From 7f58ad80533e2dac02bc242fa1efd410c673cdb2 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Wed, 19 Feb 2014 10:03:22 +0000 Subject: [PATCH 001/718] start experimental implementation of revised new_specification Based on Rob Arthan's "HOL Constant Definition Done Right". The tricky part is deciding how and where to implement the existing definitional rules that are theoretically subsumed by the new one. --- src/0/Thm.sml | 46 +++++++++++++++++++++++++--------- src/postkernel/Theory.sig | 1 + src/postkernel/Theory.sml | 13 ++++++++++ src/prekernel/FinalThm-sig.sml | 3 +-- 4 files changed, 49 insertions(+), 14 deletions(-) diff --git a/src/0/Thm.sml b/src/0/Thm.sml index 6742a9b439..a441192e48 100644 --- a/src/0/Thm.sml +++ b/src/0/Thm.sml @@ -1143,6 +1143,14 @@ fun check_free_vars tm f = ("Free variables in rhs of definition: " :: commafy (map (Lib.quote o fst o dest_var) V))); +fun check_vars tm vars f = + case Lib.set_diff (free_vars tm) vars + of [] => () + | extras => + raise f (String.concat + ("Unbound variable(s) in definition: " + :: commafy (map (Lib.quote o fst o dest_var) extras))); + fun check_tyvars body_tyvars ty f = case Lib.set_diff body_tyvars (Type.type_vars ty) of [] => () @@ -1174,6 +1182,7 @@ in mk_defn_thm(tag thm, mk_exists(rep, list_mk_comb(TYDEF,[P,rep]))) end +(* subsumed by prim_specification fun prim_constant_definition Thy M = let val (lhs, rhs) = with_exn dest_eq M DEF_FORM_ERR val {Name, Thy, Ty} = @@ -1196,25 +1205,38 @@ fun prim_constant_definition Thy M = let in mk_defn_thm(empty_tag, mk_eq(new_lhs, rhs)) end +*) fun bind thy s ty = Term.prim_new_const {Name = s, Thy = thy} ty -fun prim_specification thyname cnames th = let - val con = concl th - val checked = check_null_hyp th SPEC_ERR - val checked = check_free_vars con SPEC_ERR - val checked = +fun prim_specification thyname th = let + val hyps = hypset th + val stys = + let + fun foldthis (tm,stys) = + let + val (l,r) = + with_exn dest_eq tm (SPEC_ERR "non-equational hypothesis") + val (s,ty) = + with_exn dest_var l (SPEC_ERR "lhs of hyp not a variable") + val checked = check_free_vars r SPEC_ERR + val checked = check_tyvars (type_vars_in_term r) ty SPEC_ERR + in + (s,ty)::stys + end + in + HOLset.foldl foldthis [] hyps + end + val cnames = List.map fst stys + val checked = assert_exn (op=) (length(mk_set cnames),length cnames) (SPEC_ERR "duplicate constant names in specification") - val (V,body) = - with_exn (nstrip_exists (length cnames)) con - (SPEC_ERR "too few existentially quantified variables") - fun vOK V v = check_tyvars V (type_of v) SPEC_ERR - val checked = List.app (vOK (type_vars_in_term body)) V - fun addc v s = v |-> bind thyname s (snd(dest_var v)) + val body = concl th + val checked = check_vars body (List.map mk_var stys) SPEC_ERR + fun addc (s,ty) = (mk_var (s,ty)) |-> bind thyname s ty in - mk_defn_thm (tag th, subst (map2 addc V cnames) body) + (cnames, mk_defn_thm (tag th, subst (List.map addc stys) body)) end diff --git a/src/postkernel/Theory.sig b/src/postkernel/Theory.sig index 37f324903b..63dc08b72e 100644 --- a/src/postkernel/Theory.sig +++ b/src/postkernel/Theory.sig @@ -75,6 +75,7 @@ sig (* Extensions by definition *) structure Definition : sig val new_type_definition : string * thm -> thm + val loose_specification : string * thm -> thm val new_definition : string * term -> thm val new_specification : string * string list * thm -> thm diff --git a/src/postkernel/Theory.sml b/src/postkernel/Theory.sml index 81c6d8194e..cae2e2cada 100644 --- a/src/postkernel/Theory.sml +++ b/src/postkernel/Theory.sml @@ -1071,6 +1071,17 @@ fun new_type_definition (name,thm) = let end handle e => raise (wrap_exn "Theory.Definition" "new_type_definition" e); +fun loose_specification(name, th) = let + val thy = current_theory() + val (cnames,def) = Thm.prim_specification thy th + in + store_definition (name, def) before + List.app (fn s => call_hooks (TheoryDelta.NewConstant{Name=s, Thy=thy})) + cnames + end + handle e => raise (wrap_exn "Definition" "loose_specification" e); + +(* TODO: implement these two in terms of the above fun new_definition(name,M) = let val (dest,post) = !new_definition_hook @@ -1094,6 +1105,8 @@ fun new_specification (name, cnames, th) = let end handle e => raise (wrap_exn "Definition" "new_specification" e); +*) + end (* Definition struct *) end (* Theory *) diff --git a/src/prekernel/FinalThm-sig.sml b/src/prekernel/FinalThm-sig.sml index 898b4a9633..03f1071cfa 100644 --- a/src/prekernel/FinalThm-sig.sml +++ b/src/prekernel/FinalThm-sig.sml @@ -110,8 +110,7 @@ sig (* definitional rules of inference *) val prim_type_definition : {Thy : string, Tyop : string} * thm -> thm - val prim_constant_definition : string -> term -> thm - val prim_specification : string -> string list -> thm -> thm + val prim_specification : string -> thm -> string list * thm (* Fetching theorems from disk *) From eae01bc342a860415ad8a859f79bec370b75a99d Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Fri, 21 Feb 2014 16:51:32 +0000 Subject: [PATCH 002/718] remove Theory.new_specification and reimplement new_definition in terms of the revised Thm.prim_specification. obviously this breaks anything that depended on Theory.new_specification, so the next job is to rework those things (and write a backwards-compatible version, but later in the build sequence because it needs pairs.) --- src/0/Thm.sml | 6 +++--- src/postkernel/Theory.sig | 2 +- src/postkernel/Theory.sml | 21 +++------------------ 3 files changed, 7 insertions(+), 22 deletions(-) diff --git a/src/0/Thm.sml b/src/0/Thm.sml index a441192e48..004d964c4c 100644 --- a/src/0/Thm.sml +++ b/src/0/Thm.sml @@ -1099,11 +1099,9 @@ fun mk_defn_thm (witness_tag, c) = fun ERR f msg = HOL_ERR {origin_structure = "Thm", origin_function = f, message = msg} val TYDEF_ERR = ERR "prim_type_definition" -val DEF_ERR = ERR "new_definition" -val SPEC_ERR = ERR "new_specification" +val SPEC_ERR = ERR "prim_specification" val TYDEF_FORM_ERR = TYDEF_ERR "expected a theorem of the form \"?x. P x\"" -val DEF_FORM_ERR = DEF_ERR "expected a term of the form \"v = M\"" (* some simple term manipulation functions *) fun mk_exists (absrec as (Bvar,_)) = @@ -1183,6 +1181,8 @@ in end (* subsumed by prim_specification +val DEF_ERR = ERR "new_definition" +val DEF_FORM_ERR = DEF_ERR "expected a term of the form \"v = M\"" fun prim_constant_definition Thy M = let val (lhs, rhs) = with_exn dest_eq M DEF_FORM_ERR val {Name, Thy, Ty} = diff --git a/src/postkernel/Theory.sig b/src/postkernel/Theory.sig index 63dc08b72e..bcbebc27b0 100644 --- a/src/postkernel/Theory.sig +++ b/src/postkernel/Theory.sig @@ -76,8 +76,8 @@ sig structure Definition : sig val new_type_definition : string * thm -> thm val loose_specification : string * thm -> thm + val new_definition : string * term -> thm - val new_specification : string * string list * thm -> thm val new_definition_hook : ((term -> term list * term) * (term list * thm -> thm)) ref diff --git a/src/postkernel/Theory.sml b/src/postkernel/Theory.sml index cae2e2cada..f17f38a41b 100644 --- a/src/postkernel/Theory.sml +++ b/src/postkernel/Theory.sml @@ -1081,32 +1081,17 @@ fun loose_specification(name, th) = let end handle e => raise (wrap_exn "Definition" "loose_specification" e); -(* TODO: implement these two in terms of the above - fun new_definition(name,M) = let val (dest,post) = !new_definition_hook - val (V,eq) = dest M - val def_th = Thm.prim_constant_definition (current_theory()) eq - val {Name,Thy,...} = dest_thy_const (rand (rator (concl def_th))) + val (V,eq) = dest M + val Thy = current_theory() + val ([Name],def_th) = Thm.prim_specification Thy (Thm.ASSUME eq) in store_definition (name, post(V,def_th)) before call_hooks (TheoryDelta.NewConstant{Name=Name, Thy=Thy}) end handle e => raise (wrap_exn "Definition" "new_definition" e); -fun new_specification (name, cnames, th) = let - val thy = current_theory() - val def = Thm.prim_specification thy cnames th - val final = store_definition (name, def) - in - List.app (fn s => call_hooks (TheoryDelta.NewConstant{Name=s, Thy = thy})) - cnames - ; final - end - handle e => raise (wrap_exn "Definition" "new_specification" e); - -*) - end (* Definition struct *) end (* Theory *) From c07a105b4e916e1eae4ad6a3845fac24de77c0f0 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Fri, 21 Feb 2014 17:54:58 +0000 Subject: [PATCH 003/718] replace calls to new_specification in boolScript.sml --- src/bool/boolScript.sml | 33 +++++++++++++++------------------ src/postkernel/Theory.sml | 5 ++++- 2 files changed, 19 insertions(+), 19 deletions(-) diff --git a/src/bool/boolScript.sml b/src/bool/boolScript.sml index a26efc14a3..e592fd3910 100644 --- a/src/bool/boolScript.sml +++ b/src/bool/boolScript.sml @@ -292,8 +292,6 @@ val RES_SELECT_DEF = val _ = (add_const "RES_SELECT"; associate_restriction ("@", "RES_SELECT")); -(* Note: RES_ABSTRACT comes later, defined by new_specification *) - (*---------------------------------------------------------------------------*) (* Experimental rewriting directives *) (*---------------------------------------------------------------------------*) @@ -3948,19 +3946,19 @@ val RES_ABSTRACT_EXISTS = val B22 = GENL [p, m1, m2] B21 (* Cleaning up *) val C1 = CONJ A9 B22 - val C2 = EXISTS - (Term `?f. - (!p (m : 'a -> 'b) x. x IN p ==> (f p m x = m x)) /\ - (!p m1 m2. - (!x. x IN p ==> (m1 x = m2 x)) ==> (f p m1 = f p m2))`, - Term `\p (m : 'a -> 'b) x. (if x IN p then m x else ARB x)`) C1 + val C2 = ASSUME (Term `RES_ABSTRACT = ^witness`) + val C3 = SUBST [lhs (concl C2) |-> SYM C2] + (Term `(!p (m : 'a -> 'b) x. x IN p ==> (RES_ABSTRACT p m x = m x)) /\ + (!p m1 m2. + (!x. x IN p ==> (m1 x = m2 x)) ==> + (RES_ABSTRACT p m1 = RES_ABSTRACT p m2))`) C1 in - C2 + C3 end; val RES_ABSTRACT_DEF = - Definition.new_specification - ("RES_ABSTRACT_DEF", ["RES_ABSTRACT"], RES_ABSTRACT_EXISTS); + Definition.loose_specification + ("RES_ABSTRACT_DEF", RES_ABSTRACT_EXISTS); val _ = add_const "RES_ABSTRACT"; val _ = associate_restriction ("\\", "RES_ABSTRACT"); @@ -4435,14 +4433,13 @@ end (* define case operator *) val itself_case_thm = let val witness = ``\(i:'a itself) (b:'b). b`` - val witness_applied1 = BETA_CONV (mk_comb(witness, ``(:'a)``)) - val witness_applied2 = RIGHT_BETA (AP_THM witness_applied1 ``b:'b``) + val a = ``(:'a)`` val b = ``b:'b`` + val witness_applied1 = BETA_CONV (mk_comb(witness, a)) + val witness_applied2 = RIGHT_BETA (AP_THM witness_applied1 b) + val th1 = AP_THM (AP_THM (ASSUME ``itself_case = ^witness``) a) b + val th2 = TRANS th1 witness_applied2 in - new_specification("itself_case_thm", - ["itself_case"], - EXISTS (``?f:'a itself -> 'b -> 'b. !b. f (:'a) b = b``, - witness) - (GEN_ALL witness_applied2)) + loose_specification ("itself_case_thm", (GEN_ALL th2)) end diff --git a/src/postkernel/Theory.sml b/src/postkernel/Theory.sml index f17f38a41b..91675a8353 100644 --- a/src/postkernel/Theory.sml +++ b/src/postkernel/Theory.sml @@ -1073,6 +1073,8 @@ fun new_type_definition (name,thm) = let fun loose_specification(name, th) = let val thy = current_theory() + val _ = print("Attempting to specify "^name^" with:\n") + val _ = print((HOLPP.pp_to_string 80 (!pp_thm) th)^"\n") val (cnames,def) = Thm.prim_specification thy th in store_definition (name, def) before @@ -1085,7 +1087,8 @@ fun new_definition(name,M) = let val (dest,post) = !new_definition_hook val (V,eq) = dest M val Thy = current_theory() - val ([Name],def_th) = Thm.prim_specification Thy (Thm.ASSUME eq) + val (cnames,def_th) = Thm.prim_specification Thy (Thm.ASSUME eq) + val Name = case cnames of [Name] => Name | _ => raise Match in store_definition (name, post(V,def_th)) before call_hooks (TheoryDelta.NewConstant{Name=Name, Thy=Thy}) From abce3c6f16cdde3ecfadc5d15a81a0d50c960c11 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Tue, 25 Feb 2014 17:38:53 +0000 Subject: [PATCH 004/718] Revert "start experimental implementation of revised new_specification" This reverts commits 7f58ad8, eae01bc, and c07a105. --- src/0/Thm.sml | 52 ++++++++++------------------------ src/bool/boolScript.sml | 33 +++++++++++---------- src/postkernel/Theory.sig | 3 +- src/postkernel/Theory.sml | 29 +++++++++---------- src/prekernel/FinalThm-sig.sml | 3 +- 5 files changed, 50 insertions(+), 70 deletions(-) diff --git a/src/0/Thm.sml b/src/0/Thm.sml index 004d964c4c..6742a9b439 100644 --- a/src/0/Thm.sml +++ b/src/0/Thm.sml @@ -1099,9 +1099,11 @@ fun mk_defn_thm (witness_tag, c) = fun ERR f msg = HOL_ERR {origin_structure = "Thm", origin_function = f, message = msg} val TYDEF_ERR = ERR "prim_type_definition" -val SPEC_ERR = ERR "prim_specification" +val DEF_ERR = ERR "new_definition" +val SPEC_ERR = ERR "new_specification" val TYDEF_FORM_ERR = TYDEF_ERR "expected a theorem of the form \"?x. P x\"" +val DEF_FORM_ERR = DEF_ERR "expected a term of the form \"v = M\"" (* some simple term manipulation functions *) fun mk_exists (absrec as (Bvar,_)) = @@ -1141,14 +1143,6 @@ fun check_free_vars tm f = ("Free variables in rhs of definition: " :: commafy (map (Lib.quote o fst o dest_var) V))); -fun check_vars tm vars f = - case Lib.set_diff (free_vars tm) vars - of [] => () - | extras => - raise f (String.concat - ("Unbound variable(s) in definition: " - :: commafy (map (Lib.quote o fst o dest_var) extras))); - fun check_tyvars body_tyvars ty f = case Lib.set_diff body_tyvars (Type.type_vars ty) of [] => () @@ -1180,9 +1174,6 @@ in mk_defn_thm(tag thm, mk_exists(rep, list_mk_comb(TYDEF,[P,rep]))) end -(* subsumed by prim_specification -val DEF_ERR = ERR "new_definition" -val DEF_FORM_ERR = DEF_ERR "expected a term of the form \"v = M\"" fun prim_constant_definition Thy M = let val (lhs, rhs) = with_exn dest_eq M DEF_FORM_ERR val {Name, Thy, Ty} = @@ -1205,38 +1196,25 @@ fun prim_constant_definition Thy M = let in mk_defn_thm(empty_tag, mk_eq(new_lhs, rhs)) end -*) fun bind thy s ty = Term.prim_new_const {Name = s, Thy = thy} ty -fun prim_specification thyname th = let - val hyps = hypset th - val stys = - let - fun foldthis (tm,stys) = - let - val (l,r) = - with_exn dest_eq tm (SPEC_ERR "non-equational hypothesis") - val (s,ty) = - with_exn dest_var l (SPEC_ERR "lhs of hyp not a variable") - val checked = check_free_vars r SPEC_ERR - val checked = check_tyvars (type_vars_in_term r) ty SPEC_ERR - in - (s,ty)::stys - end - in - HOLset.foldl foldthis [] hyps - end - val cnames = List.map fst stys - val checked = +fun prim_specification thyname cnames th = let + val con = concl th + val checked = check_null_hyp th SPEC_ERR + val checked = check_free_vars con SPEC_ERR + val checked = assert_exn (op=) (length(mk_set cnames),length cnames) (SPEC_ERR "duplicate constant names in specification") - val body = concl th - val checked = check_vars body (List.map mk_var stys) SPEC_ERR - fun addc (s,ty) = (mk_var (s,ty)) |-> bind thyname s ty + val (V,body) = + with_exn (nstrip_exists (length cnames)) con + (SPEC_ERR "too few existentially quantified variables") + fun vOK V v = check_tyvars V (type_of v) SPEC_ERR + val checked = List.app (vOK (type_vars_in_term body)) V + fun addc v s = v |-> bind thyname s (snd(dest_var v)) in - (cnames, mk_defn_thm (tag th, subst (List.map addc stys) body)) + mk_defn_thm (tag th, subst (map2 addc V cnames) body) end diff --git a/src/bool/boolScript.sml b/src/bool/boolScript.sml index e592fd3910..a26efc14a3 100644 --- a/src/bool/boolScript.sml +++ b/src/bool/boolScript.sml @@ -292,6 +292,8 @@ val RES_SELECT_DEF = val _ = (add_const "RES_SELECT"; associate_restriction ("@", "RES_SELECT")); +(* Note: RES_ABSTRACT comes later, defined by new_specification *) + (*---------------------------------------------------------------------------*) (* Experimental rewriting directives *) (*---------------------------------------------------------------------------*) @@ -3946,19 +3948,19 @@ val RES_ABSTRACT_EXISTS = val B22 = GENL [p, m1, m2] B21 (* Cleaning up *) val C1 = CONJ A9 B22 - val C2 = ASSUME (Term `RES_ABSTRACT = ^witness`) - val C3 = SUBST [lhs (concl C2) |-> SYM C2] - (Term `(!p (m : 'a -> 'b) x. x IN p ==> (RES_ABSTRACT p m x = m x)) /\ - (!p m1 m2. - (!x. x IN p ==> (m1 x = m2 x)) ==> - (RES_ABSTRACT p m1 = RES_ABSTRACT p m2))`) C1 + val C2 = EXISTS + (Term `?f. + (!p (m : 'a -> 'b) x. x IN p ==> (f p m x = m x)) /\ + (!p m1 m2. + (!x. x IN p ==> (m1 x = m2 x)) ==> (f p m1 = f p m2))`, + Term `\p (m : 'a -> 'b) x. (if x IN p then m x else ARB x)`) C1 in - C3 + C2 end; val RES_ABSTRACT_DEF = - Definition.loose_specification - ("RES_ABSTRACT_DEF", RES_ABSTRACT_EXISTS); + Definition.new_specification + ("RES_ABSTRACT_DEF", ["RES_ABSTRACT"], RES_ABSTRACT_EXISTS); val _ = add_const "RES_ABSTRACT"; val _ = associate_restriction ("\\", "RES_ABSTRACT"); @@ -4433,13 +4435,14 @@ end (* define case operator *) val itself_case_thm = let val witness = ``\(i:'a itself) (b:'b). b`` - val a = ``(:'a)`` val b = ``b:'b`` - val witness_applied1 = BETA_CONV (mk_comb(witness, a)) - val witness_applied2 = RIGHT_BETA (AP_THM witness_applied1 b) - val th1 = AP_THM (AP_THM (ASSUME ``itself_case = ^witness``) a) b - val th2 = TRANS th1 witness_applied2 + val witness_applied1 = BETA_CONV (mk_comb(witness, ``(:'a)``)) + val witness_applied2 = RIGHT_BETA (AP_THM witness_applied1 ``b:'b``) in - loose_specification ("itself_case_thm", (GEN_ALL th2)) + new_specification("itself_case_thm", + ["itself_case"], + EXISTS (``?f:'a itself -> 'b -> 'b. !b. f (:'a) b = b``, + witness) + (GEN_ALL witness_applied2)) end diff --git a/src/postkernel/Theory.sig b/src/postkernel/Theory.sig index bcbebc27b0..37f324903b 100644 --- a/src/postkernel/Theory.sig +++ b/src/postkernel/Theory.sig @@ -75,9 +75,8 @@ sig (* Extensions by definition *) structure Definition : sig val new_type_definition : string * thm -> thm - val loose_specification : string * thm -> thm - val new_definition : string * term -> thm + val new_specification : string * string list * thm -> thm val new_definition_hook : ((term -> term list * term) * (term list * thm -> thm)) ref diff --git a/src/postkernel/Theory.sml b/src/postkernel/Theory.sml index 91675a8353..81c6d8194e 100644 --- a/src/postkernel/Theory.sml +++ b/src/postkernel/Theory.sml @@ -1071,30 +1071,29 @@ fun new_type_definition (name,thm) = let end handle e => raise (wrap_exn "Theory.Definition" "new_type_definition" e); -fun loose_specification(name, th) = let - val thy = current_theory() - val _ = print("Attempting to specify "^name^" with:\n") - val _ = print((HOLPP.pp_to_string 80 (!pp_thm) th)^"\n") - val (cnames,def) = Thm.prim_specification thy th - in - store_definition (name, def) before - List.app (fn s => call_hooks (TheoryDelta.NewConstant{Name=s, Thy=thy})) - cnames - end - handle e => raise (wrap_exn "Definition" "loose_specification" e); fun new_definition(name,M) = let val (dest,post) = !new_definition_hook - val (V,eq) = dest M - val Thy = current_theory() - val (cnames,def_th) = Thm.prim_specification Thy (Thm.ASSUME eq) - val Name = case cnames of [Name] => Name | _ => raise Match + val (V,eq) = dest M + val def_th = Thm.prim_constant_definition (current_theory()) eq + val {Name,Thy,...} = dest_thy_const (rand (rator (concl def_th))) in store_definition (name, post(V,def_th)) before call_hooks (TheoryDelta.NewConstant{Name=Name, Thy=Thy}) end handle e => raise (wrap_exn "Definition" "new_definition" e); +fun new_specification (name, cnames, th) = let + val thy = current_theory() + val def = Thm.prim_specification thy cnames th + val final = store_definition (name, def) + in + List.app (fn s => call_hooks (TheoryDelta.NewConstant{Name=s, Thy = thy})) + cnames + ; final + end + handle e => raise (wrap_exn "Definition" "new_specification" e); + end (* Definition struct *) end (* Theory *) diff --git a/src/prekernel/FinalThm-sig.sml b/src/prekernel/FinalThm-sig.sml index 03f1071cfa..898b4a9633 100644 --- a/src/prekernel/FinalThm-sig.sml +++ b/src/prekernel/FinalThm-sig.sml @@ -110,7 +110,8 @@ sig (* definitional rules of inference *) val prim_type_definition : {Thy : string, Tyop : string} * thm -> thm - val prim_specification : string -> thm -> string list * thm + val prim_constant_definition : string -> term -> thm + val prim_specification : string -> string list -> thm -> thm (* Fetching theorems from disk *) From 209347444b414aa3b569d5a97689f5415c87d2fc Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Tue, 25 Feb 2014 20:59:36 +0000 Subject: [PATCH 005/718] Add gen_new_specification and remove prim_constant_definition Implement new_definition in terms of gen_prim_specification. Leave the existing new_specification in place. This plan of attack suggested by RDA. Have only touched the standard kernel, and none of the theories. Next steps would include updating the other kernels, implementing new_specification in terms of gen_new_specification (at some point after pairTheory), and removing uses of new_specification before pairTheory one by one if possible/desired... --- src/0/Thm.sml | 39 ++++++++++++++++++++++++++++++++++ src/postkernel/Theory.sig | 1 + src/postkernel/Theory.sml | 16 +++++++++++--- src/prekernel/FinalThm-sig.sml | 2 +- 4 files changed, 54 insertions(+), 4 deletions(-) diff --git a/src/0/Thm.sml b/src/0/Thm.sml index 6742a9b439..110641f022 100644 --- a/src/0/Thm.sml +++ b/src/0/Thm.sml @@ -1143,6 +1143,14 @@ fun check_free_vars tm f = ("Free variables in rhs of definition: " :: commafy (map (Lib.quote o fst o dest_var) V))); +fun check_vars tm vars f = + case Lib.set_diff (free_vars tm) vars + of [] => () + | extras => + raise f (String.concat + ("Unbound variable(s) in definition: " + :: commafy (map (Lib.quote o fst o dest_var) extras))); + fun check_tyvars body_tyvars ty f = case Lib.set_diff body_tyvars (Type.type_vars ty) of [] => () @@ -1174,6 +1182,7 @@ in mk_defn_thm(tag thm, mk_exists(rep, list_mk_comb(TYDEF,[P,rep]))) end +(* subsumed by gen_prim_specification fun prim_constant_definition Thy M = let val (lhs, rhs) = with_exn dest_eq M DEF_FORM_ERR val {Name, Thy, Ty} = @@ -1196,6 +1205,7 @@ fun prim_constant_definition Thy M = let in mk_defn_thm(empty_tag, mk_eq(new_lhs, rhs)) end +*) fun bind thy s ty = Term.prim_new_const {Name = s, Thy = thy} ty @@ -1217,6 +1227,35 @@ in mk_defn_thm (tag th, subst (map2 addc V cnames) body) end +fun gen_prim_specification thyname th = let + val hyps = hypset th + val stys = + let + fun foldthis (tm,stys) = + let + val (l,r) = + with_exn dest_eq tm (SPEC_ERR "non-equational hypothesis") + val (s,ty) = + with_exn dest_var l (SPEC_ERR "lhs of hyp not a variable") + val checked = check_free_vars r SPEC_ERR + val checked = check_tyvars (type_vars_in_term r) ty SPEC_ERR + in + (s,ty)::stys + end + in + HOLset.foldl foldthis [] hyps + end + val cnames = List.map fst stys + val checked = + assert_exn (op=) (length(mk_set cnames),length cnames) + (SPEC_ERR "duplicate constant names in specification") + val body = concl th + val checked = check_vars body (List.map mk_var stys) SPEC_ERR + fun addc (s,ty) = (mk_var (s,ty)) |-> bind thyname s ty +in + (cnames, mk_defn_thm (tag th, subst (List.map addc stys) body)) +end + diff --git a/src/postkernel/Theory.sig b/src/postkernel/Theory.sig index 37f324903b..ef10629b60 100644 --- a/src/postkernel/Theory.sig +++ b/src/postkernel/Theory.sig @@ -77,6 +77,7 @@ sig val new_type_definition : string * thm -> thm val new_definition : string * term -> thm val new_specification : string * string list * thm -> thm + val gen_new_specification : string * thm -> thm val new_definition_hook : ((term -> term list * term) * (term list * thm -> thm)) ref diff --git a/src/postkernel/Theory.sml b/src/postkernel/Theory.sml index 81c6d8194e..b591eb8fd4 100644 --- a/src/postkernel/Theory.sml +++ b/src/postkernel/Theory.sml @@ -1071,12 +1071,22 @@ fun new_type_definition (name,thm) = let end handle e => raise (wrap_exn "Theory.Definition" "new_type_definition" e); +fun gen_new_specification(name, th) = let + val thy = current_theory() + val (cnames,def) = Thm.gen_prim_specification thy th + in + store_definition (name, def) before + List.app (fn s => call_hooks (TheoryDelta.NewConstant{Name=s, Thy=thy})) + cnames + end + handle e => raise (wrap_exn "Definition" "gen_new_specification" e); fun new_definition(name,M) = let val (dest,post) = !new_definition_hook - val (V,eq) = dest M - val def_th = Thm.prim_constant_definition (current_theory()) eq - val {Name,Thy,...} = dest_thy_const (rand (rator (concl def_th))) + val (V,eq) = dest M + val Thy = current_theory() + val (cnames,def_th) = Thm.gen_prim_specification Thy (Thm.ASSUME eq) + val Name = case cnames of [Name] => Name | _ => raise Match in store_definition (name, post(V,def_th)) before call_hooks (TheoryDelta.NewConstant{Name=Name, Thy=Thy}) diff --git a/src/prekernel/FinalThm-sig.sml b/src/prekernel/FinalThm-sig.sml index 898b4a9633..95c99a5575 100644 --- a/src/prekernel/FinalThm-sig.sml +++ b/src/prekernel/FinalThm-sig.sml @@ -110,8 +110,8 @@ sig (* definitional rules of inference *) val prim_type_definition : {Thy : string, Tyop : string} * thm -> thm - val prim_constant_definition : string -> term -> thm val prim_specification : string -> string list -> thm -> thm + val gen_prim_specification : string -> thm -> string list * thm (* Fetching theorems from disk *) From 9fbd0c16c529c8b1c14db3d354233bd69c55d594 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Tue, 25 Feb 2014 21:36:04 +0000 Subject: [PATCH 006/718] add gen_prim_specification to experimental-kernel --- src/experimental-kernel/Thm.sml | 38 +++++++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+) diff --git a/src/experimental-kernel/Thm.sml b/src/experimental-kernel/Thm.sml index 3b98368d91..d18777fded 100644 --- a/src/experimental-kernel/Thm.sml +++ b/src/experimental-kernel/Thm.sml @@ -1132,6 +1132,14 @@ fun check_free_vars tm f = ("Free variables in rhs of definition: " :: commafy (map (Lib.quote o fst o dest_var) V))); +fun check_vars tm vars f = + case Lib.set_diff (free_vars tm) vars + of [] => () + | extras => + raise f (String.concat + ("Unbound variable(s) in definition: " + :: commafy (map (Lib.quote o fst o dest_var) extras))); + fun check_tyvars body_tyvars ty f = case Lib.set_diff body_tyvars (Type.type_vars ty) of [] => () @@ -1164,6 +1172,7 @@ in mk_defn_thm(tag thm, mk_exists(rep, list_mk_comb(TYDEF,[P,rep]))) end +(* subsumed by gen_prim_specification fun prim_constant_definition Thy M = let val (lhs, rhs) = with_exn dest_eq M DEF_FORM_ERR val {Name, Thy, Ty} = @@ -1186,6 +1195,7 @@ fun prim_constant_definition Thy M = let in mk_defn_thm(empty_tag, mk_eq(new_lhs, rhs)) end +*) fun bind thy s ty = Term.prim_new_const {Name = s, Thy = thy} ty @@ -1207,6 +1217,34 @@ in mk_defn_thm (tag th, subst (map2 addc V cnames) body) end +fun gen_prim_specification thyname th = let + val hyps = hypset th + val stys = + let + fun foldthis (tm,stys) = + let + val (l,r) = + with_exn dest_eq tm (SPEC_ERR "non-equational hypothesis") + val (s,ty) = + with_exn dest_var l (SPEC_ERR "lhs of hyp not a variable") + val checked = check_free_vars r SPEC_ERR + val checked = check_tyvars (type_vars_in_term r) ty SPEC_ERR + in + (s,ty)::stys + end + in + HOLset.foldl foldthis [] hyps + end + val cnames = List.map fst stys + val checked = + assert_exn (op=) (length(mk_set cnames),length cnames) + (SPEC_ERR "duplicate constant names in specification") + val body = concl th + val checked = check_vars body (List.map mk_var stys) SPEC_ERR + fun addc (s,ty) = (mk_var (s,ty)) |-> bind thyname s ty +in + (cnames, mk_defn_thm (tag th, subst (List.map addc stys) body)) +end local val mk_disk_thm = make_thm Count.Disk From f6e9197f5f4ae7a62060bbd03de1173b79fb0d5e Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Thu, 27 Feb 2014 17:58:15 +0000 Subject: [PATCH 007/718] implement new_specification in terms of gen_new_specification in pairLib - should re-export elsewhere. --- src/pair/src/pairLib.sig | 2 ++ src/pair/src/pairLib.sml | 62 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 64 insertions(+) diff --git a/src/pair/src/pairLib.sig b/src/pair/src/pairLib.sig index 520cd13f73..06b6a95eb4 100644 --- a/src/pair/src/pairLib.sig +++ b/src/pair/src/pairLib.sig @@ -117,4 +117,6 @@ sig val TUPLE_TAC : term -> tactic val LET_INTRO_TAC : tactic + + val new_specification : string * string list * thm -> thm end diff --git a/src/pair/src/pairLib.sml b/src/pair/src/pairLib.sml index a04400595a..6cff9d31d0 100644 --- a/src/pair/src/pairLib.sml +++ b/src/pair/src/pairLib.sml @@ -11,4 +11,66 @@ open boolLib pairSyntax PairedLambda pairTools simpLib; val _ = Rewrite.add_implicit_rewrites pairTheory.pair_rws; +(* Implementation of new_specification as a rule derived from + gen_new_specification. This occurs here because the derivation + depends on pairs. *) + +local + open Term Thm + + (* given a varstruct (possibly nested pairs of variables) vs, return a list + of equations equating each variable to the corresponding projection of tm + e.g. varstruct_to_eqs tm ((p,q),r) = + [r = SND tm, + q = SND (FST tm), + p = FST (FST tm)] *) + fun varstruct_to_eqs tm = + let + fun f tm ac vs = + if is_var vs + then (mk_eq(vs, tm))::ac + else + let + val (a,d) = dest_pair vs + val ac = f (mk_fst tm) ac a + val ac = f (mk_snd tm) ac d + in ac end + in + f tm [] + end + + open Lib PairRules + + in + + fun new_specification (name,cnames,th) = let + val th1 = + (* this is not good enough since it doesn't guarantee the cnames will be used + - primed variants could be used if they clash with existing constant names + CONV_RULE (RENAME_VARS_CONV cnames) th *) + let + val tm1 = concl th + val (vs1,body1) = strip_exists tm1 + val tys = map type_of vs1 + val vs2 = map2 (curry mk_var) cnames tys + val body2 = Term.subst (map2 (curry op |->) vs1 vs2) body1 + val tm2 = list_mk_exists(vs2,body2) + val th2 = ALPHA tm1 tm2 + in EQ_MP th2 th end + (* turn it into a single paired existential *) + val th2 = CONV_RULE (REPEATC UNCURRY_EXISTS_CONV) th1 + val (vs,body) = strip_pexists (concl th2) + val vs = case vs of [vs] => vs | _ => raise Match + val witness = mk_pselect (vs,body) + val eqs = varstruct_to_eqs witness vs + val th3 = CONV_RULE PEXISTS_CONV th2 + val th4 = PURE_REWRITE_RULE (List.map (SYM o ASSUME) eqs) th3 + (* ensure that even totally unconstrained constants get defined *) + val th5 = List.foldl (Lib.uncurry ADD_ASSUM) th4 eqs + in + Theory.Definition.gen_new_specification (name,th5) + end + +end + end From 6aba5baa4c810646e6df06bbbaa2fcbf0276fa02 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Mon, 3 Mar 2014 15:27:38 +0000 Subject: [PATCH 008/718] export derived new_specification from bossLib --- src/boss/bossLib.sig | 4 ++++ src/boss/bossLib.sml | 2 ++ 2 files changed, 6 insertions(+) diff --git a/src/boss/bossLib.sig b/src/boss/bossLib.sig index 35dbfc23ab..465c746138 100644 --- a/src/boss/bossLib.sig +++ b/src/boss/bossLib.sig @@ -22,6 +22,10 @@ sig val xHol_reln : string -> term quotation -> thm * thm * thm val export_mono : string -> unit + (* Derived rule for specifying new constants. + (Should have the same effect as Thm.new_specification.) *) + val new_specification : string * string list * thm -> thm + (* Case-splitting and induction operations *) val Cases : tactic diff --git a/src/boss/bossLib.sml b/src/boss/bossLib.sml index 1efea40450..b7dd4760fd 100644 --- a/src/boss/bossLib.sml +++ b/src/boss/bossLib.sml @@ -29,6 +29,8 @@ in end; val ERR = mk_HOL_ERR "bossLib"; +val new_specification = pairLib.new_specification; + (*---------------------------------------------------------------------------* Datatype definition *---------------------------------------------------------------------------*) From 059e250f621b90e5a05f9f3f3c3305bc7722da0b Mon Sep 17 00:00:00 2001 From: Piotr Trojanek Date: Thu, 16 Oct 2014 00:44:31 +0100 Subject: [PATCH 009/718] rename Ho_Net.empty_net to Ho_Net.empty All similar structures (e.g. Net and Raw) use "empty" not "empty_net"; it seems right to follow a single naming convention. --- src/1/Ho_Net.sig | 2 +- src/1/Ho_Net.sml | 10 +++++----- src/1/Ho_Rewrite.sml | 4 ++-- src/quantHeuristics/quantHeuristicsLibBase.sml | 2 +- src/simp/src/congLib.sml | 2 +- src/simp/src/simpLib.sml | 2 +- 6 files changed, 11 insertions(+), 11 deletions(-) diff --git a/src/1/Ho_Net.sig b/src/1/Ho_Net.sig index 603288d87a..78e62ce40a 100644 --- a/src/1/Ho_Net.sig +++ b/src/1/Ho_Net.sig @@ -11,7 +11,7 @@ sig type 'a net type term = Term.term - val empty_net : 'a net + val empty : 'a net val enter : term list * term * 'a -> 'a net -> 'a net val lookup : term -> 'a net -> 'a list val merge_nets : 'a net * 'a net -> 'a net diff --git a/src/1/Ho_Net.sml b/src/1/Ho_Net.sml index 8b4873e08e..2324833324 100644 --- a/src/1/Ho_Net.sml +++ b/src/1/Ho_Net.sml @@ -83,15 +83,15 @@ fun label_for_lookup tm = end; (* double constructor design may seem redundant but it allows us to avoid - a value polymorphism problem, and have a simple value for empty_net. + a value polymorphism problem, and have a simple value for empty. If you try - val empty_net = NODE(mkDict label_cmp, []) - then empty_net can't be fully polymorphic, thanks to the call to + val empty = NODE(mkDict label_cmp, []) + then empty can't be fully polymorphic, thanks to the call to mkDict. *) datatype 'a net = NODE of (term_label,'a net) dict * 'a list | EMPTY of 'a list -val empty_net = EMPTY [] +val empty = EMPTY [] @@ -114,7 +114,7 @@ fun net_update (elem, tms:(term list * term) list, net) = | tm::rtms => let val (label,ntms) = stored_label tm val child = case check_edge(net, label) of - NONE => empty_net + NONE => empty | SOME n => n val new_child = net_update(elem,ntms @ rtms,child) in diff --git a/src/1/Ho_Rewrite.sml b/src/1/Ho_Rewrite.sml index 8a73de7ac2..3523651bf4 100644 --- a/src/1/Ho_Rewrite.sml +++ b/src/1/Ho_Rewrite.sml @@ -59,7 +59,7 @@ datatype rewrites = RW of {thms :thm list, net :conv Ho_Net.net} fun dest_rewrites(RW{thms, ...}) = thms -val empty_rewrites = RW{thms = [], net = Ho_Net.empty_net} +val empty_rewrites = RW{thms = [], net = Ho_Net.empty} val implicit = ref empty_rewrites; @@ -219,7 +219,7 @@ val HIGHER_REWRITE_CONV = val beta_fns = map2 BETA_VAR preds concs val ass_list = zip pats (zip preds (zip thl beta_fns)) fun insert p = Ho_Net.enter ([],p,p) - val mnet = itlist insert pats Ho_Net.empty_net + val mnet = itlist insert pats Ho_Net.empty fun look_fn t = mapfilter (fn p => if can (ho_match_term [] empty_tmset p) t then p else fail()) diff --git a/src/quantHeuristics/quantHeuristicsLibBase.sml b/src/quantHeuristics/quantHeuristicsLibBase.sml index 0712577a9b..c861e7acc0 100644 --- a/src/quantHeuristics/quantHeuristicsLibBase.sml +++ b/src/quantHeuristics/quantHeuristicsLibBase.sml @@ -1325,7 +1325,7 @@ let group_thmL ((P_t', thm::thmL)::L') thmPL end val guess_net_complex = - foldr (fn ((P_t, thmL), n) => Ho_Net.enter ([],P_t, (P_t, thmL)) n) Ho_Net.empty_net + foldr (fn ((P_t, thmL), n) => Ho_Net.enter ([],P_t, (P_t, thmL)) n) Ho_Net.empty (group_thmL [] cL) diff --git a/src/simp/src/congLib.sml b/src/simp/src/congLib.sml index 57cc8f62fc..4165151181 100644 --- a/src/simp/src/congLib.sml +++ b/src/simp/src/congLib.sml @@ -161,7 +161,7 @@ val cong_reducer = end in REDUCER {name=SOME"cong_reducer", addcontext=addcontext, apply=apply, - initial=CONVNET (Ho_Net.empty_net)} + initial=CONVNET (Ho_Net.empty)} end; diff --git a/src/simp/src/simpLib.sml b/src/simp/src/simpLib.sml index 0562081b67..9afd267ec1 100644 --- a/src/simp/src/simpLib.sml +++ b/src/simp/src/simpLib.sml @@ -185,7 +185,7 @@ datatype simpset = val empty_ss = SS {mk_rewrs=fn x => [x], ssfrags = [], limit = NONE, - initial_net=empty_net, + initial_net=empty, dprocs=[],travrules=EQ_tr}; fun ssfrags_of (SS x) = #ssfrags x; From aab658eacdc426745fd030919bf25aa3afceee2c Mon Sep 17 00:00:00 2001 From: Piotr Trojanek Date: Fri, 17 Oct 2014 22:24:29 +0100 Subject: [PATCH 010/718] use "fn" rather than "\" in SML code samples --- help/Docfiles/Tactical.POP_ASSUM.doc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/help/Docfiles/Tactical.POP_ASSUM.doc b/help/Docfiles/Tactical.POP_ASSUM.doc index ae9a5deed4..bf208d3c4b 100644 --- a/help/Docfiles/Tactical.POP_ASSUM.doc +++ b/help/Docfiles/Tactical.POP_ASSUM.doc @@ -38,7 +38,7 @@ Another point to consider is that if the relevant assumption has been obtained by {DISCH_TAC}, it is often cleaner to use {DISCH_THEN} with a theorem-tactic. For example, instead of: { - DISCH_TAC THEN POP_ASSUM (\th. SUBST1_TAC (SYM th)) + DISCH_TAC THEN POP_ASSUM (fn th => SUBST1_TAC (SYM th)) } one might use { @@ -54,7 +54,7 @@ The goal: can be solved by: { POP_ASSUM - (fn th => REWRITE_TAC[REWRITE_RULE[num_CONV (Term`4`, INV_SUC_EQ] th]]) + (fn th => REWRITE_TAC[REWRITE_RULE[num_CONV (Term`4`), INV_SUC_EQ] th]) } From 0278ba3a94144ea4adcce5f5a79eb01cba886a0f Mon Sep 17 00:00:00 2001 From: Piotr Trojanek Date: Mon, 20 Oct 2014 13:16:33 +0100 Subject: [PATCH 011/718] pair: with T1 encoding one can search for names with underscodes in PDF --- src/pair/Manual/description.tex | 2 +- src/pair/Manual/pair.tex | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/src/pair/Manual/description.tex b/src/pair/Manual/description.tex index 11a780cf99..25f77cb8ad 100644 --- a/src/pair/Manual/description.tex +++ b/src/pair/Manual/description.tex @@ -232,7 +232,7 @@ \section{The pair Library Philosophy} \section{Bugs and Future Changes} -At the time of release there were no known bugs in the system. +At the time of release there were no known bugs in the library. However, this is more likely to be a result of poor testing than of good coding. If you do find a bug please report it to me, preferably along with a short example that exhibits the bug and the version number of the diff --git a/src/pair/Manual/pair.tex b/src/pair/Manual/pair.tex index c976271c90..9881519a2a 100644 --- a/src/pair/Manual/pair.tex +++ b/src/pair/Manual/pair.tex @@ -7,6 +7,7 @@ \usepackage{fleqn} \usepackage{alltt} \usepackage{../../..//Manual/LaTeX/layout} +\usepackage[T1]{fontenc} % --------------------------------------------------------------------- % Input defined macros and commands From dabaaf6812c7459d7c5d01c4c5dd6a71507e3305 Mon Sep 17 00:00:00 2001 From: Piotr Trojanek Date: Mon, 20 Oct 2014 13:17:18 +0100 Subject: [PATCH 012/718] pair: export pvariant function, as it is already listed in manual --- src/pair/Manual/description.tex | 2 +- src/pair/src/PairRules.sig | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/src/pair/Manual/description.tex b/src/pair/Manual/description.tex index 25f77cb8ad..ffd7f80289 100644 --- a/src/pair/Manual/description.tex +++ b/src/pair/Manual/description.tex @@ -56,7 +56,7 @@ \chapter{The pair Library} BETA\_CONV & PBETA\_CONV \\ BETA\_RULE & PBETA\_RULE \\ BETA\_TAC & PBETA\_TAC \\ - bndvar & bndpair \\ + bvar & pbvar \\ body & pbody \\ CHOOSE & PCHOOSE \\ CHOOSE\_TAC & PCHOOSE\_TAC \\ diff --git a/src/pair/src/PairRules.sig b/src/pair/src/PairRules.sig index 3f6afcafb8..5fd9b56188 100644 --- a/src/pair/src/PairRules.sig +++ b/src/pair/src/PairRules.sig @@ -114,4 +114,6 @@ sig val PMATCH_MP_TAC : thm_tactic val PMATCH_MP : thm -> thm -> thm + val pvariant : term list -> term -> term + end From 15a21307bac00aa280a5a029a0bcc52f83b367b1 Mon Sep 17 00:00:00 2001 From: Piotr Trojanek Date: Wed, 22 Oct 2014 23:31:42 +0100 Subject: [PATCH 013/718] guide: grammar fix --- Manual/Guide/guide.tex | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Manual/Guide/guide.tex b/Manual/Guide/guide.tex index f628c054f2..1bae719408 100644 --- a/Manual/Guide/guide.tex +++ b/Manual/Guide/guide.tex @@ -427,7 +427,7 @@ \section{Generation of the LaTeX source} Each \id\doc\ file is in a special format (described below), from which the \latex\ source for a manual entry on the \ML\ identifier \id\ can be generated. -The file {\tt bin/doc-to-tex.sed} is the {\tt sed} script used generate \latex\ +The file {\tt bin/doc-to-tex.sed} is the {\tt sed} script used to generate \latex\ source text from \doc\ files. Executing: \begin{itemize} From 08d7a55835eacf88f47be119cf094646b981a0e0 Mon Sep 17 00:00:00 2001 From: Piotr Trojanek Date: Thu, 23 Oct 2014 10:46:09 +0100 Subject: [PATCH 014/718] trailing newlines in *.{sml,sig} files from src/ removed Trailing newlines from SML files in src/ were rendered in HTML documentation. --- src/0/Subst.sig | 3 --- src/0/Type.sig | 3 --- src/1/BoolExtractShared.sig | 1 - src/1/ConseqConv.sig | 1 - src/1/dep_rewrite.sig | 1 - src/1/dep_rewrite.sml | 1 - src/HolSat/HolSatLib.sml | 2 -- src/HolSat/def_cnf.sml | 1 - src/HolSat/minisatProve.sml | 2 -- src/HolSat/minisatResolve.sml | 2 -- src/HolSat/satTools.sml | 1 - src/TeX/mkmkmunge.sml | 4 ---- src/combin/combinScript.sml | 1 - src/compute/examples/MergeSort.sml | 2 -- src/compute/examples/Sort.sml | 1 - src/datatype/DatatypeSimps.sig | 1 - src/datatype/mutrec/ConsThms.sml | 1 - src/datatype/mutrec/MutRecDef.sml | 1 - src/datatype/record/RecordType.sig | 2 -- src/enumfset/tcScript.sml | 1 - src/finite_map/fmaptreeScript.sml | 2 -- src/integer/OmegaMath.sig | 1 - src/integer/OmegaScript.sml | 1 - src/integer/testing/selftest.sml | 1 - src/integer/testing/test_coopers.sml | 1 - src/integer/testing/test_omega.sml | 2 -- src/marker/markerScript.sml | 1 - src/meson/src/Canon_Port.sig | 1 - src/meson/test.sml | 2 -- src/metis/mlibOmega.sig | 1 - src/metis/mlibSubst.sig | 1 - src/monad/parmonadsyntax2.sml | 2 -- src/num/arith/src/GenPolyCanon.sig | 2 -- src/num/extra_theories/numpairScript.sml | 1 - src/num/theories/DecimalFractionPP.sml | 1 - src/num/theories/basicSizeScript.sml | 1 - src/option/optionSimps.sig | 1 - src/parse/CharSet.sml | 1 - src/parse/ProvideUnicode.sig | 1 - src/parse/base_tokens.sig | 1 - src/parse/errormonad.sml | 3 --- src/parse/parse_term.sig | 1 - src/parse/qbuf.sml | 4 ---- src/parse/term_pp.sig | 1 - src/parse/term_pp_utils.sig | 2 -- src/parse/term_tokens.sig | 1 - src/path/pathScript.sml | 1 - src/pfl/index.sml | 1 - src/portableML/Arbnum.sml | 1 - src/portableML/poly/Susp.sml | 1 - src/pred_set/src/gcdsetScript.sml | 1 - src/prekernel/KernelSig.sml | 1 - src/prekernel/Nonce.sig | 2 -- src/quantHeuristics/selftest.sml | 1 - src/quotient/examples/lambda/barendregt.sig | 1 - src/quotient/examples/lambda/more_listScript.sml | 1 - src/quotient/examples/lambda/more_setScript.sml | 1 - src/quotient/examples/sigma/barendregt.sig | 1 - src/quotient/examples/sigma/more_listScript.sml | 1 - src/quotient/examples/sigma/more_setScript.sml | 1 - src/quotient/src/quotientLib.sml | 1 - src/quotient/src/quotientScript.sml | 1 - src/quotient/src/quotient_listScript.sml | 1 - src/quotient/src/quotient_optionScript.sml | 1 - src/quotient/src/quotient_pairScript.sml | 1 - src/quotient/src/quotient_pred_setScript.sml | 1 - src/quotient/src/quotient_sumScript.sml | 1 - src/rational/fracScript.sml | 1 - src/rational/intExtensionScript.sml | 1 - src/real/polyScript.sml | 1 - src/refute/AC.sig | 1 - src/refute/Canon.sig | 1 - src/ring/src/numRingScript.sml | 1 - src/simp/src/Opening.sig | 2 -- src/simp/src/Opening.sml | 1 - src/simp/src/Satisfy.sig | 1 - src/simp/src/Sequence.sig | 2 -- src/simp/src/Sequence.sml | 1 - src/simp/src/Travrules.sig | 3 --- src/simp/src/Unify.sig | 1 - src/simp/src/boolSimps.sig | 1 - src/simp/src/congLib.sig | 1 - src/simp/test.sml | 8 -------- src/string/selftest.sml | 4 ---- src/string/stringSimps.sml | 1 - src/string/stringSyntax.sig | 1 - src/string/theorytesting/otherScript.sml | 1 - src/string/theorytesting/sampleScript.sml | 1 - src/temporal/src/Temporal_LogicScript.sml | 2 -- 89 files changed, 128 deletions(-) diff --git a/src/0/Subst.sig b/src/0/Subst.sig index cc96d7585b..0a866e69e4 100644 --- a/src/0/Subst.sig +++ b/src/0/Subst.sig @@ -11,6 +11,3 @@ sig val comp : ('a subs * 'a -> 'a) -> 'a subs * 'a subs -> 'a subs; end; - - - diff --git a/src/0/Type.sig b/src/0/Type.sig index 3051a6ad20..f873c5ad39 100644 --- a/src/0/Type.sig +++ b/src/0/Type.sig @@ -4,6 +4,3 @@ sig include FinalType where type hol_type = KernelTypes.hol_type end; - - - diff --git a/src/1/BoolExtractShared.sig b/src/1/BoolExtractShared.sig index de48f8fbb1..5f9ded788c 100644 --- a/src/1/BoolExtractShared.sig +++ b/src/1/BoolExtractShared.sig @@ -19,4 +19,3 @@ val BOOL_NEG_PAIR_convdata : simpfrag.convdata; end - diff --git a/src/1/ConseqConv.sig b/src/1/ConseqConv.sig index 5322f97221..60f417c35a 100644 --- a/src/1/ConseqConv.sig +++ b/src/1/ConseqConv.sig @@ -243,4 +243,3 @@ val EXT_CONTEXT_CONSEQ_HO_REWRITE_TAC : CONSEQ_CONV_context -> (thm list -> co end - diff --git a/src/1/dep_rewrite.sig b/src/1/dep_rewrite.sig index 16a3c58e16..49bae15a4a 100644 --- a/src/1/dep_rewrite.sig +++ b/src/1/dep_rewrite.sig @@ -244,4 +244,3 @@ end; (* END OF DEPENDENT REWRITING TACTICS *) (* ================================================================== *) (* ================================================================== *) - diff --git a/src/1/dep_rewrite.sml b/src/1/dep_rewrite.sml index c262725d02..b64b686278 100644 --- a/src/1/dep_rewrite.sml +++ b/src/1/dep_rewrite.sml @@ -813,4 +813,3 @@ e(DEP_ONCE_REWRITE_TAC[RIGHT_FORALL_IMP_THM]); drop(); *) - diff --git a/src/HolSat/HolSatLib.sml b/src/HolSat/HolSatLib.sml index 43a23c813d..3f20aa8fbb 100644 --- a/src/HolSat/HolSatLib.sml +++ b/src/HolSat/HolSatLib.sml @@ -12,5 +12,3 @@ exception SAT_cex = minisatProve.SAT_cex open satTools dimacsTools SatSolvers minisatProve satConfig end; - - diff --git a/src/HolSat/def_cnf.sml b/src/HolSat/def_cnf.sml index 537aaf6649..4abbb297d3 100644 --- a/src/HolSat/def_cnf.sml +++ b/src/HolSat/def_cnf.sml @@ -241,4 +241,3 @@ List.app (fn eq => end end - diff --git a/src/HolSat/minisatProve.sml b/src/HolSat/minisatProve.sml index fd1230492d..14e9f67d76 100644 --- a/src/HolSat/minisatProve.sml +++ b/src/HolSat/minisatProve.sml @@ -138,5 +138,3 @@ fun ZSAT_ORACLE tm = GEN_SAT ((set_term tm o set_flag_is_proved false) zchaff_co end end - - diff --git a/src/HolSat/minisatResolve.sml b/src/HolSat/minisatResolve.sml index 7c4b067389..a30516bf01 100644 --- a/src/HolSat/minisatResolve.sml +++ b/src/HolSat/minisatResolve.sml @@ -107,5 +107,3 @@ fun resolveChain lfn sva cl (nl,lnl) rci = end end - - diff --git a/src/HolSat/satTools.sml b/src/HolSat/satTools.sml index 7a2e718f8a..0ae8d10c3b 100644 --- a/src/HolSat/satTools.sml +++ b/src/HolSat/satTools.sml @@ -132,4 +132,3 @@ fun satCheck model t = end end - diff --git a/src/TeX/mkmkmunge.sml b/src/TeX/mkmkmunge.sml index 4af4475155..94118dbbb3 100644 --- a/src/TeX/mkmkmunge.sml +++ b/src/TeX/mkmkmunge.sml @@ -19,7 +19,3 @@ val _ = systeml "-I", HOLDIR ++ "src" ++ "TeX"] @ toload @ [HOLDIR ++ "src" ++ "TeX" ++ "mosmlmunge.uo"]) - - - - diff --git a/src/combin/combinScript.sml b/src/combin/combinScript.sml index 8810a757d8..b8201a2fec 100644 --- a/src/combin/combinScript.sml +++ b/src/combin/combinScript.sml @@ -312,4 +312,3 @@ val _ = adjoin_to_theory end)}; val _ = export_theory(); - diff --git a/src/compute/examples/MergeSort.sml b/src/compute/examples/MergeSort.sml index c90acc68f8..db09c007fd 100644 --- a/src/compute/examples/MergeSort.sml +++ b/src/compute/examples/MergeSort.sml @@ -159,5 +159,3 @@ val srws = flatten (map BODY_CONJUNCTS (COND_CLAUSES :: sort_thms)); fun simp_norm q = time (SIMP_CONV empty_ss srws) (--q--); simp_norm `merge_sort L12`; (* ~ 5s *) - - diff --git a/src/compute/examples/Sort.sml b/src/compute/examples/Sort.sml index b959fc8305..7d4023cb4a 100644 --- a/src/compute/examples/Sort.sml +++ b/src/compute/examples/Sort.sml @@ -64,4 +64,3 @@ time (funpow 100 (fn() => (tri_heap (L200()); ()))) (); (* ~ 0.36s *) time (funpow 100 (fn() => (tri_heap (L1200()); ()))) (); (* ~ 4.17s *) time (funpow 10 (fn() => (tri_heap (L19200()); ()))) (); (* ~ 15.7s *) time (funpow 10 (fn() => (tri_heap (L38400()); ()))) (); (* ~ 43.3s *) - diff --git a/src/datatype/DatatypeSimps.sig b/src/datatype/DatatypeSimps.sig index 1e3b4b20b3..07123d07c0 100644 --- a/src/datatype/DatatypeSimps.sig +++ b/src/datatype/DatatypeSimps.sig @@ -117,4 +117,3 @@ val expand_type_quants_stateful_ss : unit -> ssfrag val cases_to_top_RULE : rule end - diff --git a/src/datatype/mutrec/ConsThms.sml b/src/datatype/mutrec/ConsThms.sml index 94e84cf38d..f82c941f1f 100644 --- a/src/datatype/mutrec/ConsThms.sml +++ b/src/datatype/mutrec/ConsThms.sml @@ -662,4 +662,3 @@ end; val _ = Parse.temp_set_grammars ambient_grammars end (* ConsThms *) - diff --git a/src/datatype/mutrec/MutRecDef.sml b/src/datatype/mutrec/MutRecDef.sml index 9c1de944b1..cb8d667557 100644 --- a/src/datatype/mutrec/MutRecDef.sml +++ b/src/datatype/mutrec/MutRecDef.sml @@ -1477,4 +1477,3 @@ end val _ = Parse.temp_set_grammars ambient_grammars end (* MutRecDef *) - diff --git a/src/datatype/record/RecordType.sig b/src/datatype/record/RecordType.sig index 222bb280bd..d6f7a8c3c4 100644 --- a/src/datatype/record/RecordType.sig +++ b/src/datatype/record/RecordType.sig @@ -25,5 +25,3 @@ end accessor and update information. *) - - diff --git a/src/enumfset/tcScript.sml b/src/enumfset/tcScript.sml index ac40997441..ad6f007683 100644 --- a/src/enumfset/tcScript.sml +++ b/src/enumfset/tcScript.sml @@ -635,4 +635,3 @@ val _ = export_theory (); val _ = print_theory "-"; end; (* struct *) - diff --git a/src/finite_map/fmaptreeScript.sml b/src/finite_map/fmaptreeScript.sml index 3a4a6ce5ed..908a9e11bf 100644 --- a/src/finite_map/fmaptreeScript.sml +++ b/src/finite_map/fmaptreeScript.sml @@ -247,5 +247,3 @@ val fmtree_Axiom = store_thm( SRW_TAC [][fmtreerec_thm]); val _ = export_theory() - - diff --git a/src/integer/OmegaMath.sig b/src/integer/OmegaMath.sig index 77dec05281..3c3a500a0b 100644 --- a/src/integer/OmegaMath.sig +++ b/src/integer/OmegaMath.sig @@ -148,4 +148,3 @@ end; *) - diff --git a/src/integer/OmegaScript.sml b/src/integer/OmegaScript.sml index b9002e6ba0..c4524515a7 100644 --- a/src/integer/OmegaScript.sml +++ b/src/integer/OmegaScript.sml @@ -1078,4 +1078,3 @@ val calculational_nightmare = store_thm( PROVE_TAC []); val _ = export_theory(); - diff --git a/src/integer/testing/selftest.sml b/src/integer/testing/selftest.sml index 27aa4e44f7..a7132c597e 100644 --- a/src/integer/testing/selftest.sml +++ b/src/integer/testing/selftest.sml @@ -30,4 +30,3 @@ val cooper_result = val _ = Process.exit (if cooper_result andalso omega_result then Process.success else Process.failure) - diff --git a/src/integer/testing/test_coopers.sml b/src/integer/testing/test_coopers.sml index e402f949a6..d2a82f6b02 100644 --- a/src/integer/testing/test_coopers.sml +++ b/src/integer/testing/test_coopers.sml @@ -11,4 +11,3 @@ val _ = | _ => Profile.print_profile_results (Profile.results()) val _ = Process.exit (if result then Process.success else Process.failure) - diff --git a/src/integer/testing/test_omega.sml b/src/integer/testing/test_omega.sml index 5de3892aa4..be6e76e73f 100644 --- a/src/integer/testing/test_omega.sml +++ b/src/integer/testing/test_omega.sml @@ -8,5 +8,3 @@ val _ = case CommandLine.arguments() of [] => () | _ => Profile.print_profile_results (Profile.results()) val _ = Process.exit (if result then Process.success else Process.failure) - - diff --git a/src/marker/markerScript.sml b/src/marker/markerScript.sml index c7737678bc..3b5f10e79c 100644 --- a/src/marker/markerScript.sml +++ b/src/marker/markerScript.sml @@ -126,4 +126,3 @@ val label_def = new_definition( ``((lab:label) :- (argument:bool)) = argument``); val _ = export_theory(); - diff --git a/src/meson/src/Canon_Port.sig b/src/meson/src/Canon_Port.sig index a8e7831681..2a5f1a8d6a 100644 --- a/src/meson/src/Canon_Port.sig +++ b/src/meson/src/Canon_Port.sig @@ -15,4 +15,3 @@ sig val REFUTE_THEN : (thm -> tactic) -> tactic val GEN_FOL_CONV : (term*int)list * (term*int) list -> conv end; - diff --git a/src/meson/test.sml b/src/meson/test.sml index 7d4756168f..a507bb36df 100644 --- a/src/meson/test.sml +++ b/src/meson/test.sml @@ -3418,5 +3418,3 @@ Lib.with_flag(Globals.guessing_tyvars,true) (!X U Y. subset_collections(X,Y) /\ element_of_collection(U,X) ==> element_of_collection(U,Y)) /\ (subset_collections(g,top_of_basis(f))) /\ (~element_of_collection(union_of_members(g),top_of_basis(f))) ==> F`; - - diff --git a/src/metis/mlibOmega.sig b/src/metis/mlibOmega.sig index 7239a3ef0b..dc9720f07a 100644 --- a/src/metis/mlibOmega.sig +++ b/src/metis/mlibOmega.sig @@ -49,4 +49,3 @@ end ---------------------------------------------------------------------- *) (* a derivation represents a proof of a factoid *) - diff --git a/src/metis/mlibSubst.sig b/src/metis/mlibSubst.sig index ce5d84d233..d1b2cb6dd7 100644 --- a/src/metis/mlibSubst.sig +++ b/src/metis/mlibSubst.sig @@ -31,4 +31,3 @@ val foldr : ((string, term) maplet -> 'a -> 'a) -> 'a -> subst -> 'a val pp_subst : subst pp end - diff --git a/src/monad/parmonadsyntax2.sml b/src/monad/parmonadsyntax2.sml index 049358c163..b2e27e4139 100644 --- a/src/monad/parmonadsyntax2.sml +++ b/src/monad/parmonadsyntax2.sml @@ -293,5 +293,3 @@ end val _ = temp_add_user_printer ("parmonadsyntax.print_monads", ``x:'a``, print_monads) - - diff --git a/src/num/arith/src/GenPolyCanon.sig b/src/num/arith/src/GenPolyCanon.sig index 395d1dba30..5ec9dd9b2d 100644 --- a/src/num/arith/src/GenPolyCanon.sig +++ b/src/num/arith/src/GenPolyCanon.sig @@ -87,5 +87,3 @@ end; theorems. *) - - diff --git a/src/num/extra_theories/numpairScript.sml b/src/num/extra_theories/numpairScript.sml index ca54cc1cb5..70fba5a8b5 100644 --- a/src/num/extra_theories/numpairScript.sml +++ b/src/num/extra_theories/numpairScript.sml @@ -304,4 +304,3 @@ val nlist_cases = store_thm( val _ = export_theory() - diff --git a/src/num/theories/DecimalFractionPP.sml b/src/num/theories/DecimalFractionPP.sml index d27a6adf13..8ff8d6f08d 100644 --- a/src/num/theories/DecimalFractionPP.sml +++ b/src/num/theories/DecimalFractionPP.sml @@ -51,4 +51,3 @@ in end end - diff --git a/src/num/theories/basicSizeScript.sml b/src/num/theories/basicSizeScript.sml index 8910174541..f5df8da8f2 100644 --- a/src/num/theories/basicSizeScript.sml +++ b/src/num/theories/basicSizeScript.sml @@ -28,4 +28,3 @@ val option_size_def = rec_axiom = optionTheory.option_Axiom}; val _ = export_theory(); - diff --git a/src/option/optionSimps.sig b/src/option/optionSimps.sig index eb6945004b..541908f89f 100644 --- a/src/option/optionSimps.sig +++ b/src/option/optionSimps.sig @@ -2,4 +2,3 @@ signature optionSimps = sig val OPTION_ss : simpLib.ssfrag end - diff --git a/src/parse/CharSet.sml b/src/parse/CharSet.sml index 499e22487a..2fb65cc1a7 100644 --- a/src/parse/CharSet.sml +++ b/src/parse/CharSet.sml @@ -86,4 +86,3 @@ struct end end; - diff --git a/src/parse/ProvideUnicode.sig b/src/parse/ProvideUnicode.sig index d61e317540..8c0ba87f33 100644 --- a/src/parse/ProvideUnicode.sig +++ b/src/parse/ProvideUnicode.sig @@ -40,4 +40,3 @@ val reader : ThyUpdateInfo Coding.reader end - diff --git a/src/parse/base_tokens.sig b/src/parse/base_tokens.sig index 09c7f22b89..ea9b9896e8 100644 --- a/src/parse/base_tokens.sig +++ b/src/parse/base_tokens.sig @@ -21,4 +21,3 @@ sig val parse_fraction : string * locn.locn -> fracinfo end - diff --git a/src/parse/errormonad.sml b/src/parse/errormonad.sml index 9270f1bdc8..5b22b4c0ea 100644 --- a/src/parse/errormonad.sml +++ b/src/parse/errormonad.sml @@ -49,6 +49,3 @@ end fun repeat p env = ((p >> repeat p) ++ ok) env end - - - diff --git a/src/parse/parse_term.sig b/src/parse/parse_term.sig index 8ab188011d..43e1f0ad02 100644 --- a/src/parse/parse_term.sig +++ b/src/parse/parse_term.sig @@ -28,4 +28,3 @@ sig end - diff --git a/src/parse/qbuf.sml b/src/parse/qbuf.sml index 29578529ea..0be47b5a36 100644 --- a/src/parse/qbuf.sml +++ b/src/parse/qbuf.sml @@ -123,7 +123,3 @@ struct end end; - - - - diff --git a/src/parse/term_pp.sig b/src/parse/term_pp.sig index 092ac4635d..3bdf819f45 100644 --- a/src/parse/term_pp.sig +++ b/src/parse/term_pp.sig @@ -13,4 +13,3 @@ sig val init_casesplit_munger : (term -> term * (term * term) list) -> unit end - diff --git a/src/parse/term_pp_utils.sig b/src/parse/term_pp_utils.sig index 3e4c8fea00..1cc8cffdf3 100644 --- a/src/parse/term_pp_utils.sig +++ b/src/parse/term_pp_utils.sig @@ -16,5 +16,3 @@ sig val get_gspec : (term_pp_types.printing_info,bool) smpp.t end - - diff --git a/src/parse/term_tokens.sig b/src/parse/term_tokens.sig index f80eea5ae7..a650da0607 100644 --- a/src/parse/term_tokens.sig +++ b/src/parse/term_tokens.sig @@ -25,4 +25,3 @@ sig val lextest : string list -> string -> 'a term_token list end - diff --git a/src/path/pathScript.sml b/src/path/pathScript.sml index 4d4220d69f..f00affd313 100644 --- a/src/path/pathScript.sml +++ b/src/path/pathScript.sml @@ -1811,4 +1811,3 @@ SRW_TAC [] [] THENL val _ = export_theory(); - diff --git a/src/pfl/index.sml b/src/pfl/index.sml index 5d6c118310..b1bdae3de2 100644 --- a/src/pfl/index.sml +++ b/src/pfl/index.sml @@ -541,4 +541,3 @@ e (pbase_clause pfn_def idef limspec ifn_def_pos); (* Recursive case *) (* Recursive case *) - diff --git a/src/portableML/Arbnum.sml b/src/portableML/Arbnum.sml index d9a1622601..20fafeaf95 100644 --- a/src/portableML/Arbnum.sml +++ b/src/portableML/Arbnum.sml @@ -20,4 +20,3 @@ in end end - diff --git a/src/portableML/poly/Susp.sml b/src/portableML/poly/Susp.sml index da6e120bd4..308c99b638 100644 --- a/src/portableML/poly/Susp.sml +++ b/src/portableML/poly/Susp.sml @@ -14,4 +14,3 @@ fun force (su : 'a susp) : 'a = | THUNK f => let val v = f () in su := VAL v; v end end (* struct *) - diff --git a/src/pred_set/src/gcdsetScript.sml b/src/pred_set/src/gcdsetScript.sml index b9a4dab846..f7bfcc546c 100644 --- a/src/pred_set/src/gcdsetScript.sml +++ b/src/pred_set/src/gcdsetScript.sml @@ -86,4 +86,3 @@ val _ = export_rewrites ["gcdset_INSERT"] val _ = export_theory() - diff --git a/src/prekernel/KernelSig.sml b/src/prekernel/KernelSig.sml index 498b3a368a..5448ff6683 100644 --- a/src/prekernel/KernelSig.sml +++ b/src/prekernel/KernelSig.sml @@ -92,4 +92,3 @@ struct end - diff --git a/src/prekernel/Nonce.sig b/src/prekernel/Nonce.sig index bf25a08d83..e867e18546 100644 --- a/src/prekernel/Nonce.sig +++ b/src/prekernel/Nonce.sig @@ -6,5 +6,3 @@ sig val dest : 'a t -> 'a end - - diff --git a/src/quantHeuristics/selftest.sml b/src/quantHeuristics/selftest.sml index 9ad009a8a3..3fc3cf62b6 100644 --- a/src/quantHeuristics/selftest.sml +++ b/src/quantHeuristics/selftest.sml @@ -317,4 +317,3 @@ val _ = map (qh_test_context2 hard_fail quiet) qh_testCases_context2; val _ = Process.exit Process.success; - diff --git a/src/quotient/examples/lambda/barendregt.sig b/src/quotient/examples/lambda/barendregt.sig index 4640217aec..6277a234fe 100644 --- a/src/quotient/examples/lambda/barendregt.sig +++ b/src/quotient/examples/lambda/barendregt.sig @@ -25,4 +25,3 @@ val MAKE_SIMPLE_SUBST_TAC : tactic val SIMPLE_SUBST_TAC : tactic end; - diff --git a/src/quotient/examples/lambda/more_listScript.sml b/src/quotient/examples/lambda/more_listScript.sml index b59f4e0cc7..e5391f27bc 100644 --- a/src/quotient/examples/lambda/more_listScript.sml +++ b/src/quotient/examples/lambda/more_listScript.sml @@ -171,4 +171,3 @@ val _ = export_theory(); val _ = print_theory_to_file "-" "more_list.lst"; val _ = html_theory "more_list"; - diff --git a/src/quotient/examples/lambda/more_setScript.sml b/src/quotient/examples/lambda/more_setScript.sml index fc4950f277..f9f9c39796 100644 --- a/src/quotient/examples/lambda/more_setScript.sml +++ b/src/quotient/examples/lambda/more_setScript.sml @@ -770,4 +770,3 @@ val _ = export_theory(); val _ = print_theory_to_file "-" "more_set.lst"; val _ = html_theory "more_set"; - diff --git a/src/quotient/examples/sigma/barendregt.sig b/src/quotient/examples/sigma/barendregt.sig index d5a5275bfb..34bc8eace1 100644 --- a/src/quotient/examples/sigma/barendregt.sig +++ b/src/quotient/examples/sigma/barendregt.sig @@ -24,4 +24,3 @@ val MAKE_SIMPLE_SUBST_TAC : tactic val SIMPLE_SUBST_TAC : tactic end; - diff --git a/src/quotient/examples/sigma/more_listScript.sml b/src/quotient/examples/sigma/more_listScript.sml index b59f4e0cc7..e5391f27bc 100644 --- a/src/quotient/examples/sigma/more_listScript.sml +++ b/src/quotient/examples/sigma/more_listScript.sml @@ -171,4 +171,3 @@ val _ = export_theory(); val _ = print_theory_to_file "-" "more_list.lst"; val _ = html_theory "more_list"; - diff --git a/src/quotient/examples/sigma/more_setScript.sml b/src/quotient/examples/sigma/more_setScript.sml index fc4950f277..f9f9c39796 100644 --- a/src/quotient/examples/sigma/more_setScript.sml +++ b/src/quotient/examples/sigma/more_setScript.sml @@ -770,4 +770,3 @@ val _ = export_theory(); val _ = print_theory_to_file "-" "more_set.lst"; val _ = html_theory "more_set"; - diff --git a/src/quotient/src/quotientLib.sml b/src/quotient/src/quotientLib.sml index 299c370c89..dc6f993814 100644 --- a/src/quotient/src/quotientLib.sml +++ b/src/quotient/src/quotientLib.sml @@ -8,4 +8,3 @@ struct open quotient_pred_setTheory open quotient end - diff --git a/src/quotient/src/quotientScript.sml b/src/quotient/src/quotientScript.sml index 1da867c2b9..3633f19b73 100644 --- a/src/quotient/src/quotientScript.sml +++ b/src/quotient/src/quotientScript.sml @@ -1832,4 +1832,3 @@ val _ = export_theory(); val _ = print_theory_to_file "-" "quotient.lst"; val _ = html_theory "quotient"; - diff --git a/src/quotient/src/quotient_listScript.sml b/src/quotient/src/quotient_listScript.sml index 5100bded43..3ffe118b3b 100644 --- a/src/quotient/src/quotient_listScript.sml +++ b/src/quotient/src/quotient_listScript.sml @@ -655,4 +655,3 @@ val _ = export_theory(); val _ = print_theory_to_file "-" "quotient_list.lst"; val _ = html_theory "quotient_list"; - diff --git a/src/quotient/src/quotient_optionScript.sml b/src/quotient/src/quotient_optionScript.sml index a8dfca7b9b..ce3553fac1 100644 --- a/src/quotient/src/quotient_optionScript.sml +++ b/src/quotient/src/quotient_optionScript.sml @@ -263,4 +263,3 @@ val _ = export_theory(); val _ = print_theory_to_file "-" "quotient_option.lst"; val _ = html_theory "quotient_option"; - diff --git a/src/quotient/src/quotient_pairScript.sml b/src/quotient/src/quotient_pairScript.sml index 1ff86d6c40..1e2d746932 100644 --- a/src/quotient/src/quotient_pairScript.sml +++ b/src/quotient/src/quotient_pairScript.sml @@ -382,4 +382,3 @@ val _ = export_theory(); val _ = print_theory_to_file "-" "quotient_pair.lst"; val _ = html_theory "quotient_pair"; - diff --git a/src/quotient/src/quotient_pred_setScript.sml b/src/quotient/src/quotient_pred_setScript.sml index 8f3d3192af..370c5f55d2 100644 --- a/src/quotient/src/quotient_pred_setScript.sml +++ b/src/quotient/src/quotient_pred_setScript.sml @@ -994,4 +994,3 @@ val _ = export_theory(); val _ = print_theory_to_file "-" "quotient_pred_set.lst"; val _ = html_theory "quotient_pred_set"; - diff --git a/src/quotient/src/quotient_sumScript.sml b/src/quotient/src/quotient_sumScript.sml index eda6b86c5b..d8dbaf432f 100644 --- a/src/quotient/src/quotient_sumScript.sml +++ b/src/quotient/src/quotient_sumScript.sml @@ -291,4 +291,3 @@ val _ = export_theory(); val _ = print_theory_to_file "-" "quotient_sum.lst"; val _ = html_theory "quotient_sum"; - diff --git a/src/rational/fracScript.sml b/src/rational/fracScript.sml index 70655484e9..50edb2f3f5 100644 --- a/src/rational/fracScript.sml +++ b/src/rational/fracScript.sml @@ -1028,4 +1028,3 @@ val FRAC_MUL_SAVE = store_thm( *==========================================================================*) val _ = export_theory(); - diff --git a/src/rational/intExtensionScript.sml b/src/rational/intExtensionScript.sml index 14dc05d386..1b3fe4b006 100644 --- a/src/rational/intExtensionScript.sml +++ b/src/rational/intExtensionScript.sml @@ -336,4 +336,3 @@ val INT_LT_ADD_NEG = store_thm("INT_LT_ADD_NEG", ``!x y. x < 0i /\ y < 0i ==> x val _ = export_theory(); - diff --git a/src/real/polyScript.sml b/src/real/polyScript.sml index 9ead8709dd..2f35e0e84e 100644 --- a/src/real/polyScript.sml +++ b/src/real/polyScript.sml @@ -1430,4 +1430,3 @@ val POLY_NORMALIZE_CONV = val _ = export_theory (); end; - diff --git a/src/refute/AC.sig b/src/refute/AC.sig index 83e6cc6229..ea360eaead 100644 --- a/src/refute/AC.sig +++ b/src/refute/AC.sig @@ -13,4 +13,3 @@ sig val ASSOC_CONV : thm -> conv val DISTRIB_CONV : thm * thm -> conv end - diff --git a/src/refute/Canon.sig b/src/refute/Canon.sig index 1ff5605e28..5766633057 100644 --- a/src/refute/Canon.sig +++ b/src/refute/Canon.sig @@ -35,4 +35,3 @@ sig val latest : (thm * thm * term) option ref; end (* sig *) - diff --git a/src/ring/src/numRingScript.sml b/src/ring/src/numRingScript.sml index 6ac978c706..068135d1f1 100644 --- a/src/ring/src/numRingScript.sml +++ b/src/ring/src/numRingScript.sml @@ -36,4 +36,3 @@ end; val _ = temp_overload_on("mult",--`$* : num->num->num`--); val _ = export_theory(); - diff --git a/src/simp/src/Opening.sig b/src/simp/src/Opening.sig index b050940127..85f0054ef9 100644 --- a/src/simp/src/Opening.sig +++ b/src/simp/src/Opening.sig @@ -92,5 +92,3 @@ signature Opening = sig val EQ_CONGPROC : congproc end (* sig *) - - diff --git a/src/simp/src/Opening.sml b/src/simp/src/Opening.sml index aad7eefbbb..8bfe62b64b 100644 --- a/src/simp/src/Opening.sml +++ b/src/simp/src/Opening.sml @@ -265,4 +265,3 @@ fun EQ_CONGPROC {relation,depther,solver,freevars} tm = end (* struct *) - diff --git a/src/simp/src/Satisfy.sig b/src/simp/src/Satisfy.sig index 360bcbb744..f1d148d60c 100644 --- a/src/simp/src/Satisfy.sig +++ b/src/simp/src/Satisfy.sig @@ -49,4 +49,3 @@ signature Satisfy = sig val SATISFY_TAC : tactic val add_facts : factdb -> thm list -> factdb end (* sig *) - diff --git a/src/simp/src/Sequence.sig b/src/simp/src/Sequence.sig index 0b807bfd07..5ea1686924 100644 --- a/src/simp/src/Sequence.sig +++ b/src/simp/src/Sequence.sig @@ -38,5 +38,3 @@ signature Sequence = sig val seq_diagonalize : 'a seq -> 'b seq -> ('a * 'b) seq val seq_permutations : 'a list -> 'a list seq end (* sig *) - - diff --git a/src/simp/src/Sequence.sml b/src/simp/src/Sequence.sml index c4378fb287..3ca3574863 100644 --- a/src/simp/src/Sequence.sml +++ b/src/simp/src/Sequence.sml @@ -173,4 +173,3 @@ fun seq_permutations l = end (* struct *) - diff --git a/src/simp/src/Travrules.sig b/src/simp/src/Travrules.sig index ecf7c85dd4..e6bf07ce17 100644 --- a/src/simp/src/Travrules.sig +++ b/src/simp/src/Travrules.sig @@ -94,6 +94,3 @@ sig val EQ_tr : travrules end (* sig *) - - - diff --git a/src/simp/src/Unify.sig b/src/simp/src/Unify.sig index 624ae0859e..097e2b8ed5 100644 --- a/src/simp/src/Unify.sig +++ b/src/simp/src/Unify.sig @@ -22,4 +22,3 @@ sig val restrict_tmenv :(term -> bool) -> (term,term)subst -> (term,term)subst end - diff --git a/src/simp/src/boolSimps.sig b/src/simp/src/boolSimps.sig index eea5e93489..a2e87f1a2e 100644 --- a/src/simp/src/boolSimps.sig +++ b/src/simp/src/boolSimps.sig @@ -67,4 +67,3 @@ sig end - diff --git a/src/simp/src/congLib.sig b/src/simp/src/congLib.sig index 0e8fd668aa..8deb93c064 100644 --- a/src/simp/src/congLib.sig +++ b/src/simp/src/congLib.sig @@ -130,4 +130,3 @@ sig end - diff --git a/src/simp/test.sml b/src/simp/test.sml index 46ccd45f08..07782e29a7 100644 --- a/src/simp/test.sml +++ b/src/simp/test.sml @@ -67,11 +67,3 @@ CACHED_ARITH [] (--`3 < 1`--);; (* cache hit, failure *) val CC = SIMP_PROVE bool_ss [] (--`!P:'a->'b. (x = x') ==> (P x = P x')`--); val CC2 = SIMP_PROVE bool_ss [] (--`!P:'a->'b->'c. (x = x') /\ (y = y') ==> (P x y = P x' y')`--); SIMP_PROVE arith_ss [CC,CC2] (--`y >= z ==> z >= y ==> (P y (x + 2):bool = P z (2 + x))`--); - - - - - - - - diff --git a/src/string/selftest.sml b/src/string/selftest.sml index 3d39758756..d7734359a8 100644 --- a/src/string/selftest.sml +++ b/src/string/selftest.sml @@ -109,7 +109,3 @@ val _ = if s = "\"\\042)\"" then print "OK\n" val _ = OS.Process.exit OS.Process.success - - - - diff --git a/src/string/stringSimps.sml b/src/string/stringSimps.sml index 504ab361ae..cc27797fbb 100644 --- a/src/string/stringSimps.sml +++ b/src/string/stringSimps.sml @@ -8,4 +8,3 @@ val STRING_ss = BasicProvers.thy_ssfrag "string" val string_rewrites = frag_rewrites STRING_ss end - diff --git a/src/string/stringSyntax.sig b/src/string/stringSyntax.sig index 4aa9c78eda..453db11f25 100644 --- a/src/string/stringSyntax.sig +++ b/src/string/stringSyntax.sig @@ -184,4 +184,3 @@ sig val lift_string : hol_type -> string -> term end - diff --git a/src/string/theorytesting/otherScript.sml b/src/string/theorytesting/otherScript.sml index e19e0f5f9b..0e9bab2859 100644 --- a/src/string/theorytesting/otherScript.sml +++ b/src/string/theorytesting/otherScript.sml @@ -11,4 +11,3 @@ val _ = print "Successfully opened sampleTheory\n" val _ = export_theory(); - diff --git a/src/string/theorytesting/sampleScript.sml b/src/string/theorytesting/sampleScript.sml index cb7aa61fd0..2f4ed58328 100644 --- a/src/string/theorytesting/sampleScript.sml +++ b/src/string/theorytesting/sampleScript.sml @@ -6,4 +6,3 @@ val _ = Define `badstring = "*)"`; (* val _ = max_print_depth := 0; *) val _ = export_theory(); - diff --git a/src/temporal/src/Temporal_LogicScript.sml b/src/temporal/src/Temporal_LogicScript.sml index 8a8ad11f0b..c0cd112382 100644 --- a/src/temporal/src/Temporal_LogicScript.sml +++ b/src/temporal/src/Temporal_LogicScript.sml @@ -2999,5 +2999,3 @@ val _ = save_thm("NOT_SBEFORE",NOT_SBEFORE); val _ = export_theory(); (* html_theory "-"; *) - - From 82bb4a0ce5934b4446abc84b5d36b55ff20a82f0 Mon Sep 17 00:00:00 2001 From: Piotr Trojanek Date: Thu, 23 Oct 2014 11:09:24 +0100 Subject: [PATCH 015/718] whitespace cleanup: consistent use of tabs and spaces --- tools/mllex/mllex.sml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/mllex/mllex.sml b/tools/mllex/mllex.sml index a2db7db864..28344c5c22 100644 --- a/tools/mllex/mllex.sml +++ b/tools/mllex/mllex.sml @@ -955,7 +955,7 @@ fun maketable (fins:(int * (int list)) list, fun GetEndLeaf t = let fun f ((tl,el)::r) = if (tl=t) then el else f r | f [] = raise Fail "GetEndLeaf" - in f tcpairs + in f tcpairs end fun GetTrConLeaves s = let fun f ((s',l)::r) = if (s = s') then l else f r From e5cccb76f02564042172dfe01b1c382c6ea24c72 Mon Sep 17 00:00:00 2001 From: Piotr Trojanek Date: Fri, 24 Oct 2014 11:30:55 +0100 Subject: [PATCH 016/718] first_tok: error message improved; unused code removed --- src/parse/parse_term.sig | 3 +-- src/parse/parse_term.sml | 2 +- src/parse/term_grammar.sml | 2 +- src/parse/term_pp.sml | 4 ---- 4 files changed, 3 insertions(+), 8 deletions(-) diff --git a/src/parse/parse_term.sig b/src/parse/parse_term.sig index 43e1f0ad02..c72e75a25f 100644 --- a/src/parse/parse_term.sig +++ b/src/parse/parse_term.sig @@ -1,7 +1,7 @@ signature parse_term = sig type 'a PStack - type 'a qbuf= 'a qbuf.qbuf + type 'a qbuf = 'a qbuf.qbuf type stack_terminal = term_grammar.stack_terminal val initial_pstack : 'a PStack val is_final_pstack : 'a PStack -> bool @@ -26,5 +26,4 @@ sig term_grammar.grammar -> ((stack_terminal * bool) * stack_terminal, mx_order) Binarymap.dict ref - end diff --git a/src/parse/parse_term.sml b/src/parse/parse_term.sml index 67a27be9a2..9d8e300927 100644 --- a/src/parse/parse_term.sml +++ b/src/parse/parse_term.sml @@ -82,7 +82,7 @@ exception PrecConflict of stack_terminal * stack_terminal val complained_already = ref false; -fun first_tok [] = raise Fail "Shouldn't happen parse_term 133" +fun first_tok [] = raise Fail "Shouldn't happen: parse_term.first_tok" | first_tok (RE (TOK s)::_) = s | first_tok (_ :: t) = first_tok t diff --git a/src/parse/term_grammar.sml b/src/parse/term_grammar.sml index 94cc6e3298..c44a0b7640 100644 --- a/src/parse/term_grammar.sml +++ b/src/parse/term_grammar.sml @@ -468,7 +468,7 @@ val stdhol : grammar = absyn_postprocessors = [] } -fun first_tok [] = raise Fail "Shouldn't happen parse_term 133" +fun first_tok [] = raise Fail "Shouldn't happen: term_grammar.first_tok" | first_tok (RE (TOK s)::_) = s | first_tok (_ :: t) = first_tok t diff --git a/src/parse/term_pp.sml b/src/parse/term_pp.sml index 5d83f32fa6..4c2cd5f374 100644 --- a/src/parse/term_pp.sml +++ b/src/parse/term_pp.sml @@ -321,10 +321,6 @@ val prettyprint_bigrecs = ref true; val _ = register_btrace ("pp_bigrecs", prettyprint_bigrecs) -fun first_tok [] = raise Fail "Shouldn't happen term_pp 133" - | first_tok (RE (TOK s)::_) = s - | first_tok (_ :: t) = first_tok t - fun decdepth n = if n < 0 then n else n - 1 val unfakeconst = Option.map #fake o GrammarSpecials.dest_fakeconst_name From cf9c1e787bdce76b1a63927d150025b194c934e2 Mon Sep 17 00:00:00 2001 From: Piotr Trojanek Date: Fri, 24 Oct 2014 14:38:52 +0100 Subject: [PATCH 017/718] correct indent (3 spaces) of documentation in .sig files --- src/0/Net-sig.sml | 6 +- src/1/AC_Sort.sig | 44 +++++++------- src/experimental-kernel/Net.sig | 6 +- src/logging-kernel/Net.sig | 6 +- src/num/arith/src/GenPolyCanon.sig | 98 +++++++++++++++--------------- src/parse/parse_term.sig | 1 + src/parse/qbuf.sml | 2 +- 7 files changed, 82 insertions(+), 81 deletions(-) diff --git a/src/0/Net-sig.sml b/src/0/Net-sig.sml index 2e7a85d349..f4dff791f8 100644 --- a/src/0/Net-sig.sml +++ b/src/0/Net-sig.sml @@ -40,16 +40,16 @@ sig operations are not exact. In this sense, term nets are akin to hash tables. - [empty] is the empty term net. + [empty] is the empty term net. - [insert (tm, x) net] + [insert (tm, x) net] The term tm is used as a key to compute a path at which to store x in net. If the path does not already exist in net, it is created. Note that insert merely adds x to the net; if x has already been stored under tm, then it is not overwritten. - [match tm net] + [match tm net] Term nets can be used to cut down on the number of match attempts that a matching function would have to make, say when rewriting diff --git a/src/1/AC_Sort.sig b/src/1/AC_Sort.sig index 141c539de1..b2545fea79 100644 --- a/src/1/AC_Sort.sig +++ b/src/1/AC_Sort.sig @@ -11,36 +11,36 @@ end (* - [sort {assoc,comm,dest,mk,cmp,combine,preprocess}] is a conversion for - sorting terms with respect to an associative and commutative operator. - It uses a merge sort internally, so should be reasonably efficient. + [sort {assoc,comm,dest,mk,cmp,combine,preprocess}] is a conversion for + sorting terms with respect to an associative and commutative operator. + It uses a merge sort internally, so should be reasonably efficient. - The record's fields are: + The record's fields are: - assoc: associativity theorem in standard r-to-l format: - a + (b + c) = (a + b) + c - can be universally quantified + assoc: associativity theorem in standard r-to-l format: + a + (b + c) = (a + b) + c + can be universally quantified - comm: commutativity theorem (can be universally quantified) + comm: commutativity theorem (can be universally quantified) - dest: destructor function for operator + dest: destructor function for operator - mk: constructor function for operator + mk: constructor function for operator - cmp: comparison function for performing sort. Terms identified - as EQUAL will be combined by combine conversion. + cmp: comparison function for performing sort. Terms identified + as EQUAL will be combined by combine conversion. - combine: conv taking terms of the form (t1 op t2) where t1 and t2 - have compared as equal. Should always succeed (can be - ALL_CONV). + combine: conv taking terms of the form (t1 op t2) where t1 and t2 + have compared as equal. Should always succeed (can be + ALL_CONV). - preprocess: applied to all leaf terms as term is first examined. - If it fails or raises UNCHANGED (i.e., both ALL_CONV and - NO_CONV are OK here), nothing further is done. If it - succeeds, further processing is performed on the resulting - term + preprocess: applied to all leaf terms as term is first examined. + If it fails or raises UNCHANGED (i.e., both ALL_CONV and + NO_CONV are OK here), nothing further is done. If it + succeeds, further processing is performed on the resulting + term - E.g., combine can combine numeric literals; preprocess could convert - a - b into a + -b, or -x into -1 * x, or ~~p into p. + E.g., combine can combine numeric literals; preprocess could convert + a - b into a + -b, or -x into -1 * x, or ~~p into p. *) diff --git a/src/experimental-kernel/Net.sig b/src/experimental-kernel/Net.sig index 260f0c30f7..6065a7ec06 100644 --- a/src/experimental-kernel/Net.sig +++ b/src/experimental-kernel/Net.sig @@ -40,16 +40,16 @@ sig operations are not exact. In this sense, term nets are akin to hash tables. - [empty] is the empty term net. + [empty] is the empty term net. - [insert (tm, x) net] + [insert (tm, x) net] The term tm is used as a key to compute a path at which to store x in net. If the path does not already exist in net, it is created. Note that insert merely adds x to the net; if x has already been stored under tm, then it is not overwritten. - [match tm net] + [match tm net] Term nets can be used to cut down on the number of match attempts that a matching function would have to make, say when rewriting diff --git a/src/logging-kernel/Net.sig b/src/logging-kernel/Net.sig index 260f0c30f7..6065a7ec06 100644 --- a/src/logging-kernel/Net.sig +++ b/src/logging-kernel/Net.sig @@ -40,16 +40,16 @@ sig operations are not exact. In this sense, term nets are akin to hash tables. - [empty] is the empty term net. + [empty] is the empty term net. - [insert (tm, x) net] + [insert (tm, x) net] The term tm is used as a key to compute a path at which to store x in net. If the path does not already exist in net, it is created. Note that insert merely adds x to the net; if x has already been stored under tm, then it is not overwritten. - [match tm net] + [match tm net] Term nets can be used to cut down on the number of match attempts that a matching function would have to make, say when rewriting diff --git a/src/num/arith/src/GenPolyCanon.sig b/src/num/arith/src/GenPolyCanon.sig index 5ec9dd9b2d..4de9323488 100644 --- a/src/num/arith/src/GenPolyCanon.sig +++ b/src/num/arith/src/GenPolyCanon.sig @@ -30,60 +30,60 @@ end; (* - The gci type stores sufficient information about a type and operators over - it to allow normalisation of "polynomials" over that type, collecting up - coefficients etc. + The gci type stores sufficient information about a type and operators over + it to allow normalisation of "polynomials" over that type, collecting up + coefficients etc. - The required fields of the record are - dest : pulls apart a term (e.g., x + y -> (x,y)) - is_literal : returns true iff a term is a numeric literal - in L & R - modes literals are shunted to the right end of the term. - In L_Cflipped they appear on the front. - assoc_mode : how the term should be associated when built. - L & R are obvious. L_Cflipped has non-literals - left-associated, but possibly prepended by a literal to - the left. This is appropriate for multiplication, e.g., - c((xy)z) - assoc : associativity theorem (e.g., |- x + (y + z) = (x + y) + z) - symassoc : associativity theorem with equality flipped - comm : commutativity theorem (e.g., |- x + y = y + x) - l_asscomm : right-commutativity theorem (letter 'l' indicates that - terms are left-associated) - (e.g., |- (x + y) + z = (x + z) + y) - r_asscomm : left-commutativity theorem (terms are right-associated) - (e.g., |- x + (y + z) = y + (x + z)) - non_coeff : returns the "base" of a term, ignoring the coefficient. - (e.g., x -> x, 2 * x -> x, ~y -> y, 3 -> 1) - merge : takes a term of the form t1 op t2, where t1 and t2 have - equal base, and merges them into one by summing - coefficients. The result will be subjected to - post-normalisation (see below) - postnorm : conversion to normalise certain coeff-term pairs. Must - include the analogue of - 0 * x -> |- 0 * x = 0 - and might reasonably include - x ** 1 -> |- x ** 1 = x - ~1 * x -> |- ~1 * x = ~x - 3 * 1 -> |- 3 * 1 = 3 - left_id : theorem stating left-identity for the base operator - (e.g., |- 0 + x = x and |- 1 * x = x) - right_id : theorem stating right-identity for the base operator - reducer : conversion for doing ground arithmetic on coefficients + The required fields of the record are + dest : pulls apart a term (e.g., x + y -> (x,y)) + is_literal : returns true iff a term is a numeric literal - in L & R + modes literals are shunted to the right end of the term. + In L_Cflipped they appear on the front. + assoc_mode : how the term should be associated when built. + L & R are obvious. L_Cflipped has non-literals + left-associated, but possibly prepended by a literal to + the left. This is appropriate for multiplication, e.g., + c((xy)z) + assoc : associativity theorem (e.g., |- x + (y + z) = (x + y) + z) + symassoc : associativity theorem with equality flipped + comm : commutativity theorem (e.g., |- x + y = y + x) + l_asscomm : right-commutativity theorem (letter 'l' indicates that + terms are left-associated) + (e.g., |- (x + y) + z = (x + z) + y) + r_asscomm : left-commutativity theorem (terms are right-associated) + (e.g., |- x + (y + z) = y + (x + z)) + non_coeff : returns the "base" of a term, ignoring the coefficient. + (e.g., x -> x, 2 * x -> x, ~y -> y, 3 -> 1) + merge : takes a term of the form t1 op t2, where t1 and t2 have + equal base, and merges them into one by summing + coefficients. The result will be subjected to + post-normalisation (see below) + postnorm : conversion to normalise certain coeff-term pairs. Must + include the analogue of + 0 * x -> |- 0 * x = 0 + and might reasonably include + x ** 1 -> |- x ** 1 = x + ~1 * x -> |- ~1 * x = ~x + 3 * 1 -> |- 3 * 1 = 3 + left_id : theorem stating left-identity for the base operator + (e.g., |- 0 + x = x and |- 1 * x = x) + right_id : theorem stating right-identity for the base operator + reducer : conversion for doing ground arithmetic on coefficients - To handle literals, get non_coeff to return a base of 1 for them, and then - handle their merging separately in the merge function. + To handle literals, get non_coeff to return a base of 1 for them, and then + handle their merging separately in the merge function. - [update_mode m g] returns a g' that is identical to g except that - the assoc_mode field of the record has been updated to have value m. + [update_mode m g] returns a g' that is identical to g except that + the assoc_mode field of the record has been updated to have value m. - [gencanon g t] returns a theorem of the form |- t = t', where t' is a normal - form. The polynomial will be right-associated (for backwards compatibility - reasons). + [gencanon g t] returns a theorem of the form |- t = t', where t' is a normal + form. The polynomial will be right-associated (for backwards compatibility + reasons). - [derive_l_asscomm ass comm] derives an l_asscomm theorem from assoc and comm - theorems. + [derive_l_asscomm ass comm] derives an l_asscomm theorem from assoc and comm + theorems. - [derive_r_asscomm ass comm] derives an r_asscomm theorem from assoc and comm - theorems. + [derive_r_asscomm ass comm] derives an r_asscomm theorem from assoc and comm + theorems. *) diff --git a/src/parse/parse_term.sig b/src/parse/parse_term.sig index c72e75a25f..f3eee4f28e 100644 --- a/src/parse/parse_term.sig +++ b/src/parse/parse_term.sig @@ -3,6 +3,7 @@ sig type 'a PStack type 'a qbuf = 'a qbuf.qbuf type stack_terminal = term_grammar.stack_terminal + val initial_pstack : 'a PStack val is_final_pstack : 'a PStack -> bool val top_nonterminal : Term.term PStack -> Absyn.absyn diff --git a/src/parse/qbuf.sml b/src/parse/qbuf.sml index 0be47b5a36..442238ff60 100644 --- a/src/parse/qbuf.sml +++ b/src/parse/qbuf.sml @@ -10,7 +10,7 @@ struct (* qbufs are references to quadruples: field #1 : the optional lexing function for a current QUOTE part of the quotation - field #2 : the "current token" and its location (advance recalculates this) + field #2 : the "current token" and its location (advance recalculates this) field #3 : the first fragment number of the remainder frag list field #4 : the frag list that we're consuming. From c517f68317bb72fc165ccdd77f1e448f34c7190c Mon Sep 17 00:00:00 2001 From: Piotr Trojanek Date: Fri, 24 Oct 2014 16:05:58 +0100 Subject: [PATCH 018/718] doc: full stop at the end of SYNOPSIS sections --- help/Docfiles/Defn.tgoal.doc | 2 +- help/Docfiles/Feedback.HOL_ERR.doc | 2 +- help/Docfiles/Feedback.Raise.doc | 2 +- help/Docfiles/IndDefRules.doc | 2 +- help/Docfiles/Lib.append.doc | 2 +- help/Docfiles/Lib.cons.doc | 2 +- help/Docfiles/Lib.doc | 2 +- help/Docfiles/Parse.minus2.doc | 2 +- help/Docfiles/Term.list_mk_binder.doc | 2 +- help/Docfiles/TypeBase.doc | 2 +- 10 files changed, 10 insertions(+), 10 deletions(-) diff --git a/help/Docfiles/Defn.tgoal.doc b/help/Docfiles/Defn.tgoal.doc index d7c7c9d564..a9994d3249 100644 --- a/help/Docfiles/Defn.tgoal.doc +++ b/help/Docfiles/Defn.tgoal.doc @@ -3,7 +3,7 @@ \TYPE {tgoal : defn -> proofs} \SYNOPSIS -Set up a termination proof +Set up a termination proof. \KEYWORDS termination, goalstack. diff --git a/help/Docfiles/Feedback.HOL_ERR.doc b/help/Docfiles/Feedback.HOL_ERR.doc index 6c301893cf..f86ce7d688 100644 --- a/help/Docfiles/Feedback.HOL_ERR.doc +++ b/help/Docfiles/Feedback.HOL_ERR.doc @@ -6,7 +6,7 @@ HOL_ERR : {message : string, origin_function : string, \ELTYPE \SYNOPSIS -Standard HOL exception +Standard HOL exception. \KEYWORDS exception, error diff --git a/help/Docfiles/Feedback.Raise.doc b/help/Docfiles/Feedback.Raise.doc index 7b8711e1e1..a3431b89cd 100644 --- a/help/Docfiles/Feedback.Raise.doc +++ b/help/Docfiles/Feedback.Raise.doc @@ -3,7 +3,7 @@ \TYPE {Raise : exn -> 'a} \SYNOPSIS -Print an exception before re-raising it +Print an exception before re-raising it. \KEYWORDS I/O, exception diff --git a/help/Docfiles/IndDefRules.doc b/help/Docfiles/IndDefRules.doc index c574b278e6..66ef7d017c 100644 --- a/help/Docfiles/IndDefRules.doc +++ b/help/Docfiles/IndDefRules.doc @@ -3,7 +3,7 @@ \TYPE {structure IndDefRules} \SYNOPSIS -Tom Melham's inference support for inductive definitions +Tom Melham's inference support for inductive definitions. \KEYWORDS inductive diff --git a/help/Docfiles/Lib.append.doc b/help/Docfiles/Lib.append.doc index fb0f1812f3..b80ad6354b 100644 --- a/help/Docfiles/Lib.append.doc +++ b/help/Docfiles/Lib.append.doc @@ -6,7 +6,7 @@ Curry \SYNOPSIS -Curried form of list append +Curried form of list append. \DESCRIBE The function {append} is a curried form of the standard operation for diff --git a/help/Docfiles/Lib.cons.doc b/help/Docfiles/Lib.cons.doc index b0bc03c947..53290cc549 100644 --- a/help/Docfiles/Lib.cons.doc +++ b/help/Docfiles/Lib.cons.doc @@ -3,7 +3,7 @@ \TYPE {cons : 'a -> 'a list -> 'a list} \SYNOPSIS -Curried form of list cons operation +Curried form of list cons operation. \KEYWORDS Curry diff --git a/help/Docfiles/Lib.doc b/help/Docfiles/Lib.doc index ba9701f6d5..d1bd020313 100644 --- a/help/Docfiles/Lib.doc +++ b/help/Docfiles/Lib.doc @@ -3,7 +3,7 @@ \TYPE {structure Lib} \SYNOPSIS -Collection of commonly used functions +Collection of commonly used functions. \DESCRIBE {Lib} is a collection of functions that have been found useful in diff --git a/help/Docfiles/Parse.minus2.doc b/help/Docfiles/Parse.minus2.doc index 67404900bf..b9ef5aa91d 100644 --- a/help/Docfiles/Parse.minus2.doc +++ b/help/Docfiles/Parse.minus2.doc @@ -3,7 +3,7 @@ \TYPE {-- : term quotation -> 'a -> term} \SYNOPSIS -Parses a quotation into a term value +Parses a quotation into a term value. \KEYWORDS Parsing diff --git a/help/Docfiles/Term.list_mk_binder.doc b/help/Docfiles/Term.list_mk_binder.doc index 00018ebd7b..e26b5b19ff 100644 --- a/help/Docfiles/Term.list_mk_binder.doc +++ b/help/Docfiles/Term.list_mk_binder.doc @@ -3,7 +3,7 @@ \TYPE {list_mk_binder : term option -> term list * term -> term} \SYNOPSIS -Performs a sequence of variable binding operations on a term +Performs a sequence of variable binding operations on a term. \KEYWORDS variable, binding, abstraction. diff --git a/help/Docfiles/TypeBase.doc b/help/Docfiles/TypeBase.doc index 3141dfe39e..0d448ecf60 100644 --- a/help/Docfiles/TypeBase.doc +++ b/help/Docfiles/TypeBase.doc @@ -3,7 +3,7 @@ \TYPE {structure TypeBase} \SYNOPSIS -A database of facts stemming from datatype declarations +A database of facts stemming from datatype declarations. \KEYWORDS type, datatype, constructor, induction, primitive recursion. From 162412b0c047309dbc593441a9d805178fdd4f4a Mon Sep 17 00:00:00 2001 From: Piotr Trojanek Date: Wed, 29 Oct 2014 10:05:17 +0000 Subject: [PATCH 019/718] help: rewrite as parallel structures (firstly, secondly, thirdly) --- help/Docfiles/bossLib.srw_ss.doc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/help/Docfiles/bossLib.srw_ss.doc b/help/Docfiles/bossLib.srw_ss.doc index 2d1839fabd..dff6e01932 100644 --- a/help/Docfiles/bossLib.srw_ss.doc +++ b/help/Docfiles/bossLib.srw_ss.doc @@ -17,7 +17,7 @@ enter the {TypeBase}, and as theories are loaded. For this reason, it can't be accessed as a simple value, but is instead hidden behind a function. -The value behind {srw_ss()} can change in three ways. First, whenever +The value behind {srw_ss()} can change in three ways. Firstly, whenever a type enters the {TypeBase}, the type's associated simplification theorems (accessible directly using the function {TypeBase.simpls_of}) are all added to the {simpset}. This ensures that the "obvious" From d92257e501242c792f857e8fc5520257b98cb977 Mon Sep 17 00:00:00 2001 From: Piotr Trojanek Date: Fri, 31 Oct 2014 20:22:22 +0000 Subject: [PATCH 020/718] Prim_rec: whitespace cleanup in both .sig and .doc --- help/Docfiles/Prim_rec.new_recursive_definition.doc | 4 ++-- src/1/Prim_rec.sig | 13 ++++++------- 2 files changed, 8 insertions(+), 9 deletions(-) diff --git a/help/Docfiles/Prim_rec.new_recursive_definition.doc b/help/Docfiles/Prim_rec.new_recursive_definition.doc index dd842a9e2e..09d979cc92 100644 --- a/help/Docfiles/Prim_rec.new_recursive_definition.doc +++ b/help/Docfiles/Prim_rec.new_recursive_definition.doc @@ -41,7 +41,7 @@ variables {vsi}. If {tm} is a conjunction of clauses, as described above, then evaluating: { - new_recursive_definition{name=name, rec_axiom=th,def=tm} + new_recursive_definition{name=name, rec_axiom=th, def=tm} } automatically proves the existence of a function {fn} that satisfies the defining equations supplied as the fourth argument, and then declares a new @@ -116,7 +116,7 @@ of a function {Label} which extracts the label from a leaf node. The value of - val Label = new_recursive_definition {name = "Label", rec_axiom = th, - def = --`Label (LEAF (x:'a)) = x`--}; + def = --`Label (LEAF (x:'a)) = x`--}; > val Label = |- !x. Label (LEAF x) = x : thm } Curried functions can also be defined, and the recursion can be on diff --git a/src/1/Prim_rec.sig b/src/1/Prim_rec.sig index fa9328f9bc..13b5cb489d 100644 --- a/src/1/Prim_rec.sig +++ b/src/1/Prim_rec.sig @@ -3,12 +3,12 @@ sig include Abbrev - (*----------------------------------------------------------------------- - Returns the types defined by an axiom. Does not return type - operators that are applied to other types that are defined in - the axiom. This is a test for detecting nested recursion, where - the operator must already have an axiom elsewhere. - ------------------------------------------------------------------------*) + (*------------------------------------------------------------------------ + Returns the types defined by an axiom. Does not return type + operators that are applied to other types that are defined in + the axiom. This is a test for detecting nested recursion, where + the operator must already have an axiom elsewhere. + -------------------------------------------------------------------------*) val doms_of_tyaxiom : thm -> hol_type list @@ -20,7 +20,6 @@ sig val type_constructors : thm -> string -> term list val type_constructors_with_args : thm -> string -> term list - val new_recursive_definition : {name:string, rec_axiom:thm, def:term} -> thm (*------------------------------------------------------------------------ From b6f807a8cf7167d767506ea05c448376135b604d Mon Sep 17 00:00:00 2001 From: Piotr Trojanek Date: Fri, 7 Nov 2014 10:41:09 +0000 Subject: [PATCH 021/718] SML whitespace cleanup --- src/proofman/goalStack.sig | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/proofman/goalStack.sig b/src/proofman/goalStack.sig index a62442cf56..28465da3d9 100644 --- a/src/proofman/goalStack.sig +++ b/src/proofman/goalStack.sig @@ -24,4 +24,4 @@ sig val pp_gstk : ppstream -> gstk -> unit val set_goal_pp : (ppstream -> goal -> unit) -> (ppstream -> goal -> unit) - end +end From d88eb17f25bf2800de5a5c852051092fecd95bb6 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Fri, 7 Nov 2014 11:03:21 +0000 Subject: [PATCH 022/718] TeX notation for monad syntax I thought I had done this before but apparently not. Make do and od keywords (this was already the case for parmonadsyntax, now it also works for monadsyntax). Also, fix (I hope - correct if I'm wrong) parmonadsyntax's length for the left arrow. --- src/monad/monadsyntax.sml | 2 ++ src/monad/parmonadsyntax.sml | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/src/monad/monadsyntax.sml b/src/monad/monadsyntax.sml index e7b21c2138..bec3689ffc 100644 --- a/src/monad/monadsyntax.sml +++ b/src/monad/monadsyntax.sml @@ -202,5 +202,7 @@ val _ = temp_overload_on ("return", mkc "UNIT") val _ = TexTokenMap.temp_TeX_notation {hol = "<-", TeX = ("\\HOLTokenLeftmap", 1)} +val _ = TexTokenMap.temp_TeX_notation {hol = "do", TeX = (" \\HOLKeyword{do}", 2)} +val _ = TexTokenMap.temp_TeX_notation {hol = "od", TeX = (" \\HOLKeyword{od}", 2)} end (* struct *) diff --git a/src/monad/parmonadsyntax.sml b/src/monad/parmonadsyntax.sml index 01845e348a..51e29bdfb0 100644 --- a/src/monad/parmonadsyntax.sml +++ b/src/monad/parmonadsyntax.sml @@ -259,7 +259,7 @@ end val _ = temp_add_user_printer ("parmonadsyntax.print_monads", ``x:'a``, print_monads) -val _ = TexTokenMap.temp_TeX_notation {hol = " <-", TeX = (" \\HOLTokenLeftmap{}", 2)} +val _ = TexTokenMap.temp_TeX_notation {hol = " <-", TeX = (" \\HOLTokenLeftmap{}", 1)} val _ = TexTokenMap.temp_TeX_notation {hol = "do", TeX = (" \\HOLKeyword{do}", 2)} val _ = TexTokenMap.temp_TeX_notation {hol = "od", TeX = (" \\HOLKeyword{od}", 2)} end (* struct *) From 0c2c180e432ce05eed11f37b53f304fc9e22a266 Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Fri, 7 Nov 2014 13:03:11 +0000 Subject: [PATCH 023/718] Update the MIPS example. The model should detect more instances of branches in the branch delay slot, which is categorised as being unpredictable. --- examples/l3-machine-code/common/Import.sml | 2 - examples/l3-machine-code/mips/model/mips.sig | 222 +- examples/l3-machine-code/mips/model/mips.sml | 3179 +++-------------- .../l3-machine-code/mips/model/mipsScript.sml | 1050 +++--- .../mips/prog/mips_progLib.sml | 75 +- .../mips/step/mips_stepLib.sml | 76 +- .../mips/step/mips_stepScript.sml | 105 +- 7 files changed, 1110 insertions(+), 3599 deletions(-) diff --git a/examples/l3-machine-code/common/Import.sml b/examples/l3-machine-code/common/Import.sml index 54db70e064..368e31e166 100644 --- a/examples/l3-machine-code/common/Import.sml +++ b/examples/l3-machine-code/common/Import.sml @@ -664,8 +664,6 @@ local then wordsSyntax.mk_word_reverse else listSyntax.mk_reverse) tm - val c_mk_comb = Lib.curry Term.mk_comb - fun enum2num ty = Lib.with_exn mk_local_const (typeName ty ^ "2num", Type.--> (ty, numLib.num)) diff --git a/examples/l3-machine-code/mips/model/mips.sig b/examples/l3-machine-code/mips/model/mips.sig index 4b25fc7513..83cffc737c 100644 --- a/examples/l3-machine-code/mips/model/mips.sig +++ b/examples/l3-machine-code/mips/model/mips.sig @@ -1,4 +1,4 @@ -(* mips - generated by L<3> - Wed Oct 15 14:19:50 2014 *) +(* mips - generated by L<3> - Wed Oct 29 16:00:41 2014 *) signature mips = sig @@ -87,40 +87,6 @@ datatype IorD = INSTRUCTION | DATA datatype LorS = LOAD | STORE -type PIC_Config_Reg = - { EN: bool, IRQ: BitsN.nbit, pic_config_reg'rst: BitsN.nbit } - -type PIC = - { base_address: BitsN.nbit, config_regs: PIC_Config_Reg Map.map, - external_intrs: BitsN.nbit, ip_bits: BitsN.nbit, - mips_ip_bits: BitsN.nbit } - -type JTAG_UART_data = - { RAVAIL: BitsN.nbit, RVALID: bool, RW_DATA: BitsN.nbit, - jtag_uart_data'rst: BitsN.nbit } - -type JTAG_UART_control = - { AC: bool, RE: bool, RI: bool, WE: bool, WI: bool, WSPACE: BitsN.nbit, - jtag_uart_control'rst: BitsN.nbit } - -type JTAG_UART = - { base_address: BitsN.nbit, control: JTAG_UART_control, - data: JTAG_UART_data, read_fifo: BitsN.nbit list, - read_threshold: Nat.nat, write_fifo: BitsN.nbit list, - write_threshold: Nat.nat } - -datatype event = - w_c0 of BitsN.nbit * BitsN.nbit - | w_gpr of BitsN.nbit * BitsN.nbit - | w_hi of BitsN.nbit - | w_lo of BitsN.nbit - | w_mem of BitsN.nbit * (BitsN.nbit * (BitsN.nbit * BitsN.nbit)) - -type TLBEntry = - { ASID: BitsN.nbit, C0: BitsN.nbit, C1: BitsN.nbit, D0: bool, D1: bool, - G: bool, Mask: BitsN.nbit, PFN0: BitsN.nbit, PFN1: BitsN.nbit, - R: BitsN.nbit, V0: bool, V1: bool, VPN2: BitsN.nbit } - datatype Branch = BEQ of BitsN.nbit * (BitsN.nbit * BitsN.nbit) | BEQL of BitsN.nbit * (BitsN.nbit * BitsN.nbit) @@ -311,23 +277,16 @@ val LorSToString:LorS-> string end -val BranchDelay: (BitsN.nbit option) ref -val BranchTo: (BitsN.nbit option) ref +val BranchDelay: ((BitsN.nbit option) option) ref +val BranchTo: ((bool * BitsN.nbit) option) ref val CP0: CP0 ref -val JTAG_UART: JTAG_UART ref val LLbit: (bool option) ref val MEM: (BitsN.nbit Map.map) ref val PC: BitsN.nbit ref -val PIC: PIC ref -val TLB_assoc: (TLBEntry Map.map) ref -val TLB_direct: (TLBEntry Map.map) ref -val UNPREDICTABLE_HI: (unit -> unit) ref -val UNPREDICTABLE_LO: (unit -> unit) ref val exceptionSignalled: bool ref val gpr: (BitsN.nbit Map.map) ref val hi: (BitsN.nbit option) ref val lo: (BitsN.nbit option) ref -val log: (event list) ref val Index_Index_rupd: Index * BitsN.nbit -> Index val Index_P_rupd: Index * bool -> Index val Index_index'rst_rupd: Index * BitsN.nbit -> Index @@ -471,122 +430,6 @@ val CP0_Status_rupd: CP0 * StatusRegister -> CP0 val CP0_UsrLocal_rupd: CP0 * BitsN.nbit -> CP0 val CP0_Wired_rupd: CP0 * Wired -> CP0 val CP0_XContext_rupd: CP0 * XContext -> CP0 -val PIC_Config_Reg_EN_rupd: PIC_Config_Reg * bool -> PIC_Config_Reg -val PIC_Config_Reg_IRQ_rupd: PIC_Config_Reg * BitsN.nbit -> PIC_Config_Reg -val PIC_Config_Reg_pic_config_reg'rst_rupd: - PIC_Config_Reg * BitsN.nbit -> PIC_Config_Reg -val PIC_base_address_rupd: PIC * BitsN.nbit -> PIC -val PIC_config_regs_rupd: PIC * (PIC_Config_Reg Map.map) -> PIC -val PIC_external_intrs_rupd: PIC * BitsN.nbit -> PIC -val PIC_ip_bits_rupd: PIC * BitsN.nbit -> PIC -val PIC_mips_ip_bits_rupd: PIC * BitsN.nbit -> PIC -val JTAG_UART_data_RAVAIL_rupd: - JTAG_UART_data * BitsN.nbit -> JTAG_UART_data -val JTAG_UART_data_RVALID_rupd: JTAG_UART_data * bool -> JTAG_UART_data -val JTAG_UART_data_RW_DATA_rupd: - JTAG_UART_data * BitsN.nbit -> JTAG_UART_data -val JTAG_UART_data_jtag_uart_data'rst_rupd: - JTAG_UART_data * BitsN.nbit -> JTAG_UART_data -val JTAG_UART_control_AC_rupd: - JTAG_UART_control * bool -> JTAG_UART_control -val JTAG_UART_control_RE_rupd: - JTAG_UART_control * bool -> JTAG_UART_control -val JTAG_UART_control_RI_rupd: - JTAG_UART_control * bool -> JTAG_UART_control -val JTAG_UART_control_WE_rupd: - JTAG_UART_control * bool -> JTAG_UART_control -val JTAG_UART_control_WI_rupd: - JTAG_UART_control * bool -> JTAG_UART_control -val JTAG_UART_control_WSPACE_rupd: - JTAG_UART_control * BitsN.nbit -> JTAG_UART_control -val JTAG_UART_control_jtag_uart_control'rst_rupd: - JTAG_UART_control * BitsN.nbit -> JTAG_UART_control -val JTAG_UART_base_address_rupd: JTAG_UART * BitsN.nbit -> JTAG_UART -val JTAG_UART_control_rupd: JTAG_UART * JTAG_UART_control -> JTAG_UART -val JTAG_UART_data_rupd: JTAG_UART * JTAG_UART_data -> JTAG_UART -val JTAG_UART_read_fifo_rupd: JTAG_UART * (BitsN.nbit list) -> JTAG_UART -val JTAG_UART_read_threshold_rupd: JTAG_UART * Nat.nat -> JTAG_UART -val JTAG_UART_write_fifo_rupd: JTAG_UART * (BitsN.nbit list) -> JTAG_UART -val JTAG_UART_write_threshold_rupd: JTAG_UART * Nat.nat -> JTAG_UART -val TLBEntry_ASID_rupd: TLBEntry * BitsN.nbit -> TLBEntry -val TLBEntry_C0_rupd: TLBEntry * BitsN.nbit -> TLBEntry -val TLBEntry_C1_rupd: TLBEntry * BitsN.nbit -> TLBEntry -val TLBEntry_D0_rupd: TLBEntry * bool -> TLBEntry -val TLBEntry_D1_rupd: TLBEntry * bool -> TLBEntry -val TLBEntry_G_rupd: TLBEntry * bool -> TLBEntry -val TLBEntry_Mask_rupd: TLBEntry * BitsN.nbit -> TLBEntry -val TLBEntry_PFN0_rupd: TLBEntry * BitsN.nbit -> TLBEntry -val TLBEntry_PFN1_rupd: TLBEntry * BitsN.nbit -> TLBEntry -val TLBEntry_R_rupd: TLBEntry * BitsN.nbit -> TLBEntry -val TLBEntry_V0_rupd: TLBEntry * bool -> TLBEntry -val TLBEntry_V1_rupd: TLBEntry * bool -> TLBEntry -val TLBEntry_VPN2_rupd: TLBEntry * BitsN.nbit -> TLBEntry -val boolify'64: - BitsN.nbit -> - bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - (bool * - bool)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) val boolify'32: BitsN.nbit -> bool * @@ -703,38 +546,6 @@ val KernelMode: unit -> bool val BigEndianMem: unit -> bool val ReverseEndian: unit -> BitsN.nbit val BigEndianCPU: unit -> BitsN.nbit -val rec'PIC_Config_Reg: BitsN.nbit -> PIC_Config_Reg -val reg'PIC_Config_Reg: PIC_Config_Reg -> BitsN.nbit -val write'rec'PIC_Config_Reg: (BitsN.nbit * PIC_Config_Reg) -> BitsN.nbit -val write'reg'PIC_Config_Reg: - (PIC_Config_Reg * BitsN.nbit) -> PIC_Config_Reg -val PIC_update: unit -> unit -val PIC_initialise: Nat.nat -> unit -val PIC_load: BitsN.nbit -> BitsN.nbit -val PIC_store: (BitsN.nbit * (BitsN.nbit * BitsN.nbit)) -> unit -val rec'JTAG_UART_data: BitsN.nbit -> JTAG_UART_data -val reg'JTAG_UART_data: JTAG_UART_data -> BitsN.nbit -val write'rec'JTAG_UART_data: (BitsN.nbit * JTAG_UART_data) -> BitsN.nbit -val write'reg'JTAG_UART_data: - (JTAG_UART_data * BitsN.nbit) -> JTAG_UART_data -val rec'JTAG_UART_control: BitsN.nbit -> JTAG_UART_control -val reg'JTAG_UART_control: JTAG_UART_control -> BitsN.nbit -val write'rec'JTAG_UART_control: - (BitsN.nbit * JTAG_UART_control) -> BitsN.nbit -val write'reg'JTAG_UART_control: - (JTAG_UART_control * BitsN.nbit) -> JTAG_UART_control -val JTAG_UART_update_interrupt_bit: unit -> unit -val JTAG_UART_load: unit -> unit -val JTAG_UART_input: (BitsN.nbit list) -> unit -val JTAG_UART_store: (BitsN.nbit * BitsN.nbit) -> unit -val JTAG_UART_output: unit -> (BitsN.nbit list) -val JTAG_UART_initialise: Nat.nat -> unit -val PSIZE: Nat.nat -val mark: event -> unit -val unmark: unit -> unit -val flip_endian_word: BitsN.nbit -> BitsN.nbit -val flip_endian_dword: BitsN.nbit -> BitsN.nbit -val TLBEntries: Nat.nat val GPR: BitsN.nbit -> BitsN.nbit val write'GPR: (BitsN.nbit * BitsN.nbit) -> unit val HI: unit -> BitsN.nbit @@ -744,35 +555,18 @@ val write'LO: BitsN.nbit -> unit val CPR: (Nat.nat * (BitsN.nbit * BitsN.nbit)) -> BitsN.nbit val write'CPR: (BitsN.nbit * (Nat.nat * (BitsN.nbit * BitsN.nbit))) -> unit -val LookupTLB: (BitsN.nbit * BitsN.nbit) -> ((BitsN.nbit * TLBEntry) list) -val ModifyTLB: TLBEntry -> TLBEntry -val SignalTLBException: - (ExceptionType * (BitsN.nbit * BitsN.nbit)) -> (BitsN.nbit * BitsN.nbit) -val CheckSegment: - BitsN.nbit -> (((BitsN.nbit * BitsN.nbit) option) * bool) +val PSIZE: Nat.nat val AddressTranslation: (BitsN.nbit * (IorD * LorS)) -> (BitsN.nbit * BitsN.nbit) val LoadMemory: (BitsN.nbit * (BitsN.nbit * (BitsN.nbit * (BitsN.nbit * IorD)))) -> BitsN.nbit -val loadWord32: BitsN.nbit -> BitsN.nbit val StoreMemory: (BitsN.nbit * (BitsN.nbit * (BitsN.nbit * (BitsN.nbit * (BitsN.nbit * IorD))))) -> unit -val dfn'TLBP: unit -> unit -val dfn'TLBR: unit -> unit -val dfn'TLBWI: unit -> unit -val dfn'TLBWR: unit -> unit -val dfn'CACHE: (BitsN.nbit * (BitsN.nbit * BitsN.nbit)) -> unit -val dfn'RDHWR: (BitsN.nbit * BitsN.nbit) -> unit val Fetch: unit -> (BitsN.nbit option) -val initTLB: unit -> TLBEntry -val addTLB: (BitsN.nbit * BitsN.nbit) -> unit -val initMips: (Nat.nat * Nat.nat) -> unit -val done: unit -> bool val NotWordValue: BitsN.nbit -> bool -val CheckBranch: unit -> unit val dfn'ADDI: (BitsN.nbit * (BitsN.nbit * BitsN.nbit)) -> unit val dfn'ADDIU: (BitsN.nbit * (BitsN.nbit * BitsN.nbit)) -> unit val dfn'DADDI: (BitsN.nbit * (BitsN.nbit * BitsN.nbit)) -> unit @@ -886,6 +680,8 @@ val dfn'J: BitsN.nbit -> unit val dfn'JAL: BitsN.nbit -> unit val dfn'JR: BitsN.nbit -> unit val dfn'JALR: (BitsN.nbit * BitsN.nbit) -> unit +val ConditionalBranch: (bool * BitsN.nbit) -> unit +val ConditionalBranchLikely: (bool * BitsN.nbit) -> unit val dfn'BEQ: (BitsN.nbit * (BitsN.nbit * BitsN.nbit)) -> unit val dfn'BNE: (BitsN.nbit * (BitsN.nbit * BitsN.nbit)) -> unit val dfn'BLEZ: (BitsN.nbit * BitsN.nbit) -> unit @@ -903,6 +699,12 @@ val dfn'BGEZL: (BitsN.nbit * BitsN.nbit) -> unit val dfn'BLTZALL: (BitsN.nbit * BitsN.nbit) -> unit val dfn'BGEZALL: (BitsN.nbit * BitsN.nbit) -> unit val dfn'WAIT: unit +val dfn'TLBP: unit -> unit +val dfn'TLBR: unit -> unit +val dfn'TLBWI: unit -> unit +val dfn'TLBWR: unit -> unit +val dfn'CACHE: (BitsN.nbit * (BitsN.nbit * BitsN.nbit)) -> unit +val dfn'RDHWR: (BitsN.nbit * BitsN.nbit) -> unit val dfn'ReservedInstruction: unit -> unit val dfn'Unpredictable: unit -> unit val Run: instruction -> unit diff --git a/examples/l3-machine-code/mips/model/mips.sml b/examples/l3-machine-code/mips/model/mips.sml index 62b7434db3..2f641f8a45 100644 --- a/examples/l3-machine-code/mips/model/mips.sml +++ b/examples/l3-machine-code/mips/model/mips.sml @@ -1,4 +1,4 @@ -(* mips - generated by L<3> - Wed Oct 15 14:19:50 2014 *) +(* mips - generated by L<3> - Wed Oct 29 16:00:41 2014 *) structure mips :> mips = struct @@ -87,40 +87,6 @@ datatype IorD = INSTRUCTION | DATA datatype LorS = LOAD | STORE -type PIC_Config_Reg = - { EN: bool, IRQ: BitsN.nbit, pic_config_reg'rst: BitsN.nbit } - -type PIC = - { base_address: BitsN.nbit, config_regs: PIC_Config_Reg Map.map, - external_intrs: BitsN.nbit, ip_bits: BitsN.nbit, - mips_ip_bits: BitsN.nbit } - -type JTAG_UART_data = - { RAVAIL: BitsN.nbit, RVALID: bool, RW_DATA: BitsN.nbit, - jtag_uart_data'rst: BitsN.nbit } - -type JTAG_UART_control = - { AC: bool, RE: bool, RI: bool, WE: bool, WI: bool, WSPACE: BitsN.nbit, - jtag_uart_control'rst: BitsN.nbit } - -type JTAG_UART = - { base_address: BitsN.nbit, control: JTAG_UART_control, - data: JTAG_UART_data, read_fifo: BitsN.nbit list, - read_threshold: Nat.nat, write_fifo: BitsN.nbit list, - write_threshold: Nat.nat } - -datatype event = - w_c0 of BitsN.nbit * BitsN.nbit - | w_gpr of BitsN.nbit * BitsN.nbit - | w_hi of BitsN.nbit - | w_lo of BitsN.nbit - | w_mem of BitsN.nbit * (BitsN.nbit * (BitsN.nbit * BitsN.nbit)) - -type TLBEntry = - { ASID: BitsN.nbit, C0: BitsN.nbit, C1: BitsN.nbit, D0: bool, D1: bool, - G: bool, Mask: BitsN.nbit, PFN0: BitsN.nbit, PFN1: BitsN.nbit, - R: BitsN.nbit, V0: bool, V1: bool, VPN2: BitsN.nbit } - datatype Branch = BEQ of BitsN.nbit * (BitsN.nbit * BitsN.nbit) | BEQL of BitsN.nbit * (BitsN.nbit * BitsN.nbit) @@ -1216,224 +1182,6 @@ fun CP0_XContext_rupd ({BadVAddr, Cause, Compare, Config, Config1, Status = Status, UsrLocal = UsrLocal, Wired = Wired, XContext = x'} : CP0 -fun PIC_Config_Reg_EN_rupd ({EN, IRQ, pic_config_reg'rst} - : PIC_Config_Reg, x') = - {EN = x', IRQ = IRQ, pic_config_reg'rst = pic_config_reg'rst} - : PIC_Config_Reg - -fun PIC_Config_Reg_IRQ_rupd ({EN, IRQ, pic_config_reg'rst} - : PIC_Config_Reg, x') = - {EN = EN, IRQ = x', pic_config_reg'rst = pic_config_reg'rst} - : PIC_Config_Reg - -fun PIC_Config_Reg_pic_config_reg'rst_rupd ({EN, IRQ, pic_config_reg'rst} - : PIC_Config_Reg, x') = {EN = EN, IRQ = IRQ, pic_config_reg'rst = x'} - : PIC_Config_Reg - -fun PIC_base_address_rupd ({base_address, config_regs, external_intrs, - ip_bits, mips_ip_bits}: PIC, x') = - {base_address = x', config_regs = config_regs, - external_intrs = external_intrs, ip_bits = ip_bits, - mips_ip_bits = mips_ip_bits}: PIC - -fun PIC_config_regs_rupd ({base_address, config_regs, external_intrs, - ip_bits, mips_ip_bits}: PIC, x') = - {base_address = base_address, config_regs = x', - external_intrs = external_intrs, ip_bits = ip_bits, - mips_ip_bits = mips_ip_bits}: PIC - -fun PIC_external_intrs_rupd ({base_address, config_regs, external_intrs, - ip_bits, mips_ip_bits}: PIC, x') = - {base_address = base_address, config_regs = config_regs, - external_intrs = x', ip_bits = ip_bits, mips_ip_bits = mips_ip_bits} - : PIC - -fun PIC_ip_bits_rupd ({base_address, config_regs, external_intrs, ip_bits, - mips_ip_bits}: PIC, x') = - {base_address = base_address, config_regs = config_regs, - external_intrs = external_intrs, ip_bits = x', - mips_ip_bits = mips_ip_bits}: PIC - -fun PIC_mips_ip_bits_rupd ({base_address, config_regs, external_intrs, - ip_bits, mips_ip_bits}: PIC, x') = - {base_address = base_address, config_regs = config_regs, - external_intrs = external_intrs, ip_bits = ip_bits, mips_ip_bits = x'} - : PIC - -fun JTAG_UART_data_RAVAIL_rupd ({RAVAIL, RVALID, RW_DATA, - jtag_uart_data'rst}: JTAG_UART_data, x') = - {RAVAIL = x', RVALID = RVALID, RW_DATA = RW_DATA, - jtag_uart_data'rst = jtag_uart_data'rst}: JTAG_UART_data - -fun JTAG_UART_data_RVALID_rupd ({RAVAIL, RVALID, RW_DATA, - jtag_uart_data'rst}: JTAG_UART_data, x') = - {RAVAIL = RAVAIL, RVALID = x', RW_DATA = RW_DATA, - jtag_uart_data'rst = jtag_uart_data'rst}: JTAG_UART_data - -fun JTAG_UART_data_RW_DATA_rupd ({RAVAIL, RVALID, RW_DATA, - jtag_uart_data'rst}: JTAG_UART_data, x') = - {RAVAIL = RAVAIL, RVALID = RVALID, RW_DATA = x', - jtag_uart_data'rst = jtag_uart_data'rst}: JTAG_UART_data - -fun JTAG_UART_data_jtag_uart_data'rst_rupd ({RAVAIL, RVALID, RW_DATA, - jtag_uart_data'rst}: JTAG_UART_data, x') = - {RAVAIL = RAVAIL, RVALID = RVALID, RW_DATA = RW_DATA, - jtag_uart_data'rst = x'}: JTAG_UART_data - -fun JTAG_UART_control_AC_rupd ({AC, RE, RI, WE, WI, WSPACE, - jtag_uart_control'rst}: JTAG_UART_control, x') = - {AC = x', RE = RE, RI = RI, WE = WE, WI = WI, WSPACE = WSPACE, - jtag_uart_control'rst = jtag_uart_control'rst}: JTAG_UART_control - -fun JTAG_UART_control_RE_rupd ({AC, RE, RI, WE, WI, WSPACE, - jtag_uart_control'rst}: JTAG_UART_control, x') = - {AC = AC, RE = x', RI = RI, WE = WE, WI = WI, WSPACE = WSPACE, - jtag_uart_control'rst = jtag_uart_control'rst}: JTAG_UART_control - -fun JTAG_UART_control_RI_rupd ({AC, RE, RI, WE, WI, WSPACE, - jtag_uart_control'rst}: JTAG_UART_control, x') = - {AC = AC, RE = RE, RI = x', WE = WE, WI = WI, WSPACE = WSPACE, - jtag_uart_control'rst = jtag_uart_control'rst}: JTAG_UART_control - -fun JTAG_UART_control_WE_rupd ({AC, RE, RI, WE, WI, WSPACE, - jtag_uart_control'rst}: JTAG_UART_control, x') = - {AC = AC, RE = RE, RI = RI, WE = x', WI = WI, WSPACE = WSPACE, - jtag_uart_control'rst = jtag_uart_control'rst}: JTAG_UART_control - -fun JTAG_UART_control_WI_rupd ({AC, RE, RI, WE, WI, WSPACE, - jtag_uart_control'rst}: JTAG_UART_control, x') = - {AC = AC, RE = RE, RI = RI, WE = WE, WI = x', WSPACE = WSPACE, - jtag_uart_control'rst = jtag_uart_control'rst}: JTAG_UART_control - -fun JTAG_UART_control_WSPACE_rupd ({AC, RE, RI, WE, WI, WSPACE, - jtag_uart_control'rst}: JTAG_UART_control, x') = - {AC = AC, RE = RE, RI = RI, WE = WE, WI = WI, WSPACE = x', - jtag_uart_control'rst = jtag_uart_control'rst}: JTAG_UART_control - -fun JTAG_UART_control_jtag_uart_control'rst_rupd ({AC, RE, RI, WE, WI, - WSPACE, jtag_uart_control'rst}: JTAG_UART_control, x') = - {AC = AC, RE = RE, RI = RI, WE = WE, WI = WI, WSPACE = WSPACE, - jtag_uart_control'rst = x'}: JTAG_UART_control - -fun JTAG_UART_base_address_rupd ({base_address, control, data, read_fifo, - read_threshold, write_fifo, write_threshold}: JTAG_UART, x') = - {base_address = x', control = control, data = data, - read_fifo = read_fifo, read_threshold = read_threshold, - write_fifo = write_fifo, write_threshold = write_threshold}: JTAG_UART - -fun JTAG_UART_control_rupd ({base_address, control, data, read_fifo, - read_threshold, write_fifo, write_threshold}: JTAG_UART, x') = - {base_address = base_address, control = x', data = data, - read_fifo = read_fifo, read_threshold = read_threshold, - write_fifo = write_fifo, write_threshold = write_threshold}: JTAG_UART - -fun JTAG_UART_data_rupd ({base_address, control, data, read_fifo, - read_threshold, write_fifo, write_threshold}: JTAG_UART, x') = - {base_address = base_address, control = control, data = x', - read_fifo = read_fifo, read_threshold = read_threshold, - write_fifo = write_fifo, write_threshold = write_threshold}: JTAG_UART - -fun JTAG_UART_read_fifo_rupd ({base_address, control, data, read_fifo, - read_threshold, write_fifo, write_threshold}: JTAG_UART, x') = - {base_address = base_address, control = control, data = data, - read_fifo = x', read_threshold = read_threshold, - write_fifo = write_fifo, write_threshold = write_threshold}: JTAG_UART - -fun JTAG_UART_read_threshold_rupd ({base_address, control, data, - read_fifo, read_threshold, write_fifo, write_threshold} - : JTAG_UART, x') = - {base_address = base_address, control = control, data = data, - read_fifo = read_fifo, read_threshold = x', write_fifo = write_fifo, - write_threshold = write_threshold}: JTAG_UART - -fun JTAG_UART_write_fifo_rupd ({base_address, control, data, read_fifo, - read_threshold, write_fifo, write_threshold}: JTAG_UART, x') = - {base_address = base_address, control = control, data = data, - read_fifo = read_fifo, read_threshold = read_threshold, - write_fifo = x', write_threshold = write_threshold}: JTAG_UART - -fun JTAG_UART_write_threshold_rupd ({base_address, control, data, - read_fifo, read_threshold, write_fifo, write_threshold} - : JTAG_UART, x') = - {base_address = base_address, control = control, data = data, - read_fifo = read_fifo, read_threshold = read_threshold, - write_fifo = write_fifo, write_threshold = x'}: JTAG_UART - -fun TLBEntry_ASID_rupd ({ASID, C0, C1, D0, D1, G, Mask, PFN0, PFN1, R, V0, - V1, VPN2}: TLBEntry, x') = - {ASID = x', C0 = C0, C1 = C1, D0 = D0, D1 = D1, G = G, Mask = Mask, - PFN0 = PFN0, PFN1 = PFN1, R = R, V0 = V0, V1 = V1, VPN2 = VPN2} - : TLBEntry - -fun TLBEntry_C0_rupd ({ASID, C0, C1, D0, D1, G, Mask, PFN0, PFN1, R, V0, - V1, VPN2}: TLBEntry, x') = - {ASID = ASID, C0 = x', C1 = C1, D0 = D0, D1 = D1, G = G, Mask = Mask, - PFN0 = PFN0, PFN1 = PFN1, R = R, V0 = V0, V1 = V1, VPN2 = VPN2} - : TLBEntry - -fun TLBEntry_C1_rupd ({ASID, C0, C1, D0, D1, G, Mask, PFN0, PFN1, R, V0, - V1, VPN2}: TLBEntry, x') = - {ASID = ASID, C0 = C0, C1 = x', D0 = D0, D1 = D1, G = G, Mask = Mask, - PFN0 = PFN0, PFN1 = PFN1, R = R, V0 = V0, V1 = V1, VPN2 = VPN2} - : TLBEntry - -fun TLBEntry_D0_rupd ({ASID, C0, C1, D0, D1, G, Mask, PFN0, PFN1, R, V0, - V1, VPN2}: TLBEntry, x') = - {ASID = ASID, C0 = C0, C1 = C1, D0 = x', D1 = D1, G = G, Mask = Mask, - PFN0 = PFN0, PFN1 = PFN1, R = R, V0 = V0, V1 = V1, VPN2 = VPN2} - : TLBEntry - -fun TLBEntry_D1_rupd ({ASID, C0, C1, D0, D1, G, Mask, PFN0, PFN1, R, V0, - V1, VPN2}: TLBEntry, x') = - {ASID = ASID, C0 = C0, C1 = C1, D0 = D0, D1 = x', G = G, Mask = Mask, - PFN0 = PFN0, PFN1 = PFN1, R = R, V0 = V0, V1 = V1, VPN2 = VPN2} - : TLBEntry - -fun TLBEntry_G_rupd ({ASID, C0, C1, D0, D1, G, Mask, PFN0, PFN1, R, V0, - V1, VPN2}: TLBEntry, x') = - {ASID = ASID, C0 = C0, C1 = C1, D0 = D0, D1 = D1, G = x', Mask = Mask, - PFN0 = PFN0, PFN1 = PFN1, R = R, V0 = V0, V1 = V1, VPN2 = VPN2} - : TLBEntry - -fun TLBEntry_Mask_rupd ({ASID, C0, C1, D0, D1, G, Mask, PFN0, PFN1, R, V0, - V1, VPN2}: TLBEntry, x') = - {ASID = ASID, C0 = C0, C1 = C1, D0 = D0, D1 = D1, G = G, Mask = x', - PFN0 = PFN0, PFN1 = PFN1, R = R, V0 = V0, V1 = V1, VPN2 = VPN2} - : TLBEntry - -fun TLBEntry_PFN0_rupd ({ASID, C0, C1, D0, D1, G, Mask, PFN0, PFN1, R, V0, - V1, VPN2}: TLBEntry, x') = - {ASID = ASID, C0 = C0, C1 = C1, D0 = D0, D1 = D1, G = G, Mask = Mask, - PFN0 = x', PFN1 = PFN1, R = R, V0 = V0, V1 = V1, VPN2 = VPN2}: TLBEntry - -fun TLBEntry_PFN1_rupd ({ASID, C0, C1, D0, D1, G, Mask, PFN0, PFN1, R, V0, - V1, VPN2}: TLBEntry, x') = - {ASID = ASID, C0 = C0, C1 = C1, D0 = D0, D1 = D1, G = G, Mask = Mask, - PFN0 = PFN0, PFN1 = x', R = R, V0 = V0, V1 = V1, VPN2 = VPN2}: TLBEntry - -fun TLBEntry_R_rupd ({ASID, C0, C1, D0, D1, G, Mask, PFN0, PFN1, R, V0, - V1, VPN2}: TLBEntry, x') = - {ASID = ASID, C0 = C0, C1 = C1, D0 = D0, D1 = D1, G = G, Mask = Mask, - PFN0 = PFN0, PFN1 = PFN1, R = x', V0 = V0, V1 = V1, VPN2 = VPN2} - : TLBEntry - -fun TLBEntry_V0_rupd ({ASID, C0, C1, D0, D1, G, Mask, PFN0, PFN1, R, V0, - V1, VPN2}: TLBEntry, x') = - {ASID = ASID, C0 = C0, C1 = C1, D0 = D0, D1 = D1, G = G, Mask = Mask, - PFN0 = PFN0, PFN1 = PFN1, R = R, V0 = x', V1 = V1, VPN2 = VPN2} - : TLBEntry - -fun TLBEntry_V1_rupd ({ASID, C0, C1, D0, D1, G, Mask, PFN0, PFN1, R, V0, - V1, VPN2}: TLBEntry, x') = - {ASID = ASID, C0 = C0, C1 = C1, D0 = D0, D1 = D1, G = G, Mask = Mask, - PFN0 = PFN0, PFN1 = PFN1, R = R, V0 = V0, V1 = x', VPN2 = VPN2} - : TLBEntry - -fun TLBEntry_VPN2_rupd ({ASID, C0, C1, D0, D1, G, Mask, PFN0, PFN1, R, V0, - V1, VPN2}: TLBEntry, x') = - {ASID = ASID, C0 = C0, C1 = C1, D0 = D0, D1 = D1, G = G, Mask = Mask, - PFN0 = PFN0, PFN1 = PFN1, R = R, V0 = V0, V1 = V1, VPN2 = x'}: TLBEntry - (* ------------------------------------------------------------------------- Exceptions ------------------------------------------------------------------------- *) @@ -1444,9 +1192,9 @@ exception UNPREDICTABLE of string Global variables (state) ------------------------------------------------------------------------- *) -val BranchDelay = ref (NONE): (BitsN.nbit option) ref +val BranchDelay = ref (NONE): ((BitsN.nbit option) option) ref -val BranchTo = ref (NONE): (BitsN.nbit option) ref +val BranchTo = ref (NONE): ((bool * BitsN.nbit) option) ref val CP0 = ref ({BadVAddr = BitsN.B(0x0,64), @@ -1506,56 +1254,13 @@ val CP0 = ref {BadVPN2 = BitsN.B(0x0,27), PTEBase = BitsN.B(0x0,31), R = BitsN.B(0x0,2), xcontext'rst = BitsN.B(0x0,4)}}): CP0 ref -val JTAG_UART = ref - ({base_address = BitsN.B(0x0,37), - control = - {AC = false, RE = false, RI = false, WE = false, WI = false, - WSPACE = BitsN.B(0x0,16), jtag_uart_control'rst = BitsN.B(0x0,11)}, - data = - {RAVAIL = BitsN.B(0x0,16), RVALID = false, RW_DATA = BitsN.B(0x0,8), - jtag_uart_data'rst = BitsN.B(0x0,7)}, read_fifo = [], - read_threshold = 0, write_fifo = [], write_threshold = 0}) - : JTAG_UART ref - val LLbit = ref (NONE): (bool option) ref -val MEM = ref (Map.mkMap(SOME 137438953472,BitsN.B(0x0,64))) +val MEM = ref (Map.mkMap(SOME 18446744073709551616,BitsN.B(0x0,8))) : (BitsN.nbit Map.map) ref val PC = ref (BitsN.B(0x0,64)): BitsN.nbit ref -val PIC = ref - ({base_address = BitsN.B(0x0,37), - config_regs = - Map.mkMap - (SOME 128, - {EN = false, IRQ = BitsN.B(0x0,3), - pic_config_reg'rst = BitsN.B(0x0,60)}), - external_intrs = BitsN.B(0x0,64), ip_bits = BitsN.B(0x0,128), - mips_ip_bits = BitsN.B(0x0,6)}): PIC ref - -val TLB_assoc = ref - (Map.mkMap - (SOME 16, - {ASID = BitsN.B(0x0,8), C0 = BitsN.B(0x0,3), C1 = BitsN.B(0x0,3), - D0 = false, D1 = false, G = false, Mask = BitsN.B(0x0,12), - PFN0 = BitsN.B(0x0,28), PFN1 = BitsN.B(0x0,28), R = BitsN.B(0x0,2), - V0 = false, V1 = false, VPN2 = BitsN.B(0x0,27)})) - : (TLBEntry Map.map) ref - -val TLB_direct = ref - (Map.mkMap - (SOME 128, - {ASID = BitsN.B(0x0,8), C0 = BitsN.B(0x0,3), C1 = BitsN.B(0x0,3), - D0 = false, D1 = false, G = false, Mask = BitsN.B(0x0,12), - PFN0 = BitsN.B(0x0,28), PFN1 = BitsN.B(0x0,28), R = BitsN.B(0x0,2), - V0 = false, V1 = false, VPN2 = BitsN.B(0x0,27)})) - : (TLBEntry Map.map) ref - -val UNPREDICTABLE_HI = ref (L3.K ()): (unit -> unit) ref - -val UNPREDICTABLE_LO = ref (L3.K ()): (unit -> unit) ref - val exceptionSignalled = ref (false): bool ref val gpr = ref (Map.mkMap(SOME 32,BitsN.B(0x0,64))) @@ -1565,87 +1270,10 @@ val hi = ref (NONE): (BitsN.nbit option) ref val lo = ref (NONE): (BitsN.nbit option) ref -val log = ref ([]): (event list) ref - (* ------------------------------------------------------------------------- Main specification ------------------------------------------------------------------------- *) -local - fun tuple'64 [t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16, - t17,t18,t19,t20,t21,t22,t23,t24,t25,t26,t27,t28,t29,t30, - t31,t32,t33,t34,t35,t36,t37,t38,t39,t40,t41,t42,t43,t44, - t45,t46,t47,t48,t49,t50,t51,t52,t53,t54,t55,t56,t57,t58, - t59,t60,t61,t62,t63] = - (t0, - (t1, - (t2, - (t3, - (t4, - (t5, - (t6, - (t7, - (t8, - (t9, - (t10, - (t11, - (t12, - (t13, - (t14, - (t15, - (t16, - (t17, - (t18, - (t19, - (t20, - (t21, - (t22, - (t23, - (t24, - (t25, - (t26, - (t27, - (t28, - (t29, - (t30, - (t31, - (t32, - (t33, - (t34, - (t35, - (t36, - (t37, - (t38, - (t39, - (t40, - (t41, - (t42, - (t43, - (t44, - (t45, - (t46, - (t47, - (t48, - (t49, - (t50, - (t51, - (t52, - (t53, - (t54, - (t55, - (t56, - (t57, - (t58, - (t59, - (t60, - (t61, - (t62, - t63))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) - | tuple'64 (_: bool list) = raise Fail "tuple'64" -in - val boolify'64 = tuple'64 o BitsN.toList -end - local fun tuple'32 [t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16, t17,t18,t19,t20,t21,t22,t23,t24,t25,t26,t27,t28,t29,t30, @@ -3214,26 +2842,26 @@ fun ExceptionCode ExceptionType = fun SignalException ExceptionType = ( if not((#EXL)((#Status) (!CP0))) - then if Option.isSome (!BranchDelay) - then ( CP0 := - (CP0_EPC_rupd((!CP0),BitsN.-((!PC),BitsN.B(0x4,64)))) - ; let - val x0 = (#Cause) (!CP0) - in - CP0 := - (CP0_Cause_rupd - ((!CP0),CauseRegister_BD_rupd(x0,true))) - end - ) - else ( CP0 := (CP0_EPC_rupd((!CP0),(!PC))) - ; let - val x0 = (#Cause) (!CP0) - in - CP0 := - (CP0_Cause_rupd - ((!CP0),CauseRegister_BD_rupd(x0,false))) - end - ) + then case (!BranchDelay) of + Option.SOME(Option.SOME _) => + ( CP0 := + (CP0_EPC_rupd((!CP0),BitsN.-((!PC),BitsN.B(0x4,64)))) + ; let + val x0 = (#Cause) (!CP0) + in + CP0 := + (CP0_Cause_rupd((!CP0),CauseRegister_BD_rupd(x0,true))) + end + ) + | _ => + ( CP0 := (CP0_EPC_rupd((!CP0),(!PC))) + ; let + val x0 = (#Cause) (!CP0) + in + CP0 := + (CP0_Cause_rupd((!CP0),CauseRegister_BD_rupd(x0,false))) + end + ) else () ; let val vectorOffset = @@ -3248,2181 +2876,352 @@ fun SignalException ExceptionType = val x0 = (#Status) (!CP0) in CP0 := - (CP0_Status_rupd((!CP0),StatusRegister_EXL_rupd(x0,true))) - end - ; let - val vectorBase = - if (#BEV)((#Status) (!CP0)) - then BitsN.B(0xFFFFFFFFBFC00200,64) - else BitsN.B(0xFFFFFFFF80000000,64) - in - ( BranchDelay := NONE - ; BranchTo := NONE - ; PC := - (BitsN.@@ - (BitsN.bits(vectorBase,63,30), - BitsN.+(BitsN.bits(vectorBase,29,0),vectorOffset))) - ; exceptionSignalled := true - ) - end - ) - end - ); - -val BYTE = BitsN.B(0x0,3) - -val HALFWORD = BitsN.B(0x1,3) - -val WORD = BitsN.B(0x3,3) - -val DOUBLEWORD = BitsN.B(0x7,3) - -fun UserMode () = - (((#KSU)((#Status) (!CP0))) = (BitsN.B(0x2,2))) andalso - (not(((#EXL)((#Status) (!CP0))) orelse ((#ERL)((#Status) (!CP0))))); - -fun SupervisorMode () = - (((#KSU)((#Status) (!CP0))) = (BitsN.B(0x1,2))) andalso - (not(((#EXL)((#Status) (!CP0))) orelse ((#ERL)((#Status) (!CP0))))); - -fun KernelMode () = - ((((#KSU)((#Status) (!CP0))) = (BitsN.B(0x0,2))) orelse - ((#EXL)((#Status) (!CP0)))) orelse ((#ERL)((#Status) (!CP0))); - -fun BigEndianMem () = (#BE)((#Config) (!CP0)); - -fun ReverseEndian () = - BitsN.fromBit(((#RE)((#Status) (!CP0))) andalso (UserMode ())); - -fun BigEndianCPU () = - BitsN.??(BitsN.fromBit(BigEndianMem ()),ReverseEndian ()); - -fun rec'PIC_Config_Reg x = - {EN = BitsN.bit(x,31), IRQ = BitsN.bits(x,2,0), - pic_config_reg'rst = BitsN.@@(BitsN.bits(x,30,3),BitsN.bits(x,63,32))}; - -fun reg'PIC_Config_Reg x = - case x of - {EN = EN, IRQ = IRQ, pic_config_reg'rst = pic_config_reg'rst} => - BitsN.modify - (fn (i,_) => - if i = 63 - then BitsN.bit(pic_config_reg'rst,31) - else if i = 62 - then BitsN.bit(pic_config_reg'rst,30) - else if i = 61 - then BitsN.bit(pic_config_reg'rst,29) - else if i = 60 - then BitsN.bit(pic_config_reg'rst,28) - else if i = 59 - then BitsN.bit(pic_config_reg'rst,27) - else if i = 58 - then BitsN.bit(pic_config_reg'rst,26) - else if i = 57 - then BitsN.bit(pic_config_reg'rst,25) - else if i = 56 - then BitsN.bit(pic_config_reg'rst,24) - else if i = 55 - then BitsN.bit(pic_config_reg'rst,23) - else if i = 54 - then BitsN.bit(pic_config_reg'rst,22) - else if i = 53 - then BitsN.bit(pic_config_reg'rst,21) - else if i = 52 - then BitsN.bit(pic_config_reg'rst,20) - else if i = 51 - then BitsN.bit(pic_config_reg'rst,19) - else if i = 50 - then BitsN.bit(pic_config_reg'rst,18) - else if i = 49 - then BitsN.bit(pic_config_reg'rst,17) - else if i = 48 - then BitsN.bit(pic_config_reg'rst,16) - else if i = 47 - then BitsN.bit(pic_config_reg'rst,15) - else if i = 46 - then BitsN.bit(pic_config_reg'rst,14) - else if i = 45 - then BitsN.bit(pic_config_reg'rst,13) - else if i = 44 - then BitsN.bit(pic_config_reg'rst,12) - else if i = 43 - then BitsN.bit(pic_config_reg'rst,11) - else if i = 42 - then BitsN.bit(pic_config_reg'rst,10) - else if i = 41 - then BitsN.bit(pic_config_reg'rst,9) - else if i = 40 - then BitsN.bit(pic_config_reg'rst,8) - else if i = 39 - then BitsN.bit(pic_config_reg'rst,7) - else if i = 38 - then BitsN.bit(pic_config_reg'rst,6) - else if i = 37 - then BitsN.bit(pic_config_reg'rst,5) - else if i = 36 - then BitsN.bit(pic_config_reg'rst,4) - else if i = 35 - then BitsN.bit(pic_config_reg'rst,3) - else if i = 34 - then BitsN.bit(pic_config_reg'rst,2) - else if i = 33 - then BitsN.bit(pic_config_reg'rst,1) - else if i = 32 - then BitsN.bit(pic_config_reg'rst,0) - else if i = 31 - then EN - else if i = 30 - then BitsN.bit(pic_config_reg'rst,59) - else if i = 29 - then BitsN.bit(pic_config_reg'rst,58) - else if i = 28 - then BitsN.bit(pic_config_reg'rst,57) - else if i = 27 - then BitsN.bit(pic_config_reg'rst,56) - else if i = 26 - then BitsN.bit(pic_config_reg'rst,55) - else if i = 25 - then BitsN.bit(pic_config_reg'rst,54) - else if i = 24 - then BitsN.bit(pic_config_reg'rst,53) - else if i = 23 - then BitsN.bit(pic_config_reg'rst,52) - else if i = 22 - then BitsN.bit(pic_config_reg'rst,51) - else if i = 21 - then BitsN.bit(pic_config_reg'rst,50) - else if i = 20 - then BitsN.bit(pic_config_reg'rst,49) - else if i = 19 - then BitsN.bit(pic_config_reg'rst,48) - else if i = 18 - then BitsN.bit(pic_config_reg'rst,47) - else if i = 17 - then BitsN.bit(pic_config_reg'rst,46) - else if i = 16 - then BitsN.bit(pic_config_reg'rst,45) - else if i = 15 - then BitsN.bit(pic_config_reg'rst,44) - else if i = 14 - then BitsN.bit(pic_config_reg'rst,43) - else if i = 13 - then BitsN.bit(pic_config_reg'rst,42) - else if i = 12 - then BitsN.bit(pic_config_reg'rst,41) - else if i = 11 - then BitsN.bit(pic_config_reg'rst,40) - else if i = 10 - then BitsN.bit(pic_config_reg'rst,39) - else if i = 9 - then BitsN.bit(pic_config_reg'rst,38) - else if i = 8 - then BitsN.bit(pic_config_reg'rst,37) - else if i = 7 - then BitsN.bit(pic_config_reg'rst,36) - else if i = 6 - then BitsN.bit(pic_config_reg'rst,35) - else if i = 5 - then BitsN.bit(pic_config_reg'rst,34) - else if i = 4 - then BitsN.bit(pic_config_reg'rst,33) - else if i = 3 - then BitsN.bit(pic_config_reg'rst,32) - else if i = 2 - then BitsN.bit(IRQ,2) - else if i = 1 then BitsN.bit(IRQ,1) else BitsN.bit(IRQ,0), - BitsN.B(0x0,64)); - -fun write'rec'PIC_Config_Reg (_,x) = reg'PIC_Config_Reg x; - -fun write'reg'PIC_Config_Reg (_,x) = rec'PIC_Config_Reg x; - -fun PIC_update () = - let - val ext = BitsN.zeroExtend 128 ((#external_intrs) (!PIC)) - in - let - val ip = ref (BitsN.B(0x0,8)) - in - ( ip := (BitsN.B(0x0,8)) - ; if (not(((#ip_bits) (!PIC)) = (BitsN.B(0x0,128)))) orelse - (not(ext = (BitsN.B(0x0,128)))) - then L3.for - (0,127, - fn i => - if (BitsN.bit((#ip_bits) (!PIC),i)) orelse - (BitsN.bit(ext,i)) - then let - val reg = - Map.lookup - ((#config_regs) (!PIC), - BitsN.toNat(BitsN.fromNat(i,7))) - val i = BitsN.toNat((#IRQ) reg) - in - ip := - (BitsN.bitFieldInsert - ((!ip), - BitsN.fromBit - ((BitsN.bit - ((!ip),BitsN.toNat((#IRQ) reg))) orelse - ((#EN) reg)),i,i)) - end - else ()) - else () - ; PIC := (PIC_mips_ip_bits_rupd((!PIC),BitsN.bits((!ip),5,0))) - ) - end - end; - -fun PIC_initialise pic = - ( PIC := - (PIC_base_address_rupd - ((!PIC), - BitsN.fromNat(BitsN.toNat(BitsN.>>+(BitsN.fromNat(pic,40),3)),37))) - ; L3.for - (0,127, - fn i => - let - val f = Map.copy((#config_regs) (!PIC)) - val x0 = BitsN.fromNat(i,7) - val x1 = Map.lookup(f,BitsN.toNat x0) - in - PIC := - (PIC_config_regs_rupd - ((!PIC), - Map.update - (f,BitsN.toNat x0, - write'reg'PIC_Config_Reg(x1,BitsN.B(0x0,64))))) - end) - ; L3.for - (0,4, - fn i => - ( let - val f = Map.copy((#config_regs) (!PIC)) - val x0 = BitsN.fromNat(i,7) - val x1 = Map.lookup(f,BitsN.toNat x0) - in - PIC := - (PIC_config_regs_rupd - ((!PIC), - Map.update - (f,BitsN.toNat x0,PIC_Config_Reg_EN_rupd(x1,true)))) - end - ; let - val f = Map.copy((#config_regs) (!PIC)) - val x0 = BitsN.fromNat(i,7) - val x1 = Map.lookup(f,BitsN.toNat x0) - in - PIC := - (PIC_config_regs_rupd - ((!PIC), - Map.update - (f,BitsN.toNat x0, - PIC_Config_Reg_IRQ_rupd(x1,BitsN.fromNat(i,3))))) - end - )) - ; PIC := (PIC_ip_bits_rupd((!PIC),BitsN.B(0x0,128))) - ; PIC := (PIC_external_intrs_rupd((!PIC),BitsN.B(0x0,64))) - ; PIC_update () - ); - -fun PIC_load addr = - let - val offset = BitsN.-(addr,(#base_address) (!PIC)) - in - let - val ret = ref (BitsN.B(0x0,64)) - in - ( if BitsN.<(offset,BitsN.B(0x80,37)) - then ret := - (reg'PIC_Config_Reg - (Map.lookup - ((#config_regs) (!PIC), - BitsN.toNat(BitsN.fromNat(BitsN.toNat offset,7))))) - else if offset = (BitsN.B(0x400,37)) - then ret := - (BitsN.|| - (BitsN.bits((#ip_bits) (!PIC),63,0), - (#external_intrs) (!PIC))) - else if offset = (BitsN.B(0x401,37)) - then ret := (BitsN.bits((#ip_bits) (!PIC),127,64)) - else ret := (BitsN.B(0x0,64)) - ; (!ret) - ) - end - end; - -fun PIC_store (addr,(mask,data)) = - let - val offset = BitsN.-(addr,(#base_address) (!PIC)) - in - ( if BitsN.<(offset,BitsN.B(0x80,37)) - then let - val f = Map.copy((#config_regs) (!PIC)) - val x0 = BitsN.fromNat(BitsN.toNat offset,7) - val x1 = Map.lookup(f,BitsN.toNat x0) - in - PIC := - (PIC_config_regs_rupd - ((!PIC), - Map.update - (f,BitsN.toNat x0,write'reg'PIC_Config_Reg(x1,data)))) - end - else if BitsN.<(offset,BitsN.B(0x410,37)) - then () - else if offset = (BitsN.B(0x410,37)) - then let - val w = (#ip_bits) (!PIC) - in - PIC := - (PIC_ip_bits_rupd - ((!PIC), - BitsN.bitFieldInsert - (w, - BitsN.|| - (BitsN.bits((#ip_bits) (!PIC),63,0), - BitsN.&&(data,mask)),63,0))) - end - else if offset = (BitsN.B(0x411,37)) - then let - val w = (#ip_bits) (!PIC) - in - PIC := - (PIC_ip_bits_rupd - ((!PIC), - BitsN.bitFieldInsert - (w, - BitsN.|| - (BitsN.bits((#ip_bits) (!PIC),127,64), - BitsN.&&(data,mask)),127,64))) - end - else if offset = (BitsN.B(0x420,37)) - then let - val w = (#ip_bits) (!PIC) - in - PIC := - (PIC_ip_bits_rupd - ((!PIC), - BitsN.bitFieldInsert - (w, - BitsN.&& - (BitsN.bits((#ip_bits) (!PIC),63,0), - BitsN.~(BitsN.&&(data,mask))),63,0))) - end - else if offset = (BitsN.B(0x421,37)) - then let - val w = (#ip_bits) (!PIC) - in - PIC := - (PIC_ip_bits_rupd - ((!PIC), - BitsN.bitFieldInsert - (w, - BitsN.&& - (BitsN.bits((#ip_bits) (!PIC),127,64), - BitsN.~(BitsN.&&(data,mask))),127,64))) - end - else () - ; PIC_update () - ) - end; - -fun rec'JTAG_UART_data x = - {RAVAIL = BitsN.bits(x,31,16), RVALID = BitsN.bit(x,15), - RW_DATA = BitsN.bits(x,7,0), jtag_uart_data'rst = BitsN.bits(x,14,8)}; - -fun reg'JTAG_UART_data x = - case x of - {RAVAIL = RAVAIL, RVALID = RVALID, RW_DATA = RW_DATA, - jtag_uart_data'rst = jtag_uart_data'rst} => - BitsN.modify - (fn (i,_) => - if i = 31 - then BitsN.bit(RAVAIL,15) - else if i = 30 - then BitsN.bit(RAVAIL,14) - else if i = 29 - then BitsN.bit(RAVAIL,13) - else if i = 28 - then BitsN.bit(RAVAIL,12) - else if i = 27 - then BitsN.bit(RAVAIL,11) - else if i = 26 - then BitsN.bit(RAVAIL,10) - else if i = 25 - then BitsN.bit(RAVAIL,9) - else if i = 24 - then BitsN.bit(RAVAIL,8) - else if i = 23 - then BitsN.bit(RAVAIL,7) - else if i = 22 - then BitsN.bit(RAVAIL,6) - else if i = 21 - then BitsN.bit(RAVAIL,5) - else if i = 20 - then BitsN.bit(RAVAIL,4) - else if i = 19 - then BitsN.bit(RAVAIL,3) - else if i = 18 - then BitsN.bit(RAVAIL,2) - else if i = 17 - then BitsN.bit(RAVAIL,1) - else if i = 16 - then BitsN.bit(RAVAIL,0) - else if i = 15 - then RVALID - else if i = 14 - then BitsN.bit(jtag_uart_data'rst,6) - else if i = 13 - then BitsN.bit(jtag_uart_data'rst,5) - else if i = 12 - then BitsN.bit(jtag_uart_data'rst,4) - else if i = 11 - then BitsN.bit(jtag_uart_data'rst,3) - else if i = 10 - then BitsN.bit(jtag_uart_data'rst,2) - else if i = 9 - then BitsN.bit(jtag_uart_data'rst,1) - else if i = 8 - then BitsN.bit(jtag_uart_data'rst,0) - else if i = 7 - then BitsN.bit(RW_DATA,7) - else if i = 6 - then BitsN.bit(RW_DATA,6) - else if i = 5 - then BitsN.bit(RW_DATA,5) - else if i = 4 - then BitsN.bit(RW_DATA,4) - else if i = 3 - then BitsN.bit(RW_DATA,3) - else if i = 2 - then BitsN.bit(RW_DATA,2) - else if i = 1 - then BitsN.bit(RW_DATA,1) - else BitsN.bit(RW_DATA,0),BitsN.B(0x0,32)); - -fun write'rec'JTAG_UART_data (_,x) = reg'JTAG_UART_data x; - -fun write'reg'JTAG_UART_data (_,x) = rec'JTAG_UART_data x; - -fun rec'JTAG_UART_control x = - {AC = BitsN.bit(x,10), RE = BitsN.bit(x,0), RI = BitsN.bit(x,8), - WE = BitsN.bit(x,1), WI = BitsN.bit(x,9), WSPACE = BitsN.bits(x,31,16), - jtag_uart_control'rst = BitsN.@@(BitsN.bits(x,7,2),BitsN.bits(x,15,11))}; - -fun reg'JTAG_UART_control x = - case x of - {AC = AC, RE = RE, RI = RI, WE = WE, WI = WI, WSPACE = WSPACE, - jtag_uart_control'rst = jtag_uart_control'rst} => - BitsN.modify - (fn (i,_) => - if i = 31 - then BitsN.bit(WSPACE,15) - else if i = 30 - then BitsN.bit(WSPACE,14) - else if i = 29 - then BitsN.bit(WSPACE,13) - else if i = 28 - then BitsN.bit(WSPACE,12) - else if i = 27 - then BitsN.bit(WSPACE,11) - else if i = 26 - then BitsN.bit(WSPACE,10) - else if i = 25 - then BitsN.bit(WSPACE,9) - else if i = 24 - then BitsN.bit(WSPACE,8) - else if i = 23 - then BitsN.bit(WSPACE,7) - else if i = 22 - then BitsN.bit(WSPACE,6) - else if i = 21 - then BitsN.bit(WSPACE,5) - else if i = 20 - then BitsN.bit(WSPACE,4) - else if i = 19 - then BitsN.bit(WSPACE,3) - else if i = 18 - then BitsN.bit(WSPACE,2) - else if i = 17 - then BitsN.bit(WSPACE,1) - else if i = 16 - then BitsN.bit(WSPACE,0) - else if i = 15 - then BitsN.bit(jtag_uart_control'rst,4) - else if i = 14 - then BitsN.bit(jtag_uart_control'rst,3) - else if i = 13 - then BitsN.bit(jtag_uart_control'rst,2) - else if i = 12 - then BitsN.bit(jtag_uart_control'rst,1) - else if i = 11 - then BitsN.bit(jtag_uart_control'rst,0) - else if i = 10 - then AC - else if i = 9 - then WI - else if i = 8 - then RI - else if i = 7 - then BitsN.bit(jtag_uart_control'rst,10) - else if i = 6 - then BitsN.bit(jtag_uart_control'rst,9) - else if i = 5 - then BitsN.bit(jtag_uart_control'rst,8) - else if i = 4 - then BitsN.bit(jtag_uart_control'rst,7) - else if i = 3 - then BitsN.bit(jtag_uart_control'rst,6) - else if i = 2 - then BitsN.bit(jtag_uart_control'rst,5) - else if i = 1 then WE else RE,BitsN.B(0x0,32)); - -fun write'rec'JTAG_UART_control (_,x) = reg'JTAG_UART_control x; - -fun write'reg'JTAG_UART_control (_,x) = rec'JTAG_UART_control x; - -fun JTAG_UART_update_interrupt_bit () = - let - val readIntr = - ((#RE)((#control) (!JTAG_UART))) andalso - ((#RVALID)((#data) (!JTAG_UART))) - in - if not(((#RI)((#control) (!JTAG_UART))) = readIntr) - then ( let - val x0 = (#control) (!JTAG_UART) - in - JTAG_UART := - (JTAG_UART_control_rupd - ((!JTAG_UART),JTAG_UART_control_RI_rupd(x0,readIntr))) - end - ; let - val w = (#external_intrs) (!PIC) - in - PIC := - (PIC_external_intrs_rupd - ((!PIC), - BitsN.bitFieldInsert(w,BitsN.fromBit readIntr,0,0))) - end - ; PIC_update () - ) - else () - end; - -fun JTAG_UART_load () = - ( case (#read_fifo) (!JTAG_UART) of - [] => - ( let - val x0 = (#data) (!JTAG_UART) - in - JTAG_UART := - (JTAG_UART_data_rupd - ((!JTAG_UART), - JTAG_UART_data_RAVAIL_rupd(x0,BitsN.B(0x0,16)))) - end - ; let - val x0 = (#data) (!JTAG_UART) - in - JTAG_UART := - (JTAG_UART_data_rupd - ((!JTAG_UART),JTAG_UART_data_RVALID_rupd(x0,false))) - end - ) - | h :: t => - ( let - val x0 = (#data) (!JTAG_UART) - in - JTAG_UART := - (JTAG_UART_data_rupd - ((!JTAG_UART),JTAG_UART_data_RW_DATA_rupd(x0,h))) - end - ; let - val x0 = (#data) (!JTAG_UART) - in - JTAG_UART := - (JTAG_UART_data_rupd - ((!JTAG_UART), - JTAG_UART_data_RAVAIL_rupd - (x0,BitsN.fromNat(List.length t,16)))) - end - ; let - val x0 = (#data) (!JTAG_UART) - in - JTAG_UART := - (JTAG_UART_data_rupd - ((!JTAG_UART),JTAG_UART_data_RVALID_rupd(x0,true))) - end - ; JTAG_UART := (JTAG_UART_read_fifo_rupd((!JTAG_UART),t)) - ) - ; JTAG_UART_update_interrupt_bit () - ); - -fun JTAG_UART_input l = - ( case ((#read_fifo) (!JTAG_UART)) @ l of - [] => - let - val x0 = (#data) (!JTAG_UART) - in - JTAG_UART := - (JTAG_UART_data_rupd - ((!JTAG_UART), - JTAG_UART_data_RAVAIL_rupd(x0,BitsN.B(0x0,16)))) - end - | t => - ( JTAG_UART := (JTAG_UART_read_fifo_rupd((!JTAG_UART),t)) - ; let - val x0 = (#data) (!JTAG_UART) - in - JTAG_UART := - (JTAG_UART_data_rupd - ((!JTAG_UART), - JTAG_UART_data_RAVAIL_rupd - (x0,BitsN.fromNat(List.length t,16)))) - end - ; let - val x0 = (#control) (!JTAG_UART) - in - JTAG_UART := - (JTAG_UART_control_rupd - ((!JTAG_UART),JTAG_UART_control_AC_rupd(x0,true))) - end - ; if not((#RVALID)((#data) (!JTAG_UART))) - then JTAG_UART_load () - else () - ) - ; JTAG_UART_update_interrupt_bit () - ); - -fun JTAG_UART_store (mask,MemElem) = - ( if (not((BitsN.bits(mask,63,56)) = (BitsN.B(0x0,8)))) andalso - (not(((#WSPACE)((#control) (!JTAG_UART))) = (BitsN.B(0x0,16)))) - then ( let - val x0 = (#control) (!JTAG_UART) - in - JTAG_UART := - (JTAG_UART_control_rupd - ((!JTAG_UART), - JTAG_UART_control_WSPACE_rupd - (x0, - BitsN.- - ((#WSPACE)((#control) (!JTAG_UART)), - BitsN.B(0x1,16))))) - end - ; JTAG_UART := - (JTAG_UART_write_fifo_rupd - ((!JTAG_UART), - (BitsN.bits(MemElem,63,56)) - :: - ((#write_fifo) (!JTAG_UART)))) - ) - else () - ; if BitsN.bit(mask,24) - then let - val x0 = (#control) (!JTAG_UART) - in - JTAG_UART := - (JTAG_UART_control_rupd - ((!JTAG_UART), - JTAG_UART_control_RE_rupd(x0,BitsN.bit(MemElem,24)))) - end - else () - ; if BitsN.bit(mask,25) - then let - val x0 = (#control) (!JTAG_UART) - in - JTAG_UART := - (JTAG_UART_control_rupd - ((!JTAG_UART), - JTAG_UART_control_WE_rupd(x0,BitsN.bit(MemElem,25)))) - end - else () - ; if (BitsN.bit(mask,18)) andalso (BitsN.bit(MemElem,18)) - then let - val x0 = (#control) (!JTAG_UART) - in - JTAG_UART := - (JTAG_UART_control_rupd - ((!JTAG_UART),JTAG_UART_control_AC_rupd(x0,false))) - end - else () - ; JTAG_UART_update_interrupt_bit () - ); - -fun JTAG_UART_output () = - ( let - val x0 = (#control) (!JTAG_UART) - in - JTAG_UART := - (JTAG_UART_control_rupd - ((!JTAG_UART),JTAG_UART_control_AC_rupd(x0,true))) - end - ; let - val l = List.rev((#write_fifo) (!JTAG_UART)) - in - ( JTAG_UART := (JTAG_UART_write_fifo_rupd((!JTAG_UART),[])) - ; let - val x0 = (#control) (!JTAG_UART) - in - JTAG_UART := - (JTAG_UART_control_rupd - ((!JTAG_UART), - JTAG_UART_control_WSPACE_rupd(x0,BitsN.neg(BitsN.B(0x1,16))))) - end - ; let - val x0 = (#control) (!JTAG_UART) - in - JTAG_UART := - (JTAG_UART_control_rupd - ((!JTAG_UART),JTAG_UART_control_WI_rupd(x0,false))) - end - ; JTAG_UART_update_interrupt_bit () - ; l - ) - end - ); - -fun JTAG_UART_initialise uart = - ( JTAG_UART := - (JTAG_UART_base_address_rupd - ((!JTAG_UART), - BitsN.fromNat(BitsN.toNat(BitsN.>>+(BitsN.fromNat(uart,40),3)),37))) - ; JTAG_UART := (JTAG_UART_read_threshold_rupd((!JTAG_UART),65280)) - ; JTAG_UART := (JTAG_UART_write_threshold_rupd((!JTAG_UART),65520)) - ; JTAG_UART := (JTAG_UART_read_fifo_rupd((!JTAG_UART),[])) - ; JTAG_UART := (JTAG_UART_write_fifo_rupd((!JTAG_UART),[])) - ; let - val x0 = (#data) (!JTAG_UART) - in - JTAG_UART := - (JTAG_UART_data_rupd - ((!JTAG_UART),JTAG_UART_data_RW_DATA_rupd(x0,BitsN.B(0x0,8)))) - end - ; let - val x0 = (#data) (!JTAG_UART) - in - JTAG_UART := - (JTAG_UART_data_rupd - ((!JTAG_UART),JTAG_UART_data_RVALID_rupd(x0,false))) - end - ; let - val x0 = (#data) (!JTAG_UART) - in - JTAG_UART := - (JTAG_UART_data_rupd - ((!JTAG_UART),JTAG_UART_data_RAVAIL_rupd(x0,BitsN.B(0x0,16)))) - end - ; let - val x0 = (#control) (!JTAG_UART) - in - JTAG_UART := - (JTAG_UART_control_rupd - ((!JTAG_UART),JTAG_UART_control_RE_rupd(x0,true))) - end - ; let - val x0 = (#control) (!JTAG_UART) - in - JTAG_UART := - (JTAG_UART_control_rupd - ((!JTAG_UART),JTAG_UART_control_WE_rupd(x0,false))) - end - ; let - val x0 = (#control) (!JTAG_UART) - in - JTAG_UART := - (JTAG_UART_control_rupd - ((!JTAG_UART),JTAG_UART_control_RI_rupd(x0,false))) - end - ; let - val x0 = (#control) (!JTAG_UART) - in - JTAG_UART := - (JTAG_UART_control_rupd - ((!JTAG_UART),JTAG_UART_control_WI_rupd(x0,false))) - end - ; let - val x0 = (#control) (!JTAG_UART) - in - JTAG_UART := - (JTAG_UART_control_rupd - ((!JTAG_UART),JTAG_UART_control_AC_rupd(x0,false))) - end - ; let - val x0 = (#control) (!JTAG_UART) - in - JTAG_UART := - (JTAG_UART_control_rupd - ((!JTAG_UART), - JTAG_UART_control_WSPACE_rupd(x0,BitsN.neg(BitsN.B(0x1,16))))) - end - ); - -val PSIZE = 40 - -fun mark e = log := (e :: (!log)); - -fun unmark () = log := (List.tl (!log)); - -fun flip_endian_word w = - case boolify'32 w of - (a'7, - (a'6, - (a'5, - (a'4, - (a'3, - (a'2, - (a'1, - (a'0, - (b'7, - (b'6, - (b'5, - (b'4, - (b'3, - (b'2, - (b'1, - (b'0, - (c'7, - (c'6, - (c'5, - (c'4, - (c'3, - (c'2, - (c'1, - (c'0, - (d'7,(d'6,(d'5,(d'4,(d'3,(d'2,(d'1,d'0))))))))))))))))))))))))))))))) => - BitsN.concat - [BitsN.fromBitstring([d'7,d'6,d'5,d'4,d'3,d'2,d'1,d'0],8), - BitsN.fromBitstring([c'7,c'6,c'5,c'4,c'3,c'2,c'1,c'0],8), - BitsN.fromBitstring([b'7,b'6,b'5,b'4,b'3,b'2,b'1,b'0],8), - BitsN.fromBitstring([a'7,a'6,a'5,a'4,a'3,a'2,a'1,a'0],8)]; - -fun flip_endian_dword dw = - case boolify'64 dw of - (a'7, - (a'6, - (a'5, - (a'4, - (a'3, - (a'2, - (a'1, - (a'0, - (b'7, - (b'6, - (b'5, - (b'4, - (b'3, - (b'2, - (b'1, - (b'0, - (c'7, - (c'6, - (c'5, - (c'4, - (c'3, - (c'2, - (c'1, - (c'0, - (d'7, - (d'6, - (d'5, - (d'4, - (d'3, - (d'2, - (d'1, - (d'0, - (e'7, - (e'6, - (e'5, - (e'4, - (e'3, - (e'2, - (e'1, - (e'0, - (f'7, - (f'6, - (f'5, - (f'4, - (f'3, - (f'2, - (f'1, - (f'0, - (g'7, - (g'6, - (g'5, - (g'4, - (g'3, - (g'2, - (g'1, - (g'0, - (h'7, - (h'6, - (h'5, - (h'4, - (h'3, - (h'2, - (h'1, - h'0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) => - BitsN.concat - [BitsN.fromBitstring([h'7,h'6,h'5,h'4,h'3,h'2,h'1,h'0],8), - BitsN.fromBitstring([g'7,g'6,g'5,g'4,g'3,g'2,g'1,g'0],8), - BitsN.fromBitstring([f'7,f'6,f'5,f'4,f'3,f'2,f'1,f'0],8), - BitsN.fromBitstring([e'7,e'6,e'5,e'4,e'3,e'2,e'1,e'0],8), - BitsN.fromBitstring([d'7,d'6,d'5,d'4,d'3,d'2,d'1,d'0],8), - BitsN.fromBitstring([c'7,c'6,c'5,c'4,c'3,c'2,c'1,c'0],8), - BitsN.fromBitstring([b'7,b'6,b'5,b'4,b'3,b'2,b'1,b'0],8), - BitsN.fromBitstring([a'7,a'6,a'5,a'4,a'3,a'2,a'1,a'0],8)]; - -val TLBEntries = 16 - -fun GPR n = - if n = (BitsN.B(0x0,5)) - then BitsN.B(0x0,64) - else Map.lookup((!gpr),BitsN.toNat n); - -fun write'GPR (value,n) = - if not(n = (BitsN.B(0x0,5))) - then ( gpr := (Map.update((!gpr),BitsN.toNat n,value)) - ; mark(w_gpr(n,value)) - ) - else (); - -fun HI () = - case (!hi) of - Option.SOME v => v - | NONE => ( (!UNPREDICTABLE_HI) (); BitsN.B(0x0,64) ); - -fun write'HI value = ( hi := (Option.SOME value); mark(w_hi value) ); - -fun LO () = - case (!lo) of - Option.SOME v => v - | NONE => ( (!UNPREDICTABLE_LO) (); BitsN.B(0x0,64) ); - -fun write'LO value = ( lo := (Option.SOME value); mark(w_lo value) ); - -fun CPR (n,(reg,sel)) = - case (n,(reg,sel)) of - (0,(BitsN.B(0x0,5),BitsN.B(0x0,3))) => - BitsN.fromNat(BitsN.toNat(reg'Index((#Index) (!CP0))),64) - | (0,(BitsN.B(0x1,5),BitsN.B(0x0,3))) => - BitsN.fromNat(BitsN.toNat(reg'Random((#Random) (!CP0))),64) - | (0,(BitsN.B(0x2,5),BitsN.B(0x0,3))) => - reg'EntryLo((#EntryLo0) (!CP0)) - | (0,(BitsN.B(0x3,5),BitsN.B(0x0,3))) => - reg'EntryLo((#EntryLo1) (!CP0)) - | (0,(BitsN.B(0x4,5),BitsN.B(0x0,3))) => reg'Context((#Context) (!CP0)) - | (0,(BitsN.B(0x4,5),BitsN.B(0x2,3))) => (#UsrLocal) (!CP0) - | (0,(BitsN.B(0x5,5),BitsN.B(0x0,3))) => - BitsN.fromNat(BitsN.toNat(reg'PageMask((#PageMask) (!CP0))),64) - | (0,(BitsN.B(0x6,5),BitsN.B(0x0,3))) => - BitsN.fromNat(BitsN.toNat(reg'Wired((#Wired) (!CP0))),64) - | (0,(BitsN.B(0x7,5),BitsN.B(0x0,3))) => - BitsN.fromNat(BitsN.toNat(reg'HWREna((#HWREna) (!CP0))),64) - | (0,(BitsN.B(0x8,5),BitsN.B(0x0,3))) => (#BadVAddr) (!CP0) - | (0,(BitsN.B(0x9,5),BitsN.B(0x0,3))) => - BitsN.fromNat(BitsN.toNat((#Count) (!CP0)),64) - | (0,(BitsN.B(0xA,5),BitsN.B(0x0,3))) => reg'EntryHi((#EntryHi) (!CP0)) - | (0,(BitsN.B(0xB,5),BitsN.B(0x0,3))) => - BitsN.fromNat(BitsN.toNat((#Compare) (!CP0)),64) - | (0,(BitsN.B(0xC,5),BitsN.B(0x0,3))) => - BitsN.fromNat - (BitsN.toNat(reg'StatusRegister((#Status) (!CP0))),64) - | (0,(BitsN.B(0xD,5),BitsN.B(0x0,3))) => - BitsN.fromNat(BitsN.toNat(reg'CauseRegister((#Cause) (!CP0))),64) - | (0,(BitsN.B(0xE,5),BitsN.B(0x0,3))) => (#EPC) (!CP0) - | (0,(BitsN.B(0xF,5),BitsN.B(0x0,3))) => - BitsN.fromNat(BitsN.toNat((#PRId) (!CP0)),64) - | (0,(BitsN.B(0x10,5),BitsN.B(0x0,3))) => - BitsN.fromNat - (BitsN.toNat(reg'ConfigRegister((#Config) (!CP0))),64) - | (0,(BitsN.B(0x10,5),BitsN.B(0x1,3))) => - BitsN.fromNat - (BitsN.toNat(reg'ConfigRegister1((#Config1) (!CP0))),64) - | (0,(BitsN.B(0x10,5),BitsN.B(0x2,3))) => - BitsN.fromNat - (BitsN.toNat(reg'ConfigRegister2((#Config2) (!CP0))),64) - | (0,(BitsN.B(0x10,5),BitsN.B(0x3,3))) => - BitsN.fromNat - (BitsN.toNat(reg'ConfigRegister3((#Config3) (!CP0))),64) - | (0,(BitsN.B(0x10,5),BitsN.B(0x4,3))) => BitsN.B(0x1,64) - | (0,(BitsN.B(0x10,5),BitsN.B(0x5,3))) => BitsN.B(0x1,64) - | (0,(BitsN.B(0x10,5),BitsN.B(0x6,3))) => - BitsN.fromNat - (BitsN.toNat(reg'ConfigRegister6((#Config6) (!CP0))),64) - | (0,(BitsN.B(0x11,5),BitsN.B(0x0,3))) => - BitsN.fromNat(BitsN.toNat((#LLAddr) (!CP0)),64) - | (0,(BitsN.B(0x14,5),BitsN.B(0x0,3))) => - reg'XContext((#XContext) (!CP0)) - | (0,(BitsN.B(0x17,5),BitsN.B(0x0,3))) => - BitsN.fromNat(BitsN.toNat((#Debug) (!CP0)),64) - | (0,(BitsN.B(0x1A,5),BitsN.B(0x0,3))) => - BitsN.fromNat(BitsN.toNat((#ErrCtl) (!CP0)),64) - | (0,(BitsN.B(0x1E,5),BitsN.B(0x0,3))) => (#ErrorEPC) (!CP0) - | _ => BitsN.B(0x0,64); - -fun write'CPR (value,(n,(reg,sel))) = - ( mark(w_c0(reg,value)) - ; case (n,(reg,sel)) of - (0,(BitsN.B(0x0,5),BitsN.B(0x0,3))) => - let - val x0 = (#Index) (!CP0) - in - CP0 := - (CP0_Index_rupd - ((!CP0),Index_Index_rupd(x0,BitsN.bits(value,7,0)))) - end - | (0,(BitsN.B(0x2,5),BitsN.B(0x0,3))) => - let - val x0 = (#EntryLo0) (!CP0) - in - CP0 := (CP0_EntryLo0_rupd((!CP0),write'reg'EntryLo(x0,value))) - end - | (0,(BitsN.B(0x3,5),BitsN.B(0x0,3))) => - let - val x0 = (#EntryLo1) (!CP0) - in - CP0 := (CP0_EntryLo1_rupd((!CP0),write'reg'EntryLo(x0,value))) - end - | (0,(BitsN.B(0x4,5),BitsN.B(0x0,3))) => - let - val x0 = (#Context) (!CP0) - in - CP0 := - (CP0_Context_rupd - ((!CP0),Context_PTEBase_rupd(x0,BitsN.bits(value,63,23)))) - end - | (0,(BitsN.B(0x4,5),BitsN.B(0x2,3))) => - CP0 := (CP0_UsrLocal_rupd((!CP0),value)) - | (0,(BitsN.B(0x5,5),BitsN.B(0x0,3))) => - let - val x0 = (#PageMask) (!CP0) - in - CP0 := - (CP0_PageMask_rupd - ((!CP0),PageMask_Mask_rupd(x0,BitsN.bits(value,24,13)))) - end - | (0,(BitsN.B(0x6,5),BitsN.B(0x0,3))) => - ( let - val x0 = (#Wired) (!CP0) - in - CP0 := - (CP0_Wired_rupd - ((!CP0),Wired_Wired_rupd(x0,BitsN.bits(value,7,0)))) - end - ; let - val x0 = (#Random) (!CP0) - in - CP0 := - (CP0_Random_rupd - ((!CP0), - Random_Random_rupd - (x0,BitsN.fromNat(Nat.-(TLBEntries,1),8)))) - end - ) - | (0,(BitsN.B(0x7,5),BitsN.B(0x0,3))) => - ( let - val x0 = (#HWREna) (!CP0) - in - CP0 := - (CP0_HWREna_rupd - ((!CP0),HWREna_CPUNum_rupd(x0,BitsN.bit(value,0)))) - end - ; let - val x0 = (#HWREna) (!CP0) - in - CP0 := - (CP0_HWREna_rupd - ((!CP0),HWREna_CC_rupd(x0,BitsN.bit(value,2)))) - end - ; let - val x0 = (#HWREna) (!CP0) - in - CP0 := - (CP0_HWREna_rupd - ((!CP0),HWREna_CCRes_rupd(x0,BitsN.bit(value,3)))) - end - ; let - val x0 = (#HWREna) (!CP0) - in - CP0 := - (CP0_HWREna_rupd - ((!CP0),HWREna_UL_rupd(x0,BitsN.bit(value,29)))) - end - ) - | (0,(BitsN.B(0x9,5),BitsN.B(0x0,3))) => - CP0 := (CP0_Count_rupd((!CP0),BitsN.bits(value,31,0))) - | (0,(BitsN.B(0xA,5),BitsN.B(0x0,3))) => - let - val x0 = (#EntryHi) (!CP0) - in - CP0 := (CP0_EntryHi_rupd((!CP0),write'reg'EntryHi(x0,value))) - end - | (0,(BitsN.B(0xB,5),BitsN.B(0x0,3))) => - ( CP0 := (CP0_Compare_rupd((!CP0),BitsN.bits(value,31,0))) - ; let - val x0 = (#Cause) (!CP0) - val w = (#IP) x0 - in - CP0 := - (CP0_Cause_rupd - ((!CP0), - CauseRegister_IP_rupd - (x0,BitsN.bitFieldInsert(w,BitsN.fromBit false,7,7)))) - end - ; let - val x0 = (#Cause) (!CP0) - in - CP0 := - (CP0_Cause_rupd((!CP0),CauseRegister_TI_rupd(x0,false))) - end - ) - | (0,(BitsN.B(0xC,5),BitsN.B(0x0,3))) => - let - val x0 = (#Status) (!CP0) - in - CP0 := - (CP0_Status_rupd - ((!CP0),write'reg'StatusRegister(x0,BitsN.bits(value,31,0)))) - end - | (0,(BitsN.B(0xD,5),BitsN.B(0x0,3))) => - let - val x0 = (#Cause) (!CP0) - in - CP0 := - (CP0_Cause_rupd - ((!CP0),write'reg'CauseRegister(x0,BitsN.bits(value,31,0)))) - end - | (0,(BitsN.B(0xE,5),BitsN.B(0x0,3))) => - CP0 := (CP0_EPC_rupd((!CP0),value)) - | (0,(BitsN.B(0x10,5),BitsN.B(0x0,3))) => - let - val x0 = (#Config) (!CP0) - in - CP0 := - (CP0_Config_rupd - ((!CP0),ConfigRegister_K0_rupd(x0,BitsN.bits(value,2,0)))) - end - | (0,(BitsN.B(0x10,5),BitsN.B(0x2,3))) => - let - val x0 = (#Config2) (!CP0) - in - CP0 := - (CP0_Config2_rupd - ((!CP0),ConfigRegister2_SU_rupd(x0,BitsN.bits(value,15,12)))) - end - | (0,(BitsN.B(0x10,5),BitsN.B(0x6,3))) => - let - val x0 = (#Config6) (!CP0) - in - CP0 := - (CP0_Config6_rupd - ((!CP0),ConfigRegister6_LTLB_rupd(x0,BitsN.bit(value,2)))) - end - | (0,(BitsN.B(0x14,5),BitsN.B(0x0,3))) => - let - val x0 = (#XContext) (!CP0) - in - CP0 := - (CP0_XContext_rupd - ((!CP0),XContext_PTEBase_rupd(x0,BitsN.bits(value,63,33)))) - end - | (0,(BitsN.B(0x17,5),BitsN.B(0x0,3))) => - CP0 := (CP0_Debug_rupd((!CP0),BitsN.bits(value,31,0))) - | (0,(BitsN.B(0x1A,5),BitsN.B(0x0,3))) => - CP0 := (CP0_ErrCtl_rupd((!CP0),BitsN.bits(value,31,0))) - | (0,(BitsN.B(0x1E,5),BitsN.B(0x0,3))) => - CP0 := (CP0_ErrorEPC_rupd((!CP0),value)) - | _ => unmark () - ); - -fun LookupTLB (r,vpn2) = - let - val e = Map.lookup((!TLB_direct),BitsN.toNat(BitsN.bits(vpn2,6,0))) - val index = - if Nat.>=(BitsN.toNat(BitsN.bits(vpn2,6,0)),TLBEntries) - then BitsN.fromNat(BitsN.toNat(BitsN.bits(vpn2,6,0)),8) - else BitsN.+ - (BitsN.B(0x80,8), - BitsN.fromNat(BitsN.toNat(BitsN.bits(vpn2,6,0)),8)) - val nmask = BitsN.~(BitsN.fromNat(BitsN.toNat((#Mask) e),27)) - in - let - val found = ref [] - in - ( if (#LTLB)((#Config6) (!CP0)) - then found := - (if (((BitsN.&&((#VPN2) e,nmask)) = (BitsN.&&(vpn2,nmask))) andalso - (((#R) e) = r)) andalso - (((#G) e) orelse - (((#ASID) e) = ((#ASID)((#EntryHi) (!CP0))))) - then [(index,e)] - else []) - else () - ; L3.for - (0,Nat.-(TLBEntries,1), - fn i => - let - val e = - Map.lookup((!TLB_assoc),BitsN.toNat(BitsN.fromNat(i,4))) - val nmask = - BitsN.~(BitsN.fromNat(BitsN.toNat((#Mask) e),27)) - in - if (((BitsN.&&((#VPN2) e,nmask)) = (BitsN.&&(vpn2,nmask))) andalso - (((#R) e) = r)) andalso - (((#G) e) orelse - (((#ASID) e) = ((#ASID)((#EntryHi) (!CP0))))) - then found := ((BitsN.fromNat(i,8),e) :: (!found)) - else () - end) - ; (!found) - ) - end - end; - -fun ModifyTLB ie = - let - val eHi = (#EntryHi) (!CP0) - val eLo1 = (#EntryLo1) (!CP0) - val eLo0 = (#EntryLo0) (!CP0) - in - let - val e = ref ie - in - ( e := (TLBEntry_Mask_rupd((!e),(#Mask)((#PageMask) (!CP0)))) - ; e := (TLBEntry_R_rupd((!e),(#R) eHi)) - ; e := (TLBEntry_VPN2_rupd((!e),(#VPN2) eHi)) - ; e := (TLBEntry_ASID_rupd((!e),(#ASID) eHi)) - ; e := (TLBEntry_PFN1_rupd((!e),(#PFN) eLo1)) - ; e := (TLBEntry_C1_rupd((!e),(#C) eLo1)) - ; e := (TLBEntry_D1_rupd((!e),(#D) eLo1)) - ; e := (TLBEntry_V1_rupd((!e),(#V) eLo1)) - ; e := (TLBEntry_G_rupd((!e),((#G) eLo1) andalso ((#G) eLo0))) - ; e := (TLBEntry_PFN0_rupd((!e),(#PFN) eLo0)) - ; e := (TLBEntry_C0_rupd((!e),(#C) eLo0)) - ; e := (TLBEntry_D0_rupd((!e),(#D) eLo0)) - ; e := (TLBEntry_V0_rupd((!e),(#V) eLo0)) - ; (!e) - ) - end - end; - -fun SignalTLBException (e,(asid,vAddr)) = - let - val r = BitsN.bits(vAddr,63,62) - val vpn2 = BitsN.bits(vAddr,39,13) - in - ( SignalException e - ; CP0 := (CP0_BadVAddr_rupd((!CP0),vAddr)) - ; let - val x0 = (#EntryHi) (!CP0) - in - CP0 := (CP0_EntryHi_rupd((!CP0),EntryHi_R_rupd(x0,r))) - end - ; let - val x0 = (#EntryHi) (!CP0) - in - CP0 := (CP0_EntryHi_rupd((!CP0),EntryHi_VPN2_rupd(x0,vpn2))) - end - ; let - val x0 = (#EntryHi) (!CP0) - in - CP0 := (CP0_EntryHi_rupd((!CP0),EntryHi_ASID_rupd(x0,asid))) - end - ; let - val x0 = (#XContext) (!CP0) - in - CP0 := (CP0_XContext_rupd((!CP0),XContext_R_rupd(x0,r))) - end - ; let - val x0 = (#XContext) (!CP0) - in - CP0 := (CP0_XContext_rupd((!CP0),XContext_BadVPN2_rupd(x0,vpn2))) - end - ; let - val x0 = (#Context) (!CP0) - in - CP0 := - (CP0_Context_rupd - ((!CP0),Context_BadVPN2_rupd(x0,BitsN.bits(vAddr,31,13)))) - end - ; (BitsN.B(0x0,40),BitsN.B(0x0,3)) - ) - end; - -fun CheckSegment vAddr = - if UserMode () - then (NONE,BitsN.<+(vAddr,BitsN.B(0x10000000000,64))) - else if SupervisorMode () - then (NONE, - ((BitsN.<+(vAddr,BitsN.B(0x10000000000,64))) orelse - ((BitsN.<=+(vAddr,BitsN.B(0x4000000000000000,64))) andalso - (BitsN.<+(vAddr,BitsN.B(0x4000010000000000,64))))) orelse - ((BitsN.<=+(vAddr,BitsN.B(0xFFFFFFFFC0000000,64))) andalso - (BitsN.<+(vAddr,BitsN.B(0xFFFFFFFFE0000000,64))))) - else if BitsN.<+(vAddr,BitsN.B(0x10000000000,64)) - then (NONE,true) - else if (BitsN.<=+(BitsN.B(0x4000000000000000,64),vAddr)) andalso - (BitsN.<+(vAddr,BitsN.B(0x4000010000000000,64))) - then (NONE,true) - else if (BitsN.<=+(BitsN.B(0x8000000000000000,64),vAddr)) andalso - (BitsN.<+(vAddr,BitsN.B(0xC000000000000000,64))) - then (Option.SOME(BitsN.bits(vAddr,39,0),BitsN.bits(vAddr,61,59)), - (BitsN.bits(vAddr,58,40)) = (BitsN.B(0x0,19))) - else if (BitsN.<=+(BitsN.B(0xC000000000000000,64),vAddr)) andalso - (BitsN.<+(vAddr,BitsN.B(0xC00000FF80000000,64))) - then (NONE,true) - else if (BitsN.<=+(BitsN.B(0xFFFFFFFF80000000,64),vAddr)) andalso - (BitsN.<+(vAddr,BitsN.B(0xFFFFFFFFA0000000,64))) - then (Option.SOME - (BitsN.-(BitsN.bits(vAddr,39,0),BitsN.B(0xFF80000000,40)), - (#K0)((#Config) (!CP0))),true) - else if (BitsN.<=+(BitsN.B(0xFFFFFFFFA0000000,64),vAddr)) andalso - (BitsN.<+(vAddr,BitsN.B(0xFFFFFFFFC0000000,64))) - then (Option.SOME - (BitsN.-(BitsN.bits(vAddr,39,0),BitsN.B(0xFFA0000000,40)), - BitsN.B(0x2,3)),true) - else (NONE,BitsN.<=+(BitsN.B(0xFFFFFFFFC0000000,64),vAddr)); - -fun AddressTranslation (vAddr,(IorD,LorS)) = - let - val (unmapped,valid) = CheckSegment vAddr - in - if valid - then case unmapped of - Option.SOME(pAddr,cca) => (pAddr,cca) - | NONE => - (case LookupTLB - (BitsN.bits(vAddr,63,62),BitsN.bits(vAddr,39,13)) of - [] => - let - val exc = - if LorS = LOAD - then XTLBRefillL - else XTLBRefillS - in - SignalTLBException - (exc,((#ASID)((#EntryHi) (!CP0)),vAddr)) - end - | [(_,e)] => - let - val EvenOddBit = - case (#Mask) e of - BitsN.B(0x0,12) => 12 - | BitsN.B(0x3,12) => 14 - | BitsN.B(0xF,12) => 16 - | BitsN.B(0x3F,12) => 18 - | BitsN.B(0xFF,12) => 20 - | BitsN.B(0x3FF,12) => 22 - | BitsN.B(0xFFF,12) => 24 - | _ => raise UNPREDICTABLE ("TLB: bad mask") - val (PFN,(C,(D,V))) = - if BitsN.bit(vAddr,EvenOddBit) - then ((#PFN1) e,((#C1) e,((#D1) e,(#V1) e))) - else ((#PFN0) e,((#C0) e,((#D0) e,(#V0) e))) - in - if V - then if (not D) andalso (LorS = STORE) - then SignalTLBException - (Mod,((#ASID) e,vAddr)) - else let - val PFN_ = BitsN.toBitstring PFN - val vAddr_ = BitsN.toBitstring vAddr - val pAddr = - (Bitstring.bits - (PFN_,27,Nat.-(EvenOddBit,12))) - @ - (Bitstring.bits - (vAddr_,Nat.-(EvenOddBit,1),0)) - in - (BitsN.fromBitstring(pAddr,40),C) - end - else let - val exc = - if LorS = LOAD then TLBL else TLBS - in - SignalTLBException(exc,((#ASID) e,vAddr)) - end - end - | _ => raise UNPREDICTABLE ("TLB: multiple matches")) - else ( CP0 := (CP0_BadVAddr_rupd((!CP0),vAddr)) - ; SignalException(if LorS = LOAD then AdEL else AdES) - ; (BitsN.B(0x0,40),BitsN.B(0x0,3)) - ) - end; - -fun LoadMemory (CCA,(AccessLength,(pAddr,(vAddr,IorD)))) = - let - val a = BitsN.bits(pAddr,39,3) - in - let - val ret = ref (BitsN.B(0x0,64)) - in - ( if a = ((#base_address) (!JTAG_UART)) - then ( ret := - (BitsN.@@ - (flip_endian_word - (reg'JTAG_UART_data((#data) (!JTAG_UART))), - flip_endian_word - (reg'JTAG_UART_control((#control) (!JTAG_UART))))) - ; if (BitsN.bits(pAddr,2,0)) = (BitsN.B(0x0,3)) - then JTAG_UART_load () - else () - ) - else if (BitsN.>=(a,(#base_address) (!PIC))) andalso - (BitsN.<(a,BitsN.+((#base_address) (!PIC),BitsN.B(0x430,37)))) - then ret := (PIC_load a) - else ret := (Map.lookup((!MEM),BitsN.toNat a)) - ; (!ret) - ) - end - end; - -fun loadWord32 a = - let - val d = Map.lookup((!MEM),BitsN.toNat(BitsN.bits(a,39,3))) - in - if BitsN.bit(a,2) then BitsN.bits(d,31,0) else BitsN.bits(d,63,32) - end; - -fun StoreMemory (CCA,(AccessLength,(MemElem,(pAddr,(vAddr,IorD))))) = - let - val a = BitsN.bits(pAddr,39,3) - val l = - Nat.- - (64, - Nat.* - (Nat.+ - (Nat.+(BitsN.toNat AccessLength,1), - BitsN.toNat(BitsN.bits(pAddr,2,0))),8)) - val mask = - BitsN.fromNat - (Nat.- - (Nat.pow(2,Nat.+(l,Nat.*(Nat.+(BitsN.toNat AccessLength,1),8))), - Nat.pow(2,l)),64) - in - ( mark(w_mem(pAddr,(mask,(AccessLength,MemElem)))) - ; if a = ((#base_address) (!JTAG_UART)) - then JTAG_UART_store(mask,MemElem) - else if (BitsN.>=(a,(#base_address) (!PIC))) andalso - (BitsN.<(a,BitsN.+((#base_address) (!PIC),BitsN.B(0x430,37)))) - then PIC_store(a,(mask,MemElem)) - else MEM := - (Map.update - ((!MEM),BitsN.toNat a, - BitsN.|| - (BitsN.&&(Map.lookup((!MEM),BitsN.toNat a),BitsN.~ mask), - BitsN.&&(MemElem,mask)))) - ) - end; - -fun dfn'TLBP () = - if (not((#CU0)((#Status) (!CP0)))) andalso (not(KernelMode ())) - then SignalException CpU - else case LookupTLB((#R)((#EntryHi) (!CP0)),(#VPN2)((#EntryHi) (!CP0))) of - [] => - ( let - val x0 = (#Index) (!CP0) - in - CP0 := (CP0_Index_rupd((!CP0),Index_P_rupd(x0,true))) - end - ; let - val x0 = (#Index) (!CP0) - in - CP0 := - (CP0_Index_rupd - ((!CP0),Index_Index_rupd(x0,BitsN.B(0x0,8)))) - end - ) - | [(i,e)] => - ( let - val x0 = (#Index) (!CP0) - in - CP0 := (CP0_Index_rupd((!CP0),Index_P_rupd(x0,false))) - end - ; let - val x0 = (#Index) (!CP0) - in - CP0 := (CP0_Index_rupd((!CP0),Index_Index_rupd(x0,i))) - end - ) - | _ => raise UNPREDICTABLE ("TLB: multiple matches"); - -fun dfn'TLBR () = - if (not((#CU0)((#Status) (!CP0)))) andalso (not(KernelMode ())) - then SignalException CpU - else let - val i = (#Index)((#Index) (!CP0)) - val e = - if Nat.>=(BitsN.toNat i,TLBEntries) - then Map.lookup((!TLB_direct),BitsN.toNat(BitsN.bits(i,6,0))) - else Map.lookup - ((!TLB_assoc), - BitsN.toNat(BitsN.fromNat(BitsN.toNat i,4))) - in - ( let - val x0 = (#PageMask) (!CP0) - in - CP0 := - (CP0_PageMask_rupd((!CP0),PageMask_Mask_rupd(x0,(#Mask) e))) - end - ; let - val x0 = (#EntryHi) (!CP0) - in - CP0 := (CP0_EntryHi_rupd((!CP0),EntryHi_R_rupd(x0,(#R) e))) - end - ; let - val x0 = (#EntryHi) (!CP0) - in - CP0 := - (CP0_EntryHi_rupd((!CP0),EntryHi_VPN2_rupd(x0,(#VPN2) e))) - end - ; let - val x0 = (#EntryHi) (!CP0) - in - CP0 := - (CP0_EntryHi_rupd((!CP0),EntryHi_ASID_rupd(x0,(#ASID) e))) - end - ; let - val x0 = (#EntryLo1) (!CP0) - in - CP0 := - (CP0_EntryLo1_rupd((!CP0),EntryLo_PFN_rupd(x0,(#PFN1) e))) - end - ; let - val x0 = (#EntryLo1) (!CP0) - in - CP0 := (CP0_EntryLo1_rupd((!CP0),EntryLo_C_rupd(x0,(#C1) e))) - end - ; let - val x0 = (#EntryLo1) (!CP0) - in - CP0 := (CP0_EntryLo1_rupd((!CP0),EntryLo_D_rupd(x0,(#D1) e))) - end - ; let - val x0 = (#EntryLo1) (!CP0) - in - CP0 := (CP0_EntryLo1_rupd((!CP0),EntryLo_V_rupd(x0,(#V1) e))) - end - ; let - val x0 = (#EntryLo1) (!CP0) - in - CP0 := (CP0_EntryLo1_rupd((!CP0),EntryLo_G_rupd(x0,(#G) e))) - end - ; let - val x0 = (#EntryLo0) (!CP0) - in - CP0 := - (CP0_EntryLo0_rupd((!CP0),EntryLo_PFN_rupd(x0,(#PFN0) e))) - end - ; let - val x0 = (#EntryLo0) (!CP0) - in - CP0 := (CP0_EntryLo0_rupd((!CP0),EntryLo_C_rupd(x0,(#C0) e))) - end - ; let - val x0 = (#EntryLo0) (!CP0) - in - CP0 := (CP0_EntryLo0_rupd((!CP0),EntryLo_D_rupd(x0,(#D0) e))) - end - ; let - val x0 = (#EntryLo0) (!CP0) - in - CP0 := (CP0_EntryLo0_rupd((!CP0),EntryLo_V_rupd(x0,(#V0) e))) - end - ; let - val x0 = (#EntryLo0) (!CP0) - in - CP0 := (CP0_EntryLo0_rupd((!CP0),EntryLo_G_rupd(x0,(#G) e))) - end - ) - end; - -fun dfn'TLBWI () = - if (not((#CU0)((#Status) (!CP0)))) andalso (not(KernelMode ())) - then SignalException CpU - else if Nat.>=(BitsN.toNat((#Index)((#Index) (!CP0))),TLBEntries) - then let - val j = BitsN.bits((#VPN2)((#EntryHi) (!CP0)),6,0) - in - TLB_direct := - (Map.update - ((!TLB_direct),BitsN.toNat j, - ModifyTLB(Map.lookup((!TLB_direct),BitsN.toNat j)))) - end - else let - val i = BitsN.fromNat(BitsN.toNat((#Index)((#Index) (!CP0))),4) - in - TLB_assoc := - (Map.update - ((!TLB_assoc),BitsN.toNat i, - ModifyTLB(Map.lookup((!TLB_assoc),BitsN.toNat i)))) - end; - -fun dfn'TLBWR () = - if (not((#CU0)((#Status) (!CP0)))) andalso (not(KernelMode ())) - then SignalException CpU - else if (#LTLB)((#Config6) (!CP0)) - then let - val j = BitsN.bits((#VPN2)((#EntryHi) (!CP0)),6,0) - val old = Map.lookup((!TLB_direct),BitsN.toNat j) - in - ( TLB_direct := - (Map.update((!TLB_direct),BitsN.toNat j,ModifyTLB old)) - ; if ((#V0) old) andalso ((#V1) old) - then let - val x = - BitsN.fromNat - (BitsN.toNat((#Random)((#Random) (!CP0))),4) - in - TLB_assoc := - (Map.update((!TLB_assoc),BitsN.toNat x,old)) - end - else () - ) - end - else let - val j = (#Random)((#Random) (!CP0)) - val x = BitsN.fromNat(BitsN.toNat j,4) - in - TLB_assoc := - (Map.update - ((!TLB_assoc),BitsN.toNat x, - ModifyTLB - (Map.lookup - ((!TLB_assoc), - BitsN.toNat(BitsN.fromNat(BitsN.toNat j,4)))))) - end; - -fun dfn'CACHE (base,(opn,offset)) = - if (not((#CU0)((#Status) (!CP0)))) andalso (not(KernelMode ())) - then SignalException CpU - else let - val vAddr = BitsN.+(GPR base,BitsN.signExtend 64 offset) - val x = AddressTranslation(vAddr,(DATA,LOAD)) - in - () - end; - -fun dfn'RDHWR (rt,rd) = - if (((#CU0)((#Status) (!CP0))) orelse (KernelMode ())) orelse - (BitsN.bit(reg'HWREna((#HWREna) (!CP0)),BitsN.toNat rd)) - then case rd of - BitsN.B(0x0,5) => write'GPR(BitsN.B(0x0,64),rt) - | BitsN.B(0x2,5) => - write'GPR(BitsN.signExtend 64 ((#Count) (!CP0)),rt) - | BitsN.B(0x3,5) => write'GPR(BitsN.B(0x1,64),rt) - | BitsN.B(0x1D,5) => write'GPR((#UsrLocal) (!CP0),rt) - | _ => SignalException ResI - else SignalException ResI; - -fun Fetch () = - ( log := [] - ; let - val x0 = (#Random) (!CP0) - in - CP0 := - (CP0_Random_rupd - ((!CP0), - Random_Random_rupd - (x0, - if ((#Random)((#Random) (!CP0))) = - ((#Wired)((#Wired) (!CP0))) - then BitsN.fromNat(Nat.-(TLBEntries,1),8) - else BitsN.-((#Random)((#Random) (!CP0)),BitsN.B(0x1,8))))) - end - ; if ((#Compare) (!CP0)) = ((#Count) (!CP0)) - then ( let - val x0 = (#Cause) (!CP0) - val w = (#IP) x0 - in - CP0 := - (CP0_Cause_rupd - ((!CP0), - CauseRegister_IP_rupd - (x0,BitsN.bitFieldInsert(w,BitsN.fromBit true,7,7)))) - end - ; let - val x0 = (#Cause) (!CP0) - in - CP0 := - (CP0_Cause_rupd((!CP0),CauseRegister_TI_rupd(x0,true))) - end - ) - else () - ; if ((#IE)((#Status) (!CP0))) andalso - (not(((#EXL)((#Status) (!CP0))) orelse ((#ERL)((#Status) (!CP0))))) - then ( let - val x0 = (#Cause) (!CP0) - val w = (#IP) x0 - in - CP0 := - (CP0_Cause_rupd - ((!CP0), - CauseRegister_IP_rupd - (x0, - BitsN.bitFieldInsert - (w,BitsN.bits((#mips_ip_bits) (!PIC),4,0),6,2)))) - end - ; let - val x0 = (#Cause) (!CP0) - val w = (#IP) x0 - in - CP0 := - (CP0_Cause_rupd - ((!CP0), - CauseRegister_IP_rupd - (x0, - BitsN.bitFieldInsert - (w, - BitsN.fromBit - ((BitsN.bit((#IP)((#Cause) (!CP0)),7)) orelse - (BitsN.bit((#mips_ip_bits) (!PIC),5))),7,7)))) - end - ; if not((BitsN.&& - (BitsN.bits((#IM)((#Status) (!CP0)),7,2), - BitsN.bits((#IP)((#Cause) (!CP0)),7,2))) = - (BitsN.B(0x0,6))) - then SignalException Int - else () - ) - else () - ; if (!exceptionSignalled) - then NONE - else if (BitsN.bits((!PC),1,0)) = (BitsN.B(0x0,2)) - then let - val (pc,cca) = AddressTranslation((!PC),(INSTRUCTION,LOAD)) - in - if (!exceptionSignalled) - then NONE - else Option.SOME(loadWord32 pc) - end - else ( CP0 := (CP0_BadVAddr_rupd((!CP0),(!PC))) - ; SignalException AdEL - ; NONE - ) - ); - -fun initTLB () = - let - val e = ref {ASID = BitsN.B(0x0,8), C0 = BitsN.B(0x0,3), - C1 = BitsN.B(0x0,3), D0 = false, D1 = false, G = false, - Mask = BitsN.B(0x0,12), PFN0 = BitsN.B(0x0,28), - PFN1 = BitsN.B(0x0,28), R = BitsN.B(0x0,2), V0 = false, V1 = false, - VPN2 = BitsN.B(0x0,27)} - in - ( e := (TLBEntry_R_rupd((!e),BitsN.B(0x2,2))); (!e) ) - end; - -fun addTLB (a,i) = - let - val pfn = BitsN.bits(a,39,12) - in - ( let - val x0 = Map.lookup((!TLB_assoc),BitsN.toNat i) - in - TLB_assoc := - (Map.update - ((!TLB_assoc),BitsN.toNat i, - TLBEntry_VPN2_rupd - (x0,BitsN.fromNat(BitsN.toNat(BitsN.>>+(pfn,1)),27)))) - end - ; let - val x0 = Map.lookup((!TLB_assoc),BitsN.toNat i) - in - TLB_assoc := - (Map.update - ((!TLB_assoc),BitsN.toNat i,TLBEntry_R_rupd(x0,BitsN.B(0x0,2)))) - end - ; let - val x0 = Map.lookup((!TLB_assoc),BitsN.toNat i) - in - TLB_assoc := - (Map.update((!TLB_assoc),BitsN.toNat i,TLBEntry_G_rupd(x0,true))) - end - ; if BitsN.bit(a,12) - then ( let - val x0 = Map.lookup((!TLB_assoc),BitsN.toNat i) - in - TLB_assoc := - (Map.update - ((!TLB_assoc),BitsN.toNat i,TLBEntry_PFN1_rupd(x0,pfn))) - end - ; let - val x0 = Map.lookup((!TLB_assoc),BitsN.toNat i) - in - TLB_assoc := - (Map.update - ((!TLB_assoc),BitsN.toNat i, - TLBEntry_C1_rupd(x0,BitsN.B(0x2,3)))) - end - ; let - val x0 = Map.lookup((!TLB_assoc),BitsN.toNat i) - in - TLB_assoc := - (Map.update - ((!TLB_assoc),BitsN.toNat i,TLBEntry_D1_rupd(x0,true))) - end - ; let - val x0 = Map.lookup((!TLB_assoc),BitsN.toNat i) - in - TLB_assoc := - (Map.update - ((!TLB_assoc),BitsN.toNat i,TLBEntry_V1_rupd(x0,true))) - end - ) - else ( let - val x0 = Map.lookup((!TLB_assoc),BitsN.toNat i) - in - TLB_assoc := - (Map.update - ((!TLB_assoc),BitsN.toNat i,TLBEntry_PFN0_rupd(x0,pfn))) - end - ; let - val x0 = Map.lookup((!TLB_assoc),BitsN.toNat i) - in - TLB_assoc := - (Map.update - ((!TLB_assoc),BitsN.toNat i, - TLBEntry_C0_rupd(x0,BitsN.B(0x2,3)))) - end - ; let - val x0 = Map.lookup((!TLB_assoc),BitsN.toNat i) - in - TLB_assoc := - (Map.update - ((!TLB_assoc),BitsN.toNat i,TLBEntry_D0_rupd(x0,true))) - end - ; let - val x0 = Map.lookup((!TLB_assoc),BitsN.toNat i) - in - TLB_assoc := - (Map.update - ((!TLB_assoc),BitsN.toNat i,TLBEntry_V0_rupd(x0,true))) - end - ) - ) - end; - -fun initMips (pc,uart) = - ( let - val x0 = (#Config) (!CP0) - in - CP0 := (CP0_Config_rupd((!CP0),ConfigRegister_M_rupd(x0,true))) - end - ; let - val x0 = (#Config) (!CP0) - in - CP0 := (CP0_Config_rupd((!CP0),ConfigRegister_BE_rupd(x0,true))) - end - ; let - val x0 = (#Config) (!CP0) - in - CP0 := - (CP0_Config_rupd((!CP0),ConfigRegister_MT_rupd(x0,BitsN.B(0x1,3)))) - end - ; let - val x0 = (#Config) (!CP0) - in - CP0 := - (CP0_Config_rupd((!CP0),ConfigRegister_AR_rupd(x0,BitsN.B(0x0,3)))) - end - ; let - val x0 = (#Config) (!CP0) - in - CP0 := - (CP0_Config_rupd((!CP0),ConfigRegister_AT_rupd(x0,BitsN.B(0x2,2)))) - end - ; let - val x0 = (#Config1) (!CP0) - in - CP0 := (CP0_Config1_rupd((!CP0),ConfigRegister1_M_rupd(x0,true))) - end - ; let - val x0 = (#Config1) (!CP0) - in - CP0 := - (CP0_Config1_rupd - ((!CP0),ConfigRegister1_MMUSize_rupd(x0,BitsN.B(0xF,6)))) - end - ; let - val x0 = (#Config1) (!CP0) - in - CP0 := - (CP0_Config1_rupd((!CP0),ConfigRegister1_IS_rupd(x0,BitsN.B(0x3,3)))) - end - ; let - val x0 = (#Config1) (!CP0) - in - CP0 := - (CP0_Config1_rupd((!CP0),ConfigRegister1_IL_rupd(x0,BitsN.B(0x4,3)))) - end - ; let - val x0 = (#Config1) (!CP0) - in - CP0 := - (CP0_Config1_rupd((!CP0),ConfigRegister1_IA_rupd(x0,BitsN.B(0x0,3)))) - end - ; let - val x0 = (#Config1) (!CP0) - in - CP0 := - (CP0_Config1_rupd((!CP0),ConfigRegister1_DS_rupd(x0,BitsN.B(0x3,3)))) - end - ; let - val x0 = (#Config1) (!CP0) - in - CP0 := - (CP0_Config1_rupd((!CP0),ConfigRegister1_DL_rupd(x0,BitsN.B(0x4,3)))) - end - ; let - val x0 = (#Config1) (!CP0) - in - CP0 := - (CP0_Config1_rupd((!CP0),ConfigRegister1_DA_rupd(x0,BitsN.B(0x0,3)))) - end - ; let - val x0 = (#Config1) (!CP0) - in - CP0 := (CP0_Config1_rupd((!CP0),ConfigRegister1_C2_rupd(x0,false))) - end - ; let - val x0 = (#Config1) (!CP0) - in - CP0 := (CP0_Config1_rupd((!CP0),ConfigRegister1_MD_rupd(x0,false))) - end - ; let - val x0 = (#Config1) (!CP0) - in - CP0 := (CP0_Config1_rupd((!CP0),ConfigRegister1_PC_rupd(x0,false))) - end - ; let - val x0 = (#Config1) (!CP0) - in - CP0 := (CP0_Config1_rupd((!CP0),ConfigRegister1_WR_rupd(x0,false))) - end - ; let - val x0 = (#Config1) (!CP0) - in - CP0 := (CP0_Config1_rupd((!CP0),ConfigRegister1_CA_rupd(x0,false))) - end - ; let - val x0 = (#Config1) (!CP0) - in - CP0 := (CP0_Config1_rupd((!CP0),ConfigRegister1_EP_rupd(x0,false))) - end - ; let - val x0 = (#Config1) (!CP0) - in - CP0 := (CP0_Config1_rupd((!CP0),ConfigRegister1_FP_rupd(x0,false))) - end - ; let - val x0 = (#Config2) (!CP0) - in - CP0 := (CP0_Config2_rupd((!CP0),ConfigRegister2_M_rupd(x0,true))) - end - ; let - val x0 = (#Config2) (!CP0) - in - CP0 := - (CP0_Config2_rupd((!CP0),ConfigRegister2_TU_rupd(x0,BitsN.B(0x0,3)))) - end - ; let - val x0 = (#Config2) (!CP0) - in - CP0 := - (CP0_Config2_rupd((!CP0),ConfigRegister2_TS_rupd(x0,BitsN.B(0x0,4)))) - end - ; let - val x0 = (#Config2) (!CP0) - in - CP0 := - (CP0_Config2_rupd((!CP0),ConfigRegister2_TL_rupd(x0,BitsN.B(0x0,4)))) - end - ; let - val x0 = (#Config2) (!CP0) - in - CP0 := - (CP0_Config2_rupd((!CP0),ConfigRegister2_TA_rupd(x0,BitsN.B(0x0,4)))) - end - ; let - val x0 = (#Config2) (!CP0) - in - CP0 := - (CP0_Config2_rupd((!CP0),ConfigRegister2_SU_rupd(x0,BitsN.B(0x3,4)))) - end - ; let - val x0 = (#Config2) (!CP0) - in - CP0 := - (CP0_Config2_rupd((!CP0),ConfigRegister2_SS_rupd(x0,BitsN.B(0x8,4)))) - end - ; let - val x0 = (#Config2) (!CP0) - in - CP0 := - (CP0_Config2_rupd((!CP0),ConfigRegister2_SL_rupd(x0,BitsN.B(0x4,4)))) - end - ; let - val x0 = (#Config2) (!CP0) - in - CP0 := - (CP0_Config2_rupd((!CP0),ConfigRegister2_SA_rupd(x0,BitsN.B(0x0,4)))) - end - ; let - val x0 = (#Config3) (!CP0) - in - CP0 := (CP0_Config3_rupd((!CP0),ConfigRegister3_M_rupd(x0,true))) - end - ; let - val x0 = (#Config3) (!CP0) - in - CP0 := (CP0_Config3_rupd((!CP0),ConfigRegister3_ULRI_rupd(x0,true))) - end - ; let - val x0 = (#Config3) (!CP0) - in - CP0 := - (CP0_Config3_rupd((!CP0),ConfigRegister3_DSPP_rupd(x0,false))) - end - ; let - val x0 = (#Config3) (!CP0) - in - CP0 := (CP0_Config3_rupd((!CP0),ConfigRegister3_LPA_rupd(x0,false))) - end - ; let - val x0 = (#Config3) (!CP0) - in - CP0 := - (CP0_Config3_rupd((!CP0),ConfigRegister3_VEIC_rupd(x0,false))) - end - ; let - val x0 = (#Config3) (!CP0) - in - CP0 := - (CP0_Config3_rupd((!CP0),ConfigRegister3_VInt_rupd(x0,false))) - end - ; let - val x0 = (#Config3) (!CP0) - in - CP0 := (CP0_Config3_rupd((!CP0),ConfigRegister3_SP_rupd(x0,false))) - end - ; let - val x0 = (#Config3) (!CP0) - in - CP0 := (CP0_Config3_rupd((!CP0),ConfigRegister3_MT_rupd(x0,false))) - end - ; let - val x0 = (#Config3) (!CP0) - in - CP0 := (CP0_Config3_rupd((!CP0),ConfigRegister3_SM_rupd(x0,false))) - end - ; let - val x0 = (#Config3) (!CP0) - in - CP0 := (CP0_Config3_rupd((!CP0),ConfigRegister3_TL_rupd(x0,false))) - end - ; let - val x0 = (#Config6) (!CP0) - in - CP0 := - (CP0_Config6_rupd - ((!CP0),ConfigRegister6_TLBSize_rupd(x0,BitsN.B(0x8F,16)))) - end - ; let - val x0 = (#Config6) (!CP0) - in - CP0 := - (CP0_Config6_rupd((!CP0),ConfigRegister6_LTLB_rupd(x0,false))) - end - ; let - val x0 = (#Status) (!CP0) - in - CP0 := - (CP0_Status_rupd - ((!CP0),write'reg'StatusRegister(x0,BitsN.B(0x0,32)))) - end - ; let - val x0 = (#Status) (!CP0) - in - CP0 := (CP0_Status_rupd((!CP0),StatusRegister_BEV_rupd(x0,true))) - end - ; let - val x0 = (#Status) (!CP0) - in - CP0 := - (CP0_Status_rupd((!CP0),StatusRegister_KSU_rupd(x0,BitsN.B(0x0,2)))) - end - ; let - val x0 = (#Status) (!CP0) - in - CP0 := (CP0_Status_rupd((!CP0),StatusRegister_EXL_rupd(x0,false))) - end - ; let - val x0 = (#Status) (!CP0) - in - CP0 := (CP0_Status_rupd((!CP0),StatusRegister_ERL_rupd(x0,false))) - end - ; let - val x0 = (#Status) (!CP0) - in - CP0 := (CP0_Status_rupd((!CP0),StatusRegister_KX_rupd(x0,true))) - end - ; let - val x0 = (#Status) (!CP0) - in - CP0 := (CP0_Status_rupd((!CP0),StatusRegister_SX_rupd(x0,true))) - end - ; let - val x0 = (#Status) (!CP0) - in - CP0 := (CP0_Status_rupd((!CP0),StatusRegister_UX_rupd(x0,true))) - end - ; CP0 := (CP0_Count_rupd((!CP0),BitsN.B(0x0,32))) - ; CP0 := (CP0_Compare_rupd((!CP0),BitsN.B(0x0,32))) - ; CP0 := (CP0_PRId_rupd((!CP0),BitsN.B(0x400,32))) - ; let - val x0 = (#Index) (!CP0) - in - CP0 := (CP0_Index_rupd((!CP0),Index_P_rupd(x0,false))) - end - ; let - val x0 = (#Index) (!CP0) - in - CP0 := (CP0_Index_rupd((!CP0),Index_Index_rupd(x0,BitsN.B(0x0,8)))) - end - ; let - val x0 = (#Random) (!CP0) - in - CP0 := - (CP0_Random_rupd - ((!CP0), - Random_Random_rupd(x0,BitsN.fromNat(Nat.-(TLBEntries,1),8)))) - end - ; let - val x0 = (#Wired) (!CP0) - in - CP0 := (CP0_Wired_rupd((!CP0),Wired_Wired_rupd(x0,BitsN.B(0x0,8)))) - end - ; let - val x0 = (#HWREna) (!CP0) - in - CP0 := - (CP0_HWREna_rupd((!CP0),write'reg'HWREna(x0,BitsN.B(0x0,32)))) + (CP0_Status_rupd((!CP0),StatusRegister_EXL_rupd(x0,true))) + end + ; let + val vectorBase = + if (#BEV)((#Status) (!CP0)) + then BitsN.B(0xFFFFFFFFBFC00200,64) + else BitsN.B(0xFFFFFFFF80000000,64) + in + ( BranchDelay := NONE + ; BranchTo := + (Option.SOME + (true, + BitsN.@@ + (BitsN.bits(vectorBase,63,30), + BitsN.+(BitsN.bits(vectorBase,29,0),vectorOffset)))) + ; exceptionSignalled := true + ) + end + ) end - ; TLB_assoc := (Map.mkMap(SOME 16,initTLB ())) - ; BranchDelay := NONE - ; BranchTo := NONE - ; LLbit := NONE - ; hi := NONE - ; lo := NONE - ; PC := (BitsN.fromNat(pc,64)) - ; MEM := (Map.mkMap(SOME 137438953472,BitsN.B(0x0,64))) - ; gpr := (Map.mkMap(SOME 32,BitsN.B(0xAAAAAAAAAAAAAAAA,64))) - ; JTAG_UART_initialise uart - ; PIC_initialise 2139111424 ); -fun done () = - case (!log) of [w_c0(BitsN.B(0x17,5),_)] => true | _ => false; +val BYTE = BitsN.B(0x0,3) + +val HALFWORD = BitsN.B(0x1,3) + +val WORD = BitsN.B(0x3,3) + +val DOUBLEWORD = BitsN.B(0x7,3) + +fun UserMode () = + (((#KSU)((#Status) (!CP0))) = (BitsN.B(0x2,2))) andalso + (not(((#EXL)((#Status) (!CP0))) orelse ((#ERL)((#Status) (!CP0))))); + +fun SupervisorMode () = + (((#KSU)((#Status) (!CP0))) = (BitsN.B(0x1,2))) andalso + (not(((#EXL)((#Status) (!CP0))) orelse ((#ERL)((#Status) (!CP0))))); + +fun KernelMode () = + ((((#KSU)((#Status) (!CP0))) = (BitsN.B(0x0,2))) orelse + ((#EXL)((#Status) (!CP0)))) orelse ((#ERL)((#Status) (!CP0))); + +fun BigEndianMem () = (#BE)((#Config) (!CP0)); + +fun ReverseEndian () = + BitsN.fromBit(((#RE)((#Status) (!CP0))) andalso (UserMode ())); + +fun BigEndianCPU () = + BitsN.??(BitsN.fromBit(BigEndianMem ()),ReverseEndian ()); + +fun GPR n = + if n = (BitsN.B(0x0,5)) + then BitsN.B(0x0,64) + else Map.lookup((!gpr),BitsN.toNat n); + +fun write'GPR (value,n) = + if not(n = (BitsN.B(0x0,5))) + then gpr := (Map.update((!gpr),BitsN.toNat n,value)) + else (); + +fun HI () = + case (!hi) of Option.SOME v => v | NONE => raise UNPREDICTABLE ("HI"); + +fun write'HI value = hi := (Option.SOME value); + +fun LO () = + case (!lo) of Option.SOME v => v | NONE => raise UNPREDICTABLE ("LO"); + +fun write'LO value = lo := (Option.SOME value); + +fun CPR (n,(reg,sel)) = + case (n,(reg,sel)) of + (0,(BitsN.B(0x8,5),BitsN.B(0x0,3))) => (#BadVAddr) (!CP0) + | (0,(BitsN.B(0x9,5),BitsN.B(0x0,3))) => + BitsN.fromNat(BitsN.toNat((#Count) (!CP0)),64) + | (0,(BitsN.B(0xB,5),BitsN.B(0x0,3))) => + BitsN.fromNat(BitsN.toNat((#Compare) (!CP0)),64) + | (0,(BitsN.B(0xC,5),BitsN.B(0x0,3))) => + BitsN.fromNat + (BitsN.toNat(reg'StatusRegister((#Status) (!CP0))),64) + | (0,(BitsN.B(0xD,5),BitsN.B(0x0,3))) => + BitsN.fromNat(BitsN.toNat(reg'CauseRegister((#Cause) (!CP0))),64) + | (0,(BitsN.B(0xE,5),BitsN.B(0x0,3))) => (#EPC) (!CP0) + | (0,(BitsN.B(0xF,5),BitsN.B(0x0,3))) => + BitsN.fromNat(BitsN.toNat((#PRId) (!CP0)),64) + | (0,(BitsN.B(0x10,5),BitsN.B(0x0,3))) => + BitsN.fromNat + (BitsN.toNat(reg'ConfigRegister((#Config) (!CP0))),64) + | (0,(BitsN.B(0x11,5),BitsN.B(0x0,3))) => + BitsN.fromNat(BitsN.toNat((#LLAddr) (!CP0)),64) + | (0,(BitsN.B(0x17,5),BitsN.B(0x0,3))) => + BitsN.fromNat(BitsN.toNat((#Debug) (!CP0)),64) + | (0,(BitsN.B(0x1A,5),BitsN.B(0x0,3))) => + BitsN.fromNat(BitsN.toNat((#ErrCtl) (!CP0)),64) + | (0,(BitsN.B(0x1E,5),BitsN.B(0x0,3))) => (#ErrorEPC) (!CP0) + | _ => BitsN.B(0x0,64); + +fun write'CPR (value,(n,(reg,sel))) = + case (n,(reg,sel)) of + (0,(BitsN.B(0x9,5),BitsN.B(0x0,3))) => + CP0 := (CP0_Count_rupd((!CP0),BitsN.bits(value,31,0))) + | (0,(BitsN.B(0xB,5),BitsN.B(0x0,3))) => + CP0 := (CP0_Compare_rupd((!CP0),BitsN.bits(value,31,0))) + | (0,(BitsN.B(0xC,5),BitsN.B(0x0,3))) => + let + val x0 = (#Status) (!CP0) + in + CP0 := + (CP0_Status_rupd + ((!CP0),write'reg'StatusRegister(x0,BitsN.bits(value,31,0)))) + end + | (0,(BitsN.B(0xD,5),BitsN.B(0x0,3))) => + let + val x0 = (#Cause) (!CP0) + in + CP0 := + (CP0_Cause_rupd + ((!CP0),write'reg'CauseRegister(x0,BitsN.bits(value,31,0)))) + end + | (0,(BitsN.B(0xE,5),BitsN.B(0x0,3))) => + CP0 := (CP0_EPC_rupd((!CP0),value)) + | (0,(BitsN.B(0x10,5),BitsN.B(0x0,3))) => + let + val x0 = (#Config) (!CP0) + in + CP0 := + (CP0_Config_rupd + ((!CP0),write'reg'ConfigRegister(x0,BitsN.bits(value,31,0)))) + end + | (0,(BitsN.B(0x17,5),BitsN.B(0x0,3))) => + CP0 := (CP0_Debug_rupd((!CP0),BitsN.bits(value,31,0))) + | (0,(BitsN.B(0x1A,5),BitsN.B(0x0,3))) => + CP0 := (CP0_ErrCtl_rupd((!CP0),BitsN.bits(value,31,0))) + | (0,(BitsN.B(0x1E,5),BitsN.B(0x0,3))) => + CP0 := (CP0_ErrorEPC_rupd((!CP0),value)) + | _ => (); + +val PSIZE = 64 + +fun AddressTranslation (vAddr,(IorD,LorS)) = (vAddr,BitsN.B(0x2,3)); + +fun LoadMemory (CCA,(AccessLength,(pAddr,(vAddr,IorD)))) = + let + val a = BitsN.&&(pAddr,BitsN.~(BitsN.B(0x7,64))) + in + if BigEndianMem () + then BitsN.concat + [Map.lookup((!MEM),BitsN.toNat a), + Map.lookup((!MEM),BitsN.toNat(BitsN.+(a,BitsN.B(0x1,64)))), + Map.lookup((!MEM),BitsN.toNat(BitsN.+(a,BitsN.B(0x2,64)))), + Map.lookup((!MEM),BitsN.toNat(BitsN.+(a,BitsN.B(0x3,64)))), + Map.lookup((!MEM),BitsN.toNat(BitsN.+(a,BitsN.B(0x4,64)))), + Map.lookup((!MEM),BitsN.toNat(BitsN.+(a,BitsN.B(0x5,64)))), + Map.lookup((!MEM),BitsN.toNat(BitsN.+(a,BitsN.B(0x6,64)))), + Map.lookup((!MEM),BitsN.toNat(BitsN.+(a,BitsN.B(0x7,64))))] + else BitsN.concat + [Map.lookup((!MEM),BitsN.toNat(BitsN.+(a,BitsN.B(0x7,64)))), + Map.lookup((!MEM),BitsN.toNat(BitsN.+(a,BitsN.B(0x6,64)))), + Map.lookup((!MEM),BitsN.toNat(BitsN.+(a,BitsN.B(0x5,64)))), + Map.lookup((!MEM),BitsN.toNat(BitsN.+(a,BitsN.B(0x4,64)))), + Map.lookup((!MEM),BitsN.toNat(BitsN.+(a,BitsN.B(0x3,64)))), + Map.lookup((!MEM),BitsN.toNat(BitsN.+(a,BitsN.B(0x2,64)))), + Map.lookup((!MEM),BitsN.toNat(BitsN.+(a,BitsN.B(0x1,64)))), + Map.lookup((!MEM),BitsN.toNat a)] + end; + +fun StoreMemory (CCA,(AccessLength,(MemElem,(pAddr,(vAddr,IorD))))) = + let + val a = BitsN.&&(pAddr,BitsN.~(BitsN.B(0x7,64))) + val l = BitsN.bits(pAddr,2,0) + val h = BitsN.+(l,AccessLength) + in + if BigEndianMem () + then ( if l = (BitsN.B(0x0,3)) + then MEM := + (Map.update + ((!MEM),BitsN.toNat a,BitsN.bits(MemElem,63,56))) + else () + ; if (BitsN.<=+(l,BitsN.B(0x1,3))) andalso + (BitsN.<=+(BitsN.B(0x1,3),h)) + then let + val x = BitsN.+(a,BitsN.B(0x1,64)) + in + MEM := + (Map.update + ((!MEM),BitsN.toNat x,BitsN.bits(MemElem,55,48))) + end + else () + ; if (BitsN.<=+(l,BitsN.B(0x2,3))) andalso + (BitsN.<=+(BitsN.B(0x2,3),h)) + then let + val x = BitsN.+(a,BitsN.B(0x2,64)) + in + MEM := + (Map.update + ((!MEM),BitsN.toNat x,BitsN.bits(MemElem,47,40))) + end + else () + ; if (BitsN.<=+(l,BitsN.B(0x3,3))) andalso + (BitsN.<=+(BitsN.B(0x3,3),h)) + then let + val x = BitsN.+(a,BitsN.B(0x3,64)) + in + MEM := + (Map.update + ((!MEM),BitsN.toNat x,BitsN.bits(MemElem,39,32))) + end + else () + ; if (BitsN.<=+(l,BitsN.B(0x4,3))) andalso + (BitsN.<=+(BitsN.B(0x4,3),h)) + then let + val x = BitsN.+(a,BitsN.B(0x4,64)) + in + MEM := + (Map.update + ((!MEM),BitsN.toNat x,BitsN.bits(MemElem,31,24))) + end + else () + ; if (BitsN.<=+(l,BitsN.B(0x5,3))) andalso + (BitsN.<=+(BitsN.B(0x5,3),h)) + then let + val x = BitsN.+(a,BitsN.B(0x5,64)) + in + MEM := + (Map.update + ((!MEM),BitsN.toNat x,BitsN.bits(MemElem,23,16))) + end + else () + ; if (BitsN.<=+(l,BitsN.B(0x6,3))) andalso + (BitsN.<=+(BitsN.B(0x6,3),h)) + then let + val x = BitsN.+(a,BitsN.B(0x6,64)) + in + MEM := + (Map.update + ((!MEM),BitsN.toNat x,BitsN.bits(MemElem,15,8))) + end + else () + ; if (BitsN.<=+(l,BitsN.B(0x7,3))) andalso + (BitsN.<=+(BitsN.B(0x7,3),h)) + then let + val x = BitsN.+(a,BitsN.B(0x7,64)) + in + MEM := + (Map.update + ((!MEM),BitsN.toNat x,BitsN.bits(MemElem,7,0))) + end + else () + ) + else ( if (BitsN.<=+(l,BitsN.B(0x7,3))) andalso + (BitsN.<=+(BitsN.B(0x7,3),h)) + then let + val x = BitsN.+(a,BitsN.B(0x7,64)) + in + MEM := + (Map.update + ((!MEM),BitsN.toNat x,BitsN.bits(MemElem,63,56))) + end + else () + ; if (BitsN.<=+(l,BitsN.B(0x6,3))) andalso + (BitsN.<=+(BitsN.B(0x6,3),h)) + then let + val x = BitsN.+(a,BitsN.B(0x6,64)) + in + MEM := + (Map.update + ((!MEM),BitsN.toNat x,BitsN.bits(MemElem,55,48))) + end + else () + ; if (BitsN.<=+(l,BitsN.B(0x5,3))) andalso + (BitsN.<=+(BitsN.B(0x5,3),h)) + then let + val x = BitsN.+(a,BitsN.B(0x5,64)) + in + MEM := + (Map.update + ((!MEM),BitsN.toNat x,BitsN.bits(MemElem,47,40))) + end + else () + ; if (BitsN.<=+(l,BitsN.B(0x4,3))) andalso + (BitsN.<=+(BitsN.B(0x4,3),h)) + then let + val x = BitsN.+(a,BitsN.B(0x4,64)) + in + MEM := + (Map.update + ((!MEM),BitsN.toNat x,BitsN.bits(MemElem,39,32))) + end + else () + ; if (BitsN.<=+(l,BitsN.B(0x3,3))) andalso + (BitsN.<=+(BitsN.B(0x3,3),h)) + then let + val x = BitsN.+(a,BitsN.B(0x3,64)) + in + MEM := + (Map.update + ((!MEM),BitsN.toNat x,BitsN.bits(MemElem,31,24))) + end + else () + ; if (BitsN.<=+(l,BitsN.B(0x2,3))) andalso + (BitsN.<=+(BitsN.B(0x2,3),h)) + then let + val x = BitsN.+(a,BitsN.B(0x2,64)) + in + MEM := + (Map.update + ((!MEM),BitsN.toNat x,BitsN.bits(MemElem,23,16))) + end + else () + ; if (BitsN.<=+(l,BitsN.B(0x1,3))) andalso + (BitsN.<=+(BitsN.B(0x1,3),h)) + then let + val x = BitsN.+(a,BitsN.B(0x1,64)) + in + MEM := + (Map.update + ((!MEM),BitsN.toNat x,BitsN.bits(MemElem,15,8))) + end + else () + ; if l = (BitsN.B(0x0,3)) + then MEM := + (Map.update + ((!MEM),BitsN.toNat a,BitsN.bits(MemElem,7,0))) + else () + ) + end; + +fun Fetch () = + if (BitsN.bits((!PC),1,0)) = (BitsN.B(0x0,2)) + then let + val vAddr = (!PC) + val (pAddr,CCA) = AddressTranslation(vAddr,(INSTRUCTION,LOAD)) + val memdoubleword = + LoadMemory(CCA,(WORD,(pAddr,(vAddr,INSTRUCTION)))) + val bytesel = + BitsN.?? + (BitsN.bits(vAddr,2,0), + BitsN.@@(BigEndianCPU (),BitsN.B(0x0,2))) + val memword = + BitsN.bits + (memdoubleword,Nat.+(31,Nat.*(8,BitsN.toNat bytesel)), + Nat.*(8,BitsN.toNat bytesel)) + in + Option.SOME memword + end + else ( SignalException AdEL; NONE ); fun NotWordValue value = let @@ -5433,11 +3232,6 @@ fun NotWordValue value = else not(top = (BitsN.B(0x0,32))) end; -fun CheckBranch () = - if Option.isSome (!BranchDelay) - then raise UNPREDICTABLE ("Not permitted in delay slot") - else (); - fun dfn'ADDI (rs,(rt,immediate)) = ( if NotWordValue(GPR rs) then raise UNPREDICTABLE ("ADDI: NotWordValue") @@ -6135,7 +3929,7 @@ fun dfn'LWL (base,(rt,offset)) = val pAddr = if BigEndianMem () then pAddr - else BitsN.&&(pAddr,BitsN.~(BitsN.B(0x7,40))) + else BitsN.&&(pAddr,BitsN.~(BitsN.B(0x7,64))) val byte = BitsN.?? (BitsN.bits(vAddr,1,0), @@ -6196,7 +3990,7 @@ fun dfn'LWR (base,(rt,offset)) = val pAddr = if BigEndianMem () then pAddr - else BitsN.&&(pAddr,BitsN.~(BitsN.B(0x7,40))) + else BitsN.&&(pAddr,BitsN.~(BitsN.B(0x7,64))) val byte = BitsN.?? (BitsN.bits(vAddr,1,0), @@ -6259,7 +4053,7 @@ fun dfn'LDL (base,(rt,offset)) = val pAddr = if BigEndianMem () then pAddr - else BitsN.&&(pAddr,BitsN.~(BitsN.B(0x7,40))) + else BitsN.&&(pAddr,BitsN.~(BitsN.B(0x7,64))) val byte = BitsN.?? (BitsN.bits(vAddr,2,0), @@ -6321,7 +4115,7 @@ fun dfn'LDR (base,(rt,offset)) = val pAddr = if BigEndianMem () then pAddr - else BitsN.&&(pAddr,BitsN.~(BitsN.B(0x7,40))) + else BitsN.&&(pAddr,BitsN.~(BitsN.B(0x7,64))) val byte = BitsN.?? (BitsN.bits(vAddr,2,0), @@ -6530,7 +4324,7 @@ fun dfn'SWL (base,(rt,offset)) = val pAddr = if BigEndianMem () then pAddr - else BitsN.&&(pAddr,BitsN.~(BitsN.B(0x3,40))) + else BitsN.&&(pAddr,BitsN.~(BitsN.B(0x3,64))) val byte = BitsN.?? (BitsN.bits(vAddr,1,0), @@ -6579,7 +4373,7 @@ fun dfn'SWR (base,(rt,offset)) = BitsN.resize_replicate 3 (ReverseEndian (),3))) val pAddr = if BigEndianMem () - then BitsN.&&(pAddr,BitsN.~(BitsN.B(0x3,40))) + then BitsN.&&(pAddr,BitsN.~(BitsN.B(0x3,64))) else pAddr val byte = BitsN.?? @@ -6644,7 +4438,7 @@ fun dfn'SDL (base,(rt,offset)) = val pAddr = if BigEndianMem () then pAddr - else BitsN.&&(pAddr,BitsN.~(BitsN.B(0x7,40))) + else BitsN.&&(pAddr,BitsN.~(BitsN.B(0x7,64))) val byte = BitsN.?? (BitsN.bits(vAddr,2,0), @@ -6695,7 +4489,7 @@ fun dfn'SDR (base,(rt,offset)) = BitsN.resize_replicate 3 (ReverseEndian (),3))) val pAddr = if BigEndianMem () - then BitsN.&&(pAddr,BitsN.~(BitsN.B(0x7,40))) + then BitsN.&&(pAddr,BitsN.~(BitsN.B(0x7,64))) else pAddr val byte = BitsN.?? @@ -6749,31 +4543,33 @@ fun dfn'BREAK () = SignalException Bp; fun dfn'SYSCALL () = SignalException Sys; fun dfn'ERET () = - ( CheckBranch () - ; if ((#CU0)((#Status) (!CP0))) orelse (KernelMode ()) - then ( if (#ERL)((#Status) (!CP0)) - then ( PC := (BitsN.-((#ErrorEPC) (!CP0),BitsN.B(0x4,64))) - ; let - val x0 = (#Status) (!CP0) - in - CP0 := - (CP0_Status_rupd - ((!CP0),StatusRegister_ERL_rupd(x0,false))) - end - ) - else ( PC := (BitsN.-((#EPC) (!CP0),BitsN.B(0x4,64))) + if ((#CU0)((#Status) (!CP0))) orelse (KernelMode ()) + then ( if (#ERL)((#Status) (!CP0)) + then ( BranchTo := + (Option.SOME + (true,BitsN.-((#ErrorEPC) (!CP0),BitsN.B(0x4,64)))) ; let val x0 = (#Status) (!CP0) in CP0 := (CP0_Status_rupd - ((!CP0),StatusRegister_EXL_rupd(x0,false))) + ((!CP0),StatusRegister_ERL_rupd(x0,false))) end ) - ; LLbit := (Option.SOME false) - ) - else SignalException CpU - ); + else ( BranchTo := + (Option.SOME + (true,BitsN.-((#EPC) (!CP0),BitsN.B(0x4,64)))) + ; let + val x0 = (#Status) (!CP0) + in + CP0 := + (CP0_Status_rupd + ((!CP0),StatusRegister_EXL_rupd(x0,false))) + end + ) + ; LLbit := (Option.SOME false) + ) + else SignalException CpU; fun dfn'MTC0 (rt,(rd,sel)) = if ((#CU0)((#Status) (!CP0))) orelse (KernelMode ()) @@ -6799,92 +4595,74 @@ fun dfn'DMFC0 (rt,(rd,sel)) = fun dfn'J instr_index = BranchTo := (Option.SOME - (BitsN.concat[BitsN.bits((!PC),63,28),instr_index,BitsN.B(0x0,2)])); + (false, + BitsN.concat[BitsN.bits((!PC),63,28),instr_index,BitsN.B(0x0,2)])); fun dfn'JAL instr_index = ( write'GPR(BitsN.+((!PC),BitsN.B(0x8,64)),BitsN.B(0x1F,5)) ; BranchTo := (Option.SOME - (BitsN.concat[BitsN.bits((!PC),63,28),instr_index,BitsN.B(0x0,2)])) + (false, + BitsN.concat[BitsN.bits((!PC),63,28),instr_index,BitsN.B(0x0,2)])) ); -fun dfn'JR rs = BranchTo := (Option.SOME(GPR rs)); +fun dfn'JR rs = BranchTo := (Option.SOME(false,GPR rs)); fun dfn'JALR (rs,rd) = let val temp = GPR rs in ( write'GPR(BitsN.+((!PC),BitsN.B(0x8,64)),rd) - ; BranchTo := (Option.SOME temp) + ; BranchTo := (Option.SOME(false,temp)) ) end; -fun dfn'BEQ (rs,(rt,offset)) = - if (GPR rs) = (GPR rt) +fun ConditionalBranch (b,offset) = + BranchTo := + (Option.SOME + (if b + then (false, + BitsN.+ + (BitsN.+((!PC),BitsN.B(0x4,64)), + BitsN.<<(BitsN.signExtend 64 offset,2))) + else (true,BitsN.+((!PC),BitsN.B(0x4,64))))); + +fun ConditionalBranchLikely (b,offset) = + if b then BranchTo := (Option.SOME - (BitsN.+ + (false, + BitsN.+ (BitsN.+((!PC),BitsN.B(0x4,64)), BitsN.<<(BitsN.signExtend 64 offset,2)))) - else CheckBranch (); + else if Option.isSome (!BranchDelay) + then BranchTo := (Option.SOME(true,BitsN.+((!PC),BitsN.B(0x8,64)))) + else PC := (BitsN.+((!PC),BitsN.B(0x4,64))); + +fun dfn'BEQ (rs,(rt,offset)) = + ConditionalBranch((GPR rs) = (GPR rt),offset); fun dfn'BNE (rs,(rt,offset)) = - if not((GPR rs) = (GPR rt)) - then BranchTo := - (Option.SOME - (BitsN.+ - (BitsN.+((!PC),BitsN.B(0x4,64)), - BitsN.<<(BitsN.signExtend 64 offset,2)))) - else CheckBranch (); + ConditionalBranch(not((GPR rs) = (GPR rt)),offset); fun dfn'BLEZ (rs,offset) = - if BitsN.<=(GPR rs,BitsN.B(0x0,64)) - then BranchTo := - (Option.SOME - (BitsN.+ - (BitsN.+((!PC),BitsN.B(0x4,64)), - BitsN.<<(BitsN.signExtend 64 offset,2)))) - else CheckBranch (); + ConditionalBranch(BitsN.<=(GPR rs,BitsN.B(0x0,64)),offset); fun dfn'BGTZ (rs,offset) = - if BitsN.>(GPR rs,BitsN.B(0x0,64)) - then BranchTo := - (Option.SOME - (BitsN.+ - (BitsN.+((!PC),BitsN.B(0x4,64)), - BitsN.<<(BitsN.signExtend 64 offset,2)))) - else CheckBranch (); + ConditionalBranch(BitsN.>(GPR rs,BitsN.B(0x0,64)),offset); fun dfn'BLTZ (rs,offset) = - if BitsN.<(GPR rs,BitsN.B(0x0,64)) - then BranchTo := - (Option.SOME - (BitsN.+ - (BitsN.+((!PC),BitsN.B(0x4,64)), - BitsN.<<(BitsN.signExtend 64 offset,2)))) - else CheckBranch (); + ConditionalBranch(BitsN.<(GPR rs,BitsN.B(0x0,64)),offset); fun dfn'BGEZ (rs,offset) = - if BitsN.>=(GPR rs,BitsN.B(0x0,64)) - then BranchTo := - (Option.SOME - (BitsN.+ - (BitsN.+((!PC),BitsN.B(0x4,64)), - BitsN.<<(BitsN.signExtend 64 offset,2)))) - else CheckBranch (); + ConditionalBranch(BitsN.>=(GPR rs,BitsN.B(0x0,64)),offset); fun dfn'BLTZAL (rs,offset) = let val temp = GPR rs in ( write'GPR(BitsN.+((!PC),BitsN.B(0x8,64)),BitsN.B(0x1F,5)) - ; if BitsN.<(temp,BitsN.B(0x0,64)) - then BranchTo := - (Option.SOME - (BitsN.+ - (BitsN.+((!PC),BitsN.B(0x4,64)), - BitsN.<<(BitsN.signExtend 64 offset,2)))) - else CheckBranch () + ; ConditionalBranch(BitsN.<(temp,BitsN.B(0x0,64)),offset) ) end; @@ -6893,82 +4671,34 @@ fun dfn'BGEZAL (rs,offset) = val temp = GPR rs in ( write'GPR(BitsN.+((!PC),BitsN.B(0x8,64)),BitsN.B(0x1F,5)) - ; if BitsN.>=(temp,BitsN.B(0x0,64)) - then BranchTo := - (Option.SOME - (BitsN.+ - (BitsN.+((!PC),BitsN.B(0x4,64)), - BitsN.<<(BitsN.signExtend 64 offset,2)))) - else CheckBranch () + ; ConditionalBranch(BitsN.>=(temp,BitsN.B(0x0,64)),offset) ) end; fun dfn'BEQL (rs,(rt,offset)) = - if (GPR rs) = (GPR rt) - then BranchTo := - (Option.SOME - (BitsN.+ - (BitsN.+((!PC),BitsN.B(0x4,64)), - BitsN.<<(BitsN.signExtend 64 offset,2)))) - else ( CheckBranch (); PC := (BitsN.+((!PC),BitsN.B(0x4,64))) ); + ConditionalBranchLikely((GPR rs) = (GPR rt),offset); fun dfn'BNEL (rs,(rt,offset)) = - if not((GPR rs) = (GPR rt)) - then BranchTo := - (Option.SOME - (BitsN.+ - (BitsN.+((!PC),BitsN.B(0x4,64)), - BitsN.<<(BitsN.signExtend 64 offset,2)))) - else ( CheckBranch (); PC := (BitsN.+((!PC),BitsN.B(0x4,64))) ); + ConditionalBranchLikely(not((GPR rs) = (GPR rt)),offset); fun dfn'BLEZL (rs,offset) = - if BitsN.<=(GPR rs,BitsN.B(0x0,64)) - then BranchTo := - (Option.SOME - (BitsN.+ - (BitsN.+((!PC),BitsN.B(0x4,64)), - BitsN.<<(BitsN.signExtend 64 offset,2)))) - else ( CheckBranch (); PC := (BitsN.+((!PC),BitsN.B(0x4,64))) ); + ConditionalBranchLikely(BitsN.<=(GPR rs,BitsN.B(0x0,64)),offset); fun dfn'BGTZL (rs,offset) = - if BitsN.>(GPR rs,BitsN.B(0x0,64)) - then BranchTo := - (Option.SOME - (BitsN.+ - (BitsN.+((!PC),BitsN.B(0x4,64)), - BitsN.<<(BitsN.signExtend 64 offset,2)))) - else ( CheckBranch (); PC := (BitsN.+((!PC),BitsN.B(0x4,64))) ); + ConditionalBranchLikely(BitsN.>(GPR rs,BitsN.B(0x0,64)),offset); fun dfn'BLTZL (rs,offset) = - if BitsN.<(GPR rs,BitsN.B(0x0,64)) - then BranchTo := - (Option.SOME - (BitsN.+ - (BitsN.+((!PC),BitsN.B(0x4,64)), - BitsN.<<(BitsN.signExtend 64 offset,2)))) - else ( CheckBranch (); PC := (BitsN.+((!PC),BitsN.B(0x4,64))) ); + ConditionalBranchLikely(BitsN.<(GPR rs,BitsN.B(0x0,64)),offset); fun dfn'BGEZL (rs,offset) = - if BitsN.>=(GPR rs,BitsN.B(0x0,64)) - then BranchTo := - (Option.SOME - (BitsN.+ - (BitsN.+((!PC),BitsN.B(0x4,64)), - BitsN.<<(BitsN.signExtend 64 offset,2)))) - else ( CheckBranch (); PC := (BitsN.+((!PC),BitsN.B(0x4,64))) ); + ConditionalBranchLikely(BitsN.>=(GPR rs,BitsN.B(0x0,64)),offset); fun dfn'BLTZALL (rs,offset) = let val temp = GPR rs in ( write'GPR(BitsN.+((!PC),BitsN.B(0x8,64)),BitsN.B(0x1F,5)) - ; if BitsN.<(temp,BitsN.B(0x0,64)) - then BranchTo := - (Option.SOME - (BitsN.+ - (BitsN.+((!PC),BitsN.B(0x4,64)), - BitsN.<<(BitsN.signExtend 64 offset,2)))) - else ( CheckBranch (); PC := (BitsN.+((!PC),BitsN.B(0x4,64))) ) + ; ConditionalBranchLikely(BitsN.<(temp,BitsN.B(0x0,64)),offset) ) end; @@ -6977,18 +4707,24 @@ fun dfn'BGEZALL (rs,offset) = val temp = GPR rs in ( write'GPR(BitsN.+((!PC),BitsN.B(0x8,64)),BitsN.B(0x1F,5)) - ; if BitsN.>=(temp,BitsN.B(0x0,64)) - then BranchTo := - (Option.SOME - (BitsN.+ - (BitsN.+((!PC),BitsN.B(0x4,64)), - BitsN.<<(BitsN.signExtend 64 offset,2)))) - else ( CheckBranch (); PC := (BitsN.+((!PC),BitsN.B(0x4,64))) ) + ; ConditionalBranchLikely(BitsN.>=(temp,BitsN.B(0x0,64)),offset) ) end; val dfn'WAIT = () +fun dfn'TLBP () = SignalException ResI; + +fun dfn'TLBR () = SignalException ResI; + +fun dfn'TLBWI () = SignalException ResI; + +fun dfn'TLBWR () = SignalException ResI; + +fun dfn'CACHE (base,(opn,offset)) = SignalException ResI; + +fun dfn'RDHWR (rt,rd) = SignalException ResI; + fun dfn'ReservedInstruction () = SignalException ResI; fun dfn'Unpredictable () = @@ -11553,16 +9289,21 @@ fun Decode w = fun Next () = ( case Fetch () of Option.SOME w => Run(Decode w) | NONE => () ; case ((!BranchDelay),(!BranchTo)) of - (NONE,NONE) => - if not (!exceptionSignalled) - then PC := (BitsN.+((!PC),BitsN.B(0x4,64))) - else () - | (Option.SOME addr,NONE) => ( BranchDelay := NONE; PC := addr ) - | (NONE,Option.SOME addr) => - ( BranchDelay := (Option.SOME addr) + (NONE,NONE) => PC := (BitsN.+((!PC),BitsN.B(0x4,64))) + | (NONE,Option.SOME(true,addr)) => + ( BranchDelay := (Option.SOME NONE) + ; BranchTo := NONE + ; PC := addr + ) + | (NONE,Option.SOME(false,addr)) => + ( BranchDelay := (Option.SOME(Option.SOME addr)) ; BranchTo := NONE ; PC := (BitsN.+((!PC),BitsN.B(0x4,64))) ) + | (Option.SOME NONE,NONE) => + ( BranchDelay := NONE; PC := (BitsN.+((!PC),BitsN.B(0x4,64))) ) + | (Option.SOME(Option.SOME addr),NONE) => + ( BranchDelay := NONE; PC := addr ) | _ => raise UNPREDICTABLE ("Branch follows branch") ; exceptionSignalled := false ; CP0 := diff --git a/examples/l3-machine-code/mips/model/mipsScript.sml b/examples/l3-machine-code/mips/model/mipsScript.sml index a3d404a1ec..6f15881594 100644 --- a/examples/l3-machine-code/mips/model/mipsScript.sml +++ b/examples/l3-machine-code/mips/model/mipsScript.sml @@ -1,4 +1,4 @@ -(* mipsScript.sml - generated by L<3> - Wed Sep 17 11:16:47 2014 *) +(* mipsScript.sml - generated by L<3> - Thu Oct 30 16:32:12 2014 *) open HolKernel boolLib bossLib Import val () = Import.start "mips" @@ -226,8 +226,8 @@ val _ = Construct ; val _ = Record ("mips_state", - [("BranchDelay",OTy F64),("BranchTo",OTy F64),("CP0",CTy"CP0"), - ("LLbit",OTy bTy),("MEM",ATy(F64,F8)),("PC",F64), + [("BranchDelay",OTy(OTy F64)),("BranchTo",OTy(PTy(bTy,F64))), + ("CP0",CTy"CP0"),("LLbit",OTy bTy),("MEM",ATy(F64,F8)),("PC",F64), ("exception",CTy"exception"),("exceptionSignalled",bTy), ("gpr",ATy(FTy 5,F64)),("hi",OTy F64),("lo",OTy F64)]) ; @@ -1683,48 +1683,50 @@ val SignalException_def = Def Dest ("Status",CTy"StatusRegister", Dest("CP0",CTy"CP0",qVar"state")))), - ITE(Mop(IsSome,Dest("BranchDelay",OTy F64,qVar"state")), - Let(qVar"s", - Rupd - ("CP0", - TP[qVar"state", - Rupd - ("EPC", - TP[Dest("CP0",CTy"CP0",qVar"state"), - Bop(Sub,Dest("PC",F64,qVar"state"), - LW(4,64))])]), - Rupd - ("CP0", - TP[qVar"s", - Rupd - ("Cause", - TP[Dest("CP0",CTy"CP0",qVar"s"), - Rupd - ("BD", - TP[Dest - ("Cause",CTy"CauseRegister", - Dest("CP0",CTy"CP0",qVar"s")), - LT])])])), - Let(qVar"s", - Rupd - ("CP0", - TP[qVar"state", - Rupd - ("EPC", - TP[Dest("CP0",CTy"CP0",qVar"state"), - Dest("PC",F64,qVar"state")])]), - Rupd - ("CP0", - TP[qVar"s", - Rupd - ("Cause", - TP[Dest("CP0",CTy"CP0",qVar"s"), - Rupd - ("BD", - TP[Dest - ("Cause",CTy"CauseRegister", - Dest("CP0",CTy"CP0",qVar"s")), - LF])])]))),qVar"state"), + CS(Dest("BranchDelay",OTy(OTy F64),qVar"state"), + [(Mop(Some,Mop(Some,AVar F64)), + Let(qVar"s", + Rupd + ("CP0", + TP[qVar"state", + Rupd + ("EPC", + TP[Dest("CP0",CTy"CP0",qVar"state"), + Bop(Sub,Dest("PC",F64,qVar"state"), + LW(4,64))])]), + Rupd + ("CP0", + TP[qVar"s", + Rupd + ("Cause", + TP[Dest("CP0",CTy"CP0",qVar"s"), + Rupd + ("BD", + TP[Dest + ("Cause",CTy"CauseRegister", + Dest("CP0",CTy"CP0",qVar"s")), + LT])])]))), + (AVar(OTy(OTy F64)), + Let(qVar"s", + Rupd + ("CP0", + TP[qVar"state", + Rupd + ("EPC", + TP[Dest("CP0",CTy"CP0",qVar"state"), + Dest("PC",F64,qVar"state")])]), + Rupd + ("CP0", + TP[qVar"s", + Rupd + ("Cause", + TP[Dest("CP0",CTy"CP0",qVar"s"), + Rupd + ("BD", + TP[Dest + ("Cause",CTy"CauseRegister", + Dest("CP0",CTy"CP0",qVar"s")), + LF])])])))]),qVar"state"), Let(qVar"s0", Mop(Snd, Apply @@ -1757,37 +1759,36 @@ val SignalException_def = Def TP[Rupd ("PC", TP[Rupd - ("BranchTo", - TP[Rupd - ("BranchDelay", - TP[qVar"s0",LO F64]),LO F64]), - CC[EX(Var("v0",F64),LN 63,LN 30, - FTy 34), - Bop(Add, - EX(Var("v0",F64),LN 29,LN 0, - FTy 30), - ITE(Bop(And, - Bop(Or, - EQ(Var("ExceptionType", - CTy"ExceptionType"), - LC("XTLBRefillL", - CTy"ExceptionType")), - EQ(Var("ExceptionType", - CTy"ExceptionType"), - LC("XTLBRefillS", - CTy"ExceptionType"))), - Mop(Not, - Dest - ("EXL",bTy, - Dest - ("Status", - CTy"StatusRegister", - Dest - ("CP0", - CTy"CP0", - qVar"s"))))), - LW(128,30),LW(384,30)))]]), - LT])])))))) + ("BranchDelay", + TP[qVar"s0",LO(OTy F64)]), + Bop(Sub, + CC[EX(Var("v0",F64),LN 63,LN 30, + FTy 34), + Bop(Add, + EX(Var("v0",F64),LN 29, + LN 0,FTy 30), + ITE(Bop(And, + Bop(Or, + EQ(Var("ExceptionType", + CTy"ExceptionType"), + LC("XTLBRefillL", + CTy"ExceptionType")), + EQ(Var("ExceptionType", + CTy"ExceptionType"), + LC("XTLBRefillS", + CTy"ExceptionType"))), + Mop(Not, + Dest + ("EXL",bTy, + Dest + ("Status", + CTy"StatusRegister", + Dest + ("CP0", + CTy"CP0", + qVar"s"))))), + LW(128,30),LW(384,30)))], + LW(4,64))]),LT])])))))) ; val BYTE_def = Def0 ("BYTE",LW(0,3)) ; @@ -2535,52 +2536,6 @@ val Fetch_def = Def ("SignalException",ATy(qTy,PTy(uTy,qTy)), LC("AdEL",CTy"ExceptionType")),qVar"state"))])) ; -val dfn'TLBP_def = Def - ("dfn'TLBP",qVar"state", - Apply - (Call - ("SignalException",ATy(qTy,PTy(uTy,qTy)), - LC("ResI",CTy"ExceptionType")),qVar"state")) -; -val dfn'TLBR_def = Def - ("dfn'TLBR",qVar"state", - Apply - (Call - ("SignalException",ATy(qTy,PTy(uTy,qTy)), - LC("ResI",CTy"ExceptionType")),qVar"state")) -; -val dfn'TLBWI_def = Def - ("dfn'TLBWI",qVar"state", - Apply - (Call - ("SignalException",ATy(qTy,PTy(uTy,qTy)), - LC("ResI",CTy"ExceptionType")),qVar"state")) -; -val dfn'TLBWR_def = Def - ("dfn'TLBWR",qVar"state", - Apply - (Call - ("SignalException",ATy(qTy,PTy(uTy,qTy)), - LC("ResI",CTy"ExceptionType")),qVar"state")) -; -val dfn'CACHE_def = Def - ("dfn'CACHE",TP[Var("base",FTy 5),Var("opn",FTy 5),Var("offset",F16)], - Close - (qVar"state", - Apply - (Call - ("SignalException",ATy(qTy,PTy(uTy,qTy)), - LC("ResI",CTy"ExceptionType")),qVar"state"))) -; -val dfn'RDHWR_def = Def - ("dfn'RDHWR",TP[Var("rt",FTy 5),Var("rd",FTy 5)], - Close - (qVar"state", - Apply - (Call - ("SignalException",ATy(qTy,PTy(uTy,qTy)), - LC("ResI",CTy"ExceptionType")),qVar"state"))) -; val NotWordValue_def = Def ("NotWordValue",Var("value",F64), Let(Var("top",F32),EX(Var("value",F64),LN 63,LN 32,F32), @@ -2588,17 +2543,6 @@ val NotWordValue_def = Def Mop(Not,EQ(Var("top",F32),LW(4294967295,32))), Mop(Not,EQ(Var("top",F32),LW(0,32)))))) ; -val CheckBranch_def = Def - ("CheckBranch",qVar"state", - ITE(Mop(IsSome,Dest("BranchDelay",OTy F64,qVar"state")), - Apply - (Call - ("raise'exception",ATy(qTy,PTy(uTy,qTy)), - Call - ("UNPREDICTABLE",CTy"exception", - LS"Not permitted in delay slot")),qVar"state"), - TP[LU,qVar"state"])) -; val dfn'ADDI_def = Def ("dfn'ADDI",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("immediate",F16)], Close @@ -6436,76 +6380,80 @@ val dfn'SYSCALL_def = Def ; val dfn'ERET_def = Def ("dfn'ERET",qVar"state", - Let(qVar"s", - Mop(Snd, - Apply(Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))),qVar"state")), - ITE(Bop(Or, - Dest - ("CU0",bTy, - Dest - ("Status",CTy"StatusRegister", - Dest("CP0",CTy"CP0",qVar"s"))), - Mop(Fst, - Apply - (Const("KernelMode",ATy(qTy,PTy(bTy,qTy))),qVar"s"))), - TP[LU, - Rupd - ("LLbit", - TP[ITE(Dest - ("ERL",bTy, - Dest - ("Status",CTy"StatusRegister", - Dest("CP0",CTy"CP0",qVar"s"))), - Let(qVar"s", - Rupd - ("PC", - TP[qVar"s", - Bop(Sub, - Dest - ("ErrorEPC",F64, - Dest("CP0",CTy"CP0",qVar"s")), - LW(4,64))]), - Rupd - ("CP0", - TP[qVar"s", - Rupd - ("Status", - TP[Dest("CP0",CTy"CP0",qVar"s"), - Rupd - ("ERL", - TP[Dest - ("Status", - CTy"StatusRegister", - Dest - ("CP0",CTy"CP0",qVar"s")), - LF])])])), - Let(qVar"s", - Rupd - ("PC", - TP[qVar"s", - Bop(Sub, - Dest - ("EPC",F64, - Dest("CP0",CTy"CP0",qVar"s")), - LW(4,64))]), - Rupd - ("CP0", - TP[qVar"s", - Rupd - ("Status", - TP[Dest("CP0",CTy"CP0",qVar"s"), - Rupd - ("EXL", - TP[Dest - ("Status", - CTy"StatusRegister", - Dest - ("CP0",CTy"CP0",qVar"s")), - LF])])]))),Mop(Some,LF)])], - Apply - (Call - ("SignalException",ATy(qTy,PTy(uTy,qTy)), - LC("CpU",CTy"ExceptionType")),qVar"s")))) + ITB([(Mop(IsSome,Dest("BranchDelay",OTy(OTy F64),qVar"state")), + Apply + (Call + ("raise'exception",ATy(qTy,PTy(uTy,qTy)), + Call + ("UNPREDICTABLE",CTy"exception",LS"ERET follows branch")), + qVar"state")), + (Bop(Or, + Dest + ("CU0",bTy, + Dest + ("Status",CTy"StatusRegister", + Dest("CP0",CTy"CP0",qVar"state"))), + Mop(Fst, + Apply + (Const("KernelMode",ATy(qTy,PTy(bTy,qTy))),qVar"state"))), + TP[LU, + Rupd + ("LLbit", + TP[ITE(Dest + ("ERL",bTy, + Dest + ("Status",CTy"StatusRegister", + Dest("CP0",CTy"CP0",qVar"state"))), + Let(qVar"s", + Rupd + ("PC", + TP[qVar"state", + Bop(Sub, + Dest + ("ErrorEPC",F64, + Dest("CP0",CTy"CP0",qVar"state")), + LW(4,64))]), + Rupd + ("CP0", + TP[qVar"s", + Rupd + ("Status", + TP[Dest("CP0",CTy"CP0",qVar"s"), + Rupd + ("ERL", + TP[Dest + ("Status", + CTy"StatusRegister", + Dest + ("CP0",CTy"CP0",qVar"s")), + LF])])])), + Let(qVar"s", + Rupd + ("PC", + TP[qVar"state", + Bop(Sub, + Dest + ("EPC",F64, + Dest("CP0",CTy"CP0",qVar"state")), + LW(4,64))]), + Rupd + ("CP0", + TP[qVar"s", + Rupd + ("Status", + TP[Dest("CP0",CTy"CP0",qVar"s"), + Rupd + ("EXL", + TP[Dest + ("Status", + CTy"StatusRegister", + Dest + ("CP0",CTy"CP0",qVar"s")), + LF])])]))),Mop(Some,LF)])])], + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("CpU",CTy"ExceptionType")),qVar"state"))) ; val dfn'MTC0_def = Def ("dfn'MTC0",TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("sel",FTy 3)], @@ -6626,8 +6574,9 @@ val dfn'J_def = Def ("BranchTo", TP[qVar"state", Mop(Some, - CC[EX(Dest("PC",F64,qVar"state"),LN 63,LN 28,FTy 36), - Var("instr_index",FTy 26),LW(0,2)])])])) + TP[LF, + CC[EX(Dest("PC",F64,qVar"state"),LN 63,LN 28,FTy 36), + Var("instr_index",FTy 26),LW(0,2)]])])])) ; val dfn'JAL_def = Def ("dfn'JAL",Var("instr_index",FTy 26), @@ -6645,8 +6594,9 @@ val dfn'JAL_def = Def ("BranchTo", TP[qVar"s", Mop(Some, - CC[EX(Dest("PC",F64,qVar"s"),LN 63,LN 28,FTy 36), - Var("instr_index",FTy 26),LW(0,2)])])]))) + TP[LF, + CC[EX(Dest("PC",F64,qVar"s"),LN 63,LN 28,FTy 36), + Var("instr_index",FTy 26),LW(0,2)]])])]))) ; val dfn'JR_def = Def ("dfn'JR",Var("rs",FTy 5), @@ -6657,11 +6607,12 @@ val dfn'JR_def = Def ("BranchTo", TP[qVar"state", Mop(Some, - Mop(Fst, - Apply - (Call - ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), - qVar"state")))])])) + TP[LF, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rs",FTy 5)),qVar"state"))])])])) ; val dfn'JALR_def = Def ("dfn'JALR",TP[Var("rs",FTy 5),Var("rd",FTy 5)], @@ -6677,426 +6628,376 @@ val dfn'JALR_def = Def TP[Bop(Add,Dest("PC",F64,qVar"state"),LW(8,64)), Var("rd",FTy 5)]),qVar"state")), Mop(Some, - Mop(Fst, - Apply - (Call - ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), - qVar"state")))])])) + TP[LF, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rs",FTy 5)),qVar"state"))])])])) ; -val dfn'BEQ_def = Def - ("dfn'BEQ",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("offset",F16)], +val ConditionalBranch_def = Def + ("ConditionalBranch",TP[bVar"b",Var("offset",F16)], Close (qVar"state", - ITE(EQ(Mop(Fst, - Apply - (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), - qVar"state")), - Mop(Fst, - Apply - (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), - qVar"state"))), - TP[LU, + TP[LU, + Rupd + ("BranchTo", + TP[qVar"state", + Mop(Some, + ITE(bVar"b", + TP[LF, + Bop(Add, + Bop(Add,Dest("PC",F64,qVar"state"),LW(4,64)), + Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2))], + TP[LT,Bop(Add,Dest("PC",F64,qVar"state"),LW(4,64))]))])])) +; +val ConditionalBranchLikely_def = Def + ("ConditionalBranchLikely",TP[bVar"b",Var("offset",F16)], + Close + (qVar"state", + TP[LU, + ITB([(bVar"b", + Rupd + ("BranchTo", + TP[qVar"state", + Mop(Some, + TP[LF, + Bop(Add, + Bop(Add,Dest("PC",F64,qVar"state"), + LW(4,64)), + Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2))])])), + (Mop(IsSome,Dest("BranchDelay",OTy(OTy F64),qVar"state")), + Rupd + ("BranchTo", + TP[qVar"state", + Mop(Some, + TP[LT, + Bop(Add,Dest("PC",F64,qVar"state"),LW(8,64))])]))], Rupd - ("BranchTo", + ("PC", TP[qVar"state", - Mop(Some, - Bop(Add, - Bop(Add,Dest("PC",F64,qVar"state"),LW(4,64)), - Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))])], - Apply(Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))),qVar"state")))) + Bop(Add,Dest("PC",F64,qVar"state"),LW(4,64))]))])) +; +val dfn'BEQ_def = Def + ("dfn'BEQ",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("offset",F16)], + Close + (qVar"state", + Apply + (Call + ("ConditionalBranch",ATy(qTy,PTy(uTy,qTy)), + TP[EQ(Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state"))),Var("offset",F16)]),qVar"state"))) ; val dfn'BNE_def = Def ("dfn'BNE",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("offset",F16)], Close (qVar"state", - ITE(Mop(Not, - EQ(Mop(Fst, - Apply - (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), - qVar"state")), - Mop(Fst, - Apply - (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), - qVar"state")))), - TP[LU, - Rupd - ("BranchTo", - TP[qVar"state", - Mop(Some, - Bop(Add, - Bop(Add,Dest("PC",F64,qVar"state"),LW(4,64)), - Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))])], - Apply(Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))),qVar"state")))) + Apply + (Call + ("ConditionalBranch",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Not, + EQ(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rs",FTy 5)),qVar"state")), + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"state")))), + Var("offset",F16)]),qVar"state"))) ; val dfn'BLEZ_def = Def ("dfn'BLEZ",TP[Var("rs",FTy 5),Var("offset",F16)], Close (qVar"state", - ITE(Bop(Le, - Mop(Fst, - Apply - (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), - qVar"state")),LW(0,64)), - TP[LU, - Rupd - ("BranchTo", - TP[qVar"state", - Mop(Some, - Bop(Add, - Bop(Add,Dest("PC",F64,qVar"state"),LW(4,64)), - Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))])], - Apply(Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))),qVar"state")))) + Apply + (Call + ("ConditionalBranch",ATy(qTy,PTy(uTy,qTy)), + TP[Bop(Le, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")),LW(0,64)),Var("offset",F16)]), + qVar"state"))) ; val dfn'BGTZ_def = Def ("dfn'BGTZ",TP[Var("rs",FTy 5),Var("offset",F16)], Close (qVar"state", - ITE(Bop(Gt, - Mop(Fst, - Apply - (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), - qVar"state")),LW(0,64)), - TP[LU, - Rupd - ("BranchTo", - TP[qVar"state", - Mop(Some, - Bop(Add, - Bop(Add,Dest("PC",F64,qVar"state"),LW(4,64)), - Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))])], - Apply(Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))),qVar"state")))) + Apply + (Call + ("ConditionalBranch",ATy(qTy,PTy(uTy,qTy)), + TP[Bop(Gt, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")),LW(0,64)),Var("offset",F16)]), + qVar"state"))) ; val dfn'BLTZ_def = Def ("dfn'BLTZ",TP[Var("rs",FTy 5),Var("offset",F16)], Close (qVar"state", - ITE(Bop(Lt, - Mop(Fst, - Apply - (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), - qVar"state")),LW(0,64)), - TP[LU, - Rupd - ("BranchTo", - TP[qVar"state", - Mop(Some, - Bop(Add, - Bop(Add,Dest("PC",F64,qVar"state"),LW(4,64)), - Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))])], - Apply(Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))),qVar"state")))) + Apply + (Call + ("ConditionalBranch",ATy(qTy,PTy(uTy,qTy)), + TP[Bop(Lt, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")),LW(0,64)),Var("offset",F16)]), + qVar"state"))) ; val dfn'BGEZ_def = Def ("dfn'BGEZ",TP[Var("rs",FTy 5),Var("offset",F16)], Close (qVar"state", - ITE(Bop(Ge, - Mop(Fst, - Apply - (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), - qVar"state")),LW(0,64)), - TP[LU, - Rupd - ("BranchTo", - TP[qVar"state", - Mop(Some, - Bop(Add, - Bop(Add,Dest("PC",F64,qVar"state"),LW(4,64)), - Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))])], - Apply(Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))),qVar"state")))) + Apply + (Call + ("ConditionalBranch",ATy(qTy,PTy(uTy,qTy)), + TP[Bop(Ge, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")),LW(0,64)),Var("offset",F16)]), + qVar"state"))) ; val dfn'BLTZAL_def = Def ("dfn'BLTZAL",TP[Var("rs",FTy 5),Var("offset",F16)], Close (qVar"state", - Let(qVar"s", - Mop(Snd, - Apply - (Call - ("write'GPR",ATy(qTy,PTy(uTy,qTy)), - TP[Bop(Add,Dest("PC",F64,qVar"state"),LW(8,64)), - LW(31,5)]),qVar"state")), - ITE(Bop(Lt, - Mop(Fst, - Apply - (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), - qVar"state")),LW(0,64)), - TP[LU, - Rupd - ("BranchTo", - TP[qVar"s", - Mop(Some, - Bop(Add, - Bop(Add,Dest("PC",F64,qVar"s"),LW(4,64)), - Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))])], - Apply(Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))),qVar"s"))))) + Apply + (Call + ("ConditionalBranch",ATy(qTy,PTy(uTy,qTy)), + TP[Bop(Lt, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")),LW(0,64)),Var("offset",F16)]), + Mop(Snd, + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Bop(Add,Dest("PC",F64,qVar"state"),LW(8,64)), + LW(31,5)]),qVar"state"))))) ; val dfn'BGEZAL_def = Def ("dfn'BGEZAL",TP[Var("rs",FTy 5),Var("offset",F16)], Close (qVar"state", - Let(qVar"s", - Mop(Snd, - Apply - (Call - ("write'GPR",ATy(qTy,PTy(uTy,qTy)), - TP[Bop(Add,Dest("PC",F64,qVar"state"),LW(8,64)), - LW(31,5)]),qVar"state")), - ITE(Bop(Ge, - Mop(Fst, - Apply - (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), - qVar"state")),LW(0,64)), - TP[LU, - Rupd - ("BranchTo", - TP[qVar"s", - Mop(Some, - Bop(Add, - Bop(Add,Dest("PC",F64,qVar"s"),LW(4,64)), - Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))])], - Apply(Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))),qVar"s"))))) + Apply + (Call + ("ConditionalBranch",ATy(qTy,PTy(uTy,qTy)), + TP[Bop(Ge, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")),LW(0,64)),Var("offset",F16)]), + Mop(Snd, + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Bop(Add,Dest("PC",F64,qVar"state"),LW(8,64)), + LW(31,5)]),qVar"state"))))) ; val dfn'BEQL_def = Def ("dfn'BEQL",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("offset",F16)], Close (qVar"state", - ITE(EQ(Mop(Fst, - Apply - (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), - qVar"state")), - Mop(Fst, - Apply - (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), - qVar"state"))), - TP[LU, - Rupd - ("BranchTo", - TP[qVar"state", - Mop(Some, - Bop(Add, - Bop(Add,Dest("PC",F64,qVar"state"),LW(4,64)), - Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))])], - Let(qVar"s", - Mop(Snd, - Apply - (Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))), - qVar"state")), - TP[LU, - Rupd - ("PC", - TP[qVar"s",Bop(Add,Dest("PC",F64,qVar"s"),LW(4,64))])])))) + Apply + (Call + ("ConditionalBranchLikely",ATy(qTy,PTy(uTy,qTy)), + TP[EQ(Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state"))),Var("offset",F16)]),qVar"state"))) ; val dfn'BNEL_def = Def ("dfn'BNEL",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("offset",F16)], Close (qVar"state", - ITE(Mop(Not, - EQ(Mop(Fst, - Apply - (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), - qVar"state")), - Mop(Fst, - Apply - (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), - qVar"state")))), - TP[LU, - Rupd - ("BranchTo", - TP[qVar"state", - Mop(Some, - Bop(Add, - Bop(Add,Dest("PC",F64,qVar"state"),LW(4,64)), - Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))])], - Let(qVar"s", - Mop(Snd, - Apply - (Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))), - qVar"state")), - TP[LU, - Rupd - ("PC", - TP[qVar"s",Bop(Add,Dest("PC",F64,qVar"s"),LW(4,64))])])))) + Apply + (Call + ("ConditionalBranchLikely",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Not, + EQ(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rs",FTy 5)),qVar"state")), + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"state")))), + Var("offset",F16)]),qVar"state"))) ; val dfn'BLEZL_def = Def ("dfn'BLEZL",TP[Var("rs",FTy 5),Var("offset",F16)], Close (qVar"state", - ITE(Bop(Le, - Mop(Fst, - Apply - (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), - qVar"state")),LW(0,64)), - TP[LU, - Rupd - ("BranchTo", - TP[qVar"state", - Mop(Some, - Bop(Add, - Bop(Add,Dest("PC",F64,qVar"state"),LW(4,64)), - Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))])], - Let(qVar"s", - Mop(Snd, - Apply - (Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))), - qVar"state")), - TP[LU, - Rupd - ("PC", - TP[qVar"s",Bop(Add,Dest("PC",F64,qVar"s"),LW(4,64))])])))) + Apply + (Call + ("ConditionalBranchLikely",ATy(qTy,PTy(uTy,qTy)), + TP[Bop(Le, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")),LW(0,64)),Var("offset",F16)]), + qVar"state"))) ; val dfn'BGTZL_def = Def ("dfn'BGTZL",TP[Var("rs",FTy 5),Var("offset",F16)], Close (qVar"state", - ITE(Bop(Gt, - Mop(Fst, - Apply - (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), - qVar"state")),LW(0,64)), - TP[LU, - Rupd - ("BranchTo", - TP[qVar"state", - Mop(Some, - Bop(Add, - Bop(Add,Dest("PC",F64,qVar"state"),LW(4,64)), - Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))])], - Let(qVar"s", - Mop(Snd, - Apply - (Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))), - qVar"state")), - TP[LU, - Rupd - ("PC", - TP[qVar"s",Bop(Add,Dest("PC",F64,qVar"s"),LW(4,64))])])))) + Apply + (Call + ("ConditionalBranchLikely",ATy(qTy,PTy(uTy,qTy)), + TP[Bop(Gt, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")),LW(0,64)),Var("offset",F16)]), + qVar"state"))) ; val dfn'BLTZL_def = Def ("dfn'BLTZL",TP[Var("rs",FTy 5),Var("offset",F16)], Close (qVar"state", - ITE(Bop(Lt, - Mop(Fst, - Apply - (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), - qVar"state")),LW(0,64)), - TP[LU, - Rupd - ("BranchTo", - TP[qVar"state", - Mop(Some, - Bop(Add, - Bop(Add,Dest("PC",F64,qVar"state"),LW(4,64)), - Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))])], - Let(qVar"s", - Mop(Snd, - Apply - (Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))), - qVar"state")), - TP[LU, - Rupd - ("PC", - TP[qVar"s",Bop(Add,Dest("PC",F64,qVar"s"),LW(4,64))])])))) + Apply + (Call + ("ConditionalBranchLikely",ATy(qTy,PTy(uTy,qTy)), + TP[Bop(Lt, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")),LW(0,64)),Var("offset",F16)]), + qVar"state"))) ; val dfn'BGEZL_def = Def ("dfn'BGEZL",TP[Var("rs",FTy 5),Var("offset",F16)], Close (qVar"state", - ITE(Bop(Ge, - Mop(Fst, - Apply - (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), - qVar"state")),LW(0,64)), - TP[LU, - Rupd - ("BranchTo", - TP[qVar"state", - Mop(Some, - Bop(Add, - Bop(Add,Dest("PC",F64,qVar"state"),LW(4,64)), - Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))])], - Let(qVar"s", - Mop(Snd, - Apply - (Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))), - qVar"state")), - TP[LU, - Rupd - ("PC", - TP[qVar"s",Bop(Add,Dest("PC",F64,qVar"s"),LW(4,64))])])))) + Apply + (Call + ("ConditionalBranchLikely",ATy(qTy,PTy(uTy,qTy)), + TP[Bop(Ge, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")),LW(0,64)),Var("offset",F16)]), + qVar"state"))) ; val dfn'BLTZALL_def = Def ("dfn'BLTZALL",TP[Var("rs",FTy 5),Var("offset",F16)], Close (qVar"state", - Let(qVar"s", - Mop(Snd, - Apply - (Call - ("write'GPR",ATy(qTy,PTy(uTy,qTy)), - TP[Bop(Add,Dest("PC",F64,qVar"state"),LW(8,64)), - LW(31,5)]),qVar"state")), - ITE(Bop(Lt, - Mop(Fst, - Apply - (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), - qVar"state")),LW(0,64)), - TP[LU, - Rupd - ("BranchTo", - TP[qVar"s", - Mop(Some, - Bop(Add, - Bop(Add,Dest("PC",F64,qVar"s"),LW(4,64)), - Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))])], - Let(qVar"s", - Mop(Snd, - Apply - (Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))), - qVar"s")), - TP[LU, - Rupd - ("PC", - TP[qVar"s", - Bop(Add,Dest("PC",F64,qVar"s"),LW(4,64))])]))))) + Apply + (Call + ("ConditionalBranchLikely",ATy(qTy,PTy(uTy,qTy)), + TP[Bop(Lt, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")),LW(0,64)),Var("offset",F16)]), + Mop(Snd, + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Bop(Add,Dest("PC",F64,qVar"state"),LW(8,64)), + LW(31,5)]),qVar"state"))))) ; val dfn'BGEZALL_def = Def ("dfn'BGEZALL",TP[Var("rs",FTy 5),Var("offset",F16)], Close (qVar"state", - Let(qVar"s", - Mop(Snd, - Apply - (Call - ("write'GPR",ATy(qTy,PTy(uTy,qTy)), - TP[Bop(Add,Dest("PC",F64,qVar"state"),LW(8,64)), - LW(31,5)]),qVar"state")), - ITE(Bop(Ge, - Mop(Fst, - Apply - (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), - qVar"state")),LW(0,64)), - TP[LU, - Rupd - ("BranchTo", - TP[qVar"s", - Mop(Some, - Bop(Add, - Bop(Add,Dest("PC",F64,qVar"s"),LW(4,64)), - Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))])], - Let(qVar"s", - Mop(Snd, - Apply - (Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))), - qVar"s")), - TP[LU, - Rupd - ("PC", - TP[qVar"s", - Bop(Add,Dest("PC",F64,qVar"s"),LW(4,64))])]))))) + Apply + (Call + ("ConditionalBranchLikely",ATy(qTy,PTy(uTy,qTy)), + TP[Bop(Ge, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")),LW(0,64)),Var("offset",F16)]), + Mop(Snd, + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Bop(Add,Dest("PC",F64,qVar"state"),LW(8,64)), + LW(31,5)]),qVar"state"))))) ; val dfn'WAIT_def = Def0 ("dfn'WAIT",LU) ; +val dfn'TLBP_def = Def + ("dfn'TLBP",qVar"state", + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("ResI",CTy"ExceptionType")),qVar"state")) +; +val dfn'TLBR_def = Def + ("dfn'TLBR",qVar"state", + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("ResI",CTy"ExceptionType")),qVar"state")) +; +val dfn'TLBWI_def = Def + ("dfn'TLBWI",qVar"state", + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("ResI",CTy"ExceptionType")),qVar"state")) +; +val dfn'TLBWR_def = Def + ("dfn'TLBWR",qVar"state", + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("ResI",CTy"ExceptionType")),qVar"state")) +; +val dfn'CACHE_def = Def + ("dfn'CACHE",TP[Var("base",FTy 5),Var("opn",FTy 5),Var("offset",F16)], + Close + (qVar"state", + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("ResI",CTy"ExceptionType")),qVar"state"))) +; +val dfn'RDHWR_def = Def + ("dfn'RDHWR",TP[Var("rt",FTy 5),Var("rd",FTy 5)], + Close + (qVar"state", + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("ResI",CTy"ExceptionType")),qVar"state"))) +; val dfn'ReservedInstruction_def = Def ("dfn'ReservedInstruction",qVar"state", Apply @@ -11596,36 +11497,53 @@ val Next_def = Def Let(qVar"s", Rupd ("exceptionSignalled", - TP[CS(TP[Dest("BranchDelay",OTy F64,qVar"s"), - Dest("BranchTo",OTy F64,qVar"s")], - [(TP[LO F64,LO F64], - ITE(Mop(Not, - Dest("exceptionSignalled",bTy,qVar"s")), - Rupd - ("PC", - TP[qVar"s", - Bop(Add,Dest("PC",F64,qVar"s"), - LW(4,64))]),qVar"s")), - (TP[Mop(Some,Var("addr",F64)),LO F64], + TP[CS(TP[Dest("BranchDelay",OTy(OTy F64),qVar"s"), + Dest("BranchTo",OTy(PTy(bTy,F64)),qVar"s")], + [(TP[LO(OTy F64),LO(PTy(bTy,F64))], Rupd ("PC", - TP[Rupd("BranchDelay",TP[qVar"s",LO F64]), - Var("addr",F64)])), - (TP[LO F64,Mop(Some,Var("addr",F64))], + TP[qVar"s", + Bop(Add,Dest("PC",F64,qVar"s"),LW(4,64))])), + (TP[LO(OTy F64),Mop(Some,TP[LT,Var("addr",F64)])], + Rupd + ("PC", + TP[Rupd + ("BranchTo", + TP[Rupd + ("BranchDelay", + TP[qVar"s",Mop(Some,LO F64)]), + LO(PTy(bTy,F64))]),Var("addr",F64)])), + (TP[LO(OTy F64),Mop(Some,TP[LF,Var("addr",F64)])], Let(qVar"s", Rupd ("BranchTo", TP[Rupd ("BranchDelay", TP[qVar"s", - Mop(Some,Var("addr",F64))]), - LO F64]), + Mop(Some, + Mop(Some,Var("addr",F64)))]), + LO(PTy(bTy,F64))]), Rupd ("PC", TP[qVar"s", Bop(Add,Dest("PC",F64,qVar"s"), LW(4,64))]))), - (AVar(PTy(OTy F64,OTy F64)), + (TP[Mop(Some,LO F64),LO(PTy(bTy,F64))], + Let(qVar"s", + Rupd("BranchDelay",TP[qVar"s",LO(OTy F64)]), + Rupd + ("PC", + TP[qVar"s", + Bop(Add,Dest("PC",F64,qVar"s"), + LW(4,64))]))), + (TP[Mop(Some,Mop(Some,Var("addr",F64))), + LO(PTy(bTy,F64))], + Rupd + ("PC", + TP[Rupd + ("BranchDelay",TP[qVar"s",LO(OTy F64)]), + Var("addr",F64)])), + (AVar(PTy(OTy(OTy F64),OTy(PTy(bTy,F64)))), Mop(Snd, Apply (Call diff --git a/examples/l3-machine-code/mips/prog/mips_progLib.sml b/examples/l3-machine-code/mips/prog/mips_progLib.sml index c1feece9ed..43c5ef05c4 100644 --- a/examples/l3-machine-code/mips/prog/mips_progLib.sml +++ b/examples/l3-machine-code/mips/prog/mips_progLib.sml @@ -85,7 +85,9 @@ val state_id = [["CP0", "PC", "gpr"], ["CP0", "PC", "exceptionSignalled", "gpr"], ["CP0", "PC", "exceptionSignalled"], + ["CP0", "PC", "exceptionSignalled", "hi", "lo"], ["CP0", "LLbit", "PC"], + ["CP0", "LLbit", "PC", "exceptionSignalled"], ["CP0", "LLbit", "PC", "gpr"], ["CP0", "PC"], ["CP0", "PC", "lo"], @@ -164,22 +166,23 @@ local case fst (Term.dest_const (boolSyntax.rator tm)) of "cond" => 0 | "mips_exception" => 1 - | "mips_CP0_Status_RE" => 2 - | "mips_CP0_Status_ERL" => 3 - | "mips_CP0_Status_EXL" => 4 - | "mips_CP0_Status_BEV" => 5 - | "mips_CP0_Config_BE" => 6 - | "mips_CP0_Count" => 7 - | "mips_CP0_Cause" => 8 - | "mips_CP0_EPC" => 9 - | "mips_CP0_Debug" => 10 - | "mips_CP0_ErrCtl" => 11 - | "mips_BranchDelay" => 12 - | "mips_BranchTo" => 13 - | "mips_LLbit" => 14 - | "mips_hi" => 15 - | "mips_lo" => 16 - | "mips_PC" => 17 + | "mips_exceptionSignalled" => 2 + | "mips_CP0_Status_RE" => 3 + | "mips_CP0_Status_ERL" => 4 + | "mips_CP0_Status_EXL" => 5 + | "mips_CP0_Status_BEV" => 6 + | "mips_CP0_Config_BE" => 7 + | "mips_CP0_Count" => 8 + | "mips_CP0_Cause" => 9 + | "mips_CP0_EPC" => 10 + | "mips_CP0_Debug" => 11 + | "mips_CP0_ErrCtl" => 12 + | "mips_BranchDelay" => 13 + | "mips_BranchTo" => 14 + | "mips_LLbit" => 15 + | "mips_hi" => 16 + | "mips_lo" => 17 + | "mips_PC" => 18 | _ => ~1 val total_dest_lit = Lib.total wordsSyntax.dest_word_literal fun word_compare (w1, w2) = @@ -406,7 +409,7 @@ in end | _ => [] in - List.map + List.mapPartial (fn (s, ds) => let val sbst = Term.subst s @@ -415,13 +418,17 @@ in val f = utilsLib.rhsc o cnv o sbst val p' = subst_delete f ds pl val q' = subst_delete f ds ql + val th = thm |> Thm.INST s + |> Drule.DISCH_ALL + |> Conv.CONV_RULE cnv + |> Drule.UNDISCH_ALL in - (thm |> Thm.INST s - |> Drule.DISCH_ALL - |> Conv.CONV_RULE cnv - |> Drule.UNDISCH_ALL, - temporal_stateSyntax.mk_spec_or_temporal_next m - (stateLib.generate_temporal()) (p', sbst c, q')) + if utilsLib.vacuous th + then NONE + else SOME + (th, + temporal_stateSyntax.mk_spec_or_temporal_next m + (stateLib.generate_temporal()) (p', sbst c, q')) end) groups end end @@ -467,6 +474,12 @@ in end end +(* +val l = (List.concat thm_ts) +val x as (thm, t) = List.nth (l, 0) +spec x +*) + local val get_opcode = fst o bitstringSyntax.dest_v2w o @@ -533,6 +546,8 @@ end (* Testing... +open mips_progLib + val imp_spec = MIPS_IMP_SPEC val imp_temp = mips_progTheory.MIPS_IMP_TEMPORAL val read_thms = [mips_stepTheory.get_bytes] @@ -559,13 +574,16 @@ in in bitstringSyntax.hexstring_of_term (Term.subst s tm) end + fun hex s = + mips_spec_hex s + handle e as HOL_ERR _ => (print ("\n\n" ^ s ^ "\n\n"); raise e) end val () = mips_config false val be = false val tst = mips_spec -val tst = Count.apply mips_spec_hex o random_hex -val tst = mips_spec_hex o random_hex +val tst = Count.apply hex o random_hex +val tst = hex o random_hex val dec = Conv.CONV_RULE (Conv.DEPTH_CONV bitstringLib.v2w_n2w_CONV) o mips_stepLib.mips_decode_hex @@ -574,7 +592,12 @@ val d = List.filter (fn (s, _) => not (Lib.mem s ["MFC0", "MTC0"])) val l = List.map (I ## tst) d -mips_stepLib.mips_find_opc (mips_stepLib.hex_to_padded_opcode "9FA0AED9") +mips_stepLib.mips_find_opc (mips_stepLib.hex_to_padded_opcode "000C001E") + +val s = random_hex (Redblackmap.find (mips_stepLib.mips_dict, "ERET")) +mips_spec (Redblackmap.find (mips_stepLib.mips_dict, "ERET")) + +mips_spec_hex s dec "9FA0AED9" diff --git a/examples/l3-machine-code/mips/step/mips_stepLib.sml b/examples/l3-machine-code/mips/step/mips_stepLib.sml index 84676b2f7e..619de90f6c 100644 --- a/examples/l3-machine-code/mips/step/mips_stepLib.sml +++ b/examples/l3-machine-code/mips/step/mips_stepLib.sml @@ -40,7 +40,8 @@ val cond_thms = Q.prove( local val state_fns = utilsLib.accessor_fns ``:mips_state`` val other_fns = - [pairSyntax.fst_tm, pairSyntax.snd_tm, bitstringSyntax.v2w_tm] @ + [pairSyntax.fst_tm, pairSyntax.snd_tm, bitstringSyntax.v2w_tm, + optionSyntax.is_some_tm] @ utilsLib.update_fns ``:mips_state`` val extra_fns = [wordsSyntax.sw2sw_tm, wordsSyntax.w2w_tm, @@ -221,7 +222,8 @@ val bEV = dfn'BLTZ_def, dfn'BGEZ_def, dfn'BLTZAL_def, dfn'BGEZAL_def, dfn'BEQL_def, dfn'BNEL_def, dfn'BLEZL_def, dfn'BGTZL_def, dfn'BLTZL_def, dfn'BGEZL_def, dfn'BLTZALL_def, dfn'BGEZALL_def, - CheckBranch_def] [[``^st.BranchDelay = NONE``]] [] + ConditionalBranch_def, ConditionalBranchLikely_def] + [[``^st.BranchDelay = NONE``]] [] (* ------------------------------------------------------------------------- *) @@ -325,7 +327,9 @@ val BGEZALL = bEV ``dfn'BGEZALL (rs, offset)`` (* Assumes EXL is high, which permits return from exception *) val ERET = - EVR COND_UPDATE_RULE [dfn'ERET_def, KernelMode_def, CheckBranch_def] + EVR (SIMP_RULE std_ss [ASSUME ``^st.CP0.Status.EXL``, satTheory.AND_INV] o + COND_UPDATE_RULE) + [dfn'ERET_def, KernelMode_def] [[``^st.CP0.Status.EXL``, ``^st.BranchDelay = NONE``]] [] ``dfn'ERET`` (* ------------------------------------------------------------------------- *) @@ -581,12 +585,16 @@ local val v = fst (bitstringSyntax.dest_v2w (bitstringSyntax.mk_vec 32 0)) val unpredictable_tm = ``mips$Unpredictable`` fun fix_unpredictable thm = - case Lib.total (boolSyntax.dest_cond o utilsLib.rhsc) thm of - SOME (b, t, _) => - if t = unpredictable_tm - then REWRITE_RULE [ASSUME (boolSyntax.mk_neg b)] thm - else thm - | _ => thm + let + val thm = REWRITE_RULE [not31] thm + in + case Lib.total (boolSyntax.dest_cond o utilsLib.rhsc) thm of + SOME (b, t, _) => + if t = unpredictable_tm + then REWRITE_RULE [ASSUME (boolSyntax.mk_neg b)] thm + else thm + | _ => thm + end in fun DecodeMIPS pat = let @@ -875,26 +883,31 @@ local val st_BranchDelay_tm = mk_proj_BranchDelay st val ap_snd = Thm.AP_TERM ``SND:unit # mips_state -> mips_state`` val snd_conv = Conv.REWR_CONV pairTheory.SND - val delay_none_tm = ``^st.BranchDelay = NONE`` - val delay_ok = not o List.exists (Lib.equal delay_none_tm) o Thm.hyp val STATE_CONV = Conv.QCONV (REWRITE_CONV (utilsLib.datatype_rewrites true "mips" ["mips_state", "CP0"] @ [boolTheory.COND_ID, cond_rand_thms, ASSUME ``^st.BranchTo = NONE``])) + THENC REPEATC + (Conv.DEPTH_CONV Thm.BETA_CONV + THENC + REWRITE_CONV + [boolTheory.COND_ID, wordsTheory.WORD_SUB_ADD, branch_delay, + pairTheory.pair_case_def]) val BRANCH_DELAY_RULE = - PURE_REWRITE_RULE [ASSUME ``^st.BranchDelay = SOME a``] + utilsLib.ALL_HYP_CONV_RULE + (REWRITE_CONV [ASSUME ``^st.BranchDelay = SOME d``, + optionTheory.NOT_SOME_NONE]) val NO_BRANCH_DELAY_RULE = PURE_REWRITE_RULE [boolTheory.COND_ID, ASSUME ``^st.BranchDelay = NONE``] val state_rule = Conv.RIGHT_CONV_RULE (Conv.RAND_CONV STATE_CONV) val exc_rule = SIMP_RULE bool_ss [] o COND_UPDATE_RULE o state_rule - val MP_Next = state_rule o Drule.MATCH_MP NextStateMIPS_nodelay - val MP_NextB = state_rule o Drule.MATCH_MP NextStateMIPS_delay - val MP_NextE = exc_rule o Drule.MATCH_MP NextStateMIPS_exception o + val MP_Next = state_rule o Drule.MATCH_MP NextStateMIPS_nodelay o NO_BRANCH_DELAY_RULE - val MP_NextF = exc_rule o Drule.MATCH_MP NextStateMIPS_exception_delay o - BRANCH_DELAY_RULE + val MP_NextB = state_rule o BRANCH_DELAY_RULE o + Drule.MATCH_MP NextStateMIPS_delay + val MP_NextE = state_rule o Drule.MATCH_MP NextStateMIPS_exception val Run_CONV = utilsLib.Run_CONV ("mips", st) o utilsLib.rhsc in fun mips_eval be = @@ -915,18 +928,13 @@ in val tm = rhsc thm3 val thms = List.map (fn f => STATE_CONV (f tm)) [mk_proj_exception, - mk_proj_exceptionSignalled, mk_proj_BranchDelay, mk_proj_BranchTo] val thm = Drule.LIST_CONJ ([thm1, thm2, thm3] @ thms) in - if rhsc (List.nth (thms, 2)) = st_BranchDelay_tm - then MP_Next thm :: - (if delay_ok thm andalso - optionSyntax.is_none (rhsc (Lib.last thms)) - then [MP_NextB thm] - else []) - else [MP_NextE thm, MP_NextF thm] + [MP_Next thm] @ + ([MP_NextB thm] handle HOL_ERR _ => []) @ + ([MP_NextE thm] handle HOL_ERR _ => []) end end end @@ -956,14 +964,16 @@ open mips_stepLib val step = mips_eval false fun test s = step (Redblackmap.find (mips_dict, s)) - -test "ADDI"; -test "ADDU"; -test "J"; -test "BEQ"; -test "BEQL"; -test "BLTZAL"; -test "ERET" +fun test s = (Redblackmap.find (mips_dict, s)) + +val v = test "ADDI"; +val v = test "ADDU"; +val v = test "J"; +val v = test "BEQ"; +val v = test "BEQL"; +val v = test "BLTZAL"; +val v = test "BLTZALL"; +val v = test "ERET" val be = false val v = bitstringSyntax.bitstring_of_hexstring "811BAF37" diff --git a/examples/l3-machine-code/mips/step/mips_stepScript.sml b/examples/l3-machine-code/mips/step/mips_stepScript.sml index 1049c6954b..cc724a826e 100644 --- a/examples/l3-machine-code/mips/step/mips_stepScript.sml +++ b/examples/l3-machine-code/mips/step/mips_stepScript.sml @@ -40,6 +40,7 @@ val tac = exceptionSignalled_id, LoadMemory_ARB_CCA] \\ Cases_on `(SND (Run (Decode w) s)).BranchTo` \\ Cases_on `(SND (Run (Decode w) s)).BranchDelay` + \\ TRY (Cases_on `x`) \\ lrw [] \\ fs [mips_state_component_equality] @@ -51,88 +52,72 @@ val NextStateMIPS_nodelay = utilsLib.ustore_thm("NextStateMIPS_nodelay", (Decode w = i) /\ (SND (Run i s) = next_state) /\ (next_state.exception = s.exception) /\ - (next_state.exceptionSignalled = s.exceptionSignalled) /\ - (next_state.BranchDelay = s.BranchDelay) /\ + (next_state.BranchDelay = NONE) /\ (next_state.BranchTo = b) ==> (NextStateMIPS s = SOME (next_state with - <| PC := next_state.PC + 4w; - BranchDelay := b; + <| PC := case b of SOME (T, a) => a | _ => next_state.PC + 4w; + BranchDelay := case b of SOME (F, a) => SOME (SOME a) + | SOME (T, _) => SOME NONE + | _ => NONE; BranchTo := NONE; + exceptionSignalled := F; CP0 := next_state.CP0 with Count := next_state.CP0.Count + 1w |>))`, - tac) + tac + ) val NextStateMIPS_delay = utilsLib.ustore_thm("NextStateMIPS_delay", `(s.exception = NoException) /\ - (s.BranchDelay = SOME a) /\ + (s.BranchDelay = SOME d) /\ ~s.exceptionSignalled ==> (Fetch s = (SOME w, s)) /\ (Decode w = i) /\ (SND (Run i s) = next_state) /\ (next_state.exception = s.exception) /\ - (next_state.exceptionSignalled = s.exceptionSignalled) /\ (next_state.BranchDelay = s.BranchDelay) /\ (next_state.BranchTo = NONE) ==> (NextStateMIPS s = SOME (next_state with - <| PC := a; + <| PC := case d of SOME a => a | NONE => next_state.PC + 4w; BranchDelay := NONE; + exceptionSignalled := F; CP0 := next_state.CP0 with Count := next_state.CP0.Count + 1w |>))`, - tac) + tac + ) +(* exceptions can occur in the branch delay slot *) val NextStateMIPS_exception = utilsLib.ustore_thm("NextStateMIPS_exception", `(s.exception = NoException) /\ - (s.BranchDelay = NONE) /\ - ~s.exceptionSignalled ==> - (Fetch s = (SOME w, s)) /\ - (Decode w = i) /\ - (SND (Run i s) = next_state) /\ - (next_state.exception = s.exception) /\ - (next_state.exceptionSignalled = e) /\ - (next_state.BranchDelay = NONE) /\ - (next_state.BranchTo = b) ==> - (NextStateMIPS s = - SOME (if e /\ (b = NONE) then - next_state with - <| PC := next_state.PC; - exceptionSignalled := F; - CP0 := next_state.CP0 with - Count := next_state.CP0.Count + 1w |> - else - next_state with - <| PC := next_state.PC + 4w; - BranchDelay := b; - BranchTo := NONE; - exceptionSignalled := F; - CP0 := next_state.CP0 with - Count := next_state.CP0.Count + 1w |>))`, - tac) - -val NextStateMIPS_exception_delay = - utilsLib.ustore_thm("NextStateMIPS_exception_delay", - `(s.exception = NoException) /\ - (s.BranchDelay = SOME a) /\ + (s.BranchDelay = SOME d) /\ ~s.exceptionSignalled ==> (Fetch s = (SOME w, s)) /\ (Decode w = i) /\ (SND (Run i s) = next_state) /\ (next_state.exception = s.exception) /\ - (next_state.exceptionSignalled = e) /\ - (next_state.BranchDelay = if e then NONE else SOME a) /\ + (next_state.BranchDelay = if b then NONE else s.BranchDelay) /\ (next_state.BranchTo = NONE) ==> (NextStateMIPS s = SOME (next_state with - <| PC := if e then next_state.PC else a; + <| PC := if b then + next_state.PC + 4w + else + (case d of SOME a => a | NONE => next_state.PC + 4w); BranchDelay := NONE; exceptionSignalled := F; CP0 := next_state.CP0 with Count := next_state.CP0.Count + 1w |>))`, - tac) + tac + ) (* ------------------------------------------------------------------------ *) +val not31 = Q.store_thm("not31", + `x0 /\ x1 /\ x2 /\ x3 /\ x4 = (v2w [x0; x1; x2; x3; x4] = (31w: word5))`, + blastLib.BBLAST_TAC + ) + val v2w_0_rwts = Q.store_thm("v2w_0_rwts", `((v2w [F; F; F; F; F] = 0w: word5)) /\ ((v2w [T; b3; b2; b1; b0] = 0w: word5) = F) /\ @@ -557,4 +542,38 @@ val StoreMemory_doubleword = Q.store_thm("StoreMemory_doubleword", (* ------------------------------------------------------------------------ *) +val branch_delay = Q.store_thm("branch_delay", + `(!b x y. + (case (if b then (F, x) else (T, y)) of + (T, a) => SOME NONE + | (F, a) => SOME (SOME a)) = + (if b then SOME (SOME x) else SOME NONE)) /\ + (!b x y. + (case (if b then (F, x) else (T, y)) of + (T, a) => a + | (F, a) => y) = y) /\ + (!b x y. + (if b then + (case THE (if b then SOME (F, x) else NONE) of + (T, a) => SOME NONE + | (F, a) => SOME (SOME a)) + else + NONE) = + (if b then SOME (SOME x) else NONE)) /\ + (!b x y. + (if b then + (case THE (if b then SOME (F, x) else NONE) of + (T, a) => a + | (F, a) => y) + else + y) = y) /\ + (!b. (if b then T else F) = b) /\ + (!b x y. + (if b then x else y) + 4w = (if b then x + 4w else y + 4w)) /\ + (!x. x + 4w + 4w = x + 8w)`, + rw [] \\ fs []) + +(* ------------------------------------------------------------------------ *) + + val () = export_theory () From 210a422372a92c66744651b3e99c67a78e72df3a Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 11 Nov 2014 14:53:11 +1100 Subject: [PATCH 024/718] Tweak generation of Inno Setup file for building Windows installer --- tools/make_iss.sml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/tools/make_iss.sml b/tools/make_iss.sml index 574a69074f..74602dae9c 100644 --- a/tools/make_iss.sml +++ b/tools/make_iss.sml @@ -11,6 +11,8 @@ val holdir = Globals.HOLDIR val systeml = Systeml.systeml val sysname = Globals.release ^ " " ^ Int.toString Globals.version +val sysname_lchyphen = + String.translate (fn #" " => "-" | c => str (Char.toLower c)) sysname val _ = print "Changing to hol directory\n" val _ = FileSys.chDir holdir @@ -56,7 +58,7 @@ val header = "\ \DefaultGroupName = HOL\n\ \Compression = lzma/ultra\n\ \SolidCompression = true\n\ -\OutputBaseFilename = HOL-install\n"; +\OutputBaseFilename = "^sysname_lchyphen^"-install\n"; fun mem s [] = false | mem s (h::t) = s = h orelse mem s t From 229718f6f5ac13765a628450b16d84426008b619 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 11 Nov 2014 14:54:19 +1100 Subject: [PATCH 025/718] Fix error in K-10 release notes (already fixed on webpages etc) --- doc/kananaskis-10.release.md | 2 -- 1 file changed, 2 deletions(-) diff --git a/doc/kananaskis-10.release.md b/doc/kananaskis-10.release.md index 57be12e12d..7c038ea072 100644 --- a/doc/kananaskis-10.release.md +++ b/doc/kananaskis-10.release.md @@ -63,8 +63,6 @@ Bugs fixed: * The “munging” code for turning HOL into LaTeX now does a better job of rendering data type definition theorems. (This change is independent of the new underlying syntax described earlier.) -* On Windows, the Unicode trace is now off by default. - * Pretty-printers added to the system with `add_user_printer` weren’t having terms-to-be-printed tested against the supplied patterns (except by the gross approximation provided by the built-in term-net structure). Thanks to Ramana Kumar for the [bug report](https://github.com/mn200/HOL/issues/172). * Character literals weren’t pretty-printing to LaTeX. We also improved the handling of string literals. Thanks to Ramana Kumar for the [bug reports](http://github.com/HOL-Theorem-Prover/HOL/issues/190). From 742c71b9b46d2753a2e5403d0e6d27668a255ac0 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 11 Nov 2014 15:50:49 +1100 Subject: [PATCH 026/718] Some minor fixes to TeX hacking for monad syntax. In short, spaces shouldn't appear in the "hol" field of TeX_notation call because tokens with spaces in them aren't going to get omitted if the grammar rule is remotely sensible (math mode munging gets hard if there are literal spaces around). Putting spaces into the TeX field is wrong (even wronger, really) for the same reason. --- src/monad/monadsyntax.sml | 6 +++--- src/monad/parmonadsyntax.sml | 6 +++--- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/src/monad/monadsyntax.sml b/src/monad/monadsyntax.sml index bec3689ffc..da0a6c76c7 100644 --- a/src/monad/monadsyntax.sml +++ b/src/monad/monadsyntax.sml @@ -201,8 +201,8 @@ val _ = temp_overload_on (monad_unitbind, mkc "IGNORE_BIND") val _ = temp_overload_on ("return", mkc "UNIT") val _ = TexTokenMap.temp_TeX_notation - {hol = "<-", TeX = ("\\HOLTokenLeftmap", 1)} -val _ = TexTokenMap.temp_TeX_notation {hol = "do", TeX = (" \\HOLKeyword{do}", 2)} -val _ = TexTokenMap.temp_TeX_notation {hol = "od", TeX = (" \\HOLKeyword{od}", 2)} + {hol = "<-", TeX = ("\\HOLTokenLeftmap{}", 1)} +val _ = TexTokenMap.temp_TeX_notation {hol = "do", TeX = ("\\HOLKeyword{do}", 2)} +val _ = TexTokenMap.temp_TeX_notation {hol = "od", TeX = ("\\HOLKeyword{od}", 2)} end (* struct *) diff --git a/src/monad/parmonadsyntax.sml b/src/monad/parmonadsyntax.sml index 51e29bdfb0..047c5086ae 100644 --- a/src/monad/parmonadsyntax.sml +++ b/src/monad/parmonadsyntax.sml @@ -259,7 +259,7 @@ end val _ = temp_add_user_printer ("parmonadsyntax.print_monads", ``x:'a``, print_monads) -val _ = TexTokenMap.temp_TeX_notation {hol = " <-", TeX = (" \\HOLTokenLeftmap{}", 1)} -val _ = TexTokenMap.temp_TeX_notation {hol = "do", TeX = (" \\HOLKeyword{do}", 2)} -val _ = TexTokenMap.temp_TeX_notation {hol = "od", TeX = (" \\HOLKeyword{od}", 2)} +val _ = TexTokenMap.temp_TeX_notation {hol = "<-", TeX = ("\\HOLTokenLeftmap{}", 1)} +val _ = TexTokenMap.temp_TeX_notation {hol = "do", TeX = ("\\HOLKeyword{do}", 2)} +val _ = TexTokenMap.temp_TeX_notation {hol = "od", TeX = ("\\HOLKeyword{od}", 2)} end (* struct *) From 7e33637495f0f50b227b08c20d33f96037333729 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Tue, 18 Nov 2014 10:23:15 +1100 Subject: [PATCH 027/718] list_tactic concept introduce list_tactic - works on a list of goals, not a single goal THEN_LT (tac1, ltac2 : list_tactic), A tactical that applies ltac2 to the list of subgoals resulting from tac1 TACS_TO_LT (tac2l: tactic list) : list_tactic ALLGOALS - A list_tactic which applies a given tactic to all goals ALL_LT - always succeeds NTH_GOAL - applies tactic to nth goal of list REVERSE_LT - A list_tactic that reverses a list of subgoals SPLIT_LT - apply two list-tactics, one to first n subgoals, the other to the rest ROTATE_LT - rotate the list of subgoals by n positions --- src/0/Overlay.sml | 2 +- src/1/Abbrev.sig | 2 + src/1/Abbrev.sml | 2 + src/1/Tactical.sig | 15 ++++ src/1/Tactical.sml | 174 ++++++++++++++++++++++++++++++++++++++++++++- 5 files changed, 191 insertions(+), 4 deletions(-) diff --git a/src/0/Overlay.sml b/src/0/Overlay.sml index fa42318c65..d8c453f615 100644 --- a/src/0/Overlay.sml +++ b/src/0/Overlay.sml @@ -22,7 +22,7 @@ open CoreKernel; between the two. ---------------------------------------------------------------------- *) -infix ++ && |-> THEN THEN1 THENL THENC ORELSE ORELSEC THEN_TCL ORELSE_TCL ?> |> +infix ++ && |-> THEN THEN1 THENL THEN_LT THENC ORELSE ORELSEC THEN_TCL ORELSE_TCL ?> |> (* infixes for THEN shorthands *) infix >> >- >| \\ diff --git a/src/1/Abbrev.sig b/src/1/Abbrev.sig index 936397d903..4fce1dae32 100644 --- a/src/1/Abbrev.sig +++ b/src/1/Abbrev.sig @@ -8,6 +8,8 @@ sig type goal = term list * term type validation = thm list -> thm type tactic = goal -> goal list * validation + type list_validation = thm list -> thm list + type list_tactic = goal list -> goal list * list_validation type thm_tactic = thm -> tactic type thm_tactical = thm_tactic -> thm_tactic type ppstream = Portable.ppstream diff --git a/src/1/Abbrev.sml b/src/1/Abbrev.sml index bda92f1627..ea8168a2e4 100644 --- a/src/1/Abbrev.sml +++ b/src/1/Abbrev.sml @@ -8,6 +8,8 @@ struct type goal = term list * term type validation = thm list -> thm type tactic = goal -> goal list * validation + type list_validation = thm list -> thm list + type list_tactic = goal list -> goal list * list_validation type thm_tactic = thm -> tactic type thm_tactical = thm_tactic -> thm_tactic type ppstream = Portable.ppstream diff --git a/src/1/Tactical.sig b/src/1/Tactical.sig index 74fa1313b3..701ce57c9f 100644 --- a/src/1/Tactical.sig +++ b/src/1/Tactical.sig @@ -9,10 +9,25 @@ sig val THENL : tactic * tactic list -> tactic val ORELSE : tactic * tactic -> tactic val THEN1 : tactic * tactic -> tactic + val THEN_LT : ('a -> goal list * (thm list -> 'b)) * list_tactic -> + 'a -> goal list * (thm list -> 'b) + (* could be used as + val THEN_LT : tactic * list_tactic -> tactic + val THEN_LT : list_tactic * list_tactic -> list_tactic + *) + val TACS_TO_LT : tactic list -> list_tactic + val ALLGOALS : tactic -> list_tactic + val NTH_GOAL : tactic -> int -> list_tactic + val LASTGOAL : tactic -> list_tactic + val HEADGOAL : tactic -> list_tactic + val SPLIT_LT : int -> list_tactic * list_tactic -> list_tactic + val ROTATE_LT : int -> list_tactic val REVERSE : tactic -> tactic + val REVERSE_LT : list_tactic val FAIL_TAC : string -> tactic val NO_TAC : tactic val ALL_TAC : tactic + val ALL_LT : list_tactic val TRY : tactic -> tactic val REPEAT : tactic -> tactic val VALID : tactic -> tactic diff --git a/src/1/Tactical.sml b/src/1/Tactical.sml index b870acad0b..1bb7376990 100644 --- a/src/1/Tactical.sml +++ b/src/1/Tactical.sml @@ -75,14 +75,14 @@ fun store_thm (name, tm, tac) = (print ("Failed to prove theorem " ^ name ^ ".\n"); Raise e) -infix THEN THENL THEN1 ORELSE +infix THEN THENL THEN1 ORELSE THEN_LT (*--------------------------------------------------------------------------- * fun (tac1:tactic) THEN (tac2:tactic) : tactic = fn g => * let val (gl,p) = tac1 g * val (gll,pl) = unzip(map tac2 gl) * in - * (flatten gll, (p o mapshape(map length gll)pl)) + * (flatten gll, (p o mapshape(map length gll)pl)) * end; *---------------------------------------------------------------------------*) @@ -113,7 +113,7 @@ fun tac1 THEN tac2 = * val tac2gl = zip tac2l gl * val (gll,pl) = unzip (map (fn (tac2,g) => tac2 g) tac2gl) * in - * (flatten gll, p o mapshape(map length gll) pl) + * (flatten gll, p o mapshape(map length gll) pl) * end *---------------------------------------------------------------------------*) @@ -162,6 +162,152 @@ fun op THEN1 (tac1: tactic, tac2: tactic) : tactic = (t_gl, fn thl => jf (h_jf [] :: thl)) end +(*--------------------------------------------------------------------------- + * tac1 THEN_LT ltac2: + * A tactical that applies ltac2 to the list of subgoals resulting from tac1 + * tac1 may be a tactic or a list_tactic + *---------------------------------------------------------------------------*) +fun op THEN_LT (tac1, ltac2 : list_tactic) = + fn g => + let + val (gl1, vf1) = tac1 g + val (gl2, vf2) = ltac2 gl1 ; + in + (gl2, vf1 o vf2) + end + +(* first argument can be a tactic or a list-tactic *) +val _ = op THEN_LT : tactic * list_tactic -> tactic ; +val _ = op THEN_LT : list_tactic * list_tactic -> list_tactic ; + +(*--------------------------------------------------------------------------- + * fun ALLGOALS (tac2:tactic) : list_tactic = fn gl => + * let + * val (gll,pl) = unzip(map tac2 gl) + * in + * (flatten gll, mapshape(map length gll)pl) + * end; + * A list_tactic which applies a given tactic to all goals + *---------------------------------------------------------------------------*) + +fun ALLGOALS tac2 gl = + case itlist + (fn goal => fn (G, V, lengths) => + case tac2 goal of + ([], vfun) => let + val th = vfun [] + in + (G, empty th :: V, 0 :: lengths) + end + | (goals, vfun) => + (goals @ G, vfun :: V, length goals :: lengths)) + gl ([], [], []) of + ([], V, _) => + ([], let val ths = map (fn f => f []) V in empty ths end) + | (G, V, lengths) => (G, mapshape lengths V) + +(*--------------------------------------------------------------------------- + * fun TACS_TO_LT (tac2l: tactic list) : list_tactic = fn gl => + * let + * val tac2gl = zip tac2l gl + * val (gll,pl) = unzip (map (fn (tac2,g) => tac2 g) tac2gl) + * in + * (flatten gll, mapshape(map length gll) pl) + * end + * Converts a list of tactics to a single list_tactic + *---------------------------------------------------------------------------*) + +fun TACS_TO_LT (tacl: tactic list) : list_tactic = + fn gl => + let + val (G, V, lengths) = + itlist2 + (fn goal => fn tac => fn (G, V, lengths) => + case tac goal of + ([], vfun) => let + val th = vfun [] + in + (G, (empty th) :: V, 0 :: lengths) + end + | (goals, vfun) => + (goals @ G, vfun :: V, length goals :: lengths)) + gl tacl ([], [], []) + in + case G of + [] => ([], let val ths = map (fn f => f []) V in empty ths end) + | _ => (G, mapshape lengths V) + end + +fun (tac1 ORELSE tac2) g = tac1 g handle HOL_ERR _ => tac2 g + +(*--------------------------------------------------------------------------- + * tac1 THEN1 tac2: A tactical like THEN that applies tac2 only to the + * first subgoal of tac1 + *---------------------------------------------------------------------------*) + +fun op THEN1 (tac1: tactic, tac2: tactic) : tactic = + fn g => + let + val (gl, jf) = tac1 g + val (h_g, t_gl) = + case gl of + [] => raise ERR "THEN1" "goal completely solved by first tactic" + | h :: t => (h, t) + val (h_gl, h_jf) = tac2 h_g + val _ = + if null h_gl then () + else raise ERR "THEN1" "first subgoal not solved by second tactic" + in + (t_gl, fn thl => jf (h_jf [] :: thl)) + end + +(*--------------------------------------------------------------------------- + * NTH_GOAL tac n: A list_tactic that applies tac to the nth goal + (counting goals from 1) + *---------------------------------------------------------------------------*) +fun NTH_GOAL tac n gl1 = + let val (gl_before, g :: gl_after) = Lib.split_after (n-1) gl1 ; + val (gl2, vf2) = tac g ; + val gl_result = gl_before @ gl2 @ gl_after ; + fun vf thl = + let val (th_before, th_rest) = Lib.split_after (n-1) thl ; + val (th2, th_after) = Lib.split_after (length gl2) th_rest ; + val th_result = th_before @ vf2 th2 :: th_after ; + in th_result end ; + in (gl_result, vf) end + handle _ => raise ERR "NTH_GOAL" "no nth subgoal in list" ; + +fun LASTGOAL tac gl1 = NTH_GOAL tac (length gl1) gl1 ; +fun HEADGOAL tac gl1 = NTH_GOAL tac 1 gl1 ; + +(*--------------------------------------------------------------------------- + * SPLIT_LT n (ltaca, ltacb) : A list_tactic that applies ltaca to the + first n goals, and ltacb to the rest + *---------------------------------------------------------------------------*) +fun SPLIT_LT n (ltaca, ltacb) gl = + let val (gla, glb) = Lib.split_after n gl ; + val (glra, vfa) = ltaca gla ; + val (glrb, vfb) = ltacb glb ; + fun vf ths = + let val (thsa, thsb) = Lib.split_after (length glra) ths ; + in vfa thsa @ vfb thsb end ; + in (glra @ glrb, vf) end ; + +(*--------------------------------------------------------------------------- + * ROTATE_LT n : + * A list_tactic that moves the first n goals to the end of the goal list + * first n goals + *---------------------------------------------------------------------------*) +fun ROTATE_LT n [] = ([], Lib.I) + | ROTATE_LT n gl = + let val lgl = length gl ; + val fixn = Int.mod (n, lgl) ; + val (gla, glb) = Lib.split_after fixn gl ; + fun vf ths = + let val (thsb, thsa) = Lib.split_after (lgl - fixn) ths ; + in thsa @ thsb end ; + in (glb @ gla, vf) end ; + (*--------------------------------------------------------------------------- * REVERSE tac: A tactical that reverses the list of subgoals of tac. * Intended for use with THEN1 to pick the `easy' subgoal, e.g.: @@ -178,6 +324,21 @@ fun REVERSE tac g = (rev gl, jf o rev) end +(*--------------------------------------------------------------------------- + * REVERSE_LT: A list_tactic that reverses a list of subgoals + *---------------------------------------------------------------------------*) + +fun REVERSE_LT gl = (rev gl, rev) ; + +(* for testing, redefine REVERSE +fun REVERSE tac = tac THEN_LT REVERSE_LT ; +*) + +(* for testing, redefine THEN and THENL +fun tac1 THENL tacs2 = tac1 THEN_LT TACS_TO_LT tacs2 ; +fun tac1 THEN tac2 = tac1 THEN_LT ALLGOALS tac2 ; +*) + (*--------------------------------------------------------------------------- * Fail with the given token. Useful in tactic programs to check that a * tactic produces no subgoals. Write @@ -193,11 +354,18 @@ fun FAIL_TAC tok (g: goal) = raise ERR "FAIL_TAC" tok fun NO_TAC g = FAIL_TAC "NO_TAC" g +(* for testing, redefine THEN1 +fun tac1 THEN1 tac2 = tac1 THEN_LT NTH_GOAL (tac2 THEN NO_TAC) 1 ; +fun tac1 THEN1 tac2 = tac1 THEN_LT REVERSE_LT THEN_LT + LASTGOAL (tac2 THEN NO_TAC) THEN_LT REVERSE_LT ; +*) + (*--------------------------------------------------------------------------- * Tactic that succeeds on all goals; identity for THEN *---------------------------------------------------------------------------*) val ALL_TAC: tactic = fn (g: goal) => ([g], hd) +val ALL_LT: list_tactic = fn (gl: goal list) => (gl, Lib.I) fun TRY tac = tac ORELSE ALL_TAC From ccb4b4eb329826ee2f37109fbbaa35b102024e4d Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Tue, 18 Nov 2014 15:59:40 +0000 Subject: [PATCH 028/718] Ensure the bit-string rotate operations is well-defined on empty lists. --- src/n-bit/bitstringScript.sml | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/src/n-bit/bitstringScript.sml b/src/n-bit/bitstringScript.sml index e45cf13b9e..4d8d937a49 100644 --- a/src/n-bit/bitstringScript.sml +++ b/src/n-bit/bitstringScript.sml @@ -74,7 +74,7 @@ val rotate_def = Define` let l = LENGTH v in let x = m MOD l in - if x = 0 then v else field (x - 1) 0 v ++ field (l - 1) x v`; + if (l = 0) \/ (x = 0) then v else field (x - 1) 0 v ++ field (l - 1) x v`; val testbit_def = zDefine` testbit b v = (field b b v = [T])`; @@ -227,6 +227,15 @@ val length_w2v = Q.store_thm("length_w2v", `!w:'a word. LENGTH (w2v w) = dimindex(:'a)`, lrw [w2v_def]); +val length_rotate = Q.store_thm("length_rotate", + `!v n. LENGTH (rotate v n) = LENGTH v`, + simp [rotate_def] + \\ rw [length_field] + \\ fs [DECIDE ``n <> 0n ==> (SUC (n - 1) = n)``, + DECIDE ``n:num < l ==> (n + (l - n) = l)``, + arithmeticTheory.NOT_ZERO_LT_ZERO, arithmeticTheory.MOD_LESS] + ) + val el_rev_count_list = Q.store_thm("el_rev_count_list", `!n i. i < n ==> (EL i (rev_count_list n) = n - 1 - i)`, Induct \\ lrw [rev_count_list_def]); @@ -943,7 +952,7 @@ val ops_to_n2w = Q.store_thm("ops_to_n2w", val () = bossLib.export_rewrites ["length_w2v", "length_fixwidth", "length_field", - "length_bitify", "length_shiftr", + "length_bitify", "length_shiftr", "length_rotate", "v2w_w2v", "v2n_n2v", "v2w_n2v", "fixwidth_fixwidth", "fixwidth_id_imp"] From 06401b706a63de6bcd8a87a07fbdbc963c9749e3 Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Tue, 18 Nov 2014 16:08:27 +0000 Subject: [PATCH 029/718] Update for L3 machine-code examples. Some minor changes come from using the latest version of L3 when generating SML code. The ARMv8 model gains a function for encoding instructions (in the logic). The step tools are updated to support the NOP instruction. --- examples/l3-machine-code/arm/model/arm.sig | 4 +- examples/l3-machine-code/arm/model/arm.sml | 870 ++++++------ examples/l3-machine-code/arm8/model/arm8.sig | 2 +- examples/l3-machine-code/arm8/model/arm8.sml | 99 +- .../l3-machine-code/arm8/model/arm8Script.sml | 1257 ++++++++++++++++- .../arm8/model/arm8_encodeScript.sml | 48 + .../arm8/step/arm8_stepLib.sml | 16 +- examples/l3-machine-code/lib/L3.sig | 20 +- examples/l3-machine-code/lib/L3.sml | 45 +- examples/l3-machine-code/lib/Set.sig | 15 + examples/l3-machine-code/lib/Set.sml | 26 + examples/l3-machine-code/m0/model/m0.sig | 2 +- examples/l3-machine-code/m0/model/m0.sml | 38 +- examples/l3-machine-code/mips/model/mips.sig | 2 +- examples/l3-machine-code/mips/model/mips.sml | 24 +- examples/l3-machine-code/x64/model/x64.sig | 2 +- examples/l3-machine-code/x64/model/x64.sml | 35 +- 17 files changed, 1934 insertions(+), 571 deletions(-) create mode 100644 examples/l3-machine-code/arm8/model/arm8_encodeScript.sml create mode 100644 examples/l3-machine-code/lib/Set.sig create mode 100644 examples/l3-machine-code/lib/Set.sml diff --git a/examples/l3-machine-code/arm/model/arm.sig b/examples/l3-machine-code/arm/model/arm.sig index b6a76afd74..ad1a91f342 100644 --- a/examples/l3-machine-code/arm/model/arm.sig +++ b/examples/l3-machine-code/arm/model/arm.sig @@ -1,4 +1,4 @@ -(* arm - generated by L<3> - Fri May 16 15:32:26 2014 *) +(* arm - generated by L<3> - Tue Nov 18 15:31:11 2014 *) signature arm = sig @@ -1071,7 +1071,7 @@ val dfn'vstr: val dfn'UndefinedVFP: unit -> unit val Run: instruction -> unit val Fetch: unit -> MachineCode -val Take: (BitsN.nbit * bool) -> bool +val Do: (BitsN.nbit * bool) -> bool val Skip: unit -> instruction val UndefinedARM: BitsN.nbit -> instruction val UndefinedThumb: unit -> instruction diff --git a/examples/l3-machine-code/arm/model/arm.sml b/examples/l3-machine-code/arm/model/arm.sml index 7d6dab2323..d79169e2c3 100644 --- a/examples/l3-machine-code/arm/model/arm.sml +++ b/examples/l3-machine-code/arm/model/arm.sml @@ -1,4 +1,4 @@ -(* arm - generated by L<3> - Fri May 16 15:32:26 2014 *) +(* arm - generated by L<3> - Tue Nov 18 15:31:11 2014 *) structure arm :> arm = struct @@ -1735,26 +1735,26 @@ fun ArchVersion () = | ARMv7_R => 7; fun HaveDSPSupport () = - not(L3.mem((!Architecture),[ARMv4,ARMv4T,ARMv5T])); + not(Set.mem((!Architecture),[ARMv4,ARMv4T,ARMv5T])); -fun HaveThumb2 () = L3.mem((!Architecture),[ARMv6T2,ARMv7_A,ARMv7_R]); +fun HaveThumb2 () = Set.mem((!Architecture),[ARMv6T2,ARMv7_A,ARMv7_R]); fun HaveThumbEE () = ((!Architecture) = ARMv7_A) orelse (((!Architecture) = ARMv7_R) andalso - (L3.mem(Extension_ThumbEE,(!Extensions)))); + (Set.mem(Extension_ThumbEE,(!Extensions)))); fun HaveMPExt () = (Nat.>=(ArchVersion (),7)) andalso - (L3.mem(Extension_Multiprocessing,(!Extensions))); + (Set.mem(Extension_Multiprocessing,(!Extensions))); fun HaveSecurityExt () = - (L3.mem((!Architecture),[ARMv6K,ARMv7_A])) andalso - (L3.mem(Extension_Security,(!Extensions))); + (Set.mem((!Architecture),[ARMv6K,ARMv7_A])) andalso + (Set.mem(Extension_Security,(!Extensions))); fun HaveVirtExt () = (Nat.>=(ArchVersion (),7)) andalso - (L3.mem(Extension_Virtualization,(!Extensions))); + (Set.mem(Extension_Virtualization,(!Extensions))); fun rec'PSR x = {A = BitsN.bit(x,8), C = BitsN.bit(x,29), E = BitsN.bit(x,9), @@ -2361,7 +2361,7 @@ fun CurrentModeIsUserOrSystem () = then raise UNPREDICTABLE (("BadMode: ") ^ (BitsN.toHexString((#M) (!CPSR)))) else () - ; L3.mem((#M) (!CPSR),[BitsN.B(0x10,5),BitsN.B(0x1F,5)]) + ; Set.mem((#M) (!CPSR),[BitsN.B(0x10,5),BitsN.B(0x1F,5)]) ); fun CurrentModeIsHyp () = @@ -4058,7 +4058,7 @@ fun BankedRegisterAccessValid (SYSm,mode) = then if (BitsN.bits(SYSm,2,0)) = (BitsN.B(0x7,3)) then raise UNPREDICTABLE ("BankedRegisterAccessValid") else if (BitsN.bits(SYSm,2,0)) = (BitsN.B(0x6,3)) - then if L3.mem(mode,[BitsN.B(0x1A,5),BitsN.B(0x1F,5)]) + then if Set.mem(mode,[BitsN.B(0x1A,5),BitsN.B(0x1F,5)]) then raise UNPREDICTABLE ("BankedRegisterAccessValid") else () else if (BitsN.bits(SYSm,2,0)) = (BitsN.B(0x5,3)) @@ -4249,7 +4249,7 @@ fun DataProcessing (opc,(setflags,(d,(n,(imm32,C))))) = if (opc = (BitsN.B(0xD,4))) orelse ((opc = (BitsN.B(0xF,4))) andalso (n = (BitsN.B(0xF,4)))) then BitsN.B(0x0,32) - else if ((L3.mem(opc,[BitsN.B(0x4,4),BitsN.B(0x2,4)])) andalso + else if ((Set.mem(opc,[BitsN.B(0x4,4),BitsN.B(0x2,4)])) andalso (n = (BitsN.B(0xF,4)))) andalso (not setflags) then Align 32 (PC (),4) else R n @@ -4277,7 +4277,7 @@ fun DataProcessingPC (opc,(setflags,(n,(imm32,C)))) = if (opc = (BitsN.B(0xD,4))) orelse ((opc = (BitsN.B(0xF,4))) andalso (n = (BitsN.B(0xF,4)))) then BitsN.B(0x0,32) - else if ((L3.mem(opc,[BitsN.B(0x4,4),BitsN.B(0x2,4)])) andalso + else if ((Set.mem(opc,[BitsN.B(0x4,4),BitsN.B(0x2,4)])) andalso (n = (BitsN.B(0xF,4)))) andalso (not setflags) then Align 32 (PC (),4) else R n @@ -4921,7 +4921,7 @@ fun dfn'UnsignedAddSub16 (op',(d,(n,m))) = (w, if Int.>= (res1, - if L3.mem(op',[BitsN.B(0x1,2),BitsN.B(0x2,2)]) + if Set.mem(op',[BitsN.B(0x1,2),BitsN.B(0x2,2)]) then 0 else 65536) then BitsN.B(0x3,2) @@ -4937,7 +4937,7 @@ fun dfn'UnsignedAddSub16 (op',(d,(n,m))) = (w, if Int.>= (res2, - if L3.mem(op',[BitsN.B(0x2,2),BitsN.B(0x3,2)]) + if Set.mem(op',[BitsN.B(0x2,2),BitsN.B(0x3,2)]) then 0 else 65536) then BitsN.B(0x3,2) @@ -6738,12 +6738,14 @@ fun VFPExpandImm (imm8,single) = then BitsN.zeroExtend 64 (BitsN.concat [BitsN.bits(imm8,7,7),BitsN.~(BitsN.bits(imm8,6,6)), - BitsN.replicate(BitsN.bits(imm8,6,6),5), - BitsN.bits(imm8,5,0),BitsN.replicate(BitsN.B(0x0,1),19)]) + BitsN.resize_replicate 5 (BitsN.bits(imm8,6,6),5), + BitsN.bits(imm8,5,0), + BitsN.resize_replicate 19 (BitsN.B(0x0,1),19)]) else BitsN.concat [BitsN.bits(imm8,7,7),BitsN.~(BitsN.bits(imm8,6,6)), - BitsN.replicate(BitsN.bits(imm8,6,6),8),BitsN.bits(imm8,5,0), - BitsN.replicate(BitsN.B(0x0,1),48)]; + BitsN.resize_replicate 8 (BitsN.bits(imm8,6,6),8), + BitsN.bits(imm8,5,0), + BitsN.resize_replicate 48 (BitsN.B(0x0,1),48)]; fun FPCompare32 (op1,op2) = if ((fn _ => raise Fail "FP32_IsNan") op1) orelse @@ -7160,7 +7162,7 @@ fun Fetch () = end end; -fun Take (cond,defined) = +fun Do (cond,defined) = ( CurrentCondition := cond ; let val pass = ConditionPassed () @@ -7203,8 +7205,7 @@ fun DecodeHint (cond,op') = ((((BitsN.bits(op',7,4)) = (BitsN.B(0xF,4))) andalso ((!Encoding) = Encoding_ARM)) andalso ((!Architecture) = ARMv6K)) then NoOperation - else if Take - (cond, + else if Do(cond, (Nat.>=(ArchVersion (),7)) orelse (((!Encoding) = Encoding_ARM) andalso ((!Architecture) = ARMv6K))) then case boolify'8 op' of @@ -7585,7 +7586,7 @@ fun DecodeARM w = (_, (_, (E'0,(_,(false,(false,(false,(false,_)))))))))))))))))))))))) => - (if Take(BitsN.B(0xE,4),Nat.>=(ArchVersion (),6)) + (if Do(BitsN.B(0xE,4),Nat.>=(ArchVersion (),6)) then System (Setend ((BitsN.fromBitstring([E'0],1)) = @@ -7626,7 +7627,7 @@ fun DecodeARM w = val M = BitsN.fromBitstring([M'0],1) val imod = BitsN.fromBitstring([imod'1,imod'0],2) in - if Take(BitsN.B(0xE,4),Nat.>=(ArchVersion (),6)) + if Do(BitsN.B(0xE,4),Nat.>=(ArchVersion (),6)) then ( if ((((not(mode = (BitsN.B(0x0,5)))) andalso (M = (BitsN.B(0x0,1)))) orelse ((BitsN.bit(imod,1)) = @@ -7682,7 +7683,7 @@ fun DecodeARM w = (imm12'5, (imm12'4, (imm12'3,(imm12'2,(imm12'1,imm12'0))))))))))))))))))))))))))) => - (if Take(BitsN.B(0xE,4),Nat.>=(ArchVersion (),7)) + (if Do(BitsN.B(0xE,4),Nat.>=(ArchVersion (),7)) then let val add = (BitsN.fromBitstring([U'0],1)) = @@ -7729,7 +7730,7 @@ fun DecodeARM w = let val Rm = BitsN.fromBitstring([Rm'3,Rm'2,Rm'1,Rm'0],4) in - if Take(BitsN.B(0xE,4),Nat.>=(ArchVersion (),7)) + if Do(BitsN.B(0xE,4),Nat.>=(ArchVersion (),7)) then ( if Rm = (BitsN.B(0xF,4)) then DECODE_UNPREDICTABLE (mc,"PreloadInstruction (register)") @@ -7772,9 +7773,8 @@ fun DecodeARM w = (_, (_, (_,(_,(_,(false,(false,(false,(true,_)))))))))))))))))))))))) => - (if Take - (BitsN.B(0xE,4), - L3.mem((!Architecture),[ARMv6K,ARMv7_A,ARMv7_R])) + (if Do(BitsN.B(0xE,4), + Set.mem((!Architecture),[ARMv6K,ARMv7_A,ARMv7_R])) then ClearExclusive else Skip ()) | (false, @@ -7803,7 +7803,7 @@ fun DecodeARM w = (false, (option'3, (option'2,(option'1,option'0))))))))))))))))))))))))))) => - (if Take(BitsN.B(0xE,4),Nat.>=(ArchVersion (),7)) + (if Do(BitsN.B(0xE,4),Nat.>=(ArchVersion (),7)) then Hint (DataSynchronizationBarrier (BitsN.fromBitstring @@ -7835,7 +7835,7 @@ fun DecodeARM w = (true, (option'3, (option'2,(option'1,option'0))))))))))))))))))))))))))) => - (if Take(BitsN.B(0xE,4),Nat.>=(ArchVersion (),7)) + (if Do(BitsN.B(0xE,4),Nat.>=(ArchVersion (),7)) then Hint (DataMemoryBarrier (BitsN.fromBitstring @@ -7867,7 +7867,7 @@ fun DecodeARM w = (false, (option'3, (option'2,(option'1,option'0))))))))))))))))))))))))))) => - (if Take(BitsN.B(0xE,4),Nat.>=(ArchVersion (),7)) + (if Do(BitsN.B(0xE,4),Nat.>=(ArchVersion (),7)) then Hint (InstructionSynchronizationBarrier (BitsN.fromBitstring @@ -7898,7 +7898,7 @@ fun DecodeARM w = (imm12'5, (imm12'4, (imm12'3,(imm12'2,(imm12'1,imm12'0))))))))))))))))))))))))))) => - (if Take(BitsN.B(0xE,4),HaveDSPSupport ()) + (if Do(BitsN.B(0xE,4),HaveDSPSupport ()) then let val add = (BitsN.fromBitstring([U'0],1)) = @@ -7941,11 +7941,10 @@ fun DecodeARM w = let val R = BitsN.fromBitstring([R'0],1) in - if Take - (BitsN.B(0xE,4), + if Do(BitsN.B(0xE,4), (((R = (BitsN.B(0x1,1))) andalso (Nat.>=(ArchVersion (),7))) andalso - (L3.mem(Extension_Multiprocessing,(!Extensions)))) orelse + (Set.mem(Extension_Multiprocessing,(!Extensions)))) orelse ((R = (BitsN.B(0x0,1))) andalso (HaveDSPSupport ()))) then let val add = @@ -7998,11 +7997,10 @@ fun DecodeARM w = val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) val R = BitsN.fromBitstring([R'0],1) in - if Take - (BitsN.B(0xE,4), + if Do(BitsN.B(0xE,4), (((R = (BitsN.B(0x1,1))) andalso (Nat.>=(ArchVersion (),7))) andalso - (L3.mem(Extension_Multiprocessing,(!Extensions)))) orelse + (Set.mem(Extension_Multiprocessing,(!Extensions)))) orelse ((R = (BitsN.B(0x0,1))) andalso (HaveDSPSupport ()))) then let val is_pldw = R = (BitsN.B(0x0,1)) @@ -8058,7 +8056,7 @@ fun DecodeARM w = let val U = BitsN.fromBitstring([U'0],1) in - if Take(BitsN.B(0xE,4),Nat.>=(ArchVersion (),6)) + if Do(BitsN.B(0xE,4),Nat.>=(ArchVersion (),6)) then let val wback = (BitsN.fromBitstring([W'0],1)) = @@ -8087,7 +8085,7 @@ fun DecodeARM w = val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) val U = BitsN.fromBitstring([U'0],1) in - if Take(BitsN.B(0xE,4),Nat.>=(ArchVersion (),6)) + if Do(BitsN.B(0xE,4),Nat.>=(ArchVersion (),6)) then ( if Rn = (BitsN.B(0xF,4)) then DECODE_UNPREDICTABLE (mc,"ReturnFromException") @@ -8132,7 +8130,7 @@ fun DecodeARM w = (imm24'5, (imm24'4, (imm24'3,(imm24'2,(imm24'1,imm24'0))))))))))))))))))))))))))) => - (if Take(BitsN.B(0xE,4),Nat.>=(ArchVersion (),5)) + (if Do(BitsN.B(0xE,4),Nat.>=(ArchVersion (),5)) then let val imm32 = BitsN.signExtend 32 @@ -8224,7 +8222,7 @@ fun DecodeARM w = let val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) in - if Take(cond,HaveVirtExt ()) + if Do(cond,HaveVirtExt ()) then ( if Rd = (BitsN.B(0xF,4)) then DECODE_UNPREDICTABLE (mc,"MoveToRegisterFromBankedOrSpecial") @@ -8268,7 +8266,7 @@ fun DecodeARM w = let val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) in - if Take(cond,true) + if Do(cond,true) then ( if Rd = (BitsN.B(0xF,4)) then DECODE_UNPREDICTABLE (mc,"MoveToRegisterFromSpecial") @@ -8309,8 +8307,8 @@ fun DecodeARM w = let val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) in - if Take(cond,HaveVirtExt ()) - then ( if L3.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)]) + if Do(cond,HaveVirtExt ()) + then ( if Set.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)]) then DECODE_UNPREDICTABLE (mc,"MoveToBankedOrSpecialRegister") else () @@ -8359,7 +8357,7 @@ fun DecodeARM w = val mask = BitsN.fromBitstring([mask'3,mask'2,mask'1,mask'0],4) in - if Take(cond,true) + if Do(cond,true) then ( if (Rn = (BitsN.B(0xF,4))) orelse (mask = (BitsN.B(0x0,4))) then DECODE_UNPREDICTABLE @@ -8400,7 +8398,7 @@ fun DecodeARM w = (false, (false, (false,(true,(Rm'3,(Rm'2,(Rm'1,Rm'0))))))))))))))))))))))))))) => - (if Take(cond,not((!Architecture) = ARMv4)) + (if Do(cond,not((!Architecture) = ARMv4)) then Branch (BranchExchange (BitsN.fromBitstring([Rm'3,Rm'2,Rm'1,Rm'0],4))) @@ -8432,7 +8430,7 @@ fun DecodeARM w = val Rm = BitsN.fromBitstring([Rm'3,Rm'2,Rm'1,Rm'0],4) val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) in - if Take(cond,Nat.>=(ArchVersion (),5)) + if Do(cond,Nat.>=(ArchVersion (),5)) then ( if (Rd = (BitsN.B(0xF,4))) orelse (Rm = (BitsN.B(0xF,4))) then DECODE_UNPREDICTABLE @@ -8468,7 +8466,7 @@ fun DecodeARM w = let val Rm = BitsN.fromBitstring([Rm'3,Rm'2,Rm'1,Rm'0],4) in - if Take(cond,Nat.>=(ArchVersion (),5)) + if Do(cond,Nat.>=(ArchVersion (),5)) then ( if Rm = (BitsN.B(0xF,4)) then DECODE_UNPREDICTABLE (mc,"BranchLinkExchangeRegister") @@ -8505,7 +8503,7 @@ fun DecodeARM w = val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) in - if Take(cond,HaveDSPSupport ()) + if Do(cond,HaveDSPSupport ()) then ( if ((Rd = (BitsN.B(0xF,4))) orelse (Rn = (BitsN.B(0xF,4)))) orelse (Rm = (BitsN.B(0xF,4))) @@ -8562,7 +8560,7 @@ fun DecodeARM w = Hint(Breakpoint imm32) end ) - else if Take(cond,false) + else if Do(cond,false) then Undefined(BitsN.B(0x0,32)) else NoOperation) | (false, @@ -8589,7 +8587,7 @@ fun DecodeARM w = (true, (true, (true,(imm4'3,(imm4'2,(imm4'1,imm4'0))))))))))))))))))))))))))) => - (if Take(cond,HaveVirtExt ()) + (if Do(cond,HaveVirtExt ()) then ( if not(cond = (BitsN.B(0xE,4))) then DECODE_UNPREDICTABLE(mc,"HypervisorCall") else () @@ -8631,7 +8629,7 @@ fun DecodeARM w = (true, (true, (true,(imm4'3,(imm4'2,(imm4'1,imm4'0))))))))))))))))))))))))))) => - (if Take(cond,HaveSecurityExt ()) + (if Do(cond,HaveSecurityExt ()) then System (SecureMonitorCall (BitsN.fromBitstring @@ -8666,7 +8664,7 @@ fun DecodeARM w = val Ra = BitsN.fromBitstring([Ra'3,Ra'2,Ra'1,Ra'0],4) val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) in - if Take(cond,HaveDSPSupport ()) + if Do(cond,HaveDSPSupport ()) then ( if (((Rd = (BitsN.B(0xF,4))) orelse (Rn = (BitsN.B(0xF,4)))) orelse (Rm = (BitsN.B(0xF,4)))) orelse @@ -8718,7 +8716,7 @@ fun DecodeARM w = val Ra = BitsN.fromBitstring([Ra'3,Ra'2,Ra'1,Ra'0],4) val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) in - if Take(cond,HaveDSPSupport ()) + if Do(cond,HaveDSPSupport ()) then ( if (((Rd = (BitsN.B(0xF,4))) orelse (Rn = (BitsN.B(0xF,4)))) orelse (Rm = (BitsN.B(0xF,4)))) orelse @@ -8766,7 +8764,7 @@ fun DecodeARM w = val Rm = BitsN.fromBitstring([Rm'3,Rm'2,Rm'1,Rm'0],4) val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) in - if Take(cond,HaveDSPSupport ()) + if Do(cond,HaveDSPSupport ()) then ( if ((Rd = (BitsN.B(0xF,4))) orelse (Rn = (BitsN.B(0xF,4)))) orelse (Rm = (BitsN.B(0xF,4))) @@ -8816,7 +8814,7 @@ fun DecodeARM w = val RdHi = BitsN.fromBitstring([RdHi'3,RdHi'2,RdHi'1,RdHi'0],4) in - if Take(cond,HaveDSPSupport ()) + if Do(cond,HaveDSPSupport ()) then ( if (((RdLo = (BitsN.B(0xF,4))) orelse (RdHi = (BitsN.B(0xF,4)))) orelse (Rn = (BitsN.B(0xF,4)))) orelse @@ -8867,7 +8865,7 @@ fun DecodeARM w = val Rm = BitsN.fromBitstring([Rm'3,Rm'2,Rm'1,Rm'0],4) val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) in - if Take(cond,HaveDSPSupport ()) + if Do(cond,HaveDSPSupport ()) then ( if ((Rd = (BitsN.B(0xF,4))) orelse (Rn = (BitsN.B(0xF,4)))) orelse (Rm = (BitsN.B(0xF,4))) @@ -8913,7 +8911,7 @@ fun DecodeARM w = (true, (true, (false,(true,(true,(true,false))))))))))))))))))))))))))) => - if Take(cond,HaveVirtExt ()) + if Do(cond,HaveVirtExt ()) then System ExceptionReturn else Skip () | (false, @@ -8956,7 +8954,7 @@ fun DecodeARM w = val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) val opc = BitsN.fromBitstring([opc'3,opc'2,opc'1,opc'0],4) in - if Take(cond,true) + if Do(cond,true) then let val setflags = (BitsN.fromBitstring([S'0],1)) = @@ -8972,7 +8970,7 @@ fun DecodeARM w = (TestCompareRegister (BitsN.bits(opc,1,0), (Rn,(Rm,(shift_t,shift_n))))) - else if L3.mem + else if Set.mem (opc,[BitsN.B(0xD,4),BitsN.B(0xF,4)]) then Data (ShiftImmediate @@ -9016,7 +9014,7 @@ fun DecodeARM w = val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) val opc = BitsN.fromBitstring([opc'3,opc'2,opc'1,opc'0],4) in - if Take(cond,true) + if Do(cond,true) then ( if ((((Rd = (BitsN.B(0xF,4))) andalso (not((BitsN.bits(opc,3,2)) = (BitsN.B(0x2,2))))) orelse @@ -9078,7 +9076,7 @@ fun DecodeARM w = val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) val A = BitsN.fromBitstring([A'0],1) in - if Take(cond,true) + if Do(cond,true) then ( if ((((Rd = (BitsN.B(0xF,4))) orelse (Rn = (BitsN.B(0xF,4)))) orelse (Rm = (BitsN.B(0xF,4)))) orelse @@ -9132,7 +9130,7 @@ fun DecodeARM w = val RdHi = BitsN.fromBitstring([RdHi'3,RdHi'2,RdHi'1,RdHi'0],4) in - if Take(cond,Nat.>=(ArchVersion (),6)) + if Do(cond,Nat.>=(ArchVersion (),6)) then ( if ((((RdHi = (BitsN.B(0xF,4))) orelse (RdLo = (BitsN.B(0xF,4)))) orelse (Rn = (BitsN.B(0xF,4)))) orelse @@ -9175,7 +9173,7 @@ fun DecodeARM w = val Ra = BitsN.fromBitstring([Ra'3,Ra'2,Ra'1,Ra'0],4) val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) in - if Take(cond,HaveThumb2 ()) + if Do(cond,HaveThumb2 ()) then ( if (((Rd = (BitsN.B(0xF,4))) orelse (Rn = (BitsN.B(0xF,4)))) orelse (Rm = (BitsN.B(0xF,4)))) orelse @@ -9217,7 +9215,7 @@ fun DecodeARM w = val RdHi = BitsN.fromBitstring([RdHi'3,RdHi'2,RdHi'1,RdHi'0],4) in - if Take(cond,true) + if Do(cond,true) then ( if (((((RdLo = (BitsN.B(0xF,4))) orelse (RdHi = (BitsN.B(0xF,4)))) orelse (Rn = (BitsN.B(0xF,4)))) orelse @@ -9274,7 +9272,7 @@ fun DecodeARM w = val Rt = BitsN.fromBitstring([Rt'3,Rt'2,Rt'1,Rt'0],4) val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) in - if Take(cond,true) + if Do(cond,true) then ( if ((((Rt = (BitsN.B(0xF,4))) orelse (Rt2 = (BitsN.B(0xF,4)))) orelse (Rn = (BitsN.B(0xF,4)))) orelse (Rn = Rt)) orelse @@ -9319,7 +9317,7 @@ fun DecodeARM w = val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) in - if Take(cond,Nat.>=(ArchVersion (),6)) + if Do(cond,Nat.>=(ArchVersion (),6)) then ( if ((((Rd = (BitsN.B(0xF,4))) orelse (Rt = (BitsN.B(0xF,4)))) orelse (Rn = (BitsN.B(0xF,4)))) orelse (Rd = Rn)) orelse @@ -9352,7 +9350,7 @@ fun DecodeARM w = val Rt = BitsN.fromBitstring([Rt'3,Rt'2,Rt'1,Rt'0],4) val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) in - if Take(cond,Nat.>=(ArchVersion (),6)) + if Do(cond,Nat.>=(ArchVersion (),6)) then ( if (Rt = (BitsN.B(0xF,4))) orelse (Rn = (BitsN.B(0xF,4))) then DECODE_UNPREDICTABLE(mc,"LoadExclusive") @@ -9389,8 +9387,8 @@ fun DecodeARM w = val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) in - if Take - (cond,L3.mem((!Architecture),[ARMv6K,ARMv7_A,ARMv7_R])) + if Do(cond, + Set.mem((!Architecture),[ARMv6K,ARMv7_A,ARMv7_R])) then let val Rt2 = BitsN.+(Rt,BitsN.B(0x1,4)) in @@ -9429,8 +9427,8 @@ fun DecodeARM w = val Rt = BitsN.fromBitstring([Rt'3,Rt'2,Rt'1,Rt'0],4) val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) in - if Take - (cond,L3.mem((!Architecture),[ARMv6K,ARMv7_A,ARMv7_R])) + if Do(cond, + Set.mem((!Architecture),[ARMv6K,ARMv7_A,ARMv7_R])) then let val Rt2 = BitsN.+(Rt,BitsN.B(0x1,4)) in @@ -9473,8 +9471,8 @@ fun DecodeARM w = val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) in - if Take - (cond,L3.mem((!Architecture),[ARMv6K,ARMv7_A,ARMv7_R])) + if Do(cond, + Set.mem((!Architecture),[ARMv6K,ARMv7_A,ARMv7_R])) then ( if ((((Rd = (BitsN.B(0xF,4))) orelse (Rt = (BitsN.B(0xF,4)))) orelse (Rn = (BitsN.B(0xF,4)))) orelse (Rd = Rn)) orelse @@ -9507,8 +9505,8 @@ fun DecodeARM w = val Rt = BitsN.fromBitstring([Rt'3,Rt'2,Rt'1,Rt'0],4) val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) in - if Take - (cond,L3.mem((!Architecture),[ARMv6K,ARMv7_A,ARMv7_R])) + if Do(cond, + Set.mem((!Architecture),[ARMv6K,ARMv7_A,ARMv7_R])) then ( if (Rt = (BitsN.B(0xF,4))) orelse (Rn = (BitsN.B(0xF,4))) then DECODE_UNPREDICTABLE @@ -9546,8 +9544,8 @@ fun DecodeARM w = val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) in - if Take - (cond,L3.mem((!Architecture),[ARMv6K,ARMv7_A,ARMv7_R])) + if Do(cond, + Set.mem((!Architecture),[ARMv6K,ARMv7_A,ARMv7_R])) then ( if ((((Rd = (BitsN.B(0xF,4))) orelse (Rt = (BitsN.B(0xF,4)))) orelse (Rn = (BitsN.B(0xF,4)))) orelse (Rd = Rn)) orelse @@ -9580,8 +9578,8 @@ fun DecodeARM w = val Rt = BitsN.fromBitstring([Rt'3,Rt'2,Rt'1,Rt'0],4) val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) in - if Take - (cond,L3.mem((!Architecture),[ARMv6K,ARMv7_A,ARMv7_R])) + if Do(cond, + Set.mem((!Architecture),[ARMv6K,ARMv7_A,ARMv7_R])) then ( if (Rt = (BitsN.B(0xF,4))) orelse (Rn = (BitsN.B(0xF,4))) then DECODE_UNPREDICTABLE @@ -9619,7 +9617,7 @@ fun DecodeARM w = val Rt = BitsN.fromBitstring([Rt'3,Rt'2,Rt'1,Rt'0],4) val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) in - if Take(cond,HaveThumb2 ()) + if Do(cond,HaveThumb2 ()) then ( if (((Rt = (BitsN.B(0xF,4))) orelse (Rn = (BitsN.B(0xF,4)))) orelse (Rn = Rt)) orelse (Rm = (BitsN.B(0xF,4))) @@ -9669,7 +9667,7 @@ fun DecodeARM w = val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) val P = BitsN.fromBitstring([P'0],1) in - if Take(cond,true) + if Do(cond,true) then let val wback = (P = (BitsN.B(0x0,1))) orelse @@ -9729,8 +9727,7 @@ fun DecodeARM w = val Rt = BitsN.fromBitstring([Rt'3,Rt'2,Rt'1,Rt'0],4) val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) in - if Take - (cond, + if Do(cond, ((not(H = (BitsN.B(0x0,1)))) orelse (S = (BitsN.B(0x1,1)))) andalso (HaveThumb2 ())) then ( if (((Rt = (BitsN.B(0xF,4))) orelse @@ -9790,8 +9787,7 @@ fun DecodeARM w = val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) val P = BitsN.fromBitstring([P'0],1) in - if Take - (cond, + if Do(cond, (not(H = (BitsN.B(0x0,1)))) orelse (S = (BitsN.B(0x1,1)))) then let @@ -9859,7 +9855,7 @@ fun DecodeARM w = val W = BitsN.fromBitstring([W'0],1) val P = BitsN.fromBitstring([P'0],1) in - if Take(cond,HaveDSPSupport ()) + if Do(cond,HaveDSPSupport ()) then let val Rt2 = BitsN.+(Rt,BitsN.B(0x1,4)) val wback = @@ -9930,7 +9926,7 @@ fun DecodeARM w = let val Rt = BitsN.fromBitstring([Rt'3,Rt'2,Rt'1,Rt'0],4) in - if Take(cond,HaveDSPSupport ()) + if Do(cond,HaveDSPSupport ()) then let val Rt2 = BitsN.+(Rt,BitsN.B(0x1,4)) in @@ -9989,7 +9985,7 @@ fun DecodeARM w = val W = BitsN.fromBitstring([W'0],1) val P = BitsN.fromBitstring([P'0],1) in - if Take(cond,HaveDSPSupport ()) + if Do(cond,HaveDSPSupport ()) then let val Rt2 = BitsN.+(Rt,BitsN.B(0x1,4)) val wback = @@ -10066,8 +10062,7 @@ fun DecodeARM w = val Rt = BitsN.fromBitstring([Rt'3,Rt'2,Rt'1,Rt'0],4) val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) in - if Take - (cond, + if Do(cond, ((not(H = (BitsN.B(0x0,1)))) orelse (S = (BitsN.B(0x1,1)))) andalso (HaveThumb2 ())) then ( if ((Rt = (BitsN.B(0xF,4))) orelse @@ -10132,8 +10127,7 @@ fun DecodeARM w = val S = BitsN.fromBitstring([S'0],1) val Rt = BitsN.fromBitstring([Rt'3,Rt'2,Rt'1,Rt'0],4) in - if Take - (cond, + if Do(cond, (not(H = (BitsN.B(0x0,1)))) orelse (S = (BitsN.B(0x1,1)))) then ( if Rt = (BitsN.B(0xF,4)) @@ -10196,8 +10190,7 @@ fun DecodeARM w = val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) val P = BitsN.fromBitstring([P'0],1) in - if Take - (cond, + if Do(cond, (not(H = (BitsN.B(0x0,1)))) orelse (S = (BitsN.B(0x1,1)))) then let @@ -10270,7 +10263,7 @@ fun DecodeARM w = val Rt = BitsN.fromBitstring([Rt'3,Rt'2,Rt'1,Rt'0],4) val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) in - if Take(cond,HaveThumb2 ()) + if Do(cond,HaveThumb2 ()) then ( if ((Rt = (BitsN.B(0xF,4))) orelse (Rn = (BitsN.B(0xF,4)))) orelse (Rn = Rt) then DECODE_UNPREDICTABLE @@ -10327,7 +10320,7 @@ fun DecodeARM w = val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) val P = BitsN.fromBitstring([P'0],1) in - if Take(cond,true) + if Do(cond,true) then let val wback = (P = (BitsN.B(0x0,1))) orelse @@ -10389,7 +10382,7 @@ fun DecodeARM w = let val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) in - if Take(cond,HaveThumb2 ()) + if Do(cond,HaveThumb2 ()) then ( if Rd = (BitsN.B(0xF,4)) then DECODE_UNPREDICTABLE(mc,"MoveTopHalfword") else () @@ -10467,7 +10460,7 @@ fun DecodeARM w = val mask = BitsN.fromBitstring([mask'3,mask'2,mask'1,mask'0],4) in - if Take(cond,true) + if Do(cond,true) then ( if mask = (BitsN.B(0x0,4)) then DECODE_UNPREDICTABLE (mc,"MoveToSpecialFromImmediate") @@ -10524,7 +10517,7 @@ fun DecodeARM w = val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) val opc = BitsN.fromBitstring([opc'3,opc'2,opc'1,opc'0],4) in - if Take(cond,true) + if Do(cond,true) then let val setflags = (BitsN.fromBitstring([S'0],1)) = @@ -10580,7 +10573,7 @@ fun DecodeARM w = val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) val B = BitsN.fromBitstring([B'0],1) in - if Take(cond,true) + if Do(cond,true) then ( if (((B = (BitsN.B(0x1,1))) andalso (Rt = (BitsN.B(0xF,4)))) orelse (Rn = (BitsN.B(0xF,4)))) orelse (Rn = Rt) @@ -10642,7 +10635,7 @@ fun DecodeARM w = val B = BitsN.fromBitstring([B'0],1) val P = BitsN.fromBitstring([P'0],1) in - if Take(cond,true) + if Do(cond,true) then let val wback = (P = (BitsN.B(0x0,1))) orelse @@ -10710,7 +10703,7 @@ fun DecodeARM w = val Rt = BitsN.fromBitstring([Rt'3,Rt'2,Rt'1,Rt'0],4) val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) in - if Take(cond,true) + if Do(cond,true) then ( if ((Rt = (BitsN.B(0xF,4))) orelse (Rn = (BitsN.B(0xF,4)))) orelse (Rn = Rt) then DECODE_UNPREDICTABLE @@ -10770,7 +10763,7 @@ fun DecodeARM w = val Rt = BitsN.fromBitstring([Rt'3,Rt'2,Rt'1,Rt'0],4) val B = BitsN.fromBitstring([B'0],1) in - if Take(cond,true) + if Do(cond,true) then ( if (B = (BitsN.B(0x1,1))) andalso (Rt = (BitsN.B(0xF,4))) then DECODE_UNPREDICTABLE @@ -10826,7 +10819,7 @@ fun DecodeARM w = val B = BitsN.fromBitstring([B'0],1) val P = BitsN.fromBitstring([P'0],1) in - if Take(cond,true) + if Do(cond,true) then let val wback = (P = (BitsN.B(0x0,1))) orelse @@ -10894,7 +10887,7 @@ fun DecodeARM w = val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) val B = BitsN.fromBitstring([B'0],1) in - if Take(cond,true) + if Do(cond,true) then ( if (((((B = (BitsN.B(0x1,1))) andalso (Rt = (BitsN.B(0xF,4)))) orelse (Rn = (BitsN.B(0xF,4)))) orelse (Rn = Rt)) orelse @@ -10956,7 +10949,7 @@ fun DecodeARM w = val B = BitsN.fromBitstring([B'0],1) val P = BitsN.fromBitstring([P'0],1) in - if Take(cond,true) + if Do(cond,true) then let val wback = (P = (BitsN.B(0x0,1))) orelse @@ -11025,7 +11018,7 @@ fun DecodeARM w = val Rt = BitsN.fromBitstring([Rt'3,Rt'2,Rt'1,Rt'0],4) val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) in - if Take(cond,true) + if Do(cond,true) then ( if ((((Rt = (BitsN.B(0xF,4))) orelse (Rn = (BitsN.B(0xF,4)))) orelse (Rn = Rt)) orelse (Rm = (BitsN.B(0xF,4)))) orelse @@ -11087,7 +11080,7 @@ fun DecodeARM w = val B = BitsN.fromBitstring([B'0],1) val P = BitsN.fromBitstring([P'0],1) in - if Take(cond,true) + if Do(cond,true) then let val wback = (P = (BitsN.B(0x0,1))) orelse @@ -11157,7 +11150,7 @@ fun DecodeARM w = val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) in - if Take(cond,Nat.>=(ArchVersion (),6)) + if Do(cond,Nat.>=(ArchVersion (),6)) then ( if ((Rd = (BitsN.B(0xF,4))) orelse (Rn = (BitsN.B(0xF,4)))) orelse (Rm = (BitsN.B(0xF,4))) @@ -11200,7 +11193,7 @@ fun DecodeARM w = val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) in - if Take(cond,Nat.>=(ArchVersion (),6)) + if Do(cond,Nat.>=(ArchVersion (),6)) then ( if ((Rd = (BitsN.B(0xF,4))) orelse (Rn = (BitsN.B(0xF,4)))) orelse (Rm = (BitsN.B(0xF,4))) @@ -11249,7 +11242,7 @@ fun DecodeARM w = val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) in - if Take(cond,Nat.>=(ArchVersion (),6)) + if Do(cond,Nat.>=(ArchVersion (),6)) then ( if ((Rd = (BitsN.B(0xF,4))) orelse (Rn = (BitsN.B(0xF,4)))) orelse (Rm = (BitsN.B(0xF,4))) @@ -11289,7 +11282,7 @@ fun DecodeARM w = BitsN.fromBitstring ([sat_imm'4,sat_imm'3,sat_imm'2,sat_imm'1,sat_imm'0],5) in - if Take(cond,Nat.>=(ArchVersion (),6)) + if Do(cond,Nat.>=(ArchVersion (),6)) then ( if (Rd = (BitsN.B(0xF,4))) orelse (Rn = (BitsN.B(0xF,4))) then DECODE_UNPREDICTABLE(mc,"Saturate") @@ -11348,7 +11341,7 @@ fun DecodeARM w = BitsN.fromBitstring ([sat_imm'3,sat_imm'2,sat_imm'1,sat_imm'0],4) in - if Take(cond,Nat.>=(ArchVersion (),6)) + if Do(cond,Nat.>=(ArchVersion (),6)) then ( if (Rd = (BitsN.B(0xF,4))) orelse (Rn = (BitsN.B(0xF,4))) then DECODE_UNPREDICTABLE(mc,"Saturate16") @@ -11395,7 +11388,7 @@ fun DecodeARM w = val Rm = BitsN.fromBitstring([Rm'3,Rm'2,Rm'1,Rm'0],4) val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) in - if Take(cond,Nat.>=(ArchVersion (),6)) + if Do(cond,Nat.>=(ArchVersion (),6)) then ( if (Rd = (BitsN.B(0xF,4))) orelse (Rm = (BitsN.B(0xF,4))) then DECODE_UNPREDICTABLE(mc,"ExtendByte16") @@ -11448,7 +11441,7 @@ fun DecodeARM w = val Rm = BitsN.fromBitstring([Rm'3,Rm'2,Rm'1,Rm'0],4) val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) in - if Take(cond,Nat.>=(ArchVersion (),6)) + if Do(cond,Nat.>=(ArchVersion (),6)) then ( if (Rd = (BitsN.B(0xF,4))) orelse (Rm = (BitsN.B(0xF,4))) then DECODE_UNPREDICTABLE(mc,"ExtendByte") @@ -11501,7 +11494,7 @@ fun DecodeARM w = val Rm = BitsN.fromBitstring([Rm'3,Rm'2,Rm'1,Rm'0],4) val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) in - if Take(cond,Nat.>=(ArchVersion (),6)) + if Do(cond,Nat.>=(ArchVersion (),6)) then ( if (Rd = (BitsN.B(0xF,4))) orelse (Rm = (BitsN.B(0xF,4))) then DECODE_UNPREDICTABLE(mc,"ExtendHalfword") @@ -11554,7 +11547,7 @@ fun DecodeARM w = val Rm = BitsN.fromBitstring([Rm'3,Rm'2,Rm'1,Rm'0],4) val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) in - if Take(cond,Nat.>=(ArchVersion (),6)) + if Do(cond,Nat.>=(ArchVersion (),6)) then ( if (Rd = (BitsN.B(0xF,4))) orelse (Rm = (BitsN.B(0xF,4))) then DECODE_UNPREDICTABLE(mc,"ByteReverse") @@ -11590,7 +11583,7 @@ fun DecodeARM w = val Rm = BitsN.fromBitstring([Rm'3,Rm'2,Rm'1,Rm'0],4) val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) in - if Take(cond,Nat.>=(ArchVersion (),6)) + if Do(cond,Nat.>=(ArchVersion (),6)) then ( if (Rd = (BitsN.B(0xF,4))) orelse (Rm = (BitsN.B(0xF,4))) then DECODE_UNPREDICTABLE @@ -11627,7 +11620,7 @@ fun DecodeARM w = val Rm = BitsN.fromBitstring([Rm'3,Rm'2,Rm'1,Rm'0],4) val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) in - if Take(cond,Nat.>=(ArchVersion (),6)) + if Do(cond,Nat.>=(ArchVersion (),6)) then ( if (Rd = (BitsN.B(0xF,4))) orelse (Rm = (BitsN.B(0xF,4))) then DECODE_UNPREDICTABLE @@ -11664,7 +11657,7 @@ fun DecodeARM w = val Rm = BitsN.fromBitstring([Rm'3,Rm'2,Rm'1,Rm'0],4) val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) in - if Take(cond,Nat.>=(ArchVersion (),6)) + if Do(cond,Nat.>=(ArchVersion (),6)) then ( if (Rd = (BitsN.B(0xF,4))) orelse (Rm = (BitsN.B(0xF,4))) then DECODE_UNPREDICTABLE(mc,"ReverseBits") @@ -11701,7 +11694,7 @@ fun DecodeARM w = val Rm = BitsN.fromBitstring([Rm'3,Rm'2,Rm'1,Rm'0],4) val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) in - if Take(cond,Nat.>=(ArchVersion (),6)) + if Do(cond,Nat.>=(ArchVersion (),6)) then ( if ((Rd = (BitsN.B(0xF,4))) orelse (Rn = (BitsN.B(0xF,4)))) orelse (Rm = (BitsN.B(0xF,4))) @@ -11760,7 +11753,7 @@ fun DecodeARM w = val RdHi = BitsN.fromBitstring([RdHi'3,RdHi'2,RdHi'1,RdHi'0],4) in - if Take(cond,Nat.>=(ArchVersion (),6)) + if Do(cond,Nat.>=(ArchVersion (),6)) then ( if (((RdLo = (BitsN.B(0xF,4))) orelse (RdHi = (BitsN.B(0xF,4)))) orelse (Rn = (BitsN.B(0xF,4)))) orelse @@ -11811,7 +11804,7 @@ fun DecodeARM w = val Rm = BitsN.fromBitstring([Rm'3,Rm'2,Rm'1,Rm'0],4) val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) in - if Take(cond,Nat.>=(ArchVersion (),6)) + if Do(cond,Nat.>=(ArchVersion (),6)) then ( if ((Rd = (BitsN.B(0xF,4))) orelse (Rn = (BitsN.B(0xF,4)))) orelse (Rm = (BitsN.B(0xF,4))) @@ -11864,7 +11857,7 @@ fun DecodeARM w = val Ra = BitsN.fromBitstring([Ra'3,Ra'2,Ra'1,Ra'0],4) val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) in - if Take(cond,Nat.>=(ArchVersion (),6)) + if Do(cond,Nat.>=(ArchVersion (),6)) then ( if (((Rd = (BitsN.B(0xF,4))) orelse (Rn = (BitsN.B(0xF,4)))) orelse (Rm = (BitsN.B(0xF,4)))) orelse @@ -11913,7 +11906,7 @@ fun DecodeARM w = val Rm = BitsN.fromBitstring([Rm'3,Rm'2,Rm'1,Rm'0],4) val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) in - if Take(cond,Nat.>=(ArchVersion (),6)) + if Do(cond,Nat.>=(ArchVersion (),6)) then ( if ((Rd = (BitsN.B(0xF,4))) orelse (Rn = (BitsN.B(0xF,4)))) orelse (Rm = (BitsN.B(0xF,4))) @@ -11957,7 +11950,7 @@ fun DecodeARM w = val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) in - if Take(cond,Nat.>=(ArchVersion (),6)) + if Do(cond,Nat.>=(ArchVersion (),6)) then let val lsbit = BitsN.toNat @@ -12014,7 +12007,7 @@ fun DecodeARM w = let val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) in - if Take(cond,Nat.>=(ArchVersion (),6)) + if Do(cond,Nat.>=(ArchVersion (),6)) then let val lsbit = BitsN.toNat @@ -12076,7 +12069,7 @@ fun DecodeARM w = val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) val U = BitsN.fromBitstring([U'0],1) in - if Take(cond,true) + if Do(cond,true) then ( if (Rn = (BitsN.B(0xF,4))) orelse (Nat.<(BitCount 16 registers,1)) then DECODE_UNPREDICTABLE @@ -12130,7 +12123,7 @@ fun DecodeARM w = registers'3,registers'2,registers'1,registers'0],16) val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) in - if Take(cond,true) + if Do(cond,true) then ( if (Rn = (BitsN.B(0xF,4))) orelse (Nat.<(BitCount 16 registers,1)) then DECODE_UNPREDICTABLE(mc,"StoreMultiple") @@ -12190,7 +12183,7 @@ fun DecodeARM w = val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) val U = BitsN.fromBitstring([U'0],1) in - if Take(cond,true) + if Do(cond,true) then ( if (Rn = (BitsN.B(0xF,4))) orelse (Nat.<(BitCount 15 registers,1)) then DECODE_UNPREDICTABLE @@ -12245,7 +12238,7 @@ fun DecodeARM w = val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) val U = BitsN.fromBitstring([U'0],1) in - if Take(cond,true) + if Do(cond,true) then let val wback = (BitsN.fromBitstring([W'0],1)) = @@ -12308,7 +12301,7 @@ fun DecodeARM w = registers'3,registers'2,registers'1,registers'0],16) val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) in - if Take(cond,true) + if Do(cond,true) then let val wback = (BitsN.fromBitstring([W'0],1)) = @@ -12362,7 +12355,7 @@ fun DecodeARM w = (imm24'5, (imm24'4, (imm24'3,(imm24'2,(imm24'1,imm24'0))))))))))))))))))))))))))) => - (if Take(cond,true) + (if Do(cond,true) then let val imm32 = BitsN.signExtend 32 @@ -12404,7 +12397,7 @@ fun DecodeARM w = (imm24'5, (imm24'4, (imm24'3,(imm24'2,(imm24'1,imm24'0))))))))))))))))))))))))))) => - (if Take(cond,true) + (if Do(cond,true) then let val imm32 = BitsN.signExtend 32 @@ -12449,7 +12442,7 @@ fun DecodeARM w = (imm24'5, (imm24'4, (imm24'3,(imm24'2,(imm24'1,imm24'0))))))))))))))))))))))))))) => - (if Take(cond,true) + (if Do(cond,true) then let val imm32 = BitsN.signExtend 32 @@ -12473,7 +12466,7 @@ fun DecodeARM w = (_, (_, (_,(_,(_,(_,(_,(_,(_,(_,(true,(false,(true,_))))))))))))))))))) => - (if Take(cond,L3.mem(Extension_VFP,(!Extensions))) + (if Do(cond,Set.mem(Extension_VFP,(!Extensions))) then VFP(DecodeVFP w) else Skip ()) | _ => UndefinedARM cond @@ -12492,7 +12485,7 @@ fun DecodeThumb h = (false, (S'0, (Rm'2,(Rm'1,(Rm'0,(Rn'2,(Rn'1,(Rn'0,(Rd'2,(Rd'1,Rd'0))))))))))))))) => - (if Take(ThumbCondition (),true) + (if Do(ThumbCondition (),true) then let val d = BitsN.fromNat @@ -12527,7 +12520,7 @@ fun DecodeThumb h = (S'0, (imm3'2, (imm3'1,(imm3'0,(Rn'2,(Rn'1,(Rn'0,(Rd'2,(Rd'1,Rd'0))))))))))))))) => - (if Take(ThumbCondition (),true) + (if Do(ThumbCondition (),true) then let val d = BitsN.fromNat @@ -12558,7 +12551,7 @@ fun DecodeThumb h = (imm5'3, (imm5'2, (imm5'1,(imm5'0,(Rm'2,(Rm'1,(Rm'0,(Rd'2,(Rd'1,Rd'0))))))))))))))) => - (if Take(ThumbCondition (),true) + (if Do(ThumbCondition (),true) then let val d = BitsN.fromNat @@ -12591,7 +12584,7 @@ fun DecodeThumb h = (imm8'7, (imm8'6, (imm8'5,(imm8'4,(imm8'3,(imm8'2,(imm8'1,imm8'0))))))))))))))) => - (if Take(ThumbCondition (),true) + (if Do(ThumbCondition (),true) then let val d = BitsN.fromNat @@ -12619,7 +12612,7 @@ fun DecodeThumb h = (imm8'7, (imm8'6, (imm8'5,(imm8'4,(imm8'3,(imm8'2,(imm8'1,imm8'0))))))))))))))) => - (if Take(ThumbCondition (),true) + (if Do(ThumbCondition (),true) then let val n = BitsN.fromNat @@ -12645,7 +12638,7 @@ fun DecodeThumb h = (imm8'7, (imm8'6, (imm8'5,(imm8'4,(imm8'3,(imm8'2,(imm8'1,imm8'0))))))))))))))) => - (if Take(ThumbCondition (),true) + (if Do(ThumbCondition (),true) then let val d = BitsN.fromNat @@ -12680,7 +12673,7 @@ fun DecodeThumb h = val Rx = BitsN.fromBitstring([Rx'2,Rx'1,Rx'0],3) val opc = BitsN.fromBitstring([opc'3,opc'2,opc'1,opc'0],4) in - if Take(ThumbCondition (),true) + if Do(ThumbCondition (),true) then case opc of BitsN.B(0x0,4) => let @@ -12909,8 +12902,7 @@ fun DecodeThumb h = val Rm = BitsN.fromBitstring([Rm'3,Rm'2,Rm'1,Rm'0],4) val DN = BitsN.fromBitstring([DN'0],1) in - if Take - (ThumbCondition (), + if Do(ThumbCondition (), ((BitsN.msb Rm) orelse (DN = (BitsN.B(0x1,1)))) orelse (HaveThumb2 ())) then let @@ -12953,7 +12945,7 @@ fun DecodeThumb h = let val Rm = BitsN.fromBitstring([Rm'3,Rm'2,Rm'1,Rm'0],4) in - if Take(ThumbCondition (),true) + if Do(ThumbCondition (),true) then let val n = BitsN.@@ @@ -12985,8 +12977,7 @@ fun DecodeThumb h = val Rm = BitsN.fromBitstring([Rm'3,Rm'2,Rm'1,Rm'0],4) val D = BitsN.fromBitstring([D'0],1) in - if Take - (ThumbCondition (), + if Do(ThumbCondition (), ((BitsN.msb Rm) orelse (D = (BitsN.B(0x1,1)))) orelse (Nat.>=(ArchVersion (),6))) then let @@ -13015,7 +13006,7 @@ fun DecodeThumb h = (false, (false, (true,(true,(true,(false,(Rm'3,(Rm'2,(Rm'1,(Rm'0,_))))))))))))) => - (if Take(ThumbCondition (),true) + (if Do(ThumbCondition (),true) then ( if (InITBlock ()) andalso (not(LastInITBlock ())) then DECODE_UNPREDICTABLE(mc,"BranchExchange") else () @@ -13033,7 +13024,7 @@ fun DecodeThumb h = let val Rm = BitsN.fromBitstring([Rm'3,Rm'2,Rm'1,Rm'0],4) in - if Take(ThumbCondition (),Nat.>=(ArchVersion (),5)) + if Do(ThumbCondition (),Nat.>=(ArchVersion (),5)) then ( if (Rm = (BitsN.B(0xF,4))) orelse ((InITBlock ()) andalso (not(LastInITBlock ()))) then DECODE_UNPREDICTABLE @@ -13054,7 +13045,7 @@ fun DecodeThumb h = (imm8'7, (imm8'6, (imm8'5,(imm8'4,(imm8'3,(imm8'2,(imm8'1,imm8'0))))))))))))))) => - (if Take(ThumbCondition (),true) + (if Do(ThumbCondition (),true) then let val add = true val imm32 = @@ -13085,7 +13076,7 @@ fun DecodeThumb h = val Rt = BitsN.fromBitstring([Rt'2,Rt'1,Rt'0],3) val Rn = BitsN.fromBitstring([Rn'2,Rn'1,Rn'0],3) in - if Take(ThumbCondition (),true) + if Do(ThumbCondition (),true) then let val index = true val add = true @@ -13184,7 +13175,7 @@ fun DecodeThumb h = val Rt = BitsN.fromBitstring([Rt'2,Rt'1,Rt'0],3) val Rn = BitsN.fromBitstring([Rn'2,Rn'1,Rn'0],3) in - if Take(ThumbCondition (),true) + if Do(ThumbCondition (),true) then let val index = true val add = true @@ -13228,7 +13219,7 @@ fun DecodeThumb h = val Rt = BitsN.fromBitstring([Rt'2,Rt'1,Rt'0],3) val Rn = BitsN.fromBitstring([Rn'2,Rn'1,Rn'0],3) in - if Take(ThumbCondition (),true) + if Do(ThumbCondition (),true) then let val index = true val add = true @@ -13271,7 +13262,7 @@ fun DecodeThumb h = val Rt = BitsN.fromBitstring([Rt'2,Rt'1,Rt'0],3) val Rn = BitsN.fromBitstring([Rn'2,Rn'1,Rn'0],3) in - if Take(ThumbCondition (),true) + if Do(ThumbCondition (),true) then let val index = true val add = true @@ -13317,7 +13308,7 @@ fun DecodeThumb h = let val Rt = BitsN.fromBitstring([Rt'2,Rt'1,Rt'0],3) in - if Take(ThumbCondition (),true) + if Do(ThumbCondition (),true) then let val index = true val add = true @@ -13359,7 +13350,7 @@ fun DecodeThumb h = (imm8'7, (imm8'6, (imm8'5,(imm8'4,(imm8'3,(imm8'2,(imm8'1,imm8'0))))))))))))))) => - (if Take(ThumbCondition (),true) + (if Do(ThumbCondition (),true) then let val imm12 = BitsN.@@ @@ -13393,7 +13384,7 @@ fun DecodeThumb h = (S'0, (imm7'6, (imm7'5,(imm7'4,(imm7'3,(imm7'2,(imm7'1,imm7'0))))))))))))))) => - (if Take(ThumbCondition (),true) + (if Do(ThumbCondition (),true) then let val imm12 = BitsN.@@ @@ -13422,7 +13413,7 @@ fun DecodeThumb h = (true, (imm5'4, (imm5'3,(imm5'2,(imm5'1,(imm5'0,(Rn'2,(Rn'1,Rn'0))))))))))))))) => - (if Take(BitsN.B(0xE,4),HaveThumb2 ()) + (if Do(BitsN.B(0xE,4),HaveThumb2 ()) then ( if InITBlock () then DECODE_UNPREDICTABLE(mc,"CompareBranch") else () @@ -13455,7 +13446,7 @@ fun DecodeThumb h = (false, (true, (false,(U'0,(false,(Rm'2,(Rm'1,(Rm'0,(Rd'2,(Rd'1,Rd'0))))))))))))))) => - (if Take(ThumbCondition (),Nat.>=(ArchVersion (),6)) + (if Do(ThumbCondition (),Nat.>=(ArchVersion (),6)) then let val unsigned = (BitsN.fromBitstring([U'0],1)) = (BitsN.B(0x1,1)) @@ -13481,7 +13472,7 @@ fun DecodeThumb h = (false, (true, (false,(U'0,(true,(Rm'2,(Rm'1,(Rm'0,(Rd'2,(Rd'1,Rd'0))))))))))))))) => - (if Take(ThumbCondition (),Nat.>=(ArchVersion (),6)) + (if Do(ThumbCondition (),Nat.>=(ArchVersion (),6)) then let val unsigned = (BitsN.fromBitstring([U'0],1)) = (BitsN.B(0x1,1)) @@ -13513,7 +13504,7 @@ fun DecodeThumb h = (register_list'4, (register_list'3, (register_list'2,(register_list'1,register_list'0))))))))))))))) => - (if Take(ThumbCondition (),true) + (if Do(ThumbCondition (),true) then let val registers = BitsN.concat @@ -13546,7 +13537,7 @@ fun DecodeThumb h = (true, (true, (false,(true,(true,(false,(false,(true,(false,(_,(E'0,_))))))))))))) => - (if Take(BitsN.B(0xE,4),Nat.>=(ArchVersion (),6)) + (if Do(BitsN.B(0xE,4),Nat.>=(ArchVersion (),6)) then ( if InITBlock () then DECODE_UNPREDICTABLE(mc,"Setend") else () @@ -13571,7 +13562,7 @@ fun DecodeThumb h = val I = BitsN.fromBitstring([I'0],1) val A = BitsN.fromBitstring([A'0],1) in - if Take(BitsN.B(0xE,4),Nat.>=(ArchVersion (),6)) + if Do(BitsN.B(0xE,4),Nat.>=(ArchVersion (),6)) then ( if ((BitsN.concat[A,I,F]) = (BitsN.B(0x0,3))) orelse (InITBlock ()) then DECODE_UNPREDICTABLE(mc,"ChangeProcessorState") @@ -13604,7 +13595,7 @@ fun DecodeThumb h = val Rd = BitsN.fromBitstring([Rd'2,Rd'1,Rd'0],3) val Rm = BitsN.fromBitstring([Rm'2,Rm'1,Rm'0],3) in - if Take(ThumbCondition (),Nat.>=(ArchVersion (),6)) + if Do(ThumbCondition (),Nat.>=(ArchVersion (),6)) then case BitsN.fromBitstring([opc'1,opc'0],2) of BitsN.B(0x0,2) => Media @@ -13638,7 +13629,7 @@ fun DecodeThumb h = (register_list'4, (register_list'3, (register_list'2,(register_list'1,register_list'0))))))))))))))) => - (if Take(ThumbCondition (),true) + (if Do(ThumbCondition (),true) then let val registers = BitsN.concat @@ -13678,7 +13669,7 @@ fun DecodeThumb h = (imm8'7, (imm8'6, (imm8'5,(imm8'4,(imm8'3,(imm8'2,(imm8'1,imm8'0))))))))))))))) => - (if Take(BitsN.B(0xE,4),Nat.>=(ArchVersion (),5)) + (if Do(BitsN.B(0xE,4),Nat.>=(ArchVersion (),5)) then let val imm32 = BitsN.zeroExtend 32 @@ -13720,7 +13711,7 @@ fun DecodeThumb h = BitsN.fromBitstring ([firstcond'3,firstcond'2,firstcond'1,firstcond'0],4) in - if Take(BitsN.B(0xE,4),HaveThumb2 ()) + if Do(BitsN.B(0xE,4),HaveThumb2 ()) then ( if ((firstcond = (BitsN.B(0xF,4))) orelse ((firstcond = (BitsN.B(0xE,4))) andalso (not((BitCount 4 mask) = 1)))) orelse @@ -13745,7 +13736,7 @@ fun DecodeThumb h = (register_list'4, (register_list'3, (register_list'2,(register_list'1,register_list'0))))))))))))))) => - (if Take(ThumbCondition (),true) + (if Do(ThumbCondition (),true) then let val registers = BitsN.fromNat @@ -13794,7 +13785,7 @@ fun DecodeThumb h = let val Rn = BitsN.fromBitstring([Rn'2,Rn'1,Rn'0],3) in - if Take(ThumbCondition (),true) + if Do(ThumbCondition (),true) then let val registers = BitsN.fromNat @@ -13836,7 +13827,7 @@ fun DecodeThumb h = (imm8'7, (imm8'6, (imm8'5,(imm8'4,(imm8'3,(imm8'2,(imm8'1,imm8'0))))))))))))))) => - (if Take(ThumbCondition (),true) + (if Do(ThumbCondition (),true) then let val imm32 = BitsN.zeroExtend 32 @@ -13858,7 +13849,7 @@ fun DecodeThumb h = (imm8'7, (imm8'6, (imm8'5,(imm8'4,(imm8'3,(imm8'2,(imm8'1,imm8'0))))))))))))))) => - (if Take(ThumbCondition (),true) + (if Do(ThumbCondition (),true) then System (SupervisorCall (BitsN.zeroExtend 32 @@ -13877,8 +13868,7 @@ fun DecodeThumb h = (imm8'7, (imm8'6, (imm8'5,(imm8'4,(imm8'3,(imm8'2,(imm8'1,imm8'0))))))))))))))) => - (if Take - (BitsN.fromBitstring([cond'3,cond'2,cond'1,cond'0],4),true) + (if Do(BitsN.fromBitstring([cond'3,cond'2,cond'1,cond'0],4),true) then ( if InITBlock () then DECODE_UNPREDICTABLE(mc,"BranchTarget") else () @@ -13905,7 +13895,7 @@ fun DecodeThumb h = (imm11'7, (imm11'6, (imm11'5,(imm11'4,(imm11'3,(imm11'2,(imm11'1,imm11'0))))))))))))))) => - (if Take(ThumbCondition (),true) + (if Do(ThumbCondition (),true) then ( if (InITBlock ()) andalso (not(LastInITBlock ())) then DECODE_UNPREDICTABLE(mc,"BranchTarget") else () @@ -13942,7 +13932,7 @@ fun DecodeThumbEE h = val Rt = BitsN.fromBitstring([Rt'2,Rt'1,Rt'0],3) val Rn = BitsN.fromBitstring([Rn'2,Rn'1,Rn'0],3) in - if Take(ThumbCondition (),true) + if Do(ThumbCondition (),true) then let val index = true val add = true @@ -14013,7 +14003,7 @@ fun DecodeThumbEE h = (imm3'1, (imm3'0, (handler'4,(handler'3,(handler'2,(handler'1,handler'0))))))))))))))) => - (if Take(ThumbCondition (),true) + (if Do(ThumbCondition (),true) then ( if (InITBlock ()) andalso (not(LastInITBlock ())) then DECODE_UNPREDICTABLE(mc,"HandlerBranchParameter") else () @@ -14046,7 +14036,7 @@ fun DecodeThumbEE h = (handler'6, (handler'5, (handler'4,(handler'3,(handler'2,(handler'1,handler'0))))))))))))))) => - (if Take(ThumbCondition (),true) + (if Do(ThumbCondition (),true) then ( if (InITBlock ()) andalso (not(LastInITBlock ())) then DECODE_UNPREDICTABLE(mc,"HandlerBranchLink") else () @@ -14078,7 +14068,7 @@ fun DecodeThumbEE h = (imm5'1, (imm5'0, (handler'4,(handler'3,(handler'2,(handler'1,handler'0))))))))))))))) => - (if Take(ThumbCondition (),true) + (if Do(ThumbCondition (),true) then ( if (InITBlock ()) andalso (not(LastInITBlock ())) then DECODE_UNPREDICTABLE (mc,"HandlerBranchLinkParameter") @@ -14109,7 +14099,7 @@ fun DecodeThumbEE h = (false, (imm3'2, (imm3'1,(imm3'0,(Rn'2,(Rn'1,(Rn'0,(Rt'2,(Rt'1,Rt'0))))))))))))))) => - (if Take(ThumbCondition (),true) + (if Do(ThumbCondition (),true) then let val index = true val add = false @@ -14147,7 +14137,7 @@ fun DecodeThumbEE h = let val Rm = BitsN.fromBitstring([Rm'3,Rm'2,Rm'1,Rm'0],4) in - if Take(ThumbCondition (),true) + if Do(ThumbCondition (),true) then let val n = BitsN.@@ @@ -14155,7 +14145,7 @@ fun DecodeThumbEE h = BitsN.fromBitstring([Rn'2,Rn'1,Rn'0],3)) in ( if (n = (BitsN.B(0xF,4))) orelse - (L3.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) + (Set.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) then DECODE_UNPREDICTABLE(mc,"CheckArray") else () ; Branch(CheckArray(Rm,n)) @@ -14173,7 +14163,7 @@ fun DecodeThumbEE h = (true, (imm5'4, (imm5'3,(imm5'2,(imm5'1,(imm5'0,(Rt'2,(Rt'1,Rt'0))))))))))))))) => - (if Take(ThumbCondition (),true) + (if Do(ThumbCondition (),true) then let val index = true val add = true @@ -14210,7 +14200,7 @@ fun DecodeThumbEE h = let val Rt = BitsN.fromBitstring([Rt'2,Rt'1,Rt'0],3) in - if Take(ThumbCondition (),true) + if Do(ThumbCondition (),true) then let val index = true val add = true @@ -14290,7 +14280,7 @@ fun DecodeThumb2 h = let val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) in - if Take(ThumbCondition (),HaveThumb2 ()) + if Do(ThumbCondition (),HaveThumb2 ()) then let val registers = BitsN.concat @@ -14351,7 +14341,7 @@ fun DecodeThumb2 h = let val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) in - if Take(ThumbCondition (),HaveThumb2 ()) + if Do(ThumbCondition (),HaveThumb2 ()) then let val registers = BitsN.concat @@ -14414,7 +14404,7 @@ fun DecodeThumb2 h = val M = BitsN.fromBitstring([M'0],1) val P = BitsN.fromBitstring([P'0],1) in - if Take(ThumbCondition (),HaveThumb2 ()) + if Do(ThumbCondition (),HaveThumb2 ()) then let val registers = BitsN.concat @@ -14480,7 +14470,7 @@ fun DecodeThumb2 h = val M = BitsN.fromBitstring([M'0],1) val P = BitsN.fromBitstring([P'0],1) in - if Take(ThumbCondition (),HaveThumb2 ()) + if Do(ThumbCondition (),HaveThumb2 ()) then let val registers = BitsN.concat @@ -14534,9 +14524,8 @@ fun DecodeThumb2 h = let val op' = BitsN.fromBitstring([op'1,op'0],2) in - if Take - (ThumbCondition (), - (L3.mem(op',[BitsN.B(0x0,2),BitsN.B(0x3,2)])) andalso + if Do(ThumbCondition (), + (Set.mem(op',[BitsN.B(0x0,2),BitsN.B(0x3,2)])) andalso (HaveThumb2 ())) then ( if (CurrentInstrSet ()) = InstrSet_ThumbEE then DECODE_UNPREDICTABLE(mc,"StoreReturnState") @@ -14571,9 +14560,8 @@ fun DecodeThumb2 h = val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) val op' = BitsN.fromBitstring([op'1,op'0],2) in - if Take - (ThumbCondition (), - (L3.mem(op',[BitsN.B(0x0,2),BitsN.B(0x3,2)])) andalso + if Do(ThumbCondition (), + (Set.mem(op',[BitsN.B(0x0,2),BitsN.B(0x3,2)])) andalso (HaveThumb2 ())) then ( if (((CurrentInstrSet ()) = InstrSet_ThumbEE) orelse (Rn = (BitsN.B(0xF,4)))) orelse @@ -14618,9 +14606,9 @@ fun DecodeThumb2 h = val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) val Rt = BitsN.fromBitstring([Rt'3,Rt'2,Rt'1,Rt'0],4) in - if Take(ThumbCondition (),HaveThumb2 ()) - then ( if ((((L3.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse - (L3.mem(Rt,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse + if Do(ThumbCondition (),HaveThumb2 ()) + then ( if ((((Set.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse + (Set.mem(Rt,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse (Rn = (BitsN.B(0xF,4)))) orelse (Rd = Rn)) orelse (Rd = Rt) then DECODE_UNPREDICTABLE(mc,"StoreExclusive") @@ -14662,8 +14650,8 @@ fun DecodeThumb2 h = val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) val Rt = BitsN.fromBitstring([Rt'3,Rt'2,Rt'1,Rt'0],4) in - if Take(ThumbCondition (),HaveThumb2 ()) - then ( if (L3.mem(Rt,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse + if Do(ThumbCondition (),HaveThumb2 ()) + then ( if (Set.mem(Rt,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse (Rn = (BitsN.B(0xF,4))) then DECODE_UNPREDICTABLE(mc,"StoreExclusive") else () @@ -14702,9 +14690,9 @@ fun DecodeThumb2 h = val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) val Rt = BitsN.fromBitstring([Rt'3,Rt'2,Rt'1,Rt'0],4) in - if Take(ThumbCondition (),Nat.>=(ArchVersion (),7)) - then ( if ((((L3.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse - (L3.mem(Rt,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse + if Do(ThumbCondition (),Nat.>=(ArchVersion (),7)) + then ( if ((((Set.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse + (Set.mem(Rt,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse (Rn = (BitsN.B(0xF,4)))) orelse (Rd = Rn)) orelse (Rd = Rt) then DECODE_UNPREDICTABLE @@ -14740,10 +14728,10 @@ fun DecodeThumb2 h = val Rt2 = BitsN.fromBitstring([Rt2'3,Rt2'2,Rt2'1,Rt2'0],4) val Rt = BitsN.fromBitstring([Rt'3,Rt'2,Rt'1,Rt'0],4) in - if Take(ThumbCondition (),Nat.>=(ArchVersion (),7)) - then ( if (((((L3.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse - (L3.mem(Rt,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse - (L3.mem(Rt2,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse + if Do(ThumbCondition (),Nat.>=(ArchVersion (),7)) + then ( if (((((Set.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse + (Set.mem(Rt,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse + (Set.mem(Rt2,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse (Rn = (BitsN.B(0xF,4)))) orelse (Rd = Rn)) orelse (Rd = Rt) then DECODE_UNPREDICTABLE @@ -14774,9 +14762,9 @@ fun DecodeThumb2 h = val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) val Rm = BitsN.fromBitstring([Rm'3,Rm'2,Rm'1,Rm'0],4) in - if Take(ThumbCondition (),HaveThumb2 ()) + if Do(ThumbCondition (),HaveThumb2 ()) then ( if ((Rn = (BitsN.B(0xD,4))) orelse - (L3.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse + (Set.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse ((InITBlock ()) andalso (not(LastInITBlock ()))) then DECODE_UNPREDICTABLE(mc,"TableBranchByte") else () @@ -14810,8 +14798,8 @@ fun DecodeThumb2 h = val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) val Rt = BitsN.fromBitstring([Rt'3,Rt'2,Rt'1,Rt'0],4) in - if Take(ThumbCondition (),Nat.>=(ArchVersion (),7)) - then ( if (L3.mem(Rt,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse + if Do(ThumbCondition (),Nat.>=(ArchVersion (),7)) + then ( if (Set.mem(Rt,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse (Rn = (BitsN.B(0xF,4))) then DECODE_UNPREDICTABLE (mc,"LoadExclusive: Byte or Halfword") @@ -14841,9 +14829,9 @@ fun DecodeThumb2 h = val Rt2 = BitsN.fromBitstring([Rt2'3,Rt2'2,Rt2'1,Rt2'0],4) val Rt = BitsN.fromBitstring([Rt'3,Rt'2,Rt'1,Rt'0],4) in - if Take(ThumbCondition (),Nat.>=(ArchVersion (),7)) - then ( if (((L3.mem(Rt,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse - (L3.mem(Rt2,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse + if Do(ThumbCondition (),Nat.>=(ArchVersion (),7)) + then ( if (((Set.mem(Rt,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse + (Set.mem(Rt2,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse (Rt = Rt2)) orelse (Rn = (BitsN.B(0xF,4))) then DECODE_UNPREDICTABLE (mc,"LoadExclusiveDoubleword") @@ -14878,8 +14866,7 @@ fun DecodeThumb2 h = val Rt2 = BitsN.fromBitstring([Rt2'3,Rt2'2,Rt2'1,Rt2'0],4) val Rt = BitsN.fromBitstring([Rt'3,Rt'2,Rt'1,Rt'0],4) in - if Take - (ThumbCondition (), + if Do(ThumbCondition (), ((P = (BitsN.B(0x1,1))) orelse (W = (BitsN.B(0x1,1)))) andalso (HaveThumb2 ())) then let @@ -14887,8 +14874,8 @@ fun DecodeThumb2 h = in ( if (((wback andalso ((Rn = Rt) orelse (Rn = Rt2))) orelse (Rn = (BitsN.B(0xF,4)))) orelse - (L3.mem(Rt,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse - (L3.mem(Rt2,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) + (Set.mem(Rt,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse + (Set.mem(Rt2,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) then DECODE_UNPREDICTABLE(mc,"StoreDual") else () ; let @@ -14934,12 +14921,11 @@ fun DecodeThumb2 h = val Rt2 = BitsN.fromBitstring([Rt2'3,Rt2'2,Rt2'1,Rt2'0],4) val Rt = BitsN.fromBitstring([Rt'3,Rt'2,Rt'1,Rt'0],4) in - if Take - (ThumbCondition (), + if Do(ThumbCondition (), (((BitsN.fromBitstring([P'0],1)) = (BitsN.B(0x1,1))) orelse (W = (BitsN.B(0x1,1)))) andalso (HaveThumb2 ())) - then ( if (((L3.mem(Rt,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse - (L3.mem(Rt2,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse + then ( if (((Set.mem(Rt,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse + (Set.mem(Rt2,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse (Rt = Rt2)) orelse (W = (BitsN.B(0x1,1))) then DECODE_UNPREDICTABLE(mc,"LoadDual: literal") else () @@ -14984,16 +14970,15 @@ fun DecodeThumb2 h = val Rt2 = BitsN.fromBitstring([Rt2'3,Rt2'2,Rt2'1,Rt2'0],4) val Rt = BitsN.fromBitstring([Rt'3,Rt'2,Rt'1,Rt'0],4) in - if Take - (ThumbCondition (), + if Do(ThumbCondition (), ((P = (BitsN.B(0x1,1))) orelse (W = (BitsN.B(0x1,1)))) andalso (HaveThumb2 ())) then let val wback = W = (BitsN.B(0x1,1)) in ( if (((wback andalso ((Rn = Rt) orelse (Rn = Rt2))) orelse - (L3.mem(Rt,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse - (L3.mem(Rt2,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse + (Set.mem(Rt,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse + (Set.mem(Rt2,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse (Rt = Rt2) then DECODE_UNPREDICTABLE(mc,"LoadDual") else () @@ -15042,7 +15027,7 @@ fun DecodeThumb2 h = val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) val imm3 = BitsN.fromBitstring([imm3'2,imm3'1,imm3'0],3) in - if Take(ThumbCondition (),HaveThumb2 ()) + if Do(ThumbCondition (),HaveThumb2 ()) then let val (shift_t,shift_n) = DecodeImmShift(typ,BitsN.@@(imm3,imm2)) @@ -15051,8 +15036,8 @@ fun DecodeThumb2 h = case (BitsN.fromBitstring([op'3,op'2,op'1,op'0],4), (Rn,(Rd,S))) of (BitsN.B(0x0,4),(_,(BitsN.B(0xF,4),BitsN.B(0x1,1)))) => - ( if (L3.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse - (L3.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) + ( if (Set.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse + (Set.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) then DECODE_UNPREDICTABLE(mc,"TST (register)") else () ; Data @@ -15063,8 +15048,8 @@ fun DecodeThumb2 h = ( if (((Rd = (BitsN.B(0xD,4))) orelse ((Rd = (BitsN.B(0xF,4))) andalso (not setflags))) orelse - (L3.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse - (L3.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) + (Set.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse + (Set.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) then DECODE_UNPREDICTABLE(mc,"AND (register)") else () ; Data @@ -15073,9 +15058,9 @@ fun DecodeThumb2 h = (setflags,(Rd,(Rn,(Rm,(shift_t,shift_n))))))) ) | (BitsN.B(0x1,4),_) => - ( if ((L3.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse - (L3.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse - (L3.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) + ( if ((Set.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse + (Set.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse + (Set.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) then DECODE_UNPREDICTABLE(mc,"BIC (register)") else () ; Data @@ -15088,10 +15073,10 @@ fun DecodeThumb2 h = (imm3 = (BitsN.B(0x0,3)))) andalso (imm2 = (BitsN.B(0x0,2))) then if (setflags andalso - ((L3.mem + ((Set.mem (Rd, [BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse - (L3.mem + (Set.mem (Rm, [BitsN.B(0xD,4),BitsN.B(0xF,4)])))) orelse ((not setflags) andalso @@ -15102,9 +15087,9 @@ fun DecodeThumb2 h = then DECODE_UNPREDICTABLE (mc,"MOV (register)") else () - else if (L3.mem + else if (Set.mem (Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse - (L3.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) + (Set.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) then DECODE_UNPREDICTABLE (mc,"SHIFT (register)") else () @@ -15114,9 +15099,9 @@ fun DecodeThumb2 h = (setflags,(Rd,(Rm,(shift_t,shift_n)))))) ) | (BitsN.B(0x2,4),_) => - ( if ((L3.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse + ( if ((Set.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse (Rn = (BitsN.B(0xD,4)))) orelse - (L3.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) + (Set.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) then DECODE_UNPREDICTABLE(mc,"ORR (register)") else () ; Data @@ -15125,8 +15110,8 @@ fun DecodeThumb2 h = (setflags,(Rd,(Rn,(Rm,(shift_t,shift_n))))))) ) | (BitsN.B(0x3,4),(BitsN.B(0xF,4),_)) => - ( if (L3.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse - (L3.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) + ( if (Set.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse + (Set.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) then DECODE_UNPREDICTABLE(mc,"MVN (register)") else () ; Data @@ -15134,9 +15119,9 @@ fun DecodeThumb2 h = (true,(setflags,(Rd,(Rm,(shift_t,shift_n)))))) ) | (BitsN.B(0x3,4),_) => - ( if ((L3.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse + ( if ((Set.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse (Rn = (BitsN.B(0xD,4)))) orelse - (L3.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) + (Set.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) then DECODE_UNPREDICTABLE(mc,"ORN (register)") else () ; Data @@ -15145,8 +15130,8 @@ fun DecodeThumb2 h = (setflags,(Rd,(Rn,(Rm,(shift_t,shift_n))))))) ) | (BitsN.B(0x4,4),(_,(BitsN.B(0xF,4),BitsN.B(0x1,1)))) => - ( if (L3.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse - (L3.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) + ( if (Set.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse + (Set.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) then DECODE_UNPREDICTABLE(mc,"TEQ (register)") else () ; Data @@ -15157,8 +15142,8 @@ fun DecodeThumb2 h = ( if (((Rd = (BitsN.B(0xD,4))) orelse ((Rd = (BitsN.B(0xF,4))) andalso (not setflags))) orelse - (L3.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse - (L3.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) + (Set.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse + (Set.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) then DECODE_UNPREDICTABLE(mc,"EOR (register)") else () ; Data @@ -15169,11 +15154,11 @@ fun DecodeThumb2 h = | (BitsN.B(0x6,4),(_,(_,BitsN.B(0x0,1)))) => (if BitsN.bit(typ,0) then Undefined(BitsN.B(0x0,32)) - else ( if ((L3.mem + else ( if ((Set.mem (Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse - (L3.mem + (Set.mem (Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse - (L3.mem + (Set.mem (Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) then DECODE_UNPREDICTABLE (mc,"PackHalfword") @@ -15189,7 +15174,7 @@ fun DecodeThumb2 h = )) | (BitsN.B(0x8,4),(_,(BitsN.B(0xF,4),BitsN.B(0x1,1)))) => ( if (Rn = (BitsN.B(0xF,4))) orelse - (L3.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) + (Set.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) then DECODE_UNPREDICTABLE(mc,"CMN (register)") else () ; Data @@ -15201,7 +15186,7 @@ fun DecodeThumb2 h = ((Rd = (BitsN.B(0xF,4))) andalso (not setflags))) orelse (Rn = (BitsN.B(0xF,4)))) orelse - (L3.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) + (Set.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) then DECODE_UNPREDICTABLE(mc,"ADD (register)") else () ; let @@ -15216,9 +15201,9 @@ fun DecodeThumb2 h = end ) | (BitsN.B(0xA,4),_) => - ( if ((L3.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse - (L3.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse - (L3.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) + ( if ((Set.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse + (Set.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse + (Set.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) then DECODE_UNPREDICTABLE(mc,"ADC (register)") else () ; Data @@ -15227,9 +15212,9 @@ fun DecodeThumb2 h = (setflags,(Rd,(Rn,(Rm,(shift_t,shift_n))))))) ) | (BitsN.B(0xB,4),_) => - ( if ((L3.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse - (L3.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse - (L3.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) + ( if ((Set.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse + (Set.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse + (Set.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) then DECODE_UNPREDICTABLE(mc,"SBC (register)") else () ; Data @@ -15239,7 +15224,7 @@ fun DecodeThumb2 h = ) | (BitsN.B(0xD,4),(_,(BitsN.B(0xF,4),BitsN.B(0x1,1)))) => ( if (Rn = (BitsN.B(0xF,4))) orelse - (L3.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) + (Set.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) then DECODE_UNPREDICTABLE(mc,"CMP (register)") else () ; Data @@ -15251,7 +15236,7 @@ fun DecodeThumb2 h = ((Rd = (BitsN.B(0xF,4))) andalso (not setflags))) orelse (Rn = (BitsN.B(0xF,4)))) orelse - (L3.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) + (Set.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) then DECODE_UNPREDICTABLE(mc,"SUB (register)") else () ; Data @@ -15260,9 +15245,9 @@ fun DecodeThumb2 h = (setflags,(Rd,(Rn,(Rm,(shift_t,shift_n))))))) ) | (BitsN.B(0xE,4),_) => - ( if ((L3.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse - (L3.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse - (L3.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) + ( if ((Set.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse + (Set.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse + (Set.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) then DECODE_UNPREDICTABLE(mc,"RSB (register)") else () ; Data @@ -15298,7 +15283,7 @@ fun DecodeThumb2 h = val S = BitsN.fromBitstring([S'0],1) val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) in - if Take(ThumbCondition (),HaveThumb2 ()) + if Do(ThumbCondition (),HaveThumb2 ()) then let val imm12 = BitsN.concat @@ -15313,7 +15298,7 @@ fun DecodeThumb2 h = case (BitsN.fromBitstring([op'3,op'2,op'1,op'0],4), (Rn,(Rd,S))) of (BitsN.B(0x0,4),(_,(BitsN.B(0xF,4),BitsN.B(0x1,1)))) => - ( if L3.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)]) + ( if Set.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)]) then DECODE_UNPREDICTABLE(mc,"TST (immediate)") else () ; Data @@ -15324,7 +15309,7 @@ fun DecodeThumb2 h = ( if ((Rd = (BitsN.B(0xD,4))) orelse ((Rd = (BitsN.B(0xF,4))) andalso (not setflags))) orelse - (L3.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) + (Set.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) then DECODE_UNPREDICTABLE(mc,"AND (immediate)") else () ; Data @@ -15332,8 +15317,8 @@ fun DecodeThumb2 h = (BitsN.B(0x0,4),(setflags,(Rd,(Rn,imm12))))) ) | (BitsN.B(0x1,4),_) => - ( if (L3.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse - (L3.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) + ( if (Set.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse + (Set.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) then DECODE_UNPREDICTABLE(mc,"BIC (immediate)") else () ; Data @@ -15341,13 +15326,13 @@ fun DecodeThumb2 h = (BitsN.B(0xE,4),(setflags,(Rd,(Rn,imm12))))) ) | (BitsN.B(0x2,4),(BitsN.B(0xF,4),_)) => - ( if L3.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)]) + ( if Set.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)]) then DECODE_UNPREDICTABLE(mc,"MOV (immediate)") else () ; Data(Move(setflags,(false,(Rd,imm12)))) ) | (BitsN.B(0x2,4),_) => - ( if (L3.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse + ( if (Set.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse (Rn = (BitsN.B(0xD,4))) then DECODE_UNPREDICTABLE(mc,"ORR (immediate)") else () @@ -15356,13 +15341,13 @@ fun DecodeThumb2 h = (BitsN.B(0xC,4),(setflags,(Rd,(Rn,imm12))))) ) | (BitsN.B(0x3,4),(BitsN.B(0xF,4),_)) => - ( if L3.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)]) + ( if Set.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)]) then DECODE_UNPREDICTABLE(mc,"MVN (immediate)") else () ; Data(Move(setflags,(true,(Rd,imm12)))) ) | (BitsN.B(0x3,4),_) => - ( if (L3.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse + ( if (Set.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse (Rn = (BitsN.B(0xD,4))) then DECODE_UNPREDICTABLE(mc,"ORN (immediate)") else () @@ -15371,7 +15356,7 @@ fun DecodeThumb2 h = (BitsN.B(0xF,4),(setflags,(Rd,(Rn,imm12))))) ) | (BitsN.B(0x4,4),(_,(BitsN.B(0xF,4),BitsN.B(0x1,1)))) => - ( if L3.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)]) + ( if Set.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)]) then DECODE_UNPREDICTABLE(mc,"TEQ (immediate)") else () ; Data @@ -15382,7 +15367,7 @@ fun DecodeThumb2 h = ( if ((Rd = (BitsN.B(0xD,4))) orelse ((Rd = (BitsN.B(0xF,4))) andalso (not setflags))) orelse - (L3.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) + (Set.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) then DECODE_UNPREDICTABLE(mc,"EOR (immediate)") else () ; Data @@ -15409,8 +15394,8 @@ fun DecodeThumb2 h = (BitsN.B(0x4,4),(setflags,(Rd,(Rn,imm12))))) ) | (BitsN.B(0xA,4),_) => - ( if (L3.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse - (L3.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) + ( if (Set.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse + (Set.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) then DECODE_UNPREDICTABLE(mc,"ADC (immediate)") else () ; Data @@ -15418,8 +15403,8 @@ fun DecodeThumb2 h = (BitsN.B(0x5,4),(setflags,(Rd,(Rn,imm12))))) ) | (BitsN.B(0xB,4),_) => - ( if (L3.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse - (L3.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) + ( if (Set.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse + (Set.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) then DECODE_UNPREDICTABLE(mc,"SBC (immediate)") else () ; Data @@ -15446,8 +15431,8 @@ fun DecodeThumb2 h = (BitsN.B(0x2,4),(setflags,(Rd,(Rn,imm12))))) ) | (BitsN.B(0xE,4),_) => - ( if (L3.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse - (L3.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) + ( if (Set.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse + (Set.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) then DECODE_UNPREDICTABLE(mc,"RSB (immediate)") else () ; Data @@ -15481,8 +15466,8 @@ fun DecodeThumb2 h = let val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) in - if Take(ThumbCondition (),HaveThumb2 ()) - then ( if L3.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)]) + if Do(ThumbCondition (),HaveThumb2 ()) + then ( if Set.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)]) then DECODE_UNPREDICTABLE(mc,"ADDW (immediate)") else () ; let @@ -15527,8 +15512,8 @@ fun DecodeThumb2 h = let val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) in - if Take(ThumbCondition (),HaveThumb2 ()) - then ( if L3.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)]) + if Do(ThumbCondition (),HaveThumb2 ()) + then ( if Set.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)]) then DECODE_UNPREDICTABLE(mc,"SUBW (immediate)") else () ; let @@ -15574,8 +15559,8 @@ fun DecodeThumb2 h = let val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) in - if Take(ThumbCondition (),HaveThumb2 ()) - then ( if L3.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)]) + if Do(ThumbCondition (),HaveThumb2 ()) + then ( if Set.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)]) then DECODE_UNPREDICTABLE (mc,"MOVT or MOVW (immediate)") else () @@ -15624,9 +15609,9 @@ fun DecodeThumb2 h = ([sat_imm'3,sat_imm'2,sat_imm'1,sat_imm'0],4) val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) in - if Take(ThumbCondition (),HaveThumb2 ()) - then ( if (L3.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse - (L3.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) + if Do(ThumbCondition (),HaveThumb2 ()) + then ( if (Set.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse + (Set.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) then DECODE_UNPREDICTABLE(mc,"Saturate16") else () ; let @@ -15671,9 +15656,9 @@ fun DecodeThumb2 h = ([sat_imm'4,sat_imm'3,sat_imm'2,sat_imm'1,sat_imm'0],5) val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) in - if Take(ThumbCondition (),HaveThumb2 ()) - then ( if (L3.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse - (L3.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) + if Do(ThumbCondition (),HaveThumb2 ()) + then ( if (Set.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse + (Set.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) then DECODE_UNPREDICTABLE(mc,"Saturate") else () ; let @@ -15725,7 +15710,7 @@ fun DecodeThumb2 h = val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) in - if Take(ThumbCondition (),HaveThumb2 ()) + if Do(ThumbCondition (),HaveThumb2 ()) then let val widthminus1 = BitsN.toNat @@ -15738,8 +15723,8 @@ fun DecodeThumb2 h = (BitsN.fromBitstring([imm3'2,imm3'1,imm3'0],3), BitsN.fromBitstring([imm2'1,imm2'0],2))) in - ( if ((L3.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse - (L3.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse + ( if ((Set.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse + (Set.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse (Nat.<(31,Nat.+(lsbit,widthminus1))) then DECODE_UNPREDICTABLE(mc,"BitFieldExtract") else () @@ -15777,7 +15762,7 @@ fun DecodeThumb2 h = val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) in - if Take(ThumbCondition (),HaveThumb2 ()) + if Do(ThumbCondition (),HaveThumb2 ()) then let val msbit = BitsN.toNat @@ -15789,7 +15774,7 @@ fun DecodeThumb2 h = (BitsN.fromBitstring([imm3'2,imm3'1,imm3'0],3), BitsN.fromBitstring([imm2'1,imm2'0],2))) in - ( if ((L3.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse + ( if ((Set.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse (Rn = (BitsN.B(0xD,4)))) orelse (Nat.<(msbit,lsbit)) then DECODE_UNPREDICTABLE @@ -15815,8 +15800,8 @@ fun DecodeThumb2 h = let val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) in - if Take(ThumbCondition (),HaveVirtExt ()) - then ( if L3.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)]) + if Do(ThumbCondition (),HaveVirtExt ()) + then ( if Set.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)]) then DECODE_UNPREDICTABLE (mc,"MoveToBankedOrSpecialRegister") else () @@ -15851,9 +15836,9 @@ fun DecodeThumb2 h = val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) val mask = BitsN.fromBitstring([mask'3,mask'2,mask'1,mask'0],4) in - if Take(ThumbCondition (),HaveThumb2 ()) + if Do(ThumbCondition (),HaveThumb2 ()) then ( if (mask = (BitsN.B(0x0,4))) orelse - (L3.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) + (Set.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) then DECODE_UNPREDICTABLE (mc,"MoveToSpecialFromRegister") else () @@ -15909,7 +15894,7 @@ fun DecodeThumb2 h = val M = BitsN.fromBitstring([M'0],1) val imod = BitsN.fromBitstring([imod'1,imod'0],2) in - if Take(ThumbCondition (),HaveThumb2 ()) + if Do(ThumbCondition (),HaveThumb2 ()) then ( if ((((not(mode = (BitsN.B(0x0,5)))) andalso (M = (BitsN.B(0x0,1)))) orelse ((BitsN.bit(imod,1)) = @@ -15948,7 +15933,7 @@ fun DecodeThumb2 h = let val J = BitsN.fromBitstring([J'0],1) in - if (Take(ThumbCondition (),HaveThumbEE ())) andalso + if (Do(ThumbCondition (),HaveThumbEE ())) andalso (not(((CurrentInstrSet ()) = InstrSet_Thumb) andalso (J = (BitsN.B(0x0,1))))) then ( if InITBlock () @@ -15982,7 +15967,7 @@ fun DecodeThumb2 h = val option = BitsN.fromBitstring([option'3,option'2,option'1,option'0],4) in - if Take(ThumbCondition (),HaveThumb2 ()) + if Do(ThumbCondition (),HaveThumb2 ()) then case BitsN.fromBitstring([op'3,op'2,op'1,op'0],4) of BitsN.B(0x2,4) => ClearExclusive | BitsN.B(0x4,4) => @@ -16020,7 +16005,7 @@ fun DecodeThumb2 h = BitsN.fromBitstring ([imm8'7,imm8'6,imm8'5,imm8'4,imm8'3,imm8'2,imm8'1,imm8'0],8) in - if Take(ThumbCondition (),HaveThumb2 ()) + if Do(ThumbCondition (),HaveThumb2 ()) then if (HaveVirtExt ()) andalso (imm8 = (BitsN.B(0x0,8))) then System ExceptionReturn else ( if ((CurrentInstrSet ()) = InstrSet_ThumbEE) orelse @@ -16057,8 +16042,8 @@ fun DecodeThumb2 h = let val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) in - if Take(ThumbCondition (),HaveVirtExt ()) - then ( if L3.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)]) + if Do(ThumbCondition (),HaveVirtExt ()) + then ( if Set.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)]) then DECODE_UNPREDICTABLE (mc,"MoveToRegisterFromBankedOrSpecial") else () @@ -16087,8 +16072,8 @@ fun DecodeThumb2 h = let val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) in - if Take(ThumbCondition (),HaveThumb2 ()) - then ( if L3.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)]) + if Do(ThumbCondition (),HaveThumb2 ()) + then ( if Set.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)]) then DECODE_UNPREDICTABLE (mc,"MoveToRegisterFromSpecial") else () @@ -16122,7 +16107,7 @@ fun DecodeThumb2 h = (imm12'7, (imm12'6, (imm12'5,(imm12'4,(imm12'3,(imm12'2,(imm12'1,imm12'0)))))))))))))))) => - (if Take(ThumbCondition (),HaveVirtExt ()) + (if Do(ThumbCondition (),HaveVirtExt ()) then ( if InITBlock () then DECODE_UNPREDICTABLE(mc,"HypervisorCall") else () @@ -16151,8 +16136,7 @@ fun DecodeThumb2 h = (true, (true,(true,(true,(imm4'3,(imm4'2,(imm4'1,imm4'0))))))))))))))), (true,(false,(false,(false,_))))) => - (if Take - (ThumbCondition (), + (if Do(ThumbCondition (), (HaveSecurityExt ()) andalso (not((!Architecture) = ARMv6K))) then ( if (InITBlock ()) andalso (not(LastInITBlock ())) @@ -16185,7 +16169,7 @@ fun DecodeThumb2 h = (imm12'7, (imm12'6, (imm12'5,(imm12'4,(imm12'3,(imm12'2,(imm12'1,imm12'0)))))))))))))))) => - (if Take(ThumbCondition (),HaveThumb2 ()) + (if Do(ThumbCondition (),HaveThumb2 ()) then let val imm32 = BitsN.zeroExtend 32 @@ -16222,8 +16206,7 @@ fun DecodeThumb2 h = (imm11'7, (imm11'6, (imm11'5,(imm11'4,(imm11'3,(imm11'2,(imm11'1,imm11'0)))))))))))))))) => - (if Take - (BitsN.fromBitstring([cond'3,cond'2,cond'1,cond'0],4), + (if Do(BitsN.fromBitstring([cond'3,cond'2,cond'1,cond'0],4), HaveThumb2 ()) then ( if InITBlock () then DECODE_UNPREDICTABLE(mc,"BranchTarget") @@ -16275,8 +16258,7 @@ fun DecodeThumb2 h = val J1 = BitsN.fromBitstring([J1'0],1) val L = BitsN.fromBitstring([L'0],1) in - if Take - (ThumbCondition (), + if Do(ThumbCondition (), (((L = (BitsN.B(0x1,1))) andalso (J1 = (BitsN.B(0x1,1)))) andalso (J1 = J2)) orelse (HaveThumb2 ())) then ( if (InITBlock ()) andalso (not(LastInITBlock ())) @@ -16339,8 +16321,7 @@ fun DecodeThumb2 h = val J2 = BitsN.fromBitstring([J2'0],1) val J1 = BitsN.fromBitstring([J1'0],1) in - if Take - (ThumbCondition (), + if Do(ThumbCondition (), (not(((CurrentInstrSet ()) = InstrSet_ThumbEE) orelse ((BitsN.fromBitstring([H'0],1)) = (BitsN.B(0x1,1))))) andalso (if (J1 = (BitsN.B(0x1,1))) andalso (J1 = J2) @@ -16404,7 +16385,7 @@ fun DecodeThumb2 h = (imm12'7, (imm12'6, (imm12'5,(imm12'4,(imm12'3,(imm12'2,(imm12'1,imm12'0)))))))))))))))) => - (if Take(ThumbCondition (),HaveThumb2 ()) + (if Do(ThumbCondition (),HaveThumb2 ()) then let val imm32 = BitsN.zeroExtend 32 @@ -16438,7 +16419,7 @@ fun DecodeThumb2 h = (imm12'7, (imm12'6, (imm12'5,(imm12'4,(imm12'3,(imm12'2,(imm12'1,imm12'0)))))))))))))))) => - (if Take(ThumbCondition (),Nat.>=(ArchVersion (),7)) + (if Do(ThumbCondition (),Nat.>=(ArchVersion (),7)) then let val imm32 = BitsN.zeroExtend 32 @@ -16473,7 +16454,7 @@ fun DecodeThumb2 h = (imm12'7, (imm12'6, (imm12'5,(imm12'4,(imm12'3,(imm12'2,(imm12'1,imm12'0)))))))))))))))) => - (if Take(ThumbCondition (),Nat.>=(ArchVersion (),7)) + (if Do(ThumbCondition (),Nat.>=(ArchVersion (),7)) then let val imm32 = BitsN.zeroExtend 32 @@ -16513,8 +16494,7 @@ fun DecodeThumb2 h = let val W = BitsN.fromBitstring([W'0],1) in - if Take - (ThumbCondition (), + if Do(ThumbCondition (), if W = (BitsN.B(0x1,1)) then HaveMPExt () else HaveThumb2 ()) @@ -16568,7 +16548,7 @@ fun DecodeThumb2 h = let val Rt = BitsN.fromBitstring([Rt'3,Rt'2,Rt'1,Rt'0],4) in - if Take(ThumbCondition (),HaveThumb2 ()) + if Do(ThumbCondition (),HaveThumb2 ()) then ( if Rt = (BitsN.B(0xD,4)) then DECODE_UNPREDICTABLE (mc,"LoadByteLiteral/LoadHalfLiteral") @@ -16616,7 +16596,7 @@ fun DecodeThumb2 h = let val Rt = BitsN.fromBitstring([Rt'3,Rt'2,Rt'1,Rt'0],4) in - if Take(ThumbCondition (),HaveThumb2 ()) + if Do(ThumbCondition (),HaveThumb2 ()) then ( if ((Rt = (BitsN.B(0xF,4))) andalso (InITBlock ())) andalso (not(LastInITBlock ())) then DECODE_UNPREDICTABLE(mc,"LoadLiteral") @@ -16659,7 +16639,7 @@ fun DecodeThumb2 h = val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) val Rt = BitsN.fromBitstring([Rt'3,Rt'2,Rt'1,Rt'0],4) in - if Take(ThumbCondition (),HaveThumb2 ()) + if Do(ThumbCondition (),HaveThumb2 ()) then ( if Rt = (BitsN.B(0xD,4)) then DECODE_UNPREDICTABLE (mc,"LoadByte/LoadHalf (immediate)") @@ -16713,7 +16693,7 @@ fun DecodeThumb2 h = let val Rt = BitsN.fromBitstring([Rt'3,Rt'2,Rt'1,Rt'0],4) in - if Take(ThumbCondition (),HaveThumb2 ()) + if Do(ThumbCondition (),HaveThumb2 ()) then ( if ((Rt = (BitsN.B(0xF,4))) andalso (InITBlock ())) andalso (not(LastInITBlock ())) then DECODE_UNPREDICTABLE(mc,"LoadWord") @@ -16765,8 +16745,7 @@ fun DecodeThumb2 h = let val W = BitsN.fromBitstring([W'0],1) in - if Take - (ThumbCondition (), + if Do(ThumbCondition (), if W = (BitsN.B(0x1,1)) then HaveMPExt () else HaveThumb2 ()) @@ -16808,7 +16787,7 @@ fun DecodeThumb2 h = (imm8'7, (imm8'6, (imm8'5,(imm8'4,(imm8'3,(imm8'2,(imm8'1,imm8'0)))))))))))))))) => - (if Take(ThumbCondition (),Nat.>=(ArchVersion (),7)) + (if Do(ThumbCondition (),Nat.>=(ArchVersion (),7)) then let val imm32 = BitsN.zeroExtend 32 @@ -16853,8 +16832,8 @@ fun DecodeThumb2 h = val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) val Rt = BitsN.fromBitstring([Rt'3,Rt'2,Rt'1,Rt'0],4) in - if Take(ThumbCondition (),HaveThumb2 ()) - then ( if L3.mem(Rt,[BitsN.B(0xD,4),BitsN.B(0xF,4)]) + if Do(ThumbCondition (),HaveThumb2 ()) + then ( if Set.mem(Rt,[BitsN.B(0xD,4),BitsN.B(0xF,4)]) then DECODE_UNPREDICTABLE(mc,"LoadUnprivileged") else () ; let @@ -16916,7 +16895,7 @@ fun DecodeThumb2 h = val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) val Rt = BitsN.fromBitstring([Rt'3,Rt'2,Rt'1,Rt'0],4) in - if Take(ThumbCondition (),HaveThumb2 ()) + if Do(ThumbCondition (),HaveThumb2 ()) then let val wback = (BitsN.fromBitstring([W'0],1)) = (BitsN.B(0x1,1)) @@ -16978,8 +16957,8 @@ fun DecodeThumb2 h = let val Rt = BitsN.fromBitstring([Rt'3,Rt'2,Rt'1,Rt'0],4) in - if Take(ThumbCondition (),HaveThumb2 ()) - then ( if L3.mem(Rt,[BitsN.B(0xD,4),BitsN.B(0xF,4)]) + if Do(ThumbCondition (),HaveThumb2 ()) + then ( if Set.mem(Rt,[BitsN.B(0xD,4),BitsN.B(0xF,4)]) then DECODE_UNPREDICTABLE(mc,"LoadUnprivileged") else () ; let @@ -17029,8 +17008,7 @@ fun DecodeThumb2 h = val P = BitsN.fromBitstring([P'0],1) val Rt = BitsN.fromBitstring([Rt'3,Rt'2,Rt'1,Rt'0],4) in - if Take - (ThumbCondition (), + if Do(ThumbCondition (), ((P = (BitsN.B(0x1,1))) orelse (W = (BitsN.B(0x1,1)))) andalso (HaveThumb2 ())) then let @@ -17080,12 +17058,11 @@ fun DecodeThumb2 h = val W = BitsN.fromBitstring([W'0],1) val Rm = BitsN.fromBitstring([Rm'3,Rm'2,Rm'1,Rm'0],4) in - if Take - (ThumbCondition (), + if Do(ThumbCondition (), if W = (BitsN.B(0x1,1)) then HaveMPExt () else HaveThumb2 ()) - then ( if L3.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)]) + then ( if Set.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)]) then DECODE_UNPREDICTABLE(mc,"PreloadData") else () ; let @@ -17128,8 +17105,8 @@ fun DecodeThumb2 h = let val Rm = BitsN.fromBitstring([Rm'3,Rm'2,Rm'1,Rm'0],4) in - if Take(ThumbCondition (),Nat.>=(ArchVersion (),7)) - then ( if L3.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)]) + if Do(ThumbCondition (),Nat.>=(ArchVersion (),7)) + then ( if Set.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)]) then DECODE_UNPREDICTABLE(mc,"PreloadInstruction") else () ; let @@ -17179,9 +17156,9 @@ fun DecodeThumb2 h = val Rm = BitsN.fromBitstring([Rm'3,Rm'2,Rm'1,Rm'0],4) val Rt = BitsN.fromBitstring([Rt'3,Rt'2,Rt'1,Rt'0],4) in - if Take(ThumbCondition (),HaveThumb2 ()) + if Do(ThumbCondition (),HaveThumb2 ()) then ( if (Rt = (BitsN.B(0xD,4))) orelse - (L3.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) + (Set.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) then DECODE_UNPREDICTABLE(mc,"Load (register)") else () ; let @@ -17230,10 +17207,10 @@ fun DecodeThumb2 h = val Rm = BitsN.fromBitstring([Rm'3,Rm'2,Rm'1,Rm'0],4) val Rt = BitsN.fromBitstring([Rt'3,Rt'2,Rt'1,Rt'0],4) in - if Take(ThumbCondition (),HaveThumb2 ()) + if Do(ThumbCondition (),HaveThumb2 ()) then ( if (((Rt = (BitsN.B(0xF,4))) andalso (InITBlock ())) andalso (not(LastInITBlock ()))) orelse - (L3.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) + (Set.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) then DECODE_UNPREDICTABLE(mc,"LoadWord") else () ; let @@ -17281,11 +17258,10 @@ fun DecodeThumb2 h = val Rm = BitsN.fromBitstring([Rm'3,Rm'2,Rm'1,Rm'0],4) val Rt = BitsN.fromBitstring([Rt'3,Rt'2,Rt'1,Rt'0],4) in - if Take - (ThumbCondition (), + if Do(ThumbCondition (), (not(Rn = (BitsN.B(0xF,4)))) andalso (HaveThumb2 ())) then ( if (Rt = (BitsN.B(0xF,4))) orelse - (L3.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) + (Set.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) then DECODE_UNPREDICTABLE(mc,"Store (register)") else () ; let @@ -17326,11 +17302,10 @@ fun DecodeThumb2 h = val Rm = BitsN.fromBitstring([Rm'3,Rm'2,Rm'1,Rm'0],4) val Rt = BitsN.fromBitstring([Rt'3,Rt'2,Rt'1,Rt'0],4) in - if Take - (ThumbCondition (), + if Do(ThumbCondition (), (not(Rn = (BitsN.B(0xF,4)))) andalso (HaveThumb2 ())) - then ( if (L3.mem(Rt,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse - (L3.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) + then ( if (Set.mem(Rt,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse + (Set.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) then DECODE_UNPREDICTABLE (mc,"StoreByte/Half (register)") else () @@ -17377,10 +17352,9 @@ fun DecodeThumb2 h = val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) val Rt = BitsN.fromBitstring([Rt'3,Rt'2,Rt'1,Rt'0],4) in - if Take - (ThumbCondition (), + if Do(ThumbCondition (), (not(Rn = (BitsN.B(0xF,4)))) andalso (HaveThumb2 ())) - then ( if L3.mem(Rt,[BitsN.B(0xD,4),BitsN.B(0xF,4)]) + then ( if Set.mem(Rt,[BitsN.B(0xD,4),BitsN.B(0xF,4)]) then DECODE_UNPREDICTABLE(mc,"StoreUnprivileged") else () ; let @@ -17422,10 +17396,9 @@ fun DecodeThumb2 h = val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) val Rt = BitsN.fromBitstring([Rt'3,Rt'2,Rt'1,Rt'0],4) in - if Take - (ThumbCondition (), + if Do(ThumbCondition (), (not(Rn = (BitsN.B(0xF,4)))) andalso (HaveThumb2 ())) - then ( if L3.mem(Rt,[BitsN.B(0xD,4),BitsN.B(0xF,4)]) + then ( if Set.mem(Rt,[BitsN.B(0xD,4),BitsN.B(0xF,4)]) then DECODE_UNPREDICTABLE (mc,"StoreByte/HalfUnprivileged") else () @@ -17477,8 +17450,7 @@ fun DecodeThumb2 h = val P = BitsN.fromBitstring([P'0],1) val Rt = BitsN.fromBitstring([Rt'3,Rt'2,Rt'1,Rt'0],4) in - if Take - (ThumbCondition (), + if Do(ThumbCondition (), ((not(Rn = (BitsN.B(0xF,4)))) andalso ((P = (BitsN.B(0x1,1))) orelse (W = (BitsN.B(0x1,1))))) andalso (HaveThumb2 ())) @@ -17532,15 +17504,14 @@ fun DecodeThumb2 h = val P = BitsN.fromBitstring([P'0],1) val Rt = BitsN.fromBitstring([Rt'3,Rt'2,Rt'1,Rt'0],4) in - if Take - (ThumbCondition (), + if Do(ThumbCondition (), ((not(Rn = (BitsN.B(0xF,4)))) andalso ((P = (BitsN.B(0x1,1))) orelse (W = (BitsN.B(0x1,1))))) andalso (HaveThumb2 ())) then let val wback = W = (BitsN.B(0x1,1)) in - ( if (L3.mem(Rt,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse + ( if (Set.mem(Rt,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse (wback andalso (Rn = Rt)) then DECODE_UNPREDICTABLE (mc,"StoreByte/Half (immediate)") @@ -17592,8 +17563,7 @@ fun DecodeThumb2 h = val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) val Rt = BitsN.fromBitstring([Rt'3,Rt'2,Rt'1,Rt'0],4) in - if Take - (ThumbCondition (), + if Do(ThumbCondition (), (not(Rn = (BitsN.B(0xF,4)))) andalso (HaveThumb2 ())) then ( if Rt = (BitsN.B(0xF,4)) then DECODE_UNPREDICTABLE(mc,"Store (immediate)") @@ -17639,10 +17609,9 @@ fun DecodeThumb2 h = val Rn = BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4) val Rt = BitsN.fromBitstring([Rt'3,Rt'2,Rt'1,Rt'0],4) in - if Take - (ThumbCondition (), + if Do(ThumbCondition (), (not(Rn = (BitsN.B(0xF,4)))) andalso (HaveThumb2 ())) - then ( if L3.mem(Rt,[BitsN.B(0xD,4),BitsN.B(0xF,4)]) + then ( if Set.mem(Rt,[BitsN.B(0xD,4),BitsN.B(0xF,4)]) then DECODE_UNPREDICTABLE (mc,"StoreByte/Half (immediate)") else () @@ -17690,10 +17659,10 @@ fun DecodeThumb2 h = val Rm = BitsN.fromBitstring([Rm'3,Rm'2,Rm'1,Rm'0],4) val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) in - if Take(ThumbCondition (),HaveThumb2 ()) - then ( if ((L3.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse - (L3.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse - (L3.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) + if Do(ThumbCondition (),HaveThumb2 ()) + then ( if ((Set.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse + (Set.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse + (Set.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) then DECODE_UNPREDICTABLE(mc,"Shift (register)") else () ; let @@ -17732,10 +17701,10 @@ fun DecodeThumb2 h = val Rm = BitsN.fromBitstring([Rm'3,Rm'2,Rm'1,Rm'0],4) val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) in - if Take(ThumbCondition (),HaveThumb2 ()) - then ( if ((L3.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse + if Do(ThumbCondition (),HaveThumb2 ()) + then ( if ((Set.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse (Rn = (BitsN.B(0xD,4)))) orelse - (L3.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) + (Set.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) then DECODE_UNPREDICTABLE(mc,"Extend (register)") else () ; let @@ -17781,10 +17750,10 @@ fun DecodeThumb2 h = val Rm = BitsN.fromBitstring([Rm'3,Rm'2,Rm'1,Rm'0],4) val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) in - if Take(ThumbCondition (),HaveThumb2 ()) - then ( if ((L3.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse - (L3.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse - (L3.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) + if Do(ThumbCondition (),HaveThumb2 ()) + then ( if ((Set.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse + (Set.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse + (Set.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) then DECODE_UNPREDICTABLE (mc,"Parallel addition and subtraction") else () @@ -17831,10 +17800,10 @@ fun DecodeThumb2 h = val Rm = BitsN.fromBitstring([Rm'3,Rm'2,Rm'1,Rm'0],4) val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) in - if Take(ThumbCondition (),HaveThumb2 ()) - then ( if ((L3.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse - (L3.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse - (L3.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) + if Do(ThumbCondition (),HaveThumb2 ()) + then ( if ((Set.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse + (Set.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse + (Set.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) then DECODE_UNPREDICTABLE(mc,"SaturatingAddSubtract") else () ; let @@ -17868,11 +17837,11 @@ fun DecodeThumb2 h = val Rm = BitsN.fromBitstring([Rm'3,Rm'2,Rm'1,Rm'0],4) val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) in - if Take(ThumbCondition (),HaveThumb2 ()) + if Do(ThumbCondition (),HaveThumb2 ()) then ( if ((not((BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4)) = Rm)) orelse - (L3.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse - (L3.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) + (Set.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse + (Set.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) then DECODE_UNPREDICTABLE(mc,"Reverses") else () ; case BitsN.fromBitstring([op2'1,op2'0],2) of @@ -17909,10 +17878,10 @@ fun DecodeThumb2 h = val Rm = BitsN.fromBitstring([Rm'3,Rm'2,Rm'1,Rm'0],4) val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) in - if Take(ThumbCondition (),HaveThumb2 ()) - then ( if ((L3.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse - (L3.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse - (L3.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) + if Do(ThumbCondition (),HaveThumb2 ()) + then ( if ((Set.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse + (Set.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse + (Set.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) then DECODE_UNPREDICTABLE(mc,"SelectBytes") else () ; Media(SelectBytes(Rd,(Rn,Rm))) @@ -17941,11 +17910,11 @@ fun DecodeThumb2 h = val Rm = BitsN.fromBitstring([Rm'3,Rm'2,Rm'1,Rm'0],4) val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) in - if Take(ThumbCondition (),HaveThumb2 ()) + if Do(ThumbCondition (),HaveThumb2 ()) then ( if ((not((BitsN.fromBitstring([Rn'3,Rn'2,Rn'1,Rn'0],4)) = Rm)) orelse - (L3.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse - (L3.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) + (Set.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse + (Set.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) then DECODE_UNPREDICTABLE(mc,"CountLeadingZeroes") else () ; Data(CountLeadingZeroes(Rd,Rm)) @@ -17975,10 +17944,10 @@ fun DecodeThumb2 h = val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) val Ra = BitsN.fromBitstring([Ra'3,Ra'2,Ra'1,Ra'0],4) in - if Take(ThumbCondition (),HaveThumb2 ()) - then ( if (((L3.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse - (L3.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse - (L3.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse + if Do(ThumbCondition (),HaveThumb2 ()) + then ( if (((Set.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse + (Set.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse + (Set.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse (Ra = (BitsN.B(0xD,4))) then DECODE_UNPREDICTABLE (mc,"Multiplies and absolute difference") @@ -18062,12 +18031,11 @@ fun DecodeThumb2 h = val Rm = BitsN.fromBitstring([Rm'3,Rm'2,Rm'1,Rm'0],4) val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) in - if Take - (ThumbCondition (), + if Do(ThumbCondition (), (HaveVirtExt ()) orelse ((!Architecture) = ARMv7_R)) - then ( if ((L3.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse - (L3.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse - (L3.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) + then ( if ((Set.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse + (Set.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse + (Set.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) then DECODE_UNPREDICTABLE(mc,"Divide") else () ; let @@ -18103,11 +18071,11 @@ fun DecodeThumb2 h = val RdHi = BitsN.fromBitstring([RdHi'3,RdHi'2,RdHi'1,RdHi'0],4) val RdLo = BitsN.fromBitstring([RdLo'3,RdLo'2,RdLo'1,RdLo'0],4) in - if Take(ThumbCondition (),HaveThumb2 ()) - then ( if ((((L3.mem(RdLo,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse - (L3.mem(RdHi,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse - (L3.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse - (L3.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse + if Do(ThumbCondition (),HaveThumb2 ()) + then ( if ((((Set.mem(RdLo,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse + (Set.mem(RdHi,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse + (Set.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse + (Set.mem(Rm,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) orelse (RdHi = RdLo) then DECODE_UNPREDICTABLE (mc,"Long multiply, long multiply accumulate") @@ -18303,7 +18271,7 @@ fun EncodeAddSubOpc opc = fun EncodeVFPImmediate (imm64,single_register) = if single_register then if ((((BitsN.bits(imm64,18,0)) = (BitsN.B(0x0,19))) andalso - (L3.mem + (Set.mem (BitsN.bits(imm64,29,25),[BitsN.B(0x0,5),BitsN.B(0x1F,5)]))) andalso (not((BitsN.bit(imm64,25)) = (BitsN.bit(imm64,30))))) andalso ((BitsN.bits(imm64,63,32)) = (BitsN.B(0x0,32))) @@ -18313,7 +18281,7 @@ fun EncodeVFPImmediate (imm64,single_register) = BitsN.bits(imm64,24,19)]) else NONE else if (((BitsN.bits(imm64,47,0)) = (BitsN.B(0x0,48))) andalso - (L3.mem(BitsN.bits(imm64,61,54),[BitsN.B(0x0,8),BitsN.B(0xFF,8)]))) andalso + (Set.mem(BitsN.bits(imm64,61,54),[BitsN.B(0x0,8),BitsN.B(0xFF,8)]))) andalso (not((BitsN.bit(imm64,61)) = (BitsN.bit(imm64,62)))) then Option.SOME (BitsN.concat @@ -18341,7 +18309,7 @@ fun e_branch (c,(ast,e)) = else BadCode("B: bad offset") else if BitsN.bit(imm32,0) then BadCode("BranchTarget: bad offset") - else if L3.mem(c,[BitsN.B(0xE,4),BitsN.B(0xF,4)]) + else if Set.mem(c,[BitsN.B(0xE,4),BitsN.B(0xF,4)]) then if ((BitsN.<=(BitsN.neg(BitsN.B(0x800,32)),imm32)) andalso (BitsN.<=(imm32,BitsN.B(0x7FE,32)))) andalso (not(e = Enc_Wide)) @@ -18470,7 +18438,7 @@ fun e_branch (c,(ast,e)) = | CompareBranch(nonzero,(n,imm32)) => (if ((BitsN.<=+(imm32,BitsN.B(0x7E,32))) andalso (not((BitsN.bit(imm32,0)) orelse (BitsN.bit(n,3))))) andalso - (L3.mem(e,[Enc_Thumb,Enc_Narrow])) + (Set.mem(e,[Enc_Thumb,Enc_Narrow])) then let val op' = BitsN.fromBit nonzero val i = BitsN.bits(imm32,6,6) @@ -18484,7 +18452,7 @@ fun e_branch (c,(ast,e)) = end else BadCode("CBZ")) | TableBranchByte(is_tbh,(Rm,Rn)) => - (if L3.mem(e,[Enc_Thumb,Enc_Wide]) + (if Set.mem(e,[Enc_Thumb,Enc_Wide]) then let val H = BitsN.fromBit is_tbh in @@ -18494,7 +18462,7 @@ fun e_branch (c,(ast,e)) = end else BadCode("CBZ")) | CheckArray(Rm,n) => - (if L3.mem(e,[Enc_Thumb,Enc_Narrow]) + (if Set.mem(e,[Enc_Thumb,Enc_Narrow]) then let val N = BitsN.bits(n,3,3) val Rn = BitsN.bits(n,2,0) @@ -18505,7 +18473,7 @@ fun e_branch (c,(ast,e)) = | HandlerBranchLink(generate_link,handler_offset) => (if ((BitsN.<=+(handler_offset,BitsN.B(0x1FE0,32))) andalso ((BitsN.bits(handler_offset,4,0)) = (BitsN.B(0x0,5)))) andalso - (L3.mem(e,[Enc_Thumb,Enc_Narrow])) + (Set.mem(e,[Enc_Thumb,Enc_Narrow])) then let val L = BitsN.fromBit generate_link val handler = BitsN.bits(handler_offset,12,5) @@ -18517,7 +18485,7 @@ fun e_branch (c,(ast,e)) = (if (((BitsN.<+(imm32,BitsN.B(0x20,32))) andalso (BitsN.<=+(handler_offset,BitsN.B(0x3E0,32)))) andalso ((BitsN.bits(handler_offset,4,0)) = (BitsN.B(0x0,5)))) andalso - (L3.mem(e,[Enc_Thumb,Enc_Narrow])) + (Set.mem(e,[Enc_Thumb,Enc_Narrow])) then let val imm5 = BitsN.bits(imm32,4,0) val handler = BitsN.bits(handler_offset,9,5) @@ -18529,7 +18497,7 @@ fun e_branch (c,(ast,e)) = (if (((BitsN.<+(imm32,BitsN.B(0x8,32))) andalso (BitsN.<=+(handler_offset,BitsN.B(0x3E0,32)))) andalso ((BitsN.bits(handler_offset,4,0)) = (BitsN.B(0x0,5)))) andalso - (L3.mem(e,[Enc_Thumb,Enc_Narrow])) + (Set.mem(e,[Enc_Thumb,Enc_Narrow])) then let val imm3 = BitsN.bits(imm32,2,0) val handler = BitsN.bits(handler_offset,9,5) @@ -18785,7 +18753,7 @@ fun e_data (c,(ast,e)) = end else BadCode("MOV")) | AddSub(sub,(Rd,(Rn,imm12))) => - (if L3.mem(e,[Enc_Thumb,Enc_Wide]) + (if Set.mem(e,[Enc_Thumb,Enc_Wide]) then let val i = BitsN.bits(imm12,11,11) val imm3 = BitsN.bits(imm12,10,8) @@ -18842,7 +18810,7 @@ fun e_data (c,(ast,e)) = in ARM(BitsN.concat[c,BitsN.B(0x1,3),opc,S,Rn,Rd,imm12]) end - else if ((L3.mem(opc,[BitsN.B(0x4,4),BitsN.B(0x2,4)])) andalso + else if ((Set.mem(opc,[BitsN.B(0x4,4),BitsN.B(0x2,4)])) andalso ((BitsN.bits(imm12,11,3)) = (BitsN.B(0x0,9)))) andalso (not((((setflags = (not(c = (BitsN.B(0xE,4))))) orelse (BitsN.bit(d,3))) orelse (BitsN.bit(n,3))) orelse @@ -18855,7 +18823,7 @@ fun e_data (c,(ast,e)) = in Thumb(BitsN.concat[BitsN.B(0x7,6),S,imm3,Rn,Rd]) end - else if (((L3.mem(opc,[BitsN.B(0x4,4),BitsN.B(0x2,4)])) andalso + else if (((Set.mem(opc,[BitsN.B(0x4,4),BitsN.B(0x2,4)])) andalso (d = n)) andalso ((BitsN.bits(imm12,11,8)) = (BitsN.B(0x0,4)))) andalso (not(((setflags = (not(c = (BitsN.B(0xE,4))))) orelse (BitsN.bit(d,3))) orelse (e = Enc_Wide))) @@ -18878,7 +18846,7 @@ fun e_data (c,(ast,e)) = Thumb(BitsN.concat[BitsN.B(0x109,10),Rn,Rd]) end else if ((((opc = (BitsN.B(0x4,4))) andalso (not setflags)) andalso - (L3.mem(n,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) andalso + (Set.mem(n,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) andalso ((BitsN.bits(imm12,11,8)) = (BitsN.B(0xF,4)))) andalso (not((BitsN.bit(d,3)) orelse (e = Enc_Wide))) then let @@ -18888,7 +18856,7 @@ fun e_data (c,(ast,e)) = in Thumb(BitsN.concat[BitsN.B(0xA,4),S,Rd,imm8]) end - else if ((((L3.mem(opc,[BitsN.B(0x4,4),BitsN.B(0x2,4)])) andalso + else if ((((Set.mem(opc,[BitsN.B(0x4,4),BitsN.B(0x2,4)])) andalso (d = (BitsN.B(0xD,4)))) andalso (n = (BitsN.B(0xD,4)))) andalso ((BitsN.bits(imm12,11,7)) = (BitsN.B(0x1E,5)))) andalso (not(setflags orelse (e = Enc_Wide))) @@ -18953,7 +18921,7 @@ fun e_data (c,(ast,e)) = [c,BitsN.B(0x0,3),opc,S,Rn,Rd,imm5,typ, BitsN.B(0x0,1),Rm]) end - else if (((L3.mem(opc,[BitsN.B(0x2,4),BitsN.B(0x4,4)])) andalso + else if (((Set.mem(opc,[BitsN.B(0x2,4),BitsN.B(0x4,4)])) andalso (shift_t = SRType_LSL)) andalso (shift_n = 0)) andalso (not(((((setflags = (not(c = (BitsN.B(0xE,4))))) orelse (BitsN.bit(d,3))) orelse (BitsN.bit(n,3))) orelse @@ -18966,7 +18934,7 @@ fun e_data (c,(ast,e)) = in Thumb(BitsN.concat[BitsN.B(0x6,6),S,Rm,Rn,Rd]) end - else if ((((L3.mem + else if ((((Set.mem (opc, [BitsN.B(0x0,4),BitsN.B(0x1,4),BitsN.B(0x5,4), BitsN.B(0x6,4),BitsN.B(0xC,4),BitsN.B(0xE,4)])) andalso @@ -19096,7 +19064,7 @@ fun e_data (c,(ast,e)) = in Thumb(BitsN.concat[BitsN.B(0x10F,10),Rm,Rd]) end - else if (L3.mem(shift_t,[SRType_LSL,SRType_LSR,SRType_ASR])) andalso + else if (Set.mem(shift_t,[SRType_LSL,SRType_LSR,SRType_ASR])) andalso (not((((negate orelse (setflags = (not(c = (BitsN.B(0xE,4)))))) orelse (BitsN.bit(m,3))) orelse (BitsN.bit(d,3))) orelse (e = Enc_Wide))) @@ -19711,7 +19679,7 @@ fun e_hint (c,(ast,e)) = fun e_system (c,(ast,e)) = case ast of EnterxLeavex is_enterx => - (if L3.mem(e,[Enc_Thumb,Enc_Wide]) + (if Set.mem(e,[Enc_Thumb,Enc_Wide]) then let val J = BitsN.fromBit is_enterx in @@ -20530,7 +20498,7 @@ fun e_load (c,(ast,e)) = ARM(BitsN.concat [c,BitsN.B(0x4,4),U,BitsN.B(0x3,3),Rn,Rt,imm12]) end - else if (((L3.mem(e,[Enc_Thumb,Enc_Wide])) andalso add) andalso + else if (((Set.mem(e,[Enc_Thumb,Enc_Wide])) andalso add) andalso (not postindex)) andalso (BitsN.<=+(imm32,BitsN.B(0xFF,32))) then let val imm8 = BitsN.bits(imm32,7,0) @@ -20728,7 +20696,7 @@ fun e_load (c,(ast,e)) = ARM(BitsN.concat [c,BitsN.B(0x4,4),U,BitsN.B(0x7,3),Rn,Rt,imm12]) end - else if (((L3.mem(e,[Enc_Thumb,Enc_Wide])) andalso add) andalso + else if (((Set.mem(e,[Enc_Thumb,Enc_Wide])) andalso add) andalso (not postindex)) andalso (BitsN.<=+(imm32,BitsN.B(0xFF,32))) then let val imm8 = BitsN.bits(imm32,7,0) @@ -20763,7 +20731,7 @@ fun e_load (c,(ast,e)) = [c,BitsN.B(0x0,4),U,BitsN.B(0x7,3),Rn,Rt,imm4H, BitsN.B(0xD,4),imm4L]) end - else if (((L3.mem(e,[Enc_Thumb,Enc_Wide])) andalso add) andalso + else if (((Set.mem(e,[Enc_Thumb,Enc_Wide])) andalso add) andalso (not postindex)) andalso (BitsN.<=+(imm32,BitsN.B(0xFF,32))) then let val imm8 = BitsN.bits(imm32,7,0) @@ -20943,7 +20911,7 @@ fun e_load (c,(ast,e)) = [c,BitsN.B(0x0,4),U,BitsN.B(0x7,3),Rn,Rt,imm4H, BitsN.B(0x1,1),S,BitsN.B(0x3,2),imm4L]) end - else if ((L3.mem(e,[Enc_Thumb,Enc_Wide])) andalso add) andalso + else if ((Set.mem(e,[Enc_Thumb,Enc_Wide])) andalso add) andalso (not postindex) then let val imm8 = BitsN.bits(imm32,7,0) @@ -21288,7 +21256,7 @@ fun e_store (c,(ast,e)) = ARM(BitsN.concat [c,BitsN.B(0x4,4),U,BitsN.B(0x2,3),Rn,Rt,imm12]) end - else if (((L3.mem(e,[Enc_Thumb,Enc_Wide])) andalso add) andalso + else if (((Set.mem(e,[Enc_Thumb,Enc_Wide])) andalso add) andalso (not postindex)) andalso (BitsN.<=+(imm32,BitsN.B(0xFF,32))) then let val imm8 = BitsN.bits(imm32,7,0) @@ -21420,7 +21388,7 @@ fun e_store (c,(ast,e)) = ARM(BitsN.concat [c,BitsN.B(0x4,4),U,BitsN.B(0x6,3),Rn,Rt,imm12]) end - else if (((L3.mem(e,[Enc_Thumb,Enc_Wide])) andalso add) andalso + else if (((Set.mem(e,[Enc_Thumb,Enc_Wide])) andalso add) andalso (not postindex)) andalso (BitsN.<=+(imm32,BitsN.B(0xFF,32))) then let val imm8 = BitsN.bits(imm32,7,0) @@ -21559,7 +21527,7 @@ fun e_store (c,(ast,e)) = [c,BitsN.B(0x0,4),U,BitsN.B(0x6,3),Rn,Rt,imm4H, BitsN.B(0xB,4),imm4L]) end - else if ((L3.mem(e,[Enc_Thumb,Enc_Wide])) andalso add) andalso + else if ((Set.mem(e,[Enc_Thumb,Enc_Wide])) andalso add) andalso (not postindex) then let val imm8 = BitsN.bits(imm32,7,0) @@ -21739,11 +21707,11 @@ fun instructionEncode (c,(ast,e)) = | Hint h => e_hint(c,(h,e)) | VFP v => e_vfp(c,(v,e)) | IfThen(firstcond,mask) => - (if L3.mem(e,[Enc_Thumb,Enc_Narrow]) + (if Set.mem(e,[Enc_Thumb,Enc_Narrow]) then Thumb(BitsN.concat[BitsN.B(0xBF,8),firstcond,mask]) else BadCode("IfThen")) | Divide(unsigned,(Rd,(Rn,Rm))) => - (if L3.mem(e,[Enc_Thumb,Enc_Wide]) + (if Set.mem(e,[Enc_Thumb,Enc_Wide]) then let val U = BitsN.fromBit unsigned in @@ -22001,7 +21969,7 @@ fun p_label s = let val (l,r) = L3.splitl - (fn c => (Char.isAlphaNum c) orelse (L3.mem(c,[#"_",#"."])),t) + (fn c => (Char.isAlphaNum c) orelse (Set.mem(c,[#"_",#"."])),t) in if ((r = ("")) andalso (not(l = ("")))) andalso (not(Char.isDigit(L3.strHd l))) @@ -22035,7 +22003,7 @@ fun p_cond s = fun p_suffix s = case L3.uncurry String.fields (fn c => c = #".",s) of [cond,s] => - (case (p_cond cond,L3.mem(s,["w","n","f32","f64","32","64"])) of + (case (p_cond cond,Set.mem(s,["w","n","f32","f64","32","64"])) of (Option.SOME c,true) => Option.SOME(c,s) | _ => NONE) | [cond] => @@ -22119,10 +22087,10 @@ fun p_fp_register (single,s) = | _ => NONE; fun p_any_fp_register (s,t) = - case (p_fp_register(true,s),L3.mem(t,["","32"])) of + case (p_fp_register(true,s),Set.mem(t,["","32"])) of (Option.SOME r,true) => Option.SOME(true,r) | _ => - (case (p_fp_register(false,s),L3.mem(t,["","64"])) of + (case (p_fp_register(false,s),Set.mem(t,["","64"])) of (Option.SOME r,true) => Option.SOME(false,r) | _ => NONE); @@ -22141,7 +22109,7 @@ fun p_shift_amount (typ,(h,s)) = then case p_unbounded_immediate s of Option.SOME n => (if (Nat.<(n,32)) orelse - ((n = 32) andalso (L3.mem(typ,[SRType_LSR,SRType_ASR]))) + ((n = 32) andalso (Set.mem(typ,[SRType_LSR,SRType_ASR]))) then ("",(typ,NAT n)) else ("shift amount too large",(SRType_LSL,NAT 0))) | NONE => @@ -22169,7 +22137,7 @@ fun p_rotation s = (if Char.isSpace h then case p_unbounded_immediate(String.implode t) of Option.SOME n => - (if L3.mem(n,[0,8,16,24]) + (if Set.mem(n,[0,8,16,24]) then ("",n) else ("rotation not 0, 8, 16 or 24",0)) | NONE => ("syntax error",0) @@ -22292,7 +22260,7 @@ fun p_shift_full (c,(typ,(setflags,l))) = Option.SOME n => (if (Nat.<(n,32)) orelse ((n = 32) andalso - (L3.mem(typ,[SRType_LSR,SRType_ASR]))) + (Set.mem(typ,[SRType_LSR,SRType_ASR]))) then OK(c, Data (ShiftImmediate @@ -23383,7 +23351,7 @@ fun p_ldm_stm (c,(load,(inc,(index,l)))) = let val (r,wb) = L3.splitr(fn c => c = #"!",stripSpaces h) in - case (p_register r,(p_registers t,L3.mem(wb,["","!"]))) of + case (p_register r,(p_registers t,Set.mem(wb,["","!"]))) of (Option.SOME rn,(Option.SOME(false,w),true)) => let val r = (inc,(index,(wb = ("!"),(rn,w)))) @@ -23687,7 +23655,7 @@ fun p_rfe (c,(increment,(wordhigher,l))) = let val (r,wb) = L3.splitr(fn c => c = #"!",stripSpaces h) in - case (p_register r,L3.mem(wb,["","!"])) of + case (p_register r,Set.mem(wb,["","!"])) of (Option.SOME n,true) => OK(c, System @@ -23703,7 +23671,7 @@ fun p_srs (c,(increment,(wordhigher,l))) = let val (r,wb) = L3.splitr(fn c => c = #"!",stripSpaces h) in - case (p_register r,(L3.mem(wb,["","!"]),p_immediate_number 5 m)) of + case (p_register r,(Set.mem(wb,["","!"]),p_immediate_number 5 m)) of (Option.SOME(BitsN.B(0xD,4)),(true,Option.SOME(ok,mode))) => (if ok then OK(c, @@ -23785,7 +23753,7 @@ fun p_vmov (c,l) = case (p_suffix c,l) of (Option.SOME(c,s),[d,v]) => let - val single = L3.mem(s,["","f32"]) + val single = Set.mem(s,["","f32"]) in if single orelse (s = ("f64")) then case p_fp_register(single,d) of @@ -23808,7 +23776,7 @@ fun p_vcmpe (c,l) = case (p_suffix c,l) of (Option.SOME(c,s),[d,v]) => let - val single = L3.mem(s,["","f32"]) + val single = Set.mem(s,["","f32"]) in if single orelse (s = ("f64")) then case p_fp_register(single,d) of @@ -23838,7 +23806,7 @@ fun p_fp3 (c,(opc,l)) = case p_suffix c of Option.SOME(c,s) => let - val single = L3.mem(s,["","f32"]) + val single = Set.mem(s,["","f32"]) val double = not single in if single orelse (s = ("f64")) diff --git a/examples/l3-machine-code/arm8/model/arm8.sig b/examples/l3-machine-code/arm8/model/arm8.sig index bd0c715b38..83f33a9593 100644 --- a/examples/l3-machine-code/arm8/model/arm8.sig +++ b/examples/l3-machine-code/arm8/model/arm8.sig @@ -1,4 +1,4 @@ -(* arm8 - generated by L<3> - Fri Oct 10 16:45:06 2014 *) +(* arm8 - generated by L<3> - Tue Nov 18 15:32:41 2014 *) signature arm8 = sig diff --git a/examples/l3-machine-code/arm8/model/arm8.sml b/examples/l3-machine-code/arm8/model/arm8.sml index 34804d9f7f..e00993e3b8 100644 --- a/examples/l3-machine-code/arm8/model/arm8.sml +++ b/examples/l3-machine-code/arm8/model/arm8.sml @@ -1,4 +1,4 @@ -(* arm8 - generated by L<3> - Fri Oct 10 16:45:06 2014 *) +(* arm8 - generated by L<3> - Tue Nov 18 15:32:41 2014 *) structure arm8 :> arm8 = struct @@ -6324,28 +6324,32 @@ fun e_data (imm_enc,i) = [e_sf 64 sf,BitsN.fromBit opc,BitsN.fromBit s,BitsN.B(0x59,8), rm,BitsN.fromNat(Cast.ExtendTypeToNat sty,3),imm3,rn,rd]) | AddSubImmediate''32(sf,(opc,(s,(imm,(rn,rd))))) => - (if (BitsN.bits(imm,11,0)) = (BitsN.B(0x0,12)) - then if (BitsN.bits(imm,31,24)) = (BitsN.B(0x0,8)) + (if (BitsN.&&(imm,BitsN.B(0xFFF,32))) = (BitsN.B(0x0,32)) + then if (BitsN.&&(imm,BitsN.~(BitsN.B(0xFFFFFF,32)))) = + (BitsN.B(0x0,32)) then ARM8 (BitsN.concat [e_sf 32 sf,BitsN.fromBit opc,BitsN.fromBit s, BitsN.B(0x45,7),BitsN.bits(imm,23,12),rn,rd]) else BadCode("AddSubImmediate") - else if (BitsN.bits(imm,31,12)) = (BitsN.B(0x0,20)) + else if (BitsN.&&(imm,BitsN.~(BitsN.B(0xFFF,32)))) = + (BitsN.B(0x0,32)) then ARM8 (BitsN.concat [e_sf 32 sf,BitsN.fromBit opc,BitsN.fromBit s, BitsN.B(0x44,7),BitsN.bits(imm,11,0),rn,rd]) else BadCode("AddSubImmediate")) | AddSubImmediate''64(sf,(opc,(s,(imm,(rn,rd))))) => - (if (BitsN.bits(imm,11,0)) = (BitsN.B(0x0,12)) - then if (BitsN.bits(imm,31,24)) = (BitsN.B(0x0,8)) + (if (BitsN.&&(imm,BitsN.B(0xFFF,64))) = (BitsN.B(0x0,64)) + then if (BitsN.&&(imm,BitsN.~(BitsN.B(0xFFFFFF,64)))) = + (BitsN.B(0x0,64)) then ARM8 (BitsN.concat [e_sf 64 sf,BitsN.fromBit opc,BitsN.fromBit s, BitsN.B(0x45,7),BitsN.bits(imm,23,12),rn,rd]) else BadCode("AddSubImmediate") - else if (BitsN.bits(imm,31,12)) = (BitsN.B(0x0,20)) + else if (BitsN.&&(imm,BitsN.~(BitsN.B(0xFFF,64)))) = + (BitsN.B(0x0,64)) then ARM8 (BitsN.concat [e_sf 64 sf,BitsN.fromBit opc,BitsN.fromBit s, @@ -6629,7 +6633,7 @@ fun e_branch i = val imm26 = BitsN.bits(imm,27,2) in if (imm = (BitsN.signExtend 64 (BitsN.@@(imm26,BitsN.B(0x0,2))))) andalso - (L3.mem(btype,[BranchType_CALL,BranchType_JMP])) + (Set.mem(btype,[BranchType_CALL,BranchType_JMP])) then ARM8 (BitsN.concat [BitsN.fromBit(btype = BranchType_CALL), @@ -6731,14 +6735,15 @@ fun e_LoadStoreImmediate (acctype, (signed,(wback,(postindex,(unsigned_offset,(offset,(rn,rt)))))))))) = let + val sz = if memop = MemOp_PREFETCH then BitsN.B(0x3,2) else size val imm9 = BitsN.bits(offset,8,0) + val imm12 = BitsN.bits(LSR 64 (offset,BitsN.toNat sz),11,0) val opc = if memop = MemOp_STORE then BitsN.B(0x0,2) else if (memop = MemOp_LOAD) andalso (not signed) then BitsN.B(0x1,2) else BitsN.@@(BitsN.B(0x1,1),BitsN.fromBit regsize_word) - val sz = if memop = MemOp_PREFETCH then BitsN.B(0x3,2) else size in if wback then if (offset = (BitsN.signExtend 64 imm9)) andalso @@ -6750,16 +6755,10 @@ fun e_LoadStoreImmediate else BadCode("LoadStoreImmediate") else if postindex then BadCode("LoadStoreImmediate") - else if unsigned_offset - then let - val imm12 = BitsN.bits(LSR 64 (offset,BitsN.toNat sz),11,0) - in - if (offset = - (LSL 64 (BitsN.zeroExtend 64 imm12,BitsN.toNat sz))) andalso - (acctype = AccType_NORMAL) - then ARM8(BitsN.concat[sz,BitsN.B(0x39,6),opc,imm12,rn,rt]) - else BadCode("LoadStoreImmediate") - end + else if (unsigned_offset andalso + (offset = (LSL 64 (BitsN.zeroExtend 64 imm12,BitsN.toNat sz)))) andalso + (acctype = AccType_NORMAL) + then ARM8(BitsN.concat[sz,BitsN.B(0x39,6),opc,imm12,rn,rt]) else if offset = (BitsN.signExtend 64 imm9) then ARM8 (BitsN.concat @@ -6912,8 +6911,8 @@ fun e_load_store i = val imm7 = BitsN.bits(LSR 64 (offset,scale),6,0) in if ((((sf = (BitsN.B(0x1,1))) = ((BitsN.size size) = 64)) andalso - (L3.mem(memop,[MemOp_LOAD,MemOp_STORE]))) andalso - (L3.mem(acctype,[AccType_STREAM,AccType_NORMAL]))) andalso + (Set.mem(memop,[MemOp_LOAD,MemOp_STORE]))) andalso + (Set.mem(acctype,[AccType_STREAM,AccType_NORMAL]))) andalso (offset = (LSL 64 (BitsN.signExtend 64 imm7,scale))) then ARM8 (BitsN.concat @@ -6935,8 +6934,8 @@ fun e_load_store i = val imm7 = BitsN.bits(LSR 64 (offset,scale),6,0) in if ((((sf = (BitsN.B(0x1,1))) = ((BitsN.size size) = 64)) andalso - (L3.mem(memop,[MemOp_LOAD,MemOp_STORE]))) andalso - (L3.mem(acctype,[AccType_STREAM,AccType_NORMAL]))) andalso + (Set.mem(memop,[MemOp_LOAD,MemOp_STORE]))) andalso + (Set.mem(acctype,[AccType_STREAM,AccType_NORMAL]))) andalso (offset = (LSL 64 (BitsN.signExtend 64 imm7,scale))) then ARM8 (BitsN.concat @@ -6956,8 +6955,8 @@ fun e_load_store i = | 32 => size = (BitsN.B(0x2,8)) | _ => size = (BitsN.B(0x3,8)) in - if (sizeok andalso (L3.mem(memop,[MemOp_LOAD,MemOp_STORE]))) andalso - (L3.mem(acctype,[AccType_ORDERED,AccType_ATOMIC])) + if (sizeok andalso (Set.mem(memop,[MemOp_LOAD,MemOp_STORE]))) andalso + (Set.mem(acctype,[AccType_ORDERED,AccType_ATOMIC])) then ARM8 (BitsN.concat [BitsN.fromNat(BitsN.toNat size,2),BitsN.B(0x8,6), @@ -6978,8 +6977,8 @@ fun e_load_store i = | 32 => size = (BitsN.B(0x2,16)) | _ => size = (BitsN.B(0x3,16)) in - if (sizeok andalso (L3.mem(memop,[MemOp_LOAD,MemOp_STORE]))) andalso - (L3.mem(acctype,[AccType_ORDERED,AccType_ATOMIC])) + if (sizeok andalso (Set.mem(memop,[MemOp_LOAD,MemOp_STORE]))) andalso + (Set.mem(acctype,[AccType_ORDERED,AccType_ATOMIC])) then ARM8 (BitsN.concat [BitsN.fromNat(BitsN.toNat size,2),BitsN.B(0x8,6), @@ -7000,8 +6999,8 @@ fun e_load_store i = | 32 => size = (BitsN.B(0x2,32)) | _ => size = (BitsN.B(0x3,32)) in - if (sizeok andalso (L3.mem(memop,[MemOp_LOAD,MemOp_STORE]))) andalso - (L3.mem(acctype,[AccType_ORDERED,AccType_ATOMIC])) + if (sizeok andalso (Set.mem(memop,[MemOp_LOAD,MemOp_STORE]))) andalso + (Set.mem(acctype,[AccType_ORDERED,AccType_ATOMIC])) then ARM8 (BitsN.concat [BitsN.fromNat(BitsN.toNat size,2),BitsN.B(0x8,6), @@ -7022,8 +7021,8 @@ fun e_load_store i = | 32 => size = (BitsN.B(0x2,64)) | _ => size = (BitsN.B(0x3,64)) in - if (sizeok andalso (L3.mem(memop,[MemOp_LOAD,MemOp_STORE]))) andalso - (L3.mem(acctype,[AccType_ORDERED,AccType_ATOMIC])) + if (sizeok andalso (Set.mem(memop,[MemOp_LOAD,MemOp_STORE]))) andalso + (Set.mem(acctype,[AccType_ORDERED,AccType_ATOMIC])) then ARM8 (BitsN.concat [BitsN.fromNat(BitsN.toNat size,2),BitsN.B(0x8,6), @@ -7043,8 +7042,8 @@ fun e_load_store i = then BitsN.B(0x2,64) else BitsN.B(0x3,64)) in - if (sizeok andalso (L3.mem(memop,[MemOp_LOAD,MemOp_STORE]))) andalso - (L3.mem(acctype,[AccType_ORDERED,AccType_ATOMIC])) + if (sizeok andalso (Set.mem(memop,[MemOp_LOAD,MemOp_STORE]))) andalso + (Set.mem(acctype,[AccType_ORDERED,AccType_ATOMIC])) then ARM8 (BitsN.concat [BitsN.fromNat(BitsN.toNat size,2),BitsN.B(0x10,7), @@ -7062,8 +7061,8 @@ fun e_load_store i = then BitsN.B(0x2,128) else BitsN.B(0x3,128)) in - if (sizeok andalso (L3.mem(memop,[MemOp_LOAD,MemOp_STORE]))) andalso - (L3.mem(acctype,[AccType_ORDERED,AccType_ATOMIC])) + if (sizeok andalso (Set.mem(memop,[MemOp_LOAD,MemOp_STORE]))) andalso + (Set.mem(acctype,[AccType_ORDERED,AccType_ATOMIC])) then ARM8 (BitsN.concat [BitsN.fromNat(BitsN.toNat size,2),BitsN.B(0x10,7), @@ -7184,7 +7183,7 @@ fun p_label s = let val (l,r) = L3.splitl - (fn c => (Char.isAlphaNum c) orelse (L3.mem(c,[#"_",#"."])),t) + (fn c => (Char.isAlphaNum c) orelse (Set.mem(c,[#"_",#"."])),t) in if ((r = ("")) andalso (not(l = ("")))) andalso (not(Char.isDigit(L3.strHd l))) @@ -7382,7 +7381,7 @@ fun p_extend2 (size,(wide,s)) = | _ => NONE in case r of - Option.SOME(_,v) => (if L3.mem(v,[0,size]) then r else NONE) + Option.SOME(_,v) => (if Set.mem(v,[0,size]) then r else NONE) | NONE => NONE end; @@ -7919,7 +7918,7 @@ fun p_extend_register (wm,(ext,(BitsN.fromNat(amount,3),(wn,wd))))))))) else FAIL("syntax error: add, sub")) | (Option.SOME(wide,(rd,rn)),NONE) => - (if is_lsl andalso (L3.mem(amount,[0,12])) + (if is_lsl andalso (Set.mem(amount,[0,12])) then case p_immediate 12 m of Option.SOME(true,imm12) => (if wide @@ -8344,7 +8343,7 @@ fun p_call (typ,l) = | Option.SOME _ => FAIL("immediate too large: hint") | _ => FAIL("syntax error: svc, hvc, smc, hlt, brk, dcpsN")) | [] => - if L3.mem(typ,[1,2,3]) + if Set.mem(typ,[1,2,3]) then OK(Debug(DebugSwitch(BitsN.fromNat(typ,2)))) else FAIL("syntax error: svc, hvc, smc, hlt, brk") | _ => FAIL("syntax error: svc, hvc, smc, hlt, brk, dcpsN"); @@ -8425,7 +8424,7 @@ fun p_mov l = val i = (L3.strHd n) = #"#" val orr = (LogicalOp_ORR,(false,(false,[d,wzr_xzr d,n]))) in - if (L3.mem(d,s)) orelse (L3.mem(n,s)) + if (Set.mem(d,s)) orelse (Set.mem(n,s)) then if i then p_and_etc orr else p_add_sub(false,(false,l @ ["#0"])) @@ -9042,7 +9041,7 @@ fun s_data ast = s_regp(wide,n),", ", s_regz (wide andalso - (L3.mem(extend_type,[ExtendType_UXTX,ExtendType_SXTX])),m), + (Set.mem(extend_type,[ExtendType_UXTX,ExtendType_SXTX])),m), if ((n = (BitsN.B(0x1F,5))) orelse ((not setflags) andalso (d = (BitsN.B(0x1F,5))))) andalso ((wide andalso (extend_type = ExtendType_UXTX)) orelse @@ -9066,7 +9065,7 @@ fun s_data ast = s_regp(wide,n),", ", s_regz (wide andalso - (L3.mem(extend_type,[ExtendType_UXTX,ExtendType_SXTX])),m), + (Set.mem(extend_type,[ExtendType_UXTX,ExtendType_SXTX])),m), if ((n = (BitsN.B(0x1F,5))) orelse ((not setflags) andalso (d = (BitsN.B(0x1F,5))))) andalso ((wide andalso (extend_type = ExtendType_UXTX)) orelse @@ -9850,8 +9849,8 @@ fun s_load_store ast = String.concat [s_regz(wide,rt),", [",s_regp(true,rn),", ", s_regz - (L3.mem(extend_type,[ExtendType_UXTX,ExtendType_SXTX]), - rm), + (Set.mem + (extend_type,[ExtendType_UXTX,ExtendType_SXTX]),rm), if extend_type = ExtendType_UXTX then if shift = 0 then "" @@ -9883,8 +9882,8 @@ fun s_load_store ast = String.concat [s_regz(wide,rt),", [",s_regp(true,rn),", ", s_regz - (L3.mem(extend_type,[ExtendType_UXTX,ExtendType_SXTX]), - rm), + (Set.mem + (extend_type,[ExtendType_UXTX,ExtendType_SXTX]),rm), if extend_type = ExtendType_UXTX then if shift = 0 then "" @@ -9916,8 +9915,8 @@ fun s_load_store ast = String.concat [s_regz(wide,rt),", [",s_regp(true,rn),", ", s_regz - (L3.mem(extend_type,[ExtendType_UXTX,ExtendType_SXTX]), - rm), + (Set.mem + (extend_type,[ExtendType_UXTX,ExtendType_SXTX]),rm), if extend_type = ExtendType_UXTX then if shift = 0 then "" @@ -9949,8 +9948,8 @@ fun s_load_store ast = String.concat [s_regz(wide,rt),", [",s_regp(true,rn),", ", s_regz - (L3.mem(extend_type,[ExtendType_UXTX,ExtendType_SXTX]), - rm), + (Set.mem + (extend_type,[ExtendType_UXTX,ExtendType_SXTX]),rm), if extend_type = ExtendType_UXTX then if shift = 0 then "" diff --git a/examples/l3-machine-code/arm8/model/arm8Script.sml b/examples/l3-machine-code/arm8/model/arm8Script.sml index e770c22eef..6b1d8027f8 100644 --- a/examples/l3-machine-code/arm8/model/arm8Script.sml +++ b/examples/l3-machine-code/arm8/model/arm8Script.sml @@ -1,4 +1,4 @@ -(* arm8Script.sml - generated by L<3> - Tue Oct 14 10:39:24 2014 *) +(* arm8Script.sml - generated by L<3> - Thu Nov 06 16:00:59 2014 *) open HolKernel boolLib bossLib Import val () = Import.start "arm8" @@ -355,6 +355,10 @@ val _ = Construct ("MemoryBarrier",[PTy(CTy"MemBarrierOp",F4)]),("Reserved",[]), ("System",[CTy"System"]),("Unallocated",[])])] ; +val _ = Construct [("MachineCode",[("ARM8",[F32]),("BadCode",[sTy])])] +; +val _ = Construct [("imm32_64",[("Imm32",[F32]),("Imm64",[F64])])] +; val _ = Construct [("exception", [("ALIGNMENT_FAULT",[]),("ASSERT",[sTy]),("NoException",[]), @@ -8040,5 +8044,1256 @@ val Next_def = Def ("PC", TP[qVar"s",Bop(Add,Dest("PC",F64,qVar"s"),LW(4,64))]), qVar"s")]))) +; +val e_sf_def = Def + ("e_sf",Var("sf",BTy"N"),Mop(Cast F1,EQ(Mop(Size,LY(0,"N")),LN 64))) +; +val EncodeLogicalOp_def = Def + ("EncodeLogicalOp",TP[Var("opc",CTy"LogicalOp"),bVar"setflags"], + CS(TP[Var("opc",CTy"LogicalOp"),bVar"setflags"], + [(TP[LC("LogicalOp_AND",CTy"LogicalOp"),LF],Mop(Some,LW(0,2))), + (TP[LC("LogicalOp_ORR",CTy"LogicalOp"),LF],Mop(Some,LW(1,2))), + (TP[LC("LogicalOp_EOR",CTy"LogicalOp"),LF],Mop(Some,LW(2,2))), + (TP[LC("LogicalOp_AND",CTy"LogicalOp"),LT],Mop(Some,LW(3,2))), + (AVar(PTy(CTy"LogicalOp",bTy)),LO(FTy 2))])) +; +val e_data_def = Def + ("e_data", + TP[Var("imm_enc",ATy(CTy"imm32_64",OTy(PTy(F1,PTy(FTy 6,FTy 6))))), + Var("i",CTy"Data")], + CS(Var("i",CTy"Data"), + [(Call + ("AddSubShiftedRegister@32",CTy"Data", + TP[AVar F32,bVar"opc",bVar"s",Var("sh",CTy"ShiftType"), + Var("rm",FTy 5),Var("imm6",FTy 6),Var("rn",FTy 5), + Var("rd",FTy 5)]), + ITE(Bop(Bit,Var("imm6",FTy 6),LN 5), + Call("BadCode",CTy"MachineCode",LS"AddSubShiftedRegister32"), + Call + ("ARM8",CTy"MachineCode", + CC[LW(0,1),Mop(Cast F1,bVar"opc"),Mop(Cast F1,bVar"s"), + LW(11,5),Mop(Cast(FTy 2),Var("sh",CTy"ShiftType")), + LW(0,1),Var("rm",FTy 5),Var("imm6",FTy 6), + Var("rn",FTy 5),Var("rd",FTy 5)]))), + (Call + ("AddSubShiftedRegister@64",CTy"Data", + TP[AVar F64,bVar"opc",bVar"s",Var("sh",CTy"ShiftType"), + Var("rm",FTy 5),Var("imm6",FTy 6),Var("rn",FTy 5), + Var("rd",FTy 5)]), + Call + ("ARM8",CTy"MachineCode", + CC[LW(1,1),Mop(Cast F1,bVar"opc"),Mop(Cast F1,bVar"s"), + LW(11,5),Mop(Cast(FTy 2),Var("sh",CTy"ShiftType")),LW(0,1), + Var("rm",FTy 5),Var("imm6",FTy 6),Var("rn",FTy 5), + Var("rd",FTy 5)])), + (Call + ("AddSubExtendRegister@32",CTy"Data", + TP[Var("sf",F32),bVar"opc",bVar"s",Var("rm",FTy 5), + Var("sty",CTy"ExtendType"),Var("imm3",FTy 3), + Var("rn",FTy 5),Var("rd",FTy 5)]), + Call + ("ARM8",CTy"MachineCode", + CC[Call("e_sf",F1,Var("sf",F32)),Mop(Cast F1,bVar"opc"), + Mop(Cast F1,bVar"s"),LW(89,8),Var("rm",FTy 5), + Mop(Cast(FTy 3),Var("sty",CTy"ExtendType")), + Var("imm3",FTy 3),Var("rn",FTy 5),Var("rd",FTy 5)])), + (Call + ("AddSubExtendRegister@64",CTy"Data", + TP[Var("sf",F64),bVar"opc",bVar"s",Var("rm",FTy 5), + Var("sty",CTy"ExtendType"),Var("imm3",FTy 3), + Var("rn",FTy 5),Var("rd",FTy 5)]), + Call + ("ARM8",CTy"MachineCode", + CC[Call("e_sf",F1,Var("sf",F64)),Mop(Cast F1,bVar"opc"), + Mop(Cast F1,bVar"s"),LW(89,8),Var("rm",FTy 5), + Mop(Cast(FTy 3),Var("sty",CTy"ExtendType")), + Var("imm3",FTy 3),Var("rn",FTy 5),Var("rd",FTy 5)])), + (Call + ("AddSubImmediate@32",CTy"Data", + TP[Var("sf",F32),bVar"opc",bVar"s",Var("imm",F32), + Var("rn",FTy 5),Var("rd",FTy 5)]), + ITB([(EQ(Bop(BAnd,Var("imm",F32),LW(4095,32)),LW(0,32)), + ITE(EQ(Bop(BAnd,Var("imm",F32),Mop(BNot,LW(16777215,32))), + LW(0,32)), + Call + ("ARM8",CTy"MachineCode", + CC[Call("e_sf",F1,Var("sf",F32)), + Mop(Cast F1,bVar"opc"),Mop(Cast F1,bVar"s"), + LW(69,7),EX(Var("imm",F32),LN 23,LN 12,FTy 12), + Var("rn",FTy 5),Var("rd",FTy 5)]), + Call("BadCode",CTy"MachineCode",LS"AddSubImmediate"))), + (EQ(Bop(BAnd,Var("imm",F32),Mop(BNot,LW(4095,32))),LW(0,32)), + Call + ("ARM8",CTy"MachineCode", + CC[Call("e_sf",F1,Var("sf",F32)),Mop(Cast F1,bVar"opc"), + Mop(Cast F1,bVar"s"),LW(68,7), + EX(Var("imm",F32),LN 11,LN 0,FTy 12),Var("rn",FTy 5), + Var("rd",FTy 5)]))], + Call("BadCode",CTy"MachineCode",LS"AddSubImmediate"))), + (Call + ("AddSubImmediate@64",CTy"Data", + TP[Var("sf",F64),bVar"opc",bVar"s",Var("imm",F64), + Var("rn",FTy 5),Var("rd",FTy 5)]), + ITB([(EQ(Bop(BAnd,Var("imm",F64),LW(4095,64)),LW(0,64)), + ITE(EQ(Bop(BAnd,Var("imm",F64),Mop(BNot,LW(16777215,64))), + LW(0,64)), + Call + ("ARM8",CTy"MachineCode", + CC[Call("e_sf",F1,Var("sf",F64)), + Mop(Cast F1,bVar"opc"),Mop(Cast F1,bVar"s"), + LW(69,7),EX(Var("imm",F64),LN 23,LN 12,FTy 12), + Var("rn",FTy 5),Var("rd",FTy 5)]), + Call("BadCode",CTy"MachineCode",LS"AddSubImmediate"))), + (EQ(Bop(BAnd,Var("imm",F64),Mop(BNot,LW(4095,64))),LW(0,64)), + Call + ("ARM8",CTy"MachineCode", + CC[Call("e_sf",F1,Var("sf",F64)),Mop(Cast F1,bVar"opc"), + Mop(Cast F1,bVar"s"),LW(68,7), + EX(Var("imm",F64),LN 11,LN 0,FTy 12),Var("rn",FTy 5), + Var("rd",FTy 5)]))], + Call("BadCode",CTy"MachineCode",LS"AddSubImmediate"))), + (Call + ("AddSubCarry@32",CTy"Data", + TP[AVar F32,bVar"opc",bVar"s",Var("rm",FTy 5),Var("rn",FTy 5), + Var("rd",FTy 5)]), + Call + ("ARM8",CTy"MachineCode", + CC[LW(0,1),Mop(Cast F1,bVar"opc"),Mop(Cast F1,bVar"s"), + LW(208,8),Var("rm",FTy 5),LW(0,6),Var("rn",FTy 5), + Var("rd",FTy 5)])), + (Call + ("AddSubCarry@64",CTy"Data", + TP[AVar F64,bVar"opc",bVar"s",Var("rm",FTy 5),Var("rn",FTy 5), + Var("rd",FTy 5)]), + Call + ("ARM8",CTy"MachineCode", + CC[LW(1,1),Mop(Cast F1,bVar"opc"),Mop(Cast F1,bVar"s"), + LW(208,8),Var("rm",FTy 5),LW(0,6),Var("rn",FTy 5), + Var("rd",FTy 5)])), + (Call + ("LogicalShiftedRegister@32",CTy"Data", + TP[Var("sf",F32),Var("opc",CTy"LogicalOp"),bVar"invert", + bVar"s",Var("sh",CTy"ShiftType"),nVar"imm",Var("rm",FTy 5), + Var("rn",FTy 5),Var("rd",FTy 5)]), + CS(Call + ("EncodeLogicalOp",OTy(FTy 2), + TP[Var("opc",CTy"LogicalOp"),bVar"s"]), + [(Mop(Some,Var("opc",FTy 2)), + Let(Var("imm6",FTy 6),Mop(Cast(FTy 6),nVar"imm"), + ITE(EQ(nVar"imm",Mop(Cast nTy,Var("imm6",FTy 6))), + Call + ("ARM8",CTy"MachineCode", + CC[Call("e_sf",F1,Var("sf",F32)),Var("opc",FTy 2), + LW(10,5), + Mop(Cast(FTy 2),Var("sh",CTy"ShiftType")), + Mop(Cast F1,bVar"invert"),Var("rm",FTy 5), + Var("imm6",FTy 6),Var("rn",FTy 5), + Var("rd",FTy 5)]), + Call + ("BadCode",CTy"MachineCode", + LS"LogicalShiftedRegister")))), + (LO(FTy 2), + Call("BadCode",CTy"MachineCode",LS"LogicalShiftedRegister"))])), + (Call + ("LogicalShiftedRegister@64",CTy"Data", + TP[Var("sf",F64),Var("opc",CTy"LogicalOp"),bVar"invert", + bVar"s",Var("sh",CTy"ShiftType"),nVar"imm",Var("rm",FTy 5), + Var("rn",FTy 5),Var("rd",FTy 5)]), + CS(Call + ("EncodeLogicalOp",OTy(FTy 2), + TP[Var("opc",CTy"LogicalOp"),bVar"s"]), + [(Mop(Some,Var("opc",FTy 2)), + Let(Var("imm6",FTy 6),Mop(Cast(FTy 6),nVar"imm"), + ITE(EQ(nVar"imm",Mop(Cast nTy,Var("imm6",FTy 6))), + Call + ("ARM8",CTy"MachineCode", + CC[Call("e_sf",F1,Var("sf",F64)),Var("opc",FTy 2), + LW(10,5), + Mop(Cast(FTy 2),Var("sh",CTy"ShiftType")), + Mop(Cast F1,bVar"invert"),Var("rm",FTy 5), + Var("imm6",FTy 6),Var("rn",FTy 5), + Var("rd",FTy 5)]), + Call + ("BadCode",CTy"MachineCode", + LS"LogicalShiftedRegister")))), + (LO(FTy 2), + Call("BadCode",CTy"MachineCode",LS"LogicalShiftedRegister"))])), + (Call + ("LogicalImmediate@32",CTy"Data", + TP[AVar F32,Var("opc",CTy"LogicalOp"),bVar"s",Var("imm",F32), + Var("rn",FTy 5),Var("rd",FTy 5)]), + CS(TP[Apply + (Var("imm_enc", + ATy(CTy"imm32_64",OTy(PTy(F1,PTy(FTy 6,FTy 6))))), + Call("Imm32",CTy"imm32_64",Var("imm",F32))), + Call + ("EncodeLogicalOp",OTy(FTy 2), + TP[Var("opc",CTy"LogicalOp"),bVar"s"])], + [(TP[Mop(Some,TP[AVar F1,Var("imms",FTy 6),Var("immr",FTy 6)]), + Mop(Some,Var("opc",FTy 2))], + Call + ("ARM8",CTy"MachineCode", + CC[LW(0,1),Var("opc",FTy 2),LW(72,7),Var("immr",FTy 6), + Var("imms",FTy 6),Var("rn",FTy 5),Var("rd",FTy 5)])), + (AVar(PTy(OTy(PTy(F1,PTy(FTy 6,FTy 6))),OTy(FTy 2))), + Call("BadCode",CTy"MachineCode",LS"LogicalImmediate32"))])), + (Call + ("LogicalImmediate@64",CTy"Data", + TP[AVar F64,Var("opc",CTy"LogicalOp"),bVar"s",Var("imm",F64), + Var("rn",FTy 5),Var("rd",FTy 5)]), + CS(TP[Apply + (Var("imm_enc", + ATy(CTy"imm32_64",OTy(PTy(F1,PTy(FTy 6,FTy 6))))), + Call("Imm64",CTy"imm32_64",Var("imm",F64))), + Call + ("EncodeLogicalOp",OTy(FTy 2), + TP[Var("opc",CTy"LogicalOp"),bVar"s"])], + [(TP[Mop(Some, + TP[Var("N",F1),Var("imms",FTy 6),Var("immr",FTy 6)]), + Mop(Some,Var("opc",FTy 2))], + Call + ("ARM8",CTy"MachineCode", + CC[LW(1,1),Var("opc",FTy 2),LW(36,6),Var("N",F1), + Var("immr",FTy 6),Var("imms",FTy 6),Var("rn",FTy 5), + Var("rd",FTy 5)])), + (AVar(PTy(OTy(PTy(F1,PTy(FTy 6,FTy 6))),OTy(FTy 2))), + Call("BadCode",CTy"MachineCode",LS"LogicalImmediate64"))])), + (Call + ("Shift@32",CTy"Data", + TP[AVar F32,Var("sh",CTy"ShiftType"),Var("rm",FTy 5), + Var("rn",FTy 5),Var("rd",FTy 5)]), + Call + ("ARM8",CTy"MachineCode", + CC[LW(214,11),Var("rm",FTy 5),LW(2,4), + Mop(Cast(FTy 2),Var("sh",CTy"ShiftType")),Var("rn",FTy 5), + Var("rd",FTy 5)])), + (Call + ("Shift@64",CTy"Data", + TP[AVar F64,Var("sh",CTy"ShiftType"),Var("rm",FTy 5), + Var("rn",FTy 5),Var("rd",FTy 5)]), + Call + ("ARM8",CTy"MachineCode", + CC[LW(1238,11),Var("rm",FTy 5),LW(2,4), + Mop(Cast(FTy 2),Var("sh",CTy"ShiftType")),Var("rn",FTy 5), + Var("rd",FTy 5)])), + (Call + ("MoveWide@32",CTy"Data", + TP[AVar F32,Var("opc",CTy"MoveWideOp"),Var("hw",FTy 2), + Var("imm16",F16),Var("rd",FTy 5)]), + Call + ("ARM8",CTy"MachineCode", + CC[LW(0,1), + CS(Var("opc",CTy"MoveWideOp"), + [(LC("MoveWideOp_N",CTy"MoveWideOp"),LW(0,2)), + (LC("MoveWideOp_Z",CTy"MoveWideOp"),LW(2,2)), + (LC("MoveWideOp_K",CTy"MoveWideOp"),LW(3,2))]),LW(37,6), + Var("hw",FTy 2),Var("imm16",F16),Var("rd",FTy 5)])), + (Call + ("MoveWide@64",CTy"Data", + TP[AVar F64,Var("opc",CTy"MoveWideOp"),Var("hw",FTy 2), + Var("imm16",F16),Var("rd",FTy 5)]), + Call + ("ARM8",CTy"MachineCode", + CC[LW(1,1), + CS(Var("opc",CTy"MoveWideOp"), + [(LC("MoveWideOp_N",CTy"MoveWideOp"),LW(0,2)), + (LC("MoveWideOp_Z",CTy"MoveWideOp"),LW(2,2)), + (LC("MoveWideOp_K",CTy"MoveWideOp"),LW(3,2))]),LW(37,6), + Var("hw",FTy 2),Var("imm16",F16),Var("rd",FTy 5)])), + (Call + ("BitfieldMove@32",CTy"Data", + TP[Var("sf",F32),bVar"inzero",bVar"extend",Var("wmask",F32), + Var("tmask",F32),nVar"immr",nVar"imms",Var("rn",FTy 5), + Var("rd",FTy 5)]), + Let(Var("sz",F1),Call("e_sf",F1,Var("sf",F32)), + CS(CS(TP[bVar"inzero",bVar"extend"], + [(TP[LT,LT],Mop(Some,LW(0,2))), + (TP[LF,LF],Mop(Some,LW(1,2))), + (TP[LT,LF],Mop(Some,LW(2,2))), + (AVar(PTy(bTy,bTy)),LO(FTy 2))]), + [(Mop(Some,Var("opc",FTy 2)), + Let(Var("r",FTy 6),Mop(Cast(FTy 6),nVar"immr"), + Let(Var("s",FTy 6),Mop(Cast(FTy 6),nVar"imms"), + ITE(Bop(And, + Bop(And, + EQ(nVar"immr", + Mop(Cast nTy,Var("r",FTy 6))), + EQ(nVar"imms", + Mop(Cast nTy,Var("s",FTy 6)))), + EQ(Call + ("DecodeBitMasks",OTy(PTy(F32,F32)), + TP[Mop(Cast F1,Var("sz",F1)), + Var("s",FTy 6),Var("r",FTy 6),LF]), + Mop(Some, + TP[Var("wmask",F32), + Var("tmask",F32)]))), + Call + ("ARM8",CTy"MachineCode", + CC[Var("sz",F1),Var("opc",FTy 2),LW(38,6), + Var("sz",F1),Var("r",FTy 6), + Var("s",FTy 6),Var("rn",FTy 5), + Var("rd",FTy 5)]), + Call + ("BadCode",CTy"MachineCode", + LS"BitfieldMove"))))), + (LO(FTy 2), + Call("BadCode",CTy"MachineCode",LS"BitfieldMove"))]))), + (Call + ("BitfieldMove@64",CTy"Data", + TP[Var("sf",F64),bVar"inzero",bVar"extend",Var("wmask",F64), + Var("tmask",F64),nVar"immr",nVar"imms",Var("rn",FTy 5), + Var("rd",FTy 5)]), + Let(Var("sz",F1),Call("e_sf",F1,Var("sf",F64)), + CS(CS(TP[bVar"inzero",bVar"extend"], + [(TP[LT,LT],Mop(Some,LW(0,2))), + (TP[LF,LF],Mop(Some,LW(1,2))), + (TP[LT,LF],Mop(Some,LW(2,2))), + (AVar(PTy(bTy,bTy)),LO(FTy 2))]), + [(Mop(Some,Var("opc",FTy 2)), + Let(Var("r",FTy 6),Mop(Cast(FTy 6),nVar"immr"), + Let(Var("s",FTy 6),Mop(Cast(FTy 6),nVar"imms"), + ITE(Bop(And, + Bop(And, + EQ(nVar"immr", + Mop(Cast nTy,Var("r",FTy 6))), + EQ(nVar"imms", + Mop(Cast nTy,Var("s",FTy 6)))), + EQ(Call + ("DecodeBitMasks",OTy(PTy(F64,F64)), + TP[Mop(Cast F1,Var("sz",F1)), + Var("s",FTy 6),Var("r",FTy 6),LF]), + Mop(Some, + TP[Var("wmask",F64), + Var("tmask",F64)]))), + Call + ("ARM8",CTy"MachineCode", + CC[Var("sz",F1),Var("opc",FTy 2),LW(38,6), + Var("sz",F1),Var("r",FTy 6), + Var("s",FTy 6),Var("rn",FTy 5), + Var("rd",FTy 5)]), + Call + ("BadCode",CTy"MachineCode", + LS"BitfieldMove"))))), + (LO(FTy 2), + Call("BadCode",CTy"MachineCode",LS"BitfieldMove"))]))), + (Call + ("ConditionalCompareImmediate@32",CTy"Data", + TP[Var("sf",F32),bVar"opc",Var("imm",F32),Var("cd",F4), + TP[bVar"n",bVar"z",bVar"c",bVar"v"],Var("rn",FTy 5)]), + Let(Var("imm5",FTy 5),Mop(Cast(FTy 5),Var("imm",F32)), + ITE(EQ(Var("imm",F32),Mop(Cast F32,Var("imm5",FTy 5))), + Call + ("ARM8",CTy"MachineCode", + CC[Call("e_sf",F1,Var("sf",F32)), + Mop(Cast F1,bVar"opc"),LW(466,9),Var("imm5",FTy 5), + Var("cd",F4),LW(2,2),Var("rn",FTy 5),LW(0,1), + Mop(Cast F1,bVar"n"),Mop(Cast F1,bVar"z"), + Mop(Cast F1,bVar"c"),Mop(Cast F1,bVar"v")]), + Call + ("BadCode",CTy"MachineCode", + LS"ConditionalCompareImmediate")))), + (Call + ("ConditionalCompareImmediate@64",CTy"Data", + TP[Var("sf",F64),bVar"opc",Var("imm",F64),Var("cd",F4), + TP[bVar"n",bVar"z",bVar"c",bVar"v"],Var("rn",FTy 5)]), + Let(Var("imm5",FTy 5),Mop(Cast(FTy 5),Var("imm",F64)), + ITE(EQ(Var("imm",F64),Mop(Cast F64,Var("imm5",FTy 5))), + Call + ("ARM8",CTy"MachineCode", + CC[Call("e_sf",F1,Var("sf",F64)), + Mop(Cast F1,bVar"opc"),LW(466,9),Var("imm5",FTy 5), + Var("cd",F4),LW(2,2),Var("rn",FTy 5),LW(0,1), + Mop(Cast F1,bVar"n"),Mop(Cast F1,bVar"z"), + Mop(Cast F1,bVar"c"),Mop(Cast F1,bVar"v")]), + Call + ("BadCode",CTy"MachineCode", + LS"ConditionalCompareImmediate")))), + (Call + ("ConditionalCompareRegister@32",CTy"Data", + TP[Var("sf",F32),bVar"opc",Var("cd",F4), + TP[bVar"n",bVar"z",bVar"c",bVar"v"],Var("rm",FTy 5), + Var("rn",FTy 5)]), + Call + ("ARM8",CTy"MachineCode", + CC[Call("e_sf",F1,Var("sf",F32)),Mop(Cast F1,bVar"opc"), + LW(466,9),Var("rm",FTy 5),Var("cd",F4),LW(0,2), + Var("rn",FTy 5),LW(0,1),Mop(Cast F1,bVar"n"), + Mop(Cast F1,bVar"z"),Mop(Cast F1,bVar"c"), + Mop(Cast F1,bVar"v")])), + (Call + ("ConditionalCompareRegister@64",CTy"Data", + TP[Var("sf",F64),bVar"opc",Var("cd",F4), + TP[bVar"n",bVar"z",bVar"c",bVar"v"],Var("rm",FTy 5), + Var("rn",FTy 5)]), + Call + ("ARM8",CTy"MachineCode", + CC[Call("e_sf",F1,Var("sf",F64)),Mop(Cast F1,bVar"opc"), + LW(466,9),Var("rm",FTy 5),Var("cd",F4),LW(0,2), + Var("rn",FTy 5),LW(0,1),Mop(Cast F1,bVar"n"), + Mop(Cast F1,bVar"z"),Mop(Cast F1,bVar"c"), + Mop(Cast F1,bVar"v")])), + (Call + ("ConditionalSelect@32",CTy"Data", + TP[AVar F32,bVar"op",bVar"o2",Var("cd",F4),Var("rm",FTy 5), + Var("rn",FTy 5),Var("rd",FTy 5)]), + Call + ("ARM8",CTy"MachineCode", + CC[LW(0,1),Mop(Cast F1,bVar"op"),LW(212,9),Var("rm",FTy 5), + Var("cd",F4),LW(0,1),Mop(Cast F1,bVar"o2"),Var("rn",FTy 5), + Var("rd",FTy 5)])), + (Call + ("ConditionalSelect@64",CTy"Data", + TP[AVar F64,bVar"op",bVar"o2",Var("cd",F4),Var("rm",FTy 5), + Var("rn",FTy 5),Var("rd",FTy 5)]), + Call + ("ARM8",CTy"MachineCode", + CC[LW(1,1),Mop(Cast F1,bVar"op"),LW(212,9),Var("rm",FTy 5), + Var("cd",F4),LW(0,1),Mop(Cast F1,bVar"o2"),Var("rn",FTy 5), + Var("rd",FTy 5)])), + (Call + ("CountLeading@32",CTy"Data", + TP[AVar F32,bVar"op",Var("rn",FTy 5),Var("rd",FTy 5)]), + Call + ("ARM8",CTy"MachineCode", + CC[LW(743426,21),Mop(Cast F1,bVar"op"),Var("rn",FTy 5), + Var("rd",FTy 5)])), + (Call + ("CountLeading@64",CTy"Data", + TP[AVar F64,bVar"op",Var("rn",FTy 5),Var("rd",FTy 5)]), + Call + ("ARM8",CTy"MachineCode", + CC[LW(1792002,21),Mop(Cast F1,bVar"op"),Var("rn",FTy 5), + Var("rd",FTy 5)])), + (Call + ("ExtractRegister@32",CTy"Data", + TP[AVar F32,Var("imms",FTy 6),Var("rm",FTy 5),Var("rn",FTy 5), + Var("rd",FTy 5)]), + ITE(Bop(Bit,Var("imms",FTy 6),LN 5), + Call("BadCode",CTy"MachineCode",LS"ExtractRegister32"), + Call + ("ARM8",CTy"MachineCode", + CC[LW(156,11),Var("rm",FTy 5),Var("imms",FTy 6), + Var("rn",FTy 5),Var("rd",FTy 5)]))), + (Call + ("ExtractRegister@64",CTy"Data", + TP[AVar F64,Var("imms",FTy 6),Var("rm",FTy 5),Var("rn",FTy 5), + Var("rd",FTy 5)]), + Call + ("ARM8",CTy"MachineCode", + CC[LW(1182,11),Var("rm",FTy 5),Var("imms",FTy 6), + Var("rn",FTy 5),Var("rd",FTy 5)])), + (Call + ("Division@32",CTy"Data", + TP[AVar F32,bVar"o1",Var("rm",FTy 5),Var("rn",FTy 5), + Var("rd",FTy 5)]), + Call + ("ARM8",CTy"MachineCode", + CC[LW(214,11),Var("rm",FTy 5),LW(1,5), + Mop(Cast F1,Mop(Not,bVar"o1")),Var("rn",FTy 5), + Var("rd",FTy 5)])), + (Call + ("Division@64",CTy"Data", + TP[AVar F64,bVar"o1",Var("rm",FTy 5),Var("rn",FTy 5), + Var("rd",FTy 5)]), + Call + ("ARM8",CTy"MachineCode", + CC[LW(1238,11),Var("rm",FTy 5),LW(1,5), + Mop(Cast F1,Mop(Not,bVar"o1")),Var("rn",FTy 5), + Var("rd",FTy 5)])), + (Call + ("MultiplyAddSub@32",CTy"Data", + TP[AVar F32,bVar"o0",Var("rm",FTy 5),Var("ra",FTy 5), + Var("rn",FTy 5),Var("rd",FTy 5)]), + Call + ("ARM8",CTy"MachineCode", + CC[LW(216,11),Var("rm",FTy 5),Mop(Cast F1,bVar"o0"), + Var("ra",FTy 5),Var("rn",FTy 5),Var("rd",FTy 5)])), + (Call + ("MultiplyAddSub@64",CTy"Data", + TP[AVar F64,bVar"o0",Var("rm",FTy 5),Var("ra",FTy 5), + Var("rn",FTy 5),Var("rd",FTy 5)]), + Call + ("ARM8",CTy"MachineCode", + CC[LW(1240,11),Var("rm",FTy 5),Mop(Cast F1,bVar"o0"), + Var("ra",FTy 5),Var("rn",FTy 5),Var("rd",FTy 5)])), + (Call + ("MultiplyAddSubLong",CTy"Data", + TP[bVar"o0",bVar"u",Var("rm",FTy 5),Var("ra",FTy 5), + Var("rn",FTy 5),Var("rd",FTy 5)]), + Call + ("ARM8",CTy"MachineCode", + CC[LW(155,8),Mop(Cast F1,Mop(Not,bVar"u")),LW(1,2), + Var("rm",FTy 5),Mop(Cast F1,bVar"o0"),Var("ra",FTy 5), + Var("rn",FTy 5),Var("rd",FTy 5)])), + (Call + ("MultiplyHigh",CTy"Data", + TP[bVar"u",Var("rm",FTy 5),Var("rn",FTy 5),Var("rd",FTy 5)]), + Call + ("ARM8",CTy"MachineCode", + CC[LW(155,8),Mop(Cast F1,Mop(Not,bVar"u")),LW(2,2), + Var("rm",FTy 5),LW(31,6),Var("rn",FTy 5),Var("rd",FTy 5)])), + (Call + ("Reverse@32",CTy"Data", + TP[AVar F32,Var("opc",CTy"RevOp"),Var("rn",FTy 5), + Var("rd",FTy 5)]), + ITE(EQ(Var("opc",CTy"RevOp"),LC("RevOp_REV64",CTy"RevOp")), + Call("BadCode",CTy"MachineCode",LS"Reverse32"), + Call + ("ARM8",CTy"MachineCode", + CC[LW(371712,20),Mop(Cast(FTy 2),Var("opc",CTy"RevOp")), + Var("rn",FTy 5),Var("rd",FTy 5)]))), + (Call + ("Reverse@64",CTy"Data", + TP[AVar F64,Var("opc",CTy"RevOp"),Var("rn",FTy 5), + Var("rd",FTy 5)]), + Call + ("ARM8",CTy"MachineCode", + CC[LW(896000,20),Mop(Cast(FTy 2),Var("opc",CTy"RevOp")), + Var("rn",FTy 5),Var("rd",FTy 5)]))])) +; +val e_debug_def = Def + ("e_debug",Var("i",CTy"Debug"), + CS(Var("i",CTy"Debug"), + [(Call("Breakpoint",CTy"Debug",Var("imm16",F16)), + CC[LW(1697,11),Var("imm16",F16),LW(0,5)]), + (Const("DebugRestore",CTy"Debug"),LW(3602842592,32)), + (Call("DebugSwitch",CTy"Debug",Var("LL",FTy 2)), + CC[LW(1701,11),LW(0,16),LW(0,3),Var("LL",FTy 2)]), + (Call("Halt",CTy"Debug",Var("imm16",F16)), + CC[LW(1698,11),Var("imm16",F16),LW(0,5)])])) +; +val e_crc_def = Def + ("e_crc",Var("i",CTy"CRCExt"), + CS(Var("i",CTy"CRCExt"), + [(Call + ("CRC@8",CTy"CRCExt", + TP[AVar F8,bVar"c",Var("rm",FTy 5),Var("rn",FTy 5), + Var("rd",FTy 5)]), + CC[LW(214,11),Var("rm",FTy 5),LW(2,3),Mop(Cast F1,bVar"c"), + LW(0,2),Var("rn",FTy 5),Var("rd",FTy 5)]), + (Call + ("CRC@16",CTy"CRCExt", + TP[AVar F16,bVar"c",Var("rm",FTy 5),Var("rn",FTy 5), + Var("rd",FTy 5)]), + CC[LW(214,11),Var("rm",FTy 5),LW(2,3),Mop(Cast F1,bVar"c"), + LW(1,2),Var("rn",FTy 5),Var("rd",FTy 5)]), + (Call + ("CRC@32",CTy"CRCExt", + TP[AVar F32,bVar"c",Var("rm",FTy 5),Var("rn",FTy 5), + Var("rd",FTy 5)]), + CC[LW(214,11),Var("rm",FTy 5),LW(2,3),Mop(Cast F1,bVar"c"), + LW(2,2),Var("rn",FTy 5),Var("rd",FTy 5)]), + (Call + ("CRC@64",CTy"CRCExt", + TP[AVar F64,bVar"c",Var("rm",FTy 5),Var("rn",FTy 5), + Var("rd",FTy 5)]), + CC[LW(1238,11),Var("rm",FTy 5),LW(2,3),Mop(Cast F1,bVar"c"), + LW(3,2),Var("rn",FTy 5),Var("rd",FTy 5)])])) +; +val e_branch_def = Def + ("e_branch",Var("i",CTy"Branch"), + CS(Var("i",CTy"Branch"), + [(Call + ("BranchConditional",CTy"Branch",TP[Var("imm",F64),Var("cd",F4)]), + Let(Var("imm19",FTy 19),EX(Var("imm",F64),LN 20,LN 2,FTy 19), + ITE(EQ(Var("imm",F64), + Mop(SE F64,CC[Var("imm19",FTy 19),LW(0,2)])), + Call + ("ARM8",CTy"MachineCode", + CC[LW(84,8),Var("imm19",FTy 19),LW(0,1),Var("cd",F4)]), + Call("BadCode",CTy"MachineCode",LS"BranchConditional")))), + (Call + ("BranchImmediate",CTy"Branch", + TP[Var("imm",F64),Var("btype",CTy"BranchType")]), + Let(Var("imm26",FTy 26),EX(Var("imm",F64),LN 27,LN 2,FTy 26), + ITE(Bop(And, + EQ(Var("imm",F64), + Mop(SE F64,CC[Var("imm26",FTy 26),LW(0,2)])), + Bop(In,Var("btype",CTy"BranchType"), + SL[LC("BranchType_CALL",CTy"BranchType"), + LC("BranchType_JMP",CTy"BranchType")])), + Call + ("ARM8",CTy"MachineCode", + CC[Mop(Cast F1, + EQ(Var("btype",CTy"BranchType"), + LC("BranchType_CALL",CTy"BranchType"))), + LW(5,5),Var("imm26",FTy 26)]), + Call("BadCode",CTy"MachineCode",LS"BranchImmediate")))), + (Call + ("BranchRegister",CTy"Branch", + TP[Var("rn",FTy 5),Var("btype",CTy"BranchType")]), + Let(Var("opc",FTy 2), + CS(Var("btype",CTy"BranchType"), + [(LC("BranchType_JMP",CTy"BranchType"),LW(0,2)), + (LC("BranchType_CALL",CTy"BranchType"),LW(1,2)), + (LC("BranchType_RET",CTy"BranchType"),LW(2,2)), + (AVar(CTy"BranchType"),LW(3,2))]), + ITE(EQ(Var("opc",FTy 2),LW(3,2)), + Call("BadCode",CTy"MachineCode",LS"BranchRegister"), + Call + ("ARM8",CTy"MachineCode", + CC[LW(428,9),Var("opc",FTy 2),LW(1984,11), + Var("rn",FTy 5),LW(0,5)])))), + (Call + ("CompareAndBranch@32",CTy"Branch", + TP[AVar F32,bVar"iszero",Var("offset",F64),Var("rt",FTy 5)]), + Let(Var("imm19",FTy 19),EX(Var("offset",F64),LN 20,LN 2,FTy 19), + ITE(EQ(Var("offset",F64), + Mop(SE F64,CC[Var("imm19",FTy 19),LW(0,2)])), + Call + ("ARM8",CTy"MachineCode", + CC[LW(26,7),Mop(Cast F1,Mop(Not,bVar"iszero")), + Var("imm19",FTy 19),Var("rt",FTy 5)]), + Call("BadCode",CTy"MachineCode",LS"CompareAndBranch32")))), + (Call + ("CompareAndBranch@64",CTy"Branch", + TP[AVar F64,bVar"iszero",Var("offset",F64),Var("rt",FTy 5)]), + Let(Var("imm19",FTy 19),EX(Var("offset",F64),LN 20,LN 2,FTy 19), + ITE(EQ(Var("offset",F64), + Mop(SE F64,CC[Var("imm19",FTy 19),LW(0,2)])), + Call + ("ARM8",CTy"MachineCode", + CC[LW(90,7),Mop(Cast F1,Mop(Not,bVar"iszero")), + Var("imm19",FTy 19),Var("rt",FTy 5)]), + Call("BadCode",CTy"MachineCode",LS"CompareAndBranch64")))), + (Call + ("TestBitAndBranch@32",CTy"Branch", + TP[AVar F32,Var("bit_pos",FTy 6),bVar"bit_val", + Var("offset",F64),Var("rt",FTy 5)]), + Let(Var("imm14",FTy 14),EX(Var("offset",F64),LN 15,LN 2,FTy 14), + ITE(Bop(And, + EQ(Var("offset",F64), + Mop(SE F64,CC[Var("imm14",FTy 14),LW(0,2)])), + Mop(Not,Bop(Bit,Var("bit_pos",FTy 6),LN 5))), + Call + ("ARM8",CTy"MachineCode", + CC[LW(27,7),Mop(Cast F1,bVar"bit_val"), + EX(Var("bit_pos",FTy 6),LN 4,LN 0,FTy 5), + Var("imm14",FTy 14),Var("rt",FTy 5)]), + Call("BadCode",CTy"MachineCode",LS"TestBitAndBranch32")))), + (Call + ("TestBitAndBranch@64",CTy"Branch", + TP[AVar F64,Var("bit_pos",FTy 6),bVar"bit_val", + Var("offset",F64),Var("rt",FTy 5)]), + Let(Var("imm14",FTy 14),EX(Var("offset",F64),LN 15,LN 2,FTy 14), + ITE(Bop(And, + EQ(Var("offset",F64), + Mop(SE F64,CC[Var("imm14",FTy 14),LW(0,2)])), + Bop(Bit,Var("bit_pos",FTy 6),LN 5)), + Call + ("ARM8",CTy"MachineCode", + CC[LW(91,7),Mop(Cast F1,bVar"bit_val"), + EX(Var("bit_pos",FTy 6),LN 4,LN 0,FTy 5), + Var("imm14",FTy 14),Var("rt",FTy 5)]), + Call("BadCode",CTy"MachineCode",LS"TestBitAndBranch64"))))])) +; +val e_system_def = Def + ("e_system",Var("i",CTy"System"), + CS(Var("i",CTy"System"), + [(Call + ("MoveSystemRegister",CTy"System", + TP[bVar"l",Var("op0",FTy 3),Var("op1",FTy 3),Var("op2",FTy 3), + Var("crn",F4),Var("crm",F4),Var("rt",FTy 5)]), + CC[LW(852,10),Mop(Cast F1,bVar"l"),LW(1,1), + Mop(Cast F1,Bop(Sub,Var("op0",FTy 3),LW(2,3))), + Var("op1",FTy 3),Var("crn",F4),Var("crm",F4),Var("op2",FTy 3), + Var("rt",FTy 5)]), + (Call + ("MoveImmediateProcState",CTy"System", + TP[LC("PSTATEField_SP",CTy"PSTATEField"),Var("crm",F4)]), + CC[LW(872452,20),Var("crm",F4),LW(191,8)]), + (Call + ("MoveImmediateProcState",CTy"System", + TP[LC("PSTATEField_DAIFSet",CTy"PSTATEField"),Var("crm",F4)]), + CC[LW(872500,20),Var("crm",F4),LW(223,8)]), + (Call + ("MoveImmediateProcState",CTy"System", + TP[LC("PSTATEField_DAIFClr",CTy"PSTATEField"),Var("crm",F4)]), + CC[LW(872500,20),Var("crm",F4),LW(255,8)]), + (Const("ExceptionReturn",CTy"System"),LW(3600745440,32)), + (Call("SupervisorCall",CTy"System",Var("imm16",F16)), + CC[LW(1696,11),Var("imm16",F16),LW(1,5)]), + (Call("HypervisorCall",CTy"System",Var("imm16",F16)), + CC[LW(1696,11),Var("imm16",F16),LW(2,5)]), + (Call("SecureMonitorCall",CTy"System",Var("imm16",F16)), + CC[LW(1696,11),Var("imm16",F16),LW(3,5)]), + (Call + ("SystemInstruction",CTy"System", + TP[Var("op1",FTy 3),Var("op2",FTy 3),Var("crn",F4), + Var("crm",F4),bVar"l",Var("rt",FTy 5)]), + CC[LW(852,10),Mop(Cast F1,bVar"l"),LW(1,2),Var("op1",FTy 3), + Var("crn",F4),Var("crm",F4),Var("op2",FTy 3),Var("rt",FTy 5)])])) +; +val e_LoadStoreImmediate_def = Def + ("e_LoadStoreImmediate", + TP[Var("size",FTy 2),bVar"regsize_word",Var("memop",CTy"MemOp"), + Var("acctype",CTy"AccType"),bVar"signed",bVar"wback", + bVar"postindex",bVar"unsigned_offset",Var("offset",F64), + Var("rn",FTy 5),Var("rt",FTy 5)], + Let(Var("sz",FTy 2), + ITE(EQ(Var("memop",CTy"MemOp"),LC("MemOp_PREFETCH",CTy"MemOp")), + LW(3,2),Var("size",FTy 2)), + Let(Var("imm9",FTy 9),EX(Var("offset",F64),LN 8,LN 0,FTy 9), + Let(Var("imm12",FTy 12), + EX(Call + ("LSR",F64, + TP[Var("offset",F64),Mop(Cast nTy,Var("sz",FTy 2))]), + LN 11,LN 0,FTy 12), + Let(Var("opc",FTy 2), + ITB([(EQ(Var("memop",CTy"MemOp"), + LC("MemOp_STORE",CTy"MemOp")),LW(0,2)), + (Bop(And, + EQ(Var("memop",CTy"MemOp"), + LC("MemOp_LOAD",CTy"MemOp")), + Mop(Not,bVar"signed")),LW(1,2))], + CC[LW(1,1),Mop(Cast F1,bVar"regsize_word")]), + ITB([(bVar"wback", + ITE(Bop(And, + EQ(Var("offset",F64), + Mop(SE F64,Var("imm9",FTy 9))), + EQ(Var("acctype",CTy"AccType"), + LC("AccType_NORMAL",CTy"AccType"))), + Call + ("ARM8",CTy"MachineCode", + CC[Var("sz",FTy 2),LW(56,6), + Var("opc",FTy 2),LW(0,1), + Var("imm9",FTy 9), + Mop(Cast F1,Mop(Not,bVar"postindex")), + LW(1,1),Var("rn",FTy 5),Var("rt",FTy 5)]), + Call + ("BadCode",CTy"MachineCode", + LS"LoadStoreImmediate"))), + (bVar"postindex", + Call + ("BadCode",CTy"MachineCode", + LS"LoadStoreImmediate")), + (Bop(And, + Bop(And,bVar"unsigned_offset", + EQ(Var("offset",F64), + Call + ("LSL",F64, + TP[Mop(Cast F64,Var("imm12",FTy 12)), + Mop(Cast nTy,Var("sz",FTy 2))]))), + EQ(Var("acctype",CTy"AccType"), + LC("AccType_NORMAL",CTy"AccType"))), + Call + ("ARM8",CTy"MachineCode", + CC[Var("sz",FTy 2),LW(57,6),Var("opc",FTy 2), + Var("imm12",FTy 12),Var("rn",FTy 5), + Var("rt",FTy 5)])), + (EQ(Var("offset",F64), + Mop(SE F64,Var("imm9",FTy 9))), + Call + ("ARM8",CTy"MachineCode", + CC[Var("sz",FTy 2),LW(56,6),Var("opc",FTy 2), + LW(0,1),Var("imm9",FTy 9), + Mop(Cast F1, + EQ(Var("acctype",CTy"AccType"), + LC("AccType_UNPRIV",CTy"AccType"))), + LW(0,1),Var("rn",FTy 5),Var("rt",FTy 5)]))], + Call + ("BadCode",CTy"MachineCode", + LS"LoadStoreImmediate"))))))) +; +val e_LoadStoreRegister_def = Def + ("e_LoadStoreRegister", + TP[Var("size",FTy 2),bVar"regsize_word",Var("memop",CTy"MemOp"), + bVar"signed",Var("rm",FTy 5),Var("extend_type",CTy"ExtendType"), + nVar"shift",Var("rn",FTy 5),Var("rt",FTy 5)], + Call + ("ARM8",CTy"MachineCode", + CC[ITE(EQ(Var("memop",CTy"MemOp"),LC("MemOp_PREFETCH",CTy"MemOp")), + LW(3,2),Var("size",FTy 2)),LW(56,6), + ITB([(EQ(Var("memop",CTy"MemOp"),LC("MemOp_STORE",CTy"MemOp")), + LW(0,2)), + (Bop(And, + EQ(Var("memop",CTy"MemOp"),LC("MemOp_LOAD",CTy"MemOp")), + Mop(Not,bVar"signed")),LW(1,2))], + CC[LW(1,1),Mop(Cast F1,bVar"regsize_word")]),LW(1,1), + Var("rm",FTy 5), + Mop(Cast(FTy 3),Var("extend_type",CTy"ExtendType")), + Mop(Cast F1,Mop(Not,EQ(nVar"shift",LN 0))),LW(2,2), + Var("rn",FTy 5),Var("rt",FTy 5)])) +; +val e_load_store_def = Def + ("e_load_store",Var("i",CTy"LoadStore"), + CS(Var("i",CTy"LoadStore"), + [(Call + ("LoadStoreImmediate@8",CTy"LoadStore", + TP[Var("size",F8),bVar"regsize_word",Var("memop",CTy"MemOp"), + Var("acctype",CTy"AccType"),bVar"signed",bVar"wb_unknown", + bVar"rt_unknown",bVar"wback",bVar"postindex", + bVar"unsigned_offset",Var("offset",F64),Var("rn",FTy 5), + Var("rt",FTy 5)]), + Call + ("e_LoadStoreImmediate",CTy"MachineCode", + TP[Mop(Cast(FTy 2),Var("size",F8)),bVar"regsize_word", + Var("memop",CTy"MemOp"),Var("acctype",CTy"AccType"), + bVar"signed",bVar"wback",bVar"postindex", + bVar"unsigned_offset",Var("offset",F64),Var("rn",FTy 5), + Var("rt",FTy 5)])), + (Call + ("LoadStoreImmediate@16",CTy"LoadStore", + TP[Var("size",F16),bVar"regsize_word",Var("memop",CTy"MemOp"), + Var("acctype",CTy"AccType"),bVar"signed",bVar"wb_unknown", + bVar"rt_unknown",bVar"wback",bVar"postindex", + bVar"unsigned_offset",Var("offset",F64),Var("rn",FTy 5), + Var("rt",FTy 5)]), + Call + ("e_LoadStoreImmediate",CTy"MachineCode", + TP[Mop(Cast(FTy 2),Var("size",F16)),bVar"regsize_word", + Var("memop",CTy"MemOp"),Var("acctype",CTy"AccType"), + bVar"signed",bVar"wback",bVar"postindex", + bVar"unsigned_offset",Var("offset",F64),Var("rn",FTy 5), + Var("rt",FTy 5)])), + (Call + ("LoadStoreImmediate@32",CTy"LoadStore", + TP[Var("size",F32),bVar"regsize_word",Var("memop",CTy"MemOp"), + Var("acctype",CTy"AccType"),bVar"signed",bVar"wb_unknown", + bVar"rt_unknown",bVar"wback",bVar"postindex", + bVar"unsigned_offset",Var("offset",F64),Var("rn",FTy 5), + Var("rt",FTy 5)]), + Call + ("e_LoadStoreImmediate",CTy"MachineCode", + TP[Mop(Cast(FTy 2),Var("size",F32)),bVar"regsize_word", + Var("memop",CTy"MemOp"),Var("acctype",CTy"AccType"), + bVar"signed",bVar"wback",bVar"postindex", + bVar"unsigned_offset",Var("offset",F64),Var("rn",FTy 5), + Var("rt",FTy 5)])), + (Call + ("LoadStoreImmediate@64",CTy"LoadStore", + TP[Var("size",F64),bVar"regsize_word",Var("memop",CTy"MemOp"), + Var("acctype",CTy"AccType"),bVar"signed",bVar"wb_unknown", + bVar"rt_unknown",bVar"wback",bVar"postindex", + bVar"unsigned_offset",Var("offset",F64),Var("rn",FTy 5), + Var("rt",FTy 5)]), + Call + ("e_LoadStoreImmediate",CTy"MachineCode", + TP[Mop(Cast(FTy 2),Var("size",F64)),bVar"regsize_word", + Var("memop",CTy"MemOp"),Var("acctype",CTy"AccType"), + bVar"signed",bVar"wback",bVar"postindex", + bVar"unsigned_offset",Var("offset",F64),Var("rn",FTy 5), + Var("rt",FTy 5)])), + (Call + ("LoadStoreRegister@8",CTy"LoadStore", + TP[Var("size",F8),bVar"regsize_word",Var("memop",CTy"MemOp"), + bVar"signed",Var("rm",FTy 5), + Var("extend_type",CTy"ExtendType"),nVar"shift", + Var("rn",FTy 5),Var("rt",FTy 5)]), + Call + ("e_LoadStoreRegister",CTy"MachineCode", + TP[Mop(Cast(FTy 2),Var("size",F8)),bVar"regsize_word", + Var("memop",CTy"MemOp"),bVar"signed",Var("rm",FTy 5), + Var("extend_type",CTy"ExtendType"),nVar"shift", + Var("rn",FTy 5),Var("rt",FTy 5)])), + (Call + ("LoadStoreRegister@16",CTy"LoadStore", + TP[Var("size",F16),bVar"regsize_word",Var("memop",CTy"MemOp"), + bVar"signed",Var("rm",FTy 5), + Var("extend_type",CTy"ExtendType"),nVar"shift", + Var("rn",FTy 5),Var("rt",FTy 5)]), + Call + ("e_LoadStoreRegister",CTy"MachineCode", + TP[Mop(Cast(FTy 2),Var("size",F16)),bVar"regsize_word", + Var("memop",CTy"MemOp"),bVar"signed",Var("rm",FTy 5), + Var("extend_type",CTy"ExtendType"),nVar"shift", + Var("rn",FTy 5),Var("rt",FTy 5)])), + (Call + ("LoadStoreRegister@32",CTy"LoadStore", + TP[Var("size",F32),bVar"regsize_word",Var("memop",CTy"MemOp"), + bVar"signed",Var("rm",FTy 5), + Var("extend_type",CTy"ExtendType"),nVar"shift", + Var("rn",FTy 5),Var("rt",FTy 5)]), + Call + ("e_LoadStoreRegister",CTy"MachineCode", + TP[Mop(Cast(FTy 2),Var("size",F32)),bVar"regsize_word", + Var("memop",CTy"MemOp"),bVar"signed",Var("rm",FTy 5), + Var("extend_type",CTy"ExtendType"),nVar"shift", + Var("rn",FTy 5),Var("rt",FTy 5)])), + (Call + ("LoadStoreRegister@64",CTy"LoadStore", + TP[Var("size",F64),bVar"regsize_word",Var("memop",CTy"MemOp"), + bVar"signed",Var("rm",FTy 5), + Var("extend_type",CTy"ExtendType"),nVar"shift", + Var("rn",FTy 5),Var("rt",FTy 5)]), + Call + ("e_LoadStoreRegister",CTy"MachineCode", + TP[Mop(Cast(FTy 2),Var("size",F64)),bVar"regsize_word", + Var("memop",CTy"MemOp"),bVar"signed",Var("rm",FTy 5), + Var("extend_type",CTy"ExtendType"),nVar"shift", + Var("rn",FTy 5),Var("rt",FTy 5)])), + (Call + ("LoadLiteral@32",CTy"LoadStore", + TP[AVar F32,Var("memop",CTy"MemOp"),bVar"signed", + Var("offset",F64),Var("rt",FTy 5)]), + Let(Var("imm19",FTy 19),EX(Var("offset",F64),LN 20,LN 2,FTy 19), + Let(Var("opc",OTy(FTy 2)), + CS(TP[Var("memop",CTy"MemOp"),bVar"signed"], + [(TP[LC("MemOp_LOAD",CTy"MemOp"),LF],Mop(Some,LW(0,2))), + (TP[LC("MemOp_LOAD",CTy"MemOp"),LT],Mop(Some,LW(2,2))), + (TP[LC("MemOp_PREFETCH",CTy"MemOp"),LF], + Mop(Some,LW(3,2))), + (AVar(PTy(CTy"MemOp",bTy)),LO(FTy 2))]), + ITE(Bop(And,Mop(IsSome,Var("opc",OTy(FTy 2))), + EQ(Var("offset",F64), + Mop(SE F64,CC[Var("imm19",FTy 19),LW(0,2)]))), + Call + ("ARM8",CTy"MachineCode", + CC[Mop(ValOf,Var("opc",OTy(FTy 2))),LW(24,6), + Var("imm19",FTy 19),Var("rt",FTy 5)]), + Call("BadCode",CTy"MachineCode",LS"LoadLiteral32"))))), + (Call + ("LoadLiteral@64",CTy"LoadStore", + TP[AVar F64,LC("MemOp_LOAD",CTy"MemOp"),LF,Var("offset",F64), + Var("rt",FTy 5)]), + Let(Var("imm19",FTy 19),EX(Var("offset",F64),LN 20,LN 2,FTy 19), + ITE(EQ(Var("offset",F64), + Mop(SE F64,CC[Var("imm19",FTy 19),LW(0,2)])), + Call + ("ARM8",CTy"MachineCode", + CC[LW(88,8),Var("imm19",FTy 19),Var("rt",FTy 5)]), + Call("BadCode",CTy"MachineCode",LS"LoadLiteral64")))), + (Call + ("LoadLiteral@64",CTy"LoadStore", + AVar(PTy(F64,PTy(CTy"MemOp",PTy(bTy,PTy(F64,FTy 5)))))), + Call("BadCode",CTy"MachineCode",LS"LoadLiteral64")), + (Call + ("LoadStorePair@32",CTy"LoadStore", + TP[Var("size",F32),Var("memop",CTy"MemOp"), + Var("acctype",CTy"AccType"),bVar"signed",bVar"wb_unknown", + bVar"rt_unknown",bVar"wback",bVar"postindex", + Var("offset",F64),Var("rn",FTy 5),Var("rt",FTy 5), + Var("rt2",FTy 5)]), + Let(Var("sf",F1),Mop(Cast F1,Var("size",F32)), + Let(nVar"scale",Bop(Add,LN 2,Mop(Cast nTy,Var("sf",F1))), + Let(Var("imm7",FTy 7), + EX(Call("LSR",F64,TP[Var("offset",F64),nVar"scale"]), + LN 6,LN 0,FTy 7), + ITE(Bop(And, + Bop(And, + Bop(And, + EQ(EQ(Var("sf",F1),LW(1,1)), + EQ(Mop(Size,Var("size",F32)),LN 64)), + Bop(In,Var("memop",CTy"MemOp"), + SL[LC("MemOp_LOAD",CTy"MemOp"), + LC("MemOp_STORE",CTy"MemOp")])), + Bop(In,Var("acctype",CTy"AccType"), + SL[LC("AccType_STREAM",CTy"AccType"), + LC("AccType_NORMAL",CTy"AccType")])), + EQ(Var("offset",F64), + Call + ("LSL",F64, + TP[Mop(SE F64,Var("imm7",FTy 7)), + nVar"scale"]))), + Call + ("ARM8",CTy"MachineCode", + CC[Var("sf",F1),Mop(Cast F1,bVar"signed"), + LW(20,5), + Mop(Cast F1,Mop(Not,bVar"postindex")), + Mop(Cast F1,bVar"wback"), + Mop(Cast F1, + EQ(Var("memop",CTy"MemOp"), + LC("MemOp_LOAD",CTy"MemOp"))), + Var("imm7",FTy 7),Var("rt2",FTy 5), + Var("rn",FTy 5),Var("rt",FTy 5)]), + Call("BadCode",CTy"MachineCode",LS"LoadStorePair")))))), + (Call + ("LoadStorePair@64",CTy"LoadStore", + TP[Var("size",F64),Var("memop",CTy"MemOp"), + Var("acctype",CTy"AccType"),bVar"signed",bVar"wb_unknown", + bVar"rt_unknown",bVar"wback",bVar"postindex", + Var("offset",F64),Var("rn",FTy 5),Var("rt",FTy 5), + Var("rt2",FTy 5)]), + Let(Var("sf",F1),Mop(Cast F1,Var("size",F64)), + Let(nVar"scale",Bop(Add,LN 2,Mop(Cast nTy,Var("sf",F1))), + Let(Var("imm7",FTy 7), + EX(Call("LSR",F64,TP[Var("offset",F64),nVar"scale"]), + LN 6,LN 0,FTy 7), + ITE(Bop(And, + Bop(And, + Bop(And, + EQ(EQ(Var("sf",F1),LW(1,1)), + EQ(Mop(Size,Var("size",F64)),LN 64)), + Bop(In,Var("memop",CTy"MemOp"), + SL[LC("MemOp_LOAD",CTy"MemOp"), + LC("MemOp_STORE",CTy"MemOp")])), + Bop(In,Var("acctype",CTy"AccType"), + SL[LC("AccType_STREAM",CTy"AccType"), + LC("AccType_NORMAL",CTy"AccType")])), + EQ(Var("offset",F64), + Call + ("LSL",F64, + TP[Mop(SE F64,Var("imm7",FTy 7)), + nVar"scale"]))), + Call + ("ARM8",CTy"MachineCode", + CC[Var("sf",F1),Mop(Cast F1,bVar"signed"), + LW(20,5), + Mop(Cast F1,Mop(Not,bVar"postindex")), + Mop(Cast F1,bVar"wback"), + Mop(Cast F1, + EQ(Var("memop",CTy"MemOp"), + LC("MemOp_LOAD",CTy"MemOp"))), + Var("imm7",FTy 7),Var("rt2",FTy 5), + Var("rn",FTy 5),Var("rt",FTy 5)]), + Call("BadCode",CTy"MachineCode",LS"LoadStorePair")))))), + (Call + ("LoadStoreAcquire@8",CTy"LoadStore", + TP[Var("size",F8),Var("memop",CTy"MemOp"), + Var("acctype",CTy"AccType"),bVar"excl",bVar"rn_unknown", + bVar"rt_unknown",Var("rs",FTy 5),Var("rn",FTy 5), + Var("rt",FTy 5)]), + ITE(Bop(And, + Bop(And, + CS(Mop(Size,Var("size",F8)), + [(LN 8,EQ(Var("size",F8),LW(0,8))), + (LN 16,EQ(Var("size",F8),LW(1,8))), + (LN 32,EQ(Var("size",F8),LW(2,8))), + (AVar nTy,EQ(Var("size",F8),LW(3,8)))]), + Bop(In,Var("memop",CTy"MemOp"), + SL[LC("MemOp_LOAD",CTy"MemOp"), + LC("MemOp_STORE",CTy"MemOp")])), + Bop(In,Var("acctype",CTy"AccType"), + SL[LC("AccType_ORDERED",CTy"AccType"), + LC("AccType_ATOMIC",CTy"AccType")])), + Call + ("ARM8",CTy"MachineCode", + CC[Mop(Cast(FTy 2),Var("size",F8)),LW(8,6), + Mop(Cast F1,Mop(Not,bVar"excl")), + Mop(Cast F1, + EQ(Var("memop",CTy"MemOp"), + LC("MemOp_LOAD",CTy"MemOp"))),LW(0,1), + Var("rs",FTy 5), + Mop(Cast F1, + EQ(Var("acctype",CTy"AccType"), + LC("AccType_ORDERED",CTy"AccType"))),LW(31,5), + Var("rn",FTy 5),Var("rt",FTy 5)]), + Call("BadCode",CTy"MachineCode",LS"LoadStoreAcquire"))), + (Call + ("LoadStoreAcquire@16",CTy"LoadStore", + TP[Var("size",F16),Var("memop",CTy"MemOp"), + Var("acctype",CTy"AccType"),bVar"excl",bVar"rn_unknown", + bVar"rt_unknown",Var("rs",FTy 5),Var("rn",FTy 5), + Var("rt",FTy 5)]), + ITE(Bop(And, + Bop(And, + CS(Mop(Size,Var("size",F16)), + [(LN 8,EQ(Var("size",F16),LW(0,16))), + (LN 16,EQ(Var("size",F16),LW(1,16))), + (LN 32,EQ(Var("size",F16),LW(2,16))), + (AVar nTy,EQ(Var("size",F16),LW(3,16)))]), + Bop(In,Var("memop",CTy"MemOp"), + SL[LC("MemOp_LOAD",CTy"MemOp"), + LC("MemOp_STORE",CTy"MemOp")])), + Bop(In,Var("acctype",CTy"AccType"), + SL[LC("AccType_ORDERED",CTy"AccType"), + LC("AccType_ATOMIC",CTy"AccType")])), + Call + ("ARM8",CTy"MachineCode", + CC[Mop(Cast(FTy 2),Var("size",F16)),LW(8,6), + Mop(Cast F1,Mop(Not,bVar"excl")), + Mop(Cast F1, + EQ(Var("memop",CTy"MemOp"), + LC("MemOp_LOAD",CTy"MemOp"))),LW(0,1), + Var("rs",FTy 5), + Mop(Cast F1, + EQ(Var("acctype",CTy"AccType"), + LC("AccType_ORDERED",CTy"AccType"))),LW(31,5), + Var("rn",FTy 5),Var("rt",FTy 5)]), + Call("BadCode",CTy"MachineCode",LS"LoadStoreAcquire"))), + (Call + ("LoadStoreAcquire@32",CTy"LoadStore", + TP[Var("size",F32),Var("memop",CTy"MemOp"), + Var("acctype",CTy"AccType"),bVar"excl",bVar"rn_unknown", + bVar"rt_unknown",Var("rs",FTy 5),Var("rn",FTy 5), + Var("rt",FTy 5)]), + ITE(Bop(And, + Bop(And, + CS(Mop(Size,Var("size",F32)), + [(LN 8,EQ(Var("size",F32),LW(0,32))), + (LN 16,EQ(Var("size",F32),LW(1,32))), + (LN 32,EQ(Var("size",F32),LW(2,32))), + (AVar nTy,EQ(Var("size",F32),LW(3,32)))]), + Bop(In,Var("memop",CTy"MemOp"), + SL[LC("MemOp_LOAD",CTy"MemOp"), + LC("MemOp_STORE",CTy"MemOp")])), + Bop(In,Var("acctype",CTy"AccType"), + SL[LC("AccType_ORDERED",CTy"AccType"), + LC("AccType_ATOMIC",CTy"AccType")])), + Call + ("ARM8",CTy"MachineCode", + CC[Mop(Cast(FTy 2),Var("size",F32)),LW(8,6), + Mop(Cast F1,Mop(Not,bVar"excl")), + Mop(Cast F1, + EQ(Var("memop",CTy"MemOp"), + LC("MemOp_LOAD",CTy"MemOp"))),LW(0,1), + Var("rs",FTy 5), + Mop(Cast F1, + EQ(Var("acctype",CTy"AccType"), + LC("AccType_ORDERED",CTy"AccType"))),LW(31,5), + Var("rn",FTy 5),Var("rt",FTy 5)]), + Call("BadCode",CTy"MachineCode",LS"LoadStoreAcquire"))), + (Call + ("LoadStoreAcquire@64",CTy"LoadStore", + TP[Var("size",F64),Var("memop",CTy"MemOp"), + Var("acctype",CTy"AccType"),bVar"excl",bVar"rn_unknown", + bVar"rt_unknown",Var("rs",FTy 5),Var("rn",FTy 5), + Var("rt",FTy 5)]), + ITE(Bop(And, + Bop(And, + CS(Mop(Size,Var("size",F64)), + [(LN 8,EQ(Var("size",F64),LW(0,64))), + (LN 16,EQ(Var("size",F64),LW(1,64))), + (LN 32,EQ(Var("size",F64),LW(2,64))), + (AVar nTy,EQ(Var("size",F64),LW(3,64)))]), + Bop(In,Var("memop",CTy"MemOp"), + SL[LC("MemOp_LOAD",CTy"MemOp"), + LC("MemOp_STORE",CTy"MemOp")])), + Bop(In,Var("acctype",CTy"AccType"), + SL[LC("AccType_ORDERED",CTy"AccType"), + LC("AccType_ATOMIC",CTy"AccType")])), + Call + ("ARM8",CTy"MachineCode", + CC[Mop(Cast(FTy 2),Var("size",F64)),LW(8,6), + Mop(Cast F1,Mop(Not,bVar"excl")), + Mop(Cast F1, + EQ(Var("memop",CTy"MemOp"), + LC("MemOp_LOAD",CTy"MemOp"))),LW(0,1), + Var("rs",FTy 5), + Mop(Cast F1, + EQ(Var("acctype",CTy"AccType"), + LC("AccType_ORDERED",CTy"AccType"))),LW(31,5), + Var("rn",FTy 5),Var("rt",FTy 5)]), + Call("BadCode",CTy"MachineCode",LS"LoadStoreAcquire"))), + (Call + ("LoadStoreAcquirePair@64",CTy"LoadStore", + TP[Var("size",F64),Var("memop",CTy"MemOp"), + Var("acctype",CTy"AccType"),bVar"rn_unknown", + bVar"rt_unknown",Var("rs",FTy 5),Var("rn",FTy 5), + Var("rt",FTy 5),Var("rt2",FTy 5)]), + ITE(Bop(And, + Bop(And, + EQ(Var("size",F64), + ITE(EQ(Mop(Size,Var("size",F64)),LN 64),LW(2,64), + LW(3,64))), + Bop(In,Var("memop",CTy"MemOp"), + SL[LC("MemOp_LOAD",CTy"MemOp"), + LC("MemOp_STORE",CTy"MemOp")])), + Bop(In,Var("acctype",CTy"AccType"), + SL[LC("AccType_ORDERED",CTy"AccType"), + LC("AccType_ATOMIC",CTy"AccType")])), + Call + ("ARM8",CTy"MachineCode", + CC[Mop(Cast(FTy 2),Var("size",F64)),LW(16,7), + Mop(Cast F1, + EQ(Var("memop",CTy"MemOp"), + LC("MemOp_LOAD",CTy"MemOp"))),LW(1,1), + Var("rs",FTy 5), + Mop(Cast F1, + EQ(Var("acctype",CTy"AccType"), + LC("AccType_ORDERED",CTy"AccType"))), + Var("rt2",FTy 5),Var("rn",FTy 5),Var("rt",FTy 5)]), + Call("BadCode",CTy"MachineCode",LS"LoadStoreAcquirePair"))), + (Call + ("LoadStoreAcquirePair@128",CTy"LoadStore", + TP[Var("size",FTy 128),Var("memop",CTy"MemOp"), + Var("acctype",CTy"AccType"),bVar"rn_unknown", + bVar"rt_unknown",Var("rs",FTy 5),Var("rn",FTy 5), + Var("rt",FTy 5),Var("rt2",FTy 5)]), + ITE(Bop(And, + Bop(And, + EQ(Var("size",FTy 128), + ITE(EQ(Mop(Size,Var("size",FTy 128)),LN 64), + LW(2,128),LW(3,128))), + Bop(In,Var("memop",CTy"MemOp"), + SL[LC("MemOp_LOAD",CTy"MemOp"), + LC("MemOp_STORE",CTy"MemOp")])), + Bop(In,Var("acctype",CTy"AccType"), + SL[LC("AccType_ORDERED",CTy"AccType"), + LC("AccType_ATOMIC",CTy"AccType")])), + Call + ("ARM8",CTy"MachineCode", + CC[Mop(Cast(FTy 2),Var("size",FTy 128)),LW(16,7), + Mop(Cast F1, + EQ(Var("memop",CTy"MemOp"), + LC("MemOp_LOAD",CTy"MemOp"))),LW(1,1), + Var("rs",FTy 5), + Mop(Cast F1, + EQ(Var("acctype",CTy"AccType"), + LC("AccType_ORDERED",CTy"AccType"))), + Var("rt2",FTy 5),Var("rn",FTy 5),Var("rt",FTy 5)]), + Call("BadCode",CTy"MachineCode",LS"LoadStoreAcquirePair")))])) +; +val Encode_def = Def + ("Encode", + TP[Var("imm_enc",ATy(CTy"imm32_64",OTy(PTy(F1,PTy(FTy 6,FTy 6))))), + Var("i",CTy"instruction")], + CS(Var("i",CTy"instruction"), + [(Call + ("Address",CTy"instruction", + TP[bVar"page",Var("imm",F64),Var("rd",FTy 5)]), + ITE(bVar"page", + Let(Var("immlo",FTy 2),EX(Var("imm",F64),LN 13,LN 12,FTy 2), + Let(Var("immhi",FTy 19), + EX(Var("imm",F64),LN 32,LN 14,FTy 19), + ITE(EQ(Mop(SE F64, + CC[Var("immhi",FTy 19),Var("immlo",FTy 2), + LW(0,12)]),Var("imm",F64)), + Call + ("ARM8",CTy"MachineCode", + CC[LW(1,1),Var("immlo",FTy 2),LW(16,5), + Var("immhi",FTy 19),Var("rd",FTy 5)]), + Call("BadCode",CTy"MachineCode",LS"Address")))), + Let(Var("immlo",FTy 2),EX(Var("imm",F64),LN 1,LN 0,FTy 2), + Let(Var("immhi",FTy 19), + EX(Var("imm",F64),LN 20,LN 2,FTy 19), + ITE(EQ(Mop(SE F64, + CC[Var("immhi",FTy 19),Var("immlo",FTy 2)]), + Var("imm",F64)), + Call + ("ARM8",CTy"MachineCode", + CC[LW(0,1),Var("immlo",FTy 2),LW(16,5), + Var("immhi",FTy 19),Var("rd",FTy 5)]), + Call("BadCode",CTy"MachineCode",LS"Address")))))), + (Call("Data",CTy"instruction",Var("x",CTy"Data")), + Call + ("e_data",CTy"MachineCode", + TP[Var("imm_enc", + ATy(CTy"imm32_64",OTy(PTy(F1,PTy(FTy 6,FTy 6))))), + Var("x",CTy"Data")])), + (Call("Branch",CTy"instruction",Var("x",CTy"Branch")), + Call("e_branch",CTy"MachineCode",Var("x",CTy"Branch"))), + (Call("LoadStore",CTy"instruction",Var("x",CTy"LoadStore")), + Call("e_load_store",CTy"MachineCode",Var("x",CTy"LoadStore"))), + (Call("CRCExt",CTy"instruction",Var("x",CTy"CRCExt")), + Call + ("ARM8",CTy"MachineCode",Call("e_crc",F32,Var("x",CTy"CRCExt")))), + (Call("Debug",CTy"instruction",Var("x",CTy"Debug")), + Call + ("ARM8",CTy"MachineCode",Call("e_debug",F32,Var("x",CTy"Debug")))), + (Call("System",CTy"instruction",Var("x",CTy"System")), + Call + ("ARM8",CTy"MachineCode", + Call("e_system",F32,Var("x",CTy"System")))), + (Call + ("MemoryBarrier",CTy"instruction", + TP[Var("opc",CTy"MemBarrierOp"),Var("crm",F4)]), + Call + ("ARM8",CTy"MachineCode", + CC[LW(872499,20),Var("crm",F4),LW(1,1), + Mop(Cast(FTy 2),Var("opc",CTy"MemBarrierOp")),LW(31,5)])), + (Call("ClearExclusive",CTy"instruction",Var("crm",F4)), + Call + ("ARM8",CTy"MachineCode", + CC[LW(872499,20),Var("crm",F4),LW(95,8)])), + (Call("Hint",CTy"instruction",Var("opc",CTy"SystemHintOp")), + Call + ("ARM8",CTy"MachineCode", + CC[LW(13959968,24), + Mop(Cast(FTy 3),Var("opc",CTy"SystemHintOp")),LW(31,5)])), + (Const("Unallocated",CTy"instruction"), + Call("BadCode",CTy"MachineCode",LS"Unallocated")), + (Const("Reserved",CTy"instruction"), + Call("BadCode",CTy"MachineCode",LS"Reserved"))])) val () = Import.finish 1 \ No newline at end of file diff --git a/examples/l3-machine-code/arm8/model/arm8_encodeScript.sml b/examples/l3-machine-code/arm8/model/arm8_encodeScript.sml new file mode 100644 index 0000000000..ae75092ea7 --- /dev/null +++ b/examples/l3-machine-code/arm8/model/arm8_encodeScript.sml @@ -0,0 +1,48 @@ +open HolKernel boolLib bossLib +open arm8AssemblerLib +open sptreeTheory arm8Theory + +val () = new_theory "arm8_encode" + +(* ----------------------------------------------------------------------- *) + +(* + +val () = Globals.max_print_depth := 10 + +*) + +val () = sptreeSyntax.temp_add_sptree_printer() + +val sptree_mask32_def = zDefine `sptree_mask32 = ^m32` +val sptree_mask64_def = zDefine `sptree_mask64 = ^m64` + +val EncodeBitMask_def = zDefine` + (EncodeBitMask (Imm32 i) = sptree$lookup (w2n i) sptree_mask32) /\ + (EncodeBitMask (Imm64 i) = sptree$lookup (w2n i) sptree_mask64)` + +val InstructionEncode_def = Define` + InstructionEncode ast = arm8$Encode (EncodeBitMask, ast)` + +val () = export_theory () + +(* ----------------------------------------------------------------------- *) + +(* Testing + +open sptreeSyntax wordsLib arm8_encodeTheory + +val EncodeBitMask_CONV = PURE_REWRITE_CONV [EncodeBitMask_def] THENC lookup_CONV +val () = computeLib.add_convs [(``EncodeBitMask``, 1, EncodeBitMask_CONV)] + +Count.apply EVAL ``EncodeBitMask (Imm32 0xFFw)`` +Count.apply EVAL ``EncodeBitMask (Imm64 0xFFw)`` + +val () = Globals.max_print_depth := ~1 + +open MutableMap arm8AssemblerLib + +EVAL ``size ^(arm8AssemblerLib.m32)`` (* 1302 *) +EVAL ``size ^(arm8AssemblerLib.m64)`` (* 5334 *) + +*) diff --git a/examples/l3-machine-code/arm8/step/arm8_stepLib.sml b/examples/l3-machine-code/arm8/step/arm8_stepLib.sml index 4c61099aa8..48c3640f3a 100644 --- a/examples/l3-machine-code/arm8/step/arm8_stepLib.sml +++ b/examples/l3-machine-code/arm8/step/arm8_stepLib.sml @@ -139,6 +139,9 @@ val Address_rwt = (* ---------------------------- *) +val Nop_rwt = + EV [dfn'Hint_def] [] [] ``dfn'Hint SystemHintOp_NOP`` + val AddSubCarry_rwt = EV [dfn'AddSubCarry_def] (SPLIT_31 "d") (TF0 `setflags`) ``dfn'AddSubCarry (sf, sub_op, setflags, m, n, d)`` @@ -485,7 +488,13 @@ local v2w [x2; x3; x4; x5; x6; x7],F)= SOME (imm:word64, x)` ] - val r1 = REWRITE_RULE [] + val r_rwt = + utilsLib.map_conv + (EVAL THENC REWRITE_CONV [arm8Theory.num2SystemHintOp_thm]) + [``v2w [F; F; F] <+ 6w: word3``, + ``arm8$num2SystemHintOp (w2n (v2w [F; F; F]: word3))``] + + val r1 = REWRITE_RULE [r_rwt] val r2 = utilsLib.INST_REWRITE_RULE (LoadStoreImmediate @ LoadStorePair) val r3 = utilsLib.ALL_HYP_CONV_RULE @@ -612,7 +621,8 @@ val ps = (List.concat o List.map decode_rwt) ("LoadStoreRegister", "..TTTFFF..T______T__TF__________"), ("StorePair32", "FFTFTFF_.F______________________"), ("LoadPair32", "F_TFTFF_.T______________________"), - ("LoadStorePair64", "TFTFTFF_..______________________") + ("LoadStorePair64", "TFTFTFF_..______________________"), + ("NoOperation", "TTFTFTFTFFFFFFTTFFTFFFFFFFFTTTTT") ] local @@ -678,7 +688,7 @@ local MultiplyHigh_rwt @ Reverse32_rwt @ Reverse64_rwt @ CRC_rwt @ BranchImmediate_rwt @ BranchRegister_rwt @ BranchConditional_rwt @ CompareAndBranch_rwt @ TestBitAndBranch_rwt @ LoadStoreImmediate_rwt @ - LoadStoreRegister_rwt @ LoadLiteral_rwt @ LoadStorePair_rwt + LoadStoreRegister_rwt @ LoadLiteral_rwt @ LoadStorePair_rwt @ Nop_rwt ) val get_next = Term.rator o utilsLib.lhsc val r = REWRITE_RULE [] diff --git a/examples/l3-machine-code/lib/L3.sig b/examples/l3-machine-code/lib/L3.sig index 1c67836f1e..09a5222d29 100644 --- a/examples/l3-machine-code/lib/L3.sig +++ b/examples/l3-machine-code/lib/L3.sig @@ -5,13 +5,18 @@ signature L3 = sig val K : 'a -> 'b -> 'a + val drop : int * 'a list -> 'a list + val dropString : int * string -> string + val element : int * 'a list -> 'a val equal : ''a -> ''a -> bool - val for : int * int * (int -> 'a) -> unit + val for : int * int * (int -> unit) -> unit + val foreach : 'a list * ('a -> unit) -> unit + val indexOf : ''a * ''a list -> int option + val indexOfString : char * string -> int option val fst : 'a * 'b -> 'a val listCompare : ('a * 'a -> order) -> 'a list * 'a list -> order val lowercase : string -> string - val mem : ''a * ''a list -> bool - val mkSet : ''a list -> ''a list + val memString : char * string -> bool val padLeft : 'a * (int * 'a list) -> 'a list val padLeftString : char * (int * string) -> string val padRight : 'a * (int * 'a list) -> 'a list @@ -19,12 +24,21 @@ sig val pairCompare : ('a * 'a -> order) * ('b * 'b -> order) -> ('a * 'b) * ('a * 'b) -> order val prefix : char * string -> string + val remove : ''a list * ''a list -> ''a list + val removeExceptString : string * string -> string + val removeString : string * string -> string + val removeDuplicatesString : string -> string + val revLookup : ('a -> 'a -> bool) -> 'a * 'a list -> int option val revString : string -> string val snd : 'a * 'b -> 'b val splitl : (char -> bool) * string -> string * string val splitr : (char -> bool) * string -> string * string val strHd : string -> char val strTl : string -> string + val stringToChar : string -> char + val swap : 'a * 'b -> 'b * 'a + val take : int * 'a list -> 'a list + val takeString : int * string -> string val uncurry : ('a -> 'b -> 'c) -> 'a * 'b -> 'c val update : (''a -> 'b) -> ''a -> 'b -> ''a -> 'b val uppercase : string -> string diff --git a/examples/l3-machine-code/lib/L3.sml b/examples/l3-machine-code/lib/L3.sml index 1729806d78..24fd0831eb 100644 --- a/examples/l3-machine-code/lib/L3.sml +++ b/examples/l3-machine-code/lib/L3.sml @@ -27,6 +27,9 @@ struct else for (if Nat.< (i, j) then Nat.suc i else Nat.pred i, j, a) ) + fun foreach ([], _) = () + | foreach (h :: t, a) = (a h; foreach (t, a)) + fun pairCompare (cmp1, cmp2) ((a: 'a, b: 'b), (c: 'a, d :'b)) = case cmp1 (a, c) of General.EQUAL => cmp2 (b, d) @@ -46,15 +49,6 @@ struct ((List.length l1, l1), (List.length l2, l2)) end - fun mem (i, l) = List.exists (fn x => x = i) l - - local - fun insert i l = if mem (i, l) then l else i :: l - in - fun mkSet [] = [] - | mkSet (h :: t) = insert h (mkSet t) - end - local fun liftSubstring (f, s) = let @@ -73,6 +67,39 @@ struct l @ List.tabulate (Nat.- (n, List.length l), fn _ => e) fun padLeftString (e, (n, l)) = StringCvt.padLeft e n l fun padRightString (e, (n, l)) = StringCvt.padRight e n l + fun takeString (n, s) = String.extract (s, 0, SOME n) + fun dropString (n, s) = String.extract (s, n, NONE) + val removeDuplicatesString = String.implode o Set.mk o String.explode val revString = String.implode o List.rev o String.explode + fun stringToChar s = + if String.size s = 1 then String.sub (s, 0) else raise Domain + fun memString (c, s) = String.isSubstring (String.str c) s + + local + fun trans P (s, r) = + String.translate + (fn d => let val x = String.str d in if P x r then "" else x end) s + in + val removeExceptString = + trans (fn x => fn r => not (String.isSubstring x r)) + val removeString = trans String.isSubstring + end + + fun revLookup eq (e, l) = + let + fun loop i = + fn [] => NONE + | h :: t => if eq e h then SOME i else loop (i + 1) t + in + loop 0 l + end + + fun remove (l1, l2) = List.filter (fn x => not (Set.mem (x, l2))) l1 + fun swap (n, l) = (l, n) + fun take (n, l) = List.take (l, n) + fun drop (n, l) = List.drop (l, n) + fun element (n, l) = List.nth (l, n) + fun indexOf x = revLookup equal x + fun indexOfString (c, s) = revLookup equal (c, String.explode s) end (* structure L3 *) diff --git a/examples/l3-machine-code/lib/Set.sig b/examples/l3-machine-code/lib/Set.sig new file mode 100644 index 0000000000..5612362148 --- /dev/null +++ b/examples/l3-machine-code/lib/Set.sig @@ -0,0 +1,15 @@ +(* ------------------------------------------------------------------------- + Set + ------------------------------------------------------------------------- *) + +signature Set = +sig + val diff : ''a list * ''a list -> ''a list + val equal : ''a list * ''a list -> bool + val insert : ''a * ''a list -> ''a list + val intersect : ''a list * ''a list -> ''a list + val isSubset : ''a list * ''a list -> bool + val mem : ''a * ''a list -> bool + val mk : ''a list -> ''a list + val union : ''a list * ''a list -> ''a list +end diff --git a/examples/l3-machine-code/lib/Set.sml b/examples/l3-machine-code/lib/Set.sml new file mode 100644 index 0000000000..8e0aee61d1 --- /dev/null +++ b/examples/l3-machine-code/lib/Set.sml @@ -0,0 +1,26 @@ +(* ------------------------------------------------------------------------- + Set + ------------------------------------------------------------------------- *) + +structure Set :> Set = +struct + + fun mem (i, l) = List.exists (fn x => x = i) l + + fun insert (i, l) = if mem (i, l) then l else i :: l + + fun mk [] = [] + | mk (h :: t) = if mem (h, t) then mk t else h :: mk t + + fun diff (s1, s2) = List.filter (fn x => not (mem (x, s2))) s1 + fun intersect (s1, s2) = List.filter (fn x => mem (x, s2)) s1 + fun isSubset (s1, s2) = List.all (fn x => mem (x, s2)) s1 + + fun equal (s1, s2) = + List.length s1 = List.length s2 andalso intersect (s1, s2) = s1 + + fun union ([], s) = s + | union (s, []) = s + | union (h :: t, s) = union (t, insert (h, s)) + +end (* structure Set *) diff --git a/examples/l3-machine-code/m0/model/m0.sig b/examples/l3-machine-code/m0/model/m0.sig index 455c2b1780..168fac2e3b 100644 --- a/examples/l3-machine-code/m0/model/m0.sig +++ b/examples/l3-machine-code/m0/model/m0.sig @@ -1,4 +1,4 @@ -(* m0 - generated by L<3> - Fri May 16 15:39:31 2014 *) +(* m0 - generated by L<3> - Tue Nov 18 15:29:59 2014 *) signature m0 = sig diff --git a/examples/l3-machine-code/m0/model/m0.sml b/examples/l3-machine-code/m0/model/m0.sml index 4350410ee7..b2d39badd9 100644 --- a/examples/l3-machine-code/m0/model/m0.sml +++ b/examples/l3-machine-code/m0/model/m0.sml @@ -1,4 +1,4 @@ -(* m0 - generated by L<3> - Fri May 16 15:39:31 2014 *) +(* m0 - generated by L<3> - Tue Nov 18 15:29:59 2014 *) structure m0 :> m0 = struct @@ -1848,7 +1848,7 @@ fun DataProcessing (opc,(setflags,(d,(n,(imm32,C))))) = val rn = if (opc = (BitsN.B(0xD,4))) orelse (opc = (BitsN.B(0xF,4))) then BitsN.B(0x0,32) - else if ((L3.mem(opc,[BitsN.B(0x4,4),BitsN.B(0x2,4)])) andalso + else if ((Set.mem(opc,[BitsN.B(0x4,4),BitsN.B(0x2,4)])) andalso (n = (BitsN.B(0xF,4)))) andalso (not setflags) then Align 32 (PC (),4) else R n @@ -3457,8 +3457,8 @@ fun DecodeThumb2 h = BitsN.fromBitstring ([SYSm'7,SYSm'6,SYSm'5,SYSm'4,SYSm'3,SYSm'2,SYSm'1,SYSm'0],8) in - ( if (L3.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse - (not(L3.mem + ( if (Set.mem(Rn,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse + (not(Set.mem (SYSm, [BitsN.B(0x0,8),BitsN.B(0x1,8),BitsN.B(0x2,8), BitsN.B(0x3,8),BitsN.B(0x5,8),BitsN.B(0x6,8), @@ -3518,8 +3518,8 @@ fun DecodeThumb2 h = ([SYSm'7,SYSm'6,SYSm'5,SYSm'4,SYSm'3,SYSm'2,SYSm'1,SYSm'0],8) val Rd = BitsN.fromBitstring([Rd'3,Rd'2,Rd'1,Rd'0],4) in - ( if (L3.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse - (not(L3.mem + ( if (Set.mem(Rd,[BitsN.B(0xD,4),BitsN.B(0xF,4)])) orelse + (not(Set.mem (SYSm, [BitsN.B(0x0,8),BitsN.B(0x1,8),BitsN.B(0x2,8), BitsN.B(0x3,8),BitsN.B(0x5,8),BitsN.B(0x6,8), @@ -3628,7 +3628,7 @@ fun EncodeImmShift (shift_t,shift_n) = fun e_branch (c,(ast,e)) = case ast of BranchTarget imm32 => - (if L3.mem(c,[BitsN.B(0xE,4),BitsN.B(0xF,4)]) + (if Set.mem(c,[BitsN.B(0xE,4),BitsN.B(0xF,4)]) then if ((BitsN.<=(BitsN.neg(BitsN.B(0x800,32)),imm32)) andalso (BitsN.<=(imm32,BitsN.B(0x7FE,32)))) andalso (not(e = Enc_Wide)) @@ -3679,7 +3679,7 @@ fun e_data ast = (BitsN.concat [BitsN.B(0x4,5),BitsN.bits(d,2,0),BitsN.bits(imm32,7,0)]) | ArithLogicImmediate(opc,(setflags,(d,(n,imm32)))) => - (if (((L3.mem(opc,[BitsN.B(0x4,4),BitsN.B(0x2,4)])) andalso + (if (((Set.mem(opc,[BitsN.B(0x4,4),BitsN.B(0x2,4)])) andalso (BitsN.<=+(imm32,BitsN.B(0x7,32)))) andalso setflags) andalso (not((BitsN.bit(d,3)) orelse (BitsN.bit(n,3)))) then let @@ -3690,7 +3690,7 @@ fun e_data ast = in Thumb16(BitsN.concat[BitsN.B(0x7,6),S,imm3,Rn,Rd]) end - else if ((((L3.mem(opc,[BitsN.B(0x4,4),BitsN.B(0x2,4)])) andalso + else if ((((Set.mem(opc,[BitsN.B(0x4,4),BitsN.B(0x2,4)])) andalso (d = n)) andalso (BitsN.<=+(imm32,BitsN.B(0xFF,32)))) andalso setflags) andalso (not(BitsN.bit(d,3))) then let @@ -3710,7 +3710,7 @@ fun e_data ast = Thumb16(BitsN.concat[BitsN.B(0x109,10),Rn,Rd]) end else if (((((opc = (BitsN.B(0x4,4))) andalso (not setflags)) andalso - (L3.mem(n,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) andalso + (Set.mem(n,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) andalso (not setflags)) andalso ((BitsN.&&(imm32,BitsN.B(0xFFFFFC03,32))) = (BitsN.B(0x0,32)))) andalso (not(BitsN.bit(d,3))) @@ -3721,7 +3721,7 @@ fun e_data ast = in Thumb16(BitsN.concat[BitsN.B(0xA,4),S,Rd,imm8]) end - else if (((((L3.mem(opc,[BitsN.B(0x4,4),BitsN.B(0x2,4)])) andalso + else if (((((Set.mem(opc,[BitsN.B(0x4,4),BitsN.B(0x2,4)])) andalso (d = (BitsN.B(0xD,4)))) andalso (n = (BitsN.B(0xD,4)))) andalso (not setflags)) andalso ((BitsN.&&(imm32,BitsN.B(0xFFFFFE03,32))) = (BitsN.B(0x0,32)))) andalso @@ -3734,7 +3734,7 @@ fun e_data ast = end else BadCode("ArithLogicImmediate")) | Register(opc,(setflags,(d,(n,m)))) => - (if ((L3.mem(opc,[BitsN.B(0x2,4),BitsN.B(0x4,4)])) andalso setflags) andalso + (if ((Set.mem(opc,[BitsN.B(0x2,4),BitsN.B(0x4,4)])) andalso setflags) andalso (not(((BitsN.bit(d,3)) orelse (BitsN.bit(n,3))) orelse (BitsN.bit(m,3)))) then let @@ -3745,7 +3745,7 @@ fun e_data ast = in Thumb16(BitsN.concat[BitsN.B(0x6,6),S,Rm,Rn,Rd]) end - else if (((L3.mem + else if (((Set.mem (opc, [BitsN.B(0x0,4),BitsN.B(0x1,4),BitsN.B(0x5,4), BitsN.B(0x6,4),BitsN.B(0xC,4),BitsN.B(0xE,4)])) andalso @@ -3799,7 +3799,7 @@ fun e_data ast = in Thumb16(BitsN.concat[BitsN.B(0x10F,10),Rm,Rd]) end - else if ((L3.mem(shift_t,[SRType_LSL,SRType_LSR,SRType_ASR])) andalso + else if ((Set.mem(shift_t,[SRType_LSL,SRType_LSR,SRType_ASR])) andalso setflags) andalso (not((negate orelse (BitsN.bit(m,3))) orelse (BitsN.bit(d,3)))) then let @@ -4191,7 +4191,7 @@ fun p_label s = let val (l,r) = L3.splitl - (fn c => (Char.isAlphaNum c) orelse (L3.mem(c,[#"_",#"."])),t) + (fn c => (Char.isAlphaNum c) orelse (Set.mem(c,[#"_",#"."])),t) in if ((r = ("")) andalso (not(l = ("")))) andalso (not(Char.isDigit(L3.strHd l))) @@ -4225,7 +4225,7 @@ fun p_cond s = fun p_suffix s = case L3.uncurry String.fields (fn c => c = #".",s) of [cond,s] => - (case (p_cond cond,L3.mem(s,["w","n"])) of + (case (p_cond cond,Set.mem(s,["w","n"])) of (Option.SOME c,true) => Option.SOME(c,s) | _ => NONE) | [cond] => @@ -4304,7 +4304,7 @@ fun p_shift_amount (typ,(h,s)) = then case p_unbounded_immediate s of Option.SOME n => (if (Nat.<(n,32)) orelse - ((n = 32) andalso (L3.mem(typ,[SRType_LSR,SRType_ASR]))) + ((n = 32) andalso (Set.mem(typ,[SRType_LSR,SRType_ASR]))) then ("",(typ,NAT n)) else ("shift amount too large",(SRType_LSL,NAT 0))) | NONE => @@ -4413,7 +4413,7 @@ fun p_shift_full (c,(typ,l)) = Option.SOME n => (if (Nat.<(n,32)) orelse ((n = 32) andalso - (L3.mem(typ,[SRType_LSR,SRType_ASR]))) + (Set.mem(typ,[SRType_LSR,SRType_ASR]))) then OK(c, Data (ShiftImmediate @@ -4762,7 +4762,7 @@ fun p_ldm_stm (c,(load,l)) = let val (r,wb) = L3.splitr(fn c => c = #"!",stripSpaces h) in - case (p_register r,(p_registers t,L3.mem(wb,["","!"]))) of + case (p_register r,(p_registers t,Set.mem(wb,["","!"]))) of (Option.SOME rn,(Option.SOME w,true)) => (if (BitsN.bits(w,15,8)) = (BitsN.B(0x0,8)) then let diff --git a/examples/l3-machine-code/mips/model/mips.sig b/examples/l3-machine-code/mips/model/mips.sig index 83cffc737c..08a09f3d89 100644 --- a/examples/l3-machine-code/mips/model/mips.sig +++ b/examples/l3-machine-code/mips/model/mips.sig @@ -1,4 +1,4 @@ -(* mips - generated by L<3> - Wed Oct 29 16:00:41 2014 *) +(* mips - generated by L<3> - Tue Nov 18 15:34:51 2014 *) signature mips = sig diff --git a/examples/l3-machine-code/mips/model/mips.sml b/examples/l3-machine-code/mips/model/mips.sml index 2f641f8a45..83ac8046b2 100644 --- a/examples/l3-machine-code/mips/model/mips.sml +++ b/examples/l3-machine-code/mips/model/mips.sml @@ -1,4 +1,4 @@ -(* mips - generated by L<3> - Wed Oct 29 16:00:41 2014 *) +(* mips - generated by L<3> - Tue Nov 18 15:34:51 2014 *) structure mips :> mips = struct @@ -2885,12 +2885,12 @@ fun SignalException ExceptionType = else BitsN.B(0xFFFFFFFF80000000,64) in ( BranchDelay := NONE - ; BranchTo := - (Option.SOME - (true, - BitsN.@@ + ; PC := + (BitsN.- + (BitsN.@@ (BitsN.bits(vectorBase,63,30), - BitsN.+(BitsN.bits(vectorBase,29,0),vectorOffset)))) + BitsN.+(BitsN.bits(vectorBase,29,0),vectorOffset)), + BitsN.B(0x4,64))) ; exceptionSignalled := true ) end @@ -4543,11 +4543,11 @@ fun dfn'BREAK () = SignalException Bp; fun dfn'SYSCALL () = SignalException Sys; fun dfn'ERET () = - if ((#CU0)((#Status) (!CP0))) orelse (KernelMode ()) + if Option.isSome (!BranchDelay) + then raise UNPREDICTABLE ("ERET follows branch") + else if ((#CU0)((#Status) (!CP0))) orelse (KernelMode ()) then ( if (#ERL)((#Status) (!CP0)) - then ( BranchTo := - (Option.SOME - (true,BitsN.-((#ErrorEPC) (!CP0),BitsN.B(0x4,64)))) + then ( PC := (BitsN.-((#ErrorEPC) (!CP0),BitsN.B(0x4,64))) ; let val x0 = (#Status) (!CP0) in @@ -4556,9 +4556,7 @@ fun dfn'ERET () = ((!CP0),StatusRegister_ERL_rupd(x0,false))) end ) - else ( BranchTo := - (Option.SOME - (true,BitsN.-((#EPC) (!CP0),BitsN.B(0x4,64)))) + else ( PC := (BitsN.-((#EPC) (!CP0),BitsN.B(0x4,64))) ; let val x0 = (#Status) (!CP0) in diff --git a/examples/l3-machine-code/x64/model/x64.sig b/examples/l3-machine-code/x64/model/x64.sig index 6ff4efedc7..e241d45e14 100644 --- a/examples/l3-machine-code/x64/model/x64.sig +++ b/examples/l3-machine-code/x64/model/x64.sig @@ -1,4 +1,4 @@ -(* x64 - generated by L<3> - Fri Aug 29 10:14:41 2014 *) +(* x64 - generated by L<3> - Tue Nov 18 15:39:44 2014 *) signature x64 = sig diff --git a/examples/l3-machine-code/x64/model/x64.sml b/examples/l3-machine-code/x64/model/x64.sml index a0d72af02f..f34a318271 100644 --- a/examples/l3-machine-code/x64/model/x64.sml +++ b/examples/l3-machine-code/x64/model/x64.sml @@ -1,4 +1,4 @@ -(* x64 - generated by L<3> - Fri Aug 29 10:14:41 2014 *) +(* x64 - generated by L<3> - Tue Nov 18 15:39:44 2014 *) structure x64 :> x64 = struct @@ -562,7 +562,7 @@ fun EA ea = Zea_i i => restrictSize i | Zea_r(Z8 have_rex,r) => BitsN.&& - (if have_rex orelse (not(L3.mem(r,[RSP,RBP,RSI,RDI]))) + (if have_rex orelse (not(Set.mem(r,[RSP,RBP,RSI,RDI]))) then Map.lookup((!REG),Cast.ZregToNat r) else BitsN.>>+ (Map.lookup @@ -580,7 +580,7 @@ fun write'EA (w,ea) = case ea of Zea_i i => raise FAILURE ("write to constant") | Zea_r(Z8 have_rex,r) => - (if have_rex orelse (not(L3.mem(r,[RSP,RBP,RSI,RDI]))) + (if have_rex orelse (not(Set.mem(r,[RSP,RBP,RSI,RDI]))) then let val w0 = Map.lookup((!REG),Cast.ZregToNat r) in @@ -1339,9 +1339,9 @@ fun readPrefix (s,(p,strm)) = then Option.SOME(p,(false,(rec'REX(BitsN.B(0x0,4)),strm))) else if group = 5 then Option.SOME(p,(true,(rec'REX(BitsN.bits(h,3,0)),strm1))) - else if L3.mem(group,s) + else if Set.mem(group,s) then NONE - else readPrefix((op ::) (group,s),(h :: p,strm1)) + else readPrefix(Set.insert(group,s),(h :: p,strm1)) end | [] => Option.SOME @@ -1361,12 +1361,12 @@ fun x64_decode strm = NONE => Zdec_fail("Bad prefix") | Option.SOME(p,(have_rex,(REX,strm1))) => let - val prefixes = L3.mkSet p - val op_size_override = L3.mem(BitsN.B(0x66,8),prefixes) + val prefixes = Set.mk p + val op_size_override = Set.mem(BitsN.B(0x66,8),prefixes) in if ((#W) REX) andalso op_size_override then Zdec_fail("REX.W together with override prefix") - else if L3.mem(BitsN.B(0x67,8),prefixes) + else if Set.mem(BitsN.B(0x67,8),prefixes) then Zdec_fail("address override prefix not supported") else case strm1 of v'0 :: v'1 => @@ -2079,7 +2079,7 @@ fun e_ModRM (r,rm) = then (0,[]) else e_imm_8_32 imm in - if L3.mem(s,[0,1,4]) + if Set.mem(s,[0,1,4]) then (BitsN.concat [BitsN.B(0x0,1),BitsN.bits(r,3,3),BitsN.bits(i,3,3), BitsN.bits(b,3,3)], @@ -2103,7 +2103,7 @@ fun e_ModRM (r,rm) = then (0,[]) else e_imm_8_32 imm in - if L3.mem(s,[0,1,4]) + if Set.mem(s,[0,1,4]) then (BitsN.concat [BitsN.B(0x0,1),BitsN.bits(r,3,3),BitsN.B(0x0,1), BitsN.bits(base,3,3)], @@ -2584,7 +2584,7 @@ fun p_label s = let val (l,r) = L3.splitl - (fn c => (Char.isAlphaNum c) orelse (L3.mem(c,[#"_",#"."])),t) + (fn c => (Char.isAlphaNum c) orelse (Set.mem(c,[#"_",#"."])),t) in if ((r = ("")) andalso (not(l = ("")))) andalso (not(Char.isDigit(L3.strHd l))) @@ -2698,7 +2698,7 @@ fun p_disp (b,s) = fun p_rip_disp s = let val (l,r) = - L3.splitl(fn c => not(L3.mem(c,[#"+",#"-"])),stripLeftSpaces s) + L3.splitl(fn c => not(Set.mem(c,[#"+",#"-"])),stripLeftSpaces s) in if l = ("") then if r = ("") @@ -2731,7 +2731,8 @@ fun p_parts (m,s) = | (#"-" :: t,(si,(b,disp))) => let val (l,r) = - L3.splitl(fn c => not(L3.mem(c,[#"+",#"-"])),String.implode t) + L3.splitl + (fn c => not(Set.mem(c,[#"+",#"-"])),String.implode t) in case (p_imm32(("-") ^ l),disp) of (NONE,_) => (NONE,(NONE,NONE)) @@ -2742,7 +2743,8 @@ fun p_parts (m,s) = | (#"+" :: t,(si,(b,disp))) => let val (l,r) = - L3.splitl(fn c => not(L3.mem(c,[#"+",#"-"])),String.implode t) + L3.splitl + (fn c => not(Set.mem(c,[#"+",#"-"])),String.implode t) in case (p_imm32 l,disp) of (NONE,_) => @@ -2781,7 +2783,8 @@ fun p_parts (m,s) = | (t,(si,(b,disp))) => let val (l,r) = - L3.splitl(fn c => not(L3.mem(c,[#"+",#"-"])),String.implode t) + L3.splitl + (fn c => not(Set.mem(c,[#"+",#"-"])),String.implode t) in case (p_imm32 l,disp) of (NONE,_) => @@ -3167,7 +3170,7 @@ fun instructionFromString s = in case p_cond(String.implode cond) of Option.SOME c => - (if L3.mem(c,[Z_ALWAYS,Z_E,Z_NE]) + (if Set.mem(c,[Z_ALWAYS,Z_E,Z_NE]) then case p_imm8 i of Option.SOME imm => OK(Zloop(c,BitsN.-(imm,BitsN.B(0x2,64)))) From 37c691515f7aa91f8dfa4c6b817656d3de359e8e Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Wed, 19 Nov 2014 15:09:33 +0000 Subject: [PATCH 030/718] The MIPS tools were experiencing problems with NOP instructions. Reported by Brian Campbell. --- examples/l3-machine-code/mips/step/Holmakefile | 2 +- examples/l3-machine-code/mips/step/mips_stepLib.sml | 7 ++++++- 2 files changed, 7 insertions(+), 2 deletions(-) diff --git a/examples/l3-machine-code/mips/step/Holmakefile b/examples/l3-machine-code/mips/step/Holmakefile index b85938bbc0..549bde284a 100644 --- a/examples/l3-machine-code/mips/step/Holmakefile +++ b/examples/l3-machine-code/mips/step/Holmakefile @@ -5,7 +5,7 @@ ifdef POLY HOLHEAP = mips-heap EXTRA_CLEANS = $(HOLHEAP) $(HOLHEAP).o -BARE_THYS = ../model/mipsLib ../../Lib/MutableMap ../model/mips +BARE_THYS = ../model/mipsLib ../../lib/MutableMap ../model/mips DEPS = $(patsubst %,%.uo,$(BARE_THYS)) THYFILES = $(patsubst %Script.sml,%Theory.uo,$(wildcard *.sml)) diff --git a/examples/l3-machine-code/mips/step/mips_stepLib.sml b/examples/l3-machine-code/mips/step/mips_stepLib.sml index 619de90f6c..b0713f8515 100644 --- a/examples/l3-machine-code/mips/step/mips_stepLib.sml +++ b/examples/l3-machine-code/mips/step/mips_stepLib.sml @@ -900,7 +900,12 @@ local (REWRITE_CONV [ASSUME ``^st.BranchDelay = SOME d``, optionTheory.NOT_SOME_NONE]) val NO_BRANCH_DELAY_RULE = - PURE_REWRITE_RULE [boolTheory.COND_ID, ASSUME ``^st.BranchDelay = NONE``] + CONV_RULE + (Lib.funpow 4 RAND_CONV + (LAND_CONV + (RAND_CONV + (PURE_REWRITE_CONV + [boolTheory.COND_ID, ASSUME ``^st.BranchDelay = NONE``])))) val state_rule = Conv.RIGHT_CONV_RULE (Conv.RAND_CONV STATE_CONV) val exc_rule = SIMP_RULE bool_ss [] o COND_UPDATE_RULE o state_rule val MP_Next = state_rule o Drule.MATCH_MP NextStateMIPS_nodelay o From dcc2c549beb22b2aa615f1ebee21b04c0fe80056 Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Mon, 24 Nov 2014 11:21:48 +0000 Subject: [PATCH 031/718] Some fixes for the L3 ARM model. A number of bugs were detected when validating the L3 model against the tests used to check the old (monadic) ARM model. These can be found here: http://www.cl.cam.ac.uk/~mom22/arm-tests/ The bugs were as follows: 1. Off by one error in definition of SignExtendFrom. 2. Off by one error in definition of SignedSatQ. 3. Error in setting Q flag for QDADD. 4. Error in setting the GE flags for USAX and USUB16. 5. Error in the top-halfword result for SXTB16, UXTB16, SXTAB16 and UXTAB16. 6. Error in handling the C flag for some data-processing instructions (looks to affect immediate value variants only). 7. Incorrectly identifying some STRD instructions as unpredictable. Note that 1-5 relate to instructions that are not supported by the decompiler, and 7 just prevented some valid code from being decompiled. As such, 6 is the most significant error fixed here. The model now passes all of the tests. --- examples/l3-machine-code/arm/model/arm.sig | 4 +- examples/l3-machine-code/arm/model/arm.sml | 59 +-- .../l3-machine-code/arm/model/armScript.sml | 361 +++++++++--------- .../l3-machine-code/arm/step/arm_stepLib.sml | 13 +- 4 files changed, 230 insertions(+), 207 deletions(-) diff --git a/examples/l3-machine-code/arm/model/arm.sig b/examples/l3-machine-code/arm/model/arm.sig index ad1a91f342..e6360dada0 100644 --- a/examples/l3-machine-code/arm/model/arm.sig +++ b/examples/l3-machine-code/arm/model/arm.sig @@ -1,4 +1,4 @@ -(* arm - generated by L<3> - Tue Nov 18 15:31:11 2014 *) +(* arm - generated by L<3> - Fri Nov 21 16:33:11 2014 *) signature arm = sig @@ -805,7 +805,7 @@ val DataProcessing: (BitsN.nbit * (bool * (BitsN.nbit * (BitsN.nbit * (BitsN.nbit * bool))))) -> unit val DataProcessingPC: - (BitsN.nbit * (bool * (BitsN.nbit * (BitsN.nbit * bool)))) -> unit + (BitsN.nbit * (bool * (BitsN.nbit * BitsN.nbit))) -> unit val dfn'Move: (bool * (bool * (BitsN.nbit * BitsN.nbit))) -> unit val dfn'TestCompareImmediate: (BitsN.nbit * (BitsN.nbit * BitsN.nbit)) -> unit diff --git a/examples/l3-machine-code/arm/model/arm.sml b/examples/l3-machine-code/arm/model/arm.sml index d79169e2c3..4fd59903de 100644 --- a/examples/l3-machine-code/arm/model/arm.sml +++ b/examples/l3-machine-code/arm/model/arm.sml @@ -1,4 +1,4 @@ -(* arm - generated by L<3> - Tue Nov 18 15:31:11 2014 *) +(* arm - generated by L<3> - Fri Nov 21 16:33:11 2014 *) structure arm :> arm = struct @@ -3272,7 +3272,7 @@ fun BitCount N w = fun SignExtendFrom N (w,p) = let - val s = Nat.-(BitsN.size(BitsN.B(0x0,N)),p) + val s = Nat.-(Nat.-(BitsN.size(BitsN.B(0x0,N)),1),p) in BitsN.>>(BitsN.<<(w,s),s) end; @@ -3287,12 +3287,12 @@ fun SignedSatQ M (i,N) = then raise ASSERT ("SignedSatQ: M < N") else () ; let - val max = Nat.toInt(Nat.-(Nat.pow(2,Nat.-(N,1)),1)) + val max = Nat.toInt(Nat.pow(2,Nat.-(N,1))) in - if Int.>(i,max) - then (BitsN.fromInt(max,M),true) + if Int.>(i,Int.-(max,1)) + then (BitsN.fromInt(Int.-(max,1),M),true) else if Int.<(i,Int.~ max) - then (BitsN.neg(BitsN.fromInt(max,M)),true) + then (BitsN.fromInt(Int.~ max,M),true) else (BitsN.fromInt(i,M),false) end ); @@ -4253,7 +4253,8 @@ fun DataProcessing (opc,(setflags,(d,(n,(imm32,C))))) = (n = (BitsN.B(0xF,4)))) andalso (not setflags) then Align 32 (PC (),4) else R n - val (result,(carry,overflow)) = DataProcessingALU(opc,(rn,(imm32,C))) + val (result,(carry,overflow)) = + DataProcessingALU(opc,(rn,(imm32,(#C) (!CPSR)))) in ( if not((BitsN.bits(opc,3,2)) = (BitsN.B(0x2,2))) then write'R(result,d) @@ -4261,17 +4262,18 @@ fun DataProcessing (opc,(setflags,(d,(n,(imm32,C))))) = ; if setflags then ( CPSR := (PSR_N_rupd((!CPSR),BitsN.bit(result,31))) ; CPSR := (PSR_Z_rupd((!CPSR),result = (BitsN.B(0x0,32)))) - ; CPSR := (PSR_C_rupd((!CPSR),carry)) ; if ArithmeticOpcode opc - then CPSR := (PSR_V_rupd((!CPSR),overflow)) - else () + then ( CPSR := (PSR_C_rupd((!CPSR),carry)) + ; CPSR := (PSR_V_rupd((!CPSR),overflow)) + ) + else CPSR := (PSR_C_rupd((!CPSR),C)) ) else () ; IncPC () ) end; -fun DataProcessingPC (opc,(setflags,(n,(imm32,C)))) = +fun DataProcessingPC (opc,(setflags,(n,imm32))) = let val rn = if (opc = (BitsN.B(0xD,4))) orelse @@ -4281,7 +4283,7 @@ fun DataProcessingPC (opc,(setflags,(n,(imm32,C)))) = (n = (BitsN.B(0xF,4)))) andalso (not setflags) then Align 32 (PC (),4) else R n - val (result,(carry,overflow)) = DataProcessingALU(opc,(rn,(imm32,C))) + val (result,_) = DataProcessingALU(opc,(rn,(imm32,(#C) (!CPSR)))) in if setflags then if CurrentModeIsHyp () @@ -4304,7 +4306,7 @@ fun dfn'Move (setflags,(negate,(d,imm12))) = val (imm32,carry) = ExpandImm_C(imm12,(#C) (!CPSR)) in if d = (BitsN.B(0xF,4)) - then DataProcessingPC(opc,(setflags,(BitsN.B(0xF,4),(imm32,carry)))) + then DataProcessingPC(opc,(setflags,(BitsN.B(0xF,4),imm32))) else DataProcessing(opc,(setflags,(d,(BitsN.B(0xF,4),(imm32,carry))))) end; @@ -4322,7 +4324,7 @@ fun dfn'ArithLogicImmediate (opc,(setflags,(d,(n,imm12)))) = val (imm32,carry) = ExpandImm_C(imm12,(#C) (!CPSR)) in if d = (BitsN.B(0xF,4)) - then DataProcessingPC(opc,(setflags,(n,(imm32,carry)))) + then DataProcessingPC(opc,(setflags,(n,imm32))) else DataProcessing(opc,(setflags,(d,(n,(imm32,carry))))) end; @@ -4330,10 +4332,9 @@ fun doRegister (opc,(setflags,(d,(n,(m,(shift_t,shift_n)))))) = let val (shifted,carry) = Shift_C 32 (R m,(shift_t,(shift_n,(#C) (!CPSR)))) - val carry = if ArithmeticOpcode opc then (#C) (!CPSR) else carry in if d = (BitsN.B(0xF,4)) - then DataProcessingPC(opc,(setflags,(n,(shifted,carry)))) + then DataProcessingPC(opc,(setflags,(n,shifted))) else DataProcessing(opc,(setflags,(d,(n,(shifted,carry))))) end; @@ -4359,7 +4360,6 @@ fun doRegisterShiftedRegister (opc,(setflags,(d,(n,(m,(shift_t,s)))))) = val (shifted,carry) = Shift_C 32 (R m,(shift_t,(BitsN.toNat(BitsN.bits(R s,7,0)),(#C) (!CPSR)))) - val carry = if ArithmeticOpcode opc then (#C) (!CPSR) else carry in DataProcessing(opc,(setflags,(d,(n,(shifted,carry))))) end; @@ -4414,7 +4414,7 @@ fun dfn'SaturatingAddSubtract (opc,(d,(m,n))) = SignedSatQ 32 (Int.+(BitsN.toInt(R m),BitsN.toInt doubled),32) in - ( result := r; sat := sat1 ) + ( result := r; sat := (sat1 orelse sat2) ) end | BitsN.B(0x3,2) => let @@ -4921,7 +4921,7 @@ fun dfn'UnsignedAddSub16 (op',(d,(n,m))) = (w, if Int.>= (res1, - if Set.mem(op',[BitsN.B(0x1,2),BitsN.B(0x2,2)]) + if Set.mem(op',[BitsN.B(0x1,2),BitsN.B(0x3,2)]) then 0 else 65536) then BitsN.B(0x3,2) @@ -5186,7 +5186,7 @@ fun dfn'ExtendByte16 (unsigned,(d,(n,(m,rotation)))) = (BitsN.bits(acc,31,16), Extend (8,16) (unsigned,BitsN.bits(rotated,23,16))) in - ( write'R(BitsN.@@(r1,r1),d); IncPC () ) + ( write'R(BitsN.@@(r2,r1),d); IncPC () ) end; fun dfn'ExtendHalfword (unsigned,(d,(n,(m,rotation)))) = @@ -9861,13 +9861,17 @@ fun DecodeARM w = val wback = (P = (BitsN.B(0x0,1))) orelse (W = (BitsN.B(0x1,1))) + val store = + (BitsN.fromBitstring([S'0],1)) = + (BitsN.B(0x1,1)) in - ( if (((((((BitsN.bit(Rt,0)) orelse - ((P = (BitsN.B(0x0,1))) andalso - (W = (BitsN.B(0x1,1))))) orelse - (Rt2 = (BitsN.B(0xF,4)))) orelse - (Rm = (BitsN.B(0xF,4)))) orelse (Rm = Rt)) orelse - (Rm = Rt2)) orelse + ( if ((((((BitsN.bit(Rt,0)) orelse + ((P = (BitsN.B(0x0,1))) andalso + (W = (BitsN.B(0x1,1))))) orelse + (Rt2 = (BitsN.B(0xF,4)))) orelse + (Rm = (BitsN.B(0xF,4)))) orelse + ((not store) andalso + ((Rm = Rt) orelse (Rm = Rt2)))) orelse (wback andalso (((Rn = (BitsN.B(0xF,4))) orelse (Rn = Rt)) orelse (Rn = Rt2)))) orelse @@ -9883,8 +9887,7 @@ fun DecodeARM w = (BitsN.B(0x1,1)) val m = register_form2 Rm in - if (BitsN.fromBitstring([S'0],1)) = - (BitsN.B(0x1,1)) + if store then Store (StoreDual (add, diff --git a/examples/l3-machine-code/arm/model/armScript.sml b/examples/l3-machine-code/arm/model/armScript.sml index 03b5c6b282..0467df2f4d 100644 --- a/examples/l3-machine-code/arm/model/armScript.sml +++ b/examples/l3-machine-code/arm/model/armScript.sml @@ -1,4 +1,4 @@ -(* armScript.sml - generated by L<3> - Thu Oct 23 14:23:23 2014 *) +(* armScript.sml - generated by L<3> - Fri Nov 21 15:10:03 2014 *) open HolKernel boolLib bossLib Import val () = Import.start "arm" @@ -3476,7 +3476,7 @@ val BitCount_def = Def ; val SignExtendFrom_def = Def ("SignExtendFrom",TP[Var("w",BTy"N"),nVar"p"], - Let(nVar"s",Bop(Sub,Mop(Size,LY(0,"N")),nVar"p"), + Let(nVar"s",Bop(Sub,Bop(Sub,Mop(Size,LY(0,"N")),LN 1),nVar"p"), Bop(Asr,Bop(Lsl,Var("w",BTy"N"),nVar"s"),nVar"s"))) ; val Extend_def = Def @@ -3491,13 +3491,11 @@ val SignedSatQ_def = Def ("SignedSatQ",TP[iVar"i",nVar"N"], Close (qVar"state", - TP[Let(iVar"max", - Mop(Cast iTy, - Bop(Sub,Bop(Exp,LN 2,Bop(Sub,nVar"N",LN 1)),LN 1)), - ITB([(Bop(Gt,iVar"i",iVar"max"), - TP[Mop(Cast(BTy"M"),iVar"max"),LT]), + TP[Let(iVar"max",Mop(Cast iTy,Bop(Exp,LN 2,Bop(Sub,nVar"N",LN 1))), + ITB([(Bop(Gt,iVar"i",Bop(Sub,iVar"max",LI 1)), + TP[Mop(Cast(BTy"M"),Bop(Sub,iVar"max",LI 1)),LT]), (Bop(Lt,iVar"i",Mop(Neg,iVar"max")), - TP[Mop(Neg,Mop(Cast(BTy"M"),iVar"max")),LT])], + TP[Mop(Cast(BTy"M"),Mop(Neg,iVar"max")),LT])], TP[Mop(Cast(BTy"M"),iVar"i"),LF])), ITE(Bop(Lt,Mop(Size,LY(0,"M")),nVar"N"), Mop(Snd, @@ -8151,7 +8149,8 @@ val DataProcessing_def = Def Let(TP[Var("result",F32),bVar"carry",bVar"overflow"], Call ("DataProcessingALU",PTy(F32,PTy(bTy,bTy)), - TP[Var("opc",F4),Var("v",F32),Var("imm32",F32),bVar"C"]), + TP[Var("opc",F4),Var("v",F32),Var("imm32",F32), + Dest("C",bTy,Dest("CPSR",CTy"PSR",qVar"s"))]), Let(qVar"s", ITE(Mop(Not, EQ(EX(Var("opc",F4),LN 3,LN 2,FTy 2),LW(2,2))), @@ -8180,18 +8179,19 @@ val DataProcessing_def = Def ("Z", TP[Dest("CPSR",CTy"PSR",qVar"s"), EQ(Var("result",F32),LW(0,32))])]), - Let(qVar"s", - Rupd - ("CPSR", - TP[qVar"s", - Rupd - ("C", - TP[Dest - ("CPSR",CTy"PSR", - qVar"s"),bVar"carry"])]), - ITE(Call - ("ArithmeticOpcode",bTy, - Var("opc",F4)), + ITE(Call + ("ArithmeticOpcode",bTy, + Var("opc",F4)), + Let(qVar"s", + Rupd + ("CPSR", + TP[qVar"s", + Rupd + ("C", + TP[Dest + ("CPSR",CTy"PSR", + qVar"s"), + bVar"carry"])]), Rupd ("CPSR", TP[qVar"s", @@ -8200,12 +8200,20 @@ val DataProcessing_def = Def TP[Dest ("CPSR",CTy"PSR", qVar"s"), - bVar"overflow"])]), - qVar"s")))),qVar"s"))))))) + bVar"overflow"])])), + Rupd + ("CPSR", + TP[qVar"s", + Rupd + ("C", + TP[Dest + ("CPSR",CTy"PSR", + qVar"s"),bVar"C"])])))), + qVar"s"))))))) ; val DataProcessingPC_def = Def ("DataProcessingPC", - TP[Var("opc",F4),bVar"setflags",Var("n",F4),Var("imm32",F32),bVar"C"], + TP[Var("opc",F4),bVar"setflags",Var("n",F4),Var("imm32",F32)], Close (qVar"state", Let(TP[Var("v",F32),qVar"s"], @@ -8221,10 +8229,11 @@ val DataProcessingPC_def = Def TP[Call("Align",F32,TP[Var("v",F32),LN 4]),qVar"s"]))], Apply (Call("R",ATy(qTy,PTy(F32,qTy)),Var("n",F4)),qVar"state")), - Let(TP[Var("result",F32),bVar"carry",bVar"overflow"], + Let(TP[Var("result",F32),AVar bTy,AVar bTy], Call ("DataProcessingALU",PTy(F32,PTy(bTy,bTy)), - TP[Var("opc",F4),Var("v",F32),Var("imm32",F32),bVar"C"]), + TP[Var("opc",F4),Var("v",F32),Var("imm32",F32), + Dest("C",bTy,Dest("CPSR",CTy"PSR",qVar"s"))]), ITE(bVar"setflags", Let(TP[bVar"v",qVar"s"], Apply @@ -8323,7 +8332,7 @@ val dfn'Move_def = Def (Call ("DataProcessingPC",ATy(qTy,PTy(uTy,qTy)), TP[Var("opc",F4),bVar"setflags",LW(15,4), - Var("imm32",F32),bVar"carry"]),qVar"s"), + Var("imm32",F32)]),qVar"s"), Apply (Call ("DataProcessing",ATy(qTy,PTy(uTy,qTy)), @@ -8369,7 +8378,7 @@ val dfn'ArithLogicImmediate_def = Def (Call ("DataProcessingPC",ATy(qTy,PTy(uTy,qTy)), TP[Var("opc",F4),bVar"setflags",Var("n",F4), - Var("imm32",F32),bVar"carry"]),qVar"s"), + Var("imm32",F32)]),qVar"s"), Apply (Call ("DataProcessing",ATy(qTy,PTy(uTy,qTy)), @@ -8395,23 +8404,18 @@ val doRegister_def = Def qVar"s"), Let(TP[Var("shifted",F32),bVar"carry"], Var("v",PTy(F32,bTy)), - Let(bVar"v", - ITE(Call("ArithmeticOpcode",bTy,Var("opc",F4)), - Dest("C",bTy,Dest("CPSR",CTy"PSR",qVar"s")), - bVar"carry"), - ITE(EQ(Var("d",F4),LW(15,4)), - Apply - (Call - ("DataProcessingPC",ATy(qTy,PTy(uTy,qTy)), - TP[Var("opc",F4),bVar"setflags", - Var("n",F4),Var("shifted",F32),bVar"v"]), - qVar"s"), - Apply - (Call - ("DataProcessing",ATy(qTy,PTy(uTy,qTy)), - TP[Var("opc",F4),bVar"setflags", - Var("d",F4),Var("n",F4), - Var("shifted",F32),bVar"v"]),qVar"s")))))))) + ITE(EQ(Var("d",F4),LW(15,4)), + Apply + (Call + ("DataProcessingPC",ATy(qTy,PTy(uTy,qTy)), + TP[Var("opc",F4),bVar"setflags",Var("n",F4), + Var("shifted",F32)]),qVar"s"), + Apply + (Call + ("DataProcessing",ATy(qTy,PTy(uTy,qTy)), + TP[Var("opc",F4),bVar"setflags",Var("d",F4), + Var("n",F4),Var("shifted",F32),bVar"carry"]), + qVar"s"))))))) ; val dfn'Register_def = Def ("dfn'Register", @@ -8488,10 +8492,8 @@ val doRegisterShiftedRegister_def = Def (Call ("DataProcessing",ATy(qTy,PTy(uTy,qTy)), TP[Var("opc",F4),bVar"setflags",Var("d",F4), - Var("n",F4),Var("shifted",F32), - ITE(Call("ArithmeticOpcode",bTy,Var("opc",F4)), - Dest("C",bTy,Dest("CPSR",CTy"PSR",qVar"s")), - bVar"carry")]),qVar"s")))))) + Var("n",F4),Var("shifted",F32),bVar"carry"]), + qVar"s")))))) ; val dfn'RegisterShiftedRegister_def = Def ("dfn'RegisterShiftedRegister", @@ -8801,7 +8803,8 @@ val dfn'SaturatingAddSubtract_def = Def Var("s3",PTy(F32,qTy))]), Let(TP[Var("r",F32),bVar"sat2"], Var("v",PTy(F32,bTy)), - TP[bVar"sat1",Var("r",F32), + TP[Bop(Or,bVar"sat1",bVar"sat2"), + Var("r",F32), Mop(Snd, Mop(Snd, Var("s", @@ -10238,7 +10241,7 @@ val dfn'UnsignedAddSub16_def = Def BFI(LN 1,LN 0, ITE(Bop(Ge,iVar"res1", ITE(Bop(In,Var("op",FTy 2), - SL[LW(1,2),LW(2,2)]), + SL[LW(1,2),LW(3,2)]), LI 0,LI 65536)),LW(3,2), LW(0,2)), Dest @@ -10902,20 +10905,27 @@ val dfn'ExtendByte16_def = Def (Call ("ROR",ATy(qTy,PTy(F32,qTy)), TP[Var("v0",F32),nVar"rotation"]),qVar"s"), - Let(Var("r1",F16), - Bop(Add,EX(Var("v",F32),LN 15,LN 0,F16), - Call - ("Extend",F16, - TP[bVar"unsigned", - EX(Var("v0",F32),LN 7,LN 0,F8)])), - Apply - (Call("IncPC",ATy(qTy,PTy(uTy,qTy)),LU), - Mop(Snd, - Apply - (Call - ("write'R",ATy(qTy,PTy(uTy,qTy)), - TP[CC[Var("r1",F16),Var("r1",F16)], - Var("d",F4)]),qVar"s"))))))))) + Apply + (Call("IncPC",ATy(qTy,PTy(uTy,qTy)),LU), + Mop(Snd, + Apply + (Call + ("write'R",ATy(qTy,PTy(uTy,qTy)), + TP[CC[Bop(Add, + EX(Var("v",F32),LN 31,LN 16,F16), + Call + ("Extend",F16, + TP[bVar"unsigned", + EX(Var("v0",F32),LN 23, + LN 16,F8)])), + Bop(Add, + EX(Var("v",F32),LN 15,LN 0,F16), + Call + ("Extend",F16, + TP[bVar"unsigned", + EX(Var("v0",F32),LN 7,LN 0, + F8)]))],Var("d",F4)]), + qVar"s")))))))) ; val dfn'ExtendHalfword_def = Def ("dfn'ExtendHalfword", @@ -26485,65 +26495,66 @@ val DecodeARM_def = Def F1), LW(1, 1))), - TP[Let(bVar"index", - EQ(Var("P", - F1), - LW(1, - 1)), - Let(bVar"add", - EQ(Mop(Cast - F1, - LL[bVar"b'23"]), + Let(bVar"store", + EQ(Mop(Cast + F1, + LL[bVar"b'5"]), + LW(1, + 1)), + TP[Let(bVar"index", + EQ(Var("P", + F1), LW(1, 1)), - Let(Var("m", - CTy"offset2"), - Call - ("register_form2", - CTy"offset2", - Var("Rm", - F4)), - ITE(EQ(Mop(Cast - F1, - LL[bVar"b'5"]), - LW(1, - 1)), - Call - ("Store", - CTy"instruction", - Call - ("StoreDual", - CTy"Store", - TP[bVar"add", - bVar"index", - bVar"wback", - Var("Rt", - F4), - Var("Rt2", - F4), - Var("Rn", - F4), - Var("m", - CTy"offset2")])), + Let(bVar"add", + EQ(Mop(Cast + F1, + LL[bVar"b'23"]), + LW(1, + 1)), + Let(Var("m", + CTy"offset2"), Call - ("Load", - CTy"instruction", - Call - ("LoadDual", - CTy"Load", - TP[bVar"add", - bVar"index", - bVar"wback", - Var("Rt", - F4), - Var("Rt2", - F4), - Var("Rn", - F4), - Var("m", - CTy"offset2")])))))), - ITE(Bop(Or, - Bop(Or, + ("register_form2", + CTy"offset2", + Var("Rm", + F4)), + ITE(bVar"store", + Call + ("Store", + CTy"instruction", + Call + ("StoreDual", + CTy"Store", + TP[bVar"add", + bVar"index", + bVar"wback", + Var("Rt", + F4), + Var("Rt2", + F4), + Var("Rn", + F4), + Var("m", + CTy"offset2")])), + Call + ("Load", + CTy"instruction", + Call + ("LoadDual", + CTy"Load", + TP[bVar"add", + bVar"index", + bVar"wback", + Var("Rt", + F4), + Var("Rt2", + F4), + Var("Rn", + F4), + Var("m", + CTy"offset2")])))))), + ITE(Bop(Or, Bop(Or, Bop(Or, Bop(Or, @@ -26571,62 +26582,66 @@ val DecodeARM_def = Def F4), LW(15, 4))), - EQ(Var("Rm", - F4), - Var("Rt", - F4))), - EQ(Var("Rm", - F4), - Var("Rt2", - F4))), - Bop(And, - bVar"wback", - Bop(Or, + Bop(And, + Mop(Not, + bVar"store"), + Bop(Or, + EQ(Var("Rm", + F4), + Var("Rt", + F4)), + EQ(Var("Rm", + F4), + Var("Rt2", + F4))))), + Bop(And, + bVar"wback", Bop(Or, + Bop(Or, + EQ(Var("Rn", + F4), + LW(15, + 4)), + EQ(Var("Rn", + F4), + Var("Rt", + F4))), EQ(Var("Rn", F4), - LW(15, - 4)), - EQ(Var("Rn", - F4), - Var("Rt", - F4))), - EQ(Var("Rn", - F4), - Var("Rt2", - F4))))), - Bop(And, + Var("Rt2", + F4))))), Bop(And, - Bop(Lt, - Mop(Fst, - Apply - (Call - ("ArchVersion", - ATy(qTy, - PTy(nTy, - qTy)), - LU), - qVar"s")), - LN - 6), - bVar"wback"), - EQ(Var("Rm", - F4), - Var("Rn", - F4)))), - Mop(Snd, - Apply - (Call - ("DECODE_UNPREDICTABLE", - ATy(qTy, - PTy(uTy, - qTy)), - TP[Var("mc", - CTy"MachineCode"), - LS - "Load/StoreDual (register)"]), - qVar"s")), - qVar"s")])), + Bop(And, + Bop(Lt, + Mop(Fst, + Apply + (Call + ("ArchVersion", + ATy(qTy, + PTy(nTy, + qTy)), + LU), + qVar"s")), + LN + 6), + bVar"wback"), + EQ(Var("Rm", + F4), + Var("Rn", + F4)))), + Mop(Snd, + Apply + (Call + ("DECODE_UNPREDICTABLE", + ATy(qTy, + PTy(uTy, + qTy)), + TP[Var("mc", + CTy"MachineCode"), + LS + "Load/StoreDual (register)"]), + qVar"s")), + qVar"s")]))), TP[Mop(Fst, Apply (Call diff --git a/examples/l3-machine-code/arm/step/arm_stepLib.sml b/examples/l3-machine-code/arm/step/arm_stepLib.sml index 2b42baaf2e..2ef439755f 100644 --- a/examples/l3-machine-code/arm/step/arm_stepLib.sml +++ b/examples/l3-machine-code/arm/step/arm_stepLib.sml @@ -2710,11 +2710,17 @@ val DataProcessingPC_nsetflags_rwt = AddWithCarry, wordsTheory.FST_ADD_WITH_CARRY, ArithmeticOpcode_def, PC_rwt, IncPC_rwt, cond_rand_thms] [] (mapl (`opc`, utilsLib.tab_fixedwidth 16 4)) - ``DataProcessingPC (opc, F, n, imm32, c)``) reg_rwts + ``DataProcessingPC (opc, F, n, imm32)``) reg_rwts |> List.concat *) local + val x = ``x: word32 # bool`` + val DataProcessing = + DataProcessing_def + |> Q.SPECL [`opc`, `setflags`, `d`, `n`, `FST ^x`, `SND ^x`] + |> REWRITE_RULE [pairTheory.PAIR] + |> utilsLib.SET_RULE val DataProcessing_rwts = List.map (fn opc => @@ -2723,12 +2729,11 @@ local val wr = if i < 8 orelse 11 < i then [write'R_rwt] else [] in EV ([R_rwt, arm_stepTheory.R_x_not_pc, - utilsLib.SET_RULE DataProcessing_def, - DataProcessingALU_def, + DataProcessing, DataProcessingALU_def, AddWithCarry, wordsTheory.FST_ADD_WITH_CARRY, ArithmeticOpcode_def, PC_rwt, IncPC_rwt, cond_rand_thms, unit_state_cond] @ wr) [] [[`opc` |-> opc]] - ``DataProcessing (opc, setflags, d, n, imm32, c)`` + ``DataProcessing (opc, setflags, d, n, imm32_c)`` end |> List.map (utilsLib.ALL_HYP_CONV_RULE From 4e5904e7185466407156e1c8b46a8a87d91b67dc Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Tue, 25 Nov 2014 12:57:05 +0000 Subject: [PATCH 032/718] Fixes for MIPS instruction parsing and encoding. --- examples/l3-machine-code/mips/model/mips.sig | 2 +- examples/l3-machine-code/mips/model/mips.sml | 36 ++++++++++---------- 2 files changed, 19 insertions(+), 19 deletions(-) diff --git a/examples/l3-machine-code/mips/model/mips.sig b/examples/l3-machine-code/mips/model/mips.sig index 08a09f3d89..a62b79c485 100644 --- a/examples/l3-machine-code/mips/model/mips.sig +++ b/examples/l3-machine-code/mips/model/mips.sig @@ -1,4 +1,4 @@ -(* mips - generated by L<3> - Tue Nov 18 15:34:51 2014 *) +(* mips - generated by L<3> - Tue Nov 25 12:48:12 2014 *) signature mips = sig diff --git a/examples/l3-machine-code/mips/model/mips.sml b/examples/l3-machine-code/mips/model/mips.sml index 83ac8046b2..18fa4dc421 100644 --- a/examples/l3-machine-code/mips/model/mips.sml +++ b/examples/l3-machine-code/mips/model/mips.sml @@ -1,4 +1,4 @@ -(* mips - generated by L<3> - Tue Nov 18 15:34:51 2014 *) +(* mips - generated by L<3> - Tue Nov 25 12:48:12 2014 *) structure mips :> mips = struct @@ -9554,14 +9554,14 @@ fun Encode i = form1 (BitsN.B(0x0,5), (BitsN.B(0x0,5),(rd,(BitsN.B(0x0,5),BitsN.B(0x10,6))))) - | MultDiv(MTHI rd) => - form1 - (BitsN.B(0x0,5), - (BitsN.B(0x0,5),(rd,(BitsN.B(0x0,5),BitsN.B(0x11,6))))) - | MultDiv(MFLO rs) => + | MultDiv(MTHI rs) => form1 (rs, - (BitsN.B(0x0,5),(BitsN.B(0x0,5),(BitsN.B(0x0,5),BitsN.B(0x12,6))))) + (BitsN.B(0x0,5),(BitsN.B(0x0,5),(BitsN.B(0x0,5),BitsN.B(0x11,6))))) + | MultDiv(MFLO rd) => + form1 + (BitsN.B(0x0,5), + (BitsN.B(0x0,5),(rd,(BitsN.B(0x0,5),BitsN.B(0x12,6))))) | MultDiv(MTLO rs) => form1 (rs, @@ -9835,23 +9835,23 @@ fun p_r2 (s,(rs,rt)) = | "dmultu" => OK(MultDiv(DMULTU(rs,rt))) | "ddiv" => OK(MultDiv(DDIV(rs,rt))) | "ddivu" => OK(MultDiv(DDIVU(rs,rt))) - | "rge" => OK(Trap(TGE(rs,rt))) - | "rgeu" => OK(Trap(TGEU(rs,rt))) - | "rlt" => OK(Trap(TLT(rs,rt))) - | "rltu" => OK(Trap(TLTU(rs,rt))) + | "tge" => OK(Trap(TGE(rs,rt))) + | "tgeu" => OK(Trap(TGEU(rs,rt))) + | "tlt" => OK(Trap(TLT(rs,rt))) + | "tltu" => OK(Trap(TLTU(rs,rt))) | "teq" => OK(Trap(TEQ(rs,rt))) | "tne" => OK(Trap(TNE(rs,rt))) | "rdhwr" => OK(RDHWR(rs,rt)) | _ => FAIL("Unrecognised mnemonic"); -fun p_r3 (s,(rd,(rt,rs))) = +fun p_r3 (s,(rd,(rs,rt))) = case s of - "sllv" => OK(Shift(SLLV(rs,(rt,rd)))) - | "srlv" => OK(Shift(SRLV(rs,(rt,rd)))) - | "srav" => OK(Shift(SRAV(rs,(rt,rd)))) - | "dsllv" => OK(Shift(DSLLV(rs,(rt,rd)))) - | "dsrlv" => OK(Shift(DSRLV(rs,(rt,rd)))) - | "dsrav" => OK(Shift(DSRAV(rs,(rt,rd)))) + "sllv" => OK(Shift(SLLV(rt,(rs,rd)))) + | "srlv" => OK(Shift(SRLV(rt,(rs,rd)))) + | "srav" => OK(Shift(SRAV(rt,(rs,rd)))) + | "dsllv" => OK(Shift(DSLLV(rt,(rs,rd)))) + | "dsrlv" => OK(Shift(DSRLV(rt,(rs,rd)))) + | "dsrav" => OK(Shift(DSRAV(rt,(rs,rd)))) | "mul" => OK(MultDiv(MUL(rs,(rt,rd)))) | "movn" => OK(ArithR(MOVN(rs,(rt,rd)))) | "movz" => OK(ArithR(MOVZ(rs,(rt,rd)))) From c0318330ee22a33b3146060e647dd4f803d4cb4f Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Tue, 25 Nov 2014 14:43:16 +0000 Subject: [PATCH 033/718] Add CHERI model under L3 examples. CHERI is MIPS with capability extensions. See http://www.cl.cam.ac.uk/research/security/ctsrd/cheri/ --- examples/l3-machine-code/cheri/Holmakefile | 1 + .../l3-machine-code/cheri/cheriScript.sml | 37407 ++++++++++++++++ 2 files changed, 37408 insertions(+) create mode 100644 examples/l3-machine-code/cheri/Holmakefile create mode 100644 examples/l3-machine-code/cheri/cheriScript.sml diff --git a/examples/l3-machine-code/cheri/Holmakefile b/examples/l3-machine-code/cheri/Holmakefile new file mode 100644 index 0000000000..777f8b3a5b --- /dev/null +++ b/examples/l3-machine-code/cheri/Holmakefile @@ -0,0 +1 @@ +INCLUDES = ../common diff --git a/examples/l3-machine-code/cheri/cheriScript.sml b/examples/l3-machine-code/cheri/cheriScript.sml new file mode 100644 index 0000000000..8ad16ea616 --- /dev/null +++ b/examples/l3-machine-code/cheri/cheriScript.sml @@ -0,0 +1,37407 @@ +(* cheriScript.sml - generated by L<3> - Tue Nov 25 14:34:02 2014 *) +open HolKernel boolLib bossLib Import + +val () = Import.start "cheri" + +val _ = Record + ("EntryLo", + [("C",FTy 3),("D",bTy),("G",bTy),("L",bTy),("PFN",FTy 28),("S",bTy), + ("V",bTy),("entrylo'rst",FTy 28)]) +; +val _ = Record + ("TLBEntry", + [("ASID",F8),("C0",FTy 3),("C1",FTy 3),("D0",bTy),("D1",bTy),("G",bTy), + ("L0",bTy),("L1",bTy),("Mask",FTy 12),("PFN0",FTy 28),("PFN1",FTy 28), + ("R",FTy 2),("S0",bTy),("S1",bTy),("V0",bTy),("V1",bTy), + ("VPN2",FTy 27)]) +; +val _ = Construct [("IorD",[("INSTRUCTION",[]),("DATA",[])])] +; +val _ = Construct + [("AccessType",[("LOAD",[]),("STORE",[]),("CLOAD",[]),("CSTORE",[])])] +; +val _ = Record ("Index",[("Index",F8),("P",bTy),("index'rst",FTy 23)]) +; +val _ = Record ("Random",[("Random",F8),("random'rst",FTy 24)]) +; +val _ = Record ("Wired",[("Wired",F8),("wired'rst",FTy 24)]) +; +val _ = Record ("PageMask",[("Mask",FTy 12),("pagemask'rst",FTy 20)]) +; +val _ = Record + ("EntryHi", + [("ASID",F8),("R",FTy 2),("VPN2",FTy 27),("entryhi'rst",FTy 27)]) +; +val _ = Record + ("StatusRegister", + [("BEV",bTy),("CU0",bTy),("CU1",bTy),("CU2",bTy),("CU3",bTy), + ("ERL",bTy),("EXL",bTy),("FR",bTy),("IE",bTy),("IM",F8),("KSU",FTy 2), + ("KX",bTy),("RE",bTy),("SX",bTy),("UX",bTy), + ("statusregister'rst",FTy 9)]) +; +val _ = Record + ("ConfigRegister", + [("AR",FTy 3),("AT",FTy 2),("BE",bTy),("K0",FTy 3),("M",bTy), + ("MT",FTy 3),("configregister'rst",FTy 19)]) +; +val _ = Record + ("ConfigRegister1", + [("C2",bTy),("CA",bTy),("DA",FTy 3),("DL",FTy 3),("DS",FTy 3), + ("EP",bTy),("FP",bTy),("IA",FTy 3),("IL",FTy 3),("IS",FTy 3), + ("M",bTy),("MD",bTy),("MMUSize",FTy 6),("PCR",bTy),("WR",bTy)]) +; +val _ = Record + ("ConfigRegister2", + [("M",bTy),("SA",F4),("SL",F4),("SS",F4),("SU",F4),("TA",F4),("TL",F4), + ("TS",F4),("TU",FTy 3)]) +; +val _ = Record + ("ConfigRegister3", + [("DSPP",bTy),("LPA",bTy),("M",bTy),("MT",bTy),("SM",bTy),("SP",bTy), + ("TL",bTy),("ULRI",bTy),("VEIC",bTy),("VInt",bTy), + ("configregister3'rst",FTy 22)]) +; +val _ = Record + ("ConfigRegister6", + [("LTLB",bTy),("TLBSize",F16),("configregister6'rst",FTy 15)]) +; +val _ = Record + ("CauseRegister", + [("BD",bTy),("CE",FTy 2),("ExcCode",FTy 5),("IP",F8),("TI",bTy), + ("causeregister'rst",FTy 15)]) +; +val _ = Record + ("Context",[("BadVPN2",FTy 19),("PTEBase",FTy 41),("context'rst",F4)]) +; +val _ = Record + ("XContext", + [("BadVPN2",FTy 27),("PTEBase",FTy 31),("R",FTy 2),("xcontext'rst",F4)]) +; +val _ = Record + ("HWREna", + [("CC",bTy),("CCRes",bTy),("CPUNum",bTy),("UL",bTy), + ("hwrena'rst",FTy 28)]) +; +val _ = Record + ("CP0__renamed__", + [("BadVAddr",F64),("Cause",CTy"CauseRegister"),("Compare",F32), + ("Config",CTy"ConfigRegister"),("Config1",CTy"ConfigRegister1"), + ("Config2",CTy"ConfigRegister2"),("Config3",CTy"ConfigRegister3"), + ("Config6",CTy"ConfigRegister6"),("Context",CTy"Context"), + ("Count",F32),("Debug",F32),("EInstr",F32),("EPC",F64), + ("EntryHi",CTy"EntryHi"),("EntryLo0",CTy"EntryLo"), + ("EntryLo1",CTy"EntryLo"),("ErrCtl",F32),("ErrorEPC",F64), + ("HWREna",CTy"HWREna"),("Index",CTy"Index"),("LLAddr",F64), + ("PRId",F32),("PageMask",CTy"PageMask"),("Random",CTy"Random"), + ("Status",CTy"StatusRegister"),("UsrLocal",F64),("Wired",CTy"Wired"), + ("XContext",CTy"XContext")]) +; +val _ = Record + ("PIC_Config_Reg", + [("EN",bTy),("IRQ",FTy 3),("pic_config_reg'rst",FTy 60)]) +; +val _ = Record + ("JTAG_UART_data__renamed__", + [("RAVAIL",F16),("RVALID",bTy),("RW_DATA",F8), + ("jtag_uart_data'rst",FTy 7)]) +; +val _ = Record + ("JTAG_UART_control__renamed__", + [("AC",bTy),("RE",bTy),("RI",bTy),("WE",bTy),("WI",bTy),("WSPACE",F16), + ("jtag_uart_control'rst",FTy 11)]) +; +val _ = Record + ("JTAG_UART", + [("base_address",FTy 37),("control",CTy"JTAG_UART_control__renamed__"), + ("data",CTy"JTAG_UART_data__renamed__"),("read_fifo",LTy F8), + ("read_threshold",nTy),("write_fifo",LTy F8),("write_threshold",nTy)]) +; +val _ = Record + ("Perms", + [("Access_EPCC",bTy),("Access_KCC",bTy),("Access_KDC",bTy), + ("Access_KR1C",bTy),("Access_KR2C",bTy),("Global",bTy), + ("Permit_Execute",bTy),("Permit_Load",bTy), + ("Permit_Load_Capability",bTy),("Permit_Seal",bTy), + ("Permit_Set_Type",bTy),("Permit_Store",bTy), + ("Permit_Store_Capability",bTy),("Permit_Store_Local_Capability",bTy), + ("Reserved",bTy),("soft",F16)]) +; +val _ = Record + ("Capability", + [("base",F64),("length",F64),("offset",F64),("otype",FTy 24), + ("perms",FTy 31),("reserved",F8),("sealed",bTy),("tag",bTy)]) +; +val _ = Record ("CapCause",[("ExcCode",F8),("RegNum",F8)]) +; +val _ = Construct + [("ExceptionType", + [("Int",[]),("Mod",[]),("TLBL",[]),("TLBS",[]),("AdEL",[]), + ("AdES",[]),("Sys",[]),("Bp",[]),("ResI",[]),("CpU",[]),("Ov",[]), + ("Tr",[]),("CTLBL",[]),("CTLBS",[]),("C2E",[]),("XTLBRefillL",[]), + ("XTLBRefillS",[])])] +; +val _ = Construct + [("CapException", + [("capExcNone",[]),("capExcLength",[]),("capExcTag",[]), + ("capExcSeal",[]),("capExcType",[]),("capExcCall",[]), + ("capExcRet",[]),("capExcUnderflowTSS",[]),("capExcUser",[]), + ("capExcTLBNoStore",[]),("capExcGlobal",[]),("capExcPermExe",[]), + ("capExcPermLoad",[]),("capExcPermStore",[]), + ("capExcPermLoadCap",[]),("capExcPermStoreCap",[]), + ("capExcPermStoreLocalCap",[]),("capExcPermSeal",[]), + ("capExcPermSetType",[]),("capExcAccEPCC",[]),("capExcAccKDC",[]), + ("capExcAccKCC",[]),("capExcAccKR1C",[]),("capExcAccKR2C",[])])] +; +val _ = Construct + [("Branch", + [("BEQ",[PTy(FTy 5,PTy(FTy 5,F16))]), + ("BEQL",[PTy(FTy 5,PTy(FTy 5,F16))]),("BGEZ",[PTy(FTy 5,F16)]), + ("BGEZAL",[PTy(FTy 5,F16)]),("BGEZALL",[PTy(FTy 5,F16)]), + ("BGEZL",[PTy(FTy 5,F16)]),("BGTZ",[PTy(FTy 5,F16)]), + ("BGTZL",[PTy(FTy 5,F16)]),("BLEZ",[PTy(FTy 5,F16)]), + ("BLEZL",[PTy(FTy 5,F16)]),("BLTZ",[PTy(FTy 5,F16)]), + ("BLTZAL",[PTy(FTy 5,F16)]),("BLTZALL",[PTy(FTy 5,F16)]), + ("BLTZL",[PTy(FTy 5,F16)]),("BNE",[PTy(FTy 5,PTy(FTy 5,F16))]), + ("BNEL",[PTy(FTy 5,PTy(FTy 5,F16))]),("J",[FTy 26]),("JAL",[FTy 26]), + ("JALR",[PTy(FTy 5,FTy 5)]),("JR",[FTy 5])])] +; +val _ = Construct + [("CP", + [("DMFC0",[PTy(FTy 5,PTy(FTy 5,FTy 3))]), + ("DMTC0",[PTy(FTy 5,PTy(FTy 5,FTy 3))]), + ("MFC0",[PTy(FTy 5,PTy(FTy 5,FTy 3))]), + ("MTC0",[PTy(FTy 5,PTy(FTy 5,FTy 3))])])] +; +val _ = Construct + [("Store", + [("SB",[PTy(FTy 5,PTy(FTy 5,F16))]), + ("SC",[PTy(FTy 5,PTy(FTy 5,F16))]), + ("SCD",[PTy(FTy 5,PTy(FTy 5,F16))]), + ("SD",[PTy(FTy 5,PTy(FTy 5,F16))]), + ("SDL",[PTy(FTy 5,PTy(FTy 5,F16))]), + ("SDR",[PTy(FTy 5,PTy(FTy 5,F16))]), + ("SH",[PTy(FTy 5,PTy(FTy 5,F16))]), + ("SW",[PTy(FTy 5,PTy(FTy 5,F16))]), + ("SWL",[PTy(FTy 5,PTy(FTy 5,F16))]), + ("SWR",[PTy(FTy 5,PTy(FTy 5,F16))])])] +; +val _ = Construct + [("Load", + [("LB",[PTy(FTy 5,PTy(FTy 5,F16))]), + ("LBU",[PTy(FTy 5,PTy(FTy 5,F16))]), + ("LD",[PTy(FTy 5,PTy(FTy 5,F16))]), + ("LDL",[PTy(FTy 5,PTy(FTy 5,F16))]), + ("LDR",[PTy(FTy 5,PTy(FTy 5,F16))]), + ("LH",[PTy(FTy 5,PTy(FTy 5,F16))]), + ("LHU",[PTy(FTy 5,PTy(FTy 5,F16))]), + ("LL",[PTy(FTy 5,PTy(FTy 5,F16))]), + ("LLD",[PTy(FTy 5,PTy(FTy 5,F16))]), + ("LW",[PTy(FTy 5,PTy(FTy 5,F16))]), + ("LWL",[PTy(FTy 5,PTy(FTy 5,F16))]), + ("LWR",[PTy(FTy 5,PTy(FTy 5,F16))]), + ("LWU",[PTy(FTy 5,PTy(FTy 5,F16))])])] +; +val _ = Construct + [("Trap", + [("TEQ",[PTy(FTy 5,FTy 5)]),("TEQI",[PTy(FTy 5,F16)]), + ("TGE",[PTy(FTy 5,FTy 5)]),("TGEI",[PTy(FTy 5,F16)]), + ("TGEIU",[PTy(FTy 5,F16)]),("TGEU",[PTy(FTy 5,FTy 5)]), + ("TLT",[PTy(FTy 5,FTy 5)]),("TLTI",[PTy(FTy 5,F16)]), + ("TLTIU",[PTy(FTy 5,F16)]),("TLTU",[PTy(FTy 5,FTy 5)]), + ("TNE",[PTy(FTy 5,FTy 5)]),("TNEI",[PTy(FTy 5,F16)])])] +; +val _ = Construct + [("Shift", + [("DSLL",[PTy(FTy 5,PTy(FTy 5,FTy 5))]), + ("DSLL32",[PTy(FTy 5,PTy(FTy 5,FTy 5))]), + ("DSLLV",[PTy(FTy 5,PTy(FTy 5,FTy 5))]), + ("DSRA",[PTy(FTy 5,PTy(FTy 5,FTy 5))]), + ("DSRA32",[PTy(FTy 5,PTy(FTy 5,FTy 5))]), + ("DSRAV",[PTy(FTy 5,PTy(FTy 5,FTy 5))]), + ("DSRL",[PTy(FTy 5,PTy(FTy 5,FTy 5))]), + ("DSRL32",[PTy(FTy 5,PTy(FTy 5,FTy 5))]), + ("DSRLV",[PTy(FTy 5,PTy(FTy 5,FTy 5))]), + ("SLL",[PTy(FTy 5,PTy(FTy 5,FTy 5))]), + ("SLLV",[PTy(FTy 5,PTy(FTy 5,FTy 5))]), + ("SRA",[PTy(FTy 5,PTy(FTy 5,FTy 5))]), + ("SRAV",[PTy(FTy 5,PTy(FTy 5,FTy 5))]), + ("SRL",[PTy(FTy 5,PTy(FTy 5,FTy 5))]), + ("SRLV",[PTy(FTy 5,PTy(FTy 5,FTy 5))])])] +; +val _ = Construct + [("MultDiv", + [("DDIV",[PTy(FTy 5,FTy 5)]),("DDIVU",[PTy(FTy 5,FTy 5)]), + ("DIV",[PTy(FTy 5,FTy 5)]),("DIVU",[PTy(FTy 5,FTy 5)]), + ("DMULT",[PTy(FTy 5,FTy 5)]),("DMULTU",[PTy(FTy 5,FTy 5)]), + ("MADD",[PTy(FTy 5,FTy 5)]),("MADDU",[PTy(FTy 5,FTy 5)]), + ("MFHI",[FTy 5]),("MFLO",[FTy 5]),("MSUB",[PTy(FTy 5,FTy 5)]), + ("MSUBU",[PTy(FTy 5,FTy 5)]),("MTHI",[FTy 5]),("MTLO",[FTy 5]), + ("MUL",[PTy(FTy 5,PTy(FTy 5,FTy 5))]),("MULT",[PTy(FTy 5,FTy 5)]), + ("MULTU",[PTy(FTy 5,FTy 5)])])] +; +val _ = Construct + [("ArithR", + [("ADD",[PTy(FTy 5,PTy(FTy 5,FTy 5))]), + ("ADDU",[PTy(FTy 5,PTy(FTy 5,FTy 5))]), + ("AND",[PTy(FTy 5,PTy(FTy 5,FTy 5))]), + ("DADD",[PTy(FTy 5,PTy(FTy 5,FTy 5))]), + ("DADDU",[PTy(FTy 5,PTy(FTy 5,FTy 5))]), + ("DSUB",[PTy(FTy 5,PTy(FTy 5,FTy 5))]), + ("DSUBU",[PTy(FTy 5,PTy(FTy 5,FTy 5))]), + ("MOVN",[PTy(FTy 5,PTy(FTy 5,FTy 5))]), + ("MOVZ",[PTy(FTy 5,PTy(FTy 5,FTy 5))]), + ("NOR",[PTy(FTy 5,PTy(FTy 5,FTy 5))]), + ("OR",[PTy(FTy 5,PTy(FTy 5,FTy 5))]), + ("SLT",[PTy(FTy 5,PTy(FTy 5,FTy 5))]), + ("SLTU",[PTy(FTy 5,PTy(FTy 5,FTy 5))]), + ("SUB",[PTy(FTy 5,PTy(FTy 5,FTy 5))]), + ("SUBU",[PTy(FTy 5,PTy(FTy 5,FTy 5))]), + ("XOR",[PTy(FTy 5,PTy(FTy 5,FTy 5))])])] +; +val _ = Construct + [("ArithI", + [("ADDI",[PTy(FTy 5,PTy(FTy 5,F16))]), + ("ADDIU",[PTy(FTy 5,PTy(FTy 5,F16))]), + ("ANDI",[PTy(FTy 5,PTy(FTy 5,F16))]), + ("DADDI",[PTy(FTy 5,PTy(FTy 5,F16))]), + ("DADDIU",[PTy(FTy 5,PTy(FTy 5,F16))]),("LUI",[PTy(FTy 5,F16)]), + ("ORI",[PTy(FTy 5,PTy(FTy 5,F16))]), + ("SLTI",[PTy(FTy 5,PTy(FTy 5,F16))]), + ("SLTIU",[PTy(FTy 5,PTy(FTy 5,F16))]), + ("XORI",[PTy(FTy 5,PTy(FTy 5,F16))])])] +; +val _ = Construct + [("CGet", + [("CGetBase",[PTy(FTy 5,FTy 5)]),("CGetCause",[FTy 5]), + ("CGetLen",[PTy(FTy 5,FTy 5)]),("CGetOffset",[PTy(FTy 5,FTy 5)]), + ("CGetPCC",[FTy 5]),("CGetPerm",[PTy(FTy 5,FTy 5)]), + ("CGetSealed",[PTy(FTy 5,FTy 5)]),("CGetTag",[PTy(FTy 5,FTy 5)]), + ("CGetType",[PTy(FTy 5,FTy 5)]), + ("CToPtr",[PTy(FTy 5,PTy(FTy 5,FTy 5))])])] +; +val _ = Construct + [("CSet", + [("CAndPerm",[PTy(FTy 5,PTy(FTy 5,FTy 5))]), + ("CClearTag",[PTy(FTy 5,FTy 5)]), + ("CFromPtr",[PTy(FTy 5,PTy(FTy 5,FTy 5))]), + ("CIncBase",[PTy(FTy 5,PTy(FTy 5,FTy 5))]),("CSetCause",[FTy 5]), + ("CSetLen",[PTy(FTy 5,PTy(FTy 5,FTy 5))]), + ("CSetOffset",[PTy(FTy 5,PTy(FTy 5,FTy 5))])])] +; +val _ = Construct + [("CCheck", + [("CCheckPerm",[PTy(FTy 5,FTy 5)]),("CCheckType",[PTy(FTy 5,FTy 5)])])] +; +val _ = Construct + [("CHERICOP2", + [("CBTS",[PTy(FTy 5,F16)]),("CBTU",[PTy(FTy 5,F16)]), + ("CCall",[PTy(FTy 5,FTy 5)]),("CCheck",[CTy"CCheck"]), + ("CGet",[CTy"CGet"]),("CJALR",[PTy(FTy 5,FTy 5)]),("CJR",[FTy 5]), + ("CPtrCmp",[PTy(FTy 5,PTy(FTy 5,PTy(FTy 5,FTy 3)))]),("CReturn",[]), + ("CSeal",[PTy(FTy 5,PTy(FTy 5,FTy 5))]),("CSet",[CTy"CSet"]), + ("CUnseal",[PTy(FTy 5,PTy(FTy 5,FTy 5))]),("DumpCapReg",[]), + ("UnknownCapInstruction",[])])] +; +val _ = Construct [("COP2",[("CHERICOP2",[CTy"CHERICOP2"])])] +; +val _ = Construct + [("CHERISWC2", + [("CSCD",[PTy(FTy 5,PTy(FTy 5,PTy(FTy 5,F8)))]), + ("CStore",[PTy(FTy 5,PTy(FTy 5,PTy(FTy 5,PTy(F8,FTy 2))))])])] +; +val _ = Construct [("SWC2",[("CHERISWC2",[CTy"CHERISWC2"])])] +; +val _ = Construct + [("CHERILWC2", + [("CLLD",[PTy(FTy 5,PTy(FTy 5,PTy(FTy 5,F8)))]), + ("CLoad",[PTy(FTy 5,PTy(FTy 5,PTy(FTy 5,PTy(F8,PTy(F1,FTy 2)))))])])] +; +val _ = Construct [("LWC2",[("CHERILWC2",[CTy"CHERILWC2"])])] +; +val _ = Construct + [("CHERILDC2",[("CLC",[PTy(FTy 5,PTy(FTy 5,PTy(FTy 5,FTy 11)))])])] +; +val _ = Construct [("LDC2",[("CHERILDC2",[CTy"CHERILDC2"])])] +; +val _ = Construct + [("CHERISDC2",[("CSC",[PTy(FTy 5,PTy(FTy 5,PTy(FTy 5,FTy 11)))])])] +; +val _ = Construct [("SDC2",[("CHERISDC2",[CTy"CHERISDC2"])])] +; +val _ = Construct + [("instruction", + [("ArithI",[CTy"ArithI"]),("ArithR",[CTy"ArithR"]),("BREAK",[]), + ("Branch",[CTy"Branch"]),("CACHE",[PTy(FTy 5,PTy(FTy 5,F16))]), + ("COP2",[CTy"COP2"]),("CP",[CTy"CP"]),("ERET",[]), + ("LDC2",[CTy"LDC2"]),("LWC2",[CTy"LWC2"]),("Load",[CTy"Load"]), + ("MultDiv",[CTy"MultDiv"]),("RDHWR",[PTy(FTy 5,FTy 5)]), + ("ReservedInstruction",[]),("SDC2",[CTy"SDC2"]),("SWC2",[CTy"SWC2"]), + ("SYNC",[FTy 5]),("SYSCALL",[]),("Shift",[CTy"Shift"]), + ("Store",[CTy"Store"]),("TLBP",[]),("TLBR",[]),("TLBWI",[]), + ("TLBWR",[]),("Trap",[CTy"Trap"]),("Unpredictable",[]),("WAIT",[])])] +; +val _ = Construct + [("exception",[("NoException",[]),("UNPREDICTABLE",[sTy])])] +; +val _ = Record + ("cheri_state", + [("JTAG_UART",CTy"JTAG_UART"),("MEM",ATy(FTy 37,F64)), + ("PIC_base_address",ATy(F8,FTy 37)), + ("PIC_config_regs",ATy(F8,ATy(FTy 7,CTy"PIC_Config_Reg"))), + ("PIC_external_intrs",ATy(F8,F64)),("PIC_ip_bits",ATy(F8,FTy 128)), + ("TAG",ATy(FTy 35,bTy)),("UNPREDICTABLE_HI",ATy(uTy,uTy)), + ("UNPREDICTABLE_LO",ATy(uTy,uTy)),("c_BranchDelay",ATy(F8,OTy F64)), + ("c_BranchDelayPCC",ATy(F8,OTy(PTy(F64,CTy"Capability")))), + ("c_BranchTo",ATy(F8,OTy F64)), + ("c_BranchToPCC",ATy(F8,OTy(PTy(F64,CTy"Capability")))), + ("c_CP0",ATy(F8,CTy"CP0__renamed__")),("c_LLbit",ATy(F8,OTy bTy)), + ("c_PC",ATy(F8,F64)),("c_TLB_assoc",ATy(F8,ATy(F4,CTy"TLBEntry"))), + ("c_TLB_direct",ATy(F8,ATy(FTy 7,CTy"TLBEntry"))), + ("c_capcause",ATy(F8,CTy"CapCause")), + ("c_capr",ATy(F8,ATy(FTy 5,CTy"Capability"))), + ("c_exceptionSignalled",ATy(F8,bTy)),("c_gpr",ATy(F8,ATy(FTy 5,F64))), + ("c_hi",ATy(F8,OTy F64)),("c_lo",ATy(F8,OTy F64)), + ("c_pcc",ATy(F8,CTy"Capability")),("currentInst",OTy F32), + ("done",bTy),("exception",CTy"exception"),("instCnt",nTy), + ("log",ATy(nTy,LTy sTy)),("print",ATy(sTy,uTy)), + ("println",ATy(sTy,uTy)),("procID",F8),("totalCore",nTy)]) +; +val qTy = CTy "cheri_state"; +fun qVar v = Term.mk_var (v, ParseDatatype.pretypeToType qTy); +val raise'exception_def = Def + ("raise'exception",Var("e",CTy"exception"), + Close + (qVar"state", + TP[LX(VTy"a"), + ITE(EQ(Dest("exception",CTy"exception",qVar"state"), + Const("NoException",CTy"exception")), + Rupd("exception",TP[qVar"state",Var("e",CTy"exception")]), + qVar"state")])) +; +val rec'EntryLo_def = Def + ("rec'EntryLo",Var("x",F64), + Rec(CTy"EntryLo", + [EX(Var("x",F64),LN 5,LN 3,FTy 3),Bop(Bit,Var("x",F64),LN 2), + Bop(Bit,Var("x",F64),LN 0),Bop(Bit,Var("x",F64),LN 62), + EX(Var("x",F64),LN 33,LN 6,FTy 28),Bop(Bit,Var("x",F64),LN 63), + Bop(Bit,Var("x",F64),LN 1),EX(Var("x",F64),LN 61,LN 34,FTy 28)])) +; +val reg'EntryLo_def = Def + ("reg'EntryLo",Var("x",CTy"EntryLo"), + CS(Var("x",CTy"EntryLo"), + [(Rec(CTy"EntryLo", + [Var("C",FTy 3),bVar"D",bVar"G",bVar"L",Var("PFN",FTy 28), + bVar"S",bVar"V",Var("entrylo'rst",FTy 28)]), + Bop(Mdfy, + Close + (TP[nVar"i",AVar bTy], + ITB([(EQ(nVar"i",LN 63),bVar"S"), + (EQ(nVar"i",LN 62),bVar"L"), + (EQ(nVar"i",LN 61), + Bop(Bit,Var("entrylo'rst",FTy 28),LN 27)), + (EQ(nVar"i",LN 60), + Bop(Bit,Var("entrylo'rst",FTy 28),LN 26)), + (EQ(nVar"i",LN 59), + Bop(Bit,Var("entrylo'rst",FTy 28),LN 25)), + (EQ(nVar"i",LN 58), + Bop(Bit,Var("entrylo'rst",FTy 28),LN 24)), + (EQ(nVar"i",LN 57), + Bop(Bit,Var("entrylo'rst",FTy 28),LN 23)), + (EQ(nVar"i",LN 56), + Bop(Bit,Var("entrylo'rst",FTy 28),LN 22)), + (EQ(nVar"i",LN 55), + Bop(Bit,Var("entrylo'rst",FTy 28),LN 21)), + (EQ(nVar"i",LN 54), + Bop(Bit,Var("entrylo'rst",FTy 28),LN 20)), + (EQ(nVar"i",LN 53), + Bop(Bit,Var("entrylo'rst",FTy 28),LN 19)), + (EQ(nVar"i",LN 52), + Bop(Bit,Var("entrylo'rst",FTy 28),LN 18)), + (EQ(nVar"i",LN 51), + Bop(Bit,Var("entrylo'rst",FTy 28),LN 17)), + (EQ(nVar"i",LN 50), + Bop(Bit,Var("entrylo'rst",FTy 28),LN 16)), + (EQ(nVar"i",LN 49), + Bop(Bit,Var("entrylo'rst",FTy 28),LN 15)), + (EQ(nVar"i",LN 48), + Bop(Bit,Var("entrylo'rst",FTy 28),LN 14)), + (EQ(nVar"i",LN 47), + Bop(Bit,Var("entrylo'rst",FTy 28),LN 13)), + (EQ(nVar"i",LN 46), + Bop(Bit,Var("entrylo'rst",FTy 28),LN 12)), + (EQ(nVar"i",LN 45), + Bop(Bit,Var("entrylo'rst",FTy 28),LN 11)), + (EQ(nVar"i",LN 44), + Bop(Bit,Var("entrylo'rst",FTy 28),LN 10)), + (EQ(nVar"i",LN 43), + Bop(Bit,Var("entrylo'rst",FTy 28),LN 9)), + (EQ(nVar"i",LN 42), + Bop(Bit,Var("entrylo'rst",FTy 28),LN 8)), + (EQ(nVar"i",LN 41), + Bop(Bit,Var("entrylo'rst",FTy 28),LN 7)), + (EQ(nVar"i",LN 40), + Bop(Bit,Var("entrylo'rst",FTy 28),LN 6)), + (EQ(nVar"i",LN 39), + Bop(Bit,Var("entrylo'rst",FTy 28),LN 5)), + (EQ(nVar"i",LN 38), + Bop(Bit,Var("entrylo'rst",FTy 28),LN 4)), + (EQ(nVar"i",LN 37), + Bop(Bit,Var("entrylo'rst",FTy 28),LN 3)), + (EQ(nVar"i",LN 36), + Bop(Bit,Var("entrylo'rst",FTy 28),LN 2)), + (EQ(nVar"i",LN 35), + Bop(Bit,Var("entrylo'rst",FTy 28),LN 1)), + (EQ(nVar"i",LN 34), + Bop(Bit,Var("entrylo'rst",FTy 28),LN 0)), + (EQ(nVar"i",LN 33),Bop(Bit,Var("PFN",FTy 28),LN 27)), + (EQ(nVar"i",LN 32),Bop(Bit,Var("PFN",FTy 28),LN 26)), + (EQ(nVar"i",LN 31),Bop(Bit,Var("PFN",FTy 28),LN 25)), + (EQ(nVar"i",LN 30),Bop(Bit,Var("PFN",FTy 28),LN 24)), + (EQ(nVar"i",LN 29),Bop(Bit,Var("PFN",FTy 28),LN 23)), + (EQ(nVar"i",LN 28),Bop(Bit,Var("PFN",FTy 28),LN 22)), + (EQ(nVar"i",LN 27),Bop(Bit,Var("PFN",FTy 28),LN 21)), + (EQ(nVar"i",LN 26),Bop(Bit,Var("PFN",FTy 28),LN 20)), + (EQ(nVar"i",LN 25),Bop(Bit,Var("PFN",FTy 28),LN 19)), + (EQ(nVar"i",LN 24),Bop(Bit,Var("PFN",FTy 28),LN 18)), + (EQ(nVar"i",LN 23),Bop(Bit,Var("PFN",FTy 28),LN 17)), + (EQ(nVar"i",LN 22),Bop(Bit,Var("PFN",FTy 28),LN 16)), + (EQ(nVar"i",LN 21),Bop(Bit,Var("PFN",FTy 28),LN 15)), + (EQ(nVar"i",LN 20),Bop(Bit,Var("PFN",FTy 28),LN 14)), + (EQ(nVar"i",LN 19),Bop(Bit,Var("PFN",FTy 28),LN 13)), + (EQ(nVar"i",LN 18),Bop(Bit,Var("PFN",FTy 28),LN 12)), + (EQ(nVar"i",LN 17),Bop(Bit,Var("PFN",FTy 28),LN 11)), + (EQ(nVar"i",LN 16),Bop(Bit,Var("PFN",FTy 28),LN 10)), + (EQ(nVar"i",LN 15),Bop(Bit,Var("PFN",FTy 28),LN 9)), + (EQ(nVar"i",LN 14),Bop(Bit,Var("PFN",FTy 28),LN 8)), + (EQ(nVar"i",LN 13),Bop(Bit,Var("PFN",FTy 28),LN 7)), + (EQ(nVar"i",LN 12),Bop(Bit,Var("PFN",FTy 28),LN 6)), + (EQ(nVar"i",LN 11),Bop(Bit,Var("PFN",FTy 28),LN 5)), + (EQ(nVar"i",LN 10),Bop(Bit,Var("PFN",FTy 28),LN 4)), + (EQ(nVar"i",LN 9),Bop(Bit,Var("PFN",FTy 28),LN 3)), + (EQ(nVar"i",LN 8),Bop(Bit,Var("PFN",FTy 28),LN 2)), + (EQ(nVar"i",LN 7),Bop(Bit,Var("PFN",FTy 28),LN 1)), + (EQ(nVar"i",LN 6),Bop(Bit,Var("PFN",FTy 28),LN 0)), + (EQ(nVar"i",LN 5),Bop(Bit,Var("C",FTy 3),LN 2)), + (EQ(nVar"i",LN 4),Bop(Bit,Var("C",FTy 3),LN 1)), + (EQ(nVar"i",LN 3),Bop(Bit,Var("C",FTy 3),LN 0)), + (EQ(nVar"i",LN 2),bVar"D"),(EQ(nVar"i",LN 1),bVar"V")], + bVar"G")),LW(0,64)))])) +; +val write'rec'EntryLo_def = Def + ("write'rec'EntryLo",TP[AVar F64,Var("x",CTy"EntryLo")], + Call("reg'EntryLo",F64,Var("x",CTy"EntryLo"))) +; +val write'reg'EntryLo_def = Def + ("write'reg'EntryLo",TP[AVar(CTy"EntryLo"),Var("x",F64)], + Call("rec'EntryLo",CTy"EntryLo",Var("x",F64))) +; +val rec'Index_def = Def + ("rec'Index",Var("x",F32), + Rec(CTy"Index", + [EX(Var("x",F32),LN 7,LN 0,F8),Bop(Bit,Var("x",F32),LN 31), + EX(Var("x",F32),LN 30,LN 8,FTy 23)])) +; +val reg'Index_def = Def + ("reg'Index",Var("x",CTy"Index"), + CS(Var("x",CTy"Index"), + [(Rec(CTy"Index",[Var("Index",F8),bVar"P",Var("index'rst",FTy 23)]), + Bop(Mdfy, + Close + (TP[nVar"i",AVar bTy], + ITB([(EQ(nVar"i",LN 31),bVar"P"), + (EQ(nVar"i",LN 30), + Bop(Bit,Var("index'rst",FTy 23),LN 22)), + (EQ(nVar"i",LN 29), + Bop(Bit,Var("index'rst",FTy 23),LN 21)), + (EQ(nVar"i",LN 28), + Bop(Bit,Var("index'rst",FTy 23),LN 20)), + (EQ(nVar"i",LN 27), + Bop(Bit,Var("index'rst",FTy 23),LN 19)), + (EQ(nVar"i",LN 26), + Bop(Bit,Var("index'rst",FTy 23),LN 18)), + (EQ(nVar"i",LN 25), + Bop(Bit,Var("index'rst",FTy 23),LN 17)), + (EQ(nVar"i",LN 24), + Bop(Bit,Var("index'rst",FTy 23),LN 16)), + (EQ(nVar"i",LN 23), + Bop(Bit,Var("index'rst",FTy 23),LN 15)), + (EQ(nVar"i",LN 22), + Bop(Bit,Var("index'rst",FTy 23),LN 14)), + (EQ(nVar"i",LN 21), + Bop(Bit,Var("index'rst",FTy 23),LN 13)), + (EQ(nVar"i",LN 20), + Bop(Bit,Var("index'rst",FTy 23),LN 12)), + (EQ(nVar"i",LN 19), + Bop(Bit,Var("index'rst",FTy 23),LN 11)), + (EQ(nVar"i",LN 18), + Bop(Bit,Var("index'rst",FTy 23),LN 10)), + (EQ(nVar"i",LN 17), + Bop(Bit,Var("index'rst",FTy 23),LN 9)), + (EQ(nVar"i",LN 16), + Bop(Bit,Var("index'rst",FTy 23),LN 8)), + (EQ(nVar"i",LN 15), + Bop(Bit,Var("index'rst",FTy 23),LN 7)), + (EQ(nVar"i",LN 14), + Bop(Bit,Var("index'rst",FTy 23),LN 6)), + (EQ(nVar"i",LN 13), + Bop(Bit,Var("index'rst",FTy 23),LN 5)), + (EQ(nVar"i",LN 12), + Bop(Bit,Var("index'rst",FTy 23),LN 4)), + (EQ(nVar"i",LN 11), + Bop(Bit,Var("index'rst",FTy 23),LN 3)), + (EQ(nVar"i",LN 10), + Bop(Bit,Var("index'rst",FTy 23),LN 2)), + (EQ(nVar"i",LN 9), + Bop(Bit,Var("index'rst",FTy 23),LN 1)), + (EQ(nVar"i",LN 8), + Bop(Bit,Var("index'rst",FTy 23),LN 0)), + (EQ(nVar"i",LN 7),Bop(Bit,Var("Index",F8),LN 7)), + (EQ(nVar"i",LN 6),Bop(Bit,Var("Index",F8),LN 6)), + (EQ(nVar"i",LN 5),Bop(Bit,Var("Index",F8),LN 5)), + (EQ(nVar"i",LN 4),Bop(Bit,Var("Index",F8),LN 4)), + (EQ(nVar"i",LN 3),Bop(Bit,Var("Index",F8),LN 3)), + (EQ(nVar"i",LN 2),Bop(Bit,Var("Index",F8),LN 2)), + (EQ(nVar"i",LN 1),Bop(Bit,Var("Index",F8),LN 1))], + Bop(Bit,Var("Index",F8),LN 0))),LW(0,32)))])) +; +val write'rec'Index_def = Def + ("write'rec'Index",TP[AVar F32,Var("x",CTy"Index")], + Call("reg'Index",F32,Var("x",CTy"Index"))) +; +val write'reg'Index_def = Def + ("write'reg'Index",TP[AVar(CTy"Index"),Var("x",F32)], + Call("rec'Index",CTy"Index",Var("x",F32))) +; +val rec'Random_def = Def + ("rec'Random",Var("x",F32), + Rec(CTy"Random", + [EX(Var("x",F32),LN 7,LN 0,F8),EX(Var("x",F32),LN 31,LN 8,FTy 24)])) +; +val reg'Random_def = Def + ("reg'Random",Var("x",CTy"Random"), + CS(Var("x",CTy"Random"), + [(Rec(CTy"Random",[Var("Random",F8),Var("random'rst",FTy 24)]), + Bop(Mdfy, + Close + (TP[nVar"i",AVar bTy], + ITB([(EQ(nVar"i",LN 31), + Bop(Bit,Var("random'rst",FTy 24),LN 23)), + (EQ(nVar"i",LN 30), + Bop(Bit,Var("random'rst",FTy 24),LN 22)), + (EQ(nVar"i",LN 29), + Bop(Bit,Var("random'rst",FTy 24),LN 21)), + (EQ(nVar"i",LN 28), + Bop(Bit,Var("random'rst",FTy 24),LN 20)), + (EQ(nVar"i",LN 27), + Bop(Bit,Var("random'rst",FTy 24),LN 19)), + (EQ(nVar"i",LN 26), + Bop(Bit,Var("random'rst",FTy 24),LN 18)), + (EQ(nVar"i",LN 25), + Bop(Bit,Var("random'rst",FTy 24),LN 17)), + (EQ(nVar"i",LN 24), + Bop(Bit,Var("random'rst",FTy 24),LN 16)), + (EQ(nVar"i",LN 23), + Bop(Bit,Var("random'rst",FTy 24),LN 15)), + (EQ(nVar"i",LN 22), + Bop(Bit,Var("random'rst",FTy 24),LN 14)), + (EQ(nVar"i",LN 21), + Bop(Bit,Var("random'rst",FTy 24),LN 13)), + (EQ(nVar"i",LN 20), + Bop(Bit,Var("random'rst",FTy 24),LN 12)), + (EQ(nVar"i",LN 19), + Bop(Bit,Var("random'rst",FTy 24),LN 11)), + (EQ(nVar"i",LN 18), + Bop(Bit,Var("random'rst",FTy 24),LN 10)), + (EQ(nVar"i",LN 17), + Bop(Bit,Var("random'rst",FTy 24),LN 9)), + (EQ(nVar"i",LN 16), + Bop(Bit,Var("random'rst",FTy 24),LN 8)), + (EQ(nVar"i",LN 15), + Bop(Bit,Var("random'rst",FTy 24),LN 7)), + (EQ(nVar"i",LN 14), + Bop(Bit,Var("random'rst",FTy 24),LN 6)), + (EQ(nVar"i",LN 13), + Bop(Bit,Var("random'rst",FTy 24),LN 5)), + (EQ(nVar"i",LN 12), + Bop(Bit,Var("random'rst",FTy 24),LN 4)), + (EQ(nVar"i",LN 11), + Bop(Bit,Var("random'rst",FTy 24),LN 3)), + (EQ(nVar"i",LN 10), + Bop(Bit,Var("random'rst",FTy 24),LN 2)), + (EQ(nVar"i",LN 9), + Bop(Bit,Var("random'rst",FTy 24),LN 1)), + (EQ(nVar"i",LN 8), + Bop(Bit,Var("random'rst",FTy 24),LN 0)), + (EQ(nVar"i",LN 7),Bop(Bit,Var("Random",F8),LN 7)), + (EQ(nVar"i",LN 6),Bop(Bit,Var("Random",F8),LN 6)), + (EQ(nVar"i",LN 5),Bop(Bit,Var("Random",F8),LN 5)), + (EQ(nVar"i",LN 4),Bop(Bit,Var("Random",F8),LN 4)), + (EQ(nVar"i",LN 3),Bop(Bit,Var("Random",F8),LN 3)), + (EQ(nVar"i",LN 2),Bop(Bit,Var("Random",F8),LN 2)), + (EQ(nVar"i",LN 1),Bop(Bit,Var("Random",F8),LN 1))], + Bop(Bit,Var("Random",F8),LN 0))),LW(0,32)))])) +; +val write'rec'Random_def = Def + ("write'rec'Random",TP[AVar F32,Var("x",CTy"Random")], + Call("reg'Random",F32,Var("x",CTy"Random"))) +; +val write'reg'Random_def = Def + ("write'reg'Random",TP[AVar(CTy"Random"),Var("x",F32)], + Call("rec'Random",CTy"Random",Var("x",F32))) +; +val rec'Wired_def = Def + ("rec'Wired",Var("x",F32), + Rec(CTy"Wired", + [EX(Var("x",F32),LN 7,LN 0,F8),EX(Var("x",F32),LN 31,LN 8,FTy 24)])) +; +val reg'Wired_def = Def + ("reg'Wired",Var("x",CTy"Wired"), + CS(Var("x",CTy"Wired"), + [(Rec(CTy"Wired",[Var("Wired",F8),Var("wired'rst",FTy 24)]), + Bop(Mdfy, + Close + (TP[nVar"i",AVar bTy], + ITB([(EQ(nVar"i",LN 31), + Bop(Bit,Var("wired'rst",FTy 24),LN 23)), + (EQ(nVar"i",LN 30), + Bop(Bit,Var("wired'rst",FTy 24),LN 22)), + (EQ(nVar"i",LN 29), + Bop(Bit,Var("wired'rst",FTy 24),LN 21)), + (EQ(nVar"i",LN 28), + Bop(Bit,Var("wired'rst",FTy 24),LN 20)), + (EQ(nVar"i",LN 27), + Bop(Bit,Var("wired'rst",FTy 24),LN 19)), + (EQ(nVar"i",LN 26), + Bop(Bit,Var("wired'rst",FTy 24),LN 18)), + (EQ(nVar"i",LN 25), + Bop(Bit,Var("wired'rst",FTy 24),LN 17)), + (EQ(nVar"i",LN 24), + Bop(Bit,Var("wired'rst",FTy 24),LN 16)), + (EQ(nVar"i",LN 23), + Bop(Bit,Var("wired'rst",FTy 24),LN 15)), + (EQ(nVar"i",LN 22), + Bop(Bit,Var("wired'rst",FTy 24),LN 14)), + (EQ(nVar"i",LN 21), + Bop(Bit,Var("wired'rst",FTy 24),LN 13)), + (EQ(nVar"i",LN 20), + Bop(Bit,Var("wired'rst",FTy 24),LN 12)), + (EQ(nVar"i",LN 19), + Bop(Bit,Var("wired'rst",FTy 24),LN 11)), + (EQ(nVar"i",LN 18), + Bop(Bit,Var("wired'rst",FTy 24),LN 10)), + (EQ(nVar"i",LN 17), + Bop(Bit,Var("wired'rst",FTy 24),LN 9)), + (EQ(nVar"i",LN 16), + Bop(Bit,Var("wired'rst",FTy 24),LN 8)), + (EQ(nVar"i",LN 15), + Bop(Bit,Var("wired'rst",FTy 24),LN 7)), + (EQ(nVar"i",LN 14), + Bop(Bit,Var("wired'rst",FTy 24),LN 6)), + (EQ(nVar"i",LN 13), + Bop(Bit,Var("wired'rst",FTy 24),LN 5)), + (EQ(nVar"i",LN 12), + Bop(Bit,Var("wired'rst",FTy 24),LN 4)), + (EQ(nVar"i",LN 11), + Bop(Bit,Var("wired'rst",FTy 24),LN 3)), + (EQ(nVar"i",LN 10), + Bop(Bit,Var("wired'rst",FTy 24),LN 2)), + (EQ(nVar"i",LN 9), + Bop(Bit,Var("wired'rst",FTy 24),LN 1)), + (EQ(nVar"i",LN 8), + Bop(Bit,Var("wired'rst",FTy 24),LN 0)), + (EQ(nVar"i",LN 7),Bop(Bit,Var("Wired",F8),LN 7)), + (EQ(nVar"i",LN 6),Bop(Bit,Var("Wired",F8),LN 6)), + (EQ(nVar"i",LN 5),Bop(Bit,Var("Wired",F8),LN 5)), + (EQ(nVar"i",LN 4),Bop(Bit,Var("Wired",F8),LN 4)), + (EQ(nVar"i",LN 3),Bop(Bit,Var("Wired",F8),LN 3)), + (EQ(nVar"i",LN 2),Bop(Bit,Var("Wired",F8),LN 2)), + (EQ(nVar"i",LN 1),Bop(Bit,Var("Wired",F8),LN 1))], + Bop(Bit,Var("Wired",F8),LN 0))),LW(0,32)))])) +; +val write'rec'Wired_def = Def + ("write'rec'Wired",TP[AVar F32,Var("x",CTy"Wired")], + Call("reg'Wired",F32,Var("x",CTy"Wired"))) +; +val write'reg'Wired_def = Def + ("write'reg'Wired",TP[AVar(CTy"Wired"),Var("x",F32)], + Call("rec'Wired",CTy"Wired",Var("x",F32))) +; +val rec'PageMask_def = Def + ("rec'PageMask",Var("x",F32), + Rec(CTy"PageMask", + [EX(Var("x",F32),LN 24,LN 13,FTy 12), + CC[EX(Var("x",F32),LN 12,LN 0,FTy 13), + EX(Var("x",F32),LN 31,LN 25,FTy 7)]])) +; +val reg'PageMask_def = Def + ("reg'PageMask",Var("x",CTy"PageMask"), + CS(Var("x",CTy"PageMask"), + [(Rec(CTy"PageMask",[Var("Mask",FTy 12),Var("pagemask'rst",FTy 20)]), + Bop(Mdfy, + Close + (TP[nVar"i",AVar bTy], + ITB([(EQ(nVar"i",LN 31), + Bop(Bit,Var("pagemask'rst",FTy 20),LN 6)), + (EQ(nVar"i",LN 30), + Bop(Bit,Var("pagemask'rst",FTy 20),LN 5)), + (EQ(nVar"i",LN 29), + Bop(Bit,Var("pagemask'rst",FTy 20),LN 4)), + (EQ(nVar"i",LN 28), + Bop(Bit,Var("pagemask'rst",FTy 20),LN 3)), + (EQ(nVar"i",LN 27), + Bop(Bit,Var("pagemask'rst",FTy 20),LN 2)), + (EQ(nVar"i",LN 26), + Bop(Bit,Var("pagemask'rst",FTy 20),LN 1)), + (EQ(nVar"i",LN 25), + Bop(Bit,Var("pagemask'rst",FTy 20),LN 0)), + (EQ(nVar"i",LN 24),Bop(Bit,Var("Mask",FTy 12),LN 11)), + (EQ(nVar"i",LN 23),Bop(Bit,Var("Mask",FTy 12),LN 10)), + (EQ(nVar"i",LN 22),Bop(Bit,Var("Mask",FTy 12),LN 9)), + (EQ(nVar"i",LN 21),Bop(Bit,Var("Mask",FTy 12),LN 8)), + (EQ(nVar"i",LN 20),Bop(Bit,Var("Mask",FTy 12),LN 7)), + (EQ(nVar"i",LN 19),Bop(Bit,Var("Mask",FTy 12),LN 6)), + (EQ(nVar"i",LN 18),Bop(Bit,Var("Mask",FTy 12),LN 5)), + (EQ(nVar"i",LN 17),Bop(Bit,Var("Mask",FTy 12),LN 4)), + (EQ(nVar"i",LN 16),Bop(Bit,Var("Mask",FTy 12),LN 3)), + (EQ(nVar"i",LN 15),Bop(Bit,Var("Mask",FTy 12),LN 2)), + (EQ(nVar"i",LN 14),Bop(Bit,Var("Mask",FTy 12),LN 1)), + (EQ(nVar"i",LN 13),Bop(Bit,Var("Mask",FTy 12),LN 0)), + (EQ(nVar"i",LN 12), + Bop(Bit,Var("pagemask'rst",FTy 20),LN 19)), + (EQ(nVar"i",LN 11), + Bop(Bit,Var("pagemask'rst",FTy 20),LN 18)), + (EQ(nVar"i",LN 10), + Bop(Bit,Var("pagemask'rst",FTy 20),LN 17)), + (EQ(nVar"i",LN 9), + Bop(Bit,Var("pagemask'rst",FTy 20),LN 16)), + (EQ(nVar"i",LN 8), + Bop(Bit,Var("pagemask'rst",FTy 20),LN 15)), + (EQ(nVar"i",LN 7), + Bop(Bit,Var("pagemask'rst",FTy 20),LN 14)), + (EQ(nVar"i",LN 6), + Bop(Bit,Var("pagemask'rst",FTy 20),LN 13)), + (EQ(nVar"i",LN 5), + Bop(Bit,Var("pagemask'rst",FTy 20),LN 12)), + (EQ(nVar"i",LN 4), + Bop(Bit,Var("pagemask'rst",FTy 20),LN 11)), + (EQ(nVar"i",LN 3), + Bop(Bit,Var("pagemask'rst",FTy 20),LN 10)), + (EQ(nVar"i",LN 2), + Bop(Bit,Var("pagemask'rst",FTy 20),LN 9)), + (EQ(nVar"i",LN 1), + Bop(Bit,Var("pagemask'rst",FTy 20),LN 8))], + Bop(Bit,Var("pagemask'rst",FTy 20),LN 7))),LW(0,32)))])) +; +val write'rec'PageMask_def = Def + ("write'rec'PageMask",TP[AVar F32,Var("x",CTy"PageMask")], + Call("reg'PageMask",F32,Var("x",CTy"PageMask"))) +; +val write'reg'PageMask_def = Def + ("write'reg'PageMask",TP[AVar(CTy"PageMask"),Var("x",F32)], + Call("rec'PageMask",CTy"PageMask",Var("x",F32))) +; +val rec'EntryHi_def = Def + ("rec'EntryHi",Var("x",F64), + Rec(CTy"EntryHi", + [EX(Var("x",F64),LN 7,LN 0,F8),EX(Var("x",F64),LN 63,LN 62,FTy 2), + EX(Var("x",F64),LN 39,LN 13,FTy 27), + CC[EX(Var("x",F64),LN 12,LN 8,FTy 5), + EX(Var("x",F64),LN 61,LN 40,FTy 22)]])) +; +val reg'EntryHi_def = Def + ("reg'EntryHi",Var("x",CTy"EntryHi"), + CS(Var("x",CTy"EntryHi"), + [(Rec(CTy"EntryHi", + [Var("ASID",F8),Var("R",FTy 2),Var("VPN2",FTy 27), + Var("entryhi'rst",FTy 27)]), + Bop(Mdfy, + Close + (TP[nVar"i",AVar bTy], + ITB([(EQ(nVar"i",LN 63),Bop(Bit,Var("R",FTy 2),LN 1)), + (EQ(nVar"i",LN 62),Bop(Bit,Var("R",FTy 2),LN 0)), + (EQ(nVar"i",LN 61), + Bop(Bit,Var("entryhi'rst",FTy 27),LN 21)), + (EQ(nVar"i",LN 60), + Bop(Bit,Var("entryhi'rst",FTy 27),LN 20)), + (EQ(nVar"i",LN 59), + Bop(Bit,Var("entryhi'rst",FTy 27),LN 19)), + (EQ(nVar"i",LN 58), + Bop(Bit,Var("entryhi'rst",FTy 27),LN 18)), + (EQ(nVar"i",LN 57), + Bop(Bit,Var("entryhi'rst",FTy 27),LN 17)), + (EQ(nVar"i",LN 56), + Bop(Bit,Var("entryhi'rst",FTy 27),LN 16)), + (EQ(nVar"i",LN 55), + Bop(Bit,Var("entryhi'rst",FTy 27),LN 15)), + (EQ(nVar"i",LN 54), + Bop(Bit,Var("entryhi'rst",FTy 27),LN 14)), + (EQ(nVar"i",LN 53), + Bop(Bit,Var("entryhi'rst",FTy 27),LN 13)), + (EQ(nVar"i",LN 52), + Bop(Bit,Var("entryhi'rst",FTy 27),LN 12)), + (EQ(nVar"i",LN 51), + Bop(Bit,Var("entryhi'rst",FTy 27),LN 11)), + (EQ(nVar"i",LN 50), + Bop(Bit,Var("entryhi'rst",FTy 27),LN 10)), + (EQ(nVar"i",LN 49), + Bop(Bit,Var("entryhi'rst",FTy 27),LN 9)), + (EQ(nVar"i",LN 48), + Bop(Bit,Var("entryhi'rst",FTy 27),LN 8)), + (EQ(nVar"i",LN 47), + Bop(Bit,Var("entryhi'rst",FTy 27),LN 7)), + (EQ(nVar"i",LN 46), + Bop(Bit,Var("entryhi'rst",FTy 27),LN 6)), + (EQ(nVar"i",LN 45), + Bop(Bit,Var("entryhi'rst",FTy 27),LN 5)), + (EQ(nVar"i",LN 44), + Bop(Bit,Var("entryhi'rst",FTy 27),LN 4)), + (EQ(nVar"i",LN 43), + Bop(Bit,Var("entryhi'rst",FTy 27),LN 3)), + (EQ(nVar"i",LN 42), + Bop(Bit,Var("entryhi'rst",FTy 27),LN 2)), + (EQ(nVar"i",LN 41), + Bop(Bit,Var("entryhi'rst",FTy 27),LN 1)), + (EQ(nVar"i",LN 40), + Bop(Bit,Var("entryhi'rst",FTy 27),LN 0)), + (EQ(nVar"i",LN 39),Bop(Bit,Var("VPN2",FTy 27),LN 26)), + (EQ(nVar"i",LN 38),Bop(Bit,Var("VPN2",FTy 27),LN 25)), + (EQ(nVar"i",LN 37),Bop(Bit,Var("VPN2",FTy 27),LN 24)), + (EQ(nVar"i",LN 36),Bop(Bit,Var("VPN2",FTy 27),LN 23)), + (EQ(nVar"i",LN 35),Bop(Bit,Var("VPN2",FTy 27),LN 22)), + (EQ(nVar"i",LN 34),Bop(Bit,Var("VPN2",FTy 27),LN 21)), + (EQ(nVar"i",LN 33),Bop(Bit,Var("VPN2",FTy 27),LN 20)), + (EQ(nVar"i",LN 32),Bop(Bit,Var("VPN2",FTy 27),LN 19)), + (EQ(nVar"i",LN 31),Bop(Bit,Var("VPN2",FTy 27),LN 18)), + (EQ(nVar"i",LN 30),Bop(Bit,Var("VPN2",FTy 27),LN 17)), + (EQ(nVar"i",LN 29),Bop(Bit,Var("VPN2",FTy 27),LN 16)), + (EQ(nVar"i",LN 28),Bop(Bit,Var("VPN2",FTy 27),LN 15)), + (EQ(nVar"i",LN 27),Bop(Bit,Var("VPN2",FTy 27),LN 14)), + (EQ(nVar"i",LN 26),Bop(Bit,Var("VPN2",FTy 27),LN 13)), + (EQ(nVar"i",LN 25),Bop(Bit,Var("VPN2",FTy 27),LN 12)), + (EQ(nVar"i",LN 24),Bop(Bit,Var("VPN2",FTy 27),LN 11)), + (EQ(nVar"i",LN 23),Bop(Bit,Var("VPN2",FTy 27),LN 10)), + (EQ(nVar"i",LN 22),Bop(Bit,Var("VPN2",FTy 27),LN 9)), + (EQ(nVar"i",LN 21),Bop(Bit,Var("VPN2",FTy 27),LN 8)), + (EQ(nVar"i",LN 20),Bop(Bit,Var("VPN2",FTy 27),LN 7)), + (EQ(nVar"i",LN 19),Bop(Bit,Var("VPN2",FTy 27),LN 6)), + (EQ(nVar"i",LN 18),Bop(Bit,Var("VPN2",FTy 27),LN 5)), + (EQ(nVar"i",LN 17),Bop(Bit,Var("VPN2",FTy 27),LN 4)), + (EQ(nVar"i",LN 16),Bop(Bit,Var("VPN2",FTy 27),LN 3)), + (EQ(nVar"i",LN 15),Bop(Bit,Var("VPN2",FTy 27),LN 2)), + (EQ(nVar"i",LN 14),Bop(Bit,Var("VPN2",FTy 27),LN 1)), + (EQ(nVar"i",LN 13),Bop(Bit,Var("VPN2",FTy 27),LN 0)), + (EQ(nVar"i",LN 12), + Bop(Bit,Var("entryhi'rst",FTy 27),LN 26)), + (EQ(nVar"i",LN 11), + Bop(Bit,Var("entryhi'rst",FTy 27),LN 25)), + (EQ(nVar"i",LN 10), + Bop(Bit,Var("entryhi'rst",FTy 27),LN 24)), + (EQ(nVar"i",LN 9), + Bop(Bit,Var("entryhi'rst",FTy 27),LN 23)), + (EQ(nVar"i",LN 8), + Bop(Bit,Var("entryhi'rst",FTy 27),LN 22)), + (EQ(nVar"i",LN 7),Bop(Bit,Var("ASID",F8),LN 7)), + (EQ(nVar"i",LN 6),Bop(Bit,Var("ASID",F8),LN 6)), + (EQ(nVar"i",LN 5),Bop(Bit,Var("ASID",F8),LN 5)), + (EQ(nVar"i",LN 4),Bop(Bit,Var("ASID",F8),LN 4)), + (EQ(nVar"i",LN 3),Bop(Bit,Var("ASID",F8),LN 3)), + (EQ(nVar"i",LN 2),Bop(Bit,Var("ASID",F8),LN 2)), + (EQ(nVar"i",LN 1),Bop(Bit,Var("ASID",F8),LN 1))], + Bop(Bit,Var("ASID",F8),LN 0))),LW(0,64)))])) +; +val write'rec'EntryHi_def = Def + ("write'rec'EntryHi",TP[AVar F64,Var("x",CTy"EntryHi")], + Call("reg'EntryHi",F64,Var("x",CTy"EntryHi"))) +; +val write'reg'EntryHi_def = Def + ("write'reg'EntryHi",TP[AVar(CTy"EntryHi"),Var("x",F64)], + Call("rec'EntryHi",CTy"EntryHi",Var("x",F64))) +; +val rec'StatusRegister_def = Def + ("rec'StatusRegister",Var("x",F32), + Rec(CTy"StatusRegister", + [Bop(Bit,Var("x",F32),LN 22),Bop(Bit,Var("x",F32),LN 28), + Bop(Bit,Var("x",F32),LN 29),Bop(Bit,Var("x",F32),LN 30), + Bop(Bit,Var("x",F32),LN 31),Bop(Bit,Var("x",F32),LN 2), + Bop(Bit,Var("x",F32),LN 1),Bop(Bit,Var("x",F32),LN 26), + Bop(Bit,Var("x",F32),LN 0),EX(Var("x",F32),LN 15,LN 8,F8), + EX(Var("x",F32),LN 4,LN 3,FTy 2),Bop(Bit,Var("x",F32),LN 7), + Bop(Bit,Var("x",F32),LN 25),Bop(Bit,Var("x",F32),LN 6), + Bop(Bit,Var("x",F32),LN 5), + CC[EX(Var("x",F32),LN 21,LN 16,FTy 6), + EX(Var("x",F32),LN 24,LN 23,FTy 2), + EX(Var("x",F32),LN 27,LN 27,F1)]])) +; +val reg'StatusRegister_def = Def + ("reg'StatusRegister",Var("x",CTy"StatusRegister"), + CS(Var("x",CTy"StatusRegister"), + [(Rec(CTy"StatusRegister", + [bVar"BEV",bVar"CU0",bVar"CU1",bVar"CU2",bVar"CU3",bVar"ERL", + bVar"EXL",bVar"FR",bVar"IE",Var("IM",F8),Var("KSU",FTy 2), + bVar"KX",bVar"RE",bVar"SX",bVar"UX", + Var("statusregister'rst",FTy 9)]), + Bop(Mdfy, + Close + (TP[nVar"i",AVar bTy], + ITB([(EQ(nVar"i",LN 31),bVar"CU3"), + (EQ(nVar"i",LN 30),bVar"CU2"), + (EQ(nVar"i",LN 29),bVar"CU1"), + (EQ(nVar"i",LN 28),bVar"CU0"), + (EQ(nVar"i",LN 27), + Bop(Bit,Var("statusregister'rst",FTy 9),LN 0)), + (EQ(nVar"i",LN 26),bVar"FR"), + (EQ(nVar"i",LN 25),bVar"RE"), + (EQ(nVar"i",LN 24), + Bop(Bit,Var("statusregister'rst",FTy 9),LN 2)), + (EQ(nVar"i",LN 23), + Bop(Bit,Var("statusregister'rst",FTy 9),LN 1)), + (EQ(nVar"i",LN 22),bVar"BEV"), + (EQ(nVar"i",LN 21), + Bop(Bit,Var("statusregister'rst",FTy 9),LN 8)), + (EQ(nVar"i",LN 20), + Bop(Bit,Var("statusregister'rst",FTy 9),LN 7)), + (EQ(nVar"i",LN 19), + Bop(Bit,Var("statusregister'rst",FTy 9),LN 6)), + (EQ(nVar"i",LN 18), + Bop(Bit,Var("statusregister'rst",FTy 9),LN 5)), + (EQ(nVar"i",LN 17), + Bop(Bit,Var("statusregister'rst",FTy 9),LN 4)), + (EQ(nVar"i",LN 16), + Bop(Bit,Var("statusregister'rst",FTy 9),LN 3)), + (EQ(nVar"i",LN 15),Bop(Bit,Var("IM",F8),LN 7)), + (EQ(nVar"i",LN 14),Bop(Bit,Var("IM",F8),LN 6)), + (EQ(nVar"i",LN 13),Bop(Bit,Var("IM",F8),LN 5)), + (EQ(nVar"i",LN 12),Bop(Bit,Var("IM",F8),LN 4)), + (EQ(nVar"i",LN 11),Bop(Bit,Var("IM",F8),LN 3)), + (EQ(nVar"i",LN 10),Bop(Bit,Var("IM",F8),LN 2)), + (EQ(nVar"i",LN 9),Bop(Bit,Var("IM",F8),LN 1)), + (EQ(nVar"i",LN 8),Bop(Bit,Var("IM",F8),LN 0)), + (EQ(nVar"i",LN 7),bVar"KX"), + (EQ(nVar"i",LN 6),bVar"SX"), + (EQ(nVar"i",LN 5),bVar"UX"), + (EQ(nVar"i",LN 4),Bop(Bit,Var("KSU",FTy 2),LN 1)), + (EQ(nVar"i",LN 3),Bop(Bit,Var("KSU",FTy 2),LN 0)), + (EQ(nVar"i",LN 2),bVar"ERL"), + (EQ(nVar"i",LN 1),bVar"EXL")],bVar"IE")),LW(0,32)))])) +; +val write'rec'StatusRegister_def = Def + ("write'rec'StatusRegister",TP[AVar F32,Var("x",CTy"StatusRegister")], + Call("reg'StatusRegister",F32,Var("x",CTy"StatusRegister"))) +; +val write'reg'StatusRegister_def = Def + ("write'reg'StatusRegister",TP[AVar(CTy"StatusRegister"),Var("x",F32)], + Call("rec'StatusRegister",CTy"StatusRegister",Var("x",F32))) +; +val rec'ConfigRegister_def = Def + ("rec'ConfigRegister",Var("x",F32), + Rec(CTy"ConfigRegister", + [EX(Var("x",F32),LN 12,LN 10,FTy 3), + EX(Var("x",F32),LN 14,LN 13,FTy 2),Bop(Bit,Var("x",F32),LN 15), + EX(Var("x",F32),LN 2,LN 0,FTy 3),Bop(Bit,Var("x",F32),LN 31), + EX(Var("x",F32),LN 9,LN 7,FTy 3), + CC[EX(Var("x",F32),LN 6,LN 3,F4), + EX(Var("x",F32),LN 30,LN 16,FTy 15)]])) +; +val reg'ConfigRegister_def = Def + ("reg'ConfigRegister",Var("x",CTy"ConfigRegister"), + CS(Var("x",CTy"ConfigRegister"), + [(Rec(CTy"ConfigRegister", + [Var("AR",FTy 3),Var("AT",FTy 2),bVar"BE",Var("K0",FTy 3), + bVar"M",Var("MT",FTy 3),Var("configregister'rst",FTy 19)]), + Bop(Mdfy, + Close + (TP[nVar"i",AVar bTy], + ITB([(EQ(nVar"i",LN 31),bVar"M"), + (EQ(nVar"i",LN 30), + Bop(Bit,Var("configregister'rst",FTy 19),LN 14)), + (EQ(nVar"i",LN 29), + Bop(Bit,Var("configregister'rst",FTy 19),LN 13)), + (EQ(nVar"i",LN 28), + Bop(Bit,Var("configregister'rst",FTy 19),LN 12)), + (EQ(nVar"i",LN 27), + Bop(Bit,Var("configregister'rst",FTy 19),LN 11)), + (EQ(nVar"i",LN 26), + Bop(Bit,Var("configregister'rst",FTy 19),LN 10)), + (EQ(nVar"i",LN 25), + Bop(Bit,Var("configregister'rst",FTy 19),LN 9)), + (EQ(nVar"i",LN 24), + Bop(Bit,Var("configregister'rst",FTy 19),LN 8)), + (EQ(nVar"i",LN 23), + Bop(Bit,Var("configregister'rst",FTy 19),LN 7)), + (EQ(nVar"i",LN 22), + Bop(Bit,Var("configregister'rst",FTy 19),LN 6)), + (EQ(nVar"i",LN 21), + Bop(Bit,Var("configregister'rst",FTy 19),LN 5)), + (EQ(nVar"i",LN 20), + Bop(Bit,Var("configregister'rst",FTy 19),LN 4)), + (EQ(nVar"i",LN 19), + Bop(Bit,Var("configregister'rst",FTy 19),LN 3)), + (EQ(nVar"i",LN 18), + Bop(Bit,Var("configregister'rst",FTy 19),LN 2)), + (EQ(nVar"i",LN 17), + Bop(Bit,Var("configregister'rst",FTy 19),LN 1)), + (EQ(nVar"i",LN 16), + Bop(Bit,Var("configregister'rst",FTy 19),LN 0)), + (EQ(nVar"i",LN 15),bVar"BE"), + (EQ(nVar"i",LN 14),Bop(Bit,Var("AT",FTy 2),LN 1)), + (EQ(nVar"i",LN 13),Bop(Bit,Var("AT",FTy 2),LN 0)), + (EQ(nVar"i",LN 12),Bop(Bit,Var("AR",FTy 3),LN 2)), + (EQ(nVar"i",LN 11),Bop(Bit,Var("AR",FTy 3),LN 1)), + (EQ(nVar"i",LN 10),Bop(Bit,Var("AR",FTy 3),LN 0)), + (EQ(nVar"i",LN 9),Bop(Bit,Var("MT",FTy 3),LN 2)), + (EQ(nVar"i",LN 8),Bop(Bit,Var("MT",FTy 3),LN 1)), + (EQ(nVar"i",LN 7),Bop(Bit,Var("MT",FTy 3),LN 0)), + (EQ(nVar"i",LN 6), + Bop(Bit,Var("configregister'rst",FTy 19),LN 18)), + (EQ(nVar"i",LN 5), + Bop(Bit,Var("configregister'rst",FTy 19),LN 17)), + (EQ(nVar"i",LN 4), + Bop(Bit,Var("configregister'rst",FTy 19),LN 16)), + (EQ(nVar"i",LN 3), + Bop(Bit,Var("configregister'rst",FTy 19),LN 15)), + (EQ(nVar"i",LN 2),Bop(Bit,Var("K0",FTy 3),LN 2)), + (EQ(nVar"i",LN 1),Bop(Bit,Var("K0",FTy 3),LN 1))], + Bop(Bit,Var("K0",FTy 3),LN 0))),LW(0,32)))])) +; +val write'rec'ConfigRegister_def = Def + ("write'rec'ConfigRegister",TP[AVar F32,Var("x",CTy"ConfigRegister")], + Call("reg'ConfigRegister",F32,Var("x",CTy"ConfigRegister"))) +; +val write'reg'ConfigRegister_def = Def + ("write'reg'ConfigRegister",TP[AVar(CTy"ConfigRegister"),Var("x",F32)], + Call("rec'ConfigRegister",CTy"ConfigRegister",Var("x",F32))) +; +val rec'ConfigRegister1_def = Def + ("rec'ConfigRegister1",Var("x",F32), + Rec(CTy"ConfigRegister1", + [Bop(Bit,Var("x",F32),LN 6),Bop(Bit,Var("x",F32),LN 2), + EX(Var("x",F32),LN 9,LN 7,FTy 3), + EX(Var("x",F32),LN 12,LN 10,FTy 3), + EX(Var("x",F32),LN 15,LN 13,FTy 3),Bop(Bit,Var("x",F32),LN 1), + Bop(Bit,Var("x",F32),LN 0),EX(Var("x",F32),LN 18,LN 16,FTy 3), + EX(Var("x",F32),LN 21,LN 19,FTy 3), + EX(Var("x",F32),LN 24,LN 22,FTy 3),Bop(Bit,Var("x",F32),LN 31), + Bop(Bit,Var("x",F32),LN 5),EX(Var("x",F32),LN 30,LN 25,FTy 6), + Bop(Bit,Var("x",F32),LN 4),Bop(Bit,Var("x",F32),LN 3)])) +; +val reg'ConfigRegister1_def = Def + ("reg'ConfigRegister1",Var("x",CTy"ConfigRegister1"), + CS(Var("x",CTy"ConfigRegister1"), + [(Rec(CTy"ConfigRegister1", + [bVar"C2",bVar"CA",Var("DA",FTy 3),Var("DL",FTy 3), + Var("DS",FTy 3),bVar"EP",bVar"FP",Var("IA",FTy 3), + Var("IL",FTy 3),Var("IS",FTy 3),bVar"M",bVar"MD", + Var("MMUSize",FTy 6),bVar"PCR",bVar"WR"]), + Bop(Mdfy, + Close + (TP[nVar"i",AVar bTy], + ITB([(EQ(nVar"i",LN 31),bVar"M"), + (EQ(nVar"i",LN 30),Bop(Bit,Var("MMUSize",FTy 6),LN 5)), + (EQ(nVar"i",LN 29),Bop(Bit,Var("MMUSize",FTy 6),LN 4)), + (EQ(nVar"i",LN 28),Bop(Bit,Var("MMUSize",FTy 6),LN 3)), + (EQ(nVar"i",LN 27),Bop(Bit,Var("MMUSize",FTy 6),LN 2)), + (EQ(nVar"i",LN 26),Bop(Bit,Var("MMUSize",FTy 6),LN 1)), + (EQ(nVar"i",LN 25),Bop(Bit,Var("MMUSize",FTy 6),LN 0)), + (EQ(nVar"i",LN 24),Bop(Bit,Var("IS",FTy 3),LN 2)), + (EQ(nVar"i",LN 23),Bop(Bit,Var("IS",FTy 3),LN 1)), + (EQ(nVar"i",LN 22),Bop(Bit,Var("IS",FTy 3),LN 0)), + (EQ(nVar"i",LN 21),Bop(Bit,Var("IL",FTy 3),LN 2)), + (EQ(nVar"i",LN 20),Bop(Bit,Var("IL",FTy 3),LN 1)), + (EQ(nVar"i",LN 19),Bop(Bit,Var("IL",FTy 3),LN 0)), + (EQ(nVar"i",LN 18),Bop(Bit,Var("IA",FTy 3),LN 2)), + (EQ(nVar"i",LN 17),Bop(Bit,Var("IA",FTy 3),LN 1)), + (EQ(nVar"i",LN 16),Bop(Bit,Var("IA",FTy 3),LN 0)), + (EQ(nVar"i",LN 15),Bop(Bit,Var("DS",FTy 3),LN 2)), + (EQ(nVar"i",LN 14),Bop(Bit,Var("DS",FTy 3),LN 1)), + (EQ(nVar"i",LN 13),Bop(Bit,Var("DS",FTy 3),LN 0)), + (EQ(nVar"i",LN 12),Bop(Bit,Var("DL",FTy 3),LN 2)), + (EQ(nVar"i",LN 11),Bop(Bit,Var("DL",FTy 3),LN 1)), + (EQ(nVar"i",LN 10),Bop(Bit,Var("DL",FTy 3),LN 0)), + (EQ(nVar"i",LN 9),Bop(Bit,Var("DA",FTy 3),LN 2)), + (EQ(nVar"i",LN 8),Bop(Bit,Var("DA",FTy 3),LN 1)), + (EQ(nVar"i",LN 7),Bop(Bit,Var("DA",FTy 3),LN 0)), + (EQ(nVar"i",LN 6),bVar"C2"), + (EQ(nVar"i",LN 5),bVar"MD"), + (EQ(nVar"i",LN 4),bVar"PCR"), + (EQ(nVar"i",LN 3),bVar"WR"), + (EQ(nVar"i",LN 2),bVar"CA"), + (EQ(nVar"i",LN 1),bVar"EP")],bVar"FP")),LW(0,32)))])) +; +val write'rec'ConfigRegister1_def = Def + ("write'rec'ConfigRegister1",TP[AVar F32,Var("x",CTy"ConfigRegister1")], + Call("reg'ConfigRegister1",F32,Var("x",CTy"ConfigRegister1"))) +; +val write'reg'ConfigRegister1_def = Def + ("write'reg'ConfigRegister1", + TP[AVar(CTy"ConfigRegister1"),Var("x",F32)], + Call("rec'ConfigRegister1",CTy"ConfigRegister1",Var("x",F32))) +; +val rec'ConfigRegister2_def = Def + ("rec'ConfigRegister2",Var("x",F32), + Rec(CTy"ConfigRegister2", + [Bop(Bit,Var("x",F32),LN 31),EX(Var("x",F32),LN 3,LN 0,F4), + EX(Var("x",F32),LN 7,LN 4,F4),EX(Var("x",F32),LN 11,LN 8,F4), + EX(Var("x",F32),LN 15,LN 12,F4),EX(Var("x",F32),LN 19,LN 16,F4), + EX(Var("x",F32),LN 23,LN 20,F4),EX(Var("x",F32),LN 27,LN 24,F4), + EX(Var("x",F32),LN 30,LN 28,FTy 3)])) +; +val reg'ConfigRegister2_def = Def + ("reg'ConfigRegister2",Var("x",CTy"ConfigRegister2"), + CS(Var("x",CTy"ConfigRegister2"), + [(Rec(CTy"ConfigRegister2", + [bVar"M",Var("SA",F4),Var("SL",F4),Var("SS",F4),Var("SU",F4), + Var("TA",F4),Var("TL",F4),Var("TS",F4),Var("TU",FTy 3)]), + Bop(Mdfy, + Close + (TP[nVar"i",AVar bTy], + ITB([(EQ(nVar"i",LN 31),bVar"M"), + (EQ(nVar"i",LN 30),Bop(Bit,Var("TU",FTy 3),LN 2)), + (EQ(nVar"i",LN 29),Bop(Bit,Var("TU",FTy 3),LN 1)), + (EQ(nVar"i",LN 28),Bop(Bit,Var("TU",FTy 3),LN 0)), + (EQ(nVar"i",LN 27),Bop(Bit,Var("TS",F4),LN 3)), + (EQ(nVar"i",LN 26),Bop(Bit,Var("TS",F4),LN 2)), + (EQ(nVar"i",LN 25),Bop(Bit,Var("TS",F4),LN 1)), + (EQ(nVar"i",LN 24),Bop(Bit,Var("TS",F4),LN 0)), + (EQ(nVar"i",LN 23),Bop(Bit,Var("TL",F4),LN 3)), + (EQ(nVar"i",LN 22),Bop(Bit,Var("TL",F4),LN 2)), + (EQ(nVar"i",LN 21),Bop(Bit,Var("TL",F4),LN 1)), + (EQ(nVar"i",LN 20),Bop(Bit,Var("TL",F4),LN 0)), + (EQ(nVar"i",LN 19),Bop(Bit,Var("TA",F4),LN 3)), + (EQ(nVar"i",LN 18),Bop(Bit,Var("TA",F4),LN 2)), + (EQ(nVar"i",LN 17),Bop(Bit,Var("TA",F4),LN 1)), + (EQ(nVar"i",LN 16),Bop(Bit,Var("TA",F4),LN 0)), + (EQ(nVar"i",LN 15),Bop(Bit,Var("SU",F4),LN 3)), + (EQ(nVar"i",LN 14),Bop(Bit,Var("SU",F4),LN 2)), + (EQ(nVar"i",LN 13),Bop(Bit,Var("SU",F4),LN 1)), + (EQ(nVar"i",LN 12),Bop(Bit,Var("SU",F4),LN 0)), + (EQ(nVar"i",LN 11),Bop(Bit,Var("SS",F4),LN 3)), + (EQ(nVar"i",LN 10),Bop(Bit,Var("SS",F4),LN 2)), + (EQ(nVar"i",LN 9),Bop(Bit,Var("SS",F4),LN 1)), + (EQ(nVar"i",LN 8),Bop(Bit,Var("SS",F4),LN 0)), + (EQ(nVar"i",LN 7),Bop(Bit,Var("SL",F4),LN 3)), + (EQ(nVar"i",LN 6),Bop(Bit,Var("SL",F4),LN 2)), + (EQ(nVar"i",LN 5),Bop(Bit,Var("SL",F4),LN 1)), + (EQ(nVar"i",LN 4),Bop(Bit,Var("SL",F4),LN 0)), + (EQ(nVar"i",LN 3),Bop(Bit,Var("SA",F4),LN 3)), + (EQ(nVar"i",LN 2),Bop(Bit,Var("SA",F4),LN 2)), + (EQ(nVar"i",LN 1),Bop(Bit,Var("SA",F4),LN 1))], + Bop(Bit,Var("SA",F4),LN 0))),LW(0,32)))])) +; +val write'rec'ConfigRegister2_def = Def + ("write'rec'ConfigRegister2",TP[AVar F32,Var("x",CTy"ConfigRegister2")], + Call("reg'ConfigRegister2",F32,Var("x",CTy"ConfigRegister2"))) +; +val write'reg'ConfigRegister2_def = Def + ("write'reg'ConfigRegister2", + TP[AVar(CTy"ConfigRegister2"),Var("x",F32)], + Call("rec'ConfigRegister2",CTy"ConfigRegister2",Var("x",F32))) +; +val rec'ConfigRegister3_def = Def + ("rec'ConfigRegister3",Var("x",F32), + Rec(CTy"ConfigRegister3", + [Bop(Bit,Var("x",F32),LN 10),Bop(Bit,Var("x",F32),LN 7), + Bop(Bit,Var("x",F32),LN 31),Bop(Bit,Var("x",F32),LN 2), + Bop(Bit,Var("x",F32),LN 1),Bop(Bit,Var("x",F32),LN 4), + Bop(Bit,Var("x",F32),LN 0),Bop(Bit,Var("x",F32),LN 13), + Bop(Bit,Var("x",F32),LN 6),Bop(Bit,Var("x",F32),LN 5), + CC[EX(Var("x",F32),LN 3,LN 3,F1),EX(Var("x",F32),LN 9,LN 8,FTy 2), + EX(Var("x",F32),LN 12,LN 11,FTy 2), + EX(Var("x",F32),LN 30,LN 14,FTy 17)]])) +; +val reg'ConfigRegister3_def = Def + ("reg'ConfigRegister3",Var("x",CTy"ConfigRegister3"), + CS(Var("x",CTy"ConfigRegister3"), + [(Rec(CTy"ConfigRegister3", + [bVar"DSPP",bVar"LPA",bVar"M",bVar"MT",bVar"SM",bVar"SP", + bVar"TL",bVar"ULRI",bVar"VEIC",bVar"VInt", + Var("configregister3'rst",FTy 22)]), + Bop(Mdfy, + Close + (TP[nVar"i",AVar bTy], + ITB([(EQ(nVar"i",LN 31),bVar"M"), + (EQ(nVar"i",LN 30), + Bop(Bit,Var("configregister3'rst",FTy 22),LN 16)), + (EQ(nVar"i",LN 29), + Bop(Bit,Var("configregister3'rst",FTy 22),LN 15)), + (EQ(nVar"i",LN 28), + Bop(Bit,Var("configregister3'rst",FTy 22),LN 14)), + (EQ(nVar"i",LN 27), + Bop(Bit,Var("configregister3'rst",FTy 22),LN 13)), + (EQ(nVar"i",LN 26), + Bop(Bit,Var("configregister3'rst",FTy 22),LN 12)), + (EQ(nVar"i",LN 25), + Bop(Bit,Var("configregister3'rst",FTy 22),LN 11)), + (EQ(nVar"i",LN 24), + Bop(Bit,Var("configregister3'rst",FTy 22),LN 10)), + (EQ(nVar"i",LN 23), + Bop(Bit,Var("configregister3'rst",FTy 22),LN 9)), + (EQ(nVar"i",LN 22), + Bop(Bit,Var("configregister3'rst",FTy 22),LN 8)), + (EQ(nVar"i",LN 21), + Bop(Bit,Var("configregister3'rst",FTy 22),LN 7)), + (EQ(nVar"i",LN 20), + Bop(Bit,Var("configregister3'rst",FTy 22),LN 6)), + (EQ(nVar"i",LN 19), + Bop(Bit,Var("configregister3'rst",FTy 22),LN 5)), + (EQ(nVar"i",LN 18), + Bop(Bit,Var("configregister3'rst",FTy 22),LN 4)), + (EQ(nVar"i",LN 17), + Bop(Bit,Var("configregister3'rst",FTy 22),LN 3)), + (EQ(nVar"i",LN 16), + Bop(Bit,Var("configregister3'rst",FTy 22),LN 2)), + (EQ(nVar"i",LN 15), + Bop(Bit,Var("configregister3'rst",FTy 22),LN 1)), + (EQ(nVar"i",LN 14), + Bop(Bit,Var("configregister3'rst",FTy 22),LN 0)), + (EQ(nVar"i",LN 13),bVar"ULRI"), + (EQ(nVar"i",LN 12), + Bop(Bit,Var("configregister3'rst",FTy 22),LN 18)), + (EQ(nVar"i",LN 11), + Bop(Bit,Var("configregister3'rst",FTy 22),LN 17)), + (EQ(nVar"i",LN 10),bVar"DSPP"), + (EQ(nVar"i",LN 9), + Bop(Bit,Var("configregister3'rst",FTy 22),LN 20)), + (EQ(nVar"i",LN 8), + Bop(Bit,Var("configregister3'rst",FTy 22),LN 19)), + (EQ(nVar"i",LN 7),bVar"LPA"), + (EQ(nVar"i",LN 6),bVar"VEIC"), + (EQ(nVar"i",LN 5),bVar"VInt"), + (EQ(nVar"i",LN 4),bVar"SP"), + (EQ(nVar"i",LN 3), + Bop(Bit,Var("configregister3'rst",FTy 22),LN 21)), + (EQ(nVar"i",LN 2),bVar"MT"), + (EQ(nVar"i",LN 1),bVar"SM")],bVar"TL")),LW(0,32)))])) +; +val write'rec'ConfigRegister3_def = Def + ("write'rec'ConfigRegister3",TP[AVar F32,Var("x",CTy"ConfigRegister3")], + Call("reg'ConfigRegister3",F32,Var("x",CTy"ConfigRegister3"))) +; +val write'reg'ConfigRegister3_def = Def + ("write'reg'ConfigRegister3", + TP[AVar(CTy"ConfigRegister3"),Var("x",F32)], + Call("rec'ConfigRegister3",CTy"ConfigRegister3",Var("x",F32))) +; +val rec'ConfigRegister6_def = Def + ("rec'ConfigRegister6",Var("x",F32), + Rec(CTy"ConfigRegister6", + [Bop(Bit,Var("x",F32),LN 2),EX(Var("x",F32),LN 31,LN 16,F16), + CC[EX(Var("x",F32),LN 1,LN 0,FTy 2), + EX(Var("x",F32),LN 15,LN 3,FTy 13)]])) +; +val reg'ConfigRegister6_def = Def + ("reg'ConfigRegister6",Var("x",CTy"ConfigRegister6"), + CS(Var("x",CTy"ConfigRegister6"), + [(Rec(CTy"ConfigRegister6", + [bVar"LTLB",Var("TLBSize",F16), + Var("configregister6'rst",FTy 15)]), + Bop(Mdfy, + Close + (TP[nVar"i",AVar bTy], + ITB([(EQ(nVar"i",LN 31),Bop(Bit,Var("TLBSize",F16),LN 15)), + (EQ(nVar"i",LN 30),Bop(Bit,Var("TLBSize",F16),LN 14)), + (EQ(nVar"i",LN 29),Bop(Bit,Var("TLBSize",F16),LN 13)), + (EQ(nVar"i",LN 28),Bop(Bit,Var("TLBSize",F16),LN 12)), + (EQ(nVar"i",LN 27),Bop(Bit,Var("TLBSize",F16),LN 11)), + (EQ(nVar"i",LN 26),Bop(Bit,Var("TLBSize",F16),LN 10)), + (EQ(nVar"i",LN 25),Bop(Bit,Var("TLBSize",F16),LN 9)), + (EQ(nVar"i",LN 24),Bop(Bit,Var("TLBSize",F16),LN 8)), + (EQ(nVar"i",LN 23),Bop(Bit,Var("TLBSize",F16),LN 7)), + (EQ(nVar"i",LN 22),Bop(Bit,Var("TLBSize",F16),LN 6)), + (EQ(nVar"i",LN 21),Bop(Bit,Var("TLBSize",F16),LN 5)), + (EQ(nVar"i",LN 20),Bop(Bit,Var("TLBSize",F16),LN 4)), + (EQ(nVar"i",LN 19),Bop(Bit,Var("TLBSize",F16),LN 3)), + (EQ(nVar"i",LN 18),Bop(Bit,Var("TLBSize",F16),LN 2)), + (EQ(nVar"i",LN 17),Bop(Bit,Var("TLBSize",F16),LN 1)), + (EQ(nVar"i",LN 16),Bop(Bit,Var("TLBSize",F16),LN 0)), + (EQ(nVar"i",LN 15), + Bop(Bit,Var("configregister6'rst",FTy 15),LN 12)), + (EQ(nVar"i",LN 14), + Bop(Bit,Var("configregister6'rst",FTy 15),LN 11)), + (EQ(nVar"i",LN 13), + Bop(Bit,Var("configregister6'rst",FTy 15),LN 10)), + (EQ(nVar"i",LN 12), + Bop(Bit,Var("configregister6'rst",FTy 15),LN 9)), + (EQ(nVar"i",LN 11), + Bop(Bit,Var("configregister6'rst",FTy 15),LN 8)), + (EQ(nVar"i",LN 10), + Bop(Bit,Var("configregister6'rst",FTy 15),LN 7)), + (EQ(nVar"i",LN 9), + Bop(Bit,Var("configregister6'rst",FTy 15),LN 6)), + (EQ(nVar"i",LN 8), + Bop(Bit,Var("configregister6'rst",FTy 15),LN 5)), + (EQ(nVar"i",LN 7), + Bop(Bit,Var("configregister6'rst",FTy 15),LN 4)), + (EQ(nVar"i",LN 6), + Bop(Bit,Var("configregister6'rst",FTy 15),LN 3)), + (EQ(nVar"i",LN 5), + Bop(Bit,Var("configregister6'rst",FTy 15),LN 2)), + (EQ(nVar"i",LN 4), + Bop(Bit,Var("configregister6'rst",FTy 15),LN 1)), + (EQ(nVar"i",LN 3), + Bop(Bit,Var("configregister6'rst",FTy 15),LN 0)), + (EQ(nVar"i",LN 2),bVar"LTLB"), + (EQ(nVar"i",LN 1), + Bop(Bit,Var("configregister6'rst",FTy 15),LN 14))], + Bop(Bit,Var("configregister6'rst",FTy 15),LN 13))), + LW(0,32)))])) +; +val write'rec'ConfigRegister6_def = Def + ("write'rec'ConfigRegister6",TP[AVar F32,Var("x",CTy"ConfigRegister6")], + Call("reg'ConfigRegister6",F32,Var("x",CTy"ConfigRegister6"))) +; +val write'reg'ConfigRegister6_def = Def + ("write'reg'ConfigRegister6", + TP[AVar(CTy"ConfigRegister6"),Var("x",F32)], + Call("rec'ConfigRegister6",CTy"ConfigRegister6",Var("x",F32))) +; +val rec'CauseRegister_def = Def + ("rec'CauseRegister",Var("x",F32), + Rec(CTy"CauseRegister", + [Bop(Bit,Var("x",F32),LN 31),EX(Var("x",F32),LN 29,LN 28,FTy 2), + EX(Var("x",F32),LN 6,LN 2,FTy 5),EX(Var("x",F32),LN 15,LN 8,F8), + Bop(Bit,Var("x",F32),LN 30), + CC[EX(Var("x",F32),LN 1,LN 0,FTy 2),EX(Var("x",F32),LN 7,LN 7,F1), + EX(Var("x",F32),LN 27,LN 16,FTy 12)]])) +; +val reg'CauseRegister_def = Def + ("reg'CauseRegister",Var("x",CTy"CauseRegister"), + CS(Var("x",CTy"CauseRegister"), + [(Rec(CTy"CauseRegister", + [bVar"BD",Var("CE",FTy 2),Var("ExcCode",FTy 5),Var("IP",F8), + bVar"TI",Var("causeregister'rst",FTy 15)]), + Bop(Mdfy, + Close + (TP[nVar"i",AVar bTy], + ITB([(EQ(nVar"i",LN 31),bVar"BD"), + (EQ(nVar"i",LN 30),bVar"TI"), + (EQ(nVar"i",LN 29),Bop(Bit,Var("CE",FTy 2),LN 1)), + (EQ(nVar"i",LN 28),Bop(Bit,Var("CE",FTy 2),LN 0)), + (EQ(nVar"i",LN 27), + Bop(Bit,Var("causeregister'rst",FTy 15),LN 11)), + (EQ(nVar"i",LN 26), + Bop(Bit,Var("causeregister'rst",FTy 15),LN 10)), + (EQ(nVar"i",LN 25), + Bop(Bit,Var("causeregister'rst",FTy 15),LN 9)), + (EQ(nVar"i",LN 24), + Bop(Bit,Var("causeregister'rst",FTy 15),LN 8)), + (EQ(nVar"i",LN 23), + Bop(Bit,Var("causeregister'rst",FTy 15),LN 7)), + (EQ(nVar"i",LN 22), + Bop(Bit,Var("causeregister'rst",FTy 15),LN 6)), + (EQ(nVar"i",LN 21), + Bop(Bit,Var("causeregister'rst",FTy 15),LN 5)), + (EQ(nVar"i",LN 20), + Bop(Bit,Var("causeregister'rst",FTy 15),LN 4)), + (EQ(nVar"i",LN 19), + Bop(Bit,Var("causeregister'rst",FTy 15),LN 3)), + (EQ(nVar"i",LN 18), + Bop(Bit,Var("causeregister'rst",FTy 15),LN 2)), + (EQ(nVar"i",LN 17), + Bop(Bit,Var("causeregister'rst",FTy 15),LN 1)), + (EQ(nVar"i",LN 16), + Bop(Bit,Var("causeregister'rst",FTy 15),LN 0)), + (EQ(nVar"i",LN 15),Bop(Bit,Var("IP",F8),LN 7)), + (EQ(nVar"i",LN 14),Bop(Bit,Var("IP",F8),LN 6)), + (EQ(nVar"i",LN 13),Bop(Bit,Var("IP",F8),LN 5)), + (EQ(nVar"i",LN 12),Bop(Bit,Var("IP",F8),LN 4)), + (EQ(nVar"i",LN 11),Bop(Bit,Var("IP",F8),LN 3)), + (EQ(nVar"i",LN 10),Bop(Bit,Var("IP",F8),LN 2)), + (EQ(nVar"i",LN 9),Bop(Bit,Var("IP",F8),LN 1)), + (EQ(nVar"i",LN 8),Bop(Bit,Var("IP",F8),LN 0)), + (EQ(nVar"i",LN 7), + Bop(Bit,Var("causeregister'rst",FTy 15),LN 12)), + (EQ(nVar"i",LN 6),Bop(Bit,Var("ExcCode",FTy 5),LN 4)), + (EQ(nVar"i",LN 5),Bop(Bit,Var("ExcCode",FTy 5),LN 3)), + (EQ(nVar"i",LN 4),Bop(Bit,Var("ExcCode",FTy 5),LN 2)), + (EQ(nVar"i",LN 3),Bop(Bit,Var("ExcCode",FTy 5),LN 1)), + (EQ(nVar"i",LN 2),Bop(Bit,Var("ExcCode",FTy 5),LN 0)), + (EQ(nVar"i",LN 1), + Bop(Bit,Var("causeregister'rst",FTy 15),LN 14))], + Bop(Bit,Var("causeregister'rst",FTy 15),LN 13))), + LW(0,32)))])) +; +val write'rec'CauseRegister_def = Def + ("write'rec'CauseRegister",TP[AVar F32,Var("x",CTy"CauseRegister")], + Call("reg'CauseRegister",F32,Var("x",CTy"CauseRegister"))) +; +val write'reg'CauseRegister_def = Def + ("write'reg'CauseRegister",TP[AVar(CTy"CauseRegister"),Var("x",F32)], + Call("rec'CauseRegister",CTy"CauseRegister",Var("x",F32))) +; +val rec'Context_def = Def + ("rec'Context",Var("x",F64), + Rec(CTy"Context", + [EX(Var("x",F64),LN 22,LN 4,FTy 19), + EX(Var("x",F64),LN 63,LN 23,FTy 41),EX(Var("x",F64),LN 3,LN 0,F4)])) +; +val reg'Context_def = Def + ("reg'Context",Var("x",CTy"Context"), + CS(Var("x",CTy"Context"), + [(Rec(CTy"Context", + [Var("BadVPN2",FTy 19),Var("PTEBase",FTy 41), + Var("context'rst",F4)]), + Bop(Mdfy, + Close + (TP[nVar"i",AVar bTy], + ITB([(EQ(nVar"i",LN 63), + Bop(Bit,Var("PTEBase",FTy 41),LN 40)), + (EQ(nVar"i",LN 62), + Bop(Bit,Var("PTEBase",FTy 41),LN 39)), + (EQ(nVar"i",LN 61), + Bop(Bit,Var("PTEBase",FTy 41),LN 38)), + (EQ(nVar"i",LN 60), + Bop(Bit,Var("PTEBase",FTy 41),LN 37)), + (EQ(nVar"i",LN 59), + Bop(Bit,Var("PTEBase",FTy 41),LN 36)), + (EQ(nVar"i",LN 58), + Bop(Bit,Var("PTEBase",FTy 41),LN 35)), + (EQ(nVar"i",LN 57), + Bop(Bit,Var("PTEBase",FTy 41),LN 34)), + (EQ(nVar"i",LN 56), + Bop(Bit,Var("PTEBase",FTy 41),LN 33)), + (EQ(nVar"i",LN 55), + Bop(Bit,Var("PTEBase",FTy 41),LN 32)), + (EQ(nVar"i",LN 54), + Bop(Bit,Var("PTEBase",FTy 41),LN 31)), + (EQ(nVar"i",LN 53), + Bop(Bit,Var("PTEBase",FTy 41),LN 30)), + (EQ(nVar"i",LN 52), + Bop(Bit,Var("PTEBase",FTy 41),LN 29)), + (EQ(nVar"i",LN 51), + Bop(Bit,Var("PTEBase",FTy 41),LN 28)), + (EQ(nVar"i",LN 50), + Bop(Bit,Var("PTEBase",FTy 41),LN 27)), + (EQ(nVar"i",LN 49), + Bop(Bit,Var("PTEBase",FTy 41),LN 26)), + (EQ(nVar"i",LN 48), + Bop(Bit,Var("PTEBase",FTy 41),LN 25)), + (EQ(nVar"i",LN 47), + Bop(Bit,Var("PTEBase",FTy 41),LN 24)), + (EQ(nVar"i",LN 46), + Bop(Bit,Var("PTEBase",FTy 41),LN 23)), + (EQ(nVar"i",LN 45), + Bop(Bit,Var("PTEBase",FTy 41),LN 22)), + (EQ(nVar"i",LN 44), + Bop(Bit,Var("PTEBase",FTy 41),LN 21)), + (EQ(nVar"i",LN 43), + Bop(Bit,Var("PTEBase",FTy 41),LN 20)), + (EQ(nVar"i",LN 42), + Bop(Bit,Var("PTEBase",FTy 41),LN 19)), + (EQ(nVar"i",LN 41), + Bop(Bit,Var("PTEBase",FTy 41),LN 18)), + (EQ(nVar"i",LN 40), + Bop(Bit,Var("PTEBase",FTy 41),LN 17)), + (EQ(nVar"i",LN 39), + Bop(Bit,Var("PTEBase",FTy 41),LN 16)), + (EQ(nVar"i",LN 38), + Bop(Bit,Var("PTEBase",FTy 41),LN 15)), + (EQ(nVar"i",LN 37), + Bop(Bit,Var("PTEBase",FTy 41),LN 14)), + (EQ(nVar"i",LN 36), + Bop(Bit,Var("PTEBase",FTy 41),LN 13)), + (EQ(nVar"i",LN 35), + Bop(Bit,Var("PTEBase",FTy 41),LN 12)), + (EQ(nVar"i",LN 34), + Bop(Bit,Var("PTEBase",FTy 41),LN 11)), + (EQ(nVar"i",LN 33), + Bop(Bit,Var("PTEBase",FTy 41),LN 10)), + (EQ(nVar"i",LN 32),Bop(Bit,Var("PTEBase",FTy 41),LN 9)), + (EQ(nVar"i",LN 31),Bop(Bit,Var("PTEBase",FTy 41),LN 8)), + (EQ(nVar"i",LN 30),Bop(Bit,Var("PTEBase",FTy 41),LN 7)), + (EQ(nVar"i",LN 29),Bop(Bit,Var("PTEBase",FTy 41),LN 6)), + (EQ(nVar"i",LN 28),Bop(Bit,Var("PTEBase",FTy 41),LN 5)), + (EQ(nVar"i",LN 27),Bop(Bit,Var("PTEBase",FTy 41),LN 4)), + (EQ(nVar"i",LN 26),Bop(Bit,Var("PTEBase",FTy 41),LN 3)), + (EQ(nVar"i",LN 25),Bop(Bit,Var("PTEBase",FTy 41),LN 2)), + (EQ(nVar"i",LN 24),Bop(Bit,Var("PTEBase",FTy 41),LN 1)), + (EQ(nVar"i",LN 23),Bop(Bit,Var("PTEBase",FTy 41),LN 0)), + (EQ(nVar"i",LN 22), + Bop(Bit,Var("BadVPN2",FTy 19),LN 18)), + (EQ(nVar"i",LN 21), + Bop(Bit,Var("BadVPN2",FTy 19),LN 17)), + (EQ(nVar"i",LN 20), + Bop(Bit,Var("BadVPN2",FTy 19),LN 16)), + (EQ(nVar"i",LN 19), + Bop(Bit,Var("BadVPN2",FTy 19),LN 15)), + (EQ(nVar"i",LN 18), + Bop(Bit,Var("BadVPN2",FTy 19),LN 14)), + (EQ(nVar"i",LN 17), + Bop(Bit,Var("BadVPN2",FTy 19),LN 13)), + (EQ(nVar"i",LN 16), + Bop(Bit,Var("BadVPN2",FTy 19),LN 12)), + (EQ(nVar"i",LN 15), + Bop(Bit,Var("BadVPN2",FTy 19),LN 11)), + (EQ(nVar"i",LN 14), + Bop(Bit,Var("BadVPN2",FTy 19),LN 10)), + (EQ(nVar"i",LN 13),Bop(Bit,Var("BadVPN2",FTy 19),LN 9)), + (EQ(nVar"i",LN 12),Bop(Bit,Var("BadVPN2",FTy 19),LN 8)), + (EQ(nVar"i",LN 11),Bop(Bit,Var("BadVPN2",FTy 19),LN 7)), + (EQ(nVar"i",LN 10),Bop(Bit,Var("BadVPN2",FTy 19),LN 6)), + (EQ(nVar"i",LN 9),Bop(Bit,Var("BadVPN2",FTy 19),LN 5)), + (EQ(nVar"i",LN 8),Bop(Bit,Var("BadVPN2",FTy 19),LN 4)), + (EQ(nVar"i",LN 7),Bop(Bit,Var("BadVPN2",FTy 19),LN 3)), + (EQ(nVar"i",LN 6),Bop(Bit,Var("BadVPN2",FTy 19),LN 2)), + (EQ(nVar"i",LN 5),Bop(Bit,Var("BadVPN2",FTy 19),LN 1)), + (EQ(nVar"i",LN 4),Bop(Bit,Var("BadVPN2",FTy 19),LN 0)), + (EQ(nVar"i",LN 3),Bop(Bit,Var("context'rst",F4),LN 3)), + (EQ(nVar"i",LN 2),Bop(Bit,Var("context'rst",F4),LN 2)), + (EQ(nVar"i",LN 1),Bop(Bit,Var("context'rst",F4),LN 1))], + Bop(Bit,Var("context'rst",F4),LN 0))),LW(0,64)))])) +; +val write'rec'Context_def = Def + ("write'rec'Context",TP[AVar F64,Var("x",CTy"Context")], + Call("reg'Context",F64,Var("x",CTy"Context"))) +; +val write'reg'Context_def = Def + ("write'reg'Context",TP[AVar(CTy"Context"),Var("x",F64)], + Call("rec'Context",CTy"Context",Var("x",F64))) +; +val rec'XContext_def = Def + ("rec'XContext",Var("x",F64), + Rec(CTy"XContext", + [EX(Var("x",F64),LN 30,LN 4,FTy 27), + EX(Var("x",F64),LN 63,LN 33,FTy 31), + EX(Var("x",F64),LN 32,LN 31,FTy 2),EX(Var("x",F64),LN 3,LN 0,F4)])) +; +val reg'XContext_def = Def + ("reg'XContext",Var("x",CTy"XContext"), + CS(Var("x",CTy"XContext"), + [(Rec(CTy"XContext", + [Var("BadVPN2",FTy 27),Var("PTEBase",FTy 31),Var("R",FTy 2), + Var("xcontext'rst",F4)]), + Bop(Mdfy, + Close + (TP[nVar"i",AVar bTy], + ITB([(EQ(nVar"i",LN 63), + Bop(Bit,Var("PTEBase",FTy 31),LN 30)), + (EQ(nVar"i",LN 62), + Bop(Bit,Var("PTEBase",FTy 31),LN 29)), + (EQ(nVar"i",LN 61), + Bop(Bit,Var("PTEBase",FTy 31),LN 28)), + (EQ(nVar"i",LN 60), + Bop(Bit,Var("PTEBase",FTy 31),LN 27)), + (EQ(nVar"i",LN 59), + Bop(Bit,Var("PTEBase",FTy 31),LN 26)), + (EQ(nVar"i",LN 58), + Bop(Bit,Var("PTEBase",FTy 31),LN 25)), + (EQ(nVar"i",LN 57), + Bop(Bit,Var("PTEBase",FTy 31),LN 24)), + (EQ(nVar"i",LN 56), + Bop(Bit,Var("PTEBase",FTy 31),LN 23)), + (EQ(nVar"i",LN 55), + Bop(Bit,Var("PTEBase",FTy 31),LN 22)), + (EQ(nVar"i",LN 54), + Bop(Bit,Var("PTEBase",FTy 31),LN 21)), + (EQ(nVar"i",LN 53), + Bop(Bit,Var("PTEBase",FTy 31),LN 20)), + (EQ(nVar"i",LN 52), + Bop(Bit,Var("PTEBase",FTy 31),LN 19)), + (EQ(nVar"i",LN 51), + Bop(Bit,Var("PTEBase",FTy 31),LN 18)), + (EQ(nVar"i",LN 50), + Bop(Bit,Var("PTEBase",FTy 31),LN 17)), + (EQ(nVar"i",LN 49), + Bop(Bit,Var("PTEBase",FTy 31),LN 16)), + (EQ(nVar"i",LN 48), + Bop(Bit,Var("PTEBase",FTy 31),LN 15)), + (EQ(nVar"i",LN 47), + Bop(Bit,Var("PTEBase",FTy 31),LN 14)), + (EQ(nVar"i",LN 46), + Bop(Bit,Var("PTEBase",FTy 31),LN 13)), + (EQ(nVar"i",LN 45), + Bop(Bit,Var("PTEBase",FTy 31),LN 12)), + (EQ(nVar"i",LN 44), + Bop(Bit,Var("PTEBase",FTy 31),LN 11)), + (EQ(nVar"i",LN 43), + Bop(Bit,Var("PTEBase",FTy 31),LN 10)), + (EQ(nVar"i",LN 42),Bop(Bit,Var("PTEBase",FTy 31),LN 9)), + (EQ(nVar"i",LN 41),Bop(Bit,Var("PTEBase",FTy 31),LN 8)), + (EQ(nVar"i",LN 40),Bop(Bit,Var("PTEBase",FTy 31),LN 7)), + (EQ(nVar"i",LN 39),Bop(Bit,Var("PTEBase",FTy 31),LN 6)), + (EQ(nVar"i",LN 38),Bop(Bit,Var("PTEBase",FTy 31),LN 5)), + (EQ(nVar"i",LN 37),Bop(Bit,Var("PTEBase",FTy 31),LN 4)), + (EQ(nVar"i",LN 36),Bop(Bit,Var("PTEBase",FTy 31),LN 3)), + (EQ(nVar"i",LN 35),Bop(Bit,Var("PTEBase",FTy 31),LN 2)), + (EQ(nVar"i",LN 34),Bop(Bit,Var("PTEBase",FTy 31),LN 1)), + (EQ(nVar"i",LN 33),Bop(Bit,Var("PTEBase",FTy 31),LN 0)), + (EQ(nVar"i",LN 32),Bop(Bit,Var("R",FTy 2),LN 1)), + (EQ(nVar"i",LN 31),Bop(Bit,Var("R",FTy 2),LN 0)), + (EQ(nVar"i",LN 30), + Bop(Bit,Var("BadVPN2",FTy 27),LN 26)), + (EQ(nVar"i",LN 29), + Bop(Bit,Var("BadVPN2",FTy 27),LN 25)), + (EQ(nVar"i",LN 28), + Bop(Bit,Var("BadVPN2",FTy 27),LN 24)), + (EQ(nVar"i",LN 27), + Bop(Bit,Var("BadVPN2",FTy 27),LN 23)), + (EQ(nVar"i",LN 26), + Bop(Bit,Var("BadVPN2",FTy 27),LN 22)), + (EQ(nVar"i",LN 25), + Bop(Bit,Var("BadVPN2",FTy 27),LN 21)), + (EQ(nVar"i",LN 24), + Bop(Bit,Var("BadVPN2",FTy 27),LN 20)), + (EQ(nVar"i",LN 23), + Bop(Bit,Var("BadVPN2",FTy 27),LN 19)), + (EQ(nVar"i",LN 22), + Bop(Bit,Var("BadVPN2",FTy 27),LN 18)), + (EQ(nVar"i",LN 21), + Bop(Bit,Var("BadVPN2",FTy 27),LN 17)), + (EQ(nVar"i",LN 20), + Bop(Bit,Var("BadVPN2",FTy 27),LN 16)), + (EQ(nVar"i",LN 19), + Bop(Bit,Var("BadVPN2",FTy 27),LN 15)), + (EQ(nVar"i",LN 18), + Bop(Bit,Var("BadVPN2",FTy 27),LN 14)), + (EQ(nVar"i",LN 17), + Bop(Bit,Var("BadVPN2",FTy 27),LN 13)), + (EQ(nVar"i",LN 16), + Bop(Bit,Var("BadVPN2",FTy 27),LN 12)), + (EQ(nVar"i",LN 15), + Bop(Bit,Var("BadVPN2",FTy 27),LN 11)), + (EQ(nVar"i",LN 14), + Bop(Bit,Var("BadVPN2",FTy 27),LN 10)), + (EQ(nVar"i",LN 13),Bop(Bit,Var("BadVPN2",FTy 27),LN 9)), + (EQ(nVar"i",LN 12),Bop(Bit,Var("BadVPN2",FTy 27),LN 8)), + (EQ(nVar"i",LN 11),Bop(Bit,Var("BadVPN2",FTy 27),LN 7)), + (EQ(nVar"i",LN 10),Bop(Bit,Var("BadVPN2",FTy 27),LN 6)), + (EQ(nVar"i",LN 9),Bop(Bit,Var("BadVPN2",FTy 27),LN 5)), + (EQ(nVar"i",LN 8),Bop(Bit,Var("BadVPN2",FTy 27),LN 4)), + (EQ(nVar"i",LN 7),Bop(Bit,Var("BadVPN2",FTy 27),LN 3)), + (EQ(nVar"i",LN 6),Bop(Bit,Var("BadVPN2",FTy 27),LN 2)), + (EQ(nVar"i",LN 5),Bop(Bit,Var("BadVPN2",FTy 27),LN 1)), + (EQ(nVar"i",LN 4),Bop(Bit,Var("BadVPN2",FTy 27),LN 0)), + (EQ(nVar"i",LN 3),Bop(Bit,Var("xcontext'rst",F4),LN 3)), + (EQ(nVar"i",LN 2),Bop(Bit,Var("xcontext'rst",F4),LN 2)), + (EQ(nVar"i",LN 1),Bop(Bit,Var("xcontext'rst",F4),LN 1))], + Bop(Bit,Var("xcontext'rst",F4),LN 0))),LW(0,64)))])) +; +val write'rec'XContext_def = Def + ("write'rec'XContext",TP[AVar F64,Var("x",CTy"XContext")], + Call("reg'XContext",F64,Var("x",CTy"XContext"))) +; +val write'reg'XContext_def = Def + ("write'reg'XContext",TP[AVar(CTy"XContext"),Var("x",F64)], + Call("rec'XContext",CTy"XContext",Var("x",F64))) +; +val rec'HWREna_def = Def + ("rec'HWREna",Var("x",F32), + Rec(CTy"HWREna", + [Bop(Bit,Var("x",F32),LN 2),Bop(Bit,Var("x",F32),LN 3), + Bop(Bit,Var("x",F32),LN 0),Bop(Bit,Var("x",F32),LN 29), + CC[EX(Var("x",F32),LN 1,LN 1,F1), + EX(Var("x",F32),LN 28,LN 4,FTy 25), + EX(Var("x",F32),LN 31,LN 30,FTy 2)]])) +; +val reg'HWREna_def = Def + ("reg'HWREna",Var("x",CTy"HWREna"), + CS(Var("x",CTy"HWREna"), + [(Rec(CTy"HWREna", + [bVar"CC",bVar"CCRes",bVar"CPUNum",bVar"UL", + Var("hwrena'rst",FTy 28)]), + Bop(Mdfy, + Close + (TP[nVar"i",AVar bTy], + ITB([(EQ(nVar"i",LN 31), + Bop(Bit,Var("hwrena'rst",FTy 28),LN 1)), + (EQ(nVar"i",LN 30), + Bop(Bit,Var("hwrena'rst",FTy 28),LN 0)), + (EQ(nVar"i",LN 29),bVar"UL"), + (EQ(nVar"i",LN 28), + Bop(Bit,Var("hwrena'rst",FTy 28),LN 26)), + (EQ(nVar"i",LN 27), + Bop(Bit,Var("hwrena'rst",FTy 28),LN 25)), + (EQ(nVar"i",LN 26), + Bop(Bit,Var("hwrena'rst",FTy 28),LN 24)), + (EQ(nVar"i",LN 25), + Bop(Bit,Var("hwrena'rst",FTy 28),LN 23)), + (EQ(nVar"i",LN 24), + Bop(Bit,Var("hwrena'rst",FTy 28),LN 22)), + (EQ(nVar"i",LN 23), + Bop(Bit,Var("hwrena'rst",FTy 28),LN 21)), + (EQ(nVar"i",LN 22), + Bop(Bit,Var("hwrena'rst",FTy 28),LN 20)), + (EQ(nVar"i",LN 21), + Bop(Bit,Var("hwrena'rst",FTy 28),LN 19)), + (EQ(nVar"i",LN 20), + Bop(Bit,Var("hwrena'rst",FTy 28),LN 18)), + (EQ(nVar"i",LN 19), + Bop(Bit,Var("hwrena'rst",FTy 28),LN 17)), + (EQ(nVar"i",LN 18), + Bop(Bit,Var("hwrena'rst",FTy 28),LN 16)), + (EQ(nVar"i",LN 17), + Bop(Bit,Var("hwrena'rst",FTy 28),LN 15)), + (EQ(nVar"i",LN 16), + Bop(Bit,Var("hwrena'rst",FTy 28),LN 14)), + (EQ(nVar"i",LN 15), + Bop(Bit,Var("hwrena'rst",FTy 28),LN 13)), + (EQ(nVar"i",LN 14), + Bop(Bit,Var("hwrena'rst",FTy 28),LN 12)), + (EQ(nVar"i",LN 13), + Bop(Bit,Var("hwrena'rst",FTy 28),LN 11)), + (EQ(nVar"i",LN 12), + Bop(Bit,Var("hwrena'rst",FTy 28),LN 10)), + (EQ(nVar"i",LN 11), + Bop(Bit,Var("hwrena'rst",FTy 28),LN 9)), + (EQ(nVar"i",LN 10), + Bop(Bit,Var("hwrena'rst",FTy 28),LN 8)), + (EQ(nVar"i",LN 9), + Bop(Bit,Var("hwrena'rst",FTy 28),LN 7)), + (EQ(nVar"i",LN 8), + Bop(Bit,Var("hwrena'rst",FTy 28),LN 6)), + (EQ(nVar"i",LN 7), + Bop(Bit,Var("hwrena'rst",FTy 28),LN 5)), + (EQ(nVar"i",LN 6), + Bop(Bit,Var("hwrena'rst",FTy 28),LN 4)), + (EQ(nVar"i",LN 5), + Bop(Bit,Var("hwrena'rst",FTy 28),LN 3)), + (EQ(nVar"i",LN 4), + Bop(Bit,Var("hwrena'rst",FTy 28),LN 2)), + (EQ(nVar"i",LN 3),bVar"CCRes"), + (EQ(nVar"i",LN 2),bVar"CC"), + (EQ(nVar"i",LN 1), + Bop(Bit,Var("hwrena'rst",FTy 28),LN 27))], + bVar"CPUNum")),LW(0,32)))])) +; +val write'rec'HWREna_def = Def + ("write'rec'HWREna",TP[AVar F32,Var("x",CTy"HWREna")], + Call("reg'HWREna",F32,Var("x",CTy"HWREna"))) +; +val write'reg'HWREna_def = Def + ("write'reg'HWREna",TP[AVar(CTy"HWREna"),Var("x",F32)], + Call("rec'HWREna",CTy"HWREna",Var("x",F32))) +; +val BYTE_def = Def0 ("BYTE",LW(0,3)) +; +val HALFWORD_def = Def0 ("HALFWORD",LW(1,3)) +; +val WORD_def = Def0 ("WORD",LW(3,3)) +; +val DOUBLEWORD_def = Def0 ("DOUBLEWORD",LW(7,3)) +; +val gpr_def = Def + ("gpr",Var("n",FTy 5), + Close + (qVar"state", + TP[Apply + (Apply + (Dest("c_gpr",ATy(F8,ATy(FTy 5,F64)),qVar"state"), + Dest("procID",F8,qVar"state")),Var("n",FTy 5)),qVar"state"])) +; +val write'gpr_def = Def + ("write'gpr",TP[Var("value",F64),Var("n",FTy 5)], + Close + (qVar"state", + TP[LU, + Let(Var("s",PTy(ATy(FTy 5,F64),qTy)), + TP[Fupd + (Apply + (Dest("c_gpr",ATy(F8,ATy(FTy 5,F64)),qVar"state"), + Dest("procID",F8,qVar"state")),Var("n",FTy 5), + Var("value",F64)),qVar"state"], + Rupd + ("c_gpr", + TP[Mop(Snd,Var("s",PTy(ATy(FTy 5,F64),qTy))), + Fupd + (Dest + ("c_gpr",ATy(F8,ATy(FTy 5,F64)), + Mop(Snd,Var("s",PTy(ATy(FTy 5,F64),qTy)))), + Dest + ("procID",F8, + Mop(Snd,Var("s",PTy(ATy(FTy 5,F64),qTy)))), + Mop(Fst,Var("s",PTy(ATy(FTy 5,F64),qTy))))]))])) +; +val PC_def = Def + ("PC",qVar"state", + TP[Apply + (Dest("c_PC",ATy(F8,F64),qVar"state"), + Dest("procID",F8,qVar"state")),qVar"state"]) +; +val write'PC_def = Def + ("write'PC",Var("value",F64), + Close + (qVar"state", + TP[LU, + Rupd + ("c_PC", + TP[qVar"state", + Fupd + (Dest("c_PC",ATy(F8,F64),qVar"state"), + Dest("procID",F8,qVar"state"),Var("value",F64))])])) +; +val hi_def = Def + ("hi",qVar"state", + TP[Apply + (Dest("c_hi",ATy(F8,OTy F64),qVar"state"), + Dest("procID",F8,qVar"state")),qVar"state"]) +; +val write'hi_def = Def + ("write'hi",Var("value",OTy F64), + Close + (qVar"state", + TP[LU, + Rupd + ("c_hi", + TP[qVar"state", + Fupd + (Dest("c_hi",ATy(F8,OTy F64),qVar"state"), + Dest("procID",F8,qVar"state"),Var("value",OTy F64))])])) +; +val lo_def = Def + ("lo",qVar"state", + TP[Apply + (Dest("c_lo",ATy(F8,OTy F64),qVar"state"), + Dest("procID",F8,qVar"state")),qVar"state"]) +; +val write'lo_def = Def + ("write'lo",Var("value",OTy F64), + Close + (qVar"state", + TP[LU, + Rupd + ("c_lo", + TP[qVar"state", + Fupd + (Dest("c_lo",ATy(F8,OTy F64),qVar"state"), + Dest("procID",F8,qVar"state"),Var("value",OTy F64))])])) +; +val CP0_def = Def + ("CP0",qVar"state", + TP[Apply + (Dest("c_CP0",ATy(F8,CTy"CP0__renamed__"),qVar"state"), + Dest("procID",F8,qVar"state")),qVar"state"]) +; +val write'CP0_def = Def + ("write'CP0",Var("value",CTy"CP0__renamed__"), + Close + (qVar"state", + TP[LU, + Rupd + ("c_CP0", + TP[qVar"state", + Fupd + (Dest("c_CP0",ATy(F8,CTy"CP0__renamed__"),qVar"state"), + Dest("procID",F8,qVar"state"), + Var("value",CTy"CP0__renamed__"))])])) +; +val BranchDelay_def = Def + ("BranchDelay",qVar"state", + TP[Apply + (Dest("c_BranchDelay",ATy(F8,OTy F64),qVar"state"), + Dest("procID",F8,qVar"state")),qVar"state"]) +; +val write'BranchDelay_def = Def + ("write'BranchDelay",Var("value",OTy F64), + Close + (qVar"state", + TP[LU, + Rupd + ("c_BranchDelay", + TP[qVar"state", + Fupd + (Dest("c_BranchDelay",ATy(F8,OTy F64),qVar"state"), + Dest("procID",F8,qVar"state"),Var("value",OTy F64))])])) +; +val BranchTo_def = Def + ("BranchTo",qVar"state", + TP[Apply + (Dest("c_BranchTo",ATy(F8,OTy F64),qVar"state"), + Dest("procID",F8,qVar"state")),qVar"state"]) +; +val write'BranchTo_def = Def + ("write'BranchTo",Var("value",OTy F64), + Close + (qVar"state", + TP[LU, + Rupd + ("c_BranchTo", + TP[qVar"state", + Fupd + (Dest("c_BranchTo",ATy(F8,OTy F64),qVar"state"), + Dest("procID",F8,qVar"state"),Var("value",OTy F64))])])) +; +val LLbit_def = Def + ("LLbit",qVar"state", + TP[Apply + (Dest("c_LLbit",ATy(F8,OTy bTy),qVar"state"), + Dest("procID",F8,qVar"state")),qVar"state"]) +; +val write'LLbit_def = Def + ("write'LLbit",Var("value",OTy bTy), + Close + (qVar"state", + TP[LU, + Rupd + ("c_LLbit", + TP[qVar"state", + Fupd + (Dest("c_LLbit",ATy(F8,OTy bTy),qVar"state"), + Dest("procID",F8,qVar"state"),Var("value",OTy bTy))])])) +; +val exceptionSignalled_def = Def + ("exceptionSignalled",qVar"state", + TP[Apply + (Dest("c_exceptionSignalled",ATy(F8,bTy),qVar"state"), + Dest("procID",F8,qVar"state")),qVar"state"]) +; +val write'exceptionSignalled_def = Def + ("write'exceptionSignalled",bVar"value", + Close + (qVar"state", + TP[LU, + Rupd + ("c_exceptionSignalled", + TP[qVar"state", + Fupd + (Dest("c_exceptionSignalled",ATy(F8,bTy),qVar"state"), + Dest("procID",F8,qVar"state"),bVar"value")])])) +; +val UserMode_def = Def + ("UserMode",qVar"state", + TP[Bop(And, + EQ(Dest + ("KSU",FTy 2, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state")))),LW(2,2)), + Mop(Not, + Bop(Or, + Dest + ("EXL",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state")))), + Dest + ("ERL",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))))),qVar"state"]) +; +val SupervisorMode_def = Def + ("SupervisorMode",qVar"state", + TP[Bop(And, + EQ(Dest + ("KSU",FTy 2, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state")))),LW(1,2)), + Mop(Not, + Bop(Or, + Dest + ("EXL",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state")))), + Dest + ("ERL",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))))),qVar"state"]) +; +val KernelMode_def = Def + ("KernelMode",qVar"state", + TP[Bop(Or, + Bop(Or, + EQ(Dest + ("KSU",FTy 2, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state")))),LW(0,2)), + Dest + ("EXL",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))), + Dest + ("ERL",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))),qVar"state"]) +; +val BigEndianMem_def = Def + ("BigEndianMem",qVar"state", + TP[Dest + ("BE",bTy, + Dest + ("Config",CTy"ConfigRegister", + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state")))),qVar"state"]) +; +val ReverseEndian_def = Def + ("ReverseEndian",qVar"state", + TP[Mop(Cast F1, + Bop(And, + Dest + ("RE",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state")))), + Mop(Fst, + Apply + (Const("UserMode",ATy(qTy,PTy(bTy,qTy))),qVar"state")))), + qVar"state"]) +; +val BigEndianCPU_def = Def + ("BigEndianCPU",qVar"state", + TP[Bop(BXor, + Mop(Cast F1, + Mop(Fst, + Apply + (Const("BigEndianMem",ATy(qTy,PTy(bTy,qTy))), + qVar"state"))), + Mop(Fst, + Apply + (Const("ReverseEndian",ATy(qTy,PTy(F1,qTy))),qVar"state"))), + qVar"state"]) +; +val NotWordValue_def = Def + ("NotWordValue",Var("value",F64), + Let(Var("top",F32),EX(Var("value",F64),LN 63,LN 32,F32), + ITE(Bop(Bit,Var("value",F64),LN 31), + Mop(Not,EQ(Var("top",F32),LW(4294967295,32))), + Mop(Not,EQ(Var("top",F32),LW(0,32)))))) +; +val CheckBranch_def = Def + ("CheckBranch",qVar"state", + ITE(Mop(IsSome, + Mop(Fst, + Apply + (Const("BranchDelay",ATy(qTy,PTy(OTy F64,qTy))), + qVar"state"))), + Apply + (Call + ("raise'exception",ATy(qTy,PTy(uTy,qTy)), + Call + ("UNPREDICTABLE",CTy"exception", + LS"Not permitted in delay slot")),qVar"state"), + TP[LU,qVar"state"])) +; +val cpr_def = Def + ("cpr",Var("r",FTy 5), + CC[LS"c0_", + CS(Var("r",FTy 5), + [(LW(0,5),LS"index"),(LW(1,5),LS"random"),(LW(2,5),LS"entrylo0"), + (LW(3,5),LS"entrylo1"),(LW(4,5),LS"context"), + (LW(5,5),LS"pagemask"),(LW(6,5),LS"wired"),(LW(7,5),LS"hwrena"), + (LW(8,5),LS"badvaddr"),(LW(9,5),LS"count"), + (LW(10,5),LS"entryhi"),(LW(11,5),LS"compare"), + (LW(12,5),LS"status"),(LW(13,5),LS"cause"),(LW(14,5),LS"epc"), + (LW(15,5),LS"prid"),(LW(16,5),LS"config"),(LW(17,5),LS"lladdr"), + (LW(18,5),LS"watchlo"),(LW(19,5),LS"watchhi"), + (LW(20,5),LS"xcontext"),(LW(21,5),LS"21"),(LW(22,5),LS"22"), + (LW(23,5),LS"debug"),(LW(24,5),LS"depc"),(LW(25,5),LS"perfcnt"), + (LW(26,5),LS"errctl"),(LW(27,5),LS"cacheerr"), + (LW(28,5),LS"taglo"),(LW(29,5),LS"taghi"), + (LW(30,5),LS"errorepc"),(LW(31,5),LS"kscratch")])]) +; +val log_sig_exception_def = Def + ("log_sig_exception",Var("ExceptionCode",FTy 5), + CC[LS"Exception 0x", + Mop(PadLeft, + TP[LSC #"0",LN 2,Mop(Cast sTy,Var("ExceptionCode",FTy 5))])]) +; +val log_w_gpr_def = Def + ("log_w_gpr",TP[Var("r",FTy 5),Var("data",F64)], + CC[LS"Reg ",Mop(Cast sTy,Mop(Cast nTy,Var("r",FTy 5))),LS" <- 0x", + Mop(PadLeft,TP[LSC #"0",LN 16,Mop(Cast sTy,Var("data",F64))])]) +; +val log_w_hi_def = Def + ("log_w_hi",Var("data",F64), + CC[LS"HI <- 0x", + Mop(PadLeft,TP[LSC #"0",LN 16,Mop(Cast sTy,Var("data",F64))])]) +; +val log_w_lo_def = Def + ("log_w_lo",Var("data",F64), + CC[LS"LO <- 0x", + Mop(PadLeft,TP[LSC #"0",LN 16,Mop(Cast sTy,Var("data",F64))])]) +; +val log_w_c0_def = Def + ("log_w_c0",TP[Var("r",FTy 5),Var("data",F64)], + CC[Call("cpr",sTy,Var("r",FTy 5)),LS" <- 0x", + Mop(PadLeft,TP[LSC #"0",LN 16,Mop(Cast sTy,Var("data",F64))])]) +; +val log_w_mem_def = Def + ("log_w_mem",TP[Var("addr",FTy 37),Var("mask",F64),Var("data",F64)], + CC[LS"MEM[0x", + Mop(PadLeft,TP[LSC #"0",LN 10,Mop(Cast sTy,Var("addr",FTy 37))]), + LS"] <- (data: 0x", + Mop(PadLeft,TP[LSC #"0",LN 16,Mop(Cast sTy,Var("data",F64))]), + LS", mask: 0x", + Mop(PadLeft,TP[LSC #"0",LN 16,Mop(Cast sTy,Var("mask",F64))]),LS")"]) +; +val log_r_mem_def = Def + ("log_r_mem",TP[Var("addr",FTy 37),Var("data",F64)], + CC[LS"data <- MEM[0x", + Mop(PadLeft,TP[LSC #"0",LN 10,Mop(Cast sTy,Var("addr",FTy 37))]), + LS"]: 0x", + Mop(PadLeft,TP[LSC #"0",LN 16,Mop(Cast sTy,Var("data",F64))])]) +; +val mark_log_def = Def + ("mark_log",TP[nVar"lvl",sVar"s"], + Close + (qVar"state", + TP[LU, + Rupd + ("log", + TP[qVar"state", + Fupd + (Dest("log",ATy(nTy,LTy sTy),qVar"state"),nVar"lvl", + LLC([sVar"s"], + Apply + (Dest("log",ATy(nTy,LTy sTy),qVar"state"), + nVar"lvl")))])])) +; +val unmark_log_def = Def + ("unmark_log",nVar"lvl", + Close + (qVar"state", + TP[LU, + Rupd + ("log", + TP[qVar"state", + Fupd + (Dest("log",ATy(nTy,LTy sTy),qVar"state"),nVar"lvl", + Mop(Tail, + Apply + (Dest("log",ATy(nTy,LTy sTy),qVar"state"), + nVar"lvl")))])])) +; +val clear_logs_def = Def + ("clear_logs",AVar uTy, + Close + (qVar"state", + Apply + (For(TP[LN 0,LN 5, + Close + (nVar"i", + Close + (qVar"state", + TP[LU, + Rupd + ("log", + TP[qVar"state", + Fupd + (Dest("log",ATy(nTy,LTy sTy),qVar"state"), + nVar"i",LNL sTy)])]))]),qVar"state"))) +; +val hex32_def = Def + ("hex32",Var("x",F32), + Mop(PadLeft,TP[LSC #"0",LN 8,Mop(Cast sTy,Var("x",F32))])) +; +val hex64_def = Def + ("hex64",Var("x",F64), + Mop(PadLeft,TP[LSC #"0",LN 16,Mop(Cast sTy,Var("x",F64))])) +; +val rec'PIC_Config_Reg_def = Def + ("rec'PIC_Config_Reg",Var("x",F64), + Rec(CTy"PIC_Config_Reg", + [Bop(Bit,Var("x",F64),LN 31),EX(Var("x",F64),LN 2,LN 0,FTy 3), + CC[EX(Var("x",F64),LN 30,LN 3,FTy 28), + EX(Var("x",F64),LN 63,LN 32,F32)]])) +; +val reg'PIC_Config_Reg_def = Def + ("reg'PIC_Config_Reg",Var("x",CTy"PIC_Config_Reg"), + CS(Var("x",CTy"PIC_Config_Reg"), + [(Rec(CTy"PIC_Config_Reg", + [bVar"EN",Var("IRQ",FTy 3),Var("pic_config_reg'rst",FTy 60)]), + Bop(Mdfy, + Close + (TP[nVar"i",AVar bTy], + ITB([(EQ(nVar"i",LN 63), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 31)), + (EQ(nVar"i",LN 62), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 30)), + (EQ(nVar"i",LN 61), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 29)), + (EQ(nVar"i",LN 60), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 28)), + (EQ(nVar"i",LN 59), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 27)), + (EQ(nVar"i",LN 58), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 26)), + (EQ(nVar"i",LN 57), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 25)), + (EQ(nVar"i",LN 56), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 24)), + (EQ(nVar"i",LN 55), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 23)), + (EQ(nVar"i",LN 54), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 22)), + (EQ(nVar"i",LN 53), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 21)), + (EQ(nVar"i",LN 52), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 20)), + (EQ(nVar"i",LN 51), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 19)), + (EQ(nVar"i",LN 50), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 18)), + (EQ(nVar"i",LN 49), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 17)), + (EQ(nVar"i",LN 48), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 16)), + (EQ(nVar"i",LN 47), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 15)), + (EQ(nVar"i",LN 46), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 14)), + (EQ(nVar"i",LN 45), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 13)), + (EQ(nVar"i",LN 44), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 12)), + (EQ(nVar"i",LN 43), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 11)), + (EQ(nVar"i",LN 42), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 10)), + (EQ(nVar"i",LN 41), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 9)), + (EQ(nVar"i",LN 40), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 8)), + (EQ(nVar"i",LN 39), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 7)), + (EQ(nVar"i",LN 38), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 6)), + (EQ(nVar"i",LN 37), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 5)), + (EQ(nVar"i",LN 36), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 4)), + (EQ(nVar"i",LN 35), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 3)), + (EQ(nVar"i",LN 34), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 2)), + (EQ(nVar"i",LN 33), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 1)), + (EQ(nVar"i",LN 32), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 0)), + (EQ(nVar"i",LN 31),bVar"EN"), + (EQ(nVar"i",LN 30), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 59)), + (EQ(nVar"i",LN 29), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 58)), + (EQ(nVar"i",LN 28), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 57)), + (EQ(nVar"i",LN 27), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 56)), + (EQ(nVar"i",LN 26), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 55)), + (EQ(nVar"i",LN 25), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 54)), + (EQ(nVar"i",LN 24), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 53)), + (EQ(nVar"i",LN 23), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 52)), + (EQ(nVar"i",LN 22), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 51)), + (EQ(nVar"i",LN 21), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 50)), + (EQ(nVar"i",LN 20), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 49)), + (EQ(nVar"i",LN 19), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 48)), + (EQ(nVar"i",LN 18), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 47)), + (EQ(nVar"i",LN 17), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 46)), + (EQ(nVar"i",LN 16), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 45)), + (EQ(nVar"i",LN 15), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 44)), + (EQ(nVar"i",LN 14), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 43)), + (EQ(nVar"i",LN 13), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 42)), + (EQ(nVar"i",LN 12), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 41)), + (EQ(nVar"i",LN 11), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 40)), + (EQ(nVar"i",LN 10), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 39)), + (EQ(nVar"i",LN 9), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 38)), + (EQ(nVar"i",LN 8), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 37)), + (EQ(nVar"i",LN 7), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 36)), + (EQ(nVar"i",LN 6), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 35)), + (EQ(nVar"i",LN 5), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 34)), + (EQ(nVar"i",LN 4), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 33)), + (EQ(nVar"i",LN 3), + Bop(Bit,Var("pic_config_reg'rst",FTy 60),LN 32)), + (EQ(nVar"i",LN 2),Bop(Bit,Var("IRQ",FTy 3),LN 2)), + (EQ(nVar"i",LN 1),Bop(Bit,Var("IRQ",FTy 3),LN 1))], + Bop(Bit,Var("IRQ",FTy 3),LN 0))),LW(0,64)))])) +; +val write'rec'PIC_Config_Reg_def = Def + ("write'rec'PIC_Config_Reg",TP[AVar F64,Var("x",CTy"PIC_Config_Reg")], + Call("reg'PIC_Config_Reg",F64,Var("x",CTy"PIC_Config_Reg"))) +; +val write'reg'PIC_Config_Reg_def = Def + ("write'reg'PIC_Config_Reg",TP[AVar(CTy"PIC_Config_Reg"),Var("x",F64)], + Call("rec'PIC_Config_Reg",CTy"PIC_Config_Reg",Var("x",F64))) +; +val PIC_update_def = Def + ("PIC_update",Var("id",F8), + Close + (qVar"state", + Let(Var("v",FTy 128), + Mop(Cast(FTy 128), + Apply + (Dest("PIC_external_intrs",ATy(F8,F64),qVar"state"), + Var("id",F8))), + TP[LU, + Let(Var("s0",PTy(F8,qTy)),TP[LW(0,8),qVar"state"], + Let(Var("s",PTy(F8,qTy)), + ITE(Bop(Or, + Mop(Not, + EQ(Apply + (Dest + ("PIC_ip_bits",ATy(F8,FTy 128), + Mop(Snd,Var("s0",PTy(F8,qTy)))), + Var("id",F8)),LW(0,128))), + Mop(Not,EQ(Var("v",FTy 128),LW(0,128)))), + Mop(Snd, + Apply + (For(TP[LN 0,LN 127, + Close + (nVar"i", + Close + (Var("state0",PTy(F8,qTy)), + ITE(Bop(Or, + Bop(Bit, + Apply + (Dest + ("PIC_ip_bits", + ATy(F8, + FTy 128), + Mop(Snd, + Var("state0", + PTy(F8, + qTy)))), + Var("id",F8)), + nVar"i"), + Bop(Bit, + Var("v",FTy 128), + nVar"i")), + Let(Var("reg", + CTy"PIC_Config_Reg"), + Apply + (Apply + (Dest + ("PIC_config_regs", + ATy(F8, + ATy(FTy 7, + CTy"PIC_Config_Reg")), + qVar"state"), + Var("id",F8)), + Mop(Cast(FTy 7), + nVar"i")), + Let(nVar"i", + Mop(Cast nTy, + Dest + ("IRQ", + FTy 3, + Var("reg", + CTy"PIC_Config_Reg"))), + TP[LU, + BFI(nVar"i", + nVar"i", + Mop(Cast + F1, + Bop(Or, + Bop(Bit, + Mop(Fst, + Var("state0", + PTy(F8, + qTy))), + Mop(Cast + nTy, + Dest + ("IRQ", + FTy 3, + Var("reg", + CTy"PIC_Config_Reg")))), + Dest + ("EN", + bTy, + Var("reg", + CTy"PIC_Config_Reg")))), + Mop(Fst, + Var("state0", + PTy(F8, + qTy)))), + Mop(Snd, + Var("state0", + PTy(F8, + qTy)))])), + TP[LU, + Var("state0", + PTy(F8,qTy))])))]), + Var("s0",PTy(F8,qTy)))), + Var("s0",PTy(F8,qTy))), + Let(Var("v",CTy"CP0__renamed__"), + Apply + (Dest + ("c_CP0",ATy(F8,CTy"CP0__renamed__"), + Mop(Snd,Var("s",PTy(F8,qTy)))),Var("id",F8)), + Let(Var("x1",CTy"CauseRegister"), + Dest + ("Cause",CTy"CauseRegister", + Var("v",CTy"CP0__renamed__")), + Rupd + ("c_CP0", + TP[Mop(Snd,Var("s",PTy(F8,qTy))), + Fupd + (Dest + ("c_CP0", + ATy(F8,CTy"CP0__renamed__"), + Mop(Snd,Var("s",PTy(F8,qTy)))), + Var("id",F8), + Rupd + ("Cause", + TP[Var("v",CTy"CP0__renamed__"), + Rupd + ("IP", + TP[Var("x1", + CTy"CauseRegister"), + BFI(LN 6,LN 2, + EX(Mop(Fst, + Var("s", + PTy(F8, + qTy))), + LN 4,LN 0,FTy 5), + Dest + ("IP",F8, + Var("x1", + CTy"CauseRegister")))])]))])))))]))) +; +val PIC_initialise_def = Def + ("PIC_initialise",nVar"pic", + Close + (qVar"state", + Let(Var("v",F8),Dest("procID",F8,qVar"state"), + Let(qVar"s", + Rupd + ("PIC_base_address", + TP[qVar"state", + Fupd + (Dest("PIC_base_address",ATy(F8,FTy 37),qVar"state"), + Var("v",F8), + Mop(Cast(FTy 37), + Bop(Lsr,Mop(Cast(FTy 40),nVar"pic"),LN 3)))]), + TP[LU, + Let(Var("s",PTy(ATy(FTy 7,CTy"PIC_Config_Reg"),qTy)), + Mop(Snd, + Apply + (For(TP[LN 0,LN 4, + Close + (nVar"i", + Close + (Var("state", + PTy(ATy(FTy 7, + CTy"PIC_Config_Reg"), + qTy)), + Let(Var("s", + PTy(ATy(FTy 7, + CTy"PIC_Config_Reg"), + qTy)), + Let(Var("x",FTy 7), + Mop(Cast(FTy 7),nVar"i"), + TP[Fupd + (Mop(Fst, + Var("state", + PTy(ATy(FTy 7, + CTy"PIC_Config_Reg"), + qTy))), + Var("x",FTy 7), + Rupd + ("EN", + TP[Apply + (Mop(Fst, + Var("state", + PTy(ATy(FTy 7, + CTy"PIC_Config_Reg"), + qTy))), + Var("x", + FTy 7)), + LT])), + Mop(Snd, + Var("state", + PTy(ATy(FTy 7, + CTy"PIC_Config_Reg"), + qTy)))]), + Let(Var("x",FTy 7), + Mop(Cast(FTy 7),nVar"i"), + TP[LU, + Fupd + (Mop(Fst, + Var("s", + PTy(ATy(FTy 7, + CTy"PIC_Config_Reg"), + qTy))), + Var("x",FTy 7), + Rupd + ("IRQ", + TP[Apply + (Mop(Fst, + Var("s", + PTy(ATy(FTy 7, + CTy"PIC_Config_Reg"), + qTy))), + Var("x", + FTy 7)), + Mop(Cast + (FTy 3), + nVar"i")])), + Mop(Snd, + Var("s", + PTy(ATy(FTy 7, + CTy"PIC_Config_Reg"), + qTy)))]))))]), + Mop(Snd, + Apply + (For(TP[LN 0,LN 127, + Close + (nVar"i", + Close + (Var("state", + PTy(ATy(FTy 7, + CTy"PIC_Config_Reg"), + qTy)), + Let(Var("x",FTy 7), + Mop(Cast(FTy 7), + nVar"i"), + TP[LU, + Fupd + (Mop(Fst, + Var("state", + PTy(ATy(FTy 7, + CTy"PIC_Config_Reg"), + qTy))), + Var("x",FTy 7), + Call + ("write'reg'PIC_Config_Reg", + CTy"PIC_Config_Reg", + TP[Apply + (Mop(Fst, + Var("state", + PTy(ATy(FTy 7, + CTy"PIC_Config_Reg"), + qTy))), + Var("x", + FTy 7)), + LW(0,64)])), + Mop(Snd, + Var("state", + PTy(ATy(FTy 7, + CTy"PIC_Config_Reg"), + qTy)))])))]), + TP[Apply + (Dest + ("PIC_config_regs", + ATy(F8, + ATy(FTy 7, + CTy"PIC_Config_Reg")), + qVar"s"),Var("v",F8)),qVar"s"])))), + Let(Var("s",PTy(ATy(FTy 7,CTy"PIC_Config_Reg"),qTy)), + TP[Mop(Fst, + Var("s", + PTy(ATy(FTy 7,CTy"PIC_Config_Reg"),qTy))), + Rupd + ("PIC_config_regs", + TP[Mop(Snd, + Var("s", + PTy(ATy(FTy 7, + CTy"PIC_Config_Reg"),qTy))), + Fupd + (Dest + ("PIC_config_regs", + ATy(F8, + ATy(FTy 7,CTy"PIC_Config_Reg")), + Mop(Snd, + Var("s", + PTy(ATy(FTy 7, + CTy"PIC_Config_Reg"), + qTy)))),Var("v",F8), + Mop(Fst, + Var("s", + PTy(ATy(FTy 7, + CTy"PIC_Config_Reg"), + qTy))))])], + Let(Var("s", + PTy(ATy(FTy 7,CTy"PIC_Config_Reg"),qTy)), + TP[Mop(Fst, + Var("s", + PTy(ATy(FTy 7,CTy"PIC_Config_Reg"), + qTy))), + Rupd + ("PIC_ip_bits", + TP[Mop(Snd, + Var("s", + PTy(ATy(FTy 7, + CTy"PIC_Config_Reg"), + qTy))), + Fupd + (Dest + ("PIC_ip_bits",ATy(F8,FTy 128), + Mop(Snd, + Var("s", + PTy(ATy(FTy 7, + CTy"PIC_Config_Reg"), + qTy)))), + Var("v",F8),LW(0,128))])], + Let(Var("s", + PTy(ATy(FTy 7,CTy"PIC_Config_Reg"), + qTy)), + TP[Mop(Fst, + Var("s", + PTy(ATy(FTy 7, + CTy"PIC_Config_Reg"), + qTy))), + Rupd + ("PIC_external_intrs", + TP[Mop(Snd, + Var("s", + PTy(ATy(FTy 7, + CTy"PIC_Config_Reg"), + qTy))), + Fupd + (Dest + ("PIC_external_intrs", + ATy(F8,F64), + Mop(Snd, + Var("s", + PTy(ATy(FTy 7, + CTy"PIC_Config_Reg"), + qTy)))), + Var("v",F8),LW(0,64))])], + Mop(Snd, + Apply + (Call + ("PIC_update", + ATy(qTy,PTy(uTy,qTy)), + Var("v",F8)), + Mop(Snd, + Var("s", + PTy(ATy(FTy 7, + CTy"PIC_Config_Reg"), + qTy)))))))))])))) +; +val PIC_load_def = Def + ("PIC_load",TP[Var("id",F8),Var("addr",FTy 37)], + Close + (qVar"state", + Let(Var("v",FTy 37), + Bop(Sub,Var("addr",FTy 37), + Apply + (Dest("PIC_base_address",ATy(F8,FTy 37),qVar"state"), + Var("id",F8))), + Let(TP[Var("r",F64),Var("s1",PTy(F64,qTy))], + Let(Var("s",PTy(F64,qTy)), + ITB([(Bop(Lt,Var("v",FTy 37),LW(128,37)), + TP[Call + ("reg'PIC_Config_Reg",F64, + Apply + (Apply + (Dest + ("PIC_config_regs", + ATy(F8, + ATy(FTy 7,CTy"PIC_Config_Reg")), + qVar"state"),Var("id",F8)), + Mop(Cast(FTy 7),Var("v",FTy 37)))), + qVar"state"]), + (EQ(Var("v",FTy 37),LW(1024,37)), + Let(Var("s0",PTy(F64,qTy)),TP[LX F64,qVar"state"], + TP[Bop(BOr, + EX(Apply + (Dest + ("PIC_ip_bits",ATy(F8,FTy 128), + qVar"state"),Var("id",F8)), + LN 63,LN 0,F64), + Apply + (Dest + ("PIC_external_intrs",ATy(F8,F64), + Mop(Snd,Var("s0",PTy(F64,qTy)))), + Var("id",F8))), + Mop(Snd,Var("s0",PTy(F64,qTy)))]))], + TP[ITE(EQ(Var("v",FTy 37),LW(1025,37)), + EX(Apply + (Dest + ("PIC_ip_bits",ATy(F8,FTy 128), + qVar"state"),Var("id",F8)),LN 127, + LN 64,F64),LX F64),qVar"state"]), + TP[Mop(Fst,Var("s",PTy(F64,qTy))),Var("s",PTy(F64,qTy))]), + TP[Var("r",F64),Mop(Snd,Var("s1",PTy(F64,qTy)))])))) +; +val PIC_store_def = Def + ("PIC_store", + TP[Var("id",F8),Var("addr",FTy 37),Var("mask",F64),Var("data",F64)], + Close + (qVar"state", + Let(Var("v",FTy 37), + Bop(Sub,Var("addr",FTy 37), + Apply + (Dest("PIC_base_address",ATy(F8,FTy 37),qVar"state"), + Var("id",F8))), + Let(Var("v0",ATy(FTy 7,CTy"PIC_Config_Reg")), + Apply + (Dest + ("PIC_config_regs", + ATy(F8,ATy(FTy 7,CTy"PIC_Config_Reg")),qVar"state"), + Var("id",F8)), + TP[LU, + Let(Var("s",PTy(ATy(FTy 7,CTy"PIC_Config_Reg"),qTy)), + ITB([(Bop(Lt,Var("v",FTy 37),LW(128,37)), + Let(Var("x",FTy 7), + Mop(Cast(FTy 7),Var("v",FTy 37)), + Let(Var("s", + PTy(ATy(FTy 7,CTy"PIC_Config_Reg"), + qTy)), + TP[Var("v0", + ATy(FTy 7,CTy"PIC_Config_Reg")), + qVar"state"], + TP[Fupd + (Mop(Fst, + Var("s", + PTy(ATy(FTy 7, + CTy"PIC_Config_Reg"), + qTy))), + Var("x",FTy 7), + Call + ("write'reg'PIC_Config_Reg", + CTy"PIC_Config_Reg", + TP[Apply + (Var("v0", + ATy(FTy 7, + CTy"PIC_Config_Reg")), + Var("x",FTy 7)), + Var("data",F64)])), + Mop(Snd, + Var("s", + PTy(ATy(FTy 7, + CTy"PIC_Config_Reg"), + qTy)))]))), + (Bop(Lt,Var("v",FTy 37),LW(1040,37)), + TP[Var("v0",ATy(FTy 7,CTy"PIC_Config_Reg")), + qVar"state"]), + (EQ(Var("v",FTy 37),LW(1040,37)), + Let(Var("s0", + PTy(ATy(FTy 7,CTy"PIC_Config_Reg"),qTy)), + TP[Var("v0",ATy(FTy 7,CTy"PIC_Config_Reg")), + qVar"state"], + TP[Mop(Fst, + Var("s0", + PTy(ATy(FTy 7, + CTy"PIC_Config_Reg"),qTy))), + Rupd + ("PIC_ip_bits", + TP[Mop(Snd, + Var("s0", + PTy(ATy(FTy 7, + CTy"PIC_Config_Reg"), + qTy))), + Fupd + (Dest + ("PIC_ip_bits", + ATy(F8,FTy 128), + Mop(Snd, + Var("s0", + PTy(ATy(FTy 7, + CTy"PIC_Config_Reg"), + qTy)))), + Var("id",F8), + BFI(LN 63,LN 0, + Bop(BOr, + EX(Apply + (Dest + ("PIC_ip_bits", + ATy(F8,FTy 128), + Mop(Snd, + Var("s0", + PTy(ATy(FTy 7, + CTy"PIC_Config_Reg"), + qTy)))), + Var("id",F8)), + LN 63,LN 0,F64), + Var("data",F64)), + Apply + (Dest + ("PIC_ip_bits", + ATy(F8,FTy 128), + qVar"state"), + Var("id",F8))))])])), + (EQ(Var("v",FTy 37),LW(1041,37)), + Let(Var("s0", + PTy(ATy(FTy 7,CTy"PIC_Config_Reg"),qTy)), + TP[Var("v0",ATy(FTy 7,CTy"PIC_Config_Reg")), + qVar"state"], + TP[Mop(Fst, + Var("s0", + PTy(ATy(FTy 7, + CTy"PIC_Config_Reg"),qTy))), + Rupd + ("PIC_ip_bits", + TP[Mop(Snd, + Var("s0", + PTy(ATy(FTy 7, + CTy"PIC_Config_Reg"), + qTy))), + Fupd + (Dest + ("PIC_ip_bits", + ATy(F8,FTy 128), + Mop(Snd, + Var("s0", + PTy(ATy(FTy 7, + CTy"PIC_Config_Reg"), + qTy)))), + Var("id",F8), + BFI(LN 127,LN 64, + Bop(BOr, + EX(Apply + (Dest + ("PIC_ip_bits", + ATy(F8,FTy 128), + Mop(Snd, + Var("s0", + PTy(ATy(FTy 7, + CTy"PIC_Config_Reg"), + qTy)))), + Var("id",F8)), + LN 127,LN 64,F64), + Var("data",F64)), + Apply + (Dest + ("PIC_ip_bits", + ATy(F8,FTy 128), + qVar"state"), + Var("id",F8))))])])), + (EQ(Var("v",FTy 37),LW(1056,37)), + Let(Var("s0", + PTy(ATy(FTy 7,CTy"PIC_Config_Reg"),qTy)), + TP[Var("v0",ATy(FTy 7,CTy"PIC_Config_Reg")), + qVar"state"], + TP[Mop(Fst, + Var("s0", + PTy(ATy(FTy 7, + CTy"PIC_Config_Reg"),qTy))), + Rupd + ("PIC_ip_bits", + TP[Mop(Snd, + Var("s0", + PTy(ATy(FTy 7, + CTy"PIC_Config_Reg"), + qTy))), + Fupd + (Dest + ("PIC_ip_bits", + ATy(F8,FTy 128), + Mop(Snd, + Var("s0", + PTy(ATy(FTy 7, + CTy"PIC_Config_Reg"), + qTy)))), + Var("id",F8), + BFI(LN 63,LN 0, + Bop(BAnd, + EX(Apply + (Dest + ("PIC_ip_bits", + ATy(F8,FTy 128), + Mop(Snd, + Var("s0", + PTy(ATy(FTy 7, + CTy"PIC_Config_Reg"), + qTy)))), + Var("id",F8)), + LN 63,LN 0,F64), + Mop(BNot, + Var("data",F64))), + Apply + (Dest + ("PIC_ip_bits", + ATy(F8,FTy 128), + qVar"state"), + Var("id",F8))))])])), + (EQ(Var("v",FTy 37),LW(1057,37)), + Let(Var("s0", + PTy(ATy(FTy 7,CTy"PIC_Config_Reg"),qTy)), + TP[Var("v0",ATy(FTy 7,CTy"PIC_Config_Reg")), + qVar"state"], + TP[Mop(Fst, + Var("s0", + PTy(ATy(FTy 7, + CTy"PIC_Config_Reg"),qTy))), + Rupd + ("PIC_ip_bits", + TP[Mop(Snd, + Var("s0", + PTy(ATy(FTy 7, + CTy"PIC_Config_Reg"), + qTy))), + Fupd + (Dest + ("PIC_ip_bits", + ATy(F8,FTy 128), + Mop(Snd, + Var("s0", + PTy(ATy(FTy 7, + CTy"PIC_Config_Reg"), + qTy)))), + Var("id",F8), + BFI(LN 127,LN 64, + Bop(BAnd, + EX(Apply + (Dest + ("PIC_ip_bits", + ATy(F8,FTy 128), + Mop(Snd, + Var("s0", + PTy(ATy(FTy 7, + CTy"PIC_Config_Reg"), + qTy)))), + Var("id",F8)), + LN 127,LN 64,F64), + Mop(BNot, + Var("data",F64))), + Apply + (Dest + ("PIC_ip_bits", + ATy(F8,FTy 128), + qVar"state"), + Var("id",F8))))])]))], + TP[Var("v0",ATy(FTy 7,CTy"PIC_Config_Reg")), + qVar"state"]), + Let(Var("s",PTy(ATy(FTy 7,CTy"PIC_Config_Reg"),qTy)), + TP[Mop(Fst, + Var("s", + PTy(ATy(FTy 7,CTy"PIC_Config_Reg"),qTy))), + Rupd + ("PIC_config_regs", + TP[Mop(Snd, + Var("s", + PTy(ATy(FTy 7, + CTy"PIC_Config_Reg"),qTy))), + Fupd + (Dest + ("PIC_config_regs", + ATy(F8, + ATy(FTy 7,CTy"PIC_Config_Reg")), + Mop(Snd, + Var("s", + PTy(ATy(FTy 7, + CTy"PIC_Config_Reg"), + qTy)))),Var("id",F8), + Mop(Fst, + Var("s", + PTy(ATy(FTy 7, + CTy"PIC_Config_Reg"), + qTy))))])], + Mop(Snd, + Apply + (Call + ("PIC_update",ATy(qTy,PTy(uTy,qTy)), + Var("id",F8)), + Mop(Snd, + Var("s", + PTy(ATy(FTy 7,CTy"PIC_Config_Reg"), + qTy)))))))])))) +; +val rec'JTAG_UART_data_def = Def + ("rec'JTAG_UART_data",Var("x",F32), + Rec(CTy"JTAG_UART_data__renamed__", + [EX(Var("x",F32),LN 31,LN 16,F16),Bop(Bit,Var("x",F32),LN 15), + EX(Var("x",F32),LN 7,LN 0,F8),EX(Var("x",F32),LN 14,LN 8,FTy 7)])) +; +val reg'JTAG_UART_data_def = Def + ("reg'JTAG_UART_data",Var("x",CTy"JTAG_UART_data__renamed__"), + CS(Var("x",CTy"JTAG_UART_data__renamed__"), + [(Rec(CTy"JTAG_UART_data__renamed__", + [Var("RAVAIL",F16),bVar"RVALID",Var("RW_DATA",F8), + Var("jtag_uart_data'rst",FTy 7)]), + Bop(Mdfy, + Close + (TP[nVar"i",AVar bTy], + ITB([(EQ(nVar"i",LN 31),Bop(Bit,Var("RAVAIL",F16),LN 15)), + (EQ(nVar"i",LN 30),Bop(Bit,Var("RAVAIL",F16),LN 14)), + (EQ(nVar"i",LN 29),Bop(Bit,Var("RAVAIL",F16),LN 13)), + (EQ(nVar"i",LN 28),Bop(Bit,Var("RAVAIL",F16),LN 12)), + (EQ(nVar"i",LN 27),Bop(Bit,Var("RAVAIL",F16),LN 11)), + (EQ(nVar"i",LN 26),Bop(Bit,Var("RAVAIL",F16),LN 10)), + (EQ(nVar"i",LN 25),Bop(Bit,Var("RAVAIL",F16),LN 9)), + (EQ(nVar"i",LN 24),Bop(Bit,Var("RAVAIL",F16),LN 8)), + (EQ(nVar"i",LN 23),Bop(Bit,Var("RAVAIL",F16),LN 7)), + (EQ(nVar"i",LN 22),Bop(Bit,Var("RAVAIL",F16),LN 6)), + (EQ(nVar"i",LN 21),Bop(Bit,Var("RAVAIL",F16),LN 5)), + (EQ(nVar"i",LN 20),Bop(Bit,Var("RAVAIL",F16),LN 4)), + (EQ(nVar"i",LN 19),Bop(Bit,Var("RAVAIL",F16),LN 3)), + (EQ(nVar"i",LN 18),Bop(Bit,Var("RAVAIL",F16),LN 2)), + (EQ(nVar"i",LN 17),Bop(Bit,Var("RAVAIL",F16),LN 1)), + (EQ(nVar"i",LN 16),Bop(Bit,Var("RAVAIL",F16),LN 0)), + (EQ(nVar"i",LN 15),bVar"RVALID"), + (EQ(nVar"i",LN 14), + Bop(Bit,Var("jtag_uart_data'rst",FTy 7),LN 6)), + (EQ(nVar"i",LN 13), + Bop(Bit,Var("jtag_uart_data'rst",FTy 7),LN 5)), + (EQ(nVar"i",LN 12), + Bop(Bit,Var("jtag_uart_data'rst",FTy 7),LN 4)), + (EQ(nVar"i",LN 11), + Bop(Bit,Var("jtag_uart_data'rst",FTy 7),LN 3)), + (EQ(nVar"i",LN 10), + Bop(Bit,Var("jtag_uart_data'rst",FTy 7),LN 2)), + (EQ(nVar"i",LN 9), + Bop(Bit,Var("jtag_uart_data'rst",FTy 7),LN 1)), + (EQ(nVar"i",LN 8), + Bop(Bit,Var("jtag_uart_data'rst",FTy 7),LN 0)), + (EQ(nVar"i",LN 7),Bop(Bit,Var("RW_DATA",F8),LN 7)), + (EQ(nVar"i",LN 6),Bop(Bit,Var("RW_DATA",F8),LN 6)), + (EQ(nVar"i",LN 5),Bop(Bit,Var("RW_DATA",F8),LN 5)), + (EQ(nVar"i",LN 4),Bop(Bit,Var("RW_DATA",F8),LN 4)), + (EQ(nVar"i",LN 3),Bop(Bit,Var("RW_DATA",F8),LN 3)), + (EQ(nVar"i",LN 2),Bop(Bit,Var("RW_DATA",F8),LN 2)), + (EQ(nVar"i",LN 1),Bop(Bit,Var("RW_DATA",F8),LN 1))], + Bop(Bit,Var("RW_DATA",F8),LN 0))),LW(0,32)))])) +; +val write'rec'JTAG_UART_data_def = Def + ("write'rec'JTAG_UART_data", + TP[AVar F32,Var("x",CTy"JTAG_UART_data__renamed__")], + Call("reg'JTAG_UART_data",F32,Var("x",CTy"JTAG_UART_data__renamed__"))) +; +val write'reg'JTAG_UART_data_def = Def + ("write'reg'JTAG_UART_data", + TP[AVar(CTy"JTAG_UART_data__renamed__"),Var("x",F32)], + Call("rec'JTAG_UART_data",CTy"JTAG_UART_data__renamed__",Var("x",F32))) +; +val rec'JTAG_UART_control_def = Def + ("rec'JTAG_UART_control",Var("x",F32), + Rec(CTy"JTAG_UART_control__renamed__", + [Bop(Bit,Var("x",F32),LN 10),Bop(Bit,Var("x",F32),LN 0), + Bop(Bit,Var("x",F32),LN 8),Bop(Bit,Var("x",F32),LN 1), + Bop(Bit,Var("x",F32),LN 9),EX(Var("x",F32),LN 31,LN 16,F16), + CC[EX(Var("x",F32),LN 7,LN 2,FTy 6), + EX(Var("x",F32),LN 15,LN 11,FTy 5)]])) +; +val reg'JTAG_UART_control_def = Def + ("reg'JTAG_UART_control",Var("x",CTy"JTAG_UART_control__renamed__"), + CS(Var("x",CTy"JTAG_UART_control__renamed__"), + [(Rec(CTy"JTAG_UART_control__renamed__", + [bVar"AC",bVar"RE",bVar"RI",bVar"WE",bVar"WI", + Var("WSPACE",F16),Var("jtag_uart_control'rst",FTy 11)]), + Bop(Mdfy, + Close + (TP[nVar"i",AVar bTy], + ITB([(EQ(nVar"i",LN 31),Bop(Bit,Var("WSPACE",F16),LN 15)), + (EQ(nVar"i",LN 30),Bop(Bit,Var("WSPACE",F16),LN 14)), + (EQ(nVar"i",LN 29),Bop(Bit,Var("WSPACE",F16),LN 13)), + (EQ(nVar"i",LN 28),Bop(Bit,Var("WSPACE",F16),LN 12)), + (EQ(nVar"i",LN 27),Bop(Bit,Var("WSPACE",F16),LN 11)), + (EQ(nVar"i",LN 26),Bop(Bit,Var("WSPACE",F16),LN 10)), + (EQ(nVar"i",LN 25),Bop(Bit,Var("WSPACE",F16),LN 9)), + (EQ(nVar"i",LN 24),Bop(Bit,Var("WSPACE",F16),LN 8)), + (EQ(nVar"i",LN 23),Bop(Bit,Var("WSPACE",F16),LN 7)), + (EQ(nVar"i",LN 22),Bop(Bit,Var("WSPACE",F16),LN 6)), + (EQ(nVar"i",LN 21),Bop(Bit,Var("WSPACE",F16),LN 5)), + (EQ(nVar"i",LN 20),Bop(Bit,Var("WSPACE",F16),LN 4)), + (EQ(nVar"i",LN 19),Bop(Bit,Var("WSPACE",F16),LN 3)), + (EQ(nVar"i",LN 18),Bop(Bit,Var("WSPACE",F16),LN 2)), + (EQ(nVar"i",LN 17),Bop(Bit,Var("WSPACE",F16),LN 1)), + (EQ(nVar"i",LN 16),Bop(Bit,Var("WSPACE",F16),LN 0)), + (EQ(nVar"i",LN 15), + Bop(Bit,Var("jtag_uart_control'rst",FTy 11),LN 4)), + (EQ(nVar"i",LN 14), + Bop(Bit,Var("jtag_uart_control'rst",FTy 11),LN 3)), + (EQ(nVar"i",LN 13), + Bop(Bit,Var("jtag_uart_control'rst",FTy 11),LN 2)), + (EQ(nVar"i",LN 12), + Bop(Bit,Var("jtag_uart_control'rst",FTy 11),LN 1)), + (EQ(nVar"i",LN 11), + Bop(Bit,Var("jtag_uart_control'rst",FTy 11),LN 0)), + (EQ(nVar"i",LN 10),bVar"AC"), + (EQ(nVar"i",LN 9),bVar"WI"), + (EQ(nVar"i",LN 8),bVar"RI"), + (EQ(nVar"i",LN 7), + Bop(Bit,Var("jtag_uart_control'rst",FTy 11),LN 10)), + (EQ(nVar"i",LN 6), + Bop(Bit,Var("jtag_uart_control'rst",FTy 11),LN 9)), + (EQ(nVar"i",LN 5), + Bop(Bit,Var("jtag_uart_control'rst",FTy 11),LN 8)), + (EQ(nVar"i",LN 4), + Bop(Bit,Var("jtag_uart_control'rst",FTy 11),LN 7)), + (EQ(nVar"i",LN 3), + Bop(Bit,Var("jtag_uart_control'rst",FTy 11),LN 6)), + (EQ(nVar"i",LN 2), + Bop(Bit,Var("jtag_uart_control'rst",FTy 11),LN 5)), + (EQ(nVar"i",LN 1),bVar"WE")],bVar"RE")),LW(0,32)))])) +; +val write'rec'JTAG_UART_control_def = Def + ("write'rec'JTAG_UART_control", + TP[AVar F32,Var("x",CTy"JTAG_UART_control__renamed__")], + Call + ("reg'JTAG_UART_control",F32, + Var("x",CTy"JTAG_UART_control__renamed__"))) +; +val write'reg'JTAG_UART_control_def = Def + ("write'reg'JTAG_UART_control", + TP[AVar(CTy"JTAG_UART_control__renamed__"),Var("x",F32)], + Call + ("rec'JTAG_UART_control",CTy"JTAG_UART_control__renamed__", + Var("x",F32))) +; +val JTAG_UART_update_interrupt_bit_def = Def + ("JTAG_UART_update_interrupt_bit",AVar uTy, + Close + (qVar"state", + Let(bVar"v", + Bop(And, + Dest + ("RE",bTy, + Dest + ("control",CTy"JTAG_UART_control__renamed__", + Dest("JTAG_UART",CTy"JTAG_UART",qVar"state"))), + Dest + ("RVALID",bTy, + Dest + ("data",CTy"JTAG_UART_data__renamed__", + Dest("JTAG_UART",CTy"JTAG_UART",qVar"state")))), + ITE(Mop(Not, + EQ(Dest + ("RI",bTy, + Dest + ("control",CTy"JTAG_UART_control__renamed__", + Dest("JTAG_UART",CTy"JTAG_UART",qVar"state"))), + bVar"v")), + Let(qVar"s", + Rupd + ("JTAG_UART", + TP[qVar"state", + Rupd + ("control", + TP[Dest("JTAG_UART",CTy"JTAG_UART",qVar"state"), + Rupd + ("RI", + TP[Dest + ("control", + CTy"JTAG_UART_control__renamed__", + Dest + ("JTAG_UART",CTy"JTAG_UART", + qVar"state")),bVar"v"])])]), + Apply + (Call("PIC_update",ATy(qTy,PTy(uTy,qTy)),LW(0,8)), + Rupd + ("PIC_external_intrs", + TP[qVar"s", + Fupd + (Dest + ("PIC_external_intrs",ATy(F8,F64),qVar"s"), + LW(0,8), + BFI(LN 0,LN 0,Mop(Cast F1,bVar"v"), + Apply + (Dest + ("PIC_external_intrs",ATy(F8,F64), + qVar"s"),LW(0,8))))]))), + TP[LU,qVar"state"])))) +; +val JTAG_UART_load_def = Def + ("JTAG_UART_load",qVar"state", + Apply + (Call("JTAG_UART_update_interrupt_bit",ATy(qTy,PTy(uTy,qTy)),LU), + CS(Dest + ("read_fifo",LTy F8, + Dest("JTAG_UART",CTy"JTAG_UART",qVar"state")), + [(LNL F8, + Let(qVar"s", + Rupd + ("JTAG_UART", + TP[qVar"state", + Rupd + ("data", + TP[Dest("JTAG_UART",CTy"JTAG_UART",qVar"state"), + Rupd + ("RAVAIL", + TP[Dest + ("data",CTy"JTAG_UART_data__renamed__", + Dest + ("JTAG_UART",CTy"JTAG_UART", + qVar"state")),LW(0,16)])])]), + Rupd + ("JTAG_UART", + TP[qVar"s", + Rupd + ("data", + TP[Dest("JTAG_UART",CTy"JTAG_UART",qVar"s"), + Rupd + ("RVALID", + TP[Dest + ("data",CTy"JTAG_UART_data__renamed__", + Dest + ("JTAG_UART",CTy"JTAG_UART",qVar"s")), + LF])])]))), + (LLC([Var("h",F8)],Var("t",LTy F8)), + Let(qVar"s", + Rupd + ("JTAG_UART", + TP[qVar"state", + Rupd + ("data", + TP[Dest("JTAG_UART",CTy"JTAG_UART",qVar"state"), + Rupd + ("RW_DATA", + TP[Dest + ("data",CTy"JTAG_UART_data__renamed__", + Dest + ("JTAG_UART",CTy"JTAG_UART", + qVar"state")),Var("h",F8)])])]), + Let(qVar"s", + Rupd + ("JTAG_UART", + TP[qVar"s", + Rupd + ("data", + TP[Dest("JTAG_UART",CTy"JTAG_UART",qVar"s"), + Rupd + ("RAVAIL", + TP[Dest + ("data", + CTy"JTAG_UART_data__renamed__", + Dest + ("JTAG_UART",CTy"JTAG_UART", + qVar"s")), + Mop(Cast F16, + Mop(Length,Var("t",LTy F8)))])])]), + Let(qVar"s", + Rupd + ("JTAG_UART", + TP[qVar"s", + Rupd + ("data", + TP[Dest + ("JTAG_UART",CTy"JTAG_UART",qVar"s"), + Rupd + ("RVALID", + TP[Dest + ("data", + CTy"JTAG_UART_data__renamed__", + Dest + ("JTAG_UART",CTy"JTAG_UART", + qVar"s")),LT])])]), + Rupd + ("JTAG_UART", + TP[qVar"s", + Rupd + ("read_fifo", + TP[Dest + ("JTAG_UART",CTy"JTAG_UART",qVar"s"), + Var("t",LTy F8)])])))))]))) +; +val JTAG_UART_input_def = Def + ("JTAG_UART_input",Var("l",LTy F8), + Close + (qVar"state", + Apply + (Call("JTAG_UART_update_interrupt_bit",ATy(qTy,PTy(uTy,qTy)),LU), + CS(CC[Dest + ("read_fifo",LTy F8, + Dest("JTAG_UART",CTy"JTAG_UART",qVar"state")), + Var("l",LTy F8)], + [(LNL F8, + Rupd + ("JTAG_UART", + TP[qVar"state", + Rupd + ("data", + TP[Dest("JTAG_UART",CTy"JTAG_UART",qVar"state"), + Rupd + ("RAVAIL", + TP[Dest + ("data",CTy"JTAG_UART_data__renamed__", + Dest + ("JTAG_UART",CTy"JTAG_UART", + qVar"state")),LW(0,16)])])])), + (Var("t",LTy F8), + Let(qVar"s", + Rupd + ("JTAG_UART", + TP[qVar"state", + Rupd + ("read_fifo", + TP[Dest("JTAG_UART",CTy"JTAG_UART",qVar"state"), + Var("t",LTy F8)])]), + Let(qVar"s", + Rupd + ("JTAG_UART", + TP[qVar"s", + Rupd + ("data", + TP[Dest("JTAG_UART",CTy"JTAG_UART",qVar"s"), + Rupd + ("RAVAIL", + TP[Dest + ("data", + CTy"JTAG_UART_data__renamed__", + Dest + ("JTAG_UART",CTy"JTAG_UART", + qVar"s")), + Mop(Cast F16, + Mop(Length,Var("t",LTy F8)))])])]), + Let(qVar"s", + Rupd + ("JTAG_UART", + TP[qVar"s", + Rupd + ("control", + TP[Dest + ("JTAG_UART",CTy"JTAG_UART", + qVar"s"), + Rupd + ("AC", + TP[Dest + ("control", + CTy"JTAG_UART_control__renamed__", + Dest + ("JTAG_UART", + CTy"JTAG_UART",qVar"s")), + LT])])]), + ITE(Mop(Not, + Dest + ("RVALID",bTy, + Dest + ("data", + CTy"JTAG_UART_data__renamed__", + Dest + ("JTAG_UART",CTy"JTAG_UART", + qVar"s")))), + Mop(Snd, + Apply + (Const + ("JTAG_UART_load", + ATy(qTy,PTy(uTy,qTy))),qVar"s")), + qVar"s")))))])))) +; +val JTAG_UART_store_def = Def + ("JTAG_UART_store",TP[Var("mask",F64),Var("MemElem",F64)], + Close + (qVar"state", + Let(qVar"s", + ITE(Bop(And, + Mop(Not,EQ(EX(Var("mask",F64),LN 63,LN 56,F8),LW(0,8))), + Mop(Not, + EQ(Dest + ("WSPACE",F16, + Dest + ("control", + CTy"JTAG_UART_control__renamed__", + Dest + ("JTAG_UART",CTy"JTAG_UART",qVar"state"))), + LW(0,16)))), + Let(qVar"s", + Rupd + ("JTAG_UART", + TP[qVar"state", + Rupd + ("control", + TP[Dest("JTAG_UART",CTy"JTAG_UART",qVar"state"), + Rupd + ("WSPACE", + TP[Dest + ("control", + CTy"JTAG_UART_control__renamed__", + Dest + ("JTAG_UART",CTy"JTAG_UART", + qVar"state")), + Bop(Sub, + Dest + ("WSPACE",F16, + Dest + ("control", + CTy"JTAG_UART_control__renamed__", + Dest + ("JTAG_UART", + CTy"JTAG_UART", + qVar"state"))),LW(1,16))])])]), + Rupd + ("JTAG_UART", + TP[qVar"s", + Rupd + ("write_fifo", + TP[Dest("JTAG_UART",CTy"JTAG_UART",qVar"s"), + LLC([EX(Var("MemElem",F64),LN 63,LN 56,F8)], + Dest + ("write_fifo",LTy F8, + Dest + ("JTAG_UART",CTy"JTAG_UART",qVar"s")))])])), + qVar"state"), + Let(qVar"s", + ITE(Bop(Bit,Var("mask",F64),LN 24), + Rupd + ("JTAG_UART", + TP[qVar"s", + Rupd + ("control", + TP[Dest("JTAG_UART",CTy"JTAG_UART",qVar"s"), + Rupd + ("RE", + TP[Dest + ("control", + CTy"JTAG_UART_control__renamed__", + Dest + ("JTAG_UART",CTy"JTAG_UART", + qVar"s")), + Bop(Bit,Var("MemElem",F64),LN 24)])])]), + qVar"s"), + Let(qVar"s", + ITE(Bop(Bit,Var("mask",F64),LN 25), + Rupd + ("JTAG_UART", + TP[qVar"s", + Rupd + ("control", + TP[Dest("JTAG_UART",CTy"JTAG_UART",qVar"s"), + Rupd + ("WE", + TP[Dest + ("control", + CTy"JTAG_UART_control__renamed__", + Dest + ("JTAG_UART",CTy"JTAG_UART", + qVar"s")), + Bop(Bit,Var("MemElem",F64),LN 25)])])]), + qVar"s"), + Apply + (Call + ("JTAG_UART_update_interrupt_bit", + ATy(qTy,PTy(uTy,qTy)),LU), + ITE(Bop(And,Bop(Bit,Var("mask",F64),LN 18), + Bop(Bit,Var("MemElem",F64),LN 18)), + Rupd + ("JTAG_UART", + TP[qVar"s", + Rupd + ("control", + TP[Dest + ("JTAG_UART",CTy"JTAG_UART",qVar"s"), + Rupd + ("AC", + TP[Dest + ("control", + CTy"JTAG_UART_control__renamed__", + Dest + ("JTAG_UART", + CTy"JTAG_UART",qVar"s")), + LF])])]),qVar"s"))))))) +; +val JTAG_UART_output_def = Def + ("JTAG_UART_output",qVar"state", + Let(qVar"s", + Rupd + ("JTAG_UART", + TP[qVar"state", + Rupd + ("control", + TP[Dest("JTAG_UART",CTy"JTAG_UART",qVar"state"), + Rupd + ("AC", + TP[Dest + ("control",CTy"JTAG_UART_control__renamed__", + Dest("JTAG_UART",CTy"JTAG_UART",qVar"state")), + LT])])]), + Let(qVar"s0", + Rupd + ("JTAG_UART", + TP[qVar"s", + Rupd + ("write_fifo", + TP[Dest("JTAG_UART",CTy"JTAG_UART",qVar"s"),LNL F8])]), + Let(qVar"s0", + Rupd + ("JTAG_UART", + TP[qVar"s0", + Rupd + ("control", + TP[Dest("JTAG_UART",CTy"JTAG_UART",qVar"s0"), + Rupd + ("WSPACE", + TP[Dest + ("control", + CTy"JTAG_UART_control__renamed__", + Dest + ("JTAG_UART",CTy"JTAG_UART",qVar"s0")), + Mop(Neg,LW(1,16))])])]), + TP[Mop(Rev, + Dest + ("write_fifo",LTy F8, + Dest("JTAG_UART",CTy"JTAG_UART",qVar"s"))), + Mop(Snd, + Apply + (Call + ("JTAG_UART_update_interrupt_bit", + ATy(qTy,PTy(uTy,qTy)),LU), + Rupd + ("JTAG_UART", + TP[qVar"s0", + Rupd + ("control", + TP[Dest + ("JTAG_UART",CTy"JTAG_UART", + qVar"s0"), + Rupd + ("WI", + TP[Dest + ("control", + CTy"JTAG_UART_control__renamed__", + Dest + ("JTAG_UART", + CTy"JTAG_UART",qVar"s0")), + LF])])])))])))) +; +val JTAG_UART_initialise_def = Def + ("JTAG_UART_initialise",nVar"uart", + Close + (qVar"state", + Let(qVar"s", + Rupd + ("JTAG_UART", + TP[qVar"state", + Rupd + ("base_address", + TP[Dest("JTAG_UART",CTy"JTAG_UART",qVar"state"), + Mop(Cast(FTy 37), + Bop(Lsr,Mop(Cast(FTy 40),nVar"uart"),LN 3))])]), + Let(qVar"s", + Rupd + ("JTAG_UART", + TP[qVar"s", + Rupd + ("read_threshold", + TP[Dest("JTAG_UART",CTy"JTAG_UART",qVar"s"), + LN 65280])]), + Let(qVar"s", + Rupd + ("JTAG_UART", + TP[qVar"s", + Rupd + ("write_threshold", + TP[Dest("JTAG_UART",CTy"JTAG_UART",qVar"s"), + LN 65520])]), + Let(qVar"s", + Rupd + ("JTAG_UART", + TP[qVar"s", + Rupd + ("read_fifo", + TP[Dest("JTAG_UART",CTy"JTAG_UART",qVar"s"), + LNL F8])]), + Let(qVar"s", + Rupd + ("JTAG_UART", + TP[qVar"s", + Rupd + ("write_fifo", + TP[Dest + ("JTAG_UART",CTy"JTAG_UART", + qVar"s"),LNL F8])]), + Let(qVar"s", + Rupd + ("JTAG_UART", + TP[qVar"s", + Rupd + ("data", + TP[Dest + ("JTAG_UART",CTy"JTAG_UART", + qVar"s"), + Rupd + ("RW_DATA", + TP[Dest + ("data", + CTy"JTAG_UART_data__renamed__", + Dest + ("JTAG_UART", + CTy"JTAG_UART", + qVar"s")),LW(0,8)])])]), + Let(qVar"s", + Rupd + ("JTAG_UART", + TP[qVar"s", + Rupd + ("data", + TP[Dest + ("JTAG_UART", + CTy"JTAG_UART",qVar"s"), + Rupd + ("RVALID", + TP[Dest + ("data", + CTy"JTAG_UART_data__renamed__", + Dest + ("JTAG_UART", + CTy"JTAG_UART", + qVar"s")),LF])])]), + Let(qVar"s", + Rupd + ("JTAG_UART", + TP[qVar"s", + Rupd + ("data", + TP[Dest + ("JTAG_UART", + CTy"JTAG_UART", + qVar"s"), + Rupd + ("RAVAIL", + TP[Dest + ("data", + CTy"JTAG_UART_data__renamed__", + Dest + ("JTAG_UART", + CTy"JTAG_UART", + qVar"s")), + LW(0,16)])])]), + Let(qVar"s", + Rupd + ("JTAG_UART", + TP[qVar"s", + Rupd + ("control", + TP[Dest + ("JTAG_UART", + CTy"JTAG_UART", + qVar"s"), + Rupd + ("RE", + TP[Dest + ("control", + CTy"JTAG_UART_control__renamed__", + Dest + ("JTAG_UART", + CTy"JTAG_UART", + qVar"s")), + LT])])]), + Let(qVar"s", + Rupd + ("JTAG_UART", + TP[qVar"s", + Rupd + ("control", + TP[Dest + ("JTAG_UART", + CTy"JTAG_UART", + qVar"s"), + Rupd + ("WE", + TP[Dest + ("control", + CTy"JTAG_UART_control__renamed__", + Dest + ("JTAG_UART", + CTy"JTAG_UART", + qVar"s")), + LF])])]), + Let(qVar"s", + Rupd + ("JTAG_UART", + TP[qVar"s", + Rupd + ("control", + TP[Dest + ("JTAG_UART", + CTy"JTAG_UART", + qVar"s"), + Rupd + ("RI", + TP[Dest + ("control", + CTy"JTAG_UART_control__renamed__", + Dest + ("JTAG_UART", + CTy"JTAG_UART", + qVar"s")), + LF])])]), + Let(qVar"s", + Rupd + ("JTAG_UART", + TP[qVar"s", + Rupd + ("control", + TP[Dest + ("JTAG_UART", + CTy"JTAG_UART", + qVar"s"), + Rupd + ("WI", + TP[Dest + ("control", + CTy"JTAG_UART_control__renamed__", + Dest + ("JTAG_UART", + CTy"JTAG_UART", + qVar"s")), + LF])])]), + Let(qVar"s", + Rupd + ("JTAG_UART", + TP[qVar"s", + Rupd + ("control", + TP[Dest + ("JTAG_UART", + CTy"JTAG_UART", + qVar"s"), + Rupd + ("AC", + TP[Dest + ("control", + CTy"JTAG_UART_control__renamed__", + Dest + ("JTAG_UART", + CTy"JTAG_UART", + qVar"s")), + LF])])]), + TP[LU, + Rupd + ("JTAG_UART", + TP[qVar"s", + Rupd + ("control", + TP[Dest + ("JTAG_UART", + CTy"JTAG_UART", + qVar"s"), + Rupd + ("WSPACE", + TP[Dest + ("control", + CTy"JTAG_UART_control__renamed__", + Dest + ("JTAG_UART", + CTy"JTAG_UART", + qVar"s")), + Mop(Neg, + LW(1, + 16))])])])]))))))))))))))) +; +val rec'Perms_def = Def + ("rec'Perms",Var("x",FTy 31), + Rec(CTy"Perms", + [Bop(Bit,Var("x",FTy 31),LN 10),Bop(Bit,Var("x",FTy 31),LN 12), + Bop(Bit,Var("x",FTy 31),LN 11),Bop(Bit,Var("x",FTy 31),LN 13), + Bop(Bit,Var("x",FTy 31),LN 14),Bop(Bit,Var("x",FTy 31),LN 0), + Bop(Bit,Var("x",FTy 31),LN 1),Bop(Bit,Var("x",FTy 31),LN 2), + Bop(Bit,Var("x",FTy 31),LN 4),Bop(Bit,Var("x",FTy 31),LN 7), + Bop(Bit,Var("x",FTy 31),LN 8),Bop(Bit,Var("x",FTy 31),LN 3), + Bop(Bit,Var("x",FTy 31),LN 5),Bop(Bit,Var("x",FTy 31),LN 6), + Bop(Bit,Var("x",FTy 31),LN 9),EX(Var("x",FTy 31),LN 30,LN 15,F16)])) +; +val reg'Perms_def = Def + ("reg'Perms",Var("x",CTy"Perms"), + CS(Var("x",CTy"Perms"), + [(Rec(CTy"Perms", + [bVar"Access_EPCC",bVar"Access_KCC",bVar"Access_KDC", + bVar"Access_KR1C",bVar"Access_KR2C",bVar"Global", + bVar"Permit_Execute",bVar"Permit_Load", + bVar"Permit_Load_Capability",bVar"Permit_Seal", + bVar"Permit_Set_Type",bVar"Permit_Store", + bVar"Permit_Store_Capability", + bVar"Permit_Store_Local_Capability",bVar"Reserved", + Var("soft",F16)]), + Bop(Mdfy, + Close + (TP[nVar"i",AVar bTy], + ITB([(EQ(nVar"i",LN 30),Bop(Bit,Var("soft",F16),LN 15)), + (EQ(nVar"i",LN 29),Bop(Bit,Var("soft",F16),LN 14)), + (EQ(nVar"i",LN 28),Bop(Bit,Var("soft",F16),LN 13)), + (EQ(nVar"i",LN 27),Bop(Bit,Var("soft",F16),LN 12)), + (EQ(nVar"i",LN 26),Bop(Bit,Var("soft",F16),LN 11)), + (EQ(nVar"i",LN 25),Bop(Bit,Var("soft",F16),LN 10)), + (EQ(nVar"i",LN 24),Bop(Bit,Var("soft",F16),LN 9)), + (EQ(nVar"i",LN 23),Bop(Bit,Var("soft",F16),LN 8)), + (EQ(nVar"i",LN 22),Bop(Bit,Var("soft",F16),LN 7)), + (EQ(nVar"i",LN 21),Bop(Bit,Var("soft",F16),LN 6)), + (EQ(nVar"i",LN 20),Bop(Bit,Var("soft",F16),LN 5)), + (EQ(nVar"i",LN 19),Bop(Bit,Var("soft",F16),LN 4)), + (EQ(nVar"i",LN 18),Bop(Bit,Var("soft",F16),LN 3)), + (EQ(nVar"i",LN 17),Bop(Bit,Var("soft",F16),LN 2)), + (EQ(nVar"i",LN 16),Bop(Bit,Var("soft",F16),LN 1)), + (EQ(nVar"i",LN 15),Bop(Bit,Var("soft",F16),LN 0)), + (EQ(nVar"i",LN 14),bVar"Access_KR2C"), + (EQ(nVar"i",LN 13),bVar"Access_KR1C"), + (EQ(nVar"i",LN 12),bVar"Access_KCC"), + (EQ(nVar"i",LN 11),bVar"Access_KDC"), + (EQ(nVar"i",LN 10),bVar"Access_EPCC"), + (EQ(nVar"i",LN 9),bVar"Reserved"), + (EQ(nVar"i",LN 8),bVar"Permit_Set_Type"), + (EQ(nVar"i",LN 7),bVar"Permit_Seal"), + (EQ(nVar"i",LN 6),bVar"Permit_Store_Local_Capability"), + (EQ(nVar"i",LN 5),bVar"Permit_Store_Capability"), + (EQ(nVar"i",LN 4),bVar"Permit_Load_Capability"), + (EQ(nVar"i",LN 3),bVar"Permit_Store"), + (EQ(nVar"i",LN 2),bVar"Permit_Load"), + (EQ(nVar"i",LN 1),bVar"Permit_Execute")],bVar"Global")), + LW(0,31)))])) +; +val write'rec'Perms_def = Def + ("write'rec'Perms",TP[AVar(FTy 31),Var("x",CTy"Perms")], + Call("reg'Perms",FTy 31,Var("x",CTy"Perms"))) +; +val write'reg'Perms_def = Def + ("write'reg'Perms",TP[AVar(CTy"Perms"),Var("x",FTy 31)], + Call("rec'Perms",CTy"Perms",Var("x",FTy 31))) +; +val rec'Capability_def = Def + ("rec'Capability",Var("x",FTy 257), + Rec(CTy"Capability", + [EX(Var("x",FTy 257),LN 127,LN 64,F64), + EX(Var("x",FTy 257),LN 63,LN 0,F64), + EX(Var("x",FTy 257),LN 191,LN 128,F64), + EX(Var("x",FTy 257),LN 247,LN 224,FTy 24), + EX(Var("x",FTy 257),LN 223,LN 193,FTy 31), + EX(Var("x",FTy 257),LN 255,LN 248,F8), + Bop(Bit,Var("x",FTy 257),LN 192),Bop(Bit,Var("x",FTy 257),LN 256)])) +; +val reg'Capability_def = Def + ("reg'Capability",Var("x",CTy"Capability"), + CS(Var("x",CTy"Capability"), + [(Rec(CTy"Capability", + [Var("base",F64),Var("length",F64),Var("offset",F64), + Var("otype",FTy 24),Var("perms",FTy 31),Var("reserved",F8), + bVar"sealed",bVar"tag"]), + Bop(Mdfy, + Close + (TP[nVar"i",AVar bTy], + ITB([(EQ(nVar"i",LN 256),bVar"tag"), + (EQ(nVar"i",LN 255),Bop(Bit,Var("reserved",F8),LN 7)), + (EQ(nVar"i",LN 254),Bop(Bit,Var("reserved",F8),LN 6)), + (EQ(nVar"i",LN 253),Bop(Bit,Var("reserved",F8),LN 5)), + (EQ(nVar"i",LN 252),Bop(Bit,Var("reserved",F8),LN 4)), + (EQ(nVar"i",LN 251),Bop(Bit,Var("reserved",F8),LN 3)), + (EQ(nVar"i",LN 250),Bop(Bit,Var("reserved",F8),LN 2)), + (EQ(nVar"i",LN 249),Bop(Bit,Var("reserved",F8),LN 1)), + (EQ(nVar"i",LN 248),Bop(Bit,Var("reserved",F8),LN 0)), + (EQ(nVar"i",LN 247),Bop(Bit,Var("otype",FTy 24),LN 23)), + (EQ(nVar"i",LN 246),Bop(Bit,Var("otype",FTy 24),LN 22)), + (EQ(nVar"i",LN 245),Bop(Bit,Var("otype",FTy 24),LN 21)), + (EQ(nVar"i",LN 244),Bop(Bit,Var("otype",FTy 24),LN 20)), + (EQ(nVar"i",LN 243),Bop(Bit,Var("otype",FTy 24),LN 19)), + (EQ(nVar"i",LN 242),Bop(Bit,Var("otype",FTy 24),LN 18)), + (EQ(nVar"i",LN 241),Bop(Bit,Var("otype",FTy 24),LN 17)), + (EQ(nVar"i",LN 240),Bop(Bit,Var("otype",FTy 24),LN 16)), + (EQ(nVar"i",LN 239),Bop(Bit,Var("otype",FTy 24),LN 15)), + (EQ(nVar"i",LN 238),Bop(Bit,Var("otype",FTy 24),LN 14)), + (EQ(nVar"i",LN 237),Bop(Bit,Var("otype",FTy 24),LN 13)), + (EQ(nVar"i",LN 236),Bop(Bit,Var("otype",FTy 24),LN 12)), + (EQ(nVar"i",LN 235),Bop(Bit,Var("otype",FTy 24),LN 11)), + (EQ(nVar"i",LN 234),Bop(Bit,Var("otype",FTy 24),LN 10)), + (EQ(nVar"i",LN 233),Bop(Bit,Var("otype",FTy 24),LN 9)), + (EQ(nVar"i",LN 232),Bop(Bit,Var("otype",FTy 24),LN 8)), + (EQ(nVar"i",LN 231),Bop(Bit,Var("otype",FTy 24),LN 7)), + (EQ(nVar"i",LN 230),Bop(Bit,Var("otype",FTy 24),LN 6)), + (EQ(nVar"i",LN 229),Bop(Bit,Var("otype",FTy 24),LN 5)), + (EQ(nVar"i",LN 228),Bop(Bit,Var("otype",FTy 24),LN 4)), + (EQ(nVar"i",LN 227),Bop(Bit,Var("otype",FTy 24),LN 3)), + (EQ(nVar"i",LN 226),Bop(Bit,Var("otype",FTy 24),LN 2)), + (EQ(nVar"i",LN 225),Bop(Bit,Var("otype",FTy 24),LN 1)), + (EQ(nVar"i",LN 224),Bop(Bit,Var("otype",FTy 24),LN 0)), + (EQ(nVar"i",LN 223),Bop(Bit,Var("perms",FTy 31),LN 30)), + (EQ(nVar"i",LN 222),Bop(Bit,Var("perms",FTy 31),LN 29)), + (EQ(nVar"i",LN 221),Bop(Bit,Var("perms",FTy 31),LN 28)), + (EQ(nVar"i",LN 220),Bop(Bit,Var("perms",FTy 31),LN 27)), + (EQ(nVar"i",LN 219),Bop(Bit,Var("perms",FTy 31),LN 26)), + (EQ(nVar"i",LN 218),Bop(Bit,Var("perms",FTy 31),LN 25)), + (EQ(nVar"i",LN 217),Bop(Bit,Var("perms",FTy 31),LN 24)), + (EQ(nVar"i",LN 216),Bop(Bit,Var("perms",FTy 31),LN 23)), + (EQ(nVar"i",LN 215),Bop(Bit,Var("perms",FTy 31),LN 22)), + (EQ(nVar"i",LN 214),Bop(Bit,Var("perms",FTy 31),LN 21)), + (EQ(nVar"i",LN 213),Bop(Bit,Var("perms",FTy 31),LN 20)), + (EQ(nVar"i",LN 212),Bop(Bit,Var("perms",FTy 31),LN 19)), + (EQ(nVar"i",LN 211),Bop(Bit,Var("perms",FTy 31),LN 18)), + (EQ(nVar"i",LN 210),Bop(Bit,Var("perms",FTy 31),LN 17)), + (EQ(nVar"i",LN 209),Bop(Bit,Var("perms",FTy 31),LN 16)), + (EQ(nVar"i",LN 208),Bop(Bit,Var("perms",FTy 31),LN 15)), + (EQ(nVar"i",LN 207),Bop(Bit,Var("perms",FTy 31),LN 14)), + (EQ(nVar"i",LN 206),Bop(Bit,Var("perms",FTy 31),LN 13)), + (EQ(nVar"i",LN 205),Bop(Bit,Var("perms",FTy 31),LN 12)), + (EQ(nVar"i",LN 204),Bop(Bit,Var("perms",FTy 31),LN 11)), + (EQ(nVar"i",LN 203),Bop(Bit,Var("perms",FTy 31),LN 10)), + (EQ(nVar"i",LN 202),Bop(Bit,Var("perms",FTy 31),LN 9)), + (EQ(nVar"i",LN 201),Bop(Bit,Var("perms",FTy 31),LN 8)), + (EQ(nVar"i",LN 200),Bop(Bit,Var("perms",FTy 31),LN 7)), + (EQ(nVar"i",LN 199),Bop(Bit,Var("perms",FTy 31),LN 6)), + (EQ(nVar"i",LN 198),Bop(Bit,Var("perms",FTy 31),LN 5)), + (EQ(nVar"i",LN 197),Bop(Bit,Var("perms",FTy 31),LN 4)), + (EQ(nVar"i",LN 196),Bop(Bit,Var("perms",FTy 31),LN 3)), + (EQ(nVar"i",LN 195),Bop(Bit,Var("perms",FTy 31),LN 2)), + (EQ(nVar"i",LN 194),Bop(Bit,Var("perms",FTy 31),LN 1)), + (EQ(nVar"i",LN 193),Bop(Bit,Var("perms",FTy 31),LN 0)), + (EQ(nVar"i",LN 192),bVar"sealed"), + (EQ(nVar"i",LN 191),Bop(Bit,Var("offset",F64),LN 63)), + (EQ(nVar"i",LN 190),Bop(Bit,Var("offset",F64),LN 62)), + (EQ(nVar"i",LN 189),Bop(Bit,Var("offset",F64),LN 61)), + (EQ(nVar"i",LN 188),Bop(Bit,Var("offset",F64),LN 60)), + (EQ(nVar"i",LN 187),Bop(Bit,Var("offset",F64),LN 59)), + (EQ(nVar"i",LN 186),Bop(Bit,Var("offset",F64),LN 58)), + (EQ(nVar"i",LN 185),Bop(Bit,Var("offset",F64),LN 57)), + (EQ(nVar"i",LN 184),Bop(Bit,Var("offset",F64),LN 56)), + (EQ(nVar"i",LN 183),Bop(Bit,Var("offset",F64),LN 55)), + (EQ(nVar"i",LN 182),Bop(Bit,Var("offset",F64),LN 54)), + (EQ(nVar"i",LN 181),Bop(Bit,Var("offset",F64),LN 53)), + (EQ(nVar"i",LN 180),Bop(Bit,Var("offset",F64),LN 52)), + (EQ(nVar"i",LN 179),Bop(Bit,Var("offset",F64),LN 51)), + (EQ(nVar"i",LN 178),Bop(Bit,Var("offset",F64),LN 50)), + (EQ(nVar"i",LN 177),Bop(Bit,Var("offset",F64),LN 49)), + (EQ(nVar"i",LN 176),Bop(Bit,Var("offset",F64),LN 48)), + (EQ(nVar"i",LN 175),Bop(Bit,Var("offset",F64),LN 47)), + (EQ(nVar"i",LN 174),Bop(Bit,Var("offset",F64),LN 46)), + (EQ(nVar"i",LN 173),Bop(Bit,Var("offset",F64),LN 45)), + (EQ(nVar"i",LN 172),Bop(Bit,Var("offset",F64),LN 44)), + (EQ(nVar"i",LN 171),Bop(Bit,Var("offset",F64),LN 43)), + (EQ(nVar"i",LN 170),Bop(Bit,Var("offset",F64),LN 42)), + (EQ(nVar"i",LN 169),Bop(Bit,Var("offset",F64),LN 41)), + (EQ(nVar"i",LN 168),Bop(Bit,Var("offset",F64),LN 40)), + (EQ(nVar"i",LN 167),Bop(Bit,Var("offset",F64),LN 39)), + (EQ(nVar"i",LN 166),Bop(Bit,Var("offset",F64),LN 38)), + (EQ(nVar"i",LN 165),Bop(Bit,Var("offset",F64),LN 37)), + (EQ(nVar"i",LN 164),Bop(Bit,Var("offset",F64),LN 36)), + (EQ(nVar"i",LN 163),Bop(Bit,Var("offset",F64),LN 35)), + (EQ(nVar"i",LN 162),Bop(Bit,Var("offset",F64),LN 34)), + (EQ(nVar"i",LN 161),Bop(Bit,Var("offset",F64),LN 33)), + (EQ(nVar"i",LN 160),Bop(Bit,Var("offset",F64),LN 32)), + (EQ(nVar"i",LN 159),Bop(Bit,Var("offset",F64),LN 31)), + (EQ(nVar"i",LN 158),Bop(Bit,Var("offset",F64),LN 30)), + (EQ(nVar"i",LN 157),Bop(Bit,Var("offset",F64),LN 29)), + (EQ(nVar"i",LN 156),Bop(Bit,Var("offset",F64),LN 28)), + (EQ(nVar"i",LN 155),Bop(Bit,Var("offset",F64),LN 27)), + (EQ(nVar"i",LN 154),Bop(Bit,Var("offset",F64),LN 26)), + (EQ(nVar"i",LN 153),Bop(Bit,Var("offset",F64),LN 25)), + (EQ(nVar"i",LN 152),Bop(Bit,Var("offset",F64),LN 24)), + (EQ(nVar"i",LN 151),Bop(Bit,Var("offset",F64),LN 23)), + (EQ(nVar"i",LN 150),Bop(Bit,Var("offset",F64),LN 22)), + (EQ(nVar"i",LN 149),Bop(Bit,Var("offset",F64),LN 21)), + (EQ(nVar"i",LN 148),Bop(Bit,Var("offset",F64),LN 20)), + (EQ(nVar"i",LN 147),Bop(Bit,Var("offset",F64),LN 19)), + (EQ(nVar"i",LN 146),Bop(Bit,Var("offset",F64),LN 18)), + (EQ(nVar"i",LN 145),Bop(Bit,Var("offset",F64),LN 17)), + (EQ(nVar"i",LN 144),Bop(Bit,Var("offset",F64),LN 16)), + (EQ(nVar"i",LN 143),Bop(Bit,Var("offset",F64),LN 15)), + (EQ(nVar"i",LN 142),Bop(Bit,Var("offset",F64),LN 14)), + (EQ(nVar"i",LN 141),Bop(Bit,Var("offset",F64),LN 13)), + (EQ(nVar"i",LN 140),Bop(Bit,Var("offset",F64),LN 12)), + (EQ(nVar"i",LN 139),Bop(Bit,Var("offset",F64),LN 11)), + (EQ(nVar"i",LN 138),Bop(Bit,Var("offset",F64),LN 10)), + (EQ(nVar"i",LN 137),Bop(Bit,Var("offset",F64),LN 9)), + (EQ(nVar"i",LN 136),Bop(Bit,Var("offset",F64),LN 8)), + (EQ(nVar"i",LN 135),Bop(Bit,Var("offset",F64),LN 7)), + (EQ(nVar"i",LN 134),Bop(Bit,Var("offset",F64),LN 6)), + (EQ(nVar"i",LN 133),Bop(Bit,Var("offset",F64),LN 5)), + (EQ(nVar"i",LN 132),Bop(Bit,Var("offset",F64),LN 4)), + (EQ(nVar"i",LN 131),Bop(Bit,Var("offset",F64),LN 3)), + (EQ(nVar"i",LN 130),Bop(Bit,Var("offset",F64),LN 2)), + (EQ(nVar"i",LN 129),Bop(Bit,Var("offset",F64),LN 1)), + (EQ(nVar"i",LN 128),Bop(Bit,Var("offset",F64),LN 0)), + (EQ(nVar"i",LN 127),Bop(Bit,Var("base",F64),LN 63)), + (EQ(nVar"i",LN 126),Bop(Bit,Var("base",F64),LN 62)), + (EQ(nVar"i",LN 125),Bop(Bit,Var("base",F64),LN 61)), + (EQ(nVar"i",LN 124),Bop(Bit,Var("base",F64),LN 60)), + (EQ(nVar"i",LN 123),Bop(Bit,Var("base",F64),LN 59)), + (EQ(nVar"i",LN 122),Bop(Bit,Var("base",F64),LN 58)), + (EQ(nVar"i",LN 121),Bop(Bit,Var("base",F64),LN 57)), + (EQ(nVar"i",LN 120),Bop(Bit,Var("base",F64),LN 56)), + (EQ(nVar"i",LN 119),Bop(Bit,Var("base",F64),LN 55)), + (EQ(nVar"i",LN 118),Bop(Bit,Var("base",F64),LN 54)), + (EQ(nVar"i",LN 117),Bop(Bit,Var("base",F64),LN 53)), + (EQ(nVar"i",LN 116),Bop(Bit,Var("base",F64),LN 52)), + (EQ(nVar"i",LN 115),Bop(Bit,Var("base",F64),LN 51)), + (EQ(nVar"i",LN 114),Bop(Bit,Var("base",F64),LN 50)), + (EQ(nVar"i",LN 113),Bop(Bit,Var("base",F64),LN 49)), + (EQ(nVar"i",LN 112),Bop(Bit,Var("base",F64),LN 48)), + (EQ(nVar"i",LN 111),Bop(Bit,Var("base",F64),LN 47)), + (EQ(nVar"i",LN 110),Bop(Bit,Var("base",F64),LN 46)), + (EQ(nVar"i",LN 109),Bop(Bit,Var("base",F64),LN 45)), + (EQ(nVar"i",LN 108),Bop(Bit,Var("base",F64),LN 44)), + (EQ(nVar"i",LN 107),Bop(Bit,Var("base",F64),LN 43)), + (EQ(nVar"i",LN 106),Bop(Bit,Var("base",F64),LN 42)), + (EQ(nVar"i",LN 105),Bop(Bit,Var("base",F64),LN 41)), + (EQ(nVar"i",LN 104),Bop(Bit,Var("base",F64),LN 40)), + (EQ(nVar"i",LN 103),Bop(Bit,Var("base",F64),LN 39)), + (EQ(nVar"i",LN 102),Bop(Bit,Var("base",F64),LN 38)), + (EQ(nVar"i",LN 101),Bop(Bit,Var("base",F64),LN 37)), + (EQ(nVar"i",LN 100),Bop(Bit,Var("base",F64),LN 36)), + (EQ(nVar"i",LN 99),Bop(Bit,Var("base",F64),LN 35)), + (EQ(nVar"i",LN 98),Bop(Bit,Var("base",F64),LN 34)), + (EQ(nVar"i",LN 97),Bop(Bit,Var("base",F64),LN 33)), + (EQ(nVar"i",LN 96),Bop(Bit,Var("base",F64),LN 32)), + (EQ(nVar"i",LN 95),Bop(Bit,Var("base",F64),LN 31)), + (EQ(nVar"i",LN 94),Bop(Bit,Var("base",F64),LN 30)), + (EQ(nVar"i",LN 93),Bop(Bit,Var("base",F64),LN 29)), + (EQ(nVar"i",LN 92),Bop(Bit,Var("base",F64),LN 28)), + (EQ(nVar"i",LN 91),Bop(Bit,Var("base",F64),LN 27)), + (EQ(nVar"i",LN 90),Bop(Bit,Var("base",F64),LN 26)), + (EQ(nVar"i",LN 89),Bop(Bit,Var("base",F64),LN 25)), + (EQ(nVar"i",LN 88),Bop(Bit,Var("base",F64),LN 24)), + (EQ(nVar"i",LN 87),Bop(Bit,Var("base",F64),LN 23)), + (EQ(nVar"i",LN 86),Bop(Bit,Var("base",F64),LN 22)), + (EQ(nVar"i",LN 85),Bop(Bit,Var("base",F64),LN 21)), + (EQ(nVar"i",LN 84),Bop(Bit,Var("base",F64),LN 20)), + (EQ(nVar"i",LN 83),Bop(Bit,Var("base",F64),LN 19)), + (EQ(nVar"i",LN 82),Bop(Bit,Var("base",F64),LN 18)), + (EQ(nVar"i",LN 81),Bop(Bit,Var("base",F64),LN 17)), + (EQ(nVar"i",LN 80),Bop(Bit,Var("base",F64),LN 16)), + (EQ(nVar"i",LN 79),Bop(Bit,Var("base",F64),LN 15)), + (EQ(nVar"i",LN 78),Bop(Bit,Var("base",F64),LN 14)), + (EQ(nVar"i",LN 77),Bop(Bit,Var("base",F64),LN 13)), + (EQ(nVar"i",LN 76),Bop(Bit,Var("base",F64),LN 12)), + (EQ(nVar"i",LN 75),Bop(Bit,Var("base",F64),LN 11)), + (EQ(nVar"i",LN 74),Bop(Bit,Var("base",F64),LN 10)), + (EQ(nVar"i",LN 73),Bop(Bit,Var("base",F64),LN 9)), + (EQ(nVar"i",LN 72),Bop(Bit,Var("base",F64),LN 8)), + (EQ(nVar"i",LN 71),Bop(Bit,Var("base",F64),LN 7)), + (EQ(nVar"i",LN 70),Bop(Bit,Var("base",F64),LN 6)), + (EQ(nVar"i",LN 69),Bop(Bit,Var("base",F64),LN 5)), + (EQ(nVar"i",LN 68),Bop(Bit,Var("base",F64),LN 4)), + (EQ(nVar"i",LN 67),Bop(Bit,Var("base",F64),LN 3)), + (EQ(nVar"i",LN 66),Bop(Bit,Var("base",F64),LN 2)), + (EQ(nVar"i",LN 65),Bop(Bit,Var("base",F64),LN 1)), + (EQ(nVar"i",LN 64),Bop(Bit,Var("base",F64),LN 0)), + (EQ(nVar"i",LN 63),Bop(Bit,Var("length",F64),LN 63)), + (EQ(nVar"i",LN 62),Bop(Bit,Var("length",F64),LN 62)), + (EQ(nVar"i",LN 61),Bop(Bit,Var("length",F64),LN 61)), + (EQ(nVar"i",LN 60),Bop(Bit,Var("length",F64),LN 60)), + (EQ(nVar"i",LN 59),Bop(Bit,Var("length",F64),LN 59)), + (EQ(nVar"i",LN 58),Bop(Bit,Var("length",F64),LN 58)), + (EQ(nVar"i",LN 57),Bop(Bit,Var("length",F64),LN 57)), + (EQ(nVar"i",LN 56),Bop(Bit,Var("length",F64),LN 56)), + (EQ(nVar"i",LN 55),Bop(Bit,Var("length",F64),LN 55)), + (EQ(nVar"i",LN 54),Bop(Bit,Var("length",F64),LN 54)), + (EQ(nVar"i",LN 53),Bop(Bit,Var("length",F64),LN 53)), + (EQ(nVar"i",LN 52),Bop(Bit,Var("length",F64),LN 52)), + (EQ(nVar"i",LN 51),Bop(Bit,Var("length",F64),LN 51)), + (EQ(nVar"i",LN 50),Bop(Bit,Var("length",F64),LN 50)), + (EQ(nVar"i",LN 49),Bop(Bit,Var("length",F64),LN 49)), + (EQ(nVar"i",LN 48),Bop(Bit,Var("length",F64),LN 48)), + (EQ(nVar"i",LN 47),Bop(Bit,Var("length",F64),LN 47)), + (EQ(nVar"i",LN 46),Bop(Bit,Var("length",F64),LN 46)), + (EQ(nVar"i",LN 45),Bop(Bit,Var("length",F64),LN 45)), + (EQ(nVar"i",LN 44),Bop(Bit,Var("length",F64),LN 44)), + (EQ(nVar"i",LN 43),Bop(Bit,Var("length",F64),LN 43)), + (EQ(nVar"i",LN 42),Bop(Bit,Var("length",F64),LN 42)), + (EQ(nVar"i",LN 41),Bop(Bit,Var("length",F64),LN 41)), + (EQ(nVar"i",LN 40),Bop(Bit,Var("length",F64),LN 40)), + (EQ(nVar"i",LN 39),Bop(Bit,Var("length",F64),LN 39)), + (EQ(nVar"i",LN 38),Bop(Bit,Var("length",F64),LN 38)), + (EQ(nVar"i",LN 37),Bop(Bit,Var("length",F64),LN 37)), + (EQ(nVar"i",LN 36),Bop(Bit,Var("length",F64),LN 36)), + (EQ(nVar"i",LN 35),Bop(Bit,Var("length",F64),LN 35)), + (EQ(nVar"i",LN 34),Bop(Bit,Var("length",F64),LN 34)), + (EQ(nVar"i",LN 33),Bop(Bit,Var("length",F64),LN 33)), + (EQ(nVar"i",LN 32),Bop(Bit,Var("length",F64),LN 32)), + (EQ(nVar"i",LN 31),Bop(Bit,Var("length",F64),LN 31)), + (EQ(nVar"i",LN 30),Bop(Bit,Var("length",F64),LN 30)), + (EQ(nVar"i",LN 29),Bop(Bit,Var("length",F64),LN 29)), + (EQ(nVar"i",LN 28),Bop(Bit,Var("length",F64),LN 28)), + (EQ(nVar"i",LN 27),Bop(Bit,Var("length",F64),LN 27)), + (EQ(nVar"i",LN 26),Bop(Bit,Var("length",F64),LN 26)), + (EQ(nVar"i",LN 25),Bop(Bit,Var("length",F64),LN 25)), + (EQ(nVar"i",LN 24),Bop(Bit,Var("length",F64),LN 24)), + (EQ(nVar"i",LN 23),Bop(Bit,Var("length",F64),LN 23)), + (EQ(nVar"i",LN 22),Bop(Bit,Var("length",F64),LN 22)), + (EQ(nVar"i",LN 21),Bop(Bit,Var("length",F64),LN 21)), + (EQ(nVar"i",LN 20),Bop(Bit,Var("length",F64),LN 20)), + (EQ(nVar"i",LN 19),Bop(Bit,Var("length",F64),LN 19)), + (EQ(nVar"i",LN 18),Bop(Bit,Var("length",F64),LN 18)), + (EQ(nVar"i",LN 17),Bop(Bit,Var("length",F64),LN 17)), + (EQ(nVar"i",LN 16),Bop(Bit,Var("length",F64),LN 16)), + (EQ(nVar"i",LN 15),Bop(Bit,Var("length",F64),LN 15)), + (EQ(nVar"i",LN 14),Bop(Bit,Var("length",F64),LN 14)), + (EQ(nVar"i",LN 13),Bop(Bit,Var("length",F64),LN 13)), + (EQ(nVar"i",LN 12),Bop(Bit,Var("length",F64),LN 12)), + (EQ(nVar"i",LN 11),Bop(Bit,Var("length",F64),LN 11)), + (EQ(nVar"i",LN 10),Bop(Bit,Var("length",F64),LN 10)), + (EQ(nVar"i",LN 9),Bop(Bit,Var("length",F64),LN 9)), + (EQ(nVar"i",LN 8),Bop(Bit,Var("length",F64),LN 8)), + (EQ(nVar"i",LN 7),Bop(Bit,Var("length",F64),LN 7)), + (EQ(nVar"i",LN 6),Bop(Bit,Var("length",F64),LN 6)), + (EQ(nVar"i",LN 5),Bop(Bit,Var("length",F64),LN 5)), + (EQ(nVar"i",LN 4),Bop(Bit,Var("length",F64),LN 4)), + (EQ(nVar"i",LN 3),Bop(Bit,Var("length",F64),LN 3)), + (EQ(nVar"i",LN 2),Bop(Bit,Var("length",F64),LN 2)), + (EQ(nVar"i",LN 1),Bop(Bit,Var("length",F64),LN 1))], + Bop(Bit,Var("length",F64),LN 0))),LW(0,257)))])) +; +val write'rec'Capability_def = Def + ("write'rec'Capability",TP[AVar(FTy 257),Var("x",CTy"Capability")], + Call("reg'Capability",FTy 257,Var("x",CTy"Capability"))) +; +val write'reg'Capability_def = Def + ("write'reg'Capability",TP[AVar(CTy"Capability"),Var("x",FTy 257)], + Call("rec'Capability",CTy"Capability",Var("x",FTy 257))) +; +val rec'CapCause_def = Def + ("rec'CapCause",Var("x",F16), + Rec(CTy"CapCause", + [EX(Var("x",F16),LN 15,LN 8,F8),EX(Var("x",F16),LN 7,LN 0,F8)])) +; +val reg'CapCause_def = Def + ("reg'CapCause",Var("x",CTy"CapCause"), + CS(Var("x",CTy"CapCause"), + [(Rec(CTy"CapCause",[Var("ExcCode",F8),Var("RegNum",F8)]), + Bop(Mdfy, + Close + (TP[nVar"i",AVar bTy], + ITB([(EQ(nVar"i",LN 15),Bop(Bit,Var("ExcCode",F8),LN 7)), + (EQ(nVar"i",LN 14),Bop(Bit,Var("ExcCode",F8),LN 6)), + (EQ(nVar"i",LN 13),Bop(Bit,Var("ExcCode",F8),LN 5)), + (EQ(nVar"i",LN 12),Bop(Bit,Var("ExcCode",F8),LN 4)), + (EQ(nVar"i",LN 11),Bop(Bit,Var("ExcCode",F8),LN 3)), + (EQ(nVar"i",LN 10),Bop(Bit,Var("ExcCode",F8),LN 2)), + (EQ(nVar"i",LN 9),Bop(Bit,Var("ExcCode",F8),LN 1)), + (EQ(nVar"i",LN 8),Bop(Bit,Var("ExcCode",F8),LN 0)), + (EQ(nVar"i",LN 7),Bop(Bit,Var("RegNum",F8),LN 7)), + (EQ(nVar"i",LN 6),Bop(Bit,Var("RegNum",F8),LN 6)), + (EQ(nVar"i",LN 5),Bop(Bit,Var("RegNum",F8),LN 5)), + (EQ(nVar"i",LN 4),Bop(Bit,Var("RegNum",F8),LN 4)), + (EQ(nVar"i",LN 3),Bop(Bit,Var("RegNum",F8),LN 3)), + (EQ(nVar"i",LN 2),Bop(Bit,Var("RegNum",F8),LN 2)), + (EQ(nVar"i",LN 1),Bop(Bit,Var("RegNum",F8),LN 1))], + Bop(Bit,Var("RegNum",F8),LN 0))),LW(0,16)))])) +; +val write'rec'CapCause_def = Def + ("write'rec'CapCause",TP[AVar F16,Var("x",CTy"CapCause")], + Call("reg'CapCause",F16,Var("x",CTy"CapCause"))) +; +val write'reg'CapCause_def = Def + ("write'reg'CapCause",TP[AVar(CTy"CapCause"),Var("x",F16)], + Call("rec'CapCause",CTy"CapCause",Var("x",F16))) +; +val BranchDelayPCC_def = Def + ("BranchDelayPCC",qVar"state", + TP[Apply + (Dest + ("c_BranchDelayPCC",ATy(F8,OTy(PTy(F64,CTy"Capability"))), + qVar"state"),Dest("procID",F8,qVar"state")),qVar"state"]) +; +val write'BranchDelayPCC_def = Def + ("write'BranchDelayPCC",Var("value",OTy(PTy(F64,CTy"Capability"))), + Close + (qVar"state", + TP[LU, + Rupd + ("c_BranchDelayPCC", + TP[qVar"state", + Fupd + (Dest + ("c_BranchDelayPCC", + ATy(F8,OTy(PTy(F64,CTy"Capability"))),qVar"state"), + Dest("procID",F8,qVar"state"), + Var("value",OTy(PTy(F64,CTy"Capability"))))])])) +; +val BranchToPCC_def = Def + ("BranchToPCC",qVar"state", + TP[Apply + (Dest + ("c_BranchToPCC",ATy(F8,OTy(PTy(F64,CTy"Capability"))), + qVar"state"),Dest("procID",F8,qVar"state")),qVar"state"]) +; +val write'BranchToPCC_def = Def + ("write'BranchToPCC",Var("value",OTy(PTy(F64,CTy"Capability"))), + Close + (qVar"state", + TP[LU, + Rupd + ("c_BranchToPCC", + TP[qVar"state", + Fupd + (Dest + ("c_BranchToPCC", + ATy(F8,OTy(PTy(F64,CTy"Capability"))),qVar"state"), + Dest("procID",F8,qVar"state"), + Var("value",OTy(PTy(F64,CTy"Capability"))))])])) +; +val hex24_def = Def + ("hex24",Var("x",FTy 24), + Mop(PadLeft,TP[LSC #"0",LN 6,Mop(Cast sTy,Var("x",FTy 24))])) +; +val hex31_def = Def + ("hex31",Var("x",FTy 31), + Mop(PadLeft,TP[LSC #"0",LN 8,Mop(Cast sTy,Var("x",FTy 31))])) +; +val hex40_def = Def + ("hex40",Var("x",FTy 40), + Mop(PadLeft,TP[LSC #"0",LN 10,Mop(Cast sTy,Var("x",FTy 40))])) +; +val log_cap_write_def = Def + ("log_cap_write",Var("cap",CTy"Capability"), + CC[LS"u:", + ITE(Dest("sealed",bTy,Var("cap",CTy"Capability")),LS"1",LS"0"), + LS" perms:0x", + Call("hex31",sTy,Dest("perms",FTy 31,Var("cap",CTy"Capability"))), + LS" type:0x", + Call("hex24",sTy,Dest("otype",FTy 24,Var("cap",CTy"Capability"))), + LS" offset:0x", + Call("hex64",sTy,Dest("offset",F64,Var("cap",CTy"Capability"))), + LS" base:0x", + Call("hex64",sTy,Dest("base",F64,Var("cap",CTy"Capability"))), + LS" length:0x", + Call("hex64",sTy,Dest("length",F64,Var("cap",CTy"Capability")))]) +; +val log_cpp_write_def = Def + ("log_cpp_write",Var("cap",CTy"Capability"), + CC[LS"PCC <- ",Call("log_cap_write",sTy,Var("cap",CTy"Capability"))]) +; +val log_creg_write_def = Def + ("log_creg_write",TP[Var("r",FTy 5),Var("cap",CTy"Capability")], + CC[LS"CapReg ",Mop(Cast sTy,Mop(Cast nTy,Var("r",FTy 5))),LS" <- ", + Call("log_cap_write",sTy,Var("cap",CTy"Capability"))]) +; +val log_store_cap_def = Def + ("log_store_cap",TP[Var("pAddr",FTy 40),Var("cap",CTy"Capability")], + CC[LS"MEM[0x",Call("hex40",sTy,Var("pAddr",FTy 40)),LS"] <- ", + Call("log_cap_write",sTy,Var("cap",CTy"Capability"))]) +; +val log_cap_exce_def = Def + ("log_cap_exce",TP[Var("e",F8),Var("cr",F8)], + Close + (qVar"state", + TP[CC[LS"CapException : 0x",Mop(Cast sTy,Var("e",F8)),LS" CReg ", + Mop(Cast sTy,Mop(Cast nTy,Var("cr",F8))), + ITE(Bop(Lt,Var("cr",F8),LW(32,8)), + CC[LS" : ", + Call + ("log_cap_write",sTy, + Apply + (Apply + (Dest + ("c_capr", + ATy(F8,ATy(FTy 5,CTy"Capability")), + qVar"state"),Dest("procID",F8,qVar"state")), + Mop(Cast(FTy 5),Var("cr",F8))))],LS"")], + qVar"state"])) +; +val dumpCRegs_def = Def + ("dumpCRegs",AVar uTy, + Close + (qVar"state", + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("mark_log",ATy(qTy,PTy(uTy,qTy)), + TP[LN 0,LS"====== Registers ======"]),qVar"state")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("mark_log",ATy(qTy,PTy(uTy,qTy)), + TP[LN 0, + CC[LS"Core = ", + Mop(Cast sTy, + Mop(Cast nTy,Dest("procID",F8,qVar"s")))]]), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("mark_log",ATy(qTy,PTy(uTy,qTy)), + TP[LN 0, + CC[LS"DEBUG CAP PCC ", + Call + ("log_cap_write",sTy, + Apply + (Dest + ("c_pcc", + ATy(F8,CTy"Capability"),qVar"s"), + Dest("procID",F8,qVar"s")))]]), + qVar"s")), + Apply + (For(TP[LN 0,LN 31, + Close + (nVar"i", + Close + (qVar"state", + Apply + (Call + ("mark_log",ATy(qTy,PTy(uTy,qTy)), + TP[LN 0, + CC[LS"DEBUG CAP REG ", + ITE(Bop(Lt,nVar"i",LN 10), + LS" ",LS""), + Mop(Cast sTy, + Mop(Cast nTy,nVar"i")), + LS" ", + Call + ("log_cap_write",sTy, + Apply + (Apply + (Dest + ("c_capr", + ATy(F8, + ATy(FTy 5, + CTy"Capability")), + qVar"s"), + Dest + ("procID",F8, + qVar"s")), + Mop(Cast(FTy 5), + nVar"i")))]]), + qVar"state")))]),qVar"s")))))) +; +val capcause_def = Def + ("capcause",qVar"state", + TP[Apply + (Dest("c_capcause",ATy(F8,CTy"CapCause"),qVar"state"), + Dest("procID",F8,qVar"state")),qVar"state"]) +; +val write'capcause_def = Def + ("write'capcause",Var("value",CTy"CapCause"), + Close + (qVar"state", + TP[LU, + Rupd + ("c_capcause", + TP[qVar"state", + Fupd + (Dest("c_capcause",ATy(F8,CTy"CapCause"),qVar"state"), + Dest("procID",F8,qVar"state"),Var("value",CTy"CapCause"))])])) +; +val PCC_def = Def + ("PCC",qVar"state", + TP[Apply + (Dest("c_pcc",ATy(F8,CTy"Capability"),qVar"state"), + Dest("procID",F8,qVar"state")),qVar"state"]) +; +val write'PCC_def = Def + ("write'PCC",Var("value",CTy"Capability"), + Close + (qVar"state", + Apply + (Call + ("mark_log",ATy(qTy,PTy(uTy,qTy)), + TP[LN 2,Call("log_cpp_write",sTy,Var("value",CTy"Capability"))]), + Rupd + ("c_pcc", + TP[qVar"state", + Fupd + (Dest("c_pcc",ATy(F8,CTy"Capability"),qVar"state"), + Dest("procID",F8,qVar"state"), + Var("value",CTy"Capability"))])))) +; +val CAPR_def = Def + ("CAPR",Var("n",FTy 5), + Close + (qVar"state", + TP[Apply + (Apply + (Dest + ("c_capr",ATy(F8,ATy(FTy 5,CTy"Capability")),qVar"state"), + Dest("procID",F8,qVar"state")),Var("n",FTy 5)),qVar"state"])) +; +val write'CAPR_def = Def + ("write'CAPR",TP[Var("value",CTy"Capability"),Var("n",FTy 5)], + Close + (qVar"state", + TP[LU, + Let(Var("s",PTy(ATy(FTy 5,CTy"Capability"),qTy)), + TP[Fupd + (Apply + (Dest + ("c_capr",ATy(F8,ATy(FTy 5,CTy"Capability")), + qVar"state"),Dest("procID",F8,qVar"state")), + Var("n",FTy 5),Var("value",CTy"Capability")), + qVar"state"], + Let(Var("s",PTy(ATy(FTy 5,CTy"Capability"),qTy)), + TP[Mop(Fst,Var("s",PTy(ATy(FTy 5,CTy"Capability"),qTy))), + Rupd + ("c_capr", + TP[Mop(Snd, + Var("s",PTy(ATy(FTy 5,CTy"Capability"),qTy))), + Fupd + (Dest + ("c_capr", + ATy(F8,ATy(FTy 5,CTy"Capability")), + Mop(Snd, + Var("s", + PTy(ATy(FTy 5,CTy"Capability"),qTy)))), + Dest + ("procID",F8, + Mop(Snd, + Var("s", + PTy(ATy(FTy 5,CTy"Capability"),qTy)))), + Mop(Fst, + Var("s", + PTy(ATy(FTy 5,CTy"Capability"),qTy))))])], + Mop(Snd, + Apply + (Call + ("mark_log",ATy(qTy,PTy(uTy,qTy)), + TP[LN 2, + Call + ("log_creg_write",sTy, + TP[Var("n",FTy 5), + Var("value",CTy"Capability")])]), + Mop(Snd, + Var("s",PTy(ATy(FTy 5,CTy"Capability"),qTy)))))))])) +; +val RCC_def = Def + ("RCC",qVar"state", + TP[Mop(Fst, + Apply + (Call("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)),LW(24,5)), + qVar"state")),qVar"state"]) +; +val write'RCC_def = Def + ("write'RCC",Var("value",CTy"Capability"), + Close + (qVar"state", + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Var("value",CTy"Capability"),LW(24,5)]),qVar"state"))) +; +val IDC_def = Def + ("IDC",qVar"state", + TP[Mop(Fst, + Apply + (Call("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)),LW(26,5)), + qVar"state")),qVar"state"]) +; +val write'IDC_def = Def + ("write'IDC",Var("value",CTy"Capability"), + Close + (qVar"state", + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Var("value",CTy"Capability"),LW(26,5)]),qVar"state"))) +; +val KR1C_def = Def + ("KR1C",qVar"state", + TP[Mop(Fst, + Apply + (Call("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)),LW(27,5)), + qVar"state")),qVar"state"]) +; +val write'KR1C_def = Def + ("write'KR1C",Var("value",CTy"Capability"), + Close + (qVar"state", + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Var("value",CTy"Capability"),LW(27,5)]),qVar"state"))) +; +val KR2C_def = Def + ("KR2C",qVar"state", + TP[Mop(Fst, + Apply + (Call("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)),LW(28,5)), + qVar"state")),qVar"state"]) +; +val write'KR2C_def = Def + ("write'KR2C",Var("value",CTy"Capability"), + Close + (qVar"state", + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Var("value",CTy"Capability"),LW(28,5)]),qVar"state"))) +; +val KCC_def = Def + ("KCC",qVar"state", + TP[Mop(Fst, + Apply + (Call("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)),LW(29,5)), + qVar"state")),qVar"state"]) +; +val write'KCC_def = Def + ("write'KCC",Var("value",CTy"Capability"), + Close + (qVar"state", + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Var("value",CTy"Capability"),LW(29,5)]),qVar"state"))) +; +val KDC_def = Def + ("KDC",qVar"state", + TP[Mop(Fst, + Apply + (Call("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)),LW(30,5)), + qVar"state")),qVar"state"]) +; +val write'KDC_def = Def + ("write'KDC",Var("value",CTy"Capability"), + Close + (qVar"state", + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Var("value",CTy"Capability"),LW(30,5)]),qVar"state"))) +; +val EPCC_def = Def + ("EPCC",qVar"state", + TP[Mop(Fst, + Apply + (Call("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)),LW(31,5)), + qVar"state")),qVar"state"]) +; +val write'EPCC_def = Def + ("write'EPCC",Var("value",CTy"Capability"), + Close + (qVar"state", + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Var("value",CTy"Capability"),LW(31,5)]),qVar"state"))) +; +val ExceptionCode_def = Def + ("ExceptionCode",Var("ExceptionType",CTy"ExceptionType"), + CS(Var("ExceptionType",CTy"ExceptionType"), + [(LC("Int",CTy"ExceptionType"),LW(0,5)), + (LC("Mod",CTy"ExceptionType"),LW(1,5)), + (LC("TLBL",CTy"ExceptionType"),LW(2,5)), + (LC("TLBS",CTy"ExceptionType"),LW(3,5)), + (LC("AdEL",CTy"ExceptionType"),LW(4,5)), + (LC("AdES",CTy"ExceptionType"),LW(5,5)), + (LC("Sys",CTy"ExceptionType"),LW(8,5)), + (LC("Bp",CTy"ExceptionType"),LW(9,5)), + (LC("ResI",CTy"ExceptionType"),LW(10,5)), + (LC("CpU",CTy"ExceptionType"),LW(11,5)), + (LC("Ov",CTy"ExceptionType"),LW(12,5)), + (LC("Tr",CTy"ExceptionType"),LW(13,5)), + (LC("CTLBL",CTy"ExceptionType"),LW(16,5)), + (LC("CTLBS",CTy"ExceptionType"),LW(17,5)), + (LC("C2E",CTy"ExceptionType"),LW(18,5)), + (LC("XTLBRefillL",CTy"ExceptionType"),LW(2,5)), + (LC("XTLBRefillS",CTy"ExceptionType"),LW(3,5))])) +; +val SignalException_def = Def + ("SignalException",Var("ExceptionType",CTy"ExceptionType"), + Close + (qVar"state", + Let(qVar"s", + ITE(Mop(Not, + Dest + ("EXL",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))), + ITE(Mop(IsSome, + Mop(Fst, + Apply + (Const + ("BranchDelay",ATy(qTy,PTy(OTy F64,qTy))), + qVar"state"))), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("EPC", + TP[Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))),qVar"state")), + Bop(Sub, + Mop(Fst, + Apply + (Const + ("PC", + ATy(qTy,PTy(F64,qTy))), + qVar"state")),LW(4,64))])), + qVar"state")), + Let(Var("v",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"s")), + Mop(Snd, + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Cause", + TP[Var("v",CTy"CP0__renamed__"), + Rupd + ("BD", + TP[Dest + ("Cause", + CTy"CauseRegister", + Var("v", + CTy"CP0__renamed__")), + LT])])),qVar"s")))), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("EPC", + TP[Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))),qVar"state")), + Mop(Fst, + Apply + (Const + ("PC",ATy(qTy,PTy(F64,qTy))), + qVar"state"))])),qVar"state")), + Let(Var("v",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"s")), + Mop(Snd, + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Cause", + TP[Var("v",CTy"CP0__renamed__"), + Rupd + ("BD", + TP[Dest + ("Cause", + CTy"CauseRegister", + Var("v", + CTy"CP0__renamed__")), + LF])])),qVar"s"))))), + qVar"state"), + Let(qVar"s0", + ITE(Mop(IsSome,Dest("currentInst",OTy F32,qVar"s")), + Mop(Snd, + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("EInstr", + TP[Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))),qVar"s")), + Mop(ValOf, + Dest("currentInst",OTy F32,qVar"s"))])), + qVar"s")),qVar"s"), + Let(Var("v0",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"s0")), + Let(qVar"s0", + Mop(Snd, + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Cause", + TP[Var("v0",CTy"CP0__renamed__"), + Rupd + ("ExcCode", + TP[Dest + ("Cause",CTy"CauseRegister", + Var("v0", + CTy"CP0__renamed__")), + Call + ("ExceptionCode",FTy 5, + Var("ExceptionType", + CTy"ExceptionType"))])])), + qVar"s0")), + Let(Var("v0",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"s0")), + Let(qVar"s0", + Mop(Snd, + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Status", + TP[Var("v0",CTy"CP0__renamed__"), + Rupd + ("EXL", + TP[Dest + ("Status", + CTy"StatusRegister", + Var("v0", + CTy"CP0__renamed__")), + LT])])),qVar"s0")), + Let(Var("v0",F64), + ITE(Dest + ("BEV",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s0")))), + LW(18446744072631616000,64), + LW(18446744071562067968,64)), + Let(qVar"s0", + Mop(Snd, + Apply + (Call + ("write'exceptionSignalled", + ATy(qTy,PTy(uTy,qTy)),LT), + Mop(Snd, + Apply + (Call + ("write'BranchTo", + ATy(qTy, + PTy(uTy,qTy)), + LO F64), + Mop(Snd, + Apply + (Call + ("write'BranchDelay", + ATy(qTy, + PTy(uTy, + qTy)), + LO F64), + qVar"s0")))))), + Let(qVar"s0", + Mop(Snd, + Apply + (Call + ("write'EPCC", + ATy(qTy,PTy(uTy,qTy)), + Mop(Fst, + Apply + (Const + ("PCC", + ATy(qTy, + PTy(CTy"Capability", + qTy))), + qVar"s0"))), + qVar"s0")), + Let(qVar"s0", + Mop(Snd, + Apply + (Call + ("write'EPCC", + ATy(qTy, + PTy(uTy,qTy)), + Rupd + ("offset", + TP[Mop(Fst, + Apply + (Const + ("EPCC", + ATy(qTy, + PTy(CTy"Capability", + qTy))), + qVar"s0")), + Mop(Fst, + Apply + (Const + ("PC", + ATy(qTy, + PTy(F64, + qTy))), + qVar"s0"))])), + qVar"s0")), + Apply + (Call + ("mark_log", + ATy(qTy,PTy(uTy,qTy)), + TP[LN 2, + Call + ("log_sig_exception", + sTy, + Call + ("ExceptionCode", + FTy 5, + Var("ExceptionType", + CTy"ExceptionType")))]), + Mop(Snd, + Apply + (Call + ("write'PC", + ATy(qTy, + PTy(uTy,qTy)), + CC[EX(Var("v0", + F64), + LN 63, + LN 30, + FTy 34), + Bop(Add, + EX(Var("v0", + F64), + LN 29, + LN 0, + FTy 30), + ITB([(Bop(And, + Bop(Or, + EQ(Var("ExceptionType", + CTy"ExceptionType"), + LC("XTLBRefillL", + CTy"ExceptionType")), + EQ(Var("ExceptionType", + CTy"ExceptionType"), + LC("XTLBRefillS", + CTy"ExceptionType"))), + Mop(Not, + Dest + ("EXL", + bTy, + Dest + ("Status", + CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")))))), + LW(128, + 30)), + (Bop(And, + EQ(Var("ExceptionType", + CTy"ExceptionType"), + LC("C2E", + CTy"ExceptionType")), + Bop(Or, + EQ(Dest + ("ExcCode", + F8, + Mop(Fst, + Apply + (Const + ("capcause", + ATy(qTy, + PTy(CTy"CapCause", + qTy))), + qVar"s"))), + LW(5, + 8)), + EQ(Dest + ("ExcCode", + F8, + Mop(Fst, + Apply + (Const + ("capcause", + ATy(qTy, + PTy(CTy"CapCause", + qTy))), + qVar"s"))), + LW(6, + 8)))), + LW(640, + 30))], + LW(384, + 30)))]), + Mop(Snd, + Apply + (Call + ("write'PCC", + ATy(qTy, + PTy(uTy, + qTy)), + Mop(Fst, + Apply + (Const + ("KCC", + ATy(qTy, + PTy(CTy"Capability", + qTy))), + qVar"s0"))), + qVar"s0"))))))))))))))))) +; +val SignalCP2UnusableException_def = Def + ("SignalCP2UnusableException",qVar"state", + Let(Var("v",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state")), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("CpU",CTy"ExceptionType")), + Mop(Snd, + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Cause", + TP[Var("v",CTy"CP0__renamed__"), + Rupd + ("CE", + TP[Dest + ("Cause",CTy"CauseRegister", + Var("v",CTy"CP0__renamed__")),LW(2,2)])])), + qVar"state"))))) +; +val SignalCapException_internal_def = Def + ("SignalCapException_internal", + TP[Var("capException",CTy"CapException"),Var("regNum",F8)], + Close + (qVar"state", + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'capcause",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("ExcCode", + TP[Mop(Fst, + Apply + (Const + ("capcause", + ATy(qTy,PTy(CTy"CapCause",qTy))), + qVar"state")), + CS(Var("capException",CTy"CapException"), + [(LC("capExcNone",CTy"CapException"),LW(0,8)), + (LC("capExcLength",CTy"CapException"), + LW(1,8)), + (LC("capExcTag",CTy"CapException"),LW(2,8)), + (LC("capExcSeal",CTy"CapException"),LW(3,8)), + (LC("capExcType",CTy"CapException"),LW(4,8)), + (LC("capExcCall",CTy"CapException"),LW(5,8)), + (LC("capExcRet",CTy"CapException"),LW(6,8)), + (LC("capExcUnderflowTSS",CTy"CapException"), + LW(7,8)), + (LC("capExcUser",CTy"CapException"),LW(8,8)), + (LC("capExcTLBNoStore",CTy"CapException"), + LW(9,8)), + (LC("capExcGlobal",CTy"CapException"), + LW(16,8)), + (LC("capExcPermExe",CTy"CapException"), + LW(17,8)), + (LC("capExcPermLoad",CTy"CapException"), + LW(18,8)), + (LC("capExcPermStore",CTy"CapException"), + LW(19,8)), + (LC("capExcPermLoadCap",CTy"CapException"), + LW(20,8)), + (LC("capExcPermStoreCap",CTy"CapException"), + LW(21,8)), + (LC("capExcPermStoreLocalCap", + CTy"CapException"),LW(22,8)), + (LC("capExcPermSeal",CTy"CapException"), + LW(23,8)), + (LC("capExcPermSetType",CTy"CapException"), + LW(24,8)), + (LC("capExcAccEPCC",CTy"CapException"), + LW(26,8)), + (LC("capExcAccKDC",CTy"CapException"), + LW(27,8)), + (LC("capExcAccKCC",CTy"CapException"), + LW(28,8)), + (LC("capExcAccKR1C",CTy"CapException"), + LW(29,8)), + (LC("capExcAccKR2C",CTy"CapException"), + LW(30,8))])])),qVar"state")), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("C2E",CTy"ExceptionType")), + Mop(Snd, + Apply + (Call + ("write'capcause",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("RegNum", + TP[Mop(Fst, + Apply + (Const + ("capcause", + ATy(qTy,PTy(CTy"CapCause",qTy))), + qVar"s")),Var("regNum",F8)])),qVar"s")))))) +; +val SignalCapException_def = Def + ("SignalCapException", + TP[Var("capException",CTy"CapException"),Var("regNum",FTy 5)], + Close + (qVar"state", + Apply + (Call + ("SignalCapException_internal",ATy(qTy,PTy(uTy,qTy)), + TP[Var("capException",CTy"CapException"), + Mop(Cast F8,Var("regNum",FTy 5))]),qVar"state"))) +; +val SignalCapException_noReg_def = Def + ("SignalCapException_noReg",Var("capException",CTy"CapException"), + Close + (qVar"state", + Apply + (Call + ("SignalCapException_internal",ATy(qTy,PTy(uTy,qTy)), + TP[Var("capException",CTy"CapException"),LW(255,8)]), + qVar"state"))) +; +val SignalCapException_v_def = Def + ("SignalCapException_v",Var("regNum",FTy 5), + Close + (qVar"state", + CS(Var("regNum",FTy 5), + [(LW(31,5), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcAccEPCC",CTy"CapException"), + Mop(Cast(FTy 5),Var("regNum",FTy 5))]),qVar"state")), + (LW(30,5), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcAccKDC",CTy"CapException"), + Mop(Cast(FTy 5),Var("regNum",FTy 5))]),qVar"state")), + (LW(29,5), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcAccKCC",CTy"CapException"), + Mop(Cast(FTy 5),Var("regNum",FTy 5))]),qVar"state")), + (LW(27,5), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcAccKR1C",CTy"CapException"), + Mop(Cast(FTy 5),Var("regNum",FTy 5))]),qVar"state")), + (LW(28,5), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcAccKR2C",CTy"CapException"), + Mop(Cast(FTy 5),Var("regNum",FTy 5))]),qVar"state")), + (AVar(FTy 5),TP[LU,qVar"state"])]))) +; +val dfn'ERET_def = Def + ("dfn'ERET",qVar"state", + ITE(Bop(Or, + Dest + ("CU0",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state")))), + Mop(Fst, + Apply + (Const("KernelMode",ATy(qTy,PTy(bTy,qTy))),qVar"state"))), + Let(qVar"s", + Mop(Snd, + Apply + (Call("write'LLbit",ATy(qTy,PTy(uTy,qTy)),Mop(Some,LF)), + ITE(Dest + ("ERL",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state")))), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'PC",ATy(qTy,PTy(uTy,qTy)), + Bop(Sub, + Dest + ("ErrorEPC",F64, + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"state"))),LW(4,64))), + qVar"state")), + Let(Var("v",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__",qTy))), + qVar"s")), + Mop(Snd, + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Status", + TP[Var("v",CTy"CP0__renamed__"), + Rupd + ("ERL", + TP[Dest + ("Status", + CTy"StatusRegister", + Var("v", + CTy"CP0__renamed__")), + LF])])),qVar"s")))), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'PC",ATy(qTy,PTy(uTy,qTy)), + Bop(Sub, + Dest + ("EPC",F64, + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"state"))),LW(4,64))), + qVar"state")), + Let(Var("v",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__",qTy))), + qVar"s")), + Mop(Snd, + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Status", + TP[Var("v",CTy"CP0__renamed__"), + Rupd + ("EXL", + TP[Dest + ("Status", + CTy"StatusRegister", + Var("v", + CTy"CP0__renamed__")), + LF])])),qVar"s"))))))), + Apply + (Call + ("write'PCC",ATy(qTy,PTy(uTy,qTy)), + Mop(Fst, + Apply + (Const("EPCC",ATy(qTy,PTy(CTy"Capability",qTy))), + qVar"s"))),qVar"s")), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("CpU",CTy"ExceptionType")),qVar"state"))) +; +val TLBEntries_def = Def0 ("TLBEntries",LN 16) +; +val TLB_direct_def = Def + ("TLB_direct",Var("i",FTy 7), + Close + (qVar"state", + TP[Apply + (Apply + (Dest + ("c_TLB_direct",ATy(F8,ATy(FTy 7,CTy"TLBEntry")), + qVar"state"),Dest("procID",F8,qVar"state")), + Var("i",FTy 7)),qVar"state"])) +; +val write'TLB_direct_def = Def + ("write'TLB_direct",TP[Var("value",CTy"TLBEntry"),Var("i",FTy 7)], + Close + (qVar"state", + TP[LU, + Let(Var("s",PTy(ATy(FTy 7,CTy"TLBEntry"),qTy)), + TP[Fupd + (Apply + (Dest + ("c_TLB_direct",ATy(F8,ATy(FTy 7,CTy"TLBEntry")), + qVar"state"),Dest("procID",F8,qVar"state")), + Var("i",FTy 7),Var("value",CTy"TLBEntry")),qVar"state"], + Rupd + ("c_TLB_direct", + TP[Mop(Snd,Var("s",PTy(ATy(FTy 7,CTy"TLBEntry"),qTy))), + Fupd + (Dest + ("c_TLB_direct",ATy(F8,ATy(FTy 7,CTy"TLBEntry")), + Mop(Snd, + Var("s",PTy(ATy(FTy 7,CTy"TLBEntry"),qTy)))), + Dest + ("procID",F8, + Mop(Snd, + Var("s",PTy(ATy(FTy 7,CTy"TLBEntry"),qTy)))), + Mop(Fst,Var("s",PTy(ATy(FTy 7,CTy"TLBEntry"),qTy))))]))])) +; +val TLB_assoc_def = Def + ("TLB_assoc",Var("i",F4), + Close + (qVar"state", + TP[Apply + (Apply + (Dest + ("c_TLB_assoc",ATy(F8,ATy(F4,CTy"TLBEntry")),qVar"state"), + Dest("procID",F8,qVar"state")),Var("i",F4)),qVar"state"])) +; +val write'TLB_assoc_def = Def + ("write'TLB_assoc",TP[Var("value",CTy"TLBEntry"),Var("i",F4)], + Close + (qVar"state", + TP[LU, + Let(Var("s",PTy(ATy(F4,CTy"TLBEntry"),qTy)), + TP[Fupd + (Apply + (Dest + ("c_TLB_assoc",ATy(F8,ATy(F4,CTy"TLBEntry")), + qVar"state"),Dest("procID",F8,qVar"state")), + Var("i",F4),Var("value",CTy"TLBEntry")),qVar"state"], + Rupd + ("c_TLB_assoc", + TP[Mop(Snd,Var("s",PTy(ATy(F4,CTy"TLBEntry"),qTy))), + Fupd + (Dest + ("c_TLB_assoc",ATy(F8,ATy(F4,CTy"TLBEntry")), + Mop(Snd,Var("s",PTy(ATy(F4,CTy"TLBEntry"),qTy)))), + Dest + ("procID",F8, + Mop(Snd,Var("s",PTy(ATy(F4,CTy"TLBEntry"),qTy)))), + Mop(Fst,Var("s",PTy(ATy(F4,CTy"TLBEntry"),qTy))))]))])) +; +val LookupTLB_def = Def + ("LookupTLB",TP[Var("r",FTy 2),Var("vpn2",FTy 27)], + Close + (qVar"state", + Let(Var("v",CTy"TLBEntry"), + Mop(Fst, + Apply + (Call + ("TLB_direct",ATy(qTy,PTy(CTy"TLBEntry",qTy)), + EX(Var("vpn2",FTy 27),LN 6,LN 0,FTy 7)),qVar"state")), + Let(Var("nmask",FTy 27), + Mop(BNot, + Mop(Cast(FTy 27), + Dest("Mask",FTy 12,Var("v",CTy"TLBEntry")))), + Let(TP[Var("r",LTy(PTy(F8,CTy"TLBEntry"))), + Var("s1",PTy(LTy(PTy(F8,CTy"TLBEntry")),qTy))], + Let(TP[Var("v0",CTy"CP0__renamed__"), + Var("s",PTy(LTy(PTy(F8,CTy"TLBEntry")),qTy))], + Let(TP[Var("v",CTy"CP0__renamed__"),qVar"s3"], + TP[Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__",qTy))), + qVar"state")),qVar"state"], + TP[Var("v",CTy"CP0__renamed__"), + LNL(PTy(F8,CTy"TLBEntry")),qVar"s3"]), + Let(Var("s",PTy(LTy(PTy(F8,CTy"TLBEntry")),qTy)), + Mop(Snd, + Apply + (For(TP[LN 0, + Bop(Sub,Const("TLBEntries",nTy), + LN 1), + Close + (nVar"i", + Close + (Var("state", + PTy(LTy(PTy(F8, + CTy"TLBEntry")), + qTy)), + Let(TP[Var("v",CTy"TLBEntry"), + Var("s", + PTy(LTy(PTy(F8, + CTy"TLBEntry")), + qTy))], + Let(TP[Var("v", + CTy"TLBEntry"), + qVar"s3"], + TP[Mop(Fst, + Apply + (Call + ("TLB_assoc", + ATy(qTy, + PTy(CTy"TLBEntry", + qTy)), + Mop(Cast + F4, + nVar"i")), + Mop(Snd, + Var("state", + PTy(LTy(PTy(F8, + CTy"TLBEntry")), + qTy))))), + Mop(Snd, + Var("state", + PTy(LTy(PTy(F8, + CTy"TLBEntry")), + qTy)))], + TP[Var("v", + CTy"TLBEntry"), + Mop(Fst, + Var("state", + PTy(LTy(PTy(F8, + CTy"TLBEntry")), + qTy))), + qVar"s3"]), + Let(Var("nmask",FTy 27), + Mop(BNot, + Mop(Cast(FTy 27), + Dest + ("Mask", + FTy 12, + Var("v", + CTy"TLBEntry")))), + Let(TP[Var("v0", + CTy"CP0__renamed__"), + Var("s", + PTy(LTy(PTy(F8, + CTy"TLBEntry")), + qTy))], + Let(TP[Var("v", + CTy"CP0__renamed__"), + qVar"s3"], + TP[Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + Mop(Snd, + Var("s", + PTy(LTy(PTy(F8, + CTy"TLBEntry")), + qTy))))), + Mop(Snd, + Var("s", + PTy(LTy(PTy(F8, + CTy"TLBEntry")), + qTy)))], + TP[Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Var("s", + PTy(LTy(PTy(F8, + CTy"TLBEntry")), + qTy))), + qVar"s3"]), + TP[LU, + ITE(Bop(And, + Bop(And, + EQ(Bop(BAnd, + Dest + ("VPN2", + FTy 27, + Var("v", + CTy"TLBEntry")), + Var("nmask", + FTy 27)), + Bop(BAnd, + Var("vpn2", + FTy 27), + Var("nmask", + FTy 27))), + EQ(Dest + ("R", + FTy 2, + Var("v", + CTy"TLBEntry")), + Var("r", + FTy 2))), + Bop(Or, + Dest + ("G", + bTy, + Var("v", + CTy"TLBEntry")), + EQ(Dest + ("ASID", + F8, + Var("v", + CTy"TLBEntry")), + Dest + ("ASID", + F8, + Dest + ("EntryHi", + CTy"EntryHi", + Var("v0", + CTy"CP0__renamed__")))))), + TP[LLC([TP[Mop(Cast + F8, + nVar"i"), + Var("v", + CTy"TLBEntry")]], + Mop(Fst, + Var("s", + PTy(LTy(PTy(F8, + CTy"TLBEntry")), + qTy)))), + Mop(Snd, + Var("s", + PTy(LTy(PTy(F8, + CTy"TLBEntry")), + qTy)))], + Var("s", + PTy(LTy(PTy(F8, + CTy"TLBEntry")), + qTy)))])))))]), + ITE(Dest + ("LTLB",bTy, + Dest + ("Config6",CTy"ConfigRegister6", + Var("v0",CTy"CP0__renamed__"))), + Let(TP[Var("v0",CTy"CP0__renamed__"), + Var("s", + PTy(LTy(PTy(F8, + CTy"TLBEntry")), + qTy))], + Let(TP[Var("v", + CTy"CP0__renamed__"), + qVar"s3"], + TP[Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + Mop(Snd, + Var("s", + PTy(LTy(PTy(F8, + CTy"TLBEntry")), + qTy))))), + Mop(Snd, + Var("s", + PTy(LTy(PTy(F8, + CTy"TLBEntry")), + qTy)))], + TP[Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Var("s", + PTy(LTy(PTy(F8, + CTy"TLBEntry")), + qTy))), + qVar"s3"]), + TP[ITE(Bop(And, + Bop(And, + EQ(Bop(BAnd, + Dest + ("VPN2", + FTy 27, + Var("v", + CTy"TLBEntry")), + Var("nmask", + FTy 27)), + Bop(BAnd, + Var("vpn2", + FTy 27), + Var("nmask", + FTy 27))), + EQ(Dest + ("R",FTy 2, + Var("v", + CTy"TLBEntry")), + Var("r",FTy 2))), + Bop(Or, + Dest + ("G",bTy, + Var("v", + CTy"TLBEntry")), + EQ(Dest + ("ASID",F8, + Var("v", + CTy"TLBEntry")), + Dest + ("ASID",F8, + Dest + ("EntryHi", + CTy"EntryHi", + Var("v0", + CTy"CP0__renamed__")))))), + LL[TP[ITE(Bop(Ge, + Mop(Cast nTy, + EX(Var("vpn2", + FTy 27), + LN 6, + LN 0, + FTy 7)), + Const + ("TLBEntries", + nTy)), + Mop(Cast F8, + EX(Var("vpn2", + FTy 27), + LN 6, + LN 0, + FTy 7)), + Bop(Add, + LW(128,8), + Mop(Cast F8, + EX(Var("vpn2", + FTy 27), + LN 6, + LN 0, + FTy 7)))), + Var("v", + CTy"TLBEntry")]], + LNL(PTy(F8,CTy"TLBEntry"))), + Mop(Snd, + Var("s", + PTy(LTy(PTy(F8, + CTy"TLBEntry")), + qTy)))]), + Var("s", + PTy(LTy(PTy(F8,CTy"TLBEntry")), + qTy))))), + TP[Mop(Fst, + Var("s", + PTy(LTy(PTy(F8,CTy"TLBEntry")),qTy))), + Var("s",PTy(LTy(PTy(F8,CTy"TLBEntry")),qTy))])), + TP[Var("r",LTy(PTy(F8,CTy"TLBEntry"))), + Mop(Snd,Var("s1",PTy(LTy(PTy(F8,CTy"TLBEntry")),qTy)))]))))) +; +val SignalTLBException_def = Def + ("SignalTLBException", + TP[Var("e",CTy"ExceptionType"),Var("asid",F8),Var("vAddr",F64)], + Close + (qVar"state", + Let(Var("r",FTy 2),EX(Var("vAddr",F64),LN 63,LN 62,FTy 2), + Let(Var("vpn2",FTy 27),EX(Var("vAddr",F64),LN 39,LN 13,FTy 27), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + Var("e",CTy"ExceptionType")),qVar"state")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("BadVAddr", + TP[Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))),qVar"s")), + Var("vAddr",F64)])),qVar"s")), + Let(Var("v",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("EntryHi", + TP[Var("v",CTy"CP0__renamed__"), + Rupd + ("R", + TP[Dest + ("EntryHi", + CTy"EntryHi", + Var("v", + CTy"CP0__renamed__")), + Var("r",FTy 2)])])), + qVar"s")), + Let(Var("v",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))),qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy,PTy(uTy,qTy)), + Rupd + ("EntryHi", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("VPN2", + TP[Dest + ("EntryHi", + CTy"EntryHi", + Var("v", + CTy"CP0__renamed__")), + Var("vpn2", + FTy 27)])])), + qVar"s")), + Let(Var("v",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))),qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy,qTy)), + Rupd + ("EntryHi", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("ASID", + TP[Dest + ("EntryHi", + CTy"EntryHi", + Var("v", + CTy"CP0__renamed__")), + Var("asid", + F8)])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("XContext", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("R", + TP[Dest + ("XContext", + CTy"XContext", + Var("v", + CTy"CP0__renamed__")), + Var("r", + FTy 2)])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("XContext", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("BadVPN2", + TP[Dest + ("XContext", + CTy"XContext", + Var("v", + CTy"CP0__renamed__")), + Var("vpn2", + FTy 27)])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + TP[LX(PTy(FTy 40, + FTy 3)), + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Context", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("BadVPN2", + TP[Dest + ("Context", + CTy"Context", + Var("v", + CTy"CP0__renamed__")), + EX(Var("vAddr", + F64), + LN + 31, + LN + 13, + FTy 19)])])), + qVar"s"))]))))))))))))))))) +; +val CheckSegment_def = Def + ("CheckSegment",Var("vAddr",F64), + Close + (qVar"state", + TP[ITB([(Mop(Fst, + Apply + (Const("UserMode",ATy(qTy,PTy(bTy,qTy))),qVar"state")), + TP[LO(PTy(FTy 40,FTy 3)), + Bop(Ult,Var("vAddr",F64),LW(1099511627776,64))]), + (Mop(Fst, + Apply + (Const("SupervisorMode",ATy(qTy,PTy(bTy,qTy))), + qVar"state")), + TP[LO(PTy(FTy 40,FTy 3)), + Bop(Or, + Bop(Or, + Bop(Ult,Var("vAddr",F64),LW(1099511627776,64)), + Bop(And, + Bop(Ule,Var("vAddr",F64), + LW(4611686018427387904,64)), + Bop(Ult,Var("vAddr",F64), + LW(4611687117939015680,64)))), + Bop(And, + Bop(Ule,Var("vAddr",F64), + LW(18446744072635809792,64)), + Bop(Ult,Var("vAddr",F64), + LW(18446744073172680704,64))))]), + (Bop(Ult,Var("vAddr",F64),LW(1099511627776,64)), + TP[LO(PTy(FTy 40,FTy 3)),LT]), + (Bop(And, + Bop(Ule,LW(4611686018427387904,64),Var("vAddr",F64)), + Bop(Ult,Var("vAddr",F64),LW(4611687117939015680,64))), + TP[LO(PTy(FTy 40,FTy 3)),LT]), + (Bop(And, + Bop(Ule,LW(9223372036854775808,64),Var("vAddr",F64)), + Bop(Ult,Var("vAddr",F64),LW(13835058055282163712,64))), + TP[Mop(Some, + TP[EX(Var("vAddr",F64),LN 39,LN 0,FTy 40), + EX(Var("vAddr",F64),LN 61,LN 59,FTy 3)]), + EQ(EX(Var("vAddr",F64),LN 58,LN 40,FTy 19),LW(0,19))]), + (Bop(And, + Bop(Ule,LW(13835058055282163712,64),Var("vAddr",F64)), + Bop(Ult,Var("vAddr",F64),LW(13835059152646307840,64))), + TP[LO(PTy(FTy 40,FTy 3)),LT]), + (Bop(And, + Bop(Ule,LW(18446744071562067968,64),Var("vAddr",F64)), + Bop(Ult,Var("vAddr",F64),LW(18446744072098938880,64))), + TP[Mop(Some, + TP[Bop(Sub,EX(Var("vAddr",F64),LN 39,LN 0,FTy 40), + LW(1097364144128,40)), + Dest + ("K0",FTy 3, + Dest + ("Config",CTy"ConfigRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))]),LT]), + (Bop(And, + Bop(Ule,LW(18446744072098938880,64),Var("vAddr",F64)), + Bop(Ult,Var("vAddr",F64),LW(18446744072635809792,64))), + TP[Mop(Some, + TP[Bop(Sub,EX(Var("vAddr",F64),LN 39,LN 0,FTy 40), + LW(1097901015040,40)),LW(2,3)]),LT])], + TP[LO(PTy(FTy 40,FTy 3)), + Bop(Ule,LW(18446744072635809792,64),Var("vAddr",F64))]), + qVar"state"])) +; +val AddressTranslation_def = Def + ("AddressTranslation", + TP[Var("vAddr",F64),Var("IorD",CTy"IorD"), + Var("AccessType",CTy"AccessType")], + Close + (qVar"state", + Let(TP[Var("unmapped",OTy(PTy(FTy 40,FTy 3))),bVar"valid"], + Mop(Fst, + Apply + (Call + ("CheckSegment", + ATy(qTy,PTy(PTy(OTy(PTy(FTy 40,FTy 3)),bTy),qTy)), + Var("vAddr",F64)),qVar"state")), + ITE(bVar"valid", + CS(Var("unmapped",OTy(PTy(FTy 40,FTy 3))), + [(Mop(Some,TP[Var("pAddr",FTy 40),Var("cca",FTy 3)]), + TP[TP[Var("pAddr",FTy 40),Var("cca",FTy 3),LF,LF], + qVar"state"]), + (LO(PTy(FTy 40,FTy 3)), + CS(Mop(Fst, + Apply + (Call + ("LookupTLB", + ATy(qTy, + PTy(LTy(PTy(F8,CTy"TLBEntry")),qTy)), + TP[EX(Var("vAddr",F64),LN 63,LN 62,FTy 2), + EX(Var("vAddr",F64),LN 39,LN 13,FTy 27)]), + qVar"state")), + [(LNL(PTy(F8,CTy"TLBEntry")), + Let(TP[Var("v",PTy(FTy 40,FTy 3)),qVar"s"], + Apply + (Call + ("SignalTLBException", + ATy(qTy,PTy(PTy(FTy 40,FTy 3),qTy)), + TP[ITE(EQ(Var("AccessType", + CTy"AccessType"), + LC("LOAD",CTy"AccessType")), + LC("XTLBRefillL", + CTy"ExceptionType"), + LC("XTLBRefillS", + CTy"ExceptionType")), + Dest + ("ASID",F8, + Dest + ("EntryHi",CTy"EntryHi", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"state")))), + Var("vAddr",F64)]),qVar"state"), + TP[LX(PTy(FTy 40,PTy(FTy 3,PTy(bTy,bTy)))), + qVar"s"])), + (LL[TP[AVar F8,Var("e",CTy"TLBEntry")]], + Let(TP[nVar"v",qVar"s"], + CS(Dest("Mask",FTy 12,Var("e",CTy"TLBEntry")), + [(LW(0,12),TP[LN 12,qVar"state"]), + (LW(3,12),TP[LN 14,qVar"state"]), + (LW(15,12),TP[LN 16,qVar"state"]), + (LW(63,12),TP[LN 18,qVar"state"]), + (LW(255,12),TP[LN 20,qVar"state"]), + (LW(1023,12),TP[LN 22,qVar"state"]), + (LW(4095,12),TP[LN 24,qVar"state"]), + (AVar(FTy 12), + Apply + (Call + ("raise'exception", + ATy(qTy,PTy(nTy,qTy)), + Call + ("UNPREDICTABLE",CTy"exception", + LS"TLB: bad mask")),qVar"state"))]), + Let(TP[bVar"S",bVar"L",Var("PFN",FTy 28), + Var("C",FTy 3),bVar"D",bVar"V"], + ITE(Bop(Bit,Var("vAddr",F64),nVar"v"), + TP[Dest + ("S1",bTy,Var("e",CTy"TLBEntry")), + Dest + ("L1",bTy,Var("e",CTy"TLBEntry")), + Dest + ("PFN1",FTy 28, + Var("e",CTy"TLBEntry")), + Dest + ("C1",FTy 3, + Var("e",CTy"TLBEntry")), + Dest + ("D1",bTy,Var("e",CTy"TLBEntry")), + Dest + ("V1",bTy,Var("e",CTy"TLBEntry"))], + TP[Dest + ("S0",bTy,Var("e",CTy"TLBEntry")), + Dest + ("L0",bTy,Var("e",CTy"TLBEntry")), + Dest + ("PFN0",FTy 28, + Var("e",CTy"TLBEntry")), + Dest + ("C0",FTy 3, + Var("e",CTy"TLBEntry")), + Dest + ("D0",bTy,Var("e",CTy"TLBEntry")), + Dest + ("V0",bTy,Var("e",CTy"TLBEntry"))]), + ITE(bVar"V", + ITE(Bop(And,Mop(Not,bVar"D"), + EQ(Var("AccessType", + CTy"AccessType"), + LC("STORE",CTy"AccessType"))), + Let(TP[Var("v",PTy(FTy 40,FTy 3)), + qVar"s"], + Apply + (Call + ("SignalTLBException", + ATy(qTy, + PTy(PTy(FTy 40,FTy 3), + qTy)), + TP[LC("Mod", + CTy"ExceptionType"), + Dest + ("ASID",F8, + Var("e", + CTy"TLBEntry")), + Var("vAddr",F64)]), + qVar"s"), + TP[LX(PTy(FTy 40, + PTy(FTy 3, + PTy(bTy,bTy)))), + qVar"s"]), + TP[TP[Mop(Cast(FTy 40), + CC[EX(Mop(Cast vTy, + Var("PFN", + FTy 28)), + LN 27, + Bop(Sub,nVar"v", + LN 12),vTy), + EX(Mop(Cast vTy, + Var("vAddr", + F64)), + Bop(Sub,nVar"v", + LN 1),LN 0,vTy)]), + Var("C",FTy 3),bVar"S", + bVar"L"],qVar"s"]), + Let(TP[Var("v",PTy(FTy 40,FTy 3)), + qVar"s"], + Apply + (Call + ("SignalTLBException", + ATy(qTy, + PTy(PTy(FTy 40,FTy 3), + qTy)), + TP[ITE(EQ(Var("AccessType", + CTy"AccessType"), + LC("LOAD", + CTy"AccessType")), + LC("TLBL", + CTy"ExceptionType"), + LC("TLBS", + CTy"ExceptionType")), + Dest + ("ASID",F8, + Var("e",CTy"TLBEntry")), + Var("vAddr",F64)]), + qVar"s"), + TP[LX(PTy(FTy 40, + PTy(FTy 3,PTy(bTy,bTy)))), + qVar"s"]))))), + (AVar(LTy(PTy(F8,CTy"TLBEntry"))), + Apply + (Call + ("raise'exception", + ATy(qTy, + PTy(PTy(FTy 40,PTy(FTy 3,PTy(bTy,bTy))), + qTy)), + Call + ("UNPREDICTABLE",CTy"exception", + LS"TLB: multiple matches")),qVar"state"))]))]), + TP[LX(PTy(FTy 40,PTy(FTy 3,PTy(bTy,bTy)))), + Mop(Snd, + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + ITE(EQ(Var("AccessType",CTy"AccessType"), + LC("LOAD",CTy"AccessType")), + LC("AdEL",CTy"ExceptionType"), + LC("AdES",CTy"ExceptionType"))), + Mop(Snd, + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("BadVAddr", + TP[Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"state")), + Bop(Add, + Dest + ("base",F64, + Mop(Fst, + Apply + (Const + ("PCC", + ATy(qTy, + PTy(CTy"Capability", + qTy))), + qVar"state"))), + Var("vAddr",F64))])), + qVar"state"))))])))) +; +val ModifyTLB_def = Def + ("ModifyTLB",Var("ie",CTy"TLBEntry"), + Close + (qVar"state", + Let(Var("v",CTy"EntryHi"), + Dest + ("EntryHi",CTy"EntryHi", + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))), + Let(Var("v0",CTy"EntryLo"), + Dest + ("EntryLo1",CTy"EntryLo", + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))), + Let(Var("v1",CTy"EntryLo"), + Dest + ("EntryLo0",CTy"EntryLo", + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))), + Let(TP[Var("r",CTy"TLBEntry"), + Var("s1",PTy(CTy"TLBEntry",qTy))], + Let(Var("s",PTy(CTy"TLBEntry",qTy)), + TP[Var("ie",CTy"TLBEntry"),qVar"state"], + Let(Var("s",PTy(CTy"TLBEntry",qTy)), + Let(TP[Var("v",CTy"TLBEntry"), + Var("s",PTy(CTy"TLBEntry",qTy))], + Let(TP[Var("v",PTy(CTy"TLBEntry",FTy 12)), + Var("s",PTy(CTy"TLBEntry",qTy))], + Let(TP[Var("v0",CTy"CP0__renamed__"), + Var("s", + PTy(CTy"TLBEntry",qTy))], + Let(TP[Var("v", + CTy"CP0__renamed__"), + qVar"s3"], + TP[Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + Mop(Snd, + Var("s", + PTy(CTy"TLBEntry", + qTy))))), + Mop(Snd, + Var("s", + PTy(CTy"TLBEntry", + qTy)))], + TP[Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Var("s", + PTy(CTy"TLBEntry", + qTy))), + qVar"s3"]), + TP[TP[Var("ie",CTy"TLBEntry"), + Dest + ("Mask",FTy 12, + Dest + ("PageMask", + CTy"PageMask", + Var("v0", + CTy"CP0__renamed__")))], + Var("s", + PTy(CTy"TLBEntry",qTy))]), + TP[Rupd + ("Mask", + Var("v", + PTy(CTy"TLBEntry",FTy 12))), + Var("s",PTy(CTy"TLBEntry",qTy))]), + TP[Var("v",CTy"TLBEntry"), + Mop(Snd, + Var("s",PTy(CTy"TLBEntry",qTy)))]), + Let(Var("s",PTy(CTy"TLBEntry",qTy)), + TP[Rupd + ("R", + TP[Mop(Fst, + Var("s", + PTy(CTy"TLBEntry",qTy))), + Dest + ("R",FTy 2, + Var("v",CTy"EntryHi"))]), + Mop(Snd, + Var("s",PTy(CTy"TLBEntry",qTy)))], + Let(Var("s",PTy(CTy"TLBEntry",qTy)), + TP[Rupd + ("VPN2", + TP[Mop(Fst, + Var("s", + PTy(CTy"TLBEntry", + qTy))), + Dest + ("VPN2",FTy 27, + Var("v",CTy"EntryHi"))]), + Mop(Snd, + Var("s", + PTy(CTy"TLBEntry",qTy)))], + Let(Var("s",PTy(CTy"TLBEntry",qTy)), + TP[Rupd + ("ASID", + TP[Mop(Fst, + Var("s", + PTy(CTy"TLBEntry", + qTy))), + Dest + ("ASID",F8, + Var("v",CTy"EntryHi"))]), + Mop(Snd, + Var("s", + PTy(CTy"TLBEntry",qTy)))], + Let(Var("s", + PTy(CTy"TLBEntry",qTy)), + TP[Rupd + ("S1", + TP[Mop(Fst, + Var("s", + PTy(CTy"TLBEntry", + qTy))), + Dest + ("S",bTy, + Var("v0", + CTy"EntryLo"))]), + Mop(Snd, + Var("s", + PTy(CTy"TLBEntry", + qTy)))], + Let(Var("s", + PTy(CTy"TLBEntry", + qTy)), + TP[Rupd + ("L1", + TP[Mop(Fst, + Var("s", + PTy(CTy"TLBEntry", + qTy))), + Dest + ("L",bTy, + Var("v0", + CTy"EntryLo"))]), + Mop(Snd, + Var("s", + PTy(CTy"TLBEntry", + qTy)))], + Let(Var("s", + PTy(CTy"TLBEntry", + qTy)), + TP[Rupd + ("PFN1", + TP[Mop(Fst, + Var("s", + PTy(CTy"TLBEntry", + qTy))), + Dest + ("PFN", + FTy 28, + Var("v0", + CTy"EntryLo"))]), + Mop(Snd, + Var("s", + PTy(CTy"TLBEntry", + qTy)))], + Let(Var("s", + PTy(CTy"TLBEntry", + qTy)), + TP[Rupd + ("C1", + TP[Mop(Fst, + Var("s", + PTy(CTy"TLBEntry", + qTy))), + Dest + ("C", + FTy 3, + Var("v0", + CTy"EntryLo"))]), + Mop(Snd, + Var("s", + PTy(CTy"TLBEntry", + qTy)))], + Let(Var("s", + PTy(CTy"TLBEntry", + qTy)), + TP[Rupd + ("D1", + TP[Mop(Fst, + Var("s", + PTy(CTy"TLBEntry", + qTy))), + Dest + ("D", + bTy, + Var("v0", + CTy"EntryLo"))]), + Mop(Snd, + Var("s", + PTy(CTy"TLBEntry", + qTy)))], + Let(Var("s", + PTy(CTy"TLBEntry", + qTy)), + TP[Rupd + ("V1", + TP[Mop(Fst, + Var("s", + PTy(CTy"TLBEntry", + qTy))), + Dest + ("V", + bTy, + Var("v0", + CTy"EntryLo"))]), + Mop(Snd, + Var("s", + PTy(CTy"TLBEntry", + qTy)))], + Let(Var("s", + PTy(CTy"TLBEntry", + qTy)), + TP[Rupd + ("G", + TP[Mop(Fst, + Var("s", + PTy(CTy"TLBEntry", + qTy))), + Bop(And, + Dest + ("G", + bTy, + Var("v0", + CTy"EntryLo")), + Dest + ("G", + bTy, + Var("v1", + CTy"EntryLo")))]), + Mop(Snd, + Var("s", + PTy(CTy"TLBEntry", + qTy)))], + Let(Var("s", + PTy(CTy"TLBEntry", + qTy)), + TP[Rupd + ("S0", + TP[Mop(Fst, + Var("s", + PTy(CTy"TLBEntry", + qTy))), + Dest + ("S", + bTy, + Var("v1", + CTy"EntryLo"))]), + Mop(Snd, + Var("s", + PTy(CTy"TLBEntry", + qTy)))], + Let(Var("s", + PTy(CTy"TLBEntry", + qTy)), + TP[Rupd + ("L0", + TP[Mop(Fst, + Var("s", + PTy(CTy"TLBEntry", + qTy))), + Dest + ("L", + bTy, + Var("v1", + CTy"EntryLo"))]), + Mop(Snd, + Var("s", + PTy(CTy"TLBEntry", + qTy)))], + Let(Var("s", + PTy(CTy"TLBEntry", + qTy)), + TP[Rupd + ("PFN0", + TP[Mop(Fst, + Var("s", + PTy(CTy"TLBEntry", + qTy))), + Dest + ("PFN", + FTy 28, + Var("v1", + CTy"EntryLo"))]), + Mop(Snd, + Var("s", + PTy(CTy"TLBEntry", + qTy)))], + Let(Var("s", + PTy(CTy"TLBEntry", + qTy)), + TP[Rupd + ("C0", + TP[Mop(Fst, + Var("s", + PTy(CTy"TLBEntry", + qTy))), + Dest + ("C", + FTy 3, + Var("v1", + CTy"EntryLo"))]), + Mop(Snd, + Var("s", + PTy(CTy"TLBEntry", + qTy)))], + Let(Var("s", + PTy(CTy"TLBEntry", + qTy)), + TP[Rupd + ("D0", + TP[Mop(Fst, + Var("s", + PTy(CTy"TLBEntry", + qTy))), + Dest + ("D", + bTy, + Var("v1", + CTy"EntryLo"))]), + Mop(Snd, + Var("s", + PTy(CTy"TLBEntry", + qTy)))], + Let(Var("s", + PTy(CTy"TLBEntry", + qTy)), + TP[Rupd + ("V0", + TP[Mop(Fst, + Var("s", + PTy(CTy"TLBEntry", + qTy))), + Dest + ("V", + bTy, + Var("v1", + CTy"EntryLo"))]), + Mop(Snd, + Var("s", + PTy(CTy"TLBEntry", + qTy)))], + TP[Mop(Fst, + Var("s", + PTy(CTy"TLBEntry", + qTy))), + Var("s", + PTy(CTy"TLBEntry", + qTy))])))))))))))))))))), + TP[Var("r",CTy"TLBEntry"), + Mop(Snd,Var("s1",PTy(CTy"TLBEntry",qTy)))])))))) +; +val dfn'TLBR_def = Def + ("dfn'TLBR",qVar"state", + ITE(Bop(And, + Mop(Not, + Dest + ("CU0",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))), + Mop(Not, + Mop(Fst, + Apply + (Const("KernelMode",ATy(qTy,PTy(bTy,qTy))), + qVar"state")))), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("CpU",CTy"ExceptionType")),qVar"state"), + Let(Var("v",F8), + Dest + ("Index",F8, + Dest + ("Index",CTy"Index", + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state")))), + Let(Var("v",CTy"TLBEntry"), + ITE(Bop(Ge,Mop(Cast nTy,Var("v",F8)), + Const("TLBEntries",nTy)), + Mop(Fst, + Apply + (Call + ("TLB_direct",ATy(qTy,PTy(CTy"TLBEntry",qTy)), + EX(Var("v",F8),LN 6,LN 0,FTy 7)),qVar"state")), + Mop(Fst, + Apply + (Call + ("TLB_assoc",ATy(qTy,PTy(CTy"TLBEntry",qTy)), + Mop(Cast F4,Var("v",F8))),qVar"state"))), + Let(Var("v0",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("PageMask", + TP[Var("v0",CTy"CP0__renamed__"), + Rupd + ("Mask", + TP[Dest + ("PageMask",CTy"PageMask", + Var("v0", + CTy"CP0__renamed__")), + Dest + ("Mask",FTy 12, + Var("v",CTy"TLBEntry"))])])), + qVar"state")), + Let(Var("v0",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy,PTy(uTy,qTy)), + Rupd + ("EntryHi", + TP[Var("v0", + CTy"CP0__renamed__"), + Rupd + ("R", + TP[Dest + ("EntryHi", + CTy"EntryHi", + Var("v0", + CTy"CP0__renamed__")), + Dest + ("R",FTy 2, + Var("v", + CTy"TLBEntry"))])])), + qVar"s")), + Let(Var("v0",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))),qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy,PTy(uTy,qTy)), + Rupd + ("EntryHi", + TP[Var("v0", + CTy"CP0__renamed__"), + Rupd + ("VPN2", + TP[Dest + ("EntryHi", + CTy"EntryHi", + Var("v0", + CTy"CP0__renamed__")), + Dest + ("VPN2", + FTy 27, + Var("v", + CTy"TLBEntry"))])])), + qVar"s")), + Let(Var("v0",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy,qTy)), + Rupd + ("EntryHi", + TP[Var("v0", + CTy"CP0__renamed__"), + Rupd + ("ASID", + TP[Dest + ("EntryHi", + CTy"EntryHi", + Var("v0", + CTy"CP0__renamed__")), + Dest + ("ASID", + F8, + Var("v", + CTy"TLBEntry"))])])), + qVar"s")), + Let(Var("v0", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("EntryLo1", + TP[Var("v0", + CTy"CP0__renamed__"), + Rupd + ("S", + TP[Dest + ("EntryLo1", + CTy"EntryLo", + Var("v0", + CTy"CP0__renamed__")), + Dest + ("S1", + bTy, + Var("v", + CTy"TLBEntry"))])])), + qVar"s")), + Let(Var("v0", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("EntryLo1", + TP[Var("v0", + CTy"CP0__renamed__"), + Rupd + ("L", + TP[Dest + ("EntryLo1", + CTy"EntryLo", + Var("v0", + CTy"CP0__renamed__")), + Dest + ("L1", + bTy, + Var("v", + CTy"TLBEntry"))])])), + qVar"s")), + Let(Var("v0", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("EntryLo1", + TP[Var("v0", + CTy"CP0__renamed__"), + Rupd + ("PFN", + TP[Dest + ("EntryLo1", + CTy"EntryLo", + Var("v0", + CTy"CP0__renamed__")), + Dest + ("PFN1", + FTy 28, + Var("v", + CTy"TLBEntry"))])])), + qVar"s")), + Let(Var("v0", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("EntryLo1", + TP[Var("v0", + CTy"CP0__renamed__"), + Rupd + ("C", + TP[Dest + ("EntryLo1", + CTy"EntryLo", + Var("v0", + CTy"CP0__renamed__")), + Dest + ("C1", + FTy 3, + Var("v", + CTy"TLBEntry"))])])), + qVar"s")), + Let(Var("v0", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("EntryLo1", + TP[Var("v0", + CTy"CP0__renamed__"), + Rupd + ("D", + TP[Dest + ("EntryLo1", + CTy"EntryLo", + Var("v0", + CTy"CP0__renamed__")), + Dest + ("D1", + bTy, + Var("v", + CTy"TLBEntry"))])])), + qVar"s")), + Let(Var("v0", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("EntryLo1", + TP[Var("v0", + CTy"CP0__renamed__"), + Rupd + ("V", + TP[Dest + ("EntryLo1", + CTy"EntryLo", + Var("v0", + CTy"CP0__renamed__")), + Dest + ("V1", + bTy, + Var("v", + CTy"TLBEntry"))])])), + qVar"s")), + Let(Var("v0", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("EntryLo1", + TP[Var("v0", + CTy"CP0__renamed__"), + Rupd + ("G", + TP[Dest + ("EntryLo1", + CTy"EntryLo", + Var("v0", + CTy"CP0__renamed__")), + Dest + ("G", + bTy, + Var("v", + CTy"TLBEntry"))])])), + qVar"s")), + Let(Var("v0", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("EntryLo0", + TP[Var("v0", + CTy"CP0__renamed__"), + Rupd + ("S", + TP[Dest + ("EntryLo0", + CTy"EntryLo", + Var("v0", + CTy"CP0__renamed__")), + Dest + ("S0", + bTy, + Var("v", + CTy"TLBEntry"))])])), + qVar"s")), + Let(Var("v0", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("EntryLo0", + TP[Var("v0", + CTy"CP0__renamed__"), + Rupd + ("L", + TP[Dest + ("EntryLo0", + CTy"EntryLo", + Var("v0", + CTy"CP0__renamed__")), + Dest + ("L0", + bTy, + Var("v", + CTy"TLBEntry"))])])), + qVar"s")), + Let(Var("v0", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("EntryLo0", + TP[Var("v0", + CTy"CP0__renamed__"), + Rupd + ("PFN", + TP[Dest + ("EntryLo0", + CTy"EntryLo", + Var("v0", + CTy"CP0__renamed__")), + Dest + ("PFN0", + FTy 28, + Var("v", + CTy"TLBEntry"))])])), + qVar"s")), + Let(Var("v0", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("EntryLo0", + TP[Var("v0", + CTy"CP0__renamed__"), + Rupd + ("C", + TP[Dest + ("EntryLo0", + CTy"EntryLo", + Var("v0", + CTy"CP0__renamed__")), + Dest + ("C0", + FTy 3, + Var("v", + CTy"TLBEntry"))])])), + qVar"s")), + Let(Var("v0", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("EntryLo0", + TP[Var("v0", + CTy"CP0__renamed__"), + Rupd + ("D", + TP[Dest + ("EntryLo0", + CTy"EntryLo", + Var("v0", + CTy"CP0__renamed__")), + Dest + ("D0", + bTy, + Var("v", + CTy"TLBEntry"))])])), + qVar"s")), + Let(Var("v0", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("EntryLo0", + TP[Var("v0", + CTy"CP0__renamed__"), + Rupd + ("V", + TP[Dest + ("EntryLo0", + CTy"EntryLo", + Var("v0", + CTy"CP0__renamed__")), + Dest + ("V0", + bTy, + Var("v", + CTy"TLBEntry"))])])), + qVar"s")), + Let(Var("v0", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("EntryLo0", + TP[Var("v0", + CTy"CP0__renamed__"), + Rupd + ("G", + TP[Dest + ("EntryLo0", + CTy"EntryLo", + Var("v0", + CTy"CP0__renamed__")), + Dest + ("G", + bTy, + Var("v", + CTy"TLBEntry"))])])), + qVar"s")))))))))))))))))))))))))))))))))))))))) +; +val dfn'TLBP_def = Def + ("dfn'TLBP",qVar"state", + ITE(Bop(And, + Mop(Not, + Dest + ("CU0",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))), + Mop(Not, + Mop(Fst, + Apply + (Const("KernelMode",ATy(qTy,PTy(bTy,qTy))), + qVar"state")))), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("CpU",CTy"ExceptionType")),qVar"state"), + CS(Mop(Fst, + Apply + (Call + ("LookupTLB", + ATy(qTy,PTy(LTy(PTy(F8,CTy"TLBEntry")),qTy)), + TP[Dest + ("R",FTy 2, + Dest + ("EntryHi",CTy"EntryHi", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__",qTy))), + qVar"state")))), + Dest + ("VPN2",FTy 27, + Dest + ("EntryHi",CTy"EntryHi", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))]),qVar"state")), + [(LNL(PTy(F8,CTy"TLBEntry")), + Let(Var("v",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Index", + TP[Var("v",CTy"CP0__renamed__"), + Rupd + ("P", + TP[Dest + ("Index",CTy"Index", + Var("v",CTy"CP0__renamed__")), + LT])])),qVar"state")), + Let(Var("v",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"s")), + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Index", + TP[Var("v",CTy"CP0__renamed__"), + Rupd + ("Index", + TP[Dest + ("Index",CTy"Index", + Var("v",CTy"CP0__renamed__")), + LX F8])])),qVar"s"))))), + (LL[TP[Var("i",F8),Var("e",CTy"TLBEntry")]], + Let(Var("v",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Index", + TP[Var("v",CTy"CP0__renamed__"), + Rupd + ("P", + TP[Dest + ("Index",CTy"Index", + Var("v",CTy"CP0__renamed__")), + LF])])),qVar"state")), + Let(Var("v",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"s")), + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Index", + TP[Var("v",CTy"CP0__renamed__"), + Rupd + ("Index", + TP[Dest + ("Index",CTy"Index", + Var("v",CTy"CP0__renamed__")), + Var("i",F8)])])),qVar"s"))))), + (AVar(LTy(PTy(F8,CTy"TLBEntry"))), + Apply + (Call + ("raise'exception",ATy(qTy,PTy(uTy,qTy)), + Call + ("UNPREDICTABLE",CTy"exception", + LS"TLB: multiple matches")),qVar"state"))]))) +; +val dfn'TLBWI_def = Def + ("dfn'TLBWI",qVar"state", + ITB([(Bop(And, + Mop(Not, + Dest + ("CU0",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))), + Mop(Not, + Mop(Fst, + Apply + (Const("KernelMode",ATy(qTy,PTy(bTy,qTy))), + qVar"state")))), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("CpU",CTy"ExceptionType")),qVar"state")), + (Bop(Ge, + Mop(Cast nTy, + Dest + ("Index",F8, + Dest + ("Index",CTy"Index", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))),Const("TLBEntries",nTy)), + Let(Var("v",FTy 7), + EX(Dest + ("VPN2",FTy 27, + Dest + ("EntryHi",CTy"EntryHi", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state")))),LN 6,LN 0,FTy 7), + Apply + (Call + ("write'TLB_direct",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Fst, + Apply + (Call + ("ModifyTLB", + ATy(qTy,PTy(CTy"TLBEntry",qTy)), + Mop(Fst, + Apply + (Call + ("TLB_direct", + ATy(qTy,PTy(CTy"TLBEntry",qTy)), + Var("v",FTy 7)),qVar"state"))), + qVar"state")),Var("v",FTy 7)]),qVar"state")))], + Let(Var("v",F4), + Mop(Cast F4, + Dest + ("Index",F8, + Dest + ("Index",CTy"Index", + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))), + Apply + (Call + ("write'TLB_assoc",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Fst, + Apply + (Call + ("ModifyTLB",ATy(qTy,PTy(CTy"TLBEntry",qTy)), + Mop(Fst, + Apply + (Call + ("TLB_assoc", + ATy(qTy,PTy(CTy"TLBEntry",qTy)), + Var("v",F4)),qVar"state"))), + qVar"state")),Var("v",F4)]),qVar"state")))) +; +val dfn'TLBWR_def = Def + ("dfn'TLBWR",qVar"state", + ITB([(Bop(And, + Mop(Not, + Dest + ("CU0",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))), + Mop(Not, + Mop(Fst, + Apply + (Const("KernelMode",ATy(qTy,PTy(bTy,qTy))), + qVar"state")))), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("CpU",CTy"ExceptionType")),qVar"state")), + (Dest + ("LTLB",bTy, + Dest + ("Config6",CTy"ConfigRegister6", + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state")))), + Let(Var("v",FTy 7), + EX(Dest + ("VPN2",FTy 27, + Dest + ("EntryHi",CTy"EntryHi", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state")))),LN 6,LN 0,FTy 7), + Let(Var("v0",CTy"TLBEntry"), + Mop(Fst, + Apply + (Call + ("TLB_direct",ATy(qTy,PTy(CTy"TLBEntry",qTy)), + Var("v",FTy 7)),qVar"state")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'TLB_direct",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Fst, + Apply + (Call + ("ModifyTLB", + ATy(qTy,PTy(CTy"TLBEntry",qTy)), + Var("v0",CTy"TLBEntry")), + qVar"state")),Var("v",FTy 7)]), + qVar"state")), + ITE(Bop(And,Dest("V0",bTy,Var("v0",CTy"TLBEntry")), + Dest("V1",bTy,Var("v0",CTy"TLBEntry"))), + Apply + (Call + ("write'TLB_assoc",ATy(qTy,PTy(uTy,qTy)), + TP[Var("v0",CTy"TLBEntry"), + Mop(Cast F4, + Dest + ("Random",F8, + Dest + ("Random",CTy"Random", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")))))]),qVar"s"), + TP[LU,qVar"s"])))))], + Let(Var("v",F8), + Dest + ("Random",F8, + Dest + ("Random",CTy"Random", + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state")))), + Apply + (Call + ("write'TLB_assoc",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Fst, + Apply + (Call + ("ModifyTLB",ATy(qTy,PTy(CTy"TLBEntry",qTy)), + Mop(Fst, + Apply + (Call + ("TLB_assoc", + ATy(qTy,PTy(CTy"TLBEntry",qTy)), + Mop(Cast F4,Var("v",F8))), + qVar"state"))),qVar"state")), + Mop(Cast F4,Var("v",F8))]),qVar"state")))) +; +val r_def = Def + ("r",Var("n",FTy 5),CC[LS"$",Mop(Cast sTy,Mop(Cast nTy,Var("n",FTy 5)))]) +; +val c_def = Def + ("c",Var("n",FTy 5),CC[LS", ",Call("r",sTy,Var("n",FTy 5))]) +; +val i_def = Def + ("i",Var("n",BTy"N"), + CC[LS", ",ITE(Bop(Ult,Var("n",BTy"N"),LY(10,"N")),LS"",LS"0x"), + Mop(Cast sTy,Var("n",BTy"N"))]) +; +val oi_def = Def + ("oi",Var("n",BTy"N"), + ITE(EQ(Var("n",BTy"N"),LY(0,"N")),LS"",Call("i",sTy,Var("n",BTy"N")))) +; +val op1i_def = Def + ("op1i",TP[sVar"s",Var("n",BTy"N")], + CC[Mop(PadRight,TP[LSC #" ",LN 12,sVar"s"]),LS"0x", + Mop(Cast sTy,Var("n",BTy"N"))]) +; +val op1r_def = Def + ("op1r",TP[sVar"s",Var("n",FTy 5)], + CC[Mop(PadRight,TP[LSC #" ",LN 12,sVar"s"]), + Call("r",sTy,Var("n",FTy 5))]) +; +val op1ri_def = Def + ("op1ri",TP[sVar"s",Var("r1",FTy 5),Var("n",BTy"N")], + CC[Call("op1r",sTy,TP[sVar"s",Var("r1",FTy 5)]), + Call("i",sTy,Var("n",BTy"N"))]) +; +val op2r_def = Def + ("op2r",TP[sVar"s",Var("r1",FTy 5),Var("r2",FTy 5)], + CC[Call("op1r",sTy,TP[sVar"s",Var("r1",FTy 5)]), + Call("c",sTy,Var("r2",FTy 5))]) +; +val op2ri_def = Def + ("op2ri",TP[sVar"s",Var("r1",FTy 5),Var("r2",FTy 5),Var("n",BTy"N")], + CC[Call("op2r",sTy,TP[sVar"s",Var("r1",FTy 5),Var("r2",FTy 5)]), + Call("i",sTy,Var("n",BTy"N"))]) +; +val op3r_def = Def + ("op3r",TP[sVar"s",Var("r1",FTy 5),Var("r2",FTy 5),Var("r3",FTy 5)], + CC[Call("op2r",sTy,TP[sVar"s",Var("r1",FTy 5),Var("r2",FTy 5)]), + Call("c",sTy,Var("r3",FTy 5))]) +; +val op3ro_def = Def + ("op3ro", + TP[sVar"s",Var("r1",FTy 5),Var("r2",FTy 5),Var("r3",FTy 5), + Var("n",BTy"N")], + CC[Call("op2r",sTy,TP[sVar"s",Var("r1",FTy 5),Var("r2",FTy 5)]), + Call("i",sTy,Var("n",BTy"N")),LS"(",Call("r",sTy,Var("r3",FTy 5)), + LS")"]) +; +val op2roi_def = Def + ("op2roi",TP[sVar"s",Var("r1",FTy 5),Var("r2",FTy 5),Var("n",BTy"N")], + CC[Call("op1r",sTy,TP[sVar"s",Var("r1",FTy 5)]),LS", ", + Call("cpr",sTy,Var("r2",FTy 5)),Call("oi",sTy,Var("n",BTy"N"))]) +; +val opmem_def = Def + ("opmem",TP[sVar"s",Var("r1",FTy 5),Var("r2",FTy 5),Var("n",BTy"N")], + CC[Call("op1ri",sTy,TP[sVar"s",Var("r1",FTy 5),Var("n",BTy"N")]),LS"(", + Call("r",sTy,Var("r2",FTy 5)),LS")"]) +; +val form1_def = Def + ("form1", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5), + Var("function",FTy 6)], + CC[LW(0,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5), + Var("imm5",FTy 5),Var("function",FTy 6)]) +; +val form2_def = Def + ("form2",TP[Var("rs",FTy 5),Var("function",FTy 5),Var("imm",F16)], + CC[LW(1,6),Var("rs",FTy 5),Var("function",FTy 5),Var("imm",F16)]) +; +val form3_def = Def + ("form3", + TP[Var("function",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5), + Var("sel",FTy 3)], + CC[LW(16,6),Var("function",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5), + LW(0,8),Var("sel",FTy 3)]) +; +val form4_def = Def + ("form4", + TP[Var("function",FTy 6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)], + CC[Var("function",FTy 6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)]) +; +val form5_def = Def + ("form5", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5), + Var("function",FTy 6)], + CC[LW(28,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + Var("function",FTy 6)]) +; +val form6_def = Def + ("form6",TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("function",FTy 6)], + CC[LW(31,6),LW(0,5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + Var("function",FTy 6)]) +; +val PSIZE_def = Def0 ("PSIZE",LN 40) +; +val GPR_def = Def + ("GPR",Var("n",FTy 5), + Close + (qVar"state", + TP[ITE(EQ(Var("n",FTy 5),LW(0,5)),LW(0,64), + Mop(Fst, + Apply + (Call("gpr",ATy(qTy,PTy(F64,qTy)),Var("n",FTy 5)), + qVar"state"))),qVar"state"])) +; +val write'GPR_def = Def + ("write'GPR",TP[Var("value",F64),Var("n",FTy 5)], + Close + (qVar"state", + ITE(Mop(Not,EQ(Var("n",FTy 5),LW(0,5))), + Apply + (Call + ("mark_log",ATy(qTy,PTy(uTy,qTy)), + TP[LN 2, + Call + ("log_w_gpr",sTy,TP[Var("n",FTy 5),Var("value",F64)])]), + Mop(Snd, + Apply + (Call + ("write'gpr",ATy(qTy,PTy(uTy,qTy)), + TP[Var("value",F64),Var("n",FTy 5)]),qVar"state"))), + TP[LU,qVar"state"]))) +; +val dumpRegs_def = Def + ("dumpRegs",AVar uTy, + Close + (qVar"state", + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("mark_log",ATy(qTy,PTy(uTy,qTy)), + TP[LN 0,LS"====== Registers ======"]),qVar"state")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("mark_log",ATy(qTy,PTy(uTy,qTy)), + TP[LN 0, + CC[LS"Core = ", + Mop(Cast sTy, + Mop(Cast nTy,Dest("procID",F8,qVar"s")))]]), + qVar"s")), + Apply + (For(TP[LN 0,LN 31, + Close + (nVar"i", + Close + (qVar"state", + Apply + (Call + ("mark_log",ATy(qTy,PTy(uTy,qTy)), + TP[LN 0, + CC[LS"Reg ", + ITE(Bop(Lt,nVar"i",LN 10),LS" ", + LS""),Mop(Cast sTy,nVar"i"), + LS" ", + Call + ("hex64",sTy, + Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy, + PTy(F64,qTy)), + Mop(Cast(FTy 5), + nVar"i")), + qVar"state")))]]), + qVar"state")))]), + Mop(Snd, + Apply + (Call + ("mark_log",ATy(qTy,PTy(uTy,qTy)), + TP[LN 0, + CC[LS"PC ", + Call + ("hex64",sTy, + Mop(Fst, + Apply + (Const + ("PC",ATy(qTy,PTy(F64,qTy))), + qVar"s")))]]),qVar"s"))))))) +; +val HI_def = Def + ("HI",qVar"state", + CS(Mop(Fst,Apply(Const("hi",ATy(qTy,PTy(OTy F64,qTy))),qVar"state")), + [(Mop(Some,Var("v",F64)),TP[Var("v",F64),qVar"state"]), + (LO F64,TP[LX F64,qVar"state"])])) +; +val write'HI_def = Def + ("write'HI",Var("value",F64), + Close + (qVar"state", + Apply + (Call + ("mark_log",ATy(qTy,PTy(uTy,qTy)), + TP[LN 2,Call("log_w_hi",sTy,Var("value",F64))]), + Mop(Snd, + Apply + (Call + ("write'hi",ATy(qTy,PTy(uTy,qTy)), + Mop(Some,Var("value",F64))),qVar"state"))))) +; +val LO_def = Def + ("LO",qVar"state", + CS(Mop(Fst,Apply(Const("lo",ATy(qTy,PTy(OTy F64,qTy))),qVar"state")), + [(Mop(Some,Var("v",F64)),TP[Var("v",F64),qVar"state"]), + (LO F64,TP[LX F64,qVar"state"])])) +; +val write'LO_def = Def + ("write'LO",Var("value",F64), + Close + (qVar"state", + Apply + (Call + ("mark_log",ATy(qTy,PTy(uTy,qTy)), + TP[LN 2,Call("log_w_lo",sTy,Var("value",F64))]), + Mop(Snd, + Apply + (Call + ("write'lo",ATy(qTy,PTy(uTy,qTy)), + Mop(Some,Var("value",F64))),qVar"state"))))) +; +val flip_endian_word_def = Def + ("flip_endian_word",Var("w",F32), + CS(BL(32,Var("w",F32)), + [(TP[bVar"a'7",bVar"a'6",bVar"a'5",bVar"a'4",bVar"a'3",bVar"a'2", + bVar"a'1",bVar"a'0",bVar"b'7",bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1",bVar"b'0",bVar"c'7",bVar"c'6", + bVar"c'5",bVar"c'4",bVar"c'3",bVar"c'2",bVar"c'1",bVar"c'0", + bVar"d'7",bVar"d'6",bVar"d'5",bVar"d'4",bVar"d'3",bVar"d'2", + bVar"d'1",bVar"d'0"], + CC[Mop(Cast F8, + LL[bVar"d'7",bVar"d'6",bVar"d'5",bVar"d'4",bVar"d'3", + bVar"d'2",bVar"d'1",bVar"d'0"]), + Mop(Cast F8, + LL[bVar"c'7",bVar"c'6",bVar"c'5",bVar"c'4",bVar"c'3", + bVar"c'2",bVar"c'1",bVar"c'0"]), + Mop(Cast F8, + LL[bVar"b'7",bVar"b'6",bVar"b'5",bVar"b'4",bVar"b'3", + bVar"b'2",bVar"b'1",bVar"b'0"]), + Mop(Cast F8, + LL[bVar"a'7",bVar"a'6",bVar"a'5",bVar"a'4",bVar"a'3", + bVar"a'2",bVar"a'1",bVar"a'0"])])])) +; +val flip_endian_dword_def = Def + ("flip_endian_dword",Var("dw",F64), + CS(BL(64,Var("dw",F64)), + [(TP[bVar"a'7",bVar"a'6",bVar"a'5",bVar"a'4",bVar"a'3",bVar"a'2", + bVar"a'1",bVar"a'0",bVar"b'7",bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1",bVar"b'0",bVar"c'7",bVar"c'6", + bVar"c'5",bVar"c'4",bVar"c'3",bVar"c'2",bVar"c'1",bVar"c'0", + bVar"d'7",bVar"d'6",bVar"d'5",bVar"d'4",bVar"d'3",bVar"d'2", + bVar"d'1",bVar"d'0",bVar"e'7",bVar"e'6",bVar"e'5",bVar"e'4", + bVar"e'3",bVar"e'2",bVar"e'1",bVar"e'0",bVar"f'7",bVar"f'6", + bVar"f'5",bVar"f'4",bVar"f'3",bVar"f'2",bVar"f'1",bVar"f'0", + bVar"g'7",bVar"g'6",bVar"g'5",bVar"g'4",bVar"g'3",bVar"g'2", + bVar"g'1",bVar"g'0",bVar"h'7",bVar"h'6",bVar"h'5",bVar"h'4", + bVar"h'3",bVar"h'2",bVar"h'1",bVar"h'0"], + CC[Mop(Cast F8, + LL[bVar"h'7",bVar"h'6",bVar"h'5",bVar"h'4",bVar"h'3", + bVar"h'2",bVar"h'1",bVar"h'0"]), + Mop(Cast F8, + LL[bVar"g'7",bVar"g'6",bVar"g'5",bVar"g'4",bVar"g'3", + bVar"g'2",bVar"g'1",bVar"g'0"]), + Mop(Cast F8, + LL[bVar"f'7",bVar"f'6",bVar"f'5",bVar"f'4",bVar"f'3", + bVar"f'2",bVar"f'1",bVar"f'0"]), + Mop(Cast F8, + LL[bVar"e'7",bVar"e'6",bVar"e'5",bVar"e'4",bVar"e'3", + bVar"e'2",bVar"e'1",bVar"e'0"]), + Mop(Cast F8, + LL[bVar"d'7",bVar"d'6",bVar"d'5",bVar"d'4",bVar"d'3", + bVar"d'2",bVar"d'1",bVar"d'0"]), + Mop(Cast F8, + LL[bVar"c'7",bVar"c'6",bVar"c'5",bVar"c'4",bVar"c'3", + bVar"c'2",bVar"c'1",bVar"c'0"]), + Mop(Cast F8, + LL[bVar"b'7",bVar"b'6",bVar"b'5",bVar"b'4",bVar"b'3", + bVar"b'2",bVar"b'1",bVar"b'0"]), + Mop(Cast F8, + LL[bVar"a'7",bVar"a'6",bVar"a'5",bVar"a'4",bVar"a'3", + bVar"a'2",bVar"a'1",bVar"a'0"])])])) +; +val CPR_def = Def + ("CPR",TP[nVar"n",Var("reg",FTy 5),Var("sel",FTy 3)], + Close + (qVar"state", + CS(TP[nVar"n",Var("reg",FTy 5),Var("sel",FTy 3)], + [(TP[LN 0,LW(0,5),LW(0,3)], + TP[Mop(Cast F64, + Call + ("reg'Index",F32, + Dest + ("Index",CTy"Index", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))),qVar"state"]), + (TP[LN 0,LW(1,5),LW(0,3)], + TP[Mop(Cast F64, + Call + ("reg'Random",F32, + Dest + ("Random",CTy"Random", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))),qVar"state"]), + (TP[LN 0,LW(2,5),LW(0,3)], + TP[Call + ("reg'EntryLo",F64, + Dest + ("EntryLo0",CTy"EntryLo", + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state")))),qVar"state"]), + (TP[LN 0,LW(3,5),LW(0,3)], + TP[Call + ("reg'EntryLo",F64, + Dest + ("EntryLo1",CTy"EntryLo", + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state")))),qVar"state"]), + (TP[LN 0,LW(4,5),LW(0,3)], + TP[Call + ("reg'Context",F64, + Dest + ("Context",CTy"Context", + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state")))),qVar"state"]), + (TP[LN 0,LW(4,5),LW(2,3)], + TP[Dest + ("UsrLocal",F64, + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))),qVar"state"]), + (TP[LN 0,LW(5,5),LW(0,3)], + TP[Mop(Cast F64, + Call + ("reg'PageMask",F32, + Dest + ("PageMask",CTy"PageMask", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))),qVar"state"]), + (TP[LN 0,LW(6,5),LW(0,3)], + TP[Mop(Cast F64, + Call + ("reg'Wired",F32, + Dest + ("Wired",CTy"Wired", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))),qVar"state"]), + (TP[LN 0,LW(7,5),LW(0,3)], + TP[Mop(Cast F64, + Call + ("reg'HWREna",F32, + Dest + ("HWREna",CTy"HWREna", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))),qVar"state"]), + (TP[LN 0,LW(8,5),LW(0,3)], + TP[Dest + ("BadVAddr",F64, + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))),qVar"state"]), + (TP[LN 0,LW(8,5),LW(1,3)], + TP[Mop(Cast F64, + Dest + ("EInstr",F32, + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state")))),qVar"state"]), + (TP[LN 0,LW(9,5),LW(0,3)], + TP[Mop(Cast F64, + Dest + ("Count",F32, + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state")))),qVar"state"]), + (TP[LN 0,LW(10,5),LW(0,3)], + TP[Call + ("reg'EntryHi",F64, + Dest + ("EntryHi",CTy"EntryHi", + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state")))),qVar"state"]), + (TP[LN 0,LW(11,5),LW(0,3)], + TP[Mop(Cast F64, + Dest + ("Compare",F32, + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state")))),qVar"state"]), + (TP[LN 0,LW(12,5),LW(0,3)], + TP[Mop(Cast F64, + Call + ("reg'StatusRegister",F32, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))),qVar"state"]), + (TP[LN 0,LW(13,5),LW(0,3)], + TP[Mop(Cast F64, + Call + ("reg'CauseRegister",F32, + Dest + ("Cause",CTy"CauseRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))),qVar"state"]), + (TP[LN 0,LW(14,5),LW(0,3)], + TP[Dest + ("EPC",F64, + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))),qVar"state"]), + (TP[LN 0,LW(15,5),LW(0,3)], + TP[Mop(Cast F64, + Dest + ("PRId",F32, + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state")))),qVar"state"]), + (TP[LN 0,LW(15,5),LW(1,3)], + TP[Mop(Cast F64, + CC[Mop(Cast F16, + Bop(Sub,Dest("totalCore",nTy,qVar"state"),LN 1)), + Mop(Cast F16,Dest("procID",F8,qVar"state"))]), + qVar"state"]), + (TP[LN 0,LW(15,5),LW(6,3)], + TP[Mop(Cast F64, + CC[Mop(Cast F16, + Bop(Sub,Dest("totalCore",nTy,qVar"state"),LN 1)), + Mop(Cast F16,Dest("procID",F8,qVar"state"))]), + qVar"state"]), + (TP[LN 0,LW(16,5),LW(0,3)], + TP[Mop(Cast F64, + Call + ("reg'ConfigRegister",F32, + Dest + ("Config",CTy"ConfigRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))),qVar"state"]), + (TP[LN 0,LW(16,5),LW(1,3)], + TP[Mop(Cast F64, + Call + ("reg'ConfigRegister1",F32, + Dest + ("Config1",CTy"ConfigRegister1", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))),qVar"state"]), + (TP[LN 0,LW(16,5),LW(2,3)], + TP[Mop(Cast F64, + Call + ("reg'ConfigRegister2",F32, + Dest + ("Config2",CTy"ConfigRegister2", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))),qVar"state"]), + (TP[LN 0,LW(16,5),LW(3,3)], + TP[Mop(Cast F64, + Call + ("reg'ConfigRegister3",F32, + Dest + ("Config3",CTy"ConfigRegister3", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))),qVar"state"]), + (TP[LN 0,LW(16,5),LW(4,3)],TP[LW(1,64),qVar"state"]), + (TP[LN 0,LW(16,5),LW(5,3)],TP[LW(1,64),qVar"state"]), + (TP[LN 0,LW(16,5),LW(6,3)], + TP[Mop(Cast F64, + Call + ("reg'ConfigRegister6",F32, + Dest + ("Config6",CTy"ConfigRegister6", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))),qVar"state"]), + (TP[LN 0,LW(17,5),LW(0,3)], + TP[Mop(Cast F64, + Dest + ("LLAddr",F64, + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state")))),qVar"state"]), + (TP[LN 0,LW(20,5),LW(0,3)], + TP[Call + ("reg'XContext",F64, + Dest + ("XContext",CTy"XContext", + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state")))),qVar"state"]), + (TP[LN 0,LW(23,5),LW(0,3)], + TP[Mop(Cast F64, + Dest + ("Debug",F32, + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state")))),qVar"state"]), + (TP[LN 0,LW(26,5),LW(0,3)], + TP[Mop(Cast F64, + Dest + ("ErrCtl",F32, + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state")))),qVar"state"]), + (TP[LN 0,LW(30,5),LW(0,3)], + TP[Dest + ("ErrorEPC",F64, + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))),qVar"state"]), + (AVar(PTy(nTy,PTy(FTy 5,FTy 3))),TP[LX F64,qVar"state"])]))) +; +val write'CPR_def = Def + ("write'CPR", + TP[Var("value",F64),nVar"n",Var("reg",FTy 5),Var("sel",FTy 3)], + Close + (qVar"state", + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("mark_log",ATy(qTy,PTy(uTy,qTy)), + TP[LN 2, + Call + ("log_w_c0",sTy, + TP[Var("reg",FTy 5),Var("value",F64)])]), + qVar"state")), + CS(TP[nVar"n",Var("reg",FTy 5),Var("sel",FTy 3)], + [(TP[LN 0,LW(0,5),LW(0,3)], + Let(Var("v",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"s")), + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Index", + TP[Var("v",CTy"CP0__renamed__"), + Rupd + ("Index", + TP[Dest + ("Index",CTy"Index", + Var("v",CTy"CP0__renamed__")), + EX(Var("value",F64),LN 7,LN 0,F8)])])), + qVar"s"))), + (TP[LN 0,LW(2,5),LW(0,3)], + Let(Var("v",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"s")), + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("EntryLo0", + TP[Var("v",CTy"CP0__renamed__"), + Call + ("write'reg'EntryLo",CTy"EntryLo", + TP[Dest + ("EntryLo0",CTy"EntryLo", + Var("v",CTy"CP0__renamed__")), + Var("value",F64)])])),qVar"s"))), + (TP[LN 0,LW(3,5),LW(0,3)], + Let(Var("v",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"s")), + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("EntryLo1", + TP[Var("v",CTy"CP0__renamed__"), + Call + ("write'reg'EntryLo",CTy"EntryLo", + TP[Dest + ("EntryLo1",CTy"EntryLo", + Var("v",CTy"CP0__renamed__")), + Var("value",F64)])])),qVar"s"))), + (TP[LN 0,LW(4,5),LW(0,3)], + Let(Var("v",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"s")), + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Context", + TP[Var("v",CTy"CP0__renamed__"), + Rupd + ("PTEBase", + TP[Dest + ("Context",CTy"Context", + Var("v",CTy"CP0__renamed__")), + EX(Var("value",F64),LN 63,LN 23, + FTy 41)])])),qVar"s"))), + (TP[LN 0,LW(4,5),LW(2,3)], + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("UsrLocal", + TP[Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"s")),Var("value",F64)])),qVar"s")), + (TP[LN 0,LW(5,5),LW(0,3)], + Let(Var("v",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"s")), + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("PageMask", + TP[Var("v",CTy"CP0__renamed__"), + Rupd + ("Mask", + TP[Dest + ("PageMask",CTy"PageMask", + Var("v",CTy"CP0__renamed__")), + EX(Var("value",F64),LN 24,LN 13, + FTy 12)])])),qVar"s"))), + (TP[LN 0,LW(6,5),LW(0,3)], + Let(Var("v",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Wired", + TP[Var("v",CTy"CP0__renamed__"), + Rupd + ("Wired", + TP[Dest + ("Wired",CTy"Wired", + Var("v", + CTy"CP0__renamed__")), + EX(Var("value",F64),LN 7, + LN 0,F8)])])),qVar"s")), + Let(Var("v",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"s")), + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Random", + TP[Var("v",CTy"CP0__renamed__"), + Rupd + ("Random", + TP[Dest + ("Random",CTy"Random", + Var("v", + CTy"CP0__renamed__")), + Mop(Cast F8, + Bop(Sub, + Const + ("TLBEntries",nTy), + LN 1))])])),qVar"s"))))), + (TP[LN 0,LW(7,5),LW(0,3)], + Let(Var("v",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("HWREna", + TP[Var("v",CTy"CP0__renamed__"), + Rupd + ("CPUNum", + TP[Dest + ("HWREna",CTy"HWREna", + Var("v", + CTy"CP0__renamed__")), + Bop(Bit,Var("value",F64),LN 0)])])), + qVar"s")), + Let(Var("v",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy,PTy(uTy,qTy)), + Rupd + ("HWREna", + TP[Var("v",CTy"CP0__renamed__"), + Rupd + ("CC", + TP[Dest + ("HWREna", + CTy"HWREna", + Var("v", + CTy"CP0__renamed__")), + Bop(Bit, + Var("value",F64), + LN 2)])])), + qVar"s")), + Let(Var("v",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))),qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy,PTy(uTy,qTy)), + Rupd + ("HWREna", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("CCRes", + TP[Dest + ("HWREna", + CTy"HWREna", + Var("v", + CTy"CP0__renamed__")), + Bop(Bit, + Var("value", + F64), + LN 3)])])), + qVar"s")), + Let(Var("v",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Apply + (Call + ("write'CP0", + ATy(qTy,PTy(uTy,qTy)), + Rupd + ("HWREna", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("UL", + TP[Dest + ("HWREna", + CTy"HWREna", + Var("v", + CTy"CP0__renamed__")), + Bop(Bit, + Var("value", + F64), + LN 29)])])), + qVar"s"))))))))), + (TP[LN 0,LW(9,5),LW(0,3)], + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Count", + TP[Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"s")), + EX(Var("value",F64),LN 31,LN 0,F32)])),qVar"s")), + (TP[LN 0,LW(10,5),LW(0,3)], + Let(Var("v",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"s")), + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("EntryHi", + TP[Var("v",CTy"CP0__renamed__"), + Call + ("write'reg'EntryHi",CTy"EntryHi", + TP[Dest + ("EntryHi",CTy"EntryHi", + Var("v",CTy"CP0__renamed__")), + Var("value",F64)])])),qVar"s"))), + (TP[LN 0,LW(11,5),LW(0,3)], + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Compare", + TP[Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))),qVar"s")), + EX(Var("value",F64),LN 31,LN 0,F32)])), + qVar"s")), + Let(Var("v",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"s")), + Let(qVar"s", + Let(Var("x0",CTy"CauseRegister"), + Dest + ("Cause",CTy"CauseRegister", + Var("v",CTy"CP0__renamed__")), + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Cause", + TP[Var("v",CTy"CP0__renamed__"), + Rupd + ("IP", + TP[Var("x0", + CTy"CauseRegister"), + BFI(LN 7,LN 7, + Mop(Cast F1,LF), + Dest + ("IP",F8, + Var("x0", + CTy"CauseRegister")))])])), + qVar"s"))), + Let(Var("v",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__",qTy))), + qVar"s")), + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Cause", + TP[Var("v",CTy"CP0__renamed__"), + Rupd + ("TI", + TP[Dest + ("Cause", + CTy"CauseRegister", + Var("v", + CTy"CP0__renamed__")), + LF])])),qVar"s")))))), + (TP[LN 0,LW(12,5),LW(0,3)], + Let(Var("v",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"s")), + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Status", + TP[Var("v",CTy"CP0__renamed__"), + Call + ("write'reg'StatusRegister", + CTy"StatusRegister", + TP[Dest + ("Status",CTy"StatusRegister", + Var("v",CTy"CP0__renamed__")), + EX(Var("value",F64),LN 31,LN 0,F32)])])), + qVar"s"))), + (TP[LN 0,LW(13,5),LW(0,3)], + Let(Var("v",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"s")), + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Cause", + TP[Var("v",CTy"CP0__renamed__"), + Call + ("write'reg'CauseRegister", + CTy"CauseRegister", + TP[Dest + ("Cause",CTy"CauseRegister", + Var("v",CTy"CP0__renamed__")), + EX(Var("value",F64),LN 31,LN 0,F32)])])), + qVar"s"))), + (TP[LN 0,LW(14,5),LW(0,3)], + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("EPC", + TP[Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"s")),Var("value",F64)])),qVar"s")), + (TP[LN 0,LW(16,5),LW(0,3)], + Let(Var("v",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"s")), + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Config", + TP[Var("v",CTy"CP0__renamed__"), + Rupd + ("K0", + TP[Dest + ("Config",CTy"ConfigRegister", + Var("v",CTy"CP0__renamed__")), + EX(Var("value",F64),LN 2,LN 0,FTy 3)])])), + qVar"s"))), + (TP[LN 0,LW(16,5),LW(2,3)], + Let(Var("v",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"s")), + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Config2", + TP[Var("v",CTy"CP0__renamed__"), + Rupd + ("SU", + TP[Dest + ("Config2",CTy"ConfigRegister2", + Var("v",CTy"CP0__renamed__")), + EX(Var("value",F64),LN 15,LN 12,F4)])])), + qVar"s"))), + (TP[LN 0,LW(16,5),LW(6,3)], + Let(Var("v",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"s")), + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Config6", + TP[Var("v",CTy"CP0__renamed__"), + Rupd + ("LTLB", + TP[Dest + ("Config6",CTy"ConfigRegister6", + Var("v",CTy"CP0__renamed__")), + Bop(Bit,Var("value",F64),LN 2)])])), + qVar"s"))), + (TP[LN 0,LW(20,5),LW(0,3)], + Let(Var("v",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"s")), + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("XContext", + TP[Var("v",CTy"CP0__renamed__"), + Rupd + ("PTEBase", + TP[Dest + ("XContext",CTy"XContext", + Var("v",CTy"CP0__renamed__")), + EX(Var("value",F64),LN 63,LN 33, + FTy 31)])])),qVar"s"))), + (TP[LN 0,LW(23,5),LW(0,3)], + TP[LU, + Rupd + ("done", + TP[Mop(Snd, + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Debug", + TP[Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))),qVar"s")), + EX(Var("value",F64),LN 31,LN 0,F32)])), + qVar"s")),LT])]), + (TP[LN 0,LW(26,5),LW(0,3)], + Apply + (Call("dumpRegs",ATy(qTy,PTy(uTy,qTy)),LU), + Mop(Snd, + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("ErrCtl", + TP[Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))),qVar"s")), + EX(Var("value",F64),LN 31,LN 0,F32)])), + qVar"s")))), + (TP[LN 0,LW(30,5),LW(0,3)], + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("ErrorEPC", + TP[Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"s")),Var("value",F64)])),qVar"s")), + (AVar(PTy(nTy,PTy(FTy 5,FTy 3))), + Apply + (Call("unmark_log",ATy(qTy,PTy(uTy,qTy)),LN 2),qVar"s"))])))) +; +val dfn'CACHE_def = Def + ("dfn'CACHE",TP[Var("base",FTy 5),Var("opn",FTy 5),Var("offset",F16)], + Close + (qVar"state", + ITE(Bop(And, + Mop(Not, + Dest + ("CU0",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))), + Mop(Not, + Mop(Fst, + Apply + (Const("KernelMode",ATy(qTy,PTy(bTy,qTy))), + qVar"state")))), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("CpU",CTy"ExceptionType")),qVar"state"), + Let(TP[Var("v",PTy(FTy 40,PTy(FTy 3,PTy(bTy,bTy)))),qVar"s"], + Apply + (Call + ("AddressTranslation", + ATy(qTy,PTy(PTy(FTy 40,PTy(FTy 3,PTy(bTy,bTy))),qTy)), + TP[Bop(Add, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("base",FTy 5)),qVar"state")), + Mop(SE F64,Var("offset",F16))), + LC("DATA",CTy"IorD"),LC("LOAD",CTy"AccessType")]), + qVar"state"),TP[LU,qVar"s"])))) +; +val dfn'RDHWR_def = Def + ("dfn'RDHWR",TP[Var("rt",FTy 5),Var("rd",FTy 5)], + Close + (qVar"state", + ITE(Bop(Or, + Bop(Or, + Dest + ("CU0",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state")))), + Mop(Fst, + Apply + (Const("KernelMode",ATy(qTy,PTy(bTy,qTy))), + qVar"state"))), + Bop(Bit, + Call + ("reg'HWREna",F32, + Dest + ("HWREna",CTy"HWREna", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state")))), + Mop(Cast nTy,Var("rd",FTy 5)))), + CS(Var("rd",FTy 5), + [(LW(0,5), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Cast F64, + Bop(Sub,Dest("totalCore",nTy,qVar"state"),LN 1)), + Var("rt",FTy 5)]),qVar"state")), + (LW(2,5), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(SE F64, + Dest + ("Count",F32, + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__",qTy))), + qVar"state")))),Var("rt",FTy 5)]), + qVar"state")), + (LW(3,5), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[LW(1,64),Var("rt",FTy 5)]),qVar"state")), + (LW(29,5), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Dest + ("UsrLocal",F64, + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))),Var("rt",FTy 5)]), + qVar"state")), + (AVar(FTy 5), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("ResI",CTy"ExceptionType")),qVar"state"))]), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("ResI",CTy"ExceptionType")),qVar"state")))) +; +val InitMEM_def = Def + ("InitMEM",qVar"state", + TP[LU,Rupd("MEM",TP[qVar"state",Mop(K1(FTy 37),LW(0,64))])]) +; +val ReadData_def = Def + ("ReadData",Var("pAddr",FTy 37), + Close + (qVar"state", + Let(Var("v",F64), + Apply + (Dest("MEM",ATy(FTy 37,F64),qVar"state"),Var("pAddr",FTy 37)), + TP[Var("v",F64), + Mop(Snd, + Apply + (Call + ("mark_log",ATy(qTy,PTy(uTy,qTy)), + TP[LN 2, + Call + ("log_r_mem",sTy, + TP[Var("pAddr",FTy 37),Var("v",F64)])]), + qVar"state"))]))) +; +val WriteData_def = Def + ("WriteData",TP[Var("pAddr",FTy 37),Var("data",F64),Var("mask",F64)], + Close + (qVar"state", + Apply + (Call + ("mark_log",ATy(qTy,PTy(uTy,qTy)), + TP[LN 2, + Call + ("log_w_mem",sTy, + TP[Var("pAddr",FTy 37),Var("mask",F64),Var("data",F64)])]), + Rupd + ("MEM", + TP[qVar"state", + Fupd + (Dest("MEM",ATy(FTy 37,F64),qVar"state"), + Var("pAddr",FTy 37), + Bop(BOr, + Bop(BAnd, + Apply + (Dest("MEM",ATy(FTy 37,F64),qVar"state"), + Var("pAddr",FTy 37)), + Mop(BNot,Var("mask",F64))), + Bop(BAnd,Var("data",F64),Var("mask",F64))))])))) +; +val ReadInst_def = Def + ("ReadInst",Var("a",FTy 40), + Close + (qVar"state", + TP[ITE(Bop(Bit,Var("a",FTy 40),LN 2), + EX(Apply + (Dest("MEM",ATy(FTy 37,F64),qVar"state"), + EX(Var("a",FTy 40),LN 39,LN 3,FTy 37)),LN 31,LN 0,F32), + EX(Apply + (Dest("MEM",ATy(FTy 37,F64),qVar"state"), + EX(Var("a",FTy 40),LN 39,LN 3,FTy 37)),LN 63,LN 32,F32)), + qVar"state"])) +; +val WriteDWORD_def = Def + ("WriteDWORD",TP[Var("pAddr",FTy 37),Var("data",F64)], + Close + (qVar"state", + TP[LU, + Rupd + ("MEM", + TP[qVar"state", + Fupd + (Dest("MEM",ATy(FTy 37,F64),qVar"state"), + Var("pAddr",FTy 37),Var("data",F64))])])) +; +val Write256_def = Def + ("Write256",TP[Var("pAddr",FTy 35),Var("data",FTy 256)], + Close + (qVar"state", + Let(qVar"s", + Rupd + ("MEM", + TP[qVar"state", + Fupd + (Dest("MEM",ATy(FTy 37,F64),qVar"state"), + CC[Var("pAddr",FTy 35),LW(0,2)], + EX(Var("data",FTy 256),LN 63,LN 0,F64))]), + Let(qVar"s", + Rupd + ("MEM", + TP[qVar"s", + Fupd + (Dest("MEM",ATy(FTy 37,F64),qVar"s"), + CC[Var("pAddr",FTy 35),LW(1,2)], + EX(Var("data",FTy 256),LN 127,LN 64,F64))]), + Let(qVar"s", + Rupd + ("MEM", + TP[qVar"s", + Fupd + (Dest("MEM",ATy(FTy 37,F64),qVar"s"), + CC[Var("pAddr",FTy 35),LW(2,2)], + EX(Var("data",FTy 256),LN 191,LN 128,F64))]), + TP[LU, + Rupd + ("MEM", + TP[qVar"s", + Fupd + (Dest("MEM",ATy(FTy 37,F64),qVar"s"), + CC[Var("pAddr",FTy 35),LW(3,2)], + EX(Var("data",FTy 256),LN 255,LN 192,F64))])]))))) +; +val LoadMemoryCap_def = Def + ("LoadMemoryCap", + TP[Var("MemType",FTy 3),Var("vAddr",F64),Var("IorD",CTy"IorD"), + Var("AccessType",CTy"AccessType"),bVar"link"], + Close + (qVar"state", + Let(TP[Var("r",F64),Var("s1",PTy(FTy 40,qTy))], + Let(TP[Var("v",PTy(FTy 40,PTy(FTy 3,PTy(bTy,bTy)))), + Var("s",PTy(FTy 40,qTy))], + Let(TP[Var("v",PTy(FTy 40,PTy(FTy 3,PTy(bTy,bTy)))),qVar"s3"], + Apply + (Call + ("AddressTranslation", + ATy(qTy, + PTy(PTy(FTy 40,PTy(FTy 3,PTy(bTy,bTy))),qTy)), + TP[Var("vAddr",F64),LC("DATA",CTy"IorD"), + LC("LOAD",CTy"AccessType")]),qVar"state"), + TP[Var("v",PTy(FTy 40,PTy(FTy 3,PTy(bTy,bTy)))), + LX(FTy 40),qVar"s3"]), + Let(TP[Var("tmp",FTy 40),Var("CCA",FTy 3),bVar"S",bVar"L"], + Var("v",PTy(FTy 40,PTy(FTy 3,PTy(bTy,bTy)))), + Let(Var("s",PTy(FTy 40,qTy)), + TP[Var("tmp",FTy 40), + Mop(Snd,Var("s",PTy(FTy 40,qTy)))], + Let(Var("s",PTy(FTy 40,qTy)), + Let(TP[Var("v",FTy 40),Var("s",PTy(FTy 40,qTy))], + Let(TP[Var("v0",FTy 3), + Var("s0",PTy(FTy 40,qTy))], + CS(Var("MemType",FTy 3), + [(LW(0,3), + Let(TP[Var("v0",F1), + Var("s0",PTy(FTy 40,qTy))], + Let(TP[Var("v",F1),qVar"s3"], + TP[Mop(Fst, + Apply + (Const + ("ReverseEndian", + ATy(qTy, + PTy(F1,qTy))), + Mop(Snd, + Var("s", + PTy(FTy 40, + qTy))))), + Mop(Snd, + Var("s", + PTy(FTy 40,qTy)))], + TP[Var("v",F1), + Mop(Fst, + Var("s", + PTy(FTy 40,qTy))), + qVar"s3"]), + TP[Bop(BXor, + EX(Mop(Fst, + Var("s", + PTy(FTy 40, + qTy))), + LN 2,LN 0,FTy 3), + REP(Var("v0",F1),LN 3, + FTy 3)), + Var("s0",PTy(FTy 40,qTy))])), + (LW(1,3), + Let(TP[Var("v0",F1), + Var("s0",PTy(FTy 40,qTy))], + Let(TP[Var("v",F1),qVar"s3"], + TP[Mop(Fst, + Apply + (Const + ("ReverseEndian", + ATy(qTy, + PTy(F1,qTy))), + Mop(Snd, + Var("s", + PTy(FTy 40, + qTy))))), + Mop(Snd, + Var("s", + PTy(FTy 40,qTy)))], + TP[Var("v",F1), + Mop(Fst, + Var("s", + PTy(FTy 40,qTy))), + qVar"s3"]), + TP[Bop(BXor, + EX(Mop(Fst, + Var("s", + PTy(FTy 40, + qTy))), + LN 2,LN 0,FTy 3), + CC[REP(Var("v0",F1), + LN 2,FTy 2), + LW(0,1)]), + Var("s0",PTy(FTy 40,qTy))])), + (LW(3,3), + Let(TP[Var("v0",F1), + Var("s0",PTy(FTy 40,qTy))], + Let(TP[Var("v",F1),qVar"s3"], + TP[Mop(Fst, + Apply + (Const + ("ReverseEndian", + ATy(qTy, + PTy(F1,qTy))), + Mop(Snd, + Var("s", + PTy(FTy 40, + qTy))))), + Mop(Snd, + Var("s", + PTy(FTy 40,qTy)))], + TP[Var("v",F1), + Mop(Fst, + Var("s", + PTy(FTy 40,qTy))), + qVar"s3"]), + TP[Bop(BXor, + EX(Mop(Fst, + Var("s", + PTy(FTy 40, + qTy))), + LN 2,LN 0,FTy 3), + CC[Var("v0",F1),LW(0,2)]), + Var("s0",PTy(FTy 40,qTy))])), + (LW(7,3), + TP[EX(Mop(Fst, + Var("s",PTy(FTy 40,qTy))), + LN 2,LN 0,FTy 3), + Var("s",PTy(FTy 40,qTy))]), + (AVar(FTy 3), + Let(TP[Var("v",FTy 3),qVar"s3"], + Apply + (Call + ("raise'exception", + ATy(qTy,PTy(FTy 3,qTy)), + Call + ("UNPREDICTABLE", + CTy"exception", + LS"bad access length")), + Mop(Snd, + Var("s",PTy(FTy 40,qTy)))), + TP[Var("v",FTy 3), + Mop(Fst, + Var("s",PTy(FTy 40,qTy))), + qVar"s3"]))]), + TP[BFI(LN 2,LN 0,Var("v0",FTy 3), + Mop(Fst,Var("s",PTy(FTy 40,qTy)))), + Var("s0",PTy(FTy 40,qTy))]), + TP[Var("v",FTy 40), + Mop(Snd,Var("s",PTy(FTy 40,qTy)))]), + Let(TP[bVar"v",Var("s",PTy(FTy 40,qTy))], + Let(TP[bVar"v",qVar"s3"], + TP[Mop(Fst, + Apply + (Const + ("BigEndianMem", + ATy(qTy,PTy(bTy,qTy))), + Mop(Snd, + Var("s",PTy(FTy 40,qTy))))), + Mop(Snd,Var("s",PTy(FTy 40,qTy)))], + TP[bVar"v", + Mop(Fst,Var("s",PTy(FTy 40,qTy))), + qVar"s3"]), + Let(Var("s",PTy(FTy 40,qTy)), + TP[ITE(bVar"v", + Mop(Fst,Var("s",PTy(FTy 40,qTy))), + Bop(BAnd, + Mop(Fst, + Var("s",PTy(FTy 40,qTy))), + Mop(BNot,LW(7,40)))), + Mop(Snd,Var("s",PTy(FTy 40,qTy)))], + Let(TP[bVar"v",Var("s",PTy(FTy 40,qTy))], + Let(TP[bVar"v",qVar"s3"], + TP[Mop(Fst, + Apply + (Const + ("exceptionSignalled", + ATy(qTy, + PTy(bTy,qTy))), + Mop(Snd, + Var("s", + PTy(FTy 40,qTy))))), + Mop(Snd, + Var("s",PTy(FTy 40,qTy)))], + TP[bVar"v", + Mop(Fst, + Var("s",PTy(FTy 40,qTy))), + qVar"s3"]), + ITE(Mop(Not,bVar"v"), + Let(Var("v",FTy 37), + EX(Mop(Fst, + Var("s", + PTy(FTy 40,qTy))), + LN 39,LN 3,FTy 37), + Let(TP[Var("r",F64), + Var("s1", + PTy(F64, + PTy(FTy 40, + qTy)))], + Let(TP[Var("r",F64), + Var("s1", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy))))], + Let(Var("s0", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy)))), + TP[LF,LX F64, + Var("s", + PTy(FTy 40, + qTy))], + Let(Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy)))), + ITE(EQ(Var("v", + FTy 37), + Dest + ("base_address", + FTy 37, + Dest + ("JTAG_UART", + CTy"JTAG_UART", + Mop(Snd, + Var("s", + PTy(FTy 40, + qTy)))))), + Let(Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy)))), + TP[LT, + Mop(Snd, + Var("s0", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy)))))], + Let(Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy)))), + TP[Mop(Fst, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy))))), + CC[Call + ("flip_endian_word", + F32, + Call + ("reg'JTAG_UART_data", + F32, + Dest + ("data", + CTy"JTAG_UART_data__renamed__", + Dest + ("JTAG_UART", + CTy"JTAG_UART", + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy))))))))))), + Call + ("flip_endian_word", + F32, + Call + ("reg'JTAG_UART_control", + F32, + Dest + ("control", + CTy"JTAG_UART_control__renamed__", + Dest + ("JTAG_UART", + CTy"JTAG_UART", + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy)))))))))))], + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy))))))], + ITE(EQ(EX(Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy))))))), + LN + 2, + LN + 0, + FTy 3), + LW(0, + 3)), + TP[Mop(Fst, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy))))), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy)))))), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy))))))), + Mop(Snd, + Apply + (Const + ("JTAG_UART_load", + ATy(qTy, + PTy(uTy, + qTy))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy)))))))))], + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy))))))), + Mop(Snd, + Apply + (For(TP[LN + 0, + Bop(Sub, + Dest + ("totalCore", + nTy, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy)))))))), + LN + 1), + Close + (nVar"core", + Close + (Var("state", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy)))), + ITE(Bop(And, + Bop(Uge, + Var("v", + FTy 37), + Apply + (Dest + ("PIC_base_address", + ATy(F8, + FTy 37), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("state", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy)))))))), + Mop(Cast + F8, + nVar"core"))), + Bop(Ult, + Var("v", + FTy 37), + Bop(Add, + Apply + (Dest + ("PIC_base_address", + ATy(F8, + FTy 37), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("state", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy)))))))), + Mop(Cast + F8, + nVar"core")), + LW(1072, + 37)))), + Let(Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy)))), + TP[LT, + Mop(Snd, + Var("state", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy)))))], + Let(TP[Var("v", + F64), + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy))))], + Let(TP[Var("v", + F64), + Var("s3", + PTy(F64, + PTy(FTy 40, + qTy)))], + Let(TP[Var("v", + F64), + Var("s3", + PTy(FTy 40, + qTy))], + Let(TP[Var("v", + F64), + qVar"s3"], + TP[Mop(Fst, + Apply + (Call + ("PIC_load", + ATy(qTy, + PTy(F64, + qTy)), + TP[Mop(Cast + F8, + nVar"core"), + Var("v", + FTy 37)]), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy))))))))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy)))))))], + TP[Var("v", + F64), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy))))))), + qVar"s3"]), + TP[Var("v", + F64), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy)))))), + Var("s3", + PTy(FTy 40, + qTy))]), + TP[Var("v", + F64), + Mop(Fst, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy))))), + Var("s3", + PTy(F64, + PTy(FTy 40, + qTy)))]), + TP[LU, + Mop(Fst, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy))))), + Var("v", + F64), + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy))))))])), + TP[LU, + Var("state", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy))))])))]), + Var("s0", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy))))))), + Let(Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy)))), + ITE(bVar"link", + Let(Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy)))), + TP[Mop(Fst, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy))))), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy)))))), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy))))))), + Mop(Snd, + Apply + (Call + ("write'LLbit", + ATy(qTy, + PTy(uTy, + qTy)), + Mop(Some, + LT)), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy)))))))))], + Let(TP[Var("v", + CTy"CP0__renamed__"), + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy))))], + Let(TP[Var("v", + CTy"CP0__renamed__"), + Var("s3", + PTy(F64, + PTy(FTy 40, + qTy)))], + Let(TP[Var("v", + CTy"CP0__renamed__"), + Var("s3", + PTy(FTy 40, + qTy))], + Let(TP[Var("v", + CTy"CP0__renamed__"), + qVar"s3"], + TP[Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy))))))))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy)))))))], + TP[Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy))))))), + qVar"s3"]), + TP[Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy)))))), + Var("s3", + PTy(FTy 40, + qTy))]), + TP[Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy))))), + Var("s3", + PTy(F64, + PTy(FTy 40, + qTy)))]), + TP[Mop(Fst, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy))))), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy)))))), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy))))))), + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("LLAddr", + TP[Var("v", + CTy"CP0__renamed__"), + Mop(Cast + F64, + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy))))))))])), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy)))))))))])), + TP[Mop(Fst, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy))))), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy)))))), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy))))))), + Mop(Snd, + Apply + (Call + ("write'LLbit", + ATy(qTy, + PTy(uTy, + qTy)), + LO bTy), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy)))))))))]), + Let(Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy)))), + ITE(EQ(Mop(Fst, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy))))), + LF), + Let(TP[Var("v", + F64), + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy))))], + Let(TP[Var("v", + F64), + Var("s3", + PTy(F64, + PTy(FTy 40, + qTy)))], + Let(TP[Var("v", + F64), + Var("s3", + PTy(FTy 40, + qTy))], + Let(TP[Var("v", + F64), + qVar"s3"], + Apply + (Call + ("ReadData", + ATy(qTy, + PTy(F64, + qTy)), + Var("v", + FTy 37)), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy)))))))), + TP[Var("v", + F64), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy))))))), + qVar"s3"]), + TP[Var("v", + F64), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy)))))), + Var("s3", + PTy(FTy 40, + qTy))]), + TP[Var("v", + F64), + Mop(Fst, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy))))), + Var("s3", + PTy(F64, + PTy(FTy 40, + qTy)))]), + TP[Mop(Fst, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy))))), + Var("v", + F64), + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy))))))]), + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy))))), + TP[Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy)))))), + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy))))])))), + TP[Var("r",F64), + Mop(Snd, + Var("s1", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy)))))]), + TP[Var("r",F64), + Mop(Snd, + Var("s1", + PTy(F64, + PTy(FTy 40, + qTy))))])), + TP[LX F64, + Var("s",PTy(FTy 40,qTy))])))))))), + TP[Var("r",F64),Mop(Snd,Var("s1",PTy(FTy 40,qTy)))]))) +; +val LoadMemory_def = Def + ("LoadMemory", + TP[Var("MemType",FTy 3),Var("AccessLength",FTy 3),Var("vAddr",F64), + Var("IorD",CTy"IorD"),Var("AccessType",CTy"AccessType"),bVar"link"], + Close + (qVar"state", + Let(Var("v",F64), + Bop(Add, + Bop(Add,Var("vAddr",F64), + Dest + ("base",F64, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + LW(0,5)),qVar"state")))), + Dest + ("offset",F64, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + LW(0,5)),qVar"state")))), + ITB([(Mop(Not, + Dest + ("tag",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + LW(0,5)),qVar"state")))), + TP[LX F64, + Mop(Snd, + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcTag",CTy"CapException"),LW(0,5)]), + qVar"state"))]), + (Dest + ("sealed",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + LW(0,5)),qVar"state"))), + TP[LX F64, + Mop(Snd, + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcSeal",CTy"CapException"),LW(0,5)]), + qVar"state"))]), + (Bop(Ult,Var("v",F64), + Dest + ("base",F64, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + LW(0,5)),qVar"state")))), + TP[LX F64, + Mop(Snd, + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcLength",CTy"CapException"), + LW(0,5)]),qVar"state"))]), + (Bop(Ugt,Var("v",F64), + Bop(Add, + Dest + ("base",F64, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + LW(0,5)),qVar"state"))), + Dest + ("length",F64, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + LW(0,5)),qVar"state"))))), + TP[LX F64, + Mop(Snd, + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcLength",CTy"CapException"), + LW(0,5)]),qVar"state"))]), + (Mop(Not, + Dest + ("Permit_Load",bTy, + Call + ("rec'Perms",CTy"Perms", + Dest + ("perms",FTy 31, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + LW(0,5)),qVar"state")))))), + TP[LX F64, + Mop(Snd, + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcPermLoad",CTy"CapException"), + LW(0,5)]),qVar"state"))])], + Apply + (Call + ("LoadMemoryCap",ATy(qTy,PTy(F64,qTy)), + TP[Var("MemType",FTy 3),Var("v",F64), + Var("IorD",CTy"IorD"), + Var("AccessType",CTy"AccessType"),bVar"link"]), + qVar"state"))))) +; +val LoadCap_def = Def + ("LoadCap",Var("vAddr",F64), + Close + (qVar"state", + Let(TP[Var("v",PTy(FTy 40,PTy(FTy 3,PTy(bTy,bTy)))),qVar"s"], + Apply + (Call + ("AddressTranslation", + ATy(qTy,PTy(PTy(FTy 40,PTy(FTy 3,PTy(bTy,bTy))),qTy)), + TP[Var("vAddr",F64),LC("DATA",CTy"IorD"), + LC("CLOAD",CTy"AccessType")]),qVar"state"), + Let(TP[Var("pAddr",FTy 40),Var("CCA",FTy 3),bVar"S",bVar"L"], + Var("v",PTy(FTy 40,PTy(FTy 3,PTy(bTy,bTy)))), + ITE(Mop(Not, + Mop(Fst, + Apply + (Const + ("exceptionSignalled",ATy(qTy,PTy(bTy,qTy))), + qVar"s"))), + Let(Var("a",FTy 35), + EX(Var("pAddr",FTy 40),LN 39,LN 5,FTy 35), + Let(TP[Var("r",CTy"Capability"), + Var("s1",PTy(CTy"Capability",qTy))], + Let(Var("s",PTy(CTy"Capability",qTy)), + TP[LX(CTy"Capability"), + ITE(EQ(Var("a",FTy 35), + EX(Dest + ("base_address",FTy 37, + Dest + ("JTAG_UART", + CTy"JTAG_UART",qVar"s")), + LN 36,LN 2,FTy 35)), + Mop(Snd, + Apply + (Call + ("raise'exception", + ATy(qTy,PTy(uTy,qTy)), + Call + ("UNPREDICTABLE", + CTy"exception", + LS + "Capability load attempted on UART")), + qVar"s")), + Mop(Snd, + Apply + (For(TP[LN 0, + Bop(Sub, + Dest + ("totalCore",nTy, + qVar"s"),LN 1), + Close + (nVar"core", + Close + (qVar"state", + ITE(Bop(And, + Bop(Uge, + Var("a", + FTy 35), + EX(Apply + (Dest + ("PIC_base_address", + ATy(F8, + FTy 37), + qVar"state"), + Mop(Cast + F8, + nVar"core")), + LN + 36, + LN + 2, + FTy 35)), + Bop(Ult, + Var("a", + FTy 35), + EX(Bop(Add, + Apply + (Dest + ("PIC_base_address", + ATy(F8, + FTy 37), + qVar"state"), + Mop(Cast + F8, + nVar"core")), + LW(1072, + 37)), + LN + 36, + LN + 2, + FTy 35))), + Apply + (Call + ("raise'exception", + ATy(qTy, + PTy(uTy, + qTy)), + Call + ("UNPREDICTABLE", + CTy"exception", + LS + "Capability load attempted on PIC")), + qVar"state"), + TP[LU, + qVar"state"])))]), + qVar"s")))], + Let(Var("s",PTy(CTy"Capability",qTy)), + Let(TP[Var("v",CTy"Capability"), + Var("s",PTy(CTy"Capability",qTy))], + Let(TP[Var("v", + PTy(CTy"Capability", + FTy 257)), + Var("s", + PTy(CTy"Capability",qTy))], + Let(TP[Var("v0",F64), + Var("s0", + PTy(CTy"Capability", + qTy))], + Let(TP[Var("v",F64),qVar"s3"], + Apply + (Call + ("ReadData", + ATy(qTy, + PTy(F64,qTy)), + CC[Var("a",FTy 35), + LW(0,2)]), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy)))), + TP[Var("v",F64), + Mop(Fst, + Var("s", + PTy(CTy"Capability", + qTy))), + qVar"s3"]), + TP[TP[Mop(Fst, + Var("s", + PTy(CTy"Capability", + qTy))), + BFI(LN 255,LN 192, + Var("v0",F64), + Call + ("reg'Capability", + FTy 257, + LX(CTy"Capability")))], + Var("s0", + PTy(CTy"Capability", + qTy))]), + TP[Call + ("write'reg'Capability", + CTy"Capability", + Var("v", + PTy(CTy"Capability", + FTy 257))), + Var("s", + PTy(CTy"Capability",qTy))]), + TP[Var("v",CTy"Capability"), + Mop(Snd, + Var("s", + PTy(CTy"Capability",qTy)))]), + Let(Var("s",PTy(CTy"Capability",qTy)), + Let(TP[Var("v",CTy"Capability"), + Var("s", + PTy(CTy"Capability",qTy))], + Let(TP[Var("v", + PTy(CTy"Capability", + FTy 257)), + Var("s", + PTy(CTy"Capability", + qTy))], + Let(TP[Var("v0",F64), + Var("s0", + PTy(CTy"Capability", + qTy))], + Let(TP[Var("v",F64), + qVar"s3"], + Apply + (Call + ("ReadData", + ATy(qTy, + PTy(F64, + qTy)), + CC[Var("a", + FTy 35), + LW(1,2)]), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy)))), + TP[Var("v",F64), + Mop(Fst, + Var("s", + PTy(CTy"Capability", + qTy))), + qVar"s3"]), + TP[TP[Mop(Fst, + Var("s", + PTy(CTy"Capability", + qTy))), + BFI(LN 191,LN 128, + Var("v0",F64), + Call + ("reg'Capability", + FTy 257, + Mop(Fst, + Var("s", + PTy(CTy"Capability", + qTy)))))], + Var("s0", + PTy(CTy"Capability", + qTy))]), + TP[Call + ("write'reg'Capability", + CTy"Capability", + Var("v", + PTy(CTy"Capability", + FTy 257))), + Var("s", + PTy(CTy"Capability", + qTy))]), + TP[Var("v",CTy"Capability"), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy)))]), + Let(Var("s",PTy(CTy"Capability",qTy)), + Let(TP[Var("v",CTy"Capability"), + Var("s", + PTy(CTy"Capability", + qTy))], + Let(TP[Var("v", + PTy(CTy"Capability", + FTy 257)), + Var("s", + PTy(CTy"Capability", + qTy))], + Let(TP[Var("v0",F64), + Var("s0", + PTy(CTy"Capability", + qTy))], + Let(TP[Var("v",F64), + qVar"s3"], + Apply + (Call + ("ReadData", + ATy(qTy, + PTy(F64, + qTy)), + CC[Var("a", + FTy 35), + LW(2,2)]), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy)))), + TP[Var("v",F64), + Mop(Fst, + Var("s", + PTy(CTy"Capability", + qTy))), + qVar"s3"]), + TP[TP[Mop(Fst, + Var("s", + PTy(CTy"Capability", + qTy))), + BFI(LN 127, + LN 64, + Var("v0", + F64), + Call + ("reg'Capability", + FTy 257, + Mop(Fst, + Var("s", + PTy(CTy"Capability", + qTy)))))], + Var("s0", + PTy(CTy"Capability", + qTy))]), + TP[Call + ("write'reg'Capability", + CTy"Capability", + Var("v", + PTy(CTy"Capability", + FTy 257))), + Var("s", + PTy(CTy"Capability", + qTy))]), + TP[Var("v",CTy"Capability"), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy)))]), + Let(Var("s", + PTy(CTy"Capability",qTy)), + Let(TP[Var("v", + CTy"Capability"), + Var("s", + PTy(CTy"Capability", + qTy))], + Let(TP[Var("v", + PTy(CTy"Capability", + FTy 257)), + Var("s", + PTy(CTy"Capability", + qTy))], + Let(TP[Var("v0",F64), + Var("s0", + PTy(CTy"Capability", + qTy))], + Let(TP[Var("v", + F64), + qVar"s3"], + Apply + (Call + ("ReadData", + ATy(qTy, + PTy(F64, + qTy)), + CC[Var("a", + FTy 35), + LW(3, + 2)]), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy)))), + TP[Var("v", + F64), + Mop(Fst, + Var("s", + PTy(CTy"Capability", + qTy))), + qVar"s3"]), + TP[TP[Mop(Fst, + Var("s", + PTy(CTy"Capability", + qTy))), + BFI(LN 63, + LN 0, + Var("v0", + F64), + Call + ("reg'Capability", + FTy 257, + Mop(Fst, + Var("s", + PTy(CTy"Capability", + qTy)))))], + Var("s0", + PTy(CTy"Capability", + qTy))]), + TP[Call + ("write'reg'Capability", + CTy"Capability", + Var("v", + PTy(CTy"Capability", + FTy 257))), + Var("s", + PTy(CTy"Capability", + qTy))]), + TP[Var("v", + CTy"Capability"), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy)))]), + Let(Var("s", + PTy(CTy"Capability", + qTy)), + TP[Rupd + ("tag", + TP[Mop(Fst, + Var("s", + PTy(CTy"Capability", + qTy))), + ITE(bVar"L",LF, + Apply + (Dest + ("TAG", + ATy(FTy 35, + bTy), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy)))), + Var("a", + FTy 35)))]), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy)))], + Let(Var("s", + PTy(CTy"Capability", + qTy)), + TP[Mop(Fst, + Var("s", + PTy(CTy"Capability", + qTy))), + Mop(Snd, + Apply + (Call + ("write'LLbit", + ATy(qTy, + PTy(uTy, + qTy)), + LO bTy), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy)))))], + TP[Mop(Fst, + Var("s", + PTy(CTy"Capability", + qTy))), + Var("s", + PTy(CTy"Capability", + qTy))]))))))), + TP[Var("r",CTy"Capability"), + Mop(Snd,Var("s1",PTy(CTy"Capability",qTy)))])), + TP[LX(CTy"Capability"),qVar"s"]))))) +; +val StoreMemoryCap_def = Def + ("StoreMemoryCap", + TP[Var("MemType",FTy 3),Var("AccessLength",FTy 3),Var("MemElem",F64), + Var("vAddr",F64),Var("IorD",CTy"IorD"), + Var("AccessType",CTy"AccessType"),bVar"cond"], + Close + (qVar"state", + Let(TP[bVar"r",Var("s1",PTy(FTy 40,qTy))], + Let(TP[bVar"r",Var("s1",PTy(bTy,PTy(FTy 40,qTy)))], + Let(TP[Var("v",PTy(FTy 40,PTy(FTy 3,PTy(bTy,bTy)))), + Var("s",PTy(bTy,PTy(FTy 40,qTy)))], + Let(TP[Var("v",PTy(FTy 40,PTy(FTy 3,PTy(bTy,bTy)))), + Var("s3",PTy(FTy 40,qTy))], + Let(TP[Var("v",PTy(FTy 40,PTy(FTy 3,PTy(bTy,bTy)))), + qVar"s3"], + Apply + (Call + ("AddressTranslation", + ATy(qTy, + PTy(PTy(FTy 40,PTy(FTy 3,PTy(bTy,bTy))), + qTy)), + TP[Var("vAddr",F64),LC("DATA",CTy"IorD"), + LC("STORE",CTy"AccessType")]), + qVar"state"), + TP[Var("v",PTy(FTy 40,PTy(FTy 3,PTy(bTy,bTy)))), + LX(FTy 40),qVar"s3"]), + TP[Var("v",PTy(FTy 40,PTy(FTy 3,PTy(bTy,bTy)))),LF, + Var("s3",PTy(FTy 40,qTy))]), + Let(TP[Var("tmp",FTy 40),Var("CCA",FTy 3),bVar"S", + bVar"L"], + Var("v",PTy(FTy 40,PTy(FTy 3,PTy(bTy,bTy)))), + Let(Var("s",PTy(bTy,PTy(FTy 40,qTy))), + TP[Mop(Fst,Var("s",PTy(bTy,PTy(FTy 40,qTy)))), + Var("tmp",FTy 40), + Mop(Snd, + Mop(Snd,Var("s",PTy(bTy,PTy(FTy 40,qTy)))))], + Let(Var("s",PTy(bTy,PTy(FTy 40,qTy))), + Let(TP[Var("v",FTy 40), + Var("s",PTy(bTy,PTy(FTy 40,qTy)))], + Let(TP[Var("v0",FTy 3), + Var("s0",PTy(bTy,PTy(FTy 40,qTy)))], + CS(Var("MemType",FTy 3), + [(LW(0,3), + Let(TP[Var("v0",F1), + Var("s0", + PTy(bTy, + PTy(FTy 40,qTy)))], + Let(TP[Var("v",F1), + Var("s3", + PTy(FTy 40,qTy))], + Let(TP[Var("v",F1), + qVar"s3"], + TP[Mop(Fst, + Apply + (Const + ("ReverseEndian", + ATy(qTy, + PTy(F1, + qTy))), + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 40, + qTy))))))), + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 40, + qTy)))))], + TP[Var("v",F1), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 40, + qTy))))), + qVar"s3"]), + TP[Var("v",F1), + Mop(Fst, + Var("s", + PTy(bTy, + PTy(FTy 40, + qTy)))), + Var("s3", + PTy(FTy 40,qTy))]), + TP[Bop(BXor, + EX(Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 40, + qTy))))), + LN 2,LN 0,FTy 3), + REP(Var("v0",F1), + LN 3,FTy 3)), + Var("s0", + PTy(bTy, + PTy(FTy 40,qTy)))])), + (LW(1,3), + Let(TP[Var("v0",F1), + Var("s0", + PTy(bTy, + PTy(FTy 40,qTy)))], + Let(TP[Var("v",F1), + Var("s3", + PTy(FTy 40,qTy))], + Let(TP[Var("v",F1), + qVar"s3"], + TP[Mop(Fst, + Apply + (Const + ("ReverseEndian", + ATy(qTy, + PTy(F1, + qTy))), + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 40, + qTy))))))), + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 40, + qTy)))))], + TP[Var("v",F1), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 40, + qTy))))), + qVar"s3"]), + TP[Var("v",F1), + Mop(Fst, + Var("s", + PTy(bTy, + PTy(FTy 40, + qTy)))), + Var("s3", + PTy(FTy 40,qTy))]), + TP[Bop(BXor, + EX(Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 40, + qTy))))), + LN 2,LN 0,FTy 3), + CC[REP(Var("v0",F1), + LN 2,FTy 2), + LW(0,1)]), + Var("s0", + PTy(bTy, + PTy(FTy 40,qTy)))])), + (LW(3,3), + Let(TP[Var("v0",F1), + Var("s0", + PTy(bTy, + PTy(FTy 40,qTy)))], + Let(TP[Var("v",F1), + Var("s3", + PTy(FTy 40,qTy))], + Let(TP[Var("v",F1), + qVar"s3"], + TP[Mop(Fst, + Apply + (Const + ("ReverseEndian", + ATy(qTy, + PTy(F1, + qTy))), + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 40, + qTy))))))), + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 40, + qTy)))))], + TP[Var("v",F1), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 40, + qTy))))), + qVar"s3"]), + TP[Var("v",F1), + Mop(Fst, + Var("s", + PTy(bTy, + PTy(FTy 40, + qTy)))), + Var("s3", + PTy(FTy 40,qTy))]), + TP[Bop(BXor, + EX(Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 40, + qTy))))), + LN 2,LN 0,FTy 3), + CC[Var("v0",F1), + LW(0,2)]), + Var("s0", + PTy(bTy, + PTy(FTy 40,qTy)))])), + (LW(7,3), + TP[EX(Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 40, + qTy))))), + LN 2,LN 0,FTy 3), + Var("s", + PTy(bTy,PTy(FTy 40,qTy)))]), + (AVar(FTy 3), + Let(TP[Var("v",FTy 3), + Var("s3",PTy(FTy 40,qTy))], + Let(TP[Var("v",FTy 3), + qVar"s3"], + Apply + (Call + ("raise'exception", + ATy(qTy, + PTy(FTy 3,qTy)), + Call + ("UNPREDICTABLE", + CTy"exception", + LS + "bad access length")), + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 40, + qTy)))))), + TP[Var("v",FTy 3), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 40, + qTy))))), + qVar"s3"]), + TP[Var("v",FTy 3), + Mop(Fst, + Var("s", + PTy(bTy, + PTy(FTy 40, + qTy)))), + Var("s3",PTy(FTy 40,qTy))]))]), + TP[BFI(LN 2,LN 0,Var("v0",FTy 3), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 40, + qTy)))))), + Var("s0",PTy(bTy,PTy(FTy 40,qTy)))]), + TP[Mop(Fst, + Var("s",PTy(bTy,PTy(FTy 40,qTy)))), + Var("v",FTy 40), + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy,PTy(FTy 40,qTy)))))]), + Let(TP[bVar"v", + Var("s",PTy(bTy,PTy(FTy 40,qTy)))], + CS(Let(TP[bVar"v",qVar"s3"], + TP[Mop(Fst, + Apply + (Const + ("BigEndianMem", + ATy(qTy,PTy(bTy,qTy))), + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 40, + qTy))))))), + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 40,qTy)))))], + TP[bVar"v", + Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 40,qTy))))), + qVar"s3"]), + [(TP[bVar"v", + Var("s3",PTy(FTy 40,qTy))], + TP[bVar"v", + Mop(Fst, + Var("s", + PTy(bTy,PTy(FTy 40,qTy)))), + Var("s3",PTy(FTy 40,qTy))])]), + Let(Var("s",PTy(bTy,PTy(FTy 40,qTy))), + TP[Mop(Fst, + Var("s", + PTy(bTy,PTy(FTy 40,qTy)))), + ITE(bVar"v", + Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 40, + qTy))))), + Bop(BAnd, + Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 40, + qTy))))), + Mop(BNot,LW(7,40)))), + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 40,qTy)))))], + Let(TP[bVar"v", + Var("s", + PTy(bTy,PTy(FTy 40,qTy)))], + CS(Let(TP[bVar"v",qVar"s3"], + TP[Mop(Fst, + Apply + (Const + ("exceptionSignalled", + ATy(qTy, + PTy(bTy, + qTy))), + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 40, + qTy))))))), + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 40, + qTy)))))], + TP[bVar"v", + Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 40, + qTy))))), + qVar"s3"]), + [(TP[bVar"v", + Var("s3",PTy(FTy 40,qTy))], + TP[bVar"v", + Mop(Fst, + Var("s", + PTy(bTy, + PTy(FTy 40, + qTy)))), + Var("s3",PTy(FTy 40,qTy))])]), + Let(Var("s", + PTy(bTy,PTy(FTy 40,qTy))), + ITE(Mop(Not,bVar"v"), + Let(Var("v",FTy 37), + EX(Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 40, + qTy))))), + LN 39,LN 3,FTy 37), + Let(nVar"l", + Bop(Sub,LN 64, + Bop(Mul, + Bop(Add, + Bop(Add, + Mop(Cast + nTy, + Var("AccessLength", + FTy 3)), + LN + 1), + Mop(Cast + nTy, + EX(Var("vAddr", + F64), + LN + 2, + LN + 0, + FTy 3))), + LN 8)), + Let(Var("mask", + F64), + Mop(Cast F64, + Bop(Sub, + Bop(Exp, + LN + 2, + Bop(Add, + nVar"l", + Bop(Mul, + Bop(Add, + Mop(Cast + nTy, + Var("AccessLength", + FTy 3)), + LN + 1), + LN + 8))), + Bop(Exp, + LN + 2, + nVar"l"))), + Let(Var("s0", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))), + TP[LF, + Var("s", + PTy(bTy, + PTy(FTy 40, + qTy)))], + Let(Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))), + ITE(EQ(Var("v", + FTy 37), + Dest + ("base_address", + FTy 37, + Dest + ("JTAG_UART", + CTy"JTAG_UART", + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 40, + qTy)))))))), + Let(Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))), + TP[LT, + Mop(Snd, + Var("s0", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))))], + TP[Mop(Fst, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy))))), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))))), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy))))))), + Mop(Snd, + Apply + (Call + ("JTAG_UART_store", + ATy(qTy, + PTy(uTy, + qTy)), + TP[Var("mask", + F64), + Var("MemElem", + F64)]), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))))))))]), + Mop(Snd, + Apply + (For(TP[LN + 0, + Bop(Sub, + Dest + ("totalCore", + nTy, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))))))), + LN + 1), + Close + (nVar"core", + Close + (Var("state", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))), + ITE(Bop(And, + Bop(Uge, + Var("v", + FTy 37), + Apply + (Dest + ("PIC_base_address", + ATy(F8, + FTy 37), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("state", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))))))), + Mop(Cast + F8, + nVar"core"))), + Bop(Ult, + Var("v", + FTy 37), + Bop(Add, + Apply + (Dest + ("PIC_base_address", + ATy(F8, + FTy 37), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("state", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))))))), + Mop(Cast + F8, + nVar"core")), + LW(1072, + 37)))), + Let(Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))), + TP[LT, + Mop(Snd, + Var("state", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))))], + TP[LU, + Mop(Fst, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy))))), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))))), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy))))))), + Mop(Snd, + Apply + (Call + ("PIC_store", + ATy(qTy, + PTy(uTy, + qTy)), + TP[Mop(Cast + F8, + nVar"core"), + Var("v", + FTy 37), + Var("mask", + F64), + Var("MemElem", + F64)]), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))))))))]), + TP[LU, + Var("state", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy))))])))]), + Var("s0", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy))))))), + Let(Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))), + ITE(bVar"cond", + Let(TP[Var("v", + OTy bTy), + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy))))], + Let(TP[Var("v", + OTy bTy), + Var("s3", + PTy(bTy, + PTy(FTy 40, + qTy)))], + Let(TP[Var("v", + OTy bTy), + Var("s3", + PTy(FTy 40, + qTy))], + Let(TP[Var("v", + OTy bTy), + qVar"s3"], + TP[Mop(Fst, + Apply + (Const + ("LLbit", + ATy(qTy, + PTy(OTy bTy, + qTy))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy))))))))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))))))], + TP[Var("v", + OTy bTy), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy))))))), + qVar"s3"]), + TP[Var("v", + OTy bTy), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))))), + Var("s3", + PTy(FTy 40, + qTy))]), + TP[Var("v", + OTy bTy), + Mop(Fst, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy))))), + Var("s3", + PTy(bTy, + PTy(FTy 40, + qTy)))]), + CS(Var("v", + OTy bTy), + [(LO bTy, + TP[Mop(Fst, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy))))), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))))), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy))))))), + Mop(Snd, + Apply + (Call + ("raise'exception", + ATy(qTy, + PTy(uTy, + qTy)), + Call + ("UNPREDICTABLE", + CTy"exception", + LS + "conditional store: LLbit not set")), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))))))))]), + (Mop(Some, + LF), + TP[Mop(Fst, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy))))), + LF, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy))))))]), + (Mop(Some, + LT), + Let(TP[Var("v", + CTy"CP0__renamed__"), + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy))))], + Let(TP[Var("v", + CTy"CP0__renamed__"), + Var("s3", + PTy(bTy, + PTy(FTy 40, + qTy)))], + Let(TP[Var("v", + CTy"CP0__renamed__"), + Var("s3", + PTy(FTy 40, + qTy))], + Let(TP[Var("v", + CTy"CP0__renamed__"), + qVar"s3"], + TP[Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy))))))))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))))))], + TP[Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy))))))), + qVar"s3"]), + TP[Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))))), + Var("s3", + PTy(FTy 40, + qTy))]), + TP[Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy))))), + Var("s3", + PTy(bTy, + PTy(FTy 40, + qTy)))]), + TP[Mop(Fst, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy))))), + ITE(EQ(EX(Dest + ("LLAddr", + F64, + Var("v", + CTy"CP0__renamed__")), + LN + 39, + LN + 5, + FTy 35), + EX(Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy))))))), + LN + 39, + LN + 5, + FTy 35)), + TP[LT, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy))))))], + TP[Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))))), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy))))))), + Mop(Snd, + Apply + (Call + ("raise'exception", + ATy(qTy, + PTy(uTy, + qTy)), + Call + ("UNPREDICTABLE", + CTy"exception", + LS + "conditional store: address does not match previous LL address")), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))))))))])]))])), + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy))))), + Let(Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))), + TP[Mop(Fst, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy))))), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))))), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy))))))), + Mop(Snd, + Apply + (Call + ("write'LLbit", + ATy(qTy, + PTy(uTy, + qTy)), + LO bTy), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))))))))], + ITE(Mop(Not, + Mop(Fst, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))))), + Let(Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))), + Mop(Snd, + Apply + (For(TP[LN + 0, + Bop(Sub, + Dest + ("totalCore", + nTy, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))))))), + LN + 1), + Close + (nVar"core", + Close + (Var("state", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))), + TP[LU, + ITE(Bop(And, + Bop(And, + Mop(Not, + EQ(nVar"core", + Mop(Cast + nTy, + Dest + ("procID", + F8, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("state", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy))))))))))), + EQ(Apply + (Dest + ("c_LLbit", + ATy(F8, + OTy bTy), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("state", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))))))), + Mop(Cast + F8, + nVar"core")), + Mop(Some, + LT))), + EQ(EX(Dest + ("LLAddr", + F64, + Apply + (Dest + ("c_CP0", + ATy(F8, + CTy"CP0__renamed__"), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("state", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))))))), + Mop(Cast + F8, + nVar"core"))), + LN + 39, + LN + 5, + FTy 35), + EX(Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("state", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy))))))), + LN + 39, + LN + 5, + FTy 35))), + TP[Mop(Fst, + Var("state", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy))))), + Let(Var("s0", + PTy(bTy, + PTy(FTy 40, + qTy))), + Mop(Snd, + Var("state", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy))))), + TP[Mop(Fst, + Var("s0", + PTy(bTy, + PTy(FTy 40, + qTy)))), + Let(Var("s0", + PTy(FTy 40, + qTy)), + Mop(Snd, + Var("s0", + PTy(bTy, + PTy(FTy 40, + qTy)))), + TP[Mop(Fst, + Var("s0", + PTy(FTy 40, + qTy))), + Rupd + ("c_LLbit", + TP[Mop(Snd, + Var("s0", + PTy(FTy 40, + qTy))), + Fupd + (Dest + ("c_LLbit", + ATy(F8, + OTy bTy), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("state", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))))))), + Mop(Cast + F8, + nVar"core"), + Mop(Some, + LF))])])])], + Var("state", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))))]))]), + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))))), + ITE(Bop(Or, + Mop(Not, + bVar"cond"), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy))))))), + Let(Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))), + TP[Mop(Fst, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy))))), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))))), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy))))))), + Mop(Snd, + Apply + (Call + ("WriteData", + ATy(qTy, + PTy(uTy, + qTy)), + TP[Var("v", + FTy 37), + Var("MemElem", + F64), + Var("mask", + F64)]), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))))))))], + Let(Var("s0", + PTy(bTy, + PTy(FTy 40, + qTy))), + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy))))), + TP[Mop(Fst, + Var("s0", + PTy(bTy, + PTy(FTy 40, + qTy)))), + Let(Var("s0", + PTy(FTy 40, + qTy)), + Mop(Snd, + Var("s0", + PTy(bTy, + PTy(FTy 40, + qTy)))), + TP[Mop(Fst, + Var("s0", + PTy(FTy 40, + qTy))), + Rupd + ("TAG", + TP[Mop(Snd, + Var("s0", + PTy(FTy 40, + qTy))), + Fupd + (Dest + ("TAG", + ATy(FTy 35, + bTy), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))))))), + EX(Var("v", + FTy 37), + LN + 36, + LN + 2, + FTy 35), + LF)])])])), + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy))))))), + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy))))))))))))), + Var("s", + PTy(bTy, + PTy(FTy 40,qTy)))), + TP[Mop(Fst, + Var("s", + PTy(bTy, + PTy(FTy 40, + qTy)))), + Var("s", + PTy(bTy, + PTy(FTy 40,qTy)))])))))))), + TP[bVar"r",Mop(Snd,Var("s1",PTy(bTy,PTy(FTy 40,qTy))))]), + TP[bVar"r",Mop(Snd,Var("s1",PTy(FTy 40,qTy)))]))) +; +val StoreMemory_def = Def + ("StoreMemory", + TP[Var("MemType",FTy 3),Var("AccessLength",FTy 3),Var("MemElem",F64), + Var("vAddr",F64),Var("IorD",CTy"IorD"), + Var("AccessType",CTy"AccessType"),bVar"cond"], + Close + (qVar"state", + Let(Var("v",F64), + Bop(Add, + Bop(Add,Var("vAddr",F64), + Dest + ("base",F64, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + LW(0,5)),qVar"state")))), + Dest + ("offset",F64, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + LW(0,5)),qVar"state")))), + ITB([(Mop(Not, + Dest + ("tag",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + LW(0,5)),qVar"state")))), + TP[LX bTy, + Mop(Snd, + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcTag",CTy"CapException"),LW(0,5)]), + qVar"state"))]), + (Dest + ("sealed",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + LW(0,5)),qVar"state"))), + TP[LX bTy, + Mop(Snd, + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcSeal",CTy"CapException"),LW(0,5)]), + qVar"state"))]), + (Bop(Ult,Var("v",F64), + Dest + ("base",F64, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + LW(0,5)),qVar"state")))), + TP[LX bTy, + Mop(Snd, + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcLength",CTy"CapException"), + LW(0,5)]),qVar"state"))]), + (Bop(Ugt,Var("v",F64), + Bop(Add, + Dest + ("base",F64, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + LW(0,5)),qVar"state"))), + Dest + ("length",F64, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + LW(0,5)),qVar"state"))))), + TP[LX bTy, + Mop(Snd, + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcLength",CTy"CapException"), + LW(0,5)]),qVar"state"))]), + (Mop(Not, + Dest + ("Permit_Store",bTy, + Call + ("rec'Perms",CTy"Perms", + Dest + ("perms",FTy 31, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + LW(0,5)),qVar"state")))))), + TP[LX bTy, + Mop(Snd, + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcPermStore",CTy"CapException"), + LW(0,5)]),qVar"state"))])], + Apply + (Call + ("StoreMemoryCap",ATy(qTy,PTy(bTy,qTy)), + TP[Var("MemType",FTy 3),Var("AccessLength",FTy 3), + Var("MemElem",F64),Var("v",F64), + Var("IorD",CTy"IorD"), + Var("AccessType",CTy"AccessType"),bVar"cond"]), + qVar"state"))))) +; +val StoreCap_def = Def + ("StoreCap",TP[Var("vAddr",F64),Var("Capability",CTy"Capability")], + Close + (qVar"state", + Let(TP[Var("v",PTy(FTy 40,PTy(FTy 3,PTy(bTy,bTy)))),qVar"s"], + Apply + (Call + ("AddressTranslation", + ATy(qTy,PTy(PTy(FTy 40,PTy(FTy 3,PTy(bTy,bTy))),qTy)), + TP[Var("vAddr",F64),LC("DATA",CTy"IorD"), + LC("CSTORE",CTy"AccessType")]),qVar"state"), + Let(TP[Var("pAddr",FTy 40),Var("CCA",FTy 3),bVar"S",bVar"L"], + Var("v",PTy(FTy 40,PTy(FTy 3,PTy(bTy,bTy)))), + ITE(Mop(Not, + Mop(Fst, + Apply + (Const + ("exceptionSignalled",ATy(qTy,PTy(bTy,qTy))), + qVar"s"))), + Let(Var("a",FTy 35), + EX(Var("pAddr",FTy 40),LN 39,LN 5,FTy 35), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'LLbit",ATy(qTy,PTy(uTy,qTy)), + LO bTy), + ITE(EQ(Var("a",FTy 35), + EX(Dest + ("base_address",FTy 37, + Dest + ("JTAG_UART", + CTy"JTAG_UART",qVar"s")), + LN 36,LN 2,FTy 35)), + Mop(Snd, + Apply + (Call + ("raise'exception", + ATy(qTy,PTy(uTy,qTy)), + Call + ("UNPREDICTABLE", + CTy"exception", + LS + "Capability store attempted on UART")), + qVar"s")), + Mop(Snd, + Apply + (For(TP[LN 0, + Bop(Sub, + Dest + ("totalCore",nTy, + qVar"s"),LN 1), + Close + (nVar"core", + Close + (qVar"state", + ITE(Bop(And, + Bop(Uge, + Var("a", + FTy 35), + EX(Apply + (Dest + ("PIC_base_address", + ATy(F8, + FTy 37), + qVar"state"), + Mop(Cast + F8, + nVar"core")), + LN + 36, + LN + 2, + FTy 35)), + Bop(Ult, + Var("a", + FTy 35), + EX(Bop(Add, + Apply + (Dest + ("PIC_base_address", + ATy(F8, + FTy 37), + qVar"state"), + Mop(Cast + F8, + nVar"core")), + LW(1072, + 37)), + LN + 36, + LN + 2, + FTy 35))), + Apply + (Call + ("raise'exception", + ATy(qTy, + PTy(uTy, + qTy)), + Call + ("UNPREDICTABLE", + CTy"exception", + LS + "Capability store attempted on PIC")), + qVar"state"), + TP[LU, + qVar"state"])))]), + qVar"s"))))), + ITE(Bop(And,bVar"S", + Dest + ("tag",bTy, + Var("Capability",CTy"Capability"))), + Apply + (Call + ("SignalCapException_noReg", + ATy(qTy,PTy(uTy,qTy)), + LC("capExcTLBNoStore", + CTy"CapException")),qVar"s"), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("WriteData", + ATy(qTy,PTy(uTy,qTy)), + TP[CC[Var("a",FTy 35),LW(3,2)], + EX(Call + ("reg'Capability", + FTy 257, + Var("Capability", + CTy"Capability")), + LN 63,LN 0,F64), + Mop(BNot,LW(0,64))]), + Mop(Snd, + Apply + (Call + ("WriteData", + ATy(qTy,PTy(uTy,qTy)), + TP[CC[Var("a",FTy 35), + LW(2,2)], + EX(Call + ("reg'Capability", + FTy 257, + Var("Capability", + CTy"Capability")), + LN 127,LN 64,F64), + Mop(BNot,LW(0,64))]), + Mop(Snd, + Apply + (Call + ("WriteData", + ATy(qTy, + PTy(uTy,qTy)), + TP[CC[Var("a", + FTy 35), + LW(1,2)], + EX(Call + ("reg'Capability", + FTy 257, + Var("Capability", + CTy"Capability")), + LN 191, + LN 128,F64), + Mop(BNot, + LW(0,64))]), + Mop(Snd, + Apply + (Call + ("WriteData", + ATy(qTy, + PTy(uTy, + qTy)), + TP[CC[Var("a", + FTy 35), + LW(0, + 2)], + EX(Call + ("reg'Capability", + FTy 257, + Var("Capability", + CTy"Capability")), + LN + 255, + LN + 192, + F64), + Mop(BNot, + LW(0, + 64))]), + Mop(Snd, + Apply + (Call + ("mark_log", + ATy(qTy, + PTy(uTy, + qTy)), + TP[LN + 2, + Call + ("log_store_cap", + sTy, + TP[Var("pAddr", + FTy 40), + Var("Capability", + CTy"Capability")])]), + Mop(Snd, + Apply + (For(TP[LN + 0, + Bop(Sub, + Dest + ("totalCore", + nTy, + qVar"s"), + LN + 1), + Close + (nVar"core", + Close + (qVar"state", + TP[LU, + ITE(Bop(And, + Bop(And, + Mop(Not, + EQ(nVar"core", + Mop(Cast + nTy, + Dest + ("procID", + F8, + qVar"state")))), + EQ(Apply + (Dest + ("c_LLbit", + ATy(F8, + OTy bTy), + qVar"state"), + Mop(Cast + F8, + nVar"core")), + Mop(Some, + LT))), + EQ(EX(Dest + ("LLAddr", + F64, + Apply + (Dest + ("c_CP0", + ATy(F8, + CTy"CP0__renamed__"), + qVar"state"), + Mop(Cast + F8, + nVar"core"))), + LN + 39, + LN + 5, + FTy 35), + EX(Var("pAddr", + FTy 40), + LN + 39, + LN + 5, + FTy 35))), + Rupd + ("c_LLbit", + TP[qVar"state", + Fupd + (Dest + ("c_LLbit", + ATy(F8, + OTy bTy), + qVar"state"), + Mop(Cast + F8, + nVar"core"), + Mop(Some, + LF))]), + qVar"state")]))]), + qVar"s")))))))))))), + TP[LU, + Rupd + ("TAG", + TP[qVar"s", + Fupd + (Dest + ("TAG",ATy(FTy 35,bTy), + qVar"s"),Var("a",FTy 35), + Dest + ("tag",bTy, + Var("Capability", + CTy"Capability")))])])))), + TP[LU,qVar"s"]))))) +; +val Fetch_def = Def + ("Fetch",qVar"state", + Let(Var("v",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Random", + TP[Var("v",CTy"CP0__renamed__"), + Rupd + ("Random", + TP[Dest + ("Random",CTy"Random", + Var("v",CTy"CP0__renamed__")), + ITE(EQ(Dest + ("Random",F8, + Dest + ("Random",CTy"Random", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"state")))), + Dest + ("Wired",F8, + Dest + ("Wired",CTy"Wired", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"state"))))), + Mop(Cast F8, + Bop(Sub,Const("TLBEntries",nTy), + LN 1)), + Bop(Sub, + Dest + ("Random",F8, + Dest + ("Random",CTy"Random", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"state")))), + LW(1,8)))])])),qVar"state")), + Let(qVar"s", + ITE(EQ(Dest + ("Compare",F32, + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"s"))), + Dest + ("Count",F32, + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"s")))), + Let(Var("v",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"s")), + Let(qVar"s", + Let(Var("x0",CTy"CauseRegister"), + Dest + ("Cause",CTy"CauseRegister", + Var("v",CTy"CP0__renamed__")), + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Cause", + TP[Var("v",CTy"CP0__renamed__"), + Rupd + ("IP", + TP[Var("x0", + CTy"CauseRegister"), + BFI(LN 7,LN 7, + Mop(Cast F1,LT), + Dest + ("IP",F8, + Var("x0", + CTy"CauseRegister")))])])), + qVar"s"))), + Let(Var("v",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__",qTy))), + qVar"s")), + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Cause", + TP[Var("v",CTy"CP0__renamed__"), + Rupd + ("TI", + TP[Dest + ("Cause", + CTy"CauseRegister", + Var("v", + CTy"CP0__renamed__")), + LT])])),qVar"s"))))), + qVar"s"), + Let(qVar"s", + ITE(Bop(And, + Dest + ("IE",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__",qTy))), + qVar"s")))), + Mop(Not, + Bop(Or, + Dest + ("EXL",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))),qVar"s")))), + Dest + ("ERL",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))),qVar"s"))))))), + ITE(Mop(Not, + EQ(Bop(BAnd, + EX(Dest + ("IM",F8, + Dest + ("Status", + CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")))),LN 7, + LN 2,FTy 6), + EX(Dest + ("IP",F8, + Dest + ("Cause",CTy"CauseRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")))),LN 7, + LN 2,FTy 6)),LW(0,6))), + Mop(Snd, + Apply + (Call + ("SignalException", + ATy(qTy,PTy(uTy,qTy)), + LC("Int",CTy"ExceptionType")),qVar"s")), + qVar"s"),qVar"s"), + ITB([(Mop(Fst, + Apply + (Const + ("exceptionSignalled", + ATy(qTy,PTy(bTy,qTy))),qVar"s")), + TP[LO F32,qVar"s"]), + (EQ(EX(Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))), + qVar"s")),LN 1,LN 0,FTy 2),LW(0,2)), + Let(Var("v",F64), + Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))), + qVar"s")), + Dest + ("base",F64, + Mop(Fst, + Apply + (Const + ("PCC", + ATy(qTy, + PTy(CTy"Capability",qTy))), + qVar"s")))), + ITB([(Mop(Not, + Dest + ("tag",bTy, + Mop(Fst, + Apply + (Const + ("PCC", + ATy(qTy, + PTy(CTy"Capability", + qTy))),qVar"s")))), + TP[LO F32, + Mop(Snd, + Apply + (Call + ("SignalCapException_noReg", + ATy(qTy,PTy(uTy,qTy)), + LC("capExcTag", + CTy"CapException")), + qVar"s"))]), + (Dest + ("sealed",bTy, + Mop(Fst, + Apply + (Const + ("PCC", + ATy(qTy, + PTy(CTy"Capability", + qTy))),qVar"s"))), + TP[LO F32, + Mop(Snd, + Apply + (Call + ("SignalCapException_noReg", + ATy(qTy,PTy(uTy,qTy)), + LC("capExcSeal", + CTy"CapException")), + qVar"s"))]), + (Bop(Ugt,Var("v",F64), + Bop(Add, + Dest + ("base",F64, + Mop(Fst, + Apply + (Const + ("PCC", + ATy(qTy, + PTy(CTy"Capability", + qTy))), + qVar"s"))), + Dest + ("length",F64, + Mop(Fst, + Apply + (Const + ("PCC", + ATy(qTy, + PTy(CTy"Capability", + qTy))), + qVar"s"))))), + TP[LO F32, + Mop(Snd, + Apply + (Call + ("SignalCapException_noReg", + ATy(qTy,PTy(uTy,qTy)), + LC("capExcLength", + CTy"CapException")), + qVar"s"))]), + (Bop(Ult,Var("v",F64), + Dest + ("base",F64, + Mop(Fst, + Apply + (Const + ("PCC", + ATy(qTy, + PTy(CTy"Capability", + qTy))),qVar"s")))), + TP[LO F32, + Mop(Snd, + Apply + (Call + ("SignalCapException_noReg", + ATy(qTy,PTy(uTy,qTy)), + LC("capExcLength", + CTy"CapException")), + qVar"s"))]), + (Mop(Not, + Dest + ("Permit_Execute",bTy, + Call + ("rec'Perms",CTy"Perms", + Dest + ("perms",FTy 31, + Mop(Fst, + Apply + (Const + ("PCC", + ATy(qTy, + PTy(CTy"Capability", + qTy))), + qVar"s")))))), + TP[LO F32, + Mop(Snd, + Apply + (Call + ("SignalCapException_noReg", + ATy(qTy,PTy(uTy,qTy)), + LC("capExcPermExe", + CTy"CapException")), + qVar"s"))])], + Let(TP[Var("v", + PTy(FTy 40, + PTy(FTy 3,PTy(bTy,bTy)))), + qVar"s"], + Apply + (Call + ("AddressTranslation", + ATy(qTy, + PTy(PTy(FTy 40, + PTy(FTy 3, + PTy(bTy,bTy))), + qTy)), + TP[Var("v",F64), + LC("INSTRUCTION",CTy"IorD"), + LC("LOAD",CTy"AccessType")]), + qVar"s"), + Let(TP[Var("pc",FTy 40), + Var("cca", + PTy(FTy 3,PTy(bTy,bTy)))], + Var("v", + PTy(FTy 40, + PTy(FTy 3,PTy(bTy,bTy)))), + TP[ITE(Mop(Fst, + Apply + (Const + ("exceptionSignalled", + ATy(qTy, + PTy(bTy,qTy))), + qVar"s")),LO F32, + Mop(Some, + Mop(Fst, + Apply + (Call + ("ReadInst", + ATy(qTy, + PTy(F32, + qTy)), + Var("pc", + FTy 40)), + qVar"s")))), + qVar"s"])))))], + TP[LO F32, + Mop(Snd, + Apply + (Call + ("SignalException", + ATy(qTy,PTy(uTy,qTy)), + LC("AdEL",CTy"ExceptionType")), + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy,PTy(uTy,qTy)), + Rupd + ("BadVAddr", + TP[Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Bop(Add, + Dest + ("base",F64, + Mop(Fst, + Apply + (Const + ("PCC", + ATy(qTy, + PTy(CTy"Capability", + qTy))), + qVar"s"))), + Mop(Fst, + Apply + (Const + ("PC", + ATy(qTy, + PTy(F64, + qTy))), + qVar"s")))])), + qVar"s"))))])))))) +; +val dfn'JALR_def = Def + ("dfn'JALR",TP[Var("rs",FTy 5),Var("rd",FTy 5)], + Close + (qVar"state", + Apply + (Call + ("write'BranchTo",ATy(qTy,PTy(uTy,qTy)), + Mop(Some, + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")))), + Mop(Snd, + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))), + qVar"state")),LW(8,64)),Var("rd",FTy 5)]), + qVar"state"))))) +; +val register_inaccessible_def = Def + ("register_inaccessible",Var("cb",FTy 5), + Close + (qVar"state", + Let(Var("v",CTy"Perms"), + Call + ("rec'Perms",CTy"Perms", + Dest + ("perms",FTy 31, + Mop(Fst, + Apply + (Const("PCC",ATy(qTy,PTy(CTy"Capability",qTy))), + qVar"state")))), + TP[Bop(Or, + Bop(Or, + Bop(Or, + Bop(Or, + Bop(And,EQ(Var("cb",FTy 5),LW(31,5)), + Mop(Not, + Dest + ("Access_EPCC",bTy, + Var("v",CTy"Perms")))), + Bop(And,EQ(Var("cb",FTy 5),LW(30,5)), + Mop(Not, + Dest + ("Access_KDC",bTy, + Var("v",CTy"Perms"))))), + Bop(And,EQ(Var("cb",FTy 5),LW(29,5)), + Mop(Not, + Dest + ("Access_KCC",bTy,Var("v",CTy"Perms"))))), + Bop(And,EQ(Var("cb",FTy 5),LW(27,5)), + Mop(Not, + Dest("Access_KR1C",bTy,Var("v",CTy"Perms"))))), + Bop(And,EQ(Var("cb",FTy 5),LW(28,5)), + Mop(Not,Dest("Access_KR2C",bTy,Var("v",CTy"Perms"))))), + qVar"state"]))) +; +val SignExtendBitString_def = Def + ("SignExtendBitString",TP[nVar"w",vVar"x"], + Mop(PadLeft,TP[Mop(Head,vVar"x"),nVar"w",vVar"x"])) +; +val dfn'DumpCapReg_def = Def + ("dfn'DumpCapReg",qVar"state", + Apply(Call("dumpCRegs",ATy(qTy,PTy(uTy,qTy)),LU),qVar"state")) +; +val dfn'CGetBase_def = Def + ("dfn'CGetBase",TP[Var("rd",FTy 5),Var("cb",FTy 5)], + Close + (qVar"state", + ITB([(Mop(Not, + Dest + ("CU2",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))), + Apply + (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), + qVar"state")), + (Mop(Fst, + Apply + (Call + ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), + Var("cb",FTy 5)),qVar"state")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cb",FTy 5)),qVar"state"))], + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Dest + ("base",F64, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state"))), + Var("rd",FTy 5)]),qVar"state")))) +; +val dfn'CGetOffset_def = Def + ("dfn'CGetOffset",TP[Var("rd",FTy 5),Var("cb",FTy 5)], + Close + (qVar"state", + ITB([(Mop(Not, + Dest + ("CU2",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))), + Apply + (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), + qVar"state")), + (Mop(Fst, + Apply + (Call + ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), + Var("cb",FTy 5)),qVar"state")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cb",FTy 5)),qVar"state"))], + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Dest + ("offset",F64, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state"))), + Var("rd",FTy 5)]),qVar"state")))) +; +val dfn'CGetLen_def = Def + ("dfn'CGetLen",TP[Var("rd",FTy 5),Var("cb",FTy 5)], + Close + (qVar"state", + ITB([(Mop(Not, + Dest + ("CU2",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))), + Apply + (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), + qVar"state")), + (Mop(Fst, + Apply + (Call + ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), + Var("cb",FTy 5)),qVar"state")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cb",FTy 5)),qVar"state"))], + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Dest + ("length",F64, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state"))), + Var("rd",FTy 5)]),qVar"state")))) +; +val dfn'CGetTag_def = Def + ("dfn'CGetTag",TP[Var("rd",FTy 5),Var("cb",FTy 5)], + Close + (qVar"state", + ITB([(Mop(Not, + Dest + ("CU2",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))), + Apply + (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), + qVar"state")), + (Mop(Fst, + Apply + (Call + ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), + Var("cb",FTy 5)),qVar"state")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cb",FTy 5)),qVar"state"))], + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[BFI(LN 0,LN 0, + Mop(Cast F1, + Dest + ("tag",bTy, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("cb",FTy 5)), + qVar"state")))), + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rd",FTy 5)),qVar"state"))), + Var("rd",FTy 5)]),qVar"state")), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[BFI(LN 63,LN 1,LW(0,63), + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rd",FTy 5)),qVar"s"))), + Var("rd",FTy 5)]),qVar"s"))))) +; +val dfn'CGetSealed_def = Def + ("dfn'CGetSealed",TP[Var("rd",FTy 5),Var("cb",FTy 5)], + Close + (qVar"state", + ITB([(Mop(Not, + Dest + ("CU2",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))), + Apply + (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), + qVar"state")), + (Mop(Fst, + Apply + (Call + ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), + Var("cb",FTy 5)),qVar"state")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cb",FTy 5)),qVar"state"))], + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[BFI(LN 0,LN 0, + Mop(Cast F1, + Dest + ("sealed",bTy, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("cb",FTy 5)), + qVar"state")))), + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rd",FTy 5)),qVar"state"))), + Var("rd",FTy 5)]),qVar"state")), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[BFI(LN 63,LN 1,LW(0,63), + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rd",FTy 5)),qVar"s"))), + Var("rd",FTy 5)]),qVar"s"))))) +; +val dfn'CGetPerm_def = Def + ("dfn'CGetPerm",TP[Var("rd",FTy 5),Var("cb",FTy 5)], + Close + (qVar"state", + ITB([(Mop(Not, + Dest + ("CU2",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))), + Apply + (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), + qVar"state")), + (Mop(Fst, + Apply + (Call + ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), + Var("cb",FTy 5)),qVar"state")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cb",FTy 5)),qVar"state"))], + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[BFI(LN 30,LN 0, + Dest + ("perms",FTy 31, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state"))), + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rd",FTy 5)),qVar"state"))), + Var("rd",FTy 5)]),qVar"state")), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[BFI(LN 63,LN 31,LW(0,33), + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rd",FTy 5)),qVar"s"))), + Var("rd",FTy 5)]),qVar"s"))))) +; +val dfn'CGetType_def = Def + ("dfn'CGetType",TP[Var("rd",FTy 5),Var("cb",FTy 5)], + Close + (qVar"state", + ITB([(Mop(Not, + Dest + ("CU2",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))), + Apply + (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), + qVar"state")), + (Mop(Fst, + Apply + (Call + ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), + Var("cb",FTy 5)),qVar"state")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cb",FTy 5)),qVar"state"))], + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[BFI(LN 23,LN 0, + Dest + ("otype",FTy 24, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state"))), + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rd",FTy 5)),qVar"state"))), + Var("rd",FTy 5)]),qVar"state")), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[BFI(LN 63,LN 24,LW(0,40), + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rd",FTy 5)),qVar"s"))), + Var("rd",FTy 5)]),qVar"s"))))) +; +val dfn'CGetPCC_def = Def + ("dfn'CGetPCC",Var("cd",FTy 5), + Close + (qVar"state", + ITB([(Mop(Not, + Dest + ("CU2",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))), + Apply + (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), + qVar"state")), + (Mop(Fst, + Apply + (Call + ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), + Var("cd",FTy 5)),qVar"state")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cd",FTy 5)),qVar"state"))], + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Fst, + Apply + (Const + ("PCC", + ATy(qTy,PTy(CTy"Capability",qTy))), + qVar"state")),Var("cd",FTy 5)]), + qVar"state")), + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Rupd + ("offset", + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cd",FTy 5)),qVar"s")), + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))), + qVar"s"))]),Var("cd",FTy 5)]),qVar"s"))))) +; +val dfn'CGetCause_def = Def + ("dfn'CGetCause",Var("rd",FTy 5), + Close + (qVar"state", + ITB([(Mop(Not, + Dest + ("CU2",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))), + Apply + (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), + qVar"state")), + (Mop(Not, + Dest + ("Access_EPCC",bTy, + Call + ("rec'Perms",CTy"Perms", + Dest + ("perms",FTy 31, + Mop(Fst, + Apply + (Const + ("PCC",ATy(qTy,PTy(CTy"Capability",qTy))), + qVar"state")))))), + Apply + (Call + ("SignalCapException_noReg",ATy(qTy,PTy(uTy,qTy)), + LC("capExcAccEPCC",CTy"CapException")),qVar"state"))], + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[BFI(LN 7,LN 0, + Dest + ("RegNum",F8, + Mop(Fst, + Apply + (Const + ("capcause", + ATy(qTy,PTy(CTy"CapCause",qTy))), + qVar"state"))), + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rd",FTy 5)),qVar"state"))), + Var("rd",FTy 5)]),qVar"state")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[BFI(LN 15,LN 8, + Dest + ("ExcCode",F8, + Mop(Fst, + Apply + (Const + ("capcause", + ATy(qTy, + PTy(CTy"CapCause",qTy))), + qVar"s"))), + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rd",FTy 5)),qVar"s"))), + Var("rd",FTy 5)]),qVar"s")), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[BFI(LN 63,LN 16,LW(0,48), + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rd",FTy 5)),qVar"s"))), + Var("rd",FTy 5)]),qVar"s")))))) +; +val dfn'CSetCause_def = Def + ("dfn'CSetCause",Var("rt",FTy 5), + Close + (qVar"state", + ITB([(Mop(Not, + Dest + ("CU2",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))), + Apply + (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), + qVar"state")), + (Mop(Not, + Dest + ("Access_EPCC",bTy, + Call + ("rec'Perms",CTy"Perms", + Dest + ("perms",FTy 31, + Mop(Fst, + Apply + (Const + ("PCC",ATy(qTy,PTy(CTy"Capability",qTy))), + qVar"state")))))), + Apply + (Call + ("SignalCapException_noReg",ATy(qTy,PTy(uTy,qTy)), + LC("capExcAccEPCC",CTy"CapException")),qVar"state"))], + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'capcause",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("ExcCode", + TP[Mop(Fst, + Apply + (Const + ("capcause", + ATy(qTy,PTy(CTy"CapCause",qTy))), + qVar"state")), + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"state")), + LN 15,LN 8,F8)])),qVar"state")), + Apply + (Call + ("write'capcause",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("RegNum", + TP[Mop(Fst, + Apply + (Const + ("capcause", + ATy(qTy,PTy(CTy"CapCause",qTy))), + qVar"s")), + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"s")),LN 7, + LN 0,F8)])),qVar"s"))))) +; +val dfn'CIncBase_def = Def + ("dfn'CIncBase",TP[Var("cd",FTy 5),Var("cb",FTy 5),Var("rt",FTy 5)], + Close + (qVar"state", + ITB([(Mop(Not, + Dest + ("CU2",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))), + Apply + (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), + qVar"state")), + (Mop(Fst, + Apply + (Call + ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), + Var("cd",FTy 5)),qVar"state")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cd",FTy 5)),qVar"state")), + (Mop(Fst, + Apply + (Call + ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), + Var("cb",FTy 5)),qVar"state")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cb",FTy 5)),qVar"state")), + (Bop(And, + Mop(Not, + Dest + ("tag",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")))), + Mop(Not, + EQ(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"state")),LW(0,64)))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcTag",CTy"CapException"),Var("cb",FTy 5)]), + qVar"state")), + (Bop(And, + Dest + ("sealed",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state"))), + Mop(Not, + EQ(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"state")),LW(0,64)))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcSeal",CTy"CapException"),Var("cb",FTy 5)]), + qVar"state")), + (Bop(Ugt, + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state")), + Dest + ("length",F64, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcLength",CTy"CapException"),Var("cb",FTy 5)]), + qVar"state"))], + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")), + Var("cd",FTy 5)]),qVar"state")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Rupd + ("base", + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability",qTy)), + Var("cd",FTy 5)),qVar"s")), + Bop(Add, + Dest + ("base",F64, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("cb",FTy 5)), + qVar"s"))), + Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)), + qVar"s")))]), + Var("cd",FTy 5)]),qVar"s")), + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Rupd + ("length", + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability",qTy)), + Var("cd",FTy 5)),qVar"s")), + Bop(Sub, + Dest + ("length",F64, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("cb",FTy 5)),qVar"s"))), + Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"s")))]), + Var("cd",FTy 5)]),qVar"s")))))) +; +val dfn'CSetLen_def = Def + ("dfn'CSetLen",TP[Var("cd",FTy 5),Var("cb",FTy 5),Var("rt",FTy 5)], + Close + (qVar"state", + ITB([(Mop(Not, + Dest + ("CU2",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))), + Apply + (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), + qVar"state")), + (Mop(Fst, + Apply + (Call + ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), + Var("cd",FTy 5)),qVar"state")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cd",FTy 5)),qVar"state")), + (Mop(Fst, + Apply + (Call + ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), + Var("cb",FTy 5)),qVar"state")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cb",FTy 5)),qVar"state")), + (Mop(Not, + Dest + ("tag",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcTag",CTy"CapException"),Var("cb",FTy 5)]), + qVar"state")), + (Dest + ("sealed",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state"))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcSeal",CTy"CapException"),Var("cb",FTy 5)]), + qVar"state")), + (Bop(Ugt, + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state")), + Dest + ("length",F64, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcLength",CTy"CapException"),Var("cb",FTy 5)]), + qVar"state"))], + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")), + Var("cd",FTy 5)]),qVar"state")), + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Rupd + ("length", + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cd",FTy 5)),qVar"s")), + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"s"))]), + Var("cd",FTy 5)]),qVar"s"))))) +; +val dfn'CClearTag_def = Def + ("dfn'CClearTag",TP[Var("cd",FTy 5),Var("cb",FTy 5)], + Close + (qVar"state", + ITB([(Mop(Not, + Dest + ("CU2",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))), + Apply + (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), + qVar"state")), + (Mop(Fst, + Apply + (Call + ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), + Var("cd",FTy 5)),qVar"state")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cd",FTy 5)),qVar"state")), + (Mop(Fst, + Apply + (Call + ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), + Var("cb",FTy 5)),qVar"state")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cb",FTy 5)),qVar"state"))], + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")), + Var("cd",FTy 5)]),qVar"state")), + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Rupd + ("tag", + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cd",FTy 5)),qVar"s")),LF]), + Var("cd",FTy 5)]),qVar"s"))))) +; +val dfn'CAndPerm_def = Def + ("dfn'CAndPerm",TP[Var("cd",FTy 5),Var("cb",FTy 5),Var("rt",FTy 5)], + Close + (qVar"state", + ITB([(Mop(Not, + Dest + ("CU2",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))), + Apply + (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), + qVar"state")), + (Mop(Fst, + Apply + (Call + ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), + Var("cd",FTy 5)),qVar"state")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cd",FTy 5)),qVar"state")), + (Mop(Fst, + Apply + (Call + ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), + Var("cb",FTy 5)),qVar"state")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cb",FTy 5)),qVar"state")), + (Mop(Not, + Dest + ("tag",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcTag",CTy"CapException"),Var("cb",FTy 5)]), + qVar"state")), + (Dest + ("sealed",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state"))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcSeal",CTy"CapException"),Var("cb",FTy 5)]), + qVar"state"))], + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")), + Var("cd",FTy 5)]),qVar"state")), + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Rupd + ("perms", + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cd",FTy 5)),qVar"s")), + Bop(BAnd, + Dest + ("perms",FTy 31, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability",qTy)), + Var("cd",FTy 5)),qVar"s"))), + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"s")), + LN 30,LN 0,FTy 31))]),Var("cd",FTy 5)]), + qVar"s"))))) +; +val dfn'CSetOffset_def = Def + ("dfn'CSetOffset",TP[Var("cd",FTy 5),Var("cb",FTy 5),Var("rt",FTy 5)], + Close + (qVar"state", + ITB([(Mop(Not, + Dest + ("CU2",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))), + Apply + (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), + qVar"state")), + (Mop(Fst, + Apply + (Call + ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), + Var("cd",FTy 5)),qVar"state")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cd",FTy 5)),qVar"state")), + (Mop(Fst, + Apply + (Call + ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), + Var("cb",FTy 5)),qVar"state")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cb",FTy 5)),qVar"state")), + (Bop(And, + Mop(Not, + Dest + ("tag",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")))), + Dest + ("sealed",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcSeal",CTy"CapException"),Var("cb",FTy 5)]), + qVar"state"))], + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")), + Var("cd",FTy 5)]),qVar"state")), + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Rupd + ("offset", + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cd",FTy 5)),qVar"s")), + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"s"))]), + Var("cd",FTy 5)]),qVar"s"))))) +; +val dfn'CCheckPerm_def = Def + ("dfn'CCheckPerm",TP[Var("cs",FTy 5),Var("rt",FTy 5)], + Close + (qVar"state", + ITB([(Mop(Not, + Dest + ("CU2",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))), + Apply + (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), + qVar"state")), + (Mop(Fst, + Apply + (Call + ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), + Var("cs",FTy 5)),qVar"state")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cs",FTy 5)),qVar"state")), + (Mop(Not, + Dest + ("tag",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cs",FTy 5)),qVar"state")))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcTag",CTy"CapException"),Var("cs",FTy 5)]), + qVar"state")), + (Mop(Not, + EQ(Bop(BAnd, + Dest + ("perms",FTy 31, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cs",FTy 5)),qVar"state"))), + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"state")),LN 30, + LN 0,FTy 31)), + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"state")),LN 30,LN 0, + FTy 31))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcUser",CTy"CapException"),Var("cs",FTy 5)]), + qVar"state"))],TP[LU,qVar"state"]))) +; +val dfn'CCheckType_def = Def + ("dfn'CCheckType",TP[Var("cs",FTy 5),Var("cb",FTy 5)], + Close + (qVar"state", + ITB([(Mop(Not, + Dest + ("CU2",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))), + Apply + (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), + qVar"state")), + (Mop(Fst, + Apply + (Call + ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), + Var("cs",FTy 5)),qVar"state")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cs",FTy 5)),qVar"state")), + (Mop(Fst, + Apply + (Call + ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), + Var("cb",FTy 5)),qVar"state")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cb",FTy 5)),qVar"state")), + (Mop(Not, + Dest + ("tag",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cs",FTy 5)),qVar"state")))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcTag",CTy"CapException"),Var("cs",FTy 5)]), + qVar"state")), + (Mop(Not, + Dest + ("tag",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcTag",CTy"CapException"),Var("cb",FTy 5)]), + qVar"state")), + (Mop(Not, + Dest + ("sealed",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cs",FTy 5)),qVar"state")))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcSeal",CTy"CapException"),Var("cs",FTy 5)]), + qVar"state")), + (Mop(Not, + Dest + ("sealed",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcSeal",CTy"CapException"),Var("cb",FTy 5)]), + qVar"state")), + (Mop(Not, + EQ(Dest + ("otype",FTy 24, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cs",FTy 5)),qVar"state"))), + Dest + ("otype",FTy 24, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state"))))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcType",CTy"CapException"),Var("cs",FTy 5)]), + qVar"state"))],TP[LU,qVar"state"]))) +; +val dfn'CFromPtr_def = Def + ("dfn'CFromPtr",TP[Var("cd",FTy 5),Var("cb",FTy 5),Var("rt",FTy 5)], + Close + (qVar"state", + ITB([(Mop(Not, + Dest + ("CU2",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))), + Apply + (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), + qVar"state")), + (Mop(Fst, + Apply + (Call + ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), + Var("cd",FTy 5)),qVar"state")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cd",FTy 5)),qVar"state")), + (Mop(Fst, + Apply + (Call + ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), + Var("cb",FTy 5)),qVar"state")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cb",FTy 5)),qVar"state")), + (EQ(Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state")),LW(0,64)), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Rupd + ("tag", + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability",qTy)), + Var("cd",FTy 5)),qVar"state")), + LF]),Var("cd",FTy 5)]),qVar"state")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Rupd + ("sealed", + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("cd",FTy 5)),qVar"s")), + LF]),Var("cd",FTy 5)]),qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Rupd + ("perms", + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("cd",FTy 5)), + qVar"s")),LW(0,31)]), + Var("cd",FTy 5)]),qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Rupd + ("base", + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("cd",FTy 5)), + qVar"s")),LW(0,64)]), + Var("cd",FTy 5)]),qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CAPR", + ATy(qTy,PTy(uTy,qTy)), + TP[Rupd + ("length", + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("cd", + FTy 5)), + qVar"s")), + LW(0,64)]), + Var("cd",FTy 5)]),qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CAPR", + ATy(qTy,PTy(uTy,qTy)), + TP[Rupd + ("offset", + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("cd", + FTy 5)), + qVar"s")), + LW(0,64)]), + Var("cd",FTy 5)]),qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CAPR", + ATy(qTy,PTy(uTy,qTy)), + TP[Rupd + ("otype", + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("cd", + FTy 5)), + qVar"s")), + LW(0,24)]), + Var("cd",FTy 5)]), + qVar"s")), + Apply + (Call + ("write'CAPR", + ATy(qTy,PTy(uTy,qTy)), + TP[Rupd + ("reserved", + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("cd", + FTy 5)), + qVar"s")), + LW(0,8)]), + Var("cd",FTy 5)]),qVar"s"))))))))), + (Mop(Not, + Dest + ("tag",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcTag",CTy"CapException"),Var("cb",FTy 5)]), + qVar"state")), + (Dest + ("sealed",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state"))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcSeal",CTy"CapException"),Var("cb",FTy 5)]), + qVar"state")), + (Bop(Ugt, + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state")), + Dest + ("length",F64, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcLength",CTy"CapException"),Var("cb",FTy 5)]), + qVar"state"))], + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")), + Var("cd",FTy 5)]),qVar"state")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Rupd + ("base", + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability",qTy)), + Var("cd",FTy 5)),qVar"s")), + Bop(Add, + Dest + ("base",F64, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("cb",FTy 5)), + qVar"s"))), + Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)), + qVar"s")))]), + Var("cd",FTy 5)]),qVar"s")), + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Rupd + ("length", + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability",qTy)), + Var("cd",FTy 5)),qVar"s")), + Bop(Sub, + Dest + ("length",F64, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("cb",FTy 5)),qVar"s"))), + Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"s")))]), + Var("cd",FTy 5)]),qVar"s")))))) +; +val dfn'CToPtr_def = Def + ("dfn'CToPtr",TP[Var("rd",FTy 5),Var("cb",FTy 5),Var("ct",FTy 5)], + Close + (qVar"state", + ITB([(Mop(Not, + Dest + ("CU2",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))), + Apply + (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), + qVar"state")), + (Mop(Fst, + Apply + (Call + ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), + Var("cb",FTy 5)),qVar"state")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cb",FTy 5)),qVar"state")), + (Mop(Fst, + Apply + (Call + ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), + Var("ct",FTy 5)),qVar"state")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("ct",FTy 5)),qVar"state")), + (Mop(Not, + Dest + ("tag",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("ct",FTy 5)),qVar"state")))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcTag",CTy"CapException"),Var("ct",FTy 5)]), + qVar"state")), + (Mop(Not, + Dest + ("tag",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")))), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[LW(0,64),Var("rd",FTy 5)]),qVar"state"))], + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Bop(Sub, + Bop(Add, + Dest + ("base",F64, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state"))), + Dest + ("offset",F64, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")))), + Dest + ("base",F64, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("ct",FTy 5)),qVar"state")))), + Var("rd",FTy 5)]),qVar"state")))) +; +val dfn'CPtrCmp_def = Def + ("dfn'CPtrCmp", + TP[Var("rd",FTy 5),Var("cb",FTy 5),Var("ct",FTy 5),Var("t",FTy 3)], + Close + (qVar"state", + ITE(Mop(Not, + Dest + ("CU2",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))), + Apply + (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), + qVar"state"), + TP[LU, + Let(TP[bVar"v", + Var("s", + PTy(bTy,PTy(bTy,PTy(bTy,PTy(bTy,PTy(bTy,qTy))))))], + CS(Let(TP[bVar"v", + Var("s3",PTy(bTy,PTy(bTy,PTy(bTy,qTy))))], + Let(TP[bVar"v",Var("s3",PTy(bTy,PTy(bTy,qTy)))], + Let(TP[bVar"v",Var("s3",PTy(bTy,qTy))], + Let(TP[bVar"v",qVar"s3"], + TP[Mop(Fst, + Apply + (Call + ("register_inaccessible", + ATy(qTy,PTy(bTy,qTy)), + Var("cb",FTy 5)), + qVar"state")),qVar"state"], + TP[bVar"v",LF,qVar"s3"]), + TP[bVar"v",LX bTy,Var("s3",PTy(bTy,qTy))]), + TP[bVar"v",LX bTy, + Var("s3",PTy(bTy,PTy(bTy,qTy)))]), + TP[bVar"v",LX bTy, + Var("s3",PTy(bTy,PTy(bTy,PTy(bTy,qTy))))]), + [(TP[bVar"v", + Var("s3",PTy(bTy,PTy(bTy,PTy(bTy,PTy(bTy,qTy)))))], + TP[bVar"v",LX bTy, + Var("s3",PTy(bTy,PTy(bTy,PTy(bTy,PTy(bTy,qTy)))))])]), + Let(Var("s", + PTy(bTy,PTy(bTy,PTy(bTy,PTy(bTy,PTy(bTy,qTy)))))), + ITE(bVar"v", + TP[Mop(Fst, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy,PTy(bTy,PTy(bTy,qTy))))))), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy,PTy(bTy,qTy)))))))), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy,qTy))))))))), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))))))), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))))))), + Mop(Snd, + Apply + (Call + ("SignalCapException_v", + ATy(qTy,PTy(uTy,qTy)), + Var("cb",FTy 5)), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))))))))))], + Let(TP[bVar"v", + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy,PTy(bTy,PTy(bTy,qTy))))))], + CS(Let(TP[bVar"v", + Var("s3", + PTy(bTy,PTy(bTy,PTy(bTy,qTy))))], + Let(TP[bVar"v", + Var("s3",PTy(bTy,PTy(bTy,qTy)))], + Let(TP[bVar"v", + Var("s3",PTy(bTy,qTy))], + Let(TP[bVar"v",qVar"s3"], + TP[Mop(Fst, + Apply + (Call + ("register_inaccessible", + ATy(qTy, + PTy(bTy, + qTy)), + Var("ct", + FTy 5)), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))))))))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))))))))], + TP[bVar"v", + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))))))), + qVar"s3"]), + TP[bVar"v", + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))))))), + Var("s3",PTy(bTy,qTy))]), + TP[bVar"v", + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))))), + Var("s3",PTy(bTy,PTy(bTy,qTy)))]), + TP[bVar"v", + Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))))), + Var("s3", + PTy(bTy,PTy(bTy,PTy(bTy,qTy))))]), + [(TP[bVar"v", + Var("s3", + PTy(bTy, + PTy(bTy,PTy(bTy,PTy(bTy,qTy)))))], + TP[bVar"v", + Mop(Fst, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy,qTy))))))), + Var("s3", + PTy(bTy, + PTy(bTy,PTy(bTy,PTy(bTy,qTy)))))])]), + ITE(bVar"v", + TP[Mop(Fst, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy,qTy))))))), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))))), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))))), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))))))), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))))))), + Mop(Snd, + Apply + (Call + ("SignalCapException_v", + ATy(qTy,PTy(uTy,qTy)), + Var("ct",FTy 5)), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))))))))))], + Let(TP[Var("v",CTy"Capability"), + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy,qTy))))))], + Let(TP[Var("v",CTy"Capability"), + Var("s3", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy,qTy)))))], + Let(TP[Var("v",CTy"Capability"), + Var("s3", + PTy(bTy, + PTy(bTy, + PTy(bTy,qTy))))], + Let(TP[Var("v", + CTy"Capability"), + Var("s3", + PTy(bTy, + PTy(bTy,qTy)))], + Let(TP[Var("v", + CTy"Capability"), + Var("s3", + PTy(bTy,qTy))], + Let(TP[Var("v", + CTy"Capability"), + qVar"s3"], + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("cb", + FTy 5)), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))))))))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))))))))], + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))))))), + qVar"s3"]), + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))))))), + Var("s3", + PTy(bTy,qTy))]), + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))))), + Var("s3", + PTy(bTy, + PTy(bTy,qTy)))]), + TP[Var("v",CTy"Capability"), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))))), + Var("s3", + PTy(bTy, + PTy(bTy, + PTy(bTy,qTy))))]), + TP[Var("v",CTy"Capability"), + Mop(Fst, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))), + Var("s3", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy,qTy)))))]), + Let(TP[bVar"v", + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))], + Let(TP[bVar"v", + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))], + Let(TP[Var("v0", + CTy"Capability"), + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))], + Let(TP[Var("v", + CTy"Capability"), + Var("s3", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))], + Let(TP[Var("v", + CTy"Capability"), + Var("s3", + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))], + Let(TP[Var("v", + CTy"Capability"), + Var("s3", + PTy(bTy, + PTy(bTy, + qTy)))], + Let(TP[Var("v", + CTy"Capability"), + Var("s3", + PTy(bTy, + qTy))], + Let(TP[Var("v", + CTy"Capability"), + qVar"s3"], + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("ct", + FTy 5)), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))))))))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))))))))], + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))))))), + qVar"s3"]), + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))))))), + Var("s3", + PTy(bTy, + qTy))]), + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))))), + Var("s3", + PTy(bTy, + PTy(bTy, + qTy)))]), + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))))), + Var("s3", + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))]), + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))), + Var("s3", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))]), + TP[EQ(Dest + ("tag",bTy, + Var("v", + CTy"Capability")), + Dest + ("tag",bTy, + Var("v0", + CTy"Capability"))), + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))]), + TP[Mop(Not,bVar"v"), + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))]), + ITE(bVar"v", + Let(TP[Var("v", + CTy"Capability"), + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))], + Let(TP[Var("v", + CTy"Capability"), + Var("s3", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))], + Let(TP[Var("v", + CTy"Capability"), + Var("s3", + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))], + Let(TP[Var("v", + CTy"Capability"), + Var("s3", + PTy(bTy, + PTy(bTy, + qTy)))], + Let(TP[Var("v", + CTy"Capability"), + Var("s3", + PTy(bTy, + qTy))], + Let(TP[Var("v", + CTy"Capability"), + qVar"s3"], + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("cb", + FTy 5)), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))))))))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))))))))], + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))))))), + qVar"s3"]), + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))))))), + Var("s3", + PTy(bTy, + qTy))]), + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))))), + Var("s3", + PTy(bTy, + PTy(bTy, + qTy)))]), + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))))), + Var("s3", + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))]), + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))), + Var("s3", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))]), + ITE(Dest + ("tag",bTy, + Var("v", + CTy"Capability")), + TP[LT, + Let(Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))), + TP[LF, + Let(Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))), + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))), + Let(Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))), + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))), + TP[Mop(Fst, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))), + LF, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))]))], + TP[Mop(Fst, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))), + LT, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))))])], + TP[LF, + Let(Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))), + TP[LT, + Let(Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))), + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))), + Let(Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))), + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))), + TP[Mop(Fst, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))), + LT, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))]))], + TP[Mop(Fst, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))), + LF, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))))])])), + Let(TP[Var("v", + CTy"Capability"), + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))], + Let(TP[Var("v", + CTy"Capability"), + Var("s3", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))], + Let(TP[Var("v", + CTy"Capability"), + Var("s3", + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))], + Let(TP[Var("v", + CTy"Capability"), + Var("s3", + PTy(bTy, + PTy(bTy, + qTy)))], + Let(TP[Var("v", + CTy"Capability"), + Var("s3", + PTy(bTy, + qTy))], + Let(TP[Var("v", + CTy"Capability"), + qVar"s3"], + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("cb", + FTy 5)), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))))))))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))))))))], + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))))))), + qVar"s3"]), + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))))))), + Var("s3", + PTy(bTy, + qTy))]), + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))))), + Var("s3", + PTy(bTy, + PTy(bTy, + qTy)))]), + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))))), + Var("s3", + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))]), + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))), + Var("s3", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))]), + Let(TP[Var("v",F64), + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))], + Let(TP[Var("v0", + CTy"Capability"), + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))], + Let(TP[Var("v", + CTy"Capability"), + Var("s3", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))], + Let(TP[Var("v", + CTy"Capability"), + Var("s3", + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))], + Let(TP[Var("v", + CTy"Capability"), + Var("s3", + PTy(bTy, + PTy(bTy, + qTy)))], + Let(TP[Var("v", + CTy"Capability"), + Var("s3", + PTy(bTy, + qTy))], + Let(TP[Var("v", + CTy"Capability"), + qVar"s3"], + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("cb", + FTy 5)), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))))))))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))))))))], + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))))))), + qVar"s3"]), + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))))))), + Var("s3", + PTy(bTy, + qTy))]), + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))))), + Var("s3", + PTy(bTy, + PTy(bTy, + qTy)))]), + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))))), + Var("s3", + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))]), + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))), + Var("s3", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))]), + TP[Bop(Add, + Dest + ("base", + F64, + Var("v", + CTy"Capability")), + Dest + ("offset", + F64, + Var("v0", + CTy"Capability"))), + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))]), + Let(TP[Var("v0", + CTy"Capability"), + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))], + Let(TP[Var("v", + CTy"Capability"), + Var("s3", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))], + Let(TP[Var("v", + CTy"Capability"), + Var("s3", + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))], + Let(TP[Var("v", + CTy"Capability"), + Var("s3", + PTy(bTy, + PTy(bTy, + qTy)))], + Let(TP[Var("v", + CTy"Capability"), + Var("s3", + PTy(bTy, + qTy))], + Let(TP[Var("v", + CTy"Capability"), + qVar"s3"], + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("ct", + FTy 5)), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))))))))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))))))))], + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))))))), + qVar"s3"]), + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))))))), + Var("s3", + PTy(bTy, + qTy))]), + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))))), + Var("s3", + PTy(bTy, + PTy(bTy, + qTy)))]), + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))))), + Var("s3", + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))]), + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))), + Var("s3", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))]), + Let(TP[Var("v0", + F64), + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))], + Let(TP[Var("v1", + CTy"Capability"), + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))], + Let(TP[Var("v", + CTy"Capability"), + Var("s3", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))], + Let(TP[Var("v", + CTy"Capability"), + Var("s3", + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))], + Let(TP[Var("v", + CTy"Capability"), + Var("s3", + PTy(bTy, + PTy(bTy, + qTy)))], + Let(TP[Var("v", + CTy"Capability"), + Var("s3", + PTy(bTy, + qTy))], + Let(TP[Var("v", + CTy"Capability"), + qVar"s3"], + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("ct", + FTy 5)), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))))))))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))))))))], + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))))))), + qVar"s3"]), + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))))))), + Var("s3", + PTy(bTy, + qTy))]), + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))))), + Var("s3", + PTy(bTy, + PTy(bTy, + qTy)))]), + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))))), + Var("s3", + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))]), + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))), + Var("s3", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))]), + TP[Bop(Add, + Dest + ("base", + F64, + Var("v0", + CTy"Capability")), + Dest + ("offset", + F64, + Var("v1", + CTy"Capability"))), + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))]), + TP[Bop(Ugt, + Var("v", + F64), + Var("v0", + F64)), + Bop(Ult, + Var("v", + F64), + Var("v0", + F64)), + Let(Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))), + Let(Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))), + Let(Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))), + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))), + TP[Mop(Fst, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))), + Let(Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))), + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))), + TP[Mop(Fst, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))), + Let(Var("s", + PTy(bTy, + PTy(bTy, + qTy))), + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))), + TP[Mop(Fst, + Var("s", + PTy(bTy, + PTy(bTy, + qTy)))), + EQ(Var("v", + F64), + Var("v0", + F64)), + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + qTy)))))])])]), + TP[Mop(Fst, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))), + Let(Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))), + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))), + TP[Mop(Fst, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))), + Bop(Lt, + Var("v", + F64), + Var("v0", + F64)), + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))])]), + TP[Bop(Gt, + Var("v", + F64), + Var("v0", + F64)), + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))))])])))))))))), + CS(Var("t",FTy 3), + [(LW(0,3), + Mop(Snd, + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Cast F64, + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))))))))), + Var("rd",FTy 5)]), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))))))))))), + (LW(1,3), + Mop(Snd, + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Cast F64, + Mop(Not, + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))))))))), + Var("rd",FTy 5)]), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))))))))))), + (LW(2,3), + Mop(Snd, + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Cast F64, + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))))))), + Var("rd",FTy 5)]), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))))))))))), + (LW(3,3), + Mop(Snd, + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Cast F64, + Bop(Or, + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))))))), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))))))))), + Var("rd",FTy 5)]), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))))))))))), + (LW(4,3), + Mop(Snd, + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Cast F64, + Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))))), + Var("rd",FTy 5)]), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))))))))))), + (LW(5,3), + Mop(Snd, + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Cast F64, + Bop(Or, + Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))))), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))))))))), + Var("rd",FTy 5)]), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy)))))))))))))), + (AVar(FTy 3), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + PTy(bTy, + qTy))))))))))))])))]))) +; +val dfn'CBTU_def = Def + ("dfn'CBTU",TP[Var("cb",FTy 5),Var("offset",F16)], + Close + (qVar"state", + ITE(Mop(Not, + Dest + ("CU2",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))), + Apply + (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), + qVar"state"), + Let(qVar"s", + Mop(Snd, + Apply + (Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))), + qVar"state")), + ITB([(Mop(Fst, + Apply + (Call + ("register_inaccessible", + ATy(qTy,PTy(bTy,qTy)),Var("cb",FTy 5)), + qVar"s")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cb",FTy 5)),qVar"s")), + (Mop(Not, + Dest + ("tag",bTy, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"s")))), + ITE(Bop(Ugt, + Bop(Add, + Bop(Add, + Mop(Fst, + Apply + (Const + ("PC",ATy(qTy,PTy(F64,qTy))), + qVar"s")), + Mop(SE F64,Var("offset",F16))), + LW(4,64)), + Dest + ("length",F64, + Mop(Fst, + Apply + (Const + ("PCC", + ATy(qTy,PTy(CTy"Capability",qTy))), + qVar"s")))), + Apply + (Call + ("SignalCapException_noReg", + ATy(qTy,PTy(uTy,qTy)), + LC("capExcLength",CTy"CapException")), + qVar"s"), + Apply + (Call + ("write'BranchTo",ATy(qTy,PTy(uTy,qTy)), + Mop(Some, + Bop(Add, + Bop(Add, + Mop(Fst, + Apply + (Const + ("PC", + ATy(qTy,PTy(F64,qTy))), + qVar"s")),LW(4,64)), + Bop(Lsl, + Mop(SE F64,Var("offset",F16)), + LN 2)))),qVar"s")))], + TP[LU,qVar"s"]))))) +; +val dfn'CBTS_def = Def + ("dfn'CBTS",TP[Var("cb",FTy 5),Var("offset",F16)], + Close + (qVar"state", + ITE(Mop(Not, + Dest + ("CU2",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))), + Apply + (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), + qVar"state"), + Let(qVar"s", + Mop(Snd, + Apply + (Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))), + qVar"state")), + ITB([(Mop(Fst, + Apply + (Call + ("register_inaccessible", + ATy(qTy,PTy(bTy,qTy)),Var("cb",FTy 5)), + qVar"s")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cb",FTy 5)),qVar"s")), + (Dest + ("tag",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"s"))), + ITE(Bop(Ugt, + Bop(Add, + Bop(Add, + Mop(Fst, + Apply + (Const + ("PC",ATy(qTy,PTy(F64,qTy))), + qVar"s")), + Mop(SE F64,Var("offset",F16))), + LW(4,64)), + Dest + ("length",F64, + Mop(Fst, + Apply + (Const + ("PCC", + ATy(qTy,PTy(CTy"Capability",qTy))), + qVar"s")))), + Apply + (Call + ("SignalCapException_noReg", + ATy(qTy,PTy(uTy,qTy)), + LC("capExcLength",CTy"CapException")), + qVar"s"), + Apply + (Call + ("write'BranchTo",ATy(qTy,PTy(uTy,qTy)), + Mop(Some, + Bop(Add, + Bop(Add, + Mop(Fst, + Apply + (Const + ("PC", + ATy(qTy,PTy(F64,qTy))), + qVar"s")),LW(4,64)), + Bop(Lsl, + Mop(SE F64,Var("offset",F16)), + LN 2)))),qVar"s")))], + TP[LU,qVar"s"]))))) +; +val dfn'CSC_def = Def + ("dfn'CSC", + TP[Var("cs",FTy 5),Var("cb",FTy 5),Var("rt",FTy 5),Var("offset",FTy 11)], + Close + (qVar"state", + ITB([(Mop(Fst, + Apply + (Call + ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), + Var("cs",FTy 5)),qVar"state")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cs",FTy 5)),qVar"state")), + (Mop(Fst, + Apply + (Call + ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), + Var("cb",FTy 5)),qVar"state")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cb",FTy 5)),qVar"state")), + (Mop(Not, + Dest + ("tag",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcTag",CTy"CapException"),Var("cb",FTy 5)]), + qVar"state")), + (Dest + ("sealed",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state"))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcSeal",CTy"CapException"),Var("cb",FTy 5)]), + qVar"state")), + (Mop(Not, + Dest + ("Permit_Store_Capability",bTy, + Call + ("rec'Perms",CTy"Perms", + Dest + ("perms",FTy 31, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")))))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcPermStoreCap",CTy"CapException"), + Var("cb",FTy 5)]),qVar"state")), + (Bop(And, + Bop(And, + Mop(Not, + Dest + ("Permit_Store_Local_Capability",bTy, + Call + ("rec'Perms",CTy"Perms", + Dest + ("perms",FTy 31, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")))))), + Dest + ("tag",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cs",FTy 5)),qVar"state")))), + Mop(Not, + Dest + ("Global",bTy, + Call + ("rec'Perms",CTy"Perms", + Dest + ("perms",FTy 31, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cs",FTy 5)),qVar"state"))))))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcPermStoreLocalCap",CTy"CapException"), + Var("cb",FTy 5)]),qVar"state"))], + Let(Var("v",F64), + Bop(Add, + Bop(Add, + Bop(Add, + Dest + ("base",F64, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state"))), + Dest + ("offset",F64, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")))), + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"state"))), + Mop(SE F64,Var("offset",FTy 11))), + ITB([(Bop(Ugt, + Bop(Add, + Bop(Add, + CC[LW(0,1), + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"state"))], + Mop(SE(FTy 65),Var("offset",FTy 11))), + LW(32,65)), + CC[LW(0,1), + Dest + ("length",F64, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")))]), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcLength",CTy"CapException"), + Var("cb",FTy 5)]),qVar"state")), + (Bop(Lt, + Bop(Add, + CC[LW(0,1), + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"state"))], + Mop(SE(FTy 65),Var("offset",FTy 11))),LW(0,65)), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcLength",CTy"CapException"), + Var("cb",FTy 5)]),qVar"state")), + (Mop(Not,EQ(EX(Var("v",F64),LN 4,LN 0,FTy 5),LW(0,5))), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("AdES",CTy"ExceptionType")), + Mop(Snd, + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("BadVAddr", + TP[Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"state")),Var("v",F64)])), + qVar"state"))))], + Apply + (Call("write'LLbit",ATy(qTy,PTy(uTy,qTy)),LO bTy), + Mop(Snd, + Apply + (Call + ("StoreCap",ATy(qTy,PTy(uTy,qTy)), + TP[Var("v",F64), + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability",qTy)), + Var("cs",FTy 5)),qVar"state"))]), + qVar"state")))))))) +; +val dfn'CLC_def = Def + ("dfn'CLC", + TP[Var("cd",FTy 5),Var("cb",FTy 5),Var("rt",FTy 5),Var("offset",FTy 11)], + Close + (qVar"state", + ITB([(Mop(Fst, + Apply + (Call + ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), + Var("cd",FTy 5)),qVar"state")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cd",FTy 5)),qVar"state")), + (Mop(Fst, + Apply + (Call + ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), + Var("cb",FTy 5)),qVar"state")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cb",FTy 5)),qVar"state")), + (Mop(Not, + Dest + ("tag",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcTag",CTy"CapException"),Var("cb",FTy 5)]), + qVar"state")), + (Dest + ("sealed",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state"))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcSeal",CTy"CapException"),Var("cb",FTy 5)]), + qVar"state")), + (Mop(Not, + Dest + ("Permit_Load_Capability",bTy, + Call + ("rec'Perms",CTy"Perms", + Dest + ("perms",FTy 31, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")))))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcPermLoadCap",CTy"CapException"), + Var("cb",FTy 5)]),qVar"state"))], + Let(Var("v",F64), + Bop(Add, + Bop(Add, + Bop(Add, + Dest + ("base",F64, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state"))), + Dest + ("offset",F64, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")))), + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"state"))), + Mop(SE F64,Var("offset",FTy 11))), + ITB([(Bop(Ugt, + Bop(Add, + Bop(Add, + CC[LW(0,1), + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"state"))], + Mop(SE(FTy 65),Var("offset",FTy 11))), + LW(32,65)), + CC[LW(0,1), + Dest + ("length",F64, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")))]), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcLength",CTy"CapException"), + Var("cb",FTy 5)]),qVar"state")), + (Bop(Lt, + Bop(Add, + CC[LW(0,1), + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"state"))], + Mop(SE(FTy 65),Var("offset",FTy 11))),LW(0,65)), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcLength",CTy"CapException"), + Var("cb",FTy 5)]),qVar"state")), + (Mop(Not,EQ(EX(Var("v",F64),LN 4,LN 0,FTy 5),LW(0,5))), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("AdEL",CTy"ExceptionType")), + Mop(Snd, + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("BadVAddr", + TP[Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"state")),Var("v",F64)])), + qVar"state"))))], + Let(TP[Var("v",CTy"Capability"),qVar"s"], + Apply + (Call + ("LoadCap",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("v",F64)),qVar"state"), + Apply + (Call("write'LLbit",ATy(qTy,PTy(uTy,qTy)),LO bTy), + ITE(Mop(Not, + Mop(Fst, + Apply + (Const + ("exceptionSignalled", + ATy(qTy,PTy(bTy,qTy))),qVar"s"))), + Mop(Snd, + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Var("v",CTy"Capability"), + Var("cd",FTy 5)]),qVar"s")), + qVar"s")))))))) +; +val dfn'CLoad_def = Def + ("dfn'CLoad", + TP[Var("rd",FTy 5),Var("cb",FTy 5),Var("rt",FTy 5),Var("offset",F8), + Var("s",F1),Var("t",FTy 2)], + Close + (qVar"state", + ITB([(Mop(Fst, + Apply + (Call + ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), + Var("cb",FTy 5)),qVar"state")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cb",FTy 5)),qVar"state")), + (Mop(Not, + Dest + ("tag",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcTag",CTy"CapException"),Var("cb",FTy 5)]), + qVar"state")), + (Dest + ("sealed",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state"))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcSeal",CTy"CapException"),Var("cb",FTy 5)]), + qVar"state")), + (Mop(Not, + Dest + ("Permit_Load",bTy, + Call + ("rec'Perms",CTy"Perms", + Dest + ("perms",FTy 31, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")))))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcPermLoad",CTy"CapException"), + Var("cb",FTy 5)]),qVar"state"))], + TP[LU, + Let(TP[Var("v",CTy"Capability"), + Var("s0",PTy(bTy,PTy(FTy 65,PTy(FTy 3,qTy))))], + Let(TP[Var("v",CTy"Capability"), + Var("s3",PTy(FTy 65,PTy(FTy 3,qTy)))], + Let(TP[Var("v",CTy"Capability"), + Var("s3",PTy(FTy 3,qTy))], + Let(TP[Var("v",CTy"Capability"),qVar"s3"], + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")), + qVar"state"], + TP[Var("v",CTy"Capability"),LX(FTy 3), + qVar"s3"]), + TP[Var("v",CTy"Capability"),LX(FTy 65), + Var("s3",PTy(FTy 3,qTy))]), + TP[Var("v",CTy"Capability"),LX bTy, + Var("s3",PTy(FTy 65,PTy(FTy 3,qTy)))]), + Let(TP[Var("v",F64), + Var("s0",PTy(bTy,PTy(FTy 65,PTy(FTy 3,qTy))))], + Let(TP[Var("v0",CTy"Capability"), + Var("s",PTy(bTy,PTy(FTy 65,PTy(FTy 3,qTy))))], + Let(TP[Var("v",CTy"Capability"), + Var("s3",PTy(FTy 65,PTy(FTy 3,qTy)))], + Let(TP[Var("v",CTy"Capability"), + Var("s3",PTy(FTy 3,qTy))], + Let(TP[Var("v",CTy"Capability"),qVar"s3"], + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("cb",FTy 5)), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))], + TP[Var("v",CTy"Capability"), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + qVar"s3"]), + TP[Var("v",CTy"Capability"), + Mop(Fst, + Mop(Snd, + Var("s0", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3,qTy)))))), + Var("s3",PTy(FTy 3,qTy))]), + TP[Var("v",CTy"Capability"), + Mop(Fst, + Var("s0", + PTy(bTy,PTy(FTy 65,PTy(FTy 3,qTy))))), + Var("s3",PTy(FTy 65,PTy(FTy 3,qTy)))]), + TP[Bop(Add, + Dest("base",F64,Var("v",CTy"Capability")), + Dest + ("offset",F64,Var("v0",CTy"Capability"))), + Var("s",PTy(bTy,PTy(FTy 65,PTy(FTy 3,qTy))))]), + Let(TP[Var("v0",F64), + Var("s0",PTy(bTy,PTy(FTy 65,PTy(FTy 3,qTy))))], + Let(TP[Var("v",F64), + Var("s3",PTy(FTy 65,PTy(FTy 3,qTy)))], + Let(TP[Var("v",F64),Var("s3",PTy(FTy 3,qTy))], + Let(TP[Var("v",F64),qVar"s3"], + TP[Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))], + TP[Var("v",F64), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + qVar"s3"]), + TP[Var("v",F64), + Mop(Fst, + Mop(Snd, + Var("s0", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3,qTy)))))), + Var("s3",PTy(FTy 3,qTy))]), + TP[Var("v",F64), + Mop(Fst, + Var("s0", + PTy(bTy,PTy(FTy 65,PTy(FTy 3,qTy))))), + Var("s3",PTy(FTy 65,PTy(FTy 3,qTy)))]), + Let(Var("v",F64), + Bop(Add,Bop(Add,Var("v",F64),Var("v0",F64)), + Mop(SE F64,Var("offset",F8))), + Let(Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65,PTy(FTy 3,qTy)))))), + CS(Var("t",FTy 2), + [(LW(0,2), + Let(Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + TP[LW(0,3), + Let(Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + TP[Var("v",F64), + Var("s0", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))], + TP[Mop(Fst, + Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + Let(Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))), + Mop(Snd, + Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + TP[Mop(Fst, + Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + LW(1,65), + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))])])], + Let(Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + TP[Mop(Fst, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + Let(Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + TP[Mop(Fst, + Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + Let(Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))), + Mop(Snd, + Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + TP[Mop(Fst, + Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + Let(Var("s", + PTy(FTy 65, + PTy(FTy 3, + qTy))), + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + TP[Mop(Fst, + Var("s", + PTy(FTy 65, + PTy(FTy 3, + qTy)))), + Const + ("BYTE", + FTy 3), + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 65, + PTy(FTy 3, + qTy)))))])])])], + Let(Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + Let(TP[Var("v",FTy 3), + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))], + Let(TP[Var("v0",F1), + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))], + Let(TP[Var("v", + F1), + Var("s3", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))], + Let(TP[Var("v", + F1), + Var("s3", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))], + Let(TP[Var("v", + F1), + Var("s3", + PTy(FTy 65, + PTy(FTy 3, + qTy)))], + Let(TP[Var("v", + F1), + Var("s3", + PTy(FTy 3, + qTy))], + Let(TP[Var("v", + F1), + qVar"s3"], + TP[Mop(Fst, + Apply + (Const + ("BigEndianCPU", + ATy(qTy, + PTy(F1, + qTy))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))))], + TP[Var("v", + F1), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))), + qVar"s3"]), + TP[Var("v", + F1), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))), + Var("s3", + PTy(FTy 3, + qTy))]), + TP[Var("v", + F1), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))), + Var("s3", + PTy(FTy 65, + PTy(FTy 3, + qTy)))]), + TP[Var("v", + F1), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))), + Var("s3", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))]), + TP[Var("v", + F1), + Mop(Fst, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + Var("s3", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))]), + TP[Bop(BXor, + EX(Mop(Fst, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))), + LN 2, + LN 0, + FTy 3), + REP(Var("v0", + F1), + LN 3, + FTy 3)), + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))]), + TP[Var("v",FTy 3), + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))]), + TP[Mop(Fst, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + Let(Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + TP[Mop(Fst, + Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + LT, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))])])))), + (LW(1,2), + Let(Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + TP[LW(0,3), + Let(Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + TP[Var("v",F64), + Var("s0", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))], + TP[Mop(Fst, + Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + Let(Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))), + Mop(Snd, + Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + TP[Mop(Fst, + Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + LW(2,65), + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))])])], + Let(Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + TP[Mop(Fst, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + Let(Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + TP[Mop(Fst, + Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + Let(Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))), + Mop(Snd, + Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + TP[Mop(Fst, + Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + Let(Var("s", + PTy(FTy 65, + PTy(FTy 3, + qTy))), + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + TP[Mop(Fst, + Var("s", + PTy(FTy 65, + PTy(FTy 3, + qTy)))), + Const + ("HALFWORD", + FTy 3), + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 65, + PTy(FTy 3, + qTy)))))])])])], + Let(Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + Let(TP[Var("v",FTy 3), + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))], + Let(TP[Var("v0",F1), + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))], + Let(TP[Var("v", + F1), + Var("s3", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))], + Let(TP[Var("v", + F1), + Var("s3", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))], + Let(TP[Var("v", + F1), + Var("s3", + PTy(FTy 65, + PTy(FTy 3, + qTy)))], + Let(TP[Var("v", + F1), + Var("s3", + PTy(FTy 3, + qTy))], + Let(TP[Var("v", + F1), + qVar"s3"], + TP[Mop(Fst, + Apply + (Const + ("BigEndianCPU", + ATy(qTy, + PTy(F1, + qTy))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))))], + TP[Var("v", + F1), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))), + qVar"s3"]), + TP[Var("v", + F1), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))), + Var("s3", + PTy(FTy 3, + qTy))]), + TP[Var("v", + F1), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))), + Var("s3", + PTy(FTy 65, + PTy(FTy 3, + qTy)))]), + TP[Var("v", + F1), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))), + Var("s3", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))]), + TP[Var("v", + F1), + Mop(Fst, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + Var("s3", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))]), + TP[Bop(BXor, + EX(Mop(Fst, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))), + LN 2, + LN 0, + FTy 3), + CC[REP(Var("v0", + F1), + LN + 2, + FTy 2), + LW(0,1)]), + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))]), + TP[Var("v",FTy 3), + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))]), + TP[Mop(Fst, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + Let(Var("s0", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + TP[Mop(Fst, + Var("s0", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + EQ(Bop(Bit, + Mop(Fst, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))), + LN 0), + LF), + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))])])))), + (LW(2,2), + Let(Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + TP[LW(0,3), + Let(Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + TP[Var("v",F64), + Var("s0", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))], + TP[Mop(Fst, + Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + Let(Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))), + Mop(Snd, + Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + TP[Mop(Fst, + Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + LW(4,65), + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))])])], + Let(Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + TP[Mop(Fst, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + Let(Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + TP[Mop(Fst, + Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + Let(Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))), + Mop(Snd, + Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + TP[Mop(Fst, + Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + Let(Var("s", + PTy(FTy 65, + PTy(FTy 3, + qTy))), + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + TP[Mop(Fst, + Var("s", + PTy(FTy 65, + PTy(FTy 3, + qTy)))), + Const + ("WORD", + FTy 3), + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 65, + PTy(FTy 3, + qTy)))))])])])], + Let(Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + Let(TP[Var("v",FTy 3), + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))], + Let(TP[Var("v0",F1), + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))], + Let(TP[Var("v", + F1), + Var("s3", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))], + Let(TP[Var("v", + F1), + Var("s3", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))], + Let(TP[Var("v", + F1), + Var("s3", + PTy(FTy 65, + PTy(FTy 3, + qTy)))], + Let(TP[Var("v", + F1), + Var("s3", + PTy(FTy 3, + qTy))], + Let(TP[Var("v", + F1), + qVar"s3"], + TP[Mop(Fst, + Apply + (Const + ("BigEndianCPU", + ATy(qTy, + PTy(F1, + qTy))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))))], + TP[Var("v", + F1), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))), + qVar"s3"]), + TP[Var("v", + F1), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))), + Var("s3", + PTy(FTy 3, + qTy))]), + TP[Var("v", + F1), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))), + Var("s3", + PTy(FTy 65, + PTy(FTy 3, + qTy)))]), + TP[Var("v", + F1), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))), + Var("s3", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))]), + TP[Var("v", + F1), + Mop(Fst, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + Var("s3", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))]), + TP[Bop(BXor, + EX(Mop(Fst, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))), + LN 2, + LN 0, + FTy 3), + CC[Var("v0", + F1), + LW(0,2)]), + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))]), + TP[Var("v",FTy 3), + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))]), + TP[Mop(Fst, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + Let(Var("s0", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + TP[Mop(Fst, + Var("s0", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + EQ(EX(Mop(Fst, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))), + LN 1, + LN 0, + FTy 2), + LW(0,2)), + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))])])))), + (LW(3,2), + Let(Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + TP[LW(0,3), + Let(Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + TP[Var("v",F64), + Var("s0", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))], + TP[Mop(Fst, + Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + Let(Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))), + Mop(Snd, + Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + TP[Mop(Fst, + Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + LW(8,65), + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))])])], + Let(Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + TP[Mop(Fst, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + Let(Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + TP[Mop(Fst, + Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + Let(Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))), + Mop(Snd, + Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + TP[Mop(Fst, + Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + Let(Var("s", + PTy(FTy 65, + PTy(FTy 3, + qTy))), + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + TP[Mop(Fst, + Var("s", + PTy(FTy 65, + PTy(FTy 3, + qTy)))), + Const + ("DOUBLEWORD", + FTy 3), + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 65, + PTy(FTy 3, + qTy)))))])])])], + TP[Mop(Fst, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + Let(Var("s0", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + TP[Mop(Fst, + Var("s0", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + EQ(EX(Mop(Fst, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))), + LN 2,LN 0, + FTy 3), + LW(0,3)), + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))])])))]), + Let(TP[Var("v",F64), + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3,qTy))))))], + Let(TP[Var("v",F64), + Var("s3", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3,qTy)))))], + Let(TP[Var("v",F64), + Var("s3", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3,qTy))))], + Let(TP[Var("v",F64), + Var("s3", + PTy(FTy 65, + PTy(FTy 3,qTy)))], + Let(TP[Var("v",F64), + Var("s3", + PTy(FTy 3,qTy))], + Let(TP[Var("v",F64), + qVar"s3"], + TP[Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy, + PTy(F64, + qTy)), + Var("rt", + FTy 5)), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))))], + TP[Var("v",F64), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))), + qVar"s3"]), + TP[Var("v",F64), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))), + Var("s3", + PTy(FTy 3,qTy))]), + TP[Var("v",F64), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))), + Var("s3", + PTy(FTy 65, + PTy(FTy 3,qTy)))]), + TP[Var("v",F64), + Mop(Fst, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))), + Var("s3", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3,qTy))))]), + TP[Var("v",F64), + Mop(Fst, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + Var("s3", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3,qTy)))))]), + Let(TP[bVar"v", + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))], + Let(TP[Var("v0",CTy"Capability"), + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))], + Let(TP[Var("v", + CTy"Capability"), + Var("s3", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))], + Let(TP[Var("v", + CTy"Capability"), + Var("s3", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))], + Let(TP[Var("v", + CTy"Capability"), + Var("s3", + PTy(FTy 65, + PTy(FTy 3, + qTy)))], + Let(TP[Var("v", + CTy"Capability"), + Var("s3", + PTy(FTy 3, + qTy))], + Let(TP[Var("v", + CTy"Capability"), + qVar"s3"], + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("cb", + FTy 5)), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))))], + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))), + qVar"s3"]), + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))), + Var("s3", + PTy(FTy 3, + qTy))]), + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))), + Var("s3", + PTy(FTy 65, + PTy(FTy 3, + qTy)))]), + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))), + Var("s3", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))]), + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + Var("s3", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))]), + TP[Bop(Ugt, + Bop(Add, + Bop(Add, + Mop(SE(FTy 65), + Var("offset", + F8)), + CC[LW(0,1), + Var("v",F64)]), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))), + CC[LW(0,1), + Dest + ("length",F64, + Var("v0", + CTy"Capability"))]), + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))]), + ITE(bVar"v", + Mop(Snd, + Apply + (Call + ("SignalCapException", + ATy(qTy, + PTy(uTy,qTy)), + TP[LC("capExcLength", + CTy"CapException"), + Var("cb",FTy 5)]), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))))), + Let(TP[Var("v",F64), + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))], + Let(TP[Var("v",F64), + Var("s3", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))], + Let(TP[Var("v",F64), + Var("s3", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))], + Let(TP[Var("v", + F64), + Var("s3", + PTy(FTy 65, + PTy(FTy 3, + qTy)))], + Let(TP[Var("v", + F64), + Var("s3", + PTy(FTy 3, + qTy))], + Let(TP[Var("v", + F64), + qVar"s3"], + TP[Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy, + PTy(F64, + qTy)), + Var("rt", + FTy 5)), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))))], + TP[Var("v", + F64), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))), + qVar"s3"]), + TP[Var("v", + F64), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))), + Var("s3", + PTy(FTy 3, + qTy))]), + TP[Var("v", + F64), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))), + Var("s3", + PTy(FTy 65, + PTy(FTy 3, + qTy)))]), + TP[Var("v",F64), + Mop(Fst, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))), + Var("s3", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))]), + TP[Var("v",F64), + Mop(Fst, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + Var("s3", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))]), + ITB([(Bop(Lt, + Bop(Add, + Mop(SE(FTy 65), + Var("offset", + F8)), + CC[LW(0,1), + Var("v", + F64)]), + LW(0,65)), + Mop(Snd, + Apply + (Call + ("SignalCapException", + ATy(qTy, + PTy(uTy, + qTy)), + TP[LC("capExcLength", + CTy"CapException"), + Var("cb", + FTy 5)]), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))))))), + (Mop(Not, + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))), + Let(TP[Var("v", + CTy"CP0__renamed__"), + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))], + Let(TP[Var("v", + CTy"CP0__renamed__"), + Var("s3", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))], + Let(TP[Var("v", + CTy"CP0__renamed__"), + Var("s3", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))], + Let(TP[Var("v", + CTy"CP0__renamed__"), + Var("s3", + PTy(FTy 65, + PTy(FTy 3, + qTy)))], + Let(TP[Var("v", + CTy"CP0__renamed__"), + Var("s3", + PTy(FTy 3, + qTy))], + Let(TP[Var("v", + CTy"CP0__renamed__"), + qVar"s3"], + TP[Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))))], + TP[Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))), + qVar"s3"]), + TP[Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))), + Var("s3", + PTy(FTy 3, + qTy))]), + TP[Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))), + Var("s3", + PTy(FTy 65, + PTy(FTy 3, + qTy)))]), + TP[Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))), + Var("s3", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))]), + TP[Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + Var("s3", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))]), + Let(Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + TP[Mop(Fst, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))), + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("BadVAddr", + TP[Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))])), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))))))], + Mop(Snd, + Apply + (Call + ("SignalException", + ATy(qTy, + PTy(uTy, + qTy)), + LC("AdEL", + CTy"ExceptionType")), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))))))))], + Let(TP[Var("v",F64), + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))], + Let(TP[Var("v", + F64), + Var("s3", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))], + Let(TP[Var("v", + F64), + Var("s3", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))], + Let(TP[Var("v", + F64), + Var("s3", + PTy(FTy 65, + PTy(FTy 3, + qTy)))], + Let(TP[Var("v", + F64), + Var("s3", + PTy(FTy 3, + qTy))], + Let(TP[Var("v", + F64), + qVar"s3"], + Apply + (Call + ("LoadMemoryCap", + ATy(qTy, + PTy(F64, + qTy)), + TP[Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))), + Mop(Fst, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))), + LC("DATA", + CTy"IorD"), + LC("LOAD", + CTy"AccessType"), + LF]), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))))), + TP[Var("v", + F64), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))), + qVar"s3"]), + TP[Var("v", + F64), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))), + Var("s3", + PTy(FTy 3, + qTy))]), + TP[Var("v", + F64), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))), + Var("s3", + PTy(FTy 65, + PTy(FTy 3, + qTy)))]), + TP[Var("v", + F64), + Mop(Fst, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))), + Var("s3", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))]), + TP[Var("v", + F64), + Mop(Fst, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + Var("s3", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))]), + Let(TP[bVar"v0", + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))], + Let(TP[bVar"v", + Var("s3", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))], + Let(TP[bVar"v", + Var("s3", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))], + Let(TP[bVar"v", + Var("s3", + PTy(FTy 65, + PTy(FTy 3, + qTy)))], + Let(TP[bVar"v", + Var("s3", + PTy(FTy 3, + qTy))], + Let(TP[bVar"v", + qVar"s3"], + TP[Mop(Fst, + Apply + (Const + ("exceptionSignalled", + ATy(qTy, + PTy(bTy, + qTy))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))))], + TP[bVar"v", + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))), + qVar"s3"]), + TP[bVar"v", + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))), + Var("s3", + PTy(FTy 3, + qTy))]), + TP[bVar"v", + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))), + Var("s3", + PTy(FTy 65, + PTy(FTy 3, + qTy)))]), + TP[bVar"v", + Mop(Fst, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))), + Var("s3", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))]), + TP[bVar"v", + Mop(Fst, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + Var("s3", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))]), + ITE(Mop(Not, + bVar"v0"), + Let(vVar"final_data", + EX(Mop(Cast + vTy, + Var("v", + F64)), + Bop(Sub, + Bop(Add, + Bop(Mul, + Mop(Cast + nTy, + Mop(Fst, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))), + LN + 8), + Bop(Mul, + Mop(Cast + nTy, + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))), + LN + 8)), + LN + 1), + Bop(Mul, + Mop(Cast + nTy, + Mop(Fst, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))), + LN + 8), + vTy), + ITE(EQ(Var("s", + F1), + LW(0, + 1)), + Mop(Snd, + Apply + (Call + ("write'GPR", + ATy(qTy, + PTy(uTy, + qTy)), + TP[Mop(Cast + F64, + vVar"final_data"), + Var("rd", + FTy 5)]), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))))), + Mop(Snd, + Apply + (Call + ("write'GPR", + ATy(qTy, + PTy(uTy, + qTy)), + TP[Mop(Cast + F64, + Call + ("SignExtendBitString", + vTy, + TP[LN + 64, + vVar"final_data"])), + Var("rd", + FTy 5)]), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))))))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))))))))))))))))]))) +; +val dfn'CLLD_def = Def + ("dfn'CLLD", + TP[Var("rd",FTy 5),Var("cb",FTy 5),Var("rt",FTy 5),Var("offset",F8)], + Close + (qVar"state", + Let(Var("v",F64), + Bop(Add, + Bop(Add, + Bop(Add, + Dest + ("base",F64, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state"))), + Dest + ("offset",F64, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")))), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state"))),Mop(SE F64,Var("offset",F8))), + ITB([(Mop(Fst, + Apply + (Call + ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), + Var("cb",FTy 5)),qVar"state")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cb",FTy 5)),qVar"state")), + (Mop(Not, + Dest + ("tag",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcTag",CTy"CapException"),Var("cb",FTy 5)]), + qVar"state")), + (Dest + ("sealed",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state"))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcSeal",CTy"CapException"), + Var("cb",FTy 5)]),qVar"state")), + (Mop(Not, + Dest + ("Permit_Load",bTy, + Call + ("rec'Perms",CTy"Perms", + Dest + ("perms",FTy 31, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")))))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcPermLoad",CTy"CapException"), + Var("cb",FTy 5)]),qVar"state")), + (Bop(Ugt, + Bop(Add, + Bop(Add,Mop(SE(FTy 65),Var("offset",F8)), + CC[LW(0,1), + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"state"))]), + LW(8,65)), + CC[LW(0,1), + Dest + ("length",F64, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")))]), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcLength",CTy"CapException"), + Var("cb",FTy 5)]),qVar"state")), + (Bop(Lt, + Bop(Add,Mop(SE(FTy 65),Var("offset",F8)), + CC[LW(0,1), + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"state"))]), + LW(0,65)), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcLength",CTy"CapException"), + Var("cb",FTy 5)]),qVar"state")), + (Mop(Not,EQ(EX(Var("v",F64),LN 3,LN 0,F4),LW(0,4))), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("AdEL",CTy"ExceptionType")), + Mop(Snd, + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("BadVAddr", + TP[Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))),qVar"state")), + Var("v",F64)])),qVar"state"))))], + Let(TP[Var("v",F64),qVar"s"], + Apply + (Call + ("LoadMemoryCap",ATy(qTy,PTy(F64,qTy)), + TP[Const("DOUBLEWORD",FTy 3),Var("v",F64), + LC("DATA",CTy"IorD"), + LC("LOAD",CTy"AccessType"),LT]),qVar"state"), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Var("v",F64),Var("rd",FTy 5)]),qVar"s")))))) +; +val dfn'CStore_def = Def + ("dfn'CStore", + TP[Var("rs",FTy 5),Var("cb",FTy 5),Var("rt",FTy 5),Var("offset",F8), + Var("t",FTy 2)], + Close + (qVar"state", + ITB([(Mop(Fst, + Apply + (Call + ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), + Var("cb",FTy 5)),qVar"state")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cb",FTy 5)),qVar"state")), + (Mop(Not, + Dest + ("tag",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcTag",CTy"CapException"),Var("cb",FTy 5)]), + qVar"state")), + (Dest + ("sealed",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state"))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcSeal",CTy"CapException"),Var("cb",FTy 5)]), + qVar"state")), + (Mop(Not, + Dest + ("Permit_Store",bTy, + Call + ("rec'Perms",CTy"Perms", + Dest + ("perms",FTy 31, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")))))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcPermStore",CTy"CapException"), + Var("cb",FTy 5)]),qVar"state"))], + TP[LU, + Let(TP[Var("v",CTy"Capability"), + Var("s",PTy(bTy,PTy(FTy 65,PTy(FTy 3,qTy))))], + Let(TP[Var("v",CTy"Capability"), + Var("s3",PTy(FTy 65,PTy(FTy 3,qTy)))], + Let(TP[Var("v",CTy"Capability"), + Var("s3",PTy(FTy 3,qTy))], + Let(TP[Var("v",CTy"Capability"),qVar"s3"], + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")), + qVar"state"], + TP[Var("v",CTy"Capability"),LX(FTy 3), + qVar"s3"]), + TP[Var("v",CTy"Capability"),LX(FTy 65), + Var("s3",PTy(FTy 3,qTy))]), + TP[Var("v",CTy"Capability"),LX bTy, + Var("s3",PTy(FTy 65,PTy(FTy 3,qTy)))]), + Let(TP[Var("v",F64), + Var("s",PTy(bTy,PTy(FTy 65,PTy(FTy 3,qTy))))], + Let(TP[Var("v0",CTy"Capability"), + Var("s",PTy(bTy,PTy(FTy 65,PTy(FTy 3,qTy))))], + Let(TP[Var("v",CTy"Capability"), + Var("s3",PTy(FTy 65,PTy(FTy 3,qTy)))], + Let(TP[Var("v",CTy"Capability"), + Var("s3",PTy(FTy 3,qTy))], + Let(TP[Var("v",CTy"Capability"),qVar"s3"], + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("cb",FTy 5)), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))], + TP[Var("v",CTy"Capability"), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + qVar"s3"]), + TP[Var("v",CTy"Capability"), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3,qTy)))))), + Var("s3",PTy(FTy 3,qTy))]), + TP[Var("v",CTy"Capability"), + Mop(Fst, + Var("s", + PTy(bTy,PTy(FTy 65,PTy(FTy 3,qTy))))), + Var("s3",PTy(FTy 65,PTy(FTy 3,qTy)))]), + TP[Bop(Add, + Dest("base",F64,Var("v",CTy"Capability")), + Dest + ("offset",F64,Var("v0",CTy"Capability"))), + Var("s",PTy(bTy,PTy(FTy 65,PTy(FTy 3,qTy))))]), + Let(TP[Var("v0",F64), + Var("s",PTy(bTy,PTy(FTy 65,PTy(FTy 3,qTy))))], + Let(TP[Var("v",F64), + Var("s3",PTy(FTy 65,PTy(FTy 3,qTy)))], + Let(TP[Var("v",F64),Var("s3",PTy(FTy 3,qTy))], + Let(TP[Var("v",F64),qVar"s3"], + TP[Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))], + TP[Var("v",F64), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + qVar"s3"]), + TP[Var("v",F64), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3,qTy)))))), + Var("s3",PTy(FTy 3,qTy))]), + TP[Var("v",F64), + Mop(Fst, + Var("s", + PTy(bTy,PTy(FTy 65,PTy(FTy 3,qTy))))), + Var("s3",PTy(FTy 65,PTy(FTy 3,qTy)))]), + Let(Var("v",F64), + Bop(Add,Bop(Add,Var("v",F64),Var("v0",F64)), + Mop(SE F64,Var("offset",F8))), + Let(Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65,PTy(FTy 3,qTy)))))), + CS(Var("t",FTy 2), + [(LW(0,2), + Let(Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + TP[LW(0,3), + Let(Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + TP[Var("v",F64), + Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))], + TP[Mop(Fst, + Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + Let(Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))), + Mop(Snd, + Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + TP[Mop(Fst, + Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + LW(1,65), + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))])])], + Let(Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + TP[Mop(Fst, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + Let(Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + TP[Mop(Fst, + Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + Let(Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))), + Mop(Snd, + Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + TP[Mop(Fst, + Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + Let(Var("s", + PTy(FTy 65, + PTy(FTy 3, + qTy))), + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + TP[Mop(Fst, + Var("s", + PTy(FTy 65, + PTy(FTy 3, + qTy)))), + Const + ("BYTE", + FTy 3), + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 65, + PTy(FTy 3, + qTy)))))])])])], + Let(Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + Let(TP[Var("v",FTy 3), + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))], + Let(TP[Var("v0",F1), + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))], + Let(TP[Var("v", + F1), + Var("s3", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))], + Let(TP[Var("v", + F1), + Var("s3", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))], + Let(TP[Var("v", + F1), + Var("s3", + PTy(FTy 65, + PTy(FTy 3, + qTy)))], + Let(TP[Var("v", + F1), + Var("s3", + PTy(FTy 3, + qTy))], + Let(TP[Var("v", + F1), + qVar"s3"], + TP[Mop(Fst, + Apply + (Const + ("BigEndianCPU", + ATy(qTy, + PTy(F1, + qTy))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))))], + TP[Var("v", + F1), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))), + qVar"s3"]), + TP[Var("v", + F1), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))), + Var("s3", + PTy(FTy 3, + qTy))]), + TP[Var("v", + F1), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))), + Var("s3", + PTy(FTy 65, + PTy(FTy 3, + qTy)))]), + TP[Var("v", + F1), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))), + Var("s3", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))]), + TP[Var("v", + F1), + Mop(Fst, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + Var("s3", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))]), + TP[Bop(BXor, + EX(Mop(Fst, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))), + LN 2, + LN 0, + FTy 3), + REP(Var("v0", + F1), + LN 3, + FTy 3)), + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))]), + TP[Var("v",FTy 3), + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))]), + TP[Mop(Fst, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + Let(Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + TP[Mop(Fst, + Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + LT, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))])])))), + (LW(1,2), + Let(Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + TP[LW(0,3), + Let(Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + TP[Var("v",F64), + Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))], + TP[Mop(Fst, + Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + Let(Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))), + Mop(Snd, + Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + TP[Mop(Fst, + Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + LW(2,65), + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))])])], + Let(Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + TP[Mop(Fst, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + Let(Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + TP[Mop(Fst, + Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + Let(Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))), + Mop(Snd, + Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + TP[Mop(Fst, + Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + Let(Var("s", + PTy(FTy 65, + PTy(FTy 3, + qTy))), + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + TP[Mop(Fst, + Var("s", + PTy(FTy 65, + PTy(FTy 3, + qTy)))), + Const + ("HALFWORD", + FTy 3), + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 65, + PTy(FTy 3, + qTy)))))])])])], + Let(Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + Let(TP[Var("v",FTy 3), + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))], + Let(TP[Var("v0",F1), + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))], + Let(TP[Var("v", + F1), + Var("s3", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))], + Let(TP[Var("v", + F1), + Var("s3", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))], + Let(TP[Var("v", + F1), + Var("s3", + PTy(FTy 65, + PTy(FTy 3, + qTy)))], + Let(TP[Var("v", + F1), + Var("s3", + PTy(FTy 3, + qTy))], + Let(TP[Var("v", + F1), + qVar"s3"], + TP[Mop(Fst, + Apply + (Const + ("BigEndianCPU", + ATy(qTy, + PTy(F1, + qTy))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))))], + TP[Var("v", + F1), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))), + qVar"s3"]), + TP[Var("v", + F1), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))), + Var("s3", + PTy(FTy 3, + qTy))]), + TP[Var("v", + F1), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))), + Var("s3", + PTy(FTy 65, + PTy(FTy 3, + qTy)))]), + TP[Var("v", + F1), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))), + Var("s3", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))]), + TP[Var("v", + F1), + Mop(Fst, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + Var("s3", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))]), + TP[Bop(BXor, + EX(Mop(Fst, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))), + LN 2, + LN 0, + FTy 3), + CC[REP(Var("v0", + F1), + LN + 2, + FTy 2), + LW(0,1)]), + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))]), + TP[Var("v",FTy 3), + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))]), + TP[Mop(Fst, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + Let(Var("s0", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + TP[Mop(Fst, + Var("s0", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + EQ(Bop(Bit, + Mop(Fst, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))), + LN 0), + LF), + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))])])))), + (LW(2,2), + Let(Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + TP[LW(0,3), + Let(Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + TP[Var("v",F64), + Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))], + TP[Mop(Fst, + Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + Let(Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))), + Mop(Snd, + Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + TP[Mop(Fst, + Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + LW(4,65), + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))])])], + Let(Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + TP[Mop(Fst, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + Let(Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + TP[Mop(Fst, + Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + Let(Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))), + Mop(Snd, + Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + TP[Mop(Fst, + Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + Let(Var("s", + PTy(FTy 65, + PTy(FTy 3, + qTy))), + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + TP[Mop(Fst, + Var("s", + PTy(FTy 65, + PTy(FTy 3, + qTy)))), + Const + ("WORD", + FTy 3), + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 65, + PTy(FTy 3, + qTy)))))])])])], + Let(Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + Let(TP[Var("v",FTy 3), + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))], + Let(TP[Var("v0",F1), + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))], + Let(TP[Var("v", + F1), + Var("s3", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))], + Let(TP[Var("v", + F1), + Var("s3", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))], + Let(TP[Var("v", + F1), + Var("s3", + PTy(FTy 65, + PTy(FTy 3, + qTy)))], + Let(TP[Var("v", + F1), + Var("s3", + PTy(FTy 3, + qTy))], + Let(TP[Var("v", + F1), + qVar"s3"], + TP[Mop(Fst, + Apply + (Const + ("BigEndianCPU", + ATy(qTy, + PTy(F1, + qTy))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))))], + TP[Var("v", + F1), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))), + qVar"s3"]), + TP[Var("v", + F1), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))), + Var("s3", + PTy(FTy 3, + qTy))]), + TP[Var("v", + F1), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))), + Var("s3", + PTy(FTy 65, + PTy(FTy 3, + qTy)))]), + TP[Var("v", + F1), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))), + Var("s3", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))]), + TP[Var("v", + F1), + Mop(Fst, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + Var("s3", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))]), + TP[Bop(BXor, + EX(Mop(Fst, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))), + LN 2, + LN 0, + FTy 3), + CC[REP(Var("v0", + F1), + LN + 1, + F1), + LW(0,2)]), + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))]), + TP[Var("v",FTy 3), + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))]), + TP[Mop(Fst, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + Let(Var("s0", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + TP[Mop(Fst, + Var("s0", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + EQ(EX(Mop(Fst, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))), + LN 1, + LN 0, + FTy 2), + LW(0,2)), + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))])])))), + (LW(3,2), + Let(Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + TP[LW(0,3), + Let(Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + TP[Var("v",F64), + Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))], + TP[Mop(Fst, + Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + Let(Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))), + Mop(Snd, + Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + TP[Mop(Fst, + Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + LW(8,65), + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))])])], + Let(Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + TP[Mop(Fst, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + Let(Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + TP[Mop(Fst, + Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + Let(Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))), + Mop(Snd, + Var("s", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + TP[Mop(Fst, + Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + Let(Var("s", + PTy(FTy 65, + PTy(FTy 3, + qTy))), + Mop(Snd, + Var("s", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + TP[Mop(Fst, + Var("s", + PTy(FTy 65, + PTy(FTy 3, + qTy)))), + Const + ("DOUBLEWORD", + FTy 3), + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 65, + PTy(FTy 3, + qTy)))))])])])], + TP[Mop(Fst, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + Let(Var("s0", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))), + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + TP[Mop(Fst, + Var("s0", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + EQ(EX(Mop(Fst, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))), + LN 2,LN 0, + FTy 3), + LW(0,3)), + Mop(Snd, + Mop(Snd, + Var("s0", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))])])))]), + Let(TP[Var("v",F64), + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3,qTy))))))], + Let(TP[Var("v",F64), + Var("s3", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3,qTy)))))], + Let(TP[Var("v",F64), + Var("s3", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3,qTy))))], + Let(TP[Var("v",F64), + Var("s3", + PTy(FTy 65, + PTy(FTy 3,qTy)))], + Let(TP[Var("v",F64), + Var("s3", + PTy(FTy 3,qTy))], + Let(TP[Var("v",F64), + qVar"s3"], + TP[Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy, + PTy(F64, + qTy)), + Var("rt", + FTy 5)), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))))], + TP[Var("v",F64), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))), + qVar"s3"]), + TP[Var("v",F64), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))), + Var("s3", + PTy(FTy 3,qTy))]), + TP[Var("v",F64), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))), + Var("s3", + PTy(FTy 65, + PTy(FTy 3,qTy)))]), + TP[Var("v",F64), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))), + Var("s3", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3,qTy))))]), + TP[Var("v",F64), + Mop(Fst, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + Var("s3", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3,qTy)))))]), + Let(TP[bVar"v", + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))], + Let(TP[Var("v0",CTy"Capability"), + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))], + Let(TP[Var("v", + CTy"Capability"), + Var("s3", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))], + Let(TP[Var("v", + CTy"Capability"), + Var("s3", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))], + Let(TP[Var("v", + CTy"Capability"), + Var("s3", + PTy(FTy 65, + PTy(FTy 3, + qTy)))], + Let(TP[Var("v", + CTy"Capability"), + Var("s3", + PTy(FTy 3, + qTy))], + Let(TP[Var("v", + CTy"Capability"), + qVar"s3"], + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("cb", + FTy 5)), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))))], + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))), + qVar"s3"]), + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))), + Var("s3", + PTy(FTy 3, + qTy))]), + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))), + Var("s3", + PTy(FTy 65, + PTy(FTy 3, + qTy)))]), + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))), + Var("s3", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))]), + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + Var("s3", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))]), + TP[Bop(Ugt, + Bop(Add, + Bop(Add, + Mop(SE(FTy 65), + Var("offset", + F8)), + CC[LW(0,1), + Var("v",F64)]), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))), + CC[LW(0,1), + Dest + ("length",F64, + Var("v0", + CTy"Capability"))]), + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))]), + ITE(bVar"v", + Mop(Snd, + Apply + (Call + ("SignalCapException", + ATy(qTy, + PTy(uTy,qTy)), + TP[LC("capExcLength", + CTy"CapException"), + Var("cb",FTy 5)]), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))))), + Let(TP[Var("v",F64), + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))], + Let(TP[Var("v",F64), + Var("s3", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))], + Let(TP[Var("v",F64), + Var("s3", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))], + Let(TP[Var("v", + F64), + Var("s3", + PTy(FTy 65, + PTy(FTy 3, + qTy)))], + Let(TP[Var("v", + F64), + Var("s3", + PTy(FTy 3, + qTy))], + Let(TP[Var("v", + F64), + qVar"s3"], + TP[Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy, + PTy(F64, + qTy)), + Var("rt", + FTy 5)), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))))], + TP[Var("v", + F64), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))), + qVar"s3"]), + TP[Var("v", + F64), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))), + Var("s3", + PTy(FTy 3, + qTy))]), + TP[Var("v", + F64), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))), + Var("s3", + PTy(FTy 65, + PTy(FTy 3, + qTy)))]), + TP[Var("v",F64), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))), + Var("s3", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))]), + TP[Var("v",F64), + Mop(Fst, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + Var("s3", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))]), + ITB([(Bop(Lt, + Bop(Add, + Mop(SE(FTy 65), + Var("offset", + F8)), + CC[LW(0,1), + Var("v", + F64)]), + LW(0,65)), + Mop(Snd, + Apply + (Call + ("SignalCapException", + ATy(qTy, + PTy(uTy, + qTy)), + TP[LC("capExcLength", + CTy"CapException"), + Var("cb", + FTy 5)]), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))))))), + (Mop(Not, + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))), + Let(TP[Var("v", + CTy"CP0__renamed__"), + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))], + Let(TP[Var("v", + CTy"CP0__renamed__"), + Var("s3", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))], + Let(TP[Var("v", + CTy"CP0__renamed__"), + Var("s3", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))], + Let(TP[Var("v", + CTy"CP0__renamed__"), + Var("s3", + PTy(FTy 65, + PTy(FTy 3, + qTy)))], + Let(TP[Var("v", + CTy"CP0__renamed__"), + Var("s3", + PTy(FTy 3, + qTy))], + Let(TP[Var("v", + CTy"CP0__renamed__"), + qVar"s3"], + TP[Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))))], + TP[Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))), + qVar"s3"]), + TP[Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))), + Var("s3", + PTy(FTy 3, + qTy))]), + TP[Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))), + Var("s3", + PTy(FTy 65, + PTy(FTy 3, + qTy)))]), + TP[Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))), + Var("s3", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))]), + TP[Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + Var("s3", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))]), + Let(Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))), + TP[Mop(Fst, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))), + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("BadVAddr", + TP[Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))])), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))))))], + Mop(Snd, + Apply + (Call + ("SignalException", + ATy(qTy, + PTy(uTy, + qTy)), + LC("AdES", + CTy"ExceptionType")), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))))))))], + Let(TP[bVar"v", + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))], + Let(TP[Var("v", + PTy(FTy 3, + PTy(FTy 3, + PTy(F64, + PTy(F64, + PTy(CTy"IorD", + PTy(CTy"AccessType", + bTy))))))), + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))], + Let(TP[Var("v0", + PTy(FTy 3, + PTy(F64, + PTy(F64, + PTy(CTy"IorD", + PTy(CTy"AccessType", + bTy)))))), + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))], + Let(TP[Var("v1", + F64), + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))], + Let(TP[Var("v", + F64), + Var("s3", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))], + Let(TP[Var("v", + F64), + Var("s3", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))], + Let(TP[Var("v", + F64), + Var("s3", + PTy(FTy 65, + PTy(FTy 3, + qTy)))], + Let(TP[Var("v", + F64), + Var("s3", + PTy(FTy 3, + qTy))], + Let(TP[Var("v", + F64), + qVar"s3"], + TP[Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy, + PTy(F64, + qTy)), + Var("rs", + FTy 5)), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))))], + TP[Var("v", + F64), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))), + qVar"s3"]), + TP[Var("v", + F64), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))), + Var("s3", + PTy(FTy 3, + qTy))]), + TP[Var("v", + F64), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))), + Var("s3", + PTy(FTy 65, + PTy(FTy 3, + qTy)))]), + TP[Var("v", + F64), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))), + Var("s3", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))]), + TP[Var("v", + F64), + Mop(Fst, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + Var("s3", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))]), + TP[TP[Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))), + Bop(Lsl, + Var("v1", + F64), + Bop(Mul, + LN + 8, + Mop(Cast + nTy, + Mop(Fst, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))), + Mop(Fst, + Mop(Snd, + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))), + LC("DATA", + CTy"IorD"), + LC("STORE", + CTy"AccessType"), + LF], + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))]), + TP[TP[Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))), + Var("v0", + PTy(FTy 3, + PTy(F64, + PTy(F64, + PTy(CTy"IorD", + PTy(CTy"AccessType", + bTy))))))], + Var("s0", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))]), + Let(TP[bVar"v", + Var("s3", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))], + Let(TP[bVar"v", + Var("s3", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))], + Let(TP[bVar"v", + Var("s3", + PTy(FTy 65, + PTy(FTy 3, + qTy)))], + Let(TP[bVar"v", + Var("s3", + PTy(FTy 3, + qTy))], + Let(TP[bVar"v", + qVar"s3"], + Apply + (Call + ("StoreMemoryCap", + ATy(qTy, + PTy(bTy, + qTy)), + Var("v", + PTy(FTy 3, + PTy(FTy 3, + PTy(F64, + PTy(F64, + PTy(CTy"IorD", + PTy(CTy"AccessType", + bTy)))))))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))))), + TP[bVar"v", + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))), + qVar"s3"]), + TP[bVar"v", + Mop(Fst, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))))), + Var("s3", + PTy(FTy 3, + qTy))]), + TP[bVar"v", + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))), + Var("s3", + PTy(FTy 65, + PTy(FTy 3, + qTy)))]), + TP[bVar"v", + Mop(Fst, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))))), + Var("s3", + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))]), + TP[bVar"v", + Mop(Fst, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))), + Var("s3", + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy)))))])), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(FTy 3, + PTy(F64, + PTy(bTy, + PTy(FTy 65, + PTy(FTy 3, + qTy))))))))))))))))))))))]))) +; +val dfn'CSCD_def = Def + ("dfn'CSCD", + TP[Var("rs",FTy 5),Var("cb",FTy 5),Var("rt",FTy 5),Var("offset",F8)], + Close + (qVar"state", + Let(Var("v",F64), + Bop(Add, + Bop(Add, + Bop(Add, + Dest + ("base",F64, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state"))), + Dest + ("offset",F64, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")))), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state"))),Mop(SE F64,Var("offset",F8))), + ITB([(Mop(Fst, + Apply + (Call + ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), + Var("cb",FTy 5)),qVar"state")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cb",FTy 5)),qVar"state")), + (Mop(Not, + Dest + ("tag",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcTag",CTy"CapException"),Var("cb",FTy 5)]), + qVar"state")), + (Dest + ("sealed",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state"))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcSeal",CTy"CapException"), + Var("cb",FTy 5)]),qVar"state")), + (Mop(Not, + Dest + ("Permit_Store",bTy, + Call + ("rec'Perms",CTy"Perms", + Dest + ("perms",FTy 31, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")))))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcPermStore",CTy"CapException"), + Var("cb",FTy 5)]),qVar"state")), + (Bop(Ugt, + Bop(Add, + Bop(Add,Mop(SE(FTy 65),Var("offset",F8)), + CC[LW(0,1), + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"state"))]), + LW(32,65)), + CC[LW(0,1), + Dest + ("length",F64, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")))]), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcLength",CTy"CapException"), + Var("cb",FTy 5)]),qVar"state")), + (Bop(Lt, + Bop(Add,Mop(SE(FTy 65),Var("offset",F8)), + CC[LW(0,1), + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"state"))]), + LW(0,65)), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcLength",CTy"CapException"), + Var("cb",FTy 5)]),qVar"state")), + (Mop(Not,EQ(EX(Var("v",F64),LN 4,LN 0,FTy 5),LW(0,5))), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("AdES",CTy"ExceptionType")), + Mop(Snd, + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("BadVAddr", + TP[Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))),qVar"state")), + Var("v",F64)])),qVar"state"))))], + Let(TP[Var("v",PTy(F64,FTy 5)),qVar"s"], + Let(TP[Var("v",F64),qVar"s"], + Let(TP[bVar"v",qVar"s"], + Apply + (Call + ("StoreMemoryCap",ATy(qTy,PTy(bTy,qTy)), + TP[Const("DOUBLEWORD",FTy 3), + Const("DOUBLEWORD",FTy 3), + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rs",FTy 5)),qVar"state")), + Var("v",F64),LC("DATA",CTy"IorD"), + LC("LOAD",CTy"AccessType"),LT]), + qVar"state"), + TP[ITE(bVar"v",LW(1,64),LW(0,64)),qVar"s"]), + TP[TP[Var("v",F64),Var("rs",FTy 5)],qVar"s"]), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + Var("v",PTy(F64,FTy 5))),qVar"s")))))) +; +val dfn'CJR_def = Def + ("dfn'CJR",Var("cb",FTy 5), + Close + (qVar"state", + ITE(Mop(Not, + Dest + ("CU2",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))), + Apply + (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), + qVar"state"), + Let(qVar"s", + Mop(Snd, + Apply + (Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))), + qVar"state")), + ITB([(Mop(Fst, + Apply + (Call + ("register_inaccessible", + ATy(qTy,PTy(bTy,qTy)),Var("cb",FTy 5)), + qVar"s")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cb",FTy 5)),qVar"s")), + (Mop(Not, + Dest + ("tag",bTy, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"s")))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcTag",CTy"CapException"), + Var("cb",FTy 5)]),qVar"s")), + (Dest + ("sealed",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"s"))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcSeal",CTy"CapException"), + Var("cb",FTy 5)]),qVar"s")), + (Mop(Not, + Dest + ("Permit_Execute",bTy, + Call + ("rec'Perms",CTy"Perms", + Dest + ("perms",FTy 31, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"s")))))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcPermExe",CTy"CapException"), + Var("cb",FTy 5)]),qVar"s")), + (Mop(Not, + Dest + ("Global",bTy, + Call + ("rec'Perms",CTy"Perms", + Dest + ("perms",FTy 31, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"s")))))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcGlobal",CTy"CapException"), + Var("cb",FTy 5)]),qVar"s")), + (Bop(Ugt, + Bop(Add, + Dest + ("offset",F64, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"s"))), + LW(4,64)), + Dest + ("length",F64, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"s")))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcLength",CTy"CapException"), + Var("cb",FTy 5)]),qVar"s")), + (Mop(Not, + EQ(EX(Bop(Add, + Dest + ("base",F64, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"s"))), + Dest + ("offset",F64, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"s")))), + LN 1,LN 0,FTy 2),LW(0,2))), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("AdEL",CTy"ExceptionType")), + Mop(Snd, + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("BadVAddr", + TP[Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))),qVar"s")), + Bop(Add, + Dest + ("base",F64, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("cb",FTy 5)), + qVar"s"))), + Dest + ("offset",F64, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("cb",FTy 5)), + qVar"s"))))])), + qVar"s"))))], + Apply + (Call + ("write'BranchToPCC",ATy(qTy,PTy(uTy,qTy)), + Mop(Some, + TP[Dest + ("offset",F64, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"s"))), + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"s"))])), + qVar"s")))))) +; +val dfn'CJALR_def = Def + ("dfn'CJALR",TP[Var("cd",FTy 5),Var("cb",FTy 5)], + Close + (qVar"state", + ITE(Mop(Not, + Dest + ("CU2",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))), + Apply + (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), + qVar"state"), + Let(qVar"s", + Mop(Snd, + Apply + (Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))), + qVar"state")), + ITB([(Mop(Fst, + Apply + (Call + ("register_inaccessible", + ATy(qTy,PTy(bTy,qTy)),Var("cd",FTy 5)), + qVar"s")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cd",FTy 5)),qVar"s")), + (Mop(Fst, + Apply + (Call + ("register_inaccessible", + ATy(qTy,PTy(bTy,qTy)),Var("cb",FTy 5)), + qVar"s")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cb",FTy 5)),qVar"s")), + (Mop(Not, + Dest + ("tag",bTy, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"s")))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcTag",CTy"CapException"), + Var("cb",FTy 5)]),qVar"s")), + (Dest + ("sealed",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"s"))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcSeal",CTy"CapException"), + Var("cb",FTy 5)]),qVar"s")), + (Mop(Not, + Dest + ("Permit_Execute",bTy, + Call + ("rec'Perms",CTy"Perms", + Dest + ("perms",FTy 31, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"s")))))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcPermExe",CTy"CapException"), + Var("cb",FTy 5)]),qVar"s")), + (Mop(Not, + Dest + ("Global",bTy, + Call + ("rec'Perms",CTy"Perms", + Dest + ("perms",FTy 31, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"s")))))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcGlobal",CTy"CapException"), + Var("cb",FTy 5)]),qVar"s")), + (Bop(Ugt, + Bop(Add, + Dest + ("offset",F64, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"s"))), + LW(4,64)), + Dest + ("length",F64, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"s")))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcLength",CTy"CapException"), + Var("cb",FTy 5)]),qVar"s")), + (Mop(Not, + EQ(EX(Bop(Add, + Dest + ("base",F64, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"s"))), + Dest + ("offset",F64, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"s")))), + LN 1,LN 0,FTy 2),LW(0,2))), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("AdEL",CTy"ExceptionType")), + Mop(Snd, + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("BadVAddr", + TP[Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))),qVar"s")), + Bop(Add, + Dest + ("base",F64, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("cb",FTy 5)), + qVar"s"))), + Dest + ("offset",F64, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("cb",FTy 5)), + qVar"s"))))])), + qVar"s"))))], + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Fst, + Apply + (Const + ("PCC", + ATy(qTy, + PTy(CTy"Capability",qTy))), + qVar"s")),Var("cd",FTy 5)]), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Rupd + ("offset", + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("cd",FTy 5)), + qVar"s")), + Bop(Add, + Mop(Fst, + Apply + (Const + ("PC", + ATy(qTy, + PTy(F64,qTy))), + qVar"s")),LW(8,64))]), + Var("cd",FTy 5)]),qVar"s")), + Apply + (Call + ("write'BranchToPCC",ATy(qTy,PTy(uTy,qTy)), + Mop(Some, + TP[Dest + ("offset",F64, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("cb",FTy 5)), + qVar"s"))), + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("cb",FTy 5)),qVar"s"))])), + qVar"s")))))))) +; +val dfn'CSeal_def = Def + ("dfn'CSeal",TP[Var("cd",FTy 5),Var("cs",FTy 5),Var("ct",FTy 5)], + Close + (qVar"state", + ITB([(Mop(Not, + Dest + ("CU2",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))), + Apply + (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), + qVar"state")), + (Mop(Fst, + Apply + (Call + ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), + Var("cd",FTy 5)),qVar"state")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cd",FTy 5)),qVar"state")), + (Mop(Fst, + Apply + (Call + ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), + Var("cs",FTy 5)),qVar"state")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cs",FTy 5)),qVar"state")), + (Mop(Fst, + Apply + (Call + ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), + Var("ct",FTy 5)),qVar"state")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("ct",FTy 5)),qVar"state")), + (Mop(Not, + Dest + ("tag",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cs",FTy 5)),qVar"state")))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcTag",CTy"CapException"),Var("cs",FTy 5)]), + qVar"state")), + (Mop(Not, + Dest + ("tag",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("ct",FTy 5)),qVar"state")))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcTag",CTy"CapException"),Var("ct",FTy 5)]), + qVar"state")), + (Dest + ("sealed",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cs",FTy 5)),qVar"state"))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcSeal",CTy"CapException"),Var("cs",FTy 5)]), + qVar"state")), + (Dest + ("sealed",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("ct",FTy 5)),qVar"state"))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcSeal",CTy"CapException"),Var("ct",FTy 5)]), + qVar"state")), + (Mop(Not, + Dest + ("Permit_Seal",bTy, + Call + ("rec'Perms",CTy"Perms", + Dest + ("perms",FTy 31, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("ct",FTy 5)),qVar"state")))))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcPermSeal",CTy"CapException"), + Var("ct",FTy 5)]),qVar"state")), + (Bop(Uge, + Dest + ("offset",F64, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("ct",FTy 5)),qVar"state"))), + Dest + ("length",F64, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("ct",FTy 5)),qVar"state")))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcLength",CTy"CapException"),Var("ct",FTy 5)]), + qVar"state")), + (Bop(Uge, + Bop(Add, + Dest + ("base",F64, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("ct",FTy 5)),qVar"state"))), + Dest + ("offset",F64, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("ct",FTy 5)),qVar"state")))), + LW(16777216,64)), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcLength",CTy"CapException"),Var("ct",FTy 5)]), + qVar"state"))], + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cs",FTy 5)),qVar"state")), + Var("cd",FTy 5)]),qVar"state")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Rupd + ("sealed", + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability",qTy)), + Var("cd",FTy 5)),qVar"s")), + LT]),Var("cd",FTy 5)]),qVar"s")), + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Rupd + ("otype", + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability",qTy)), + Var("cd",FTy 5)),qVar"s")), + EX(Bop(Add, + Dest + ("base",F64, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("ct",FTy 5)), + qVar"s"))), + Dest + ("offset",F64, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("ct",FTy 5)), + qVar"s")))),LN 23,LN 0, + FTy 24)]),Var("cd",FTy 5)]),qVar"s")))))) +; +val dfn'CUnseal_def = Def + ("dfn'CUnseal",TP[Var("cd",FTy 5),Var("cs",FTy 5),Var("ct",FTy 5)], + Close + (qVar"state", + ITB([(Mop(Not, + Dest + ("CU2",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))), + Apply + (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), + qVar"state")), + (Mop(Fst, + Apply + (Call + ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), + Var("cd",FTy 5)),qVar"state")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cd",FTy 5)),qVar"state")), + (Mop(Fst, + Apply + (Call + ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), + Var("cs",FTy 5)),qVar"state")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cs",FTy 5)),qVar"state")), + (Mop(Fst, + Apply + (Call + ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), + Var("ct",FTy 5)),qVar"state")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("ct",FTy 5)),qVar"state")), + (Mop(Not, + Dest + ("tag",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cs",FTy 5)),qVar"state")))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcTag",CTy"CapException"),Var("cs",FTy 5)]), + qVar"state")), + (Mop(Not, + Dest + ("tag",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("ct",FTy 5)),qVar"state")))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcTag",CTy"CapException"),Var("ct",FTy 5)]), + qVar"state")), + (Mop(Not, + Dest + ("sealed",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cs",FTy 5)),qVar"state")))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcSeal",CTy"CapException"),Var("cs",FTy 5)]), + qVar"state")), + (Dest + ("sealed",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("ct",FTy 5)),qVar"state"))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcSeal",CTy"CapException"),Var("ct",FTy 5)]), + qVar"state")), + (Mop(Not, + EQ(EX(Bop(Add, + Dest + ("base",F64, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("ct",FTy 5)),qVar"state"))), + Dest + ("offset",F64, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("ct",FTy 5)),qVar"state")))), + LN 23,LN 0,FTy 24), + Dest + ("otype",FTy 24, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cs",FTy 5)),qVar"state"))))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcType",CTy"CapException"),Var("ct",FTy 5)]), + qVar"state")), + (Mop(Not, + Dest + ("Permit_Seal",bTy, + Call + ("rec'Perms",CTy"Perms", + Dest + ("perms",FTy 31, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("ct",FTy 5)),qVar"state")))))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcPermSeal",CTy"CapException"), + Var("ct",FTy 5)]),qVar"state")), + (Bop(Uge, + Dest + ("offset",F64, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("ct",FTy 5)),qVar"state"))), + Dest + ("length",F64, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("ct",FTy 5)),qVar"state")))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcLength",CTy"CapException"),Var("ct",FTy 5)]), + qVar"state"))], + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cs",FTy 5)),qVar"state")), + Var("cd",FTy 5)]),qVar"state")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Rupd + ("sealed", + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability",qTy)), + Var("cd",FTy 5)),qVar"s")), + LF]),Var("cd",FTy 5)]),qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Rupd + ("otype", + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("cd",FTy 5)), + qVar"s")),LW(0,24)]), + Var("cd",FTy 5)]),qVar"s")), + Let(Var("v",CTy"Capability"), + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cd",FTy 5)),qVar"s")), + Let(Var("x1",FTy 31), + Dest + ("perms",FTy 31,Var("v",CTy"Capability")), + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Rupd + ("perms", + TP[Var("v",CTy"Capability"), + Call + ("write'rec'Perms",FTy 31, + TP[Var("x1",FTy 31), + Rupd + ("Global", + TP[Call + ("rec'Perms", + CTy"Perms", + Var("x1", + FTy 31)), + Bop(And, + Dest + ("Global", + bTy, + Call + ("rec'Perms", + CTy"Perms", + Dest + ("perms", + FTy 31, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("cs", + FTy 5)), + qVar"s"))))), + Dest + ("Global", + bTy, + Call + ("rec'Perms", + CTy"Perms", + Dest + ("perms", + FTy 31, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("ct", + FTy 5)), + qVar"s"))))))])])]), + Var("cd",FTy 5)]),qVar"s"))))))))) +; +val dfn'CCall_def = Def + ("dfn'CCall",TP[Var("cs",FTy 5),Var("cb",FTy 5)], + Close + (qVar"state", + ITE(Mop(Not, + Dest + ("CU2",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))), + Apply + (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), + qVar"state"), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcCall",CTy"CapException"),Var("cs",FTy 5)]), + qVar"state")))) +; +val dfn'CReturn_def = Def + ("dfn'CReturn",qVar"state", + ITE(Mop(Not, + Dest + ("CU2",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))), + Apply + (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), + qVar"state"), + Apply + (Call + ("SignalCapException_noReg",ATy(qTy,PTy(uTy,qTy)), + LC("capExcRet",CTy"CapException")),qVar"state"))) +; +val dfn'UnknownCapInstruction_def = Def + ("dfn'UnknownCapInstruction",qVar"state", + ITE(Mop(Not, + Dest + ("CU2",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state"))))), + Apply + (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), + qVar"state"), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("ResI",CTy"ExceptionType")),qVar"state"))) +; +val dfn'ADDI_def = Def + ("dfn'ADDI",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("immediate",F16)], + Close + (qVar"state", + Let(qVar"s", + ITE(Call + ("NotWordValue",bTy, + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state"))), + Mop(Snd, + Apply + (Call + ("raise'exception",ATy(qTy,PTy(uTy,qTy)), + Call + ("UNPREDICTABLE",CTy"exception", + LS"ADDI: NotWordValue")),qVar"state")), + qVar"state"), + Let(Var("v",FTy 33), + Bop(Add, + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"s")),LN 32,LN 0,FTy 33), + Mop(SE(FTy 33),Var("immediate",F16))), + ITE(Mop(Not, + EQ(Bop(Bit,Var("v",FTy 33),LN 32), + Bop(Bit,Var("v",FTy 33),LN 31))), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("Ov",CTy"ExceptionType")),qVar"s"), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(SE F64,EX(Var("v",FTy 33),LN 31,LN 0,F32)), + Var("rt",FTy 5)]),qVar"s")))))) +; +val dfn'ADDIU_def = Def + ("dfn'ADDIU",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("immediate",F16)], + Close + (qVar"state", + Let(qVar"s", + ITE(Call + ("NotWordValue",bTy, + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state"))), + Mop(Snd, + Apply + (Call + ("raise'exception",ATy(qTy,PTy(uTy,qTy)), + Call + ("UNPREDICTABLE",CTy"exception", + LS"ADDIU: NotWordValue")),qVar"state")), + qVar"state"), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(SE F64, + Bop(Add, + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rs",FTy 5)),qVar"s")),LN 31, + LN 0,F32),Mop(SE F32,Var("immediate",F16)))), + Var("rt",FTy 5)]),qVar"s")))) +; +val dfn'DADDI_def = Def + ("dfn'DADDI",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("immediate",F16)], + Close + (qVar"state", + Let(Var("v",FTy 65), + Bop(Add, + Mop(SE(FTy 65), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state"))), + Mop(SE(FTy 65),Var("immediate",F16))), + ITE(Mop(Not, + EQ(Bop(Bit,Var("v",FTy 65),LN 64), + Bop(Bit,Var("v",FTy 65),LN 63))), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("Ov",CTy"ExceptionType")),qVar"state"), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[EX(Var("v",FTy 65),LN 63,LN 0,F64),Var("rt",FTy 5)]), + qVar"state"))))) +; +val dfn'DADDIU_def = Def + ("dfn'DADDIU",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("immediate",F16)], + Close + (qVar"state", + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Bop(Add, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")),Mop(SE F64,Var("immediate",F16))), + Var("rt",FTy 5)]),qVar"state"))) +; +val dfn'SLTI_def = Def + ("dfn'SLTI",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("immediate",F16)], + Close + (qVar"state", + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Cast F64, + Bop(Lt, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rs",FTy 5)),qVar"state")), + Mop(SE F64,Var("immediate",F16)))),Var("rt",FTy 5)]), + qVar"state"))) +; +val dfn'SLTIU_def = Def + ("dfn'SLTIU",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("immediate",F16)], + Close + (qVar"state", + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Cast F64, + Bop(Ult, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rs",FTy 5)),qVar"state")), + Mop(SE F64,Var("immediate",F16)))),Var("rt",FTy 5)]), + qVar"state"))) +; +val dfn'ANDI_def = Def + ("dfn'ANDI",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("immediate",F16)], + Close + (qVar"state", + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Bop(BAnd, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")),Mop(Cast F64,Var("immediate",F16))), + Var("rt",FTy 5)]),qVar"state"))) +; +val dfn'ORI_def = Def + ("dfn'ORI",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("immediate",F16)], + Close + (qVar"state", + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Bop(BOr, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")),Mop(Cast F64,Var("immediate",F16))), + Var("rt",FTy 5)]),qVar"state"))) +; +val dfn'XORI_def = Def + ("dfn'XORI",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("immediate",F16)], + Close + (qVar"state", + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Bop(BXor, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")),Mop(Cast F64,Var("immediate",F16))), + Var("rt",FTy 5)]),qVar"state"))) +; +val dfn'LUI_def = Def + ("dfn'LUI",TP[Var("rt",FTy 5),Var("immediate",F16)], + Close + (qVar"state", + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(SE F64,CC[Var("immediate",F16),LW(0,16)]), + Var("rt",FTy 5)]),qVar"state"))) +; +val dfn'ADD_def = Def + ("dfn'ADD",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)], + Close + (qVar"state", + Let(qVar"s", + ITE(Bop(Or, + Call + ("NotWordValue",bTy, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state"))), + Call + ("NotWordValue",bTy, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state")))), + Mop(Snd, + Apply + (Call + ("raise'exception",ATy(qTy,PTy(uTy,qTy)), + Call + ("UNPREDICTABLE",CTy"exception", + LS"ADD: NotWordValue")),qVar"state")), + qVar"state"), + Let(Var("v",FTy 33), + Bop(Add, + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"s")),LN 32,LN 0,FTy 33), + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"s")),LN 32,LN 0,FTy 33)), + ITE(Mop(Not, + EQ(Bop(Bit,Var("v",FTy 33),LN 32), + Bop(Bit,Var("v",FTy 33),LN 31))), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("Ov",CTy"ExceptionType")),qVar"s"), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(SE F64,EX(Var("v",FTy 33),LN 31,LN 0,F32)), + Var("rd",FTy 5)]),qVar"s")))))) +; +val dfn'ADDU_def = Def + ("dfn'ADDU",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)], + Close + (qVar"state", + Let(qVar"s", + ITE(Bop(Or, + Call + ("NotWordValue",bTy, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state"))), + Call + ("NotWordValue",bTy, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state")))), + Mop(Snd, + Apply + (Call + ("raise'exception",ATy(qTy,PTy(uTy,qTy)), + Call + ("UNPREDICTABLE",CTy"exception", + LS"ADDU: NotWordValue")),qVar"state")), + qVar"state"), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(SE F64, + Bop(Add, + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rs",FTy 5)),qVar"s")),LN 31, + LN 0,F32), + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"s")),LN 31, + LN 0,F32))),Var("rd",FTy 5)]),qVar"s")))) +; +val dfn'SUB_def = Def + ("dfn'SUB",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)], + Close + (qVar"state", + Let(qVar"s", + ITE(Bop(Or, + Call + ("NotWordValue",bTy, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state"))), + Call + ("NotWordValue",bTy, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state")))), + Mop(Snd, + Apply + (Call + ("raise'exception",ATy(qTy,PTy(uTy,qTy)), + Call + ("UNPREDICTABLE",CTy"exception", + LS"SUB: NotWordValue")),qVar"state")), + qVar"state"), + Let(Var("v",FTy 33), + Bop(Sub, + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"s")),LN 32,LN 0,FTy 33), + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"s")),LN 32,LN 0,FTy 33)), + ITE(Mop(Not, + EQ(Bop(Bit,Var("v",FTy 33),LN 32), + Bop(Bit,Var("v",FTy 33),LN 31))), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("Ov",CTy"ExceptionType")),qVar"s"), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(SE F64,EX(Var("v",FTy 33),LN 31,LN 0,F32)), + Var("rd",FTy 5)]),qVar"s")))))) +; +val dfn'SUBU_def = Def + ("dfn'SUBU",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)], + Close + (qVar"state", + Let(qVar"s", + ITE(Bop(Or, + Call + ("NotWordValue",bTy, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state"))), + Call + ("NotWordValue",bTy, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state")))), + Mop(Snd, + Apply + (Call + ("raise'exception",ATy(qTy,PTy(uTy,qTy)), + Call + ("UNPREDICTABLE",CTy"exception", + LS"SUBU: NotWordValue")),qVar"state")), + qVar"state"), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(SE F64, + Bop(Sub, + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rs",FTy 5)),qVar"s")),LN 31, + LN 0,F32), + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"s")),LN 31, + LN 0,F32))),Var("rd",FTy 5)]),qVar"s")))) +; +val dfn'DADD_def = Def + ("dfn'DADD",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)], + Close + (qVar"state", + Let(Var("v",FTy 65), + Bop(Add, + Mop(SE(FTy 65), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state"))), + Mop(SE(FTy 65), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state")))), + ITE(Mop(Not, + EQ(Bop(Bit,Var("v",FTy 65),LN 64), + Bop(Bit,Var("v",FTy 65),LN 63))), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("Ov",CTy"ExceptionType")),qVar"state"), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[EX(Var("v",FTy 65),LN 63,LN 0,F64),Var("rd",FTy 5)]), + qVar"state"))))) +; +val dfn'DADDU_def = Def + ("dfn'DADDU",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)], + Close + (qVar"state", + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Bop(Add, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")), + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state"))),Var("rd",FTy 5)]),qVar"state"))) +; +val dfn'DSUB_def = Def + ("dfn'DSUB",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)], + Close + (qVar"state", + Let(Var("v",FTy 65), + Bop(Sub, + Mop(SE(FTy 65), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state"))), + Mop(SE(FTy 65), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state")))), + ITE(Mop(Not, + EQ(Bop(Bit,Var("v",FTy 65),LN 64), + Bop(Bit,Var("v",FTy 65),LN 63))), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("Ov",CTy"ExceptionType")),qVar"state"), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[EX(Var("v",FTy 65),LN 63,LN 0,F64),Var("rd",FTy 5)]), + qVar"state"))))) +; +val dfn'DSUBU_def = Def + ("dfn'DSUBU",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)], + Close + (qVar"state", + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Bop(Sub, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")), + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state"))),Var("rd",FTy 5)]),qVar"state"))) +; +val dfn'SLT_def = Def + ("dfn'SLT",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)], + Close + (qVar"state", + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Cast F64, + Bop(Lt, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rs",FTy 5)),qVar"state")), + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"state")))), + Var("rd",FTy 5)]),qVar"state"))) +; +val dfn'SLTU_def = Def + ("dfn'SLTU",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)], + Close + (qVar"state", + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Cast F64, + Bop(Ult, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rs",FTy 5)),qVar"state")), + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"state")))), + Var("rd",FTy 5)]),qVar"state"))) +; +val dfn'AND_def = Def + ("dfn'AND",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)], + Close + (qVar"state", + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Bop(BAnd, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")), + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state"))),Var("rd",FTy 5)]),qVar"state"))) +; +val dfn'OR_def = Def + ("dfn'OR",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)], + Close + (qVar"state", + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Bop(BOr, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")), + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state"))),Var("rd",FTy 5)]),qVar"state"))) +; +val dfn'XOR_def = Def + ("dfn'XOR",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)], + Close + (qVar"state", + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Bop(BXor, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")), + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state"))),Var("rd",FTy 5)]),qVar"state"))) +; +val dfn'NOR_def = Def + ("dfn'NOR",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)], + Close + (qVar"state", + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(BNot, + Bop(BOr, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rs",FTy 5)),qVar"state")), + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"state")))), + Var("rd",FTy 5)]),qVar"state"))) +; +val dfn'MOVN_def = Def + ("dfn'MOVN",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)], + Close + (qVar"state", + ITE(Mop(Not, + EQ(Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state")),LW(0,64))), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")),Var("rd",FTy 5)]),qVar"state"), + TP[LU,qVar"state"]))) +; +val dfn'MOVZ_def = Def + ("dfn'MOVZ",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)], + Close + (qVar"state", + ITE(EQ(Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state")),LW(0,64)), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")),Var("rd",FTy 5)]),qVar"state"), + TP[LU,qVar"state"]))) +; +val dfn'MADD_def = Def + ("dfn'MADD",TP[Var("rs",FTy 5),Var("rt",FTy 5)], + Close + (qVar"state", + Let(qVar"s", + ITE(Bop(Or, + Call + ("NotWordValue",bTy, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state"))), + Call + ("NotWordValue",bTy, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state")))), + Mop(Snd, + Apply + (Call + ("raise'exception",ATy(qTy,PTy(uTy,qTy)), + Call + ("UNPREDICTABLE",CTy"exception", + LS"MADD: NotWordValue")),qVar"state")), + qVar"state"), + Let(Var("v",F64), + Bop(Add, + CC[EX(Mop(Fst, + Apply + (Const("HI",ATy(qTy,PTy(F64,qTy))),qVar"s")), + LN 31,LN 0,F32), + EX(Mop(Fst, + Apply + (Const("LO",ATy(qTy,PTy(F64,qTy))),qVar"s")), + LN 31,LN 0,F32)], + Bop(Mul, + Mop(SE F64, + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rs",FTy 5)),qVar"s")),LN 31, + LN 0,F32)), + Mop(SE F64, + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"s")),LN 31, + LN 0,F32)))), + Apply + (Call + ("write'LO",ATy(qTy,PTy(uTy,qTy)), + Mop(SE F64,EX(Var("v",F64),LN 31,LN 0,F32))), + Mop(Snd, + Apply + (Call + ("write'HI",ATy(qTy,PTy(uTy,qTy)), + Mop(SE F64,EX(Var("v",F64),LN 63,LN 32,F32))), + qVar"s"))))))) +; +val dfn'MADDU_def = Def + ("dfn'MADDU",TP[Var("rs",FTy 5),Var("rt",FTy 5)], + Close + (qVar"state", + Let(qVar"s", + ITE(Bop(Or, + Call + ("NotWordValue",bTy, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state"))), + Call + ("NotWordValue",bTy, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state")))), + Mop(Snd, + Apply + (Call + ("raise'exception",ATy(qTy,PTy(uTy,qTy)), + Call + ("UNPREDICTABLE",CTy"exception", + LS"MADDU: NotWordValue")),qVar"state")), + qVar"state"), + Let(Var("v",F64), + Bop(Add, + CC[EX(Mop(Fst, + Apply + (Const("HI",ATy(qTy,PTy(F64,qTy))),qVar"s")), + LN 31,LN 0,F32), + EX(Mop(Fst, + Apply + (Const("LO",ATy(qTy,PTy(F64,qTy))),qVar"s")), + LN 31,LN 0,F32)], + Bop(Mul, + Mop(Cast F64, + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rs",FTy 5)),qVar"s")),LN 31, + LN 0,F32)), + Mop(Cast F64, + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"s")),LN 31, + LN 0,F32)))), + Apply + (Call + ("write'LO",ATy(qTy,PTy(uTy,qTy)), + Mop(SE F64,EX(Var("v",F64),LN 31,LN 0,F32))), + Mop(Snd, + Apply + (Call + ("write'HI",ATy(qTy,PTy(uTy,qTy)), + Mop(SE F64,EX(Var("v",F64),LN 63,LN 32,F32))), + qVar"s"))))))) +; +val dfn'MSUB_def = Def + ("dfn'MSUB",TP[Var("rs",FTy 5),Var("rt",FTy 5)], + Close + (qVar"state", + Let(qVar"s", + ITE(Bop(Or, + Call + ("NotWordValue",bTy, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state"))), + Call + ("NotWordValue",bTy, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state")))), + Mop(Snd, + Apply + (Call + ("raise'exception",ATy(qTy,PTy(uTy,qTy)), + Call + ("UNPREDICTABLE",CTy"exception", + LS"MSUB: NotWordValue")),qVar"state")), + qVar"state"), + Let(Var("v",F64), + Bop(Sub, + CC[EX(Mop(Fst, + Apply + (Const("HI",ATy(qTy,PTy(F64,qTy))),qVar"s")), + LN 31,LN 0,F32), + EX(Mop(Fst, + Apply + (Const("LO",ATy(qTy,PTy(F64,qTy))),qVar"s")), + LN 31,LN 0,F32)], + Bop(Mul, + Mop(SE F64, + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rs",FTy 5)),qVar"s")),LN 31, + LN 0,F32)), + Mop(SE F64, + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"s")),LN 31, + LN 0,F32)))), + Apply + (Call + ("write'LO",ATy(qTy,PTy(uTy,qTy)), + Mop(SE F64,EX(Var("v",F64),LN 31,LN 0,F32))), + Mop(Snd, + Apply + (Call + ("write'HI",ATy(qTy,PTy(uTy,qTy)), + Mop(SE F64,EX(Var("v",F64),LN 63,LN 32,F32))), + qVar"s"))))))) +; +val dfn'MSUBU_def = Def + ("dfn'MSUBU",TP[Var("rs",FTy 5),Var("rt",FTy 5)], + Close + (qVar"state", + Let(qVar"s", + ITE(Bop(Or, + Call + ("NotWordValue",bTy, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state"))), + Call + ("NotWordValue",bTy, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state")))), + Mop(Snd, + Apply + (Call + ("raise'exception",ATy(qTy,PTy(uTy,qTy)), + Call + ("UNPREDICTABLE",CTy"exception", + LS"MSUBU: NotWordValue")),qVar"state")), + qVar"state"), + Let(Var("v",F64), + Bop(Sub, + CC[EX(Mop(Fst, + Apply + (Const("HI",ATy(qTy,PTy(F64,qTy))),qVar"s")), + LN 31,LN 0,F32), + EX(Mop(Fst, + Apply + (Const("LO",ATy(qTy,PTy(F64,qTy))),qVar"s")), + LN 31,LN 0,F32)], + Bop(Mul, + Mop(Cast F64, + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rs",FTy 5)),qVar"s")),LN 31, + LN 0,F32)), + Mop(Cast F64, + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"s")),LN 31, + LN 0,F32)))), + Apply + (Call + ("write'LO",ATy(qTy,PTy(uTy,qTy)), + Mop(SE F64,EX(Var("v",F64),LN 31,LN 0,F32))), + Mop(Snd, + Apply + (Call + ("write'HI",ATy(qTy,PTy(uTy,qTy)), + Mop(SE F64,EX(Var("v",F64),LN 63,LN 32,F32))), + qVar"s"))))))) +; +val dfn'MUL_def = Def + ("dfn'MUL",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)], + Close + (qVar"state", + Let(qVar"s", + ITE(Bop(Or, + Call + ("NotWordValue",bTy, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state"))), + Call + ("NotWordValue",bTy, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state")))), + Mop(Snd, + Apply + (Call + ("raise'exception",ATy(qTy,PTy(uTy,qTy)), + Call + ("UNPREDICTABLE",CTy"exception", + LS"MUL: NotWordValue")),qVar"state")), + qVar"state"), + Apply + (Call("write'hi",ATy(qTy,PTy(uTy,qTy)),LO F64), + Mop(Snd, + Apply + (Call("write'lo",ATy(qTy,PTy(uTy,qTy)),LO F64), + Mop(Snd, + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(SE F64, + Bop(Mul, + EX(Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rs",FTy 5)), + qVar"s")),LN 31,LN 0, + F32), + EX(Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)), + qVar"s")),LN 31,LN 0, + F32))),Var("rd",FTy 5)]), + qVar"s")))))))) +; +val dfn'MULT_def = Def + ("dfn'MULT",TP[Var("rs",FTy 5),Var("rt",FTy 5)], + Close + (qVar"state", + Let(qVar"s", + ITE(Bop(Or, + Call + ("NotWordValue",bTy, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state"))), + Call + ("NotWordValue",bTy, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state")))), + Mop(Snd, + Apply + (Call + ("raise'exception",ATy(qTy,PTy(uTy,qTy)), + Call + ("UNPREDICTABLE",CTy"exception", + LS"MULT: NotWordValue")),qVar"state")), + qVar"state"), + Let(Var("v",F64), + Bop(Mul, + Mop(SE F64, + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rs",FTy 5)),qVar"s")),LN 31,LN 0, + F32)), + Mop(SE F64, + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"s")),LN 31,LN 0, + F32))), + Apply + (Call + ("write'HI",ATy(qTy,PTy(uTy,qTy)), + Mop(SE F64,EX(Var("v",F64),LN 63,LN 32,F32))), + Mop(Snd, + Apply + (Call + ("write'LO",ATy(qTy,PTy(uTy,qTy)), + Mop(SE F64,EX(Var("v",F64),LN 31,LN 0,F32))), + qVar"s"))))))) +; +val dfn'MULTU_def = Def + ("dfn'MULTU",TP[Var("rs",FTy 5),Var("rt",FTy 5)], + Close + (qVar"state", + Let(qVar"s", + ITE(Bop(Or, + Call + ("NotWordValue",bTy, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state"))), + Call + ("NotWordValue",bTy, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state")))), + Mop(Snd, + Apply + (Call + ("raise'exception",ATy(qTy,PTy(uTy,qTy)), + Call + ("UNPREDICTABLE",CTy"exception", + LS"MULTU: NotWordValue")),qVar"state")), + qVar"state"), + Let(Var("v",F64), + Bop(Mul, + Mop(Cast F64, + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rs",FTy 5)),qVar"s")),LN 31,LN 0, + F32)), + Mop(Cast F64, + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"s")),LN 31,LN 0, + F32))), + Apply + (Call + ("write'HI",ATy(qTy,PTy(uTy,qTy)), + Mop(SE F64,EX(Var("v",F64),LN 63,LN 32,F32))), + Mop(Snd, + Apply + (Call + ("write'LO",ATy(qTy,PTy(uTy,qTy)), + Mop(SE F64,EX(Var("v",F64),LN 31,LN 0,F32))), + qVar"s"))))))) +; +val dfn'DMULT_def = Def + ("dfn'DMULT",TP[Var("rs",FTy 5),Var("rt",FTy 5)], + Close + (qVar"state", + Let(Var("v",FTy 128), + Bop(Mul, + Mop(SE(FTy 128), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state"))), + Mop(SE(FTy 128), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state")))), + Apply + (Call + ("write'HI",ATy(qTy,PTy(uTy,qTy)), + EX(Var("v",FTy 128),LN 127,LN 64,F64)), + Mop(Snd, + Apply + (Call + ("write'LO",ATy(qTy,PTy(uTy,qTy)), + EX(Var("v",FTy 128),LN 63,LN 0,F64)),qVar"state")))))) +; +val dfn'DMULTU_def = Def + ("dfn'DMULTU",TP[Var("rs",FTy 5),Var("rt",FTy 5)], + Close + (qVar"state", + Let(Var("v",FTy 128), + Bop(Mul, + Mop(Cast(FTy 128), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state"))), + Mop(Cast(FTy 128), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state")))), + Apply + (Call + ("write'HI",ATy(qTy,PTy(uTy,qTy)), + EX(Var("v",FTy 128),LN 127,LN 64,F64)), + Mop(Snd, + Apply + (Call + ("write'LO",ATy(qTy,PTy(uTy,qTy)), + EX(Var("v",FTy 128),LN 63,LN 0,F64)),qVar"state")))))) +; +val dfn'DIV_def = Def + ("dfn'DIV",TP[Var("rs",FTy 5),Var("rt",FTy 5)], + Close + (qVar"state", + Let(Var("v",F64), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")), + Let(Var("v0",F64), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state")), + Let(qVar"s1", + ITE(Bop(Or,Call("NotWordValue",bTy,Var("v",F64)), + Call("NotWordValue",bTy,Var("v0",F64))), + Mop(Snd, + Apply + (Call + ("raise'exception",ATy(qTy,PTy(uTy,qTy)), + Call + ("UNPREDICTABLE",CTy"exception", + LS"DIV: NotWordValue")),qVar"state")), + qVar"state"), + ITE(EQ(Var("v0",F64),LW(0,64)), + Apply + (Call("write'hi",ATy(qTy,PTy(uTy,qTy)),LO F64), + Mop(Snd, + Apply + (Call + ("write'lo",ATy(qTy,PTy(uTy,qTy)),LO F64), + qVar"s1"))), + Apply + (Call + ("write'HI",ATy(qTy,PTy(uTy,qTy)), + Mop(SE F64, + Bop(Rem,EX(Var("v",F64),LN 31,LN 0,F32), + EX(Var("v0",F64),LN 31,LN 0,F32)))), + Mop(Snd, + Apply + (Call + ("write'LO",ATy(qTy,PTy(uTy,qTy)), + Mop(SE F64, + Bop(Quot, + EX(Var("v",F64),LN 31,LN 0,F32), + EX(Var("v0",F64),LN 31,LN 0,F32)))), + qVar"s1"))))))))) +; +val dfn'DIVU_def = Def + ("dfn'DIVU",TP[Var("rs",FTy 5),Var("rt",FTy 5)], + Close + (qVar"state", + Let(Var("v",F64), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")), + Let(Var("v0",F64), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state")), + Let(qVar"s1", + ITE(Bop(Or,Call("NotWordValue",bTy,Var("v",F64)), + Call("NotWordValue",bTy,Var("v0",F64))), + Mop(Snd, + Apply + (Call + ("raise'exception",ATy(qTy,PTy(uTy,qTy)), + Call + ("UNPREDICTABLE",CTy"exception", + LS"DIVU: NotWordValue")),qVar"state")), + qVar"state"), + ITE(EQ(Var("v0",F64),LW(0,64)), + Apply + (Call("write'hi",ATy(qTy,PTy(uTy,qTy)),LO F64), + Mop(Snd, + Apply + (Call + ("write'lo",ATy(qTy,PTy(uTy,qTy)),LO F64), + qVar"s1"))), + Apply + (Call + ("write'HI",ATy(qTy,PTy(uTy,qTy)), + Mop(SE F64, + Bop(Mod,EX(Var("v",F64),LN 31,LN 0,F32), + EX(Var("v0",F64),LN 31,LN 0,F32)))), + Mop(Snd, + Apply + (Call + ("write'LO",ATy(qTy,PTy(uTy,qTy)), + Mop(SE F64, + Bop(Div, + EX(Var("v",F64),LN 31,LN 0,F32), + EX(Var("v0",F64),LN 31,LN 0,F32)))), + qVar"s1"))))))))) +; +val dfn'DDIV_def = Def + ("dfn'DDIV",TP[Var("rs",FTy 5),Var("rt",FTy 5)], + Close + (qVar"state", + Let(Var("v",F64), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state")), + ITE(EQ(Var("v",F64),LW(0,64)), + Apply + (Call("write'hi",ATy(qTy,PTy(uTy,qTy)),LO F64), + Mop(Snd, + Apply + (Call("write'lo",ATy(qTy,PTy(uTy,qTy)),LO F64), + qVar"state"))), + Let(Var("v0",F64), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")), + Apply + (Call + ("write'HI",ATy(qTy,PTy(uTy,qTy)), + Bop(Rem,Var("v0",F64),Var("v",F64))), + Mop(Snd, + Apply + (Call + ("write'LO",ATy(qTy,PTy(uTy,qTy)), + Bop(Quot,Var("v0",F64),Var("v",F64))), + qVar"state")))))))) +; +val dfn'DDIVU_def = Def + ("dfn'DDIVU",TP[Var("rs",FTy 5),Var("rt",FTy 5)], + Close + (qVar"state", + Let(Var("v",F64), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state")), + ITE(EQ(Var("v",F64),LW(0,64)), + Apply + (Call("write'hi",ATy(qTy,PTy(uTy,qTy)),LO F64), + Mop(Snd, + Apply + (Call("write'lo",ATy(qTy,PTy(uTy,qTy)),LO F64), + qVar"state"))), + Let(Var("v0",F64), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")), + Apply + (Call + ("write'HI",ATy(qTy,PTy(uTy,qTy)), + Bop(Mod,Var("v0",F64),Var("v",F64))), + Mop(Snd, + Apply + (Call + ("write'LO",ATy(qTy,PTy(uTy,qTy)), + Bop(Div,Var("v0",F64),Var("v",F64))), + qVar"state")))))))) +; +val dfn'MFHI_def = Def + ("dfn'MFHI",Var("rd",FTy 5), + Close + (qVar"state", + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Fst, + Apply(Const("HI",ATy(qTy,PTy(F64,qTy))),qVar"state")), + Var("rd",FTy 5)]),qVar"state"))) +; +val dfn'MFLO_def = Def + ("dfn'MFLO",Var("rd",FTy 5), + Close + (qVar"state", + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Fst, + Apply(Const("LO",ATy(qTy,PTy(F64,qTy))),qVar"state")), + Var("rd",FTy 5)]),qVar"state"))) +; +val dfn'MTHI_def = Def + ("dfn'MTHI",Var("rs",FTy 5), + Close + (qVar"state", + Apply + (Call + ("write'HI",ATy(qTy,PTy(uTy,qTy)), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state"))),qVar"state"))) +; +val dfn'MTLO_def = Def + ("dfn'MTLO",Var("rs",FTy 5), + Close + (qVar"state", + Apply + (Call + ("write'LO",ATy(qTy,PTy(uTy,qTy)), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state"))),qVar"state"))) +; +val dfn'SLL_def = Def + ("dfn'SLL",TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("sa",FTy 5)], + Close + (qVar"state", + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(SE F64, + Bop(Lsl, + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"state")),LN 31, + LN 0,F32),Mop(Cast nTy,Var("sa",FTy 5)))), + Var("rd",FTy 5)]),qVar"state"))) +; +val dfn'SRL_def = Def + ("dfn'SRL",TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("sa",FTy 5)], + Close + (qVar"state", + Let(qVar"s", + ITE(Call + ("NotWordValue",bTy, + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state"))), + Mop(Snd, + Apply + (Call + ("raise'exception",ATy(qTy,PTy(uTy,qTy)), + Call + ("UNPREDICTABLE",CTy"exception", + LS"SRL: NotWordValue")),qVar"state")), + qVar"state"), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(SE F64, + Bop(Lsr, + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"s")),LN 31, + LN 0,F32),Mop(Cast nTy,Var("sa",FTy 5)))), + Var("rd",FTy 5)]),qVar"s")))) +; +val dfn'SRA_def = Def + ("dfn'SRA",TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("sa",FTy 5)], + Close + (qVar"state", + Let(qVar"s", + ITE(Call + ("NotWordValue",bTy, + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state"))), + Mop(Snd, + Apply + (Call + ("raise'exception",ATy(qTy,PTy(uTy,qTy)), + Call + ("UNPREDICTABLE",CTy"exception", + LS"SRA: NotWordValue")),qVar"state")), + qVar"state"), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(SE F64, + Bop(Asr, + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"s")),LN 31, + LN 0,F32),Mop(Cast nTy,Var("sa",FTy 5)))), + Var("rd",FTy 5)]),qVar"s")))) +; +val dfn'SLLV_def = Def + ("dfn'SLLV",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)], + Close + (qVar"state", + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(SE F64, + Bop(Lsl, + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"state")),LN 31, + LN 0,F32), + Mop(Cast nTy, + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rs",FTy 5)),qVar"state")), + LN 4,LN 0,FTy 5)))),Var("rd",FTy 5)]), + qVar"state"))) +; +val dfn'SRLV_def = Def + ("dfn'SRLV",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)], + Close + (qVar"state", + Let(qVar"s", + ITE(Call + ("NotWordValue",bTy, + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state"))), + Mop(Snd, + Apply + (Call + ("raise'exception",ATy(qTy,PTy(uTy,qTy)), + Call + ("UNPREDICTABLE",CTy"exception", + LS"SRLV: NotWordValue")),qVar"state")), + qVar"state"), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(SE F64, + Bop(Lsr, + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"s")),LN 31, + LN 0,F32), + Mop(Cast nTy, + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rs",FTy 5)),qVar"s")), + LN 4,LN 0,FTy 5)))),Var("rd",FTy 5)]), + qVar"s")))) +; +val dfn'SRAV_def = Def + ("dfn'SRAV",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)], + Close + (qVar"state", + Let(qVar"s", + ITE(Call + ("NotWordValue",bTy, + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state"))), + Mop(Snd, + Apply + (Call + ("raise'exception",ATy(qTy,PTy(uTy,qTy)), + Call + ("UNPREDICTABLE",CTy"exception", + LS"SRAV: NotWordValue")),qVar"state")), + qVar"state"), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(SE F64, + Bop(Asr, + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"s")),LN 31, + LN 0,F32), + Mop(Cast nTy, + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rs",FTy 5)),qVar"s")), + LN 4,LN 0,FTy 5)))),Var("rd",FTy 5)]), + qVar"s")))) +; +val dfn'DSLL_def = Def + ("dfn'DSLL",TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("sa",FTy 5)], + Close + (qVar"state", + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Bop(Lsl, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state")),Mop(Cast nTy,Var("sa",FTy 5))), + Var("rd",FTy 5)]),qVar"state"))) +; +val dfn'DSRL_def = Def + ("dfn'DSRL",TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("sa",FTy 5)], + Close + (qVar"state", + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Bop(Lsr, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state")),Mop(Cast nTy,Var("sa",FTy 5))), + Var("rd",FTy 5)]),qVar"state"))) +; +val dfn'DSRA_def = Def + ("dfn'DSRA",TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("sa",FTy 5)], + Close + (qVar"state", + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Bop(Asr, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state")),Mop(Cast nTy,Var("sa",FTy 5))), + Var("rd",FTy 5)]),qVar"state"))) +; +val dfn'DSLLV_def = Def + ("dfn'DSLLV",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)], + Close + (qVar"state", + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Bop(Lsl, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state")), + Mop(Cast nTy, + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rs",FTy 5)),qVar"state")),LN 5, + LN 0,FTy 6))),Var("rd",FTy 5)]),qVar"state"))) +; +val dfn'DSRLV_def = Def + ("dfn'DSRLV",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)], + Close + (qVar"state", + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Bop(Lsr, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state")), + Mop(Cast nTy, + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rs",FTy 5)),qVar"state")),LN 5, + LN 0,FTy 6))),Var("rd",FTy 5)]),qVar"state"))) +; +val dfn'DSRAV_def = Def + ("dfn'DSRAV",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)], + Close + (qVar"state", + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Bop(Asr, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state")), + Mop(Cast nTy, + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rs",FTy 5)),qVar"state")),LN 5, + LN 0,FTy 6))),Var("rd",FTy 5)]),qVar"state"))) +; +val dfn'DSLL32_def = Def + ("dfn'DSLL32",TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("sa",FTy 5)], + Close + (qVar"state", + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Bop(Lsl, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state")), + Bop(Add,Mop(Cast nTy,Var("sa",FTy 5)),LN 32)), + Var("rd",FTy 5)]),qVar"state"))) +; +val dfn'DSRL32_def = Def + ("dfn'DSRL32",TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("sa",FTy 5)], + Close + (qVar"state", + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Bop(Lsr, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state")), + Bop(Add,Mop(Cast nTy,Var("sa",FTy 5)),LN 32)), + Var("rd",FTy 5)]),qVar"state"))) +; +val dfn'DSRA32_def = Def + ("dfn'DSRA32",TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("sa",FTy 5)], + Close + (qVar"state", + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Bop(Asr, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state")), + Bop(Add,Mop(Cast nTy,Var("sa",FTy 5)),LN 32)), + Var("rd",FTy 5)]),qVar"state"))) +; +val dfn'TGE_def = Def + ("dfn'TGE",TP[Var("rs",FTy 5),Var("rt",FTy 5)], + Close + (qVar"state", + ITE(Bop(Ge, + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state"))), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("Tr",CTy"ExceptionType")),qVar"state"), + TP[LU,qVar"state"]))) +; +val dfn'TGEU_def = Def + ("dfn'TGEU",TP[Var("rs",FTy 5),Var("rt",FTy 5)], + Close + (qVar"state", + ITE(Bop(Uge, + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state"))), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("Tr",CTy"ExceptionType")),qVar"state"), + TP[LU,qVar"state"]))) +; +val dfn'TLT_def = Def + ("dfn'TLT",TP[Var("rs",FTy 5),Var("rt",FTy 5)], + Close + (qVar"state", + ITE(Bop(Lt, + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state"))), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("Tr",CTy"ExceptionType")),qVar"state"), + TP[LU,qVar"state"]))) +; +val dfn'TLTU_def = Def + ("dfn'TLTU",TP[Var("rs",FTy 5),Var("rt",FTy 5)], + Close + (qVar"state", + ITE(Bop(Ult, + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state"))), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("Tr",CTy"ExceptionType")),qVar"state"), + TP[LU,qVar"state"]))) +; +val dfn'TEQ_def = Def + ("dfn'TEQ",TP[Var("rs",FTy 5),Var("rt",FTy 5)], + Close + (qVar"state", + ITE(EQ(Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state"))), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("Tr",CTy"ExceptionType")),qVar"state"), + TP[LU,qVar"state"]))) +; +val dfn'TNE_def = Def + ("dfn'TNE",TP[Var("rs",FTy 5),Var("rt",FTy 5)], + Close + (qVar"state", + ITE(Mop(Not, + EQ(Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state")))), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("Tr",CTy"ExceptionType")),qVar"state"), + TP[LU,qVar"state"]))) +; +val dfn'TGEI_def = Def + ("dfn'TGEI",TP[Var("rs",FTy 5),Var("immediate",F16)], + Close + (qVar"state", + ITE(Bop(Ge, + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")),Mop(SE F64,Var("immediate",F16))), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("Tr",CTy"ExceptionType")),qVar"state"), + TP[LU,qVar"state"]))) +; +val dfn'TGEIU_def = Def + ("dfn'TGEIU",TP[Var("rs",FTy 5),Var("immediate",F16)], + Close + (qVar"state", + ITE(Bop(Uge, + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")),Mop(SE F64,Var("immediate",F16))), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("Tr",CTy"ExceptionType")),qVar"state"), + TP[LU,qVar"state"]))) +; +val dfn'TLTI_def = Def + ("dfn'TLTI",TP[Var("rs",FTy 5),Var("immediate",F16)], + Close + (qVar"state", + ITE(Bop(Lt, + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")),Mop(SE F64,Var("immediate",F16))), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("Tr",CTy"ExceptionType")),qVar"state"), + TP[LU,qVar"state"]))) +; +val dfn'TLTIU_def = Def + ("dfn'TLTIU",TP[Var("rs",FTy 5),Var("immediate",F16)], + Close + (qVar"state", + ITE(Bop(Ult, + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")),Mop(SE F64,Var("immediate",F16))), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("Tr",CTy"ExceptionType")),qVar"state"), + TP[LU,qVar"state"]))) +; +val dfn'TEQI_def = Def + ("dfn'TEQI",TP[Var("rs",FTy 5),Var("immediate",F16)], + Close + (qVar"state", + ITE(EQ(Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")),Mop(SE F64,Var("immediate",F16))), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("Tr",CTy"ExceptionType")),qVar"state"), + TP[LU,qVar"state"]))) +; +val dfn'TNEI_def = Def + ("dfn'TNEI",TP[Var("rs",FTy 5),Var("immediate",F16)], + Close + (qVar"state", + ITE(Mop(Not, + EQ(Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")),Mop(SE F64,Var("immediate",F16)))), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("Tr",CTy"ExceptionType")),qVar"state"), + TP[LU,qVar"state"]))) +; +val loadByte_def = Def + ("loadByte", + TP[Var("base",FTy 5),Var("rt",FTy 5),Var("offset",F16),bVar"unsigned"], + Close + (qVar"state", + Let(Var("v",F64), + Bop(Add,Mop(SE F64,Var("offset",F16)), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("base",FTy 5)), + qVar"state"))), + Let(TP[Var("v0",F64),qVar"s"], + Apply + (Call + ("LoadMemory",ATy(qTy,PTy(F64,qTy)), + TP[Const("BYTE",FTy 3),Const("BYTE",FTy 3), + Var("v",F64),LC("DATA",CTy"IorD"), + LC("LOAD",CTy"AccessType"),LF]),qVar"state"), + ITE(Mop(Not, + Mop(Fst, + Apply + (Const + ("exceptionSignalled",ATy(qTy,PTy(bTy,qTy))), + qVar"s"))), + Let(Var("v1",FTy 3), + Bop(BXor,EX(Var("v",F64),LN 2,LN 0,FTy 3), + REP(Mop(Fst, + Apply + (Const + ("BigEndianCPU", + ATy(qTy,PTy(F1,qTy))),qVar"s")), + LN 3,FTy 3)), + Let(Var("membyte",F8), + EX(Var("v0",F64), + Bop(Add,LN 7, + Bop(Mul,LN 8, + Mop(Cast nTy,Var("v1",FTy 3)))), + Bop(Mul,LN 8,Mop(Cast nTy,Var("v1",FTy 3))), + F8), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[ITE(bVar"unsigned", + Mop(Cast F64,Var("membyte",F8)), + Mop(SE F64,Var("membyte",F8))), + Var("rt",FTy 5)]),qVar"s"))), + TP[LU,qVar"s"]))))) +; +val loadHalf_def = Def + ("loadHalf", + TP[Var("base",FTy 5),Var("rt",FTy 5),Var("offset",F16),bVar"unsigned"], + Close + (qVar"state", + Let(Var("v",F64), + Bop(Add,Mop(SE F64,Var("offset",F16)), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("base",FTy 5)), + qVar"state"))), + ITE(Bop(Bit,Var("v",F64),LN 0), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("AdEL",CTy"ExceptionType")), + Mop(Snd, + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("BadVAddr", + TP[Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__",qTy))), + qVar"state")),Var("v",F64)])), + qVar"state"))), + Let(TP[Var("v0",F64),qVar"s"], + Apply + (Call + ("LoadMemory",ATy(qTy,PTy(F64,qTy)), + TP[Const("HALFWORD",FTy 3), + Const("HALFWORD",FTy 3),Var("v",F64), + LC("DATA",CTy"IorD"), + LC("LOAD",CTy"AccessType"),LF]),qVar"state"), + ITE(Mop(Not, + Mop(Fst, + Apply + (Const + ("exceptionSignalled", + ATy(qTy,PTy(bTy,qTy))),qVar"s"))), + Let(Var("v1",FTy 3), + Bop(BXor,EX(Var("v",F64),LN 2,LN 0,FTy 3), + CC[REP(Mop(Fst, + Apply + (Const + ("BigEndianCPU", + ATy(qTy,PTy(F1,qTy))), + qVar"s")),LN 2,FTy 2),LW(0,1)]), + Let(Var("memhalf",F16), + EX(Var("v0",F64), + Bop(Add,LN 15, + Bop(Mul,LN 8, + Mop(Cast nTy,Var("v1",FTy 3)))), + Bop(Mul,LN 8, + Mop(Cast nTy,Var("v1",FTy 3))),F16), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[ITE(bVar"unsigned", + Mop(Cast F64,Var("memhalf",F16)), + Mop(SE F64,Var("memhalf",F16))), + Var("rt",FTy 5)]),qVar"s"))), + TP[LU,qVar"s"])))))) +; +val loadWord_def = Def + ("loadWord", + TP[bVar"link",Var("base",FTy 5),Var("rt",FTy 5),Var("offset",F16), + bVar"unsigned"], + Close + (qVar"state", + Let(Var("v",F64), + Bop(Add,Mop(SE F64,Var("offset",F16)), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("base",FTy 5)), + qVar"state"))), + ITE(Mop(Not,EQ(EX(Var("v",F64),LN 1,LN 0,FTy 2),LW(0,2))), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("AdEL",CTy"ExceptionType")), + Mop(Snd, + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("BadVAddr", + TP[Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__",qTy))), + qVar"state")),Var("v",F64)])), + qVar"state"))), + Let(TP[Var("v0",F64),qVar"s"], + Apply + (Call + ("LoadMemory",ATy(qTy,PTy(F64,qTy)), + TP[Const("WORD",FTy 3),Const("WORD",FTy 3), + Var("v",F64),LC("DATA",CTy"IorD"), + LC("LOAD",CTy"AccessType"),bVar"link"]), + qVar"state"), + ITE(Mop(Not, + Mop(Fst, + Apply + (Const + ("exceptionSignalled", + ATy(qTy,PTy(bTy,qTy))),qVar"s"))), + Let(Var("v1",FTy 3), + Bop(BXor,EX(Var("v",F64),LN 2,LN 0,FTy 3), + CC[Mop(Fst, + Apply + (Const + ("BigEndianCPU", + ATy(qTy,PTy(F1,qTy))),qVar"s")), + LW(0,2)]), + Let(Var("memword",F32), + EX(Var("v0",F64), + Bop(Add,LN 31, + Bop(Mul,LN 8, + Mop(Cast nTy,Var("v1",FTy 3)))), + Bop(Mul,LN 8, + Mop(Cast nTy,Var("v1",FTy 3))),F32), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[ITE(bVar"unsigned", + Mop(Cast F64,Var("memword",F32)), + Mop(SE F64,Var("memword",F32))), + Var("rt",FTy 5)]),qVar"s"))), + TP[LU,qVar"s"])))))) +; +val loadDoubleword_def = Def + ("loadDoubleword", + TP[bVar"link",Var("base",FTy 5),Var("rt",FTy 5),Var("offset",F16)], + Close + (qVar"state", + Let(Var("v",F64), + Bop(Add,Mop(SE F64,Var("offset",F16)), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("base",FTy 5)), + qVar"state"))), + ITE(Mop(Not,EQ(EX(Var("v",F64),LN 2,LN 0,FTy 3),LW(0,3))), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("AdEL",CTy"ExceptionType")), + Mop(Snd, + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("BadVAddr", + TP[Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__",qTy))), + qVar"state")),Var("v",F64)])), + qVar"state"))), + Let(TP[Var("v",F64),qVar"s"], + Apply + (Call + ("LoadMemory",ATy(qTy,PTy(F64,qTy)), + TP[Const("DOUBLEWORD",FTy 3), + Const("DOUBLEWORD",FTy 3),Var("v",F64), + LC("DATA",CTy"IorD"), + LC("LOAD",CTy"AccessType"),bVar"link"]), + qVar"state"), + ITE(Mop(Not, + Mop(Fst, + Apply + (Const + ("exceptionSignalled", + ATy(qTy,PTy(bTy,qTy))),qVar"s"))), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Var("v",F64),Var("rt",FTy 5)]),qVar"s"), + TP[LU,qVar"s"])))))) +; +val dfn'LB_def = Def + ("dfn'LB",TP[Var("base",FTy 5),Var("rt",FTy 5),Var("offset",F16)], + Close + (qVar"state", + Apply + (Call + ("loadByte",ATy(qTy,PTy(uTy,qTy)), + TP[Var("base",FTy 5),Var("rt",FTy 5),Var("offset",F16),LF]), + qVar"state"))) +; +val dfn'LBU_def = Def + ("dfn'LBU",TP[Var("base",FTy 5),Var("rt",FTy 5),Var("offset",F16)], + Close + (qVar"state", + Apply + (Call + ("loadByte",ATy(qTy,PTy(uTy,qTy)), + TP[Var("base",FTy 5),Var("rt",FTy 5),Var("offset",F16),LT]), + qVar"state"))) +; +val dfn'LH_def = Def + ("dfn'LH",TP[Var("base",FTy 5),Var("rt",FTy 5),Var("offset",F16)], + Close + (qVar"state", + Apply + (Call + ("loadHalf",ATy(qTy,PTy(uTy,qTy)), + TP[Var("base",FTy 5),Var("rt",FTy 5),Var("offset",F16),LF]), + qVar"state"))) +; +val dfn'LHU_def = Def + ("dfn'LHU",TP[Var("base",FTy 5),Var("rt",FTy 5),Var("offset",F16)], + Close + (qVar"state", + Apply + (Call + ("loadHalf",ATy(qTy,PTy(uTy,qTy)), + TP[Var("base",FTy 5),Var("rt",FTy 5),Var("offset",F16),LT]), + qVar"state"))) +; +val dfn'LW_def = Def + ("dfn'LW",TP[Var("base",FTy 5),Var("rt",FTy 5),Var("offset",F16)], + Close + (qVar"state", + Apply + (Call + ("loadWord",ATy(qTy,PTy(uTy,qTy)), + TP[LF,Var("base",FTy 5),Var("rt",FTy 5),Var("offset",F16),LF]), + qVar"state"))) +; +val dfn'LWU_def = Def + ("dfn'LWU",TP[Var("base",FTy 5),Var("rt",FTy 5),Var("offset",F16)], + Close + (qVar"state", + Apply + (Call + ("loadWord",ATy(qTy,PTy(uTy,qTy)), + TP[LF,Var("base",FTy 5),Var("rt",FTy 5),Var("offset",F16),LT]), + qVar"state"))) +; +val dfn'LL_def = Def + ("dfn'LL",TP[Var("base",FTy 5),Var("rt",FTy 5),Var("offset",F16)], + Close + (qVar"state", + Apply + (Call + ("loadWord",ATy(qTy,PTy(uTy,qTy)), + TP[LT,Var("base",FTy 5),Var("rt",FTy 5),Var("offset",F16),LF]), + qVar"state"))) +; +val dfn'LD_def = Def + ("dfn'LD",TP[Var("base",FTy 5),Var("rt",FTy 5),Var("offset",F16)], + Close + (qVar"state", + Apply + (Call + ("loadDoubleword",ATy(qTy,PTy(uTy,qTy)), + TP[LF,Var("base",FTy 5),Var("rt",FTy 5),Var("offset",F16)]), + qVar"state"))) +; +val dfn'LLD_def = Def + ("dfn'LLD",TP[Var("base",FTy 5),Var("rt",FTy 5),Var("offset",F16)], + Close + (qVar"state", + Apply + (Call + ("loadDoubleword",ATy(qTy,PTy(uTy,qTy)), + TP[LT,Var("base",FTy 5),Var("rt",FTy 5),Var("offset",F16)]), + qVar"state"))) +; +val dfn'LWL_def = Def + ("dfn'LWL",TP[Var("base",FTy 5),Var("rt",FTy 5),Var("offset",F16)], + Close + (qVar"state", + Let(Var("v",F64), + Bop(Add,Mop(SE F64,Var("offset",F16)), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("base",FTy 5)), + qVar"state"))), + Let(Var("v0",FTy 2), + Bop(BXor,EX(Var("v",F64),LN 1,LN 0,FTy 2), + REP(Mop(Fst, + Apply + (Const("BigEndianCPU",ATy(qTy,PTy(F1,qTy))), + qVar"state")),LN 2,FTy 2)), + Let(TP[Var("v1",F64),qVar"s0"], + Apply + (Call + ("LoadMemory",ATy(qTy,PTy(F64,qTy)), + TP[Const("WORD",FTy 3), + CC[LW(0,1),Var("v0",FTy 2)],Var("v",F64), + LC("DATA",CTy"IorD"), + LC("LOAD",CTy"AccessType"),LF]),qVar"state"), + ITE(Mop(Not, + Mop(Fst, + Apply + (Const + ("exceptionSignalled", + ATy(qTy,PTy(bTy,qTy))),qVar"s0"))), + Let(TP[Var("v",F32),qVar"s"], + CS(TP[Bop(BXor,EX(Var("v",F64),LN 2,LN 2,F1), + Mop(Fst, + Apply + (Const + ("BigEndianCPU", + ATy(qTy,PTy(F1,qTy))), + qVar"state"))),Var("v0",FTy 2)], + [(TP[LW(0,1),LW(0,2)], + TP[CC[EX(Var("v1",F64),LN 7,LN 0,F8), + EX(Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)), + qVar"s0")),LN 23,LN 0, + FTy 24)],qVar"s0"]), + (TP[LW(0,1),LW(1,2)], + TP[CC[EX(Var("v1",F64),LN 15,LN 0,F16), + EX(Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)), + qVar"s0")),LN 15,LN 0,F16)], + qVar"s0"]), + (TP[LW(0,1),LW(2,2)], + TP[CC[EX(Var("v1",F64),LN 23,LN 0,FTy 24), + EX(Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)), + qVar"s0")),LN 7,LN 0,F8)], + qVar"s0"]), + (TP[LW(0,1),LW(3,2)], + TP[EX(Var("v1",F64),LN 31,LN 0,F32), + qVar"s0"]), + (TP[LW(1,1),LW(0,2)], + TP[CC[EX(Var("v1",F64),LN 39,LN 32,F8), + EX(Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)), + qVar"s0")),LN 23,LN 0, + FTy 24)],qVar"s0"]), + (TP[LW(1,1),LW(1,2)], + TP[CC[EX(Var("v1",F64),LN 47,LN 32,F16), + EX(Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)), + qVar"s0")),LN 15,LN 0,F16)], + qVar"s0"]), + (TP[LW(1,1),LW(2,2)], + TP[CC[EX(Var("v1",F64),LN 55,LN 32,FTy 24), + EX(Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)), + qVar"s0")),LN 7,LN 0,F8)], + qVar"s0"]), + (TP[LW(1,1),LW(3,2)], + TP[EX(Var("v1",F64),LN 63,LN 32,F32), + qVar"s0"])]), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(SE F64,Var("v",F32)), + Var("rt",FTy 5)]),qVar"s")), + TP[LU,qVar"s0"])))))) +; +val dfn'LWR_def = Def + ("dfn'LWR",TP[Var("base",FTy 5),Var("rt",FTy 5),Var("offset",F16)], + Close + (qVar"state", + Let(Var("v",F64), + Bop(Add,Mop(SE F64,Var("offset",F16)), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("base",FTy 5)), + qVar"state"))), + Let(Var("v0",FTy 2), + Bop(BXor,EX(Var("v",F64),LN 1,LN 0,FTy 2), + REP(Mop(Fst, + Apply + (Const("BigEndianCPU",ATy(qTy,PTy(F1,qTy))), + qVar"state")),LN 2,FTy 2)), + Let(TP[Var("v1",F64),qVar"s0"], + Apply + (Call + ("LoadMemory",ATy(qTy,PTy(F64,qTy)), + TP[Const("WORD",FTy 3), + Bop(Sub,Const("WORD",FTy 3), + CC[LW(0,1),Var("v0",FTy 2)]),Var("v",F64), + LC("DATA",CTy"IorD"), + LC("LOAD",CTy"AccessType"),LF]),qVar"state"), + ITE(Mop(Not, + Mop(Fst, + Apply + (Const + ("exceptionSignalled", + ATy(qTy,PTy(bTy,qTy))),qVar"s0"))), + Let(TP[Var("v",F32),qVar"s"], + CS(TP[Bop(BXor,EX(Var("v",F64),LN 2,LN 2,F1), + Mop(Fst, + Apply + (Const + ("BigEndianCPU", + ATy(qTy,PTy(F1,qTy))), + qVar"state"))),Var("v0",FTy 2)], + [(TP[LW(0,1),LW(0,2)], + TP[EX(Var("v1",F64),LN 31,LN 0,F32), + qVar"s0"]), + (TP[LW(0,1),LW(1,2)], + TP[CC[EX(Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)), + qVar"s0")),LN 31,LN 24,F8), + EX(Var("v1",F64),LN 31,LN 8,FTy 24)], + qVar"s0"]), + (TP[LW(0,1),LW(2,2)], + TP[CC[EX(Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)), + qVar"s0")),LN 31,LN 16,F16), + EX(Var("v1",F64),LN 31,LN 16,F16)], + qVar"s0"]), + (TP[LW(0,1),LW(3,2)], + TP[CC[EX(Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)), + qVar"s0")),LN 31,LN 8, + FTy 24), + EX(Var("v1",F64),LN 31,LN 24,F8)], + qVar"s0"]), + (TP[LW(1,1),LW(0,2)], + TP[EX(Var("v1",F64),LN 63,LN 32,F32), + qVar"s0"]), + (TP[LW(1,1),LW(1,2)], + TP[CC[EX(Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)), + qVar"s0")),LN 31,LN 24,F8), + EX(Var("v1",F64),LN 63,LN 40,FTy 24)], + qVar"s0"]), + (TP[LW(1,1),LW(2,2)], + TP[CC[EX(Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)), + qVar"s0")),LN 31,LN 16,F16), + EX(Var("v1",F64),LN 63,LN 48,F16)], + qVar"s0"]), + (TP[LW(1,1),LW(3,2)], + TP[CC[EX(Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)), + qVar"s0")),LN 31,LN 8, + FTy 24), + EX(Var("v1",F64),LN 63,LN 56,F8)], + qVar"s0"])]), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(SE F64,Var("v",F32)), + Var("rt",FTy 5)]),qVar"s")), + TP[LU,qVar"s0"])))))) +; +val dfn'LDL_def = Def + ("dfn'LDL",TP[Var("base",FTy 5),Var("rt",FTy 5),Var("offset",F16)], + Close + (qVar"state", + Let(Var("v",F64), + Bop(Add,Mop(SE F64,Var("offset",F16)), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("base",FTy 5)), + qVar"state"))), + Let(Var("v0",FTy 3), + Bop(BXor,EX(Var("v",F64),LN 2,LN 0,FTy 3), + REP(Mop(Fst, + Apply + (Const("BigEndianCPU",ATy(qTy,PTy(F1,qTy))), + qVar"state")),LN 3,FTy 3)), + Let(TP[Var("v1",F64),qVar"s"], + Apply + (Call + ("LoadMemory",ATy(qTy,PTy(F64,qTy)), + TP[Const("DOUBLEWORD",FTy 3),Var("v0",FTy 3), + Var("v",F64),LC("DATA",CTy"IorD"), + LC("LOAD",CTy"AccessType"),LF]),qVar"state"), + ITE(Mop(Not, + Mop(Fst, + Apply + (Const + ("exceptionSignalled", + ATy(qTy,PTy(bTy,qTy))),qVar"s"))), + Let(TP[Var("v",F64),qVar"s"], + CS(Var("v0",FTy 3), + [(LW(0,3), + TP[CC[EX(Var("v1",F64),LN 7,LN 0,F8), + EX(Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"s")), + LN 55,LN 0,FTy 56)],qVar"s"]), + (LW(1,3), + TP[CC[EX(Var("v1",F64),LN 15,LN 0,F16), + EX(Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"s")), + LN 47,LN 0,FTy 48)],qVar"s"]), + (LW(2,3), + TP[CC[EX(Var("v1",F64),LN 23,LN 0,FTy 24), + EX(Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"s")), + LN 39,LN 0,FTy 40)],qVar"s"]), + (LW(3,3), + TP[CC[EX(Var("v1",F64),LN 31,LN 0,F32), + EX(Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"s")), + LN 31,LN 0,F32)],qVar"s"]), + (LW(4,3), + TP[CC[EX(Var("v1",F64),LN 39,LN 0,FTy 40), + EX(Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"s")), + LN 23,LN 0,FTy 24)],qVar"s"]), + (LW(5,3), + TP[CC[EX(Var("v1",F64),LN 47,LN 0,FTy 48), + EX(Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"s")), + LN 15,LN 0,F16)],qVar"s"]), + (LW(6,3), + TP[CC[EX(Var("v1",F64),LN 55,LN 0,FTy 56), + EX(Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"s")), + LN 7,LN 0,F8)],qVar"s"]), + (LW(7,3), + TP[EX(Var("v1",F64),LN 63,LN 0,F64),qVar"s"])]), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Var("v",F64),Var("rt",FTy 5)]),qVar"s")), + TP[LU,qVar"s"])))))) +; +val dfn'LDR_def = Def + ("dfn'LDR",TP[Var("base",FTy 5),Var("rt",FTy 5),Var("offset",F16)], + Close + (qVar"state", + Let(Var("v",F64), + Bop(Add,Mop(SE F64,Var("offset",F16)), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("base",FTy 5)), + qVar"state"))), + Let(Var("v0",FTy 3), + Bop(BXor,EX(Var("v",F64),LN 2,LN 0,FTy 3), + REP(Mop(Fst, + Apply + (Const("BigEndianCPU",ATy(qTy,PTy(F1,qTy))), + qVar"state")),LN 3,FTy 3)), + Let(TP[Var("v1",F64),qVar"s"], + Apply + (Call + ("LoadMemory",ATy(qTy,PTy(F64,qTy)), + TP[Const("DOUBLEWORD",FTy 3), + Bop(Sub,Const("DOUBLEWORD",FTy 3), + Var("v0",FTy 3)),Var("v",F64), + LC("DATA",CTy"IorD"), + LC("LOAD",CTy"AccessType"),LF]),qVar"state"), + ITE(Mop(Not, + Mop(Fst, + Apply + (Const + ("exceptionSignalled", + ATy(qTy,PTy(bTy,qTy))),qVar"s"))), + Let(TP[Var("v",F64),qVar"s"], + CS(Var("v0",FTy 3), + [(LW(0,3), + TP[EX(Var("v1",F64),LN 63,LN 0,F64),qVar"s"]), + (LW(1,3), + TP[CC[EX(Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"s")), + LN 63,LN 56,F8), + EX(Var("v1",F64),LN 63,LN 8,FTy 56)], + qVar"s"]), + (LW(2,3), + TP[CC[EX(Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"s")), + LN 63,LN 48,F16), + EX(Var("v1",F64),LN 63,LN 16,FTy 48)], + qVar"s"]), + (LW(3,3), + TP[CC[EX(Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"s")), + LN 63,LN 40,FTy 24), + EX(Var("v1",F64),LN 63,LN 24,FTy 40)], + qVar"s"]), + (LW(4,3), + TP[CC[EX(Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"s")), + LN 63,LN 32,F32), + EX(Var("v1",F64),LN 63,LN 32,F32)], + qVar"s"]), + (LW(5,3), + TP[CC[EX(Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"s")), + LN 63,LN 24,FTy 40), + EX(Var("v1",F64),LN 63,LN 40,FTy 24)], + qVar"s"]), + (LW(6,3), + TP[CC[EX(Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"s")), + LN 63,LN 16,FTy 48), + EX(Var("v1",F64),LN 63,LN 48,F16)], + qVar"s"]), + (LW(7,3), + TP[CC[EX(Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"s")), + LN 63,LN 8,FTy 56), + EX(Var("v1",F64),LN 63,LN 56,F8)], + qVar"s"])]), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Var("v",F64),Var("rt",FTy 5)]),qVar"s")), + TP[LU,qVar"s"])))))) +; +val dfn'SB_def = Def + ("dfn'SB",TP[Var("base",FTy 5),Var("rt",FTy 5),Var("offset",F16)], + Close + (qVar"state", + Let(Var("v",F64), + Bop(Add,Mop(SE F64,Var("offset",F16)), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("base",FTy 5)), + qVar"state"))), + Let(TP[bVar"v",qVar"s"], + Apply + (Call + ("StoreMemory",ATy(qTy,PTy(bTy,qTy)), + TP[Const("BYTE",FTy 3),Const("BYTE",FTy 3), + Bop(Lsl, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"state")), + Bop(Mul,LN 8, + Mop(Cast nTy, + Bop(BXor, + EX(Var("v",F64),LN 2,LN 0,FTy 3), + REP(Mop(Fst, + Apply + (Const + ("BigEndianCPU", + ATy(qTy,PTy(F1,qTy))), + qVar"state")),LN 3,FTy 3))))), + Var("v",F64),LC("DATA",CTy"IorD"), + LC("STORE",CTy"AccessType"),LF]),qVar"state"), + ITE(Mop(Not, + Mop(Fst, + Apply + (Const + ("exceptionSignalled",ATy(qTy,PTy(bTy,qTy))), + qVar"s"))), + Apply + (Call("write'LLbit",ATy(qTy,PTy(uTy,qTy)),LO bTy), + qVar"s"),TP[LU,qVar"s"]))))) +; +val dfn'SH_def = Def + ("dfn'SH",TP[Var("base",FTy 5),Var("rt",FTy 5),Var("offset",F16)], + Close + (qVar"state", + Let(Var("v",F64), + Bop(Add,Mop(SE F64,Var("offset",F16)), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("base",FTy 5)), + qVar"state"))), + ITE(Bop(Bit,Var("v",F64),LN 0), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("AdES",CTy"ExceptionType")), + Mop(Snd, + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("BadVAddr", + TP[Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__",qTy))), + qVar"state")),Var("v",F64)])), + qVar"state"))), + Let(TP[bVar"v",qVar"s"], + Apply + (Call + ("StoreMemory",ATy(qTy,PTy(bTy,qTy)), + TP[Const("HALFWORD",FTy 3), + Const("HALFWORD",FTy 3), + Bop(Lsl, + Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"state")), + Bop(Mul,LN 8, + Mop(Cast nTy, + Bop(BXor, + EX(Var("v",F64),LN 2,LN 0,FTy 3), + CC[REP(Mop(Fst, + Apply + (Const + ("BigEndianCPU", + ATy(qTy, + PTy(F1,qTy))), + qVar"state")), + LN 2,FTy 2),LW(0,1)])))), + Var("v",F64),LC("DATA",CTy"IorD"), + LC("STORE",CTy"AccessType"),LF]),qVar"state"), + ITE(Mop(Not, + Mop(Fst, + Apply + (Const + ("exceptionSignalled", + ATy(qTy,PTy(bTy,qTy))),qVar"s"))), + Apply + (Call("write'LLbit",ATy(qTy,PTy(uTy,qTy)),LO bTy), + qVar"s"),TP[LU,qVar"s"])))))) +; +val storeWord_def = Def + ("storeWord", + TP[Var("base",FTy 5),Var("rt",FTy 5),Var("offset",F16),bVar"cond"], + Close + (qVar"state", + Let(Var("v",F64), + Bop(Add,Mop(SE F64,Var("offset",F16)), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("base",FTy 5)), + qVar"state"))), + Let(TP[bVar"r",Var("s1",PTy(bTy,qTy))], + Let(Var("s",PTy(bTy,qTy)), + ITE(Mop(Not,EQ(EX(Var("v",F64),LN 1,LN 0,FTy 2),LW(0,2))), + Let(TP[Var("v0",CTy"CP0__renamed__"), + Var("s",PTy(bTy,qTy))], + Let(TP[Var("v",CTy"CP0__renamed__"),qVar"s3"], + TP[Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__",qTy))), + qVar"state")),qVar"state"], + TP[Var("v",CTy"CP0__renamed__"),LF,qVar"s3"]), + Let(Var("s",PTy(bTy,qTy)), + TP[Mop(Fst,Var("s",PTy(bTy,qTy))), + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy,PTy(uTy,qTy)), + Rupd + ("BadVAddr", + TP[Var("v0", + CTy"CP0__renamed__"), + Var("v",F64)])), + Mop(Snd,Var("s",PTy(bTy,qTy)))))], + TP[Mop(Fst,Var("s",PTy(bTy,qTy))), + Mop(Snd, + Apply + (Call + ("SignalException", + ATy(qTy,PTy(uTy,qTy)), + LC("AdES",CTy"ExceptionType")), + Mop(Snd,Var("s",PTy(bTy,qTy)))))])), + Let(TP[Var("v0",F1),Var("s",PTy(bTy,qTy))], + Let(TP[Var("v",F1),qVar"s3"], + TP[Mop(Fst, + Apply + (Const + ("BigEndianCPU", + ATy(qTy,PTy(F1,qTy))), + qVar"state")),qVar"state"], + TP[Var("v",F1),LF,qVar"s3"]), + Let(TP[Var("v1",F64),Var("s",PTy(bTy,qTy))], + Let(TP[Var("v",F64),qVar"s3"], + TP[Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)), + Mop(Snd,Var("s",PTy(bTy,qTy))))), + Mop(Snd,Var("s",PTy(bTy,qTy)))], + TP[Var("v",F64), + Mop(Fst,Var("s",PTy(bTy,qTy))), + qVar"s3"]), + Let(TP[bVar"v",Var("s",PTy(bTy,qTy))], + CS(Apply + (Call + ("StoreMemory", + ATy(qTy,PTy(bTy,qTy)), + TP[Const("WORD",FTy 3), + Const("WORD",FTy 3), + Bop(Lsl,Var("v1",F64), + Bop(Mul,LN 8, + Mop(Cast nTy, + Bop(BXor, + EX(Var("v", + F64), + LN 2, + LN 0, + FTy 3), + CC[Var("v0", + F1), + LW(0,2)])))), + Var("v",F64), + LC("DATA",CTy"IorD"), + LC("STORE",CTy"AccessType"), + bVar"cond"]), + Mop(Snd,Var("s",PTy(bTy,qTy)))), + [(TP[bVar"v",qVar"s3"], + TP[bVar"v", + Mop(Fst,Var("s",PTy(bTy,qTy))), + qVar"s3"])]), + TP[bVar"v", + Mop(Snd,Var("s",PTy(bTy,qTy)))])))), + TP[Mop(Fst,Var("s",PTy(bTy,qTy))),Var("s",PTy(bTy,qTy))]), + TP[bVar"r",Mop(Snd,Var("s1",PTy(bTy,qTy)))])))) +; +val storeDoubleword_def = Def + ("storeDoubleword", + TP[Var("base",FTy 5),Var("rt",FTy 5),Var("offset",F16),bVar"cond"], + Close + (qVar"state", + Let(Var("v",F64), + Bop(Add,Mop(SE F64,Var("offset",F16)), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("base",FTy 5)), + qVar"state"))), + Let(TP[bVar"r",Var("s1",PTy(bTy,qTy))], + Let(Var("s",PTy(bTy,qTy)), + ITE(Mop(Not,EQ(EX(Var("v",F64),LN 2,LN 0,FTy 3),LW(0,3))), + Let(TP[Var("v0",CTy"CP0__renamed__"), + Var("s",PTy(bTy,qTy))], + Let(TP[Var("v",CTy"CP0__renamed__"),qVar"s3"], + TP[Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__",qTy))), + qVar"state")),qVar"state"], + TP[Var("v",CTy"CP0__renamed__"),LF,qVar"s3"]), + Let(Var("s",PTy(bTy,qTy)), + TP[Mop(Fst,Var("s",PTy(bTy,qTy))), + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy,PTy(uTy,qTy)), + Rupd + ("BadVAddr", + TP[Var("v0", + CTy"CP0__renamed__"), + Var("v",F64)])), + Mop(Snd,Var("s",PTy(bTy,qTy)))))], + TP[Mop(Fst,Var("s",PTy(bTy,qTy))), + Mop(Snd, + Apply + (Call + ("SignalException", + ATy(qTy,PTy(uTy,qTy)), + LC("AdES",CTy"ExceptionType")), + Mop(Snd,Var("s",PTy(bTy,qTy)))))])), + Let(TP[Var("v0",F64),Var("s",PTy(bTy,qTy))], + Let(TP[Var("v",F64),qVar"s3"], + TP[Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"state")), + qVar"state"],TP[Var("v",F64),LF,qVar"s3"]), + Let(TP[bVar"v",Var("s",PTy(bTy,qTy))], + CS(Apply + (Call + ("StoreMemory", + ATy(qTy,PTy(bTy,qTy)), + TP[Const("DOUBLEWORD",FTy 3), + Const("DOUBLEWORD",FTy 3), + Var("v0",F64),Var("v",F64), + LC("DATA",CTy"IorD"), + LC("STORE",CTy"AccessType"), + bVar"cond"]), + Mop(Snd,Var("s",PTy(bTy,qTy)))), + [(TP[bVar"v",qVar"s3"], + TP[bVar"v", + Mop(Fst,Var("s",PTy(bTy,qTy))), + qVar"s3"])]), + TP[bVar"v",Mop(Snd,Var("s",PTy(bTy,qTy)))]))), + TP[Mop(Fst,Var("s",PTy(bTy,qTy))),Var("s",PTy(bTy,qTy))]), + TP[bVar"r",Mop(Snd,Var("s1",PTy(bTy,qTy)))])))) +; +val dfn'SW_def = Def + ("dfn'SW",TP[Var("base",FTy 5),Var("rt",FTy 5),Var("offset",F16)], + Close + (qVar"state", + Let(TP[bVar"v",qVar"s"], + Apply + (Call + ("storeWord",ATy(qTy,PTy(bTy,qTy)), + TP[Var("base",FTy 5),Var("rt",FTy 5),Var("offset",F16),LF]), + qVar"state"),TP[LU,qVar"s"]))) +; +val dfn'SD_def = Def + ("dfn'SD",TP[Var("base",FTy 5),Var("rt",FTy 5),Var("offset",F16)], + Close + (qVar"state", + Let(TP[bVar"v",qVar"s"], + Apply + (Call + ("storeDoubleword",ATy(qTy,PTy(bTy,qTy)), + TP[Var("base",FTy 5),Var("rt",FTy 5),Var("offset",F16),LF]), + qVar"state"),TP[LU,qVar"s"]))) +; +val dfn'SC_def = Def + ("dfn'SC",TP[Var("base",FTy 5),Var("rt",FTy 5),Var("offset",F16)], + Close + (qVar"state", + Let(TP[bVar"v",qVar"s"], + Apply + (Call + ("storeWord",ATy(qTy,PTy(bTy,qTy)), + TP[Var("base",FTy 5),Var("rt",FTy 5),Var("offset",F16),LT]), + qVar"state"), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[ITE(bVar"v",LW(1,64),LW(0,64)),Var("rt",FTy 5)]), + qVar"s")))) +; +val dfn'SCD_def = Def + ("dfn'SCD",TP[Var("base",FTy 5),Var("rt",FTy 5),Var("offset",F16)], + Close + (qVar"state", + Let(TP[bVar"v",qVar"s"], + Apply + (Call + ("storeDoubleword",ATy(qTy,PTy(bTy,qTy)), + TP[Var("base",FTy 5),Var("rt",FTy 5),Var("offset",F16),LT]), + qVar"state"), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[ITE(bVar"v",LW(1,64),LW(0,64)),Var("rt",FTy 5)]), + qVar"s")))) +; +val dfn'SWL_def = Def + ("dfn'SWL",TP[Var("base",FTy 5),Var("rt",FTy 5),Var("offset",F16)], + Close + (qVar"state", + Let(Var("v",F64), + Bop(Add,Mop(SE F64,Var("offset",F16)), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("base",FTy 5)), + qVar"state"))), + Let(Var("v0",FTy 2), + Bop(BXor,EX(Var("v",F64),LN 1,LN 0,FTy 2), + REP(Mop(Fst, + Apply + (Const("BigEndianCPU",ATy(qTy,PTy(F1,qTy))), + qVar"state")),LN 2,FTy 2)), + Let(TP[Var("v1",F64),qVar"s0"], + CS(Var("v0",FTy 2), + [(LW(0,2), + TP[Mop(Cast F64, + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"state")), + LN 31,LN 24,F8)),qVar"state"]), + (LW(1,2), + TP[Mop(Cast F64, + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"state")), + LN 31,LN 16,F16)),qVar"state"]), + (LW(2,2), + TP[Mop(Cast F64, + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"state")), + LN 31,LN 8,FTy 24)),qVar"state"]), + (LW(3,2), + TP[Mop(Cast F64, + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"state")), + LN 31,LN 0,F32)),qVar"state"])]), + Let(TP[bVar"v",qVar"s"], + Apply + (Call + ("StoreMemory",ATy(qTy,PTy(bTy,qTy)), + TP[Const("WORD",FTy 3), + Mop(Cast(FTy 3),Var("v0",FTy 2)), + ITE(EQ(Bop(BXor, + EX(Var("v",F64),LN 2,LN 2,F1), + Mop(Fst, + Apply + (Const + ("BigEndianCPU", + ATy(qTy,PTy(F1,qTy))), + qVar"state"))),LW(1,1)), + Bop(Lsl,Var("v1",F64),LN 32), + Var("v1",F64)), + ITE(Mop(Fst, + Apply + (Const + ("BigEndianMem", + ATy(qTy,PTy(bTy,qTy))), + qVar"s0")),Var("v",F64), + Bop(BAnd,Var("v",F64), + Mop(BNot,LW(3,64)))), + LC("DATA",CTy"IorD"), + LC("STORE",CTy"AccessType"),LF]),qVar"s0"), + TP[LU,qVar"s"])))))) +; +val dfn'SWR_def = Def + ("dfn'SWR",TP[Var("base",FTy 5),Var("rt",FTy 5),Var("offset",F16)], + Close + (qVar"state", + Let(Var("v",F64), + Bop(Add,Mop(SE F64,Var("offset",F16)), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("base",FTy 5)), + qVar"state"))), + Let(Var("v0",FTy 2), + Bop(BXor,EX(Var("v",F64),LN 1,LN 0,FTy 2), + REP(Mop(Fst, + Apply + (Const("BigEndianCPU",ATy(qTy,PTy(F1,qTy))), + qVar"state")),LN 2,FTy 2)), + Let(TP[Var("v1",F64),qVar"s"], + CS(TP[Bop(BXor,EX(Var("v",F64),LN 2,LN 2,F1), + Mop(Fst, + Apply + (Const + ("BigEndianCPU",ATy(qTy,PTy(F1,qTy))), + qVar"state"))),Var("v0",FTy 2)], + [(TP[LW(0,1),LW(0,2)], + TP[Mop(Cast F64, + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"state")), + LN 31,LN 0,F32)),qVar"state"]), + (TP[LW(0,1),LW(1,2)], + TP[Bop(Lsl, + Mop(Cast F64, + EX(Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)), + qVar"state")),LN 23,LN 0, + FTy 24)),LN 8),qVar"state"]), + (TP[LW(0,1),LW(2,2)], + TP[Bop(Lsl, + Mop(Cast F64, + EX(Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)), + qVar"state")),LN 15,LN 0,F16)), + LN 16),qVar"state"]), + (TP[LW(0,1),LW(3,2)], + TP[Bop(Lsl, + Mop(Cast F64, + EX(Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)), + qVar"state")),LN 7,LN 0,F8)), + LN 24),qVar"state"]), + (TP[LW(1,1),LW(0,2)], + TP[Bop(Lsl, + Mop(Cast F64, + EX(Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)), + qVar"state")),LN 31,LN 0,F32)), + LN 32),qVar"state"]), + (TP[LW(1,1),LW(1,2)], + TP[Bop(Lsl, + Mop(Cast F64, + EX(Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)), + qVar"state")),LN 23,LN 0, + FTy 24)),LN 40),qVar"state"]), + (TP[LW(1,1),LW(2,2)], + TP[Bop(Lsl, + Mop(Cast F64, + EX(Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)), + qVar"state")),LN 15,LN 0,F16)), + LN 48),qVar"state"]), + (TP[LW(1,1),LW(3,2)], + TP[Bop(Lsl, + Mop(Cast F64, + EX(Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)), + qVar"state")),LN 7,LN 0,F8)), + LN 56),qVar"state"])]), + Let(TP[bVar"v",qVar"s"], + Apply + (Call + ("StoreMemory",ATy(qTy,PTy(bTy,qTy)), + TP[Const("WORD",FTy 3), + Bop(Sub,Const("WORD",FTy 3), + Mop(Cast(FTy 3),Var("v0",FTy 2))), + Var("v1",F64), + ITE(Mop(Fst, + Apply + (Const + ("BigEndianMem", + ATy(qTy,PTy(bTy,qTy))), + qVar"s")), + Bop(BAnd,Var("v",F64), + Mop(BNot,LW(3,64))),Var("v",F64)), + LC("DATA",CTy"IorD"), + LC("STORE",CTy"AccessType"),LF]),qVar"s"), + TP[LU,qVar"s"])))))) +; +val dfn'SDL_def = Def + ("dfn'SDL",TP[Var("base",FTy 5),Var("rt",FTy 5),Var("offset",F16)], + Close + (qVar"state", + Let(Var("v",F64), + Bop(Add,Mop(SE F64,Var("offset",F16)), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("base",FTy 5)), + qVar"state"))), + Let(Var("v0",FTy 3), + Bop(BXor,EX(Var("v",F64),LN 2,LN 0,FTy 3), + REP(Mop(Fst, + Apply + (Const("BigEndianCPU",ATy(qTy,PTy(F1,qTy))), + qVar"state")),LN 3,FTy 3)), + Let(TP[Var("v1",F64),qVar"s"], + CS(Var("v0",FTy 3), + [(LW(0,3), + TP[Mop(Cast F64, + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"state")), + LN 63,LN 56,F8)),qVar"state"]), + (LW(1,3), + TP[Mop(Cast F64, + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"state")), + LN 63,LN 48,F16)),qVar"state"]), + (LW(2,3), + TP[Mop(Cast F64, + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"state")), + LN 63,LN 40,FTy 24)),qVar"state"]), + (LW(3,3), + TP[Mop(Cast F64, + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"state")), + LN 63,LN 32,F32)),qVar"state"]), + (LW(4,3), + TP[Mop(Cast F64, + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"state")), + LN 63,LN 24,FTy 40)),qVar"state"]), + (LW(5,3), + TP[Mop(Cast F64, + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"state")), + LN 63,LN 16,FTy 48)),qVar"state"]), + (LW(6,3), + TP[Mop(Cast F64, + EX(Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"state")), + LN 63,LN 8,FTy 56)),qVar"state"]), + (LW(7,3), + TP[Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"state")), + qVar"state"])]), + Let(TP[bVar"v",qVar"s"], + Apply + (Call + ("StoreMemory",ATy(qTy,PTy(bTy,qTy)), + TP[Const("DOUBLEWORD",FTy 3),Var("v0",FTy 3), + Var("v1",F64), + ITE(Mop(Fst, + Apply + (Const + ("BigEndianMem", + ATy(qTy,PTy(bTy,qTy))), + qVar"s")),Var("v",F64), + Bop(BAnd,Var("v",F64), + Mop(BNot,LW(7,64)))), + LC("DATA",CTy"IorD"), + LC("STORE",CTy"AccessType"),LF]),qVar"s"), + TP[LU,qVar"s"])))))) +; +val dfn'SDR_def = Def + ("dfn'SDR",TP[Var("base",FTy 5),Var("rt",FTy 5),Var("offset",F16)], + Close + (qVar"state", + Let(Var("v",F64), + Bop(Add,Mop(SE F64,Var("offset",F16)), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("base",FTy 5)), + qVar"state"))), + Let(Var("v0",FTy 3), + Bop(BXor,EX(Var("v",F64),LN 2,LN 0,FTy 3), + REP(Mop(Fst, + Apply + (Const("BigEndianCPU",ATy(qTy,PTy(F1,qTy))), + qVar"state")),LN 3,FTy 3)), + Let(TP[Var("v1",F64),qVar"s"], + CS(Var("v0",FTy 3), + [(LW(0,3), + TP[Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)),qVar"state")), + qVar"state"]), + (LW(1,3), + TP[Bop(Lsl, + Mop(Cast F64, + EX(Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)), + qVar"state")),LN 55,LN 0, + FTy 56)),LN 8),qVar"state"]), + (LW(2,3), + TP[Bop(Lsl, + Mop(Cast F64, + EX(Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)), + qVar"state")),LN 47,LN 0, + FTy 48)),LN 16),qVar"state"]), + (LW(3,3), + TP[Bop(Lsl, + Mop(Cast F64, + EX(Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)), + qVar"state")),LN 39,LN 0, + FTy 40)),LN 24),qVar"state"]), + (LW(4,3), + TP[Bop(Lsl, + Mop(Cast F64, + EX(Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)), + qVar"state")),LN 31,LN 0,F32)), + LN 32),qVar"state"]), + (LW(5,3), + TP[Bop(Lsl, + Mop(Cast F64, + EX(Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)), + qVar"state")),LN 23,LN 0, + FTy 24)),LN 40),qVar"state"]), + (LW(6,3), + TP[Bop(Lsl, + Mop(Cast F64, + EX(Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)), + qVar"state")),LN 15,LN 0,F16)), + LN 48),qVar"state"]), + (LW(7,3), + TP[Bop(Lsl, + Mop(Cast F64, + EX(Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)), + qVar"state")),LN 7,LN 0,F8)), + LN 56),qVar"state"])]), + Let(TP[bVar"v",qVar"s"], + Apply + (Call + ("StoreMemory",ATy(qTy,PTy(bTy,qTy)), + TP[Const("DOUBLEWORD",FTy 3), + Bop(Sub,Const("DOUBLEWORD",FTy 3), + Var("v0",FTy 3)),Var("v1",F64), + ITE(Mop(Fst, + Apply + (Const + ("BigEndianMem", + ATy(qTy,PTy(bTy,qTy))), + qVar"s")), + Bop(BAnd,Var("v",F64), + Mop(BNot,LW(7,64))),Var("v",F64)), + LC("DATA",CTy"IorD"), + LC("STORE",CTy"AccessType"),LF]),qVar"s"), + TP[LU,qVar"s"])))))) +; +val dfn'SYNC_def = Def ("dfn'SYNC",Var("stype",FTy 5),LU) +; +val dfn'BREAK_def = Def + ("dfn'BREAK",qVar"state", + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("Bp",CTy"ExceptionType")),qVar"state")) +; +val dfn'SYSCALL_def = Def + ("dfn'SYSCALL",qVar"state", + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("Sys",CTy"ExceptionType")),qVar"state")) +; +val dfn'MTC0_def = Def + ("dfn'MTC0",TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("sel",FTy 3)], + Close + (qVar"state", + ITE(Bop(Or, + Dest + ("CU0",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state")))), + Mop(Fst, + Apply + (Const("KernelMode",ATy(qTy,PTy(bTy,qTy))),qVar"state"))), + Apply + (Call + ("write'CPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state")),LN 0,Var("rd",FTy 5), + Var("sel",FTy 3)]),qVar"state"), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("CpU",CTy"ExceptionType")),qVar"state")))) +; +val dfn'DMTC0_def = Def + ("dfn'DMTC0",TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("sel",FTy 3)], + Close + (qVar"state", + ITE(Bop(Or, + Dest + ("CU0",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state")))), + Mop(Fst, + Apply + (Const("KernelMode",ATy(qTy,PTy(bTy,qTy))),qVar"state"))), + Apply + (Call + ("write'CPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Fst, + Apply + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state")),LN 0,Var("rd",FTy 5), + Var("sel",FTy 3)]),qVar"state"), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("CpU",CTy"ExceptionType")),qVar"state")))) +; +val dfn'MFC0_def = Def + ("dfn'MFC0",TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("sel",FTy 3)], + Close + (qVar"state", + ITE(Bop(Or, + Dest + ("CU0",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state")))), + Mop(Fst, + Apply + (Const("KernelMode",ATy(qTy,PTy(bTy,qTy))),qVar"state"))), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(SE F64, + EX(Mop(Fst, + Apply + (Call + ("CPR",ATy(qTy,PTy(F64,qTy)), + TP[LN 0,Var("rd",FTy 5), + Var("sel",FTy 3)]),qVar"state")), + LN 31,LN 0,F32)),Var("rt",FTy 5)]),qVar"state"), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("CpU",CTy"ExceptionType")),qVar"state")))) +; +val dfn'DMFC0_def = Def + ("dfn'DMFC0",TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("sel",FTy 3)], + Close + (qVar"state", + ITE(Bop(Or, + Dest + ("CU0",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state")))), + Mop(Fst, + Apply + (Const("KernelMode",ATy(qTy,PTy(bTy,qTy))),qVar"state"))), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Fst, + Apply + (Call + ("CPR",ATy(qTy,PTy(F64,qTy)), + TP[LN 0,Var("rd",FTy 5),Var("sel",FTy 3)]), + qVar"state")),Var("rt",FTy 5)]),qVar"state"), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("CpU",CTy"ExceptionType")),qVar"state")))) +; +val dfn'J_def = Def + ("dfn'J",Var("instr_index",FTy 26), + Close + (qVar"state", + Apply + (Call + ("write'BranchTo",ATy(qTy,PTy(uTy,qTy)), + Mop(Some, + CC[EX(Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))),qVar"state")), + LN 63,LN 28,FTy 36),Var("instr_index",FTy 26), + LW(0,2)])),qVar"state"))) +; +val dfn'JAL_def = Def + ("dfn'JAL",Var("instr_index",FTy 26), + Close + (qVar"state", + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))), + qVar"state")),LW(8,64)),LW(31,5)]), + qVar"state")), + Apply + (Call + ("write'BranchTo",ATy(qTy,PTy(uTy,qTy)), + Mop(Some, + CC[EX(Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))),qVar"s")), + LN 63,LN 28,FTy 36),Var("instr_index",FTy 26), + LW(0,2)])),qVar"s")))) +; +val dfn'JR_def = Def + ("dfn'JR",Var("rs",FTy 5), + Close + (qVar"state", + Apply + (Call + ("write'BranchTo",ATy(qTy,PTy(uTy,qTy)), + Mop(Some, + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")))),qVar"state"))) +; +val dfn'BEQ_def = Def + ("dfn'BEQ",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("offset",F16)], + Close + (qVar"state", + ITE(EQ(Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state"))), + Apply + (Call + ("write'BranchTo",ATy(qTy,PTy(uTy,qTy)), + Mop(Some, + Bop(Add, + Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))), + qVar"state")),LW(4,64)), + Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))), + qVar"state"), + Apply(Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))),qVar"state")))) +; +val dfn'BNE_def = Def + ("dfn'BNE",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("offset",F16)], + Close + (qVar"state", + ITE(Mop(Not, + EQ(Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state")))), + Apply + (Call + ("write'BranchTo",ATy(qTy,PTy(uTy,qTy)), + Mop(Some, + Bop(Add, + Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))), + qVar"state")),LW(4,64)), + Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))), + qVar"state"), + Apply(Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))),qVar"state")))) +; +val dfn'BLEZ_def = Def + ("dfn'BLEZ",TP[Var("rs",FTy 5),Var("offset",F16)], + Close + (qVar"state", + ITE(Bop(Le, + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")),LW(0,64)), + Apply + (Call + ("write'BranchTo",ATy(qTy,PTy(uTy,qTy)), + Mop(Some, + Bop(Add, + Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))), + qVar"state")),LW(4,64)), + Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))), + qVar"state"), + Apply(Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))),qVar"state")))) +; +val dfn'BGTZ_def = Def + ("dfn'BGTZ",TP[Var("rs",FTy 5),Var("offset",F16)], + Close + (qVar"state", + ITE(Bop(Gt, + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")),LW(0,64)), + Apply + (Call + ("write'BranchTo",ATy(qTy,PTy(uTy,qTy)), + Mop(Some, + Bop(Add, + Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))), + qVar"state")),LW(4,64)), + Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))), + qVar"state"), + Apply(Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))),qVar"state")))) +; +val dfn'BLTZ_def = Def + ("dfn'BLTZ",TP[Var("rs",FTy 5),Var("offset",F16)], + Close + (qVar"state", + ITE(Bop(Lt, + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")),LW(0,64)), + Apply + (Call + ("write'BranchTo",ATy(qTy,PTy(uTy,qTy)), + Mop(Some, + Bop(Add, + Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))), + qVar"state")),LW(4,64)), + Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))), + qVar"state"), + Apply(Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))),qVar"state")))) +; +val dfn'BGEZ_def = Def + ("dfn'BGEZ",TP[Var("rs",FTy 5),Var("offset",F16)], + Close + (qVar"state", + ITE(Bop(Ge, + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")),LW(0,64)), + Apply + (Call + ("write'BranchTo",ATy(qTy,PTy(uTy,qTy)), + Mop(Some, + Bop(Add, + Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))), + qVar"state")),LW(4,64)), + Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))), + qVar"state"), + Apply(Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))),qVar"state")))) +; +val dfn'BLTZAL_def = Def + ("dfn'BLTZAL",TP[Var("rs",FTy 5),Var("offset",F16)], + Close + (qVar"state", + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))), + qVar"state")),LW(8,64)),LW(31,5)]), + qVar"state")), + ITE(Bop(Lt, + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")),LW(0,64)), + Apply + (Call + ("write'BranchTo",ATy(qTy,PTy(uTy,qTy)), + Mop(Some, + Bop(Add, + Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))), + qVar"s")),LW(4,64)), + Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))), + qVar"s"), + Apply(Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))),qVar"s"))))) +; +val dfn'BGEZAL_def = Def + ("dfn'BGEZAL",TP[Var("rs",FTy 5),Var("offset",F16)], + Close + (qVar"state", + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))), + qVar"state")),LW(8,64)),LW(31,5)]), + qVar"state")), + ITE(Bop(Ge, + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")),LW(0,64)), + Apply + (Call + ("write'BranchTo",ATy(qTy,PTy(uTy,qTy)), + Mop(Some, + Bop(Add, + Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))), + qVar"s")),LW(4,64)), + Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))), + qVar"s"), + Apply(Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))),qVar"s"))))) +; +val dfn'BEQL_def = Def + ("dfn'BEQL",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("offset",F16)], + Close + (qVar"state", + ITE(EQ(Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state"))), + Apply + (Call + ("write'BranchTo",ATy(qTy,PTy(uTy,qTy)), + Mop(Some, + Bop(Add, + Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))), + qVar"state")),LW(4,64)), + Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))), + qVar"state"), + Let(qVar"s", + Mop(Snd, + Apply + (Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))), + qVar"state")), + Apply + (Call + ("write'PC",ATy(qTy,PTy(uTy,qTy)), + Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))),qVar"s")), + LW(4,64))),qVar"s"))))) +; +val dfn'BNEL_def = Def + ("dfn'BNEL",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("offset",F16)], + Close + (qVar"state", + ITE(Mop(Not, + EQ(Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state")))), + Apply + (Call + ("write'BranchTo",ATy(qTy,PTy(uTy,qTy)), + Mop(Some, + Bop(Add, + Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))), + qVar"state")),LW(4,64)), + Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))), + qVar"state"), + Let(qVar"s", + Mop(Snd, + Apply + (Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))), + qVar"state")), + Apply + (Call + ("write'PC",ATy(qTy,PTy(uTy,qTy)), + Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))),qVar"s")), + LW(4,64))),qVar"s"))))) +; +val dfn'BLEZL_def = Def + ("dfn'BLEZL",TP[Var("rs",FTy 5),Var("offset",F16)], + Close + (qVar"state", + ITE(Bop(Le, + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")),LW(0,64)), + Apply + (Call + ("write'BranchTo",ATy(qTy,PTy(uTy,qTy)), + Mop(Some, + Bop(Add, + Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))), + qVar"state")),LW(4,64)), + Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))), + qVar"state"), + Let(qVar"s", + Mop(Snd, + Apply + (Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))), + qVar"state")), + Apply + (Call + ("write'PC",ATy(qTy,PTy(uTy,qTy)), + Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))),qVar"s")), + LW(4,64))),qVar"s"))))) +; +val dfn'BGTZL_def = Def + ("dfn'BGTZL",TP[Var("rs",FTy 5),Var("offset",F16)], + Close + (qVar"state", + ITE(Bop(Gt, + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")),LW(0,64)), + Apply + (Call + ("write'BranchTo",ATy(qTy,PTy(uTy,qTy)), + Mop(Some, + Bop(Add, + Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))), + qVar"state")),LW(4,64)), + Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))), + qVar"state"), + Let(qVar"s", + Mop(Snd, + Apply + (Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))), + qVar"state")), + Apply + (Call + ("write'PC",ATy(qTy,PTy(uTy,qTy)), + Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))),qVar"s")), + LW(4,64))),qVar"s"))))) +; +val dfn'BLTZL_def = Def + ("dfn'BLTZL",TP[Var("rs",FTy 5),Var("offset",F16)], + Close + (qVar"state", + ITE(Bop(Lt, + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")),LW(0,64)), + Apply + (Call + ("write'BranchTo",ATy(qTy,PTy(uTy,qTy)), + Mop(Some, + Bop(Add, + Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))), + qVar"state")),LW(4,64)), + Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))), + qVar"state"), + Let(qVar"s", + Mop(Snd, + Apply + (Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))), + qVar"state")), + Apply + (Call + ("write'PC",ATy(qTy,PTy(uTy,qTy)), + Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))),qVar"s")), + LW(4,64))),qVar"s"))))) +; +val dfn'BGEZL_def = Def + ("dfn'BGEZL",TP[Var("rs",FTy 5),Var("offset",F16)], + Close + (qVar"state", + ITE(Bop(Ge, + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")),LW(0,64)), + Apply + (Call + ("write'BranchTo",ATy(qTy,PTy(uTy,qTy)), + Mop(Some, + Bop(Add, + Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))), + qVar"state")),LW(4,64)), + Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))), + qVar"state"), + Let(qVar"s", + Mop(Snd, + Apply + (Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))), + qVar"state")), + Apply + (Call + ("write'PC",ATy(qTy,PTy(uTy,qTy)), + Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))),qVar"s")), + LW(4,64))),qVar"s"))))) +; +val dfn'BLTZALL_def = Def + ("dfn'BLTZALL",TP[Var("rs",FTy 5),Var("offset",F16)], + Close + (qVar"state", + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))), + qVar"state")),LW(8,64)),LW(31,5)]), + qVar"state")), + ITE(Bop(Lt, + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")),LW(0,64)), + Apply + (Call + ("write'BranchTo",ATy(qTy,PTy(uTy,qTy)), + Mop(Some, + Bop(Add, + Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))), + qVar"s")),LW(4,64)), + Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))), + qVar"s"), + Let(qVar"s", + Mop(Snd, + Apply + (Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))), + qVar"s")), + Apply + (Call + ("write'PC",ATy(qTy,PTy(uTy,qTy)), + Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))), + qVar"s")),LW(4,64))),qVar"s")))))) +; +val dfn'BGEZALL_def = Def + ("dfn'BGEZALL",TP[Var("rs",FTy 5),Var("offset",F16)], + Close + (qVar"state", + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))), + qVar"state")),LW(8,64)),LW(31,5)]), + qVar"state")), + ITE(Bop(Ge, + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")),LW(0,64)), + Apply + (Call + ("write'BranchTo",ATy(qTy,PTy(uTy,qTy)), + Mop(Some, + Bop(Add, + Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))), + qVar"s")),LW(4,64)), + Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))), + qVar"s"), + Let(qVar"s", + Mop(Snd, + Apply + (Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))), + qVar"s")), + Apply + (Call + ("write'PC",ATy(qTy,PTy(uTy,qTy)), + Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))), + qVar"s")),LW(4,64))),qVar"s")))))) +; +val dfn'WAIT_def = Def0 ("dfn'WAIT",LU) +; +val dfn'ReservedInstruction_def = Def + ("dfn'ReservedInstruction",qVar"state", + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("ResI",CTy"ExceptionType")),qVar"state")) +; +val dfn'Unpredictable_def = Def + ("dfn'Unpredictable",qVar"state", + Apply + (Call + ("raise'exception",ATy(qTy,PTy(uTy,qTy)), + Call + ("UNPREDICTABLE",CTy"exception",LS"Unpredictable instruction")), + qVar"state")) +; +val Run_def = Def + ("Run",Var("v0",CTy"instruction"), + Close + (qVar"state", + CS(Var("v0",CTy"instruction"), + [(Const("BREAK",CTy"instruction"), + Apply(Const("dfn'BREAK",ATy(qTy,PTy(uTy,qTy))),qVar"state")), + (Const("ERET",CTy"instruction"), + Apply(Const("dfn'ERET",ATy(qTy,PTy(uTy,qTy))),qVar"state")), + (Const("ReservedInstruction",CTy"instruction"), + Apply + (Const("dfn'ReservedInstruction",ATy(qTy,PTy(uTy,qTy))), + qVar"state")), + (Const("SYSCALL",CTy"instruction"), + Apply(Const("dfn'SYSCALL",ATy(qTy,PTy(uTy,qTy))),qVar"state")), + (Const("TLBP",CTy"instruction"), + Apply(Const("dfn'TLBP",ATy(qTy,PTy(uTy,qTy))),qVar"state")), + (Const("TLBR",CTy"instruction"), + Apply(Const("dfn'TLBR",ATy(qTy,PTy(uTy,qTy))),qVar"state")), + (Const("TLBWI",CTy"instruction"), + Apply(Const("dfn'TLBWI",ATy(qTy,PTy(uTy,qTy))),qVar"state")), + (Const("TLBWR",CTy"instruction"), + Apply(Const("dfn'TLBWR",ATy(qTy,PTy(uTy,qTy))),qVar"state")), + (Const("Unpredictable",CTy"instruction"), + Apply + (Const("dfn'Unpredictable",ATy(qTy,PTy(uTy,qTy))),qVar"state")), + (Const("WAIT",CTy"instruction"), + TP[Const("dfn'WAIT",uTy),qVar"state"]), + (Call + ("CACHE",CTy"instruction", + Var("v173",PTy(FTy 5,PTy(FTy 5,F16)))), + Apply + (Call + ("dfn'CACHE",ATy(qTy,PTy(uTy,qTy)), + Var("v173",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + (Call("RDHWR",CTy"instruction",Var("v174",PTy(FTy 5,FTy 5))), + Apply + (Call + ("dfn'RDHWR",ATy(qTy,PTy(uTy,qTy)), + Var("v174",PTy(FTy 5,FTy 5))),qVar"state")), + (Call("SYNC",CTy"instruction",Var("v175",FTy 5)), + TP[Call("dfn'SYNC",uTy,Var("v175",FTy 5)),qVar"state"]), + (Call("ArithI",CTy"instruction",Var("v1",CTy"ArithI")), + CS(Var("v1",CTy"ArithI"), + [(Call + ("ADDI",CTy"ArithI",Var("v2",PTy(FTy 5,PTy(FTy 5,F16)))), + Apply + (Call + ("dfn'ADDI",ATy(qTy,PTy(uTy,qTy)), + Var("v2",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + (Call + ("ADDIU",CTy"ArithI",Var("v3",PTy(FTy 5,PTy(FTy 5,F16)))), + Apply + (Call + ("dfn'ADDIU",ATy(qTy,PTy(uTy,qTy)), + Var("v3",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + (Call + ("ANDI",CTy"ArithI",Var("v4",PTy(FTy 5,PTy(FTy 5,F16)))), + Apply + (Call + ("dfn'ANDI",ATy(qTy,PTy(uTy,qTy)), + Var("v4",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + (Call + ("DADDI",CTy"ArithI",Var("v5",PTy(FTy 5,PTy(FTy 5,F16)))), + Apply + (Call + ("dfn'DADDI",ATy(qTy,PTy(uTy,qTy)), + Var("v5",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + (Call + ("DADDIU",CTy"ArithI", + Var("v6",PTy(FTy 5,PTy(FTy 5,F16)))), + Apply + (Call + ("dfn'DADDIU",ATy(qTy,PTy(uTy,qTy)), + Var("v6",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + (Call("LUI",CTy"ArithI",Var("v7",PTy(FTy 5,F16))), + Apply + (Call + ("dfn'LUI",ATy(qTy,PTy(uTy,qTy)), + Var("v7",PTy(FTy 5,F16))),qVar"state")), + (Call + ("ORI",CTy"ArithI",Var("v8",PTy(FTy 5,PTy(FTy 5,F16)))), + Apply + (Call + ("dfn'ORI",ATy(qTy,PTy(uTy,qTy)), + Var("v8",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + (Call + ("SLTI",CTy"ArithI",Var("v9",PTy(FTy 5,PTy(FTy 5,F16)))), + Apply + (Call + ("dfn'SLTI",ATy(qTy,PTy(uTy,qTy)), + Var("v9",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + (Call + ("SLTIU",CTy"ArithI", + Var("v10",PTy(FTy 5,PTy(FTy 5,F16)))), + Apply + (Call + ("dfn'SLTIU",ATy(qTy,PTy(uTy,qTy)), + Var("v10",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + (Call + ("XORI",CTy"ArithI",Var("v11",PTy(FTy 5,PTy(FTy 5,F16)))), + Apply + (Call + ("dfn'XORI",ATy(qTy,PTy(uTy,qTy)), + Var("v11",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state"))])), + (Call("ArithR",CTy"instruction",Var("v12",CTy"ArithR")), + CS(Var("v12",CTy"ArithR"), + [(Call + ("ADD",CTy"ArithR", + Var("v13",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Apply + (Call + ("dfn'ADD",ATy(qTy,PTy(uTy,qTy)), + Var("v13",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + (Call + ("ADDU",CTy"ArithR", + Var("v14",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Apply + (Call + ("dfn'ADDU",ATy(qTy,PTy(uTy,qTy)), + Var("v14",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + (Call + ("AND",CTy"ArithR", + Var("v15",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Apply + (Call + ("dfn'AND",ATy(qTy,PTy(uTy,qTy)), + Var("v15",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + (Call + ("DADD",CTy"ArithR", + Var("v16",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Apply + (Call + ("dfn'DADD",ATy(qTy,PTy(uTy,qTy)), + Var("v16",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + (Call + ("DADDU",CTy"ArithR", + Var("v17",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Apply + (Call + ("dfn'DADDU",ATy(qTy,PTy(uTy,qTy)), + Var("v17",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + (Call + ("DSUB",CTy"ArithR", + Var("v18",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Apply + (Call + ("dfn'DSUB",ATy(qTy,PTy(uTy,qTy)), + Var("v18",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + (Call + ("DSUBU",CTy"ArithR", + Var("v19",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Apply + (Call + ("dfn'DSUBU",ATy(qTy,PTy(uTy,qTy)), + Var("v19",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + (Call + ("MOVN",CTy"ArithR", + Var("v20",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Apply + (Call + ("dfn'MOVN",ATy(qTy,PTy(uTy,qTy)), + Var("v20",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + (Call + ("MOVZ",CTy"ArithR", + Var("v21",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Apply + (Call + ("dfn'MOVZ",ATy(qTy,PTy(uTy,qTy)), + Var("v21",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + (Call + ("NOR",CTy"ArithR", + Var("v22",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Apply + (Call + ("dfn'NOR",ATy(qTy,PTy(uTy,qTy)), + Var("v22",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + (Call + ("OR",CTy"ArithR",Var("v23",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Apply + (Call + ("dfn'OR",ATy(qTy,PTy(uTy,qTy)), + Var("v23",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + (Call + ("SLT",CTy"ArithR", + Var("v24",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Apply + (Call + ("dfn'SLT",ATy(qTy,PTy(uTy,qTy)), + Var("v24",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + (Call + ("SLTU",CTy"ArithR", + Var("v25",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Apply + (Call + ("dfn'SLTU",ATy(qTy,PTy(uTy,qTy)), + Var("v25",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + (Call + ("SUB",CTy"ArithR", + Var("v26",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Apply + (Call + ("dfn'SUB",ATy(qTy,PTy(uTy,qTy)), + Var("v26",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + (Call + ("SUBU",CTy"ArithR", + Var("v27",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Apply + (Call + ("dfn'SUBU",ATy(qTy,PTy(uTy,qTy)), + Var("v27",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + (Call + ("XOR",CTy"ArithR", + Var("v28",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Apply + (Call + ("dfn'XOR",ATy(qTy,PTy(uTy,qTy)), + Var("v28",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state"))])), + (Call("Branch",CTy"instruction",Var("v29",CTy"Branch")), + CS(Var("v29",CTy"Branch"), + [(Call + ("BEQ",CTy"Branch",Var("v30",PTy(FTy 5,PTy(FTy 5,F16)))), + Apply + (Call + ("dfn'BEQ",ATy(qTy,PTy(uTy,qTy)), + Var("v30",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + (Call + ("BEQL",CTy"Branch",Var("v31",PTy(FTy 5,PTy(FTy 5,F16)))), + Apply + (Call + ("dfn'BEQL",ATy(qTy,PTy(uTy,qTy)), + Var("v31",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + (Call("BGEZ",CTy"Branch",Var("v32",PTy(FTy 5,F16))), + Apply + (Call + ("dfn'BGEZ",ATy(qTy,PTy(uTy,qTy)), + Var("v32",PTy(FTy 5,F16))),qVar"state")), + (Call("BGEZAL",CTy"Branch",Var("v33",PTy(FTy 5,F16))), + Apply + (Call + ("dfn'BGEZAL",ATy(qTy,PTy(uTy,qTy)), + Var("v33",PTy(FTy 5,F16))),qVar"state")), + (Call("BGEZALL",CTy"Branch",Var("v34",PTy(FTy 5,F16))), + Apply + (Call + ("dfn'BGEZALL",ATy(qTy,PTy(uTy,qTy)), + Var("v34",PTy(FTy 5,F16))),qVar"state")), + (Call("BGEZL",CTy"Branch",Var("v35",PTy(FTy 5,F16))), + Apply + (Call + ("dfn'BGEZL",ATy(qTy,PTy(uTy,qTy)), + Var("v35",PTy(FTy 5,F16))),qVar"state")), + (Call("BGTZ",CTy"Branch",Var("v36",PTy(FTy 5,F16))), + Apply + (Call + ("dfn'BGTZ",ATy(qTy,PTy(uTy,qTy)), + Var("v36",PTy(FTy 5,F16))),qVar"state")), + (Call("BGTZL",CTy"Branch",Var("v37",PTy(FTy 5,F16))), + Apply + (Call + ("dfn'BGTZL",ATy(qTy,PTy(uTy,qTy)), + Var("v37",PTy(FTy 5,F16))),qVar"state")), + (Call("BLEZ",CTy"Branch",Var("v38",PTy(FTy 5,F16))), + Apply + (Call + ("dfn'BLEZ",ATy(qTy,PTy(uTy,qTy)), + Var("v38",PTy(FTy 5,F16))),qVar"state")), + (Call("BLEZL",CTy"Branch",Var("v39",PTy(FTy 5,F16))), + Apply + (Call + ("dfn'BLEZL",ATy(qTy,PTy(uTy,qTy)), + Var("v39",PTy(FTy 5,F16))),qVar"state")), + (Call("BLTZ",CTy"Branch",Var("v40",PTy(FTy 5,F16))), + Apply + (Call + ("dfn'BLTZ",ATy(qTy,PTy(uTy,qTy)), + Var("v40",PTy(FTy 5,F16))),qVar"state")), + (Call("BLTZAL",CTy"Branch",Var("v41",PTy(FTy 5,F16))), + Apply + (Call + ("dfn'BLTZAL",ATy(qTy,PTy(uTy,qTy)), + Var("v41",PTy(FTy 5,F16))),qVar"state")), + (Call("BLTZALL",CTy"Branch",Var("v42",PTy(FTy 5,F16))), + Apply + (Call + ("dfn'BLTZALL",ATy(qTy,PTy(uTy,qTy)), + Var("v42",PTy(FTy 5,F16))),qVar"state")), + (Call("BLTZL",CTy"Branch",Var("v43",PTy(FTy 5,F16))), + Apply + (Call + ("dfn'BLTZL",ATy(qTy,PTy(uTy,qTy)), + Var("v43",PTy(FTy 5,F16))),qVar"state")), + (Call + ("BNE",CTy"Branch",Var("v44",PTy(FTy 5,PTy(FTy 5,F16)))), + Apply + (Call + ("dfn'BNE",ATy(qTy,PTy(uTy,qTy)), + Var("v44",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + (Call + ("BNEL",CTy"Branch",Var("v45",PTy(FTy 5,PTy(FTy 5,F16)))), + Apply + (Call + ("dfn'BNEL",ATy(qTy,PTy(uTy,qTy)), + Var("v45",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + (Call("J",CTy"Branch",Var("v46",FTy 26)), + Apply + (Call("dfn'J",ATy(qTy,PTy(uTy,qTy)),Var("v46",FTy 26)), + qVar"state")), + (Call("JAL",CTy"Branch",Var("v47",FTy 26)), + Apply + (Call("dfn'JAL",ATy(qTy,PTy(uTy,qTy)),Var("v47",FTy 26)), + qVar"state")), + (Call("JALR",CTy"Branch",Var("v48",PTy(FTy 5,FTy 5))), + Apply + (Call + ("dfn'JALR",ATy(qTy,PTy(uTy,qTy)), + Var("v48",PTy(FTy 5,FTy 5))),qVar"state")), + (Call("JR",CTy"Branch",Var("v49",FTy 5)), + Apply + (Call("dfn'JR",ATy(qTy,PTy(uTy,qTy)),Var("v49",FTy 5)), + qVar"state"))])), + (Call("COP2",CTy"instruction",Var("v50",CTy"COP2")), + CS(Var("v50",CTy"COP2"), + [(Call("CHERICOP2",CTy"COP2",Var("v51",CTy"CHERICOP2")), + CS(Var("v51",CTy"CHERICOP2"), + [(Const("CReturn",CTy"CHERICOP2"), + Apply + (Const("dfn'CReturn",ATy(qTy,PTy(uTy,qTy))), + qVar"state")), + (Const("DumpCapReg",CTy"CHERICOP2"), + Apply + (Const("dfn'DumpCapReg",ATy(qTy,PTy(uTy,qTy))), + qVar"state")), + (Const("UnknownCapInstruction",CTy"CHERICOP2"), + Apply + (Const + ("dfn'UnknownCapInstruction", + ATy(qTy,PTy(uTy,qTy))),qVar"state")), + (Call("CBTS",CTy"CHERICOP2",Var("v74",PTy(FTy 5,F16))), + Apply + (Call + ("dfn'CBTS",ATy(qTy,PTy(uTy,qTy)), + Var("v74",PTy(FTy 5,F16))),qVar"state")), + (Call("CBTU",CTy"CHERICOP2",Var("v75",PTy(FTy 5,F16))), + Apply + (Call + ("dfn'CBTU",ATy(qTy,PTy(uTy,qTy)), + Var("v75",PTy(FTy 5,F16))),qVar"state")), + (Call + ("CCall",CTy"CHERICOP2",Var("v76",PTy(FTy 5,FTy 5))), + Apply + (Call + ("dfn'CCall",ATy(qTy,PTy(uTy,qTy)), + Var("v76",PTy(FTy 5,FTy 5))),qVar"state")), + (Call + ("CJALR",CTy"CHERICOP2",Var("v77",PTy(FTy 5,FTy 5))), + Apply + (Call + ("dfn'CJALR",ATy(qTy,PTy(uTy,qTy)), + Var("v77",PTy(FTy 5,FTy 5))),qVar"state")), + (Call("CJR",CTy"CHERICOP2",Var("v78",FTy 5)), + Apply + (Call + ("dfn'CJR",ATy(qTy,PTy(uTy,qTy)), + Var("v78",FTy 5)),qVar"state")), + (Call + ("CPtrCmp",CTy"CHERICOP2", + Var("v79",PTy(FTy 5,PTy(FTy 5,PTy(FTy 5,FTy 3))))), + Apply + (Call + ("dfn'CPtrCmp",ATy(qTy,PTy(uTy,qTy)), + Var("v79", + PTy(FTy 5,PTy(FTy 5,PTy(FTy 5,FTy 3))))), + qVar"state")), + (Call + ("CSeal",CTy"CHERICOP2", + Var("v80",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Apply + (Call + ("dfn'CSeal",ATy(qTy,PTy(uTy,qTy)), + Var("v80",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + qVar"state")), + (Call + ("CUnseal",CTy"CHERICOP2", + Var("v81",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Apply + (Call + ("dfn'CUnseal",ATy(qTy,PTy(uTy,qTy)), + Var("v81",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + qVar"state")), + (Call("CCheck",CTy"CHERICOP2",Var("v52",CTy"CCheck")), + CS(Var("v52",CTy"CCheck"), + [(Call + ("CCheckPerm",CTy"CCheck", + Var("v53",PTy(FTy 5,FTy 5))), + Apply + (Call + ("dfn'CCheckPerm",ATy(qTy,PTy(uTy,qTy)), + Var("v53",PTy(FTy 5,FTy 5))),qVar"state")), + (Call + ("CCheckType",CTy"CCheck", + Var("v54",PTy(FTy 5,FTy 5))), + Apply + (Call + ("dfn'CCheckType",ATy(qTy,PTy(uTy,qTy)), + Var("v54",PTy(FTy 5,FTy 5))),qVar"state"))])), + (Call("CGet",CTy"CHERICOP2",Var("v55",CTy"CGet")), + CS(Var("v55",CTy"CGet"), + [(Call + ("CGetBase",CTy"CGet", + Var("v56",PTy(FTy 5,FTy 5))), + Apply + (Call + ("dfn'CGetBase",ATy(qTy,PTy(uTy,qTy)), + Var("v56",PTy(FTy 5,FTy 5))),qVar"state")), + (Call("CGetCause",CTy"CGet",Var("v57",FTy 5)), + Apply + (Call + ("dfn'CGetCause",ATy(qTy,PTy(uTy,qTy)), + Var("v57",FTy 5)),qVar"state")), + (Call + ("CGetLen",CTy"CGet", + Var("v58",PTy(FTy 5,FTy 5))), + Apply + (Call + ("dfn'CGetLen",ATy(qTy,PTy(uTy,qTy)), + Var("v58",PTy(FTy 5,FTy 5))),qVar"state")), + (Call + ("CGetOffset",CTy"CGet", + Var("v59",PTy(FTy 5,FTy 5))), + Apply + (Call + ("dfn'CGetOffset",ATy(qTy,PTy(uTy,qTy)), + Var("v59",PTy(FTy 5,FTy 5))),qVar"state")), + (Call("CGetPCC",CTy"CGet",Var("v60",FTy 5)), + Apply + (Call + ("dfn'CGetPCC",ATy(qTy,PTy(uTy,qTy)), + Var("v60",FTy 5)),qVar"state")), + (Call + ("CGetPerm",CTy"CGet", + Var("v61",PTy(FTy 5,FTy 5))), + Apply + (Call + ("dfn'CGetPerm",ATy(qTy,PTy(uTy,qTy)), + Var("v61",PTy(FTy 5,FTy 5))),qVar"state")), + (Call + ("CGetSealed",CTy"CGet", + Var("v62",PTy(FTy 5,FTy 5))), + Apply + (Call + ("dfn'CGetSealed",ATy(qTy,PTy(uTy,qTy)), + Var("v62",PTy(FTy 5,FTy 5))),qVar"state")), + (Call + ("CGetTag",CTy"CGet", + Var("v63",PTy(FTy 5,FTy 5))), + Apply + (Call + ("dfn'CGetTag",ATy(qTy,PTy(uTy,qTy)), + Var("v63",PTy(FTy 5,FTy 5))),qVar"state")), + (Call + ("CGetType",CTy"CGet", + Var("v64",PTy(FTy 5,FTy 5))), + Apply + (Call + ("dfn'CGetType",ATy(qTy,PTy(uTy,qTy)), + Var("v64",PTy(FTy 5,FTy 5))),qVar"state")), + (Call + ("CToPtr",CTy"CGet", + Var("v65",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Apply + (Call + ("dfn'CToPtr",ATy(qTy,PTy(uTy,qTy)), + Var("v65",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + qVar"state"))])), + (Call("CSet",CTy"CHERICOP2",Var("v66",CTy"CSet")), + CS(Var("v66",CTy"CSet"), + [(Call + ("CAndPerm",CTy"CSet", + Var("v67",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Apply + (Call + ("dfn'CAndPerm",ATy(qTy,PTy(uTy,qTy)), + Var("v67",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + qVar"state")), + (Call + ("CClearTag",CTy"CSet", + Var("v68",PTy(FTy 5,FTy 5))), + Apply + (Call + ("dfn'CClearTag",ATy(qTy,PTy(uTy,qTy)), + Var("v68",PTy(FTy 5,FTy 5))),qVar"state")), + (Call + ("CFromPtr",CTy"CSet", + Var("v69",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Apply + (Call + ("dfn'CFromPtr",ATy(qTy,PTy(uTy,qTy)), + Var("v69",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + qVar"state")), + (Call + ("CIncBase",CTy"CSet", + Var("v70",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Apply + (Call + ("dfn'CIncBase",ATy(qTy,PTy(uTy,qTy)), + Var("v70",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + qVar"state")), + (Call("CSetCause",CTy"CSet",Var("v71",FTy 5)), + Apply + (Call + ("dfn'CSetCause",ATy(qTy,PTy(uTy,qTy)), + Var("v71",FTy 5)),qVar"state")), + (Call + ("CSetLen",CTy"CSet", + Var("v72",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Apply + (Call + ("dfn'CSetLen",ATy(qTy,PTy(uTy,qTy)), + Var("v72",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + qVar"state")), + (Call + ("CSetOffset",CTy"CSet", + Var("v73",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Apply + (Call + ("dfn'CSetOffset",ATy(qTy,PTy(uTy,qTy)), + Var("v73",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + qVar"state"))]))]))])), + (Call("CP",CTy"instruction",Var("v82",CTy"CP")), + CS(Var("v82",CTy"CP"), + [(Call + ("DMFC0",CTy"CP",Var("v83",PTy(FTy 5,PTy(FTy 5,FTy 3)))), + Apply + (Call + ("dfn'DMFC0",ATy(qTy,PTy(uTy,qTy)), + Var("v83",PTy(FTy 5,PTy(FTy 5,FTy 3)))),qVar"state")), + (Call + ("DMTC0",CTy"CP",Var("v84",PTy(FTy 5,PTy(FTy 5,FTy 3)))), + Apply + (Call + ("dfn'DMTC0",ATy(qTy,PTy(uTy,qTy)), + Var("v84",PTy(FTy 5,PTy(FTy 5,FTy 3)))),qVar"state")), + (Call + ("MFC0",CTy"CP",Var("v85",PTy(FTy 5,PTy(FTy 5,FTy 3)))), + Apply + (Call + ("dfn'MFC0",ATy(qTy,PTy(uTy,qTy)), + Var("v85",PTy(FTy 5,PTy(FTy 5,FTy 3)))),qVar"state")), + (Call + ("MTC0",CTy"CP",Var("v86",PTy(FTy 5,PTy(FTy 5,FTy 3)))), + Apply + (Call + ("dfn'MTC0",ATy(qTy,PTy(uTy,qTy)), + Var("v86",PTy(FTy 5,PTy(FTy 5,FTy 3)))),qVar"state"))])), + (Call("LDC2",CTy"instruction",Var("v87",CTy"LDC2")), + CS(Var("v87",CTy"LDC2"), + [(Call("CHERILDC2",CTy"LDC2",Var("v88",CTy"CHERILDC2")), + CS(Var("v88",CTy"CHERILDC2"), + [(Call + ("CLC",CTy"CHERILDC2", + Var("v89",PTy(FTy 5,PTy(FTy 5,PTy(FTy 5,FTy 11))))), + Apply + (Call + ("dfn'CLC",ATy(qTy,PTy(uTy,qTy)), + Var("v89", + PTy(FTy 5,PTy(FTy 5,PTy(FTy 5,FTy 11))))), + qVar"state"))]))])), + (Call("LWC2",CTy"instruction",Var("v90",CTy"LWC2")), + CS(Var("v90",CTy"LWC2"), + [(Call("CHERILWC2",CTy"LWC2",Var("v91",CTy"CHERILWC2")), + CS(Var("v91",CTy"CHERILWC2"), + [(Call + ("CLLD",CTy"CHERILWC2", + Var("v92",PTy(FTy 5,PTy(FTy 5,PTy(FTy 5,F8))))), + Apply + (Call + ("dfn'CLLD",ATy(qTy,PTy(uTy,qTy)), + Var("v92",PTy(FTy 5,PTy(FTy 5,PTy(FTy 5,F8))))), + qVar"state")), + (Call + ("CLoad",CTy"CHERILWC2", + Var("v93", + PTy(FTy 5, + PTy(FTy 5,PTy(FTy 5,PTy(F8,PTy(F1,FTy 2))))))), + Apply + (Call + ("dfn'CLoad",ATy(qTy,PTy(uTy,qTy)), + Var("v93", + PTy(FTy 5, + PTy(FTy 5, + PTy(FTy 5,PTy(F8,PTy(F1,FTy 2))))))), + qVar"state"))]))])), + (Call("Load",CTy"instruction",Var("v94",CTy"Load")), + CS(Var("v94",CTy"Load"), + [(Call("LB",CTy"Load",Var("v95",PTy(FTy 5,PTy(FTy 5,F16)))), + Apply + (Call + ("dfn'LB",ATy(qTy,PTy(uTy,qTy)), + Var("v95",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + (Call("LBU",CTy"Load",Var("v96",PTy(FTy 5,PTy(FTy 5,F16)))), + Apply + (Call + ("dfn'LBU",ATy(qTy,PTy(uTy,qTy)), + Var("v96",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + (Call("LD",CTy"Load",Var("v97",PTy(FTy 5,PTy(FTy 5,F16)))), + Apply + (Call + ("dfn'LD",ATy(qTy,PTy(uTy,qTy)), + Var("v97",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + (Call("LDL",CTy"Load",Var("v98",PTy(FTy 5,PTy(FTy 5,F16)))), + Apply + (Call + ("dfn'LDL",ATy(qTy,PTy(uTy,qTy)), + Var("v98",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + (Call("LDR",CTy"Load",Var("v99",PTy(FTy 5,PTy(FTy 5,F16)))), + Apply + (Call + ("dfn'LDR",ATy(qTy,PTy(uTy,qTy)), + Var("v99",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + (Call("LH",CTy"Load",Var("v100",PTy(FTy 5,PTy(FTy 5,F16)))), + Apply + (Call + ("dfn'LH",ATy(qTy,PTy(uTy,qTy)), + Var("v100",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + (Call + ("LHU",CTy"Load",Var("v101",PTy(FTy 5,PTy(FTy 5,F16)))), + Apply + (Call + ("dfn'LHU",ATy(qTy,PTy(uTy,qTy)), + Var("v101",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + (Call("LL",CTy"Load",Var("v102",PTy(FTy 5,PTy(FTy 5,F16)))), + Apply + (Call + ("dfn'LL",ATy(qTy,PTy(uTy,qTy)), + Var("v102",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + (Call + ("LLD",CTy"Load",Var("v103",PTy(FTy 5,PTy(FTy 5,F16)))), + Apply + (Call + ("dfn'LLD",ATy(qTy,PTy(uTy,qTy)), + Var("v103",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + (Call("LW",CTy"Load",Var("v104",PTy(FTy 5,PTy(FTy 5,F16)))), + Apply + (Call + ("dfn'LW",ATy(qTy,PTy(uTy,qTy)), + Var("v104",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + (Call + ("LWL",CTy"Load",Var("v105",PTy(FTy 5,PTy(FTy 5,F16)))), + Apply + (Call + ("dfn'LWL",ATy(qTy,PTy(uTy,qTy)), + Var("v105",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + (Call + ("LWR",CTy"Load",Var("v106",PTy(FTy 5,PTy(FTy 5,F16)))), + Apply + (Call + ("dfn'LWR",ATy(qTy,PTy(uTy,qTy)), + Var("v106",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + (Call + ("LWU",CTy"Load",Var("v107",PTy(FTy 5,PTy(FTy 5,F16)))), + Apply + (Call + ("dfn'LWU",ATy(qTy,PTy(uTy,qTy)), + Var("v107",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state"))])), + (Call("MultDiv",CTy"instruction",Var("v108",CTy"MultDiv")), + CS(Var("v108",CTy"MultDiv"), + [(Call("DDIV",CTy"MultDiv",Var("v109",PTy(FTy 5,FTy 5))), + Apply + (Call + ("dfn'DDIV",ATy(qTy,PTy(uTy,qTy)), + Var("v109",PTy(FTy 5,FTy 5))),qVar"state")), + (Call("DDIVU",CTy"MultDiv",Var("v110",PTy(FTy 5,FTy 5))), + Apply + (Call + ("dfn'DDIVU",ATy(qTy,PTy(uTy,qTy)), + Var("v110",PTy(FTy 5,FTy 5))),qVar"state")), + (Call("DIV",CTy"MultDiv",Var("v111",PTy(FTy 5,FTy 5))), + Apply + (Call + ("dfn'DIV",ATy(qTy,PTy(uTy,qTy)), + Var("v111",PTy(FTy 5,FTy 5))),qVar"state")), + (Call("DIVU",CTy"MultDiv",Var("v112",PTy(FTy 5,FTy 5))), + Apply + (Call + ("dfn'DIVU",ATy(qTy,PTy(uTy,qTy)), + Var("v112",PTy(FTy 5,FTy 5))),qVar"state")), + (Call("DMULT",CTy"MultDiv",Var("v113",PTy(FTy 5,FTy 5))), + Apply + (Call + ("dfn'DMULT",ATy(qTy,PTy(uTy,qTy)), + Var("v113",PTy(FTy 5,FTy 5))),qVar"state")), + (Call("DMULTU",CTy"MultDiv",Var("v114",PTy(FTy 5,FTy 5))), + Apply + (Call + ("dfn'DMULTU",ATy(qTy,PTy(uTy,qTy)), + Var("v114",PTy(FTy 5,FTy 5))),qVar"state")), + (Call("MADD",CTy"MultDiv",Var("v115",PTy(FTy 5,FTy 5))), + Apply + (Call + ("dfn'MADD",ATy(qTy,PTy(uTy,qTy)), + Var("v115",PTy(FTy 5,FTy 5))),qVar"state")), + (Call("MADDU",CTy"MultDiv",Var("v116",PTy(FTy 5,FTy 5))), + Apply + (Call + ("dfn'MADDU",ATy(qTy,PTy(uTy,qTy)), + Var("v116",PTy(FTy 5,FTy 5))),qVar"state")), + (Call("MFHI",CTy"MultDiv",Var("v117",FTy 5)), + Apply + (Call + ("dfn'MFHI",ATy(qTy,PTy(uTy,qTy)),Var("v117",FTy 5)), + qVar"state")), + (Call("MFLO",CTy"MultDiv",Var("v118",FTy 5)), + Apply + (Call + ("dfn'MFLO",ATy(qTy,PTy(uTy,qTy)),Var("v118",FTy 5)), + qVar"state")), + (Call("MSUB",CTy"MultDiv",Var("v119",PTy(FTy 5,FTy 5))), + Apply + (Call + ("dfn'MSUB",ATy(qTy,PTy(uTy,qTy)), + Var("v119",PTy(FTy 5,FTy 5))),qVar"state")), + (Call("MSUBU",CTy"MultDiv",Var("v120",PTy(FTy 5,FTy 5))), + Apply + (Call + ("dfn'MSUBU",ATy(qTy,PTy(uTy,qTy)), + Var("v120",PTy(FTy 5,FTy 5))),qVar"state")), + (Call("MTHI",CTy"MultDiv",Var("v121",FTy 5)), + Apply + (Call + ("dfn'MTHI",ATy(qTy,PTy(uTy,qTy)),Var("v121",FTy 5)), + qVar"state")), + (Call("MTLO",CTy"MultDiv",Var("v122",FTy 5)), + Apply + (Call + ("dfn'MTLO",ATy(qTy,PTy(uTy,qTy)),Var("v122",FTy 5)), + qVar"state")), + (Call + ("MUL",CTy"MultDiv", + Var("v123",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Apply + (Call + ("dfn'MUL",ATy(qTy,PTy(uTy,qTy)), + Var("v123",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + (Call("MULT",CTy"MultDiv",Var("v124",PTy(FTy 5,FTy 5))), + Apply + (Call + ("dfn'MULT",ATy(qTy,PTy(uTy,qTy)), + Var("v124",PTy(FTy 5,FTy 5))),qVar"state")), + (Call("MULTU",CTy"MultDiv",Var("v125",PTy(FTy 5,FTy 5))), + Apply + (Call + ("dfn'MULTU",ATy(qTy,PTy(uTy,qTy)), + Var("v125",PTy(FTy 5,FTy 5))),qVar"state"))])), + (Call("SDC2",CTy"instruction",Var("v126",CTy"SDC2")), + CS(Var("v126",CTy"SDC2"), + [(Call("CHERISDC2",CTy"SDC2",Var("v127",CTy"CHERISDC2")), + CS(Var("v127",CTy"CHERISDC2"), + [(Call + ("CSC",CTy"CHERISDC2", + Var("v128",PTy(FTy 5,PTy(FTy 5,PTy(FTy 5,FTy 11))))), + Apply + (Call + ("dfn'CSC",ATy(qTy,PTy(uTy,qTy)), + Var("v128", + PTy(FTy 5,PTy(FTy 5,PTy(FTy 5,FTy 11))))), + qVar"state"))]))])), + (Call("SWC2",CTy"instruction",Var("v129",CTy"SWC2")), + CS(Var("v129",CTy"SWC2"), + [(Call("CHERISWC2",CTy"SWC2",Var("v130",CTy"CHERISWC2")), + CS(Var("v130",CTy"CHERISWC2"), + [(Call + ("CSCD",CTy"CHERISWC2", + Var("v131",PTy(FTy 5,PTy(FTy 5,PTy(FTy 5,F8))))), + Apply + (Call + ("dfn'CSCD",ATy(qTy,PTy(uTy,qTy)), + Var("v131",PTy(FTy 5,PTy(FTy 5,PTy(FTy 5,F8))))), + qVar"state")), + (Call + ("CStore",CTy"CHERISWC2", + Var("v132", + PTy(FTy 5,PTy(FTy 5,PTy(FTy 5,PTy(F8,FTy 2)))))), + Apply + (Call + ("dfn'CStore",ATy(qTy,PTy(uTy,qTy)), + Var("v132", + PTy(FTy 5, + PTy(FTy 5,PTy(FTy 5,PTy(F8,FTy 2)))))), + qVar"state"))]))])), + (Call("Shift",CTy"instruction",Var("v133",CTy"Shift")), + CS(Var("v133",CTy"Shift"), + [(Call + ("DSLL",CTy"Shift", + Var("v134",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Apply + (Call + ("dfn'DSLL",ATy(qTy,PTy(uTy,qTy)), + Var("v134",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + (Call + ("DSLL32",CTy"Shift", + Var("v135",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Apply + (Call + ("dfn'DSLL32",ATy(qTy,PTy(uTy,qTy)), + Var("v135",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + (Call + ("DSLLV",CTy"Shift", + Var("v136",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Apply + (Call + ("dfn'DSLLV",ATy(qTy,PTy(uTy,qTy)), + Var("v136",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + (Call + ("DSRA",CTy"Shift", + Var("v137",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Apply + (Call + ("dfn'DSRA",ATy(qTy,PTy(uTy,qTy)), + Var("v137",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + (Call + ("DSRA32",CTy"Shift", + Var("v138",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Apply + (Call + ("dfn'DSRA32",ATy(qTy,PTy(uTy,qTy)), + Var("v138",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + (Call + ("DSRAV",CTy"Shift", + Var("v139",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Apply + (Call + ("dfn'DSRAV",ATy(qTy,PTy(uTy,qTy)), + Var("v139",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + (Call + ("DSRL",CTy"Shift", + Var("v140",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Apply + (Call + ("dfn'DSRL",ATy(qTy,PTy(uTy,qTy)), + Var("v140",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + (Call + ("DSRL32",CTy"Shift", + Var("v141",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Apply + (Call + ("dfn'DSRL32",ATy(qTy,PTy(uTy,qTy)), + Var("v141",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + (Call + ("DSRLV",CTy"Shift", + Var("v142",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Apply + (Call + ("dfn'DSRLV",ATy(qTy,PTy(uTy,qTy)), + Var("v142",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + (Call + ("SLL",CTy"Shift", + Var("v143",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Apply + (Call + ("dfn'SLL",ATy(qTy,PTy(uTy,qTy)), + Var("v143",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + (Call + ("SLLV",CTy"Shift", + Var("v144",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Apply + (Call + ("dfn'SLLV",ATy(qTy,PTy(uTy,qTy)), + Var("v144",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + (Call + ("SRA",CTy"Shift", + Var("v145",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Apply + (Call + ("dfn'SRA",ATy(qTy,PTy(uTy,qTy)), + Var("v145",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + (Call + ("SRAV",CTy"Shift", + Var("v146",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Apply + (Call + ("dfn'SRAV",ATy(qTy,PTy(uTy,qTy)), + Var("v146",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + (Call + ("SRL",CTy"Shift", + Var("v147",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Apply + (Call + ("dfn'SRL",ATy(qTy,PTy(uTy,qTy)), + Var("v147",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + (Call + ("SRLV",CTy"Shift", + Var("v148",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Apply + (Call + ("dfn'SRLV",ATy(qTy,PTy(uTy,qTy)), + Var("v148",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state"))])), + (Call("Store",CTy"instruction",Var("v149",CTy"Store")), + CS(Var("v149",CTy"Store"), + [(Call + ("SB",CTy"Store",Var("v150",PTy(FTy 5,PTy(FTy 5,F16)))), + Apply + (Call + ("dfn'SB",ATy(qTy,PTy(uTy,qTy)), + Var("v150",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + (Call + ("SC",CTy"Store",Var("v151",PTy(FTy 5,PTy(FTy 5,F16)))), + Apply + (Call + ("dfn'SC",ATy(qTy,PTy(uTy,qTy)), + Var("v151",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + (Call + ("SCD",CTy"Store",Var("v152",PTy(FTy 5,PTy(FTy 5,F16)))), + Apply + (Call + ("dfn'SCD",ATy(qTy,PTy(uTy,qTy)), + Var("v152",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + (Call + ("SD",CTy"Store",Var("v153",PTy(FTy 5,PTy(FTy 5,F16)))), + Apply + (Call + ("dfn'SD",ATy(qTy,PTy(uTy,qTy)), + Var("v153",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + (Call + ("SDL",CTy"Store",Var("v154",PTy(FTy 5,PTy(FTy 5,F16)))), + Apply + (Call + ("dfn'SDL",ATy(qTy,PTy(uTy,qTy)), + Var("v154",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + (Call + ("SDR",CTy"Store",Var("v155",PTy(FTy 5,PTy(FTy 5,F16)))), + Apply + (Call + ("dfn'SDR",ATy(qTy,PTy(uTy,qTy)), + Var("v155",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + (Call + ("SH",CTy"Store",Var("v156",PTy(FTy 5,PTy(FTy 5,F16)))), + Apply + (Call + ("dfn'SH",ATy(qTy,PTy(uTy,qTy)), + Var("v156",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + (Call + ("SW",CTy"Store",Var("v157",PTy(FTy 5,PTy(FTy 5,F16)))), + Apply + (Call + ("dfn'SW",ATy(qTy,PTy(uTy,qTy)), + Var("v157",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + (Call + ("SWL",CTy"Store",Var("v158",PTy(FTy 5,PTy(FTy 5,F16)))), + Apply + (Call + ("dfn'SWL",ATy(qTy,PTy(uTy,qTy)), + Var("v158",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + (Call + ("SWR",CTy"Store",Var("v159",PTy(FTy 5,PTy(FTy 5,F16)))), + Apply + (Call + ("dfn'SWR",ATy(qTy,PTy(uTy,qTy)), + Var("v159",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state"))])), + (Call("Trap",CTy"instruction",Var("v160",CTy"Trap")), + CS(Var("v160",CTy"Trap"), + [(Call("TEQ",CTy"Trap",Var("v161",PTy(FTy 5,FTy 5))), + Apply + (Call + ("dfn'TEQ",ATy(qTy,PTy(uTy,qTy)), + Var("v161",PTy(FTy 5,FTy 5))),qVar"state")), + (Call("TEQI",CTy"Trap",Var("v162",PTy(FTy 5,F16))), + Apply + (Call + ("dfn'TEQI",ATy(qTy,PTy(uTy,qTy)), + Var("v162",PTy(FTy 5,F16))),qVar"state")), + (Call("TGE",CTy"Trap",Var("v163",PTy(FTy 5,FTy 5))), + Apply + (Call + ("dfn'TGE",ATy(qTy,PTy(uTy,qTy)), + Var("v163",PTy(FTy 5,FTy 5))),qVar"state")), + (Call("TGEI",CTy"Trap",Var("v164",PTy(FTy 5,F16))), + Apply + (Call + ("dfn'TGEI",ATy(qTy,PTy(uTy,qTy)), + Var("v164",PTy(FTy 5,F16))),qVar"state")), + (Call("TGEIU",CTy"Trap",Var("v165",PTy(FTy 5,F16))), + Apply + (Call + ("dfn'TGEIU",ATy(qTy,PTy(uTy,qTy)), + Var("v165",PTy(FTy 5,F16))),qVar"state")), + (Call("TGEU",CTy"Trap",Var("v166",PTy(FTy 5,FTy 5))), + Apply + (Call + ("dfn'TGEU",ATy(qTy,PTy(uTy,qTy)), + Var("v166",PTy(FTy 5,FTy 5))),qVar"state")), + (Call("TLT",CTy"Trap",Var("v167",PTy(FTy 5,FTy 5))), + Apply + (Call + ("dfn'TLT",ATy(qTy,PTy(uTy,qTy)), + Var("v167",PTy(FTy 5,FTy 5))),qVar"state")), + (Call("TLTI",CTy"Trap",Var("v168",PTy(FTy 5,F16))), + Apply + (Call + ("dfn'TLTI",ATy(qTy,PTy(uTy,qTy)), + Var("v168",PTy(FTy 5,F16))),qVar"state")), + (Call("TLTIU",CTy"Trap",Var("v169",PTy(FTy 5,F16))), + Apply + (Call + ("dfn'TLTIU",ATy(qTy,PTy(uTy,qTy)), + Var("v169",PTy(FTy 5,F16))),qVar"state")), + (Call("TLTU",CTy"Trap",Var("v170",PTy(FTy 5,FTy 5))), + Apply + (Call + ("dfn'TLTU",ATy(qTy,PTy(uTy,qTy)), + Var("v170",PTy(FTy 5,FTy 5))),qVar"state")), + (Call("TNE",CTy"Trap",Var("v171",PTy(FTy 5,FTy 5))), + Apply + (Call + ("dfn'TNE",ATy(qTy,PTy(uTy,qTy)), + Var("v171",PTy(FTy 5,FTy 5))),qVar"state")), + (Call("TNEI",CTy"Trap",Var("v172",PTy(FTy 5,F16))), + Apply + (Call + ("dfn'TNEI",ATy(qTy,PTy(uTy,qTy)), + Var("v172",PTy(FTy 5,F16))),qVar"state"))]))]))) +; +val COP2Decode_def = Def + ("COP2Decode",Var("v",FTy 26), + Call + ("COP2",CTy"instruction", + Call + ("CHERICOP2",CTy"COP2", + Let(TP[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22",bVar"b'21", + bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17",bVar"b'16", + bVar"b'15",bVar"b'14",bVar"b'13",bVar"b'12",bVar"b'11", + bVar"b'10",bVar"b'9",bVar"b'8",bVar"b'7",bVar"b'6", + bVar"b'5",bVar"b'4",bVar"b'3",bVar"b'2",bVar"b'1", + bVar"b'0"],BL(26,Var("v",FTy 26)), + ITB([(bVar"b'23", + ITB([(bVar"b'24", + ITE(Mop(Not,bVar"b'25"), + ITB([(Bop(And,Mop(Not,bVar"b'22"), + Bop(And,bVar"b'21", + Bop(And,Mop(Not,bVar"b'2"), + Bop(And,bVar"b'1", + Mop(Not,bVar"b'0"))))), + Call + ("CGet",CTy"CHERICOP2", + Call + ("CGetOffset",CTy"CGet", + TP[Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19", + bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14", + bVar"b'13",bVar"b'12", + bVar"b'11"])]))), + (Bop(And,Mop(Not,bVar"b'22"), + Bop(And,bVar"b'21", + Bop(And,Mop(Not,bVar"b'2"), + Bop(And,Mop(Not,bVar"b'1"), + bVar"b'0")))), + Call + ("CSet",CTy"CHERICOP2", + Call + ("CSetOffset",CTy"CSet", + TP[Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19", + bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14", + bVar"b'13",bVar"b'12", + bVar"b'11"]), + Mop(Cast(FTy 5), + LL[bVar"b'10",bVar"b'9", + bVar"b'8",bVar"b'7", + bVar"b'6"])]))), + (Bop(And,Mop(Not,bVar"b'22"), + Mop(Not,bVar"b'21")), + Call + ("CGet",CTy"CHERICOP2", + Call + ("CToPtr",CTy"CGet", + TP[Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19", + bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14", + bVar"b'13",bVar"b'12", + bVar"b'11"]), + Mop(Cast(FTy 5), + LL[bVar"b'10",bVar"b'9", + bVar"b'8",bVar"b'7", + bVar"b'6"])]))), + (Bop(And,bVar"b'22",Mop(Not,bVar"b'21")), + Call + ("CPtrCmp",CTy"CHERICOP2", + TP[Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19", + bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14", + bVar"b'13",bVar"b'12", + bVar"b'11"]), + Mop(Cast(FTy 5), + LL[bVar"b'10",bVar"b'9", + bVar"b'8",bVar"b'7", + bVar"b'6"]), + Mop(Cast(FTy 3), + LL[bVar"b'2",bVar"b'1", + bVar"b'0"])]))], + Const + ("UnknownCapInstruction",CTy"CHERICOP2")), + Const("UnknownCapInstruction",CTy"CHERICOP2"))), + (Mop(Not,bVar"b'25"), + ITB([(Bop(And,Mop(Not,bVar"b'22"), + Bop(And,Mop(Not,bVar"b'21"), + Bop(And,bVar"b'2", + Bop(And,bVar"b'1", + Mop(Not,bVar"b'0"))))), + Const("DumpCapReg",CTy"CHERICOP2")), + (Bop(And,Mop(Not,bVar"b'22"), + Bop(And,Mop(Not,bVar"b'21"), + Bop(And,Mop(Not,bVar"b'20"), + Bop(And,Mop(Not,bVar"b'19"), + Bop(And, + Mop(Not,bVar"b'18"), + Bop(And, + Mop(Not,bVar"b'17"), + Bop(And, + Mop(Not, + bVar"b'16"), + Bop(And, + Mop(Not, + bVar"b'15"), + Bop(And, + Mop(Not, + bVar"b'14"), + Bop(And, + Mop(Not, + bVar"b'13"), + Bop(And, + Mop(Not, + bVar"b'12"), + Bop(And, + Mop(Not, + bVar"b'11"), + Bop(And, + bVar"b'2", + Bop(And, + Mop(Not, + bVar"b'1"), + Mop(Not, + bVar"b'0"))))))))))))))), + Call + ("CSet",CTy"CHERICOP2", + Call + ("CSetCause",CTy"CSet", + Mop(Cast(FTy 5), + LL[bVar"b'10",bVar"b'9", + bVar"b'8",bVar"b'7",bVar"b'6"])))), + (Bop(And,Mop(Not,bVar"b'22"), + Bop(And,Mop(Not,bVar"b'21"), + Bop(And,Mop(Not,bVar"b'2"), + Bop(And,bVar"b'1", + Mop(Not,bVar"b'0"))))), + Call + ("CSet",CTy"CHERICOP2", + Call + ("CIncBase",CTy"CSet", + TP[Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19", + bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14", + bVar"b'13",bVar"b'12", + bVar"b'11"]), + Mop(Cast(FTy 5), + LL[bVar"b'10",bVar"b'9", + bVar"b'8",bVar"b'7", + bVar"b'6"])]))), + (Bop(And,Mop(Not,bVar"b'22"), + Bop(And,Mop(Not,bVar"b'21"), + Bop(And,Mop(Not,bVar"b'2"), + Bop(And,bVar"b'1",bVar"b'0")))), + Call + ("CSet",CTy"CHERICOP2", + Call + ("CSetLen",CTy"CSet", + TP[Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19", + bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14", + bVar"b'13",bVar"b'12", + bVar"b'11"]), + Mop(Cast(FTy 5), + LL[bVar"b'10",bVar"b'9", + bVar"b'8",bVar"b'7", + bVar"b'6"])]))), + (Bop(And,Mop(Not,bVar"b'22"), + Bop(And,Mop(Not,bVar"b'21"), + Bop(And,bVar"b'2", + Bop(And,Mop(Not,bVar"b'1"), + bVar"b'0")))), + Call + ("CSet",CTy"CHERICOP2", + Call + ("CClearTag",CTy"CSet", + TP[Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19", + bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14", + bVar"b'13",bVar"b'12", + bVar"b'11"])]))), + (Bop(And,Mop(Not,bVar"b'22"), + Bop(And,Mop(Not,bVar"b'21"), + Bop(And,Mop(Not,bVar"b'2"), + Bop(And,Mop(Not,bVar"b'1"), + Mop(Not,bVar"b'0"))))), + Call + ("CSet",CTy"CHERICOP2", + Call + ("CAndPerm",CTy"CSet", + TP[Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19", + bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14", + bVar"b'13",bVar"b'12", + bVar"b'11"]), + Mop(Cast(FTy 5), + LL[bVar"b'10",bVar"b'9", + bVar"b'8",bVar"b'7", + bVar"b'6"])]))), + (Bop(And,Mop(Not,bVar"b'22"), + Bop(And,Mop(Not,bVar"b'21"), + Bop(And,bVar"b'2", + Bop(And,bVar"b'1",bVar"b'0")))), + Call + ("CSet",CTy"CHERICOP2", + Call + ("CFromPtr",CTy"CSet", + TP[Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19", + bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14", + bVar"b'13",bVar"b'12", + bVar"b'11"]), + Mop(Cast(FTy 5), + LL[bVar"b'10",bVar"b'9", + bVar"b'8",bVar"b'7", + bVar"b'6"])]))), + (Bop(And,bVar"b'22",bVar"b'21"), + Call + ("CJALR",CTy"CHERICOP2", + TP[Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19", + bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14", + bVar"b'13",bVar"b'12", + bVar"b'11"])])), + (Bop(And,Mop(Not,bVar"b'22"),bVar"b'21"), + Call + ("CCall",CTy"CHERICOP2", + TP[Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19", + bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14", + bVar"b'13",bVar"b'12", + bVar"b'11"])])), + (Bop(And,bVar"b'22",Mop(Not,bVar"b'21")), + Const("CReturn",CTy"CHERICOP2"))], + Const("UnknownCapInstruction",CTy"CHERICOP2")))], + Const("UnknownCapInstruction",CTy"CHERICOP2"))), + (bVar"b'24", + ITE(Mop(Not,bVar"b'25"), + ITB([(Bop(And,bVar"b'22", + Bop(And,bVar"b'21", + Bop(And,Mop(Not,bVar"b'2"), + Bop(And,Mop(Not,bVar"b'1"), + Mop(Not,bVar"b'0"))))), + Call + ("CCheck",CTy"CHERICOP2", + Call + ("CCheckPerm",CTy"CCheck", + TP[Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19", + bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'10",bVar"b'9", + bVar"b'8",bVar"b'7",bVar"b'6"])]))), + (Bop(And,bVar"b'22", + Bop(And,bVar"b'21", + Bop(And,Mop(Not,bVar"b'2"), + Bop(And,Mop(Not,bVar"b'1"), + bVar"b'0")))), + Call + ("CCheck",CTy"CHERICOP2", + Call + ("CCheckType",CTy"CCheck", + TP[Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19", + bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14", + bVar"b'13",bVar"b'12", + bVar"b'11"])]))), + (Bop(And,Mop(Not,bVar"b'22"),bVar"b'21"), + Call + ("CBTU",CTy"CHERICOP2", + TP[Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19", + bVar"b'18",bVar"b'17",bVar"b'16"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14", + bVar"b'13",bVar"b'12", + bVar"b'11",bVar"b'10",bVar"b'9", + bVar"b'8",bVar"b'7",bVar"b'6", + bVar"b'5",bVar"b'4",bVar"b'3", + bVar"b'2",bVar"b'1",bVar"b'0"])])), + (Bop(And,bVar"b'22",Mop(Not,bVar"b'21")), + Call + ("CBTS",CTy"CHERICOP2", + TP[Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19", + bVar"b'18",bVar"b'17",bVar"b'16"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14", + bVar"b'13",bVar"b'12", + bVar"b'11",bVar"b'10",bVar"b'9", + bVar"b'8",bVar"b'7",bVar"b'6", + bVar"b'5",bVar"b'4",bVar"b'3", + bVar"b'2",bVar"b'1",bVar"b'0"])])), + (Bop(And,Mop(Not,bVar"b'22"), + Mop(Not,bVar"b'21")), + Call + ("CJR",CTy"CHERICOP2", + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11"])))], + Const("UnknownCapInstruction",CTy"CHERICOP2")), + Const("UnknownCapInstruction",CTy"CHERICOP2"))), + (Mop(Not,bVar"b'25"), + ITB([(Bop(And,Mop(Not,bVar"b'22"), + Bop(And,Mop(Not,bVar"b'21"), + Bop(And,Mop(Not,bVar"b'2"), + Bop(And,bVar"b'1",Mop(Not,bVar"b'0"))))), + Call + ("CGet",CTy"CHERICOP2", + Call + ("CGetBase",CTy"CGet", + TP[Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11"])]))), + (Bop(And,Mop(Not,bVar"b'22"), + Bop(And,Mop(Not,bVar"b'21"), + Bop(And,Mop(Not,bVar"b'2"), + Bop(And,bVar"b'1",bVar"b'0")))), + Call + ("CGet",CTy"CHERICOP2", + Call + ("CGetLen",CTy"CGet", + TP[Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11"])]))), + (Bop(And,Mop(Not,bVar"b'22"), + Bop(And,Mop(Not,bVar"b'21"), + Bop(And,bVar"b'2", + Bop(And,Mop(Not,bVar"b'1"),bVar"b'0")))), + Call + ("CGet",CTy"CHERICOP2", + Call + ("CGetTag",CTy"CGet", + TP[Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11"])]))), + (Bop(And,Mop(Not,bVar"b'22"), + Bop(And,Mop(Not,bVar"b'21"), + Bop(And,bVar"b'2", + Bop(And,bVar"b'1",Mop(Not,bVar"b'0"))))), + Call + ("CGet",CTy"CHERICOP2", + Call + ("CGetSealed",CTy"CGet", + TP[Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11"])]))), + (Bop(And,Mop(Not,bVar"b'22"), + Bop(And,Mop(Not,bVar"b'21"), + Bop(And,Mop(Not,bVar"b'2"), + Bop(And,Mop(Not,bVar"b'1"), + Mop(Not,bVar"b'0"))))), + Call + ("CGet",CTy"CHERICOP2", + Call + ("CGetPerm",CTy"CGet", + TP[Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11"])]))), + (Bop(And,Mop(Not,bVar"b'22"), + Bop(And,Mop(Not,bVar"b'21"), + Bop(And,Mop(Not,bVar"b'2"), + Bop(And,Mop(Not,bVar"b'1"),bVar"b'0")))), + Call + ("CGet",CTy"CHERICOP2", + Call + ("CGetType",CTy"CGet", + TP[Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11"])]))), + (Bop(And,Mop(Not,bVar"b'22"), + Bop(And,Mop(Not,bVar"b'21"), + Bop(And,bVar"b'2", + Bop(And,bVar"b'1",bVar"b'0")))), + Call + ("CGet",CTy"CHERICOP2", + Call + ("CGetPCC",CTy"CGet", + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11"])))), + (Bop(And,Mop(Not,bVar"b'22"), + Bop(And,Mop(Not,bVar"b'21"), + Bop(And,Mop(Not,bVar"b'15"), + Bop(And,Mop(Not,bVar"b'14"), + Bop(And,Mop(Not,bVar"b'13"), + Bop(And,Mop(Not,bVar"b'12"), + Bop(And, + Mop(Not,bVar"b'11"), + Bop(And,bVar"b'2", + Bop(And, + Mop(Not, + bVar"b'1"), + Mop(Not, + bVar"b'0")))))))))), + Call + ("CGet",CTy"CHERICOP2", + Call + ("CGetCause",CTy"CGet", + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"])))), + (Bop(And,bVar"b'22",Mop(Not,bVar"b'21")), + Call + ("CSeal",CTy"CHERICOP2", + TP[Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11"]), + Mop(Cast(FTy 5), + LL[bVar"b'10",bVar"b'9",bVar"b'8", + bVar"b'7",bVar"b'6"])])), + (Bop(And,bVar"b'22",bVar"b'21"), + Call + ("CUnseal",CTy"CHERICOP2", + TP[Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11"]), + Mop(Cast(FTy 5), + LL[bVar"b'10",bVar"b'9",bVar"b'8", + bVar"b'7",bVar"b'6"])]))], + Const("UnknownCapInstruction",CTy"CHERICOP2")))], + Const("UnknownCapInstruction",CTy"CHERICOP2")))))) +; +val LWC2Decode_def = Def + ("LWC2Decode",Var("v",FTy 26), + Call + ("LWC2",CTy"instruction", + Call + ("CHERILWC2",CTy"LWC2", + Let(TP[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22",bVar"b'21", + bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17",bVar"b'16", + bVar"b'15",bVar"b'14",bVar"b'13",bVar"b'12",bVar"b'11", + bVar"b'10",bVar"b'9",bVar"b'8",bVar"b'7",bVar"b'6", + bVar"b'5",bVar"b'4",bVar"b'3",bVar"b'2",bVar"b'1", + bVar"b'0"],BL(26,Var("v",FTy 26)), + ITB([(Mop(Not,bVar"b'2"), + Call + ("CLoad",CTy"CHERILWC2", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11"]), + Mop(Cast F8, + LL[bVar"b'10",bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4",bVar"b'3"]), + LW(0,1),Mop(Cast(FTy 2),LL[bVar"b'1",bVar"b'0"])])), + (Bop(And,bVar"b'2", + Bop(And,Mop(Not,bVar"b'1"),Mop(Not,bVar"b'0"))), + Call + ("CLoad",CTy"CHERILWC2", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11"]), + Mop(Cast F8, + LL[bVar"b'10",bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4",bVar"b'3"]), + LW(1,1),LW(0,2)])), + (Bop(And,bVar"b'2",Bop(And,Mop(Not,bVar"b'1"),bVar"b'0")), + Call + ("CLoad",CTy"CHERILWC2", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11"]), + Mop(Cast F8, + LL[bVar"b'10",bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4",bVar"b'3"]), + LW(1,1),LW(1,2)])), + (Bop(And,bVar"b'2",Bop(And,bVar"b'1",Mop(Not,bVar"b'0"))), + Call + ("CLoad",CTy"CHERILWC2", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11"]), + Mop(Cast F8, + LL[bVar"b'10",bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4",bVar"b'3"]), + LW(1,1),LW(2,2)]))], + Call + ("CLLD",CTy"CHERILWC2", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13",bVar"b'12", + bVar"b'11"]), + Mop(Cast F8, + LL[bVar"b'10",bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4",bVar"b'3"])])))))) +; +val LDC2Decode_def = Def + ("LDC2Decode",Var("v",FTy 26), + CS(BL(26,Var("v",FTy 26)), + [(TP[bVar"cd'4",bVar"cd'3",bVar"cd'2",bVar"cd'1",bVar"cd'0", + bVar"cb'4",bVar"cb'3",bVar"cb'2",bVar"cb'1",bVar"cb'0", + bVar"rt'4",bVar"rt'3",bVar"rt'2",bVar"rt'1",bVar"rt'0", + bVar"offset'10",bVar"offset'9",bVar"offset'8",bVar"offset'7", + bVar"offset'6",bVar"offset'5",bVar"offset'4",bVar"offset'3", + bVar"offset'2",bVar"offset'1",bVar"offset'0"], + Call + ("LDC2",CTy"instruction", + Call + ("CHERILDC2",CTy"LDC2", + Call + ("CLC",CTy"CHERILDC2", + TP[Mop(Cast(FTy 5), + LL[bVar"cd'4",bVar"cd'3",bVar"cd'2",bVar"cd'1", + bVar"cd'0"]), + Mop(Cast(FTy 5), + LL[bVar"cb'4",bVar"cb'3",bVar"cb'2",bVar"cb'1", + bVar"cb'0"]), + Mop(Cast(FTy 5), + LL[bVar"rt'4",bVar"rt'3",bVar"rt'2",bVar"rt'1", + bVar"rt'0"]), + Mop(Cast(FTy 11), + LL[bVar"offset'10",bVar"offset'9",bVar"offset'8", + bVar"offset'7",bVar"offset'6",bVar"offset'5", + bVar"offset'4",bVar"offset'3",bVar"offset'2", + bVar"offset'1",bVar"offset'0"])]))))])) +; +val SWC2Decode_def = Def + ("SWC2Decode",Var("v",FTy 26), + Let(TP[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22",bVar"b'21", + bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17",bVar"b'16", + bVar"b'15",bVar"b'14",bVar"b'13",bVar"b'12",bVar"b'11", + bVar"b'10",bVar"b'9",bVar"b'8",bVar"b'7",bVar"b'6",bVar"b'5", + bVar"b'4",bVar"b'3",bVar"b'2",bVar"b'1",bVar"b'0"], + BL(26,Var("v",FTy 26)), + ITB([(Mop(Not,bVar"b'2"), + Call + ("SWC2",CTy"instruction", + Call + ("CHERISWC2",CTy"SWC2", + Call + ("CStore",CTy"CHERISWC2", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11"]), + Mop(Cast F8, + LL[bVar"b'10",bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4",bVar"b'3"]), + Mop(Cast(FTy 2),LL[bVar"b'1",bVar"b'0"])])))), + (Bop(And,bVar"b'2",Bop(And,bVar"b'1",bVar"b'0")), + Call + ("SWC2",CTy"instruction", + Call + ("CHERISWC2",CTy"SWC2", + Call + ("CSCD",CTy"CHERISWC2", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11"]), + Mop(Cast F8, + LL[bVar"b'10",bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4",bVar"b'3"])]))))], + Call + ("COP2",CTy"instruction", + Call + ("CHERICOP2",CTy"COP2", + Const("UnknownCapInstruction",CTy"CHERICOP2")))))) +; +val SDC2Decode_def = Def + ("SDC2Decode",Var("v",FTy 26), + CS(BL(26,Var("v",FTy 26)), + [(TP[bVar"cs'4",bVar"cs'3",bVar"cs'2",bVar"cs'1",bVar"cs'0", + bVar"cb'4",bVar"cb'3",bVar"cb'2",bVar"cb'1",bVar"cb'0", + bVar"rt'4",bVar"rt'3",bVar"rt'2",bVar"rt'1",bVar"rt'0", + bVar"offset'10",bVar"offset'9",bVar"offset'8",bVar"offset'7", + bVar"offset'6",bVar"offset'5",bVar"offset'4",bVar"offset'3", + bVar"offset'2",bVar"offset'1",bVar"offset'0"], + Call + ("SDC2",CTy"instruction", + Call + ("CHERISDC2",CTy"SDC2", + Call + ("CSC",CTy"CHERISDC2", + TP[Mop(Cast(FTy 5), + LL[bVar"cs'4",bVar"cs'3",bVar"cs'2",bVar"cs'1", + bVar"cs'0"]), + Mop(Cast(FTy 5), + LL[bVar"cb'4",bVar"cb'3",bVar"cb'2",bVar"cb'1", + bVar"cb'0"]), + Mop(Cast(FTy 5), + LL[bVar"rt'4",bVar"rt'3",bVar"rt'2",bVar"rt'1", + bVar"rt'0"]), + Mop(Cast(FTy 11), + LL[bVar"offset'10",bVar"offset'9",bVar"offset'8", + bVar"offset'7",bVar"offset'6",bVar"offset'5", + bVar"offset'4",bVar"offset'3",bVar"offset'2", + bVar"offset'1",bVar"offset'0"])]))))])) +; +val Decode_def = Def + ("Decode",Var("w",F32), + Let(TP[bVar"b'31",bVar"b'30",bVar"b'29",bVar"b'28",bVar"b'27", + bVar"b'26",bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21",bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16",bVar"b'15",bVar"b'14",bVar"b'13",bVar"b'12", + bVar"b'11",bVar"b'10",bVar"b'9",bVar"b'8",bVar"b'7",bVar"b'6", + bVar"b'5",bVar"b'4",bVar"b'3",bVar"b'2",bVar"b'1",bVar"b'0"], + BL(32,Var("w",F32)), + ITB([(bVar"b'26", + ITB([(bVar"b'28", + ITB([(bVar"b'31", + ITB([(Bop(And,Mop(Not,bVar"b'30"), + Bop(And,Mop(Not,bVar"b'29"), + Mop(Not,bVar"b'27"))), + Call + ("Load",CTy"instruction", + Call + ("LHU",CTy"Load", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24", + bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19", + bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14", + bVar"b'13",bVar"b'12", + bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8", + bVar"b'7",bVar"b'6", + bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2", + bVar"b'1",bVar"b'0"])]))), + (Bop(And,Mop(Not,bVar"b'30"), + Bop(And,Mop(Not,bVar"b'29"),bVar"b'27")), + Call + ("Load",CTy"instruction", + Call + ("LWU",CTy"Load", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24", + bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19", + bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14", + bVar"b'13",bVar"b'12", + bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8", + bVar"b'7",bVar"b'6", + bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2", + bVar"b'1",bVar"b'0"])]))), + (Bop(And,Mop(Not,bVar"b'30"), + Bop(And,bVar"b'29",Mop(Not,bVar"b'27"))), + Call + ("Store",CTy"instruction", + Call + ("SDR",CTy"Store", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24", + bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19", + bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14", + bVar"b'13",bVar"b'12", + bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8", + bVar"b'7",bVar"b'6", + bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2", + bVar"b'1",bVar"b'0"])]))), + (Bop(And,bVar"b'30", + Bop(And,Mop(Not,bVar"b'29"),bVar"b'27")), + Call + ("Load",CTy"instruction", + Call + ("LD",CTy"Load", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24", + bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19", + bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14", + bVar"b'13",bVar"b'12", + bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8", + bVar"b'7",bVar"b'6", + bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2", + bVar"b'1",bVar"b'0"])]))), + (Bop(And,bVar"b'30", + Bop(And,bVar"b'29",bVar"b'27")), + Call + ("Store",CTy"instruction", + Call + ("SD",CTy"Store", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24", + bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19", + bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14", + bVar"b'13",bVar"b'12", + bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8", + bVar"b'7",bVar"b'6", + bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2", + bVar"b'1",bVar"b'0"])]))), + (Bop(And,Mop(Not,bVar"b'30"), + Bop(And,bVar"b'29",bVar"b'27")), + Call + ("CACHE",CTy"instruction", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24", + bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19", + bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14", + bVar"b'13",bVar"b'12", + bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1", + bVar"b'0"])]))], + Const("ReservedInstruction",CTy"instruction"))), + (Bop(And,Mop(Not,bVar"b'30"), + Bop(And,Mop(Not,bVar"b'29"), + Bop(And,bVar"b'27", + Bop(And,Mop(Not,bVar"b'20"), + Bop(And,Mop(Not,bVar"b'19"), + Bop(And,Mop(Not,bVar"b'18"), + Bop(And, + Mop(Not,bVar"b'17"), + Mop(Not,bVar"b'16")))))))), + Call + ("Branch",CTy"instruction", + Call + ("BGTZ",CTy"Branch", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1", + bVar"b'0"])]))), + (Bop(And,Mop(Not,bVar"b'30"), + Bop(And,bVar"b'29", + Bop(And,bVar"b'27", + Bop(And,Mop(Not,bVar"b'25"), + Bop(And,Mop(Not,bVar"b'24"), + Bop(And,Mop(Not,bVar"b'23"), + Bop(And, + Mop(Not,bVar"b'22"), + Mop(Not,bVar"b'21")))))))), + Call + ("ArithI",CTy"instruction", + Call + ("LUI",CTy"ArithI", + TP[Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1", + bVar"b'0"])]))), + (Bop(And,bVar"b'30", + Bop(And,Mop(Not,bVar"b'29"), + Bop(And,bVar"b'27", + Bop(And,Mop(Not,bVar"b'20"), + Bop(And,Mop(Not,bVar"b'19"), + Bop(And,Mop(Not,bVar"b'18"), + Bop(And, + Mop(Not,bVar"b'17"), + Mop(Not,bVar"b'16")))))))), + Call + ("Branch",CTy"instruction", + Call + ("BGTZL",CTy"Branch", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1", + bVar"b'0"])]))), + (Bop(And,Mop(Not,bVar"b'30"), + Bop(And,Mop(Not,bVar"b'29"), + Mop(Not,bVar"b'27"))), + Call + ("Branch",CTy"instruction", + Call + ("BNE",CTy"Branch", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1", + bVar"b'0"])]))), + (Bop(And,Mop(Not,bVar"b'30"), + Bop(And,bVar"b'29",Mop(Not,bVar"b'27"))), + Call + ("ArithI",CTy"instruction", + Call + ("ORI",CTy"ArithI", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1", + bVar"b'0"])]))), + (Bop(And,bVar"b'30", + Bop(And,Mop(Not,bVar"b'29"), + Mop(Not,bVar"b'27"))), + Call + ("Branch",CTy"instruction", + Call + ("BNEL",CTy"Branch", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1", + bVar"b'0"])]))), + (Bop(And,bVar"b'30", + Bop(And,bVar"b'29", + Bop(And,bVar"b'27", + Bop(And,Mop(Not,bVar"b'25"), + Bop(And,Mop(Not,bVar"b'24"), + Bop(And,Mop(Not,bVar"b'23"), + Bop(And, + Mop(Not,bVar"b'22"), + Bop(And, + Mop(Not, + bVar"b'21"), + Bop(And, + Mop(Not, + bVar"b'10"), + Bop(And, + Mop(Not, + bVar"b'9"), + Bop(And, + Mop(Not, + bVar"b'8"), + Bop(And, + Mop(Not, + bVar"b'7"), + Bop(And, + Mop(Not, + bVar"b'6"), + Bop(And, + bVar"b'5", + Bop(And, + bVar"b'4", + Bop(And, + bVar"b'3", + Bop(And, + Mop(Not, + bVar"b'2"), + Bop(And, + bVar"b'1", + bVar"b'0")))))))))))))))))), + Call + ("RDHWR",CTy"instruction", + TP[Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11"])]))], + Const("ReservedInstruction",CTy"instruction"))), + (bVar"b'29", + ITB([(Bop(And,Mop(Not,bVar"b'31"), + Bop(And,Mop(Not,bVar"b'30"), + Mop(Not,bVar"b'27"))), + Call + ("ArithI",CTy"instruction", + Call + ("ADDIU",CTy"ArithI", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1", + bVar"b'0"])]))), + (Bop(And,Mop(Not,bVar"b'31"), + Bop(And,Mop(Not,bVar"b'30"),bVar"b'27")), + Call + ("ArithI",CTy"instruction", + Call + ("SLTIU",CTy"ArithI", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1", + bVar"b'0"])]))), + (Bop(And,Mop(Not,bVar"b'31"), + Bop(And,bVar"b'30",Mop(Not,bVar"b'27"))), + Call + ("ArithI",CTy"instruction", + Call + ("DADDIU",CTy"ArithI", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1", + bVar"b'0"])]))), + (Bop(And,Mop(Not,bVar"b'31"), + Bop(And,bVar"b'30",bVar"b'27")), + Call + ("Load",CTy"instruction", + Call + ("LDR",CTy"Load", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1", + bVar"b'0"])]))), + (Bop(And,bVar"b'31", + Bop(And,Mop(Not,bVar"b'30"), + Mop(Not,bVar"b'27"))), + Call + ("Store",CTy"instruction", + Call + ("SH",CTy"Store", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1", + bVar"b'0"])]))), + (Bop(And,bVar"b'31", + Bop(And,Mop(Not,bVar"b'30"),bVar"b'27")), + Call + ("Store",CTy"instruction", + Call + ("SW",CTy"Store", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1", + bVar"b'0"])])))], + Const("ReservedInstruction",CTy"instruction"))), + (Mop(Not,bVar"b'30"), + ITB([(Bop(And,Mop(Not,bVar"b'31"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'20"), + Bop(And,Mop(Not,bVar"b'19"), + Bop(And,Mop(Not,bVar"b'18"), + Bop(And,Mop(Not,bVar"b'17"), + Mop(Not,bVar"b'16"))))))), + Call + ("Branch",CTy"instruction", + Call + ("BLTZ",CTy"Branch", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1", + bVar"b'0"])]))), + (Bop(And,Mop(Not,bVar"b'31"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'20"), + Bop(And,Mop(Not,bVar"b'19"), + Bop(And,Mop(Not,bVar"b'18"), + Bop(And,Mop(Not,bVar"b'17"), + bVar"b'16")))))), + Call + ("Branch",CTy"instruction", + Call + ("BGEZ",CTy"Branch", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1", + bVar"b'0"])]))), + (Bop(And,Mop(Not,bVar"b'31"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'20"), + Bop(And,Mop(Not,bVar"b'19"), + Bop(And,Mop(Not,bVar"b'18"), + Bop(And,bVar"b'17", + Mop(Not,bVar"b'16"))))))), + Call + ("Branch",CTy"instruction", + Call + ("BLTZL",CTy"Branch", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1", + bVar"b'0"])]))), + (Bop(And,Mop(Not,bVar"b'31"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'20"), + Bop(And,Mop(Not,bVar"b'19"), + Bop(And,Mop(Not,bVar"b'18"), + Bop(And,bVar"b'17",bVar"b'16")))))), + Call + ("Branch",CTy"instruction", + Call + ("BGEZL",CTy"Branch", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1", + bVar"b'0"])]))), + (Bop(And,Mop(Not,bVar"b'31"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'20"), + Bop(And,bVar"b'19", + Bop(And,Mop(Not,bVar"b'18"), + Bop(And,Mop(Not,bVar"b'17"), + Mop(Not,bVar"b'16"))))))), + Call + ("Trap",CTy"instruction", + Call + ("TGEI",CTy"Trap", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1", + bVar"b'0"])]))), + (Bop(And,Mop(Not,bVar"b'31"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'20"), + Bop(And,bVar"b'19", + Bop(And,Mop(Not,bVar"b'18"), + Bop(And,Mop(Not,bVar"b'17"), + bVar"b'16")))))), + Call + ("Trap",CTy"instruction", + Call + ("TGEIU",CTy"Trap", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1", + bVar"b'0"])]))), + (Bop(And,Mop(Not,bVar"b'31"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'20"), + Bop(And,bVar"b'19", + Bop(And,Mop(Not,bVar"b'18"), + Bop(And,bVar"b'17", + Mop(Not,bVar"b'16"))))))), + Call + ("Trap",CTy"instruction", + Call + ("TLTI",CTy"Trap", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1", + bVar"b'0"])]))), + (Bop(And,Mop(Not,bVar"b'31"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'20"), + Bop(And,bVar"b'19", + Bop(And,Mop(Not,bVar"b'18"), + Bop(And,bVar"b'17",bVar"b'16")))))), + Call + ("Trap",CTy"instruction", + Call + ("TLTIU",CTy"Trap", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1", + bVar"b'0"])]))), + (Bop(And,Mop(Not,bVar"b'31"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'20"), + Bop(And,bVar"b'19", + Bop(And,bVar"b'18", + Bop(And,Mop(Not,bVar"b'17"), + Mop(Not,bVar"b'16"))))))), + Call + ("Trap",CTy"instruction", + Call + ("TEQI",CTy"Trap", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1", + bVar"b'0"])]))), + (Bop(And,Mop(Not,bVar"b'31"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'20"), + Bop(And,bVar"b'19", + Bop(And,bVar"b'18", + Bop(And,bVar"b'17", + Mop(Not,bVar"b'16"))))))), + Call + ("Trap",CTy"instruction", + Call + ("TNEI",CTy"Trap", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1", + bVar"b'0"])]))), + (Bop(And,Mop(Not,bVar"b'31"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,bVar"b'25", + Bop(And,bVar"b'24", + Bop(And,bVar"b'23", + Bop(And,bVar"b'22", + Bop(And,bVar"b'21", + Bop(And,bVar"b'20", + Bop(And, + Mop(Not, + bVar"b'19"), + Mop(Not, + bVar"b'18")))))))))), + Const("Unpredictable",CTy"instruction")), + (Bop(And,Mop(Not,bVar"b'31"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,bVar"b'20", + Bop(And,Mop(Not,bVar"b'19"), + Bop(And,Mop(Not,bVar"b'18"), + Bop(And,Mop(Not,bVar"b'17"), + Mop(Not,bVar"b'16"))))))), + Call + ("Branch",CTy"instruction", + Call + ("BLTZAL",CTy"Branch", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1", + bVar"b'0"])]))), + (Bop(And,Mop(Not,bVar"b'31"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,bVar"b'20", + Bop(And,Mop(Not,bVar"b'19"), + Bop(And,Mop(Not,bVar"b'18"), + Bop(And,Mop(Not,bVar"b'17"), + bVar"b'16")))))), + Call + ("Branch",CTy"instruction", + Call + ("BGEZAL",CTy"Branch", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1", + bVar"b'0"])]))), + (Bop(And,Mop(Not,bVar"b'31"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,bVar"b'20", + Bop(And,Mop(Not,bVar"b'19"), + Bop(And,Mop(Not,bVar"b'18"), + Bop(And,bVar"b'17", + Mop(Not,bVar"b'16"))))))), + Call + ("Branch",CTy"instruction", + Call + ("BLTZALL",CTy"Branch", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1", + bVar"b'0"])]))), + (Bop(And,Mop(Not,bVar"b'31"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,bVar"b'20", + Bop(And,Mop(Not,bVar"b'19"), + Bop(And,Mop(Not,bVar"b'18"), + Bop(And,bVar"b'17",bVar"b'16")))))), + Call + ("Branch",CTy"instruction", + Call + ("BGEZALL",CTy"Branch", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1", + bVar"b'0"])]))), + (Bop(And,Mop(Not,bVar"b'31"),bVar"b'27"), + Call + ("Branch",CTy"instruction", + Call + ("JAL",CTy"Branch", + Mop(Cast(FTy 26), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21",bVar"b'20", + bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16",bVar"b'15",bVar"b'14", + bVar"b'13",bVar"b'12",bVar"b'11", + bVar"b'10",bVar"b'9",bVar"b'8", + bVar"b'7",bVar"b'6",bVar"b'5", + bVar"b'4",bVar"b'3",bVar"b'2", + bVar"b'1",bVar"b'0"])))), + (Bop(And,bVar"b'31",Mop(Not,bVar"b'27")), + Call + ("Load",CTy"instruction", + Call + ("LH",CTy"Load", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1", + bVar"b'0"])]))), + (Bop(And,bVar"b'31",bVar"b'27"), + Call + ("Load",CTy"instruction", + Call + ("LW",CTy"Load", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1", + bVar"b'0"])])))], + Const("ReservedInstruction",CTy"instruction")))], + Const("ReservedInstruction",CTy"instruction"))), + (bVar"b'30", + ITB([(bVar"b'29", + ITB([(bVar"b'28", + ITB([(Bop(And,Mop(Not,bVar"b'31"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'15"), + Bop(And,Mop(Not,bVar"b'14"), + Bop(And, + Mop(Not,bVar"b'13"), + Bop(And, + Mop(Not,bVar"b'12"), + Bop(And, + Mop(Not, + bVar"b'11"), + Bop(And, + Mop(Not, + bVar"b'10"), + Bop(And, + Mop(Not, + bVar"b'9"), + Bop(And, + Mop(Not, + bVar"b'8"), + Bop(And, + Mop(Not, + bVar"b'7"), + Bop(And, + Mop(Not, + bVar"b'6"), + Bop(And, + Mop(Not, + bVar"b'5"), + Bop(And, + Mop(Not, + bVar"b'4"), + Bop(And, + Mop(Not, + bVar"b'3"), + Bop(And, + Mop(Not, + bVar"b'2"), + Bop(And, + Mop(Not, + bVar"b'1"), + Mop(Not, + bVar"b'0")))))))))))))))))), + Call + ("MultDiv",CTy"instruction", + Call + ("MADD",CTy"MultDiv", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24", + bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19", + bVar"b'18",bVar"b'17", + bVar"b'16"])]))), + (Bop(And,Mop(Not,bVar"b'31"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'15"), + Bop(And,Mop(Not,bVar"b'14"), + Bop(And, + Mop(Not,bVar"b'13"), + Bop(And, + Mop(Not,bVar"b'12"), + Bop(And, + Mop(Not, + bVar"b'11"), + Bop(And, + Mop(Not, + bVar"b'10"), + Bop(And, + Mop(Not, + bVar"b'9"), + Bop(And, + Mop(Not, + bVar"b'8"), + Bop(And, + Mop(Not, + bVar"b'7"), + Bop(And, + Mop(Not, + bVar"b'6"), + Bop(And, + Mop(Not, + bVar"b'5"), + Bop(And, + Mop(Not, + bVar"b'4"), + Bop(And, + Mop(Not, + bVar"b'3"), + Bop(And, + Mop(Not, + bVar"b'2"), + Bop(And, + Mop(Not, + bVar"b'1"), + bVar"b'0"))))))))))))))))), + Call + ("MultDiv",CTy"instruction", + Call + ("MADDU",CTy"MultDiv", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24", + bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19", + bVar"b'18",bVar"b'17", + bVar"b'16"])]))), + (Bop(And,Mop(Not,bVar"b'31"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'15"), + Bop(And,Mop(Not,bVar"b'14"), + Bop(And, + Mop(Not,bVar"b'13"), + Bop(And, + Mop(Not,bVar"b'12"), + Bop(And, + Mop(Not, + bVar"b'11"), + Bop(And, + Mop(Not, + bVar"b'10"), + Bop(And, + Mop(Not, + bVar"b'9"), + Bop(And, + Mop(Not, + bVar"b'8"), + Bop(And, + Mop(Not, + bVar"b'7"), + Bop(And, + Mop(Not, + bVar"b'6"), + Bop(And, + Mop(Not, + bVar"b'5"), + Bop(And, + Mop(Not, + bVar"b'4"), + Bop(And, + Mop(Not, + bVar"b'3"), + Bop(And, + bVar"b'2", + Bop(And, + Mop(Not, + bVar"b'1"), + Mop(Not, + bVar"b'0")))))))))))))))))), + Call + ("MultDiv",CTy"instruction", + Call + ("MSUB",CTy"MultDiv", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24", + bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19", + bVar"b'18",bVar"b'17", + bVar"b'16"])]))), + (Bop(And,Mop(Not,bVar"b'31"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'15"), + Bop(And,Mop(Not,bVar"b'14"), + Bop(And, + Mop(Not,bVar"b'13"), + Bop(And, + Mop(Not,bVar"b'12"), + Bop(And, + Mop(Not, + bVar"b'11"), + Bop(And, + Mop(Not, + bVar"b'10"), + Bop(And, + Mop(Not, + bVar"b'9"), + Bop(And, + Mop(Not, + bVar"b'8"), + Bop(And, + Mop(Not, + bVar"b'7"), + Bop(And, + Mop(Not, + bVar"b'6"), + Bop(And, + Mop(Not, + bVar"b'5"), + Bop(And, + Mop(Not, + bVar"b'4"), + Bop(And, + Mop(Not, + bVar"b'3"), + Bop(And, + bVar"b'2", + Bop(And, + Mop(Not, + bVar"b'1"), + bVar"b'0"))))))))))))))))), + Call + ("MultDiv",CTy"instruction", + Call + ("MSUBU",CTy"MultDiv", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24", + bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19", + bVar"b'18",bVar"b'17", + bVar"b'16"])]))), + (Bop(And,Mop(Not,bVar"b'31"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'10"), + Bop(And,Mop(Not,bVar"b'9"), + Bop(And,Mop(Not,bVar"b'8"), + Bop(And, + Mop(Not,bVar"b'7"), + Bop(And, + Mop(Not, + bVar"b'6"), + Bop(And, + Mop(Not, + bVar"b'5"), + Bop(And, + Mop(Not, + bVar"b'4"), + Bop(And, + Mop(Not, + bVar"b'3"), + Bop(And, + Mop(Not, + bVar"b'2"), + Bop(And, + bVar"b'1", + Mop(Not, + bVar"b'0"))))))))))))), + Call + ("MultDiv",CTy"instruction", + Call + ("MUL",CTy"MultDiv", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24", + bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19", + bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14", + bVar"b'13",bVar"b'12", + bVar"b'11"])]))), + (Bop(And,bVar"b'31",Mop(Not,bVar"b'27")), + Call + ("Store",CTy"instruction", + Call + ("SCD",CTy"Store", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24", + bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19", + bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14", + bVar"b'13",bVar"b'12", + bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8", + bVar"b'7",bVar"b'6", + bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2", + bVar"b'1",bVar"b'0"])]))), + (Bop(And,bVar"b'31",bVar"b'27"), + Call + ("SDC2Decode",CTy"instruction", + Mop(Cast(FTy 26), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21",bVar"b'20", + bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16",bVar"b'15",bVar"b'14", + bVar"b'13",bVar"b'12",bVar"b'11", + bVar"b'10",bVar"b'9",bVar"b'8", + bVar"b'7",bVar"b'6",bVar"b'5", + bVar"b'4",bVar"b'3",bVar"b'2", + bVar"b'1",bVar"b'0"])))], + Const("ReservedInstruction",CTy"instruction"))), + (Bop(And,Mop(Not,bVar"b'31"),Mop(Not,bVar"b'27")), + Call + ("ArithI",CTy"instruction", + Call + ("DADDI",CTy"ArithI", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1", + bVar"b'0"])]))), + (Bop(And,Mop(Not,bVar"b'31"),bVar"b'27"), + Call + ("Load",CTy"instruction", + Call + ("LDL",CTy"Load", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1", + bVar"b'0"])]))), + (Bop(And,bVar"b'31",Mop(Not,bVar"b'27")), + Call + ("Store",CTy"instruction", + Call + ("SC",CTy"Store", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1", + bVar"b'0"])]))), + (Bop(And,bVar"b'31",bVar"b'27"), + Call + ("SWC2Decode",CTy"instruction", + Mop(Cast(FTy 26), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21",bVar"b'20", + bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16",bVar"b'15",bVar"b'14", + bVar"b'13",bVar"b'12",bVar"b'11", + bVar"b'10",bVar"b'9",bVar"b'8", + bVar"b'7",bVar"b'6",bVar"b'5", + bVar"b'4",bVar"b'3",bVar"b'2", + bVar"b'1",bVar"b'0"])))], + Const("ReservedInstruction",CTy"instruction"))), + (bVar"b'31", + ITB([(Bop(And,Mop(Not,bVar"b'28"),Mop(Not,bVar"b'27")), + Call + ("Load",CTy"instruction", + Call + ("LL",CTy"Load", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1", + bVar"b'0"])]))), + (Bop(And,bVar"b'28",Mop(Not,bVar"b'27")), + Call + ("Load",CTy"instruction", + Call + ("LLD",CTy"Load", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1", + bVar"b'0"])]))), + (Bop(And,Mop(Not,bVar"b'28"),bVar"b'27"), + Call + ("LWC2Decode",CTy"instruction", + Mop(Cast(FTy 26), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21",bVar"b'20", + bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16",bVar"b'15",bVar"b'14", + bVar"b'13",bVar"b'12",bVar"b'11", + bVar"b'10",bVar"b'9",bVar"b'8", + bVar"b'7",bVar"b'6",bVar"b'5", + bVar"b'4",bVar"b'3",bVar"b'2", + bVar"b'1",bVar"b'0"]))), + (Bop(And,bVar"b'28",bVar"b'27"), + Call + ("LDC2Decode",CTy"instruction", + Mop(Cast(FTy 26), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21",bVar"b'20", + bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16",bVar"b'15",bVar"b'14", + bVar"b'13",bVar"b'12",bVar"b'11", + bVar"b'10",bVar"b'9",bVar"b'8", + bVar"b'7",bVar"b'6",bVar"b'5", + bVar"b'4",bVar"b'3",bVar"b'2", + bVar"b'1",bVar"b'0"])))], + Const("ReservedInstruction",CTy"instruction"))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,bVar"b'25", + Bop(And,Mop(Not,bVar"b'24"), + Bop(And,Mop(Not,bVar"b'23"), + Bop(And,Mop(Not,bVar"b'22"), + Bop(And,Mop(Not,bVar"b'21"), + Bop(And, + Mop(Not,bVar"b'20"), + Bop(And, + Mop(Not,bVar"b'19"), + Bop(And, + Mop(Not, + bVar"b'18"), + Bop(And, + Mop(Not, + bVar"b'17"), + Bop(And, + Mop(Not, + bVar"b'16"), + Bop(And, + Mop(Not, + bVar"b'15"), + Bop(And, + Mop(Not, + bVar"b'14"), + Bop(And, + Mop(Not, + bVar"b'13"), + Bop(And, + Mop(Not, + bVar"b'12"), + Bop(And, + Mop(Not, + bVar"b'11"), + Bop(And, + Mop(Not, + bVar"b'10"), + Bop(And, + Mop(Not, + bVar"b'9"), + Bop(And, + Mop(Not, + bVar"b'8"), + Bop(And, + Mop(Not, + bVar"b'7"), + Bop(And, + Mop(Not, + bVar"b'6"), + Bop(And, + Mop(Not, + bVar"b'5"), + Bop(And, + Mop(Not, + bVar"b'4"), + Bop(And, + Mop(Not, + bVar"b'3"), + Bop(And, + Mop(Not, + bVar"b'2"), + Bop(And, + Mop(Not, + bVar"b'1"), + bVar"b'0"))))))))))))))))))))))))))), + Const("TLBR",CTy"instruction")), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,bVar"b'25", + Bop(And,Mop(Not,bVar"b'24"), + Bop(And,Mop(Not,bVar"b'23"), + Bop(And,Mop(Not,bVar"b'22"), + Bop(And,Mop(Not,bVar"b'21"), + Bop(And, + Mop(Not,bVar"b'20"), + Bop(And, + Mop(Not,bVar"b'19"), + Bop(And, + Mop(Not, + bVar"b'18"), + Bop(And, + Mop(Not, + bVar"b'17"), + Bop(And, + Mop(Not, + bVar"b'16"), + Bop(And, + Mop(Not, + bVar"b'15"), + Bop(And, + Mop(Not, + bVar"b'14"), + Bop(And, + Mop(Not, + bVar"b'13"), + Bop(And, + Mop(Not, + bVar"b'12"), + Bop(And, + Mop(Not, + bVar"b'11"), + Bop(And, + Mop(Not, + bVar"b'10"), + Bop(And, + Mop(Not, + bVar"b'9"), + Bop(And, + Mop(Not, + bVar"b'8"), + Bop(And, + Mop(Not, + bVar"b'7"), + Bop(And, + Mop(Not, + bVar"b'6"), + Bop(And, + Mop(Not, + bVar"b'5"), + Bop(And, + Mop(Not, + bVar"b'4"), + Bop(And, + Mop(Not, + bVar"b'3"), + Bop(And, + Mop(Not, + bVar"b'2"), + Bop(And, + bVar"b'1", + Mop(Not, + bVar"b'0")))))))))))))))))))))))))))), + Const("TLBWI",CTy"instruction")), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,bVar"b'25", + Bop(And,Mop(Not,bVar"b'24"), + Bop(And,Mop(Not,bVar"b'23"), + Bop(And,Mop(Not,bVar"b'22"), + Bop(And,Mop(Not,bVar"b'21"), + Bop(And, + Mop(Not,bVar"b'20"), + Bop(And, + Mop(Not,bVar"b'19"), + Bop(And, + Mop(Not, + bVar"b'18"), + Bop(And, + Mop(Not, + bVar"b'17"), + Bop(And, + Mop(Not, + bVar"b'16"), + Bop(And, + Mop(Not, + bVar"b'15"), + Bop(And, + Mop(Not, + bVar"b'14"), + Bop(And, + Mop(Not, + bVar"b'13"), + Bop(And, + Mop(Not, + bVar"b'12"), + Bop(And, + Mop(Not, + bVar"b'11"), + Bop(And, + Mop(Not, + bVar"b'10"), + Bop(And, + Mop(Not, + bVar"b'9"), + Bop(And, + Mop(Not, + bVar"b'8"), + Bop(And, + Mop(Not, + bVar"b'7"), + Bop(And, + Mop(Not, + bVar"b'6"), + Bop(And, + Mop(Not, + bVar"b'5"), + Bop(And, + Mop(Not, + bVar"b'4"), + Bop(And, + Mop(Not, + bVar"b'3"), + Bop(And, + bVar"b'2", + Bop(And, + bVar"b'1", + Mop(Not, + bVar"b'0")))))))))))))))))))))))))))), + Const("TLBWR",CTy"instruction")), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,bVar"b'25", + Bop(And,Mop(Not,bVar"b'24"), + Bop(And,Mop(Not,bVar"b'23"), + Bop(And,Mop(Not,bVar"b'22"), + Bop(And,Mop(Not,bVar"b'21"), + Bop(And, + Mop(Not,bVar"b'20"), + Bop(And, + Mop(Not,bVar"b'19"), + Bop(And, + Mop(Not, + bVar"b'18"), + Bop(And, + Mop(Not, + bVar"b'17"), + Bop(And, + Mop(Not, + bVar"b'16"), + Bop(And, + Mop(Not, + bVar"b'15"), + Bop(And, + Mop(Not, + bVar"b'14"), + Bop(And, + Mop(Not, + bVar"b'13"), + Bop(And, + Mop(Not, + bVar"b'12"), + Bop(And, + Mop(Not, + bVar"b'11"), + Bop(And, + Mop(Not, + bVar"b'10"), + Bop(And, + Mop(Not, + bVar"b'9"), + Bop(And, + Mop(Not, + bVar"b'8"), + Bop(And, + Mop(Not, + bVar"b'7"), + Bop(And, + Mop(Not, + bVar"b'6"), + Bop(And, + Mop(Not, + bVar"b'5"), + Bop(And, + Mop(Not, + bVar"b'4"), + Bop(And, + bVar"b'3", + Bop(And, + Mop(Not, + bVar"b'2"), + Bop(And, + Mop(Not, + bVar"b'1"), + Mop(Not, + bVar"b'0")))))))))))))))))))))))))))), + Const("TLBP",CTy"instruction")), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,bVar"b'25", + Bop(And,Mop(Not,bVar"b'24"), + Bop(And,Mop(Not,bVar"b'23"), + Bop(And,Mop(Not,bVar"b'22"), + Bop(And,Mop(Not,bVar"b'21"), + Bop(And, + Mop(Not,bVar"b'20"), + Bop(And, + Mop(Not,bVar"b'19"), + Bop(And, + Mop(Not, + bVar"b'18"), + Bop(And, + Mop(Not, + bVar"b'17"), + Bop(And, + Mop(Not, + bVar"b'16"), + Bop(And, + Mop(Not, + bVar"b'15"), + Bop(And, + Mop(Not, + bVar"b'14"), + Bop(And, + Mop(Not, + bVar"b'13"), + Bop(And, + Mop(Not, + bVar"b'12"), + Bop(And, + Mop(Not, + bVar"b'11"), + Bop(And, + Mop(Not, + bVar"b'10"), + Bop(And, + Mop(Not, + bVar"b'9"), + Bop(And, + Mop(Not, + bVar"b'8"), + Bop(And, + Mop(Not, + bVar"b'7"), + Bop(And, + Mop(Not, + bVar"b'6"), + Bop(And, + Mop(Not, + bVar"b'5"), + Bop(And, + bVar"b'4", + Bop(And, + bVar"b'3", + Bop(And, + Mop(Not, + bVar"b'2"), + Bop(And, + Mop(Not, + bVar"b'1"), + Mop(Not, + bVar"b'0")))))))))))))))))))))))))))), + Const("ERET",CTy"instruction")), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'25"), + Bop(And,Mop(Not,bVar"b'24"), + Bop(And,Mop(Not,bVar"b'23"), + Bop(And,Mop(Not,bVar"b'22"), + Bop(And,Mop(Not,bVar"b'21"), + Bop(And, + Mop(Not,bVar"b'10"), + Bop(And, + Mop(Not,bVar"b'9"), + Bop(And, + Mop(Not, + bVar"b'8"), + Bop(And, + Mop(Not, + bVar"b'7"), + Bop(And, + Mop(Not, + bVar"b'6"), + Bop(And, + Mop(Not, + bVar"b'5"), + Bop(And, + Mop(Not, + bVar"b'4"), + Mop(Not, + bVar"b'3"))))))))))))))), + Call + ("CP",CTy"instruction", + Call + ("MFC0",CTy"CP", + TP[Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11"]), + Mop(Cast(FTy 3), + LL[bVar"b'2",bVar"b'1",bVar"b'0"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'25"), + Bop(And,Mop(Not,bVar"b'24"), + Bop(And,Mop(Not,bVar"b'23"), + Bop(And,Mop(Not,bVar"b'22"), + Bop(And,bVar"b'21", + Bop(And, + Mop(Not,bVar"b'10"), + Bop(And, + Mop(Not,bVar"b'9"), + Bop(And, + Mop(Not, + bVar"b'8"), + Bop(And, + Mop(Not, + bVar"b'7"), + Bop(And, + Mop(Not, + bVar"b'6"), + Bop(And, + Mop(Not, + bVar"b'5"), + Bop(And, + Mop(Not, + bVar"b'4"), + Mop(Not, + bVar"b'3"))))))))))))))), + Call + ("CP",CTy"instruction", + Call + ("DMFC0",CTy"CP", + TP[Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11"]), + Mop(Cast(FTy 3), + LL[bVar"b'2",bVar"b'1",bVar"b'0"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'25"), + Bop(And,Mop(Not,bVar"b'24"), + Bop(And,bVar"b'23", + Bop(And,Mop(Not,bVar"b'22"), + Bop(And,Mop(Not,bVar"b'21"), + Bop(And, + Mop(Not,bVar"b'10"), + Bop(And, + Mop(Not,bVar"b'9"), + Bop(And, + Mop(Not, + bVar"b'8"), + Bop(And, + Mop(Not, + bVar"b'7"), + Bop(And, + Mop(Not, + bVar"b'6"), + Bop(And, + Mop(Not, + bVar"b'5"), + Bop(And, + Mop(Not, + bVar"b'4"), + Mop(Not, + bVar"b'3"))))))))))))))), + Call + ("CP",CTy"instruction", + Call + ("MTC0",CTy"CP", + TP[Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11"]), + Mop(Cast(FTy 3), + LL[bVar"b'2",bVar"b'1",bVar"b'0"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'25"), + Bop(And,Mop(Not,bVar"b'24"), + Bop(And,bVar"b'23", + Bop(And,Mop(Not,bVar"b'22"), + Bop(And,bVar"b'21", + Bop(And, + Mop(Not,bVar"b'10"), + Bop(And, + Mop(Not,bVar"b'9"), + Bop(And, + Mop(Not, + bVar"b'8"), + Bop(And, + Mop(Not, + bVar"b'7"), + Bop(And, + Mop(Not, + bVar"b'6"), + Bop(And, + Mop(Not, + bVar"b'5"), + Bop(And, + Mop(Not, + bVar"b'4"), + Mop(Not, + bVar"b'3"))))))))))))))), + Call + ("CP",CTy"instruction", + Call + ("DMTC0",CTy"CP", + TP[Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11"]), + Mop(Cast(FTy 3), + LL[bVar"b'2",bVar"b'1",bVar"b'0"])]))), + (Bop(And,bVar"b'28", + Bop(And,bVar"b'27", + Bop(And,Mop(Not,bVar"b'20"), + Bop(And,Mop(Not,bVar"b'19"), + Bop(And,Mop(Not,bVar"b'18"), + Bop(And,Mop(Not,bVar"b'17"), + Mop(Not,bVar"b'16"))))))), + Call + ("Branch",CTy"instruction", + Call + ("BLEZL",CTy"Branch", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1",bVar"b'0"])]))), + (Bop(And,bVar"b'28",Mop(Not,bVar"b'27")), + Call + ("Branch",CTy"instruction", + Call + ("BEQL",CTy"Branch", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1",bVar"b'0"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,bVar"b'25", + Bop(And,Mop(Not,bVar"b'24"), + Bop(And,Mop(Not,bVar"b'23"), + Bop(And,Mop(Not,bVar"b'22"), + Bop(And,Mop(Not,bVar"b'21"), + Bop(And, + Mop(Not,bVar"b'20"), + Bop(And, + Mop(Not,bVar"b'19"), + Bop(And, + Mop(Not, + bVar"b'18"), + Bop(And, + Mop(Not, + bVar"b'17"), + Bop(And, + Mop(Not, + bVar"b'16"), + Bop(And, + Mop(Not, + bVar"b'15"), + Bop(And, + Mop(Not, + bVar"b'14"), + Bop(And, + Mop(Not, + bVar"b'13"), + Bop(And, + Mop(Not, + bVar"b'12"), + Bop(And, + Mop(Not, + bVar"b'11"), + Bop(And, + Mop(Not, + bVar"b'10"), + Bop(And, + Mop(Not, + bVar"b'9"), + Bop(And, + Mop(Not, + bVar"b'8"), + Bop(And, + Mop(Not, + bVar"b'7"), + Bop(And, + Mop(Not, + bVar"b'6"), + Bop(And, + bVar"b'5", + Bop(And, + Mop(Not, + bVar"b'4"), + Bop(And, + Mop(Not, + bVar"b'3"), + Bop(And, + Mop(Not, + bVar"b'2"), + Bop(And, + Mop(Not, + bVar"b'1"), + Mop(Not, + bVar"b'0")))))))))))))))))))))))))))), + Const("WAIT",CTy"instruction")), + (Bop(And,Mop(Not,bVar"b'28"),bVar"b'27"), + Call + ("COP2Decode",CTy"instruction", + Mop(Cast(FTy 26), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21",bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16",bVar"b'15",bVar"b'14", + bVar"b'13",bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7",bVar"b'6", + bVar"b'5",bVar"b'4",bVar"b'3",bVar"b'2", + bVar"b'1",bVar"b'0"])))], + Const("ReservedInstruction",CTy"instruction"))), + (bVar"b'31", + ITB([(bVar"b'29", + ITB([(Bop(And,Mop(Not,bVar"b'28"),Mop(Not,bVar"b'27")), + Call + ("Store",CTy"instruction", + Call + ("SB",CTy"Store", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1", + bVar"b'0"])]))), + (Bop(And,Mop(Not,bVar"b'28"),bVar"b'27"), + Call + ("Store",CTy"instruction", + Call + ("SWL",CTy"Store", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1", + bVar"b'0"])]))), + (Bop(And,bVar"b'28",Mop(Not,bVar"b'27")), + Call + ("Store",CTy"instruction", + Call + ("SDL",CTy"Store", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1", + bVar"b'0"])]))), + (Bop(And,bVar"b'28",bVar"b'27"), + Call + ("Store",CTy"instruction", + Call + ("SWR",CTy"Store", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1", + bVar"b'0"])])))], + Const("ReservedInstruction",CTy"instruction"))), + (Bop(And,Mop(Not,bVar"b'28"),Mop(Not,bVar"b'27")), + Call + ("Load",CTy"instruction", + Call + ("LB",CTy"Load", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1",bVar"b'0"])]))), + (Bop(And,Mop(Not,bVar"b'28"),bVar"b'27"), + Call + ("Load",CTy"instruction", + Call + ("LWL",CTy"Load", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1",bVar"b'0"])]))), + (Bop(And,bVar"b'28",Mop(Not,bVar"b'27")), + Call + ("Load",CTy"instruction", + Call + ("LBU",CTy"Load", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1",bVar"b'0"])]))), + (Bop(And,bVar"b'28",bVar"b'27"), + Call + ("Load",CTy"instruction", + Call + ("LWR",CTy"Load", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1",bVar"b'0"])])))], + Const("ReservedInstruction",CTy"instruction"))), + (bVar"b'29", + ITB([(Bop(And,Mop(Not,bVar"b'28"),Mop(Not,bVar"b'27")), + Call + ("ArithI",CTy"instruction", + Call + ("ADDI",CTy"ArithI", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1",bVar"b'0"])]))), + (Bop(And,Mop(Not,bVar"b'28"),bVar"b'27"), + Call + ("ArithI",CTy"instruction", + Call + ("SLTI",CTy"ArithI", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1",bVar"b'0"])]))), + (Bop(And,bVar"b'28",Mop(Not,bVar"b'27")), + Call + ("ArithI",CTy"instruction", + Call + ("ANDI",CTy"ArithI", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1",bVar"b'0"])]))), + (Bop(And,bVar"b'28",bVar"b'27"), + Call + ("ArithI",CTy"instruction", + Call + ("XORI",CTy"ArithI", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23", + bVar"b'22",bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13", + bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1",bVar"b'0"])])))], + Const("ReservedInstruction",CTy"instruction"))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'25"), + Bop(And,Mop(Not,bVar"b'24"), + Bop(And,Mop(Not,bVar"b'23"), + Bop(And,Mop(Not,bVar"b'22"), + Bop(And,Mop(Not,bVar"b'21"), + Bop(And,Mop(Not,bVar"b'5"), + Bop(And,Mop(Not,bVar"b'4"), + Bop(And, + Mop(Not,bVar"b'3"), + Bop(And, + Mop(Not,bVar"b'2"), + Bop(And, + Mop(Not, + bVar"b'1"), + Mop(Not, + bVar"b'0"))))))))))))), + Call + ("Shift",CTy"instruction", + Call + ("SLL",CTy"Shift", + TP[Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13",bVar"b'12", + bVar"b'11"]), + Mop(Cast(FTy 5), + LL[bVar"b'10",bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'25"), + Bop(And,Mop(Not,bVar"b'24"), + Bop(And,Mop(Not,bVar"b'23"), + Bop(And,Mop(Not,bVar"b'22"), + Bop(And,Mop(Not,bVar"b'21"), + Bop(And,Mop(Not,bVar"b'5"), + Bop(And,Mop(Not,bVar"b'4"), + Bop(And, + Mop(Not,bVar"b'3"), + Bop(And, + Mop(Not,bVar"b'2"), + Bop(And, + bVar"b'1", + Mop(Not, + bVar"b'0"))))))))))))), + Call + ("Shift",CTy"instruction", + Call + ("SRL",CTy"Shift", + TP[Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13",bVar"b'12", + bVar"b'11"]), + Mop(Cast(FTy 5), + LL[bVar"b'10",bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'25"), + Bop(And,Mop(Not,bVar"b'24"), + Bop(And,Mop(Not,bVar"b'23"), + Bop(And,Mop(Not,bVar"b'22"), + Bop(And,Mop(Not,bVar"b'21"), + Bop(And,Mop(Not,bVar"b'5"), + Bop(And,Mop(Not,bVar"b'4"), + Bop(And, + Mop(Not,bVar"b'3"), + Bop(And, + Mop(Not,bVar"b'2"), + Bop(And, + bVar"b'1", + bVar"b'0")))))))))))), + Call + ("Shift",CTy"instruction", + Call + ("SRA",CTy"Shift", + TP[Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13",bVar"b'12", + bVar"b'11"]), + Mop(Cast(FTy 5), + LL[bVar"b'10",bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'10"), + Bop(And,Mop(Not,bVar"b'9"), + Bop(And,Mop(Not,bVar"b'8"), + Bop(And,Mop(Not,bVar"b'7"), + Bop(And,Mop(Not,bVar"b'6"), + Bop(And,Mop(Not,bVar"b'5"), + Bop(And,Mop(Not,bVar"b'4"), + Bop(And, + Mop(Not,bVar"b'3"), + Bop(And,bVar"b'2", + Bop(And, + Mop(Not, + bVar"b'1"), + Mop(Not, + bVar"b'0"))))))))))))), + Call + ("Shift",CTy"instruction", + Call + ("SLLV",CTy"Shift", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13",bVar"b'12", + bVar"b'11"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'10"), + Bop(And,Mop(Not,bVar"b'9"), + Bop(And,Mop(Not,bVar"b'8"), + Bop(And,Mop(Not,bVar"b'7"), + Bop(And,Mop(Not,bVar"b'6"), + Bop(And,Mop(Not,bVar"b'5"), + Bop(And,Mop(Not,bVar"b'4"), + Bop(And, + Mop(Not,bVar"b'3"), + Bop(And,bVar"b'2", + Bop(And, + bVar"b'1", + Mop(Not, + bVar"b'0"))))))))))))), + Call + ("Shift",CTy"instruction", + Call + ("SRLV",CTy"Shift", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13",bVar"b'12", + bVar"b'11"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'10"), + Bop(And,Mop(Not,bVar"b'9"), + Bop(And,Mop(Not,bVar"b'8"), + Bop(And,Mop(Not,bVar"b'7"), + Bop(And,Mop(Not,bVar"b'6"), + Bop(And,Mop(Not,bVar"b'5"), + Bop(And,Mop(Not,bVar"b'4"), + Bop(And, + Mop(Not,bVar"b'3"), + Bop(And,bVar"b'2", + Bop(And, + bVar"b'1", + bVar"b'0")))))))))))), + Call + ("Shift",CTy"instruction", + Call + ("SRAV",CTy"Shift", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13",bVar"b'12", + bVar"b'11"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'20"), + Bop(And,Mop(Not,bVar"b'19"), + Bop(And,Mop(Not,bVar"b'18"), + Bop(And,Mop(Not,bVar"b'17"), + Bop(And,Mop(Not,bVar"b'16"), + Bop(And,Mop(Not,bVar"b'15"), + Bop(And,Mop(Not,bVar"b'14"), + Bop(And, + Mop(Not,bVar"b'13"), + Bop(And, + Mop(Not, + bVar"b'12"), + Bop(And, + Mop(Not, + bVar"b'11"), + Bop(And, + Mop(Not, + bVar"b'5"), + Bop(And, + Mop(Not, + bVar"b'4"), + Bop(And, + bVar"b'3", + Bop(And, + Mop(Not, + bVar"b'2"), + Bop(And, + Mop(Not, + bVar"b'1"), + Mop(Not, + bVar"b'0")))))))))))))))))), + Call + ("Branch",CTy"instruction", + Call + ("JR",CTy"Branch", + Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21"])))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'20"), + Bop(And,Mop(Not,bVar"b'19"), + Bop(And,Mop(Not,bVar"b'18"), + Bop(And,Mop(Not,bVar"b'17"), + Bop(And,Mop(Not,bVar"b'16"), + Bop(And,Mop(Not,bVar"b'5"), + Bop(And,Mop(Not,bVar"b'4"), + Bop(And,bVar"b'3", + Bop(And, + Mop(Not,bVar"b'2"), + Bop(And, + Mop(Not, + bVar"b'1"), + bVar"b'0")))))))))))), + Call + ("Branch",CTy"instruction", + Call + ("JALR",CTy"Branch", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13",bVar"b'12", + bVar"b'11"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'10"), + Bop(And,Mop(Not,bVar"b'9"), + Bop(And,Mop(Not,bVar"b'8"), + Bop(And,Mop(Not,bVar"b'7"), + Bop(And,Mop(Not,bVar"b'6"), + Bop(And,Mop(Not,bVar"b'5"), + Bop(And,Mop(Not,bVar"b'4"), + Bop(And,bVar"b'3", + Bop(And, + Mop(Not,bVar"b'2"), + Bop(And, + bVar"b'1", + Mop(Not, + bVar"b'0"))))))))))))), + Call + ("ArithR",CTy"instruction", + Call + ("MOVZ",CTy"ArithR", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13",bVar"b'12", + bVar"b'11"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'10"), + Bop(And,Mop(Not,bVar"b'9"), + Bop(And,Mop(Not,bVar"b'8"), + Bop(And,Mop(Not,bVar"b'7"), + Bop(And,Mop(Not,bVar"b'6"), + Bop(And,Mop(Not,bVar"b'5"), + Bop(And,Mop(Not,bVar"b'4"), + Bop(And,bVar"b'3", + Bop(And, + Mop(Not,bVar"b'2"), + Bop(And, + bVar"b'1", + bVar"b'0")))))))))))), + Call + ("ArithR",CTy"instruction", + Call + ("MOVN",CTy"ArithR", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13",bVar"b'12", + bVar"b'11"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'25"), + Bop(And,Mop(Not,bVar"b'24"), + Bop(And,Mop(Not,bVar"b'23"), + Bop(And,Mop(Not,bVar"b'22"), + Bop(And,Mop(Not,bVar"b'21"), + Bop(And,Mop(Not,bVar"b'5"), + Bop(And,Mop(Not,bVar"b'4"), + Bop(And,bVar"b'3", + Bop(And,bVar"b'2", + Bop(And, + Mop(Not, + bVar"b'1"), + Mop(Not, + bVar"b'0"))))))))))))), + Const("SYSCALL",CTy"instruction")), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'25"), + Bop(And,Mop(Not,bVar"b'24"), + Bop(And,Mop(Not,bVar"b'23"), + Bop(And,Mop(Not,bVar"b'22"), + Bop(And,Mop(Not,bVar"b'21"), + Bop(And,Mop(Not,bVar"b'5"), + Bop(And,Mop(Not,bVar"b'4"), + Bop(And,bVar"b'3", + Bop(And,bVar"b'2", + Bop(And, + Mop(Not, + bVar"b'1"), + bVar"b'0")))))))))))), + Const("BREAK",CTy"instruction")), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'25"), + Bop(And,Mop(Not,bVar"b'24"), + Bop(And,Mop(Not,bVar"b'23"), + Bop(And,Mop(Not,bVar"b'22"), + Bop(And,Mop(Not,bVar"b'21"), + Bop(And,Mop(Not,bVar"b'20"), + Bop(And,Mop(Not,bVar"b'19"), + Bop(And, + Mop(Not,bVar"b'18"), + Bop(And, + Mop(Not, + bVar"b'17"), + Bop(And, + Mop(Not, + bVar"b'16"), + Bop(And, + Mop(Not, + bVar"b'15"), + Bop(And, + Mop(Not, + bVar"b'14"), + Bop(And, + Mop(Not, + bVar"b'13"), + Bop(And, + Mop(Not, + bVar"b'12"), + Bop(And, + Mop(Not, + bVar"b'11"), + Bop(And, + Mop(Not, + bVar"b'5"), + Bop(And, + Mop(Not, + bVar"b'4"), + Bop(And, + bVar"b'3", + Bop(And, + bVar"b'2", + Bop(And, + bVar"b'1", + bVar"b'0")))))))))))))))))))))), + Call + ("SYNC",CTy"instruction", + Mop(Cast(FTy 5), + LL[bVar"b'10",bVar"b'9",bVar"b'8",bVar"b'7",bVar"b'6"]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'25"), + Bop(And,Mop(Not,bVar"b'24"), + Bop(And,Mop(Not,bVar"b'23"), + Bop(And,Mop(Not,bVar"b'22"), + Bop(And,Mop(Not,bVar"b'21"), + Bop(And,Mop(Not,bVar"b'20"), + Bop(And,Mop(Not,bVar"b'19"), + Bop(And, + Mop(Not,bVar"b'18"), + Bop(And, + Mop(Not, + bVar"b'17"), + Bop(And, + Mop(Not, + bVar"b'16"), + Bop(And, + Mop(Not, + bVar"b'10"), + Bop(And, + Mop(Not, + bVar"b'9"), + Bop(And, + Mop(Not, + bVar"b'8"), + Bop(And, + Mop(Not, + bVar"b'7"), + Bop(And, + Mop(Not, + bVar"b'6"), + Bop(And, + Mop(Not, + bVar"b'5"), + Bop(And, + bVar"b'4", + Bop(And, + Mop(Not, + bVar"b'3"), + Bop(And, + Mop(Not, + bVar"b'2"), + Bop(And, + Mop(Not, + bVar"b'1"), + Mop(Not, + bVar"b'0"))))))))))))))))))))))), + Call + ("MultDiv",CTy"instruction", + Call + ("MFHI",CTy"MultDiv", + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13",bVar"b'12", + bVar"b'11"])))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'20"), + Bop(And,Mop(Not,bVar"b'19"), + Bop(And,Mop(Not,bVar"b'18"), + Bop(And,Mop(Not,bVar"b'17"), + Bop(And,Mop(Not,bVar"b'16"), + Bop(And,Mop(Not,bVar"b'15"), + Bop(And,Mop(Not,bVar"b'14"), + Bop(And, + Mop(Not,bVar"b'13"), + Bop(And, + Mop(Not, + bVar"b'12"), + Bop(And, + Mop(Not, + bVar"b'11"), + Bop(And, + Mop(Not, + bVar"b'10"), + Bop(And, + Mop(Not, + bVar"b'9"), + Bop(And, + Mop(Not, + bVar"b'8"), + Bop(And, + Mop(Not, + bVar"b'7"), + Bop(And, + Mop(Not, + bVar"b'6"), + Bop(And, + Mop(Not, + bVar"b'5"), + Bop(And, + bVar"b'4", + Bop(And, + Mop(Not, + bVar"b'3"), + Bop(And, + Mop(Not, + bVar"b'2"), + Bop(And, + Mop(Not, + bVar"b'1"), + bVar"b'0")))))))))))))))))))))), + Call + ("MultDiv",CTy"instruction", + Call + ("MTHI",CTy"MultDiv", + Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21"])))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'25"), + Bop(And,Mop(Not,bVar"b'24"), + Bop(And,Mop(Not,bVar"b'23"), + Bop(And,Mop(Not,bVar"b'22"), + Bop(And,Mop(Not,bVar"b'21"), + Bop(And,Mop(Not,bVar"b'20"), + Bop(And,Mop(Not,bVar"b'19"), + Bop(And, + Mop(Not,bVar"b'18"), + Bop(And, + Mop(Not, + bVar"b'17"), + Bop(And, + Mop(Not, + bVar"b'16"), + Bop(And, + Mop(Not, + bVar"b'10"), + Bop(And, + Mop(Not, + bVar"b'9"), + Bop(And, + Mop(Not, + bVar"b'8"), + Bop(And, + Mop(Not, + bVar"b'7"), + Bop(And, + Mop(Not, + bVar"b'6"), + Bop(And, + Mop(Not, + bVar"b'5"), + Bop(And, + bVar"b'4", + Bop(And, + Mop(Not, + bVar"b'3"), + Bop(And, + Mop(Not, + bVar"b'2"), + Bop(And, + bVar"b'1", + Mop(Not, + bVar"b'0"))))))))))))))))))))))), + Call + ("MultDiv",CTy"instruction", + Call + ("MFLO",CTy"MultDiv", + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13",bVar"b'12", + bVar"b'11"])))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'20"), + Bop(And,Mop(Not,bVar"b'19"), + Bop(And,Mop(Not,bVar"b'18"), + Bop(And,Mop(Not,bVar"b'17"), + Bop(And,Mop(Not,bVar"b'16"), + Bop(And,Mop(Not,bVar"b'15"), + Bop(And,Mop(Not,bVar"b'14"), + Bop(And, + Mop(Not,bVar"b'13"), + Bop(And, + Mop(Not, + bVar"b'12"), + Bop(And, + Mop(Not, + bVar"b'11"), + Bop(And, + Mop(Not, + bVar"b'10"), + Bop(And, + Mop(Not, + bVar"b'9"), + Bop(And, + Mop(Not, + bVar"b'8"), + Bop(And, + Mop(Not, + bVar"b'7"), + Bop(And, + Mop(Not, + bVar"b'6"), + Bop(And, + Mop(Not, + bVar"b'5"), + Bop(And, + bVar"b'4", + Bop(And, + Mop(Not, + bVar"b'3"), + Bop(And, + Mop(Not, + bVar"b'2"), + Bop(And, + bVar"b'1", + bVar"b'0")))))))))))))))))))))), + Call + ("MultDiv",CTy"instruction", + Call + ("MTLO",CTy"MultDiv", + Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21"])))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'10"), + Bop(And,Mop(Not,bVar"b'9"), + Bop(And,Mop(Not,bVar"b'8"), + Bop(And,Mop(Not,bVar"b'7"), + Bop(And,Mop(Not,bVar"b'6"), + Bop(And,Mop(Not,bVar"b'5"), + Bop(And,bVar"b'4", + Bop(And, + Mop(Not,bVar"b'3"), + Bop(And,bVar"b'2", + Bop(And, + Mop(Not, + bVar"b'1"), + Mop(Not, + bVar"b'0"))))))))))))), + Call + ("Shift",CTy"instruction", + Call + ("DSLLV",CTy"Shift", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13",bVar"b'12", + bVar"b'11"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'10"), + Bop(And,Mop(Not,bVar"b'9"), + Bop(And,Mop(Not,bVar"b'8"), + Bop(And,Mop(Not,bVar"b'7"), + Bop(And,Mop(Not,bVar"b'6"), + Bop(And,Mop(Not,bVar"b'5"), + Bop(And,bVar"b'4", + Bop(And, + Mop(Not,bVar"b'3"), + Bop(And,bVar"b'2", + Bop(And, + bVar"b'1", + Mop(Not, + bVar"b'0"))))))))))))), + Call + ("Shift",CTy"instruction", + Call + ("DSRLV",CTy"Shift", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13",bVar"b'12", + bVar"b'11"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'10"), + Bop(And,Mop(Not,bVar"b'9"), + Bop(And,Mop(Not,bVar"b'8"), + Bop(And,Mop(Not,bVar"b'7"), + Bop(And,Mop(Not,bVar"b'6"), + Bop(And,Mop(Not,bVar"b'5"), + Bop(And,bVar"b'4", + Bop(And, + Mop(Not,bVar"b'3"), + Bop(And,bVar"b'2", + Bop(And, + bVar"b'1", + bVar"b'0")))))))))))), + Call + ("Shift",CTy"instruction", + Call + ("DSRAV",CTy"Shift", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13",bVar"b'12", + bVar"b'11"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'15"), + Bop(And,Mop(Not,bVar"b'14"), + Bop(And,Mop(Not,bVar"b'13"), + Bop(And,Mop(Not,bVar"b'12"), + Bop(And,Mop(Not,bVar"b'11"), + Bop(And,Mop(Not,bVar"b'10"), + Bop(And,Mop(Not,bVar"b'9"), + Bop(And, + Mop(Not,bVar"b'8"), + Bop(And, + Mop(Not,bVar"b'7"), + Bop(And, + Mop(Not, + bVar"b'6"), + Bop(And, + Mop(Not, + bVar"b'5"), + Bop(And, + bVar"b'4", + Bop(And, + bVar"b'3", + Bop(And, + Mop(Not, + bVar"b'2"), + Bop(And, + Mop(Not, + bVar"b'1"), + Mop(Not, + bVar"b'0")))))))))))))))))), + Call + ("MultDiv",CTy"instruction", + Call + ("MULT",CTy"MultDiv", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'15"), + Bop(And,Mop(Not,bVar"b'14"), + Bop(And,Mop(Not,bVar"b'13"), + Bop(And,Mop(Not,bVar"b'12"), + Bop(And,Mop(Not,bVar"b'11"), + Bop(And,Mop(Not,bVar"b'10"), + Bop(And,Mop(Not,bVar"b'9"), + Bop(And, + Mop(Not,bVar"b'8"), + Bop(And, + Mop(Not,bVar"b'7"), + Bop(And, + Mop(Not, + bVar"b'6"), + Bop(And, + Mop(Not, + bVar"b'5"), + Bop(And, + bVar"b'4", + Bop(And, + bVar"b'3", + Bop(And, + Mop(Not, + bVar"b'2"), + Bop(And, + Mop(Not, + bVar"b'1"), + bVar"b'0"))))))))))))))))), + Call + ("MultDiv",CTy"instruction", + Call + ("MULTU",CTy"MultDiv", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'15"), + Bop(And,Mop(Not,bVar"b'14"), + Bop(And,Mop(Not,bVar"b'13"), + Bop(And,Mop(Not,bVar"b'12"), + Bop(And,Mop(Not,bVar"b'11"), + Bop(And,Mop(Not,bVar"b'10"), + Bop(And,Mop(Not,bVar"b'9"), + Bop(And, + Mop(Not,bVar"b'8"), + Bop(And, + Mop(Not,bVar"b'7"), + Bop(And, + Mop(Not, + bVar"b'6"), + Bop(And, + Mop(Not, + bVar"b'5"), + Bop(And, + bVar"b'4", + Bop(And, + bVar"b'3", + Bop(And, + Mop(Not, + bVar"b'2"), + Bop(And, + bVar"b'1", + Mop(Not, + bVar"b'0")))))))))))))))))), + Call + ("MultDiv",CTy"instruction", + Call + ("DIV",CTy"MultDiv", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'15"), + Bop(And,Mop(Not,bVar"b'14"), + Bop(And,Mop(Not,bVar"b'13"), + Bop(And,Mop(Not,bVar"b'12"), + Bop(And,Mop(Not,bVar"b'11"), + Bop(And,Mop(Not,bVar"b'10"), + Bop(And,Mop(Not,bVar"b'9"), + Bop(And, + Mop(Not,bVar"b'8"), + Bop(And, + Mop(Not,bVar"b'7"), + Bop(And, + Mop(Not, + bVar"b'6"), + Bop(And, + Mop(Not, + bVar"b'5"), + Bop(And, + bVar"b'4", + Bop(And, + bVar"b'3", + Bop(And, + Mop(Not, + bVar"b'2"), + Bop(And, + bVar"b'1", + bVar"b'0"))))))))))))))))), + Call + ("MultDiv",CTy"instruction", + Call + ("DIVU",CTy"MultDiv", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'15"), + Bop(And,Mop(Not,bVar"b'14"), + Bop(And,Mop(Not,bVar"b'13"), + Bop(And,Mop(Not,bVar"b'12"), + Bop(And,Mop(Not,bVar"b'11"), + Bop(And,Mop(Not,bVar"b'10"), + Bop(And,Mop(Not,bVar"b'9"), + Bop(And, + Mop(Not,bVar"b'8"), + Bop(And, + Mop(Not,bVar"b'7"), + Bop(And, + Mop(Not, + bVar"b'6"), + Bop(And, + Mop(Not, + bVar"b'5"), + Bop(And, + bVar"b'4", + Bop(And, + bVar"b'3", + Bop(And, + bVar"b'2", + Bop(And, + Mop(Not, + bVar"b'1"), + Mop(Not, + bVar"b'0")))))))))))))))))), + Call + ("MultDiv",CTy"instruction", + Call + ("DMULT",CTy"MultDiv", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'15"), + Bop(And,Mop(Not,bVar"b'14"), + Bop(And,Mop(Not,bVar"b'13"), + Bop(And,Mop(Not,bVar"b'12"), + Bop(And,Mop(Not,bVar"b'11"), + Bop(And,Mop(Not,bVar"b'10"), + Bop(And,Mop(Not,bVar"b'9"), + Bop(And, + Mop(Not,bVar"b'8"), + Bop(And, + Mop(Not,bVar"b'7"), + Bop(And, + Mop(Not, + bVar"b'6"), + Bop(And, + Mop(Not, + bVar"b'5"), + Bop(And, + bVar"b'4", + Bop(And, + bVar"b'3", + Bop(And, + bVar"b'2", + Bop(And, + Mop(Not, + bVar"b'1"), + bVar"b'0"))))))))))))))))), + Call + ("MultDiv",CTy"instruction", + Call + ("DMULTU",CTy"MultDiv", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'15"), + Bop(And,Mop(Not,bVar"b'14"), + Bop(And,Mop(Not,bVar"b'13"), + Bop(And,Mop(Not,bVar"b'12"), + Bop(And,Mop(Not,bVar"b'11"), + Bop(And,Mop(Not,bVar"b'10"), + Bop(And,Mop(Not,bVar"b'9"), + Bop(And, + Mop(Not,bVar"b'8"), + Bop(And, + Mop(Not,bVar"b'7"), + Bop(And, + Mop(Not, + bVar"b'6"), + Bop(And, + Mop(Not, + bVar"b'5"), + Bop(And, + bVar"b'4", + Bop(And, + bVar"b'3", + Bop(And, + bVar"b'2", + Bop(And, + bVar"b'1", + Mop(Not, + bVar"b'0")))))))))))))))))), + Call + ("MultDiv",CTy"instruction", + Call + ("DDIV",CTy"MultDiv", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'15"), + Bop(And,Mop(Not,bVar"b'14"), + Bop(And,Mop(Not,bVar"b'13"), + Bop(And,Mop(Not,bVar"b'12"), + Bop(And,Mop(Not,bVar"b'11"), + Bop(And,Mop(Not,bVar"b'10"), + Bop(And,Mop(Not,bVar"b'9"), + Bop(And, + Mop(Not,bVar"b'8"), + Bop(And, + Mop(Not,bVar"b'7"), + Bop(And, + Mop(Not, + bVar"b'6"), + Bop(And, + Mop(Not, + bVar"b'5"), + Bop(And, + bVar"b'4", + Bop(And, + bVar"b'3", + Bop(And, + bVar"b'2", + Bop(And, + bVar"b'1", + bVar"b'0"))))))))))))))))), + Call + ("MultDiv",CTy"instruction", + Call + ("DDIVU",CTy"MultDiv", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'10"), + Bop(And,Mop(Not,bVar"b'9"), + Bop(And,Mop(Not,bVar"b'8"), + Bop(And,Mop(Not,bVar"b'7"), + Bop(And,Mop(Not,bVar"b'6"), + Bop(And,bVar"b'5", + Bop(And,Mop(Not,bVar"b'4"), + Bop(And, + Mop(Not,bVar"b'3"), + Bop(And, + Mop(Not,bVar"b'2"), + Bop(And, + Mop(Not, + bVar"b'1"), + Mop(Not, + bVar"b'0"))))))))))))), + Call + ("ArithR",CTy"instruction", + Call + ("ADD",CTy"ArithR", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13",bVar"b'12", + bVar"b'11"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'10"), + Bop(And,Mop(Not,bVar"b'9"), + Bop(And,Mop(Not,bVar"b'8"), + Bop(And,Mop(Not,bVar"b'7"), + Bop(And,Mop(Not,bVar"b'6"), + Bop(And,bVar"b'5", + Bop(And,Mop(Not,bVar"b'4"), + Bop(And, + Mop(Not,bVar"b'3"), + Bop(And, + Mop(Not,bVar"b'2"), + Bop(And, + Mop(Not, + bVar"b'1"), + bVar"b'0")))))))))))), + Call + ("ArithR",CTy"instruction", + Call + ("ADDU",CTy"ArithR", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13",bVar"b'12", + bVar"b'11"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'10"), + Bop(And,Mop(Not,bVar"b'9"), + Bop(And,Mop(Not,bVar"b'8"), + Bop(And,Mop(Not,bVar"b'7"), + Bop(And,Mop(Not,bVar"b'6"), + Bop(And,bVar"b'5", + Bop(And,Mop(Not,bVar"b'4"), + Bop(And, + Mop(Not,bVar"b'3"), + Bop(And, + Mop(Not,bVar"b'2"), + Bop(And, + bVar"b'1", + Mop(Not, + bVar"b'0"))))))))))))), + Call + ("ArithR",CTy"instruction", + Call + ("SUB",CTy"ArithR", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13",bVar"b'12", + bVar"b'11"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'10"), + Bop(And,Mop(Not,bVar"b'9"), + Bop(And,Mop(Not,bVar"b'8"), + Bop(And,Mop(Not,bVar"b'7"), + Bop(And,Mop(Not,bVar"b'6"), + Bop(And,bVar"b'5", + Bop(And,Mop(Not,bVar"b'4"), + Bop(And, + Mop(Not,bVar"b'3"), + Bop(And, + Mop(Not,bVar"b'2"), + Bop(And, + bVar"b'1", + bVar"b'0")))))))))))), + Call + ("ArithR",CTy"instruction", + Call + ("SUBU",CTy"ArithR", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13",bVar"b'12", + bVar"b'11"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'10"), + Bop(And,Mop(Not,bVar"b'9"), + Bop(And,Mop(Not,bVar"b'8"), + Bop(And,Mop(Not,bVar"b'7"), + Bop(And,Mop(Not,bVar"b'6"), + Bop(And,bVar"b'5", + Bop(And,Mop(Not,bVar"b'4"), + Bop(And, + Mop(Not,bVar"b'3"), + Bop(And,bVar"b'2", + Bop(And, + Mop(Not, + bVar"b'1"), + Mop(Not, + bVar"b'0"))))))))))))), + Call + ("ArithR",CTy"instruction", + Call + ("AND",CTy"ArithR", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13",bVar"b'12", + bVar"b'11"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'10"), + Bop(And,Mop(Not,bVar"b'9"), + Bop(And,Mop(Not,bVar"b'8"), + Bop(And,Mop(Not,bVar"b'7"), + Bop(And,Mop(Not,bVar"b'6"), + Bop(And,bVar"b'5", + Bop(And,Mop(Not,bVar"b'4"), + Bop(And, + Mop(Not,bVar"b'3"), + Bop(And,bVar"b'2", + Bop(And, + Mop(Not, + bVar"b'1"), + bVar"b'0")))))))))))), + Call + ("ArithR",CTy"instruction", + Call + ("OR",CTy"ArithR", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13",bVar"b'12", + bVar"b'11"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'10"), + Bop(And,Mop(Not,bVar"b'9"), + Bop(And,Mop(Not,bVar"b'8"), + Bop(And,Mop(Not,bVar"b'7"), + Bop(And,Mop(Not,bVar"b'6"), + Bop(And,bVar"b'5", + Bop(And,Mop(Not,bVar"b'4"), + Bop(And, + Mop(Not,bVar"b'3"), + Bop(And,bVar"b'2", + Bop(And, + bVar"b'1", + Mop(Not, + bVar"b'0"))))))))))))), + Call + ("ArithR",CTy"instruction", + Call + ("XOR",CTy"ArithR", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13",bVar"b'12", + bVar"b'11"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'10"), + Bop(And,Mop(Not,bVar"b'9"), + Bop(And,Mop(Not,bVar"b'8"), + Bop(And,Mop(Not,bVar"b'7"), + Bop(And,Mop(Not,bVar"b'6"), + Bop(And,bVar"b'5", + Bop(And,Mop(Not,bVar"b'4"), + Bop(And, + Mop(Not,bVar"b'3"), + Bop(And,bVar"b'2", + Bop(And, + bVar"b'1", + bVar"b'0")))))))))))), + Call + ("ArithR",CTy"instruction", + Call + ("NOR",CTy"ArithR", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13",bVar"b'12", + bVar"b'11"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'10"), + Bop(And,Mop(Not,bVar"b'9"), + Bop(And,Mop(Not,bVar"b'8"), + Bop(And,Mop(Not,bVar"b'7"), + Bop(And,Mop(Not,bVar"b'6"), + Bop(And,bVar"b'5", + Bop(And,Mop(Not,bVar"b'4"), + Bop(And,bVar"b'3", + Bop(And, + Mop(Not,bVar"b'2"), + Bop(And, + bVar"b'1", + Mop(Not, + bVar"b'0"))))))))))))), + Call + ("ArithR",CTy"instruction", + Call + ("SLT",CTy"ArithR", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13",bVar"b'12", + bVar"b'11"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'10"), + Bop(And,Mop(Not,bVar"b'9"), + Bop(And,Mop(Not,bVar"b'8"), + Bop(And,Mop(Not,bVar"b'7"), + Bop(And,Mop(Not,bVar"b'6"), + Bop(And,bVar"b'5", + Bop(And,Mop(Not,bVar"b'4"), + Bop(And,bVar"b'3", + Bop(And, + Mop(Not,bVar"b'2"), + Bop(And, + bVar"b'1", + bVar"b'0")))))))))))), + Call + ("ArithR",CTy"instruction", + Call + ("SLTU",CTy"ArithR", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13",bVar"b'12", + bVar"b'11"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'10"), + Bop(And,Mop(Not,bVar"b'9"), + Bop(And,Mop(Not,bVar"b'8"), + Bop(And,Mop(Not,bVar"b'7"), + Bop(And,Mop(Not,bVar"b'6"), + Bop(And,bVar"b'5", + Bop(And,Mop(Not,bVar"b'4"), + Bop(And,bVar"b'3", + Bop(And,bVar"b'2", + Bop(And, + Mop(Not, + bVar"b'1"), + Mop(Not, + bVar"b'0"))))))))))))), + Call + ("ArithR",CTy"instruction", + Call + ("DADD",CTy"ArithR", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13",bVar"b'12", + bVar"b'11"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'10"), + Bop(And,Mop(Not,bVar"b'9"), + Bop(And,Mop(Not,bVar"b'8"), + Bop(And,Mop(Not,bVar"b'7"), + Bop(And,Mop(Not,bVar"b'6"), + Bop(And,bVar"b'5", + Bop(And,Mop(Not,bVar"b'4"), + Bop(And,bVar"b'3", + Bop(And,bVar"b'2", + Bop(And, + Mop(Not, + bVar"b'1"), + bVar"b'0")))))))))))), + Call + ("ArithR",CTy"instruction", + Call + ("DADDU",CTy"ArithR", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13",bVar"b'12", + bVar"b'11"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'10"), + Bop(And,Mop(Not,bVar"b'9"), + Bop(And,Mop(Not,bVar"b'8"), + Bop(And,Mop(Not,bVar"b'7"), + Bop(And,Mop(Not,bVar"b'6"), + Bop(And,bVar"b'5", + Bop(And,Mop(Not,bVar"b'4"), + Bop(And,bVar"b'3", + Bop(And,bVar"b'2", + Bop(And, + bVar"b'1", + Mop(Not, + bVar"b'0"))))))))))))), + Call + ("ArithR",CTy"instruction", + Call + ("DSUB",CTy"ArithR", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13",bVar"b'12", + bVar"b'11"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'10"), + Bop(And,Mop(Not,bVar"b'9"), + Bop(And,Mop(Not,bVar"b'8"), + Bop(And,Mop(Not,bVar"b'7"), + Bop(And,Mop(Not,bVar"b'6"), + Bop(And,bVar"b'5", + Bop(And,Mop(Not,bVar"b'4"), + Bop(And,bVar"b'3", + Bop(And,bVar"b'2", + Bop(And, + bVar"b'1", + bVar"b'0")))))))))))), + Call + ("ArithR",CTy"instruction", + Call + ("DSUBU",CTy"ArithR", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13",bVar"b'12", + bVar"b'11"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,bVar"b'5", + Bop(And,bVar"b'4", + Bop(And,Mop(Not,bVar"b'3"), + Bop(And,Mop(Not,bVar"b'2"), + Bop(And,Mop(Not,bVar"b'1"), + Mop(Not,bVar"b'0")))))))), + Call + ("Trap",CTy"instruction", + Call + ("TGE",CTy"Trap", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,bVar"b'5", + Bop(And,bVar"b'4", + Bop(And,Mop(Not,bVar"b'3"), + Bop(And,Mop(Not,bVar"b'2"), + Bop(And,Mop(Not,bVar"b'1"),bVar"b'0"))))))), + Call + ("Trap",CTy"instruction", + Call + ("TGEU",CTy"Trap", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,bVar"b'5", + Bop(And,bVar"b'4", + Bop(And,Mop(Not,bVar"b'3"), + Bop(And,Mop(Not,bVar"b'2"), + Bop(And,bVar"b'1",Mop(Not,bVar"b'0")))))))), + Call + ("Trap",CTy"instruction", + Call + ("TLT",CTy"Trap", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,bVar"b'5", + Bop(And,bVar"b'4", + Bop(And,Mop(Not,bVar"b'3"), + Bop(And,Mop(Not,bVar"b'2"), + Bop(And,bVar"b'1",bVar"b'0"))))))), + Call + ("Trap",CTy"instruction", + Call + ("TLTU",CTy"Trap", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,bVar"b'5", + Bop(And,bVar"b'4", + Bop(And,Mop(Not,bVar"b'3"), + Bop(And,bVar"b'2", + Bop(And,Mop(Not,bVar"b'1"), + Mop(Not,bVar"b'0")))))))), + Call + ("Trap",CTy"instruction", + Call + ("TEQ",CTy"Trap", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,bVar"b'5", + Bop(And,bVar"b'4", + Bop(And,Mop(Not,bVar"b'3"), + Bop(And,bVar"b'2", + Bop(And,bVar"b'1",Mop(Not,bVar"b'0")))))))), + Call + ("Trap",CTy"instruction", + Call + ("TNE",CTy"Trap", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'25"), + Bop(And,Mop(Not,bVar"b'24"), + Bop(And,Mop(Not,bVar"b'23"), + Bop(And,Mop(Not,bVar"b'22"), + Bop(And,Mop(Not,bVar"b'21"), + Bop(And,bVar"b'5", + Bop(And,bVar"b'4", + Bop(And,bVar"b'3", + Bop(And, + Mop(Not,bVar"b'2"), + Bop(And, + Mop(Not, + bVar"b'1"), + Mop(Not, + bVar"b'0"))))))))))))), + Call + ("Shift",CTy"instruction", + Call + ("DSLL",CTy"Shift", + TP[Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13",bVar"b'12", + bVar"b'11"]), + Mop(Cast(FTy 5), + LL[bVar"b'10",bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'25"), + Bop(And,Mop(Not,bVar"b'24"), + Bop(And,Mop(Not,bVar"b'23"), + Bop(And,Mop(Not,bVar"b'22"), + Bop(And,Mop(Not,bVar"b'21"), + Bop(And,bVar"b'5", + Bop(And,bVar"b'4", + Bop(And,bVar"b'3", + Bop(And, + Mop(Not,bVar"b'2"), + Bop(And, + bVar"b'1", + Mop(Not, + bVar"b'0"))))))))))))), + Call + ("Shift",CTy"instruction", + Call + ("DSRL",CTy"Shift", + TP[Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13",bVar"b'12", + bVar"b'11"]), + Mop(Cast(FTy 5), + LL[bVar"b'10",bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'25"), + Bop(And,Mop(Not,bVar"b'24"), + Bop(And,Mop(Not,bVar"b'23"), + Bop(And,Mop(Not,bVar"b'22"), + Bop(And,Mop(Not,bVar"b'21"), + Bop(And,bVar"b'5", + Bop(And,bVar"b'4", + Bop(And,bVar"b'3", + Bop(And, + Mop(Not,bVar"b'2"), + Bop(And, + bVar"b'1", + bVar"b'0")))))))))))), + Call + ("Shift",CTy"instruction", + Call + ("DSRA",CTy"Shift", + TP[Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13",bVar"b'12", + bVar"b'11"]), + Mop(Cast(FTy 5), + LL[bVar"b'10",bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'25"), + Bop(And,Mop(Not,bVar"b'24"), + Bop(And,Mop(Not,bVar"b'23"), + Bop(And,Mop(Not,bVar"b'22"), + Bop(And,Mop(Not,bVar"b'21"), + Bop(And,bVar"b'5", + Bop(And,bVar"b'4", + Bop(And,bVar"b'3", + Bop(And,bVar"b'2", + Bop(And, + Mop(Not, + bVar"b'1"), + Mop(Not, + bVar"b'0"))))))))))))), + Call + ("Shift",CTy"instruction", + Call + ("DSLL32",CTy"Shift", + TP[Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13",bVar"b'12", + bVar"b'11"]), + Mop(Cast(FTy 5), + LL[bVar"b'10",bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'25"), + Bop(And,Mop(Not,bVar"b'24"), + Bop(And,Mop(Not,bVar"b'23"), + Bop(And,Mop(Not,bVar"b'22"), + Bop(And,Mop(Not,bVar"b'21"), + Bop(And,bVar"b'5", + Bop(And,bVar"b'4", + Bop(And,bVar"b'3", + Bop(And,bVar"b'2", + Bop(And, + bVar"b'1", + Mop(Not, + bVar"b'0"))))))))))))), + Call + ("Shift",CTy"instruction", + Call + ("DSRL32",CTy"Shift", + TP[Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13",bVar"b'12", + bVar"b'11"]), + Mop(Cast(FTy 5), + LL[bVar"b'10",bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6"])]))), + (Bop(And,Mop(Not,bVar"b'28"), + Bop(And,Mop(Not,bVar"b'27"), + Bop(And,Mop(Not,bVar"b'25"), + Bop(And,Mop(Not,bVar"b'24"), + Bop(And,Mop(Not,bVar"b'23"), + Bop(And,Mop(Not,bVar"b'22"), + Bop(And,Mop(Not,bVar"b'21"), + Bop(And,bVar"b'5", + Bop(And,bVar"b'4", + Bop(And,bVar"b'3", + Bop(And,bVar"b'2", + Bop(And, + bVar"b'1", + bVar"b'0")))))))))))), + Call + ("Shift",CTy"instruction", + Call + ("DSRA32",CTy"Shift", + TP[Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14",bVar"b'13",bVar"b'12", + bVar"b'11"]), + Mop(Cast(FTy 5), + LL[bVar"b'10",bVar"b'9",bVar"b'8",bVar"b'7", + bVar"b'6"])]))), + (Bop(And,Mop(Not,bVar"b'28"),bVar"b'27"), + Call + ("Branch",CTy"instruction", + Call + ("J",CTy"Branch", + Mop(Cast(FTy 26), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21",bVar"b'20",bVar"b'19",bVar"b'18", + bVar"b'17",bVar"b'16",bVar"b'15",bVar"b'14", + bVar"b'13",bVar"b'12",bVar"b'11",bVar"b'10", + bVar"b'9",bVar"b'8",bVar"b'7",bVar"b'6", + bVar"b'5",bVar"b'4",bVar"b'3",bVar"b'2", + bVar"b'1",bVar"b'0"])))), + (Bop(And,bVar"b'28", + Bop(And,bVar"b'27", + Bop(And,Mop(Not,bVar"b'20"), + Bop(And,Mop(Not,bVar"b'19"), + Bop(And,Mop(Not,bVar"b'18"), + Bop(And,Mop(Not,bVar"b'17"), + Mop(Not,bVar"b'16"))))))), + Call + ("Branch",CTy"instruction", + Call + ("BLEZ",CTy"Branch", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13",bVar"b'12", + bVar"b'11",bVar"b'10",bVar"b'9",bVar"b'8", + bVar"b'7",bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1",bVar"b'0"])]))), + (Bop(And,bVar"b'28",Mop(Not,bVar"b'27")), + Call + ("Branch",CTy"instruction", + Call + ("BEQ",CTy"Branch", + TP[Mop(Cast(FTy 5), + LL[bVar"b'25",bVar"b'24",bVar"b'23",bVar"b'22", + bVar"b'21"]), + Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19",bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast F16, + LL[bVar"b'15",bVar"b'14",bVar"b'13",bVar"b'12", + bVar"b'11",bVar"b'10",bVar"b'9",bVar"b'8", + bVar"b'7",bVar"b'6",bVar"b'5",bVar"b'4", + bVar"b'3",bVar"b'2",bVar"b'1",bVar"b'0"])])))], + Const("ReservedInstruction",CTy"instruction")))) +; +val COP2InstructionToString_def = Def + ("COP2InstructionToString",Var("i",CTy"instruction"), + CS(Var("i",CTy"instruction"), + [(Call + ("COP2",CTy"instruction", + Call("CHERICOP2",CTy"COP2",Var("j",CTy"CHERICOP2"))), + CS(Var("j",CTy"CHERICOP2"), + [(Const("DumpCapReg",CTy"CHERICOP2"),LS"mtc2 ?,?,6"), + (Call + ("CGet",CTy"CHERICOP2", + Call + ("CGetBase",CTy"CGet", + TP[Var("rd",FTy 5),Var("cb",FTy 5)])), + Call + ("op2r",sTy, + TP[LS"cgetbase",Var("rd",FTy 5),Var("cb",FTy 5)])), + (Call + ("CGet",CTy"CHERICOP2", + Call + ("CGetOffset",CTy"CGet", + TP[Var("rd",FTy 5),Var("cb",FTy 5)])), + Call + ("op2r",sTy, + TP[LS"cgetoffset",Var("rd",FTy 5),Var("cb",FTy 5)])), + (Call + ("CGet",CTy"CHERICOP2", + Call + ("CGetLen",CTy"CGet",TP[Var("rd",FTy 5),Var("cb",FTy 5)])), + Call + ("op2r",sTy,TP[LS"cgetlen",Var("rd",FTy 5),Var("cb",FTy 5)])), + (Call + ("CGet",CTy"CHERICOP2", + Call + ("CGetTag",CTy"CGet",TP[Var("rd",FTy 5),Var("cb",FTy 5)])), + Call + ("op2r",sTy,TP[LS"cgettag",Var("rd",FTy 5),Var("cb",FTy 5)])), + (Call + ("CGet",CTy"CHERICOP2", + Call + ("CGetSealed",CTy"CGet", + TP[Var("rd",FTy 5),Var("cb",FTy 5)])), + Call + ("op2r",sTy, + TP[LS"cgetsealed",Var("rd",FTy 5),Var("cb",FTy 5)])), + (Call + ("CGet",CTy"CHERICOP2", + Call + ("CGetPerm",CTy"CGet", + TP[Var("rd",FTy 5),Var("cb",FTy 5)])), + Call + ("op2r",sTy, + TP[LS"cgetperm",Var("rd",FTy 5),Var("cb",FTy 5)])), + (Call + ("CGet",CTy"CHERICOP2", + Call + ("CGetType",CTy"CGet", + TP[Var("rd",FTy 5),Var("cb",FTy 5)])), + Call + ("op2r",sTy, + TP[LS"cgettype",Var("rd",FTy 5),Var("cb",FTy 5)])), + (Call + ("CGet",CTy"CHERICOP2", + Call("CGetPCC",CTy"CGet",Var("cd",FTy 5))), + Call("op1r",sTy,TP[LS"cgetpcc",Var("cd",FTy 5)])), + (Call + ("CGet",CTy"CHERICOP2", + Call("CGetCause",CTy"CGet",Var("rd",FTy 5))), + Call("op1r",sTy,TP[LS"cgetcause",Var("rd",FTy 5)])), + (Call + ("CSet",CTy"CHERICOP2", + Call("CSetCause",CTy"CSet",Var("rt",FTy 5))), + Call("op1r",sTy,TP[LS"csetcause",Var("rt",FTy 5)])), + (Call + ("CSet",CTy"CHERICOP2", + Call + ("CIncBase",CTy"CSet", + TP[Var("cd",FTy 5),Var("cb",FTy 5),Var("rt",FTy 5)])), + Call + ("op3r",sTy, + TP[LS"cincbase",Var("cd",FTy 5),Var("cb",FTy 5), + Var("rt",FTy 5)])), + (Call + ("CSet",CTy"CHERICOP2", + Call + ("CSetLen",CTy"CSet", + TP[Var("cd",FTy 5),Var("cb",FTy 5),Var("rt",FTy 5)])), + Call + ("op3r",sTy, + TP[LS"csetlen",Var("cd",FTy 5),Var("cb",FTy 5), + Var("rt",FTy 5)])), + (Call + ("CSet",CTy"CHERICOP2", + Call + ("CClearTag",CTy"CSet", + TP[Var("cd",FTy 5),Var("cb",FTy 5)])), + Call + ("op2r",sTy, + TP[LS"ccleartag",Var("cd",FTy 5),Var("cb",FTy 5)])), + (Call + ("CSet",CTy"CHERICOP2", + Call + ("CAndPerm",CTy"CSet", + TP[Var("cd",FTy 5),Var("cb",FTy 5),Var("rt",FTy 5)])), + Call + ("op3r",sTy, + TP[LS"candperm",Var("cd",FTy 5),Var("cb",FTy 5), + Var("rt",FTy 5)])), + (Call + ("CSet",CTy"CHERICOP2", + Call + ("CSetOffset",CTy"CSet", + TP[Var("cd",FTy 5),Var("cb",FTy 5),Var("rt",FTy 5)])), + Call + ("op3r",sTy, + TP[LS"csetoffset",Var("cd",FTy 5),Var("cb",FTy 5), + Var("rt",FTy 5)])), + (Call + ("CCheck",CTy"CHERICOP2", + Call + ("CCheckPerm",CTy"CCheck", + TP[Var("cs",FTy 5),Var("rt",FTy 5)])), + Call + ("op2r",sTy, + TP[LS"ccheckperm",Var("cs",FTy 5),Var("rt",FTy 5)])), + (Call + ("CCheck",CTy"CHERICOP2", + Call + ("CCheckType",CTy"CCheck", + TP[Var("cs",FTy 5),Var("cb",FTy 5)])), + Call + ("op2r",sTy, + TP[LS"cchecktype",Var("cs",FTy 5),Var("cb",FTy 5)])), + (Call + ("CSet",CTy"CHERICOP2", + Call + ("CFromPtr",CTy"CSet", + TP[Var("cd",FTy 5),Var("cb",FTy 5),Var("rt",FTy 5)])), + Call + ("op3r",sTy, + TP[LS"cfromptr",Var("cd",FTy 5),Var("cb",FTy 5), + Var("rt",FTy 5)])), + (Call + ("CGet",CTy"CHERICOP2", + Call + ("CToPtr",CTy"CGet", + TP[Var("rd",FTy 5),Var("cb",FTy 5),Var("ct",FTy 5)])), + Call + ("op3r",sTy, + TP[LS"ctoptr",Var("rd",FTy 5),Var("cb",FTy 5), + Var("ct",FTy 5)])), + (Call + ("CPtrCmp",CTy"CHERICOP2", + TP[Var("rd",FTy 5),Var("cb",FTy 5),Var("ct",FTy 5), + Var("t",FTy 3)]), + CS(Var("t",FTy 3), + [(LW(0,3), + Call + ("op3r",sTy, + TP[LS"ceq",Var("rd",FTy 5),Var("cb",FTy 5), + Var("ct",FTy 5)])), + (LW(1,3), + Call + ("op3r",sTy, + TP[LS"cne",Var("rd",FTy 5),Var("cb",FTy 5), + Var("ct",FTy 5)])), + (LW(2,3), + Call + ("op3r",sTy, + TP[LS"clt",Var("rd",FTy 5),Var("cb",FTy 5), + Var("ct",FTy 5)])), + (LW(3,3), + Call + ("op3r",sTy, + TP[LS"cle",Var("rd",FTy 5),Var("cb",FTy 5), + Var("ct",FTy 5)])), + (LW(4,3), + Call + ("op3r",sTy, + TP[LS"cltu",Var("rd",FTy 5),Var("cb",FTy 5), + Var("ct",FTy 5)])), + (LW(5,3), + Call + ("op3r",sTy, + TP[LS"cleu",Var("rd",FTy 5),Var("cb",FTy 5), + Var("ct",FTy 5)])), + (AVar(FTy 3),LS"unmatched_cap_inst")])), + (Call + ("CBTU",CTy"CHERICOP2", + TP[Var("cb",FTy 5),Var("offset",F16)]), + Call + ("op1ri",sTy,TP[LS"cbtu",Var("cb",FTy 5),Var("offset",F16)])), + (Call + ("CBTS",CTy"CHERICOP2", + TP[Var("cb",FTy 5),Var("offset",F16)]), + Call + ("op1ri",sTy,TP[LS"cbts",Var("cb",FTy 5),Var("offset",F16)])), + (Call("CJR",CTy"CHERICOP2",Var("cb",FTy 5)), + Call("op1r",sTy,TP[LS"cjr",Var("cb",FTy 5)])), + (Call + ("CJALR",CTy"CHERICOP2",TP[Var("cd",FTy 5),Var("cb",FTy 5)]), + Call + ("op2r",sTy,TP[LS"cjalr",Var("cd",FTy 5),Var("cb",FTy 5)])), + (Call + ("CSeal",CTy"CHERICOP2", + TP[Var("cd",FTy 5),Var("cs",FTy 5),Var("ct",FTy 5)]), + Call + ("op3r",sTy, + TP[LS"cseal",Var("cd",FTy 5),Var("cs",FTy 5), + Var("ct",FTy 5)])), + (Call + ("CUnseal",CTy"CHERICOP2", + TP[Var("cd",FTy 5),Var("cs",FTy 5),Var("ct",FTy 5)]), + Call + ("op3r",sTy, + TP[LS"cunseal",Var("cd",FTy 5),Var("cs",FTy 5), + Var("ct",FTy 5)])), + (Call + ("CCall",CTy"CHERICOP2",TP[Var("cs",FTy 5),Var("cb",FTy 5)]), + Call + ("op2r",sTy,TP[LS"ccall",Var("cs",FTy 5),Var("cb",FTy 5)])), + (Const("CReturn",CTy"CHERICOP2"),LS"creturn"), + (Const("UnknownCapInstruction",CTy"CHERICOP2"), + LS"unknown_cap_inst")])), + (AVar(CTy"instruction"),LS"unmatched_cap_inst")])) +; +val LWC2InstructionToString_def = Def + ("LWC2InstructionToString",Var("i",CTy"instruction"), + CS(Var("i",CTy"instruction"), + [(Call + ("LWC2",CTy"instruction", + Call("CHERILWC2",CTy"LWC2",Var("j",CTy"CHERILWC2"))), + CS(Var("j",CTy"CHERILWC2"), + [(Call + ("CLoad",CTy"CHERILWC2", + TP[Var("rd",FTy 5),Var("cb",FTy 5),Var("rt",FTy 5), + Var("offset",F8),LW(0,1),Var("t",FTy 2)]), + CS(Var("t",FTy 2), + [(LW(0,2), + Call + ("op3ro",sTy, + TP[LS"clbu",Var("rd",FTy 5),Var("cb",FTy 5), + Var("rt",FTy 5),Var("offset",F8)])), + (LW(1,2), + Call + ("op3ro",sTy, + TP[LS"clhu",Var("rd",FTy 5),Var("cb",FTy 5), + Var("rt",FTy 5),Var("offset",F8)])), + (LW(2,2), + Call + ("op3ro",sTy, + TP[LS"clwu",Var("rd",FTy 5),Var("cb",FTy 5), + Var("rt",FTy 5),Var("offset",F8)])), + (LW(3,2), + Call + ("op3ro",sTy, + TP[LS"cld",Var("rd",FTy 5),Var("cb",FTy 5), + Var("rt",FTy 5),Var("offset",F8)]))])), + (Call + ("CLoad",CTy"CHERILWC2", + TP[Var("rd",FTy 5),Var("cb",FTy 5),Var("rt",FTy 5), + Var("offset",F8),LW(1,1),LW(0,2)]), + Call + ("op3ro",sTy, + TP[LS"clb",Var("rd",FTy 5),Var("cb",FTy 5), + Var("rt",FTy 5),Var("offset",F8)])), + (Call + ("CLoad",CTy"CHERILWC2", + TP[Var("rd",FTy 5),Var("cb",FTy 5),Var("rt",FTy 5), + Var("offset",F8),LW(1,1),LW(1,2)]), + Call + ("op3ro",sTy, + TP[LS"clh",Var("rd",FTy 5),Var("cb",FTy 5), + Var("rt",FTy 5),Var("offset",F8)])), + (Call + ("CLoad",CTy"CHERILWC2", + TP[Var("rd",FTy 5),Var("cb",FTy 5),Var("rt",FTy 5), + Var("offset",F8),LW(1,1),LW(2,2)]), + Call + ("op3ro",sTy, + TP[LS"clw",Var("rd",FTy 5),Var("cb",FTy 5), + Var("rt",FTy 5),Var("offset",F8)])), + (Call + ("CLLD",CTy"CHERILWC2", + TP[Var("rd",FTy 5),Var("cb",FTy 5),Var("rt",FTy 5), + Var("offset",F8)]), + Call + ("op3ro",sTy, + TP[LS"clld",Var("rd",FTy 5),Var("cb",FTy 5), + Var("rt",FTy 5),Var("offset",F8)])), + (AVar(CTy"CHERILWC2"),LS"unmatched_cap_inst")])), + (AVar(CTy"instruction"),LS"unmatched_cap_inst")])) +; +val LDC2InstructionToString_def = Def + ("LDC2InstructionToString",Var("i",CTy"instruction"), + CS(Var("i",CTy"instruction"), + [(Call + ("LDC2",CTy"instruction", + Call("CHERILDC2",CTy"LDC2",Var("j",CTy"CHERILDC2"))), + CS(Var("j",CTy"CHERILDC2"), + [(Call + ("CLC",CTy"CHERILDC2", + TP[Var("cd",FTy 5),Var("cb",FTy 5),Var("rt",FTy 5), + Var("offset",FTy 11)]), + Call + ("op3ro",sTy, + TP[LS"clc",Var("cd",FTy 5),Var("cb",FTy 5), + Var("rt",FTy 5),Var("offset",FTy 11)]))])), + (AVar(CTy"instruction"),LS"unmatched_cap_inst")])) +; +val SWC2InstructionToString_def = Def + ("SWC2InstructionToString",Var("i",CTy"instruction"), + CS(Var("i",CTy"instruction"), + [(Call + ("SWC2",CTy"instruction", + Call("CHERISWC2",CTy"SWC2",Var("j",CTy"CHERISWC2"))), + CS(Var("j",CTy"CHERISWC2"), + [(Call + ("CStore",CTy"CHERISWC2", + TP[Var("rs",FTy 5),Var("cb",FTy 5),Var("rt",FTy 5), + Var("offset",F8),Var("t",FTy 2)]), + CS(Var("t",FTy 2), + [(LW(0,2), + Call + ("op3ro",sTy, + TP[LS"csb",Var("rs",FTy 5),Var("cb",FTy 5), + Var("rt",FTy 5),Var("offset",F8)])), + (LW(1,2), + Call + ("op3ro",sTy, + TP[LS"csh",Var("rs",FTy 5),Var("cb",FTy 5), + Var("rt",FTy 5),Var("offset",F8)])), + (LW(2,2), + Call + ("op3ro",sTy, + TP[LS"csw",Var("rs",FTy 5),Var("cb",FTy 5), + Var("rt",FTy 5),Var("offset",F8)])), + (LW(3,2), + Call + ("op3ro",sTy, + TP[LS"csd",Var("rs",FTy 5),Var("cb",FTy 5), + Var("rt",FTy 5),Var("offset",F8)]))])), + (Call + ("CSCD",CTy"CHERISWC2", + TP[Var("rs",FTy 5),Var("cb",FTy 5),Var("rt",FTy 5), + Var("offset",F8)]), + Call + ("op3ro",sTy, + TP[LS"cscd",Var("rs",FTy 5),Var("cb",FTy 5), + Var("rt",FTy 5),Var("offset",F8)]))])), + (AVar(CTy"instruction"),LS"unmatched_cap_inst")])) +; +val SDC2InstructionToString_def = Def + ("SDC2InstructionToString",Var("i",CTy"instruction"), + CS(Var("i",CTy"instruction"), + [(Call + ("SDC2",CTy"instruction", + Call("CHERISDC2",CTy"SDC2",Var("j",CTy"CHERISDC2"))), + CS(Var("j",CTy"CHERISDC2"), + [(Call + ("CSC",CTy"CHERISDC2", + TP[Var("cs",FTy 5),Var("cb",FTy 5),Var("rt",FTy 5), + Var("offset",FTy 11)]), + Call + ("op3ro",sTy, + TP[LS"csc",Var("cs",FTy 5),Var("cb",FTy 5), + Var("rt",FTy 5),Var("offset",FTy 11)]))])), + (AVar(CTy"instruction"),LS"unmatched_cap_inst")])) +; +val COP2Encode_def = Def + ("COP2Encode",Var("i",CTy"instruction"),CC[LW(18,6),LW(0,26)]) +; +val LWC2Encode_def = Def + ("LWC2Encode",Var("i",CTy"instruction"),CC[LW(50,6),LW(0,26)]) +; +val LDC2Encode_def = Def + ("LDC2Encode",Var("i",CTy"instruction"),CC[LW(54,6),LW(0,26)]) +; +val SWC2Encode_def = Def + ("SWC2Encode",Var("i",CTy"instruction"),CC[LW(58,6),LW(0,26)]) +; +val SDC2Encode_def = Def + ("SDC2Encode",Var("i",CTy"instruction"),CC[LW(62,6),LW(0,26)]) +; +val instructionToString_def = Def + ("instructionToString",Var("i",CTy"instruction"), + CS(Var("i",CTy"instruction"), + [(Call + ("Shift",CTy"instruction", + Call("SLL",CTy"Shift",TP[LW(0,5),LW(0,5),LW(0,5)])),LS"nop"), + (Call + ("Shift",CTy"instruction", + Call("SLL",CTy"Shift",TP[LW(0,5),LW(0,5),LW(1,5)])),LS"ssnop"), + (Call + ("Shift",CTy"instruction", + Call + ("SLL",CTy"Shift", + TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5)])), + Call + ("op2ri",sTy, + TP[LS"sll",Var("rd",FTy 5),Var("rt",FTy 5),Var("imm5",FTy 5)])), + (Call + ("Shift",CTy"instruction", + Call + ("SRL",CTy"Shift", + TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5)])), + Call + ("op2ri",sTy, + TP[LS"srl",Var("rd",FTy 5),Var("rt",FTy 5),Var("imm5",FTy 5)])), + (Call + ("Shift",CTy"instruction", + Call + ("SRA",CTy"Shift", + TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5)])), + Call + ("op2ri",sTy, + TP[LS"sra",Var("rd",FTy 5),Var("rt",FTy 5),Var("imm5",FTy 5)])), + (Call + ("Shift",CTy"instruction", + Call + ("SLLV",CTy"Shift", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("op3r",sTy, + TP[LS"sllv",Var("rd",FTy 5),Var("rt",FTy 5),Var("rs",FTy 5)])), + (Call + ("Shift",CTy"instruction", + Call + ("SRLV",CTy"Shift", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("op3r",sTy, + TP[LS"srlv",Var("rd",FTy 5),Var("rt",FTy 5),Var("rs",FTy 5)])), + (Call + ("Shift",CTy"instruction", + Call + ("SRAV",CTy"Shift", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("op3r",sTy, + TP[LS"srav",Var("rd",FTy 5),Var("rt",FTy 5),Var("rs",FTy 5)])), + (Call + ("Branch",CTy"instruction", + Call("JR",CTy"Branch",Var("rs",FTy 5))), + Call("op1r",sTy,TP[LS"jr",Var("rs",FTy 5)])), + (Call + ("Branch",CTy"instruction", + Call("JALR",CTy"Branch",TP[Var("rs",FTy 5),Var("rd",FTy 5)])), + Call("op2r",sTy,TP[LS"jalr",Var("rd",FTy 5),Var("rs",FTy 5)])), + (Call + ("MultDiv",CTy"instruction", + Call("MFHI",CTy"MultDiv",Var("rd",FTy 5))), + Call("op1r",sTy,TP[LS"mfhi",Var("rd",FTy 5)])), + (Call + ("MultDiv",CTy"instruction", + Call("MTHI",CTy"MultDiv",Var("rd",FTy 5))), + Call("op1r",sTy,TP[LS"mthi",Var("rd",FTy 5)])), + (Call + ("MultDiv",CTy"instruction", + Call("MFLO",CTy"MultDiv",Var("rs",FTy 5))), + Call("op1r",sTy,TP[LS"mflo",Var("rs",FTy 5)])), + (Call + ("MultDiv",CTy"instruction", + Call("MTLO",CTy"MultDiv",Var("rs",FTy 5))), + Call("op1r",sTy,TP[LS"mtlo",Var("rs",FTy 5)])), + (Call + ("Shift",CTy"instruction", + Call + ("DSLLV",CTy"Shift", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("op3r",sTy, + TP[LS"dsllv",Var("rd",FTy 5),Var("rt",FTy 5),Var("rs",FTy 5)])), + (Call + ("Shift",CTy"instruction", + Call + ("DSRLV",CTy"Shift", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("op3r",sTy, + TP[LS"dsrlv",Var("rd",FTy 5),Var("rt",FTy 5),Var("rs",FTy 5)])), + (Call + ("Shift",CTy"instruction", + Call + ("DSRAV",CTy"Shift", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("op3r",sTy, + TP[LS"dsrav",Var("rd",FTy 5),Var("rt",FTy 5),Var("rs",FTy 5)])), + (Call + ("MultDiv",CTy"instruction", + Call("MADD",CTy"MultDiv",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call("op2r",sTy,TP[LS"madd",Var("rs",FTy 5),Var("rt",FTy 5)])), + (Call + ("MultDiv",CTy"instruction", + Call("MADDU",CTy"MultDiv",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call("op2r",sTy,TP[LS"maddu",Var("rs",FTy 5),Var("rt",FTy 5)])), + (Call + ("MultDiv",CTy"instruction", + Call("MSUB",CTy"MultDiv",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call("op2r",sTy,TP[LS"msub",Var("rs",FTy 5),Var("rt",FTy 5)])), + (Call + ("MultDiv",CTy"instruction", + Call("MSUBU",CTy"MultDiv",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call("op2r",sTy,TP[LS"msubu",Var("rs",FTy 5),Var("rt",FTy 5)])), + (Call + ("MultDiv",CTy"instruction", + Call + ("MUL",CTy"MultDiv", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("op3r",sTy, + TP[LS"mul",Var("rd",FTy 5),Var("rs",FTy 5),Var("rt",FTy 5)])), + (Call + ("MultDiv",CTy"instruction", + Call("MULT",CTy"MultDiv",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call("op2r",sTy,TP[LS"mult",Var("rs",FTy 5),Var("rt",FTy 5)])), + (Call + ("MultDiv",CTy"instruction", + Call("MULTU",CTy"MultDiv",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call("op2r",sTy,TP[LS"multu",Var("rs",FTy 5),Var("rt",FTy 5)])), + (Call + ("MultDiv",CTy"instruction", + Call("DIV",CTy"MultDiv",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call("op2r",sTy,TP[LS"div",Var("rs",FTy 5),Var("rt",FTy 5)])), + (Call + ("MultDiv",CTy"instruction", + Call("DIVU",CTy"MultDiv",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call("op2r",sTy,TP[LS"divu",Var("rs",FTy 5),Var("rt",FTy 5)])), + (Call + ("MultDiv",CTy"instruction", + Call("DMULT",CTy"MultDiv",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call("op2r",sTy,TP[LS"dmult",Var("rs",FTy 5),Var("rt",FTy 5)])), + (Call + ("MultDiv",CTy"instruction", + Call("DMULTU",CTy"MultDiv",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call("op2r",sTy,TP[LS"dmultu",Var("rs",FTy 5),Var("rt",FTy 5)])), + (Call + ("MultDiv",CTy"instruction", + Call("DDIV",CTy"MultDiv",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call("op2r",sTy,TP[LS"ddiv",Var("rs",FTy 5),Var("rt",FTy 5)])), + (Call + ("MultDiv",CTy"instruction", + Call("DDIVU",CTy"MultDiv",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call("op2r",sTy,TP[LS"ddivu",Var("rs",FTy 5),Var("rt",FTy 5)])), + (Call + ("ArithR",CTy"instruction", + Call + ("MOVN",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("op3r",sTy, + TP[LS"movn",Var("rd",FTy 5),Var("rs",FTy 5),Var("rt",FTy 5)])), + (Call + ("ArithR",CTy"instruction", + Call + ("MOVZ",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("op3r",sTy, + TP[LS"movz",Var("rd",FTy 5),Var("rs",FTy 5),Var("rt",FTy 5)])), + (Call + ("ArithR",CTy"instruction", + Call + ("ADD",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("op3r",sTy, + TP[LS"add",Var("rd",FTy 5),Var("rs",FTy 5),Var("rt",FTy 5)])), + (Call + ("ArithR",CTy"instruction", + Call + ("ADDU",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("op3r",sTy, + TP[LS"addu",Var("rd",FTy 5),Var("rs",FTy 5),Var("rt",FTy 5)])), + (Call + ("ArithR",CTy"instruction", + Call + ("SUB",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("op3r",sTy, + TP[LS"sub",Var("rd",FTy 5),Var("rs",FTy 5),Var("rt",FTy 5)])), + (Call + ("ArithR",CTy"instruction", + Call + ("SUBU",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("op3r",sTy, + TP[LS"subu",Var("rd",FTy 5),Var("rs",FTy 5),Var("rt",FTy 5)])), + (Call + ("ArithR",CTy"instruction", + Call + ("AND",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("op3r",sTy, + TP[LS"and",Var("rd",FTy 5),Var("rs",FTy 5),Var("rt",FTy 5)])), + (Call + ("ArithR",CTy"instruction", + Call + ("OR",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("op3r",sTy, + TP[LS"or",Var("rd",FTy 5),Var("rs",FTy 5),Var("rt",FTy 5)])), + (Call + ("ArithR",CTy"instruction", + Call + ("XOR",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("op3r",sTy, + TP[LS"xor",Var("rd",FTy 5),Var("rs",FTy 5),Var("rt",FTy 5)])), + (Call + ("ArithR",CTy"instruction", + Call + ("NOR",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("op3r",sTy, + TP[LS"nor",Var("rd",FTy 5),Var("rs",FTy 5),Var("rt",FTy 5)])), + (Call + ("ArithR",CTy"instruction", + Call + ("SLT",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("op3r",sTy, + TP[LS"slt",Var("rd",FTy 5),Var("rs",FTy 5),Var("rt",FTy 5)])), + (Call + ("ArithR",CTy"instruction", + Call + ("SLTU",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("op3r",sTy, + TP[LS"sltu",Var("rd",FTy 5),Var("rs",FTy 5),Var("rt",FTy 5)])), + (Call + ("ArithR",CTy"instruction", + Call + ("DADD",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("op3r",sTy, + TP[LS"dadd",Var("rd",FTy 5),Var("rs",FTy 5),Var("rt",FTy 5)])), + (Call + ("ArithR",CTy"instruction", + Call + ("DADDU",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("op3r",sTy, + TP[LS"daddu",Var("rd",FTy 5),Var("rs",FTy 5),Var("rt",FTy 5)])), + (Call + ("ArithR",CTy"instruction", + Call + ("DSUB",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("op3r",sTy, + TP[LS"dsub",Var("rd",FTy 5),Var("rs",FTy 5),Var("rt",FTy 5)])), + (Call + ("ArithR",CTy"instruction", + Call + ("DSUBU",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("op3r",sTy, + TP[LS"dsubu",Var("rd",FTy 5),Var("rs",FTy 5),Var("rt",FTy 5)])), + (Call + ("Trap",CTy"instruction", + Call("TGE",CTy"Trap",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call("op2r",sTy,TP[LS"tge",Var("rs",FTy 5),Var("rt",FTy 5)])), + (Call + ("Trap",CTy"instruction", + Call("TGEU",CTy"Trap",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call("op2r",sTy,TP[LS"tgeu",Var("rs",FTy 5),Var("rt",FTy 5)])), + (Call + ("Trap",CTy"instruction", + Call("TLT",CTy"Trap",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call("op2r",sTy,TP[LS"tlt",Var("rs",FTy 5),Var("rt",FTy 5)])), + (Call + ("Trap",CTy"instruction", + Call("TLTU",CTy"Trap",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call("op2r",sTy,TP[LS"tltu",Var("rs",FTy 5),Var("rt",FTy 5)])), + (Call + ("Trap",CTy"instruction", + Call("TEQ",CTy"Trap",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call("op2r",sTy,TP[LS"teq",Var("rs",FTy 5),Var("rt",FTy 5)])), + (Call + ("Trap",CTy"instruction", + Call("TNE",CTy"Trap",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call("op2r",sTy,TP[LS"tne",Var("rs",FTy 5),Var("rt",FTy 5)])), + (Call + ("Shift",CTy"instruction", + Call + ("DSLL",CTy"Shift", + TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5)])), + Call + ("op2ri",sTy, + TP[LS"dsll",Var("rd",FTy 5),Var("rt",FTy 5),Var("imm5",FTy 5)])), + (Call + ("Shift",CTy"instruction", + Call + ("DSRL",CTy"Shift", + TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5)])), + Call + ("op2ri",sTy, + TP[LS"dsrl",Var("rd",FTy 5),Var("rt",FTy 5),Var("imm5",FTy 5)])), + (Call + ("Shift",CTy"instruction", + Call + ("DSRA",CTy"Shift", + TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5)])), + Call + ("op2ri",sTy, + TP[LS"dsra",Var("rd",FTy 5),Var("rt",FTy 5),Var("imm5",FTy 5)])), + (Call + ("Shift",CTy"instruction", + Call + ("DSLL32",CTy"Shift", + TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5)])), + Call + ("op2ri",sTy, + TP[LS"dsll32",Var("rd",FTy 5),Var("rt",FTy 5),Var("imm5",FTy 5)])), + (Call + ("Shift",CTy"instruction", + Call + ("DSRL32",CTy"Shift", + TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5)])), + Call + ("op2ri",sTy, + TP[LS"dsrl32",Var("rd",FTy 5),Var("rt",FTy 5),Var("imm5",FTy 5)])), + (Call + ("Shift",CTy"instruction", + Call + ("DSRA32",CTy"Shift", + TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5)])), + Call + ("op2ri",sTy, + TP[LS"dsra32",Var("rd",FTy 5),Var("rt",FTy 5),Var("imm5",FTy 5)])), + (Call + ("Branch",CTy"instruction", + Call("BLTZ",CTy"Branch",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("op1ri",sTy,TP[LS"bltz",Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call("BGEZ",CTy"Branch",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("op1ri",sTy,TP[LS"bgez",Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call("BLTZL",CTy"Branch",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("op1ri",sTy,TP[LS"bltzl",Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call("BGEZL",CTy"Branch",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("op1ri",sTy,TP[LS"bgezl",Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("Trap",CTy"instruction", + Call("TGEI",CTy"Trap",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("op1ri",sTy,TP[LS"tgei",Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("Trap",CTy"instruction", + Call("TGEIU",CTy"Trap",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("op1ri",sTy,TP[LS"tgeiu",Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("Trap",CTy"instruction", + Call("TLTI",CTy"Trap",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("op1ri",sTy,TP[LS"tlti",Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("Trap",CTy"instruction", + Call("TLTIU",CTy"Trap",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("op1ri",sTy,TP[LS"tltiu",Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("Trap",CTy"instruction", + Call("TEQI",CTy"Trap",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("op1ri",sTy,TP[LS"teqi",Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("Trap",CTy"instruction", + Call("TNEI",CTy"Trap",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("op1ri",sTy,TP[LS"tnei",Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call("BLTZAL",CTy"Branch",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("op1ri",sTy,TP[LS"bltzal",Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call("BGEZAL",CTy"Branch",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("op1ri",sTy,TP[LS"bgezal",Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call("BLTZALL",CTy"Branch",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("op1ri",sTy,TP[LS"bltzall",Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call("BGEZALL",CTy"Branch",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("op1ri",sTy,TP[LS"bgezall",Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call("J",CTy"Branch",Var("imm",FTy 26))), + Call("op1i",sTy,TP[LS"j",Var("imm",FTy 26)])), + (Call + ("Branch",CTy"instruction", + Call("JAL",CTy"Branch",Var("imm",FTy 26))), + Call("op1i",sTy,TP[LS"jal",Var("imm",FTy 26)])), + (Call + ("CP",CTy"instruction", + Call + ("MFC0",CTy"CP", + TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("sel",FTy 3)])), + Call + ("op2roi",sTy, + TP[LS"mfc0",Var("rt",FTy 5),Var("rd",FTy 5),Var("sel",FTy 3)])), + (Call + ("CP",CTy"instruction", + Call + ("DMFC0",CTy"CP", + TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("sel",FTy 3)])), + Call + ("op2roi",sTy, + TP[LS"dmfc0",Var("rt",FTy 5),Var("rd",FTy 5),Var("sel",FTy 3)])), + (Call + ("CP",CTy"instruction", + Call + ("MTC0",CTy"CP", + TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("sel",FTy 3)])), + Call + ("op2roi",sTy, + TP[LS"mtc0",Var("rt",FTy 5),Var("rd",FTy 5),Var("sel",FTy 3)])), + (Call + ("CP",CTy"instruction", + Call + ("DMTC0",CTy"CP", + TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("sel",FTy 3)])), + Call + ("op2roi",sTy, + TP[LS"dmtc0",Var("rt",FTy 5),Var("rd",FTy 5),Var("sel",FTy 3)])), + (Call + ("Branch",CTy"instruction", + Call("BEQ",CTy"Branch",TP[LW(0,5),LW(0,5),Var("imm",F16)])), + Call("op1i",sTy,TP[LS"b",Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call + ("BEQ",CTy"Branch", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("op2ri",sTy, + TP[LS"beq",Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call + ("BNE",CTy"Branch", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("op2ri",sTy, + TP[LS"bne",Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call("BLEZ",CTy"Branch",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("op1ri",sTy,TP[LS"blez",Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call("BGTZ",CTy"Branch",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("op1ri",sTy,TP[LS"bgtz",Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("ArithI",CTy"instruction", + Call + ("ADDI",CTy"ArithI", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("op2ri",sTy, + TP[LS"addi",Var("rt",FTy 5),Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("ArithI",CTy"instruction", + Call + ("ADDIU",CTy"ArithI", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("op2ri",sTy, + TP[LS"addiu",Var("rt",FTy 5),Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("ArithI",CTy"instruction", + Call + ("SLTI",CTy"ArithI", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("op2ri",sTy, + TP[LS"slti",Var("rt",FTy 5),Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("ArithI",CTy"instruction", + Call + ("SLTIU",CTy"ArithI", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("op2ri",sTy, + TP[LS"sltiu",Var("rt",FTy 5),Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("ArithI",CTy"instruction", + Call + ("ANDI",CTy"ArithI", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("op2ri",sTy, + TP[LS"andi",Var("rt",FTy 5),Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("ArithI",CTy"instruction", + Call + ("ORI",CTy"ArithI", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("op2ri",sTy, + TP[LS"ori",Var("rt",FTy 5),Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("ArithI",CTy"instruction", + Call + ("XORI",CTy"ArithI", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("op2ri",sTy, + TP[LS"xori",Var("rt",FTy 5),Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("ArithI",CTy"instruction", + Call("LUI",CTy"ArithI",TP[Var("rt",FTy 5),Var("imm",F16)])), + Call("op1ri",sTy,TP[LS"lui",Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call + ("BEQL",CTy"Branch", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("op2ri",sTy, + TP[LS"beql",Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call + ("BNEL",CTy"Branch", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("op2ri",sTy, + TP[LS"bnel",Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call("BLEZL",CTy"Branch",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("op1ri",sTy,TP[LS"blezl",Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call("BGTZL",CTy"Branch",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("op1ri",sTy,TP[LS"bgtzl",Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("ArithI",CTy"instruction", + Call + ("DADDI",CTy"ArithI", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("op2ri",sTy, + TP[LS"daddi",Var("rt",FTy 5),Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("ArithI",CTy"instruction", + Call + ("DADDIU",CTy"ArithI", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("op2ri",sTy, + TP[LS"daddiu",Var("rt",FTy 5),Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("Load",CTy"instruction", + Call + ("LDL",CTy"Load", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("opmem",sTy, + TP[LS"ldl",Var("rt",FTy 5),Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("Load",CTy"instruction", + Call + ("LDR",CTy"Load", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("opmem",sTy, + TP[LS"ldr",Var("rt",FTy 5),Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("Load",CTy"instruction", + Call + ("LB",CTy"Load", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("opmem",sTy, + TP[LS"lb",Var("rt",FTy 5),Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("Load",CTy"instruction", + Call + ("LH",CTy"Load", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("opmem",sTy, + TP[LS"lh",Var("rt",FTy 5),Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("Load",CTy"instruction", + Call + ("LWL",CTy"Load", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("opmem",sTy, + TP[LS"lwl",Var("rt",FTy 5),Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("Load",CTy"instruction", + Call + ("LW",CTy"Load", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("opmem",sTy, + TP[LS"lw",Var("rt",FTy 5),Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("Load",CTy"instruction", + Call + ("LBU",CTy"Load", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("opmem",sTy, + TP[LS"lbu",Var("rt",FTy 5),Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("Load",CTy"instruction", + Call + ("LHU",CTy"Load", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("opmem",sTy, + TP[LS"lhu",Var("rt",FTy 5),Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("Load",CTy"instruction", + Call + ("LWR",CTy"Load", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("opmem",sTy, + TP[LS"lwr",Var("rt",FTy 5),Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("Load",CTy"instruction", + Call + ("LWU",CTy"Load", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("opmem",sTy, + TP[LS"lwu",Var("rt",FTy 5),Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("Store",CTy"instruction", + Call + ("SB",CTy"Store", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("opmem",sTy, + TP[LS"sb",Var("rt",FTy 5),Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("Store",CTy"instruction", + Call + ("SH",CTy"Store", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("opmem",sTy, + TP[LS"sh",Var("rt",FTy 5),Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("Store",CTy"instruction", + Call + ("SWL",CTy"Store", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("opmem",sTy, + TP[LS"swl",Var("rt",FTy 5),Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("Store",CTy"instruction", + Call + ("SW",CTy"Store", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("opmem",sTy, + TP[LS"sw",Var("rt",FTy 5),Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("Store",CTy"instruction", + Call + ("SDL",CTy"Store", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("opmem",sTy, + TP[LS"sdl",Var("rt",FTy 5),Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("Store",CTy"instruction", + Call + ("SDR",CTy"Store", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("opmem",sTy, + TP[LS"sdr",Var("rt",FTy 5),Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("Store",CTy"instruction", + Call + ("SWR",CTy"Store", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("opmem",sTy, + TP[LS"swr",Var("rt",FTy 5),Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("Load",CTy"instruction", + Call + ("LL",CTy"Load", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("opmem",sTy, + TP[LS"ll",Var("rt",FTy 5),Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("Load",CTy"instruction", + Call + ("LLD",CTy"Load", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("opmem",sTy, + TP[LS"lld",Var("rt",FTy 5),Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("Load",CTy"instruction", + Call + ("LD",CTy"Load", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("opmem",sTy, + TP[LS"ld",Var("rt",FTy 5),Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("Store",CTy"instruction", + Call + ("SC",CTy"Store", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("opmem",sTy, + TP[LS"sc",Var("rt",FTy 5),Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("Store",CTy"instruction", + Call + ("SCD",CTy"Store", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("opmem",sTy, + TP[LS"scd",Var("rt",FTy 5),Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("Store",CTy"instruction", + Call + ("SD",CTy"Store", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("opmem",sTy, + TP[LS"sd",Var("rt",FTy 5),Var("rs",FTy 5),Var("imm",F16)])), + (Call + ("CACHE",CTy"instruction", + TP[Var("rs",FTy 5),Var("opn",FTy 5),Var("imm",F16)]), + Call + ("opmem",sTy, + TP[LS"cache",Var("opn",FTy 5),Var("rs",FTy 5),Var("imm",F16)])), + (Const("SYSCALL",CTy"instruction"),LS"syscall"), + (Const("BREAK",CTy"instruction"),LS"break"), + (Call("SYNC",CTy"instruction",Var("imm5",FTy 5)), + CC[LS"sync ",Mop(Cast sTy,Var("imm5",FTy 5))]), + (Const("TLBR",CTy"instruction"),LS"tlbr"), + (Const("TLBWI",CTy"instruction"),LS"tlbwi"), + (Const("TLBWR",CTy"instruction"),LS"tlbwr"), + (Const("TLBP",CTy"instruction"),LS"tlbp"), + (Const("ERET",CTy"instruction"),LS"eret"), + (Call("RDHWR",CTy"instruction",TP[Var("rt",FTy 5),Var("rd",FTy 5)]), + Call("op2r",sTy,TP[LS"rdhwr",Var("rt",FTy 5),Var("rd",FTy 5)])), + (Const("WAIT",CTy"instruction"),LS"wait"), + (Call("COP2",CTy"instruction",AVar(CTy"COP2")), + Call("COP2InstructionToString",sTy,Var("i",CTy"instruction"))), + (Call("LWC2",CTy"instruction",AVar(CTy"LWC2")), + Call("LWC2InstructionToString",sTy,Var("i",CTy"instruction"))), + (Call("LDC2",CTy"instruction",AVar(CTy"LDC2")), + Call("LDC2InstructionToString",sTy,Var("i",CTy"instruction"))), + (Call("SWC2",CTy"instruction",AVar(CTy"SWC2")), + Call("SWC2InstructionToString",sTy,Var("i",CTy"instruction"))), + (Call("SDC2",CTy"instruction",AVar(CTy"SDC2")), + Call("SDC2InstructionToString",sTy,Var("i",CTy"instruction"))), + (Const("Unpredictable",CTy"instruction"),LS"???"), + (Const("ReservedInstruction",CTy"instruction"),LS"???")])) +; +val Encode_def = Def + ("Encode",Var("i",CTy"instruction"), + CS(Var("i",CTy"instruction"), + [(Call + ("Shift",CTy"instruction", + Call + ("SLL",CTy"Shift", + TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5)])), + Call + ("form1",F32, + TP[LW(0,5),Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5), + LW(0,6)])), + (Call + ("Shift",CTy"instruction", + Call + ("SRL",CTy"Shift", + TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5)])), + Call + ("form1",F32, + TP[LW(0,5),Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5), + LW(2,6)])), + (Call + ("Shift",CTy"instruction", + Call + ("SRA",CTy"Shift", + TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5)])), + Call + ("form1",F32, + TP[LW(0,5),Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5), + LW(3,6)])), + (Call + ("Shift",CTy"instruction", + Call + ("SLLV",CTy"Shift", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + LW(4,6)])), + (Call + ("Shift",CTy"instruction", + Call + ("SRLV",CTy"Shift", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + LW(6,6)])), + (Call + ("Shift",CTy"instruction", + Call + ("SRAV",CTy"Shift", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + LW(7,6)])), + (Call + ("Branch",CTy"instruction", + Call("JR",CTy"Branch",Var("rs",FTy 5))), + Call + ("form1",F32,TP[Var("rs",FTy 5),LW(0,5),LW(0,5),LW(0,5),LW(8,6)])), + (Call + ("Branch",CTy"instruction", + Call("JALR",CTy"Branch",TP[Var("rs",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),LW(0,5),Var("rd",FTy 5),LW(0,5),LW(9,6)])), + (Call + ("MultDiv",CTy"instruction", + Call("MFHI",CTy"MultDiv",Var("rd",FTy 5))), + Call + ("form1",F32, + TP[LW(0,5),LW(0,5),Var("rd",FTy 5),LW(0,5),LW(16,6)])), + (Call + ("MultDiv",CTy"instruction", + Call("MTHI",CTy"MultDiv",Var("rs",FTy 5))), + Call + ("form1",F32, + TP[Var("rs",FTy 5),LW(0,5),LW(0,5),LW(0,5),LW(17,6)])), + (Call + ("MultDiv",CTy"instruction", + Call("MFLO",CTy"MultDiv",Var("rd",FTy 5))), + Call + ("form1",F32, + TP[LW(0,5),LW(0,5),Var("rd",FTy 5),LW(0,5),LW(18,6)])), + (Call + ("MultDiv",CTy"instruction", + Call("MTLO",CTy"MultDiv",Var("rs",FTy 5))), + Call + ("form1",F32, + TP[Var("rs",FTy 5),LW(0,5),LW(0,5),LW(0,5),LW(19,6)])), + (Call + ("Shift",CTy"instruction", + Call + ("DSLLV",CTy"Shift", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + LW(20,6)])), + (Call + ("Shift",CTy"instruction", + Call + ("DSRLV",CTy"Shift", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + LW(22,6)])), + (Call + ("Shift",CTy"instruction", + Call + ("DSRAV",CTy"Shift", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + LW(23,6)])), + (Call + ("MultDiv",CTy"instruction", + Call("MADD",CTy"MultDiv",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call + ("form5",F32,TP[Var("rs",FTy 5),Var("rt",FTy 5),LW(0,5),LW(0,6)])), + (Call + ("MultDiv",CTy"instruction", + Call("MADDU",CTy"MultDiv",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call + ("form5",F32,TP[Var("rs",FTy 5),Var("rt",FTy 5),LW(0,5),LW(1,6)])), + (Call + ("MultDiv",CTy"instruction", + Call("MSUB",CTy"MultDiv",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call + ("form5",F32,TP[Var("rs",FTy 5),Var("rt",FTy 5),LW(0,5),LW(4,6)])), + (Call + ("MultDiv",CTy"instruction", + Call("MSUBU",CTy"MultDiv",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call + ("form5",F32,TP[Var("rs",FTy 5),Var("rt",FTy 5),LW(0,5),LW(5,6)])), + (Call + ("MultDiv",CTy"instruction", + Call + ("MUL",CTy"MultDiv", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form5",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(2,6)])), + (Call + ("MultDiv",CTy"instruction", + Call("MULT",CTy"MultDiv",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),LW(0,5),LW(0,5),LW(24,6)])), + (Call + ("MultDiv",CTy"instruction", + Call("MULTU",CTy"MultDiv",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),LW(0,5),LW(0,5),LW(25,6)])), + (Call + ("MultDiv",CTy"instruction", + Call("DIV",CTy"MultDiv",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),LW(0,5),LW(0,5),LW(26,6)])), + (Call + ("MultDiv",CTy"instruction", + Call("DIVU",CTy"MultDiv",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),LW(0,5),LW(0,5),LW(27,6)])), + (Call + ("MultDiv",CTy"instruction", + Call("DMULT",CTy"MultDiv",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),LW(0,5),LW(0,5),LW(28,6)])), + (Call + ("MultDiv",CTy"instruction", + Call("DMULTU",CTy"MultDiv",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),LW(0,5),LW(0,5),LW(29,6)])), + (Call + ("MultDiv",CTy"instruction", + Call("DDIV",CTy"MultDiv",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),LW(0,5),LW(0,5),LW(30,6)])), + (Call + ("MultDiv",CTy"instruction", + Call("DDIVU",CTy"MultDiv",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),LW(0,5),LW(0,5),LW(31,6)])), + (Call + ("ArithR",CTy"instruction", + Call + ("MOVZ",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + LW(10,6)])), + (Call + ("ArithR",CTy"instruction", + Call + ("MOVN",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + LW(11,6)])), + (Call + ("ArithR",CTy"instruction", + Call + ("ADD",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + LW(32,6)])), + (Call + ("ArithR",CTy"instruction", + Call + ("ADDU",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + LW(33,6)])), + (Call + ("ArithR",CTy"instruction", + Call + ("SUB",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + LW(34,6)])), + (Call + ("ArithR",CTy"instruction", + Call + ("SUBU",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + LW(35,6)])), + (Call + ("ArithR",CTy"instruction", + Call + ("AND",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + LW(36,6)])), + (Call + ("ArithR",CTy"instruction", + Call + ("OR",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + LW(37,6)])), + (Call + ("ArithR",CTy"instruction", + Call + ("XOR",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + LW(38,6)])), + (Call + ("ArithR",CTy"instruction", + Call + ("NOR",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + LW(39,6)])), + (Call + ("ArithR",CTy"instruction", + Call + ("SLT",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + LW(42,6)])), + (Call + ("ArithR",CTy"instruction", + Call + ("SLTU",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + LW(43,6)])), + (Call + ("ArithR",CTy"instruction", + Call + ("DADD",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + LW(44,6)])), + (Call + ("ArithR",CTy"instruction", + Call + ("DADDU",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + LW(45,6)])), + (Call + ("ArithR",CTy"instruction", + Call + ("DSUB",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + LW(46,6)])), + (Call + ("ArithR",CTy"instruction", + Call + ("DSUBU",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + LW(47,6)])), + (Call + ("Trap",CTy"instruction", + Call("TGE",CTy"Trap",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),LW(0,5),LW(0,5),LW(48,6)])), + (Call + ("Trap",CTy"instruction", + Call("TGEU",CTy"Trap",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),LW(0,5),LW(0,5),LW(49,6)])), + (Call + ("Trap",CTy"instruction", + Call("TLT",CTy"Trap",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),LW(0,5),LW(0,5),LW(50,6)])), + (Call + ("Trap",CTy"instruction", + Call("TLTU",CTy"Trap",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),LW(0,5),LW(0,5),LW(51,6)])), + (Call + ("Trap",CTy"instruction", + Call("TEQ",CTy"Trap",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),LW(0,5),LW(0,5),LW(52,6)])), + (Call + ("Trap",CTy"instruction", + Call("TNE",CTy"Trap",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),LW(0,5),LW(0,5),LW(54,6)])), + (Call + ("Shift",CTy"instruction", + Call + ("DSLL",CTy"Shift", + TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5)])), + Call + ("form1",F32, + TP[LW(0,5),Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5), + LW(56,6)])), + (Call + ("Shift",CTy"instruction", + Call + ("DSRL",CTy"Shift", + TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5)])), + Call + ("form1",F32, + TP[LW(0,5),Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5), + LW(58,6)])), + (Call + ("Shift",CTy"instruction", + Call + ("DSRA",CTy"Shift", + TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5)])), + Call + ("form1",F32, + TP[LW(0,5),Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5), + LW(59,6)])), + (Call + ("Shift",CTy"instruction", + Call + ("DSLL32",CTy"Shift", + TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5)])), + Call + ("form1",F32, + TP[LW(0,5),Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5), + LW(60,6)])), + (Call + ("Shift",CTy"instruction", + Call + ("DSRL32",CTy"Shift", + TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5)])), + Call + ("form1",F32, + TP[LW(0,5),Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5), + LW(62,6)])), + (Call + ("Shift",CTy"instruction", + Call + ("DSRA32",CTy"Shift", + TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5)])), + Call + ("form1",F32, + TP[LW(0,5),Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5), + LW(63,6)])), + (Call + ("Branch",CTy"instruction", + Call("BLTZ",CTy"Branch",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("form2",F32,TP[Var("rs",FTy 5),LW(0,5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call("BGEZ",CTy"Branch",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("form2",F32,TP[Var("rs",FTy 5),LW(1,5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call("BLTZL",CTy"Branch",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("form2",F32,TP[Var("rs",FTy 5),LW(2,5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call("BGEZL",CTy"Branch",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("form2",F32,TP[Var("rs",FTy 5),LW(3,5),Var("imm",F16)])), + (Call + ("Trap",CTy"instruction", + Call("TGEI",CTy"Trap",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("form2",F32,TP[Var("rs",FTy 5),LW(8,5),Var("imm",F16)])), + (Call + ("Trap",CTy"instruction", + Call("TGEIU",CTy"Trap",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("form2",F32,TP[Var("rs",FTy 5),LW(9,5),Var("imm",F16)])), + (Call + ("Trap",CTy"instruction", + Call("TLTI",CTy"Trap",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("form2",F32,TP[Var("rs",FTy 5),LW(10,5),Var("imm",F16)])), + (Call + ("Trap",CTy"instruction", + Call("TLTIU",CTy"Trap",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("form2",F32,TP[Var("rs",FTy 5),LW(11,5),Var("imm",F16)])), + (Call + ("Trap",CTy"instruction", + Call("TEQI",CTy"Trap",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("form2",F32,TP[Var("rs",FTy 5),LW(12,5),Var("imm",F16)])), + (Call + ("Trap",CTy"instruction", + Call("TNEI",CTy"Trap",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("form2",F32,TP[Var("rs",FTy 5),LW(14,5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call("BLTZAL",CTy"Branch",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("form2",F32,TP[Var("rs",FTy 5),LW(16,5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call("BGEZAL",CTy"Branch",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("form2",F32,TP[Var("rs",FTy 5),LW(17,5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call("BLTZALL",CTy"Branch",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("form2",F32,TP[Var("rs",FTy 5),LW(18,5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call("BGEZALL",CTy"Branch",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("form2",F32,TP[Var("rs",FTy 5),LW(19,5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call("J",CTy"Branch",Var("imm",FTy 26))), + CC[LW(2,6),Var("imm",FTy 26)]), + (Call + ("Branch",CTy"instruction", + Call("JAL",CTy"Branch",Var("imm",FTy 26))), + CC[LW(3,6),Var("imm",FTy 26)]), + (Call + ("CP",CTy"instruction", + Call + ("MFC0",CTy"CP", + TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("sel",FTy 3)])), + Call + ("form3",F32, + TP[LW(0,5),Var("rt",FTy 5),Var("rd",FTy 5),Var("sel",FTy 3)])), + (Call + ("CP",CTy"instruction", + Call + ("DMFC0",CTy"CP", + TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("sel",FTy 3)])), + Call + ("form3",F32, + TP[LW(1,5),Var("rt",FTy 5),Var("rd",FTy 5),Var("sel",FTy 3)])), + (Call + ("CP",CTy"instruction", + Call + ("MTC0",CTy"CP", + TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("sel",FTy 3)])), + Call + ("form3",F32, + TP[LW(4,5),Var("rt",FTy 5),Var("rd",FTy 5),Var("sel",FTy 3)])), + (Call + ("CP",CTy"instruction", + Call + ("DMTC0",CTy"CP", + TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("sel",FTy 3)])), + Call + ("form3",F32, + TP[LW(5,5),Var("rt",FTy 5),Var("rd",FTy 5),Var("sel",FTy 3)])), + (Call + ("Branch",CTy"instruction", + Call + ("BEQ",CTy"Branch", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(4,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call + ("BNE",CTy"Branch", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(5,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call("BLEZ",CTy"Branch",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call + ("form4",F32,TP[LW(6,6),Var("rs",FTy 5),LW(0,5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call("BGTZ",CTy"Branch",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call + ("form4",F32,TP[LW(7,6),Var("rs",FTy 5),LW(0,5),Var("imm",F16)])), + (Call + ("ArithI",CTy"instruction", + Call + ("ADDI",CTy"ArithI", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(8,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("ArithI",CTy"instruction", + Call + ("ADDIU",CTy"ArithI", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(9,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("ArithI",CTy"instruction", + Call + ("SLTI",CTy"ArithI", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(10,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("ArithI",CTy"instruction", + Call + ("SLTIU",CTy"ArithI", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(11,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("ArithI",CTy"instruction", + Call + ("ANDI",CTy"ArithI", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(12,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("ArithI",CTy"instruction", + Call + ("ORI",CTy"ArithI", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(13,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("ArithI",CTy"instruction", + Call + ("XORI",CTy"ArithI", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(14,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("ArithI",CTy"instruction", + Call("LUI",CTy"ArithI",TP[Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32,TP[LW(15,6),LW(0,5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call + ("BEQL",CTy"Branch", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(20,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call + ("BNEL",CTy"Branch", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(21,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call("BLEZL",CTy"Branch",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call + ("form4",F32,TP[LW(22,6),Var("rs",FTy 5),LW(0,5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call("BGTZL",CTy"Branch",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call + ("form4",F32,TP[LW(23,6),Var("rs",FTy 5),LW(0,5),Var("imm",F16)])), + (Call + ("ArithI",CTy"instruction", + Call + ("DADDI",CTy"ArithI", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(24,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("ArithI",CTy"instruction", + Call + ("DADDIU",CTy"ArithI", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(25,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Load",CTy"instruction", + Call + ("LDL",CTy"Load", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(26,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Load",CTy"instruction", + Call + ("LDR",CTy"Load", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(27,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Load",CTy"instruction", + Call + ("LB",CTy"Load", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(32,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Load",CTy"instruction", + Call + ("LH",CTy"Load", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(33,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Load",CTy"instruction", + Call + ("LWL",CTy"Load", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(34,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Load",CTy"instruction", + Call + ("LW",CTy"Load", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(35,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Load",CTy"instruction", + Call + ("LBU",CTy"Load", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(36,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Load",CTy"instruction", + Call + ("LHU",CTy"Load", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(37,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Load",CTy"instruction", + Call + ("LWR",CTy"Load", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(38,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Load",CTy"instruction", + Call + ("LWU",CTy"Load", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(39,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Store",CTy"instruction", + Call + ("SB",CTy"Store", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(40,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Store",CTy"instruction", + Call + ("SH",CTy"Store", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(41,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Store",CTy"instruction", + Call + ("SWL",CTy"Store", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(42,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Store",CTy"instruction", + Call + ("SW",CTy"Store", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(43,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Store",CTy"instruction", + Call + ("SDL",CTy"Store", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(44,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Store",CTy"instruction", + Call + ("SDR",CTy"Store", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(45,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Store",CTy"instruction", + Call + ("SWR",CTy"Store", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(46,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Load",CTy"instruction", + Call + ("LL",CTy"Load", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(48,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Load",CTy"instruction", + Call + ("LLD",CTy"Load", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(52,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Load",CTy"instruction", + Call + ("LD",CTy"Load", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(55,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Store",CTy"instruction", + Call + ("SC",CTy"Store", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(56,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Store",CTy"instruction", + Call + ("SCD",CTy"Store", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(60,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Store",CTy"instruction", + Call + ("SD",CTy"Store", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(63,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("CACHE",CTy"instruction", + TP[Var("rs",FTy 5),Var("opn",FTy 5),Var("imm",F16)]), + Call + ("form4",F32, + TP[LW(47,6),Var("rs",FTy 5),Var("opn",FTy 5),Var("imm",F16)])), + (Const("SYSCALL",CTy"instruction"),Mop(Cast F32,LW(12,6))), + (Const("BREAK",CTy"instruction"),Mop(Cast F32,LW(13,6))), + (Call("SYNC",CTy"instruction",Var("imm5",FTy 5)), + Mop(Cast F32,CC[Var("imm5",FTy 5),LW(15,6)])), + (Const("TLBR",CTy"instruction"),LW(1107296257,32)), + (Const("TLBWI",CTy"instruction"),LW(1107296258,32)), + (Const("TLBWR",CTy"instruction"),LW(1107296262,32)), + (Const("TLBP",CTy"instruction"),LW(1107296264,32)), + (Const("ERET",CTy"instruction"),LW(1107296280,32)), + (Call("RDHWR",CTy"instruction",TP[Var("rt",FTy 5),Var("rd",FTy 5)]), + Call("form6",F32,TP[Var("rt",FTy 5),Var("rd",FTy 5),LW(59,6)])), + (Const("WAIT",CTy"instruction"),LW(1107296288,32)), + (Call("COP2",CTy"instruction",AVar(CTy"COP2")), + Call("COP2Encode",F32,Var("i",CTy"instruction"))), + (Call("LWC2",CTy"instruction",AVar(CTy"LWC2")), + Call("LWC2Encode",F32,Var("i",CTy"instruction"))), + (Call("LDC2",CTy"instruction",AVar(CTy"LDC2")), + Call("LDC2Encode",F32,Var("i",CTy"instruction"))), + (Call("SWC2",CTy"instruction",AVar(CTy"SWC2")), + Call("SWC2Encode",F32,Var("i",CTy"instruction"))), + (Call("SDC2",CTy"instruction",AVar(CTy"SDC2")), + Call("SDC2Encode",F32,Var("i",CTy"instruction"))), + (Const("Unpredictable",CTy"instruction"),LW(133169152,32)), + (Const("ReservedInstruction",CTy"instruction"),LW(0,32))])) +; +val log_instruction_def = Def + ("log_instruction",TP[Var("w",F32),Var("inst",CTy"instruction")], + Close + (qVar"state", + TP[CC[LS"instr ",Mop(Cast sTy,Dest("procID",F8,qVar"state")),LS" ", + Mop(Cast sTy,Dest("instCnt",nTy,qVar"state")),LS" ", + Call + ("hex64",sTy, + Mop(Fst, + Apply(Const("PC",ATy(qTy,PTy(F64,qTy))),qVar"state"))), + LS" : ",Call("hex32",sTy,Var("w",F32)),LS" ", + Call("instructionToString",sTy,Var("inst",CTy"instruction"))], + qVar"state"])) +; +val Next_def = Def + ("Next",qVar"state", + Let(TP[Var("v",OTy F32),qVar"s"], + Apply + (Const("Fetch",ATy(qTy,PTy(OTy F32,qTy))), + Rupd + ("currentInst", + TP[Mop(Snd, + Apply + (Call("clear_logs",ATy(qTy,PTy(uTy,qTy)),LU), + qVar"state")),LO F32])), + Let(qVar"s",Rupd("currentInst",TP[qVar"s",Var("v",OTy F32)]), + Let(qVar"s", + CS(Dest("currentInst",OTy F32,qVar"s"), + [(Mop(Some,Var("w",F32)), + Let(Var("inst",CTy"instruction"), + Call("Decode",CTy"instruction",Var("w",F32)), + Mop(Snd, + Apply + (Call + ("Run",ATy(qTy,PTy(uTy,qTy)), + Var("inst",CTy"instruction")), + Mop(Snd, + Apply + (Call + ("mark_log",ATy(qTy,PTy(uTy,qTy)), + TP[LN 1, + Mop(Fst, + Apply + (Call + ("log_instruction", + ATy(qTy,PTy(sTy,qTy)), + TP[Var("w",F32), + Var("inst", + CTy"instruction")]), + qVar"s"))]),qVar"s")))))), + (LO F32,qVar"s")]), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'exceptionSignalled", + ATy(qTy,PTy(uTy,qTy)),LF), + CS(TP[Mop(Fst, + Apply + (Const + ("BranchDelay", + ATy(qTy,PTy(OTy F64,qTy))), + qVar"s")), + Mop(Fst, + Apply + (Const + ("BranchTo", + ATy(qTy,PTy(OTy F64,qTy))), + qVar"s")), + Mop(Fst, + Apply + (Const + ("BranchDelayPCC", + ATy(qTy, + PTy(OTy(PTy(F64, + CTy"Capability")), + qTy))),qVar"s")), + Mop(Fst, + Apply + (Const + ("BranchToPCC", + ATy(qTy, + PTy(OTy(PTy(F64, + CTy"Capability")), + qTy))),qVar"s"))], + [(TP[LO F64,LO F64, + LO(PTy(F64,CTy"Capability")), + LO(PTy(F64,CTy"Capability"))], + ITE(Mop(Not, + Mop(Fst, + Apply + (Const + ("exceptionSignalled", + ATy(qTy,PTy(bTy,qTy))), + qVar"s"))), + Mop(Snd, + Apply + (Call + ("write'PC", + ATy(qTy,PTy(uTy,qTy)), + Bop(Add, + Mop(Fst, + Apply + (Const + ("PC", + ATy(qTy, + PTy(F64,qTy))), + qVar"s")),LW(4,64))), + qVar"s")),qVar"s")), + (TP[Mop(Some,Var("addr",F64)),LO F64, + LO(PTy(F64,CTy"Capability")), + LO(PTy(F64,CTy"Capability"))], + Mop(Snd, + Apply + (Call + ("write'PC",ATy(qTy,PTy(uTy,qTy)), + Var("addr",F64)), + Mop(Snd, + Apply + (Call + ("write'BranchDelay", + ATy(qTy,PTy(uTy,qTy)), + LO F64),qVar"s"))))), + (TP[LO F64,Mop(Some,Var("addr",F64)), + LO(PTy(F64,CTy"Capability")), + LO(PTy(F64,CTy"Capability"))], + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'BranchTo", + ATy(qTy,PTy(uTy,qTy)),LO F64), + Mop(Snd, + Apply + (Call + ("write'BranchDelay", + ATy(qTy,PTy(uTy,qTy)), + Mop(Some, + Var("addr",F64))), + qVar"s")))), + Mop(Snd, + Apply + (Call + ("write'PC", + ATy(qTy,PTy(uTy,qTy)), + Bop(Add, + Mop(Fst, + Apply + (Const + ("PC", + ATy(qTy, + PTy(F64,qTy))), + qVar"s")),LW(4,64))), + qVar"s")))), + (TP[LO F64,LO F64, + Mop(Some, + TP[Var("addr",F64), + Var("cap",CTy"Capability")]), + LO(PTy(F64,CTy"Capability"))], + Mop(Snd, + Apply + (Call + ("write'PCC", + ATy(qTy,PTy(uTy,qTy)), + Var("cap",CTy"Capability")), + Mop(Snd, + Apply + (Call + ("write'PC", + ATy(qTy,PTy(uTy,qTy)), + Var("addr",F64)), + Mop(Snd, + Apply + (Call + ("write'BranchDelayPCC", + ATy(qTy, + PTy(uTy,qTy)), + LO(PTy(F64, + CTy"Capability"))), + qVar"s"))))))), + (TP[LO F64,LO F64, + LO(PTy(F64,CTy"Capability")), + Mop(Some, + TP[Var("addr",F64), + Var("cap",CTy"Capability")])], + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'BranchToPCC", + ATy(qTy,PTy(uTy,qTy)), + LO(PTy(F64,CTy"Capability"))), + Mop(Snd, + Apply + (Call + ("write'BranchDelayPCC", + ATy(qTy,PTy(uTy,qTy)), + Mop(Some, + TP[Var("addr",F64), + Var("cap", + CTy"Capability")])), + qVar"s")))), + Mop(Snd, + Apply + (Call + ("write'PC", + ATy(qTy,PTy(uTy,qTy)), + Bop(Add, + Mop(Fst, + Apply + (Const + ("PC", + ATy(qTy, + PTy(F64,qTy))), + qVar"s")),LW(4,64))), + qVar"s")))), + (AVar + (PTy(OTy F64, + PTy(OTy F64, + PTy(OTy(PTy(F64,CTy"Capability")), + OTy(PTy(F64,CTy"Capability")))))), + Mop(Snd, + Apply + (Call + ("raise'exception", + ATy(qTy,PTy(uTy,qTy)), + Call + ("UNPREDICTABLE", + CTy"exception", + LS"Branch follows branch")), + qVar"s")))]))), + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Count", + TP[Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__",qTy))), + qVar"s")), + Bop(Add, + Dest + ("Count",F32, + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))),qVar"s"))), + LW(1,32))])),qVar"s")))))) +; +val hasCP2_def = Def0 ("hasCP2",LT) +; +val COP2Init_def = Def + ("COP2Init",AVar uTy, + Close + (qVar"state", + TP[LU, + Let(Var("s",PTy(CTy"CapCause",qTy)), + TP[Rupd("ExcCode",TP[LX(CTy"CapCause"),LW(0,8)]), + Rupd("TAG",TP[qVar"state",Mop(K1(FTy 35),LF)])], + Let(Var("s",PTy(CTy"CapCause",qTy)), + TP[Rupd + ("RegNum", + TP[Mop(Fst,Var("s",PTy(CTy"CapCause",qTy))),LW(0,8)]), + Mop(Snd,Var("s",PTy(CTy"CapCause",qTy)))], + Let(Var("s",PTy(CTy"Capability",PTy(CTy"CapCause",qTy))), + TP[Rupd("tag",TP[LX(CTy"Capability"),LT]), + Mop(Fst,Var("s",PTy(CTy"CapCause",qTy))), + Mop(Snd, + Apply + (Call + ("write'capcause",ATy(qTy,PTy(uTy,qTy)), + Mop(Fst,Var("s",PTy(CTy"CapCause",qTy)))), + Mop(Snd,Var("s",PTy(CTy"CapCause",qTy)))))], + Let(Var("s", + PTy(CTy"Capability",PTy(CTy"CapCause",qTy))), + TP[Rupd + ("sealed", + TP[Mop(Fst, + Var("s", + PTy(CTy"Capability", + PTy(CTy"CapCause",qTy)))),LF]), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + PTy(CTy"CapCause",qTy))))], + Let(Var("s", + PTy(CTy"Capability", + PTy(CTy"CapCause",qTy))), + TP[Rupd + ("offset", + TP[Mop(Fst, + Var("s", + PTy(CTy"Capability", + PTy(CTy"CapCause",qTy)))), + LW(0,64)]), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + PTy(CTy"CapCause",qTy))))], + Let(Var("s", + PTy(CTy"Capability", + PTy(CTy"CapCause",qTy))), + TP[Rupd + ("base", + TP[Mop(Fst, + Var("s", + PTy(CTy"Capability", + PTy(CTy"CapCause", + qTy)))),LW(0,64)]), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + PTy(CTy"CapCause",qTy))))], + Let(Var("s", + PTy(CTy"Capability", + PTy(CTy"CapCause",qTy))), + TP[Rupd + ("length", + TP[Mop(Fst, + Var("s", + PTy(CTy"Capability", + PTy(CTy"CapCause", + qTy)))), + Mop(BNot,LW(0,64))]), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + PTy(CTy"CapCause",qTy))))], + Let(Var("s", + PTy(CTy"Capability", + PTy(CTy"CapCause",qTy))), + TP[Rupd + ("otype", + TP[Mop(Fst, + Var("s", + PTy(CTy"Capability", + PTy(CTy"CapCause", + qTy)))), + LW(0,24)]), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + PTy(CTy"CapCause", + qTy))))], + Let(Var("s", + PTy(CTy"Capability", + PTy(CTy"CapCause",qTy))), + TP[Rupd + ("perms", + TP[Mop(Fst, + Var("s", + PTy(CTy"Capability", + PTy(CTy"CapCause", + qTy)))), + Mop(BNot,LW(0,31))]), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + PTy(CTy"CapCause", + qTy))))], + Let(Var("s", + PTy(CTy"Capability", + PTy(CTy"CapCause", + qTy))), + TP[Rupd + ("reserved", + TP[Mop(Fst, + Var("s", + PTy(CTy"Capability", + PTy(CTy"CapCause", + qTy)))), + LW(0,8)]), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + PTy(CTy"CapCause", + qTy))))], + Mop(Snd, + Mop(Snd, + Mop(Snd, + Apply + (For(TP[LN + 0, + LN + 31, + Close + (nVar"i", + Close + (Var("state", + PTy(CTy"Capability", + PTy(CTy"CapCause", + qTy))), + TP[LU, + Mop(Fst, + Var("state", + PTy(CTy"Capability", + PTy(CTy"CapCause", + qTy)))), + Mop(Fst, + Mop(Snd, + Var("state", + PTy(CTy"Capability", + PTy(CTy"CapCause", + qTy))))), + Mop(Snd, + Apply + (Call + ("write'CAPR", + ATy(qTy, + PTy(uTy, + qTy)), + TP[Mop(Fst, + Var("state", + PTy(CTy"Capability", + PTy(CTy"CapCause", + qTy)))), + Mop(Cast + (FTy 5), + nVar"i")]), + Mop(Snd, + Mop(Snd, + Var("state", + PTy(CTy"Capability", + PTy(CTy"CapCause", + qTy)))))))]))]), + TP[Mop(Fst, + Var("s", + PTy(CTy"Capability", + PTy(CTy"CapCause", + qTy)))), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(CTy"Capability", + PTy(CTy"CapCause", + qTy))))), + Mop(Snd, + Apply + (Call + ("write'PCC", + ATy(qTy, + PTy(uTy, + qTy)), + Mop(Fst, + Var("s", + PTy(CTy"Capability", + PTy(CTy"CapCause", + qTy))))), + Mop(Snd, + Mop(Snd, + Var("s", + PTy(CTy"Capability", + PTy(CTy"CapCause", + qTy)))))))]))))))))))))))])) +; +val initTLB_def = Def + ("initTLB",qVar"state", + Let(TP[Var("r",CTy"TLBEntry"),Var("s1",PTy(CTy"TLBEntry",qTy))], + Let(Var("s",PTy(CTy"TLBEntry",qTy)), + TP[Rupd("R",TP[LX(CTy"TLBEntry"),LW(2,2)]),qVar"state"], + TP[Mop(Fst,Var("s",PTy(CTy"TLBEntry",qTy))), + Var("s",PTy(CTy"TLBEntry",qTy))]), + TP[Var("r",CTy"TLBEntry"),Mop(Snd,Var("s1",PTy(CTy"TLBEntry",qTy)))])) +; +val initMips_def = Def + ("initMips",TP[nVar"pc",nVar"uart"], + Close + (qVar"state", + Let(Var("v",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"state")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Config", + TP[Var("v",CTy"CP0__renamed__"), + Rupd + ("M", + TP[Dest + ("Config",CTy"ConfigRegister", + Var("v",CTy"CP0__renamed__")),LT])])), + qVar"state")), + Let(Var("v",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Config", + TP[Var("v",CTy"CP0__renamed__"), + Rupd + ("BE", + TP[Dest + ("Config", + CTy"ConfigRegister", + Var("v",CTy"CP0__renamed__")), + LT])])),qVar"s")), + Let(Var("v",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Config", + TP[Var("v",CTy"CP0__renamed__"), + Rupd + ("MT", + TP[Dest + ("Config", + CTy"ConfigRegister", + Var("v", + CTy"CP0__renamed__")), + LW(1,3)])])),qVar"s")), + Let(Var("v",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))),qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Config", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("AR", + TP[Dest + ("Config", + CTy"ConfigRegister", + Var("v", + CTy"CP0__renamed__")), + LW(0,3)])])), + qVar"s")), + Let(Var("v",CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))),qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy,qTy)), + Rupd + ("Config", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("AT", + TP[Dest + ("Config", + CTy"ConfigRegister", + Var("v", + CTy"CP0__renamed__")), + LW(2,2)])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Config1", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("M", + TP[Dest + ("Config1", + CTy"ConfigRegister1", + Var("v", + CTy"CP0__renamed__")), + LT])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Config1", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("MMUSize", + TP[Dest + ("Config1", + CTy"ConfigRegister1", + Var("v", + CTy"CP0__renamed__")), + LW(15, + 6)])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Config1", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("IS", + TP[Dest + ("Config1", + CTy"ConfigRegister1", + Var("v", + CTy"CP0__renamed__")), + LW(3, + 3)])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Config1", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("IL", + TP[Dest + ("Config1", + CTy"ConfigRegister1", + Var("v", + CTy"CP0__renamed__")), + LW(4, + 3)])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Config1", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("IA", + TP[Dest + ("Config1", + CTy"ConfigRegister1", + Var("v", + CTy"CP0__renamed__")), + LW(0, + 3)])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Config1", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("DS", + TP[Dest + ("Config1", + CTy"ConfigRegister1", + Var("v", + CTy"CP0__renamed__")), + LW(3, + 3)])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Config1", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("DL", + TP[Dest + ("Config1", + CTy"ConfigRegister1", + Var("v", + CTy"CP0__renamed__")), + LW(4, + 3)])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Config1", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("DA", + TP[Dest + ("Config1", + CTy"ConfigRegister1", + Var("v", + CTy"CP0__renamed__")), + LW(0, + 3)])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Config1", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("C2", + TP[Dest + ("Config1", + CTy"ConfigRegister1", + Var("v", + CTy"CP0__renamed__")), + Const + ("hasCP2", + bTy)])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Config1", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("MD", + TP[Dest + ("Config1", + CTy"ConfigRegister1", + Var("v", + CTy"CP0__renamed__")), + LF])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Config1", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("PCR", + TP[Dest + ("Config1", + CTy"ConfigRegister1", + Var("v", + CTy"CP0__renamed__")), + LF])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Config1", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("WR", + TP[Dest + ("Config1", + CTy"ConfigRegister1", + Var("v", + CTy"CP0__renamed__")), + LF])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Config1", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("CA", + TP[Dest + ("Config1", + CTy"ConfigRegister1", + Var("v", + CTy"CP0__renamed__")), + LF])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Config1", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("EP", + TP[Dest + ("Config1", + CTy"ConfigRegister1", + Var("v", + CTy"CP0__renamed__")), + LF])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Config1", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("FP", + TP[Dest + ("Config1", + CTy"ConfigRegister1", + Var("v", + CTy"CP0__renamed__")), + LF])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Config2", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("M", + TP[Dest + ("Config2", + CTy"ConfigRegister2", + Var("v", + CTy"CP0__renamed__")), + LT])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Config2", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("TU", + TP[Dest + ("Config2", + CTy"ConfigRegister2", + Var("v", + CTy"CP0__renamed__")), + LW(0, + 3)])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Config2", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("TS", + TP[Dest + ("Config2", + CTy"ConfigRegister2", + Var("v", + CTy"CP0__renamed__")), + LW(0, + 4)])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Config2", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("TL", + TP[Dest + ("Config2", + CTy"ConfigRegister2", + Var("v", + CTy"CP0__renamed__")), + LW(0, + 4)])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Config2", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("TA", + TP[Dest + ("Config2", + CTy"ConfigRegister2", + Var("v", + CTy"CP0__renamed__")), + LW(0, + 4)])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Config2", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("SU", + TP[Dest + ("Config2", + CTy"ConfigRegister2", + Var("v", + CTy"CP0__renamed__")), + LW(3, + 4)])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Config2", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("SS", + TP[Dest + ("Config2", + CTy"ConfigRegister2", + Var("v", + CTy"CP0__renamed__")), + LW(8, + 4)])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Config2", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("SL", + TP[Dest + ("Config2", + CTy"ConfigRegister2", + Var("v", + CTy"CP0__renamed__")), + LW(4, + 4)])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Config2", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("SA", + TP[Dest + ("Config2", + CTy"ConfigRegister2", + Var("v", + CTy"CP0__renamed__")), + LW(0, + 4)])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Config3", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("M", + TP[Dest + ("Config3", + CTy"ConfigRegister3", + Var("v", + CTy"CP0__renamed__")), + LT])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Config3", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("ULRI", + TP[Dest + ("Config3", + CTy"ConfigRegister3", + Var("v", + CTy"CP0__renamed__")), + LT])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Config3", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("DSPP", + TP[Dest + ("Config3", + CTy"ConfigRegister3", + Var("v", + CTy"CP0__renamed__")), + LF])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Config3", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("LPA", + TP[Dest + ("Config3", + CTy"ConfigRegister3", + Var("v", + CTy"CP0__renamed__")), + LF])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Config3", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("VEIC", + TP[Dest + ("Config3", + CTy"ConfigRegister3", + Var("v", + CTy"CP0__renamed__")), + LF])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Config3", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("VInt", + TP[Dest + ("Config3", + CTy"ConfigRegister3", + Var("v", + CTy"CP0__renamed__")), + LF])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Config3", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("SP", + TP[Dest + ("Config3", + CTy"ConfigRegister3", + Var("v", + CTy"CP0__renamed__")), + LF])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Config3", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("MT", + TP[Dest + ("Config3", + CTy"ConfigRegister3", + Var("v", + CTy"CP0__renamed__")), + LF])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Config3", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("SM", + TP[Dest + ("Config3", + CTy"ConfigRegister3", + Var("v", + CTy"CP0__renamed__")), + LF])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Config3", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("TL", + TP[Dest + ("Config3", + CTy"ConfigRegister3", + Var("v", + CTy"CP0__renamed__")), + LF])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Config6", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("TLBSize", + TP[Dest + ("Config6", + CTy"ConfigRegister6", + Var("v", + CTy"CP0__renamed__")), + LW(143, + 16)])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Config6", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("LTLB", + TP[Dest + ("Config6", + CTy"ConfigRegister6", + Var("v", + CTy"CP0__renamed__")), + LF])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Status", + TP[Var("v", + CTy"CP0__renamed__"), + Call + ("write'reg'StatusRegister", + CTy"StatusRegister", + TP[Dest + ("Status", + CTy"StatusRegister", + Var("v", + CTy"CP0__renamed__")), + LW(0, + 32)])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Status", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("BEV", + TP[Dest + ("Status", + CTy"StatusRegister", + Var("v", + CTy"CP0__renamed__")), + LT])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Status", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("KSU", + TP[Dest + ("Status", + CTy"StatusRegister", + Var("v", + CTy"CP0__renamed__")), + LW(0, + 2)])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Status", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("EXL", + TP[Dest + ("Status", + CTy"StatusRegister", + Var("v", + CTy"CP0__renamed__")), + LF])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Status", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("ERL", + TP[Dest + ("Status", + CTy"StatusRegister", + Var("v", + CTy"CP0__renamed__")), + LF])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Status", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("KX", + TP[Dest + ("Status", + CTy"StatusRegister", + Var("v", + CTy"CP0__renamed__")), + LT])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Status", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("SX", + TP[Dest + ("Status", + CTy"StatusRegister", + Var("v", + CTy"CP0__renamed__")), + LT])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Status", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("UX", + TP[Dest + ("Status", + CTy"StatusRegister", + Var("v", + CTy"CP0__renamed__")), + LT])])), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Count", + TP[Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + LW(0, + 32)])), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Compare", + TP[Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + LW(0, + 32)])), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("PRId", + TP[Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + LW(1024, + 32)])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Index", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("P", + TP[Dest + ("Index", + CTy"Index", + Var("v", + CTy"CP0__renamed__")), + LF])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Index", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("Index", + TP[Dest + ("Index", + CTy"Index", + Var("v", + CTy"CP0__renamed__")), + LW(0, + 8)])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Random", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("Random", + TP[Dest + ("Random", + CTy"Random", + Var("v", + CTy"CP0__renamed__")), + Mop(Cast + F8, + Bop(Sub, + Const + ("TLBEntries", + nTy), + LN + 1))])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("Wired", + TP[Var("v", + CTy"CP0__renamed__"), + Rupd + ("Wired", + TP[Dest + ("Wired", + CTy"Wired", + Var("v", + CTy"CP0__renamed__")), + LW(0, + 8)])])), + qVar"s")), + Let(Var("v", + CTy"CP0__renamed__"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0__renamed__", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (For(TP[LN + 0, + LN + 31, + Close + (nVar"i", + Close + (qVar"state", + Apply + (Call + ("write'gpr", + ATy(qTy, + PTy(uTy, + qTy)), + TP[LW(12297829382473034410, + 64), + Mop(Cast + (FTy 5), + nVar"i")]), + qVar"state")))]), + Rupd + ("done", + TP[Mop(Snd, + Apply + (Call + ("COP2Init", + ATy(qTy, + PTy(uTy, + qTy)), + LU), + Mop(Snd, + Apply + (Call + ("write'PC", + ATy(qTy, + PTy(uTy, + qTy)), + Mop(Cast + F64, + nVar"pc")), + Mop(Snd, + Apply + (Call + ("write'lo", + ATy(qTy, + PTy(uTy, + qTy)), + LO F64), + Mop(Snd, + Apply + (Call + ("write'hi", + ATy(qTy, + PTy(uTy, + qTy)), + LO F64), + Mop(Snd, + Apply + (Call + ("write'LLbit", + ATy(qTy, + PTy(uTy, + qTy)), + LO bTy), + Mop(Snd, + Apply + (Call + ("write'BranchTo", + ATy(qTy, + PTy(uTy, + qTy)), + LO F64), + Mop(Snd, + Apply + (Call + ("write'BranchDelay", + ATy(qTy, + PTy(uTy, + qTy)), + LO F64), + Mop(Snd, + Apply + (For(TP[LN + 0, + LN + 127, + Close + (nVar"i", + Close + (qVar"state", + Apply + (Call + ("write'TLB_assoc", + ATy(qTy, + PTy(uTy, + qTy)), + TP[Mop(Fst, + Apply + (Const + ("initTLB", + ATy(qTy, + PTy(CTy"TLBEntry", + qTy))), + qVar"state")), + Mop(Cast + F4, + nVar"i")]), + qVar"state")))]), + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("HWREna", + TP[Var("v", + CTy"CP0__renamed__"), + Call + ("write'reg'HWREna", + CTy"HWREna", + TP[Dest + ("HWREna", + CTy"HWREna", + Var("v", + CTy"CP0__renamed__")), + LW(0, + 32)])])), + qVar"s")))))))))))))))))), + LF]))), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("PIC_initialise", + ATy(qTy, + PTy(uTy, + qTy)), + Bop(Add, + LN + 2139111424, + Bop(Mul, + Mop(Cast + nTy, + Dest + ("procID", + F8, + qVar"s")), + LN + 16384))), + qVar"s")), + ITE(EQ(Dest + ("procID", + F8, + qVar"s"), + LW(0, + 8)), + Apply + (Const + ("InitMEM", + ATy(qTy, + PTy(uTy, + qTy))), + Mop(Snd, + Apply + (Call + ("JTAG_UART_initialise", + ATy(qTy, + PTy(uTy, + qTy)), + nVar"uart"), + qVar"s"))), + TP[LU, + qVar"s"]))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) + +val () = Import.finish 1 \ No newline at end of file From b8492ebdb874d0e330405033cb4cda411ad7de19 Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Thu, 27 Nov 2014 15:20:05 +0000 Subject: [PATCH 034/718] Add support for MIPS instructions SC and SCD. --- .../mips/prog/mips_progLib.sml | 2 + .../mips/step/mips_stepLib.sml | 16 +++++- .../mips/step/mips_stepScript.sml | 49 +++++++++++++++++++ 3 files changed, 66 insertions(+), 1 deletion(-) diff --git a/examples/l3-machine-code/mips/prog/mips_progLib.sml b/examples/l3-machine-code/mips/prog/mips_progLib.sml index 43c5ef05c4..f4948d5a4e 100644 --- a/examples/l3-machine-code/mips/prog/mips_progLib.sml +++ b/examples/l3-machine-code/mips/prog/mips_progLib.sml @@ -96,6 +96,8 @@ val state_id = ["CP0", "PC", "gpr", "hi", "lo"], ["CP0", "LLbit", "MEM", "PC"], ["CP0", "MEM", "PC"], + ["CP0", "MEM", "PC", "exceptionSignalled", "gpr"], + ["MEM", "PC", "exceptionSignalled", "gpr"], ["MEM", "PC"], ["gpr", "hi", "lo"], ["gpr"]] diff --git a/examples/l3-machine-code/mips/step/mips_stepLib.sml b/examples/l3-machine-code/mips/step/mips_stepLib.sml index b0713f8515..a3cffe53e3 100644 --- a/examples/l3-machine-code/mips/step/mips_stepLib.sml +++ b/examples/l3-machine-code/mips/step/mips_stepLib.sml @@ -95,7 +95,7 @@ fun mips_thms thms = val COND_UPDATE_CONV = REWRITE_CONV (utilsLib.mk_cond_update_thms [``:mips_state``, ``:CP0``, ``:StatusRegister``]) - THENC REWRITE_CONV (mips_thms []) + THENC REWRITE_CONV (mips_stepTheory.cond_update_memory :: mips_thms []) val COND_UPDATE_RULE = Conv.CONV_RULE COND_UPDATE_CONV @@ -491,6 +491,18 @@ val SD = EVR (store_rule []) (dfn'SD_def :: mem_thms) dmemcntxts [] ``dfn'SD (base, rt, offset)`` +val sc = List.map (fn l => ``^st.LLbit = SOME llbit`` :: l) + +val SC = + EVR (COND_UPDATE_RULE o store_rule [bit_1_0_2_0, bit_1_0_2_0_4]) + ([dfn'SC_def, extract_word] @ mem_thms) (sc memcntxts) [] + ``dfn'SC (base, rt, offset)`` + +val SCD = + EVR (COND_UPDATE_RULE o store_rule []) + ([dfn'SCD_def, extract_word] @ mem_thms) (sc dmemcntxts) [] + ``dfn'SCD (base, rt, offset)`` + (* ------------------------------------------------------------------------- *) (* Coprocessor instructions *) @@ -725,6 +737,8 @@ val mips_patterns = List.map (I ## utilsLib.pattern) ("LL", "TTFFFF__________________________"), ("LLD", "TTFTFF__________________________"), ("LD", "TTFTTT__________________________"), + ("SC", "TTTFFF__________________________"), + ("SCD", "TTTTFF__________________________"), ("SD", "TTTTTT__________________________"), ("ERET", "FTFFFFTFFFFFFFFFFFFFFFFFFFFTTFFF") ] diff --git a/examples/l3-machine-code/mips/step/mips_stepScript.sml b/examples/l3-machine-code/mips/step/mips_stepScript.sml index cc724a826e..97a006b238 100644 --- a/examples/l3-machine-code/mips/step/mips_stepScript.sml +++ b/examples/l3-machine-code/mips/step/mips_stepScript.sml @@ -542,6 +542,55 @@ val StoreMemory_doubleword = Q.store_thm("StoreMemory_doubleword", (* ------------------------------------------------------------------------ *) +val cond_update_memory = Q.store_thm("cond_update_memory", + `(!a: word64 b x0 x1 x2 x3 m. + (if b then + (a =+ x0) ((a + 1w =+ x1) ((a + 2w =+ x2) ((a + 3w =+ x3) m))) + else m) = + (a =+ (if b then x0 else m a)) + ((a + 1w =+ (if b then x1 else m (a + 1w))) + ((a + 2w =+ (if b then x2 else m (a + 2w))) + ((a + 3w =+ (if b then x3 else m (a + 3w))) m)))) /\ + (!a: word64 b x0 x1 x2 x3 m. + (if b then + (a + 3w =+ x0) ((a + 2w =+ x1) ((a + 1w =+ x2) ((a =+ x3) m))) + else m) = + (a + 3w =+ (if b then x0 else m (a + 3w))) + ((a + 2w =+ (if b then x1 else m (a + 2w))) + ((a + 1w =+ (if b then x2 else m (a + 1w))) + ((a =+ (if b then x3 else m a)) m)))) /\ + (!a: word64 b x0 x1 x2 x3 x4 x5 x6 x7 m. + (if b then + (a =+ x0) ((a + 1w =+ x1) ((a + 2w =+ x2) ((a + 3w =+ x3) + ((a + 4w =+ x4) ((a + 5w =+ x5) ((a + 6w =+ x6) + ((a + 7w =+ x7) m))))))) + else m) = + (a =+ (if b then x0 else m a)) + ((a + 1w =+ (if b then x1 else m (a + 1w))) + ((a + 2w =+ (if b then x2 else m (a + 2w))) + ((a + 3w =+ (if b then x3 else m (a + 3w))) + ((a + 4w =+ (if b then x4 else m (a + 4w))) + ((a + 5w =+ (if b then x5 else m (a + 5w))) + ((a + 6w =+ (if b then x6 else m (a + 6w))) + ((a + 7w =+ (if b then x7 else m (a + 7w))) m)))))))) /\ + (!a: word64 b x0 x1 x2 x3 x4 x5 x6 x7 m. + (if b then + (a + 7w =+ x0) ((a + 6w =+ x1) ((a + 5w =+ x2) ((a + 4w =+ x3) + ((a + 3w =+ x4) ((a + 2w =+ x5) ((a + 1w =+ x6) ((a =+ x7) m))))))) + else m) = + (a + 7w =+ (if b then x0 else m (a + 7w))) + ((a + 6w =+ (if b then x1 else m (a + 6w))) + ((a + 5w =+ (if b then x2 else m (a + 5w))) + ((a + 4w =+ (if b then x3 else m (a + 4w))) + ((a + 3w =+ (if b then x4 else m (a + 3w))) + ((a + 2w =+ (if b then x5 else m (a + 2w))) + ((a + 1w =+ (if b then x6 else m (a + 1w))) + ((a =+ (if b then x7 else m a)) m))))))))`, + rw [combinTheory.UPDATE_def, FUN_EQ_THM] + ) + +(* ------------------------------------------------------------------------ *) + val branch_delay = Q.store_thm("branch_delay", `(!b x y. (case (if b then (F, x) else (T, y)) of From 88a392b2177a0b3aa3fd20540706955a4b803be5 Mon Sep 17 00:00:00 2001 From: Brian Campbell Date: Thu, 27 Nov 2014 15:20:16 +0000 Subject: [PATCH 035/718] Fix optionSyntax.is_is_some --- src/option/optionSyntax.sml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/option/optionSyntax.sml b/src/option/optionSyntax.sml index d45f14bed3..1913fb2955 100644 --- a/src/option/optionSyntax.sml +++ b/src/option/optionSyntax.sml @@ -101,7 +101,7 @@ val is_none = can dest_none val is_some = can dest_some val is_the = can dest_the val is_is_none = can dest_is_none -val is_is_some = can dest_is_none +val is_is_some = can dest_is_some val is_option_map = can dest_option_map val is_option_join = can dest_option_join val is_option_case = can dest_option_case From 8230d99eb54a5e3da0c5e5e896cd27be25a713a7 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Sat, 29 Nov 2014 18:21:40 +1100 Subject: [PATCH 036/718] some new doc files to do with list_tactics --- help/Docfiles/Tactical.ALLGOALS.doc | 27 +++++++++++++ help/Docfiles/Tactical.ALL_LT.doc | 27 +++++++++++++ help/Docfiles/Tactical.HEADGOAL.doc | 33 ++++++++++++++++ help/Docfiles/Tactical.LASTGOAL.doc | 33 ++++++++++++++++ help/Docfiles/Tactical.NTH_GOAL.doc | 35 +++++++++++++++++ help/Docfiles/Tactical.REVERSE_LT.doc | 24 ++++++++++++ help/Docfiles/Tactical.ROTATE_LT.doc | 33 ++++++++++++++++ help/Docfiles/Tactical.SPLIT_LT.doc | 35 +++++++++++++++++ help/Docfiles/Tactical.TACS_TO_LT.doc | 33 ++++++++++++++++ help/Docfiles/Tactical.THEN_LT.doc | 55 +++++++++++++++++++++++++++ src/1/Tactical.sml | 3 +- 11 files changed, 337 insertions(+), 1 deletion(-) create mode 100644 help/Docfiles/Tactical.ALLGOALS.doc create mode 100644 help/Docfiles/Tactical.ALL_LT.doc create mode 100644 help/Docfiles/Tactical.HEADGOAL.doc create mode 100644 help/Docfiles/Tactical.LASTGOAL.doc create mode 100644 help/Docfiles/Tactical.NTH_GOAL.doc create mode 100644 help/Docfiles/Tactical.REVERSE_LT.doc create mode 100644 help/Docfiles/Tactical.ROTATE_LT.doc create mode 100644 help/Docfiles/Tactical.SPLIT_LT.doc create mode 100644 help/Docfiles/Tactical.TACS_TO_LT.doc create mode 100644 help/Docfiles/Tactical.THEN_LT.doc diff --git a/help/Docfiles/Tactical.ALLGOALS.doc b/help/Docfiles/Tactical.ALLGOALS.doc new file mode 100644 index 0000000000..66f6dba6ff --- /dev/null +++ b/help/Docfiles/Tactical.ALLGOALS.doc @@ -0,0 +1,27 @@ +\DOC ALLGOALS + +\TYPE {ALLGOALS : tactic -> list_tactic} + +\SYNOPSIS +Applies a tactic to every goal in a list + +\KEYWORDS +tactical, list_tactic. + +\DESCRIBE +If {tac} is a tactic, {ALLGOALS tac} is a list_tactic which +applies the tactic {tac} to all the goals in the given list. + +\FAILURE +The application of {ALLGOALS} to a tactic never fails. +The resulting list_tactic fails if +{tac} fails when applied to any of the goals in the given list. + +\EXAMPLE +Where {tac1} and {tac2} are tactics, +{tac1 THEN_LT ALLGOALS tac2} is equivalent to {tac1 THEN tac2} + +\SEEALSO +Tactical.THEN_LT, Tactical.THEN +\ENDDOC + diff --git a/help/Docfiles/Tactical.ALL_LT.doc b/help/Docfiles/Tactical.ALL_LT.doc new file mode 100644 index 0000000000..b7475a5ced --- /dev/null +++ b/help/Docfiles/Tactical.ALL_LT.doc @@ -0,0 +1,27 @@ +\DOC ALL_LT + +\TYPE {ALL_LT : list_tactic} + +\SYNOPSIS +Passes on a goal list unchanged. + +\KEYWORDS +list_tactic, identity. + +\DESCRIBE +{ALL_LT} applied to a goal list {gl} +simply produces the goal list {gl}. It is +the identity for the {THEN_LT} tactical. + +\FAILURE +Never fails. + +\EXAMPLE +To apply tactic {tac1} to a goal, and then to apply {tac2} +to all resulting subgoals except the first, use +{ + tac1 THEN_LT SPLIT_LT 1 (ALL_LT, ALLGOALS tac2) +} +\SEEALSO +Tactical.THEN_LT, Tactical.SPLIT_LT, Tactical.ALLGOALS +\ENDDOC diff --git a/help/Docfiles/Tactical.HEADGOAL.doc b/help/Docfiles/Tactical.HEADGOAL.doc new file mode 100644 index 0000000000..8460e4a075 --- /dev/null +++ b/help/Docfiles/Tactical.HEADGOAL.doc @@ -0,0 +1,33 @@ +\DOC HEADGOAL + +\TYPE {HEADGOAL : tactic -> list_tactic} + +\SYNOPSIS +The list_tactic which applies a tactic to the first member of a list of goals. + +\KEYWORDS +tactical. + +\DESCRIBE +If {tac} is a tactic, {HEADGOAL tac} is a +list_tactic which applies the tactic {tac} to the +first member of a list of goals. + +\FAILURE +The application of {HEADGOAL} to a tactic never fails. +The resulting list_tactic fails the goal list is empty or +or finally if {tac} fails when applied to the first member of the goal list. + +\USES +Applying a tactic to the first subgoal. + +\EXAMPLE +Where {tac1} and {tac2} are tactics, {tac1 THEN_LT HEADGOAL tac2} +applies {tac1} to a goal, and then applies {tac2} to the first resulting +subgoal. + +\SEEALSO +Tactical.THEN_LT, Tactical.NTH_GOAL, Tactical.THEN1, Tactical.LASTGOAL. +\ENDDOC + + diff --git a/help/Docfiles/Tactical.LASTGOAL.doc b/help/Docfiles/Tactical.LASTGOAL.doc new file mode 100644 index 0000000000..65e6367540 --- /dev/null +++ b/help/Docfiles/Tactical.LASTGOAL.doc @@ -0,0 +1,33 @@ +\DOC LASTGOAL + +\TYPE {LASTGOAL : tactic -> list_tactic} + +\SYNOPSIS +The list_tactic which applies a tactic to the last member of a list of goals. + +\KEYWORDS +tactical. + +\DESCRIBE +If {tac} is a tactic, {LASTGOAL tac} is a +list_tactic which applies the tactic {tac} to the +last member of a list of goals. + +\FAILURE +The application of {LASTGOAL} to a tactic never fails. +The resulting list_tactic fails the goal list is empty or +or finally if {tac} fails when applied to the last member of the goal list. + +\USES +Applying a tactic to the last subgoal. + +\EXAMPLE +Where {tac1} and {tac2} are tactics, {tac1 THEN_LT LASTGOAL tac2} +applies {tac1} to a goal, and then applies {tac2} to the last resulting +subgoal. + +\SEEALSO +Tactical.THEN_LT, Tactical.NTH_GOAL, Tactical.HEADGOAL. +\ENDDOC + + diff --git a/help/Docfiles/Tactical.NTH_GOAL.doc b/help/Docfiles/Tactical.NTH_GOAL.doc new file mode 100644 index 0000000000..3e525ac04f --- /dev/null +++ b/help/Docfiles/Tactical.NTH_GOAL.doc @@ -0,0 +1,35 @@ +\DOC NTH_GOAL + +\TYPE {NTH_GOAL : tactic -> int -> list_tactic} + +\SYNOPSIS +The list_tactic which applies a tactic to the +{n}'th member of a list of goals. + +\KEYWORDS +tactical. + +\DESCRIBE +If {tac} is a tactic, {NTH_GOAL n tac} is a +list_tactic which applies the tactic {tac} to the +{n}'th member of a list of goals. + +\FAILURE +The application of {NTH_GOAL} to a tactic and integer never fails. +The resulting list_tactic fails if {n} is less than 1 or greater than the +length of the goal list, +or finally if {tac} fails when applied to the {n}'th member of the goal list. + +\USES +Applying a tactic to a particular subgoal. + +\EXAMPLE +Where {tac1} and {tac2} are tactics, {tac1 THEN_LT NTH_GOAL n tac2} +applies {tac1} to a goal, and then applies {tac2} to the {n}'th resulting +subgoal. + +\SEEALSO +Tactical.THEN_LT, Tactical.THEN1, Tactical.HEADGOAL, Tactical.LASTGOAL. +\ENDDOC + + diff --git a/help/Docfiles/Tactical.REVERSE_LT.doc b/help/Docfiles/Tactical.REVERSE_LT.doc new file mode 100644 index 0000000000..db94a2b606 --- /dev/null +++ b/help/Docfiles/Tactical.REVERSE_LT.doc @@ -0,0 +1,24 @@ +\DOC REVERSE_LT + +\TYPE {REVERSE_LT : list_tactic} + +\SYNOPSIS +Reverses the order of a list of subgoals. + +\KEYWORDS +list_tactic. + +\DESCRIBE +The list_tactic {REVERSE_LT} reverses +the order of a list of subgoals. + +\FAILURE +Never fails. + +\EXAMPLE +Where {tac} is a tactic, +{tac THEN_LT REVERSE_LT} is equivalent to {REVERSE tac} + +\SEEALSO +Tactical.THEN_LT, Tactical.REVERSE, Tactical.ROTATE_LT +\ENDDOC diff --git a/help/Docfiles/Tactical.ROTATE_LT.doc b/help/Docfiles/Tactical.ROTATE_LT.doc new file mode 100644 index 0000000000..72a57ca89e --- /dev/null +++ b/help/Docfiles/Tactical.ROTATE_LT.doc @@ -0,0 +1,33 @@ +\DOC ROTATE_LT + +\TYPE {ROTATE_LT : int -> list_tactic} + +\SYNOPSIS +Rotates a list of goals + +\KEYWORDS +list_tactic. + +\DESCRIBE +{ROTATE_LT n gl} rotates a goal list {gl} by {n} places. +For {n >= 0}, this means moving the first {n} goals to the end of the list. +A negative {n} means rotating the list in the opposite direction. + +\FAILURE +Never fails. + +\EXAMPLE +To bring the third goal to first position, leaving the others in order, use +{ + SPLIT_LT 3 (ROTATE_LT ~1, ALL_LT) +} + +\COMMENTS +Using {SPLIT_LT}, {ROTATE_LT} and {REVERSE_LT}, +any reordering of a list of goals is possible. + +\SEEALSO +proofManagerLib.rotate, proofManagerLib.r, +Tactical.SPLIT_LT, Tactical.REVERSE_LT, Tactical.ALL_LT +\ENDDOC + diff --git a/help/Docfiles/Tactical.SPLIT_LT.doc b/help/Docfiles/Tactical.SPLIT_LT.doc new file mode 100644 index 0000000000..3c2896772d --- /dev/null +++ b/help/Docfiles/Tactical.SPLIT_LT.doc @@ -0,0 +1,35 @@ +\DOC SPLIT_LT + +\TYPE {SPLIT_LT : int -> list_tactic * list_tactic -> list_tactic} + +\SYNOPSIS +Splits a list of goals into two and applies a list_tactic to each part + +\KEYWORDS +list_tactic. + +\DESCRIBE +For list_tactics {ltac1} and {ltac2}, integer {n} and goal list {gl}, +the application {SPLIT_LT n (ltac1, ltac2) gl} +applies {ltac1} to the first {n} goals in {gl}, and {ltac2} to the remainder. +If {n} is negative, {ltac1} is applied to the goals before the last {-n}, +and {ltac2} to the last {-n} goals. + +\FAILURE +The application {SPLIT_LT n (ltac1, ltac2)} never fails, +but when applied to a goal list, +it fails if the index {n} is (in absolute value) +larger then the length of the list, +or if either of the list_tactics {ltac1} and {ltac2} fails. + +\EXAMPLE +To apply tactic {tac1} to a goal, and then to apply {tac2} +to all resulting subgoals except the first, use +{ + tac1 THEN_LT SPLIT_LT 1 (ALL_LT, ALLGOALS tac2) +} + +\SEEALSO +Tactical.THEN_LT, Tactical.ALL_LT, Tactical.ALLGOALS +\ENDDOC + diff --git a/help/Docfiles/Tactical.TACS_TO_LT.doc b/help/Docfiles/Tactical.TACS_TO_LT.doc new file mode 100644 index 0000000000..06565d1076 --- /dev/null +++ b/help/Docfiles/Tactical.TACS_TO_LT.doc @@ -0,0 +1,33 @@ +\DOC TACS_TO_LT + +\TYPE {TACS_TO_LT : tactic list -> list_tactic} + +\SYNOPSIS +The list_tactic which applies a list of tactics to the +corresponding members of a list of goals. + +\KEYWORDS +tactical. + +\DESCRIBE +If {T1,...,Tn} are tactics, {TACS_TO_LT [T1,...,Tn]} is a +list_tactic which applies the tactics {T1,...,Tn} to the +corresponding goals. + +\FAILURE +The application of {TACS_TO_LT} to a tactic list never fails. +The resulting list_tactic fails if length of the goal list +is not the same as that of the tactic list, +or finally if {Ti} fails when applied to the {i}'th member of the goal list. + +\USES +Applying different tactics to different subgoals. + +\EXAMPLE +Where {tac1} is a tactic and {tacs2} is a list of tactics, +{tac1 THEN_LT TACS_TO_LT tacs2} is equivalent to {tac1 THENL tacs2} + +\SEEALSO +Tactical.THEN_LT, Tactical.THENL. +\ENDDOC + diff --git a/help/Docfiles/Tactical.THEN_LT.doc b/help/Docfiles/Tactical.THEN_LT.doc new file mode 100644 index 0000000000..6c166b2b4d --- /dev/null +++ b/help/Docfiles/Tactical.THEN_LT.doc @@ -0,0 +1,55 @@ +\DOC THEN_LT + +\TYPE {op THEN_LT : tactic -> list_tactic -> tactic +op THEN_LT : list_tactic -> list_tactic -> list_tactic} + +\SYNOPSIS +Applies a list_tactic to the corresponding subgoals generated by a tactic +or by a previous list_tactic. + +\KEYWORDS +tactical, list_tactic. + +\DESCRIBE +If {tac} is a tactic and {ltac} is a list_tactic, +then {tac THEN_LT ltac} is a tactic which applies +{tac} to a goal, and if it does not fail, +applies the list_tactic {ltac} to the +resulting list of subgoals. + +If {ltac1} and {ltac2} are list_tactics, +then {ltac1 THEN_LT ltac2} is a list_tactic which applies +{ltac1} to a goal list, and if it does not fail, +applies {ltac2} to the resulting list of goals. + +\FAILURE +The application of {THEN_LT} to a tactic or list_tactic and a list_tactic +never fails. + +The tactic {tac THEN_LT ltac} fails +if {tac} fails when applied to the goal, +or if {ltac} fails when applied to the resulting subgoal list. + +The list_tactic {ltac1 THEN_LT ltac2} fails +if {ltac1} fails when applied to the goal list, +or if {ltac2} fails when applied to the goal list result of {ltac1}. + +\USES +Applying a combination of tactics to a list of subgoals, +or otherwise manipulating a list of subgoals. + +\EXAMPLE +Where {tac1} and {tac2} are tactics, +{tac1 THEN_LT ALLGOALS tac2} is equivalent to {tac1 THEN tac2} + +Where {tac1} is a tactic and {tacs2} is a list of tactics, +{tac1 THEN_LT TACS_TO_LT tacs2} is equivalent to {tac1 THENL tacs2} + +Where {tac} is a tactic, +{tac THEN_LT REVERSE_LT} is equivalent to {REVERSE tac} + +\SEEALSO +Tactical.ALLGOALS, Tactical.THEN, Tactical.TACS_TO_LT, Tactical.THENL, +Tactical.NTH_GOAL, Tactical.REVERSE_LT, Tactical.REVERSE +\ENDDOC + diff --git a/src/1/Tactical.sml b/src/1/Tactical.sml index 1bb7376990..8ebc1c8b55 100644 --- a/src/1/Tactical.sml +++ b/src/1/Tactical.sml @@ -285,7 +285,8 @@ fun HEADGOAL tac gl1 = NTH_GOAL tac 1 gl1 ; first n goals, and ltacb to the rest *---------------------------------------------------------------------------*) fun SPLIT_LT n (ltaca, ltacb) gl = - let val (gla, glb) = Lib.split_after n gl ; + let val fixn = if n >= 0 then n else length gl + n ; + val (gla, glb) = Lib.split_after fixn gl ; val (glra, vfa) = ltaca gla ; val (glrb, vfb) = ltacb glb ; fun vf ths = From 8a8d11a3b1e30067541abeb6a61d722fb9cb66c2 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Mon, 1 Dec 2014 17:10:02 +1100 Subject: [PATCH 037/718] changed list_tactic to list-tactic in doc files, where not the ML type --- help/Docfiles/Tactical.ALLGOALS.doc | 6 +++--- help/Docfiles/Tactical.ALL_LT.doc | 2 +- help/Docfiles/Tactical.HEADGOAL.doc | 6 +++--- help/Docfiles/Tactical.LASTGOAL.doc | 6 +++--- help/Docfiles/Tactical.NTH_GOAL.doc | 6 +++--- help/Docfiles/Tactical.REVERSE_LT.doc | 4 ++-- help/Docfiles/Tactical.ROTATE_LT.doc | 2 +- help/Docfiles/Tactical.SPLIT_LT.doc | 8 ++++---- help/Docfiles/Tactical.TACS_TO_LT.doc | 6 +++--- help/Docfiles/Tactical.THEN_LT.doc | 18 +++++++++--------- 10 files changed, 32 insertions(+), 32 deletions(-) diff --git a/help/Docfiles/Tactical.ALLGOALS.doc b/help/Docfiles/Tactical.ALLGOALS.doc index 66f6dba6ff..e9b0430ebb 100644 --- a/help/Docfiles/Tactical.ALLGOALS.doc +++ b/help/Docfiles/Tactical.ALLGOALS.doc @@ -6,15 +6,15 @@ Applies a tactic to every goal in a list \KEYWORDS -tactical, list_tactic. +tactical, list-tactic. \DESCRIBE -If {tac} is a tactic, {ALLGOALS tac} is a list_tactic which +If {tac} is a tactic, {ALLGOALS tac} is a list-tactic which applies the tactic {tac} to all the goals in the given list. \FAILURE The application of {ALLGOALS} to a tactic never fails. -The resulting list_tactic fails if +The resulting list-tactic fails if {tac} fails when applied to any of the goals in the given list. \EXAMPLE diff --git a/help/Docfiles/Tactical.ALL_LT.doc b/help/Docfiles/Tactical.ALL_LT.doc index b7475a5ced..1656431c22 100644 --- a/help/Docfiles/Tactical.ALL_LT.doc +++ b/help/Docfiles/Tactical.ALL_LT.doc @@ -6,7 +6,7 @@ Passes on a goal list unchanged. \KEYWORDS -list_tactic, identity. +list-tactic, identity. \DESCRIBE {ALL_LT} applied to a goal list {gl} diff --git a/help/Docfiles/Tactical.HEADGOAL.doc b/help/Docfiles/Tactical.HEADGOAL.doc index 8460e4a075..54cecbf2eb 100644 --- a/help/Docfiles/Tactical.HEADGOAL.doc +++ b/help/Docfiles/Tactical.HEADGOAL.doc @@ -3,19 +3,19 @@ \TYPE {HEADGOAL : tactic -> list_tactic} \SYNOPSIS -The list_tactic which applies a tactic to the first member of a list of goals. +The list-tactic which applies a tactic to the first member of a list of goals. \KEYWORDS tactical. \DESCRIBE If {tac} is a tactic, {HEADGOAL tac} is a -list_tactic which applies the tactic {tac} to the +list-tactic which applies the tactic {tac} to the first member of a list of goals. \FAILURE The application of {HEADGOAL} to a tactic never fails. -The resulting list_tactic fails the goal list is empty or +The resulting list-tactic fails the goal list is empty or or finally if {tac} fails when applied to the first member of the goal list. \USES diff --git a/help/Docfiles/Tactical.LASTGOAL.doc b/help/Docfiles/Tactical.LASTGOAL.doc index 65e6367540..0da1328341 100644 --- a/help/Docfiles/Tactical.LASTGOAL.doc +++ b/help/Docfiles/Tactical.LASTGOAL.doc @@ -3,19 +3,19 @@ \TYPE {LASTGOAL : tactic -> list_tactic} \SYNOPSIS -The list_tactic which applies a tactic to the last member of a list of goals. +The list-tactic which applies a tactic to the last member of a list of goals. \KEYWORDS tactical. \DESCRIBE If {tac} is a tactic, {LASTGOAL tac} is a -list_tactic which applies the tactic {tac} to the +list-tactic which applies the tactic {tac} to the last member of a list of goals. \FAILURE The application of {LASTGOAL} to a tactic never fails. -The resulting list_tactic fails the goal list is empty or +The resulting list-tactic fails the goal list is empty or or finally if {tac} fails when applied to the last member of the goal list. \USES diff --git a/help/Docfiles/Tactical.NTH_GOAL.doc b/help/Docfiles/Tactical.NTH_GOAL.doc index 3e525ac04f..5dc7a85005 100644 --- a/help/Docfiles/Tactical.NTH_GOAL.doc +++ b/help/Docfiles/Tactical.NTH_GOAL.doc @@ -3,7 +3,7 @@ \TYPE {NTH_GOAL : tactic -> int -> list_tactic} \SYNOPSIS -The list_tactic which applies a tactic to the +The list-tactic which applies a tactic to the {n}'th member of a list of goals. \KEYWORDS @@ -11,12 +11,12 @@ tactical. \DESCRIBE If {tac} is a tactic, {NTH_GOAL n tac} is a -list_tactic which applies the tactic {tac} to the +list-tactic which applies the tactic {tac} to the {n}'th member of a list of goals. \FAILURE The application of {NTH_GOAL} to a tactic and integer never fails. -The resulting list_tactic fails if {n} is less than 1 or greater than the +The resulting list-tactic fails if {n} is less than 1 or greater than the length of the goal list, or finally if {tac} fails when applied to the {n}'th member of the goal list. diff --git a/help/Docfiles/Tactical.REVERSE_LT.doc b/help/Docfiles/Tactical.REVERSE_LT.doc index db94a2b606..08f8abdb63 100644 --- a/help/Docfiles/Tactical.REVERSE_LT.doc +++ b/help/Docfiles/Tactical.REVERSE_LT.doc @@ -6,10 +6,10 @@ Reverses the order of a list of subgoals. \KEYWORDS -list_tactic. +list-tactic. \DESCRIBE -The list_tactic {REVERSE_LT} reverses +The list-tactic {REVERSE_LT} reverses the order of a list of subgoals. \FAILURE diff --git a/help/Docfiles/Tactical.ROTATE_LT.doc b/help/Docfiles/Tactical.ROTATE_LT.doc index 72a57ca89e..7c721d7605 100644 --- a/help/Docfiles/Tactical.ROTATE_LT.doc +++ b/help/Docfiles/Tactical.ROTATE_LT.doc @@ -6,7 +6,7 @@ Rotates a list of goals \KEYWORDS -list_tactic. +list-tactic. \DESCRIBE {ROTATE_LT n gl} rotates a goal list {gl} by {n} places. diff --git a/help/Docfiles/Tactical.SPLIT_LT.doc b/help/Docfiles/Tactical.SPLIT_LT.doc index 3c2896772d..4414b086f2 100644 --- a/help/Docfiles/Tactical.SPLIT_LT.doc +++ b/help/Docfiles/Tactical.SPLIT_LT.doc @@ -3,13 +3,13 @@ \TYPE {SPLIT_LT : int -> list_tactic * list_tactic -> list_tactic} \SYNOPSIS -Splits a list of goals into two and applies a list_tactic to each part +Splits a list of goals into two and applies a list-tactic to each part \KEYWORDS -list_tactic. +list-tactic. \DESCRIBE -For list_tactics {ltac1} and {ltac2}, integer {n} and goal list {gl}, +For list-tactics {ltac1} and {ltac2}, integer {n} and goal list {gl}, the application {SPLIT_LT n (ltac1, ltac2) gl} applies {ltac1} to the first {n} goals in {gl}, and {ltac2} to the remainder. If {n} is negative, {ltac1} is applied to the goals before the last {-n}, @@ -20,7 +20,7 @@ The application {SPLIT_LT n (ltac1, ltac2)} never fails, but when applied to a goal list, it fails if the index {n} is (in absolute value) larger then the length of the list, -or if either of the list_tactics {ltac1} and {ltac2} fails. +or if either of the list-tactics {ltac1} and {ltac2} fails. \EXAMPLE To apply tactic {tac1} to a goal, and then to apply {tac2} diff --git a/help/Docfiles/Tactical.TACS_TO_LT.doc b/help/Docfiles/Tactical.TACS_TO_LT.doc index 06565d1076..59fd4c7e12 100644 --- a/help/Docfiles/Tactical.TACS_TO_LT.doc +++ b/help/Docfiles/Tactical.TACS_TO_LT.doc @@ -3,7 +3,7 @@ \TYPE {TACS_TO_LT : tactic list -> list_tactic} \SYNOPSIS -The list_tactic which applies a list of tactics to the +The list-tactic which applies a list of tactics to the corresponding members of a list of goals. \KEYWORDS @@ -11,12 +11,12 @@ tactical. \DESCRIBE If {T1,...,Tn} are tactics, {TACS_TO_LT [T1,...,Tn]} is a -list_tactic which applies the tactics {T1,...,Tn} to the +list-tactic which applies the tactics {T1,...,Tn} to the corresponding goals. \FAILURE The application of {TACS_TO_LT} to a tactic list never fails. -The resulting list_tactic fails if length of the goal list +The resulting list-tactic fails if length of the goal list is not the same as that of the tactic list, or finally if {Ti} fails when applied to the {i}'th member of the goal list. diff --git a/help/Docfiles/Tactical.THEN_LT.doc b/help/Docfiles/Tactical.THEN_LT.doc index 6c166b2b4d..cf3cab16fc 100644 --- a/help/Docfiles/Tactical.THEN_LT.doc +++ b/help/Docfiles/Tactical.THEN_LT.doc @@ -4,33 +4,33 @@ op THEN_LT : list_tactic -> list_tactic -> list_tactic} \SYNOPSIS -Applies a list_tactic to the corresponding subgoals generated by a tactic -or by a previous list_tactic. +Applies a list-tactic to the corresponding subgoals generated by a tactic +or by a previous list-tactic. \KEYWORDS -tactical, list_tactic. +tactical, list-tactic. \DESCRIBE -If {tac} is a tactic and {ltac} is a list_tactic, +If {tac} is a tactic and {ltac} is a list-tactic, then {tac THEN_LT ltac} is a tactic which applies {tac} to a goal, and if it does not fail, -applies the list_tactic {ltac} to the +applies the list-tactic {ltac} to the resulting list of subgoals. -If {ltac1} and {ltac2} are list_tactics, -then {ltac1 THEN_LT ltac2} is a list_tactic which applies +If {ltac1} and {ltac2} are list-tactics, +then {ltac1 THEN_LT ltac2} is a list-tactic which applies {ltac1} to a goal list, and if it does not fail, applies {ltac2} to the resulting list of goals. \FAILURE -The application of {THEN_LT} to a tactic or list_tactic and a list_tactic +The application of {THEN_LT} to a tactic or list-tactic and a list-tactic never fails. The tactic {tac THEN_LT ltac} fails if {tac} fails when applied to the goal, or if {ltac} fails when applied to the resulting subgoal list. -The list_tactic {ltac1 THEN_LT ltac2} fails +The list-tactic {ltac1 THEN_LT ltac2} fails if {ltac1} fails when applied to the goal list, or if {ltac2} fails when applied to the goal list result of {ltac1}. From 279c6472105f62550a4a314337013672568c6c90 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Mon, 1 Dec 2014 23:51:48 +1100 Subject: [PATCH 038/718] replacing code for THEN and THENL using ALLGOALS and TACS_TO_LT also defines NULL_OK_LT to implement change to THENL (see https://github.com/HOL-Theorem-Prover/HOL/issues/214 ) --- help/Docfiles/Tactical.NULL_OK_LT.doc | 26 ++++++ help/Docfiles/Tactical.THEN_LT.doc | 5 +- src/1/Tactical.sig | 1 + src/1/Tactical.sml | 122 +++++++------------------- 4 files changed, 62 insertions(+), 92 deletions(-) create mode 100644 help/Docfiles/Tactical.NULL_OK_LT.doc diff --git a/help/Docfiles/Tactical.NULL_OK_LT.doc b/help/Docfiles/Tactical.NULL_OK_LT.doc new file mode 100644 index 0000000000..92893e6b43 --- /dev/null +++ b/help/Docfiles/Tactical.NULL_OK_LT.doc @@ -0,0 +1,26 @@ +\DOC NULL_OK_LT + +\TYPE {NULL_OK_LT : list_tactic -> list_tactic} + +\SYNOPSIS +Makes a list-tactic succeed with no effect when applied to the empty goal list. + +\KEYWORDS +list-tactical, failure. + +\DESCRIBE +For any list-tactic {ltac}, the application {NULL_OK_LT ltac} +gives a new list-tactic which has the same effect as {ltac} when applied to +a non-empty goal list. Applied to the empty goal list it succeeds with no +effect. + +\FAILURE +The application of {NULL_OK_LT} to a list-tactic {ltac} never fails. +The resulting list-tactic fails if applies to a non-empty goal list on which +{ltac} fails. + +\SEEALSO +Tactical.ALL_LT, Tactical.THENL + +\ENDDOC + diff --git a/help/Docfiles/Tactical.THEN_LT.doc b/help/Docfiles/Tactical.THEN_LT.doc index cf3cab16fc..3de3f8f8e4 100644 --- a/help/Docfiles/Tactical.THEN_LT.doc +++ b/help/Docfiles/Tactical.THEN_LT.doc @@ -43,13 +43,14 @@ Where {tac1} and {tac2} are tactics, {tac1 THEN_LT ALLGOALS tac2} is equivalent to {tac1 THEN tac2} Where {tac1} is a tactic and {tacs2} is a list of tactics, -{tac1 THEN_LT TACS_TO_LT tacs2} is equivalent to {tac1 THENL tacs2} +{tac1 THEN_LT NULL_OK_LT (TACS_TO_LT tacs2)} is equivalent to +{tac1 THENL tacs2} Where {tac} is a tactic, {tac THEN_LT REVERSE_LT} is equivalent to {REVERSE tac} \SEEALSO Tactical.ALLGOALS, Tactical.THEN, Tactical.TACS_TO_LT, Tactical.THENL, -Tactical.NTH_GOAL, Tactical.REVERSE_LT, Tactical.REVERSE +Tactical.NULL_OK_LT, Tactical.NTH_GOAL, Tactical.REVERSE_LT, Tactical.REVERSE \ENDDOC diff --git a/src/1/Tactical.sig b/src/1/Tactical.sig index 701ce57c9f..e28ea96503 100644 --- a/src/1/Tactical.sig +++ b/src/1/Tactical.sig @@ -16,6 +16,7 @@ sig val THEN_LT : list_tactic * list_tactic -> list_tactic *) val TACS_TO_LT : tactic list -> list_tactic + val NULL_OK_LT : list_tactic -> list_tactic val ALLGOALS : tactic -> list_tactic val NTH_GOAL : tactic -> int -> list_tactic val LASTGOAL : tactic -> list_tactic diff --git a/src/1/Tactical.sml b/src/1/Tactical.sml index 8ebc1c8b55..aae33f9255 100644 --- a/src/1/Tactical.sml +++ b/src/1/Tactical.sml @@ -77,91 +77,6 @@ fun store_thm (name, tm, tac) = infix THEN THENL THEN1 ORELSE THEN_LT -(*--------------------------------------------------------------------------- - * fun (tac1:tactic) THEN (tac2:tactic) : tactic = fn g => - * let val (gl,p) = tac1 g - * val (gll,pl) = unzip(map tac2 gl) - * in - * (flatten gll, (p o mapshape(map length gll)pl)) - * end; - *---------------------------------------------------------------------------*) - -fun tac1 THEN tac2 = - fn g => - let - val (gl, vf) = tac1 g - in - case itlist - (fn goal => fn (G, V, lengths) => - case tac2 goal of - ([], vfun) => let - val th = vfun [] - in - (G, empty th :: V, 0 :: lengths) - end - | (goals, vfun) => - (goals @ G, vfun :: V, length goals :: lengths)) - gl ([], [], []) of - ([], V, _) => - ([], let val th = vf (map (fn f => f []) V) in empty th end) - | (G, V, lengths) => (G, (vf o mapshape lengths V)) - end - -(*--------------------------------------------------------------------------- - * fun (tac1:tactic) THENL (tac2l: tactic list) : tactic = fn g => - * let val (gl,p) = tac1 g - * val tac2gl = zip tac2l gl - * val (gll,pl) = unzip (map (fn (tac2,g) => tac2 g) tac2gl) - * in - * (flatten gll, p o mapshape(map length gll) pl) - * end - *---------------------------------------------------------------------------*) - -fun (tac1: tactic) THENL (tacl: tactic list) : tactic = - fn g => - let - val (gl, vf) = tac1 g - val (G, V, lengths) = - itlist2 - (fn goal => fn tac => fn (G, V, lengths) => - case tac goal of - ([], vfun) => let - val th = vfun [] - in - (G, (empty th) :: V, 0 :: lengths) - end - | (goals, vfun) => - (goals @ G, vfun :: V, length goals :: lengths)) - gl tacl ([], [], []) - in - case G of - [] => ([], let val th = vf (map (fn f => f []) V) in empty th end) - | _ => (G, vf o mapshape lengths V) - end - -fun (tac1 ORELSE tac2) g = tac1 g handle HOL_ERR _ => tac2 g - -(*--------------------------------------------------------------------------- - * tac1 THEN1 tac2: A tactical like THEN that applies tac2 only to the - * first subgoal of tac1 - *---------------------------------------------------------------------------*) - -fun op THEN1 (tac1: tactic, tac2: tactic) : tactic = - fn g => - let - val (gl, jf) = tac1 g - val (h_g, t_gl) = - case gl of - [] => raise ERR "THEN1" "goal completely solved by first tactic" - | h :: t => (h, t) - val (h_gl, h_jf) = tac2 h_g - val _ = - if null h_gl then () - else raise ERR "THEN1" "first subgoal not solved by second tactic" - in - (t_gl, fn thl => jf (h_jf [] :: thl)) - end - (*--------------------------------------------------------------------------- * tac1 THEN_LT ltac2: * A tactical that applies ltac2 to the list of subgoals resulting from tac1 @@ -206,6 +121,17 @@ fun ALLGOALS tac2 gl = ([], let val ths = map (fn f => f []) V in empty ths end) | (G, V, lengths) => (G, mapshape lengths V) +(*--------------------------------------------------------------------------- + * fun (tac1:tactic) THEN (tac2:tactic) : tactic = fn g => + * let val (gl,p) = tac1 g + * val (gll,pl) = unzip(map tac2 gl) + * in + * (flatten gll, (p o mapshape(map length gll)pl)) + * end; + *---------------------------------------------------------------------------*) + +fun tac1 THEN tac2 = tac1 THEN_LT ALLGOALS tac2 ; + (*--------------------------------------------------------------------------- * fun TACS_TO_LT (tac2l: tactic list) : list_tactic = fn gl => * let @@ -238,6 +164,27 @@ fun TACS_TO_LT (tacl: tactic list) : list_tactic = | _ => (G, mapshape lengths V) end +(*--------------------------------------------------------------------------- + * NULL_OK_LT ltac: A list-tactical like ltac but succeeds with no effect + * when applied to an ampty goal list + *---------------------------------------------------------------------------*) + +fun NULL_OK_LT ltac [] = ([], Lib.I) + | NULL_OK_LT ltac gl = ltac gl ; + +(*--------------------------------------------------------------------------- + * fun (tac1:tactic) THENL (tac2l: tactic list) : tactic = fn g => + * let val (gl,p) = tac1 g + * val tac2gl = zip tac2l gl + * val (gll,pl) = unzip (map (fn (tac2,g) => tac2 g) tac2gl) + * in + * (flatten gll, p o mapshape(map length gll) pl) + * end + * BUT - if gl is empty, just return (gl, p) + *---------------------------------------------------------------------------*) + +fun tac1 THENL tacs2 = tac1 THEN_LT NULL_OK_LT (TACS_TO_LT tacs2) ; + fun (tac1 ORELSE tac2) g = tac1 g handle HOL_ERR _ => tac2 g (*--------------------------------------------------------------------------- @@ -335,11 +282,6 @@ fun REVERSE_LT gl = (rev gl, rev) ; fun REVERSE tac = tac THEN_LT REVERSE_LT ; *) -(* for testing, redefine THEN and THENL -fun tac1 THENL tacs2 = tac1 THEN_LT TACS_TO_LT tacs2 ; -fun tac1 THEN tac2 = tac1 THEN_LT ALLGOALS tac2 ; -*) - (*--------------------------------------------------------------------------- * Fail with the given token. Useful in tactic programs to check that a * tactic produces no subgoals. Write From 404e6efef5dd692b32148e8659068f6c66a67aeb Mon Sep 17 00:00:00 2001 From: Thomas Tuerk Date: Thu, 4 Dec 2014 07:47:11 +0100 Subject: [PATCH 039/718] add an experimental deep embedding of pattern matching this is work in progress and far from finished --- examples/deep_matches/README | 2 + examples/deep_matches/constrFamiliesLib.sig | 6 + examples/deep_matches/constrFamiliesLib.sml | 78 ++ examples/deep_matches/deepMatchesExamples.sml | 97 ++ examples/deep_matches/deepMatchesLib.sig | 48 + examples/deep_matches/deepMatchesLib.sml | 952 ++++++++++++++++++ examples/deep_matches/deepMatchesScript.sml | 405 ++++++++ examples/deep_matches/deepMatchesSyntax.sig | 71 ++ examples/deep_matches/deepMatchesSyntax.sml | 167 +++ 9 files changed, 1826 insertions(+) create mode 100644 examples/deep_matches/README create mode 100644 examples/deep_matches/constrFamiliesLib.sig create mode 100644 examples/deep_matches/constrFamiliesLib.sml create mode 100644 examples/deep_matches/deepMatchesExamples.sml create mode 100644 examples/deep_matches/deepMatchesLib.sig create mode 100644 examples/deep_matches/deepMatchesLib.sml create mode 100644 examples/deep_matches/deepMatchesScript.sml create mode 100644 examples/deep_matches/deepMatchesSyntax.sig create mode 100644 examples/deep_matches/deepMatchesSyntax.sml diff --git a/examples/deep_matches/README b/examples/deep_matches/README new file mode 100644 index 0000000000..26e3de4d74 --- /dev/null +++ b/examples/deep_matches/README @@ -0,0 +1,2 @@ +This directory contains a deep embedding of pattern matching. +It is work in progress and still far from stable. diff --git a/examples/deep_matches/constrFamiliesLib.sig b/examples/deep_matches/constrFamiliesLib.sig new file mode 100644 index 0000000000..21b802d6bf --- /dev/null +++ b/examples/deep_matches/constrFamiliesLib.sig @@ -0,0 +1,6 @@ +signature constrFamiliesLib = +sig + include Abbrev + + val gen_case_expand_thm : thm -> thm -> thm +end diff --git a/examples/deep_matches/constrFamiliesLib.sml b/examples/deep_matches/constrFamiliesLib.sml new file mode 100644 index 0000000000..ef846a6dcd --- /dev/null +++ b/examples/deep_matches/constrFamiliesLib.sml @@ -0,0 +1,78 @@ +structure constrFamiliesLib :> constrFamiliesLib = +struct + +open Abbrev + +(* Contructor families are lists of constructors. + Constructors are functions that are injective and + pairwise distinct. Moreover, a case-expansion theorem needs to be provided. + + Let's assume we have a datatype t with + C1 of bool, C2, C3 of nat. Then we need the following theorems + + !b1 b2. (C1 b1 = C1 b2) <-> (b1 = b2) + !n1 n2. (C3 n1 = C3 n2) <-> (n1 = n2) + (!b. not (C1 b = C2)) + (!b. not (C2 = C1 b)) + (!b n. not (C1 b = C3 n)) + (!b n. not (C3 n = C3 b)) + (!n. not (C3 n = C2)) + (!n. not (C2 = C3 n)) + + and a case split theorem like + + !f v. f v = (case v of + C1 b -> f (C1 b) + | C2 -> f C2 + | C3 n -> f (C3 n)) +*) + +type constrFamily = { + constructors : term list, + one_one_thm : thm, + distinct_thm : thm, + case_split_thm: thm +} + + + +fun gen_case_expand_thm case_def_thm nchotomy_thm = let + val c = fst ( + strip_comb (lhs (snd (strip_forall (hd (strip_conj (concl case_def_thm))))))) + val (a, cases) = dest_forall (concl nchotomy_thm) + + val res_ty = snd (strip_fun (type_of c)) + val ff_tm = mk_var ("ff", (type_of a) --> res_ty) + + val args = let + val cases_tms = strip_disj cases + fun process_case ct = let + val (vars, b) = strip_exists ct + val b' = rhs b + in + list_mk_abs (vars, (mk_comb (ff_tm, b'))) + end + in + map process_case cases_tms + end + + val t_rhs = list_mk_comb (c, a::args) + val t_lhs = mk_comb (ff_tm, a) + val t = list_mk_forall([ff_tm, a], mk_eq (t_lhs, t_rhs)) + + val res_thm = prove (t, + REPEAT GEN_TAC THEN + MP_TAC (ISPEC a nchotomy_thm) THEN + SIMP_TAC std_ss [DISJ_IMP_THM, case_def_thm, + GSYM LEFT_FORALL_IMP_THM]) +in + res_thm +end + + + + + + + +end diff --git a/examples/deep_matches/deepMatchesExamples.sml b/examples/deep_matches/deepMatchesExamples.sml new file mode 100644 index 0000000000..f90f647de8 --- /dev/null +++ b/examples/deep_matches/deepMatchesExamples.sml @@ -0,0 +1,97 @@ +open bossLib +open deepMatchesLib + + +(* Introducing case expressions *) + +val t = ``case x of (NONE, []) => 0`` +val t' = convert_case t +val thm_t = PMATCH_INTRO_CONV t + +(* check that SIMP works *) +val thm_t' = PMATCH_REMOVE_ARB_CONV t' +val thm_t' = PMATCH_SIMP_CONV t' + +(* more fancy *) + +val t = ``case x of + (NONE, []) => 0 + | (SOME 2, []) => 2 + | (SOME 3, (x :: xs)) => 3 + x + | (SOME _, (x :: xs)) => x`` + +val t' = convert_case t +val thm_t = PMATCH_INTRO_CONV t + +val thm_t' = PMATCH_REMOVE_ARB_CONV t' +val thm_t' = PMATCH_SIMP_CONV t' + +(* Playing around with some examples *) + +val example1 = `` +PMATCH (a,x,xs) + [PMATCH_ROW (\x. ((NONE,x,[]),x)); + PMATCH_ROW (\x. ((NONE,x,[2]),x)); + PMATCH_ROW (\(x,v18). ((NONE,x,[v18]),3)); + PMATCH_ROW (\(x,v12,v16,v17). ((NONE,x,v12::v16::v17),3)); + PMATCH_ROW (\(y,x,z,zs). ((SOME y,x,[z]),x+5+z)); + PMATCH_ROW (\(y,v23,v24). ((SOME y,0,v23::v24),v23+y)); + PMATCH_ROW (\(y,z,v23). ((SOME y,SUC z,[v23]),3)); + PMATCH_ROW (\(y,z). ((SOME y,SUC z,[1; 2]),y + z)); + PMATCH_ROW (\(y,z,v38). ((SOME y,SUC z,[1; v38]),3)); + PMATCH_ROW (\(y,x). ((y,x,[2;4;3]),3+x)); + PMATCH_ROW + (\(y,z,v29,v36,v37). ((SOME y,SUC z,1::v29::v36::v37),z+v36+v29)); + PMATCH_ROW (\(y,z,v31,v29,v30). ((SOME y,SUC z,v31::v29::v30),v31+z))]`` + +val example2 = ``PMATCH (h::t) + [PMATCH_ROW (\_ . ([],x)); + PMATCH_ROW (\_. ([2],x)); PMATCH_ROW (\v18. ([v18],3)); + PMATCH_ROW (\(v12,v16,v17). (v12::v16::v17,3)); + PMATCH_ROW (\_. ([2; 4; 3],3 + x))]`` + +val example3 = + ``PMATCH (NONE,x,xs) + [PMATCH_ROW (\x. ((NONE,x,[]),x)); + PMATCH_ROW (\x. ((NONE,x,[2]),x)); + PMATCH_ROW (\(x,v18). ((NONE,x,[v18]),3)); + PMATCH_ROW (\(x,v12,v16,v17). ((NONE,x,v12::v16::v17),3)); + PMATCH_ROW (\(y,x). ((y,x,[2; 4; 3]),3 + x))]``; + + +(* turn off pretty printer *) + +set_trace "use pmatch_pp" 0; +example1; +set_trace "use pmatch_pp" 1; +example1; + + +PMATCH_SIMP_CONV example1 +PMATCH_SIMP_CONV example2 +PMATCH_SIMP_CONV example3 + +set_goal ([], ``^example1 = XXX``); + +e (Cases_on `a`) +e (CONV_TAC (DEPTH_CONV PMATCH_SIMP_CONV)) +e (Cases_on `xs`) +e (CONV_TAC (DEPTH_CONV PMATCH_SIMP_CONV)) + +proofManagerLib.restart () + +e (Cases_on `xs`) +e (CONV_TAC (DEPTH_CONV PMATCH_SIMP_CONV)) + +proofManagerLib.restart () + +e (Cases_on `x`) +e (CONV_TAC (DEPTH_CONV PMATCH_SIMP_CONV)) +e (Cases_on `xs`) + +proofManagerLib.rotate 1 +e (CONV_TAC (DEPTH_CONV PMATCH_SIMP_CONV)) +SIMP_TAC std_ss [] + +proofManagerLib.drop () + diff --git a/examples/deep_matches/deepMatchesLib.sig b/examples/deep_matches/deepMatchesLib.sig new file mode 100644 index 0000000000..cf1c3726fe --- /dev/null +++ b/examples/deep_matches/deepMatchesLib.sig @@ -0,0 +1,48 @@ +signature deepMatchesLib = +sig + include Abbrev + + (********************************) + (* turn shallow case-terms into *) + (* deeply embedded ones *) + (********************************) + + val convert_case : term -> term + val PMATCH_INTRO_CONV : conv + + + (********************************) + (* simplify PMATCH-terms *) + (********************************) + + (* There are various ways of simplifying + PMATCH. One can e.g. remove redundant rows + or partially evaluate it. The conversion + PMATCH_SIMP_CONV does this. *) + val PMATCH_SIMP_CONV : conv + + (* There is also a more generic version that + allows to provide extra ssfrags. This might + be handy, if the PMATCH contains functions + not known by the default methods. *) + val PMATCH_SIMP_CONV_GEN : ssfrag list -> conv + + + (* PMATCH_SIMP_CONV consists of various + component conversions. These can be used + independently as well. *) + val PMATCH_REMOVE_ARB_CONV : conv + val PMATCH_REMOVE_ARB_CONV_GEN : ssfrag list -> conv + + val PMATCH_CLEANUP_PVARS_CONV : conv + + val PMATCH_CLEANUP_CONV : conv + val PMATCH_CLEANUP_CONV_GEN : ssfrag list -> conv + + val PMATCH_SIMP_COLS_CONV : conv + val PMATCH_SIMP_COLS_CONV_GEN : ssfrag list -> conv + + val PMATCH_EXPAND_COLS_CONV : conv + + +end diff --git a/examples/deep_matches/deepMatchesLib.sml b/examples/deep_matches/deepMatchesLib.sml new file mode 100644 index 0000000000..4f2ac6a2f8 --- /dev/null +++ b/examples/deep_matches/deepMatchesLib.sml @@ -0,0 +1,952 @@ +structure deepMatchesLib :> deepMatchesLib = +struct + +open deepMatchesTheory bossLib +open quantHeuristicsLib +open deepMatchesSyntax +open constrFamiliesLib + +(***********************************************) +(* Simpset to evaluate PMATCH_ROWS *) +(***********************************************) + +val PAIR_EQ_COLLAPSE = prove ( +``((FST x = a) /\ (SND x = b)) = (x = (a, b))``, +Cases_on `x` THEN SIMP_TAC std_ss []) + +(* +val rc = DEPTH_CONV pairTools.PABS_ELIM_CONV THENC SIMP_CONV list_ss [pairTheory.EXISTS_PROD, pairTheory.FORALL_PROD, PMATCH_ROW_EQ_NONE, PAIR_EQ_COLLAPSE, oneTheory.one] +*) + +val pabs_elim_ss = + simpLib.conv_ss + {name = "PABS_ELIM_CONV", + trace = 2, + key = SOME ([],``UNCURRY (f:'a -> 'b -> bool)``), + conv = K (K pairTools.PABS_ELIM_CONV)} + +fun rc_ss gl = list_ss ++ simpLib.merge_ss + (gl @ + [pabs_elim_ss, + pairSimps.paired_forall_ss, + pairSimps.paired_exists_ss, + pairSimps.gen_beta_ss, + simpLib.rewrites [ + pairTheory.EXISTS_PROD, + pairTheory.FORALL_PROD, + PMATCH_ROW_EQ_NONE, + PAIR_EQ_COLLAPSE, + oneTheory.one]]) + + +(***********************************************) +(* converting case-splits to PMATCH *) +(***********************************************) + +(* +val t = ``case x of + (NONE, []) => 0`` *) + +fun type_names ty = + let val {Thy,Tyop,Args} = Type.dest_thy_type ty + in {Thy=Thy,Tyop=Tyop} + end; + +(* destruct variant cases, see dest_case_fun *) +fun dest_case_fun_aux1 t = let + val (f, args) = strip_comb t + val (tys, _) = strip_fun (type_of f) + val _ = if (List.null args) then failwith "dest_case_fun" else () + val ty = case tys of + [] => failwith "dest_case_fun" + | (ty::_) => ty + val tn = type_names ty + val ti = case TypeBase.fetch ty of + NONE => failwith "dest_case_fun" + | SOME ti => ti + + val _ = if (same_const (TypeBasePure.case_const_of ti) f) then + () else failwith "dest_case_fun" + + val ty_s = match_type (type_of (TypeBasePure.case_const_of ti)) (type_of f) + val constrs = List.map (inst ty_s) (TypeBasePure.constructors_of ti) + + val a = hd args + val ps = map2 (fn c => fn arg => let + val (vars, res) = strip_abs arg in + (list_mk_comb (c, vars), res) end) constrs (tl args) +in + (a, ps) +end + +(* destruct literal cases, see dest_case_fun *) +fun dest_case_fun_aux2 t = let + val _ = if is_literal_case t then () else failwith "dest_case_fun" + + val (f, args) = strip_comb t + + val v = (el 2 args) + val (v', b) = dest_abs (el 1 args) + + fun strip_cond acc b = let + val (c, t_t, t_f) = dest_cond b + val (c_l, c_r) = dest_eq c + val _ = if (aconv c_l v') then () else failwith "dest_case_fun" + in + strip_cond ((c_r, t_t)::acc) t_f + end handle HOL_ERR _ => (acc, b) + + val (ps_rev, c_else) = strip_cond [] b + val ps = List.rev ((v', c_else) :: ps_rev) +in + (v, ps) +end + + +(* destruct a case-function. + The top-most split is split into the input + a list of rows. + Each row consists of a pattern + the right-hand side. *) +fun dest_case_fun t = dest_case_fun_aux1 t handle HOL_ERR _ => dest_case_fun_aux2 t + + +fun convert_case_aux x t = let + val (a, ps) = dest_case_fun t + + fun process_arg (p, rh) = let + val x' = subst [a |-> p] x + in + (* recursive call *) + case convert_case_aux x' rh of + NONE => [(x', rh)] + | SOME resl => resl + end + + val ps = flatten (map process_arg ps) +in + SOME ps +end handle HOL_ERR _ => NONE; + +(* convert a case-term into a PMATCH-term, without any proofs *) +fun convert_case t = let + val (f, args) = strip_comb t + val _ = if (List.null args) then failwith "not a case-split" else () + + val (p,patterns) = if is_literal_case t then (el 2 args, [el 1 args]) else + (hd args, tl args) + val v = genvar (type_of p) + + val t0 = if is_literal_case t then list_mk_comb (f, patterns @ [v]) else list_mk_comb (f, v::patterns) + val ps = case convert_case_aux v t0 of + NONE => failwith "not a case-split" + | SOME ps => ps + + fun process_pattern (p, rh) = let + val fvs = List.rev (free_vars p) + in + mk_PMATCH_ROW fvs p rh + end + val rows = List.map process_pattern ps + val rows_tm = listSyntax.mk_list (rows, type_of (hd rows)) + + val rows_tm_p = subst [v |-> p] rows_tm +in + mk_PMATCH p rows_tm_p +end + +fun PMATCH_INTRO_CONV t = let + val t' = convert_case t + val tm = mk_eq (t, t') + + (* very slow, simple approach. Just brute force. + TODO: change implementation to get more runtime-speed *) + val my_tac = ( + CASE_TAC THEN + FULL_SIMP_TAC (rc_ss []) [PMATCH_EVAL] + ) +in + (* set_goal ([], tm) *) + prove (tm, REPEAT my_tac) +end handle HOL_ERR _ => NO_CONV t; + + +(***********************************************) +(* removing ARB rows *) +(***********************************************) + +(* when converting CASE expressions into PMATCH, + often ARB rows are introduced for the not + covered cases. These ARB rows are + not needed for PMATCH and can be removed. *) + +(* +val ssl = [] +val t = ``PMATCH x + [PMATCH_ROW (\_ . (NONE,0)); + PMATCH_ROW (\v. (SOME v,ARB))]`` + +val t = + ``PMATCH x + [PMATCH_ROW (\_. ((NONE,[]),0)); + PMATCH_ROW (\(v4,v5). ((NONE,v4::v5),ARB)); + PMATCH_ROW (\(v2,v1). ((SOME v2,v1),ARB))]`` + +*) + +fun PMATCH_REMOVE_ARB_CONV_GEN_SINGLE ssl t = let + val (v, rows) = dest_PMATCH t + val rows_rev = List.rev rows + + val i_rev = index (fn row => ( + is_arb (#3(dest_PMATCH_ROW row))) + handle HOL_ERR _ => false) rows_rev + val i = length rows - (i_rev + 1) + + val rows1 = List.take (rows, i) + val r = List.nth (rows, i) + val rows2 = List.drop (rows, i+1) + + val r_ty = type_of r + val rows1_tm = listSyntax.mk_list (rows1, r_ty) + val rows2_tm = listSyntax.mk_list (rows2, r_ty) + val r_thm = (snd (PMATCH_ROW_PABS_ELIM_CONV r)) handle + UNCHANGED => REFL r + + val input_rows = + listSyntax.mk_append (rows1_tm, + listSyntax.mk_cons (rhs (concl r_thm), rows2_tm)) + + val thm0 = HO_PART_MATCH (rand o lhs o snd o dest_imp o #2 o strip_forall) ( + ISPEC v (FRESH_TY_VARS_RULE PMATCH_REMOVE_ARB_NO_OVERLAP) + ) input_rows + + + val pre = rand (rator (concl thm0)) + val pre_thm = prove (pre, SIMP_TAC (rc_ss ssl) []) + val thm1 = MP thm0 pre_thm + val thm2 = CONV_RULE + ((RHS_CONV o RAND_CONV) listLib.APPEND_CONV) + thm1 + + val thm2_lhs_tm = mk_eq (t, lhs (concl thm2)) + val thm2_lhs = prove (thm2_lhs_tm, + MP_TAC r_thm THEN SIMP_TAC (rc_ss []) []) + + val thm3 = TRANS thm2_lhs thm2 +in + thm3 +end handle HOL_ERR _ => raise UNCHANGED + +fun PMATCH_REMOVE_ARB_CONV_GEN ssl = REPEATC (PMATCH_REMOVE_ARB_CONV_GEN_SINGLE ssl) +val PMATCH_REMOVE_ARB_CONV = PMATCH_REMOVE_ARB_CONV_GEN [] + + +(***********************************************) +(* Cleaning up unused vars in PMATCH_ROW *) +(***********************************************) + +(*val t = `` +PMATCH (SOME x, xz) + [PMATCH_ROW (\x. ((SOME 2,x,[]),x)); + PMATCH_ROW (\y:'a. ((SOME 2,3,[]),x)); + PMATCH_ROW (\(z,x,yy). ((z,x,[2]),x)); + PMATCH_ROW (\(z,yy,xs). ((SOME z,xs),3+z)); + PMATCH_ROW (\(z,xs). ((SOME z,xs),3+z)); + PMATCH_ROW (\(yy,x,xs). ((NONE,xs),3))]`` +*) + +(* Many simps depend on patterns being injective. This means + in particular that no extra, unused vars occur in the patterns. + The following removes such unused vars. *) + +fun PMATCH_CLEANUP_PVARS_CONV t = let + val _ = if is_PMATCH t then () else raise UNCHANGED + + fun row_conv row = let + val (vars_tm, pt, rh) = dest_PMATCH_ROW row + val _ = if (type_of vars_tm = ``:unit``) then raise UNCHANGED else () + val vars = pairSyntax.strip_pair vars_tm + val used_vars = FVL [pt, rh] empty_tmset + + val filtered_vars = filter (fn v => HOLset.member (used_vars, v)) vars + + val _ = if (length vars = length filtered_vars) then + raise UNCHANGED else () + + val row' = mk_PMATCH_ROW filtered_vars pt rh + + val eq_tm = mk_eq (row, row') + (* set_goal ([], eq_tm) *) + val eq_thm = prove (eq_tm, + CONV_TAC (DEPTH_CONV pairTools.PABS_ELIM_CONV) THEN + HO_MATCH_MP_TAC PMATCH_ROW_EQ_AUX THEN + SIMP_TAC (rc_ss []) [] + ) + in + eq_thm + end +in + DEPTH_CONV row_conv t +end + + +(***********************************************) +(* Cleaning up by removing rows that *) +(* don't match or are redundant *) +(* also remove the whole PMATCH, if first *) +(* row matches *) +(***********************************************) + +fun map_filter f l = case l of + [] => [] + | x::xs => (case f x of + NONE => map_filter f xs + | SOME y => y :: (map_filter f xs)); + +(* remove redundant rows *) +fun PMATCH_CLEANUP_CONV_GEN ssl t = let + val (v, rows) = dest_PMATCH t + val rc_conv = SIMP_CONV (rc_ss ssl) [] + + fun check_row r = let + val r_tm = mk_eq (mk_comb (r, v), optionSyntax.mk_none (type_of t)) val r_thm = rc_conv r_tm + val res_tm = rhs (concl r_thm) + in + if (same_const res_tm T) then SOME (true, r_thm) else + (if (same_const res_tm F) then SOME (false, r_thm) else NONE) + end handle HOL_ERR _ => NONE + + val (rows_checked_rev, _) = foldl (fn (r, (acc, abort)) => + if abort then ((r, NONE)::acc, true) else ( + let + val res = check_row r + val abort = (case res of + (SOME (false, _)) => true + | _ => false) + in + ((r, res)::acc, abort) + end)) ([], false) rows + val rows_checked = List.rev rows_checked_rev + + (* did we get any results? *) + fun check_row_exists v rows = + exists (fn x => case x of (_, SOME (v', _)) => v = v' | _ => false) rows + + val _ = if ((check_row_exists true rows_checked_rev) orelse (check_row_exists false (tl rows_checked_rev))) then () else raise UNCHANGED + + val row_ty = type_of (hd rows) + + (* drop redundant rows *) + val (thm0, rows_checked0) = let + val n = index (fn x => case x of (_, SOME (false, _)) => true | _ => false) rows_checked + val n_tm = numSyntax.term_of_int n + + val thma = ISPECL [v, listSyntax.mk_list (rows, row_ty), n_tm] + (FRESH_TY_VARS_RULE PMATCH_ROWS_DROP_REDUNDANT_TRIVIAL_SOUNDNESS) + + val precond = fst (dest_imp (concl thma)) + val precond_thm = prove (precond, + MP_TAC (snd(valOf (snd (el (n+1) rows_checked)))) THEN + SIMP_TAC list_ss [quantHeuristicsTheory.IS_SOME_EQ_NOT_NONE]) + + val thmb = MP thma precond_thm + + val take_conv = RATOR_CONV (RAND_CONV reduceLib.SUC_CONV) THENC + listLib.FIRSTN_CONV + val thmc = CONV_RULE (RHS_CONV (RAND_CONV take_conv)) thmb + in + (thmc, List.take (rows_checked, n+1)) + end handle HOL_ERR _ => (REFL t, rows_checked) + + (* drop false rows *) + val (thm1, rows_checked1) = let + val _ = if (exists (fn x => case x of (_, (SOME (true, _))) => true | _ => false) rows_checked0) then () else failwith "nothing to do" + + fun process_row ((r, r_thm_opt), thm) = (case r_thm_opt of + (SOME (true, r_thm)) => let + val thmA = PMATCH_EXTEND_OLD + val thmB = HO_MATCH_MP thmA (EQT_ELIM r_thm) + val thmC = HO_MATCH_MP thmB thm + in + thmC + end + | _ => let + val thmA = PMATCH_EXTEND_BOTH_ID + val thmB = HO_MATCH_MP thmA thm + in + ISPEC r thmB + end) + + val base_thm = INST_TYPE [gamma |-> type_of t] (ISPECL [v, v] PMATCH_EXTEND_BASE) + val thma = foldl process_row base_thm (List.rev rows_checked0) + + val rows_checked1 = filter (fn (_, res_opt) => case res_opt of + SOME (true, thm) => false + | _ => true) rows_checked0 + in + (thma, rows_checked1) + end handle HOL_ERR _ => (REFL (rhs (concl thm0)), rows_checked0) + + + (* if first line matches, evaluate *) + val thm2 = let + val _ = if (not (List.null rows_checked1) andalso + (case hd rows_checked1 of (_, (SOME (false, _))) => true | _ => false)) then () else failwith "nothing to do" + + val thm1_tm = rhs (concl thm1) + val thm2a = DEPTH_CONV pairTools.PABS_ELIM_CONV thm1_tm handle UNCHANGED => REFL thm1_tm + val (vars,_) = pairLib.dest_pabs (rand (rand (rator (rand (thm1_tm))))) + + val thm2a0 = HO_PART_MATCH (lhs o rand) PMATCH_EVAL_MATCH (rhs (concl thm2a)) + + val pre_tm = fst (dest_imp (concl thm2a0)) + val pre_thm0 = snd (valOf(snd (hd rows_checked1))) + val pre_thm = prove (pre_tm, + MP_TAC pre_thm0 THEN + SIMP_TAC (rc_ss ssl) []) + + val thm2a1 = MP thm2a0 pre_thm + + val thm2b = TRANS thm2a thm2a1 + val thm2c = CONV_RULE (RHS_CONV (RAND_CONV rc_conv)) thm2b handle HOL_ERR _ => thm2b + in + thm2c + end handle HOL_ERR _ => let + val _ = if (List.null rows_checked1) then () else failwith "nothing to do" + in + (REWR_CONV (CONJUNCT1 PMATCH_def)) (rhs (concl thm1)) + end handle HOL_ERR _ => REFL (rhs (concl thm1)) +in + TRANS (TRANS thm0 thm1) thm2 +end handle HOL_ERR _ => raise UNCHANGED + + +fun PMATCH_CLEANUP_CONV t = PMATCH_CLEANUP_CONV_GEN [] t + + + +(***********************************************) +(* simplify a column *) +(***********************************************) + +fun pair_get_col col v = let + val vs = pairSyntax.strip_pair v + val c_v = List.nth (vs, col) + val vs' = List.take (vs, col) @ + List.drop (vs, col+1) + val _ = if (List.null vs') then failwith "pair_get_col" + else () + val v' = pairSyntax.list_mk_pair vs' +in + (v', c_v) +end; + +(*----------------*) +(* drop a column *) +(*----------------*) + +fun PMATCH_REMOVE_COL_AUX ssl col t = let + val (v, rows) = dest_PMATCH t + val (v', c_v) = pair_get_col col v + + fun PMATCH_ROW_REMOVE_FUN_VAR_COL_AUX row = let + val (vars_tm, pt, rh) = dest_PMATCH_ROW row + val vars = pairSyntax.strip_pair vars_tm + + val (pt', pv) = pair_get_col col pt + + val pv_i_opt = SOME (index (aconv pv) vars) handle HOL_ERR _ => NONE + val (vars'_tm, g') = case pv_i_opt of + (SOME pv_i) => (let + (* we eliminate a variabe column *) + val vars' = let + val vars' = List.take (vars, pv_i) @ List.drop (vars, pv_i+1) + in + if (List.null vars') then [genvar ``:unit``] else vars' + end + + val vars'_tm = pairSyntax.list_mk_pair vars' + val g' = let + val vs = List.take (vars, pv_i) @ (c_v :: List.drop (vars, pv_i+1)) + val vs_tm = pairSyntax.list_mk_pair vs + in + pairSyntax.mk_pabs (vars'_tm, vs_tm) + end + in + (vars'_tm, g') + end) + | NONE => (let + (* we eliminate a costant columns *) + val (sub, _) = match_term pv c_v + val _ = if List.all (fn x => List.exists (aconv (#redex x)) vars) sub then () else failwith "not a constant-col after all" + + val vars' = filter (fn v => not (List.exists (fn x => (aconv v (#redex x))) sub)) vars + val vars' = if (List.null vars') then [genvar ``:unit``] else vars' + val vars'_tm = pairSyntax.list_mk_pair vars' + + val g' = pairSyntax.mk_pabs (vars'_tm, Term.subst sub vars_tm) + in + (vars'_tm, g') + end) + + val f = pairSyntax.mk_pabs (vars_tm, pt) + val f' = pairSyntax.mk_pabs (vars'_tm, pt') + val g = pairSyntax.mk_pabs (vars_tm, rh) + + val thm0 = let + val thm = FRESH_TY_VARS_RULE PMATCH_ROW_REMOVE_FUN_VAR + val thm = ISPEC v thm + val thm = ISPEC v' thm + val thm = ISPEC f thm + val thm = ISPEC g thm + val thm = ISPEC f' thm + val thm = ISPEC g' thm + + fun elim_conv vs = RATOR_CONV (RAND_CONV ( + (pairTools.PABS_INTRO_CONV vs) THENC + (DEPTH_CONV (pairLib.PAIRED_BETA_CONV ORELSEC BETA_CONV)) + )) + + val thm = CONV_RULE ((RAND_CONV o LHS_CONV) (elim_conv vars_tm)) thm + val thm = CONV_RULE ((RAND_CONV o RHS_CONV) (elim_conv vars'_tm)) thm + + val tm_eq = mk_eq(lhs (rand (concl thm)), mk_comb (row, v)) + val eq_thm = prove (tm_eq, SIMP_TAC (rc_ss ssl) []) + + val thm = CONV_RULE (RAND_CONV (LHS_CONV (K eq_thm))) thm + in + thm + end + + val pre_tm = fst (dest_imp (concl thm0)) +(* set_goal ([], pre_tm) *) + val pre_thm = prove (pre_tm, SIMP_TAC (rc_ss ssl) []) + val thm1 = MP thm0 pre_thm + in + thm1 + end + + fun process_row (row, thm) = let + val row_thm = PMATCH_ROW_REMOVE_FUN_VAR_COL_AUX row + val thmA = PMATCH_EXTEND_BOTH + val thmB = HO_MATCH_MP thmA row_thm + val thmC = HO_MATCH_MP thmB thm + in + thmC + end + + val base_thm = INST_TYPE [gamma |-> type_of t] (ISPECL [v, v'] PMATCH_EXTEND_BASE) + val thm0 = List.foldl process_row base_thm (List.rev rows) +in + thm0 +end handle HOL_ERR _ => raise UNCHANGED + + + +(*------------------------------------*) +(* remove a constructor from a column *) +(*------------------------------------*) + +fun PMATCH_REMOVE_FUN_AUX ssl col t = let + val (v, rows) = dest_PMATCH t + + val (ff_tm, ff_inv, ff_inv_var, c) = let + val vs = pairSyntax.strip_pair v + val c_args = List.nth(vs, col) + val (c, args) = strip_comb c_args + + val vs_vars = List.map (fn t => genvar (type_of t)) vs + val args_vars = List.map (fn t => genvar (type_of t)) args + + val vars = List.take (vs_vars, col) @ args_vars @ + List.drop (vs_vars, col+1) + val ff_res = List.take (vs_vars, col) @ list_mk_comb (c, args_vars) :: List.drop (vs_vars, col+1) + val ff_tm = pairSyntax.mk_pabs (pairSyntax.list_mk_pair vars, + pairSyntax.list_mk_pair ff_res) + + fun ff_inv tt = let + val tts = pairSyntax.strip_pair tt + val tt_args = List.nth(tts, col) + + val (c', args') = strip_comb tt_args + val _ = if (aconv c c') then () else failwith "different constr" + + val vars = List.take (tts, col) @ args' @ + List.drop (tts, col+1) + in + pairSyntax.list_mk_pair vars + end + + fun ff_inv_var avoid tt = let + val tts = pairSyntax.strip_pair tt + val tt_col = List.nth(tts, col) + + val _ = if (is_var tt_col) then () else failwith "no var" + + val (var_basename, _) = dest_var (tt_col) + fun gen_var i arg = let + val n = var_basename ^ "_"^int_to_string i + in + mk_var (n, type_of arg) + end + + + val (args, _) = quantHeuristicsTools.list_variant avoid (mapi gen_var args_vars) + + val vars = List.take (tts, col) @ args @ + List.drop (tts, col+1) + in + (pairSyntax.list_mk_pair vars, tt_col, args) + end + + in + (ff_tm, ff_inv, ff_inv_var, c) + end + + val ff_thm_tm = ``!x y. (^ff_tm x = ^ff_tm y) ==> (x = y)`` + val ff_thm = prove (ff_thm_tm, SIMP_TAC (rc_ss ssl) []) + + val v' = ff_inv v + + val PMATCH_ROW_REMOVE_FUN' = let + val thm0 = (HO_MATCH_MP PMATCH_ROW_REMOVE_FUN ff_thm) + val thm1 = ISPEC v' thm0 + + val thm_v' = prove (``^ff_tm ^v' = ^v``, SIMP_TAC (rc_ss ssl) []) + val thm2 = CONV_RULE (STRIP_QUANT_CONV (LHS_CONV (RAND_CONV (K thm_v')))) thm1 + in + thm2 + end + + fun PMATCH_ROW_REMOVE_FUN_COL_AUX row = let + val (vars_tm, pt, rh) = dest_PMATCH_ROW row + + val pt' = ff_inv pt + val f = pairSyntax.mk_pabs (vars_tm, pt') + val g = pairSyntax.mk_pabs (vars_tm, rh) + + val thm0 = ISPEC g (ISPEC f PMATCH_ROW_REMOVE_FUN') + val eq_thm_tm = mk_eq (lhs (concl thm0), mk_comb (row, v)) + val eq_thm = prove (eq_thm_tm, SIMP_TAC (rc_ss ssl) []) + + val thm1 = CONV_RULE (LHS_CONV (K eq_thm)) thm0 + + val vi_conv = (pairTools.PABS_INTRO_CONV vars_tm) THENC + (DEPTH_CONV (pairLib.PAIRED_BETA_CONV ORELSEC BETA_CONV)) + + val thm2 = CONV_RULE (RHS_CONV (RATOR_CONV (RAND_CONV vi_conv))) thm1 + in + thm2 + end + + fun PMATCH_ROW_REMOVE_VAR_COL_AUX row = let + val (vars_tm, pt, rh) = dest_PMATCH_ROW row + val vars = pairSyntax.strip_pair vars_tm + + val avoid = vars @ free_vars pt @ free_vars rh + val (pt', pv, new_vars) = ff_inv_var avoid pt + + val pv_i = index (aconv pv) vars + + val vars' = let + val vars' = List.take (vars, pv_i) @ new_vars @ List.drop (vars, pv_i+1) + in + if (List.null vars') then [genvar ``:unit``] else vars' + end + + val vars'_tm = pairSyntax.list_mk_pair vars' + val g' = let + val c_v = list_mk_comb (c, new_vars) + val vs = List.take (vars, pv_i) @ (c_v :: List.drop (vars, pv_i+1)) + val vs_tm = pairSyntax.list_mk_pair vs + in + pairSyntax.mk_pabs (vars'_tm, vs_tm) + end + + val f = pairSyntax.mk_pabs (vars_tm, pt) + val f' = pairSyntax.mk_pabs (vars'_tm, pt') + val g = pairSyntax.mk_pabs (vars_tm, rh) + + val thm0 = let + val thm = FRESH_TY_VARS_RULE PMATCH_ROW_REMOVE_FUN_VAR + val thm = ISPEC v thm + val thm = ISPEC v' thm + val thm = ISPEC f thm + val thm = ISPEC g thm + val thm = ISPEC f' thm + val thm = ISPEC g' thm + + fun elim_conv vs = RATOR_CONV (RAND_CONV ( + (pairTools.PABS_INTRO_CONV vs) THENC + (DEPTH_CONV (pairLib.PAIRED_BETA_CONV ORELSEC BETA_CONV)) + )) + + val thm = CONV_RULE ((RAND_CONV o LHS_CONV) (elim_conv vars_tm)) thm + val thm = CONV_RULE ((RAND_CONV o RHS_CONV) (elim_conv vars'_tm)) thm + + val tm_eq = mk_eq(lhs (rand (concl thm)), mk_comb (row, v)) + val eq_thm = prove (tm_eq, + SIMP_TAC (rc_ss ssl) []) + + val thm = CONV_RULE (RAND_CONV (LHS_CONV (K eq_thm))) thm + in + thm + end + + val pre_tm = fst (dest_imp (concl thm0)) + val pre_thm = prove (pre_tm, SIMP_TAC (rc_ss ssl) []) + + val thm1 = MP thm0 pre_thm + in + thm1 + end + + + fun process_row (row, thm) = let + val row_thm = PMATCH_ROW_REMOVE_FUN_COL_AUX row handle HOL_ERR _ => + PMATCH_ROW_REMOVE_VAR_COL_AUX row + val thmA = PMATCH_EXTEND_BOTH + val thmB = HO_MATCH_MP thmA row_thm + val thmC = HO_MATCH_MP thmB thm + in + thmC + end + +(* + val row = el 1 (List.rev rows) + val thm = base_thm + val thm = thm0 +*) + + val base_thm = INST_TYPE [gamma |-> type_of t] (ISPECL [v, v'] PMATCH_EXTEND_BASE) + val thm0 = foldl process_row base_thm (List.rev rows) +in + thm0 +end handle HOL_ERR _ => raise UNCHANGED + + +(*------------------------*) +(* Combine auxiliary funs *) +(*------------------------*) + +fun PMATCH_SIMP_COLS_CONV_GEN ssl t = let + val cols = dest_PMATCH_COLS t +(* + val (col_v, col) = el 1 cols + val (vars, col_pat) = el 3 col +*) + fun do_match col_v (vars, col_pat) = let + val (sub, _) = match_term col_pat col_v + val vars_ok = List.all (fn x => (List.exists (aconv (#redex x)) vars)) sub + in + vars_ok + end handle HOL_ERR _ => false + + fun elim_col_ok (col_v, col) = + List.all (do_match col_v) col + + fun simp_col_ok (col_v, col) = let + val (c, args) = strip_comb col_v + val _ = if (List.null args) then failwith "elim_col instead" else () + + fun check_line (vars, pt) = + (List.exists (aconv pt) vars) orelse + (aconv (fst (strip_comb pt)) c) + in + List.all check_line col + end handle HOL_ERR _ => false + + fun process_col i col = if (elim_col_ok col) then + SOME (PMATCH_REMOVE_COL_AUX ssl i t) + else if (simp_col_ok col) then + SOME (PMATCH_REMOVE_FUN_AUX ssl i t) + else NONE + + val thm_opt = first_opt process_col cols +in + case thm_opt of NONE => raise UNCHANGED + | SOME thm => thm +end + +val PMATCH_SIMP_COLS_CONV = PMATCH_SIMP_COLS_CONV_GEN [] + + +(***********************************************) +(* Expand columns *) +(***********************************************) + +(* Sometimes not all rows of a PMATCH have the same number of + explicit columns. This can happen, if some patterns are + explicit pairs, while others are not. The following tries + to expand columns into explicit ones. *) + +fun PMATCH_EXPAND_COLS_CONV t = let + val (v, rows) = dest_PMATCH t + + val col_no_v = length (pairSyntax.strip_pair v) + val col_no = foldl (fn (r, m) => let + val (_, pt, _) = dest_PMATCH_ROW r + val m' = length (pairSyntax.strip_pair pt) + val m'' = if m' > m then m' else m + in m'' end) col_no_v rows + + fun split_var avoid cols l = let + fun splits acc no ty = if (no = 0) then List.rev (ty::acc) else + let + val (ty_s, ty') = pairSyntax.dest_prod ty + in + splits (ty_s::acc) (no - 1) ty' + end + + val types = splits [] (col_no - cols) (type_of l) + + val var_basename = fst (dest_var l) handle HOL_ERR _ => "v" + fun gen_var i ty = let + val n = var_basename ^ "_"^int_to_string i + in + mk_var (n, ty) + end + + val (new_vars, _) = quantHeuristicsTools.list_variant avoid (mapi gen_var types) + in + new_vars + end + + fun PMATCH_ROW_EXPAND_COLS row = let + val (vars_tm, pt, rh) = dest_PMATCH_ROW row + + val vars = pairSyntax.strip_pair vars_tm + val pts = pairSyntax.strip_pair pt + val cols = length pts + + val _ = if (cols < col_no) then () else failwith "nothing to do" + val l = last pts + + val _ = if (List.exists (aconv l) vars) then () else failwith "nothing to do" + + val avoids = vars @ free_vars pt @ free_vars rh + val new_vars = split_var avoids cols l + + val sub = [l |-> pairSyntax.list_mk_pair new_vars] + val pt' = Term.subst sub pt + val rh' = Term.subst sub rh + val vars_tm' = Term.subst sub vars_tm + val new_f = pairSyntax.mk_pabs(vars_tm', pairSyntax.mk_pair (pt', rh')) + + val eq_tm = mk_eq(rand row, new_f) + val eq_thm = prove (eq_tm, SIMP_TAC (rc_ss []) []) + + val thm = RATOR_CONV (RAND_CONV (K eq_thm)) (mk_comb (row, v)) + in + thm + end handle HOL_ERR _ => REFL (mk_comb (row, v)) + + fun process_row (row, thm) = let + val row_thm = PMATCH_ROW_EXPAND_COLS row + val thmA = PMATCH_EXTEND_BOTH + val thmB = HO_MATCH_MP thmA row_thm + val thmC = HO_MATCH_MP thmB thm + in + thmC + end + + val base_thm = INST_TYPE [gamma |-> type_of t] (ISPECL [v, v] PMATCH_EXTEND_BASE) + val thm0 = foldl process_row base_thm (List.rev rows) + + val thm1 = if (col_no_v >= col_no) then thm0 else let + val avoids = free_vars t + val vs = pairSyntax.strip_pair v + val l = List.last vs + val new_vars = split_var avoids col_no_v l + val new_vars_tm = pairSyntax.list_mk_pair new_vars + + val sub = [l |-> new_vars_tm] + + val tt = rhs (concl thm0) + val tt' = Term.subst sub tt + val tt'' = boolSyntax.mk_let (pairSyntax.mk_pabs (new_vars_tm, tt'), l) + + val thm_eq = prove (mk_eq (tt, tt''), + SIMP_TAC (rc_ss []) [LET_DEF]) + in + TRANS thm0 thm_eq + end +in + thm1 +end handle HOL_ERR _ => raise UNCHANGED + + +(***********************************************) +(* PMATCH_SIMP_CONV *) +(***********************************************) +fun PMATCH_SIMP_CONV_GEN rc = REPEATC (FIRST_CONV [ + CHANGED_CONV (PMATCH_CLEANUP_PVARS_CONV), + CHANGED_CONV (PMATCH_CLEANUP_CONV_GEN rc), + CHANGED_CONV (PMATCH_REMOVE_ARB_CONV_GEN rc), + CHANGED_CONV (PMATCH_SIMP_COLS_CONV_GEN rc)]) + +val PMATCH_SIMP_CONV = PMATCH_SIMP_CONV_GEN [] + + +(***********************************************) +(* Case_splits *) +(* This is work in progress *) +(***********************************************) + +fun STRIP_ABS_CONV conv t = + if (is_abs t) then ABS_CONV (STRIP_ABS_CONV conv) t else + conv t + +fun PMATCH_CASE_SPLIT_AUX col expand_thm conv t = let + val (v, rows) = dest_PMATCH t + val vs = pairSyntax.strip_pair v + + val arg = el (col+1) vs + val arg_v = genvar (type_of arg) + val vs' = pairSyntax.list_mk_pair (List.take (vs, col) @ (arg_v :: (List.drop (vs, col+1)))) + + val ff = let + val (x, xs) = strip_comb t + val t' = list_mk_comb(x, vs' :: (tl xs)) + in + mk_abs (arg_v, t') + end + + val thm0 = ISPEC arg (ISPEC ff expand_thm) + val thm1 = CONV_RULE (LHS_CONV BETA_CONV) thm0 + + fun is_case_conv_end t = + is_comb (fst (dest_comb t)) handle HOL_ERR _ => false + + fun case_conv conv t = + if not (is_case_conv_end t) then REFL t else + (RAND_CONV (STRIP_ABS_CONV conv) THENC RATOR_CONV (case_conv conv)) t + + val thm2 = CONV_RULE (RHS_CONV (case_conv (BETA_CONV THENC TRY_CONV conv))) thm1 +in + thm2 +end + +fun PMATCH_CASE_SPLIT_CONV_GEN ssl col t = let + val thm0 = QCHANGED_CONV ( + PMATCH_SIMP_CONV_GEN ssl) t handle HOL_ERR _ => REFL t + + val t' = rhs (concl thm0) + val (v, _) = dest_PMATCH t' + val vs = pairSyntax.strip_pair v + val ty = type_of (el (col+1) vs) + + val expand_thm = let + val case_def_thm = TypeBase.case_def_of ty + val nchotomy_thm = TypeBase.nchotomy_of ty + in + constrFamiliesLib.gen_case_expand_thm case_def_thm nchotomy_thm + end + + val thm1 = QCHANGED_CONV (PMATCH_CASE_SPLIT_AUX col expand_thm (PMATCH_SIMP_CONV_GEN ssl)) t' handle HOL_ERR _ => (REFL t') +in + TRANS thm0 thm1 +end + +end + + diff --git a/examples/deep_matches/deepMatchesScript.sml b/examples/deep_matches/deepMatchesScript.sml new file mode 100644 index 0000000000..c876f148aa --- /dev/null +++ b/examples/deep_matches/deepMatchesScript.sml @@ -0,0 +1,405 @@ +open HolKernel Parse boolLib bossLib; +open quantHeuristicsLib + +val _ = new_theory "deepMatches" + +(***************************************************) +(* Main Definitions *) +(***************************************************) + +(* rows of a pattern match are pairs of a pattern to match + against p and a result r. The result and pattern are linked + with free variables [v] bound in both. So it looks like + (\v. (p v, r v)) *) +val PMATCH_ROW_def = Define `PMATCH_ROW row i = + (if ?x. FST (row x) = i then + SOME (SND (row (@x. FST (row x) = i))) + else NONE)` + +(* We defined semantics or single rows. Let's extend + it to multiple ones, i.e. full pattern matches now *) +val PMATCH_INCOMPLETE_def = Define `PMATCH_INCOMPLETE = ARB` +val PMATCH_def = Define ` + (PMATCH v [] = PMATCH_INCOMPLETE) /\ + (PMATCH v (r::rs) = option_CASE (r v) (PMATCH v rs) I)` + + +val PMATCH_IS_EXHAUSTIVE_def = Define ` + PMATCH_IS_EXHAUSTIVE rs = ( + !v. EXISTS (\r. IS_SOME (r v)) rs)` + +val PMATCH_ROW_REDUNDANT_def = Define ` + PMATCH_ROW_REDUNDANT rs i = ( + (i < LENGTH rs /\ (!v. ?j. ((j < i) /\ + (IS_SOME ((EL i rs) v) ==> + IS_SOME ((EL j rs) v))))))` + +val PMATCH_REDUNDANT_ROWS_def = Define ` + PMATCH_REDUNDANT_ROWS rs = {i | (PMATCH_ROW_REDUNDANT rs i)}` + + +(***************************************************) +(* Rewrites *) +(***************************************************) + +val PMATCH_ROW_EQ_AUX = store_thm ("PMATCH_ROW_EQ_AUX", + ``((!i. (?x. (g x = i)) = (?x'. (g' x' = i))) /\ + (!x x'. (g x = g' x') ==> (f x = f' x'))) ==> + (PMATCH_ROW (\x:'a. (g x, f x)) = + PMATCH_ROW (\x':'b. (g' x', f' x')))``, +REPEAT STRIP_TAC THEN +SIMP_TAC std_ss [PMATCH_ROW_def, FUN_EQ_THM] THEN +CONV_TAC (RENAME_VARS_CONV ["i"]) THEN +GEN_TAC THEN +Q.PAT_ASSUM `!i. (_ = _)` (fn thm => ASSUME_TAC (Q.SPEC `i` thm)) THEN +Cases_on `?x'. g' x' = i` THEN ( + ASM_REWRITE_TAC[] +) THEN +FULL_SIMP_TAC std_ss [] THEN +SELECT_ELIM_TAC THEN +REPEAT STRIP_TAC THEN1 PROVE_TAC[] THEN +SELECT_ELIM_TAC THEN +REPEAT STRIP_TAC THEN1 PROVE_TAC[] THEN +PROVE_TAC[]) + +val PMATCH_ROW_EQ_NONE = store_thm ("PMATCH_ROW_EQ_NONE", + ``(PMATCH_ROW (\x. (g x, f x)) v = NONE) <=> + (!x. ~(g x = v))``, +SIMP_TAC std_ss [PMATCH_ROW_def]); + +val PMATCH_EVAL = store_thm ("PMATCH_EVAL", + ``(PMATCH v [] = PMATCH_INCOMPLETE) /\ + (PMATCH v ((PMATCH_ROW (\x. (g x, f x))) :: rs) = + if (?x. (g x = v)) then + (f (@x. g x = v)) else PMATCH v rs)``, + +SIMP_TAC std_ss [PMATCH_def] THEN +Cases_on `PMATCH_ROW (\x. (g x,f x)) v` THEN ( + FULL_SIMP_TAC std_ss [PMATCH_ROW_def] THEN + METIS_TAC[] +)) + +val PMATCH_EVAL_MATCH = store_thm ("PMATCH_EVAL_MATCH", + ``~(PMATCH_ROW (\x. (g x, f x)) v = NONE) ==> + (PMATCH v ((PMATCH_ROW (\x. (g x, f x))) :: rs) = + (f (@x. g x = v)))``, + +SIMP_TAC std_ss [PMATCH_def] THEN +Cases_on `PMATCH_ROW (\x. (g x,f x)) v` THEN ( + FULL_SIMP_TAC std_ss [PMATCH_ROW_def] THEN + METIS_TAC[] +)) + + +(***************************************************) +(* Changing rows and removing redundant ones *) +(***************************************************) + +(* An easy way is to start with an empty set of rows + and then step by step add rows to either one or both + sides till the desired correspondance is shown. This + is achieved by the following theorems. *) +val PMATCH_EXTEND_BASE = store_thm ("PMATCH_EXTEND_BASE", +``!v_old v_new. (PMATCH v_old [] = PMATCH v_new [])``, +SIMP_TAC std_ss [PMATCH_def]) + +val PMATCH_EXTEND_BOTH = store_thm ("PMATCH_EXTEND_BOTH", +``!v_old v_new rows_old rows_new r_old r_new. + (r_old v_old = r_new v_new) ==> + (PMATCH v_old rows_old = PMATCH v_new rows_new) ==> + (PMATCH v_old (r_old::rows_old) = PMATCH v_new (r_new :: rows_new))``, +SIMP_TAC std_ss [PMATCH_def]) + +val PMATCH_EXTEND_BOTH_ID = store_thm ("PMATCH_EXTEND_BOTH_ID", +``!v rows_old rows_new r. + (PMATCH v rows_old = PMATCH v rows_new) ==> + (PMATCH v (r::rows_old) = PMATCH v (r :: rows_new))``, +SIMP_TAC std_ss [PMATCH_def]) + +val PMATCH_EXTEND_OLD = store_thm ("PMATCH_EXTEND_OLD", +``!v_old v_new rows_old rows_new r_old. + (r_old v_old = NONE) ==> + (PMATCH v_old rows_old = PMATCH v_new rows_new) ==> + (PMATCH v_old (r_old::rows_old) = PMATCH v_new rows_new)``, +SIMP_TAC std_ss [PMATCH_def]) + + + +(***************************************************) +(* Equivalent sets of rows *) +(***************************************************) + +val PMATCH_EQUIV_ROWS_def = Define ` + PMATCH_EQUIV_ROWS v rows1 rows2 = ( + (PMATCH v rows1 = PMATCH v rows2) /\ + ((?r. MEM r rows1 /\ IS_SOME (r v)) = + (?r. MEM r rows2 /\ IS_SOME (r v))))` + +val PMATCH_EQUIV_ROWS_is_equiv_1 = store_thm ("PMATCH_EQUIV_ROWS_is_equiv_1", + ``(!rows. (PMATCH_EQUIV_ROWS v rows rows))``, +SIMP_TAC std_ss [PMATCH_EQUIV_ROWS_def]) + + +val PMATCH_EQUIV_ROWS_is_equiv_2 = store_thm ("PMATCH_EQUIV_ROWS_is_equiv_2", + ``(!rows1 rows2. ((PMATCH_EQUIV_ROWS v rows1 rows2) = + (PMATCH_EQUIV_ROWS v rows2 rows1)))``, +SIMP_TAC std_ss [PMATCH_EQUIV_ROWS_def] THEN METIS_TAC[]) + +val PMATCH_EQUIV_ROWS_is_equiv_3 = store_thm ("PMATCH_EQUIV_ROWS_is_equiv_3", + ``(!rows1 rows2 rows3. + (PMATCH_EQUIV_ROWS v rows1 rows2) ==> + (PMATCH_EQUIV_ROWS v rows2 rows3) ==> + (PMATCH_EQUIV_ROWS v rows1 rows3))``, +SIMP_TAC std_ss [PMATCH_EQUIV_ROWS_def]); + +val PMATCH_EQUIV_ROWS_MATCH = store_thm ("PMATCH_EQUIV_ROWS_MATCH", + ``PMATCH_EQUIV_ROWS v rows1 rows2 ==> + (PMATCH v rows1 = PMATCH v rows2)``, +SIMP_TAC std_ss [PMATCH_EQUIV_ROWS_def]) + +val PMATCH_APPEND_SEM = store_thm ("PMATCH_APPEND_SEM", + ``!v rows1 rows2. PMATCH v (rows1 ++ rows2) = ( + if (?r. MEM r rows1 /\ IS_SOME (r v)) then PMATCH v rows1 else PMATCH v rows2)``, +REPEAT GEN_TAC THEN +Induct_on `rows1` THEN1 ( + SIMP_TAC list_ss [] +) THEN +ASM_SIMP_TAC list_ss [PMATCH_def, RIGHT_AND_OVER_OR, EXISTS_OR_THM] THEN +GEN_TAC THEN +Cases_on `h v` THEN ( + ASM_SIMP_TAC std_ss [] +)) + +val PMATCH_APPEND = store_thm ("PMATCH_EXTEND_APPEND", +``!v rows1a rows1b rows2a rows2b. + (PMATCH_EQUIV_ROWS v rows1a rows1b) ==> + (PMATCH_EQUIV_ROWS v rows2a rows2b) ==> + (PMATCH_EQUIV_ROWS v (rows1a ++ rows2a) (rows1b ++ rows2b))``, +REPEAT STRIP_TAC THEN +FULL_SIMP_TAC list_ss [PMATCH_EQUIV_ROWS_def, RIGHT_AND_OVER_OR, + EXISTS_OR_THM, PMATCH_APPEND_SEM]) + + +(* If we have a row that matches, everything after it can be dropped *) +val PMATCH_ROWS_DROP_REDUNDANT_TRIVIAL_SOUNDNESS_EQUIV = store_thm ("PMATCH_ROWS_DROP_REDUNDANT_TRIVIAL_SOUNDNESS_EQUIV", +``!v rows n. ((n < LENGTH rows) /\ (IS_SOME ((EL n rows) v))) ==> + (PMATCH_EQUIV_ROWS v rows (TAKE (SUC n) rows))``, + +REPEAT STRIP_TAC THEN +Tactical.REVERSE (`PMATCH_EQUIV_ROWS v (TAKE (SUC n) rows ++ DROP (SUC n) rows) (TAKE (SUC n) rows)` by ALL_TAC) THEN1 ( + FULL_SIMP_TAC list_ss [] +) THEN + +SIMP_TAC std_ss [PMATCH_EQUIV_ROWS_def, PMATCH_APPEND_SEM] THEN +SIMP_TAC list_ss [] THEN + +Tactical.REVERSE (`?r. MEM r (TAKE (SUC n) rows) /\ IS_SOME (r v)` by ALL_TAC) THEN1 ( + METIS_TAC[] +) THEN +Q.EXISTS_TAC `EL n (TAKE (SUC n) rows)` THEN +ASM_SIMP_TAC list_ss [rich_listTheory.MEM_TAKE, rich_listTheory.EL_MEM, + listTheory.LENGTH_TAKE, rich_listTheory.EL_TAKE]); + + +val PMATCH_ROWS_DROP_REDUNDANT_TRIVIAL_SOUNDNESS = store_thm ("PMATCH_ROWS_DROP_REDUNDANT_TRIVIAL_SOUNDNESS", +``!v rows n. ((n < LENGTH rows) /\ (IS_SOME ((EL n rows) v))) ==> + (PMATCH v rows = PMATCH v (TAKE (SUC n) rows))``, + +REPEAT STRIP_TAC THEN +MATCH_MP_TAC PMATCH_EQUIV_ROWS_MATCH THEN +MATCH_MP_TAC PMATCH_ROWS_DROP_REDUNDANT_TRIVIAL_SOUNDNESS_EQUIV THEN +ASM_REWRITE_TAC[]) + + +val PMATCH_REMOVE_ARB = store_thm ("PMATCH_REMOVE_ARB", +``(PMATCH v (SNOC (PMATCH_ROW (\x. (f x, ARB))) rows) = + PMATCH v rows)``, + +Induct_on `rows` THENL [ + SIMP_TAC list_ss [PMATCH_def, PMATCH_ROW_def] THEN + Cases_on `?x. f x = v` THEN ( + ASM_SIMP_TAC std_ss [PMATCH_INCOMPLETE_def] + ), + + ASM_SIMP_TAC list_ss [PMATCH_def] +]) + +(* ARB rows can be removed, since a match failiure is the same + as ARB *) +val PMATCH_REMOVE_ARB_NO_OVERLAP = store_thm ("PMATCH_REMOVE_ARB_NO_OVERLAP", +``!v ff rows1 rows2. + (!x. (v = ff x) ==> EVERY (\r. (r (ff x) = NONE)) rows2) ==> + (PMATCH v (rows1 ++ ((PMATCH_ROW (\x. (ff x, ARB))) :: rows2)) = + PMATCH v (rows1 ++ rows2))``, + +REPEAT STRIP_TAC THEN +Tactical.REVERSE (Induct_on `rows1`) THEN ( + ASM_SIMP_TAC list_ss [PMATCH_def] +) THEN + +ASM_SIMP_TAC list_ss [PMATCH_def, PMATCH_ROW_def] THEN +Cases_on `?x. ff x = v` THEN ( + ASM_SIMP_TAC std_ss [PMATCH_INCOMPLETE_def] +) THEN +FULL_SIMP_TAC std_ss [] THEN +Q.PAT_ASSUM `_ = v` (ASSUME_TAC o GSYM) THEN +Induct_on `rows2` THEN ( + FULL_SIMP_TAC list_ss [PMATCH_def, PMATCH_INCOMPLETE_def] +)) + + + +(* Add an injective function to the pattern and the value. + This can be used to eliminate constructors. *) +val PMATCH_ROW_REMOVE_FUN = store_thm ("PMATCH_ROW_REMOVE_FUN", +``!ff v f g. (!x y. (ff x = ff y) ==> (x = y)) ==> + + (PMATCH_ROW (\x. (ff (f x), g x)) (ff v) = + PMATCH_ROW (\x. (f x, g x)) v)``, + +REPEAT STRIP_TAC THEN +`!x y. (ff x = ff y) = (x = y)` by PROVE_TAC[] THEN +ASM_SIMP_TAC std_ss [PMATCH_ROW_def]) + + +val PMATCH_ROW_REMOVE_FUN_EXT = store_thm ("PMATCH_ROW_REMOVE_FUN_EXT", +``!ff v f f' g g'. + + ((?x. f' x = ff v) = (?x. f x = v)) ==> + (!x x'. (f' x = ff v) ==> (f x' = v) ==> (g x v = g' x')) ==> + + (PMATCH_ROW (\x. (f' x, g x v)) (ff v) = + PMATCH_ROW (\x. (f x, g' x)) v)``, + +REPEAT STRIP_TAC THEN +ASM_SIMP_TAC std_ss [PMATCH_ROW_def] THEN +Cases_on `?x. f x = v` THEN ( + ASM_REWRITE_TAC[] +) THEN +SELECT_ELIM_TAC THEN +ASM_REWRITE_TAC [] THEN +REPEAT STRIP_TAC THEN +SELECT_ELIM_TAC THEN +ASM_REWRITE_TAC [] THEN +REPEAT STRIP_TAC THEN +PROVE_TAC[]) + + + +(* The following lemma looks rather complicated. It is + intended to work together with PMATCH_ROW_REMOVE_FUN to + propagate information in the var cases. + + as an example consider + + val t = ``PMATCH (SOME x, y) [ + PMATCH_ROW (\ x. ((SOME x, 0), SOME (x + y))); + PMATCH_ROW (\ (x', y). ((x', y), x')) + ]`` + + We want to simplify this to + + val t' = ``PMATCH (x, y) [ + PMATCH_ROW (\ x. ((x, 0), SOME (x + y))); + PMATCH_ROW (\ (x'', y). ((x'', y), SOME x'')) + ]`` + + This is done via PMATCH_ROWS_SIMP and PMATCH_ROWS_SIMP_SOUNDNESS. + We need to show that the rows correspond to each other. + + For the first row, PMATCH_ROW_REMOVE_FUN is used with + + v := (x, y) + ff (x, y) := (SOME x, y) + + f x := (x, 0) + g x := SOME (x + y) + + + For the second row, PMATCH_ROW_REMOVE_FUN is used with + + v := (SOME x, y) + v' := (x, y) + f (x', y) := (x', y) + g (x', y) := x' + f' (x'', y) = (x'', y) + g' (x'', y) := (SOME x'', y) +*) + +val PMATCH_ROW_REMOVE_FUN_VAR = store_thm ("PMATCH_ROW_REMOVE_FUN_VAR", +``!v v' f g f' g'. + ((!x'. (f' x' = v') = (f (g' x') = v)) /\ + ((!x. (f x = v) ==> ?x'. g' x' = x)) /\ + ((!x y. (f x = f y) ==> (x = y)))) ==> + (PMATCH_ROW (\x. (f x, g x)) v = + PMATCH_ROW (\x'. (f' x'), g (g' x')) v')``, + +REPEAT STRIP_TAC THEN +ASM_SIMP_TAC std_ss [PMATCH_ROW_def] THEN +`(?x'. f (g' x') = v) = (?x. f x = v)` by ALL_TAC THEN1 ( + METIS_TAC[] +) THEN +Cases_on `?x. f x = v` THEN ( + ASM_SIMP_TAC std_ss [] +) THEN + +SELECT_ELIM_TAC THEN +ASM_SIMP_TAC std_ss [] THEN +SELECT_ELIM_TAC THEN +REPEAT STRIP_TAC THEN ( + METIS_TAC[] +)); + + + +(***************************************************) +(* THEOREMS ABOUT FLATTENING *) +(***************************************************) + +val PMATCH_FLATTEN_FUN_def = Define ` + PMATCH_FLATTEN_FUN f g h v = + if (?x. g x = v) then h (f (@x. g x = v)) else NONE` + +val PMATCH_FLATTEN_THM_AUX = prove ( + ``(PMATCH v [PMATCH_ROW (\x. (g x, (PMATCH (f x) (MAP (\r. r x) rows'))))]) = + (PMATCH v (MAP (\r. (PMATCH_FLATTEN_FUN f g) (r (@x. g x = v))) rows'))``, + +Induct_on `rows'` THEN1 ( + Cases_on `?x. g x = v` THEN + ASM_SIMP_TAC list_ss [PMATCH_def, PMATCH_ROW_def] +) THEN + +Cases_on `?x. g x = v` THENL [ + GEN_TAC THEN + ASM_SIMP_TAC list_ss [PMATCH_def, PMATCH_ROW_def, PMATCH_FLATTEN_FUN_def] THEN + FULL_SIMP_TAC list_ss [PMATCH_def, PMATCH_ROW_def], + + GEN_TAC THEN + `!r. (PMATCH_FLATTEN_FUN f g r v) = NONE` by ALL_TAC THEN1 ( + ASM_SIMP_TAC std_ss [PMATCH_FLATTEN_FUN_def] + ) THEN + FULL_SIMP_TAC list_ss [PMATCH_def, PMATCH_ROW_def] +]) + + +val PMATCH_FLATTEN_FUN_PMATCH_ROW = store_thm ("PMATCH_FLATTEN_FUN_PMATCH_ROW", +``(!x1 x2. (g x1 = g x2) ==> (x1 = x2)) ==> + (!x y. (g'' x = y) = (g' x = f y)) ==> ( + PMATCH_FLATTEN_FUN f g (PMATCH_ROW (\x'. (g' x', f' x'))) = + PMATCH_ROW (\x. (g (g'' x), f' x)))``, + +REPEAT STRIP_TAC THEN +SIMP_TAC std_ss [PMATCH_FLATTEN_FUN_def, FUN_EQ_THM, PMATCH_ROW_def] THEN +GEN_TAC THEN +Tactical.REVERSE (Cases_on `?x'. g x' = x`) THEN1 ( + `~(?x'. g (g'' x') = x)` by METIS_TAC[] THEN + ASM_REWRITE_TAC[] +) THEN +FULL_SIMP_TAC std_ss [] THEN +`!x''. (g x'' = x) = (x'' = x')` by METIS_TAC[] THEN +ASM_SIMP_TAC std_ss [] THEN +METIS_TAC[]) + + +val _ = export_theory() + diff --git a/examples/deep_matches/deepMatchesSyntax.sig b/examples/deep_matches/deepMatchesSyntax.sig new file mode 100644 index 0000000000..8642d89c37 --- /dev/null +++ b/examples/deep_matches/deepMatchesSyntax.sig @@ -0,0 +1,71 @@ +signature deepMatchesSyntax = +sig + include Abbrev + + val PMATCH_tm : term + val PMATCH_ROW_tm : term + + (* auxiliary function that introduces fresh + typevars for all type-vars used by + free vars of a thm *) + val FRESH_TY_VARS_RULE : rule + + + (******************) + (* PMATCH_ROW *) + (******************) + + (* dest_PMATCH_ROW ``PMATCH_ROW (\(x, y). (p x y, rh x y)`` + returns (``(x,y)``, ``p x y``, ``rh x y``). *) + val dest_PMATCH_ROW : term -> (term * term * term) + + val is_PMATCH_ROW : term -> bool + + (* [mk_PMATCH_ROW vars p rh] constructs the term + ``PMATCH_ROW (\vars. (p vars, rh vars))``. *) + val mk_PMATCH_ROW : term list -> term -> term -> term + + (* [PMATCH_ROW_PABS_ELIM_CONV ``PMATCH_ROW (\(v1, ... vn). ( p (v1, + ... vn), rh (v1, ... vn))``] removes the pair [(v1, ... vn)] and + replaces the paired lambda abstraction with a normal lambda + abstraction. It returns a theorem stating the equivalence as + well as the original varstruct removed. *) + val PMATCH_ROW_PABS_ELIM_CONV : term -> (term * thm) + + (* [PMATCH_ROW_PABS_INTRO_CONV vars t] reintroduces + paired abstraction again after being removed by e.g. + [PMATCH_ROW_PABS_ELIM_CONV]. It uses [vars] for the newly + introduced varstruct. *) + val PMATCH_ROW_PABS_INTRO_CONV : term -> term -> thm + + + (******************) + (* PMATCH *) + (******************) + + (* [dest_PMATCH ``PMATCH v rows``] returns (``v``, ``rows``). *) + val dest_PMATCH : term -> (term * term list) + + val is_PMATCH : term -> bool + + val mk_PMATCH : term -> term -> term + + (* [dest_PMATCH_COLS ``PMATCH v rows``] tries to extract the columns + of the pattern match. Each column consists of the value of v, + the free variables in the pattern and the column of the pattern + for each row. *) + val dest_PMATCH_COLS : term -> (term * (term list * term) list) list + + + (******************) + (* Pretty printer *) + (******************) + + (* A pretty printer is defined and added for PMATCH. + Whether it is use can be controled via the trace + + "use pmatch_pp" + *) + + +end diff --git a/examples/deep_matches/deepMatchesSyntax.sml b/examples/deep_matches/deepMatchesSyntax.sml new file mode 100644 index 0000000000..e4dba29c11 --- /dev/null +++ b/examples/deep_matches/deepMatchesSyntax.sml @@ -0,0 +1,167 @@ +structure deepMatchesSyntax :> deepMatchesSyntax = +struct + +open deepMatchesTheory bossLib + + +(***********************************************) +(* Terms *) +(***********************************************) + +val PMATCH_ROW_tm = ``PMATCH_ROW`` +val PMATCH_tm = ``PMATCH`` + +(***********************************************) +(* Matching support *) +(***********************************************) + +val thm = PMATCH_REMOVE_ARB_NO_OVERLAP + +fun FRESH_TY_VARS_RULE thm = let + val (vars0, _) = strip_forall (concl thm) + val vars1 = free_vars (concl thm) + val vars = vars0 @ vars1 + val tys = type_varsl (map type_of vars) + val subst = map (fn ty => (ty |-> gen_tyvar ())) tys +in + INST_TYPE subst thm +end + +(***********************************************) +(* PMATCH_ROW *) +(***********************************************) + +fun dest_PMATCH_ROW row = let + val (f, args) = strip_comb row + val _ = if (same_const f PMATCH_ROW_tm) andalso (List.length args = 1) then () else failwith "dest_PMATCH_ROW" + + val arg = hd args + + val (vars_tm, prh) = pairSyntax.dest_pabs arg + val (p, rh) = pairSyntax.dest_pair prh +in + (vars_tm, p, rh) +end + +fun is_PMATCH_ROW t = can dest_PMATCH_ROW t + +fun mk_PMATCH_ROW vars p rh = let + val prh = pairSyntax.mk_pair(p, rh) + val pabs = case vars of + [] => mk_abs (genvar ``:unit``, prh) + | [v] => mk_abs (v, prh) + | _ => pairSyntax.mk_pabs (pairSyntax.list_mk_pair vars, prh) + in + mk_icomb (PMATCH_ROW_tm, pabs) + end + + +fun PMATCH_ROW_PABS_ELIM_CONV r = let + val (vars, _, _) = dest_PMATCH_ROW r + val thm = (RAND_CONV pairTools.PABS_ELIM_CONV) r +in + (vars, thm) +end + +fun PMATCH_ROW_PABS_INTRO_CONV vars r = let + val _ = if (is_PMATCH_ROW r) then () else failwith "PMATCH_ROW_PABS_INTRO_CONV" + val thm = (RAND_CONV (pairTools.PABS_INTRO_CONV vars)) r +in + thm +end + + + +(***********************************************) +(* PMATCH *) +(***********************************************) + +fun mk_PMATCH v rows = let + val rows_ty = let + val ty0 = type_of PMATCH_tm + val (arg_tys, _) = wfrecUtils.strip_fun_type ty0 + in el 2 arg_tys end + + val ty_subst = match_type rows_ty (type_of rows) + val b_tm = inst ty_subst PMATCH_tm + val t1 = mk_comb (b_tm, v) + val t2 = mk_comb (t1, rows) +in + t2 +end + +fun dest_PMATCH t = let + val (f, args) = strip_comb t + val _ = if (same_const f PMATCH_tm) andalso (List.length args = 2) then () else failwith "dest_PMATCH" + val (l, _) = listSyntax.dest_list (el 2 args) +in + (el 1 args, l) +end + +fun is_PMATCH t = can dest_PMATCH t + +fun dest_PMATCH_COLS t = let + val (v, rows) = dest_PMATCH t + val vs = pairSyntax.strip_pair v + + fun split_row r = let + val (vars_tm, pt, rh) = dest_PMATCH_ROW r + val vars = pairSyntax.strip_pair vars_tm + val pts = pairSyntax.strip_pair pt + in + List.map (fn x => (vars, x)) pts + end + val rows' = map split_row rows + + fun get_cols acc vs rows = case vs of + [] => List.rev acc + | (v::vs') => let + val col = map hd rows + val rows' = map tl rows + in + get_cols ((v, col)::acc) vs' rows' + end + val cols = get_cols [] vs rows' +in + cols +end + + + +(***********************************************) +(* Pretty Printing *) +(***********************************************) + +val use_pmatch_pp = ref true +val _ = Feedback.register_btrace ("use pmatch_pp", use_pmatch_pp); + +fun pmatch_printer GS backend sys (ppfns:term_pp_types.ppstream_funs) gravs d t = + let + open Portable term_pp_types smpp + infix >> + val _ = if (!use_pmatch_pp) then () else raise term_pp_types.UserPP_Failed + val {add_string,add_break,ublock,add_newline,ustyle,...} = ppfns + val (v,rows) = dest_PMATCH t; + + val rows' = map dest_PMATCH_ROW rows + + fun pp_row (vars, pat, rh) = ( + term_pp_utils.record_bvars (pairSyntax.strip_pair vars) ( + ublock PP.CONSISTENT 0 ( + add_string "|" >> add_break (1, 0) >> + sys (Top, Top, Top) (d - 1) pat >> + add_break (1, 0) >> add_string "=>" >> add_break (1, 0) >> + sys (Top, Top, Top) (d - 1) rh + )) + ) + in + (ublock PP.CONSISTENT 2 (add_string "CASE" >> add_break(1,2) >> + sys (Top, Top, Top) (d - 1) v >> + add_break(1,0) >> add_string "OF")) >> + add_break (1, 0) >> + smpp.pr_list pp_row (add_break (0, 0)) rows' + end handle HOL_ERR _ => raise term_pp_types.UserPP_Failed; + +val _ = add_user_printer ("PMATCH", ``PMATCH v l``, pmatch_printer); + +end From c231f2c949505030530fc0659509837d8fc596c9 Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Thu, 4 Dec 2014 16:00:57 +0000 Subject: [PATCH 040/718] Expose conversion in x64_stepLib. --- examples/l3-machine-code/x64/step/x64_stepLib.sig | 1 + 1 file changed, 1 insertion(+) diff --git a/examples/l3-machine-code/x64/step/x64_stepLib.sig b/examples/l3-machine-code/x64/step/x64_stepLib.sig index 48dde76cfd..fa1b48a09a 100644 --- a/examples/l3-machine-code/x64/step/x64_stepLib.sig +++ b/examples/l3-machine-code/x64/step/x64_stepLib.sig @@ -1,5 +1,6 @@ signature x64_stepLib = sig + val x64_CONV: Conv.conv val x64_step: Term.term list -> Thm.thm val x64_step_hex: string -> Thm.thm val x64_step_code: string quotation -> Thm.thm list From 29fbf94c125075ca301e9b57e929a3089ce193c6 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 8 Dec 2014 10:52:08 +1100 Subject: [PATCH 041/718] Remove HOL88-isms from FREEZE_THEN's doc-file. Prompted by question from Rob Arthan on hol-info mailing list. --- help/Docfiles/Tactic.FREEZE_THEN.doc | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/help/Docfiles/Tactic.FREEZE_THEN.doc b/help/Docfiles/Tactic.FREEZE_THEN.doc index d8ae4e5f72..3a2eeed75a 100644 --- a/help/Docfiles/Tactic.FREEZE_THEN.doc +++ b/help/Docfiles/Tactic.FREEZE_THEN.doc @@ -35,7 +35,7 @@ tactic arises if the hypotheses of the theorem are not alpha-convertible to assumptions of the goal. \EXAMPLE -Given the goal {([ "b < c"; "a < b" ], "(SUC a) <= c")}, and the +Given the goal {([ ``b < c``, ``a < b`` ], ``SUC a <= c``)}, and the specialized variant of the theorem {LESS_TRANS}: { th = |- !p. a < b /\ b < p ==> a < p @@ -43,7 +43,7 @@ specialized variant of the theorem {LESS_TRANS}: {IMP_RES_TAC th} will generate several unneeded assumptions: { {b < c, a < b, a < c, !p. c < p ==> b < p, !a'. a' < a ==> a' < b} - ?- (SUC a) <= c + ?- SUC a <= c } which can be avoided by first `freezing' the theorem, using the tactic @@ -52,7 +52,7 @@ the tactic } This prevents the variables {a} and {b} from being instantiated. { - {b < c, a < b, a < c} ?- (SUC a) <= c + {b < c, a < b, a < c} ?- SUC a <= c } From 61756ea72f601162487f0ee463f6b2a70104e452 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 8 Dec 2014 10:58:12 +1100 Subject: [PATCH 042/718] Changes to goal assumptions in FREEZE_THEN described more accurately --- help/Docfiles/Tactic.FREEZE_THEN.doc | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/help/Docfiles/Tactic.FREEZE_THEN.doc b/help/Docfiles/Tactic.FREEZE_THEN.doc index 3a2eeed75a..9ad51286fe 100644 --- a/help/Docfiles/Tactic.FREEZE_THEN.doc +++ b/help/Docfiles/Tactic.FREEZE_THEN.doc @@ -13,16 +13,16 @@ theorem-tactic, selective, free. and a theorem {(A1 |- w)} as arguments. The tactic-generating function {f} is applied to the theorem {(w |- w)}. If this tactic generates the subgoal: { - A ?- t + A0 ?- t ========= f (w |- w) - A ?- t1 + A ?- t1 } then applying {FREEZE_THEN f (A1 |- w)} -to the goal {(A ?- t)} produces the subgoal: +to the goal {(A0 ?- t)} produces the subgoal: { - A ?- t - ========= FREEZE_THEN f (A1 |- w) - A ?- t1 + A0 ?- t + =================== FREEZE_THEN f (A1 |- w) + A - {w}, A1 ?- t1 } Since the term {w} is a hypothesis of the argument to the function {f}, none of the free variables present in {w} may be From a582063128d2ab97cbab179918eed9cfa0a1e86f Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 8 Dec 2014 11:37:29 +1100 Subject: [PATCH 043/718] Remove calls to print_theory in enumfset/script files. print_theory is fine to call interactively, but just adds verbiage when done as part of a build. Having done a build, looking at a Theory.sig file is a good way to see what one has achieved. --- src/enumfset/enumeralScript.sml | 13 ++++++------- src/enumfset/fmapalScript.sml | 17 ++++++++--------- src/enumfset/inttoScript.sml | 1 - src/enumfset/tcScript.sml | 7 +++---- src/enumfset/totoScript.sml | 1 - src/enumfset/wotScript.sml | 1 - 6 files changed, 17 insertions(+), 23 deletions(-) diff --git a/src/enumfset/enumeralScript.sml b/src/enumfset/enumeralScript.sml index 091ca90030..9078879d67 100644 --- a/src/enumfset/enumeralScript.sml +++ b/src/enumfset/enumeralScript.sml @@ -102,7 +102,7 @@ val K2 = Define`K2 (a:'a) = 2`; val bt_rev_size = maybe_thm ("bt_rev_size", Term `!ft bl:'a bl. bl_size K2 (bt_rev ft bl) = bt_size K2 ft + bl_size K2 bl`, -Induct THEN +Induct THEN ASM_REWRITE_TAC [bl_size_def, bt_size_def, K2,bt_rev,arithmeticTheory.ADD] THEN SIMP_TAC arith_ss []); @@ -167,7 +167,7 @@ val smerge_set = maybe_thm ("smerge_set", ``!cmp:'a toto l m. (set (smerge cmp l m) = set l UNION set m)``, GEN_TAC THEN Induct THEN SRW_TAC [] [smerge, smerge_nil] THEN -Induct_on `m` THEN +Induct_on `m` THEN SRW_TAC [] [smerge, smerge_nil] THEN Cases_on `apto cmp h h'` THENL [ALL_TAC, `h = h'` by IMP_RES_TAC toto_equal_eq, ALL_TAC] THEN @@ -179,7 +179,7 @@ val smerge_OL = store_thm ("smerge_OL", ``!cmp:'a toto l m. OL cmp l /\ OL cmp m ==> OL cmp (smerge cmp l m)``, GEN_TAC THEN Induct THEN SRW_TAC [] [smerge, OL, smerge_nil] THEN -Induct_on `m` THEN +Induct_on `m` THEN SRW_TAC [] [smerge, OL, smerge_nil] THEN Cases_on `apto cmp h h'` THEN SRW_TAC [] [OL] THENL [`MEM p l \/ MEM p (h' :: m)` @@ -212,7 +212,7 @@ val OL_sublists = Define val OL_sublists_ind = theorem "OL_sublists_ind"; -(* OL_sublists_ind = |- !P. (!cmp. P cmp []) /\ +(* OL_sublists_ind = |- !P. (!cmp. P cmp []) /\ (!cmp lol. P cmp lol ==> P cmp (NONE::lol)) /\ (!cmp m lol. P cmp lol ==> P cmp (SOME m::lol)) ==> !v v1. P v v1 *) @@ -663,7 +663,7 @@ val OU_EMPTY = store_thm ("OU_EMPTY", ``!cmp:'a toto t:'a set. OU cmp t {} = t``, REWRITE_TAC [OU, NOT_IN_EMPTY, UNION_EMPTY, GSPEC_ID]); -val sing_UO = maybe_thm ("sing_UO",``!cmp:'a toto x:'a t:'a set. +val sing_UO = maybe_thm ("sing_UO",``!cmp:'a toto x:'a t:'a set. {x} UNION {y | y IN t /\ (apto cmp x y = LESS)} = UO cmp {x} t``, RW_TAC bool_ss [UO, IN_SING]); @@ -673,7 +673,7 @@ val LESS_UO_LEM = store_thm ("LESS_UO_LEM", RW_TAC bool_ss [GSYM sing_UO] THEN EQ_TAC THEN REWRITE_TAC [IN_UNION, IN_SING] THEN CONV_TAC (ONCE_DEPTH_CONV SET_SPEC_CONV) THENL -[CONV_TAC LEFT_IMP_FORALL_CONV THEN +[CONV_TAC LEFT_IMP_FORALL_CONV THEN Q.EXISTS_TAC `x` THEN RW_TAC bool_ss [] ,REPEAT STRIP_TAC THENL [AR, IMP_RES_TAC toto_trans_less] ]); @@ -1167,6 +1167,5 @@ val set_OWL_thm = store_thm ("set_OWL_thm", REWRITE_TAC [OWL, incr_ssort_set, incr_ssort_OL]); val _ = export_theory (); -val _ = print_theory "-"; end; diff --git a/src/enumfset/fmapalScript.sml b/src/enumfset/fmapalScript.sml index 7e725bb591..4b55ae8d5c 100644 --- a/src/enumfset/fmapalScript.sml +++ b/src/enumfset/fmapalScript.sml @@ -248,7 +248,7 @@ val ORL_single_valued = prove (Term`!cmp l. ORL cmp l ==> !x:'a y:'b z. MEM (x,y) l /\ MEM (x,z) l ==> (z = y)`, GEN_TAC THEN Induct THENL [REWRITE_TAC [MEM] -,P_PGEN_TAC (Term`p:'a,q:'b`) THEN +,P_PGEN_TAC (Term`p:'a,q:'b`) THEN DISCH_TAC THEN IMP_RES_TAC ORL THEN REPEAT GEN_TAC THEN Cases_on `apto cmp x p` THEN IMP_RES_TAC toto_glneq THEN IMP_RES_TAC toto_equal_imp_eq THEN @@ -382,7 +382,7 @@ MATCH_MP_TAC assocv_merge THEN AR); val incr_merge = Define` (incr_merge cmp (l:('a#'b)list) [] = [SOME l]) /\ (incr_merge cmp (l:('a#'b)list) (NONE :: lol) = SOME l :: lol) -/\ (incr_merge cmp (l:('a#'b)list) (SOME m :: lol) = +/\ (incr_merge cmp (l:('a#'b)list) (SOME m :: lol) = NONE :: incr_merge cmp (merge cmp l m) lol)`; val ORL_sublists = Define`(ORL_sublists cmp ([]:('a#'b)list option list) = T) @@ -676,7 +676,7 @@ SRW_TAC [] [assocv_APPEND, incr_build, merge_out] THENL val incr_sort_fun = maybe_thm ("incr_sort_fun", ``!cmp: 'a toto l:('a#'b)list. assocv (incr_sort cmp l) = assocv l``, REPEAT GEN_TAC THEN REWRITE_TAC [incr_sort, incr_flat] THEN -Q.SUBGOAL_THEN `assocv l = assocv ([] ++ l)` SUBST1_TAC +Q.SUBGOAL_THEN `assocv l = assocv ([] ++ l)` SUBST1_TAC THEN1 REWRITE_TAC [APPEND] THEN MATCH_MP_TAC assocv_incr_build THEN REWRITE_TAC [ORL]); @@ -1402,7 +1402,7 @@ val MEM_IN_DOM_fmap = maybe_thm ("MEM_IN_DOM_fmap", GEN_TAC THEN Induct THENL [REWRITE_TAC [FDOM_FEMPTY, fmap_rec, NOT_IN_EMPTY, MEM] ,P_PGEN_TAC ``x:'a,y:'b`` THEN - DISCH_THEN (fn orlc => + DISCH_THEN (fn orlc => STRIP_ASSUME_TAC (MATCH_MP (CONJUNCT1 ORL_NOT_MEM) orlc) THEN STRIP_ASSUME_TAC (REWRITE_RULE [ORL] orlc)) THEN SRW_TAC [] [fmap_rec, FAPPLY_FUPDATE_THM, FDOM_FUPDATE] THEN @@ -1564,8 +1564,8 @@ val bl_to_bt_fmap = maybe_thm ("bl_to_bt_fmap", ``!cmp b:('a#'b)bl. FMAPAL cmp (bl_to_bt b) = bl_to_fmap cmp b``, REWRITE_TAC [bl_to_bt, bl_rev_fmap_lem, bt_to_fmap, FEMPTY_OFU]); -(* Imitating enumeralTheory as usual, we next aim to show that building a - bl from a list does the same, and to begin with that +(* Imitating enumeralTheory as usual, we next aim to show that building a + bl from a list does the same, and to begin with that LESS_ALL cmp x (FDOM (bl_to_fmap cmp b)) ==> (bl_to_fmap cmp (BL_CONS (x,y) b) = bl_to_fmap cmp b |+ (x,y), @@ -1703,7 +1703,7 @@ REWRITE_TAC [combinTheory.o_THM] THEN Induct THENL val FDOM_assocv = maybe_thm ("FDOM_assocv", ``!l:('a#'b)list. FDOM (unlookup (assocv l)) = set (MAP FST l)``, -GEN_TAC THEN +GEN_TAC THEN MP_TAC (ISPEC ``MAP FST (l:('a#'b)list)`` FINITE_LIST_TO_SET) THEN REWRITE_TAC [GSYM IS_SOME_assocv] THEN MATCH_ACCEPT_TAC unlookup_FDOM); @@ -1726,7 +1726,7 @@ val fmap_ALT = maybe_thm ("fmap_ALT", ``!l:('a#'b)list. fmap l = unlookup (assocv l)``, REWRITE_TAC [FUPDATE_ALT, fmap_EXT] THEN GEN_TAC THEN CONJ_TAC THENL [REWRITE_TAC [fmap_FDOM, FDOM_assocv] -,GEN_TAC THEN +,GEN_TAC THEN REWRITE_TAC [fmap_FDOM, fmap, SPECIFICATION] THEN Induct_on `l` THENL [REWRITE_TAC [MAP, LIST_TO_SET_THM, rrs NOT_IN_EMPTY] @@ -2516,6 +2516,5 @@ val fmap_ORWL_thm = store_thm ("fmap_ORWL_thm", REWRITE_TAC [ORWL, incr_sort_fmap, incr_sort_ORL]); val _ = export_theory (); -val _ = print_theory "-"; end; diff --git a/src/enumfset/inttoScript.sml b/src/enumfset/inttoScript.sml index 5c0e0e0b7d..f9229adb39 100644 --- a/src/enumfset/inttoScript.sml +++ b/src/enumfset/inttoScript.sml @@ -124,6 +124,5 @@ val ZERO_eq_neg_ZERO_thm = store_thm ("ZERO_eq_neg_ZERO_thm", SRW_TAC [] [TO_of_LinearOrder, intOrd, GSYM arithmeticTheory.ALT_ZERO]); val _ = export_theory (); -val _ = print_theory "-"; end; diff --git a/src/enumfset/tcScript.sml b/src/enumfset/tcScript.sml index ad6f007683..34517f612e 100644 --- a/src/enumfset/tcScript.sml +++ b/src/enumfset/tcScript.sml @@ -400,7 +400,7 @@ GEN_TAC THEN REPEAT (CONV_TAC FUN_EQ_CONV THEN GEN_TAC) THEN EQ_TAC THENL MATCH_MP_TAC RTC_MONOTONE THEN REWRITE_TAC [BRESTR, DRESTR, RRESTR] THEN REPEAT STRIP_TAC THEN AR ,MATCH_MP_TAC TC_INDUCT THEN REWRITE_TAC [subTC] THEN - REPEAT STRIP_TAC + REPEAT STRIP_TAC THEN1 AR THEN DISJ2_TAC THENL [Q.EXISTS_TAC `y` THEN Q.EXISTS_TAC `y` THEN ASM_REWRITE_TAC [RTC_REFL, IN_RDOM] THEN Q.EXISTS_TAC `z` THEN AR @@ -552,11 +552,11 @@ HO_MATCH_MP_TAC FINITE_INDUCT THEN CONJ_TAC THENL val subTC_FDOM = store_thm ("subTC_FDOM", ``!g R:'a reln. (subTC R (RDOM R) = FMAP_TO_RELN g) ==> (subTC R (FDOM g) = subTC R (RDOM R))``, REPEAT STRIP_TAC THEN -Q.SUBGOAL_THEN `RDOM R SUBSET FDOM g` +Q.SUBGOAL_THEN `RDOM R SUBSET FDOM g` (SUBST1_TAC o GSYM o REWRITE_RULE [SUBSET_UNION_ABSORPTION]) THENL [Q.SUBGOAL_THEN `RDOM (subTC R (RDOM R)) = RDOM R` (SUBST1_TAC o SYM) THEN1 MATCH_ACCEPT_TAC RDOM_subTC THEN - ASM_REWRITE_TAC [RDOM_SUBSET_FDOM] + ASM_REWRITE_TAC [RDOM_SUBSET_FDOM] ,MATCH_MP_TAC subTC_SUPERSET_RDOM THEN MATCH_ACCEPT_TAC FDOM_FINITE ]); @@ -632,6 +632,5 @@ GEN_TAC THEN Induct THENL ]]]); val _ = export_theory (); -val _ = print_theory "-"; end; (* struct *) diff --git a/src/enumfset/totoScript.sml b/src/enumfset/totoScript.sml index 6dabe108eb..fb11fc2617 100644 --- a/src/enumfset/totoScript.sml +++ b/src/enumfset/totoScript.sml @@ -1000,6 +1000,5 @@ IMP_RES_THEN SUBST1_TAC TO_apto_TO_IMP THEN REWRITE_TAC [oneOrd]); (* intto moved to inttoTheory, to avoid always loading intLib *) val _ = export_theory (); -val _ = print_theory "-"; end; diff --git a/src/enumfset/wotScript.sml b/src/enumfset/wotScript.sml index 5e1ed69a7d..0b945eb63c 100644 --- a/src/enumfset/wotScript.sml +++ b/src/enumfset/wotScript.sml @@ -542,6 +542,5 @@ Q.EXISTS_TAC `$mex_less` THEN REWRITE_TAC [WellOrd_mex_less, GSYM StrongWellOrder]); val _ = export_theory (); -val _ = print_theory "-"; end; From 6ac8ba082fd3f5bc5e7f9077abbfd7beb2de2211 Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Mon, 8 Dec 2014 15:34:54 +0000 Subject: [PATCH 044/718] Add tool support for the MIPS instructions LWL, LWR, LDL and LDR. --- .../mips/prog/mips_progLib.sml | 1 + .../mips/step/mips_stepLib.sml | 72 ++++++++++++++++++- .../mips/step/mips_stepScript.sml | 30 ++++++++ 3 files changed, 101 insertions(+), 2 deletions(-) diff --git a/examples/l3-machine-code/mips/prog/mips_progLib.sml b/examples/l3-machine-code/mips/prog/mips_progLib.sml index f4948d5a4e..6c20ebf92d 100644 --- a/examples/l3-machine-code/mips/prog/mips_progLib.sml +++ b/examples/l3-machine-code/mips/prog/mips_progLib.sml @@ -88,6 +88,7 @@ val state_id = ["CP0", "PC", "exceptionSignalled", "hi", "lo"], ["CP0", "LLbit", "PC"], ["CP0", "LLbit", "PC", "exceptionSignalled"], + ["CP0", "LLbit", "PC", "exceptionSignalled", "gpr"], ["CP0", "LLbit", "PC", "gpr"], ["CP0", "PC"], ["CP0", "PC", "lo"], diff --git a/examples/l3-machine-code/mips/step/mips_stepLib.sml b/examples/l3-machine-code/mips/step/mips_stepLib.sml index a3cffe53e3..37dc2fde49 100644 --- a/examples/l3-machine-code/mips/step/mips_stepLib.sml +++ b/examples/l3-machine-code/mips/step/mips_stepLib.sml @@ -336,6 +336,46 @@ val ERET = (* Load/Store thms and tools *) +val cond_0_1 = Q.prove( + `!w: word1 a b c. + (if w = 0w then a else if w = 1w then b else c) = + (if w = 0w then a else b)`, + wordsLib.Cases_word_value \\ simp []) + +val cond_0_3 = Q.prove( + `!w: word2 a b c d e. + (if w = 0w then a + else if w = 1w then b + else if w = 2w then c + else if w = 3w then d + else e) = + (if w = 0w then a + else if w = 1w then b + else if w = 2w then c + else d)`, + wordsLib.Cases_word_value \\ simp []) + +val cond_0_7 = Q.prove( + `!w: word3 a b c d e f g h i. + (if w = 0w then a + else if w = 1w then b + else if w = 2w then c + else if w = 3w then d + else if w = 4w then e + else if w = 5w then f + else if w = 6w then g + else if w = 7w then h + else i) = + (if w = 0w then a + else if w = 1w then b + else if w = 2w then c + else if w = 3w then d + else if w = 4w then e + else if w = 5w then f + else if w = 6w then g + else h)`, + wordsLib.Cases_word_value \\ simp []) + val mem_thms = [AddressTranslation_def, LoadMemory_def, StoreMemory_byte, storeWord_def, storeDoubleword_def, @@ -345,6 +385,9 @@ val mem_thms = BYTE_def, HALFWORD_def, WORD_def, DOUBLEWORD_def, address_align, address_align2, cond_sign_extend, byte_address, extract_byte, wordsTheory.word_concat_0_0, wordsTheory.WORD_XOR_CLAUSES, + cond_0_1, cond_0_3, cond_0_7, + EVAL ``word_replicate 2 (0w: word1) : word2``, + EVAL ``word_replicate 2 (1w: word1) : word2``, EVAL ``((1w:word1) @@ (0w:word2)) : word3``, EVAL ``(word_replicate 2 (0w:word1) : word2 @@ (0w:word1)) : word3``, EVAL ``(word_replicate 2 (1w:word1) : word2 @@ (0w:word1)) : word3``, @@ -353,8 +396,9 @@ val mem_thms = val select_rule = REWRITE_RULE - [select_byte_le, select_byte_be, byte_address, - wordsTheory.WORD_XOR_ASSOC, wordsTheory.WORD_XOR_CLAUSES] o + [select_byte_le, select_byte_be, byte_address, + SIMP_RULE (bool_ss++boolSimps.LET_ss) [] select_parts, + wordsTheory.WORD_XOR_ASSOC, wordsTheory.WORD_XOR_CLAUSES] o utilsLib.INST_REWRITE_RULE [select_half_le, select_half_be, select_word_le, select_word_be, @@ -376,6 +420,10 @@ val memcntxts = val addr = ``sw2sw (offset:word16) + if base = 0w then 0w else ^st.gpr base`` +val unaligned_memcntxts = + List.map (fn l => [``rt <> 0w:word5``, ``~^st.exceptionSignalled``] @ l) + memcntxts + val memcntxts = List.map (fn l => @@ -468,6 +516,22 @@ val LL = EVL loadWord ``dfn'LL (base, rt, offset) ^st`` val LD = EVL loadDoubleword ``dfn'LD (base, rt, offset) ^st`` val LLD = EVL loadDoubleword ``dfn'LLD (base, rt, offset) ^st`` +val LWL = + EVR select_rule (dfn'LWL_def :: mem_thms) unaligned_memcntxts [] + ``dfn'LWL (base, rt, offset)`` + +val LWR = + EVR select_rule (dfn'LWR_def :: mem_thms) unaligned_memcntxts [] + ``dfn'LWR (base, rt, offset)`` + +val LDL = + EVR select_rule (dfn'LDL_def :: mem_thms) unaligned_memcntxts [] + ``dfn'LDL (base, rt, offset)`` + +val LDR = + EVR select_rule (dfn'LDR_def :: mem_thms) unaligned_memcntxts [] + ``dfn'LDR (base, rt, offset)`` + (* Store instructions *) val SB = @@ -725,11 +789,15 @@ val mips_patterns = List.map (I ## utilsLib.pattern) ("BNEL", "FTFTFT__________________________"), ("BLEZL", "FTFTTF_____FFFFF________________"), ("BGTZL", "FTFTTT_____FFFFF________________"), + ("LDL", "FTTFTF__________________________"), + ("LDR", "FTTFTT__________________________"), ("LB", "TFFFFF__________________________"), ("LH", "TFFFFT__________________________"), + ("LWL", "TFFFTF__________________________"), ("LW", "TFFFTT__________________________"), ("LBU", "TFFTFF__________________________"), ("LHU", "TFFTFT__________________________"), + ("LWR", "TFFTTF__________________________"), ("LWU", "TFFTTT__________________________"), ("SB", "TFTFFF__________________________"), ("SH", "TFTFFT__________________________"), diff --git a/examples/l3-machine-code/mips/step/mips_stepScript.sml b/examples/l3-machine-code/mips/step/mips_stepScript.sml index 97a006b238..bdfa8784e4 100644 --- a/examples/l3-machine-code/mips/step/mips_stepScript.sml +++ b/examples/l3-machine-code/mips/step/mips_stepScript.sml @@ -277,6 +277,36 @@ val select_word_be = Q.prove( tac ) +val select_parts = Q.store_thm("select_parts", + `!a0: word8 a1: word8 a2: word8 a3: word8 a4: word8 a5: word8 a6: word8 + a7: word8. + let w = a7 @@ a6 @@ a5 @@ a4 @@ a3 @@ a2 @@ a1 @@ a0 + in + ((7 >< 0) w = a0) /\ + ((15 >< 0) w = (a1 @@ a0) : word16) /\ + ((23 >< 0) w = (a2 @@ a1 @@ a0) : word24) /\ + ((31 >< 0) w = (a3 @@ a2 @@ a1 @@ a0) : word32) /\ + ((39 >< 0) w = (a4 @@ a3 @@ a2 @@ a1 @@ a0) : 40 word) /\ + ((47 >< 0) w = (a5 @@ a4 @@ a3 @@ a2 @@ a1 @@ a0) : word48) /\ + ((55 >< 0) w = (a6 @@ a5 @@ a4 @@ a3 @@ a2 @@ a1 @@ a0) : 56 word) /\ + ((63 >< 0) w = w) /\ + ((39 >< 32) w = a4) /\ + ((47 >< 32) w = (a5 @@ a4) : word16) /\ + ((55 >< 32) w = (a6 @@ a5 @@ a4) : word24) /\ + ((63 >< 32) w = (a7 @@ a6 @@ a5 @@ a4) : word32) /\ + ((31 >< 8) w = (a3 @@ a2 @@ a1) : word24) /\ + ((31 >< 16) w = (a3 @@ a2) : word16) /\ + ((31 >< 24) w = a3) /\ + ((63 >< 8) w = (a7 @@ a6 @@ a5 @@ a4 @@ a3 @@ a2 @@ a1) : 56 word) /\ + ((63 >< 16) w = (a7 @@ a6 @@ a5 @@ a4 @@ a3 @@ a2) : word48) /\ + ((63 >< 24) w = (a7 @@ a6 @@ a5 @@ a4 @@ a3) : 40 word) /\ + ((63 >< 32) w = (a7 @@ a6 @@ a5 @@ a4) : word32) /\ + ((63 >< 40) w = (a7 @@ a6 @@ a5) : word24) /\ + ((63 >< 48) w = (a7 @@ a6) : word16) /\ + ((63 >< 56) w = a7 : word8)`, + SIMP_TAC (srw_ss()++boolSimps.LET_ss++wordsLib.WORD_EXTRACT_ss) [] + ) + (* ------------------------------------------------------------------------ *) val bit_0_2_0 = Theory.save_thm("bit_0_2_0", From 4588239f712f1a8aea84bffbc8555ad429286e5c Mon Sep 17 00:00:00 2001 From: Thomas Tuerk Date: Mon, 8 Dec 2014 23:12:33 +0100 Subject: [PATCH 045/718] more work on deep-matches - split pat and rh side of PMATCH_ROW - this removes the need for higher order matching - added guards to PMATCH_ROW - add congruence rules for PMATCH - work on parsing PMATCH - work on using the simplifier with PMATCH --- examples/deep_matches/constrFamiliesLib.sig | 4 + examples/deep_matches/constrFamiliesLib.sml | 7 + examples/deep_matches/deepMatchesExamples.sml | 128 +++-- examples/deep_matches/deepMatchesLib.sig | 24 + examples/deep_matches/deepMatchesLib.sml | 436 +++++++++++++----- examples/deep_matches/deepMatchesScript.sml | 267 +++++++---- examples/deep_matches/deepMatchesSyntax.sig | 50 +- examples/deep_matches/deepMatchesSyntax.sml | 219 +++++++-- 8 files changed, 843 insertions(+), 292 deletions(-) diff --git a/examples/deep_matches/constrFamiliesLib.sig b/examples/deep_matches/constrFamiliesLib.sig index 21b802d6bf..9ee176a0df 100644 --- a/examples/deep_matches/constrFamiliesLib.sig +++ b/examples/deep_matches/constrFamiliesLib.sig @@ -3,4 +3,8 @@ sig include Abbrev val gen_case_expand_thm : thm -> thm -> thm + + val get_case_expand_thm : term * ((term list * term) list) -> + thm + end diff --git a/examples/deep_matches/constrFamiliesLib.sml b/examples/deep_matches/constrFamiliesLib.sml index ef846a6dcd..bcf87776ef 100644 --- a/examples/deep_matches/constrFamiliesLib.sml +++ b/examples/deep_matches/constrFamiliesLib.sml @@ -69,6 +69,13 @@ in res_thm end +fun get_case_expand_thm (v, _) = let + val ty = type_of v + val case_def_thm = TypeBase.case_def_of ty + val nchotomy_thm = TypeBase.nchotomy_of ty +in + gen_case_expand_thm case_def_thm nchotomy_thm +end diff --git a/examples/deep_matches/deepMatchesExamples.sml b/examples/deep_matches/deepMatchesExamples.sml index f90f647de8..cd856ae8d3 100644 --- a/examples/deep_matches/deepMatchesExamples.sml +++ b/examples/deep_matches/deepMatchesExamples.sml @@ -1,6 +1,7 @@ open bossLib open deepMatchesLib - +open deepMatchesTheory +open deepMatchesSyntax (* Introducing case expressions *) @@ -13,50 +14,63 @@ val thm_t' = PMATCH_REMOVE_ARB_CONV t' val thm_t' = PMATCH_SIMP_CONV t' (* more fancy *) - val t = ``case x of (NONE, []) => 0 | (SOME 2, []) => 2 | (SOME 3, (x :: xs)) => 3 + x | (SOME _, (x :: xs)) => x`` - val t' = convert_case t val thm_t = PMATCH_INTRO_CONV t val thm_t' = PMATCH_REMOVE_ARB_CONV t' val thm_t' = PMATCH_SIMP_CONV t' + (* Playing around with some examples *) val example1 = `` PMATCH (a,x,xs) - [PMATCH_ROW (\x. ((NONE,x,[]),x)); - PMATCH_ROW (\x. ((NONE,x,[2]),x)); - PMATCH_ROW (\(x,v18). ((NONE,x,[v18]),3)); - PMATCH_ROW (\(x,v12,v16,v17). ((NONE,x,v12::v16::v17),3)); - PMATCH_ROW (\(y,x,z,zs). ((SOME y,x,[z]),x+5+z)); - PMATCH_ROW (\(y,v23,v24). ((SOME y,0,v23::v24),v23+y)); - PMATCH_ROW (\(y,z,v23). ((SOME y,SUC z,[v23]),3)); - PMATCH_ROW (\(y,z). ((SOME y,SUC z,[1; 2]),y + z)); - PMATCH_ROW (\(y,z,v38). ((SOME y,SUC z,[1; v38]),3)); - PMATCH_ROW (\(y,x). ((y,x,[2;4;3]),3+x)); - PMATCH_ROW - (\(y,z,v29,v36,v37). ((SOME y,SUC z,1::v29::v36::v37),z+v36+v29)); - PMATCH_ROW (\(y,z,v31,v29,v30). ((SOME y,SUC z,v31::v29::v30),v31+z))]`` + [PMATCH_ROW (\x. (NONE,x,[])) (\x. T) (\x. x); + PMATCH_ROW (\x. (NONE,x,[2])) (\x. T) (\x. x); + PMATCH_ROW (\ (x,v18). (NONE,x,[v18])) (\ (x, v18). T) (\ (x, v18). 3); + PMATCH_ROW (\ (x,v12,v16,v17). (NONE,x,v12::v16::v17)) + (\ (x,v12,v16,v17). T) + (\ (x,v12,v16,v17). 3); + PMATCH_ROW (\ (y,x,z,zs). (SOME y,x,[z])) + (\ (y,x,z,zs). T) + (\ (y,x,z,zs). x+5+z); + PMATCH_ROW (\ (y,v23,v24). (SOME y,0,v23::v24)) + (\ (y,v23,v24). T) + (\ (y,v23,v24). v23+y); + PMATCH_ROW (\ (y,z,v23). (SOME y,SUC z,[v23])) + (\ (y,z,v23). y > 5) + (\ (y,z,v23). 3); + PMATCH_ROW (\ (y,z). (SOME y,SUC z,[1; 2])) + (\ (y,z). T) + (\ (y,z). y + z) + ]`` + val example2 = ``PMATCH (h::t) - [PMATCH_ROW (\_ . ([],x)); - PMATCH_ROW (\_. ([2],x)); PMATCH_ROW (\v18. ([v18],3)); - PMATCH_ROW (\(v12,v16,v17). (v12::v16::v17,3)); - PMATCH_ROW (\_. ([2; 4; 3],3 + x))]`` + [PMATCH_ROW (\_ . []) (\_. T) (\_. x); + PMATCH_ROW (\_. [2]) (\_. T) (\_. x); + PMATCH_ROW (\v18. [v18]) (\v18. T) (\v18. 3); + PMATCH_ROW (\ (v12,v16,v17). (v12::v16::v17)) + (\ (v12,v16,v17). T) + (\ (v12,v16,v17). 3); + PMATCH_ROW (\_. [2; 4; 3]) (\_. T) (\_. 3 + x)]`` val example3 = ``PMATCH (NONE,x,xs) - [PMATCH_ROW (\x. ((NONE,x,[]),x)); - PMATCH_ROW (\x. ((NONE,x,[2]),x)); - PMATCH_ROW (\(x,v18). ((NONE,x,[v18]),3)); - PMATCH_ROW (\(x,v12,v16,v17). ((NONE,x,v12::v16::v17),3)); - PMATCH_ROW (\(y,x). ((y,x,[2; 4; 3]),3 + x))]``; + [PMATCH_ROW (\x. (NONE,x,[])) (\x. T) (\x. x); + PMATCH_ROW (\x. (NONE,x,[2])) (\x. T) (\x. x); + PMATCH_ROW (\ (x,v18). (NONE,x,[v18])) (\ (x,v18). T) (\ (x,v18). 3); + PMATCH_ROW (\ (x,v12,v16,v17). (NONE,x,v12::v16::v17)) + (\ (x,v12,v16,v17). T) + (\ (x,v12,v16,v17). 3); + PMATCH_ROW (\ (y,x). (y,x,[2; 4; 3])) + (\ (y,x). x > 5) + (\ (y,x). 3 + x)]``; (* turn off pretty printer *) @@ -74,7 +88,7 @@ PMATCH_SIMP_CONV example3 set_goal ([], ``^example1 = XXX``); e (Cases_on `a`) -e (CONV_TAC (DEPTH_CONV PMATCH_SIMP_CONV)) +e (SIMP_TAC (std_ss++PMATCH_SIMP_ss) []) e (Cases_on `xs`) e (CONV_TAC (DEPTH_CONV PMATCH_SIMP_CONV)) @@ -86,12 +100,68 @@ e (CONV_TAC (DEPTH_CONV PMATCH_SIMP_CONV)) proofManagerLib.restart () e (Cases_on `x`) -e (CONV_TAC (DEPTH_CONV PMATCH_SIMP_CONV)) +e (SIMP_TAC (std_ss++PMATCH_SIMP_ss) []) e (Cases_on `xs`) proofManagerLib.rotate 1 -e (CONV_TAC (DEPTH_CONV PMATCH_SIMP_CONV)) -SIMP_TAC std_ss [] +e (SIMP_TAC (std_ss++PMATCH_SIMP_ss) []) proofManagerLib.drop () + +(**************************************) +(* Playing around with parsing *) +(**************************************) + +(* set parsing of case expression to deep ones *) +set_trace "parse deep cases" 1; + +val ex1 = ``case (x, y, z) of + (x, [], NONE) => x + | (x, [], SOME y) => x+y + | (_, z::zs, _) => z`` + +(* there are new features as well. Multiple + occurences of the same variable in a pattern are fine *) + +val ex2 = ``case (x, y) of + (x, x) => T + | _ => F`` + +(* let's prove that this really behaves as expected. + Notice that here the simpset-fragments for + PMATCH pick out information from the context to + simplify the PMATCH. *) + +val ex2_thm = prove (``^ex2 = (x = y)``, + +SIMP_TAC (std_ss++PMATCH_SIMP_ss) [] THEN +Cases_on `x=y` THEN ( + ASM_SIMP_TAC (std_ss++PMATCH_SIMP_ss) [] +)) + + +(**************************************) +(* PMATCH has necessary congruences *) +(* theorems to use for recursive defs *) +(**************************************) + +val _ = set_trace "parse deep cases" 1; + +val my_d_def = Define + `my_d xx = case xx of + (x, []) => x + | (x, y::ys) => my_d (x + y, ys)` + +val my_d_thms = store_thm ("my_d_thms", +``(!x. my_d (x, []) = x) /\ + (!x y ys. my_d (x, y::ys) = my_d (x + y, ys))``, + +REPEAT STRIP_TAC THENL [ + SIMP_TAC (std_ss++PMATCH_SIMP_ss) [my_d_def], + + CONV_TAC (LHS_CONV (ONCE_REWRITE_CONV [my_d_def])) THEN + SIMP_TAC (std_ss ++ PMATCH_SIMP_ss) [] +]) + + diff --git a/examples/deep_matches/deepMatchesLib.sig b/examples/deep_matches/deepMatchesLib.sig index cf1c3726fe..8fcb6545de 100644 --- a/examples/deep_matches/deepMatchesLib.sig +++ b/examples/deep_matches/deepMatchesLib.sig @@ -2,6 +2,27 @@ signature deepMatchesLib = sig include Abbrev + (********************************) + (* eliminating select *) + (********************************) + + (* PMATCH leads to selects consisting of + conjunctions that determine the value of one + component of the variable. An example is + + @x. SND (SND x = ..) /\ (FST x = ..) /\ (FST (SND x) = ..) + + by resorting these conjunctions, one can + easily derive a form + + @x. x = .. + + and therefore eliminate the select operator. + This is done by the following conversion + ssfrag. *) + val ELIM_FST_SND_SELECT_CONV : conv + val elim_fst_snd_select_ss : ssfrag + + (********************************) (* turn shallow case-terms into *) (* deeply embedded ones *) @@ -27,6 +48,9 @@ sig not known by the default methods. *) val PMATCH_SIMP_CONV_GEN : ssfrag list -> conv + (* corresponding ssfrags *) + val PMATCH_SIMP_GEN_ss : ssfrag list -> ssfrag + val PMATCH_SIMP_ss : ssfrag (* PMATCH_SIMP_CONV consists of various component conversions. These can be used diff --git a/examples/deep_matches/deepMatchesLib.sml b/examples/deep_matches/deepMatchesLib.sml index 4f2ac6a2f8..3270e28c5d 100644 --- a/examples/deep_matches/deepMatchesLib.sml +++ b/examples/deep_matches/deepMatchesLib.sml @@ -11,8 +11,39 @@ open constrFamiliesLib (***********************************************) val PAIR_EQ_COLLAPSE = prove ( -``((FST x = a) /\ (SND x = b)) = (x = (a, b))``, -Cases_on `x` THEN SIMP_TAC std_ss []) +``(((FST x = (a:'a)) /\ (SND x = (b:'b))) = (x = (a, b)))``, +Cases_on `x` THEN SIMP_TAC std_ss [] THEN METIS_TAC[]) + + +fun is_FST_eq x t = let + val (l, r) = dest_eq t + val pred = aconv (pairSyntax.mk_fst x) +in + pred l +end + +fun FST_SND_CONJUNCT_COLLAPSE v conj = let + val conj'_thm = markerLib.move_conj_left (is_FST_eq v) conj + + val v' = pairSyntax.mk_snd v + + val thm_coll = (TRY_CONV (RAND_CONV (FST_SND_CONJUNCT_COLLAPSE v')) THENC + (REWR_CONV PAIR_EQ_COLLAPSE)) + (rhs (concl conj'_thm)) +in + TRANS conj'_thm thm_coll +end handle HOL_ERR _ => raise UNCHANGED + +fun ELIM_FST_SND_SELECT_CONV t = let + val (v, conj) = boolSyntax.dest_select t + val thm0 = FST_SND_CONJUNCT_COLLAPSE v conj + + val thm1 = RAND_CONV (ABS_CONV (K thm0)) t + val thm2 = CONV_RULE (RHS_CONV (REWR_CONV SELECT_REFL)) thm1 +in + thm2 +end handle HOL_ERR _ => raise UNCHANGED + (* val rc = DEPTH_CONV pairTools.PABS_ELIM_CONV THENC SIMP_CONV list_ss [pairTheory.EXISTS_PROD, pairTheory.FORALL_PROD, PMATCH_ROW_EQ_NONE, PAIR_EQ_COLLAPSE, oneTheory.one] @@ -25,19 +56,47 @@ val pabs_elim_ss = key = SOME ([],``UNCURRY (f:'a -> 'b -> bool)``), conv = K (K pairTools.PABS_ELIM_CONV)} +val elim_fst_snd_select_ss = + simpLib.conv_ss + {name = "ELIM_FST_SND_SELECT_CONV", + trace = 2, + key = SOME ([],``$@ (f:'a -> bool)``), + conv = K (K ELIM_FST_SND_SELECT_CONV)} + fun rc_ss gl = list_ss ++ simpLib.merge_ss (gl @ [pabs_elim_ss, pairSimps.paired_forall_ss, pairSimps.paired_exists_ss, pairSimps.gen_beta_ss, + elim_fst_snd_select_ss, simpLib.rewrites [ pairTheory.EXISTS_PROD, pairTheory.FORALL_PROD, PMATCH_ROW_EQ_NONE, + PMATCH_ROW_COND_def, PAIR_EQ_COLLAPSE, oneTheory.one]]) +fun callback_CONV cb_opt t = (case cb_opt of + NONE => raise UNCHANGED + | SOME cb => ( + if (aconv t T) orelse (aconv t F) then (raise UNCHANGED) else + (EQT_INTRO (cb t) + handle HOL_ERR _ => EQF_INTRO (cb (mk_neg t))))) + +fun rc_conv (gl, callback_opt) = + SIMP_CONV (rc_ss gl) [] THENC + TRY_CONV (callback_CONV callback_opt) + +fun rc_tac (gl, callback_opt) = + CONV_TAC (rc_conv (gl, callback_opt)) + +fun PMATCH_ROW_ARGS_CONV c = + RATOR_CONV (RAND_CONV (TRY_CONV c)) THENC + RATOR_CONV (RATOR_CONV (RAND_CONV (TRY_CONV c))) THENC + RATOR_CONV (RATOR_CONV (RATOR_CONV (RAND_CONV (TRY_CONV c)))) + (***********************************************) (* converting case-splits to PMATCH *) @@ -143,7 +202,7 @@ fun convert_case t = let fun process_pattern (p, rh) = let val fvs = List.rev (free_vars p) in - mk_PMATCH_ROW fvs p rh + mk_PMATCH_ROW_PABS fvs (p, T, rh) end val rows = List.map process_pattern ps val rows_tm = listSyntax.mk_list (rows, type_of (hd rows)) @@ -161,12 +220,12 @@ fun PMATCH_INTRO_CONV t = let TODO: change implementation to get more runtime-speed *) val my_tac = ( CASE_TAC THEN - FULL_SIMP_TAC (rc_ss []) [PMATCH_EVAL] + FULL_SIMP_TAC (rc_ss []) [PMATCH_EVAL, PMATCH_ROW_COND_def] ) in (* set_goal ([], tm) *) prove (tm, REPEAT my_tac) -end handle HOL_ERR _ => NO_CONV t; +end handle HOL_ERR _ => raise UNCHANGED (***********************************************) @@ -179,25 +238,24 @@ end handle HOL_ERR _ => NO_CONV t; not needed for PMATCH and can be removed. *) (* -val ssl = [] -val t = ``PMATCH x - [PMATCH_ROW (\_ . (NONE,0)); - PMATCH_ROW (\v. (SOME v,ARB))]`` +val rc_arg = [] + +set_trace "parse deep cases" 0 +val t = convert_case ``case x of NONE => 0`` -val t = - ``PMATCH x - [PMATCH_ROW (\_. ((NONE,[]),0)); - PMATCH_ROW (\(v4,v5). ((NONE,v4::v5),ARB)); - PMATCH_ROW (\(v2,v1). ((SOME v2,v1),ARB))]`` +val t = convert_case ``case (x, y, z) of + (0, y, z) => 2 + | (x, NONE, []) => x + | (x, SOME y, l) => x+y`` *) -fun PMATCH_REMOVE_ARB_CONV_GEN_SINGLE ssl t = let +fun PMATCH_REMOVE_ARB_CONV_GENCALL_SINGLE rc_arg t = let val (v, rows) = dest_PMATCH t val rows_rev = List.rev rows val i_rev = index (fn row => ( - is_arb (#3(dest_PMATCH_ROW row))) + is_arb (#4(dest_PMATCH_ROW_ABS row))) handle HOL_ERR _ => false) rows_rev val i = length rows - (i_rev + 1) @@ -215,13 +273,13 @@ fun PMATCH_REMOVE_ARB_CONV_GEN_SINGLE ssl t = let listSyntax.mk_append (rows1_tm, listSyntax.mk_cons (rhs (concl r_thm), rows2_tm)) - val thm0 = HO_PART_MATCH (rand o lhs o snd o dest_imp o #2 o strip_forall) ( + val thm0 = PART_MATCH (rand o lhs o snd o dest_imp o #2 o strip_forall) ( ISPEC v (FRESH_TY_VARS_RULE PMATCH_REMOVE_ARB_NO_OVERLAP) ) input_rows val pre = rand (rator (concl thm0)) - val pre_thm = prove (pre, SIMP_TAC (rc_ss ssl) []) + val pre_thm = prove (pre, rc_tac rc_arg) val thm1 = MP thm0 pre_thm val thm2 = CONV_RULE ((RHS_CONV o RAND_CONV) listLib.APPEND_CONV) @@ -229,14 +287,16 @@ fun PMATCH_REMOVE_ARB_CONV_GEN_SINGLE ssl t = let val thm2_lhs_tm = mk_eq (t, lhs (concl thm2)) val thm2_lhs = prove (thm2_lhs_tm, - MP_TAC r_thm THEN SIMP_TAC (rc_ss []) []) + MP_TAC r_thm THEN + rc_tac rc_arg) val thm3 = TRANS thm2_lhs thm2 in thm3 end handle HOL_ERR _ => raise UNCHANGED -fun PMATCH_REMOVE_ARB_CONV_GEN ssl = REPEATC (PMATCH_REMOVE_ARB_CONV_GEN_SINGLE ssl) +fun PMATCH_REMOVE_ARB_CONV_GENCALL rc_arg = REPEATC (PMATCH_REMOVE_ARB_CONV_GENCALL_SINGLE rc_arg) +fun PMATCH_REMOVE_ARB_CONV_GEN ssl = PMATCH_REMOVE_ARB_CONV_GENCALL (ssl, NONE) val PMATCH_REMOVE_ARB_CONV = PMATCH_REMOVE_ARB_CONV_GEN [] @@ -246,14 +306,12 @@ val PMATCH_REMOVE_ARB_CONV = PMATCH_REMOVE_ARB_CONV_GEN [] (*val t = `` PMATCH (SOME x, xz) - [PMATCH_ROW (\x. ((SOME 2,x,[]),x)); - PMATCH_ROW (\y:'a. ((SOME 2,3,[]),x)); - PMATCH_ROW (\(z,x,yy). ((z,x,[2]),x)); - PMATCH_ROW (\(z,yy,xs). ((SOME z,xs),3+z)); - PMATCH_ROW (\(z,xs). ((SOME z,xs),3+z)); - PMATCH_ROW (\(yy,x,xs). ((NONE,xs),3))]`` + [PMATCH_ROW (\x. (SOME 2,x,[])) (\x. T) (\x. x); + PMATCH_ROW (\y:'a. ((SOME 2,3,[]))) (\y. T) (\y. x); + PMATCH_ROW (\(z,x,yy). (z,x,[2])) (\(z,x,yy). T) (\(z,x,yy). x)]`` *) + (* Many simps depend on patterns being injective. This means in particular that no extra, unused vars occur in the patterns. The following removes such unused vars. *) @@ -262,7 +320,7 @@ fun PMATCH_CLEANUP_PVARS_CONV t = let val _ = if is_PMATCH t then () else raise UNCHANGED fun row_conv row = let - val (vars_tm, pt, rh) = dest_PMATCH_ROW row + val (vars_tm, pt, gt, rh) = dest_PMATCH_ROW_ABS row val _ = if (type_of vars_tm = ``:unit``) then raise UNCHANGED else () val vars = pairSyntax.strip_pair vars_tm val used_vars = FVL [pt, rh] empty_tmset @@ -272,21 +330,20 @@ fun PMATCH_CLEANUP_PVARS_CONV t = let val _ = if (length vars = length filtered_vars) then raise UNCHANGED else () - val row' = mk_PMATCH_ROW filtered_vars pt rh + val row' = mk_PMATCH_ROW_PABS filtered_vars (pt, gt, rh) val eq_tm = mk_eq (row, row') (* set_goal ([], eq_tm) *) val eq_thm = prove (eq_tm, - CONV_TAC (DEPTH_CONV pairTools.PABS_ELIM_CONV) THEN - HO_MATCH_MP_TAC PMATCH_ROW_EQ_AUX THEN - SIMP_TAC (rc_ss []) [] + MATCH_MP_TAC PMATCH_ROW_EQ_AUX THEN + rc_tac ([], NONE) ) in eq_thm end in - DEPTH_CONV row_conv t -end + CHANGED_CONV (DEPTH_CONV (PMATCH_ROW_FORCE_SAME_VARS_CONV THENC row_conv)) t +end handle HOL_ERR _ => raise UNCHANGED (***********************************************) @@ -296,6 +353,22 @@ end (* row matches *) (***********************************************) +(* +val t = `` +PMATCH (NONE,x,l) + [PMATCH_ROW (\x. (NONE,x,[])) (\x. T) (\x. x); + PMATCH_ROW (\x. (NONE,x,[2])) (\x. F) (\x. x); + PMATCH_ROW (\x. (NONE,x,[2])) (\x. T) (\x. x); + PMATCH_ROW (\(x,y). (y,x,[2])) (\(x, y). T) (\(x, y). x); + PMATCH_ROW (\x. (SOME 3,x,[])) (\x. T) (\x. x) + ]`` + +val t = ``PMATCH y [PMATCH_ROW (\_0_1. _0_1) (\_0_1. T) (\_0_1. F)]`` +val rc_arg = [] + +val t' = rhs (concl (PMATCH_CLEANUP_CONV t)) +*) + fun map_filter f l = case l of [] => [] | x::xs => (case f x of @@ -303,12 +376,11 @@ fun map_filter f l = case l of | SOME y => y :: (map_filter f xs)); (* remove redundant rows *) -fun PMATCH_CLEANUP_CONV_GEN ssl t = let +fun PMATCH_CLEANUP_CONV_GENCALL rc_arg t = let val (v, rows) = dest_PMATCH t - val rc_conv = SIMP_CONV (rc_ss ssl) [] fun check_row r = let - val r_tm = mk_eq (mk_comb (r, v), optionSyntax.mk_none (type_of t)) val r_thm = rc_conv r_tm + val r_tm = mk_eq (mk_comb (r, v), optionSyntax.mk_none (type_of t)) val r_thm = rc_conv rc_arg r_tm val res_tm = rhs (concl r_thm) in if (same_const res_tm T) then SOME (true, r_thm) else @@ -331,7 +403,7 @@ fun PMATCH_CLEANUP_CONV_GEN ssl t = let fun check_row_exists v rows = exists (fn x => case x of (_, SOME (v', _)) => v = v' | _ => false) rows - val _ = if ((check_row_exists true rows_checked_rev) orelse (check_row_exists false (tl rows_checked_rev))) then () else raise UNCHANGED + val _ = if ((check_row_exists true rows_checked_rev) orelse (check_row_exists false rows_checked_rev)) then () else raise UNCHANGED val row_ty = type_of (hd rows) @@ -391,23 +463,15 @@ fun PMATCH_CLEANUP_CONV_GEN ssl t = let val thm2 = let val _ = if (not (List.null rows_checked1) andalso (case hd rows_checked1 of (_, (SOME (false, _))) => true | _ => false)) then () else failwith "nothing to do" - + val thm1_tm = rhs (concl thm1) - val thm2a = DEPTH_CONV pairTools.PABS_ELIM_CONV thm1_tm handle UNCHANGED => REFL thm1_tm - val (vars,_) = pairLib.dest_pabs (rand (rand (rator (rand (thm1_tm))))) - - val thm2a0 = HO_PART_MATCH (lhs o rand) PMATCH_EVAL_MATCH (rhs (concl thm2a)) - - val pre_tm = fst (dest_imp (concl thm2a0)) - val pre_thm0 = snd (valOf(snd (hd rows_checked1))) - val pre_thm = prove (pre_tm, - MP_TAC pre_thm0 THEN - SIMP_TAC (rc_ss ssl) []) + val thm2a = PART_MATCH (lhs o rand) PMATCH_EVAL_MATCH thm1_tm + val pre_thm = EQF_ELIM (snd (valOf(snd (hd rows_checked1)))) + val thm2b = MP thm2a pre_thm - val thm2a1 = MP thm2a0 pre_thm - - val thm2b = TRANS thm2a thm2a1 - val thm2c = CONV_RULE (RHS_CONV (RAND_CONV rc_conv)) thm2b handle HOL_ERR _ => thm2b + val thm2c = CONV_RULE (RHS_CONV + (RAND_CONV (rc_conv rc_arg) THENC + pairLib.GEN_BETA_CONV)) thm2b handle HOL_ERR _ => thm2b in thm2c end handle HOL_ERR _ => let @@ -420,7 +484,8 @@ in end handle HOL_ERR _ => raise UNCHANGED -fun PMATCH_CLEANUP_CONV t = PMATCH_CLEANUP_CONV_GEN [] t +fun PMATCH_CLEANUP_CONV_GEN ssl = PMATCH_CLEANUP_CONV_GENCALL (ssl, NONE) +val PMATCH_CLEANUP_CONV = PMATCH_CLEANUP_CONV_GEN [] @@ -444,24 +509,53 @@ end; (* drop a column *) (*----------------*) -fun PMATCH_REMOVE_COL_AUX ssl col t = let +(* +val t = `` +PMATCH (NONE,x,l) + [PMATCH_ROW (\x. (NONE,x,[])) (\x. T) (\x. x); + PMATCH_ROW (\z. (NONE,z,[2])) (\z. F) (\z. z); + PMATCH_ROW (\x. (NONE,x,[2])) (\x. T) (\x. x); + PMATCH_ROW (\(z,y). (y,z,[2])) (\(z, y). IS_SOME y) (\(z, y). y) + ]`` + + +val t = `` + PMATCH (x + y,ys) + [PMATCH_ROW (λx. (x,[])) (λx. T) (λx. x); + PMATCH_ROW (λ(x,y,ys). (x,y::ys)) (λ(x,y,ys). T) + (λ(x,y,ys). my_d (x + y,ys))]`` + + +val t = ``PMATCH (x,y) + [PMATCH_ROW (λx. (x,x)) (λx. T) (λx. T); + PMATCH_ROW (λ (z, y). (z, y)) (λ (z, y). T) (λ (z, y). F)]`` + + +val rc_arg = [] +val col = 0 +*) + +fun PMATCH_REMOVE_COL_AUX rc_arg col t = let val (v, rows) = dest_PMATCH t val (v', c_v) = pair_get_col col v + val vs = free_vars c_v fun PMATCH_ROW_REMOVE_FUN_VAR_COL_AUX row = let - val (vars_tm, pt, rh) = dest_PMATCH_ROW row + val (vars_tm, pt, gt, rh) = dest_PMATCH_ROW_ABS_VARIANT vs row val vars = pairSyntax.strip_pair vars_tm + val avoid = free_varsl [pt, gt, rh] - val (pt', pv) = pair_get_col col pt + val (pt0', pv) = pair_get_col col pt + val pt' = subst [pv |-> c_v] pt0' val pv_i_opt = SOME (index (aconv pv) vars) handle HOL_ERR _ => NONE - val (vars'_tm, g') = case pv_i_opt of + val (vars'_tm, f) = case pv_i_opt of (SOME pv_i) => (let (* we eliminate a variabe column *) val vars' = let val vars' = List.take (vars, pv_i) @ List.drop (vars, pv_i+1) in - if (List.null vars') then [genvar ``:unit``] else vars' + if (List.null vars') then [variant avoid ``uv:unit``] else vars' end val vars'_tm = pairSyntax.list_mk_pair vars' @@ -488,29 +582,36 @@ fun PMATCH_REMOVE_COL_AUX ssl col t = let (vars'_tm, g') end) - val f = pairSyntax.mk_pabs (vars_tm, pt) +(* val f = pairSyntax.mk_pabs (vars_tm, pt) val f' = pairSyntax.mk_pabs (vars'_tm, pt') val g = pairSyntax.mk_pabs (vars_tm, rh) +*) + val p = pairSyntax.mk_pabs (vars_tm, pt) + val p' = pairSyntax.mk_pabs (vars'_tm, pt') + val g = pairSyntax.mk_pabs (vars_tm, gt) + val r = pairSyntax.mk_pabs (vars_tm, rh) + val thm0 = let val thm = FRESH_TY_VARS_RULE PMATCH_ROW_REMOVE_FUN_VAR val thm = ISPEC v thm val thm = ISPEC v' thm val thm = ISPEC f thm + val thm = ISPEC p thm val thm = ISPEC g thm - val thm = ISPEC f' thm - val thm = ISPEC g' thm + val thm = ISPEC r thm + val thm = ISPEC p' thm - fun elim_conv vs = RATOR_CONV (RAND_CONV ( + fun elim_conv_aux vs = ( (pairTools.PABS_INTRO_CONV vs) THENC (DEPTH_CONV (pairLib.PAIRED_BETA_CONV ORELSEC BETA_CONV)) - )) + ) - val thm = CONV_RULE ((RAND_CONV o LHS_CONV) (elim_conv vars_tm)) thm + fun elim_conv vs = PMATCH_ROW_ARGS_CONV (elim_conv_aux vs) val thm = CONV_RULE ((RAND_CONV o RHS_CONV) (elim_conv vars'_tm)) thm val tm_eq = mk_eq(lhs (rand (concl thm)), mk_comb (row, v)) - val eq_thm = prove (tm_eq, SIMP_TAC (rc_ss ssl) []) + val eq_thm = prove (tm_eq, rc_tac rc_arg) val thm = CONV_RULE (RAND_CONV (LHS_CONV (K eq_thm))) thm in @@ -519,7 +620,7 @@ fun PMATCH_REMOVE_COL_AUX ssl col t = let val pre_tm = fst (dest_imp (concl thm0)) (* set_goal ([], pre_tm) *) - val pre_thm = prove (pre_tm, SIMP_TAC (rc_ss ssl) []) + val pre_thm = prove (pre_tm, rc_tac rc_arg) val thm1 = MP thm0 pre_thm in thm1 @@ -541,12 +642,25 @@ in end handle HOL_ERR _ => raise UNCHANGED - (*------------------------------------*) (* remove a constructor from a column *) (*------------------------------------*) -fun PMATCH_REMOVE_FUN_AUX ssl col t = let +(* +val t = `` +PMATCH (SOME y,x,l) + [PMATCH_ROW (\x. (SOME 0,x,[])) (\x. T) (\x. x); + PMATCH_ROW (\z. (SOME 1,z,[2])) (\z. F) (\z. z); + PMATCH_ROW (\x. (SOME 3,x,[2])) (\x. T) (\x. x); + PMATCH_ROW (\(z,y). (y,z,[2])) (\(z, y). IS_SOME y) (\(z, y). y) + ]`` + +val rc_arg = [] +val col = 0 +*) + + +fun PMATCH_REMOVE_FUN_AUX rc_arg col t = let val (v, rows) = dest_PMATCH t val (ff_tm, ff_inv, ff_inv_var, c) = let @@ -603,46 +717,49 @@ fun PMATCH_REMOVE_FUN_AUX ssl col t = let end val ff_thm_tm = ``!x y. (^ff_tm x = ^ff_tm y) ==> (x = y)`` - val ff_thm = prove (ff_thm_tm, SIMP_TAC (rc_ss ssl) []) + val ff_thm = prove (ff_thm_tm, rc_tac rc_arg) val v' = ff_inv v val PMATCH_ROW_REMOVE_FUN' = let - val thm0 = (HO_MATCH_MP PMATCH_ROW_REMOVE_FUN ff_thm) - val thm1 = ISPEC v' thm0 + val thm0 = FRESH_TY_VARS_RULE PMATCH_ROW_REMOVE_FUN + val thm1 = ISPEC ff_tm thm0 + val thm2 = ISPEC v' thm1 + val thm3 = MATCH_MP thm2 ff_thm - val thm_v' = prove (``^ff_tm ^v' = ^v``, SIMP_TAC (rc_ss ssl) []) - val thm2 = CONV_RULE (STRIP_QUANT_CONV (LHS_CONV (RAND_CONV (K thm_v')))) thm1 + val thm_v' = prove (``^ff_tm ^v' = ^v``, rc_tac rc_arg) + val thm4 = CONV_RULE (STRIP_QUANT_CONV (LHS_CONV (RAND_CONV (K thm_v')))) thm3 in - thm2 + thm4 end fun PMATCH_ROW_REMOVE_FUN_COL_AUX row = let - val (vars_tm, pt, rh) = dest_PMATCH_ROW row + val (vars_tm, pt, gt, rh) = dest_PMATCH_ROW_ABS row val pt' = ff_inv pt - val f = pairSyntax.mk_pabs (vars_tm, pt') - val g = pairSyntax.mk_pabs (vars_tm, rh) + val vpt' = pairSyntax.mk_pabs (vars_tm, pt') + val vgt = pairSyntax.mk_pabs (vars_tm, gt) + val vrh = pairSyntax.mk_pabs (vars_tm, rh) - val thm0 = ISPEC g (ISPEC f PMATCH_ROW_REMOVE_FUN') + val thm0 = ISPECL [vpt', vgt, vrh] PMATCH_ROW_REMOVE_FUN' val eq_thm_tm = mk_eq (lhs (concl thm0), mk_comb (row, v)) - val eq_thm = prove (eq_thm_tm, SIMP_TAC (rc_ss ssl) []) + val eq_thm = prove (eq_thm_tm, rc_tac rc_arg) val thm1 = CONV_RULE (LHS_CONV (K eq_thm)) thm0 val vi_conv = (pairTools.PABS_INTRO_CONV vars_tm) THENC (DEPTH_CONV (pairLib.PAIRED_BETA_CONV ORELSEC BETA_CONV)) - val thm2 = CONV_RULE (RHS_CONV (RATOR_CONV (RAND_CONV vi_conv))) thm1 + val thm2 = CONV_RULE (RHS_CONV (PMATCH_ROW_ARGS_CONV vi_conv)) thm1 in thm2 end fun PMATCH_ROW_REMOVE_VAR_COL_AUX row = let - val (vars_tm, pt, rh) = dest_PMATCH_ROW row + val (vars_tm, pt, gt, rh) = dest_PMATCH_ROW_ABS row val vars = pairSyntax.strip_pair vars_tm - val avoid = vars @ free_vars pt @ free_vars rh + val avoid = vars @ free_vars pt @ free_vars rh @ free_vars gt val (pt', pv, new_vars) = ff_inv_var avoid pt val pv_i = index (aconv pv) vars @@ -650,11 +767,11 @@ fun PMATCH_REMOVE_FUN_AUX ssl col t = let val vars' = let val vars' = List.take (vars, pv_i) @ new_vars @ List.drop (vars, pv_i+1) in - if (List.null vars') then [genvar ``:unit``] else vars' + if (List.null vars') then [variant avoid ``uv:unit``] else vars' end val vars'_tm = pairSyntax.list_mk_pair vars' - val g' = let + val f_tm = let val c_v = list_mk_comb (c, new_vars) val vs = List.take (vars, pv_i) @ (c_v :: List.drop (vars, pv_i+1)) val vs_tm = pairSyntax.list_mk_pair vs @@ -662,30 +779,30 @@ fun PMATCH_REMOVE_FUN_AUX ssl col t = let pairSyntax.mk_pabs (vars'_tm, vs_tm) end - val f = pairSyntax.mk_pabs (vars_tm, pt) - val f' = pairSyntax.mk_pabs (vars'_tm, pt') - val g = pairSyntax.mk_pabs (vars_tm, rh) + val vpt = pairSyntax.mk_pabs (vars_tm, pt) + val vpt' = pairSyntax.mk_pabs (vars'_tm, pt') + val vrh = pairSyntax.mk_pabs (vars_tm, rh) + val vgt = pairSyntax.mk_pabs (vars_tm, gt) val thm0 = let val thm = FRESH_TY_VARS_RULE PMATCH_ROW_REMOVE_FUN_VAR val thm = ISPEC v thm val thm = ISPEC v' thm - val thm = ISPEC f thm - val thm = ISPEC g thm - val thm = ISPEC f' thm - val thm = ISPEC g' thm + val thm = ISPEC f_tm thm + val thm = ISPEC vpt thm + val thm = ISPEC vgt thm + val thm = ISPEC vrh thm + val thm = ISPEC vpt' thm - fun elim_conv vs = RATOR_CONV (RAND_CONV ( + fun elim_conv vs = PMATCH_ROW_ARGS_CONV ( (pairTools.PABS_INTRO_CONV vs) THENC (DEPTH_CONV (pairLib.PAIRED_BETA_CONV ORELSEC BETA_CONV)) - )) + ) - val thm = CONV_RULE ((RAND_CONV o LHS_CONV) (elim_conv vars_tm)) thm val thm = CONV_RULE ((RAND_CONV o RHS_CONV) (elim_conv vars'_tm)) thm val tm_eq = mk_eq(lhs (rand (concl thm)), mk_comb (row, v)) - val eq_thm = prove (tm_eq, - SIMP_TAC (rc_ss ssl) []) + val eq_thm = prove (tm_eq, rc_tac rc_arg) val thm = CONV_RULE (RAND_CONV (LHS_CONV (K eq_thm))) thm in @@ -693,7 +810,7 @@ fun PMATCH_REMOVE_FUN_AUX ssl col t = let end val pre_tm = fst (dest_imp (concl thm0)) - val pre_thm = prove (pre_tm, SIMP_TAC (rc_ss ssl) []) + val pre_thm = prove (pre_tm, rc_tac rc_arg) val thm1 = MP thm0 pre_thm in @@ -728,7 +845,18 @@ end handle HOL_ERR _ => raise UNCHANGED (* Combine auxiliary funs *) (*------------------------*) -fun PMATCH_SIMP_COLS_CONV_GEN ssl t = let +(* +val t = `` +PMATCH (SOME y,x,l) + [PMATCH_ROW (\x. (SOME 0,x,[])) (\x. T) (\x. x); + PMATCH_ROW (\z. z) (\z. F) (\z. (FST (SND z))); + PMATCH_ROW (\x. (SOME 3,x)) (\x. T) (\x. (FST x)); + PMATCH_ROW (\(z,y). (y,z,[2])) (\(z, y). IS_SOME y) (\(z, y). y) + ]`` +val rc_arg = [] +*) + +fun PMATCH_SIMP_COLS_CONV_GENCALL rc_arg t = let val cols = dest_PMATCH_COLS t (* val (col_v, col) = el 1 cols @@ -756,9 +884,9 @@ fun PMATCH_SIMP_COLS_CONV_GEN ssl t = let end handle HOL_ERR _ => false fun process_col i col = if (elim_col_ok col) then - SOME (PMATCH_REMOVE_COL_AUX ssl i t) + SOME (PMATCH_REMOVE_COL_AUX rc_arg i t) else if (simp_col_ok col) then - SOME (PMATCH_REMOVE_FUN_AUX ssl i t) + SOME (PMATCH_REMOVE_FUN_AUX rc_arg i t) else NONE val thm_opt = first_opt process_col cols @@ -767,6 +895,7 @@ in | SOME thm => thm end +fun PMATCH_SIMP_COLS_CONV_GEN ssl = PMATCH_SIMP_COLS_CONV_GENCALL (ssl, NONE) val PMATCH_SIMP_COLS_CONV = PMATCH_SIMP_COLS_CONV_GEN [] @@ -779,6 +908,17 @@ val PMATCH_SIMP_COLS_CONV = PMATCH_SIMP_COLS_CONV_GEN [] explicit pairs, while others are not. The following tries to expand columns into explicit ones. *) +(* +val t = `` +PMATCH (SOME y,x,l) + [PMATCH_ROW (\x. (SOME 0,x,[])) (\x. T) (\x. x); + PMATCH_ROW (\z. z) (\z. F) (\z. (FST (SND z))); + PMATCH_ROW (\x. (SOME 3,x)) (\x. T) (\x. (FST x)); + PMATCH_ROW (\(z,y). (y,z,[2])) (\(z, y). IS_SOME y) (\(z, y). y) + ]`` +*) + + fun PMATCH_EXPAND_COLS_CONV t = let val (v, rows) = dest_PMATCH t @@ -812,7 +952,7 @@ fun PMATCH_EXPAND_COLS_CONV t = let end fun PMATCH_ROW_EXPAND_COLS row = let - val (vars_tm, pt, rh) = dest_PMATCH_ROW row + val (vars_tm, pt, gt, rh) = dest_PMATCH_ROW_ABS row val vars = pairSyntax.strip_pair vars_tm val pts = pairSyntax.strip_pair pt @@ -823,19 +963,20 @@ fun PMATCH_EXPAND_COLS_CONV t = let val _ = if (List.exists (aconv l) vars) then () else failwith "nothing to do" - val avoids = vars @ free_vars pt @ free_vars rh + val avoids = vars @ free_vars pt @ free_vars gt @ free_vars rh val new_vars = split_var avoids cols l val sub = [l |-> pairSyntax.list_mk_pair new_vars] val pt' = Term.subst sub pt + val gt' = Term.subst sub gt val rh' = Term.subst sub rh - val vars_tm' = Term.subst sub vars_tm - val new_f = pairSyntax.mk_pabs(vars_tm', pairSyntax.mk_pair (pt', rh')) + val vars' = pairSyntax.strip_pair (Term.subst sub vars_tm) - val eq_tm = mk_eq(rand row, new_f) - val eq_thm = prove (eq_tm, SIMP_TAC (rc_ss []) []) + val row' = mk_PMATCH_ROW_PABS vars' (pt', gt', rh') - val thm = RATOR_CONV (RAND_CONV (K eq_thm)) (mk_comb (row, v)) + val eq_tm = mk_eq(row, row') + val eq_thm = prove (eq_tm, rc_tac ([], NONE)) + val thm = AP_THM eq_thm v in thm end handle HOL_ERR _ => REFL (mk_comb (row, v)) @@ -878,20 +1019,74 @@ end handle HOL_ERR _ => raise UNCHANGED (***********************************************) (* PMATCH_SIMP_CONV *) (***********************************************) -fun PMATCH_SIMP_CONV_GEN rc = REPEATC (FIRST_CONV [ + +(* +val t = `` +PMATCH (SOME y,x,l) + [PMATCH_ROW (\x. (SOME 0,x,[])) (\y. T) (\x. x); + PMATCH_ROW (\z. z) (\z. F) (\z. (FST (SND z))); + PMATCH_ROW (\x. (SOME 3,x)) (\x. T) (\x. (FST x)); + PMATCH_ROW (\(z,y). (y,z,[2])) (\(z, y). IS_SOME y) (\(z, y). y) + ]`` +*) + +fun PMATCH_SIMP_CONV_GENCALL rc_arg = REPEATC (FIRST_CONV [ CHANGED_CONV (PMATCH_CLEANUP_PVARS_CONV), - CHANGED_CONV (PMATCH_CLEANUP_CONV_GEN rc), - CHANGED_CONV (PMATCH_REMOVE_ARB_CONV_GEN rc), - CHANGED_CONV (PMATCH_SIMP_COLS_CONV_GEN rc)]) + CHANGED_CONV (PMATCH_CLEANUP_CONV_GENCALL rc_arg), + CHANGED_CONV (PMATCH_REMOVE_ARB_CONV_GENCALL rc_arg), + CHANGED_CONV (PMATCH_SIMP_COLS_CONV_GENCALL rc_arg), + CHANGED_CONV (PMATCH_EXPAND_COLS_CONV), + CHANGED_CONV PMATCH_FORCE_SAME_VARS_CONV +]) + +fun PMATCH_SIMP_CONV_GEN ssl = PMATCH_SIMP_CONV_GENCALL (ssl, NONE) val PMATCH_SIMP_CONV = PMATCH_SIMP_CONV_GEN [] +fun PMATCH_SIMP_convdata_conv ssl callback back = + PMATCH_SIMP_CONV_GENCALL (ssl, SOME (callback back)) + + +fun PMATCH_SIMP_GEN_ss ssl = simpLib.conv_ss + { name = "PMATCH_SIMP_CONV", + key = SOME ([], ``(PMATCH (v:'a) rows):'b``), + trace = 1, + conv = PMATCH_SIMP_convdata_conv ssl + } + +val PMATCH_SIMP_ss = PMATCH_SIMP_GEN_ss [] + + (***********************************************) (* Case_splits *) (* This is work in progress *) (***********************************************) +(* +val t = `` +PMATCH (a,x,xs) + [PMATCH_ROW (\x. (NONE,x,[])) (\x. T) (\x. x); + PMATCH_ROW (\x. (NONE,x,[2])) (\x. T) (\x. x); + PMATCH_ROW (\ (x,v18). (NONE,x,[v18])) (\ (x, v18). T) (\ (x, v18). 3); + PMATCH_ROW (\ (x,v12,v16,v17). (NONE,x,v12::v16::v17)) + (\ (x,v12,v16,v17). T) + (\ (x,v12,v16,v17). 3); + PMATCH_ROW (\ (y,x,z,zs). (SOME y,x,[z])) + (\ (y,x,z,zs). T) + (\ (y,x,z,zs). x+5+z); + PMATCH_ROW (\ (y,v23,v24). (SOME y,0,v23::v24)) + (\ (y,v23,v24). T) + (\ (y,v23,v24). v23+y); + PMATCH_ROW (\ (y,z,v23). (SOME y,SUC z,[v23])) + (\ (y,z,v23). y > 5) + (\ (y,z,v23). 3); + PMATCH_ROW (\ (y,z). (SOME y,SUC z,[1; 2])) + (\ (y,z). T) + (\ (y,z). y + z) + ]`` +*) + fun STRIP_ABS_CONV conv t = if (is_abs t) then ABS_CONV (STRIP_ABS_CONV conv) t else conv t @@ -926,23 +1121,18 @@ in thm2 end -fun PMATCH_CASE_SPLIT_CONV_GEN ssl col t = let + +fun PMATCH_CASE_SPLIT_CONV_GENCALL rc_arg col_no t = let val thm0 = QCHANGED_CONV ( - PMATCH_SIMP_CONV_GEN ssl) t handle HOL_ERR _ => REFL t + PMATCH_SIMP_CONV_GENCALL rc_arg) t handle HOL_ERR _ => REFL t val t' = rhs (concl thm0) - val (v, _) = dest_PMATCH t' - val vs = pairSyntax.strip_pair v - val ty = type_of (el (col+1) vs) - val expand_thm = let - val case_def_thm = TypeBase.case_def_of ty - val nchotomy_thm = TypeBase.nchotomy_of ty - in - constrFamiliesLib.gen_case_expand_thm case_def_thm nchotomy_thm - end + val (v, col) = el (col_no+1) (dest_PMATCH_COLS t') + + val expand_thm = get_case_expand_thm (v, col) - val thm1 = QCHANGED_CONV (PMATCH_CASE_SPLIT_AUX col expand_thm (PMATCH_SIMP_CONV_GEN ssl)) t' handle HOL_ERR _ => (REFL t') + val thm1 = QCHANGED_CONV (PMATCH_CASE_SPLIT_AUX col_no expand_thm (PMATCH_SIMP_CONV_GENCALL rc_arg)) t' handle HOL_ERR _ => (REFL t') in TRANS thm0 thm1 end diff --git a/examples/deep_matches/deepMatchesScript.sml b/examples/deep_matches/deepMatchesScript.sml index c876f148aa..7b6c669410 100644 --- a/examples/deep_matches/deepMatchesScript.sml +++ b/examples/deep_matches/deepMatchesScript.sml @@ -1,5 +1,6 @@ open HolKernel Parse boolLib bossLib; open quantHeuristicsLib +open optionTheory val _ = new_theory "deepMatches" @@ -8,15 +9,15 @@ val _ = new_theory "deepMatches" (***************************************************) (* rows of a pattern match are pairs of a pattern to match - against p and a result r. The result and pattern are linked - with free variables [v] bound in both. So it looks like - (\v. (p v, r v)) *) -val PMATCH_ROW_def = Define `PMATCH_ROW row i = - (if ?x. FST (row x) = i then - SOME (SND (row (@x. FST (row x) = i))) - else NONE)` - -(* We defined semantics or single rows. Let's extend + against pat, a guard and a result value. *) +val PMATCH_ROW_COND_def = Define `PMATCH_ROW_COND pat guard i x = + (pat x = i) /\ (guard x)` + +val PMATCH_ROW_def = Define `PMATCH_ROW pat guard res i = + (OPTION_MAP res (some x. PMATCH_ROW_COND pat guard i x))` + + +(* We defined semantics of single rows. Let's extend it to multiple ones, i.e. full pattern matches now *) val PMATCH_INCOMPLETE_def = Define `PMATCH_INCOMPLETE = ARB` val PMATCH_def = Define ` @@ -38,57 +39,144 @@ val PMATCH_REDUNDANT_ROWS_def = Define ` PMATCH_REDUNDANT_ROWS rs = {i | (PMATCH_ROW_REDUNDANT rs i)}` + +(***************************************************) +(* Congruences *) +(***************************************************) + +val some_eq_SOME = store_thm ("some_eq_SOME", + ``!P x. ((some x. P x) = SOME x) ==> (P x)``, +SIMP_TAC std_ss [some_def] THEN +REPEAT STRIP_TAC THEN +SELECT_ELIM_TAC THEN +PROVE_TAC[]) + +val some_eq_NONE = store_thm ("some_eq_NONE", + ``!P. ((some x. P x) = NONE) <=> (!x. ~(P x))``, +SIMP_TAC std_ss [some_def]) + +val some_IS_SOME = store_thm ("some_IS_SOME", + ``!P. (IS_SOME (some x. P x)) <=> (?x. P x)``, +SIMP_TAC (std_ss++boolSimps.LIFT_COND_ss) [some_def]) + +val some_IS_SOME_EXISTS = store_thm ("some_IS_SOME_EXISTS", + ``!P. (IS_SOME (some x. P x)) <=> (?x. P x /\ ((some x. P x) = SOME x))``, +GEN_TAC THEN EQ_TAC THEN REPEAT STRIP_TAC THEN ( + ASM_SIMP_TAC std_ss [] +) THEN +Cases_on `some x. P x` THEN FULL_SIMP_TAC std_ss [] THEN +MATCH_MP_TAC some_eq_SOME THEN +ASM_REWRITE_TAC[]) + + +val OPTION_MAP_EQ_OPTION_MAP = store_thm ("OPTION_MAP_EQ_OPTION_MAP", +``(OPTION_MAP f x = OPTION_MAP f' x') = + (((x = NONE) /\ (x' = NONE)) \/ + (?y y'. (x = SOME y) /\ (x' = SOME y') /\ (f y = f' y')))``, + +Cases_on `x` THEN Cases_on `x'` THEN ( + SIMP_TAC std_ss [] +)) + +val PMATCH_ROW_CONG = store_thm ("PMATCH_ROW_CONG", +``!p p' g g' r r' v v'. + (p = p') /\ (v = v') /\ + (!x. (v = (p x)) ==> (g x = g' x)) /\ + (!x. ((v = (p x)) /\ (g x)) ==> + (r x = r' x)) ==> + (PMATCH_ROW p g r v = PMATCH_ROW p' g' r' v')``, + +REPEAT STRIP_TAC THEN +ASM_SIMP_TAC (std_ss++boolSimps.CONJ_ss) [PMATCH_ROW_def, + PMATCH_ROW_COND_def] THEN +Cases_on `some x. (p' x = v') /\ (g' x)` THEN ( + ASM_SIMP_TAC std_ss [] +) THEN +POP_ASSUM (fn thm => MP_TAC (HO_MATCH_MP (SPEC_ALL some_eq_SOME) thm)) THEN +ASM_SIMP_TAC std_ss []) + +val PMATCH_CONG = store_thm ("PMATCH_CONG", +``!v v' rows rows'. ((v = v') /\ (r v' = r' v') /\ + (PMATCH v' rows = PMATCH v' rows')) ==> + (PMATCH v (r :: rows) = PMATCH v' (r' :: rows'))``, +SIMP_TAC std_ss [PMATCH_def]) + +val _ = DefnBase.export_cong "PMATCH_ROW_CONG"; +val _ = DefnBase.export_cong "PMATCH_CONG"; + + (***************************************************) (* Rewrites *) (***************************************************) val PMATCH_ROW_EQ_AUX = store_thm ("PMATCH_ROW_EQ_AUX", - ``((!i. (?x. (g x = i)) = (?x'. (g' x' = i))) /\ - (!x x'. (g x = g' x') ==> (f x = f' x'))) ==> - (PMATCH_ROW (\x:'a. (g x, f x)) = - PMATCH_ROW (\x':'b. (g' x', f' x')))``, + ``((!i. (?x. PMATCH_ROW_COND p g i x) = + (?x'. PMATCH_ROW_COND p' g' i x')) /\ + (!x x'. ((p x = p' x') /\ g x /\ g' x') ==> (r x = r' x'))) ==> + (PMATCH_ROW p g r = PMATCH_ROW p' g' r')``, REPEAT STRIP_TAC THEN -SIMP_TAC std_ss [PMATCH_ROW_def, FUN_EQ_THM] THEN +SIMP_TAC std_ss [FUN_EQ_THM, PMATCH_ROW_def, + OPTION_MAP_EQ_OPTION_MAP] THEN CONV_TAC (RENAME_VARS_CONV ["i"]) THEN GEN_TAC THEN Q.PAT_ASSUM `!i. (_ = _)` (fn thm => ASSUME_TAC (Q.SPEC `i` thm)) THEN -Cases_on `?x'. g' x' = i` THEN ( - ASM_REWRITE_TAC[] +Tactical.REVERSE (Cases_on `?x. PMATCH_ROW_COND p g i x`) THEN ( + FULL_SIMP_TAC std_ss [] ) THEN -FULL_SIMP_TAC std_ss [] THEN -SELECT_ELIM_TAC THEN -REPEAT STRIP_TAC THEN1 PROVE_TAC[] THEN -SELECT_ELIM_TAC THEN -REPEAT STRIP_TAC THEN1 PROVE_TAC[] THEN -PROVE_TAC[]) +DISJ2_TAC THEN +`IS_SOME (some x. PMATCH_ROW_COND p g i x) /\ + IS_SOME (some x. PMATCH_ROW_COND p' g' i x)` by ALL_TAC THEN1 ( + ASM_SIMP_TAC std_ss [some_IS_SOME] THEN + PROVE_TAC[] +) THEN +FULL_SIMP_TAC std_ss [some_IS_SOME_EXISTS] THEN +FULL_SIMP_TAC std_ss [PMATCH_ROW_COND_def]) val PMATCH_ROW_EQ_NONE = store_thm ("PMATCH_ROW_EQ_NONE", - ``(PMATCH_ROW (\x. (g x, f x)) v = NONE) <=> - (!x. ~(g x = v))``, -SIMP_TAC std_ss [PMATCH_ROW_def]); + ``(PMATCH_ROW p g r i = NONE) <=> + (!x. ~(PMATCH_ROW_COND p g i x))``, +SIMP_TAC std_ss [PMATCH_ROW_def, some_eq_NONE]); + + +val PMATCH_ROW_EQ_SOME = store_thm ("PMATCH_ROW_EQ_SOME", + ``(PMATCH_ROW p g r i = SOME y) ==> + (?x. (PMATCH_ROW_COND p g i x) /\ (y = r x))``, +SIMP_TAC std_ss [PMATCH_ROW_def] THEN +REPEAT STRIP_TAC THEN +Q.EXISTS_TAC `z` THEN +IMP_RES_TAC some_eq_SOME THEN +ASM_SIMP_TAC std_ss []); + val PMATCH_EVAL = store_thm ("PMATCH_EVAL", ``(PMATCH v [] = PMATCH_INCOMPLETE) /\ - (PMATCH v ((PMATCH_ROW (\x. (g x, f x))) :: rs) = - if (?x. (g x = v)) then - (f (@x. g x = v)) else PMATCH v rs)``, + (PMATCH v ((PMATCH_ROW p g r) :: rs) = + if (?x. (PMATCH_ROW_COND p g v x)) then + (r (@x. PMATCH_ROW_COND p g v x)) else PMATCH v rs)``, SIMP_TAC std_ss [PMATCH_def] THEN -Cases_on `PMATCH_ROW (\x. (g x,f x)) v` THEN ( - FULL_SIMP_TAC std_ss [PMATCH_ROW_def] THEN +Cases_on `PMATCH_ROW p g r v` THENL [ + FULL_SIMP_TAC std_ss [PMATCH_ROW_def, some_eq_NONE], + + FULL_SIMP_TAC std_ss [PMATCH_ROW_def, some_def] THEN METIS_TAC[] -)) +]) val PMATCH_EVAL_MATCH = store_thm ("PMATCH_EVAL_MATCH", - ``~(PMATCH_ROW (\x. (g x, f x)) v = NONE) ==> - (PMATCH v ((PMATCH_ROW (\x. (g x, f x))) :: rs) = - (f (@x. g x = v)))``, + ``~(PMATCH_ROW p g r v = NONE) ==> + (PMATCH v ((PMATCH_ROW p g r) :: rs) = + (r (@x.PMATCH_ROW_COND p g v x)))``, -SIMP_TAC std_ss [PMATCH_def] THEN -Cases_on `PMATCH_ROW (\x. (g x,f x)) v` THEN ( - FULL_SIMP_TAC std_ss [PMATCH_ROW_def] THEN - METIS_TAC[] -)) +SIMP_TAC std_ss [PMATCH_EVAL, + PMATCH_ROW_EQ_NONE]) + +val PMATCH_EVAL_MATCH = store_thm ("PMATCH_EVAL_MATCH", + ``~(PMATCH_ROW p g r v = NONE) ==> + (PMATCH v ((PMATCH_ROW p g r) :: rs) = + (r (@x.PMATCH_ROW_COND p g v x)))``, + +SIMP_TAC std_ss [PMATCH_EVAL, + PMATCH_ROW_EQ_NONE]) (***************************************************) @@ -212,24 +300,22 @@ ASM_REWRITE_TAC[]) val PMATCH_REMOVE_ARB = store_thm ("PMATCH_REMOVE_ARB", -``(PMATCH v (SNOC (PMATCH_ROW (\x. (f x, ARB))) rows) = +``(!x. r x = ARB) ==> + (PMATCH v (SNOC (PMATCH_ROW p g r) rows) = PMATCH v rows)``, Induct_on `rows` THENL [ - SIMP_TAC list_ss [PMATCH_def, PMATCH_ROW_def] THEN - Cases_on `?x. f x = v` THEN ( - ASM_SIMP_TAC std_ss [PMATCH_INCOMPLETE_def] - ), - + SIMP_TAC list_ss [PMATCH_EVAL, PMATCH_INCOMPLETE_def], ASM_SIMP_TAC list_ss [PMATCH_def] ]) (* ARB rows can be removed, since a match failiure is the same as ARB *) val PMATCH_REMOVE_ARB_NO_OVERLAP = store_thm ("PMATCH_REMOVE_ARB_NO_OVERLAP", -``!v ff rows1 rows2. - (!x. (v = ff x) ==> EVERY (\r. (r (ff x) = NONE)) rows2) ==> - (PMATCH v (rows1 ++ ((PMATCH_ROW (\x. (ff x, ARB))) :: rows2)) = +``!v p g r rows1 rows2. + ((!x. (r x = ARB)) /\ + (!x. ((v = p x) /\ (g x)) ==> EVERY (\row. (row (p x) = NONE)) rows2)) ==> + (PMATCH v (rows1 ++ ((PMATCH_ROW p g r) :: rows2)) = PMATCH v (rows1 ++ rows2))``, REPEAT STRIP_TAC THEN @@ -237,14 +323,14 @@ Tactical.REVERSE (Induct_on `rows1`) THEN ( ASM_SIMP_TAC list_ss [PMATCH_def] ) THEN -ASM_SIMP_TAC list_ss [PMATCH_def, PMATCH_ROW_def] THEN -Cases_on `?x. ff x = v` THEN ( - ASM_SIMP_TAC std_ss [PMATCH_INCOMPLETE_def] +Cases_on `PMATCH_ROW p g r v` THEN ( + ASM_SIMP_TAC std_ss [] ) THEN -FULL_SIMP_TAC std_ss [] THEN -Q.PAT_ASSUM `_ = v` (ASSUME_TAC o GSYM) THEN +IMP_RES_TAC PMATCH_ROW_EQ_SOME THEN +Q.PAT_ASSUM `!x. P x ==> Q x` (MP_TAC o Q.SPEC `x'`) THEN +FULL_SIMP_TAC std_ss [PMATCH_ROW_COND_def] THEN Induct_on `rows2` THEN ( - FULL_SIMP_TAC list_ss [PMATCH_def, PMATCH_INCOMPLETE_def] + ASM_SIMP_TAC list_ss [PMATCH_def, PMATCH_INCOMPLETE_def] )) @@ -252,16 +338,16 @@ Induct_on `rows2` THEN ( (* Add an injective function to the pattern and the value. This can be used to eliminate constructors. *) val PMATCH_ROW_REMOVE_FUN = store_thm ("PMATCH_ROW_REMOVE_FUN", -``!ff v f g. (!x y. (ff x = ff y) ==> (x = y)) ==> +``!ff v p g r. (!x y. (ff x = ff y) ==> (x = y)) ==> - (PMATCH_ROW (\x. (ff (f x), g x)) (ff v) = - PMATCH_ROW (\x. (f x, g x)) v)``, + (PMATCH_ROW (\x. (ff (p x))) g r (ff v) = + PMATCH_ROW (\x. (p x)) g r v)``, REPEAT STRIP_TAC THEN `!x y. (ff x = ff y) = (x = y)` by PROVE_TAC[] THEN -ASM_SIMP_TAC std_ss [PMATCH_ROW_def]) - +ASM_SIMP_TAC std_ss [PMATCH_ROW_def, PMATCH_ROW_COND_def]) +(* val PMATCH_ROW_REMOVE_FUN_EXT = store_thm ("PMATCH_ROW_REMOVE_FUN_EXT", ``!ff v f f' g g'. @@ -284,7 +370,7 @@ ASM_REWRITE_TAC [] THEN REPEAT STRIP_TAC THEN PROVE_TAC[]) - +*) (* The following lemma looks rather complicated. It is intended to work together with PMATCH_ROW_REMOVE_FUN to @@ -293,15 +379,15 @@ PROVE_TAC[]) as an example consider val t = ``PMATCH (SOME x, y) [ - PMATCH_ROW (\ x. ((SOME x, 0), SOME (x + y))); - PMATCH_ROW (\ (x', y). ((x', y), x')) + PMATCH_ROW (\x. (SOME x, 0)) (K T) (\x. (SOME (x + y))); + PMATCH_ROW (\(x', y). (x', y)) (K T) (\(x', y). x') ]`` We want to simplify this to - val t' = ``PMATCH (x, y) [ - PMATCH_ROW (\ x. ((x, 0), SOME (x + y))); - PMATCH_ROW (\ (x'', y). ((x'', y), SOME x'')) + val t = ``PMATCH (x, y) [ + PMATCH_ROW (\x. (x, 0)) (K T) (\x. (SOME (x + y))); + PMATCH_ROW (\(x'', y). (x'', y)) (K T) (\(x'', y). SOME x'') ]`` This is done via PMATCH_ROWS_SIMP and PMATCH_ROWS_SIMP_SOUNDNESS. @@ -312,45 +398,48 @@ PROVE_TAC[]) v := (x, y) ff (x, y) := (SOME x, y) - f x := (x, 0) - g x := SOME (x + y) + p x := (x, 0) + r x := SOME (x + y) For the second row, PMATCH_ROW_REMOVE_FUN is used with v := (SOME x, y) v' := (x, y) - f (x', y) := (x', y) - g (x', y) := x' - f' (x'', y) = (x'', y) - g' (x'', y) := (SOME x'', y) + p (x', y) := (x', y) + r (x', y) := x' + p' (x'', y) = (x'', y) + f (x'', y) := (SOME x'', y) *) val PMATCH_ROW_REMOVE_FUN_VAR = store_thm ("PMATCH_ROW_REMOVE_FUN_VAR", -``!v v' f g f' g'. - ((!x'. (f' x' = v') = (f (g' x') = v)) /\ - ((!x. (f x = v) ==> ?x'. g' x' = x)) /\ - ((!x y. (f x = f y) ==> (x = y)))) ==> - (PMATCH_ROW (\x. (f x, g x)) v = - PMATCH_ROW (\x'. (f' x'), g (g' x')) v')``, +``!v v' f p g r p' . + ((!x'. (p' x' = v') = (p (f x') = v)) /\ + ((!x. (p x = v) ==> ?x'. f x' = x)) /\ + ((!x y. (p x = p y) ==> (x = y)))) ==> + (PMATCH_ROW p g r v = + PMATCH_ROW p' (\x. g (f x)) (\x. r (f x)) v')``, REPEAT STRIP_TAC THEN ASM_SIMP_TAC std_ss [PMATCH_ROW_def] THEN -`(?x'. f (g' x') = v) = (?x. f x = v)` by ALL_TAC THEN1 ( - METIS_TAC[] +`IS_SOME (some x. PMATCH_ROW_COND p' (\x. g (f x)) v' x) = + IS_SOME (some x. PMATCH_ROW_COND p g v x)` by ALL_TAC THEN1 ( + ASM_SIMP_TAC std_ss [some_IS_SOME, PMATCH_ROW_COND_def] THEN + EQ_TAC THEN1 PROVE_TAC[] THEN + REPEAT STRIP_TAC THEN + `?x'. f x' = x` by PROVE_TAC[] THEN + Q.EXISTS_TAC `x'` THEN + ASM_REWRITE_TAC[] ) THEN -Cases_on `?x. f x = v` THEN ( - ASM_SIMP_TAC std_ss [] +Tactical.REVERSE (Cases_on `IS_SOME (some x. PMATCH_ROW_COND p g v x)`) THEN ( + FULL_SIMP_TAC std_ss [] ) THEN - -SELECT_ELIM_TAC THEN -ASM_SIMP_TAC std_ss [] THEN -SELECT_ELIM_TAC THEN -REPEAT STRIP_TAC THEN ( - METIS_TAC[] -)); +FULL_SIMP_TAC std_ss [some_IS_SOME_EXISTS] THEN +FULL_SIMP_TAC std_ss [PMATCH_ROW_COND_def] THEN +METIS_TAC[]); +(* (***************************************************) (* THEOREMS ABOUT FLATTENING *) @@ -400,6 +489,6 @@ FULL_SIMP_TAC std_ss [] THEN ASM_SIMP_TAC std_ss [] THEN METIS_TAC[]) - +*) val _ = export_theory() diff --git a/examples/deep_matches/deepMatchesSyntax.sig b/examples/deep_matches/deepMatchesSyntax.sig index 8642d89c37..f47e85f64d 100644 --- a/examples/deep_matches/deepMatchesSyntax.sig +++ b/examples/deep_matches/deepMatchesSyntax.sig @@ -10,34 +10,54 @@ sig free vars of a thm *) val FRESH_TY_VARS_RULE : rule - (******************) (* PMATCH_ROW *) (******************) - (* dest_PMATCH_ROW ``PMATCH_ROW (\(x, y). (p x y, rh x y)`` - returns (``(x,y)``, ``p x y``, ``rh x y``). *) + (* dest_PMATCH_ROW ``PMATCH_ROW p g r`` + returns (``p``, ``g``, ``r``). *) val dest_PMATCH_ROW : term -> (term * term * term) val is_PMATCH_ROW : term -> bool - (* [mk_PMATCH_ROW vars p rh] constructs the term - ``PMATCH_ROW (\vars. (p vars, rh vars))``. *) - val mk_PMATCH_ROW : term list -> term -> term -> term + (* [mk_PMATCH_ROW (p, g, rh)] constructs the term + ``PMATCH_ROW p g rh``. *) + val mk_PMATCH_ROW : term * term * term -> term + + (* [mk_PMATCH_ROW vars (p, g, rh)] constructs the term + ``PMATCH_ROW (\vars. p) (\vars. g) (\vars. rh)``. *) + val mk_PMATCH_ROW_PABS : term list -> term * term * term -> term + + (* dest_PMATCH_ROW_ABS ``PMATCH_ROW (\(x,y). p x y) + (\(x,y). g x y) (\(x,y). r x y)`` + returns (``(x,y)``, ``p x y``, ``g x y``, ``r x y``). + It fails, if not all paired abstractions use the same + variable names. *) + val dest_PMATCH_ROW_ABS : term -> (term * term * term * term) + + (* calls dest_PMATCH_ROW_ABS and renames the abstracted vars + consistently to be different from the list of given vars. *) + val dest_PMATCH_ROW_ABS_VARIANT : term list -> term -> (term * term * term * term) - (* [PMATCH_ROW_PABS_ELIM_CONV ``PMATCH_ROW (\(v1, ... vn). ( p (v1, - ... vn), rh (v1, ... vn))``] removes the pair [(v1, ... vn)] and - replaces the paired lambda abstraction with a normal lambda + + (* [PMATCH_ROW_PABS_ELIM_CONV t] + replaces paired lambda abstraction in t with a normal lambda abstraction. It returns a theorem stating the equivalence as - well as the original varstruct removed. *) + well as the original varstruct of p removed. *) val PMATCH_ROW_PABS_ELIM_CONV : term -> (term * thm) (* [PMATCH_ROW_PABS_INTRO_CONV vars t] reintroduces paired abstraction again after being removed by e.g. [PMATCH_ROW_PABS_ELIM_CONV]. It uses [vars] for the newly introduced varstruct. *) - val PMATCH_ROW_PABS_INTRO_CONV : term -> term -> thm + val PMATCH_ROW_PABS_INTRO_CONV : term -> conv + (* [PMATCH_ROW_FORCE_SAME_VARS_CONV] renames the + abstracted variables for the pattern, guard and right hand side + of a row to match with each other. This invariant + is required by many operations working on PMATCH_ROW *) + val PMATCH_ROW_FORCE_SAME_VARS_CONV : conv + val PMATCH_FORCE_SAME_VARS_CONV : conv (******************) (* PMATCH *) @@ -68,4 +88,12 @@ sig *) + (******************) + (* Parser *) + (******************) + + (* Writing a parser for CASES is tricky. The existing + one can be used however. If the trace "parse deep cases" + is set to true, standard case-expressions are parsed + to deep-matches, otherwise the default state-expressions. *) end diff --git a/examples/deep_matches/deepMatchesSyntax.sml b/examples/deep_matches/deepMatchesSyntax.sml index e4dba29c11..d6843885b1 100644 --- a/examples/deep_matches/deepMatchesSyntax.sml +++ b/examples/deep_matches/deepMatchesSyntax.sml @@ -4,28 +4,53 @@ struct open deepMatchesTheory bossLib + +(* Stolen from pairTools. TODO: + add it to interface there. *) +fun variant_of_term vs t = +let + val check_vars = free_vars t; + val (_,sub) = + foldl (fn (v, (vs,sub)) => + let + val v' = variant vs v; + val vs' = v'::vs; + val sub' = if (aconv v v') then sub else + (v |-> v')::sub; + in + (vs',sub') + end) (vs,[]) check_vars; + val t' = subst sub t +in + (t', sub) +end; + + (***********************************************) (* Terms *) (***********************************************) +val ty_var_subst = [alpha |-> gen_tyvar (), + beta |-> gen_tyvar (), + gamma |-> gen_tyvar (), + delta |-> gen_tyvar (), + ``:'e`` |-> gen_tyvar (), + ``:'f`` |-> gen_tyvar (), + ``:'g`` |-> gen_tyvar (), + ``:'h`` |-> gen_tyvar (), + ``:'i`` |-> gen_tyvar (), + ``:'j`` |-> gen_tyvar () + ] + val PMATCH_ROW_tm = ``PMATCH_ROW`` -val PMATCH_tm = ``PMATCH`` +val PMATCH_ROW_gtm = inst ty_var_subst PMATCH_ROW_tm -(***********************************************) -(* Matching support *) -(***********************************************) +val PMATCH_tm = ``PMATCH`` +val PMATCH_gtm = inst ty_var_subst PMATCH_tm -val thm = PMATCH_REMOVE_ARB_NO_OVERLAP +fun FRESH_TY_VARS_RULE thm = + INST_TYPE ty_var_subst thm -fun FRESH_TY_VARS_RULE thm = let - val (vars0, _) = strip_forall (concl thm) - val vars1 = free_vars (concl thm) - val vars = vars0 @ vars1 - val tys = type_varsl (map type_of vars) - val subst = map (fn ty => (ty |-> gen_tyvar ())) tys -in - INST_TYPE subst thm -end (***********************************************) (* PMATCH_ROW *) @@ -33,44 +58,97 @@ end fun dest_PMATCH_ROW row = let val (f, args) = strip_comb row - val _ = if (same_const f PMATCH_ROW_tm) andalso (List.length args = 1) then () else failwith "dest_PMATCH_ROW" - - val arg = hd args - - val (vars_tm, prh) = pairSyntax.dest_pabs arg - val (p, rh) = pairSyntax.dest_pair prh + val _ = if (same_const f PMATCH_ROW_tm) andalso (List.length args = 3) then () else failwith "dest_PMATCH_ROW" in - (vars_tm, p, rh) + (el 1 args, el 2 args, el 3 args) end fun is_PMATCH_ROW t = can dest_PMATCH_ROW t -fun mk_PMATCH_ROW vars p rh = let - val prh = pairSyntax.mk_pair(p, rh) - val pabs = case vars of - [] => mk_abs (genvar ``:unit``, prh) - | [v] => mk_abs (v, prh) - | _ => pairSyntax.mk_pabs (pairSyntax.list_mk_pair vars, prh) +fun mk_PMATCH_ROW (p_t, g_t, r_t) = + list_mk_icomb (PMATCH_ROW_gtm, [p_t, g_t, r_t]) + +fun mk_PMATCH_ROW_PABS vars (p_t, g_t, r_t) = let + val mk_pabs = case vars of + [] => let + val uv = variant (free_varsl [p_t, g_t, r_t]) ``uv:unit`` + in + fn t => mk_abs (uv, t) + end + | [v] => (fn t => mk_abs (v, t)) + | _ => (fn t => pairSyntax.mk_pabs (pairSyntax.list_mk_pair vars, t)) in - mk_icomb (PMATCH_ROW_tm, pabs) + mk_PMATCH_ROW (mk_pabs p_t, mk_pabs g_t, mk_pabs r_t) end + +fun dest_PMATCH_ROW_ABS row = let + val (p_t, g_t, r_t) = dest_PMATCH_ROW row + val (p_vars, p_body) = pairSyntax.dest_pabs p_t + val (g_vars, g_body) = pairSyntax.dest_pabs g_t + val (r_vars, r_body) = pairSyntax.dest_pabs r_t -fun PMATCH_ROW_PABS_ELIM_CONV r = let - val (vars, _, _) = dest_PMATCH_ROW r - val thm = (RAND_CONV pairTools.PABS_ELIM_CONV) r + val _ = if (aconv p_vars g_vars) andalso (aconv g_vars r_vars) then + () else failwith "dest_PMATCH_ROW_ABS" +in + (p_vars, p_body, g_body, r_body) +end + + +fun dest_PMATCH_ROW_ABS_VARIANT vs row = let + val (p_vars, p_body, g_body, r_body) = dest_PMATCH_ROW_ABS row + val (p_vars', sub) = variant_of_term vs p_vars +in + (p_vars', subst sub p_body, subst sub g_body, subst sub r_body) +end + + +fun PMATCH_ROW_PABS_ELIM_CONV row = let + val (p, _, _) = dest_PMATCH_ROW row + val (vars, _) = pairSyntax.dest_pabs p + + val c = TRY_CONV pairTools.PABS_ELIM_CONV + val thm = ((RAND_CONV c) THENC + (RATOR_CONV (RAND_CONV c)) THENC + (RATOR_CONV (RATOR_CONV (RAND_CONV c)))) row + handle UNCHANGED => REFL row in (vars, thm) end -fun PMATCH_ROW_PABS_INTRO_CONV vars r = let - val _ = if (is_PMATCH_ROW r) then () else failwith "PMATCH_ROW_PABS_INTRO_CONV" - val thm = (RAND_CONV (pairTools.PABS_INTRO_CONV vars)) r + +fun PMATCH_ROW_PABS_INTRO_CONV vars row = let + val _ = if (is_PMATCH_ROW row) then () else failwith "PMATCH_ROW_PABS_INTRO_CONV" + + val (vars', _) = variant_of_term (free_vars row) vars + val c = pairTools.PABS_INTRO_CONV vars' + val thm = ((RAND_CONV c) THENC + (RATOR_CONV (RAND_CONV c)) THENC + (RATOR_CONV (RATOR_CONV (RAND_CONV c)))) row in thm end +fun PMATCH_ROW_FORCE_SAME_VARS_CONV row = let + val _ = if not (is_PMATCH_ROW row) then raise UNCHANGED else () + val _ = if can dest_PMATCH_ROW_ABS row then raise UNCHANGED else () + + val (vars, thm0) = PMATCH_ROW_PABS_ELIM_CONV row + val thm1 = PMATCH_ROW_PABS_INTRO_CONV vars (rhs (concl thm0)) +in + TRANS thm0 thm1 +end handle HOL_ERR _ => raise UNCHANGED +(* +val row = `` + PMATCH_ROW (\ (y,z). (SOME y,SUC z,[1; 2])) + (\ x. T) + (\ (y,z). y + z)`` + +val (vars, thm) = PMATCH_ROW_PABS_ELIM_CONV row +val thm2 = PMATCH_ROW_PABS_INTRO_CONV vars (rhs (concl thm)) +val row = rhs (concl thm2) +*) (***********************************************) (* PMATCH *) @@ -105,7 +183,7 @@ fun dest_PMATCH_COLS t = let val vs = pairSyntax.strip_pair v fun split_row r = let - val (vars_tm, pt, rh) = dest_PMATCH_ROW r + val (vars_tm, pt, gt, rh) = dest_PMATCH_ROW_ABS r val vars = pairSyntax.strip_pair vars_tm val pts = pairSyntax.strip_pair pt in @@ -124,9 +202,13 @@ fun dest_PMATCH_COLS t = let val cols = get_cols [] vs rows' in cols -end - +end handle Empty => failwith "dest_PMATCH_COLS" +fun PMATCH_FORCE_SAME_VARS_CONV t = let + val _ = if not (is_PMATCH t) then raise UNCHANGED else () +in + DEPTH_CONV PMATCH_ROW_FORCE_SAME_VARS_CONV t +end (***********************************************) (* Pretty Printing *) @@ -143,13 +225,17 @@ fun pmatch_printer GS backend sys (ppfns:term_pp_types.ppstream_funs) gravs d t val {add_string,add_break,ublock,add_newline,ustyle,...} = ppfns val (v,rows) = dest_PMATCH t; - val rows' = map dest_PMATCH_ROW rows + val rows' = map dest_PMATCH_ROW_ABS rows - fun pp_row (vars, pat, rh) = ( + fun pp_row (vars, pat, guard, rh) = ( term_pp_utils.record_bvars (pairSyntax.strip_pair vars) ( ublock PP.CONSISTENT 0 ( add_string "|" >> add_break (1, 0) >> sys (Top, Top, Top) (d - 1) pat >> + (if (aconv guard T) then nothing else ( + add_break (1, 0) >> add_string "when" >> add_break (1, 0) >> + sys (Top, Top, Top) (d - 1) guard + )) >> add_break (1, 0) >> add_string "=>" >> add_break (1, 0) >> sys (Top, Top, Top) (d - 1) rh )) @@ -159,9 +245,62 @@ fun pmatch_printer GS backend sys (ppfns:term_pp_types.ppstream_funs) gravs d t sys (Top, Top, Top) (d - 1) v >> add_break(1,0) >> add_string "OF")) >> add_break (1, 0) >> - smpp.pr_list pp_row (add_break (0, 0)) rows' + smpp.pr_list pp_row (add_break (1, 0)) rows' end handle HOL_ERR _ => raise term_pp_types.UserPP_Failed; val _ = add_user_printer ("PMATCH", ``PMATCH v l``, pmatch_printer); + +(***********************************************) +(* Parser *) +(***********************************************) + + +fun case_magic_to_deep_case t = let + val rows = strip_conj t + + val v = rator (lhs (hd rows)) + val (arg_tyL, res_ty) = strip_fun (type_of v) + + fun process_row row = let + val (l,r) = dest_eq row + val p = rand l + + val vars = free_vars_lr p + in + mk_PMATCH_ROW_PABS vars (p, T, r) + end + + val prows = map process_row rows + val i = genvar (hd arg_tyL) + val prows' = listSyntax.mk_list (prows, type_of (hd prows)) + val pmatch_t = mk_PMATCH i prows' +in + mk_abs (v, mk_abs (i, pmatch_t)) +end + + +val parse_case_as_pmatch = ref false +val _ = Feedback.register_btrace ("parse deep cases", parse_case_as_pmatch); + +val _ = + let fun lookup s = + case TypeBase.read s + of SOME tyi => SOME {constructors = TypeBasePure.constructors_of tyi, + case_const = TypeBasePure.case_const_of tyi} + | NONE => NONE + open GrammarSpecials + in + set_case_specials ((fn t => + if !parse_case_as_pmatch then + case_magic_to_deep_case t + else + #functional (Pmatch.mk_functional lookup t)), + + (fn s => + case lookup s of + NONE => [] + | SOME {constructors,...} => constructors)) + end + end From 8d315d0c67a88c69a958cfbf35266246131989cd Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 10 Dec 2014 16:34:13 +1100 Subject: [PATCH 046/718] Delete trailing whitespace in src/ This needs doing periodically, and is best done to a whole bunch of files at once. --- src/1/PmatchHeuristics.sig | 24 +- src/1/Tactical.sig | 4 +- src/1/Tactical.sml | 52 ++--- src/datatype/DatatypeSimps.sig | 10 +- src/datatype/DatatypeSimps.sml | 56 ++--- src/enumfset/enumTacs.sml | 20 +- src/enumfset/fmapalTacs.sml | 14 +- src/enumfset/inttoTacs.sml | 2 +- src/enumfset/tcTacs.sml | 10 +- src/enumfset/totoTacs.sml | 16 +- src/floating-point/binary_ieeeSyntax.sml | 4 +- src/num/extra_theories/numeral_bitScript.sml | 2 +- src/portableML/mosml/Arbnumcore.sml | 2 +- src/probability/extrealScript.sml | 4 +- src/probability/lebesgueScript.sml | 8 +- src/quantHeuristics/doc/quantHeu.tex | 220 +++++++++---------- src/quantHeuristics/selftest.sml | 2 +- src/tfl/src/Defn.sml | 6 +- src/tfl/src/Induction.sml | 14 +- 19 files changed, 235 insertions(+), 235 deletions(-) diff --git a/src/1/PmatchHeuristics.sig b/src/1/PmatchHeuristics.sig index 69910e99c3..5e940264c9 100644 --- a/src/1/PmatchHeuristics.sig +++ b/src/1/PmatchHeuristics.sig @@ -7,25 +7,25 @@ sig {case_const : term, constructors : term list} option type pmatch_heuristic = {skip_rows : bool, (* skip splitting for redundant rows? *) collapse_cases : bool, (* collapse cases that lead to the same result ? *) - (* given a list of rows of patterns, which column to split on? *) + (* given a list of rows of patterns, which column to split on? *) col_fun : thry -> term list list -> int } - (* some predefined heuristics *) + (* some predefined heuristics *) val pheu_classic : pmatch_heuristic (* HOL 4's old heuristic *) - val pheu_first_row : pmatch_heuristic + val pheu_first_row : pmatch_heuristic val pheu_constr_prefix : pmatch_heuristic val pheu_qba : pmatch_heuristic (* the recommended one *) - val pheu_cqba : pmatch_heuristic - val pheu_first_col : pmatch_heuristic - val pheu_last_col : pmatch_heuristic + val pheu_cqba : pmatch_heuristic + val pheu_first_col : pmatch_heuristic + val pheu_last_col : pmatch_heuristic (* A heuristic based on column ranks. Given a pattern match matrix like p_11 ... p_1n - ... + ... p_m1 --- p_mn - and a list of ranking functions prheuL = [r_1, ... r_j]. The + and a list of ranking functions prheuL = [r_1, ... r_j]. The heuristic pheu_rank applies all ranking functions to all columns. Let's denote the result of "r_i current_thyr [p_k1, ... pkm]" with c_ik. It then picks column i such that [c_1i, ... c_ji] is maximal @@ -39,7 +39,7 @@ sig val prheu_small_branching_factor : thry -> term list -> int val prheu_arity : thry -> term list -> int - (* A comparison for the results of heuristic application + (* A comparison for the results of heuristic application (list of pattern lists, resulting decision tree) *) type pmatch_heuristic_res_compare = (term list list * term) Lib.cmp val pmatch_heuristic_cases_cmp : pmatch_heuristic_res_compare (* few cases are good *) @@ -48,7 +48,7 @@ sig (* Using such comparisons, we can supply multiple heuristics and choose the best results. For technical reasons, this function might be stateful and therefore get's unit arguments. - The usage of a heu_fun by the Pmatch library is as follows. Heu_fun initialises the functions and returns a + The usage of a heu_fun by the Pmatch library is as follows. Heu_fun initialises the functions and returns a compare function and a function heu_fun' which provides heuristics. As long as heu_fun' () provides fresh heuristics these are tried. Then the best result of all these heuristics according to the compare function is choosen. *) @@ -59,7 +59,7 @@ sig (* An exhaustive heuristic_fun. It tries all possibilities and very quickly blows up! Only usable for very small examples! *) - val exhaustive_heuristic_fun : pmatch_heuristic_res_compare -> pmatch_heuristic_fun + val exhaustive_heuristic_fun : pmatch_heuristic_res_compare -> pmatch_heuristic_fun (* custom pmatch_heuristic_fun can be easiest constructed by an explicit list of heuristics and a compare function *) @@ -70,7 +70,7 @@ sig (* The pmatch_heuristic_fun to be used by default and various functions to set it *) - val pmatch_heuristic : pmatch_heuristic_fun ref + val pmatch_heuristic : pmatch_heuristic_fun ref val set_heuristic : pmatch_heuristic -> unit val set_heuristic_fun : pmatch_heuristic_fun -> unit diff --git a/src/1/Tactical.sig b/src/1/Tactical.sig index e28ea96503..088bbb9597 100644 --- a/src/1/Tactical.sig +++ b/src/1/Tactical.sig @@ -11,7 +11,7 @@ sig val THEN1 : tactic * tactic -> tactic val THEN_LT : ('a -> goal list * (thm list -> 'b)) * list_tactic -> 'a -> goal list * (thm list -> 'b) - (* could be used as + (* could be used as val THEN_LT : tactic * list_tactic -> tactic val THEN_LT : list_tactic * list_tactic -> list_tactic *) @@ -24,7 +24,7 @@ sig val SPLIT_LT : int -> list_tactic * list_tactic -> list_tactic val ROTATE_LT : int -> list_tactic val REVERSE : tactic -> tactic - val REVERSE_LT : list_tactic + val REVERSE_LT : list_tactic val FAIL_TAC : string -> tactic val NO_TAC : tactic val ALL_TAC : tactic diff --git a/src/1/Tactical.sml b/src/1/Tactical.sml index aae33f9255..0b73f26e1e 100644 --- a/src/1/Tactical.sml +++ b/src/1/Tactical.sml @@ -78,7 +78,7 @@ fun store_thm (name, tm, tac) = infix THEN THENL THEN1 ORELSE THEN_LT (*--------------------------------------------------------------------------- - * tac1 THEN_LT ltac2: + * tac1 THEN_LT ltac2: * A tactical that applies ltac2 to the list of subgoals resulting from tac1 * tac1 may be a tactic or a list_tactic *---------------------------------------------------------------------------*) @@ -87,17 +87,17 @@ fun op THEN_LT (tac1, ltac2 : list_tactic) = let val (gl1, vf1) = tac1 g val (gl2, vf2) = ltac2 gl1 ; - in - (gl2, vf1 o vf2) - end + in + (gl2, vf1 o vf2) + end (* first argument can be a tactic or a list-tactic *) val _ = op THEN_LT : tactic * list_tactic -> tactic ; val _ = op THEN_LT : list_tactic * list_tactic -> list_tactic ; - + (*--------------------------------------------------------------------------- * fun ALLGOALS (tac2:tactic) : list_tactic = fn gl => - * let + * let * val (gll,pl) = unzip(map tac2 gl) * in * (flatten gll, mapshape(map length gll)pl) @@ -134,13 +134,13 @@ fun tac1 THEN tac2 = tac1 THEN_LT ALLGOALS tac2 ; (*--------------------------------------------------------------------------- * fun TACS_TO_LT (tac2l: tactic list) : list_tactic = fn gl => - * let + * let * val tac2gl = zip tac2l gl * val (gll,pl) = unzip (map (fn (tac2,g) => tac2 g) tac2gl) * in * (flatten gll, mapshape(map length gll) pl) * end - * Converts a list of tactics to a single list_tactic + * Converts a list of tactics to a single list_tactic *---------------------------------------------------------------------------*) fun TACS_TO_LT (tacl: tactic list) : list_tactic = @@ -210,50 +210,50 @@ fun op THEN1 (tac1: tactic, tac2: tactic) : tactic = (*--------------------------------------------------------------------------- * NTH_GOAL tac n: A list_tactic that applies tac to the nth goal - (counting goals from 1) + (counting goals from 1) *---------------------------------------------------------------------------*) -fun NTH_GOAL tac n gl1 = - let val (gl_before, g :: gl_after) = Lib.split_after (n-1) gl1 ; +fun NTH_GOAL tac n gl1 = + let val (gl_before, g :: gl_after) = Lib.split_after (n-1) gl1 ; val (gl2, vf2) = tac g ; val gl_result = gl_before @ gl2 @ gl_after ; - fun vf thl = + fun vf thl = let val (th_before, th_rest) = Lib.split_after (n-1) thl ; val (th2, th_after) = Lib.split_after (length gl2) th_rest ; - val th_result = th_before @ vf2 th2 :: th_after ; + val th_result = th_before @ vf2 th2 :: th_after ; in th_result end ; - in (gl_result, vf) end + in (gl_result, vf) end handle _ => raise ERR "NTH_GOAL" "no nth subgoal in list" ; fun LASTGOAL tac gl1 = NTH_GOAL tac (length gl1) gl1 ; fun HEADGOAL tac gl1 = NTH_GOAL tac 1 gl1 ; (*--------------------------------------------------------------------------- - * SPLIT_LT n (ltaca, ltacb) : A list_tactic that applies ltaca to the - first n goals, and ltacb to the rest + * SPLIT_LT n (ltaca, ltacb) : A list_tactic that applies ltaca to the + first n goals, and ltacb to the rest *---------------------------------------------------------------------------*) -fun SPLIT_LT n (ltaca, ltacb) gl = +fun SPLIT_LT n (ltaca, ltacb) gl = let val fixn = if n >= 0 then n else length gl + n ; val (gla, glb) = Lib.split_after fixn gl ; val (glra, vfa) = ltaca gla ; val (glrb, vfb) = ltacb glb ; - fun vf ths = + fun vf ths = let val (thsa, thsb) = Lib.split_after (length glra) ths ; - in vfa thsa @ vfb thsb end ; + in vfa thsa @ vfb thsb end ; in (glra @ glrb, vf) end ; (*--------------------------------------------------------------------------- - * ROTATE_LT n : + * ROTATE_LT n : * A list_tactic that moves the first n goals to the end of the goal list * first n goals *---------------------------------------------------------------------------*) -fun ROTATE_LT n [] = ([], Lib.I) - | ROTATE_LT n gl = +fun ROTATE_LT n [] = ([], Lib.I) + | ROTATE_LT n gl = let val lgl = length gl ; val fixn = Int.mod (n, lgl) ; val (gla, glb) = Lib.split_after fixn gl ; - fun vf ths = + fun vf ths = let val (thsb, thsa) = Lib.split_after (lgl - fixn) ths ; - in thsa @ thsb end ; + in thsa @ thsb end ; in (glb @ gla, vf) end ; (*--------------------------------------------------------------------------- @@ -278,7 +278,7 @@ fun REVERSE tac g = fun REVERSE_LT gl = (rev gl, rev) ; -(* for testing, redefine REVERSE +(* for testing, redefine REVERSE fun REVERSE tac = tac THEN_LT REVERSE_LT ; *) @@ -299,7 +299,7 @@ fun NO_TAC g = FAIL_TAC "NO_TAC" g (* for testing, redefine THEN1 fun tac1 THEN1 tac2 = tac1 THEN_LT NTH_GOAL (tac2 THEN NO_TAC) 1 ; -fun tac1 THEN1 tac2 = tac1 THEN_LT REVERSE_LT THEN_LT +fun tac1 THEN1 tac2 = tac1 THEN_LT REVERSE_LT THEN_LT LASTGOAL (tac2 THEN NO_TAC) THEN_LT REVERSE_LT ; *) diff --git a/src/datatype/DatatypeSimps.sig b/src/datatype/DatatypeSimps.sig index 07123d07c0..eaabf50a3e 100644 --- a/src/datatype/DatatypeSimps.sig +++ b/src/datatype/DatatypeSimps.sig @@ -37,9 +37,9 @@ val mk_case_cong_thm_tyinfo : tyinfo -> thm val mk_type_rewrites_tyinfo : tyinfo -> thm list (* mk_case_cong_thm_tyinfo generates an elimination theorem - that fires if all inputs give the same result. - - |- !M c. (case M of C1 => c | C2 x0 => c) = c + that fires if all inputs give the same result. + + |- !M c. (case M of C1 => c | C2 x0 => c) = c *) val mk_case_elim_thm_tyinfo : tyinfo -> thm @@ -58,7 +58,7 @@ val mk_type_quant_thms_tyinfo : tyinfo -> thm * thm (* mk_case_rand_thm_tyinfo, mk_case_rand_thm_tyinfo and mk_case_abs_thm_tyinfo provide theorems that are used for lifting case constants. Use carefully, since their application - easily loops. + easily loops. |- !M f f0 f1. f (case M of C1 => f0 | C2 x0 => f1 x0) = @@ -76,7 +76,7 @@ val mk_type_quant_thms_tyinfo : tyinfo -> thm * thm val mk_case_rand_thm_tyinfo : tyinfo -> thm val mk_case_rator_thm_tyinfo : tyinfo -> thm val mk_case_abs_thm_tyinfo : tyinfo -> thm - + (*---------------------------------------------------------------------------*) (* Simpsets *) (*---------------------------------------------------------------------------*) diff --git a/src/datatype/DatatypeSimps.sml b/src/datatype/DatatypeSimps.sml index 169062952c..45eb3dd59d 100644 --- a/src/datatype/DatatypeSimps.sml +++ b/src/datatype/DatatypeSimps.sml @@ -31,7 +31,7 @@ fun make_variant_list n s avoid [] = [] end fun make_args_simple [] = [] - | make_args_simple (ty :: tys) = + | make_args_simple (ty :: tys) = let val arg0 = mk_var("M", ty); val args = make_variant_list 0 "f" [arg0] tys; @@ -83,7 +83,7 @@ fun mk_type_quant_thms_tyinfo tyinfo = let val P_neg_tm = mk_abs (P_arg_tm, mk_neg (mk_comb (P_tm, P_arg_tm))) val thm0 = SPEC P_neg_tm forall_thm - val thm1 = AP_TERM boolSyntax.negation thm0 + val thm1 = AP_TERM boolSyntax.negation thm0 val thm3 = CONV_RULE (BINOP_CONV (SIMP_CONV std_ss [])) thm1 val thm4 = GEN P_tm thm3 in @@ -91,7 +91,7 @@ in end -fun mk_type_exists_thm_tyinfo tyinfo = +fun mk_type_exists_thm_tyinfo tyinfo = snd (mk_type_quant_thms_tyinfo tyinfo) @@ -124,7 +124,7 @@ fun mk_type_rewrites_tyinfo tyinfo = let val thms_dist = case (distinct_of tyinfo) of NONE => [] - | SOME thm_dist0 => let + | SOME thm_dist0 => let val thms_dist1 = CONJUNCTS thm_dist0 val thms_dist = thms_dist1 @ List.map GSYM thms_dist1 in thms_dist end @@ -164,8 +164,8 @@ fun mk_case_cong_thm_tyinfo tyinfo = let val constr = constructors_of tyinfo val M_eq = mk_eq (input_arg, input_arg') fun mk_imp args c c' cr = let - val t0 = list_mk_icomb (c, args) - val t1 = list_mk_icomb (c', args) + val t0 = list_mk_icomb (c, args) + val t1 = list_mk_icomb (c', args) val t2 = mk_eq (t0, t1) val u0 = list_mk_icomb (cr, args) val u1 = mk_eq (input_arg', u0) @@ -174,12 +174,12 @@ fun mk_case_cong_thm_tyinfo tyinfo = let in t4 end - val imps = List.map (fn (((args, c), (_, c')), cr) => + val imps = List.map (fn (((args, c), (_, c')), cr) => mk_imp args c c' cr) (zip (zip case_args case_args') constr) - val t3 = boolSyntax.list_mk_imp (M_eq::imps, t2) + val t3 = boolSyntax.list_mk_imp (M_eq::imps, t2) val t4 = list_mk_forall ([input_arg, input_arg']@(List.map snd case_args)@(List.map snd case_args'), t3) val forall_thm = mk_type_forall_thm_tyinfo tyinfo @@ -207,7 +207,7 @@ fun mk_case_rand_thm_tyinfo tyinfo = let val t2a = mk_comb (const, t1) val case_args1 = List.map (fn (args, c) => - list_mk_abs (args, mk_comb (const, list_mk_comb (c, args)))) + list_mk_abs (args, mk_comb (const, list_mk_comb (c, args)))) case_args val t2b = list_mk_icomb (case_c, [input_arg] @ case_args1) @@ -244,7 +244,7 @@ fun mk_case_rator_thm_tyinfo tyinfo = let val t3a = mk_icomb (t2, const) val case_args1 = List.map (fn (args, c) => - list_mk_abs (args, mk_comb (inst_ty (list_mk_comb (c, args)), const))) + list_mk_abs (args, mk_comb (inst_ty (list_mk_comb (c, args)), const))) case_args val t3b = list_mk_icomb (case_c, [input_arg] @ case_args1) @@ -279,7 +279,7 @@ fun mk_case_abs_thm_tyinfo tyinfo = let val t2a = mk_abs (const, t1) val case_args1 = List.map (fn (args, c) => - list_mk_abs (args, mk_abs (const, mk_comb (inst_ty (list_mk_comb (c, args)), const)))) + list_mk_abs (args, mk_abs (const, mk_comb (inst_ty (list_mk_comb (c, args)), const)))) case_args val t2b = list_mk_icomb (case_c, [input_arg] @ case_args1) @@ -303,14 +303,14 @@ end fun lift_case_const_CONV stop_consts rand_thms = let val conv = Ho_Rewrite.GEN_REWRITE_CONV I rand_thms -in (fn t => let - val thm = conv t - val (c, args) = strip_comb t +in (fn t => let + val thm = conv t + val (c, args) = strip_comb t in if (List.length args > 1 andalso List.exists (same_const c) stop_consts) then raise UNCHANGED else thm -end handle HOL_ERR _ => raise UNCHANGED) end - +end handle HOL_ERR _ => raise UNCHANGED) end + fun lift_cases_typeinfos_ss til = let val rand_thms = Lib.mapfilter mk_case_rand_thm_tyinfo til @@ -318,11 +318,11 @@ fun lift_cases_typeinfos_ss til = let val abs_thms = Lib.mapfilter mk_case_abs_thm_tyinfo til val consts = Lib.mapfilter case_const_of til - val conv_rand = lift_case_const_CONV consts rand_thms + val conv_rand = lift_case_const_CONV consts rand_thms val conv_rand_ss = simpLib.std_conv_ss { name = "lift_case_const_CONV", pats = [``f x``], - conv = conv_rand} + conv = conv_rand} val rewr_ss = simpLib.rewrites (abs_thms @ rator_thms) in @@ -340,30 +340,30 @@ fun lift_cases_stateful_ss () = lift_cases_typeinfos_ss (TypeBase.elts ()) fun unlift_case_const_CONV stop_consts rand_thms = let val conv = Rewrite.GEN_REWRITE_CONV I empty_rewrites rand_thms -in (fn t => let - val thm = conv t +in (fn t => let + val thm = conv t val (c, args) = strip_comb (rhs (concl thm)) in if (List.length args > 1 andalso List.exists (same_const c) stop_consts) then raise UNCHANGED else thm -end handle HOL_ERR _ => raise UNCHANGED) end - +end handle HOL_ERR _ => raise UNCHANGED) end + fun unlift_cases_typeinfos_ss til = let val rand_thms = List.map GSYM (Lib.mapfilter mk_case_rand_thm_tyinfo til) val rator_thms = List.map GSYM (Lib.mapfilter mk_case_rator_thm_tyinfo til) val abs_thms = List.map GSYM (Lib.mapfilter mk_case_abs_thm_tyinfo til) val consts = Lib.mapfilter case_const_of til - val conv_rand = unlift_case_const_CONV consts rand_thms + val conv_rand = unlift_case_const_CONV consts rand_thms val conv_rand_ss = simpLib.std_conv_ss { name = "unlift_case_const_CONV", pats = [``f x``], - conv = conv_rand} + conv = conv_rand} val conv_rator_ss = simpLib.std_conv_ss { name = "unlift_case_const_CONV", pats = [``f x``], - conv = Rewrite.GEN_REWRITE_CONV I empty_rewrites rator_thms} + conv = Rewrite.GEN_REWRITE_CONV I empty_rewrites rator_thms} val rewr_ss = simpLib.rewrites abs_thms in @@ -406,7 +406,7 @@ fun case_cong_stateful_ss () = case_cong_typeinfos_ss (TypeBase.elts ()) fun expand_type_quants_typeinfos_ss til = - rewrites (flatten (List.map (fn (x, y) => [x, y]) (Lib.mapfilter + rewrites (flatten (List.map (fn (x, y) => [x, y]) (Lib.mapfilter mk_type_quant_thms_tyinfo til))) fun expand_type_quants_ss tyL = expand_type_quants_typeinfos_ss (tyinfos_of_tys tyL) @@ -420,7 +420,7 @@ fun expand_type_quants_stateful_ss () = expand_type_quants_typeinfos_ss (TypeBas fun cases_to_top_RULE thm = let val input_thmL = BODY_CONJUNCTS thm - val (input_eqL, input_restL) = partition (fn thm => is_eq (concl thm)) input_thmL + val (input_eqL, input_restL) = partition (fn thm => is_eq (concl thm)) input_thmL fun process_eq eq_thm = let val free_vars_lhs = free_vars (lhs (concl eq_thm)); @@ -464,7 +464,7 @@ fun cases_to_top_RULE thm = let | SOME eq_thms => process_all acc (eq_thms @ thms)) val processed_eq_thms = process_all [] input_eqL - val all_thms = processed_eq_thms @ input_restL + val all_thms = processed_eq_thms @ input_restL in LIST_CONJ (List.map GEN_ALL all_thms) end diff --git a/src/enumfset/enumTacs.sml b/src/enumfset/enumTacs.sml index a9da911f5c..b5a61e3c6b 100644 --- a/src/enumfset/enumTacs.sml +++ b/src/enumfset/enumTacs.sml @@ -1,6 +1,6 @@ (* File: enumTacs.sml. Author: F. Lockwood Morris. Begun 6 Aug 2013. *) -(* Basic conversions and conversionals, and inference rules for *) +(* Basic conversions and conversionals, and inference rules for *) (* sorting lists, building ENUMERALS, look-up and converting them to *) (* OWL's, performing merge-based opns. on OWL's, recovering ENUMERALS. *) @@ -214,7 +214,7 @@ val [blr_nbl, blr_zer, blr_one] = CONJUNCTS bl_rev; blr_zer = |- !ft b. bl_rev ft (zerbl b) = bl_rev ft b blr_one = |- !ft a f b. bl_rev ft (onebl a f b) = bl_rev (node ft a f) b *) -fun bl_rev_CONV t = +fun bl_rev_CONV t = ((REWR_CONV blr_one THENC bl_rev_CONV) ORELSEC (REWR_CONV blr_zer THENC bl_rev_CONV) ORELSEC REWR_CONV blr_nbl) t; @@ -250,7 +250,7 @@ let val (s, ty) = dest_const t; val ety = hd (snd (dest_type ty)) in INST_TYPE [alpha |-> ety] LIST_TO_SET_NIL end else -let val (elem, st) = dest_binop (Term`($INSERT):'a->('a->bool)->'a->bool`) +let val (elem, st) = dest_binop (Term`($INSERT):'a->('a->bool)->'a->bool`) (ERR "DISPLAY_TO_set_CONV" "not a finite set extension") t; val ety = type_of elem in SPEC elem (MATCH_MP (INST_TYPE [alpha |-> ety] LIST_TO_SET_CONS) @@ -368,7 +368,7 @@ let fun olc t = ORELSEC olc))) t in olc end; -(* Top-level conversion works on a bt_to_ol, not a bt_to_ol_ac, term. +(* Top-level conversion works on a bt_to_ol, not a bt_to_ol_ac, term. Improved to check OL_bt first, and if this comes out T, as it always should, to use bt_to_list_CONV in place of bt_to_ol_lb/ub_CONV. *) @@ -376,7 +376,7 @@ val [aTT, aTF, aFT, aFF] = CONJUNCTS (prove ( ``(T/\T=T) /\ (T/\F=F) /\ (F/\T=F) /\ (F/\F=F)``, REWRITE_TAC [AND_CLAUSES])); -val AND_CONV = REWR_CONV aTT ORELSEC REWR_CONV aTF ORELSEC +val AND_CONV = REWR_CONV aTT ORELSEC REWR_CONV aTF ORELSEC REWR_CONV aFT ORELSEC REWR_CONV aFF; val [OL_lu_nt, OL_lu_node] = CONJUNCTS OL_bt_lb_ub; @@ -387,7 +387,7 @@ val [OL_lu_nt, OL_lu_node] = CONJUNCTS OL_bt_lb_ub; OL_bt_lb_ub cmp lb (node l x r) ub <=> OL_bt_lb_ub cmp lb l x /\ OL_bt_lb_ub cmp x r ub *) -fun OL_bt_lb_ub_CONV keyconv = +fun OL_bt_lb_ub_CONV keyconv = let fun olu t = ((REWR_CONV OL_lu_nt THENC LAND_CONV keyconv THENC EQ_LESS_CONV) ORELSEC (REWR_CONV OL_lu_node THENC @@ -401,7 +401,7 @@ val [OL_l_nt, OL_l_node] = CONJUNCTS OL_bt_lb; |- !cmp lb l x r. OL_bt_lb cmp lb (node l x r) <=> OL_bt_lb_ub cmp lb l x /\ OL_bt_lb cmp x r *) -fun OL_bt_lb_CONV keyconv = +fun OL_bt_lb_CONV keyconv = let fun ol t = ((REWR_CONV OL_l_node THENC LAND_CONV (OL_bt_lb_ub_CONV keyconv) THENC RAND_CONV ol THENC AND_CONV) @@ -415,7 +415,7 @@ val [OL_u_nt, OL_u_node] = CONJUNCTS OL_bt_ub; OL_bt_ub cmp (node l x r) ub <=> OL_bt_ub cmp l x /\ OL_bt_lb_ub cmp x r ub *) -fun OL_bt_ub_CONV keyconv = +fun OL_bt_ub_CONV keyconv = let fun ou t = ((REWR_CONV OL_u_node THENC LAND_CONV ou THENC RAND_CONV (OL_bt_lb_ub_CONV keyconv) THENC AND_CONV) @@ -645,7 +645,7 @@ incr_smerge_CONV numto_CONV imz; val ibl = Term`incr_sbuild numto [3; 1; 3; 4; 2; 1]`; incr_sbuild_CONV numto_CONV ibl; - + val mo5 = Term`smerge_out numto [5] [NONE; SOME [1; 3]; SOME [1; 2; 3; 4]]`; smerge_out_CONV numto_CONV mo5; @@ -773,7 +773,7 @@ SET_DIFF_CONV numto_CONV itwet'; val ta = rand (concl (DISPLAY_TO_ENUMERAL_CONV numto_CONV ``numto`` ``{4;1;3;5;2}``)); val tb = rand (concl (DISPLAY_TO_ENUMERAL_CONV - numto_CONV ``numto`` ``{3; 4; 6; 7; 3}``)); + numto_CONV ``numto`` ``{3; 4; 6; 7; 3}``)); val tc = rand (concl (DISPLAY_TO_ENUMERAL_CONV numto_CONV ``numto`` ``{5; 6; 4; 8; 3; 1}``)); diff --git a/src/enumfset/fmapalTacs.sml b/src/enumfset/fmapalTacs.sml index 885541ba6b..9194d0773f 100644 --- a/src/enumfset/fmapalTacs.sml +++ b/src/enumfset/fmapalTacs.sml @@ -1,6 +1,6 @@ (* File: fmapalTacs.sml. Author: F. Lockwood Morris. Begun 6 Aug 2013. *) -(* Basic conversions and conversionals, and inference rules for *) +(* Basic conversions and conversionals, and inference rules for *) (* sorting lists, building FMAPALS, look-up and converting them to *) (* lists and uniting and restricting them. *) @@ -256,7 +256,7 @@ val [ORL_lu_nt, ORL_lu_node] = CONJUNCTS ORL_bt_lb_ub; ORL_bt_lb_ub cmp lb (node l (x,y) r) ub <=> ORL_bt_lb_ub cmp lb l x /\ ORL_bt_lb_ub cmp x r ub *) -fun ORL_bt_lb_ub_CONV keyconv = +fun ORL_bt_lb_ub_CONV keyconv = let fun olu t = ((REWR_CONV ORL_lu_nt THENC LAND_CONV keyconv THENC EQ_LESS_CONV) ORELSEC (REWR_CONV ORL_lu_node THENC @@ -270,7 +270,7 @@ val [ORL_l_nt, ORL_l_node] = CONJUNCTS ORL_bt_lb; ORL_bt_lb cmp lb (node l (x,y) r) <=> ORL_bt_lb_ub cmp lb l x /\ ORL_bt_lb cmp x r *) -fun ORL_bt_lb_CONV keyconv = +fun ORL_bt_lb_CONV keyconv = let fun ol t = ((REWR_CONV ORL_l_node THENC LAND_CONV (ORL_bt_lb_ub_CONV keyconv) THENC RAND_CONV ol THENC AND_CONV) @@ -284,7 +284,7 @@ val [ORL_u_nt, ORL_u_node] = CONJUNCTS ORL_bt_ub; ORL_bt_ub cmp (node l (x,y) r) ub <=> ORL_bt_ub cmp l x /\ ORL_bt_lb_ub cmp x r ub *) -fun ORL_bt_ub_CONV keyconv = +fun ORL_bt_ub_CONV keyconv = let fun ou t = ((REWR_CONV ORL_u_node THENC LAND_CONV ou THENC RAND_CONV (ORL_bt_lb_ub_CONV keyconv) THENC AND_CONV) @@ -610,7 +610,7 @@ else FMAPAL_FUPDATE_CONV keyconv t; (* ******************************************************************* *) fun FMAPAL_EXPR_TO_ORWL keyconv t = -let val c = rator (rator t) +let val c = rator (rator t) in if is_const c then let val d = fst (dest_const c) in if d = "FMAPAL" then FMAPAL_TO_ORWL keyconv t @@ -623,7 +623,7 @@ in if is_const c then ORWL_DRESTRICT_COMPL keyconv (FMAPAL_EXPR_TO_ORWL keyconv (rand (rator t))) (ENUMERAL_TO_OWL keyconv (rand (rand t))) - else + else ORWL_DRESTRICT keyconv (FMAPAL_EXPR_TO_ORWL keyconv (rand (rator t))) (ENUMERAL_TO_OWL keyconv (rand t)) @@ -659,7 +659,7 @@ incr_merge_CONV numto_CONV imz; val ibl = Term`incr_build numto [(3,()); (1,()); (3,()); (4,()); (2,()); (1,())]`; incr_build_CONV numto_CONV ibl; - + val mo5 = Term`merge_out numto [(5,())] [NONE; SOME [(1,()); (3,())]; SOME [(1,()); (2,()); (3,()); (4,())]]`; merge_out_CONV numto_CONV mo5; diff --git a/src/enumfset/inttoTacs.sml b/src/enumfset/inttoTacs.sml index 27716e6133..27f4d65d6a 100644 --- a/src/enumfset/inttoTacs.sml +++ b/src/enumfset/inttoTacs.sml @@ -60,7 +60,7 @@ end; ``intOrd 2i 3i``, ``intOrd 2i (-3i)``, ``intOrd 3i (-3i)``, ``intOrd 0i (-2i)``, ``intOrd (0i) (-3i)``, ``intOrd 0i (-0i)``]; *) -val intto_CONV = +val intto_CONV = RATOR_CONV (RATOR_CONV (REWR_CONV apintto_thm)) THENC intOrd_CONV; diff --git a/src/enumfset/tcTacs.sml b/src/enumfset/tcTacs.sml index 83301b8194..9ebb47f53a 100644 --- a/src/enumfset/tcTacs.sml +++ b/src/enumfset/tcTacs.sml @@ -1,6 +1,6 @@ (* File: tcTacs.sml. Author: F. Lockwood Morris. Begun 6 Aug 2013. *) -(* Conversions culminating in TC_CONV, applicable to a term of the *) +(* Conversions culminating in TC_CONV, applicable to a term of the *) (* form (FMAP_TO_RELN (FMAPAL ... ))^+ (with ENUMERAL-sets as *) (* the map values), which it proves equal to one of the form *) (* (FMAP_TO_RELN (FMAPAL ......... )), alternatively applicable to a *) @@ -93,17 +93,17 @@ val cormenex = ``[(2, {4; 3}); (3, {2}); (4, {3; 1}); (1, {})]``; val corfmap = rand (concl (ENUF_CONV numto_CONV ``numto`` ``fmap ^cormenex``)); val Aplus = ``(FMAP_TO_RELN ^corfmap)^+``; - val keyconv = numto_CONV; + val keyconv = numto_CONV; - PRE_TC_CONV keyconv ``(FMAP_TO_RELN ^corfmap)^+``; - PRE_TC_CONV NO_CONV ``(FMAP_TO_RELN (fmap ^cormenex))^+``; + PRE_TC_CONV keyconv ``(FMAP_TO_RELN ^corfmap)^+``; + PRE_TC_CONV NO_CONV ``(FMAP_TO_RELN (fmap ^cormenex))^+``; val s123 = rand (concl (DISPLAY_TO_ENUMERAL_CONV numto_CONV ``numto`` ``{1; 2; 3}``)); val s345 = rand (concl (DISPLAY_TO_ENUMERAL_CONV numto_CONV ``numto`` ``{5; 4; 3}``)); TC_MOD_CONV numto_CONV ``TC_MOD 5 ^s123 ^s345``; - TC_MOD_CONV numto_CONV ``TC_MOD 5 ^s345 ^s123``; + TC_MOD_CONV numto_CONV ``TC_MOD 5 ^s345 ^s123``; val t123 = ``{1; 2; 3}``; val t345 = ``{5; 4; 3}``; TC_MOD_CONV REDUCE_CONV ``TC_MOD 5 ^t123 ^t345``; diff --git a/src/enumfset/totoTacs.sml b/src/enumfset/totoTacs.sml index 6bb7102695..36bd1aed3f 100644 --- a/src/enumfset/totoTacs.sml +++ b/src/enumfset/totoTacs.sml @@ -54,7 +54,7 @@ val cpn_REWR_CONV = REWR_CONV LESS_REWR ORELSEC REWR_CONV EQUAL_REWR ORELSEC (* **** Getting to toto-deciding conversions. **** *) (* *********************************************************************** *) -(* Given +(* Given lin_ord_thm: |- LinearOrder phi; toto_of_thm: |- cmp = toto_of_LinearOrder phi; eq_conv: reduces equations of ground terms (of phi's arg. type) to T/F; @@ -78,7 +78,7 @@ in fn (t:term) => (* supposed to have the form apto cmp t1 t2 *) let val (t1, t2) = (rand (rator t), rand t); val eq_verdict = eq_conv (mk_eq (t1, t2)) in PURE_MATCH_MP eq_thm eq_verdict - handle _ => + handle _ => let val cond = PURE_MATCH_MP uneq_thm eq_verdict; (* cond = `if phi x y then ... = LESS else ... = GREATER` *) val (phi12, arm1, arm2) = dest_cond (concl cond); @@ -121,7 +121,7 @@ fun numOrd_CONV t = Raise (ERR "numOrd_CONV" "not a numOrd test") end end; -val numto_CONV = +val numto_CONV = RATOR_CONV (RATOR_CONV (REWR_CONV apnumto_thm)) THENC numOrd_CONV; @@ -163,7 +163,7 @@ fun qk_numOrd_CONV t = Raise (ERR "qk_numOrd_CONV" "not a qk_numOrd test") end end; -val qk_numto_CONV = +val qk_numto_CONV = RATOR_CONV (RATOR_CONV (REWR_CONV ap_qk_numto_thm)) THENC qk_numOrd_CONV; @@ -198,8 +198,8 @@ val [lsnn, lsnc, lscn, lscc] = map GEN_ALL (CONJUNCTS (SPEC_ALL aplistoto)); fun listoto_CONV elem_conv = let fun lis_c t = - ((REWR_CONV lscc THENC - RATOR_CONV (RATOR_CONV (RATOR_CONV (RAND_CONV elem_conv))) THENC + ((REWR_CONV lscc THENC + RATOR_CONV (RATOR_CONV (RATOR_CONV (RAND_CONV elem_conv))) THENC ((REWR_CONV EQUAL_REWR THENC lis_c) ORELSEC REWR_CONV LESS_REWR ORELSEC REWR_CONV GREATER_REWR)) ORELSEC REWR_CONV lsnn ORELSEC REWR_CONV lsnc ORELSEC REWR_CONV lscn) t @@ -210,7 +210,7 @@ fun listoto_CONV elem_conv = val refl_clause_string = MATCH_MP TO_refl (ISPEC (Term`stringto`) TotOrd_apto); -fun stringto_CONV t = +fun stringto_CONV t = if rand (rator t) = rand t then SPEC (rand t) refl_clause_string else (RATOR_CONV (RATOR_CONV (RAND_CONV (REWR_CONV stringto))) THENC listoto_CONV charto_CONV) t; @@ -233,7 +233,7 @@ charto_CONV (Term`apto charto #"8" #"7"`); val testn = Count.apply (numto_CONV o Term); testn`apto numto 5 7`; -testn`apto numto 0 0`; +testn`apto numto 0 0`; val testc = Count.apply (charOrd_CONV o Term); diff --git a/src/floating-point/binary_ieeeSyntax.sml b/src/floating-point/binary_ieeeSyntax.sml index d30b825bf3..4b234b941f 100644 --- a/src/floating-point/binary_ieeeSyntax.sml +++ b/src/floating-point/binary_ieeeSyntax.sml @@ -129,7 +129,7 @@ val etw_monop = boolSyntax.mk_icomb (tm1, pairSyntax.mk_pair (t1, t2)) end) -val tw_binop = +val tw_binop = HolKernel.syntax_fns "binary_ieee" 2 (fn tm1 => fn e => fn tm2 => let @@ -304,7 +304,7 @@ val (float_mul_add_tm, mk_float_mul_add, dest_float_mul_add, is_float_mul_add) = val (round_tm, mk_round, dest_round, is_round) = tw_binop "round" -val (float_round_tm, mk_float_round, dest_float_round, is_float_round) = +val (float_round_tm, mk_float_round, dest_float_round, is_float_round) = tw_triop "float_round" (* ------------------------------------------------------------------------- *) diff --git a/src/num/extra_theories/numeral_bitScript.sml b/src/num/extra_theories/numeral_bitScript.sml index 998f9755e0..dca6542116 100644 --- a/src/num/extra_theories/numeral_bitScript.sml +++ b/src/num/extra_theories/numeral_bitScript.sml @@ -509,7 +509,7 @@ val MOD_2EXP_MAX = Q.store_thm("MOD_2EXP_MAX", [GSYM BITS_ZERO3, SYM BIT0_ODD, GSYM BIT_BITS_THM, BIT_DIV2, DIV2_def] \\ EQ_TAC \\ RW_TAC arith_ss [BIT_EXP_SUB1] - \\ Cases_on `x` + \\ Cases_on `x` \\ RW_TAC arith_ss []) (* ------------------------------------------------------------------------- *) diff --git a/src/portableML/mosml/Arbnumcore.sml b/src/portableML/mosml/Arbnumcore.sml index 3a8a92564f..b0526768c1 100644 --- a/src/portableML/mosml/Arbnumcore.sml +++ b/src/portableML/mosml/Arbnumcore.sml @@ -479,7 +479,7 @@ fun isqrt n = if n < two then n else let - fun iter a = + fun iter a = if a * a <= n andalso n < (a + one) * (a + one) then a else iter (div2 ((a * a + n) div a)) diff --git a/src/probability/extrealScript.sml b/src/probability/extrealScript.sml index 8bd8ba0129..4f210c7861 100644 --- a/src/probability/extrealScript.sml +++ b/src/probability/extrealScript.sml @@ -2635,11 +2635,11 @@ val sup_add_mono = store_thm ++ ONCE_REWRITE_TAC [GSYM SPECIFICATION] ++ METIS_TAC [IN_UNIV,IN_IMAGE]) ++ Cases_on `sup (IMAGE f UNIV) = PosInf` - >> (`sup (IMAGE (\n. sup (IMAGE f UNIV) + g n) UNIV) = PosInf` + >> (`sup (IMAGE (\n. sup (IMAGE f UNIV) + g n) UNIV) = PosInf` by (RW_TAC std_ss [extreal_add_def,sup_eq,le_infty] ++ POP_ASSUM (MP_TAC o Q.SPEC `PosInf`) ++ RW_TAC std_ss [] - ++ `PosInf <= y'` + ++ `PosInf <= y'` by (POP_ASSUM MATCH_MP_TAC ++ ONCE_REWRITE_TAC [GSYM SPECIFICATION] ++ RW_TAC std_ss [IN_UNIV,IN_IMAGE]) diff --git a/src/probability/lebesgueScript.sml b/src/probability/lebesgueScript.sml index 260b9e0132..a4c57bcb75 100644 --- a/src/probability/lebesgueScript.sml +++ b/src/probability/lebesgueScript.sml @@ -2293,7 +2293,7 @@ val lemma_fn_in_psfis = store_thm val integral_sequence = store_thm ("integral_sequence",``!m f. (!x. 0 <= f x) /\ measure_space m /\ f IN measurable (m_space m,measurable_sets m) Borel - ==> (pos_fn_integral m f = sup (IMAGE (\i. pos_fn_integral m (fn_seq m f i)) UNIV))``, + ==> (pos_fn_integral m f = sup (IMAGE (\i. pos_fn_integral m (fn_seq m f i)) UNIV))``, RW_TAC std_ss [] ++ MATCH_MP_TAC lebesgue_monotone_convergence ++ RW_TAC std_ss [lemma_fn_sup,lemma_fn_mono_increasing,lemma_fn_upper_bounded,lemma_fn_5] @@ -2301,7 +2301,7 @@ val integral_sequence = store_thm val measurable_sequence = store_thm -("measurable_sequence",``!m f. measure_space m /\ f IN measurable (m_space m,measurable_sets m) Borel ==> +("measurable_sequence",``!m f. measure_space m /\ f IN measurable (m_space m,measurable_sets m) Borel ==> (?fi ri. (!x. mono_increasing (\i. fi i x)) /\ (!x. x IN m_space m ==> (sup (IMAGE (\i. fi i x) UNIV) = fn_plus f x)) /\ (!i. ri i IN psfis m (fi i)) /\ @@ -2948,7 +2948,7 @@ val integrable_not_infty_alt3 = store_thm by (RW_TAC std_ss [fn_plus_def,FUN_EQ_THM] ++ Cases_on `f x` ++ METIS_TAC [lt_infty]) ++ `fn_minus (\x. if (f x = NegInf) \/ (f x = PosInf) then 0 else f x) = - (\x. if fn_minus f x = PosInf then 0 else fn_minus f x)` + (\x. if fn_minus f x = PosInf then 0 else fn_minus f x)` by (RW_TAC std_ss [fn_minus_def,FUN_EQ_THM] ++ Cases_on `f x` ++ METIS_TAC [lt_infty, lt_refl, extreal_ainv_def, extreal_not_infty]) @@ -3123,7 +3123,7 @@ val integral_mspace = store_thm val integral_mono = store_thm ("integral_mono", ``!m f1 f2. measure_space m /\ (!t. t IN m_space m ==> f1 t <= f2 t) ==> - (integral m f1 <= integral m f2)``, + (integral m f1 <= integral m f2)``, RW_TAC std_ss [] ++ ONCE_REWRITE_TAC [(UNDISCH o Q.SPECL [`m`,`f`]) integral_mspace] ++ RW_TAC std_ss [integral_def] diff --git a/src/quantHeuristics/doc/quantHeu.tex b/src/quantHeuristics/doc/quantHeu.tex index fbef37ef30..08ccae740f 100644 --- a/src/quantHeuristics/doc/quantHeu.tex +++ b/src/quantHeuristics/doc/quantHeu.tex @@ -2,7 +2,7 @@ \usepackage{amsthm} \usepackage{palatino} -\usepackage{amssymb} +\usepackage{amssymb} \usepackage{amsmath} \usepackage[sort&compress]{natbib} \usepackage{hyperref} @@ -64,13 +64,13 @@ \section{Motivation} and \[ \exists x_1\ \ldots x_i \ldots x_n.\ P_1 \wedge \ldots \wedge x_i = c \wedge \ldots \wedge P_n \] can be simplified by -instantiating $x_i$ with $c$. Because unwind-conversions are +instantiating $x_i$ with $c$. Because unwind-conversions are part of \texttt{bool\_ss}, they are used with nearly every call of the simplifier and often simplify proofs considerably. However, the unwind library can only handle these common cases. If the term structure is only slightly more complicated, it fails. For example, $\exists x.\ P(a) \Longrightarrow (x = 2) \wedge Q(x)$ cannot be tackled. -There is also the satisfy library\footnote{see \texttt{src/simp/src/Satisfy.sml}}, which uses unification to +There is also the satisfy library\footnote{see \texttt{src/simp/src/Satisfy.sml}}, which uses unification to show existentially quantified formulas. It can handle problems like $\exists x.\ P_1(x,c_1)\ \wedge \ldots P_n(x,c_n)$ if given theorems of the form $\forall x\ c.\ P_i(x, c)$. This is often handy, but still rather limited. @@ -101,10 +101,10 @@ \section{Motivation} $\forall x.\ x = 2$ & $\textit{false}$ \\ \tablehead{complicated nestings of standard operators} -$\exists x_1. \forall x_2.\ (x_1 = 2) \wedge P(x_1, x_2)$ & +$\exists x_1. \forall x_2.\ (x_1 = 2) \wedge P(x_1, x_2)$ & $\forall x_2.\ P(2, x_2)$ \\ -$\exists x_1, x_2.\ P_1(x_2) \Longrightarrow (x_1 = 2) \wedge P(x_1, x_2)$ & +$\exists x_1, x_2.\ P_1(x_2) \Longrightarrow (x_1 = 2) \wedge P(x_1, x_2)$ & $\exists x_2.\ P_1(x_2) \Longrightarrow P(2, x_2)$ \\ $\exists x.\ ((x = 2) \vee (2 = x)) \wedge P(x)$ & $P(2)$ \\ @@ -150,7 +150,7 @@ \section{Structure} this abstract presentation, Section~\ref{sec_examples} shows how guess-search works for simple examples. -The second part starts with a high level presentation of the user-interface in +The second part starts with a high level presentation of the user-interface in Section~\ref{sec_interface}. An important concept of the interface are quantifier heuristic parameters, which allow configuring the behaviour of the library. In Section~\ref{sec_qps} first predefined parameters are presented. @@ -169,7 +169,7 @@ \subsection{Weak Guesses for Existential Quantifiers} is a search based on heuristics. Abstractly, given a term $\exists x.\ P(x)$ we want to find an instantiation $\lambda \fv. i(\fv)$ such that $\exists x.\ P(x) \Longleftrightarrow \exists \fv.\ P(i(\fv))$ -holds. In the following, such an $i$ is called a \emph{guess} for +holds. In the following, such an $i$ is called a \emph{guess} for variable $x$ in $P(x)$. In order to justify such a guess, we define special predicates that capture the intended semantics. @@ -184,22 +184,22 @@ \subsection{Weak Guesses for Existential Quantifiers} \Longleftrightarrow 2 = 2$ holds. More interestingly, $\GE(\lambda(x, xs').\ x::xs'), \lambda xs.\ xs \neq [] \wedge P(xs))$ holds. Therefore, $\exists xs.\ xs \neq []\ \wedge\ P(xs)$ can be simplified -to $\exists x\ xs'.\ x::xs' \neq []\ \wedge\ P(x::xs')$. +to $\exists x\ xs'.\ x::xs' \neq []\ \wedge\ P(x::xs')$. \end{example} So, when trying to process $\exists x.\ P(x)$, we search for an existential guess $i$ such that $\GE(i, \lambda x. P(x))$ holds. If such a guess is found, the original term can be simplified to $\exists \fv.\ P(i(\fv))$, which is really \emph{simpler} provided sensible heuristics for creating -guesses are used. In particular, guesses $i$ that do not depend on $\fv$ frequently occur in practice. +guesses are used. In particular, guesses $i$ that do not depend on $\fv$ frequently occur in practice. The quantifier disappears completely in this common case. \subsection{Strong Guesses for Existential Quantifiers} -The general idea for coming up with a guess $\GE(i, P)$ is preforming +The general idea for coming up with a guess $\GE(i, P)$ is preforming a bottom-up search of the syntax tree of $P$. Unluckily, $\GE$ is -not well suited for such a search, because it is too weak to easily lift -guesses for subterms. Consider, for example, terms of the form +not well suited for such a search, because it is too weak to easily lift +guesses for subterms. Consider, for example, terms of the form $\exists x.\ P_1(x) \vee P_2(x)$. If we have a guess $\GE(i, P_1)$, we unluckily can't lift it to a guess $\GE(i, \lambda x.\ P_1(x) \vee P_2(x))$ in general. A counterexample is $P_1(x) := \textit{false}$, $P_2(x) := (x = 2)$ and $i := K\ 3 = \lambda \fv.\ 3$. @@ -228,7 +228,7 @@ \subsection{Strong Guesses for Existential Quantifiers} \begin{example} In addition to weak existential guesses $\GE(i,P)$, gap existential guesses $\GEG(i,P)$ carry information about all points except the gap $i$. -The guess $\GEG(K\ 2, \lambda x.\ x = 2\ \wedge\ Q(x))$ holds, because $\lambda x.\ (x = 2)\ \wedge\ Q(x)$ +The guess $\GEG(K\ 2, \lambda x.\ x = 2\ \wedge\ Q(x))$ holds, because $\lambda x.\ (x = 2)\ \wedge\ Q(x)$ does not hold for all values except possibly $2$. Since nothing is known about $Q$, we don't know, whether $P$ holds for the point $2$. This point is a gap in the argument. \end{example} @@ -266,7 +266,7 @@ \subsection{Guesses for Universal Quantifiers} \end{definition} Similar to guesses for existential quantification, we are mainly interested in weak universal guesses. Point and gap -universal guesses are stronger than universal ones and allow lifting. +universal guesses are stronger than universal ones and allow lifting. \subsection{Overview} @@ -305,42 +305,42 @@ \subsection{Overview} So, the core of the framework searches for guesses. Once found, the guesses are used as described by the following theorem: \begin{theorem}[Usage of Guesses]\label{lemma_guesses_usage} -Guesses are used to simplify formulae with quantifiers in various ways. In the most basic case, they can +Guesses are used to simplify formulae with quantifiers in various ways. In the most basic case, they can be used to (partially) instantiate quantifiers as follows: \[% \begin{array}[t]{cccrclc} - \GE(i, P) & \Longrightarrow & \Big( & \exists x.\ P(x) & \Leftrightarrow & \exists \fv.\ P(i(\fv)) & \Big) \\ - \GU(i, P) & \Longrightarrow & \Big( & \forall x.\ P(x) & \Leftrightarrow & \forall \fv.\ P(i(\fv)) & \Big) \\ + \GE(i, P) & \Longrightarrow & \Big( & \exists x.\ P(x) & \Leftrightarrow & \exists \fv.\ P(i(\fv)) & \Big) \\ + \GU(i, P) & \Longrightarrow & \Big( & \forall x.\ P(x) & \Leftrightarrow & \forall \fv.\ P(i(\fv)) & \Big) \\ \end{array} \] % If the guess does not depend on a free variable (as denoted by $K\ i_c$), the quantifier can be removed completely: \[ \begin{array}[t]{cccrclc} - \GE(K\ i_c, P) & \Longrightarrow & \Big( & \exists x.\ P(x) & \Leftrightarrow & P(i_c) & \Big) \\ - \GU(K\ i_c, P) & \Longrightarrow & \Big( & \forall x.\ P(x) & \Leftrightarrow & P(i_c) & \Big) \\ + \GE(K\ i_c, P) & \Longrightarrow & \Big( & \exists x.\ P(x) & \Leftrightarrow & P(i_c) & \Big) \\ + \GU(K\ i_c, P) & \Longrightarrow & \Big( & \forall x.\ P(x) & \Leftrightarrow & P(i_c) & \Big) \\ \end{array} \] Point guesses lead to even more simplification: \[ \begin{array}[t]{cccrclc} - \GEP(i, P) & \Longrightarrow & \Big( & \exists x.\ P(x) & \Leftrightarrow & \textit{true} & \Big) \\ - \GUP(i, P) & \Longrightarrow & \Big( & \forall x.\ P(x) & \Leftrightarrow & \textit{false} & \Big) \\ + \GEP(i, P) & \Longrightarrow & \Big( & \exists x.\ P(x) & \Leftrightarrow & \textit{true} & \Big) \\ + \GUP(i, P) & \Longrightarrow & \Big( & \forall x.\ P(x) & \Leftrightarrow & \textit{false} & \Big) \\ \end{array} \] -In contrast, the additional strength of gap guesses +In contrast, the additional strength of gap guesses is mainly important for lifting. For instantiating quantifiers the same rules as for existential and universal guesses apply. However, gap existential guesses are useful for handling unique existential quantification, provided the guess does not contain free variables. \[ \begin{array}[t]{cccrclc} - \GE(K\ i_c, P) & \Longrightarrow & \Big( & \exists! x.\ P(x) & \Leftrightarrow & - (P(i_c)\ \wedge\ \forall v.\ P(v) \Rightarrow v = i_c) & \Big) \\ - \GEG(K\ i_c, P) & \Longrightarrow & \Big( & \exists! x.\ P(x) & \Leftrightarrow & - P(i_c) & \Big) \\ - \GEP(K\ i_c, P) & \Longrightarrow & \Big( & \exists! x.\ P(x) & \Leftrightarrow & - (\forall v.\ P(v) \Rightarrow v = i_c) & \Big) + \GE(K\ i_c, P) & \Longrightarrow & \Big( & \exists! x.\ P(x) & \Leftrightarrow & + (P(i_c)\ \wedge\ \forall v.\ P(v) \Rightarrow v = i_c) & \Big) \\ + \GEG(K\ i_c, P) & \Longrightarrow & \Big( & \exists! x.\ P(x) & \Leftrightarrow & + P(i_c) & \Big) \\ + \GEP(K\ i_c, P) & \Longrightarrow & \Big( & \exists! x.\ P(x) & \Leftrightarrow & + (\forall v.\ P(v) \Rightarrow v = i_c) & \Big) \end{array} \] \end{theorem} @@ -360,32 +360,32 @@ \subsection{Oracle Guesses} An oracle guess carries no semantic information, it just states something like ``\textit{Trust me! This is a sensible guess!}''. Therefore, oracle guesses can only be used to prove implications instead of -equivalences. +equivalences. % \begin{lemma}[Usage of Oracle Guesses] \[ \begin{array}[t]{cccrclc} - \GO(i, P) & \Longrightarrow & \Big( & \exists x.\ P(x) & \Leftarrow & \exists \fv.\ P(i(\fv)) & \Big) \\ - \GO(i, P) & \Longrightarrow & \Big( & \forall x.\ P(x) & \Rightarrow & \forall \fv.\ P(i(\fv)) & \Big) + \GO(i, P) & \Longrightarrow & \Big( & \exists x.\ P(x) & \Leftarrow & \exists \fv.\ P(i(\fv)) & \Big) \\ + \GO(i, P) & \Longrightarrow & \Big( & \forall x.\ P(x) & \Rightarrow & \forall \fv.\ P(i(\fv)) & \Big) \end{array} \] \end{lemma} % -Oracle guesses allow the user to instantiate quantifiers without formal justification. -Therefore, they require hardly any theoretical foundation and +Oracle guesses allow the user to instantiate quantifiers without formal justification. +Therefore, they require hardly any theoretical foundation and are mainly interesting for tool implementation. Therefore, they won't be discussed much below. \section{Base Guesses} \label{sec_base_guesses} After introducing guesses, guess-search can be presented now. -This presentation is twofold. In this section, guesses for basic terms are discussed. Lifting guesses +This presentation is twofold. In this section, guesses for basic terms are discussed. Lifting guesses is presented in the next section. \subsection{Equations} The most basic, but also most common source of guesses are equations: \begin{lemma}[Guesses for Equations with Variables at Top-Level]\label{lemma_guesses_equation_top} -Given an equation $x = t$ such that the variable $x$ +Given an equation $x = t$ such that the variable $x$ does not occur in $t$, the term $t$ is both a point and gap existential guess for $x$: \[% @@ -396,7 +396,7 @@ \subsection{Equations} \end{lemma} % \begin{lemma}[Point Existential Guesses for Equations]\label{lemma_guesses_equation_T} -Given an equation $t_1(x) = t_2(x)$ and a term $i_c$ such that +Given an equation $t_1(x) = t_2(x)$ and a term $i_c$ such that the formula $t_1(i_c) = t_2(i_c)$ holds, the term $i_c$ is a point existential guess for $x$. This means that the following holds. \[ @@ -433,14 +433,14 @@ \subsection{Dichotomies}\label{subsec_base_guesses_dichotomies} \GUP(\lambda \fv.\ c_2(\fv),\ \lambda x.\ (x = c_1)) \\ (\forall x.\ x = c_1\ \vee\ (\exists \fv.\ x = c_2(\fv))) & \Longrightarrow & -\GUG(\lambda \fv.\ c_2(\fv),\ \lambda x.\ (x = c_1)) +\GUG(\lambda \fv.\ c_2(\fv),\ \lambda x.\ (x = c_1)) \end{array} \] \end{lemma} % Exploiting dichotomy is very useful in practice. Holfoot uses it to reason about lists. The variable \textit{pdata'} in the list-reversal example of the introduction can, for example, -be instantiated using the dichotomy of lists. Without this rule, Holfoot's inference rules for +be instantiated using the dichotomy of lists. Without this rule, Holfoot's inference rules for singly-linked list predicates would need to unfold the data-content manually. Many other datatypes unluckily have more than just two @@ -466,15 +466,15 @@ \subsection{Monochotomies} \subsection{Other guesses} The base guesses presented above are at the most important ones. However, other -trivial base guesses are exploited as well for the implementation. -The most important ones are point guesses that can be derived +trivial base guesses are exploited as well for the implementation. +The most important ones are point guesses that can be derived from some context information: % \begin{lemma}[Context Guesses]\label{lemma_guesses_context} \[ \begin{array}{l@{\quad\quad}l} P(c) \Longrightarrow \GEP(K\ c,\ \lambda x.\ P(x)) \\ -\neg P(c) \Longrightarrow \GUP(K\ c,\ \lambda x.\ P(x)) +\neg P(c) \Longrightarrow \GUP(K\ c,\ \lambda x.\ P(x)) \end{array} \] \end{lemma} @@ -484,11 +484,11 @@ \subsection{Other guesses} implement lifting efficiently: % \begin{lemma}[Guesses for Constants]\label{lemma_guesses_const} -Given a term $c$ such that a variable $x$ does not occur in $c$, any term $i$ is a -valid existential and universal guess: +Given a term $c$ such that a variable $x$ does not occur in $c$, any term $i$ is a +valid existential and universal guess: \[ \begin{array}{l@{\quad\quad}l} -\GE(i,\ \lambda x.\ c) & \GU(i,\ \lambda x.\ c) +\GE(i,\ \lambda x.\ c) & \GU(i,\ \lambda x.\ c) \end{array} \] \end{lemma} @@ -528,7 +528,7 @@ \subsection{Disjunction} \[ \begin{array}{l@{\quad}l@{\quad}l} \GEP(i,\ \lambda x.\ P_1(x)) & \Longrightarrow & \GEP(i,\ \lambda x.\ P_1(x) \vee P_2(x)) \\ -\GEP(i,\ \lambda x.\ P_2(x)) & \Longrightarrow & \GEP(i,\ \lambda x.\ P_1(x) \vee P_2(x)) +\GEP(i,\ \lambda x.\ P_2(x)) & \Longrightarrow & \GEP(i,\ \lambda x.\ P_1(x) \vee P_2(x)) \end{array} \] \end{lemma} @@ -556,7 +556,7 @@ \subsection{Disjunction} \[ \begin{array}{l@{\quad}l@{\quad}l} \GUG(i,\ \lambda x.\ P_1(x)) & \Longrightarrow & \GUG(i,\ \lambda x.\ P_1(x) \vee P_2(x)) \\ -\GUG(i,\ \lambda x.\ P_2(x)) & \Longrightarrow & \GUG(i,\ \lambda x.\ P_1(x) \vee P_2(x)) +\GUG(i,\ \lambda x.\ P_2(x)) & \Longrightarrow & \GUG(i,\ \lambda x.\ P_1(x) \vee P_2(x)) \end{array} \] \end{lemma} @@ -576,13 +576,13 @@ \subsection{Disjunction} \end{lemma} For universal guesses it is even more complicated, because the handling of free variables does not fit well. -The guess is not allowed to depend on any free variable (denoted by $K\ i_c$). +The guess is not allowed to depend on any free variable (denoted by $K\ i_c$). \begin{lemma}[Lifting Universal Guesses over Disjunction]\label{lemma_guesses_lift_disj_A} \[ \begin{array}{c@{\quad}c@{\quad}l} \begin{array}{cl} \GU(K\ i_c,\ \lambda x.\ P_1(x)) & \wedge \\ -\GU(K\ i_c,\ \lambda x.\ P_2(x)) +\GU(K\ i_c,\ \lambda x.\ P_2(x)) \end{array} & \Longrightarrow & \GU(K\ i_c,\ \lambda x.\ P_1(x) \vee P_2(x)) \\[1em] \GU(i,\ \lambda x.\ P_1(x)) & \Longrightarrow & \GU(i,\ \lambda x.\ P_1(x) \vee p_2) \\ \GU(i,\ \lambda x.\ P_2(x)) & \Longrightarrow & \GU(i,\ \lambda x.\ p_1 \vee P_2(x)) @@ -648,7 +648,7 @@ \subsection{Other Boolean Operations} \subsection{Quantifiers} -It remains to lift guesses over quantifiers. Let's first consider universal quantification. +It remains to lift guesses over quantifiers. Let's first consider universal quantification. If the guess does depend on the quantified variables, it becomes a free variable of the guess: \begin{lemma}[Lifting Guesses over Universal Quantification (1)]\label{lemma_guesses_lift_forall_1} @@ -680,7 +680,7 @@ \subsection{Quantifiers} (\forall y.\ \GEG(i,\ \lambda x.\ P(x, y)) & \Longrightarrow & \GEG(i,\ \lambda x.\ \forall y.\ P(x, y)) \\ (\forall y.\ \GUP(i,\ \lambda x.\ P(x, y)) & \Longrightarrow & \GUP(i,\ \lambda x.\ \forall y.\ P(x, y)) \\ (\forall y.\ \GU(i,\ \lambda x.\ P(x, y)) & \Longrightarrow & \GU(i,\ \lambda x.\ \forall y.\ P(x, y)) \\ -(\forall y.\ \GUG(i,\ \lambda x.\ P(x, y)) & \Longrightarrow & \GUG(i,\ \lambda x.\ \forall y.\ P(x, y)) +(\forall y.\ \GUG(i,\ \lambda x.\ P(x, y)) & \Longrightarrow & \GUG(i,\ \lambda x.\ \forall y.\ P(x, y)) \end{array} \] \end{lemma} @@ -692,7 +692,7 @@ \subsection{Quantifiers} \[ \begin{array}{c@{\quad}c@{\quad}l} (\forall y.\ \GUP(i,\ \lambda x.\ P(x, y)) & \Longrightarrow & \GUP(i,\ \lambda x.\ \exists! y.\ P(x, y)) \\ -(\forall y.\ \GEG(i,\ \lambda x.\ P(x, y)) & \Longrightarrow & \GEG(i,\ \lambda x.\ \exists! y.\ P(x, y)) +(\forall y.\ \GEG(i,\ \lambda x.\ P(x, y)) & \Longrightarrow & \GEG(i,\ \lambda x.\ \exists! y.\ P(x, y)) \end{array} \] \end{lemma} @@ -701,7 +701,7 @@ \subsection{Quantifiers} \section{Related Techniques}\label{sec_other_techniques} Above base guesses and lifting of guesses have been presented. This section now -briefly discusses other techniques that enhance guess search: +briefly discusses other techniques that enhance guess search: \subsection{Rewrites}\label{subsec_other_techniques_rewrites} @@ -726,7 +726,7 @@ \subsection{Strengthening and Weakening}\label{subsec_other_techniques_imp} \begin{lemma}[Strengthening / Weakening Guesses]\label{lemma_guesses_strengthen_weaken} \[ -\left(\forall x.\ P_1(x) \Rightarrow P_2(x)\right) \Longrightarrow +\left(\forall x.\ P_1(x) \Rightarrow P_2(x)\right) \Longrightarrow \left(\begin{array}{@{}rcl} \forall x.\ \GEP(i, P_1) & \Longrightarrow & \GEP(i,\ \lambda x.\ P_2) \qquad \wedge\\ \forall x.\ \GUG(i, P_1) & \Longrightarrow & \GUG(i,\ \lambda x.\ P_2) \qquad \wedge\\ @@ -742,17 +742,17 @@ \subsection{Strengthening and Weakening}\label{subsec_other_techniques_imp} \subsection{Minimising Variable Occurrences}\label{subsec_varmin} As for example Lemma~\ref{lemma_guesses_lift_disj_E} illustrates, it -is easier to find guesses for a variable if it occurs in fewer +is easier to find guesses for a variable if it occurs in fewer positions. Therefore, the HOL~4 implementation preprocesses the term and tries to minimise the number of occurrences. For example, $\exists x.\ (f (8 + 2) = f (x + 2)) \wedge P (f (x + 2))$ is rewritten to $\exists x.\ (f (8 + 2) = f (x + 2)) \wedge P (f (8 + 2))$ by this prepossessing step. This explains, why this example can be handled, whereas apparently similar ones cannot (see Table~\ref{table_examples}). -The implementation for minimising variable occurrences is based +The implementation for minimising variable occurrences is based on simple rules like $(x = t) \wedge P(x) \ \Longleftrightarrow\ (x = t) \wedge P(t)$ or $x \neq t \vee P(x) -\ \Longleftrightarrow\ x \neq t \vee P(t)$. +\ \Longleftrightarrow\ x \neq t \vee P(t)$. \section{Examples}\label{sec_examples} @@ -761,7 +761,7 @@ \section{Examples}\label{sec_examples} Let's now consider a few examples to see how this methods works in practice. \subsection{Example 1} -Let's start with the example +Let's start with the example $\exists x.\ (\forall y.\ Q(y)\ \wedge\ (x=7)) \ \wedge\ P(x)$. This example cannot be handled by existing tools. However, the lemmata presented above allow to @@ -775,11 +775,11 @@ \subsection{Example 1} \end{array} \] % -With Lemma~\ref{lemma_guesses_usage} we can therefore simplify -$\exists x.\ (\forall y.\ Q(y)\ \wedge\ (x=7)) \ \wedge\ P(x)$ to +With Lemma~\ref{lemma_guesses_usage} we can therefore simplify +$\exists x.\ (\forall y.\ Q(y)\ \wedge\ (x=7)) \ \wedge\ P(x)$ to $(\forall y.\ Q(y)\ \wedge\ (7=7)) \ \wedge\ P(7)$ and with some general infrastructure further to $(\forall y.\ Q(y)) \ \wedge\ P(7)$. -Here, only the trace that succeeds is presented. The search actually produces more guesses. +Here, only the trace that succeeds is presented. The search actually produces more guesses. For example, $\GEP(K\ 7, \lambda x.\ x = 7)$ is derived as well, but then fails to be lifted over the conjunction. @@ -788,11 +788,11 @@ \subsection{Example 2}\label{subsec_Example_2} \[\begin{array}{cc@{\qquad}l} \GUG(\lambda x'.\ \textsf{SOME}(x'), \lambda x.\ x = \textsf{NONE}) & \text{(1)} & \text{from Lemma~\ref{lemma_guesses_dichotomy}} \\ \GUG(\lambda x'.\ \textsf{SOME}(x'), \lambda x.\ \textsf{IS\_NONE}(x)) & \text{(2)} & \text{rewrite of (1)} \\ -\GUG(\lambda x'.\ \textsf{SOME}(x'), \lambda x.\ \textsf{IS\_NONE}(x) \vee P(x)) & \text{(3)} & \text{from (2) and Lemma~\ref{lemma_guesses_lift_disj_SA}} +\GUG(\lambda x'.\ \textsf{SOME}(x'), \lambda x.\ \textsf{IS\_NONE}(x) \vee P(x)) & \text{(3)} & \text{from (2) and Lemma~\ref{lemma_guesses_lift_disj_SA}} \end{array} \] -Therefore, -$\forall x.\ \textsf{IS\_NONE}(x) \vee P(x)$ can be simplified to +Therefore, +$\forall x.\ \textsf{IS\_NONE}(x) \vee P(x)$ can be simplified to $\forall x'.\ P(\textsf{SOME}(x'))$. \subsection{Example 3} @@ -818,8 +818,8 @@ \subsection{Example 3} Thus, we found a guess and can instantiate the quantifier with 8. \subsection{Example 4} -Finally, consider $\big((\forall x.\ P_1(x) \Rightarrow P_2(x)) \wedge P_1(2)\big) \Longrightarrow \exists x.\ P_2(x)$. -First, HOL~4's general infrastructure processes this and allows us to concentrate on +Finally, consider $\big((\forall x.\ P_1(x) \Rightarrow P_2(x)) \wedge P_1(2)\big) \Longrightarrow \exists x.\ P_2(x)$. +First, HOL~4's general infrastructure processes this and allows us to concentrate on $\exists x.\ P_2(x)$, while using (1) $\forall x.\ P_1(x) \Rightarrow P_2(x)$ and (2)~$P_1(2)$ as lemmata. Then guesses can be derived as follows: \[\begin{array}{cc@{\qquad}l} @@ -827,7 +827,7 @@ \subsection{Example 4} \GEP(K\ 2, \lambda x.\ P_2(x)) & \text{(4)} & \text{from (1), (3), Lemma~\ref{lemma_guesses_strengthen_weaken}} \end{array} \] -Thus, we found a guess and can simplify the original goal first to +Thus, we found a guess and can simplify the original goal first to $\big((\forall x.\ P_1(x) \Rightarrow P_2(x)) \wedge P_1(2)\big) \Longrightarrow \textit{true}$ and then further to \textit{true}. @@ -838,7 +838,7 @@ \section{User Interface}\label{sec_interface} The quantifier heuristics library can be found in the sub-directory \texttt{src/quantHeuristics}. The entry point to the framework is the -library \texttt{quantHeuristicsLib}. +library \texttt{quantHeuristicsLib}. \subsection{Conversions} Usually the library is used for @@ -851,15 +851,15 @@ \subsection{Conversions} \texttt{QUANT\_INSTANTIATE\_CONV} & \texttt{: quant\_param list -> conv} \\ \texttt{QUANT\_INST\_ss} & \texttt{: quant\_param list -> ssfrag} \\ \texttt{QUANT\_INSTANTIATE\_TAC} & \texttt{: quant\_param list -> tactic} \\ -\texttt{ASM\_QUANT\_INSTANTIATE\_TAC} & \texttt{: quant\_param list -> tactic} +\texttt{ASM\_QUANT\_INSTANTIATE\_TAC} & \texttt{: quant\_param list -> tactic} \end{tabular} \bigskip All these functions get a list of \emph{quantifier heuristic parameters} as arguments. These parameters essentially configure, which heuristics are used during the guess-search. If an empty list is provided, the tools know about the standard Boolean combinators, equations and context. -\texttt{std\_qp} adds support for common datatypes like pairs or lists. -Quantifier heuristic parameters are explained in more detail in +\texttt{std\_qp} adds support for common datatypes like pairs or lists. +Quantifier heuristic parameters are explained in more detail in Section~\ref{sec_qps}. So, some simple usage of the quantifier heuristic library looks like: @@ -874,7 +874,7 @@ \subsection{Conversions} Usually, the quantifier heuristics library is used together with the simplifier using \texttt{QUANT\_INST\_ss}. Besides interleaving -simplification and quantifier instantiation, this has the benefit of +simplification and quantifier instantiation, this has the benefit of being able to use context information collected by the simplifier: {\scriptsize @@ -917,8 +917,8 @@ \subsection{Unjustified Guesses} However, $2$ looks tempting and is probably sensible in many situations. (Counterexample: $P(2)$, $\neg Q(2)$ and $\neg P(3)$ hold) -\texttt{implication\_concl\_qp} is a quantifier parameter that looks for valid guesses in the conclusion of an implication. -Then, it assumes without justification that these guesses are probably sensible for the whole implication as well. +\texttt{implication\_concl\_qp} is a quantifier parameter that looks for valid guesses in the conclusion of an implication. +Then, it assumes without justification that these guesses are probably sensible for the whole implication as well. Because these guesses might be wrong, one can either use implications or expansion theorems like $\exists x. P(x)\ \Leftrightarrow (\forall x.\ (x \neq c) \Rightarrow \neg P(x)) \Rightarrow P(c)$. @@ -927,7 +927,7 @@ \subsection{Unjustified Guesses} > QUANT_INSTANTIATE_CONV [implication_concl_qp] ``?x. P x ==> (x = 2) /\ Q x`` Exception- UNCHANGED raised -> QUANT_INSTANTIATE_CONSEQ_CONV [implication_concl_qp] CONSEQ_CONV_STRENGTHEN_direction +> QUANT_INSTANTIATE_CONSEQ_CONV [implication_concl_qp] CONSEQ_CONV_STRENGTHEN_direction ``?x. P x ==> (x = 2) /\ Q x`` val it = |- (P 2 ==> Q 2) ==> ?x. P x ==> (x = 2) /\ Q x: thm @@ -950,12 +950,12 @@ \subsection{Unjustified Guesses} \texttt{QUANT\_INSTANTIATE\_CONSEQ\_CONV} & \texttt{: quant\_param list -> directed\_conseq\_conv} \\ \texttt{EXPAND\_QUANT\_INSTANTIATE\_CONV} & \texttt{: quant\_param list -> conv} \\ \texttt{EXPAND\_QUANT\_INST\_ss} & \texttt{: quant\_param list -> ssfrag} \\ -\texttt{QUANT\_INSTANTIATE\_CONSEQ\_TAC} & \texttt{: quant\_param list -> tactic} +\texttt{QUANT\_INSTANTIATE\_CONSEQ\_TAC} & \texttt{: quant\_param list -> tactic} \end{tabular} \subsection{Debugging} -To debug the guess-search, it is possible to print tracing information. +To debug the guess-search, it is possible to print tracing information. This is done by setting the trace \texttt{QUANT\_INSTANTIATE\_HEURISTIC} to 1 or 2. For the example in Sec.~\ref{subsec_Example_2} the debug output looks like: @@ -1019,7 +1019,7 @@ \subsection{Interface Details} \item[\texttt{re\ :\ bool}] redescent into a term after some instantiation has been found? It determines, whether internally \texttt{DEPTH\_CONV} or \texttt{REDEPTH\_CONV} is used. - \item[\texttt{min\_var\_occs\ :\ bool}] add a preprocessing step to minimise the number of occurrences of + \item[\texttt{min\_var\_occs\ :\ bool}] add a preprocessing step to minimise the number of occurrences of a variable (see Sec.\ref{subsec_varmin}). Since this preprocessing might be slow, one might want to skip it. \item[\texttt{expand\ :\ bool}] use expansion to exploit unjustified guesses? @@ -1038,7 +1038,7 @@ \subsection{Interface Details} arguments, except \texttt{expand} and \texttt{ctx}. Since it can use implications, expansion is not needed. Because \texttt{DEPTH\_CONSEQ\_CONV} collects its own context and can't easily -be used with the simplifier anyhow, \texttt{ctx} is unnecessary. +be used with the simplifier anyhow, \texttt{ctx} is unnecessary. \texttt{EXTENSIBLE\_QUANT\_INST\_ss} is a wrapper of the conversion that removes the arguments \texttt{re} and \texttt{ctx}, because they are taken care of by the simplifier. @@ -1055,8 +1055,8 @@ \subsection{Explicit Instantiations} A special (slightly degenerated) use of the framework, is turning guess search off completely and providing instantiations explicitly. The tactic \texttt{QUANT\_TAC} allows this. This means that it allows to partially instantiate quantifiers at subpositions -with explicitly given terms. As such, it can be seen as -a generalisation of \texttt{EXISTS\_TAC}. +with explicitly given terms. As such, it can be seen as +a generalisation of \texttt{EXISTS\_TAC}. % {\scriptsize \begin{verbatim} @@ -1086,8 +1086,8 @@ \section{Quantifier Heuristic Parameters}\label{sec_qps} \subsection{Quantifier Heuristic Parameters for Common Datatypes} -There are \texttt{option\_qp}, \texttt{list\_qp}, \texttt{num\_qp} and \texttt{sum\_qp} for option types, lists, -natural numbers and sum types respectively. +There are \texttt{option\_qp}, \texttt{list\_qp}, \texttt{num\_qp} and \texttt{sum\_qp} for option types, lists, +natural numbers and sum types respectively. Some examples are displayed in the following table: % \[\begin{array}{r@{\quad \Longleftrightarrow \quad}l} @@ -1095,13 +1095,13 @@ \subsection{Quantifier Heuristic Parameters for Common Datatypes} \forall x.\ \texttt{IS\_NONE}(x)& \textit{false} \\ \forall l.\ l \neq [\,] \Rightarrow P(l)& \forall h, l'.\ P(h::l') \\ \forall x.\ x = c + 3& \textit{false} \\ -\forall x.\ x \neq 0 \Rightarrow P(x)& \forall x'.\ P(\texttt{SUC}(x')) +\forall x.\ x \neq 0 \Rightarrow P(x)& \forall x'.\ P(\texttt{SUC}(x')) \end{array}\] \subsection{Quantifier Heuristic Parameters for Tuples} For tuples the situation is peculiar, because each quantifier over a variable of a product type -can be instantiated. The challenge is to decide which quantifiers should be instantiated and +can be instantiated. The challenge is to decide which quantifiers should be instantiated and which new variable names to use for the components of the pair. There is a quantifier heuristic parameter called \texttt{pair\_default\_qp}. It first looks for subterms of the form $(\lambda (x_1, \ldots, x_n).\ \ldots)\ x$. If such a term is found, $x$ is instantiated with @@ -1110,7 +1110,7 @@ \subsection{Quantifier Heuristic Parameters for Tuples} % \[\begin{array}{r@{\quad \Longleftrightarrow \quad}l} \forall p.\ (x = \texttt{SND}(p)) \Rightarrow P(p)& \forall p_1.\ P(p_1, x) \\ -\exists p.\ (\lambda (p_a, p_b, p_c). P(p_a, p_b, p_c))\ p & \exists p_a, p_b, p_c.\ P(p_a, p_b, p_c) +\exists p.\ (\lambda (p_a, p_b, p_c). P(p_a, p_b, p_c))\ p & \exists p_a, p_b, p_c.\ P(p_a, p_b, p_c) \end{array}\] \texttt{pair\_default\_qp} is implemented in terms of the more general @@ -1122,7 +1122,7 @@ \subsection{Quantifier Heuristic Parameters for Tuples} is not instantiated. In the example of $\exists p.\ (\lambda (p_a, p_b, p_c). P(p_a, p_b, p_c))\ p$ these functions are given the variable $p$ and the term $(\lambda (p_a, p_b, p_c). P(p_a, p_b, -p_c))\ p$ and return $\texttt{SOME} (p_a, p_b, p_c)$. +p_c))\ p$ and return $\texttt{SOME} (p_a, p_b, p_c)$. \subsection{Quantifier Heuristic Parameter for Records} @@ -1163,20 +1163,20 @@ \section{User defined Quantifier Heuristic Parameters}\label{sec_qps_user} \subsection{Rewrites / Conversions} -As discussed in Sec.~\ref{subsec_other_techniques_rewrites}, adding +As discussed in Sec.~\ref{subsec_other_techniques_rewrites}, adding rewrites is a very powerful technique. \texttt{rewrite\_qp} allows to provide rewrites in the form of rewrite theorems. For the example of \texttt{IS\_SOME} discussed in Sec.~\label{subsec_other_techniques_rewrites} this looks like: {\scriptsize \begin{verbatim} -> val thm = QUANT_INSTANTIATE_CONV [] ``!x. IS_SOME x ==> P x`` +> val thm = QUANT_INSTANTIATE_CONV [] ``!x. IS_SOME x ==> P x`` Exception- UNCHANGED raised > val IS_SOME_EXISTS = prove (``IS_SOME x = (?x'. x = SOME x')``, Cases_on `x` THEN SIMP_TAC std_ss []); val IS_SOME_EXISTS = |- IS_SOME x <=> ?x'. x = SOME x': thm -> val thm = QUANT_INSTANTIATE_CONV [rewrite_qp[IS_SOME_EXISTS]] ``!x. IS_SOME x ==> P x`` +> val thm = QUANT_INSTANTIATE_CONV [rewrite_qp[IS_SOME_EXISTS]] ``!x. IS_SOME x ==> P x`` val thm = |- (!x. IS_SOME x ==> P x) <=> !x'. IS_SOME (SOME x') ==> P (SOME x'): thm \end{verbatim}} @@ -1185,7 +1185,7 @@ \subsection{Rewrites / Conversions} {\scriptsize \begin{verbatim} -> val thm = QUANT_INSTANTIATE_CONV [rewrite_qp[IS_SOME_EXISTS], final_rewrite_qp[option_CLAUSES]] +> val thm = QUANT_INSTANTIATE_CONV [rewrite_qp[IS_SOME_EXISTS], final_rewrite_qp[option_CLAUSES]] ``!x. IS_SOME x ==> P x`` val thm = |- (!x. IS_SOME x ==> P x) <=> !x'. P (SOME x'): thm \end{verbatim}} @@ -1194,7 +1194,7 @@ \subsection{Rewrites / Conversions} {\scriptsize \begin{verbatim} -> val thm = QUANT_INSTANTIATE_CONV [] ``?x. (\y. y = 2) x`` +> val thm = QUANT_INSTANTIATE_CONV [] ``?x. (\y. y = 2) x`` Exception- UNCHANGED raised > val thm = QUANT_INSTANTIATE_CONV [convs_qp[BETA_CONV]] ``?x. (\y. y = 2) x`` @@ -1209,7 +1209,7 @@ \subsection{Strengthening / Weakening} {\scriptsize \begin{verbatim} -> val thm = QUANT_INSTANTIATE_CONV [list_qp] ``!l. 0 < LENGTH l ==> P l`` +> val thm = QUANT_INSTANTIATE_CONV [list_qp] ``!l. 0 < LENGTH l ==> P l`` Exception- UNCHANGED raised > val LENGTH_LESS_IMP = prove (``!l n. n < LENGTH l ==> l <> []``, Cases_on `l` THEN SIMP_TAC list_ss []); @@ -1220,27 +1220,27 @@ \subsection{Strengthening / Weakening} |- (!l. 0 < LENGTH l ==> P l) <=> !l_t l_h. 0 < LENGTH (l_h::l_t) ==> P (l_h::l_t): thm -> val thm = SIMP_CONV (list_ss ++ QUANT_INST_ss [imp_qp[LENGTH_LESS_IMP], list_qp]) [] +> val thm = SIMP_CONV (list_ss ++ QUANT_INST_ss [imp_qp[LENGTH_LESS_IMP], list_qp]) [] ``!l. SUC (SUC n) < LENGTH l ==> P l`` val thm = |- (!l. SUC (SUC n) < LENGTH l ==> P l) <=> !l_h l_t_h l_t_t_t l_t_t_h. n < SUC (LENGTH l_t_t_t) ==> P (l_h::l_t_h::l_t_t_h::l_t_t_t): thm \end{verbatim}} - + \subsection{Filtering} -Sometimes, one might want to avoid to instantiate certain quantifiers. +Sometimes, one might want to avoid to instantiate certain quantifiers. The function \texttt{filter\_qp} allows to add ML-functions that filter the handled -quantifiers. These functions are given a variable $x$ and a term $P(x)$. +quantifiers. These functions are given a variable $x$ and a term $P(x)$. The tool only tries to find instantiate $x$ in $P(x)$, if all filter functions -return \textit{true}. +return \textit{true}. {\scriptsize \begin{verbatim} > val thm = QUANT_INSTANTIATE_CONV [] ``?x y z. (x = 1) /\ (y = 2) /\ (z = 3) /\ P (x, y, z)`` val thm = |- (?x y z. (x = 1) /\ (y = 2) /\ (z = 3) /\ P (x,y,z)) <=> P (1,2,3): thm -> val thm = QUANT_INSTANTIATE_CONV [filter_qp [fn v => fn t => (v = ``y:num``)]] +> val thm = QUANT_INSTANTIATE_CONV [filter_qp [fn v => fn t => (v = ``y:num``)]] ``?x y z. (x = 1) /\ (y = 2) /\ (z = 3) /\ P (x, y, z)`` val thm = |- (?x y z. (x = 1) /\ (y = 2) /\ (z = 3) /\ P (x,y,z)) <=> ?x z. (x = 1) /\ (z = 3) /\ P (x,2,z): thm @@ -1248,8 +1248,8 @@ \subsection{Filtering} \subsection{Satisfying and Contradicting Instantiations} -As the satisfy library\footnote{see \texttt{src/simp/src/Satisfy.sml}} demonstrates, it is often -useful to use unification and explicitly given theorems to +As the satisfy library\footnote{see \texttt{src/simp/src/Satisfy.sml}} demonstrates, it is often +useful to use unification and explicitly given theorems to find instantiations. In addition to satisfying instantiations, the quantifier heuristics framework is also able to use contradicting ones. The theorems used for finding instantiations usually come from the context. However, \texttt{instantiation\_qp} allows to add additional ones: @@ -1259,7 +1259,7 @@ \subsection{Satisfying and Contradicting Instantiations} > val thm = SIMP_CONV (std_ss++QUANT_INST_ss[]) [] ``P n ==> ?m:num. n <= m /\ P m`` Exception- UNCHANGED raised -> val thm = SIMP_CONV (std_ss++QUANT_INST_ss[instantiation_qp[arithmeticTheory.LESS_EQ_REFL]]) [] +> val thm = SIMP_CONV (std_ss++QUANT_INST_ss[instantiation_qp[arithmeticTheory.LESS_EQ_REFL]]) [] ``P n ==> ?m:num. n <= m /\ P m`` > val thm = |- P n ==> ?m:num. n <= m /\ P m = T : thm @@ -1269,9 +1269,9 @@ \subsection{Di- and Monochotomies} As discussed in Sec.~\ref{subsec_base_guesses_dichotomies}, dichotomies can be exploited for guess search. \texttt{distinct\_qp} provides an interface to add theorems -of the form $\forall x.\ c_1(x) \neq c_2(x)$. +of the form $\forall x.\ c_1(x) \neq c_2(x)$. \texttt{cases\_qp} expects theorems of the form -$\forall x. \ (x = \exists \fv. c_1(\fv))\ \vee \ldots \vee (x = \exists \fv. c_n(\fv))$. +$\forall x. \ (x = \exists \fv. c_1(\fv))\ \vee \ldots \vee (x = \exists \fv. c_n(\fv))$. These theorems are for $n = 2$ used with Lemma~\ref{lemma_guesses_dichotomy} and for $n=1$ with Lemma~\ref{lemma_guesses_monochotomy}. All other cases are currently ignored. @@ -1294,7 +1294,7 @@ \subsection{Lifting Theorems} occurrence of $P_1 \Leftrightarrow P_2$ with for example $(P_1 \wedge P_2) \vee (\neg P_1 \wedge \neg P_2)$. However, this may lead to an exponential blowup of the size of the original term, since both $P_1$ -and $P_2$ occur twice in the result. Therefore, it is more efficient to +and $P_2$ occur twice in the result. Therefore, it is more efficient to provide a new lifting inference for equivalences. Such a rule can easily be derived using the existing rules for basic Boolean operations. \end{example} @@ -1302,7 +1302,7 @@ \subsection{Lifting Theorems} \subsection{Oracle Guesses} Sometimes, the user does not want to justify guesses. The tactic -\texttt{QUANT\_TAC} is implemented using oracle guesses for example. +\texttt{QUANT\_TAC} is implemented using oracle guesses for example. A simple interface to oracle guesses is provided by \texttt{oracle\_qp}. It expects a ML function that given a variable and a term returns an pair of an instantiation and the free variables in this instantiation. @@ -1325,14 +1325,14 @@ \subsection{Oracle Guesses} \noindent Notice, that an option type is returned and that the function is -allowed to throw \texttt{HOL\_ERR} exceptions. +allowed to throw \texttt{HOL\_ERR} exceptions. With this definition, the call \begin{verbatim} -NORE_QUANT_INSTANTIATE_CONSEQ_CONV [dummy_list_qp] +NORE_QUANT_INSTANTIATE_CONSEQ_CONV [dummy_list_qp] CONSEQ_CONV_STRENGTHEN_direction ``?x:'a list y:'b. P (x, y)`` \end{verbatim} -results in -\verb+(?y x_hd x_tl. P (x_hd::x_tl,y)) ==> ?x y. P (x,y) : thm+. +results in +\verb+(?y x_hd x_tl. P (x_hd::x_tl,y)) ==> ?x y. P (x,y) : thm+. \subsection{User defined Quantifier Heuristics}\label{subsec_user_defined_quantheu} @@ -1352,7 +1352,7 @@ \subsection{User defined Quantifier Heuristics}\label{subsec_user_defined_quanth \chapter{Conclusion}\label{sec_conclusion} -The quantifier heuristic is a powerful tool to instantiate quantifiers. +The quantifier heuristic is a powerful tool to instantiate quantifiers. It subsumes the power of the existing unwind and satisfy libraries. More importantly though, it is very flexible and easily extendable by the user. Moreover, it can be used to instantiate quantifiers using unjustified guesses. diff --git a/src/quantHeuristics/selftest.sml b/src/quantHeuristics/selftest.sml index 3fc3cf62b6..ebc57cf621 100644 --- a/src/quantHeuristics/selftest.sml +++ b/src/quantHeuristics/selftest.sml @@ -19,7 +19,7 @@ let val _ = print ("``\n "); val ct = Timer.startCPUTimer(); val thm_opt = SOME (conv t) handle Interrupt => raise Interrupt - | _ => NONE; + | _ => NONE; val ok = if not (isSome r_opt) then not (isSome thm_opt) else isSome thm_opt andalso diff --git a/src/tfl/src/Defn.sml b/src/tfl/src/Defn.sml index 2e403a9363..08832587ae 100644 --- a/src/tfl/src/Defn.sml +++ b/src/tfl/src/Defn.sml @@ -571,8 +571,8 @@ fun elim_triv_literal_CONV tm = fun checkSV pats SV = let fun get_pat (GIVEN(p,_)) = p | get_pat (OMITTED(p,_)) = p - fun strings_of vlist = - Lib.commafy (List.map (Lib.quote o #1 o dest_var) + fun strings_of vlist = + Lib.commafy (List.map (Lib.quote o #1 o dest_var) (Listsort.sort Term.compare vlist)) in if null SV then () @@ -584,7 +584,7 @@ fun checkSV pats SV = of [] => () | probs => raise ERR "wfrec_eqns" - (String.concat + (String.concat (["the following variables occur both free (schematic) ", "and bound in the definition: \n "] @ strings_of probs)) end diff --git a/src/tfl/src/Induction.sml b/src/tfl/src/Induction.sml index c5c0802a06..dab58326cb 100644 --- a/src/tfl/src/Induction.sml +++ b/src/tfl/src/Induction.sml @@ -165,18 +165,18 @@ val mk = mk_case ty_info FV thy mk in_1 val in -hm = mk_case ty_info FV thy {path=[z], rows=rows} +hm = mk_case ty_info FV thy {path=[z], rows=rows} -val arg0 = {path=[z], rows=rows} +val arg0 = {path=[z], rows=rows} val {path=rstp0, rows = rows0} = el 1 news *) -fun mk_case_choose_column i rows = +fun mk_case_choose_column i rows = let val col_i = map (fn (l, _) => el (i+1) l) rows - val col_i_ok = + val col_i_ok = (all is_var col_i) orelse (all (fn p => Literal.is_literal p orelse is_var p) col_i) orelse (all (fn p => not (Literal.is_pure_literal p) andalso not (is_var p)) col_i) @@ -198,9 +198,9 @@ fun mk_case ty_info FV thy = let val col_index = mk_case_choose_column 0 rows0 val rows = map (fn (pL, rhs) => (bring_to_front_list col_index pL, rhs)) rows0 val (pat_rectangle,rights) = unzip rows - val u_rstp = bring_to_front_list col_index rstp0 + val u_rstp = bring_to_front_list col_index rstp0 val (u, rstp) = (hd u_rstp, tl u_rstp) - val p = hd (fst (hd rows)) + val p = hd (fst (hd rows)) val col0 = map (Lib.trye hd) pat_rectangle val pat_rectangle' = map (Lib.trye tl) pat_rectangle in @@ -305,7 +305,7 @@ fun complete_cases thy = val th0 = ASSUME a_eq_z val rows:row list = map (fn x => ([x], (th0,[]))) pats - val cases_thm0 = mk_case ty_info FV thy {path=[z], rows=rows} + val cases_thm0 = mk_case ty_info FV thy {path=[z], rows=rows} fun mk_pat_pred p = list_mk_exists (free_vars_lr p, mk_eq(a, p)) val cases_tm = list_mk_disj (map mk_pat_pred pats) From 876ff199290730573e44bbb033c5f6b0b25689bd Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Thu, 11 Dec 2014 23:04:56 +1100 Subject: [PATCH 047/718] expand_list to interactively work on a list of subgoals also Tactical.VALID_LT, to check that a list-tactical is valid (expand_list checks validity, expand_listf doesn't) also abbreviations elt, eall, eta, enth to apply (list-)tactic to subgoal(s) --- help/Docfiles/Tactical.FAIL_LT.doc | 21 ++++ help/Docfiles/Tactical.NO_LT.doc | 20 ++++ help/Docfiles/Tactical.NULL_OK_LT.doc | 2 +- help/Docfiles/Tactical.ORELSE_LT.doc | 23 +++++ help/Docfiles/Tactical.REPEAT_LT.doc | 23 +++++ help/Docfiles/Tactical.TRYALL.doc | 28 ++++++ help/Docfiles/Tactical.TRY_LT.doc | 23 +++++ help/Docfiles/Tactical.VALID_LT.doc | 31 ++++++ help/Docfiles/proofManagerLib.eall.doc | 26 +++++ help/Docfiles/proofManagerLib.elt.doc | 23 +++++ help/Docfiles/proofManagerLib.enth.doc | 26 +++++ help/Docfiles/proofManagerLib.eta.doc | 28 ++++++ help/Docfiles/proofManagerLib.expand_list.doc | 95 +++++++++++++++++++ .../Docfiles/proofManagerLib.expand_listf.doc | 47 +++++++++ src/0/Overlay.sml | 3 +- src/1/Tactical.sig | 7 ++ src/1/Tactical.sml | 25 ++++- src/proofman/Manager.sig | 2 + src/proofman/Manager.sml | 10 ++ src/proofman/goalStack.sig | 2 + src/proofman/goalStack.sml | 55 +++++++---- src/proofman/proofManagerLib.sig | 6 ++ src/proofman/proofManagerLib.sml | 16 ++++ 23 files changed, 517 insertions(+), 25 deletions(-) create mode 100644 help/Docfiles/Tactical.FAIL_LT.doc create mode 100644 help/Docfiles/Tactical.NO_LT.doc create mode 100644 help/Docfiles/Tactical.ORELSE_LT.doc create mode 100644 help/Docfiles/Tactical.REPEAT_LT.doc create mode 100644 help/Docfiles/Tactical.TRYALL.doc create mode 100644 help/Docfiles/Tactical.TRY_LT.doc create mode 100644 help/Docfiles/Tactical.VALID_LT.doc create mode 100644 help/Docfiles/proofManagerLib.eall.doc create mode 100644 help/Docfiles/proofManagerLib.elt.doc create mode 100644 help/Docfiles/proofManagerLib.enth.doc create mode 100644 help/Docfiles/proofManagerLib.eta.doc create mode 100644 help/Docfiles/proofManagerLib.expand_list.doc create mode 100644 help/Docfiles/proofManagerLib.expand_listf.doc diff --git a/help/Docfiles/Tactical.FAIL_LT.doc b/help/Docfiles/Tactical.FAIL_LT.doc new file mode 100644 index 0000000000..2228736fae --- /dev/null +++ b/help/Docfiles/Tactical.FAIL_LT.doc @@ -0,0 +1,21 @@ +\DOC FAIL_LT + +\TYPE {FAIL_LT : string -> list_tactic} + +\SYNOPSIS +List-tactic which always fails, with the supplied string. + +\KEYWORDS +tactic. + +\DESCRIBE +Whatever goal list it is applied to, {FAIL_LT s} always fails +with the string {s}. + +\FAILURE +The application of {FAIL_LT} to a string never fails; the resulting +list-tactic always fails. + +\SEEALSO +Tactical.FAIL_TAC, Tactical.ALL_LT, Tactical.NO_LT. +\ENDDOC diff --git a/help/Docfiles/Tactical.NO_LT.doc b/help/Docfiles/Tactical.NO_LT.doc new file mode 100644 index 0000000000..ad9c42b972 --- /dev/null +++ b/help/Docfiles/Tactical.NO_LT.doc @@ -0,0 +1,20 @@ +\DOC NO_LT + +\TYPE {NO_LT : list_tactic} + +\SYNOPSIS +List-tactic which always fails. + +\KEYWORDS +list-tactic. + +\DESCRIBE +Whatever goal list it is applied to, {NO_LT} always fails +with string {`NO_LT`}. + +\FAILURE +Always fails. + +\SEEALSO +Tactical.NO_TAC, Tactical.ALL_LT, Tactical.FAIL_LT +\ENDDOC diff --git a/help/Docfiles/Tactical.NULL_OK_LT.doc b/help/Docfiles/Tactical.NULL_OK_LT.doc index 92893e6b43..4f472d5363 100644 --- a/help/Docfiles/Tactical.NULL_OK_LT.doc +++ b/help/Docfiles/Tactical.NULL_OK_LT.doc @@ -16,7 +16,7 @@ effect. \FAILURE The application of {NULL_OK_LT} to a list-tactic {ltac} never fails. -The resulting list-tactic fails if applies to a non-empty goal list on which +The resulting list-tactic fails if applied to a non-empty goal list on which {ltac} fails. \SEEALSO diff --git a/help/Docfiles/Tactical.ORELSE_LT.doc b/help/Docfiles/Tactical.ORELSE_LT.doc new file mode 100644 index 0000000000..28dbe8f2db --- /dev/null +++ b/help/Docfiles/Tactical.ORELSE_LT.doc @@ -0,0 +1,23 @@ +\DOC ORELSE_LT + +\TYPE {op ORELSE_LT : list_tactic * list_tactic -> list_tactic} + +\SYNOPSIS +Applies first list-tactic, and if it fails, applies the second instead. + +\KEYWORDS +tactical. + +\DESCRIBE +If {ltac1} and {ltac2} are list-tactics, {ltac1 ORELSE_LT ltac2} +is a list-tactic which applies {ltac1} to a goal list, and if it fails, +applies {ltac2} to the goals. + +\FAILURE +The application of {ORELSE_LT} to a pair of list-tactics never fails. +The resulting list-tactic fails if both {ltac1} and {ltac2} fail +when applied to the relevant goals. + +\SEEALSO +Tactical.ORELSE, Tactical.THEN_LT +\ENDDOC diff --git a/help/Docfiles/Tactical.REPEAT_LT.doc b/help/Docfiles/Tactical.REPEAT_LT.doc new file mode 100644 index 0000000000..5a678f7fbd --- /dev/null +++ b/help/Docfiles/Tactical.REPEAT_LT.doc @@ -0,0 +1,23 @@ +\DOC REPEAT_LT + +\TYPE {REPEAT_LT : (list_tactic -> list_tactic)} + +\SYNOPSIS +Repeatedly applies a list-tactic until it fails. + +\KEYWORDS +tactical. + +\DESCRIBE +The list-tactic {REPEAT_LT ltac} is a list-tactic which applies {ltac} +to a goal list, and while it succeeds, +continues applying it to the resulting subgoal list. + +\FAILURE +The application of {REPEAT_LT} to a list-tactic never fails, +and neither does the composite list-tactic, +even if the basic list-tactic fails immediately. + +\SEEALSO +Tactical.REPEAT, Tactical.THEN_LT. +\ENDDOC diff --git a/help/Docfiles/Tactical.TRYALL.doc b/help/Docfiles/Tactical.TRYALL.doc new file mode 100644 index 0000000000..5417836052 --- /dev/null +++ b/help/Docfiles/Tactical.TRYALL.doc @@ -0,0 +1,28 @@ +\DOC TRYALL + +\TYPE {TRYALL : tactic -> list_tactic} + +\SYNOPSIS +Tries to apply a tactic to every goal in a list + +\KEYWORDS +tactical, list-tactic. + +\DESCRIBE +If {tac} is a tactic, {TRYALL tac} is a list-tactic which, +when applied to a list of goals, +applies the tactic {tac} to each goal for which it succeeds. +When {tac} fails on a goal, {TRYALL tac} has no effect on that goal. + +\FAILURE +The application of {TRYALL} to a tactic never fails. +The resulting list-tactic never fails. + +\EXAMPLE +Where {tac1} and {tac2} are tactics, +{tac1 THEN_LT TRYALL tac2} is equivalent to {tac1 THEN TRY tac2} + +\SEEALSO +Tactical.TRY, Tactical.THEN_LT, Tactical.THEN, Tactical.TRY, Tactical.ALLGOALS +\ENDDOC + diff --git a/help/Docfiles/Tactical.TRY_LT.doc b/help/Docfiles/Tactical.TRY_LT.doc new file mode 100644 index 0000000000..5ad6518d8a --- /dev/null +++ b/help/Docfiles/Tactical.TRY_LT.doc @@ -0,0 +1,23 @@ +\DOC TRY_LT + +\TYPE {TRY_LT : (list_tactic -> list_tactic)} + +\SYNOPSIS +Makes a list-tactic have no effect rather than fail. + +\KEYWORDS +tactical, failure. + +\DESCRIBE +For any list-tactic {ltac}, the application {TRY_LT ltac} +gives a new list-tactic which has the same effect as {ltac} if that succeeds, +and otherwise has no effect. + +\FAILURE +The application of {TRY_LT} to a list-tactic never fails. The resulting +list-tactic never fails. + +\SEEALSO +Tactical.TRY + +\ENDDOC diff --git a/help/Docfiles/Tactical.VALID_LT.doc b/help/Docfiles/Tactical.VALID_LT.doc new file mode 100644 index 0000000000..fef1355eb9 --- /dev/null +++ b/help/Docfiles/Tactical.VALID_LT.doc @@ -0,0 +1,31 @@ +\DOC VALID_LT + +\TYPE {VALID_LT : tactic -> tactic} + +\SYNOPSIS +Makes a list-tactic fail if it would otherwise return an invalid proof. + +\DESCRIBE +When list-tactic {ltac} is applied to a goal list {gl} +it produces new goal list {gl'} and a justification. +When the justification is applied to a list {thl'} of theorems +which are the new goals {gl'}, proved, it should produce a list {thl} +of theorems which are the goals {gl}, proved. + +Precisely, for each goal {(asl, g)} in {gl}, the corresponding theorem in {thl} +should be {A |- g}, with {A} a subset of {asl}. +If this is not the case, then the list-tactic is invalid, +and {VALID_LT ltac gl} fails (raises an exception). +Otherwise, {VALID_LT ltac gl} behaves the same as {ltac gl}. + +\FAILURE +{VALID_LT ltac gl} fails by design if {ltac gl} produces new goals and +justification which do not prove the given goals {gl}. +Also fails if its {ltac gl} fails. + +\SEEALSO +Tactical.VALID, +proofManagerLib.expand_list. + +\ENDDOC + diff --git a/help/Docfiles/proofManagerLib.eall.doc b/help/Docfiles/proofManagerLib.eall.doc new file mode 100644 index 0000000000..59684655ad --- /dev/null +++ b/help/Docfiles/proofManagerLib.eall.doc @@ -0,0 +1,26 @@ +\DOC eall + +\TYPE {eall : tactic -> proof} + +\SYNOPSIS +Applies a tactic to all goals in the current goal list, +replacing the list with the resulting subgoals. + +\DESCRIBE +{eall tac} applies {tac} to all the goals in the current goal list, +replacing the goal list with the list of all the resulting subgoals. +It is an abbreviation for {expand_list (ALLGOALS tac)}. + +\USES +For interactively constructing suitable compound tactics: +in an interactive proof, the effect of {e (tac1 THEN tac2)} +can be obtained by {e tac1} and then {eall tac2}. + +\SEEALSO +proofManagerLib.expand_list, +proofManagerLib.elt, +Tactical.ALLGOALS, +proofManagerLib.eta, +proofManagerLib.set_goal. + +\ENDDOC diff --git a/help/Docfiles/proofManagerLib.elt.doc b/help/Docfiles/proofManagerLib.elt.doc new file mode 100644 index 0000000000..d015d54264 --- /dev/null +++ b/help/Docfiles/proofManagerLib.elt.doc @@ -0,0 +1,23 @@ +\DOC elt + +\TYPE {elt : list_tactic -> proof} + +\SYNOPSIS +Applies a list-tactic to the current goal list, +replacing it with the resulting subgoals. + +\DESCRIBE +The function {elt} is part of the subgoal package. It is an abbreviation for +{expand_list}. For a description of the subgoal package, see {set_goal}. + +\FAILURE +As for {expand_list}. + +\USES +Doing a step in an interactive goal-directed proof, +where the step may affect the list of goals produced by the previous step. + +\SEEALSO +proofManagerLib.expand_list, proofManagerLib.set_goal. + +\ENDDOC diff --git a/help/Docfiles/proofManagerLib.enth.doc b/help/Docfiles/proofManagerLib.enth.doc new file mode 100644 index 0000000000..89c00c1201 --- /dev/null +++ b/help/Docfiles/proofManagerLib.enth.doc @@ -0,0 +1,26 @@ +\DOC enth + +\TYPE {enth : tactic -> int -> proof} + +\SYNOPSIS +Applies a tactic to one goal, referenced by number, in the current goal list, +replacing that goal with the resulting subgoals. + +\DESCRIBE +{enth tac i} applies {tac} to all the i'th goal in the current goal list, +replacing that goal in the goal list with the subgoals produced by {tac}. +It is an abbreviation for {expand_list (NTH_GOAL tac i)}. + +\USES +For interactively constructing suitable compound tactics, +for example to test whether a particular subgoal can be proved easily, +before attacking the other subgoals. + +\SEEALSO +proofManagerLib.expand_list, +proofManagerLib.elt, +Tactical.NTH_GOAL, +proofManagerLib.set_goal, +proofManagerLib.r. + +\ENDDOC diff --git a/help/Docfiles/proofManagerLib.eta.doc b/help/Docfiles/proofManagerLib.eta.doc new file mode 100644 index 0000000000..b64a4424b7 --- /dev/null +++ b/help/Docfiles/proofManagerLib.eta.doc @@ -0,0 +1,28 @@ +\DOC eta + +\TYPE {eta : tactic -> proof} + +\SYNOPSIS +Applies a tactic to all goals, on which it succeeds, in the current goal list, +replacing the list with the resulting subgoals. + +\DESCRIBE +{eta tac} tries to apply {tac} to all the goals in the current goal list; +replacing the goal list with the list of all the resulting subgoals. +If it fails on a goal, it has no effect on that goal. +It is an abbreviation for {expand_list (TRYALL tac)}. + +\USES +For interactively constructing suitable compound tactics: +in an interactive proof, the effect of {e (tac1 THEN TRY tac2)} +can be obtained by {e tac1} and then {eta tac2}. + +\SEEALSO +proofManagerLib.expand_list, +proofManagerLib.elt, +Tactical.TRYALL, +Tactical.TRY, +proofManagerLib.eall, +proofManagerLib.set_goal. + +\ENDDOC diff --git a/help/Docfiles/proofManagerLib.expand_list.doc b/help/Docfiles/proofManagerLib.expand_list.doc new file mode 100644 index 0000000000..94b71fa0d5 --- /dev/null +++ b/help/Docfiles/proofManagerLib.expand_list.doc @@ -0,0 +1,95 @@ +\DOC expand_list + +\TYPE {expand_list : list_tactic -> proof} + +\SYNOPSIS +Applies a list-tactic to replace the current goal list. + +\DESCRIBE +The function {expand_list} is part of the subgoal package. +It may be abbreviated by the function {elt}. +It applies a tactic to the current goal list (that is, +the list of goals produced by the most recent use of {expand} or {expand_list}) +to give a new proof state. +The previous state is stored on the backup list. If the list-tactic produces +subgoals, the new proof state is formed from the old one by removing the +current goal list from the goal stack and replacing it by the list of subgoals +produced by the list-tactic. +The corresponding justification is modified accordingly, +appropriate to the new goal list. +The new subgoals are printed. If more than one subgoal is produced, they are +printed from the bottom of the stack so that the new current goal is printed +last. + +If a list-tactic solves the current goal list (returns an empty subgoal list), +then its justification is used to prove a corresponding theorem. This theorem +is incorporated into the justification of the parent goal and printed. +That level of goals is removed and the parent +goal is proved using its (new) justification. This process is repeated until a +level with unproven subgoals is reached. The next goal on the goal stack then +becomes the current goal. This goal is printed. If all the subgoals are proved, +the resulting proof state consists of the theorem proved by the justifications. + +The list-tactic applied is a validating version of the list-tactic given. +It ensures that +the justification of the list-tactic does provide a proof of the goals from the +subgoals generated by the tactic. It will cause failure if this is not so. The +tactical {VALID_LT} performs this validation. + +For a description of the subgoal package, see {set_goal}. + +\FAILURE +{expand_list ltac} fails if the tactic {ltac} fails for the current goal list. +It will diverge if the list-tactic diverges for the goal. It will fail if there are no unproven goals. +This could be because no goal has been set using {set_goal} or because +the last goal set has been completely proved. It will also fail in cases when +the list-tactic is invalid. + +\EXAMPLE +{ +> expand_list (ALLGOALS CONJ_TAC) ; +OK.. +NO_PROOFSException- NO_PROOFS raised + +> g `(HD[1;2;3] = 1) /\ (TL[1;2;3] = [2;3])`; +> val it = + Proof manager status: 1 proof. + 1. Incomplete: + Initial goal: + (HD [1; 2; 3] = 1) /\ (TL [1; 2; 3] = [2; 3]) + + : proofs + +> expand CONJ_TAC; +OK.. +2 subgoals: +> val it = + TL [1; 2; 3] = [2; 3] + + + HD [1; 2; 3] = 1 + + : proof + +> expand_list (ALLGOALS (REWRITE_TAC[listTheory.HD,listTheory.TL])) ; +OK.. +val it = + Initial goal proved. + |- (HD [1; 2; 3] = 1) /\ (TL [1; 2; 3] = [2; 3]): + proof + +} + +\USES +Doing a step in an interactive goal-directed proof, +in particular, a step which affects all the subgoals generated by the +preceding step. + +\SEEALSO +proofManagerLib.set_goal, proofManagerLib.restart, +proofManagerLib.backup,proofManagerLib.restore, proofManagerLib.save, +proofManagerLib.set_backup,proofManagerLib.expand, proofManagerLib.expandf, +proofManagerLib.expand_listf, +proofManagerLib.p,proofManagerLib.top_thm, proofManagerLib.top_goal. + +\ENDDOC diff --git a/help/Docfiles/proofManagerLib.expand_listf.doc b/help/Docfiles/proofManagerLib.expand_listf.doc new file mode 100644 index 0000000000..7be69d379e --- /dev/null +++ b/help/Docfiles/proofManagerLib.expand_listf.doc @@ -0,0 +1,47 @@ +\DOC expand_listf + +\TYPE {expand_listf : (list_tactic -> unit)} + +\SYNOPSIS +Applies a list-tactic to the current goal, stacking the resulting subgoals. + +\DESCRIBE +The function {expand_listf} is a faster version of {expand_list}. +It does not use a validated version of the list-tactic. +That is, no check is made that the justification of the list-tactic +does prove the goals from the subgoals it generates. +If an invalid list-tactic is used, +the theorem ultimately proved may not match the goal originally set. +Alternatively, failure may occur when the justifications +are applied in which case the theorem would not be proved. For a description of +the subgoal package, see under {set_goal}. + +\FAILURE +Calling {expand_listf ltac} fails if the list-tactic {ltac} fails +for the current goal list. It will diverge if the list-tactic diverges +for the goals. It will fail if there are no +unproven goals. This could be because no goal has been set using {set_goal} or +because the last goal set has been completely proved. If an invalid tactic, +whose justification actually fails, has been used earlier in the proof, +{expand_listf ltac} may succeed in applying {ltac} and apparently prove +the current goals. It may then fail as it applies the justifications +of the tactics applied earlier. + +\USES +Saving CPU time when doing goal-directed proofs, since the extra validation is +not done. Redoing proofs quickly that are already known to work. + +\COMMENTS +The CPU time saved may cause misery later. +If an invalid tactic or list-tactic is used, this +will only be discovered when the proof has apparently been finished and the +justifications are applied. + +\SEEALSO +proofManagerLib.set_goal, proofManagerLib.restart, +proofManagerLib.backup,proofManagerLib.restore, proofManagerLib.save, +proofManagerLib.set_backup,proofManagerLib.expand, proofManagerLib.expandf, +proofManagerLib.expand_list, +proofManagerLib.p,proofManagerLib.top_thm, proofManagerLib.top_goal. + +\ENDDOC diff --git a/src/0/Overlay.sml b/src/0/Overlay.sml index d8c453f615..b53ff4954a 100644 --- a/src/0/Overlay.sml +++ b/src/0/Overlay.sml @@ -22,7 +22,8 @@ open CoreKernel; between the two. ---------------------------------------------------------------------- *) -infix ++ && |-> THEN THEN1 THENL THEN_LT THENC ORELSE ORELSEC THEN_TCL ORELSE_TCL ?> |> +infix ++ && |-> THEN THEN1 THENL THEN_LT THENC ORELSE ORELSE_LT ORELSEC + THEN_TCL ORELSE_TCL ?> |> (* infixes for THEN shorthands *) infix >> >- >| \\ diff --git a/src/1/Tactical.sig b/src/1/Tactical.sig index 088bbb9597..8abd823372 100644 --- a/src/1/Tactical.sig +++ b/src/1/Tactical.sig @@ -8,6 +8,7 @@ sig val THEN : tactic * tactic -> tactic val THENL : tactic * tactic list -> tactic val ORELSE : tactic * tactic -> tactic + val ORELSE_LT : list_tactic * list_tactic -> list_tactic val THEN1 : tactic * tactic -> tactic val THEN_LT : ('a -> goal list * (thm list -> 'b)) * list_tactic -> 'a -> goal list * (thm list -> 'b) @@ -18,6 +19,7 @@ sig val TACS_TO_LT : tactic list -> list_tactic val NULL_OK_LT : list_tactic -> list_tactic val ALLGOALS : tactic -> list_tactic + val TRYALL : tactic -> list_tactic val NTH_GOAL : tactic -> int -> list_tactic val LASTGOAL : tactic -> list_tactic val HEADGOAL : tactic -> list_tactic @@ -27,11 +29,16 @@ sig val REVERSE_LT : list_tactic val FAIL_TAC : string -> tactic val NO_TAC : tactic + val FAIL_LT : string -> list_tactic + val NO_LT : list_tactic val ALL_TAC : tactic val ALL_LT : list_tactic val TRY : tactic -> tactic + val TRY_LT : list_tactic -> list_tactic val REPEAT : tactic -> tactic + val REPEAT_LT : list_tactic -> list_tactic val VALID : tactic -> tactic + val VALID_LT : list_tactic -> list_tactic val EVERY : tactic list -> tactic val FIRST : tactic list -> tactic val MAP_EVERY : ('a -> tactic) -> 'a list -> tactic diff --git a/src/1/Tactical.sml b/src/1/Tactical.sml index 0b73f26e1e..0217fd5358 100644 --- a/src/1/Tactical.sml +++ b/src/1/Tactical.sml @@ -75,7 +75,7 @@ fun store_thm (name, tm, tac) = (print ("Failed to prove theorem " ^ name ^ ".\n"); Raise e) -infix THEN THENL THEN1 ORELSE THEN_LT +infix THEN THENL THEN1 ORELSE ORELSE_LT THEN_LT (*--------------------------------------------------------------------------- * tac1 THEN_LT ltac2: @@ -186,6 +186,7 @@ fun NULL_OK_LT ltac [] = ([], Lib.I) fun tac1 THENL tacs2 = tac1 THEN_LT NULL_OK_LT (TACS_TO_LT tacs2) ; fun (tac1 ORELSE tac2) g = tac1 g handle HOL_ERR _ => tac2 g +fun (ltac1 ORELSE_LT ltac2) gl = ltac1 gl handle HOL_ERR _ => ltac2 gl (*--------------------------------------------------------------------------- * tac1 THEN1 tac2: A tactical like THEN that applies tac2 only to the @@ -290,12 +291,14 @@ fun REVERSE tac = tac THEN_LT REVERSE_LT ; *---------------------------------------------------------------------------*) fun FAIL_TAC tok (g: goal) = raise ERR "FAIL_TAC" tok +fun FAIL_LT tok (gl: goal list) = raise ERR "FAIL_LT" tok (*--------------------------------------------------------------------------- * Tactic that succeeds on no goals; identity for ORELSE. *---------------------------------------------------------------------------*) fun NO_TAC g = FAIL_TAC "NO_TAC" g +fun NO_LT gl = FAIL_LT "NO_LT" gl (* for testing, redefine THEN1 fun tac1 THEN1 tac2 = tac1 THEN_LT NTH_GOAL (tac2 THEN NO_TAC) 1 ; @@ -311,6 +314,8 @@ val ALL_TAC: tactic = fn (g: goal) => ([g], hd) val ALL_LT: list_tactic = fn (gl: goal list) => (gl, Lib.I) fun TRY tac = tac ORELSE ALL_TAC +fun TRY_LT ltac = ltac ORELSE_LT ALL_LT +fun TRYALL tac = ALLGOALS (TRY tac) ; (*--------------------------------------------------------------------------- * The abstraction around g is essential to avoid looping, due to applicative @@ -318,14 +323,20 @@ fun TRY tac = tac ORELSE ALL_TAC *---------------------------------------------------------------------------*) fun REPEAT tac g = ((tac THEN REPEAT tac) ORELSE ALL_TAC) g +fun REPEAT_LT ltac gl = ((ltac THEN_LT REPEAT_LT ltac) ORELSE_LT ALL_LT) gl (*--------------------------------------------------------------------------- - * Tactical to make any tactic valid. + * Tacticals to make any tactic or list_tactic valid. * * VALID tac * * is the same as "tac", except it will fail in the cases where "tac" * returns an invalid proof. + * + * VALID_LT ltac + * + * is the same as "ltac", except it will fail in the cases where "ltac" + * returns an invalid proof. *---------------------------------------------------------------------------*) local @@ -344,6 +355,16 @@ in then result else raise ERR "VALID" "Invalid tactic" end + + fun VALID_LT (ltac: list_tactic) : list_tactic = + fn gl: goal list => + let + val (result as (glist, prf)) = ltac gl + in + if Lib.all2 achieves (prf (map masquerade glist)) gl + then result + else raise ERR "VALID_LT" "Invalid list-tactic" + end end (*--------------------------------------------------------------------------- diff --git a/src/proofman/Manager.sig b/src/proofman/Manager.sig index 7344a5721f..b1fb138712 100644 --- a/src/proofman/Manager.sig +++ b/src/proofman/Manager.sig @@ -27,6 +27,8 @@ sig (* Applying a tactic to a goal *) val expand : tactic -> proof -> proof val expandf : tactic -> proof -> proof + val expand_list : list_tactic -> proof -> proof + val expand_listf : list_tactic -> proof -> proof val expandv : string * tactic -> proof -> proof (* Seeing what the state of the proof manager is *) diff --git a/src/proofman/Manager.sml b/src/proofman/Manager.sml index 793732f82e..f7269fe9a3 100644 --- a/src/proofman/Manager.sml +++ b/src/proofman/Manager.sml @@ -87,6 +87,16 @@ fun expandf tac (GOALSTACK s) = GOALSTACK (apply (goalStack.expandf tac) s) fun expand tac (GOALSTACK s) = GOALSTACK (apply (goalStack.expand tac) s) | expand tac (GOALTREE t) = GOALTREE (apply (goalTree.expand("",tac)) t); +fun expand_listf ltac (GOALSTACK s) = + GOALSTACK (apply (goalStack.expand_listf ltac) s) + | expand_listf _ _ = + raise ERR "expand_listf" "not implemented for goal trees"; + +fun expand_list ltac (GOALSTACK s) = + GOALSTACK (apply (goalStack.expand_list ltac) s) + | expand_list _ _ = + raise ERR "expand_list" "not implemented for goal trees"; + fun expandv (s,tac) (GOALTREE t) = GOALTREE (apply (goalTree.expand (s,tac)) t) | expandv _ _ = raise ERR "expandv" "not implemented for goal stacks"; diff --git a/src/proofman/goalStack.sig b/src/proofman/goalStack.sig index 28465da3d9..ac4fe37357 100644 --- a/src/proofman/goalStack.sig +++ b/src/proofman/goalStack.sig @@ -8,6 +8,8 @@ sig val expand : tactic -> gstk -> gstk val expandf : tactic -> gstk -> gstk + val expand_list : list_tactic -> gstk -> gstk + val expand_listf : list_tactic -> gstk -> gstk val print_tac : string -> tactic val extract_thm : gstk -> thm val initial_goal : gstk -> goal diff --git a/src/proofman/goalStack.sml b/src/proofman/goalStack.sml index 326d8124e8..aa703dbbec 100644 --- a/src/proofman/goalStack.sml +++ b/src/proofman/goalStack.sml @@ -111,9 +111,10 @@ fun rotate(GSTK{prop=PROVED _, ...}) _ = stack={goals=funpow n rotl goals, validation=validation o funpow n rotr} :: rst}; +local + fun imp_err s = + raise ERR "expandf or expand_listf" ("implementation error: "^s) -local - fun imp_err s = raise ERR "expandf" ("implementation error: "^s) fun return(GSTK{stack={goals=[],validation}::rst, prop as POSED g,final}) = let val th = validation [] in case rst @@ -133,6 +134,21 @@ local | otherwise => imp_err (quote "return") end | return gstk = gstk + + fun expand_msg dpth (GSTK{prop = PROVED _, ...}) = () + | expand_msg dpth (GSTK{prop, final, stack as {goals, ...}::_}) = + let val dpth' = length stack + in if dpth' > dpth + then if (dpth+1 = dpth') + then add_string_cr + (case (length goals) + of 0 => imp_err "1" + | 1 => "1 subgoal:" + | n => (int_to_string n)^" subgoals:") + else imp_err "2" + else cr_add_string_cr "Remaining subgoals:" + end + | expand_msg _ _ = imp_err "3" ; in fun expandf _ (GSTK{prop=PROVED _, ...}) = raise ERR "expandf" "goal has already been proved" @@ -142,27 +158,24 @@ fun expandf _ (GSTK{prop=PROVED _, ...}) = val dpth = length stack val gs = return(GSTK{prop=prop,final=final, stack={goals=glist, validation=vf} :: stack}) - in case gs - of GSTK{prop = PROVED _, ...} => () - | GSTK{prop, final, stack as {goals, ...}::_} => - let val dpth' = length stack - in if dpth' > dpth - then if (dpth+1 = dpth') - then add_string_cr - (case (length goals) - of 0 => imp_err "1" - | 1 => "1 subgoal:" - | n => (int_to_string n)^" subgoals:") - else imp_err "2" - else cr_add_string_cr "Remaining subgoals:" - end - | _ => imp_err "3" - ; - gs - end -end; + in expand_msg dpth gs ; gs end + +(* note - expand_listf, unlike expandf, replaces the top member of the stack *) +fun expand_listf ltac (GSTK{prop=PROVED _, ...}) = + raise ERR "expand_listf" "goal has already been proved" + | expand_listf ltac (GSTK{prop as POSED g, stack = [], final}) = + expand_listf ltac (GSTK{prop = POSED g, + stack = [{goals = [g], validation = hd}], final = final}) + | expand_listf ltac (GSTK{prop, stack as {goals,validation}::rst, final}) = + let val (new_goals, new_vf) = ltac goals + val dpth = length stack - 1 (* because we don't augment the stack *) + val new_gs = return (GSTK{prop=prop, final=final, + stack={goals=new_goals, validation=validation o new_vf} :: rst}) + in expand_msg dpth new_gs ; new_gs end ; +end ; fun expand tac gs = expandf (Tactical.VALID tac) gs; +fun expand_list ltac gs = expand_listf (Tactical.VALID_LT ltac) gs; fun extract_thm (GSTK{prop=PROVED(th,_), ...}) = th | extract_thm _ = raise ERR "extract_thm" "no theorem proved"; diff --git a/src/proofman/proofManagerLib.sig b/src/proofman/proofManagerLib.sig index 8a607afa4b..d6d26ddda9 100644 --- a/src/proofman/proofManagerLib.sig +++ b/src/proofman/proofManagerLib.sig @@ -31,9 +31,15 @@ sig (* Applying a tactic to the current goal *) val e : tactic -> proof + val elt : list_tactic -> proof + val eall : tactic -> proof + val eta : tactic -> proof + val enth : tactic -> int -> proof val et : string * tactic -> proof val expand : tactic -> proof val expandf : tactic -> proof + val expand_list : list_tactic -> proof + val expand_listf : list_tactic -> proof val expandv : string * tactic -> proof (* Seeing what the state of the proof manager is *) diff --git a/src/proofman/proofManagerLib.sml b/src/proofman/proofManagerLib.sml index 49002c5063..a5e705db8a 100644 --- a/src/proofman/proofManagerLib.sml +++ b/src/proofman/proofManagerLib.sml @@ -84,12 +84,28 @@ fun expand tac = top_proof()) handle e => Raise e; +fun expand_listf ltac = + (say "OK..\n"; + the_proofs := Manager.hd_opr (Manager.expand_listf ltac) (proofs()); + top_proof()) + handle e => Raise e; + +fun expand_list ltac = + (say "OK..\n"; + the_proofs := Manager.hd_opr (Manager.expand_list ltac) (proofs()); + top_proof()) + handle e => Raise e; + fun expandv (s,tac) = (say "OK..\n"; the_proofs := Manager.hd_opr (Manager.expandv (s,tac)) (proofs()); top_proof()) handle e => Raise e; +val elt = expand_list ; +fun eall tac = expand_list (Tactical.ALLGOALS tac) ; +fun eta tac = expand_list (Tactical.TRYALL tac) ; +fun enth tac i = expand_list (Tactical.NTH_GOAL tac i) ; val e = expand; val et = expandv; From b3a33fbc0d6d89fc3f73f11405036de6c48bda1d Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Fri, 12 Dec 2014 14:41:40 +0000 Subject: [PATCH 048/718] Add assembly code entry points for some decompiler tools. --- .../l3-machine-code/arm/decompiler/arm_core_decompLib.sig | 1 + .../l3-machine-code/arm/decompiler/arm_core_decompLib.sml | 4 ++++ examples/l3-machine-code/m0/decompiler/m0_core_decompLib.sig | 1 + examples/l3-machine-code/m0/decompiler/m0_core_decompLib.sml | 3 +++ 4 files changed, 9 insertions(+) diff --git a/examples/l3-machine-code/arm/decompiler/arm_core_decompLib.sig b/examples/l3-machine-code/arm/decompiler/arm_core_decompLib.sig index 8e84a6c309..1525c54467 100644 --- a/examples/l3-machine-code/arm/decompiler/arm_core_decompLib.sig +++ b/examples/l3-machine-code/arm/decompiler/arm_core_decompLib.sig @@ -2,6 +2,7 @@ signature arm_core_decompLib = sig val config_for_arm: unit -> unit val l3_triple: string -> helperLib.instruction + val l3_triple_code: string quotation -> helperLib.instruction list val arm_core_decompile: string -> string quotation -> Thm.thm * Thm.thm val arm_core_decompile_code: string -> string quotation -> Thm.thm * Thm.thm end diff --git a/examples/l3-machine-code/arm/decompiler/arm_core_decompLib.sml b/examples/l3-machine-code/arm/decompiler/arm_core_decompLib.sml index 4158ce478c..879e9c738b 100644 --- a/examples/l3-machine-code/arm/decompiler/arm_core_decompLib.sml +++ b/examples/l3-machine-code/arm/decompiler/arm_core_decompLib.sml @@ -19,6 +19,10 @@ val l3_triple = (* utilsLib.cache 10000 String.compare *) (helperLib.instruction_apply rule o spec) +val l3_triple_code = + List.map l3_triple o + (armAssemblerLib.arm_code: string quotation -> string list) + val vars = Term.mk_var ("cond", Type.bool) :: fst (boolSyntax.strip_forall (Thm.concl ARM_ASSERT_def)) diff --git a/examples/l3-machine-code/m0/decompiler/m0_core_decompLib.sig b/examples/l3-machine-code/m0/decompiler/m0_core_decompLib.sig index c1ad4cda37..6b12a784d9 100644 --- a/examples/l3-machine-code/m0/decompiler/m0_core_decompLib.sig +++ b/examples/l3-machine-code/m0/decompiler/m0_core_decompLib.sig @@ -2,6 +2,7 @@ signature m0_core_decompLib = sig val config_for_m0: unit -> unit val m0_triple: string -> helperLib.instruction + val m0_triple_code: string quotation -> helperLib.instruction list val m0_core_decompile: string -> string quotation -> Thm.thm * Thm.thm val m0_core_decompile_code: string -> string quotation -> Thm.thm * Thm.thm end diff --git a/examples/l3-machine-code/m0/decompiler/m0_core_decompLib.sml b/examples/l3-machine-code/m0/decompiler/m0_core_decompLib.sml index 1b816b40a3..14006d8ae4 100644 --- a/examples/l3-machine-code/m0/decompiler/m0_core_decompLib.sml +++ b/examples/l3-machine-code/m0/decompiler/m0_core_decompLib.sml @@ -187,6 +187,9 @@ in [x] => (x, NONE) | [x1, x2] => (x1, SOME x2) | _ => raise ERR "m0_triple" "" + val m0_triple_code = + List.map m0_triple o + (m0AssemblerLib.m0_code: string quotation -> string list) end val vars = Term.mk_var ("cond", Type.bool) :: From 1456dbddb499d2366a9f4cf79fc2de4dba05441a Mon Sep 17 00:00:00 2001 From: Scott Owens Date: Fri, 12 Dec 2014 17:46:15 +0000 Subject: [PATCH 049/718] Add a verified balanced binary tree example This is based on the implementation of weight balanced binary search trees in the ghc Haskell compiler's standard library. comparisonScript.sml has a basic theory of comparisons that return either Less, Greater, or Equal. This is not compatible with the existing totoScript.sml, because I don't require cmp x y = Equal ==> x = y, but it does. osetScript.sml uses the balanced trees to implement sets. Functional correctenss of the operations is verified, along with the balancing properties. --- examples/balanced_bst/balanced_mapScript.sml | 3504 ++++++++++++++++++ examples/balanced_bst/comparisonScript.sml | 327 ++ examples/balanced_bst/osetScript.sml | 357 ++ 3 files changed, 4188 insertions(+) create mode 100644 examples/balanced_bst/balanced_mapScript.sml create mode 100644 examples/balanced_bst/comparisonScript.sml create mode 100644 examples/balanced_bst/osetScript.sml diff --git a/examples/balanced_bst/balanced_mapScript.sml b/examples/balanced_bst/balanced_mapScript.sml new file mode 100644 index 0000000000..5fc12e54d4 --- /dev/null +++ b/examples/balanced_bst/balanced_mapScript.sml @@ -0,0 +1,3504 @@ +open HolKernel boolLib bossLib BasicProvers; +open optionTheory pairTheory stringTheory; +open arithmeticTheory pred_setTheory listTheory finite_mapTheory alistTheory sortingTheory; +open comparisonTheory; +open lcsymtacs; + +val _ = new_theory "balanced_map"; + +(* ------------------------ Preliminaries ------------------------ *) + +val _ = temp_tight_equality (); +val _ = numLib.prefer_num(); + +val list_rel_lem1 = Q.prove ( +`!f l l'. + ~LIST_REL f l l' + ⇒ + ∃n. n ≤ LENGTH l ∧ n ≤ LENGTH l' ∧ LIST_REL f (TAKE n l) (TAKE n l') ∧ + ((n = LENGTH l ∧ n ≠ LENGTH l') ∨ + (n ≠ LENGTH l ∧ n = LENGTH l') ∨ + (n ≠ LENGTH l ∧ n ≠ LENGTH l' ∧ ~f (EL n l) (EL n l')))`, + rw [] >> + `FINITE { n | n ≤ LENGTH l ∧ n ≤ LENGTH l' ∧ LIST_REL f (TAKE n l) (TAKE n l') }` + by (rw [GSPEC_AND, LE_LT1] >> + match_mp_tac FINITE_INTER >> + disj1_tac >> + rw [GSYM count_def]) >> + qabbrev_tac `nset = { n | n ≤ LENGTH l ∧ n ≤ LENGTH l' ∧ LIST_REL f (TAKE n l) (TAKE n l') }` >> + Cases_on `nset = {}` >> + rw [] + >- (fs [markerTheory.Abbrev_def, EXTENSION] >> + qexists_tac `0` >> + rw [] >> + Cases_on `l` >> + Cases_on `l'` >> + fs [] >> + pop_assum (qspecl_then [`0`] mp_tac) >> + rw []) + >- (imp_res_tac MAX_SET_DEF >> + qexists_tac `MAX_SET nset` >> + qabbrev_tac `max_nset = MAX_SET nset` >> + qunabbrev_tac `nset` >> + imp_res_tac in_max_set >> + rfs [] >> + rw [] >> + fs [LESS_OR_EQ] >> + srw_tac [ARITH_ss] [] >> + fs [TAKE_LENGTH_ID] >> + CCONTR_TAC >> + fs [] >> + `LIST_REL f (TAKE (max_nset + 1) l) (TAKE (max_nset + 1) l')` + by (fs [rich_listTheory.TAKE_EL_SNOC, SNOC_APPEND, + rich_listTheory.LIST_REL_APPEND_SING]) >> + `max_nset + 1 ∈ {n | (n < LENGTH l ∨ n = LENGTH l) ∧ (n < LENGTH l' ∨ n = LENGTH l') ∧ LIST_REL f (TAKE n l) (TAKE n l')}` + by srw_tac [ARITH_ss] [] >> + imp_res_tac in_max_set >> + unabbrev_all_tac >> + decide_tac)); + +val list_rel_lem2 = Q.prove ( +`!l l'. + LIST_REL f l l' + ⇒ + ¬∃n. n ≤ LENGTH l ∧ n ≤ LENGTH l' ∧ LIST_REL f (TAKE n l) (TAKE n l') ∧ + ((n = LENGTH l ∧ n ≠ LENGTH l') ∨ + (n ≠ LENGTH l ∧ n = LENGTH l') ∨ + (n ≠ LENGTH l ∧ n ≠ LENGTH l' ∧ ~f (EL n l) (EL n l')))`, + ho_match_mp_tac LIST_REL_ind >> + rw [] >> + CCONTR_TAC >> + fs [] >> + EVERY_CASE_TAC >> + fs [] >> + rw [] + >- (first_x_assum (qspecl_then [`LENGTH l`] mp_tac) >> + rw []) + >- (first_x_assum (qspecl_then [`LENGTH l'`] mp_tac) >> + rw []) + >- (first_x_assum (qspecl_then [`n-1`] mp_tac) >> + rw [] >> + full_simp_tac (srw_ss()++ARITH_ss) [] >> + fs [LIST_REL_EL_EQN] >> + `n - 1 ≤ LENGTH l ∧ n - 1 ≤ LENGTH l'` by decide_tac >> + `n ≤ LENGTH l ∧ n ≤ LENGTH l'` by decide_tac >> + fs [LENGTH_TAKE, rich_listTheory.EL_TAKE] >> + rw [] >> + `0 < n` by decide_tac >> + full_simp_tac (srw_ss()++ARITH_ss) [rich_listTheory.EL_CONS] >> + `PRE n = n - 1` by decide_tac >> + fs [])); + +val list_rel_thm = Q.prove ( +`!f l l'. + LIST_REL f l l' ⇔ + !n. + ¬(n ≤ LENGTH l) ∨ ¬(n ≤ LENGTH l') ∨ ¬LIST_REL f (TAKE n l) (TAKE n l') ∨ + (n ≠ LENGTH l ∨ n = LENGTH l') ∧ + (n = LENGTH l ∨ n ≠ LENGTH l') ∧ + (n = LENGTH l ∨ n = LENGTH l' ∨ f (EL n l) (EL n l'))`, + rw [] >> + eq_tac >> + rw [] >> + imp_res_tac list_rel_lem2 >> + fs [] >> + metis_tac [list_rel_lem1]); + +val list_rel_thm = Q.prove ( +`!f l l'. + LIST_REL f l l' ⇔ + !n. + n ≤ LENGTH l ∧ n ≤ LENGTH l' ∧ LIST_REL f (TAKE n l) (TAKE n l') ∧ + (n ≠ LENGTH l ∨ n ≠ LENGTH l') ⇒ + (n ≠ LENGTH l ∧ n ≠ LENGTH l' ∧ f (EL n l) (EL n l'))`, + metis_tac [list_rel_thm]); + +val _ = bossLib.augment_srw_ss [rewrites + [FUNION_FUPDATE_1,FUNION_ASSOC,FUNION_FEMPTY_2,FUNION_FEMPTY_1,FDOM_DRESTRICT, + DRESTRICT_UNIV]] + +fun fs x = full_simp_tac (srw_ss()++ARITH_ss) x; +fun rfs x = REV_FULL_SIMP_TAC (srw_ss()++ARITH_ss) x; +val rw = srw_tac [ARITH_ss]; + +val fmrw = srw_tac [ARITH_ss, rewrites [FLOOKUP_UPDATE,FLOOKUP_FUNION,FLOOKUP_DRESTRICT, + FUNION_FUPDATE_2,FAPPLY_FUPDATE_THM,FUNION_DEF, DRESTRICT_DEF]]; + +fun inv_to_front_tac tm (g as (asl,w)) = let + val tms = strip_conj w + val (tms1,tms2) = List.partition (fn x => can (find_term (can (match_term tm))) x) tms + val tms = tms1@tms2 + val thm = prove (``^w ⇔ ^(list_mk_conj tms)``, SIMP_TAC (std_ss) [AC CONJ_COMM CONJ_ASSOC]) +in + ONCE_REWRITE_TAC [thm] g +end + +val inv_mp_tac = let + val lemma = PROVE [] ``!A B C D. (A ⇒ B ∧ C) ⇒ (A ∧ (B ∧ C ⇒ D)) ⇒ (B ∧ D)`` +in + fn th => fn (g as (asl,w)) => let + val c = th |> concl + val (xs,b) = strip_forall c + val tm = b |> dest_imp |> snd |> strip_conj |> hd + val tm2 = hd (strip_conj w) + val s = fst (match_term tm tm2) + val th2 = SPECL (map (Term.subst s) xs) th + val th3 = MATCH_MP lemma th2 + in + MATCH_MP_TAC (GEN_ALL th3) g + end +end + +val fdom_eq = PROVE [] ``m1 = m2 ⇒ FDOM m1 = FDOM m2``; + +val TIMES_MIN = Q.prove ( +`!x y z. x * MIN y z = MIN (x * y) (x * z)`, + rw [MIN_DEF] >> + fs []); + +val FCARD_DISJOINT_UNION = Q.prove ( +`!m1 m2. + DISJOINT (FDOM m1) (FDOM m2) ∨ DISJOINT (FDOM m2) (FDOM m1) + ⇒ + FCARD (FUNION m1 m2) = FCARD m1 + FCARD m2`, + rw [DISJOINT_DEF, FCARD_DEF] >> + metis_tac [CARD_UNION, FDOM_FINITE, CARD_DEF, ADD_0, INTER_COMM]); + +val CARD_DISJOINT_UNION = Q.prove ( +`!s1 s2. + FINITE s1 ∧ FINITE s2 + ⇒ + DISJOINT s1 s2 ∨ DISJOINT s2 s1 + ⇒ + CARD (s1 ∪ s2) = CARD s1 + CARD s2`, + rw [DISJOINT_DEF] >> + metis_tac [CARD_UNION, CARD_DEF, ADD_0, INTER_COMM]); + +val FCARD_DRESTRICT = Q.prove ( +`∀m s. FCARD (DRESTRICT m s) = CARD (FDOM m ∩ s)`, + rw [FCARD_DEF, FDOM_DRESTRICT]); + +val DELETE_INTER2 = Q.prove ( +`∀s t x. t ∩ (s DELETE x) = s ∩ t DELETE x`, + metis_tac [DELETE_INTER, INTER_COMM]); + +val POS_CARD_HAS_MEM = Q.prove ( +`!s. FINITE s ⇒ 0 < CARD s ⇒ ?x. x ∈ s`, + Cases_on `s` >> + rw [CARD_INSERT] >> + metis_tac []); + +val all_distinct_up_to_def = Define ` +(all_distinct_up_to cmp [] ⇔ T) ∧ +(all_distinct_up_to cmp (k::t) ⇔ + (∀k'. cmp k k' = Equal ⇒ ~MEM k' t) ∧ all_distinct_up_to cmp t)`; + +val every_case_tac = BasicProvers.EVERY_CASE_TAC; + +(* ------------------------ Finite maps up to key equivalence ------------------------ *) + +val key_set_def = Define ` +key_set cmp k = { k' | cmp k k' = Equal }`; + +val key_set_equiv = Q.store_thm ("key_set_equiv", +`!cmp. + good_cmp cmp + ⇒ + (!k. k ∈ key_set cmp k) ∧ + (!k1 k2. k1 ∈ key_set cmp k2 ⇒ k2 ∈ key_set cmp k1) ∧ + (!k1 k2 k3. k1 ∈ key_set cmp k2 ∧ k2 ∈ key_set cmp k3 ⇒ k1 ∈ key_set cmp k3)`, + rw [key_set_def] >> + metis_tac [good_cmp_def]); + +val key_set_partition = Q.store_thm ("key_set_partition", +`!cmp k1 k2. + good_cmp cmp ∧ + key_set cmp k1 ≠ key_set cmp k2 + ⇒ + DISJOINT (key_set cmp k1) (key_set cmp k2)`, + rw [DISJOINT_DEF, EXTENSION] >> + metis_tac [key_set_equiv]); + +val key_set_eq = Q.store_thm ("key_set_eq", +`!cmp k1 k2. + good_cmp cmp + ⇒ + (key_set cmp k1 = key_set cmp k2 ⇔ cmp k1 k2 = Equal)`, + rw [key_set_def, EXTENSION] >> + metis_tac [cmp_thms, key_set_equiv]); + +val key_set_cmp_def = Define ` +key_set_cmp cmp k ks res ⇔ + !k'. k' ∈ ks ⇒ cmp k k' = res`; + +val key_set_cmp_thm = Q.store_thm ("key_set_cmp_thm", +`!cmp k k' res. + good_cmp cmp + ⇒ + (key_set_cmp cmp k (key_set cmp k') res ⇔ cmp k k' = res)`, + rw [key_set_cmp_def, key_set_def] >> + metis_tac [cmp_thms]); + +val key_set_cmp2_def = Define ` +key_set_cmp2 cmp ks1 ks2 res ⇔ + !k1 k2. k1 ∈ ks1 ∧ k2 ∈ ks2 ⇒ cmp k1 k2 = res`; + +val key_set_cmp2_thm = Q.store_thm ("key_set_cmp2_thm", +`!cmp k k' res. + good_cmp cmp + ⇒ + (key_set_cmp2 cmp (key_set cmp k) (key_set cmp k') res ⇔ cmp k k' = res)`, + rw [key_set_cmp2_def, key_set_def] >> + metis_tac [cmp_thms]); + +(* Maps based on balanced binary trees. Copied from ghc-7.8.3 + * libraries/containers/Data/Map/Base.hs. It starts with the following comment: + +----------------------------------------------------------------------------- +-- | +-- Module : Data.Map.Base +-- Copyright : (c) Daan Leijen 2002 +-- (c) Andriy Palamarchuk 2008 +-- License : BSD-style +-- Maintainer : libraries@haskell.org +-- Stability : provisional +-- Portability : portable +-- +-- An efficient implementation of maps from keys to values (dictionaries). +-- +-- Since many function names (but not the type name) clash with +-- "Prelude" names, this module is usually imported @qualified@, e.g. +-- +-- > import Data.Map (Map) +-- > import qualified Data.Map as Map +-- +-- The implementation of 'Map' is based on /size balanced/ binary trees (or +-- trees of /bounded balance/) as described by: +-- +-- * Stephen Adams, \"/Efficient sets: a balancing act/\", +-- Journal of Functional Programming 3(4):553-562, October 1993, +-- . +-- +-- * J. Nievergelt and E.M. Reingold, +-- \"/Binary search trees of bounded balance/\", +-- SIAM journal of computing 2(1), March 1973. +-- +-- Note that the implementation is /left-biased/ -- the elements of a +-- first argument are always preferred to the second, for example in +-- 'union' or 'insert'. +-- +-- Operation comments contain the operation time complexity in +-- the Big-O notation . +----------------------------------------------------------------------------- + +*) + +val _ = Datatype ` +balanced_map = Tip | Bin num 'k 'v balanced_map balanced_map`; + +val ratio_def = Define ` +ratio = 2`; + +val delta_def = Define ` +delta = 3:num`; + +val size_def = Define ` +(size Tip = 0) ∧ +(size (Bin s k v l r) = s)`; + +val bin_def = Define ` +bin k x l r = Bin (size l + size r + 1) k x l r`; + +val null_def = Define ` +(null Tip = T) ∧ +(null (Bin s k v m1 m2) = F)`; + +val lookup_def = Define ` +(lookup cmp k Tip = NONE) ∧ +(lookup cmp k (Bin s k' v l r) = + case cmp k k' of + | Less => lookup cmp k l + | Greater => lookup cmp k r + | Equal => SOME v)`; + +val member_def = Define ` +(member cmp k Tip = F) ∧ +(member cmp k (Bin s k' v l r) = + case cmp k k' of + | Less => member cmp k l + | Greater => member cmp k r + | Equal => T)`; + +val empty_def = Define ` +empty = Tip`; + +val singleton_def = Define ` +singleton k x = Bin 1 k x Tip Tip`; + +(* Just like the Haskell, but w/o @ patterns *) +val balanceL'_def = Define ` +balanceL' k x l r = + case r of + | Tip => + (case l of + | Tip => Bin 1 k x Tip Tip + | (Bin _ _ _ Tip Tip) => Bin 2 k x l Tip + | (Bin _ lk lx Tip (Bin _ lrk lrx _ _)) => Bin 3 lrk lrx (Bin 1 lk lx Tip Tip) (Bin 1 k x Tip Tip) + | (Bin _ lk lx (Bin s' k' v' l' r') Tip) => Bin 3 lk lx (Bin s' k' v' l' r') (Bin 1 k x Tip Tip) + | (Bin ls lk lx (Bin lls k' v' l' r') (Bin lrs lrk lrx lrl lrr)) => + if lrs < ratio*lls then Bin (1+ls) lk lx (Bin lls k' v' l' r') (Bin (1+lrs) k x (Bin lrs lrk lrx lrl lrr) Tip) + else Bin (1+ls) lrk lrx (Bin (1+lls+size lrl) lk lx (Bin lls k' v' l' r') lrl) (Bin (1+size lrr) k x lrr Tip)) + | (Bin rs _ _ _ _) => + case l of + | Tip => Bin (1+rs) k x Tip r + | (Bin ls lk lx ll lr) => + if ls > delta*rs then + case (ll, lr) of + | (Bin lls _ _ _ _, Bin lrs lrk lrx lrl lrr) => + if lrs < ratio*lls then Bin (1+ls+rs) lk lx ll (Bin (1+rs+lrs) k x lr r) + else Bin (1+ls+rs) lrk lrx (Bin (1+lls+size lrl) lk lx ll lrl) (Bin (1+rs+size lrr) k x lrr r) + | (_, _) => Tip (* error "Failure in Data.Map.balanceL" *) + else Bin (1+ls+rs) k x l r`; + +val balanceR'_def = Define ` +balanceR' k x l r = + case l of + | Tip => + (case r of + | Tip => Bin 1 k x Tip Tip + | (Bin _ _ _ Tip Tip) => Bin 2 k x Tip r + | (Bin _ rk rx Tip (Bin s' k' v' l' r')) => Bin 3 rk rx (Bin 1 k x Tip Tip) (Bin s' k' v' l' r') + | (Bin _ rk rx (Bin _ rlk rlx _ _) Tip) => Bin 3 rlk rlx (Bin 1 k x Tip Tip) (Bin 1 rk rx Tip Tip) + | (Bin rs rk rx (Bin rls rlk rlx rll rlr) (Bin rrs k' v' l' r')) => + if rls < ratio*rrs then Bin (1+rs) rk rx (Bin (1+rls) k x Tip (Bin rls rlk rlx rll rlr)) (Bin rrs k' v' l' r') + else Bin (1+rs) rlk rlx (Bin (1+size rll) k x Tip rll) (Bin (1+rrs+size rlr) rk rx rlr (Bin rrs k' v' l' r'))) + | (Bin ls _ _ _ _) => + case r of + | Tip => Bin (1+ls) k x l Tip + | (Bin rs rk rx rl rr) => + if rs > delta*ls then + case (rl, rr) of + | (Bin rls rlk rlx rll rlr, Bin rrs _ _ _ _) => + if rls < ratio*rrs then Bin (1+ls+rs) rk rx (Bin (1+ls+rls) k x l rl) rr + else Bin (1+ls+rs) rlk rlx (Bin (1+ls+size rll) k x l rll) (Bin (1+rrs+size rlr) rk rx rlr rr) + | (_, _) => Tip (* error "Failure in Data.Map.balanceR" *) + else Bin (1+ls+rs) k x l r`; + +val balanceL_def = Define ` +(balanceL k x Tip Tip = + Bin 1 k x Tip Tip) ∧ +(balanceL k x (Bin s' k' v' Tip Tip) Tip = + Bin 2 k x (Bin s' k' v' Tip Tip) Tip) ∧ +(balanceL k x (Bin _ lk lx Tip (Bin _ lrk lrx _ _)) Tip = + Bin 3 lrk lrx (Bin 1 lk lx Tip Tip) (Bin 1 k x Tip Tip)) ∧ +(balanceL k x (Bin _ lk lx (Bin s' k' v' l' r') Tip) Tip = + Bin 3 lk lx (Bin s' k' v' l' r') (Bin 1 k x Tip Tip)) ∧ +(balanceL k x (Bin ls lk lx (Bin lls k' v' l' r') (Bin lrs lrk lrx lrl lrr)) Tip = + if lrs < ratio*lls then + Bin (1+ls) lk lx (Bin lls k' v' l' r') + (Bin (1+lrs) k x (Bin lrs lrk lrx lrl lrr) Tip) + else + Bin (1+ls) lrk lrx (Bin (1+lls+size lrl) lk lx (Bin lls k' v' l' r') lrl) + (Bin (1+size lrr) k x lrr Tip)) ∧ +(balanceL k x Tip (Bin rs k' v' l' r') = + Bin (1+rs) k x Tip (Bin rs k' v' l' r')) ∧ +(balanceL k x (Bin ls lk lx ll lr) (Bin rs k' v' l' r') = + if ls > delta*rs then + case (ll, lr) of + | (Bin lls _ _ _ _, Bin lrs lrk lrx lrl lrr) => + if lrs < ratio*lls then + Bin (1+ls+rs) lk lx ll (Bin (1+rs+lrs) k x lr (Bin rs k' v' l' r')) + else + Bin (1+ls+rs) lrk lrx (Bin (1+lls+size lrl) lk lx ll lrl) + (Bin (1+rs+size lrr) k x lrr (Bin rs k' v' l' r')) + | (_, _) => Tip (* error "Failure in Data.Map.balanceL" *) + else + Bin (1+ls+rs) k x (Bin ls lk lx ll lr) (Bin rs k' v' l' r'))`; + +val balanceR_def = Define ` +(balanceR k x Tip Tip = + Bin 1 k x Tip Tip) ∧ +(balanceR k x Tip (Bin s' k' v' Tip Tip) = + Bin 2 k x Tip (Bin s' k' v' Tip Tip)) ∧ +(balanceR k x Tip (Bin _ rk rx Tip (Bin s' k' v' l' r')) = + Bin 3 rk rx (Bin 1 k x Tip Tip) (Bin s' k' v' l' r')) ∧ +(balanceR k x Tip (Bin _ rk rx (Bin _ rlk rlx _ _) Tip) = + Bin 3 rlk rlx (Bin 1 k x Tip Tip) (Bin 1 rk rx Tip Tip)) ∧ +(balanceR k x Tip (Bin rs rk rx (Bin rls rlk rlx rll rlr) (Bin rrs k' v' l' r')) = + if rls < ratio*rrs then + Bin (1+rs) rk rx (Bin (1+rls) k x Tip (Bin rls rlk rlx rll rlr)) (Bin rrs k' v' l' r') + else + Bin (1+rs) rlk rlx (Bin (1+size rll) k x Tip rll) + (Bin (1+rrs+size rlr) rk rx rlr (Bin rrs k' v' l' r'))) ∧ +(balanceR k x (Bin ls k' v' l' r') Tip = + Bin (1+ls) k x (Bin ls k' v' l' r') Tip) ∧ +(balanceR k x (Bin ls k' v' l' r') (Bin rs rk rx rl rr) = + if rs > delta*ls then + case (rl, rr) of + | (Bin rls rlk rlx rll rlr, Bin rrs _ _ _ _) => + if rls < ratio*rrs then + Bin (1+ls+rs) rk rx (Bin (1+ls+rls) k x (Bin ls k' v' l' r') rl) rr + else + Bin (1+ls+rs) rlk rlx (Bin (1+ls+size rll) k x (Bin ls k' v' l' r') rll) + (Bin (1+rrs+size rlr) rk rx rlr rr) + | (_, _) => Tip (* error "Failure in Data.Map.balanceR" *) + else + Bin (1+ls+rs) k x (Bin ls k' v' l' r') (Bin rs rk rx rl rr))`; + +val insert_def = Define ` +(insert cmp k v Tip = singleton k v) ∧ +(insert cmp k v (Bin s k' v' l r) = + case cmp k k' of + | Less => balanceL k' v' (insert cmp k v l) r + | Greater => balanceR k' v' l (insert cmp k v r) + | Equal => Bin s k v l r)`; + +val insertR_def = Define ` +(insertR cmp k v Tip = singleton k v) ∧ +(insertR cmp k v (Bin s k' v' l r) = + case cmp k k' of + | Less => balanceL k' v' (insertR cmp k v l) r + | Greater => balanceR k' v' l (insertR cmp k v r) + | Equal => Bin s k' v' l r)`; + +val insertMax_def = Define ` +(insertMax k v Tip = singleton k v) ∧ +(insertMax k v (Bin s k' v' l r) = balanceR k' v' l (insertMax k v r))`; + +val insertMin_def = Define ` +(insertMin k v Tip = singleton k v) ∧ +(insertMin k v (Bin s k' v' l r) = balanceL k' v' (insertMin k v l) r)`; + +val deleteFindMax_def = Define ` +(deleteFindMax (Bin s k x l Tip) = ((k,x),l)) ∧ +(deleteFindMax (Bin s k x l r) = + let (km,r') = deleteFindMax r in + (km,balanceL k x l r')) ∧ +(deleteFindMax Tip = + (ARB,Tip))`; (*(error "Map.deleteFindMax: can not return the maximal element of an empty map", Tip)*) + +val deleteFindMin_def = Define ` +(deleteFindMin (Bin s k x Tip r) = ((k,x),r)) ∧ +(deleteFindMin (Bin s k x l r) = + let (km,l') = deleteFindMin l in + (km,balanceR k x l' r)) ∧ +(deleteFindMin Tip = + (ARB,Tip))`; (*(error "Map.deleteFindMin: can not return the maximal element of an empty map", Tip)*) + +val glue_def = Define ` +(glue Tip r = r) ∧ +(glue l Tip = l) ∧ +(glue l r = + if size l > size r then + let ((km,m),l') = deleteFindMax l in + balanceR km m l' r + else + let ((km,m),r') = deleteFindMin r in + balanceL km m l r')`; + +val delete_def = Define ` +(delete cmp k Tip = Tip) ∧ +(delete cmp k (Bin s k' v l r) = + case cmp k k' of + | Less => balanceR k' v (delete cmp k l) r + | Greater => balanceL k' v l (delete cmp k r) + | Eq => glue l r)`; + +val trim_help_greater_def = Define ` +(trim_help_greater cmp lo (Bin s' k v' l' r) = + if cmp k lo = Less ∨ cmp k lo = Equal then + trim_help_greater cmp lo r + else + Bin s' k v' l' r) ∧ +(trim_help_greater cmp lo Tip = Tip)`; + +val trim_help_lesser_def = Define ` +(trim_help_lesser cmp hi (Bin s' k v' l r') = + if cmp k hi = Greater ∨ cmp k hi = Equal then + trim_help_lesser cmp hi l + else + Bin s' k v' l r') ∧ +(trim_help_lesser cmp lo Tip = Tip)`; + +val trim_help_middle_def = Define ` +(trim_help_middle cmp lo hi (Bin s' k v' l r) = + if cmp k lo = Less ∨ cmp k lo = Equal then + trim_help_middle cmp lo hi r + else if cmp k hi = Greater ∨ cmp k hi = Equal then + trim_help_middle cmp lo hi l + else + Bin s' k v' l r) ∧ +(trim_help_middle lo cmp hi Tip = Tip)`; + +val trim_def = Define ` +(trim cmp NONE NONE t = t) ∧ +(trim cmp (SOME lk) NONE t = trim_help_greater cmp lk t) ∧ +(trim cmp NONE (SOME hk) t = trim_help_lesser cmp hk t) ∧ +(trim cmp (SOME lk) (SOME hk) t = trim_help_middle cmp lk hk t)`; + +val link_def = Define ` +(link k v Tip r = insertMin k v r) ∧ +(link k v l Tip = insertMax k v l) ∧ +(link k v (Bin sizeL ky y ly ry) (Bin sizeR kz z lz rz) = + if delta*sizeL < sizeR then + balanceL kz z (link k v (Bin sizeL ky y ly ry) lz) rz + else if delta*sizeR < sizeL then + balanceR ky y ly (link k v ry (Bin sizeR kz z lz rz)) + else + bin k v (Bin sizeL ky y ly ry) (Bin sizeR kz z lz rz))`; + +val filterLt_help_def = Define ` +(filterLt_help cmp b Tip = Tip) ∧ +(filterLt_help cmp b' (Bin s kx x l r) = + case cmp kx b' of + | Less => link kx x l (filterLt_help cmp b' r) + | Equal => l + | Greater => filterLt_help cmp b' l)`; + +val filterLt_def = Define ` +(filterLt cmp NONE t = t) ∧ +(filterLt cmp (SOME b) t = filterLt_help cmp b t)`; + +val filterGt_help_def = Define ` +(filterGt_help cmp b Tip = Tip) ∧ +(filterGt_help cmp b' (Bin s kx x l r) = + case cmp b' kx of + | Less => link kx x (filterGt_help cmp b' l) r + | Equal => r + | Greater => filterGt_help cmp b' r)`; + +val filterGt_def = Define ` +(filterGt cmp NONE t = t) ∧ +(filterGt cmp (SOME b) t = filterGt_help cmp b t)`; + +val hedgeUnion_def = Define ` +(hedgeUnion cmp blo bhi t1 Tip = t1) ∧ +(hedgeUnion cmp blo bhi Tip (Bin _ kx x l r) = + link kx x (filterGt cmp blo l) (filterLt cmp bhi r)) ∧ +(hedgeUnion cmp blo bhi t1 (Bin _ kx x Tip Tip) = insertR cmp kx x t1) ∧ +(hedgeUnion cmp blo bhi (Bin s kx x l r) t2 = + link kx x (hedgeUnion cmp blo (SOME kx) l (trim cmp blo (SOME kx) t2)) + (hedgeUnion cmp (SOME kx) bhi r (trim cmp (SOME kx) bhi t2)))`; + +val union_def = Define ` +(union cmp Tip t2 = t2) ∧ +(union cmp t1 Tip = t1) ∧ +(union cmp t1 t2 = hedgeUnion cmp NONE NONE t1 t2)`; + +val foldrWithKey_def = Define ` +(foldrWithKey f z' Tip = z') ∧ +(foldrWithKey f z' (Bin _ kx x l r) = + foldrWithKey f (f kx x (foldrWithKey f z' r)) l)`; + +val toAscList_def = Define ` +toAscList t = foldrWithKey (\k x xs. (k,x)::xs) [] t`; + +val compare_def = Define ` +compare cmp1 cmp2 t1 t2 = list_cmp (pair_cmp cmp1 cmp2) (toAscList t1) (toAscList t2)`; + +val map_def = Define ` +(map _ Tip ⇔ Tip) ∧ +(map f (Bin sx kx x l r) ⇔ Bin sx kx (f x) (map f l) (map f r))`; + +val splitLookup_def = Define ` +(splitLookup cmp k Tip = (Tip,NONE,Tip)) ∧ +(splitLookup cmp k (Bin _ kx x l r) = + case cmp k kx of + | Less => + let (lt,z,gt) = splitLookup cmp k l in + let gt' = link kx x gt r in + (lt,z,gt') + | Greater => + let (lt,z,gt) = splitLookup cmp k r in + let lt' = link kx x l lt in + (lt',z,gt) + | Equal => + (l,SOME x,r))`; + +val submap'_def = Define ` +(submap' cmp _ Tip _ = T) ∧ +(submap' cmp _ _ Tip = F) ∧ +(submap' cmp f (Bin _ kx x l r) t = + case splitLookup cmp kx t of + | (lt,NONE,gt) => F + | (lt,SOME y,gt) => f x y ∧ submap' cmp f l lt ∧ submap' cmp f r gt)`; + +val isSubmapOfBy_def = Define ` +isSubmapOfBy cmp f t1 t2 ⇔ size t1 ≤ size t2 ∧ submap' cmp f t1 t2`; + +val isSubmapOf_def = Define ` +isSubmapOf cmp t1 t2 ⇔ isSubmapOfBy cmp (=) t1 t2`; + +(* TODO: The ghc implementation is more complex and efficient *) +val fromList_def = Define ` +fromList cmp l = FOLDR (λ(k,v) t. insert cmp k v t) empty l`; + +(* ----------------------- proofs ------------------------ *) + +val balanceL_ind = fetch "-" "balanceL_ind"; +val balanceR_ind = fetch "-" "balanceR_ind"; + +val balanceL'_thm = Q.prove ( +`!k v l r. balanceL k v l r = balanceL' k v l r`, + ho_match_mp_tac balanceL_ind >> + rw [balanceL_def, balanceL'_def]); + +val balanceR'_thm = Q.prove ( +`!k v l r. balanceR k v l r = balanceR' k v l r`, + ho_match_mp_tac balanceR_ind >> + rw [balanceR_def, balanceR'_def]); + +val to_fmap_def = Define ` +(to_fmap cmp Tip = FEMPTY) ∧ +(to_fmap cmp (Bin s k v l r) = + (FUNION (to_fmap cmp l) (to_fmap cmp r)) |+ (key_set cmp k,v))`; + +val to_fmap_key_set = Q.store_thm ("to_fmap_key_set", +`!cmp ks t. + ks ∈ FDOM (to_fmap cmp t) ⇒ ?k. ks = key_set cmp k`, + Induct_on `t` >> + rw [to_fmap_def] >> + metis_tac []); + +val balanced_def = Define ` +balanced l r ⇔ + l + r ≤ 1 ∨ MAX l r ≤ delta * MIN l r`; + +val structure_size_def = Define ` +(structure_size Tip = 0) ∧ +(structure_size (Bin n k v l r) = 1 + structure_size l + structure_size r)`; + +val key_ordered_def = Define ` +(key_ordered cmp k Tip res ⇔ T) ∧ +(key_ordered cmp k (Bin n k' v l r) res ⇔ + cmp k k' = res ∧ + key_ordered cmp k l res ∧ + key_ordered cmp k r res)`; + +val key_ordered_to_fmap = Q.prove ( +`!cmp k t res. + good_cmp cmp ⇒ + (key_ordered cmp k t res + ⇔ + (!ks. ks ∈ FDOM (to_fmap cmp t) ⇒ key_set_cmp cmp k ks res))`, + Induct_on `t` >> + rw [key_ordered_def, to_fmap_def] >> + eq_tac >> + rw [] >> + metis_tac [key_set_cmp_thm]); + +val invariant_def = Define ` +(invariant cmp Tip ⇔ T) ∧ +(invariant cmp (Bin s k v l r) ⇔ + s = 1 + structure_size l + structure_size r ∧ + key_ordered cmp k l Greater ∧ + key_ordered cmp k r Less ∧ + balanced (size l) (size r) ∧ + invariant cmp l ∧ + invariant cmp r)`; + +val invariant_eq = Q.store_thm ("invariant_eq", +`(invariant cmp Tip ⇔ T) ∧ + (invariant cmp (Bin s k v l r) ⇔ + (good_cmp cmp ⇒ DISJOINT (FDOM (to_fmap cmp l)) (FDOM (to_fmap cmp r))) ∧ + (good_cmp cmp ⇒ key_set cmp k ∉ FDOM (to_fmap cmp l)) ∧ + (good_cmp cmp ⇒ key_set cmp k ∉ FDOM (to_fmap cmp r)) ∧ + s = 1 + structure_size l + structure_size r ∧ + key_ordered cmp k l Greater ∧ + key_ordered cmp k r Less ∧ + balanced (size l) (size r) ∧ + invariant cmp l ∧ + invariant cmp r)`, + rw [invariant_def] >> + eq_tac >> + rw [DISJOINT_DEF, EXTENSION] >> + CCONTR_TAC >> + fs [] >> + imp_res_tac key_ordered_to_fmap >> + fs [] >> + imp_res_tac to_fmap_key_set >> + rw [] >> + rfs [key_set_cmp_thm] >> + metis_tac [cmp_thms]); + +val inv_props = Q.prove ( +`!cmp s k v l r. + good_cmp cmp ∧ + invariant cmp (Bin s k v l r) + ⇒ + DISJOINT (FDOM (to_fmap cmp l)) (FDOM (to_fmap cmp r)) ∧ + (!x. key_set cmp x ∈ FDOM (to_fmap cmp l) ⇒ cmp k x = Greater) ∧ + (!x. key_set cmp x ∈ FDOM (to_fmap cmp r) ⇒ cmp k x = Less)`, + rw [invariant_eq] >> + imp_res_tac key_ordered_to_fmap >> + rfs [key_set_cmp_thm]); + +val structure_size_thm = Q.prove ( +`!cmp t. invariant cmp t ⇒ size t = structure_size t`, + Cases_on `t` >> + rw [size_def, invariant_def, structure_size_def]); + +val structure_size_to_fmap = Q.prove ( +`!cmp t. good_cmp cmp ∧ invariant cmp t ⇒ FCARD (to_fmap cmp t) = structure_size t`, + Induct_on `t` >> + rw [invariant_eq, structure_size_def, to_fmap_def, FCARD_FEMPTY] >> + rw [FCARD_FUPDATE, FCARD_DISJOINT_UNION]); + +val size_thm = Q.store_thm ("size_thm", +`!cmp t. good_cmp cmp ∧ invariant cmp t ⇒ size t = FCARD (to_fmap cmp t)`, + metis_tac [structure_size_thm, structure_size_to_fmap]); + +val null_thm = Q.store_thm ("null_thm", +`!cmp t. null t ⇔ (to_fmap cmp t = FEMPTY)`, + Cases_on `t` >> + rw [null_def, to_fmap_def]); + +val lookup_thm = Q.store_thm ("lookup_thm", +`!cmp k t. + good_cmp cmp ∧ + invariant cmp t + ⇒ + lookup cmp k t = FLOOKUP (to_fmap cmp t) (key_set cmp k)`, + Induct_on `t` >> + rw [lookup_def, to_fmap_def] >> + imp_res_tac inv_props >> + every_case_tac >> + fs [invariant_eq, FLOOKUP_UPDATE, FLOOKUP_FUNION] >> + every_case_tac >> + fs [] >> + rw [] >> + rfs [key_set_eq] >> + fs [FLOOKUP_DEF] >> + metis_tac [cmp_thms]); + +val member_thm = Q.store_thm ("member_thm", +`!cmp k t. + good_cmp cmp ∧ + invariant cmp t + ⇒ + (member cmp k t ⇔ key_set cmp k ∈ FDOM (to_fmap cmp t))`, + Induct_on `t` >> + rw [member_def, to_fmap_def] >> + imp_res_tac inv_props >> + every_case_tac >> + fs [invariant_def, FLOOKUP_UPDATE, FLOOKUP_FUNION] >> + every_case_tac >> + fs [] >> + rw [] >> + rfs [key_set_eq] >> + fs [FLOOKUP_DEF] >> + metis_tac [cmp_thms]); + +val empty_thm = Q.store_thm ("empty_thm", +`!cmp. invariant cmp empty ∧ to_fmap cmp empty = FEMPTY`, + rw [invariant_def, empty_def, to_fmap_def, FCARD_DEF]); + +val singleton_thm = Q.store_thm ("singleton_thm", +`!cmp k v. invariant cmp (singleton k v) ∧ to_fmap cmp (singleton k v) = FEMPTY |+ (key_set cmp k,v)`, + rw [balanced_def, invariant_def, singleton_def, to_fmap_def, size_def, structure_size_def, + key_ordered_def]); + +(* The balance routine from the comments in the Haskell file *) + +val singleL_def = Define ` +singleL k1 x1 t1 (Bin _ k2 x2 t2 t3) = bin k2 x2 (bin k1 x1 t1 t2) t3`; + +val singleR_def = Define ` +singleR k1 x1 (Bin _ k2 x2 t1 t2) t3 = bin k2 x2 t1 (bin k1 x1 t2 t3)`; + +val doubleL_def = Define ` +doubleL k1 x1 t1 (Bin _ k2 x2 (Bin _ k3 x3 t2 t3) t4) = + bin k3 x3 (bin k1 x1 t1 t2) (bin k2 x2 t3 t4)`; + +val doubleR_def = Define ` +doubleR k1 x1 (Bin _ k2 x2 t1 (Bin _ k3 x3 t2 t3)) t4 = + bin k3 x3 (bin k2 x2 t1 t2) (bin k1 x1 t3 t4)`; + +val rotateL_def = Define ` +(rotateL k x l (Bin s' k' x' ly ry) = + if size ly < ratio * size ry then + singleL k x l (Bin s' k' x' ly ry) + else + doubleL k x l (Bin s' k' x' ly ry)) ∧ +(rotateL k x l Tip = + doubleL k x l Tip)`; + +val rotateR_def = Define ` +(rotateR k x (Bin s' k' x' ly ry) r = + if size ry < ratio * size ly then + singleR k x (Bin s' k' x' ly ry) r + else + doubleR k x (Bin s' k' x' ly ry) r) ∧ +(rotateR k x Tip r = + doubleR k x Tip r)`; + +val bal_def = Define ` +bal k x l r = + if size l + size r ≤ 1 then + Bin (size l + size r + 1) k x l r + else if size r > delta * size l then + rotateL k x l r + else if size l > delta * size r then + rotateR k x l r + else + Bin (size l + size r + 1) k x l r`; + +val balL_def = Define ` +balL k x l r = + if size l + size r ≤ 1 then + Bin (size l + size r + 1) k x l r + else if size l > delta * size r then + rotateR k x l r + else + Bin (size l + size r + 1) k x l r`; + +val balR_def = Define ` +balR k x l r = + if size l + size r ≤ 1 then + Bin (size l + size r + 1) k x l r + else if size r > delta * size l then + rotateL k x l r + else + Bin (size l + size r + 1) k x l r`; + +(* We want a formula that states how unbalanced two trees can be + * and still be re-balanced by the balancer. It also has to allow the + * trees to be as unbalanced as the link, insert and delete functions need. The + * formula below is the result of guesswork. *) +val almost_balancedL_def = Define ` +almost_balancedL l r = + if l + r ≤ 1 ∨ l ≤ delta * r then + balanced l r + else if r = 0 then + l < 5 + else if r = 1 then + l < 8 + else + 2 * l < (2 * delta + 3) * r + 2`; + +val almost_balancedR_def = Define ` +almost_balancedR l r = + if l + r ≤ 1 ∨ r ≤ delta * l then + balanced l r + else if l = 0 then + r < 5 + else if l = 1 then + r < 8 + else + 2 * r < (2 * delta + 3) * l + 2`; + +val balanced_lem1 = Q.prove ( +`!l r. l + r ≤ 1 ⇒ balanced l r`, + rw [balanced_def]); + +val balanced_lem2 = Q.prove ( +`!l r. + ¬(l > delta * r) ∧ + almost_balancedL l r ∧ + ¬(l + r ≤ 1) + ⇒ + balanced l r`, + rw [almost_balancedL_def, balanced_def, NOT_LESS_EQUAL, NOT_GREATER, TIMES_MIN, delta_def]); + +val balanced_lem3 = Q.prove ( +`!b b0 r. + almost_balancedL (b + b0 + 1) r ∧ + b + b0 + 1 > delta * r ∧ + b0 < ratio * b ∧ + balanced b b0 + ⇒ + balanced b (b0 + r + 1) ∧ + balanced b0 r`, + rw [almost_balancedL_def, balanced_def, TIMES_MIN, delta_def, ratio_def] >> + fs [MIN_DEF]); + +val balanced_lem4 = Q.prove ( +`!b b' b0' r. + almost_balancedL (b + b' + b0' + 2) r ∧ + b + b' + b0' + 2 > delta * r ∧ + ¬(b' + b0' + 1 < ratio * b) ∧ + balanced b (b' + b0' + 1) ∧ + balanced b' b0' + ⇒ + balanced (b + b' + 1) (b0' + r + 1) ∧ + balanced b b' ∧ + balanced b0' r`, + rw [almost_balancedL_def, balanced_def, TIMES_MIN, delta_def, ratio_def] >> + fs [MIN_DEF]); + +val balanced_lem5 = Q.prove ( +`!l r. + ¬(r > delta * l) ∧ + almost_balancedR l r + ⇒ + balanced l r`, + rw [almost_balancedR_def, balanced_def, NOT_LESS_EQUAL, NOT_GREATER, TIMES_MIN, delta_def]); + +val balanced_lem6 = Q.prove ( +`!b b0 l. + almost_balancedR l (b + b0 + 1) ∧ + b + b0 + 1 > delta * l ∧ + b < ratio * b0 ∧ + balanced b b0 + ⇒ + balanced (b + l + 1) b0 ∧ balanced l b`, + rw [almost_balancedR_def, balanced_def, TIMES_MIN, delta_def, ratio_def] >> + fs [MIN_DEF]); + +val balanced_lem7 = Q.prove ( +`!b b0 b0' l b'. + almost_balancedR l (b' + b0 + b0' + 2) ∧ + b' + b0 + b0' + 2 > delta * l ∧ + ¬(b' + b0' + 1 < ratio * b0) ∧ + balanced (b' + b0' + 1) b0 ∧ + balanced b' b0' + ⇒ + balanced (b' + l + 1) (b0 + b0' + 1) ∧ + balanced l b' ∧ + balanced b0' b0`, + rw [almost_balancedR_def, balanced_def, TIMES_MIN, delta_def, ratio_def] >> + fs [MIN_DEF]); + +val singleR_thm = Q.prove ( +`!k v r cmp n k' v' b b0. + good_cmp cmp ∧ + key_ordered cmp k (Bin n k' v' b b0) Greater ∧ + key_ordered cmp k r Less ∧ + almost_balancedL n (size r) ∧ + ¬(size r + n ≤ 1) ∧ + n > delta * size r ∧ + size b0 < ratio * size b ∧ + invariant cmp (Bin n k' v' b b0) ∧ + invariant cmp r + ⇒ + invariant cmp (singleR k v (Bin n k' v' b b0) r) ∧ + to_fmap cmp (singleR k v (Bin n k' v' b b0) r) = + (FUNION (to_fmap cmp (Bin n k' v' b b0)) (to_fmap cmp r)) |+ (key_set cmp k,v)`, + rw [singleR_def] >> + imp_res_tac inv_props + >- (fs [invariant_def, bin_def, size_def, structure_size_def, bin_def, key_ordered_def] >> + imp_res_tac structure_size_thm >> + rw [size_def] >> + rfs [size_def, key_ordered_to_fmap] >> + rw [] >> + metis_tac [to_fmap_key_set, key_set_cmp_thm, cmp_thms, balanced_lem3, ADD_ASSOC]) + >- (rw [to_fmap_def, bin_def, FUNION_FUPDATE_2, FUNION_FUPDATE_1] >> + fs [to_fmap_def, invariant_def, key_ordered_def] >> + metis_tac [to_fmap_key_set, key_set_cmp_thm, cmp_thms, FUPDATE_COMMUTES, FUNION_ASSOC])); + +val doubleR_thm = Q.prove ( +`!k v r cmp n k' v' b b0. + good_cmp cmp ∧ + key_ordered cmp k (Bin n k' v' b b0) Greater ∧ + key_ordered cmp k r Less ∧ + almost_balancedL n (size r) ∧ + ¬(size r + n ≤ 1) ∧ + n > delta * size r ∧ + ¬(size b0 < ratio * size b) ∧ + invariant cmp (Bin n k' v' b b0) ∧ + invariant cmp r + ⇒ + invariant cmp (doubleR k v (Bin n k' v' b b0) r) ∧ + to_fmap cmp (doubleR k v (Bin n k' v' b b0) r) = + (FUNION (to_fmap cmp (Bin n k' v' b b0)) (to_fmap cmp r)) |+ (key_set cmp k,v)`, + rw [] >> + `structure_size b0 ≠ 0` + by (fs [delta_def, ratio_def, invariant_def, size_def, + NOT_LESS_EQUAL, NOT_LESS, NOT_GREATER] >> + imp_res_tac structure_size_thm >> + fs []) >> + Cases_on `b0` >> + fs [structure_size_def, doubleR_def, bin_def] >> + imp_res_tac inv_props >> + fs [Once invariant_def] >> + imp_res_tac inv_props >> + fs [invariant_def, to_fmap_def] + >- (fs [size_def, bin_def, to_fmap_def] >> + imp_res_tac structure_size_thm >> + simp [structure_size_def, key_ordered_def] >> + fs [structure_size_def, to_fmap_def, key_ordered_def] >> + rfs [key_ordered_to_fmap] >> + rw [] + >- metis_tac [to_fmap_key_set, key_set_cmp_thm, cmp_thms] + >- metis_tac [to_fmap_key_set, key_set_cmp_thm, cmp_thms] + >- metis_tac [to_fmap_key_set, key_set_cmp_thm, cmp_thms] + >- metis_tac [to_fmap_key_set, key_set_cmp_thm, cmp_thms] >> + metis_tac [ADD_ASSOC, balanced_lem4]) + >- (rw [FUNION_FUPDATE_2, FUNION_FUPDATE_1] >> + fs [key_ordered_def] >> + rfs [key_ordered_to_fmap] + >- metis_tac [cmp_thms] + >- metis_tac [cmp_thms] >> + `key_set cmp k' ≠ key_set cmp k'' ∧ + key_set cmp k ≠ key_set cmp k' ∧ + key_set cmp k ≠ key_set cmp k''` + by metis_tac [key_set_eq, cmp_thms] >> + metis_tac [FUPDATE_COMMUTES, FUNION_ASSOC])); + +val rotateR_thm = Q.prove ( +`!k v l r cmp. + good_cmp cmp ∧ + key_ordered cmp k l Greater ∧ + key_ordered cmp k r Less ∧ + ¬(size l + size r ≤ 1) ∧ + size l > delta * size r ∧ + almost_balancedL (size l) (size r) ∧ + invariant cmp l ∧ + invariant cmp r + ⇒ + invariant cmp (rotateR k v l r) ∧ + to_fmap cmp (rotateR k v l r) = + (FUNION (to_fmap cmp l) (to_fmap cmp r)) |+ (key_set cmp k,v)`, + Cases_on `l` + >- fs [size_def] >> + rw [size_def, rotateR_def] >> + metis_tac [singleR_thm, doubleR_thm, ADD_COMM, NOT_ZERO_LT_ZERO, GREATER_DEF]); + +val balanceL_balL = Q.prove ( +`!k v l r cmp. + good_cmp cmp ∧ + invariant cmp l ∧ + invariant cmp r + ⇒ + balanceL k v l r = balL k v l r`, + ho_match_mp_tac balanceL_ind >> + rw [] >> + rw [balanceL_def, balL_def, rotateR_def, doubleR_def, bin_def, singleR_def] >> + imp_res_tac structure_size_thm >> + fs [size_def, invariant_def, structure_size_def] >> + imp_res_tac structure_size_thm >> + fs [balanced_def] >> + TRY (Cases_on `l` >> fs [structure_size_def, size_def] >> NO_TAC) >> + TRY (Cases_on `r` >> fs [structure_size_def, size_def] >> NO_TAC) >> + TRY (fs [ratio_def] >> NO_TAC) >> + every_case_tac >> + fs [size_def, structure_size_def, ratio_def, delta_def] >> + imp_res_tac structure_size_thm >> + fs [invariant_def, doubleR_def, bin_def, size_def] >> + imp_res_tac structure_size_thm >> + rw []); + +val balanceL_thm = Q.prove ( +`!k v l r cmp. + good_cmp cmp ∧ + key_ordered cmp k l Greater ∧ + key_ordered cmp k r Less ∧ + almost_balancedL (size l) (size r) ∧ + invariant cmp l ∧ + invariant cmp r + ⇒ + invariant cmp (balanceL k v l r) ∧ + to_fmap cmp (balanceL k v l r) = + (FUNION (to_fmap cmp l) (to_fmap cmp r)) |+ (key_set cmp k,v)`, + rw [] >> + `balanceL k v l r = balL k v l r` by metis_tac [balanceL_balL] >> + rw [] >> + rw [balL_def, invariant_def] >> + imp_res_tac structure_size_thm >> + rw [balanced_lem1, balanced_lem2, to_fmap_def] >> + metis_tac [rotateR_thm]); + +val singleL_thm = Q.prove ( +`!k v l cmp n k' v' b b0. + good_cmp cmp ∧ + key_ordered cmp k (Bin n k' v' b b0) Less ∧ + key_ordered cmp k l Greater ∧ + almost_balancedR (size l) n ∧ + ¬(size l + n ≤ 1) ∧ + n > delta * size l ∧ + size b < ratio * size b0 ∧ + invariant cmp (Bin n k' v' b b0) ∧ + invariant cmp l + ⇒ + invariant cmp (singleL k v l (Bin n k' v' b b0)) ∧ + to_fmap cmp (singleL k v l (Bin n k' v' b b0)) = + (FUNION (to_fmap cmp l) (to_fmap cmp (Bin n k' v' b b0))) |+ (key_set cmp k,v)`, + rw [singleL_def] >> + imp_res_tac inv_props + >- (fs [invariant_def, bin_def, size_def, structure_size_def, bin_def, key_ordered_def] >> + imp_res_tac structure_size_thm >> + rw [size_def] >> + rfs [size_def, key_ordered_to_fmap] >> + rw [] >> + metis_tac [to_fmap_key_set, key_set_cmp_thm, cmp_thms, balanced_lem6, ADD_ASSOC]) + >- (rw [to_fmap_def, bin_def, FUNION_FUPDATE_2, FUNION_FUPDATE_1] >> + fs [to_fmap_def, invariant_def, key_ordered_def] >> + rfs [key_ordered_to_fmap] >> + metis_tac [to_fmap_key_set, key_set_cmp_thm, cmp_thms, FUPDATE_COMMUTES, FUNION_ASSOC])); + +val doubleL_thm = Q.prove ( +`!k v l cmp n k' v' b b0. + good_cmp cmp ∧ + key_ordered cmp k (Bin n k' v' b b0) Less ∧ + key_ordered cmp k l Greater ∧ + almost_balancedR (size l) n ∧ + ¬(n + size l ≤ 1) ∧ + n > delta * size l ∧ + ¬(size b < ratio * size b0) ∧ + invariant cmp (Bin n k' v' b b0) ∧ + invariant cmp l + ⇒ + invariant cmp (doubleL k v l (Bin n k' v' b b0)) ∧ + to_fmap cmp (doubleL k v l (Bin n k' v' b b0)) = + (FUNION (to_fmap cmp l) (to_fmap cmp (Bin n k' v' b b0))) |+ (key_set cmp k,v)`, + rw [] >> + `structure_size b ≠ 0` + by (fs [delta_def, ratio_def, invariant_def, size_def, + NOT_LESS_EQUAL, NOT_LESS, NOT_GREATER] >> + imp_res_tac structure_size_thm >> + fs []) >> + Cases_on `b` >> + fs [structure_size_def, doubleL_def, bin_def] >> + imp_res_tac inv_props >> + fs [Once invariant_def] >> + imp_res_tac inv_props >> + fs [invariant_def, to_fmap_def] + >- (fs [size_def, bin_def, to_fmap_def] >> + imp_res_tac structure_size_thm >> + simp [structure_size_def, key_ordered_def] >> + fs [structure_size_def, to_fmap_def, key_ordered_def] >> + rfs [key_ordered_to_fmap] >> + rw [] + >- metis_tac [to_fmap_key_set, key_set_cmp_thm, cmp_thms] + >- metis_tac [to_fmap_key_set, key_set_cmp_thm, cmp_thms] + >- metis_tac [to_fmap_key_set, key_set_cmp_thm, cmp_thms] + >- metis_tac [to_fmap_key_set, key_set_cmp_thm, cmp_thms] >> + metis_tac [ADD_ASSOC, balanced_lem7]) + >- (rw [FUNION_FUPDATE_2, FUNION_FUPDATE_1] >> + fs [key_ordered_def] >> + rfs [key_ordered_to_fmap] + >- metis_tac [to_fmap_key_set, key_set_cmp_thm, cmp_thms] + >- metis_tac [cmp_thms] + >- metis_tac [to_fmap_key_set, key_set_cmp_thm, cmp_thms] + >- metis_tac [cmp_thms] + >- metis_tac [cmp_thms] + >- metis_tac [cmp_thms] + >- metis_tac [to_fmap_key_set, key_set_cmp_thm, cmp_thms] + >- (`key_set cmp k' ≠ key_set cmp k'' ∧ + key_set cmp k ≠ key_set cmp k' ∧ + key_set cmp k ≠ key_set cmp k''` + by metis_tac [key_set_eq, cmp_thms] >> + metis_tac [FUPDATE_COMMUTES, FUNION_ASSOC]))); + +val rotateL_thm = Q.prove ( +`!k v l r cmp. + good_cmp cmp ∧ + key_ordered cmp k r Less ∧ + key_ordered cmp k l Greater ∧ + ¬(size l + size r ≤ 1) ∧ + size r > delta * size l ∧ + almost_balancedR (size l) (size r) ∧ + invariant cmp l ∧ + invariant cmp r + ⇒ + invariant cmp (rotateL k v l r) ∧ + to_fmap cmp (rotateL k v l r) = + (FUNION (to_fmap cmp l) (to_fmap cmp r)) |+ (key_set cmp k,v)`, + Cases_on `r` + >- fs [size_def] >> + rw [size_def, rotateL_def] >> + metis_tac [singleL_thm, doubleL_thm, ADD_COMM, NOT_ZERO_LT_ZERO, GREATER_DEF]); + +val balanceR_balR = Q.prove ( +`!k v l r cmp. + good_cmp cmp ∧ + invariant cmp l ∧ + invariant cmp r + ⇒ + balanceR k v l r = balR k v l r`, + ho_match_mp_tac balanceR_ind >> + rw [] >> + rw [balanceR_def, balR_def, rotateL_def, doubleL_def, bin_def, singleL_def] >> + imp_res_tac structure_size_thm >> + fs [size_def, invariant_def, structure_size_def] >> + imp_res_tac structure_size_thm >> + fs [balanced_def] >> + TRY (Cases_on `l` >> fs [structure_size_def, size_def] >> NO_TAC) >> + TRY (Cases_on `r` >> fs [structure_size_def, size_def] >> NO_TAC) >> + TRY (Cases_on `v4` >> fs [structure_size_def, size_def] >> NO_TAC) >> + TRY (fs [ratio_def] >> NO_TAC) >> + every_case_tac >> + fs [size_def, structure_size_def, ratio_def, delta_def] >> + imp_res_tac structure_size_thm >> + fs [invariant_def, doubleL_def, bin_def, size_def] >> + imp_res_tac structure_size_thm >> + rw []); + +val balanceR_thm = Q.prove ( +`!k v l r cmp. + good_cmp cmp ∧ + key_ordered cmp k r Less ∧ + key_ordered cmp k l Greater ∧ + almost_balancedR (size l) (size r) ∧ + invariant cmp l ∧ + invariant cmp r + ⇒ + invariant cmp (balanceR k v l r) ∧ + to_fmap cmp (balanceR k v l r) = + (FUNION (to_fmap cmp l) (to_fmap cmp r)) |+ (key_set cmp k,v)`, + rw [] >> + `balanceR k v l r = balR k v l r` by metis_tac [balanceR_balR] >> + rw [balR_def, invariant_def] >> + imp_res_tac structure_size_thm >> + rw [balanced_lem1, balanced_lem5, to_fmap_def] >> + metis_tac [rotateL_thm]); + +val almost_balancedL_thm = Q.prove ( +`!l r. + balanced l r ⇒ + almost_balancedL l r ∧ almost_balancedL (l + 1) r ∧ almost_balancedL l (r - 1)`, + rw [almost_balancedL_def] >> + fs [balanced_def, NOT_LESS_EQUAL, TIMES_MIN] >> + rw [] >> + CCONTR_TAC >> + fs [] >> + fs [NOT_LESS_EQUAL] >> + fs [delta_def, MIN_DEF]); + +val almost_balancedR_thm = Q.prove ( +`!l r. + balanced l r ⇒ + almost_balancedR l r ∧ almost_balancedR l (r + 1) ∧ almost_balancedR (l - 1) r`, + rw [almost_balancedR_def] >> + fs [balanced_def, NOT_LESS_EQUAL, TIMES_MIN] >> + rw [] >> + CCONTR_TAC >> + fs [] >> + fs [NOT_LESS_EQUAL] >> + fs [delta_def, MIN_DEF] >> + fs [NOT_LESS, LESS_OR_EQ] >> + rw [] >> + decide_tac); + +val insert_thm = Q.store_thm ("insert_thm", +`∀t. + good_cmp cmp ∧ + invariant cmp t + ⇒ + invariant cmp (insert cmp k v t) ∧ + to_fmap cmp (insert cmp k v t) = to_fmap cmp t |+ (key_set cmp k,v)`, + Induct_on `t` + >- fs [insert_def, singleton_def, to_fmap_def, invariant_eq, + structure_size_def, balanced_def, size_def, key_ordered_def] >> + simp [invariant_eq] >> + rpt gen_tac >> + strip_tac >> + fs [insert_def] >> + Cases_on `cmp k k'` >> + fs [] >> + simp [] >> + TRY (inv_mp_tac balanceL_thm) >> + TRY (inv_mp_tac balanceR_thm) >> + conj_asm1_tac >> + rw [to_fmap_def] + >- (rfs [key_ordered_to_fmap] >> + rw [] >> + imp_res_tac to_fmap_key_set >> + rw [key_set_cmp_thm] >> + metis_tac [cmp_thms]) + >- (imp_res_tac size_thm >> + rw [FCARD_FUPDATE] >> + fs [key_ordered_to_fmap] >> + metis_tac [almost_balancedL_thm]) + >- (rfs [key_ordered_to_fmap] >> + rw [] >> + `key_set cmp k ≠ key_set cmp k'` by metis_tac [key_set_eq, cmp_thms] >> + metis_tac [FUPDATE_COMMUTES]) + >- (rfs [key_ordered_to_fmap] >> + rw [] >> + imp_res_tac to_fmap_key_set >> + rw [key_set_cmp_thm] >> + metis_tac [cmp_thms]) + >- (imp_res_tac size_thm >> + rw [FCARD_FUPDATE] >> + fs [key_ordered_to_fmap] >> + metis_tac [almost_balancedR_thm]) + >- (rw [FUNION_FUPDATE_2, to_fmap_def] >> + rfs [key_ordered_to_fmap] >> + rw [] >> + metis_tac [FUPDATE_COMMUTES, cmp_thms, to_fmap_key_set, key_set_cmp_thm]) + >- (fs [invariant_def] >> + rfs [key_ordered_to_fmap] >> + metis_tac [to_fmap_key_set, key_set_cmp_thm, cmp_thms]) + >- metis_tac [key_set_eq, FUPDATE_EQ]); + +val insertR_thm = Q.store_thm ("insertR_thm", +`∀t. + good_cmp cmp ∧ + invariant cmp t + ⇒ + invariant cmp (insertR cmp k v t) ∧ + to_fmap cmp (insertR cmp k v t) = + if key_set cmp k ∈ FDOM (to_fmap cmp t) then to_fmap cmp t else to_fmap cmp t |+ (key_set cmp k,v)`, + Induct_on `t` + >- fs [insertR_def, singleton_def, to_fmap_def, invariant_def, + structure_size_def, balanced_def, size_def, key_ordered_def] >> + rpt gen_tac >> + strip_tac >> + imp_res_tac inv_props >> + fs [insertR_def, invariant_def] >> + Cases_on `cmp k k'` >> + fs [] >> + simp [to_fmap_def] + >- (`almost_balancedL (size (insertR cmp k v t)) (size t')` + by (imp_res_tac size_thm >> + rw [FCARD_FUPDATE] >> + fs [key_ordered_to_fmap] >> + metis_tac [almost_balancedL_thm]) >> + `key_ordered cmp k' (insertR cmp k v t) Greater` + by (rfs [key_ordered_to_fmap] >> + rw [] >> + rw [key_set_cmp_thm] >> + metis_tac [good_cmp_def]) >> + rw [balanceL_thm] >> + imp_res_tac balanceL_thm >> + rw [FUNION_FUPDATE_1] >> + metis_tac [FUPDATE_COMMUTES, good_cmp_def, comparison_distinct]) + >- (`almost_balancedR (size t) (size (insertR cmp k v t'))` + by (imp_res_tac size_thm >> + rw [FCARD_FUPDATE] >> + fs [key_ordered_to_fmap] >> + metis_tac [almost_balancedR_thm]) >> + `key_ordered cmp k' (insertR cmp k v t') Less` + by (fs [key_ordered_to_fmap] >> + rw [] >> + imp_res_tac to_fmap_key_set >> + rw [key_set_cmp_thm] >> + metis_tac [cmp_thms]) >> + rw [balanceR_thm] >> + imp_res_tac balanceR_thm >> + rw [FUNION_FUPDATE_2] >> + rfs [key_ordered_to_fmap] >> + metis_tac [FUPDATE_COMMUTES, good_cmp_def, comparison_distinct]) + >- (fs [invariant_def] >> + rfs [key_ordered_to_fmap] >> + metis_tac [to_fmap_key_set, key_set_cmp_thm, cmp_thms,key_set_eq, FUPDATE_EQ])); + +val insertMax_thm = Q.store_thm ("insertMax_thm", +`∀t. + good_cmp cmp ∧ + invariant cmp t ∧ + (!k1. k1 ∈ FDOM (to_fmap cmp t) ⇒ key_set_cmp cmp k k1 Greater) + ⇒ + invariant cmp (insertMax k v t) ∧ + to_fmap cmp (insertMax k v t) = to_fmap cmp t |+ (key_set cmp k,v)`, + Induct_on `t` + >- fs [insertMax_def, singleton_def, to_fmap_def, invariant_def, + structure_size_def, balanced_def, size_def, key_ordered_def] >> + rpt gen_tac >> + strip_tac >> + fs [insertMax_def, invariant_def, to_fmap_def] >> + inv_mp_tac balanceR_thm >> + conj_asm1_tac >> + simp [] + >- (rfs [key_ordered_to_fmap] >> + imp_res_tac size_thm >> + rw [FCARD_FUPDATE] >> + fs [] >> + metis_tac [almost_balancedR_thm, good_cmp_def, key_set_cmp_thm]) >> + rw [FUNION_FUPDATE_2] >> + rfs [key_ordered_to_fmap] >> + metis_tac [FUPDATE_COMMUTES, cmp_thms, key_set_cmp_thm]); + +val insertMin_thm = Q.store_thm ("insertMin_thm", +`∀t. + good_cmp cmp ∧ + invariant cmp t ∧ + (!k1. k1 ∈ FDOM (to_fmap cmp t) ⇒ key_set_cmp cmp k k1 Less) + ⇒ + invariant cmp (insertMin k v t) ∧ + to_fmap cmp (insertMin k v t) = to_fmap cmp t |+ (key_set cmp k,v)`, + Induct_on `t` + >- fs [insertMin_def, singleton_def, to_fmap_def, invariant_def, + structure_size_def, balanced_def, size_def, key_ordered_def] >> + rpt gen_tac >> + strip_tac >> + fs [insertMin_def, invariant_def, to_fmap_def] >> + simp [] >> + `almost_balancedL (size (insertMin k v t)) (size t')` + by (imp_res_tac size_thm >> + rw [FCARD_FUPDATE] >> + fs [key_ordered_to_fmap] >> + metis_tac [almost_balancedL_thm]) >> + `key_ordered cmp k' (insertMin k v t) Greater` + by (rfs [key_ordered_to_fmap] >> + rw [] >> + imp_res_tac to_fmap_key_set >> + rw [key_set_cmp_thm] >> + metis_tac [cmp_thms, key_set_cmp_thm]) >> + rw [balanceL_thm] >> + imp_res_tac balanceL_thm >> + rw [FUNION_FUPDATE_1] >> + metis_tac [FUPDATE_COMMUTES, cmp_thms, key_set_cmp_thm]); + +val deleteFindMin_thm = Q.store_thm ("deleteFindMin", +`∀t t' k v. + good_cmp cmp ∧ + invariant cmp t ∧ + ~null t ∧ + deleteFindMin t = ((k,v),t') + ⇒ + invariant cmp t' ∧ + key_ordered cmp k t' Less ∧ + FLOOKUP (to_fmap cmp t) (key_set cmp k) = SOME v ∧ + to_fmap cmp t' = + DRESTRICT (to_fmap cmp t) (FDOM (to_fmap cmp t) DELETE key_set cmp k)`, + ho_match_mp_tac (fetch "-" "deleteFindMin_ind") >> + rpt conj_tac >> + rpt gen_tac >> + strip_tac >> + rpt gen_tac >> + TRY DISCH_TAC >> + fs [deleteFindMin_def, invariant_eq, to_fmap_def] >> + fs [null_def, to_fmap_def, FUNION_FEMPTY_1, deleteFindMin_def] >> + BasicProvers.VAR_EQ_TAC >> + fs [to_fmap_def, FLOOKUP_UPDATE, key_ordered_def, LET_THM, null_def] + >- (rw [] >> + fs [key_ordered_to_fmap] >> + rw [fmap_eq_flookup, FLOOKUP_UPDATE, FLOOKUP_DRESTRICT] >> + rw [flookup_thm] >> + fs [] >> + metis_tac [comparison_distinct, good_cmp_def]) >> + `?km l. deleteFindMin (Bin (structure_size v8 + (structure_size v9 + 1)) v6 v7 v8 v9) = (km,l)` + by metis_tac [pairTheory.pair_CASES] >> + fs [] >> + rpt BasicProvers.VAR_EQ_TAC >> + inv_mp_tac balanceR_thm >> + simp [] >> + Cases_on `key_set cmp v6 = key_set cmp k'` >> + fs [] + >- (`FDOM (to_fmap cmp l) = FDOM (to_fmap cmp v8) ∪ FDOM (to_fmap cmp v9)` + by (FIRST_ASSUM (assume_tac o MATCH_MP (METIS_PROVE [] ``m1 = m2 ⇒ FDOM m1 = FDOM m2``)) >> + fs [FDOM_DRESTRICT, EXTENSION] >> + rfs [key_ordered_to_fmap] >> + metis_tac [cmp_thms]) >> + conj_asm1_tac + >- (rw [] + >- (rfs [key_ordered_to_fmap] >> + metis_tac []) + >- (fs [size_def] >> + imp_res_tac size_thm >> + rw [DELETE_INSERT, FCARD_DRESTRICT] >> + `key_set cmp k' ∉ FDOM (to_fmap cmp v8) ∪ FDOM (to_fmap cmp v9)` + by (fs [key_ordered_to_fmap] >> + metis_tac [good_cmp_def, comparison_distinct]) >> + imp_res_tac DELETE_NON_ELEMENT >> + rw [CARD_DISJOINT_UNION] >> + imp_res_tac almost_balancedR_thm >> + fs [] >> + metis_tac [FCARD_DEF, structure_size_thm, size_thm])) >> + strip_tac >> + simp [] >> + rw [fmap_eq_flookup, FLOOKUP_UPDATE, FLOOKUP_DRESTRICT, FLOOKUP_FUNION] + >- (rfs [key_ordered_to_fmap, FDOM_DRESTRICT] >> + fs [key_ordered_to_fmap, FDOM_DRESTRICT] >> + rw [] >> + imp_res_tac to_fmap_key_set >> + rw [key_set_cmp_thm] >> + metis_tac [cmp_thms, key_set_eq, key_set_cmp_thm]) >> + every_case_tac >> + fs [flookup_thm,key_ordered_to_fmap] >> + rfs [key_ordered_to_fmap] >> + rw [] >> + metis_tac [cmp_thms, key_set_eq, key_set_cmp_thm]) + >- (`key_set cmp k' ∈ FDOM (to_fmap cmp v8 ⊌ to_fmap cmp v9)` + by (every_case_tac >> + fs [FLOOKUP_DEF]) >> + `key_set cmp k ≠ key_set cmp k' ∧ cmp k' k = Less` + by (rfs [key_ordered_to_fmap] >> + fs [key_ordered_to_fmap] >> + metis_tac [cmp_thms, to_fmap_key_set, key_set_cmp_thm]) >> + simp [] >> + `FDOM (to_fmap cmp l) = (key_set cmp v6 INSERT FDOM (to_fmap cmp v8) ∪ FDOM (to_fmap cmp v9)) DELETE key_set cmp k'` + by (FIRST_ASSUM (assume_tac o MATCH_MP (METIS_PROVE [] ``m1 = m2 ⇒ FDOM m1 = FDOM m2``)) >> + fs [FDOM_DRESTRICT, EXTENSION] >> + rfs [key_ordered_to_fmap] >> + metis_tac [cmp_thms]) >> + conj_asm1_tac + >- (rw [] + >- (rfs [key_ordered_to_fmap] >> + fs [key_ordered_to_fmap] >> + rw [key_set_cmp_thm] >> + metis_tac [key_set_cmp_thm, to_fmap_key_set]) + >- (imp_res_tac size_thm >> + rw [FCARD_FUPDATE, FDOM_DRESTRICT] >> + rw [FCARD_DRESTRICT, DELETE_INSERT] >> + `(FDOM (to_fmap cmp v8) ∪ FDOM (to_fmap cmp v9)) ∩ + (key_set cmp v6 INSERT FDOM (to_fmap cmp v8) ∪ FDOM (to_fmap cmp v9) DELETE key_set cmp k') + = + FDOM (to_fmap cmp v8) ∪ FDOM (to_fmap cmp v9) DELETE key_set cmp k'` + by (rw [EXTENSION] >> + metis_tac [key_set_eq, EXTENSION]) >> + simp [CARD_UNION_EQN] >> + fs [DISJOINT_DEF] >| + [`CARD (FDOM (to_fmap cmp v8)) ≠ 0` + by (rw [CARD_EQ_0, EXTENSION] >> + metis_tac []) >> + `0 < CARD (FDOM (to_fmap cmp v8))` by decide_tac, + `CARD (FDOM (to_fmap cmp v9)) ≠ 0` + by (rw [CARD_EQ_0, EXTENSION] >> + metis_tac []) >> + `0 < CARD (FDOM (to_fmap cmp v9))` by decide_tac] >> + rw [] >> + imp_res_tac almost_balancedR_thm >> + fs [size_def] >> + metis_tac [FCARD_DEF, structure_size_thm, size_thm])) >> + strip_tac >> + simp [] >> + rw [fmap_eq_flookup, FLOOKUP_UPDATE, FLOOKUP_DRESTRICT, FLOOKUP_FUNION] + >- (rfs [key_ordered_to_fmap, FDOM_DRESTRICT] >> + fs [key_ordered_to_fmap, FDOM_DRESTRICT] >> + rw [] >> + imp_res_tac to_fmap_key_set >> + rw [key_set_cmp_thm] >> + metis_tac [cmp_thms, key_set_eq, key_set_cmp_thm]) >> + every_case_tac >> + fs [flookup_thm,key_ordered_to_fmap] >> + rfs [key_ordered_to_fmap] >> + rw [] >> + metis_tac [cmp_thms, key_set_eq, key_set_cmp_thm])); + +val deleteFindMax_thm = Q.store_thm ("deleteFindMax", +`∀t t' k v. + good_cmp cmp ∧ + invariant cmp t ∧ + ~null t ∧ + deleteFindMax t = ((k,v),t') + ⇒ + invariant cmp t' ∧ + key_ordered cmp k t' Greater ∧ + FLOOKUP (to_fmap cmp t) (key_set cmp k) = SOME v ∧ + to_fmap cmp t' = + DRESTRICT (to_fmap cmp t) (FDOM (to_fmap cmp t) DELETE key_set cmp k)`, + ho_match_mp_tac (fetch "-" "deleteFindMax_ind") >> + rpt conj_tac >> + rpt gen_tac >> + strip_tac >> + rpt gen_tac >> + TRY DISCH_TAC >> + fs [deleteFindMax_def, invariant_eq, to_fmap_def] >> + fs [null_def, to_fmap_def, FUNION_FEMPTY_2, deleteFindMax_def] >> + BasicProvers.VAR_EQ_TAC >> + fs [to_fmap_def, FLOOKUP_UPDATE, key_ordered_def, LET_THM, null_def] + >- (rw [] >> + fs [key_ordered_to_fmap] >> + rw [fmap_eq_flookup, FLOOKUP_UPDATE, FLOOKUP_DRESTRICT] >> + rw [flookup_thm] >> + fs [] >> + metis_tac [comparison_distinct, good_cmp_def]) >> + `?km l. deleteFindMax (Bin (structure_size v8 + (structure_size v9 + 1)) v6 v7 v8 v9) = (km,l)` + by metis_tac [pairTheory.pair_CASES] >> + fs [] >> + rpt BasicProvers.VAR_EQ_TAC >> + inv_mp_tac balanceL_thm >> + simp [] >> + Cases_on `key_set cmp v6 = key_set cmp k'` >> + fs [] + >- (`FDOM (to_fmap cmp l') = FDOM (to_fmap cmp v8) ∪ FDOM (to_fmap cmp v9)` + by (FIRST_ASSUM (assume_tac o MATCH_MP (METIS_PROVE [] ``m1 = m2 ⇒ FDOM m1 = FDOM m2``)) >> + fs [FDOM_DRESTRICT, EXTENSION] >> + rfs [key_ordered_to_fmap] >> + metis_tac [cmp_thms]) >> + conj_asm1_tac + >- (rw [] + >- (rfs [key_ordered_to_fmap] >> + metis_tac []) + >- (fs [size_def] >> + imp_res_tac size_thm >> + rw [DELETE_INSERT, FCARD_DRESTRICT] >> + `key_set cmp k' ∉ FDOM (to_fmap cmp v8) ∪ FDOM (to_fmap cmp v9)` + by (fs [key_ordered_to_fmap] >> + metis_tac [good_cmp_def, comparison_distinct]) >> + imp_res_tac DELETE_NON_ELEMENT >> + rw [CARD_DISJOINT_UNION] >> + imp_res_tac almost_balancedL_thm >> + fs [] >> + metis_tac [FCARD_DEF, structure_size_thm, size_thm])) >> + strip_tac >> + simp [] >> + rw [fmap_eq_flookup, FLOOKUP_UPDATE, FLOOKUP_DRESTRICT, FLOOKUP_FUNION] + >- (rfs [key_ordered_to_fmap, FDOM_DRESTRICT] >> + fs [key_ordered_to_fmap, FDOM_DRESTRICT] >> + rw [] >> + imp_res_tac to_fmap_key_set >> + rw [key_set_cmp_thm] >> + metis_tac [cmp_thms, key_set_eq, key_set_cmp_thm]) >> + every_case_tac >> + fs [flookup_thm,key_ordered_to_fmap] >> + rfs [key_ordered_to_fmap] >> + rw [] >> + metis_tac [cmp_thms, key_set_eq, key_set_cmp_thm]) + >- (`key_set cmp k' ∈ FDOM (to_fmap cmp v8 ⊌ to_fmap cmp v9)` + by (every_case_tac >> + fs [FLOOKUP_DEF]) >> + `key_set cmp k' ≠ key_set cmp k ∧ cmp k' k = Greater` + by (rfs [key_ordered_to_fmap] >> + fs [key_ordered_to_fmap] >> + metis_tac [cmp_thms, to_fmap_key_set, key_set_cmp_thm]) >> + simp [] >> + `FDOM (to_fmap cmp l') = (key_set cmp v6 INSERT FDOM (to_fmap cmp v8) ∪ FDOM (to_fmap cmp v9)) DELETE key_set cmp k'` + by (FIRST_ASSUM (assume_tac o MATCH_MP (METIS_PROVE [] ``m1 = m2 ⇒ FDOM m1 = FDOM m2``)) >> + fs [FDOM_DRESTRICT, EXTENSION] >> + metis_tac [comparison_distinct, key_ordered_to_fmap, good_cmp_def]) >> + conj_asm1_tac + >- (rw [] + >- (rfs [key_ordered_to_fmap] >> + fs [key_ordered_to_fmap] >> + rw [key_set_cmp_thm] >> + metis_tac [key_set_cmp_thm, to_fmap_key_set]) + >- (imp_res_tac size_thm >> + rw [FCARD_FUPDATE, FDOM_DRESTRICT] >> + rw [FCARD_DRESTRICT, DELETE_INSERT] >> + `(FDOM (to_fmap cmp v8) ∪ FDOM (to_fmap cmp v9)) ∩ + (key_set cmp v6 INSERT FDOM (to_fmap cmp v8) ∪ FDOM (to_fmap cmp v9) DELETE key_set cmp k') + = + FDOM (to_fmap cmp v8) ∪ FDOM (to_fmap cmp v9) DELETE key_set cmp k'` + by (rw [EXTENSION] >> + metis_tac [key_set_eq, EXTENSION]) >> + simp [CARD_UNION_EQN] >> + fs [DISJOINT_DEF] >| + [`CARD (FDOM (to_fmap cmp v8)) ≠ 0` + by (rw [CARD_EQ_0, EXTENSION] >> + metis_tac []) >> + `0 < CARD (FDOM (to_fmap cmp v8))` by decide_tac, + `CARD (FDOM (to_fmap cmp v9)) ≠ 0` + by (rw [CARD_EQ_0, EXTENSION] >> + metis_tac []) >> + `0 < CARD (FDOM (to_fmap cmp v9))` by decide_tac] >> + rw [] >> + imp_res_tac almost_balancedL_thm >> + fs [size_def] >> + metis_tac [FCARD_DEF, structure_size_thm, size_thm])) >> + strip_tac >> + simp [] >> + rw [fmap_eq_flookup, FLOOKUP_UPDATE, FLOOKUP_DRESTRICT, FLOOKUP_FUNION] + >- (rfs [key_ordered_to_fmap, FDOM_DRESTRICT] >> + fs [key_ordered_to_fmap, FDOM_DRESTRICT] >> + rw [] >> + imp_res_tac to_fmap_key_set >> + rw [key_set_cmp_thm] >> + metis_tac [cmp_thms, key_set_eq, key_set_cmp_thm]) >> + every_case_tac >> + fs [flookup_thm,key_ordered_to_fmap] >> + rfs [key_ordered_to_fmap] >> + rw [] >> + metis_tac [cmp_thms, key_set_eq, key_set_cmp_thm])); + +val glue_thm = Q.store_thm ("glue_thm", +`!l r. + good_cmp cmp ∧ + invariant cmp l ∧ + invariant cmp r ∧ + (!ks ks'. ks ∈ FDOM (to_fmap cmp l) ∧ ks' ∈ FDOM (to_fmap cmp r) ⇒ key_set_cmp2 cmp ks ks' Less) ∧ + balanced (size l) (size r) + ⇒ + invariant cmp (glue l r) ∧ + to_fmap cmp (glue l r) = FUNION (to_fmap cmp l) (to_fmap cmp r)`, + Cases_on `l` >> + Cases_on `r` >> + simp [size_def, glue_def] >> + TRY (simp [to_fmap_def, FUNION_FEMPTY_2, FUNION_FEMPTY_1] >> NO_TAC) >> + strip_tac >> + Cases_on `n > n'` >> + simp [] + >- (`?k' v' l. deleteFindMax (Bin n k v b b0) = ((k',v'),l)` + by metis_tac [pairTheory.pair_CASES] >> + simp [] >> + inv_mp_tac balanceR_thm >> + simp [] >> + inv_to_front_tac ``invariant`` >> + inv_mp_tac deleteFindMax_thm >> + simp [Once SWAP_EXISTS_THM] >> + qexists_tac `Bin n k v b b0` >> + simp [null_def] >> + strip_tac >> + imp_res_tac fdom_eq >> + fs [FDOM_DRESTRICT, DELETE_INSERT, FLOOKUP_UPDATE] >> + fs [DELETE_INTER2] >> + rw [] + >- (rw [fmap_eq_flookup, FLOOKUP_FUNION, FLOOKUP_UPDATE, FLOOKUP_DRESTRICT] >> + every_case_tac >> + fs [invariant_eq, FLOOKUP_DEF] >> + metis_tac [good_cmp_def, comparison_distinct]) + >- (rfs [key_ordered_to_fmap] >> + fs [FLOOKUP_DEF] >> + rw [] >> + imp_res_tac to_fmap_key_set >> + rw [key_set_cmp_thm] >> + metis_tac [cmp_thms, key_set_cmp2_thm]) + >- (fs [invariant_eq] >> + `size l = size (Bin n k v b b0) - 1` + by (rw [size_def] >> + imp_res_tac size_thm >> + rw [FCARD_DEF, FDOM_FUPDATE, FDOM_DRESTRICT, to_fmap_def, + CARD_DISJOINT_UNION, DELETE_INTER2] >> + fs [to_fmap_def, FLOOKUP_DEF] >> + metis_tac [structure_size_thm, FCARD_DEF]) >> + imp_res_tac almost_balancedR_thm >> + fs [size_def] >> + rw [] >> + FULL_SIMP_TAC (srw_ss()++ARITH_ss) [])) + >- (`?k v l. deleteFindMin (Bin n' k' v' b' b0') = ((k,v),l)` + by metis_tac [pairTheory.pair_CASES] >> + simp [] >> + inv_mp_tac balanceL_thm >> + simp [] >> + inv_to_front_tac ``invariant`` >> + inv_mp_tac deleteFindMin_thm >> + simp [Once SWAP_EXISTS_THM] >> + qexists_tac `Bin n' k' v' b' b0'` >> + simp [null_def] >> + strip_tac >> + imp_res_tac fdom_eq >> + fs [FDOM_DRESTRICT, DELETE_INSERT, FLOOKUP_UPDATE] >> + fs [DELETE_INTER2] >> + rw [] + >- (rw [fmap_eq_flookup, FLOOKUP_FUNION, FLOOKUP_UPDATE, FLOOKUP_DRESTRICT] >> + every_case_tac + >- metis_tac [] >> + fs [invariant_eq, FLOOKUP_DEF] + >- metis_tac [cmp_thms, key_set_cmp2_thm]) + >- (rfs [key_ordered_to_fmap] >> + fs [FLOOKUP_DEF] >> + rw [] >> + imp_res_tac to_fmap_key_set >> + rw [key_set_cmp_thm] >> + metis_tac [cmp_thms, key_set_cmp2_thm]) + >- (fs [invariant_eq] >> + `size l = size (Bin n' k' v' b' b0') - 1` + by (rw [size_def] >> + imp_res_tac size_thm >> + rw [FCARD_DEF, FDOM_FUPDATE, FDOM_DRESTRICT, to_fmap_def, + CARD_DISJOINT_UNION, DELETE_INTER2] >> + fs [to_fmap_def, FLOOKUP_DEF] >> + metis_tac [structure_size_thm, FCARD_DEF]) >> + imp_res_tac almost_balancedL_thm >> + fs [size_def] >> + rw [] >> + FULL_SIMP_TAC (srw_ss()++ARITH_ss) []))); + +val to_fmap_tac = + rw [to_fmap_def] >> + rw [fmap_eq_flookup, FLOOKUP_DRESTRICT, FLOOKUP_UPDATE, FLOOKUP_FUNION] >> + BasicProvers.EVERY_CASE_TAC >> + fs [FLOOKUP_DEF] >> + fs [to_fmap_def] >> + fs [key_ordered_to_fmap] >> + rfs [key_ordered_to_fmap] >> + metis_tac [cmp_thms, to_fmap_key_set, key_set_eq, key_set_cmp_thm]; + +val delete_thm = Q.store_thm ("delete_thm", +`!t. + good_cmp cmp ∧ + invariant cmp t + ⇒ + invariant cmp (delete cmp k t) ∧ + to_fmap cmp (delete cmp k t) = + DRESTRICT (to_fmap cmp t) (FDOM (to_fmap cmp t) DELETE key_set cmp k)`, + Induct_on `t` + >- rw [delete_def, to_fmap_def] >> + rpt gen_tac >> + strip_tac >> + simp [delete_def] >> + fs [invariant_eq] >> + Cases_on `cmp k k'` >> + simp [] + >- (inv_mp_tac balanceR_thm >> + simp [] >> + rw [] + >- (fs [key_ordered_to_fmap] >> + rfs [key_ordered_to_fmap] >> + rw [FDOM_DRESTRICT] >> + metis_tac [to_fmap_key_set, key_set_cmp_thm]) + >- (imp_res_tac size_thm >> + rw [FCARD_DRESTRICT, DELETE_INTER2] >> + imp_res_tac almost_balancedR_thm >> + metis_tac [FCARD_DEF]) + >- to_fmap_tac) + >- (inv_mp_tac balanceL_thm >> + simp [] >> + rw [] + >- (fs [key_ordered_to_fmap] >> + rfs [key_ordered_to_fmap] >> + rw [FDOM_DRESTRICT] >> + metis_tac [to_fmap_key_set, key_set_cmp_thm]) + >- (imp_res_tac size_thm >> + rw [FCARD_DRESTRICT, DELETE_INTER2] >> + imp_res_tac almost_balancedL_thm >> + metis_tac [FCARD_DEF]) + >- to_fmap_tac) + >- (inv_mp_tac glue_thm >> + rw [] >> + rfs [key_ordered_to_fmap] + >- metis_tac [key_set_cmp2_thm, to_fmap_key_set, key_set_cmp_thm, cmp_thms] + >- to_fmap_tac)); + +val restrict_set_def = Define ` +restrict_set cmp lo hi = +{ k | option_cmp cmp lo (SOME k) = Less ∧ + option_cmp2 cmp (SOME k) hi = Less }`; + +val restrict_domain_def = Define ` + restrict_domain cmp lo hi m = + DRESTRICT m (IMAGE (key_set cmp) (restrict_set cmp lo hi))`; + +val restrict_domain_union = Q.prove ( +`restrict_domain cmp lo hi (FUNION m1 m2) = + FUNION (restrict_domain cmp lo hi m1) (restrict_domain cmp lo hi m2)`, + rw [restrict_domain_def, fmap_eq_flookup, FLOOKUP_DRESTRICT, FLOOKUP_FUNION] >> + rw [FLOOKUP_DRESTRICT, FLOOKUP_FUNION]); + +val restrict_domain_update = Q.prove ( +`good_cmp cmp + ⇒ + restrict_domain cmp lo hi (m1 |+ (key_set cmp k,v)) = + if k ∈ restrict_set cmp lo hi then + restrict_domain cmp lo hi m1 |+ (key_set cmp k,v) + else + restrict_domain cmp lo hi m1`, + rw [restrict_domain_def, fmap_eq_flookup, FLOOKUP_DRESTRICT, FLOOKUP_FUNION] >> + rfs [key_set_eq] >> + fs [restrict_set_def] >> + Cases_on `hi` >> + Cases_on `lo` >> + fs [option_cmp_def, option_cmp2_def] >> + metis_tac [cmp_thms]); + +val bounded_root_def = Define ` + bounded_root cmp lk hk t ⇔ + !s k v l r. t = Bin s k v l r ⇒ k ∈ restrict_set cmp lk hk`; + +val trim_thm = Q.prove ( +`!t lk hk cmp. + good_cmp cmp ∧ + invariant cmp t + ⇒ + invariant cmp (trim cmp lk hk t) ∧ + bounded_root cmp lk hk (trim cmp lk hk t) ∧ + to_fmap cmp (trim cmp lk hk t) SUBMAP to_fmap cmp t ∧ + restrict_domain cmp lk hk (to_fmap cmp (trim cmp lk hk t)) = + restrict_domain cmp lk hk (to_fmap cmp t)`, + Cases_on `lk` >> + Cases_on `hk` >> + simp [bounded_root_def, trim_def, restrict_set_def, option_cmp_def, option_cmp2_def] >> + Induct_on `t` >> + simp [trim_help_lesser_def, trim_help_greater_def, trim_help_middle_def, key_ordered_def] >> + fs [invariant_eq] >> + rpt gen_tac >> + strip_tac >> + every_case_tac >> + fs [] >> + simp [to_fmap_def] >> + fs [SUBMAP_DEF, restrict_domain_def, DRESTRICTED_FUNION, DRESTRICT_FUPDATE] >> + rw [invariant_def] >> + rw [FAPPLY_FUPDATE_THM, FUNION_DEF, fmap_eq_flookup, FLOOKUP_DRESTRICT, + FLOOKUP_FUNION, FLOOKUP_UPDATE] >> + rw [] >> + every_case_tac >> + fs [flookup_thm, key_ordered_to_fmap, restrict_set_def, option_cmp_def, option_cmp2_def] >> + rfs [key_ordered_to_fmap] >> + metis_tac [cmp_thms, key_set_eq, key_set_cmp_thm, to_fmap_key_set]); + +val link_balanced_lem1 = Q.prove ( +`!r rz l. + balanced r rz ∧ + delta * (l + 1) < r + (rz + 1) + ⇒ + almost_balancedL (l + (r + 2)) rz`, + fs [almost_balancedL_def, balanced_def, TIMES_MIN, LESS_OR_EQ, delta_def, LEFT_ADD_DISTRIB] >> + CCONTR_TAC >> + fs [NOT_LESS, LESS_OR_EQ] >> + fs [MIN_DEF] >> + rw [] >> + every_case_tac >> + fs [NOT_LESS, LESS_OR_EQ]); + +val link_balanced_lem2 = Q.prove ( +`!r l ly. + balanced ly l ∧ + ¬(delta * (l + (ly + 1)) < r + 1) ∧ + delta * (r + 1) < l + (ly + 1) + ⇒ + almost_balancedR ly (SUC (l + r) + 1)`, + fs [ADD1, almost_balancedR_def, balanced_def, TIMES_MIN, LESS_OR_EQ, delta_def, LEFT_ADD_DISTRIB] >> + CCONTR_TAC >> + fs [NOT_LESS, LESS_OR_EQ] >> + fs [MIN_DEF] >> + rw [] >> + every_case_tac >> + fs [NOT_LESS, LESS_OR_EQ]); + +val link_balanced_lem3 = Q.prove ( +`!r l. + ¬(delta * (l + 1) < r + 1) ∧ + ¬(delta * (r + 1) < l + 1) + ⇒ + balanced (l + 1) (r + 1)`, + fs [ADD1, balanced_def, TIMES_MIN, LESS_OR_EQ, delta_def, LEFT_ADD_DISTRIB] >> + CCONTR_TAC >> + fs [NOT_LESS, LESS_OR_EQ, MIN_DEF]); + +val link_thm = Q.prove ( +`!k v l r. + good_cmp cmp ∧ + invariant cmp l ∧ + invariant cmp r ∧ + key_ordered cmp k l Greater ∧ + key_ordered cmp k r Less + ⇒ + invariant cmp (link k v l r) ∧ + to_fmap cmp (link k v l r) = + (FUNION (to_fmap cmp l) (to_fmap cmp r)) |+ (key_set cmp k,v)`, + ho_match_mp_tac (fetch "-" "link_ind") >> + rpt conj_tac >> + simp [link_def] >> + rpt conj_tac >> + rpt gen_tac >> + strip_tac + >- (inv_mp_tac insertMin_thm >> + rw [] + >- metis_tac [key_ordered_to_fmap] >> + rw [to_fmap_def, FUNION_FEMPTY_1]) + >- (inv_mp_tac insertMax_thm >> + rw [] + >- metis_tac [key_ordered_to_fmap] >> + rw [to_fmap_def, FUNION_FEMPTY_2]) >> + Cases_on `sizeL * delta < sizeR` >> + simp [] >> + fs [] + >- (strip_tac >> + fs [invariant_eq, link_def, key_ordered_def] >> + inv_mp_tac balanceL_thm >> + simp [] >> + rw [] + >- (rfs [key_ordered_to_fmap, to_fmap_def] >> + rw [] >> + rw [key_set_cmp_thm] >> + metis_tac [cmp_thms, key_set_cmp_thm, to_fmap_key_set]) + >- (imp_res_tac size_thm >> + rw [to_fmap_def] >> + fs [] >> + rfs [key_ordered_to_fmap] >> + simp [FCARD_FUPDATE, key_set_eq] >> + `key_set cmp k ∉ FDOM (to_fmap cmp ly) ∧ + key_set cmp k ∉ FDOM (to_fmap cmp l) ∧ + key_set cmp ky ∉ FDOM (to_fmap cmp r) ∧ + key_set cmp k ∉ FDOM (to_fmap cmp r)` + by metis_tac [cmp_thms, key_set_cmp_thm] >> + simp [FCARD_DEF] >> + `DISJOINT (FDOM (to_fmap cmp ly) ∪ FDOM (to_fmap cmp l)) (FDOM (to_fmap cmp r))` + by (rw [DISJOINT_UNION] >> + rw [DISJOINT_DEF, EXTENSION] >> + metis_tac [cmp_thms, key_set_cmp_thm, to_fmap_key_set]) >> + rw [CARD_DISJOINT_UNION] >> + imp_res_tac structure_size_to_fmap >> + fs [GSYM FCARD_DEF] >> + metis_tac [link_balanced_lem1, ADD_ASSOC]) + >- to_fmap_tac) >> + Cases_on `sizeR * delta < sizeL` >> + simp [] >> + fs [] + >- (strip_tac >> + fs [invariant_eq, link_def, key_ordered_def] >> + inv_mp_tac balanceR_thm >> + simp [] >> + rw [] + >- (rfs [key_ordered_to_fmap, to_fmap_def] >> + rw [] >> + rw [key_set_cmp_thm] >> + metis_tac [cmp_thms, key_set_cmp_thm, to_fmap_key_set]) + >- (imp_res_tac size_thm >> + rw [to_fmap_def] >> + fs [] >> + rfs [key_ordered_to_fmap] >> + simp [FUNION_FUPDATE_2, FCARD_FUPDATE, key_set_eq] >> + `key_set cmp k ∉ FDOM (to_fmap cmp rz) ∧ + key_set cmp k ∉ FDOM (to_fmap cmp l) ∧ + key_set cmp kz ∉ FDOM (to_fmap cmp l) ∧ + key_set cmp k ∉ FDOM (to_fmap cmp r)` + by metis_tac [cmp_thms, key_set_cmp_thm] >> + simp [FCARD_DEF] >> + `DISJOINT (FDOM (to_fmap cmp l) ∪ FDOM (to_fmap cmp r)) (FDOM (to_fmap cmp rz))` + by (rw [DISJOINT_UNION] >> + rw [DISJOINT_DEF, EXTENSION] >> + metis_tac [cmp_thms, key_set_cmp_thm, to_fmap_key_set]) >> + `DISJOINT (FDOM (to_fmap cmp l)) (FDOM (to_fmap cmp r))` + by (rw [DISJOINT_UNION] >> + rw [DISJOINT_DEF, EXTENSION] >> + metis_tac [cmp_thms, key_set_cmp_thm, to_fmap_key_set]) >> + rw [CARD_DISJOINT_UNION] >> + imp_res_tac structure_size_to_fmap >> + fs [GSYM FCARD_DEF] >> + metis_tac [link_balanced_lem2, ADD_ASSOC]) + >- to_fmap_tac) + >- (simp [bin_def, size_def] >> + rw [invariant_def, structure_size_def] >> + fs [invariant_eq, size_def] + >- metis_tac [link_balanced_lem3, structure_size_thm, ADD_ASSOC] >> + to_fmap_tac)); + +val filter_lt_help_thm = Q.prove ( +`!cmp bound t. + good_cmp cmp ∧ + invariant cmp t + ⇒ + invariant cmp (filterLt_help cmp bound t) ∧ + to_fmap cmp (filterLt_help cmp bound t) = restrict_domain cmp NONE (SOME bound) (to_fmap cmp t)`, + Induct_on `t` >> + simp [to_fmap_def, filterLt_help_def, restrict_domain_union, restrict_domain_update] >> + simp [restrict_domain_def, restrict_set_def, option_cmp2_def, option_cmp_def] >> + rpt gen_tac >> + strip_tac >> + Cases_on `cmp k bound` >> + simp [] + >- (inv_mp_tac link_thm >> + conj_asm1_tac >> + rw [] >> + fs [invariant_eq] + >- (rfs [key_ordered_to_fmap] >> + rw [restrict_domain_def]) >> + rw [restrict_domain_def, restrict_set_def, option_cmp_def, option_cmp2_def] >> + to_fmap_tac) + >- (first_x_assum inv_mp_tac >> + fs [invariant_eq] >> + rw [restrict_domain_def, restrict_set_def, option_cmp2_def, option_cmp_def] >> + to_fmap_tac) + >- (fs [invariant_eq] >> + rw [restrict_domain_def, restrict_set_def, option_cmp2_def, option_cmp_def] >> + to_fmap_tac)); + +val filterLt_thm = Q.prove ( +`!cmp bound t. + good_cmp cmp ∧ + invariant cmp t + ⇒ + invariant cmp (filterLt cmp bound t) ∧ + to_fmap cmp (filterLt cmp bound t) = restrict_domain cmp NONE bound (to_fmap cmp t)`, + Cases_on `bound` >> + simp [to_fmap_def, filterLt_def, restrict_domain_union, restrict_domain_update] >> + simp [restrict_domain_def, restrict_set_def, option_cmp2_def, option_cmp_def] >> + rw [] >> + imp_res_tac filter_lt_help_thm + >- (rw [fmap_eq_flookup, FLOOKUP_DRESTRICT] >> + rw [] >> + fs [FLOOKUP_DEF] >> + metis_tac [to_fmap_key_set]) >> + rw [restrict_domain_def, restrict_set_def, option_cmp2_def, option_cmp_def]); + +val filter_gt_help_thm = Q.prove ( +`!cmp bound t. + good_cmp cmp ∧ + invariant cmp t + ⇒ + invariant cmp (filterGt_help cmp bound t) ∧ + to_fmap cmp (filterGt_help cmp bound t) = restrict_domain cmp (SOME bound) NONE (to_fmap cmp t)`, + Induct_on `t` >> + simp [to_fmap_def, filterGt_help_def, restrict_domain_union, restrict_domain_update] >> + simp [restrict_domain_def, restrict_set_def, option_cmp2_def, option_cmp_def] >> + rpt gen_tac >> + strip_tac >> + Cases_on `cmp bound k` >> + simp [] + >- (inv_mp_tac link_thm >> + conj_asm1_tac >> + rw [] >> + fs [invariant_eq] + >- (rfs [key_ordered_to_fmap] >> + rw [restrict_domain_def]) >> + rw [restrict_domain_def, restrict_set_def, option_cmp_def, option_cmp2_def] >> + to_fmap_tac) + >- (first_x_assum inv_mp_tac >> + fs [invariant_eq] >> + rw [restrict_domain_def, restrict_set_def, option_cmp2_def, option_cmp_def] >> + to_fmap_tac) + >- (fs [invariant_eq] >> + rw [restrict_domain_def, restrict_set_def, option_cmp2_def, option_cmp_def] >> + to_fmap_tac)); + +val filterGt_thm = Q.prove ( +`!cmp bound t. + good_cmp cmp ∧ + invariant cmp t + ⇒ + invariant cmp (filterGt cmp bound t) ∧ + to_fmap cmp (filterGt cmp bound t) = restrict_domain cmp bound NONE (to_fmap cmp t)`, + Cases_on `bound` >> + simp [to_fmap_def, filterGt_def, restrict_domain_union, restrict_domain_update] >> + simp [restrict_domain_def, restrict_set_def, option_cmp2_def, option_cmp_def] >> + rw [] >> + imp_res_tac filter_gt_help_thm + >- (rw [fmap_eq_flookup, FLOOKUP_DRESTRICT] >> + rw [] >> + fs [FLOOKUP_DEF] >> + metis_tac [to_fmap_key_set]) >> + rw [restrict_domain_def, restrict_set_def, option_cmp2_def, option_cmp_def]); + +val restrict_domain_partition = Q.prove ( +`!cmp x l h t1 t2. + good_cmp cmp ∧ + x ∈ restrict_set cmp l h ∧ + restrict_domain cmp l (SOME x) t2 SUBMAP t1 ∧ + restrict_domain cmp (SOME x) h t1 SUBMAP t2 ∧ + key_set cmp x ∉ FDOM t1 ∧ + key_set cmp x ∉ FDOM t2 + ⇒ + FUNION (restrict_domain cmp l h t1) (restrict_domain cmp l h t2) = + FUNION (restrict_domain cmp l (SOME x) t1) (restrict_domain cmp (SOME x) h t2)`, + rw [restrict_domain_def, fmap_eq_flookup] >> + every_case_tac >> + rw [] >> + fs [restrict_set_def] >> + `h = NONE ∨ ?h'. h = SOME h'` by Cases_on `h` >> + `l = NONE ∨ ?l'. l = SOME l'` by Cases_on `l` >> + fs [option_cmp_def, option_cmp2_def, SUBMAP_DEF, EXTENSION, FDOM_DRESTRICT, FLOOKUP_DEF, + DRESTRICT_DEF, FAPPLY_FUPDATE_THM] >> + fmrw [] >> + metis_tac [cmp_thms, EXTENSION, key_set_eq]); + +val restrict_domain_union_swap = Q.prove ( +` good_cmp cmp + ⇒ + a ⊌ + restrict_domain cmp blo (SOME kx) (to_fmap cmp r2) ⊌ + restrict_domain cmp (SOME kx) bhi (to_fmap cmp t1') + = + a ⊌ + restrict_domain cmp (SOME kx) bhi (to_fmap cmp t1') ⊌ + restrict_domain cmp blo (SOME kx) (to_fmap cmp r2)`, + rw [restrict_domain_def] >> + Cases_on `blo` >> + Cases_on `bhi` >> + rw [restrict_set_def, fmap_eq_flookup] >> + fmrw [] >> + fs [option_cmp_def, option_cmp2_def] >> + every_case_tac >> + rw [] >> + metis_tac [cmp_thms, key_set_eq]); + +val restrict_domain_extend = Q.prove ( +` good_cmp cmp ∧ + invariant cmp (Bin s kx x t1 t1') ∧ + kx ∈ restrict_set cmp blo bhi + ⇒ + restrict_domain cmp blo (SOME kx) (to_fmap cmp t1) = + restrict_domain cmp blo bhi (to_fmap cmp t1) ∧ + restrict_domain cmp (SOME kx) bhi (to_fmap cmp t1') = + restrict_domain cmp blo bhi (to_fmap cmp t1')`, + rw [invariant_eq, restrict_domain_def] >> + rfs [key_ordered_to_fmap] >> + Cases_on `blo` >> + Cases_on `bhi` >> + rw [restrict_set_def, fmap_eq_flookup] >> + fmrw [] >> + fs [option_cmp_def, option_cmp2_def, restrict_set_def] >> + every_case_tac >> + rw [FLOOKUP_DEF] >> + metis_tac [cmp_thms, key_set_eq, key_set_cmp_thm, to_fmap_key_set]); + +val restrict_domain_combine = Q.prove ( +` good_cmp cmp ∧ + key_set cmp kx ≠ k ∧ + kx ∈ restrict_set cmp blo bhi + ⇒ + FLOOKUP (restrict_domain cmp (SOME kx) bhi (to_fmap cmp r2) ⊌ + restrict_domain cmp blo (SOME kx) (to_fmap cmp r2)) k = + FLOOKUP (restrict_domain cmp blo bhi (to_fmap cmp r2)) k`, + fmrw [restrict_domain_def] >> + every_case_tac >> + rw [] >> + Cases_on `blo` >> + Cases_on `bhi` >> + fs [restrict_set_def, option_cmp2_def, option_cmp_def, FLOOKUP_DEF] >> + metis_tac [key_set_eq, cmp_thms, to_fmap_key_set, key_set_cmp_thm]); + +val bounded_all_def = Define ` +(bounded_all cmp lk hk Tip ⇔ T) ∧ +(bounded_all cmp lk hk (Bin s k v t1 t2) ⇔ + k ∈ restrict_set cmp lk hk ∧ + bounded_all cmp lk hk t1 ∧ + bounded_all cmp lk hk t2)`; + +val bounded_all_shrink1 = Q.prove ( +`!t blo bhi. + good_cmp cmp ∧ + bounded_all cmp blo bhi t ∧ + key_ordered cmp kx t Greater + ⇒ + bounded_all cmp blo (SOME kx) t`, + Induct_on `t` >> + rw [bounded_all_def, key_ordered_def] + >- (Cases_on `blo` >> + fs [restrict_set_def, option_cmp_def, option_cmp2_def] >> + metis_tac [good_cmp_def, comparison_distinct]) >> + metis_tac []); + +val bounded_all_shrink2 = Q.prove ( +`!t blo bhi. + good_cmp cmp ∧ + bounded_all cmp blo bhi t ∧ + key_ordered cmp kx t Less + ⇒ + bounded_all cmp (SOME kx) bhi t`, + Induct_on `t` >> + rw [bounded_all_def, key_ordered_def] + >- (Cases_on `bhi` >> + fs [restrict_set_def, option_cmp_def, option_cmp2_def] >> + metis_tac [good_cmp_def, comparison_distinct]) >> + metis_tac []); + +val bounded_restrict_id = Q.prove ( +`!t. + good_cmp cmp ∧ + bounded_all cmp blo bhi t + ⇒ + restrict_domain cmp blo bhi (to_fmap cmp t) = to_fmap cmp t`, + Induct_on `t` >> + rw [bounded_all_def, to_fmap_def, restrict_domain_union, restrict_domain_update] >> + Cases_on `blo` >> + Cases_on `bhi` >> + fs [restrict_domain_def, restrict_set_def, option_cmp_def, option_cmp2_def]); + +val restrict_domain_empty = Q.prove ( +`good_cmp cmp ⇒ + restrict_domain cmp blo (SOME kx) (restrict_domain cmp (SOME kx) bhi t) = FEMPTY ∧ + restrict_domain cmp (SOME kx) bhi (restrict_domain cmp blo (SOME kx) t) = FEMPTY`, + Cases_on `blo` >> + Cases_on `bhi` >> + fmrw [restrict_domain_def, restrict_set_def, option_cmp_def, option_cmp2_def, fmap_eq_flookup] >> + metis_tac [good_cmp_def, comparison_distinct, key_set_eq]); + +val hedgeUnion_thm = Q.prove ( +`!cmp blo bhi t1 t2. + good_cmp cmp ∧ + invariant cmp t1 ∧ + invariant cmp t2 ∧ + bounded_all cmp blo bhi t1 ∧ + bounded_root cmp blo bhi t2 + ⇒ + invariant cmp (hedgeUnion cmp blo bhi t1 t2) ∧ + to_fmap cmp (hedgeUnion cmp blo bhi t1 t2) = + restrict_domain cmp blo bhi (to_fmap cmp t1 ⊌ to_fmap cmp t2)`, + ho_match_mp_tac (fetch "-" "hedgeUnion_ind") >> + rpt conj_tac >> + simp [hedgeUnion_def] >> + rpt conj_tac >> + rpt gen_tac >> + strip_tac + >- rw [to_fmap_def, FUNION_FEMPTY_2, bounded_restrict_id] + >- (inv_mp_tac link_thm >> + simp [GSYM CONJ_ASSOC] >> + inv_mp_tac filterGt_thm >> + simp [] >> + fs [invariant_eq] >> + strip_tac >> + inv_mp_tac filterLt_thm >> + simp [] >> + strip_tac >> + conj_tac + >- (rfs [key_ordered_to_fmap, restrict_domain_def] >> + Cases_on `blo` >> + fs [restrict_set_def, option_cmp_def, option_cmp2_def]) >> + conj_tac + >- (rfs [key_ordered_to_fmap, restrict_domain_def] >> + Cases_on `bhi` >> + fs [restrict_set_def, option_cmp_def, option_cmp2_def]) >> + `restrict_domain cmp blo bhi FEMPTY = FEMPTY` by rw [restrict_domain_def] >> + rw [to_fmap_def, restrict_domain_union, restrict_domain_update] >> + fmrw [restrict_domain_def, fmap_eq_flookup] >> + rw [] >> + Cases_on `blo` >> + Cases_on `bhi` >> + fs [restrict_set_def, option_cmp_def, option_cmp2_def, bounded_root_def] >> + fs [] >> + rw [FLOOKUP_DEF] >> + metis_tac [key_ordered_to_fmap, cmp_thms, to_fmap_key_set, key_set_cmp_thm]) + >- (inv_mp_tac insertR_thm >> + imp_res_tac bounded_restrict_id >> + rw [restrict_domain_union, to_fmap_def, restrict_domain_update] >> + rw [restrict_domain_def, fmap_eq_flookup] >> + fmrw [] >> + every_case_tac >> + fs [FLOOKUP_DEF, bounded_root_def]) >| + [qabbrev_tac `r1 = Bin v39 v40 v41 v42 v43` >> + qabbrev_tac `r2 = Bin v9 v10 v11 Tip r1`, + qabbrev_tac `r1 = Bin v29 v30 v31 v32 v33` >> + qabbrev_tac `r2 = Bin v9 v10 v11 r1 v13`] >> +(simp [bounded_all_def] >> + strip_tac >> + inv_mp_tac link_thm >> + `invariant cmp t1'` by metis_tac [invariant_def] >> + `invariant cmp t1` by metis_tac [invariant_def] >> + simp [bounded_all_def, GSYM CONJ_ASSOC] >> + FIRST_X_ASSUM inv_mp_tac >> + simp [GSYM CONJ_ASSOC] >> + inv_mp_tac trim_thm >> + simp [bounded_all_def] >> + strip_tac >> + conj_tac + >- (fs [invariant_eq] >> + metis_tac [bounded_all_shrink1]) >> + strip_tac >> + FIRST_X_ASSUM inv_mp_tac >> + simp [GSYM CONJ_ASSOC] >> + inv_mp_tac trim_thm >> + simp [bounded_all_def] >> + strip_tac >> + conj_tac + >- (fs [invariant_eq] >> + metis_tac [bounded_all_shrink2]) >> + strip_tac >> + qabbrev_tac `m1 = hedgeUnion cmp blo (SOME kx) t1 (trim cmp blo (SOME kx) r2)` >> + qabbrev_tac `m2 = hedgeUnion cmp (SOME kx) bhi t1' (trim cmp (SOME kx) bhi r2)` >> + conj_asm1_tac + >- (rw [key_ordered_to_fmap, restrict_domain_union] >> + Cases_on `blo` >> + fs [restrict_domain_def, restrict_set_def, option_cmp_def, option_cmp2_def] >> + metis_tac [good_cmp_def, comparison_distinct, key_set_cmp_thm]) >> + conj_asm1_tac + >- (rw [key_ordered_to_fmap, restrict_domain_union] >> + Cases_on `bhi` >> + fs [restrict_domain_def, restrict_set_def, option_cmp_def, option_cmp2_def] >> + metis_tac [good_cmp_def, comparison_distinct, key_set_cmp_thm]) >> + rw [restrict_domain_union, restrict_domain_update] >> + `key_set cmp kx ∉ FDOM (to_fmap cmp m1) ∧ key_set cmp kx ∉ FDOM (to_fmap cmp m2)` + by metis_tac [key_ordered_to_fmap, cmp_thms, to_fmap_key_set, key_set_cmp_thm] >> + `restrict_domain cmp blo (SOME kx) (to_fmap cmp m2) SUBMAP (to_fmap cmp m1) ∧ + restrict_domain cmp (SOME kx) bhi (to_fmap cmp m1) SUBMAP (to_fmap cmp m2)` + by (qunabbrev_tac `m1` >> + qunabbrev_tac `m2` >> + rw [restrict_domain_union, SUBMAP_DEF, restrict_domain_empty]) >> + `restrict_domain cmp blo bhi (to_fmap cmp m1) ⊌ + restrict_domain cmp blo bhi (to_fmap cmp m2) = + restrict_domain cmp blo (SOME kx) (to_fmap cmp m1) ⊌ + restrict_domain cmp (SOME kx) bhi (to_fmap cmp m2)` + by metis_tac [restrict_domain_partition] >> + simp [restrict_domain_union, restrict_domain_update, to_fmap_def] >> + rw [restrict_domain_union_swap] >> + imp_res_tac restrict_domain_extend >> + rw [] >> + simp [fmap_eq_flookup] >> + rw [FLOOKUP_UPDATE] >> + REWRITE_TAC [GSYM FUNION_ASSOC] >> + ONCE_REWRITE_TAC [FLOOKUP_FUNION] >> + every_case_tac >> + ONCE_REWRITE_TAC [FLOOKUP_FUNION] >> + every_case_tac >> + metis_tac [restrict_domain_combine])); + +val bounded_all_NONE = Q.prove ( +`!cmp t. bounded_all cmp NONE NONE t`, + Induct_on `t` >> + rw [bounded_all_def, restrict_set_def, option_cmp_def, option_cmp2_def]); + +val union_thm = Q.store_thm ("union_thm", +`!cmp blo bhi t1 t2. + good_cmp cmp ∧ + invariant cmp t1 ∧ + invariant cmp t2 + ⇒ + invariant cmp (union cmp t1 t2) ∧ + to_fmap cmp (union cmp t1 t2) = (to_fmap cmp t1 ⊌ to_fmap cmp t2)`, + Cases_on `t1` >> + Cases_on `t2` >> + simp [union_def, to_fmap_def] >> + gen_tac >> + strip_tac >> + inv_mp_tac hedgeUnion_thm >> + rw [bounded_all_NONE, bounded_root_def, restrict_set_def, option_cmp_def, + restrict_domain_def, option_cmp2_def, to_fmap_def] >> + rw [fmap_eq_flookup] >> + fmrw [] >> + every_case_tac >> + fs [FLOOKUP_DEF, invariant_eq] >> + rfs [key_ordered_to_fmap] >> + metis_tac [cmp_thms, to_fmap_key_set]); + +val EXT2 = Q.prove ( +`!s1 s2. s1 = s2 ⇔ (!k v. (k,v) ∈ s1 ⇔ (k,v) ∈ s2)`, + rw [EXTENSION] >> + EQ_TAC >> + rw [] >> + PairCases_on `x` >> + rw []); + +val lift_key_def = Define ` +lift_key cmp kvs = IMAGE (\(k,v). (key_set cmp k, v)) kvs`; + +val toAscList_helper = Q.prove ( +`!cmp l t. + good_cmp cmp ∧ + invariant cmp t ∧ + SORTED (\(x,y) (x',y'). cmp x x' = Less) l ∧ + (!k1 v1 k2 v2. MEM (k1,v1) l ∧ FLOOKUP (to_fmap cmp t) (key_set cmp k2) = SOME v2 ⇒ cmp k2 k1 = Less) + ⇒ + SORTED (\(x,y) (x',y'). cmp x x' = Less) (foldrWithKey (λk x xs. (k,x)::xs) l t) ∧ + lift_key cmp (set (foldrWithKey (λk x xs. (k,x)::xs) l t)) = + set (fmap_to_alist (to_fmap cmp t)) ∪ lift_key cmp (set l)`, + Induct_on `t` >> + simp [foldrWithKey_def, to_fmap_def] >> + fs [invariant_eq, EXT2] >> + rpt gen_tac >> + strip_tac >> + simp [FLOOKUP_UPDATE, FLOOKUP_FUNION, PULL_FORALL] >> + rpt gen_tac >> + first_x_assum (qspecl_then [`cmp`, `l`] mp_tac) >> + first_x_assum (qspecl_then [`cmp`, `(k,v)::foldrWithKey (λk x xs. (k,x)::xs) l t'`] mp_tac) >> + simp [] >> + strip_tac >> + strip_tac >> + fs [FLOOKUP_UPDATE, FLOOKUP_FUNION] >> + `SORTED (λ(x,y) (x',y'). cmp x x' = Less) (foldrWithKey (λk x xs. (k,x)::xs) l t') ∧ + ∀k v. + (k,v) ∈ lift_key cmp (set (foldrWithKey (λk x xs. (k,x)::xs) l t')) ⇔ + FLOOKUP (to_fmap cmp t') k = SOME v ∨ (k,v) ∈ lift_key cmp (set l)` + by (first_x_assum match_mp_tac >> + rw [] >> + last_x_assum match_mp_tac >> + rw [] + >- metis_tac [] >> + qexists_tac `v1` >> + rw [] >> + qexists_tac `v2` >> + rw [] >> + every_case_tac >> + fs [DISJOINT_DEF, EXTENSION, FLOOKUP_DEF] >> + metis_tac []) >> + `SORTED (λ(x,y) (x',y'). cmp x x' = Less) + (foldrWithKey (λk x xs. (k,x)::xs) + ((k,v)::foldrWithKey (λk x xs. (k,x)::xs) l t') t) ∧ + ∀k' v'. + (k',v') ∈ lift_key cmp (set (foldrWithKey (λk x xs. (k,x)::xs) ((k,v)::foldrWithKey (λk x xs. (k,x)::xs) l t') t)) ⇔ + FLOOKUP (to_fmap cmp t) k' = SOME v' ∨ + (k',v') ∈ lift_key cmp ((k,v) INSERT set (foldrWithKey (λk x xs. (k,x)::xs) l t'))` + by (first_x_assum match_mp_tac >> + simp [good_cmp_trans, SORTED_EQ, FORALL_PROD] >> + rw [] + >- (`(key_set cmp p_1, p_2) ∈ lift_key cmp (set (foldrWithKey (λk x xs. (k,x)::xs) l t'))` + by (fs [lift_key_def, LAMBDA_PROD, EXISTS_PROD] >> + metis_tac []) >> + rfs [FLOOKUP_DEF] >> + rfs [key_ordered_to_fmap] + >- metis_tac [cmp_thms, key_set_cmp_thm] >> + fs [lift_key_def, LAMBDA_PROD, EXISTS_PROD] >> + metis_tac [cmp_thms, key_set_eq]) + >- (rfs [key_ordered_to_fmap, FLOOKUP_DEF] >> + metis_tac [cmp_thms, key_set_cmp_thm]) + >- (`(key_set cmp k1, v1) ∈ lift_key cmp (set (foldrWithKey (λk x xs. (k,x)::xs) l t'))` + by (fs [lift_key_def, LAMBDA_PROD, EXISTS_PROD] >> + metis_tac []) >> + rfs [FLOOKUP_DEF] >> + rfs [key_ordered_to_fmap] + >- metis_tac [cmp_thms, key_set_cmp_thm] >> + fs [lift_key_def, LAMBDA_PROD, EXISTS_PROD] >> + metis_tac [cmp_thms, key_set_cmp_thm, key_set_eq])) >> + simp [] >> + eq_tac >> + rw [] >> + fs [FLOOKUP_DEF, DISJOINT_DEF, EXTENSION, FLOOKUP_DEF] >> + every_case_tac >> + rw [] >> + fs [lift_key_def, LAMBDA_PROD, EXISTS_PROD] >> + metis_tac []); + +val toAscList_thm = Q.store_thm ("toAscList_thm", +`!cmp t. + good_cmp cmp ∧ + invariant cmp t + ⇒ + SORTED (\(x,y) (x',y'). cmp x x' = Less) (toAscList t) ∧ + lift_key cmp (set (toAscList t)) = set (fmap_to_alist (to_fmap cmp t))`, + rpt gen_tac >> + strip_tac >> + qspecl_then [`cmp`, `[]`, `t`] mp_tac toAscList_helper >> + simp [toAscList_def, lift_key_def]); + +val compare_good_cmp = Q.store_thm ("compare_good_cmp", +`!cmp1 cmp2. good_cmp cmp1 ∧ good_cmp cmp2 ⇒ good_cmp (compare cmp1 cmp2)`, + rw [] >> + imp_res_tac pair_cmp_good >> + imp_res_tac list_cmp_good >> + rpt (pop_assum mp_tac) >> + REWRITE_TAC [good_cmp_def, compare_def] >> + metis_tac []); + +val compare_thm1 = Q.prove ( +`!cmp1 cmp2 t1 t2. + good_cmp cmp1 ∧ + good_cmp cmp2 ∧ + invariant cmp1 t1 ∧ + invariant cmp1 t2 ∧ + compare cmp1 cmp2 t1 t2 = Equal + ⇒ + fmap_rel (\x y. cmp2 x y = Equal) (to_fmap cmp1 t1) (to_fmap cmp1 t2)`, + rw [compare_def, fmap_rel_OPTREL_FLOOKUP, OPTREL_def] >> + imp_res_tac toAscList_thm >> + fs [lift_key_def, list_cmp_equal_list_rel, pair_cmp_def] >> + fs [key_set_def, EXTENSION, LAMBDA_PROD, FORALL_PROD, EXISTS_PROD] >> + fs [LIST_REL_EL_EQN] >> + pop_assum (mp_tac o GSYM) >> + pop_assum (mp_tac o GSYM) >> + rw [] >> + Cases_on `FLOOKUP (to_fmap cmp1 t1) k` >> + rw [] + >- (disj1_tac >> + Cases_on `FLOOKUP (to_fmap cmp1 t2) k` >> + fs [] >> + rfs [] >> + fs [MEM_EL] >> + res_tac >> + Cases_on `EL n (toAscList t1)` >> + Cases_on `EL n (toAscList t2)` >> + fs [] >> + every_case_tac >> + fs [] >> + rw [] >> + first_x_assum (qspecl_then [`k`] mp_tac) >> + strip_tac >> + rfs [] >> + pop_assum (qspecl_then [`r`, `q`] mp_tac) >> + rw [] >> + metis_tac [NOT_SOME_NONE, cmp_thms]) + >- (rfs [] >> + fs [MEM_EL] >> + rfs [] >> + res_tac >> + Cases_on `EL n (toAscList t1)` >> + Cases_on `EL n (toAscList t2)` >> + fs [] >> + every_case_tac >> + fs [] >> + rw [] >> + MAP_EVERY qexists_tac [`r`, `r'`] >> + rw [] + >- metis_tac [] >> + qexists_tac `q'` >> + rw [] >> + metis_tac [cmp_thms])); + +val NONE_lem = Q.prove ( +`x = NONE ⇔ ¬?y. x = SOME y`, + Cases_on `x` >> + rw []); + +val pair_cmp_lem = Q.prove ( +`!cmp1 cmp2. pair_cmp cmp1 cmp2 (x1,x2) (y1,y2) = Equal ⇔ cmp1 x1 y1 = Equal ∧ cmp2 x2 y2 = Equal`, + rw [pair_cmp_def] >> + every_case_tac); + +val strict_sorted_unique = Q.prove ( +`!cmp l x1 y1 x2 y2. + good_cmp cmp ∧ + SORTED (λ(x,y) (x',y'). cmp x x' = Less) l ∧ + MEM (x1,y1) l ∧ + MEM (x2,y2) l ∧ + cmp x1 x2 = Equal + ⇒ + x1 = x2 ∧ y1 = y2`, + Induct_on `l` >> + rw [] >> + `transitive (λ(x,y) (x',y'). cmp x x' = Less)` by metis_tac [good_cmp_trans] >> + fs [SORTED_EQ, LAMBDA_PROD, FORALL_PROD] + >- metis_tac [cmp_thms] + >- metis_tac [cmp_thms] + >- metis_tac [cmp_thms] + >- metis_tac [cmp_thms] >> + Cases_on `h` >> + fs [] >> + res_tac); + +val strict_sorted_eq_el = Q.prove ( +`!cmp l m n. + good_cmp cmp ∧ + SORTED (λ(x,y) (x',y'). cmp x x' = Less) l ∧ + cmp (FST (EL m l)) (FST (EL n l)) = Equal ∧ + m < LENGTH l ∧ + n < LENGTH l + ⇒ + m = n`, + Induct_on `l` >> + rw [] >> + `transitive (λ(x,y) (x',y'). cmp x x' = Less)` by metis_tac [good_cmp_trans] >> + fs [SORTED_EQ, LAMBDA_PROD, FORALL_PROD] >> + Cases_on `h` >> + fs [] >> + Cases_on `0 < n` >> + Cases_on `0 < m` >> + fs [rich_listTheory.EL_CONS] >> + full_simp_tac (srw_ss()++ARITH_ss) [] >> + rw [] + >- (res_tac >> + full_simp_tac (srw_ss()++ARITH_ss) []) + >- (`PRE n < LENGTH l` by decide_tac >> + `MEM (EL (PRE n) l) l` by metis_tac [MEM_EL] >> + Cases_on `EL (PRE n) l` >> + fs [] >> + metis_tac [cmp_thms]) + >- (`PRE m < LENGTH l` by decide_tac >> + `MEM (EL (PRE m) l) l` by metis_tac [MEM_EL] >> + Cases_on `EL (PRE m) l` >> + fs [] >> + metis_tac [cmp_thms])); + +val compare_lem2 = Q.prove ( +`!cmp1 cmp2 n l1 l2. + good_cmp cmp1 ∧ + good_cmp cmp2 ∧ + (∀k. + (∀y p_1' y' p_1''. + (k ≠ key_set cmp1 p_1' ∨ ¬MEM (p_1',y) l1) ∧ + (k ≠ key_set cmp1 p_1'' ∨ ¬MEM (p_1'',y') l2)) ∨ + ∃x y p_1' p_1''. + (k = key_set cmp1 p_1' ∧ MEM (p_1',x) l1) ∧ + (k = key_set cmp1 p_1'' ∧ MEM (p_1'',y) l2) ∧ cmp2 x y = Equal) ∧ + SORTED (λ(x,y) (x',y'). cmp1 x x' = Less) l2 ∧ + SORTED (λ(x,y) (x',y'). cmp1 x x' = Less) l1 ∧ + n ≤ LENGTH l1 ∧ + n ≤ LENGTH l2 ∧ + LIST_REL (λ(p1,p2) (p1',p2'). pair_cmp cmp1 cmp2 (p1,p2) (p1',p2') = Equal) + (TAKE n l1) (TAKE n l2) ∧ + n ≠ LENGTH l1 + ⇒ + n ≠ LENGTH l2 ∧ + (λ(p1,p2) (p1',p2'). pair_cmp cmp1 cmp2 (p1,p2) (p1',p2') = Equal) + (EL n l1) (EL n l2)`, + rpt GEN_TAC >> + rpt DISCH_TAC >> + fs [] >> + `?kn1 vn1. EL n l1 = (kn1,vn1)` by metis_tac [pair_CASES] >> + simp [] >> + `?kn2 vn2. MEM (kn2,vn2) l2 ∧ cmp1 kn1 kn2 = Equal ∧ cmp2 vn1 vn2 = Equal` + by (first_assum (qspecl_then [`key_set cmp1 kn1`] assume_tac) >> + `MEM (EL n l1) l1` by metis_tac [PAIR, rich_listTheory.EL_MEM, LESS_OR_EQ] >> + fs [] >> + rfs [key_set_eq] + >- metis_tac [PAIR, cmp_thms] >> + `p_1' = kn1 ∧ x = vn1` + by (match_mp_tac strict_sorted_unique >> + rw [] >> + metis_tac [cmp_thms]) >> + rw [] >> + metis_tac []) >> + fs [MEM_EL] >> + `n' < n ∨ n = n' ∨ n < n'` by decide_tac >> + fs [] + >- (fs [LIST_REL_EL_EQN] >> + first_x_assum (qspecl_then [`n'`] mp_tac) >> + simp [rich_listTheory.EL_TAKE] >> + DISCH_TAC >> + fs [] >> + Cases_on `EL n' l1` >> + Cases_on `EL n' l2` >> + fs [pair_cmp_lem] >> + `n' < LENGTH l1 ∧ n < LENGTH l1` by decide_tac >> + imp_res_tac strict_sorted_eq_el >> + `n' = n` by metis_tac [FST, PAIR, cmp_thms] >> + fs []) + >- (rw [pair_cmp_lem] >> + Cases_on `EL n l2` >> + rw [] >> + metis_tac []) + >- (`?kn3 vn3. EL n l2 = (kn3,vn3)` by metis_tac [pair_CASES] >> + simp [] >> + `?kn4 vn4. MEM (kn4,vn4) l1 ∧ cmp1 kn3 kn4 = Equal ∧ cmp2 vn3 vn4 = Equal` + by (first_assum (qspecl_then [`key_set cmp1 kn3`] assume_tac) >> + `n < LENGTH l2` by decide_tac >> + `n < LENGTH l1` by decide_tac >> + `MEM (EL n l2) l2` by metis_tac [PAIR, rich_listTheory.EL_MEM, LESS_OR_EQ] >> + fs [] >> + rfs [key_set_eq] >> + `n < LENGTH l2` by decide_tac >> + `n < LENGTH l1` by decide_tac + >- metis_tac [PAIR, cmp_thms] >> + rw [] >> + `p_1'' = kn3 ∧ y = vn3` + by (match_mp_tac strict_sorted_unique >> + rw [] >> + metis_tac [rich_listTheory.EL_MEM, cmp_thms]) >> + rw [] >> + MAP_EVERY qexists_tac [`p_1'`, `x`] >> + rw [rich_listTheory.EL_MEM] >> + metis_tac [cmp_thms]) >> + fs [MEM_EL] >> + `n < n'' ∨ n = n'' ∨ n'' < n` by decide_tac >> + fs [] >> + `cmp1 kn3 kn2 = Less` + by (`transitive (λ(x,y) (x',y'). cmp1 x x' = Less)` by metis_tac [good_cmp_trans] >> + `(λ(x,y) (x',y'). cmp1 x x' = Less) (EL n l2) (EL n' l2)` + by metis_tac [SORTED_EL_LESS] >> + rfs [] >> + Cases_on `EL n' l2` >> + fs []) + >- (`cmp1 kn1 kn4 = Less` + by (`transitive (λ(x,y) (x',y'). cmp1 x x' = Less)` by metis_tac [good_cmp_trans] >> + `(λ(x,y) (x',y'). cmp1 x x' = Less) (EL n l1) (EL n'' l1)` + by metis_tac [SORTED_EL_LESS] >> + rfs [] >> + Cases_on `EL n'' l1` >> + fs []) >> + metis_tac [cmp_thms]) + >- (rw [] >> + rfs [] >> + metis_tac [cmp_thms]) + >- (fs [LIST_REL_EL_EQN] >> + first_x_assum (qspecl_then [`n''`] mp_tac) >> + simp [rich_listTheory.EL_TAKE] >> + DISCH_TAC >> + fs [] >> + Cases_on `EL n'' l1` >> + Cases_on `EL n'' l2` >> + fs [pair_cmp_lem] >> + rfs [] >> + `n < LENGTH l2` by decide_tac >> + `cmp1 kn1 kn4 = Less` + by (`transitive (λ(x,y) (x',y'). cmp1 x x' = Less)` by metis_tac [good_cmp_trans] >> + `(λ(x,y) (x',y'). cmp1 x x' = Less) (EL n'' l2) (EL n l2)` + by metis_tac [SORTED_EL_LESS] >> + rfs [] >> + Cases_on `EL n'' l2` >> + fs [] >> + metis_tac [cmp_thms]) >> + metis_tac [cmp_thms]))); + +val compare_thm2 = Q.prove ( +`!cmp1 cmp2 t1 t2. + good_cmp cmp1 ∧ + good_cmp cmp2 ∧ + invariant cmp1 t1 ∧ + invariant cmp1 t2 ∧ + fmap_rel (\x y. cmp2 x y = Equal) (to_fmap cmp1 t1) (to_fmap cmp1 t2) + ⇒ + compare cmp1 cmp2 t1 t2 = Equal`, + rw [compare_def, fmap_rel_OPTREL_FLOOKUP, OPTREL_def, list_cmp_equal_list_rel] >> + imp_res_tac toAscList_thm >> + fs [EXTENSION] >> + simp [] >> + fs [lift_key_def, PULL_EXISTS, LAMBDA_PROD, FORALL_PROD, EXISTS_PROD] >> + pop_assum (mp_tac o GSYM) >> + pop_assum (mp_tac o GSYM) >> + DISCH_TAC >> + DISCH_TAC >> + fs [NONE_lem] >> + ntac 3 (pop_assum (fn _ => all_tac)) >> + pop_assum mp_tac >> + pop_assum mp_tac >> + pop_assum (fn _ => all_tac) >> + pop_assum mp_tac >> + ntac 2 (pop_assum (fn _ => all_tac)) >> + Q.SPEC_TAC (`toAscList t1`, `l1`) >> + Q.SPEC_TAC (`toAscList t2`, `l2`) >> + fs [PULL_FORALL, PULL_EXISTS] >> + rw [] >> + ONCE_REWRITE_TAC [list_rel_thm] >> + gen_tac >> + DISCH_TAC >> + fs [] + >- (match_mp_tac compare_lem2 >> + rw []) + >- (`n ≠ LENGTH l1 ∧ (λ(p1,p2) (p1',p2'). pair_cmp cmp1 cmp2 (p1,p2) (p1',p2') = Equal) (EL n l2) (EL n l1)` + by (match_mp_tac compare_lem2 >> + rw [] + >- (first_x_assum (qspecl_then [`k`] mp_tac) >> + rw [] >> + metis_tac [good_cmp_def]) + >- (match_mp_tac (SIMP_RULE (srw_ss()) [AND_IMP_INTRO, PULL_FORALL] (GEN_ALL EVERY2_sym)) >> + qexists_tac `(λ(p1,p2) (p1',p2'). pair_cmp cmp1 cmp2 (p1,p2) (p1',p2') = Equal)` >> + rw [] >> + PairCases_on `y'` >> + PairCases_on `x'` >> + fs [] >> + metis_tac [good_cmp_def, pair_cmp_good])) >> + Cases_on `EL n l1` >> + Cases_on `EL n l2` >> + fs [] >> + metis_tac [good_cmp_def, pair_cmp_good])); + +val compare_thm = Q.store_thm ("compare_thm", +`!cmp1 cmp2 t1 t2. + good_cmp cmp1 ∧ + good_cmp cmp2 ∧ + invariant cmp1 t1 ∧ + invariant cmp1 t2 + ⇒ + (compare cmp1 cmp2 t1 t2 = Equal + ⇔ + fmap_rel (\x y. cmp2 x y = Equal) (to_fmap cmp1 t1) (to_fmap cmp1 t2))`, + metis_tac [compare_thm1, compare_thm2]); + +val map_thm = Q.store_thm ("map_thm", +`!t. + good_cmp cmp ∧ + invariant cmp t + ⇒ + invariant cmp (map f t) ∧ + to_fmap cmp (map f t) = f o_f to_fmap cmp t`, + Induct_on `t` >> + simp [map_def, to_fmap_def] + >- rw [invariant_def] >> + rpt gen_tac >> + strip_tac >> + simp [invariant_def, GSYM CONJ_ASSOC] >> + inv_to_front_tac ``invariant`` >> + first_x_assum inv_mp_tac >> + simp [] >> + fs [invariant_eq] >> + strip_tac >> + imp_res_tac (GSYM structure_size_thm) >> + imp_res_tac size_thm >> + simp [FCARD_DEF] >> + rw [] + >- rfs [key_ordered_to_fmap] + >- rfs [key_ordered_to_fmap] + >- fs [FCARD_DEF] + >- (fmrw [fmap_eq_flookup] >> + fmrw [FLOOKUP_o_f, DOMSUB_FLOOKUP_THM] >> + every_case_tac >> + fs [])); + +val splitLookup_thm = Q.store_thm ("splitLookup_thm", +`!t lt v gt. + good_cmp cmp ∧ + invariant cmp t ∧ + (lt,v,gt) = splitLookup cmp k t + ⇒ + invariant cmp lt ∧ + invariant cmp gt ∧ + FLOOKUP (to_fmap cmp t) (key_set cmp k) = v ∧ + key_ordered cmp k lt Greater ∧ + key_ordered cmp k gt Less ∧ + to_fmap cmp t = + case v of + | NONE => FUNION (to_fmap cmp lt) (to_fmap cmp gt) + | SOME v => (FUNION (to_fmap cmp lt) (to_fmap cmp gt)) |+ (key_set cmp k, v)`, + Induct_on `t` >> + simp [splitLookup_def, to_fmap_def, key_ordered_to_fmap] >> + rpt gen_tac >> + strip_tac >> + Cases_on `cmp k k'` >> + fs [] + >- (`?lt v gt. splitLookup cmp k t = (lt,v,gt)` by metis_tac [pair_CASES] >> + fs [] >> + last_x_assum inv_mp_tac >> + simp [] >> + fs [invariant_eq] >> + strip_tac >> + inv_mp_tac link_thm >> + simp [] >> + conj_asm1_tac + >- (rfs [key_ordered_to_fmap] >> + rw [] >> + first_x_assum match_mp_tac >> + rw [] >> + every_case_tac >> + fs []) >> + strip_tac >> + Cases_on `v''` >> + fs [] >> + fmrw [] >> + rfs [FLOOKUP_FUNION] >> + every_case_tac >> + fs [] >> + TRY (match_mp_tac FUPDATE_COMMUTES) >> + rfs [key_ordered_to_fmap, flookup_thm] >> + res_tac >> + metis_tac [cmp_thms, key_set_cmp_def, key_set_cmp_thm]) + >- (`?lt v gt. splitLookup cmp k t' = (lt,v,gt)` by metis_tac [pair_CASES] >> + fs [] >> + fs [invariant_eq] >> + inv_mp_tac link_thm >> + simp [] >> + conj_asm1_tac + >- (rfs [key_ordered_to_fmap] >> + rw [] >> + first_x_assum match_mp_tac >> + rw [] >> + every_case_tac >> + fs []) >> + strip_tac >> + Cases_on `v''` >> + fs [] >> + fmrw [] >> + rfs [FLOOKUP_FUNION] >> + every_case_tac >> + fs [] >> + TRY (match_mp_tac FUPDATE_COMMUTES) >> + rfs [key_ordered_to_fmap, flookup_thm] >> + fs [key_ordered_to_fmap, flookup_thm] >> + res_tac >> + metis_tac [cmp_thms, key_set_cmp_def, key_set_cmp_thm]) + >- (fs [invariant_eq] >> + fmrw [key_set_eq] >> + rfs [key_ordered_to_fmap] >> + res_tac >> + fs [key_set_cmp_def] >> + fmrw [fmap_eq_flookup] >> + every_case_tac >> + fs [] >> + rw [] >> + rfs [key_set_eq] >> + metis_tac [cmp_thms])); + +val submap'_thm = Q.prove ( +`!cmp f t1 t2. + good_cmp cmp ∧ + invariant cmp t1 ∧ + invariant cmp t2 + ⇒ + (submap' cmp f t1 t2 ⇔ !k v. lookup cmp k t1 = SOME v ⇒ ?v'. lookup cmp k t2 = SOME v' ∧ f v v')`, + ho_match_mp_tac (fetch "-" "submap'_ind") >> + rpt conj_tac + >- rw [lookup_def, submap'_def] + >- (rw [lookup_def, submap'_def, invariant_eq] >> + qexists_tac `v11` >> + qexists_tac `v12` >> + every_case_tac >> + fs [] >> + metis_tac [cmp_thms]) >> + rw [] >> + qabbrev_tac `t = Bin v20 v21 v22 v23 v24` >> + `?lt v gt. splitLookup cmp kx t = (lt,v,gt)` by metis_tac [pair_CASES] >> + fs [] >> + `invariant cmp lt ∧ invariant cmp gt ∧ + FLOOKUP (to_fmap cmp t) (key_set cmp kx) = v ∧ + key_ordered cmp kx lt Greater ∧ key_ordered cmp kx gt Less ∧ + to_fmap cmp t = + case v of + NONE => to_fmap cmp lt ⊌ to_fmap cmp gt + | SOME v' => (to_fmap cmp lt ⊌ to_fmap cmp gt) |+ (key_set cmp kx,v')` + by metis_tac [splitLookup_thm] >> + unabbrev_all_tac >> + Cases_on `v` >> + fs [] + >- (rw [submap'_def, lookup_def] >> + qexists_tac `kx` >> + qexists_tac `x` >> + rw [] + >- metis_tac [cmp_thms] >> + every_case_tac >> + fs [] >> + CCONTR_TAC >> + fs [] >> + imp_res_tac lookup_thm >> + fs [lookup_def, to_fmap_def] >> + metis_tac [cmp_thms, NOT_SOME_NONE]) + >- (simp [submap'_def] >> + qabbrev_tac `t = Bin v20 v21 v22 v23 v24` >> + pop_assum (fn _ => all_tac) >> + fs [invariant_eq] >> + rw [lookup_def] >> + eq_tac >> + simp [] + >- (rw [] >> + imp_res_tac lookup_thm >> + rw [FLOOKUP_UPDATE] >> + rfs [key_set_eq] >> + fs [] + >- (`cmp k kx = Equal` by metis_tac [cmp_thms] >> + fs []) >> + rw [FLOOKUP_FUNION] >> + Cases_on `cmp k kx` >> + fs [] >> + res_tac + >- (qexists_tac `v''` >> + rw []) + >- (rfs [key_ordered_to_fmap] >> + `FLOOKUP (to_fmap cmp lt) (key_set cmp k) = NONE` + by (fs [FLOOKUP_DEF] >> + CCONTR_TAC >> + fs [] >> + res_tac >> + fs [key_set_cmp_def, key_set_def] >> + metis_tac [cmp_thms]) >> + rw []) + >- metis_tac [cmp_thms]) >> + rw [] + >- (first_assum (qspecl_then [`kx`, `x`] assume_tac) >> + every_case_tac >> + fs [] + >- metis_tac [cmp_thms] + >- metis_tac [cmp_thms] >> + imp_res_tac lookup_thm >> + fs [] >> + rfs [] >> + rw []) + >- (imp_res_tac lookup_thm >> + fs [] >> + rfs [FLOOKUP_UPDATE] >> + rw [] >> + last_assum (qspecl_then [`k`] assume_tac) >> + Cases_on `cmp k kx` >> + fs [] >> + rfs [key_set_eq] + >- (`cmp kx k ≠ Equal` by metis_tac [cmp_thms] >> + fs [FLOOKUP_FUNION] >> + Cases_on `FLOOKUP (to_fmap cmp lt) (key_set cmp k)` >> + fs [FLOOKUP_DEF] >> + rfs [key_ordered_to_fmap] >> + res_tac >> + fs [key_set_cmp_def, key_set_def] >> + metis_tac [cmp_thms]) + >- (`cmp kx k ≠ Equal` by metis_tac [cmp_thms] >> + fs [FLOOKUP_DEF] >> + rfs [key_ordered_to_fmap] >> + res_tac >> + fs [key_set_cmp_def, key_set_def] >> + metis_tac [cmp_thms]) + >- (`cmp kx k = Equal` by metis_tac [cmp_thms] >> + fs [FLOOKUP_DEF] >> + rfs [key_ordered_to_fmap] >> + res_tac >> + fs [key_set_cmp_def, key_set_def] >> + metis_tac [cmp_thms])) + >- (imp_res_tac lookup_thm >> + fs [] >> + rfs [FLOOKUP_UPDATE] >> + rw [] >> + last_assum (qspecl_then [`k`] assume_tac) >> + Cases_on `cmp k kx` >> + fs [] >> + rfs [key_set_eq] + >- (`cmp kx k ≠ Equal` by metis_tac [cmp_thms] >> + fs [FLOOKUP_DEF] >> + rfs [key_ordered_to_fmap] >> + res_tac >> + fs [key_set_cmp_def, key_set_def] >> + metis_tac [cmp_thms]) + >- (`cmp kx k ≠ Equal` by metis_tac [cmp_thms] >> + fs [FLOOKUP_FUNION] >> + Cases_on `FLOOKUP (to_fmap cmp lt) (key_set cmp k)` >> + fs [FLOOKUP_DEF] >> + rfs [key_ordered_to_fmap] >> + res_tac >> + fs [key_set_cmp_def, key_set_def] >> + metis_tac [cmp_thms]) + >- (`cmp kx k = Equal` by metis_tac [cmp_thms] >> + fs [FLOOKUP_DEF] >> + rfs [key_ordered_to_fmap] >> + res_tac >> + fs [key_set_cmp_def, key_set_def] >> + metis_tac [cmp_thms])))); + +val isSubmapOfBy_thm = Q.store_thm ("isSubmapOfBy_thm", +`!cmp f t1 t2. + good_cmp cmp ∧ + invariant cmp t1 ∧ + invariant cmp t2 + ⇒ + (isSubmapOfBy cmp f t1 t2 ⇔ !k v. lookup cmp k t1 = SOME v ⇒ ?v'. lookup cmp k t2 = SOME v' ∧ f v v')`, + rw [isSubmapOfBy_def] >> + Cases_on `size t1 ≤ size t2` >> + rw [submap'_thm] >> + fs [NOT_LESS_EQUAL] >> + imp_res_tac size_thm >> + imp_res_tac lookup_thm >> + fs [FCARD_DEF] >> + `FINITE (FDOM (to_fmap cmp t1)) ∧ FINITE (FDOM (to_fmap cmp t2))` by rw [] >> + imp_res_tac LESS_CARD_DIFF >> + full_simp_tac std_ss [] >> + `FINITE (FDOM (to_fmap cmp t1) DIFF FDOM (to_fmap cmp t2))` by rw [] >> + imp_res_tac POS_CARD_HAS_MEM >> + fs [] >> + rw [FLOOKUP_DEF] >> + imp_res_tac to_fmap_key_set >> + rw [] >> + qexists_tac `k` >> + rw []); + +val isSubmapOf_thm = Q.store_thm ("isSubmapOf_thm", +`!cmp t1 t2. + good_cmp cmp ∧ + invariant cmp t1 ∧ + invariant cmp t2 + ⇒ + (isSubmapOf cmp t1 t2 ⇔ !k v. lookup cmp k t1 = SOME v ⇒ lookup cmp k t2 = SOME v)`, + rw [isSubmapOf_def, isSubmapOfBy_thm]); + +val fromList_thm = Q.store_thm ("fromList_thm", +`!cmp l. + good_cmp cmp + ⇒ + invariant cmp (fromList cmp l) ∧ + to_fmap cmp (fromList cmp l) = alist_to_fmap (MAP (\(k,v). (key_set cmp k, v)) l)`, + Induct_on `l` >> + simp [fromList_def, empty_thm] >> + rpt gen_tac >> + strip_tac >> + PairCases_on `h` >> + simp [] >> + inv_mp_tac insert_thm >> + strip_tac >> + simp [] >> + fs [fromList_def]); + +(* ------------------------ Extra stuff, not from ghc ----------------- *) + +val map_keys_def = Define ` +map_keys cmp f t = fromList cmp (MAP (\(k,v). (f k, v)) (toAscList t))`; + +val in_lift_key = Q.prove ( +`!cmp k v l. + good_cmp cmp ∧ + SORTED (λ(x,y:'a) (x',y':'a). cmp x x' = Less) l ∧ + transitive (λ(x,y:'a) (x',y':'a). cmp x x' = Less) + ⇒ + ((k,v) ∈ lift_key cmp (set l) ⇔ ALOOKUP (MAP (λ(x,y). (key_set cmp x, y)) l) k = SOME v)`, + Induct_on `l` >> + fs [lift_key_def, key_set_def, LAMBDA_PROD, EXISTS_PROD, EXTENSION, FORALL_PROD] >> + rw [] >> + fs [] >> + eq_tac >> + rw [] >> + fs [SORTED_EQ] >> + res_tac >> + fs [] >> + metis_tac [cmp_thms]); + + (* +val alookup_unit_lem = Q.prove ( +`!cmp1 cmp2 f k l x. + good_cmp cmp1 ∧ + good_cmp cmp2 ∧ + resp_equiv2 cmp1 cmp2 f + ⇒ + (ALOOKUP (MAP (\(k,v). (key_set cmp1 k, ())) l) (key_set cmp1 x') = + ALOOKUP (MAP (\(k,v). (key_set cmp2 (f k), ())) l) (key_set cmp2 (f x')))`, + + Induct_on `l` >> + rw [] >> + PairCases_on `h` >> + rw [] >> + rfs [key_set_eq, resp_equiv2_def] >> + >- (rfs [] >> + fs [EXTENSION, key_set_def] >> + match_mp_tac (METIS_PROVE [] ``F⇒x``) >> + rw [] >> + pop_assum mp_tac >> + simp [] >> + eq_tac >> + rw [] >> + fs [resp_equiv2_def] + >- (qexists_tac `key_set cmp2 (f h0)` >> + rw [key_set_def] >> + metis_tac [cmp_thms]) + >- metis_tac [cmp_thms]) + >- (rfs [] >> + rw [] >> + fs [EXTENSION, key_set_def] >> + Cases_on `x ∈ k` >> + fs [resp_equiv2_def] >> + first_x_assum (qspecl_then [`f x`] assume_tac) >> + fs [] >> + Cases_on `cmp2 (f h0) (f x) = Equal` >> + fs [] +metis_tac [cmp_thms] + + + rfs [key_set_eq] >> + `IMAGE f (key_set cmp1 h0) ⊆ key_set cmp2 (f h0)` by metis_tac [key_set_map] >> + fs [SUBSET_DEF, EXTENSION] >> + `x ∈ key_set cmp2 (f h0) ∧ ¬?x'. x = f x' ∧ x' ∈ key_set cmp1 h0` by metis_tac [] + fs [] + + fs [key_set_def, resp_equiv2_def, EXTENSION] >> + rw [] >> + rfs [] >> + Cases_on `h1 = v` >> + rw [] >> + + pop_assum mp_tac >> + match_mp_tac (METIS_PROVE [] ``x ⇒ (~x ⇒ y)``) >> + eq_tac >> + rw [] + + metis_tac [cmp_thms] + >- (`IMAGE f k ≠ {}` by cheat >> + imp_res_tac CHOICE_DEF >> + fs [] >> + fs [] >> + + rfs [key_set_eq] >> + fs [key_set_def, resp_equiv2_def] >> + metis_tac [cmp_thms]) + + fs [resp_equiv2_def, key_set_def, EXTENSION] >> + rfs [] + metis_tac [] + *) + +val bigunion_key_sets = Q.prove ( +`!cmp1. + good_cmp cmp1 ∧ + good_cmp cmp2 ∧ + resp_equiv2 cmp1 cmp2 f + ⇒ + BIGUNION (IMAGE (\x. key_set cmp2 (f x)) (key_set cmp1 x)) = + key_set cmp2 (CHOICE (IMAGE f (key_set cmp1 x)))`, + rw [EXTENSION] >> + `IMAGE f (key_set cmp1 x) ≠ {}` by (rw [EXTENSION, key_set_def] >> metis_tac [cmp_thms]) >> + imp_res_tac CHOICE_DEF >> + fs [key_set_def] >> + eq_tac >> + rw [] >> + rfs [resp_equiv2_def] + >- metis_tac [cmp_thms] >> + qexists_tac `key_set cmp2 (f x)` >> + rw [key_set_def] >> + metis_tac [cmp_thms]); + +val image_lem = Q.prove ( +`good_cmp cmp1 + ⇒ + IMAGE (λx. key_set cmp2 (f x)) (key_set cmp1 k'') = + { key_set cmp2 (f x) | x | cmp1 x k'' = Equal }`, + rw [EXTENSION,key_set_def] >> + metis_tac [cmp_thms]); + + (* +val map_keys_thm = Q.store_thm ("map_keys_thm", +`!cmp1 cmp2 f t. + good_cmp cmp1 ∧ + good_cmp cmp2 ∧ + invariant cmp1 t ∧ + resp_equiv2 cmp1 cmp2 f ∧ + equiv_inj cmp1 cmp2 f + ⇒ + invariant cmp2 (map_keys cmp2 f t) ∧ + to_fmap cmp2 (map_keys cmp2 f t) = MAP_KEYS (BIGUNION o IMAGE (key_set cmp2 o f)) (to_fmap cmp1 t)`, + + simp [map_keys_def] >> + rpt gen_tac >> + DISCH_TAC >> + inv_mp_tac fromList_thm >> + rw [MAP_MAP_o, combinTheory.o_DEF] >> + rw [fmap_eq_flookup] >> + `SORTED (λ(x,y) (x',y'). cmp1 x x' = Less) (toAscList t) ∧ + lift_key cmp1 (set (toAscList t)) = set (fmap_to_alist (to_fmap cmp1 t))` + by metis_tac [toAscList_thm] >> + pop_assum mp_tac >> + simp [EXTENSION, MEM_MAP, LAMBDA_PROD, EXISTS_PROD, FORALL_PROD] >> + `transitive (λ(x,y:'c) (x',y':'c). cmp1 x x' = Less)` by metis_tac [good_cmp_trans] >> + rw [in_lift_key] >> + fs [] >> + rw [FLOOKUP_DEF] >> + `INJ (λx. BIGUNION (IMAGE (λx. key_set cmp2 (f x)) x)) (FDOM (to_fmap cmp1 t)) UNIV` + by rw [INJ_DEF] >> + imp_res_tac to_fmap_key_set + rw [] >> + CCONTR_TAC >> + fs [equiv_inj_def] >> + rfs [key_set_eq] >> + `cmp2 (f k'') (f k') ≠ Equal` by metis_tac [] + rfs [image_lem] + + fs [EXTENSION] + fs [PULL_EXISTS, PULL_FORALL] + + + rfs [bigunion_key_sets] + + fs [resp_equiv2_def, equiv_inj_def] + + rw [key_set_def] + fs [key_set_def] + CCONTR_TAC + Cases_on `cmp1 k' k'' = Equal` >> + fs [] + `cmp2 (f k') (f k'') ≠ Equal` by metis_tac [cmp_thms] +metis_tac [cmp_thms] + + Cases_on `ALOOKUP (MAP (λ(p1,p2). (key_set cmp2 (f p1),())) (toAscList t)) k = NONE` >> + fs [] + + Cases_on `?x. k = key_set cmp2 x` >> + fs [] + >- (Cases_on `?x'. x = f x'` >> + fs [] + >- (first_x_assum (qspecl_then [`key_set cmp1 x'`] mp_tac) >> + rw [] + + rw [] >> + + + fs [lift_key_def] + + Cases_on `FLOOKUP (MAP_KEYS (IMAGE f) (to_fmap cmp1 t)) k` + >- (fs [ALOOKUP_NONE, MEM_MAP, LAMBDA_PROD, EXISTS_PROD] >> + CCONTR_TAC >> + fs [] >> + rw [] >> + fs [lift_key_def, resp_equiv2_def, EXTENSION, LAMBDA_PROD,EXISTS_PROD, FORALL_PROD, + PULL_FORALL, PULL_EXISTS]>> + + fs [PULL_EXISTS, PULL_FORALL, key_set_def, EXTENSION] + + first_x_assum (qspecl_then [`key_set cmp1 p_1'`, `p_2`] assume_tac) >> + fs [FLOOKUP_DEF, MAP_KEYS_def] >> + fs [EXTENSION, key_set_def] >> + metis_tac [cmp_thms] + +val key_set_map = Q.prove ( +`!cmp1 cmp2 f k. + resp_equiv2 cmp1 cmp2 f ⇒ + IMAGE f (key_set cmp1 k) SUBSET key_set cmp2 (f k)`, + rw [key_set_def, SUBSET_DEF, resp_equiv2_def] >> + metis_tac []); + +`good_cmp cmp1 ∧ good_cmp cmp2 ∧ (!x y. cmp1 x y = Equal ⇒ x = y) /\ (!x y. cmp2 x y = Equal ⇒ x = y) ∧ (!x y. f x = f y ⇒ x = y) ⇒ resp_equiv2 cmp1 cmp2 f` + rw [resp_equiv2_def] >> + metis_tac [cmp_thms] + + +val flookup_lem = Q.prove ( +`!cmp1 cmp2 m k v f. + (FLOOKUP m k = + FLOOKUP (MAP_KEYS (BIGUNION o IMAGE (λx. key_set cmp2 (f x))) m) (BIGUNION o IMAGE (λx. key_set cmp2 (f k))))`, + + rw [FLOOKUP_DEF, MAP_KEYS_def] >> + eq_tac >> + rw [] + + +val map_keys_thm = Q.store_thm ("map_keys_thm", +`!cmp1 cmp2 f t. + good_cmp cmp1 ∧ + good_cmp cmp2 ∧ + invariant cmp1 t ∧ + resp_equiv2 cmp1 cmp2 f + ⇒ + invariant cmp2 (map_keys cmp2 f t) ∧ + to_fmap cmp2 (map_keys cmp2 f t) = MAP_KEYS (IMAGE f) (to_fmap cmp1 t)`, + + simp [map_keys_def] >> + rpt gen_tac >> + DISCH_TAC >> + inv_mp_tac fromList_thm >> + rw [MAP_MAP_o, combinTheory.o_DEF] >> + rw [LAMBDA_PROD] >> + rw [fmap_eq_flookup] >> + `SORTED (λ(x,y) (x',y'). cmp1 x x' = Less) (toAscList t) ∧ + lift_key cmp1 (set (toAscList t)) = set (fmap_to_alist (to_fmap cmp1 t))` + by metis_tac [toAscList_thm] >> + pop_assum mp_tac >> + simp [EXTENSION, MEM_MAP, LAMBDA_PROD, EXISTS_PROD, FORALL_PROD] >> + `transitive (λ(x,y:'c) (x',y':'c). cmp1 x x' = Less)` by metis_tac [good_cmp_trans] >> + rw [in_lift_key] >> + fs [] + + + fs [lift_key_def] + + Cases_on `FLOOKUP (MAP_KEYS (IMAGE f) (to_fmap cmp1 t)) k` + >- (rw [ALOOKUP_NONE, MEM_MAP, LAMBDA_PROD, EXISTS_PROD] >> + CCONTR_TAC >> + fs [] >> + rw [] >> + fs [lift_key_def, resp_equiv2_def, EXTENSION, LAMBDA_PROD,EXISTS_PROD, FORALL_PROD, + PULL_FORALL, PULL_EXISTS]>> + + fs [PULL_EXISTS, PULL_FORALL, key_set_def, EXTENSION] + + first_x_assum (qspecl_then [`key_set cmp1 p_1'`, `p_2`] assume_tac) >> + fs [FLOOKUP_DEF, MAP_KEYS_def] >> + fs [EXTENSION, key_set_def] >> + metis_tac [cmp_thms] + *) + +val every_def = Define ` +(every f Tip = T) ∧ +(every f (Bin _ kx x l r) = + if f kx x then + if every f l then + if every f r then T else F + else F + else F)`; + +val every_thm = Q.store_thm ("every_thm", +`!f t cmp. + good_cmp cmp ∧ + invariant cmp t ∧ + resp_equiv cmp f + ⇒ + (every f t ⇔ (!k v. lookup cmp k t = SOME v ⇒ f k v))`, + Induct_on `t` >> + rw [every_def, lookup_def] >> + fs [invariant_eq, resp_equiv_def] >> + first_x_assum (qspecl_then [`f`, `cmp`] assume_tac) >> + first_x_assum (qspecl_then [`f`, `cmp`] assume_tac) >> + rfs [] >> + eq_tac >> + rw [] + >- (EVERY_CASE_TAC >> + fs [] >> + metis_tac []) + >- (first_x_assum (qspecl_then [`k`] assume_tac) >> + rfs [] >> + EVERY_CASE_TAC >> + fs [] >> + metis_tac [cmp_thms]) + >- (first_x_assum (qspecl_then [`k'`] assume_tac) >> + EVERY_CASE_TAC >> + fs [] >> + rfs [lookup_thm, flookup_thm] >> + rfs [key_ordered_to_fmap] >> + res_tac >> + imp_res_tac key_set_cmp_thm >> + metis_tac [cmp_thms]) + >- (first_x_assum (qspecl_then [`k'`] assume_tac) >> + EVERY_CASE_TAC >> + fs [] >> + rfs [lookup_thm, flookup_thm] >> + rfs [key_ordered_to_fmap] >> + res_tac >> + imp_res_tac key_set_cmp_thm >> + metis_tac [cmp_thms])); + +val exists_def = Define ` +(exists f Tip = F) ∧ +(exists f (Bin _ kx x l r) = + if f kx x then + T + else if exists f l then + T + else if exists f r then + T + else + F)`; + +val exists_thm = Q.store_thm ("exists_thm", +`!f t cmp. + good_cmp cmp ∧ + invariant cmp t ∧ + resp_equiv cmp f + ⇒ + (exists f t ⇔ (?k v. lookup cmp k t = SOME v ∧ f k v))`, + Induct_on `t` >> + rw [exists_def, lookup_def] >> + fs [invariant_eq, resp_equiv_def] >> + first_x_assum (qspecl_then [`f`, `cmp`] assume_tac) >> + first_x_assum (qspecl_then [`f`, `cmp`] assume_tac) >> + rfs [] >> + eq_tac >> + rw [] + >- metis_tac [cmp_thms] + >- (qexists_tac `k'` >> + rw [] >> + EVERY_CASE_TAC >> + fs [] >> + rfs [lookup_thm, flookup_thm] >> + rfs [key_ordered_to_fmap] >> + res_tac >> + imp_res_tac key_set_cmp_thm >> + metis_tac [cmp_thms]) + >- (qexists_tac `k'` >> + rw [] >> + EVERY_CASE_TAC >> + fs [] >> + rfs [lookup_thm, flookup_thm] >> + rfs [key_ordered_to_fmap] >> + res_tac >> + imp_res_tac key_set_cmp_thm >> + metis_tac [cmp_thms]) + >- (EVERY_CASE_TAC >> + fs [] >> + metis_tac [])); + +val _ = export_theory (); diff --git a/examples/balanced_bst/comparisonScript.sml b/examples/balanced_bst/comparisonScript.sml new file mode 100644 index 0000000000..d563a2dd3c --- /dev/null +++ b/examples/balanced_bst/comparisonScript.sml @@ -0,0 +1,327 @@ +open HolKernel boolLib bossLib BasicProvers; +open optionTheory pairTheory stringTheory listTheory arithmeticTheory; +open lcsymtacs; + +val _ = new_theory "comparison"; + +val _ = temp_tight_equality (); +val every_case_tac = BasicProvers.EVERY_CASE_TAC; + +val _ = Datatype `comparison = Less | Greater | Equal`; + +val comparison_distinct = fetch "-" "comparison_distinct"; +val comparison_case_def = fetch "-" "comparison_case_def"; +val comparison_nchotomy = fetch "-" "comparison_nchotomy"; + +val good_cmp_def = Define ` +good_cmp cmp ⇔ + (!x. cmp x x = Equal) ∧ + (!x y. cmp x y = Equal ⇒ cmp y x = Equal) ∧ + (!x y. cmp x y = Greater ⇔ cmp y x = Less) ∧ + (!x y z. cmp x y = Equal ∧ cmp y z = Less ⇒ cmp x z = Less) ∧ + (!x y z. cmp x y = Less ∧ cmp y z = Equal ⇒ cmp x z = Less) ∧ + (!x y z. cmp x y = Equal ∧ cmp y z = Equal ⇒ cmp x z = Equal) ∧ + (!x y z. cmp x y = Less ∧ cmp y z = Less ⇒ cmp x z = Less)`; + +val good_cmp_thm = Q.store_thm ("good_cmp_thm", +`!cmp. + good_cmp cmp ⇔ + (!x. cmp x x = Equal) ∧ + (!x y z. + (cmp x y = Greater ⇔ cmp y x = Less) ∧ + (cmp x y = Less ∧ cmp y z = Equal ⇒ cmp x z = Less) ∧ + (cmp x y = Less ∧ cmp y z = Less ⇒ cmp x z = Less))`, + rw [good_cmp_def] >> + metis_tac [comparison_distinct, comparison_nchotomy]); + +val cmp_thms = save_thm ("cmp_thms", LIST_CONJ [comparison_distinct, comparison_case_def, comparison_nchotomy, good_cmp_def]) + +val option_cmp_def = Define ` +(option_cmp cmp NONE NONE = Equal) ∧ +(option_cmp cmp NONE (SOME x) = Less) ∧ +(option_cmp cmp (SOME x) NONE = Greater) ∧ +(option_cmp cmp (SOME x) (SOME y) = cmp x y)`; + +val option_cmp2_def = Define ` +(option_cmp2 cmp NONE NONE = Equal) ∧ +(option_cmp2 cmp NONE (SOME x) = Greater) ∧ +(option_cmp2 cmp (SOME x) NONE = Less) ∧ +(option_cmp2 cmp (SOME x) (SOME y) = cmp x y)`; + +val list_cmp_def = Define ` +(list_cmp cmp [] [] = Equal) ∧ +(list_cmp cmp [] (x::y) = Less) ∧ +(list_cmp cmp (x::y) [] = Greater) ∧ +(list_cmp cmp (x1::y1) (x2::y2) = + case cmp x1 x2 of + | Equal => list_cmp cmp y1 y2 + | Less => Less + | Greater => Greater)`; + +val list_cmp_ind = fetch "-" "list_cmp_ind"; + +val pair_cmp_def = Define ` +pair_cmp cmp1 cmp2 x y = + case cmp1 (FST x) (FST y) of + | Equal => cmp2 (SND x) (SND y) + | Less => Less + | Greater => Greater`; + +val bool_cmp_def = Define ` +(bool_cmp T T = Equal) ∧ +(bool_cmp F F = Equal) ∧ +(bool_cmp T F = Greater) ∧ +(bool_cmp F T = Less)`; + +val num_cmp_def = Define ` +num_cmp n1 n2 = + if n1 = n2 then + Equal + else if n1 < n2 then + Less + else + Greater`; + +val char_cmp_def = Define ` +char_cmp c1 c2 = num_cmp (ORD c1) (ORD c2)`; + +val string_cmp_def = Define ` +string_cmp = list_cmp char_cmp`; + +val option_cmp_good = Q.store_thm ("option_cmp_good", +`!cmp. good_cmp cmp ⇒ good_cmp (option_cmp cmp)`, + rw [good_cmp_def] >> + Cases_on `x` >> + TRY (Cases_on `y`) >> + TRY (Cases_on `z`) >> + metis_tac [option_cmp_def, comparison_distinct]); + +val option_cmp2_good = Q.store_thm ("option_cmp2_good", +`!cmp. good_cmp cmp ⇒ good_cmp (option_cmp2 cmp)`, + rw [good_cmp_def] >> + Cases_on `x` >> + TRY (Cases_on `y`) >> + TRY (Cases_on `z`) >> + metis_tac [option_cmp2_def, comparison_distinct]); + +val list_cmp_good = Q.store_thm ("list_cmp_good", +`!cmp. good_cmp cmp ⇒ good_cmp (list_cmp cmp)`, + simp [good_cmp_def] >> + rpt gen_tac >> + strip_tac >> + rpt conj_tac >> + Induct_on `x` >> + TRY (Cases_on `y`) >> + TRY (Cases_on `z`) >> + REWRITE_TAC [list_cmp_def] >> + rpt strip_tac >> + every_case_tac >> + metis_tac [list_cmp_def, comparison_distinct, comparison_case_def, comparison_nchotomy]); + +val pair_cmp_good = Q.store_thm ("pair_cmp_good", +`!cmp1 cmp2. good_cmp cmp1 ∧ good_cmp cmp2 ⇒ good_cmp (pair_cmp cmp1 cmp2)`, + simp [good_cmp_def] >> + rpt gen_tac >> + strip_tac >> + rpt conj_tac >> + TRY (Cases_on `x`) >> + TRY (Cases_on `y`) >> + TRY (Cases_on `z`) >> + REWRITE_TAC [pair_cmp_def] >> + rpt strip_tac >> + every_case_tac >> + metis_tac [pair_cmp_def, comparison_distinct, comparison_case_def, comparison_nchotomy]); + +val bool_cmp_good = Q.store_thm ("bool_cmp_good[simp]", +`good_cmp bool_cmp`, + simp [good_cmp_def] >> + rpt conj_tac >> + TRY (Cases_on `x`) >> + TRY (Cases_on `y`) >> + TRY (Cases_on `z`) >> + REWRITE_TAC [bool_cmp_def] >> + every_case_tac >> + fs []); + +val num_cmp_good = Q.store_thm ("num_cmp_good[simp]", +`good_cmp num_cmp`, + simp [good_cmp_def] >> + rpt conj_tac >> + TRY (Cases_on `x`) >> + TRY (Cases_on `y`) >> + TRY (Cases_on `z`) >> + REWRITE_TAC [num_cmp_def] >> + every_case_tac >> + full_simp_tac (srw_ss()++ARITH_ss) []); + +val char_cmp_good = Q.store_thm ("char_cmp_good[simp]", +`good_cmp char_cmp`, + simp [good_cmp_def] >> + rpt conj_tac >> + TRY (Cases_on `x`) >> + TRY (Cases_on `y`) >> + TRY (Cases_on `z`) >> + REWRITE_TAC [char_cmp_def, num_cmp_def] >> + every_case_tac >> + full_simp_tac (srw_ss()++ARITH_ss) []); + +val string_cmp_good = Q.store_thm ("string_cmp_good[simp]", +`good_cmp string_cmp`, + metis_tac [string_cmp_def, char_cmp_good, list_cmp_good]); + +val list_cmp_cong = Q.store_thm ("list_cmp_cong", +`!cmp l1 l2 cmp' l1' l2'. + (l1 = l1') ∧ + (l2 = l2') ∧ + (!x x'. MEM x l1' ∧ MEM x' l2' ⇒ cmp x x' = cmp' x x') + ⇒ + list_cmp cmp l1 l2 = list_cmp cmp' l1' l2'`, + ho_match_mp_tac list_cmp_ind >> + rw [list_cmp_def] >> + rw [list_cmp_def] >> + every_case_tac >> + rw []); + +val option_cmp_cong = Q.store_thm ("option_cmp_cong", +`!cmp v1 v2 cmp' v1' v2'. + (v1 = v1') ∧ + (v2 = v2') ∧ + (!x x'. v1' = SOME x ∧ v2' = SOME x' ⇒ cmp x x' = cmp' x x') + ⇒ + option_cmp cmp v1 v2 = option_cmp cmp' v1' v2'`, + ho_match_mp_tac (fetch "-" "option_cmp_ind") >> + rw [option_cmp_def] >> + rw [option_cmp_def]); + +val option_cmp2_cong = Q.store_thm ("option_cmp2_cong", +`!cmp v1 v2 cmp' v1' v2'. + (v1 = v1') ∧ + (v2 = v2') ∧ + (!x x'. v1' = SOME x ∧ v2' = SOME x' ⇒ cmp x x' = cmp' x x') + ⇒ + option_cmp2 cmp v1 v2 = option_cmp2 cmp' v1' v2'`, + ho_match_mp_tac (fetch "-" "option_cmp2_ind") >> + rw [option_cmp2_def] >> + rw [option_cmp2_def]); + +val pair_cmp_cong = Q.store_thm ("pair_cmp_cong", +`!cmp1 cmp2 v1 v2 cmp1' cmp2' v1' v2'. + (v1 = v1') ∧ + (v2 = v2') ∧ + (!a b c d. v1' = (a,b) ∧ v2' = (c,d) ⇒ cmp1 a c = cmp1' a c) ∧ + (!a b c d. v1' = (a,b) ∧ v2' = (c,d) ⇒ cmp2 b d = cmp2' b d) + ⇒ + pair_cmp cmp1 cmp2 v1 v2 = pair_cmp cmp1' cmp2' v1' v2'`, + rw [pair_cmp_def] >> + every_case_tac >> + Cases_on `v1` >> + Cases_on `v2` >> + fs []); + +val _ = DefnBase.export_cong "list_cmp_cong"; +val _ = DefnBase.export_cong "option_cmp_cong"; +val _ = DefnBase.export_cong "option_cmp2_cong"; +val _ = DefnBase.export_cong "pair_cmp_cong"; + +val good_cmp_trans = Q.store_thm ("good_cmp_trans", +`!cmp. good_cmp cmp ⇒ transitive (λ(k,v) (k',v'). cmp k k' = Less)`, + rw [relationTheory.transitive_def] >> + Cases_on `x` >> + Cases_on `y` >> + Cases_on `z` >> + fs [] >> + metis_tac [cmp_thms]); + +val bool_cmp_antisym = Q.store_thm ("bool_cmp_antisym[simp]", +`!x y. bool_cmp x y = Equal ⇔ x = y`, + rw [] >> + Cases_on `x` >> + Cases_on `y` >> + rw [bool_cmp_def]); + +val num_cmp_antisym = Q.store_thm ("num_cmp_antisym[simp]", +`!x y. num_cmp x y = Equal ⇔ x = y`, + rw [num_cmp_def]); + +val char_cmp_antisym = Q.store_thm ("char_cmp_antisym[simp]", +`!x y. char_cmp x y = Equal ⇔ x = y`, + rw [char_cmp_def, num_cmp_antisym] >> + rw [ORD_11]); + +val list_cmp_antisym = Q.store_thm ("list_cmp_antisym", +`!cmp x y. (!x y. cmp x y = Equal ⇔ x = y) ⇒ (list_cmp cmp x y = Equal ⇔ x = y)`, + ho_match_mp_tac list_cmp_ind >> + rw [list_cmp_def] >> + every_case_tac >> + rw [] >> + metis_tac [comparison_distinct]); + +val string_cmp_antisym = Q.store_thm ("string_cmp_antisym[simp]", +`!x y. string_cmp x y = Equal ⇔ x = y`, + metis_tac [string_cmp_def, char_cmp_antisym, list_cmp_antisym]); + +val pair_cmp_antisym = Q.store_thm ("pair_cmp_antisym", +`!cmp1 cmp2 x y. + (!x y. cmp1 x y = Equal ⇔ x = y) ∧ + (!x y. cmp2 x y = Equal ⇔ x = y) + ⇒ + (pair_cmp cmp1 cmp2 x y = Equal ⇔ x = y)`, + Cases_on `x` >> + Cases_on `y` >> + rw [pair_cmp_def] >> + every_case_tac >> + rw [] >> + metis_tac [comparison_distinct]); + +val option_cmp_antisym = Q.store_thm ("option_cmp_antisym", +`!cmp x y. + (!x y. cmp x y = Equal ⇔ x = y) + ⇒ + (option_cmp cmp x y = Equal ⇔ x = y)`, + Cases_on `x` >> + Cases_on `y` >> + rw [option_cmp_def] >> + every_case_tac >> + rw [] >> + metis_tac [comparison_distinct]); + +val option_cmp2_antisym = Q.store_thm ("option_cmp2_antisym", +`!cmp x y. + (!x y. cmp x y = Equal ⇔ x = y) + ⇒ + (option_cmp2 cmp x y = Equal ⇔ x = y)`, + Cases_on `x` >> + Cases_on `y` >> + rw [option_cmp2_def] >> + every_case_tac >> + rw [] >> + metis_tac [comparison_distinct]); + +val resp_equiv_def = Define ` +resp_equiv cmp f ⇔ !k1 k2 v. cmp k1 k2 = Equal ⇒ f k1 v = f k2 v`; + +val resp_equiv2_def = Define ` +resp_equiv2 cmp cmp2 f ⇔ (!k1 k2. cmp k1 k2 = Equal ⇒ cmp2 (f k1) (f k2) = Equal)`; + +val equiv_inj_def = Define ` +equiv_inj cmp cmp2 f ⇔ (!k1 k2. cmp2 (f k1) (f k2) = Equal ⇒ cmp k1 k2 = Equal)`; + +val antisym_resp_equiv = Q.store_thm ("antisym_resp_equiv", +`!cmp f. + (!x y. cmp x y = Equal ⇒ x = y) + ⇒ + resp_equiv cmp f ∧ !cmp2. good_cmp cmp2 ⇒ resp_equiv2 cmp cmp2 f`, + rw [resp_equiv_def, resp_equiv2_def] >> + metis_tac [cmp_thms]); + +val list_cmp_equal_list_rel = Q.store_thm ("list_cmp_equal_list_rel", +`!cmp l1 l2. + list_cmp cmp l1 l2 = Equal ⇔ LIST_REL (\x y. cmp x y = Equal) l1 l2`, + Induct_on `l1` >> + rw [] >> + Cases_on `l2` >> + fs [list_cmp_def] >> + every_case_tac >> + fs []); + +val _ = export_theory (); diff --git a/examples/balanced_bst/osetScript.sml b/examples/balanced_bst/osetScript.sml new file mode 100644 index 0000000000..e0f1c7a59e --- /dev/null +++ b/examples/balanced_bst/osetScript.sml @@ -0,0 +1,357 @@ +open HolKernel boolLib bossLib BasicProvers Parse; +open optionTheory pairTheory stringTheory; +open arithmeticTheory pred_setTheory listTheory finite_mapTheory alistTheory sortingTheory; +open balanced_mapTheory comparisonTheory; +open lcsymtacs; + +val _ = new_theory "oset"; + +val _ = temp_tight_equality (); + +(* oset for ordered set *) +val _ = type_abbrev ("oset", ``:('a,unit) balanced_map``); + +(* Basic definitions, that correspond directly to balanced tree operations *) +val good_oset_def = Define ` +good_oset cmp (s:'a oset) ⇔ good_cmp cmp ∧ invariant cmp s`; + +val oempty_def = Define ` +oempty = empty:'a oset`; + +val osingleton_def = Define ` +osingleton v = singleton v ()`; + +val oin_def = Define ` +oin cmp (v:'a) (s:'a oset) ⇔ member cmp v s`; + +val oinsert_def = Define ` +oinsert cmp v s = insert cmp v () s`; + +val odelete_def = Define ` +odelete cmp (s:'a oset) (v:'a) = delete cmp v s`; + +val ounion_def = Define ` +ounion cmp (s1:'a oset) s2 = union cmp s1 s2`; + +val oimage_def = Define ` +oimage cmp f (s:'a oset) = map_keys cmp f s`; + +val osubset_def = Define ` +osubset cmp (s1:'a oset) (s2:'a oset) ⇔ isSubmapOf cmp s1 s2`; + +val ocompare_def = Define ` +ocompare cmp (s1:'a oset) (s2:'a oset) = compare cmp (\x y. Equal) s1 s2`; + +val oevery_def = Define ` +oevery f (s:'a oset) ⇔ every (\x y. f x) s`; + +val oexists_def = Define ` +oexists f (s:'a oset) ⇔ exists (\x y. f x) s`; + +val oset_def = Define ` +oset cmp l = FOLDR (λx t. oinsert cmp x t) oempty l`; + +val oresp_equiv_def = Define ` +oresp_equiv cmp f = resp_equiv cmp (λx y:unit. f x)`; + +(* operations preserve good_set *) + +val good_oset_oempty = Q.store_thm ("good_oset_oempty", +`!cmp. good_cmp cmp ⇒ good_oset cmp oempty`, + rw [empty_thm, good_oset_def, oempty_def]); + +val good_oset_osingleton = Q.store_thm ("good_oset_osingleton", +`!cmp x. good_cmp cmp ⇒ good_oset cmp (osingleton x)`, + rw [singleton_thm, good_oset_def, osingleton_def]); + +val good_oset_oinsert = Q.store_thm ("good_oset_oinsert", +`!cmp s x. good_oset cmp s ⇒ good_oset cmp (oinsert cmp x s)`, + rw [oinsert_def, good_oset_def] >> + metis_tac [insert_thm]); + +val good_oset_odelete = Q.store_thm ("good_oset_odelete", +`!cmp s x. good_oset cmp s ⇒ good_oset cmp (odelete cmp s x)`, + rw [good_oset_def, odelete_def] >> + metis_tac [delete_thm]); + +val good_oset_ounion = Q.store_thm ("good_oset_ounion", +`!cmp s1 s2. good_oset cmp s1 ∧ good_oset cmp s2 ⇒ good_oset cmp (ounion cmp s1 s2)`, + rw [good_oset_def, ounion_def] >> + metis_tac [union_thm]); + +(* +val good_oset_oimage = Q.store_thm ("good_oset_oimage", +`!cmp f s. good_cmp cmp ⇒ good_oset cmp (oimage cmp f s)`, + cheat); + *) + +val good_cmp_ocompare = Q.store_thm ("good_cmp_ocompare", +`!cmp f s. good_cmp cmp ⇒ good_cmp (ocompare cmp)`, + rw [] >> + `good_cmp (\(x:unit) (y:unit). Equal)` + by (rw [good_cmp_def, LAMBDA_PROD, FORALL_PROD] >> + metis_tac [good_cmp_def]) >> + imp_res_tac compare_good_cmp >> + rw [ocompare_def, good_cmp_def] >> + metis_tac [good_cmp_def]); + +val good_oset_oset_help = Q.prove ( +`!cmp s l. good_oset cmp s ⇒ good_oset cmp (FOLDR (λx t. oinsert cmp x t) s l)`, + Induct_on `l` >> + rw [] >> + match_mp_tac good_oset_oinsert >> + metis_tac []); + +val good_oset_oset = Q.store_thm ("good_oset_oset", +`!cmp l. good_cmp cmp ⇒ good_oset cmp (oset cmp l)`, + rw [oset_def] >> + metis_tac [good_oset_oset_help, good_oset_oempty]); + +(* oempty theorems *) + +val oin_oempty = Q.store_thm ("oin_oinsert[simp]", +`!cmp x. oin cmp x oempty = F`, + rw [oin_def, oempty_def, empty_def, member_def]); + +val oimage_oempty = Q.store_thm ("oimage_oempty[simp]", +`!cmp f. oimage cmp f oempty = oempty`, + rw [oimage_def, oempty_def, map_keys_def, empty_def, fromList_def, + toAscList_def, foldrWithKey_def]); + +val oinsert_oempty = Q.store_thm ("oinsert_oempty[simp]", +`!cmp x. oinsert cmp x oempty = osingleton x`, + rw [oinsert_def, oempty_def, osingleton_def, insert_def, empty_def, singleton_def]); + +val odelete_oempty = Q.store_thm ("odelete_oempty[simp]", +`!cmp x. odelete cmp oempty x = oempty`, + rw [odelete_def, oempty_def, delete_def, empty_def]); + +val ounion_oempty = Q.store_thm ("ounion_oempty[simp]", +`!cmp s. ounion cmp oempty s = s ∧ ounion cmp s oempty = s`, + rw [ounion_def, oempty_def, union_def, empty_def] >> + Cases_on `s` >> + rw [union_def]); + +val oempty_subset = Q.store_thm ("oempty_subset[simp]", +`!cmp s. (osubset cmp oempty s ⇔ T) ∧ (osubset cmp s oempty ⇔ s = oempty)`, + rw [osubset_def, oempty_def, isSubmapOf_def, isSubmapOfBy_def, empty_def, + submap'_def, size_def] >> + Cases_on `s` >> + rw [submap'_def, size_def]); + +val oevery_oempty = Q.store_thm ("oevery_oempty[simp]", +`!f. oevery f oempty = T`, + rw [oevery_def, oempty_def, every_def, empty_def]); + +val oexists_oempty = Q.store_thm ("oexists_oempty[simp]", +`!f. oexists f oempty = F`, + rw [oexists_def, oempty_def, exists_def, empty_def]); + +val oset_empty = Q.store_thm ("oset_empty[simp]", +`!cmp. oset cmp [] = oempty`, + rw [oset_def, oempty_def]); + +(* singleton theorems *) + +val oin_singleton = Q.store_thm ("oin_singleton[simp]", +`∀cmp x y. oin cmp x (osingleton y) ⇔ cmp x y = Equal`, + rw [oin_def, osingleton_def, member_def, singleton_def] >> + EVERY_CASE_TAC); + +val oimage_osingleton = Q.store_thm ("oimage_osingleton[simp]", +`!cmp f x. oimage cmp f (osingleton x) = osingleton (f x)`, + rw [oimage_def, osingleton_def, map_keys_def, singleton_def, fromList_def, + toAscList_def, foldrWithKey_def, empty_def, insert_def]); + +val odelete_osingleton = Q.store_thm ("odelete_osingleton[simp]", +`!cmp x y. good_cmp cmp ⇒ odelete cmp (osingleton x) y = if cmp x y = Equal then oempty else osingleton x`, + rw [odelete_def, oempty_def, delete_def, empty_def, singleton_def, osingleton_def] >> + EVERY_CASE_TAC >> + rw [balanceR_def, balanceL_def, glue_def] >> + metis_tac [cmp_thms]); + +val oevery_osingleton = Q.store_thm ("oevery_osingleton[simp]", +`!f x. oevery f (osingleton x) = f x`, + rw [oevery_def, osingleton_def, every_def, singleton_def]); + +val oexists_osingleton = Q.store_thm ("oexists_osingleton[simp]", +`!f x. oexists f (osingleton x) = f x`, + rw [oexists_def, osingleton_def, exists_def, singleton_def]); + +val oset_singleton = Q.store_thm ("oset_singleton[simp]", +`!cmp x. oset cmp [x] = osingleton x`, + rw [oset_def, osingleton_def]); + +(* How oin interacts with other operations *) + +val oin_oinsert = Q.store_thm ("oin_oinsert", +`∀cmp x y s. good_oset cmp s ⇒ (oin cmp x (oinsert cmp y s) ⇔ cmp x y = Equal ∨ oin cmp x s)`, + rw [good_oset_def, oin_def, oinsert_def] >> + imp_res_tac insert_thm >> + last_x_assum (qspecl_then [`()`, `y`] assume_tac) >> + imp_res_tac member_thm >> + rw [FLOOKUP_UPDATE] >> + rfs [key_set_eq] >> + metis_tac [good_cmp_def]); + +val oin_odelete = Q.store_thm ("oin_odelete", +`!cmp s x y. good_oset cmp s ⇒ (oin cmp x (odelete cmp s y) ⇔ oin cmp x s ∧ cmp x y ≠ Equal)`, + rw [oin_def, odelete_def] >> + imp_res_tac good_oset_odelete >> + pop_assum (qspecl_then [`y`] assume_tac) >> + fs [good_oset_def, odelete_def] >> + imp_res_tac delete_thm >> + imp_res_tac member_thm >> + rw [FDOM_DRESTRICT, key_set_eq] >> + eq_tac >> + rw []); + +val oin_ounion = Q.store_thm ("oin_ounion", +`!cmp x s1 s2. good_oset cmp s1 ∧ good_oset cmp s2 ⇒ (oin cmp x (ounion cmp s1 s2) ⇔ oin cmp x s1 ∨ oin cmp x s2)`, + rw [oin_def] >> + `good_oset cmp (ounion cmp s1 s2)` by metis_tac [good_oset_ounion] >> + fs [good_oset_def, ounion_def] >> + imp_res_tac member_thm >> + rw [] >> + `to_fmap cmp (union cmp s1 s2) = to_fmap cmp s1 ⊌ to_fmap cmp s2` by metis_tac [union_thm] >> + rw []); + +(* +val oin_oimage = Q.store_thm ("oin_oimage", +`!cmp y s f. good_cmp cmp ⇒ (oin cmp y (oimage cmp f s) ⇔ ?x. cmp y (f x) = Equal ∧ oin cmp x s)`, + cheat); + *) + +val osubset_thm = Q.store_thm ("osubset_thm", +`!cmp s1 s2. good_oset cmp s1 ∧ good_oset cmp s2 ⇒ (osubset cmp s1 s2 ⇔ (!x. oin cmp x s1 ⇒ oin cmp x s2))`, + rw [osubset_def, good_oset_def, isSubmapOf_thm, oin_def] >> + rw [member_thm, lookup_thm, FLOOKUP_DEF] >> + eq_tac >> + rw []); + +val oextension = Q.store_thm ("oextension", +`!cmp s1 s2. + good_oset cmp s1 ∧ good_oset cmp s2 + ⇒ + (ocompare cmp s1 s2 = Equal ⇔ (!x. oin cmp x s1 ⇔ oin cmp x s2))`, + rw [good_oset_def, ocompare_def] >> + `good_cmp (\(x:unit) (y:unit). Equal)` + by (rw [good_cmp_def, LAMBDA_PROD, FORALL_PROD] >> + metis_tac [good_cmp_def]) >> + rw [compare_thm] >> + rw [oin_def, member_thm, fmap_rel_OPTREL_FLOOKUP, OPTREL_def, FLOOKUP_DEF] >> + eq_tac >> + rw [] + >- metis_tac [] >> + CCONTR_TAC >> + fs [] >> + imp_res_tac to_fmap_key_set >> + fs [] >> + metis_tac []); + +val oevery_oin = Q.store_thm ("oevery_oin", +`!cmp f s. + good_oset cmp s ∧ + oresp_equiv cmp f + ⇒ + (oevery f s ⇔ (!x. oin cmp x s ⇒ f x))`, + rw [good_oset_def, oevery_def, oin_def, oresp_equiv_def] >> + imp_res_tac every_thm >> + rw [lookup_thm, flookup_thm, member_thm]); + +val oexists_oin = Q.store_thm ("oexists_oin", +`!cmp f s. + good_oset cmp s ∧ + oresp_equiv cmp f + ⇒ + (oexists f s ⇔ (?x. oin cmp x s ∧ f x))`, + rw [oresp_equiv_def, good_oset_def, oexists_def, oin_def] >> + imp_res_tac exists_thm >> + rw [lookup_thm, flookup_thm, member_thm]); + +val oin_oset_help = Q.prove ( +`!cmp l x s. + good_oset cmp s + ⇒ + (oin cmp x (FOLDR (λx t. oinsert cmp x t) s l) + ⇔ + oin cmp x s ∨ ?y. MEM y l ∧ cmp x y = Equal)`, + Induct_on `l` >> + rw [] >> + imp_res_tac good_oset_oset_help >> + rw [oin_oinsert] >> + eq_tac >> + rw [] >> + res_tac >> + fs [] >> + metis_tac []); + +val oin_oset = Q.store_thm ("oin_oset", +`!cmp l x. good_cmp cmp ⇒ (oin cmp x (oset cmp l) ⇔ ?y. MEM y l ∧ cmp x y = Equal)`, + rw [oset_def] >> + metis_tac [oin_oset_help, good_oset_oempty, oin_oempty]); + +(* Theorems about oevery and oexists *) + +val oevery_oinsert = Q.store_thm ("oevery_oinsert", +`!f cmp x s. + good_oset cmp s ∧ + oresp_equiv cmp f + ⇒ + (oevery f (oinsert cmp x s) ⇔ f x ∧ oevery f s)`, + rw [] >> + `good_oset cmp (oinsert cmp x s)` by metis_tac [good_oset_oinsert] >> + imp_res_tac oevery_oin >> + rw [oin_oinsert] >> + eq_tac >> + rw [] >> + fs [oresp_equiv_def, resp_equiv_def] >> + metis_tac [good_oset_def, cmp_thms]); + +val oexists_oinsert = Q.store_thm ("oexists_oinsert", +`!f cmp x s. + good_oset cmp s ∧ + oresp_equiv cmp f + ⇒ + (oexists f (oinsert cmp x s) ⇔ f x ∨ oexists f s)`, + rw [] >> + `good_oset cmp (oinsert cmp x s)` by metis_tac [good_oset_oinsert] >> + imp_res_tac oexists_oin >> + rw [oin_oinsert] >> + eq_tac >> + rw [] >> + fs [oresp_equiv_def, resp_equiv_def] >> + metis_tac [good_oset_def, cmp_thms]); + +val oevery_ounion = Q.store_thm ("oevery_ounion", +`!f cmp s1 s2. + good_oset cmp s1 ∧ + good_oset cmp s2 ∧ + oresp_equiv cmp f + ⇒ + (oevery f (ounion cmp s1 s2) ⇔ oevery f s1 ∧ oevery f s2)`, + rw [] >> + `good_oset cmp (ounion cmp s1 s2)` by metis_tac [good_oset_ounion] >> + imp_res_tac oevery_oin >> + rw [oin_ounion] >> + eq_tac >> + rw [] >> + fs [oresp_equiv_def, resp_equiv_def]); + +val oexists_ounion = Q.store_thm ("oexists_ounion", +`!f cmp s1 s2. + good_oset cmp s1 ∧ + good_oset cmp s2 ∧ + oresp_equiv cmp f + ⇒ + (oexists f (ounion cmp s1 s2) ⇔ oexists f s1 ∨ oexists f s2)`, + rw [] >> + `good_oset cmp (ounion cmp s1 s2)` by metis_tac [good_oset_ounion] >> + imp_res_tac oexists_oin >> + rw [oin_ounion] >> + eq_tac >> + rw [] >> + fs [oresp_equiv_def, resp_equiv_def] >> + metis_tac []); + +val _ = export_theory (); From 621c1ebba0c90a304da4668cebce92f8b5c49dc1 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Sat, 13 Dec 2014 18:34:09 +1100 Subject: [PATCH 050/718] VALIDATE and VALIDATE_LT If tac (ltac) is invalid due to proving theorems with extra assumptions, VALIDATE tac and VALIDATE_LT ltac make the tactic valid by returning extra subgoals to prove the extra assumptions --- help/Docfiles/Tactical.VALID.doc | 9 +- help/Docfiles/Tactical.VALIDATE.doc | 102 +++++++++++++++++++++++ help/Docfiles/Tactical.VALIDATE_LT.doc | 92 ++++++++++++++++++++ help/Docfiles/Tactical.VALID_LT.doc | 8 +- help/Docfiles/proofManagerLib.expand.doc | 30 ++++++- src/1/Tactical.sig | 2 + src/1/Tactical.sml | 68 +++++++++++++++ 7 files changed, 301 insertions(+), 10 deletions(-) create mode 100644 help/Docfiles/Tactical.VALIDATE.doc create mode 100644 help/Docfiles/Tactical.VALIDATE_LT.doc diff --git a/help/Docfiles/Tactical.VALID.doc b/help/Docfiles/Tactical.VALID.doc index 0c80870e51..946122cf58 100644 --- a/help/Docfiles/Tactical.VALID.doc +++ b/help/Docfiles/Tactical.VALID.doc @@ -10,14 +10,13 @@ If {tac} applied to the goal {(asl,g)} produces a justification that does not create a theorem {A |- g}, with {A} a subset of {asl}, then {VALID tac (asl,g)} fails (raises an exception). If {tac} produces a valid proof on the goal, then the behaviour of {VALID tac (asl,g)} is -the same +the same as {tac (asl,g)} \FAILURE -Fails by design if its argument produces an invalid proof when applied -to a goal. Also fails if its argument fails when applied to the given -proof. +Fails by design if {tac} produces an invalid proof when applied +to a goal. Also fails if {tac} fails when applied to the given goal. \SEEALSO -proofManagerLib.expand. +proofManagerLib.expand, Tactical.VALIDATE. \ENDDOC diff --git a/help/Docfiles/Tactical.VALIDATE.doc b/help/Docfiles/Tactical.VALIDATE.doc new file mode 100644 index 0000000000..6b677d84ae --- /dev/null +++ b/help/Docfiles/Tactical.VALIDATE.doc @@ -0,0 +1,102 @@ +\DOC VALIDATE + +\TYPE {VALIDATE : tactic -> tactic} + +\SYNOPSIS +Makes a tactic valid if its invalidity is due to relying on assumptions not +present in the goal. + +\DESCRIBE +Suppose {tac} applied to the goal {(asl,g)} produces a justification that +creates a theorem {A |- g'}. +If {A} a not a subset of {asl}, then the tactic is invalid +(and {VALID tac (asl,g)} fails, ie, raises an exception). +But {VALIDATE tac (asl,g)} produces a subgoal list augmented by the +members of {asl} missing from {A}. + +If {g'} differs from {g}, both {VALID tac (asl,g)} and {VALIDATE tac (asl,g)} +fail. + +\FAILURE +Fails by design if {tac}, when applied to a goal, +produces a proof which is invalid on account of proving +a theorem whose conclusion differs from that of the goal. + +Also fails if {tac} fails when applied to the given goal. + +\EXAMPLE +For example, where theorem {uth'} is {[p'] |- q} + +{ +1 subgoal: +val it = + +q +------------------------------------ + p +: + proof + +> e (ACCEPT_TAC uth') ; +OK.. + +Exception raised at Tactical.VALID: +Invalid tactic [...] + +> e (VALIDATE (ACCEPT_TAC uth')) ; +OK.. +1 subgoal: +val it = + +p' +------------------------------------ + p +: + proof +} + +Given a goal with an implication in the assumptions, +one can split it into two subgoals. +{ +1 subgoal: +val it = + +r +------------------------------------ + p ==> q +: + proof + +> e (VALIDATE (POP_ASSUM (ASSUME_TAC o UNDISCH))) ; + +OK.. +2 subgoals: +val it = + +r +------------------------------------ + q + +p +------------------------------------ + p ==> q + +2 subgoals +: + proof +} +Meanwhile, to propose a term, prove it as a subgoal and then use it to prove +the goal, as is done using {SUBGOAL_THEN tm ASSUME_TAC}, +can also be done by {VALIDATE (ASSUME_TAC (ASSUME tm)))} + + +\USES +Where a tactic {tac} requires certain assumptions to be present in the goal, +which are not present but are capable of being proved, +{VALIDATE tac} will conveniently set up new subgoals to prove the missing +assumptions. + +\SEEALSO +proofManagerLib.expand, Tactical.VALID, Tactical.SUBGOAL_THEN. + +\ENDDOC diff --git a/help/Docfiles/Tactical.VALIDATE_LT.doc b/help/Docfiles/Tactical.VALIDATE_LT.doc new file mode 100644 index 0000000000..3995a59f2b --- /dev/null +++ b/help/Docfiles/Tactical.VALIDATE_LT.doc @@ -0,0 +1,92 @@ +\DOC VALIDATE_LT + +\TYPE {VALIDATE_LT : list_tactic -> list_tactic} + +\SYNOPSIS +Makes a list-tactic valid if its invalidity is due to relying on assumptions +not present in one of the goals. + +\DESCRIBE +When list-tactic {ltac} is applied to a goal list {gl} +it produces a new goal list {gl'} and a justification. +When the justification is applied to a list {thl'} of theorems +which are the new goals {gl'}, proved, it should produce a list {thl} +of theorems which are the goals {gl}, proved. + +A list-tactic can be invalid due to proving +a theorem whose conclusion differs from that of the corresponding goal, +or due to proving a theorem which contains extra assumptions relative to the +corresponding goal. +In this latter case, {VALIDATE_LT ltac} makes the list-tactic valid +by returning extra subgoals to prove those extra assumptions. + +See {VALID_LT} for more details. + +\FAILURE +Fails by design if {ltac}, when applied to a goal list, +produces a proof which is invalid on account of proving +a theorem whose conclusion differs from that of the corresponding goal. + +Also fails if {ltac} fails when applied to the given goals. + +\EXAMPLE +Where {uthr'} is {[p', q] |- r} and {uths'} is {[p, q'] |- s} + +{ +2 subgoals: +val it = + +s +------------------------------------ + 0. p + 1. q + +r +------------------------------------ + 0. p + 1. q + +2 subgoals +: + proof + +> elt (ALLGOALS (FIRST (map ACCEPT_TAC [uthr', uths']))) ; +OK.. + +Exception raised at Tactical.VALID_LT: +Invalid list-tactic [...] + +> elt (VALIDATE_LT (ALLGOALS (FIRST (map ACCEPT_TAC [uthr', uths'])))) ; +OK.. +2 subgoals: +val it = + +q' +------------------------------------ + 0. p + 1. q + +p' +------------------------------------ + 0. p + 1. q + +2 subgoals +: + proof +} + +\USES +Where a tactic {ltac} requires certain assumptions to be present in +one of the goals, +which are not present but are capable of being proved, +{VALIDATE_LT ltac} will conveniently set up new subgoals to prove the missing +assumptions. + +\SEEALSO +Tactical.VALID, Tactical.VALID_LT, Tactical.VALIDATE, +proofManagerLib.elt, proofManagerLib.expand_list. + +\ENDDOC + + diff --git a/help/Docfiles/Tactical.VALID_LT.doc b/help/Docfiles/Tactical.VALID_LT.doc index fef1355eb9..d03d5dd517 100644 --- a/help/Docfiles/Tactical.VALID_LT.doc +++ b/help/Docfiles/Tactical.VALID_LT.doc @@ -1,13 +1,13 @@ \DOC VALID_LT -\TYPE {VALID_LT : tactic -> tactic} +\TYPE {VALID_LT : list_tactic -> list_tactic} \SYNOPSIS Makes a list-tactic fail if it would otherwise return an invalid proof. \DESCRIBE When list-tactic {ltac} is applied to a goal list {gl} -it produces new goal list {gl'} and a justification. +it produces a new goal list {gl'} and a justification. When the justification is applied to a list {thl'} of theorems which are the new goals {gl'}, proved, it should produce a list {thl} of theorems which are the goals {gl}, proved. @@ -24,8 +24,8 @@ justification which do not prove the given goals {gl}. Also fails if its {ltac gl} fails. \SEEALSO -Tactical.VALID, -proofManagerLib.expand_list. +Tactical.VALID, Tactical.VALIDATE_LT, +proofManagerLib.elt, proofManagerLib.expand_list. \ENDDOC diff --git a/help/Docfiles/proofManagerLib.expand.doc b/help/Docfiles/proofManagerLib.expand.doc index 75348bf08b..eb029f4ed0 100644 --- a/help/Docfiles/proofManagerLib.expand.doc +++ b/help/Docfiles/proofManagerLib.expand.doc @@ -111,6 +111,33 @@ Invalid tactic ! HOL_ERR } +Note that an invalid tactic may "succeed". +Thus, where {tac1} is invalid, and {tac2} is valid (and both succeed), +{FIRST [tac1, tac2]} is invalid. For example, where +theorem {uth} is {[p] |- q} and {uth'} is {[p'] |- q} + +{ +1 subgoal: +val it = + +q +------------------------------------ + p +: + proof + +> e (FIRST (map ACCEPT_TAC [uth', uth])) ; +OK.. + +Exception raised at Tactical.VALID: +Invalid tactic [...] + +> e (FIRST (map (VALID o ACCEPT_TAC) [uth', uth])) ; +OK.. + +Goal proved. + [p] |- q +} \USES Doing a step in an interactive goal-directed proof. @@ -119,6 +146,7 @@ Doing a step in an interactive goal-directed proof. proofManagerLib.set_goal, proofManagerLib.restart, proofManagerLib.backup,proofManagerLib.restore, proofManagerLib.save, proofManagerLib.set_backup,proofManagerLib.expand, proofManagerLib.expandf, -proofManagerLib.p,proofManagerLib.top_thm, proofManagerLib.top_goal. +proofManagerLib.p,proofManagerLib.top_thm, proofManagerLib.top_goal, +Tactical.VALID, Tactical.VALIDATE \ENDDOC diff --git a/src/1/Tactical.sig b/src/1/Tactical.sig index 8abd823372..9f06979f99 100644 --- a/src/1/Tactical.sig +++ b/src/1/Tactical.sig @@ -39,6 +39,8 @@ sig val REPEAT_LT : list_tactic -> list_tactic val VALID : tactic -> tactic val VALID_LT : list_tactic -> list_tactic + val VALIDATE : tactic -> tactic + val VALIDATE_LT : list_tactic -> list_tactic val EVERY : tactic list -> tactic val FIRST : tactic list -> tactic val MAP_EVERY : ('a -> tactic) -> 'a list -> tactic diff --git a/src/1/Tactical.sml b/src/1/Tactical.sml index 0217fd5358..71639fa120 100644 --- a/src/1/Tactical.sml +++ b/src/1/Tactical.sml @@ -367,6 +367,74 @@ in end end +(*--------------------------------------------------------------------------- + * Tacticals to include proofs of necessary hypotheses for an invalid + * tactic or list_tactic valid. + * + * VALIDATE tac + * + * is the same as "tac", except that where "tac" returns a proof which is + * because if proves a theorem with extra hypotheses, it returns those + * hypotheses as extra goals + * + * VALIDATE_LT ltac + * + * is the same as "ltac", except it will return extra goals where this is + * necessary to make a valid list-tactic + *---------------------------------------------------------------------------*) +local val validity_tag = "ValidityCheck" + fun masquerade goal = Thm.mk_oracle_thm validity_tag goal ; + fun achieves_concl th (asl, w) = Term.aconv (concl th) w ; + fun hyps_not_in_goal th (asl, w) = + Lib.filter (fn h => not (Lib.exists (aconv h) asl)) (hyp th) ; + fun extra_goals_tbp th (asl, w) = + List.map (fn eg => (asl, eg)) (hyps_not_in_goal th (asl, w)) ; +in +fun VALIDATE (tac : tactic) (g as (asl, w) : goal) = + let val (glist, prf) = tac g ; + (* pretend new goals are theorems, and apply validation to them *) + val thprf = (prf (map masquerade glist)) ; + val _ = if achieves_concl thprf g then () + else raise ERR "VALIDATE" "Invalid tactic - wrong conclusion" ; + val extra_goals = extra_goals_tbp thprf g ; + val nextra = length extra_goals ; + (* new validation: apply the theorems proving the additional goals to + eliminate the extra hyps in the theorem proved by the given validation *) + fun eprf ethlist = + let val (extra_thms, thlist) = split_after nextra ethlist ; + in itlist PROVE_HYP extra_thms (prf thlist) end ; + in (extra_goals @ glist, eprf) end ; + +(* split_lists : int list -> 'a list -> 'a list list * 'a list *) +fun split_lists (n :: ns) ths = + let val (nths, rest) = split_after n ths ; + val (nsths, left) = split_lists ns rest ; + in (nths :: nsths, left) end + | split_lists [] ths = ([], ths) ; + +(* VALIDATE_LT : list_tactic -> list_tactic *) +fun VALIDATE_LT (ltac : list_tactic) (gl : goal list) = + let val (glist, prf) = ltac gl ; + (* pretend new goals are theorems, and apply validation to them *) + val thsprf = (prf (map masquerade glist)) ; + val _ = if Lib.all2 achieves_concl thsprf gl then () + else raise ERR "VALIDATE_LT" + "Invalid list-tactic - some wrong conclusion" ; + val extra_goal_lists = Lib.map2 extra_goals_tbp thsprf gl ; + val nextras = map length extra_goal_lists ; + (* new validation: apply the theorems proving the additional goals to + eliminate the extra hyps in the theorems proved by the given validation *) + fun eprf ethlist = + let val (extra_thm_lists, thlist) = split_lists nextras ethlist ; + in Lib.map2 (itlist PROVE_HYP) extra_thm_lists (prf thlist) end ; + in (List.concat extra_goal_lists @ glist, eprf) end ; + +end; + +(* could avoid duplication of code in the above by the following +fun VALIDATE tac = ALL_TAC THEN_LT VALIDATE_LT (TACS_TO_LT [tac]) ; +*) + (*--------------------------------------------------------------------------- * Provide a function (tactic) with the current assumption list. *---------------------------------------------------------------------------*) From cbc3e6a385b71f545c12d5fb4b673f03bb0d34ab Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 15 Dec 2014 15:01:57 +1100 Subject: [PATCH 051/718] Add balanced_bst to build sequence at selftest level 2. --- tools/sequences/large-theories | 1 + 1 file changed, 1 insertion(+) diff --git a/tools/sequences/large-theories b/tools/sequences/large-theories index 25a4b2f8db..2beb78d157 100644 --- a/tools/sequences/large-theories +++ b/tools/sequences/large-theories @@ -20,6 +20,7 @@ src/opentheory !!examples/lambda/typing !!examples/computability/lambda !!examples/computability/register +!!examples/balanced_bst src/Boolify/src src/float [poly]src/floating-point From afb42a28b3ddf7f1f14b80c9137e322b327f0f44 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 15 Dec 2014 15:03:20 +1100 Subject: [PATCH 052/718] Add deep_matches to build sequence at level 1. --- tools/sequences/large-theories | 1 + 1 file changed, 1 insertion(+) diff --git a/tools/sequences/large-theories b/tools/sequences/large-theories index 2beb78d157..de56034a17 100644 --- a/tools/sequences/large-theories +++ b/tools/sequences/large-theories @@ -21,6 +21,7 @@ src/opentheory !!examples/computability/lambda !!examples/computability/register !!examples/balanced_bst +!examples/deep_matches src/Boolify/src src/float [poly]src/floating-point From 137c5ca931f1123c3b8033f68ba09ceaad0099c2 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 15 Dec 2014 15:13:40 +1100 Subject: [PATCH 053/718] Mention balanced_bst example in release notes. --- doc/next-release.md | 47 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 47 insertions(+) create mode 100644 doc/next-release.md diff --git a/doc/next-release.md b/doc/next-release.md new file mode 100644 index 0000000000..462769728c --- /dev/null +++ b/doc/next-release.md @@ -0,0 +1,47 @@ +% Release notes for HOL4, ?????? + + + + +(Released: ??????) + +We are pleased to announce the ?????? release of HOL 4. + +Contents +-------- + +- [New features](#new-features) +- [Bugs fixed](#bugs-fixed) +- [New theories](#new-theories) +- [New tools](#new-tools) +- [Examples](#examples) +- [Incompatibilities](#incompatibilities) + +New features: +------------- + +Bugs fixed: +----------- + +New theories: +------------- + +New tools: +---------- + +New examples: +--------- + +- A theory of balanced binary trees (`examples/balanced_bst`), based on Haskell code by Leijen and Palamarchuk, and mechanised by Scott Owens. The type supports operations such as `insert`, `union`, `delete`, filters and folds. Operations are parameterised by comparison operators for comparing keys. Balanced trees can themselves be compared. + +Incompatibilities: +------------------ + +* * * * * + +
+*[HOL4, ??????](http://hol.sourceforge.net)* + +[Release notes for the previous version](kananaskis-10.release.html) + +
From ab1ace449a8a4fb2f251eb135e8e7af7a35ef753 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 16 Dec 2014 09:43:25 +1100 Subject: [PATCH 054/718] Remove trailing whitespace in examples/deep_matches/constrFamiliesLib.sml --- examples/deep_matches/constrFamiliesLib.sml | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/examples/deep_matches/constrFamiliesLib.sml b/examples/deep_matches/constrFamiliesLib.sml index bcf87776ef..297925fe21 100644 --- a/examples/deep_matches/constrFamiliesLib.sml +++ b/examples/deep_matches/constrFamiliesLib.sml @@ -3,8 +3,8 @@ struct open Abbrev -(* Contructor families are lists of constructors. - Constructors are functions that are injective and +(* Contructor families are lists of constructors. + Constructors are functions that are injective and pairwise distinct. Moreover, a case-expansion theorem needs to be provided. Let's assume we have a datatype t with @@ -60,7 +60,7 @@ fun gen_case_expand_thm case_def_thm nchotomy_thm = let val t_lhs = mk_comb (ff_tm, a) val t = list_mk_forall([ff_tm, a], mk_eq (t_lhs, t_rhs)) - val res_thm = prove (t, + val res_thm = prove (t, REPEAT GEN_TAC THEN MP_TAC (ISPEC a nchotomy_thm) THEN SIMP_TAC std_ss [DISJ_IMP_THM, case_def_thm, @@ -69,7 +69,7 @@ in res_thm end -fun get_case_expand_thm (v, _) = let +fun get_case_expand_thm (v, _) = let val ty = type_of v val case_def_thm = TypeBase.case_def_of ty val nchotomy_thm = TypeBase.nchotomy_of ty From a40ca685e9b657cf87af3267130ca4225a0c6e30 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 16 Dec 2014 09:46:35 +1100 Subject: [PATCH 055/718] Get constrFamiliesLib.sml to compile properly. It would load interactively under Poly/ML, but if a dependency for another theory, or if compiled with Moscow ML it would fail to compile. --- examples/deep_matches/constrFamiliesLib.sml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/deep_matches/constrFamiliesLib.sml b/examples/deep_matches/constrFamiliesLib.sml index 297925fe21..6723cf685c 100644 --- a/examples/deep_matches/constrFamiliesLib.sml +++ b/examples/deep_matches/constrFamiliesLib.sml @@ -1,7 +1,7 @@ structure constrFamiliesLib :> constrFamiliesLib = struct -open Abbrev +open HolKernel boolLib simpLib bossLib (* Contructor families are lists of constructors. Constructors are functions that are injective and From d245ffc09b39436e05c21c5f0cccdb144dd00872 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 16 Dec 2014 14:38:49 +1100 Subject: [PATCH 056/718] Fix quotation-marks in doc-file for Parse.reveal. --- help/Docfiles/Parse.reveal.doc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/help/Docfiles/Parse.reveal.doc b/help/Docfiles/Parse.reveal.doc index 5af96864a0..1958f5d0c6 100644 --- a/help/Docfiles/Parse.reveal.doc +++ b/help/Docfiles/Parse.reveal.doc @@ -9,8 +9,8 @@ Restores recognition of a constant by the quotation parser. Parse \DESCRIBE -A call {reveal c}, where {c} the name of a (perhaps) hidden constant, -will `unhide` the constant, that is, will make the quotation parser map +A call {reveal c}, where {c} the name of a (perhaps) hidden constant, +will `unhide' the constant, that is, will make the quotation parser map the identifier {c} to all current constants with the same name (there may be more than one such as different theories may re-use the same name). From 86b1b4d0ff56e225f6eeb86609021261f19d13bb Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 17 Dec 2014 09:14:08 +1100 Subject: [PATCH 057/718] Eliminate more trailing whitespace in examples/deep_matches A prelude to another minor bug fix. --- examples/deep_matches/deepMatchesLib.sig | 10 +- examples/deep_matches/deepMatchesLib.sml | 110 ++++++++++---------- examples/deep_matches/deepMatchesSyntax.sml | 34 +++--- 3 files changed, 76 insertions(+), 78 deletions(-) diff --git a/examples/deep_matches/deepMatchesLib.sig b/examples/deep_matches/deepMatchesLib.sig index 8fcb6545de..43eb84b2d1 100644 --- a/examples/deep_matches/deepMatchesLib.sig +++ b/examples/deep_matches/deepMatchesLib.sig @@ -12,14 +12,14 @@ sig @x. SND (SND x = ..) /\ (FST x = ..) /\ (FST (SND x) = ..) - by resorting these conjunctions, one can + by resorting these conjunctions, one can easily derive a form @x. x = .. and therefore eliminate the select operator. This is done by the following conversion + ssfrag. *) - val ELIM_FST_SND_SELECT_CONV : conv + val ELIM_FST_SND_SELECT_CONV : conv val elim_fst_snd_select_ss : ssfrag @@ -39,7 +39,7 @@ sig (* There are various ways of simplifying PMATCH. One can e.g. remove redundant rows or partially evaluate it. The conversion - PMATCH_SIMP_CONV does this. *) + PMATCH_SIMP_CONV does this. *) val PMATCH_SIMP_CONV : conv (* There is also a more generic version that @@ -53,7 +53,7 @@ sig val PMATCH_SIMP_ss : ssfrag (* PMATCH_SIMP_CONV consists of various - component conversions. These can be used + component conversions. These can be used independently as well. *) val PMATCH_REMOVE_ARB_CONV : conv val PMATCH_REMOVE_ARB_CONV_GEN : ssfrag list -> conv @@ -65,7 +65,7 @@ sig val PMATCH_SIMP_COLS_CONV : conv val PMATCH_SIMP_COLS_CONV_GEN : ssfrag list -> conv - + val PMATCH_EXPAND_COLS_CONV : conv diff --git a/examples/deep_matches/deepMatchesLib.sml b/examples/deep_matches/deepMatchesLib.sml index 3270e28c5d..a15afd3e98 100644 --- a/examples/deep_matches/deepMatchesLib.sml +++ b/examples/deep_matches/deepMatchesLib.sml @@ -1,7 +1,7 @@ structure deepMatchesLib :> deepMatchesLib = struct -open deepMatchesTheory bossLib +open deepMatchesTheory bossLib open quantHeuristicsLib open deepMatchesSyntax open constrFamiliesLib @@ -35,7 +35,7 @@ in end handle HOL_ERR _ => raise UNCHANGED fun ELIM_FST_SND_SELECT_CONV t = let - val (v, conj) = boolSyntax.dest_select t + val (v, conj) = boolSyntax.dest_select t val thm0 = FST_SND_CONJUNCT_COLLAPSE v conj val thm1 = RAND_CONV (ABS_CONV (K thm0)) t @@ -63,19 +63,19 @@ val elim_fst_snd_select_ss = key = SOME ([],``$@ (f:'a -> bool)``), conv = K (K ELIM_FST_SND_SELECT_CONV)} -fun rc_ss gl = list_ss ++ simpLib.merge_ss - (gl @ +fun rc_ss gl = list_ss ++ simpLib.merge_ss + (gl @ [pabs_elim_ss, pairSimps.paired_forall_ss, pairSimps.paired_exists_ss, pairSimps.gen_beta_ss, elim_fst_snd_select_ss, simpLib.rewrites [ - pairTheory.EXISTS_PROD, + pairTheory.EXISTS_PROD, pairTheory.FORALL_PROD, - PMATCH_ROW_EQ_NONE, + PMATCH_ROW_EQ_NONE, PMATCH_ROW_COND_def, - PAIR_EQ_COLLAPSE, + PAIR_EQ_COLLAPSE, oneTheory.one]]) fun callback_CONV cb_opt t = (case cb_opt of @@ -84,15 +84,15 @@ fun callback_CONV cb_opt t = (case cb_opt of if (aconv t T) orelse (aconv t F) then (raise UNCHANGED) else (EQT_INTRO (cb t) handle HOL_ERR _ => EQF_INTRO (cb (mk_neg t))))) - -fun rc_conv (gl, callback_opt) = + +fun rc_conv (gl, callback_opt) = SIMP_CONV (rc_ss gl) [] THENC TRY_CONV (callback_CONV callback_opt) fun rc_tac (gl, callback_opt) = CONV_TAC (rc_conv (gl, callback_opt)) -fun PMATCH_ROW_ARGS_CONV c = +fun PMATCH_ROW_ARGS_CONV c = RATOR_CONV (RAND_CONV (TRY_CONV c)) THENC RATOR_CONV (RATOR_CONV (RAND_CONV (TRY_CONV c))) THENC RATOR_CONV (RATOR_CONV (RATOR_CONV (RAND_CONV (TRY_CONV c)))) @@ -102,7 +102,7 @@ fun PMATCH_ROW_ARGS_CONV c = (* converting case-splits to PMATCH *) (***********************************************) -(* +(* val t = ``case x of (NONE, []) => 0`` *) @@ -125,7 +125,7 @@ fun dest_case_fun_aux1 t = let | SOME ti => ti val _ = if (same_const (TypeBasePure.case_const_of ti) f) then - () else failwith "dest_case_fun" + () else failwith "dest_case_fun" val ty_s = match_type (type_of (TypeBasePure.case_const_of ti)) (type_of f) val constrs = List.map (inst ty_s) (TypeBasePure.constructors_of ti) @@ -136,7 +136,7 @@ fun dest_case_fun_aux1 t = let (list_mk_comb (c, vars), res) end) constrs (tl args) in (a, ps) -end +end (* destruct literal cases, see dest_case_fun *) fun dest_case_fun_aux2 t = let @@ -149,9 +149,9 @@ fun dest_case_fun_aux2 t = let fun strip_cond acc b = let val (c, t_t, t_f) = dest_cond b - val (c_l, c_r) = dest_eq c + val (c_l, c_r) = dest_eq c val _ = if (aconv c_l v') then () else failwith "dest_case_fun" - in + in strip_cond ((c_r, t_t)::acc) t_f end handle HOL_ERR _ => (acc, b) @@ -159,7 +159,7 @@ fun dest_case_fun_aux2 t = let val ps = List.rev ((v', c_else) :: ps_rev) in (v, ps) -end +end (* destruct a case-function. @@ -222,7 +222,7 @@ fun PMATCH_INTRO_CONV t = let CASE_TAC THEN FULL_SIMP_TAC (rc_ss []) [PMATCH_EVAL, PMATCH_ROW_COND_def] ) -in +in (* set_goal ([], tm) *) prove (tm, REPEAT my_tac) end handle HOL_ERR _ => raise UNCHANGED @@ -237,7 +237,7 @@ end handle HOL_ERR _ => raise UNCHANGED covered cases. These ARB rows are not needed for PMATCH and can be removed. *) -(* +(* val rc_arg = [] set_trace "parse deep cases" 0 @@ -269,10 +269,10 @@ fun PMATCH_REMOVE_ARB_CONV_GENCALL_SINGLE rc_arg t = let val r_thm = (snd (PMATCH_ROW_PABS_ELIM_CONV r)) handle UNCHANGED => REFL r - val input_rows = - listSyntax.mk_append (rows1_tm, + val input_rows = + listSyntax.mk_append (rows1_tm, listSyntax.mk_cons (rhs (concl r_thm), rows2_tm)) - + val thm0 = PART_MATCH (rand o lhs o snd o dest_imp o #2 o strip_forall) ( ISPEC v (FRESH_TY_VARS_RULE PMATCH_REMOVE_ARB_NO_OVERLAP) ) input_rows @@ -281,13 +281,13 @@ fun PMATCH_REMOVE_ARB_CONV_GENCALL_SINGLE rc_arg t = let val pre = rand (rator (concl thm0)) val pre_thm = prove (pre, rc_tac rc_arg) val thm1 = MP thm0 pre_thm - val thm2 = CONV_RULE + val thm2 = CONV_RULE ((RHS_CONV o RAND_CONV) listLib.APPEND_CONV) - thm1 + thm1 val thm2_lhs_tm = mk_eq (t, lhs (concl thm2)) val thm2_lhs = prove (thm2_lhs_tm, - MP_TAC r_thm THEN + MP_TAC r_thm THEN rc_tac rc_arg) val thm3 = TRANS thm2_lhs thm2 @@ -332,7 +332,7 @@ fun PMATCH_CLEANUP_PVARS_CONV t = let val row' = mk_PMATCH_ROW_PABS filtered_vars (pt, gt, rh) - val eq_tm = mk_eq (row, row') + val eq_tm = mk_eq (row, row') (* set_goal ([], eq_tm) *) val eq_thm = prove (eq_tm, MATCH_MP_TAC PMATCH_ROW_EQ_AUX THEN @@ -387,10 +387,10 @@ fun PMATCH_CLEANUP_CONV_GENCALL rc_arg t = let (if (same_const res_tm F) then SOME (false, r_thm) else NONE) end handle HOL_ERR _ => NONE - val (rows_checked_rev, _) = foldl (fn (r, (acc, abort)) => + val (rows_checked_rev, _) = foldl (fn (r, (acc, abort)) => if abort then ((r, NONE)::acc, true) else ( let - val res = check_row r + val res = check_row r val abort = (case res of (SOME (false, _)) => true | _ => false) @@ -412,14 +412,14 @@ fun PMATCH_CLEANUP_CONV_GENCALL rc_arg t = let val n = index (fn x => case x of (_, SOME (false, _)) => true | _ => false) rows_checked val n_tm = numSyntax.term_of_int n - val thma = ISPECL [v, listSyntax.mk_list (rows, row_ty), n_tm] + val thma = ISPECL [v, listSyntax.mk_list (rows, row_ty), n_tm] (FRESH_TY_VARS_RULE PMATCH_ROWS_DROP_REDUNDANT_TRIVIAL_SOUNDNESS) val precond = fst (dest_imp (concl thma)) - val precond_thm = prove (precond, + val precond_thm = prove (precond, MP_TAC (snd(valOf (snd (el (n+1) rows_checked)))) THEN SIMP_TAC list_ss [quantHeuristicsTheory.IS_SOME_EQ_NOT_NONE]) - + val thmb = MP thma precond_thm val take_conv = RATOR_CONV (RAND_CONV reduceLib.SUC_CONV) THENC @@ -463,20 +463,20 @@ fun PMATCH_CLEANUP_CONV_GENCALL rc_arg t = let val thm2 = let val _ = if (not (List.null rows_checked1) andalso (case hd rows_checked1 of (_, (SOME (false, _))) => true | _ => false)) then () else failwith "nothing to do" - + val thm1_tm = rhs (concl thm1) val thm2a = PART_MATCH (lhs o rand) PMATCH_EVAL_MATCH thm1_tm val pre_thm = EQF_ELIM (snd (valOf(snd (hd rows_checked1)))) val thm2b = MP thm2a pre_thm - val thm2c = CONV_RULE (RHS_CONV + val thm2c = CONV_RULE (RHS_CONV (RAND_CONV (rc_conv rc_arg) THENC pairLib.GEN_BETA_CONV)) thm2b handle HOL_ERR _ => thm2b in thm2c end handle HOL_ERR _ => let val _ = if (List.null rows_checked1) then () else failwith "nothing to do" - in + in (REWR_CONV (CONJUNCT1 PMATCH_def)) (rhs (concl thm1)) end handle HOL_ERR _ => REFL (rhs (concl thm1)) in @@ -558,27 +558,27 @@ fun PMATCH_REMOVE_COL_AUX rc_arg col t = let if (List.null vars') then [variant avoid ``uv:unit``] else vars' end - val vars'_tm = pairSyntax.list_mk_pair vars' + val vars'_tm = pairSyntax.list_mk_pair vars' val g' = let - val vs = List.take (vars, pv_i) @ (c_v :: List.drop (vars, pv_i+1)) + val vs = List.take (vars, pv_i) @ (c_v :: List.drop (vars, pv_i+1)) val vs_tm = pairSyntax.list_mk_pair vs in pairSyntax.mk_pabs (vars'_tm, vs_tm) end - in + in (vars'_tm, g') end) | NONE => (let - (* we eliminate a costant columns *) + (* we eliminate a costant columns *) val (sub, _) = match_term pv c_v val _ = if List.all (fn x => List.exists (aconv (#redex x)) vars) sub then () else failwith "not a constant-col after all" val vars' = filter (fn v => not (List.exists (fn x => (aconv v (#redex x))) sub)) vars val vars' = if (List.null vars') then [genvar ``:unit``] else vars' - val vars'_tm = pairSyntax.list_mk_pair vars' + val vars'_tm = pairSyntax.list_mk_pair vars' val g' = pairSyntax.mk_pabs (vars'_tm, Term.subst sub vars_tm) - in + in (vars'_tm, g') end) @@ -605,7 +605,7 @@ fun PMATCH_REMOVE_COL_AUX rc_arg col t = let fun elim_conv_aux vs = ( (pairTools.PABS_INTRO_CONV vs) THENC (DEPTH_CONV (pairLib.PAIRED_BETA_CONV ORELSEC BETA_CONV)) - ) + ) fun elim_conv vs = PMATCH_ROW_ARGS_CONV (elim_conv_aux vs) val thm = CONV_RULE ((RAND_CONV o RHS_CONV) (elim_conv vars'_tm)) thm @@ -620,7 +620,7 @@ fun PMATCH_REMOVE_COL_AUX rc_arg col t = let val pre_tm = fst (dest_imp (concl thm0)) (* set_goal ([], pre_tm) *) - val pre_thm = prove (pre_tm, rc_tac rc_arg) + val pre_thm = prove (pre_tm, rc_tac rc_arg) val thm1 = MP thm0 pre_thm in thm1 @@ -683,7 +683,7 @@ fun PMATCH_REMOVE_FUN_AUX rc_arg col t = let val (c', args') = strip_comb tt_args val _ = if (aconv c c') then () else failwith "different constr" - + val vars = List.take (tts, col) @ args' @ List.drop (tts, col+1) in @@ -762,7 +762,7 @@ fun PMATCH_REMOVE_FUN_AUX rc_arg col t = let val avoid = vars @ free_vars pt @ free_vars rh @ free_vars gt val (pt', pv, new_vars) = ff_inv_var avoid pt - val pv_i = index (aconv pv) vars + val pv_i = index (aconv pv) vars val vars' = let val vars' = List.take (vars, pv_i) @ new_vars @ List.drop (vars, pv_i+1) @@ -770,10 +770,10 @@ fun PMATCH_REMOVE_FUN_AUX rc_arg col t = let if (List.null vars') then [variant avoid ``uv:unit``] else vars' end - val vars'_tm = pairSyntax.list_mk_pair vars' + val vars'_tm = pairSyntax.list_mk_pair vars' val f_tm = let val c_v = list_mk_comb (c, new_vars) - val vs = List.take (vars, pv_i) @ (c_v :: List.drop (vars, pv_i+1)) + val vs = List.take (vars, pv_i) @ (c_v :: List.drop (vars, pv_i+1)) val vs_tm = pairSyntax.list_mk_pair vs in pairSyntax.mk_pabs (vars'_tm, vs_tm) @@ -811,7 +811,7 @@ fun PMATCH_REMOVE_FUN_AUX rc_arg col t = let val pre_tm = fst (dest_imp (concl thm0)) val pre_thm = prove (pre_tm, rc_tac rc_arg) - + val thm1 = MP thm0 pre_thm in thm1 @@ -903,7 +903,7 @@ val PMATCH_SIMP_COLS_CONV = PMATCH_SIMP_COLS_CONV_GEN [] (* Expand columns *) (***********************************************) -(* Sometimes not all rows of a PMATCH have the same number of +(* Sometimes not all rows of a PMATCH have the same number of explicit columns. This can happen, if some patterns are explicit pairs, while others are not. The following tries to expand columns into explicit ones. *) @@ -926,7 +926,7 @@ fun PMATCH_EXPAND_COLS_CONV t = let val col_no = foldl (fn (r, m) => let val (_, pt, _) = dest_PMATCH_ROW r val m' = length (pairSyntax.strip_pair pt) - val m'' = if m' > m then m' else m + val m'' = if m' > m then m' else m in m'' end) col_no_v rows fun split_var avoid cols l = let @@ -938,7 +938,7 @@ fun PMATCH_EXPAND_COLS_CONV t = let end val types = splits [] (col_no - cols) (type_of l) - + val var_basename = fst (dest_var l) handle HOL_ERR _ => "v" fun gen_var i ty = let val n = var_basename ^ "_"^int_to_string i @@ -976,7 +976,7 @@ fun PMATCH_EXPAND_COLS_CONV t = let val eq_tm = mk_eq(row, row') val eq_thm = prove (eq_tm, rc_tac ([], NONE)) - val thm = AP_THM eq_thm v + val thm = AP_THM eq_thm v in thm end handle HOL_ERR _ => REFL (mk_comb (row, v)) @@ -1043,7 +1043,7 @@ fun PMATCH_SIMP_CONV_GEN ssl = PMATCH_SIMP_CONV_GENCALL (ssl, NONE) val PMATCH_SIMP_CONV = PMATCH_SIMP_CONV_GEN [] -fun PMATCH_SIMP_convdata_conv ssl callback back = +fun PMATCH_SIMP_convdata_conv ssl callback back = PMATCH_SIMP_CONV_GENCALL (ssl, SOME (callback back)) @@ -1069,7 +1069,7 @@ PMATCH (a,x,xs) [PMATCH_ROW (\x. (NONE,x,[])) (\x. T) (\x. x); PMATCH_ROW (\x. (NONE,x,[2])) (\x. T) (\x. x); PMATCH_ROW (\ (x,v18). (NONE,x,[v18])) (\ (x, v18). T) (\ (x, v18). 3); - PMATCH_ROW (\ (x,v12,v16,v17). (NONE,x,v12::v16::v17)) + PMATCH_ROW (\ (x,v12,v16,v17). (NONE,x,v12::v16::v17)) (\ (x,v12,v16,v17). T) (\ (x,v12,v16,v17). 3); PMATCH_ROW (\ (y,x,z,zs). (SOME y,x,[z])) @@ -1112,7 +1112,7 @@ fun PMATCH_CASE_SPLIT_AUX col expand_thm conv t = let fun is_case_conv_end t = is_comb (fst (dest_comb t)) handle HOL_ERR _ => false - fun case_conv conv t = + fun case_conv conv t = if not (is_case_conv_end t) then REFL t else (RAND_CONV (STRIP_ABS_CONV conv) THENC RATOR_CONV (case_conv conv)) t @@ -1130,7 +1130,7 @@ fun PMATCH_CASE_SPLIT_CONV_GENCALL rc_arg col_no t = let val (v, col) = el (col_no+1) (dest_PMATCH_COLS t') - val expand_thm = get_case_expand_thm (v, col) + val expand_thm = get_case_expand_thm (v, col) val thm1 = QCHANGED_CONV (PMATCH_CASE_SPLIT_AUX col_no expand_thm (PMATCH_SIMP_CONV_GENCALL rc_arg)) t' handle HOL_ERR _ => (REFL t') in @@ -1138,5 +1138,3 @@ in end end - - diff --git a/examples/deep_matches/deepMatchesSyntax.sml b/examples/deep_matches/deepMatchesSyntax.sml index d6843885b1..ff41a087cd 100644 --- a/examples/deep_matches/deepMatchesSyntax.sml +++ b/examples/deep_matches/deepMatchesSyntax.sml @@ -1,7 +1,7 @@ structure deepMatchesSyntax :> deepMatchesSyntax = struct -open deepMatchesTheory bossLib +open deepMatchesTheory bossLib @@ -32,7 +32,7 @@ end; val ty_var_subst = [alpha |-> gen_tyvar (), beta |-> gen_tyvar (), - gamma |-> gen_tyvar (), + gamma |-> gen_tyvar (), delta |-> gen_tyvar (), ``:'e`` |-> gen_tyvar (), ``:'f`` |-> gen_tyvar (), @@ -48,7 +48,7 @@ val PMATCH_ROW_gtm = inst ty_var_subst PMATCH_ROW_tm val PMATCH_tm = ``PMATCH`` val PMATCH_gtm = inst ty_var_subst PMATCH_tm -fun FRESH_TY_VARS_RULE thm = +fun FRESH_TY_VARS_RULE thm = INST_TYPE ty_var_subst thm @@ -65,7 +65,7 @@ end fun is_PMATCH_ROW t = can dest_PMATCH_ROW t -fun mk_PMATCH_ROW (p_t, g_t, r_t) = +fun mk_PMATCH_ROW (p_t, g_t, r_t) = list_mk_icomb (PMATCH_ROW_gtm, [p_t, g_t, r_t]) fun mk_PMATCH_ROW_PABS vars (p_t, g_t, r_t) = let @@ -80,7 +80,7 @@ fun mk_PMATCH_ROW_PABS vars (p_t, g_t, r_t) = let in mk_PMATCH_ROW (mk_pabs p_t, mk_pabs g_t, mk_pabs r_t) end - + fun dest_PMATCH_ROW_ABS row = let val (p_t, g_t, r_t) = dest_PMATCH_ROW row @@ -88,7 +88,7 @@ fun dest_PMATCH_ROW_ABS row = let val (g_vars, g_body) = pairSyntax.dest_pabs g_t val (r_vars, r_body) = pairSyntax.dest_pabs r_t - val _ = if (aconv p_vars g_vars) andalso (aconv g_vars r_vars) then + val _ = if (aconv p_vars g_vars) andalso (aconv g_vars r_vars) then () else failwith "dest_PMATCH_ROW_ABS" in (p_vars, p_body, g_body, r_body) @@ -107,9 +107,9 @@ fun PMATCH_ROW_PABS_ELIM_CONV row = let val (p, _, _) = dest_PMATCH_ROW row val (vars, _) = pairSyntax.dest_pabs p - val c = TRY_CONV pairTools.PABS_ELIM_CONV - val thm = ((RAND_CONV c) THENC - (RATOR_CONV (RAND_CONV c)) THENC + val c = TRY_CONV pairTools.PABS_ELIM_CONV + val thm = ((RAND_CONV c) THENC + (RATOR_CONV (RAND_CONV c)) THENC (RATOR_CONV (RATOR_CONV (RAND_CONV c)))) row handle UNCHANGED => REFL row in @@ -122,8 +122,8 @@ fun PMATCH_ROW_PABS_INTRO_CONV vars row = let val (vars', _) = variant_of_term (free_vars row) vars val c = pairTools.PABS_INTRO_CONV vars' - val thm = ((RAND_CONV c) THENC - (RATOR_CONV (RAND_CONV c)) THENC + val thm = ((RAND_CONV c) THENC + (RATOR_CONV (RAND_CONV c)) THENC (RATOR_CONV (RATOR_CONV (RAND_CONV c)))) row in thm @@ -135,7 +135,7 @@ fun PMATCH_ROW_FORCE_SAME_VARS_CONV row = let val (vars, thm0) = PMATCH_ROW_PABS_ELIM_CONV row val thm1 = PMATCH_ROW_PABS_INTRO_CONV vars (rhs (concl thm0)) -in +in TRANS thm0 thm1 end handle HOL_ERR _ => raise UNCHANGED @@ -160,7 +160,7 @@ fun mk_PMATCH v rows = let val (arg_tys, _) = wfrecUtils.strip_fun_type ty0 in el 2 arg_tys end - val ty_subst = match_type rows_ty (type_of rows) + val ty_subst = match_type rows_ty (type_of rows) val b_tm = inst ty_subst PMATCH_tm val t1 = mk_comb (b_tm, v) val t2 = mk_comb (t1, rows) @@ -227,17 +227,17 @@ fun pmatch_printer GS backend sys (ppfns:term_pp_types.ppstream_funs) gravs d t val rows' = map dest_PMATCH_ROW_ABS rows - fun pp_row (vars, pat, guard, rh) = ( + fun pp_row (vars, pat, guard, rh) = ( term_pp_utils.record_bvars (pairSyntax.strip_pair vars) ( ublock PP.CONSISTENT 0 ( add_string "|" >> add_break (1, 0) >> sys (Top, Top, Top) (d - 1) pat >> (if (aconv guard T) then nothing else ( add_break (1, 0) >> add_string "when" >> add_break (1, 0) >> - sys (Top, Top, Top) (d - 1) guard + sys (Top, Top, Top) (d - 1) guard )) >> add_break (1, 0) >> add_string "=>" >> add_break (1, 0) >> - sys (Top, Top, Top) (d - 1) rh + sys (Top, Top, Top) (d - 1) rh )) ) in @@ -265,7 +265,7 @@ fun case_magic_to_deep_case t = let fun process_row row = let val (l,r) = dest_eq row val p = rand l - + val vars = free_vars_lr p in mk_PMATCH_ROW_PABS vars (p, T, r) From 058f11b17140dc5c5173c1ac25d65c8a06b0a1fe Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 17 Dec 2014 09:30:33 +1100 Subject: [PATCH 058/718] Fix more deep_matches files so that they compile. Check compilation of non-theory files with a selftest file that doesn't do anything except load the "lib" files. --- examples/deep_matches/Holmakefile | 9 +++++++++ examples/deep_matches/deepMatchesLib.sig | 2 +- examples/deep_matches/deepMatchesLib.sml | 3 ++- examples/deep_matches/deepMatchesSyntax.sml | 3 ++- examples/deep_matches/selftest.sml | 3 +++ 5 files changed, 17 insertions(+), 3 deletions(-) create mode 100644 examples/deep_matches/Holmakefile create mode 100644 examples/deep_matches/selftest.sml diff --git a/examples/deep_matches/Holmakefile b/examples/deep_matches/Holmakefile new file mode 100644 index 0000000000..eaeddd064f --- /dev/null +++ b/examples/deep_matches/Holmakefile @@ -0,0 +1,9 @@ +test: selftest.exe + ./$< + +.PHONY: test + +selftest.exe: selftest.uo deepMatchesSyntax.uo deepMatchesTheory.uo deepMatchesLib.uo constrFamiliesLib.uo + $(HOLMOSMLC) -o $@ $< + +EXTRA_CLEANS = selftest.exe diff --git a/examples/deep_matches/deepMatchesLib.sig b/examples/deep_matches/deepMatchesLib.sig index 43eb84b2d1..a7fda89c47 100644 --- a/examples/deep_matches/deepMatchesLib.sig +++ b/examples/deep_matches/deepMatchesLib.sig @@ -1,7 +1,7 @@ signature deepMatchesLib = sig include Abbrev - + type ssfrag = simpLib.ssfrag (********************************) (* eliminating select *) (********************************) diff --git a/examples/deep_matches/deepMatchesLib.sml b/examples/deep_matches/deepMatchesLib.sml index a15afd3e98..7857462df4 100644 --- a/examples/deep_matches/deepMatchesLib.sml +++ b/examples/deep_matches/deepMatchesLib.sml @@ -1,7 +1,8 @@ structure deepMatchesLib :> deepMatchesLib = struct -open deepMatchesTheory bossLib +open HolKernel boolLib bossLib +open deepMatchesTheory open quantHeuristicsLib open deepMatchesSyntax open constrFamiliesLib diff --git a/examples/deep_matches/deepMatchesSyntax.sml b/examples/deep_matches/deepMatchesSyntax.sml index ff41a087cd..9b8390459e 100644 --- a/examples/deep_matches/deepMatchesSyntax.sml +++ b/examples/deep_matches/deepMatchesSyntax.sml @@ -1,7 +1,8 @@ structure deepMatchesSyntax :> deepMatchesSyntax = struct -open deepMatchesTheory bossLib +open HolKernel Parse boolLib bossLib +open deepMatchesTheory diff --git a/examples/deep_matches/selftest.sml b/examples/deep_matches/selftest.sml new file mode 100644 index 0000000000..055a805944 --- /dev/null +++ b/examples/deep_matches/selftest.sml @@ -0,0 +1,3 @@ +open constrFamiliesLib deepMatchesLib + +val _ = print "OK\n" From 15c0b3365bfe6b7367c3adcaee42706fcf2828a0 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 17 Dec 2014 13:28:16 +1100 Subject: [PATCH 059/718] Fix an indentation glitch --- src/integer/testing/selftest.sml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/integer/testing/selftest.sml b/src/integer/testing/selftest.sml index a7132c597e..8575179430 100644 --- a/src/integer/testing/selftest.sml +++ b/src/integer/testing/selftest.sml @@ -18,7 +18,7 @@ fun usage() = val cooper_result = case CommandLine.arguments() of [] => if Systeml.ML_SYSNAME = "poly" then cooper() else (usage(); true) - | [x] => let + | [x] => let in case Int.fromString x of SOME n => if n >= 2 then cooper() From 1c5ae6b6d733e0e40fdd001f4d469ee47e7bc1b2 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 17 Dec 2014 13:37:29 +1100 Subject: [PATCH 060/718] Fix & document an infinite loop bug in intSimps.{OMEGA,COOPER}_ss Problem was that the term F was viewed as suitable context for the simplifier's decision procedure. Though superficially reasonable, this leads to problems because the simplifier will rewrite everything it can inside this context to F, using the rewrite [F] |- somegenvar = F (1) but the integer decision procedures will correctly rewrite occurrences of F to T, because the underlying conversion is happy to prove |- (F ==> F) <=> T The natural number procedure in ARITH_ss doesn't suffer from this problem because it doesn't add F as context to the decision procedure's context, and that's the fix taken here. The decision to use (1) above rather than rewrite to true, say, was taken in 9bc4bdaa. --- doc/next-release.md | 2 ++ src/integer/intSimps.sml | 4 +++- src/integer/testing/selftest.sml | 9 +++++++++ 3 files changed, 14 insertions(+), 1 deletion(-) diff --git a/doc/next-release.md b/doc/next-release.md index 462769728c..aaf23c84c6 100644 --- a/doc/next-release.md +++ b/doc/next-release.md @@ -23,6 +23,8 @@ New features: Bugs fixed: ----------- +- An embarrassing infinite loop bug in the integration of the integer decision procedures (the Omega test, Cooper’s algorithm) into the simplifier was fixed. + New theories: ------------- diff --git a/src/integer/intSimps.sml b/src/integer/intSimps.sml index 57de65ee9a..58e34ec7c3 100644 --- a/src/integer/intSimps.sml +++ b/src/integer/intSimps.sml @@ -260,7 +260,9 @@ fun mkSS DPname DP = let exception CTXT of thm list fun get_ctxt e = (raise e) handle CTXT c => c fun add_ctxt(ctxt, newthms) = let - val addthese = filter is_arith_thm (flatten (map CONJUNCTS newthms)) + val addthese = filter (fn th => is_arith_thm th andalso + concl th <> boolSyntax.F) + (flatten (map CONJUNCTS newthms)) in CTXT (addthese @ get_ctxt ctxt) end diff --git a/src/integer/testing/selftest.sml b/src/integer/testing/selftest.sml index 8575179430..547a19a536 100644 --- a/src/integer/testing/selftest.sml +++ b/src/integer/testing/selftest.sml @@ -27,6 +27,15 @@ val cooper_result = end | _ => (usage(); true) +val _ = print "Testing simplifier integration\n" + +open testutils simpLib boolSimps + +val _ = tprint "F ==> F equivalent shouldn't loop" +val th = SIMP_CONV (bool_ss ++ intSimps.OMEGA_ss) [] ``x > 2n /\ F ==> x > 1`` + handle e => die (General.exnMessage e) +val _ = print "OK\n" + val _ = Process.exit (if cooper_result andalso omega_result then Process.success else Process.failure) From 1eb04c9b90dffedf060bd542015f929ffa93e795 Mon Sep 17 00:00:00 2001 From: Magnus Myreen Date: Sat, 20 Dec 2014 10:17:30 +1100 Subject: [PATCH 061/718] exported a useful theorem about the x64 code pool --- .../instruction-set-models/x86_64/prog_x64Script.sml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/machine-code/instruction-set-models/x86_64/prog_x64Script.sml b/examples/machine-code/instruction-set-models/x86_64/prog_x64Script.sml index 18919c8232..595ded223c 100644 --- a/examples/machine-code/instruction-set-models/x86_64/prog_x64Script.sml +++ b/examples/machine-code/instruction-set-models/x86_64/prog_x64Script.sml @@ -1209,7 +1209,7 @@ val X64_SPEC_EXLPODE_CODE_LEMMA = store_thm("X64_SPEC_EXLPODE_CODE_LEMMA", val X64_SPEC_EXLPODE_CODE = save_thm("X64_SPEC_EXLPODE_CODE", RW [UNION_EMPTY] (Q.SPEC `{}` X64_SPEC_EXLPODE_CODE_LEMMA)); -val CODE_POOL_INSERT_INSERT = prove( +val CODE_POOL_INSERT_INSERT = store_thm("CODE_POOL_INSERT_INSERT", ``CODE_POOL X64_INSTR ((a1,xs) INSERT (a1 + n2w (LENGTH xs),ys) INSERT s) = CODE_POOL X64_INSTR ((a1,xs ++ ys) INSERT s)``, SIMP_TAC std_ss [CODE_POOL_def,IMAGE_INSERT] \\ ONCE_REWRITE_TAC [FUN_EQ_THM] From e8e1f70ea89e04872dbc8e092e6e192ae204505a Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Sat, 20 Dec 2014 20:58:56 +1100 Subject: [PATCH 062/718] GEN_VALIDATE(_LT) - flag for adding new subgoals in any event GEN_VALIDATE false is like VALIDATE, but adds subgoals for the assumptions of the theorem produced by the justification, regardless of whether they are among the assumptions of the goal. Advantage of this is that GEN_VALIDATE false (ACCEPT_TAC th) produces predictable subgoals, which may help in coding compound tactics --- help/Docfiles/Tactical.GEN_VALIDATE.doc | 75 ++++++++++++++++++++++ help/Docfiles/Tactical.GEN_VALIDATE_LT.doc | 42 ++++++++++++ help/Docfiles/Tactical.VALIDATE.doc | 5 +- src/1/Tactical.sig | 2 + src/1/Tactical.sml | 33 +++++++--- 5 files changed, 145 insertions(+), 12 deletions(-) create mode 100644 help/Docfiles/Tactical.GEN_VALIDATE.doc create mode 100644 help/Docfiles/Tactical.GEN_VALIDATE_LT.doc diff --git a/help/Docfiles/Tactical.GEN_VALIDATE.doc b/help/Docfiles/Tactical.GEN_VALIDATE.doc new file mode 100644 index 0000000000..2bbcdfbc97 --- /dev/null +++ b/help/Docfiles/Tactical.GEN_VALIDATE.doc @@ -0,0 +1,75 @@ +\DOC GEN_VALIDATE + +\TYPE {GEN_VALIDATE : bool -> tactic -> tactic} + +\SYNOPSIS +Where a tactic requires assumptions to be in the goal, +add those assumptions as new subgoals. + +\DESCRIBE +See {VALIDATE}, which is implemented as {GEN_VALIDATE true}. + +Suppose {tac} applied to the goal {(asl,g)} produces a justification that +creates a theorem {A |- g'}. +Then {GEN_VALIDATE false} adds new subgoals for members of {A}, +regardless of whether they are present in {asl}. + +\FAILURE +Fails by design if {tac}, when applied to a goal, +produces a proof which is invalid on account of proving +a theorem whose conclusion differs from that of the goal. + +Also fails if {tac} fails when applied to the given goal. + +\EXAMPLE +For example, where theorem {uthr'} is {[p', q] |- r} + +{ +1 subgoal: +val it = + +r +------------------------------------ + 0. p + 1. q + +> e (VALIDATE (ACCEPT_TAC uthr')) ; +OK.. +1 subgoal: +val it = + +p' +------------------------------------ + p +: + proof +} +but, instead of that, +{ +> e (GEN_VALIDATE false (ACCEPT_TAC uthr')) ; +OK.. +2 subgoals: +val it = + +q +------------------------------------ + 0. p + 1. q + + +p' +------------------------------------ + 0. p + 1. q +} + +\USES +Use {GEN_VALIDATE false} rather than {VALIDATE} +when programming compound tactics if you want to know +what the resulting subgoals will be, + regardless of what the assumptions of the goal are. + +\SEEALSO +Tactical.VALID, Tactical.VALIDATE + +\ENDDOC diff --git a/help/Docfiles/Tactical.GEN_VALIDATE_LT.doc b/help/Docfiles/Tactical.GEN_VALIDATE_LT.doc new file mode 100644 index 0000000000..c388363552 --- /dev/null +++ b/help/Docfiles/Tactical.GEN_VALIDATE_LT.doc @@ -0,0 +1,42 @@ +\DOC GEN_VALIDATE_LT + +\TYPE {GEN_VALIDATE_LT : bool -> list_tactic -> list_tactic} + +\SYNOPSIS +Where a list-tactic requires assumptions to be in the goal, +add those assumptions as new subgoals. + +\DESCRIBE +See {VALIDATE_LT}, which is implemented as {GEN_VALIDATE_LT true}. + +When list-tactic {ltac} is applied to a goal list {gl} +it produces a new goal list {gl'} and a justification. +When the justification is applied to a list {thl'} of theorems +which are the new goals {gl'}, proved, it produces a list {thl} +of theorems (which, for a valid list-tactic are the goals {gl}, proved). + +But {GEN_VALIDATE_LT false ltac} also returns extra subgoals corresponding to +the assumptions of {thl}. + +See {GEN_VALIDATE} for more details. + +\FAILURE +Fails by design if {ltac}, when applied to a goal list, +produces a proof which is invalid on account of proving +a theorem whose conclusion differs from that of the corresponding goal. + +Also fails if {ltac} fails when applied to the given goals. + +\USES +Compared with {VALIDATE_LT ltac}, {GEN_VALIDATE_LT false ltac} can +produces extra, unnecessary, subgoals. +But since the subgoals produced are predictable, regardless of the assumptions +of the goal, which may be useful when coding compound tactics. + +\SEEALSO +Tactical.VALID, Tactical.VALID_LT, Tactical.VALIDATE, +Tactical.VALIDATE_LT, Tactical.GEN_VALIDATE + +\ENDDOC + + diff --git a/help/Docfiles/Tactical.VALIDATE.doc b/help/Docfiles/Tactical.VALIDATE.doc index 6b677d84ae..291c2fbbb5 100644 --- a/help/Docfiles/Tactical.VALIDATE.doc +++ b/help/Docfiles/Tactical.VALIDATE.doc @@ -12,7 +12,7 @@ creates a theorem {A |- g'}. If {A} a not a subset of {asl}, then the tactic is invalid (and {VALID tac (asl,g)} fails, ie, raises an exception). But {VALIDATE tac (asl,g)} produces a subgoal list augmented by the -members of {asl} missing from {A}. +members of {A} missing from {asl}. If {g'} differs from {g}, both {VALID tac (asl,g)} and {VALIDATE tac (asl,g)} fail. @@ -97,6 +97,7 @@ which are not present but are capable of being proved, assumptions. \SEEALSO -proofManagerLib.expand, Tactical.VALID, Tactical.SUBGOAL_THEN. +proofManagerLib.expand, Tactical.VALID, Tactical.GEN_VALIDATE, +Tactical.SUBGOAL_THEN. \ENDDOC diff --git a/src/1/Tactical.sig b/src/1/Tactical.sig index 9f06979f99..2dbcf35c21 100644 --- a/src/1/Tactical.sig +++ b/src/1/Tactical.sig @@ -41,6 +41,8 @@ sig val VALID_LT : list_tactic -> list_tactic val VALIDATE : tactic -> tactic val VALIDATE_LT : list_tactic -> list_tactic + val GEN_VALIDATE : bool -> tactic -> tactic + val GEN_VALIDATE_LT : bool -> list_tactic -> list_tactic val EVERY : tactic list -> tactic val FIRST : tactic list -> tactic val MAP_EVERY : ('a -> tactic) -> 'a list -> tactic diff --git a/src/1/Tactical.sml b/src/1/Tactical.sml index 71639fa120..b2d0cf7dd1 100644 --- a/src/1/Tactical.sml +++ b/src/1/Tactical.sml @@ -372,31 +372,40 @@ end * tactic or list_tactic valid. * * VALIDATE tac + * GEN_VALIDATE true tac * * is the same as "tac", except that where "tac" returns a proof which is * because if proves a theorem with extra hypotheses, it returns those * hypotheses as extra goals * * VALIDATE_LT ltac + * GEN_VALIDATE_LT true ltac * * is the same as "ltac", except it will return extra goals where this is * necessary to make a valid list-tactic + * + * GEN_VALIDATE(_LT) false always returns extra goals corresponding + * to the hypotheses of the theorem proved + * *---------------------------------------------------------------------------*) local val validity_tag = "ValidityCheck" fun masquerade goal = Thm.mk_oracle_thm validity_tag goal ; fun achieves_concl th (asl, w) = Term.aconv (concl th) w ; fun hyps_not_in_goal th (asl, w) = Lib.filter (fn h => not (Lib.exists (aconv h) asl)) (hyp th) ; - fun extra_goals_tbp th (asl, w) = - List.map (fn eg => (asl, eg)) (hyps_not_in_goal th (asl, w)) ; + fun extra_goals_tbp flag th (asl, w) = + List.map (fn eg => (asl, eg)) + (case flag of true => hyps_not_in_goal th (asl, w) + | false => hyp th) ; in -fun VALIDATE (tac : tactic) (g as (asl, w) : goal) = +(* GEN_VALIDATE : bool -> tactic -> tactic *) +fun GEN_VALIDATE (flag : bool) (tac : tactic) (g as (asl, w) : goal) = let val (glist, prf) = tac g ; (* pretend new goals are theorems, and apply validation to them *) val thprf = (prf (map masquerade glist)) ; val _ = if achieves_concl thprf g then () - else raise ERR "VALIDATE" "Invalid tactic - wrong conclusion" ; - val extra_goals = extra_goals_tbp thprf g ; + else raise ERR "GEN_VALIDATE" "Invalid tactic - wrong conclusion" ; + val extra_goals = extra_goals_tbp flag thprf g ; val nextra = length extra_goals ; (* new validation: apply the theorems proving the additional goals to eliminate the extra hyps in the theorem proved by the given validation *) @@ -412,15 +421,15 @@ fun split_lists (n :: ns) ths = in (nths :: nsths, left) end | split_lists [] ths = ([], ths) ; -(* VALIDATE_LT : list_tactic -> list_tactic *) -fun VALIDATE_LT (ltac : list_tactic) (gl : goal list) = +(* GEN_VALIDATE_LT : bool -> list_tactic -> list_tactic *) +fun GEN_VALIDATE_LT (flag : bool) (ltac : list_tactic) (gl : goal list) = let val (glist, prf) = ltac gl ; (* pretend new goals are theorems, and apply validation to them *) val thsprf = (prf (map masquerade glist)) ; val _ = if Lib.all2 achieves_concl thsprf gl then () - else raise ERR "VALIDATE_LT" + else raise ERR "GEN_VALIDATE_LT" "Invalid list-tactic - some wrong conclusion" ; - val extra_goal_lists = Lib.map2 extra_goals_tbp thsprf gl ; + val extra_goal_lists = Lib.map2 (extra_goals_tbp flag) thsprf gl ; val nextras = map length extra_goal_lists ; (* new validation: apply the theorems proving the additional goals to eliminate the extra hyps in the theorems proved by the given validation *) @@ -431,8 +440,12 @@ fun VALIDATE_LT (ltac : list_tactic) (gl : goal list) = end; +val VALIDATE = GEN_VALIDATE true ; +val VALIDATE_LT = GEN_VALIDATE_LT true ; + (* could avoid duplication of code in the above by the following -fun VALIDATE tac = ALL_TAC THEN_LT VALIDATE_LT (TACS_TO_LT [tac]) ; +fun GEN_VALIDATE flag tac = + ALL_TAC THEN_LT GEN_VALIDATE_LT flag (TACS_TO_LT [tac]) ; *) (*--------------------------------------------------------------------------- From fce4b42aaca3feff27380cba13acd9ec3972d50f Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Sat, 20 Dec 2014 23:57:40 +1100 Subject: [PATCH 063/718] added flatn command in proofManagerLib in interactive proof, to flatten subgoal stack, so as to merge current list of subgoals with previous level(s) --- help/Docfiles/proofManagerLib.expand.doc | 4 +- help/Docfiles/proofManagerLib.expand_list.doc | 2 +- help/Docfiles/proofManagerLib.flatn.doc | 37 +++++++++++++++++++ help/Docfiles/proofManagerLib.set_goal.doc | 9 ++++- src/proofman/Manager.sig | 1 + src/proofman/Manager.sml | 4 ++ src/proofman/goalStack.sig | 1 + src/proofman/goalStack.sml | 15 ++++++++ src/proofman/proofManagerLib.sig | 1 + src/proofman/proofManagerLib.sml | 4 ++ 10 files changed, 73 insertions(+), 5 deletions(-) create mode 100644 help/Docfiles/proofManagerLib.flatn.doc diff --git a/help/Docfiles/proofManagerLib.expand.doc b/help/Docfiles/proofManagerLib.expand.doc index eb029f4ed0..e97b42017e 100644 --- a/help/Docfiles/proofManagerLib.expand.doc +++ b/help/Docfiles/proofManagerLib.expand.doc @@ -146,7 +146,7 @@ Doing a step in an interactive goal-directed proof. proofManagerLib.set_goal, proofManagerLib.restart, proofManagerLib.backup,proofManagerLib.restore, proofManagerLib.save, proofManagerLib.set_backup,proofManagerLib.expand, proofManagerLib.expandf, -proofManagerLib.p,proofManagerLib.top_thm, proofManagerLib.top_goal, -Tactical.VALID, Tactical.VALIDATE +proofManagerLib.flatn,proofManagerLib.p,proofManagerLib.top_thm, +proofManagerLib.top_goal, Tactical.VALID, Tactical.VALIDATE \ENDDOC diff --git a/help/Docfiles/proofManagerLib.expand_list.doc b/help/Docfiles/proofManagerLib.expand_list.doc index 94b71fa0d5..7db56b52b3 100644 --- a/help/Docfiles/proofManagerLib.expand_list.doc +++ b/help/Docfiles/proofManagerLib.expand_list.doc @@ -89,7 +89,7 @@ preceding step. proofManagerLib.set_goal, proofManagerLib.restart, proofManagerLib.backup,proofManagerLib.restore, proofManagerLib.save, proofManagerLib.set_backup,proofManagerLib.expand, proofManagerLib.expandf, -proofManagerLib.expand_listf, +proofManagerLib.expand_listf, proofManagerLib.flatn, proofManagerLib.p,proofManagerLib.top_thm, proofManagerLib.top_goal. \ENDDOC diff --git a/help/Docfiles/proofManagerLib.flatn.doc b/help/Docfiles/proofManagerLib.flatn.doc new file mode 100644 index 0000000000..3df347ab4f --- /dev/null +++ b/help/Docfiles/proofManagerLib.flatn.doc @@ -0,0 +1,37 @@ +\DOC flatn + +\TYPE {flatn : int -> unit} + +\SYNOPSIS +Flattens the tree structure of subgoals on the subgoal package goal stack. + +\DESCRIBE +The function {flatn} is part of the subgoal package. +For a general description of the subgoal package, see {set_goal}. + +The {flatn} function's basic step of operation is to take the +the current list of sub-goals and concatenate it with the previous list of +subgoals (excluding the first of that list, from which the current list was +obtained). +The numeric argument passed to {flatn} specifies how many +times this operation is to be performed. + +\FAILURE +Raises the {NO_PROOFS} exception if there is no current proof +manipulated by the subgoal package. + +If {n} is too large, or negative, +the result will be a flat list of all subgoals. + +\USES +To view, reorder, or attack simultaneously, +current and previously obtained subgoals. + +\SEEALSO +proofManagerLib.set_goal, proofManagerLib.restart, +proofManagerLib.backup,proofManagerLib.restore, proofManagerLib.save, +proofManagerLib.set_backup,proofManagerLib.expand, proofManagerLib.expandf, +proofManagerLib.p,proofManagerLib.top_thm, proofManagerLib.top_goal. + +\ENDDOC + diff --git a/help/Docfiles/proofManagerLib.set_goal.doc b/help/Docfiles/proofManagerLib.set_goal.doc index 7a0401cb15..da552bb0fb 100644 --- a/help/Docfiles/proofManagerLib.set_goal.doc +++ b/help/Docfiles/proofManagerLib.set_goal.doc @@ -46,8 +46,12 @@ subgoals and justifications. These are pushed onto the goal stack and justification stack, respectively, to form a new proof state. Several preceding proof states are saved and can be returned to if a mistake is made in the proof. The goal stack is divided into levels, a new level being -created each time a tactic is successfully applied to give new subgoals. The -subgoals of the current level may be considered in any order. +created each time a tactic is successfully applied to give new subgoals. +Alternatively a list-tactic can process the entire list of goals of the current +level to change that level (rather than creating a new level). +The subgoals of the current level may be considered in any order. +Levels of the goal stack may be collapsed so that subgoals of a previous level +appear as part of of the current level. If a tactic solves the current goal (returns an empty subgoal list), then its justification is used to prove a corresponding theorem. This theorem is @@ -66,6 +70,7 @@ saved. proofManagerLib.set_goal, proofManagerLib.restart, proofManagerLib.backup,proofManagerLib.restore, proofManagerLib.save, proofManagerLib.set_backup,proofManagerLib.expand, proofManagerLib.expandf, +proofManagerLib.expand_list, proofManagerLib.flatn, proofManagerLib.p,proofManagerLib.top_thm, proofManagerLib.top_goal. \ENDDOC diff --git a/src/proofman/Manager.sig b/src/proofman/Manager.sig index b1fb138712..d9b2d35108 100644 --- a/src/proofman/Manager.sig +++ b/src/proofman/Manager.sig @@ -41,6 +41,7 @@ sig (* Switch focus to a different subgoal (or proof attempt) *) val rotate : int -> proof -> proof + val flatn : int -> proof -> proof val rotate_proofs : int -> proofs -> proofs (* Operations on proof attempts *) diff --git a/src/proofman/Manager.sml b/src/proofman/Manager.sml index f7269fe9a3..ff4c1b2bce 100644 --- a/src/proofman/Manager.sml +++ b/src/proofman/Manager.sml @@ -120,6 +120,10 @@ fun rotate i (GOALSTACK s) = GOALSTACK(apply (C goalStack.rotate i) s) | rotate i (GOALTREE t) = raise ERR "rotate" "not implemented for goal trees"; +fun flatn i (GOALSTACK s) = GOALSTACK(apply (C goalStack.flatn i) s) + | flatn i (GOALTREE t) = raise ERR "flatn" + "not implemented for goal trees"; + fun restart (GOALSTACK s) = GOALSTACK (new_history_default (initialValue s)) | restart (GOALTREE t) = GOALTREE (new_history_default (initialValue t)); diff --git a/src/proofman/goalStack.sig b/src/proofman/goalStack.sig index ac4fe37357..1125d0e108 100644 --- a/src/proofman/goalStack.sig +++ b/src/proofman/goalStack.sig @@ -17,6 +17,7 @@ sig val is_initial : gstk -> bool val new_goal : goal -> (thm -> thm) -> gstk val rotate : gstk -> int -> gstk + val flatn : gstk -> int -> gstk val top_goal : gstk -> goal val top_goals : gstk -> goal list val depth : gstk -> int diff --git a/src/proofman/goalStack.sml b/src/proofman/goalStack.sml index aa703dbbec..a8460e134f 100644 --- a/src/proofman/goalStack.sml +++ b/src/proofman/goalStack.sml @@ -177,6 +177,21 @@ end ; fun expand tac gs = expandf (Tactical.VALID tac) gs; fun expand_list ltac gs = expand_listf (Tactical.VALID_LT ltac) gs; +fun flat (GSTK{prop, stack as {goals,validation} :: + {goals = g2 :: goals2, validation = validation2} :: rst, final}) = + let fun v thl = + let val (thl1, thl2) = Lib.split_after (length goals) thl ; + in validation2 (validation thl1 :: thl2) end ; + val newgv = {goals = goals @ goals2, validation = v} ; + in GSTK {prop = prop, stack = newgv :: rst, final = final} end ; + +fun flatn (GSTK{prop=PROVED _, ...}) n = + raise ERR "flatn" "goal has already been proved" + | flatn gstk 0 = gstk + | flatn (gstk as GSTK{prop, stack = [], final}) n = gstk + | flatn (gstk as GSTK{prop, stack as [_], final}) n = gstk + | flatn (gstk as GSTK{prop, stack, final}) n = flatn (flat gstk) (n-1) ; + fun extract_thm (GSTK{prop=PROVED(th,_), ...}) = th | extract_thm _ = raise ERR "extract_thm" "no theorem proved"; diff --git a/src/proofman/proofManagerLib.sig b/src/proofman/proofManagerLib.sig index d6d26ddda9..f53cd785af 100644 --- a/src/proofman/proofManagerLib.sig +++ b/src/proofman/proofManagerLib.sig @@ -56,6 +56,7 @@ sig val r : int -> proof val R : int -> proofs val rotate : int -> proof + val flatn : int -> proof val rotate_proofs : int -> proofs (* Switch to a different prettyprinter for all goals *) diff --git a/src/proofman/proofManagerLib.sml b/src/proofman/proofManagerLib.sml index a5e705db8a..1a9d0f581e 100644 --- a/src/proofman/proofManagerLib.sml +++ b/src/proofman/proofManagerLib.sml @@ -121,6 +121,10 @@ fun p () = Manager.hd_proj I (proofs()) val status = proofs; +fun flatn i = + (the_proofs := Manager.hd_opr (Manager.flatn i) (proofs()); + top_proof()); + fun rotate i = (the_proofs := Manager.hd_opr (Manager.rotate i) (proofs()); top_proof()); From 284ce52d3ac95cb5c4814c66fb3d8168c3c46e22 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Sun, 21 Dec 2014 05:20:03 +0000 Subject: [PATCH 064/718] reuse cpn datatype from totoTheory in comparisonTheory rather than creating an isomorphic new type. balanced_mapScript.sml has apparently (but not actually) significant changes because the proofs depend heavily on the order in which the comparison datatype constructors are defined (inasmuch as it affects the order of subgoals from cases/induction). --- examples/balanced_bst/balanced_mapScript.sml | 97 +++++++++++--------- examples/balanced_bst/comparisonScript.sml | 13 +-- examples/balanced_bst/osetScript.sml | 2 + 3 files changed, 61 insertions(+), 51 deletions(-) diff --git a/examples/balanced_bst/balanced_mapScript.sml b/examples/balanced_bst/balanced_mapScript.sml index 5fc12e54d4..eaee1364f6 100644 --- a/examples/balanced_bst/balanced_mapScript.sml +++ b/examples/balanced_bst/balanced_mapScript.sml @@ -11,6 +11,13 @@ val _ = new_theory "balanced_map"; val _ = temp_tight_equality (); val _ = numLib.prefer_num(); +val _ = Parse.temp_overload_on("Less",``LESS``) +val _ = Parse.temp_overload_on("Equal",``EQUAL``) +val _ = Parse.temp_overload_on("Greater",``GREATER``) +val comparison_distinct = totoTheory.cpn_distinct +val comparison_case_def = totoTheory.cpn_case_def +val comparison_nchotomy = totoTheory.cpn_nchotomy + val list_rel_lem1 = Q.prove ( `!f l l'. ~LIST_REL f l l' @@ -1304,6 +1311,10 @@ val insert_thm = Q.store_thm ("insert_thm", rw [] >> `key_set cmp k ≠ key_set cmp k'` by metis_tac [key_set_eq, cmp_thms] >> metis_tac [FUPDATE_COMMUTES]) + >- (fs [invariant_def] >> + rfs [key_ordered_to_fmap] >> + metis_tac [to_fmap_key_set, key_set_cmp_thm, cmp_thms]) + >- metis_tac [key_set_eq, FUPDATE_EQ] >- (rfs [key_ordered_to_fmap] >> rw [] >> imp_res_tac to_fmap_key_set >> @@ -1316,11 +1327,7 @@ val insert_thm = Q.store_thm ("insert_thm", >- (rw [FUNION_FUPDATE_2, to_fmap_def] >> rfs [key_ordered_to_fmap] >> rw [] >> - metis_tac [FUPDATE_COMMUTES, cmp_thms, to_fmap_key_set, key_set_cmp_thm]) - >- (fs [invariant_def] >> - rfs [key_ordered_to_fmap] >> - metis_tac [to_fmap_key_set, key_set_cmp_thm, cmp_thms]) - >- metis_tac [key_set_eq, FUPDATE_EQ]); + metis_tac [FUPDATE_COMMUTES, cmp_thms, to_fmap_key_set, key_set_cmp_thm])); val insertR_thm = Q.store_thm ("insertR_thm", `∀t. @@ -1354,6 +1361,9 @@ val insertR_thm = Q.store_thm ("insertR_thm", imp_res_tac balanceL_thm >> rw [FUNION_FUPDATE_1] >> metis_tac [FUPDATE_COMMUTES, good_cmp_def, comparison_distinct]) + >- (fs [invariant_def] >> + rfs [key_ordered_to_fmap] >> + metis_tac [to_fmap_key_set, key_set_cmp_thm, cmp_thms,key_set_eq, FUPDATE_EQ]) >- (`almost_balancedR (size t) (size (insertR cmp k v t'))` by (imp_res_tac size_thm >> rw [FCARD_FUPDATE] >> @@ -1369,10 +1379,7 @@ val insertR_thm = Q.store_thm ("insertR_thm", imp_res_tac balanceR_thm >> rw [FUNION_FUPDATE_2] >> rfs [key_ordered_to_fmap] >> - metis_tac [FUPDATE_COMMUTES, good_cmp_def, comparison_distinct]) - >- (fs [invariant_def] >> - rfs [key_ordered_to_fmap] >> - metis_tac [to_fmap_key_set, key_set_cmp_thm, cmp_thms,key_set_eq, FUPDATE_EQ])); + metis_tac [FUPDATE_COMMUTES, good_cmp_def, comparison_distinct])); val insertMax_thm = Q.store_thm ("insertMax_thm", `∀t. @@ -1815,6 +1822,11 @@ val delete_thm = Q.store_thm ("delete_thm", imp_res_tac almost_balancedR_thm >> metis_tac [FCARD_DEF]) >- to_fmap_tac) + >- (inv_mp_tac glue_thm >> + rw [] >> + rfs [key_ordered_to_fmap] + >- metis_tac [key_set_cmp2_thm, to_fmap_key_set, key_set_cmp_thm, cmp_thms] + >- to_fmap_tac) >- (inv_mp_tac balanceL_thm >> simp [] >> rw [] @@ -1826,11 +1838,6 @@ val delete_thm = Q.store_thm ("delete_thm", rw [FCARD_DRESTRICT, DELETE_INTER2] >> imp_res_tac almost_balancedL_thm >> metis_tac [FCARD_DEF]) - >- to_fmap_tac) - >- (inv_mp_tac glue_thm >> - rw [] >> - rfs [key_ordered_to_fmap] - >- metis_tac [key_set_cmp2_thm, to_fmap_key_set, key_set_cmp_thm, cmp_thms] >- to_fmap_tac)); val restrict_set_def = Define ` @@ -2059,11 +2066,11 @@ val filter_lt_help_thm = Q.prove ( rw [restrict_domain_def]) >> rw [restrict_domain_def, restrict_set_def, option_cmp_def, option_cmp2_def] >> to_fmap_tac) - >- (first_x_assum inv_mp_tac >> - fs [invariant_eq] >> + >- (fs [invariant_eq] >> rw [restrict_domain_def, restrict_set_def, option_cmp2_def, option_cmp_def] >> to_fmap_tac) - >- (fs [invariant_eq] >> + >- (first_x_assum inv_mp_tac >> + fs [invariant_eq] >> rw [restrict_domain_def, restrict_set_def, option_cmp2_def, option_cmp_def] >> to_fmap_tac)); @@ -2107,11 +2114,11 @@ val filter_gt_help_thm = Q.prove ( rw [restrict_domain_def]) >> rw [restrict_domain_def, restrict_set_def, option_cmp_def, option_cmp2_def] >> to_fmap_tac) - >- (first_x_assum inv_mp_tac >> - fs [invariant_eq] >> + >- (fs [invariant_eq] >> rw [restrict_domain_def, restrict_set_def, option_cmp2_def, option_cmp_def] >> to_fmap_tac) - >- (fs [invariant_eq] >> + >- (first_x_assum inv_mp_tac >> + fs [invariant_eq] >> rw [restrict_domain_def, restrict_set_def, option_cmp2_def, option_cmp_def] >> to_fmap_tac)); @@ -2901,6 +2908,17 @@ val splitLookup_thm = Q.store_thm ("splitLookup_thm", rfs [key_ordered_to_fmap, flookup_thm] >> res_tac >> metis_tac [cmp_thms, key_set_cmp_def, key_set_cmp_thm]) + >- (fs [invariant_eq] >> + fmrw [key_set_eq] >> + rfs [key_ordered_to_fmap] >> + res_tac >> + fs [key_set_cmp_def] >> + fmrw [fmap_eq_flookup] >> + every_case_tac >> + fs [] >> + rw [] >> + rfs [key_set_eq] >> + metis_tac [cmp_thms]) >- (`?lt v gt. splitLookup cmp k t' = (lt,v,gt)` by metis_tac [pair_CASES] >> fs [] >> fs [invariant_eq] >> @@ -2924,18 +2942,7 @@ val splitLookup_thm = Q.store_thm ("splitLookup_thm", rfs [key_ordered_to_fmap, flookup_thm] >> fs [key_ordered_to_fmap, flookup_thm] >> res_tac >> - metis_tac [cmp_thms, key_set_cmp_def, key_set_cmp_thm]) - >- (fs [invariant_eq] >> - fmrw [key_set_eq] >> - rfs [key_ordered_to_fmap] >> - res_tac >> - fs [key_set_cmp_def] >> - fmrw [fmap_eq_flookup] >> - every_case_tac >> - fs [] >> - rw [] >> - rfs [key_set_eq] >> - metis_tac [cmp_thms])); + metis_tac [cmp_thms, key_set_cmp_def, key_set_cmp_thm])); val submap'_thm = Q.prove ( `!cmp f t1 t2. @@ -3000,6 +3007,7 @@ val submap'_thm = Q.prove ( res_tac >- (qexists_tac `v''` >> rw []) + >- metis_tac [cmp_thms] >- (rfs [key_ordered_to_fmap] >> `FLOOKUP (to_fmap cmp lt) (key_set cmp k) = NONE` by (fs [FLOOKUP_DEF] >> @@ -3008,18 +3016,17 @@ val submap'_thm = Q.prove ( res_tac >> fs [key_set_cmp_def, key_set_def] >> metis_tac [cmp_thms]) >> - rw []) - >- metis_tac [cmp_thms]) >> + rw [])) >> rw [] >- (first_assum (qspecl_then [`kx`, `x`] assume_tac) >> every_case_tac >> fs [] >- metis_tac [cmp_thms] - >- metis_tac [cmp_thms] >> - imp_res_tac lookup_thm >> - fs [] >> - rfs [] >> - rw []) + >- (imp_res_tac lookup_thm >> + fs [] >> + rfs [] >> + rw []) + >- metis_tac [cmp_thms]) >- (imp_res_tac lookup_thm >> fs [] >> rfs [FLOOKUP_UPDATE] >> @@ -3036,13 +3043,13 @@ val submap'_thm = Q.prove ( res_tac >> fs [key_set_cmp_def, key_set_def] >> metis_tac [cmp_thms]) - >- (`cmp kx k ≠ Equal` by metis_tac [cmp_thms] >> + >- (`cmp kx k = Equal` by metis_tac [cmp_thms] >> fs [FLOOKUP_DEF] >> rfs [key_ordered_to_fmap] >> res_tac >> fs [key_set_cmp_def, key_set_def] >> metis_tac [cmp_thms]) - >- (`cmp kx k = Equal` by metis_tac [cmp_thms] >> + >- (`cmp kx k ≠ Equal` by metis_tac [cmp_thms] >> fs [FLOOKUP_DEF] >> rfs [key_ordered_to_fmap] >> res_tac >> @@ -3062,15 +3069,15 @@ val submap'_thm = Q.prove ( res_tac >> fs [key_set_cmp_def, key_set_def] >> metis_tac [cmp_thms]) - >- (`cmp kx k ≠ Equal` by metis_tac [cmp_thms] >> - fs [FLOOKUP_FUNION] >> - Cases_on `FLOOKUP (to_fmap cmp lt) (key_set cmp k)` >> + >- (`cmp kx k = Equal` by metis_tac [cmp_thms] >> fs [FLOOKUP_DEF] >> rfs [key_ordered_to_fmap] >> res_tac >> fs [key_set_cmp_def, key_set_def] >> metis_tac [cmp_thms]) - >- (`cmp kx k = Equal` by metis_tac [cmp_thms] >> + >- (`cmp kx k ≠ Equal` by metis_tac [cmp_thms] >> + fs [FLOOKUP_FUNION] >> + Cases_on `FLOOKUP (to_fmap cmp lt) (key_set cmp k)` >> fs [FLOOKUP_DEF] >> rfs [key_ordered_to_fmap] >> res_tac >> diff --git a/examples/balanced_bst/comparisonScript.sml b/examples/balanced_bst/comparisonScript.sml index d563a2dd3c..ebb2fddf14 100644 --- a/examples/balanced_bst/comparisonScript.sml +++ b/examples/balanced_bst/comparisonScript.sml @@ -1,5 +1,5 @@ open HolKernel boolLib bossLib BasicProvers; -open optionTheory pairTheory stringTheory listTheory arithmeticTheory; +open optionTheory pairTheory stringTheory listTheory arithmeticTheory totoTheory; open lcsymtacs; val _ = new_theory "comparison"; @@ -7,11 +7,12 @@ val _ = new_theory "comparison"; val _ = temp_tight_equality (); val every_case_tac = BasicProvers.EVERY_CASE_TAC; -val _ = Datatype `comparison = Less | Greater | Equal`; - -val comparison_distinct = fetch "-" "comparison_distinct"; -val comparison_case_def = fetch "-" "comparison_case_def"; -val comparison_nchotomy = fetch "-" "comparison_nchotomy"; +val comparison_distinct = cpn_distinct +val comparison_case_def = cpn_case_def +val comparison_nchotomy = cpn_nchotomy +val _ = Parse.temp_overload_on("Less",``LESS``) +val _ = Parse.temp_overload_on("Equal",``EQUAL``) +val _ = Parse.temp_overload_on("Greater",``GREATER``) val good_cmp_def = Define ` good_cmp cmp ⇔ diff --git a/examples/balanced_bst/osetScript.sml b/examples/balanced_bst/osetScript.sml index e0f1c7a59e..ff3b83c32f 100644 --- a/examples/balanced_bst/osetScript.sml +++ b/examples/balanced_bst/osetScript.sml @@ -8,6 +8,8 @@ val _ = new_theory "oset"; val _ = temp_tight_equality (); +val _ = Parse.temp_overload_on("Equal",``EQUAL``) + (* oset for ordered set *) val _ = type_abbrev ("oset", ``:('a,unit) balanced_map``); From a7c65cf7865374691b18f2ff267de50c59416595 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Sun, 21 Dec 2014 08:32:52 +0000 Subject: [PATCH 065/718] prove TotOrd implies good_cmp --- examples/balanced_bst/comparisonScript.sml | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/examples/balanced_bst/comparisonScript.sml b/examples/balanced_bst/comparisonScript.sml index ebb2fddf14..1aecac91ef 100644 --- a/examples/balanced_bst/comparisonScript.sml +++ b/examples/balanced_bst/comparisonScript.sml @@ -35,6 +35,10 @@ val good_cmp_thm = Q.store_thm ("good_cmp_thm", rw [good_cmp_def] >> metis_tac [comparison_distinct, comparison_nchotomy]); +val TotOrd_imp_good_cmp = store_thm("TotOrder_imp_good_cmp", + ``∀cmp. TotOrd cmp ⇒ good_cmp cmp``, + rw[TotOrd,good_cmp_thm] >> metis_tac[]) + val cmp_thms = save_thm ("cmp_thms", LIST_CONJ [comparison_distinct, comparison_case_def, comparison_nchotomy, good_cmp_def]) val option_cmp_def = Define ` From fef315cad9d9c6c9380e4f2bbce1628429d543e7 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Sun, 21 Dec 2014 08:33:40 +0000 Subject: [PATCH 066/718] delete trailing whitespace in examples/balanced_bst --- examples/balanced_bst/balanced_mapScript.sml | 342 +++++++++---------- examples/balanced_bst/comparisonScript.sml | 26 +- examples/balanced_bst/osetScript.sml | 26 +- 3 files changed, 197 insertions(+), 197 deletions(-) diff --git a/examples/balanced_bst/balanced_mapScript.sml b/examples/balanced_bst/balanced_mapScript.sml index eaee1364f6..568c562e1a 100644 --- a/examples/balanced_bst/balanced_mapScript.sml +++ b/examples/balanced_bst/balanced_mapScript.sml @@ -19,9 +19,9 @@ val comparison_case_def = totoTheory.cpn_case_def val comparison_nchotomy = totoTheory.cpn_nchotomy val list_rel_lem1 = Q.prove ( -`!f l l'. - ~LIST_REL f l l' - ⇒ +`!f l l'. + ~LIST_REL f l l' + ⇒ ∃n. n ≤ LENGTH l ∧ n ≤ LENGTH l' ∧ LIST_REL f (TAKE n l) (TAKE n l') ∧ ((n = LENGTH l ∧ n ≠ LENGTH l') ∨ (n ≠ LENGTH l ∧ n = LENGTH l') ∨ @@ -56,18 +56,18 @@ val list_rel_lem1 = Q.prove ( CCONTR_TAC >> fs [] >> `LIST_REL f (TAKE (max_nset + 1) l) (TAKE (max_nset + 1) l')` - by (fs [rich_listTheory.TAKE_EL_SNOC, SNOC_APPEND, + by (fs [rich_listTheory.TAKE_EL_SNOC, SNOC_APPEND, rich_listTheory.LIST_REL_APPEND_SING]) >> - `max_nset + 1 ∈ {n | (n < LENGTH l ∨ n = LENGTH l) ∧ (n < LENGTH l' ∨ n = LENGTH l') ∧ LIST_REL f (TAKE n l) (TAKE n l')}` + `max_nset + 1 ∈ {n | (n < LENGTH l ∨ n = LENGTH l) ∧ (n < LENGTH l' ∨ n = LENGTH l') ∧ LIST_REL f (TAKE n l) (TAKE n l')}` by srw_tac [ARITH_ss] [] >> imp_res_tac in_max_set >> unabbrev_all_tac >> decide_tac)); val list_rel_lem2 = Q.prove ( -`!l l'. - LIST_REL f l l' - ⇒ +`!l l'. + LIST_REL f l l' + ⇒ ¬∃n. n ≤ LENGTH l ∧ n ≤ LENGTH l' ∧ LIST_REL f (TAKE n l) (TAKE n l') ∧ ((n = LENGTH l ∧ n ≠ LENGTH l') ∨ (n ≠ LENGTH l ∧ n = LENGTH l') ∨ @@ -101,7 +101,7 @@ val list_rel_thm = Q.prove ( LIST_REL f l l' ⇔ !n. ¬(n ≤ LENGTH l) ∨ ¬(n ≤ LENGTH l') ∨ ¬LIST_REL f (TAKE n l) (TAKE n l') ∨ - (n ≠ LENGTH l ∨ n = LENGTH l') ∧ + (n ≠ LENGTH l ∨ n = LENGTH l') ∧ (n = LENGTH l ∨ n ≠ LENGTH l') ∧ (n = LENGTH l ∨ n = LENGTH l' ∨ f (EL n l) (EL n l'))`, rw [] >> @@ -120,7 +120,7 @@ val list_rel_thm = Q.prove ( (n ≠ LENGTH l ∧ n ≠ LENGTH l' ∧ f (EL n l) (EL n l'))`, metis_tac [list_rel_thm]); -val _ = bossLib.augment_srw_ss [rewrites +val _ = bossLib.augment_srw_ss [rewrites [FUNION_FUPDATE_1,FUNION_ASSOC,FUNION_FEMPTY_2,FUNION_FEMPTY_1,FDOM_DRESTRICT, DRESTRICT_UNIV]] @@ -140,7 +140,7 @@ in ONCE_REWRITE_TAC [thm] g end -val inv_mp_tac = let +val inv_mp_tac = let val lemma = PROVE [] ``!A B C D. (A ⇒ B ∧ C) ⇒ (A ∧ (B ∧ C ⇒ D)) ⇒ (B ∧ D)`` in fn th => fn (g as (asl,w)) => let @@ -151,9 +151,9 @@ in val s = fst (match_term tm tm2) val th2 = SPECL (map (Term.subst s) xs) th val th3 = MATCH_MP lemma th2 - in + in MATCH_MP_TAC (GEN_ALL th3) g - end + end end val fdom_eq = PROVE [] ``m1 = m2 ⇒ FDOM m1 = FDOM m2``; @@ -209,7 +209,7 @@ key_set cmp k = { k' | cmp k k' = Equal }`; val key_set_equiv = Q.store_thm ("key_set_equiv", `!cmp. - good_cmp cmp + good_cmp cmp ⇒ (!k. k ∈ key_set cmp k) ∧ (!k1 k2. k1 ∈ key_set cmp k2 ⇒ k2 ∈ key_set cmp k1) ∧ @@ -220,8 +220,8 @@ val key_set_equiv = Q.store_thm ("key_set_equiv", val key_set_partition = Q.store_thm ("key_set_partition", `!cmp k1 k2. good_cmp cmp ∧ - key_set cmp k1 ≠ key_set cmp k2 - ⇒ + key_set cmp k1 ≠ key_set cmp k2 + ⇒ DISJOINT (key_set cmp k1) (key_set cmp k2)`, rw [DISJOINT_DEF, EXTENSION] >> metis_tac [key_set_equiv]); @@ -239,7 +239,7 @@ key_set_cmp cmp k ks res ⇔ !k'. k' ∈ ks ⇒ cmp k k' = res`; val key_set_cmp_thm = Q.store_thm ("key_set_cmp_thm", -`!cmp k k' res. +`!cmp k k' res. good_cmp cmp ⇒ (key_set_cmp cmp k (key_set cmp k') res ⇔ cmp k k' = res)`, @@ -251,7 +251,7 @@ key_set_cmp2 cmp ks1 ks2 res ⇔ !k1 k2. k1 ∈ ks1 ∧ k2 ∈ ks2 ⇒ cmp k1 k2 = res`; val key_set_cmp2_thm = Q.store_thm ("key_set_cmp2_thm", -`!cmp k k' res. +`!cmp k k' res. good_cmp cmp ⇒ (key_set_cmp2 cmp (key_set cmp k) (key_set cmp k') res ⇔ cmp k k' = res)`, @@ -260,7 +260,7 @@ val key_set_cmp2_thm = Q.store_thm ("key_set_cmp2_thm", (* Maps based on balanced binary trees. Copied from ghc-7.8.3 * libraries/containers/Data/Map/Base.hs. It starts with the following comment: - + ----------------------------------------------------------------------------- -- | -- Module : Data.Map.Base @@ -298,7 +298,7 @@ val key_set_cmp2_thm = Q.store_thm ("key_set_cmp2_thm", -- the Big-O notation . ----------------------------------------------------------------------------- -*) +*) val _ = Datatype ` balanced_map = Tip | Bin num 'k 'v balanced_map balanced_map`; @@ -344,9 +344,9 @@ singleton k x = Bin 1 k x Tip Tip`; (* Just like the Haskell, but w/o @ patterns *) val balanceL'_def = Define ` -balanceL' k x l r = +balanceL' k x l r = case r of - | Tip => + | Tip => (case l of | Tip => Bin 1 k x Tip Tip | (Bin _ _ _ Tip Tip) => Bin 2 k x l Tip @@ -355,7 +355,7 @@ balanceL' k x l r = | (Bin ls lk lx (Bin lls k' v' l' r') (Bin lrs lrk lrx lrl lrr)) => if lrs < ratio*lls then Bin (1+ls) lk lx (Bin lls k' v' l' r') (Bin (1+lrs) k x (Bin lrs lrk lrx lrl lrr) Tip) else Bin (1+ls) lrk lrx (Bin (1+lls+size lrl) lk lx (Bin lls k' v' l' r') lrl) (Bin (1+size lrr) k x lrr Tip)) - | (Bin rs _ _ _ _) => + | (Bin rs _ _ _ _) => case l of | Tip => Bin (1+rs) k x Tip r | (Bin ls lk lx ll lr) => @@ -368,7 +368,7 @@ balanceL' k x l r = else Bin (1+ls+rs) k x l r`; val balanceR'_def = Define ` -balanceR' k x l r = +balanceR' k x l r = case l of | Tip => (case r of @@ -379,7 +379,7 @@ balanceR' k x l r = | (Bin rs rk rx (Bin rls rlk rlx rll rlr) (Bin rrs k' v' l' r')) => if rls < ratio*rrs then Bin (1+rs) rk rx (Bin (1+rls) k x Tip (Bin rls rlk rlx rll rlr)) (Bin rrs k' v' l' r') else Bin (1+rs) rlk rlx (Bin (1+size rll) k x Tip rll) (Bin (1+rrs+size rlr) rk rx rlr (Bin rrs k' v' l' r'))) - | (Bin ls _ _ _ _) => + | (Bin ls _ _ _ _) => case r of | Tip => Bin (1+ls) k x l Tip | (Bin rs rk rx rl rr) => @@ -392,38 +392,38 @@ balanceR' k x l r = else Bin (1+ls+rs) k x l r`; val balanceL_def = Define ` -(balanceL k x Tip Tip = +(balanceL k x Tip Tip = Bin 1 k x Tip Tip) ∧ -(balanceL k x (Bin s' k' v' Tip Tip) Tip = +(balanceL k x (Bin s' k' v' Tip Tip) Tip = Bin 2 k x (Bin s' k' v' Tip Tip) Tip) ∧ (balanceL k x (Bin _ lk lx Tip (Bin _ lrk lrx _ _)) Tip = Bin 3 lrk lrx (Bin 1 lk lx Tip Tip) (Bin 1 k x Tip Tip)) ∧ (balanceL k x (Bin _ lk lx (Bin s' k' v' l' r') Tip) Tip = Bin 3 lk lx (Bin s' k' v' l' r') (Bin 1 k x Tip Tip)) ∧ (balanceL k x (Bin ls lk lx (Bin lls k' v' l' r') (Bin lrs lrk lrx lrl lrr)) Tip = - if lrs < ratio*lls then - Bin (1+ls) lk lx (Bin lls k' v' l' r') + if lrs < ratio*lls then + Bin (1+ls) lk lx (Bin lls k' v' l' r') (Bin (1+lrs) k x (Bin lrs lrk lrx lrl lrr) Tip) - else - Bin (1+ls) lrk lrx (Bin (1+lls+size lrl) lk lx (Bin lls k' v' l' r') lrl) + else + Bin (1+ls) lrk lrx (Bin (1+lls+size lrl) lk lx (Bin lls k' v' l' r') lrl) (Bin (1+size lrr) k x lrr Tip)) ∧ -(balanceL k x Tip (Bin rs k' v' l' r') = +(balanceL k x Tip (Bin rs k' v' l' r') = Bin (1+rs) k x Tip (Bin rs k' v' l' r')) ∧ (balanceL k x (Bin ls lk lx ll lr) (Bin rs k' v' l' r') = if ls > delta*rs then case (ll, lr) of | (Bin lls _ _ _ _, Bin lrs lrk lrx lrl lrr) => - if lrs < ratio*lls then + if lrs < ratio*lls then Bin (1+ls+rs) lk lx ll (Bin (1+rs+lrs) k x lr (Bin rs k' v' l' r')) - else - Bin (1+ls+rs) lrk lrx (Bin (1+lls+size lrl) lk lx ll lrl) + else + Bin (1+ls+rs) lrk lrx (Bin (1+lls+size lrl) lk lx ll lrl) (Bin (1+rs+size lrr) k x lrr (Bin rs k' v' l' r')) | (_, _) => Tip (* error "Failure in Data.Map.balanceL" *) - else + else Bin (1+ls+rs) k x (Bin ls lk lx ll lr) (Bin rs k' v' l' r'))`; val balanceR_def = Define ` -(balanceR k x Tip Tip = +(balanceR k x Tip Tip = Bin 1 k x Tip Tip) ∧ (balanceR k x Tip (Bin s' k' v' Tip Tip) = Bin 2 k x Tip (Bin s' k' v' Tip Tip)) ∧ @@ -432,10 +432,10 @@ val balanceR_def = Define ` (balanceR k x Tip (Bin _ rk rx (Bin _ rlk rlx _ _) Tip) = Bin 3 rlk rlx (Bin 1 k x Tip Tip) (Bin 1 rk rx Tip Tip)) ∧ (balanceR k x Tip (Bin rs rk rx (Bin rls rlk rlx rll rlr) (Bin rrs k' v' l' r')) = - if rls < ratio*rrs then + if rls < ratio*rrs then Bin (1+rs) rk rx (Bin (1+rls) k x Tip (Bin rls rlk rlx rll rlr)) (Bin rrs k' v' l' r') - else - Bin (1+rs) rlk rlx (Bin (1+size rll) k x Tip rll) + else + Bin (1+rs) rlk rlx (Bin (1+size rll) k x Tip rll) (Bin (1+rrs+size rlr) rk rx rlr (Bin rrs k' v' l' r'))) ∧ (balanceR k x (Bin ls k' v' l' r') Tip = Bin (1+ls) k x (Bin ls k' v' l' r') Tip) ∧ @@ -443,10 +443,10 @@ val balanceR_def = Define ` if rs > delta*ls then case (rl, rr) of | (Bin rls rlk rlx rll rlr, Bin rrs _ _ _ _) => - if rls < ratio*rrs then + if rls < ratio*rrs then Bin (1+ls+rs) rk rx (Bin (1+ls+rls) k x (Bin ls k' v' l' r') rl) rr - else - Bin (1+ls+rs) rlk rlx (Bin (1+ls+size rll) k x (Bin ls k' v' l' r') rll) + else + Bin (1+ls+rs) rlk rlx (Bin (1+ls+size rll) k x (Bin ls k' v' l' r') rll) (Bin (1+rrs+size rlr) rk rx rlr rr) | (_, _) => Tip (* error "Failure in Data.Map.balanceR" *) else @@ -479,7 +479,7 @@ val insertMin_def = Define ` val deleteFindMax_def = Define ` (deleteFindMax (Bin s k x l Tip) = ((k,x),l)) ∧ (deleteFindMax (Bin s k x l r) = - let (km,r') = deleteFindMax r in + let (km,r') = deleteFindMax r in (km,balanceL k x l r')) ∧ (deleteFindMax Tip = (ARB,Tip))`; (*(error "Map.deleteFindMax: can not return the maximal element of an empty map", Tip)*) @@ -487,7 +487,7 @@ val deleteFindMax_def = Define ` val deleteFindMin_def = Define ` (deleteFindMin (Bin s k x Tip r) = ((k,x),r)) ∧ (deleteFindMin (Bin s k x l r) = - let (km,l') = deleteFindMin l in + let (km,l') = deleteFindMin l in (km,balanceR k x l' r)) ∧ (deleteFindMin Tip = (ARB,Tip))`; (*(error "Map.deleteFindMin: can not return the maximal element of an empty map", Tip)*) @@ -497,10 +497,10 @@ val glue_def = Define ` (glue l Tip = l) ∧ (glue l r = if size l > size r then - let ((km,m),l') = deleteFindMax l in + let ((km,m),l') = deleteFindMax l in balanceR km m l' r else - let ((km,m),r') = deleteFindMin r in + let ((km,m),r') = deleteFindMin r in balanceL km m l r')`; val delete_def = Define ` @@ -512,7 +512,7 @@ val delete_def = Define ` | Eq => glue l r)`; val trim_help_greater_def = Define ` -(trim_help_greater cmp lo (Bin s' k v' l' r) = +(trim_help_greater cmp lo (Bin s' k v' l' r) = if cmp k lo = Less ∨ cmp k lo = Equal then trim_help_greater cmp lo r else @@ -520,7 +520,7 @@ val trim_help_greater_def = Define ` (trim_help_greater cmp lo Tip = Tip)`; val trim_help_lesser_def = Define ` -(trim_help_lesser cmp hi (Bin s' k v' l r') = +(trim_help_lesser cmp hi (Bin s' k v' l r') = if cmp k hi = Greater ∨ cmp k hi = Equal then trim_help_lesser cmp hi l else @@ -528,7 +528,7 @@ val trim_help_lesser_def = Define ` (trim_help_lesser cmp lo Tip = Tip)`; val trim_help_middle_def = Define ` -(trim_help_middle cmp lo hi (Bin s' k v' l r) = +(trim_help_middle cmp lo hi (Bin s' k v' l r) = if cmp k lo = Less ∨ cmp k lo = Equal then trim_help_middle cmp lo hi r else if cmp k hi = Greater ∨ cmp k hi = Equal then @@ -580,7 +580,7 @@ val filterGt_def = Define ` val hedgeUnion_def = Define ` (hedgeUnion cmp blo bhi t1 Tip = t1) ∧ -(hedgeUnion cmp blo bhi Tip (Bin _ kx x l r) = +(hedgeUnion cmp blo bhi Tip (Bin _ kx x l r) = link kx x (filterGt cmp blo l) (filterLt cmp bhi r)) ∧ (hedgeUnion cmp blo bhi t1 (Bin _ kx x Tip Tip) = insertR cmp kx x t1) ∧ (hedgeUnion cmp blo bhi (Bin s kx x l r) t2 = @@ -594,7 +594,7 @@ val union_def = Define ` val foldrWithKey_def = Define ` (foldrWithKey f z' Tip = z') ∧ -(foldrWithKey f z' (Bin _ kx x l r) = +(foldrWithKey f z' (Bin _ kx x l r) = foldrWithKey f (f kx x (foldrWithKey f z' r)) l)`; val toAscList_def = Define ` @@ -611,21 +611,21 @@ val splitLookup_def = Define ` (splitLookup cmp k Tip = (Tip,NONE,Tip)) ∧ (splitLookup cmp k (Bin _ kx x l r) = case cmp k kx of - | Less => + | Less => let (lt,z,gt) = splitLookup cmp k l in let gt' = link kx x gt r in (lt,z,gt') - | Greater => + | Greater => let (lt,z,gt) = splitLookup cmp k r in let lt' = link kx x l lt in (lt',z,gt) - | Equal => + | Equal => (l,SOME x,r))`; val submap'_def = Define ` (submap' cmp _ Tip _ = T) ∧ (submap' cmp _ _ Tip = F) ∧ -(submap' cmp f (Bin _ kx x l r) t = +(submap' cmp f (Bin _ kx x l r) t = case splitLookup cmp kx t of | (lt,NONE,gt) => F | (lt,SOME y,gt) => f x y ∧ submap' cmp f l lt ∧ submap' cmp f r gt)`; @@ -677,7 +677,7 @@ val structure_size_def = Define ` val key_ordered_def = Define ` (key_ordered cmp k Tip res ⇔ T) ∧ -(key_ordered cmp k (Bin n k' v l r) res ⇔ +(key_ordered cmp k (Bin n k' v l r) res ⇔ cmp k k' = res ∧ key_ordered cmp k l res ∧ key_ordered cmp k r res)`; @@ -775,7 +775,7 @@ val lookup_thm = Q.store_thm ("lookup_thm", fs [] >> rw [] >> rfs [key_set_eq] >> - fs [FLOOKUP_DEF] >> + fs [FLOOKUP_DEF] >> metis_tac [cmp_thms]); val member_thm = Q.store_thm ("member_thm", @@ -814,11 +814,11 @@ val singleR_def = Define ` singleR k1 x1 (Bin _ k2 x2 t1 t2) t3 = bin k2 x2 t1 (bin k1 x1 t2 t3)`; val doubleL_def = Define ` -doubleL k1 x1 t1 (Bin _ k2 x2 (Bin _ k3 x3 t2 t3) t4) = +doubleL k1 x1 t1 (Bin _ k2 x2 (Bin _ k3 x3 t2 t3) t4) = bin k3 x3 (bin k1 x1 t1 t2) (bin k2 x2 t3 t4)`; val doubleR_def = Define ` -doubleR k1 x1 (Bin _ k2 x2 t1 (Bin _ k3 x3 t2 t3)) t4 = +doubleR k1 x1 (Bin _ k2 x2 t1 (Bin _ k3 x3 t2 t3)) t4 = bin k3 x3 (bin k2 x2 t1 t2) (bin k1 x1 t3 t4)`; val rotateL_def = Define ` @@ -827,7 +827,7 @@ val rotateL_def = Define ` singleL k x l (Bin s' k' x' ly ry) else doubleL k x l (Bin s' k' x' ly ry)) ∧ -(rotateL k x l Tip = +(rotateL k x l Tip = doubleL k x l Tip)`; val rotateR_def = Define ` @@ -836,7 +836,7 @@ val rotateR_def = Define ` singleR k x (Bin s' k' x' ly ry) r else doubleR k x (Bin s' k' x' ly ry) r) ∧ -(rotateR k x Tip r = +(rotateR k x Tip r = doubleR k x Tip r)`; val bal_def = Define ` @@ -849,7 +849,7 @@ bal k x l r = rotateR k x l r else Bin (size l + size r + 1) k x l r`; - + val balL_def = Define ` balL k x l r = if size l + size r ≤ 1 then @@ -868,7 +868,7 @@ balR k x l r = else Bin (size l + size r + 1) k x l r`; -(* We want a formula that states how unbalanced two trees can be +(* We want a formula that states how unbalanced two trees can be * and still be re-balanced by the balancer. It also has to allow the * trees to be as unbalanced as the link, insert and delete functions need. The * formula below is the result of guesswork. *) @@ -899,7 +899,7 @@ val balanced_lem1 = Q.prove ( rw [balanced_def]); val balanced_lem2 = Q.prove ( -`!l r. +`!l r. ¬(l > delta * r) ∧ almost_balancedL l r ∧ ¬(l + r ≤ 1) @@ -914,7 +914,7 @@ val balanced_lem3 = Q.prove ( b0 < ratio * b ∧ balanced b b0 ⇒ - balanced b (b0 + r + 1) ∧ + balanced b (b0 + r + 1) ∧ balanced b0 r`, rw [almost_balancedL_def, balanced_def, TIMES_MIN, delta_def, ratio_def] >> fs [MIN_DEF]); @@ -934,7 +934,7 @@ val balanced_lem4 = Q.prove ( fs [MIN_DEF]); val balanced_lem5 = Q.prove ( -`!l r. +`!l r. ¬(r > delta * l) ∧ almost_balancedR l r ⇒ @@ -979,7 +979,7 @@ val singleR_thm = Q.prove ( invariant cmp r ⇒ invariant cmp (singleR k v (Bin n k' v' b b0) r) ∧ - to_fmap cmp (singleR k v (Bin n k' v' b b0) r) = + to_fmap cmp (singleR k v (Bin n k' v' b b0) r) = (FUNION (to_fmap cmp (Bin n k' v' b b0)) (to_fmap cmp r)) |+ (key_set cmp k,v)`, rw [singleR_def] >> imp_res_tac inv_props @@ -1006,12 +1006,12 @@ val doubleR_thm = Q.prove ( invariant cmp r ⇒ invariant cmp (doubleR k v (Bin n k' v' b b0) r) ∧ - to_fmap cmp (doubleR k v (Bin n k' v' b b0) r) = + to_fmap cmp (doubleR k v (Bin n k' v' b b0) r) = (FUNION (to_fmap cmp (Bin n k' v' b b0)) (to_fmap cmp r)) |+ (key_set cmp k,v)`, rw [] >> - `structure_size b0 ≠ 0` - by (fs [delta_def, ratio_def, invariant_def, size_def, - NOT_LESS_EQUAL, NOT_LESS, NOT_GREATER] >> + `structure_size b0 ≠ 0` + by (fs [delta_def, ratio_def, invariant_def, size_def, + NOT_LESS_EQUAL, NOT_LESS, NOT_GREATER] >> imp_res_tac structure_size_thm >> fs []) >> Cases_on `b0` >> @@ -1036,9 +1036,9 @@ val doubleR_thm = Q.prove ( rfs [key_ordered_to_fmap] >- metis_tac [cmp_thms] >- metis_tac [cmp_thms] >> - `key_set cmp k' ≠ key_set cmp k'' ∧ - key_set cmp k ≠ key_set cmp k' ∧ - key_set cmp k ≠ key_set cmp k''` + `key_set cmp k' ≠ key_set cmp k'' ∧ + key_set cmp k ≠ key_set cmp k' ∧ + key_set cmp k ≠ key_set cmp k''` by metis_tac [key_set_eq, cmp_thms] >> metis_tac [FUPDATE_COMMUTES, FUNION_ASSOC])); @@ -1054,7 +1054,7 @@ val rotateR_thm = Q.prove ( invariant cmp r ⇒ invariant cmp (rotateR k v l r) ∧ - to_fmap cmp (rotateR k v l r) = + to_fmap cmp (rotateR k v l r) = (FUNION (to_fmap cmp l) (to_fmap cmp r)) |+ (key_set cmp k,v)`, Cases_on `l` >- fs [size_def] >> @@ -1065,7 +1065,7 @@ val balanceL_balL = Q.prove ( `!k v l r cmp. good_cmp cmp ∧ invariant cmp l ∧ - invariant cmp r + invariant cmp r ⇒ balanceL k v l r = balL k v l r`, ho_match_mp_tac balanceL_ind >> @@ -1095,7 +1095,7 @@ val balanceL_thm = Q.prove ( invariant cmp r ⇒ invariant cmp (balanceL k v l r) ∧ - to_fmap cmp (balanceL k v l r) = + to_fmap cmp (balanceL k v l r) = (FUNION (to_fmap cmp l) (to_fmap cmp r)) |+ (key_set cmp k,v)`, rw [] >> `balanceL k v l r = balL k v l r` by metis_tac [balanceL_balL] >> @@ -1118,7 +1118,7 @@ val singleL_thm = Q.prove ( invariant cmp l ⇒ invariant cmp (singleL k v l (Bin n k' v' b b0)) ∧ - to_fmap cmp (singleL k v l (Bin n k' v' b b0)) = + to_fmap cmp (singleL k v l (Bin n k' v' b b0)) = (FUNION (to_fmap cmp l) (to_fmap cmp (Bin n k' v' b b0))) |+ (key_set cmp k,v)`, rw [singleL_def] >> imp_res_tac inv_props @@ -1146,12 +1146,12 @@ val doubleL_thm = Q.prove ( invariant cmp l ⇒ invariant cmp (doubleL k v l (Bin n k' v' b b0)) ∧ - to_fmap cmp (doubleL k v l (Bin n k' v' b b0)) = + to_fmap cmp (doubleL k v l (Bin n k' v' b b0)) = (FUNION (to_fmap cmp l) (to_fmap cmp (Bin n k' v' b b0))) |+ (key_set cmp k,v)`, rw [] >> - `structure_size b ≠ 0` - by (fs [delta_def, ratio_def, invariant_def, size_def, - NOT_LESS_EQUAL, NOT_LESS, NOT_GREATER] >> + `structure_size b ≠ 0` + by (fs [delta_def, ratio_def, invariant_def, size_def, + NOT_LESS_EQUAL, NOT_LESS, NOT_GREATER] >> imp_res_tac structure_size_thm >> fs []) >> Cases_on `b` >> @@ -1181,9 +1181,9 @@ val doubleL_thm = Q.prove ( >- metis_tac [cmp_thms] >- metis_tac [cmp_thms] >- metis_tac [to_fmap_key_set, key_set_cmp_thm, cmp_thms] - >- (`key_set cmp k' ≠ key_set cmp k'' ∧ - key_set cmp k ≠ key_set cmp k' ∧ - key_set cmp k ≠ key_set cmp k''` + >- (`key_set cmp k' ≠ key_set cmp k'' ∧ + key_set cmp k ≠ key_set cmp k' ∧ + key_set cmp k ≠ key_set cmp k''` by metis_tac [key_set_eq, cmp_thms] >> metis_tac [FUPDATE_COMMUTES, FUNION_ASSOC]))); @@ -1199,7 +1199,7 @@ val rotateL_thm = Q.prove ( invariant cmp r ⇒ invariant cmp (rotateL k v l r) ∧ - to_fmap cmp (rotateL k v l r) = + to_fmap cmp (rotateL k v l r) = (FUNION (to_fmap cmp l) (to_fmap cmp r)) |+ (key_set cmp k,v)`, Cases_on `r` >- fs [size_def] >> @@ -1210,7 +1210,7 @@ val balanceR_balR = Q.prove ( `!k v l r cmp. good_cmp cmp ∧ invariant cmp l ∧ - invariant cmp r + invariant cmp r ⇒ balanceR k v l r = balR k v l r`, ho_match_mp_tac balanceR_ind >> @@ -1241,7 +1241,7 @@ val balanceR_thm = Q.prove ( invariant cmp r ⇒ invariant cmp (balanceR k v l r) ∧ - to_fmap cmp (balanceR k v l r) = + to_fmap cmp (balanceR k v l r) = (FUNION (to_fmap cmp l) (to_fmap cmp r)) |+ (key_set cmp k,v)`, rw [] >> `balanceR k v l r = balR k v l r` by metis_tac [balanceR_balR] >> @@ -1251,8 +1251,8 @@ val balanceR_thm = Q.prove ( metis_tac [rotateL_thm]); val almost_balancedL_thm = Q.prove ( -`!l r. - balanced l r ⇒ +`!l r. + balanced l r ⇒ almost_balancedL l r ∧ almost_balancedL (l + 1) r ∧ almost_balancedL l (r - 1)`, rw [almost_balancedL_def] >> fs [balanced_def, NOT_LESS_EQUAL, TIMES_MIN] >> @@ -1263,8 +1263,8 @@ val almost_balancedL_thm = Q.prove ( fs [delta_def, MIN_DEF]); val almost_balancedR_thm = Q.prove ( -`!l r. - balanced l r ⇒ +`!l r. + balanced l r ⇒ almost_balancedR l r ∧ almost_balancedR l (r + 1) ∧ almost_balancedR (l - 1) r`, rw [almost_balancedR_def] >> fs [balanced_def, NOT_LESS_EQUAL, TIMES_MIN] >> @@ -1285,7 +1285,7 @@ val insert_thm = Q.store_thm ("insert_thm", invariant cmp (insert cmp k v t) ∧ to_fmap cmp (insert cmp k v t) = to_fmap cmp t |+ (key_set cmp k,v)`, Induct_on `t` - >- fs [insert_def, singleton_def, to_fmap_def, invariant_eq, + >- fs [insert_def, singleton_def, to_fmap_def, invariant_eq, structure_size_def, balanced_def, size_def, key_ordered_def] >> simp [invariant_eq] >> rpt gen_tac >> @@ -1335,10 +1335,10 @@ val insertR_thm = Q.store_thm ("insertR_thm", invariant cmp t ⇒ invariant cmp (insertR cmp k v t) ∧ - to_fmap cmp (insertR cmp k v t) = + to_fmap cmp (insertR cmp k v t) = if key_set cmp k ∈ FDOM (to_fmap cmp t) then to_fmap cmp t else to_fmap cmp t |+ (key_set cmp k,v)`, Induct_on `t` - >- fs [insertR_def, singleton_def, to_fmap_def, invariant_def, + >- fs [insertR_def, singleton_def, to_fmap_def, invariant_def, structure_size_def, balanced_def, size_def, key_ordered_def] >> rpt gen_tac >> strip_tac >> @@ -1347,12 +1347,12 @@ val insertR_thm = Q.store_thm ("insertR_thm", Cases_on `cmp k k'` >> fs [] >> simp [to_fmap_def] - >- (`almost_balancedL (size (insertR cmp k v t)) (size t')` + >- (`almost_balancedL (size (insertR cmp k v t)) (size t')` by (imp_res_tac size_thm >> rw [FCARD_FUPDATE] >> fs [key_ordered_to_fmap] >> metis_tac [almost_balancedL_thm]) >> - `key_ordered cmp k' (insertR cmp k v t) Greater` + `key_ordered cmp k' (insertR cmp k v t) Greater` by (rfs [key_ordered_to_fmap] >> rw [] >> rw [key_set_cmp_thm] >> @@ -1364,12 +1364,12 @@ val insertR_thm = Q.store_thm ("insertR_thm", >- (fs [invariant_def] >> rfs [key_ordered_to_fmap] >> metis_tac [to_fmap_key_set, key_set_cmp_thm, cmp_thms,key_set_eq, FUPDATE_EQ]) - >- (`almost_balancedR (size t) (size (insertR cmp k v t'))` + >- (`almost_balancedR (size t) (size (insertR cmp k v t'))` by (imp_res_tac size_thm >> rw [FCARD_FUPDATE] >> fs [key_ordered_to_fmap] >> metis_tac [almost_balancedR_thm]) >> - `key_ordered cmp k' (insertR cmp k v t') Less` + `key_ordered cmp k' (insertR cmp k v t') Less` by (fs [key_ordered_to_fmap] >> rw [] >> imp_res_tac to_fmap_key_set >> @@ -1390,7 +1390,7 @@ val insertMax_thm = Q.store_thm ("insertMax_thm", invariant cmp (insertMax k v t) ∧ to_fmap cmp (insertMax k v t) = to_fmap cmp t |+ (key_set cmp k,v)`, Induct_on `t` - >- fs [insertMax_def, singleton_def, to_fmap_def, invariant_def, + >- fs [insertMax_def, singleton_def, to_fmap_def, invariant_def, structure_size_def, balanced_def, size_def, key_ordered_def] >> rpt gen_tac >> strip_tac >> @@ -1416,18 +1416,18 @@ val insertMin_thm = Q.store_thm ("insertMin_thm", invariant cmp (insertMin k v t) ∧ to_fmap cmp (insertMin k v t) = to_fmap cmp t |+ (key_set cmp k,v)`, Induct_on `t` - >- fs [insertMin_def, singleton_def, to_fmap_def, invariant_def, + >- fs [insertMin_def, singleton_def, to_fmap_def, invariant_def, structure_size_def, balanced_def, size_def, key_ordered_def] >> rpt gen_tac >> strip_tac >> fs [insertMin_def, invariant_def, to_fmap_def] >> simp [] >> - `almost_balancedL (size (insertMin k v t)) (size t')` + `almost_balancedL (size (insertMin k v t)) (size t')` by (imp_res_tac size_thm >> rw [FCARD_FUPDATE] >> fs [key_ordered_to_fmap] >> metis_tac [almost_balancedL_thm]) >> - `key_ordered cmp k' (insertMin k v t) Greater` + `key_ordered cmp k' (insertMin k v t) Greater` by (rfs [key_ordered_to_fmap] >> rw [] >> imp_res_tac to_fmap_key_set >> @@ -1448,7 +1448,7 @@ val deleteFindMin_thm = Q.store_thm ("deleteFindMin", invariant cmp t' ∧ key_ordered cmp k t' Less ∧ FLOOKUP (to_fmap cmp t) (key_set cmp k) = SOME v ∧ - to_fmap cmp t' = + to_fmap cmp t' = DRESTRICT (to_fmap cmp t) (FDOM (to_fmap cmp t) DELETE key_set cmp k)`, ho_match_mp_tac (fetch "-" "deleteFindMin_ind") >> rpt conj_tac >> @@ -1468,7 +1468,7 @@ val deleteFindMin_thm = Q.store_thm ("deleteFindMin", metis_tac [comparison_distinct, good_cmp_def]) >> `?km l. deleteFindMin (Bin (structure_size v8 + (structure_size v9 + 1)) v6 v7 v8 v9) = (km,l)` by metis_tac [pairTheory.pair_CASES] >> - fs [] >> + fs [] >> rpt BasicProvers.VAR_EQ_TAC >> inv_mp_tac balanceR_thm >> simp [] >> @@ -1508,7 +1508,7 @@ val deleteFindMin_thm = Q.store_thm ("deleteFindMin", rfs [key_ordered_to_fmap] >> rw [] >> metis_tac [cmp_thms, key_set_eq, key_set_cmp_thm]) - >- (`key_set cmp k' ∈ FDOM (to_fmap cmp v8 ⊌ to_fmap cmp v9)` + >- (`key_set cmp k' ∈ FDOM (to_fmap cmp v8 ⊌ to_fmap cmp v9)` by (every_case_tac >> fs [FLOOKUP_DEF]) >> `key_set cmp k ≠ key_set cmp k' ∧ cmp k' k = Less` @@ -1530,19 +1530,19 @@ val deleteFindMin_thm = Q.store_thm ("deleteFindMin", >- (imp_res_tac size_thm >> rw [FCARD_FUPDATE, FDOM_DRESTRICT] >> rw [FCARD_DRESTRICT, DELETE_INSERT] >> - `(FDOM (to_fmap cmp v8) ∪ FDOM (to_fmap cmp v9)) ∩ + `(FDOM (to_fmap cmp v8) ∪ FDOM (to_fmap cmp v9)) ∩ (key_set cmp v6 INSERT FDOM (to_fmap cmp v8) ∪ FDOM (to_fmap cmp v9) DELETE key_set cmp k') = FDOM (to_fmap cmp v8) ∪ FDOM (to_fmap cmp v9) DELETE key_set cmp k'` - by (rw [EXTENSION] >> + by (rw [EXTENSION] >> metis_tac [key_set_eq, EXTENSION]) >> simp [CARD_UNION_EQN] >> fs [DISJOINT_DEF] >| - [`CARD (FDOM (to_fmap cmp v8)) ≠ 0` + [`CARD (FDOM (to_fmap cmp v8)) ≠ 0` by (rw [CARD_EQ_0, EXTENSION] >> metis_tac []) >> `0 < CARD (FDOM (to_fmap cmp v8))` by decide_tac, - `CARD (FDOM (to_fmap cmp v9)) ≠ 0` + `CARD (FDOM (to_fmap cmp v9)) ≠ 0` by (rw [CARD_EQ_0, EXTENSION] >> metis_tac []) >> `0 < CARD (FDOM (to_fmap cmp v9))` by decide_tac] >> @@ -1575,7 +1575,7 @@ val deleteFindMax_thm = Q.store_thm ("deleteFindMax", invariant cmp t' ∧ key_ordered cmp k t' Greater ∧ FLOOKUP (to_fmap cmp t) (key_set cmp k) = SOME v ∧ - to_fmap cmp t' = + to_fmap cmp t' = DRESTRICT (to_fmap cmp t) (FDOM (to_fmap cmp t) DELETE key_set cmp k)`, ho_match_mp_tac (fetch "-" "deleteFindMax_ind") >> rpt conj_tac >> @@ -1595,7 +1595,7 @@ val deleteFindMax_thm = Q.store_thm ("deleteFindMax", metis_tac [comparison_distinct, good_cmp_def]) >> `?km l. deleteFindMax (Bin (structure_size v8 + (structure_size v9 + 1)) v6 v7 v8 v9) = (km,l)` by metis_tac [pairTheory.pair_CASES] >> - fs [] >> + fs [] >> rpt BasicProvers.VAR_EQ_TAC >> inv_mp_tac balanceL_thm >> simp [] >> @@ -1635,7 +1635,7 @@ val deleteFindMax_thm = Q.store_thm ("deleteFindMax", rfs [key_ordered_to_fmap] >> rw [] >> metis_tac [cmp_thms, key_set_eq, key_set_cmp_thm]) - >- (`key_set cmp k' ∈ FDOM (to_fmap cmp v8 ⊌ to_fmap cmp v9)` + >- (`key_set cmp k' ∈ FDOM (to_fmap cmp v8 ⊌ to_fmap cmp v9)` by (every_case_tac >> fs [FLOOKUP_DEF]) >> `key_set cmp k' ≠ key_set cmp k ∧ cmp k' k = Greater` @@ -1656,19 +1656,19 @@ val deleteFindMax_thm = Q.store_thm ("deleteFindMax", >- (imp_res_tac size_thm >> rw [FCARD_FUPDATE, FDOM_DRESTRICT] >> rw [FCARD_DRESTRICT, DELETE_INSERT] >> - `(FDOM (to_fmap cmp v8) ∪ FDOM (to_fmap cmp v9)) ∩ + `(FDOM (to_fmap cmp v8) ∪ FDOM (to_fmap cmp v9)) ∩ (key_set cmp v6 INSERT FDOM (to_fmap cmp v8) ∪ FDOM (to_fmap cmp v9) DELETE key_set cmp k') = FDOM (to_fmap cmp v8) ∪ FDOM (to_fmap cmp v9) DELETE key_set cmp k'` - by (rw [EXTENSION] >> + by (rw [EXTENSION] >> metis_tac [key_set_eq, EXTENSION]) >> simp [CARD_UNION_EQN] >> fs [DISJOINT_DEF] >| - [`CARD (FDOM (to_fmap cmp v8)) ≠ 0` + [`CARD (FDOM (to_fmap cmp v8)) ≠ 0` by (rw [CARD_EQ_0, EXTENSION] >> metis_tac []) >> `0 < CARD (FDOM (to_fmap cmp v8))` by decide_tac, - `CARD (FDOM (to_fmap cmp v9)) ≠ 0` + `CARD (FDOM (to_fmap cmp v9)) ≠ 0` by (rw [CARD_EQ_0, EXTENSION] >> metis_tac []) >> `0 < CARD (FDOM (to_fmap cmp v9))` by decide_tac] >> @@ -1800,7 +1800,7 @@ val delete_thm = Q.store_thm ("delete_thm", invariant cmp t ⇒ invariant cmp (delete cmp k t) ∧ - to_fmap cmp (delete cmp k t) = + to_fmap cmp (delete cmp k t) = DRESTRICT (to_fmap cmp t) (FDOM (to_fmap cmp t) DELETE key_set cmp k)`, Induct_on `t` >- rw [delete_def, to_fmap_def] >> @@ -1812,7 +1812,7 @@ val delete_thm = Q.store_thm ("delete_thm", simp [] >- (inv_mp_tac balanceR_thm >> simp [] >> - rw [] + rw [] >- (fs [key_ordered_to_fmap] >> rfs [key_ordered_to_fmap] >> rw [FDOM_DRESTRICT] >> @@ -1829,7 +1829,7 @@ val delete_thm = Q.store_thm ("delete_thm", >- to_fmap_tac) >- (inv_mp_tac balanceL_thm >> simp [] >> - rw [] + rw [] >- (fs [key_ordered_to_fmap] >> rfs [key_ordered_to_fmap] >> rw [FDOM_DRESTRICT] >> @@ -1838,7 +1838,7 @@ val delete_thm = Q.store_thm ("delete_thm", rw [FCARD_DRESTRICT, DELETE_INTER2] >> imp_res_tac almost_balancedL_thm >> metis_tac [FCARD_DEF]) - >- to_fmap_tac)); + >- to_fmap_tac)); val restrict_set_def = Define ` restrict_set cmp lo hi = @@ -1859,7 +1859,7 @@ val restrict_domain_update = Q.prove ( `good_cmp cmp ⇒ restrict_domain cmp lo hi (m1 |+ (key_set cmp k,v)) = - if k ∈ restrict_set cmp lo hi then + if k ∈ restrict_set cmp lo hi then restrict_domain cmp lo hi m1 |+ (key_set cmp k,v) else restrict_domain cmp lo hi m1`, @@ -1883,10 +1883,10 @@ val trim_thm = Q.prove ( invariant cmp (trim cmp lk hk t) ∧ bounded_root cmp lk hk (trim cmp lk hk t) ∧ to_fmap cmp (trim cmp lk hk t) SUBMAP to_fmap cmp t ∧ - restrict_domain cmp lk hk (to_fmap cmp (trim cmp lk hk t)) = + restrict_domain cmp lk hk (to_fmap cmp (trim cmp lk hk t)) = restrict_domain cmp lk hk (to_fmap cmp t)`, - Cases_on `lk` >> - Cases_on `hk` >> + Cases_on `lk` >> + Cases_on `hk` >> simp [bounded_root_def, trim_def, restrict_set_def, option_cmp_def, option_cmp2_def] >> Induct_on `t` >> simp [trim_help_lesser_def, trim_help_greater_def, trim_help_middle_def, key_ordered_def] >> @@ -1898,7 +1898,7 @@ val trim_thm = Q.prove ( simp [to_fmap_def] >> fs [SUBMAP_DEF, restrict_domain_def, DRESTRICTED_FUNION, DRESTRICT_FUPDATE] >> rw [invariant_def] >> - rw [FAPPLY_FUPDATE_THM, FUNION_DEF, fmap_eq_flookup, FLOOKUP_DRESTRICT, + rw [FAPPLY_FUPDATE_THM, FUNION_DEF, fmap_eq_flookup, FLOOKUP_DRESTRICT, FLOOKUP_FUNION, FLOOKUP_UPDATE] >> rw [] >> every_case_tac >> @@ -1954,7 +1954,7 @@ val link_thm = Q.prove ( key_ordered cmp k r Less ⇒ invariant cmp (link k v l r) ∧ - to_fmap cmp (link k v l r) = + to_fmap cmp (link k v l r) = (FUNION (to_fmap cmp l) (to_fmap cmp r)) |+ (key_set cmp k,v)`, ho_match_mp_tac (fetch "-" "link_ind") >> rpt conj_tac >> @@ -1995,7 +1995,7 @@ val link_thm = Q.prove ( simp [FCARD_DEF] >> `DISJOINT (FDOM (to_fmap cmp ly) ∪ FDOM (to_fmap cmp l)) (FDOM (to_fmap cmp r))` by (rw [DISJOINT_UNION] >> - rw [DISJOINT_DEF, EXTENSION] >> + rw [DISJOINT_DEF, EXTENSION] >> metis_tac [cmp_thms, key_set_cmp_thm, to_fmap_key_set]) >> rw [CARD_DISJOINT_UNION] >> imp_res_tac structure_size_to_fmap >> @@ -2027,11 +2027,11 @@ val link_thm = Q.prove ( simp [FCARD_DEF] >> `DISJOINT (FDOM (to_fmap cmp l) ∪ FDOM (to_fmap cmp r)) (FDOM (to_fmap cmp rz))` by (rw [DISJOINT_UNION] >> - rw [DISJOINT_DEF, EXTENSION] >> + rw [DISJOINT_DEF, EXTENSION] >> metis_tac [cmp_thms, key_set_cmp_thm, to_fmap_key_set]) >> `DISJOINT (FDOM (to_fmap cmp l)) (FDOM (to_fmap cmp r))` by (rw [DISJOINT_UNION] >> - rw [DISJOINT_DEF, EXTENSION] >> + rw [DISJOINT_DEF, EXTENSION] >> metis_tac [cmp_thms, key_set_cmp_thm, to_fmap_key_set]) >> rw [CARD_DISJOINT_UNION] >> imp_res_tac structure_size_to_fmap >> @@ -2085,7 +2085,7 @@ val filterLt_thm = Q.prove ( simp [to_fmap_def, filterLt_def, restrict_domain_union, restrict_domain_update] >> simp [restrict_domain_def, restrict_set_def, option_cmp2_def, option_cmp_def] >> rw [] >> - imp_res_tac filter_lt_help_thm + imp_res_tac filter_lt_help_thm >- (rw [fmap_eq_flookup, FLOOKUP_DRESTRICT] >> rw [] >> fs [FLOOKUP_DEF] >> @@ -2133,7 +2133,7 @@ val filterGt_thm = Q.prove ( simp [to_fmap_def, filterGt_def, restrict_domain_union, restrict_domain_update] >> simp [restrict_domain_def, restrict_set_def, option_cmp2_def, option_cmp_def] >> rw [] >> - imp_res_tac filter_gt_help_thm + imp_res_tac filter_gt_help_thm >- (rw [fmap_eq_flookup, FLOOKUP_DRESTRICT] >> rw [] >> fs [FLOOKUP_DEF] >> @@ -2148,7 +2148,7 @@ val restrict_domain_partition = Q.prove ( restrict_domain cmp (SOME x) h t1 SUBMAP t2 ∧ key_set cmp x ∉ FDOM t1 ∧ key_set cmp x ∉ FDOM t2 - ⇒ + ⇒ FUNION (restrict_domain cmp l h t1) (restrict_domain cmp l h t2) = FUNION (restrict_domain cmp l (SOME x) t1) (restrict_domain cmp (SOME x) h t2)`, rw [restrict_domain_def, fmap_eq_flookup] >> @@ -2164,7 +2164,7 @@ val restrict_domain_partition = Q.prove ( val restrict_domain_union_swap = Q.prove ( ` good_cmp cmp - ⇒ + ⇒ a ⊌ restrict_domain cmp blo (SOME kx) (to_fmap cmp r2) ⊌ restrict_domain cmp (SOME kx) bhi (to_fmap cmp t1') @@ -2186,7 +2186,7 @@ val restrict_domain_extend = Q.prove ( ` good_cmp cmp ∧ invariant cmp (Bin s kx x t1 t1') ∧ kx ∈ restrict_set cmp blo bhi - ⇒ + ⇒ restrict_domain cmp blo (SOME kx) (to_fmap cmp t1) = restrict_domain cmp blo bhi (to_fmap cmp t1) ∧ restrict_domain cmp (SOME kx) bhi (to_fmap cmp t1') = @@ -2257,7 +2257,7 @@ val bounded_restrict_id = Q.prove ( `!t. good_cmp cmp ∧ bounded_all cmp blo bhi t - ⇒ + ⇒ restrict_domain cmp blo bhi (to_fmap cmp t) = to_fmap cmp t`, Induct_on `t` >> rw [bounded_all_def, to_fmap_def, restrict_domain_union, restrict_domain_update] >> @@ -2266,7 +2266,7 @@ val bounded_restrict_id = Q.prove ( fs [restrict_domain_def, restrict_set_def, option_cmp_def, option_cmp2_def]); val restrict_domain_empty = Q.prove ( -`good_cmp cmp ⇒ +`good_cmp cmp ⇒ restrict_domain cmp blo (SOME kx) (restrict_domain cmp (SOME kx) bhi t) = FEMPTY ∧ restrict_domain cmp (SOME kx) bhi (restrict_domain cmp blo (SOME kx) t) = FEMPTY`, Cases_on `blo` >> @@ -2283,14 +2283,14 @@ val hedgeUnion_thm = Q.prove ( bounded_root cmp blo bhi t2 ⇒ invariant cmp (hedgeUnion cmp blo bhi t1 t2) ∧ - to_fmap cmp (hedgeUnion cmp blo bhi t1 t2) = + to_fmap cmp (hedgeUnion cmp blo bhi t1 t2) = restrict_domain cmp blo bhi (to_fmap cmp t1 ⊌ to_fmap cmp t2)`, ho_match_mp_tac (fetch "-" "hedgeUnion_ind") >> rpt conj_tac >> simp [hedgeUnion_def] >> rpt conj_tac >> rpt gen_tac >> - strip_tac + strip_tac >- rw [to_fmap_def, FUNION_FEMPTY_2, bounded_restrict_id] >- (inv_mp_tac link_thm >> simp [GSYM CONJ_ASSOC] >> @@ -2367,7 +2367,7 @@ val hedgeUnion_thm = Q.prove ( fs [restrict_domain_def, restrict_set_def, option_cmp_def, option_cmp2_def] >> metis_tac [good_cmp_def, comparison_distinct, key_set_cmp_thm]) >> rw [restrict_domain_union, restrict_domain_update] >> - `key_set cmp kx ∉ FDOM (to_fmap cmp m1) ∧ key_set cmp kx ∉ FDOM (to_fmap cmp m2)` + `key_set cmp kx ∉ FDOM (to_fmap cmp m1) ∧ key_set cmp kx ∉ FDOM (to_fmap cmp m2)` by metis_tac [key_ordered_to_fmap, cmp_thms, to_fmap_key_set, key_set_cmp_thm] >> `restrict_domain cmp blo (SOME kx) (to_fmap cmp m2) SUBMAP (to_fmap cmp m1) ∧ restrict_domain cmp (SOME kx) bhi (to_fmap cmp m1) SUBMAP (to_fmap cmp m2)` @@ -2439,7 +2439,7 @@ val toAscList_helper = Q.prove ( (!k1 v1 k2 v2. MEM (k1,v1) l ∧ FLOOKUP (to_fmap cmp t) (key_set cmp k2) = SOME v2 ⇒ cmp k2 k1 = Less) ⇒ SORTED (\(x,y) (x',y'). cmp x x' = Less) (foldrWithKey (λk x xs. (k,x)::xs) l t) ∧ - lift_key cmp (set (foldrWithKey (λk x xs. (k,x)::xs) l t)) = + lift_key cmp (set (foldrWithKey (λk x xs. (k,x)::xs) l t)) = set (fmap_to_alist (to_fmap cmp t)) ∪ lift_key cmp (set l)`, Induct_on `t` >> simp [foldrWithKey_def, to_fmap_def] >> @@ -2529,13 +2529,13 @@ val compare_good_cmp = Q.store_thm ("compare_good_cmp", metis_tac []); val compare_thm1 = Q.prove ( -`!cmp1 cmp2 t1 t2. - good_cmp cmp1 ∧ - good_cmp cmp2 ∧ +`!cmp1 cmp2 t1 t2. + good_cmp cmp1 ∧ + good_cmp cmp2 ∧ invariant cmp1 t1 ∧ invariant cmp1 t2 ∧ - compare cmp1 cmp2 t1 t2 = Equal - ⇒ + compare cmp1 cmp2 t1 t2 = Equal + ⇒ fmap_rel (\x y. cmp2 x y = Equal) (to_fmap cmp1 t1) (to_fmap cmp1 t2)`, rw [compare_def, fmap_rel_OPTREL_FLOOKUP, OPTREL_def] >> imp_res_tac toAscList_thm >> @@ -2661,7 +2661,7 @@ val compare_lem2 = Q.prove ( SORTED (λ(x,y) (x',y'). cmp1 x x' = Less) l1 ∧ n ≤ LENGTH l1 ∧ n ≤ LENGTH l2 ∧ - LIST_REL (λ(p1,p2) (p1',p2'). pair_cmp cmp1 cmp2 (p1,p2) (p1',p2') = Equal) + LIST_REL (λ(p1,p2) (p1',p2'). pair_cmp cmp1 cmp2 (p1,p2) (p1',p2') = Equal) (TAKE n l1) (TAKE n l2) ∧ n ≠ LENGTH l1 ⇒ @@ -2679,7 +2679,7 @@ val compare_lem2 = Q.prove ( fs [] >> rfs [key_set_eq] >- metis_tac [PAIR, cmp_thms] >> - `p_1' = kn1 ∧ x = vn1` + `p_1' = kn1 ∧ x = vn1` by (match_mp_tac strict_sorted_unique >> rw [] >> metis_tac [cmp_thms]) >> @@ -2717,7 +2717,7 @@ val compare_lem2 = Q.prove ( `n < LENGTH l1` by decide_tac >- metis_tac [PAIR, cmp_thms] >> rw [] >> - `p_1'' = kn3 ∧ y = vn3` + `p_1'' = kn3 ∧ y = vn3` by (match_mp_tac strict_sorted_unique >> rw [] >> metis_tac [rich_listTheory.EL_MEM, cmp_thms]) >> @@ -2767,9 +2767,9 @@ val compare_lem2 = Q.prove ( metis_tac [cmp_thms]))); val compare_thm2 = Q.prove ( -`!cmp1 cmp2 t1 t2. - good_cmp cmp1 ∧ - good_cmp cmp2 ∧ +`!cmp1 cmp2 t1 t2. + good_cmp cmp1 ∧ + good_cmp cmp2 ∧ invariant cmp1 t1 ∧ invariant cmp1 t2 ∧ fmap_rel (\x y. cmp2 x y = Equal) (to_fmap cmp1 t1) (to_fmap cmp1 t2) @@ -2820,9 +2820,9 @@ val compare_thm2 = Q.prove ( metis_tac [good_cmp_def, pair_cmp_good])); val compare_thm = Q.store_thm ("compare_thm", -`!cmp1 cmp2 t1 t2. - good_cmp cmp1 ∧ - good_cmp cmp2 ∧ +`!cmp1 cmp2 t1 t2. + good_cmp cmp1 ∧ + good_cmp cmp2 ∧ invariant cmp1 t1 ∧ invariant cmp1 t2 ⇒ @@ -2872,7 +2872,7 @@ val splitLookup_thm = Q.store_thm ("splitLookup_thm", FLOOKUP (to_fmap cmp t) (key_set cmp k) = v ∧ key_ordered cmp k lt Greater ∧ key_ordered cmp k gt Less ∧ - to_fmap cmp t = + to_fmap cmp t = case v of | NONE => FUNION (to_fmap cmp lt) (to_fmap cmp gt) | SOME v => (FUNION (to_fmap cmp lt) (to_fmap cmp gt)) |+ (key_set cmp k, v)`, @@ -3164,9 +3164,9 @@ val alookup_unit_lem = Q.prove ( `!cmp1 cmp2 f k l x. good_cmp cmp1 ∧ good_cmp cmp2 ∧ - resp_equiv2 cmp1 cmp2 f + resp_equiv2 cmp1 cmp2 f ⇒ - (ALOOKUP (MAP (\(k,v). (key_set cmp1 k, ())) l) (key_set cmp1 x') = + (ALOOKUP (MAP (\(k,v). (key_set cmp1 k, ())) l) (key_set cmp1 x') = ALOOKUP (MAP (\(k,v). (key_set cmp2 (f k), ())) l) (key_set cmp2 (f x')))`, Induct_on `l` >> @@ -3245,16 +3245,16 @@ val bigunion_key_sets = Q.prove ( fs [key_set_def] >> eq_tac >> rw [] >> - rfs [resp_equiv2_def] + rfs [resp_equiv2_def] >- metis_tac [cmp_thms] >> qexists_tac `key_set cmp2 (f x)` >> rw [key_set_def] >> metis_tac [cmp_thms]); val image_lem = Q.prove ( -`good_cmp cmp1 +`good_cmp cmp1 ⇒ - IMAGE (λx. key_set cmp2 (f x)) (key_set cmp1 k'') = + IMAGE (λx. key_set cmp2 (f x)) (key_set cmp1 k'') = { key_set cmp2 (f x) | x | cmp1 x k'' = Equal }`, rw [EXTENSION,key_set_def] >> metis_tac [cmp_thms]); @@ -3306,7 +3306,7 @@ val map_keys_thm = Q.store_thm ("map_keys_thm", rw [key_set_def] fs [key_set_def] - CCONTR_TAC + CCONTR_TAC Cases_on `cmp1 k' k'' = Equal` >> fs [] `cmp2 (f k') (f k'') ≠ Equal` by metis_tac [cmp_thms] @@ -3318,7 +3318,7 @@ metis_tac [cmp_thms] Cases_on `?x. k = key_set cmp2 x` >> fs [] >- (Cases_on `?x'. x = f x'` >> - fs [] + fs [] >- (first_x_assum (qspecl_then [`key_set cmp1 x'`] mp_tac) >> rw [] @@ -3356,7 +3356,7 @@ val key_set_map = Q.prove ( val flookup_lem = Q.prove ( `!cmp1 cmp2 m k v f. - (FLOOKUP m k = + (FLOOKUP m k = FLOOKUP (MAP_KEYS (BIGUNION o IMAGE (λx. key_set cmp2 (f x))) m) (BIGUNION o IMAGE (λx. key_set cmp2 (f k))))`, rw [FLOOKUP_DEF, MAP_KEYS_def] >> @@ -3411,7 +3411,7 @@ val map_keys_thm = Q.store_thm ("map_keys_thm", val every_def = Define ` (every f Tip = T) ∧ -(every f (Bin _ kx x l r) = +(every f (Bin _ kx x l r) = if f kx x then if every f l then if every f r then T else F @@ -3419,11 +3419,11 @@ val every_def = Define ` else F)`; val every_thm = Q.store_thm ("every_thm", -`!f t cmp. +`!f t cmp. good_cmp cmp ∧ invariant cmp t ∧ resp_equiv cmp f - ⇒ + ⇒ (every f t ⇔ (!k v. lookup cmp k t = SOME v ⇒ f k v))`, Induct_on `t` >> rw [every_def, lookup_def] >> @@ -3460,7 +3460,7 @@ val every_thm = Q.store_thm ("every_thm", val exists_def = Define ` (exists f Tip = F) ∧ -(exists f (Bin _ kx x l r) = +(exists f (Bin _ kx x l r) = if f kx x then T else if exists f l then @@ -3471,11 +3471,11 @@ val exists_def = Define ` F)`; val exists_thm = Q.store_thm ("exists_thm", -`!f t cmp. +`!f t cmp. good_cmp cmp ∧ invariant cmp t ∧ resp_equiv cmp f - ⇒ + ⇒ (exists f t ⇔ (?k v. lookup cmp k t = SOME v ∧ f k v))`, Induct_on `t` >> rw [exists_def, lookup_def] >> diff --git a/examples/balanced_bst/comparisonScript.sml b/examples/balanced_bst/comparisonScript.sml index 1aecac91ef..9b6dcd9fc4 100644 --- a/examples/balanced_bst/comparisonScript.sml +++ b/examples/balanced_bst/comparisonScript.sml @@ -25,7 +25,7 @@ good_cmp cmp ⇔ (!x y z. cmp x y = Less ∧ cmp y z = Less ⇒ cmp x z = Less)`; val good_cmp_thm = Q.store_thm ("good_cmp_thm", -`!cmp. +`!cmp. good_cmp cmp ⇔ (!x. cmp x x = Equal) ∧ (!x y z. @@ -266,10 +266,10 @@ val string_cmp_antisym = Q.store_thm ("string_cmp_antisym[simp]", metis_tac [string_cmp_def, char_cmp_antisym, list_cmp_antisym]); val pair_cmp_antisym = Q.store_thm ("pair_cmp_antisym", -`!cmp1 cmp2 x y. +`!cmp1 cmp2 x y. (!x y. cmp1 x y = Equal ⇔ x = y) ∧ - (!x y. cmp2 x y = Equal ⇔ x = y) - ⇒ + (!x y. cmp2 x y = Equal ⇔ x = y) + ⇒ (pair_cmp cmp1 cmp2 x y = Equal ⇔ x = y)`, Cases_on `x` >> Cases_on `y` >> @@ -279,9 +279,9 @@ val pair_cmp_antisym = Q.store_thm ("pair_cmp_antisym", metis_tac [comparison_distinct]); val option_cmp_antisym = Q.store_thm ("option_cmp_antisym", -`!cmp x y. - (!x y. cmp x y = Equal ⇔ x = y) - ⇒ +`!cmp x y. + (!x y. cmp x y = Equal ⇔ x = y) + ⇒ (option_cmp cmp x y = Equal ⇔ x = y)`, Cases_on `x` >> Cases_on `y` >> @@ -291,9 +291,9 @@ val option_cmp_antisym = Q.store_thm ("option_cmp_antisym", metis_tac [comparison_distinct]); val option_cmp2_antisym = Q.store_thm ("option_cmp2_antisym", -`!cmp x y. - (!x y. cmp x y = Equal ⇔ x = y) - ⇒ +`!cmp x y. + (!x y. cmp x y = Equal ⇔ x = y) + ⇒ (option_cmp2 cmp x y = Equal ⇔ x = y)`, Cases_on `x` >> Cases_on `y` >> @@ -312,9 +312,9 @@ val equiv_inj_def = Define ` equiv_inj cmp cmp2 f ⇔ (!k1 k2. cmp2 (f k1) (f k2) = Equal ⇒ cmp k1 k2 = Equal)`; val antisym_resp_equiv = Q.store_thm ("antisym_resp_equiv", -`!cmp f. - (!x y. cmp x y = Equal ⇒ x = y) - ⇒ +`!cmp f. + (!x y. cmp x y = Equal ⇒ x = y) + ⇒ resp_equiv cmp f ∧ !cmp2. good_cmp cmp2 ⇒ resp_equiv2 cmp cmp2 f`, rw [resp_equiv_def, resp_equiv2_def] >> metis_tac [cmp_thms]); diff --git a/examples/balanced_bst/osetScript.sml b/examples/balanced_bst/osetScript.sml index ff3b83c32f..4d2a698b7d 100644 --- a/examples/balanced_bst/osetScript.sml +++ b/examples/balanced_bst/osetScript.sml @@ -90,7 +90,7 @@ val good_oset_oimage = Q.store_thm ("good_oset_oimage", val good_cmp_ocompare = Q.store_thm ("good_cmp_ocompare", `!cmp f s. good_cmp cmp ⇒ good_cmp (ocompare cmp)`, rw [] >> - `good_cmp (\(x:unit) (y:unit). Equal)` + `good_cmp (\(x:unit) (y:unit). Equal)` by (rw [good_cmp_def, LAMBDA_PROD, FORALL_PROD] >> metis_tac [good_cmp_def]) >> imp_res_tac compare_good_cmp >> @@ -113,7 +113,7 @@ val good_oset_oset = Q.store_thm ("good_oset_oset", val oin_oempty = Q.store_thm ("oin_oinsert[simp]", `!cmp x. oin cmp x oempty = F`, - rw [oin_def, oempty_def, empty_def, member_def]); + rw [oin_def, oempty_def, empty_def, member_def]); val oimage_oempty = Q.store_thm ("oimage_oempty[simp]", `!cmp f. oimage cmp f oempty = oempty`, @@ -136,7 +136,7 @@ val ounion_oempty = Q.store_thm ("ounion_oempty[simp]", val oempty_subset = Q.store_thm ("oempty_subset[simp]", `!cmp s. (osubset cmp oempty s ⇔ T) ∧ (osubset cmp s oempty ⇔ s = oempty)`, - rw [osubset_def, oempty_def, isSubmapOf_def, isSubmapOfBy_def, empty_def, + rw [osubset_def, oempty_def, isSubmapOf_def, isSubmapOfBy_def, empty_def, submap'_def, size_def] >> Cases_on `s` >> rw [submap'_def, size_def]); @@ -232,12 +232,12 @@ val osubset_thm = Q.store_thm ("osubset_thm", rw []); val oextension = Q.store_thm ("oextension", -`!cmp s1 s2. +`!cmp s1 s2. good_oset cmp s1 ∧ good_oset cmp s2 - ⇒ + ⇒ (ocompare cmp s1 s2 = Equal ⇔ (!x. oin cmp x s1 ⇔ oin cmp x s2))`, rw [good_oset_def, ocompare_def] >> - `good_cmp (\(x:unit) (y:unit). Equal)` + `good_cmp (\(x:unit) (y:unit). Equal)` by (rw [good_cmp_def, LAMBDA_PROD, FORALL_PROD] >> metis_tac [good_cmp_def]) >> rw [compare_thm] >> @@ -252,31 +252,31 @@ val oextension = Q.store_thm ("oextension", metis_tac []); val oevery_oin = Q.store_thm ("oevery_oin", -`!cmp f s. +`!cmp f s. good_oset cmp s ∧ oresp_equiv cmp f - ⇒ + ⇒ (oevery f s ⇔ (!x. oin cmp x s ⇒ f x))`, rw [good_oset_def, oevery_def, oin_def, oresp_equiv_def] >> imp_res_tac every_thm >> rw [lookup_thm, flookup_thm, member_thm]); val oexists_oin = Q.store_thm ("oexists_oin", -`!cmp f s. +`!cmp f s. good_oset cmp s ∧ oresp_equiv cmp f - ⇒ + ⇒ (oexists f s ⇔ (?x. oin cmp x s ∧ f x))`, rw [oresp_equiv_def, good_oset_def, oexists_def, oin_def] >> imp_res_tac exists_thm >> rw [lookup_thm, flookup_thm, member_thm]); val oin_oset_help = Q.prove ( -`!cmp l x s. +`!cmp l x s. good_oset cmp s ⇒ - (oin cmp x (FOLDR (λx t. oinsert cmp x t) s l) - ⇔ + (oin cmp x (FOLDR (λx t. oinsert cmp x t) s l) + ⇔ oin cmp x s ∨ ?y. MEM y l ∧ cmp x y = Equal)`, Induct_on `l` >> rw [] >> From 6a90350b28977aa1258fce6f81efe3091c96b05a Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Mon, 22 Dec 2014 05:00:24 +0000 Subject: [PATCH 067/718] do not export constant t0 from wotTheory I get the impression that none of the definitions in wotTheory were supposed to be exported, so perhaps they all should be deleted at the end. I am not sure, though, so I just remove t0, whose name is particularly annoying outside this theory to be taken by a constant. --- src/enumfset/wotScript.sml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/enumfset/wotScript.sml b/src/enumfset/wotScript.sml index 0b945eb63c..d4bb6d41d5 100644 --- a/src/enumfset/wotScript.sml +++ b/src/enumfset/wotScript.sml @@ -541,6 +541,8 @@ val StrongWellOrderExists = store_thm ("StrongWellOrderExists", Q.EXISTS_TAC `$mex_less` THEN REWRITE_TAC [WellOrd_mex_less, GSYM StrongWellOrder]); +val _ = delete_const"t0"; + val _ = export_theory (); end; From 0f24f23428ee8e13bd6dfa1be75f87f423e51f5c Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Mon, 22 Dec 2014 06:29:26 +0000 Subject: [PATCH 068/718] Move comparisonTheory to src/enumfset (from examples/balanced_bst) Prove a theorem relating most of the definitions in comparisonTheory to something in totoTheory. Also, add a new definition for inverting cpns. Make the overloads on the constructors of cpn permanent in comparisonTheory. Turn on totoTheory's "BigSig" to get more useful exports. This is work towards integration, but the approach has been towards plurality, i.e. keeping multiple definitions around and proving relationships between them. More integration could be possible. Also, the dependency between toto and comparison could be flipped (I wanted to write new proofs in the nicer environment of comparison so did not do that.) It has become apparent that totoTheory is in various minor ways not self-consistent (esp. with regard to its naming schemes). --- examples/balanced_bst/balanced_mapScript.sml | 7 -- examples/balanced_bst/osetScript.sml | 2 - .../enumfset}/comparisonScript.sml | 98 +++++++++++++++---- src/enumfset/totoScript.sml | 2 +- 4 files changed, 81 insertions(+), 28 deletions(-) rename {examples/balanced_bst => src/enumfset}/comparisonScript.sml (77%) diff --git a/examples/balanced_bst/balanced_mapScript.sml b/examples/balanced_bst/balanced_mapScript.sml index 568c562e1a..e630909af7 100644 --- a/examples/balanced_bst/balanced_mapScript.sml +++ b/examples/balanced_bst/balanced_mapScript.sml @@ -11,13 +11,6 @@ val _ = new_theory "balanced_map"; val _ = temp_tight_equality (); val _ = numLib.prefer_num(); -val _ = Parse.temp_overload_on("Less",``LESS``) -val _ = Parse.temp_overload_on("Equal",``EQUAL``) -val _ = Parse.temp_overload_on("Greater",``GREATER``) -val comparison_distinct = totoTheory.cpn_distinct -val comparison_case_def = totoTheory.cpn_case_def -val comparison_nchotomy = totoTheory.cpn_nchotomy - val list_rel_lem1 = Q.prove ( `!f l l'. ~LIST_REL f l l' diff --git a/examples/balanced_bst/osetScript.sml b/examples/balanced_bst/osetScript.sml index 4d2a698b7d..a1ee1ac9cf 100644 --- a/examples/balanced_bst/osetScript.sml +++ b/examples/balanced_bst/osetScript.sml @@ -8,8 +8,6 @@ val _ = new_theory "oset"; val _ = temp_tight_equality (); -val _ = Parse.temp_overload_on("Equal",``EQUAL``) - (* oset for ordered set *) val _ = type_abbrev ("oset", ``:('a,unit) balanced_map``); diff --git a/examples/balanced_bst/comparisonScript.sml b/src/enumfset/comparisonScript.sml similarity index 77% rename from examples/balanced_bst/comparisonScript.sml rename to src/enumfset/comparisonScript.sml index 9b6dcd9fc4..ddce77dc66 100644 --- a/examples/balanced_bst/comparisonScript.sml +++ b/src/enumfset/comparisonScript.sml @@ -7,12 +7,12 @@ val _ = new_theory "comparison"; val _ = temp_tight_equality (); val every_case_tac = BasicProvers.EVERY_CASE_TAC; -val comparison_distinct = cpn_distinct -val comparison_case_def = cpn_case_def -val comparison_nchotomy = cpn_nchotomy -val _ = Parse.temp_overload_on("Less",``LESS``) -val _ = Parse.temp_overload_on("Equal",``EQUAL``) -val _ = Parse.temp_overload_on("Greater",``GREATER``) +val comparison_distinct = save_thm("comparison_distinct",cpn_distinct) +val comparison_case_def = save_thm("comparison_case_def",cpn_case_def) +val comparison_nchotomy = save_thm("comparison_nchotomy",cpn_nchotomy) +val _ = Parse.overload_on("Less",``LESS``) +val _ = Parse.overload_on("Equal",``EQUAL``) +val _ = Parse.overload_on("Greater",``GREATER``) val good_cmp_def = Define ` good_cmp cmp ⇔ @@ -35,10 +35,6 @@ val good_cmp_thm = Q.store_thm ("good_cmp_thm", rw [good_cmp_def] >> metis_tac [comparison_distinct, comparison_nchotomy]); -val TotOrd_imp_good_cmp = store_thm("TotOrder_imp_good_cmp", - ``∀cmp. TotOrd cmp ⇒ good_cmp cmp``, - rw[TotOrd,good_cmp_thm] >> metis_tac[]) - val cmp_thms = save_thm ("cmp_thms", LIST_CONJ [comparison_distinct, comparison_case_def, comparison_nchotomy, good_cmp_def]) val option_cmp_def = Define ` @@ -47,13 +43,13 @@ val option_cmp_def = Define ` (option_cmp cmp (SOME x) NONE = Greater) ∧ (option_cmp cmp (SOME x) (SOME y) = cmp x y)`; -val option_cmp2_def = Define ` -(option_cmp2 cmp NONE NONE = Equal) ∧ -(option_cmp2 cmp NONE (SOME x) = Greater) ∧ -(option_cmp2 cmp (SOME x) NONE = Less) ∧ -(option_cmp2 cmp (SOME x) (SOME y) = cmp x y)`; +val option_cmp2_def = Define` + (option_cmp2 cmp NONE NONE = Equal) ∧ + (option_cmp2 cmp NONE (SOME x) = Greater) ∧ + (option_cmp2 cmp (SOME x) NONE = Less) ∧ + (option_cmp2 cmp (SOME x) (SOME y) = cmp x y)` -val list_cmp_def = Define ` +val list_cmp_def = Define` (list_cmp cmp [] [] = Equal) ∧ (list_cmp cmp [] (x::y) = Less) ∧ (list_cmp cmp (x::y) [] = Greater) ∧ @@ -61,11 +57,11 @@ val list_cmp_def = Define ` case cmp x1 x2 of | Equal => list_cmp cmp y1 y2 | Less => Less - | Greater => Greater)`; + | Greater => Greater)` val list_cmp_ind = fetch "-" "list_cmp_ind"; -val pair_cmp_def = Define ` +val pair_cmp_def = Define` pair_cmp cmp1 cmp2 x y = case cmp1 (FST x) (FST y) of | Equal => cmp2 (SND x) (SND y) @@ -93,6 +89,72 @@ char_cmp c1 c2 = num_cmp (ORD c1) (ORD c2)`; val string_cmp_def = Define ` string_cmp = list_cmp char_cmp`; +(* relationship to toto *) + +val TotOrd_imp_good_cmp = store_thm("TotOrder_imp_good_cmp", + ``∀cmp. TotOrd cmp ⇒ good_cmp cmp``, + rw[TotOrd,good_cmp_thm] >> metis_tac[]) + +val invert_def = Define` + invert GREATER = LESS ∧ + invert LESS = GREATER ∧ + invert EQUAL = EQUAL` +val _ = export_rewrites["invert_def"] + +val invert_eq_EQUAL = store_thm("invert_eq_EQUAL[simp]", + ``∀x. invert x = EQUAL ⇔ x = EQUAL``, + Cases >> simp[]) + +val TO_inv_invert = store_thm("TO_inv_invert", + ``∀c. TotOrd c ⇒ TO_inv c = CURRY (invert o UNCURRY c)``, + simp[FUN_EQ_THM,TO_inv] >> gen_tac >> strip_tac >> + map_every qx_gen_tac[`x`,`y`] >> + Cases_on`c x y`>>simp[]>> + fs[TotOrd] >> metis_tac[]) + +val option_cmp2_TO_inv = store_thm("option_cmp2_TO_inv", + ``∀c. option_cmp2 c = TO_inv (option_cmp (TO_inv c))``, + simp[FUN_EQ_THM,TO_inv] >> + gen_tac >> Cases >> Cases >> + simp[option_cmp2_def,option_cmp_def,TO_inv]); + +val list_cmp_ListOrd = store_thm("list_cmp_ListOrd", + ``∀c. TotOrd c ⇒ list_cmp c = ListOrd (TO c)``, + simp[FUN_EQ_THM,PULL_FORALL] >> + ho_match_mp_tac list_cmp_ind >> + simp[list_cmp_def,ListOrd,TO_of_LinearOrder, + StrongLinearOrder_of_TO,TO_apto_TO_ID,listorder] >> + rw[] >> + fs[GSYM TO_apto_TO_ID,TotOrd] >> + BasicProvers.CASE_TAC >> + metis_tac[cmp_thms]) + +val pair_cmp_lexTO = store_thm("pair_cmp_lexTO", + ``∀R V. TotOrd R ∧ TotOrd V ⇒ pair_cmp R V = R lexTO V``, + simp[FUN_EQ_THM,lexTO_thm,pair_cmp_def]) + +val num_cmp_numOrd = store_thm("num_cmp_numOrd", + ``num_cmp = numOrd``, + simp[FUN_EQ_THM,num_cmp_def,numOrd,TO_of_LinearOrder]) + +val char_cmp_charOrd = store_thm("char_cmp_charOrd", + ``char_cmp = charOrd``, + simp[FUN_EQ_THM,char_cmp_def,charOrd,num_cmp_numOrd]) + +val string_cmp_stringto = store_thm("string_cmp_stringto", + ``string_cmp = apto stringto``, + simp[FUN_EQ_THM,stringto] >> + Induct >- ( Cases >> simp[aplistoto,string_cmp_def,list_cmp_def] ) >> + gen_tac >> Cases >> + simp[aplistoto,string_cmp_def,list_cmp_def,apcharto_thm,char_cmp_charOrd] >> + BasicProvers.CASE_TAC >> + simp[MATCH_MP list_cmp_ListOrd TO_charOrd,listoto,charto] >> + rpt AP_THM_TAC >> + match_mp_tac (GSYM TO_apto_TO_IMP) >> + simp[TO_ListOrd]) + +(* cmps are good *) + val option_cmp_good = Q.store_thm ("option_cmp_good", `!cmp. good_cmp cmp ⇒ good_cmp (option_cmp cmp)`, rw [good_cmp_def] >> diff --git a/src/enumfset/totoScript.sml b/src/enumfset/totoScript.sml index fb11fc2617..3fc0bce3b4 100644 --- a/src/enumfset/totoScript.sml +++ b/src/enumfset/totoScript.sml @@ -38,7 +38,7 @@ val _ = Defn.def_suffix := ""; (* replacing default "_def" *) (* from print_theory and the stuff known to DB.match, DB.find *) (* ***************************************************************** *) -val BigSig = false; +val BigSig = true; fun maybe_thm (s, tm, tac) = if BigSig then store_thm (s, tm, tac) else prove (tm, tac); From 4e0bf360ef5eb3ffb04ddf33ab007a884d2cac01 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Fri, 26 Dec 2014 17:27:46 +1100 Subject: [PATCH 069/718] fix logging-kernel/Holmakefile (it should just be the same as experimental-kernel's, which changed recently) --- src/logging-kernel/Holmakefile | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/logging-kernel/Holmakefile b/src/logging-kernel/Holmakefile index d5c6fde652..20a1dbb9a6 100644 --- a/src/logging-kernel/Holmakefile +++ b/src/logging-kernel/Holmakefile @@ -18,6 +18,11 @@ LIBD = $(dprot $(SIGOBJ)/Lib.ui) HOLSETD = $(dprot $(SIGOBJ)/HOLset.ui) +UOFILES = $(patsubst %.sml,%.uo,$(wildcard *.sml)) + +all: $(UOFILES) +.PHONY: all + Overlay.uo: Overlay.sml Net.ui Thm.ui $(FTAGD) $(FTYPED) $(FTERMD) $(FTHMD) $(HOLMOSMLC) -c -toplevel $(FTAG) $(FTYPE) $(FTERM) $(FTHM) Net.ui Overlay.sml From d8071b0bef24dd237a2d95a56a8cf21745e34a8d Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Fri, 26 Dec 2014 20:03:01 +1100 Subject: [PATCH 070/718] fix read_buildsequence for kernelnames the comment in build-sequence says the kernel names are "otknl", "stdknl" and "expk", but in the code they have a hyphen at the front. I guess this isn't used for anything apart from otknl so hadn't been tested much. --- tools/buildutils.sml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/buildutils.sml b/tools/buildutils.sml index a5df10c107..245300e1ab 100644 --- a/tools/buildutils.sml +++ b/tools/buildutils.sml @@ -153,7 +153,7 @@ fun read_buildsequence {kernelname} bseq_fname = let open FileSys in if (mlsys = "" orelse mlsys = Systeml.ML_SYSNAME) andalso - (knl = "" orelse knl = kernelname) then + (knl = "" orelse ("-"^knl) = kernelname) then if access (dirname, [A_READ, A_EXEC]) then if isDir dirname orelse mlsys <> "" then read_file ((dirname,testcount)::acc) From 8fd7f7b965a8d0deef5a3f5b7a4ed6e7023a4d55 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Fri, 26 Dec 2014 20:12:22 +1100 Subject: [PATCH 071/718] move opentheory earlier in build sequence it is not a large theory - indeed there are no theories in these directories, just some libraries, so take very little time to process. --- tools/sequences/large-theories | 2 -- tools/sequences/more-theories | 2 ++ 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/tools/sequences/large-theories b/tools/sequences/large-theories index de56034a17..0422644e6d 100644 --- a/tools/sequences/large-theories +++ b/tools/sequences/large-theories @@ -3,8 +3,6 @@ src/complex !!examples/separationLogic/src/ src/HolQbf src/HolSmt -src/opentheory -(otknl)src/opentheory/logging !examples/misc # these examples require Muddy, which is MoscowML specific [mosml]!examples/muddy/muddyC diff --git a/tools/sequences/more-theories b/tools/sequences/more-theories index 0e290fe7c2..f27e9b8e6c 100644 --- a/tools/sequences/more-theories +++ b/tools/sequences/more-theories @@ -1,3 +1,5 @@ +src/opentheory +(otknl)src/opentheory/logging !src/boss/theory_tests !src/tfl/src/test src/TeX From 779739fa3ac29f1b5042f5c099fa212b8f12bcad Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Fri, 26 Dec 2014 20:13:19 +1100 Subject: [PATCH 072/718] update opentheory/logging/Holmakefile for Holmake's new behaviour that does not automatically process all *.sml by default --- src/opentheory/logging/Holmakefile | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/opentheory/logging/Holmakefile b/src/opentheory/logging/Holmakefile index 552bf33484..004cb3d67f 100644 --- a/src/opentheory/logging/Holmakefile +++ b/src/opentheory/logging/Holmakefile @@ -1,3 +1,5 @@ +all: $(patsubst %.sml,%.uo,$(wildcard *.sml)) +.PHONY: all mkholdecide: holdecide.uo HOLMOSMLC -o $@ $< holdecide.o: mkholdecide From 4871926803af53a6a8ecae7e8f5d7ea2c01ef8a6 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Sat, 27 Dec 2014 05:08:50 +0000 Subject: [PATCH 073/718] remove miniML from the gitignore file --- .gitignore | 4 ---- 1 file changed, 4 deletions(-) diff --git a/.gitignore b/.gitignore index fbf6fbb511..6708364b61 100644 --- a/.gitignore +++ b/.gitignore @@ -133,11 +133,7 @@ examples/set-theory/hol_sets/ordinalML.* examples/theorem-prover/lisp-runtime/bin/*.s - examples/computability/lambda/computability-heap -examples/miniML/hol2miniml/*.txt -examples/miniML/hol2miniml/miniml-heap - local-hol-heap examples/l3-machine-code/**/*-heap From 31b01c1c657f91a231959d32feeb1e645506de72 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Sat, 27 Dec 2014 05:38:05 +0000 Subject: [PATCH 074/718] move opentheory after string since it depends on it. don't know why travis didn't catch this. --- tools/sequences/more-theories | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tools/sequences/more-theories b/tools/sequences/more-theories index f27e9b8e6c..5281ea8dec 100644 --- a/tools/sequences/more-theories +++ b/tools/sequences/more-theories @@ -1,5 +1,3 @@ -src/opentheory -(otknl)src/opentheory/logging !src/boss/theory_tests !src/tfl/src/test src/TeX @@ -9,6 +7,8 @@ src/TeX src/sort src/string !src/string/theorytesting +src/opentheory +(otknl)src/opentheory/logging !examples/STE src/res_quan/src src/quotient/src From f1369e3002d1cf2f176b2a3166250ba16c4f056b Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Tue, 30 Dec 2014 00:16:51 +1100 Subject: [PATCH 075/718] apropos_in, find_in to search for thms among previous results these functions search for term patterns or name substrings among only the list of values returned previously by listDB, apropos, find, thy --- src/bool/DB.sig | 5 +++++ src/bool/DB.sml | 13 +++++++++++++ 2 files changed, 18 insertions(+) diff --git a/src/bool/DB.sig b/src/bool/DB.sig index 58e869d6fc..4a8e894ca8 100644 --- a/src/bool/DB.sig +++ b/src/bool/DB.sig @@ -21,10 +21,13 @@ sig val theorems : string -> (string * thm) list val definitions : string -> (string * thm) list val find : string -> data list + val find_in : string -> data list -> data list val matchp : (thm -> bool) -> string list -> data list val matcher : (term -> term -> 'a) -> string list -> term -> data list val match : string list -> term -> data list + val matches : term -> thm -> bool val apropos : term -> data list + val apropos_in : term -> data list -> data list val listDB : unit -> data list val data_list_to_string : data list -> string @@ -46,6 +49,8 @@ sig val bindl : string -> (string * thm * class) list -> unit + val CT : unit -> (string, (string, data list) Redblackmap.dict * + (string, data list) Redblackmap.dict) Redblackmap.dict end diff --git a/src/bool/DB.sml b/src/bool/DB.sml index 81a8cbb465..b1bdee96ef 100644 --- a/src/bool/DB.sml +++ b/src/bool/DB.sml @@ -207,6 +207,19 @@ fun matcher f thyl pat = val match = matcher (ho_match_term [] empty_tmset); val apropos = match []; +(* matches : term -> thm -> bool + tests whether theorem matches pattern *) +fun matches pat th = + can (find_term (can (ho_match_term [] empty_tmset pat))) (concl th) ; + +fun apropos_in pat dbdata = + List.filter (fn (_, (th, _)) => matches pat th) dbdata ; + +fun find_in s = + let val lows = toLower s ; + fun finds dbdata = + List.filter (fn ((_, name), _) => occurs lows (toLower name)) dbdata ; + in finds end ; fun listDB () = let fun subfold (k,v,acc) = v @ acc From ca62b766d79ed0fd37d12c5a496f48cadf95fb43 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Tue, 30 Dec 2014 11:30:55 +1100 Subject: [PATCH 076/718] docs for find_in, apropos_in --- help/Docfiles/DB.apropos.doc | 2 +- help/Docfiles/DB.apropos_in.doc | 48 +++++++++++++++++++++++++++++++++ help/Docfiles/DB.find.doc | 2 +- help/Docfiles/DB.find_in.doc | 43 +++++++++++++++++++++++++++++ help/Docfiles/DB.match.doc | 2 +- help/Docfiles/DB.matches.doc | 40 +++++++++++++++++++++++++++ 6 files changed, 134 insertions(+), 3 deletions(-) create mode 100644 help/Docfiles/DB.apropos_in.doc create mode 100644 help/Docfiles/DB.find_in.doc create mode 100644 help/Docfiles/DB.matches.doc diff --git a/help/Docfiles/DB.apropos.doc b/help/Docfiles/DB.apropos.doc index ccb2236fb9..10887da8b6 100644 --- a/help/Docfiles/DB.apropos.doc +++ b/help/Docfiles/DB.apropos.doc @@ -34,5 +34,5 @@ The notion of matching is a restricted version of higher-order matching. For finer control over the theories searched, use {DB.match}. \SEEALSO -DB.match, DB.find. +DB.match, DB.find, DB.apropos_in, DB.matches. \ENDDOC diff --git a/help/Docfiles/DB.apropos_in.doc b/help/Docfiles/DB.apropos_in.doc new file mode 100644 index 0000000000..299c68a20d --- /dev/null +++ b/help/Docfiles/DB.apropos_in.doc @@ -0,0 +1,48 @@ +\DOC apropos_in + +\TYPE {apropos_in : term -> data list -> data list} + +\SYNOPSIS +Attempt to select matching theorems among a given list. + +\DESCRIBE +An invocation {DB.apropos_in M data_list} selects all +theorems, definitions, and axioms within {data_list} that have a subterm +that matches {M}. If there are no matches, the empty list is returned. + +\FAILURE +Never fails. + +\EXAMPLE +{ +- DB.apropos (Term `(!x y. P x y) ==> Q`); +<> +> val it = + [(("ind_type", "INJ_INVERSE2"), + (|- !P. + (!x1 y1 x2 y2. (P x1 y1 = P x2 y2) = (x1 = x2) /\ (y1 = y2)) ==> + ?X Y. !x y. (X (P x y) = x) /\ (Y (P x y) = y), Thm)), + (("pair", "pair_induction"), + (|- (!p_1 p_2. P (p_1,p_2)) ==> !p. P p, Thm))] : + ((string * string) * (thm * class)) list + +- DB.apropos_in (Term `(x, y)`) it ; + [(("pair", "pair_induction"), + (|- (!p_1 p_2. P (p_1,p_2)) ==> !p. P p, Thm))] : + ((string * string) * (thm * class)) list +} + + +\COMMENTS +The notion of matching is a restricted version of higher-order matching. +It uses {DB.matches}. + +\USES +Finding theorems in interactive proof sessions. +The second argument will normally be the result of a previous call to +{DB.find, DB.match, DB.apropos, DB.listDB, DB.thy} etc. + +\SEEALSO +DB.apropos, DB.match, DB.matches, DB.find, DB.find_in, DB.listDB, DB.thy, +DB.theorems. +\ENDDOC diff --git a/help/Docfiles/DB.find.doc b/help/Docfiles/DB.find.doc index 9932d1a981..da958e4482 100644 --- a/help/Docfiles/DB.find.doc +++ b/help/Docfiles/DB.find.doc @@ -32,5 +32,5 @@ Never fails. If nothing suitable can be found, the empty list is returned. Finding theorems in interactive proof sessions. \SEEALSO -DB.match, DB.apropos, DB.thy, DB.theorems. +DB.find_in, DB.match, DB.apropos, DB.thy, DB.theorems. \ENDDOC diff --git a/help/Docfiles/DB.find_in.doc b/help/Docfiles/DB.find_in.doc new file mode 100644 index 0000000000..15669043c1 --- /dev/null +++ b/help/Docfiles/DB.find_in.doc @@ -0,0 +1,43 @@ +\DOC find_in + +\TYPE {find_in : string -> data list -> data list} + +\SYNOPSIS +Search for theory element by name fragment, among a given list. + +\DESCRIBE +An invocation {DB.find_in s data_list} +selects from {data_list} those theory elements which have +been stored with a name in which {s} occurs as a proper substring, +ignoring case distinctions. + +\FAILURE +Never fails. If nothing suitable can be found, the empty list is returned. + +\EXAMPLE +{ +- DB.find "inc"; +> val it = + [(("arithmetic", "MULT_INCREASES"), + (|- !m n. 1 < m /\ 0 < n ==> SUC n <= m * n, Thm)), + (("bool", "BOOL_EQ_DISTINCT"), (|- ~(T = F) /\ ~(F = T), Thm)), + (("list", "list_distinct"), (|- !a1 a0. ~([] = a0::a1), Thm)), + (("sum", "sum_distinct"), (|- !x y. ~(INL x = INR y), Thm)), + (("sum", "sum_distinct1"), (|- !x y. ~(INR y = INL x), Thm))] + : ((string * string) * (thm * class)) list + +- DB.find_in "sum" it; +> val it = + [(("sum", "sum_distinct"), (|- !x y. ~(INL x = INR y), Thm)), + (("sum", "sum_distinct1"), (|- !x y. ~(INR y = INL x), Thm))] + : ((string * string) * (thm * class)) list +} + +\USES +Finding theorems in interactive proof sessions. +The second argument will normally be the result of a previous call to +{DB.find, DB.match, DB.apropos, DB.listDB, DB.thy} etc. + +\SEEALSO +DB.find, DB.match, DB.apropos, DB.listDB, DB.thy, DB.theorems. +\ENDDOC diff --git a/help/Docfiles/DB.match.doc b/help/Docfiles/DB.match.doc index 236483fbf2..f2202dd75b 100644 --- a/help/Docfiles/DB.match.doc +++ b/help/Docfiles/DB.match.doc @@ -55,5 +55,5 @@ The notion of matching is a restricted version of higher-order matching. For locating theorems when doing interactive proof. \SEEALSO -DB.matcher, DB.matchp, DB.find, DB.theorems, Db.thy, Db.listDB. +DB.matcher, DB.matchp, DB.find, DB.theorems, DB.thy, DB.listDB. \ENDDOC diff --git a/help/Docfiles/DB.matches.doc b/help/Docfiles/DB.matches.doc new file mode 100644 index 0000000000..2da4f6fe86 --- /dev/null +++ b/help/Docfiles/DB.matches.doc @@ -0,0 +1,40 @@ +\DOC matches + +\TYPE {matches : term -> thm -> bool} + +\SYNOPSIS +Tells whether part of a theorem matches a pattern. + +\KEYWORDS +matching. + +\DESCRIBE +An invocation {DB.match pat th} tells whether the conclusion of {th} +has a subterm matching {pat}. + +\FAILURE +Never fails. + +\EXAMPLE +{ +> DB.matches (Term `(a = b) = c`) EQ_CLAUSES ; +<> +val it = true: bool + +> DB.matches (Term `(a = b) = c`) EQ_TRANS ; +<> +val it = false: bool +} + + +\COMMENTS +The notion of matching is a restricted version of higher-order matching, +as used by {DB.apropos, DB.apropos_in, DB.match}, etc. + +\USES +For locating theorems relevant to a given pattern. + +\SEEALSO +DB.matcher, DB.matchp, DB.apropos, DB.apropos_in +\ENDDOC + From 79fc3d409a9000f799f29c64c5cdaa9f021533a1 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Wed, 31 Dec 2014 20:13:52 +1100 Subject: [PATCH 077/718] relaxing type constraint for THEN and THENL to permit val THEN : list_tactic * tactic -> list_tactic val THENL : list_tactic * tactic list -> list_tactic as well as the usual types --- help/Docfiles/Tactical.EVERY_LT.doc | 31 +++++++++++++++++++++++++++++ help/Docfiles/Tactical.THEN.doc | 8 ++++++-- help/Docfiles/Tactical.THENL.doc | 22 +++++++++++--------- help/Docfiles/Tactical.THEN_LT.doc | 4 ++-- src/1/Tactical.sig | 11 ++++++++++ src/1/Tactical.sml | 11 +++++++++- 6 files changed, 73 insertions(+), 14 deletions(-) create mode 100644 help/Docfiles/Tactical.EVERY_LT.doc diff --git a/help/Docfiles/Tactical.EVERY_LT.doc b/help/Docfiles/Tactical.EVERY_LT.doc new file mode 100644 index 0000000000..3dc9272d61 --- /dev/null +++ b/help/Docfiles/Tactical.EVERY_LT.doc @@ -0,0 +1,31 @@ +\DOC EVERY_LT + +\TYPE {EVERY_LT : (list_tactic list -> list_tactic)} + +\SYNOPSIS +Sequentially applies all the list-tactics in a given list of list-tactics. + +\KEYWORDS +list-tactic, tactical. + +\DESCRIBE +When applied to a list of list-tactics {[LT1; ... ;LTn]}, and a goal {g}, +the tactical {EVERY_LT} applies each list-tactic in sequence to every +subgoal generated by the previous one. This can be represented as: +{ + EVERY_LT [LT1;...;LTn] = LT1 THEN_LT ... THEN_LT LTn +} +If the list-tactic list is empty, the resulting list-tactic has no effect. + +\FAILURE +The application of {EVERY_LT} to a list-tactic list never fails. The resulting +list-tactic fails iff any of the component list-tactics do. + +\COMMENTS +It is possible to use {EVERY_LT} instead of {THEN_LT}, but probably +stylistically inferior. {EVERY_LT} is more useful when applied to a list of +list-tactics generated by a function. + +\SEEALSO +Tactical.THEN_LT. +\ENDDOC diff --git a/help/Docfiles/Tactical.THEN.doc b/help/Docfiles/Tactical.THEN.doc index 4fb9cfc43d..0f580c2608 100644 --- a/help/Docfiles/Tactical.THEN.doc +++ b/help/Docfiles/Tactical.THEN.doc @@ -1,9 +1,10 @@ \DOC THEN \TYPE {op THEN : tactic * tactic -> tactic} +op THEN : list_tactic * tactic -> list_tactic} \SYNOPSIS -Applies two tactics in sequence. +Applies a tactic to all subgoals produced by a tactic or list-tactic. \KEYWORDS tactical. @@ -13,6 +14,9 @@ If {T1} and {T2} are tactics, {T1 THEN T2} is a tactic which applies {T1} to a goal, then applies the tactic {T2} to all the subgoals generated. If {T1} solves the goal then {T2} is never applied. +Alternatively, {T1} may be a list-tactic which is applied to an initial list of +goals. + \FAILURE The application of {THEN} to a pair of tactics never fails. The resulting tactic fails if {T1} fails when applied to the goal, or if @@ -32,5 +36,5 @@ can be replaced by the briefer: \SEEALSO -Tactical.EVERY, Tactical.ORELSE, Tactical.THENL. +Tactical.EVERY, Tactical.ORELSE, Tactical.THENL, Tactical.THEN_LT. \ENDDOC diff --git a/help/Docfiles/Tactical.THENL.doc b/help/Docfiles/Tactical.THENL.doc index b892bd0e85..99583337be 100644 --- a/help/Docfiles/Tactical.THENL.doc +++ b/help/Docfiles/Tactical.THENL.doc @@ -1,21 +1,25 @@ -\DOC +\DOC THENL -\TYPE {op THENL : tactic -> tactic list -> tactic} +\TYPE {op THENL : tactic * tactic list -> tactic +op THENL : list_tactic * tactic list -> list_tactic} \SYNOPSIS -Applies a list of tactics to the corresponding subgoals generated by a tactic. +Applies a list of tactics to the corresponding subgoals generated by a +tactic or a list-tactic. \KEYWORDS tactical. \DESCRIBE -If {T,T1,...,Tn} are tactics, {T THENL [T1,...,Tn]} is a tactic which applies -{T} to a goal, and if it does not fail, applies the tactics {T1,...,Tn} to the -corresponding subgoals, unless {T} completely solves the goal. +If {T} is a tactic or list-tactic and {T1,...,Tn} are tactics, +{T THENL [T1,...,Tn]} is a tactic or list-tactic which applies +{T} to a goal or goal list, and if it does not fail, +applies the tactics {T1,...,Tn} to the corresponding subgoals, +unless {T} completely solves the goal(s). \FAILURE -The application of {THENL} to a tactic and tactic list never fails. -The resulting tactic fails if {T} fails when applied to the goal, or if +The application of {THENL} to a (list-)tactic and tactic list never fails. +The resulting tactic fails if {T} fails when applied to the goal(s), or if the goal list is not empty and its length is not the same as that of the tactic list, or finally if {Ti} fails when applied to the {i}'th subgoal generated by {T}. @@ -24,5 +28,5 @@ generated by {T}. Applying different tactics to different subgoals. \SEEALSO -Tactical.EVERY, Tactical.ORELSE, Tactical.THEN. +Tactical.EVERY, Tactical.ORELSE, Tactical.THEN, Tactical.THEN_LT. \ENDDOC diff --git a/help/Docfiles/Tactical.THEN_LT.doc b/help/Docfiles/Tactical.THEN_LT.doc index 3de3f8f8e4..7609292b8e 100644 --- a/help/Docfiles/Tactical.THEN_LT.doc +++ b/help/Docfiles/Tactical.THEN_LT.doc @@ -1,7 +1,7 @@ \DOC THEN_LT -\TYPE {op THEN_LT : tactic -> list_tactic -> tactic -op THEN_LT : list_tactic -> list_tactic -> list_tactic} +\TYPE {op THEN_LT : tactic * list_tactic -> tactic +op THEN_LT : list_tactic * list_tactic -> list_tactic} \SYNOPSIS Applies a list-tactic to the corresponding subgoals generated by a tactic diff --git a/src/1/Tactical.sig b/src/1/Tactical.sig index 2dbcf35c21..aa9c7e0ba2 100644 --- a/src/1/Tactical.sig +++ b/src/1/Tactical.sig @@ -5,8 +5,18 @@ sig val TAC_PROOF : goal * tactic -> thm val prove : term * tactic -> thm val store_thm : string * term * tactic -> thm + val THEN : ('a -> goal list * (thm list -> 'b)) * tactic -> + 'a -> goal list * (thm list -> 'b) + (* could be used as val THEN : tactic * tactic -> tactic + val THEN : list_tactic * tactic -> list_tactic + *) + val THENL : ('a -> goal list * (thm list -> 'b)) * tactic list -> + 'a -> goal list * (thm list -> 'b) + (* could be used as val THENL : tactic * tactic list -> tactic + val THENL : list_tactic * tactic list -> list_tactic + *) val ORELSE : tactic * tactic -> tactic val ORELSE_LT : list_tactic * list_tactic -> list_tactic val THEN1 : tactic * tactic -> tactic @@ -44,6 +54,7 @@ sig val GEN_VALIDATE : bool -> tactic -> tactic val GEN_VALIDATE_LT : bool -> list_tactic -> list_tactic val EVERY : tactic list -> tactic + val EVERY_LT : list_tactic list -> list_tactic val FIRST : tactic list -> tactic val MAP_EVERY : ('a -> tactic) -> 'a list -> tactic val MAP_FIRST : ('a -> tactic) -> 'a list -> tactic diff --git a/src/1/Tactical.sml b/src/1/Tactical.sml index b2d0cf7dd1..78e3bdc945 100644 --- a/src/1/Tactical.sml +++ b/src/1/Tactical.sml @@ -132,6 +132,10 @@ fun ALLGOALS tac2 gl = fun tac1 THEN tac2 = tac1 THEN_LT ALLGOALS tac2 ; +(* first argument can be a tactic or a list-tactic *) +val _ = op THEN : tactic * tactic -> tactic ; +val _ = op THEN : list_tactic * tactic -> list_tactic ; + (*--------------------------------------------------------------------------- * fun TACS_TO_LT (tac2l: tactic list) : list_tactic = fn gl => * let @@ -185,6 +189,10 @@ fun NULL_OK_LT ltac [] = ([], Lib.I) fun tac1 THENL tacs2 = tac1 THEN_LT NULL_OK_LT (TACS_TO_LT tacs2) ; +(* first argument can be a tactic or a list-tactic *) +val _ = op THENL : tactic * tactic list -> tactic ; +val _ = op THENL : list_tactic * tactic list -> list_tactic ; + fun (tac1 ORELSE tac2) g = tac1 g handle HOL_ERR _ => tac2 g fun (ltac1 ORELSE_LT ltac2) gl = ltac1 gl handle HOL_ERR _ => ltac2 gl @@ -511,11 +519,12 @@ end (*-- Tactical quantifiers -- Apply a list of tactics in succession. -------*) (*--------------------------------------------------------------------------- - * Uses every tactic. + * Uses every tactic (similarly EVERY_LT for list_tactics) * EVERY [TAC1;...;TACn] = TAC1 THEN ... THEN TACn *---------------------------------------------------------------------------*) fun EVERY tacl = List.foldr (op THEN) ALL_TAC tacl +fun EVERY_LT ltacl = List.foldr (op THEN_LT) ALL_LT ltacl (*--------------------------------------------------------------------------- * Uses first tactic that succeeds. From ca5c8d4958ead932ab3d1a65591e99813c68a184 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Thu, 1 Jan 2015 00:40:28 +1100 Subject: [PATCH 078/718] new list-tactic USE_SG_THEN makes one subgoal available in the proof of another --- help/Docfiles/Tactical.NTH_GOAL.doc | 3 + help/Docfiles/Tactical.USE_SG_THEN.doc | 124 +++++++++++++++++++++++++ src/1/Tactical.sig | 1 + src/1/Tactical.sml | 31 +++++++ 4 files changed, 159 insertions(+) create mode 100644 help/Docfiles/Tactical.USE_SG_THEN.doc diff --git a/help/Docfiles/Tactical.NTH_GOAL.doc b/help/Docfiles/Tactical.NTH_GOAL.doc index 5dc7a85005..f0be2104bd 100644 --- a/help/Docfiles/Tactical.NTH_GOAL.doc +++ b/help/Docfiles/Tactical.NTH_GOAL.doc @@ -14,6 +14,9 @@ If {tac} is a tactic, {NTH_GOAL n tac} is a list-tactic which applies the tactic {tac} to the {n}'th member of a list of goals. +Note that in the interactive system, +subgoals are printed in reverse order of their numbering. + \FAILURE The application of {NTH_GOAL} to a tactic and integer never fails. The resulting list-tactic fails if {n} is less than 1 or greater than the diff --git a/help/Docfiles/Tactical.USE_SG_THEN.doc b/help/Docfiles/Tactical.USE_SG_THEN.doc new file mode 100644 index 0000000000..4bdeb8c7ff --- /dev/null +++ b/help/Docfiles/Tactical.USE_SG_THEN.doc @@ -0,0 +1,124 @@ +\DOC USE_SG_THEN + +\TYPE {USE_SG_THEN : thm_tactic -> int -> int -> list_tactic} + +\SYNOPSIS +Allows the user to use one subgoal to prove another + +\KEYWORDS +theorem-tactic, lemma. + +\DESCRIBE +In {USE_SG_THEN ttac nu np}, of the current goal list, subgoal number +{nu} can be used in proving subgoal number {np}. +Subgoal number {nu} is used as a lemma by {ttac} +to simplify subgoal number {np}. That is, if +subgoal number {nu} is {A ?- u}, subgoal number {np} is {A1 ?- t1}, and +{ + A1 ?- t1 + ========== ttac (u |- u) + A2 ?- t2 +} +then the list-tactic {USE_SG_THEN ttac nu np} gives this same result +(new subgoal(s)) for subgoal {np}. + +This list-tactic will be invalid unless {A} is a subset of {A1}. + +Note that in the interactive system, +subgoals are printed in reverse order of their numbering. + +\FAILURE +{USE_SG_THEN} will fail {ttac (u |- u)} fails on subgoal number {np}, +or if indices {np} or {nu} are out of range. Note that the subgoals in the +current subgoal list are numbered starting from 1. + +\USES +Where two subgoals are similar and not easy to prove, one can be used to +help prove the other. + +\EXAMPLE +Here subgoal 1 is assumed, so as to help in proving subgoal 2. +{ +r ∨ s +------------------------------------ + 0. p + 1. q + + +r +------------------------------------ + 0. p + 1. q + +2 subgoals +: + proof + +> elt (USE_SG_THEN ASSUME_TAC 1 2) ; +OK.. +2 subgoals: +val it = + +r ∨ s +------------------------------------ + 0. p + 1. q + 2. r + + +r +------------------------------------ + 0. p + 1. q + +2 subgoals +: + proof +} +Here is an example where the assumptions differ. +Subgoal 2 is used to solve subgoal 1, but the assumption {p') of +subgoal 2 remains to be proved. Without {VALIDATE_LT}, the list-tactic would +be invalid. +{ +r +------------------------------------ + 0. p' + 1. q + + +r +------------------------------------ + 0. p + 1. q + +2 subgoals +: + proof + +> elt (VALIDATE_LT (USE_SG_THEN ACCEPT_TAC 2 1)) ; +OK.. +2 subgoals: +val it = + +r +------------------------------------ + 0. p' + 1. q + + +p' +------------------------------------ + 0. p + 1. q + +2 subgoals +: + proof +} + + +\COMMENTS +Some users may expect the generated tactic to be {ttac (A |- u)}, rather +than {ttac (u |- u)}. + +\ENDDOC diff --git a/src/1/Tactical.sig b/src/1/Tactical.sig index aa9c7e0ba2..267ff4d91b 100644 --- a/src/1/Tactical.sig +++ b/src/1/Tactical.sig @@ -70,6 +70,7 @@ sig val PAT_ASSUM : term -> thm_tactic -> tactic val POP_ASSUM_LIST : (thm list -> tactic) -> tactic val SUBGOAL_THEN : term -> thm_tactic -> tactic + val USE_SG_THEN : thm_tactic -> int -> int -> list_tactic val CHANGED_TAC : tactic -> tactic val Q_TAC : (term -> tactic) -> term frag list -> tactic diff --git a/src/1/Tactical.sml b/src/1/Tactical.sml index 78e3bdc945..df16a57174 100644 --- a/src/1/Tactical.sml +++ b/src/1/Tactical.sml @@ -610,6 +610,37 @@ fun SUBGOAL_THEN wa ttac (asl, w) = (fn (tha :: thl) => PROVE_HYP tha (p thl) | _ => raise Match)) end +(*--------------------------------------------------------------------------- + * Use another subgoal, providing it as a theorem to a tactic + * + * USE_SG_THEN ttac nu np + * + * assumes subgoal number nu for proving subgoal number np + *---------------------------------------------------------------------------*) + +(* apnth : ('a -> 'a) -> int -> 'a list -> 'a list + apply a function to the nth member of a list *) +fun apnth f 0 (y :: ys) = f y :: ys + | apnth f n (y :: ys) = y :: apnth f (n-1) ys ; + +(* USE_SG_VAL : int -> int -> list_validation *) +fun USE_SG_VAL nu np thl = + let val thu = List.nth (thl, nu - 1) ; + in apnth (PROVE_HYP thu) (np - 1) thl end ; + +(* USE_SG_THEN : thm_tactic -> int -> int -> list_tactic *) +fun USE_SG_THEN ttac nu np gl = + let + val (_, wu) = List.nth (gl, nu - 1) ; + val ltac = NTH_GOAL (ttac (ASSUME wu)) np ; + val (glr, v) = ltac gl ; + val vp = USE_SG_VAL nu np ; + in (glr, vp o v) end ; + +(* USE_SG_TAC : int -> int -> list_tactic +val USE_SG_TAC = USE_SG_THEN ASSUME_TAC ; +*) + (*--------------------------------------------------------------------------- * A tactical that makes a tactic fail if it has no effect. *---------------------------------------------------------------------------*) From d004132040f0f1f0c97061531b553d97bba02ea4 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Thu, 1 Jan 2015 13:36:56 +1100 Subject: [PATCH 079/718] re-implement CONJ_ASM1_TAC, CONJ_ASM2_TAC using USE_SG_THEN now one-line implementation of these tactics --- help/Docfiles/Tactic.CONJ_ASM1_TAC.doc | 2 +- help/Docfiles/Tactic.CONJ_ASM2_TAC.doc | 2 +- src/1/Tactic.sml | 21 ++------------------- 3 files changed, 4 insertions(+), 21 deletions(-) diff --git a/help/Docfiles/Tactic.CONJ_ASM1_TAC.doc b/help/Docfiles/Tactic.CONJ_ASM1_TAC.doc index 90d293fe54..07035a0b40 100644 --- a/help/Docfiles/Tactic.CONJ_ASM1_TAC.doc +++ b/help/Docfiles/Tactic.CONJ_ASM1_TAC.doc @@ -23,5 +23,5 @@ to two subgoals corresponding to the first conjunct then the second conjunct. Fails unless the conclusion of the goal is a conjunction. \SEEALSO -Tactic.CONJ_ASM2_TAC, Tactic.CONJ_TAC. +Tactic.CONJ_ASM2_TAC, Tactic.CONJ_TAC, Tactical.USE_SG_THEN. \ENDDOC diff --git a/help/Docfiles/Tactic.CONJ_ASM2_TAC.doc b/help/Docfiles/Tactic.CONJ_ASM2_TAC.doc index 6b5a733b24..2c36ab798a 100644 --- a/help/Docfiles/Tactic.CONJ_ASM2_TAC.doc +++ b/help/Docfiles/Tactic.CONJ_ASM2_TAC.doc @@ -24,5 +24,5 @@ prove the second. Fails unless the conclusion of the goal is a conjunction. \SEEALSO -Tactic.CONJ_ASM1_TAC, Tactic.CONJ_TAC. +Tactic.CONJ_ASM1_TAC, Tactic.CONJ_TAC, Tactical.USE_SG_THEN. \ENDDOC diff --git a/src/1/Tactic.sml b/src/1/Tactic.sml index 978d8104fe..e199a25272 100644 --- a/src/1/Tactic.sml +++ b/src/1/Tactic.sml @@ -142,25 +142,8 @@ val CONJ_TAC: tactic = (* ASM1 & ASM2 variants assume the given conjunct when proving the other one *) -val CONJ_ASM1_TAC: tactic = - fn (asl, w) => - let - val (conj1, conj2) = dest_conj w - in - ([(asl, conj1), (conj1 :: asl, conj2)], - pairths (fn th1 => fn th2 => CONJ th1 (PROVE_HYP th1 th2))) - end - handle HOL_ERR _ => raise ERR "CONJ_ASM1_TAC" "" - -val CONJ_ASM2_TAC: tactic = - fn (asl, w) => - let - val (conj1, conj2) = dest_conj w - in - ([(conj2 :: asl, conj1), (asl, conj2)], - pairths (fn th1 => fn th2 => CONJ (PROVE_HYP th2 th1) th2)) - end - handle HOL_ERR _ => raise ERR "CONJ_ASM2_TAC" "" +val CONJ_ASM1_TAC = CONJ_TAC THEN_LT USE_SG_THEN ASSUME_TAC 1 2 ; +val CONJ_ASM2_TAC = CONJ_TAC THEN_LT USE_SG_THEN ASSUME_TAC 2 1 ; (*---------------------------------------------------------------------------* * Disjunction introduction * From fc9792d28d169d567b6aedbfe471ed74bbd24bff Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Thu, 1 Jan 2015 14:06:12 +1100 Subject: [PATCH 080/718] fix to help file Tactical.USE_SG_THEN.doc --- help/Docfiles/Tactical.USE_SG_THEN.doc | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/help/Docfiles/Tactical.USE_SG_THEN.doc b/help/Docfiles/Tactical.USE_SG_THEN.doc index 4bdeb8c7ff..18963faa25 100644 --- a/help/Docfiles/Tactical.USE_SG_THEN.doc +++ b/help/Docfiles/Tactical.USE_SG_THEN.doc @@ -39,7 +39,7 @@ help prove the other. \EXAMPLE Here subgoal 1 is assumed, so as to help in proving subgoal 2. { -r ∨ s +r \/ s ------------------------------------ 0. p 1. q @@ -59,7 +59,7 @@ OK.. 2 subgoals: val it = -r ∨ s +r \/ s ------------------------------------ 0. p 1. q @@ -76,9 +76,9 @@ r proof } Here is an example where the assumptions differ. -Subgoal 2 is used to solve subgoal 1, but the assumption {p') of -subgoal 2 remains to be proved. Without {VALIDATE_LT}, the list-tactic would -be invalid. +Subgoal 2 is used to solve subgoal 1, +but the assumption {p'} of subgoal 2 remains to be proved. +Without {VALIDATE_LT}, the list-tactic would be invalid. { r ------------------------------------ @@ -116,7 +116,6 @@ p' proof } - \COMMENTS Some users may expect the generated tactic to be {ttac (A |- u)}, rather than {ttac (u |- u)}. From 8663830389d8d1e66108b8bad54cb0fc4147c956 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Thu, 1 Jan 2015 15:26:58 +1100 Subject: [PATCH 081/718] infix declaration for THEN_LT in Tactic.sml not sure why this is needed - builds here without it, but not on GitHub; and clearly not needed for THEN in Tactic.sml --- src/1/Tactic.sml | 1 + 1 file changed, 1 insertion(+) diff --git a/src/1/Tactic.sml b/src/1/Tactic.sml index e199a25272..128960eeac 100644 --- a/src/1/Tactic.sml +++ b/src/1/Tactic.sml @@ -142,6 +142,7 @@ val CONJ_TAC: tactic = (* ASM1 & ASM2 variants assume the given conjunct when proving the other one *) +infix THEN_LT ; (* why do we need this? Not needed for THEN, below! *) val CONJ_ASM1_TAC = CONJ_TAC THEN_LT USE_SG_THEN ASSUME_TAC 1 2 ; val CONJ_ASM2_TAC = CONJ_TAC THEN_LT USE_SG_THEN ASSUME_TAC 2 1 ; From 21c9098c064d27345d624bee36aa2ac33c91cade Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Sat, 3 Jan 2015 10:11:32 +0800 Subject: [PATCH 082/718] Implement new, somewhat more generic subterm-finding functions. These subsume my previous attempt in the same vein (bvk_find_term). In this form, I believe gen_find_term will help with github issue #81, which is to do matching-and-renaming on sub-terms, not just whole goals or assumptions. --- help/Docfiles/HolKernel.gen_find_term.doc | 53 +++++++++++++++++ help/Docfiles/HolKernel.gen_find_terms.doc | 48 ++++++++++++++++ src/postkernel/HolKernel.sml | 67 +++++++++++++++------- src/postkernel/HolKernelDoc.sig | 2 + 4 files changed, 148 insertions(+), 22 deletions(-) create mode 100644 help/Docfiles/HolKernel.gen_find_term.doc create mode 100644 help/Docfiles/HolKernel.gen_find_terms.doc diff --git a/help/Docfiles/HolKernel.gen_find_term.doc b/help/Docfiles/HolKernel.gen_find_term.doc new file mode 100644 index 0000000000..c7326e1aca --- /dev/null +++ b/help/Docfiles/HolKernel.gen_find_term.doc @@ -0,0 +1,53 @@ +\DOC + +\TYPE {gen_find_term : (term list * term -> 'a option) -> term -> 'a option} + +\SYNOPSIS +Finds first value in range of partial function mapped over sub-terms of a term. + +\KEYWORDS +sub-term, search + +\DESCRIBE + +If a call to {gen_find_term f t} returns {SOME v}, then that result is +the first value returned by a call of function {f} to one of the +sub-terms of term {t}. The function {f} is successively passed +sub-terms of {t} starting with {t} itself and then proceeding in a +top-down, left-to-right traversal. + +The additional list of terms passed to the function {f} is the list of bound variables ``governing'' the sub-term in question, with the innermost bound variable first in the list. + +\FAILURE +A call to {gen_find_term f t} will fail if {f} fails when applied to any of the sub-terms of {t}. + +\EXAMPLE +{ +> gen_find_term (fn x => SOME x) ``SUC x``; +val it = SOME ([], ``SUC x``) : (term list * term) option + +> gen_find_term + (fn (bvs,t) => if null bvs andalso + (is_var t orelse numSyntax.is_numeral t) + then + Lib.total (match_term ``x:num``) t + else NONE) + ``SUC z + (\y. y) 5``; +val it = + SOME ([{redex = ``x``, residue = ``z``}], [])] : + ((term, term) Term.subst * (hol_type, hol_type) Term.subst) option +} + +\COMMENTS + +This function is used to implement {bvk_find_term}. This function +could itself be approximated by returning the last value in the list +returned by {gen_find_terms}. Such an implementation would be less +efficient because it would unnecessarily construct a list of all +possible results. It would also be semantically different if {f} had +side effects. + +\SEEALSO +HolKernel.bvk_find_term, HolKernel.find_term, HolKernel.gen_find_terms. + +\ENDDOC diff --git a/help/Docfiles/HolKernel.gen_find_terms.doc b/help/Docfiles/HolKernel.gen_find_terms.doc new file mode 100644 index 0000000000..087419c387 --- /dev/null +++ b/help/Docfiles/HolKernel.gen_find_terms.doc @@ -0,0 +1,48 @@ +\DOC + +\TYPE {gen_find_terms : (term list * term -> 'a option) -> term -> 'a list} + +\SYNOPSIS +Maps a partial function over sub-terms of a term. + +\KEYWORDS +sub-term, search + +\DESCRIBE +A call to {gen_find_terms f t} returns a list of values derived from +sub-terms of term {t}. The values are those generated by the function +{f} when it returns {SOME v}. The function {f} is successively passed +sub-terms of {t} starting with {t} itself and then proceeding in a +top-down, left-to-right traversal. The list of results returned in the +reverse of this order (but the fact that the traversal is done in the +described order is observable if {f} has side effects). + +The additional list of terms passed to the function {f} is the list of bound variables ``governing'' the sub-term in question, with the innermost bound variable first in the list. + +\FAILURE +A call to {gen_find_terms f t} will fail if {f} fails when applied to any of the sub-terms of {t}. + +\EXAMPLE +{ +> gen_find_terms (fn x => SOME x) ``SUC x``; +val it = + [([], ``x``), ([], ``SUC``), ([], ``SUC x``)]: + (term list * term) list + +> gen_find_terms + (fn (bvs,t) => if null bvs andalso + (is_var t orelse numSyntax.is_numeral t) + then + Lib.total (match_term ``x:num``) t + else NONE) + ``SUC z + (\y. y) 5``; +val it = + [([{redex = ``x``, residue = ``5``}], []), + ([{redex = ``x``, residue = ``z``}], [])]: + ((term, term) Term.subst * (hol_type, hol_type) Term.subst) list +} + +\SEEALSO +HolKernel.bvk_find_term, HolKernel.find_term, HolKernel.gen_find_term. + +\ENDDOC diff --git a/src/postkernel/HolKernel.sml b/src/postkernel/HolKernel.sml index 83ad2458fd..f0d48a2c57 100644 --- a/src/postkernel/HolKernel.sml +++ b/src/postkernel/HolKernel.sml @@ -268,6 +268,48 @@ fun find_term P = find_tm end + +local + datatype action = SEARCH of term | POP +in + fun gen_find_term f t = + let + fun search bvs actions = + case actions of + [] => NONE + | POP :: alist => search (tl bvs) alist + | SEARCH t :: alist => (case f (bvs, t) of + NONE => subterm bvs alist t + | x => x) + and subterm bvs alist t = + case dest_term t of + COMB (t1, t2) => search bvs (SEARCH t1 :: SEARCH t2 :: alist) + | LAMB (bv, t) => search (bv :: bvs) (SEARCH t :: POP :: alist) + | _ => search bvs alist + in + search [] [SEARCH t] + end + fun gen_find_terms f t = + let + fun search bvs actions acc = + case actions of + [] => acc + | POP :: alist => search (tl bvs) alist acc + | SEARCH t :: alist => + (case f (bvs, t) of + NONE => subterm bvs alist acc t + | SOME x => subterm bvs alist (x::acc) t) + and subterm bvs alist acc t = + case dest_term t of + COMB(t1, t2) => search bvs (SEARCH t1 :: SEARCH t2 :: alist) + acc + | LAMB (bv, t) => search (bv::bvs) (SEARCH t :: POP :: alist) acc + | _ => search bvs alist acc + in + search [] [SEARCH t] [] + end +end (* local *) + (* ---------------------------------------------------------------------- bvk_find_term : (term list * term -> bool) -> (term -> 'a) -> term -> 'a option @@ -290,28 +332,9 @@ fun find_term P = bound variables appearing earlier in the list. ---------------------------------------------------------------------- *) -local - datatype action = SEARCH of term | POP -in - fun bvk_find_term P k t = - let - fun search bvs actions = - case actions of - [] => NONE - | POP :: alist => search (tl bvs) alist - | SEARCH t :: alist => - (if P (bvs, t) - then SOME (k t) handle HOL_ERR _ => subterm bvs alist t - else subterm bvs alist t) - and subterm bvs alist t = - case dest_term t of - COMB (t1, t2) => search bvs (SEARCH t1 :: SEARCH t2 :: alist) - | LAMB (bv, t) => search (bv :: bvs) (SEARCH t :: POP :: alist) - | _ => search bvs alist - in - search [] [SEARCH t] - end -end (* local *) +fun bvk_find_term P k = + gen_find_term (fn x => if P x then SOME (k (#2 x)) handle HOL_ERR _ => NONE + else NONE) (*--------------------------------------------------------------------------- * find_terms: (term -> bool) -> term -> term list diff --git a/src/postkernel/HolKernelDoc.sig b/src/postkernel/HolKernelDoc.sig index 01c37bfeee..d65e1b2752 100644 --- a/src/postkernel/HolKernelDoc.sig +++ b/src/postkernel/HolKernelDoc.sig @@ -14,6 +14,8 @@ sig | COMB of term * term | LAMB of term * term + val gen_find_term: (term list * term -> 'a option) -> term -> 'a option + val gen_find_terms: (term list * term -> 'a option) -> term -> 'a list val bvk_find_term: (term list * term -> bool) -> (term -> 'a) -> term -> 'a option val dest_binder: term -> exn -> term -> term * term From acbc902fe3e3cb4ddc072814a52f66b2f64a8861 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Sat, 3 Jan 2015 14:51:01 +0800 Subject: [PATCH 083/718] Fill paragraphs in doc-file to make it appear better in within-HOL help. --- help/Docfiles/Q.MATCH_ASSUM_RENAME_TAC.doc | 43 +++++++++++++--------- 1 file changed, 25 insertions(+), 18 deletions(-) diff --git a/help/Docfiles/Q.MATCH_ASSUM_RENAME_TAC.doc b/help/Docfiles/Q.MATCH_ASSUM_RENAME_TAC.doc index dbd290fe5b..f0ca09e070 100644 --- a/help/Docfiles/Q.MATCH_ASSUM_RENAME_TAC.doc +++ b/help/Docfiles/Q.MATCH_ASSUM_RENAME_TAC.doc @@ -3,40 +3,47 @@ \TYPE {Q.MATCH_ASSUM_RENAME_TAC : term quotation -> string list -> tactic} \SYNOPSIS -Replaces selected terms with new variables by matching a pattern against an assumption. +Replaces selected terms with new variables by matching a pattern +against an assumption. \DESCRIBE -When applied to the goal {(asl, w)}, the tactic {Q.MATCH_ASSUM_RENAME_TAC q ls} -parses the quotation {q} in the context of the goal, producing a term to use as -a pattern. The tactic then attempts a (first order) match of the pattern -against each term in {asl}, stopping on the first matching assumption {a}. -For each variable {v} in the pattern, there will be an instantiation term {t}, -such that the substitution {pattern[v1 |-> t1, v2 |-> t2, ...]} produces {a}. -The effect of the tactic is to then replace each {t} with the corresponding -{v}, yielding a new goal. The list {ls} is of exceptions: if a variable {v}'s -name appears in {ls}, then no replacement of {v} for {t} is made. +When applied to the goal {(asl, w)}, the tactic +{Q.MATCH_ASSUM_RENAME_TAC q ls} parses the quotation {q} in the +context of the goal, producing a term to use as a pattern. The tactic +then attempts a (first order) match of the pattern against each term +in {asl}, stopping on the first matching assumption {a}. + +For each variable {v} in the pattern, there will be an instantiation +term {t}, such that the substitution +{ + pattern[v1 |-> t1, v2 |-> t2, ...] +} +produces {a}. The effect of the tactic is to then replace each {t} +with the corresponding {v}, yielding a new goal. The list {ls} is of +exceptions: if a variable {v}'s name appears in {ls}, then no +replacement of {v} for {t} is made. \FAILURE -{MATCH_ASSUM_RENAME_TAC} fails if the pattern provided does not match any -assumption, or if variables from the goal are used in the pattern in ways that -make the pattern fail to type-check. +{MATCH_ASSUM_RENAME_TAC} fails if the pattern provided does not match +any assumption, or if variables from the goal are used in the pattern +in ways that make the pattern fail to type-check. \EXAMPLE If the current goal is { (f x = Pair C'' C0') ?- (f C'' = f C0') } -then applying the tactic {Q.MATCH_ASSUM_RENAME_TAC `X = Pair c1 c2` ["X"]} results in -the goal +then applying the tactic {Q.MATCH_ASSUM_RENAME_TAC `X = Pair c1 c2` +["X"]} results in the goal { (f x = Pair c1 c2) ?- (f c1 = f c2) } \COMMENTS -This tactic improves on the following tedious workflow: {Q.PAT_ASSUM pat MP_TAC}, -{Q.MATCH_ABBREV_TAC `pat ==> X`}, {Q.UNABBREV_TAC `X`}, -{markerLib.RM_ALL_ABBREVS_TAC}, {STRIP_TAC}. + +This tactic improves on the following tedious workflow: +{Q.PAT_ASSUM pat MP_TAC}, {Q.MATCH_ABBREV_TAC `pat ==> X`}, {Q.UNABBREV_TAC `X`}, {markerLib.RM_ALL_ABBREVS_TAC}, {STRIP_TAC}. \SEEALSO Q.MATCH_RENAME_TAC. From 4e6cbfb2ba007ee4848d62c35d05edf171cc45a5 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Sat, 3 Jan 2015 21:04:15 +0800 Subject: [PATCH 084/718] A renaming/matching tactic that matches against subterms in the goal. Progress with Github issue #81 (which also calls for the same against assumptions and an abbreviation version too). --- help/Docfiles/Q.MATCH_GOALSUB_RENAME_TAC.doc | 48 ++++++++++++++++++ src/q/Q.sig | 1 + src/q/Q.sml | 25 ++++++++++ src/q/selftest.sml | 51 ++++++++++++++++---- 4 files changed, 115 insertions(+), 10 deletions(-) create mode 100644 help/Docfiles/Q.MATCH_GOALSUB_RENAME_TAC.doc diff --git a/help/Docfiles/Q.MATCH_GOALSUB_RENAME_TAC.doc b/help/Docfiles/Q.MATCH_GOALSUB_RENAME_TAC.doc new file mode 100644 index 0000000000..0985f47f81 --- /dev/null +++ b/help/Docfiles/Q.MATCH_GOALSUB_RENAME_TAC.doc @@ -0,0 +1,48 @@ +\DOC + +\TYPE {MATCH_GOALSUB_RENAME_TAC : term quotation -> string list -> tactic} + +\SYNOPSIS +Renames a goal in accordance with a pattern matched against a subterm +of the goal. + +\KEYWORDS +Renaming + +\DESCRIBE + +A call to {MATCH_GOALSUB_RENAME_TAC pat excs} attempts to find a match +for the pattern {pat} in the current goal (using {gen_find_term} to +find a sub-term of the goal that matches). If a match is found, the +goal is adjusted so that the variables occurring in the pattern now +also appear in the goal. This may rename variables in the goal, or +even cause larger sub-terms to be replaced by variables (as with +{SPEC_TAC}). + +\FAILURE + +Fails if there is no sub-term of the goal that matches the pattern. +Fails if the instantiation changes a pattern variable that already +exists in the goal. + +\EXAMPLE + +If the goal is +{ + ?- !x. x * 2 < y * (z + 1) * (y + a) +} +then applying {Q.MATCH_GOALSUB_RENAME_TAC `y + c` []} will match the +pattern {y + c} against the various subterms within the goal. The +first obvious match, with {z + 1} will be rejected because the +variable {y} is free in the goal, and is treated as if it were a local +constant. Because of this, {y + a} is the matching sub-term, and after +renaming the goal becomes +{ + ?- !x. x * 2 < y * (z + 1) * (y + c) +} + + +\SEEALSO +Q.MATCH_RENAME_TAC. + +\ENDDOC diff --git a/src/q/Q.sig b/src/q/Q.sig index 6040439620..a9b5f2473d 100644 --- a/src/q/Q.sig +++ b/src/q/Q.sig @@ -61,5 +61,6 @@ sig val MATCH_RENAME_TAC : tmquote -> string list -> tactic val MATCH_ASSUM_RENAME_TAC : tmquote -> string list -> tactic + val MATCH_GOALSUB_RENAME_TAC : tmquote -> string list -> tactic end diff --git a/src/q/Q.sml b/src/q/Q.sml index a62a147c91..344deb3b29 100644 --- a/src/q/Q.sml +++ b/src/q/Q.sml @@ -361,6 +361,8 @@ let val (sf,sb) = partition (fn {redex=l,residue=r} => mem l fvs) s in (filter (fn {redex=l,residue=r} => not (mem (fst(dest_var l)) except)) sb) end +(* these functions should probably be using raw_match_term in order to + handle the variables that are only allowed to be bound to themselves *) fun MATCH_RENAME_TAC q except (g as (asl,t)) = let val fvs = free_varsl(t::asl) val pat = Parse.parse_in_context fvs q @@ -381,4 +383,27 @@ fun MATCH_ASSUM_RENAME_TAC q except (g as (asl,t)) = let handle HOL_ERR e => find tl in find asl end g +fun MATCH_GOALSUB_RENAME_TAC q except (g as (asl, t)) = let + val ERR = ERR "MATCH_GOALSUB_RENAME_TAC" + val fvs = free_varsl (t::asl) + val pat = Parse.parse_in_context fvs q + val fvs_set = HOLset.fromList Term.compare fvs + fun test (bvs, subt) = + case Lib.total (fn t => raw_match [] fvs_set pat t ([],[])) subt of + SOME ((theta0, _), _) => + let + fun filt1 {redex,...} = not (mem (#1 (dest_var redex)) except) + fun filt2 {residue, ...} = + List.all (fn bv => not (free_in bv residue)) bvs + val theta = filter (fn s => filt1 s andalso filt2 s) theta0 + in + if null theta then NONE else SOME theta + end + | NONE => NONE +in + case gen_find_term test t of + SOME theta => make_rename_tac theta fvs except ERR g + | NONE => raise ERR "No matching sub-term found in goal term" +end + end (* Q *) diff --git a/src/q/selftest.sml b/src/q/selftest.sml index 602676a814..2ebf54635a 100644 --- a/src/q/selftest.sml +++ b/src/q/selftest.sml @@ -1,11 +1,9 @@ -open Parse boolLib HolKernel +open Parse boolLib HolKernel testutils -fun tprint s = print (StringCvt.padRight #" " 65 s) -fun die() = (print "FAILED!\n"; Process.exit Process.failure) val _ = tprint "Testing Q.EXISTS ... " val th = Q.EXISTS (`?f. f T T = T`, `$/\`) (REWRITE_CONV [] ``T /\ T``) - handle HOL_ERR _ => die() + handle HOL_ERR _ => die "FAILED!" val _ = print "OK\n" @@ -13,18 +11,51 @@ val _ = tprint "Testing Q.REFINE_EXISTS_TAC" val asm = ``!x1:'a x2:'a y1:'b y2:'b. (f x1 y1:'c = f x2 y2) <=> (x1 = x2) /\ (y1 = y2)`` val goal = ``?a:'c b:'d. Q a b`` -val (sgs, vfn) = Q.REFINE_EXISTS_TAC `f x y` ([asm], goal) handle _ => die() +val (sgs, vfn) = Q.REFINE_EXISTS_TAC `f x y` ([asm], goal) + handle _ => die "FAILED!" val expected_sg = ``?x:'a y:'b b:'d. Q (f x y:'c) b`` val result = case sgs of [g as ([a],g')] => if aconv a asm andalso aconv g' expected_sg then vfn [mk_thm g] - else die() - | _ => die() + else die "FAILED!" + | _ => die "FAILED!" val _ = if aconv (concl result) goal then case hyp result of - [a] => if aconv a asm then print "OK\n" else die() - | _ => die() - else die() + [a] => if aconv a asm then print "OK\n" else die "FAILED!" + | _ => die "FAILED!" + else die "FAILED!" + +(* fake arithmetic *) +val _ = new_type ("num", 0) +val _ = new_constant ("*", ``:num -> num -> num``) +val _ = new_constant ("+", ``:num -> num -> num``) +val _ = new_constant ("<", ``:num -> num -> bool``) +val _ = new_constant ("SUC", ``:num -> num``) +val _ = new_constant ("zero", ``:num``) +val _ = set_fixity "+" (Infixl 500) +val _ = set_fixity "*" (Infixl 600) +val _ = set_fixity "<" (Infix(NONASSOC, 450)) + +val _ = tprint "Q.MATCH_GOALSUB_RENAME_TAC 1" +val gl1 = ([] : term list, + ``!x. x * SUC (SUC zero) < y * (z + SUC zero) * (y + a)``) +val expected_result1 = + ``!x. x * SUC (SUC zero) < y * (z + SUC zero) * (y + c)`` +val (sgs, _) = Q.MATCH_GOALSUB_RENAME_TAC `y + c` [] gl1 +val _ = case sgs of + [([], t)] => if aconv t expected_result1 then print "OK\n" + else die "FAILED!" + | _ => die "FAILED!" + +val _ = tprint "Q.MATCH_GOALSUB_RENAME_TAC 2" +val gl2 = ([] : term list, + ``!x. x * SUC zero < y * (z + SUC zero) * (z + SUC (SUC zero))``) +val expected_result2 = ``!x. x * c < y * (a + c) * (a + SUC c)`` +val (sgs, _) = Q.MATCH_GOALSUB_RENAME_TAC `a + c` [] gl2 +val _ = case sgs of + [([], t)] => if aconv t expected_result2 then print "OK\n" + else die "FAILED!" + | _ => die "FAILED!" val _ = Process.exit Process.success; From eb627e3179f28e0cf8f2ead4c3d4b6f1b01829b9 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Wed, 7 Jan 2015 16:46:01 +1100 Subject: [PATCH 085/718] prove relationship between foldi and FOLDR This means you can prove something about a fold over sptrees by doing a list proof on the toAList of the tree, rather than messing with the sptree's structure. (But still do the fold directly on the tree when you execute it.) --- src/patricia/sptreeScript.sml | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/src/patricia/sptreeScript.sml b/src/patricia/sptreeScript.sml index e44dd74065..5001a288b6 100644 --- a/src/patricia/sptreeScript.sml +++ b/src/patricia/sptreeScript.sml @@ -613,6 +613,16 @@ val domain_empty = store_thm("domain_empty", val _ = remove_ovl_mapping "lrnext" {Name = "lrnext", Thy = "sptree"} +val foldi_FOLDR_toAList_lemma = prove( + ``∀t n a ls. foldi f n (FOLDR (UNCURRY f) a ls) t = + FOLDR (UNCURRY f) a (foldi (λk v a. (k,v)::a) n ls t)``, + Induct >> simp[foldi_def] >> + rw[] >> pop_assum(assume_tac o GSYM) >> simp[]) + +val foldi_FOLDR_toAList = store_thm("foldi_FOLDR_toAList", + ``∀f a t. foldi f 0 a t = FOLDR (UNCURRY f) a (toAList t)``, + simp[toAList_def,GSYM foldi_FOLDR_toAList_lemma]) + val toListA_def = Define` (toListA acc LN = acc) /\ (toListA acc (LS a) = a::acc) /\ From 2a779459578de3a7aa61cc5140baf18d6aad18e5 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Wed, 7 Jan 2015 22:36:09 +1100 Subject: [PATCH 086/718] prove the keys of toAList of an sptree are ALL_DISTINCT --- src/patricia/sptreeScript.sml | 125 ++++++++++++++++++++++++++++++++++ 1 file changed, 125 insertions(+) diff --git a/src/patricia/sptreeScript.sml b/src/patricia/sptreeScript.sml index 5001a288b6..1a7c9703cd 100644 --- a/src/patricia/sptreeScript.sml +++ b/src/patricia/sptreeScript.sml @@ -611,6 +611,131 @@ val domain_empty = store_thm("domain_empty", ``!t. wf t ==> ((t = LN) <=> (domain t = EMPTY))``, simp[] >> Induct >> simp[wf_def] >> metis_tac[]) +val toAList_append = prove( + ``∀t n ls. + foldi (λk v a. (k,v)::a) n ls t = + foldi (λk v a. (k,v)::a) n [] t ++ ls``, + Induct + >- simp[foldi_def] + >- simp[foldi_def] + >- ( + simp_tac std_ss [foldi_def,LET_THM] >> rpt gen_tac >> + first_assum(fn th => + CONV_TAC(LAND_CONV(RATOR_CONV(RAND_CONV(REWR_CONV th))))) >> + first_assum(fn th => + CONV_TAC(LAND_CONV(REWR_CONV th))) >> + first_assum(fn th => + CONV_TAC(RAND_CONV(LAND_CONV(REWR_CONV th)))) >> + metis_tac[APPEND_ASSOC] ) >> + simp_tac std_ss [foldi_def,LET_THM] >> rpt gen_tac >> + first_assum(fn th => + CONV_TAC(LAND_CONV(RATOR_CONV(RAND_CONV(RAND_CONV(REWR_CONV th)))))) >> + first_assum(fn th => + CONV_TAC(LAND_CONV(REWR_CONV th))) >> + first_assum(fn th => + CONV_TAC(RAND_CONV(LAND_CONV(REWR_CONV th)))) >> + metis_tac[APPEND_ASSOC,APPEND] ) + +val toAList_inc = prove( + ``∀t n. + foldi (λk v a. (k,v)::a) n [] t = + MAP (λ(k,v). (n + lrnext n * k,v)) (foldi (λk v a. (k,v)::a) 0 [] t)``, + Induct + >- simp[foldi_def] + >- simp[foldi_def] + >- ( + simp_tac std_ss [foldi_def,LET_THM] >> rpt gen_tac >> + CONV_TAC(LAND_CONV(REWR_CONV toAList_append)) >> + CONV_TAC(RAND_CONV(RAND_CONV(REWR_CONV toAList_append))) >> + first_assum(fn th => + CONV_TAC(LAND_CONV(LAND_CONV(REWR_CONV th)))) >> + first_assum(fn th => + CONV_TAC(LAND_CONV(RAND_CONV(REWR_CONV th)))) >> + first_assum(fn th => + CONV_TAC(RAND_CONV(RAND_CONV(LAND_CONV(REWR_CONV th))))) >> + first_assum(fn th => + CONV_TAC(RAND_CONV(RAND_CONV(RAND_CONV(REWR_CONV th))))) >> + rpt(pop_assum kall_tac) >> + simp[MAP_MAP_o,combinTheory.o_DEF,APPEND_11_LENGTH] >> + simp[MAP_EQ_f] >> + simp[lrnext_thm,pairTheory.UNCURRY,pairTheory.FORALL_PROD] >> + simp[lrlemma1,lrlemma2] ) + >- ( + simp_tac std_ss [foldi_def,LET_THM] >> rpt gen_tac >> + CONV_TAC(LAND_CONV(REWR_CONV toAList_append)) >> + CONV_TAC(RAND_CONV(RAND_CONV(REWR_CONV toAList_append))) >> + first_assum(fn th => + CONV_TAC(LAND_CONV(LAND_CONV(REWR_CONV th)))) >> + first_assum(fn th => + CONV_TAC(LAND_CONV(RAND_CONV(RAND_CONV(REWR_CONV th))))) >> + first_assum(fn th => + CONV_TAC(RAND_CONV(RAND_CONV(LAND_CONV(REWR_CONV th))))) >> + first_assum(fn th => + CONV_TAC(RAND_CONV(RAND_CONV(RAND_CONV(RAND_CONV(REWR_CONV th)))))) >> + rpt(pop_assum kall_tac) >> + simp[MAP_MAP_o,combinTheory.o_DEF,APPEND_11_LENGTH] >> + simp[MAP_EQ_f] >> + simp[lrnext_thm,pairTheory.UNCURRY,pairTheory.FORALL_PROD] >> + simp[lrlemma1,lrlemma2] )) + +val lemmas = prove( + ``(∀x. EVEN (2 * x + 2)) ∧ + (∀x. ODD (2 * x + 1))``, + conj_tac >- ( + simp[EVEN_EXISTS] >> rw[] >> + qexists_tac`SUC x` >> simp[] ) >> + simp[ODD_EXISTS,ADD1] >> + metis_tac[] ) + +val ALL_DISTINCT_MAP_FST_toAList = store_thm("ALL_DISTINCT_MAP_FST_toAList", + ``∀t. ALL_DISTINCT (MAP FST (toAList t))``, + simp[toAList_def] >> + Induct >> simp[foldi_def] >- ( + CONV_TAC(RAND_CONV(RAND_CONV(RATOR_CONV(RAND_CONV(REWR_CONV toAList_inc))))) >> + CONV_TAC(RAND_CONV(RAND_CONV(REWR_CONV toAList_append))) >> + CONV_TAC(RAND_CONV(RAND_CONV(LAND_CONV(REWR_CONV toAList_inc)))) >> + simp[MAP_MAP_o,combinTheory.o_DEF,pairTheory.UNCURRY,lrnext_thm] >> + simp[ALL_DISTINCT_APPEND] >> + rpt conj_tac >- ( + qmatch_abbrev_tac`ALL_DISTINCT (MAP f ls)` >> + `MAP f ls = MAP (λx. 2 * x + 1) (MAP FST ls)` by ( + simp[MAP_MAP_o,combinTheory.o_DEF,Abbr`f`] ) >> + pop_assum SUBST1_TAC >> qunabbrev_tac`f` >> + match_mp_tac ALL_DISTINCT_MAP_INJ >> + simp[] ) + >- ( + qmatch_abbrev_tac`ALL_DISTINCT (MAP f ls)` >> + `MAP f ls = MAP (λx. 2 * x + 2) (MAP FST ls)` by ( + simp[MAP_MAP_o,combinTheory.o_DEF,Abbr`f`] ) >> + pop_assum SUBST1_TAC >> qunabbrev_tac`f` >> + match_mp_tac ALL_DISTINCT_MAP_INJ >> + simp[] ) >> + simp[MEM_MAP,PULL_EXISTS,pairTheory.EXISTS_PROD] >> + metis_tac[ODD_EVEN,lemmas] ) >> + gen_tac >> + CONV_TAC(RAND_CONV(RAND_CONV(RATOR_CONV(RAND_CONV(RAND_CONV(REWR_CONV toAList_inc)))))) >> + CONV_TAC(RAND_CONV(RAND_CONV(REWR_CONV toAList_append))) >> + CONV_TAC(RAND_CONV(RAND_CONV(LAND_CONV(REWR_CONV toAList_inc)))) >> + simp[MAP_MAP_o,combinTheory.o_DEF,pairTheory.UNCURRY,lrnext_thm] >> + simp[ALL_DISTINCT_APPEND] >> + rpt conj_tac >- ( + qmatch_abbrev_tac`ALL_DISTINCT (MAP f ls)` >> + `MAP f ls = MAP (λx. 2 * x + 1) (MAP FST ls)` by ( + simp[MAP_MAP_o,combinTheory.o_DEF,Abbr`f`] ) >> + pop_assum SUBST1_TAC >> qunabbrev_tac`f` >> + match_mp_tac ALL_DISTINCT_MAP_INJ >> + simp[] ) + >- ( simp[MEM_MAP] ) + >- ( + qmatch_abbrev_tac`ALL_DISTINCT (MAP f ls)` >> + `MAP f ls = MAP (λx. 2 * x + 2) (MAP FST ls)` by ( + simp[MAP_MAP_o,combinTheory.o_DEF,Abbr`f`] ) >> + pop_assum SUBST1_TAC >> qunabbrev_tac`f` >> + match_mp_tac ALL_DISTINCT_MAP_INJ >> + simp[] ) >> + simp[MEM_MAP,PULL_EXISTS,pairTheory.EXISTS_PROD] >> + metis_tac[ODD_EVEN,lemmas] ) + val _ = remove_ovl_mapping "lrnext" {Name = "lrnext", Thy = "sptree"} val foldi_FOLDR_toAList_lemma = prove( From 21853aa66f90cce48313ea2285e18adf5fdd971f Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 8 Jan 2015 12:32:46 +1100 Subject: [PATCH 087/718] Implement Q.MATCH_ASMSUB_RENAME_TAC. Progress with #81. --- src/q/Q.sig | 1 + src/q/Q.sml | 31 ++++++++++++++++++++++++------- src/q/selftest.sml | 16 ++++++++++++++++ 3 files changed, 41 insertions(+), 7 deletions(-) diff --git a/src/q/Q.sig b/src/q/Q.sig index a9b5f2473d..da0ec3bd51 100644 --- a/src/q/Q.sig +++ b/src/q/Q.sig @@ -62,5 +62,6 @@ sig val MATCH_RENAME_TAC : tmquote -> string list -> tactic val MATCH_ASSUM_RENAME_TAC : tmquote -> string list -> tactic val MATCH_GOALSUB_RENAME_TAC : tmquote -> string list -> tactic + val MATCH_ASMSUB_RENAME_TAC : tmquote -> string list -> tactic end diff --git a/src/q/Q.sml b/src/q/Q.sml index 344deb3b29..ef8486eeed 100644 --- a/src/q/Q.sml +++ b/src/q/Q.sml @@ -383,11 +383,10 @@ fun MATCH_ASSUM_RENAME_TAC q except (g as (asl,t)) = let handle HOL_ERR e => find tl in find asl end g -fun MATCH_GOALSUB_RENAME_TAC q except (g as (asl, t)) = let - val ERR = ERR "MATCH_GOALSUB_RENAME_TAC" - val fvs = free_varsl (t::asl) - val pat = Parse.parse_in_context fvs q - val fvs_set = HOLset.fromList Term.compare fvs +(* needs to be eta-expanded so that the possible HOL_ERRs are raised + when applied to a goal, not before, thereby letting FIRST_ASSUM catch + the exception *) +fun subterm_rename_helper except ERR pat fvs fvs_set t g = let fun test (bvs, subt) = case Lib.total (fn t => raw_match [] fvs_set pat t ([],[])) subt of SOME ((theta0, _), _) => @@ -402,8 +401,26 @@ fun MATCH_GOALSUB_RENAME_TAC q except (g as (asl, t)) = let | NONE => NONE in case gen_find_term test t of - SOME theta => make_rename_tac theta fvs except ERR g - | NONE => raise ERR "No matching sub-term found in goal term" + SOME theta => make_rename_tac theta fvs except ERR + | NONE => raise ERR "No matching sub-term found" +end g + +fun MATCH_GOALSUB_RENAME_TAC q except (g as (asl, t)) = let + val ERR = ERR "MATCH_GOALSUB_RENAME_TAC" + val fvs = free_varsl (t::asl) + val pat = Parse.parse_in_context fvs q + val fvs_set = HOLset.fromList Term.compare fvs +in + subterm_rename_helper except ERR pat fvs fvs_set t g +end + +fun MATCH_ASMSUB_RENAME_TAC q except (g as (asl, t)) = let + val ERR = ERR "MATCH_ASMSUB_RENAME_TAC" + val fvs = free_varsl (t::asl) + val fvs_set = HOLset.fromList Term.compare fvs + val pat = Parse.parse_in_context fvs q +in + FIRST_ASSUM (subterm_rename_helper except ERR pat fvs fvs_set o concl) g end end (* Q *) diff --git a/src/q/selftest.sml b/src/q/selftest.sml index 2ebf54635a..f61038184d 100644 --- a/src/q/selftest.sml +++ b/src/q/selftest.sml @@ -58,4 +58,20 @@ val _ = case sgs of else die "FAILED!" | _ => die "FAILED!" +val _ = tprint "Q.MATCH_ASMSUB_RENAME_TAC 1" +val gl3 = ([``P (x:num): bool``, ``Q (x < SUC (SUC (SUC zero))) : bool``], + ``x + y < SUC (SUC zero)``); +val expected_a1 = ``P (x:num) : bool`` +val expected_a2 = ``Q (x < n) : bool`` +val expected_c = ``x + y < SUC (SUC zero)`` +val (sgs, _) = Q.MATCH_ASMSUB_RENAME_TAC `x < n` [] gl3 +val _ = case sgs of + [([a1, a2], c)] => if aconv a1 expected_a1 andalso + aconv a2 expected_a2 andalso + aconv c expected_c + then + print "OK\n" + else die "FAILED!" + | _ => die "FAILED!" + val _ = Process.exit Process.success; From 597f0957bbb9df48ad7597f28efdcb5f097fd2af Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 8 Jan 2015 12:34:47 +1100 Subject: [PATCH 088/718] Remove non-exhaustive match warning by slight code rewrite --- src/1/Tactical.sml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/1/Tactical.sml b/src/1/Tactical.sml index df16a57174..c06accdc18 100644 --- a/src/1/Tactical.sml +++ b/src/1/Tactical.sml @@ -222,7 +222,9 @@ fun op THEN1 (tac1: tactic, tac2: tactic) : tactic = (counting goals from 1) *---------------------------------------------------------------------------*) fun NTH_GOAL tac n gl1 = - let val (gl_before, g :: gl_after) = Lib.split_after (n-1) gl1 ; + let + val (gl_before, ggl_after) = Lib.split_after (n-1) gl1 + val (g, gl_after) = valOf (List.getItem ggl_after) val (gl2, vf2) = tac g ; val gl_result = gl_before @ gl2 @ gl_after ; fun vf thl = From 3118e6a78a9c8590859c5ae40ee54bdf14a16b9a Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 8 Jan 2015 12:35:13 +1100 Subject: [PATCH 089/718] Remove trailing whitespace in Tactical.sml --- src/1/Tactical.sml | 32 ++++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/src/1/Tactical.sml b/src/1/Tactical.sml index c06accdc18..5d7145fcbd 100644 --- a/src/1/Tactical.sml +++ b/src/1/Tactical.sml @@ -384,8 +384,8 @@ end * VALIDATE tac * GEN_VALIDATE true tac * - * is the same as "tac", except that where "tac" returns a proof which is - * because if proves a theorem with extra hypotheses, it returns those + * is the same as "tac", except that where "tac" returns a proof which is + * because if proves a theorem with extra hypotheses, it returns those * hypotheses as extra goals * * VALIDATE_LT ltac @@ -395,21 +395,21 @@ end * necessary to make a valid list-tactic * * GEN_VALIDATE(_LT) false always returns extra goals corresponding - * to the hypotheses of the theorem proved + * to the hypotheses of the theorem proved * *---------------------------------------------------------------------------*) local val validity_tag = "ValidityCheck" fun masquerade goal = Thm.mk_oracle_thm validity_tag goal ; fun achieves_concl th (asl, w) = Term.aconv (concl th) w ; - fun hyps_not_in_goal th (asl, w) = + fun hyps_not_in_goal th (asl, w) = Lib.filter (fn h => not (Lib.exists (aconv h) asl)) (hyp th) ; - fun extra_goals_tbp flag th (asl, w) = - List.map (fn eg => (asl, eg)) + fun extra_goals_tbp flag th (asl, w) = + List.map (fn eg => (asl, eg)) (case flag of true => hyps_not_in_goal th (asl, w) | false => hyp th) ; in (* GEN_VALIDATE : bool -> tactic -> tactic *) -fun GEN_VALIDATE (flag : bool) (tac : tactic) (g as (asl, w) : goal) = +fun GEN_VALIDATE (flag : bool) (tac : tactic) (g as (asl, w) : goal) = let val (glist, prf) = tac g ; (* pretend new goals are theorems, and apply validation to them *) val thprf = (prf (map masquerade glist)) ; @@ -425,21 +425,21 @@ fun GEN_VALIDATE (flag : bool) (tac : tactic) (g as (asl, w) : goal) = in (extra_goals @ glist, eprf) end ; (* split_lists : int list -> 'a list -> 'a list list * 'a list *) -fun split_lists (n :: ns) ths = +fun split_lists (n :: ns) ths = let val (nths, rest) = split_after n ths ; val (nsths, left) = split_lists ns rest ; - in (nths :: nsths, left) end + in (nths :: nsths, left) end | split_lists [] ths = ([], ths) ; - + (* GEN_VALIDATE_LT : bool -> list_tactic -> list_tactic *) -fun GEN_VALIDATE_LT (flag : bool) (ltac : list_tactic) (gl : goal list) = +fun GEN_VALIDATE_LT (flag : bool) (ltac : list_tactic) (gl : goal list) = let val (glist, prf) = ltac gl ; (* pretend new goals are theorems, and apply validation to them *) val thsprf = (prf (map masquerade glist)) ; val _ = if Lib.all2 achieves_concl thsprf gl then () - else raise ERR "GEN_VALIDATE_LT" + else raise ERR "GEN_VALIDATE_LT" "Invalid list-tactic - some wrong conclusion" ; - val extra_goal_lists = Lib.map2 (extra_goals_tbp flag) thsprf gl ; + val extra_goal_lists = Lib.map2 (extra_goals_tbp flag) thsprf gl ; val nextras = map length extra_goal_lists ; (* new validation: apply the theorems proving the additional goals to eliminate the extra hyps in the theorems proved by the given validation *) @@ -454,7 +454,7 @@ val VALIDATE = GEN_VALIDATE true ; val VALIDATE_LT = GEN_VALIDATE_LT true ; (* could avoid duplication of code in the above by the following -fun GEN_VALIDATE flag tac = +fun GEN_VALIDATE flag tac = ALL_TAC THEN_LT GEN_VALIDATE_LT flag (TACS_TO_LT [tac]) ; *) @@ -521,7 +521,7 @@ end (*-- Tactical quantifiers -- Apply a list of tactics in succession. -------*) (*--------------------------------------------------------------------------- - * Uses every tactic (similarly EVERY_LT for list_tactics) + * Uses every tactic (similarly EVERY_LT for list_tactics) * EVERY [TAC1;...;TACn] = TAC1 THEN ... THEN TACn *---------------------------------------------------------------------------*) @@ -641,7 +641,7 @@ fun USE_SG_THEN ttac nu np gl = (* USE_SG_TAC : int -> int -> list_tactic val USE_SG_TAC = USE_SG_THEN ASSUME_TAC ; -*) +*) (*--------------------------------------------------------------------------- * A tactical that makes a tactic fail if it has no effect. From 904bab9db4860a0a21bfe0b97a833f25c0f05d27 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 8 Jan 2015 13:42:12 +1100 Subject: [PATCH 090/718] Move useful apnth function to Lib Also make it raise a HOL_ERR rather than a Bind error if the index is negative or greater than the length of the list. --- src/1/Tactical.sml | 5 ----- src/prekernel/Lib.sig | 1 + src/prekernel/Lib.sml | 6 ++++++ 3 files changed, 7 insertions(+), 5 deletions(-) diff --git a/src/1/Tactical.sml b/src/1/Tactical.sml index 5d7145fcbd..280f8b9346 100644 --- a/src/1/Tactical.sml +++ b/src/1/Tactical.sml @@ -620,11 +620,6 @@ fun SUBGOAL_THEN wa ttac (asl, w) = * assumes subgoal number nu for proving subgoal number np *---------------------------------------------------------------------------*) -(* apnth : ('a -> 'a) -> int -> 'a list -> 'a list - apply a function to the nth member of a list *) -fun apnth f 0 (y :: ys) = f y :: ys - | apnth f n (y :: ys) = y :: apnth f (n-1) ys ; - (* USE_SG_VAL : int -> int -> list_validation *) fun USE_SG_VAL nu np thl = let val thu = List.nth (thl, nu - 1) ; diff --git a/src/prekernel/Lib.sig b/src/prekernel/Lib.sig index a8fa3b71bc..f6165539b3 100644 --- a/src/prekernel/Lib.sig +++ b/src/prekernel/Lib.sig @@ -21,6 +21,7 @@ sig val apfst : ('a -> 'b) -> 'a * 'c -> 'b * 'c val append : 'a list -> 'a list -> 'a list val appi : (int -> 'a -> unit) -> 'a list -> unit + val apnth : ('a -> 'a) -> int -> 'a list -> 'a list val apsnd : ('a -> 'b) -> 'c * 'a -> 'c * 'b val assert : ('a -> bool) -> 'a -> 'a val assert_exn : ('a -> bool) -> 'a -> exn -> 'a diff --git a/src/prekernel/Lib.sml b/src/prekernel/Lib.sml index b4c57bd066..818a74cc40 100644 --- a/src/prekernel/Lib.sml +++ b/src/prekernel/Lib.sml @@ -354,6 +354,12 @@ fun appi f = recurse 0 end +(* apnth : ('a -> 'a) -> int -> 'a list -> 'a list + apply a function to the nth member of a list *) +fun apnth f 0 (y :: ys) = f y :: ys + | apnth f n (y :: ys) = y :: apnth f (n-1) ys + | apnth f n [] = raise ERR "apnth" "list too short (or -ve index)" + fun mapi f lst = let fun recurse n acc lst = From 754a85197ece05d2a55775a0738a3f1796b143e0 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 8 Jan 2015 13:57:13 +1100 Subject: [PATCH 091/718] Add regression test for issue #214 --- src/1/selftest.sml | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/1/selftest.sml b/src/1/selftest.sml index 78ef115b89..2c0d5ff408 100644 --- a/src/1/selftest.sml +++ b/src/1/selftest.sml @@ -496,5 +496,9 @@ in else die "FAILED" end +val _ = tprint "Testing (foo THENL [...]) when foo solves" +val _ = (ACCEPT_TAC TRUTH THENL [ACCEPT_TAC TRUTH]) ([], ``T``) handle HOL_ERR _ => die "FAILED!" +val _ = print "OK\n" + val _ = Process.exit (if List.all substtest tests then Process.success else Process.failure) From 521a5421bb3372631fb914cc889037810ac6afb8 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 8 Jan 2015 14:01:56 +1100 Subject: [PATCH 092/718] Remove trailing whitespace in proofman/goalStack.sml --- src/proofman/goalStack.sml | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/src/proofman/goalStack.sml b/src/proofman/goalStack.sml index a8460e134f..f4c9cb6bb9 100644 --- a/src/proofman/goalStack.sml +++ b/src/proofman/goalStack.sml @@ -111,8 +111,8 @@ fun rotate(GSTK{prop=PROVED _, ...}) _ = stack={goals=funpow n rotl goals, validation=validation o funpow n rotr} :: rst}; -local - fun imp_err s = +local + fun imp_err s = raise ERR "expandf or expand_listf" ("implementation error: "^s) fun return(GSTK{stack={goals=[],validation}::rst, prop as POSED g,final}) = @@ -165,7 +165,7 @@ fun expand_listf ltac (GSTK{prop=PROVED _, ...}) = raise ERR "expand_listf" "goal has already been proved" | expand_listf ltac (GSTK{prop as POSED g, stack = [], final}) = expand_listf ltac (GSTK{prop = POSED g, - stack = [{goals = [g], validation = hd}], final = final}) + stack = [{goals = [g], validation = hd}], final = final}) | expand_listf ltac (GSTK{prop, stack as {goals,validation}::rst, final}) = let val (new_goals, new_vf) = ltac goals val dpth = length stack - 1 (* because we don't augment the stack *) @@ -177,21 +177,21 @@ end ; fun expand tac gs = expandf (Tactical.VALID tac) gs; fun expand_list ltac gs = expand_listf (Tactical.VALID_LT ltac) gs; -fun flat (GSTK{prop, stack as {goals,validation} :: - {goals = g2 :: goals2, validation = validation2} :: rst, final}) = - let fun v thl = +fun flat (GSTK{prop, stack as {goals,validation} :: + {goals = g2 :: goals2, validation = validation2} :: rst, final}) = + let fun v thl = let val (thl1, thl2) = Lib.split_after (length goals) thl ; in validation2 (validation thl1 :: thl2) end ; val newgv = {goals = goals @ goals2, validation = v} ; in GSTK {prop = prop, stack = newgv :: rst, final = final} end ; - + fun flatn (GSTK{prop=PROVED _, ...}) n = raise ERR "flatn" "goal has already been proved" | flatn gstk 0 = gstk | flatn (gstk as GSTK{prop, stack = [], final}) n = gstk - | flatn (gstk as GSTK{prop, stack as [_], final}) n = gstk + | flatn (gstk as GSTK{prop, stack as [_], final}) n = gstk | flatn (gstk as GSTK{prop, stack, final}) n = flatn (flat gstk) (n-1) ; - + fun extract_thm (GSTK{prop=PROVED(th,_), ...}) = th | extract_thm _ = raise ERR "extract_thm" "no theorem proved"; From 144b3bd24e03582564d2c327d74d7bd30d15cb1c Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 8 Jan 2015 14:09:28 +1100 Subject: [PATCH 093/718] Reformat goalStack.sml's flat function to avoid non-exhaustive match warning --- src/proofman/goalStack.sml | 25 ++++++++++++++++++------- 1 file changed, 18 insertions(+), 7 deletions(-) diff --git a/src/proofman/goalStack.sml b/src/proofman/goalStack.sml index f4c9cb6bb9..b5b9779655 100644 --- a/src/proofman/goalStack.sml +++ b/src/proofman/goalStack.sml @@ -177,13 +177,24 @@ end ; fun expand tac gs = expandf (Tactical.VALID tac) gs; fun expand_list ltac gs = expand_listf (Tactical.VALID_LT ltac) gs; -fun flat (GSTK{prop, stack as {goals,validation} :: - {goals = g2 :: goals2, validation = validation2} :: rst, final}) = - let fun v thl = - let val (thl1, thl2) = Lib.split_after (length goals) thl ; - in validation2 (validation thl1 :: thl2) end ; - val newgv = {goals = goals @ goals2, validation = v} ; - in GSTK {prop = prop, stack = newgv :: rst, final = final} end ; +fun flat gstk = + case gstk of + GSTK{prop, + stack as {goals,validation} :: + {goals = g2 :: goals2, validation = validation2} :: + rst, + final} => + let + fun v thl = let + val (thl1, thl2) = Lib.split_after (length goals) thl + in + validation2 (validation thl1 :: thl2) + end + val newgv = {goals = goals @ goals2, validation = v} + in + GSTK {prop = prop, stack = newgv :: rst, final = final} + end + | _ => raise ERR "flat" "goalstack in wrong shape" fun flatn (GSTK{prop=PROVED _, ...}) n = raise ERR "flatn" "goal has already been proved" From a2d8c621ac33dcc09b020ff68f04cb398a2e7771 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 8 Jan 2015 14:11:40 +1100 Subject: [PATCH 094/718] Modify optionSyntax.dest_none to unwrap the type returned. Closes #215. --- doc/next-release.md | 2 ++ src/option/Holmakefile | 10 ++++++++++ src/option/optionSyntax.sml | 4 +++- src/option/selftest.sml | 9 +++++++++ 4 files changed, 24 insertions(+), 1 deletion(-) create mode 100644 src/option/Holmakefile create mode 100644 src/option/selftest.sml diff --git a/doc/next-release.md b/doc/next-release.md index aaf23c84c6..4fe687c67f 100644 --- a/doc/next-release.md +++ b/doc/next-release.md @@ -39,6 +39,8 @@ New examples: Incompatibilities: ------------------ +- The function `optionSyntax.dest_none` will now unwrap the type of its result, *e.g.*, returning `:α` rather than `:α option` when applied to `NONE : α option`. This brings it into line with the behaviour of `listSyntax.dest_nil`. See [this github issue](https://github.com/HOL-Theorem-Prover/HOL/issues/215). + * * * * *
diff --git a/src/option/Holmakefile b/src/option/Holmakefile new file mode 100644 index 0000000000..8c4fba2bec --- /dev/null +++ b/src/option/Holmakefile @@ -0,0 +1,10 @@ +EXTRA_CLEANS = selftest.exe + +THYFILES = $(patsubst %Script.sml,%Theory.uo,$(wildcard *.sml)) +TARGETS = $(patsubst %.sml,%.uo,$(THYFILES)) + +all: $(TARGETS) selftest.exe +.PHONY: all + +selftest.exe: selftest.uo optionSyntax.uo optionTheory.uo $(dprot $(SIGOBJ)/testutils.uo) + $(HOLMOSMLC) -o $@ $< diff --git a/src/option/optionSyntax.sml b/src/option/optionSyntax.sml index 1913fb2955..38a45a29c8 100644 --- a/src/option/optionSyntax.sml +++ b/src/option/optionSyntax.sml @@ -77,7 +77,9 @@ fun mk_option_case (n,s,p) = ---------------------------------------------------------------------------*) fun dest_none tm = - if same_const none_tm tm then type_of tm else raise ERR "dest_none" ""; + if same_const none_tm tm then + hd (#2 (dest_type (type_of tm))) + else raise ERR "dest_none" ""; val dest_some = dest_monop some_tm (ERR "dest_some" "") val dest_the = dest_monop the_tm (ERR "dest_the" "") diff --git a/src/option/selftest.sml b/src/option/selftest.sml new file mode 100644 index 0000000000..78c7e067bb --- /dev/null +++ b/src/option/selftest.sml @@ -0,0 +1,9 @@ +open HolKernel optionSyntax testutils + +val alpha_option_ty = mk_option alpha +val alphanone_t = mk_thy_const{Thy = "option", Name = "NONE", Ty = alpha_option_ty} + +val _ = tprint "dest_none returns unwrapped type" +val ty = dest_none alphanone_t +val _ = if Type.compare(ty, alpha) = EQUAL then print "OK\n" + else die "FAILED!" From 94c5f179b9764659335d5fd81d78fc92d4d51ad4 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 8 Jan 2015 15:30:47 +1100 Subject: [PATCH 095/718] Fix text-filling from commit acbc902f * It was too aggressive and broke a verbatim {...} over two lines, which is forbidden (in LaTeX). * It wasn't particularly good for the \COMMENTS section --- help/Docfiles/Q.MATCH_ASSUM_RENAME_TAC.doc | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/help/Docfiles/Q.MATCH_ASSUM_RENAME_TAC.doc b/help/Docfiles/Q.MATCH_ASSUM_RENAME_TAC.doc index f0ca09e070..7c81744b3b 100644 --- a/help/Docfiles/Q.MATCH_ASSUM_RENAME_TAC.doc +++ b/help/Docfiles/Q.MATCH_ASSUM_RENAME_TAC.doc @@ -34,8 +34,8 @@ If the current goal is { (f x = Pair C'' C0') ?- (f C'' = f C0') } -then applying the tactic {Q.MATCH_ASSUM_RENAME_TAC `X = Pair c1 c2` -["X"]} results in the goal +then applying the tactic {Q.MATCH_ASSUM_RENAME_TAC `X = Pair c1 c2` ["X"]} +results in the goal { (f x = Pair c1 c2) ?- (f c1 = f c2) } @@ -43,7 +43,8 @@ then applying the tactic {Q.MATCH_ASSUM_RENAME_TAC `X = Pair c1 c2` \COMMENTS This tactic improves on the following tedious workflow: -{Q.PAT_ASSUM pat MP_TAC}, {Q.MATCH_ABBREV_TAC `pat ==> X`}, {Q.UNABBREV_TAC `X`}, {markerLib.RM_ALL_ABBREVS_TAC}, {STRIP_TAC}. +{Q.PAT_ASSUM pat MP_TAC}, {Q.MATCH_ABBREV_TAC `pat ==> X`}, +{Q.UNABBREV_TAC `X`}, {markerLib.RM_ALL_ABBREVS_TAC}, {STRIP_TAC}. \SEEALSO Q.MATCH_RENAME_TAC. From 8d79ce8fec6224a829ccf36c29048502708e8003 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 8 Jan 2015 15:32:21 +1100 Subject: [PATCH 096/718] Document MATCH_ASMSUB_RENAME_TAC. Progress with #81 --- help/Docfiles/Q.MATCH_ASMSUB_RENAME_TAC.doc | 49 +++++++++++++++++++++ 1 file changed, 49 insertions(+) create mode 100644 help/Docfiles/Q.MATCH_ASMSUB_RENAME_TAC.doc diff --git a/help/Docfiles/Q.MATCH_ASMSUB_RENAME_TAC.doc b/help/Docfiles/Q.MATCH_ASMSUB_RENAME_TAC.doc new file mode 100644 index 0000000000..20bc426d9e --- /dev/null +++ b/help/Docfiles/Q.MATCH_ASMSUB_RENAME_TAC.doc @@ -0,0 +1,49 @@ +\DOC + +\TYPE {MATCH_ASMSUB_RENAME_TAC : term quotation -> string list -> tactic} + +\SYNOPSIS +Finds a match for a pattern in assumptions; instantiates goal to rename or abbreviate. + +\DESCRIBE + +When applied to the goal {(asl,w)}, the tactic +{Q.MATCH_ASMSUB_RENAME_TAC q ls} parses the quotation {q} in the +context of the goal, producing a term {pat} to use as a pattern. The +tactic then attempts a (first order) match of {pat} against each term +in {asl}, stopping when it finds an assumption that either matches +{pat} in its entirety, or has a sub-term that matches {pat} (holding +existing free variables from the goal constant). + +In either case, the match will return an instantiation mapping the +fresh free variables of {pat} to terms occurring in the goal. This +instantiation drops its bindings for variables whose names appear in +{ls}, is reversed, and is then applied to the goal. This will both +cause free variables in the goal to be renamed, and for larger terms +to be replaced by variables (similar to what happens with the use of +{SPEC_TAC}). + +\FAILURE + +Fails if there is no valid match for the pattern among the assumptions +and their sub-terms. A valid match will not bind variables that are +bound in the assumption being searched. + +\EXAMPLE + +In the following example, the variable {x} is treated as if a +constant, so the search for a match with the pattern does not succeed +on the first assumption (featuring {P}). Instead the second assumption +provides the instantiation, and so the variable {z} in the original is +renamed to {n}. +{ + > Q.MATCH_ASMSUB_RENAME_TAC `x < n` [] + ([``P(y < m):bool``, ``Q(x < z) : bool``], ``x + z < 10``); + val it = ([([``P (y < m)``, ``Q (x < n)``], ``x + n < 10``)], + fn): goal list * validation +} + +\SEEALSO +Q.MATCH_ASSUM_RENAME_TAC, Q.MATCH_GOALSUB_RENAME_TAC. + +\ENDDOC From 95b436c9ff08629de96414ccbdf5616251c32d06 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 8 Jan 2015 15:57:01 +1100 Subject: [PATCH 097/718] Document new FIND_CASE_TAC. --- help/Docfiles/Q.FIND_CASE_TAC.doc | 38 +++++++++++++++++++++++++++++++ src/q/Q.sig | 1 + src/q/Q.sml | 4 ++++ 3 files changed, 43 insertions(+) create mode 100644 help/Docfiles/Q.FIND_CASE_TAC.doc diff --git a/help/Docfiles/Q.FIND_CASE_TAC.doc b/help/Docfiles/Q.FIND_CASE_TAC.doc new file mode 100644 index 0000000000..75e7ae5db7 --- /dev/null +++ b/help/Docfiles/Q.FIND_CASE_TAC.doc @@ -0,0 +1,38 @@ +\DOC + +\TYPE {FIND_CASE_TAC : term quotation -> string list -> tactic} + +\SYNOPSIS +Finds an instance of a pattern in a goal, and renames to use names from the pattern + +\KEYWORDS + +\DESCRIBE +The tactic {Q.FIND_CASE_TAC pat sl} is defined to be +{ + MATCH_RENAME_TAC q sl ORELSE MATCH_ASSUM_RENAME_TAC q sl ORELSE + MATCH_GOALSUB_RENAME_TAC q sl ORELSE MATCH_ASMSUB_RENAME_TAC q sl +} + + +\FAILURE +Fails if all of the constituent tactics fail. + + +\COMMENTS +This tactic can be used to force a particular set of names on a goal, +hopefully making the resulting tactic more robust in the face of +underlying implementation changes. Note though that successful use of +this tactic requires that the ``new'' names in the provided pattern +really be fresh for the goal. If one is really uncertain about what +names might be appearing in a goal, this condition may be difficult to +ensure. + +The name is derived from the fact that this tactic can be used to +ensure that it is being applied to a particular case in a proof that +has branched. + +\SEEALSO +Q.MATCH_ASMSUB_RENAME_TAC, Q.MATCH_ASSUM_RENAME_TAC, Q.MATCH_GOALSUB_RENAME_TAC, Q.MATCH_RENAME_TAC. + +\ENDDOC diff --git a/src/q/Q.sig b/src/q/Q.sig index da0ec3bd51..871829c6f3 100644 --- a/src/q/Q.sig +++ b/src/q/Q.sig @@ -63,5 +63,6 @@ sig val MATCH_ASSUM_RENAME_TAC : tmquote -> string list -> tactic val MATCH_GOALSUB_RENAME_TAC : tmquote -> string list -> tactic val MATCH_ASMSUB_RENAME_TAC : tmquote -> string list -> tactic + val FIND_CASE_TAC : tmquote -> string list -> tactic end diff --git a/src/q/Q.sml b/src/q/Q.sml index ef8486eeed..8fad6cfe41 100644 --- a/src/q/Q.sml +++ b/src/q/Q.sml @@ -423,4 +423,8 @@ in FIRST_ASSUM (subterm_rename_helper except ERR pat fvs fvs_set o concl) g end +fun FIND_CASE_TAC q sl = + MATCH_RENAME_TAC q sl ORELSE MATCH_ASSUM_RENAME_TAC q sl ORELSE + MATCH_GOALSUB_RENAME_TAC q sl ORELSE MATCH_ASMSUB_RENAME_TAC q sl + end (* Q *) From 843f04ff3f96447ad670ce6c742c34e68dcd06bd Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 8 Jan 2015 15:59:54 +1100 Subject: [PATCH 098/718] Provide lcsymtacs bindings for recent additions to Q module. --- src/boss/lcsymtacs.sig | 3 +++ src/boss/lcsymtacs.sml | 3 +++ 2 files changed, 6 insertions(+) diff --git a/src/boss/lcsymtacs.sig b/src/boss/lcsymtacs.sig index a923b0b224..229ee06ac7 100644 --- a/src/boss/lcsymtacs.sig +++ b/src/boss/lcsymtacs.sig @@ -49,6 +49,9 @@ sig val qmatch_rename_tac : term quotation -> string list -> tactic val qmatch_assum_abbrev_tac : term quotation -> tactic val qmatch_assum_rename_tac : term quotation -> string list -> tactic + val qmatch_asmsub_rename_tac : term quotation -> string list -> tactic + val qmatch_goalsub_rename_tac : term quotation -> string list -> tactic + val qcase_tac : term quotation -> string list -> tactic val assume_tac : thm_tactic val strip_assume_tac : thm_tactic diff --git a/src/boss/lcsymtacs.sml b/src/boss/lcsymtacs.sml index e5cc713610..218bf35790 100644 --- a/src/boss/lcsymtacs.sml +++ b/src/boss/lcsymtacs.sml @@ -53,6 +53,9 @@ struct Q.MATCH_ASSUM_ABBREV_TAC val qmatch_assum_rename_tac : term quotation -> string list -> tactic = Q.MATCH_ASSUM_RENAME_TAC + val qmatch_asmsub_rename_tac = Q.MATCH_ASMSUB_RENAME_TAC + val qmatch_goalsub_rename_tac = Q.MATCH_GOALSUB_RENAME_TAC + val qcase_tac = Q.FIND_CASE_TAC val rule_assum_tac : (thm -> thm) -> tactic = Tactic.RULE_ASSUM_TAC val assume_tac : thm_tactic = Tactic.ASSUME_TAC From ab3b166e8879995cbd80cb8ca7b92b56e81cd6fb Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 9 Jan 2015 13:48:39 +1100 Subject: [PATCH 099/718] Fix a bug in Q.MATCH_{GOAL,ASM}SUB_RENAME_TAC The old code wouldn't allow a match to go through if the returned instantiation was empty, but some patterns don't have any free variables, so this was bogus. The new check is more careful: it requires the instantiation to be exactly the right size. --- src/q/Q.sml | 25 +++++++++++++++---------- src/q/selftest.sml | 11 +++++++++++ 2 files changed, 26 insertions(+), 10 deletions(-) diff --git a/src/q/Q.sml b/src/q/Q.sml index 8fad6cfe41..3df62d8315 100644 --- a/src/q/Q.sml +++ b/src/q/Q.sml @@ -386,7 +386,7 @@ in find asl end g (* needs to be eta-expanded so that the possible HOL_ERRs are raised when applied to a goal, not before, thereby letting FIRST_ASSUM catch the exception *) -fun subterm_rename_helper except ERR pat fvs fvs_set t g = let +fun subterm_rename_helper {except,thetasz,ERR,pat,fvs,fvs_set} t g = let fun test (bvs, subt) = case Lib.total (fn t => raw_match [] fvs_set pat t ([],[])) subt of SOME ((theta0, _), _) => @@ -396,7 +396,7 @@ fun subterm_rename_helper except ERR pat fvs fvs_set t g = let List.all (fn bv => not (free_in bv residue)) bvs val theta = filter (fn s => filt1 s andalso filt2 s) theta0 in - if null theta then NONE else SOME theta + if length theta <> thetasz then NONE else SOME theta end | NONE => NONE in @@ -405,22 +405,27 @@ in | NONE => raise ERR "No matching sub-term found" end g -fun MATCH_GOALSUB_RENAME_TAC q except (g as (asl, t)) = let - val ERR = ERR "MATCH_GOALSUB_RENAME_TAC" +fun prep_rename q except nm (asl, t) = let + val ERR = ERR nm val fvs = free_varsl (t::asl) val pat = Parse.parse_in_context fvs q val fvs_set = HOLset.fromList Term.compare fvs + val patfvs = free_vars pat + val pat_binds = + filter (fn v => not (mem v fvs) andalso not (mem (#1 (dest_var v)) except)) + patfvs in - subterm_rename_helper except ERR pat fvs fvs_set t g + {ERR = ERR, fvs = fvs, pat = pat, fvs_set = fvs_set, thetasz = length pat_binds, + except = except} end +fun MATCH_GOALSUB_RENAME_TAC q except (g as (asl, t)) = + subterm_rename_helper (prep_rename q except "MATCH_GOALSUB_RENAME_TAC" g) t g + fun MATCH_ASMSUB_RENAME_TAC q except (g as (asl, t)) = let - val ERR = ERR "MATCH_ASMSUB_RENAME_TAC" - val fvs = free_varsl (t::asl) - val fvs_set = HOLset.fromList Term.compare fvs - val pat = Parse.parse_in_context fvs q + val args = prep_rename q except "MATCH_ASMSUB_RENAME_TAC" g in - FIRST_ASSUM (subterm_rename_helper except ERR pat fvs fvs_set o concl) g + FIRST_ASSUM (subterm_rename_helper args o concl) g end fun FIND_CASE_TAC q sl = diff --git a/src/q/selftest.sml b/src/q/selftest.sml index f61038184d..cff81a14d2 100644 --- a/src/q/selftest.sml +++ b/src/q/selftest.sml @@ -58,6 +58,16 @@ val _ = case sgs of else die "FAILED!" | _ => die "FAILED!" +val _ = tprint "Q.MATCH_GOALSUB_RENAME_TAC 3" +val gl2a = ([] : term list, ``!x. x * SUC zero < z``) +val expected_result2a = #2 gl2a +val (sgs, _) = Q.MATCH_GOALSUB_RENAME_TAC `SUC` [] gl2a +val _ = case sgs of + [([], t)] => if aconv t expected_result2a then print "OK\n" + else die "FAILED!" + | _ => die "FAILED!" + + val _ = tprint "Q.MATCH_ASMSUB_RENAME_TAC 1" val gl3 = ([``P (x:num): bool``, ``Q (x < SUC (SUC (SUC zero))) : bool``], ``x + y < SUC (SUC zero)``); @@ -74,4 +84,5 @@ val _ = case sgs of else die "FAILED!" | _ => die "FAILED!" + val _ = Process.exit Process.success; From 92317114af81626c72675d63e4cb122ef4d15bd9 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 9 Jan 2015 16:22:16 +1100 Subject: [PATCH 100/718] Change API of Q's MATCH...RENAME_TACs. Now rather than a string list hanging off the end specifying which variable bindings aren't supposed to induce a renaming, just put underscores into the pattern in those positions. Documentation and release notes updated. --- doc/next-release.md | 12 +++ examples/parsing/NTpropertiesScript.sml | 2 +- examples/parsing/grammarScript.sml | 2 +- help/Docfiles/Q.FIND_CASE_TAC.doc | 11 +-- help/Docfiles/Q.MATCH_ASMSUB_RENAME_TAC.doc | 22 ++--- help/Docfiles/Q.MATCH_ASSUM_RENAME_TAC.doc | 18 ++-- help/Docfiles/Q.MATCH_GOALSUB_RENAME_TAC.doc | 19 ++-- help/Docfiles/Q.MATCH_RENAME_TAC.doc | 20 +++-- src/bag/bagScript.sml | 8 +- src/boss/lcsymtacs.sig | 10 +-- src/boss/lcsymtacs.sml | 4 +- src/finite_map/alistScript.sml | 20 ++--- src/finite_map/finite_mapScript.sml | 16 ++-- src/integer/int_bitwiseScript.sml | 2 +- src/list/src/listScript.sml | 2 +- src/num/theories/arithmeticScript.sml | 4 +- src/patricia/sptreeScript.sml | 8 +- src/q/Q.sig | 10 +-- src/q/Q.sml | 91 ++++++++++++-------- src/q/selftest.sml | 21 ++++- src/relation/relationScript.sml | 2 +- src/sort/sortingScript.sml | 2 +- 22 files changed, 176 insertions(+), 130 deletions(-) diff --git a/doc/next-release.md b/doc/next-release.md index 4fe687c67f..b21840a753 100644 --- a/doc/next-release.md +++ b/doc/next-release.md @@ -41,6 +41,18 @@ Incompatibilities: - The function `optionSyntax.dest_none` will now unwrap the type of its result, *e.g.*, returning `:α` rather than `:α option` when applied to `NONE : α option`. This brings it into line with the behaviour of `listSyntax.dest_nil`. See [this github issue](https://github.com/HOL-Theorem-Prover/HOL/issues/215). +- The functions `Q.MATCH_RENAME_TAC` and `Q.MATCH_ASSUM_RENAME_TAC` have been adjusted to lose their second arguments (the list of variable names that are not to be bound). For example, applying ``Q.MATCH_RENAME_TAC `(f x = Pair c1 c2) ⇒ X` ["X"]`` to the goal + + ?- (f x = Pair C'' C0') ⇒ (f C'' = f C0') + + used to result in the renamed goal + + ?- (f x = Pair c1 c2) ⇒ (f c1 = f c2) + + where the `X` in the pattern was ignored. The interface now achieves the same end by simply allowing the user to write underscores in the pattern. Thus, the tactic would become `Q.MATCH_RENAME_TAC `(f x = Pair c1 c2) ⇒ _`. Multiple underscores can be used to ignore multiple sub-terms. + + Of course, the `qmatch_rename_tac` and `qmatch_assum_rename_tac` names for these tactics in `lcsymtacs` have changed types as well. The new `Q.MATCH_GOALSUB_RENAME_TAC` and `Q.MATCH_ASMSUB_RENAME_TAC` (and their lower-case versions) have similar types, without explicit lists of variable names to ignore. + * * * * *
diff --git a/examples/parsing/NTpropertiesScript.sml b/examples/parsing/NTpropertiesScript.sml index 597d154af3..509508a9e2 100644 --- a/examples/parsing/NTpropertiesScript.sml +++ b/examples/parsing/NTpropertiesScript.sml @@ -6,7 +6,7 @@ open lcsymtacs open pred_setTheory val rveq = rpt BasicProvers.VAR_EQ_TAC -fun asm_match q = Q.MATCH_ASSUM_RENAME_TAC q [] +fun asm_match q = Q.MATCH_ASSUM_RENAME_TAC q val MAP_EQ_CONS = prove( ``(MAP f l = h::t) ⇔ ∃e es. l = e::es ∧ f e = h ∧ MAP f es = t``, diff --git a/examples/parsing/grammarScript.sml b/examples/parsing/grammarScript.sml index d49faf2886..4490e6ca33 100644 --- a/examples/parsing/grammarScript.sml +++ b/examples/parsing/grammarScript.sml @@ -6,7 +6,7 @@ open listTheory pred_setTheory finite_mapTheory val FLAT_APPEND = rich_listTheory.FLAT_APPEND val rveq = rpt BasicProvers.VAR_EQ_TAC -fun asm_match q = Q.MATCH_ASSUM_RENAME_TAC q [] +fun asm_match q = Q.MATCH_ASSUM_RENAME_TAC q val _ = new_theory "grammar" diff --git a/help/Docfiles/Q.FIND_CASE_TAC.doc b/help/Docfiles/Q.FIND_CASE_TAC.doc index 75e7ae5db7..375de5a14f 100644 --- a/help/Docfiles/Q.FIND_CASE_TAC.doc +++ b/help/Docfiles/Q.FIND_CASE_TAC.doc @@ -1,17 +1,18 @@ \DOC -\TYPE {FIND_CASE_TAC : term quotation -> string list -> tactic} +\TYPE {FIND_CASE_TAC : term quotation -> tactic} \SYNOPSIS -Finds an instance of a pattern in a goal, and renames to use names from the pattern +Finds an instance of a pattern in a goal, and renames to use names +from the pattern \KEYWORDS \DESCRIBE -The tactic {Q.FIND_CASE_TAC pat sl} is defined to be +The tactic {Q.FIND_CASE_TAC pat} is defined to be { - MATCH_RENAME_TAC q sl ORELSE MATCH_ASSUM_RENAME_TAC q sl ORELSE - MATCH_GOALSUB_RENAME_TAC q sl ORELSE MATCH_ASMSUB_RENAME_TAC q sl + MATCH_RENAME_TAC q ORELSE MATCH_ASSUM_RENAME_TAC q ORELSE + MATCH_GOALSUB_RENAME_TAC q ORELSE MATCH_ASMSUB_RENAME_TAC q } diff --git a/help/Docfiles/Q.MATCH_ASMSUB_RENAME_TAC.doc b/help/Docfiles/Q.MATCH_ASMSUB_RENAME_TAC.doc index 20bc426d9e..56d2f930dd 100644 --- a/help/Docfiles/Q.MATCH_ASMSUB_RENAME_TAC.doc +++ b/help/Docfiles/Q.MATCH_ASMSUB_RENAME_TAC.doc @@ -8,20 +8,20 @@ Finds a match for a pattern in assumptions; instantiates goal to rename or abbre \DESCRIBE When applied to the goal {(asl,w)}, the tactic -{Q.MATCH_ASMSUB_RENAME_TAC q ls} parses the quotation {q} in the -context of the goal, producing a term {pat} to use as a pattern. The -tactic then attempts a (first order) match of {pat} against each term -in {asl}, stopping when it finds an assumption that either matches -{pat} in its entirety, or has a sub-term that matches {pat} (holding +{Q.MATCH_ASMSUB_RENAME_TAC q} parses the quotation {q} in the context +of the goal, producing a term {pat} to use as a pattern. The tactic +then attempts a (first order) match of {pat} against each term in +{asl}, stopping when it finds an assumption that either matches {pat} +in its entirety, or has a sub-term that matches {pat} (holding existing free variables from the goal constant). In either case, the match will return an instantiation mapping the fresh free variables of {pat} to terms occurring in the goal. This -instantiation drops its bindings for variables whose names appear in -{ls}, is reversed, and is then applied to the goal. This will both -cause free variables in the goal to be renamed, and for larger terms -to be replaced by variables (similar to what happens with the use of -{SPEC_TAC}). +instantiation drops its bindings for variables whose names begin with +an underscore, is next reversed, and is finally applied to the goal. +This will both cause free variables in the goal to be renamed, and for +larger terms to be replaced by variables (similar to what happens with +the use of {SPEC_TAC}). \FAILURE @@ -37,7 +37,7 @@ on the first assumption (featuring {P}). Instead the second assumption provides the instantiation, and so the variable {z} in the original is renamed to {n}. { - > Q.MATCH_ASMSUB_RENAME_TAC `x < n` [] + > Q.MATCH_ASMSUB_RENAME_TAC `x < n` ([``P(y < m):bool``, ``Q(x < z) : bool``], ``x + z < 10``); val it = ([([``P (y < m)``, ``Q (x < n)``], ``x + n < 10``)], fn): goal list * validation diff --git a/help/Docfiles/Q.MATCH_ASSUM_RENAME_TAC.doc b/help/Docfiles/Q.MATCH_ASSUM_RENAME_TAC.doc index 7c81744b3b..b8ed71157e 100644 --- a/help/Docfiles/Q.MATCH_ASSUM_RENAME_TAC.doc +++ b/help/Docfiles/Q.MATCH_ASSUM_RENAME_TAC.doc @@ -1,6 +1,6 @@ \DOC MATCH_ASSUM_RENAME_TAC -\TYPE {Q.MATCH_ASSUM_RENAME_TAC : term quotation -> string list -> tactic} +\TYPE {Q.MATCH_ASSUM_RENAME_TAC : term quotation -> tactic} \SYNOPSIS Replaces selected terms with new variables by matching a pattern @@ -9,10 +9,10 @@ against an assumption. \DESCRIBE When applied to the goal {(asl, w)}, the tactic -{Q.MATCH_ASSUM_RENAME_TAC q ls} parses the quotation {q} in the -context of the goal, producing a term to use as a pattern. The tactic -then attempts a (first order) match of the pattern against each term -in {asl}, stopping on the first matching assumption {a}. +{Q.MATCH_ASSUM_RENAME_TAC q} parses the quotation {q} in the context +of the goal, producing a term to use as a pattern. The tactic then +attempts a (first order) match of the pattern against each term in +{asl}, stopping on the first matching assumption {a}. For each variable {v} in the pattern, there will be an instantiation term {t}, such that the substitution @@ -20,9 +20,9 @@ term {t}, such that the substitution pattern[v1 |-> t1, v2 |-> t2, ...] } produces {a}. The effect of the tactic is to then replace each {t} -with the corresponding {v}, yielding a new goal. The list {ls} is of -exceptions: if a variable {v}'s name appears in {ls}, then no -replacement of {v} for {t} is made. +with the corresponding {v}, yielding a new goal. Note that underscores +within a pattern, though strictly speaking variables, are not included +in this reverse instantiation. \FAILURE {MATCH_ASSUM_RENAME_TAC} fails if the pattern provided does not match @@ -34,7 +34,7 @@ If the current goal is { (f x = Pair C'' C0') ?- (f C'' = f C0') } -then applying the tactic {Q.MATCH_ASSUM_RENAME_TAC `X = Pair c1 c2` ["X"]} +then applying the tactic {Q.MATCH_ASSUM_RENAME_TAC `_ = Pair c1 c2`} results in the goal { (f x = Pair c1 c2) ?- (f c1 = f c2) diff --git a/help/Docfiles/Q.MATCH_GOALSUB_RENAME_TAC.doc b/help/Docfiles/Q.MATCH_GOALSUB_RENAME_TAC.doc index 0985f47f81..39a80acda2 100644 --- a/help/Docfiles/Q.MATCH_GOALSUB_RENAME_TAC.doc +++ b/help/Docfiles/Q.MATCH_GOALSUB_RENAME_TAC.doc @@ -1,6 +1,6 @@ \DOC -\TYPE {MATCH_GOALSUB_RENAME_TAC : term quotation -> string list -> tactic} +\TYPE {MATCH_GOALSUB_RENAME_TAC : term quotation -> tactic} \SYNOPSIS Renames a goal in accordance with a pattern matched against a subterm @@ -11,13 +11,14 @@ Renaming \DESCRIBE -A call to {MATCH_GOALSUB_RENAME_TAC pat excs} attempts to find a match -for the pattern {pat} in the current goal (using {gen_find_term} to -find a sub-term of the goal that matches). If a match is found, the -goal is adjusted so that the variables occurring in the pattern now -also appear in the goal. This may rename variables in the goal, or -even cause larger sub-terms to be replaced by variables (as with -{SPEC_TAC}). +A call to {MATCH_GOALSUB_RENAME_TAC pat} attempts to find a match for +the pattern {pat} in the current goal (using {gen_find_term} to find a +sub-term of the goal that matches). If a match is found, the goal is +adjusted so that the variables occurring in the pattern now also +appear in the goal. This may rename variables in the goal, or even +cause larger sub-terms to be replaced by variables (as with +{SPEC_TAC}). Underscores may be used in {pat} to indicate ``don't +care'' bindings, where no renaming or instantiation will take place. \FAILURE @@ -31,7 +32,7 @@ If the goal is { ?- !x. x * 2 < y * (z + 1) * (y + a) } -then applying {Q.MATCH_GOALSUB_RENAME_TAC `y + c` []} will match the +then applying {Q.MATCH_GOALSUB_RENAME_TAC `y + c`} will match the pattern {y + c} against the various subterms within the goal. The first obvious match, with {z + 1} will be rejected because the variable {y} is free in the goal, and is treated as if it were a local diff --git a/help/Docfiles/Q.MATCH_RENAME_TAC.doc b/help/Docfiles/Q.MATCH_RENAME_TAC.doc index dff6be22a3..26b69a7cc8 100644 --- a/help/Docfiles/Q.MATCH_RENAME_TAC.doc +++ b/help/Docfiles/Q.MATCH_RENAME_TAC.doc @@ -1,6 +1,6 @@ \DOC MATCH_RENAME_TAC -\TYPE {Q.MATCH_RENAME_TAC : term quotation -> string list -> tactic} +\TYPE {Q.MATCH_RENAME_TAC : term quotation -> tactic} \SYNOPSIS Replaces selected terms with new variables by matching a pattern against the goal statement. @@ -11,11 +11,15 @@ parses the quotation {q} in the context of the goal, producing a term to use as a pattern. The tactic then attempts a (first order) match of the pattern against the term {w}. -For each variable {v} in the pattern, there will be an instantiation term {t}, -such that the substitution {pattern[v1 |-> t1, v2 |-> t2, ...]} produces {w}. -The effect of the tactic is to then replace each {t} with the corresponding -{v}, yielding a new goal. The list {ls} is of exceptions: if a variable {v}'s -name appears in {ls}, then no replacement of {v} for {t} is made. +For each variable {v} in the pattern, there will be an instantiation +term {t}, such that the substitution +{ + pattern[v1 |-> t1, v2 |-> t2, ...] +} +produces {w}. The effect of the tactic is to then replace each {t} +with the corresponding {v}, yielding a new goal. Note that underscores +within a pattern, though strictly speaking variables, are not included +in this reverse instantiation. \FAILURE {MATCH_RENAME_TAC} fails if the pattern provided does not match the @@ -27,7 +31,7 @@ If the current goal is { ?- (f x = Pair C'' C0') ==> (f C'' = f C0') } -then applying the tactic {Q.MATCH_RENAME_TAC `(f x = Pair c1 c2) ==> X` ["X"]} results in +then applying the tactic {Q.MATCH_RENAME_TAC `(f x = Pair c1 c2) ==> _`} results in the goal { ?- (f x = Pair c1 c2) ==> (f c1 = f c2) @@ -35,7 +39,7 @@ the goal \COMMENTS This tactic is equivalent to first applying {Q.MATCH_ABBREV_TAC q}, then -applying {Q.RM_ABBREV_TAC `v`} for each {v} in {q} whose name is not in {ls}. +applying {Q.RM_ABBREV_TAC `v`} for each underscore in {q}. \SEEALSO Q.MATCH_ABBREV_TAC, Q.MATCH_ASSUM_RENAME_TAC diff --git a/src/bag/bagScript.sml b/src/bag/bagScript.sml index 1f5420774b..8928085a30 100644 --- a/src/bag/bagScript.sml +++ b/src/bag/bagScript.sml @@ -2470,11 +2470,11 @@ val mlt_dominates_thm1 = store_thm( strip_tac >> map_every qexists_tac [`{|e|}`, `rep`] >> simp[COMM_BAG_UNION]) >> rpt strip_tac >> - qmatch_assum_rename_tac `mlt1 R B0 B1` [] >> - qmatch_assum_rename_tac `mlt R B1 B2` [] >> + qmatch_assum_rename_tac `mlt1 R B0 B1` >> + qmatch_assum_rename_tac `mlt R B1 B2` >> fs[mlt1_def] >> - qmatch_assum_rename_tac `!e'. BAG_IN e' Rep ==> R e' E` [] >> - qmatch_assum_rename_tac `(B2 - X) + Y = Res + {|E|}` []>> + qmatch_assum_rename_tac `!e'. BAG_IN e' Rep ==> R e' E` >> + qmatch_assum_rename_tac `(B2 - X) + Y = Res + {|E|}` >> Cases_on `BAG_IN E Y` >- (map_every qexists_tac [`X`, `Y - {| E |} + Rep`] >> simp[] >> reverse conj_tac diff --git a/src/boss/lcsymtacs.sig b/src/boss/lcsymtacs.sig index 229ee06ac7..8d70802811 100644 --- a/src/boss/lcsymtacs.sig +++ b/src/boss/lcsymtacs.sig @@ -46,12 +46,12 @@ sig val qpat_abbrev_tac : term quotation -> tactic val qmatch_abbrev_tac : term quotation -> tactic val qho_match_abbrev_tac : term quotation -> tactic - val qmatch_rename_tac : term quotation -> string list -> tactic + val qmatch_rename_tac : term quotation -> tactic val qmatch_assum_abbrev_tac : term quotation -> tactic - val qmatch_assum_rename_tac : term quotation -> string list -> tactic - val qmatch_asmsub_rename_tac : term quotation -> string list -> tactic - val qmatch_goalsub_rename_tac : term quotation -> string list -> tactic - val qcase_tac : term quotation -> string list -> tactic + val qmatch_assum_rename_tac : term quotation -> tactic + val qmatch_asmsub_rename_tac : term quotation -> tactic + val qmatch_goalsub_rename_tac : term quotation -> tactic + val qcase_tac : term quotation -> tactic val assume_tac : thm_tactic val strip_assume_tac : thm_tactic diff --git a/src/boss/lcsymtacs.sml b/src/boss/lcsymtacs.sml index 218bf35790..19343e256b 100644 --- a/src/boss/lcsymtacs.sml +++ b/src/boss/lcsymtacs.sml @@ -47,11 +47,11 @@ struct val qpat_abbrev_tac : term quotation -> tactic = Q.PAT_ABBREV_TAC val qmatch_abbrev_tac : term quotation -> tactic = Q.MATCH_ABBREV_TAC val qho_match_abbrev_tac : term quotation -> tactic = Q.HO_MATCH_ABBREV_TAC - val qmatch_rename_tac : term quotation -> string list -> tactic = + val qmatch_rename_tac : term quotation -> tactic = Q.MATCH_RENAME_TAC val qmatch_assum_abbrev_tac : term quotation -> tactic = Q.MATCH_ASSUM_ABBREV_TAC - val qmatch_assum_rename_tac : term quotation -> string list -> tactic = + val qmatch_assum_rename_tac : term quotation -> tactic = Q.MATCH_ASSUM_RENAME_TAC val qmatch_asmsub_rename_tac = Q.MATCH_ASMSUB_RENAME_TAC val qmatch_goalsub_rename_tac = Q.MATCH_GOALSUB_RENAME_TAC diff --git a/src/finite_map/alistScript.sml b/src/finite_map/alistScript.sml index ef155aee74..f72159e737 100644 --- a/src/finite_map/alistScript.sml +++ b/src/finite_map/alistScript.sml @@ -211,7 +211,7 @@ val alist_to_fmap_to_alist = store_thm( ``!al. fmap_to_alist (alist_to_fmap al) = MAP (\k. (k, THE (ALOOKUP al k))) (SET_TO_LIST (set (MAP FST al)))``, SRW_TAC[][fmap_to_alist_def,MAP_EQ_f,MEM_MAP] THEN -Q.MATCH_ASSUM_RENAME_TAC `MEM p al` [] THEN +Q.MATCH_ASSUM_RENAME_TAC `MEM p al` THEN PairCases_on `p` THEN SRW_TAC[][] THEN Cases_on `ALOOKUP al p0` THEN IMP_RES_TAC ALOOKUP_FAILS THEN @@ -262,20 +262,20 @@ SRW_TAC[][] THEN1 ( SRW_TAC[][EL_MAP] ) THEN numLib.LEAST_ELIM_TAC THEN SRW_TAC[][] THEN -Q.MATCH_ASSUM_RENAME_TAC `EL m (MAP FST ls) = FST (EL n ls)`[] THEN1 ( +Q.MATCH_ASSUM_RENAME_TAC `EL m (MAP FST ls) = FST (EL n ls)` THEN1 ( Q.EXISTS_TAC `SUC m` THEN SRW_TAC[][] ) THEN Cases_on `n < m` THEN1 METIS_TAC[EL_MAP] THEN `m < LENGTH ls` by DECIDE_TAC THEN FULL_SIMP_TAC(srw_ss())[EL_MAP] THEN -Q.MATCH_ASSUM_RENAME_TAC `EL z (h::MAP FST ls) = FST (EL n ls)`[] THEN +Q.MATCH_ASSUM_RENAME_TAC `EL z (h::MAP FST ls) = FST (EL n ls)` THEN Cases_on `SUC n < z` THEN1 ( RES_TAC THEN FULL_SIMP_TAC(srw_ss())[] THEN METIS_TAC[EL_MAP]) THEN `z < SUC (LENGTH ls)` by DECIDE_TAC THEN Cases_on `z` THEN FULL_SIMP_TAC (srw_ss()) [EL_MAP] THEN -Q.MATCH_RENAME_TAC `SND (EL m ls) = SND (EL z ls)`[] THEN +Q.MATCH_RENAME_TAC `SND (EL m ls) = SND (EL z ls)` THEN Cases_on `m < z` THEN1 ( `SUC m < SUC z` by DECIDE_TAC THEN RES_TAC THEN @@ -302,7 +302,7 @@ numLib.LEAST_ELIM_TAC >> conj_tac >- ( qexists_tac `n` >> rw[] ) >> rw[] >> -qmatch_rename_tac `EL m (MAP SND al) = v`[] >> +qmatch_rename_tac `EL m (MAP SND al) = v` >> `~(n < m)` by PROVE_TAC[] >> `m < LENGTH al` by DECIDE_TAC >> fs[EL_ALL_DISTINCT_EL_EQ] >> @@ -384,9 +384,9 @@ imp_res_tac MEM_PERM >> by rw[ALL_DISTINCT_fmap_to_alist_keys,Abbr`af1`,Abbr`af2`] >> fs[EL_ALL_DISTINCT_EL_EQ,MEM_EL,EL_MAP] >> rw[] >> -qmatch_rename_tac `r1 = r2`[] >> -qmatch_assum_rename_tac `(q,r1) = EL n1 afx`[] >> -qmatch_assum_rename_tac `(q,r2) = EL n2 afy`[] >> +qmatch_rename_tac `r1 = r2` >> +qmatch_assum_rename_tac `(q,r1) = EL n1 afx` >> +qmatch_assum_rename_tac `(q,r2) = EL n2 afy` >> rpt (qpat_assum `(X,Y) = EL N Z` (assume_tac o SYM)) >> `LENGTH afy = LENGTH afx` by rw[PERM_LENGTH] >> fs[] >> metis_tac[pairTheory.PAIR_EQ,pairTheory.FST]) @@ -440,7 +440,7 @@ val FRANGE_alist_to_fmap_SUBSET = store_thm( "FRANGE_alist_to_fmap_SUBSET", ``FRANGE (alist_to_fmap ls) SUBSET IMAGE SND (set ls)``, srw_tac[DNF_ss][FRANGE_DEF,SUBSET_DEF,pairTheory.EXISTS_PROD] >> -qmatch_assum_rename_tac `MEM z (MAP FST ls)`[] >> +qmatch_assum_rename_tac `MEM z (MAP FST ls)` >> qexists_tac `z` >> match_mp_tac alist_to_fmap_FAPPLY_MEM >> rw[]) @@ -595,7 +595,7 @@ val ALOOKUP_ALL_DISTINCT_PERM_same = store_thm("ALOOKUP_ALL_DISTINCT_PERM_same", imp_res_tac MEM_PERM >> fs[FORALL_PROD,MEM_MAP,EXISTS_PROD] >> metis_tac[ALOOKUP_FAILS] ) >> - qmatch_assum_rename_tac`ALOOKUP l2 x = SOME p`[] >> + qmatch_assum_rename_tac`ALOOKUP l2 x = SOME p` >> imp_res_tac ALOOKUP_MEM >> `ALL_DISTINCT (MAP FST l2)` by ( metis_tac[ALL_DISTINCT_PERM]) >> diff --git a/src/finite_map/finite_mapScript.sml b/src/finite_map/finite_mapScript.sml index bed5b3a3c9..4e2979a7cc 100644 --- a/src/finite_map/finite_mapScript.sml +++ b/src/finite_map/finite_mapScript.sml @@ -1608,24 +1608,24 @@ val FUPDATE_LIST_APPLY_MEM = store_thm( Induct THEN1 SRW_TAC[][] THEN Cases THEN NTAC 3 GEN_TAC THEN Cases THEN1 ( - Q.MATCH_RENAME_TAC `0 < LENGTH ((q,r)::kvl) /\ X ==> Y` ["X","Y"] THEN + Q.MATCH_RENAME_TAC `0 < LENGTH ((q,r)::kvl) /\ _ ==> _` THEN Q.ISPECL_THEN [`kvl`,`f |+ (k,r)`,`k`] MP_TAC FUPDATE_LIST_APPLY_NOT_MEM THEN SRW_TAC[][FUPDATE_LIST_THM] THEN FIRST_X_ASSUM MATCH_MP_TAC THEN SRW_TAC[][MEM_MAP,MEM_EL,pairTheory.EXISTS_PROD] THEN - Q.MATCH_RENAME_TAC `X \/ Y <> EL n kvl` ["X","Y"] THEN + Q.MATCH_RENAME_TAC `_ \/ _ <> EL n kvl` THEN FIRST_X_ASSUM (Q.SPEC_THEN `SUC n` MP_TAC) THEN SRW_TAC[][EL_MAP] THEN METIS_TAC[pairTheory.FST]) THEN SRW_TAC[][] THEN -Q.MATCH_RENAME_TAC `(f |++ ((q,r)::kvl)) ' X = Y` ["X","Y"] THEN +Q.MATCH_RENAME_TAC `(f |++ ((q,r)::kvl)) ' _ = _` THEN Q.ISPECL_THEN [`(q,r)`,`kvl`] SUBST1_TAC rich_listTheory.CONS_APPEND THEN REWRITE_TAC [FUPDATE_LIST_APPEND] THEN FIRST_X_ASSUM MATCH_MP_TAC THEN -Q.MATCH_ASSUM_RENAME_TAC `n < LENGTH kvl` [] THEN +Q.MATCH_ASSUM_RENAME_TAC `n < LENGTH kvl` THEN Q.EXISTS_TAC `n` THEN SRW_TAC[][] THEN -Q.MATCH_RENAME_TAC `EL m (MAP FST kvl) <> X` ["X"] THEN +Q.MATCH_RENAME_TAC `EL m (MAP FST kvl) <> _` THEN FIRST_X_ASSUM (Q.SPEC_THEN `SUC m` MP_TAC) THEN SRW_TAC[][]) end @@ -2132,7 +2132,7 @@ GEN_TAC THEN Induct THEN Cases THEN SRW_TAC[][FUPDATE_LIST_THM,listTheory.LIST_REL_CONS1] THEN Cases_on `ls2` THEN FULL_SIMP_TAC(srw_ss())[FUPDATE_LIST_THM] THEN FIRST_X_ASSUM MATCH_MP_TAC THEN FULL_SIMP_TAC(srw_ss())[] THEN SRW_TAC[][] THEN -Q.MATCH_ASSUM_RENAME_TAC `R a (SND b)`[] THEN +Q.MATCH_ASSUM_RENAME_TAC `R a (SND b)` THEN Cases_on `b` THEN FULL_SIMP_TAC(srw_ss())[] THEN SRW_TAC[][fmap_rel_FUPDATE_same]) @@ -2421,7 +2421,7 @@ ho_match_mp_tac SNOC_INDUCT >> conj_tac >- rw[] >> rw[FUPDATE_LIST,FOLDL_SNOC] >> match_mp_tac FUPDATE_SAME_APPLY >> -qmatch_rename_tac `(y = FST p) \/ Z` ["Z"] >> +qmatch_rename_tac `(y = FST p) \/ _` >> Cases_on `y = FST p` >> rw[] >> first_x_assum match_mp_tac >> fs[MEM_MAP] >> @@ -2590,7 +2590,7 @@ val f_o_f_FUPDATE_compose = store_thm("f_o_f_FUPDATE_compose", fs[IN_FRANGE] >> rw[] >- PROVE_TAC[] >- PROVE_TAC[] >> - qmatch_assum_rename_tac`y <> k`[] >> + qmatch_assum_rename_tac`y <> k` >> `y IN FDOM (f1 f_o_f f2)` by rw[f_o_f_DEF] >> rw[f_o_f_DEF]) diff --git a/src/integer/int_bitwiseScript.sml b/src/integer/int_bitwiseScript.sml index 4d2a81d259..f3f1162b23 100644 --- a/src/integer/int_bitwiseScript.sml +++ b/src/integer/int_bitwiseScript.sml @@ -235,7 +235,7 @@ val int_bit_equiv = store_thm("int_bit_equiv", \\ first_x_assum (mp_tac o Q.SPEC `x`) \\ fs []) \\ CCONTR_TAC - \\ Q.MATCH_ASSUM_RENAME_TAC `LENGTH bs2 <> LENGTH bs1` [] + \\ Q.MATCH_ASSUM_RENAME_TAC `LENGTH bs2 <> LENGTH bs1` \\ `LENGTH bs1 < LENGTH bs2 \/ LENGTH bs2 < LENGTH bs1` by DECIDE_TAC \\ IMP_RES_TAC bits_of_int_LAST THEN1 (Cases_on `bs2 = []` \\ fs [LENGTH] diff --git a/src/list/src/listScript.sml b/src/list/src/listScript.sml index 41f4d93805..b17c00e496 100644 --- a/src/list/src/listScript.sml +++ b/src/list/src/listScript.sml @@ -2412,7 +2412,7 @@ SRW_TAC [] [EQ_IMP_THM] THEN1 ( SRW_TAC [] [] ) THEN NTAC 2 (FIRST_X_ASSUM (Q.SPEC_THEN `m1` MP_TAC)) THEN SRW_TAC [] [] ) THEN1 ( - Q.MATCH_RENAME_TAC `~(m < n) \/ f n <> EL m (GENLIST f n)` [] THEN + Q.MATCH_RENAME_TAC `~(m < n) \/ f n <> EL m (GENLIST f n)` THEN Cases_on `m < n` THEN SRW_TAC [] [] THEN FIRST_X_ASSUM (Q.SPECL_THEN [`m`,`n`] MP_TAC) THEN SRW_TAC [] [LESS_SUC] THEN diff --git a/src/num/theories/arithmeticScript.sml b/src/num/theories/arithmeticScript.sml index 41e4cfefed..c995d3ecd7 100644 --- a/src/num/theories/arithmeticScript.sml +++ b/src/num/theories/arithmeticScript.sml @@ -2759,7 +2759,7 @@ val ONE_MOD_IFF = Q.store_thm ("ONE_MOD_IFF", SIMP_TAC bool_ss [ONE] THEN STRIP_TAC THEN MATCH_MP_TAC LESS_MONO THEN - Q.MATCH_RENAME_TAC `0 < m` [] THEN + Q.MATCH_RENAME_TAC `0 < m` THEN FULL_STRUCT_CASES_TAC (SPEC ``m:num`` num_CASES) THEN1 ( FULL_SIMP_TAC bool_ss [MOD_ONE,SUC_NOT] ) THEN SIMP_TAC bool_ss [LESS_0]) @@ -3079,7 +3079,7 @@ val X_LT_EXP_X_IFF = Q.store_thm ("X_LT_EXP_X_IFF", Cases_on `b` THEN1 ( Cases_on `x` THEN SIMP_TAC bool_ss [ZERO_EXP,SUC_NOT,NOT_LESS_0] ) THEN - Q.MATCH_RENAME_TAC `x < SUC b ** x ==> 1 < SUC b \/ (x = 0)` [] THEN + Q.MATCH_RENAME_TAC `x < SUC b ** x ==> 1 < SUC b \/ (x = 0)` THEN Cases_on `b` THEN1 ( SIMP_TAC bool_ss [EXP_1,SYM ONE] THEN SIMP_TAC bool_ss [ONE,LESS_THM,NOT_LESS_0] ) THEN diff --git a/src/patricia/sptreeScript.sml b/src/patricia/sptreeScript.sml index 1a7c9703cd..2311e6a693 100644 --- a/src/patricia/sptreeScript.sml +++ b/src/patricia/sptreeScript.sml @@ -401,7 +401,7 @@ val lookup_fromList = store_thm( full_simp_tac (srw_ss() ++ ARITH_ss) [] >> `0 < n - i` by simp[] >> Cases_on `n - i` >> fs[] >> - qmatch_assum_rename_tac `n - i = SUC nn` [] >> + qmatch_assum_rename_tac `n - i = SUC nn` >> `nn = n - (i + 1)` by decide_tac >> simp[]); val bit_cases = prove( @@ -465,7 +465,7 @@ val domain_fromList = store_thm( suffices_by (simp[] >> strip_tac >> simp[pred_setTheory.EXTENSION]) >> Induct_on `l` >> simp[pred_setTheory.EXTENSION, EQ_IMP_THM] >> rpt strip_tac >> simp[DECIDE ``(x = x + y) <=> (y = 0)``] >> - qmatch_assum_rename_tac `nn < SUC (LENGTH l)` [] >> + qmatch_assum_rename_tac `nn < SUC (LENGTH l)` >> Cases_on `nn` >> fs[] >> metis_tac[ADD1]); val ODD_IMP_NOT_ODD = prove( @@ -845,7 +845,7 @@ val spt_eq_thm = store_thm("spt_eq_thm", qspec_then`x`strip_assume_tac div2_odd_lemma >> first_x_assum(qspec_then`n`mp_tac) >> fs[ODD_EVEN] >> simp[lookup_def] >> NO_TAC) >> - qmatch_assum_rename_tac`wf (BN s1 s2)`[] >> + qmatch_assum_rename_tac`wf (BN s1 s2)` >> `wf s1 /\ wf s2` by fs[wf_def] >> first_x_assum(qspec_then`s2`mp_tac) >> first_x_assum(qspec_then`s1`mp_tac) >> @@ -870,7 +870,7 @@ val spt_eq_thm = store_thm("spt_eq_thm", qspec_then`x`strip_assume_tac div2_odd_lemma >> first_x_assum(qspec_then`n`mp_tac) >> fs[ODD_EVEN] >> simp[lookup_def] >> NO_TAC) >> - qmatch_assum_rename_tac`wf (BS s1 z s2)`[] >> + qmatch_assum_rename_tac`wf (BS s1 z s2)` >> `wf s1 /\ wf s2` by fs[wf_def] >> first_x_assum(qspec_then`s2`mp_tac) >> first_x_assum(qspec_then`s1`mp_tac) >> diff --git a/src/q/Q.sig b/src/q/Q.sig index 871829c6f3..0f69c1d27d 100644 --- a/src/q/Q.sig +++ b/src/q/Q.sig @@ -59,10 +59,10 @@ sig val UNABBREV_TAC : tmquote -> tactic val RM_ABBREV_TAC : tmquote -> tactic - val MATCH_RENAME_TAC : tmquote -> string list -> tactic - val MATCH_ASSUM_RENAME_TAC : tmquote -> string list -> tactic - val MATCH_GOALSUB_RENAME_TAC : tmquote -> string list -> tactic - val MATCH_ASMSUB_RENAME_TAC : tmquote -> string list -> tactic - val FIND_CASE_TAC : tmquote -> string list -> tactic + val MATCH_RENAME_TAC : tmquote -> tactic + val MATCH_ASSUM_RENAME_TAC : tmquote -> tactic + val MATCH_GOALSUB_RENAME_TAC : tmquote -> tactic + val MATCH_ASMSUB_RENAME_TAC : tmquote -> tactic + val FIND_CASE_TAC : tmquote -> tactic end diff --git a/src/q/Q.sml b/src/q/Q.sml index 3df62d8315..8e0b175e55 100644 --- a/src/q/Q.sml +++ b/src/q/Q.sml @@ -350,86 +350,101 @@ fun MATCH_ASSUM_ABBREV_TAC q (gl as (asl,w)) = (* Renaming tactics *) (*---------------------------------------------------------------------------*) -fun make_rename_tac s fvs except ERR = -let val (sf,sb) = partition (fn {redex=l,residue=r} => mem l fvs) s in - if exists (fn {redex=l,residue=r} => (not (l = r))) sf - then raise ERR "Double bind" - else MAP_EVERY - (fn {redex=l,residue=r} => - CHOOSE_THEN SUBST_ALL_TAC +fun make_rename_tac s = + MAP_EVERY + (fn {redex=l,residue=r} => + CHOOSE_THEN SUBST_ALL_TAC (Thm.EXISTS(mk_exists(l, mk_eq(r, l)), r) (Thm.REFL r))) - (filter (fn {redex=l,residue=r} => not (mem (fst(dest_var l)) except)) sb) + s + +fun isnt_uscore_var v = let + val (s, _) = dest_var v +in + size s <> 0 andalso String.sub(s, 0) <> #"_" end +val strip_uscore_bindings = filter (fn {redex,residue} => isnt_uscore_var redex) +fun redex_map f {redex,residue} = {redex = f redex, residue = residue} + +(* needs to be eta-expanded so that the possible HOL_ERRs are raised + when applied to a goal, not before, thereby letting FIRST_ASSUM catch + the exception *) +fun wholeterm_rename_helper {pat,fvs_set,ERR} tm g = let + val ((tmtheta0, _), (tytheta, _)) = + raw_match [] fvs_set pat tm ([],[]) + handle HOL_ERR _ => raise ERR "No match" +in + tmtheta0 |> strip_uscore_bindings |> map (redex_map (inst tytheta)) + |> make_rename_tac +end g (* these functions should probably be using raw_match_term in order to handle the variables that are only allowed to be bound to themselves *) -fun MATCH_RENAME_TAC q except (g as (asl,t)) = let +fun MATCH_RENAME_TAC q (g as (asl,t)) = let val fvs = free_varsl(t::asl) val pat = Parse.parse_in_context fvs q in - make_rename_tac - (fst (match_term pat t)) fvs except (ERR "MATCH_RENAME_TAC") + wholeterm_rename_helper + {pat=pat, ERR = ERR "MATCH_RENAME_TAC", + fvs_set = HOLset.fromList Term.compare fvs} + t end g -fun MATCH_ASSUM_RENAME_TAC q except (g as (asl,t)) = let - val ERR = ERR "MATCH_ASSUM_RENAME_TAC" +fun MATCH_ASSUM_RENAME_TAC q (g as (asl,t)) = let val fvs = free_varsl(t::asl) val pat = Parse.parse_in_context fvs q - fun find [] = raise ERR "No matching assumption found" - | find (asm::tl) = - case (total (match_term pat)) asm of - NONE => find tl - | SOME (s,_) => make_rename_tac s fvs except ERR - handle HOL_ERR e => find tl -in find asl end g +in + FIRST_ASSUM (wholeterm_rename_helper {pat=pat, ERR = ERR "MATCH_ASSUM_RENAME_TAC", + fvs_set = HOLset.fromList Term.compare fvs} o + concl) +end g (* needs to be eta-expanded so that the possible HOL_ERRs are raised when applied to a goal, not before, thereby letting FIRST_ASSUM catch the exception *) -fun subterm_rename_helper {except,thetasz,ERR,pat,fvs,fvs_set} t g = let +fun subterm_rename_helper {thetasz,ERR,pat,fvs_set} t g = let fun test (bvs, subt) = case Lib.total (fn t => raw_match [] fvs_set pat t ([],[])) subt of - SOME ((theta0, _), _) => + SOME ((theta0, _), (tytheta,_)) => let - fun filt1 {redex,...} = not (mem (#1 (dest_var redex)) except) - fun filt2 {residue, ...} = + fun filt {residue, ...} = List.all (fn bv => not (free_in bv residue)) bvs - val theta = filter (fn s => filt1 s andalso filt2 s) theta0 + val theta0 = + filter (fn s => isnt_uscore_var (#redex s) andalso filt s) + theta0 + val theta = map (redex_map (inst tytheta)) theta0 in if length theta <> thetasz then NONE else SOME theta end | NONE => NONE in case gen_find_term test t of - SOME theta => make_rename_tac theta fvs except ERR + SOME theta => make_rename_tac theta | NONE => raise ERR "No matching sub-term found" end g -fun prep_rename q except nm (asl, t) = let +fun prep_rename q nm (asl, t) = let val ERR = ERR nm val fvs = free_varsl (t::asl) val pat = Parse.parse_in_context fvs q val fvs_set = HOLset.fromList Term.compare fvs val patfvs = free_vars pat val pat_binds = - filter (fn v => not (mem v fvs) andalso not (mem (#1 (dest_var v)) except)) - patfvs + filter (fn v => not (mem v fvs) andalso isnt_uscore_var v) patfvs in - {ERR = ERR, fvs = fvs, pat = pat, fvs_set = fvs_set, thetasz = length pat_binds, - except = except} + {ERR = ERR, pat = pat, fvs_set = fvs_set, thetasz = length pat_binds} end -fun MATCH_GOALSUB_RENAME_TAC q except (g as (asl, t)) = - subterm_rename_helper (prep_rename q except "MATCH_GOALSUB_RENAME_TAC" g) t g +fun MATCH_GOALSUB_RENAME_TAC q (g as (asl, t)) = + subterm_rename_helper (prep_rename q "MATCH_GOALSUB_RENAME_TAC" g) t g -fun MATCH_ASMSUB_RENAME_TAC q except (g as (asl, t)) = let - val args = prep_rename q except "MATCH_ASMSUB_RENAME_TAC" g +fun MATCH_ASMSUB_RENAME_TAC q (g as (asl, t)) = let + val args = prep_rename q "MATCH_ASMSUB_RENAME_TAC" g in FIRST_ASSUM (subterm_rename_helper args o concl) g end -fun FIND_CASE_TAC q sl = - MATCH_RENAME_TAC q sl ORELSE MATCH_ASSUM_RENAME_TAC q sl ORELSE - MATCH_GOALSUB_RENAME_TAC q sl ORELSE MATCH_ASMSUB_RENAME_TAC q sl +fun FIND_CASE_TAC q = + MATCH_RENAME_TAC q ORELSE MATCH_ASSUM_RENAME_TAC q ORELSE + MATCH_GOALSUB_RENAME_TAC q ORELSE MATCH_ASMSUB_RENAME_TAC q end (* Q *) diff --git a/src/q/selftest.sml b/src/q/selftest.sml index cff81a14d2..23ab96c842 100644 --- a/src/q/selftest.sml +++ b/src/q/selftest.sml @@ -37,12 +37,25 @@ val _ = set_fixity "+" (Infixl 500) val _ = set_fixity "*" (Infixl 600) val _ = set_fixity "<" (Infix(NONASSOC, 450)) +val _ = tprint "Q.MATCH_RENAME_TAC 1" +val gl0 = ([``x < y``], ``x = z:num``) +val expected_a0 = ``a < y`` +val expected_c0 = ``a = b:num`` +val (sgs, _) = Q.MATCH_RENAME_TAC `a = b` gl0 +val _ = case sgs of + [([a], c)] => if aconv a expected_a0 andalso + aconv c expected_c0 + then + print "OK\n" + else die "FAILED!" + | _ => die "FAILED!" + val _ = tprint "Q.MATCH_GOALSUB_RENAME_TAC 1" val gl1 = ([] : term list, ``!x. x * SUC (SUC zero) < y * (z + SUC zero) * (y + a)``) val expected_result1 = ``!x. x * SUC (SUC zero) < y * (z + SUC zero) * (y + c)`` -val (sgs, _) = Q.MATCH_GOALSUB_RENAME_TAC `y + c` [] gl1 +val (sgs, _) = Q.MATCH_GOALSUB_RENAME_TAC `y + c` gl1 val _ = case sgs of [([], t)] => if aconv t expected_result1 then print "OK\n" else die "FAILED!" @@ -52,7 +65,7 @@ val _ = tprint "Q.MATCH_GOALSUB_RENAME_TAC 2" val gl2 = ([] : term list, ``!x. x * SUC zero < y * (z + SUC zero) * (z + SUC (SUC zero))``) val expected_result2 = ``!x. x * c < y * (a + c) * (a + SUC c)`` -val (sgs, _) = Q.MATCH_GOALSUB_RENAME_TAC `a + c` [] gl2 +val (sgs, _) = Q.MATCH_GOALSUB_RENAME_TAC `a + c` gl2 val _ = case sgs of [([], t)] => if aconv t expected_result2 then print "OK\n" else die "FAILED!" @@ -61,7 +74,7 @@ val _ = case sgs of val _ = tprint "Q.MATCH_GOALSUB_RENAME_TAC 3" val gl2a = ([] : term list, ``!x. x * SUC zero < z``) val expected_result2a = #2 gl2a -val (sgs, _) = Q.MATCH_GOALSUB_RENAME_TAC `SUC` [] gl2a +val (sgs, _) = Q.MATCH_GOALSUB_RENAME_TAC `SUC` gl2a val _ = case sgs of [([], t)] => if aconv t expected_result2a then print "OK\n" else die "FAILED!" @@ -74,7 +87,7 @@ val gl3 = ([``P (x:num): bool``, ``Q (x < SUC (SUC (SUC zero))) : bool``], val expected_a1 = ``P (x:num) : bool`` val expected_a2 = ``Q (x < n) : bool`` val expected_c = ``x + y < SUC (SUC zero)`` -val (sgs, _) = Q.MATCH_ASMSUB_RENAME_TAC `x < n` [] gl3 +val (sgs, _) = Q.MATCH_ASMSUB_RENAME_TAC `x < n` gl3 val _ = case sgs of [([a1, a2], c)] => if aconv a1 expected_a1 andalso aconv a2 expected_a2 andalso diff --git a/src/relation/relationScript.sml b/src/relation/relationScript.sml index cea2b9194d..0808118ed3 100644 --- a/src/relation/relationScript.sml +++ b/src/relation/relationScript.sml @@ -742,7 +742,7 @@ HO_MATCH_MP_TAC TC_INDUCT THEN1 ( PROVE_TAC [TC_RULES,SC_DEF] ) THEN REVERSE (SRW_TAC [][SC_DEF]) THEN1 PROVE_TAC [TC_RULES,SC_DEF] THEN -Q.MATCH_ASSUM_RENAME_TAC `R^+ a b` [] THEN +Q.MATCH_ASSUM_RENAME_TAC `R^+ a b` THEN POP_ASSUM MP_TAC THEN MAP_EVERY Q.ID_SPEC_TAC [`b`,`a`] THEN HO_MATCH_MP_TAC TC_INDUCT THEN diff --git a/src/sort/sortingScript.sml b/src/sort/sortingScript.sml index f1f9a13661..3d5fd4a31a 100644 --- a/src/sort/sortingScript.sml +++ b/src/sort/sortingScript.sml @@ -917,7 +917,7 @@ UNABBREV_ALL_TAC THEN SRW_TAC[][] THEN1 SRW_TAC[][] THEN EQ_TAC THEN1 METIS_TAC[] THEN STRIP_TAC THEN Q.X_GEN_TAC `x` THEN REVERSE (Cases_on `MEM x L2`) THEN1 METIS_TAC[] THEN -Q.MATCH_ASSUM_RENAME_TAC `R (LAST (y::t)) (HD L2)` [] THEN +Q.MATCH_ASSUM_RENAME_TAC `R (LAST (y::t)) (HD L2)` THEN `R h (LAST (y::t))` by ( FIRST_X_ASSUM MATCH_MP_TAC THEN Cases_on `t` THEN1 SRW_TAC[][] THEN From 7ab9724eaf44b423079ec84fc416ba2d01fb1808 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 9 Jan 2015 16:25:38 +1100 Subject: [PATCH 101/718] Use Datatype instead of Hol_datatype in examples/parsing/grammarScript --- examples/parsing/grammarScript.sml | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) diff --git a/examples/parsing/grammarScript.sml b/examples/parsing/grammarScript.sml index 4490e6ca33..95efe9718f 100644 --- a/examples/parsing/grammarScript.sml +++ b/examples/parsing/grammarScript.sml @@ -13,22 +13,20 @@ val _ = new_theory "grammar" val _ = ParseExtras.tight_equality() val _ = type_abbrev("inf", ``:'a + num``) -val _ = Hol_datatype ` - symbol = TOK of 'a | NT of 'b inf -`; +val _ = Datatype `symbol = TOK 'a | NT ('b inf)`; val isTOK_def = Define`(isTOK (TOK tok) = T) ∧ (isTOK (NT n) = F)` val _ = export_rewrites ["isTOK_def"] -val _ = Hol_datatype` +val _ = Datatype` grammar = <| start : 'b inf; rules : 'b inf |-> ('a,'b)symbol list set |> `; -val _ = Hol_datatype` - parsetree = Lf of ('a,'b) symbol - | Nd of 'b inf => parsetree list +val _ = Datatype` + parsetree = Lf (('a,'b) symbol) + | Nd ('b inf) (parsetree list) `; val ptree_size_def = tDefine "ptree_size" ` From f24dd06331f6fd32ace0f6598e63f78667a82f6e Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 9 Jan 2015 17:02:55 +1100 Subject: [PATCH 102/718] Get unification example to build in light of 92317114 --- .../triangular/first-order/redUnifScript.sml | 12 +- .../triangular/first-order/unifDefScript.sml | 6 +- .../first-order/unifPropsScript.sml | 12 +- .../triangular/first-order/walkScript.sml | 4 +- .../triangular/nominal/nunifDefScript.sml | 18 +-- .../triangular/nominal/nunifPropsScript.sml | 144 +++++++++--------- .../triangular/nominal/nwalkScript.sml | 4 +- .../triangular/nominal/nwalkstarScript.sml | 7 +- 8 files changed, 103 insertions(+), 104 deletions(-) diff --git a/examples/unification/triangular/first-order/redUnifScript.sml b/examples/unification/triangular/first-order/redUnifScript.sml index 42fdabb501..274b330a27 100644 --- a/examples/unification/triangular/first-order/redUnifScript.sml +++ b/examples/unification/triangular/first-order/redUnifScript.sml @@ -76,13 +76,13 @@ THEN1 ( SRW_TAC [][] THEN RES_TAC THEN HO_MATCH_MP_TAC RTC_INDUCT THEN SRW_TAC [][] THEN1 ( Q.EXISTS_TAC `SND x` THEN SRW_TAC [][] ) THEN -Q.MATCH_ASSUM_RENAME_TAC `tstep a b` [] THEN +Q.MATCH_ASSUM_RENAME_TAC `tstep a b` THEN MAP_EVERY Cases_on [`a`,`b`] THEN -Q.MATCH_ASSUM_RENAME_TAC `tstep (sl,bl) (si,bi)` [] THEN +Q.MATCH_ASSUM_RENAME_TAC `tstep (sl,bl) (si,bi)` THEN FULL_SIMP_TAC (srw_ss()) [] THEN IMP_RES_TAC wfs_tstep THEN FULL_SIMP_TAC (srw_ss()) [] THEN -Q.MATCH_ASSUM_RENAME_TAC `istep^* (si,bi) (FST sr,br)` [] THEN +Q.MATCH_ASSUM_RENAME_TAC `istep^* (si,bi) (FST sr,br)` THEN FULL_SIMP_TAC (srw_ss()) [tstep_def] THEN SRW_TAC [][] THEN1 ( @@ -109,10 +109,10 @@ THEN1 ( SRW_TAC [][] THEN RES_TAC THEN HO_MATCH_MP_TAC RTC_INDUCT THEN SRW_TAC [][] THEN1 ( Q.EXISTS_TAC `SND x` THEN SRW_TAC [][] ) THEN -Q.MATCH_ASSUM_RENAME_TAC `istep a b` [] THEN +Q.MATCH_ASSUM_RENAME_TAC `istep a b` THEN MAP_EVERY Cases_on [`a`,`b`] THEN -Q.MATCH_ASSUM_RENAME_TAC `istep (sl,bl) (si,bi)` [] THEN -Q.MATCH_ASSUM_RENAME_TAC `tstep^* (si,bi) (FST sr,br)` [] THEN +Q.MATCH_ASSUM_RENAME_TAC `istep (sl,bl) (si,bi)` THEN +Q.MATCH_ASSUM_RENAME_TAC `tstep^* (si,bi) (FST sr,br)` THEN FULL_SIMP_TAC (srw_ss()) [istep_def] THEN SRW_TAC [][] THEN1 ( Q.EXISTS_TAC `br` THEN diff --git a/examples/unification/triangular/first-order/unifDefScript.sml b/examples/unification/triangular/first-order/unifDefScript.sml index 549f127df6..0da27a30f1 100644 --- a/examples/unification/triangular/first-order/unifDefScript.sml +++ b/examples/unification/triangular/first-order/unifDefScript.sml @@ -127,7 +127,7 @@ val uR_RSUBSET_uR_lex = Q.store_thm( `uR RSUBSET uR_lex`, srw_tac [][RSUBSET] >> PairCases_on`x` >> PairCases_on`y` >> -Q.MATCH_RENAME_TAC `uR_lex (sx,c1,c2) (s,t1,t2)` [] >> +Q.MATCH_RENAME_TAC `uR_lex (sx,c1,c2) (s,t1,t2)` >> FULL_SIMP_TAC (srw_ss()) [uR_def,uR_lex_def,measure_thm,inv_image_def,LEX_DEF] >> Cases_on `sx = s` >> srw_tac [][PSUBSET_DEF]) @@ -497,7 +497,7 @@ THEN ASM_SIMP_TAC (srw_ss()) [] THENL [ by (IMP_RES_TAC walk_var_vwalk THEN IMP_RES_TAC vwalk_to_var THEN IMP_RES_TAC NOT_FDOM_vwalk) THEN - Q.MATCH_ASSUM_RENAME_TAC `walk s X = Const c` ["X"] THEN + Q.MATCH_ASSUM_RENAME_TAC `walk s _ = Const c` THEN `n NOTIN vars (walkstar s (Const c))` by (SRW_TAC [][walkstar_thm]) THEN METIS_TAC [uP_FUPDATE,walkstar_walk], @@ -531,7 +531,7 @@ THEN ASM_SIMP_TAC (srw_ss()) [] THENL [ by (IMP_RES_TAC walk_var_vwalk THEN IMP_RES_TAC vwalk_to_var THEN IMP_RES_TAC NOT_FDOM_vwalk) THEN - Q.MATCH_ASSUM_RENAME_TAC `walk s X = Const c` ["X"] THEN + Q.MATCH_ASSUM_RENAME_TAC `walk s _ = Const c` THEN `n NOTIN vars (walkstar s (Const c))` by (SRW_TAC [][walkstar_thm]) THEN METIS_TAC [uP_FUPDATE,walkstar_walk,uP_sym], diff --git a/examples/unification/triangular/first-order/unifPropsScript.sml b/examples/unification/triangular/first-order/unifPropsScript.sml index 11bce82d51..7641a00ade 100644 --- a/examples/unification/triangular/first-order/unifPropsScript.sml +++ b/examples/unification/triangular/first-order/unifPropsScript.sml @@ -121,7 +121,7 @@ SRW_TAC [][] THENL [ Cases_on `tx` THEN SRW_TAC [][] THEN Q.PAT_ASSUM `walkstar s1 (Var X) = walkstar s1 Y` MP_TAC THEN SRW_TAC [][] THEN - Q.MATCH_ASSUM_RENAME_TAC `vwalk X n'' = Const c` ["X"] THEN + Q.MATCH_ASSUM_RENAME_TAC `vwalk _ n'' = Const c` THEN `vwalk s n'' = Const c` by METIS_TAC [vwalk_FUPDATE_var] THEN Q.SPECL_THEN [`n''`,`s`] MP_TAC (Q.INST[`sx`|->`s1`] (UNDISCH vwalk_SUBMAP)) THEN @@ -261,7 +261,7 @@ val vars_measure = Q.store_thm( `v ∈ vars t ∧ (∀w. t ≠ Var w) ∧ wfs s ⇒ measure (pair_count o (walk* s)) (Var v) t`, Induct_on `t` THEN SRW_TAC [][] THEN -Q.MATCH_ASSUM_RENAME_TAC `v ∈ vars tt` [] THEN +Q.MATCH_ASSUM_RENAME_TAC `v ∈ vars tt` THEN Q.PAT_ASSUM `wfs s` ASSUME_TAC THEN Cases_on `tt` THEN FULL_SIMP_TAC (srw_ss()) [] THEN FULL_SIMP_TAC (srw_ss()++ARITH_ss) [measure_thm]) @@ -294,13 +294,13 @@ Q.PAT_ASSUM `wfs s` ASSUME_TAC THEN IMP_RES_TAC walk_to_var_NOT_FDOM THEN FULL_SIMP_TAC (srw_ss()) [NOT_FDOM_vwalk] THEN ASM_SIMP_TAC (srw_ss()) [Once unify_def] THEN1 ( - Q.MATCH_ASSUM_RENAME_TAC `walk s X = Pair c1 c2` ["X"] THEN + Q.MATCH_ASSUM_RENAME_TAC `walk s _ = Pair c1 c2` THEN (oc_subterm_neq |> CONTRAPOS |> Q.INST [`v`|->`n`,`t`|->`Pair c1 c2`] |> MP_TAC) THEN ASM_SIMP_TAC (srw_ss()) [] ) THEN1 ( - Q.MATCH_ASSUM_RENAME_TAC `walk s X = Pair c1 c2` ["X"] THEN + Q.MATCH_ASSUM_RENAME_TAC `walk s _ = Pair c1 c2` THEN (oc_subterm_neq |> CONTRAPOS |> Q.INST [`v`|->`n`,`t`|->`Pair c1 c2`] |> MP_TAC) THEN @@ -308,8 +308,8 @@ THEN1 ( THEN1 ( FULL_SIMP_TAC (srw_ss()) [] THEN `wfs sx` by METIS_TAC [unify_unifier] THEN - Q.MATCH_ASSUM_RENAME_TAC `walk s t1 = Pair t1a t1d` [] THEN - Q.MATCH_ASSUM_RENAME_TAC `walk s t2 = Pair t2a t2d` [] THEN + Q.MATCH_ASSUM_RENAME_TAC `walk s t1 = Pair t1a t1d` THEN + Q.MATCH_ASSUM_RENAME_TAC `walk s t2 = Pair t2a t2d` THEN (unify_mgu |> Q.SPECL [`s`,`t1a`,`t2a`,`sx`,`s2`] |> MP_TAC) THEN SRW_TAC [][] ) THEN1 ( diff --git a/examples/unification/triangular/first-order/walkScript.sml b/examples/unification/triangular/first-order/walkScript.sml index ae02290549..186768a89b 100644 --- a/examples/unification/triangular/first-order/walkScript.sml +++ b/examples/unification/triangular/first-order/walkScript.sml @@ -105,7 +105,7 @@ Cases_on `t` THENL [ `vwalk s v = Pair t' t0` by (SRW_TAC [][Once vwalk_def]) THEN MATCH_MP_TAC TC_SUBSET THEN SRW_TAC [][vR_def] THEN FULL_SIMP_TAC (srw_ss()) [], - Q.MATCH_ASSUM_RENAME_TAC `FLOOKUP s v = SOME (Const c)` [] THEN + Q.MATCH_ASSUM_RENAME_TAC `FLOOKUP s v = SOME (Const c)` THEN `vwalk s v = Const c` by (SRW_TAC [] [Once vwalk_def]) THEN FULL_SIMP_TAC (srw_ss()) [] ]); @@ -149,7 +149,7 @@ Cases_on `x` THEN SRW_TAC [][] THENL [ METIS_TAC [], `FLOOKUP sx v = SOME (Pair t t0)` by METIS_TAC [FLOOKUP_SUBMAP] THEN SRW_TAC [][Once (DISCH_ALL vwalk_def)], - Q.MATCH_ASSUM_RENAME_TAC `FLOOKUP s v = SOME (Const c)` [] THEN + Q.MATCH_ASSUM_RENAME_TAC `FLOOKUP s v = SOME (Const c)` THEN `FLOOKUP sx v = SOME (Const c)` by METIS_TAC [FLOOKUP_SUBMAP] THEN SRW_TAC [][Once (DISCH_ALL vwalk_def)] ]); diff --git a/examples/unification/triangular/nominal/nunifDefScript.sml b/examples/unification/triangular/nominal/nunifDefScript.sml index a001b421fc..c1d0afc5fb 100644 --- a/examples/unification/triangular/nominal/nunifDefScript.sml +++ b/examples/unification/triangular/nominal/nunifDefScript.sml @@ -568,7 +568,7 @@ val uP_subterm_FUPDATE = Q.prove( STRIP_TAC THEN `nwfs (s |+ (v,apply_pi pi t))` by METIS_TAC [nwfs_extend,nvars_nwalkstar_ignores_pi] THEN `s SUBMAP (s|+(v,apply_pi pi t))` by METIS_TAC [SUBMAP_FUPDATE_EQN] THEN -Q.MATCH_ASSUM_RENAME_TAC `nwalk s tt = Sus p v` [] THEN +Q.MATCH_ASSUM_RENAME_TAC `nwalk s tt = Sus p v` THEN Q.PAT_ASSUM `nwalk s tt = Sus p v` MP_TAC THEN Cases_on `tt` THEN SRW_TAC [][nwalk_def] THENL [ Cases_on `nwalk s t2` THEN Cases_on `t2`, @@ -743,8 +743,8 @@ THEN ASM_SIMP_TAC (srw_ss()) [] THENL [ MATCH_MP_TAC (SIMP_RULE (srw_ss()) [] (Q.INST[`t`|->`nPair C C0`] uP_subterm_FUPDATE)) THEN SRW_TAC [][] THEN1 METIS_TAC [nwalk_to_var] THEN METIS_TAC [noc_eq_nvars_nwalkstar,IN_DEF,nvars_nwalkstar_ignores_pi], - Q.MATCH_ASSUM_RENAME_TAC `nwalk s t1 = nPair D1a D1b` [] THEN - Q.MATCH_ASSUM_RENAME_TAC `nwalk s t2 = nPair D2a D2b` [] THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk s t1 = nPair D1a D1b` THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk s t2 = nPair D2a D2b` THEN `uR ((s,fe),D1a,D2a) ((s,fe),t1,t2)` by METIS_TAC [uR_subpair] THEN SRW_TAC [][RESTRICT_LEMMA] THEN Cases_on `x` THEN @@ -845,10 +845,10 @@ SRW_TAC [][Once aux_eqn] THEN SRW_TAC [][Once ntunify_def,SimpRHS] THEN Cases_on `nwalk s t1` THEN Cases_on `nwalk s t2` THEN SRW_TAC [][] THENL [ - Q.MATCH_ASSUM_RENAME_TAC `nwalk q t2 = Tie a2 c2` [] THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk q t2 = Tie a2 c2` THEN Cases_on `term_fcs s' (nwalk* q c2)` THEN SRW_TAC [][], - Q.MATCH_ASSUM_RENAME_TAC `nwalk q t1 = nPair t1a t1d` [] THEN - Q.MATCH_ASSUM_RENAME_TAC `nwalk q t2 = nPair t2a t2d` [] THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk q t1 = nPair t1a t1d` THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk q t2 = nPair t2a t2d` THEN Cases_on `ntunify (q,fe) t1a t2a` THEN SRW_TAC [][UNCURRY] ]); @@ -890,10 +890,10 @@ SRW_TAC [][Once ntunify_def,SimpRHS] THEN SRW_TAC [][Once nunify_def,SimpLHS] THEN Cases_on `nwalk s t1` THEN Cases_on `nwalk s t2` THEN SRW_TAC [][] THENL [ - Q.MATCH_ASSUM_RENAME_TAC `nwalk s t2 = Tie a2 c2` [] THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk s t2 = Tie a2 c2` THEN Cases_on `term_fcs s' (nwalk* s c2)` THEN SRW_TAC [][], - Q.MATCH_ASSUM_RENAME_TAC `nwalk s t1 = nPair t1a t1d` [] THEN - Q.MATCH_ASSUM_RENAME_TAC `nwalk s t2 = nPair t2a t2d` [] THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk s t1 = nPair t1a t1d` THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk s t2 = nPair t2a t2d` THEN Cases_on `ntunify (s,fe) t1a t2a` THEN SRW_TAC [][] THEN `nwfs (FST x)` by METIS_TAC [aux_eq_ntunify,uP_def,aux_uP,PAIR] THEN SRW_TAC [][UNCURRY] diff --git a/examples/unification/triangular/nominal/nunifPropsScript.sml b/examples/unification/triangular/nominal/nunifPropsScript.sml index efb22f069f..274788a582 100644 --- a/examples/unification/triangular/nominal/nunifPropsScript.sml +++ b/examples/unification/triangular/nominal/nunifPropsScript.sml @@ -324,8 +324,8 @@ STRIP_TAC THEN1 ( `equiv fe ([(a1,a2)] · t2) ([(a1,a2)] · ([(a2,a1)] · t2'))` by ( MATCH_MP_TAC equiv_apply_pi THEN SRW_TAC [][]) THEN FULL_SIMP_TAC (srw_ss()) [pmact_flip_args]) THEN - Q.MATCH_ASSUM_RENAME_TAC `a2 ≠ a3` [] THEN - Q.MATCH_ASSUM_RENAME_TAC `fresh fe a2 t3` [] THEN + Q.MATCH_ASSUM_RENAME_TAC `a2 ≠ a3` THEN + Q.MATCH_ASSUM_RENAME_TAC `fresh fe a2 t3` THEN CONJ1_TAC THEN1 ( `equiv fe (apply_pi (REVERSE [(a2,a3)]) t2) (apply_pi (REVERSE [(a2,a3)]) (apply_pi [(a2,a3)] t3))` by METIS_TAC [equiv_apply_pi] THEN @@ -561,7 +561,7 @@ Cases_on `nvwalk s [] v` THEN FULL_SIMP_TAC (psrw_ss()) [] THENL [ SRW_TAC [][] THEN IMP_RES_TAC unify_eq_vars_fresh THEN POP_ASSUM MP_TAC THEN ASM_SIMP_TAC (psrw_ss()) [], - Q.MATCH_ASSUM_RENAME_TAC `nvwalk s [] v = Tie s' C` [] THEN + Q.MATCH_ASSUM_RENAME_TAC `nvwalk s [] v = Tie s' C` THEN (fresh_ds_equiv |> GEN_ALL |> Q.SPECL [`nwalkstar s (Tie s' C)`,`pi2`,`pi1`] |> SIMP_RULE (srw_ss()) [] |> MP_TAC) THEN SRW_TAC [][nwalkstar_apply_pi] THEN @@ -570,7 +570,7 @@ Cases_on `nvwalk s [] v` THEN FULL_SIMP_TAC (psrw_ss()) [] THENL [ SRW_TAC [][] THEN IMP_RES_TAC unify_eq_vars_fresh THEN POP_ASSUM MP_TAC THEN ASM_SIMP_TAC (psrw_ss()) [], - Q.MATCH_ASSUM_RENAME_TAC `nvwalk s [] v = nPair C1 C2` [] THEN + Q.MATCH_ASSUM_RENAME_TAC `nvwalk s [] v = nPair C1 C2` THEN (fresh_ds_equiv |> GEN_ALL |> Q.SPECL [`nwalkstar s (nPair C1 C2)`,`pi2`,`pi1`] |> SIMP_RULE (srw_ss()) [] |> MP_TAC) THEN SRW_TAC [][nwalkstar_apply_pi] THEN @@ -1192,7 +1192,7 @@ Cases_on `x` THEN FULL_SIMP_TAC (srw_ss()) [] THEN `nwfs q` by METIS_TAC [nunify_uP,uP_def] THEN Q.PAT_ASSUM `nunify (q,r) Y Z = X` ASSUME_TAC THEN FULL_SIMP_TAC (srw_ss()) [] THEN -Q.MATCH_ASSUM_RENAME_TAC `nunify (s,fe) C2 C2' = SOME (q,r)` [] THEN +Q.MATCH_ASSUM_RENAME_TAC `nunify (s,fe) C2 C2' = SOME (q,r)` THEN `∃r'. nunify (s,fe') C2 C2' = SOME (q,r')` by METIS_TAC [] THEN SRW_TAC [][]); @@ -1237,8 +1237,8 @@ THEN1 ( Q.EXISTS_TAC `{}` THEN SRW_TAC [][] ) THEN1 ( Q.EXISTS_TAC `{}` THEN SRW_TAC [][] ) THEN1 ( Q.EXISTS_TAC `{}` THEN SRW_TAC [][] ) THEN1 ( - Q.MATCH_ASSUM_RENAME_TAC `nwalk s t1 = Tie s1 C1` [] THEN - Q.MATCH_ASSUM_RENAME_TAC `nwalk s t2 = Tie s2 C2` [] THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk s t1 = Tie s1 C1` THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk s t2 = Tie s2 C2` THEN Cases_on `s1 = s2` THEN SRW_TAC [][] THEN Q.PAT_ASSUM `nwfs s` ASSUME_TAC THEN FULL_SIMP_TAC (srw_ss()) [] THEN @@ -1248,8 +1248,8 @@ THEN1 ( METIS_TAC [UNION_ASSOC,UNION_COMM] ) THEN1 (Q.EXISTS_TAC `{}` THEN SRW_TAC [][] ) THEN1 ( - Q.MATCH_ASSUM_RENAME_TAC `nwalk s t1 = nPair t1a t1d` [] THEN - Q.MATCH_ASSUM_RENAME_TAC `nwalk s t2 = nPair t2a t2d` [] THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk s t1 = nPair t1a t1d` THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk s t2 = nPair t2a t2d` THEN Cases_on `nunify (s,fe) t1a t2a` THEN Q.PAT_ASSUM `nwfs s` ASSUME_TAC THEN FULL_SIMP_TAC (srw_ss()) [] THEN1 ( @@ -1330,8 +1330,8 @@ SRW_TAC [][] THEN1 ( IMP_RES_TAC NOT_FDOM_nvwalk THEN Q.PAT_ASSUM `nwfs s` ASSUME_TAC THEN FULL_SIMP_TAC (srw_ss()) [] THEN SRW_TAC [][] THEN - Q.MATCH_ASSUM_RENAME_TAC `nvwalk s p1 u1 = Sus l n` [] THEN - Q.MATCH_ASSUM_RENAME_TAC `nvwalk s p2 u2 = Sus l' n'` [] THEN + Q.MATCH_ASSUM_RENAME_TAC `nvwalk s p1 u1 = Sus l n` THEN + Q.MATCH_ASSUM_RENAME_TAC `nvwalk s p2 u2 = Sus l' n'` THEN MP_TAC (Q.SPECL [`p1`,`u1`,`s`] (Q.INST [`pu`|->`l`,`u`|->`n`] (UNDISCH nvwalk_SUBMAP_var))) THEN MP_TAC (Q.SPECL [`p2`,`u2`,`s`] (Q.INST [`pu`|->`l'`,`u`|->`n'`] (UNDISCH nvwalk_SUBMAP_var))) THEN SRW_TAC [][] THEN @@ -1412,7 +1412,7 @@ SRW_TAC [][] THEN1 ( NTAC 2 (POP_ASSUM MP_TAC) THEN SRW_TAC [][] THEN REVERSE (SRW_TAC [][Once equiv_cases]) THEN1 METIS_TAC [nwalkstar_apply_pi] THEN - Q.MATCH_RENAME_TAC `fresh fex a (nwalk* sx c)` [] THEN + Q.MATCH_RENAME_TAC `fresh fex a (nwalk* sx c)` THEN Q_TAC SUFF_TAC `fresh fex a (nwalk* sx (nwalk* s c))` THEN1 METIS_TAC [nwalkstar_SUBMAP] THEN MATCH_MP_TAC (GEN_ALL fresh_verify_fcs) THEN @@ -1442,10 +1442,10 @@ SRW_TAC [][] THEN1 ( Q.PAT_ASSUM `nunify X Y Z = SOME (sx,fx0)` ASSUME_TAC THEN Q.PAT_ASSUM `verify_fcs X Y = Z` ASSUME_TAC THEN FULL_SIMP_TAC (srw_ss()) [] THEN - Q.MATCH_ASSUM_RENAME_TAC `nwalk s t1 = nPair t1a t1d` [] THEN - Q.MATCH_ASSUM_RENAME_TAC `nwalk s t2 = nPair t2a t2d` [] THEN - Q.MATCH_ASSUM_RENAME_TAC `nunify (s,fe) t1a t2a = SOME (sa, fea)` [] THEN - Q.MATCH_ASSUM_RENAME_TAC `nunify (sa,fea) t1d t2d = SOME (sd, fed)` [] THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk s t1 = nPair t1a t1d` THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk s t2 = nPair t2a t2d` THEN + Q.MATCH_ASSUM_RENAME_TAC `nunify (s,fe) t1a t2a = SOME (sa, fea)` THEN + Q.MATCH_ASSUM_RENAME_TAC `nunify (sa,fea) t1d t2d = SOME (sd, fed)` THEN `nwfs sa ∧ sa SUBMAP sd` by METIS_TAC [nunify_uP,uP_def] THEN `FINITE fea ∧ fea SUBSET fed ∧ FINITE fed` by METIS_TAC [nunify_FINITE_fe,nunify_extends_fe] THEN @@ -1701,7 +1701,7 @@ val nomunify_COMPAT = Q.store_thm( SRW_TAC [][nomunify_def] THEN Cases_on `x` THEN FULL_SIMP_TAC (srw_ss()) [] THEN SRW_TAC [][] THEN -Q.MATCH_ASSUM_RENAME_TAC `verify_fcs fu0 su = SOME fu` [] THEN +Q.MATCH_ASSUM_RENAME_TAC `verify_fcs fu0 su = SOME fu` THEN `s SUBMAP su ∧ nwfs su` by METIS_TAC [nunify_uP,uP_def] THEN `fe SUBSET fu0` by METIS_TAC [nunify_extends_fe] THEN `FINITE fu0` by METIS_TAC [nunify_FINITE_fe] THEN @@ -1952,7 +1952,7 @@ val fresh_FINITE = Q.store_thm( Induct_on `t` THEN ASM_SIMP_TAC (psrw_ss()) [fresh_def] THEN SRW_TAC [][] THEN1 ( Q.EXISTS_TAC `{}` THEN SRW_TAC [][] ) THEN1 ( - Q.MATCH_ASSUM_RENAME_TAC `x ∈ fe` [] THEN + Q.MATCH_ASSUM_RENAME_TAC `x ∈ fe` THEN Q.EXISTS_TAC `{x}` THEN SRW_TAC [][] ) THEN1 ( Q.EXISTS_TAC `{}` THEN SRW_TAC [][] ) @@ -2025,8 +2025,8 @@ Cases_on `nwalk s t1` THEN Cases_on `nwalk s t2` THEN ASM_SIMP_TAC (psrw_ss()) [Once nunify_def,LET_THM] THEN SRW_TAC [][] THEN FULL_SIMP_TAC (srw_ss()) [] THEN SRW_TAC [][] THEN1 ( - Q.MATCH_ASSUM_RENAME_TAC `nwalk s X = Sus pi vx` ["X"] THEN - Q.MATCH_ASSUM_RENAME_TAC `nwalk s X = Nom a` ["X"] THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk s _ = Sus pi vx` THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk s _ = Nom a` THEN MATCH_MP_TAC (ee |> Q.SPECL [`pi`,`Nom a`] |> SIMP_RULE (srw_ss()) []) THEN `vx ∉ FDOM s` by METIS_TAC [nwalk_to_var] THEN `(nwalk* s t1 = nwalk* s (nwalk s t1)) ∧ @@ -2034,8 +2034,8 @@ THEN1 ( FULL_SIMP_TAC (psrw_ss()) [NOT_FDOM_nvwalk] THEN METIS_TAC [equiv_sym] ) THEN1 ( - Q.MATCH_ASSUM_RENAME_TAC `nwalk s X = Sus pi vx` ["X"] THEN - Q.MATCH_ASSUM_RENAME_TAC `nwalk s X = Nom a` ["X"] THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk s _ = Sus pi vx` THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk s _ = Nom a` THEN MATCH_MP_TAC (ee |> Q.SPECL [`pi`,`Nom a`] |> SIMP_RULE (srw_ss()) []) THEN `vx ∉ FDOM s` by METIS_TAC [nwalk_to_var] THEN `(nwalk* s t1 = nwalk* s (nwalk s t1)) ∧ @@ -2047,40 +2047,40 @@ THEN1 ( IMP_RES_TAC unify_eq_vars_preserves_s THEN FULL_SIMP_TAC (srw_ss()) [] ) THEN1 ( - Q.MATCH_ASSUM_RENAME_TAC `nwalk s t1 = Sus pi1 vx` [] THEN - Q.MATCH_ASSUM_RENAME_TAC `nwalk s t2 = Sus pi2 v2` [] THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk s t1 = Sus pi1 vx` THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk s t2 = Sus pi2 v2` THEN MATCH_MP_TAC (ee |> Q.SPECL [`pi1`,`Sus pi2 v2`] |> SIMP_RULE (psrw_ss()) []) THEN `vx ∉ FDOM s` by METIS_TAC [nwalk_to_var] THEN `(nwalk* s t1 = nwalk* s (nwalk s t1)) ∧ (nwalk* s t2 = nwalk* s (nwalk s t2))` by METIS_TAC [nwalkstar_nwalk] THEN FULL_SIMP_TAC (psrw_ss()) [NOT_FDOM_nvwalk]) THEN1 ( - Q.MATCH_ASSUM_RENAME_TAC `nwalk s X = Sus pi vx` ["X"] THEN - Q.MATCH_ASSUM_RENAME_TAC `nwalk s X = Tie a c` ["X"] THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk s _ = Sus pi vx` THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk s _ = Tie a c` THEN MATCH_MP_TAC (ee |> Q.SPECL [`pi`,`Tie a c`] |> SIMP_RULE (srw_ss()) []) THEN `vx ∉ FDOM s` by METIS_TAC [nwalk_to_var] THEN `(nwalk* s t1 = nwalk* s (nwalk s t1)) ∧ (nwalk* s t2 = nwalk* s (nwalk s t2))` by METIS_TAC [nwalkstar_nwalk] THEN FULL_SIMP_TAC (psrw_ss()) [NOT_FDOM_nvwalk] ) THEN1 ( - Q.MATCH_ASSUM_RENAME_TAC `nwalk s X = Sus pi vx` ["X"] THEN - Q.MATCH_ASSUM_RENAME_TAC `nwalk s X = nPair c1 c2` ["X"] THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk s _ = Sus pi vx` THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk s _ = nPair c1 c2` THEN MATCH_MP_TAC (ee |> Q.SPECL [`pi`,`nPair c1 c2`] |> SIMP_RULE (srw_ss()) []) THEN `vx ∉ FDOM s` by METIS_TAC [nwalk_to_var] THEN `(nwalk* s t1 = nwalk* s (nwalk s t1)) ∧ (nwalk* s t2 = nwalk* s (nwalk s t2))` by METIS_TAC [nwalkstar_nwalk] THEN FULL_SIMP_TAC (psrw_ss()) [NOT_FDOM_nvwalk] ) THEN1 ( - Q.MATCH_ASSUM_RENAME_TAC `nwalk s X = Sus pi vx` ["X"] THEN - Q.MATCH_ASSUM_RENAME_TAC `nwalk s X = nConst c` ["X"] THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk s _ = Sus pi vx` THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk s _ = nConst c` THEN MATCH_MP_TAC (ee |> Q.SPECL [`pi`,`nConst c`] |> SIMP_RULE (srw_ss()) []) THEN `vx ∉ FDOM s` by METIS_TAC [nwalk_to_var] THEN `(nwalk* s t1 = nwalk* s (nwalk s t1)) ∧ (nwalk* s t2 = nwalk* s (nwalk s t2))` by METIS_TAC [nwalkstar_nwalk] THEN FULL_SIMP_TAC (psrw_ss()) [NOT_FDOM_nvwalk] ) THEN1 ( - Q.MATCH_ASSUM_RENAME_TAC `nwalk s X = Sus pi vx` ["X"] THEN - Q.MATCH_ASSUM_RENAME_TAC `nwalk s X = Tie a c` ["X"] THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk s _ = Sus pi vx` THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk s _ = Tie a c` THEN MATCH_MP_TAC (ee |> Q.SPECL [`pi`,`Tie a c`] |> SIMP_RULE (srw_ss()) []) THEN `vx ∉ FDOM s` by METIS_TAC [nwalk_to_var] THEN `(nwalk* s t1 = nwalk* s (nwalk s t1)) ∧ @@ -2102,8 +2102,8 @@ THEN1 ( Q.PAT_ASSUM `equiv fe2 X Y` MP_TAC THEN ASM_SIMP_TAC (srw_ss()) [Once equiv_cases,nwalkstar_apply_pi] ) THEN1 ( - Q.MATCH_ASSUM_RENAME_TAC `nwalk s X = Sus pi vx` ["X"] THEN - Q.MATCH_ASSUM_RENAME_TAC `nwalk s X = nPair c1 c2` ["X"] THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk s _ = Sus pi vx` THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk s _ = nPair c1 c2` THEN MATCH_MP_TAC (ee |> Q.SPECL [`pi`,`nPair c1 c2`] |> SIMP_RULE (srw_ss()) []) THEN `vx ∉ FDOM s` by METIS_TAC [nwalk_to_var] THEN `(nwalk* s t1 = nwalk* s (nwalk s t1)) ∧ @@ -2113,8 +2113,8 @@ THEN1 ( THEN1 ( Cases_on `x` THEN Cases_on `x'` THEN FULL_SIMP_TAC (srw_ss()) [] THEN SRW_TAC [][] THEN - Q.MATCH_ASSUM_RENAME_TAC `nunify (s,fe) t1a t2a = SOME (sa,fa)` [] THEN - Q.MATCH_ASSUM_RENAME_TAC `nunify (sa,fa) t1d t2d = SOME (sd,fd)` [] THEN + Q.MATCH_ASSUM_RENAME_TAC `nunify (s,fe) t1a t2a = SOME (sa,fa)` THEN + Q.MATCH_ASSUM_RENAME_TAC `nunify (sa,fa) t1d t2d = SOME (sd,fd)` THEN `nwfs sa ∧ FINITE fa ∧ fa ⊆ fd ∧ FINITE fd ∧ sa SUBMAP sd ∧ nwfs sd` by METIS_TAC [nunify_uP,uP_def,nunify_FINITE_fe,nunify_extends_fe] THEN `∃fad. (verify_fcs fa sd = SOME fad)` by METIS_TAC [verify_fcs_SUBSET] THEN @@ -2128,8 +2128,8 @@ THEN1 ( SRW_TAC [][Once equiv_cases] THEN METIS_TAC [equiv_trans,equiv_refl,equiv_sym] ) THEN1 ( - Q.MATCH_ASSUM_RENAME_TAC `nwalk s X = Sus pi vx` ["X"] THEN - Q.MATCH_ASSUM_RENAME_TAC `nwalk s X = nConst c` ["X"] THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk s _ = Sus pi vx` THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk s _ = nConst c` THEN MATCH_MP_TAC (ee |> Q.SPECL [`pi`,`nConst c`] |> SIMP_RULE (srw_ss()) []) THEN `vx ∉ FDOM s` by METIS_TAC [nwalk_to_var] THEN `(nwalk* s t1 = nwalk* s (nwalk s t1)) ∧ @@ -2222,7 +2222,7 @@ Q.PAT_ASSUM `nwfs sx` ASSUME_TAC THEN Cases_on `t` THEN FULL_SIMP_TAC (psrw_ss()) [] THEN Cases_on `nvwalk sx l' n'` THEN FULL_SIMP_TAC (psrw_ss()) [] THEN IMP_RES_TAC nvwalk_to_var THEN -Q.MATCH_ASSUM_RENAME_TAC `v ∉ FDOM sx` [] THEN +Q.MATCH_ASSUM_RENAME_TAC `v ∉ FDOM sx` THEN `v ∉ FDOM s` by METIS_TAC [SUBMAP_DEF,SUBSET_DEF] THEN SRW_TAC [][] THEN FULL_SIMP_TAC (srw_ss()) [NOT_FDOM_nvwalk]); @@ -2272,7 +2272,7 @@ THEN1 ( FULL_SIMP_TAC (srw_ss()) [] ) THEN NTAC 2 (POP_ASSUM MP_TAC) THEN Cases_on `x` THEN SRW_TAC [][] THEN -Q.MATCH_ASSUM_RENAME_TAC `nunify (s,fe) t1a t2a = SOME (sa,fa)` [] THEN +Q.MATCH_ASSUM_RENAME_TAC `nunify (s,fe) t1a t2a = SOME (sa,fa)` THEN Cases_on `(a,v) ∈ fa` THEN FULL_SIMP_TAC (srw_ss()) [] THEN `nwfs sa ∧ FINITE fa ∧ s SUBMAP sa` by METIS_TAC [nunify_uP,uP_def,nunify_FINITE_fe] THEN METIS_TAC [SUBMAP_DEF,SUBSET_DEF]); @@ -2367,7 +2367,7 @@ val equiv_fcs_nwalkstar = Q.store_thm( MAP_EVERY Q.ID_SPEC_TAC [`fe2`,`fe1`,`t2`,`t1`] THEN Induct THEN Cases_on `t2` THEN FULL_SIMP_TAC (psrw_ss()) [] THEN1 ( SRW_TAC [][] THEN - Q.MATCH_ASSUM_RENAME_TAC `equiv_fcs (nwalk* s (Sus p1 v)) (nwalk* s (Sus p2 v)) = SOME fe2` [] THEN + Q.MATCH_ASSUM_RENAME_TAC `equiv_fcs (nwalk* s (Sus p1 v)) (nwalk* s (Sus p2 v)) = SOME fe2` THEN `equiv fe2 (apply_pi p1 (nwalk* s (Sus [] v))) (apply_pi p2 (nwalk* s (Sus [] v)))` by ( IMP_RES_TAC equiv_fcs_equiv THEN POP_ASSUM MP_TAC THEN @@ -2404,7 +2404,7 @@ REPEAT STRIP_TAC THEN IMP_RES_TAC term_fcs_fresh THEN IMP_RES_TAC fresh_SUBMAP THEN IMP_RES_TAC fresh_term_fcs THEN -Q.MATCH_ASSUM_RENAME_TAC `term_fcs a t = SOME fe0` [] THEN +Q.MATCH_ASSUM_RENAME_TAC `term_fcs a t = SOME fe0` THEN Q.EXISTS_TAC `fe0` THEN CONJ_TAC THEN1 SRW_TAC [][] THEN REPEAT STRIP_TAC THEN `(b,w) ∈ fe` by FULL_SIMP_TAC (srw_ss()) [SUBSET_DEF] THEN @@ -2496,7 +2496,7 @@ Q_TAC SUFF_TAC NTAC 3 (Q.PAT_ASSUM `!X.Y` (K ALL_TAC)) THEN IMP_RES_TAC equiv_fcs_minimal THEN FULL_SIMP_TAC (srw_ss()) [nomunify_def,EXISTS_PROD] THEN - Q.MATCH_ASSUM_RENAME_TAC `nunify (s,fe) t1 t2 = SOME (sx,fx)` [] THEN + Q.MATCH_ASSUM_RENAME_TAC `nunify (s,fe) t1 t2 = SOME (sx,fx)` THEN `FINITE fx` by IMP_RES_TAC nunify_FINITE_fe THEN `∃b w fcs. (b,w) ∈ fx ∧ (term_fcs b (nwalk* sx (Sus [] w)) = SOME fcs) ∧ (a,v) ∈ fcs` by (MATCH_MP_TAC (GEN_ALL verify_fcs_minimal) THEN SRW_TAC [][]) THEN @@ -2549,8 +2549,8 @@ THEN1 ( MAP_EVERY Q.EXISTS_TAC [`sxx`,`b`,`w`] THEN SRW_TAC [][]) THEN FULL_SIMP_TAC (srw_ss()) [] THEN - Q.MATCH_ASSUM_RENAME_TAC `nwalk s t1 = Tie a1 c1` [] THEN - Q.MATCH_ASSUM_RENAME_TAC `nwalk s t2 = Tie a2 c2` [] THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk s t1 = Tie a1 c1` THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk s t2 = Tie a2 c2` THEN `nwfs sx ∧ s SUBMAP sx` by METIS_TAC [nunify_uP,uP_def] THEN `(nwalk* sxx t1 = nwalk* sxx (nwalk s t1)) ∧ (nwalk* sxx t2 = nwalk* sxx (nwalk s t2))` @@ -2575,8 +2575,8 @@ THEN1 ( SRW_TAC [][nwalkstar_apply_pi]) THEN1 ( Cases_on `x` THEN FULL_SIMP_TAC (srw_ss()) [] THEN - Q.MATCH_ASSUM_RENAME_TAC `nunify (s,fe) t1a t2a = SOME (sa,fa)` [] THEN - Q.MATCH_ASSUM_RENAME_TAC `nunify (sa,fa) t1d t2d = SOME (sd,fd)` [] THEN + Q.MATCH_ASSUM_RENAME_TAC `nunify (s,fe) t1a t2a = SOME (sa,fa)` THEN + Q.MATCH_ASSUM_RENAME_TAC `nunify (sa,fa) t1d t2d = SOME (sd,fd)` THEN `nwfs sa ∧ FINITE fa ∧ fa ⊆ fd ∧ FINITE fd ∧ s SUBMAP sa ∧ sa SUBMAP sd ∧ nwfs sd` by METIS_TAC [nunify_uP,uP_def,nunify_FINITE_fe,nunify_extends_fe] THEN `(nwalk* sxx t1 = nwalk* sxx (nwalk s t1)) ∧ @@ -2662,8 +2662,8 @@ THEN1 ( THEN1 ( IMP_RES_TAC nwalkstar_subterm_exists THEN SRW_TAC [][] THEN - Q.MATCH_ASSUM_RENAME_TAC `nwalk* s t1 = Tie a (nwalk* s c1)`[] THEN - Q.MATCH_ASSUM_RENAME_TAC `nwalk* s t2 = Tie a (nwalk* s c2)`[] THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk* s t1 = Tie a (nwalk* s c1)` THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk* s t2 = Tie a (nwalk* s c2)` THEN NTAC 2 (POP_ASSUM (K ALL_TAC)) THEN FIRST_X_ASSUM (Q.SPECL_THEN [`c1`,`c2`,`s`] MP_TAC) THEN SRW_TAC [][] THEN @@ -2673,8 +2673,8 @@ THEN1 ( IMP_RES_TAC nwalkstar_subterm_exists THEN SRW_TAC [][] THEN NTAC 2 (POP_ASSUM (K ALL_TAC)) THEN - Q.MATCH_ASSUM_RENAME_TAC `nwalk* s t1 = Tie a1 (nwalk* s c1)`[] THEN - Q.MATCH_ASSUM_RENAME_TAC `nwalk* s t2' = Tie a2 (nwalk* s c2)`[] THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk* s t1 = Tie a1 (nwalk* s c1)` THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk* s t2' = Tie a2 (nwalk* s c2)` THEN FIRST_X_ASSUM (Q.SPECL_THEN [`c1`,`apply_pi [(a1,a2)] c2`,`s`] MP_TAC) THEN SRW_TAC [][nwalkstar_apply_pi] THEN SRW_TAC [][Once equiv_cases] THEN @@ -2696,8 +2696,8 @@ THEN1 ( IMP_RES_TAC nwalkstar_subterm_exists THEN SRW_TAC [][] THEN POP_ASSUM (K ALL_TAC) THEN - Q.MATCH_ASSUM_RENAME_TAC `nwalk* s t1 = nPair (nwalk* s t1a) (nwalk* s t1d)` [] THEN - Q.MATCH_ASSUM_RENAME_TAC `nwalk* s t2 = nPair (nwalk* s t2a) (nwalk* s t2d)` [] THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk* s t1 = nPair (nwalk* s t1a) (nwalk* s t1d)` THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk* s t2 = nPair (nwalk* s t2a) (nwalk* s t2d)` THEN FIRST_X_ASSUM (Q.SPECL_THEN [`t1d`,`t2d`,`s`] MP_TAC) THEN FIRST_X_ASSUM (Q.SPECL_THEN [`t1a`,`t2a`,`s`] MP_TAC) THEN SRW_TAC [][] THEN @@ -2780,7 +2780,7 @@ THEN1 ( SRW_TAC [][] THEN FULL_SIMP_TAC (srw_ss()) [] THEN1 ( FIRST_X_ASSUM MATCH_MP_TAC THEN ASM_SIMP_TAC (srw_ss()) [nwalk_apply_pi] THEN - Q.MATCH_ASSUM_RENAME_TAC `nwalk s t1 = Tie X (apply_pi Y t)` ["X","Y"] THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk s t1 = Tie _ (apply_pi _ t)` THEN MAP_EVERY Q.EXISTS_TAC [`q1`,`q2`,`nwalk s t`] THEN SRW_TAC [][] THEN Q.PAT_ASSUM `!X.Y` MP_TAC THEN @@ -2789,7 +2789,7 @@ THEN1 ( FULL_SIMP_TAC (srw_ss()) [dis_set_def] THEN SRW_TAC [][] THEN FULL_SIMP_TAC (srw_ss()) [] THEN SRW_TAC [][nwalkstar_nwalk] ) THEN - Q.MATCH_ASSUM_RENAME_TAC `nwalk s t1 = Tie (lswapstr q1 a) (apply_pi q1 t)` [] THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk s t1 = Tie (lswapstr q1 a) (apply_pi q1 t)` THEN `lswapstr (REVERSE q2) (lswapstr q1 a) ∈ dis_set q1 q2` by ( ASM_SIMP_TAC (srw_ss()) [dis_set_def] THEN FULL_SIMP_TAC (srw_ss())[pmact_eql] ) THEN @@ -2836,14 +2836,14 @@ THEN1 ( THEN1 ( SRW_TAC [][EXISTS_PROD] THEN FULL_SIMP_TAC (srw_ss()) [] THEN FULL_SIMP_TAC (srw_ss()) [nwalk_apply_pi] THEN - Q.MATCH_ASSUM_RENAME_TAC `nwalk s t1 = nPair (apply_pi q1 ta) (apply_pi q1 td)` [] THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk s t1 = nPair (apply_pi q1 ta) (apply_pi q1 td)` THEN FIRST_X_ASSUM (Q.SPECL_THEN [`q1`,`q2`,`nwalk s ta`] MP_TAC) THEN SRW_TAC [][] THEN Q.PAT_ASSUM `!X.Y` MP_TAC THEN SRW_TAC [][Once term_fcs_def] THEN Q.PAT_ASSUM `nwfs s` ASSUME_TAC THEN FULL_SIMP_TAC (srw_ss()) [nwalkstar_nwalk] THEN - Q.MATCH_ASSUM_RENAME_TAC `nunify (s,fe) X Y = SOME (s,fu)` ["X","Y"] THEN + Q.MATCH_ASSUM_RENAME_TAC `nunify (s,fe) _ _ = SOME (s,fu)` THEN FIRST_X_ASSUM (Q.SPECL_THEN [`s`,`fu`] MP_TAC) THEN SRW_TAC [][] THEN FIRST_X_ASSUM MATCH_MP_TAC THEN @@ -2858,7 +2858,7 @@ val nvars_measure = Q.store_thm( `v ∈ nvars t ∧ ¬ is_Sus t ∧ nwfs s ⇒ measure (npair_count o (nwalk* s)) (Sus [] v) t`, Induct_on `t` THEN SRW_TAC [][] THEN -Q.MATCH_ASSUM_RENAME_TAC `v ∈ nvars tt` [] THEN +Q.MATCH_ASSUM_RENAME_TAC `v ∈ nvars tt` THEN Cases_on `tt` THEN FULL_SIMP_TAC (srw_ss()) [] THEN FULL_SIMP_TAC (srw_ss()++ARITH_ss) [measure_thm] THEN (npair_count_nwalkstar_ignores_pi |> @@ -3066,32 +3066,32 @@ THEN1 ( MATCH_MP_TAC (GEN_ALL unify_eq_vars_verify_fcs) THEN METIS_TAC [FINITE_dis_set,FINITE_EMPTY,verify_fcs_empty]) THEN1 ( - Q.MATCH_ASSUM_RENAME_TAC `nwalk s Z = Tie a t` ["Z"] THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk s _ = Tie a t` THEN (noc_subterm_nequiv |> CONTRAPOS |> Q.INST [`v`|->`n`,`t`|->`Tie a t`,`pi`|->`l`,`fe`|->`fe2`] |> MP_TAC) THEN FULL_SIMP_TAC (srw_ss()) [noc_ignores_pi]) THEN1 ( - Q.MATCH_ASSUM_RENAME_TAC `nwalk s Z = nPair c1 c2` ["Z"] THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk s _ = nPair c1 c2` THEN (noc_subterm_nequiv |> CONTRAPOS |> Q.INST [`v`|->`n`,`t`|->`nPair c1 c2`,`pi`|->`l`,`fe`|->`fe2`] |> MP_TAC) THEN FULL_SIMP_TAC (srw_ss()) [noc_ignores_pi]) THEN1 ( - Q.MATCH_ASSUM_RENAME_TAC `nwalk s Z = nPair c1 c2` ["Z"] THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk s _ = nPair c1 c2` THEN (noc_subterm_nequiv |> CONTRAPOS |> Q.INST [`v`|->`n`,`t`|->`nPair c1 c2`,`pi`|->`l`,`fe`|->`fe2`] |> MP_TAC) THEN FULL_SIMP_TAC (srw_ss()) [noc_ignores_pi]) THEN1 ( - Q.MATCH_ASSUM_RENAME_TAC `nwalk s Z = Tie a t` ["Z"] THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk s _ = Tie a t` THEN (noc_subterm_nequiv |> CONTRAPOS |> Q.INST [`v`|->`n`,`t`|->`Tie a t`,`pi`|->`l`,`fe`|->`fe2`] |> MP_TAC) THEN FULL_SIMP_TAC (srw_ss()) [noc_ignores_pi,equiv_sym]) THEN1 ( - Q.MATCH_ASSUM_RENAME_TAC `nwalk s t1 = Tie a1 c1` [] THEN - Q.MATCH_ASSUM_RENAME_TAC `nwalk s t2 = Tie a2 c2` [] THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk s t1 = Tie a1 c1` THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk s t2 = Tie a2 c2` THEN Cases_on `a1 = a2` THEN SRW_TAC [][] THEN1 ( POP_ASSUM MATCH_MP_TAC THEN FULL_SIMP_TAC (srw_ss()) [Once equiv_cases] ) THEN @@ -3131,20 +3131,20 @@ THEN1 ( by METIS_TAC [verify_fcs_NONE] THEN METIS_TAC [term_fcs_nwalkstar,optionTheory.NOT_SOME_NONE] ) THEN1 ( - Q.MATCH_ASSUM_RENAME_TAC `nwalk s Z = nPair c1 c2` ["Z"] THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk s _ = nPair c1 c2` THEN (noc_subterm_nequiv |> CONTRAPOS |> Q.INST [`v`|->`n`,`t`|->`nPair c1 c2`,`pi`|->`l`,`fe`|->`fe2`] |> MP_TAC) THEN FULL_SIMP_TAC (srw_ss()) [noc_ignores_pi,equiv_sym]) THEN1 ( - Q.MATCH_ASSUM_RENAME_TAC `nwalk s Z = nPair c1 c2` ["Z"] THEN + Q.MATCH_ASSUM_RENAME_TAC `nwalk s _ = nPair c1 c2` THEN (noc_subterm_nequiv |> CONTRAPOS |> Q.INST [`v`|->`n`,`t`|->`nPair c1 c2`,`pi`|->`l`,`fe`|->`fe2`] |> MP_TAC) THEN FULL_SIMP_TAC (srw_ss()) [noc_ignores_pi,equiv_sym]) THEN SRW_TAC [][EXISTS_PROD] THEN -Q.MATCH_ASSUM_RENAME_TAC `nwalk s t1 = nPair t1a t1d` [] THEN -Q.MATCH_ASSUM_RENAME_TAC `nwalk s t2 = nPair t2a t2d` [] THEN +Q.MATCH_ASSUM_RENAME_TAC `nwalk s t1 = nPair t1a t1d` THEN +Q.MATCH_ASSUM_RENAME_TAC `nwalk s t2 = nPair t2a t2d` THEN Q.PAT_ASSUM `equiv fe2 X Y` MP_TAC THEN SRW_TAC [][Once equiv_cases] THEN FULL_SIMP_TAC (srw_ss()) [] THEN @@ -3164,10 +3164,10 @@ FULL_SIMP_TAC (srw_ss()) [] THEN by METIS_TAC [equiv_trans,equiv_sym] THEN `nwfs sx ∧ FINITE fu` by METIS_TAC [nunify_uP,uP_def,nunify_FINITE_fe,FINITE_EMPTY] THEN FULL_SIMP_TAC (srw_ss()) [] THEN -Q.MATCH_ASSUM_RENAME_TAC `nunify (s,{}) t1a t2a = SOME (sa,fa)` [] THEN -Q.MATCH_ASSUM_RENAME_TAC `nunify (sa,{}) t1d t2d = SOME (sd,fd)` [] THEN -Q.MATCH_ASSUM_RENAME_TAC `verify_fcs fa sa = SOME faa` [] THEN -Q.MATCH_ASSUM_RENAME_TAC `verify_fcs fd sd = SOME fdd` [] THEN +Q.MATCH_ASSUM_RENAME_TAC `nunify (s,{}) t1a t2a = SOME (sa,fa)` THEN +Q.MATCH_ASSUM_RENAME_TAC `nunify (sa,{}) t1d t2d = SOME (sd,fd)` THEN +Q.MATCH_ASSUM_RENAME_TAC `verify_fcs fa sa = SOME faa` THEN +Q.MATCH_ASSUM_RENAME_TAC `verify_fcs fd sd = SOME fdd` THEN `∃fe1. nunify (sa,fa) t1d t2d = SOME (sd,fe1)` by METIS_TAC [nunify_ignores_fe] THEN `fe1 = fa ∪ fd` by ( diff --git a/examples/unification/triangular/nominal/nwalkScript.sml b/examples/unification/triangular/nominal/nwalkScript.sml index 1283baa807..873bbaebd4 100644 --- a/examples/unification/triangular/nominal/nwalkScript.sml +++ b/examples/unification/triangular/nominal/nwalkScript.sml @@ -106,12 +106,12 @@ Cases_on `t` THENL [ `u IN nvars t` by METIS_TAC [nvars_apply_pi] THEN MATCH_MP_TAC TC_SUBSET THEN SRW_TAC [][nvR_def], - Q.MATCH_ASSUM_RENAME_TAC `FLOOKUP s v = SOME (nPair t1 t2)` [] THEN + Q.MATCH_ASSUM_RENAME_TAC `FLOOKUP s v = SOME (nPair t1 t2)` THEN `∃pi. nvwalk s p v = apply_pi pi (nPair t1 t2)` by (SRW_TAC [][Once nvwalk_def] THEN METIS_TAC []) THEN `u IN nvars (nPair t1 t2)` by METIS_TAC [nvars_apply_pi] THEN MATCH_MP_TAC TC_SUBSET THEN SRW_TAC [][nvR_def] THEN FULL_SIMP_TAC (srw_ss()) [], - Q.MATCH_ASSUM_RENAME_TAC `FLOOKUP s v = SOME (nConst c)` [] THEN + Q.MATCH_ASSUM_RENAME_TAC `FLOOKUP s v = SOME (nConst c)` THEN `nvwalk s p v = nConst c` by (SRW_TAC [] [Once nvwalk_def]) THEN FULL_SIMP_TAC (srw_ss()) [] ]); diff --git a/examples/unification/triangular/nominal/nwalkstarScript.sml b/examples/unification/triangular/nominal/nwalkstarScript.sml index 920cb93c17..863d808d1f 100644 --- a/examples/unification/triangular/nominal/nwalkstarScript.sml +++ b/examples/unification/triangular/nominal/nwalkstarScript.sml @@ -148,7 +148,7 @@ Cases_on `t` THEN SRW_TAC [][] THENL [ SRW_TAC [][mlt1_def] THEN MAP_EVERY Q.EXISTS_TAC [`n`,`nvarb t2`,`{||}`] THEN SRW_TAC [][], - Q.MATCH_RENAME_TAC `X ∨ Y ∧ 0 < 1 + npair_count t1` ["X","Y"] THEN + Q.MATCH_RENAME_TAC `_ ∨ _ ∧ 0 < 1 + npair_count t1` THEN Cases_on `nvarb t1 = {||}` THEN1 SRW_TAC [ARITH_ss][] THEN DISJ1_TAC THEN Q.MATCH_ABBREV_TAC `(mlt1 R)^+ b2 (b1 + b2)` THEN @@ -170,8 +170,7 @@ Cases_on `t` THEN SRW_TAC [][] THENL [ MAP_EVERY Q.EXISTS_TAC [`n`,`nvarb t1`,`{||}`] THEN SRW_TAC [][], Q.MATCH_RENAME_TAC - `X ∨ Y ∧ npair_count t1 < 1 + npair_count t1 + npair_count t2` - ["X","Y"] THEN + `_ ∨ _ ∧ npair_count t1 < 1 + npair_count t1 + npair_count t2` THEN Cases_on `nvarb t2 = {||}` THEN1 SRW_TAC [ARITH_ss][] THEN DISJ1_TAC THEN MATCH_MP_TAC TC_mlt1_UNION2_I THEN @@ -405,7 +404,7 @@ val TC_nvR_nvars_nwalkstar = Q.store_thm( by METIS_TAC [EXTEND_RTC_TC_EQN,RTC_CASES1] THEN FULL_SIMP_TAC (srw_ss()) [NOT_FDOM_nwalkstar] THEN METIS_TAC [], - Q.MATCH_RENAME_TAC `v IN nvars (nwalkstar s t1) ∨ v IN nvars (nwalkstar s t2)` [] THEN + Q.MATCH_RENAME_TAC `v IN nvars (nwalkstar s t1) ∨ v IN nvars (nwalkstar s t2)` THEN `?u. u IN nvars (nPair t1 t2) /\ (nvR s)^* v u` by (SRW_TAC [][] THEN METIS_TAC [nvwalk_EQ_pair_nvR]) THEN `(u = v) \/ (nvR s)^+ v u` From 35460a5848674fc9b83e70d9472f8dc9ed820620 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 9 Jan 2015 17:08:37 +1100 Subject: [PATCH 103/718] Changes in light of 92317114 --- .../machine-code/multiword/x64_multiwordScript.sml | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/examples/machine-code/multiword/x64_multiwordScript.sml b/examples/machine-code/multiword/x64_multiwordScript.sml index 73354c6627..857dad5469 100644 --- a/examples/machine-code/multiword/x64_multiwordScript.sml +++ b/examples/machine-code/multiword/x64_multiwordScript.sml @@ -1731,7 +1731,7 @@ val x64_div_test_thm = prove( \\ Cases_on `single_mul_add (n2w (w2n q - 1)) v1 0x0w 0x0w` \\ FULL_SIMP_TAC std_ss [LET_DEF,x64_cmp2_thm] \\ Q.MATCH_ASSUM_RENAME_TAC - `single_mul_add (n2w (w2n q - 1)) v1 0x0w 0x0w = (q1,q2)` [] + `single_mul_add (n2w (w2n q - 1)) v1 0x0w 0x0w = (q1,q2)` \\ FULL_SIMP_TAC std_ss [mw_add_0_1] \\ Cases_on `mw_cmp [u2; u1] [q1; q2 + 0x1w] = SOME T` \\ FULL_SIMP_TAC std_ss [EVAL ``0w = 1w:word64``]); @@ -1893,9 +1893,9 @@ val x64_adjust_aux_thm = prove( \\ DECIDE_TAC) \\ ONCE_REWRITE_TAC [x64_adjust_aux_def,x64_adjust_aux_pre_def] \\ Cases_on `zs` \\ SIMP_TAC std_ss [LENGTH,ADD1] \\ NTAC 8 STRIP_TAC - \\ Q.MATCH_ASSUM_RENAME_TAC `LENGTH (zs1 ++ z::zs) < dimword (:64)` [] + \\ Q.MATCH_ASSUM_RENAME_TAC `LENGTH (zs1 ++ z::zs) < dimword (:64)` \\ POP_ASSUM MP_TAC - \\ Q.MATCH_ASSUM_RENAME_TAC `LENGTH (ys1 ++ y::ys) < dimword (:64)` [] + \\ Q.MATCH_ASSUM_RENAME_TAC `LENGTH (ys1 ++ y::ys) < dimword (:64)` \\ STRIP_TAC \\ `n2w (LENGTH (ys1 ++ y::ys)) <> n2w (LENGTH ys1):word64` by ALL_TAC THEN1 (FULL_SIMP_TAC std_ss [LENGTH_APPEND] @@ -2042,9 +2042,9 @@ val x64_div_sub_loop_thm = prove( \\ FULL_SIMP_TAC std_ss [LET_DEF,SNOC_INTRO,APPEND_NIL] \\ DECIDE_TAC) \\ ONCE_REWRITE_TAC [x64_div_sub_loop_def,x64_div_sub_loop_pre_def] \\ Cases_on `zs` \\ SIMP_TAC std_ss [LENGTH,ADD1] \\ NTAC 8 STRIP_TAC - \\ Q.MATCH_ASSUM_RENAME_TAC `LENGTH (zs1 ++ z::zs) < dimword (:64)` [] + \\ Q.MATCH_ASSUM_RENAME_TAC `LENGTH (zs1 ++ z::zs) < dimword (:64)` \\ POP_ASSUM MP_TAC - \\ Q.MATCH_ASSUM_RENAME_TAC `LENGTH (ys1 ++ y::ys) < dimword (:64)` [] + \\ Q.MATCH_ASSUM_RENAME_TAC `LENGTH (ys1 ++ y::ys) < dimword (:64)` \\ STRIP_TAC \\ `n2w (LENGTH (ys1 ++ y::ys)) <> n2w (LENGTH ys1):word64` by (FULL_SIMP_TAC std_ss [LENGTH_APPEND] @@ -2432,7 +2432,7 @@ val x64_copy_down_thm = prove( \\ FULL_SIMP_TAC std_ss [GSYM word_add_n2w,WORD_ADD_SUB,LET_DEF] \\ FULL_SIMP_TAC std_ss [word_add_n2w] \\ Cases_on `zs1` \\ FULL_SIMP_TAC std_ss [] - \\ Q.MATCH_ASSUM_RENAME_TAC `z::zs <> []` [] + \\ Q.MATCH_ASSUM_RENAME_TAC `z::zs <> []` \\ FULL_SIMP_TAC std_ss [] \\ `(LENGTH (zs0 ++ z::zs) + 1 = LENGTH (SNOC h zs0 ++ SNOC h zs)) /\ (LENGTH zs0 + 1 = LENGTH (SNOC h zs0))` @@ -2700,7 +2700,7 @@ val x64_div_thm = prove( \\ FULL_SIMP_TAC std_ss [] \\ NTAC 2 (POP_ASSUM (K ALL_TAC)) \\ Cases_on `t` \\ FULL_SIMP_TAC std_ss [LENGTH,LENGTH_APPEND] THEN1 (`F` by DECIDE_TAC) - \\ Q.MATCH_ASSUM_RENAME_TAC `zs = zs1 ++ z1::z2::zs2` [] + \\ Q.MATCH_ASSUM_RENAME_TAC `zs = zs1 ++ z1::z2::zs2` \\ FULL_SIMP_TAC std_ss [LENGTH_mw_mul_by_single] \\ `LENGTH xs + 1 < dimword (:64)` by DECIDE_TAC \\ FULL_SIMP_TAC std_ss [w2n_n2w] \\ `LUPDATE 0x0w (LENGTH xs + 1) (mw_mul_by_single d xs ++ z2::zs2) = From 7106a911db9b2cfb1176afdb257b8dfe7b436431 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 9 Jan 2015 21:26:40 +1100 Subject: [PATCH 104/718] Fixes to category theory example in light of 92317114 --- examples/category/YonedaScript.sml | 10 +++++----- examples/category/categoryScript.sml | 4 ++-- examples/category/ens_catScript.sml | 4 ++-- examples/category/functorScript.sml | 14 +++++++------- examples/category/hom_functorScript.sml | 6 +++--- examples/category/limitScript.sml | 8 ++++---- examples/category/nat_transScript.sml | 8 ++++---- examples/category/zfset_catScript.sml | 16 ++++++++-------- 8 files changed, 35 insertions(+), 35 deletions(-) diff --git a/examples/category/YonedaScript.sml b/examples/category/YonedaScript.sml index e843d8c86c..da0022f83d 100644 --- a/examples/category/YonedaScript.sml +++ b/examples/category/YonedaScript.sml @@ -53,7 +53,7 @@ srw_tac [][nat_trans_axioms_def] >- ( fsrw_tac [][hom_def] >> match_mp_tac maps_to_comp >> metis_tac [maps_to_in_def,maps_to_def] ) >> -qmatch_assum_rename_tac `g° :- y → x -:c` [] >> +qmatch_assum_rename_tac `g° :- y → x -:c` >> imp_res_tac maps_to_in_def >> fsrw_tac [][] >> srw_tac [][] >> imp_res_tac mor_obj >> srw_tac [][] >> @@ -272,7 +272,7 @@ srw_tac [][YMapInv_def] >> srw_tac [][nat_trans_axioms_def] >- metis_tac [objf_in_obj,op_cat_obj,ens_cat_obj] >- ( - qmatch_assum_rename_tac `g ∈ c|u→x|` [] >> + qmatch_assum_rename_tac `g ∈ c|u→x|` >> `g° :- x → u -:(c°)` by fsrw_tac [][hom_def] >> `f##g° :- (f@@x) → (f@@u) -:ens_cat (homs c)` by ( match_mp_tac morf_maps_to >> @@ -280,7 +280,7 @@ srw_tac [][nat_trans_axioms_def] srw_tac [][] ) >> fsrw_tac [][IsTypedFun_def,HasFunType_def] >> fsrw_tac [][]) >> -qmatch_assum_rename_tac `g° :- u → v -:c` [] >> +qmatch_assum_rename_tac `g° :- u → v -:c` >> imp_res_tac maps_to_in_def >> fsrw_tac [][] >> qmatch_abbrev_tac @@ -359,7 +359,7 @@ imp_res_tac is_nat_trans_YMapInv >> srw_tac [][] >- fsrw_tac [][YMapInv_def] >- fsrw_tac [][YMapInv_def] >> -qmatch_rename_tac `X = n @+ z` ["X"] >> +qmatch_rename_tac `_ = n @+ z` >> `z ∈ c.obj` by ( pop_assum mp_tac >> srw_tac [][YMapInv_def] ) >> srw_tac [][] >> @@ -376,7 +376,7 @@ srw_tac [][restrict_def] >> srw_tac [][FUN_EQ_THM] >> fsrw_tac [][IsTypedFun_def,HasFunType_def,extensional_def] >> srw_tac [][YMap_def] >> -qmatch_assum_rename_tac `f ∈ c|z→x|` [] >> +qmatch_assum_rename_tac `f ∈ c|z→x|` >> Q.ISPECL_THEN [`n`,`c|_→x|`,`n.cod` ,`n.cod.cod` ,`f°`,`x`,`z`] mp_tac naturality >> fsrw_tac [][hom_def] >> diff --git a/examples/category/categoryScript.sml b/examples/category/categoryScript.sml index e61c25b87f..5402db4b0d 100644 --- a/examples/category/categoryScript.sml +++ b/examples/category/categoryScript.sml @@ -1104,14 +1104,14 @@ val category_eq_thm = Q.store_thm( ⇒ (c1 = c2)`, srw_tac [][category_component_equality] >> srw_tac [][FUN_EQ_THM] >- ( - qmatch_rename_tac `c1.id_map x = c2.id_map x` [] >> + qmatch_rename_tac `c1.id_map x = c2.id_map x` >> Cases_on `x ∈ c1.obj` >- ( first_x_assum (qspec_then `x` mp_tac) >> srw_tac [][id_in_def,restrict_def] >> metis_tac [] ) >> fsrw_tac [][is_category_def,extensional_category_def,extensional_def] >> metis_tac [] ) >> -qmatch_rename_tac `c1.comp f g = c2.comp f g` [] >> +qmatch_rename_tac `c1.comp f g = c2.comp f g` >> Cases_on `f ≈> g-:c1` >- ( first_x_assum (qspecl_then [`f`,`g`] mp_tac) >> srw_tac [][compose_in_def,restrict_def,compose_def,composable_in_def] >> diff --git a/examples/category/ens_catScript.sml b/examples/category/ens_catScript.sml index 724cf38d09..60abfe5f95 100644 --- a/examples/category/ens_catScript.sml +++ b/examples/category/ens_catScript.sml @@ -208,7 +208,7 @@ srw_tac [][] >- ( srw_tac [][EQ_IMP_THM,CHOICE_DEF] >> first_x_assum (qspec_then `t` mp_tac) >> srw_tac [][] >> - qmatch_assum_rename_tac `x ∈ f.cod` [] >> + qmatch_assum_rename_tac `x ∈ f.cod` >> first_x_assum (qspecl_then [`TypedGraphFun (f.dom,f.cod) (K x)`,`TypedGraphFun (f.dom,f.cod) (K (CHOICE f.cod))`] mp_tac) >> srw_tac [][CHOICE_DEF] >> fsrw_tac [][morphism_component_equality,restrict_def] >> @@ -219,7 +219,7 @@ srw_tac [][] >- ( qpat_assum `x ∈ f.cod` mp_tac >> simp_tac std_ss [] ) >- ( - qmatch_assum_rename_tac `y ∈ U` [] >> + qmatch_assum_rename_tac `y ∈ U` >> qexists_tac `TypedGraphFun (y,{x}) (K x)` >> srw_tac [][] ) >> srw_tac [][TypedFun_ext] >> diff --git a/examples/category/functorScript.sml b/examples/category/functorScript.sml index d616bde8b3..3828589ae6 100644 --- a/examples/category/functorScript.sml +++ b/examples/category/functorScript.sml @@ -398,7 +398,7 @@ srw_tac [][] >- ( imp_res_tac id_mor >> srw_tac [][] >> metis_tac [morf_id,objf_in_obj,maps_to_def] ) >> -qmatch_assum_rename_tac `x ≈> y -:f.dom` [] >> +qmatch_assum_rename_tac `x ≈> y -:f.dom` >> Q.ISPECL_THEN [`f`,`f.dom`,`f.cod`,`x`,`y`] mp_tac morf_comp >> imp_res_tac comp_mor_dom_cod >> srw_tac [][] >> @@ -438,7 +438,7 @@ srw_tac [][] >> match_mp_tac functor_eq_thm >> srw_tac [][] >> match_mp_tac (GSYM functor_comp_morf) >> -qmatch_assum_rename_tac `x ∈ h.dom.mor` [] >> +qmatch_assum_rename_tac `x ∈ h.dom.mor` >> Q.ISPECL_THEN [`h`,`h.dom`,`h.cod`,`x`,`x.dom`,`x.cod`,`h@@x.dom`,`h@@x.cod`] mp_tac morf_maps_to >> srw_tac [][maps_to_in_def]); @@ -523,8 +523,8 @@ fsrw_tac [][full_def,faithful_def] >> first_assum (qspecl_then [`id (f@@a) -:f.cod`,`a`,`b`] mp_tac) >> first_x_assum (qspecl_then [`id (f@@b) -:f.cod`,`b`,`a`] mp_tac) >> srw_tac [][is_functor_is_category,id_maps_to,objf_in_obj] >> -qmatch_assum_rename_tac `ba :- b → a -:f.dom` [] >> -qmatch_assum_rename_tac `ab :- a → b -:f.dom` [] >> +qmatch_assum_rename_tac `ba :- b → a -:f.dom` >> +qmatch_assum_rename_tac `ab :- a → b -:f.dom` >> map_every qexists_tac [`ab`,`ba`] >> `ab ≈> ba -:f.dom` by metis_tac [maps_to_composable] >> `ba ≈> ab -:f.dom` by metis_tac [maps_to_composable] >> @@ -562,7 +562,7 @@ val faithful_functor_comp = Q.store_thm( "faithful_functor_comp", `∀f g. is_functor f ∧ is_functor g ∧ (f ≈> g) ∧ faithful f ∧ faithful g ⇒ faithful (g ◎ f)`, srw_tac [][faithful_def] >> -qmatch_rename_tac `h1 = h2` [] >> +qmatch_rename_tac `h1 = h2` >> pop_assum mp_tac >> fsrw_tac [][maps_to_in_def] >> strip_tac >> first_x_assum match_mp_tac >> fsrw_tac [][] >> first_x_assum match_mp_tac >> fsrw_tac [][] >> @@ -750,7 +750,7 @@ fsrw_tac [][cat_iso_def] >> fsrw_tac [][BIJ_IFF_INV] >> fsrw_tac [][GSYM RIGHT_EXISTS_IMP_THM, GSYM RIGHT_EXISTS_AND_THM] >> fsrw_tac [][SKOLEM_THM] >> -qmatch_assum_rename_tac `∀x. x ∈ f.cod.obj ⇒ gob x ∈ f.dom.obj` [] >> +qmatch_assum_rename_tac `∀x. x ∈ f.cod.obj ⇒ gob x ∈ f.dom.obj` >> pop_assum mp_tac >> qho_match_abbrev_tac `(∀a b. P1 a b ⇒ P2 a b ∧ P3 a b ∧ (∀x. x ∈ (f.dom|a→b|) ⇒ (gmo a b (f##x) = x)) ∧ P4 a b) ⇒ P5` >> qpat_assum `Abbrev (gmo = X)` (K ALL_TAC) >> @@ -812,7 +812,7 @@ imp_res_tac is_functor_is_category >> imp_res_tac maps_to_in_def >> fsrw_tac [][] ) >- ( qexists_tac `gob x` >> fsrw_tac [][] ) >> - qmatch_assum_rename_tac `k ≈> j -:f.cod` [] >> + qmatch_assum_rename_tac `k ≈> j -:f.cod` >> `(g##k) ≈> (g##j) -:f.dom` by ( match_mp_tac maps_to_composable >> metis_tac [composable_in_def,composable_def,maps_to_in_def,maps_to_def] ) >> diff --git a/examples/category/hom_functorScript.sml b/examples/category/hom_functorScript.sml index 7d1937514d..5cf8e5df27 100644 --- a/examples/category/hom_functorScript.sml +++ b/examples/category/hom_functorScript.sml @@ -112,7 +112,7 @@ srw_tac [][functor_axioms_def] imp_res_tac maps_to_obj >> fsrw_tac [][maps_to_in_def] ) >- ( - qmatch_assum_rename_tac `y ∈ c.obj` [] >> + qmatch_assum_rename_tac `y ∈ c.obj` >> qexists_tac `c|x→y|` >> srw_tac [][TypedGraphFun_def] >> srw_tac [][FUN_EQ_THM,restrict_def] >> @@ -382,7 +382,7 @@ fsrw_tac [][] >> srw_tac [][] >> qmatch_abbrev_tac `(op_mor_functor u1 u2)##f = g` >> `IsTypedFun f` by ( srw_tac [][Abbr`f`,Abbr`g`] >> - qmatch_assum_rename_tac `f ∈ (c|g.cod→x|)` [] >> + qmatch_assum_rename_tac `f ∈ (c|g.cod→x|)` >> qexists_tac `f° ° o g° ° -:c` >> `g° ° ≈> f° ° -:c` by ( match_mp_tac maps_to_composable >> @@ -401,7 +401,7 @@ srw_tac [][Abbr`g`,Abbr`f`,morphism_component_equality] >> TRY (srw_tac [DNF_ss][EXTENSION] >> NO_TAC) >> srw_tac [][restrict_def,FUN_EQ_THM] >> srw_tac [][] >> fsrw_tac [DNF_ss][] >- ( - qmatch_rename_tac `(g° o f° -:c°)° = f o g -:c` [] >> + qmatch_rename_tac `(g° o f° -:c°)° = f o g -:c` >> qspecl_then [`f`,`g`,`c°`] mp_tac op_cat_compose_in >> srw_tac [][] >> pop_assum (match_mp_tac o GSYM) >> match_mp_tac maps_to_composable >> diff --git a/examples/category/limitScript.sml b/examples/category/limitScript.sml index 4773dbff81..3fd050bf2f 100644 --- a/examples/category/limitScript.sml +++ b/examples/category/limitScript.sml @@ -46,7 +46,7 @@ first_x_assum (qspec_then `g@@y` mp_tac) >> srw_tac [][] >> imp_res_tac is_functor_is_category >> fsrw_tac [][EXISTS_UNIQUE_THM] >> -qmatch_assum_rename_tac `h :- g@@y → x -:f.dom` [] >> +qmatch_assum_rename_tac `h :- g@@y → x -:f.dom` >> `f##h :- f@@(g@@y) → f@@x -:f.cod` by metis_tac [morf_maps_to,maps_to_def] >> conj_tac >- metis_tac [functor_comp_objf,cat_iso_pair_def,id_functor_objf,composable_def] >> qx_gen_tac `h1` >> qx_gen_tac `h2` >> strip_tac >> @@ -419,7 +419,7 @@ EQ_TAC >- ( pop_assum (qspec_then `1` mp_tac), pop_assum (qspec_then `2` mp_tac)] >> srw_tac [][] ) >> - qmatch_rename_tac `ma = mb` [] >> + qmatch_rename_tac `ma = mb` >> qabbrev_tac `mma = mk_cone_mor co l ma` >> qabbrev_tac `mmb = mk_cone_mor co l mb` >> `mma :- co → l -:cone_cat d` by ( @@ -452,7 +452,7 @@ srw_tac [][EXISTS_UNIQUE_THM] >- ( qexists_tac `mk_cone_mor c2 co m` >> srw_tac [][cone_cat_maps_to,Abbr`co`,mk_cone_proj_ext,restrict_def] >> srw_tac [][] >> fsrw_tac [][maps_to_in_def] ) >> -qmatch_rename_tac `f1 = f2` [] >> +qmatch_rename_tac `f1 = f2` >> first_x_assum (qspecl_then [`FST f1.map`,`FST f2.map`] assume_tac) >> qsuff_tac `FST f1.map = FST f2.map` >- ( simp_tac std_ss [morphism_component_equality] >> @@ -706,7 +706,7 @@ srw_tac [][functor_axioms_def] >- ( qspecl_then [`c`,`f.dom`,`y`] mp_tac pi_maps_to >> fsrw_tac [][] >> strip_tac >> - qmatch_assum_rename_tac `f :- x → w -:c` [] >> + qmatch_assum_rename_tac `f :- x → w -:c` >> qspecl_then [`c`,`π1 x×y -:c`,`f`,`x × y-:c`,`x`,`w`] mp_tac maps_to_comp >> fsrw_tac [][] >> strip_tac >> imp_res_tac maps_to_in_def >> diff --git a/examples/category/nat_transScript.sml b/examples/category/nat_transScript.sml index c9c143942d..6cacdf83fa 100644 --- a/examples/category/nat_transScript.sml +++ b/examples/category/nat_transScript.sml @@ -112,7 +112,7 @@ srw_tac [][nat_trans_axioms_def] >- ( metis_tac [maps_to_morf,id_mor,morf_id,maps_to_def, is_functor_is_category,id_dom_cod] ) >> imp_res_tac is_functor_is_category >> -qmatch_assum_rename_tac `g :- x → y -:f.dom` [] >> +qmatch_assum_rename_tac `g :- x → y -:f.dom` >> `id (f@@y) -:f.cod = f##(id y -:f.dom)` by ( match_mp_tac (GSYM morf_id) >> srw_tac [][] >> imp_res_tac maps_to_obj ) >> @@ -703,7 +703,7 @@ imp_res_tac is_functor_is_category >> conj_tac >> match_mp_tac functor_eq_thm >> fsrw_tac [][] >> qx_gen_tac `n` >> strip_tac >> -qmatch_rename_tac `postcomp_functor b j##(functor_nt k n) = n` [] >> +qmatch_rename_tac `postcomp_functor b j##(functor_nt k n) = n` >> `n.dom ≈> k` by ( fsrw_tac [][is_nat_trans_def,nat_trans_axioms_def] ) >> srw_tac [][GSYM functor_nt_functor_comp]); @@ -1111,9 +1111,9 @@ val equivalence_full_faithful_ess_surj = Q.store_thm( gen_tac >> strip_tac >> EQ_TAC >> strip_tac >- ( fsrw_tac [][equivalence_def,equivalence_pair_def] >> fsrw_tac [][iso_objs_def,iso_pair_between_objs_def] >> - qmatch_assum_rename_tac `n1.dom = g ◎ f` [] >> + qmatch_assum_rename_tac `n1.dom = g ◎ f` >> qmatch_assum_abbrev_tac `X = g ◎ f` >> - qmatch_assum_rename_tac `n2.dom = f ◎ g` [] >> + qmatch_assum_rename_tac `n2.dom = f ◎ g` >> qunabbrev_tac `X` >> `∀h x y. h :- x → y -:f.dom ⇒ (n1 @+ y o (g ◎ f)##h -:f.dom = ((id_functor f.dom)##h) o n1 @+ x -:f.dom)` by ( rpt gen_tac >> strip_tac >> diff --git a/examples/category/zfset_catScript.sml b/examples/category/zfset_catScript.sml index 2773dbb0b6..92e739b60f 100644 --- a/examples/category/zfset_catScript.sml +++ b/examples/category/zfset_catScript.sml @@ -41,7 +41,7 @@ val IsSmall_IMAGE = Q.store_thm( "IsSmall_IMAGE", `∀s f. IsSmall s ⇒ IsSmall (IMAGE f s)`, srw_tac [][IsSmall_def] >> -qmatch_assum_rename_tac `INJ g s (explode z)` [] >> +qmatch_assum_rename_tac `INJ g s (explode z)` >> map_every qexists_tac [`λx. g (@y. y ∈ s ∧ (f y = x))`,`z`] >> fsrw_tac [DNF_ss][INJ_DEF] >> srw_tac [][] >- ( @@ -60,7 +60,7 @@ val IsSmall_IMAGE_iff = Q.store_thm( `∀s t f. INJ f s t ⇒ (IsSmall (IMAGE f s) ⇔ IsSmall s)`, srw_tac [][EQ_IMP_THM] >> fsrw_tac [][IsSmall_def] >> -qmatch_assum_rename_tac `INJ g (IMAGE f s) (explode z)` [] >> +qmatch_assum_rename_tac `INJ g (IMAGE f s) (explode z)` >> map_every qexists_tac [`g o f`,`z`] >> fsrw_tac [DNF_ss][INJ_DEF]); @@ -162,7 +162,7 @@ EQ_TAC >- ( strip_tac >> res_tac >> qexists_tac `y` >> srw_tac [][] ) >> srw_tac [][] >> -qmatch_rename_tac `THE (b x) In z` [] >> +qmatch_rename_tac `THE (b x) In z` >> Cases_on `b x` >> res_tac >> fsrw_tac [][] >> srw_tac [][]); @@ -372,7 +372,7 @@ conj_tac >- ( unabbrev_all_tac >> srw_tac [][morphism_component_equality] >> fsrw_tac [][ComposeGraphFns] >> - qmatch_rename_tac `X = p.map` ["X"] >> + qmatch_rename_tac `_ = p.map` >> match_mp_tac FnEqThm >> map_every qexists_tac [`p.dom`,`p.cod`] >> fsrw_tac [][GraphFnAp,HasFnType_def] >> @@ -382,7 +382,7 @@ conj_tac >- ( fsrw_tac [][IsTypedFn_def] >> fsrw_tac [][Fst,Snd] )) >> srw_tac [][] >> -qmatch_rename_tac `m1 = m2` [] >> +qmatch_rename_tac `m1 = m2` >> first_assum (qspec_then `m1` mp_tac) >> first_x_assum (qspec_then `m2` mp_tac) >> ntac 2 strip_tac >> @@ -397,7 +397,7 @@ srw_tac [][] >> `m1.map ' x In (p1.cod # p2.cod)` by metis_tac [InFn] >> `m2.map ' x In (p1.cod # p2.cod)` by metis_tac [InFn] >> fsrw_tac [][InProdEq] >> -qmatch_rename_tac `Pair x11 x21 = Pair x12 x22` [] >> +qmatch_rename_tac `Pair x11 x21 = Pair x12 x22` >> qmatch_assum_abbrev_tac `ComposeFn (X,Y,Z) (GraphFn (a#b) P) Q = R` >> map_every qunabbrev_tac [`P`,`Q`,`R`,`Z`] >> `(ComposeFn (X,Y,a) (GraphFn Y Fst) m1.map) ' x = p1.map ' x` by srw_tac [][] >> @@ -1154,7 +1154,7 @@ srw_tac [][restrict_def] >> `g ∈ (ens_cat (homs c)).mor` by srw_tac [][] >> `h ∈ (ens_cat (homs c)).mor` by srw_tac [][] >> fsrw_tac [][morphism_component_equality] >> -qmatch_rename_tac `zfel g.cod (g.map z) = zfel g.cod (h.map z)` [] >> +qmatch_rename_tac `zfel g.cod (g.map z) = zfel g.cod (h.map z)` >> `GraphFn (tagged_homset c g.dom) (tag_fun c g) ' (Pair (the_hom_tag c g.dom) (zfel g.dom z)) = GraphFn (tagged_homset c h.dom) (tag_fun c h) ' (Pair (the_hom_tag c h.dom) (zfel h.dom z))` by metis_tac [] >> @@ -1247,7 +1247,7 @@ fsrw_tac [][hom_tag_def] >> srw_tac [][] >> fsrw_tac [][is_self_hom_def] >> fsrw_tac [][hom_def,EXTENSION] >> -qmatch_assum_rename_tac `!x. x :- a → b -:c = x :- z → z -:c` [] >> +qmatch_assum_rename_tac `!x. x :- a → b -:c = x :- z → z -:c` >> `id z -: c :- z → z -:c` by metis_tac [id_maps_to] >> `id z -: c :- a → b -:c` by metis_tac [] >> fsrw_tac [][maps_to_in_def]); From 5a001e81cb2860c478f4b93b0ccd46e74286eeb8 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Sun, 11 Jan 2015 14:28:16 +1100 Subject: [PATCH 105/718] Fix to miller example in light of 92317114 --- examples/miller/formalize/measureScript.sml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/miller/formalize/measureScript.sml b/examples/miller/formalize/measureScript.sml index 2c8df09b12..ff42faf237 100644 --- a/examples/miller/formalize/measureScript.sml +++ b/examples/miller/formalize/measureScript.sml @@ -1663,7 +1663,7 @@ val SIGMA_PROPERTY_DISJOINT_LEMMA1 = store_thm ++ PROVE_TAC [ALGEBRA_INTER]) ++ RW_TAC std_ss [GSPECIFICATION, SUBSET_DEF, closed_cdi_def] << [PROVE_TAC [closed_cdi_def, SMALLEST_CLOSED_CDI], - Q.MATCH_ASSUM_RENAME_TAC `s1 ∩ s2 ∈ smallest_closed_cdi a` [] ++ + Q.MATCH_ASSUM_RENAME_TAC `s1 ∩ s2 ∈ smallest_closed_cdi a` ++ Know `s1 INTER COMPL s2 = COMPL (COMPL s1 UNION (s1 INTER s2))` >> (PSET_TAC [EXTENSION] ++ PROVE_TAC []) From 35a31865cb399099776d6c700124daf55fffdccc Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Sun, 11 Jan 2015 14:32:51 +1100 Subject: [PATCH 106/718] Update build instructions for miller example. --- examples/miller/README | 22 ++-------------------- 1 file changed, 2 insertions(+), 20 deletions(-) diff --git a/examples/miller/README b/examples/miller/README index 2a51bb8694..8fb4ec0410 100644 --- a/examples/miller/README +++ b/examples/miller/README @@ -6,26 +6,8 @@ The reason I haven't incorporated it into src/ is that it takes about 2 hours to build, and carries a lot of `baggage' from my experiments with proof tools. -The most convenient way to build it is change to the examples/miller/ -directory, and use the `m' bash script (it also understands `m clean' -to clean the directories). If this doesn't work, or you can't do this, -then there's a longer version: - -cd ho_prover -Holmake --qof -cd ../subtypes -Holmake -I ../ho_prover --qof -cd ../RSA -Holmake --qof -cd ../formalize -Holmake -I ../ho_prover -I ../subtypes -I ../RSA --qof -cd ../prob -Holmake -I ../ho_prover -I ../subtypes -I ../RSA -I ../formalize --qof -cd ../groups -Holmake -I ../ho_prover -I ../subtypes -I ../RSA -I ../formalize --qof -cd ../miller -Holmake -I ../ho_prover -I ../subtypes -I ../RSA -I ../formalize -I ../prob -I ../groups --qof -cd .. +The most convenient way to build it is change to the examples/miller/miller +directory, and use Holmake. This will build the dependent directories in the example as necessary. It does build RIGHT NOW, but is quite sensitive to changes in the HOL proof tools. I'll try and support it (especially if anyone uses it), From eccd9ac2092ac3df3f9427a987f016443bd56cf0 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Sun, 11 Jan 2015 22:58:17 +1100 Subject: [PATCH 107/718] infix THEN_LT - hopefully in the right place now see comments on https://github.com/HOL-Theorem-Prover/HOL/pull/221 --- src/1/Tactic.sml | 1 - src/experimental-kernel/Overlay.sml | 3 ++- src/logging-kernel/Overlay.sml | 3 ++- 3 files changed, 4 insertions(+), 3 deletions(-) diff --git a/src/1/Tactic.sml b/src/1/Tactic.sml index 128960eeac..e199a25272 100644 --- a/src/1/Tactic.sml +++ b/src/1/Tactic.sml @@ -142,7 +142,6 @@ val CONJ_TAC: tactic = (* ASM1 & ASM2 variants assume the given conjunct when proving the other one *) -infix THEN_LT ; (* why do we need this? Not needed for THEN, below! *) val CONJ_ASM1_TAC = CONJ_TAC THEN_LT USE_SG_THEN ASSUME_TAC 1 2 ; val CONJ_ASM2_TAC = CONJ_TAC THEN_LT USE_SG_THEN ASSUME_TAC 2 1 ; diff --git a/src/experimental-kernel/Overlay.sml b/src/experimental-kernel/Overlay.sml index 906f26c2ea..2cbf410bf3 100644 --- a/src/experimental-kernel/Overlay.sml +++ b/src/experimental-kernel/Overlay.sml @@ -6,7 +6,8 @@ between the two. ---------------------------------------------------------------------- *) -infix ++ && |-> THEN THEN1 THENL THENC ORELSE ORELSEC THEN_TCL ORELSE_TCL ?> |> +infix ++ && |-> THEN THEN1 THENL THEN_LT THENC ORELSE ORELSEC + THEN_TCL ORELSE_TCL ?> |> infixr ## infixr 3 -->; infix 8 via by suffices_by diff --git a/src/logging-kernel/Overlay.sml b/src/logging-kernel/Overlay.sml index 906f26c2ea..2cbf410bf3 100644 --- a/src/logging-kernel/Overlay.sml +++ b/src/logging-kernel/Overlay.sml @@ -6,7 +6,8 @@ between the two. ---------------------------------------------------------------------- *) -infix ++ && |-> THEN THEN1 THENL THENC ORELSE ORELSEC THEN_TCL ORELSE_TCL ?> |> +infix ++ && |-> THEN THEN1 THENL THEN_LT THENC ORELSE ORELSEC + THEN_TCL ORELSE_TCL ?> |> infixr ## infixr 3 -->; infix 8 via by suffices_by From f9093ec3bb76496f9e68b52840bdf062f019eb4d Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Mon, 12 Jan 2015 14:43:33 +1100 Subject: [PATCH 108/718] abbreviation lcsymtacs.>>> for THEN_LT see comment in https://github.com/HOL-Theorem-Prover/HOL/pull/222 also relaxed typing for lcsymtacs synonyms for THEN, THENL --- src/0/Overlay.sml | 2 +- src/boss/lcsymtacs.sig | 19 ++++++++++++++++--- src/boss/lcsymtacs.sml | 1 + src/experimental-kernel/Overlay.sml | 2 +- src/logging-kernel/Overlay.sml | 2 +- 5 files changed, 20 insertions(+), 6 deletions(-) diff --git a/src/0/Overlay.sml b/src/0/Overlay.sml index b53ff4954a..2c0c31fd5e 100644 --- a/src/0/Overlay.sml +++ b/src/0/Overlay.sml @@ -26,7 +26,7 @@ infix ++ && |-> THEN THEN1 THENL THEN_LT THENC ORELSE ORELSE_LT ORELSEC THEN_TCL ORELSE_TCL ?> |> (* infixes for THEN shorthands *) -infix >> >- >| \\ +infix >> >- >| \\ >>> infixr ##; infixr 3 -->; diff --git a/src/boss/lcsymtacs.sig b/src/boss/lcsymtacs.sig index 8d70802811..0b51ff3be1 100644 --- a/src/boss/lcsymtacs.sig +++ b/src/boss/lcsymtacs.sig @@ -90,9 +90,22 @@ sig val fs : thm list -> tactic val rfs : thm list -> tactic - val >> : tactic * tactic -> tactic - val \\ : tactic * tactic -> tactic - val >| : tactic * tactic list -> tactic + val >> : ('a -> goal list * (thm list -> 'b)) * tactic -> + 'a -> goal list * (thm list -> 'b) + val \\ : ('a -> goal list * (thm list -> 'b)) * tactic -> + 'a -> goal list * (thm list -> 'b) + (* ie, tactic * tactic -> tactic OR list_tactic * tactic -> list_tactic *) + + val >| : ('a -> goal list * (thm list -> 'b)) * tactic list -> + 'a -> goal list * (thm list -> 'b) + (* ie, tactic * tactic list -> tactic OR + list_tactic * tactic list -> list_tactic *) + val >- : tactic * tactic -> tactic + val >>> : ('a -> goal list * (thm list -> 'b)) * list_tactic -> + 'a -> goal list * (thm list -> 'b) + (* ie, tactic * list_tactic -> tactic OR + list_tactic * list_tactic -> list_tactic *) + end diff --git a/src/boss/lcsymtacs.sml b/src/boss/lcsymtacs.sml index 19343e256b..13ea1c7599 100644 --- a/src/boss/lcsymtacs.sml +++ b/src/boss/lcsymtacs.sml @@ -111,5 +111,6 @@ struct val op\\ = op Tactical.THEN val op>- = op Tactical.THEN1 val op>| = op Tactical.THENL + val op>>> = op Tactical.THEN_LT end diff --git a/src/experimental-kernel/Overlay.sml b/src/experimental-kernel/Overlay.sml index 2cbf410bf3..bc1938bf15 100644 --- a/src/experimental-kernel/Overlay.sml +++ b/src/experimental-kernel/Overlay.sml @@ -13,7 +13,7 @@ infixr 3 -->; infix 8 via by suffices_by (* infixes for THEN shorthands *) -infix >> >- >| \\ +infix >> >- >| \\ >>> structure Tag = Tag :> FinalTag where type tag = Tag.tag structure Type = Type :> FinalType where type hol_type = Type.hol_type diff --git a/src/logging-kernel/Overlay.sml b/src/logging-kernel/Overlay.sml index 2cbf410bf3..bc1938bf15 100644 --- a/src/logging-kernel/Overlay.sml +++ b/src/logging-kernel/Overlay.sml @@ -13,7 +13,7 @@ infixr 3 -->; infix 8 via by suffices_by (* infixes for THEN shorthands *) -infix >> >- >| \\ +infix >> >- >| \\ >>> structure Tag = Tag :> FinalTag where type tag = Tag.tag structure Type = Type :> FinalType where type hol_type = Type.hol_type From 1347b6ae1978ebaa2c0514e56ea5f8c1b56680b5 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Tue, 13 Jan 2015 08:37:21 +1100 Subject: [PATCH 109/718] Fix to examples/countable in light of 92317114 --- examples/countable/countableLib.sml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/countable/countableLib.sml b/examples/countable/countableLib.sml index 1904f42f3e..531ba8fe44 100644 --- a/examples/countable/countableLib.sml +++ b/examples/countable/countableLib.sml @@ -82,7 +82,7 @@ in fn tys => fn ttac => let val th = prove(list_mk_conj concls, ho_match_mp_tac induction >> srw_tac[boolSimps.ETA_ss][] >> - qmatch_rename_tac `(X = Y z) ⇔ Z` ["X","Y","Z"] >> + qmatch_rename_tac `(_ = _ z) ⇔ _` >> Cases_on `z` >> rw[]) val (_,ths) = foldr (fn (ty,(all,ths)) => let From 3dcefcac29baf3c4d3bc11e4444330e22728c967 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 13 Jan 2015 14:30:24 +1100 Subject: [PATCH 110/718] Make the integer decision procedures handle maximum and minimum. This works for :num and :int. In both cases, the treatment is to expand with the definition of the relevant constant. --- src/integer/IntDP_Munge.sml | 12 +++++++++--- src/integer/testing/test_cases.sml | 4 ++++ 2 files changed, 13 insertions(+), 3 deletions(-) diff --git a/src/integer/IntDP_Munge.sml b/src/integer/IntDP_Munge.sml index 79c1f09765..ef342b0dd5 100644 --- a/src/integer/IntDP_Munge.sml +++ b/src/integer/IntDP_Munge.sml @@ -363,10 +363,13 @@ in NO_CONV tm end +val nat_rewrites = + [arithmeticTheory.LEFT_ADD_DISTRIB, arithmeticTheory.RIGHT_ADD_DISTRIB, + arithmeticTheory.MAX_DEF, arithmeticTheory.MIN_DEF] + val dealwith_nats = let val phase1 = - tacCONV (PURE_REWRITE_CONV [arithmeticTheory.LEFT_ADD_DISTRIB, - arithmeticTheory.RIGHT_ADD_DISTRIB] THENC + tacCONV (PURE_REWRITE_CONV nat_rewrites THENC ONCE_DEPTH_CONV normalise_mult THENC elim_div_mod THENC (* eliminate nasty subtractions *) @@ -445,9 +448,12 @@ in Parse.term_to_string (hd subterms)^"...) but it was false") end +val int_rewrites = + [INT_LDISTRIB, INT_RDISTRIB, INT_MAX, INT_MIN] + fun BASIC_CONV DPname DP tm = let val (natgoal, natvalidation) = dealwith_nats tm - val stage1 = PURE_REWRITE_CONV [INT_LDISTRIB, INT_RDISTRIB] THENC + val stage1 = PURE_REWRITE_CONV int_rewrites THENC ONCE_DEPTH_CONV normalise_mult fun stage2 tm = case non_presburger_subterms0 [] tm of diff --git a/src/integer/testing/test_cases.sml b/src/integer/testing/test_cases.sml index fda8ce9af0..068acbc425 100644 --- a/src/integer/testing/test_cases.sml +++ b/src/integer/testing/test_cases.sml @@ -53,6 +53,10 @@ val terms_to_test = (((((i >= 0 /\ j >= 0 /\ k >= 0) /\ ~(((i = 0) \/ (j = 0)) \/ (k = 0))) /\ ~(i = j)) /\ ~(i = k)) /\ (j = k)) /\ i < j + k``), + T ("NAT MAX 1", ``x:num <= MAX x y``), + T ("NAT MAX 2", ``!y:num. 0 < y ==> ?x:num. x < MAX x y``), + T ("INT MAX 1", ``x <= int_max x y``), + T ("INT MAX 2", ``!y. ?x:int. x < int_max x y``), T ("BUG1", ``(?x. y <= x /\ x <= z /\ 2i * z + 1 <= x /\ x <= 2 * y) = y <= z /\ 2 * z + 1 <= 2 * y /\ y <= 2 * y /\ 2 * z + 1 <= z``), From 86b39f929d7cd24d95d7d9c57f45398cb9ee541a Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Tue, 13 Jan 2015 14:42:29 +0000 Subject: [PATCH 111/718] Update ARMv8 model. The encoder now explicitly defines an encoding function for bit-mask values. This avoids the use of a reverse look up function (implemented with sptress). Thanks to Shaked Flur for implementing the encoding algorithm. --- examples/l3-machine-code/arm8/model/arm8.sig | 22 ++-- examples/l3-machine-code/arm8/model/arm8.sml | 70 +++++++++--- .../arm8/model/arm8AssemblerLib.sig | 3 - .../arm8/model/arm8AssemblerLib.sml | 77 +++++-------- .../l3-machine-code/arm8/model/arm8Script.sml | 104 ++++++++++++++---- .../arm8/model/arm8_encodeScript.sml | 48 -------- .../arm8/step/arm8_stepLib.sml | 2 +- 7 files changed, 176 insertions(+), 150 deletions(-) delete mode 100644 examples/l3-machine-code/arm8/model/arm8_encodeScript.sml diff --git a/examples/l3-machine-code/arm8/model/arm8.sig b/examples/l3-machine-code/arm8/model/arm8.sig index 83f33a9593..77926d606e 100644 --- a/examples/l3-machine-code/arm8/model/arm8.sig +++ b/examples/l3-machine-code/arm8/model/arm8.sig @@ -1,4 +1,4 @@ -(* arm8 - generated by L<3> - Tue Nov 18 15:32:41 2014 *) +(* arm8 - generated by L<3> - Mon Jan 12 16:38:36 2015 *) signature arm8 = sig @@ -367,8 +367,6 @@ datatype instruction = datatype MachineCode = ARM8 of BitsN.nbit | BadCode of string -datatype imm32_64 = Imm32 of BitsN.nbit | Imm64 of BitsN.nbit - datatype maybe_instruction = FAIL of string | OK of instruction @@ -794,11 +792,14 @@ val LoadStoreAcquire: val Decode: BitsN.nbit -> instruction val Fetch: unit -> BitsN.nbit val Next: unit -> unit +val CountTrailing:Nat.nat-> (bool * BitsN.nbit) -> Nat.nat +val EncodeBitMaskAux:Nat.nat-> + BitsN.nbit -> (Nat.nat * (Nat.nat * Nat.nat)) +val EncodeBitMask:Nat.nat-> + BitsN.nbit -> ((BitsN.nbit * (BitsN.nbit * BitsN.nbit)) option) val e_sf:Nat.nat-> BitsN.nbit -> BitsN.nbit val EncodeLogicalOp: (LogicalOp * bool) -> (BitsN.nbit option) -val e_data: - ((imm32_64 -> ((BitsN.nbit * (BitsN.nbit * BitsN.nbit)) option)) * Data) -> - MachineCode +val e_data: Data -> MachineCode val e_debug: Debug -> BitsN.nbit val e_crc: CRCExt -> BitsN.nbit val e_branch: Branch -> MachineCode @@ -819,9 +820,7 @@ val e_LoadStoreRegister: (BitsN.nbit * (ExtendType * (Nat.nat * (BitsN.nbit * BitsN.nbit)))))))) -> MachineCode val e_load_store: LoadStore -> MachineCode -val Encode: - ((imm32_64 -> ((BitsN.nbit * (BitsN.nbit * BitsN.nbit)) option)) * - instruction) -> MachineCode +val Encode: instruction -> MachineCode val skipSpaces: string -> string val stripSpaces: string -> string val p_number: string -> (Nat.nat option) @@ -932,10 +931,7 @@ val convert_zr2: (string list) -> (string list) val convert_zr_end: (string list) -> (string list) val p_tokens: string -> (string list) val instructionFromString: string -> maybe_instruction -val EncodeARM: - ((imm32_64 -> ((BitsN.nbit * (BitsN.nbit * BitsN.nbit)) option)) * - string) -> (string * (string option)) -val CheckDecode: string -> (string option) +val EncodeARM: string -> (string * (string option)) val s_cond: BitsN.nbit -> string val s_regz: (bool * BitsN.nbit) -> string val s_regp: (bool * BitsN.nbit) -> string diff --git a/examples/l3-machine-code/arm8/model/arm8.sml b/examples/l3-machine-code/arm8/model/arm8.sml index e00993e3b8..0dd964a212 100644 --- a/examples/l3-machine-code/arm8/model/arm8.sml +++ b/examples/l3-machine-code/arm8/model/arm8.sml @@ -1,4 +1,4 @@ -(* arm8 - generated by L<3> - Tue Nov 18 15:32:41 2014 *) +(* arm8 - generated by L<3> - Mon Jan 12 16:38:36 2015 *) structure arm8 :> arm8 = struct @@ -367,8 +367,6 @@ datatype instruction = datatype MachineCode = ARM8 of BitsN.nbit | BadCode of string -datatype imm32_64 = Imm32 of BitsN.nbit | Imm64 of BitsN.nbit - datatype maybe_instruction = FAIL of string | OK of instruction @@ -6287,6 +6285,52 @@ fun Next () = else () ); +fun CountTrailing N (b,w) = + if ((BitsN.bit(w,0)) = b) orelse + (if b then w = (BitsN.B(0x0,N)) else w = (BitsN.neg(BitsN.B(0x1,N)))) + then 0 + else Nat.+(1,CountTrailing N (b,BitsN.>>+(w,1))); + +fun EncodeBitMaskAux N imm = + let + val pref0 = CountTrailing N (true,imm) + in + if pref0 = 0 + then let + val pref1 = CountTrailing N (false,imm) + val run0 = CountTrailing N (true,BitsN.#>>(imm,pref1)) + val run1 = + CountTrailing N (false,BitsN.#>>(imm,Nat.+(pref1,run0))) + in + (Nat.+(run0,run1),(run1,Nat.-(run1,pref1))) + end + else let + val run1 = CountTrailing N (false,BitsN.#>>(imm,pref0)) + val run0 = + CountTrailing N (true,BitsN.#>>(imm,Nat.+(pref0,run1))) + in + (Nat.+(run0,run1),(run1,Nat.-(Nat.+(run0,run1),pref0))) + end + end; + +fun EncodeBitMask N imm = + let + val (e,(S,R)) = EncodeBitMaskAux N imm + val (immN,(imms,immr)) = + if e = 64 + then (BitsN.B(0x1,1), + (BitsN.fromNat(Nat.-(S,1),6),BitsN.fromNat(R,6))) + else (BitsN.B(0x0,1), + (BitsN.|| + (BitsN.~(BitsN.fromNat(Nat.-(Nat.*(e,2),1),6)), + BitsN.fromNat(Nat.-(S,1),6)),BitsN.fromNat(R,6))) + in + case DecodeBitMasks N (immN,(imms,(immr,true))) of + Option.SOME(imm2,_) => + (if imm = imm2 then Option.SOME(immN,(imms,immr)) else NONE) + | NONE => NONE + end; + fun e_sf N sf = BitsN.fromBit((BitsN.size(BitsN.B(0x0,N))) = 64); fun EncodeLogicalOp (opc,setflags) = @@ -6297,7 +6341,7 @@ fun EncodeLogicalOp (opc,setflags) = | (LogicalOp_AND,true) => Option.SOME(BitsN.B(0x3,2)) | _ => NONE; -fun e_data (imm_enc,i) = +fun e_data i = case i of AddSubShiftedRegister''32(_,(opc,(s,(sh,(rm,(imm6,(rn,rd))))))) => (if BitsN.bit(imm6,5) @@ -6398,14 +6442,14 @@ fun e_data (imm_enc,i) = end | NONE => BadCode("LogicalShiftedRegister")) | LogicalImmediate''32(_,(opc,(s,(imm,(rn,rd))))) => - (case (imm_enc (Imm32 imm),EncodeLogicalOp(opc,s)) of + (case (EncodeBitMask 32 imm,EncodeLogicalOp(opc,s)) of (Option.SOME(_,(imms,immr)),Option.SOME opc) => ARM8 (BitsN.concat [BitsN.B(0x0,1),opc,BitsN.B(0x48,7),immr,imms,rn,rd]) | _ => BadCode("LogicalImmediate32")) | LogicalImmediate''64(_,(opc,(s,(imm,(rn,rd))))) => - (case (imm_enc (Imm64 imm),EncodeLogicalOp(opc,s)) of + (case (EncodeBitMask 64 imm,EncodeLogicalOp(opc,s)) of (Option.SOME(N,(imms,immr)),Option.SOME opc) => ARM8 (BitsN.concat @@ -7071,7 +7115,7 @@ fun e_load_store i = else BadCode("LoadStoreAcquirePair") end; -fun Encode (imm_enc,i) = +fun Encode i = case i of Address(page,(imm,rd)) => (if page @@ -7096,7 +7140,7 @@ fun Encode (imm_enc,i) = [BitsN.B(0x0,1),immlo,BitsN.B(0x10,5),immhi,rd]) else BadCode("Address") end) - | Data x => e_data(imm_enc,x) + | Data x => e_data x | Branch x => e_branch x | LoadStore x => e_load_store x | CRCExt x => ARM8(e_crc x) @@ -8845,10 +8889,10 @@ fun instructionFromString s = | _ => FAIL("Unrecognised mnemonic")) | _ => FAIL("Unrecognised mnemonic"); -fun EncodeARM (imm_enc,s) = +fun EncodeARM s = case instructionFromString s of OK ast => - (case Encode(imm_enc,ast) of + (case Encode ast of ARM8 w => ("",Option.SOME(L3.padLeftString(#"0",(8,BitsN.toHexString w)))) | BadCode err => (("Encode error: ") ^ err,NONE)) @@ -8857,12 +8901,6 @@ fun EncodeARM (imm_enc,s) = ("",Option.SOME(L3.padLeftString(#"0",(8,BitsN.toHexString w)))) | FAIL err => (("Parse error: ") ^ err,NONE); -fun CheckDecode s = - L3.snd - (EncodeARM - (L3.K(Option.SOME(BitsN.B(0x0,1),(BitsN.B(0x0,6),BitsN.B(0x0,6)))), - s)); - fun s_cond c = case c of BitsN.B(0x0,4) => "eq" diff --git a/examples/l3-machine-code/arm8/model/arm8AssemblerLib.sig b/examples/l3-machine-code/arm8/model/arm8AssemblerLib.sig index e4c373bcf4..e0fa931cc8 100644 --- a/examples/l3-machine-code/arm8/model/arm8AssemblerLib.sig +++ b/examples/l3-machine-code/arm8/model/arm8AssemblerLib.sig @@ -2,9 +2,6 @@ signature arm8AssemblerLib = sig val arm8_code: string quotation -> string list val arm8_disassemble: string quotation -> string list - val instructionEncode: arm8.instruction -> arm8.MachineCode - val m32 : Term.term - val m64 : Term.term val print_arm8_code: string quotation -> unit val print_arm8_disassemble: string quotation -> unit end diff --git a/examples/l3-machine-code/arm8/model/arm8AssemblerLib.sml b/examples/l3-machine-code/arm8/model/arm8AssemblerLib.sml index b08bcf961a..b54fdc2cf0 100644 --- a/examples/l3-machine-code/arm8/model/arm8AssemblerLib.sml +++ b/examples/l3-machine-code/arm8/model/arm8AssemblerLib.sml @@ -2,7 +2,6 @@ structure arm8AssemblerLib :> arm8AssemblerLib = struct open HolKernel boolLib bossLib -open sptreeSyntax wordsSyntax local open MutableMap arm8 assemblerLib @@ -11,65 +10,49 @@ end val ERR = Feedback.mk_HOL_ERR "arm8AssemblerLib" -(* - -val () = sptreeSyntax.temp_add_sptree_printer() -val () = Globals.max_print_depth := 10 - -*) - -(* - Compute inverse for the function arm8.DecodeBitMasks. -*) +(* Validity check for EncodeBitMask local val b0 = BitsN.B (0, 1) val b1 = BitsN.B (1, 1) - type dtype = BitsN.nbit * int * int - val mkDict = - List.foldl (fn ((SOME k, d: dtype), m) => Redblackmap.insert (m, k, d) - | ((NONE, _), m) => m) - (Redblackmap.mkDict BitsN.compare) o Lib.mk_set o List.concat fun mask (m, n) (s, r) = Option.map fst (arm8.DecodeBitMasks m (BitsN.fromNat (n, 1), (BitsN.fromNat (s, 6), (BitsN.fromNat (r, 6), true)))) - val mask32 = mask (32, 0) - val mask64_0 = mask (64, 0) - val mask64_1 = mask (64, 1) + fun checkMask (m, n) (s, r) = + case mask (m, n) (s, r) of + SOME imm => Option.isSome (arm8.EncodeBitMask m imm) + | NONE => false + val mask32 = checkMask (32, 0) + val mask64_0 = checkMask (64, 0) + val mask64_1 = checkMask (64, 1) val d64 = (List.tabulate - (64, fn i => List.tabulate (64, fn j => (mask64_1 (i, j), (b1, i, j)))) + (64, + fn i => List.tabulate (64, fn j => (mask64_1 (i, j), (b1, i, j)))) @ List.tabulate - (62, fn i => List.tabulate (64, fn j => (mask64_0 (i, j), (b0, i, j))))) - |> mkDict + (62, + fn i => List.tabulate (64, fn j => (mask64_0 (i, j), (b0, i, j))))) + |> List.concat val d32 = - List.tabulate - (62, fn i => List.tabulate (64, fn j => (mask32 (i, j), (b0, i, j)))) - |> mkDict - val imm6 = - Option.map (fn (a, b, c): dtype => (a, (BitsN.B (b, 6), BitsN.B (c, 6)))) - val bits2num = Arbnum.fromHexString o BitsN.toHexString - val sptree = - sptreeSyntax.fromAList o - List.map - (fn (k, (a, b, c): dtype) => - (bits2num k, - pairSyntax.list_mk_pair - [wordsSyntax.mk_wordi (bits2num a, 1), - wordsSyntax.mk_wordii (b, 6), - wordsSyntax.mk_wordii (c, 6)])) o Redblackmap.listItems - val EncodeBitMask = - fn arm8.Imm32 i => imm6 (Redblackmap.peek (d32, i)) - | arm8.Imm64 i => imm6 (Redblackmap.peek (d64, i)) + (List.tabulate + (62, fn i => List.tabulate (64, fn j => (mask32 (i, j), (b0, i, j))))) + |> List.concat in - fun instructionEncode ast = arm8.Encode (EncodeBitMask, ast) - val m32 = sptree d32 - val m64 = sptree d64 + val fail64 = + List.filter (not o fst) d64 + |> List.map (fn (_, (n, s, r)) => mask (64, BitsN.toNat n) (s, r)) + |> List.filter Option.isSome + val fail32 = + List.filter (not o fst) d32 + |> List.map (fn (_, (n, s, r)) => mask (32, BitsN.toNat n) (s, r)) + |> List.filter Option.isSome end +*) + fun arm_syntax_pass1 q = let open arm8 @@ -106,7 +89,7 @@ fun arm_syntax_pass1 q = then p1 else case instructionFromString s1 of OK ast => - (case instructionEncode ast of + (case arm8.Encode ast of ARM8 w => let val ast' = Decode w @@ -131,7 +114,7 @@ fun encode (line, ast) = fun err s = raise assemblerLib.Assembler [{string = "Encode failed" ^ s, line = line}] in - case instructionEncode ast of + case arm8.Encode ast of arm8.ARM8 w => let val ast' = arm8.Decode w @@ -254,7 +237,7 @@ in val print_arm8_disassemble = List.app printn o arm8_disassemble end -(* Testing +(* Testing - round-trip open MutableMap arm8AssemblerLib @@ -319,7 +302,7 @@ local in case arm8.instructionFromString s of arm8.OK i' => - (case arm8AssemblerLib.instructionEncode i' of + (case arm8.Encode i' of arm8.ARM8 w' => if w = w' orelse astEquiv i i' then (* (print (s ^ "\n"); NONE) *) NONE diff --git a/examples/l3-machine-code/arm8/model/arm8Script.sml b/examples/l3-machine-code/arm8/model/arm8Script.sml index 6b1d8027f8..807a7adc18 100644 --- a/examples/l3-machine-code/arm8/model/arm8Script.sml +++ b/examples/l3-machine-code/arm8/model/arm8Script.sml @@ -1,4 +1,4 @@ -(* arm8Script.sml - generated by L<3> - Thu Nov 06 16:00:59 2014 *) +(* arm8Script.sml - generated by L<3> - Mon Jan 12 16:28:29 2015 *) open HolKernel boolLib bossLib Import val () = Import.start "arm8" @@ -357,8 +357,6 @@ val _ = Construct ; val _ = Construct [("MachineCode",[("ARM8",[F32]),("BadCode",[sTy])])] ; -val _ = Construct [("imm32_64",[("Imm32",[F32]),("Imm64",[F64])])] -; val _ = Construct [("exception", [("ALIGNMENT_FAULT",[]),("ASSERT",[sTy]),("NoException",[]), @@ -8045,6 +8043,78 @@ val Next_def = Def TP[qVar"s",Bop(Add,Dest("PC",F64,qVar"s"),LW(4,64))]), qVar"s")]))) ; +val CountTrailing_def = tDef + ("CountTrailing",TP[bVar"b",Var("w",BTy"N")], + ITE(Bop(Or,EQ(Bop(Bit,Var("w",BTy"N"),LN 0),bVar"b"), + ITE(bVar"b",EQ(Var("w",BTy"N"),LY(0,"N")), + EQ(Var("w",BTy"N"),Mop(Neg,LY(1,"N"))))),LN 0, + Bop(Add,LN 1, + Call + ("CountTrailing",nTy, + TP[bVar"b",Bop(Lsr,Var("w",BTy"N"),LN 1)]))), + Close(TP[bVar"b",Var("w",BTy"N")],Mop(Cast nTy,Var("w",BTy"N"))), + SRW_TAC [] [wordsTheory.LSR_LESS] +THEN Cases_on `w = 0w` +THEN FULL_SIMP_TAC (srw_ss()) [wordsTheory.word_0, wordsTheory.LSR_LESS] +) +; +val EncodeBitMaskAux_def = Def + ("EncodeBitMaskAux",Var("imm",BTy"N"), + Let(nVar"pref0",Call("CountTrailing",nTy,TP[LT,Var("imm",BTy"N")]), + ITE(EQ(nVar"pref0",LN 0), + Let(nVar"pref1", + Call("CountTrailing",nTy,TP[LF,Var("imm",BTy"N")]), + Let(nVar"run0", + Call + ("CountTrailing",nTy, + TP[LT,Bop(Ror,Var("imm",BTy"N"),nVar"pref1")]), + Let(nVar"run1", + Call + ("CountTrailing",nTy, + TP[LF, + Bop(Ror,Var("imm",BTy"N"), + Bop(Add,nVar"pref1",nVar"run0"))]), + TP[Bop(Add,nVar"run0",nVar"run1"),nVar"run1", + Bop(Sub,nVar"run1",nVar"pref1")]))), + Let(nVar"run1", + Call + ("CountTrailing",nTy, + TP[LF,Bop(Ror,Var("imm",BTy"N"),nVar"pref0")]), + Let(nVar"run0", + Call + ("CountTrailing",nTy, + TP[LT, + Bop(Ror,Var("imm",BTy"N"), + Bop(Add,nVar"pref0",nVar"run1"))]), + TP[Bop(Add,nVar"run0",nVar"run1"),nVar"run1", + Bop(Sub,Bop(Add,nVar"run0",nVar"run1"),nVar"pref0")]))))) +; +val EncodeBitMask_def = Def + ("EncodeBitMask",Var("imm",BTy"N"), + Let(TP[nVar"e",nVar"S",nVar"R"], + Call("EncodeBitMaskAux",PTy(nTy,PTy(nTy,nTy)),Var("imm",BTy"N")), + Let(TP[Var("immN",F1),Var("imms",FTy 6),Var("immr",FTy 6)], + ITE(EQ(nVar"e",LN 64), + TP[LW(1,1),Mop(Cast(FTy 6),Bop(Sub,nVar"S",LN 1)), + Mop(Cast(FTy 6),nVar"R")], + TP[LW(0,1), + Bop(BOr, + Mop(BNot, + Mop(Cast(FTy 6), + Bop(Sub,Bop(Mul,nVar"e",LN 2),LN 1))), + Mop(Cast(FTy 6),Bop(Sub,nVar"S",LN 1))), + Mop(Cast(FTy 6),nVar"R")]), + CS(Call + ("DecodeBitMasks",OTy(PTy(BTy"N",BTy"N")), + TP[Var("immN",F1),Var("imms",FTy 6),Var("immr",FTy 6),LT]), + [(Mop(Some,TP[Var("imm2",BTy"N"),AVar(BTy"N")]), + ITE(EQ(Var("imm",BTy"N"),Var("imm2",BTy"N")), + Mop(Some, + TP[Var("immN",F1),Var("imms",FTy 6), + Var("immr",FTy 6)]), + LO(PTy(F1,PTy(FTy 6,FTy 6))))), + (LO(PTy(BTy"N",BTy"N")),LO(PTy(F1,PTy(FTy 6,FTy 6))))])))) +; val e_sf_def = Def ("e_sf",Var("sf",BTy"N"),Mop(Cast F1,EQ(Mop(Size,LY(0,"N")),LN 64))) ; @@ -8058,9 +8128,7 @@ val EncodeLogicalOp_def = Def (AVar(PTy(CTy"LogicalOp",bTy)),LO(FTy 2))])) ; val e_data_def = Def - ("e_data", - TP[Var("imm_enc",ATy(CTy"imm32_64",OTy(PTy(F1,PTy(FTy 6,FTy 6))))), - Var("i",CTy"Data")], + ("e_data",Var("i",CTy"Data"), CS(Var("i",CTy"Data"), [(Call ("AddSubShiftedRegister@32",CTy"Data", @@ -8222,10 +8290,9 @@ val e_data_def = Def ("LogicalImmediate@32",CTy"Data", TP[AVar F32,Var("opc",CTy"LogicalOp"),bVar"s",Var("imm",F32), Var("rn",FTy 5),Var("rd",FTy 5)]), - CS(TP[Apply - (Var("imm_enc", - ATy(CTy"imm32_64",OTy(PTy(F1,PTy(FTy 6,FTy 6))))), - Call("Imm32",CTy"imm32_64",Var("imm",F32))), + CS(TP[Call + ("EncodeBitMask",OTy(PTy(F1,PTy(FTy 6,FTy 6))), + Var("imm",F32)), Call ("EncodeLogicalOp",OTy(FTy 2), TP[Var("opc",CTy"LogicalOp"),bVar"s"])], @@ -8241,10 +8308,9 @@ val e_data_def = Def ("LogicalImmediate@64",CTy"Data", TP[AVar F64,Var("opc",CTy"LogicalOp"),bVar"s",Var("imm",F64), Var("rn",FTy 5),Var("rd",FTy 5)]), - CS(TP[Apply - (Var("imm_enc", - ATy(CTy"imm32_64",OTy(PTy(F1,PTy(FTy 6,FTy 6))))), - Call("Imm64",CTy"imm32_64",Var("imm",F64))), + CS(TP[Call + ("EncodeBitMask",OTy(PTy(F1,PTy(FTy 6,FTy 6))), + Var("imm",F64)), Call ("EncodeLogicalOp",OTy(FTy 2), TP[Var("opc",CTy"LogicalOp"),bVar"s"])], @@ -9225,9 +9291,7 @@ val e_load_store_def = Def Call("BadCode",CTy"MachineCode",LS"LoadStoreAcquirePair")))])) ; val Encode_def = Def - ("Encode", - TP[Var("imm_enc",ATy(CTy"imm32_64",OTy(PTy(F1,PTy(FTy 6,FTy 6))))), - Var("i",CTy"instruction")], + ("Encode",Var("i",CTy"instruction"), CS(Var("i",CTy"instruction"), [(Call ("Address",CTy"instruction", @@ -9256,11 +9320,7 @@ val Encode_def = Def Var("immhi",FTy 19),Var("rd",FTy 5)]), Call("BadCode",CTy"MachineCode",LS"Address")))))), (Call("Data",CTy"instruction",Var("x",CTy"Data")), - Call - ("e_data",CTy"MachineCode", - TP[Var("imm_enc", - ATy(CTy"imm32_64",OTy(PTy(F1,PTy(FTy 6,FTy 6))))), - Var("x",CTy"Data")])), + Call("e_data",CTy"MachineCode",Var("x",CTy"Data"))), (Call("Branch",CTy"instruction",Var("x",CTy"Branch")), Call("e_branch",CTy"MachineCode",Var("x",CTy"Branch"))), (Call("LoadStore",CTy"instruction",Var("x",CTy"LoadStore")), diff --git a/examples/l3-machine-code/arm8/model/arm8_encodeScript.sml b/examples/l3-machine-code/arm8/model/arm8_encodeScript.sml deleted file mode 100644 index ae75092ea7..0000000000 --- a/examples/l3-machine-code/arm8/model/arm8_encodeScript.sml +++ /dev/null @@ -1,48 +0,0 @@ -open HolKernel boolLib bossLib -open arm8AssemblerLib -open sptreeTheory arm8Theory - -val () = new_theory "arm8_encode" - -(* ----------------------------------------------------------------------- *) - -(* - -val () = Globals.max_print_depth := 10 - -*) - -val () = sptreeSyntax.temp_add_sptree_printer() - -val sptree_mask32_def = zDefine `sptree_mask32 = ^m32` -val sptree_mask64_def = zDefine `sptree_mask64 = ^m64` - -val EncodeBitMask_def = zDefine` - (EncodeBitMask (Imm32 i) = sptree$lookup (w2n i) sptree_mask32) /\ - (EncodeBitMask (Imm64 i) = sptree$lookup (w2n i) sptree_mask64)` - -val InstructionEncode_def = Define` - InstructionEncode ast = arm8$Encode (EncodeBitMask, ast)` - -val () = export_theory () - -(* ----------------------------------------------------------------------- *) - -(* Testing - -open sptreeSyntax wordsLib arm8_encodeTheory - -val EncodeBitMask_CONV = PURE_REWRITE_CONV [EncodeBitMask_def] THENC lookup_CONV -val () = computeLib.add_convs [(``EncodeBitMask``, 1, EncodeBitMask_CONV)] - -Count.apply EVAL ``EncodeBitMask (Imm32 0xFFw)`` -Count.apply EVAL ``EncodeBitMask (Imm64 0xFFw)`` - -val () = Globals.max_print_depth := ~1 - -open MutableMap arm8AssemblerLib - -EVAL ``size ^(arm8AssemblerLib.m32)`` (* 1302 *) -EVAL ``size ^(arm8AssemblerLib.m64)`` (* 5334 *) - -*) diff --git a/examples/l3-machine-code/arm8/step/arm8_stepLib.sml b/examples/l3-machine-code/arm8/step/arm8_stepLib.sml index 48c3640f3a..0dcb1a1708 100644 --- a/examples/l3-machine-code/arm8/step/arm8_stepLib.sml +++ b/examples/l3-machine-code/arm8/step/arm8_stepLib.sml @@ -6,7 +6,7 @@ structure arm8_stepLib :> arm8_stepLib = struct open HolKernel boolLib bossLib -open lcsymtacs sptreeTheory arm8Theory arm8_stepTheory arm8AssemblerLib +open lcsymtacs arm8Theory arm8_stepTheory arm8AssemblerLib open blastLib structure Parse = From e26f5b9d9e88316aff7f2f32e4565a9c85a4b401 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 14 Jan 2015 15:33:46 +1100 Subject: [PATCH 112/718] Tidy up the ARM/v4 Holmakefile (ensure all files are generated). This is yet more fallout from 6e6ca266b. Problem spotted by Konrad. --- examples/ARM/v4/Holmakefile | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) diff --git a/examples/ARM/v4/Holmakefile b/examples/ARM/v4/Holmakefile index 1595591b2b..6841256765 100644 --- a/examples/ARM/v4/Holmakefile +++ b/examples/ARM/v4/Holmakefile @@ -1,5 +1,4 @@ -EXTRA_CLEANS = evalML.uo evalML.ui assemblerML.ui assemblerML.uo\ - Data.ui Data.uo armParser.lex.sig armParser.lex.sml\ +EXTRA_CLEANS = armParser.lex.sig armParser.lex.sml\ armParser.grm.sig armParser.grm.sml armParser.grm.desc\ armParser.grm-sig.sml @@ -8,25 +7,28 @@ MLYACC = $(protect $(HOLDIR)/tools/mlyacc/src/mlyacc.exe) MLYACCLIB = $(protect $(HOLDIR)/tools/mlyacc/mlyacclib/) MLYACCLIB_UIS = $(patsubst %,MLY_%.ui,base-sig join lrtable parser2 stream) -Data.uo : Data.sml - HOLMOSMLC -c Data.sml +THYFILES = $(patsubst %Script.sml,%Theory.uo,$(wildcard *.sml)) +TARGETS = $(patsubst %.sml,%.uo,$(THYFILES)) + +all: $(TARGETS) +.PHONY: all armParser.grm.sml armParser.grm-sig.sml: armParser.grm $(MLYACC) $< $(MV) armParser.grm.sig armParser.grm-sig.sml armParser.grm-sig.uo: armParser.grm-sig.sml - HOLMOSMLC -toplevel -c -I $(MLYACCLIB) $(MLYACCLIB_UIS) $< + $(HOLMOSMLC) -toplevel -c -I $(MLYACCLIB) $(MLYACCLIB_UIS) $< armParser.grm.uo : armParser.grm.sml armParser.grm-sig.uo - HOLMOSMLC -toplevel -c -I $(MLYACCLIB) $(MLYACCLIB_UIS) armParser.grm-sig.ui $< + $(HOLMOSMLC) -toplevel -c -I $(MLYACCLIB) $(MLYACCLIB_UIS) armParser.grm-sig.ui $< armParser.lex.sml : armParser.lex $(protect $(HOLDIR)/tools/mllex/mllex.exe) $< armParser.lex.uo: armParser.lex.sml - HOLMOSMLC -toplevel -c Data.ui armParser.grm-sig.ui $< + $(HOLMOSMLC) -toplevel -c Data.ui armParser.grm-sig.ui $< assemblerML.uo: assemblerML.sml assemblerML.ui \ armParser.grm.uo armParser.lex.uo - HOLMOSMLC -c -I $(MLYACCLIB) $(MLYACCLIB_UIS) armParser.grm.ui armParser.lex.ui $< + $(HOLMOSMLC) -c -I $(MLYACCLIB) $(MLYACCLIB_UIS) armParser.grm.ui armParser.lex.ui $< From 7e8978433be148d188cbcbe8dcb509d2654a7cb7 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 14 Jan 2015 15:35:37 +1100 Subject: [PATCH 113/718] Tidy up the Holmakefile in src/emit/ML/ Effect is to remove all the emitted ML when a build cleanAll is done. This should then make it more obvious when the ARM/v4 example is not doing its thing and failing to generate armML.{sig,sml} (which caused the build problem Konrad spotted). --- src/emit/ML/Holmakefile | 3 ++- src/emit/ML/README | 13 +++++++++++++ 2 files changed, 15 insertions(+), 1 deletion(-) create mode 100644 src/emit/ML/README diff --git a/src/emit/ML/Holmakefile b/src/emit/ML/Holmakefile index 4f0f3a2740..1c9d2426c7 100644 --- a/src/emit/ML/Holmakefile +++ b/src/emit/ML/Holmakefile @@ -1,5 +1,6 @@ OPTIONS = NO_OVERLAY -EXTRA_CLEANS = selftest.exe selftest.sml +EXTRA_CLEANS = selftest.exe selftest.sml $(wildcard *ML.sig) $(wildcard *ML.sml) +INCLUDES = .. # testing SELFTESTLEVEL like this only works in Poly/ML for the moment. # when/if github issue 100 (http://github.com/mn200/HOL/issues/100) is diff --git a/src/emit/ML/README b/src/emit/ML/README new file mode 100644 index 0000000000..1f4ccfc4af --- /dev/null +++ b/src/emit/ML/README @@ -0,0 +1,13 @@ +This directory contains files generated by calls to EmitML. + +Most of these come from the execution of ../basis_emitScript. If they +have to be regenerated, then that script needs to be run again. That +effect can be achieved by touching (in the sense of the Unix command), +../basis_emitScript.sml and then running Holmake. It would also be +possible to simply remove ../basis_emitTheory.sml before calling +Holmake. + +The ARM/v4 example distributed with HOL also generates an ML file that +is deposited here. Dealing with the fact that it may or may not be +deposited, depending on how HOL is being built, explains the +complicated Holmakefile. From 6da728bc739f0419d3be80523dfd9e1c5d5eeeb7 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 14 Jan 2015 16:36:30 +1100 Subject: [PATCH 114/718] Ensure record type constructor names don't interfere with user names. When you declare a type like foo = <| n : num ; b : bool |> there is an underlying constructor defined called foo: foo : num -> bool -> foo This underpins the definition of the various functions over record types, which are made with the recursion principle for this underlying algebraic type. However, with sufficient care/malice, this constant (which users are typically oblivious to), can interfere with other definitions to ill effect. The fix is to make the constant take a name that can't even be generated by the parser, but to then overload the name ("foo" in the example) to this constant. The parser is happy to have a string overload to multiple constants; the internal theory signature mechanism has to prevent multiple constants from having the real name. (Before the fix, the kernel signature maintenance lets the second definition of a constant with this name go through but invalidates the first constant, causing a theory to purge itself of what the user thinks is a perfectly valid type.) This solves one of the problems identified in github issue #224. --- src/datatype/Datatype.sml | 7 +++++-- src/datatype/record/RecordType.sig | 2 ++ src/datatype/record/RecordType.sml | 4 +++- 3 files changed, 10 insertions(+), 3 deletions(-) diff --git a/src/datatype/Datatype.sml b/src/datatype/Datatype.sml index 1e510f7779..bf0250d8c6 100644 --- a/src/datatype/Datatype.sml +++ b/src/datatype/Datatype.sml @@ -179,8 +179,10 @@ in Args = List.tabulate (arity, fn n => Type.alpha)} end +val mk_recordtype_constructor = RecordType.mk_recordtype_constructor + fun check_constrs_unique_in_theory asts = let - fun cnames (s, Record _) = [(s,s)] + fun cnames (s, Record _) = [(s,mk_recordtype_constructor s)] | cnames (s, Constructors l) = map (fn s' => (s, #1 s')) l val newtypes = map #1 asts val constrs = List.concat (map cnames asts) @@ -218,7 +220,8 @@ end local fun tyname_as_tyvar n = mk_vartype ("'" ^ n) fun stage1 (s,Constructors l) = (s,l) - | stage1 (s,Record fields) = (s,[(s,map snd fields)]) + | stage1 (s,Record fields) = (s,[(mk_recordtype_constructor s, + map snd fields)]) fun check_fields (s,Record fields) = (case duplicate_names (map fst fields) of NONE => () diff --git a/src/datatype/record/RecordType.sig b/src/datatype/record/RecordType.sig index d6f7a8c3c4..f9021455f8 100644 --- a/src/datatype/record/RecordType.sig +++ b/src/datatype/record/RecordType.sig @@ -2,6 +2,8 @@ signature RecordType = sig include Abbrev + val mk_recordtype_constructor : string -> string + val prove_recordtype_thms : TypeBasePure.tyinfo * string list -> TypeBasePure.tyinfo * string diff --git a/src/datatype/record/RecordType.sml b/src/datatype/record/RecordType.sml index 8072551238..d97919b3b0 100644 --- a/src/datatype/record/RecordType.sml +++ b/src/datatype/record/RecordType.sml @@ -25,6 +25,7 @@ val K_tm = combinSyntax.K_tm val ERR = mk_HOL_ERR "RecordType"; +fun mk_recordtype_constructor s = "recordtype." ^ s (* ---------------------------------------------------------------------- General utilities @@ -515,7 +516,8 @@ fun prove_recordtype_thms (tyinfo, fields) = let syntax, and we want this to be preferred where possible. *) ListPair.app do_fupdfn (fields, fupdfn_terms); - ListPair.app add_record_fupdate (fields, fupdfn_terms) + ListPair.app add_record_fupdate (fields, fupdfn_terms); + Parse.overload_on(typename, constructor) end val thm_str_list = From bbdc769218f7bba0eb0c60aa6bd7f2bdacadd561 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Wed, 14 Jan 2015 19:56:23 +1100 Subject: [PATCH 115/718] add support for suffices_by to Vimhol --- tools/vim/README | 2 ++ tools/vim/hol.src | 11 +++++++++++ 2 files changed, 13 insertions(+) diff --git a/tools/vim/README b/tools/vim/README index d647d15f26..8357e06308 100644 --- a/tools/vim/README +++ b/tools/vim/README @@ -61,6 +61,7 @@ hl Same as above, but also send the region as a command afterwards. hg Send region (should be a quotation) to g, to start a new proof. he Send region (should be a tactic) to e, to expand a tactic. hS Send region (should be a quotation) as a new subgoal. +hF Send region (should be a quotation) to be proved sufficient then proved. If a visual mode command above is given in normal mode, the region will be the line containing the cursor. @@ -94,6 +95,7 @@ hL and hl don't "load" these words: local open in end. hg strips commas from the end of the region. hS strips everything including and after the first "by" in the region, if any. +hF strips everything including and after the first "suffices_by" in the region, if any. he strips these tokens from the ends of the region start: ) ] [ diff --git a/tools/vim/hol.src b/tools/vim/hol.src index da5720d7b0..5d919f8175 100644 --- a/tools/vim/hol.src +++ b/tools/vim/hol.src @@ -129,6 +129,15 @@ fu! HOLSubgoal() silent keepjumps normal G$a by ALL_TAC) endf +fu! HOLSuffices() + keepjumps normal iproofManagerLib.expand( + silent normal p + if search(s:delim.'suffices_by'.s:delim.'\_.*','cW') + silent keepjumps normal vG$"_d + en + silent keepjumps normal G$a suffices_by ALL_TAC) +endf + fu! HOLF(f) exe "normal i" . a:f endf @@ -187,6 +196,7 @@ vn u :call YankThenHOLCall(function("HOLSendQuiet"),[]) g :call YankThenHOLCall(function("HOLGoal"),[]) vn e :call YankThenHOLCall(function("HOLExpand"),[]) vn S :call YankThenHOLCall(function("HOLSubgoal"),[]) +vn F :call YankThenHOLCall(function("HOLSuffices"),[]) nm l "V".maplocalleader."l" nm L "V".maplocalleader."L" nm s "V".maplocalleader."s" @@ -194,6 +204,7 @@ nm u "V".maplocalleader."u" nm g "V".maplocalleader."g" nm e "V".maplocalleader."e" nm S "V".maplocalleader."S" +nm F "V".maplocalleader."F" nn R :call HOLRotate() nn b :call HOLRepeat("proofManagerLib.backup();") nn B :call HOLRepeat("proofManagerLib.restore();") From 6a5443a16aa2f5b5c9d4485224aca15d4a40d6be Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Wed, 14 Jan 2015 11:40:38 +0000 Subject: [PATCH 116/718] Update to CHERI model. --- .../l3-machine-code/cheri/cheriScript.sml | 4958 +++++++++-------- 1 file changed, 2760 insertions(+), 2198 deletions(-) diff --git a/examples/l3-machine-code/cheri/cheriScript.sml b/examples/l3-machine-code/cheri/cheriScript.sml index 8ad16ea616..5ba9f21647 100644 --- a/examples/l3-machine-code/cheri/cheriScript.sml +++ b/examples/l3-machine-code/cheri/cheriScript.sml @@ -1,4 +1,4 @@ -(* cheriScript.sml - generated by L<3> - Tue Nov 25 14:34:02 2014 *) +(* cheriScript.sml - generated by L<3> - Wed Jan 14 10:29:13 2015 *) open HolKernel boolLib bossLib Import val () = Import.start "cheri" @@ -83,7 +83,7 @@ val _ = Record ("hwrena'rst",FTy 28)]) ; val _ = Record - ("CP0__renamed__", + ("CP0", [("BadVAddr",F64),("Cause",CTy"CauseRegister"),("Compare",F32), ("Config",CTy"ConfigRegister"),("Config1",CTy"ConfigRegister1"), ("Config2",CTy"ConfigRegister2"),("Config3",CTy"ConfigRegister3"), @@ -101,19 +101,19 @@ val _ = Record [("EN",bTy),("IRQ",FTy 3),("pic_config_reg'rst",FTy 60)]) ; val _ = Record - ("JTAG_UART_data__renamed__", + ("JTAG_UART_data", [("RAVAIL",F16),("RVALID",bTy),("RW_DATA",F8), ("jtag_uart_data'rst",FTy 7)]) ; val _ = Record - ("JTAG_UART_control__renamed__", + ("JTAG_UART_control", [("AC",bTy),("RE",bTy),("RI",bTy),("WE",bTy),("WI",bTy),("WSPACE",F16), ("jtag_uart_control'rst",FTy 11)]) ; val _ = Record ("JTAG_UART", - [("base_address",FTy 37),("control",CTy"JTAG_UART_control__renamed__"), - ("data",CTy"JTAG_UART_data__renamed__"),("read_fifo",LTy F8), + [("base_address",FTy 37),("control",CTy"JTAG_UART_control"), + ("data",CTy"JTAG_UART_data"),("read_fifo",LTy F8), ("read_threshold",nTy),("write_fifo",LTy F8),("write_threshold",nTy)]) ; val _ = Record @@ -284,7 +284,8 @@ val _ = Construct [("CAndPerm",[PTy(FTy 5,PTy(FTy 5,FTy 5))]), ("CClearTag",[PTy(FTy 5,FTy 5)]), ("CFromPtr",[PTy(FTy 5,PTy(FTy 5,FTy 5))]), - ("CIncBase",[PTy(FTy 5,PTy(FTy 5,FTy 5))]),("CSetCause",[FTy 5]), + ("CIncBase",[PTy(FTy 5,PTy(FTy 5,FTy 5))]), + ("CIncOffset",[PTy(FTy 5,PTy(FTy 5,FTy 5))]),("CSetCause",[FTy 5]), ("CSetLen",[PTy(FTy 5,PTy(FTy 5,FTy 5))]), ("CSetOffset",[PTy(FTy 5,PTy(FTy 5,FTy 5))])])] ; @@ -354,7 +355,7 @@ val _ = Record ("c_BranchDelayPCC",ATy(F8,OTy(PTy(F64,CTy"Capability")))), ("c_BranchTo",ATy(F8,OTy F64)), ("c_BranchToPCC",ATy(F8,OTy(PTy(F64,CTy"Capability")))), - ("c_CP0",ATy(F8,CTy"CP0__renamed__")),("c_LLbit",ATy(F8,OTy bTy)), + ("c_CP0",ATy(F8,CTy"CP0")),("c_LLbit",ATy(F8,OTy bTy)), ("c_PC",ATy(F8,F64)),("c_TLB_assoc",ATy(F8,ATy(F4,CTy"TLBEntry"))), ("c_TLB_direct",ATy(F8,ATy(FTy 7,CTy"TLBEntry"))), ("c_capcause",ATy(F8,CTy"CapCause")), @@ -1867,11 +1868,11 @@ val write'lo_def = Def val CP0_def = Def ("CP0",qVar"state", TP[Apply - (Dest("c_CP0",ATy(F8,CTy"CP0__renamed__"),qVar"state"), + (Dest("c_CP0",ATy(F8,CTy"CP0"),qVar"state"), Dest("procID",F8,qVar"state")),qVar"state"]) ; val write'CP0_def = Def - ("write'CP0",Var("value",CTy"CP0__renamed__"), + ("write'CP0",Var("value",CTy"CP0"), Close (qVar"state", TP[LU, @@ -1879,9 +1880,8 @@ val write'CP0_def = Def ("c_CP0", TP[qVar"state", Fupd - (Dest("c_CP0",ATy(F8,CTy"CP0__renamed__"),qVar"state"), - Dest("procID",F8,qVar"state"), - Var("value",CTy"CP0__renamed__"))])])) + (Dest("c_CP0",ATy(F8,CTy"CP0"),qVar"state"), + Dest("procID",F8,qVar"state"),Var("value",CTy"CP0"))])])) ; val BranchDelay_def = Def ("BranchDelay",qVar"state", @@ -1964,8 +1964,7 @@ val UserMode_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state")))),LW(2,2)), Mop(Not, Bop(Or, @@ -1975,9 +1974,7 @@ val UserMode_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state")))), Dest ("ERL",bTy, @@ -1985,9 +1982,7 @@ val UserMode_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))))),qVar"state"]) ; val SupervisorMode_def = Def @@ -1999,8 +1994,7 @@ val SupervisorMode_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state")))),LW(1,2)), Mop(Not, Bop(Or, @@ -2010,9 +2004,7 @@ val SupervisorMode_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state")))), Dest ("ERL",bTy, @@ -2020,9 +2012,7 @@ val SupervisorMode_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))))),qVar"state"]) ; val KernelMode_def = Def @@ -2035,9 +2025,7 @@ val KernelMode_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state")))),LW(0,2)), Dest ("EXL",bTy, @@ -2045,8 +2033,7 @@ val KernelMode_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))), Dest ("ERL",bTy, @@ -2054,8 +2041,8 @@ val KernelMode_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), - qVar"state"))))),qVar"state"]) + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"state"))))), + qVar"state"]) ; val BigEndianMem_def = Def ("BigEndianMem",qVar"state", @@ -2064,9 +2051,8 @@ val BigEndianMem_def = Def Dest ("Config",CTy"ConfigRegister", Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), - qVar"state")))),qVar"state"]) + Apply(Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"state")))), + qVar"state"]) ; val ReverseEndian_def = Def ("ReverseEndian",qVar"state", @@ -2078,8 +2064,7 @@ val ReverseEndian_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state")))), Mop(Fst, Apply @@ -2141,7 +2126,7 @@ val cpr_def = Def ; val log_sig_exception_def = Def ("log_sig_exception",Var("ExceptionCode",FTy 5), - CC[LS"Exception 0x", + CC[LS"MIPS exception 0x", Mop(PadLeft, TP[LSC #"0",LN 2,Mop(Cast sTy,Var("ExceptionCode",FTy 5))])]) ; @@ -2484,27 +2469,26 @@ val PIC_update_def = Def PTy(F8,qTy))])))]), Var("s0",PTy(F8,qTy)))), Var("s0",PTy(F8,qTy))), - Let(Var("v",CTy"CP0__renamed__"), + Let(Var("v",CTy"CP0"), Apply (Dest - ("c_CP0",ATy(F8,CTy"CP0__renamed__"), + ("c_CP0",ATy(F8,CTy"CP0"), Mop(Snd,Var("s",PTy(F8,qTy)))),Var("id",F8)), Let(Var("x1",CTy"CauseRegister"), Dest ("Cause",CTy"CauseRegister", - Var("v",CTy"CP0__renamed__")), + Var("v",CTy"CP0")), Rupd ("c_CP0", TP[Mop(Snd,Var("s",PTy(F8,qTy))), Fupd (Dest - ("c_CP0", - ATy(F8,CTy"CP0__renamed__"), + ("c_CP0",ATy(F8,CTy"CP0"), Mop(Snd,Var("s",PTy(F8,qTy)))), Var("id",F8), Rupd ("Cause", - TP[Var("v",CTy"CP0__renamed__"), + TP[Var("v",CTy"CP0"), Rupd ("IP", TP[Var("x1", @@ -3054,14 +3038,14 @@ val PIC_store_def = Def ; val rec'JTAG_UART_data_def = Def ("rec'JTAG_UART_data",Var("x",F32), - Rec(CTy"JTAG_UART_data__renamed__", + Rec(CTy"JTAG_UART_data", [EX(Var("x",F32),LN 31,LN 16,F16),Bop(Bit,Var("x",F32),LN 15), EX(Var("x",F32),LN 7,LN 0,F8),EX(Var("x",F32),LN 14,LN 8,FTy 7)])) ; val reg'JTAG_UART_data_def = Def - ("reg'JTAG_UART_data",Var("x",CTy"JTAG_UART_data__renamed__"), - CS(Var("x",CTy"JTAG_UART_data__renamed__"), - [(Rec(CTy"JTAG_UART_data__renamed__", + ("reg'JTAG_UART_data",Var("x",CTy"JTAG_UART_data"), + CS(Var("x",CTy"JTAG_UART_data"), + [(Rec(CTy"JTAG_UART_data", [Var("RAVAIL",F16),bVar"RVALID",Var("RW_DATA",F8), Var("jtag_uart_data'rst",FTy 7)]), Bop(Mdfy, @@ -3108,18 +3092,16 @@ val reg'JTAG_UART_data_def = Def Bop(Bit,Var("RW_DATA",F8),LN 0))),LW(0,32)))])) ; val write'rec'JTAG_UART_data_def = Def - ("write'rec'JTAG_UART_data", - TP[AVar F32,Var("x",CTy"JTAG_UART_data__renamed__")], - Call("reg'JTAG_UART_data",F32,Var("x",CTy"JTAG_UART_data__renamed__"))) + ("write'rec'JTAG_UART_data",TP[AVar F32,Var("x",CTy"JTAG_UART_data")], + Call("reg'JTAG_UART_data",F32,Var("x",CTy"JTAG_UART_data"))) ; val write'reg'JTAG_UART_data_def = Def - ("write'reg'JTAG_UART_data", - TP[AVar(CTy"JTAG_UART_data__renamed__"),Var("x",F32)], - Call("rec'JTAG_UART_data",CTy"JTAG_UART_data__renamed__",Var("x",F32))) + ("write'reg'JTAG_UART_data",TP[AVar(CTy"JTAG_UART_data"),Var("x",F32)], + Call("rec'JTAG_UART_data",CTy"JTAG_UART_data",Var("x",F32))) ; val rec'JTAG_UART_control_def = Def ("rec'JTAG_UART_control",Var("x",F32), - Rec(CTy"JTAG_UART_control__renamed__", + Rec(CTy"JTAG_UART_control", [Bop(Bit,Var("x",F32),LN 10),Bop(Bit,Var("x",F32),LN 0), Bop(Bit,Var("x",F32),LN 8),Bop(Bit,Var("x",F32),LN 1), Bop(Bit,Var("x",F32),LN 9),EX(Var("x",F32),LN 31,LN 16,F16), @@ -3127,9 +3109,9 @@ val rec'JTAG_UART_control_def = Def EX(Var("x",F32),LN 15,LN 11,FTy 5)]])) ; val reg'JTAG_UART_control_def = Def - ("reg'JTAG_UART_control",Var("x",CTy"JTAG_UART_control__renamed__"), - CS(Var("x",CTy"JTAG_UART_control__renamed__"), - [(Rec(CTy"JTAG_UART_control__renamed__", + ("reg'JTAG_UART_control",Var("x",CTy"JTAG_UART_control"), + CS(Var("x",CTy"JTAG_UART_control"), + [(Rec(CTy"JTAG_UART_control", [bVar"AC",bVar"RE",bVar"RI",bVar"WE",bVar"WI", Var("WSPACE",F16),Var("jtag_uart_control'rst",FTy 11)]), Bop(Mdfy, @@ -3180,17 +3162,13 @@ val reg'JTAG_UART_control_def = Def ; val write'rec'JTAG_UART_control_def = Def ("write'rec'JTAG_UART_control", - TP[AVar F32,Var("x",CTy"JTAG_UART_control__renamed__")], - Call - ("reg'JTAG_UART_control",F32, - Var("x",CTy"JTAG_UART_control__renamed__"))) + TP[AVar F32,Var("x",CTy"JTAG_UART_control")], + Call("reg'JTAG_UART_control",F32,Var("x",CTy"JTAG_UART_control"))) ; val write'reg'JTAG_UART_control_def = Def ("write'reg'JTAG_UART_control", - TP[AVar(CTy"JTAG_UART_control__renamed__"),Var("x",F32)], - Call - ("rec'JTAG_UART_control",CTy"JTAG_UART_control__renamed__", - Var("x",F32))) + TP[AVar(CTy"JTAG_UART_control"),Var("x",F32)], + Call("rec'JTAG_UART_control",CTy"JTAG_UART_control",Var("x",F32))) ; val JTAG_UART_update_interrupt_bit_def = Def ("JTAG_UART_update_interrupt_bit",AVar uTy, @@ -3201,18 +3179,18 @@ val JTAG_UART_update_interrupt_bit_def = Def Dest ("RE",bTy, Dest - ("control",CTy"JTAG_UART_control__renamed__", + ("control",CTy"JTAG_UART_control", Dest("JTAG_UART",CTy"JTAG_UART",qVar"state"))), Dest ("RVALID",bTy, Dest - ("data",CTy"JTAG_UART_data__renamed__", + ("data",CTy"JTAG_UART_data", Dest("JTAG_UART",CTy"JTAG_UART",qVar"state")))), ITE(Mop(Not, EQ(Dest ("RI",bTy, Dest - ("control",CTy"JTAG_UART_control__renamed__", + ("control",CTy"JTAG_UART_control", Dest("JTAG_UART",CTy"JTAG_UART",qVar"state"))), bVar"v")), Let(qVar"s", @@ -3225,8 +3203,7 @@ val JTAG_UART_update_interrupt_bit_def = Def Rupd ("RI", TP[Dest - ("control", - CTy"JTAG_UART_control__renamed__", + ("control",CTy"JTAG_UART_control", Dest ("JTAG_UART",CTy"JTAG_UART", qVar"state")),bVar"v"])])]), @@ -3264,7 +3241,7 @@ val JTAG_UART_load_def = Def Rupd ("RAVAIL", TP[Dest - ("data",CTy"JTAG_UART_data__renamed__", + ("data",CTy"JTAG_UART_data", Dest ("JTAG_UART",CTy"JTAG_UART", qVar"state")),LW(0,16)])])]), @@ -3277,7 +3254,7 @@ val JTAG_UART_load_def = Def Rupd ("RVALID", TP[Dest - ("data",CTy"JTAG_UART_data__renamed__", + ("data",CTy"JTAG_UART_data", Dest ("JTAG_UART",CTy"JTAG_UART",qVar"s")), LF])])]))), @@ -3292,7 +3269,7 @@ val JTAG_UART_load_def = Def Rupd ("RW_DATA", TP[Dest - ("data",CTy"JTAG_UART_data__renamed__", + ("data",CTy"JTAG_UART_data", Dest ("JTAG_UART",CTy"JTAG_UART", qVar"state")),Var("h",F8)])])]), @@ -3306,8 +3283,7 @@ val JTAG_UART_load_def = Def Rupd ("RAVAIL", TP[Dest - ("data", - CTy"JTAG_UART_data__renamed__", + ("data",CTy"JTAG_UART_data", Dest ("JTAG_UART",CTy"JTAG_UART", qVar"s")), @@ -3324,8 +3300,7 @@ val JTAG_UART_load_def = Def Rupd ("RVALID", TP[Dest - ("data", - CTy"JTAG_UART_data__renamed__", + ("data",CTy"JTAG_UART_data", Dest ("JTAG_UART",CTy"JTAG_UART", qVar"s")),LT])])]), @@ -3358,7 +3333,7 @@ val JTAG_UART_input_def = Def Rupd ("RAVAIL", TP[Dest - ("data",CTy"JTAG_UART_data__renamed__", + ("data",CTy"JTAG_UART_data", Dest ("JTAG_UART",CTy"JTAG_UART", qVar"state")),LW(0,16)])])])), @@ -3381,8 +3356,7 @@ val JTAG_UART_input_def = Def Rupd ("RAVAIL", TP[Dest - ("data", - CTy"JTAG_UART_data__renamed__", + ("data",CTy"JTAG_UART_data", Dest ("JTAG_UART",CTy"JTAG_UART", qVar"s")), @@ -3401,7 +3375,7 @@ val JTAG_UART_input_def = Def ("AC", TP[Dest ("control", - CTy"JTAG_UART_control__renamed__", + CTy"JTAG_UART_control", Dest ("JTAG_UART", CTy"JTAG_UART",qVar"s")), @@ -3410,8 +3384,7 @@ val JTAG_UART_input_def = Def Dest ("RVALID",bTy, Dest - ("data", - CTy"JTAG_UART_data__renamed__", + ("data",CTy"JTAG_UART_data", Dest ("JTAG_UART",CTy"JTAG_UART", qVar"s")))), @@ -3433,8 +3406,7 @@ val JTAG_UART_store_def = Def EQ(Dest ("WSPACE",F16, Dest - ("control", - CTy"JTAG_UART_control__renamed__", + ("control",CTy"JTAG_UART_control", Dest ("JTAG_UART",CTy"JTAG_UART",qVar"state"))), LW(0,16)))), @@ -3448,8 +3420,7 @@ val JTAG_UART_store_def = Def Rupd ("WSPACE", TP[Dest - ("control", - CTy"JTAG_UART_control__renamed__", + ("control",CTy"JTAG_UART_control", Dest ("JTAG_UART",CTy"JTAG_UART", qVar"state")), @@ -3458,7 +3429,7 @@ val JTAG_UART_store_def = Def ("WSPACE",F16, Dest ("control", - CTy"JTAG_UART_control__renamed__", + CTy"JTAG_UART_control", Dest ("JTAG_UART", CTy"JTAG_UART", @@ -3486,8 +3457,7 @@ val JTAG_UART_store_def = Def Rupd ("RE", TP[Dest - ("control", - CTy"JTAG_UART_control__renamed__", + ("control",CTy"JTAG_UART_control", Dest ("JTAG_UART",CTy"JTAG_UART", qVar"s")), @@ -3505,7 +3475,7 @@ val JTAG_UART_store_def = Def ("WE", TP[Dest ("control", - CTy"JTAG_UART_control__renamed__", + CTy"JTAG_UART_control", Dest ("JTAG_UART",CTy"JTAG_UART", qVar"s")), @@ -3528,7 +3498,7 @@ val JTAG_UART_store_def = Def ("AC", TP[Dest ("control", - CTy"JTAG_UART_control__renamed__", + CTy"JTAG_UART_control", Dest ("JTAG_UART", CTy"JTAG_UART",qVar"s")), @@ -3546,7 +3516,7 @@ val JTAG_UART_output_def = Def Rupd ("AC", TP[Dest - ("control",CTy"JTAG_UART_control__renamed__", + ("control",CTy"JTAG_UART_control", Dest("JTAG_UART",CTy"JTAG_UART",qVar"state")), LT])])]), Let(qVar"s0", @@ -3566,8 +3536,7 @@ val JTAG_UART_output_def = Def Rupd ("WSPACE", TP[Dest - ("control", - CTy"JTAG_UART_control__renamed__", + ("control",CTy"JTAG_UART_control", Dest ("JTAG_UART",CTy"JTAG_UART",qVar"s0")), Mop(Neg,LW(1,16))])])]), @@ -3592,7 +3561,7 @@ val JTAG_UART_output_def = Def ("WI", TP[Dest ("control", - CTy"JTAG_UART_control__renamed__", + CTy"JTAG_UART_control", Dest ("JTAG_UART", CTy"JTAG_UART",qVar"s0")), @@ -3657,7 +3626,7 @@ val JTAG_UART_initialise_def = Def ("RW_DATA", TP[Dest ("data", - CTy"JTAG_UART_data__renamed__", + CTy"JTAG_UART_data", Dest ("JTAG_UART", CTy"JTAG_UART", @@ -3675,7 +3644,7 @@ val JTAG_UART_initialise_def = Def ("RVALID", TP[Dest ("data", - CTy"JTAG_UART_data__renamed__", + CTy"JTAG_UART_data", Dest ("JTAG_UART", CTy"JTAG_UART", @@ -3694,7 +3663,7 @@ val JTAG_UART_initialise_def = Def ("RAVAIL", TP[Dest ("data", - CTy"JTAG_UART_data__renamed__", + CTy"JTAG_UART_data", Dest ("JTAG_UART", CTy"JTAG_UART", @@ -3714,7 +3683,7 @@ val JTAG_UART_initialise_def = Def ("RE", TP[Dest ("control", - CTy"JTAG_UART_control__renamed__", + CTy"JTAG_UART_control", Dest ("JTAG_UART", CTy"JTAG_UART", @@ -3734,7 +3703,7 @@ val JTAG_UART_initialise_def = Def ("WE", TP[Dest ("control", - CTy"JTAG_UART_control__renamed__", + CTy"JTAG_UART_control", Dest ("JTAG_UART", CTy"JTAG_UART", @@ -3754,7 +3723,7 @@ val JTAG_UART_initialise_def = Def ("RI", TP[Dest ("control", - CTy"JTAG_UART_control__renamed__", + CTy"JTAG_UART_control", Dest ("JTAG_UART", CTy"JTAG_UART", @@ -3774,7 +3743,7 @@ val JTAG_UART_initialise_def = Def ("WI", TP[Dest ("control", - CTy"JTAG_UART_control__renamed__", + CTy"JTAG_UART_control", Dest ("JTAG_UART", CTy"JTAG_UART", @@ -3794,7 +3763,7 @@ val JTAG_UART_initialise_def = Def ("AC", TP[Dest ("control", - CTy"JTAG_UART_control__renamed__", + CTy"JTAG_UART_control", Dest ("JTAG_UART", CTy"JTAG_UART", @@ -3814,7 +3783,7 @@ val JTAG_UART_initialise_def = Def ("WSPACE", TP[Dest ("control", - CTy"JTAG_UART_control__renamed__", + CTy"JTAG_UART_control", Dest ("JTAG_UART", CTy"JTAG_UART", @@ -4627,9 +4596,7 @@ val SignalException_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))), ITE(Mop(IsSome, Mop(Fst, @@ -4648,9 +4615,8 @@ val SignalException_def = Def Apply (Const ("CP0", - ATy(qTy, - PTy(CTy"CP0__renamed__", - qTy))),qVar"state")), + ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state")), Bop(Sub, Mop(Fst, Apply @@ -4659,12 +4625,10 @@ val SignalException_def = Def ATy(qTy,PTy(F64,qTy))), qVar"state")),LW(4,64))])), qVar"state")), - Let(Var("v",CTy"CP0__renamed__"), + Let(Var("v",CTy"CP0"), Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"s")), Mop(Snd, Apply @@ -4672,15 +4636,14 @@ val SignalException_def = Def ("write'CP0",ATy(qTy,PTy(uTy,qTy)), Rupd ("Cause", - TP[Var("v",CTy"CP0__renamed__"), + TP[Var("v",CTy"CP0"), Rupd ("BD", TP[Dest ("Cause", CTy"CauseRegister", - Var("v", - CTy"CP0__renamed__")), - LT])])),qVar"s")))), + Var("v",CTy"CP0")),LT])])), + qVar"s")))), Let(qVar"s", Mop(Snd, Apply @@ -4692,20 +4655,17 @@ val SignalException_def = Def Apply (Const ("CP0", - ATy(qTy, - PTy(CTy"CP0__renamed__", - qTy))),qVar"state")), + ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state")), Mop(Fst, Apply (Const ("PC",ATy(qTy,PTy(F64,qTy))), qVar"state"))])),qVar"state")), - Let(Var("v",CTy"CP0__renamed__"), + Let(Var("v",CTy"CP0"), Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"s")), Mop(Snd, Apply @@ -4713,16 +4673,14 @@ val SignalException_def = Def ("write'CP0",ATy(qTy,PTy(uTy,qTy)), Rupd ("Cause", - TP[Var("v",CTy"CP0__renamed__"), + TP[Var("v",CTy"CP0"), Rupd ("BD", TP[Dest ("Cause", CTy"CauseRegister", - Var("v", - CTy"CP0__renamed__")), - LF])])),qVar"s"))))), - qVar"state"), + Var("v",CTy"CP0")),LF])])), + qVar"s"))))),qVar"state"), Let(qVar"s0", ITE(Mop(IsSome,Dest("currentInst",OTy F32,qVar"s")), Mop(Snd, @@ -4735,18 +4693,15 @@ val SignalException_def = Def Apply (Const ("CP0", - ATy(qTy, - PTy(CTy"CP0__renamed__", - qTy))),qVar"s")), + ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"s")), Mop(ValOf, Dest("currentInst",OTy F32,qVar"s"))])), qVar"s")),qVar"s"), - Let(Var("v0",CTy"CP0__renamed__"), + Let(Var("v0",CTy"CP0"), Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), - qVar"s0")), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s0")), Let(qVar"s0", Mop(Snd, Apply @@ -4754,24 +4709,21 @@ val SignalException_def = Def ("write'CP0",ATy(qTy,PTy(uTy,qTy)), Rupd ("Cause", - TP[Var("v0",CTy"CP0__renamed__"), + TP[Var("v0",CTy"CP0"), Rupd ("ExcCode", TP[Dest ("Cause",CTy"CauseRegister", - Var("v0", - CTy"CP0__renamed__")), + Var("v0",CTy"CP0")), Call ("ExceptionCode",FTy 5, Var("ExceptionType", CTy"ExceptionType"))])])), qVar"s0")), - Let(Var("v0",CTy"CP0__renamed__"), + Let(Var("v0",CTy"CP0"), Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"s0")), Let(qVar"s0", Mop(Snd, @@ -4780,14 +4732,13 @@ val SignalException_def = Def ("write'CP0",ATy(qTy,PTy(uTy,qTy)), Rupd ("Status", - TP[Var("v0",CTy"CP0__renamed__"), + TP[Var("v0",CTy"CP0"), Rupd ("EXL", TP[Dest ("Status", CTy"StatusRegister", - Var("v0", - CTy"CP0__renamed__")), + Var("v0",CTy"CP0")), LT])])),qVar"s0")), Let(Var("v0",F64), ITE(Dest @@ -4799,8 +4750,7 @@ val SignalException_def = Def (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", - qTy))), + PTy(CTy"CP0",qTy))), qVar"s0")))), LW(18446744072631616000,64), LW(18446744071562067968,64)), @@ -4826,164 +4776,281 @@ val SignalException_def = Def qTy)), LO F64), qVar"s0")))))), - Let(qVar"s0", - Mop(Snd, + Let(Var("v1",CTy"Capability"), + Mop(Fst, Apply - (Call - ("write'EPCC", - ATy(qTy,PTy(uTy,qTy)), - Mop(Fst, - Apply - (Const - ("PCC", - ATy(qTy, - PTy(CTy"Capability", - qTy))), - qVar"s0"))), + (Const + ("PCC", + ATy(qTy, + PTy(CTy"Capability", + qTy))), qVar"s0")), - Let(qVar"s0", - Mop(Snd, - Apply - (Call - ("write'EPCC", - ATy(qTy, - PTy(uTy,qTy)), - Rupd - ("offset", - TP[Mop(Fst, - Apply - (Const - ("EPCC", - ATy(qTy, + TP[LU, + Let(Var("s0", + PTy(CTy"Capability", + qTy)), + TP[Var("v1", + CTy"Capability"), + qVar"s0"], + Let(Var("s0", + PTy(CTy"Capability", + qTy)), + Let(TP[Var("v", + CTy"Capability"), + Var("s", + PTy(CTy"Capability", + qTy))], + Let(TP[Var("v", + PTy(CTy"Capability", + F64)), + Var("s", + PTy(CTy"Capability", + qTy))], + Let(TP[Var("v2", + F64), + Var("s", + PTy(CTy"Capability", + qTy))], + Let(TP[Var("v", + F64), + qVar"s3"], + TP[Mop(Fst, + Apply + (Const + ("PC", + ATy(qTy, + PTy(F64, + qTy))), + Mop(Snd, + Var("s0", + PTy(CTy"Capability", + qTy))))), + Mop(Snd, + Var("s0", + PTy(CTy"Capability", + qTy)))], + TP[Var("v", + F64), + Mop(Fst, + Var("s0", + PTy(CTy"Capability", + qTy))), + qVar"s3"]), + TP[TP[Var("v1", + CTy"Capability"), + Var("v2", + F64)], + Var("s", + PTy(CTy"Capability", + qTy))]), + TP[Rupd + ("offset", + Var("v", + PTy(CTy"Capability", + F64))), + Var("s", + PTy(CTy"Capability", + qTy))]), + TP[Var("v", + CTy"Capability"), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy)))]), + Let(Var("s0", + PTy(CTy"Capability", + qTy)), + TP[Mop(Fst, + Var("s0", + PTy(CTy"Capability", + qTy))), + Mop(Snd, + Apply + (Call + ("write'EPCC", + ATy(qTy, + PTy(uTy, + qTy)), + Mop(Fst, + Var("s0", + PTy(CTy"Capability", + qTy)))), + Mop(Snd, + Var("s0", + PTy(CTy"Capability", + qTy)))))], + Let(TP[Var("v1", + CTy"Capability"), + Var("s0", + PTy(CTy"Capability", + qTy))], + CS(TP[Mop(Fst, + Apply + (Const + ("KCC", + ATy(qTy, + PTy(CTy"Capability", + qTy))), + Mop(Snd, + Var("s0", + PTy(CTy"Capability", + qTy))))), + Mop(Snd, + Var("s0", + PTy(CTy"Capability", + qTy)))], + [(TP[Var("v", + CTy"Capability"), + qVar"s3"], + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Var("s0", + PTy(CTy"Capability", + qTy))), + qVar"s3"])]), + Let(Var("s0", + PTy(CTy"Capability", + qTy)), + TP[Mop(Fst, + Var("s0", PTy(CTy"Capability", qTy))), - qVar"s0")), - Mop(Fst, - Apply - (Const - ("PC", - ATy(qTy, - PTy(F64, - qTy))), - qVar"s0"))])), - qVar"s0")), - Apply - (Call - ("mark_log", - ATy(qTy,PTy(uTy,qTy)), - TP[LN 2, - Call - ("log_sig_exception", - sTy, - Call - ("ExceptionCode", - FTy 5, - Var("ExceptionType", - CTy"ExceptionType")))]), - Mop(Snd, - Apply - (Call - ("write'PC", - ATy(qTy, - PTy(uTy,qTy)), - CC[EX(Var("v0", - F64), - LN 63, - LN 30, - FTy 34), - Bop(Add, - EX(Var("v0", - F64), - LN 29, - LN 0, - FTy 30), - ITB([(Bop(And, - Bop(Or, - EQ(Var("ExceptionType", - CTy"ExceptionType"), - LC("XTLBRefillL", - CTy"ExceptionType")), - EQ(Var("ExceptionType", - CTy"ExceptionType"), - LC("XTLBRefillS", - CTy"ExceptionType"))), - Mop(Not, - Dest - ("EXL", - bTy, - Dest - ("Status", - CTy"StatusRegister", - Mop(Fst, - Apply - (Const - ("CP0", - ATy(qTy, - PTy(CTy"CP0__renamed__", - qTy))), - qVar"s")))))), - LW(128, - 30)), - (Bop(And, - EQ(Var("ExceptionType", - CTy"ExceptionType"), - LC("C2E", - CTy"ExceptionType")), - Bop(Or, - EQ(Dest - ("ExcCode", - F8, - Mop(Fst, - Apply - (Const - ("capcause", - ATy(qTy, - PTy(CTy"CapCause", - qTy))), - qVar"s"))), - LW(5, - 8)), - EQ(Dest - ("ExcCode", - F8, - Mop(Fst, - Apply - (Const - ("capcause", - ATy(qTy, - PTy(CTy"CapCause", - qTy))), - qVar"s"))), - LW(6, - 8)))), - LW(640, - 30))], - LW(384, - 30)))]), - Mop(Snd, - Apply - (Call - ("write'PCC", - ATy(qTy, - PTy(uTy, - qTy)), - Mop(Fst, - Apply - (Const - ("KCC", - ATy(qTy, + Mop(Snd, + Apply + (Call + ("write'PCC", + ATy(qTy, + PTy(uTy, + qTy)), + Var("v1", + CTy"Capability")), + Mop(Snd, + Var("s0", + PTy(CTy"Capability", + qTy)))))], + Let(Var("s", + PTy(CTy"Capability", + qTy)), + TP[Mop(Fst, + Var("s0", PTy(CTy"Capability", qTy))), - qVar"s0"))), - qVar"s0"))))))))))))))))) + Mop(Snd, + Apply + (Call + ("write'PC", + ATy(qTy, + PTy(uTy, + qTy)), + CC[EX(Var("v0", + F64), + LN + 63, + LN + 30, + FTy 34), + Bop(Add, + EX(Var("v0", + F64), + LN + 29, + LN + 0, + FTy 30), + ITB([(Bop(And, + Bop(Or, + EQ(Var("ExceptionType", + CTy"ExceptionType"), + LC("XTLBRefillL", + CTy"ExceptionType")), + EQ(Var("ExceptionType", + CTy"ExceptionType"), + LC("XTLBRefillS", + CTy"ExceptionType"))), + Mop(Not, + Dest + ("EXL", + bTy, + Dest + ("Status", + CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0", + qTy))), + qVar"s")))))), + LW(128, + 30)), + (Bop(And, + EQ(Var("ExceptionType", + CTy"ExceptionType"), + LC("C2E", + CTy"ExceptionType")), + Bop(Or, + EQ(Dest + ("ExcCode", + F8, + Mop(Fst, + Apply + (Const + ("capcause", + ATy(qTy, + PTy(CTy"CapCause", + qTy))), + qVar"s"))), + LW(5, + 8)), + EQ(Dest + ("ExcCode", + F8, + Mop(Fst, + Apply + (Const + ("capcause", + ATy(qTy, + PTy(CTy"CapCause", + qTy))), + qVar"s"))), + LW(6, + 8)))), + LW(640, + 30))], + LW(384, + 30)))]), + Mop(Snd, + Var("s0", + PTy(CTy"Capability", + qTy)))))], + Mop(Snd, + Apply + (Call + ("mark_log", + ATy(qTy, + PTy(uTy, + qTy)), + TP[LN + 2, + Call + ("log_sig_exception", + sTy, + Call + ("ExceptionCode", + FTy 5, + Var("ExceptionType", + CTy"ExceptionType")))]), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy)))))))))))]))))))))))) ; val SignalCP2UnusableException_def = Def ("SignalCP2UnusableException",qVar"state", - Let(Var("v",CTy"CP0__renamed__"), - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), - qVar"state")), + Let(Var("v",CTy"CP0"), + Mop(Fst,Apply(Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"state")), Apply (Call ("SignalException",ATy(qTy,PTy(uTy,qTy)), @@ -4994,12 +5061,12 @@ val SignalCP2UnusableException_def = Def ("write'CP0",ATy(qTy,PTy(uTy,qTy)), Rupd ("Cause", - TP[Var("v",CTy"CP0__renamed__"), + TP[Var("v",CTy"CP0"), Rupd ("CE", TP[Dest ("Cause",CTy"CauseRegister", - Var("v",CTy"CP0__renamed__")),LW(2,2)])])), + Var("v",CTy"CP0")),LW(2,2)])])), qVar"state"))))) ; val SignalCapException_internal_def = Def @@ -5062,22 +5129,51 @@ val SignalCapException_internal_def = Def LW(29,8)), (LC("capExcAccKR2C",CTy"CapException"), LW(30,8))])])),qVar"state")), - Apply - (Call - ("SignalException",ATy(qTy,PTy(uTy,qTy)), - LC("C2E",CTy"ExceptionType")), - Mop(Snd, - Apply - (Call - ("write'capcause",ATy(qTy,PTy(uTy,qTy)), - Rupd - ("RegNum", - TP[Mop(Fst, - Apply - (Const - ("capcause", - ATy(qTy,PTy(CTy"CapCause",qTy))), - qVar"s")),Var("regNum",F8)])),qVar"s")))))) + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'capcause",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("RegNum", + TP[Mop(Fst, + Apply + (Const + ("capcause", + ATy(qTy,PTy(CTy"CapCause",qTy))), + qVar"s")),Var("regNum",F8)])),qVar"s")), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("C2E",CTy"ExceptionType")), + Mop(Snd, + Apply + (Call + ("mark_log",ATy(qTy,PTy(uTy,qTy)), + TP[LN 2, + CC[LS"Cap exception - cause: 0x", + Mop(Cast sTy, + Dest + ("ExcCode",F8, + Mop(Fst, + Apply + (Const + ("capcause", + ATy(qTy, + PTy(CTy"CapCause", + qTy))),qVar"s")))), + LS", reg: 0x", + Mop(Cast sTy, + Dest + ("RegNum",F8, + Mop(Fst, + Apply + (Const + ("capcause", + ATy(qTy, + PTy(CTy"CapCause", + qTy))),qVar"s"))))]]), + qVar"s"))))))) ; val SignalCapException_def = Def ("SignalCapException", @@ -5146,7 +5242,7 @@ val dfn'ERET_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state")))), Mop(Fst, Apply @@ -5161,9 +5257,7 @@ val dfn'ERET_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state")))), Let(qVar"s", Mop(Snd, @@ -5178,17 +5272,14 @@ val dfn'ERET_def = Def (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", - qTy))), + PTy(CTy"CP0",qTy))), qVar"state"))),LW(4,64))), qVar"state")), - Let(Var("v",CTy"CP0__renamed__"), + Let(Var("v",CTy"CP0"), Mop(Fst, Apply (Const - ("CP0", - ATy(qTy, - PTy(CTy"CP0__renamed__",qTy))), + ("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"s")), Mop(Snd, Apply @@ -5196,14 +5287,13 @@ val dfn'ERET_def = Def ("write'CP0",ATy(qTy,PTy(uTy,qTy)), Rupd ("Status", - TP[Var("v",CTy"CP0__renamed__"), + TP[Var("v",CTy"CP0"), Rupd ("ERL", TP[Dest ("Status", CTy"StatusRegister", - Var("v", - CTy"CP0__renamed__")), + Var("v",CTy"CP0")), LF])])),qVar"s")))), Let(qVar"s", Mop(Snd, @@ -5218,17 +5308,14 @@ val dfn'ERET_def = Def (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", - qTy))), + PTy(CTy"CP0",qTy))), qVar"state"))),LW(4,64))), qVar"state")), - Let(Var("v",CTy"CP0__renamed__"), + Let(Var("v",CTy"CP0"), Mop(Fst, Apply (Const - ("CP0", - ATy(qTy, - PTy(CTy"CP0__renamed__",qTy))), + ("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"s")), Mop(Snd, Apply @@ -5236,14 +5323,13 @@ val dfn'ERET_def = Def ("write'CP0",ATy(qTy,PTy(uTy,qTy)), Rupd ("Status", - TP[Var("v",CTy"CP0__renamed__"), + TP[Var("v",CTy"CP0"), Rupd ("EXL", TP[Dest ("Status", CTy"StatusRegister", - Var("v", - CTy"CP0__renamed__")), + Var("v",CTy"CP0")), LF])])),qVar"s"))))))), Apply (Call @@ -5346,18 +5432,16 @@ val LookupTLB_def = Def Dest("Mask",FTy 12,Var("v",CTy"TLBEntry")))), Let(TP[Var("r",LTy(PTy(F8,CTy"TLBEntry"))), Var("s1",PTy(LTy(PTy(F8,CTy"TLBEntry")),qTy))], - Let(TP[Var("v0",CTy"CP0__renamed__"), + Let(TP[Var("v0",CTy"CP0"), Var("s",PTy(LTy(PTy(F8,CTy"TLBEntry")),qTy))], - Let(TP[Var("v",CTy"CP0__renamed__"),qVar"s3"], + Let(TP[Var("v",CTy"CP0"),qVar"s3"], TP[Mop(Fst, Apply (Const - ("CP0", - ATy(qTy, - PTy(CTy"CP0__renamed__",qTy))), + ("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state")),qVar"state"], - TP[Var("v",CTy"CP0__renamed__"), - LNL(PTy(F8,CTy"TLBEntry")),qVar"s3"]), + TP[Var("v",CTy"CP0"),LNL(PTy(F8,CTy"TLBEntry")), + qVar"s3"]), Let(Var("s",PTy(LTy(PTy(F8,CTy"TLBEntry")),qTy)), Mop(Snd, Apply @@ -5416,20 +5500,20 @@ val LookupTLB_def = Def Var("v", CTy"TLBEntry")))), Let(TP[Var("v0", - CTy"CP0__renamed__"), + CTy"CP0"), Var("s", PTy(LTy(PTy(F8, CTy"TLBEntry")), qTy))], Let(TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), qVar"s3"], TP[Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), Mop(Snd, Var("s", @@ -5442,7 +5526,7 @@ val LookupTLB_def = Def CTy"TLBEntry")), qTy)))], TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Var("s", PTy(LTy(PTy(F8, @@ -5490,7 +5574,7 @@ val LookupTLB_def = Def ("EntryHi", CTy"EntryHi", Var("v0", - CTy"CP0__renamed__")))))), + CTy"CP0")))))), TP[LLC([TP[Mop(Cast F8, nVar"i"), @@ -5514,21 +5598,19 @@ val LookupTLB_def = Def ("LTLB",bTy, Dest ("Config6",CTy"ConfigRegister6", - Var("v0",CTy"CP0__renamed__"))), - Let(TP[Var("v0",CTy"CP0__renamed__"), + Var("v0",CTy"CP0"))), + Let(TP[Var("v0",CTy"CP0"), Var("s", PTy(LTy(PTy(F8, CTy"TLBEntry")), qTy))], - Let(TP[Var("v", - CTy"CP0__renamed__"), - qVar"s3"], + Let(TP[Var("v",CTy"CP0"),qVar"s3"], TP[Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), Mop(Snd, Var("s", @@ -5540,8 +5622,7 @@ val LookupTLB_def = Def PTy(LTy(PTy(F8, CTy"TLBEntry")), qTy)))], - TP[Var("v", - CTy"CP0__renamed__"), + TP[Var("v",CTy"CP0"), Mop(Fst, Var("s", PTy(LTy(PTy(F8, @@ -5583,7 +5664,7 @@ val LookupTLB_def = Def ("EntryHi", CTy"EntryHi", Var("v0", - CTy"CP0__renamed__")))))), + CTy"CP0")))))), LL[TP[ITE(Bop(Ge, Mop(Cast nTy, EX(Var("vpn2", @@ -5650,16 +5731,13 @@ val SignalTLBException_def = Def Apply (Const ("CP0", - ATy(qTy, - PTy(CTy"CP0__renamed__", - qTy))),qVar"s")), - Var("vAddr",F64)])),qVar"s")), - Let(Var("v",CTy"CP0__renamed__"), + ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"s")),Var("vAddr",F64)])), + qVar"s")), + Let(Var("v",CTy"CP0"), Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"s")), Let(qVar"s", Mop(Snd, @@ -5668,24 +5746,22 @@ val SignalTLBException_def = Def ("write'CP0",ATy(qTy,PTy(uTy,qTy)), Rupd ("EntryHi", - TP[Var("v",CTy"CP0__renamed__"), + TP[Var("v",CTy"CP0"), Rupd ("R", TP[Dest ("EntryHi", CTy"EntryHi", - Var("v", - CTy"CP0__renamed__")), + Var("v",CTy"CP0")), Var("r",FTy 2)])])), qVar"s")), - Let(Var("v",CTy"CP0__renamed__"), + Let(Var("v",CTy"CP0"), Mop(Fst, Apply (Const ("CP0", - ATy(qTy, - PTy(CTy"CP0__renamed__", - qTy))),qVar"s")), + ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"s")), Let(qVar"s", Mop(Snd, Apply @@ -5694,26 +5770,25 @@ val SignalTLBException_def = Def ATy(qTy,PTy(uTy,qTy)), Rupd ("EntryHi", - TP[Var("v", - CTy"CP0__renamed__"), + TP[Var("v",CTy"CP0"), Rupd ("VPN2", TP[Dest ("EntryHi", CTy"EntryHi", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), Var("vpn2", FTy 27)])])), qVar"s")), - Let(Var("v",CTy"CP0__renamed__"), + Let(Var("v",CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", - qTy))),qVar"s")), + PTy(CTy"CP0",qTy))), + qVar"s")), Let(qVar"s", Mop(Snd, Apply @@ -5724,25 +5799,24 @@ val SignalTLBException_def = Def Rupd ("EntryHi", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("ASID", TP[Dest ("EntryHi", CTy"EntryHi", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), Var("asid", F8)])])), qVar"s")), - Let(Var("v", - CTy"CP0__renamed__"), + Let(Var("v",CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -5756,25 +5830,24 @@ val SignalTLBException_def = Def Rupd ("XContext", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("R", TP[Dest ("XContext", CTy"XContext", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), Var("r", FTy 2)])])), qVar"s")), - Let(Var("v", - CTy"CP0__renamed__"), + Let(Var("v",CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -5788,25 +5861,25 @@ val SignalTLBException_def = Def Rupd ("XContext", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("BadVPN2", TP[Dest ("XContext", CTy"XContext", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), Var("vpn2", FTy 27)])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), TP[LX(PTy(FTy 40, @@ -5821,14 +5894,14 @@ val SignalTLBException_def = Def Rupd ("Context", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("BadVPN2", TP[Dest ("Context", CTy"Context", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), EX(Var("vAddr", F64), LN @@ -5895,9 +5968,7 @@ val CheckSegment_def = Def Mop(Fst, Apply (Const - ("CP0", - ATy(qTy, - PTy(CTy"CP0__renamed__",qTy))), + ("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))]),LT]), (Bop(And, Bop(Ule,LW(18446744072098938880,64),Var("vAddr",F64)), @@ -5959,8 +6030,7 @@ val AddressTranslation_def = Def (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", - qTy))), + PTy(CTy"CP0",qTy))), qVar"state")))), Var("vAddr",F64)]),qVar"state"), TP[LX(PTy(FTy 40,PTy(FTy 3,PTy(bTy,bTy)))), @@ -6107,8 +6177,7 @@ val AddressTranslation_def = Def (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", - qTy))), + PTy(CTy"CP0",qTy))), qVar"state")), Bop(Add, Dest @@ -6133,22 +6202,20 @@ val ModifyTLB_def = Def ("EntryHi",CTy"EntryHi", Mop(Fst, Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), - qVar"state"))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"state"))), Let(Var("v0",CTy"EntryLo"), Dest ("EntryLo1",CTy"EntryLo", Mop(Fst, Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))), Let(Var("v1",CTy"EntryLo"), Dest ("EntryLo0",CTy"EntryLo", Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))), Let(TP[Var("r",CTy"TLBEntry"), Var("s1",PTy(CTy"TLBEntry",qTy))], @@ -6159,18 +6226,17 @@ val ModifyTLB_def = Def Var("s",PTy(CTy"TLBEntry",qTy))], Let(TP[Var("v",PTy(CTy"TLBEntry",FTy 12)), Var("s",PTy(CTy"TLBEntry",qTy))], - Let(TP[Var("v0",CTy"CP0__renamed__"), + Let(TP[Var("v0",CTy"CP0"), Var("s", PTy(CTy"TLBEntry",qTy))], - Let(TP[Var("v", - CTy"CP0__renamed__"), + Let(TP[Var("v",CTy"CP0"), qVar"s3"], TP[Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), Mop(Snd, Var("s", @@ -6180,8 +6246,7 @@ val ModifyTLB_def = Def Var("s", PTy(CTy"TLBEntry", qTy)))], - TP[Var("v", - CTy"CP0__renamed__"), + TP[Var("v",CTy"CP0"), Mop(Fst, Var("s", PTy(CTy"TLBEntry", @@ -6193,8 +6258,7 @@ val ModifyTLB_def = Def Dest ("PageMask", CTy"PageMask", - Var("v0", - CTy"CP0__renamed__")))], + Var("v0",CTy"CP0")))], Var("s", PTy(CTy"TLBEntry",qTy))]), TP[Rupd @@ -6499,8 +6563,7 @@ val dfn'TLBR_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))), Mop(Not, Mop(Fst, @@ -6518,7 +6581,7 @@ val dfn'TLBR_def = Def ("Index",CTy"Index", Mop(Fst, Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state")))), Let(Var("v",CTy"TLBEntry"), ITE(Bop(Ge,Mop(Cast nTy,Var("v",F8)), @@ -6533,11 +6596,10 @@ val dfn'TLBR_def = Def (Call ("TLB_assoc",ATy(qTy,PTy(CTy"TLBEntry",qTy)), Mop(Cast F4,Var("v",F8))),qVar"state"))), - Let(Var("v0",CTy"CP0__renamed__"), + Let(Var("v0",CTy"CP0"), Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state")), Let(qVar"s", Mop(Snd, @@ -6546,23 +6608,20 @@ val dfn'TLBR_def = Def ("write'CP0",ATy(qTy,PTy(uTy,qTy)), Rupd ("PageMask", - TP[Var("v0",CTy"CP0__renamed__"), + TP[Var("v0",CTy"CP0"), Rupd ("Mask", TP[Dest ("PageMask",CTy"PageMask", - Var("v0", - CTy"CP0__renamed__")), + Var("v0",CTy"CP0")), Dest ("Mask",FTy 12, Var("v",CTy"TLBEntry"))])])), qVar"state")), - Let(Var("v0",CTy"CP0__renamed__"), + Let(Var("v0",CTy"CP0"), Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"s")), Let(qVar"s", Mop(Snd, @@ -6572,28 +6631,25 @@ val dfn'TLBR_def = Def ATy(qTy,PTy(uTy,qTy)), Rupd ("EntryHi", - TP[Var("v0", - CTy"CP0__renamed__"), + TP[Var("v0",CTy"CP0"), Rupd ("R", TP[Dest ("EntryHi", CTy"EntryHi", - Var("v0", - CTy"CP0__renamed__")), + Var("v0",CTy"CP0")), Dest ("R",FTy 2, Var("v", CTy"TLBEntry"))])])), qVar"s")), - Let(Var("v0",CTy"CP0__renamed__"), + Let(Var("v0",CTy"CP0"), Mop(Fst, Apply (Const ("CP0", - ATy(qTy, - PTy(CTy"CP0__renamed__", - qTy))),qVar"s")), + ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"s")), Let(qVar"s", Mop(Snd, Apply @@ -6602,29 +6658,27 @@ val dfn'TLBR_def = Def ATy(qTy,PTy(uTy,qTy)), Rupd ("EntryHi", - TP[Var("v0", - CTy"CP0__renamed__"), + TP[Var("v0",CTy"CP0"), Rupd ("VPN2", TP[Dest ("EntryHi", CTy"EntryHi", Var("v0", - CTy"CP0__renamed__")), + CTy"CP0")), Dest ("VPN2", FTy 27, Var("v", CTy"TLBEntry"))])])), qVar"s")), - Let(Var("v0",CTy"CP0__renamed__"), + Let(Var("v0",CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", - qTy))), + PTy(CTy"CP0",qTy))), qVar"s")), Let(qVar"s", Mop(Snd, @@ -6636,28 +6690,27 @@ val dfn'TLBR_def = Def Rupd ("EntryHi", TP[Var("v0", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("ASID", TP[Dest ("EntryHi", CTy"EntryHi", Var("v0", - CTy"CP0__renamed__")), + CTy"CP0")), Dest ("ASID", F8, Var("v", CTy"TLBEntry"))])])), qVar"s")), - Let(Var("v0", - CTy"CP0__renamed__"), + Let(Var("v0",CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -6671,14 +6724,14 @@ val dfn'TLBR_def = Def Rupd ("EntryLo1", TP[Var("v0", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("S", TP[Dest ("EntryLo1", CTy"EntryLo", Var("v0", - CTy"CP0__renamed__")), + CTy"CP0")), Dest ("S1", bTy, @@ -6686,13 +6739,13 @@ val dfn'TLBR_def = Def CTy"TLBEntry"))])])), qVar"s")), Let(Var("v0", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -6706,14 +6759,14 @@ val dfn'TLBR_def = Def Rupd ("EntryLo1", TP[Var("v0", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("L", TP[Dest ("EntryLo1", CTy"EntryLo", Var("v0", - CTy"CP0__renamed__")), + CTy"CP0")), Dest ("L1", bTy, @@ -6721,13 +6774,13 @@ val dfn'TLBR_def = Def CTy"TLBEntry"))])])), qVar"s")), Let(Var("v0", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -6741,14 +6794,14 @@ val dfn'TLBR_def = Def Rupd ("EntryLo1", TP[Var("v0", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("PFN", TP[Dest ("EntryLo1", CTy"EntryLo", Var("v0", - CTy"CP0__renamed__")), + CTy"CP0")), Dest ("PFN1", FTy 28, @@ -6756,13 +6809,13 @@ val dfn'TLBR_def = Def CTy"TLBEntry"))])])), qVar"s")), Let(Var("v0", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -6776,14 +6829,14 @@ val dfn'TLBR_def = Def Rupd ("EntryLo1", TP[Var("v0", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("C", TP[Dest ("EntryLo1", CTy"EntryLo", Var("v0", - CTy"CP0__renamed__")), + CTy"CP0")), Dest ("C1", FTy 3, @@ -6791,13 +6844,13 @@ val dfn'TLBR_def = Def CTy"TLBEntry"))])])), qVar"s")), Let(Var("v0", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -6811,14 +6864,14 @@ val dfn'TLBR_def = Def Rupd ("EntryLo1", TP[Var("v0", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("D", TP[Dest ("EntryLo1", CTy"EntryLo", Var("v0", - CTy"CP0__renamed__")), + CTy"CP0")), Dest ("D1", bTy, @@ -6826,13 +6879,13 @@ val dfn'TLBR_def = Def CTy"TLBEntry"))])])), qVar"s")), Let(Var("v0", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -6846,14 +6899,14 @@ val dfn'TLBR_def = Def Rupd ("EntryLo1", TP[Var("v0", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("V", TP[Dest ("EntryLo1", CTy"EntryLo", Var("v0", - CTy"CP0__renamed__")), + CTy"CP0")), Dest ("V1", bTy, @@ -6861,13 +6914,13 @@ val dfn'TLBR_def = Def CTy"TLBEntry"))])])), qVar"s")), Let(Var("v0", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -6881,14 +6934,14 @@ val dfn'TLBR_def = Def Rupd ("EntryLo1", TP[Var("v0", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("G", TP[Dest ("EntryLo1", CTy"EntryLo", Var("v0", - CTy"CP0__renamed__")), + CTy"CP0")), Dest ("G", bTy, @@ -6896,13 +6949,13 @@ val dfn'TLBR_def = Def CTy"TLBEntry"))])])), qVar"s")), Let(Var("v0", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -6916,14 +6969,14 @@ val dfn'TLBR_def = Def Rupd ("EntryLo0", TP[Var("v0", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("S", TP[Dest ("EntryLo0", CTy"EntryLo", Var("v0", - CTy"CP0__renamed__")), + CTy"CP0")), Dest ("S0", bTy, @@ -6931,13 +6984,13 @@ val dfn'TLBR_def = Def CTy"TLBEntry"))])])), qVar"s")), Let(Var("v0", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -6951,14 +7004,14 @@ val dfn'TLBR_def = Def Rupd ("EntryLo0", TP[Var("v0", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("L", TP[Dest ("EntryLo0", CTy"EntryLo", Var("v0", - CTy"CP0__renamed__")), + CTy"CP0")), Dest ("L0", bTy, @@ -6966,13 +7019,13 @@ val dfn'TLBR_def = Def CTy"TLBEntry"))])])), qVar"s")), Let(Var("v0", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -6986,14 +7039,14 @@ val dfn'TLBR_def = Def Rupd ("EntryLo0", TP[Var("v0", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("PFN", TP[Dest ("EntryLo0", CTy"EntryLo", Var("v0", - CTy"CP0__renamed__")), + CTy"CP0")), Dest ("PFN0", FTy 28, @@ -7001,13 +7054,13 @@ val dfn'TLBR_def = Def CTy"TLBEntry"))])])), qVar"s")), Let(Var("v0", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -7021,14 +7074,14 @@ val dfn'TLBR_def = Def Rupd ("EntryLo0", TP[Var("v0", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("C", TP[Dest ("EntryLo0", CTy"EntryLo", Var("v0", - CTy"CP0__renamed__")), + CTy"CP0")), Dest ("C0", FTy 3, @@ -7036,13 +7089,13 @@ val dfn'TLBR_def = Def CTy"TLBEntry"))])])), qVar"s")), Let(Var("v0", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -7056,14 +7109,14 @@ val dfn'TLBR_def = Def Rupd ("EntryLo0", TP[Var("v0", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("D", TP[Dest ("EntryLo0", CTy"EntryLo", Var("v0", - CTy"CP0__renamed__")), + CTy"CP0")), Dest ("D0", bTy, @@ -7071,13 +7124,13 @@ val dfn'TLBR_def = Def CTy"TLBEntry"))])])), qVar"s")), Let(Var("v0", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -7091,14 +7144,14 @@ val dfn'TLBR_def = Def Rupd ("EntryLo0", TP[Var("v0", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("V", TP[Dest ("EntryLo0", CTy"EntryLo", Var("v0", - CTy"CP0__renamed__")), + CTy"CP0")), Dest ("V0", bTy, @@ -7106,13 +7159,13 @@ val dfn'TLBR_def = Def CTy"TLBEntry"))])])), qVar"s")), Let(Var("v0", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Apply @@ -7124,14 +7177,14 @@ val dfn'TLBR_def = Def Rupd ("EntryLo0", TP[Var("v0", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("G", TP[Dest ("EntryLo0", CTy"EntryLo", Var("v0", - CTy"CP0__renamed__")), + CTy"CP0")), Dest ("G", bTy, @@ -7149,8 +7202,7 @@ val dfn'TLBP_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))), Mop(Not, Mop(Fst, @@ -7173,9 +7225,7 @@ val dfn'TLBP_def = Def Mop(Fst, Apply (Const - ("CP0", - ATy(qTy, - PTy(CTy"CP0__renamed__",qTy))), + ("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state")))), Dest ("VPN2",FTy 27, @@ -7184,16 +7234,13 @@ val dfn'TLBP_def = Def Mop(Fst, Apply (Const - ("CP0", - ATy(qTy, - PTy(CTy"CP0__renamed__",qTy))), + ("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))]),qVar"state")), [(LNL(PTy(F8,CTy"TLBEntry")), - Let(Var("v",CTy"CP0__renamed__"), + Let(Var("v",CTy"CP0"), Mop(Fst, Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), - qVar"state")), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"state")), Let(qVar"s", Mop(Snd, Apply @@ -7201,38 +7248,35 @@ val dfn'TLBP_def = Def ("write'CP0",ATy(qTy,PTy(uTy,qTy)), Rupd ("Index", - TP[Var("v",CTy"CP0__renamed__"), + TP[Var("v",CTy"CP0"), Rupd ("P", TP[Dest ("Index",CTy"Index", - Var("v",CTy"CP0__renamed__")), - LT])])),qVar"state")), - Let(Var("v",CTy"CP0__renamed__"), + Var("v",CTy"CP0")),LT])])), + qVar"state")), + Let(Var("v",CTy"CP0"), Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"s")), Apply (Call ("write'CP0",ATy(qTy,PTy(uTy,qTy)), Rupd ("Index", - TP[Var("v",CTy"CP0__renamed__"), + TP[Var("v",CTy"CP0"), Rupd ("Index", TP[Dest ("Index",CTy"Index", - Var("v",CTy"CP0__renamed__")), - LX F8])])),qVar"s"))))), + Var("v",CTy"CP0")),LX F8])])), + qVar"s"))))), (LL[TP[Var("i",F8),Var("e",CTy"TLBEntry")]], - Let(Var("v",CTy"CP0__renamed__"), + Let(Var("v",CTy"CP0"), Mop(Fst, Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), - qVar"state")), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"state")), Let(qVar"s", Mop(Snd, Apply @@ -7240,31 +7284,29 @@ val dfn'TLBP_def = Def ("write'CP0",ATy(qTy,PTy(uTy,qTy)), Rupd ("Index", - TP[Var("v",CTy"CP0__renamed__"), + TP[Var("v",CTy"CP0"), Rupd ("P", TP[Dest ("Index",CTy"Index", - Var("v",CTy"CP0__renamed__")), - LF])])),qVar"state")), - Let(Var("v",CTy"CP0__renamed__"), + Var("v",CTy"CP0")),LF])])), + qVar"state")), + Let(Var("v",CTy"CP0"), Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"s")), Apply (Call ("write'CP0",ATy(qTy,PTy(uTy,qTy)), Rupd ("Index", - TP[Var("v",CTy"CP0__renamed__"), + TP[Var("v",CTy"CP0"), Rupd ("Index", TP[Dest ("Index",CTy"Index", - Var("v",CTy"CP0__renamed__")), + Var("v",CTy"CP0")), Var("i",F8)])])),qVar"s"))))), (AVar(LTy(PTy(F8,CTy"TLBEntry"))), Apply @@ -7284,9 +7326,7 @@ val dfn'TLBWI_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))), Mop(Not, Mop(Fst, @@ -7305,9 +7345,7 @@ val dfn'TLBWI_def = Def ("Index",CTy"Index", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))),Const("TLBEntries",nTy)), Let(Var("v",FTy 7), EX(Dest @@ -7316,9 +7354,7 @@ val dfn'TLBWI_def = Def ("EntryHi",CTy"EntryHi", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state")))),LN 6,LN 0,FTy 7), Apply (Call @@ -7343,8 +7379,7 @@ val dfn'TLBWI_def = Def ("Index",CTy"Index", Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))), Apply (Call @@ -7371,9 +7406,7 @@ val dfn'TLBWR_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))), Mop(Not, Mop(Fst, @@ -7390,8 +7423,7 @@ val dfn'TLBWR_def = Def ("Config6",CTy"ConfigRegister6", Mop(Fst, Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), - qVar"state")))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"state")))), Let(Var("v",FTy 7), EX(Dest ("VPN2",FTy 27, @@ -7399,9 +7431,7 @@ val dfn'TLBWR_def = Def ("EntryHi",CTy"EntryHi", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state")))),LN 6,LN 0,FTy 7), Let(Var("v0",CTy"TLBEntry"), Mop(Fst, @@ -7438,8 +7468,7 @@ val dfn'TLBWR_def = Def (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", - qTy))), + PTy(CTy"CP0",qTy))), qVar"s")))))]),qVar"s"), TP[LU,qVar"s"])))))], Let(Var("v",F8), @@ -7449,7 +7478,7 @@ val dfn'TLBWR_def = Def ("Random",CTy"Random", Mop(Fst, Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state")))), Apply (Call @@ -7516,8 +7545,8 @@ val op3ro_def = Def ("op3ro", TP[sVar"s",Var("r1",FTy 5),Var("r2",FTy 5),Var("r3",FTy 5), Var("n",BTy"N")], - CC[Call("op2r",sTy,TP[sVar"s",Var("r1",FTy 5),Var("r2",FTy 5)]), - Call("i",sTy,Var("n",BTy"N")),LS"(",Call("r",sTy,Var("r3",FTy 5)), + CC[Call("op2r",sTy,TP[sVar"s",Var("r1",FTy 5),Var("r3",FTy 5)]), + Call("i",sTy,Var("n",BTy"N")),LS"(",Call("r",sTy,Var("r2",FTy 5)), LS")"]) ; val op2roi_def = Def @@ -7769,9 +7798,7 @@ val CPR_def = Def ("Index",CTy"Index", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))),qVar"state"]), (TP[LN 0,LW(1,5),LW(0,3)], TP[Mop(Cast F64, @@ -7781,9 +7808,7 @@ val CPR_def = Def ("Random",CTy"Random", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))),qVar"state"]), (TP[LN 0,LW(2,5),LW(0,3)], TP[Call @@ -7792,8 +7817,7 @@ val CPR_def = Def ("EntryLo0",CTy"EntryLo", Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state")))),qVar"state"]), (TP[LN 0,LW(3,5),LW(0,3)], TP[Call @@ -7802,8 +7826,7 @@ val CPR_def = Def ("EntryLo1",CTy"EntryLo", Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state")))),qVar"state"]), (TP[LN 0,LW(4,5),LW(0,3)], TP[Call @@ -7812,15 +7835,14 @@ val CPR_def = Def ("Context",CTy"Context", Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state")))),qVar"state"]), (TP[LN 0,LW(4,5),LW(2,3)], TP[Dest ("UsrLocal",F64, Mop(Fst, Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))),qVar"state"]), (TP[LN 0,LW(5,5),LW(0,3)], TP[Mop(Cast F64, @@ -7830,9 +7852,7 @@ val CPR_def = Def ("PageMask",CTy"PageMask", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))),qVar"state"]), (TP[LN 0,LW(6,5),LW(0,3)], TP[Mop(Cast F64, @@ -7842,9 +7862,7 @@ val CPR_def = Def ("Wired",CTy"Wired", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))),qVar"state"]), (TP[LN 0,LW(7,5),LW(0,3)], TP[Mop(Cast F64, @@ -7854,16 +7872,14 @@ val CPR_def = Def ("HWREna",CTy"HWREna", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))),qVar"state"]), (TP[LN 0,LW(8,5),LW(0,3)], TP[Dest ("BadVAddr",F64, Mop(Fst, Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))),qVar"state"]), (TP[LN 0,LW(8,5),LW(1,3)], TP[Mop(Cast F64, @@ -7871,8 +7887,7 @@ val CPR_def = Def ("EInstr",F32, Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state")))),qVar"state"]), (TP[LN 0,LW(9,5),LW(0,3)], TP[Mop(Cast F64, @@ -7880,8 +7895,7 @@ val CPR_def = Def ("Count",F32, Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state")))),qVar"state"]), (TP[LN 0,LW(10,5),LW(0,3)], TP[Call @@ -7890,8 +7904,7 @@ val CPR_def = Def ("EntryHi",CTy"EntryHi", Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state")))),qVar"state"]), (TP[LN 0,LW(11,5),LW(0,3)], TP[Mop(Cast F64, @@ -7899,8 +7912,7 @@ val CPR_def = Def ("Compare",F32, Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state")))),qVar"state"]), (TP[LN 0,LW(12,5),LW(0,3)], TP[Mop(Cast F64, @@ -7910,9 +7922,7 @@ val CPR_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))),qVar"state"]), (TP[LN 0,LW(13,5),LW(0,3)], TP[Mop(Cast F64, @@ -7922,16 +7932,14 @@ val CPR_def = Def ("Cause",CTy"CauseRegister", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))),qVar"state"]), (TP[LN 0,LW(14,5),LW(0,3)], TP[Dest ("EPC",F64, Mop(Fst, Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))),qVar"state"]), (TP[LN 0,LW(15,5),LW(0,3)], TP[Mop(Cast F64, @@ -7939,8 +7947,7 @@ val CPR_def = Def ("PRId",F32, Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state")))),qVar"state"]), (TP[LN 0,LW(15,5),LW(1,3)], TP[Mop(Cast F64, @@ -7962,9 +7969,7 @@ val CPR_def = Def ("Config",CTy"ConfigRegister", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))),qVar"state"]), (TP[LN 0,LW(16,5),LW(1,3)], TP[Mop(Cast F64, @@ -7974,9 +7979,7 @@ val CPR_def = Def ("Config1",CTy"ConfigRegister1", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))),qVar"state"]), (TP[LN 0,LW(16,5),LW(2,3)], TP[Mop(Cast F64, @@ -7986,9 +7989,7 @@ val CPR_def = Def ("Config2",CTy"ConfigRegister2", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))),qVar"state"]), (TP[LN 0,LW(16,5),LW(3,3)], TP[Mop(Cast F64, @@ -7998,9 +7999,7 @@ val CPR_def = Def ("Config3",CTy"ConfigRegister3", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))),qVar"state"]), (TP[LN 0,LW(16,5),LW(4,3)],TP[LW(1,64),qVar"state"]), (TP[LN 0,LW(16,5),LW(5,3)],TP[LW(1,64),qVar"state"]), @@ -8012,9 +8011,7 @@ val CPR_def = Def ("Config6",CTy"ConfigRegister6", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))),qVar"state"]), (TP[LN 0,LW(17,5),LW(0,3)], TP[Mop(Cast F64, @@ -8022,8 +8019,7 @@ val CPR_def = Def ("LLAddr",F64, Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state")))),qVar"state"]), (TP[LN 0,LW(20,5),LW(0,3)], TP[Call @@ -8032,8 +8028,7 @@ val CPR_def = Def ("XContext",CTy"XContext", Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state")))),qVar"state"]), (TP[LN 0,LW(23,5),LW(0,3)], TP[Mop(Cast F64, @@ -8041,8 +8036,7 @@ val CPR_def = Def ("Debug",F32, Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state")))),qVar"state"]), (TP[LN 0,LW(26,5),LW(0,3)], TP[Mop(Cast F64, @@ -8050,15 +8044,14 @@ val CPR_def = Def ("ErrCtl",F32, Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state")))),qVar"state"]), (TP[LN 0,LW(30,5),LW(0,3)], TP[Dest ("ErrorEPC",F64, Mop(Fst, Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))),qVar"state"]), (AVar(PTy(nTy,PTy(FTy 5,FTy 3))),TP[LX F64,qVar"state"])]))) ; @@ -8079,81 +8072,73 @@ val write'CPR_def = Def qVar"state")), CS(TP[nVar"n",Var("reg",FTy 5),Var("sel",FTy 3)], [(TP[LN 0,LW(0,5),LW(0,3)], - Let(Var("v",CTy"CP0__renamed__"), + Let(Var("v",CTy"CP0"), Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), - qVar"s")), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s")), Apply (Call ("write'CP0",ATy(qTy,PTy(uTy,qTy)), Rupd ("Index", - TP[Var("v",CTy"CP0__renamed__"), + TP[Var("v",CTy"CP0"), Rupd ("Index", TP[Dest ("Index",CTy"Index", - Var("v",CTy"CP0__renamed__")), + Var("v",CTy"CP0")), EX(Var("value",F64),LN 7,LN 0,F8)])])), qVar"s"))), (TP[LN 0,LW(2,5),LW(0,3)], - Let(Var("v",CTy"CP0__renamed__"), + Let(Var("v",CTy"CP0"), Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), - qVar"s")), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s")), Apply (Call ("write'CP0",ATy(qTy,PTy(uTy,qTy)), Rupd ("EntryLo0", - TP[Var("v",CTy"CP0__renamed__"), + TP[Var("v",CTy"CP0"), Call ("write'reg'EntryLo",CTy"EntryLo", TP[Dest ("EntryLo0",CTy"EntryLo", - Var("v",CTy"CP0__renamed__")), + Var("v",CTy"CP0")), Var("value",F64)])])),qVar"s"))), (TP[LN 0,LW(3,5),LW(0,3)], - Let(Var("v",CTy"CP0__renamed__"), + Let(Var("v",CTy"CP0"), Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), - qVar"s")), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s")), Apply (Call ("write'CP0",ATy(qTy,PTy(uTy,qTy)), Rupd ("EntryLo1", - TP[Var("v",CTy"CP0__renamed__"), + TP[Var("v",CTy"CP0"), Call ("write'reg'EntryLo",CTy"EntryLo", TP[Dest ("EntryLo1",CTy"EntryLo", - Var("v",CTy"CP0__renamed__")), + Var("v",CTy"CP0")), Var("value",F64)])])),qVar"s"))), (TP[LN 0,LW(4,5),LW(0,3)], - Let(Var("v",CTy"CP0__renamed__"), + Let(Var("v",CTy"CP0"), Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), - qVar"s")), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s")), Apply (Call ("write'CP0",ATy(qTy,PTy(uTy,qTy)), Rupd ("Context", - TP[Var("v",CTy"CP0__renamed__"), + TP[Var("v",CTy"CP0"), Rupd ("PTEBase", TP[Dest ("Context",CTy"Context", - Var("v",CTy"CP0__renamed__")), + Var("v",CTy"CP0")), EX(Var("value",F64),LN 63,LN 23, FTy 41)])])),qVar"s"))), (TP[LN 0,LW(4,5),LW(2,3)], @@ -8164,37 +8149,31 @@ val write'CPR_def = Def ("UsrLocal", TP[Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"s")),Var("value",F64)])),qVar"s")), (TP[LN 0,LW(5,5),LW(0,3)], - Let(Var("v",CTy"CP0__renamed__"), + Let(Var("v",CTy"CP0"), Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), - qVar"s")), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s")), Apply (Call ("write'CP0",ATy(qTy,PTy(uTy,qTy)), Rupd ("PageMask", - TP[Var("v",CTy"CP0__renamed__"), + TP[Var("v",CTy"CP0"), Rupd ("Mask", TP[Dest ("PageMask",CTy"PageMask", - Var("v",CTy"CP0__renamed__")), + Var("v",CTy"CP0")), EX(Var("value",F64),LN 24,LN 13, FTy 12)])])),qVar"s"))), (TP[LN 0,LW(6,5),LW(0,3)], - Let(Var("v",CTy"CP0__renamed__"), + Let(Var("v",CTy"CP0"), Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), - qVar"s")), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s")), Let(qVar"s", Mop(Snd, Apply @@ -8202,46 +8181,40 @@ val write'CPR_def = Def ("write'CP0",ATy(qTy,PTy(uTy,qTy)), Rupd ("Wired", - TP[Var("v",CTy"CP0__renamed__"), + TP[Var("v",CTy"CP0"), Rupd ("Wired", TP[Dest ("Wired",CTy"Wired", - Var("v", - CTy"CP0__renamed__")), + Var("v",CTy"CP0")), EX(Var("value",F64),LN 7, LN 0,F8)])])),qVar"s")), - Let(Var("v",CTy"CP0__renamed__"), + Let(Var("v",CTy"CP0"), Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"s")), Apply (Call ("write'CP0",ATy(qTy,PTy(uTy,qTy)), Rupd ("Random", - TP[Var("v",CTy"CP0__renamed__"), + TP[Var("v",CTy"CP0"), Rupd ("Random", TP[Dest ("Random",CTy"Random", - Var("v", - CTy"CP0__renamed__")), + Var("v",CTy"CP0")), Mop(Cast F8, Bop(Sub, Const ("TLBEntries",nTy), LN 1))])])),qVar"s"))))), (TP[LN 0,LW(7,5),LW(0,3)], - Let(Var("v",CTy"CP0__renamed__"), + Let(Var("v",CTy"CP0"), Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), - qVar"s")), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s")), Let(qVar"s", Mop(Snd, Apply @@ -8249,21 +8222,18 @@ val write'CPR_def = Def ("write'CP0",ATy(qTy,PTy(uTy,qTy)), Rupd ("HWREna", - TP[Var("v",CTy"CP0__renamed__"), + TP[Var("v",CTy"CP0"), Rupd ("CPUNum", TP[Dest ("HWREna",CTy"HWREna", - Var("v", - CTy"CP0__renamed__")), + Var("v",CTy"CP0")), Bop(Bit,Var("value",F64),LN 0)])])), qVar"s")), - Let(Var("v",CTy"CP0__renamed__"), + Let(Var("v",CTy"CP0"), Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"s")), Let(qVar"s", Mop(Snd, @@ -8273,26 +8243,24 @@ val write'CPR_def = Def ATy(qTy,PTy(uTy,qTy)), Rupd ("HWREna", - TP[Var("v",CTy"CP0__renamed__"), + TP[Var("v",CTy"CP0"), Rupd ("CC", TP[Dest ("HWREna", CTy"HWREna", - Var("v", - CTy"CP0__renamed__")), + Var("v",CTy"CP0")), Bop(Bit, Var("value",F64), LN 2)])])), qVar"s")), - Let(Var("v",CTy"CP0__renamed__"), + Let(Var("v",CTy"CP0"), Mop(Fst, Apply (Const ("CP0", - ATy(qTy, - PTy(CTy"CP0__renamed__", - qTy))),qVar"s")), + ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"s")), Let(qVar"s", Mop(Snd, Apply @@ -8301,28 +8269,26 @@ val write'CPR_def = Def ATy(qTy,PTy(uTy,qTy)), Rupd ("HWREna", - TP[Var("v", - CTy"CP0__renamed__"), + TP[Var("v",CTy"CP0"), Rupd ("CCRes", TP[Dest ("HWREna", CTy"HWREna", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), Bop(Bit, Var("value", F64), LN 3)])])), qVar"s")), - Let(Var("v",CTy"CP0__renamed__"), + Let(Var("v",CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", - qTy))), + PTy(CTy"CP0",qTy))), qVar"s")), Apply (Call @@ -8330,15 +8296,14 @@ val write'CPR_def = Def ATy(qTy,PTy(uTy,qTy)), Rupd ("HWREna", - TP[Var("v", - CTy"CP0__renamed__"), + TP[Var("v",CTy"CP0"), Rupd ("UL", TP[Dest ("HWREna", CTy"HWREna", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), Bop(Bit, Var("value", F64), @@ -8352,29 +8317,25 @@ val write'CPR_def = Def ("Count", TP[Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"s")), EX(Var("value",F64),LN 31,LN 0,F32)])),qVar"s")), (TP[LN 0,LW(10,5),LW(0,3)], - Let(Var("v",CTy"CP0__renamed__"), + Let(Var("v",CTy"CP0"), Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), - qVar"s")), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s")), Apply (Call ("write'CP0",ATy(qTy,PTy(uTy,qTy)), Rupd ("EntryHi", - TP[Var("v",CTy"CP0__renamed__"), + TP[Var("v",CTy"CP0"), Call ("write'reg'EntryHi",CTy"EntryHi", TP[Dest ("EntryHi",CTy"EntryHi", - Var("v",CTy"CP0__renamed__")), + Var("v",CTy"CP0")), Var("value",F64)])])),qVar"s"))), (TP[LN 0,LW(11,5),LW(0,3)], Let(qVar"s", @@ -8388,23 +8349,20 @@ val write'CPR_def = Def Apply (Const ("CP0", - ATy(qTy, - PTy(CTy"CP0__renamed__", - qTy))),qVar"s")), + ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"s")), EX(Var("value",F64),LN 31,LN 0,F32)])), qVar"s")), - Let(Var("v",CTy"CP0__renamed__"), + Let(Var("v",CTy"CP0"), Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"s")), Let(qVar"s", Let(Var("x0",CTy"CauseRegister"), Dest ("Cause",CTy"CauseRegister", - Var("v",CTy"CP0__renamed__")), + Var("v",CTy"CP0")), Mop(Snd, Apply (Call @@ -8412,7 +8370,7 @@ val write'CPR_def = Def ATy(qTy,PTy(uTy,qTy)), Rupd ("Cause", - TP[Var("v",CTy"CP0__renamed__"), + TP[Var("v",CTy"CP0"), Rupd ("IP", TP[Var("x0", @@ -8424,68 +8382,61 @@ val write'CPR_def = Def Var("x0", CTy"CauseRegister")))])])), qVar"s"))), - Let(Var("v",CTy"CP0__renamed__"), + Let(Var("v",CTy"CP0"), Mop(Fst, Apply (Const - ("CP0", - ATy(qTy, - PTy(CTy"CP0__renamed__",qTy))), + ("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"s")), Apply (Call ("write'CP0",ATy(qTy,PTy(uTy,qTy)), Rupd ("Cause", - TP[Var("v",CTy"CP0__renamed__"), + TP[Var("v",CTy"CP0"), Rupd ("TI", TP[Dest ("Cause", CTy"CauseRegister", - Var("v", - CTy"CP0__renamed__")), - LF])])),qVar"s")))))), + Var("v",CTy"CP0")),LF])])), + qVar"s")))))), (TP[LN 0,LW(12,5),LW(0,3)], - Let(Var("v",CTy"CP0__renamed__"), + Let(Var("v",CTy"CP0"), Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), - qVar"s")), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s")), Apply (Call ("write'CP0",ATy(qTy,PTy(uTy,qTy)), Rupd ("Status", - TP[Var("v",CTy"CP0__renamed__"), + TP[Var("v",CTy"CP0"), Call ("write'reg'StatusRegister", CTy"StatusRegister", TP[Dest ("Status",CTy"StatusRegister", - Var("v",CTy"CP0__renamed__")), + Var("v",CTy"CP0")), EX(Var("value",F64),LN 31,LN 0,F32)])])), qVar"s"))), (TP[LN 0,LW(13,5),LW(0,3)], - Let(Var("v",CTy"CP0__renamed__"), + Let(Var("v",CTy"CP0"), Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), - qVar"s")), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s")), Apply (Call ("write'CP0",ATy(qTy,PTy(uTy,qTy)), Rupd ("Cause", - TP[Var("v",CTy"CP0__renamed__"), + TP[Var("v",CTy"CP0"), Call ("write'reg'CauseRegister", CTy"CauseRegister", TP[Dest ("Cause",CTy"CauseRegister", - Var("v",CTy"CP0__renamed__")), + Var("v",CTy"CP0")), EX(Var("value",F64),LN 31,LN 0,F32)])])), qVar"s"))), (TP[LN 0,LW(14,5),LW(0,3)], @@ -8496,88 +8447,78 @@ val write'CPR_def = Def ("EPC", TP[Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"s")),Var("value",F64)])),qVar"s")), (TP[LN 0,LW(16,5),LW(0,3)], - Let(Var("v",CTy"CP0__renamed__"), + Let(Var("v",CTy"CP0"), Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), - qVar"s")), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s")), Apply (Call ("write'CP0",ATy(qTy,PTy(uTy,qTy)), Rupd ("Config", - TP[Var("v",CTy"CP0__renamed__"), + TP[Var("v",CTy"CP0"), Rupd ("K0", TP[Dest ("Config",CTy"ConfigRegister", - Var("v",CTy"CP0__renamed__")), + Var("v",CTy"CP0")), EX(Var("value",F64),LN 2,LN 0,FTy 3)])])), qVar"s"))), (TP[LN 0,LW(16,5),LW(2,3)], - Let(Var("v",CTy"CP0__renamed__"), + Let(Var("v",CTy"CP0"), Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), - qVar"s")), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s")), Apply (Call ("write'CP0",ATy(qTy,PTy(uTy,qTy)), Rupd ("Config2", - TP[Var("v",CTy"CP0__renamed__"), + TP[Var("v",CTy"CP0"), Rupd ("SU", TP[Dest ("Config2",CTy"ConfigRegister2", - Var("v",CTy"CP0__renamed__")), + Var("v",CTy"CP0")), EX(Var("value",F64),LN 15,LN 12,F4)])])), qVar"s"))), (TP[LN 0,LW(16,5),LW(6,3)], - Let(Var("v",CTy"CP0__renamed__"), + Let(Var("v",CTy"CP0"), Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), - qVar"s")), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s")), Apply (Call ("write'CP0",ATy(qTy,PTy(uTy,qTy)), Rupd ("Config6", - TP[Var("v",CTy"CP0__renamed__"), + TP[Var("v",CTy"CP0"), Rupd ("LTLB", TP[Dest ("Config6",CTy"ConfigRegister6", - Var("v",CTy"CP0__renamed__")), + Var("v",CTy"CP0")), Bop(Bit,Var("value",F64),LN 2)])])), qVar"s"))), (TP[LN 0,LW(20,5),LW(0,3)], - Let(Var("v",CTy"CP0__renamed__"), + Let(Var("v",CTy"CP0"), Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), - qVar"s")), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s")), Apply (Call ("write'CP0",ATy(qTy,PTy(uTy,qTy)), Rupd ("XContext", - TP[Var("v",CTy"CP0__renamed__"), + TP[Var("v",CTy"CP0"), Rupd ("PTEBase", TP[Dest ("XContext",CTy"XContext", - Var("v",CTy"CP0__renamed__")), + Var("v",CTy"CP0")), EX(Var("value",F64),LN 63,LN 33, FTy 31)])])),qVar"s"))), (TP[LN 0,LW(23,5),LW(0,3)], @@ -8595,8 +8536,8 @@ val write'CPR_def = Def (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", - qTy))),qVar"s")), + PTy(CTy"CP0",qTy))), + qVar"s")), EX(Var("value",F64),LN 31,LN 0,F32)])), qVar"s")),LT])]), (TP[LN 0,LW(26,5),LW(0,3)], @@ -8612,9 +8553,8 @@ val write'CPR_def = Def Apply (Const ("CP0", - ATy(qTy, - PTy(CTy"CP0__renamed__", - qTy))),qVar"s")), + ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"s")), EX(Var("value",F64),LN 31,LN 0,F32)])), qVar"s")))), (TP[LN 0,LW(30,5),LW(0,3)], @@ -8625,9 +8565,7 @@ val write'CPR_def = Def ("ErrorEPC", TP[Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"s")),Var("value",F64)])),qVar"s")), (AVar(PTy(nTy,PTy(FTy 5,FTy 3))), Apply @@ -8645,9 +8583,7 @@ val dfn'CACHE_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))), Mop(Not, Mop(Fst, @@ -8685,9 +8621,7 @@ val dfn'RDHWR_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state")))), Mop(Fst, Apply @@ -8700,9 +8634,7 @@ val dfn'RDHWR_def = Def ("HWREna",CTy"HWREna", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state")))), Mop(Cast nTy,Var("rd",FTy 5)))), CS(Var("rd",FTy 5), @@ -8710,8 +8642,7 @@ val dfn'RDHWR_def = Def Apply (Call ("write'GPR",ATy(qTy,PTy(uTy,qTy)), - TP[Mop(Cast F64, - Bop(Sub,Dest("totalCore",nTy,qVar"state"),LN 1)), + TP[Mop(Cast F64,Dest("procID",F8,qVar"state")), Var("rt",FTy 5)]),qVar"state")), (LW(2,5), Apply @@ -8723,9 +8654,7 @@ val dfn'RDHWR_def = Def Mop(Fst, Apply (Const - ("CP0", - ATy(qTy, - PTy(CTy"CP0__renamed__",qTy))), + ("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state")))),Var("rt",FTy 5)]), qVar"state")), (LW(3,5), @@ -8741,11 +8670,16 @@ val dfn'RDHWR_def = Def ("UsrLocal",F64, Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))),Var("rt",FTy 5)]), qVar"state")), + (LW(30,5), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Cast F64, + Bop(Sub,Dest("totalCore",nTy,qVar"state"),LN 1)), + Var("rt",FTy 5)]),qVar"state")), (AVar(FTy 5), Apply (Call @@ -9125,7 +9059,7 @@ val LoadMemoryCap_def = Def F32, Dest ("data", - CTy"JTAG_UART_data__renamed__", + CTy"JTAG_UART_data", Dest ("JTAG_UART", CTy"JTAG_UART", @@ -9145,7 +9079,7 @@ val LoadMemoryCap_def = Def F32, Dest ("control", - CTy"JTAG_UART_control__renamed__", + CTy"JTAG_UART_control", Dest ("JTAG_UART", CTy"JTAG_UART", @@ -9461,32 +9395,32 @@ val LoadMemoryCap_def = Def PTy(FTy 40, qTy)))))))))], Let(TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Var("s", PTy(bTy, PTy(F64, PTy(FTy 40, qTy))))], Let(TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Var("s3", PTy(F64, PTy(FTy 40, qTy)))], Let(TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Var("s3", PTy(FTy 40, qTy))], Let(TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), qVar"s3"], TP[Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), Mop(Snd, Mop(Snd, @@ -9505,7 +9439,7 @@ val LoadMemoryCap_def = Def PTy(FTy 40, qTy)))))))], TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Mop(Snd, Mop(Snd, @@ -9516,7 +9450,7 @@ val LoadMemoryCap_def = Def qTy))))))), qVar"s3"]), TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Mop(Snd, Var("s", @@ -9528,7 +9462,7 @@ val LoadMemoryCap_def = Def PTy(FTy 40, qTy))]), TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Var("s", PTy(bTy, @@ -9570,7 +9504,7 @@ val LoadMemoryCap_def = Def Rupd ("LLAddr", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Cast F64, Mop(Fst, @@ -11099,32 +11033,32 @@ val StoreMemoryCap_def = Def (Mop(Some, LT), Let(TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Var("s", PTy(bTy, PTy(bTy, PTy(FTy 40, qTy))))], Let(TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Var("s3", PTy(bTy, PTy(FTy 40, qTy)))], Let(TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Var("s3", PTy(FTy 40, qTy))], Let(TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), qVar"s3"], TP[Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), Mop(Snd, Mop(Snd, @@ -11143,7 +11077,7 @@ val StoreMemoryCap_def = Def PTy(FTy 40, qTy)))))))], TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Mop(Snd, Mop(Snd, @@ -11154,7 +11088,7 @@ val StoreMemoryCap_def = Def qTy))))))), qVar"s3"]), TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Mop(Snd, Var("s", @@ -11166,7 +11100,7 @@ val StoreMemoryCap_def = Def PTy(FTy 40, qTy))]), TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Var("s", PTy(bTy, @@ -11187,7 +11121,7 @@ val StoreMemoryCap_def = Def ("LLAddr", F64, Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LN 39, LN @@ -11377,7 +11311,7 @@ val StoreMemoryCap_def = Def (Dest ("c_CP0", ATy(F8, - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Snd, Mop(Snd, Mop(Snd, @@ -11982,7 +11916,7 @@ val StoreCap_def = Def (Dest ("c_CP0", ATy(F8, - CTy"CP0__renamed__"), + CTy"CP0"), qVar"state"), Mop(Cast F8, @@ -12031,11 +11965,8 @@ val StoreCap_def = Def ; val Fetch_def = Def ("Fetch",qVar"state", - Let(Var("v",CTy"CP0__renamed__"), - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), - qVar"state")), + Let(Var("v",CTy"CP0"), + Mop(Fst,Apply(Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"state")), Let(qVar"s", Mop(Snd, Apply @@ -12043,12 +11974,11 @@ val Fetch_def = Def ("write'CP0",ATy(qTy,PTy(uTy,qTy)), Rupd ("Random", - TP[Var("v",CTy"CP0__renamed__"), + TP[Var("v",CTy"CP0"), Rupd ("Random", TP[Dest - ("Random",CTy"Random", - Var("v",CTy"CP0__renamed__")), + ("Random",CTy"Random",Var("v",CTy"CP0")), ITE(EQ(Dest ("Random",F8, Dest @@ -12058,7 +11988,7 @@ val Fetch_def = Def (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"state")))), Dest @@ -12070,7 +12000,7 @@ val Fetch_def = Def (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"state"))))), Mop(Cast F8, @@ -12086,7 +12016,7 @@ val Fetch_def = Def (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"state")))), LW(1,8)))])])),qVar"state")), @@ -12095,30 +12025,24 @@ val Fetch_def = Def ("Compare",F32, Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"s"))), Dest ("Count",F32, Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"s")))), - Let(Var("v",CTy"CP0__renamed__"), + Let(Var("v",CTy"CP0"), Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"s")), Let(qVar"s", Let(Var("x0",CTy"CauseRegister"), Dest ("Cause",CTy"CauseRegister", - Var("v",CTy"CP0__renamed__")), + Var("v",CTy"CP0")), Mop(Snd, Apply (Call @@ -12126,7 +12050,7 @@ val Fetch_def = Def ATy(qTy,PTy(uTy,qTy)), Rupd ("Cause", - TP[Var("v",CTy"CP0__renamed__"), + TP[Var("v",CTy"CP0"), Rupd ("IP", TP[Var("x0", @@ -12138,13 +12062,11 @@ val Fetch_def = Def Var("x0", CTy"CauseRegister")))])])), qVar"s"))), - Let(Var("v",CTy"CP0__renamed__"), + Let(Var("v",CTy"CP0"), Mop(Fst, Apply (Const - ("CP0", - ATy(qTy, - PTy(CTy"CP0__renamed__",qTy))), + ("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"s")), Mop(Snd, Apply @@ -12153,14 +12075,13 @@ val Fetch_def = Def ATy(qTy,PTy(uTy,qTy)), Rupd ("Cause", - TP[Var("v",CTy"CP0__renamed__"), + TP[Var("v",CTy"CP0"), Rupd ("TI", TP[Dest ("Cause", CTy"CauseRegister", - Var("v", - CTy"CP0__renamed__")), + Var("v",CTy"CP0")), LT])])),qVar"s"))))), qVar"s"), Let(qVar"s", @@ -12173,8 +12094,7 @@ val Fetch_def = Def Apply (Const ("CP0", - ATy(qTy, - PTy(CTy"CP0__renamed__",qTy))), + ATy(qTy,PTy(CTy"CP0",qTy))), qVar"s")))), Mop(Not, Bop(Or, @@ -12187,8 +12107,8 @@ val Fetch_def = Def (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", - qTy))),qVar"s")))), + PTy(CTy"CP0",qTy))), + qVar"s")))), Dest ("ERL",bTy, Dest @@ -12198,8 +12118,8 @@ val Fetch_def = Def (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", - qTy))),qVar"s"))))))), + PTy(CTy"CP0",qTy))), + qVar"s"))))))), ITE(Mop(Not, EQ(Bop(BAnd, EX(Dest @@ -12212,7 +12132,7 @@ val Fetch_def = Def (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")))),LN 7, LN 2,FTy 6), @@ -12225,7 +12145,7 @@ val Fetch_def = Def (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")))),LN 7, LN 2,FTy 6)),LW(0,6))), @@ -12432,7 +12352,7 @@ val Fetch_def = Def (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Bop(Add, @@ -12536,9 +12456,7 @@ val dfn'CGetBase_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))), Apply (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), @@ -12575,9 +12493,7 @@ val dfn'CGetOffset_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))), Apply (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), @@ -12614,9 +12530,7 @@ val dfn'CGetLen_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))), Apply (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), @@ -12653,9 +12567,7 @@ val dfn'CGetTag_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))), Apply (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), @@ -12715,9 +12627,7 @@ val dfn'CGetSealed_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))), Apply (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), @@ -12777,9 +12687,7 @@ val dfn'CGetPerm_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))), Apply (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), @@ -12836,9 +12744,7 @@ val dfn'CGetType_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))), Apply (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), @@ -12895,9 +12801,7 @@ val dfn'CGetPCC_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))), Apply (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), @@ -12911,33 +12815,57 @@ val dfn'CGetPCC_def = Def (Call ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), Var("cd",FTy 5)),qVar"state"))], - Let(qVar"s", - Mop(Snd, + Let(Var("v",CTy"Capability"), + Mop(Fst, Apply - (Call - ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), - TP[Mop(Fst, - Apply - (Const - ("PCC", - ATy(qTy,PTy(CTy"Capability",qTy))), - qVar"state")),Var("cd",FTy 5)]), + (Const("PCC",ATy(qTy,PTy(CTy"Capability",qTy))), qVar"state")), - Apply - (Call - ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), - TP[Rupd - ("offset", - TP[Mop(Fst, - Apply - (Call - ("CAPR", - ATy(qTy,PTy(CTy"Capability",qTy)), - Var("cd",FTy 5)),qVar"s")), - Mop(Fst, - Apply - (Const("PC",ATy(qTy,PTy(F64,qTy))), - qVar"s"))]),Var("cd",FTy 5)]),qVar"s"))))) + TP[LU, + Let(Var("s",PTy(CTy"Capability",qTy)), + TP[Var("v",CTy"Capability"),qVar"state"], + Let(Var("s",PTy(CTy"Capability",qTy)), + Let(TP[Var("v",CTy"Capability"), + Var("s",PTy(CTy"Capability",qTy))], + Let(TP[Var("v",PTy(CTy"Capability",F64)), + Var("s",PTy(CTy"Capability",qTy))], + Let(TP[Var("v0",F64), + Var("s",PTy(CTy"Capability",qTy))], + Let(TP[Var("v",F64),qVar"s3"], + TP[Mop(Fst, + Apply + (Const + ("PC", + ATy(qTy,PTy(F64,qTy))), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy))))), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy)))], + TP[Var("v",F64), + Mop(Fst, + Var("s", + PTy(CTy"Capability", + qTy))),qVar"s3"]), + TP[TP[Var("v",CTy"Capability"), + Var("v0",F64)], + Var("s",PTy(CTy"Capability",qTy))]), + TP[Rupd + ("offset", + Var("v",PTy(CTy"Capability",F64))), + Var("s",PTy(CTy"Capability",qTy))]), + TP[Var("v",CTy"Capability"), + Mop(Snd,Var("s",PTy(CTy"Capability",qTy)))]), + Mop(Snd, + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Fst, + Var("s",PTy(CTy"Capability",qTy))), + Var("cd",FTy 5)]), + Mop(Snd,Var("s",PTy(CTy"Capability",qTy)))))))])))) ; val dfn'CGetCause_def = Def ("dfn'CGetCause",Var("rd",FTy 5), @@ -12950,9 +12878,7 @@ val dfn'CGetCause_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))), Apply (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), @@ -13036,9 +12962,7 @@ val dfn'CSetCause_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))), Apply (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), @@ -13107,9 +13031,7 @@ val dfn'CIncBase_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))), Apply (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), @@ -13188,193 +13110,197 @@ val dfn'CIncBase_def = Def ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), TP[LC("capExcLength",CTy"CapException"),Var("cb",FTy 5)]), qVar"state"))], - Let(qVar"s", - Mop(Snd, + Let(Var("v",CTy"Capability"), + Mop(Fst, Apply (Call - ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), - TP[Mop(Fst, - Apply - (Call - ("CAPR", - ATy(qTy,PTy(CTy"Capability",qTy)), - Var("cb",FTy 5)),qVar"state")), - Var("cd",FTy 5)]),qVar"state")), - Let(qVar"s", - Mop(Snd, - Apply - (Call - ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), - TP[Rupd - ("base", - TP[Mop(Fst, - Apply - (Call - ("CAPR", - ATy(qTy, - PTy(CTy"Capability",qTy)), - Var("cd",FTy 5)),qVar"s")), - Bop(Add, - Dest - ("base",F64, - Mop(Fst, - Apply - (Call - ("CAPR", - ATy(qTy, + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")), + TP[LU, + Let(Var("s",PTy(CTy"Capability",qTy)), + TP[Var("v",CTy"Capability"),qVar"state"], + Let(Var("s",PTy(CTy"Capability",qTy)), + Let(TP[Var("v",CTy"Capability"), + Var("s",PTy(CTy"Capability",qTy))], + Let(TP[Var("v",PTy(CTy"Capability",F64)), + Var("s",PTy(CTy"Capability",qTy))], + Let(TP[Var("v0",CTy"Capability"), + Var("s",PTy(CTy"Capability",qTy))], + CS(TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("cb",FTy 5)), + Mop(Snd, + Var("s", PTy(CTy"Capability", - qTy)), - Var("cb",FTy 5)), - qVar"s"))), - Mop(Fst, - Apply - (Call - ("GPR", - ATy(qTy,PTy(F64,qTy)), - Var("rt",FTy 5)), - qVar"s")))]), - Var("cd",FTy 5)]),qVar"s")), - Apply - (Call - ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), - TP[Rupd - ("length", - TP[Mop(Fst, - Apply - (Call - ("CAPR", - ATy(qTy, - PTy(CTy"Capability",qTy)), - Var("cd",FTy 5)),qVar"s")), - Bop(Sub, - Dest - ("length",F64, - Mop(Fst, - Apply - (Call - ("CAPR", - ATy(qTy, - PTy(CTy"Capability", - qTy)), - Var("cb",FTy 5)),qVar"s"))), - Mop(Fst, - Apply - (Call - ("GPR", - ATy(qTy,PTy(F64,qTy)), - Var("rt",FTy 5)),qVar"s")))]), - Var("cd",FTy 5)]),qVar"s")))))) -; -val dfn'CSetLen_def = Def - ("dfn'CSetLen",TP[Var("cd",FTy 5),Var("cb",FTy 5),Var("rt",FTy 5)], - Close - (qVar"state", - ITB([(Mop(Not, - Dest - ("CU2",bTy, - Dest - ("Status",CTy"StatusRegister", - Mop(Fst, - Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), - qVar"state"))))), - Apply - (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), - qVar"state")), - (Mop(Fst, - Apply - (Call - ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), - Var("cd",FTy 5)),qVar"state")), - Apply - (Call - ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), - Var("cd",FTy 5)),qVar"state")), - (Mop(Fst, - Apply - (Call - ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), - Var("cb",FTy 5)),qVar"state")), - Apply - (Call - ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), - Var("cb",FTy 5)),qVar"state")), - (Mop(Not, - Dest - ("tag",bTy, - Mop(Fst, - Apply - (Call - ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), - Var("cb",FTy 5)),qVar"state")))), - Apply - (Call - ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), - TP[LC("capExcTag",CTy"CapException"),Var("cb",FTy 5)]), - qVar"state")), - (Dest - ("sealed",bTy, - Mop(Fst, - Apply - (Call - ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), - Var("cb",FTy 5)),qVar"state"))), - Apply - (Call - ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), - TP[LC("capExcSeal",CTy"CapException"),Var("cb",FTy 5)]), - qVar"state")), - (Bop(Ugt, - Mop(Fst, - Apply - (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), - qVar"state")), - Dest - ("length",F64, - Mop(Fst, - Apply - (Call - ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), - Var("cb",FTy 5)),qVar"state")))), - Apply - (Call - ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), - TP[LC("capExcLength",CTy"CapException"),Var("cb",FTy 5)]), - qVar"state"))], - Let(qVar"s", - Mop(Snd, - Apply - (Call - ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), - TP[Mop(Fst, - Apply - (Call - ("CAPR", - ATy(qTy,PTy(CTy"Capability",qTy)), - Var("cb",FTy 5)),qVar"state")), - Var("cd",FTy 5)]),qVar"state")), - Apply - (Call - ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), - TP[Rupd - ("length", - TP[Mop(Fst, - Apply - (Call - ("CAPR", - ATy(qTy,PTy(CTy"Capability",qTy)), - Var("cd",FTy 5)),qVar"s")), - Mop(Fst, + qTy))))), + Mop(Snd, + Var("s", + PTy(CTy"Capability",qTy)))], + [(TP[Var("v",CTy"Capability"), + qVar"s3"], + TP[Var("v",CTy"Capability"), + Mop(Fst, + Var("s", + PTy(CTy"Capability", + qTy))),qVar"s3"])]), + Let(TP[Var("v0",F64), + Var("s", + PTy(CTy"Capability",qTy))], + Let(TP[Var("v1",F64), + Var("s", + PTy(CTy"Capability", + qTy))], + Let(TP[Var("v",F64),qVar"s3"], + TP[Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy, + PTy(F64, + qTy)), + Var("rt", + FTy 5)), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy))))), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy)))], + TP[Var("v",F64), + Mop(Fst, + Var("s", + PTy(CTy"Capability", + qTy))), + qVar"s3"]), + TP[Bop(Add, + Dest + ("base",F64, + Var("v0", + CTy"Capability")), + Var("v1",F64)), + Var("s", + PTy(CTy"Capability", + qTy))]), + TP[TP[Var("v",CTy"Capability"), + Var("v0",F64)], + Var("s", + PTy(CTy"Capability",qTy))])), + TP[Rupd + ("base", + Var("v",PTy(CTy"Capability",F64))), + Var("s",PTy(CTy"Capability",qTy))]), + TP[Var("v",CTy"Capability"), + Mop(Snd,Var("s",PTy(CTy"Capability",qTy)))]), + Let(Var("s",PTy(CTy"Capability",qTy)), + Let(TP[Var("v",CTy"Capability"), + Var("s",PTy(CTy"Capability",qTy))], + Let(TP[Var("v",PTy(CTy"Capability",F64)), + Var("s",PTy(CTy"Capability",qTy))], + Let(TP[Var("v0",CTy"Capability"), + Var("s0", + PTy(CTy"Capability",qTy))], + CS(TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("cb",FTy 5)), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy))))), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy)))], + [(TP[Var("v",CTy"Capability"), + qVar"s3"], + TP[Var("v",CTy"Capability"), + Mop(Fst, + Var("s", + PTy(CTy"Capability", + qTy))), + qVar"s3"])]), + Let(TP[Var("v0",F64), + Var("s0", + PTy(CTy"Capability", + qTy))], + Let(TP[Var("v1",F64), + Var("s", + PTy(CTy"Capability", + qTy))], + Let(TP[Var("v",F64), + qVar"s3"], + TP[Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy, + PTy(F64, + qTy)), + Var("rt", + FTy 5)), + Mop(Snd, + Var("s0", + PTy(CTy"Capability", + qTy))))), + Mop(Snd, + Var("s0", + PTy(CTy"Capability", + qTy)))], + TP[Var("v",F64), + Mop(Fst, + Var("s0", + PTy(CTy"Capability", + qTy))), + qVar"s3"]), + TP[Bop(Sub, + Dest + ("length",F64, + Var("v0", + CTy"Capability")), + Var("v1",F64)), + Var("s", + PTy(CTy"Capability", + qTy))]), + TP[TP[Mop(Fst, + Var("s", + PTy(CTy"Capability", + qTy))), + Var("v0",F64)], + Var("s0", + PTy(CTy"Capability", + qTy))])), + TP[Rupd + ("length", + Var("v", + PTy(CTy"Capability",F64))), + Var("s",PTy(CTy"Capability",qTy))]), + TP[Var("v",CTy"Capability"), + Mop(Snd, + Var("s",PTy(CTy"Capability",qTy)))]), + Mop(Snd, Apply (Call - ("GPR",ATy(qTy,PTy(F64,qTy)), - Var("rt",FTy 5)),qVar"s"))]), - Var("cd",FTy 5)]),qVar"s"))))) + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Fst, + Var("s", + PTy(CTy"Capability",qTy))), + Var("cd",FTy 5)]), + Mop(Snd, + Var("s",PTy(CTy"Capability",qTy))))))))])))) ; -val dfn'CClearTag_def = Def - ("dfn'CClearTag",TP[Var("cd",FTy 5),Var("cb",FTy 5)], +val dfn'CIncOffset_def = Def + ("dfn'CIncOffset",TP[Var("cd",FTy 5),Var("cb",FTy 5),Var("rt",FTy 5)], Close (qVar"state", ITB([(Mop(Not, @@ -13384,9 +13310,7 @@ val dfn'CClearTag_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))), Apply (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), @@ -13408,31 +13332,306 @@ val dfn'CClearTag_def = Def Apply (Call ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), - Var("cb",FTy 5)),qVar"state"))], - Let(qVar"s", - Mop(Snd, + Var("cb",FTy 5)),qVar"state")), + (Bop(And, + Dest + ("tag",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state"))), + Dest + ("sealed",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcSeal",CTy"CapException"),Var("cb",FTy 5)]), + qVar"state"))], + Let(Var("v",CTy"Capability"), + Mop(Fst, Apply (Call - ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), - TP[Mop(Fst, - Apply - (Call - ("CAPR", - ATy(qTy,PTy(CTy"Capability",qTy)), - Var("cb",FTy 5)),qVar"state")), - Var("cd",FTy 5)]),qVar"state")), - Apply - (Call - ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), - TP[Rupd - ("tag", - TP[Mop(Fst, - Apply - (Call - ("CAPR", - ATy(qTy,PTy(CTy"Capability",qTy)), - Var("cd",FTy 5)),qVar"s")),LF]), - Var("cd",FTy 5)]),qVar"s"))))) + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")), + TP[LU, + Let(Var("s",PTy(CTy"Capability",qTy)), + TP[Var("v",CTy"Capability"),qVar"state"], + Let(Var("s",PTy(CTy"Capability",qTy)), + Let(TP[Var("v",CTy"Capability"), + Var("s",PTy(CTy"Capability",qTy))], + Let(TP[Var("v",PTy(CTy"Capability",F64)), + Var("s",PTy(CTy"Capability",qTy))], + Let(TP[Var("v0",CTy"Capability"), + Var("s",PTy(CTy"Capability",qTy))], + CS(TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("cb",FTy 5)), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy))))), + Mop(Snd, + Var("s", + PTy(CTy"Capability",qTy)))], + [(TP[Var("v",CTy"Capability"), + qVar"s3"], + TP[Var("v",CTy"Capability"), + Mop(Fst, + Var("s", + PTy(CTy"Capability", + qTy))),qVar"s3"])]), + Let(TP[Var("v0",F64), + Var("s", + PTy(CTy"Capability",qTy))], + Let(TP[Var("v1",F64), + Var("s", + PTy(CTy"Capability", + qTy))], + Let(TP[Var("v",F64),qVar"s3"], + TP[Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy, + PTy(F64, + qTy)), + Var("rt", + FTy 5)), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy))))), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy)))], + TP[Var("v",F64), + Mop(Fst, + Var("s", + PTy(CTy"Capability", + qTy))), + qVar"s3"]), + TP[Bop(Add, + Dest + ("offset",F64, + Var("v0", + CTy"Capability")), + Var("v1",F64)), + Var("s", + PTy(CTy"Capability", + qTy))]), + TP[TP[Var("v",CTy"Capability"), + Var("v0",F64)], + Var("s", + PTy(CTy"Capability",qTy))])), + TP[Rupd + ("offset", + Var("v",PTy(CTy"Capability",F64))), + Var("s",PTy(CTy"Capability",qTy))]), + TP[Var("v",CTy"Capability"), + Mop(Snd,Var("s",PTy(CTy"Capability",qTy)))]), + Mop(Snd, + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Fst, + Var("s",PTy(CTy"Capability",qTy))), + Var("cd",FTy 5)]), + Mop(Snd,Var("s",PTy(CTy"Capability",qTy)))))))])))) +; +val dfn'CSetLen_def = Def + ("dfn'CSetLen",TP[Var("cd",FTy 5),Var("cb",FTy 5),Var("rt",FTy 5)], + Close + (qVar"state", + ITB([(Mop(Not, + Dest + ("CU2",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state"))))), + Apply + (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), + qVar"state")), + (Mop(Fst, + Apply + (Call + ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), + Var("cd",FTy 5)),qVar"state")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cd",FTy 5)),qVar"state")), + (Mop(Fst, + Apply + (Call + ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), + Var("cb",FTy 5)),qVar"state")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cb",FTy 5)),qVar"state")), + (Mop(Not, + Dest + ("tag",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcTag",CTy"CapException"),Var("cb",FTy 5)]), + qVar"state")), + (Dest + ("sealed",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state"))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcSeal",CTy"CapException"),Var("cb",FTy 5)]), + qVar"state")), + (Bop(Ugt, + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state")), + Dest + ("length",F64, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")))), + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcLength",CTy"CapException"),Var("cb",FTy 5)]), + qVar"state"))], + Let(Var("v",CTy"Capability"), + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")), + TP[LU, + Let(Var("s",PTy(CTy"Capability",qTy)), + TP[Var("v",CTy"Capability"),qVar"state"], + Let(Var("s",PTy(CTy"Capability",qTy)), + Let(TP[Var("v",CTy"Capability"), + Var("s",PTy(CTy"Capability",qTy))], + Let(TP[Var("v",PTy(CTy"Capability",F64)), + Var("s",PTy(CTy"Capability",qTy))], + Let(TP[Var("v0",F64), + Var("s",PTy(CTy"Capability",qTy))], + Let(TP[Var("v",F64),qVar"s3"], + TP[Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy))))), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy)))], + TP[Var("v",F64), + Mop(Fst, + Var("s", + PTy(CTy"Capability", + qTy))),qVar"s3"]), + TP[TP[Var("v",CTy"Capability"), + Var("v0",F64)], + Var("s",PTy(CTy"Capability",qTy))]), + TP[Rupd + ("length", + Var("v",PTy(CTy"Capability",F64))), + Var("s",PTy(CTy"Capability",qTy))]), + TP[Var("v",CTy"Capability"), + Mop(Snd,Var("s",PTy(CTy"Capability",qTy)))]), + Mop(Snd, + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Fst, + Var("s",PTy(CTy"Capability",qTy))), + Var("cd",FTy 5)]), + Mop(Snd,Var("s",PTy(CTy"Capability",qTy)))))))])))) +; +val dfn'CClearTag_def = Def + ("dfn'CClearTag",TP[Var("cd",FTy 5),Var("cb",FTy 5)], + Close + (qVar"state", + ITB([(Mop(Not, + Dest + ("CU2",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state"))))), + Apply + (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), + qVar"state")), + (Mop(Fst, + Apply + (Call + ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), + Var("cd",FTy 5)),qVar"state")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cd",FTy 5)),qVar"state")), + (Mop(Fst, + Apply + (Call + ("register_inaccessible",ATy(qTy,PTy(bTy,qTy)), + Var("cb",FTy 5)),qVar"state")), + Apply + (Call + ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), + Var("cb",FTy 5)),qVar"state"))], + TP[LU, + Let(Var("s",PTy(CTy"Capability",qTy)), + TP[Rupd + ("tag", + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")),LF]), + qVar"state"], + Mop(Snd, + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Fst,Var("s",PTy(CTy"Capability",qTy))), + Var("cd",FTy 5)]), + Mop(Snd,Var("s",PTy(CTy"Capability",qTy))))))]))) ; val dfn'CAndPerm_def = Def ("dfn'CAndPerm",TP[Var("cd",FTy 5),Var("cb",FTy 5),Var("rt",FTy 5)], @@ -13445,9 +13644,7 @@ val dfn'CAndPerm_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))), Apply (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), @@ -13495,46 +13692,103 @@ val dfn'CAndPerm_def = Def ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), TP[LC("capExcSeal",CTy"CapException"),Var("cb",FTy 5)]), qVar"state"))], - Let(qVar"s", - Mop(Snd, + Let(Var("v",CTy"Capability"), + Mop(Fst, Apply (Call - ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), - TP[Mop(Fst, - Apply - (Call - ("CAPR", - ATy(qTy,PTy(CTy"Capability",qTy)), - Var("cb",FTy 5)),qVar"state")), - Var("cd",FTy 5)]),qVar"state")), - Apply - (Call - ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), - TP[Rupd - ("perms", - TP[Mop(Fst, - Apply - (Call - ("CAPR", - ATy(qTy,PTy(CTy"Capability",qTy)), - Var("cd",FTy 5)),qVar"s")), - Bop(BAnd, - Dest - ("perms",FTy 31, - Mop(Fst, - Apply - (Call - ("CAPR", - ATy(qTy, - PTy(CTy"Capability",qTy)), - Var("cd",FTy 5)),qVar"s"))), - EX(Mop(Fst, - Apply - (Call - ("GPR",ATy(qTy,PTy(F64,qTy)), - Var("rt",FTy 5)),qVar"s")), - LN 30,LN 0,FTy 31))]),Var("cd",FTy 5)]), - qVar"s"))))) + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")), + TP[LU, + Let(Var("s",PTy(CTy"Capability",qTy)), + TP[Var("v",CTy"Capability"),qVar"state"], + Let(Var("s",PTy(CTy"Capability",qTy)), + Let(TP[Var("v",CTy"Capability"), + Var("s",PTy(CTy"Capability",qTy))], + Let(TP[Var("v",PTy(CTy"Capability",FTy 31)), + Var("s",PTy(CTy"Capability",qTy))], + Let(TP[Var("v0",CTy"Capability"), + Var("s",PTy(CTy"Capability",qTy))], + CS(TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("cb",FTy 5)), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy))))), + Mop(Snd, + Var("s", + PTy(CTy"Capability",qTy)))], + [(TP[Var("v",CTy"Capability"), + qVar"s3"], + TP[Var("v",CTy"Capability"), + Mop(Fst, + Var("s", + PTy(CTy"Capability", + qTy))),qVar"s3"])]), + Let(TP[Var("v0",FTy 31), + Var("s", + PTy(CTy"Capability",qTy))], + Let(TP[Var("v1",F64), + Var("s", + PTy(CTy"Capability", + qTy))], + Let(TP[Var("v",F64),qVar"s3"], + TP[Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy, + PTy(F64, + qTy)), + Var("rt", + FTy 5)), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy))))), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy)))], + TP[Var("v",F64), + Mop(Fst, + Var("s", + PTy(CTy"Capability", + qTy))), + qVar"s3"]), + TP[Bop(BAnd, + Dest + ("perms",FTy 31, + Var("v0", + CTy"Capability")), + EX(Var("v1",F64), + LN 30,LN 0,FTy 31)), + Var("s", + PTy(CTy"Capability", + qTy))]), + TP[TP[Var("v",CTy"Capability"), + Var("v0",FTy 31)], + Var("s", + PTy(CTy"Capability",qTy))])), + TP[Rupd + ("perms", + Var("v",PTy(CTy"Capability",FTy 31))), + Var("s",PTy(CTy"Capability",qTy))]), + TP[Var("v",CTy"Capability"), + Mop(Snd,Var("s",PTy(CTy"Capability",qTy)))]), + Mop(Snd, + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Fst, + Var("s",PTy(CTy"Capability",qTy))), + Var("cd",FTy 5)]), + Mop(Snd,Var("s",PTy(CTy"Capability",qTy)))))))])))) ; val dfn'CSetOffset_def = Def ("dfn'CSetOffset",TP[Var("cd",FTy 5),Var("cb",FTy 5),Var("rt",FTy 5)], @@ -13547,9 +13801,7 @@ val dfn'CSetOffset_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))), Apply (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), @@ -13573,14 +13825,13 @@ val dfn'CSetOffset_def = Def ("SignalCapException_v",ATy(qTy,PTy(uTy,qTy)), Var("cb",FTy 5)),qVar"state")), (Bop(And, - Mop(Not, - Dest - ("tag",bTy, - Mop(Fst, - Apply - (Call - ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), - Var("cb",FTy 5)),qVar"state")))), + Dest + ("tag",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state"))), Dest ("sealed",bTy, Mop(Fst, @@ -13593,35 +13844,59 @@ val dfn'CSetOffset_def = Def ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), TP[LC("capExcSeal",CTy"CapException"),Var("cb",FTy 5)]), qVar"state"))], - Let(qVar"s", - Mop(Snd, + Let(Var("v",CTy"Capability"), + Mop(Fst, Apply (Call - ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), - TP[Mop(Fst, - Apply - (Call - ("CAPR", - ATy(qTy,PTy(CTy"Capability",qTy)), - Var("cb",FTy 5)),qVar"state")), - Var("cd",FTy 5)]),qVar"state")), - Apply - (Call - ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), - TP[Rupd - ("offset", - TP[Mop(Fst, - Apply - (Call - ("CAPR", - ATy(qTy,PTy(CTy"Capability",qTy)), - Var("cd",FTy 5)),qVar"s")), - Mop(Fst, - Apply - (Call - ("GPR",ATy(qTy,PTy(F64,qTy)), - Var("rt",FTy 5)),qVar"s"))]), - Var("cd",FTy 5)]),qVar"s"))))) + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")), + TP[LU, + Let(Var("s",PTy(CTy"Capability",qTy)), + TP[Var("v",CTy"Capability"),qVar"state"], + Let(Var("s",PTy(CTy"Capability",qTy)), + Let(TP[Var("v",CTy"Capability"), + Var("s",PTy(CTy"Capability",qTy))], + Let(TP[Var("v",PTy(CTy"Capability",F64)), + Var("s",PTy(CTy"Capability",qTy))], + Let(TP[Var("v0",F64), + Var("s",PTy(CTy"Capability",qTy))], + Let(TP[Var("v",F64),qVar"s3"], + TP[Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy,PTy(F64,qTy)), + Var("rt",FTy 5)), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy))))), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy)))], + TP[Var("v",F64), + Mop(Fst, + Var("s", + PTy(CTy"Capability", + qTy))),qVar"s3"]), + TP[TP[Var("v",CTy"Capability"), + Var("v0",F64)], + Var("s",PTy(CTy"Capability",qTy))]), + TP[Rupd + ("offset", + Var("v",PTy(CTy"Capability",F64))), + Var("s",PTy(CTy"Capability",qTy))]), + TP[Var("v",CTy"Capability"), + Mop(Snd,Var("s",PTy(CTy"Capability",qTy)))]), + Mop(Snd, + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Fst, + Var("s",PTy(CTy"Capability",qTy))), + Var("cd",FTy 5)]), + Mop(Snd,Var("s",PTy(CTy"Capability",qTy)))))))])))) ; val dfn'CCheckPerm_def = Def ("dfn'CCheckPerm",TP[Var("cs",FTy 5),Var("rt",FTy 5)], @@ -13634,9 +13909,7 @@ val dfn'CCheckPerm_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))), Apply (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), @@ -13702,9 +13975,7 @@ val dfn'CCheckType_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))), Apply (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), @@ -13811,9 +14082,7 @@ val dfn'CFromPtr_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))), Apply (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), @@ -13840,150 +14109,92 @@ val dfn'CFromPtr_def = Def Apply (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), qVar"state")),LW(0,64)), - Let(qVar"s", - Mop(Snd, - Apply - (Call - ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), - TP[Rupd - ("tag", - TP[Mop(Fst, - Apply - (Call - ("CAPR", - ATy(qTy, - PTy(CTy"Capability",qTy)), - Var("cd",FTy 5)),qVar"state")), - LF]),Var("cd",FTy 5)]),qVar"state")), - Let(qVar"s", - Mop(Snd, - Apply - (Call - ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), - TP[Rupd - ("sealed", - TP[Mop(Fst, - Apply - (Call - ("CAPR", - ATy(qTy, - PTy(CTy"Capability", - qTy)), - Var("cd",FTy 5)),qVar"s")), - LF]),Var("cd",FTy 5)]),qVar"s")), - Let(qVar"s", - Mop(Snd, - Apply - (Call - ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), - TP[Rupd - ("perms", - TP[Mop(Fst, - Apply - (Call - ("CAPR", - ATy(qTy, - PTy(CTy"Capability", - qTy)), - Var("cd",FTy 5)), - qVar"s")),LW(0,31)]), - Var("cd",FTy 5)]),qVar"s")), - Let(qVar"s", - Mop(Snd, - Apply - (Call - ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), - TP[Rupd - ("base", - TP[Mop(Fst, + TP[LU, + Let(Var("s",PTy(CTy"Capability",qTy)), + TP[Rupd("tag",TP[LX(CTy"Capability"),LF]),qVar"state"], + Let(Var("s",PTy(CTy"Capability",qTy)), + TP[Rupd + ("sealed", + TP[Mop(Fst,Var("s",PTy(CTy"Capability",qTy))), + LF]), + Mop(Snd,Var("s",PTy(CTy"Capability",qTy)))], + Let(Var("s",PTy(CTy"Capability",qTy)), + TP[Rupd + ("perms", + TP[Mop(Fst, + Var("s",PTy(CTy"Capability",qTy))), + LW(0,31)]), + Mop(Snd,Var("s",PTy(CTy"Capability",qTy)))], + Let(Var("s",PTy(CTy"Capability",qTy)), + TP[Rupd + ("base", + TP[Mop(Fst, + Var("s", + PTy(CTy"Capability",qTy))), + LW(0,64)]), + Mop(Snd, + Var("s",PTy(CTy"Capability",qTy)))], + Let(Var("s",PTy(CTy"Capability",qTy)), + TP[Rupd + ("length", + TP[Mop(Fst, + Var("s", + PTy(CTy"Capability", + qTy))),LW(0,64)]), + Mop(Snd, + Var("s",PTy(CTy"Capability",qTy)))], + Let(Var("s",PTy(CTy"Capability",qTy)), + TP[Rupd + ("offset", + TP[Mop(Fst, + Var("s", + PTy(CTy"Capability", + qTy))), + LW(0,64)]), + Mop(Snd, + Var("s", + PTy(CTy"Capability",qTy)))], + Let(Var("s", + PTy(CTy"Capability",qTy)), + TP[Rupd + ("otype", + TP[Mop(Fst, + Var("s", + PTy(CTy"Capability", + qTy))), + LW(0,24)]), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy)))], + Let(Var("s", + PTy(CTy"Capability",qTy)), + TP[Rupd + ("reserved", + TP[Mop(Fst, + Var("s", + PTy(CTy"Capability", + qTy))), + LW(0,8)]), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy)))], + Mop(Snd, Apply (Call - ("CAPR", + ("write'CAPR", ATy(qTy, - PTy(CTy"Capability", - qTy)), - Var("cd",FTy 5)), - qVar"s")),LW(0,64)]), - Var("cd",FTy 5)]),qVar"s")), - Let(qVar"s", - Mop(Snd, - Apply - (Call - ("write'CAPR", - ATy(qTy,PTy(uTy,qTy)), - TP[Rupd - ("length", - TP[Mop(Fst, - Apply - (Call - ("CAPR", - ATy(qTy, - PTy(CTy"Capability", - qTy)), - Var("cd", - FTy 5)), - qVar"s")), - LW(0,64)]), - Var("cd",FTy 5)]),qVar"s")), - Let(qVar"s", - Mop(Snd, - Apply - (Call - ("write'CAPR", - ATy(qTy,PTy(uTy,qTy)), - TP[Rupd - ("offset", - TP[Mop(Fst, - Apply - (Call - ("CAPR", - ATy(qTy, - PTy(CTy"Capability", - qTy)), - Var("cd", - FTy 5)), - qVar"s")), - LW(0,64)]), - Var("cd",FTy 5)]),qVar"s")), - Let(qVar"s", - Mop(Snd, - Apply - (Call - ("write'CAPR", - ATy(qTy,PTy(uTy,qTy)), - TP[Rupd - ("otype", - TP[Mop(Fst, - Apply - (Call - ("CAPR", - ATy(qTy, - PTy(CTy"Capability", - qTy)), - Var("cd", - FTy 5)), - qVar"s")), - LW(0,24)]), - Var("cd",FTy 5)]), - qVar"s")), - Apply - (Call - ("write'CAPR", - ATy(qTy,PTy(uTy,qTy)), - TP[Rupd - ("reserved", - TP[Mop(Fst, - Apply - (Call - ("CAPR", - ATy(qTy, - PTy(CTy"Capability", - qTy)), - Var("cd", - FTy 5)), - qVar"s")), - LW(0,8)]), - Var("cd",FTy 5)]),qVar"s"))))))))), + PTy(uTy,qTy)), + TP[Mop(Fst, + Var("s", + PTy(CTy"Capability", + qTy))), + Var("cd",FTy 5)]), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy)))))))))))))]), (Mop(Not, Dest ("tag",bTy, @@ -14026,82 +14237,194 @@ val dfn'CFromPtr_def = Def ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), TP[LC("capExcLength",CTy"CapException"),Var("cb",FTy 5)]), qVar"state"))], - Let(qVar"s", - Mop(Snd, + Let(Var("v",CTy"Capability"), + Mop(Fst, Apply (Call - ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), - TP[Mop(Fst, - Apply - (Call - ("CAPR", - ATy(qTy,PTy(CTy"Capability",qTy)), - Var("cb",FTy 5)),qVar"state")), - Var("cd",FTy 5)]),qVar"state")), - Let(qVar"s", - Mop(Snd, - Apply - (Call - ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), - TP[Rupd - ("base", - TP[Mop(Fst, - Apply - (Call - ("CAPR", - ATy(qTy, - PTy(CTy"Capability",qTy)), - Var("cd",FTy 5)),qVar"s")), - Bop(Add, - Dest - ("base",F64, - Mop(Fst, - Apply - (Call - ("CAPR", - ATy(qTy, + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cb",FTy 5)),qVar"state")), + TP[LU, + Let(Var("s",PTy(CTy"Capability",qTy)), + TP[Var("v",CTy"Capability"),qVar"state"], + Let(Var("s",PTy(CTy"Capability",qTy)), + Let(TP[Var("v",CTy"Capability"), + Var("s",PTy(CTy"Capability",qTy))], + Let(TP[Var("v",PTy(CTy"Capability",F64)), + Var("s",PTy(CTy"Capability",qTy))], + Let(TP[Var("v0",CTy"Capability"), + Var("s",PTy(CTy"Capability",qTy))], + CS(TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("cb",FTy 5)), + Mop(Snd, + Var("s", PTy(CTy"Capability", - qTy)), - Var("cb",FTy 5)), - qVar"s"))), - Mop(Fst, - Apply - (Call - ("GPR", - ATy(qTy,PTy(F64,qTy)), - Var("rt",FTy 5)), - qVar"s")))]), - Var("cd",FTy 5)]),qVar"s")), - Apply - (Call - ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), - TP[Rupd - ("length", - TP[Mop(Fst, - Apply - (Call - ("CAPR", - ATy(qTy, - PTy(CTy"Capability",qTy)), - Var("cd",FTy 5)),qVar"s")), - Bop(Sub, - Dest - ("length",F64, - Mop(Fst, - Apply - (Call - ("CAPR", - ATy(qTy, - PTy(CTy"Capability", - qTy)), - Var("cb",FTy 5)),qVar"s"))), - Mop(Fst, - Apply - (Call - ("GPR", - ATy(qTy,PTy(F64,qTy)), - Var("rt",FTy 5)),qVar"s")))]), - Var("cd",FTy 5)]),qVar"s")))))) + qTy))))), + Mop(Snd, + Var("s", + PTy(CTy"Capability",qTy)))], + [(TP[Var("v",CTy"Capability"), + qVar"s3"], + TP[Var("v",CTy"Capability"), + Mop(Fst, + Var("s", + PTy(CTy"Capability", + qTy))),qVar"s3"])]), + Let(TP[Var("v0",F64), + Var("s", + PTy(CTy"Capability",qTy))], + Let(TP[Var("v1",F64), + Var("s", + PTy(CTy"Capability", + qTy))], + Let(TP[Var("v",F64),qVar"s3"], + TP[Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy, + PTy(F64, + qTy)), + Var("rt", + FTy 5)), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy))))), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy)))], + TP[Var("v",F64), + Mop(Fst, + Var("s", + PTy(CTy"Capability", + qTy))), + qVar"s3"]), + TP[Bop(Add, + Dest + ("base",F64, + Var("v0", + CTy"Capability")), + Var("v1",F64)), + Var("s", + PTy(CTy"Capability", + qTy))]), + TP[TP[Var("v",CTy"Capability"), + Var("v0",F64)], + Var("s", + PTy(CTy"Capability",qTy))])), + TP[Rupd + ("base", + Var("v",PTy(CTy"Capability",F64))), + Var("s",PTy(CTy"Capability",qTy))]), + TP[Var("v",CTy"Capability"), + Mop(Snd,Var("s",PTy(CTy"Capability",qTy)))]), + Let(Var("s",PTy(CTy"Capability",qTy)), + Let(TP[Var("v",CTy"Capability"), + Var("s",PTy(CTy"Capability",qTy))], + Let(TP[Var("v",PTy(CTy"Capability",F64)), + Var("s",PTy(CTy"Capability",qTy))], + Let(TP[Var("v0",CTy"Capability"), + Var("s0", + PTy(CTy"Capability",qTy))], + CS(TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("cb",FTy 5)), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy))))), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy)))], + [(TP[Var("v",CTy"Capability"), + qVar"s3"], + TP[Var("v",CTy"Capability"), + Mop(Fst, + Var("s", + PTy(CTy"Capability", + qTy))), + qVar"s3"])]), + Let(TP[Var("v0",F64), + Var("s0", + PTy(CTy"Capability", + qTy))], + Let(TP[Var("v1",F64), + Var("s", + PTy(CTy"Capability", + qTy))], + Let(TP[Var("v",F64), + qVar"s3"], + TP[Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy, + PTy(F64, + qTy)), + Var("rt", + FTy 5)), + Mop(Snd, + Var("s0", + PTy(CTy"Capability", + qTy))))), + Mop(Snd, + Var("s0", + PTy(CTy"Capability", + qTy)))], + TP[Var("v",F64), + Mop(Fst, + Var("s0", + PTy(CTy"Capability", + qTy))), + qVar"s3"]), + TP[Bop(Sub, + Dest + ("length",F64, + Var("v0", + CTy"Capability")), + Var("v1",F64)), + Var("s", + PTy(CTy"Capability", + qTy))]), + TP[TP[Mop(Fst, + Var("s", + PTy(CTy"Capability", + qTy))), + Var("v0",F64)], + Var("s0", + PTy(CTy"Capability", + qTy))])), + TP[Rupd + ("length", + Var("v", + PTy(CTy"Capability",F64))), + Var("s",PTy(CTy"Capability",qTy))]), + TP[Var("v",CTy"Capability"), + Mop(Snd, + Var("s",PTy(CTy"Capability",qTy)))]), + Mop(Snd, + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Fst, + Var("s", + PTy(CTy"Capability",qTy))), + Var("cd",FTy 5)]), + Mop(Snd, + Var("s",PTy(CTy"Capability",qTy))))))))])))) ; val dfn'CToPtr_def = Def ("dfn'CToPtr",TP[Var("rd",FTy 5),Var("cb",FTy 5),Var("ct",FTy 5)], @@ -14114,9 +14437,7 @@ val dfn'CToPtr_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))), Apply (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), @@ -14207,8 +14528,7 @@ val dfn'CPtrCmp_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))), Apply (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), @@ -16112,8 +16432,7 @@ val dfn'CBTU_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))), Apply (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), @@ -16194,8 +16513,7 @@ val dfn'CBTS_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))), Apply (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), @@ -16450,9 +16768,7 @@ val dfn'CSC_def = Def Apply (Const ("CP0", - ATy(qTy, - PTy(CTy"CP0__renamed__", - qTy))), + ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state")),Var("v",F64)])), qVar"state"))))], Apply @@ -16617,9 +16933,7 @@ val dfn'CLC_def = Def Apply (Const ("CP0", - ATy(qTy, - PTy(CTy"CP0__renamed__", - qTy))), + ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state")),Var("v",F64)])), qVar"state"))))], Let(TP[Var("v",CTy"Capability"),qVar"s"], @@ -18672,7 +18986,7 @@ val dfn'CLoad_def = Def PTy(FTy 3, qTy)))))))))), Let(TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Var("s", PTy(FTy 3, PTy(F64, @@ -18681,7 +18995,7 @@ val dfn'CLoad_def = Def PTy(FTy 3, qTy))))))], Let(TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Var("s3", PTy(F64, PTy(bTy, @@ -18689,32 +19003,32 @@ val dfn'CLoad_def = Def PTy(FTy 3, qTy)))))], Let(TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Var("s3", PTy(bTy, PTy(FTy 65, PTy(FTy 3, qTy))))], Let(TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Var("s3", PTy(FTy 65, PTy(FTy 3, qTy)))], Let(TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Var("s3", PTy(FTy 3, qTy))], Let(TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), qVar"s3"], TP[Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), Mop(Snd, Mop(Snd, @@ -18741,7 +19055,7 @@ val dfn'CLoad_def = Def PTy(FTy 3, qTy)))))))))))], TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Mop(Snd, Mop(Snd, @@ -18756,7 +19070,7 @@ val dfn'CLoad_def = Def qTy))))))))))), qVar"s3"]), TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Mop(Snd, Mop(Snd, @@ -18772,7 +19086,7 @@ val dfn'CLoad_def = Def PTy(FTy 3, qTy))]), TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Mop(Snd, Mop(Snd, @@ -18788,7 +19102,7 @@ val dfn'CLoad_def = Def PTy(FTy 3, qTy)))]), TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Mop(Snd, Var("s0", @@ -18804,7 +19118,7 @@ val dfn'CLoad_def = Def PTy(FTy 3, qTy))))]), TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Var("s0", PTy(FTy 3, @@ -18886,7 +19200,7 @@ val dfn'CLoad_def = Def Rupd ("BadVAddr", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Mop(Snd, Var("s", @@ -19484,10 +19798,9 @@ val dfn'CLLD_def = Def Apply (Const ("CP0", - ATy(qTy, - PTy(CTy"CP0__renamed__", - qTy))),qVar"state")), - Var("v",F64)])),qVar"state"))))], + ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state")),Var("v",F64)])), + qVar"state"))))], Let(TP[Var("v",F64),qVar"s"], Apply (Call @@ -21532,7 +21845,7 @@ val dfn'CStore_def = Def PTy(FTy 3, qTy)))))))))), Let(TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Var("s", PTy(FTy 3, PTy(F64, @@ -21541,7 +21854,7 @@ val dfn'CStore_def = Def PTy(FTy 3, qTy))))))], Let(TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Var("s3", PTy(F64, PTy(bTy, @@ -21549,32 +21862,32 @@ val dfn'CStore_def = Def PTy(FTy 3, qTy)))))], Let(TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Var("s3", PTy(bTy, PTy(FTy 65, PTy(FTy 3, qTy))))], Let(TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Var("s3", PTy(FTy 65, PTy(FTy 3, qTy)))], Let(TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Var("s3", PTy(FTy 3, qTy))], Let(TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), qVar"s3"], TP[Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), Mop(Snd, Mop(Snd, @@ -21601,7 +21914,7 @@ val dfn'CStore_def = Def PTy(FTy 3, qTy)))))))))))], TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Mop(Snd, Mop(Snd, @@ -21616,7 +21929,7 @@ val dfn'CStore_def = Def qTy))))))))))), qVar"s3"]), TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Mop(Snd, Mop(Snd, @@ -21632,7 +21945,7 @@ val dfn'CStore_def = Def PTy(FTy 3, qTy))]), TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Mop(Snd, Mop(Snd, @@ -21648,7 +21961,7 @@ val dfn'CStore_def = Def PTy(FTy 3, qTy)))]), TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Mop(Snd, Var("s", @@ -21664,7 +21977,7 @@ val dfn'CStore_def = Def PTy(FTy 3, qTy))))]), TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Var("s", PTy(FTy 3, @@ -21746,7 +22059,7 @@ val dfn'CStore_def = Def Rupd ("BadVAddr", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Mop(Snd, Var("s", @@ -22322,10 +22635,9 @@ val dfn'CSCD_def = Def Apply (Const ("CP0", - ATy(qTy, - PTy(CTy"CP0__renamed__", - qTy))),qVar"state")), - Var("v",F64)])),qVar"state"))))], + ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state")),Var("v",F64)])), + qVar"state"))))], Let(TP[Var("v",PTy(F64,FTy 5)),qVar"s"], Let(TP[Var("v",F64),qVar"s"], Let(TP[bVar"v",qVar"s"], @@ -22360,8 +22672,7 @@ val dfn'CJR_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))), Apply (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), @@ -22504,9 +22815,8 @@ val dfn'CJR_def = Def Apply (Const ("CP0", - ATy(qTy, - PTy(CTy"CP0__renamed__", - qTy))),qVar"s")), + ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"s")), Bop(Add, Dest ("base",F64, @@ -22563,8 +22873,7 @@ val dfn'CJALR_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))), Apply (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), @@ -22717,9 +23026,8 @@ val dfn'CJALR_def = Def Apply (Const ("CP0", - ATy(qTy, - PTy(CTy"CP0__renamed__", - qTy))),qVar"s")), + ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"s")), Bop(Add, Dest ("base",F64, @@ -22744,68 +23052,183 @@ val dfn'CJALR_def = Def Var("cb",FTy 5)), qVar"s"))))])), qVar"s"))))], - Let(qVar"s", - Mop(Snd, + Let(Var("v",CTy"Capability"), + Mop(Fst, Apply - (Call - ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), - TP[Mop(Fst, - Apply - (Const - ("PCC", - ATy(qTy, - PTy(CTy"Capability",qTy))), - qVar"s")),Var("cd",FTy 5)]), + (Const + ("PCC",ATy(qTy,PTy(CTy"Capability",qTy))), qVar"s")), - Let(qVar"s", - Mop(Snd, - Apply - (Call - ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), - TP[Rupd - ("offset", - TP[Mop(Fst, + TP[LU, + Let(Var("s",PTy(CTy"Capability",qTy)), + TP[Var("v",CTy"Capability"),qVar"s"], + Let(Var("s",PTy(CTy"Capability",qTy)), + Let(TP[Var("v",CTy"Capability"), + Var("s",PTy(CTy"Capability",qTy))], + Let(TP[Var("v", + PTy(CTy"Capability",F64)), + Var("s", + PTy(CTy"Capability",qTy))], + Let(TP[Var("v0",F64), + Var("s", + PTy(CTy"Capability", + qTy))], + Let(TP[Var("v",F64),qVar"s3"], + TP[Mop(Fst, + Apply + (Const + ("PC", + ATy(qTy, + PTy(F64, + qTy))), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy))))), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy)))], + TP[Var("v",F64), + Mop(Fst, + Var("s", + PTy(CTy"Capability", + qTy))), + qVar"s3"]), + TP[TP[Var("v",CTy"Capability"), + Bop(Add,Var("v0",F64), + LW(8,64))], + Var("s", + PTy(CTy"Capability", + qTy))]), + TP[Rupd + ("offset", + Var("v", + PTy(CTy"Capability",F64))), + Var("s", + PTy(CTy"Capability",qTy))]), + TP[Var("v",CTy"Capability"), + Mop(Snd, + Var("s", + PTy(CTy"Capability",qTy)))]), + Let(Var("s",PTy(CTy"Capability",qTy)), + TP[Mop(Fst, + Var("s", + PTy(CTy"Capability",qTy))), + Mop(Snd, + Apply + (Call + ("write'CAPR", + ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Fst, + Var("s", + PTy(CTy"Capability", + qTy))), + Var("cd",FTy 5)]), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy)))))], + Let(TP[Var("v",CTy"Capability"), + Var("s", + PTy(CTy"Capability",qTy))], + CS(TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("cb",FTy 5)), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy))))), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy)))], + [(TP[Var("v",CTy"Capability"), + qVar"s3"], + TP[Var("v",CTy"Capability"), + Mop(Fst, + Var("s", + PTy(CTy"Capability", + qTy))), + qVar"s3"])]), + Let(TP[Var("v", + OTy(PTy(F64, + CTy"Capability"))), + Var("s", + PTy(CTy"Capability", + qTy))], + Let(TP[Var("v", + PTy(F64, + CTy"Capability")), + Var("s", + PTy(CTy"Capability", + qTy))], + Let(TP[Var("v0", + CTy"Capability"), + Var("s", + PTy(CTy"Capability", + qTy))], + CS(TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("cb", + FTy 5)), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy))))), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy)))], + [(TP[Var("v", + CTy"Capability"), + qVar"s3"], + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Var("s", + PTy(CTy"Capability", + qTy))), + qVar"s3"])]), + TP[TP[Dest + ("offset", + F64, + Var("v", + CTy"Capability")), + Var("v0", + CTy"Capability")], + Var("s", + PTy(CTy"Capability", + qTy))]), + TP[Mop(Some, + Var("v", + PTy(F64, + CTy"Capability"))), + Var("s", + PTy(CTy"Capability", + qTy))]), + Mop(Snd, Apply (Call - ("CAPR", + ("write'BranchToPCC", ATy(qTy, - PTy(CTy"Capability", - qTy)), - Var("cd",FTy 5)), - qVar"s")), - Bop(Add, - Mop(Fst, - Apply - (Const - ("PC", - ATy(qTy, - PTy(F64,qTy))), - qVar"s")),LW(8,64))]), - Var("cd",FTy 5)]),qVar"s")), - Apply - (Call - ("write'BranchToPCC",ATy(qTy,PTy(uTy,qTy)), - Mop(Some, - TP[Dest - ("offset",F64, - Mop(Fst, - Apply - (Call - ("CAPR", - ATy(qTy, - PTy(CTy"Capability", - qTy)), - Var("cb",FTy 5)), - qVar"s"))), - Mop(Fst, - Apply - (Call - ("CAPR", - ATy(qTy, - PTy(CTy"Capability", - qTy)), - Var("cb",FTy 5)),qVar"s"))])), - qVar"s")))))))) + PTy(uTy,qTy)), + Var("v", + OTy(PTy(F64, + CTy"Capability")))), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy))))))))))])))))) ; val dfn'CSeal_def = Def ("dfn'CSeal",TP[Var("cd",FTy 5),Var("cs",FTy 5),Var("ct",FTy 5)], @@ -22818,9 +23241,7 @@ val dfn'CSeal_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))), Apply (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), @@ -22962,69 +23383,116 @@ val dfn'CSeal_def = Def ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), TP[LC("capExcLength",CTy"CapException"),Var("ct",FTy 5)]), qVar"state"))], - Let(qVar"s", - Mop(Snd, - Apply - (Call - ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), - TP[Mop(Fst, - Apply - (Call - ("CAPR", - ATy(qTy,PTy(CTy"Capability",qTy)), - Var("cs",FTy 5)),qVar"state")), - Var("cd",FTy 5)]),qVar"state")), - Let(qVar"s", - Mop(Snd, - Apply - (Call - ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), - TP[Rupd - ("sealed", - TP[Mop(Fst, - Apply - (Call - ("CAPR", - ATy(qTy, - PTy(CTy"Capability",qTy)), - Var("cd",FTy 5)),qVar"s")), - LT]),Var("cd",FTy 5)]),qVar"s")), - Apply - (Call - ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), - TP[Rupd - ("otype", - TP[Mop(Fst, - Apply - (Call - ("CAPR", - ATy(qTy, - PTy(CTy"Capability",qTy)), - Var("cd",FTy 5)),qVar"s")), - EX(Bop(Add, - Dest - ("base",F64, - Mop(Fst, - Apply - (Call - ("CAPR", - ATy(qTy, - PTy(CTy"Capability", - qTy)), - Var("ct",FTy 5)), - qVar"s"))), - Dest - ("offset",F64, - Mop(Fst, - Apply - (Call - ("CAPR", - ATy(qTy, - PTy(CTy"Capability", - qTy)), - Var("ct",FTy 5)), - qVar"s")))),LN 23,LN 0, - FTy 24)]),Var("cd",FTy 5)]),qVar"s")))))) + TP[LU, + Let(Var("s",PTy(CTy"Capability",qTy)), + TP[Rupd + ("sealed", + TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("cs",FTy 5)),qVar"state")),LT]), + qVar"state"], + Let(Var("s",PTy(CTy"Capability",qTy)), + Let(TP[Var("v",CTy"Capability"), + Var("s",PTy(CTy"Capability",qTy))], + Let(TP[Var("v",PTy(CTy"Capability",FTy 24)), + Var("s",PTy(CTy"Capability",qTy))], + Let(TP[Var("v0",CTy"Capability"), + Var("s0",PTy(CTy"Capability",qTy))], + CS(TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("ct",FTy 5)), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy))))), + Mop(Snd, + Var("s", + PTy(CTy"Capability",qTy)))], + [(TP[Var("v",CTy"Capability"),qVar"s3"], + TP[Var("v",CTy"Capability"), + Mop(Fst, + Var("s", + PTy(CTy"Capability",qTy))), + qVar"s3"])]), + Let(TP[Var("v0",FTy 24), + Var("s0",PTy(CTy"Capability",qTy))], + Let(TP[Var("v",F64), + Var("s", + PTy(CTy"Capability",qTy))], + Let(TP[Var("v1",CTy"Capability"), + Var("s", + PTy(CTy"Capability", + qTy))], + CS(TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("ct", + FTy 5)), + Mop(Snd, + Var("s0", + PTy(CTy"Capability", + qTy))))), + Mop(Snd, + Var("s0", + PTy(CTy"Capability", + qTy)))], + [(TP[Var("v", + CTy"Capability"), + qVar"s3"], + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Var("s0", + PTy(CTy"Capability", + qTy))), + qVar"s3"])]), + TP[Bop(Add, + Dest + ("base",F64, + Var("v0", + CTy"Capability")), + Dest + ("offset",F64, + Var("v1", + CTy"Capability"))), + Var("s", + PTy(CTy"Capability", + qTy))]), + TP[EX(Var("v",F64),LN 23,LN 0, + FTy 24), + Var("s", + PTy(CTy"Capability",qTy))]), + TP[TP[Mop(Fst, + Var("s", + PTy(CTy"Capability",qTy))), + Var("v0",FTy 24)], + Var("s0",PTy(CTy"Capability",qTy))])), + TP[Rupd + ("otype", + Var("v",PTy(CTy"Capability",FTy 24))), + Var("s",PTy(CTy"Capability",qTy))]), + TP[Var("v",CTy"Capability"), + Mop(Snd,Var("s",PTy(CTy"Capability",qTy)))]), + Mop(Snd, + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Fst, + Var("s",PTy(CTy"Capability",qTy))), + Var("cd",FTy 5)]), + Mop(Snd,Var("s",PTy(CTy"Capability",qTy)))))))]))) ; val dfn'CUnseal_def = Def ("dfn'CUnseal",TP[Var("cd",FTy 5),Var("cs",FTy 5),Var("ct",FTy 5)], @@ -23037,9 +23505,7 @@ val dfn'CUnseal_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))), Apply (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), @@ -23191,116 +23657,202 @@ val dfn'CUnseal_def = Def ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), TP[LC("capExcLength",CTy"CapException"),Var("ct",FTy 5)]), qVar"state"))], - Let(qVar"s", - Mop(Snd, - Apply - (Call - ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), - TP[Mop(Fst, - Apply - (Call - ("CAPR", - ATy(qTy,PTy(CTy"Capability",qTy)), - Var("cs",FTy 5)),qVar"state")), - Var("cd",FTy 5)]),qVar"state")), - Let(qVar"s", - Mop(Snd, - Apply - (Call - ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), - TP[Rupd - ("sealed", - TP[Mop(Fst, - Apply - (Call - ("CAPR", - ATy(qTy, - PTy(CTy"Capability",qTy)), - Var("cd",FTy 5)),qVar"s")), - LF]),Var("cd",FTy 5)]),qVar"s")), - Let(qVar"s", - Mop(Snd, - Apply - (Call - ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), - TP[Rupd - ("otype", - TP[Mop(Fst, - Apply - (Call - ("CAPR", - ATy(qTy, - PTy(CTy"Capability", - qTy)), - Var("cd",FTy 5)), - qVar"s")),LW(0,24)]), - Var("cd",FTy 5)]),qVar"s")), - Let(Var("v",CTy"Capability"), - Mop(Fst, + TP[LU, + Let(Var("s",PTy(CTy"Capability",qTy)), + TP[Rupd + ("sealed", + TP[Mop(Fst, Apply (Call ("CAPR", ATy(qTy,PTy(CTy"Capability",qTy)), - Var("cd",FTy 5)),qVar"s")), - Let(Var("x1",FTy 31), - Dest - ("perms",FTy 31,Var("v",CTy"Capability")), - Apply - (Call - ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), - TP[Rupd - ("perms", - TP[Var("v",CTy"Capability"), - Call - ("write'rec'Perms",FTy 31, - TP[Var("x1",FTy 31), - Rupd - ("Global", - TP[Call - ("rec'Perms", - CTy"Perms", - Var("x1", - FTy 31)), - Bop(And, - Dest - ("Global", - bTy, - Call - ("rec'Perms", - CTy"Perms", - Dest - ("perms", - FTy 31, - Mop(Fst, - Apply - (Call - ("CAPR", - ATy(qTy, - PTy(CTy"Capability", - qTy)), - Var("cs", - FTy 5)), - qVar"s"))))), - Dest - ("Global", - bTy, - Call - ("rec'Perms", - CTy"Perms", - Dest - ("perms", - FTy 31, - Mop(Fst, - Apply - (Call - ("CAPR", - ATy(qTy, - PTy(CTy"Capability", - qTy)), - Var("ct", - FTy 5)), - qVar"s"))))))])])]), - Var("cd",FTy 5)]),qVar"s"))))))))) + Var("cs",FTy 5)),qVar"state")),LF]), + qVar"state"], + Let(Var("s",PTy(CTy"Capability",qTy)), + TP[Rupd + ("otype", + TP[Mop(Fst,Var("s",PTy(CTy"Capability",qTy))), + LW(0,24)]), + Mop(Snd,Var("s",PTy(CTy"Capability",qTy)))], + Let(Var("s",PTy(CTy"Capability",qTy)), + Let(Var("v",FTy 31), + Dest + ("perms",FTy 31, + Mop(Fst,Var("s",PTy(CTy"Capability",qTy)))), + Let(TP[Var("v",CTy"Capability"), + Var("s",PTy(CTy"Capability",qTy))], + Let(TP[Var("v", + PTy(CTy"Capability",FTy 31)), + Var("s",PTy(CTy"Capability",qTy))], + Let(TP[Var("v0",CTy"Capability"), + Var("s0", + PTy(CTy"Capability",qTy))], + CS(TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("cs",FTy 5)), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy))))), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy)))], + [(TP[Var("v",CTy"Capability"), + qVar"s3"], + TP[Var("v",CTy"Capability"), + Mop(Fst, + Var("s", + PTy(CTy"Capability", + qTy))), + qVar"s3"])]), + Let(TP[Var("v0",FTy 31), + Var("s0", + PTy(CTy"Capability", + qTy))], + Let(TP[Var("v", + PTy(FTy 31, + CTy"Perms")), + Var("s", + PTy(CTy"Capability", + qTy))], + Let(TP[Var("v0", + CTy"Perms"), + Var("s", + PTy(CTy"Capability", + qTy))], + Let(TP[Var("v", + PTy(CTy"Perms", + bTy)), + Var("s", + PTy(CTy"Capability", + qTy))], + Let(TP[bVar"v0", + Var("s", + PTy(CTy"Capability", + qTy))], + ITE(Dest + ("Global", + bTy, + Call + ("rec'Perms", + CTy"Perms", + Dest + ("perms", + FTy 31, + Var("v0", + CTy"Capability")))), + Let(TP[Var("v", + CTy"Capability"), + Var("s", + PTy(CTy"Capability", + qTy))], + CS(TP[Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy, + PTy(CTy"Capability", + qTy)), + Var("ct", + FTy 5)), + Mop(Snd, + Var("s0", + PTy(CTy"Capability", + qTy))))), + Mop(Snd, + Var("s0", + PTy(CTy"Capability", + qTy)))], + [(TP[Var("v", + CTy"Capability"), + qVar"s3"], + TP[Var("v", + CTy"Capability"), + Mop(Fst, + Var("s0", + PTy(CTy"Capability", + qTy))), + qVar"s3"])]), + TP[Dest + ("Global", + bTy, + Call + ("rec'Perms", + CTy"Perms", + Dest + ("perms", + FTy 31, + Var("v", + CTy"Capability")))), + Var("s", + PTy(CTy"Capability", + qTy))]), + TP[LF, + Var("s0", + PTy(CTy"Capability", + qTy))]), + TP[TP[Call + ("rec'Perms", + CTy"Perms", + Var("v", + FTy 31)), + bVar"v0"], + Var("s", + PTy(CTy"Capability", + qTy))]), + TP[Rupd + ("Global", + Var("v", + PTy(CTy"Perms", + bTy))), + Var("s", + PTy(CTy"Capability", + qTy))]), + TP[TP[Var("v",FTy 31), + Var("v0", + CTy"Perms")], + Var("s", + PTy(CTy"Capability", + qTy))]), + TP[Call + ("write'rec'Perms", + FTy 31, + Var("v", + PTy(FTy 31, + CTy"Perms"))), + Var("s", + PTy(CTy"Capability", + qTy))]), + TP[TP[Mop(Fst, + Var("s", + PTy(CTy"Capability", + qTy))), + Var("v0",FTy 31)], + Var("s0", + PTy(CTy"Capability", + qTy))])), + TP[Rupd + ("perms", + Var("v", + PTy(CTy"Capability",FTy 31))), + Var("s",PTy(CTy"Capability",qTy))]), + TP[Var("v",CTy"Capability"), + Mop(Snd, + Var("s",PTy(CTy"Capability",qTy)))])), + Mop(Snd, + Apply + (Call + ("write'CAPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Fst, + Var("s",PTy(CTy"Capability",qTy))), + Var("cd",FTy 5)]), + Mop(Snd,Var("s",PTy(CTy"Capability",qTy))))))))]))) ; val dfn'CCall_def = Def ("dfn'CCall",TP[Var("cs",FTy 5),Var("cb",FTy 5)], @@ -23313,8 +23865,7 @@ val dfn'CCall_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))), Apply (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), @@ -23334,7 +23885,7 @@ val dfn'CReturn_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))), Apply (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), @@ -23353,7 +23904,7 @@ val dfn'UnknownCapInstruction_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state"))))), Apply (Const("SignalCP2UnusableException",ATy(qTy,PTy(uTy,qTy))), @@ -25313,8 +25864,7 @@ val loadHalf_def = Def Apply (Const ("CP0", - ATy(qTy, - PTy(CTy"CP0__renamed__",qTy))), + ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state")),Var("v",F64)])), qVar"state"))), Let(TP[Var("v0",F64),qVar"s"], @@ -25382,8 +25932,7 @@ val loadWord_def = Def Apply (Const ("CP0", - ATy(qTy, - PTy(CTy"CP0__renamed__",qTy))), + ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state")),Var("v",F64)])), qVar"state"))), Let(TP[Var("v0",F64),qVar"s"], @@ -25450,8 +25999,7 @@ val loadDoubleword_def = Def Apply (Const ("CP0", - ATy(qTy, - PTy(CTy"CP0__renamed__",qTy))), + ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state")),Var("v",F64)])), qVar"state"))), Let(TP[Var("v",F64),qVar"s"], @@ -26071,8 +26619,7 @@ val dfn'SH_def = Def Apply (Const ("CP0", - ATy(qTy, - PTy(CTy"CP0__renamed__",qTy))), + ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state")),Var("v",F64)])), qVar"state"))), Let(TP[bVar"v",qVar"s"], @@ -26125,17 +26672,15 @@ val storeWord_def = Def Let(TP[bVar"r",Var("s1",PTy(bTy,qTy))], Let(Var("s",PTy(bTy,qTy)), ITE(Mop(Not,EQ(EX(Var("v",F64),LN 1,LN 0,FTy 2),LW(0,2))), - Let(TP[Var("v0",CTy"CP0__renamed__"), - Var("s",PTy(bTy,qTy))], - Let(TP[Var("v",CTy"CP0__renamed__"),qVar"s3"], + Let(TP[Var("v0",CTy"CP0"),Var("s",PTy(bTy,qTy))], + Let(TP[Var("v",CTy"CP0"),qVar"s3"], TP[Mop(Fst, Apply (Const ("CP0", - ATy(qTy, - PTy(CTy"CP0__renamed__",qTy))), + ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state")),qVar"state"], - TP[Var("v",CTy"CP0__renamed__"),LF,qVar"s3"]), + TP[Var("v",CTy"CP0"),LF,qVar"s3"]), Let(Var("s",PTy(bTy,qTy)), TP[Mop(Fst,Var("s",PTy(bTy,qTy))), Mop(Snd, @@ -26145,8 +26690,7 @@ val storeWord_def = Def ATy(qTy,PTy(uTy,qTy)), Rupd ("BadVAddr", - TP[Var("v0", - CTy"CP0__renamed__"), + TP[Var("v0",CTy"CP0"), Var("v",F64)])), Mop(Snd,Var("s",PTy(bTy,qTy)))))], TP[Mop(Fst,Var("s",PTy(bTy,qTy))), @@ -26226,17 +26770,15 @@ val storeDoubleword_def = Def Let(TP[bVar"r",Var("s1",PTy(bTy,qTy))], Let(Var("s",PTy(bTy,qTy)), ITE(Mop(Not,EQ(EX(Var("v",F64),LN 2,LN 0,FTy 3),LW(0,3))), - Let(TP[Var("v0",CTy"CP0__renamed__"), - Var("s",PTy(bTy,qTy))], - Let(TP[Var("v",CTy"CP0__renamed__"),qVar"s3"], + Let(TP[Var("v0",CTy"CP0"),Var("s",PTy(bTy,qTy))], + Let(TP[Var("v",CTy"CP0"),qVar"s3"], TP[Mop(Fst, Apply (Const ("CP0", - ATy(qTy, - PTy(CTy"CP0__renamed__",qTy))), + ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state")),qVar"state"], - TP[Var("v",CTy"CP0__renamed__"),LF,qVar"s3"]), + TP[Var("v",CTy"CP0"),LF,qVar"s3"]), Let(Var("s",PTy(bTy,qTy)), TP[Mop(Fst,Var("s",PTy(bTy,qTy))), Mop(Snd, @@ -26246,8 +26788,7 @@ val storeDoubleword_def = Def ATy(qTy,PTy(uTy,qTy)), Rupd ("BadVAddr", - TP[Var("v0", - CTy"CP0__renamed__"), + TP[Var("v0",CTy"CP0"), Var("v",F64)])), Mop(Snd,Var("s",PTy(bTy,qTy)))))], TP[Mop(Fst,Var("s",PTy(bTy,qTy))), @@ -26793,8 +27334,7 @@ val dfn'MTC0_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state")))), Mop(Fst, Apply @@ -26824,8 +27364,7 @@ val dfn'DMTC0_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state")))), Mop(Fst, Apply @@ -26855,8 +27394,7 @@ val dfn'MFC0_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state")))), Mop(Fst, Apply @@ -26888,8 +27426,7 @@ val dfn'DMFC0_def = Def ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"state")))), Mop(Fst, Apply @@ -27530,18 +28067,18 @@ val Run_def = Def TP[Const("dfn'WAIT",uTy),qVar"state"]), (Call ("CACHE",CTy"instruction", - Var("v173",PTy(FTy 5,PTy(FTy 5,F16)))), + Var("v174",PTy(FTy 5,PTy(FTy 5,F16)))), Apply (Call ("dfn'CACHE",ATy(qTy,PTy(uTy,qTy)), - Var("v173",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), - (Call("RDHWR",CTy"instruction",Var("v174",PTy(FTy 5,FTy 5))), + Var("v174",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + (Call("RDHWR",CTy"instruction",Var("v175",PTy(FTy 5,FTy 5))), Apply (Call ("dfn'RDHWR",ATy(qTy,PTy(uTy,qTy)), - Var("v174",PTy(FTy 5,FTy 5))),qVar"state")), - (Call("SYNC",CTy"instruction",Var("v175",FTy 5)), - TP[Call("dfn'SYNC",uTy,Var("v175",FTy 5)),qVar"state"]), + Var("v175",PTy(FTy 5,FTy 5))),qVar"state")), + (Call("SYNC",CTy"instruction",Var("v176",FTy 5)), + TP[Call("dfn'SYNC",uTy,Var("v176",FTy 5)),qVar"state"]), (Call("ArithI",CTy"instruction",Var("v1",CTy"ArithI")), CS(Var("v1",CTy"ArithI"), [(Call @@ -27838,57 +28375,57 @@ val Run_def = Def (Const ("dfn'UnknownCapInstruction", ATy(qTy,PTy(uTy,qTy))),qVar"state")), - (Call("CBTS",CTy"CHERICOP2",Var("v74",PTy(FTy 5,F16))), + (Call("CBTS",CTy"CHERICOP2",Var("v75",PTy(FTy 5,F16))), Apply (Call ("dfn'CBTS",ATy(qTy,PTy(uTy,qTy)), - Var("v74",PTy(FTy 5,F16))),qVar"state")), - (Call("CBTU",CTy"CHERICOP2",Var("v75",PTy(FTy 5,F16))), + Var("v75",PTy(FTy 5,F16))),qVar"state")), + (Call("CBTU",CTy"CHERICOP2",Var("v76",PTy(FTy 5,F16))), Apply (Call ("dfn'CBTU",ATy(qTy,PTy(uTy,qTy)), - Var("v75",PTy(FTy 5,F16))),qVar"state")), + Var("v76",PTy(FTy 5,F16))),qVar"state")), (Call - ("CCall",CTy"CHERICOP2",Var("v76",PTy(FTy 5,FTy 5))), + ("CCall",CTy"CHERICOP2",Var("v77",PTy(FTy 5,FTy 5))), Apply (Call ("dfn'CCall",ATy(qTy,PTy(uTy,qTy)), - Var("v76",PTy(FTy 5,FTy 5))),qVar"state")), + Var("v77",PTy(FTy 5,FTy 5))),qVar"state")), (Call - ("CJALR",CTy"CHERICOP2",Var("v77",PTy(FTy 5,FTy 5))), + ("CJALR",CTy"CHERICOP2",Var("v78",PTy(FTy 5,FTy 5))), Apply (Call ("dfn'CJALR",ATy(qTy,PTy(uTy,qTy)), - Var("v77",PTy(FTy 5,FTy 5))),qVar"state")), - (Call("CJR",CTy"CHERICOP2",Var("v78",FTy 5)), + Var("v78",PTy(FTy 5,FTy 5))),qVar"state")), + (Call("CJR",CTy"CHERICOP2",Var("v79",FTy 5)), Apply (Call ("dfn'CJR",ATy(qTy,PTy(uTy,qTy)), - Var("v78",FTy 5)),qVar"state")), + Var("v79",FTy 5)),qVar"state")), (Call ("CPtrCmp",CTy"CHERICOP2", - Var("v79",PTy(FTy 5,PTy(FTy 5,PTy(FTy 5,FTy 3))))), + Var("v80",PTy(FTy 5,PTy(FTy 5,PTy(FTy 5,FTy 3))))), Apply (Call ("dfn'CPtrCmp",ATy(qTy,PTy(uTy,qTy)), - Var("v79", + Var("v80", PTy(FTy 5,PTy(FTy 5,PTy(FTy 5,FTy 3))))), qVar"state")), (Call ("CSeal",CTy"CHERICOP2", - Var("v80",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Var("v81",PTy(FTy 5,PTy(FTy 5,FTy 5)))), Apply (Call ("dfn'CSeal",ATy(qTy,PTy(uTy,qTy)), - Var("v80",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Var("v81",PTy(FTy 5,PTy(FTy 5,FTy 5)))), qVar"state")), (Call ("CUnseal",CTy"CHERICOP2", - Var("v81",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Var("v82",PTy(FTy 5,PTy(FTy 5,FTy 5)))), Apply (Call ("dfn'CUnseal",ATy(qTy,PTy(uTy,qTy)), - Var("v81",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Var("v82",PTy(FTy 5,PTy(FTy 5,FTy 5)))), qVar"state")), (Call("CCheck",CTy"CHERICOP2",Var("v52",CTy"CCheck")), CS(Var("v52",CTy"CCheck"), @@ -28008,519 +28545,528 @@ val Run_def = Def ("dfn'CIncBase",ATy(qTy,PTy(uTy,qTy)), Var("v70",PTy(FTy 5,PTy(FTy 5,FTy 5)))), qVar"state")), - (Call("CSetCause",CTy"CSet",Var("v71",FTy 5)), + (Call + ("CIncOffset",CTy"CSet", + Var("v71",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Apply + (Call + ("dfn'CIncOffset",ATy(qTy,PTy(uTy,qTy)), + Var("v71",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + qVar"state")), + (Call("CSetCause",CTy"CSet",Var("v72",FTy 5)), Apply (Call ("dfn'CSetCause",ATy(qTy,PTy(uTy,qTy)), - Var("v71",FTy 5)),qVar"state")), + Var("v72",FTy 5)),qVar"state")), (Call ("CSetLen",CTy"CSet", - Var("v72",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Var("v73",PTy(FTy 5,PTy(FTy 5,FTy 5)))), Apply (Call ("dfn'CSetLen",ATy(qTy,PTy(uTy,qTy)), - Var("v72",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Var("v73",PTy(FTy 5,PTy(FTy 5,FTy 5)))), qVar"state")), (Call ("CSetOffset",CTy"CSet", - Var("v73",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Var("v74",PTy(FTy 5,PTy(FTy 5,FTy 5)))), Apply (Call ("dfn'CSetOffset",ATy(qTy,PTy(uTy,qTy)), - Var("v73",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Var("v74",PTy(FTy 5,PTy(FTy 5,FTy 5)))), qVar"state"))]))]))])), - (Call("CP",CTy"instruction",Var("v82",CTy"CP")), - CS(Var("v82",CTy"CP"), + (Call("CP",CTy"instruction",Var("v83",CTy"CP")), + CS(Var("v83",CTy"CP"), [(Call - ("DMFC0",CTy"CP",Var("v83",PTy(FTy 5,PTy(FTy 5,FTy 3)))), + ("DMFC0",CTy"CP",Var("v84",PTy(FTy 5,PTy(FTy 5,FTy 3)))), Apply (Call ("dfn'DMFC0",ATy(qTy,PTy(uTy,qTy)), - Var("v83",PTy(FTy 5,PTy(FTy 5,FTy 3)))),qVar"state")), + Var("v84",PTy(FTy 5,PTy(FTy 5,FTy 3)))),qVar"state")), (Call - ("DMTC0",CTy"CP",Var("v84",PTy(FTy 5,PTy(FTy 5,FTy 3)))), + ("DMTC0",CTy"CP",Var("v85",PTy(FTy 5,PTy(FTy 5,FTy 3)))), Apply (Call ("dfn'DMTC0",ATy(qTy,PTy(uTy,qTy)), - Var("v84",PTy(FTy 5,PTy(FTy 5,FTy 3)))),qVar"state")), + Var("v85",PTy(FTy 5,PTy(FTy 5,FTy 3)))),qVar"state")), (Call - ("MFC0",CTy"CP",Var("v85",PTy(FTy 5,PTy(FTy 5,FTy 3)))), + ("MFC0",CTy"CP",Var("v86",PTy(FTy 5,PTy(FTy 5,FTy 3)))), Apply (Call ("dfn'MFC0",ATy(qTy,PTy(uTy,qTy)), - Var("v85",PTy(FTy 5,PTy(FTy 5,FTy 3)))),qVar"state")), + Var("v86",PTy(FTy 5,PTy(FTy 5,FTy 3)))),qVar"state")), (Call - ("MTC0",CTy"CP",Var("v86",PTy(FTy 5,PTy(FTy 5,FTy 3)))), + ("MTC0",CTy"CP",Var("v87",PTy(FTy 5,PTy(FTy 5,FTy 3)))), Apply (Call ("dfn'MTC0",ATy(qTy,PTy(uTy,qTy)), - Var("v86",PTy(FTy 5,PTy(FTy 5,FTy 3)))),qVar"state"))])), - (Call("LDC2",CTy"instruction",Var("v87",CTy"LDC2")), - CS(Var("v87",CTy"LDC2"), - [(Call("CHERILDC2",CTy"LDC2",Var("v88",CTy"CHERILDC2")), - CS(Var("v88",CTy"CHERILDC2"), + Var("v87",PTy(FTy 5,PTy(FTy 5,FTy 3)))),qVar"state"))])), + (Call("LDC2",CTy"instruction",Var("v88",CTy"LDC2")), + CS(Var("v88",CTy"LDC2"), + [(Call("CHERILDC2",CTy"LDC2",Var("v89",CTy"CHERILDC2")), + CS(Var("v89",CTy"CHERILDC2"), [(Call ("CLC",CTy"CHERILDC2", - Var("v89",PTy(FTy 5,PTy(FTy 5,PTy(FTy 5,FTy 11))))), + Var("v90",PTy(FTy 5,PTy(FTy 5,PTy(FTy 5,FTy 11))))), Apply (Call ("dfn'CLC",ATy(qTy,PTy(uTy,qTy)), - Var("v89", + Var("v90", PTy(FTy 5,PTy(FTy 5,PTy(FTy 5,FTy 11))))), qVar"state"))]))])), - (Call("LWC2",CTy"instruction",Var("v90",CTy"LWC2")), - CS(Var("v90",CTy"LWC2"), - [(Call("CHERILWC2",CTy"LWC2",Var("v91",CTy"CHERILWC2")), - CS(Var("v91",CTy"CHERILWC2"), + (Call("LWC2",CTy"instruction",Var("v91",CTy"LWC2")), + CS(Var("v91",CTy"LWC2"), + [(Call("CHERILWC2",CTy"LWC2",Var("v92",CTy"CHERILWC2")), + CS(Var("v92",CTy"CHERILWC2"), [(Call ("CLLD",CTy"CHERILWC2", - Var("v92",PTy(FTy 5,PTy(FTy 5,PTy(FTy 5,F8))))), + Var("v93",PTy(FTy 5,PTy(FTy 5,PTy(FTy 5,F8))))), Apply (Call ("dfn'CLLD",ATy(qTy,PTy(uTy,qTy)), - Var("v92",PTy(FTy 5,PTy(FTy 5,PTy(FTy 5,F8))))), + Var("v93",PTy(FTy 5,PTy(FTy 5,PTy(FTy 5,F8))))), qVar"state")), (Call ("CLoad",CTy"CHERILWC2", - Var("v93", + Var("v94", PTy(FTy 5, PTy(FTy 5,PTy(FTy 5,PTy(F8,PTy(F1,FTy 2))))))), Apply (Call ("dfn'CLoad",ATy(qTy,PTy(uTy,qTy)), - Var("v93", + Var("v94", PTy(FTy 5, PTy(FTy 5, PTy(FTy 5,PTy(F8,PTy(F1,FTy 2))))))), qVar"state"))]))])), - (Call("Load",CTy"instruction",Var("v94",CTy"Load")), - CS(Var("v94",CTy"Load"), - [(Call("LB",CTy"Load",Var("v95",PTy(FTy 5,PTy(FTy 5,F16)))), + (Call("Load",CTy"instruction",Var("v95",CTy"Load")), + CS(Var("v95",CTy"Load"), + [(Call("LB",CTy"Load",Var("v96",PTy(FTy 5,PTy(FTy 5,F16)))), Apply (Call ("dfn'LB",ATy(qTy,PTy(uTy,qTy)), - Var("v95",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), - (Call("LBU",CTy"Load",Var("v96",PTy(FTy 5,PTy(FTy 5,F16)))), + Var("v96",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + (Call("LBU",CTy"Load",Var("v97",PTy(FTy 5,PTy(FTy 5,F16)))), Apply (Call ("dfn'LBU",ATy(qTy,PTy(uTy,qTy)), - Var("v96",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), - (Call("LD",CTy"Load",Var("v97",PTy(FTy 5,PTy(FTy 5,F16)))), + Var("v97",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + (Call("LD",CTy"Load",Var("v98",PTy(FTy 5,PTy(FTy 5,F16)))), Apply (Call ("dfn'LD",ATy(qTy,PTy(uTy,qTy)), - Var("v97",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), - (Call("LDL",CTy"Load",Var("v98",PTy(FTy 5,PTy(FTy 5,F16)))), + Var("v98",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + (Call("LDL",CTy"Load",Var("v99",PTy(FTy 5,PTy(FTy 5,F16)))), Apply (Call ("dfn'LDL",ATy(qTy,PTy(uTy,qTy)), - Var("v98",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), - (Call("LDR",CTy"Load",Var("v99",PTy(FTy 5,PTy(FTy 5,F16)))), + Var("v99",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + (Call + ("LDR",CTy"Load",Var("v100",PTy(FTy 5,PTy(FTy 5,F16)))), Apply (Call ("dfn'LDR",ATy(qTy,PTy(uTy,qTy)), - Var("v99",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), - (Call("LH",CTy"Load",Var("v100",PTy(FTy 5,PTy(FTy 5,F16)))), + Var("v100",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + (Call("LH",CTy"Load",Var("v101",PTy(FTy 5,PTy(FTy 5,F16)))), Apply (Call ("dfn'LH",ATy(qTy,PTy(uTy,qTy)), - Var("v100",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + Var("v101",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), (Call - ("LHU",CTy"Load",Var("v101",PTy(FTy 5,PTy(FTy 5,F16)))), + ("LHU",CTy"Load",Var("v102",PTy(FTy 5,PTy(FTy 5,F16)))), Apply (Call ("dfn'LHU",ATy(qTy,PTy(uTy,qTy)), - Var("v101",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), - (Call("LL",CTy"Load",Var("v102",PTy(FTy 5,PTy(FTy 5,F16)))), + Var("v102",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + (Call("LL",CTy"Load",Var("v103",PTy(FTy 5,PTy(FTy 5,F16)))), Apply (Call ("dfn'LL",ATy(qTy,PTy(uTy,qTy)), - Var("v102",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + Var("v103",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), (Call - ("LLD",CTy"Load",Var("v103",PTy(FTy 5,PTy(FTy 5,F16)))), + ("LLD",CTy"Load",Var("v104",PTy(FTy 5,PTy(FTy 5,F16)))), Apply (Call ("dfn'LLD",ATy(qTy,PTy(uTy,qTy)), - Var("v103",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), - (Call("LW",CTy"Load",Var("v104",PTy(FTy 5,PTy(FTy 5,F16)))), + Var("v104",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + (Call("LW",CTy"Load",Var("v105",PTy(FTy 5,PTy(FTy 5,F16)))), Apply (Call ("dfn'LW",ATy(qTy,PTy(uTy,qTy)), - Var("v104",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + Var("v105",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), (Call - ("LWL",CTy"Load",Var("v105",PTy(FTy 5,PTy(FTy 5,F16)))), + ("LWL",CTy"Load",Var("v106",PTy(FTy 5,PTy(FTy 5,F16)))), Apply (Call ("dfn'LWL",ATy(qTy,PTy(uTy,qTy)), - Var("v105",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + Var("v106",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), (Call - ("LWR",CTy"Load",Var("v106",PTy(FTy 5,PTy(FTy 5,F16)))), + ("LWR",CTy"Load",Var("v107",PTy(FTy 5,PTy(FTy 5,F16)))), Apply (Call ("dfn'LWR",ATy(qTy,PTy(uTy,qTy)), - Var("v106",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + Var("v107",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), (Call - ("LWU",CTy"Load",Var("v107",PTy(FTy 5,PTy(FTy 5,F16)))), + ("LWU",CTy"Load",Var("v108",PTy(FTy 5,PTy(FTy 5,F16)))), Apply (Call ("dfn'LWU",ATy(qTy,PTy(uTy,qTy)), - Var("v107",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state"))])), - (Call("MultDiv",CTy"instruction",Var("v108",CTy"MultDiv")), - CS(Var("v108",CTy"MultDiv"), - [(Call("DDIV",CTy"MultDiv",Var("v109",PTy(FTy 5,FTy 5))), + Var("v108",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state"))])), + (Call("MultDiv",CTy"instruction",Var("v109",CTy"MultDiv")), + CS(Var("v109",CTy"MultDiv"), + [(Call("DDIV",CTy"MultDiv",Var("v110",PTy(FTy 5,FTy 5))), Apply (Call ("dfn'DDIV",ATy(qTy,PTy(uTy,qTy)), - Var("v109",PTy(FTy 5,FTy 5))),qVar"state")), - (Call("DDIVU",CTy"MultDiv",Var("v110",PTy(FTy 5,FTy 5))), + Var("v110",PTy(FTy 5,FTy 5))),qVar"state")), + (Call("DDIVU",CTy"MultDiv",Var("v111",PTy(FTy 5,FTy 5))), Apply (Call ("dfn'DDIVU",ATy(qTy,PTy(uTy,qTy)), - Var("v110",PTy(FTy 5,FTy 5))),qVar"state")), - (Call("DIV",CTy"MultDiv",Var("v111",PTy(FTy 5,FTy 5))), + Var("v111",PTy(FTy 5,FTy 5))),qVar"state")), + (Call("DIV",CTy"MultDiv",Var("v112",PTy(FTy 5,FTy 5))), Apply (Call ("dfn'DIV",ATy(qTy,PTy(uTy,qTy)), - Var("v111",PTy(FTy 5,FTy 5))),qVar"state")), - (Call("DIVU",CTy"MultDiv",Var("v112",PTy(FTy 5,FTy 5))), + Var("v112",PTy(FTy 5,FTy 5))),qVar"state")), + (Call("DIVU",CTy"MultDiv",Var("v113",PTy(FTy 5,FTy 5))), Apply (Call ("dfn'DIVU",ATy(qTy,PTy(uTy,qTy)), - Var("v112",PTy(FTy 5,FTy 5))),qVar"state")), - (Call("DMULT",CTy"MultDiv",Var("v113",PTy(FTy 5,FTy 5))), + Var("v113",PTy(FTy 5,FTy 5))),qVar"state")), + (Call("DMULT",CTy"MultDiv",Var("v114",PTy(FTy 5,FTy 5))), Apply (Call ("dfn'DMULT",ATy(qTy,PTy(uTy,qTy)), - Var("v113",PTy(FTy 5,FTy 5))),qVar"state")), - (Call("DMULTU",CTy"MultDiv",Var("v114",PTy(FTy 5,FTy 5))), + Var("v114",PTy(FTy 5,FTy 5))),qVar"state")), + (Call("DMULTU",CTy"MultDiv",Var("v115",PTy(FTy 5,FTy 5))), Apply (Call ("dfn'DMULTU",ATy(qTy,PTy(uTy,qTy)), - Var("v114",PTy(FTy 5,FTy 5))),qVar"state")), - (Call("MADD",CTy"MultDiv",Var("v115",PTy(FTy 5,FTy 5))), + Var("v115",PTy(FTy 5,FTy 5))),qVar"state")), + (Call("MADD",CTy"MultDiv",Var("v116",PTy(FTy 5,FTy 5))), Apply (Call ("dfn'MADD",ATy(qTy,PTy(uTy,qTy)), - Var("v115",PTy(FTy 5,FTy 5))),qVar"state")), - (Call("MADDU",CTy"MultDiv",Var("v116",PTy(FTy 5,FTy 5))), + Var("v116",PTy(FTy 5,FTy 5))),qVar"state")), + (Call("MADDU",CTy"MultDiv",Var("v117",PTy(FTy 5,FTy 5))), Apply (Call ("dfn'MADDU",ATy(qTy,PTy(uTy,qTy)), - Var("v116",PTy(FTy 5,FTy 5))),qVar"state")), - (Call("MFHI",CTy"MultDiv",Var("v117",FTy 5)), + Var("v117",PTy(FTy 5,FTy 5))),qVar"state")), + (Call("MFHI",CTy"MultDiv",Var("v118",FTy 5)), Apply (Call - ("dfn'MFHI",ATy(qTy,PTy(uTy,qTy)),Var("v117",FTy 5)), + ("dfn'MFHI",ATy(qTy,PTy(uTy,qTy)),Var("v118",FTy 5)), qVar"state")), - (Call("MFLO",CTy"MultDiv",Var("v118",FTy 5)), + (Call("MFLO",CTy"MultDiv",Var("v119",FTy 5)), Apply (Call - ("dfn'MFLO",ATy(qTy,PTy(uTy,qTy)),Var("v118",FTy 5)), + ("dfn'MFLO",ATy(qTy,PTy(uTy,qTy)),Var("v119",FTy 5)), qVar"state")), - (Call("MSUB",CTy"MultDiv",Var("v119",PTy(FTy 5,FTy 5))), + (Call("MSUB",CTy"MultDiv",Var("v120",PTy(FTy 5,FTy 5))), Apply (Call ("dfn'MSUB",ATy(qTy,PTy(uTy,qTy)), - Var("v119",PTy(FTy 5,FTy 5))),qVar"state")), - (Call("MSUBU",CTy"MultDiv",Var("v120",PTy(FTy 5,FTy 5))), + Var("v120",PTy(FTy 5,FTy 5))),qVar"state")), + (Call("MSUBU",CTy"MultDiv",Var("v121",PTy(FTy 5,FTy 5))), Apply (Call ("dfn'MSUBU",ATy(qTy,PTy(uTy,qTy)), - Var("v120",PTy(FTy 5,FTy 5))),qVar"state")), - (Call("MTHI",CTy"MultDiv",Var("v121",FTy 5)), + Var("v121",PTy(FTy 5,FTy 5))),qVar"state")), + (Call("MTHI",CTy"MultDiv",Var("v122",FTy 5)), Apply (Call - ("dfn'MTHI",ATy(qTy,PTy(uTy,qTy)),Var("v121",FTy 5)), + ("dfn'MTHI",ATy(qTy,PTy(uTy,qTy)),Var("v122",FTy 5)), qVar"state")), - (Call("MTLO",CTy"MultDiv",Var("v122",FTy 5)), + (Call("MTLO",CTy"MultDiv",Var("v123",FTy 5)), Apply (Call - ("dfn'MTLO",ATy(qTy,PTy(uTy,qTy)),Var("v122",FTy 5)), + ("dfn'MTLO",ATy(qTy,PTy(uTy,qTy)),Var("v123",FTy 5)), qVar"state")), (Call ("MUL",CTy"MultDiv", - Var("v123",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Var("v124",PTy(FTy 5,PTy(FTy 5,FTy 5)))), Apply (Call ("dfn'MUL",ATy(qTy,PTy(uTy,qTy)), - Var("v123",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), - (Call("MULT",CTy"MultDiv",Var("v124",PTy(FTy 5,FTy 5))), + Var("v124",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + (Call("MULT",CTy"MultDiv",Var("v125",PTy(FTy 5,FTy 5))), Apply (Call ("dfn'MULT",ATy(qTy,PTy(uTy,qTy)), - Var("v124",PTy(FTy 5,FTy 5))),qVar"state")), - (Call("MULTU",CTy"MultDiv",Var("v125",PTy(FTy 5,FTy 5))), + Var("v125",PTy(FTy 5,FTy 5))),qVar"state")), + (Call("MULTU",CTy"MultDiv",Var("v126",PTy(FTy 5,FTy 5))), Apply (Call ("dfn'MULTU",ATy(qTy,PTy(uTy,qTy)), - Var("v125",PTy(FTy 5,FTy 5))),qVar"state"))])), - (Call("SDC2",CTy"instruction",Var("v126",CTy"SDC2")), - CS(Var("v126",CTy"SDC2"), - [(Call("CHERISDC2",CTy"SDC2",Var("v127",CTy"CHERISDC2")), - CS(Var("v127",CTy"CHERISDC2"), + Var("v126",PTy(FTy 5,FTy 5))),qVar"state"))])), + (Call("SDC2",CTy"instruction",Var("v127",CTy"SDC2")), + CS(Var("v127",CTy"SDC2"), + [(Call("CHERISDC2",CTy"SDC2",Var("v128",CTy"CHERISDC2")), + CS(Var("v128",CTy"CHERISDC2"), [(Call ("CSC",CTy"CHERISDC2", - Var("v128",PTy(FTy 5,PTy(FTy 5,PTy(FTy 5,FTy 11))))), + Var("v129",PTy(FTy 5,PTy(FTy 5,PTy(FTy 5,FTy 11))))), Apply (Call ("dfn'CSC",ATy(qTy,PTy(uTy,qTy)), - Var("v128", + Var("v129", PTy(FTy 5,PTy(FTy 5,PTy(FTy 5,FTy 11))))), qVar"state"))]))])), - (Call("SWC2",CTy"instruction",Var("v129",CTy"SWC2")), - CS(Var("v129",CTy"SWC2"), - [(Call("CHERISWC2",CTy"SWC2",Var("v130",CTy"CHERISWC2")), - CS(Var("v130",CTy"CHERISWC2"), + (Call("SWC2",CTy"instruction",Var("v130",CTy"SWC2")), + CS(Var("v130",CTy"SWC2"), + [(Call("CHERISWC2",CTy"SWC2",Var("v131",CTy"CHERISWC2")), + CS(Var("v131",CTy"CHERISWC2"), [(Call ("CSCD",CTy"CHERISWC2", - Var("v131",PTy(FTy 5,PTy(FTy 5,PTy(FTy 5,F8))))), + Var("v132",PTy(FTy 5,PTy(FTy 5,PTy(FTy 5,F8))))), Apply (Call ("dfn'CSCD",ATy(qTy,PTy(uTy,qTy)), - Var("v131",PTy(FTy 5,PTy(FTy 5,PTy(FTy 5,F8))))), + Var("v132",PTy(FTy 5,PTy(FTy 5,PTy(FTy 5,F8))))), qVar"state")), (Call ("CStore",CTy"CHERISWC2", - Var("v132", + Var("v133", PTy(FTy 5,PTy(FTy 5,PTy(FTy 5,PTy(F8,FTy 2)))))), Apply (Call ("dfn'CStore",ATy(qTy,PTy(uTy,qTy)), - Var("v132", + Var("v133", PTy(FTy 5, PTy(FTy 5,PTy(FTy 5,PTy(F8,FTy 2)))))), qVar"state"))]))])), - (Call("Shift",CTy"instruction",Var("v133",CTy"Shift")), - CS(Var("v133",CTy"Shift"), + (Call("Shift",CTy"instruction",Var("v134",CTy"Shift")), + CS(Var("v134",CTy"Shift"), [(Call ("DSLL",CTy"Shift", - Var("v134",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Var("v135",PTy(FTy 5,PTy(FTy 5,FTy 5)))), Apply (Call ("dfn'DSLL",ATy(qTy,PTy(uTy,qTy)), - Var("v134",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + Var("v135",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), (Call ("DSLL32",CTy"Shift", - Var("v135",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Var("v136",PTy(FTy 5,PTy(FTy 5,FTy 5)))), Apply (Call ("dfn'DSLL32",ATy(qTy,PTy(uTy,qTy)), - Var("v135",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + Var("v136",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), (Call ("DSLLV",CTy"Shift", - Var("v136",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Var("v137",PTy(FTy 5,PTy(FTy 5,FTy 5)))), Apply (Call ("dfn'DSLLV",ATy(qTy,PTy(uTy,qTy)), - Var("v136",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + Var("v137",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), (Call ("DSRA",CTy"Shift", - Var("v137",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Var("v138",PTy(FTy 5,PTy(FTy 5,FTy 5)))), Apply (Call ("dfn'DSRA",ATy(qTy,PTy(uTy,qTy)), - Var("v137",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + Var("v138",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), (Call ("DSRA32",CTy"Shift", - Var("v138",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Var("v139",PTy(FTy 5,PTy(FTy 5,FTy 5)))), Apply (Call ("dfn'DSRA32",ATy(qTy,PTy(uTy,qTy)), - Var("v138",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + Var("v139",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), (Call ("DSRAV",CTy"Shift", - Var("v139",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Var("v140",PTy(FTy 5,PTy(FTy 5,FTy 5)))), Apply (Call ("dfn'DSRAV",ATy(qTy,PTy(uTy,qTy)), - Var("v139",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + Var("v140",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), (Call ("DSRL",CTy"Shift", - Var("v140",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Var("v141",PTy(FTy 5,PTy(FTy 5,FTy 5)))), Apply (Call ("dfn'DSRL",ATy(qTy,PTy(uTy,qTy)), - Var("v140",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + Var("v141",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), (Call ("DSRL32",CTy"Shift", - Var("v141",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Var("v142",PTy(FTy 5,PTy(FTy 5,FTy 5)))), Apply (Call ("dfn'DSRL32",ATy(qTy,PTy(uTy,qTy)), - Var("v141",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + Var("v142",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), (Call ("DSRLV",CTy"Shift", - Var("v142",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Var("v143",PTy(FTy 5,PTy(FTy 5,FTy 5)))), Apply (Call ("dfn'DSRLV",ATy(qTy,PTy(uTy,qTy)), - Var("v142",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + Var("v143",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), (Call ("SLL",CTy"Shift", - Var("v143",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Var("v144",PTy(FTy 5,PTy(FTy 5,FTy 5)))), Apply (Call ("dfn'SLL",ATy(qTy,PTy(uTy,qTy)), - Var("v143",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + Var("v144",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), (Call ("SLLV",CTy"Shift", - Var("v144",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Var("v145",PTy(FTy 5,PTy(FTy 5,FTy 5)))), Apply (Call ("dfn'SLLV",ATy(qTy,PTy(uTy,qTy)), - Var("v144",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + Var("v145",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), (Call ("SRA",CTy"Shift", - Var("v145",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Var("v146",PTy(FTy 5,PTy(FTy 5,FTy 5)))), Apply (Call ("dfn'SRA",ATy(qTy,PTy(uTy,qTy)), - Var("v145",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + Var("v146",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), (Call ("SRAV",CTy"Shift", - Var("v146",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Var("v147",PTy(FTy 5,PTy(FTy 5,FTy 5)))), Apply (Call ("dfn'SRAV",ATy(qTy,PTy(uTy,qTy)), - Var("v146",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + Var("v147",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), (Call ("SRL",CTy"Shift", - Var("v147",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Var("v148",PTy(FTy 5,PTy(FTy 5,FTy 5)))), Apply (Call ("dfn'SRL",ATy(qTy,PTy(uTy,qTy)), - Var("v147",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), + Var("v148",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state")), (Call ("SRLV",CTy"Shift", - Var("v148",PTy(FTy 5,PTy(FTy 5,FTy 5)))), + Var("v149",PTy(FTy 5,PTy(FTy 5,FTy 5)))), Apply (Call ("dfn'SRLV",ATy(qTy,PTy(uTy,qTy)), - Var("v148",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state"))])), - (Call("Store",CTy"instruction",Var("v149",CTy"Store")), - CS(Var("v149",CTy"Store"), + Var("v149",PTy(FTy 5,PTy(FTy 5,FTy 5)))),qVar"state"))])), + (Call("Store",CTy"instruction",Var("v150",CTy"Store")), + CS(Var("v150",CTy"Store"), [(Call - ("SB",CTy"Store",Var("v150",PTy(FTy 5,PTy(FTy 5,F16)))), + ("SB",CTy"Store",Var("v151",PTy(FTy 5,PTy(FTy 5,F16)))), Apply (Call ("dfn'SB",ATy(qTy,PTy(uTy,qTy)), - Var("v150",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + Var("v151",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), (Call - ("SC",CTy"Store",Var("v151",PTy(FTy 5,PTy(FTy 5,F16)))), + ("SC",CTy"Store",Var("v152",PTy(FTy 5,PTy(FTy 5,F16)))), Apply (Call ("dfn'SC",ATy(qTy,PTy(uTy,qTy)), - Var("v151",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + Var("v152",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), (Call - ("SCD",CTy"Store",Var("v152",PTy(FTy 5,PTy(FTy 5,F16)))), + ("SCD",CTy"Store",Var("v153",PTy(FTy 5,PTy(FTy 5,F16)))), Apply (Call ("dfn'SCD",ATy(qTy,PTy(uTy,qTy)), - Var("v152",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + Var("v153",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), (Call - ("SD",CTy"Store",Var("v153",PTy(FTy 5,PTy(FTy 5,F16)))), + ("SD",CTy"Store",Var("v154",PTy(FTy 5,PTy(FTy 5,F16)))), Apply (Call ("dfn'SD",ATy(qTy,PTy(uTy,qTy)), - Var("v153",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + Var("v154",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), (Call - ("SDL",CTy"Store",Var("v154",PTy(FTy 5,PTy(FTy 5,F16)))), + ("SDL",CTy"Store",Var("v155",PTy(FTy 5,PTy(FTy 5,F16)))), Apply (Call ("dfn'SDL",ATy(qTy,PTy(uTy,qTy)), - Var("v154",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + Var("v155",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), (Call - ("SDR",CTy"Store",Var("v155",PTy(FTy 5,PTy(FTy 5,F16)))), + ("SDR",CTy"Store",Var("v156",PTy(FTy 5,PTy(FTy 5,F16)))), Apply (Call ("dfn'SDR",ATy(qTy,PTy(uTy,qTy)), - Var("v155",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + Var("v156",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), (Call - ("SH",CTy"Store",Var("v156",PTy(FTy 5,PTy(FTy 5,F16)))), + ("SH",CTy"Store",Var("v157",PTy(FTy 5,PTy(FTy 5,F16)))), Apply (Call ("dfn'SH",ATy(qTy,PTy(uTy,qTy)), - Var("v156",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + Var("v157",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), (Call - ("SW",CTy"Store",Var("v157",PTy(FTy 5,PTy(FTy 5,F16)))), + ("SW",CTy"Store",Var("v158",PTy(FTy 5,PTy(FTy 5,F16)))), Apply (Call ("dfn'SW",ATy(qTy,PTy(uTy,qTy)), - Var("v157",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + Var("v158",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), (Call - ("SWL",CTy"Store",Var("v158",PTy(FTy 5,PTy(FTy 5,F16)))), + ("SWL",CTy"Store",Var("v159",PTy(FTy 5,PTy(FTy 5,F16)))), Apply (Call ("dfn'SWL",ATy(qTy,PTy(uTy,qTy)), - Var("v158",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), + Var("v159",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state")), (Call - ("SWR",CTy"Store",Var("v159",PTy(FTy 5,PTy(FTy 5,F16)))), + ("SWR",CTy"Store",Var("v160",PTy(FTy 5,PTy(FTy 5,F16)))), Apply (Call ("dfn'SWR",ATy(qTy,PTy(uTy,qTy)), - Var("v159",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state"))])), - (Call("Trap",CTy"instruction",Var("v160",CTy"Trap")), - CS(Var("v160",CTy"Trap"), - [(Call("TEQ",CTy"Trap",Var("v161",PTy(FTy 5,FTy 5))), + Var("v160",PTy(FTy 5,PTy(FTy 5,F16)))),qVar"state"))])), + (Call("Trap",CTy"instruction",Var("v161",CTy"Trap")), + CS(Var("v161",CTy"Trap"), + [(Call("TEQ",CTy"Trap",Var("v162",PTy(FTy 5,FTy 5))), Apply (Call ("dfn'TEQ",ATy(qTy,PTy(uTy,qTy)), - Var("v161",PTy(FTy 5,FTy 5))),qVar"state")), - (Call("TEQI",CTy"Trap",Var("v162",PTy(FTy 5,F16))), + Var("v162",PTy(FTy 5,FTy 5))),qVar"state")), + (Call("TEQI",CTy"Trap",Var("v163",PTy(FTy 5,F16))), Apply (Call ("dfn'TEQI",ATy(qTy,PTy(uTy,qTy)), - Var("v162",PTy(FTy 5,F16))),qVar"state")), - (Call("TGE",CTy"Trap",Var("v163",PTy(FTy 5,FTy 5))), + Var("v163",PTy(FTy 5,F16))),qVar"state")), + (Call("TGE",CTy"Trap",Var("v164",PTy(FTy 5,FTy 5))), Apply (Call ("dfn'TGE",ATy(qTy,PTy(uTy,qTy)), - Var("v163",PTy(FTy 5,FTy 5))),qVar"state")), - (Call("TGEI",CTy"Trap",Var("v164",PTy(FTy 5,F16))), + Var("v164",PTy(FTy 5,FTy 5))),qVar"state")), + (Call("TGEI",CTy"Trap",Var("v165",PTy(FTy 5,F16))), Apply (Call ("dfn'TGEI",ATy(qTy,PTy(uTy,qTy)), - Var("v164",PTy(FTy 5,F16))),qVar"state")), - (Call("TGEIU",CTy"Trap",Var("v165",PTy(FTy 5,F16))), + Var("v165",PTy(FTy 5,F16))),qVar"state")), + (Call("TGEIU",CTy"Trap",Var("v166",PTy(FTy 5,F16))), Apply (Call ("dfn'TGEIU",ATy(qTy,PTy(uTy,qTy)), - Var("v165",PTy(FTy 5,F16))),qVar"state")), - (Call("TGEU",CTy"Trap",Var("v166",PTy(FTy 5,FTy 5))), + Var("v166",PTy(FTy 5,F16))),qVar"state")), + (Call("TGEU",CTy"Trap",Var("v167",PTy(FTy 5,FTy 5))), Apply (Call ("dfn'TGEU",ATy(qTy,PTy(uTy,qTy)), - Var("v166",PTy(FTy 5,FTy 5))),qVar"state")), - (Call("TLT",CTy"Trap",Var("v167",PTy(FTy 5,FTy 5))), + Var("v167",PTy(FTy 5,FTy 5))),qVar"state")), + (Call("TLT",CTy"Trap",Var("v168",PTy(FTy 5,FTy 5))), Apply (Call ("dfn'TLT",ATy(qTy,PTy(uTy,qTy)), - Var("v167",PTy(FTy 5,FTy 5))),qVar"state")), - (Call("TLTI",CTy"Trap",Var("v168",PTy(FTy 5,F16))), + Var("v168",PTy(FTy 5,FTy 5))),qVar"state")), + (Call("TLTI",CTy"Trap",Var("v169",PTy(FTy 5,F16))), Apply (Call ("dfn'TLTI",ATy(qTy,PTy(uTy,qTy)), - Var("v168",PTy(FTy 5,F16))),qVar"state")), - (Call("TLTIU",CTy"Trap",Var("v169",PTy(FTy 5,F16))), + Var("v169",PTy(FTy 5,F16))),qVar"state")), + (Call("TLTIU",CTy"Trap",Var("v170",PTy(FTy 5,F16))), Apply (Call ("dfn'TLTIU",ATy(qTy,PTy(uTy,qTy)), - Var("v169",PTy(FTy 5,F16))),qVar"state")), - (Call("TLTU",CTy"Trap",Var("v170",PTy(FTy 5,FTy 5))), + Var("v170",PTy(FTy 5,F16))),qVar"state")), + (Call("TLTU",CTy"Trap",Var("v171",PTy(FTy 5,FTy 5))), Apply (Call ("dfn'TLTU",ATy(qTy,PTy(uTy,qTy)), - Var("v170",PTy(FTy 5,FTy 5))),qVar"state")), - (Call("TNE",CTy"Trap",Var("v171",PTy(FTy 5,FTy 5))), + Var("v171",PTy(FTy 5,FTy 5))),qVar"state")), + (Call("TNE",CTy"Trap",Var("v172",PTy(FTy 5,FTy 5))), Apply (Call ("dfn'TNE",ATy(qTy,PTy(uTy,qTy)), - Var("v171",PTy(FTy 5,FTy 5))),qVar"state")), - (Call("TNEI",CTy"Trap",Var("v172",PTy(FTy 5,F16))), + Var("v172",PTy(FTy 5,FTy 5))),qVar"state")), + (Call("TNEI",CTy"Trap",Var("v173",PTy(FTy 5,F16))), Apply (Call ("dfn'TNEI",ATy(qTy,PTy(uTy,qTy)), - Var("v172",PTy(FTy 5,F16))),qVar"state"))]))]))) + Var("v173",PTy(FTy 5,F16))),qVar"state"))]))]))) ; val COP2Decode_def = Def ("COP2Decode",Var("v",FTy 26), @@ -28554,6 +29100,27 @@ val COP2Decode_def = Def LL[bVar"b'15",bVar"b'14", bVar"b'13",bVar"b'12", bVar"b'11"])]))), + (Bop(And,Mop(Not,bVar"b'22"), + Bop(And,bVar"b'21", + Bop(And,Mop(Not,bVar"b'2"), + Bop(And,Mop(Not,bVar"b'1"), + Mop(Not,bVar"b'0"))))), + Call + ("CSet",CTy"CHERICOP2", + Call + ("CIncOffset",CTy"CSet", + TP[Mop(Cast(FTy 5), + LL[bVar"b'20",bVar"b'19", + bVar"b'18",bVar"b'17", + bVar"b'16"]), + Mop(Cast(FTy 5), + LL[bVar"b'15",bVar"b'14", + bVar"b'13",bVar"b'12", + bVar"b'11"]), + Mop(Cast(FTy 5), + LL[bVar"b'10",bVar"b'9", + bVar"b'8",bVar"b'7", + bVar"b'6"])]))), (Bop(And,Mop(Not,bVar"b'22"), Bop(And,bVar"b'21", Bop(And,Mop(Not,bVar"b'2"), @@ -33071,6 +33638,15 @@ val COP2InstructionToString_def = Def ("op3r",sTy, TP[LS"cincbase",Var("cd",FTy 5),Var("cb",FTy 5), Var("rt",FTy 5)])), + (Call + ("CSet",CTy"CHERICOP2", + Call + ("CIncOffset",CTy"CSet", + TP[Var("cd",FTy 5),Var("cb",FTy 5),Var("rt",FTy 5)])), + Call + ("op3r",sTy, + TP[LS"cincoffset",Var("cd",FTy 5),Var("cb",FTy 5), + Var("rt",FTy 5)])), (Call ("CSet",CTy"CHERICOP2", Call @@ -35281,9 +35857,7 @@ val Next_def = Def TP[Mop(Fst, Apply (Const - ("CP0", - ATy(qTy, - PTy(CTy"CP0__renamed__",qTy))), + ("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"s")), Bop(Add, Dest @@ -35292,10 +35866,9 @@ val Next_def = Def Apply (Const ("CP0", - ATy(qTy, - PTy(CTy"CP0__renamed__", - qTy))),qVar"s"))), - LW(1,32))])),qVar"s")))))) + ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"s"))),LW(1,32))])), + qVar"s")))))) ; val hasCP2_def = Def0 ("hasCP2",LT) ; @@ -35516,11 +36089,9 @@ val initMips_def = Def ("initMips",TP[nVar"pc",nVar"uart"], Close (qVar"state", - Let(Var("v",CTy"CP0__renamed__"), + Let(Var("v",CTy"CP0"), Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), - qVar"state")), + Apply(Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"state")), Let(qVar"s", Mop(Snd, Apply @@ -35528,19 +36099,17 @@ val initMips_def = Def ("write'CP0",ATy(qTy,PTy(uTy,qTy)), Rupd ("Config", - TP[Var("v",CTy"CP0__renamed__"), + TP[Var("v",CTy"CP0"), Rupd ("M", TP[Dest ("Config",CTy"ConfigRegister", - Var("v",CTy"CP0__renamed__")),LT])])), + Var("v",CTy"CP0")),LT])])), qVar"state")), - Let(Var("v",CTy"CP0__renamed__"), + Let(Var("v",CTy"CP0"), Mop(Fst, Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), - qVar"s")), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s")), Let(qVar"s", Mop(Snd, Apply @@ -35548,20 +36117,18 @@ val initMips_def = Def ("write'CP0",ATy(qTy,PTy(uTy,qTy)), Rupd ("Config", - TP[Var("v",CTy"CP0__renamed__"), + TP[Var("v",CTy"CP0"), Rupd ("BE", TP[Dest ("Config", CTy"ConfigRegister", - Var("v",CTy"CP0__renamed__")), - LT])])),qVar"s")), - Let(Var("v",CTy"CP0__renamed__"), + Var("v",CTy"CP0")),LT])])), + qVar"s")), + Let(Var("v",CTy"CP0"), Mop(Fst, Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0__renamed__",qTy))), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"s")), Let(qVar"s", Mop(Snd, @@ -35570,23 +36137,21 @@ val initMips_def = Def ("write'CP0",ATy(qTy,PTy(uTy,qTy)), Rupd ("Config", - TP[Var("v",CTy"CP0__renamed__"), + TP[Var("v",CTy"CP0"), Rupd ("MT", TP[Dest ("Config", CTy"ConfigRegister", - Var("v", - CTy"CP0__renamed__")), + Var("v",CTy"CP0")), LW(1,3)])])),qVar"s")), - Let(Var("v",CTy"CP0__renamed__"), + Let(Var("v",CTy"CP0"), Mop(Fst, Apply (Const ("CP0", - ATy(qTy, - PTy(CTy"CP0__renamed__", - qTy))),qVar"s")), + ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"s")), Let(qVar"s", Mop(Snd, Apply @@ -35595,25 +36160,24 @@ val initMips_def = Def ATy(qTy,PTy(uTy,qTy)), Rupd ("Config", - TP[Var("v", - CTy"CP0__renamed__"), + TP[Var("v",CTy"CP0"), Rupd ("AR", TP[Dest ("Config", CTy"ConfigRegister", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LW(0,3)])])), qVar"s")), - Let(Var("v",CTy"CP0__renamed__"), + Let(Var("v",CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", - qTy))),qVar"s")), + PTy(CTy"CP0",qTy))), + qVar"s")), Let(qVar"s", Mop(Snd, Apply @@ -35624,24 +36188,23 @@ val initMips_def = Def Rupd ("Config", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("AT", TP[Dest ("Config", CTy"ConfigRegister", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LW(2,2)])])), qVar"s")), - Let(Var("v", - CTy"CP0__renamed__"), + Let(Var("v",CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -35655,24 +36218,23 @@ val initMips_def = Def Rupd ("Config1", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("M", TP[Dest ("Config1", CTy"ConfigRegister1", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LT])])), qVar"s")), - Let(Var("v", - CTy"CP0__renamed__"), + Let(Var("v",CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -35686,25 +36248,25 @@ val initMips_def = Def Rupd ("Config1", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("MMUSize", TP[Dest ("Config1", CTy"ConfigRegister1", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LW(15, 6)])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -35718,25 +36280,25 @@ val initMips_def = Def Rupd ("Config1", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("IS", TP[Dest ("Config1", CTy"ConfigRegister1", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LW(3, 3)])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -35750,25 +36312,25 @@ val initMips_def = Def Rupd ("Config1", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("IL", TP[Dest ("Config1", CTy"ConfigRegister1", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LW(4, 3)])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -35782,25 +36344,25 @@ val initMips_def = Def Rupd ("Config1", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("IA", TP[Dest ("Config1", CTy"ConfigRegister1", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LW(0, 3)])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -35814,25 +36376,25 @@ val initMips_def = Def Rupd ("Config1", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("DS", TP[Dest ("Config1", CTy"ConfigRegister1", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LW(3, 3)])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -35846,25 +36408,25 @@ val initMips_def = Def Rupd ("Config1", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("DL", TP[Dest ("Config1", CTy"ConfigRegister1", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LW(4, 3)])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -35878,25 +36440,25 @@ val initMips_def = Def Rupd ("Config1", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("DA", TP[Dest ("Config1", CTy"ConfigRegister1", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LW(0, 3)])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -35910,26 +36472,26 @@ val initMips_def = Def Rupd ("Config1", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("C2", TP[Dest ("Config1", CTy"ConfigRegister1", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), Const ("hasCP2", bTy)])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -35943,24 +36505,24 @@ val initMips_def = Def Rupd ("Config1", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("MD", TP[Dest ("Config1", CTy"ConfigRegister1", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LF])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -35974,24 +36536,24 @@ val initMips_def = Def Rupd ("Config1", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("PCR", TP[Dest ("Config1", CTy"ConfigRegister1", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LF])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -36005,24 +36567,24 @@ val initMips_def = Def Rupd ("Config1", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("WR", TP[Dest ("Config1", CTy"ConfigRegister1", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LF])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -36036,24 +36598,24 @@ val initMips_def = Def Rupd ("Config1", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("CA", TP[Dest ("Config1", CTy"ConfigRegister1", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LF])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -36067,24 +36629,24 @@ val initMips_def = Def Rupd ("Config1", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("EP", TP[Dest ("Config1", CTy"ConfigRegister1", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LF])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -36098,24 +36660,24 @@ val initMips_def = Def Rupd ("Config1", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("FP", TP[Dest ("Config1", CTy"ConfigRegister1", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LF])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -36129,24 +36691,24 @@ val initMips_def = Def Rupd ("Config2", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("M", TP[Dest ("Config2", CTy"ConfigRegister2", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LT])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -36160,25 +36722,25 @@ val initMips_def = Def Rupd ("Config2", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("TU", TP[Dest ("Config2", CTy"ConfigRegister2", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LW(0, 3)])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -36192,25 +36754,25 @@ val initMips_def = Def Rupd ("Config2", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("TS", TP[Dest ("Config2", CTy"ConfigRegister2", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LW(0, 4)])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -36224,25 +36786,25 @@ val initMips_def = Def Rupd ("Config2", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("TL", TP[Dest ("Config2", CTy"ConfigRegister2", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LW(0, 4)])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -36256,25 +36818,25 @@ val initMips_def = Def Rupd ("Config2", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("TA", TP[Dest ("Config2", CTy"ConfigRegister2", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LW(0, 4)])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -36288,25 +36850,25 @@ val initMips_def = Def Rupd ("Config2", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("SU", TP[Dest ("Config2", CTy"ConfigRegister2", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LW(3, 4)])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -36320,25 +36882,25 @@ val initMips_def = Def Rupd ("Config2", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("SS", TP[Dest ("Config2", CTy"ConfigRegister2", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LW(8, 4)])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -36352,25 +36914,25 @@ val initMips_def = Def Rupd ("Config2", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("SL", TP[Dest ("Config2", CTy"ConfigRegister2", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LW(4, 4)])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -36384,25 +36946,25 @@ val initMips_def = Def Rupd ("Config2", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("SA", TP[Dest ("Config2", CTy"ConfigRegister2", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LW(0, 4)])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -36416,24 +36978,24 @@ val initMips_def = Def Rupd ("Config3", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("M", TP[Dest ("Config3", CTy"ConfigRegister3", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LT])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -36447,24 +37009,24 @@ val initMips_def = Def Rupd ("Config3", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("ULRI", TP[Dest ("Config3", CTy"ConfigRegister3", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LT])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -36478,24 +37040,24 @@ val initMips_def = Def Rupd ("Config3", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("DSPP", TP[Dest ("Config3", CTy"ConfigRegister3", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LF])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -36509,24 +37071,24 @@ val initMips_def = Def Rupd ("Config3", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("LPA", TP[Dest ("Config3", CTy"ConfigRegister3", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LF])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -36540,24 +37102,24 @@ val initMips_def = Def Rupd ("Config3", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("VEIC", TP[Dest ("Config3", CTy"ConfigRegister3", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LF])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -36571,24 +37133,24 @@ val initMips_def = Def Rupd ("Config3", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("VInt", TP[Dest ("Config3", CTy"ConfigRegister3", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LF])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -36602,24 +37164,24 @@ val initMips_def = Def Rupd ("Config3", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("SP", TP[Dest ("Config3", CTy"ConfigRegister3", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LF])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -36633,24 +37195,24 @@ val initMips_def = Def Rupd ("Config3", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("MT", TP[Dest ("Config3", CTy"ConfigRegister3", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LF])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -36664,24 +37226,24 @@ val initMips_def = Def Rupd ("Config3", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("SM", TP[Dest ("Config3", CTy"ConfigRegister3", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LF])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -36695,24 +37257,24 @@ val initMips_def = Def Rupd ("Config3", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("TL", TP[Dest ("Config3", CTy"ConfigRegister3", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LF])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -36726,25 +37288,25 @@ val initMips_def = Def Rupd ("Config6", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("TLBSize", TP[Dest ("Config6", CTy"ConfigRegister6", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LW(143, 16)])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -36758,24 +37320,24 @@ val initMips_def = Def Rupd ("Config6", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("LTLB", TP[Dest ("Config6", CTy"ConfigRegister6", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LF])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -36789,7 +37351,7 @@ val initMips_def = Def Rupd ("Status", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Call ("write'reg'StatusRegister", CTy"StatusRegister", @@ -36797,18 +37359,18 @@ val initMips_def = Def ("Status", CTy"StatusRegister", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LW(0, 32)])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -36822,24 +37384,24 @@ val initMips_def = Def Rupd ("Status", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("BEV", TP[Dest ("Status", CTy"StatusRegister", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LT])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -36853,25 +37415,25 @@ val initMips_def = Def Rupd ("Status", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("KSU", TP[Dest ("Status", CTy"StatusRegister", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LW(0, 2)])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -36885,24 +37447,24 @@ val initMips_def = Def Rupd ("Status", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("EXL", TP[Dest ("Status", CTy"StatusRegister", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LF])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -36916,24 +37478,24 @@ val initMips_def = Def Rupd ("Status", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("ERL", TP[Dest ("Status", CTy"StatusRegister", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LF])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -36947,24 +37509,24 @@ val initMips_def = Def Rupd ("Status", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("KX", TP[Dest ("Status", CTy"StatusRegister", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LT])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -36978,24 +37540,24 @@ val initMips_def = Def Rupd ("Status", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("SX", TP[Dest ("Status", CTy"StatusRegister", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LT])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -37009,14 +37571,14 @@ val initMips_def = Def Rupd ("Status", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("UX", TP[Dest ("Status", CTy"StatusRegister", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LT])])), qVar"s")), Let(qVar"s", @@ -37034,7 +37596,7 @@ val initMips_def = Def (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), LW(0, @@ -37055,7 +37617,7 @@ val initMips_def = Def (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), LW(0, @@ -37076,20 +37638,20 @@ val initMips_def = Def (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), LW(1024, 32)])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -37103,24 +37665,24 @@ val initMips_def = Def Rupd ("Index", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("P", TP[Dest ("Index", CTy"Index", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LF])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -37134,25 +37696,25 @@ val initMips_def = Def Rupd ("Index", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("Index", TP[Dest ("Index", CTy"Index", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LW(0, 8)])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -37166,14 +37728,14 @@ val initMips_def = Def Rupd ("Random", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("Random", TP[Dest ("Random", CTy"Random", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), Mop(Cast F8, Bop(Sub, @@ -37184,13 +37746,13 @@ val initMips_def = Def 1))])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -37204,25 +37766,25 @@ val initMips_def = Def Rupd ("Wired", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Rupd ("Wired", TP[Dest ("Wired", CTy"Wired", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LW(0, 8)])])), qVar"s")), Let(Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Mop(Fst, Apply (Const ("CP0", ATy(qTy, - PTy(CTy"CP0__renamed__", + PTy(CTy"CP0", qTy))), qVar"s")), Let(qVar"s", @@ -37346,7 +37908,7 @@ val initMips_def = Def Rupd ("HWREna", TP[Var("v", - CTy"CP0__renamed__"), + CTy"CP0"), Call ("write'reg'HWREna", CTy"HWREna", @@ -37354,7 +37916,7 @@ val initMips_def = Def ("HWREna", CTy"HWREna", Var("v", - CTy"CP0__renamed__")), + CTy"CP0")), LW(0, 32)])])), qVar"s")))))))))))))))))), From 5957dac98bcfb2225781c667d308a09e3bd5d005 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 14 Jan 2015 16:59:33 +1100 Subject: [PATCH 117/718] Correct a minor indentation glitch --- src/datatype/record/RecordType.sml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/datatype/record/RecordType.sml b/src/datatype/record/RecordType.sml index d97919b3b0..cf76f7186b 100644 --- a/src/datatype/record/RecordType.sml +++ b/src/datatype/record/RecordType.sml @@ -515,9 +515,9 @@ fun prove_recordtype_thms (tyinfo, fields) = let "artificial" constant for special printing of record syntax, and we want this to be preferred where possible. *) - ListPair.app do_fupdfn (fields, fupdfn_terms); - ListPair.app add_record_fupdate (fields, fupdfn_terms); - Parse.overload_on(typename, constructor) + ListPair.app do_fupdfn (fields, fupdfn_terms); + ListPair.app add_record_fupdate (fields, fupdfn_terms); + Parse.overload_on(typename, constructor) end val thm_str_list = From ed6c520b8a8e59ca5996c218769640c5ae38e66a Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 14 Jan 2015 17:02:06 +1100 Subject: [PATCH 118/718] Delete some unused code --- src/datatype/record/RecordType.sml | 4 ---- 1 file changed, 4 deletions(-) diff --git a/src/datatype/record/RecordType.sml b/src/datatype/record/RecordType.sml index cf76f7186b..06ad12246b 100644 --- a/src/datatype/record/RecordType.sml +++ b/src/datatype/record/RecordType.sml @@ -497,10 +497,6 @@ fun prove_recordtype_thms (tyinfo, fields) = let if List.exists (is_substring brss) (typename :: fields) then () else let - fun do_updfn (name0, tm) = let val name = name0 ^ "_update" - in - Parse.overload_on(name, tm) - end fun do_fupdfn (name0, tm) = let val name = name0 ^ "_fupd" in Parse.overload_on(name, tm) From fc3e8b06915c9fd017bb4847b289d3fa7a8c62eb Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 15 Jan 2015 09:53:00 +1100 Subject: [PATCH 119/718] Record dependency of main hol heap on RecordType module --- src/boss/Holmakefile | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/boss/Holmakefile b/src/boss/Holmakefile index a47c9b6526..2f10c3f130 100644 --- a/src/boss/Holmakefile +++ b/src/boss/Holmakefile @@ -6,7 +6,8 @@ TARGET = $(dprot $(HOLDIR)/bin/hol.builder) builder0 = $(HOLDIR)/src/num/termination/numheap boss_deps = listTheory pred_setTheory arithmeticTheory numLib \ - pred_setLib pred_setSimps numSimps optionTheory + pred_setLib pred_setSimps numSimps optionTheory \ + RecordType DEPS = bossLib.uo $(patsubst %,$(dprot $(SIGOBJ)/%.uo),$(boss_deps)) \ $(dprot $(builder0)) From 3bcca9611b90a1bf53b2908fcb249172cc0f2e64 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 15 Jan 2015 13:32:44 +1100 Subject: [PATCH 120/718] Fix the breakage to records and EmitML caused by 6da728bc --- src/emit/EmitML.sml | 139 ++++++++++-------- src/emit/theory_tests/emitrecordScript.sml | 22 +++ src/emit/theory_tests1/Holmakefile | 1 + .../theory_tests1/useEmitRecordScript.sml | 10 ++ tools/sequences/more-theories | 2 + 5 files changed, 116 insertions(+), 58 deletions(-) create mode 100644 src/emit/theory_tests/emitrecordScript.sml create mode 100644 src/emit/theory_tests1/Holmakefile create mode 100644 src/emit/theory_tests1/useEmitRecordScript.sml diff --git a/src/emit/EmitML.sml b/src/emit/EmitML.sml index 760842fcd4..80b3569937 100644 --- a/src/emit/EmitML.sml +++ b/src/emit/EmitML.sml @@ -62,6 +62,7 @@ val int_of_term_hook = ref val is_pair_type = Lib.can pairSyntax.dest_prod; val is_num_literal = Lib.can Literal.relaxed_dest_numeral; +fun nameOfC t = #Name (dest_thy_const t) (*---------------------------------------------------------------------------*) (* Version of dest_string that doesn't care if characters look like *) @@ -596,26 +597,30 @@ fun term_to_ML openthys side ppstrm = and pp_one tm = add_string "()" and pp_nil tm = add_string "[]" and pp_open_comb i (f,args) = - let val is_constr = case Lib.total ConstMapML.apply f - of SOME (true,_,_,_) => true - | _ => false + let val constrname = + case Lib.total ConstMapML.apply f of + SOME (true,_,nm,_) => SOME nm + | _ => NONE in begin_block CONSISTENT 0 ; lparen i maxprec - ; if TypeBase.is_constructor f andalso is_constr + ; if TypeBase.is_constructor f andalso isSome constrname orelse is_fake_constructor f then - (let val fname = fst(dest_const f) handle HOL_ERR _ => - fst(dest_record_vconstr f) - in add_string (fix_name ("", true, fname)) - end; (* pp maxprec f; *) - add_string "("; - begin_block INCONSISTENT 0; - pr_list (pp minprec) - (fn () => add_string ",") - (fn () => add_break(0,0)) args; - end_block(); - add_string ")" - ) + let + val fname = case constrname of + SOME s => s + | _ => fst(dest_record_vconstr f) + in + (* instead of: pp maxprec f; *) + add_string (fix_name ("", true, fname)); + add_string "("; + begin_block INCONSISTENT 0; + pr_list (pp minprec) + (fn () => add_string ",") + (fn () => add_break(0,0)) args; + end_block(); + add_string ")" + end else (begin_block INCONSISTENT 2; pr_list (pp maxprec) (fn () => ()) (fn () => add_break(1,0)) (f::args); @@ -844,21 +849,6 @@ datatype elem | MLSIG of string | MLSTRUCT of string; -(*---------------------------------------------------------------------------*) -(* Fetch the constructors out of a datatype declaration *) -(*---------------------------------------------------------------------------*) - -local open ParseDatatype -in -fun constructors [] = [] - | constructors ((s,Constructors clist)::rst) = clist@constructors rst - | constructors ((s,Record flds)::rst) = [(s, map snd flds)]@constructors rst - -fun constrl [] = [] - | constrl ((s,Constructors clist)::rst) = (s,clist)::constrl rst - | constrl ((s,Record flds)::rst) = (s, [(s,map snd flds)])::constrl rst -end; - (*---------------------------------------------------------------------------*) (* Internal version of elem (nearly identical, except that datatype *) (* declarations have been parsed) and some standard definitions from *) @@ -995,6 +985,28 @@ in () end; +local + open ParseDatatype + fun cmk s = {name = s, terms = Term.decls s} + fun rmk s = + {name = s, terms = Term.decls (RecordType.mk_recordtype_constructor s)} +in +fun constructors decls = + case decls of + [] => [] + | (s, Constructors clist) :: rst => map (cmk o #1) clist @ constructors rst + | (s,Record flds)::rst => rmk s :: constructors rst + +fun constrl [] = [] + | constrl ((s,Constructors clist)::rst) = (s,clist)::constrl rst + | constrl ((s,Record flds)::rst) = + (s, [(RecordType.mk_recordtype_constructor s,map snd flds)])::constrl rst +end; + + + + + fun elemi (DEFN th) (cs,il) = (cs,iDEFN (!reshape_thm_hook th) :: il) | elemi (DEFN_NOSIG th) (cs,il) = (cs,iDEFN_NOSIG (!reshape_thm_hook th)::il) | elemi (DATATYPE q) (cs,il) = @@ -1381,18 +1393,18 @@ fun munge_def_type def = (* been defined in an ancestor theory. *) (*---------------------------------------------------------------------------*) -fun add (is_constr, s) c = +fun add (is_constr, s) {name, terms} = let + fun perterm c = case ConstMapML.exact_peek c of - NONE => let - val {Name,Thy,Ty} = dest_thy_const c - in - ConstMapML.prim_insert(c,(is_constr,s,Name,Ty)) - end - | SOME _ => () + NONE => ConstMapML.prim_insert(c, (is_constr, s, name, type_of c)) + | SOME _ => () +in + List.app perterm terms +end -fun install_consts _ [] = [] - | install_consts s (iDEFN_NOSIG thm::rst) = install_consts s (iDEFN thm::rst) - | install_consts s (iDEFN thm::rst) = +fun install_consts _ [] k = k ([], []) + | install_consts s (iDEFN_NOSIG thm::rst) k = install_consts s (iDEFN thm::rst) k + | install_consts s (iDEFN thm::rst) k = let val clist0 = munge_def_type thm val clist = (* IN is only allowed to be defined in the setML module/structure; @@ -1400,22 +1412,34 @@ fun install_consts _ [] = [] *) if s <> "set" then filter (not o same_const IN_tm) clist0 else clist0 - val _ = List.app (add (false, s)) clist - in map (pair false) clist @ install_consts s rst + val _ = List.app + (fn c => add (false, s) {name = nameOfC c, terms = [c]}) + clist + in + install_consts s rst + (fn (cs, nms) => k (clist @ cs, map nameOfC clist @ nms)) end - | install_consts s (iDATATYPE ty::rst) = - let val consts = U (map (Term.decls o fst) (constructors ty)) - val _ = List.app (add (true, s)) consts - in map (pair true) consts @ install_consts s rst + | install_consts s (iDATATYPE ty::rst) k = + let + val constrs = constructors ty + val allterms = U (map #terms constrs) + val _ = List.app (add (true, s)) constrs + in + install_consts s rst + (fn (cs,nms) => k (allterms @ cs, map #name constrs @ nms)) end - | install_consts s (iEQDATATYPE (tyvars,ty)::rst) = - let val consts = U (map (Term.decls o fst) (constructors ty)) - val _ = List.app (add (true, s)) consts - in map (pair true) consts @ install_consts s rst + | install_consts s (iEQDATATYPE (tyvars,ty)::rst) k = + let + val constrs = constructors ty + val allterms = U (map #terms constrs) + val _ = List.app (add (true, s)) constrs + in + install_consts s rst + (fn (cs,nms) => k (allterms @ cs, map #name constrs @ nms)) end - | install_consts s (iABSDATATYPE (tyvars,ty)::rst) = - install_consts s (iEQDATATYPE (tyvars,ty)::rst) - | install_consts s (other::rst) = install_consts s rst; + | install_consts s (iABSDATATYPE (tyvars,ty)::rst) k = + install_consts s (iEQDATATYPE (tyvars,ty)::rst) k + | install_consts s (other::rst) k = install_consts s rst k; (*---------------------------------------------------------------------------*) @@ -1501,8 +1525,7 @@ fun emit_adjoin_call thy (consts,pcs) = let S " "; begin_block ppstrm INCONSISTENT 0; Portable.pr_list (pr3 ppstrm) (fn () => S",") (fn () => BR(1,0)) - (map (fn (_, c) => (dest_thy_const c, getdata c)) - consts); + (map (fn c => (dest_thy_const c, getdata c)) consts); end_block ppstrm; NL(); S " ]"; NL(); S " end"; NL(); NL(); @@ -1541,10 +1564,10 @@ fun emit_xML (Ocaml,sigSuffix,structSuffix) p (s,elems_0) = in let val (sigStrm,sigPPstrm) = mk_file_ppstream sigfile val (structStrm,structPPstrm) = mk_file_ppstream structfile - val consts = install_consts s elems + val (consts, usednames) = install_consts s elems (fn x => x) in (pp_sig sigPPstrm (s,elems); - pp_struct structPPstrm (s,elems,map (fst o dest_const o snd) consts); + pp_struct structPPstrm (s,elems,usednames); TextIO.closeOut sigStrm; TextIO.closeOut structStrm; HOL_MESG ("emitML: " ^ s ^ "{" ^ sigSuffix ^ "," ^ structSuffix ^ "}\n\ diff --git a/src/emit/theory_tests/emitrecordScript.sml b/src/emit/theory_tests/emitrecordScript.sml new file mode 100644 index 0000000000..530c201758 --- /dev/null +++ b/src/emit/theory_tests/emitrecordScript.sml @@ -0,0 +1,22 @@ +open HolKernel Parse boolLib bossLib; +open EmitML + +open basis_emitTheory + +val _ = new_theory "emitrecord"; + +val fooq = `foo = <| n : num ; b : bool |>`; +val _ = Datatype fooq + +val literal_def = Define`literal m = <| n := m ; b := T |>`; + +val accessor_def = Define`accessor x = x.n + 1`; + +val _ = eSML "emitRecordTest" + [OPEN ["num"], + MLSIG "type num = numML.num", + DATATYPE fooq, + DEFN literal_def, + DEFN accessor_def] + +val _ = export_theory(); diff --git a/src/emit/theory_tests1/Holmakefile b/src/emit/theory_tests1/Holmakefile new file mode 100644 index 0000000000..7b38322951 --- /dev/null +++ b/src/emit/theory_tests1/Holmakefile @@ -0,0 +1 @@ +INCLUDES = $(protect $(HOLDIR)/src/emit/ML) ../theory_tests diff --git a/src/emit/theory_tests1/useEmitRecordScript.sml b/src/emit/theory_tests1/useEmitRecordScript.sml new file mode 100644 index 0000000000..6602852786 --- /dev/null +++ b/src/emit/theory_tests1/useEmitRecordScript.sml @@ -0,0 +1,10 @@ +open HolKernel Parse boolLib bossLib; + +open emitrecordTheory emitRecordTestML + +val _ = new_theory "useEmitRecord"; + +val _ = save_thm("T", TRUTH) + + +val _ = export_theory(); diff --git a/tools/sequences/more-theories b/tools/sequences/more-theories index 5281ea8dec..d6b83c6012 100644 --- a/tools/sequences/more-theories +++ b/tools/sequences/more-theories @@ -34,6 +34,8 @@ src/emit !!examples/ARM/v4 !!examples/ARM/v7 !!src/emit/ML +!src/emit/theory_tests +!src/emit/theory_tests1 src/hol88 !examples/dev !src/quotient/examples/lambda From 8187d840f551213db72c792615ec9d0fd8925771 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 15 Jan 2015 13:33:38 +1100 Subject: [PATCH 121/718] Regression tests for the fixed part of #224 Still to deal with allowing size to be the name of a record field. --- src/datatype/theory_tests/gh224aScript.sml | 11 +++++++++++ src/datatype/theory_tests/gh224bScript.sml | 10 ++++++++++ 2 files changed, 21 insertions(+) create mode 100644 src/datatype/theory_tests/gh224aScript.sml create mode 100644 src/datatype/theory_tests/gh224bScript.sml diff --git a/src/datatype/theory_tests/gh224aScript.sml b/src/datatype/theory_tests/gh224aScript.sml new file mode 100644 index 0000000000..597b623a2a --- /dev/null +++ b/src/datatype/theory_tests/gh224aScript.sml @@ -0,0 +1,11 @@ +open HolKernel Parse boolLib Datatype + +val _ = new_theory "gh224a"; + +(* val _ = Datatype `bar = <| size : num |>` *) + +val _ = Datatype `A_x = <| y : num |>` +val _ = Datatype `A = <| x : A_x |>` + + +val _ = export_theory(); diff --git a/src/datatype/theory_tests/gh224bScript.sml b/src/datatype/theory_tests/gh224bScript.sml new file mode 100644 index 0000000000..e421a82461 --- /dev/null +++ b/src/datatype/theory_tests/gh224bScript.sml @@ -0,0 +1,10 @@ +open HolKernel Parse boolLib + +open gh224aTheory + +val _ = new_theory "gh224b"; + +val _ = save_thm("T", TRUTH) + + +val _ = export_theory(); From 7db6a7cc3bc4fe0ba113f8e697bec2939f6e7990 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Thu, 15 Jan 2015 11:58:45 +0800 Subject: [PATCH 122/718] prove MEM_toList for sptrees The tactic used resists the obvious simplifications. I don't know why sometimes (t1 >> t2) doesn't work whereas (t1 >- t2 >- t2) does. --- src/patricia/sptreeScript.sml | 35 +++++++++++++++++++++++++++++++++++ 1 file changed, 35 insertions(+) diff --git a/src/patricia/sptreeScript.sml b/src/patricia/sptreeScript.sml index 2311e6a693..841cebb8e0 100644 --- a/src/patricia/sptreeScript.sml +++ b/src/patricia/sptreeScript.sml @@ -775,6 +775,41 @@ val isEmpty_toList = store_thm("isEmpty_toList", ``!t. wf t ==> ((t = LN) <=> (toList t = []))``, rw[toList_def,isEmpty_toListA]) +val lem2 = + SIMP_RULE (srw_ss()) [] (Q.SPECL[`2`,`1`]DIV_MULT) + +fun tac () = ( + (disj2_tac >> qexists_tac`0` >> simp[] >> NO_TAC) ORELSE + (disj2_tac >> + qexists_tac`2*k+1` >> simp[] >> + REWRITE_TAC[Once MULT_COMM] >> simp[MULT_DIV] >> + rw[] >> `F` suffices_by rw[] >> pop_assum mp_tac >> + simp[lemmas,GSYM ODD_EVEN] >> NO_TAC) ORELSE + (disj2_tac >> + qexists_tac`2*k+2` >> simp[] >> + REWRITE_TAC[Once MULT_COMM] >> simp[lem2] >> + rw[] >> `F` suffices_by rw[] >> pop_assum mp_tac >> + simp[lemmas] >> NO_TAC) ORELSE + (metis_tac[])) + +val MEM_toListA = prove( + ``∀t acc x. MEM x (toListA acc t) ⇔ (MEM x acc ∨ ∃k. lookup k t = SOME x)``, + Induct >> simp[toListA_def,lookup_def] >- metis_tac[] >> + rw[EQ_IMP_THM] >> rw[] >> pop_assum mp_tac >> rw[] + >- (tac()) + >- (tac()) + >- (tac()) + >- (tac()) + >- (tac()) + >- (tac()) + >- (tac()) + >- (tac()) + >- (tac())) + +val MEM_toList = store_thm("MEM_toList", + ``∀x t. MEM x (toList t) ⇔ ∃k. lookup k t = SOME x``, + rw[toList_def,MEM_toListA]) + val div2_even_lemma = prove( ``!x. ?n. (x = (n - 1) DIV 2) /\ EVEN n /\ 0 < n``, Induct >- ( qexists_tac`2` >> simp[] ) >> fs[] >> From 15e9d3a96a5b3edb2f97ab321bfade8a64c33ce1 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 15 Jan 2015 15:48:20 +1100 Subject: [PATCH 123/718] Change MLsyntax example to use new Datatype syntax. --- examples/MLsyntax/MLScript.sml | 34 +++++++++++++++++----------------- 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/examples/MLsyntax/MLScript.sml b/examples/MLsyntax/MLScript.sml index 882218978e..a74c753052 100644 --- a/examples/MLsyntax/MLScript.sml +++ b/examples/MLsyntax/MLScript.sml @@ -70,36 +70,36 @@ val _ = new_theory "ML"; Define the type of variables. ---------------------------------------------------------------------------*) -val _ = Hol_datatype `var = VAR of string`; +val _ = Datatype `var = VAR string`; (*--------------------------------------------------------------------------- Define the datatype of ML syntax trees. ---------------------------------------------------------------------------*) -val _ = Hol_datatype - `atexp = var_exp of var - | let_exp of dec => exp ; +val _ = Datatype + `atexp = var_exp var + | let_exp dec exp ; - exp = aexp of atexp - | app_exp of exp => atexp - | fn_exp of match ; + exp = aexp atexp + | app_exp exp atexp + | fn_exp match ; - match = match of rule - | matchl of rule => match ; + match = match rule + | matchl rule match ; - rule = rule of pat => exp ; + rule = rule pat exp ; - dec = val_dec of valbind - | local_dec of dec => dec - | seq_dec of dec => dec ; + dec = val_dec valbind + | local_dec dec dec + | seq_dec dec dec ; - valbind = bind of pat => exp - | bindl of pat => exp => valbind - | rec_bind of valbind ; + valbind = bind pat exp + | bindl pat exp valbind + | rec_bind valbind ; pat = wild_pat - | var_pat of var`; + | var_pat var`; (*--------------------------------------------------------------------------- From 0c8281835d9df2c257d950eaf5ba34e4b6daa4ac Mon Sep 17 00:00:00 2001 From: Magnus Myreen Date: Thu, 15 Jan 2015 16:08:16 +1100 Subject: [PATCH 124/718] slightly improved support for SPEC_1 --- .../machine-code/hoare-triple/helperLib.sml | 8 +- .../hoare-triple/temporalScript.sml | 90 +++++++----- .../x86_64/prog_x64Lib.sig | 7 + .../x86_64/prog_x64Lib.sml | 50 +++++-- .../x86_64/prog_x64Script.sml | 93 ++++++++++-- .../x86_64/prog_x64_extraScript.sml | 136 +++++++++++++++++- .../lisp-runtime/implementation/Holmakefile | 4 +- .../milawa-prover/soundness-thm/Holmakefile | 8 +- .../soundness-thm/milawa_soundnessScript.sml | 3 +- 9 files changed, 337 insertions(+), 62 deletions(-) diff --git a/examples/machine-code/hoare-triple/helperLib.sml b/examples/machine-code/hoare-triple/helperLib.sml index 262607896e..96652dffbd 100644 --- a/examples/machine-code/hoare-triple/helperLib.sml +++ b/examples/machine-code/hoare-triple/helperLib.sml @@ -3,7 +3,7 @@ struct open HolKernel boolLib bossLib; open wordsLib stringLib addressTheory set_sepTheory progTheory wordsTheory; -open pairSyntax progSyntax; +open pairSyntax progSyntax temporalTheory; structure Parse = struct @@ -877,11 +877,17 @@ fun HIDE_PRE_STATUS_RULE hide_th th = HIDE_STATUS_RULE false hide_th th fun SPEC_STRENGTHEN_RULE th pre = let val th = SPEC pre (MATCH_MP progTheory.SPEC_STRENGTHEN th) val goal = (fst o dest_imp o concl) th + in (th,goal) end handle HOL_ERR _ => let + val th = SPEC pre (MATCH_MP temporalTheory.SPEC_1_STRENGTHEN th) + val goal = (fst o dest_imp o concl) th in (th,goal) end; fun SPEC_WEAKEN_RULE th post = let val th = SPEC post (MATCH_MP progTheory.SPEC_WEAKEN th) val goal = (fst o dest_imp o concl) th + in (th,goal) end handle HOL_ERR _ => let + val th = SPEC post (MATCH_MP temporalTheory.SPEC_1_WEAKEN th) + val goal = (fst o dest_imp o concl) th in (th,goal) end; fun SPEC_BOOL_FRAME_RULE th frame = let diff --git a/examples/machine-code/hoare-triple/temporalScript.sml b/examples/machine-code/hoare-triple/temporalScript.sml index 2b94da6607..c662692054 100644 --- a/examples/machine-code/hoare-triple/temporalScript.sml +++ b/examples/machine-code/hoare-triple/temporalScript.sml @@ -48,8 +48,7 @@ val SPEC_EQ_TEMPORAL = Q.store_thm("SPEC_EQ_TEMPORAL", [SPEC_def, TEMPORAL_def, RUN_def, LET_DEF, PULL_FORALL, T_IMPLIES_def, NOW_def, EVENTUALLY_def, rel_sequence_def] \\ SIMP_TAC std_ss [AC STAR_ASSOC STAR_COMM, GSYM rel_sequence_def] - \\ METIS_TAC [] - ); + \\ METIS_TAC []); val TEMPORAL_ALWAYS = Q.store_thm("TEMPORAL_ALWAYS", `TEMPORAL model code (ALWAYS p) <=> TEMPORAL model code p`, @@ -69,8 +68,7 @@ val TEMPORAL_ALWAYS = Q.store_thm("TEMPORAL_ALWAYS", \\ FULL_SIMP_TAC std_ss [rel_sequence_def] \\ REPEAT STRIP_TAC \\ FIRST_X_ASSUM (ASSUME_TAC o Q.SPEC `n + k`) - \\ FULL_SIMP_TAC std_ss [ADD_CLAUSES] - ) + \\ FULL_SIMP_TAC std_ss [ADD_CLAUSES]) val TEMPORAL_NEXT_IMP_EVENTUALLY = Q.store_thm("TEMPORAL_NEXT_IMP_EVENTUALLY", `TEMPORAL model code (T_IMPLIES p1 (NEXT p2)) ==> @@ -78,8 +76,7 @@ val TEMPORAL_NEXT_IMP_EVENTUALLY = Q.store_thm("TEMPORAL_NEXT_IMP_EVENTUALLY", INIT \\ ASM_SIMP_TAC std_ss [TEMPORAL_def, LET_DEF, T_IMPLIES_def, NEXT_def, EVENTUALLY_def] - \\ METIS_TAC [] - ) + \\ METIS_TAC []) val SPEC_1_IMP_SPEC = store_thm("SPEC_1_IMP_SPEC", ``SPEC_1 model pre code post err ==> @@ -119,43 +116,66 @@ val SPEC_IMP_SPEC_1 = store_thm("SPEC_IMP_SPEC_1", \\ Cases_on `k` \\ FULL_SIMP_TAC std_ss [ADD1,SEP_DISJ_def] \\ METIS_TAC []); +val SEP_IMP_IMP_SEP_REFINE = prove( + ``SEP_IMP q1 q3 ==> + (!r1 r2 t2. + SEP_REFINE (q1 * r1 * r2) m f t2 ==> + SEP_REFINE (q3 * r1 * r2) m f t2)``, + FULL_SIMP_TAC std_ss [SEP_REFINE_def,GSYM STAR_ASSOC] + \\ REPEAT STRIP_TAC \\ IMP_RES_TAC SEP_IMP_FRAME + \\ FULL_SIMP_TAC std_ss [SEP_IMP_def] \\ METIS_TAC []); + val SPEC_1_STRENGTHEN = store_thm("SPEC_1_STRENGTHEN", ``!model p c q err. SPEC_1 model p c q err ==> !r. SEP_IMP r p ==> SPEC_1 model r c q err``, - STRIP_TAC \\ INIT \\ ASM_SIMP_TAC std_ss [] - \\ SIMP_TAC bool_ss [SPEC_1_def,TEMPORAL_def,GSYM STAR_ASSOC, - SEP_REFINE_def,LET_DEF,T_IMPLIES_def,NOW_def,PULL_EXISTS] - \\ REPEAT STRIP_TAC \\ FULL_SIMP_TAC std_ss [AND_IMP_INTRO] - THEN1 - (`(p * (CODE_POOL instr c * r')) (to_set s)` by - METIS_TAC [SEP_IMP_def,SEP_IMP_REFL,SEP_IMP_STAR] - \\ METIS_TAC []) - \\ FIRST_X_ASSUM MATCH_MP_TAC - \\ Q.EXISTS_TAC `state` \\ FULL_SIMP_TAC std_ss []); + STRIP_TAC \\ INIT \\ ASM_SIMP_TAC std_ss [] \\ REPEAT STRIP_TAC + \\ FULL_SIMP_TAC std_ss [TEMPORAL_def,LET_DEF,PULL_FORALL, + AND_IMP_INTRO,T_IMPLIES_def,ALWAYS_def,EVENTUALLY_def, + NOW_def,T_OR_F_def,SPEC_1_def] + \\ METIS_TAC [SEP_IMP_IMP_SEP_REFINE]); val SPEC_1_WEAKEN = store_thm("SPEC_1_WEAKEN", ``!model p c r err. SPEC_1 model p c r err ==> !q. SEP_IMP r q ==> SPEC_1 model p c q err``, - STRIP_TAC \\ INIT \\ ASM_SIMP_TAC std_ss [] - \\ SIMP_TAC bool_ss [SPEC_1_def,TEMPORAL_def,GSYM STAR_ASSOC,T_OR_F_def, - SEP_REFINE_def,LET_DEF,T_IMPLIES_def,NOW_def,PULL_EXISTS] - \\ REVERSE (REPEAT STRIP_TAC) \\ FULL_SIMP_TAC std_ss [AND_IMP_INTRO] - THEN1 - (FIRST_X_ASSUM (MP_TAC o Q.SPECL [`state`,`seq`,`r'`]) - \\ FULL_SIMP_TAC std_ss [] \\ REPEAT STRIP_TAC \\ DISJ2_TAC - \\ SIMP_TAC std_ss [EVENTUALLY_def,NOW_def] \\ METIS_TAC []) - \\ FIRST_X_ASSUM (MP_TAC o Q.SPECL [`state`,`seq`,`r'`]) - \\ MATCH_MP_TAC IMP_IMP \\ STRIP_TAC - THEN1 (FULL_SIMP_TAC std_ss [] \\ METIS_TAC []) - \\ SIMP_TAC std_ss [EVENTUALLY_def,NOW_def,NEXT_def,PULL_EXISTS] - \\ REVERSE (REPEAT STRIP_TAC) - THEN1 METIS_TAC [] - THEN1 METIS_TAC [] - THEN1 METIS_TAC [] - \\ `(q * (CODE_POOL instr c * r')) (to_set s')` by - METIS_TAC [SEP_IMP_def,SEP_IMP_REFL,SEP_IMP_STAR] - \\ METIS_TAC []); + STRIP_TAC \\ INIT \\ ASM_SIMP_TAC std_ss [] \\ REPEAT STRIP_TAC + \\ FULL_SIMP_TAC std_ss [TEMPORAL_def,LET_DEF,PULL_FORALL, + AND_IMP_INTRO,T_IMPLIES_def,ALWAYS_def,EVENTUALLY_def, + NOW_def,T_OR_F_def,SPEC_1_def,SEP_DISJ_def,SEP_CLAUSES,NEXT_def] + \\ METIS_TAC [SEP_IMP_IMP_SEP_REFINE]); + +val SPEC_1_FRAME = store_thm("SPEC_1_FRAME", + ``!model p c q err. SPEC_1 model p c q err ==> + !r. SPEC_1 model (p * r) c (q * r) (err * r)``, + STRIP_TAC \\ INIT \\ ASM_SIMP_TAC std_ss [] \\ REPEAT STRIP_TAC + \\ FULL_SIMP_TAC std_ss [TEMPORAL_def,LET_DEF,PULL_FORALL, + AND_IMP_INTRO,T_IMPLIES_def,ALWAYS_def,EVENTUALLY_def, + NOW_def,T_OR_F_def,SPEC_1_def,SEP_DISJ_def,SEP_CLAUSES,NEXT_def] + \\ NTAC 3 STRIP_TAC + \\ FIRST_X_ASSUM (MP_TAC o Q.SPECL [`state`,`seq`,`r * r'`]) + \\ FULL_SIMP_TAC std_ss [AC STAR_ASSOC STAR_COMM]); + +val SPEC_MOVE_1_COND = store_thm("SPEC_MOVE_1_COND", + ``!model p c q g err. + SPEC_1 model (p * cond g) c q err <=> (g ==> SPEC_1 model p c q err)``, + STRIP_TAC \\ INIT \\ ASM_SIMP_TAC std_ss [] \\ REPEAT STRIP_TAC + \\ FULL_SIMP_TAC std_ss [TEMPORAL_def,LET_DEF,PULL_FORALL, + AND_IMP_INTRO,T_IMPLIES_def,ALWAYS_def,EVENTUALLY_def, + NOW_def,T_OR_F_def,SPEC_1_def,SEP_DISJ_def,SEP_CLAUSES,NEXT_def] + \\ FULL_SIMP_TAC std_ss [SEP_REFINE_def] + \\ Cases_on `g` \\ FULL_SIMP_TAC std_ss [SEP_CLAUSES] + \\ FULL_SIMP_TAC std_ss [SEP_F_def] \\ METIS_TAC []); + +val SPEC_1_PRE_EXISTS = store_thm("SPEC_1_PRE_EXISTS", + ``!model p c q err. (!y. SPEC_1 model (p y) c q err) <=> + SPEC_1 model (SEP_EXISTS y. p y) c q err``, + STRIP_TAC \\ INIT \\ ASM_SIMP_TAC std_ss [] \\ REPEAT STRIP_TAC + \\ FULL_SIMP_TAC std_ss [TEMPORAL_def,LET_DEF,PULL_FORALL, + AND_IMP_INTRO,T_IMPLIES_def,ALWAYS_def,EVENTUALLY_def, + NOW_def,T_OR_F_def,SPEC_1_def,SEP_DISJ_def,SEP_CLAUSES,NEXT_def] + \\ FULL_SIMP_TAC std_ss [SEP_REFINE_def,SEP_CLAUSES,SEP_EXISTS_THM] + \\ REPEAT STRIP_TAC \\ EQ_TAC \\ REPEAT STRIP_TAC + \\ FIRST_X_ASSUM MATCH_MP_TAC \\ METIS_TAC []) val _ = export_theory() diff --git a/examples/machine-code/instruction-set-models/x86_64/prog_x64Lib.sig b/examples/machine-code/instruction-set-models/x86_64/prog_x64Lib.sig index 72b6e31437..b48566115e 100644 --- a/examples/machine-code/instruction-set-models/x86_64/prog_x64Lib.sig +++ b/examples/machine-code/instruction-set-models/x86_64/prog_x64Lib.sig @@ -24,4 +24,11 @@ sig val set_x64_code_write_perm_flag : bool -> unit val set_x64_use_stack : bool -> unit + val calc_code : thm -> term + val pre_process_thm : thm -> thm + val w2n_MOD : thm + val x64_prove_one_spec_1 : thm -> term -> thm + val introduce_zMEMORY64 : thm -> thm + val introduce_zMEMORY64_1 : thm -> thm + end diff --git a/examples/machine-code/instruction-set-models/x86_64/prog_x64Lib.sml b/examples/machine-code/instruction-set-models/x86_64/prog_x64Lib.sml index 753273fd00..0ec039d50b 100644 --- a/examples/machine-code/instruction-set-models/x86_64/prog_x64Lib.sml +++ b/examples/machine-code/instruction-set-models/x86_64/prog_x64Lib.sml @@ -269,14 +269,29 @@ fun introduce_zM64 th = if val th = RW [STAR_ASSOC,LOAD64] th in th end handle HOL_ERR _ => th; -fun introduce_zMEMORY64 th = +val is_spec_1 = true +val is_spec_1 = false + +val SPEC_1_pat = temporalTheory.SPEC_1_def |> SPEC_ALL |> concl |> dest_eq |> fst +fun dest_spec_1 tm = + if can (match_term SPEC_1_pat) tm then let + val (x1234,x5) = dest_comb tm + val (x123,x4) = dest_comb x1234 + val (x12,x3) = dest_comb x123 + val (x1,x2) = dest_comb x12 + val (x0,x1) = dest_comb x1 + in (x1,x2,x3,x4) end + else failwith("not a SPEC_1") + +fun introduce_zMEMORY64_spec_or_spec_1 th is_spec_1 = let val th = introduce_zM64 th in if not (can (find_term (can (match_term ``zM64``))) (concl th)) then th else let - val th = CONV_RULE (PRE_CONV STAR_REVERSE_CONV) th + val pre_conv = if is_spec_1 then RATOR_CONV o PRE_CONV else PRE_CONV + val th = CONV_RULE (pre_conv STAR_REVERSE_CONV) th val th = SIMP_RULE (bool_ss++sep_cond_ss) [] th - val th = CONV_RULE (PRE_CONV STAR_REVERSE_CONV) th - val (_,p,_,q) = dest_spec(concl th) + val th = CONV_RULE (pre_conv STAR_REVERSE_CONV) th + val (_,p,_,q) = dest_spec(concl th) handle HOL_ERR _ => dest_spec_1(concl th) val xs = (rev o list_dest dest_star) p val tm = ``zM64 a x`` val xs = filter (can (match_term tm)) xs @@ -284,7 +299,7 @@ fun introduce_zMEMORY64 th = mk_comb(mk_var("f",``:word64->word64``),(cdr o car) tm) val th = INST (map foo xs) th in if xs = [] then th else let - val (_,p,_,q) = dest_spec(concl th) + val (_,p,_,q) = dest_spec(concl th) handle HOL_ERR _ => dest_spec_1(concl th) val xs = (rev o list_dest dest_star) p val tm = ``zM64 a x`` val xs = filter (can (match_term tm)) xs @@ -293,7 +308,9 @@ fun introduce_zMEMORY64 th = | foo (v::vs) = pred_setSyntax.mk_delete(foo vs,v) val frame = mk_comb(mk_comb(``zMEMORY64``,foo ys),mk_var("f",``:word64->word64``)) val th = SPEC frame (MATCH_MP progTheory.SPEC_FRAME th) - val th = RW [GSYM STAR_ASSOC] th + handle HOL_ERR _ => + SPEC frame (MATCH_MP temporalTheory.SPEC_1_FRAME th) + val th = RW [GSYM STAR_ASSOC,SEP_CLAUSES] th val fff = (fst o dest_eq o concl o UNDISCH_ALL o SPEC_ALL o GSYM) zMEMORY64_INSERT fun compact th = let val x = find_term (can (match_term fff)) ((car o car o concl o UNDISCH_ALL) th) @@ -325,12 +342,16 @@ fun introduce_zMEMORY64 th = THEN FULL_SIMP_TAC std_ss [] THEN FULL_SIMP_TAC std_ss []) val th = DISCH_ALL (MATCH_MP th (UNDISCH imp)) - val th = RW [GSYM progTheory.SPEC_MOVE_COND] th + val th = RW [GSYM progTheory.SPEC_MOVE_COND, + GSYM temporalTheory.SPEC_MOVE_1_COND] th val th = remove_primes th val th = REWRITE_RULE [SING_SUBSET] th val th = SIMP_RULE (bool_ss++sep_cond_ss) [] th in th end end end +fun introduce_zMEMORY64 th = introduce_zMEMORY64_spec_or_spec_1 th false; +fun introduce_zMEMORY64_1 th = introduce_zMEMORY64_spec_or_spec_1 th true; + (* fun introduce_zSTACK th = if not (can (find_term (fn x => x = ``RSP``)) (concl th)) then th else let @@ -397,12 +418,14 @@ fun calc_code th = let val code = map snd (sort (fn (x,_) => fn (y,_) => x <= y) tms) in listSyntax.mk_list (code, ``:word8``) end; -fun x64_prove_one_spec th c = let +fun x64_prove_one_spec_or_spec_1 th c is_spec_1 = let val g = concl th val s = find_term (can (match_term ``X64_NEXT x = SOME y``)) g val s = (snd o dest_comb o snd o dest_comb) s val (pre,post) = x64_pre_post g s - val tm = ``SPEC X64_MODEL pre {(rip,c)} post`` + val tm = if is_spec_1 + then ``SPEC_1 X64_MODEL pre {(rip,c)} post SEP_F`` + else ``SPEC X64_MODEL pre {(rip,c)} post`` val tm = subst [mk_var("pre",type_of pre) |-> pre, mk_var("post",type_of post) |-> post, mk_var("c",type_of c) |-> c] tm @@ -416,7 +439,8 @@ fun x64_prove_one_spec th c = let (* set_goal([],tm) *) - MATCH_MP_TAC IMP_X64_SPEC \\ REPEAT STRIP_TAC + MATCH_MP_TAC (if is_spec_1 then IMP_X64_SPEC_1 else IMP_X64_SPEC) + \\ REPEAT STRIP_TAC \\ EXISTS_TAC ((cdr o cdr o concl o UNDISCH) th1) \\ STRIP_TAC \\ REWRITE_TAC [X64_ICACHE_UPDATE_def] THENL [MATCH_MP_TAC th1,ALL_TAC] @@ -461,6 +485,12 @@ fun x64_prove_one_spec th c = let val th = INST [``w:bool``|-> (if !x64_code_write_perm then T else F)] th in RW [STAR_ASSOC,SEP_CLAUSES,markerTheory.Abbrev_def] th end; +fun x64_prove_one_spec th c = + x64_prove_one_spec_or_spec_1 th c false; + +fun x64_prove_one_spec_1 th c = + x64_prove_one_spec_or_spec_1 th c true; + fun x64_prove_specs mpred no_status s = let val th = x64_step s val th = if mpred = zMEM_BYTE_MEMORY then diff --git a/examples/machine-code/instruction-set-models/x86_64/prog_x64Script.sml b/examples/machine-code/instruction-set-models/x86_64/prog_x64Script.sml index 595ded223c..a7e4e307f8 100644 --- a/examples/machine-code/instruction-set-models/x86_64/prog_x64Script.sml +++ b/examples/machine-code/instruction-set-models/x86_64/prog_x64Script.sml @@ -225,6 +225,11 @@ val lemma = METIS_PROVE [SPLIT_x64_2set] ``p (x64_2set' y s) ==> (?u v. SPLIT (x64_2set s) (u,v) /\ p u /\ (\v. v = x64_2set'' y s) v)``; +val CODE_POOL_EMPTY = prove( + ``CODE_POOL m EMPTY = emp``, + FULL_SIMP_TAC std_ss [Once FUN_EQ_THM,emp_def,CODE_POOL_def] + \\ FULL_SIMP_TAC (srw_ss()) []); + val X64_SPEC_SEMANTICS = store_thm("X64_SPEC_SEMANTICS", ``SPEC X64_MODEL p {} q = !y s t1 seq. @@ -254,6 +259,42 @@ val X64_SPEC_SEMANTICS = store_thm("X64_SPEC_SEMANTICS", \\ IMP_RES_TAC x64_2set''_11 \\ FULL_SIMP_TAC std_ss [])); +val X64_SPEC_1_SEMANTICS = store_thm("X64_SPEC_1_SEMANTICS", + ``SPEC_1 X64_MODEL p {} q SEP_F = + !y s t1 seq. + p (x64_2set' y t1) /\ X64_ICACHE t1 s /\ rel_sequence X64_NEXT_REL seq s /\ + ~(X64_STACK_FULL s) ==> + ?k t2. q (x64_2set' y t2) /\ X64_ICACHE t2 (seq (k + 1)) /\ + (x64_2set'' y t1 = x64_2set'' y t2) \/ X64_STACK_FULL (seq k)``, + SIMP_TAC bool_ss [GSYM RUN_EQ_SPEC,RUN_thm,X64_MODEL_def, + SEP_REFINE_def,PULL_EXISTS,SPEC_1_def,TEMPORAL_def,T_IMPLIES_def, + T_OR_F_def,NEXT_def,EVENTUALLY_def,NOW_def,SEP_F_def,LET_DEF, + CODE_POOL_EMPTY,SEP_CLAUSES] \\ SIMP_TAC std_ss [STAR_def] + \\ REPEAT STRIP_TAC \\ REVERSE EQ_TAC \\ REPEAT STRIP_TAC THEN1 + (FULL_SIMP_TAC bool_ss [SPLIT_x64_2set_EXISTS] \\ SRW_TAC [] [] + \\ REPEAT STRIP_TAC + \\ Q.PAT_ASSUM `!y.bbb` (MP_TAC o Q.SPECL [`y`,`state`,`s`,`seq`]) + \\ FULL_SIMP_TAC std_ss [] + \\ Cases_on `X64_STACK_FULL state` \\ FULL_SIMP_TAC std_ss [] + THEN1 (FULL_SIMP_TAC std_ss [rel_sequence_def] \\ METIS_TAC []) + \\ `state = seq 0` by FULL_SIMP_TAC std_ss [rel_sequence_def] + \\ FULL_SIMP_TAC std_ss [] \\ REPEAT STRIP_TAC + \\ FULL_SIMP_TAC std_ss [PULL_EXISTS] \\ METIS_TAC []) + \\ IMP_RES_TAC lemma \\ FULL_SIMP_TAC std_ss [PULL_FORALL] + \\ FULL_SIMP_TAC bool_ss [SPLIT_x64_2set_EXISTS] + \\ IMP_RES_TAC x64_2set''_11 + \\ FULL_SIMP_TAC std_ss [PULL_EXISTS] + THEN1 (METIS_TAC []) + \\ SRW_TAC [] [] + \\ Q.PAT_ASSUM `!y.bbb` (MP_TAC o Q.SPECL [`s`,`seq`,`\s. s = x64_2set'' y t1`]) + \\ FULL_SIMP_TAC std_ss [] + \\ MATCH_MP_TAC IMP_IMP \\ STRIP_TAC + THEN1 METIS_TAC [rel_sequence_def] + \\ REVERSE (REPEAT STRIP_TAC) + THEN1 METIS_TAC [] + THEN1 METIS_TAC [] + \\ IMP_RES_TAC x64_2set''_11 + \\ Q.LIST_EXISTS_TAC [`k`,`s'`] \\ FULL_SIMP_TAC std_ss []) (* ----------------------------------------------------------------------------- *) (* Theorems for construction of |- SPEC X64_MODEL ... *) @@ -414,10 +455,23 @@ val UPDATE_x64_2set'' = store_thm("UPDATE_x64_2set''", \\ ASM_SIMP_TAC std_ss [] \\ SRW_TAC [] [X64_ACCURATE_UPDATE] \\ METIS_TAC [X64_ACCURATE_UPDATE]); +val SPEC_1_CODE = prove( + ``!x p c q. + SPEC_1 x (CODE_POOL (FST (SND (SND x))) c * p) {} + (CODE_POOL (FST (SND (SND x))) c * q) SEP_F <=> + SPEC_1 x p c q SEP_F``, + FULL_SIMP_TAC std_ss [SPEC_1_def,FORALL_PROD,TEMPORAL_def,T_IMPLIES_def, + EVENTUALLY_def,T_OR_F_def,NOW_def,NEXT_def,LET_DEF,CODE_POOL_EMPTY, + SEP_CLAUSES,AC STAR_ASSOC STAR_COMM]); + val X64_SPEC_CODE = save_thm("X64_SPEC_CODE", RW [GSYM X64_MODEL_def,GSYM zCODE_def] (SIMP_RULE std_ss [X64_MODEL_def] (Q.ISPEC `X64_MODEL` SPEC_CODE))); +val X64_SPEC_1_CODE = save_thm("X64_SPEC_1_CODE", + RW [GSYM X64_MODEL_def,GSYM zCODE_def] + (SIMP_RULE std_ss [X64_MODEL_def] (Q.ISPEC `X64_MODEL` SPEC_1_CODE))); + val IMP_X64_SPEC_LEMMA = prove( ``!p q. (!y s t1. @@ -426,8 +480,8 @@ val IMP_X64_SPEC_LEMMA = prove( p (x64_2set' y s) /\ (X64_NEXT s = SOME v) /\ q (x64_2set' y t2) /\ X64_ICACHE t2 v /\ (x64_2set'' y t1 = x64_2set'' y t2)) ==> - SPEC X64_MODEL p {} q``, - REWRITE_TAC [X64_SPEC_SEMANTICS] \\ REPEAT STRIP_TAC + SPEC_1 X64_MODEL p {} q SEP_F``, + REWRITE_TAC [X64_SPEC_1_SEMANTICS] \\ REPEAT STRIP_TAC \\ `p (x64_2set' y s)` by METIS_TAC [] \\ `X64_NEXT_REL (seq 0) (seq (SUC 0))` by ALL_TAC THEN1 (`?x. X64_NEXT_REL (seq 0) x` by ALL_TAC THEN1 @@ -438,7 +492,7 @@ val IMP_X64_SPEC_LEMMA = prove( \\ METIS_TAC [rel_sequence_def]) \\ FULL_SIMP_TAC std_ss [X64_NEXT_REL_def] \\ `seq 0 = s` by FULL_SIMP_TAC std_ss [rel_sequence_def] - \\ FULL_SIMP_TAC std_ss [] \\ Q.EXISTS_TAC `1` + \\ FULL_SIMP_TAC std_ss [] \\ Q.EXISTS_TAC `0` \\ Q.PAT_ASSUM `!y s t1. bbb` (MP_TAC o RW [GSYM AND_IMP_INTRO] o Q.SPECL [`y`,`u`,`t1`]) \\ IMP_RES_TAC X64_ICACHE_TRANS @@ -554,7 +608,7 @@ val IMP_X64_SPEC_LEMMA2 = prove( q (x64_2set' (rs,st,ei,ms) (X64_ICACHE_REVERT v (r,e,t,m,i))) /\ (x64_2set'' (rs,st,ei,ms) (r,e,t,m,i) = x64_2set'' (rs,st,ei,ms) (X64_ICACHE_REVERT v (r,e,t,m,i)))) ==> - SPEC X64_MODEL p {} q``, + SPEC_1 X64_MODEL p {} q SEP_F``, REPEAT STRIP_TAC \\ MATCH_MP_TAC IMP_X64_SPEC_LEMMA \\ REPEAT STRIP_TAC \\ IMP_RES_TAC X64_ICACHE_THM2 @@ -570,8 +624,22 @@ val IMP_X64_SPEC_LEMMA2 = prove( \\ MATCH_MP_TAC X64_ICACHE_X64_ICACHE_REVERT \\ Q.EXISTS_TAC `(X64_ICACHE_UPDATE z (r,e,t,m,i))` \\ ASM_SIMP_TAC std_ss []); +val SPEC_1_SEP_F_IMP_SPEC = store_thm("SPEC_1_SEP_F_IMP_SPEC", + ``SPEC_1 model pre code post SEP_F ==> SPEC model pre code post``, + REPEAT STRIP_TAC \\ IMP_RES_TAC SPEC_1_IMP_SPEC + \\ FULL_SIMP_TAC std_ss [SEP_CLAUSES]); + val IMP_X64_SPEC = save_thm("IMP_X64_SPEC", - (RW1 [STAR_COMM] o RW [X64_SPEC_CODE,GSYM zCODE_def] o + (SPECL [``p * CODE_POOL X64_INSTR {(rip,c)}``, + ``q * CODE_POOL X64_INSTR {(rip,c)}``]) IMP_X64_SPEC_LEMMA2 + |> UNDISCH |> MATCH_MP SPEC_1_IMP_SPEC |> RW [SEP_CLAUSES] + |> RW [X64_SPEC_CODE,GSYM zCODE_def] + |> RW1 [STAR_COMM] + |> DISCH_ALL + |> RW [X64_SPEC_CODE,GSYM zCODE_def]); + +val IMP_X64_SPEC_1 = save_thm("IMP_X64_SPEC_1", + (RW1 [STAR_COMM] o RW [X64_SPEC_1_CODE,GSYM zCODE_def] o SPECL [``CODE_POOL X64_INSTR {(rip,c)} * p``, ``CODE_POOL X64_INSTR {(rip,c)} * q``]) IMP_X64_SPEC_LEMMA2); @@ -1018,7 +1086,7 @@ val IMP_X64_SPEC_LEMMA3 = prove( q (x64_2set' (rs,st,ei,ms) ((\(r,e,t,m,i). (r,e,t,m,X64_ICACHE_EMPTY)) v)) /\ (x64_2set'' (rs,st,ei,ms) (r,e,t,m,i) = x64_2set'' (rs,st,ei,ms) ((\(r,e,t,m,i2). (r,e,t,m,i)) v))) ==> - SPEC X64_MODEL p {} q``, + SPEC_1 X64_MODEL p {} q SEP_F``, REPEAT STRIP_TAC \\ MATCH_MP_TAC IMP_X64_SPEC_LEMMA \\ REPEAT STRIP_TAC \\ IMP_RES_TAC X64_ICACHE_THM2 @@ -1037,15 +1105,20 @@ val IMP_X64_SPEC_LEMMA3 = prove( \\ Q.EXISTS_TAC `{}` \\ Q.EXISTS_TAC `UNIV` \\ SRW_TAC [] [] \\ EVAL_TAC); val IMP_X64_SPEC2 = save_thm("IMP_X64_SPEC2", - (RW1 [STAR_COMM] o RW [X64_SPEC_CODE,GSYM zCODE_def] o - SPECL [``CODE_POOL X64_INSTR c * p``, - ``CODE_POOL X64_INSTR c * q``]) IMP_X64_SPEC_LEMMA3); + SPECL [``p * CODE_POOL X64_INSTR c``, + ``q * CODE_POOL X64_INSTR c``] IMP_X64_SPEC_LEMMA3 + |> UNDISCH_ALL + |> MATCH_MP SPEC_1_SEP_F_IMP_SPEC + |> RW1 [STAR_COMM] + |> DISCH_ALL + |> RW [X64_SPEC_CODE,GSYM zCODE_def]); val cpuid_thm = let val th = x64_step "0FA2" (* cpuid *) val th = Q.INST [`s`|->`X64_ICACHE_UPDATE x (r,e,t,m,i)`] th val th = RW [ZREAD_CLAUSES] th - val th = RW [ZREAD_REG_def,X64_ICACHE_UPDATE_def,ZWRITE_RIP_def,ZCLEAR_ICACHE_def] th + val th = RW [ZREAD_REG_def,X64_ICACHE_UPDATE_def, + ZWRITE_RIP_def,ZCLEAR_ICACHE_def] th in th end val zBYTE_MEMORY_Z_x64_2set = prove( diff --git a/examples/machine-code/instruction-set-models/x86_64/prog_x64_extraScript.sml b/examples/machine-code/instruction-set-models/x86_64/prog_x64_extraScript.sml index 2fd4bc43f6..26947af98c 100644 --- a/examples/machine-code/instruction-set-models/x86_64/prog_x64_extraScript.sml +++ b/examples/machine-code/instruction-set-models/x86_64/prog_x64_extraScript.sml @@ -4,7 +4,7 @@ open HolKernel Parse boolLib bossLib; val _ = new_theory "prog_x64_extra"; open prog_x64Theory prog_x64Lib x64_encodeLib; -open helperLib progTheory set_sepTheory addressTheory; +open helperLib progTheory set_sepTheory addressTheory temporalTheory; open wordsTheory wordsLib listTheory arithmeticTheory; open whileTheory pairTheory relationTheory combinTheory optionTheory; @@ -315,7 +315,7 @@ val X64_SPEC_WEAKEN = prove( \\ `?r e s m i. seq k = (r,e,s,m,i)` by METIS_TAC [PAIR] \\ FULL_SIMP_TAC std_ss [STAR_x64_2set,GSYM STAR_ASSOC] \\ FULL_SIMP_TAC std_ss [X64_STACK_FULL_def,x64_icacheTheory.X64_ICACHE_def] - \\ METIS_TAC []) |> SIMP_RULE std_ss [PULL_FORALL,AND_IMP_INTRO]; + \\ SRW_TAC [] []) |> SIMP_RULE std_ss [PULL_FORALL,AND_IMP_INTRO]; val X64_SPEC_WEAKEN = prove( ``!p c q. SPEC X64_MODEL p c q ==> @@ -332,6 +332,42 @@ val X64_SPEC_WEAKEN = prove( \\ REPEAT STRIP_TAC \\ RES_TAC THEN1 (METIS_TAC []) \\ METIS_TAC [STAR_ASSOC,STAR_COMM]); +val X64_SPEC_1_WEAKEN = prove( + ``!p c q. SPEC_1 X64_MODEL p EMPTY q SEP_F ==> + !r. SEP_IMP q (r \/ SEP_EXISTS x frame. + zR1 RSP x * zR1 zGhost_stack_top x * frame) ==> + SPEC_1 X64_MODEL p EMPTY r SEP_F``, + SIMP_TAC std_ss [X64_SPEC_1_SEMANTICS] \\ REPEAT STRIP_TAC + \\ Q.PAT_ASSUM `!x.bbb` (MP_TAC o Q.SPECL [`y`,`s`,`t1`,`seq`]) + \\ FULL_SIMP_TAC std_ss [] \\ REVERSE STRIP_TAC THEN1 (METIS_TAC []) + \\ Cases_on `X64_STACK_FULL (seq (k+1))` THEN1 METIS_TAC [] + \\ Cases_on `X64_STACK_FULL (seq k)` THEN1 METIS_TAC [] + \\ Q.LIST_EXISTS_TAC [`k`,`t2`] \\ FULL_SIMP_TAC std_ss [] + \\ FULL_SIMP_TAC std_ss [SEP_IMP_def,SEP_DISJ_def,SEP_EXISTS_THM] + \\ RES_TAC \\ FULL_SIMP_TAC std_ss [] + \\ `?rs st ei ms. y = (rs,st,ei,ms)` by METIS_TAC [PAIR] + \\ `?r e s m i. t2 = (r,e,s,m,i)` by METIS_TAC [PAIR] + \\ `?r e s m i. seq (k+1) = (r,e,s,m,i)` by METIS_TAC [PAIR] + \\ FULL_SIMP_TAC std_ss [STAR_x64_2set,GSYM STAR_ASSOC] + \\ FULL_SIMP_TAC std_ss [X64_STACK_FULL_def,x64_icacheTheory.X64_ICACHE_def] + \\ SRW_TAC [] [] \\ FULL_SIMP_TAC std_ss []) + |> SIMP_RULE std_ss [PULL_FORALL,AND_IMP_INTRO]; + +val X64_SPEC_1_WEAKEN = prove( + ``!p c q. SPEC_1 X64_MODEL p c q SEP_F ==> + !r. SEP_IMP q (r \/ SEP_EXISTS x frame. + zR1 RSP x * zR1 zGhost_stack_top x * frame) ==> + SPEC_1 X64_MODEL p c r SEP_F``, + ONCE_REWRITE_TAC [GSYM X64_SPEC_1_CODE] \\ REPEAT STRIP_TAC + \\ MATCH_MP_TAC X64_SPEC_1_WEAKEN + \\ Q.EXISTS_TAC `zCODE c * q` \\ FULL_SIMP_TAC std_ss [] + \\ IMP_RES_TAC SEP_IMP_FRAME + \\ POP_ASSUM (MP_TAC o Q.SPEC `zCODE c`) + \\ SIMP_TAC (std_ss++star_ss) [SEP_CLAUSES] + \\ SIMP_TAC std_ss [SEP_IMP_def,SEP_DISJ_def,SEP_EXISTS_THM] + \\ REPEAT STRIP_TAC \\ RES_TAC THEN1 (METIS_TAC []) + \\ METIS_TAC [STAR_ASSOC,STAR_COMM]); + fun x64_push (s,r,v) = save_thm("x64_push_" ^ s,let val ((th,_,_),_) = x64_spec_memory64 (x64_encode ("push " ^ s)) val th = th |> Q.INST [`r4`|->`rsp`,`df`|->`dm`,`f`|->`m`,`rip`|->`p`] @@ -375,6 +411,55 @@ val sw2sw_64_32 = |> SIMP_RULE std_ss [EVAL ``dimindex (:64)``,EVAL ``dimindex (:32)``] |> GSYM +fun SPEC_1_FRAME_RULE th tm = + SPEC tm (MATCH_MP temporalTheory.SPEC_1_FRAME th) |> RW [SEP_CLAUSES] + +val x64_call_imm_raw_spec_1 = let + val th = x64_Lib.x64_step "48E8" + val c = calc_code th + val th = pre_process_thm th + val th = RW [w2n_MOD] th + val th = x64_prove_one_spec_1 th c + val th = introduce_zMEMORY64 th + in th end + +val x64_call_imm_spec_1 = save_thm("x64_call_imm_spec_1",let + val th = x64_call_imm_raw_spec_1 + val th = th |> RW [sw2sw_64_32,GSYM word_add_n2w,WORD_ADD_ASSOC] + val th = th |> Q.INST [`r4`|->`rsp`,`df`|->`dm`,`f`|->`m`,`rip`|->`p`] + val th = SPEC_1_FRAME_RULE th `` + zR1 zGhost_stack_top top * zR1 zGhost_stack_bottom base * + cond (stack_ok rsp top base stack dm m)`` + val new_p = ``(p + 6w + sw2sw (imm32:word32)):word64`` + val th = MATCH_MP X64_SPEC_1_WEAKEN th + |> Q.SPEC `zPC ^new_p * zSTACK (base,p+6w::stack)` + val goal = th |> concl |> dest_imp |> fst + val lemma = prove(goal, + SIMP_TAC std_ss [SEP_IMP_def,zSTACK_def,SEP_CLAUSES,SEP_EXISTS_THM] + \\ REPEAT STRIP_TAC \\ Q.LIST_EXISTS_TAC [`top`, + `zPC ^new_p * + zR1 zGhost_stack_bottom base * zMEMORY64 dm ((rsp - 0x8w =+ p+6w) m)`, + `rsp-8w`,`top`,`dm`, + `((rsp - 0x8w =+ p+6w) m)`] + \\ FULL_SIMP_TAC (std_ss++sep_cond_ss) [cond_STAR,SEP_DISJ_def] + \\ IMP_RES_TAC stack_ok_PUSH + \\ POP_ASSUM (STRIP_ASSUME_TAC o Q.SPEC `p+6w`) + \\ FULL_SIMP_TAC (std_ss++star_ss) [zR_def]) + val th = MP th lemma + val th = th |> Q.GENL (rev [`rsp`,`top`,`dm`,`m`]) + |> SIMP_RULE std_ss [SPEC_1_PRE_EXISTS] + val (th,goal) = SPEC_STRENGTHEN_RULE th + ``zPC p * zSTACK (base,stack)`` + val lemma = prove(goal, + SIMP_TAC std_ss [SEP_IMP_def,zSTACK_def,SEP_CLAUSES,SEP_EXISTS_THM] + \\ REPEAT STRIP_TAC \\ Q.LIST_EXISTS_TAC [`rsp`,`top`,`dm`,`m`] + \\ FULL_SIMP_TAC (std_ss++sep_cond_ss) [cond_STAR] + \\ IMP_RES_TAC stack_ok_PUSH + \\ FULL_SIMP_TAC (std_ss++star_ss) [zR_def]) + val th = MP th lemma + val th = RW [GSYM IMM32_def,GSYM word_add_n2w,WORD_ADD_ASSOC] th + in th |> stack_ss end); + val x64_call_imm = save_thm("x64_call_imm",let val ((th,_,_),_) = x64_spec_memory64 "48E8" val th = th |> RW [sw2sw_64_32,GSYM word_add_n2w,WORD_ADD_ASSOC] @@ -541,6 +626,43 @@ val x64_pops = save_thm("x64_pops",let (* ret *) +val x64_ret_raw_spec_1 = let + val th = x64_Lib.x64_step (x64_encode "ret") + val c = calc_code th + val th = pre_process_thm th + val th = RW [w2n_MOD] th + val th = x64_prove_one_spec_1 th c + val th = introduce_zMEMORY64 th + in th end + +val x64_ret_spec_1 = save_thm("x64_ret_spec_1",let + val th = x64_ret_raw_spec_1 + val th = th |> Q.INST [`r4`|->`rsp`,`df`|->`dm`,`f`|->`m`,`rip`|->`p`] + val th = SPEC_1_FRAME_RULE th `` + zR1 zGhost_stack_top top * zR1 zGhost_stack_bottom base * + cond (stack_ok rsp top base stack dm m /\ stack <> [])`` + val (th,goal) = SPEC_WEAKEN_RULE th + ``zPC (HD stack) * zSTACK (base,TL stack)`` + val lemma = prove(goal, + SIMP_TAC std_ss [SEP_IMP_def,zSTACK_def,SEP_CLAUSES,SEP_EXISTS_THM] + \\ REPEAT STRIP_TAC \\ Q.LIST_EXISTS_TAC [`rsp+8w`,`top`,`dm`,`m`] + \\ FULL_SIMP_TAC (std_ss++sep_cond_ss) [cond_STAR] + \\ IMP_RES_TAC stack_ok_POP + \\ FULL_SIMP_TAC (std_ss++star_ss) [zR_def]) + val th = MP th lemma + val th = th |> Q.GENL (rev [`rsp`,`top`,`dm`,`m`]) + |> SIMP_RULE std_ss [SPEC_1_PRE_EXISTS] + val (th,goal) = SPEC_STRENGTHEN_RULE th + ``zPC p * zSTACK (base,stack) * cond (stack <> [])`` + val lemma = prove(goal, + SIMP_TAC std_ss [SEP_IMP_def,zSTACK_def,SEP_CLAUSES,SEP_EXISTS_THM] + \\ REPEAT STRIP_TAC \\ Q.LIST_EXISTS_TAC [`rsp`,`top`,`dm`,`m`] + \\ FULL_SIMP_TAC (std_ss++sep_cond_ss) [cond_STAR] + \\ IMP_RES_TAC stack_ok_POP + \\ FULL_SIMP_TAC (std_ss++star_ss) [zR_def]) + val th = MP th lemma + in th |> stack_ss end); + val x64_ret = save_thm("x64_ret",let val ((th,_,_),_) = x64_spec_memory64 (x64_encode "ret") val th = th |> Q.INST [`r4`|->`rsp`,`df`|->`dm`,`f`|->`m`,`rip`|->`p`] @@ -569,6 +691,16 @@ val x64_ret = save_thm("x64_ret",let val th = MP th lemma in th |> stack_ss end); +(* SPEC_1 jmp imm *) + +val x64_ret_raw_spec_1 = save_thm("x64_ret_raw_spec_1",let + val th = x64_Lib.x64_step "48E9" + val c = calc_code th + val th = pre_process_thm th + val th = RW [w2n_MOD] th + val th = x64_prove_one_spec_1 th c + in th end); + (* read/write stack *) val LENGTH_LESS = prove( diff --git a/examples/theorem-prover/lisp-runtime/implementation/Holmakefile b/examples/theorem-prover/lisp-runtime/implementation/Holmakefile index 8c7b46b697..f026b9eddd 100644 --- a/examples/theorem-prover/lisp-runtime/implementation/Holmakefile +++ b/examples/theorem-prover/lisp-runtime/implementation/Holmakefile @@ -17,9 +17,9 @@ HOLHEAP = local-hol-heap EXTRA_CLEANS = $(HOLHEAP) $(HOLHEAP).o BARE_THYS = ../parse/lisp_sexpTheory \ + $(HOLDIR)/examples/machine-code/compiler/compilerLib \ ../garbage-collector/lisp_consTheory \ - ../bytecode/lisp_compilerTheory \ - $(HOLDIR)/examples/machine-code/compiler/compilerLib + ../bytecode/lisp_compilerTheory DEPS = $(patsubst %,%.uo,$(BARE_THYS)) THYFILES = $(patsubst %Script.sml,%Theory.uo,$(wildcard *.sml)) diff --git a/examples/theorem-prover/milawa-prover/soundness-thm/Holmakefile b/examples/theorem-prover/milawa-prover/soundness-thm/Holmakefile index 12bd8f1801..5bd554bc32 100644 --- a/examples/theorem-prover/milawa-prover/soundness-thm/Holmakefile +++ b/examples/theorem-prover/milawa-prover/soundness-thm/Holmakefile @@ -1,2 +1,8 @@ -INCLUDES = .. ../../lisp-runtime/implementation $(HOLDIR)/examples/machine-code/hoare-triple +INCLUDES = .. ../../lisp-runtime/implementation \ + $(HOLDIR)/examples/machine-code/hoare-triple \ + $(HOLDIR)/examples/machine-code/instruction-set-models/common \ + $(HOLDIR)/examples/machine-code/instruction-set-models/x86_64 \ + $(HOLDIR)/examples/machine-code/instruction-set-models/x86 \ + $(HOLDIR)/examples/machine-code/instruction-set-models/ppc \ + $(HOLDIR)/examples/machine-code/instruction-set-models/arm OPTIONS=QUIT_ON_FAILURE diff --git a/examples/theorem-prover/milawa-prover/soundness-thm/milawa_soundnessScript.sml b/examples/theorem-prover/milawa-prover/soundness-thm/milawa_soundnessScript.sml index f5ca6bf18e..28178360c3 100644 --- a/examples/theorem-prover/milawa-prover/soundness-thm/milawa_soundnessScript.sml +++ b/examples/theorem-prover/milawa-prover/soundness-thm/milawa_soundnessScript.sml @@ -1,6 +1,8 @@ open HolKernel Parse boolLib bossLib; val _ = new_theory "milawa_soundness"; +open prog_armTheory prog_ppcTheory prog_x86Theory; + open helperLib set_sepTheory progTheory; open lisp_correctnessTheory milawa_proofpTheory lisp_semanticsTheory; @@ -45,4 +47,3 @@ val milawa_soundness_thm = save_thm("milawa_soundness_thm",let in th end); val _ = export_theory(); - From 42c88489d51444a54576c592a62be62e101ef54a Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 16 Jan 2015 11:28:15 +1100 Subject: [PATCH 125/718] Fix bugs in Q's match_{rename,abbrev} tactics; refine spec. In particular, make sure that instantiations arising from the matches are applied in an order that is sure to make the substitutions apply as much as possible. There are two obvious ways in which things can go wrong (resulting in a goal-term that doesn't in fact look like the supplied pattern). 1. If the match results in an instantiation that has a variable binding a term that appears within another. E.g., (example from Ramana): Q.MATCH_RENAME_TAC `f v = z` (?- `f (h s) = s`) The match will return (v |-> h s, z |-> s), but if this is applied with the z going first, the goal won't contain `h s` when the substitution for v is attempted. So that's bad, and affects both renaming and abbreviating tactics. The fix is to sort the instantiation list so that larger terms are substituted out first. 2. Distinct variables in the pattern may end up binding the same term. This is something users are less likely to bring about, but it still seems worth trying to nail down what the behaviour should be. E.g., Q.MATCH_RENAME_TAC `a + b = 10` (?- 5 + 5 = 10) This will want to bind a and b to 5. When abbreviating, you might like to see abbreviations `a = 5` and `b = 5` in the assumptions, and when renaming or abbreviating, you might like to have the goal become `a + b = 10`. Achieving both these might be possible, but seems hard. Instead, the operational approach of performing substitutions in a sequence is stuck to, but the substitution is sorted so that the variable with the earlier name goes first. This means you'll get ?- a + a = 10 as the goal, and when abbreviating, you'll get `a = b` and `b = 5` as abbreviations in the assumptions. The fixes in examples/ are generally because proofs have relied on abbreviations *not* occurring, despite the presence of variables in the pattern. The situation is analogous to the situation in 1. above, where the user has exploited the fact that a binding hasn't been introduced for v. --- examples/category/hom_functorScript.sml | 2 +- examples/lambda/other-models/gmtermScript.sml | 6 +- .../hol_sets/ordNotationSemanticsScript.sml | 3 +- .../triangular/nominal/nunifDefScript.sml | 2 +- src/marker/markerLib.sig | 1 + src/marker/markerLib.sml | 16 +++- src/q/Q.sml | 4 +- src/q/selftest.sml | 82 +++++++++++++++---- 8 files changed, 85 insertions(+), 31 deletions(-) diff --git a/examples/category/hom_functorScript.sml b/examples/category/hom_functorScript.sml index 5cf8e5df27..d98bf48628 100644 --- a/examples/category/hom_functorScript.sml +++ b/examples/category/hom_functorScript.sml @@ -171,7 +171,7 @@ qmatch_abbrev_tac `inclusion_functor u1 u2##z = X` >> fsrw_tac [][hom_def] >> match_mp_tac maps_to_comp >> metis_tac [maps_to_in_def,maps_to_def] ) >> -srw_tac [][]); +srw_tac [][Abbr`X`]); val _ = export_rewrites["hom_functor_objf","hom_functor_morf"]; diff --git a/examples/lambda/other-models/gmtermScript.sml b/examples/lambda/other-models/gmtermScript.sml index cffe7bc4b6..3715105f9d 100644 --- a/examples/lambda/other-models/gmtermScript.sml +++ b/examples/lambda/other-models/gmtermScript.sml @@ -563,6 +563,7 @@ val swap_RECURSION = store_thm( REVERSE (SRW_TAC [][]) THEN1 SRW_TAC [][] THEN Q.MATCH_ABBREV_TAC `lam (rswap a z Y) a (tpm [(a,z)] M') = R` THEN + Q.UNABBREV_TAC `R` THEN `lam (rswap a z Y) a (tpm [(a,z)] M') = lam (rswap a z Y) (swapstr a z z) (tpm [(a,z)] M')` by SRW_TAC [][] THEN @@ -648,8 +649,3 @@ val swap_RECURSION_nosideset = save_thm( val _ = export_theory(); - - - - - diff --git a/examples/set-theory/hol_sets/ordNotationSemanticsScript.sml b/examples/set-theory/hol_sets/ordNotationSemanticsScript.sml index 4aee00d83a..526503a1f5 100644 --- a/examples/set-theory/hol_sets/ordNotationSemanticsScript.sml +++ b/examples/set-theory/hol_sets/ordNotationSemanticsScript.sml @@ -121,8 +121,7 @@ val oless_total = store_thm( `(∃j. n = End j) ∨ (∃e2 c2 t2. n = Plus e2 c2 t2)` by (Cases_on `n` >> simp[]) >> simp[]) >> map_every qx_gen_tac [`i`, `n`] >> - qmatch_abbrev_tac `oless (Plus e1 i t1) n ∨ FOO` >> - markerLib.RM_ALL_ABBREVS_TAC >> + qmatch_rename_tac `oless (Plus e1 i t1) n ∨ _` >> `(∃j. n = End j) ∨ (∃e2 j t2. n = Plus e2 j t2)` by (Cases_on `n` >> simp[]) >> simp[] >> `oless e1 e2 ∨ oless e2 e1 ∨ (e2 = e1)` by metis_tac[] >> rw[] >> diff --git a/examples/unification/triangular/nominal/nunifDefScript.sml b/examples/unification/triangular/nominal/nunifDefScript.sml index c1d0afc5fb..28b8b47988 100644 --- a/examples/unification/triangular/nominal/nunifDefScript.sml +++ b/examples/unification/triangular/nominal/nunifDefScript.sml @@ -68,7 +68,7 @@ val term_fcs_monadic_thm = Q.store_thm("term_fcs_monadic_thm", | nPair t1 t2 => do fe1 <- term_fcs a t1; fe2 <- term_fcs a t2; SOME (fe1 ∪ fe2) od | nConst _ => SOME {}`, Cases_on `t` THEN SRW_TAC [][Once term_fcs_def] THEN -Q.MATCH_ABBREV_TAC `OPTION_MAP2 $UNION x1 x2 = y` THEN +Q.MATCH_RENAME_TAC `OPTION_MAP2 $UNION x1 x2 = _` THEN Cases_on `x1` THEN SRW_TAC [][] THEN Cases_on `x2` THEN SRW_TAC [][]); diff --git a/src/marker/markerLib.sig b/src/marker/markerLib.sig index 65f08e93c3..50d355125c 100644 --- a/src/marker/markerLib.sig +++ b/src/marker/markerLib.sig @@ -38,6 +38,7 @@ sig val ABBRS_THEN : (thm list -> tactic) -> thm list -> tactic val MK_ABBREVS_OLDSTYLE : tactic val Abbr : term quotation -> thm + val safe_inst_cmp : {redex:term,residue:term} Lib.cmp val MK_LABEL : string * thm -> thm val DEST_LABEL : thm -> thm diff --git a/src/marker/markerLib.sml b/src/marker/markerLib.sml index 5a372625c2..8cb4da8286 100644 --- a/src/marker/markerLib.sml +++ b/src/marker/markerLib.sml @@ -119,11 +119,21 @@ fun fixed_tyvars ctxt pattern = fun ABB' {redex=l,residue=r} = ABB l r +val safe_inst_cmp = let + fun img {redex,residue} = + (term_size residue, (residue, #1 (dest_var redex) handle HOL_ERR _ => "")) + val cmp = pair_compare + (flip_cmp Int.compare, pair_compare (Term.compare, String.compare)) +in + inv_img_cmp img cmp +end +val safe_inst_sort = Listsort.sort safe_inst_cmp + fun MATCH_ABBREV_TAC fv_set pattern (g as (asl, w)) = let val ctxt = HOLset.listItems fv_set val (tminst,_) = match_terml (fixed_tyvars ctxt pattern) fv_set pattern w in - MAP_EVERY ABB' tminst g + MAP_EVERY ABB' (safe_inst_sort tminst) g end fun MATCH_ASSUM_ABBREV_TAC fv_set pattern (g as (asl, w)) = let @@ -133,7 +143,7 @@ fun MATCH_ASSUM_ABBREV_TAC fv_set pattern (g as (asl, w)) = let | find (asm::tl) = case total (match_terml fixed fv_set pattern) asm of NONE => find tl - | SOME (tminst,_) => MAP_EVERY ABB' tminst g + | SOME (tminst,_) => MAP_EVERY ABB' (safe_inst_sort tminst) g handle HOL_ERR e => find tl in find asl end @@ -144,7 +154,7 @@ fun HO_MATCH_ABBREV_TAC fv_set pattern (gl as (asl,w)) = Tactical.default_prover(mk_eq(w, subst tminst (inst tyinst pattern)), BETA_TAC THEN REFL_TAC) in - CONV_TAC (K unbeta_goal) THEN MAP_EVERY ABB' tminst + CONV_TAC (K unbeta_goal) THEN MAP_EVERY ABB' (safe_inst_sort tminst) end gl; fun UNABBREV_TAC s = diff --git a/src/q/Q.sml b/src/q/Q.sml index 8e0b175e55..c99ca4efc4 100644 --- a/src/q/Q.sml +++ b/src/q/Q.sml @@ -351,11 +351,11 @@ fun MATCH_ASSUM_ABBREV_TAC q (gl as (asl,w)) = (*---------------------------------------------------------------------------*) fun make_rename_tac s = - MAP_EVERY + MAP_EVERY (fn {redex=l,residue=r} => CHOOSE_THEN SUBST_ALL_TAC (Thm.EXISTS(mk_exists(l, mk_eq(r, l)), r) (Thm.REFL r))) - s + (Listsort.sort markerLib.safe_inst_cmp s) fun isnt_uscore_var v = let val (s, _) = dest_var v diff --git a/src/q/selftest.sml b/src/q/selftest.sml index 23ab96c842..5cc1590449 100644 --- a/src/q/selftest.sml +++ b/src/q/selftest.sml @@ -37,19 +37,70 @@ val _ = set_fixity "+" (Infixl 500) val _ = set_fixity "*" (Infixl 600) val _ = set_fixity "<" (Infix(NONASSOC, 450)) +fun aconvdie m t1 t2 = aconv t1 t2 orelse die ("FAILED! (" ^ m ^ " wrong)") + val _ = tprint "Q.MATCH_RENAME_TAC 1" val gl0 = ([``x < y``], ``x = z:num``) val expected_a0 = ``a < y`` val expected_c0 = ``a = b:num`` val (sgs, _) = Q.MATCH_RENAME_TAC `a = b` gl0 val _ = case sgs of - [([a], c)] => if aconv a expected_a0 andalso - aconv c expected_c0 - then - print "OK\n" - else die "FAILED!" + [([a], c)] => (aconvdie "assumption" a expected_a0; + aconvdie "goal" c expected_c0; + print "OK\n") + | _ => die "FAILED!" + +val _ = tprint "Q.MATCH_RENAME_TAC 2" +val glmrt2 = ([] : term list, ``f ((h : 'a -> 'b) s) = s``) +val expected_mrt2 = ``(f : 'b -> 'a) z = v`` +val (sgs, _) = Q.MATCH_RENAME_TAC `f z = v` glmrt2 +val _ = case sgs of + [([], c)] => (aconvdie "conclusion" c expected_mrt2; print "OK\n") + | _ => die "FAILED!" + +val _ = tprint "Q.MATCH_RENAME_TAC 3" +val glmrt3 = ([] : term list, ``f zero zero = (z:'a)``) +val expected_mrt3 = ``f (a:num) a = (u:'a)`` +val (sgs, _) = Q.MATCH_RENAME_TAC `f b a = u` glmrt3 +val _ = case sgs of + [([], c)] => (aconvdie "conclusion" c expected_mrt3; print "OK\n") | _ => die "FAILED!" +val _ = tprint "Q.MATCH_ABBREV_TAC 1" +val expected_mat1c = ``f (a:num) a = (u:'a)`` +val expected_mat1a1 = ``Abbrev (b = zero)`` +val expected_mat1a2 = ``Abbrev (a:num = b)`` +val expected_mat1a3 = ``Abbrev (u:'a = z)`` +val (sgs, _) = Q.MATCH_ABBREV_TAC `f b a = u` glmrt3 +val _ = case sgs of + [([a1,a2,a3], c)] => + let + val _ = aconvdie "assumption #1" a1 expected_mat1a1 + val _ = aconvdie "assumption #2" a2 expected_mat1a2 + val _ = aconvdie "assumption #3" a3 expected_mat1a3 + val _ = aconvdie "goal conclusion" c expected_mat1c + in + print "OK\n" + end + | _ => die "FAILED! (new goal of wrong shape)" + +val _ = tprint "Q.MATCH_ABBREV_TAC 2" +val expected_mat2c = ``(f : 'b -> 'a) z = v`` +(* first assumption is most recently created *) +val expected_mat2a1 = ``Abbrev(v : 'a = s)`` +val expected_mat2a2 = ``Abbrev(z :'b = h (v:'a))`` +val (sgs, _) = Q.MATCH_ABBREV_TAC `f z = v` glmrt2 +val _ = case sgs of + [([a1, a2], c)] => + let + val _ = aconvdie "goal conclusion" c expected_mat2c + val _ = aconvdie "assumption #1" a1 expected_mat2a1 + val _ = aconvdie "assumption #2" a2 expected_mat2a2 + in + print "OK\n" + end + | _ => die "FAILED! (new goal of wrong shape)" + val _ = tprint "Q.MATCH_GOALSUB_RENAME_TAC 1" val gl1 = ([] : term list, ``!x. x * SUC (SUC zero) < y * (z + SUC zero) * (y + a)``) @@ -57,8 +108,7 @@ val expected_result1 = ``!x. x * SUC (SUC zero) < y * (z + SUC zero) * (y + c)`` val (sgs, _) = Q.MATCH_GOALSUB_RENAME_TAC `y + c` gl1 val _ = case sgs of - [([], t)] => if aconv t expected_result1 then print "OK\n" - else die "FAILED!" + [([], t)] => (aconvdie "goal" t expected_result1; print "OK\n") | _ => die "FAILED!" val _ = tprint "Q.MATCH_GOALSUB_RENAME_TAC 2" @@ -67,8 +117,8 @@ val gl2 = ([] : term list, val expected_result2 = ``!x. x * c < y * (a + c) * (a + SUC c)`` val (sgs, _) = Q.MATCH_GOALSUB_RENAME_TAC `a + c` gl2 val _ = case sgs of - [([], t)] => if aconv t expected_result2 then print "OK\n" - else die "FAILED!" + [([], t)] => + (aconvdie "goal conclusion" t expected_result2; print "OK\n") | _ => die "FAILED!" val _ = tprint "Q.MATCH_GOALSUB_RENAME_TAC 3" @@ -76,8 +126,8 @@ val gl2a = ([] : term list, ``!x. x * SUC zero < z``) val expected_result2a = #2 gl2a val (sgs, _) = Q.MATCH_GOALSUB_RENAME_TAC `SUC` gl2a val _ = case sgs of - [([], t)] => if aconv t expected_result2a then print "OK\n" - else die "FAILED!" + [([], t)] => + (aconvdie "goal conclusion" t expected_result2a; print "OK\n") | _ => die "FAILED!" @@ -89,12 +139,10 @@ val expected_a2 = ``Q (x < n) : bool`` val expected_c = ``x + y < SUC (SUC zero)`` val (sgs, _) = Q.MATCH_ASMSUB_RENAME_TAC `x < n` gl3 val _ = case sgs of - [([a1, a2], c)] => if aconv a1 expected_a1 andalso - aconv a2 expected_a2 andalso - aconv c expected_c - then - print "OK\n" - else die "FAILED!" + [([a1, a2], c)] => (aconvdie "assumption #1" a1 expected_a1; + aconvdie "assumption #2" a2 expected_a2; + aconvdie "goal conclusion" c expected_c; + print "OK\n") | _ => die "FAILED!" From 2673d9c6013c02c343e2e2f425258169393271c1 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 19 Jan 2015 12:29:28 +1100 Subject: [PATCH 126/718] Allow users to export theorem names that are constructor names. The hacky trick to allow this is to first use a fun binding to "de-constructorify" the name. Thus fun Empty x = x val Empty = 3 allows you to bind Empty, despite it being an exception name, and thus a constructor name. There are still names that just won't work: Poly/ML (at least) doesn't allow rebinding of ::, true, false, ref and nil. We should probably immediately raise an error with those cases on an attempt to save. Closes #225 --- src/1/theory_tests/gh225aScript.sml | 9 +++++++++ src/1/theory_tests/gh225bScript.sml | 9 +++++++++ src/postkernel/TheoryPP.sml | 4 +++- 3 files changed, 21 insertions(+), 1 deletion(-) create mode 100644 src/1/theory_tests/gh225aScript.sml create mode 100644 src/1/theory_tests/gh225bScript.sml diff --git a/src/1/theory_tests/gh225aScript.sml b/src/1/theory_tests/gh225aScript.sml new file mode 100644 index 0000000000..340248d261 --- /dev/null +++ b/src/1/theory_tests/gh225aScript.sml @@ -0,0 +1,9 @@ +open HolKernel Parse boolLib + +val _ = new_theory "gh225a"; + +val _ = save_thm("Empty", TRUTH); +val _ = save_thm("GREATER", TRUTH); + + +val _ = export_theory(); diff --git a/src/1/theory_tests/gh225bScript.sml b/src/1/theory_tests/gh225bScript.sml new file mode 100644 index 0000000000..12a9390d3a --- /dev/null +++ b/src/1/theory_tests/gh225bScript.sml @@ -0,0 +1,9 @@ +open HolKernel Parse boolLib + +open gh225aTheory + +val _ = new_theory "gh225b"; + +val _ = save_thm("TRUTH", TRUTH); + +val _ = export_theory(); diff --git a/src/postkernel/TheoryPP.sml b/src/postkernel/TheoryPP.sml index 247cebb7ae..4f53239bd1 100644 --- a/src/postkernel/TheoryPP.sml +++ b/src/postkernel/TheoryPP.sml @@ -344,7 +344,9 @@ fun pp_struct info_record = let val (tg, asl, w) = (Thm.tag th, Thm.hyp th, Thm.concl th) in block INCONSISTENT 2 - (add_string "val">> + (add_string "fun" >> add_break (1,0) >> add_string ("op "^s) >> + add_break(1,0) >> add_string ("x = x") >> add_newline >> + add_string "val">> add_break(1,0)>> add_string ("op "^s) >> add_break(1,0)>> add_string "=">> add_break(1,0)>> add_string "DT(">> From fdf60dffa56d3c97828c28d369d628ef0f1a1648 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 19 Jan 2015 12:34:45 +1100 Subject: [PATCH 127/718] Make TheoryPP an explicit dependency for the first hol heap. --- src/proofman/Holmakefile | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/proofman/Holmakefile b/src/proofman/Holmakefile index 978b784d47..ed7efde375 100644 --- a/src/proofman/Holmakefile +++ b/src/proofman/Holmakefile @@ -18,7 +18,8 @@ DEPS = $(BOOLLIB) $(BOOLTHEORY) $(PRIMREC) $(TERMPP) \ $(dprot $(SIGOBJ)/TypeBase.uo) \ $(dprot $(SIGOBJ)/Preterm.uo) \ $(dprot $(SIGOBJ)/type_pp.uo) \ - $(dprot $(SIGOBJ)/ParseExtras.uo) + $(dprot $(SIGOBJ)/ParseExtras.uo) \ + $(dprot $(SIGOBJ)/TheoryPP.uo) EXTRA_CLEANS = $(TARGET) From 57d38bd45ac767d881871a8b2b1cd7c5c5221a2d Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 19 Jan 2015 12:51:53 +1100 Subject: [PATCH 128/718] Make save_thm etc reject names that will cause uncompilable theory files This causes exceptions/errors earlier rather than later. --- src/1/selftest.sml | 7 +++++++ src/postkernel/Theory.sml | 7 ++++++- 2 files changed, 13 insertions(+), 1 deletion(-) diff --git a/src/1/selftest.sml b/src/1/selftest.sml index 2c0d5ff408..dd849448ab 100644 --- a/src/1/selftest.sml +++ b/src/1/selftest.sml @@ -500,5 +500,12 @@ val _ = tprint "Testing (foo THENL [...]) when foo solves" val _ = (ACCEPT_TAC TRUTH THENL [ACCEPT_TAC TRUTH]) ([], ``T``) handle HOL_ERR _ => die "FAILED!" val _ = print "OK\n" +val _ = tprint "Testing save_thm rejecting names" +val badnames = ["::", "nil", "true", "false", "ref", "="] +fun test s = (save_thm(s, TRUTH); die "FAILED!") handle HOL_ERR _ => () +val _ = List.app test badnames +val _ = print "OK\n" + + val _ = Process.exit (if List.all substtest tests then Process.success else Process.failure) diff --git a/src/postkernel/Theory.sml b/src/postkernel/Theory.sml index 81c6d8194e..1d0fefb60f 100644 --- a/src/postkernel/Theory.sml +++ b/src/postkernel/Theory.sml @@ -512,7 +512,12 @@ fun scrubCT() = (scrub(); theCT()); * WRITING AXIOMS, DEFINITIONS, AND THEOREMS INTO THE CURRENT SEGMENT * *---------------------------------------------------------------------------*) -local fun check_name (fname,s) = () +local fun check_name (fname,s) = + if Lexis.ok_sml_identifier s andalso + not (Lib.mem s ["ref", "true", "false", "::", "nil", "="]) + then () + else raise ERR fname ("Can't use name "^Lib.mlquote s^ + " as a theory-binding") fun DATED_ERR f bindname = ERR f (Lib.quote bindname^" is out-of-date!") val save_thm_reporting = ref 1 val _ = Feedback.register_trace ("Theory.save_thm_reporting", From ef72cbeb1e540deccab88913a668905fa1d52412 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 20 Jan 2015 15:40:21 +1100 Subject: [PATCH 129/718] WIP fixing problems with 57d38bd4 --- src/datatype/EnumType.sml | 2 +- src/datatype/ind_types.sml | 18 +++--- .../theory_tests/loadDatatypeAScript.sml | 34 ++++++++++ .../theory_tests/loadDatatypeBScript.sml | 9 +++ src/postkernel/Theory.sig | 2 + src/postkernel/Theory.sml | 43 +++++++------ src/postkernel/TheoryPP.sig | 3 + src/postkernel/TheoryPP.sml | 63 +++++++++++-------- src/ring/src/prelimScript.sml | 4 -- 9 files changed, 123 insertions(+), 55 deletions(-) create mode 100644 src/datatype/theory_tests/loadDatatypeAScript.sml create mode 100644 src/datatype/theory_tests/loadDatatypeBScript.sml diff --git a/src/datatype/EnumType.sml b/src/datatype/EnumType.sml index 14aac7ccb5..e21a3d80a6 100644 --- a/src/datatype/EnumType.sml +++ b/src/datatype/EnumType.sml @@ -241,7 +241,7 @@ fun define_enum_type(name,clist,ABS,REP) = val ABSconst = mk_const(ABS, NUM --> TYPE) val REPconst = mk_const(REP, TYPE --> NUM) val nclist = enumerate 0 clist - fun def(n,s) = (s ^ "_def", + fun def(n,s) = (temp_binding (s ^ "_def"), mk_eq(mk_var(s,TYPE), mk_comb(ABSconst,term_of_int n))) val defs = map (new_definition o def) nclist diff --git a/src/datatype/ind_types.sml b/src/datatype/ind_types.sml index d1f7786919..1355936c20 100644 --- a/src/datatype/ind_types.sml +++ b/src/datatype/ind_types.sml @@ -299,7 +299,8 @@ val safepfx = " @ind_type" local val count = ref 0 fun vary_to_avoid_constants () = let - val nm = safepfx ^ current_theory() ^ Int.toString (!count) + val nm = + temp_binding (safepfx ^ current_theory() ^ Int.toString (!count)) in if (not (null (decls nm))) then (count := !count + 100; vary_to_avoid_constants()) @@ -356,7 +357,7 @@ fun define_inductive_type_constructor defs consindex th = let val expth = valOf (List.find (fn th => lhand(concl th) = oldcon) defs) val rexpth = SUBS_CONV [expth] defrt val deflf = mk_var(fst(dest_var oldcon),type_of defrt) - val defth = new_definition(fst (dest_var oldcon) ^ "_def", + val defth = new_definition(temp_binding (fst (dest_var oldcon) ^ "_def"), mk_eq(deflf,rand(concl rexpth))) in TRANS defth (SYM rexpth) @@ -1401,7 +1402,7 @@ local val mtys = itlist (insert o type_of) cjs' [] val pcons = map (fn ty => filter (fn t => type_of t = ty) cjs') mtys val cls' = zip mtys (map (map (recover_clause id)) pcons) - val tyal = map (fn ty => ty |-> mk_vartype("'"^fst(dest_type ty)^id)) mtys + val tyal = map (fn ty => ty |-> mk_vartype("'"^id^fst(dest_type ty))) mtys val cls'' = map (modify_type tyal ## map (modify_item tyal)) cls' in (k,tyal,cls'',Thm.INST_TYPE tyins ith, Thm.INST_TYPE tyins rth) @@ -1519,9 +1520,12 @@ val define_type_nested = fn def => val allcls = conjuncts(snd(strip_exists etm)) val relcls = fst(chop_list (length truecons) allcls) val gencons = map(repeat rator o rand o lhand o snd o strip_forall) relcls - val cdefs = map2 (fn s => fn r => - SYM(new_definition (s, mk_eq(mk_var(s,type_of r),r)))) - truecons gencons + val cdefs = + map2 (fn s => fn r => + SYM(new_definition (temp_binding s, + mk_eq(mk_var(s,type_of r),r)))) + truecons + gencons val tavs = make_args "f" [] (map type_of avs) val ith1 = SUBS cdefs ith0 and rth1 = GENL tavs (SUBS cdefs (SPECL tavs rth0)) @@ -1551,7 +1555,7 @@ fun define_type d = val def = [(Type`:'bar`, [("D1", [Type`:num`]), ("D2", [Type`:'bar`])])]; define_type_nested def; - val def = [(Type`:'qux`, [("F1", []), ("F2", [Type`:'qux option`])])]; + val def = [(Type`:'qux`, [("F1", []), ("##", [Type`:'qux option`])])]; (* HOL Light equivalent : let def = let qux = mk_vartype "qux" in diff --git a/src/datatype/theory_tests/loadDatatypeAScript.sml b/src/datatype/theory_tests/loadDatatypeAScript.sml new file mode 100644 index 0000000000..d8f25b3260 --- /dev/null +++ b/src/datatype/theory_tests/loadDatatypeAScript.sml @@ -0,0 +1,34 @@ +open HolKernel Parse boolLib + +open Datatype + +val _ = new_theory "loadDatatypeA"; + +val _ = Datatype`enum = EC1 | EC2 | EC3 | EC4`; + +val _ = Datatype`simple = SC1 num | SC2 bool num` + +val _ = Datatype`polysimple = PS1 'a | PS2 'b num` + +val _ = Datatype`recursive = RC1 num | RC2 recursive bool` + +val _ = Datatype`polyrec = PR1 'a | PR2 polyrec 'b`; + +val _ = Datatype`simpleref = SR1 num | SR2 ((num,'a) polyrec)` + +val _ = Datatype` + mut1 = con1 'a num | con2 mut2 ; + mut2 = con3 bool | con4 mut1 mut2 +`; + +val _ = Datatype`simplenest = SN1 num | SN2 (simplenest option)`; + +(* bug in older implementations of Datatype too -- +val _ = Datatype` + nested1 = con5 'a nested2 ; + nested2 = con6 (nested1 mut1) +`; +*) + + +val _ = export_theory(); diff --git a/src/datatype/theory_tests/loadDatatypeBScript.sml b/src/datatype/theory_tests/loadDatatypeBScript.sml new file mode 100644 index 0000000000..0f0c9b74a2 --- /dev/null +++ b/src/datatype/theory_tests/loadDatatypeBScript.sml @@ -0,0 +1,9 @@ +open HolKernel Parse boolLib + +open loadDatatypeATheory + +val _ = new_theory "loadDatatypeB"; + +val _ = save_thm("T", TRUTH) + +val _ = export_theory(); diff --git a/src/postkernel/Theory.sig b/src/postkernel/Theory.sig index 37f324903b..daa66f9e79 100644 --- a/src/postkernel/Theory.sig +++ b/src/postkernel/Theory.sig @@ -15,6 +15,8 @@ sig (* Add to the current theory segment *) + val temp_binding : string -> string + val is_temp_binding : string -> bool val new_type : string * int -> unit val new_constant : string * hol_type -> unit val new_axiom : string * term -> thm diff --git a/src/postkernel/Theory.sml b/src/postkernel/Theory.sml index 1d0fefb60f..5d92313886 100644 --- a/src/postkernel/Theory.sml +++ b/src/postkernel/Theory.sml @@ -51,13 +51,14 @@ struct open Feedback Lib Type Term Thm ; +open TheoryPP + + type ppstream = Portable.ppstream type pp_type = ppstream -> hol_type -> unit type pp_thm = ppstream -> thm -> unit type num = Arbnum.num -infix ##; - val ERR = mk_HOL_ERR "Theory"; val WARN = HOL_WARNING "Theory"; @@ -512,20 +513,24 @@ fun scrubCT() = (scrub(); theCT()); * WRITING AXIOMS, DEFINITIONS, AND THEOREMS INTO THE CURRENT SEGMENT * *---------------------------------------------------------------------------*) -local fun check_name (fname,s) = - if Lexis.ok_sml_identifier s andalso - not (Lib.mem s ["ref", "true", "false", "::", "nil", "="]) - then () - else raise ERR fname ("Can't use name "^Lib.mlquote s^ - " as a theory-binding") - fun DATED_ERR f bindname = ERR f (Lib.quote bindname^" is out-of-date!") - val save_thm_reporting = ref 1 - val _ = Feedback.register_trace ("Theory.save_thm_reporting", - save_thm_reporting, 2) - val mesg = with_flag(MESG_to_string, Lib.I) HOL_MESG +local + val temp_binding_pfx = "@temp" + val is_temp_binding = String.isPrefix temp_binding_pfx + fun check_name tempok (fname,s) = + if Lexis.ok_sml_identifier s andalso + not (Lib.mem s ["ref", "true", "false", "::", "nil", "="]) orelse + tempok andalso is_temp_binding s + then () + else raise ERR fname ("Can't use name "^Lib.mlquote s^ + " as a theory-binding") + fun DATED_ERR f bindname = ERR f (Lib.quote bindname^" is out-of-date!") + val save_thm_reporting = ref 1 + val _ = Feedback.register_trace ("Theory.save_thm_reporting", + save_thm_reporting, 2) + val mesg = with_flag(MESG_to_string, Lib.I) HOL_MESG in fun save_thm (name,th) = - (check_name ("save_thm",name) + (check_name true ("save_thm",name) ; if uptodate_thm th then add_thmCT(name,th) else raise DATED_ERR "save_thm" name ; if !save_thm_reporting = 0 then () @@ -541,17 +546,17 @@ fun save_thm (name,th) = fun new_axiom (name,tm) = let val rname = Nonce.mk name val axiom = Thm.mk_axiom_thm (rname,tm) - val _ = check_name ("new_axiom",name) + val _ = check_name false ("new_axiom",name) in if uptodate_term tm then add_axiomCT(rname,axiom) else raise DATED_ERR "new_axiom" name ; axiom end fun store_definition(name, def) = - let val () = check_name ("store_type_definition",name) + let val () = check_name true ("store_definition",name) in if uptodate_thm def then () - else raise DATED_ERR "store_type_definition" name + else raise DATED_ERR "store_definition" name ; add_defnCT(name,def) ; def end @@ -871,8 +876,10 @@ fun export_theory () = let StringCvt.padLeft #"0" 3 (Int.toString msecs) ^ "s" end end + fun filtP s = not (Lexis.ok_sml_identifier s) andalso + not (is_temp_binding s) in - case filter (not o Lexis.ok_sml_identifier) (map fst (A@D@T)) of + case filter filtP (map fst (A@D@T)) of [] => (let val ostrm1 = Portable.open_out(concat["./",name,".sig"]) val ostrm2 = Portable.open_out(concat["./",name,".sml"]) diff --git a/src/postkernel/TheoryPP.sig b/src/postkernel/TheoryPP.sig index 3361289e27..ad0bdcd51f 100644 --- a/src/postkernel/TheoryPP.sig +++ b/src/postkernel/TheoryPP.sig @@ -39,4 +39,7 @@ sig -> ppstream -> unit + val temp_binding : string -> string + val is_temp_binding : string -> bool + end diff --git a/src/postkernel/TheoryPP.sml b/src/postkernel/TheoryPP.sml index 4f53239bd1..24499c4380 100644 --- a/src/postkernel/TheoryPP.sml +++ b/src/postkernel/TheoryPP.sml @@ -15,6 +15,10 @@ open Feedback Lib Portable; val ERR = mk_HOL_ERR "TheoryPP"; +val temp_binding_pfx = "@temp" +val is_temp_binding = String.isPrefix temp_binding_pfx +fun temp_binding s = temp_binding_pfx ^ s + val pp_sig_hook = ref (fn () => ()); val concat = String.concat; @@ -90,9 +94,10 @@ fun pp_sig pp_thm info_record ppstrm = let add_newline,flush_ppstream,...} = Portable.with_ppstream ppstrm val pp_thm = pp_thm ppstrm val parents' = sort parents - val axioms' = psort axioms - val definitions' = psort definitions - val theorems' = psort theorems + val rm_temp = List.filter (fn (s, _) => not (is_temp_binding s)) + val axioms' = psort axioms |> rm_temp + val definitions' = psort definitions |> rm_temp + val theorems' = psort theorems |> rm_temp val thml = axioms@definitions@theorems fun vblock(header, ob_pr, obs) = (begin_block CONSISTENT 2; @@ -158,9 +163,11 @@ fun pp_sig pp_thm info_record ppstrm = let else () fun pthms (heading, ths) = vblock(heading, - (fn (s,th) => (begin_block CONSISTENT 0; - add_string(concat["val ",s, " : thm"]); - end_block())), ths) + (fn (s,th) => (if is_temp_binding s then () + else + (begin_block CONSISTENT 0; + add_string(concat["val ",s, " : thm"]); + end_block()))), ths) in begin_block CONSISTENT 0; add_string ("signature "^ThrySig name^" ="); add_newline(); @@ -343,18 +350,20 @@ fun pp_struct info_record = let fun pr_bind(s, th) = let val (tg, asl, w) = (Thm.tag th, Thm.hyp th, Thm.concl th) in - block INCONSISTENT 2 - (add_string "fun" >> add_break (1,0) >> add_string ("op "^s) >> - add_break(1,0) >> add_string ("x = x") >> add_newline >> - add_string "val">> - add_break(1,0)>> add_string ("op "^s) >> add_break(1,0)>> - add_string "=">> add_break(1,0)>> - add_string "DT(">> - block INCONSISTENT 0 - (C Tag.pp_to_disk tg>> - add_string ",">> add_break(1,0)>> - pp_sml_list pp_tm (w::asl))>> - add_string")") + if is_temp_binding s then fn _ => () + else + block INCONSISTENT 2 + (add_string "fun" >> add_break (1,0) >> add_string ("op "^s) >> + add_break(1,0) >> add_string ("x = x") >> add_newline >> + add_string "val">> + add_break(1,0)>> add_string ("op "^s) >> add_break(1,0)>> + add_string "=">> add_break(1,0)>> + add_string "DT(">> + block INCONSISTENT 0 + (C Tag.pp_to_disk tg>> + add_string ",">> add_break(1,0)>> + pp_sml_list pp_tm (w::asl))>> + add_string")") end fun stringbrk s = (add_string s >> add_break(1,0)) @@ -374,15 +383,19 @@ fun pp_struct info_record = let add_string"end") fun pr_dbtriple (class,th) = - block CONSISTENT 1 - (add_string"(" >> add_string (stringify th) >> add_string"," >> - add_break (0,0) >> add_string th >> add_string"," >> - add_break(0,0) >> add_string class >> add_string ")") + block CONSISTENT 1 + (add_string"(" >> add_string (stringify th) >> add_string"," >> + add_break (0,0) >> add_string th >> add_string"," >> + add_break(0,0) >> add_string class >> add_string ")") fun dblist () = - let val axl = map (fn (s,_) => ("DB.Axm",s)) axioms - val defl = map (fn (s,_) => ("DB.Def",s)) definitions - val thml = map (fn (s,_) => ("DB.Thm",s)) theorems + let + fun check tys = + List.mapPartial (fn (s, _) => if is_temp_binding s then NONE + else SOME (tys, s)) + val axl = check "DB.Axm" axioms + val defl = check "DB.Def" definitions + val thml = check "DB.Thm" theorems in block INCONSISTENT 0 (add_string "val _ = DB.bindl" >> add_break(1,0) >> diff --git a/src/ring/src/prelimScript.sml b/src/ring/src/prelimScript.sml index cac7b159a0..2652be43a6 100644 --- a/src/ring/src/prelimScript.sml +++ b/src/ring/src/prelimScript.sml @@ -10,10 +10,6 @@ val _ = new_theory "prelim"; val _ = Hol_datatype `ordering = LESS | EQUAL | GREATER`; -val _ = set_MLname "LESS" "LESS_def"; -val _ = set_MLname "EQUAL" "EQUAL_def"; -val _ = set_MLname "GREATER" "GREATER_def"; - val compare_def = Define ` (compare LESS lt eq gt = lt) /\ (compare EQUAL lt eq gt = eq) From be95efddfff50bbc4782f3cb97a16b69ec7d47cf Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 21 Jan 2015 10:17:55 +1100 Subject: [PATCH 130/718] Use new Theory.temp_binding to allow "silly" definitions/bindings Previously, bindings made in decompilerLib just got the name "(( step ))"; now the binding machinery rejects this with an exception. So, the code now has to generate a name that the Theory machinery won't reject. As a bonus, this name can't get exported either (though outdating constants will typically serve this purpose as well). --- examples/machine-code/decompiler/decompilerLib.sml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/machine-code/decompiler/decompilerLib.sml b/examples/machine-code/decompiler/decompilerLib.sml index 0ab5c270d9..f7d77f4bac 100644 --- a/examples/machine-code/decompiler/decompilerLib.sml +++ b/examples/machine-code/decompiler/decompilerLib.sml @@ -1638,7 +1638,7 @@ fun extract_function name th entry exit function_in_out = let val main_thm = finalise main_thm val pre_thm = finalise pre_thm (* define temporary abbreviation *) - val silly_string = "(( step ))" + val silly_string = Theory.temp_binding "(( step ))" val step_def = new_definition (silly_string,mk_eq(mk_var(silly_string,type_of step_fun),step_fun)) From b93abac8852ac717c35b2433fde71531c4fc1af7 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 21 Jan 2015 16:56:06 +1100 Subject: [PATCH 131/718] A test-case for a Holmake bug. This should break Moscow ML builds, but Poly/ML builds from nothing get around it because of a hacky use of a reference in Holdep. If the Poly/ML build is staged, then the bug resurfaces. --- tools/Holmake/tests/depchain1/dir1/baseScript.sml | 7 +++++++ tools/Holmake/tests/depchain1/dir2/Holmakefile | 1 + tools/Holmake/tests/depchain1/dir2/baseLib.sig | 6 ++++++ tools/Holmake/tests/depchain1/dir2/baseLib.sml | 8 ++++++++ tools/Holmake/tests/depchain1/dir3/Holmakefile | 1 + tools/Holmake/tests/depchain1/dir3/lastScript.sml | 10 ++++++++++ tools/Holmake/tests/depchain1/dir3/nextScript.sml | 9 +++++++++ tools/sequences/kernel | 1 + 8 files changed, 43 insertions(+) create mode 100644 tools/Holmake/tests/depchain1/dir1/baseScript.sml create mode 100644 tools/Holmake/tests/depchain1/dir2/Holmakefile create mode 100644 tools/Holmake/tests/depchain1/dir2/baseLib.sig create mode 100644 tools/Holmake/tests/depchain1/dir2/baseLib.sml create mode 100644 tools/Holmake/tests/depchain1/dir3/Holmakefile create mode 100644 tools/Holmake/tests/depchain1/dir3/lastScript.sml create mode 100644 tools/Holmake/tests/depchain1/dir3/nextScript.sml diff --git a/tools/Holmake/tests/depchain1/dir1/baseScript.sml b/tools/Holmake/tests/depchain1/dir1/baseScript.sml new file mode 100644 index 0000000000..95a409b3b0 --- /dev/null +++ b/tools/Holmake/tests/depchain1/dir1/baseScript.sml @@ -0,0 +1,7 @@ +open HolKernel Parse boolLib + +val _ = new_theory "base"; + +val _ = save_thm("baseTRUTH", TRUTH) + +val _ = export_theory(); diff --git a/tools/Holmake/tests/depchain1/dir2/Holmakefile b/tools/Holmake/tests/depchain1/dir2/Holmakefile new file mode 100644 index 0000000000..088498f62a --- /dev/null +++ b/tools/Holmake/tests/depchain1/dir2/Holmakefile @@ -0,0 +1 @@ +INCLUDES = ../dir1 diff --git a/tools/Holmake/tests/depchain1/dir2/baseLib.sig b/tools/Holmake/tests/depchain1/dir2/baseLib.sig new file mode 100644 index 0000000000..8196cd1600 --- /dev/null +++ b/tools/Holmake/tests/depchain1/dir2/baseLib.sig @@ -0,0 +1,6 @@ +signature baseLib = +sig + + val do_base_thing : int -> int + +end diff --git a/tools/Holmake/tests/depchain1/dir2/baseLib.sml b/tools/Holmake/tests/depchain1/dir2/baseLib.sml new file mode 100644 index 0000000000..c3b53aeea2 --- /dev/null +++ b/tools/Holmake/tests/depchain1/dir2/baseLib.sml @@ -0,0 +1,8 @@ +structure baseLib :> baseLib = +struct + +open HolKernel baseTheory + +fun do_base_thing n = n + term_size (concl baseTRUTH) + +end diff --git a/tools/Holmake/tests/depchain1/dir3/Holmakefile b/tools/Holmake/tests/depchain1/dir3/Holmakefile new file mode 100644 index 0000000000..fbf507d364 --- /dev/null +++ b/tools/Holmake/tests/depchain1/dir3/Holmakefile @@ -0,0 +1 @@ +INCLUDES = ../dir2 diff --git a/tools/Holmake/tests/depchain1/dir3/lastScript.sml b/tools/Holmake/tests/depchain1/dir3/lastScript.sml new file mode 100644 index 0000000000..80ad7db142 --- /dev/null +++ b/tools/Holmake/tests/depchain1/dir3/lastScript.sml @@ -0,0 +1,10 @@ +open HolKernel Parse boolLib + +open nextTheory + +val _ = new_theory "last"; + +val _ = save_thm("last", TRUTH) + + +val _ = export_theory(); diff --git a/tools/Holmake/tests/depchain1/dir3/nextScript.sml b/tools/Holmake/tests/depchain1/dir3/nextScript.sml new file mode 100644 index 0000000000..abea9ddafb --- /dev/null +++ b/tools/Holmake/tests/depchain1/dir3/nextScript.sml @@ -0,0 +1,9 @@ +open HolKernel Parse boolLib + +open baseLib + +val _ = new_theory "next"; + +val _ = save_thm("B" ^ Int.toString (do_base_thing 3), TRUTH); + +val _ = export_theory(); diff --git a/tools/sequences/kernel b/tools/sequences/kernel index 0dc002a666..efe7945ff3 100644 --- a/tools/sequences/kernel +++ b/tools/sequences/kernel @@ -10,5 +10,6 @@ src/parse src/bool src/1 !src/1/theory_tests +!tools/Holmake/tests/depchain1/dir3 src/proofman [poly]bin/hol.bare From fac53deb3245e1f029ed32fe150e1b9b3a652778 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Thu, 22 Jan 2015 14:56:44 +1100 Subject: [PATCH 132/718] self-test for USE_SG_TAC and some other list-tactics --- src/1/selftest.sml | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/src/1/selftest.sml b/src/1/selftest.sml index 2c0d5ff408..3f43284082 100644 --- a/src/1/selftest.sml +++ b/src/1/selftest.sml @@ -500,5 +500,29 @@ val _ = tprint "Testing (foo THENL [...]) when foo solves" val _ = (ACCEPT_TAC TRUTH THENL [ACCEPT_TAC TRUTH]) ([], ``T``) handle HOL_ERR _ => die "FAILED!" val _ = print "OK\n" +val _ = let + val _ = tprint "Testing USE_SG_THEN" + val tac = REPEAT DISCH_TAC THEN CONJ_TAC THEN_LT USE_SG_THEN ASSUME_TAC 1 2 + THENL [POP_ASSUM MATCH_MP_TAC THEN CONJ_TAC, DISJ1_TAC] + THEN (FIRST_ASSUM ACCEPT_TAC) + val th = prove (``p ==> q ==> (p /\ q ==> r) ==> r /\ (r \/ s)``, tac) ; +in if hyp th = [] then print "OK\n" else die "FAILED" +end handle _ => die "FAILED!" + +val _ = let + val _ = tprint "Testing USE_SG_THEN and VALIDATE_LT" + val tac = CONJ_TAC THEN REPEAT DISCH_TAC + THEN_LT EVERY_LT [VALIDATE_LT (USE_SG_THEN ACCEPT_TAC 1 2), + NTH_GOAL (REPEAT STRIP_TAC) 1 ] + THEN (POP_ASSUM MATCH_MP_TAC) + THEN_LT NTH_GOAL CONJ_TAC 2 + THEN (FIRST_ASSUM ACCEPT_TAC) + val g = ``(p ==> q ==> (p /\ q ==> r) ==> r) /\ + (p ==> q ==> (p ==> r) ==> r)`` + val th = prove (g, tac) ; +in if hyp th = [] then print "OK\n" else die "FAILED" +end handle _ => die "FAILED!" + + val _ = Process.exit (if List.all substtest tests then Process.success else Process.failure) From ea019d4591d46811477d1036844aeffd54f3765c Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 28 Jan 2015 13:41:20 +1100 Subject: [PATCH 133/718] Get Poly/Holmake to apply the quotation filter to more files. The Moscow ML implementation just applies it to everything (and perhaps the Poly/ML implementation should do the same). The new behaviour in the Poly/ML code is to apply the filter if the ` character is detected, or if any character with code > 127 appears in the file to be consumed. Curiously, the quotation filter is applied within Holmake under Moscow ML, but within the load implementation in Poly/ML, and this lives in tools-poly/poly/poly-init2.ML. Because it isn't used in tools-poly/Holmake.sml, I can delete some redundant code in The test-case exercises this because it uses only "new style" quotations (enabled by 199f6f07d0). --- tools-poly/Holmake/Holmake.sml | 4 ---- tools-poly/poly/poly-init2.ML | 2 +- tools/Holmake/tests/altquote1/fooScript.sml | 7 +++++++ tools/sequences/kernel | 1 + 4 files changed, 9 insertions(+), 5 deletions(-) create mode 100644 tools/Holmake/tests/altquote1/fooScript.sml diff --git a/tools-poly/Holmake/Holmake.sml b/tools-poly/Holmake/Holmake.sml index 09ef8e9d02..a87bc9e9c0 100644 --- a/tools-poly/Holmake/Holmake.sml +++ b/tools-poly/Holmake/Holmake.sml @@ -344,10 +344,6 @@ val HOLDIR = case cmdl_HOLDIR of NONE => HOLDIR0 | SOME s => s val POLYMLLIBDIR = case cmdl_POLYMLLIBDIR of NONE => POLYMLLIBDIR0 | SOME s => s val SIGOBJ = normPath(OS.Path.concat(HOLDIR, "sigobj")); -val UNQUOTER = xable_string(fullPath [HOLDIR, "bin/unquote"]) -fun has_unquoter() = OS.FileSys.access(UNQUOTER, [OS.FileSys.A_EXEC]) -fun unquote_to file1 file2 = SYSTEML [UNQUOTER, file1, file2] - (* fun compile debug args = let val _ = if debug then print (" with command "^ diff --git a/tools-poly/poly/poly-init2.ML b/tools-poly/poly/poly-init2.ML index 98feb87436..03ad83636b 100644 --- a/tools-poly/poly/poly-init2.ML +++ b/tools-poly/poly/poly-init2.ML @@ -24,7 +24,7 @@ local case TextIO.input1 istrm of NONE => false | SOME #"`" => true - | SOME _ => loop() + | SOME c => Char.ord c > 127 orelse loop() in loop() before TextIO.closeIn istrm end handle IO.Io _ => false diff --git a/tools/Holmake/tests/altquote1/fooScript.sml b/tools/Holmake/tests/altquote1/fooScript.sml new file mode 100644 index 0000000000..47997bf01f --- /dev/null +++ b/tools/Holmake/tests/altquote1/fooScript.sml @@ -0,0 +1,7 @@ +open HolKernel Parse boolLib + +val _ = new_theory "foo"; + +val foo_def = new_definition("foo_def", “foo P x <=> P x”); + +val _ = export_theory(); diff --git a/tools/sequences/kernel b/tools/sequences/kernel index efe7945ff3..eb1b801a17 100644 --- a/tools/sequences/kernel +++ b/tools/sequences/kernel @@ -11,5 +11,6 @@ src/bool src/1 !src/1/theory_tests !tools/Holmake/tests/depchain1/dir3 +!tools/Holmake/tests/altquote1/ src/proofman [poly]bin/hol.bare From 8a464d08c97afbf8915a30aec09119baf63005be Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Wed, 28 Jan 2015 17:38:02 +1100 Subject: [PATCH 134/718] self-test for some list-tactics, eg ROTATE_LT, REVERSE_LT, SPLIT_LT --- src/1/selftest.sml | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/src/1/selftest.sml b/src/1/selftest.sml index a5f4841760..3ddce5d31a 100644 --- a/src/1/selftest.sml +++ b/src/1/selftest.sml @@ -506,6 +506,18 @@ fun test s = (save_thm(s, TRUTH); die "FAILED!") handle HOL_ERR _ => () val _ = List.app test badnames val _ = print "OK\n" +val _ = let + val _ = tprint "Testing structural list-tactics" + val tac = REPEAT DISCH_TAC THEN REPEAT CONJ_TAC THEN_LT + EVERY_LT [ (ROTATE_LT 2), + (SPLIT_LT 2 (REVERSE_LT, ROTATE_LT 1)), + (HEADGOAL (POP_ASSUM ACCEPT_TAC)), + (REPEAT_LT (ALLGOALS (POP_ASSUM (fn _ => ALL_TAC)) + THEN_LT HEADGOAL (POP_ASSUM ACCEPT_TAC))) ] ; + val th = prove (``a ==> b ==> c ==> d ==> a /\ b /\ c /\ d``, tac) ; +in if hyp th = [] then print "OK\n" else die "FAILED" +end handle _ => die "FAILED!" + val _ = let val _ = tprint "Testing USE_SG_THEN" val tac = REPEAT DISCH_TAC THEN CONJ_TAC THEN_LT USE_SG_THEN ASSUME_TAC 1 2 From ea4c358a88c6d013ff220428586b164faa3df816 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Wed, 28 Jan 2015 22:34:01 +1100 Subject: [PATCH 135/718] self-test for flatn (in goalStack) --- src/proofman/Holmakefile | 5 ++++- src/proofman/selftest.sml | 26 ++++++++++++++++++++++++++ 2 files changed, 30 insertions(+), 1 deletion(-) create mode 100644 src/proofman/selftest.sml diff --git a/src/proofman/Holmakefile b/src/proofman/Holmakefile index ed7efde375..f18a2314f6 100644 --- a/src/proofman/Holmakefile +++ b/src/proofman/Holmakefile @@ -8,7 +8,7 @@ TERMPP = $(dprot $(SIGOBJ)/term_pp.uo) DEPS = $(BOOLLIB) $(BOOLTHEORY) $(PRIMREC) $(TERMPP) \ proofManagerLib.uo History.uo \ - goalStack.uo goalTree.uo Manager.uo \ + goalStack.uo goalTree.uo Manager.uo selftest.exe \ $(dprot $(HOLDIR)/tools-poly/builder0.ML) \ $(dprot $(HOLDIR)/tools-poly/poly/poly-init2.ML) \ $(dprot $(SIGOBJ)/UnicodeChars.uo) \ @@ -21,6 +21,9 @@ DEPS = $(BOOLLIB) $(BOOLTHEORY) $(PRIMREC) $(TERMPP) \ $(dprot $(SIGOBJ)/ParseExtras.uo) \ $(dprot $(SIGOBJ)/TheoryPP.uo) +selftest.exe: selftest.uo + $(HOLMOSMLC) -o $@ $< + EXTRA_CLEANS = $(TARGET) $(TARGET): $(DEPS) diff --git a/src/proofman/selftest.sml b/src/proofman/selftest.sml new file mode 100644 index 0000000000..61f9af9f91 --- /dev/null +++ b/src/proofman/selftest.sml @@ -0,0 +1,26 @@ + +open HolKernel Parse goalStack Tactic Tactical +open testutils + +val _ = print "\n" + +val _ = set_trace "Unicode" 0 + +val _ = tprint "test of flatn" + +val _ = let + val g = ([], ``a ==> b ==> c ==> d ==> e ==> a /\ b /\ c /\ d /\ e``) : goal + val gstk = new_goal g Lib.I ; + val gstk = expand (REPEAT DISCH_TAC) gstk ; + val gstk = expand (REVERSE CONJ_TAC) gstk ; + val gstk = expand (REVERSE CONJ_TAC) gstk ; + val gstk = expand (REVERSE CONJ_TAC) gstk ; + val gstk = expand (REVERSE CONJ_TAC) gstk ; + val gstk = expand ALL_TAC gstk ; val 1 = length (top_goals gstk) ; + val gstk = flatn gstk 2 ; val 3 = length (top_goals gstk) ; + val gstk = flatn gstk 2 ; val 5 = length (top_goals gstk) ; + val gstk = flatn gstk 2 ; val 5 = length (top_goals gstk) ; + val gstk = expand_list (ALLGOALS (FIRST_ASSUM ACCEPT_TAC)) gstk ; + val th = extract_thm gstk ; + in if (hyp th, concl th) = g then print "OK\n" else die "FAILED" end ; + From 74e6839c728b698ae235d55797cc610123e0e792 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Thu, 29 Jan 2015 09:46:52 +1100 Subject: [PATCH 136/718] fix to src/proofman/Holmakefile see discussion at https://github.com/HOL-Theorem-Prover/HOL/pull/228 http://hol.sourceforge.net/kananaskis-10.release.html#incompatibilities (last item) refers --- src/proofman/Holmakefile | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/src/proofman/Holmakefile b/src/proofman/Holmakefile index f18a2314f6..a254f1dc0c 100644 --- a/src/proofman/Holmakefile +++ b/src/proofman/Holmakefile @@ -8,7 +8,7 @@ TERMPP = $(dprot $(SIGOBJ)/term_pp.uo) DEPS = $(BOOLLIB) $(BOOLTHEORY) $(PRIMREC) $(TERMPP) \ proofManagerLib.uo History.uo \ - goalStack.uo goalTree.uo Manager.uo selftest.exe \ + goalStack.uo goalTree.uo Manager.uo \ $(dprot $(HOLDIR)/tools-poly/builder0.ML) \ $(dprot $(HOLDIR)/tools-poly/poly/poly-init2.ML) \ $(dprot $(SIGOBJ)/UnicodeChars.uo) \ @@ -21,9 +21,6 @@ DEPS = $(BOOLLIB) $(BOOLTHEORY) $(PRIMREC) $(TERMPP) \ $(dprot $(SIGOBJ)/ParseExtras.uo) \ $(dprot $(SIGOBJ)/TheoryPP.uo) -selftest.exe: selftest.uo - $(HOLMOSMLC) -o $@ $< - EXTRA_CLEANS = $(TARGET) $(TARGET): $(DEPS) @@ -31,4 +28,11 @@ $(TARGET): $(DEPS) $(POLY) < builder0.ML && \ cc -o $(protect $@) hol.builder0.o $(POLY_LDFLAGS) && \ rm hol.builder0.o + +all: selftest.exe $(TARGET) +.PHONY: all + +selftest.exe: selftest.uo + $(HOLMOSMLC) -o $@ $< + endif From a94c141a91ddb2ee9c6faadd5b6db82774960335 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 29 Jan 2015 11:19:11 +1100 Subject: [PATCH 137/718] Start of a new approach to detecting SML/HOL dependencies. The advantage of this method is that it doesn't use a grammar; everything happens in the lexer. --- tools/Holmake/Holdep_tokens.lex | 110 ++++++++++++++++++++++++++++++++ tools/Holmake/MLton-LICENSE | 26 ++++++++ tools/Holmake/Region.sig | 36 +++++++++++ tools/Holmake/Region.sml | 79 +++++++++++++++++++++++ tools/Holmake/SourceFile.sig | 22 +++++++ tools/Holmake/SourceFile.sml | 44 +++++++++++++ tools/Holmake/SourcePos.sig | 26 ++++++++ tools/Holmake/SourcePos.sml | 52 +++++++++++++++ tools/Holmake/holdeptool.sml | 46 +++++++++++++ 9 files changed, 441 insertions(+) create mode 100644 tools/Holmake/Holdep_tokens.lex create mode 100644 tools/Holmake/MLton-LICENSE create mode 100644 tools/Holmake/Region.sig create mode 100644 tools/Holmake/Region.sml create mode 100644 tools/Holmake/SourceFile.sig create mode 100644 tools/Holmake/SourceFile.sml create mode 100644 tools/Holmake/SourcePos.sig create mode 100644 tools/Holmake/SourcePos.sml create mode 100644 tools/Holmake/holdeptool.sml diff --git a/tools/Holmake/Holdep_tokens.lex b/tools/Holmake/Holdep_tokens.lex new file mode 100644 index 0000000000..a9a5f81294 --- /dev/null +++ b/tools/Holmake/Holdep_tokens.lex @@ -0,0 +1,110 @@ +(* though strictly an mllex file, -*- sml -*- mode works OK *) +type lexstate = { + commentdepth : int ref, + commentstart : SourcePos.t ref, + in_string : bool ref, + stringstart : SourcePos.t ref, + source : SourceFile.t +} +fun new_state fname = {commentdepth = ref 0, + commentstart = ref SourcePos.bogus, + stringstart = ref SourcePos.bogus, + in_string = ref false, + source = SourceFile.new fname} + +fun inputLine strm = + case TextIO.inputLine strm of + SOME s => s + | NONE => "" + +type lexresult = string option +exception LEX_ERROR of string +fun regionError (r, s) = Region.toString r ^ ": " ^ s +fun lexErrorP(source, yypos, s) = + let + val p = SourceFile.getPos(source, yypos) + val r = Region.make {left = p, right = p} + in + raise LEX_ERROR(regionError(r, s)) + end +fun lexErrorR(region, s) = raise LEX_ERROR(regionError(region,s)) + +fun eof ({commentdepth,source,commentstart,in_string,stringstart,...} : lexstate) = + let + fun mkr st = Region.make{left = st, right = SourceFile.lineStart source} + in + if !commentdepth <> 0 then + lexErrorR(mkr (!commentstart), "Unclosed comment") + else if !in_string then + lexErrorR(mkr (!stringstart), "Unterminated string") + else NONE + end + +fun getQual s = + let + fun parse n = + if String.sub(s, n) = #"." then + String.extract(s, 0, SOME n) + else + parse (n+1) + in + parse 0 + end; + +%% +id = [A-Za-z][A-Za-z0-9_']* | [-!%&$#+/:<=>?@~^|*`\\]+; +ws = [\ \013\t]; +newline = "\n" | "\013\n"; +openterminator = "val" | "fun" | "in" | "infix[lr]?" | "local" | "type" | "datatype" | "nonfix" | "exception" | "end" | "structure" | "signature"; +%s OPEN STRING COMMENT INCLUDE STRINGCONT; +%arg ({source, commentdepth, commentstart, in_string, stringstart, ...}:UserDeclarations.lexstate); +%structure Holdep_tokens +%% +{ws} => (continue()); +{newline} => + (SourceFile.newline(source,yypos+size yytext); continue()); +"(*" => ( + YYBEGIN COMMENT; + commentstart := SourceFile.getPos(source, yypos); + commentdepth := 1; + continue()); +"*)" => ( + lexErrorP(source, yypos, "Unmatched comment bracket") +); +'[A-Za-z0-9_']+ => (continue()); +~?[0-9]+(\.[0-9]+)?(E~?[0-9]+)? => (continue()); +\" | #\" => ( + YYBEGIN STRING; + stringstart := SourceFile.getPos(source, yypos); + in_string := true; + continue()); +[_,{}[();] | ] | "..." => (continue()); +({id}\.)+{id} => (SOME (getQual yytext)); +"open" => (YYBEGIN OPEN; continue()); +"include" => (YYBEGIN INCLUDE; continue()); +{id} => (continue()); + +"(*" => (commentdepth := !commentdepth + 1; continue()); +"*)" => (commentdepth := !commentdepth - 1; + YYBEGIN (if !commentdepth = 0 then INITIAL else COMMENT); + continue()); +. => (continue()); + +{openterminator} => (YYBEGIN INITIAL; continue()); +"open" => (continue()); +{id} => (SOME yytext); + +"\\\"" => (continue()); +"\\" {newline} => (SourceFile.newline(source,yypos+size yytext); + YYBEGIN STRINGCONT; + continue()); +"\\" {ws} => (YYBEGIN STRINGCONT; continue()); +"\\" . => (continue()); +\" => (YYBEGIN INITIAL; in_string := false; continue()); +. => (continue()); +{newline} => (lexErrorP(source, yypos, "String terminated by newline")); + +{ws} => (continue()); +{newline} => (SourceFile.newline(source,yypos+size yytext); continue()); +"\\" => (YYBEGIN STRING; continue()); + . => (lexErrorP(source, yypos, "Invalid character in \\ ... \\")); diff --git a/tools/Holmake/MLton-LICENSE b/tools/Holmake/MLton-LICENSE new file mode 100644 index 0000000000..6d8d9bb066 --- /dev/null +++ b/tools/Holmake/MLton-LICENSE @@ -0,0 +1,26 @@ +This is the license for MLton, a whole-program optimizing compiler for +the Standard ML programming language. Send comments and questions to +MLton@mlton.org. + +MLton COPYRIGHT NOTICE, LICENSE AND DISCLAIMER. + +Copyright (C) 1999-2005 Henry Cejtin, Matthew Fluet, Suresh + Jagannathan, and Stephen Weeks. +Copyright (C) 1997-2000 by the NEC Research Institute + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both the copyright notice and this permission notice and warranty +disclaimer appear in supporting documentation, and that the name of +NEC, or any NEC entity not be used in advertising or publicity +pertaining to distribution of the software without specific, written +prior permission. + +NEC disclaims all warranties with regard to this software, including +all implied warranties of merchantability and fitness. In no event +shall NEC be liable for any special, indirect or consequential damages +or any damages whatsoever resulting from loss of use, data or profits, +whether in an action of contract, negligence or other tortious action, +arising out of or in connection with the use or performance of this +software. diff --git a/tools/Holmake/Region.sig b/tools/Holmake/Region.sig new file mode 100644 index 0000000000..1433327336 --- /dev/null +++ b/tools/Holmake/Region.sig @@ -0,0 +1,36 @@ +(* Copyright (C) 1999-2002 Henry Cejtin, Matthew Fluet, Suresh + * Jagannathan, and Stephen Weeks. + * Copyright (C) 1997-1999 NEC Research Institute. + * + * MLton is released under a BSD-style license. + * Please see the file MLton-LICENSE for license information. + *) +signature Region = + sig + + type t + + val <= : t * t -> bool + val append: t * t -> t + val bogus: t + val compare: t * t -> order + val equals: t * t -> bool + val extendRight: t * SourcePos.t -> t + val left: t -> SourcePos.t option + val list: 'a list * ('a -> t) -> t + val make: {left: SourcePos.t, right: SourcePos.t} -> t + val right: t -> SourcePos.t option + val toString: t -> string + + structure Wrap: + sig + type region + type 'a t + val region: 'a t -> region + val node: 'a t -> 'a + val makeRegion: 'a * region -> 'a t + val makeRegion': 'a * SourcePos.t * SourcePos.t -> 'a t + val dest: 'a t -> 'a * region + end + sharing type Wrap.region = t + end diff --git a/tools/Holmake/Region.sml b/tools/Holmake/Region.sml new file mode 100644 index 0000000000..173e66b7f3 --- /dev/null +++ b/tools/Holmake/Region.sml @@ -0,0 +1,79 @@ +(* Copyright (C) 1999-2002 Henry Cejtin, Matthew Fluet, Suresh + * Jagannathan, and Stephen Weeks. + * Copyright (C) 1997-1999 NEC Research Institute. + * + * MLton is released under a BSD-style license. + * Please see the file MLton-LICENSE for license information. + *) + +structure Region :> Region = +struct + +datatype t = + Bogus + | T of {left: SourcePos.t, + right: SourcePos.t} + +val bogus = Bogus + +local + fun make f r = + case r of + Bogus => NONE + | T r => SOME (f r) +in + val left = make #left + val right = make #right +end + +val extendRight = + fn (Bogus, _) => Bogus + | (T {left, ...}, right) => T {left = left, right = right} + +val toString = + fn Bogus => "Bogus" + | T {left, right} => + String.concat [SourcePos.file left, ":", + SourcePos.posToString left, "-", SourcePos.posToString right] + +val make = T + +val append = + fn (Bogus, r) => r + | (r, Bogus) => r + | (T {left, ...}, T {right, ...}) => T {left = left, right = right} + +fun list (xs, reg) = List.foldl (fn (x, r) => append (reg x, r)) Bogus xs + +fun compare (r, r') = + case (left r, left r') of + (NONE, NONE) => EQUAL + | (NONE, _) => LESS + | (_, NONE) => GREATER + | (SOME p, SOME p') => SourcePos.compare (p, p') + +fun equals (r, r') = compare (r, r') = EQUAL + +fun r <= r' = + case compare (r, r') of + EQUAL => true + | GREATER => false + | LESS => true + +structure Wrap = + struct + type region = t + datatype 'a t = T of {node: 'a, + region: region} + + fun node (T {node, ...}) = node + fun region (T {region, ...}) = region + fun makeRegion (node, region) = T {node = node, region = region} + fun makeRegion' (node, left, right) = T {node = node, + region = make {left = left, + right = right}} + + fun dest (T {node, region}) = (node, region) + end + +end diff --git a/tools/Holmake/SourceFile.sig b/tools/Holmake/SourceFile.sig new file mode 100644 index 0000000000..edaf9bbe85 --- /dev/null +++ b/tools/Holmake/SourceFile.sig @@ -0,0 +1,22 @@ +(* Copyright (C) 1999-2002 Henry Cejtin, Matthew Fluet, Suresh + * Jagannathan, and Stephen Weeks. + * Copyright (C) 1997-1999 NEC Research Institute. + * + * MLton is released under a BSD-style license. + * Please see the file MLton-LICENSE for license information. + *) +signature SourceFile = + sig + type t + + (* The pos in the following specs is a file position (e.g. yypos of mllex). + *) + val getPos: t * int -> SourcePos.t + val observe_line_directives : bool ref + val lineDirective: + t * string option * {lineNum: int, lineStart: int} -> unit + val lineStart: t -> SourcePos.t + + val new: string -> t + val newline: t * int -> unit + end; diff --git a/tools/Holmake/SourceFile.sml b/tools/Holmake/SourceFile.sml new file mode 100644 index 0000000000..750d0f5c84 --- /dev/null +++ b/tools/Holmake/SourceFile.sml @@ -0,0 +1,44 @@ +(* Copyright (C) 1999-2002 Henry Cejtin, Matthew Fluet, Suresh + * Jagannathan, and Stephen Weeks. + * Copyright (C) 1997-1999 NEC Research Institute. + * + * MLton is released under a BSD-style license. + * Please see the file MLton-LICENSE for license information. + *) + +structure SourceFile :> SourceFile = +struct + +datatype t = T of {file: string ref, + lineNum: int ref, + lineStart: int ref} + +fun getPos (T {file, lineNum, lineStart, ...}, n) = + SourcePos.make {column = n - !lineStart, + file = !file, + line = !lineNum} + +fun lineStart (s as T {lineStart, ...}) = getPos (s, !lineStart) + +val observe_line_directives = ref true + +fun new file = T {file = ref file, + lineNum = ref 1, + lineStart = ref 0} + +fun newline (T {lineStart, lineNum, ...}, n) = + (lineNum := !lineNum + 1 + ; lineStart := n) + +fun lineDirective (src as T {file, lineNum, lineStart}, + f, + {lineNum = n, lineStart = s}) = + if !observe_line_directives then + (Option.app (fn f => file := f) f + ; lineNum := n + ; lineStart := s) + else newline(src,s) + + + +end; diff --git a/tools/Holmake/SourcePos.sig b/tools/Holmake/SourcePos.sig new file mode 100644 index 0000000000..f78c5e4039 --- /dev/null +++ b/tools/Holmake/SourcePos.sig @@ -0,0 +1,26 @@ +(* Copyright (C) 1999-2002 Henry Cejtin, Matthew Fluet, Suresh + * Jagannathan, and Stephen Weeks. + * Copyright (C) 1997-1999 NEC Research Institute. + * + * MLton is released under a BSD-style license. + * Please see the file MLton-LICENSE for license information. + + * Slightly adjusted by Michael Norrish (2006) + + *) + +signature SourcePos = +sig + + type t + + val bogus: t + val column: t -> int + val compare: t * t -> order + val equals: t * t -> bool + val file: t -> string + val line: t -> int + val make: {column: int, file: string, line: int} -> t + val toString: t -> string + val posToString : t -> string +end diff --git a/tools/Holmake/SourcePos.sml b/tools/Holmake/SourcePos.sml new file mode 100644 index 0000000000..b7f79fcbec --- /dev/null +++ b/tools/Holmake/SourcePos.sml @@ -0,0 +1,52 @@ +(* Copyright (C) 1999-2002 Henry Cejtin, Matthew Fluet, Suresh + * Jagannathan, and Stephen Weeks. + * Copyright (C) 1997-1999 NEC Research Institute. + * + * MLton is released under a BSD-style license. + * Please see the file MLton-LICENSE for license information. + + * Slightly adjusted by Michael Norrish (2006) + + *) + +structure SourcePos :> SourcePos = +struct + +datatype t = T of {column: int, file: string, line: int} + +local + fun f g (T r) = g r +in + val column = f #column + val line = f #line +end + +fun compare (T {column = c, file = f, line = l}, + T {column = c', file = f', line = l'}) = + case String.compare (f, f') of + EQUAL => + (case Int.compare (l, l') of + EQUAL => Int.compare (c, c') + | r => r) + | r => r + +fun equals (T r, T r') = r = r' + +fun make {column, file, line} = + T {column = column, + file = file, + line = line} + +fun file (p as T {file, ...}) = file + +val bogus = T {column = ~1, + file = "", + line = ~1} + +fun toString (p as T {column, line, ...}) = + String.concat [file p, " ", Int.toString line, ".", Int.toString column] + +fun posToString (T {column,line,...}) = + String.concat [Int.toString line, ".", Int.toString column] + +end diff --git a/tools/Holmake/holdeptool.sml b/tools/Holmake/holdeptool.sml new file mode 100644 index 0000000000..929a091ad8 --- /dev/null +++ b/tools/Holmake/holdeptool.sml @@ -0,0 +1,46 @@ +structure holdeptool = +struct + +fun die () = OS.Process.exit OS.Process.failure +fun ok () = OS.Process.exit OS.Process.success +fun usage k = + (TextIO.output(TextIO.stdErr, + "Usage:\n " ^ CommandLine.name() ^ " [-h | -n [file]]"); + k()) +fun diewith s = (TextIO.output(TextIO.stdErr, s ^ "\n"); die()) + +fun main() = let + open Holdep_tokens + val stdin = (TextIO.stdIn, "", (fn () => ())) + fun file f = let + val strm = TextIO.openIn f + in + (strm, f, (fn () => TextIO.closeIn strm)) + end + val unsorted = ref false + val (strm, fname, closer) = + case CommandLine.arguments() of + [] => stdin + | ["-n"] => (unsorted := true; stdin) + | ["-h"] => usage ok + | [fname] => file fname + | ["-n", fname] => (unsorted := true; file fname) + | _ => usage die + val arg = UserDeclarations.new_state fname + val lexer = makeLexer (fn _ => UserDeclarations.inputLine strm) arg + fun safelex () = + lexer() handle UserDeclarations.LEX_ERROR s => diewith ("Lexical error: "^ s) + fun unsortedf () = + case safelex() of + NONE => closer() + | SOME s => (TextIO.print (s ^ "\n"); unsortedf()) + fun sorted acc = + case safelex() of + NONE => (closer(); + Binaryset.app (fn s => print (s ^ "\n")) acc) + | SOME s => sorted (Binaryset.add(acc, s)) +in + if !unsorted then unsortedf() else sorted (Binaryset.empty String.compare) +end + +end (* struct *) From 5b4f05103203ef0472dd67d193010e868effedad Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 29 Jan 2015 12:17:55 +1100 Subject: [PATCH 138/718] Start to rationalise Holdep's interface. There were some strange holdovers still in there from the ancient days when it was a separate command-line tool. Aim is to ultimately drop Lexer.lex and Parser.grm and replace those with the Holdep_tokens lexer. I'm also only doing this to the Moscow ML implementation for the moment with the ultimate aim being to have the Poly and mosml implementations using the same Holdep code. --- tools/Holmake/Holdep.sig | 11 ++++++++ tools/Holmake/Holdep.sml | 57 ++++++++++++++++----------------------- tools/Holmake/Holmake.sml | 23 +++++++++------- tools/configure.sml | 1 + 4 files changed, 49 insertions(+), 43 deletions(-) create mode 100644 tools/Holmake/Holdep.sig diff --git a/tools/Holmake/Holdep.sig b/tools/Holmake/Holdep.sig new file mode 100644 index 0000000000..9d9b1c47dc --- /dev/null +++ b/tools/Holmake/Holdep.sig @@ -0,0 +1,11 @@ +signature Holdep = +sig + + +val main : { assumes : string list, + includes : string list, + debug : bool, + fname : string } -> string + + +end diff --git a/tools/Holmake/Holdep.sml b/tools/Holmake/Holdep.sml index 4b803702a2..33e4cd7b11 100644 --- a/tools/Holmake/Holdep.sml +++ b/tools/Holmake/Holdep.sml @@ -8,7 +8,8 @@ sources, first by Ken Larsen and later by Konrad Slind and Michael Norrish. *) -structure Holdep = struct +structure Holdep :> Holdep = +struct structure Process = OS.Process @@ -56,31 +57,17 @@ end; fun parseFile (f, strm) = parsePhraseAndClear (f, strm) Parser.MLtext Lexer.Token; -local val path = ref [""] - fun lpcl [] = (errMsg "No filenames"; fail()) - | lpcl ("-I"::dir::tail) = (path := dir :: !path ; lpcl tail) - | lpcl l = l -in -fun parseComLine l = - let val s = lpcl l - in - path := List.rev (!path); - s - end - -fun access assumes cdir s ext = let +fun access {assumes, includes} cdir s ext = let val sext = addExt s ext fun inDir dir = FileSys.access (addDir dir sext, []) in if inDir cdir orelse List.exists (fn nm => nm = sext) assumes then SOME s else - case List.find inDir (!path) of + case List.find inDir includes of SOME dir => SOME(addDir dir s) | NONE => NONE end -end (* local *) - local val res = ref []; in fun isTheory s = @@ -90,29 +77,29 @@ fun isTheory s = | _ => NONE fun addThExt s s' ext = addExt (addDir (Path.dir s') s) ext -fun outname assumes cdir s = +fun outname (rcd as {assumes,includes}) cdir s = case isTheory s of SOME n => let in (* allow a dependency on a theory if we can see a script.sml file *) - case access assumes cdir (n^"Script") "sml" of + case access rcd cdir (n^"Script") "sml" of SOME s' => res := addThExt s s' "ui" :: !res | NONE => let in (* or, if we can see the theory.ui file already; which might happen if the theory file is in sigobj *) - case access assumes cdir (n^"Theory") "ui" of + case access rcd cdir (n^"Theory") "ui" of SOME s' => res := addThExt s s' "ui" :: !res | NONE => () end end | _ => let in - case access assumes cdir s "sig" of + case access rcd cdir s "sig" of SOME s' => res := addExt s' "ui" :: !res | _ => let in - case access assumes cdir s "sml" of + case access rcd cdir s "sml" of (* this case handles the situation where there is no .sig file locally, but a .sml file instead; compiling this will generate the .ui file too. We have to say that we're dependent @@ -130,7 +117,7 @@ fun outname assumes cdir s = so making the dependency analysis ignore foo. We cover this possibility by looking to see if we can see a .ui file; if so, we can retain the dependency *) - case access assumes cdir s "ui" of + case access rcd cdir s "ui" of SOME s' => res := addExt s' "ui" :: !res | NONE => () end @@ -162,7 +149,7 @@ fun endentry() = (* for non-file-based Holdep *) else "" end; -fun read assumes srcext objext filename = let +fun read {assumes, includes, srcext, objext, filename} = let open OS.FileSys Systeml val op ^ = Path.concat val unquote = xable_string(Systeml.HOLDIR ^ "bin" ^ "unquote") @@ -186,34 +173,36 @@ fun read assumes srcext objext filename = let FileSys.remove actualfile handle _ => () else () val curr_dir = Path.dir filename + val outrcd = {assumes = assumes, includes = includes} in beginentry objext (manglefilename filename); app insert names; - Polyhash.apply (outname assumes curr_dir o manglefilename o #1) mentions; + Polyhash.apply (outname outrcd curr_dir o manglefilename o #1) mentions; endentry () end handle (e as Parsing.ParseError _) => (print "Parse error!\n"; raise e) -fun processfile assumes filename = +fun processfile {assumes, includes, fname = filename, debug} = let (* val _ = output(std_err, "Processing " ^ filename ^ "\n"); *) val {base, ext} = Path.splitBaseExt filename in case ext of - SOME "sig" => read assumes "sig" "ui" base - | SOME "sml" => read assumes "sml" "uo" base + SOME "sig" => read {assumes = assumes, srcext = "sig", objext = "ui", + filename = base, includes = includes} + | SOME "sml" => read {assumes = assumes, srcext = "sml", objext = "uo", + filename = base, includes = includes} | _ => "" end (* assumes parameter is a list of files that we assume can be built in this directory *) -fun main assumes debug sl = - let val cl_args = parseComLine sl - val results = List.map (processfile assumes) cl_args - val final = String.concat results +fun main (r as {assumes, debug, includes, fname}) = + let + val results = processfile r in - if debug then print ("Holdep: "^final^"\n") else (); - final + if debug then print ("Holdep: "^results^"\n") else (); + results end handle e as OS.SysErr (str, _) => (errMsg str; raise e) diff --git a/tools/Holmake/Holmake.sml b/tools/Holmake/Holmake.sml index b30939f3da..e20aed5470 100644 --- a/tools/Holmake/Holmake.sml +++ b/tools/Holmake/Holmake.sml @@ -465,9 +465,9 @@ val envlist = envlist hmakefile_env val hmake_includes = envlist "INCLUDES" val hmake_options = envlist "OPTIONS" val additional_includes = - includify (remove_duplicates (cline_additional_includes @ hmake_includes)) + remove_duplicates (cline_additional_includes @ hmake_includes) -val hmake_preincludes = includify (envlist "PRE_INCLUDES") +val hmake_preincludes = envlist "PRE_INCLUDES" val hmake_no_overlay = member "NO_OVERLAY" hmake_options val hmake_no_basis2002 = member "NO_BASIS2002" hmake_options val hmake_no_sigobj = member "NO_SIGOBJ" hmake_options @@ -498,7 +498,7 @@ val actual_overlay = NONE => SOME DEFAULT_OVERLAY | SOME _ => user_overlay -val std_include_flags = if no_sigobj then [] else ["-I", SIGOBJ] +val std_include_flags = if no_sigobj then [] else [SIGOBJ] fun extra_deps t = @@ -641,10 +641,15 @@ fun runholdep arg destination_file = let map fromFile files end val buildable_extras = List.concat (map buildables extra_targets) + val includes = hmake_preincludes @ std_include_flags @ additional_includes + val _ = diag ("Running Holdep on "^fromFile arg^" with debug = "^ + Bool.toString debug ^ ", includes = " ^ + String.concatWith "," includes) val result = - Success(Holdep.main buildable_extras debug - (hmake_preincludes @ std_include_flags @ - additional_includes @ [fromFile arg])) + Success(Holdep.main {assumes = buildable_extras, debug = debug, + includes = hmake_preincludes @ std_include_flags @ + additional_includes, + fname = fromFile arg}) handle _ => (print "Holdep failed.\n"; Failure "") fun myopen s = if FileSys.access(DEPDIR, []) then @@ -789,8 +794,8 @@ datatype buildcmds = MOSMLC val failed_script_cache = ref (Binaryset.empty String.compare) fun build_command c arg = let - val include_flags = hmake_preincludes @ std_include_flags @ - additional_includes + val include_flags = includify (hmake_preincludes @ std_include_flags @ + additional_includes) (* val include_flags = ["-I",SIGOBJ] @ additional_includes *) val overlay_stringl = case actual_overlay of @@ -1104,7 +1109,7 @@ fun hm_recur ctgt k = {warn = warn, no_prereqs = no_prereqs, hm = Holmake, visited = visiteddirs, includes = - cline_additional_includes @ envlist "PRE_INCLUDES" @ hmake_includes, + cline_additional_includes @ hmake_preincludes @ hmake_includes, dir = {abspath = dir, relpath = dirnm}, local_build = k, cleantgt = ctgt} in diff --git a/tools/configure.sml b/tools/configure.sml index 7e140f9d06..bf5468f4c6 100644 --- a/tools/configure.sml +++ b/tools/configure.sml @@ -360,6 +360,7 @@ val _ = compile [] "Parser.sig"; compile [] "Parser.sml"; compile [] "Lexer.sml"; + compile [] "Holdep.sig"; compile [] "Holdep.sml"; compile [] "regexpMatch.sig"; compile [] "regexpMatch.sml"; From 05417c4857fc12af8887e3a1bf7d9e63e0c75aa7 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Thu, 29 Jan 2015 13:50:25 +1100 Subject: [PATCH 139/718] test for VALIDATE in src/1/selftest --- src/1/selftest.sml | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) diff --git a/src/1/selftest.sml b/src/1/selftest.sml index 3ddce5d31a..81c4dda37e 100644 --- a/src/1/selftest.sml +++ b/src/1/selftest.sml @@ -506,6 +506,37 @@ fun test s = (save_thm(s, TRUTH); die "FAILED!") handle HOL_ERR _ => () val _ = List.app test badnames val _ = print "OK\n" +val _ = let + val _ = tprint "Testing VALIDATE (1)" + val th' = Thm.mk_oracle_thm "Testing" ([], ``p' ==> q``) ; + val th = Thm.mk_oracle_thm "Testing" ([], ``p ==> q``) ; + val uth' = UNDISCH_ALL th' ; + val uth = UNDISCH_ALL th ; + + val g = ([], ``p ==> q``) : goal ; + val ([g'], _) = STRIP_TAC g ; + val ([], _) = (FIRST (map (VALID o ACCEPT_TAC) [uth', uth])) g' ; + val ([_], _) = (VALIDATE (FIRST (map ACCEPT_TAC [uth', uth]))) g' ; + val true = (VALID (FIRST (map ACCEPT_TAC [uth', uth])) g' ; false) + handle HOL_ERR _ => true ; +in print "OK\n" +end handle _ => die "FAILED!" + +val _ = let + val _ = tprint "Testing VALIDATE (2)" + val g = ([], ``(p ==> q) ==> r``) : goal ; + val tac = STRIP_TAC THEN VALIDATE (POP_ASSUM (ASSUME_TAC o UNDISCH)) ; + val (ngs, vf) = VALID tac g ; + + val tac1 = (VALIDATE (ASSUME_TAC (ASSUME ``x /\ y``))) ; + val tac2 = (SUBGOAL_THEN ``x /\ y`` ASSUME_TAC ) ; + + val (ngs1, _) = VALID tac1 g ; + val (ngs2, _) = VALID tac2 g ; + val true = ngs1 = ngs2 ; +in print "OK\n" +end handle _ => die "FAILED!" + val _ = let val _ = tprint "Testing structural list-tactics" val tac = REPEAT DISCH_TAC THEN REPEAT CONJ_TAC THEN_LT From cfea4edb0e3df67f2db37c7f8bbb8766c0728135 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Thu, 29 Jan 2015 14:26:52 +1100 Subject: [PATCH 140/718] test of find_in, apropos_in, in src/bool/selftest --- src/bool/Holmakefile | 8 ++++++++ src/bool/selftest.sml | 25 +++++++++++++++++++++++++ 2 files changed, 33 insertions(+) create mode 100644 src/bool/Holmakefile create mode 100644 src/bool/selftest.sml diff --git a/src/bool/Holmakefile b/src/bool/Holmakefile new file mode 100644 index 0000000000..e7ac4eabd7 --- /dev/null +++ b/src/bool/Holmakefile @@ -0,0 +1,8 @@ +UOFILES = $(patsubst %.sml,%.uo,$(wildcard *.sml)) + +all: selftest.exe $(UOFILES) + +.PHONY: all + +selftest.exe: selftest.uo DB.uo + $(HOLMOSMLC) -o $@ $< diff --git a/src/bool/selftest.sml b/src/bool/selftest.sml new file mode 100644 index 0000000000..76395a72fb --- /dev/null +++ b/src/bool/selftest.sml @@ -0,0 +1,25 @@ + +open HolKernel Parse DB +(* open testutils NOT YET BUILT - therefore need following lines *) + +fun die s = (print (s ^ "\n"); OS.Process.exit OS.Process.failure) +fun tprint s = print (StringCvt.padRight #" " 65 (s ^ " ... ")) + +val _ = print "\n" + +val _ = set_trace "Unicode" 0 + +val _ = tprint "test of apropos_in, find_in" + +val _ = let + val str = "THM" ; + val tm = ``$/\`` ; + val find1 = find str ; + val list1 = apropos_in tm find1 ; + val apropos2 = apropos tm ; + val list2 = find_in str apropos2 ; + val true = length list1 = length list2 ; + (* next test may be implementation dependent *) + val true = map #1 list1 = map #1 list2 ; +in print "OK\n" end handle _ => die "FAILED" ; + From f30c7f3873d747995f1d40dff3d84c87ca059d23 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Thu, 29 Jan 2015 14:48:52 +1100 Subject: [PATCH 141/718] trying something different for src/bool/Holmakefile --- src/bool/Holmakefile | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/bool/Holmakefile b/src/bool/Holmakefile index e7ac4eabd7..a6fcb49819 100644 --- a/src/bool/Holmakefile +++ b/src/bool/Holmakefile @@ -1,7 +1,8 @@ -UOFILES = $(patsubst %.sml,%.uo,$(wildcard *.sml)) -all: selftest.exe $(UOFILES) +THYFILES = $(patsubst %Script.sml,%Theory.uo,$(wildcard *.sml)) +TARGETS = $(patsubst %.sml,%.uo,$(THYFILES)) +all: $(TARGETS) selftest.exe .PHONY: all selftest.exe: selftest.uo DB.uo From 00cde98cbb50da0437fb1050b5d80e45e55e3672 Mon Sep 17 00:00:00 2001 From: Konrad Slind Date: Thu, 29 Jan 2015 16:01:48 -0600 Subject: [PATCH 142/718] fixed Scott's TFL bug on tc-extraction for higher order combinators like pair_cmp. --- src/boss/bossLib.sml | 2 +- src/tfl/examples/test.Define | 89 ++++--- src/tfl/src/Defn.sml | 3 +- src/tfl/src/RW.sml | 441 +++++++++++++---------------------- 4 files changed, 217 insertions(+), 318 deletions(-) diff --git a/src/boss/bossLib.sml b/src/boss/bossLib.sml index 7e9f2474bb..b6f4459832 100644 --- a/src/boss/bossLib.sml +++ b/src/boss/bossLib.sml @@ -24,7 +24,7 @@ open HolKernel Parse boolLib pairLib simpLib metisLib pred_setLib local open listTheory optionTheory combinSyntax listSyntax optionSyntax numSyntax oneSyntax sumSyntax - EvalRef Lift; + (* EvalRef Lift; *) in end; val ERR = mk_HOL_ERR "bossLib"; diff --git a/src/tfl/examples/test.Define b/src/tfl/examples/test.Define index 8bd3469543..7a32c482bc 100644 --- a/src/tfl/examples/test.Define +++ b/src/tfl/examples/test.Define @@ -155,8 +155,8 @@ val Swap_def' = val Flag_defn = Hol_defn "Flag" `Flag list = case Swap list - of NONE -> list - || SOME slist -> Flag slist`; + of NONE => list + | SOME slist => Flag slist`; (*--------------------------------------------------------------------------- @@ -458,7 +458,8 @@ TypeBasePure.type_size (TypeBase.theTypeBase()) (Type`:'a Btree list`); *---------------------------------------------------------------------------*) val Lin_def = -Define`(Lin (Leaf x) = Leaf x) + Define + `(Lin (Leaf x) = Leaf x) /\ (Lin (Brh a (Leaf x) bt) = Brh a (Leaf x) (Lin bt)) /\ (Lin (Brh a (Brh x bt1 bt2) bt) = Lin (Brh x bt1 (Brh a bt2 bt)))`; @@ -660,26 +661,46 @@ val nS_defn = Hol_defn "nS" `nS ms = case SPLIT (\x. ?r l w. x = (Repeat r::l, w, SOME (Repeat r::l))) ms [] - of NONE -> ms - || SOME (l1, (bad_r, bad_w, bad_s), z) -> + of NONE => ms + | SOME (l1, (bad_r, bad_w, bad_s), z) => case SPLIT (\x. ?s. x = (bad_r, bad_w, s)) l1 [] - of NONE -> [] - || SOME (x1, (rl,w1,s1), y) -> nS (x1 ++ [(rl, w1, s1)] ++ csp z s1)`; - -Hol_defn "foo" - `foo L = case SPLIT ($= 3) L [] - of NONE -> L - || SOME(L1,x,L2) -> - case SPLIT ($=2) L1 [] - of NONE -> [] - || SOME (L1a,y, L1b) -> foo (L1a ++ [y] ++ L2)`; - -Hol_defn "foo" + of NONE => [] + | SOME (x1, (rl,w1,s1), y) => nS (x1 ++ [(rl, w1, s1)] ++ csp z s1)`; + +val defn = + Hol_defn + "foo" + `foo L = + case SPLIT ($= 3) L [] + of NONE => L + | SOME(L1,x,L2) => + case SPLIT ($=2) L1 [] + of NONE => [] + | SOME (L1a, y, L1b) => foo (L1a ++ [y] ++ L2)`; + +Defn.tgoal defn; +e (RW_TAC list_ss []); + + +val defn = + Hol_defn + "foo1" + `foo1 L = + case SPLIT ($= 3) L [] + of NONE => L + | SOME(L1,_,L2) => + case SPLIT ($=2) L1 [] + of NONE => [] + | SOME (L1a, y, _) => foo1 (L1a ++ [y] ++ L2)`; + +val defn = + Hol_defn + "bar" `bar L = case L - of [] -> 1 - || h::t -> case t - of [] -> 2 - || h1::t1 -> bar t1`; + of [] => 1 + | h::t => case t + of [] => 2 + | h1::t1 => bar t1`; (*---------------------------------------------------------------------------*) @@ -839,8 +860,8 @@ val ZIP_DELTA_def = if v1 = v2 then (v1,x1) :: ZIP_DELTA b d1 d2 else case LOOKUP d2 v1 of - SOME(v,x) -> (v1, if b then x1 else x) :: ZIP_DELTA b d1 d2 - || NONE -> (v1,x1) :: ZIP_DELTA b d1 ((v2,x2)::d2))`; + SOME(v,x) => (v1, if b then x1 else x) :: ZIP_DELTA b d1 d2 + | NONE => (v1,x1) :: ZIP_DELTA b d1 ((v2,x2)::d2))`; val test_def = Define @@ -848,8 +869,8 @@ val test_def = (test [] d2 = d2) /\ (test (p1::d1) (p2::d2) = case LOOKUP d2 (FST p1) of - NONE -> p1 :: test d1 (p2::d2) - || SOME(v,x) -> (FST p1,x) :: test d1 d2)`; + NONE => p1 :: test d1 (p2::d2) + | SOME(v,x) => (FST p1,x) :: test d1 d2)`; (*---------------------------------------------------------------------------*) @@ -875,17 +896,17 @@ val code_eval_defn = Hol_defn "code_eval" ` (code_eval v [] = v) /\ (code_eval v (cod :: rest) = case cod of - Assign b -> code_eval (SOME b) rest - || PosCond c -> + Assign b => code_eval (SOME b) rest + | PosCond c => (case v of - NONE -> NONE - || SOME T -> code_eval (code_eval v c) rest - || SOME F -> code_eval v rest) - || NegCond c -> + NONE => NONE + | SOME T => code_eval (code_eval v c) rest + | SOME F => code_eval v rest) + | NegCond c => (case v of - NONE -> NONE - || SOME F -> code_eval (code_eval v c) rest - || SOME T -> code_eval v rest)) + NONE => NONE + | SOME F => code_eval (code_eval v c) rest + | SOME T => code_eval v rest)) `; val code1_size = prove(``code1_size = list_size code_size``, diff --git a/src/tfl/src/Defn.sml b/src/tfl/src/Defn.sml index 08832587ae..f36f78b0e7 100644 --- a/src/tfl/src/Defn.sml +++ b/src/tfl/src/Defn.sml @@ -595,8 +595,7 @@ fun checkSV pats SV = (*---------------------------------------------------------------------------*) fun wfrec_eqns facts tup_eqs = - let - val {functional,pats} = + let val {functional,pats} = mk_functional (TypeBasePure.toPmatchThry facts) (protect tup_eqs) val SV = free_vars functional (* schematic variables *) val _ = checkSV pats SV diff --git a/src/tfl/src/RW.sml b/src/tfl/src/RW.sml index 781f20ecac..75b5e95a1c 100644 --- a/src/tfl/src/RW.sml +++ b/src/tfl/src/RW.sml @@ -202,6 +202,7 @@ fun PRIM_RW_CONV th = * The ci do not have to be there, i.e., unconditional antecedents can * certainly exist. *---------------------------------------------------------------------------*) + fun CONGR th = let val (ants,eq) = strip_imp_only (concl th) (* TODO: Check that it is a congruence rule *) @@ -323,10 +324,10 @@ end fun CONG_STEP (RW{cong_net,...}) tm = Lib.trye hd (Net.match tm cong_net) tm; - (*---------------------------------------------------------------------------- * Prettyprinting *---------------------------------------------------------------------------*) + local open Portable in fun pp_simpls ppstrm (RW{thms,congs,...}) = @@ -428,7 +429,8 @@ end; fun TRY_QCONV cnv = ORELSEQC cnv ALL_QCONV; -datatype delta = CHANGE of thm | NO_CHANGE of term list * term +datatype delta = CHANGE of thm | NO_CHANGE of thm; + fun unchanged (NO_CHANGE _) = true | unchanged _ = false; @@ -482,142 +484,159 @@ fun dest_combn tm 0 = (tm,[]) fun add_cntxt ADD = add_rws | add_cntxt DONT_ADD = Lib.K; (*---------------------------------------------------------------------------*) -(* Handler for simple cong. rule antecedents: ones without quantification. *) +(* A congruence rule can have two kinds of antecedent: universally *) +(* quantified or unquantified. A bare antecedent is fairly simple to deal *) +(* with: it has the form *) +(* *) +(* conditions ==> lhs = ?rhs *) +(* *) +(* The following congruence rule has only bare antecedents: *) +(* *) +(* |- !P Q x x' y y'. *) +(* (P ⇔ Q) /\ *) +(* (Q ⇒ (x = x')) /\ *) +(* (¬Q ⇒ (y = y')) *) +(* ==> *) +(* ((if P then x else y) = if Q then x' else y') *) +(* *) +(* A bare antecedent is processed by assuming the conditions and rewriting *) +(* the LHS of the equation. This yields the value for ?rhs. *) +(* *) +(* A quantified antecedent is more troublesome, since it usually implies *) +(* that something higher-order is going on, and so beta-conversion and *) +(* paired-lambdas may need to be handled. The following is the congruence *) +(* rule for LET: *) +(* *) +(* |- (M = M') /\ (!x. (x = M') ==> (f x = g x)) ==> LET f M = LET g M' *) +(* *) +(* In the second antecedent, f is a function that may be a constant, a *) +(* lambda term, a paired lambda term, or even the application of a higher- *) +(* order function. In order to extract termination conditions from f x, *) +(* a (paired) beta reduction will be done, which can completely transform *) +(* the term structure. After extraction, a corresponding function g is *) +(* obtained from the rhs of the equality theorem returned. This may not look *) +(* like a function, so there is a step of "un-beta-expansion" on g. *) +(* *) +(* Note. *) +(* When doing rewriting of quantified antecedents to congruence rules, as *) +(* in the one for "let" statements above, the temptation is there to only *) +(* rewrite (in context) f to g, and use MK_COMB to get f x = g x. (Assume *) +(* that f is a lambda term.) However, the free variables in the context *) +(* (i.e., x) map to bound variables in f and the attempt to abstract on the *) +(* way out of the rewrite will fail, or isolate the free variables. Dealing *) +(* with this causes some clutter in the code. *) (*---------------------------------------------------------------------------*) -fun simple cnv (cps as {context as (cntxt,b),prover,simpls}) (ant,rst) = let - val _ = lztrace(5, "simple", - (fn () => "ant: " ^ ppstring pp_term ant)) -in - case total ((I##dest_eq) o strip_imp_only) ant of - SOME (L,(lhs,rhs)) => let - val outcome = - if aconv lhs rhs then NO_CHANGE (L,lhs) - else let val cps' = - if null L then cps else - {context = (map ASSUME L @ cntxt,b), - prover = prover, - simpls = add_cntxt b simpls (map ASSUME L)} - in CHANGE(cnv cps' lhs) handle HOL_ERR _ => NO_CHANGE (L,lhs) - | UNCHANGED => NO_CHANGE (L,lhs) +fun no_change V L tm = + NO_CHANGE (itlist GEN V (itlist DISCH L (REFL tm))) + +fun try_cong cnv (cps as {context,prover,simpls}) tm = + let + fun simple cnv (cps as {context as (cntxt,b),prover,simpls}) (ant,rst) = + case total ((I##dest_eq) o strip_imp_only) ant + of NONE (* Not an equality, so just assume *) + => (CHANGE(ASSUME ant), rst) + | SOME (L,(lhs,rhs)) + => let val outcome = + if aconv lhs rhs then no_change [] L lhs + else let val cps' = if null L then cps else + {context = (map ASSUME L @ cntxt,b), + prover = prover, + simpls = add_cntxt b simpls (map ASSUME L)} + in CHANGE(cnv cps' lhs) + handle HOL_ERR _ => no_change [] L lhs + | UNCHANGED => no_change [] L lhs + end + in + case outcome + of CHANGE th => + let val Mnew = boolSyntax.rhs(concl th) + in (CHANGE (itlist DISCH L th), + map (subst [rhs |-> Mnew]) rst) end - in - case outcome of - CHANGE th => let - val Mnew = boolSyntax.rhs(concl th) - in - lztrace(5, "simple", - (fn () => "outcome: " ^ ppstring pp_term Mnew)); - (CHANGE (itlist DISCH L th), map (subst [rhs |-> Mnew]) rst) - end - | _ => (lztrace(5, "simple", (fn () => "unchanged outcome "^ - ppstring pp_term lhs)); - (outcome, map (subst [rhs |-> lhs]) rst)) - end - | NONE => (CHANGE(ASSUME ant), rst) (* Not an equality, so just assume *) -end - + | NO_CHANGE _ => (outcome, map (subst [rhs |-> lhs]) rst) + end -fun complex cnv (cps as {context as (cntxt,b),prover,simpls}) (ant,rst) = -let fun tr (i,mf) = lztrace(i,"complex",mf) - fun trterm (i,m,t) = tr(i, (fn () => m ^ ppstring pp_term t)) - fun trvlist (i,m,tlist) = - tr(i, (fn () => String.concatWith "\n" - (m :: map (ppstring pp_term) tlist))) - fun trthlist (i,m,thlist) = - tr(i, - trace ("assumptions", 1) - (fn () => String.concatWith "\n" - (m :: map (ppstring pp_thm) thlist))) - val _ = trterm(5, "Antecedent: ", ant) - val _ = trthlist(6, "Context: ", cntxt) - val ant_frees = free_vars ant - val _ = trvlist(10, "Antecedent frees: ", ant_frees) - val context_frees = free_varsl (map concl (fst context)) - val _ = trvlist(10, "Context frees: ", context_frees) + fun complex cnv (cps as {context as (cntxt,b),prover,simpls}) (ant,rst) = + let val ant_frees = free_vars ant + val context_frees = free_varsl (map concl cntxt) val (vlist,ceqn) = strip_forall ant - val (lhs,rhs) = dest_eq(snd(strip_imp_only ceqn)) - val (f,args) = (I##rev) (dest_combn lhs (length vlist)) - val _ = assert is_pabs f - val (rhsv,_) = dest_combn rhs (length vlist) + val (L0,eq) = strip_imp_only ceqn + val (lhs,rhs) = dest_eq eq + val nvars = length (snd (strip_comb rhs)) (* guessing ... *) + val (f,args) = (I##rev) (dest_combn lhs nvars) + val (rhsv,_) = dest_combn rhs nvars val vstrl = #1(strip_pabs f) - val vstrl1 = vstrl_variants (union ant_frees context_frees) vstrl - val ceqn' = subst (map (op|->) (zip args vstrl1)) ceqn + val vstructs = vstrl_variants (union ant_frees context_frees) vstrl + val ceqn' = if null vstrl then ceqn else subst (map (op|->) (zip args vstructs)) ceqn val (L,(lhs,rhs)) = (I##dest_eq) (strip_imp_only ceqn') - val outcome = - if aconv lhs rhs then NO_CHANGE (L,lhs) else - let val lhs_beta_maybe = - Conv.DEPTH_CONV GEN_BETA_CONV lhs handle HOL_ERR _ => REFL lhs - val lhs' = boolSyntax.rhs(concl lhs_beta_maybe) - val cps' = case L of [] => cps - | otherwise => - {context = (map ASSUME L @ cntxt,b), - prover = prover, - simpls = add_cntxt b simpls (map ASSUME L)} - in CHANGE(TRANS lhs_beta_maybe (cnv cps' lhs')) - handle HOL_ERR _ => if aconv lhs lhs' then NO_CHANGE (L,lhs) - else CHANGE lhs_beta_maybe - | UNCHANGED => if aconv lhs lhs' then NO_CHANGE (L,lhs) - else CHANGE lhs_beta_maybe - end -in - case outcome of - CHANGE th => let - val Mnew = boolSyntax.rhs(concl th) - val _ = trterm(5, "rhs of CHANGE th (Mnew): ", Mnew) - val _ = trvlist(10, "assumptions of CHANGE th: ", hyp th) - val g = list_mk_pabs(vstrl1,Mnew) - val gvstrl1 = list_mk_comb(g,vstrl1) - val eq = SYM(DEPTH_CONV GEN_BETA_CONV gvstrl1 - handle HOL_ERR _ => REFL gvstrl1) - val th1 = TRANS th eq (* f vstrl1 = g vstrl1 *) - val pairs = zip args vstrl1 - fun generalize v thm = - case assoc1 v pairs - of SOME (_,tup) => pairTools.PGEN v tup thm - | NONE => raise RW_ERR "complex" "generalize" - val result = itlist generalize vlist (itlist DISCH L th1) - val _ = lztrace(6, "complex", - trace ("assumptions", 1) - (fn () => "Changed outcome: " ^ - ppstring pp_thm result)) - in - (CHANGE result, map (subst [rhsv |-> g]) rst) - end - | otherwise => let - in - tr(5, K "outcome was no change"); - (outcome, map (subst [rhsv |-> f]) rst) - end -end; - - -(*--------------------------------------------------------------------------- - * Note. - * When doing rewriting of quantified antecedents to congruence rules, as - * in the one for "let" statements - * - * |- (M = M') /\ (!x. (x = M') ==> (f x = g x)) ==> LET f M = LET g M', - * |----------------------------| - * - * the temptation is there to only rewrite (in context) f to g, and - * use MK_COMB to get f x = g x. (Assume that f is a lambda term.) However, - * the free variables in the context (i.e., x) map to bound variables in - * f and the attempt to abstract on the way out of the rewrite will fail, or - * isolate the free variables. - *---------------------------------------------------------------------------*) + val outcome = + if aconv lhs rhs + then no_change vlist L lhs + else + let val lhs_beta_maybe = Conv.QCONV (Conv.DEPTH_CONV GEN_BETA_CONV) lhs + val lhs' = boolSyntax.rhs(concl lhs_beta_maybe) + val cps' = case L + of [] => cps + | otherwise => + {context = (map ASSUME L @ cntxt,b), + prover = prover, + simpls = add_cntxt b simpls (map ASSUME L)} + in CHANGE(TRANS lhs_beta_maybe (cnv cps' lhs')) + handle HOL_ERR _ => + if aconv lhs lhs' + then no_change vlist L lhs + else CHANGE lhs_beta_maybe + | UNCHANGED => if aconv lhs lhs' + then no_change vlist L lhs + else CHANGE lhs_beta_maybe + end + in + case outcome + of NO_CHANGE _ => (outcome, map (subst [rhsv |-> f]) rst) + | CHANGE th => + let (*------------------------------------------------------------*) + (* Function eta_rhs packages up the new rhs, eta-expanding it *) + (* if need be, i.e. if the lhs is an application of a lambda *) + (* or paired-lambda term f. In that case, the extraction has *) + (* first done a beta-reduction and then extraction, so the *) + (* derived rhs needs to be "un-beta-expanded" in order that *) + (* the existential var on the rhs be filled in with a thingb *) + (* that has function syntax. This will allow the final *) + (* MATCH_MP icong ... to succeed. *) + (*------------------------------------------------------------*) + fun eta_rhs th = + let val r = boolSyntax.rhs(concl th) + val not_lambda_app = null vstrl + val rcore = if not_lambda_app + then fst(dest_combn r nvars) + else r + val g = list_mk_pabs(vstructs,rcore) + val gvstructs = list_mk_comb(g,vstructs) + val rhs_eq = if not_lambda_app then REFL gvstructs + else SYM(Conv.QCONV (DEPTH_CONV GEN_BETA_CONV) gvstructs) + val th1 = TRANS th rhs_eq (* |- f vstructs = g vstructs *) + handle HOL_ERR _ => th + in (g,th1) + end + val (g,th1) = eta_rhs th + val th2 = itlist DISCH L th1 + val pairs = zip args vstructs handle HOL_ERR _ => [] + fun generalize v thm = + case assoc1 v pairs + of SOME (_,tup) => pairTools.PGEN v tup thm + | NONE => GEN v thm + val result = itlist generalize vlist th2 + in + (CHANGE result, map (subst [rhsv |-> g]) rst) + end + end (* complex *) -fun do_cong cnv cps th0 = let - val th = th0 -(* val th = GENVAR_THM th0 *) - val (a, c) = dest_imp (concl th) - val _ = lztrace(6, "do_cong", - (fn () => "th concl: "^ppstring pp_term c)) - val ants = strip_conj a - val _ = lztrace(6, "do_cong", - (fn () => String.concatWith "\n" - ("ants: " :: map (ppstring pp_term) ants))) - fun loop [] = [] (* loop proves each antecedent in turn. *) + val icong = CONG_STEP simpls tm + val ants = strip_conj (fst(dest_imp (concl icong))) + (* loop proves each antecedent in turn and propagates + instantiations to the remainder. *) + fun loop [] = [] | loop (ant::rst) = let val (outcome,rst') = if is_forall ant @@ -627,25 +646,26 @@ fun do_cong cnv cps th0 = let outcome::loop rst' end val outcomes = loop ants - fun mk_ant (NO_CHANGE (L,tm)) = itlist DISCH L (REFL tm) + fun mk_ant (NO_CHANGE th) = th | mk_ant (CHANGE th) = th -in - if Lib.all unchanged outcomes - then raise UNCHANGED - else MATCH_MP th (LIST_CONJ (map mk_ant outcomes)) -end; + in + if Lib.all unchanged outcomes + then raise UNCHANGED + else MATCH_MP icong (LIST_CONJ (map mk_ant outcomes)) + end -fun SUB_QCONV cnv (cps as {context,prover,simpls}) tm = +fun SUB_QCONV cnv cps tm = case dest_term tm of COMB(Rator,Rand) => - (do_cong cnv cps (CONG_STEP simpls tm) + (try_cong cnv cps tm handle UNCHANGED => raise UNCHANGED | HOL_ERR _ => let val th = cnv cps Rator in MK_COMB (th, cnv cps Rand) handle UNCHANGED => AP_THM th Rand end - handle UNCHANGED => AP_TERM Rator (cnv cps Rand)) + handle UNCHANGED => AP_TERM Rator (cnv cps Rand) + ) | LAMB(Bvar,Body) => let val Bth = cnv cps Body in ABS Bvar Bth @@ -669,7 +689,7 @@ fun SUB_QCONV cnv (cps as {context,prover,simpls}) tm = in TRANS (TRANS th1 eq_thm') th2 end end - | otherwise => raise UNCHANGED (* Constants and variables *); + | otherwise => raise UNCHANGED (* Constants and variables *) fun DEPTH_QCONV cnv cps tm = @@ -737,7 +757,6 @@ fun RW_STEPS traverser (simpls,context,congs,prover) thl = traverser RW_STEP {context=context, prover=prover, simpls=simpls'} end; - (*---------------------------------------------------------------------------* * Define an implicit set of rewrites, so that common rewrite rules don't * * need to be constantly given by the user. * @@ -1016,143 +1035,3 @@ fun Simpl tac std_thms thl = val _ = Parse.temp_set_grammars ambient_grammars; end (* structure RW *) - -(* -(* -val bar_defn = Hol_defn "bar" -`bar s = STATE_OPTION_BIND - STATE_OPTION_GET - (\s1. STATE_OPTION_BIND - STATE_OPTION_GET - (\s2. STATE_OPTION_IGNORE_BIND - (if s1=s2 then STATE_OPTION_UNIT () else (\b. bar b)) - (STATE_OPTION_UNIT ()))) - s`; -*) -val stem = "bar"; -val q = -`bar s = STATE_OPTION_BIND - STATE_OPTION_GET - (\s1. STATE_OPTION_BIND - STATE_OPTION_GET - (\s2. STATE_OPTION_IGNORE_BIND - (if s1=s2 then STATE_OPTION_UNIT () else (\b. bar b)) - (STATE_OPTION_UNIT ()))) - s`; -val [eqns] = parse_quote q; -val facts = TypeBase.theTypeBase(); -val tup_eqs = eqns; -val thy = facts; -val [(p,th)] = (zip given_pats corollaries'') -extract [R1] congs f (proto_def,WFR) (pat,corr) -val FV = [R1] -val tma = boolSyntax.rhs(concl th); - -val R = rand WFR -val CUT_LEM = ISPECL [f,R] relationTheory.RESTRICT_LEMMA -val restr_fR = rator(rator(lhs(snd(dest_imp (concl (SPEC_ALL CUT_LEM)))))) -fun mk_restr p = mk_comb(restr_fR, p) - -Given (p,th) from Defn.sml::extract: - - val tma = boolSyntax.rhs(concl th) - val tmb = rator tma; - val tmc = body (rand tmb); - val tmd = body (rand tmc); - val tme = ``^tmd q``; - - val nested_ref = ref false; - val (Pure thl,Context cntxt,Congs congs,Solver solver) = (* rwArgs *) - (Pure [CUT_LEM], - Context ([],DONT_ADD), - Congs congs, - Solver (solver (mk_restr p, f, FV@free_vars(concl th), nested_ref))); - -(* - val thl = [CUT_LEM] - val cntxt = ([],DONT_ADD) - val solver = solver (mk_restr p, f, FV@free_vars(concl th), nested_ref); -*) - -RW_STEPS TOP_DEPTH (empty_simpls,cntxt,congs,solver) thl tma; (* d.n.work *) -RW_STEPS TOP_DEPTH (empty_simpls,cntxt,congs,solver) thl tmb; (* d.n.work *) -RW_STEPS TOP_DEPTH (empty_simpls,cntxt,congs,solver) thl tmc; (* d.n.work *) -RW_STEPS TOP_DEPTH (empty_simpls,cntxt,congs,solver) thl tmd; (* d.n.work *) -RW_STEPS TOP_DEPTH (empty_simpls,cntxt,congs,solver) thl tme; (* works *) - -val simpls' = add_congs(add_rws empty_simpls thl) congs; - -TOP_DEPTH_QCONV RW_STEP {context=cntxt, prover=solver, simpls=simpls'} tmb; -val cnv = RW_STEP; -val cps = {context=cntxt, prover=solver, simpls=simpls'}; -val tm = tmb; -(* SUB_QCONV is where cong rule applied *) -val cnv = TOP_DEPTH_QCONV cnv; -SUB_QCONV cnv cps tmb; -val (cps as {context,prover,simpls}) = cps; -val COMB(Rator,Rand) = dest_term tmb; -val th = CONG_STEP simpls tmb; -do_cong cnv cps th; -val (ant1::rst) = strip_conj (fst(dest_imp (concl th))) -val (outcome1,[ant2]) = simple cnv cps (ant1,rst) -val (outcome2 as CHANGE chthm,[]) = complex cnv cps (ant2,[]); -(* note: chthm is actually unchanged, no? the lhs & rhs are aconv ... *) - -val ant = ant2; -val rst = []; -val {context as (cntxt,b),prover,simpls} = cps; - -val ant_frees = free_vars ant - val context_frees = free_varsl (map concl (fst context)) - val (vlist,ceqn) = strip_forall ant - val (lhs,rhs) = dest_eq(snd(strip_imp_only ceqn)) - val (f,args) = (I##rev) (dest_combn lhs (length vlist)) - val _ = assert is_pabs f - val (rhsv,_) = dest_combn rhs (length vlist) - val vstrl = #1(strip_pabs f) - val vstrl1 = vstrl_variants (union ant_frees context_frees) vstrl - val ceqn' = subst (map (op|->) (zip args vstrl1)) ceqn - val (L,(lhs,rhs)) = (I##dest_eq) (strip_imp_only ceqn'); -aconv lhs rhs; (* false *) -val lhs_beta_maybe = - Conv.DEPTH_CONV GEN_BETA_CONV lhs handle HOL_ERR _ => REFL lhs -val lhs' = boolSyntax.rhs(concl lhs_beta_maybe); -val cps' = {context = (map ASSUME L @ cntxt,b), - prover = prover, - simpls = add_cntxt b simpls (map ASSUME L)}; -TOP_DEPTH_QCONV RW_STEP cps' lhs'; -val cnv = TOP_DEPTH_QCONV RW_STEP; -SUB_QCONV cnv cps' lhs'; -val (cps as {context,prover,simpls}) = cps'; -val tm = lhs'; -val COMB(Rator,Rand) = dest_term tm; -val cong_thm = CONG_STEP simpls tm; -do_cong cnv cps cong_thm; -val th = cong_thm; -val ants = strip_conj (fst(dest_imp (concl th))) -val (ant::rst) = ants; -val (outcome1,rst') = - if not(is_forall ant) - then simple cnv cps (ant,rst) - else complex cnv cps (ant,rst); -val (ant::rst) = rst'; -val (outcome2,rst') = simple cnv cps (ant,rst); -val {context as (cntxt,b),prover,simpls} = cps; -val SOME (L,(lhs,rhs)) = total ((I##dest_eq) o strip_imp_only) ant; -val cps' = {context = (map ASSUME L @ cntxt,b), - prover = prover, - simpls = add_cntxt b simpls (map ASSUME L)}; -TOP_DEPTH_QCONV RW_STEP cps' lhs; -REPEATQC RW_STEP cps' lhs; -RW_STEP cps' lhs; -val {context=(cntxt,_),prover,simpls as RW{rw_net,...}} = cps'; -val tm = lhs; -val [matchf] = Net.match tm rw_net; -val COND th = matchf tm; -val condition = fst(dest_imp(concl th)); -val cond_thm = prover simpls cntxt condition; (* fails *) -val tm = condition; -val rcontext = rev cntxt; -val antl = [list_mk_conj(map concl rcontext)]; - -*) From 380b2915b8dc53bd50c5d4762ab5eda9308156eb Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 30 Jan 2015 10:13:42 +1100 Subject: [PATCH 143/718] Start compiling new Holdep code in Moscow ML configure. Generate a holdeptool along the way. This examines a source file and outputs all the dependencies it believes that source file might have. Mostly useful for debugging. --- tools/Holmake/mosml_holdeptool.sml | 1 + tools/configure.sml | 24 +++++++++++++++++++----- 2 files changed, 20 insertions(+), 5 deletions(-) create mode 100644 tools/Holmake/mosml_holdeptool.sml diff --git a/tools/Holmake/mosml_holdeptool.sml b/tools/Holmake/mosml_holdeptool.sml new file mode 100644 index 0000000000..7f8da2d365 --- /dev/null +++ b/tools/Holmake/mosml_holdeptool.sml @@ -0,0 +1 @@ +val _ = holdeptool.main() diff --git a/tools/configure.sml b/tools/configure.sml index bf5468f4c6..48622b1006 100644 --- a/tools/configure.sml +++ b/tools/configure.sml @@ -342,21 +342,34 @@ val _ = val hmakedir = normPath(Path.concat(holdir, "tools/Holmake")) val _ = FileSys.chDir hmakedir val bin = fullPath [holdir, "bin/Holmake"] + val mllex = fullPath [holdir, "tools", "mllex", "mllex.exe"] val lexer = fullPath [mosmldir, "mosmllex"] val yaccer = fullPath [mosmldir, "mosmlyac"] val systeml = fn clist => if not (Process.isSuccess (systeml clist)) then die "Holmake compilation failed." else () - fun link () = let - val pfx = if OS <> "winNT" then [compiler, "-standalone", "-o", bin] - else [compiler, "-o", bin] + fun link {extras,srcobj,tgt} = let + val pfx = if OS <> "winNT" then [compiler, "-standalone", "-o", tgt] + else [compiler, "-o", tgt] val b2002comp = if have_basis2002 then [] else ["basis2002.ui"] in - systeml (pfx @ b2002comp @ ["Holmake.sml"]) + systeml (pfx @ b2002comp @ extras @ [srcobj]) end in systeml [yaccer, "Parser.grm"]; systeml [lexer, "Lexer.lex"]; + systeml [mllex, "Holdep_tokens.lex"]; + compile [] "SourcePos.sig"; + compile [] "SourcePos.sml"; + compile [] "SourceFile.sig"; + compile [] "SourceFile.sml"; + compile [] "Region.sig"; + compile [] "Region.sml"; + compile ["-toplevel"] "Holdep_tokens.lex.sml"; + compile ["Holdep_tokens.lex.ui"] "holdeptool.sml"; + compile [] "mosml_holdeptool.sml"; + link{extras = ["Holdep_tokens.lex.ui"], srcobj = "mosml_holdeptool.uo", + tgt = fullPath[holdir, "bin", "holdeptool.exe"]}; compile [] "Parser.sig"; compile [] "Parser.sml"; compile [] "Lexer.sml"; @@ -374,7 +387,8 @@ val _ = compile [] "Holmake_tools.sml"; compile [] "ReadHMF.sig"; compile [] "ReadHMF.sml"; - link(); + compile [] "Holmake.sml"; + link{extras = [], tgt = bin, srcobj = "Holmake.uo"}; mk_xable bin; FileSys.chDir cdir end From bdc74b83dd2b7c95a78463b26f38d518cacbd9cd Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Sun, 1 Feb 2015 15:27:50 +1100 Subject: [PATCH 144/718] fix doc for norm_subst docfile must refer to an earlier version of norm_subst --- help/Docfiles/Drule.INST_TY_TERM.doc | 8 ++++- help/Docfiles/Term.norm_subst.doc | 45 +++++++++++++++++----------- 2 files changed, 35 insertions(+), 18 deletions(-) diff --git a/help/Docfiles/Drule.INST_TY_TERM.doc b/help/Docfiles/Drule.INST_TY_TERM.doc index da6719cfb8..e83b70f792 100644 --- a/help/Docfiles/Drule.INST_TY_TERM.doc +++ b/help/Docfiles/Drule.INST_TY_TERM.doc @@ -16,10 +16,16 @@ rule, type, instantiate. {INST_TYPE} does. Then it instantiates some or all of the free variables in the resulting theorem, in the same way as {INST}. +\COMMENTS +Because the types are instantiated first, the terms (redexes as well as +residues) in the term substitution must contain the substituted types, not the +original ones. Use {norm_subst} to achieve this. + \FAILURE {INST_TY_TERM} fails under the same conditions as either {INST} or {INST_TYPE} fail. \SEEALSO -Thm.INST, Thm.INST_TYPE, Drule.ISPEC, Thm.SPEC, Drule.SUBS, Thm.SUBST. +Thm.INST, Thm.INST_TYPE, Drule.ISPEC, Thm.SPEC, Drule.SUBS, Thm.SUBST, +Term.norm_subst \ENDDOC diff --git a/help/Docfiles/Term.norm_subst.doc b/help/Docfiles/Term.norm_subst.doc index deac8083c0..a0918ca87f 100644 --- a/help/Docfiles/Term.norm_subst.doc +++ b/help/Docfiles/Term.norm_subst.doc @@ -1,8 +1,9 @@ \DOC norm_subst \BLTYPE -norm_subst : (hol_type,hol_type) subst - -> (term,term) subst -> (term,term)subst +norm_subst : ((term, term) subst * term set) * + ((hol_type, hol_type) subst * hol_type list) -> + (term, term) subst * (hol_type, hol_type) subst \ELTYPE \SYNOPSIS @@ -12,34 +13,44 @@ Instantiate term substitution by a type substitution. substitution, term, type. \DESCRIBE +Given a term substitution and a type substitution, +{norm_subst} applies the type substitution to the redexes of the term +substitution. + The substitutions coming from {raw_match} need to be normalized before they can be applied by inference rules like {INST_TY_TERM}. An invocation {raw_match avoid_tys avoid_tms pat ob A} returns a pair of substitutions -{(S,(T,Id))}. The {Id} component can be ignored. The {S} component is -a substitution for term variables, but it has to be instantiated by {T} -in order to be suitable for use by {INST_TY_TERM}. In this case, one uses -{norm_subst T S}. Thus a suitable input for {INST_TY_TERM} would be -{(norm_subst T S, T)}. +{((S,Ids),(T,Idt))}. The {Id} components can be ignored. The {S} component is +a substitution for term variables, but it has to be instantiated by +the type substitution {T} in order to be suitable for use by {INST_TY_TERM}. +In this case, one uses +{norm_subst ((S,Ids),(T,Idt))} as the first argument for {INST_TY_TERM}. + +{norm_subst ((S,Ids),(T,Idt))} ignores {Ids} and {Idt}, and returns {T} +unchanged. +Where a type-substituted term redex becomes equal to the corresponding residue, +that term redex-residue pair is omitted from the term substitution returned. \FAILURE Never fails. \EXAMPLE { -- val (S,(T,_)) = raw_match [] empty_varset +- val ((S,Ids),(T,Idt)) = raw_match [] empty_varset (Term `\x:'a. x = f (y:'b)`) - (Term `\a. a = ~p`) ([],([],[])); + (Term `\a. a = ~p`) ([],[]); > val S = [{redex = `(f :'b -> 'a)`, residue = `$~`}, - {redex = `(y :'b)`, residue = `(p :bool)`}] : ... + {redex = `(y :'b)`, residue = `(p :bool)`}] + : (term, term) subst val T = [{redex = `:'b`, residue = `:bool`}, - {redex = `:'a`, residue = `:bool`}] : ... + {redex = `:'a`, residue = `:bool`}] + : (hol_type, hol_type) subst -- norm_subst T S; -> val it = - [{redex = `(y :bool)`, residue = `(p :bool)`}, - {redex = `(f :bool -> bool)`, residue = `$~`}] - : {redex : term, residue : term} list +- val (S',_) = norm_subst ((S,Ids),(T,Idt)) ; +> val S' = [{redex = `(y :bool)`, residue = `(p :bool)`}, + {redex = `(f :bool -> bool)`, residue = `$~`}] + : (term, term) subst } @@ -48,5 +59,5 @@ Higher level matching routines, like {match_term} and {match_terml} already return normalized substitutions. \SEEALSO -Term.raw_match, Term.match_term, Term.match_terml. +Term.raw_match, Term.match_term, Term.match_terml, Drule.INST_TY_TERM. \ENDDOC From 106ba92a31efb72fffc774d230ab88a809dae29f Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 2 Feb 2015 17:08:42 +1100 Subject: [PATCH 145/718] Remove reference values from Holdep (make things more functional) Still to do: * replace the mosmllex, mosmlyac technology * change the API so that Holdep doesn't return the string that is to be written into the .HOLMK file, but rather return the string list of dependencies, which the caller can then put in the appropriate place. This would be a better separation of concerns. --- tools/Holmake/Holdep.sml | 50 +++++++++++++++++++--------------------- 1 file changed, 24 insertions(+), 26 deletions(-) diff --git a/tools/Holmake/Holdep.sml b/tools/Holmake/Holdep.sml index 33e4cd7b11..d9a79e2b8f 100644 --- a/tools/Holmake/Holdep.sml +++ b/tools/Holmake/Holdep.sml @@ -68,8 +68,6 @@ in | NONE => NONE end -local val res = ref []; -in fun isTheory s = case List.rev(String.explode s) of #"y" :: #"r" :: #"o" :: #"e" :: #"h" :: #"T" :: n::ame => @@ -77,26 +75,26 @@ fun isTheory s = | _ => NONE fun addThExt s s' ext = addExt (addDir (Path.dir s') s) ext -fun outname (rcd as {assumes,includes}) cdir s = +fun outname (rcd as {assumes,includes}) cdir (s, res) = case isTheory s of SOME n => let in (* allow a dependency on a theory if we can see a script.sml file *) case access rcd cdir (n^"Script") "sml" of - SOME s' => res := addThExt s s' "ui" :: !res + SOME s' => addThExt s s' "ui" :: res | NONE => let in (* or, if we can see the theory.ui file already; which might happen if the theory file is in sigobj *) case access rcd cdir (n^"Theory") "ui" of - SOME s' => res := addThExt s s' "ui" :: !res - | NONE => () + SOME s' => addThExt s s' "ui" :: res + | NONE => res end end | _ => let in case access rcd cdir s "sig" of - SOME s' => res := addExt s' "ui" :: !res + SOME s' => addExt s' "ui" :: res | _ => let in case access rcd cdir s "sml" of @@ -105,7 +103,7 @@ fun outname (rcd as {assumes,includes}) cdir s = the .ui file too. We have to say that we're dependent on the .uo file because the automatic logic will then correctly hunt back to the .sml file *) - SOME s' => res := addExt s' "uo" :: !res + SOME s' => addExt s' "uo" :: res | _ => let in (* this case added to cover the situations where we think we @@ -118,8 +116,8 @@ fun outname (rcd as {assumes,includes}) cdir s = this possibility by looking to see if we can see a .ui file; if so, we can retain the dependency *) case access rcd cdir s "ui" of - SOME s' => res := addExt s' "ui" :: !res - | NONE => () + SOME s' => addExt s' "ui" :: res + | NONE => res end end end @@ -127,10 +125,10 @@ fun outname (rcd as {assumes,includes}) cdir s = fun beginentry objext target = let val targetname = addExt target objext in - res := [targetname ^ ":"]; - if objext = "uo" andalso FileSys.access(addExt target "sig", []) then - res := addExt target "ui" :: !res - else () + (targetname, + if objext = "uo" andalso FileSys.access(addExt target "sig", []) then + [addExt target "ui"] + else []) end; val escape_spaces = let @@ -142,12 +140,11 @@ in map escape_space end -fun endentry() = (* for non-file-based Holdep *) - if length (!res) > 1 then (* the first entry is the name of the file for - which we are computing dependencies *) - String.concat (spacify (rev ("\n" :: escape_spaces (!res)))) - else "" -end; +fun endentry tgtname s = + if null s then "" + else + hd (escape_spaces [tgtname]) ^ ": " ^ + String.concat (spacify (rev ("\n" :: escape_spaces s))) fun read {assumes, includes, srcext, objext, filename} = let open OS.FileSys Systeml @@ -165,20 +162,21 @@ fun read {assumes, includes, srcext, objext, filename} = let else file0 val is = BasicIO.open_in actualfile val lexbuf = createLexerStream is - val mentions = Polyhash.mkPolyTable (37, Subscript) - fun insert s = Polyhash.insert mentions (s,()) val names = parseFile (filename, is) lexbuf + val mentions = Binaryset.addList (Binaryset.empty String.compare, names) val _ = BasicIO.close_in is val _ = if actualfile <> file0 then FileSys.remove actualfile handle _ => () else () val curr_dir = Path.dir filename val outrcd = {assumes = assumes, includes = includes} + val (targetname, res0) = beginentry objext (manglefilename filename); + val res = Binaryset.foldl + (fn (s, acc) => outname outrcd curr_dir (manglefilename s, acc)) + res0 + mentions in - beginentry objext (manglefilename filename); - app insert names; - Polyhash.apply (outname outrcd curr_dir o manglefilename o #1) mentions; - endentry () + endentry targetname res end handle (e as Parsing.ParseError _) => (print "Parse error!\n"; raise e) From 1e80cac7fd6ce0a5d97ca765581b325545976ca6 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 3 Feb 2015 11:52:34 +1100 Subject: [PATCH 146/718] Isolate writing of Holdep info into file from calculation of info --- tools/Holmake/Holdep.sig | 5 ++++- tools/Holmake/Holdep.sml | 16 +++++++++------- tools/Holmake/Holmake.sml | 18 +++++++++--------- 3 files changed, 22 insertions(+), 17 deletions(-) diff --git a/tools/Holmake/Holdep.sig b/tools/Holmake/Holdep.sig index 9d9b1c47dc..2fe7c82c46 100644 --- a/tools/Holmake/Holdep.sig +++ b/tools/Holmake/Holdep.sig @@ -5,7 +5,10 @@ sig val main : { assumes : string list, includes : string list, debug : bool, - fname : string } -> string + fname : string } -> + string list + +val encode_for_HOLMKfile : {tgt : string, deps : string list} -> string end diff --git a/tools/Holmake/Holdep.sml b/tools/Holmake/Holdep.sml index d9a79e2b8f..d25ac5be98 100644 --- a/tools/Holmake/Holdep.sml +++ b/tools/Holmake/Holdep.sml @@ -140,11 +140,11 @@ in map escape_space end -fun endentry tgtname s = - if null s then "" +fun encode_for_HOLMKfile {tgt, deps} = + if null deps then "" else - hd (escape_spaces [tgtname]) ^ ": " ^ - String.concat (spacify (rev ("\n" :: escape_spaces s))) + hd (escape_spaces [tgt]) ^ ": " ^ + String.concat (spacify (rev ("\n" :: escape_spaces deps))) fun read {assumes, includes, srcext, objext, filename} = let open OS.FileSys Systeml @@ -176,7 +176,7 @@ fun read {assumes, includes, srcext, objext, filename} = let res0 mentions in - endentry targetname res + res end handle (e as Parsing.ParseError _) => (print "Parse error!\n"; raise e) @@ -190,7 +190,7 @@ fun processfile {assumes, includes, fname = filename, debug} = filename = base, includes = includes} | SOME "sml" => read {assumes = assumes, srcext = "sml", objext = "uo", filename = base, includes = includes} - | _ => "" + | _ => [] end (* assumes parameter is a list of files that we assume can be built in this @@ -199,7 +199,9 @@ fun main (r as {assumes, debug, includes, fname}) = let val results = processfile r in - if debug then print ("Holdep: "^results^"\n") else (); + if debug then + print ("Holdep: "^fname ^ ": " ^ String.concatWith ", " results^"\n") + else (); results end handle e as OS.SysErr (str, _) => (errMsg str; raise e) diff --git a/tools/Holmake/Holmake.sml b/tools/Holmake/Holmake.sml index e20aed5470..bfba308c1c 100644 --- a/tools/Holmake/Holmake.sml +++ b/tools/Holmake/Holmake.sml @@ -625,7 +625,7 @@ end else () exception HolDepFailed fun runholdep arg destination_file = let - open Mosml + datatype res = Success of string list | Failure of string val _ = print ("Analysing "^fromFile arg^"\n") fun buildables s = let val f = toFile s @@ -643,13 +643,14 @@ fun runholdep arg destination_file = let val buildable_extras = List.concat (map buildables extra_targets) val includes = hmake_preincludes @ std_include_flags @ additional_includes val _ = diag ("Running Holdep on "^fromFile arg^" with debug = "^ - Bool.toString debug ^ ", includes = " ^ - String.concatWith "," includes) + Bool.toString debug ^ ", includes = [" ^ + String.concatWith ", " includes ^ "]") + val target = fromFile arg val result = Success(Holdep.main {assumes = buildable_extras, debug = debug, includes = hmake_preincludes @ std_include_flags @ additional_includes, - fname = fromFile arg}) + fname = target}) handle _ => (print "Holdep failed.\n"; Failure "") fun myopen s = if FileSys.access(DEPDIR, []) then @@ -657,22 +658,21 @@ fun runholdep arg destination_file = let else die_with ("Want to put dependency information in directory "^ DEPDIR^", but it already exists as a file") else - (print ("Trying to create directory "^DEPDIR^" for dependency files\n"); + (info ("Trying to create directory "^DEPDIR^" for dependency files\n"); FileSys.mkDir DEPDIR; TextIO.openOut s ) - fun write_result_to_file s = let + fun write_result_to_file deps = let open TextIO val destin = normPath destination_file - (* val _ = print ("destination: "^quote destin^"\n") *) val outstr = myopen destin in - output(outstr, s); + output(outstr, Holdep.encode_for_HOLMKfile{tgt = target, deps = deps}); closeOut outstr end in case result of - Success s => write_result_to_file s + Success deps => write_result_to_file deps | Failure s => raise HolDepFailed end From b0bfd575f9f5147c483c9c2017f1c131645a060d Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 3 Feb 2015 15:13:27 +1100 Subject: [PATCH 147/718] Do away with use of mosmllex and mosmlyac in Holdep. These tools are too Moscow ML specific, and unnecessary given that we have mllex available for all SML implementations. --- tools/Holmake/Holdep.sig | 4 +- tools/Holmake/Holdep.sml | 62 ++++------ tools/Holmake/Holdep_tokens.lex | 40 ++++++- tools/Holmake/Holmake.sml | 35 +++--- tools/Holmake/Lexer.lex | 201 -------------------------------- tools/Holmake/Parser.grm | 51 -------- tools/configure.sml | 9 +- 7 files changed, 76 insertions(+), 326 deletions(-) delete mode 100644 tools/Holmake/Lexer.lex delete mode 100644 tools/Holmake/Parser.grm diff --git a/tools/Holmake/Holdep.sig b/tools/Holmake/Holdep.sig index 2fe7c82c46..0e1ba64cc0 100644 --- a/tools/Holmake/Holdep.sig +++ b/tools/Holmake/Holdep.sig @@ -1,12 +1,12 @@ signature Holdep = sig - +exception Holdep_Error of string val main : { assumes : string list, includes : string list, debug : bool, fname : string } -> - string list + {tgt : string, deps : string list} val encode_for_HOLMKfile : {tgt : string, deps : string list} -> string diff --git a/tools/Holmake/Holdep.sml b/tools/Holmake/Holdep.sml index d25ac5be98..f4f7bfd771 100644 --- a/tools/Holmake/Holdep.sml +++ b/tools/Holmake/Holdep.sml @@ -12,6 +12,7 @@ structure Holdep :> Holdep = struct structure Process = OS.Process +exception Holdep_Error of string fun normPath s = Path.toString(Path.fromString s) fun manglefilename s = normPath s @@ -28,35 +29,6 @@ fun spacify [] = [] | spacify [x] = [x] | spacify (h::t) = h::space::spacify t; -fun createLexerStream (is : BasicIO.instream) = - Lexing.createLexer (fn buff => fn n => Nonstdio.buff_input is buff 0 n) - -fun parsePhraseAndClear (file, stream) parsingFun lexingFun lexbuf = let - val phr = parsingFun lexingFun lexbuf handle - Parsing.ParseError f => let - val pos1 = Lexing.getLexemeStart lexbuf - val pos2 = Lexing.getLexemeEnd lexbuf - in - Location.errMsg (file, stream, lexbuf) (Location.Loc(pos1, pos2)) - "Syntax error." - end - | Lexer.LexicalError(msg, pos1, pos2) => - if pos1 >= 0 andalso pos2 >= 0 then - Location.errMsg (file, stream, lexbuf) - (Location.Loc(pos1, pos2)) - ("Lexical error: " ^ msg) - else - (Location.errPrompt ("Lexical error: " ^ msg ^ "\n\n"); - raise Fail "Lexical error") - | x => (Parsing.clearParser(); raise x) -in - Parsing.clearParser(); - phr -end; - -fun parseFile (f, strm) = - parsePhraseAndClear (f, strm) Parser.MLtext Lexer.Token; - fun access {assumes, includes} cdir s ext = let val sext = addExt s ext fun inDir dir = FileSys.access (addDir dir sext, []) @@ -146,6 +118,21 @@ fun encode_for_HOLMKfile {tgt, deps} = hd (escape_spaces [tgt]) ^ ": " ^ String.concat (spacify (rev ("\n" :: escape_spaces deps))) +fun scanFile {fname,actualfname} = let + open Holdep_tokens + val is = TextIO.openIn actualfname + val arg = UserDeclarations.new_state fname + val lexer = makeLexer (fn _ => UserDeclarations.inputLine is) arg + handle UserDeclarations.LEX_ERROR s => + raise Holdep_Error ("Lexical error: "^s) + fun recurse acc = + case lexer() of + NONE => (TextIO.closeIn is; acc) + | SOME s => recurse (Binaryset.add(acc, s)) +in + recurse (Binaryset.empty String.compare) +end + fun read {assumes, includes, srcext, objext, filename} = let open OS.FileSys Systeml val op ^ = Path.concat @@ -160,11 +147,7 @@ fun read {assumes, includes, srcext, objext, filename} = let else file0 end else file0 - val is = BasicIO.open_in actualfile - val lexbuf = createLexerStream is - val names = parseFile (filename, is) lexbuf - val mentions = Binaryset.addList (Binaryset.empty String.compare, names) - val _ = BasicIO.close_in is + val mentions = scanFile {actualfname = actualfile, fname = file0} val _ = if actualfile <> file0 then FileSys.remove actualfile handle _ => () else () @@ -176,13 +159,11 @@ fun read {assumes, includes, srcext, objext, filename} = let res0 mentions in - res + {tgt = targetname, deps = res} end - handle (e as Parsing.ParseError _) => (print "Parse error!\n"; raise e) - fun processfile {assumes, includes, fname = filename, debug} = - let (* val _ = output(std_err, "Processing " ^ filename ^ "\n"); *) + let val {base, ext} = Path.splitBaseExt filename in case ext of @@ -190,7 +171,7 @@ fun processfile {assumes, includes, fname = filename, debug} = filename = base, includes = includes} | SOME "sml" => read {assumes = assumes, srcext = "sml", objext = "uo", filename = base, includes = includes} - | _ => [] + | _ => {tgt = filename, deps = []} end (* assumes parameter is a list of files that we assume can be built in this @@ -200,7 +181,8 @@ fun main (r as {assumes, debug, includes, fname}) = val results = processfile r in if debug then - print ("Holdep: "^fname ^ ": " ^ String.concatWith ", " results^"\n") + print ("Holdep: " ^ #tgt results ^ ": " ^ + String.concatWith ", " (#deps results) ^ "\n") else (); results end diff --git a/tools/Holmake/Holdep_tokens.lex b/tools/Holmake/Holdep_tokens.lex index a9a5f81294..ac5003112c 100644 --- a/tools/Holmake/Holdep_tokens.lex +++ b/tools/Holmake/Holdep_tokens.lex @@ -1,15 +1,18 @@ (* though strictly an mllex file, -*- sml -*- mode works OK *) +datatype retstate = SOPEN | SINITIAL | SINCLUDE; type lexstate = { commentdepth : int ref, commentstart : SourcePos.t ref, in_string : bool ref, stringstart : SourcePos.t ref, + return : retstate ref, source : SourceFile.t } fun new_state fname = {commentdepth = ref 0, commentstart = ref SourcePos.bogus, stringstart = ref SourcePos.bogus, in_string = ref false, + return = ref SINITIAL, source = SourceFile.new fname} fun inputLine strm = @@ -43,7 +46,8 @@ fun eof ({commentdepth,source,commentstart,in_string,stringstart,...} : lexstate fun getQual s = let fun parse n = - if String.sub(s, n) = #"." then + if n >= size s then s + else if String.sub(s, n) = #"." then String.extract(s, 0, SOME n) else parse (n+1) @@ -55,9 +59,9 @@ fun getQual s = id = [A-Za-z][A-Za-z0-9_']* | [-!%&$#+/:<=>?@~^|*`\\]+; ws = [\ \013\t]; newline = "\n" | "\013\n"; -openterminator = "val" | "fun" | "in" | "infix[lr]?" | "local" | "type" | "datatype" | "nonfix" | "exception" | "end" | "structure" | "signature"; +openterminator = "val" | "fun" | "in" | "infix"[lr]? | "local" | "type" | "datatype" | "nonfix" | "exception" | "end" | "structure" | "signature" | "prim_val" | ";" ; %s OPEN STRING COMMENT INCLUDE STRINGCONT; -%arg ({source, commentdepth, commentstart, in_string, stringstart, ...}:UserDeclarations.lexstate); +%arg ({source, commentdepth, commentstart, in_string, stringstart, return, ...}:UserDeclarations.lexstate); %structure Holdep_tokens %% {ws} => (continue()); @@ -67,6 +71,7 @@ openterminator = "val" | "fun" | "in" | "infix[lr]?" | "local" | "type" | "datat YYBEGIN COMMENT; commentstart := SourceFile.getPos(source, yypos); commentdepth := 1; + return := SINITIAL; continue()); "*)" => ( lexErrorP(source, yypos, "Unmatched comment bracket") @@ -83,16 +88,31 @@ openterminator = "val" | "fun" | "in" | "infix[lr]?" | "local" | "type" | "datat "open" => (YYBEGIN OPEN; continue()); "include" => (YYBEGIN INCLUDE; continue()); {id} => (continue()); +. => ( + lexErrorP(source, yypos, "Unexpected character >" ^ yytext ^ "< in INITIAL") +); "(*" => (commentdepth := !commentdepth + 1; continue()); "*)" => (commentdepth := !commentdepth - 1; - YYBEGIN (if !commentdepth = 0 then INITIAL else COMMENT); + YYBEGIN (if !commentdepth = 0 then + if !return = SINITIAL then INITIAL + else OPEN + else COMMENT); continue()); . => (continue()); {openterminator} => (YYBEGIN INITIAL; continue()); "open" => (continue()); -{id} => (SOME yytext); +({id}\.)*{id} => (SOME (getQual yytext)); +"(*" => ( + YYBEGIN COMMENT; + commentstart := SourceFile.getPos(source,yypos); + commentdepth := 1; + return := SOPEN; + continue()); +. => ( + lexErrorP(source, yypos, "Unexpected character >" ^ yytext ^ "< in OPEN") +); "\\\"" => (continue()); "\\" {newline} => (SourceFile.newline(source,yypos+size yytext); @@ -108,3 +128,13 @@ openterminator = "val" | "fun" | "in" | "infix[lr]?" | "local" | "type" | "datat {newline} => (SourceFile.newline(source,yypos+size yytext); continue()); "\\" => (YYBEGIN STRING; continue()); . => (lexErrorP(source, yypos, "Invalid character in \\ ... \\")); + +{id} => (YYBEGIN INITIAL; SOME yytext); +"(*" => ( + YYBEGIN COMMENT; + commentstart := SourceFile.getPos(source,yypos); + commentdepth := 1; + return := SINCLUDE; + continue()); +. => ( + lexErrorP(source, yypos, "Invalid character >" ^ yytext ^ "< after include")); diff --git a/tools/Holmake/Holmake.sml b/tools/Holmake/Holmake.sml index bfba308c1c..d98a04fd15 100644 --- a/tools/Holmake/Holmake.sml +++ b/tools/Holmake/Holmake.sml @@ -645,35 +645,32 @@ fun runholdep arg destination_file = let val _ = diag ("Running Holdep on "^fromFile arg^" with debug = "^ Bool.toString debug ^ ", includes = [" ^ String.concatWith ", " includes ^ "]") - val target = fromFile arg - val result = - Success(Holdep.main {assumes = buildable_extras, debug = debug, - includes = hmake_preincludes @ std_include_flags @ - additional_includes, - fname = target}) - handle _ => (print "Holdep failed.\n"; Failure "") + val holdep_result = + Holdep.main {assumes = buildable_extras, debug = debug, + includes = hmake_preincludes @ std_include_flags @ + additional_includes, + fname = fromFile arg} + handle Holdep.Holdep_Error s => + (info "Holdep failed: s"; raise HolDepFailed) + | Interrupt => raise Interrupt + | e => (info ("Holdep exception: "^General.exnMessage e); + raise HolDepFailed) fun myopen s = if FileSys.access(DEPDIR, []) then if FileSys.isDir DEPDIR then TextIO.openOut s else die_with ("Want to put dependency information in directory "^ DEPDIR^", but it already exists as a file") else - (info ("Trying to create directory "^DEPDIR^" for dependency files\n"); + (info ("Trying to create directory "^DEPDIR^" for dependency files"); FileSys.mkDir DEPDIR; TextIO.openOut s ) - fun write_result_to_file deps = let - open TextIO - val destin = normPath destination_file - val outstr = myopen destin - in - output(outstr, Holdep.encode_for_HOLMKfile{tgt = target, deps = deps}); - closeOut outstr - end + open TextIO + val destin = normPath destination_file + val outstr = myopen destin in - case result of - Success deps => write_result_to_file deps - | Failure s => raise HolDepFailed + output(outstr, Holdep.encode_for_HOLMKfile holdep_result); + closeOut outstr end fun get_direct_dependencies (f : File) : File list = let diff --git a/tools/Holmake/Lexer.lex b/tools/Holmake/Lexer.lex deleted file mode 100644 index a0cd154faf..0000000000 --- a/tools/Holmake/Lexer.lex +++ /dev/null @@ -1,201 +0,0 @@ -{ -open Parser - -(* For nesting comments *) - -val comment_depth = ref 0; - -(* The table of keywords *) -val keyword_table = - (Polyhash.mkPolyTable(53, Subscript) : (string,token) Polyhash.hash_table); - -val () = - List.app (Polyhash.insert keyword_table) - [ - ("abstype", NULL), - ("and", NULL), - ("andalso", NULL), - ("as", NULL), - ("case", NULL), - ("datatype", NULL), - ("do", NULL), - ("else", NULL), - ("eqtype", NULL), - ("end", NULL), - ("exception", NULL), - ("fn", NULL), - ("fun", NULL), - ("handle", NULL), - ("if", NULL), - ("in", NULL), - ("include", INCLUDE), - ("infix", NULL), - ("infixr", NULL), - ("let", NULL), - ("local", NULL), - ("nonfix", NULL), - ("of", NULL), - ("op", NULL), - ("open", OPEN), - ("orelse", NULL), - ("prim_eqtype", NULL), - ("prim_EQtype", NULL), - ("prim_type", NULL), - ("prim_val", NULL), - ("raise", NULL), - ("rec", NULL), - ("then", NULL), - ("type", NULL), - ("val", NULL), - ("while", NULL), - ("with", NULL), - ("withtype", NULL), - ("#", NULL), - ("->", NULL), - ("|", NULL), - (":", NULL), - ("=>", NULL), - ("=", NULL), - ("*", NULL) - ]; - -fun mkKeyword lexbuf = - let val s = getLexeme lexbuf in - Polyhash.find keyword_table s - handle Subscript => ID s - end -; - -val savedLexemeStart = ref 0; -exception LexicalError of string * int * int (* (message, loc1, loc2) *) - -fun getQual s = - let open CharVector - val len' = size s - 1 - fun parse n = - if sub(s, n) = #"." then - String.extract(s, 0, SOME n) - else - parse (n+1) - in parse 0 end; - -fun mkQualId lexbuf = - QUAL_ID (getQual(getLexeme lexbuf)); - -fun lexError msg lexbuf = - raise LexicalError (msg, getLexemeStart lexbuf, getLexemeEnd lexbuf) - - -fun incr r = (r := !r + 1); -fun decr r = (r := !r - 1); - -} - -rule Token = parse - [^ `\000`-`\255`] - { lexError "this will be never called!" lexbuf } - | "" - {TokenN lexbuf} -and TokenN = parse - [` ` `\n` `\r` `\t`] { TokenN lexbuf } - | "(*" - { savedLexemeStart := getLexemeStart lexbuf; - comment_depth := 1; Comment lexbuf; TokenN lexbuf - } - | "*)" - { lexError "unmatched comment bracket" lexbuf } - | "'" [ `A`-`Z` `a`-`z` `0`-`9` `_` `'`]+ - { NULL } - | "~"? [`0`-`9`]+ (`.` [`0`-`9`]+)? (`E` `~`? [`0`-`9`]+)? - { NULL } - | "\"" - { String lexbuf } - | "#\"" - { String lexbuf } - | "_" { NULL } - | "," { NULL } - | "..." { NULL } - | "{" { NULL } - | "}" { NULL } - | "[" { NULL } - | "#[" { NULL } - | "]" { NULL } - | "(" { NULL } - | ")" { NULL } - | ";" { NULL } - | (eof | `\^Z`) { EOF } - | "``" { DQuotation lexbuf } - | `\`` { Quotation lexbuf } - | "" { TokenId lexbuf } - -and TokenId = parse - ( [`A`-`Z` `a`-`z`] [ `A`-`Z` `a`-`z` `0`-`9` `_` `'`]* - | [`!` `%` `&` `$` `#` `+` `-` `/` `:` `<` `=` `>` `?` `@` `\\` - `~` `^` `|` `*`]+ ) - { mkKeyword lexbuf } - | ( [`A`-`Z` `a`-`z`] [ `A`-`Z` `a`-`z` `0`-`9` `_` `'`]* - | [`!` `%` `&` `$` `#` `+` `-` `/` `:` `<` `=` `>` `?` `@` `\\` - `~` `^` `|` `*`]+ ) - "." - ( [`A`-`Z` `a`-`z`] [ `A`-`Z` `a`-`z` `0`-`9` `_` `'` `.`]* - | [`!` `%` `&` `$` `#` `+` `-` `/` `:` `<` `=` `>` `?` `@` `\\` - `~` `^` `|` `*` `.`]+ ) - { mkQualId lexbuf } - | _ - { lexError "ill-formed token" lexbuf } - -and Comment = parse - "(*" - { (incr comment_depth; Comment lexbuf) } - | "*)" - { (decr comment_depth; - if !comment_depth > 0 then Comment lexbuf else NULL) } - | (eof | `\^Z`) - { EOF } - | _ - { Comment lexbuf } - -and String = parse - `"` - { NULL } - | `\\` [`\\` `"` `n` `t`] - { String lexbuf } - | `\\` [` ` `\t` `\n` `\r`]+ `\\` - { String lexbuf } - | `\\` `^` [`@`-`_`] - { String lexbuf } - | `\\` [`0`-`9`] [`0`-`9`] [`0`-`9`] - { String lexbuf } - | `\\` - { SkipString lexbuf } - | (eof | `\^Z`) - { EOF } - | [`\^A`-`\^Z` `\127` `\255`] - { SkipString lexbuf } - | _ - { String lexbuf } - -and SkipString = parse - `"` - { NULL } - | `\\` [`\\` `"` `n` `t`] - { SkipString lexbuf } - | `\\` [` ` `\t` `\n` `\r`]+ `\\` - { SkipString lexbuf } - | (eof | `\^Z`) - { EOF } - | _ - { SkipString lexbuf } - -and Quotation = parse - "`" { NULL } - | (eof | `\^Z`) { EOF } - | "^`" { Quotation lexbuf } - | _ { Quotation lexbuf } -and DQuotation = parse - "``" { NULL } - | (eof | `\^Z`) { EOF } - | "^`" { Quotation lexbuf } - | _ {DQuotation lexbuf } - -; diff --git a/tools/Holmake/Parser.grm b/tools/Holmake/Parser.grm deleted file mode 100644 index 4f6d7c5d08..0000000000 --- a/tools/Holmake/Parser.grm +++ /dev/null @@ -1,51 +0,0 @@ -%{ -open List - -fun print s = BasicIO.print; -fun printb s = print (s ^ " "); -%} - -%token ID EQUALS NULL OPEN QUAL_ID STAR INCLUDE -%token ID QUAL_ID -%token EOF -%start MLtext -%type MLtext MLfrag MLseq UnitName_seq LongIdent -%type UnitName Ident - -%% -MLtext : - MLseq EOF { $1 } - | EOF { [] } -; - -MLfrag : - NULL { [] } - | LongIdent { $1 } - | OPEN UnitName_seq { $2 } - | INCLUDE UnitName_seq{ $2 } -; - -MLseq : - MLfrag MLseq { $1 @ $2 } - | MLfrag { $1 } -; - -UnitName_seq : - UnitName UnitName_seq { $1 :: $2 } - | /* empty */ { [] } -; - -UnitName : - Ident { $1 } - | EQUALS { "=" } -; - -Ident : - ID { $1 } - | STAR { "*" } -; - -LongIdent : - Ident { [] } - | QUAL_ID { [$1] } -; diff --git a/tools/configure.sml b/tools/configure.sml index 48622b1006..a4f7bd48fe 100644 --- a/tools/configure.sml +++ b/tools/configure.sml @@ -343,8 +343,6 @@ val _ = val _ = FileSys.chDir hmakedir val bin = fullPath [holdir, "bin/Holmake"] val mllex = fullPath [holdir, "tools", "mllex", "mllex.exe"] - val lexer = fullPath [mosmldir, "mosmllex"] - val yaccer = fullPath [mosmldir, "mosmlyac"] val systeml = fn clist => if not (Process.isSuccess (systeml clist)) then die "Holmake compilation failed." else () @@ -356,8 +354,6 @@ val _ = systeml (pfx @ b2002comp @ extras @ [srcobj]) end in - systeml [yaccer, "Parser.grm"]; - systeml [lexer, "Lexer.lex"]; systeml [mllex, "Holdep_tokens.lex"]; compile [] "SourcePos.sig"; compile [] "SourcePos.sml"; @@ -370,11 +366,8 @@ val _ = compile [] "mosml_holdeptool.sml"; link{extras = ["Holdep_tokens.lex.ui"], srcobj = "mosml_holdeptool.uo", tgt = fullPath[holdir, "bin", "holdeptool.exe"]}; - compile [] "Parser.sig"; - compile [] "Parser.sml"; - compile [] "Lexer.sml"; compile [] "Holdep.sig"; - compile [] "Holdep.sml"; + compile ["Holdep_tokens.lex.ui"] "Holdep.sml"; compile [] "regexpMatch.sig"; compile [] "regexpMatch.sml"; compile [] "parse_glob.sig"; From 4522c28a638e53665281e7826c17fb0e3c1ba519 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 3 Feb 2015 15:40:43 +1100 Subject: [PATCH 148/718] runholdep function moves to Holmake_tools (Poly/ML Holmake affected) In the latter module, it can be used in the Poly/ML implementation. This is progress with github issue #77 The Poly/ML implementation now fails the regression test in tools/Holmake/tests/depchain1/dir3 so comment out that test from the build sequence temporarily. I believe there will be a Holmake failure in machine-code until the behaviour is properly fixed. I hope selftest 2 will go through correctly. Holmake's output also changes slightly because I've been more consistent about using the built-in 'info' function instead of print. --- tools-poly/Holmake/Holdep.sml | 254 ----------------------------- tools-poly/Holmake/Holmake.sml | 71 +------- tools-poly/Holmake/Lexer.lex | 169 ------------------- tools-poly/Holmake/Parser.grm | 48 ------ tools-poly/Holmake/poly-Holmake.ML | 19 +-- tools-poly/configure.sml | 3 +- tools-poly/poly-build.ML | 28 ++-- tools/Holmake/Holdep.sig | 2 +- tools/Holmake/Holdep.sml | 14 +- tools/Holmake/Holmake.sml | 54 +----- tools/Holmake/Holmake_tools.sig | 6 + tools/Holmake/Holmake_tools.sml | 47 ++++++ tools/sequences/kernel | 2 +- 13 files changed, 100 insertions(+), 617 deletions(-) delete mode 100644 tools-poly/Holmake/Holdep.sml delete mode 100644 tools-poly/Holmake/Lexer.lex delete mode 100644 tools-poly/Holmake/Parser.grm diff --git a/tools-poly/Holmake/Holdep.sml b/tools-poly/Holmake/Holdep.sml deleted file mode 100644 index 27ee620bd8..0000000000 --- a/tools-poly/Holmake/Holdep.sml +++ /dev/null @@ -1,254 +0,0 @@ -(* Holdep -- computing dependencies for a (list of) Moscow ML - source files. Also has knowledge of HOL script and theory files. - Handles strings and nested comments correctly; - - DOES NOT normalize file names under DOS. (yet) - - This has been adapted from the mosmldep in the MoscowML compiler - sources, first by Ken Larsen and later by Konrad Slind and - Michael Norrish. -*) -structure Holdep = struct - -structure SimpleSMLLrVals = - SimpleSMLLrValsFun(structure Token = LrParser.Token) -structure SimpleSMLLex = - SimpleSMLLexFun(structure Tokens = SimpleSMLLrVals.Tokens) -structure SimpleSMLParser= - Join(structure ParserData = SimpleSMLLrVals.ParserData - structure Lex=SimpleSMLLex - structure LrParser=LrParser) - -fun normPath s = OS.Path.toString(OS.Path.fromString s) -fun manglefilename s = normPath s -fun errMsg str = TextIO.output(TextIO.stdErr, str ^ "\n\n") -fun fail() = OS.Process.exit OS.Process.failure - -fun addExt s "" = normPath s - | addExt s ext = normPath s^"."^ext; -fun addDir dir s = OS.Path.joinDirFile{dir=normPath dir,file=s} -val srev = String.implode o List.rev o String.explode - -val space = " "; -fun spacify [] = [] - | spacify [x] = [x] - | spacify (h::t) = h::space::spacify t; - - (* -fun createLexerStream (is : TextIO.instream) = - LexBuffer.createLexer (fn buff => fn n => Nonstdio.buff_input is buff 0 n) - -fun parsePhraseAndClear (file, stream) parsingFun lexingFun lexbuf = let - val phr = parsingFun lexingFun lexbuf handle - Parsing.ParseError f => let - val pos1 = LexBuffer.getLexemeStart lexbuf - val pos2 = LexBuffer.getLexemeEnd lexbuf - in - Location.errMsg (file, stream, lexbuf) (Location.Loc(pos1, pos2)) - "Syntax error." - end - | Lexer.LexicalError(msg, pos1, pos2) => - if pos1 >= 0 andalso pos2 >= 0 then - Location.errMsg (file, stream, lexbuf) - (Location.Loc(pos1, pos2)) - ("Lexical error: " ^ msg) - else - (Location.errPrompt ("Lexical error: " ^ msg ^ "\n\n"); - raise Fail "Lexical error") - | x => (Parsing.clearParser(); raise x) -in - Parsing.clearParser(); - phr -end; - -fun parseFile (f:string, strm:instream) : lexbuf -> string list = - parsePhraseAndClear (f, strm) Parser.MLtext Lexer.Token; - - *) - -fun parseFile (f:string, strm:TextIO.instream) : string list = -let val lexer = SimpleSMLParser.makeLexer (fn n => TextIO.inputN(strm,n)) - fun print_error (s,i1,i2) = - (print ("Parse error in " ^ s ^ " at " ^ Int.toString i1 ^ " to " ^ - Int.toString i2 ^ "\n"); - raise (Fail "Syntax Error.")) -in - #1 (SimpleSMLParser.parse(15,lexer,print_error,())) - handle SimpleSMLLex.UserDeclarations.LexicalError(msg, text, pos) => - (print ("Lex error: " ^ msg ^ " at text " ^ text ^ - " and at position " ^ Int.toString pos ^ "\n"); - raise (Fail "Lexical error")) -end - -local val path = ref [""] - fun lpcl [] = (errMsg "No filenames"; fail()) - | lpcl ("-I"::dir::tail) = (path := dir :: !path ; lpcl tail) - | lpcl l = l -in -fun parseComLine l = - let val s = lpcl l - in - path := List.rev (!path); - s - end - -fun access assumes cdir s ext = let - val sext = addExt s ext - fun inDir dir = OS.FileSys.access (addDir dir sext, []) -in - if inDir cdir orelse List.exists (fn nm => nm = sext) assumes then SOME s - else - case List.find inDir (!path) of - SOME dir => SOME(addDir dir s) - | NONE => NONE -end - -end (* local *) - -local val res = ref []; -in -fun isTheory s = - case List.rev(String.explode s) of - #"y" :: #"r" :: #"o" :: #"e" :: #"h" :: #"T" :: n::ame => - SOME(String.implode(List.rev (n::ame))) - | _ => NONE - -fun addThExt s s' ext = addExt (addDir (OS.Path.dir s') s) ext -fun outname assumes cdir s = - case isTheory s of - SOME n => let - in - (* allow a dependency on a theory if we can see a script.sml file *) - case access assumes cdir (n^"Script") "sml" of - SOME s' => res := addThExt s s' "ui" :: !res - | NONE => let - in - (* or, if we can see the theory.ui file already; which might - happen if the theory file is in sigobj *) - case access assumes cdir (n^"Theory") "ui" of - SOME s' => res := addThExt s s' "ui" :: !res - | NONE => () - end - end - | _ => let - in - case access assumes cdir s "sig" of - SOME s' => res := addExt s' "ui" :: !res - | _ => let - in - case access assumes cdir s "sml" of - (* this case handles the situation where there is no .sig file - locally, but a .sml file instead; compiling this will generate - the .ui file too. We have to say that we're dependent - on the .uo file because the automatic logic will then - correctly hunt back to the .sml file *) - SOME s' => res := addExt s' "uo" :: !res - | _ => let - in - (* this case added to cover the situations where we think we - are dependent on module foo, but we can't find foo.sml or - foo.sig. This can happen when foo.sml exists in some - HOL directory but no foo.sig. In this situation, the HOL - build process only copies foo.ui and foo.uo across to - sigobj (and not the .sig file that we usually find there), - so making the dependency analysis ignore foo. We cover - this possibility by looking to see if we can see a .ui - file; if so, we can retain the dependency *) - case access assumes cdir s "ui" of - SOME s' => res := addExt s' "ui" :: !res - | NONE => () - end - end - end - -fun beginentry objext target = let - val targetname = addExt target objext -in - res := [targetname ^ ":"]; - if objext = "uo" andalso OS.FileSys.access(addExt target "sig", []) then - res := addExt target "ui" :: !res - else () -end; - -val escape_spaces = let - fun translation c = if c = #" " then "\\ " - else if c = #"\\" then "\\\\" - else str c - val escape_space = String.translate translation -in - map escape_space -end - -fun endentry() = (* for non-file-based Holdep *) - if length (!res) > 1 then (* the first entry is the name of the file for - which we are computing dependencies *) - String.concat (spacify (rev ("\n" :: escape_spaces (!res)))) - else "" -end; - -fun read (assumes:string list) (srcext:string) - (objext:string) (filename:string) : string = let - open OS.FileSys Systeml - val op ^ = OS.Path.concat - val unquote = xable_string(Systeml.HOLDIR ^ "bin" ^ "unquote") - val file0 = addExt filename srcext - fun try_remove f = - if file0 <> f then - ((OS.FileSys.remove f) handle OS.SysErr _ => ()) - else - (); - val actualfile = - if access (unquote, [A_EXEC]) then let - val newname = tmpName(); - in - (if OS.Process.isSuccess (Systeml.systeml [unquote, file0, newname]) then - newname - else file0) - handle e => (try_remove newname; raise e) - end - else file0 - in let - val is = TextIO.openIn actualfile - val mentions = ref (Binaryset.empty String.compare) - fun insert s = mentions := Binaryset.addList (!mentions, s) - val names = parseFile (filename, is) - val _ = TextIO.closeIn is - val _ = try_remove actualfile - val curr_dir = OS.Path.dir filename -in - beginentry objext (manglefilename filename); - insert names; - Binaryset.app (outname assumes curr_dir o manglefilename) (!mentions); - endentry () -end -handle e => (try_remove actualfile; raise e) -end -(* - handle (e as Parsing.ParseError _) => (print "Parse error!\n"; raise e) - - *) - -fun processfile assumes filename = - let (* val _ = output(std_err, "Processing " ^ filename ^ "\n"); *) - val {base, ext} = OS.Path.splitBaseExt filename - in - case ext of - SOME "sig" => read assumes "sig" "ui" base - | SOME "sml" => read assumes "sml" "uo" base - | _ => "" - end - -(* assumes parameter is a list of files that we assume can be built in this - directory *) -fun main assumes debug sl = - let val cl_args = parseComLine sl - val results = List.map (processfile assumes) cl_args - val final = String.concat results - in - if debug then print ("Holdep: "^final^"\n") else (); - final - end - handle e as OS.SysErr (str, _) => (errMsg str; raise e) - -end (* struct *) - diff --git a/tools-poly/Holmake/Holmake.sml b/tools-poly/Holmake/Holmake.sml index a87bc9e9c0..bbc28c41ad 100644 --- a/tools-poly/Holmake/Holmake.sml +++ b/tools-poly/Holmake/Holmake.sml @@ -447,9 +447,9 @@ val envlist = envlist hmakefile_env val hmake_includes = envlist "INCLUDES" val hmake_options = envlist "OPTIONS" val additional_includes = - includify (remove_duplicates (cline_additional_includes @ hmake_includes)) + remove_duplicates (cline_additional_includes @ hmake_includes) -val hmake_preincludes = includify (envlist "PRE_INCLUDES") +val hmake_preincludes = envlist "PRE_INCLUDES" val hmake_no_overlay = member "NO_OVERLAY" hmake_options val hmake_no_sigobj = member "NO_SIGOBJ" hmake_options val hmake_qof = member "QUIT_ON_FAILURE" hmake_options @@ -501,7 +501,7 @@ val actual_overlay = NONE => SOME DEFAULT_OVERLAY | SOME _ => user_overlay -val std_include_flags = if no_sigobj then [] else ["-I", SIGOBJ] +val std_include_flags = if no_sigobj then [] else [SIGOBJ] fun extra_deps t = Option.map #dependencies @@ -787,61 +787,6 @@ end else () *) -(**** runholdep *) -(* The primary dependency chain does not depend on anything in the - file-system; it always looks the same. However, additional - dependencies depend on what holdep tells us. This function that - runs holdep, and puts the output into specified file, which will live - in DEPDIR somewhere. *) - -exception HolDepFailed -fun runholdep arg destination_file = let - open Mosml - val _ = print ("Analysing "^fromFile arg^"\n") - fun buildables s = let - val f = toFile s - val files = - case f of - SML (ss as Script t) => [UI ss, UO ss, SML (Theory t), - SIG (Theory t), UI (Theory t), - UO (Theory t), f] - | SML ss => [UI ss, UO ss, f] - | SIG ss => [UI ss, f] - | x => [x] - in - map fromFile files - end - val buildable_extras = List.concat (map buildables extra_targets) - val result = - Success(Holdep.main buildable_extras debug - (hmake_preincludes @ std_include_flags @ - additional_includes @ [fromFile arg])) - handle _ => (print "Holdep failed.\n"; Failure "") - fun myopen s = - if OS.FileSys.access(DEPDIR, []) then - if OS.FileSys.isDir DEPDIR then TextIO.openOut s - else die_with ("Want to put dependency information in directory "^ - DEPDIR^", but it already exists as a file") - else - (print ("Trying to create directory "^DEPDIR^" for dependency files\n"); - OS.FileSys.mkDir DEPDIR; - TextIO.openOut s - ) - fun write_result_to_file s = let - open TextIO - val destin = normPath destination_file - (* val _ = print ("destination: "^quote destin^"\n") *) - val outstr = myopen destin - in - output(outstr, s); - closeOut outstr - end -in - case result of - Success s => write_result_to_file s - | Failure s => raise HolDepFailed -end - fun get_direct_dependencies (f : File) : File list = let val fname = fromFile f val arg = holdep_arg f (* arg is file to analyse for dependencies *) @@ -852,7 +797,10 @@ in val depfile = mk_depfile_name argname val _ = if argname forces_update_of depfile then - runholdep arg depfile + runholdep {ofs = outputfunctions, extras = extra_targets, + includes = hmake_preincludes @ std_include_flags @ + additional_includes, arg = arg, + destination = depfile} else () val phase1 = (* circumstances can arise in which the dependency file won't be @@ -967,10 +915,9 @@ datatype buildcmds = Compile of File list val failed_script_cache = ref (Binaryset.empty String.compare) fun build_command c arg = let - val include_flags = hmake_preincludes @ std_include_flags @ - additional_includes + val include_flags = includify (hmake_preincludes @ std_include_flags @ + additional_includes) val include_flags = List.filter (fn x => not (x = "-I")) include_flags - (* val include_flags = ["-I",SIGOBJ] @ additional_includes *) val overlay_stringl = case actual_overlay of NONE => [] | SOME s => [s] exception CompileFailed exception FileNotFound diff --git a/tools-poly/Holmake/Lexer.lex b/tools-poly/Holmake/Lexer.lex deleted file mode 100644 index b0dc9392ca..0000000000 --- a/tools-poly/Holmake/Lexer.lex +++ /dev/null @@ -1,169 +0,0 @@ -type pos = int; -type svalue = Tokens.svalue -type ('a,'b) token = ('a,'b) Tokens.token -type lexresult = (svalue,pos) token -open Tokens; - -fun eof () = EOF(~1,~1); - -(* For nesting comments *) - -val comment_depth = ref 0; - -(* The table of keywords *) - -val keyword_table = - List.foldl (fn ((k,v), d) => Binarymap.insert (d, k, v)) - (Binarymap.mkDict String.compare) - [ - ("abstype", NULL), - ("and", NULL), - ("andalso", NULL), - ("as", NULL), - ("case", NULL), - ("datatype", NULL), - ("do", NULL), - ("else", NULL), - ("eqtype", NULL), - ("end", NULL), - ("exception", NULL), - ("fn", NULL), - ("fun", NULL), - ("handle", NULL), - ("if", NULL), - ("in", NULL), - ("include", INCLUDE), - ("infix", NULL), - ("infixr", NULL), - ("let", NULL), - ("local", NULL), - ("nonfix", NULL), - ("of", NULL), - ("op", NULL), - ("open", OPEN), - ("orelse", NULL), - ("prim_eqtype", NULL), - ("prim_EQtype", NULL), - ("prim_type", NULL), - ("prim_val", NULL), - ("raise", NULL), - ("rec", NULL), - ("then", NULL), - ("type", NULL), - ("val", NULL), - ("while", NULL), - ("with", NULL), - ("withtype", NULL), - ("#", NULL), - ("->", NULL), - ("|", NULL), - (":", NULL), - ("=>", NULL), - ("=", NULL), - ("*", NULL) - ]; - -fun mkKeyword s pos = - (Binarymap.find (keyword_table, s))(pos, pos) - handle Binarymap.NotFound => ID (s, pos, pos) -; - -fun getQual s = - let val len' = String.size s - 1 - fun parse n = - if String.sub(s, n) = #"." then - String.extract(s, 0, SOME n) - else - parse (n+1) - in parse 0 end; - -fun mkQualId s pos = QUAL_ID (getQual s, pos, pos); - -exception LexicalError of string * string * int (* (message, loc1, loc2) *) -fun lexError msg text pos = - raise (LexicalError (msg, text, pos)) - - -fun incr r = (r := !r + 1); -fun decr r = (r := !r - 1); - -%% -%header (functor SimpleSMLLexFun(structure Tokens : SimpleSML_TOKENS)); -%s Comment String SkipString Quotation DQuotation; -%full -id=[A-Za-z][A-Za-z0-9_']* | [-!%&$#+/:<=>?@~^|*`\\]+; - -%% - -[\ \n\013\t] => - ( lex () ); -"(*" => - ( (comment_depth := 1; YYBEGIN Comment; lex ()) ); -"*)" => - ( lexError "unmatched comment bracket" yytext yypos ); -'[A-Za-z0-9_']+ => - ( NULL(yypos,yypos) ); -~?[0-9]+(\.[0-9]+)?(E~?[0-9]+)? => - ( NULL(yypos,yypos) ); -["] | #["] => - ( (YYBEGIN String; lex ()) ); -[_,{}[();] | "]" | "..." | #\[ => - ( NULL(yypos,yypos) ); -`` => - ( (YYBEGIN DQuotation; lex ()) ); -` => - ( (YYBEGIN Quotation; lex ()) ); -{id} => - ( mkKeyword yytext yypos ); -({id}\.)+{id} => - ( mkQualId yytext yypos ); -[\000-\255] => - ( lexError "ill-formed token" yytext yypos ); - - "(*" => - ( (incr comment_depth; lex ()) ); -"*)" => - ( (decr comment_depth; - if !comment_depth > 0 then lex () else (YYBEGIN INITIAL; lex ())) ); -[\000-\255] => - ( lex () ); - -\" => - ( YYBEGIN INITIAL; NULL(yypos,yypos) ); -\\["nt\\] => - ( lex () ); -\\[\ \t\n\013]+\\ => - ( lex () ); -\\\^[@-_] => - ( lex () ); -\\[0-9][0-9][0-9]=> - ( lex ()); -\\ => - ( (YYBEGIN SkipString; lex ()) ); -[\001-\026\127] => - ( (YYBEGIN SkipString; lex ()) ); -[\000-\255] => - ( lex () ); - -\" => - ( YYBEGIN INITIAL; NULL(yypos,yypos) ); -\\["nt\\] => - ( lex () ); -\\[\ \t\n\013]+\\ => - ( lex () ); -[\000-\255] => - ( lex () ); - -` => - ( YYBEGIN INITIAL; NULL(yypos,yypos) ); -\^` => - ( lex () ); -[\000-\255] => - ( lex () ); - -`` => - ( YYBEGIN INITIAL; NULL(yypos,yypos) ); -\^` => - ( YYBEGIN Quotation; lex () ); -[\000-\255] => - ( lex () ); diff --git a/tools-poly/Holmake/Parser.grm b/tools-poly/Holmake/Parser.grm deleted file mode 100644 index 022c22b676..0000000000 --- a/tools-poly/Holmake/Parser.grm +++ /dev/null @@ -1,48 +0,0 @@ -open List - -fun print s = TextIO.print; -fun printb s = print (s ^ " "); - -%% - -%eop EOF -%term EQUALS | NULL | OPEN | STAR | INCLUDE | ID of string | EOF | - QUAL_ID of string -%name SimpleSML - -%pos int - -%nonterm MLtext of string list | MLfrag of string list | - MLseq of string list | UnitName_seq of string list | - LongIdent of string list | UnitName of string | Ident of string - -%% -MLtext : - MLseq EOF ( MLseq1 ) - | EOF ( [] ) - -MLfrag : - NULL ( [] ) - | LongIdent ( LongIdent1 ) - | OPEN UnitName_seq ( UnitName_seq1 ) - | INCLUDE UnitName_seq( UnitName_seq1 ) - -MLseq : - MLfrag MLseq ( MLfrag1 @ MLseq1 ) - | MLfrag ( MLfrag1 ) - -UnitName_seq : - UnitName UnitName_seq ( UnitName1 :: UnitName_seq1 ) - | (* empty *) ( [] ) - -UnitName : - Ident ( Ident1 ) - | EQUALS ( "=" ) - -Ident : - ID ( ID1 ) - | STAR ( "*" ) - -LongIdent : - Ident ( [] ) - | QUAL_ID ( [QUAL_ID1] ) diff --git a/tools-poly/Holmake/poly-Holmake.ML b/tools-poly/Holmake/poly-Holmake.ML index cd97856126..3c9e5f7adb 100644 --- a/tools-poly/Holmake/poly-Holmake.ML +++ b/tools-poly/Holmake/poly-Holmake.ML @@ -4,6 +4,7 @@ val _ = PolyML.print_depth 0; val _ = use "poly/poly-init.ML"; structure BasicIO = SML90; +exception Interrupt = SML90.Interrupt fun useH f = (use ("Holmake/" ^ f ^ ".sig"); @@ -15,6 +16,13 @@ fun useC f = val _ = use "../tools/Holmake/Systeml.sig" val _ = use "Holmake/Systeml.sml"; + +val _ = useC "SourcePos"; +val _ = useC "SourceFile"; +val _ = useC "Region" +val _ = use "../tools/Holmake/Holdep_tokens.lex.sml"; +val _ = useC "Holdep"; + val _ = useC "regexpMatch"; val _ = useC "parse_glob"; val _ = useC "internal_functions"; @@ -22,17 +30,6 @@ val _ = useC "Holmake_types"; val _ = useC "Holmake_tools"; val _ = useC "ReadHMF"; -fun u f = use ("../tools/mlyacc/mlyacclib/" ^ f ^ ".sml"); -val _ = u "MLY_base-sig"; -val _ = u "MLY_join"; -val _ = u "MLY_lrtable"; -val _ = u "MLY_stream"; -val _ = u "MLY_parser2"; - -val _ = useH "Parser.grm"; -val _ = use "Holmake/Lexer.lex.sml"; - -val _ = use "Holmake/Holdep.sml"; val _ = use "Holmake/Holmake.sml"; val _ = PolyML.shareCommonData Holmake.main; diff --git a/tools-poly/configure.sml b/tools-poly/configure.sml index b4fc718d11..3f16ed7c2d 100644 --- a/tools-poly/configure.sml +++ b/tools-poly/configure.sml @@ -406,8 +406,7 @@ val _ = val _ = (echo "Making bin/Holmake"; FileSys.chDir hmakedir; - systeml [lexer, "Lexer.lex"]; - systeml [yaccer, "Parser.grm"]; + systeml [lexer, fullPath [HOLDIR, "tools", "Holmake", "Holdep_tokens.lex"]]; FileSys.chDir toolsdir; system_ps (POLY ^ " < " ^ fullPath ["Holmake", "poly-Holmake.ML"]); compile systeml hmakebin (fullPath ["Holmake", "Holmake.o"]); diff --git a/tools-poly/poly-build.ML b/tools-poly/poly-build.ML index caf8063456..aa1033e085 100644 --- a/tools-poly/poly-build.ML +++ b/tools-poly/poly-build.ML @@ -2,20 +2,24 @@ val _ = PolyML.Compiler.prompt1:=""; val _ = PolyML.Compiler.prompt2:=""; val _ = PolyML.print_depth 0; val _ = use "poly/poly-init.ML"; +exception Interrupt = SML90.Interrupt val _ = use "../tools/Holmake/Systeml.sig"; +fun useC f = + (use ("../tools/Holmake/" ^ f ^ ".sig"); + use ("../tools/Holmake/" ^ f ^ ".sml")) + val _ = use "Holmake/Systeml.sml"; -val _ = use "../tools/Holmake/Holmake_tools.sig" -val _ = use "../tools/Holmake/Holmake_tools.sml" -val _ = use "../tools/Holmake/regexpMatch.sig" -val _ = use "../tools/Holmake/regexpMatch.sml" -val _ = use "../tools/Holmake/parse_glob.sig" -val _ = use "../tools/Holmake/parse_glob.sml" -val _ = use "../tools/Holmake/internal_functions.sig" -val _ = use "../tools/Holmake/internal_functions.sml" -val _ = use "../tools/Holmake/Holmake_types.sig" -val _ = use "../tools/Holmake/Holmake_types.sml" -val _ = use "../tools/Holmake/ReadHMF.sig" -val _ = use "../tools/Holmake/ReadHMF.sml" +val _ = useC "SourcePos"; +val _ = useC "SourceFile"; +val _ = useC "Region" +val _ = use "../tools/Holmake/Holdep_tokens.lex.sml"; +val _ = useC "Holdep"; +val _ = useC "Holmake_tools" +val _ = useC "regexpMatch" +val _ = useC "parse_glob" +val _ = useC "internal_functions" +val _ = useC "Holmake_types" +val _ = useC "ReadHMF" val _ = use "../tools/buildutils.sig"; val _ = use "../tools/buildutils.sml"; val _ = use "build.sml"; diff --git a/tools/Holmake/Holdep.sig b/tools/Holmake/Holdep.sig index 0e1ba64cc0..bb6892891d 100644 --- a/tools/Holmake/Holdep.sig +++ b/tools/Holmake/Holdep.sig @@ -4,7 +4,7 @@ sig exception Holdep_Error of string val main : { assumes : string list, includes : string list, - debug : bool, + diag : string -> unit, fname : string } -> {tgt : string, deps : string list} diff --git a/tools/Holmake/Holdep.sml b/tools/Holmake/Holdep.sml index f4f7bfd771..05a7872a41 100644 --- a/tools/Holmake/Holdep.sml +++ b/tools/Holmake/Holdep.sml @@ -12,11 +12,13 @@ structure Holdep :> Holdep = struct structure Process = OS.Process +structure Path = OS.Path +structure FileSys = OS.FileSys exception Holdep_Error of string fun normPath s = Path.toString(Path.fromString s) fun manglefilename s = normPath s -fun errMsg str = BasicIO.output(BasicIO.std_err, str ^ "\n\n") +fun errMsg str = TextIO.output(TextIO.stdErr, str ^ "\n\n") fun fail() = Process.exit Process.failure fun addExt s "" = normPath s @@ -162,7 +164,7 @@ in {tgt = targetname, deps = res} end -fun processfile {assumes, includes, fname = filename, debug} = +fun processfile {assumes, includes, fname = filename, diag} = let val {base, ext} = Path.splitBaseExt filename in @@ -176,14 +178,12 @@ fun processfile {assumes, includes, fname = filename, debug} = (* assumes parameter is a list of files that we assume can be built in this directory *) -fun main (r as {assumes, debug, includes, fname}) = +fun main (r as {assumes, diag, includes, fname}) = let val results = processfile r in - if debug then - print ("Holdep: " ^ #tgt results ^ ": " ^ - String.concatWith ", " (#deps results) ^ "\n") - else (); + diag ("Holdep: " ^ #tgt results ^ ": " ^ + String.concatWith ", " (#deps results) ^ "\n"); results end handle e as OS.SysErr (str, _) => (errMsg str; raise e) diff --git a/tools/Holmake/Holmake.sml b/tools/Holmake/Holmake.sml index d98a04fd15..47582bb072 100644 --- a/tools/Holmake/Holmake.sml +++ b/tools/Holmake/Holmake.sml @@ -623,55 +623,6 @@ end else () runs holdep, and puts the output into specified file, which will live in DEPDIR somewhere. *) -exception HolDepFailed -fun runholdep arg destination_file = let - datatype res = Success of string list | Failure of string - val _ = print ("Analysing "^fromFile arg^"\n") - fun buildables s = let - val f = toFile s - val files = - case f of - SML (ss as Script t) => [UI ss, UO ss, SML (Theory t), - SIG (Theory t), UI (Theory t), - UO (Theory t), f] - | SML ss => [UI ss, UO ss, f] - | SIG ss => [UI ss, f] - | x => [x] - in - map fromFile files - end - val buildable_extras = List.concat (map buildables extra_targets) - val includes = hmake_preincludes @ std_include_flags @ additional_includes - val _ = diag ("Running Holdep on "^fromFile arg^" with debug = "^ - Bool.toString debug ^ ", includes = [" ^ - String.concatWith ", " includes ^ "]") - val holdep_result = - Holdep.main {assumes = buildable_extras, debug = debug, - includes = hmake_preincludes @ std_include_flags @ - additional_includes, - fname = fromFile arg} - handle Holdep.Holdep_Error s => - (info "Holdep failed: s"; raise HolDepFailed) - | Interrupt => raise Interrupt - | e => (info ("Holdep exception: "^General.exnMessage e); - raise HolDepFailed) - fun myopen s = - if FileSys.access(DEPDIR, []) then - if FileSys.isDir DEPDIR then TextIO.openOut s - else die_with ("Want to put dependency information in directory "^ - DEPDIR^", but it already exists as a file") - else - (info ("Trying to create directory "^DEPDIR^" for dependency files"); - FileSys.mkDir DEPDIR; - TextIO.openOut s - ) - open TextIO - val destin = normPath destination_file - val outstr = myopen destin -in - output(outstr, Holdep.encode_for_HOLMKfile holdep_result); - closeOut outstr -end fun get_direct_dependencies (f : File) : File list = let val fname = fromFile f @@ -683,7 +634,10 @@ in val depfile = mk_depfile_name argname val _ = if argname forces_update_of depfile then - runholdep arg depfile + runholdep {ofs = output_functions, extras = extra_targets, + includes = hmake_preincludes @ std_include_flags @ + additional_includes, arg = arg, + destination = depfile} else () val phase1 = (* circumstances can arise in which the dependency file won't be diff --git a/tools/Holmake/Holmake_tools.sig b/tools/Holmake/Holmake_tools.sig index 74ee39298f..703fb7b047 100644 --- a/tools/Holmake/Holmake_tools.sig +++ b/tools/Holmake/Holmake_tools.sig @@ -33,6 +33,12 @@ sig {no_lastmakercheck : bool} -> unit + (* dependency analysis *) + exception HolDepFailed + val runholdep : + {ofs : output_functions, includes : string list, extras : string list, + arg : File, destination : string} -> unit + (* File IO *) val string_part : File -> string val toCodeType : string -> CodeType diff --git a/tools/Holmake/Holmake_tools.sml b/tools/Holmake/Holmake_tools.sml index bc2a1dffb5..35ea861d66 100644 --- a/tools/Holmake/Holmake_tools.sml +++ b/tools/Holmake/Holmake_tools.sml @@ -373,4 +373,51 @@ fun generate_all_plausible_targets first_target = remove_sorted_dups (Listsort.sort file_compare initially) end +(* dependency analysis *) +exception HolDepFailed +fun runholdep {ofs, extras, includes, arg, destination} = let + val {info, diag, ...} : output_functions = ofs + val _ = info ("Analysing "^fromFile arg) + fun buildables s = let + val f = toFile s + val files = + case f of + SML (ss as Script t) => [UI ss, UO ss, SML (Theory t), + SIG (Theory t), UI (Theory t), + UO (Theory t), f] + | SML ss => [UI ss, UO ss, f] + | SIG ss => [UI ss, f] + | x => [x] + in + map fromFile files + end + val buildable_extras = List.concat (map buildables extras) + val _ = diag ("Running Holdep on "^fromFile arg^" with includes = [" ^ + String.concatWith ", " includes ^ "], assumes = [" ^ + String.concatWith ", " buildable_extras ^"]") + val holdep_result = + Holdep.main {assumes = buildable_extras, diag = diag, + includes = includes, fname = fromFile arg} + handle Holdep.Holdep_Error s => + (info "Holdep failed: s"; raise HolDepFailed) + | Interrupt => raise Interrupt + | e => (info ("Holdep exception: "^General.exnMessage e); + raise HolDepFailed) + fun myopen s = + if FileSys.access(DEPDIR, []) then + if FileSys.isDir DEPDIR then TextIO.openOut s + else die_with ("Want to put dependency information in directory "^ + DEPDIR^", but it already exists as a file") + else + (info ("Trying to create directory "^DEPDIR^" for dependency files"); + FileSys.mkDir DEPDIR; + TextIO.openOut s + ) + open TextIO + val outstr = myopen (normPath destination) +in + output(outstr, Holdep.encode_for_HOLMKfile holdep_result); + closeOut outstr +end + end (* struct *) diff --git a/tools/sequences/kernel b/tools/sequences/kernel index eb1b801a17..56ec05ea54 100644 --- a/tools/sequences/kernel +++ b/tools/sequences/kernel @@ -10,7 +10,7 @@ src/parse src/bool src/1 !src/1/theory_tests -!tools/Holmake/tests/depchain1/dir3 +# (FIXME!) !tools/Holmake/tests/depchain1/dir3 !tools/Holmake/tests/altquote1/ src/proofman [poly]bin/hol.bare From 9d0df2dd9332b9b74db485a150b1b3892f2f02d7 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 4 Feb 2015 15:10:07 +1100 Subject: [PATCH 149/718] Allow Define to work even if = has been overloaded Doing so is probably a bad idea, but if the quotation would parse successfully to a term, it should work as a definition too. Issue is that the use of pdest_eq required a preterm of Const("="), but when "=" is overloaded the preterm will be using the Overloaded constructor instead. This form of definition used to work, incidentally. It was broken by work on issue #112 --- src/tfl/src/Defn.sml | 5 ++++- src/tfl/src/selftest.sml | 3 +++ 2 files changed, 7 insertions(+), 1 deletion(-) diff --git a/src/tfl/src/Defn.sml b/src/tfl/src/Defn.sml index f36f78b0e7..5f59db3ad2 100644 --- a/src/tfl/src/Defn.sml +++ b/src/tfl/src/Defn.sml @@ -1663,7 +1663,10 @@ end fun ptdefn_freevars pt = let open Preterm val (uvars, body) = strip_pforall pt - val (l,r) = pdest_eq body + val (l,r) = case strip_pcomb body of + (_, [l,r]) => (l,r) + | _ => raise ERRloc "ptdefn_freevars" (locn body) + "Couldn't see preterm as equality" val (f0, args) = strip_pcomb l val f = head_var f0 val lfs = op_U eq (map ptfvs args) diff --git a/src/tfl/src/selftest.sml b/src/tfl/src/selftest.sml index 0d6d8f87aa..cced041d65 100644 --- a/src/tfl/src/selftest.sml +++ b/src/tfl/src/selftest.sml @@ -37,3 +37,6 @@ val def7 = test "Case expression with underscores of different types" val def8 = test "Case expression with variables of different types" (Hol_defn "f3") `f3 x = case x of (f,T,_) => ~f | (_,F,f) => f F`; + +val _ = overload_on ("=", ``T``) +val _ = test "Definition with overloaded =" (Hol_defn "f4") `f4 x y = x /\ y` From 6970522cdbc88e4f5daa6977f52e731502580ebe Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 4 Feb 2015 15:59:37 +1100 Subject: [PATCH 150/718] Make holdeptool available as part of Poly/ML build. Also slightly tidy up lex implementation: can use inputN as parameter to makeLexer rather than inputLine. --- tools-poly/configure.sml | 5 +++++ tools/Holmake/Holdep_tokens.lex | 5 ----- tools/Holmake/holdeptool.sml | 2 +- tools/Holmake/poly-holdeptool.ML | 16 ++++++++++++++++ 4 files changed, 22 insertions(+), 6 deletions(-) create mode 100644 tools/Holmake/poly-holdeptool.ML diff --git a/tools-poly/configure.sml b/tools-poly/configure.sml index 3f16ed7c2d..62ae07aed5 100644 --- a/tools-poly/configure.sml +++ b/tools-poly/configure.sml @@ -410,6 +410,11 @@ val _ = FileSys.chDir toolsdir; system_ps (POLY ^ " < " ^ fullPath ["Holmake", "poly-Holmake.ML"]); compile systeml hmakebin (fullPath ["Holmake", "Holmake.o"]); + FileSys.chDir (fullPath [HOLDIR, "tools", "Holmake"]); + system_ps (POLY ^ " < poly-holdeptool.ML"); + compile systeml + (fullPath [HOLDIR, "bin", "holdeptool.exe"]) + (fullPath [HOLDIR, "tools", "Holmake", "holdeptool.o"]); FileSys.chDir cdir) handle _ => die "Failed to build Holmake."; diff --git a/tools/Holmake/Holdep_tokens.lex b/tools/Holmake/Holdep_tokens.lex index ac5003112c..ef1d162f5e 100644 --- a/tools/Holmake/Holdep_tokens.lex +++ b/tools/Holmake/Holdep_tokens.lex @@ -15,11 +15,6 @@ fun new_state fname = {commentdepth = ref 0, return = ref SINITIAL, source = SourceFile.new fname} -fun inputLine strm = - case TextIO.inputLine strm of - SOME s => s - | NONE => "" - type lexresult = string option exception LEX_ERROR of string fun regionError (r, s) = Region.toString r ^ ": " ^ s diff --git a/tools/Holmake/holdeptool.sml b/tools/Holmake/holdeptool.sml index 929a091ad8..c36c165954 100644 --- a/tools/Holmake/holdeptool.sml +++ b/tools/Holmake/holdeptool.sml @@ -27,7 +27,7 @@ fun main() = let | ["-n", fname] => (unsorted := true; file fname) | _ => usage die val arg = UserDeclarations.new_state fname - val lexer = makeLexer (fn _ => UserDeclarations.inputLine strm) arg + val lexer = makeLexer (fn n => TextIO.inputN(strm, n)) arg fun safelex () = lexer() handle UserDeclarations.LEX_ERROR s => diewith ("Lexical error: "^ s) fun unsortedf () = diff --git a/tools/Holmake/poly-holdeptool.ML b/tools/Holmake/poly-holdeptool.ML new file mode 100644 index 0000000000..21041d4989 --- /dev/null +++ b/tools/Holmake/poly-holdeptool.ML @@ -0,0 +1,16 @@ +val _ = PolyML.Compiler.prompt1:=""; +val _ = PolyML.Compiler.prompt2:=""; +val _ = PolyML.print_depth 0; +use "../../tools-poly/poly/Binaryset.sig"; +use "../../tools-poly/poly/Binaryset.sml"; +use "SourcePos.sig"; +use "SourcePos.sml"; +use "SourceFile.sig"; +use "SourceFile.sml"; +use "Region.sig"; +use "Region.sml"; +use "Holdep_tokens.lex.sml"; +use "holdeptool.sml"; + +val _ = PolyML.shareCommonData holdeptool.main +val _ = PolyML.export("holdeptool", holdeptool.main) From c92c0fadd757ef6b7ef96c22553ca62e1d146a5f Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 4 Feb 2015 16:02:41 +1100 Subject: [PATCH 151/718] Oops: inputN change needed to be made to Holdep.sml as well. --- tools/Holmake/Holdep.sml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/Holmake/Holdep.sml b/tools/Holmake/Holdep.sml index 05a7872a41..d65419ffa9 100644 --- a/tools/Holmake/Holdep.sml +++ b/tools/Holmake/Holdep.sml @@ -124,7 +124,7 @@ fun scanFile {fname,actualfname} = let open Holdep_tokens val is = TextIO.openIn actualfname val arg = UserDeclarations.new_state fname - val lexer = makeLexer (fn _ => UserDeclarations.inputLine is) arg + val lexer = makeLexer (fn n => TextIO.inputN(is,n)) arg handle UserDeclarations.LEX_ERROR s => raise Holdep_Error ("Lexical error: "^s) fun recurse acc = From 40158b75c83806e2901edf0037677582098ec5a3 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 5 Feb 2015 12:23:49 +1100 Subject: [PATCH 152/718] MLton implementation of quote filter. See some discussion of threading and interrupts at http://www.mlton.org/pipermail/mlton-user/2009-August/001559.html Seems to perform quite poorly compared to the PolyML version. --- tools/quote-filter/filter | 11 +++++ tools/quote-filter/mlton-quote-filter.sml | 55 +++++++++++++++++++++++ tools/quote-filter/unquote.mlb | 4 ++ 3 files changed, 70 insertions(+) create mode 100644 tools/quote-filter/mlton-quote-filter.sml create mode 100644 tools/quote-filter/unquote.mlb diff --git a/tools/quote-filter/filter b/tools/quote-filter/filter index 7f2256c8bc..cca2dd5606 100644 --- a/tools/quote-filter/filter +++ b/tools/quote-filter/filter @@ -11,6 +11,17 @@ datatype qfs = QFS of {output_stream : TextIO.outstream, row : int ref, rowstart : int ref} +fun newstate os = QFS {output_stream = os, + comdepth = ref 0, + pardepth = ref 0, + antiquote = ref false, + row = ref 0, + rowstart = ref 0} + +fun resetstate (QFS{comdepth, pardepth, antiquote,...}) = + (comdepth := 0; pardepth := 0; antiquote := false) + + fun ECHO (QFS {output_stream , ...}) s = TextIO.output(output_stream, s) fun print (QFS {output_stream, ...}) s = TextIO.output(output_stream, s) diff --git a/tools/quote-filter/mlton-quote-filter.sml b/tools/quote-filter/mlton-quote-filter.sml new file mode 100644 index 0000000000..6fe3019bab --- /dev/null +++ b/tools/quote-filter/mlton-quote-filter.sml @@ -0,0 +1,55 @@ +open OS.Process +open filter.UserDeclarations + +fun slave (input, outstream) state = let + val lexer = filter.makeLexer input state +in + lexer(); + TextIO.closeOut outstream; + exit success +end + +fun noninteractive (is,os) = let + fun input n = TextIO.input is +in + (fn () => slave(input, os) (newstate os)) +end + +fun interactive () = let + open MLton.Thread + val out = TextIO.stdOut + fun input _ = TextIO.input TextIO.stdIn + fun go() = prepare (new (slave (input, out)), newstate out) + fun interrupt_handler _ = go() + + val h = MLton.Signal.Handler.handler interrupt_handler +in + MLton.Signal.setHandler(Posix.Signal.int, h); + switch interrupt_handler +end + +val go : unit -> unit = + case CommandLine.arguments() of + [] => interactive + | [ifile, ofile] => + let + open TextIO + val is = openIn ifile + handle OS.SysErr _ => + (output(stdErr, "Error opening "^ifile^"\n"); + exit failure) + val os = openOut ofile + handle IO.Io {cause = OS.SysErr (_, eo), ...} => + (case eo of + SOME e => output(stdErr, OS.errorMsg e) + | NONE => (); + exit failure) + in + noninteractive (is,os) + end + | _ => (TextIO.output(TextIO.stdErr, + "Usage:\n " ^ CommandLine.name() ^ + " [ ]\n"); + exit failure) + +val _ = go() diff --git a/tools/quote-filter/unquote.mlb b/tools/quote-filter/unquote.mlb new file mode 100644 index 0000000000..dd2ecdba3f --- /dev/null +++ b/tools/quote-filter/unquote.mlb @@ -0,0 +1,4 @@ +$(SML_LIB)/basis/basis.mlb +$(SML_LIB)/basis/mlton.mlb +filter.sml +mlton-quote-filter.sml From 5119d3f36fa57539fcbe98e0e28453a2041e7bef Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Thu, 5 Feb 2015 15:43:12 +0000 Subject: [PATCH 153/718] Update ARM tools. Provides support for a few more instructions. --- .../l3-machine-code/arm/prog/arm_progLib.sml | 7 +- .../l3-machine-code/arm/step/arm_stepLib.sml | 78 +++++++++++++++++-- examples/l3-machine-code/common/stateLib.sml | 26 ++++--- examples/l3-machine-code/common/utilsLib.sig | 1 + examples/l3-machine-code/common/utilsLib.sml | 5 +- 5 files changed, 96 insertions(+), 21 deletions(-) diff --git a/examples/l3-machine-code/arm/prog/arm_progLib.sml b/examples/l3-machine-code/arm/prog/arm_progLib.sml index 0ddcc3814d..5d7a095d4d 100644 --- a/examples/l3-machine-code/arm/prog/arm_progLib.sml +++ b/examples/l3-machine-code/arm/prog/arm_progLib.sml @@ -610,6 +610,7 @@ local THENC stateLib.PRE_COND_CONV (DEPTH_CONV DISJOINT_CONV THENC REWRITE_CONV [arm_stepTheory.Aligned_numeric] + THENC numLib.REDUCE_CONV THENC NOT_F_CONV) THENC helperLib.POST_CONV (PURE_REWRITE_CONV spec_rwts @@ -839,9 +840,9 @@ local else let val thms = step s val ts = List.map arm_mk_pre_post thms - val thms_ts = - List.concat - (List.map combinations (ListPair.zip (thms, ts))) + val thms_ts = (thms, ts) |> ListPair.zip + |> List.map combinations + |> List.concat in List.app (fn x => (print "."; add1_pending x)) thms_ts ; thms_ts diff --git a/examples/l3-machine-code/arm/step/arm_stepLib.sml b/examples/l3-machine-code/arm/step/arm_stepLib.sml index 2ef439755f..416329e32d 100644 --- a/examples/l3-machine-code/arm/step/arm_stepLib.sml +++ b/examples/l3-machine-code/arm/step/arm_stepLib.sml @@ -66,6 +66,9 @@ local u_of "arm_state" val exc = ``SND (raise'exception e s : 'a # arm_state)`` in + val cond_thms = + [SIMP_CONV std_ss [] ``if a then b else if a then c else d : 'a``, + boolTheory.COND_ID] val cond_rand_thms = utilsLib.mk_cond_rand_thms (other_fns @ state_fns) val snd_exception_thms = utilsLib.map_conv @@ -79,7 +82,7 @@ end (* ARM datatype theorems/conversions *) fun datatype_thms thms = - thms @ [cond_rand_thms, snd_exception_thms, FST_SWAP] @ + thms @ cond_thms @ [cond_rand_thms, snd_exception_thms, FST_SWAP] @ utilsLib.datatype_rewrites true "arm" ["arm_state", "Architecture", "RName", "InstrSet", "SRType", "Encoding", "PSR", "VFPNegMul"] @@ -1684,6 +1687,10 @@ val arm_patterns = List.map (I ## epattern) ("Signed16x32Multiply32Result", "FFFTFFTF____________T_TF"), ("Signed16Multiply64Accumulate", "FFFTFTFF____________T__F"), ("Signed16Multiply32Result", "FFFTFTTF____________T__F"), + ("BitFieldClearOrInsert", "FTTTTTF______________FFT"), + ("BitFieldExtract", "FTTTT_T______________TFT"), + ("ExtendByte16", "FTTFT_FF__________FFFTTT"), + ("ByteReverse", "FTTFTFTTTTTT____TTTTFFTT"), ("Register", "FFFF___________________F"), ("Register ORR/BIC", "FFFTT_F________________F"), ("ShiftImmediate", "FFFTT_T________________F"), @@ -1766,6 +1773,7 @@ val arm_patterns = List.map (I ## epattern) val arm_patterns15 = List.map (I ## epattern) [("Setend", "FFFTFFFF___T________FFFF"), ("ChangeProcessorState", "FFFTFFFF___F__________F_"), + ("DataMemoryBarrier", "FTFTFTTTTTTTTTTTFFFFFTFT"), ("ReturnFromException", "TFF__F_T________________"), ("BranchLinkExchangeImmediate (to Thumb)", "TFT_____________________") ] @@ -1916,6 +1924,7 @@ local ("BLX (imm)", ("BranchLinkExchangeImmediate (to Thumb)", [])), ("BLX (reg)", ("BranchLinkExchangeRegister", [])), ("CLZ", ("CountLeadingZeroes", [])), + ("DMB", ("DataMemoryBarrier", [])), ("MOVT", ("MoveHalfword", [xT 0])), ("MOVW", ("MoveHalfword", [xF 0])), ("MOV (imm)", ("Move", [xF 0, xF 1])), @@ -2008,16 +2017,25 @@ local ("SMULL", ("MultiplyLong", [xT 0, xF 1, xF 2])), ("UMLAL", ("MultiplyLong", [xF 0, xT 1, xF 2])), ("SMLAL", ("MultiplyLong", [xT 0, xT 1, xF 2])), + ("UMULLS", ("MultiplyLong", [xF 0, xF 1, xT 2])), + ("SMULLS", ("MultiplyLong", [xT 0, xF 1, xT 2])), + ("UMLALS", ("MultiplyLong", [xF 0, xT 1, xT 2])), + ("SMLALS", ("MultiplyLong", [xT 0, xT 1, xT 2])), ("MULS", ("Multiply32", [xT 0])), ("MLAS", ("MultiplyAccumulate", [xT 0])), + ("SMLA", ("Signed16Multiply32Accumulate", [])), + ("BFC", ("BitFieldClearOrInsert", [])), + ("REV", ("ByteReverse", [])), ("UXTAB", ("ExtendByte", [xT 0])), ("SXTAB", ("ExtendByte", [xF 0])), ("UXTB", ("ExtendByte", [xT 0, xT 1, xT 2, xT 3, xT 4])), ("SXTB", ("ExtendByte", [xF 0, xT 1, xT 2, xT 3, xT 4])), - ("UMULLS", ("MultiplyLong", [xF 0, xF 1, xT 2])), - ("SMULLS", ("MultiplyLong", [xT 0, xF 1, xT 2])), - ("UMLALS", ("MultiplyLong", [xF 0, xT 1, xT 2])), - ("SMLALS", ("MultiplyLong", [xT 0, xT 1, xT 2])), + ("UXTAB16", ("ExtendByte16", [xT 0])), + ("SXTAB16", ("ExtendByte16", [xF 0])), + ("UXTB16", ("ExtendByte16", [xT 0, xT 1, xT 2, xT 3, xT 4])), + ("SXTB16", ("ExtendByte16", [xF 0, xT 1, xT 2, xT 3, xT 4])), + ("UBFX", ("BitFieldExtract", [xT 0])), + ("SBFX", ("BitFieldExtract", [xF 0])), ("LDR (+imm,pre,wb)", ("LoadWord (imm,pre)", [xT 0, xT 1])), ("LDR (-imm,pre,wb)", ("LoadWord (imm,pre)", [xF 0, xT 1])), ("LDR (+imm,pre)", ("LoadWord (imm,pre)", [xT 0, xF 1])), @@ -2095,6 +2113,10 @@ local ("LDRSB (-reg,pre,pc)", ("LoadSignedByte (reg,pre)", [xF 0, xF 1, xT 2, xT 3, xT 4, xT 5])), ("LDRSB (reg,post)", ("LoadSignedByte (reg,post)", [])), + ("LDRBT (+imm)", ("LoadByteUnprivileged (imm)", [xT 0])), + ("LDRBT (-imm)", ("LoadByteUnprivileged (imm)", [xF 0])), + ("LDRBT (+reg)", ("LoadByteUnprivileged (reg)", [xT 0])), + ("LDRBT (-reg)", ("LoadByteUnprivileged (reg)", [xF 0])), ("LDRH (+imm,pre,wb)", ("LoadHalf (imm,pre)", [xT 0, xT 1, xF 13])), ("LDRH (-imm,pre,wb)", ("LoadHalf (imm,pre)", [xF 0, xT 1, xF 13])), ("LDRH (+imm,pre)", ("LoadHalf (imm,pre)", [xT 0, xF 1, xF 13])), @@ -2533,6 +2555,7 @@ in in fn s => let + val s = utilsLib.removeSpaces s val v = bitstringSyntax.bitstring_of_hexstring s val x = if String.size s = 8 andalso uncond (String.sub (s, 0)) then [true] @@ -2552,6 +2575,11 @@ val NoOperation_rwt = ``dfn'NoOperation`` |> addThms +val DataMemoryBarrier_rwt = + EV [dfn'DataMemoryBarrier_def, IncPC_rwt] [] [] + ``dfn'DataMemoryBarrier opt`` + |> addThms + (* ---------------------------- *) val Setend_rwt = @@ -2904,6 +2932,15 @@ val MultiplyLong_rwt = ``n <> 15w: word4``, ``m <> 15w: word4``]] (TF `signed`) ``dfn'MultiplyLong (accumulate, signed, setflags, dhi, dlo, n, m)`` +val Signed16Multiply32Accumulate_rwt = + EV ([dfn'Signed16Multiply32Accumulate_def, IncPC_rwt, R_rwt, write'R_rwt] @ + npc_thm [`d`]) + [[``d <> 15w: word4``, ``n <> 15w: word4``, + ``m <> 15w: word4``, ``a <> 15w: word4``]] [] + ``dfn'Signed16Multiply32Accumulate (m_high, n_high, d, n, m, a)`` + |> List.map (FULL_DATATYPE_RULE o COND_UPDATE_RULE) + |> addThms + (* ---------------------------- *) val ExtendByte_rwt = @@ -2957,6 +2994,7 @@ in val bpc_addr1 = immediate1 List.tl bpc_addr val bpc_addr2 = immediate2 List.tl bpc_addr val bpc_addr3 = immediate3 List.tl bpc_addr + val plain_addr1 = immediate1 Lib.I [[`a` |-> ``T``], [`a` |-> ``F``]] end (* ---------------------------- *) @@ -3121,6 +3159,12 @@ val LoadSignedByte_base_pc_rwts = ``dfn'LoadByte (F, a, idx, wb, t, 15w, register_form1 (r, SRType_LSL, imm2))`` +val LoadByteUnprivileged_rwts = + memEV (rule_npc false) MemU_unpriv_1_rwt [dfn'LoadByteUnprivileged_def] + [[``t <> 15w: word4``, ``n <> 15w: word4``, ``r <> 15w: word4``]] + plain_addr1 + ``dfn'LoadByteUnprivileged (a, T, t, n, m)`` + (* ---------------------------- *) val LoadHalf_rwts = @@ -3461,6 +3505,29 @@ val () = resetEvConv () (* ---------------------------- *) +(* Media *) + +val BitFieldClearOrInsert_rwt = + regEV [`d`] [dfn'BitFieldClearOrInsert_def] [[``d <> 15w: word4``]] [] + ``dfn'BitFieldClearOrInsert (d, n, lsb, msb)`` + +val BitFieldExtract_rwt = + regEV [`d`] [dfn'BitFieldExtract_def] + [[``d <> 15w: word4``, ``n <> 15w: word4``]] [] + ``dfn'BitFieldExtract (U, d, n, lsb, widthminus1)`` + +val ExtendByte16_rwt = + regEV [`d`] [dfn'ExtendByte16_def, ROR_rwt, wordsTheory.WORD_EXTRACT_ZERO2] + [[``d <> 15w: word4``, ``m <> 15w: word4``]] [] + ``dfn'ExtendByte16 (U, d, n, m, rot)`` + +val ByteReverse_rwt = + regEV [`d`] [dfn'ByteReverse_def] + [[``d <> 15w: word4``, ``m <> 15w:word4``]] [] + ``dfn'ByteReverse (d, m)`` + +(* ---------------------------- *) + val COND_B_CONV = Conv.RATOR_CONV o Conv.RATOR_CONV o Conv.RAND_CONV val COND_T_CONV = Conv.RATOR_CONV o Conv.RAND_CONV val COND_E_CONV = Conv.RAND_CONV @@ -3842,6 +3909,7 @@ in in fn s => let + val s = utilsLib.removeSpaces s val v = bitstringSyntax.bitstring_of_hexstring s in if String.size s = 8 andalso uncond (String.sub (s, 0)) diff --git a/examples/l3-machine-code/common/stateLib.sml b/examples/l3-machine-code/common/stateLib.sml index 09692447e3..667032b56f 100644 --- a/examples/l3-machine-code/common/stateLib.sml +++ b/examples/l3-machine-code/common/stateLib.sml @@ -1462,6 +1462,13 @@ local List.map (fn ((r1, a), (r2, b)) => (Lib.assert (op =) (r1, r2); (r1, a, b))) (ListPair.zip (f p, f q)) + fun takeWhile P = + let + fun iter [] = [] + | iter (h :: t) = if P h then h :: iter t else [] + in + iter + end in fun register_combinations (dest_reg, reg_width, proj_reg, reg_conv, ok_conv, asm, model_tm) = @@ -1499,21 +1506,16 @@ in ((v2 |-> v1) :: List.mapPartial instantiate l, [tm2]) end val frees = List.filter Term.is_var o explode_reg - val no_free = List.null o frees - fun exists_free l = List.exists (fn (t, _, _) => not (no_free t)) l + fun no_free (t, _: term, _: term) = List.null (frees t) + val exists_free = List.exists (not o no_free) + fun no_good l = List.length (takeWhile no_free l) > 1 fun groupings ok rs = let - val (cs, vs) = List.partition (fn (t, _, _) => no_free t) rs - fun add_c l = - List.concat - (List.map - (fn x => - x :: - List.map (fn c => List.map (fn y => c :: y) x) cs) l) + val (cs, vs) = List.partition no_free rs in - vs + (cs @ vs) |> utilsLib.partitions - |> add_c + |> List.filter (not o Lib.exists no_good) |> List.map (List.mapPartial (fn l => @@ -1535,7 +1537,7 @@ in (fn l => let val (h, t) = - Lib.pluck (fn (tm, _, _) => no_free tm) l + Lib.pluck no_free l handle HOL_ERR {message = "predicate not satisfied", diff --git a/examples/l3-machine-code/common/utilsLib.sig b/examples/l3-machine-code/common/utilsLib.sig index 3c5d29f3bd..3659f7813b 100644 --- a/examples/l3-machine-code/common/utilsLib.sig +++ b/examples/l3-machine-code/common/utilsLib.sig @@ -82,6 +82,7 @@ sig 'c * 'a list val qm: thm list -> term -> thm val qm_tac: thm list -> tactic + val removeSpaces: string -> string val resetStepConv: unit -> unit val rhsc: thm -> term val rng: hol_type -> hol_type diff --git a/examples/l3-machine-code/common/utilsLib.sml b/examples/l3-machine-code/common/utilsLib.sml index f926052f08..621abbd43f 100644 --- a/examples/l3-machine-code/common/utilsLib.sml +++ b/examples/l3-machine-code/common/utilsLib.sml @@ -168,6 +168,9 @@ end val lowercase = String.map Char.toLower val uppercase = String.map Char.toUpper +val removeSpaces = + String.translate (fn c => if Char.isSpace c then "" else String.str c) + val long_term_to_string = Lib.with_flag (Globals.linewidth, 1000) Hol_pp.term_to_string @@ -373,7 +376,7 @@ local wordsTheory.WORD_ADD_0, wordsTheory.WORD_MULT_CLAUSES, wordsTheory.WORD_AND_CLAUSES, wordsTheory.WORD_OR_CLAUSES, wordsTheory.WORD_XOR_CLAUSES, wordsTheory.WORD_EXTRACT_ZERO2, - wordsTheory.w2w_0, wordsTheory.WORD_SUB_REFL] + wordsTheory.w2w_0, wordsTheory.WORD_SUB_REFL, wordsTheory.SHIFT_ZERO] in val WALPHA_CONV = REWRITE_CONV alpha_rwts val WGROUND_CONV = From e9d15b45508f17159f270e3287a9f4899387d6ab Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 5 Feb 2015 13:49:29 +1100 Subject: [PATCH 154/718] Minor tidying in quotation filter code. --- tools/quote-filter/poly-unquote.ML | 17 ++--------------- tools/quote-filter/quote-filter.sml | 4 +--- 2 files changed, 3 insertions(+), 18 deletions(-) diff --git a/tools/quote-filter/poly-unquote.ML b/tools/quote-filter/poly-unquote.ML index 89e6a44bbe..6c7710aa9f 100644 --- a/tools/quote-filter/poly-unquote.ML +++ b/tools/quote-filter/poly-unquote.ML @@ -2,10 +2,6 @@ val _ = PolyML.Compiler.prompt1:=""; val _ = PolyML.Compiler.prompt2:=""; val _ = PolyML.print_depth 0; -structure Substring = struct - open Substring - val all = full -end; use "filter.sml"; open OS.Process @@ -44,21 +40,12 @@ fun main() = let Kenn Heinrich who helped me see the light with respect to this code *) open filter.UserDeclarations - val state as QFS args = - QFS {output_stream=outstream, comdepth=ref 0, pardepth=ref 0, - antiquote=ref false, row=ref 0, rowstart=ref 0}; + val state as QFS args = newstate outstream fun loop() = let val lexer = filter.makeLexer (read_from_stream instream) state in - lexer() - handle Interrupt => (let open filter.UserDeclarations - in - #comdepth args := 0; - #pardepth args := 0; - #antiquote args := false; - loop() - end) + lexer() handle Interrupt => (resetstate state; loop()) end in loop(); diff --git a/tools/quote-filter/quote-filter.sml b/tools/quote-filter/quote-filter.sml index 7839bea381..12af463505 100644 --- a/tools/quote-filter/quote-filter.sml +++ b/tools/quote-filter/quote-filter.sml @@ -31,9 +31,7 @@ val (instream, outstream) = exit failure) open filter.UserDeclarations - val state as QFS args = - QFS {output_stream=outstream, comdepth=ref 0, pardepth=ref 0, - antiquote=ref false, row=ref 0, rowstart=ref 0}; +val state as QFS args = newstate outstream (* with many thanks to Ken Friis Larsen, Peter Sestoft, Claudio Russo and Kenn Heinrich who helped me see the light with respect to this code *) From d979b8fec24f19c3f24d792caf2702aa1156e7f8 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 5 Feb 2015 15:09:13 +1100 Subject: [PATCH 155/718] Minor code cleanup in Holdep.sml --- tools/Holmake/Holdep.sml | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/tools/Holmake/Holdep.sml b/tools/Holmake/Holdep.sml index d65419ffa9..753f6eeb49 100644 --- a/tools/Holmake/Holdep.sml +++ b/tools/Holmake/Holdep.sml @@ -19,12 +19,10 @@ exception Holdep_Error of string fun normPath s = Path.toString(Path.fromString s) fun manglefilename s = normPath s fun errMsg str = TextIO.output(TextIO.stdErr, str ^ "\n\n") -fun fail() = Process.exit Process.failure fun addExt s "" = normPath s | addExt s ext = normPath s^"."^ext; fun addDir dir s = Path.joinDirFile{dir=normPath dir,file=s} -val srev = String.implode o List.rev o String.explode val space = " "; fun spacify [] = [] @@ -105,19 +103,20 @@ in else []) end; -val escape_spaces = let +val escape_space = let fun translation c = if c = #" " then "\\ " else if c = #"\\" then "\\\\" else str c - val escape_space = String.translate translation in - map escape_space + String.translate translation end +val escape_spaces = map escape_space + fun encode_for_HOLMKfile {tgt, deps} = if null deps then "" else - hd (escape_spaces [tgt]) ^ ": " ^ + escape_space tgt ^ ": " ^ String.concat (spacify (rev ("\n" :: escape_spaces deps))) fun scanFile {fname,actualfname} = let From 914184adc57ffa5626b534bccf059008c47ace99 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 5 Feb 2015 15:09:36 +1100 Subject: [PATCH 156/718] Modify term-encoding in theory files to be more compact. Both kernels now use a reverse-polish encoding (with the two binary operators being application and abstraction). There is no whitespace or any parentheses in the new encoding. On "typical" core theories such as integerTheory and wordsTheory, this saves about 10% in total theory size. On larger theories (such as those in CakeML), I hope the saving will be even greater. --- src/0/Term.sig | 1 - src/0/Term.sml | 112 +++++++++-------------- src/experimental-kernel/Term.sml | 152 +++++++++---------------------- 3 files changed, 82 insertions(+), 183 deletions(-) diff --git a/src/0/Term.sig b/src/0/Term.sig index 114b9ca4ee..2b8eb02511 100644 --- a/src/0/Term.sig +++ b/src/0/Term.sig @@ -14,7 +14,6 @@ sig val break_const : term -> KernelTypes.id * hol_type val break_abs : term -> term val trav : (term -> unit) -> term -> unit - val pp_raw_term : (term -> int) -> Portable.ppstream -> term -> unit val is_bvar : term -> bool end; diff --git a/src/0/Term.sml b/src/0/Term.sml index 6101a7f201..0df73864dc 100644 --- a/src/0/Term.sml +++ b/src/0/Term.sml @@ -972,31 +972,30 @@ fun trav f = * Raw syntax prettyprinter for terms. * *---------------------------------------------------------------------------*) -val dot = "." +val app = "@" +val lam = "|" val dollar = "$" -val percent = "%"; - -fun pp_raw_term index pps tm = - let open Portable - val {add_string,add_break,begin_block,end_block,...} = with_ppstream pps - fun pp (Abs(Bvar,Body)) = - ( add_string "(|"; - pp Bvar; add_string dot; add_break(1,0); - pp Body; add_string ")" ) - | pp (Comb(Rator,Rand)) = - ( add_string "("; pp Rator; add_break(1,0); - pp Rand; add_string ")") - | pp (Bv i) = add_string (dollar^Lib.int_to_string i) - | pp a = add_string (percent^Lib.int_to_string (index a)) - in - begin_block INCONSISTENT 0; - pp (norm_clos tm); - end_block() - end; +val percent = "%" +datatype pptask = ppTM of term | ppLAM | ppAPP +fun pp_raw_term index tm = let + fun pp acc tasklist = + case tasklist of + [] => String.concat (List.rev acc) + | ppTM (Abs(Bvar, Body)) :: rest => + pp acc (ppTM Bvar :: ppTM Body :: ppLAM :: rest) + | ppTM (Comb(Rator, Rand)) :: rest => + pp acc (ppTM Rator :: ppTM Rand :: ppAPP :: rest) + | ppTM (Bv i) :: rest => + pp (dollar ^ Int.toString i :: acc) rest + | ppTM a :: rest => + pp (percent ^ Int.toString (index a) :: acc) rest + | ppLAM :: rest => pp (lam :: acc) rest + | ppAPP :: rest => pp (app :: acc) rest +in + pp [] [ppTM tm] +end -fun write_raw index = - String.translate (fn #"\n" => " " | c => str c) o - HOLPP.pp_to_string 75 (pp_raw_term index) +fun write_raw index tm = pp_raw_term index (norm_clos tm) (*---------------------------------------------------------------------------* * Fetching theorems from disk. The following parses the "raw" term * @@ -1005,10 +1004,8 @@ fun write_raw index = local datatype lexeme - = dot + = app | lamb - | lparen - | rparen | ident of int | bvar of int; @@ -1025,60 +1022,33 @@ end; (* don't allow numbers to be split across fragments *) fun lexer ss1 = - case Substring.getc (Lib.deinitcommentss ss1) of - (* was: (Substring.dropl Char.isSpace ss1) *) + case Substring.getc ss1 of NONE => NONE | SOME (c,ss2) => case c of - #"." => SOME(dot, ss2) - | #"|" => SOME(lamb, ss2) - | #"(" => SOME(lparen,ss2) - | #")" => SOME(rparen,ss2) - | #"%" => let val (n,ss3) = take_numb ss2 in SOME(ident n, ss3) end - | #"$" => let val (n,ss3) = take_numb ss2 in SOME(bvar n, ss3) end - | _ => raise ERR "raw lexer" "bad character"; - -fun eat_rparen ss = - case lexer ss - of SOME (rparen, ss') => ss' - | _ => raise ERR "eat_rparen" "expected right parenthesis"; - -fun eat_dot ss = - case lexer ss - of SOME (dot, ss') => ss' - | _ => raise ERR "eat_dot" "expected a \".\""; + #"|" => SOME(lamb, ss2) + | #"%" => let val (n,ss3) = take_numb ss2 in SOME(ident n, ss3) end + | #"$" => let val (n,ss3) = take_numb ss2 in SOME(bvar n, ss3) end + | #"@" => SOME(app, ss2) + | _ => raise ERR "raw lexer" "bad character"; in fun read_raw tmv = let fun index i = Vector.sub(tmv, i) fun parse (stk,ss) = - case lexer ss of - SOME (bvar n, rst) => (Bv n::stk,rst) - | SOME (ident n, rst) => (index n::stk,rst) - | SOME (lparen, rst) => - (case lexer rst - of SOME (lamb, rst') => parse (glamb (stk,rst')) - | _ => parse (parsel (parse (stk,rst)))) - | _ => (stk,ss) - and - parsel (stk,ss) = - case parse (stk,ss) - of (h1::h2::t, ss') => (Comb(h2,h1)::t, eat_rparen ss') - | _ => raise ERR "raw.parsel" "impossible" - and - glamb(stk,ss) = - case lexer ss - of SOME (ident n, rst) => - (case parse (stk, eat_dot rst) - of (h::t,rst1) => (Abs(index n,h)::t, eat_rparen rst1) - | _ => raise ERR "glamb" "impossible") - | _ => raise ERR "glamb" "expected an identifier" + case (stk, lexer ss) of + (_, SOME (bvar n, rst)) => parse (Bv n::stk,rst) + | (_, SOME (ident n, rst)) => parse (index n::stk,rst) + | (x::f::stk, SOME (app, rst)) => parse (Comb(f,x)::stk, rst) + | (bd::bv::stk, SOME(lam,rst)) => parse (Abs(bv,bd)::stk, rst) + | (_, SOME(app, _)) => raise ERR "read_raw" "app: small stack" + | (_, SOME(lam, _)) => raise ERR "read_raw" "lam: small stack" + | ([tm], NONE) => tm + | ([], NONE) => raise ERR "read_raw" "eof: empty stack" + | (_, NONE) => raise ERR "read_raw" "eof: large stack" in -fn s => - case parse ([], Substring.full s) - of ([v], _) => v - | otherwise => raise ERR "raw term parser" "parse failed" -end; +fn s => parse ([], Substring.full s) +end end (* local *) (* ---------------------------------------------------------------------- diff --git a/src/experimental-kernel/Term.sml b/src/experimental-kernel/Term.sml index bd2f906d9e..8328ba6752 100644 --- a/src/experimental-kernel/Term.sml +++ b/src/experimental-kernel/Term.sml @@ -1058,138 +1058,68 @@ fun prim_mk_imp t1 t2 = App(App(imp, t1), t2) * Raw syntax prettyprinter for terms. * *---------------------------------------------------------------------------*) -val dot = "." -val percent = "%"; - -fun pp_raw_term index pps tm = - let open Portable - val {add_string,add_break,begin_block,end_block,...} = with_ppstream pps - fun pp (Abs(Bvar,Body)) = - ( add_string "\\\\("; - pp Bvar; add_string ","; add_break(1,0); - pp Body; add_string ")" ) - | pp (App(Rator,Rand)) = - ( add_string "("; pp Rator; add_break(1,0); - add_string "& "; - pp Rand; add_string ")") - | pp a = add_string (percent^Lib.int_to_string (index a)) - in - begin_block INCONSISTENT 0; - pp tm; - end_block() - end; - +val app = "@" +val lam = "|" +val percent = "%" + +datatype pptask = ppTM of term | ppLAM | ppAPP +fun pp_raw_term index tm = let + fun pp acc tasklist = + case tasklist of + [] => String.concat (List.rev acc) + | ppTM (Abs(Bvar, Body)) :: rest => + pp acc (ppTM Bvar :: ppTM Body :: ppLAM :: rest) + | ppTM (App(Rator, Rand)) :: rest => + pp acc (ppTM Rator :: ppTM Rand :: ppAPP :: rest) + | ppTM vc :: rest => + pp (percent ^ Int.toString (index vc) :: acc) rest + | ppLAM :: rest => pp ("|" :: acc) rest + | ppAPP :: rest => pp ("@" :: acc) rest +in + pp [] [ppTM tm] +end +val write_raw = pp_raw_term local -datatype tok = bslash | id of int | lparen | rparen +datatype tok = lam | id of int | app open StringCvt -fun readtok (c : (char, cs) reader) cs0 = let - val cs = skipWS c cs0 +fun readtok (c : (char, cs) reader) cs = let val intread = Int.scan DEC c in case c cs of NONE => NONE - | SOME (#"|",cs') => SOME (bslash,cs') - | SOME (#"(",cs') => SOME (lparen,cs') - | SOME (#")",cs') => SOME (rparen,cs') - | SOME c => (case intread cs of - NONE => NONE - | SOME (i,cs') => SOME(id i, cs')) + | SOME (#"|",cs') => SOME (lam,cs') + | SOME (#"@",cs') => SOME (app,cs') + | SOME (c,cs') => (case intread cs' of + NONE => NONE + | SOME (i,cs'') => SOME(id i, cs'')) end -(* SLR parser for grammar - - T ::= tm $ - tm ::= '|' [id] tm - tm ::= tmc - tmc ::= tmc tmb - tmc ::= tmb - tmb ::= [id] - tmb ::= '(' tm ')' -*) - -datatype stk_item = LAM of term | C of term | BK | Start - fun parse tmv c cs0 = let fun adv cs = case readtok c cs of NONE => (NONE, cs) | SOME (t, cs') => (SOME t, cs') - fun new_bv i stk = LAM (Vector.sub(tmv,i)) :: stk fun parse_term stk cur = - case cur of - (NONE,_) => NONE - | (SOME bslash, cs') => let - in - case readtok c cs' of - NONE => NONE - | SOME (id i, cs'') => parse_term (new_bv i stk) (adv cs'') - | _ => NONE - end - | (SOME lparen, cs') => parse_term (BK :: stk) (adv cs') - | (SOME (id i), cs') => reduce_tmb stk (Vector.sub(tmv,i)) (adv cs') - | _ => raise Fail "parse failure 1 in RawParse.parse" - and reduce_tmb stk tm cur = - case stk of - [] => NONE - | C t :: rest => parse_tmc (C (mk_comb(t,tm)) :: rest) cur - | _ => parse_tmc (C tm :: stk) cur - and parse_tmc stk cur = - case cur of - (NONE, _) => reduce_tm stk cur - | (SOME(id i), cs') => reduce_tmb stk (Vector.sub(tmv,i)) (adv cs') - | (SOME lparen, cs') => parse_term (BK :: stk) (adv cs') - | (SOME rparen, cs') => reduce_tm stk (adv cs') - | _ => raise Fail "parse failure 2 in RawParse.parse" - and reduce_tm stk cur = - case stk of - C t :: BK :: rest => reduce_tmb rest t cur - | C t :: Start :: rest => SOME (t, #2 cur) - | C t :: LAM bv :: rest => reduce_tm (C (mk_abs(bv,t)) :: rest) cur - | _ => raise Fail "parse failure 3 (reduce) in RawParse.parse" + case (stk, cur) of + ([t], (NONE,cs)) => SOME (t, cs) + | ([], (NONE, _)) => raise Fail "raw_parse.eof: empty stack" + | (_, (NONE, _)) => raise Fail "raw_parse.eof: large stack" + | (body :: bvar :: stk, (SOME lam, cs')) => + parse_term (Abs(bvar,body) :: stk) (adv cs') + | (_, (SOME lam, _)) => raise Fail "raw_parse.abs: short stack" + | (x :: f :: stk, (SOME app, cs')) => + parse_term (App(f,x) :: stk) (adv cs') + | (_, (SOME app, _)) => raise Fail "raw_parse.app: short stack" + | (stk, (SOME (id i), cs')) => + parse_term (Vector.sub(tmv, i) :: stk) (adv cs') in - parse_term [Start] (adv cs0) + parse_term [] (adv cs0) end -datatype grav = Top | CombL | CombR -datatype ppaction = Brk | Tm of term * grav | Stg of string - in fun read_raw tmv s = valOf (scanString (parse tmv) s) -fun write_raw map t = let - fun doit acc actlist = - case actlist of - [] => String.concat (List.rev acc) - | Brk :: rest => doit (" "::acc) rest - | Stg s :: rest => doit (s::acc) rest - | Tm (t,g) :: rest => let - in - if is_var t orelse is_const t then - doit (Int.toString (map t)::acc) rest - else if is_comb t then let - val (Rator,Rand) = dest_comb t - in - if g = CombR then - doit acc - (Stg "(" :: Tm(Rator,CombL) :: Brk :: Tm(Rand,CombR) :: - Stg ")" :: rest) - else - doit acc (Tm(Rator,CombL) :: Brk :: Tm(Rand,CombR) :: rest) - end - else let - val (bv, body) = dest_abs t - val core = [Stg "|", Tm(bv, Top), Brk, Tm(body, Top)] - in - if g <> Top then - doit acc ((Stg "(" :: core) @ (Stg ")" :: rest)) - else - doit acc (core @ rest) - end - end -in - doit [] [Tm(t,Top)] -end end (* local *) From 37d61e338c0098f3771af3362c1b3935207cbf00 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Sat, 7 Feb 2015 13:39:58 +1100 Subject: [PATCH 157/718] Implement (efficient) holdep lexing by hand. Without using references (except in the side-effecting stream reading, I suppose). In any case, performance in Poly/ML is much better (~4s on my old Mac for holdeptool on the 30MB CakeML theory.sml file). Includes some test-cases. --- tools-poly/Holmake/poly-Holmake.ML | 5 +- tools-poly/configure.sml | 2 - tools-poly/poly-build.ML | 5 +- tools/Holmake/Holdep.sml | 10 +- tools/Holmake/Holdep_tokens.lex | 135 ------- tools/Holmake/Holdep_tokens.sig | 8 + tools/Holmake/Holdep_tokens.sml | 443 +++++++++++++++++++++ tools/Holmake/holdeptool.sml | 33 +- tools/Holmake/poly-holdeptool.ML | 9 +- tools/Holmake/tests/holdep/.gitignore | 1 + tools/Holmake/tests/holdep/Holmakefile | 8 + tools/Holmake/tests/holdep/expected_output | 22 + tools/Holmake/tests/holdep/input | 25 ++ tools/configure.sml | 16 +- tools/sequences/kernel | 1 + 15 files changed, 528 insertions(+), 195 deletions(-) delete mode 100644 tools/Holmake/Holdep_tokens.lex create mode 100644 tools/Holmake/Holdep_tokens.sig create mode 100644 tools/Holmake/Holdep_tokens.sml create mode 100644 tools/Holmake/tests/holdep/.gitignore create mode 100644 tools/Holmake/tests/holdep/Holmakefile create mode 100644 tools/Holmake/tests/holdep/expected_output create mode 100644 tools/Holmake/tests/holdep/input diff --git a/tools-poly/Holmake/poly-Holmake.ML b/tools-poly/Holmake/poly-Holmake.ML index 3c9e5f7adb..8273cea522 100644 --- a/tools-poly/Holmake/poly-Holmake.ML +++ b/tools-poly/Holmake/poly-Holmake.ML @@ -17,10 +17,7 @@ fun useC f = val _ = use "../tools/Holmake/Systeml.sig" val _ = use "Holmake/Systeml.sml"; -val _ = useC "SourcePos"; -val _ = useC "SourceFile"; -val _ = useC "Region" -val _ = use "../tools/Holmake/Holdep_tokens.lex.sml"; +val _ = useC "Holdep_tokens"; val _ = useC "Holdep"; val _ = useC "regexpMatch"; diff --git a/tools-poly/configure.sml b/tools-poly/configure.sml index 62ae07aed5..41ef707a6f 100644 --- a/tools-poly/configure.sml +++ b/tools-poly/configure.sml @@ -405,8 +405,6 @@ val _ = ---------------------------------------------------------------------------*) val _ = (echo "Making bin/Holmake"; - FileSys.chDir hmakedir; - systeml [lexer, fullPath [HOLDIR, "tools", "Holmake", "Holdep_tokens.lex"]]; FileSys.chDir toolsdir; system_ps (POLY ^ " < " ^ fullPath ["Holmake", "poly-Holmake.ML"]); compile systeml hmakebin (fullPath ["Holmake", "Holmake.o"]); diff --git a/tools-poly/poly-build.ML b/tools-poly/poly-build.ML index aa1033e085..45a8f1acb4 100644 --- a/tools-poly/poly-build.ML +++ b/tools-poly/poly-build.ML @@ -9,10 +9,7 @@ fun useC f = use ("../tools/Holmake/" ^ f ^ ".sml")) val _ = use "Holmake/Systeml.sml"; -val _ = useC "SourcePos"; -val _ = useC "SourceFile"; -val _ = useC "Region" -val _ = use "../tools/Holmake/Holdep_tokens.lex.sml"; +val _ = useC "Holdep_tokens"; val _ = useC "Holdep"; val _ = useC "Holmake_tools" val _ = useC "regexpMatch" diff --git a/tools/Holmake/Holdep.sml b/tools/Holmake/Holdep.sml index 753f6eeb49..1816124ebb 100644 --- a/tools/Holmake/Holdep.sml +++ b/tools/Holmake/Holdep.sml @@ -122,16 +122,8 @@ fun encode_for_HOLMKfile {tgt, deps} = fun scanFile {fname,actualfname} = let open Holdep_tokens val is = TextIO.openIn actualfname - val arg = UserDeclarations.new_state fname - val lexer = makeLexer (fn n => TextIO.inputN(is,n)) arg - handle UserDeclarations.LEX_ERROR s => - raise Holdep_Error ("Lexical error: "^s) - fun recurse acc = - case lexer() of - NONE => (TextIO.closeIn is; acc) - | SOME s => recurse (Binaryset.add(acc, s)) in - recurse (Binaryset.empty String.compare) + stream_deps (fname, is) before TextIO.closeIn is end fun read {assumes, includes, srcext, objext, filename} = let diff --git a/tools/Holmake/Holdep_tokens.lex b/tools/Holmake/Holdep_tokens.lex deleted file mode 100644 index ef1d162f5e..0000000000 --- a/tools/Holmake/Holdep_tokens.lex +++ /dev/null @@ -1,135 +0,0 @@ -(* though strictly an mllex file, -*- sml -*- mode works OK *) -datatype retstate = SOPEN | SINITIAL | SINCLUDE; -type lexstate = { - commentdepth : int ref, - commentstart : SourcePos.t ref, - in_string : bool ref, - stringstart : SourcePos.t ref, - return : retstate ref, - source : SourceFile.t -} -fun new_state fname = {commentdepth = ref 0, - commentstart = ref SourcePos.bogus, - stringstart = ref SourcePos.bogus, - in_string = ref false, - return = ref SINITIAL, - source = SourceFile.new fname} - -type lexresult = string option -exception LEX_ERROR of string -fun regionError (r, s) = Region.toString r ^ ": " ^ s -fun lexErrorP(source, yypos, s) = - let - val p = SourceFile.getPos(source, yypos) - val r = Region.make {left = p, right = p} - in - raise LEX_ERROR(regionError(r, s)) - end -fun lexErrorR(region, s) = raise LEX_ERROR(regionError(region,s)) - -fun eof ({commentdepth,source,commentstart,in_string,stringstart,...} : lexstate) = - let - fun mkr st = Region.make{left = st, right = SourceFile.lineStart source} - in - if !commentdepth <> 0 then - lexErrorR(mkr (!commentstart), "Unclosed comment") - else if !in_string then - lexErrorR(mkr (!stringstart), "Unterminated string") - else NONE - end - -fun getQual s = - let - fun parse n = - if n >= size s then s - else if String.sub(s, n) = #"." then - String.extract(s, 0, SOME n) - else - parse (n+1) - in - parse 0 - end; - -%% -id = [A-Za-z][A-Za-z0-9_']* | [-!%&$#+/:<=>?@~^|*`\\]+; -ws = [\ \013\t]; -newline = "\n" | "\013\n"; -openterminator = "val" | "fun" | "in" | "infix"[lr]? | "local" | "type" | "datatype" | "nonfix" | "exception" | "end" | "structure" | "signature" | "prim_val" | ";" ; -%s OPEN STRING COMMENT INCLUDE STRINGCONT; -%arg ({source, commentdepth, commentstart, in_string, stringstart, return, ...}:UserDeclarations.lexstate); -%structure Holdep_tokens -%% -{ws} => (continue()); -{newline} => - (SourceFile.newline(source,yypos+size yytext); continue()); -"(*" => ( - YYBEGIN COMMENT; - commentstart := SourceFile.getPos(source, yypos); - commentdepth := 1; - return := SINITIAL; - continue()); -"*)" => ( - lexErrorP(source, yypos, "Unmatched comment bracket") -); -'[A-Za-z0-9_']+ => (continue()); -~?[0-9]+(\.[0-9]+)?(E~?[0-9]+)? => (continue()); -\" | #\" => ( - YYBEGIN STRING; - stringstart := SourceFile.getPos(source, yypos); - in_string := true; - continue()); -[_,{}[();] | ] | "..." => (continue()); -({id}\.)+{id} => (SOME (getQual yytext)); -"open" => (YYBEGIN OPEN; continue()); -"include" => (YYBEGIN INCLUDE; continue()); -{id} => (continue()); -. => ( - lexErrorP(source, yypos, "Unexpected character >" ^ yytext ^ "< in INITIAL") -); - -"(*" => (commentdepth := !commentdepth + 1; continue()); -"*)" => (commentdepth := !commentdepth - 1; - YYBEGIN (if !commentdepth = 0 then - if !return = SINITIAL then INITIAL - else OPEN - else COMMENT); - continue()); -. => (continue()); - -{openterminator} => (YYBEGIN INITIAL; continue()); -"open" => (continue()); -({id}\.)*{id} => (SOME (getQual yytext)); -"(*" => ( - YYBEGIN COMMENT; - commentstart := SourceFile.getPos(source,yypos); - commentdepth := 1; - return := SOPEN; - continue()); -. => ( - lexErrorP(source, yypos, "Unexpected character >" ^ yytext ^ "< in OPEN") -); - -"\\\"" => (continue()); -"\\" {newline} => (SourceFile.newline(source,yypos+size yytext); - YYBEGIN STRINGCONT; - continue()); -"\\" {ws} => (YYBEGIN STRINGCONT; continue()); -"\\" . => (continue()); -\" => (YYBEGIN INITIAL; in_string := false; continue()); -. => (continue()); -{newline} => (lexErrorP(source, yypos, "String terminated by newline")); - -{ws} => (continue()); -{newline} => (SourceFile.newline(source,yypos+size yytext); continue()); -"\\" => (YYBEGIN STRING; continue()); - . => (lexErrorP(source, yypos, "Invalid character in \\ ... \\")); - -{id} => (YYBEGIN INITIAL; SOME yytext); -"(*" => ( - YYBEGIN COMMENT; - commentstart := SourceFile.getPos(source,yypos); - commentdepth := 1; - return := SINCLUDE; - continue()); -. => ( - lexErrorP(source, yypos, "Invalid character >" ^ yytext ^ "< after include")); diff --git a/tools/Holmake/Holdep_tokens.sig b/tools/Holmake/Holdep_tokens.sig new file mode 100644 index 0000000000..273f99f53e --- /dev/null +++ b/tools/Holmake/Holdep_tokens.sig @@ -0,0 +1,8 @@ +signature Holdep_tokens = +sig + + exception LEX_ERROR of string + val file_deps : string -> string Binaryset.set + val stream_deps : string * TextIO.instream -> string Binaryset.set + +end diff --git a/tools/Holmake/Holdep_tokens.sml b/tools/Holmake/Holdep_tokens.sml new file mode 100644 index 0000000000..940af1f275 --- /dev/null +++ b/tools/Holmake/Holdep_tokens.sml @@ -0,0 +1,443 @@ +structure Holdep_tokens :> Holdep_tokens = +struct + +infix |> +fun x |> f = f x + +exception LEX_ERROR of string + +datatype char_reader = CR of {reader : unit -> string, + current : char option, + maxpos : int, + buffer : string, + closer : unit -> unit, + pos : int} +(* invariants: + * buffer = "" ⇒ current = NONE ∧ maxpos = 0 ∧ pos = 0 + * 0 ≤ pos ≤ maxpos +*) + +fun current (CR {current = c, ...}) = c +fun make inp close = let + val newbuf = inp() +in + if newbuf = "" then CR {pos = 0, maxpos = 0, buffer = newbuf, + reader = inp, current = NONE, + closer = close} + else CR {pos = 0, maxpos = size newbuf - 1, buffer = newbuf, + reader = inp, current = SOME(String.sub(newbuf, 0)), + closer = close} +end +fun fromFile f = let + val is = TextIO.openIn f +in + make (fn () => TextIO.input is) (fn () => TextIO.closeIn is) +end +fun fromStream is = make (fn () => TextIO.input is) (fn () => ()) +fun closeCR (CR {closer,...}) = closer() + +fun advance (c as CR {pos, buffer, maxpos, reader, current, closer}) = + if pos < maxpos then + CR { pos = pos + 1, buffer = buffer, reader = reader, + current = SOME(String.sub(buffer, pos + 1)), + maxpos = maxpos, closer = closer } + else if buffer = "" then c + else make reader closer + +datatype SCR = SCR of {linenum : int, + filename : string, + colnum : int, + currentID : string list option, + ids : string Binaryset.set, + cr : char_reader} +fun makeSCR fname = let + val cr = fromFile fname +in + SCR {linenum = 1, colnum = 0, filename = fname, + currentID = NONE, ids = Binaryset.empty String.compare, + cr = cr} +end + +fun SCRfromStream (name, is) = let + val cr = fromStream is +in + SCR {linenum = 1, colnum = 0, filename = name, + currentID = NONE, ids = Binaryset.empty String.compare, + cr = cr} +end + +fun currentChar (SCR{cr,...}) = current cr +fun closeSCR (SCR{cr,...}) = closeCR cr +fun getIDs (SCR{ids,...}) = ids +fun inc (SCR {linenum, filename, colnum, currentID, ids, cr}) = + SCR{linenum = linenum, filename = filename, colnum = colnum + 1, + currentID = currentID, ids = ids, cr = advance cr} +fun newline (SCR{linenum, filename, colnum, currentID, ids, cr}) = + SCR{linenum = linenum + 1, filename = filename, colnum = 0, + currentID = NONE, ids = ids, cr = advance cr} +fun newID s (SCR{linenum, filename, colnum, currentID, ids, cr}) = + SCR{linenum = linenum, filename = filename, colnum = colnum, + currentID = SOME [s], ids = ids, cr = cr} +fun extendID c (SCR{linenum, filename, colnum, currentID, ids, cr}) = + case currentID of + SOME strs => + SCR{linenum = linenum, filename = filename, colnum = colnum, + currentID = SOME (str c :: strs), ids = ids, cr = cr} + | NONE => + raise Fail "Invariant failure: extendID with no ID current" +fun completeID s (SCR{linenum, filename, colnum, currentID, ids, cr}) = + SCR{linenum = linenum, filename = filename, colnum = colnum, + currentID = NONE, ids = Binaryset.add(ids, s), cr = cr} +fun finishID (SCR{linenum, filename, colnum, currentID, ids, cr}) = + case currentID of + NONE => raise Fail "Invariant failure: finishID with no ID current" + | SOME strs => + let + val s = String.concat (List.rev strs) + in + SCR{linenum = linenum, filename = filename, colnum = colnum, + currentID = NONE, ids = Binaryset.add(ids, s), cr = cr} + end + +fun mem x [] = false + | mem x (y::ys) = x = y orelse mem x ys +val SMLsyms = String.explode "!%&$+/:<=>?@~|#*\\-~^" +val symbools = List.tabulate(256, fn i => mem (Char.chr i) SMLsyms) +val symb_vec = Vector.fromList symbools +fun isSMLSym c = Vector.sub(symb_vec, Char.ord c) + +fun isSMLAlphaCont c = + Char.isAlphaNum c orelse c = #"_" orelse c = #"'" + +fun Error(SCR {filename,colnum,linenum,...}, msg) = + raise LEX_ERROR (filename^" "^Int.toString linenum ^ "." ^ + Int.toString colnum ^ " " ^ msg) + + + +fun clean_open scr = + case currentChar scr of + NONE => scr + | SOME #"d" => openTerminatorPFX "datatype" 1 (inc scr) (* datatype *) + | SOME #"e" => opene (inc scr) (* exception, end *) + | SOME #"f" => openTerminatorPFX "fun" 1 (inc scr) + | SOME #"i" => openi (inc scr) (* in, infixl, infix, infixr *) + | SOME #"l" => openTerminatorPFX "local" 1 (inc scr) + | SOME #"n" => openTerminatorPFX "nonfix" 1 (inc scr) + | SOME #"o" => openAlphaKWordPFX "open" 1 clean_open (inc scr) + | SOME #"p" => openTerminatorPFX "prim_val" 1 (inc scr) + | SOME #"s" => opens (inc scr) (* structure, signature *) + | SOME #"t" => openTerminatorPFX "type" 1 (inc scr) + | SOME #"v" => openTerminatorPFX "val" 1 (inc scr) + | SOME #";" => clean_initial (inc scr) + | SOME #"(" => openLPAREN (inc scr) + | SOME #"#" => openHASH (inc scr) + | SOME #"\n" => clean_open (newline scr) + | SOME c => if Char.isSpace c then clean_open (inc scr) + else if Char.isAlpha c then + openAlphaID (scr |> inc |> newID (str c)) + else if isSMLSym c then + openSymID (scr |> inc |> newID (str c)) + else Error(scr, "Bad character >"^str c^"< after open") +and openTerminatorPFX kword cnt scr = + openAlphaKWordPFX kword cnt clean_initial scr +and openOnTerminator kword scr = + openOnKWord kword clean_initial scr +and opene scr = + case currentChar scr of + NONE => scr |> completeID "e" + | SOME #"n" => openTerminatorPFX "end" 2 (inc scr) + | SOME #"x" => openTerminatorPFX "exception" 2 (inc scr) + | SOME c => extend_openAlpha "e" c scr +and openi scr = + case currentChar scr of + NONE => scr |> completeID "i" + | SOME #"n" => openin (inc scr) + | SOME c => extend_openAlpha "i" c scr +and openin scr = + case currentChar scr of + NONE => Error(scr, "Don't expect to see 'in'-EOF") + | SOME #"f" => scr |> inc |> openinf + | SOME c => openOnTerminator "in" scr +and openinf scr = + case currentChar scr of + NONE => scr |> completeID "inf" + | SOME #"i" => scr |> inc |> openinfi + | SOME c => extend_openAlpha "inf" c scr +and openinfi scr = + case currentChar scr of + NONE => scr |> completeID "infi" + | SOME #"x" => scr |> inc |> openinfix + | SOME c => extend_openAlpha "infi" c scr +and openinfix scr = + case currentChar scr of + NONE => Error(scr, "Don't expect to see 'infix'-EOF") + | SOME #"l" => openOnTerminator "infixl" (inc scr) + | SOME #"r" => openOnTerminator "infixr" (inc scr) + | SOME c => openOnTerminator "infix" scr +and opens scr = + case currentChar scr of + NONE => scr |> completeID "s" + | SOME #"i" => openTerminatorPFX "signature" 2 (inc scr) + | SOME #"t" => openTerminatorPFX "structure" 2 (inc scr) + | SOME c => extend_openAlpha "s" c scr +and openLPAREN scr = + case currentChar scr of + NONE => Error(scr, "Don't expect to see '('-EOF") + | SOME #"*" => COMMENT clean_open (inc scr) + | SOME c => Error(scr, "Don't expect to see '("^str c^"' after 'open'") +and openHASH scr = + case currentChar scr of + NONE => Error(scr, "Don't expect to see 'open'-'#'") + | SOME c => if isSMLSym c then + openSymID (scr |> inc |> newID ("#" ^ str c)) + else Error(scr, "Don't expect to see 'open'-'#'") +and openAlphaID scr = + case currentChar scr of + NONE => scr |> finishID + | SOME #"." => openQID0 (scr |> inc |> finishID) + | SOME c => if isSMLAlphaCont c then + openAlphaID (scr |> inc |> extendID c) + else + clean_open (scr |> finishID) +and openSymID scr = + case currentChar scr of + NONE => scr |> finishID + | SOME #"." => openQID0 (scr |> inc |> finishID) + | SOME c => if isSMLSym c then openSymID (scr |> inc |> extendID c) + else clean_open (scr |> finishID) +and openQID0 scr = (* seen the dot *) + case currentChar scr of + NONE => Error(scr, "'.'-EOF unexpected") + | SOME c => if Char.isAlpha c then openQIDalpha (inc scr) + else if isSMLSym c then openQIDsym (inc scr) + else Error(scr, "'."^str c^" unexpected") +and openQIDalpha scr = + case currentChar scr of + NONE => scr + | SOME #"." => openQID0 (inc scr) + | SOME c => if isSMLAlphaCont c then openQIDalpha (inc scr) + else clean_open scr +and openQIDsym scr = + case currentChar scr of + NONE => scr + | SOME #"." => openQID0 (inc scr) + | SOME c => if isSMLSym c then openQIDsym (inc scr) + else clean_open scr +and openAlphaKWordPFX kword numseen k scr = let + fun get() = String.extract(kword, 0, SOME numseen) +in + case currentChar scr of + NONE => scr |> completeID (get()) + | SOME c => if c = String.sub(kword, numseen) then + if numseen + 1 = size kword then + openOnKWord kword k (inc scr) + else openAlphaKWordPFX kword (numseen + 1) k (inc scr) + else if isSMLAlphaCont c then + extend_openAlpha (get()) c scr + else clean_open (scr |> completeID (get())) +end +and openOnKWord kword k scr = + case currentChar scr of + NONE => k scr + | SOME c => if isSMLAlphaCont c then + extend_openAlpha kword c scr + else k scr +and extend_openAlpha pfx c scr = + if Char.isSpace c then clean_open (scr |> inc |> completeID pfx) + else if isSMLAlphaCont c then + openAlphaID (scr |> inc |> newID (pfx ^ str c)) + else if isSMLSym c then + openSymID (scr |> inc |> completeID pfx |> newID (str c)) + else Error(scr, "Bad character >"^str c^"< after 'open'") +and extend_openKeyword kword c scr = + if Char.isSpace c then Error(scr, "Don't expect to see '"^kword^"' after 'open'") + else if Char.isAlpha c then + openAlphaID (scr |> inc |> newID (kword ^ str c)) + else if isSMLSym c then + Error(scr, "Don't expect to see '"^kword^"' after 'open'") + else Error(scr, "Bad character >"^str c^"< after 'open'") +and extend_openTerminator kword c scr = + if c = #"\n" then clean_initial (scr |> newline) + else if Char.isSpace c then clean_initial (scr |> inc) + else if Char.isAlpha c then + openAlphaID (scr |> inc |> newID (kword ^ str c)) + else clean_initial (scr |> inc) +and includeALPHA cs scr = + case currentChar scr of + NONE => scr |> completeID (implode (List.rev cs)) + | SOME c => if isSMLAlphaCont c then includeALPHA (c::cs) (inc scr) + else clean_initial (scr |> completeID (implode (List.rev cs))) +and includeSYM cs scr = + case currentChar scr of + NONE => scr |> completeID (implode (List.rev cs)) + | SOME c => if isSMLSym c then includeSYM (c::cs) (inc scr) + else clean_initial (scr |> completeID (implode (List.rev cs))) +and includeLPAR scr = + case currentChar scr of + NONE => Error(scr, "Don't expect 'include'-'('-EOF") + | SOME #"*" => COMMENT clean_include (inc scr) + | SOME c => Error(scr, "Don't expect 'include'-'('-'"^str c^"'") +and clean_include scr = + case currentChar scr of + NONE => Error(scr, "Don't expect to see 'include'-EOF") + | SOME #"\n" => clean_include (newline scr) + | SOME #"(" => includeLPAR (inc scr) + | SOME c => if Char.isSpace c then clean_include (inc scr) + else if Char.isAlpha c then includeALPHA [c] (inc scr) + else if isSMLSym c then includeSYM [c] (inc scr) + else Error(scr, "Bad character >"^str c^"< after 'include'") +and clean_initial scr = + case currentChar scr of + NONE => scr + | SOME #"i" => initialAlphaKWordPFX "include" 1 clean_include (inc scr) + | SOME #"o" => initialAlphaKWordPFX "open" 1 clean_open (inc scr) + | SOME #"\n" => clean_initial (newline scr) + | SOME #"(" => initialLPAREN (inc scr) + | SOME #"\"" => STRING (inc scr) + | SOME c => + if Char.isSpace c then clean_initial (inc scr) + else if Char.isAlpha c then initialAlphaID("", [c]) (inc scr) + else if isSMLSym c then initialSymID("", [c]) (inc scr) + else clean_initial (inc scr) +and initialAlphaID (pfx, cs) scr = + case currentChar scr of + NONE => scr + | SOME #"." => + initialQID0 (scr |> inc + |> completeID (pfx ^ String.implode (List.rev cs))) + | SOME #"\n" => clean_initial (newline scr) + | SOME c => if isSMLAlphaCont c then initialAlphaID (pfx, c::cs) (inc scr) + else clean_initial scr +and initialSymID (pfx, cs) scr = + case currentChar scr of + NONE => scr + | SOME #"." => initialQID0 (scr |> inc |> completeID (pfx ^ String.implode (List.rev cs))) + | SOME #"\n" => clean_initial (newline scr) + | SOME c => if isSMLSym c then initialSymID (pfx, c::cs) (inc scr) + else clean_initial scr +and initialLPAREN scr = + case currentChar scr of + NONE => Error(scr, "'('-EOF unexpected") + | SOME #"*" => COMMENT clean_initial (inc scr) + | SOME #"(" => initialLPAREN (inc scr) + | _ => clean_initial scr +and COMMENT k scr = + case currentChar scr of + NONE => Error(scr, "Unterminated comment") + | SOME #"(" => COMMENTlpar k (inc scr) + | SOME #"*" => COMMENTast k (inc scr) + | SOME #"\n" => COMMENT k (newline scr) + | _ => COMMENT k (inc scr) +and COMMENTlpar k scr = + case currentChar scr of + NONE => Error(scr, "Unterminated comment") + | SOME #"(" => COMMENTlpar k (inc scr) + | SOME #"*" => COMMENT (COMMENT k) (inc scr) + | SOME #"\n" => COMMENT k (newline scr) + | _ => COMMENT k (inc scr) +and COMMENTast k scr = + case currentChar scr of + NONE => Error(scr, "Unterminated comment") + | SOME #"*" => COMMENTast k (inc scr) + | SOME #")" => k (inc scr) + | SOME #"\n" => COMMENT k (newline scr) + | _ => COMMENT k (inc scr) +and initialQID0 scr = (* have just seen '.' *) + case currentChar scr of + NONE => Error(scr, "'.'-EOF unexpected") + | SOME c => if Char.isSpace c then Error(scr, "'.'-whitespace unexpected") + else if Char.isAlpha c then + initialAlphaQID (inc scr) + else if isSMLSym c then + initialSymQID (inc scr) + else Error(scr, "Bad character >"^str c^"< after qualifying '.'") +and initialAlphaQID scr = (* have seen some characters of ID *) + case currentChar scr of + NONE => scr + | SOME #"." => initialQID0 (inc scr) + | SOME c => if isSMLAlphaCont c then initialAlphaQID (inc scr) + else clean_initial scr +and initialSymQID scr = (* have seen some characters of ID *) + case currentChar scr of + NONE => scr + | SOME #"." => initialQID0 (inc scr) + | SOME c => if isSMLSym c then initialSymQID (inc scr) + else clean_initial scr +and STRING scr = (* have seen the quote *) + case currentChar scr of + NONE => Error(scr, "Unterminated string literal") + | SOME #"\"" => clean_initial (inc scr) + | SOME #"\\" => STRINGslash (inc scr) + | SOME #"\n" => Error(scr, "Unescaped newline in string literal") + | _ => STRING (inc scr) +and STRINGcaret scr = + case currentChar scr of + NONE => Error(scr, "Unterminated string literal") + | SOME c => let val i = Char.ord c + in + if i < 64 orelse i >= 96 then + Error(scr, "Illegal caret-escape in string literal") + else STRING (inc scr) + end +and STRINGslash scr = + case currentChar scr of + NONE => Error(scr, "Unterminated string literal") + | SOME #"\n" => STRINGelidews (newline scr) + | SOME #"\\" => STRING (inc scr) + | SOME #"\"" => STRING (inc scr) + | SOME #"^" => STRINGcaret (inc scr) + | SOME #"a" => STRING (inc scr) + | SOME #"b" => STRING (inc scr) + | SOME #"f" => STRING (inc scr) + | SOME #"n" => STRING (inc scr) + | SOME #"r" => STRING (inc scr) + | SOME #"t" => STRING (inc scr) + | SOME #"v" => STRING (inc scr) + | SOME c => if Char.isDigit c then + STRINGslashdigit 1 (inc scr) + else Error(scr, "Illegal backslash escape >" ^ str c ^ + "< in string literal") +and STRINGelidews scr = + case currentChar scr of + NONE => Error(scr, "Unterminated string literal") + | SOME #"\\" => STRING (inc scr) + | SOME #"\n" => STRINGelidews (newline scr) + | SOME c => if Char.isSpace c then STRINGelidews (inc scr) + else Error(scr, "Illegal char >" ^ str c ^ + "< in string \\...\\ elision") +and STRINGslashdigit cnt scr = + case currentChar scr of + NONE => Error(scr, "Unterminated string literal") + | SOME c => if Char.isDigit c then + if cnt = 2 then STRING (inc scr) + else STRINGslashdigit (cnt + 1) (inc scr) + else Error(scr, "Illegal backslash escape in string literal") +and initialAlphaKWordPFX kword numseen k scr = + case currentChar scr of + NONE => scr + | SOME c => + if c = String.sub(kword, numseen) then + if numseen + 1 = size kword then + initialAlphaKWord kword k (inc scr) + else + initialAlphaKWordPFX kword (numseen + 1) k (inc scr) + else if isSMLAlphaCont c then + initialAlphaID (String.extract(kword, 0, SOME numseen), [c]) + (inc scr) + else clean_initial scr +and initialAlphaKWord kword k scr = + case currentChar scr of + NONE => k scr + | SOME c => if isSMLAlphaCont c then + initialAlphaID (kword, [c]) (inc scr) + else k scr + +fun scrdeps scr = + getIDs (clean_initial scr) before + closeSCR scr + +fun file_deps fname = scrdeps (makeSCR fname) +fun stream_deps p = scrdeps (SCRfromStream p) + +end (* struct *) diff --git a/tools/Holmake/holdeptool.sml b/tools/Holmake/holdeptool.sml index c36c165954..e22a57b246 100644 --- a/tools/Holmake/holdeptool.sml +++ b/tools/Holmake/holdeptool.sml @@ -3,11 +3,11 @@ struct fun die () = OS.Process.exit OS.Process.failure fun ok () = OS.Process.exit OS.Process.success +fun warn s = TextIO.output(TextIO.stdErr, s ^ "\n") fun usage k = - (TextIO.output(TextIO.stdErr, - "Usage:\n " ^ CommandLine.name() ^ " [-h | -n [file]]"); + (warn ("Usage:\n " ^ CommandLine.name() ^ " [-h | [file]]"); k()) -fun diewith s = (TextIO.output(TextIO.stdErr, s ^ "\n"); die()) +fun diewith s = (warn s; die()) fun main() = let open Holdep_tokens @@ -17,30 +17,17 @@ fun main() = let in (strm, f, (fn () => TextIO.closeIn strm)) end - val unsorted = ref false - val (strm, fname, closer) = + val results = case CommandLine.arguments() of - [] => stdin - | ["-n"] => (unsorted := true; stdin) + [] => stream_deps ("", TextIO.stdIn) | ["-h"] => usage ok - | [fname] => file fname - | ["-n", fname] => (unsorted := true; file fname) + | [fname] => (file_deps fname + handle LEX_ERROR s => diewith("Lexical error: " ^ s) + | e => diewith ("Exception: "^General.exnMessage e)) | _ => usage die - val arg = UserDeclarations.new_state fname - val lexer = makeLexer (fn n => TextIO.inputN(strm, n)) arg - fun safelex () = - lexer() handle UserDeclarations.LEX_ERROR s => diewith ("Lexical error: "^ s) - fun unsortedf () = - case safelex() of - NONE => closer() - | SOME s => (TextIO.print (s ^ "\n"); unsortedf()) - fun sorted acc = - case safelex() of - NONE => (closer(); - Binaryset.app (fn s => print (s ^ "\n")) acc) - | SOME s => sorted (Binaryset.add(acc, s)) + in - if !unsorted then unsortedf() else sorted (Binaryset.empty String.compare) + Binaryset.app (fn s => print (s ^ "\n")) results end end (* struct *) diff --git a/tools/Holmake/poly-holdeptool.ML b/tools/Holmake/poly-holdeptool.ML index 21041d4989..735ab523e4 100644 --- a/tools/Holmake/poly-holdeptool.ML +++ b/tools/Holmake/poly-holdeptool.ML @@ -3,13 +3,8 @@ val _ = PolyML.Compiler.prompt2:=""; val _ = PolyML.print_depth 0; use "../../tools-poly/poly/Binaryset.sig"; use "../../tools-poly/poly/Binaryset.sml"; -use "SourcePos.sig"; -use "SourcePos.sml"; -use "SourceFile.sig"; -use "SourceFile.sml"; -use "Region.sig"; -use "Region.sml"; -use "Holdep_tokens.lex.sml"; +use "Holdep_tokens.sig"; +use "Holdep_tokens.sml"; use "holdeptool.sml"; val _ = PolyML.shareCommonData holdeptool.main diff --git a/tools/Holmake/tests/holdep/.gitignore b/tools/Holmake/tests/holdep/.gitignore new file mode 100644 index 0000000000..53752db253 --- /dev/null +++ b/tools/Holmake/tests/holdep/.gitignore @@ -0,0 +1 @@ +output diff --git a/tools/Holmake/tests/holdep/Holmakefile b/tools/Holmake/tests/holdep/Holmakefile new file mode 100644 index 0000000000..7fe98a3557 --- /dev/null +++ b/tools/Holmake/tests/holdep/Holmakefile @@ -0,0 +1,8 @@ +INCLUDES = ../../../cmp + +.PHONY: test +test: + $(protect $(HOLDIR)/bin/holdeptool.exe) input > output + $(protect $(HOLDIR)/tools/cmp/cmp.exe) output expected_output + +EXTRA_CLEANS = output diff --git a/tools/Holmake/tests/holdep/expected_output b/tools/Holmake/tests/holdep/expected_output new file mode 100644 index 0000000000..de7334eb7e --- /dev/null +++ b/tools/Holmake/tests/holdep/expected_output @@ -0,0 +1,22 @@ +#$ +++ +OS +Opopen +bar +base_lexer +baz +data1 +data2 +foo +included_module' +inf +m31 +manic1 +manic2 +module +module' +module_2 +openfoo +qidcolon +qux +r2 diff --git a/tools/Holmake/tests/holdep/input b/tools/Holmake/tests/holdep/input new file mode 100644 index 0000000000..d603bc0ec8 --- /dev/null +++ b/tools/Holmake/tests/holdep/input @@ -0,0 +1,25 @@ +open foo bar (* yikes *) baz openfoo +open manic1 open manic2; +open data1 +open data2.fool +datatype datafoo + +fun f x = qux.yy.z + r2.x * f (2 * (* foo (* bar foolcomment.x *) ****) z) +fun g x = m31.z + x +fun h x = let + open module module_2 module' inf #$ +in + x "fooledyou1.bar open fooledyou2 in" * 3 +end + +"\226\138\140", "foo", "$\\\\", "\^[", #"\000" + +open OS.Process ++.fool1.barfool +val x = f y + +fun openFool1 x = x +fun opopen openFool2 x = x +fun f x = Opopen.x + qidcolon.::> + +include included_module' +type extrastate = base_lexer.UserDecs.extrastate diff --git a/tools/configure.sml b/tools/configure.sml index a4f7bd48fe..f62876a22d 100644 --- a/tools/configure.sml +++ b/tools/configure.sml @@ -354,20 +354,14 @@ val _ = systeml (pfx @ b2002comp @ extras @ [srcobj]) end in - systeml [mllex, "Holdep_tokens.lex"]; - compile [] "SourcePos.sig"; - compile [] "SourcePos.sml"; - compile [] "SourceFile.sig"; - compile [] "SourceFile.sml"; - compile [] "Region.sig"; - compile [] "Region.sml"; - compile ["-toplevel"] "Holdep_tokens.lex.sml"; - compile ["Holdep_tokens.lex.ui"] "holdeptool.sml"; + compile [] "Holdep_tokens.sig"; + compile [] "Holdep_tokens.sml"; + compile [] "holdeptool.sml"; compile [] "mosml_holdeptool.sml"; - link{extras = ["Holdep_tokens.lex.ui"], srcobj = "mosml_holdeptool.uo", + link{extras = [], srcobj = "mosml_holdeptool.uo", tgt = fullPath[holdir, "bin", "holdeptool.exe"]}; compile [] "Holdep.sig"; - compile ["Holdep_tokens.lex.ui"] "Holdep.sml"; + compile [] "Holdep.sml"; compile [] "regexpMatch.sig"; compile [] "regexpMatch.sml"; compile [] "parse_glob.sig"; diff --git a/tools/sequences/kernel b/tools/sequences/kernel index 56ec05ea54..d12ddc3c19 100644 --- a/tools/sequences/kernel +++ b/tools/sequences/kernel @@ -1,3 +1,4 @@ +!tools/Holmake/tests/holdep tools/mlyacc/mlyacclib [mosml]src/portableML/mosml [poly]src/portableML/poly From e08c29e6df6ce21d5b8ecce03f0bd85a48185e9d Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 9 Feb 2015 10:26:26 +1100 Subject: [PATCH 158/718] Document fix to issue #225 (constructor names for theorems) --- doc/next-release.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/doc/next-release.md b/doc/next-release.md index b21840a753..53348bdef7 100644 --- a/doc/next-release.md +++ b/doc/next-release.md @@ -25,6 +25,8 @@ Bugs fixed: - An embarrassing infinite loop bug in the integration of the integer decision procedures (the Omega test, Cooper’s algorithm) into the simplifier was fixed. +- Theorems can now have names that are the same as SML constructor names (*e.g.*, `Empty`). ([Github issue](http://github.com/HOL-Theorem-Prover/HOL/issues/225)) + New theories: ------------- From 4fd9753d9f9c9a715ab5ee10cf7f85da91fbc43f Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 9 Feb 2015 10:44:13 +1100 Subject: [PATCH 159/718] Fix a Markdown error in release notes. --- doc/next-release.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/next-release.md b/doc/next-release.md index 53348bdef7..47bb4237d7 100644 --- a/doc/next-release.md +++ b/doc/next-release.md @@ -51,7 +51,7 @@ Incompatibilities: ?- (f x = Pair c1 c2) ⇒ (f c1 = f c2) - where the `X` in the pattern was ignored. The interface now achieves the same end by simply allowing the user to write underscores in the pattern. Thus, the tactic would become `Q.MATCH_RENAME_TAC `(f x = Pair c1 c2) ⇒ _`. Multiple underscores can be used to ignore multiple sub-terms. + where the `X` in the pattern was ignored. The interface now achieves the same end by simply allowing the user to write underscores in the pattern. Thus, the tactic would become ``Q.MATCH_RENAME_TAC `(f x = Pair c1 c2) ⇒ _` ``. Multiple underscores can be used to ignore multiple sub-terms. Of course, the `qmatch_rename_tac` and `qmatch_assum_rename_tac` names for these tactics in `lcsymtacs` have changed types as well. The new `Q.MATCH_GOALSUB_RENAME_TAC` and `Q.MATCH_ASMSUB_RENAME_TAC` (and their lower-case versions) have similar types, without explicit lists of variable names to ignore. From b7d46bc61e7a0b94185dd709529f0741e5ab9273 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 9 Feb 2015 11:08:00 +1100 Subject: [PATCH 160/718] Delete extremely old and unused file from tools/Holmake. Last change to that file happened in 2001, and the file has hard file paths to a Cambridge file-system setup. --- tools/Holmake/fake_src.pl | 8 -------- 1 file changed, 8 deletions(-) delete mode 100644 tools/Holmake/fake_src.pl diff --git a/tools/Holmake/fake_src.pl b/tools/Holmake/fake_src.pl deleted file mode 100644 index 5aa38100b6..0000000000 --- a/tools/Holmake/fake_src.pl +++ /dev/null @@ -1,8 +0,0 @@ -while (<>) { - s|^val HOLDIR = .*$|val HOLDIR = "/local/scratch/mn200/Work/hol98/"|; - s|^val MOSMLDIR = .*$|val MOSMLDIR = "/local/scratch/kxs/200/"|; - s|^val DEPDIR = .*$|val DEPDIR = ".HOLMK"|; - s|^fun MK_XABLE file = .*$|fun MK_XABLE file = (Process.system ("chmod a+x "^file); file)|; - s|^val DEFAULT_OVERLAY = .*$|val DEFAULT_OVERLAY = SOME "Overlay.ui"|; - print; -} From 5d59df252fb20a1ea6c8a06104b02c35f070b264 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 9 Feb 2015 11:09:31 +1100 Subject: [PATCH 161/718] Add mlton .mlb file to allow building of holdeptool. Basis for interesting experiments. Curious state-of-play, as of this commit: - mlton is (~4.5x) faster running holdeptool - Poly/ML is (~4.5x) faster running unquote In both cases, on the 30MB CakeML file. --- tools/Holmake/holdeptool.exe.mlb | 7 +++++++ 1 file changed, 7 insertions(+) create mode 100644 tools/Holmake/holdeptool.exe.mlb diff --git a/tools/Holmake/holdeptool.exe.mlb b/tools/Holmake/holdeptool.exe.mlb new file mode 100644 index 0000000000..0e01676bd0 --- /dev/null +++ b/tools/Holmake/holdeptool.exe.mlb @@ -0,0 +1,7 @@ +$(SML_LIB)/basis/basis.mlb +../../tools-poly/poly/Binaryset.sig +../../tools-poly/poly/Binaryset.sml +Holdep_tokens.sig +Holdep_tokens.sml +holdeptool.sml +mosml_holdeptool.sml From ea6677b8689cff651498a844980397fd26bfccf9 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 10 Feb 2015 10:48:53 +1100 Subject: [PATCH 162/718] Improve documentation of "HOL style" for script and SML files. Response to comment made in github issue #232, which fairly pointed out that our documentation is not as comprehensive as it might be. Closes #232 --- Manual/Description/misc.tex | 149 ++++++++++++++++++++++-------------- 1 file changed, 90 insertions(+), 59 deletions(-) diff --git a/Manual/Description/misc.tex b/Manual/Description/misc.tex index 221eaabe4c..812abc2ac5 100644 --- a/Manual/Description/misc.tex +++ b/Manual/Description/misc.tex @@ -160,76 +160,107 @@ \subsection{Theory construction} the theory file is available for use. \end{enumerate} -\subsection{Making the script separately compilable} - -First, the invocation -\begin{verbatim} - val _ = export_theory(); -\end{verbatim} -should be added at the end of the file. When the script is finally -executed, this call writes the theory to disk. +\subsection{Source Conventions for Script and SML Files} +\paragraph{Script and Theory Files} +The file that generates the \HOL{} theory \textit{my}\texttt{Theory} must be called \textit{my}\texttt{Script.sml}. +After the theory has been successfully generated, it can be \texttt{open}-ed at the head of other developments: +\begin{alltt} + open myTheory +\end{alltt} \index{load (ML function)@\ml{load} (\ML{} function)} -Second, we address a crucial environmental issue: if a theory script -has been constructed using\verb+ /bin/hol+, then it has been -developed in an environment where some commonly used structures, \eg, -\verb+Tactic+, have already been loaded and opened for the user's -convenience. When we wish to apply \holmake{} to a script developed -in this way, we have to take some extra steps to ensure that the -compilation environment also provides these structures. In the common -case, this is simple; one must only add, at the head of the theory -script, the following ``boilerplate'': -\begin{verbatim} - open HolKernel Parse boolLib; -\end{verbatim} -This will duplicate the starting environment that one obtains with -\verb+hol.bare+ and \linebreak \verb+hol.bare.noquote+. If the script was -developed interactively with \texttt{hol} or \texttt{hol.noquote}, -then one must also add -\begin{verbatim} - open bossLib -\end{verbatim} -Now the script should be separately compilable. Invoke \holmake{} -to check; the \ML{} compiler will flag any unaccounted-for identifiers it finds. -The user has to resolve these, either by using the `dot' notation to -locate the identifier for the compiler, or by \verb+open+-ing the -relevant module. This ``compile/resolve-identifier'' loop should -continue until \holmake{} succeeds in compiling the module. +and it can be loaded interactively: +\begin{alltt} + load "myTheory"; +\end{alltt} +The file \texttt{myScript.sml} should begin with the standard boilerplate: +\begin{alltt} + open HolKernel Parse boolLib bossLib -The following notes may be of some further help. + val _ = new_theory "my" +\end{alltt} +This ``boilerplate'' ensures that the standard tactics and SML commands will be in the namespace when the script file is compiled. +Interactively, these modules have already been loaded and \texttt{open}-ed, so what can be typed directly at \texttt{hol} cannot necessarily be included as-is in a script file. +In addition, if \texttt{myTheory} depends on other \HOL{} theories, this ancestry should also be recorded in the script file. +The easiest way to achieve this is simply to \texttt{open} the relevant theories. +Conventionally, the \texttt{open} declarations for such theories appear just before the call to \texttt{new_theory}. +For example: +\begin{alltt} + open HolKernel Parse boolLib bossLib -\begin{enumerate} -\item The filenames of theory scripts must follow the following - convention: a HOL theory script for theory ``x'' should be named - \texttt{xScript.sml}. When \verb+export_theory+ is called during an - invocation of \holmake, the files \texttt{xTheory.sig} and - \texttt{xTheory.sml} will be generated and then compiled. - -\item In \ML{}, modules are not allowed to include unbound top-level expressions. - Hence, something like the following is not allowed: -\begin{verbatim} - new_theory "ted"; -\end{verbatim} -To make \ML{} happy, one must instead write something like -\begin{verbatim} - val _ = new_theory "ted"; -\end{verbatim} -\noindent -This is because (due to restrictions imposed by Moscow~ML\index{Moscow ML}) the script file is required to be an ML structure, and the contents of a structure must be \emph{declarations}, not expressions. -Indeed, one is allowed to (and often will) omit the bracketing \texttt{structure~foo~=~struct} - \texttt{end} lines, but the contents of the file are still interpreted as if belonging to a structure. + open myfirstAncestorTheory OtherAncestorTheory + val _ = new_theory "my" +\end{alltt} \index{load (ML function)@\ml{load} (\ML{} function)} -\item In the interactive system, one has to explicitly \ml{load} modules; on the other hand, the batch compiler will load modules automatically. +Interactively, these may well be the names of theories that have been explicitly loaded into the context with the \texttt{load} function. +In the interactive system, one has to explicitly \ml{load} modules; on the other hand, the batch compiler will load modules automatically. For example, in order to execute \ml{open Foo} (or refer to values in structure \ml{Foo}) in the interactive system, one must first have executed \ml{load "Foo"}. (This is on the assumption that structure \ml{Foo} is defined in a file \texttt{Foo.sml}.) Contrarily, the batch compiler will reject files having occurrences of \ml{load}, since \ml{load} is only defined for the interactive system. -\item Take care not to have the string ``Theory'' embedded in the name of any of your files. +In addition, simply referring to a theory's theorems using the `dot-notation' will make that theory an ancestor. +For example, +\begin{alltt} + val mytheorem = store_thm( + "mytheorem", + ``...``, + SIMP_TAC (srw_ss()) [ThirdAncestorTheory.important_lemma] ...); +\end{alltt} +will record a dependency on \texttt{ThirdAncestoryTheory}, making it just as much an ancestor as the theories that have been explicitly \texttt{open}-ed elsewhere. + +Finally, all script files should also end with the invocation: +\begin{verbatim} + val _ = export_theory(); +\end{verbatim} +When the script is finally executed, this call writes the theory to disk. + +The calls to \texttt{new_theory} and \texttt{export_theory} must bracket a sequence of SML declarations. +A declaration will typically be a \texttt{val}-binding, but might also be a function definition (\emph{via} \texttt{fun}), an \texttt{open}, or even a \texttt{structure} declaration. +Declarations are \emph{not} expressions. +This means that script files should \emph{not} include bare calls to \HOL{} functions like \texttt{Datatype}. +Instead, declarations such as the following need to be used: +\begin{alltt} + val _ = Datatype`tree = Lf | Nd num tree tree` +\end{alltt} +This is because (due to restrictions imposed by Moscow~ML\index{Moscow ML}) the script file is required to be an ML structure, and the contents of a structure must be \emph{declarations}, not expressions. +Indeed, one is allowed to (and generally should) omit the bracketing +\begin{alltt} + structure myScript = struct + ... + end +\end{alltt} +lines, but the contents of the file are still interpreted as if belonging to a structure. + +Finally, take care not to have the string ``\texttt{Theory}'' appear at the end of the name of any of your files. \HOL{} generates files containing this string, and when it cleans up after itself, it removes such files using a regular expression. -This will also remove other files with names containing ``Theory''. +This will also remove other files with names containing ``\texttt{Theory.sml}'' or ``\texttt{Theory.sig}''. For example, if, in your development directory, you had a file of \ML{} code named \texttt{MyTheory.sml} and you were also managing a \HOL{} development there with \holmake, then \texttt{MyTheory.sml} would get deleted if \texttt{Holmake~clean} were invoked. -\end{enumerate} +\paragraph{Other SML Code} +When developing \HOL{} libraries, one should again attempt to follow Moscow~ML's conventions. +Most importantly, file names should match \texttt{signature} and \texttt{structure} names. +If this can be done, the automatic dependency analysis done by \holmake{} will work ``out of the box''. +A signature for module \texttt{foo} should always appear in file \texttt{foo.sig}, and should have the form +\begin{alltt} + signature foo = + sig + ... + end +\end{alltt} +The accompanying implementation of \texttt{foo} should appear in file \texttt{foo.sml}, and should have the form +\begin{alltt} + structure foo :> foo = + struct + ... + end +\end{alltt} +As with theory files, the contents of a \texttt{structure} must be a sequence of declarations only. +Neither sort of file should have any other declarations within it (before or after the \texttt{signature} or \texttt{structure}). + +Deviations from this general pattern are possible, but life is much simpler if such deviations can be avoided. +The \HOL{} distribution\footnote{See, for example, the kernel implementation in \texttt{src/0}.} contains some examples of trickier situations where the guidelines need to be ignored. +Ignoring the guidelines will generally result in the need for quite involved \texttt{Holmakefile}s (see Section~\ref{sec:using-Holmakefiles} below). \subsection{Summary} @@ -261,7 +292,7 @@ \subsection{\holmake{}'s command-line arguments} Like {\tt make}, \holmake{} takes command-line arguments corresponding to the targets that the user desires to build. If there are no command-line targets, then \holmake{} will look for a \texttt{Holmakefile} in the current directory. If there is none, or if that file specifies no targets, then \holmake{} will attempt to build all \ML{} modules and \HOL{} theories it can detect in the current directory. -If there is a target in the \texttt{Holmakefile}, then \holmake{} will try to build that target (only). +If there is a target in the \texttt{Holmakefile}, then \holmake{} will try to build the first such target (only). In addition, there are three special targets that can be used: \begin{description} @@ -359,7 +390,7 @@ \subsection{\holmake{}'s command-line arguments} \texttt{cleanDeps} option above) before proceeding with the build. \end{description} -\noindent \holmake{} should never exit with the Moscow~ML message ``Uncaught +\noindent \holmake{} should never exit with error messages such as ``Uncaught exception''. Such behaviour is a bug, please report it! From d1061c17c25ec4dfe19899ec95280bde351242b7 Mon Sep 17 00:00:00 2001 From: Piotr Trojanek Date: Thu, 15 Jan 2015 23:42:03 +0000 Subject: [PATCH 163/718] help: GEN_REWRITE_* functions take 'rewrites' not 'thm list' --- help/Docfiles/Rewrite.GEN_REWRITE_CONV.doc | 4 ++-- help/Docfiles/Rewrite.GEN_REWRITE_RULE.doc | 4 ++-- help/Docfiles/Rewrite.GEN_REWRITE_TAC.doc | 7 ++++--- 3 files changed, 8 insertions(+), 7 deletions(-) diff --git a/help/Docfiles/Rewrite.GEN_REWRITE_CONV.doc b/help/Docfiles/Rewrite.GEN_REWRITE_CONV.doc index 4f4110d193..544c9122c4 100644 --- a/help/Docfiles/Rewrite.GEN_REWRITE_CONV.doc +++ b/help/Docfiles/Rewrite.GEN_REWRITE_CONV.doc @@ -1,6 +1,6 @@ \DOC GEN_REWRITE_CONV -\TYPE {GEN_REWRITE_CONV : ((conv -> conv) -> thm list -> thm list -> conv)} +\TYPE {GEN_REWRITE_CONV : ((conv -> conv) -> rewrites -> thm list -> conv)} \SYNOPSIS Rewrites a term, selecting terms according to a user-specified strategy. @@ -60,7 +60,7 @@ and we would like to rewrite the left-hand side with the theorem {ADD_SYM} without changing the right hand side. This can be done by using: { - GEN_REWRITE_CONV (RATOR_CONV o ONCE_DEPTH_CONV) [] [ADD_SYM] mythm + GEN_REWRITE_CONV (RATOR_CONV o ONCE_DEPTH_CONV) empty_rewrites [ADD_SYM] mythm } Other rules, such as {ONCE_REWRITE_CONV}, would match and substitute on both sides, which would not be the desirable result. diff --git a/help/Docfiles/Rewrite.GEN_REWRITE_RULE.doc b/help/Docfiles/Rewrite.GEN_REWRITE_RULE.doc index 9655891fb6..30b50a7278 100644 --- a/help/Docfiles/Rewrite.GEN_REWRITE_RULE.doc +++ b/help/Docfiles/Rewrite.GEN_REWRITE_RULE.doc @@ -1,6 +1,6 @@ \DOC GEN_REWRITE_RULE -\TYPE {GEN_REWRITE_RULE : ((conv -> conv) -> thm list -> thm list -> thm -> thm)} +\TYPE {GEN_REWRITE_RULE : ((conv -> conv) -> rewrites -> thm list -> thm -> thm)} \SYNOPSIS Rewrites a theorem, selecting terms according to a user-specified strategy. @@ -60,7 +60,7 @@ and we would like to rewrite the left-hand side with the theorem {ADD_SYM} without changing the right hand side. This can be done by using: { - GEN_REWRITE_RULE (RATOR_CONV o ONCE_DEPTH_CONV) [] [ADD_SYM] mythm + GEN_REWRITE_RULE (RATOR_CONV o ONCE_DEPTH_CONV) empty_rewrites [ADD_SYM] mythm } Other rules, such as {ONCE_REWRITE_RULE}, would match and substitute on both sides, which would not be the desirable result. diff --git a/help/Docfiles/Rewrite.GEN_REWRITE_TAC.doc b/help/Docfiles/Rewrite.GEN_REWRITE_TAC.doc index 35d7a19aaf..23ad2f2a9e 100644 --- a/help/Docfiles/Rewrite.GEN_REWRITE_TAC.doc +++ b/help/Docfiles/Rewrite.GEN_REWRITE_TAC.doc @@ -1,6 +1,6 @@ \DOC GEN_REWRITE_TAC -\TYPE {GEN_REWRITE_TAC : ((conv -> conv) -> thm list -> thm list -> tactic)} +\TYPE {GEN_REWRITE_TAC : ((conv -> conv) -> rewrites -> thm list -> tactic)} \SYNOPSIS Rewrites a goal, selecting terms according to a user-specified strategy. @@ -67,7 +67,7 @@ sides to produce the following goal: as {ADD_SYM} matches at two positions. To rewrite on only one side of the equation, the following tactic can be used: { - GEN_REWRITE_TAC (RAND_CONV o ONCE_DEPTH_CONV) [] [ADD_SYM] + GEN_REWRITE_TAC (RAND_CONV o ONCE_DEPTH_CONV) empty_rewrites [ADD_SYM] } which produces the desired goal: { @@ -79,7 +79,8 @@ to {REWRITE_TAC} but will also include {ADD_CLAUSES} in the set of theorems to use always: { val ADD_REWRITE_TAC = GEN_REWRITE_TAC TOP_DEPTH_CONV - (ADD_CLAUSES :: implicit_rewrites()) + (add_rewrites (implicit_rewrites ()) + [ADD_CLAUSES]) } From 32bf1e49427437b1f9f1041fc9ee63fa000cc827 Mon Sep 17 00:00:00 2001 From: Piotr Trojanek Date: Mon, 2 Feb 2015 14:00:33 +0000 Subject: [PATCH 164/718] extra semicolons removed from (some) .sig files --- src/0/KernelTypes.sig | 4 +- src/0/Subst.sig | 18 +++--- src/0/Term.sig | 4 +- src/0/Type.sig | 2 +- src/1/Prim_rec.sig | 2 +- src/1/Psyntax.sig | 2 +- src/1/Tactic.sig | 2 +- src/1/Tactical.sig | 2 +- src/1/dep_rewrite.sig | 2 +- src/1/simpfrag.sig | 2 +- src/IndDef/InductiveDefinition.sig | 2 +- src/basicProof/BasicProvers.sig | 2 +- src/compute/src/compute_rules.sig | 3 +- src/datatype/mutrec/ConsThms.sig | 2 +- src/datatype/mutrec/Recftn.sig | 2 +- src/enumfset/enumTacs.sig | 64 ++++++++++----------- src/enumfset/fmapalTacs.sig | 50 ++++++++-------- src/enumfset/inttoTacs.sig | 14 ++--- src/enumfset/tcTacs.sig | 18 +++--- src/enumfset/totoTacs.sig | 36 ++++++------ src/experimental-kernel/Net.sig | 2 +- src/integer/CooperCore.sig | 2 +- src/integer/CooperShell.sig | 2 +- src/integer/IntDP_Munge.sig | 2 +- src/integer/Omega.sig | 2 +- src/integer/OmegaMLShadow.sig | 2 +- src/integer/OmegaMath.sig | 2 +- src/integer/OmegaShell.sig | 2 +- src/integer/OmegaSimple.sig | 2 +- src/integer/OmegaSymbolic.sig | 2 +- src/integer/intSimps.sig | 2 +- src/integer/jrhCore.sig | 2 +- src/integer/testing/test_cases.sig | 2 +- src/list/src/ListConv1.sig | 2 +- src/lite/liteLib.sig | 2 +- src/lite/liteLib.sml | 6 +- src/logging-kernel/Net.sig | 2 +- src/meson/src/Canon_Port.sig | 2 +- src/meson/src/mesonLib.sig | 2 +- src/monad/monadsyntax.sig | 2 +- src/num/arith/src/GenPolyCanon.sig | 2 +- src/num/theories/Num_conv.sig | 2 +- src/option/optionLib.sig | 2 +- src/pair/src/pairTools.sig | 2 +- src/parse/Absyn.sig | 2 +- src/parse/CharSet.sig | 2 +- src/parse/PPBackEnd.sig | 2 +- src/parse/Preterm.sig | 2 +- src/parse/qbuf.sig | 2 +- src/portableML/HOLPP.sig | 2 +- src/portableML/UnicodeChars.sig | 3 +- src/postkernel/SharingTables.sig | 4 +- src/postkernel/Theory.sig | 3 - src/pred_set/src/PGspec.sig | 2 +- src/pred_set/src/PSet_ind.sig | 2 +- src/pred_set/src/pred_setLib.sig | 2 +- src/prekernel/Lexis.sig | 2 +- src/prekernel/locn.sig | 2 +- src/quotient/examples/ind_rel.sig | 2 +- src/quotient/examples/lambda/barendregt.sig | 2 +- src/quotient/examples/lambda/ind_rel.sig | 2 +- src/quotient/examples/lambda/tactics.sig | 2 +- src/quotient/examples/sigma/barendregt.sig | 2 +- src/quotient/examples/sigma/ind_rel.sig | 2 +- src/quotient/examples/sigma/tactics.sig | 2 +- src/quotient/src/quotient.sig | 2 +- src/rational/fracLib.sig | 2 +- src/rational/fracSyntax.sig | 2 +- src/rational/fracUtils.sig | 2 +- src/rational/intExtensionLib.sig | 2 +- src/rational/jbUtils.sig | 2 +- src/rational/ratLib.sig | 10 ++-- src/rational/ratSyntax.sig | 2 +- src/rational/ratUtils.sig | 2 +- src/rational/schneiderUtils.sig | 2 +- src/refute/Canon.sig | 2 +- src/refute/refuteLib.sig | 2 +- src/res_quan/src/res_quanLib.sig | 2 +- src/res_quan/src/res_quanTools.sig | 2 +- src/ring/src/abstraction.sig | 2 +- src/ring/src/ringLib.sig | 3 +- src/simp/src/SatisfySimps.sig | 2 +- src/tfl/src/Induction.sig | 2 +- src/tfl/src/wfrecUtils.sig | 4 +- tools/Holmake/Systeml.sig | 2 +- 85 files changed, 186 insertions(+), 196 deletions(-) diff --git a/src/0/KernelTypes.sig b/src/0/KernelTypes.sig index 60e5a4d07a..73d21505b9 100644 --- a/src/0/KernelTypes.sig +++ b/src/0/KernelTypes.sig @@ -15,7 +15,7 @@ type id = KernelSig.kernelid type tyconst = id * int datatype hol_type = Tyv of string - | Tyapp of tyconst * hol_type list; + | Tyapp of tyconst * hol_type list (*---------------------------------------------------------------------------* @@ -36,7 +36,7 @@ datatype term = Fv of string * hol_type | Const of tmconst | Comb of term * term | Abs of term * term - | Clos of term Subst.subs * term; + | Clos of term Subst.subs * term (*--------------------------------------------------------------------------- diff --git a/src/0/Subst.sig b/src/0/Subst.sig index 0a866e69e4..17ee0f219f 100644 --- a/src/0/Subst.sig +++ b/src/0/Subst.sig @@ -1,13 +1,13 @@ signature Subst = sig - eqtype 'a subs; + eqtype 'a subs - val id : 'a subs; - val cons : 'a subs * 'a -> 'a subs; - val shift : int * 'a subs -> 'a subs; - val lift : int * 'a subs -> 'a subs; - val is_id : 'a subs -> bool; - val exp_rel : 'a subs * int -> int * 'a option; - val comp : ('a subs * 'a -> 'a) -> 'a subs * 'a subs -> 'a subs; + val id : 'a subs + val cons : 'a subs * 'a -> 'a subs + val shift : int * 'a subs -> 'a subs + val lift : int * 'a subs -> 'a subs + val is_id : 'a subs -> bool + val exp_rel : 'a subs * int -> int * 'a option + val comp : ('a subs * 'a -> 'a) -> 'a subs * 'a subs -> 'a subs -end; +end diff --git a/src/0/Term.sig b/src/0/Term.sig index 2b8eb02511..69c660432a 100644 --- a/src/0/Term.sig +++ b/src/0/Term.sig @@ -4,7 +4,7 @@ sig include FinalTerm where type hol_type = KernelTypes.hol_type and type term = KernelTypes.term - val termsig : KernelTypes.holty KernelSig.symboltable + val termsig : KernelTypes.holty KernelSig.symboltable val lazy_beta_conv : term -> term val imp : term @@ -16,4 +16,4 @@ sig val trav : (term -> unit) -> term -> unit val is_bvar : term -> bool -end; +end diff --git a/src/0/Type.sig b/src/0/Type.sig index f873c5ad39..26c51d2576 100644 --- a/src/0/Type.sig +++ b/src/0/Type.sig @@ -3,4 +3,4 @@ sig include FinalType where type hol_type = KernelTypes.hol_type -end; +end diff --git a/src/1/Prim_rec.sig b/src/1/Prim_rec.sig index 13b5cb489d..03c6a26fc4 100644 --- a/src/1/Prim_rec.sig +++ b/src/1/Prim_rec.sig @@ -52,4 +52,4 @@ sig (* A utility function *) val EXISTS_EQUATION : term -> thm -> thm -end; +end diff --git a/src/1/Psyntax.sig b/src/1/Psyntax.sig index 87c0420835..2ecfa47751 100644 --- a/src/1/Psyntax.sig +++ b/src/1/Psyntax.sig @@ -50,4 +50,4 @@ sig | LAMB of term * term val dest_term : term -> lambda -end; +end diff --git a/src/1/Tactic.sig b/src/1/Tactic.sig index 6f47796458..6543b702cf 100644 --- a/src/1/Tactic.sig +++ b/src/1/Tactic.sig @@ -74,4 +74,4 @@ sig val SELECT_ELIM_TAC : tactic val HINT_EXISTS_TAC : tactic -end; +end diff --git a/src/1/Tactical.sig b/src/1/Tactical.sig index 267ff4d91b..3561d897ba 100644 --- a/src/1/Tactical.sig +++ b/src/1/Tactical.sig @@ -78,4 +78,4 @@ sig val set_prover : (term * tactic -> thm) -> unit val restore_prover : unit -> unit -end; +end diff --git a/src/1/dep_rewrite.sig b/src/1/dep_rewrite.sig index 49bae15a4a..d1b9828c8a 100644 --- a/src/1/dep_rewrite.sig +++ b/src/1/dep_rewrite.sig @@ -237,7 +237,7 @@ val DEP_PURE_ASM_REWRITE_TAC : thm list -> tactic val DEP_ASM_REWRITE_TAC : thm list -> tactic -end; +end (* ================================================================== *) (* ================================================================== *) diff --git a/src/1/simpfrag.sig b/src/1/simpfrag.sig index f0434ec9ff..670f493ab8 100644 --- a/src/1/simpfrag.sig +++ b/src/1/simpfrag.sig @@ -12,4 +12,4 @@ sig val empty_simpfrag : simpfrag val add_rwts : simpfrag -> thm list -> simpfrag -end; +end diff --git a/src/IndDef/InductiveDefinition.sig b/src/IndDef/InductiveDefinition.sig index 600f8f865b..1c6104968c 100644 --- a/src/IndDef/InductiveDefinition.sig +++ b/src/IndDef/InductiveDefinition.sig @@ -23,4 +23,4 @@ sig val derive_nonschematic_inductive_relations : term -> thm val prove_monotonicity_hyps : monoset -> thm -> thm -end; +end diff --git a/src/basicProof/BasicProvers.sig b/src/basicProof/BasicProvers.sig index f7c2f72292..16ea61af88 100644 --- a/src/basicProof/BasicProvers.sig +++ b/src/basicProof/BasicProvers.sig @@ -48,7 +48,7 @@ sig datatype tmkind = Free of term | Bound of term list * term - | Alien of term; + | Alien of term val dest_tmkind : tmkind -> term val prim_find_subterm : term list -> term -> goal -> tmkind diff --git a/src/compute/src/compute_rules.sig b/src/compute/src/compute_rules.sig index dab2a22574..6eac416939 100644 --- a/src/compute/src/compute_rules.sig +++ b/src/compute/src/compute_rules.sig @@ -32,5 +32,4 @@ val lazyfy_thm : Thm.thm -> Thm.thm val strictify_thm : Thm.thm -> Thm.thm val eq_intro : Thm.thm -> Thm.thm - -end; +end diff --git a/src/datatype/mutrec/ConsThms.sig b/src/datatype/mutrec/ConsThms.sig index 0e2725bb49..e6c7fbffee 100644 --- a/src/datatype/mutrec/ConsThms.sig +++ b/src/datatype/mutrec/ConsThms.sig @@ -11,4 +11,4 @@ sig mutual_cases : thm, argument_extraction_definitions : (string * thm) list} -end; +end diff --git a/src/datatype/mutrec/Recftn.sig b/src/datatype/mutrec/Recftn.sig index 81ceb92e7d..f2d4ab6ca2 100644 --- a/src/datatype/mutrec/Recftn.sig +++ b/src/datatype/mutrec/Recftn.sig @@ -9,4 +9,4 @@ sig def : term, fixities : fixity list option, rec_axiom: thm} -> thm -end; +end diff --git a/src/enumfset/enumTacs.sig b/src/enumfset/enumTacs.sig index 10b98ce339..76876c27d7 100644 --- a/src/enumfset/enumTacs.sig +++ b/src/enumfset/enumTacs.sig @@ -3,48 +3,48 @@ signature enumTacs = sig -type conv = Abbrev.conv; -type thm = Thm.thm; -type term = Term.term; -type hol_type = Term.hol_type; +type conv = Abbrev.conv +type thm = Thm.thm +type term = Term.term +type hol_type = Term.hol_type -val EQ_LESS_CONV: conv; -val COND_EQ_LESS_CONV: conv; +val EQ_LESS_CONV: conv +val COND_EQ_LESS_CONV: conv -val BL_CONS_CONV: conv; -val bt_rev_CONV: conv; +val BL_CONS_CONV: conv +val bt_rev_CONV: conv -val bt_to_list_CONV: conv; -val bl_to_bt_CONV: conv; -val list_to_bl_CONV: conv; -val list_to_bt_CONV: conv; +val bt_to_list_CONV: conv +val bl_to_bt_CONV: conv +val list_to_bl_CONV: conv +val list_to_bt_CONV: conv -val set_TO_ENUMERAL_CONV: conv -> term -> conv; -val DISPLAY_TO_set_CONV: conv; -val DISPLAY_TO_ENUMERAL_CONV:conv -> term -> conv; +val set_TO_ENUMERAL_CONV: conv -> term -> conv +val DISPLAY_TO_set_CONV: conv +val DISPLAY_TO_ENUMERAL_CONV:conv -> term -> conv -val IN_CONV: conv -> conv; +val IN_CONV: conv -> conv -val OWL_TO_ENUMERAL: thm -> thm; -val ENUMERAL_TO_OWL: conv -> conv; +val OWL_TO_ENUMERAL: thm -> thm +val ENUMERAL_TO_OWL: conv -> conv -val set_TO_DISPLAY_CONV: conv; -val ENUMERAL_TO_set_CONV: conv -> conv; -val ENUMERAL_TO_DISPLAY_CONV: conv -> conv; -val TO_set_CONV: conv -> conv; +val set_TO_DISPLAY_CONV: conv +val ENUMERAL_TO_set_CONV: conv -> conv +val ENUMERAL_TO_DISPLAY_CONV: conv -> conv +val TO_set_CONV: conv -> conv -val OWL_UNION: conv -> thm -> thm -> thm; -val UNION_CONV: conv -> conv; +val OWL_UNION: conv -> thm -> thm -> thm +val UNION_CONV: conv -> conv -val OWL_INTER: conv -> thm -> thm -> thm; -val INTER_CONV: conv -> conv; +val OWL_INTER: conv -> thm -> thm -> thm +val INTER_CONV: conv -> conv -val OWL_DIFF: conv -> thm -> thm -> thm; -val SET_DIFF_CONV: conv -> conv; +val OWL_DIFF: conv -> thm -> thm -> thm +val SET_DIFF_CONV: conv -> conv -val SET_EXPR_TO_OWL: conv -> term -> thm; -val SET_EXPR_CONV: conv -> conv; +val SET_EXPR_TO_OWL: conv -> term -> thm +val SET_EXPR_CONV: conv -> conv -val set_TO_OWL: conv -> term -> term -> thm; +val set_TO_OWL: conv -> term -> term -> thm -end; +end diff --git a/src/enumfset/fmapalTacs.sig b/src/enumfset/fmapalTacs.sig index dd899e4d5a..dd801532a5 100644 --- a/src/enumfset/fmapalTacs.sig +++ b/src/enumfset/fmapalTacs.sig @@ -3,38 +3,38 @@ signature fmapalTacs = sig -type conv = Abbrev.conv; -type thm = Thm.thm; -type term = Term.term; -type hol_type = Term.hol_type; +type conv = Abbrev.conv +type thm = Thm.thm +type term = Term.term +type hol_type = Term.hol_type -val merge_CONV: conv -> conv; -val incr_sort_CONV: conv -> conv; +val merge_CONV: conv -> conv +val incr_sort_CONV: conv -> conv -val fmap_TO_FMAPAL_CONV: conv -> term -> conv; -val FMAPAL_TO_fmap_CONV: conv -> conv; -val FUN_fmap_CONV: conv -> conv; -val FUN_FMAPAL_CONV: conv -> term -> conv -> conv; +val fmap_TO_FMAPAL_CONV: conv -> term -> conv +val FMAPAL_TO_fmap_CONV: conv -> conv +val FUN_fmap_CONV: conv -> conv +val FUN_FMAPAL_CONV: conv -> term -> conv -> conv -val FAPPLY_CONV: conv -> conv; +val FAPPLY_CONV: conv -> conv -val ORWL_TO_FMAPAL: thm -> thm; -val FMAPAL_TO_ORWL:conv -> conv; +val ORWL_TO_FMAPAL: thm -> thm +val FMAPAL_TO_ORWL:conv -> conv -val ORWL_FUNION: conv -> thm -> thm -> thm; -val FUNION_CONV: conv -> conv; +val ORWL_FUNION: conv -> thm -> thm -> thm +val FUNION_CONV: conv -> conv -val ORWL_DRESTRICT: conv -> thm -> thm -> thm; -val ORWL_DRESTRICT_COMPL: conv -> thm -> thm -> thm; -val DRESTRICT_CONV: conv -> conv; +val ORWL_DRESTRICT: conv -> thm -> thm -> thm +val ORWL_DRESTRICT_COMPL: conv -> thm -> thm -> thm +val DRESTRICT_CONV: conv -> conv -val MAP_ELEM_CONV: conv -> conv; -val FDOM_CONV: conv; -val IN_FDOM_CONV: conv -> conv; -val o_f_CONV: conv -> conv; +val MAP_ELEM_CONV: conv -> conv +val FDOM_CONV: conv +val IN_FDOM_CONV: conv -> conv +val o_f_CONV: conv -> conv -val FUPDATE_CONV: conv -> conv; +val FUPDATE_CONV: conv -> conv -val FMAP_EXPR_CONV: conv -> conv; +val FMAP_EXPR_CONV: conv -> conv -end; +end diff --git a/src/enumfset/inttoTacs.sig b/src/enumfset/inttoTacs.sig index 41532e058e..812e7e265e 100644 --- a/src/enumfset/inttoTacs.sig +++ b/src/enumfset/inttoTacs.sig @@ -3,12 +3,12 @@ signature inttoTacs = sig -type conv = Abbrev.conv; -type thm = Thm.thm; -type term = Term.term; -type hol_type = Term.hol_type; -type tactic = Abbrev.tactic; +type conv = Abbrev.conv +type thm = Thm.thm +type term = Term.term +type hol_type = Term.hol_type +type tactic = Abbrev.tactic -val intto_CONV: conv; +val intto_CONV: conv -end; +end diff --git a/src/enumfset/tcTacs.sig b/src/enumfset/tcTacs.sig index 68a1a494e1..3e54e9769c 100644 --- a/src/enumfset/tcTacs.sig +++ b/src/enumfset/tcTacs.sig @@ -3,17 +3,15 @@ signature tcTacs = sig -type conv = Abbrev.conv; -type thm = Thm.thm; -type term = Term.term; -type hol_type = Term.hol_type; +type conv = Abbrev.conv +type thm = Thm.thm +type term = Term.term +type hol_type = Term.hol_type -val FMAP_TO_RELN: thm; +val FMAP_TO_RELN: thm -val ENUF_CONV: conv -> term -> conv; +val ENUF_CONV: conv -> term -> conv -val TC_CONV: conv -> conv; +val TC_CONV: conv -> conv - - -end; +end diff --git a/src/enumfset/totoTacs.sig b/src/enumfset/totoTacs.sig index be6c10e1e7..b946ea4430 100644 --- a/src/enumfset/totoTacs.sig +++ b/src/enumfset/totoTacs.sig @@ -3,28 +3,28 @@ signature totoTacs = sig -type conv = Abbrev.conv; -type thm = Thm.thm; -type term = Term.term; -type hol_type = Term.hol_type; -type tactic = Abbrev.tactic; +type conv = Abbrev.conv +type thm = Thm.thm +type term = Term.term +type hol_type = Term.hol_type +type tactic = Abbrev.tactic -val PURE_MATCH_MP: thm -> thm -> thm; -val LESS_REWR: thm; -val EQUAL_REWR: thm; -val GREATER_REWR:thm; -val cpn_REWR_CONV: conv; +val PURE_MATCH_MP: thm -> thm -> thm +val LESS_REWR: thm +val EQUAL_REWR: thm +val GREATER_REWR:thm +val cpn_REWR_CONV: conv -val toto_CONV: thm -> thm -> conv -> conv -> conv; -val numto_CONV: conv; -val charto_CONV: conv; -val qk_numto_CONV: conv; -val stringto_CONV: conv; +val toto_CONV: thm -> thm -> conv -> conv -> conv +val numto_CONV: conv +val charto_CONV: conv +val qk_numto_CONV: conv +val stringto_CONV: conv -val lextoto_CONV: conv -> conv -> conv; -val listoto_CONV: conv -> conv; +val lextoto_CONV: conv -> conv -> conv +val listoto_CONV: conv -> conv val numOrd_CONV : conv val num_pre_CONV : conv -end; +end diff --git a/src/experimental-kernel/Net.sig b/src/experimental-kernel/Net.sig index 6065a7ec06..c3e150a17a 100644 --- a/src/experimental-kernel/Net.sig +++ b/src/experimental-kernel/Net.sig @@ -91,4 +91,4 @@ sig [lookup tm net] An outdated version of match, kept for compatibility. ---------------------------------------------------------------------------*) -end; +end diff --git a/src/integer/CooperCore.sig b/src/integer/CooperCore.sig index fdcc4125da..b1e4d26c8d 100644 --- a/src/integer/CooperCore.sig +++ b/src/integer/CooperCore.sig @@ -2,4 +2,4 @@ signature CooperCore = sig include Abbrev val phase4_CONV : conv val phase5_CONV : conv -end; +end diff --git a/src/integer/CooperShell.sig b/src/integer/CooperShell.sig index 673615c554..e960a70e8b 100644 --- a/src/integer/CooperShell.sig +++ b/src/integer/CooperShell.sig @@ -5,4 +5,4 @@ signature CooperShell = sig val pure_goal : conv val decide_pure_presburger_term : conv -end; +end diff --git a/src/integer/IntDP_Munge.sig b/src/integer/IntDP_Munge.sig index d91768be07..131e2bc240 100644 --- a/src/integer/IntDP_Munge.sig +++ b/src/integer/IntDP_Munge.sig @@ -12,7 +12,7 @@ sig val conv_tac : conv -> tactic -end; +end (* [BASIC_CONV s c t] normalises term t, and then applies conversion c diff --git a/src/integer/Omega.sig b/src/integer/Omega.sig index 73446c68c8..2ea8bff5a8 100644 --- a/src/integer/Omega.sig +++ b/src/integer/Omega.sig @@ -6,4 +6,4 @@ sig val OMEGA_PROVE : conv val OMEGA_TAC : tactic -end; +end diff --git a/src/integer/OmegaMLShadow.sig b/src/integer/OmegaMLShadow.sig index e257efa11c..4bd19a9c90 100644 --- a/src/integer/OmegaMLShadow.sig +++ b/src/integer/OmegaMLShadow.sig @@ -31,4 +31,4 @@ sig val work : 'b cstdb -> ('b result -> 'a) -> 'a -end; +end diff --git a/src/integer/OmegaMath.sig b/src/integer/OmegaMath.sig index 3c3a500a0b..a9c589b389 100644 --- a/src/integer/OmegaMath.sig +++ b/src/integer/OmegaMath.sig @@ -26,7 +26,7 @@ sig val calculate_range_disjunct : conv val OmegaEq : conv -end; +end (* diff --git a/src/integer/OmegaShell.sig b/src/integer/OmegaShell.sig index 21a0efe56b..471be5d0e2 100644 --- a/src/integer/OmegaShell.sig +++ b/src/integer/OmegaShell.sig @@ -6,4 +6,4 @@ sig val decide_strategy : conv val decide_closed_presburger : conv -end; +end diff --git a/src/integer/OmegaSimple.sig b/src/integer/OmegaSimple.sig index 0ca1cb9317..c485b9a928 100644 --- a/src/integer/OmegaSimple.sig +++ b/src/integer/OmegaSimple.sig @@ -13,7 +13,7 @@ sig val verify_gcd_check : thm -> thm val verify_combination : term -> thm -> thm -> thm -end; +end (* This file turns the "external proofs" returned by the OmegaMLShadow diff --git a/src/integer/OmegaSymbolic.sig b/src/integer/OmegaSymbolic.sig index 4caeee5b42..ea56ac055b 100644 --- a/src/integer/OmegaSymbolic.sig +++ b/src/integer/OmegaSymbolic.sig @@ -7,7 +7,7 @@ sig val sym_normalise : conv val findelim_deep_existential : conv -end; +end (* [eliminate_an_existential t] with t of the form diff --git a/src/integer/intSimps.sig b/src/integer/intSimps.sig index 6f6c058aec..ccec46f619 100644 --- a/src/integer/intSimps.sig +++ b/src/integer/intSimps.sig @@ -40,4 +40,4 @@ sig (* collects up all terms, summing coefficients. Does more than collect_additive_consts therefore. Right-associates. *) -end; +end diff --git a/src/integer/jrhCore.sig b/src/integer/jrhCore.sig index 714ab37ed2..afc6a76da2 100644 --- a/src/integer/jrhCore.sig +++ b/src/integer/jrhCore.sig @@ -2,4 +2,4 @@ signature jrhCore = sig include Abbrev val phase4_CONV : conv val phase5_CONV : conv -end; +end diff --git a/src/integer/testing/test_cases.sig b/src/integer/testing/test_cases.sig index 77915cc7fd..c0b715629f 100644 --- a/src/integer/testing/test_cases.sig +++ b/src/integer/testing/test_cases.sig @@ -13,4 +13,4 @@ sig val perform_omega_tests : conv -> bool val perform_cooper_tests : conv -> bool -end; +end diff --git a/src/list/src/ListConv1.sig b/src/list/src/ListConv1.sig index d74234e1ba..59d53be872 100644 --- a/src/list/src/ListConv1.sig +++ b/src/list/src/ListConv1.sig @@ -42,4 +42,4 @@ sig val SCANR_CONV : conv -> conv val REPLICATE_CONV : conv val GENLIST_CONV : conv -> conv -end; +end diff --git a/src/lite/liteLib.sig b/src/lite/liteLib.sig index 59ee088562..51ea1f9b0a 100644 --- a/src/lite/liteLib.sig +++ b/src/lite/liteLib.sig @@ -150,4 +150,4 @@ sig val SIMPLE_DISJ_CASES : thm -> thm -> thm val SIMPLE_CHOOSE : term -> thm -> thm -end; +end diff --git a/src/lite/liteLib.sml b/src/lite/liteLib.sml index 18935a4b79..e5339979db 100644 --- a/src/lite/liteLib.sml +++ b/src/lite/liteLib.sml @@ -17,7 +17,7 @@ infix THENC ORELSEC |->; * Exceptions *--------------------------------------------------------------------*) -val ERR = mk_HOL_ERR "liteLib"; +val ERR = mk_HOL_ERR "liteLib" fun STRUCT_ERR s (func,mesg) = raise Feedback.mk_HOL_ERR s func mesg fun STRUCT_WRAP s (func,exn) = raise Feedback.wrap_exn s func exn @@ -33,13 +33,13 @@ fun is_some (SOME x) = true | is_some NONE = false fun is_none NONE = true - | is_none _ = false; + | is_none _ = false fun option_cases f e (SOME x) = f x | option_cases f e NONE = e fun option_app f (SOME x) = SOME (f x) - | option_app f NONE = NONE; + | option_app f NONE = NONE infix 3 |> thenf orelsef; diff --git a/src/logging-kernel/Net.sig b/src/logging-kernel/Net.sig index 6065a7ec06..c3e150a17a 100644 --- a/src/logging-kernel/Net.sig +++ b/src/logging-kernel/Net.sig @@ -91,4 +91,4 @@ sig [lookup tm net] An outdated version of match, kept for compatibility. ---------------------------------------------------------------------------*) -end; +end diff --git a/src/meson/src/Canon_Port.sig b/src/meson/src/Canon_Port.sig index 2a5f1a8d6a..2829f1cc84 100644 --- a/src/meson/src/Canon_Port.sig +++ b/src/meson/src/Canon_Port.sig @@ -14,4 +14,4 @@ sig val PRENEX_CONV : conv val REFUTE_THEN : (thm -> tactic) -> tactic val GEN_FOL_CONV : (term*int)list * (term*int) list -> conv -end; +end diff --git a/src/meson/src/mesonLib.sig b/src/meson/src/mesonLib.sig index a401861ecd..85c8baf6f6 100644 --- a/src/meson/src/mesonLib.sig +++ b/src/meson/src/mesonLib.sig @@ -6,7 +6,7 @@ signature mesonLib = sig type thm = Thm.thm -type tactic = Abbrev.tactic; +type tactic = Abbrev.tactic val depth : bool ref val prefine : bool ref diff --git a/src/monad/monadsyntax.sig b/src/monad/monadsyntax.sig index b9521dc073..5d08981b44 100644 --- a/src/monad/monadsyntax.sig +++ b/src/monad/monadsyntax.sig @@ -1,4 +1,4 @@ signature monadsyntax = sig -end; +end diff --git a/src/num/arith/src/GenPolyCanon.sig b/src/num/arith/src/GenPolyCanon.sig index 4de9323488..473cf4b617 100644 --- a/src/num/arith/src/GenPolyCanon.sig +++ b/src/num/arith/src/GenPolyCanon.sig @@ -26,7 +26,7 @@ val gencanon : gci -> term -> thm val derive_l_asscomm : thm -> thm -> thm val derive_r_asscomm : thm -> thm -> thm -end; +end (* diff --git a/src/num/theories/Num_conv.sig b/src/num/theories/Num_conv.sig index 03fe42933a..efcbb88474 100644 --- a/src/num/theories/Num_conv.sig +++ b/src/num/theories/Num_conv.sig @@ -13,4 +13,4 @@ signature Num_conv = sig val num_CONV : Term.term -> Thm.thm -end; +end diff --git a/src/option/optionLib.sig b/src/option/optionLib.sig index b924003a15..8bc8740fce 100644 --- a/src/option/optionLib.sig +++ b/src/option/optionLib.sig @@ -45,4 +45,4 @@ sig val option_rws : thm val OPTION_rws : computeLib.compset -> unit -end; +end diff --git a/src/pair/src/pairTools.sig b/src/pair/src/pairTools.sig index 355671e908..381a6213b3 100644 --- a/src/pair/src/pairTools.sig +++ b/src/pair/src/pairTools.sig @@ -21,4 +21,4 @@ sig val PABS_ELIM_CONV : conv val PABS_INTRO_CONV : term -> conv -end; +end diff --git a/src/parse/Absyn.sig b/src/parse/Absyn.sig index ffc3dc1f7d..7f4ee231c9 100644 --- a/src/parse/Absyn.sig +++ b/src/parse/Absyn.sig @@ -91,4 +91,4 @@ sig val is_exists : absyn -> bool val is_exists1 : absyn -> bool val is_select : absyn -> bool -end; +end diff --git a/src/parse/CharSet.sig b/src/parse/CharSet.sig index 4ecd8b2d50..90402dc844 100644 --- a/src/parse/CharSet.sig +++ b/src/parse/CharSet.sig @@ -15,4 +15,4 @@ sig val listItems : CharSet -> char list -end; +end diff --git a/src/parse/PPBackEnd.sig b/src/parse/PPBackEnd.sig index 7f2b6a7282..5109a6f4c7 100644 --- a/src/parse/PPBackEnd.sig +++ b/src/parse/PPBackEnd.sig @@ -21,7 +21,7 @@ sig | Blue | PinkPurple | LightBlue - | White; + | White datatype pp_style = FG of pp_color diff --git a/src/parse/Preterm.sig b/src/parse/Preterm.sig index 0d888971ac..8dc548a554 100644 --- a/src/parse/Preterm.sig +++ b/src/parse/Preterm.sig @@ -81,4 +81,4 @@ sig val last_tcerror : (tcheck_error * locn.locn) option ref -end; +end diff --git a/src/parse/qbuf.sig b/src/parse/qbuf.sig index e7e590e63b..57cf5caf5d 100644 --- a/src/parse/qbuf.sig +++ b/src/parse/qbuf.sig @@ -15,4 +15,4 @@ signature qbuf = sig val toString : 'a qbuf -> string -end; +end diff --git a/src/portableML/HOLPP.sig b/src/portableML/HOLPP.sig index 6aba231d60..b4637670db 100644 --- a/src/portableML/HOLPP.sig +++ b/src/portableML/HOLPP.sig @@ -203,4 +203,4 @@ val catch_withpp_err : bool ref Plus(e3, Plus(e3, Plus(e3, Plus(e3, Plus(e3, Plus(e3, e7)))))); *) -end; +end diff --git a/src/portableML/UnicodeChars.sig b/src/portableML/UnicodeChars.sig index 968a8f14f4..598e1c1f27 100644 --- a/src/portableML/UnicodeChars.sig +++ b/src/portableML/UnicodeChars.sig @@ -90,7 +90,7 @@ sig val lensel : string val lenser : string - (*stars*) + (* stars *) val blackstar : string val whitestar : string val bigasterisk : string @@ -153,5 +153,4 @@ sig val isSymbolic : string -> bool val isMLIdent : string -> bool - end diff --git a/src/postkernel/SharingTables.sig b/src/postkernel/SharingTables.sig index d7b1e9d79d..2765b6baa0 100644 --- a/src/postkernel/SharingTables.sig +++ b/src/postkernel/SharingTables.sig @@ -1,7 +1,6 @@ signature SharingTables = sig - structure Map : Binarymap type id = {Thy : string, Other : string} datatype shared_type = TYV of string @@ -49,5 +48,4 @@ sig termtable_nm : string} -> termtable -> unit - -end; +end diff --git a/src/postkernel/Theory.sig b/src/postkernel/Theory.sig index daa66f9e79..6d8a21641e 100644 --- a/src/postkernel/Theory.sig +++ b/src/postkernel/Theory.sig @@ -112,7 +112,4 @@ sig TheoryDelta event to be sent to all registered listeners *) val load_complete : string -> unit - - - end diff --git a/src/pred_set/src/PGspec.sig b/src/pred_set/src/PGspec.sig index 0178ad71e4..eccdb2d9ff 100644 --- a/src/pred_set/src/PGspec.sig +++ b/src/pred_set/src/PGspec.sig @@ -2,4 +2,4 @@ signature PGspec = sig type conv = Abbrev.conv val SET_SPEC_CONV : Thm.thm -> conv -end; +end diff --git a/src/pred_set/src/PSet_ind.sig b/src/pred_set/src/PSet_ind.sig index dd4c9ea553..fef1bf7466 100644 --- a/src/pred_set/src/PSet_ind.sig +++ b/src/pred_set/src/PSet_ind.sig @@ -3,4 +3,4 @@ sig type tactic = Abbrev.tactic val SET_INDUCT_TAC : Thm.thm -> tactic -end; +end diff --git a/src/pred_set/src/pred_setLib.sig b/src/pred_set/src/pred_setLib.sig index fe0c0c8f5d..cddfe28609 100644 --- a/src/pred_set/src/pred_setLib.sig +++ b/src/pred_set/src/pred_setLib.sig @@ -17,4 +17,4 @@ sig val add_pred_set_compset : computeLib.compset -> unit -end; +end diff --git a/src/prekernel/Lexis.sig b/src/prekernel/Lexis.sig index a29cc4b029..9e1fdb3dfd 100644 --- a/src/prekernel/Lexis.sig +++ b/src/prekernel/Lexis.sig @@ -24,4 +24,4 @@ sig val tmvar_vary : string -> string val gen_variant : (string -> string) -> string list -> string -> string -end; +end diff --git a/src/prekernel/locn.sig b/src/prekernel/locn.sig index c3ebbdd57c..c01960c820 100644 --- a/src/prekernel/locn.sig +++ b/src/prekernel/locn.sig @@ -48,4 +48,4 @@ signature locn = sig type 'a located = 'a * locn -end; +end diff --git a/src/quotient/examples/ind_rel.sig b/src/quotient/examples/ind_rel.sig index d93b1fd0e2..59321a158f 100644 --- a/src/quotient/examples/ind_rel.sig +++ b/src/quotient/examples/ind_rel.sig @@ -25,4 +25,4 @@ val rule_induct : Thm.thm -> (* induction theorem (strong or regular) *) Abbrev.tactic (* sets up induction *) -end; +end diff --git a/src/quotient/examples/lambda/barendregt.sig b/src/quotient/examples/lambda/barendregt.sig index 6277a234fe..50f56dfe36 100644 --- a/src/quotient/examples/lambda/barendregt.sig +++ b/src/quotient/examples/lambda/barendregt.sig @@ -24,4 +24,4 @@ val MAKE_SIMPLE_SUBST_TAC : tactic val SIMPLE_SUBST_TAC : tactic -end; +end diff --git a/src/quotient/examples/lambda/ind_rel.sig b/src/quotient/examples/lambda/ind_rel.sig index d93b1fd0e2..59321a158f 100644 --- a/src/quotient/examples/lambda/ind_rel.sig +++ b/src/quotient/examples/lambda/ind_rel.sig @@ -25,4 +25,4 @@ val rule_induct : Thm.thm -> (* induction theorem (strong or regular) *) Abbrev.tactic (* sets up induction *) -end; +end diff --git a/src/quotient/examples/lambda/tactics.sig b/src/quotient/examples/lambda/tactics.sig index 0d7bb3023c..94706d252d 100644 --- a/src/quotient/examples/lambda/tactics.sig +++ b/src/quotient/examples/lambda/tactics.sig @@ -143,4 +143,4 @@ val THEN1 : tactic * tactic -> tactic (* infix THEN1; *) val EVERY1 : tactic list -> tactic -end; (* sig *) +end (* sig *) diff --git a/src/quotient/examples/sigma/barendregt.sig b/src/quotient/examples/sigma/barendregt.sig index 34bc8eace1..0add146257 100644 --- a/src/quotient/examples/sigma/barendregt.sig +++ b/src/quotient/examples/sigma/barendregt.sig @@ -23,4 +23,4 @@ val MAKE_SIMPLE_SUBST_TAC : tactic val SIMPLE_SUBST_TAC : tactic -end; +end diff --git a/src/quotient/examples/sigma/ind_rel.sig b/src/quotient/examples/sigma/ind_rel.sig index d93b1fd0e2..59321a158f 100644 --- a/src/quotient/examples/sigma/ind_rel.sig +++ b/src/quotient/examples/sigma/ind_rel.sig @@ -25,4 +25,4 @@ val rule_induct : Thm.thm -> (* induction theorem (strong or regular) *) Abbrev.tactic (* sets up induction *) -end; +end diff --git a/src/quotient/examples/sigma/tactics.sig b/src/quotient/examples/sigma/tactics.sig index 54a447f2a7..95d811cf77 100644 --- a/src/quotient/examples/sigma/tactics.sig +++ b/src/quotient/examples/sigma/tactics.sig @@ -151,4 +151,4 @@ val THEN1 : tactic * tactic -> tactic (* infix THEN1; *) val EVERY1 : tactic list -> tactic -end; (* sig *) +end (* sig *) diff --git a/src/quotient/src/quotient.sig b/src/quotient/src/quotient.sig index 47dd165096..9d1b2b0bd8 100644 --- a/src/quotient/src/quotient.sig +++ b/src/quotient/src/quotient.sig @@ -508,4 +508,4 @@ val define_subset_types_rule : Thm.thm (* new lifted theorem *) -end; (* of signature quotient *) +end (* of signature quotient *) diff --git a/src/rational/fracLib.sig b/src/rational/fracLib.sig index 066a47985c..2dc01932a3 100644 --- a/src/rational/fracLib.sig +++ b/src/rational/fracLib.sig @@ -35,4 +35,4 @@ sig val FRAC_SAVE_CONV : conv val FRAC_SAVE_TAC : tactic -end; +end diff --git a/src/rational/fracSyntax.sig b/src/rational/fracSyntax.sig index cdbfb846e9..c72c1b89a0 100644 --- a/src/rational/fracSyntax.sig +++ b/src/rational/fracSyntax.sig @@ -48,4 +48,4 @@ sig val is_frac_mul : term -> bool val is_frac_div : term -> bool -end; +end diff --git a/src/rational/fracUtils.sig b/src/rational/fracUtils.sig index b3db9880e1..5e4f9241c7 100644 --- a/src/rational/fracUtils.sig +++ b/src/rational/fracUtils.sig @@ -12,4 +12,4 @@ sig val extract_frac_fun : term list -> term -> (term * term * term) list val INT_GT0_CONV : term -> thm -end; +end diff --git a/src/rational/intExtensionLib.sig b/src/rational/intExtensionLib.sig index 35eeb1f6e9..299170f510 100644 --- a/src/rational/intExtensionLib.sig +++ b/src/rational/intExtensionLib.sig @@ -10,4 +10,4 @@ sig (* tactics *) val INT_SGN_CASES_TAC: term -> tactic val INT_CALCEQ_TAC: tactic -end; \ No newline at end of file +end diff --git a/src/rational/jbUtils.sig b/src/rational/jbUtils.sig index 067b7116e1..19877c08f8 100644 --- a/src/rational/jbUtils.sig +++ b/src/rational/jbUtils.sig @@ -26,4 +26,4 @@ sig val list_merge : ''a list -> ''a list -> ''a list val list_xmerge : ''a list list -> ''a list val dest_binop_triple : term -> term * term * term -end; +end diff --git a/src/rational/ratLib.sig b/src/rational/ratLib.sig index cdf83666a7..9758023d92 100644 --- a/src/rational/ratLib.sig +++ b/src/rational/ratLib.sig @@ -39,9 +39,9 @@ sig val RAT_BASIC_ARITH_TAC : tactic val RAT_ELIMINATE_MINV_TAC : tactic - val int_rewrites : thm list; - val rat_basic_rewrites : thm list; - val rat_rewrites : thm list; - val rat_num_rewrites : thm list; + val int_rewrites : thm list + val rat_basic_rewrites : thm list + val rat_rewrites : thm list + val rat_num_rewrites : thm list -end; +end diff --git a/src/rational/ratSyntax.sig b/src/rational/ratSyntax.sig index a9025a16f8..0d4c477e23 100644 --- a/src/rational/ratSyntax.sig +++ b/src/rational/ratSyntax.sig @@ -77,4 +77,4 @@ sig val strip_rat_add : term -> term list val strip_rat_mul : term -> term list -end; +end diff --git a/src/rational/ratUtils.sig b/src/rational/ratUtils.sig index 6e9f3f6682..51846c6680 100644 --- a/src/rational/ratUtils.sig +++ b/src/rational/ratUtils.sig @@ -13,4 +13,4 @@ sig val extract_rat_equations : term -> term list val extract_rat_minv : term -> term list -end; \ No newline at end of file +end diff --git a/src/rational/schneiderUtils.sig b/src/rational/schneiderUtils.sig index c5b472f3dc..7d2e5e6aff 100644 --- a/src/rational/schneiderUtils.sig +++ b/src/rational/schneiderUtils.sig @@ -51,4 +51,4 @@ signature schneiderUtils = val delete : int -> 'a list -> 'a list val elem : int -> 'a list -> 'a val prove_thm : string * term * tactic -> thm - end; + end diff --git a/src/refute/Canon.sig b/src/refute/Canon.sig index 5766633057..e0857af5bb 100644 --- a/src/refute/Canon.sig +++ b/src/refute/Canon.sig @@ -32,6 +32,6 @@ sig val UNLAMB_CONV : conv val EQ_ABS_CONV : conv - val latest : (thm * thm * term) option ref; + val latest : (thm * thm * term) option ref end (* sig *) diff --git a/src/refute/refuteLib.sig b/src/refute/refuteLib.sig index 6171b23353..46743ee1f1 100644 --- a/src/refute/refuteLib.sig +++ b/src/refute/refuteLib.sig @@ -32,6 +32,6 @@ sig val UNLAMB_CONV : conv val EQ_ABS_CONV : conv - val latest : (thm * thm * term) option ref; + val latest : (thm * thm * term) option ref end diff --git a/src/res_quan/src/res_quanLib.sig b/src/res_quan/src/res_quanLib.sig index 26a11b7392..f7907c4905 100644 --- a/src/res_quan/src/res_quanLib.sig +++ b/src/res_quan/src/res_quanLib.sig @@ -3,4 +3,4 @@ sig include res_quanTools -end; +end diff --git a/src/res_quan/src/res_quanTools.sig b/src/res_quan/src/res_quanTools.sig index d9a81d3a19..39f65b7eb7 100644 --- a/src/res_quan/src/res_quanTools.sig +++ b/src/res_quan/src/res_quanTools.sig @@ -84,4 +84,4 @@ sig val Q_RESQ_ISPEC : term quotation -> rule val Q_RESQ_ISPECL : term quotation list -> rule -end; +end diff --git a/src/ring/src/abstraction.sig b/src/ring/src/abstraction.sig index 585120bf38..39850985d1 100644 --- a/src/ring/src/abstraction.sig +++ b/src/ring/src/abstraction.sig @@ -30,4 +30,4 @@ sig val compute_inst_infos : term list -> inst_infos -> cinst_infos val inst_thm_fun : cinst_infos -> thm -> thm -end; +end diff --git a/src/ring/src/ringLib.sig b/src/ring/src/ringLib.sig index b4460a6448..a0706213ec 100644 --- a/src/ring/src/ringLib.sig +++ b/src/ring/src/ringLib.sig @@ -36,5 +36,4 @@ sig val RING_CONV : conv val reify : term list -> {Metamap : term, Poly : term list} - -end; +end diff --git a/src/simp/src/SatisfySimps.sig b/src/simp/src/SatisfySimps.sig index 90fb08b701..9b410118c7 100644 --- a/src/simp/src/SatisfySimps.sig +++ b/src/simp/src/SatisfySimps.sig @@ -2,4 +2,4 @@ signature SatisfySimps = sig val SATISFY_REDUCER : Traverse.reducer; val SATISFY_ss : simpLib.ssfrag -end; +end diff --git a/src/tfl/src/Induction.sig b/src/tfl/src/Induction.sig index 27aac8db67..4c8b483910 100644 --- a/src/tfl/src/Induction.sig +++ b/src/tfl/src/Induction.sig @@ -10,4 +10,4 @@ sig val recInduct : thm -> tactic -end; +end diff --git a/src/tfl/src/wfrecUtils.sig b/src/tfl/src/wfrecUtils.sig index 755e3c4cee..19a21b66c4 100644 --- a/src/tfl/src/wfrecUtils.sig +++ b/src/tfl/src/wfrecUtils.sig @@ -22,8 +22,8 @@ sig val is_WFR : term -> bool val func_of_cond_eqn : term -> term val vary : term list -> hol_type -> term - val match_type :'a -> hol_type -> hol_type -> (hol_type,hol_type)subst + val match_type : 'a -> hol_type -> hol_type -> (hol_type,hol_type)subst val match_term : 'a -> term -> term -> (term,term) subst * (hol_type,hol_type) subst -end; +end diff --git a/tools/Holmake/Systeml.sig b/tools/Holmake/Systeml.sig index 413ac4c03b..87ccfb31ec 100644 --- a/tools/Holmake/Systeml.sig +++ b/tools/Holmake/Systeml.sig @@ -44,4 +44,4 @@ sig val release : string val version : int -end; +end From ab4a4cbb24c326b688b8350450ca38f08faa6aa2 Mon Sep 17 00:00:00 2001 From: Piotr Trojanek Date: Tue, 3 Feb 2015 23:45:04 +0000 Subject: [PATCH 165/718] remove executable bit from text files in examples/ --- examples/PSL/1.01/executable-semantics/README | 0 examples/PSL/1.01/parser/README | 0 examples/acl2/ml/signedintScript.sml | 0 examples/acl2/ml/testACL2encoding.ml | 0 examples/acl2/ml/testTypesScript.sml | 0 .../src/decidable_separationLogicScript.sml | 0 examples/dev/sw2/test/elliptic.751.for.magnus | 0 examples/dev/sw2/test/f32.hand.compiled | 0 examples/diningcryptos/extra_boolScript.sml | 0 examples/diningcryptos/extra_listScript.sml | 0 examples/diningcryptos/extra_numScript.sml | 0 examples/diningcryptos/extra_pred_setScript.sml | 0 examples/diningcryptos/extra_realScript.sml | 0 examples/diningcryptos/formalizeUseful.sig | 0 examples/diningcryptos/formalizeUseful.sml | 0 examples/diningcryptos/measureScript.sml | 0 examples/diningcryptos/subtypeScript.sml | 0 examples/diningcryptos/subtypeUseful.sig | 0 examples/diningcryptos/subtypeUseful.sml | 0 examples/elliptic/swsep/Holmakefile | 0 examples/elliptic/swsep/examples.sml | 0 .../java/classes/exception/AnalyzeException.class | Bin .../classes/exception/ConstraintException.class | Bin .../xmlterm2csp/java/classes/exception/README | 0 .../classes/exception/ValidationException.class | Bin .../java/classes/expression/Expression.class | Bin .../java/classes/expression/ExpressionVisitor.class | Bin .../xmlterm2csp/java/classes/expression/README | 0 .../integer/BinaryIntegerExpression.class | Bin .../classes/expression/integer/DivExpression.class | Bin .../expression/integer/IntegerExpression.class | Bin .../classes/expression/integer/IntegerLiteral.class | Bin .../expression/integer/MinusExpression.class | Bin .../classes/expression/integer/PlusExpression.class | Bin .../classes/expression/integer/TimeExpression.class | Bin .../classes/expression/logical/AndExpression.class | Bin .../expression/logical/BinaryLogicalOperator.class | Bin .../classes/expression/logical/Comparator.class | Bin .../expression/logical/EqualExpression.class | Bin .../expression/logical/GreatEqualExpression.class | Bin .../expression/logical/GreatExpression.class | Bin .../expression/logical/ImpliesExpression.class | Bin .../expression/logical/LessEqualExpression.class | Bin .../classes/expression/logical/LessExpression.class | Bin .../expression/logical/LogicalExpression.class | Bin .../classes/expression/logical/NotExpression.class | Bin .../classes/expression/logical/OrExpression.class | Bin .../java/classes/solvers/ConcreteSolver.class | Bin .../xmlterm2csp/java/classes/solvers/README | 0 .../xmlterm2csp/java/classes/solvers/Solver.class | Bin .../java/classes/solvers/jsolver/JSolver.class | Bin .../solvers/jsolver/JSolverConstraintBlock.class | Bin .../solvers/jsolver/JSolverExpressionVisitor.class | Bin .../solvers/jsolver/JSolverIntVarBlock.class | Bin .../classes/solvers/jsolver/JSolverTermCSP.class | Bin .../classes/solvers/jsolver/JSolverTermSystem.class | Bin .../xmlterm2csp/java/classes/validation/README | 0 .../java/classes/validation/Validation.class | Bin .../classes/validation/ValidationLauncher.class | Bin .../java/classes/validation/solution/README | 0 .../java/classes/validation/solution/Solution.class | Bin .../classes/validation/solution/SolutionValue.class | Bin .../validation/solution/SolvedIntegerVariable.class | Bin .../classes/validation/solution/SolverStatus.class | Bin .../java/classes/validation/system/Constraint.class | Bin .../classes/validation/system/ConstraintBlock.class | Bin .../classes/validation/system/IntegerVarBlock.class | Bin .../java/classes/validation/system/README | 0 .../java/classes/validation/system/TermCSP.class | Bin .../java/classes/validation/system/TermSystem.class | Bin .../classes/validation/util/ChildIterator.class | Bin .../xmlterm2csp/java/classes/validation/util/README | 0 .../java/classes/validation/util/Strategy.class | Bin .../validation/variables/IntegerSymbolTable.class | Bin .../validation/variables/IntegerVariable.class | Bin .../java/classes/validation/variables/README | 0 .../classes/validation/visitor/IntExprVisitor.class | Bin .../validation/visitor/LogicalExprVisitor.class | Bin .../java/classes/validation/visitor/README | 0 .../validation/visitor/XMLVisitAndValidate.class | Bin .../classes/validation/visitor/XMLVisitor.class | Bin .../java/src/exception/AnalyzeException.java | 0 .../java/src/exception/ConstraintException.java | 0 .../xmlterm2csp/java/src/exception/README | 0 .../xmlterm2csp/java/src/expression/Expression.java | 0 .../java/src/expression/ExpressionVisitor.java | 0 .../xmlterm2csp/java/src/expression/README | 0 .../expression/integer/BinaryIntegerExpression.java | 0 .../src/expression/integer/IntegerExpression.java | 0 .../java/src/expression/integer/IntegerLiteral.java | 0 .../src/expression/integer/MinusExpression.java | 0 .../java/src/expression/integer/PlusExpression.java | 0 .../java/src/expression/integer/TimeExpression.java | 0 .../java/src/expression/logical/AndExpression.java | 0 .../expression/logical/BinaryLogicalOperator.java | 0 .../src/expression/logical/EqualExpression.java | 0 .../expression/logical/GreatEqualExpression.java | 0 .../src/expression/logical/GreatExpression.java | 0 .../src/expression/logical/ImpliesExpression.java | 0 .../src/expression/logical/LessEqualExpression.java | 0 .../java/src/expression/logical/LessExpression.java | 0 .../src/expression/logical/LogicalExpression.java | 0 .../java/src/expression/logical/NotExpression.java | 0 .../java/src/expression/logical/OrExpression.java | 0 .../xmlterm2csp/java/src/solvers/README | 0 .../solvers/jsolver/JSolverExpressionVisitor.java | 0 .../xmlterm2csp/java/src/validation/README | 0 .../xmlterm2csp/java/src/validation/Validation.java | 0 .../java/src/validation/ValidationLauncher.java | 0 .../xmlterm2csp/java/src/validation/solution/README | 0 .../java/src/validation/system/Constraint.java | 0 .../xmlterm2csp/java/src/validation/system/README | 0 .../java/src/validation/system/TermSystem.java | 0 .../java/src/validation/util/ChildIterator.java | 0 .../xmlterm2csp/java/src/validation/util/README | 0 .../java/src/validation/util/Strategy.java | 0 .../src/validation/variables/IntegerVariable.java | 0 .../java/src/validation/variables/README | 0 .../java/src/validation/visitor/IntExprVisitor.java | 0 .../src/validation/visitor/LogicalExprVisitor.java | 0 .../xmlterm2csp/java/src/validation/visitor/README | 0 .../java/src/validation/visitor/XMLVisitor.java | 0 .../constraintSolver/xmlterm2csp/xml/term.css | 0 .../constraintSolver/xmlterm2csp/xml/term.dtd | 0 examples/temporal_deep/src/Holmakefile | 0 .../temporal_deep/src/deep_embeddings/Holmakefile | 0 .../src/deep_embeddings/automaton_formulaScript.sml | 0 .../src/deep_embeddings/infinite_pathScript.sml | 0 .../temporal_deep/src/deep_embeddings/ltlScript.sml | 0 .../src/deep_embeddings/prop_logicScript.sml | 0 .../src/deep_embeddings/rltlScript.sml | 0 .../src/deep_embeddings/semi_automatonScript.sml | 0 .../symbolic_semi_automatonScript.sml | 0 .../temporal_deep_simplificationsLib.sig | 0 .../src/deep_embeddings/xprop_logicScript.sml | 0 examples/temporal_deep/src/examples/Holmakefile | 0 examples/temporal_deep/src/model_check/Holmakefile | 0 examples/temporal_deep/src/tools/Holmakefile | 0 .../temporal_deep/src/tools/psl_lemmataScript.sml | 0 .../temporal_deep/src/tools/set_lemmataScript.sml | 0 .../src/tools/temporal_deep_mixedScript.sml | 0 .../temporal_deep/src/tools/tuerk_tacticsLib.sig | 0 .../temporal_deep/src/tools/tuerk_tacticsLib.sml | 0 examples/temporal_deep/src/translations/Holmakefile | 0 .../src/translations/psl_to_rltlScript.sml | 0 .../src/translations/rltl_to_ltlScript.sml | 0 146 files changed, 0 insertions(+), 0 deletions(-) mode change 100755 => 100644 examples/PSL/1.01/executable-semantics/README mode change 100755 => 100644 examples/PSL/1.01/parser/README mode change 100755 => 100644 examples/acl2/ml/signedintScript.sml mode change 100755 => 100644 examples/acl2/ml/testACL2encoding.ml mode change 100755 => 100644 examples/acl2/ml/testTypesScript.sml mode change 100755 => 100644 examples/decidable_separationLogic/src/decidable_separationLogicScript.sml mode change 100755 => 100644 examples/dev/sw2/test/elliptic.751.for.magnus mode change 100755 => 100644 examples/dev/sw2/test/f32.hand.compiled mode change 100755 => 100644 examples/diningcryptos/extra_boolScript.sml mode change 100755 => 100644 examples/diningcryptos/extra_listScript.sml mode change 100755 => 100644 examples/diningcryptos/extra_numScript.sml mode change 100755 => 100644 examples/diningcryptos/extra_pred_setScript.sml mode change 100755 => 100644 examples/diningcryptos/extra_realScript.sml mode change 100755 => 100644 examples/diningcryptos/formalizeUseful.sig mode change 100755 => 100644 examples/diningcryptos/formalizeUseful.sml mode change 100755 => 100644 examples/diningcryptos/measureScript.sml mode change 100755 => 100644 examples/diningcryptos/subtypeScript.sml mode change 100755 => 100644 examples/diningcryptos/subtypeUseful.sig mode change 100755 => 100644 examples/diningcryptos/subtypeUseful.sml mode change 100755 => 100644 examples/elliptic/swsep/Holmakefile mode change 100755 => 100644 examples/elliptic/swsep/examples.sml mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/exception/AnalyzeException.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/exception/ConstraintException.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/exception/README mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/exception/ValidationException.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/Expression.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/ExpressionVisitor.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/README mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/integer/BinaryIntegerExpression.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/integer/DivExpression.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/integer/IntegerExpression.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/integer/IntegerLiteral.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/integer/MinusExpression.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/integer/PlusExpression.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/integer/TimeExpression.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/logical/AndExpression.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/logical/BinaryLogicalOperator.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/logical/Comparator.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/logical/EqualExpression.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/logical/GreatEqualExpression.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/logical/GreatExpression.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/logical/ImpliesExpression.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/logical/LessEqualExpression.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/logical/LessExpression.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/logical/LogicalExpression.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/logical/NotExpression.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/logical/OrExpression.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/solvers/ConcreteSolver.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/solvers/README mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/solvers/Solver.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/solvers/jsolver/JSolver.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/solvers/jsolver/JSolverConstraintBlock.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/solvers/jsolver/JSolverExpressionVisitor.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/solvers/jsolver/JSolverIntVarBlock.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/solvers/jsolver/JSolverTermCSP.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/solvers/jsolver/JSolverTermSystem.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/README mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/Validation.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/ValidationLauncher.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/solution/README mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/solution/Solution.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/solution/SolutionValue.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/solution/SolvedIntegerVariable.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/solution/SolverStatus.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/system/Constraint.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/system/ConstraintBlock.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/system/IntegerVarBlock.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/system/README mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/system/TermCSP.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/system/TermSystem.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/util/ChildIterator.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/util/README mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/util/Strategy.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/variables/IntegerSymbolTable.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/variables/IntegerVariable.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/variables/README mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/visitor/IntExprVisitor.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/visitor/LogicalExprVisitor.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/visitor/README mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/visitor/XMLVisitAndValidate.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/visitor/XMLVisitor.class mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/exception/AnalyzeException.java mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/exception/ConstraintException.java mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/exception/README mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/Expression.java mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/ExpressionVisitor.java mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/README mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/integer/BinaryIntegerExpression.java mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/integer/IntegerExpression.java mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/integer/IntegerLiteral.java mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/integer/MinusExpression.java mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/integer/PlusExpression.java mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/integer/TimeExpression.java mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/logical/AndExpression.java mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/logical/BinaryLogicalOperator.java mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/logical/EqualExpression.java mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/logical/GreatEqualExpression.java mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/logical/GreatExpression.java mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/logical/ImpliesExpression.java mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/logical/LessEqualExpression.java mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/logical/LessExpression.java mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/logical/LogicalExpression.java mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/logical/NotExpression.java mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/logical/OrExpression.java mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/solvers/README mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/solvers/jsolver/JSolverExpressionVisitor.java mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/README mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/Validation.java mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/ValidationLauncher.java mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/solution/README mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/system/Constraint.java mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/system/README mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/system/TermSystem.java mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/util/ChildIterator.java mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/util/README mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/util/Strategy.java mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/variables/IntegerVariable.java mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/variables/README mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/visitor/IntExprVisitor.java mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/visitor/LogicalExprVisitor.java mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/visitor/README mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/visitor/XMLVisitor.java mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/xml/term.css mode change 100755 => 100644 examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/xml/term.dtd mode change 100755 => 100644 examples/temporal_deep/src/Holmakefile mode change 100755 => 100644 examples/temporal_deep/src/deep_embeddings/Holmakefile mode change 100755 => 100644 examples/temporal_deep/src/deep_embeddings/automaton_formulaScript.sml mode change 100755 => 100644 examples/temporal_deep/src/deep_embeddings/infinite_pathScript.sml mode change 100755 => 100644 examples/temporal_deep/src/deep_embeddings/ltlScript.sml mode change 100755 => 100644 examples/temporal_deep/src/deep_embeddings/prop_logicScript.sml mode change 100755 => 100644 examples/temporal_deep/src/deep_embeddings/rltlScript.sml mode change 100755 => 100644 examples/temporal_deep/src/deep_embeddings/semi_automatonScript.sml mode change 100755 => 100644 examples/temporal_deep/src/deep_embeddings/symbolic_semi_automatonScript.sml mode change 100755 => 100644 examples/temporal_deep/src/deep_embeddings/temporal_deep_simplificationsLib.sig mode change 100755 => 100644 examples/temporal_deep/src/deep_embeddings/xprop_logicScript.sml mode change 100755 => 100644 examples/temporal_deep/src/examples/Holmakefile mode change 100755 => 100644 examples/temporal_deep/src/model_check/Holmakefile mode change 100755 => 100644 examples/temporal_deep/src/tools/Holmakefile mode change 100755 => 100644 examples/temporal_deep/src/tools/psl_lemmataScript.sml mode change 100755 => 100644 examples/temporal_deep/src/tools/set_lemmataScript.sml mode change 100755 => 100644 examples/temporal_deep/src/tools/temporal_deep_mixedScript.sml mode change 100755 => 100644 examples/temporal_deep/src/tools/tuerk_tacticsLib.sig mode change 100755 => 100644 examples/temporal_deep/src/tools/tuerk_tacticsLib.sml mode change 100755 => 100644 examples/temporal_deep/src/translations/Holmakefile mode change 100755 => 100644 examples/temporal_deep/src/translations/psl_to_rltlScript.sml mode change 100755 => 100644 examples/temporal_deep/src/translations/rltl_to_ltlScript.sml diff --git a/examples/PSL/1.01/executable-semantics/README b/examples/PSL/1.01/executable-semantics/README old mode 100755 new mode 100644 diff --git a/examples/PSL/1.01/parser/README b/examples/PSL/1.01/parser/README old mode 100755 new mode 100644 diff --git a/examples/acl2/ml/signedintScript.sml b/examples/acl2/ml/signedintScript.sml old mode 100755 new mode 100644 diff --git a/examples/acl2/ml/testACL2encoding.ml b/examples/acl2/ml/testACL2encoding.ml old mode 100755 new mode 100644 diff --git a/examples/acl2/ml/testTypesScript.sml b/examples/acl2/ml/testTypesScript.sml old mode 100755 new mode 100644 diff --git a/examples/decidable_separationLogic/src/decidable_separationLogicScript.sml b/examples/decidable_separationLogic/src/decidable_separationLogicScript.sml old mode 100755 new mode 100644 diff --git a/examples/dev/sw2/test/elliptic.751.for.magnus b/examples/dev/sw2/test/elliptic.751.for.magnus old mode 100755 new mode 100644 diff --git a/examples/dev/sw2/test/f32.hand.compiled b/examples/dev/sw2/test/f32.hand.compiled old mode 100755 new mode 100644 diff --git a/examples/diningcryptos/extra_boolScript.sml b/examples/diningcryptos/extra_boolScript.sml old mode 100755 new mode 100644 diff --git a/examples/diningcryptos/extra_listScript.sml b/examples/diningcryptos/extra_listScript.sml old mode 100755 new mode 100644 diff --git a/examples/diningcryptos/extra_numScript.sml b/examples/diningcryptos/extra_numScript.sml old mode 100755 new mode 100644 diff --git a/examples/diningcryptos/extra_pred_setScript.sml b/examples/diningcryptos/extra_pred_setScript.sml old mode 100755 new mode 100644 diff --git a/examples/diningcryptos/extra_realScript.sml b/examples/diningcryptos/extra_realScript.sml old mode 100755 new mode 100644 diff --git a/examples/diningcryptos/formalizeUseful.sig b/examples/diningcryptos/formalizeUseful.sig old mode 100755 new mode 100644 diff --git a/examples/diningcryptos/formalizeUseful.sml b/examples/diningcryptos/formalizeUseful.sml old mode 100755 new mode 100644 diff --git a/examples/diningcryptos/measureScript.sml b/examples/diningcryptos/measureScript.sml old mode 100755 new mode 100644 diff --git a/examples/diningcryptos/subtypeScript.sml b/examples/diningcryptos/subtypeScript.sml old mode 100755 new mode 100644 diff --git a/examples/diningcryptos/subtypeUseful.sig b/examples/diningcryptos/subtypeUseful.sig old mode 100755 new mode 100644 diff --git a/examples/diningcryptos/subtypeUseful.sml b/examples/diningcryptos/subtypeUseful.sml old mode 100755 new mode 100644 diff --git a/examples/elliptic/swsep/Holmakefile b/examples/elliptic/swsep/Holmakefile old mode 100755 new mode 100644 diff --git a/examples/elliptic/swsep/examples.sml b/examples/elliptic/swsep/examples.sml old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/exception/AnalyzeException.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/exception/AnalyzeException.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/exception/ConstraintException.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/exception/ConstraintException.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/exception/README b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/exception/README old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/exception/ValidationException.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/exception/ValidationException.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/Expression.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/Expression.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/ExpressionVisitor.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/ExpressionVisitor.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/README b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/README old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/integer/BinaryIntegerExpression.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/integer/BinaryIntegerExpression.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/integer/DivExpression.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/integer/DivExpression.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/integer/IntegerExpression.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/integer/IntegerExpression.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/integer/IntegerLiteral.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/integer/IntegerLiteral.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/integer/MinusExpression.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/integer/MinusExpression.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/integer/PlusExpression.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/integer/PlusExpression.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/integer/TimeExpression.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/integer/TimeExpression.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/logical/AndExpression.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/logical/AndExpression.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/logical/BinaryLogicalOperator.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/logical/BinaryLogicalOperator.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/logical/Comparator.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/logical/Comparator.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/logical/EqualExpression.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/logical/EqualExpression.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/logical/GreatEqualExpression.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/logical/GreatEqualExpression.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/logical/GreatExpression.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/logical/GreatExpression.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/logical/ImpliesExpression.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/logical/ImpliesExpression.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/logical/LessEqualExpression.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/logical/LessEqualExpression.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/logical/LessExpression.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/logical/LessExpression.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/logical/LogicalExpression.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/logical/LogicalExpression.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/logical/NotExpression.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/logical/NotExpression.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/logical/OrExpression.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/expression/logical/OrExpression.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/solvers/ConcreteSolver.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/solvers/ConcreteSolver.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/solvers/README b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/solvers/README old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/solvers/Solver.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/solvers/Solver.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/solvers/jsolver/JSolver.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/solvers/jsolver/JSolver.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/solvers/jsolver/JSolverConstraintBlock.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/solvers/jsolver/JSolverConstraintBlock.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/solvers/jsolver/JSolverExpressionVisitor.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/solvers/jsolver/JSolverExpressionVisitor.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/solvers/jsolver/JSolverIntVarBlock.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/solvers/jsolver/JSolverIntVarBlock.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/solvers/jsolver/JSolverTermCSP.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/solvers/jsolver/JSolverTermCSP.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/solvers/jsolver/JSolverTermSystem.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/solvers/jsolver/JSolverTermSystem.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/README b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/README old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/Validation.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/Validation.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/ValidationLauncher.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/ValidationLauncher.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/solution/README b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/solution/README old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/solution/Solution.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/solution/Solution.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/solution/SolutionValue.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/solution/SolutionValue.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/solution/SolvedIntegerVariable.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/solution/SolvedIntegerVariable.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/solution/SolverStatus.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/solution/SolverStatus.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/system/Constraint.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/system/Constraint.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/system/ConstraintBlock.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/system/ConstraintBlock.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/system/IntegerVarBlock.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/system/IntegerVarBlock.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/system/README b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/system/README old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/system/TermCSP.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/system/TermCSP.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/system/TermSystem.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/system/TermSystem.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/util/ChildIterator.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/util/ChildIterator.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/util/README b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/util/README old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/util/Strategy.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/util/Strategy.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/variables/IntegerSymbolTable.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/variables/IntegerSymbolTable.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/variables/IntegerVariable.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/variables/IntegerVariable.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/variables/README b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/variables/README old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/visitor/IntExprVisitor.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/visitor/IntExprVisitor.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/visitor/LogicalExprVisitor.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/visitor/LogicalExprVisitor.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/visitor/README b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/visitor/README old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/visitor/XMLVisitAndValidate.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/visitor/XMLVisitAndValidate.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/visitor/XMLVisitor.class b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/classes/validation/visitor/XMLVisitor.class old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/exception/AnalyzeException.java b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/exception/AnalyzeException.java old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/exception/ConstraintException.java b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/exception/ConstraintException.java old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/exception/README b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/exception/README old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/Expression.java b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/Expression.java old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/ExpressionVisitor.java b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/ExpressionVisitor.java old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/README b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/README old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/integer/BinaryIntegerExpression.java b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/integer/BinaryIntegerExpression.java old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/integer/IntegerExpression.java b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/integer/IntegerExpression.java old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/integer/IntegerLiteral.java b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/integer/IntegerLiteral.java old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/integer/MinusExpression.java b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/integer/MinusExpression.java old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/integer/PlusExpression.java b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/integer/PlusExpression.java old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/integer/TimeExpression.java b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/integer/TimeExpression.java old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/logical/AndExpression.java b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/logical/AndExpression.java old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/logical/BinaryLogicalOperator.java b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/logical/BinaryLogicalOperator.java old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/logical/EqualExpression.java b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/logical/EqualExpression.java old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/logical/GreatEqualExpression.java b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/logical/GreatEqualExpression.java old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/logical/GreatExpression.java b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/logical/GreatExpression.java old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/logical/ImpliesExpression.java b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/logical/ImpliesExpression.java old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/logical/LessEqualExpression.java b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/logical/LessEqualExpression.java old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/logical/LessExpression.java b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/logical/LessExpression.java old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/logical/LogicalExpression.java b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/logical/LogicalExpression.java old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/logical/NotExpression.java b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/logical/NotExpression.java old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/logical/OrExpression.java b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/expression/logical/OrExpression.java old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/solvers/README b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/solvers/README old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/solvers/jsolver/JSolverExpressionVisitor.java b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/solvers/jsolver/JSolverExpressionVisitor.java old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/README b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/README old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/Validation.java b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/Validation.java old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/ValidationLauncher.java b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/ValidationLauncher.java old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/solution/README b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/solution/README old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/system/Constraint.java b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/system/Constraint.java old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/system/README b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/system/README old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/system/TermSystem.java b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/system/TermSystem.java old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/util/ChildIterator.java b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/util/ChildIterator.java old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/util/README b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/util/README old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/util/Strategy.java b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/util/Strategy.java old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/variables/IntegerVariable.java b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/variables/IntegerVariable.java old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/variables/README b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/variables/README old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/visitor/IntExprVisitor.java b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/visitor/IntExprVisitor.java old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/visitor/LogicalExprVisitor.java b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/visitor/LogicalExprVisitor.java old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/visitor/README b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/visitor/README old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/visitor/XMLVisitor.java b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/java/src/validation/visitor/XMLVisitor.java old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/xml/term.css b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/xml/term.css old mode 100755 new mode 100644 diff --git a/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/xml/term.dtd b/examples/opsemTools/verify/solvers/constraintSolver/xmlterm2csp/xml/term.dtd old mode 100755 new mode 100644 diff --git a/examples/temporal_deep/src/Holmakefile b/examples/temporal_deep/src/Holmakefile old mode 100755 new mode 100644 diff --git a/examples/temporal_deep/src/deep_embeddings/Holmakefile b/examples/temporal_deep/src/deep_embeddings/Holmakefile old mode 100755 new mode 100644 diff --git a/examples/temporal_deep/src/deep_embeddings/automaton_formulaScript.sml b/examples/temporal_deep/src/deep_embeddings/automaton_formulaScript.sml old mode 100755 new mode 100644 diff --git a/examples/temporal_deep/src/deep_embeddings/infinite_pathScript.sml b/examples/temporal_deep/src/deep_embeddings/infinite_pathScript.sml old mode 100755 new mode 100644 diff --git a/examples/temporal_deep/src/deep_embeddings/ltlScript.sml b/examples/temporal_deep/src/deep_embeddings/ltlScript.sml old mode 100755 new mode 100644 diff --git a/examples/temporal_deep/src/deep_embeddings/prop_logicScript.sml b/examples/temporal_deep/src/deep_embeddings/prop_logicScript.sml old mode 100755 new mode 100644 diff --git a/examples/temporal_deep/src/deep_embeddings/rltlScript.sml b/examples/temporal_deep/src/deep_embeddings/rltlScript.sml old mode 100755 new mode 100644 diff --git a/examples/temporal_deep/src/deep_embeddings/semi_automatonScript.sml b/examples/temporal_deep/src/deep_embeddings/semi_automatonScript.sml old mode 100755 new mode 100644 diff --git a/examples/temporal_deep/src/deep_embeddings/symbolic_semi_automatonScript.sml b/examples/temporal_deep/src/deep_embeddings/symbolic_semi_automatonScript.sml old mode 100755 new mode 100644 diff --git a/examples/temporal_deep/src/deep_embeddings/temporal_deep_simplificationsLib.sig b/examples/temporal_deep/src/deep_embeddings/temporal_deep_simplificationsLib.sig old mode 100755 new mode 100644 diff --git a/examples/temporal_deep/src/deep_embeddings/xprop_logicScript.sml b/examples/temporal_deep/src/deep_embeddings/xprop_logicScript.sml old mode 100755 new mode 100644 diff --git a/examples/temporal_deep/src/examples/Holmakefile b/examples/temporal_deep/src/examples/Holmakefile old mode 100755 new mode 100644 diff --git a/examples/temporal_deep/src/model_check/Holmakefile b/examples/temporal_deep/src/model_check/Holmakefile old mode 100755 new mode 100644 diff --git a/examples/temporal_deep/src/tools/Holmakefile b/examples/temporal_deep/src/tools/Holmakefile old mode 100755 new mode 100644 diff --git a/examples/temporal_deep/src/tools/psl_lemmataScript.sml b/examples/temporal_deep/src/tools/psl_lemmataScript.sml old mode 100755 new mode 100644 diff --git a/examples/temporal_deep/src/tools/set_lemmataScript.sml b/examples/temporal_deep/src/tools/set_lemmataScript.sml old mode 100755 new mode 100644 diff --git a/examples/temporal_deep/src/tools/temporal_deep_mixedScript.sml b/examples/temporal_deep/src/tools/temporal_deep_mixedScript.sml old mode 100755 new mode 100644 diff --git a/examples/temporal_deep/src/tools/tuerk_tacticsLib.sig b/examples/temporal_deep/src/tools/tuerk_tacticsLib.sig old mode 100755 new mode 100644 diff --git a/examples/temporal_deep/src/tools/tuerk_tacticsLib.sml b/examples/temporal_deep/src/tools/tuerk_tacticsLib.sml old mode 100755 new mode 100644 diff --git a/examples/temporal_deep/src/translations/Holmakefile b/examples/temporal_deep/src/translations/Holmakefile old mode 100755 new mode 100644 diff --git a/examples/temporal_deep/src/translations/psl_to_rltlScript.sml b/examples/temporal_deep/src/translations/psl_to_rltlScript.sml old mode 100755 new mode 100644 diff --git a/examples/temporal_deep/src/translations/rltl_to_ltlScript.sml b/examples/temporal_deep/src/translations/rltl_to_ltlScript.sml old mode 100755 new mode 100644 From 5d03167e244f3e73bdc79bc503b3c5dca436104b Mon Sep 17 00:00:00 2001 From: Piotr Trojanek Date: Wed, 4 Feb 2015 21:18:02 +0000 Subject: [PATCH 166/718] code style: space after parenthesis in "(x*y)list" --- src/datatype/DataSize.sig | 2 +- src/meson/src/Canon_Port.sig | 6 +++--- src/num/arith/src/Term_coeffs.sig | 2 +- src/postkernel/Theory.sig | 2 +- src/res_quan/src/Cond_rewrite.sig | 2 +- 5 files changed, 7 insertions(+), 7 deletions(-) diff --git a/src/datatype/DataSize.sig b/src/datatype/DataSize.sig index f32b8e5ced..1c1487a37e 100644 --- a/src/datatype/DataSize.sig +++ b/src/datatype/DataSize.sig @@ -4,6 +4,6 @@ sig val define_size : thm -> TypeBasePure.typeBase -> {def : thm, - const_tyopl : (term * (string*string))list} option + const_tyopl : (term * (string*string)) list} option end diff --git a/src/meson/src/Canon_Port.sig b/src/meson/src/Canon_Port.sig index 2829f1cc84..b46c2b87f7 100644 --- a/src/meson/src/Canon_Port.sig +++ b/src/meson/src/Canon_Port.sig @@ -4,8 +4,8 @@ sig val is_eqc : term -> bool val freesl : term list -> term list - val get_thm_heads : thm -> (term*int)list * (term*int) list - -> (term*int)list * (term*int) list + val get_thm_heads : thm -> (term*int) list * (term*int) list + -> (term*int) list * (term*int) list val NNFC_CONV : conv val DELAMB_CONV : conv val PROP_CNF_CONV : conv @@ -13,5 +13,5 @@ sig val SKOLEM_CONV : conv val PRENEX_CONV : conv val REFUTE_THEN : (thm -> tactic) -> tactic - val GEN_FOL_CONV : (term*int)list * (term*int) list -> conv + val GEN_FOL_CONV : (term*int) list * (term*int) list -> conv end diff --git a/src/num/arith/src/Term_coeffs.sig b/src/num/arith/src/Term_coeffs.sig index 5d22b2da18..b3ab229f10 100644 --- a/src/num/arith/src/Term_coeffs.sig +++ b/src/num/arith/src/Term_coeffs.sig @@ -15,7 +15,7 @@ sig val var_of_prod : Term.term -> string val coeffs_of_arith : Term.term -> (int * (string * int) list) val coeffs_of_leq : Term.term -> (int * (string * int) list) - val coeffs_of_leq_set : Term.term -> (int * (string * int)list) list + val coeffs_of_leq_set : Term.term -> (int * (string * int) list) list val build_arith : int * (string * int) list -> Term.term val build_leq : (int * (string * int) list) -> Term.term end diff --git a/src/postkernel/Theory.sig b/src/postkernel/Theory.sig index 6d8a21641e..375ca0075b 100644 --- a/src/postkernel/Theory.sig +++ b/src/postkernel/Theory.sig @@ -100,7 +100,7 @@ sig (* For internal use *) val pp_thm : (ppstream -> thm -> unit) ref - val link_parents : string*num*num -> (string*num*num)list -> unit + val link_parents : string*num*num -> (string*num*num) list -> unit val incorporate_types : string -> (string*int) list -> unit diff --git a/src/res_quan/src/Cond_rewrite.sig b/src/res_quan/src/Cond_rewrite.sig index 8ab02a5aef..05b6a593f7 100644 --- a/src/res_quan/src/Cond_rewrite.sig +++ b/src/res_quan/src/Cond_rewrite.sig @@ -18,7 +18,7 @@ sig val search_top_down :term -> term -> ((term,term)subst * (hol_type,hol_type)subst) list val COND_REWR_CONV - :(term -> term -> ((term,term)subst * (hol_type,hol_type)subst)list) + :(term -> term -> ((term,term)subst * (hol_type,hol_type)subst) list) -> thm -> conv val COND_REWR_CANON : thm -> thm val COND_REWRITE1_TAC : thm_tactic From f318953269b34e203782d819097ef40fb672e78e Mon Sep 17 00:00:00 2001 From: Piotr Trojanek Date: Tue, 10 Feb 2015 00:45:44 +0000 Subject: [PATCH 167/718] extra semicolon removed from code sample There is no semicolon after "new_theory" in this section so there should be no semicolon after "export_theory". --- Manual/Description/description.tex | 1 + Manual/Description/misc.tex | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/Manual/Description/description.tex b/Manual/Description/description.tex index b54b190dad..f324fe6a82 100644 --- a/Manual/Description/description.tex +++ b/Manual/Description/description.tex @@ -20,6 +20,7 @@ \usepackage{../../src/TeX/holtexbasic} \usepackage{fancyvrb} +\hyphenation{docu-ments} % --------------------------------------------------------------------- % Input defined macros and commands diff --git a/Manual/Description/misc.tex b/Manual/Description/misc.tex index 812abc2ac5..07761ffb7b 100644 --- a/Manual/Description/misc.tex +++ b/Manual/Description/misc.tex @@ -211,7 +211,7 @@ \subsection{Source Conventions for Script and SML Files} Finally, all script files should also end with the invocation: \begin{verbatim} - val _ = export_theory(); + val _ = export_theory() \end{verbatim} When the script is finally executed, this call writes the theory to disk. From 85a05f12bb15f55f4ffb5d40248430c4433d9201 Mon Sep 17 00:00:00 2001 From: Magnus Myreen Date: Tue, 10 Feb 2015 12:01:04 +0100 Subject: [PATCH 168/718] split an include to get Holmake to work --- examples/ARM/v7/armLib.sig | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/examples/ARM/v7/armLib.sig b/examples/ARM/v7/armLib.sig index 62633bc6bd..7bcda78e59 100644 --- a/examples/ARM/v7/armLib.sig +++ b/examples/ARM/v7/armLib.sig @@ -4,7 +4,9 @@ sig include arm_parserLib where type arm_code = arm_parserLib.arm_code - include arm_encoderLib arm_disassemblerLib arm_stepLib + include arm_encoderLib + include arm_disassemblerLib + include arm_stepLib val arm_decode : string -> arm_code val thumb_decode : int -> string -> arm_code From 60a839e347a91e683cb57442528bc8150c4e68c8 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 11 Feb 2015 13:12:14 +1100 Subject: [PATCH 169/718] Revise holdep lexer to handle multiple IDs after 'include' Hadn't realised this was valid SML. Code is a little simplified also. --- tools/Holmake/Holdep_tokens.sml | 203 ++++++++++----------- tools/Holmake/tests/holdep/expected_output | 5 + tools/Holmake/tests/holdep/input | 11 ++ 3 files changed, 111 insertions(+), 108 deletions(-) diff --git a/tools/Holmake/Holdep_tokens.sml b/tools/Holmake/Holdep_tokens.sml index 940af1f275..9937de1378 100644 --- a/tools/Holmake/Holdep_tokens.sml +++ b/tools/Holmake/Holdep_tokens.sml @@ -47,57 +47,34 @@ fun advance (c as CR {pos, buffer, maxpos, reader, current, closer}) = datatype SCR = SCR of {linenum : int, filename : string, colnum : int, - currentID : string list option, ids : string Binaryset.set, cr : char_reader} fun makeSCR fname = let val cr = fromFile fname in SCR {linenum = 1, colnum = 0, filename = fname, - currentID = NONE, ids = Binaryset.empty String.compare, - cr = cr} + ids = Binaryset.empty String.compare, cr = cr} end fun SCRfromStream (name, is) = let val cr = fromStream is in SCR {linenum = 1, colnum = 0, filename = name, - currentID = NONE, ids = Binaryset.empty String.compare, - cr = cr} + ids = Binaryset.empty String.compare, cr = cr} end fun currentChar (SCR{cr,...}) = current cr fun closeSCR (SCR{cr,...}) = closeCR cr fun getIDs (SCR{ids,...}) = ids -fun inc (SCR {linenum, filename, colnum, currentID, ids, cr}) = +fun inc (SCR {linenum, filename, colnum, ids, cr}) = SCR{linenum = linenum, filename = filename, colnum = colnum + 1, - currentID = currentID, ids = ids, cr = advance cr} -fun newline (SCR{linenum, filename, colnum, currentID, ids, cr}) = + ids = ids, cr = advance cr} +fun newline (SCR{linenum, filename, colnum, ids, cr}) = SCR{linenum = linenum + 1, filename = filename, colnum = 0, - currentID = NONE, ids = ids, cr = advance cr} -fun newID s (SCR{linenum, filename, colnum, currentID, ids, cr}) = + ids = ids, cr = advance cr} +fun completeID s (SCR{linenum, filename, colnum, ids, cr}) = SCR{linenum = linenum, filename = filename, colnum = colnum, - currentID = SOME [s], ids = ids, cr = cr} -fun extendID c (SCR{linenum, filename, colnum, currentID, ids, cr}) = - case currentID of - SOME strs => - SCR{linenum = linenum, filename = filename, colnum = colnum, - currentID = SOME (str c :: strs), ids = ids, cr = cr} - | NONE => - raise Fail "Invariant failure: extendID with no ID current" -fun completeID s (SCR{linenum, filename, colnum, currentID, ids, cr}) = - SCR{linenum = linenum, filename = filename, colnum = colnum, - currentID = NONE, ids = Binaryset.add(ids, s), cr = cr} -fun finishID (SCR{linenum, filename, colnum, currentID, ids, cr}) = - case currentID of - NONE => raise Fail "Invariant failure: finishID with no ID current" - | SOME strs => - let - val s = String.concat (List.rev strs) - in - SCR{linenum = linenum, filename = filename, colnum = colnum, - currentID = NONE, ids = Binaryset.add(ids, s), cr = cr} - end + ids = Binaryset.add(ids, s), cr = cr} fun mem x [] = false | mem x (y::ys) = x = y orelse mem x ys @@ -118,36 +95,35 @@ fun Error(SCR {filename,colnum,linenum,...}, msg) = fun clean_open scr = case currentChar scr of NONE => scr - | SOME #"d" => openTerminatorPFX "datatype" 1 (inc scr) (* datatype *) + | SOME #"d" => openTermPFX "datatype" 1 (inc scr) | SOME #"e" => opene (inc scr) (* exception, end *) - | SOME #"f" => openTerminatorPFX "fun" 1 (inc scr) + | SOME #"f" => openTermPFX "fun" 1 (inc scr) | SOME #"i" => openi (inc scr) (* in, infixl, infix, infixr *) - | SOME #"l" => openTerminatorPFX "local" 1 (inc scr) - | SOME #"n" => openTerminatorPFX "nonfix" 1 (inc scr) - | SOME #"o" => openAlphaKWordPFX "open" 1 clean_open (inc scr) - | SOME #"p" => openTerminatorPFX "prim_val" 1 (inc scr) + | SOME #"l" => openTermPFX "local" 1 (inc scr) + | SOME #"n" => openTermPFX "nonfix" 1 (inc scr) + | SOME #"o" => modTermPFX true "open" 1 (clean_open, clean_open) (inc scr) + | SOME #"p" => openTermPFX "prim_val" 1 (inc scr) | SOME #"s" => opens (inc scr) (* structure, signature *) - | SOME #"t" => openTerminatorPFX "type" 1 (inc scr) - | SOME #"v" => openTerminatorPFX "val" 1 (inc scr) + | SOME #"t" => openTermPFX "type" 1 (inc scr) + | SOME #"v" => openTermPFX "val" 1 (inc scr) | SOME #";" => clean_initial (inc scr) | SOME #"(" => openLPAREN (inc scr) | SOME #"#" => openHASH (inc scr) | SOME #"\n" => clean_open (newline scr) | SOME c => if Char.isSpace c then clean_open (inc scr) else if Char.isAlpha c then - openAlphaID (scr |> inc |> newID (str c)) + modAlphaID true clean_open ("", [c]) (scr |> inc) else if isSMLSym c then - openSymID (scr |> inc |> newID (str c)) + modSymID true clean_open [c] (scr |> inc) else Error(scr, "Bad character >"^str c^"< after open") -and openTerminatorPFX kword cnt scr = - openAlphaKWordPFX kword cnt clean_initial scr -and openOnTerminator kword scr = - openOnKWord kword clean_initial scr +and openTermPFX kstr c scr = + modTermPFX true kstr c (clean_initial, clean_open) scr +and openOnKWord kstr scr = OnKWord true kstr (clean_initial, clean_open) scr and opene scr = case currentChar scr of NONE => scr |> completeID "e" - | SOME #"n" => openTerminatorPFX "end" 2 (inc scr) - | SOME #"x" => openTerminatorPFX "exception" 2 (inc scr) + | SOME #"n" => openTermPFX "end" 2 (inc scr) + | SOME #"x" => openTermPFX "exception" 2 (inc scr) | SOME c => extend_openAlpha "e" c scr and openi scr = case currentChar scr of @@ -158,7 +134,7 @@ and openin scr = case currentChar scr of NONE => Error(scr, "Don't expect to see 'in'-EOF") | SOME #"f" => scr |> inc |> openinf - | SOME c => openOnTerminator "in" scr + | SOME c => openOnKWord "in" scr and openinf scr = case currentChar scr of NONE => scr |> completeID "inf" @@ -172,15 +148,22 @@ and openinfi scr = and openinfix scr = case currentChar scr of NONE => Error(scr, "Don't expect to see 'infix'-EOF") - | SOME #"l" => openOnTerminator "infixl" (inc scr) - | SOME #"r" => openOnTerminator "infixr" (inc scr) - | SOME c => openOnTerminator "infix" scr + | SOME #"l" => openOnKWord "infixl" (inc scr) + | SOME #"r" => openOnKWord "infixr" (inc scr) + | SOME c => openOnKWord "infix" scr and opens scr = case currentChar scr of NONE => scr |> completeID "s" - | SOME #"i" => openTerminatorPFX "signature" 2 (inc scr) - | SOME #"t" => openTerminatorPFX "structure" 2 (inc scr) + | SOME #"i" => openTermPFX "signature" 2 (inc scr) + | SOME #"t" => openTermPFX "structure" 2 (inc scr) | SOME c => extend_openAlpha "s" c scr +and extend_openAlpha pfx c scr = + if Char.isSpace c then clean_open (scr |> inc |> completeID pfx) + else if isSMLAlphaCont c then + modAlphaID true clean_open (pfx, [c]) (scr |> inc) + else if isSMLSym c then + modSymID true clean_open [c] (scr |> inc |> completeID pfx) + else Error(scr, "Bad character >"^str c^"< after 'open'") and openLPAREN scr = case currentChar scr of NONE => Error(scr, "Don't expect to see '('-EOF") @@ -190,22 +173,8 @@ and openHASH scr = case currentChar scr of NONE => Error(scr, "Don't expect to see 'open'-'#'") | SOME c => if isSMLSym c then - openSymID (scr |> inc |> newID ("#" ^ str c)) + modSymID true clean_open [c,#"#"] (scr |> inc) else Error(scr, "Don't expect to see 'open'-'#'") -and openAlphaID scr = - case currentChar scr of - NONE => scr |> finishID - | SOME #"." => openQID0 (scr |> inc |> finishID) - | SOME c => if isSMLAlphaCont c then - openAlphaID (scr |> inc |> extendID c) - else - clean_open (scr |> finishID) -and openSymID scr = - case currentChar scr of - NONE => scr |> finishID - | SOME #"." => openQID0 (scr |> inc |> finishID) - | SOME c => if isSMLSym c then openSymID (scr |> inc |> extendID c) - else clean_open (scr |> finishID) and openQID0 scr = (* seen the dot *) case currentChar scr of NONE => Error(scr, "'.'-EOF unexpected") @@ -224,55 +193,45 @@ and openQIDsym scr = | SOME #"." => openQID0 (inc scr) | SOME c => if isSMLSym c then openQIDsym (inc scr) else clean_open scr -and openAlphaKWordPFX kword numseen k scr = let +and modTermPFX dotok kword numseen (seenk, notk) scr = let fun get() = String.extract(kword, 0, SOME numseen) in case currentChar scr of - NONE => scr |> completeID (get()) + NONE => notk (scr |> completeID (get())) | SOME c => if c = String.sub(kword, numseen) then if numseen + 1 = size kword then - openOnKWord kword k (inc scr) - else openAlphaKWordPFX kword (numseen + 1) k (inc scr) + OnKWord dotok kword (seenk,notk) (inc scr) + else + modTermPFX dotok kword (numseen + 1) (seenk,notk) (inc scr) else if isSMLAlphaCont c then - extend_openAlpha (get()) c scr - else clean_open (scr |> completeID (get())) + modAlphaID dotok notk (get(), [c]) (inc scr) + else notk (scr |> completeID (get())) end -and openOnKWord kword k scr = +and OnKWord dotok kword (seenk,notseenk) scr = case currentChar scr of - NONE => k scr + NONE => seenk scr | SOME c => if isSMLAlphaCont c then - extend_openAlpha kword c scr - else k scr -and extend_openAlpha pfx c scr = - if Char.isSpace c then clean_open (scr |> inc |> completeID pfx) - else if isSMLAlphaCont c then - openAlphaID (scr |> inc |> newID (pfx ^ str c)) - else if isSMLSym c then - openSymID (scr |> inc |> completeID pfx |> newID (str c)) - else Error(scr, "Bad character >"^str c^"< after 'open'") -and extend_openKeyword kword c scr = - if Char.isSpace c then Error(scr, "Don't expect to see '"^kword^"' after 'open'") - else if Char.isAlpha c then - openAlphaID (scr |> inc |> newID (kword ^ str c)) - else if isSMLSym c then - Error(scr, "Don't expect to see '"^kword^"' after 'open'") - else Error(scr, "Bad character >"^str c^"< after 'open'") -and extend_openTerminator kword c scr = - if c = #"\n" then clean_initial (scr |> newline) - else if Char.isSpace c then clean_initial (scr |> inc) - else if Char.isAlpha c then - openAlphaID (scr |> inc |> newID (kword ^ str c)) - else clean_initial (scr |> inc) -and includeALPHA cs scr = + modAlphaID dotok notseenk (kword, [c]) (inc scr) + else seenk scr +and modAlphaID dotok k (base,cs) scr = case currentChar scr of - NONE => scr |> completeID (implode (List.rev cs)) - | SOME c => if isSMLAlphaCont c then includeALPHA (c::cs) (inc scr) - else clean_initial (scr |> completeID (implode (List.rev cs))) -and includeSYM cs scr = + NONE => scr |> completeID (base ^ implode (List.rev cs)) + | SOME #"." => + if dotok then + openQID0 (scr |> inc |> completeID (base ^ implode (List.rev cs))) + else Error(scr, "Didn't expect to see qualified ident here") + | SOME c => + if isSMLAlphaCont c then modAlphaID dotok k (base,c::cs) (inc scr) + else k (scr |> completeID (base ^ implode (List.rev cs))) +and modSymID dotok k cs scr = case currentChar scr of NONE => scr |> completeID (implode (List.rev cs)) - | SOME c => if isSMLSym c then includeSYM (c::cs) (inc scr) - else clean_initial (scr |> completeID (implode (List.rev cs))) + | SOME #"." => + if dotok then + openQID0 (scr |> inc |> completeID (implode (List.rev cs))) + else Error(scr, "Didn't expect to see qualified ident here") + | SOME c => if isSMLSym c then modSymID dotok k (c::cs) (inc scr) + else k (scr |> completeID (implode (List.rev cs))) and includeLPAR scr = case currentChar scr of NONE => Error(scr, "Don't expect 'include'-'('-EOF") @@ -280,12 +239,40 @@ and includeLPAR scr = | SOME c => Error(scr, "Don't expect 'include'-'('-'"^str c^"'") and clean_include scr = case currentChar scr of - NONE => Error(scr, "Don't expect to see 'include'-EOF") + NONE => scr + | SOME #"d" => + modTermPFX false "datatype" 1 (clean_initial, clean_include) (inc scr) + | SOME #"e" => includee (inc scr) + | SOME #"s" => + modTermPFX false "structure" 1 (clean_initial, clean_include) (inc scr) + | SOME #"t" => + modTermPFX false "type" 1 (clean_initial, clean_include) (inc scr) + | SOME #"v" => + modTermPFX false "val" 1 (clean_initial, clean_include) (inc scr) + | SOME #"w" => + modTermPFX false "where" 1 (clean_initial, clean_include) (inc scr) | SOME #"\n" => clean_include (newline scr) | SOME #"(" => includeLPAR (inc scr) + | SOME #";" => clean_initial (inc scr) | SOME c => if Char.isSpace c then clean_include (inc scr) - else if Char.isAlpha c then includeALPHA [c] (inc scr) - else if isSMLSym c then includeSYM [c] (inc scr) + else if Char.isAlpha c then + modAlphaID false clean_include ("", [c]) (inc scr) + else if isSMLSym c then + modSymID false clean_include [c] (inc scr) + else Error(scr, "Bad character >"^str c^"< after 'include'") +and includee scr = + case currentChar scr of + NONE => scr |> completeID "e" + | SOME #"\n" => clean_include (scr |> newline |> completeID "e") + | SOME #"n" => + modTermPFX false "end" 2 (clean_initial, clean_include) (inc scr) + | SOME #"x" => + modTermPFX false "exception" 2 (clean_initial, clean_include) (inc scr) + | SOME c => if Char.isSpace c then clean_include (scr |> inc |> completeID "e") + else if isSMLSym c then + modSymID false clean_include [c] (scr |> inc |> completeID "e") + else if isSMLAlphaCont c then + modAlphaID false clean_include ("e", [c]) (inc scr) else Error(scr, "Bad character >"^str c^"< after 'include'") and clean_initial scr = case currentChar scr of diff --git a/tools/Holmake/tests/holdep/expected_output b/tools/Holmake/tests/holdep/expected_output index de7334eb7e..94b2274b34 100644 --- a/tools/Holmake/tests/holdep/expected_output +++ b/tools/Holmake/tests/holdep/expected_output @@ -8,6 +8,11 @@ baz data1 data2 foo +included1 +included2 +included3 +included4 +included5 included_module' inf m31 diff --git a/tools/Holmake/tests/holdep/input b/tools/Holmake/tests/holdep/input index d603bc0ec8..525cec70e7 100644 --- a/tools/Holmake/tests/holdep/input +++ b/tools/Holmake/tests/holdep/input @@ -23,3 +23,14 @@ fun f x = Opopen.x + qidcolon.::> include included_module' type extrastate = base_lexer.UserDecs.extrastate + +include included1 included2 +val x : int + +include included3 ; +val y : int + +include included4 +datatype datafoo + +include included5 where type t = int From d64d43d5ab64cd24571dc3d3966dd365325ffb62 Mon Sep 17 00:00:00 2001 From: Magnus Myreen Date: Wed, 11 Feb 2015 09:21:36 +0100 Subject: [PATCH 170/718] gave lrnext a better def w.r.t. CakeML translator --- .../soundness-thm/milawa_soundnessScript.sml | 2 +- src/patricia/sptreeScript.sml | 26 ++++++++++++++----- 2 files changed, 20 insertions(+), 8 deletions(-) diff --git a/examples/theorem-prover/milawa-prover/soundness-thm/milawa_soundnessScript.sml b/examples/theorem-prover/milawa-prover/soundness-thm/milawa_soundnessScript.sml index 28178360c3..00ead980e1 100644 --- a/examples/theorem-prover/milawa-prover/soundness-thm/milawa_soundnessScript.sml +++ b/examples/theorem-prover/milawa-prover/soundness-thm/milawa_soundnessScript.sml @@ -1,7 +1,7 @@ open HolKernel Parse boolLib bossLib; val _ = new_theory "milawa_soundness"; -open prog_armTheory prog_ppcTheory prog_x86Theory; +(* open prog_armTheory prog_ppcTheory prog_x86Theory; *) open helperLib set_sepTheory progTheory; open lisp_correctnessTheory milawa_proofpTheory lisp_semanticsTheory; diff --git a/src/patricia/sptreeScript.sml b/src/patricia/sptreeScript.sml index 841cebb8e0..d7e1fbcd4a 100644 --- a/src/patricia/sptreeScript.sml +++ b/src/patricia/sptreeScript.sml @@ -354,13 +354,25 @@ val lookup_difference = store_thm( rw[optcase_lemma] >> REPEAT BasicProvers.CASE_TAC >> fs [lookup_def, lookup_mk_BS, lookup_mk_BN]) -val lrnext_def = new_specification( - "lrnext_def", ["lrnext"], - numeralTheory.bit_initiality - |> INST_TYPE [alpha |-> ``:num``] - |> Q.SPECL [`1`, `\n r. 2 * r`, - `\n r. 2 * r`] - |> SIMP_RULE bool_ss []); +val lrnext_real_def = tzDefine "lrnext" ` + lrnext n = if n = 0 then 1 else 2 * lrnext ((n - 1) DIV 2)` + (WF_REL_TAC `measure I` \\ fs [DIV_LT_X] \\ REPEAT STRIP_TAC \\ DECIDE_TAC) ; + +val lrnext_def = prove( + ``(lrnext ZERO = 1) /\ + (!n. lrnext (BIT1 n) = 2 * lrnext n) /\ + (!n. lrnext (BIT2 n) = 2 * lrnext n)``, + REPEAT STRIP_TAC + THEN1 (fs [Once ALT_ZERO,Once lrnext_real_def]) + THEN1 + (fs [Once BIT1,Once lrnext_real_def] + \\ AP_TERM_TAC \\ AP_TERM_TAC \\ fs [Once BIT1] + \\ fs [ADD_ASSOC,DECIDE ``n+n=n*2``,MULT_DIV]) + THEN1 + (fs [Once BIT2,Once lrnext_real_def] + \\ AP_TERM_TAC \\ AP_TERM_TAC \\ fs [Once BIT2] + \\ `n + (n + 2) - 1 = n * 2 + 1` by DECIDE_TAC + \\ fs [DIV_MULT])) val lrnext' = prove( ``(!a. lrnext 0 = 1) /\ (!n a. lrnext (NUMERAL n) = lrnext n)``, simp[NUMERAL_DEF, GSYM ALT_ZERO, lrnext_def]) From 661ec75f89069714086f794978f1ef781da36c10 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 13 Feb 2015 10:04:36 +1100 Subject: [PATCH 171/718] Regression tests for github issue #234 In particular, terms printed into theory.sml files are done so with the print_depth variable controlling how this happens. If the user has a print_depth variable that is set so as to cause a term to be printed with '...'s occurring, then the term will fail to parse back when the theory is loaded. --- src/1/theory_tests/github234aScript.sml | 8 ++++++++ src/1/theory_tests/github234bScript.sml | 10 ++++++++++ 2 files changed, 18 insertions(+) create mode 100644 src/1/theory_tests/github234aScript.sml create mode 100644 src/1/theory_tests/github234bScript.sml diff --git a/src/1/theory_tests/github234aScript.sml b/src/1/theory_tests/github234aScript.sml new file mode 100644 index 0000000000..5be947afd0 --- /dev/null +++ b/src/1/theory_tests/github234aScript.sml @@ -0,0 +1,8 @@ +open HolKernel Parse boolLib + +val _ = new_theory "github234a"; + +val _ = Globals.max_print_depth := 5 +val _ = overload_on("foo",``\t1 t2. !t. (t1 ==> t2 ==> t) ==> t``) + +val _ = export_theory(); diff --git a/src/1/theory_tests/github234bScript.sml b/src/1/theory_tests/github234bScript.sml new file mode 100644 index 0000000000..9d2fed7719 --- /dev/null +++ b/src/1/theory_tests/github234bScript.sml @@ -0,0 +1,10 @@ +open HolKernel Parse boolLib + +open github234aTheory + +val _ = new_theory "github234b"; + +val _ = save_thm("T", TRUTH) + + +val _ = export_theory(); From a464d166d37c3045b987fde4175586eeb6e570c4 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 13 Feb 2015 10:13:40 +1100 Subject: [PATCH 172/718] Set max_print_depth to -1 before printing terms to theory files Closes #234. --- src/parse/Parse.sml | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/src/parse/Parse.sml b/src/parse/Parse.sml index 6df852e5df..4bbeee91ae 100644 --- a/src/parse/Parse.sml +++ b/src/parse/Parse.sml @@ -221,11 +221,13 @@ val min_grammars = (type_grammar.min_grammar, term_grammar.min_grammar) fun minprint t = let fun default t = let val (_, baseprinter) = - Lib.with_flag (current_backend, PPBackEnd.raw_terminal) - print_from_grammars - min_grammars + with_flag (current_backend, PPBackEnd.raw_terminal) + print_from_grammars + min_grammars fun printer pps = - baseprinter pps |> trace ("types", 1) |> trace ("Greek tyvars", 0) + baseprinter pps + |> trace ("types", 1) |> trace ("Greek tyvars", 0) + |> with_flag (max_print_depth, ~1) val t_str = String.toString (PP.pp_to_string 1000000 printer t) in From 07480c255cc54f927bb9fc1da1d33d7ea35ec538 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 13 Feb 2015 16:46:06 +1100 Subject: [PATCH 173/718] Slightly adjust Holmake's internal interface. Just a refactoring to make the recursive calls return a record-option rather a straight set. Intention is to next make the return value a bigger record so that it can return a list of extra includes, thereby allowing a fix for issue illustrated by the holdep test-case under Holmake/tests. --- tools-poly/Holmake/Holmake.sml | 10 +++++----- tools/Holmake/Holmake.sml | 14 +++++++------- tools/Holmake/Holmake_tools.sig | 9 ++++++--- tools/Holmake/Holmake_tools.sml | 11 ++++++----- 4 files changed, 24 insertions(+), 20 deletions(-) diff --git a/tools-poly/Holmake/Holmake.sml b/tools-poly/Holmake/Holmake.sml index bbc28c41ad..9b8ccca799 100644 --- a/tools-poly/Holmake/Holmake.sml +++ b/tools-poly/Holmake/Holmake.sml @@ -380,8 +380,8 @@ end (* directory specific stuff here *) -fun Holmake dirinfo visiteddirs cline_additional_includes targets = let - val {abspath=dir, relpath=dirnm} = dirinfo +fun Holmake dirinfo cline_additional_includes targets : holmake_result = let + val {abspath=dir, relpath=dirnm, visited = visiteddirs} = dirinfo val _ = OS.FileSys.chDir dir @@ -1232,7 +1232,7 @@ in x in_target ".PHONY" in if List.all isPhony xs andalso not cline_recursive then - if finish_logging (strategy xs) then SOME visiteddirs else NONE + if finish_logging (strategy xs) then SOME {visited = visiteddirs} else NONE else let val ctgt = @@ -1280,8 +1280,8 @@ in open OS.Process val result = Holmake {relpath = SOME (OS.Path.currentArc), - abspath = OS.FileSys.getDir()} - (Binaryset.empty String.compare) + abspath = OS.FileSys.getDir(), + visited = Binaryset.empty String.compare} cline_additional_includes targets handle Fail s => (print ("Fail exception: "^s^"\n"); diff --git a/tools/Holmake/Holmake.sml b/tools/Holmake/Holmake.sml index 47582bb072..82a95dfba0 100644 --- a/tools/Holmake/Holmake.sml +++ b/tools/Holmake/Holmake.sml @@ -391,10 +391,9 @@ in recurse (false, false, ss) end - (* directory specific stuff here *) -fun Holmake dirinfo visiteddirs cline_additional_includes targets = let - val {abspath=dir,relpath=dirnm} = dirinfo +fun Holmake dirinfo cline_additional_includes targets : holmake_result = let + val {abspath=dir,relpath=dirnm, visited = visiteddirs} = dirinfo val _ = OS.FileSys.chDir dir @@ -1055,7 +1054,7 @@ in if keep_going_flag then keep_going tgts else stop_on_failure tgts end -fun hm_recur ctgt k = +fun hm_recur ctgt k : holmake_result = maybe_recurse {warn = warn, no_prereqs = no_prereqs, hm = Holmake, visited = visiteddirs, @@ -1085,7 +1084,8 @@ in x in_target ".PHONY" in if List.all isPhony xs andalso not cline_recursive then - if finish_logging (strategy xs) then SOME visiteddirs else NONE + if finish_logging (strategy xs) then SOME {visited = visiteddirs} + else NONE else let val ctgt = @@ -1131,8 +1131,8 @@ val _ = open Process val result = Holmake {relpath = SOME (OS.Path.currentArc), - abspath = OS.FileSys.getDir()} - (Binaryset.empty String.compare) + abspath = OS.FileSys.getDir(), + visited = Binaryset.empty String.compare} cline_additional_includes targets handle Fail s => (print ("Fail exception: "^s^"\n"); diff --git a/tools/Holmake/Holmake_tools.sig b/tools/Holmake/Holmake_tools.sig index 703fb7b047..32a6d09630 100644 --- a/tools/Holmake/Holmake_tools.sig +++ b/tools/Holmake/Holmake_tools.sig @@ -53,16 +53,19 @@ sig val clean_dir : {extra_cleans: string list} -> unit val clean_depdir : {depdirname : string} -> bool + type holmake_result = {visited : string Binaryset.set } option + val maybe_recurse : {warn: string -> unit, no_prereqs : bool, - hm: {relpath:string option,abspath:string} -> string Binaryset.set -> - string list -> string list -> string Binaryset.set option, + hm: {relpath : string option, abspath : string, + visited : string Binaryset.set} -> + string list -> string list -> holmake_result, visited: string Binaryset.set, includes : string list, dir : {abspath: string, relpath: string option}, local_build : unit -> bool, cleantgt : string option} -> - string Binaryset.set option + holmake_result end diff --git a/tools/Holmake/Holmake_tools.sml b/tools/Holmake/Holmake_tools.sml index 35ea861d66..6c8e051228 100644 --- a/tools/Holmake/Holmake_tools.sml +++ b/tools/Holmake/Holmake_tools.sml @@ -288,6 +288,7 @@ val terminal_log = if Systeml.isUnix then xterm_log else (fn s => ()) +type holmake_result = {visited : string Binaryset.set } option fun maybe_recurse {warn,no_prereqs,hm,visited,includes,dir,local_build=k, cleantgt} = @@ -296,7 +297,7 @@ let val k = fn () => (terminal_log ("Holmake: "^nice_dir dir); k()) val tgts = case cleantgt of SOME s => [s] | NONE => [] fun recurse visited (newdir,nm) = - if Binaryset.member(visited, newdir) then SOME visited + if Binaryset.member(visited, newdir) then SOME {visited = visited} else let val newrelpath = if Path.isAbsolute nm then NONE @@ -308,23 +309,23 @@ let val _ = warn ("Recursively calling Holmake in "^nm) val _ = terminal_log ("Holmake: "^nice_dir nm) in - hm {relpath=newrelpath,abspath=newdir} visited [] tgts + hm {relpath=newrelpath,abspath=newdir,visited=visited} [] tgts before (warn ("Finished recursive invocation in "^nm); terminal_log ("Holmake: "^nice_dir dir); FileSys.chDir dir) end - fun do_em accg [] = if k() then SOME accg else NONE + fun do_em accg [] = if k() then SOME {visited = accg} else NONE | do_em accg (x::xs) = let in case recurse accg x of - SOME g' => do_em g' xs + SOME {visited} => do_em visited xs | NONE => NONE end val visited = Binaryset.add(visited, dir) in if no_prereqs then - if k() then SOME visited else NONE + if k() then SOME {visited = visited} else NONE else let fun foldthis (dir, m) = Binarymap.insert(m, FileSys.fullPath dir, dir) From ac89e3da46210fa2494a79d3f9987d110150b615 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 13 Feb 2015 16:49:47 +1100 Subject: [PATCH 174/718] A shell-script to build Holmake under Moscow ML. Running this script is faster than waiting for smart-configure.sml to do its thing. Assumes mosml2.01, and that its installed in user path etc. --- tools/Holmake/qcompile.sh | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) create mode 100755 tools/Holmake/qcompile.sh diff --git a/tools/Holmake/qcompile.sh b/tools/Holmake/qcompile.sh new file mode 100755 index 0000000000..d745d71651 --- /dev/null +++ b/tools/Holmake/qcompile.sh @@ -0,0 +1,27 @@ +#!/bin/sh + +set -e +mosmlc -c -toplevel basis2002.sml +mosmlc -c basis2002.ui Systeml.sig +mosmlc -c basis2002.ui Systeml.sml +mosmlc -c basis2002.ui Holdep_tokens.sig +mosmlc -c basis2002.ui Holdep_tokens.sml +mosmlc -c basis2002.ui holdeptool.sml +mosmlc -c basis2002.ui mosml_holdeptool.sml +mosmlc -c Holdep.sig +mosmlc -c basis2002.ui Holdep.sml +mosmlc -c regexpMatch.sig +mosmlc -c basis2002.ui regexpMatch.sml +mosmlc -c parse_glob.sig +mosmlc -c basis2002.ui parse_glob.sml +mosmlc -c internal_functions.sig +mosmlc -c basis2002.ui internal_functions.sml +mosmlc -c basis2002.ui Holmake_types.sig +mosmlc -c basis2002.ui Holmake_types.sml +mosmlc -o holdeptool.exe mosml_holdeptool.uo +mosmlc -c basis2002.ui Holmake_tools.sig +mosmlc -c basis2002.ui Holmake_tools.sml +mosmlc -c ReadHMF.sig +mosmlc -c basis2002.ui ReadHMF.sml +mosmlc -c basis2002.ui Holmake.sml +mosmlc -o Holmake Holmake.uo From 641b3118bd6ff746f221d44d5ecddab499f2cf4d Mon Sep 17 00:00:00 2001 From: Magnus Myreen Date: Fri, 13 Feb 2015 12:29:02 +0100 Subject: [PATCH 175/718] got Milawa's top-level thm to build again --- .../lisp-runtime/garbage-collector/Holmakefile | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/examples/theorem-prover/lisp-runtime/garbage-collector/Holmakefile b/examples/theorem-prover/lisp-runtime/garbage-collector/Holmakefile index 025fd1960e..993ad08099 100644 --- a/examples/theorem-prover/lisp-runtime/garbage-collector/Holmakefile +++ b/examples/theorem-prover/lisp-runtime/garbage-collector/Holmakefile @@ -2,5 +2,8 @@ INCLUDES = ../parse $(HOLDIR)/examples/machine-code/compiler \ $(HOLDIR)/examples/machine-code/decompiler \ $(HOLDIR)/examples/machine-code/hoare-triple \ $(HOLDIR)/examples/machine-code/instruction-set-models/common \ - $(HOLDIR)/examples/machine-code/instruction-set-models/x86_64 + $(HOLDIR)/examples/machine-code/instruction-set-models/x86_64 \ + $(HOLDIR)/examples/machine-code/instruction-set-models/x86 \ + $(HOLDIR)/examples/machine-code/instruction-set-models/arm \ + $(HOLDIR)/examples/machine-code/instruction-set-models/ppc OPTIONS = QUIT_ON_FAILURE From 5da2963c063e25ae437c246e8a8a315c3a2a6db6 Mon Sep 17 00:00:00 2001 From: Thomas Tuerk Date: Sat, 14 Feb 2015 09:33:04 +0100 Subject: [PATCH 176/718] deep_matches examples work - new syntax - parser for this new syntax - more work on constrFamiliesLib - cleanup deepMatchesScript - start adding defs and proofs for removing redundant rows --- examples/deep_matches/README | 31 ++ examples/deep_matches/constrFamiliesLib.sig | 70 ++- examples/deep_matches/constrFamiliesLib.sml | 397 ++++++++++++-- examples/deep_matches/deepMatchesExamples.sml | 71 +-- examples/deep_matches/deepMatchesLib.sml | 12 +- examples/deep_matches/deepMatchesScript.sml | 513 ++++++++++++++---- examples/deep_matches/deepMatchesSyntax.sml | 145 ++++- 7 files changed, 1022 insertions(+), 217 deletions(-) diff --git a/examples/deep_matches/README b/examples/deep_matches/README index 26e3de4d74..edccabbf85 100644 --- a/examples/deep_matches/README +++ b/examples/deep_matches/README @@ -1,2 +1,33 @@ This directory contains a deep embedding of pattern matching. + +************************************************* It is work in progress and still far from stable. +************************************************* + +Normally, pattern matches are removed from the input by the parser of +HOL4. An implementation of a pattern-match compilation algorithm +replaces them with decision trees using primitive case-split functions +for each involved type. The pretty printer prints the resulting decision +trees in the form of pattern matches again. Both the pattern-compilation +and the pretty printer are long, complicated ML-programs. As such, we +are not sure, whether we can really trust them. + +Usually this is not a big issue. One can use simple pattern matches in +a definition and then prove theorems expressing the semantics of the new +definition not using pattern matching. This is advisable anyhow, since +the command `Define` can behave unexpectedly anyhow. However, as soon as +pattern matching is used extensively, this becomes infeasible. For +example consider the ARM disassembler function `arm_decode` in +`examples/ARM/v7/arm_decoderScript.sml`. Why should we trust the result +of the pattern match compilation in such definitions? + +This pattern matching library tries to solve this problem. It provides +a deep embedding of pattern matches. The parsing and pretty printing +of these deeply embedded matches is much simpler and therefore more +trustworthy. The complicated, untrusted pattern match compilation can +then be performed inside the logic. Therefore, the need to trust the +implementation of the pattern match compilation is removed. Moreover, +the deep embedding provides some additional features like guards, +views, free variables in patterns or multiple occurrences of a bound +variable inside a pattern. There is also tool support for working with +deeply embedded pattern matches inside the logic. \ No newline at end of file diff --git a/examples/deep_matches/constrFamiliesLib.sig b/examples/deep_matches/constrFamiliesLib.sig index 9ee176a0df..3ae069395a 100644 --- a/examples/deep_matches/constrFamiliesLib.sig +++ b/examples/deep_matches/constrFamiliesLib.sig @@ -2,9 +2,73 @@ signature constrFamiliesLib = sig include Abbrev - val gen_case_expand_thm : thm -> thm -> thm - val get_case_expand_thm : term * ((term list * term) list) -> - thm + (**********************) + (* Constructors *) + (**********************) + (* A constructor is a combination of a term with + a list of names for all it's arguments *) + type constructor + + (* check whether a constructor has no arguments *) + val constructor_is_const : constructor -> bool + + (* [mk_constructor_term vs constr] construct a term + corresponding to [constr]. For the arguments + variables are generated. These variables are + distinct from the ones provided in the argument [vs]. + The resulting term as well the used argument vars are + returned. *) + val mk_constructor_term : term list -> constructor -> (term * term list) + + (* We usually consider lists of constructors. It is an abstract + type that should only be used via [make_constructorList]. *) + type constructorList + + (* [make_constructorList exh constrs] makes a new constructorList. + *) + val make_constructorList : bool -> (term * string list) list -> constructorList + + + (************************) + (* Constructor Families *) + (************************) + + (* a constructor family is a list of constructors, + a case-split function and various theorems *) + type constructorFamily + + (* Get the rewrites stored in a constructor family, these + are theorems that use that all constructors are distinct + to each other and injective. *) + val constructorFamily_get_rewrites : constructorFamily -> thm + + (* Get the case-split theorem for the family. *) + val constructorFamily_get_case_split : constructorFamily -> thm + + (* If the constructor family is exhaustive, a theorem stating + this exhaustiveness. *) + val constructorFamily_get_nchotomy_thm_opt : constructorFamily -> thm option + + + (* [mk_constructorFamily (constrL, case_split_tm, tac)] + make a new constructor family. It consists of the constructors + [constrL], the case split constant [case_split_tm]. The + resulting proof obligations are proofed by tactic [tac]. *) + val mk_constructorFamily : constructorList * term * tactic -> constructorFamily + + (* [get_constructorFamily_proofObligations] returns the + proof obligations that occur when creating a new constructor family. *) + val get_constructorFamily_proofObligations : constructorList * term -> term + + (* [set_constructorFamily] sets the proof obligations + using goalStack *) + val set_constructorFamily : constructorList * term -> Manager.proof + + + + + val constructorFamily_of_typebase : hol_type -> constructorFamily + end diff --git a/examples/deep_matches/constrFamiliesLib.sml b/examples/deep_matches/constrFamiliesLib.sml index 6723cf685c..2108aea42b 100644 --- a/examples/deep_matches/constrFamiliesLib.sml +++ b/examples/deep_matches/constrFamiliesLib.sml @@ -3,82 +3,371 @@ struct open HolKernel boolLib simpLib bossLib -(* Contructor families are lists of constructors. - Constructors are functions that are injective and - pairwise distinct. Moreover, a case-expansion theorem needs to be provided. - - Let's assume we have a datatype t with - C1 of bool, C2, C3 of nat. Then we need the following theorems - - !b1 b2. (C1 b1 = C1 b2) <-> (b1 = b2) - !n1 n2. (C3 n1 = C3 n2) <-> (n1 = n2) - (!b. not (C1 b = C2)) - (!b. not (C2 = C1 b)) - (!b n. not (C1 b = C3 n)) - (!b n. not (C3 n = C3 b)) - (!n. not (C3 n = C2)) - (!n. not (C2 = C3 n)) - - and a case split theorem like - - !f v. f v = (case v of - C1 b -> f (C1 b) - | C2 -> f C2 - | C3 n -> f (C3 n)) +fun failwith f x = + raise (mk_HOL_ERR "constrFamiliesLib" f x) + +fun variants used_vs vs = let + val (_, vs') = foldl (fn (v, (used_vs, vs')) => + let val v' = variant used_vs v + in (v'::used_vs, v'::vs') end) (used_vs, []) vs +in + List.rev vs' +end + + +fun list_mk_comb_subst (c, args) = (case args of + [] => c + | (a::args') => let + val (v, c') = dest_abs c + in + list_mk_comb_subst (subst [v |-> a] c', args') + end handle HOL_ERR _ => + list_mk_comb_subst (mk_comb (c, a), args') +) + + +fun next_ty ty = mk_vartype(Lexis.tyvar_vary (dest_vartype ty)); + + +fun normalise_ty ty = let + fun recurse (acc as (dict,usethis)) tylist = + case tylist of + [] => acc + | ty :: rest => let + in + if is_vartype ty then + case Binarymap.peek(dict,ty) of + NONE => recurse (Binarymap.insert(dict,ty,usethis), + next_ty usethis) + rest + | SOME _ => recurse acc rest + else let + val {Args,...} = dest_thy_type ty + in + recurse acc (Args @ rest) + end + end + val (inst0, _) = recurse (Binarymap.mkDict Type.compare, Type.alpha) [ty] + val inst = Binarymap.foldl (fn (tyk,tyv,acc) => (tyk |-> tyv)::acc) + [] + inst0 +in + Type.type_subst inst ty +end + + +(***************************************************) +(* Encoding theorem lists *) +(***************************************************) + + +fun encode_term_opt_list tl = let + val tl' = List.map (fn t => markerSyntax.mk_label ("THM_PART", Option.getOpt (t, T))) tl + val t = list_mk_conj tl' + val thm = (markerLib.DEST_LABELS_CONV THENC REWRITE_CONV []) t +in + thm +end + +fun decode_thm_opt_list combined_thm = let + fun process_thm thm = let + val thm' = CONV_RULE markerLib.DEST_LABEL_CONV thm + in + if (aconv (concl thm') T) then NONE else SOME thm' + end + + val thms = CONJUNCTS combined_thm + val thms' = List.map process_thm thms +in + thms' +end + +fun set_goal_list tl = let + val thm = encode_term_opt_list tl +in + Manager.set_goal ([], rhs (concl thm)) +end + + +fun prove_list (tl, tac) = let + val thm = encode_term_opt_list tl + val thm2 = prove (rhs (concl thm), tac) + val thm3 = EQ_MP (GSYM thm) thm2 +in + decode_thm_opt_list thm3 +end + + + +(***************************************************) +(* Constructors *) +(***************************************************) + +(* A constructor is a combination of a term with + a list of names for all it's arguments *) +datatype constructor = CONSTR of term * (string list) + +fun constructor_is_const (CONSTR (_, sl)) = + null sl + +fun mk_constructor_term vs (CONSTR (c, args)) = let + val (arg_tys, b_ty) = strip_fun (type_of c) + val _ = if (length arg_tys < length args) then + failwith "check_constructor" "too many argument names given" else () + + val typed_args = zip args (List.take (arg_tys, length args)) + val arg_vars = List.map mk_var typed_args + val arg_vars' = variants vs arg_vars + val t = list_mk_comb_subst (c, arg_vars') +in + (t, arg_vars') +end + + + + +(* Multiple constructors for a single type are usually + grouped. These can be exhaustive or not. *) +type constructorList = { + cl_type : hol_type, + cl_constructors : constructor list, + cl_is_exhaustive : bool +} + +fun make_constructorList is_exhaustive constrs' = let + val constrs = List.map CONSTR constrs' + val ts = List.map (fst o (mk_constructor_term [])) constrs + val _ = if null ts then failwith "make_constructorList" "no constructors given" else () + val ty = type_of (hd ts) + val _ = if (Lib.all (fn t => type_of t = ty) ts) then () else + failwith "make_constructorList" "types of constructors don't match" +in + { cl_type = ty, + cl_constructors = constrs, + cl_is_exhaustive = is_exhaustive }:constructorList +end + + +(***************************************************) +(* Constructor Families *) +(***************************************************) + +(* Contructor families are lists of constructors with + a cass-split constant + extra theorems. *) -type constrFamily = { - constructors : term list, - one_one_thm : thm, - distinct_thm : thm, - case_split_thm: thm +type constructorFamily = { + constructors : constructorList, + case_const : term, + one_one_thm : thm option, + distinct_thm : thm option, + case_split_thm: thm, + nchotomy_thm : thm option } +fun constructorFamily_get_rewrites (cf : constructorFamily) = + case (#one_one_thm cf, #distinct_thm cf) of + (NONE, NONE) => TRUTH + | (SOME thm1, NONE) => thm1 + | (NONE, SOME thm2) => thm2 + | (SOME thm1, SOME thm2) => CONJ thm1 thm2 +fun constructorFamily_get_case_split (cf: constructorFamily) = + (#case_split_thm cf) -fun gen_case_expand_thm case_def_thm nchotomy_thm = let - val c = fst ( - strip_comb (lhs (snd (strip_forall (hd (strip_conj (concl case_def_thm))))))) - val (a, cases) = dest_forall (concl nchotomy_thm) +fun constructorFamily_get_nchotomy_thm_opt (cf: constructorFamily) = + (#nchotomy_thm cf) - val res_ty = snd (strip_fun (type_of c)) - val ff_tm = mk_var ("ff", (type_of a) --> res_ty) +(* Test datatype +val _ = Datatype `test_ty = + A + | B 'b + | C bool 'a bool + | D num bool` - val args = let - val cases_tms = strip_disj cases - fun process_case ct = let - val (vars, b) = strip_exists ct - val b' = rhs b +val SOME constrL = constructorList_of_typebase ``:('a, 'b) test_ty`` +val case_const = TypeBase.case_const_of ``:('a, 'b) test_ty`` + +val constrL = make_constructorList false [(``{}:'a set``, []), (``\x:'a. {x}``, ["x"])] + +val set_CASE_def = zDefine ` + set_CASE s c_emp c_sing c_else = + (if s = {} then c_emp else ( + if (FINITE s /\ (CARD s = 1)) then c_sing (CHOICE s) else + c_else))` + +val case_const = ``set_CASE`` +*) + + +fun mk_one_one_thm_term_opt (constrL : constructorList) = let + fun mk_one_one_single cr = let + val (l, vl) = mk_constructor_term [] cr + val (r, vr) = mk_constructor_term vl cr + val lr = mk_eq (l, r) + val eqs = list_mk_conj (List.map mk_eq (zip vl vr)) + val b = mk_eq (lr, eqs) + in + list_mk_forall (vl @ vr, b) + end + + val constrs = filter (not o constructor_is_const) (#cl_constructors constrL) + val eqs = map mk_one_one_single constrs +in + if (null eqs) then NONE else SOME (list_mk_conj eqs) +end + + +fun mk_distinct_thm_term_opt (constrL : constructorList) = let + val constrs = #cl_constructors constrL + val all_pairs = flatten (List.map (fn x => + List.map (fn y => (x, y)) constrs) constrs) + val dist_pairs = List.filter (fn (CONSTR (c1, _), CONSTR (c2, _)) => + not (aconv c1 c2)) all_pairs + fun mk_distinct_single (cr1, cr2) = let + val (l, vl) = mk_constructor_term [] cr1 + val (r, vr) = mk_constructor_term vl cr2 + val lr = mk_neg (mk_eq (l, r)) + in + list_mk_forall (vl @ vr, lr) + end + + val eqs = map mk_distinct_single dist_pairs +in + if (null eqs) then NONE else SOME (list_mk_conj eqs) +end + + +fun mk_case_expand_thm_term case_const (constrL : constructorList) = let + val (arg_tys, res_ty) = strip_fun (type_of case_const) + val split_arg = mk_var ("x", hd arg_tys) + val split_fun = mk_var ("ff", hd arg_tys --> res_ty) + + fun mk_arg cr = let + val (b, vs) = mk_constructor_term [split_fun,split_arg] cr + val b' = mk_comb (split_fun, b) + in + list_mk_abs (vs, b') + end + + val args = List.map mk_arg (#cl_constructors constrL) + val args = if (#cl_is_exhaustive constrL) then args else + args@[(mk_abs (split_arg, mk_comb(split_fun, split_arg)))] + + val r = list_mk_comb (case_const, split_arg::args) + val l = mk_comb (split_fun, split_arg) + + val eq = list_mk_forall ([split_fun, split_arg], mk_eq (l, r)) +in + eq +end + +fun mk_nchotomy_thm_term_opt (constrL : constructorList) = + if not (#cl_is_exhaustive constrL) then NONE else let + val v = mk_var ("x", #cl_type constrL) + + fun mk_disj cr = let + val (b, vs) = mk_constructor_term [v] cr + val eq = mk_eq (v, b) in - list_mk_abs (vars, (mk_comb (ff_tm, b'))) + list_mk_exists (vs, eq) end + + val eqs = List.map mk_disj (#cl_constructors constrL) + val eqs_t = list_mk_disj eqs in - map process_case cases_tms - end + SOME (mk_forall (v, eqs_t)) + end; + + +fun mk_constructorFamily_terms case_const constrL = let + val t1 = mk_one_one_thm_term_opt constrL + val t2 = mk_distinct_thm_term_opt constrL + val t3 = SOME (mk_case_expand_thm_term case_const constrL) + val t4 = mk_nchotomy_thm_term_opt constrL +in + [t1, t2, t3, t4] +end + +fun get_constructorFamily_proofObligations (constrL, case_const) = let + val ts = mk_constructorFamily_terms case_const constrL + val thm = encode_term_opt_list ts +in + rhs (concl thm) +end - val t_rhs = list_mk_comb (c, a::args) - val t_lhs = mk_comb (ff_tm, a) - val t = list_mk_forall([ff_tm, a], mk_eq (t_lhs, t_rhs)) +fun set_constructorFamily (constrL, case_const) = + set_goal_list (mk_constructorFamily_terms case_const constrL) - val res_thm = prove (t, - REPEAT GEN_TAC THEN - MP_TAC (ISPEC a nchotomy_thm) THEN - SIMP_TAC std_ss [DISJ_IMP_THM, case_def_thm, - GSYM LEFT_FORALL_IMP_THM]) +fun mk_constructorFamily (constrL, case_const, tac) = let + val thms = prove_list (mk_constructorFamily_terms case_const constrL, tac) in - res_thm + { + constructors = constrL, + case_const = case_const, + one_one_thm = el 1 thms, + distinct_thm = el 2 thms, + case_split_thm = valOf (el 3 thms), + nchotomy_thm = el 4 thms + }:constructorFamily end -fun get_case_expand_thm (v, _) = let - val ty = type_of v - val case_def_thm = TypeBase.case_def_of ty + + + +(***************************************************) +(* Connection to typebase *) +(***************************************************) + +(* given a type try to extract the constructors of a type + from typebase. Do not use the default type-base functions + for this but destruct the nchotomy_thm in order to get + the default argument names as well. *) +fun constructorList_of_typebase ty = + if null (TypeBase.constructors_of ty) then NONE else let val nchotomy_thm = TypeBase.nchotomy_of ty + val eqs = strip_disj (snd (dest_forall (concl nchotomy_thm))) + + fun dest_eq eq = let + val (_, b) = strip_exists eq + val (c, args) = strip_comb (rhs b) + val args' = List.map (fst o dest_var) args + in + CONSTR (c, args') + end + + val constrs = List.map dest_eq eqs in - gen_case_expand_thm case_def_thm nchotomy_thm + SOME ({ cl_type = ty, + cl_constructors = constrs, + cl_is_exhaustive = true }:constructorList) end +fun constructorFamily_of_typebase ty = let + val crL = valOf (constructorList_of_typebase ty) + handle Option => failwith "constructorList_of_typebase" "not a datatype" + val case_split_tm = TypeBase.case_const_of ty + val thm_distinct = TypeBase.distinct_of ty + val thm_one_one = TypeBase.one_one_of ty + val thm_case = TypeBase.case_def_of ty + + +(* set_constructorFamily (crL, case_split_tm) *) + val cf = mk_constructorFamily (crL, case_split_tm, + SIMP_TAC std_ss [thm_distinct, thm_one_one] THEN + REPEAT STRIP_TAC THEN ( + Cases_on `x` THEN + SIMP_TAC std_ss [thm_distinct, thm_one_one, thm_case] + ) + ) +in + cf +end +(***************************************************) +(* Build a on to typebase *) +(***************************************************) diff --git a/examples/deep_matches/deepMatchesExamples.sml b/examples/deep_matches/deepMatchesExamples.sml index cd856ae8d3..8f6e703756 100644 --- a/examples/deep_matches/deepMatchesExamples.sml +++ b/examples/deep_matches/deepMatchesExamples.sml @@ -12,6 +12,7 @@ val thm_t = PMATCH_INTRO_CONV t (* check that SIMP works *) val thm_t' = PMATCH_REMOVE_ARB_CONV t' val thm_t' = PMATCH_SIMP_CONV t' + (* more fancy *) val t = ``case x of @@ -25,31 +26,19 @@ val thm_t = PMATCH_INTRO_CONV t val thm_t' = PMATCH_REMOVE_ARB_CONV t' val thm_t' = PMATCH_SIMP_CONV t' - (* Playing around with some examples *) val example1 = `` -PMATCH (a,x,xs) - [PMATCH_ROW (\x. (NONE,x,[])) (\x. T) (\x. x); - PMATCH_ROW (\x. (NONE,x,[2])) (\x. T) (\x. x); - PMATCH_ROW (\ (x,v18). (NONE,x,[v18])) (\ (x, v18). T) (\ (x, v18). 3); - PMATCH_ROW (\ (x,v12,v16,v17). (NONE,x,v12::v16::v17)) - (\ (x,v12,v16,v17). T) - (\ (x,v12,v16,v17). 3); - PMATCH_ROW (\ (y,x,z,zs). (SOME y,x,[z])) - (\ (y,x,z,zs). T) - (\ (y,x,z,zs). x+5+z); - PMATCH_ROW (\ (y,v23,v24). (SOME y,0,v23::v24)) - (\ (y,v23,v24). T) - (\ (y,v23,v24). v23+y); - PMATCH_ROW (\ (y,z,v23). (SOME y,SUC z,[v23])) - (\ (y,z,v23). y > 5) - (\ (y,z,v23). 3); - PMATCH_ROW (\ (y,z). (SOME y,SUC z,[1; 2])) - (\ (y,z). T) - (\ (y,z). y + z) - ]`` - + CASE (a,x,xs) OF [ + || x. (NONE,x,[]) ~> x; + || x. (NONE,x,[2]) ~> x; + || (x,v18). (NONE,x,[v18]) ~> 3; + || (x,v12,v16,v17). (NONE,x,v12::v16::v17) ~> 3; + || (y,x,z,zs). (SOME y,x,[z]) ~> x + 5 + z; + || (y,v23,v24). (SOME y,0,v23::v24) ~> (v23 + y); + || (y,z,v23). (SOME y,SUC z,[v23]) when y > 5 ~> 3; + || (y,z). (SOME y,SUC z,[1; 2]) ~> y + z + ]``; val example2 = ``PMATCH (h::t) [PMATCH_ROW (\_ . []) (\_. T) (\_. x); @@ -60,17 +49,14 @@ val example2 = ``PMATCH (h::t) (\ (v12,v16,v17). 3); PMATCH_ROW (\_. [2; 4; 3]) (\_. T) (\_. 3 + x)]`` -val example3 = - ``PMATCH (NONE,x,xs) - [PMATCH_ROW (\x. (NONE,x,[])) (\x. T) (\x. x); - PMATCH_ROW (\x. (NONE,x,[2])) (\x. T) (\x. x); - PMATCH_ROW (\ (x,v18). (NONE,x,[v18])) (\ (x,v18). T) (\ (x,v18). 3); - PMATCH_ROW (\ (x,v12,v16,v17). (NONE,x,v12::v16::v17)) - (\ (x,v12,v16,v17). T) - (\ (x,v12,v16,v17). 3); - PMATCH_ROW (\ (y,x). (y,x,[2; 4; 3])) - (\ (y,x). x > 5) - (\ (y,x). 3 + x)]``; +val example3 = `` + CASE (NONE,x,xs) OF [ + || x. (NONE,x,[]) ~> x; + || x. (NONE,x,[2]) ~> x; + || (x,v18). (NONE,x,[v18]) ~> 3; + || (x,v12,v16,v17). (NONE,x,v12::v16::v17) ~> 3; + || (y,x). (y,x,[2; 4; 3]) when (x > 5) ~> (3 + x) + ]``; (* turn off pretty printer *) @@ -128,9 +114,10 @@ val ex2 = ``case (x, y) of (x, x) => T | _ => F`` + (* let's prove that this really behaves as expected. Notice that here the simpset-fragments for - PMATCH pick out information from the context to + PMATCH picks out information from the context to simplify the PMATCH. *) val ex2_thm = prove (``^ex2 = (x = y)``, @@ -146,19 +133,21 @@ Cases_on `x=y` THEN ( (* theorems to use for recursive defs *) (**************************************) -val _ = set_trace "parse deep cases" 1; - val my_d_def = Define - `my_d xx = case xx of - (x, []) => x - | (x, y::ys) => my_d (x + y, ys)` + `my_d xx = CASE xx OF [ + || x. (x, []) when x > 3 ~> x; + || x. (x, []) ~> 0; + || (x, y, ys). (x, y::ys) ~> my_d (x + y, ys)]` val my_d_thms = store_thm ("my_d_thms", -``(!x. my_d (x, []) = x) /\ +``(!x. x > 3 ==> (my_d (x, []) = x)) /\ + (!x. x <= 3 ==> (my_d (x, []) = 0)) /\ (!x y ys. my_d (x, y::ys) = my_d (x + y, ys))``, REPEAT STRIP_TAC THENL [ - SIMP_TAC (std_ss++PMATCH_SIMP_ss) [my_d_def], + ASM_SIMP_TAC (std_ss++PMATCH_SIMP_ss) [my_d_def], + + ASM_SIMP_TAC (arith_ss++PMATCH_SIMP_ss) [my_d_def], CONV_TAC (LHS_CONV (ONCE_REWRITE_CONV [my_d_def])) THEN SIMP_TAC (std_ss ++ PMATCH_SIMP_ss) [] diff --git a/examples/deep_matches/deepMatchesLib.sml b/examples/deep_matches/deepMatchesLib.sml index 7857462df4..b66214ebf6 100644 --- a/examples/deep_matches/deepMatchesLib.sml +++ b/examples/deep_matches/deepMatchesLib.sml @@ -3,6 +3,7 @@ struct open HolKernel boolLib bossLib open deepMatchesTheory +open simpLib open quantHeuristicsLib open deepMatchesSyntax open constrFamiliesLib @@ -64,12 +65,20 @@ val elim_fst_snd_select_ss = key = SOME ([],``$@ (f:'a -> bool)``), conv = K (K ELIM_FST_SND_SELECT_CONV)} +val select_conj_ss = + simpLib.conv_ss + {name = "SELECT_CONJ_SS_CONV", + trace = 2, + key = SOME ([],``$@ (f:'a -> bool)``), + conv = K (K (SIMP_CONV (std_ss++boolSimps.CONJ_ss) []))}; + fun rc_ss gl = list_ss ++ simpLib.merge_ss (gl @ [pabs_elim_ss, pairSimps.paired_forall_ss, pairSimps.paired_exists_ss, pairSimps.gen_beta_ss, + select_conj_ss, elim_fst_snd_select_ss, simpLib.rewrites [ pairTheory.EXISTS_PROD, @@ -1122,7 +1131,7 @@ in thm2 end - +(* fun PMATCH_CASE_SPLIT_CONV_GENCALL rc_arg col_no t = let val thm0 = QCHANGED_CONV ( PMATCH_SIMP_CONV_GENCALL rc_arg) t handle HOL_ERR _ => REFL t @@ -1137,5 +1146,6 @@ fun PMATCH_CASE_SPLIT_CONV_GENCALL rc_arg col_no t = let in TRANS thm0 thm1 end +*) end diff --git a/examples/deep_matches/deepMatchesScript.sml b/examples/deep_matches/deepMatchesScript.sml index 7b6c669410..21c37a68d2 100644 --- a/examples/deep_matches/deepMatchesScript.sml +++ b/examples/deep_matches/deepMatchesScript.sml @@ -1,65 +1,35 @@ open HolKernel Parse boolLib bossLib; open quantHeuristicsLib open optionTheory +open listTheory val _ = new_theory "deepMatches" (***************************************************) -(* Main Definitions *) +(* Auxiliary stuff *) (***************************************************) -(* rows of a pattern match are pairs of a pattern to match - against pat, a guard and a result value. *) -val PMATCH_ROW_COND_def = Define `PMATCH_ROW_COND pat guard i x = - (pat x = i) /\ (guard x)` - -val PMATCH_ROW_def = Define `PMATCH_ROW pat guard res i = - (OPTION_MAP res (some x. PMATCH_ROW_COND pat guard i x))` - - -(* We defined semantics of single rows. Let's extend - it to multiple ones, i.e. full pattern matches now *) -val PMATCH_INCOMPLETE_def = Define `PMATCH_INCOMPLETE = ARB` -val PMATCH_def = Define ` - (PMATCH v [] = PMATCH_INCOMPLETE) /\ - (PMATCH v (r::rs) = option_CASE (r v) (PMATCH v rs) I)` - - -val PMATCH_IS_EXHAUSTIVE_def = Define ` - PMATCH_IS_EXHAUSTIVE rs = ( - !v. EXISTS (\r. IS_SOME (r v)) rs)` - -val PMATCH_ROW_REDUNDANT_def = Define ` - PMATCH_ROW_REDUNDANT rs i = ( - (i < LENGTH rs /\ (!v. ?j. ((j < i) /\ - (IS_SOME ((EL i rs) v) ==> - IS_SOME ((EL j rs) v))))))` - -val PMATCH_REDUNDANT_ROWS_def = Define ` - PMATCH_REDUNDANT_ROWS rs = {i | (PMATCH_ROW_REDUNDANT rs i)}` - - - -(***************************************************) -(* Congruences *) -(***************************************************) +val IS_SOME_OPTION_MAP = prove ( + ``!f v. IS_SOME (OPTION_MAP f v) = IS_SOME v``, +Cases_on `v` THEN +SIMP_TAC list_ss []) -val some_eq_SOME = store_thm ("some_eq_SOME", +val some_eq_SOME = prove ( ``!P x. ((some x. P x) = SOME x) ==> (P x)``, SIMP_TAC std_ss [some_def] THEN REPEAT STRIP_TAC THEN SELECT_ELIM_TAC THEN PROVE_TAC[]) -val some_eq_NONE = store_thm ("some_eq_NONE", +val some_eq_NONE = prove ( ``!P. ((some x. P x) = NONE) <=> (!x. ~(P x))``, SIMP_TAC std_ss [some_def]) -val some_IS_SOME = store_thm ("some_IS_SOME", +val some_IS_SOME = prove ( ``!P. (IS_SOME (some x. P x)) <=> (?x. P x)``, SIMP_TAC (std_ss++boolSimps.LIFT_COND_ss) [some_def]) -val some_IS_SOME_EXISTS = store_thm ("some_IS_SOME_EXISTS", +val some_IS_SOME_EXISTS = prove ( ``!P. (IS_SOME (some x. P x)) <=> (?x. P x /\ ((some x. P x) = SOME x))``, GEN_TAC THEN EQ_TAC THEN REPEAT STRIP_TAC THEN ( ASM_SIMP_TAC std_ss [] @@ -68,8 +38,7 @@ Cases_on `some x. P x` THEN FULL_SIMP_TAC std_ss [] THEN MATCH_MP_TAC some_eq_SOME THEN ASM_REWRITE_TAC[]) - -val OPTION_MAP_EQ_OPTION_MAP = store_thm ("OPTION_MAP_EQ_OPTION_MAP", +val OPTION_MAP_EQ_OPTION_MAP = prove ( ``(OPTION_MAP f x = OPTION_MAP f' x') = (((x = NONE) /\ (x' = NONE)) \/ (?y y'. (x = SOME y) /\ (x' = SOME y') /\ (f y = f' y')))``, @@ -78,8 +47,45 @@ Cases_on `x` THEN Cases_on `x'` THEN ( SIMP_TAC std_ss [] )) + +(***************************************************) +(* Main Definitions *) +(***************************************************) + +(* rows of a pattern match are pairs of a pattern to match + against pat, a guard and a result value. *) +val PMATCH_ROW_COND_def = Define `PMATCH_ROW_COND pat guard i x = + (pat x = i) /\ (guard x)` + +val PMATCH_ROW_def = Define `PMATCH_ROW pat guard res i = + (OPTION_MAP res (some x. PMATCH_ROW_COND pat guard i x))` + + +(* We defined semantics of single rows. Let's extend + it to multiple ones, i.e. full pattern matches now *) +val PMATCH_INCOMPLETE_def = Define `PMATCH_INCOMPLETE = ARB` +val PMATCH_def = Define ` + (PMATCH v [] = PMATCH_INCOMPLETE) /\ + (PMATCH v (r::rs) = option_CASE (r v) (PMATCH v rs) I)` + + +val PMATCH_IS_EXHAUSTIVE_def = Define ` + PMATCH_IS_EXHAUSTIVE v rs = ( + EXISTS (\r. IS_SOME (r v)) rs)` + +val PMATCH_ROW_REDUNDANT_def = Define ` + PMATCH_ROW_REDUNDANT v rs i = ( + (i < LENGTH rs /\ (IS_SOME ((EL i rs) v) ==> + (?j. ((j < i) /\ IS_SOME ((EL j rs) v))))))` + + + +(***************************************************) +(* Congruences *) +(***************************************************) + val PMATCH_ROW_CONG = store_thm ("PMATCH_ROW_CONG", -``!p p' g g' r r' v v'. +``!p p' g g' r r' v v'. (p = p') /\ (v = v') /\ (!x. (v = (p x)) ==> (g x = g' x)) /\ (!x. ((v = (p x)) /\ (g x)) ==> @@ -95,8 +101,9 @@ Cases_on `some x. (p' x = v') /\ (g' x)` THEN ( POP_ASSUM (fn thm => MP_TAC (HO_MATCH_MP (SPEC_ALL some_eq_SOME) thm)) THEN ASM_SIMP_TAC std_ss []) + val PMATCH_CONG = store_thm ("PMATCH_CONG", -``!v v' rows rows'. ((v = v') /\ (r v' = r' v') /\ +``!v v' rows rows'. ((v = v') /\ (r v' = r' v') /\ (PMATCH v' rows = PMATCH v' rows')) ==> (PMATCH v (r :: rows) = PMATCH v' (r' :: rows'))``, SIMP_TAC std_ss [PMATCH_def]) @@ -110,7 +117,7 @@ val _ = DefnBase.export_cong "PMATCH_CONG"; (***************************************************) val PMATCH_ROW_EQ_AUX = store_thm ("PMATCH_ROW_EQ_AUX", - ``((!i. (?x. PMATCH_ROW_COND p g i x) = + ``((!i. (?x. PMATCH_ROW_COND p g i x) = (?x'. PMATCH_ROW_COND p' g' i x')) /\ (!x x'. ((p x = p' x') /\ g x /\ g' x') ==> (r x = r' x'))) ==> (PMATCH_ROW p g r = PMATCH_ROW p' g' r')``, @@ -142,7 +149,7 @@ val PMATCH_ROW_EQ_SOME = store_thm ("PMATCH_ROW_EQ_SOME", ``(PMATCH_ROW p g r i = SOME y) ==> (?x. (PMATCH_ROW_COND p g i x) /\ (y = r x))``, SIMP_TAC std_ss [PMATCH_ROW_def] THEN -REPEAT STRIP_TAC THEN +REPEAT STRIP_TAC THEN Q.EXISTS_TAC `z` THEN IMP_RES_TAC some_eq_SOME THEN ASM_SIMP_TAC std_ss []); @@ -151,11 +158,11 @@ ASM_SIMP_TAC std_ss []); val PMATCH_EVAL = store_thm ("PMATCH_EVAL", ``(PMATCH v [] = PMATCH_INCOMPLETE) /\ (PMATCH v ((PMATCH_ROW p g r) :: rs) = - if (?x. (PMATCH_ROW_COND p g v x)) then + if (?x. (PMATCH_ROW_COND p g v x)) then (r (@x. PMATCH_ROW_COND p g v x)) else PMATCH v rs)``, SIMP_TAC std_ss [PMATCH_def] THEN -Cases_on `PMATCH_ROW p g r v` THENL [ +Cases_on `PMATCH_ROW p g r v` THENL [ FULL_SIMP_TAC std_ss [PMATCH_ROW_def, some_eq_NONE], FULL_SIMP_TAC std_ss [PMATCH_ROW_def, some_def] THEN @@ -168,22 +175,15 @@ val PMATCH_EVAL_MATCH = store_thm ("PMATCH_EVAL_MATCH", (r (@x.PMATCH_ROW_COND p g v x)))``, SIMP_TAC std_ss [PMATCH_EVAL, - PMATCH_ROW_EQ_NONE]) + PMATCH_ROW_EQ_NONE]); -val PMATCH_EVAL_MATCH = store_thm ("PMATCH_EVAL_MATCH", - ``~(PMATCH_ROW p g r v = NONE) ==> - (PMATCH v ((PMATCH_ROW p g r) :: rs) = - (r (@x.PMATCH_ROW_COND p g v x)))``, - -SIMP_TAC std_ss [PMATCH_EVAL, - PMATCH_ROW_EQ_NONE]) (***************************************************) (* Changing rows and removing redundant ones *) (***************************************************) -(* An easy way is to start with an empty set of rows +(* An easy way is to start with an empty list of rows and then step by step add rows to either one or both sides till the desired correspondance is shown. This is achieved by the following theorems. *) @@ -192,20 +192,20 @@ val PMATCH_EXTEND_BASE = store_thm ("PMATCH_EXTEND_BASE", SIMP_TAC std_ss [PMATCH_def]) val PMATCH_EXTEND_BOTH = store_thm ("PMATCH_EXTEND_BOTH", -``!v_old v_new rows_old rows_new r_old r_new. +``!v_old v_new rows_old rows_new r_old r_new. (r_old v_old = r_new v_new) ==> (PMATCH v_old rows_old = PMATCH v_new rows_new) ==> (PMATCH v_old (r_old::rows_old) = PMATCH v_new (r_new :: rows_new))``, SIMP_TAC std_ss [PMATCH_def]) val PMATCH_EXTEND_BOTH_ID = store_thm ("PMATCH_EXTEND_BOTH_ID", -``!v rows_old rows_new r. +``!v rows_old rows_new r. (PMATCH v rows_old = PMATCH v rows_new) ==> (PMATCH v (r::rows_old) = PMATCH v (r :: rows_new))``, SIMP_TAC std_ss [PMATCH_def]) val PMATCH_EXTEND_OLD = store_thm ("PMATCH_EXTEND_OLD", -``!v_old v_new rows_old rows_new r_old. +``!v_old v_new rows_old rows_new r_old. (r_old v_old = NONE) ==> (PMATCH v_old rows_old = PMATCH v_new rows_new) ==> (PMATCH v_old (r_old::rows_old) = PMATCH v_new rows_new)``, @@ -223,18 +223,26 @@ val PMATCH_EQUIV_ROWS_def = Define ` ((?r. MEM r rows1 /\ IS_SOME (r v)) = (?r. MEM r rows2 /\ IS_SOME (r v))))` + +val PMATCH_EQUIV_ROWS_EQUIV_EXPAND = store_thm ("PMATCH_EQUIV_ROWS_EQUIV_EXPAND", + ``PMATCH_EQUIV_ROWS v rows1 rows2 = ( + PMATCH_EQUIV_ROWS v rows1 = PMATCH_EQUIV_ROWS v rows2)``, + +SIMP_TAC std_ss [PMATCH_EQUIV_ROWS_def, FUN_EQ_THM] THEN +METIS_TAC[]) + val PMATCH_EQUIV_ROWS_is_equiv_1 = store_thm ("PMATCH_EQUIV_ROWS_is_equiv_1", ``(!rows. (PMATCH_EQUIV_ROWS v rows rows))``, SIMP_TAC std_ss [PMATCH_EQUIV_ROWS_def]) - + val PMATCH_EQUIV_ROWS_is_equiv_2 = store_thm ("PMATCH_EQUIV_ROWS_is_equiv_2", ``(!rows1 rows2. ((PMATCH_EQUIV_ROWS v rows1 rows2) = (PMATCH_EQUIV_ROWS v rows2 rows1)))``, SIMP_TAC std_ss [PMATCH_EQUIV_ROWS_def] THEN METIS_TAC[]) val PMATCH_EQUIV_ROWS_is_equiv_3 = store_thm ("PMATCH_EQUIV_ROWS_is_equiv_3", - ``(!rows1 rows2 rows3. + ``(!v rows1 rows2 rows3. (PMATCH_EQUIV_ROWS v rows1 rows2) ==> (PMATCH_EQUIV_ROWS v rows2 rows3) ==> (PMATCH_EQUIV_ROWS v rows1 rows3))``, @@ -258,14 +266,281 @@ Cases_on `h v` THEN ( ASM_SIMP_TAC std_ss [] )) -val PMATCH_APPEND = store_thm ("PMATCH_EXTEND_APPEND", -``!v rows1a rows1b rows2a rows2b. - (PMATCH_EQUIV_ROWS v rows1a rows1b) ==> - (PMATCH_EQUIV_ROWS v rows2a rows2b) ==> +val PMATCH_EQUIV_APPEND = store_thm ("PMATCH_EQUIV_APPEND", +``!v rows1a rows1b rows2a rows2b. + (PMATCH_EQUIV_ROWS v rows1a rows1b) ==> + (PMATCH_EQUIV_ROWS v rows2a rows2b) ==> (PMATCH_EQUIV_ROWS v (rows1a ++ rows2a) (rows1b ++ rows2b))``, REPEAT STRIP_TAC THEN -FULL_SIMP_TAC list_ss [PMATCH_EQUIV_ROWS_def, RIGHT_AND_OVER_OR, - EXISTS_OR_THM, PMATCH_APPEND_SEM]) +FULL_SIMP_TAC list_ss [PMATCH_EQUIV_ROWS_def, RIGHT_AND_OVER_OR, + EXISTS_OR_THM, PMATCH_APPEND_SEM]); + + +val PMATCH_EQUIV_ROWS_CONS_NONE = store_thm("PMATCH_EQUIV_ROWS_CONS_NONE", +``(row v = NONE) ==> ( + PMATCH_EQUIV_ROWS v (row::rows) = + PMATCH_EQUIV_ROWS v rows)``, + +SIMP_TAC list_ss [GSYM PMATCH_EQUIV_ROWS_EQUIV_EXPAND, + PMATCH_EQUIV_ROWS_def, RIGHT_AND_OVER_OR, + EXISTS_OR_THM, PMATCH_def]) + + +val IS_REDUNDANT_ROWS_INFO_def = Define ` + IS_REDUNDANT_ROWS_INFO v rows infos <=> ( + (LENGTH rows = LENGTH infos) /\ + (!i. i < LENGTH rows ==> EL i infos ==> + PMATCH_ROW_REDUNDANT v rows i))` + + +val IS_REDUNDANT_ROWS_INFO_CONS = store_thm ( + "IS_REDUNDANT_ROWS_INFO_CONS", +`` + IS_REDUNDANT_ROWS_INFO v (row::rows) (i::infos') = ( + (LENGTH rows = LENGTH infos') /\ + (i ==> ((row v) = NONE)) /\ + ((row v = NONE) ==> IS_REDUNDANT_ROWS_INFO v rows infos') +)``, + +EQ_TAC THEN SIMP_TAC list_ss [IS_REDUNDANT_ROWS_INFO_def] THEN +REPEAT STRIP_TAC THENL [ + Q.PAT_ASSUM `!i'. _` (MP_TAC o SPEC ``0``) THEN + ASM_SIMP_TAC list_ss [PMATCH_ROW_REDUNDANT_def], + + Q.PAT_ASSUM `!i'. _` (MP_TAC o Q.SPEC `SUC i'`) THEN + FULL_SIMP_TAC list_ss [PMATCH_ROW_REDUNDANT_def] THEN + REPEAT STRIP_TAC THEN + FULL_SIMP_TAC std_ss [] THEN + Q.PAT_ASSUM `row v = NONE` ASSUME_TAC THEN + Q.EXISTS_TAC `PRE j` THEN + Cases_on `j` THEN ( + FULL_SIMP_TAC list_ss [] + ), + + FULL_SIMP_TAC list_ss [PMATCH_ROW_REDUNDANT_def] THEN + `(i'=0) \/ (?i''. (i' = SUC i''))` by ALL_TAC THENL [ + Cases_on `i'` THEN SIMP_TAC std_ss [], + FULL_SIMP_TAC list_ss [], + ALL_TAC + ] THEN + FULL_SIMP_TAC list_ss [] THEN + STRIP_TAC THEN + Tactical.REVERSE (Cases_on `row v`) THEN1 ( + Q.EXISTS_TAC `0` THEN + ASM_SIMP_TAC list_ss [] + ) THEN + FULL_SIMP_TAC std_ss [] THEN + Q.PAT_ASSUM `!i. _` (MP_TAC o Q.SPEC `i''`) THEN + ASM_SIMP_TAC std_ss [] THEN + STRIP_TAC THEN + Q.EXISTS_TAC `SUC j` THEN + ASM_SIMP_TAC list_ss [] +]) + + +val APPLY_REDUNDANT_ROWS_INFO_def = Define ` + (APPLY_REDUNDANT_ROWS_INFO is xs = MAP SND ( + FILTER (\x. ~ (FST x)) (ZIP (is, xs))))` + +val APPLY_REDUNDANT_ROWS_INFO_THMS = store_thm ( + "APPLY_REDUNDANT_ROWS_INFO_THMS", +``(APPLY_REDUNDANT_ROWS_INFO [] [] = []) /\ + (!is x xs. (APPLY_REDUNDANT_ROWS_INFO (T::is) (x::xs) = + (APPLY_REDUNDANT_ROWS_INFO is xs))) /\ + (!is x xs. (APPLY_REDUNDANT_ROWS_INFO (F::is) (x::xs) = + x::(APPLY_REDUNDANT_ROWS_INFO is xs)))``, + +SIMP_TAC list_ss [APPLY_REDUNDANT_ROWS_INFO_def]); + + +val PMATCH_ROWS_DROP_REDUNDANT_EQUIV = store_thm ("PMATCH_ROWS_DROP_REDUNDANT_EQUIV", +``!v rows infos. IS_REDUNDANT_ROWS_INFO v rows infos ==> + (PMATCH_EQUIV_ROWS v rows (APPLY_REDUNDANT_ROWS_INFO infos rows))``, + +GEN_TAC THEN +Induct_on `rows` THEN1 ( + SIMP_TAC (list_ss++QUANT_INST_ss [std_qp]) [ + IS_REDUNDANT_ROWS_INFO_def, + APPLY_REDUNDANT_ROWS_INFO_def, + PMATCH_EQUIV_ROWS_is_equiv_1] +) THEN +CONV_TAC (RENAME_VARS_CONV ["row"]) THEN +REPEAT STRIP_TAC THEN +`?i infos'. infos = i::infos'` by ALL_TAC THEN1 ( + Cases_on `infos` THEN + FULL_SIMP_TAC list_ss [IS_REDUNDANT_ROWS_INFO_def] +) THEN +FULL_SIMP_TAC std_ss [IS_REDUNDANT_ROWS_INFO_CONS] THEN +Q.PAT_ASSUM `!infos. _` (MP_TAC o Q.SPEC `infos'`) THEN +Cases_on `i` THENL [ + FULL_SIMP_TAC std_ss [APPLY_REDUNDANT_ROWS_INFO_THMS, + PMATCH_EQUIV_ROWS_CONS_NONE], + + Cases_on `row v` THEN ( + FULL_SIMP_TAC std_ss [APPLY_REDUNDANT_ROWS_INFO_THMS, + PMATCH_EQUIV_ROWS_CONS_NONE, PMATCH_EQUIV_ROWS_EQUIV_EXPAND] + ) THEN + STRIP_TAC THEN + ASM_SIMP_TAC list_ss [PMATCH_EQUIV_ROWS_def, + GSYM PMATCH_EQUIV_ROWS_EQUIV_EXPAND, RIGHT_AND_OVER_OR, + EXISTS_OR_THM, PMATCH_def] +]) + + +val IS_REDUNDANT_ROWS_INFO_GEN_def = Define ` + IS_REDUNDANT_ROWS_INFO_GEN vf gf rows infos = ( + (LENGTH rows = LENGTH infos) /\ + (!x. gf x ==> IS_REDUNDANT_ROWS_INFO (vf x) rows infos))`; + + +val IS_REDUNDANT_ROWS_INFO_GEN_NIL = store_thm ("IS_REDUNDANT_ROWS_INFO_GEN_NIL", + ``!vf gf. IS_REDUNDANT_ROWS_INFO_GEN vf gf [] []``, +SIMP_TAC list_ss [IS_REDUNDANT_ROWS_INFO_GEN_def, + IS_REDUNDANT_ROWS_INFO_def]); + + +val IS_REDUNDANT_ROWS_INFO_GEN_CONS_NONE = store_thm ("IS_REDUNDANT_ROWS_INFO_GEN_CONS_NONE", + ``!vf gf row rows infos pats. (!x. gf x ==> (row (vf x) = NONE)) ==> + IS_REDUNDANT_ROWS_INFO_GEN vf gf rows infos ==> + IS_REDUNDANT_ROWS_INFO_GEN vf gf (row::rows) (T::infos)``, + +SIMP_TAC list_ss [IS_REDUNDANT_ROWS_INFO_GEN_def, + IS_REDUNDANT_ROWS_INFO_def, FORALL_AND_THM, + IMP_CONJ_THM, GSYM RIGHT_FORALL_IMP_THM] THEN +REPEAT STRIP_TAC THEN +`(i=0) \/ (?i'. (i = SUC i'))` by ALL_TAC THENL [ + Cases_on `i` THEN SIMP_TAC std_ss [], + FULL_SIMP_TAC list_ss [PMATCH_ROW_REDUNDANT_def], + + FULL_SIMP_TAC list_ss [PMATCH_ROW_REDUNDANT_def, FORALL_AND_THM] THEN + Q.PAT_ASSUM `!x i''. _` (MP_TAC o Q.SPECL [`x`, `i'`]) THEN + ASM_SIMP_TAC std_ss [] THEN + REPEAT STRIP_TAC THEN + FULL_SIMP_TAC std_ss [] THEN + Q.EXISTS_TAC `SUC j` THEN + ASM_SIMP_TAC list_ss [] +]); + + +val IS_REDUNDANT_ROWS_INFO_GEN_CONS_SOME = store_thm ("IS_REDUNDANT_ROWS_INFO_GEN_CONS_SOME", + ``!vf gf row rows. (!x. gf x ==> IS_SOME (row (vf x))) ==> + IS_REDUNDANT_ROWS_INFO_GEN vf gf (row::rows) (F::(MAP (\x. T) rows))``, + +SIMP_TAC list_ss [IS_REDUNDANT_ROWS_INFO_GEN_def, + IS_REDUNDANT_ROWS_INFO_def, combinTheory.o_DEF] THEN +REPEAT STRIP_TAC THEN +`(i=0) \/ (?i'. (i = SUC i'))` by ALL_TAC THENL [ + Cases_on `i` THEN SIMP_TAC std_ss [], + FULL_SIMP_TAC list_ss [], + + FULL_SIMP_TAC list_ss [PMATCH_ROW_REDUNDANT_def] THEN + STRIP_TAC THEN + Q.EXISTS_TAC `0` THEN + ASM_SIMP_TAC list_ss [] +]) + + +val COMBINE_REDUNDANT_ROWS_INFOS_def = Define ` + COMBINE_REDUNDANT_ROWS_INFOS ip1 ip2 = + (MAP2 (\i1 i2. i1 /\ i2) ip1 ip2)`; + +val COMBINE_REDUNDANT_ROWS_INFOS_LIST_def = Define ` + (COMBINE_REDUNDANT_ROWS_INFOS_LIST [ip] = ip) /\ + (COMBINE_REDUNDANT_ROWS_INFOS_LIST (ip1::ip2::ips) = + COMBINE_REDUNDANT_ROWS_INFOS ip1 ( + COMBINE_REDUNDANT_ROWS_INFOS_LIST (ip2::ips)))`; + +val EL_MAP2 = store_thm ("EL_MAP2", +``!n l1 l2. n < LENGTH l1 /\ n < LENGTH l2 ==> + (!f. EL n (MAP2 f l1 l2) = f (EL n l1) (EL n l2))``, + +Induct_on `n` THEN1 ( + SIMP_TAC (list_ss++QUANT_INST_ss[std_qp]) [] +) THEN +REPEAT STRIP_TAC THEN +Cases_on `l1` THEN Cases_on `l2` THEN ( + FULL_SIMP_TAC list_ss [] +)) + + +val COMBINE_REDUNDANT_ROWS_INFOS_LIST_LENGTH_INFOS = store_thm ( +"COMBINE_REDUNDANT_ROWS_INFOS_LIST_LENGTH_INFOS", +``!l ips infos. + ~(ips = []) ==> + EVERY (\ip. (LENGTH ip = l)) ips ==> + (COMBINE_REDUNDANT_ROWS_INFOS_LIST ips = infos) ==> + ((LENGTH infos = l) /\ + (!i. i < l ==> EL i infos ==> + EVERY (\ip. EL i ip) ips))``, + +GEN_TAC THEN +Induct_on `ips` THEN SIMP_TAC list_ss [] THEN +CONV_TAC (RENAME_VARS_CONV ["ip"]) THEN +Cases_on `ips = []` THEN1 ( + FULL_SIMP_TAC list_ss [COMBINE_REDUNDANT_ROWS_INFOS_LIST_def] +) THEN +`?ip' ips'. ips = ip'::ips'` by (Cases_on `ips` THEN FULL_SIMP_TAC list_ss []) THEN +FULL_SIMP_TAC list_ss [COMBINE_REDUNDANT_ROWS_INFOS_LIST_def] THEN +REPEAT GEN_TAC THEN REPEAT DISCH_TAC THEN +`?infos'. + COMBINE_REDUNDANT_ROWS_INFOS_LIST (ip'::ips') = infos'` by + ALL_TAC THEN1 ( + PROVE_TAC[] +) THEN +FULL_SIMP_TAC list_ss [COMBINE_REDUNDANT_ROWS_INFOS_def] THEN +ASM_SIMP_TAC list_ss [rich_listTheory.LENGTH_MAP2, + EL_MAP2]); + + +val IS_REDUNDANT_ROWS_INFO_GEN_SPLIT = store_thm ("IS_REDUNDANT_ROWS_INFO_GEN_SPLIT", + ``!vf gf vips rows infos pats. ( + ~(vips = []) /\ + (EVERY (\ ((vf', gf'), infos'). + IS_REDUNDANT_ROWS_INFO_GEN vf' gf' rows infos') vips) /\ + (!x. gf x ==> + EXISTS (\ ((vf', gf'), infos'). ?x'. (gf' x') /\ (vf' x' = vf x)) vips) /\ + (COMBINE_REDUNDANT_ROWS_INFOS_LIST (MAP SND vips) = + infos)) ==> + + IS_REDUNDANT_ROWS_INFO_GEN vf gf rows infos``, + +REPEAT STRIP_TAC THEN +FULL_SIMP_TAC std_ss [IS_REDUNDANT_ROWS_INFO_GEN_def, + GSYM FORALL_AND_THM] THEN +`EVERY (\vip. LENGTH (SND vip) = LENGTH rows) vips` by ALL_TAC THEN1 ( + Q.PAT_ASSUM `EVERY _ vips` MP_TAC THEN + REPEAT (POP_ASSUM (K ALL_TAC)) THEN + SIMP_TAC (std_ss++pairSimps.gen_beta_ss) [EVERY_MEM] +) THEN +MP_TAC (Q.ISPECL [`LENGTH (rows : ('b -> 'd option) list)`, + `MAP SND (vips : ((('c -> 'b) # ('c -> bool)) # bool list) list)`] + COMBINE_REDUNDANT_ROWS_INFOS_LIST_LENGTH_INFOS) THEN +ASM_SIMP_TAC list_ss [MAP_EQ_NIL, EVERY_MAP] THEN +REPEAT STRIP_TAC THEN +`?vf' gf' infos' x'. (MEM ((vf', gf'), infos') vips) /\ + gf' x' /\ (vf' x' = vf x)` by ALL_TAC THEN1 ( + RES_TAC THEN + FULL_SIMP_TAC std_ss [EXISTS_MEM] THEN + Cases_on `e` THEN Cases_on `q` THEN + FULL_SIMP_TAC std_ss [] THEN + METIS_TAC[] +) THEN +`IS_REDUNDANT_ROWS_INFO (vf x) rows infos'` by ALL_TAC THEN1 ( + FULL_SIMP_TAC std_ss [EVERY_MEM] THEN + RES_TAC THEN + FULL_SIMP_TAC std_ss [] THEN + METIS_TAC[] +) THEN +Q.PAT_ASSUM `IS_REDUNDANT_ROWS_INFO _ _ _` MP_TAC THEN +ASM_SIMP_TAC std_ss [IS_REDUNDANT_ROWS_INFO_def, + AND_IMP_INTRO] THEN +REPEAT STRIP_TAC THEN +Q.PAT_ASSUM `!i. _ ==> _` MATCH_MP_TAC THEN +Q.PAT_ASSUM `!i. _` (MP_TAC o Q.SPEC `i`) THEN +ASM_SIMP_TAC std_ss [EVERY_MEM] THEN +REPEAT STRIP_TAC THEN +RES_TAC THEN +FULL_SIMP_TAC std_ss []); (* If we have a row that matches, everything after it can be dropped *) @@ -301,7 +576,7 @@ ASM_REWRITE_TAC[]) val PMATCH_REMOVE_ARB = store_thm ("PMATCH_REMOVE_ARB", ``(!x. r x = ARB) ==> - (PMATCH v (SNOC (PMATCH_ROW p g r) rows) = + (PMATCH v (SNOC (PMATCH_ROW p g r) rows) = PMATCH v rows)``, Induct_on `rows` THENL [ @@ -309,13 +584,13 @@ Induct_on `rows` THENL [ ASM_SIMP_TAC list_ss [PMATCH_def] ]) -(* ARB rows can be removed, since a match failiure is the same +(* ARB rows can be removed, since a match failiure is the same as ARB *) val PMATCH_REMOVE_ARB_NO_OVERLAP = store_thm ("PMATCH_REMOVE_ARB_NO_OVERLAP", ``!v p g r rows1 rows2. ((!x. (r x = ARB)) /\ (!x. ((v = p x) /\ (g x)) ==> EVERY (\row. (row (p x) = NONE)) rows2)) ==> - (PMATCH v (rows1 ++ ((PMATCH_ROW p g r) :: rows2)) = + (PMATCH v (rows1 ++ ((PMATCH_ROW p g r) :: rows2)) = PMATCH v (rows1 ++ rows2))``, REPEAT STRIP_TAC THEN @@ -336,7 +611,7 @@ Induct_on `rows2` THEN ( (* Add an injective function to the pattern and the value. - This can be used to eliminate constructors. *) + This can be used to eliminate constructors. *) val PMATCH_ROW_REMOVE_FUN = store_thm ("PMATCH_ROW_REMOVE_FUN", ``!ff v p g r. (!x y. (ff x = ff y) ==> (x = y)) ==> @@ -349,7 +624,7 @@ ASM_SIMP_TAC std_ss [PMATCH_ROW_def, PMATCH_ROW_COND_def]) (* val PMATCH_ROW_REMOVE_FUN_EXT = store_thm ("PMATCH_ROW_REMOVE_FUN_EXT", -``!ff v f f' g g'. +``!ff v f f' g g'. ((?x. f' x = ff v) = (?x. f x = v)) ==> (!x x'. (f' x = ff v) ==> (f x' = v) ==> (g x v = g' x')) ==> @@ -383,13 +658,13 @@ PROVE_TAC[]) PMATCH_ROW (\(x', y). (x', y)) (K T) (\(x', y). x') ]`` - We want to simplify this to + We want to simplify this to val t = ``PMATCH (x, y) [ PMATCH_ROW (\x. (x, 0)) (K T) (\x. (SOME (x + y))); PMATCH_ROW (\(x'', y). (x'', y)) (K T) (\(x'', y). SOME x'') ]`` - + This is done via PMATCH_ROWS_SIMP and PMATCH_ROWS_SIMP_SOUNDNESS. We need to show that the rows correspond to each other. @@ -397,7 +672,7 @@ PROVE_TAC[]) v := (x, y) ff (x, y) := (SOME x, y) - + p x := (x, 0) r x := SOME (x + y) @@ -407,7 +682,7 @@ PROVE_TAC[]) v := (SOME x, y) v' := (x, y) p (x', y) := (x', y) - r (x', y) := x' + r (x', y) := x' p' (x'', y) = (x'', y) f (x'', y) := (SOME x'', y) *) @@ -439,56 +714,82 @@ FULL_SIMP_TAC std_ss [PMATCH_ROW_COND_def] THEN METIS_TAC[]); -(* (***************************************************) (* THEOREMS ABOUT FLATTENING *) (***************************************************) val PMATCH_FLATTEN_FUN_def = Define ` - PMATCH_FLATTEN_FUN f g h v = - if (?x. g x = v) then h (f (@x. g x = v)) else NONE` + PMATCH_FLATTEN_FUN p g row v = ( + option_CASE (some x. PMATCH_ROW_COND p g v x) + NONE (\x. row x x))`; + val PMATCH_FLATTEN_THM_AUX = prove ( - ``(PMATCH v [PMATCH_ROW (\x. (g x, (PMATCH (f x) (MAP (\r. r x) rows'))))]) = - (PMATCH v (MAP (\r. (PMATCH_FLATTEN_FUN f g) (r (@x. g x = v))) rows'))``, + ``(PMATCH v [PMATCH_ROW p g (\x. (PMATCH x (MAP (\r. r x) rows')))]) = + (PMATCH v (MAP (\r. (PMATCH_FLATTEN_FUN p g r)) rows'))``, +REPEAT GEN_TAC THEN Induct_on `rows'` THEN1 ( - Cases_on `?x. g x = v` THEN + Cases_on `some x. PMATCH_ROW_COND p g v x` THEN ASM_SIMP_TAC list_ss [PMATCH_def, PMATCH_ROW_def] ) THEN -Cases_on `?x. g x = v` THENL [ - GEN_TAC THEN - ASM_SIMP_TAC list_ss [PMATCH_def, PMATCH_ROW_def, PMATCH_FLATTEN_FUN_def] THEN - FULL_SIMP_TAC list_ss [PMATCH_def, PMATCH_ROW_def], +Q.PAT_ASSUM `_ = _` (ASSUME_TAC o GSYM) THEN +FULL_SIMP_TAC list_ss [PMATCH_def, PMATCH_ROW_def] THEN +Q.PAT_ASSUM `_ = _` (K ALL_TAC) THEN + +Cases_on `some x. PMATCH_ROW_COND p g v x` THEN ( + ASM_SIMP_TAC std_ss [PMATCH_FLATTEN_FUN_def] +)); - GEN_TAC THEN - `!r. (PMATCH_FLATTEN_FUN f g r v) = NONE` by ALL_TAC THEN1 ( - ASM_SIMP_TAC std_ss [PMATCH_FLATTEN_FUN_def] - ) THEN - FULL_SIMP_TAC list_ss [PMATCH_def, PMATCH_ROW_def] -]) + +val PMATCH_FLATTEN_THM = store_thm ("PMATCH_FLATTEN_THM", + ``!v p g r rows. + (!x. PMATCH_IS_EXHAUSTIVE x (MAP (\r. r x) rows)) ==> +PMATCH_EQUIV_ROWS v [PMATCH_ROW p g (\x. (PMATCH x (MAP (\r. r x) rows)))] (MAP (\r. (PMATCH_FLATTEN_FUN p g r)) rows)``, + +REPEAT STRIP_TAC THEN +SIMP_TAC list_ss [PMATCH_EQUIV_ROWS_def, PMATCH_FLATTEN_THM_AUX] THEN +SIMP_TAC list_ss [PMATCH_ROW_def, IS_SOME_OPTION_MAP, some_IS_SOME, + listTheory.MEM_MAP, GSYM LEFT_EXISTS_AND_THM] THEN + +SIMP_TAC std_ss [PMATCH_FLATTEN_FUN_def, some_def] THEN +Cases_on `?x. PMATCH_ROW_COND p g v x` THEN ( + ASM_SIMP_TAC std_ss [PMATCH_ROW_COND_def] +) THEN +FULL_SIMP_TAC std_ss [PMATCH_IS_EXHAUSTIVE_def, + listTheory.EXISTS_MEM, listTheory.MEM_MAP, + GSYM LEFT_EXISTS_AND_THM]) val PMATCH_FLATTEN_FUN_PMATCH_ROW = store_thm ("PMATCH_FLATTEN_FUN_PMATCH_ROW", -``(!x1 x2. (g x1 = g x2) ==> (x1 = x2)) ==> - (!x y. (g'' x = y) = (g' x = f y)) ==> ( - PMATCH_FLATTEN_FUN f g (PMATCH_ROW (\x'. (g' x', f' x'))) = - PMATCH_ROW (\x. (g (g'' x), f' x)))``, +``!p g p' g' r'. + (!x1 x2. (p x1 = p x2) ==> (x1 = x2)) ==> ( + + PMATCH_FLATTEN_FUN p g (\x. PMATCH_ROW p' (g' x) (r' x)) = + PMATCH_ROW (\x. (p (p' x))) (\x. (g (p' x)) /\ (g' (p' x) x)) (\x. r' (p' x) x))``, REPEAT STRIP_TAC THEN SIMP_TAC std_ss [PMATCH_FLATTEN_FUN_def, FUN_EQ_THM, PMATCH_ROW_def] THEN -GEN_TAC THEN -Tactical.REVERSE (Cases_on `?x'. g x' = x`) THEN1 ( - `~(?x'. g (g'' x') = x)` by METIS_TAC[] THEN - ASM_REWRITE_TAC[] +CONV_TAC (RENAME_VARS_CONV ["v"]) THEN GEN_TAC THEN +Cases_on ` some x. PMATCH_ROW_COND p g v x` THEN1 ( + FULL_SIMP_TAC list_ss [some_eq_NONE, PMATCH_ROW_COND_def] THEN + PROVE_TAC[] ) THEN -FULL_SIMP_TAC std_ss [] THEN -`!x''. (g x'' = x) = (x'' = x')` by METIS_TAC[] THEN + ASM_SIMP_TAC std_ss [] THEN -METIS_TAC[]) +FULL_SIMP_TAC std_ss [PMATCH_ROW_COND_def] THEN +Q.PAT_ASSUM `_ = SOME x` (fn thm => + ASSUME_TAC (HO_MATCH_MP some_eq_SOME thm)) THEN +`!x'. (p x' = v) = (x' = x)` by PROVE_TAC[] THEN +ASM_SIMP_TAC (std_ss++boolSimps.CONJ_ss) [] THEN +Cases_on `(some x'. (p' x' = x) ∧ g' x x')` THEN ( + ASM_SIMP_TAC std_ss [] +) THEN +Q.PAT_ASSUM `_ = SOME x'` (fn thm => + ASSUME_TAC (HO_MATCH_MP some_eq_SOME thm)) THEN +ASM_SIMP_TAC std_ss []) -*) -val _ = export_theory() +val _ = export_theory() diff --git a/examples/deep_matches/deepMatchesSyntax.sml b/examples/deep_matches/deepMatchesSyntax.sml index 9b8390459e..7c62891615 100644 --- a/examples/deep_matches/deepMatchesSyntax.sml +++ b/examples/deep_matches/deepMatchesSyntax.sml @@ -3,7 +3,7 @@ struct open HolKernel Parse boolLib bossLib open deepMatchesTheory - +open pairSyntax (* Stolen from pairTools. TODO: @@ -44,7 +44,7 @@ val ty_var_subst = [alpha |-> gen_tyvar (), ] val PMATCH_ROW_tm = ``PMATCH_ROW`` -val PMATCH_ROW_gtm = inst ty_var_subst PMATCH_ROW_tm +val PMATCH_ROW_gtm = inst ty_var_subst PMATCH_ROW_tm; val PMATCH_tm = ``PMATCH`` val PMATCH_gtm = inst ty_var_subst PMATCH_tm @@ -101,7 +101,7 @@ fun dest_PMATCH_ROW_ABS_VARIANT vs row = let val (p_vars', sub) = variant_of_term vs p_vars in (p_vars', subst sub p_body, subst sub g_body, subst sub r_body) -end +end; fun PMATCH_ROW_PABS_ELIM_CONV row = let @@ -115,7 +115,7 @@ fun PMATCH_ROW_PABS_ELIM_CONV row = let handle UNCHANGED => REFL row in (vars, thm) -end +end; fun PMATCH_ROW_PABS_INTRO_CONV vars row = let @@ -128,7 +128,7 @@ fun PMATCH_ROW_PABS_INTRO_CONV vars row = let (RATOR_CONV (RATOR_CONV (RAND_CONV c)))) row in thm -end +end; fun PMATCH_ROW_FORCE_SAME_VARS_CONV row = let val _ = if not (is_PMATCH_ROW row) then raise UNCHANGED else () @@ -231,22 +231,34 @@ fun pmatch_printer GS backend sys (ppfns:term_pp_types.ppstream_funs) gravs d t fun pp_row (vars, pat, guard, rh) = ( term_pp_utils.record_bvars (pairSyntax.strip_pair vars) ( ublock PP.CONSISTENT 0 ( - add_string "|" >> add_break (1, 0) >> + (if ((type_of vars = oneSyntax.one_ty) andalso + not (free_in vars pat) andalso + not (free_in vars guard) andalso + not (free_in vars rh)) then ( + add_string "||." >> add_break (1, 0) + ) else ( + add_string "||" >> add_break (1, 0) >> + sys (Top, Top, Top) (d - 1) vars >> + add_string "." >> + add_break (1, 0) + )) >> sys (Top, Top, Top) (d - 1) pat >> (if (aconv guard T) then nothing else ( add_break (1, 0) >> add_string "when" >> add_break (1, 0) >> - sys (Top, Top, Top) (d - 1) guard + sys (Top, Prec (2000, ""), Top) (d - 1) guard )) >> - add_break (1, 0) >> add_string "=>" >> add_break (1, 0) >> - sys (Top, Top, Top) (d - 1) rh + add_break (1, 0) >> add_string "~>" >> add_break (1, 0) >> + sys (Top, Prec (2000, ""), Top) (d - 1) rh )) ) in (ublock PP.CONSISTENT 2 (add_string "CASE" >> add_break(1,2) >> sys (Top, Top, Top) (d - 1) v >> - add_break(1,0) >> add_string "OF")) >> + add_break(1,0) >> add_string "OF [")) >> + add_break (1, 2) >> + smpp.pr_list pp_row (add_string ";" >> add_break (1, 2)) rows' >> add_break (1, 0) >> - smpp.pr_list pp_row (add_break (1, 0)) rows' + add_string "]" end handle HOL_ERR _ => raise term_pp_types.UserPP_Failed; val _ = add_user_printer ("PMATCH", ``PMATCH v l``, pmatch_printer); @@ -302,6 +314,115 @@ val _ = case lookup s of NONE => [] | SOME {constructors,...} => constructors)) - end + end; + + + + +val _ = new_constant ("PMATCH_magic_1", type_of ``PMATCH``) +val _ = new_constant ("PMATCH_ROW_magic_1", type_of + ``\abc. PMATCH_ROW (\x. FST (abc x)) (\x. FST (SND (abc x))) (\x. SND (SND ((abc x))))``) + +val _ = new_constant ("PMATCH_ROW_magic_0", type_of + ``\abc. PMATCH_ROW (\x:unit. FST abc) (\x. FST (SND abc)) (\x. SND (SND (abc)))``) + +val _ = new_constant ("PMATCH_ROW_magic_2", type_of + ``\(pat:'a) (g:bool) (res:'b). (pat,g,res)``) + +val _ = new_constant ("PMATCH_ROW_magic_3", type_of + ``\(pat:'a) (res:'b). (pat,T,res)``) + +val PMATCH_magic_1_tm = ``PMATCH_magic_1``; +val PMATCH_ROW_magic_0_tm = ``PMATCH_ROW_magic_0``; +val PMATCH_ROW_magic_1_tm = ``PMATCH_ROW_magic_1``; +val PMATCH_ROW_magic_2_tm = ``PMATCH_ROW_magic_2``; +val PMATCH_ROW_magic_3_tm = ``PMATCH_ROW_magic_3``; + +val _ = add_rule{pp_elements = [TOK "~>"], + fixity = Infix (NONASSOC, 3), + block_style = (AroundEachPhrase, (PP.CONSISTENT, 0)), + paren_style = OnlyIfNecessary, + term_name = "PMATCH_ROW_magic_3"} + +val _ = add_rule{term_name = "PMATCH_ROW_magic_2", + fixity = Infix (HOLgrammars.NONASSOC, 3), + pp_elements = [TOK "when", TM, TOK "~>"], + paren_style = OnlyIfNecessary, + block_style = (AroundEachPhrase, + (PP.INCONSISTENT, 0))}; + +val _ = add_rule{term_name = "PMATCH_ROW_magic_1", + fixity = Binder, + pp_elements = [TOK "||"], + paren_style = OnlyIfNecessary, + block_style = (AroundEachPhrase, + (PP.INCONSISTENT, 0))}; + +val _ = add_rule{term_name = "PMATCH_ROW_magic_0", + fixity = Prefix 2, + pp_elements = [TOK "||."], + paren_style = OnlyIfNecessary, + block_style = (AroundEachPhrase, + (PP.INCONSISTENT, 0))}; + +val _ = add_rule{term_name = "PMATCH_magic_1", + fixity = Closefix, + pp_elements = [TOK "CASE", TM, TOK "OF"], + paren_style = OnlyIfNecessary, + block_style = (AroundEachPhrase, + (PP.INCONSISTENT, 0))}; + + + +fun traverse f tm = + f tm handle HOL_ERR _ => + let + val (tm1, tm2) = dest_comb tm + in + mk_comb (traverse f tm1, traverse f tm2) + end handle HOL_ERR _ => + let + val (tm1, tm2) = dest_abs tm + in + mk_abs (traverse f tm1, traverse f tm2) + end handle HOL_ERR _ => tm; + + +fun fix_CASE tm = let + val (c, args) = strip_comb tm + in + if (same_const c PMATCH_magic_1_tm) then + let + val (arg_tys, base_ty) = strip_fun (type_of c) + val c' = inst [(alpha |-> hd arg_tys), (beta |-> base_ty)] PMATCH_tm; + val args' = map (traverse fix_CASE) args + in + list_mk_comb (c', args') + end + else if (same_const c PMATCH_ROW_magic_1_tm) orelse (same_const c PMATCH_ROW_magic_0_tm) then + let + val args' = map (traverse fix_CASE) args + val (vars, b) = if (same_const c PMATCH_ROW_magic_1_tm) then let + val (p_var, b) = dest_pabs (hd args') + val vars = pairSyntax.strip_pair p_var + in (vars, b) end else ([], hd args'); + val (b_c, b_args) = strip_comb b; + val (p, g, r) = if (same_const b_c PMATCH_ROW_magic_2_tm) then + (el 1 b_args, el 2 b_args, el 3 b_args) + else if (same_const b_c PMATCH_ROW_magic_3_tm) then + (el 1 b_args, T, el 2 b_args) + else failwith "unexpected constant"; + in + mk_PMATCH_ROW_PABS vars (p, g, r) + end + else failwith "no CASE" +end; + +(* +Preterm.post_process_term := I *) +val old_f = !Preterm.post_process_term; +val _ = (Preterm.post_process_term := (fn tm => (traverse fix_CASE (old_f tm)))); end + + From 39503d01aa6c5e9d0379ddc001d85da8e11b4d65 Mon Sep 17 00:00:00 2001 From: Thomas Tuerk Date: Sat, 14 Feb 2015 10:33:33 +0100 Subject: [PATCH 177/718] deepMatches examples some minor improvements looking at Magnus Myreen's red-black-tree example --- examples/deep_matches/deepMatchesExamples.sml | 3 ++- examples/deep_matches/deepMatchesLib.sml | 4 ++++ examples/deep_matches/deepMatchesSyntax.sml | 13 +++++++------ 3 files changed, 13 insertions(+), 7 deletions(-) diff --git a/examples/deep_matches/deepMatchesExamples.sml b/examples/deep_matches/deepMatchesExamples.sml index 8f6e703756..7d879f3325 100644 --- a/examples/deep_matches/deepMatchesExamples.sml +++ b/examples/deep_matches/deepMatchesExamples.sml @@ -30,7 +30,8 @@ val thm_t' = PMATCH_SIMP_CONV t' val example1 = `` CASE (a,x,xs) OF [ - || x. (NONE,x,[]) ~> x; + ||. (NONE,4,[]) ~> 0; + || x. (NONE,x,[]) when x < 10 ~> x; || x. (NONE,x,[2]) ~> x; || (x,v18). (NONE,x,[v18]) ~> 3; || (x,v12,v16,v17). (NONE,x,v12::v16::v17) ~> 3; diff --git a/examples/deep_matches/deepMatchesLib.sml b/examples/deep_matches/deepMatchesLib.sml index b66214ebf6..f21d50ad58 100644 --- a/examples/deep_matches/deepMatchesLib.sml +++ b/examples/deep_matches/deepMatchesLib.sml @@ -5,6 +5,7 @@ open HolKernel boolLib bossLib open deepMatchesTheory open simpLib open quantHeuristicsLib +open DatatypeSimps open deepMatchesSyntax open constrFamiliesLib @@ -72,6 +73,7 @@ val select_conj_ss = key = SOME ([],``$@ (f:'a -> bool)``), conv = K (K (SIMP_CONV (std_ss++boolSimps.CONJ_ss) []))}; + fun rc_ss gl = list_ss ++ simpLib.merge_ss (gl @ [pabs_elim_ss, @@ -80,6 +82,8 @@ fun rc_ss gl = list_ss ++ simpLib.merge_ss pairSimps.gen_beta_ss, select_conj_ss, elim_fst_snd_select_ss, + boolSimps.EQUIV_EXTRACT_ss, + type_rewrites_stateful_ss (), simpLib.rewrites [ pairTheory.EXISTS_PROD, pairTheory.FORALL_PROD, diff --git a/examples/deep_matches/deepMatchesSyntax.sml b/examples/deep_matches/deepMatchesSyntax.sml index 7c62891615..83e4020484 100644 --- a/examples/deep_matches/deepMatchesSyntax.sml +++ b/examples/deep_matches/deepMatchesSyntax.sml @@ -230,25 +230,26 @@ fun pmatch_printer GS backend sys (ppfns:term_pp_types.ppstream_funs) gravs d t fun pp_row (vars, pat, guard, rh) = ( term_pp_utils.record_bvars (pairSyntax.strip_pair vars) ( - ublock PP.CONSISTENT 0 ( + ublock PP.INCONSISTENT 5 ( (if ((type_of vars = oneSyntax.one_ty) andalso not (free_in vars pat) andalso not (free_in vars guard) andalso not (free_in vars rh)) then ( add_string "||." >> add_break (1, 0) ) else ( - add_string "||" >> add_break (1, 0) >> + add_string "||" >> + add_break (1, 0) >> sys (Top, Top, Top) (d - 1) vars >> add_string "." >> add_break (1, 0) - )) >> + )) >> sys (Top, Top, Top) (d - 1) pat >> (if (aconv guard T) then nothing else ( - add_break (1, 0) >> add_string "when" >> add_break (1, 0) >> + add_string " when" >> add_break (1, 0) >> sys (Top, Prec (2000, ""), Top) (d - 1) guard )) >> - add_break (1, 0) >> add_string "~>" >> add_break (1, 0) >> - sys (Top, Prec (2000, ""), Top) (d - 1) rh + add_string " ~>" >> add_break (1, 0) >> + sys (Top, Prec (2000, ""), Top) (d - 1) rh )) ) in From 4e5e090f9c4a99c284e81e596a70e051c00b80cb Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Fri, 13 Feb 2015 23:47:59 +0000 Subject: [PATCH 178/718] OpenTheory names for ind, ONE_ONE, and ONTO --- src/bool/boolScript.sml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/bool/boolScript.sml b/src/bool/boolScript.sml index a26efc14a3..43321e66de 100644 --- a/src/bool/boolScript.sml +++ b/src/bool/boolScript.sml @@ -26,6 +26,7 @@ val _ = OpenTheory_tyop_name {tyop={Thy="min",Tyop="fun"},name=([],"->")} val _ = OpenTheory_tyop_name {tyop={Thy="min",Tyop="bool"},name=([],"bool")} val _ = OpenTheory_const_name {const={Thy="min",Name="="},name=([],"=")} val _ = OpenTheory_const_name {const={Thy="min",Name="@"},name=([],"select")} +val _ = OpenTheory_tyop_name {tyop={Thy="min",Tyop="ind"},name=([],"ind")} val ns = ["Data","Bool"] @@ -155,12 +156,14 @@ val ONE_ONE_DEF = (f x1 = f x2) ==> (x1 = x2)`); val _ = add_const "ONE_ONE"; +val _ = OpenTheory_const_name {const={Thy="bool",Name="ONE_ONE"},name=(["Function"],"injective")} val ONTO_DEF = Definition.new_definition ("ONTO_DEF", Term `ONTO = \f:'a->'b. !y. ?x. y = f x`); val _ = add_const "ONTO"; +val _ = OpenTheory_const_name {const={Thy="bool",Name="ONTO"},name=(["Function"],"surjective")} val TYPE_DEFINITION = Definition.new_definition From 31921f82fd54907d3ab1d565d562719e8c6867f8 Mon Sep 17 00:00:00 2001 From: Thomas Tuerk Date: Sat, 14 Feb 2015 21:23:49 +0100 Subject: [PATCH 179/718] fix problem in deepMatches example As spotted by Ramana, I moved the definitions of auxiliary parsing constants out of deepMatchesSyntax. This prevents several problems, esp. it prevents a spurious theory being created. --- examples/deep_matches/deepMatchesScript.sml | 20 +++++++++- examples/deep_matches/deepMatchesSyntax.sml | 41 ++++++++------------- 2 files changed, 34 insertions(+), 27 deletions(-) diff --git a/examples/deep_matches/deepMatchesScript.sml b/examples/deep_matches/deepMatchesScript.sml index 21c37a68d2..cb2ad3fe83 100644 --- a/examples/deep_matches/deepMatchesScript.sml +++ b/examples/deep_matches/deepMatchesScript.sml @@ -79,6 +79,22 @@ val PMATCH_ROW_REDUNDANT_def = Define ` (?j. ((j < i) /\ IS_SOME ((EL j rs) v))))))` +(***************************************************) +(* Constants for parsing magic *) +(***************************************************) + +val _ = new_constant ("PMATCH_magic_1", type_of ``PMATCH``) +val _ = new_constant ("PMATCH_ROW_magic_1", type_of + ``\abc. PMATCH_ROW (\x. FST (abc x)) (\x. FST (SND (abc x))) (\x. SND (SND ((abc x))))``) + +val _ = new_constant ("PMATCH_ROW_magic_0", type_of + ``\abc. PMATCH_ROW (\x:unit. FST abc) (\x. FST (SND abc)) (\x. SND (SND (abc)))``) + +val _ = new_constant ("PMATCH_ROW_magic_2", type_of + ``\(pat:'a) (g:bool) (res:'b). (pat,g,res)``) + +val _ = new_constant ("PMATCH_ROW_magic_3", type_of + ``\(pat:'a) (res:'b). (pat,T,res)``) (***************************************************) (* Congruences *) @@ -792,4 +808,6 @@ Q.PAT_ASSUM `_ = SOME x'` (fn thm => ASM_SIMP_TAC std_ss []) -val _ = export_theory() +val _ = export_theory();; + + diff --git a/examples/deep_matches/deepMatchesSyntax.sml b/examples/deep_matches/deepMatchesSyntax.sml index 83e4020484..f20f3039cf 100644 --- a/examples/deep_matches/deepMatchesSyntax.sml +++ b/examples/deep_matches/deepMatchesSyntax.sml @@ -262,7 +262,7 @@ fun pmatch_printer GS backend sys (ppfns:term_pp_types.ppstream_funs) gravs d t add_string "]" end handle HOL_ERR _ => raise term_pp_types.UserPP_Failed; -val _ = add_user_printer ("PMATCH", ``PMATCH v l``, pmatch_printer); +val _ = temp_add_user_printer ("PMATCH", ``PMATCH v l``, pmatch_printer); (***********************************************) @@ -318,55 +318,44 @@ val _ = end; +val PMATCH_magic_1_tm = mk_const ("PMATCH_magic_1", ``:'a -> ('a -> 'b option) list -> 'b``); +val PMATCH_ROW_magic_0_tm = mk_const ("PMATCH_ROW_magic_0", + ``:'a # bool # 'b -> 'a -> 'b option``); +val PMATCH_ROW_magic_1_tm = mk_const ("PMATCH_ROW_magic_1", + ``:('a -> 'b # bool # 'c) -> 'b -> 'c option``); +val PMATCH_ROW_magic_2_tm = mk_const("PMATCH_ROW_magic_2", + ``:'a -> bool -> 'b -> 'a # bool # 'b``); +val PMATCH_ROW_magic_3_tm = mk_const("PMATCH_ROW_magic_3", + ``:'a -> 'b -> 'a # bool # 'b``); - -val _ = new_constant ("PMATCH_magic_1", type_of ``PMATCH``) -val _ = new_constant ("PMATCH_ROW_magic_1", type_of - ``\abc. PMATCH_ROW (\x. FST (abc x)) (\x. FST (SND (abc x))) (\x. SND (SND ((abc x))))``) - -val _ = new_constant ("PMATCH_ROW_magic_0", type_of - ``\abc. PMATCH_ROW (\x:unit. FST abc) (\x. FST (SND abc)) (\x. SND (SND (abc)))``) - -val _ = new_constant ("PMATCH_ROW_magic_2", type_of - ``\(pat:'a) (g:bool) (res:'b). (pat,g,res)``) - -val _ = new_constant ("PMATCH_ROW_magic_3", type_of - ``\(pat:'a) (res:'b). (pat,T,res)``) - -val PMATCH_magic_1_tm = ``PMATCH_magic_1``; -val PMATCH_ROW_magic_0_tm = ``PMATCH_ROW_magic_0``; -val PMATCH_ROW_magic_1_tm = ``PMATCH_ROW_magic_1``; -val PMATCH_ROW_magic_2_tm = ``PMATCH_ROW_magic_2``; -val PMATCH_ROW_magic_3_tm = ``PMATCH_ROW_magic_3``; - -val _ = add_rule{pp_elements = [TOK "~>"], +val _ = temp_add_rule{pp_elements = [TOK "~>"], fixity = Infix (NONASSOC, 3), block_style = (AroundEachPhrase, (PP.CONSISTENT, 0)), paren_style = OnlyIfNecessary, term_name = "PMATCH_ROW_magic_3"} -val _ = add_rule{term_name = "PMATCH_ROW_magic_2", +val _ = temp_add_rule{term_name = "PMATCH_ROW_magic_2", fixity = Infix (HOLgrammars.NONASSOC, 3), pp_elements = [TOK "when", TM, TOK "~>"], paren_style = OnlyIfNecessary, block_style = (AroundEachPhrase, (PP.INCONSISTENT, 0))}; -val _ = add_rule{term_name = "PMATCH_ROW_magic_1", +val _ = temp_add_rule{term_name = "PMATCH_ROW_magic_1", fixity = Binder, pp_elements = [TOK "||"], paren_style = OnlyIfNecessary, block_style = (AroundEachPhrase, (PP.INCONSISTENT, 0))}; -val _ = add_rule{term_name = "PMATCH_ROW_magic_0", +val _ = temp_add_rule{term_name = "PMATCH_ROW_magic_0", fixity = Prefix 2, pp_elements = [TOK "||."], paren_style = OnlyIfNecessary, block_style = (AroundEachPhrase, (PP.INCONSISTENT, 0))}; -val _ = add_rule{term_name = "PMATCH_magic_1", +val _ = temp_add_rule{term_name = "PMATCH_magic_1", fixity = Closefix, pp_elements = [TOK "CASE", TM, TOK "OF"], paren_style = OnlyIfNecessary, From 3af1cefc94914690ff91c70ec41fda103152bd56 Mon Sep 17 00:00:00 2001 From: Thomas Tuerk Date: Sat, 14 Feb 2015 23:03:14 +0100 Subject: [PATCH 180/718] extend interface of reducers in simplifier reducers, i.e. dprocs, are the most flexible way to use the simplifier. Reducers can use a callback to resolve side-conditions. However the old interface only allowed proving these side-conditions. This commits adds an additional callback interface, that allows to only simplify side-conditions. This allows using additional tools to prove a sidecondition after it has already been processed by the callback. --- src/simp/src/Traverse.sig | 7 +++++++ src/simp/src/Traverse.sml | 14 ++++++++++++-- src/simp/src/simpLib.sml | 6 +++--- 3 files changed, 22 insertions(+), 5 deletions(-) diff --git a/src/simp/src/Traverse.sig b/src/simp/src/Traverse.sig index 0ea48d2b01..f3751e58aa 100644 --- a/src/simp/src/Traverse.sig +++ b/src/simp/src/Traverse.sig @@ -53,6 +53,11 @@ sig * The current side condition stack, which grows as nested calls * to the solver are made. * + * conv: + * A continuation function, to be used if the reducer + * wants to continue traversing. The continuation invokes traversal + * under equality. Similar to solver, but does not call EQT_ELIM. + * * addcontext: routine is invoked every time more context is added * to the current environment by virtue of congruence routines. * @@ -64,6 +69,7 @@ sig initial: context, addcontext : context * thm list -> context, apply: {solver:term list -> term -> thm, + conv: term list -> term -> thm, context: context, stack:term list, relation : (term * (term -> thm))} -> conv @@ -74,6 +80,7 @@ sig initial: context, addcontext : context * thm list -> context, apply: {solver:term list -> term -> thm, + conv: term list -> term -> thm, context: context, stack:term list, relation : (term * (term -> thm))} -> conv} diff --git a/src/simp/src/Traverse.sml b/src/simp/src/Traverse.sml index 9088c7200d..6b62bc9ac2 100644 --- a/src/simp/src/Traverse.sml +++ b/src/simp/src/Traverse.sml @@ -37,7 +37,9 @@ datatype reducer = REDUCER of {name : string option, initial: context, addcontext : context * Thm.thm list -> context, - apply: {solver:term list -> term -> thm, context: context, + apply: {solver:term list -> term -> thm, + conv: term list -> term -> thm, + context: context, stack: term list, relation : term * (term -> thm)} -> conv }; fun dest_reducer (REDUCER x) = x @@ -236,13 +238,21 @@ fun TRAVERSE_IN_CONTEXT limit rewriters dprocs travrules stack ctxt tm = let EQT_ELIM (trav stack (change_relation' (context,equality)) tm) handle e as HOL_ERR _ => (lim_r := old ; raise e) end + fun ctxt_conv stack tm = let + val old = !lim_r + in + trav stack (change_relation' (context,equality)) tm + handle e as HOL_ERR _ => (lim_r := old ; raise e) + end fun mkrefl t = let val PREORDER(_, _, irefl) = relation in irefl {Rinst = relname, arg = t} end fun apply_reducer (REDUCER rdata) context tm = - (#apply rdata) {solver=ctxt_solver,context=context, + (#apply rdata) {solver=ctxt_solver, + conv=ctxt_conv, + context=context, stack=stack, relation=(relname, mkrefl)} tm before dec lim_r diff --git a/src/simp/src/simpLib.sml b/src/simp/src/simpLib.sml index 9afd267ec1..5af1430624 100644 --- a/src/simp/src/simpLib.sml +++ b/src/simp/src/simpLib.sml @@ -414,7 +414,7 @@ datatype simpset = mk_comb(Term.inst theta f, x) end - fun apply {solver,context,stack,relation = (relation,_)} t = let + fun apply {solver,conv,context,stack,relation = (relation,_)} t = let val _ = can (match_term rel_t) relation orelse raise ERR ("mk_reducer.apply", "Wrong relation") val n = case context of redExn n => n @@ -518,10 +518,10 @@ fun remove_ssfrags ss names = in CONVNET (net_add_convs net (List.mapPartial mk_rewr_convdata new_rwts)) end - fun apply {solver,context,stack,relation} tm = let + fun apply {solver,conv,context,stack,relation} tm = let val net = (raise context) handle CONVNET net => net in - tryfind (fn conv => conv solver stack tm) (lookup tm net) + tryfind (fn conv' => conv' solver stack tm) (lookup tm net) end in REDUCER {name=SOME"rewriter_for_ss", addcontext=addcontext, apply=apply, From 61dfebc6fd3960a9376ba1597a16d37b1a847d5d Mon Sep 17 00:00:00 2001 From: Thomas Tuerk Date: Sat, 14 Feb 2015 23:03:33 +0100 Subject: [PATCH 181/718] use new reducer interface for deepMatchesLib --- examples/deep_matches/deepMatchesLib.sml | 54 ++++++++++++------------ 1 file changed, 27 insertions(+), 27 deletions(-) diff --git a/examples/deep_matches/deepMatchesLib.sml b/examples/deep_matches/deepMatchesLib.sml index f21d50ad58..6e5aa3eb13 100644 --- a/examples/deep_matches/deepMatchesLib.sml +++ b/examples/deep_matches/deepMatchesLib.sml @@ -8,6 +8,7 @@ open quantHeuristicsLib open DatatypeSimps open deepMatchesSyntax open constrFamiliesLib +open Traverse (***********************************************) (* Simpset to evaluate PMATCH_ROWS *) @@ -74,8 +75,7 @@ val select_conj_ss = conv = K (K (SIMP_CONV (std_ss++boolSimps.CONJ_ss) []))}; -fun rc_ss gl = list_ss ++ simpLib.merge_ss - (gl @ +val static_ss = simpLib.merge_ss [pabs_elim_ss, pairSimps.paired_forall_ss, pairSimps.paired_exists_ss, @@ -83,25 +83,23 @@ fun rc_ss gl = list_ss ++ simpLib.merge_ss select_conj_ss, elim_fst_snd_select_ss, boolSimps.EQUIV_EXTRACT_ss, - type_rewrites_stateful_ss (), simpLib.rewrites [ pairTheory.EXISTS_PROD, pairTheory.FORALL_PROD, PMATCH_ROW_EQ_NONE, PMATCH_ROW_COND_def, PAIR_EQ_COLLAPSE, - oneTheory.one]]) + oneTheory.one]]; + +fun rc_ss gl = srw_ss() ++ simpLib.merge_ss (static_ss :: gl) fun callback_CONV cb_opt t = (case cb_opt of - NONE => raise UNCHANGED - | SOME cb => ( - if (aconv t T) orelse (aconv t F) then (raise UNCHANGED) else - (EQT_INTRO (cb t) - handle HOL_ERR _ => EQF_INTRO (cb (mk_neg t))))) + NONE => NO_CONV t + | SOME cb => cb t) -fun rc_conv (gl, callback_opt) = +fun rc_conv (gl, callback_opt) = REPEATC ( SIMP_CONV (rc_ss gl) [] THENC - TRY_CONV (callback_CONV callback_opt) + TRY_CONV (callback_CONV callback_opt)) fun rc_tac (gl, callback_opt) = CONV_TAC (rc_conv (gl, callback_opt)) @@ -499,7 +497,7 @@ end handle HOL_ERR _ => raise UNCHANGED fun PMATCH_CLEANUP_CONV_GEN ssl = PMATCH_CLEANUP_CONV_GENCALL (ssl, NONE) -val PMATCH_CLEANUP_CONV = PMATCH_CLEANUP_CONV_GEN [] +val PMATCH_CLEANUP_CONV = PMATCH_CLEANUP_CONV_GEN []; @@ -1027,7 +1025,7 @@ fun PMATCH_EXPAND_COLS_CONV t = let end in thm1 -end handle HOL_ERR _ => raise UNCHANGED +end handle HOL_ERR _ => raise UNCHANGED; (***********************************************) @@ -1044,29 +1042,31 @@ PMATCH (SOME y,x,l) ]`` *) -fun PMATCH_SIMP_CONV_GENCALL rc_arg = REPEATC (FIRST_CONV [ +fun PMATCH_SIMP_CONV_GENCALL rc_arg = +REPEATC (FIRST_CONV [ CHANGED_CONV (PMATCH_CLEANUP_PVARS_CONV), CHANGED_CONV (PMATCH_CLEANUP_CONV_GENCALL rc_arg), CHANGED_CONV (PMATCH_REMOVE_ARB_CONV_GENCALL rc_arg), CHANGED_CONV (PMATCH_SIMP_COLS_CONV_GENCALL rc_arg), CHANGED_CONV (PMATCH_EXPAND_COLS_CONV), CHANGED_CONV PMATCH_FORCE_SAME_VARS_CONV -]) +]); fun PMATCH_SIMP_CONV_GEN ssl = PMATCH_SIMP_CONV_GENCALL (ssl, NONE) -val PMATCH_SIMP_CONV = PMATCH_SIMP_CONV_GEN [] - -fun PMATCH_SIMP_convdata_conv ssl callback back = - PMATCH_SIMP_CONV_GENCALL (ssl, SOME (callback back)) - - -fun PMATCH_SIMP_GEN_ss ssl = simpLib.conv_ss - { name = "PMATCH_SIMP_CONV", - key = SOME ([], ``(PMATCH (v:'a) rows):'b``), - trace = 1, - conv = PMATCH_SIMP_convdata_conv ssl - } +val PMATCH_SIMP_CONV = PMATCH_SIMP_CONV_GEN []; + +fun PMATCH_SIMP_GEN_ss ssl = let + exception pmatch_simp_reducer_exn + fun addcontext (context,thms) = context + fun apply {solver,conv,context,stack,relation} tm = ( + if not (is_PMATCH tm) then failwith "not a PMATCH" else + QCHANGED_CONV (PMATCH_SIMP_CONV_GENCALL (ssl, SOME (conv stack))) tm + ) + in simpLib.dproc_ss (REDUCER {name=SOME"PMATCH_SIMP_REDUCER", + addcontext=addcontext, apply=apply, + initial=pmatch_simp_reducer_exn}) + end; val PMATCH_SIMP_ss = PMATCH_SIMP_GEN_ss [] From 65d33e1580240bfe7de24d6b656f2c59cd96e4f6 Mon Sep 17 00:00:00 2001 From: Thomas Tuerk Date: Sun, 15 Feb 2015 14:22:52 +0100 Subject: [PATCH 182/718] fix bug in congLib fix a bug introduced by the change of REDUCER interface in 3af1cefc94914690ff91c70ec41fda103152bd56. --- examples/elliptic/subtypeTools.sml | 2 +- .../deep_embeddings/temporal_deep_simplificationsLib.sml | 6 +++--- src/simp/src/congLib.sml | 7 ++++--- 3 files changed, 8 insertions(+), 7 deletions(-) diff --git a/examples/elliptic/subtypeTools.sml b/examples/elliptic/subtypeTools.sml index 832ad5b283..9e69090efe 100644 --- a/examples/elliptic/subtypeTools.sml +++ b/examples/elliptic/subtypeTools.sml @@ -400,7 +400,7 @@ local else if !ORACLE then ORACLE_solver goal else let - val {context, solver = _, relation = _, stack = _} = dproc_context + val {context, solver = _, conv = _, relation = _, stack = _} = dproc_context val {assumptions,reductions,judgements} = case context of State state => state diff --git a/examples/temporal_deep/src/deep_embeddings/temporal_deep_simplificationsLib.sml b/examples/temporal_deep/src/deep_embeddings/temporal_deep_simplificationsLib.sml index 15d1951105..ba7c8b533f 100644 --- a/examples/temporal_deep/src/deep_embeddings/temporal_deep_simplificationsLib.sml +++ b/examples/temporal_deep/src/deep_embeddings/temporal_deep_simplificationsLib.sml @@ -93,10 +93,10 @@ fun prop_logic_equivalent_or_conv t = exception reducer_empty_context; -fun simple_conv_reducer conv = +fun simple_conv_reducer conv' = let fun addcontext (context,thms) = reducer_empty_context - fun apply {solver,context,stack,relation} tm = conv tm; + fun apply {solver,conv, context,stack,relation} tm = conv' tm; in REDUCER {addcontext=addcontext, apply=apply, initial=reducer_empty_context} end; @@ -178,4 +178,4 @@ LTL_WHILE_def, LTL_PSWHILE_def, LTL_PWHILE_def]; val ltl_cs = cs_addfrag prop_logic_cs ltl_CS; val ltl_nnf_cs = cs_addfrag prop_logic_nnf_cs ltl_nnf_CS; -end \ No newline at end of file +end diff --git a/src/simp/src/congLib.sml b/src/simp/src/congLib.sml index 4165151181..5984be9b34 100644 --- a/src/simp/src/congLib.sml +++ b/src/simp/src/congLib.sml @@ -152,7 +152,7 @@ val cong_reducer = in CONVNET (insertThms net thms) end - fun apply {solver,context,stack,relation} tm = + fun apply {solver,conv,context,stack,relation} tm = let val net = ((raise context) handle CONVNET net => net) val thm = cong_rewrite net relation tm @@ -174,9 +174,10 @@ fun eq_reducer_wrapper (eq_reducer as REDUCER data)= let val initial = #initial data val addcontext = #addcontext data - fun apply {solver,context,stack,relation as (_, refl)} tm = let + fun apply {solver,conv,context,stack,relation as (_, refl)} tm = let val eqthm = #apply data - {solver=solver,context=context,stack=stack, + {solver=solver,conv=conv, + context=context,stack=stack, relation=relation} tm val congThm = refl tm From ac674f82d55f2881443a32f69c573adcd443c5c7 Mon Sep 17 00:00:00 2001 From: Thomas Tuerk Date: Sun, 15 Feb 2015 23:44:25 +0100 Subject: [PATCH 183/718] deepMatches example: implement lifting to nearest boolean valued term --- examples/deep_matches/deepMatchesExamples.sml | 10 ++ examples/deep_matches/deepMatchesLib.sig | 30 ++++ examples/deep_matches/deepMatchesLib.sml | 161 ++++++++++++++++++ examples/deep_matches/deepMatchesScript.sml | 33 ++++ examples/deep_matches/deepMatchesSyntax.sml | 7 +- 5 files changed, 239 insertions(+), 2 deletions(-) diff --git a/examples/deep_matches/deepMatchesExamples.sml b/examples/deep_matches/deepMatchesExamples.sml index 7d879f3325..badaa6df73 100644 --- a/examples/deep_matches/deepMatchesExamples.sml +++ b/examples/deep_matches/deepMatchesExamples.sml @@ -154,4 +154,14 @@ REPEAT STRIP_TAC THENL [ SIMP_TAC (std_ss ++ PMATCH_SIMP_ss) [] ]) +(* Let's prove it via lifting *) +val my_d_thms2 = store_thm ("my_d_thms2", +``(!x. x > 3 ==> (my_d (x, []) = x)) /\ + (!x. x <= 3 ==> (my_d (x, []) = 0)) /\ + (!x y ys. my_d (x, y::ys) = my_d (x + y, ys))``, + +REPEAT STRIP_TAC THEN ( + CONV_TAC (LHS_CONV (ONCE_REWRITE_CONV [my_d_def])) THEN + ASM_SIMP_TAC (arith_ss++PMATCH_LIFT_BOOL_ss) [] +)) diff --git a/examples/deep_matches/deepMatchesLib.sig b/examples/deep_matches/deepMatchesLib.sig index a7fda89c47..498f6287fc 100644 --- a/examples/deep_matches/deepMatchesLib.sig +++ b/examples/deep_matches/deepMatchesLib.sig @@ -69,4 +69,34 @@ sig val PMATCH_EXPAND_COLS_CONV : conv + (********************************) + (* removing PMATCH-terms *) + (* via lifting it to the nearest*) + (* boolean term and then *) + (* unfolding *) + (********************************) + + (* One can eliminate PMATCHs by unfolding all + cases explicitly. This is often handy to + prove properties about functions defined + via pattern matches without the need to + do the case-splits manually. + + This tactic looks for the smallest wrapper + around a PMATCH such that the term is of type + bool. This term is then expanded into a big + conjunction. For each case of the pattern match, + one conjunct is created. *) + val PMATCH_LIFT_BOOL_CONV : conv + + (* There is also a more generic version that + allows to provide extra ssfrags. This might + be handy, if the PMATCH contains functions + not known by the default methods. *) + val PMATCH_LIFT_BOOL_CONV_GEN : ssfrag list -> conv + + (* corresponding ssfrags *) + val PMATCH_LIFT_BOOL_GEN_ss : ssfrag list -> ssfrag + val PMATCH_LIFT_BOOL_ss : ssfrag + end diff --git a/examples/deep_matches/deepMatchesLib.sml b/examples/deep_matches/deepMatchesLib.sml index 6e5aa3eb13..cac447d9b3 100644 --- a/examples/deep_matches/deepMatchesLib.sml +++ b/examples/deep_matches/deepMatchesLib.sml @@ -1071,6 +1071,167 @@ fun PMATCH_SIMP_GEN_ss ssl = let val PMATCH_SIMP_ss = PMATCH_SIMP_GEN_ss [] +(***********************************************) +(* Lifting to lowest boolean level *) +(***********************************************) + +(* + + + +val tm = ``P ( + CASE xx OF [ + ]):bool`` + +val tm = ``P ( + CASE xx OF [ + || (x, y, ys). (x, y::ys) ~> (x + y); + ||. (0, []) ~> 9; + || x. (x, []) when x > 3 ~> x; + || x. (x, []) ~> 0]):bool`` +*) + +fun PMATCH_LIFT_BOOL_CONV_AUX rc_arg tm = let + val (p_tm, m_tm) = dest_comb tm + val (v, rows) = dest_PMATCH m_tm +in + case rows of + [] => + REWRITE_CONV [PMATCH_PRED_UNROLL_NIL] tm + | row::rows' => let + val (pt, gt, rh) = dest_PMATCH_ROW row + (* instantiate base thm *) + val thm0 = let + val thm00 = ISPEC p_tm (FRESH_TY_VARS_RULE PMATCH_PRED_UNROLL_CONS) + val thm01 = ISPEC v thm00 + val thm02 = ISPEC pt thm01 + val thm03 = ISPEC gt thm02 + val thm04 = ISPEC rh thm03 + val thm05 = ISPEC (listSyntax.mk_list (rows', type_of row)) thm04 in + thm05 + end + + (* elem precond *) + val thm1 = let + val pre = fst (dest_imp (concl thm0)) + val pre_thm = prove (pre, rc_tac rc_arg) + in + MP thm0 pre_thm + end + + (* Use right variable names *) + val thm2 = let + val vars_tm = fst (pairSyntax.dest_pabs pt) + + val c = (RAND_CONV (pairTools.PABS_INTRO_CONV vars_tm)) THENC + TRY_CONV (pairTools.ELIM_TUPLED_QUANT_CONV) THENC + SIMP_CONV std_ss [] + val thm2a = CONV_RULE (RHS_CONV (RATOR_CONV (RAND_CONV c))) thm1 + val thm2b = CONV_RULE (RHS_CONV (RAND_CONV (RATOR_CONV (RAND_CONV c)))) thm2a + in + thm2b + end + + (* recursive call *) + val thm3 = let + val c = PMATCH_LIFT_BOOL_CONV_AUX rc_arg + val thm3 = CONV_RULE (RHS_CONV (RAND_CONV (RAND_CONV c))) thm2 + in + thm3 + end + in + thm3 + end +end + +(* +val tm = ``(P2 /\ Q ==> ( + CASE xx OF [ + || (x, y, ys). (x, y::ys) ~> (x + y); + ||. (0, []) ~> 9; + || x. (x, []) when x > 3 ~> x; + || x. (x, []) ~> 0] = 5))`` + +val tm = `` + CASE xx OF [ + || (x, y, ys). (x, y::ys) ~> (x + y); + ||. (0, []) ~> 9; + || x. (x, []) when x > 3 ~> x; + || x. (x, []) ~> 0] = 5`` +*) + + +val PMATCH_LIFT_BOOL_CONV_GENCALL_AUX_THM = prove ( + ``(P1 ==> (X1 /\ (P2 ==> X2)) = + (P1 ==> X1) /\ ((P1 /\ P2) ==> X2))``, +PROVE_TAC[]) + +fun PMATCH_LIFT_BOOL_CONV_GENCALL rc_arg tm = let + (* check whether we should really process tm *) + val _ = if type_of tm = bool then () else raise UNCHANGED + val p_tm = find_term is_PMATCH tm + fun has_subterm p t = (find_term p t; true) handle HOL_ERR _ => false + + val is_minimal = not (has_subterm (fn t => + (not (aconv t tm)) andalso + (type_of t = bool) andalso + (has_subterm is_PMATCH t)) tm) + val _ = if is_minimal then () else raise UNCHANGED + + (* prepare tm *) + val v = genvar (type_of p_tm) + val P_tm = mk_abs (v, subst [p_tm |-> v] tm) + val P_v = genvar (type_of P_tm) + + (* do real work *) + val thm0 = PMATCH_LIFT_BOOL_CONV_AUX rc_arg (mk_comb (P_v, p_tm)) + + (* create conjuncts *) + val thm1 = let + fun c t = (REWR_CONV PMATCH_LIFT_BOOL_CONV_GENCALL_AUX_THM THENC + TRY_CONV (RAND_CONV c)) t + val thm1a = CONV_RULE (RHS_CONV (RAND_CONV c)) thm0 + + val c = SIMP_CONV (std_ss++boolSimps.CONJ_ss) [AND_IMP_INTRO, GSYM RIGHT_FORALL_IMP_THM, GSYM CONJ_ASSOC] + val thm1b = CONV_RULE (RHS_CONV (EVERY_CONJ_CONV c)) thm1a + + val c = rc_conv rc_arg + val thm1c = CONV_RULE (RHS_CONV (EVERY_CONJ_CONV c)) thm1b + in + thm1c + end + + (* restore original predicate *) + val thm2 = let + val thm2a = INST [P_v |-> P_tm] thm1 + val thm2b = CONV_RULE (LHS_CONV BETA_CONV) thm2a + val thm2c = CONV_RULE (RHS_CONV (DEPTH_CONV BETA_CONV)) thm2b + val _ = assert (fn thm => aconv (lhs (concl thm)) tm) thm2c + in + thm2c + end +in + thm2 +end + +fun PMATCH_LIFT_BOOL_CONV_GEN ssl = PMATCH_LIFT_BOOL_CONV_GENCALL (ssl, NONE) + +val PMATCH_LIFT_BOOL_CONV = PMATCH_LIFT_BOOL_CONV_GEN []; + +fun PMATCH_LIFT_BOOL_GEN_ss ssl = let + exception pmatch_simp_reducer_exn + fun addcontext (context,thms) = context + fun apply {solver,conv,context,stack,relation} tm = ( + QCHANGED_CONV (PMATCH_LIFT_BOOL_CONV_GENCALL (ssl, SOME (conv stack))) tm + ) + in simpLib.dproc_ss (REDUCER {name=SOME"PMATCH_LIFT_BOOL_REDUCER", + addcontext=addcontext, apply=apply, + initial=pmatch_simp_reducer_exn}) + end; + +val PMATCH_LIFT_BOOL_ss = PMATCH_LIFT_BOOL_GEN_ss [] + + (***********************************************) (* Case_splits *) diff --git a/examples/deep_matches/deepMatchesScript.sml b/examples/deep_matches/deepMatchesScript.sml index cb2ad3fe83..a4d03e17c4 100644 --- a/examples/deep_matches/deepMatchesScript.sml +++ b/examples/deep_matches/deepMatchesScript.sml @@ -808,6 +808,39 @@ Q.PAT_ASSUM `_ = SOME x'` (fn thm => ASM_SIMP_TAC std_ss []) + +(***************************************************) +(* UNROLLING PREDICATES *) +(***************************************************) + +(* trivial case added only for completeness *) + +val PMATCH_PRED_UNROLL_NIL = store_thm ("PMATCH_PRED_UNROLL_NIL", + ``!P v. P (PMATCH v []) = P ARB``, + SIMP_TAC std_ss [PMATCH_def, PMATCH_INCOMPLETE_def]); + +val PMATCH_PRED_UNROLL_CONS = store_thm ("PMATCH_PRED_UNROLL_CONS", +``!P v p g r rows. + (!x1 x2. (p x1 = p x2) ==> (x1 = x2)) ==> + + (P (PMATCH v ((PMATCH_ROW p g r)::rows)) <=> + (!x. (v = p x) ==> g x ==> P (r x)) /\ + ((!x. (v = p x) ==> ~(g x)) ==> P (PMATCH v rows)))``, + +REPEAT STRIP_TAC THEN +SIMP_TAC std_ss [PMATCH_def, PMATCH_ROW_def] THEN +Cases_on `?x. PMATCH_ROW_COND p g v x` THENL [ + FULL_SIMP_TAC std_ss [PMATCH_ROW_COND_def] THEN + `!x'. (p x' = v) = (x' = x)` by METIS_TAC[] THEN + `!x'. (v = p x') = (x' = x)` by METIS_TAC[] THEN + ASM_SIMP_TAC (std_ss++boolSimps.CONJ_ss) [], + + FULL_SIMP_TAC std_ss [] THEN + FULL_SIMP_TAC std_ss [PMATCH_ROW_COND_def] THEN + METIS_TAC[] +]) + + val _ = export_theory();; diff --git a/examples/deep_matches/deepMatchesSyntax.sml b/examples/deep_matches/deepMatchesSyntax.sml index f20f3039cf..145604bd11 100644 --- a/examples/deep_matches/deepMatchesSyntax.sml +++ b/examples/deep_matches/deepMatchesSyntax.sml @@ -252,14 +252,17 @@ fun pmatch_printer GS backend sys (ppfns:term_pp_types.ppstream_funs) gravs d t sys (Top, Prec (2000, ""), Top) (d - 1) rh )) ) - in + in ublock PP.CONSISTENT 0 ( (ublock PP.CONSISTENT 2 (add_string "CASE" >> add_break(1,2) >> sys (Top, Top, Top) (d - 1) v >> add_break(1,0) >> add_string "OF [")) >> add_break (1, 2) >> - smpp.pr_list pp_row (add_string ";" >> add_break (1, 2)) rows' >> + ublock PP.CONSISTENT 0 ( + smpp.pr_list pp_row (add_string ";" >> add_break (1, 0)) rows' + ) >> add_break (1, 0) >> add_string "]" + ) end handle HOL_ERR _ => raise term_pp_types.UserPP_Failed; val _ = temp_add_user_printer ("PMATCH", ``PMATCH v l``, pmatch_printer); From 213dd62db10ae7d726d656173dfc83d47a20d785 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Mon, 16 Feb 2015 09:55:53 +0000 Subject: [PATCH 184/718] use new trans and sym commands in opentheory article version 6 this should reduce the size of logged articles slightly. the new claim of producing version 6 articles is not quite true: the defineTypeOp command's semantics has changed and the HOL4 logger is still producing the old version of that command. --- src/opentheory/logging/Logging.sml | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) diff --git a/src/opentheory/logging/Logging.sml b/src/opentheory/logging/Logging.sml index 0531917423..06e5c37d1a 100644 --- a/src/opentheory/logging/Logging.sml +++ b/src/opentheory/logging/Logging.sml @@ -481,13 +481,13 @@ val (log_term, log_thm, log_clear, val _ = log_thm (EQ_MP (MK_COMB (REFL t, REFL t2)) (REFL t1)) in () end | TRANS_prf (th1,th2) => let - val t = rator(concl th1) - val _ = log_thm (EQ_MP (MK_COMB (REFL t, th2)) th1) + val _ = log_thm th1 + val _ = log_thm th2 + val _ = log_command "trans" in () end | SYM_prf th => let - val (eq,l) = dest_comb(fst(dest_comb(concl th))) - val ll = REFL l - val _ = log_thm (EQ_MP (MK_COMB (MK_COMB (REFL eq, th), ll)) ll) + val _ = log_thm th + val _ = log_command "sym" in () end | AP_TERM_prf (tm,th) => log_thm (MK_COMB(REFL tm, th)) | AP_THM_prf (th,tm) => log_thm (MK_COMB(th, REFL tm)) @@ -725,8 +725,11 @@ fun mk_path name = OS.Path.concat(OS.FileSys.getDir(),OS.Path.joinBaseExt{base=n fun raw_start_logging out = case !log_state of Not_logging => let - val _ = Thm.set_definition_callback log_thm - in log_state := Active_logging out end + val _ = Thm.set_definition_callback log_thm + val _ = log_state := Active_logging out + val _ = log_num 6 + val _ = log_command "version" + in () end | Active_logging _ => () fun start_logging() = From 9bac2d54c1ede0ac7a5aa202f0a3ffa59d680e0c Mon Sep 17 00:00:00 2001 From: Thomas Tuerk Date: Mon, 16 Feb 2015 22:23:53 +0100 Subject: [PATCH 185/718] deepMatches example: implement PMATCH_TO_TOP_RULE also generalise lifting such that it can use a fallback in case a pattern cannot be shown to be injective --- examples/deep_matches/deepMatchesExamples.sml | 26 +++++---- examples/deep_matches/deepMatchesLib.sig | 10 ++++ examples/deep_matches/deepMatchesLib.sml | 53 ++++++++++++++----- examples/deep_matches/deepMatchesScript.sml | 34 ++++++++++-- 4 files changed, 95 insertions(+), 28 deletions(-) diff --git a/examples/deep_matches/deepMatchesExamples.sml b/examples/deep_matches/deepMatchesExamples.sml index badaa6df73..9a01f6bccd 100644 --- a/examples/deep_matches/deepMatchesExamples.sml +++ b/examples/deep_matches/deepMatchesExamples.sml @@ -145,14 +145,9 @@ val my_d_thms = store_thm ("my_d_thms", (!x. x <= 3 ==> (my_d (x, []) = 0)) /\ (!x y ys. my_d (x, y::ys) = my_d (x + y, ys))``, -REPEAT STRIP_TAC THENL [ - ASM_SIMP_TAC (std_ss++PMATCH_SIMP_ss) [my_d_def], - - ASM_SIMP_TAC (arith_ss++PMATCH_SIMP_ss) [my_d_def], - - CONV_TAC (LHS_CONV (ONCE_REWRITE_CONV [my_d_def])) THEN - SIMP_TAC (std_ss ++ PMATCH_SIMP_ss) [] -]) +REPEAT STRIP_TAC THEN ( + ASM_SIMP_TAC (arith_ss++PMATCH_SIMP_ss) [Once my_d_def] +)); (* Let's prove it via lifting *) val my_d_thms2 = store_thm ("my_d_thms2", @@ -161,7 +156,18 @@ val my_d_thms2 = store_thm ("my_d_thms2", (!x y ys. my_d (x, y::ys) = my_d (x + y, ys))``, REPEAT STRIP_TAC THEN ( - CONV_TAC (LHS_CONV (ONCE_REWRITE_CONV [my_d_def])) THEN - ASM_SIMP_TAC (arith_ss++PMATCH_LIFT_BOOL_ss) [] + ASM_SIMP_TAC (arith_ss++PMATCH_LIFT_BOOL_ss) [Once my_d_def] )) +(* This lifting is also automated as a rule*) +val my_d_thms3 = PMATCH_TO_TOP_RULE my_d_def + +(* The result is not as nice, but often useful + + val my_d_thms3 = + |- (∀x. x > 3 ⇒ (my_d (x,[]) = x)) ∧ + (∀x. ¬(x > 3) ⇒ (my_d (x,[]) = 0)) ∧ + (∀x y ys. my_d (x,y::ys) = my_d (x + y,ys)) ∧ + ∀xx. (∀x. xx ≠ (x,[])) ∧ (∀x y ys. xx ≠ (x,y::ys)) ⇒ (my_d xx = ARB): + thm +*) diff --git a/examples/deep_matches/deepMatchesLib.sig b/examples/deep_matches/deepMatchesLib.sig index 498f6287fc..9153878820 100644 --- a/examples/deep_matches/deepMatchesLib.sig +++ b/examples/deep_matches/deepMatchesLib.sig @@ -99,4 +99,14 @@ sig val PMATCH_LIFT_BOOL_GEN_ss : ssfrag list -> ssfrag val PMATCH_LIFT_BOOL_ss : ssfrag + (* A special case of lifting are function definitons, + which use PMATCH. In order to use such definitions + with the rewritig tools, it is often handy to + move the PMATCH to the toplevel and introduce + multiple cases, one case for each row of the + PMATCH. This is automated by the following rules. *) + + val PMATCH_TO_TOP_RULE_GEN : ssfrag list -> rule + val PMATCH_TO_TOP_RULE : rule + end diff --git a/examples/deep_matches/deepMatchesLib.sml b/examples/deep_matches/deepMatchesLib.sml index cac447d9b3..7edd769177 100644 --- a/examples/deep_matches/deepMatchesLib.sml +++ b/examples/deep_matches/deepMatchesLib.sml @@ -1099,24 +1099,24 @@ in [] => REWRITE_CONV [PMATCH_PRED_UNROLL_NIL] tm | row::rows' => let +(* val (row::rows') = rows *) val (pt, gt, rh) = dest_PMATCH_ROW row - (* instantiate base thm *) - val thm0 = let - val thm00 = ISPEC p_tm (FRESH_TY_VARS_RULE PMATCH_PRED_UNROLL_CONS) - val thm01 = ISPEC v thm00 - val thm02 = ISPEC pt thm01 - val thm03 = ISPEC gt thm02 - val thm04 = ISPEC rh thm03 - val thm05 = ISPEC (listSyntax.mk_list (rows', type_of row)) thm04 in - thm05 - end + val rows'_tm = listSyntax.mk_list (rows', type_of row) - (* elem precond *) - val thm1 = let - val pre = fst (dest_imp (concl thm0)) + (* instantiate base thm and try to prove precond *) + val thm1 = let + val thm00 = FRESH_TY_VARS_RULE PMATCH_PRED_UNROLL_CONS + val thm01 = ISPECL [p_tm, v, pt, gt, rh, rows'_tm] thm00 + val pre = fst (dest_imp (concl thm01)) val pre_thm = prove (pre, rc_tac rc_arg) in - MP thm0 pre_thm + MP thm01 pre_thm + end handle HOL_ERR _ => let + (* proving precond failed, try fallback theorem *) + val thm00 = FRESH_TY_VARS_RULE PMATCH_PRED_UNROLL_CONS_NO_INJ + val thm01 = ISPECL [p_tm, v, pt, gt, rh, rows'_tm] thm00 + in + thm01 end (* Use right variable names *) @@ -1145,6 +1145,7 @@ in end (* + val tm = ``(P2 /\ Q ==> ( CASE xx OF [ || (x, y, ys). (x, y::ys) ~> (x + y); @@ -1166,6 +1167,7 @@ val PMATCH_LIFT_BOOL_CONV_GENCALL_AUX_THM = prove ( (P1 ==> X1) /\ ((P1 /\ P2) ==> X2))``, PROVE_TAC[]) + fun PMATCH_LIFT_BOOL_CONV_GENCALL rc_arg tm = let (* check whether we should really process tm *) val _ = if type_of tm = bool then () else raise UNCHANGED @@ -1232,6 +1234,29 @@ fun PMATCH_LIFT_BOOL_GEN_ss ssl = let val PMATCH_LIFT_BOOL_ss = PMATCH_LIFT_BOOL_GEN_ss [] +fun PMATCH_TO_TOP_RULE_SINGLE ssl thm = let + val thm0 = GEN_ALL thm + val thm1 = CONV_RULE (DEPTH_CONV (PMATCH_LIFT_BOOL_CONV_GEN ssl)) thm0 + val thm2 = CONV_RULE (STRIP_QUANT_CONV ( + EVERY_CONJ_CONV (STRIP_QUANT_CONV (TRY_CONV (RAND_CONV markerLib.stmark_term))))) thm1 + val thm3 = SIMP_RULE std_ss [FORALL_AND_THM, + Cong (REFL ``stmarker (t:'a)``)] thm2 + val thm4 = PURE_REWRITE_RULE [markerTheory.stmarker_def] thm3 +in + thm4 +end + +fun PMATCH_TO_TOP_RULE_GEN ssl thm = let + val thms = BODY_CONJUNCTS thm + val thms' = List.map (PMATCH_TO_TOP_RULE_SINGLE ssl) thms + val thm0 = LIST_CONJ thms' + val thm1 = CONV_RULE unwindLib.FLATTEN_CONJ_CONV thm0 +in + thm1 +end + +fun PMATCH_TO_TOP_RULE thm = PMATCH_TO_TOP_RULE_GEN [] thm; + (***********************************************) (* Case_splits *) diff --git a/examples/deep_matches/deepMatchesScript.sml b/examples/deep_matches/deepMatchesScript.sml index a4d03e17c4..e20671f82d 100644 --- a/examples/deep_matches/deepMatchesScript.sml +++ b/examples/deep_matches/deepMatchesScript.sml @@ -821,7 +821,7 @@ val PMATCH_PRED_UNROLL_NIL = store_thm ("PMATCH_PRED_UNROLL_NIL", val PMATCH_PRED_UNROLL_CONS = store_thm ("PMATCH_PRED_UNROLL_CONS", ``!P v p g r rows. - (!x1 x2. (p x1 = p x2) ==> (x1 = x2)) ==> + (!x1 x2. (g x1 /\ g x2 /\ (p x1 = p x2)) ==> (x1 = x2)) ==> (P (PMATCH v ((PMATCH_ROW p g r)::rows)) <=> (!x. (v = p x) ==> g x ==> P (r x)) /\ @@ -831,15 +831,41 @@ REPEAT STRIP_TAC THEN SIMP_TAC std_ss [PMATCH_def, PMATCH_ROW_def] THEN Cases_on `?x. PMATCH_ROW_COND p g v x` THENL [ FULL_SIMP_TAC std_ss [PMATCH_ROW_COND_def] THEN - `!x'. (p x' = v) = (x' = x)` by METIS_TAC[] THEN - `!x'. (v = p x') = (x' = x)` by METIS_TAC[] THEN - ASM_SIMP_TAC (std_ss++boolSimps.CONJ_ss) [], + `!x'. ((p x' = v) /\ g x') = (x' = x)` by METIS_TAC[] THEN + ASM_SIMP_TAC (std_ss++boolSimps.CONJ_ss) [] THEN + METIS_TAC[], FULL_SIMP_TAC std_ss [] THEN FULL_SIMP_TAC std_ss [PMATCH_ROW_COND_def] THEN METIS_TAC[] ]) +val PMATCH_PRED_UNROLL_CONS_NO_INJ = store_thm ("PMATCH_PRED_UNROLL_CONS_NO_INJ", +``!P v p g r rows. + (P (PMATCH v ((PMATCH_ROW p g r)::rows)) <=> + (!x. (v = p x) ==> g x ==> P (r (@x. PMATCH_ROW_COND p g v x))) /\ + ((!x. (v = p x) ==> ~(g x)) ==> P (PMATCH v rows)))``, + +REPEAT STRIP_TAC THEN +SIMP_TAC std_ss [PMATCH_def, PMATCH_ROW_def] THEN +Cases_on `?x. PMATCH_ROW_COND p g v x` THENL [ + ASM_SIMP_TAC std_ss [some_def] THEN + FULL_SIMP_TAC std_ss [PMATCH_ROW_COND_def] THEN + EQ_TAC THEN REPEAT STRIP_TAC THENL [ + Q.PAT_ASSUM `v = p x'` (ASSUME_TAC o GSYM) THEN + ASM_SIMP_TAC std_ss [], + + PROVE_TAC[], + + Q.PAT_ASSUM `!x'. _ ==> _` (MP_TAC o Q.SPEC `x`) THEN + ASM_SIMP_TAC std_ss [] + ], + + ASM_SIMP_TAC std_ss [some_def] THEN + FULL_SIMP_TAC std_ss [PMATCH_ROW_COND_def] THEN + METIS_TAC[] +]) + val _ = export_theory();; From 30bbe0b796a7bf8fa5253f803a977c0c21ca4b63 Mon Sep 17 00:00:00 2001 From: Thomas Tuerk Date: Mon, 16 Feb 2015 22:48:10 +0100 Subject: [PATCH 186/718] update dprocs in Description-manual Document the recent changes to simplifier library with respect to the new interface of decision procedures. --- Manual/Description/libraries.tex | 24 ++++++++++++++++-------- 1 file changed, 16 insertions(+), 8 deletions(-) diff --git a/Manual/Description/libraries.tex b/Manual/Description/libraries.tex index 5655aaaf95..76ad17b64a 100644 --- a/Manual/Description/libraries.tex +++ b/Manual/Description/libraries.tex @@ -2756,9 +2756,9 @@ \subsubsection{Embedding code} the stack of side-conditions, and a new side-condition to solve. The \ml{term} argument must be of type \holtxt{:bool}, and the recursive call will simplify it to true (and call \ml{EQT\_ELIM} to turn a term -$t$ into the theorem $\vdash t$). This restriction may be lifted in a -future version of \HOL{} but as it stands, the recursive call can -\emph{only} be used for side-condition discharge. Note also that it +$t$ into the theorem $\vdash t$). This restriction is lifted for +decision procedures (see below), but for conversions the recursive call can +\emph{only} be used for side-condition discharge. Note also that it is the user's responsibility to pass an appropriately updated stack of side-conditions to the recursive invocation of the simplifier. @@ -2767,6 +2767,8 @@ \subsubsection{Embedding code} loop. Rather than return such a result, raise a \ml{HOL\_ERR} or \ml{Conv.UNCHANGED} exception. (Both are treated the same by the simplifier.) + + \paragraph{Context-aware decision procedures} Another, more involved, method for embedding user code into the simplifier is \emph{via} the \ml{dprocs} field of the \simpset{} @@ -2782,6 +2784,7 @@ \subsubsection{Embedding code} REDUCER : {initial : context, addcontext : context * thm list -> context, apply : {solver : term list -> term -> thm, + conv : term list -> term -> thm, context : context, stack : term list} -> term -> thm} -> reducer @@ -2823,11 +2826,16 @@ \subsubsection{Embedding code} When an embedded reducer is applied to a term, the provided \ml{apply} function is called. As well as the term to be transformed, the \ml{apply} function is also passed a record containing a -side-condition solver, the decision procedure's current context, and -the stack of side-conditions attempted so far. The stack and solver -are the same as the additional arguments provided to user-supplied -conversions. The power of the reducer abstraction is having access to -a context that can be built appropriately for each decision procedure. +side-condition solver, a more general call-back to the simplifier, +the decision procedure's current context, and the +stack of side-conditions attempted so far. The stack and solver are +the same as the additional arguments provided to user-supplied +conversions. The \ml{conv} argument is call-back to the simplifier, +which given a term $t$ returns a theorem of the form $\vdash t = t'$ +or fails. In contrast, the \ml{solver} either returns the theorem +$\vdash t$ or fails. The power of the reducer abstraction is having +access to a context that can be built appropriately for each decision +procedure. Decision procedures are applied last when a term is encountered by the simplifier. More, they are applied \emph{after} the simplifier has From b32d2be8e8b518c222f445f8bd03bdcbfd4215e4 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Tue, 17 Feb 2015 11:32:54 +1100 Subject: [PATCH 187/718] generalising code of (l)_spine_binop to get strip_gen_left/right --- src/postkernel/HolKernel.sml | 24 +++++++++++++++++++----- src/postkernel/HolKernelDoc.sig | 4 ++++ 2 files changed, 23 insertions(+), 5 deletions(-) diff --git a/src/postkernel/HolKernel.sml b/src/postkernel/HolKernel.sml index f0d48a2c57..8ae10b821e 100644 --- a/src/postkernel/HolKernel.sml +++ b/src/postkernel/HolKernel.sml @@ -120,30 +120,44 @@ fun strip_binop dest = strip [] o Lib.list_of_singleton end -(* For right-associative binary operators. Tail recursive. *) +(* For right-associative binary operators, + or such as dest_abs, SPEC_VAR, dom_rng, dest_imp. Tail recursive. *) -fun spine_binop dest = +local +fun spine_binop' dest = let fun strip A tm = case dest tm of - NONE => rev (tm :: A) + NONE => (tm, A) | SOME (l, r) => strip (l :: A) r in strip [] end +in +fun spine_binop dest tm = rev ((op ::) (spine_binop' dest tm)) ; + +fun strip_gen_left_opt dest t = + let val (tm, A) = spine_binop' dest t in (rev A, tm) end ; +end (* local fun spine_binop' *) + +fun strip_gen_left dest = strip_gen_left_opt (total dest) ; (* For left-associative binary operators. Tail recursive *) -fun lspine_binop dest = +fun strip_gen_right_opt dest = let fun strip A tm = case dest tm of - NONE => tm :: A + NONE => (tm, A) | SOME (l, r) => strip (r :: A) l in strip [] end +fun lspine_binop dest tm = (op ::) (strip_gen_right_opt dest tm) ; + +fun strip_gen_right dest = strip_gen_right_opt (total dest) ; + (* For right-associative binary operators. Tail recursive. *) fun list_mk_rbinop mk_binop alist = diff --git a/src/postkernel/HolKernelDoc.sig b/src/postkernel/HolKernelDoc.sig index d65e1b2752..24a6d45f95 100644 --- a/src/postkernel/HolKernelDoc.sig +++ b/src/postkernel/HolKernelDoc.sig @@ -53,6 +53,10 @@ sig val strip_binop: ('a -> ('a * 'a) option) -> 'a -> 'a list val strip_comb: term -> term * term list val strip_fun: hol_type -> hol_type list * hol_type + val strip_gen_right_opt : ('a -> ('a * 'b) option) -> 'a -> 'a * 'b list + val strip_gen_right : ('a -> 'a * 'b) -> 'a -> 'a * 'b list + val strip_gen_left_opt : ('a -> ('b * 'a) option) -> 'a -> 'b list * 'a + val strip_gen_left : ('a -> 'b * 'a) -> 'a -> 'b list * 'a val subst_occs: int list list -> {redex: term, residue: term} list -> term -> term val syntax_fns: From a72d68fc81e500654c658e11fc7fee3e26417e8a Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 17 Feb 2015 15:48:25 +1100 Subject: [PATCH 188/718] Most of a fix for recursive holdep problem. See test-case in Holmake/tests/depchain1 Test-case still not re-enabled as I don't think this quite works for Moscow ML yet. Some incidental progress with sharing more code between Moscow ML and Poly/ML (github issue #77). --- tools-poly/Holmake/Holmake.sml | 168 +++++---------- tools/Holmake/Holmake.sml | 187 +++++------------ tools/Holmake/Holmake_tools.sig | 32 ++- tools/Holmake/Holmake_tools.sml | 195 +++++++++++++++--- .../Holmake/tests/depchain1/dir2/Holmakefile | 2 +- .../depchain1/{ => dir2}/dir1/baseScript.sml | 0 6 files changed, 297 insertions(+), 287 deletions(-) rename tools/Holmake/tests/depchain1/{ => dir2}/dir1/baseScript.sml (100%) diff --git a/tools-poly/Holmake/Holmake.sml b/tools-poly/Holmake/Holmake.sml index 9b8ccca799..62b9660ef9 100644 --- a/tools-poly/Holmake/Holmake.sml +++ b/tools-poly/Holmake/Holmake.sml @@ -60,42 +60,6 @@ fun fromFileNoSuf f = fun mk_depfile_name s = fullPath [DEPDIR, s^".d"] -(* pull out a list of files that target depends on from depfile. *) -(* All files on the right of a colon are assumed to be dependencies. - This is despite the fact that holdep produces two entries when run - on fooScript.sml files, one for fooScript.uo, and another for fooScript - itself, we actually want all of those dependencies in one big chunk - because the production of fooTheory.{sig,sml} is done as one - atomic step from fooScript.sml. *) -fun first f [] = NONE - | first f (x::xs) = case f x of NONE => first f xs | res => res - -fun get_dependencies_from_file depfile = let - fun get_whole_file s = let - open TextIO - val instr = openIn (normPath s) - in - inputAll instr before closeIn instr - end - fun parse_result s = let - val lines = String.fields (fn c => c = #"\n") (collapse_bslash_lines s) - fun process_line line = let - val (lhs0, rhs0) = Substring.splitl (fn c => c <> #":") - (Substring.full line) - val lhs = Substring.string lhs0 - val rhs = Substring.string (Substring.slice(rhs0, 1, NONE)) - handle Subscript => "" - in - realspace_delimited_fields rhs - end - val result = List.concat (map process_line lines) - in - List.map toFile result - end -in - parse_result (get_whole_file depfile) -end - (**** get_dependencies *) (* figures out whether or not a dependency file is a suitable place to read information about current target or not, and then either does so, or makes @@ -114,16 +78,6 @@ in (not (OS.FileSys.access(f2, [])) orelse OS.FileSys.modTime f1 > OS.FileSys.modTime f2) end -(* a function that given a product file, figures out the argument that - should be passed to runholdep in order to get back secondary - dependencies. *) - -fun holdep_arg (UO c) = SOME (SML c) - | holdep_arg (UI c) = SOME (SIG c) - | holdep_arg (SML (Theory s)) = SOME (SML (Script s)) - | holdep_arg (SIG (Theory s)) = SOME (SML (Script s)) - | holdep_arg _ = NONE - (**** get dependencies from file *) @@ -779,55 +733,11 @@ end else () were themselves out of date. *) -(** Construction of the dependency graph - ------------------------------------ - - The first thing to do is to define a type that will store our - dependency graph: - -*) - -fun get_direct_dependencies (f : File) : File list = let - val fname = fromFile f - val arg = holdep_arg f (* arg is file to analyse for dependencies *) -in - if isSome arg then let - val arg = valOf arg - val argname = fromFile arg - val depfile = mk_depfile_name argname - val _ = - if argname forces_update_of depfile then - runholdep {ofs = outputfunctions, extras = extra_targets, - includes = hmake_preincludes @ std_include_flags @ - additional_includes, arg = arg, - destination = depfile} - else () - val phase1 = - (* circumstances can arise in which the dependency file won't be - built, and won't exist; mainly because the file we're trying to - compute dependencies for doesn't exist either. In this case, we - can only return the empty list *) - if exists_readable depfile then - get_dependencies_from_file depfile - else - [] - in - case f of - UO x => - if OS.FileSys.access(fromFile (SIG x), []) andalso - List.all (fn f => f <> SIG x) phase1 - then - UI x :: phase1 - else - phase1 - | _ => phase1 - end - else - [] -end - -fun get_implicit_dependencies (f: File) : File list = let - val file_dependencies0 = get_direct_dependencies f +fun get_implicit_dependencies incinfo (f: File) : File list = let + val file_dependencies0 = + get_direct_dependencies {incinfo=incinfo, extra_targets = extra_targets, + output_functions = outputfunctions, + DEPDIR=DEPDIR} f val file_dependencies = case actual_overlay of NONE => file_dependencies0 @@ -844,6 +754,10 @@ in theory, this build depends on all of the dependencies (meaning the transitive closure of the direct dependency relation) in their .UO form, not just .UI *) + val get_direct_dependencies = + get_direct_dependencies {incinfo=incinfo, extra_targets = extra_targets, + output_functions = outputfunctions, + DEPDIR=DEPDIR} fun collect_all_dependencies sofar tovisit = case tovisit of [] => sofar @@ -877,7 +791,7 @@ in if exists_readable (fromFile f) then List.mapPartial (fn (x as (UO (Theory s))) => SOME x | _ => NONE) - (get_implicit_dependencies (UO x)) + (get_implicit_dependencies incinfo (UO x)) else [] in set_union alldeps additional_theories @@ -1026,7 +940,8 @@ val up_to_date_cache:(File, bool)Binarymap.dict ref = fun cache_insert(f, b) = ((up_to_date_cache := Binarymap.insert (!up_to_date_cache, f, b)); b) -fun make_up_to_date ctxt target = let +fun make_up_to_date incinfo ctxt target = let + val make_up_to_date = make_up_to_date incinfo fun print s = if debug then (nspaces TextIO.print (length ctxt); TextIO.print s) @@ -1061,8 +976,9 @@ in val pdep = valOf pdep in if make_up_to_date (target::ctxt) pdep then let - val secondaries = set_union (get_implicit_dependencies target) - (get_explicit_dependencies target) + val secondaries = + set_union (get_implicit_dependencies incinfo target) + (get_explicit_dependencies target) val _ = (print ("Secondary dependencies for "^fromFile target^ " are: "); @@ -1160,7 +1076,7 @@ end handle CircularDependency => cache_insert (target, false) exnMessage x^"> in make_up_to_date") (** Dealing with the command-line *) -fun do_target x = let +fun do_target incinfo x = let fun clean_action () = (Holmake_tools.clean_dir {extra_cleans = extra_cleans}; true) @@ -1177,39 +1093,59 @@ in true) handle _ => false) | "cleanDeps" => clean_deps() | "cleanAll" => clean_action() andalso clean_deps() - | _ => make_up_to_date [] (toFile x) + | _ => make_up_to_date incinfo [] (toFile x) end - | SOME _ => make_up_to_date [] (toFile x) + | SOME _ => make_up_to_date incinfo [] (toFile x) else true end -fun stop_on_failure tgts = +fun stop_on_failure incinfo tgts = case tgts of [] => true - | (t::ts) => do_target t andalso stop_on_failure ts -fun keep_going tgts = let + | (t::ts) => do_target incinfo t andalso stop_on_failure incinfo ts +fun keep_going incinfo tgts = let fun recurse acc tgts = case tgts of [] => acc - | (t::ts) => recurse (do_target t andalso acc) ts + | (t::ts) => recurse (do_target incinfo t andalso acc) ts in recurse true tgts end -fun strategy tgts = let +fun strategy incinfo tgts = let val tgts = if always_rebuild_deps then "cleanDeps" :: tgts else tgts in - if keep_going_flag then keep_going tgts else stop_on_failure tgts + if keep_going_flag then keep_going incinfo tgts else stop_on_failure incinfo tgts end +val allincludes = + cline_additional_includes @ hmake_includes + +fun add_sigobj {includes,preincludes} = + {includes = std_include_flags @ includes, + preincludes = preincludes} + +val dirinfo = let + val f = make_best_relative{relpath=dirnm,absdir=dir} +in + {visited = visiteddirs, + includes = map f allincludes, + preincludes = map f hmake_preincludes} +end + +val purelocal_incinfo = + add_sigobj {includes = allincludes, preincludes = hmake_preincludes} + fun hm_recur ctgt k = maybe_recurse - {warn = warn, no_prereqs = no_prereqs, hm = Holmake, - visited = visiteddirs, - includes = - cline_additional_includes @ envlist "PRE_INCLUDES" @ hmake_includes, + {warn = warn, + diag = diag, + no_prereqs = no_prereqs, hm = Holmake, + dirinfo = dirinfo, dir = {abspath = dir, relpath = dirnm}, local_build = k, cleantgt = ctgt} +fun stdcont tgts ii = finish_logging (strategy (add_sigobj ii) tgts) + in case targets of [] => let @@ -1225,20 +1161,22 @@ in end else () in - hm_recur NONE (fn () => finish_logging (strategy targets)) + hm_recur NONE (stdcont targets) end | xs => let fun isPhony x = member x ["clean", "cleanDeps", "cleanAll"] orelse x in_target ".PHONY" in if List.all isPhony xs andalso not cline_recursive then - if finish_logging (strategy xs) then SOME {visited = visiteddirs} else NONE + if finish_logging (strategy purelocal_incinfo xs) then + SOME dirinfo + else NONE else let val ctgt = List.find (fn s => member s ["clean", "cleanDeps", "cleanAll"]) xs in - hm_recur ctgt (fn () => finish_logging (strategy xs)) + hm_recur ctgt (stdcont xs) end end end diff --git a/tools/Holmake/Holmake.sml b/tools/Holmake/Holmake.sml index 82a95dfba0..67e6d07389 100644 --- a/tools/Holmake/Holmake.sml +++ b/tools/Holmake/Holmake.sml @@ -19,6 +19,7 @@ prim_val catch_interrupt : bool -> unit = 1 "sys_catch_break"; val _ = catch_interrupt true; open Systeml Holmake_tools +infix forces_update_of structure Process = OS.Process structure Path = OS.Path @@ -66,58 +67,6 @@ fun variant str = (* get an unused file name in the current directory *) end else str; - -(* - Rather than continually have to deal with strings corresponding to - file-names and mess with nasty suffixes and the like, we define a - structured datatype into which file-names can be translated once - and for all. -*) - -(** Definition of structured file type *) - - -(*** Construction of secondary dependencies *) - -fun mk_depfile_name s = fullPath [DEPDIR, s^".d"] - - -(* pull out a list of files that target depends on from depfile. *) -(* All files on the right of a colon are assumed to be dependencies. - This is despite the fact that holdep produces two entries when run - on fooScript.sml files, one for fooScript.uo, and another for fooScript - itself, we actually want all of those dependencies in one big chunk - because the production of fooTheory.{sig,sml} is done as one - atomic step from fooScript.sml. *) -fun first f [] = NONE - | first f (x::xs) = case f x of NONE => first f xs | res => res - -fun get_dependencies_from_file depfile = let - fun get_whole_file s = let - open TextIO - val instr = openIn (normPath s) - in - inputAll instr before closeIn instr - end - fun parse_result s = let - val lines = String.fields (fn c => c = #"\n") (collapse_bslash_lines s) - fun process_line line = let - val (lhs0, rhs0) = Substring.splitl (fn c => c <> #":") - (Substring.full line) - val lhs = Substring.string lhs0 - val rhs = Substring.string (Substring.slice(rhs0, 1, NONE)) - handle Subscript => "" - in - realspace_delimited_fields rhs - end - val result = List.concat (map process_line lines) - in - List.map toFile result - end -in - parse_result (get_whole_file depfile) -end - (**** get_dependencies *) (* figures out whether or not a dependency file is a suitable place to read information about current target or not, and then either does so, or makes @@ -128,24 +77,6 @@ end f1 exists /\ (f2 exists ==> f1 is newer than f2) *) -infix forces_update_of -fun (f1 forces_update_of f2) = let - open Time -in - FileSys.access(f1, []) andalso - (not (FileSys.access(f2, [])) orelse FileSys.modTime f1 > FileSys.modTime f2) -end - -(* a function that given a product file, figures out the argument that - should be passed to runholdep in order to get back secondary - dependencies. *) - -fun holdep_arg (UO c) = SOME (SML c) - | holdep_arg (UI c) = SOME (SIG c) - | holdep_arg (SML (Theory s)) = SOME (SML (Script s)) - | holdep_arg (SIG (Theory s)) = SOME (SML (Script s)) - | holdep_arg _ = NONE - (**** get dependencies from file *) @@ -622,48 +553,11 @@ end else () runs holdep, and puts the output into specified file, which will live in DEPDIR somewhere. *) - -fun get_direct_dependencies (f : File) : File list = let - val fname = fromFile f - val arg = holdep_arg f (* arg is file to analyse for dependencies *) -in - if isSome arg then let - val arg = valOf arg - val argname = fromFile arg - val depfile = mk_depfile_name argname - val _ = - if argname forces_update_of depfile then - runholdep {ofs = output_functions, extras = extra_targets, - includes = hmake_preincludes @ std_include_flags @ - additional_includes, arg = arg, - destination = depfile} - else () - val phase1 = - (* circumstances can arise in which the dependency file won't be - built, and won't exist; mainly because the file we're trying to - compute dependencies for doesn't exist either. In this case, we - can only return the empty list *) - if exists_readable depfile then - get_dependencies_from_file depfile - else - [] - in - case f of - UO x => - if FileSys.access(fromFile (SIG x), []) andalso - List.all (fn f => f <> SIG x) phase1 - then - UI x :: phase1 - else - phase1 - | _ => phase1 - end - else - [] -end - -fun get_implicit_dependencies (f: File) : File list = let - val file_dependencies0 = get_direct_dependencies f +fun get_implicit_dependencies incinfo (f: File) : File list = let + val file_dependencies0 = + get_direct_dependencies {incinfo=incinfo,DEPDIR=DEPDIR, + output_functions = output_functions, + extra_targets = extra_targets } f val file_dependencies = case actual_overlay of NONE => file_dependencies0 @@ -683,6 +577,10 @@ in theory, this build depends on all of the dependencies (meaning the transitive closure of the direct dependency relation) in their .UO form, not just .UI *) + val get_direct_dependencies = + get_direct_dependencies {incinfo=incinfo,DEPDIR=DEPDIR, + output_functions = output_functions, + extra_targets = extra_targets} fun collect_all_dependencies sofar tovisit = case tovisit of [] => sofar @@ -714,7 +612,7 @@ in if exists_readable (fromFile f) then List.mapPartial (fn (x as (UO (Theory s))) => SOME x | _ => NONE) - (get_implicit_dependencies (UO x)) + (get_implicit_dependencies incinfo (UO x)) else [] in set_union alldeps additional_theories @@ -884,7 +782,8 @@ val done_some_work = ref false val up_to_date_cache:(File, bool)Polyhash.hash_table = Polyhash.mkPolyTable(50, NotFound) fun cache_insert(f, b) = (Polyhash.insert up_to_date_cache (f, b); b) -fun make_up_to_date ctxt target = let +fun make_up_to_date incinfo ctxt target = let + val make_up_to_date = make_up_to_date incinfo fun print s = if debug then (nspaces TextIO.print (length ctxt); TextIO.print s) @@ -916,8 +815,9 @@ in val pdep = valOf pdep in if make_up_to_date (target::ctxt) pdep then let - val secondaries = set_union (get_implicit_dependencies target) - (get_explicit_dependencies target) + val secondaries = + set_union (get_implicit_dependencies incinfo target) + (get_explicit_dependencies target) val _ = (print ("Secondary dependencies for "^fromFile target^ " are: "); @@ -1012,7 +912,7 @@ end handle CircularDependency => cache_insert (target, false) exnMessage x^"> in make_up_to_date") (** Dealing with the command-line *) -fun do_target x = let +fun do_target incinfo x = let fun clean_action () = (Holmake_tools.clean_dir {extra_cleans = extra_cleans}; true) fun clean_deps() = Holmake_tools.clean_depdir {depdirname = DEPDIR} @@ -1028,40 +928,63 @@ in true) handle _ => false) | "cleanDeps" => clean_deps() | "cleanAll" => clean_action() andalso clean_deps() - | _ => make_up_to_date [] (toFile x) + | _ => make_up_to_date incinfo [] (toFile x) end - | SOME _ => make_up_to_date [] (toFile x) + | SOME _ => make_up_to_date incinfo [] (toFile x) else true end -fun stop_on_failure tgts = +fun stop_on_failure incinfo tgts = case tgts of [] => true - | (t::ts) => do_target t andalso stop_on_failure ts -fun keep_going tgts = let + | (t::ts) => do_target incinfo t andalso stop_on_failure incinfo ts +fun keep_going incinfo tgts = let fun recurse acc tgts = case tgts of [] => acc - | (t::ts) => recurse (do_target t andalso acc) ts + | (t::ts) => recurse (do_target incinfo t andalso acc) ts in recurse true tgts end -fun strategy tgts = let +fun strategy incinfo tgts = let val tgts = if always_rebuild_deps then "cleanDeps" :: tgts else tgts in - if keep_going_flag then keep_going tgts else stop_on_failure tgts + if keep_going_flag then keep_going incinfo tgts + else stop_on_failure incinfo tgts +end + +val allincludes = + cline_additional_includes @ hmake_includes + +fun add_sigobj {includes,preincludes} = + {includes = std_include_flags @ includes, + preincludes = preincludes} + +val dirinfo = let + val f = make_best_relative{relpath=dirnm,absdir=dir} +in + {visited = visiteddirs, + includes = map f allincludes, + preincludes = map f hmake_preincludes} end fun hm_recur ctgt k : holmake_result = maybe_recurse - {warn = warn, no_prereqs = no_prereqs, hm = Holmake, - visited = visiteddirs, - includes = - cline_additional_includes @ hmake_preincludes @ hmake_includes, + {warn = warn, + diag = diag, + no_prereqs = no_prereqs, hm = Holmake, + dirinfo = dirinfo, dir = {abspath = dir, relpath = dirnm}, local_build = k, cleantgt = ctgt} + +fun stdcont tgts ii = finish_logging (strategy (add_sigobj ii) tgts) + +(* only to be used if there is no recursing into other directories, which + might extend the includes we should be looking at *) +val purelocal_includes = + add_sigobj {includes = allincludes, preincludes = hmake_preincludes} in case targets of [] => let @@ -1077,21 +1000,21 @@ in end else () in - hm_recur NONE (fn () => finish_logging (strategy targets)) + hm_recur NONE (stdcont targets) end | xs => let fun isPhony x = member x ["clean", "cleanDeps", "cleanAll"] orelse x in_target ".PHONY" in if List.all isPhony xs andalso not cline_recursive then - if finish_logging (strategy xs) then SOME {visited = visiteddirs} + if finish_logging (strategy purelocal_includes xs) then SOME dirinfo else NONE else let val ctgt = List.find (fn s => member s ["clean", "cleanDeps", "cleanAll"]) xs in - hm_recur ctgt (fn () => finish_logging (strategy xs)) + hm_recur ctgt (stdcont xs) end end end diff --git a/tools/Holmake/Holmake_tools.sig b/tools/Holmake/Holmake_tools.sig index 32a6d09630..40e2832f55 100644 --- a/tools/Holmake/Holmake_tools.sig +++ b/tools/Holmake/Holmake_tools.sig @@ -33,11 +33,6 @@ sig {no_lastmakercheck : bool} -> unit - (* dependency analysis *) - exception HolDepFailed - val runholdep : - {ofs : output_functions, includes : string list, extras : string list, - arg : File, destination : string} -> unit (* File IO *) val string_part : File -> string @@ -53,19 +48,38 @@ sig val clean_dir : {extra_cleans: string list} -> unit val clean_depdir : {depdirname : string} -> bool - type holmake_result = {visited : string Binaryset.set } option + val make_best_relative : + {relpath : string option, absdir : string} -> string -> string + + type include_info = {includes : string list, preincludes : string list} + type holmake_dirinfo = {visited : string Binaryset.set, + includes : string list, + preincludes : string list } + type holmake_result = holmake_dirinfo option val maybe_recurse : {warn: string -> unit, + diag : string -> unit, no_prereqs : bool, hm: {relpath : string option, abspath : string, visited : string Binaryset.set} -> string list -> string list -> holmake_result, - visited: string Binaryset.set, - includes : string list, + dirinfo : holmake_dirinfo, dir : {abspath: string, relpath: string option}, - local_build : unit -> bool, + local_build : include_info -> bool, cleantgt : string option} -> holmake_result + val holdep_arg : File -> File option + + val get_direct_dependencies : + {incinfo : include_info, DEPDIR : string, + output_functions : output_functions, + extra_targets : string list } -> + File -> File list + exception HolDepFailed + + val forces_update_of : string * string -> bool + + end diff --git a/tools/Holmake/Holmake_tools.sml b/tools/Holmake/Holmake_tools.sml index 6c8e051228..5dfbd2a2be 100644 --- a/tools/Holmake/Holmake_tools.sml +++ b/tools/Holmake/Holmake_tools.sml @@ -288,44 +288,80 @@ val terminal_log = if Systeml.isUnix then xterm_log else (fn s => ()) -type holmake_result = {visited : string Binaryset.set } option - -fun maybe_recurse {warn,no_prereqs,hm,visited,includes,dir,local_build=k, - cleantgt} = +fun make_best_relative {relpath, absdir} extension = + if Path.isAbsolute extension then extension + else + case relpath of + NONE => Path.mkCanonical (Path.concat(absdir, extension)) + | SOME p => Path.mkCanonical (Path.concat(p, extension)) + +type include_info = {includes : string list, preincludes : string list } +type holmake_dirinfo = {visited : string Binaryset.set, includes : string list, + preincludes : string list } +type holmake_result = holmake_dirinfo option + +(* this function doesn't handle all recursion, just one level's worth. In + other words, the master Holmake calls this function, and this then arranges the + recursive calls into the various include directories that need to happen. + The holmake that gets called in those directories will in turn call this function for + recursion at that level in the "tree" +*) +fun maybe_recurse {warn,diag,no_prereqs,hm,dirinfo,dir,local_build=k,cleantgt} = let val {abspath=dir,relpath} = dir - val k = fn () => (terminal_log ("Holmake: "^nice_dir dir); k()) + val {includes,preincludes,visited} = dirinfo + val k = fn ii => (terminal_log ("Holmake: "^nice_dir dir); k ii) val tgts = case cleantgt of SOME s => [s] | NONE => [] - fun recurse visited (newdir,nm) = - if Binaryset.member(visited, newdir) then SOME {visited = visited} - else let - val newrelpath = - if Path.isAbsolute nm then NONE - else - case relpath of - NONE => NONE - | SOME d => SOME (Path.mkCanonical (Path.concat(d, nm))) - val nm = case newrelpath of NONE => newdir | SOME d => d - val _ = warn ("Recursively calling Holmake in "^nm) - val _ = terminal_log ("Holmake: "^nice_dir nm) - in - hm {relpath=newrelpath,abspath=newdir,visited=visited} [] tgts - before - (warn ("Finished recursive invocation in "^nm); - terminal_log ("Holmake: "^nice_dir dir); - FileSys.chDir dir) - end - fun do_em accg [] = if k() then SOME {visited = accg} else NONE + fun recurse acc (newdir,nm) = let + val {visited, includes, preincludes} = acc + in + if Binaryset.member(visited, newdir) then SOME acc + else let + val newrelpath = + if Path.isAbsolute nm then NONE + else + case relpath of + NONE => NONE + | SOME d => SOME (Path.mkCanonical (Path.concat(d, nm))) + val nm = case newrelpath of NONE => newdir | SOME d => d + val _ = warn ("Recursively calling Holmake in "^nm) + val _ = terminal_log ("Holmake: "^nice_dir nm) + val result = + case hm {relpath=newrelpath,abspath=newdir,visited=visited} [] tgts + of + NONE => NONE + | SOME {visited,includes = inc0, preincludes = pre0} => + SOME{visited = visited, includes = includes @ inc0, + preincludes = preincludes @ pre0} + in + warn ("Finished recursive invocation in "^nm); + terminal_log ("Holmake: "^nice_dir dir); + FileSys.chDir dir; + case result of + SOME{includes=incs,preincludes=pre,...} => + (diag ("Recursively computed includes = " ^ + String.concatWith ", " incs); + diag ("Recursively computed pre-includes = " ^ + String.concatWith ", " pre)) + | NONE => (); + result + end + end + fun do_em (accg as {includes,preincludes,...}) [] = + if k {includes=includes,preincludes=preincludes} then SOME accg + else NONE | do_em accg (x::xs) = let in case recurse accg x of - SOME {visited} => do_em visited xs + SOME result => do_em result xs | NONE => NONE end val visited = Binaryset.add(visited, dir) in if no_prereqs then - if k() then SOME {visited = visited} else NONE + if k {includes = #includes dirinfo, preincludes = #preincludes dirinfo} then + SOME dirinfo + else NONE else let fun foldthis (dir, m) = Binarymap.insert(m, FileSys.fullPath dir, dir) @@ -334,10 +370,10 @@ in m) val possible_calls = List.foldr foldthis (Binarymap.mkDict String.compare) - includes - + (preincludes @ includes) in - do_em visited (Binarymap.listItems possible_calls) + do_em {visited = visited, includes = includes, preincludes = preincludes} + (Binarymap.listItems possible_calls) end end @@ -421,4 +457,103 @@ in closeOut outstr end +(* pull out a list of files that target depends on from depfile. *) +(* All files on the right of a colon are assumed to be dependencies. + This is despite the fact that holdep produces two entries when run + on fooScript.sml files, one for fooScript.uo, and another for fooScript + itself, we actually want all of those dependencies in one big chunk + because the production of fooTheory.{sig,sml} is done as one + atomic step from fooScript.sml. *) +fun first f [] = NONE + | first f (x::xs) = case f x of NONE => first f xs | res => res + +fun get_dependencies_from_file depfile = let + fun get_whole_file s = let + open TextIO + val instr = openIn (normPath s) + in + inputAll instr before closeIn instr + end + fun parse_result s = let + val lines = String.fields (fn c => c = #"\n") (collapse_bslash_lines s) + fun process_line line = let + val (lhs0, rhs0) = Substring.splitl (fn c => c <> #":") + (Substring.full line) + val lhs = Substring.string lhs0 + val rhs = Substring.string (Substring.slice(rhs0, 1, NONE)) + handle Subscript => "" + in + realspace_delimited_fields rhs + end + val result = List.concat (map process_line lines) + in + List.map toFile result + end +in + parse_result (get_whole_file depfile) +end + +(* a function that given a product file, figures out the argument that + should be passed to runholdep in order to get back secondary + dependencies. *) + +fun holdep_arg (UO c) = SOME (SML c) + | holdep_arg (UI c) = SOME (SIG c) + | holdep_arg (SML (Theory s)) = SOME (SML (Script s)) + | holdep_arg (SIG (Theory s)) = SOME (SML (Script s)) + | holdep_arg _ = NONE + +fun mk_depfile_name DEPDIR s = fullPath [DEPDIR, s^".d"] + +infix forces_update_of +fun (f1 forces_update_of f2) = let + open Time +in + FileSys.access(f1, []) andalso + (not (FileSys.access(f2, [])) orelse FileSys.modTime f1 > FileSys.modTime f2) +end + + +fun get_direct_dependencies {incinfo,DEPDIR,output_functions,extra_targets} f = +let + val fname = fromFile f + val arg = holdep_arg f (* arg is file to analyse for dependencies *) + val {includes,preincludes} = incinfo +in + if isSome arg then let + val arg = valOf arg + val argname = fromFile arg + val depfile = mk_depfile_name DEPDIR argname + val _ = + if argname forces_update_of depfile then + runholdep {ofs = output_functions, extras = extra_targets, + includes = preincludes @ includes, arg = arg, + destination = depfile} + else () + val phase1 = + (* circumstances can arise in which the dependency file won't be + built, and won't exist; mainly because the file we're trying to + compute dependencies for doesn't exist either. In this case, we + can only return the empty list *) + if exists_readable depfile then + get_dependencies_from_file depfile + else + [] + in + case f of + UO x => + if FileSys.access(fromFile (SIG x), []) andalso + List.all (fn f => f <> SIG x) phase1 + then + UI x :: phase1 + else + phase1 + | _ => phase1 + end + else + [] +end + + + end (* struct *) diff --git a/tools/Holmake/tests/depchain1/dir2/Holmakefile b/tools/Holmake/tests/depchain1/dir2/Holmakefile index 088498f62a..4882974e09 100644 --- a/tools/Holmake/tests/depchain1/dir2/Holmakefile +++ b/tools/Holmake/tests/depchain1/dir2/Holmakefile @@ -1 +1 @@ -INCLUDES = ../dir1 +INCLUDES = dir1 diff --git a/tools/Holmake/tests/depchain1/dir1/baseScript.sml b/tools/Holmake/tests/depchain1/dir2/dir1/baseScript.sml similarity index 100% rename from tools/Holmake/tests/depchain1/dir1/baseScript.sml rename to tools/Holmake/tests/depchain1/dir2/dir1/baseScript.sml From 826a0b01cc0526c3687fe1243ef72dc65c37faee Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 18 Feb 2015 14:37:12 +1100 Subject: [PATCH 189/718] Fix recursive dep problem under Moscow ML (re-enable regression test) Build commands within Holmake are now passed the correct include information. --- tools-poly/Holmake/Holmake.sml | 16 ++++++++-------- tools/Holmake/Holmake.sml | 15 ++++++++------- tools/sequences/kernel | 2 +- 3 files changed, 17 insertions(+), 16 deletions(-) diff --git a/tools-poly/Holmake/Holmake.sml b/tools-poly/Holmake/Holmake.sml index 62b9660ef9..6263bc2c95 100644 --- a/tools-poly/Holmake/Holmake.sml +++ b/tools-poly/Holmake/Holmake.sml @@ -828,10 +828,8 @@ datatype buildcmds = Compile of File list (*** Compilation of files *) val failed_script_cache = ref (Binaryset.empty String.compare) -fun build_command c arg = let - val include_flags = includify (hmake_preincludes @ std_include_flags @ - additional_includes) - val include_flags = List.filter (fn x => not (x = "-I")) include_flags +fun build_command (ii as {preincludes,includes}) c arg = let + val include_flags = preincludes @ includes val overlay_stringl = case actual_overlay of NONE => [] | SOME s => [s] exception CompileFailed exception FileNotFound @@ -857,7 +855,7 @@ in val scriptui = script^".ui" open OS.Process (* first thing to do is to create the Script.uo file *) - val b = build_command (Compile deps) scriptsml_file + val b = build_command ii (Compile deps) scriptsml_file val _ = b orelse raise CompileFailed val _ = print ("Linking "^scriptuo^ " to produce theory-builder executable\n") @@ -906,11 +904,12 @@ in | FileNotFound => false end -fun do_a_build_command target pdep secondaries = +fun do_a_build_command incinfo target pdep secondaries = case (extra_commands (fromFile target)) of SOME (cs as _ :: _) => OS.Process.isSuccess (run_extra_commands (fromFile target) cs secondaries) | _ (* i.e., NONE or SOME [] *) => let + val build_command = build_command incinfo in case target of UO c => build_command (Compile secondaries) pdep @@ -994,8 +993,9 @@ in in print ("Dependency: "^fromFile d^" forces rebuild\n"); done_some_work := true; - cache_insert (target, - do_a_build_command target pdep secondaries) + cache_insert + (target, + do_a_build_command incinfo target pdep secondaries) end end else diff --git a/tools/Holmake/Holmake.sml b/tools/Holmake/Holmake.sml index 67e6d07389..795c12551d 100644 --- a/tools/Holmake/Holmake.sml +++ b/tools/Holmake/Holmake.sml @@ -641,9 +641,8 @@ datatype buildcmds = MOSMLC (*** Compilation of files *) val failed_script_cache = ref (Binaryset.empty String.compare) -fun build_command c arg = let - val include_flags = includify (hmake_preincludes @ std_include_flags @ - additional_includes) +fun build_command (ii as {preincludes,includes}) c arg = let + val include_flags = includify (preincludes @ includes) (* val include_flags = ["-I",SIGOBJ] @ additional_includes *) val overlay_stringl = case actual_overlay of @@ -707,7 +706,7 @@ in val scriptui = script^".ui" open Process (* first thing to do is to create the Script.uo file *) - val b = build_command MOSMLC scriptsml_file + val b = build_command ii MOSMLC scriptsml_file val _ = b orelse raise CompileFailed val _ = print ("Linking "^scriptuo^ " to produce theory-builder executable\n") @@ -750,11 +749,12 @@ in | FileNotFound => false end -fun do_a_build_command target pdep secondaries = +fun do_a_build_command incinfo target pdep secondaries = case (extra_commands (fromFile target)) of SOME (cs as _ :: _) => Process.isSuccess (run_extra_commands (fromFile target) cs) | _ (* i.e., NONE or SOME [] *) => let + val build_command = build_command incinfo in case target of UO c => build_command MOSMLC pdep @@ -833,8 +833,9 @@ in in print ("Dependency: "^fromFile d^" forces rebuild\n"); done_some_work := true; - cache_insert (target, - do_a_build_command target pdep secondaries) + cache_insert + (target, + do_a_build_command incinfo target pdep secondaries) end end else diff --git a/tools/sequences/kernel b/tools/sequences/kernel index d12ddc3c19..da916bb7d4 100644 --- a/tools/sequences/kernel +++ b/tools/sequences/kernel @@ -11,7 +11,7 @@ src/parse src/bool src/1 !src/1/theory_tests -# (FIXME!) !tools/Holmake/tests/depchain1/dir3 +!tools/Holmake/tests/depchain1/dir3 !tools/Holmake/tests/altquote1/ src/proofman [poly]bin/hol.bare From 148bed9639ef3609f1b3f6e2c1fbcc4221c2146c Mon Sep 17 00:00:00 2001 From: Thomas Tuerk Date: Wed, 18 Feb 2015 09:14:20 +0100 Subject: [PATCH 190/718] more work on deep_matches example more work on PMATCH_LIFT_BOOL and show that its usefulness even for non-injective patterns --- examples/deep_matches/deepMatchesExamples.sml | 130 ++++++++++++++++++ examples/deep_matches/deepMatchesLib.sml | 25 ++-- examples/deep_matches/deepMatchesScript.sml | 39 ++++-- 3 files changed, 177 insertions(+), 17 deletions(-) diff --git a/examples/deep_matches/deepMatchesExamples.sml b/examples/deep_matches/deepMatchesExamples.sml index 9a01f6bccd..f6ac4b143b 100644 --- a/examples/deep_matches/deepMatchesExamples.sml +++ b/examples/deep_matches/deepMatchesExamples.sml @@ -2,6 +2,7 @@ open bossLib open deepMatchesLib open deepMatchesTheory open deepMatchesSyntax +open pred_setTheory (* Introducing case expressions *) @@ -171,3 +172,132 @@ val my_d_thms3 = PMATCH_TO_TOP_RULE my_d_def ∀xx. (∀x. xx ≠ (x,[])) ∧ (∀x y ys. xx ≠ (x,y::ys)) ⇒ (my_d xx = ARB): thm *) + +(*********************************) +(* Using non-injective patterns *) +(*********************************) + +(* Normally patterns should be injective. + However, the tools even work, if they are not. + The following definition defines cardinality + of sets in a simple case and more advanced. *) + +val simple_card_def = Define ` + simple_card s = CASE s OF [ + ||. {} ~> SOME 0; + || x. {x} ~> SOME 1; + || (x, y). {x; y} ~> SOME 2; + || s. s ~> NONE + ]`; + +val simple_card_THM_AUX = PMATCH_TO_TOP_RULE simple_card_def; + +val simple_card_ALT_DEF = prove (``simple_card s = + if (INFINITE s \/ CARD s > 2) then NONE else SOME (CARD s)``, + +Tactical.REVERSE (Cases_on `FINITE s`) THEN1 ( + MP_TAC (Q.SPEC `s` (el 4 (CONJUNCTS simple_card_THM_AUX))) THEN + MATCH_MP_TAC (prove (``(A /\ (B ==> C)) ==> ((A ==> B) ==> C)``, PROVE_TAC[])) THEN + CONJ_TAC THEN1 ( + CCONTR_TAC THEN + FULL_SIMP_TAC std_ss [] THEN + FULL_SIMP_TAC std_ss [FINITE_INSERT, FINITE_EMPTY] + ) THEN + ASM_SIMP_TAC std_ss [] +) THEN + +Cases_on `s` THEN1 ( + SIMP_TAC std_ss [CARD_EMPTY, simple_card_THM_AUX, FINITE_EMPTY] +) THEN +Cases_on `t` THEN1 ( + SIMP_TAC std_ss [CARD_SING, simple_card_THM_AUX, FINITE_SING] +) THEN +Cases_on `t'` THEN1 ( + MP_TAC (Q.SPEC `{x;x'}` (el 3 (CONJUNCTS simple_card_THM_AUX))) THEN + MATCH_MP_TAC (prove (``(A /\ (B ==> C)) ==> ((A ==> B) ==> C)``, PROVE_TAC[])) THEN + CONJ_TAC THEN1 ( + FULL_SIMP_TAC std_ss [EXTENSION, IN_INSERT, NOT_IN_EMPTY] THEN + METIS_TAC[] + ) THEN + REPEAT STRIP_TAC THEN + Q.PAT_ASSUM `{x;x'} = _` (K ALL_TAC) THEN + FULL_SIMP_TAC std_ss [FINITE_SING, CARD_INSERT, IN_INSERT, + NOT_IN_EMPTY, CARD_SING] +) THEN1 ( + FULL_SIMP_TAC (std_ss++boolSimps.CONJ_ss) [IN_INSERT, CARD_INSERT, FINITE_INSERT] THEN + MP_TAC (Q.SPEC `x INSERT x' INSERT x'' INSERT t` (el 4 (CONJUNCTS simple_card_THM_AUX))) THEN + MATCH_MP_TAC (prove (``(A /\ (B ==> C)) ==> ((A ==> B) ==> C)``, PROVE_TAC[])) THEN + CONJ_TAC THEN1 ( + FULL_SIMP_TAC std_ss [EXTENSION, IN_INSERT, NOT_IN_EMPTY, IN_UNION] THEN + METIS_TAC[] + ) THEN + REPEAT STRIP_TAC THEN + ASM_SIMP_TAC std_ss [] THEN + Cases_on `FINITE t` THEN ASM_REWRITE_TAC[] THEN + ASM_SIMP_TAC arith_ss [CARD_INSERT, FINITE_INSERT, IN_INSERT] +)); + + + +val CARD2_defn = Defn.Hol_defn "CARD2" ` + CARD2 s = CASE s OF [ + ||. {} ~> 0; + || (x, s'). x INSERT s' when (FINITE s' /\ ~(x IN s')) ~> + SUC (CARD2 s'); + || s'. s' ~> 0 + ]` + +val (CARD2_def, _) = Defn.tprove (CARD2_defn, + Q.EXISTS_TAC `measure CARD` THEN + SIMP_TAC std_ss [prim_recTheory.WF_measure, + pred_setTheory.FINITE_INSERT] THEN + REPEAT STRIP_TAC THEN + ASM_SIMP_TAC std_ss [prim_recTheory.measure_thm, + pred_setTheory.CARD_INSERT] +) + +val CARD2_AUX_DEFS = PMATCH_TO_TOP_RULE CARD2_def + +val CARD2_EMPTY = store_thm ("CARD2_EMPTY", + ``CARD2 {} = 0``, +REWRITE_TAC [CARD2_AUX_DEFS]) + +val CARD2_INFINITE = store_thm ("CARD2_INFINITE", + ``!s. INFINITE s ==> (CARD2 s = 0)``, + +REPEAT STRIP_TAC THEN +MATCH_MP_TAC (el 3 (BODY_CONJUNCTS CARD2_AUX_DEFS)) THEN +Cases_on `s = {}` THEN ( + REPEAT STRIP_TAC THEN + FULL_SIMP_TAC (std_ss++pred_setSimps.PRED_SET_ss) [] +)); + +val CARD2_EQ = store_thm ("CARD2_EQ", + ``!s. FINITE s ==> (CARD2 s = CARD s)``, + +Induct_on `CARD s` THEN1 ( + REPEAT STRIP_TAC THEN + `s = {}` by PROVE_TAC [CARD_EQ_0] THEN + Q.PAT_ASSUM `0 = _` (K ALL_TAC) THEN + ASM_REWRITE_TAC [CARD_EMPTY, CARD2_EMPTY] +) THEN +REPEAT STRIP_TAC THEN +Cases_on `s` THEN1 ( + FULL_SIMP_TAC arith_ss [CARD_EMPTY] +) THEN +Q.PAT_ASSUM `v = X` (ASSUME_TAC o GSYM) THEN +FULL_SIMP_TAC std_ss [FINITE_INSERT, CARD_INSERT] THEN + +MP_TAC (Q.ISPEC `x INSERT t` (el 2 (CONJUNCTS CARD2_AUX_DEFS))) THEN +MATCH_MP_TAC (prove (``(A /\ (B ==> C)) ==> ((A ==> B) ==> C)``, PROVE_TAC[])) THEN +CONJ_TAC THEN1 ( + ASM_SIMP_TAC (std_ss++pred_setSimps.PRED_SET_ss) [] THEN + PROVE_TAC[] +) THEN +STRIP_TAC THEN +`CARD (x' INSERT s') = CARD (x INSERT t)` by PROVE_TAC[] THEN +POP_ASSUM MP_TAC THEN +Q.PAT_ASSUM `x INSERT t = _` (K ALL_TAC) THEN +ASM_SIMP_TAC std_ss [CARD_INSERT]) + + diff --git a/examples/deep_matches/deepMatchesLib.sml b/examples/deep_matches/deepMatchesLib.sml index 7edd769177..3cf4cb474b 100644 --- a/examples/deep_matches/deepMatchesLib.sml +++ b/examples/deep_matches/deepMatchesLib.sml @@ -7,8 +7,8 @@ open simpLib open quantHeuristicsLib open DatatypeSimps open deepMatchesSyntax -open constrFamiliesLib open Traverse +open constrFamiliesLib (***********************************************) (* Simpset to evaluate PMATCH_ROWS *) @@ -1089,6 +1089,9 @@ val tm = ``P ( ||. (0, []) ~> 9; || x. (x, []) when x > 3 ~> x; || x. (x, []) ~> 0]):bool`` + +val tm = mk_comb (P_v, p_tm) +val rc_arg = ([], NONE) *) fun PMATCH_LIFT_BOOL_CONV_AUX rc_arg tm = let @@ -1104,19 +1107,19 @@ in val rows'_tm = listSyntax.mk_list (rows', type_of row) (* instantiate base thm and try to prove precond *) - val thm1 = let + val (thm1, is_inj) = let val thm00 = FRESH_TY_VARS_RULE PMATCH_PRED_UNROLL_CONS val thm01 = ISPECL [p_tm, v, pt, gt, rh, rows'_tm] thm00 val pre = fst (dest_imp (concl thm01)) - val pre_thm = prove (pre, rc_tac rc_arg) + val pre_thm = Lib.with_flag (Feedback.emit_MESG, false) prove (pre, rc_tac rc_arg) in - MP thm01 pre_thm + (MP thm01 pre_thm, true) end handle HOL_ERR _ => let (* proving precond failed, try fallback theorem *) val thm00 = FRESH_TY_VARS_RULE PMATCH_PRED_UNROLL_CONS_NO_INJ val thm01 = ISPECL [p_tm, v, pt, gt, rh, rows'_tm] thm00 in - thm01 + (thm01, false) end (* Use right variable names *) @@ -1126,7 +1129,11 @@ in val c = (RAND_CONV (pairTools.PABS_INTRO_CONV vars_tm)) THENC TRY_CONV (pairTools.ELIM_TUPLED_QUANT_CONV) THENC SIMP_CONV std_ss [] - val thm2a = CONV_RULE (RHS_CONV (RATOR_CONV (RAND_CONV c))) thm1 + val c2a_inj = RHS_CONV (RATOR_CONV (RAND_CONV c)) + val c2a_no_inj = RHS_CONV (RATOR_CONV (RAND_CONV + (BINOP_CONV c))) + val c2a = if is_inj then c2a_inj else c2a_no_inj + val thm2a = CONV_RULE c2a thm1 val thm2b = CONV_RULE (RHS_CONV (RAND_CONV (RATOR_CONV (RAND_CONV c)))) thm2a in thm2b @@ -1163,9 +1170,9 @@ val tm = `` val PMATCH_LIFT_BOOL_CONV_GENCALL_AUX_THM = prove ( - ``(P1 ==> (X1 /\ (P2 ==> X2)) = - (P1 ==> X1) /\ ((P1 /\ P2) ==> X2))``, -PROVE_TAC[]) + ``(P1 ==> (X1 /\ (P2 ==> X2))) = + ((P1 ==> X1) /\ ((P1 /\ P2) ==> X2))``, +REWRITE_TAC [IMP_CONJ_THM, AND_IMP_INTRO]); fun PMATCH_LIFT_BOOL_CONV_GENCALL rc_arg tm = let diff --git a/examples/deep_matches/deepMatchesScript.sml b/examples/deep_matches/deepMatchesScript.sml index e20671f82d..85c29701d4 100644 --- a/examples/deep_matches/deepMatchesScript.sml +++ b/examples/deep_matches/deepMatchesScript.sml @@ -2,6 +2,7 @@ open HolKernel Parse boolLib bossLib; open quantHeuristicsLib open optionTheory open listTheory +open ConseqConv val _ = new_theory "deepMatches" @@ -824,7 +825,7 @@ val PMATCH_PRED_UNROLL_CONS = store_thm ("PMATCH_PRED_UNROLL_CONS", (!x1 x2. (g x1 /\ g x2 /\ (p x1 = p x2)) ==> (x1 = x2)) ==> (P (PMATCH v ((PMATCH_ROW p g r)::rows)) <=> - (!x. (v = p x) ==> g x ==> P (r x)) /\ + (!x. ((v = p x) /\ g x) ==> P (r x)) /\ ((!x. (v = p x) ==> ~(g x)) ==> P (PMATCH v rows)))``, REPEAT STRIP_TAC THEN @@ -843,7 +844,9 @@ Cases_on `?x. PMATCH_ROW_COND p g v x` THENL [ val PMATCH_PRED_UNROLL_CONS_NO_INJ = store_thm ("PMATCH_PRED_UNROLL_CONS_NO_INJ", ``!P v p g r rows. (P (PMATCH v ((PMATCH_ROW p g r)::rows)) <=> - (!x. (v = p x) ==> g x ==> P (r (@x. PMATCH_ROW_COND p g v x))) /\ + ((?x. (p x = v) /\ g x) ==> ?x. ( + (v = p x) /\ g x /\ ((@x. PMATCH_ROW_COND p g v x) = x) /\ + P (r x))) /\ ((!x. (v = p x) ==> ~(g x)) ==> P (PMATCH v rows)))``, REPEAT STRIP_TAC THEN @@ -852,13 +855,11 @@ Cases_on `?x. PMATCH_ROW_COND p g v x` THENL [ ASM_SIMP_TAC std_ss [some_def] THEN FULL_SIMP_TAC std_ss [PMATCH_ROW_COND_def] THEN EQ_TAC THEN REPEAT STRIP_TAC THENL [ - Q.PAT_ASSUM `v = p x'` (ASSUME_TAC o GSYM) THEN - ASM_SIMP_TAC std_ss [], - + SELECT_ELIM_TAC THEN PROVE_TAC [], + SELECT_ELIM_TAC THEN PROVE_TAC [], + ASM_REWRITE_TAC[], PROVE_TAC[], - - Q.PAT_ASSUM `!x'. _ ==> _` (MP_TAC o Q.SPEC `x`) THEN - ASM_SIMP_TAC std_ss [] + PROVE_TAC[] ], ASM_SIMP_TAC std_ss [some_def] THEN @@ -867,6 +868,28 @@ Cases_on `?x. PMATCH_ROW_COND p g v x` THENL [ ]) +val PMATCH_PRED_UNROLL_CONS = store_thm ("PMATCH_PRED_UNROLL_CONS", +``!P v p g r rows. + (!x1 x2. (g x1 /\ g x2 /\ (p x1 = p x2)) ==> (x1 = x2)) ==> + + (P (PMATCH v ((PMATCH_ROW p g r)::rows)) <=> + (!x. ((v = p x) /\ g x) ==> P (r x)) /\ + ((!x. (v = p x) ==> ~(g x)) ==> P (PMATCH v rows)))``, + +SIMP_TAC (std_ss++boolSimps.EQUIV_EXTRACT_ss) [PMATCH_PRED_UNROLL_CONS_NO_INJ, GSYM LEFT_FORALL_IMP_THM] THEN +REPEAT STRIP_TAC THEN +CONSEQ_CONV_TAC (K FORALL_EQ___CONSEQ_CONV) THEN +SIMP_TAC (std_ss++boolSimps.EQUIV_EXTRACT_ss) [] THEN +REPEAT STRIP_TAC THEN +Tactical.REVERSE (`(@x'. PMATCH_ROW_COND p g v x') = x` by ALL_TAC) THEN1 ( + POP_ASSUM MP_TAC THEN + ASM_SIMP_TAC std_ss [] +) THEN +SELECT_ELIM_TAC THEN +SIMP_TAC std_ss [PMATCH_ROW_COND_def] THEN +METIS_TAC[]); + + val _ = export_theory();; From 2cd4c16de6aabd0776caa97e98750bb8037978e9 Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Fri, 20 Feb 2015 10:58:29 +0000 Subject: [PATCH 191/718] Update CHERI model. --- .../l3-machine-code/cheri/cheriScript.sml | 912 +++++++++++------- 1 file changed, 582 insertions(+), 330 deletions(-) diff --git a/examples/l3-machine-code/cheri/cheriScript.sml b/examples/l3-machine-code/cheri/cheriScript.sml index 5ba9f21647..b728d29908 100644 --- a/examples/l3-machine-code/cheri/cheriScript.sml +++ b/examples/l3-machine-code/cheri/cheriScript.sml @@ -1,4 +1,4 @@ -(* cheriScript.sml - generated by L<3> - Wed Jan 14 10:29:13 2015 *) +(* cheriScript.sml - generated by L<3> - Fri Feb 20 10:52:48 2015 *) open HolKernel boolLib bossLib Import val () = Import.start "cheri" @@ -4268,6 +4268,11 @@ val log_store_cap_def = Def CC[LS"MEM[0x",Call("hex40",sTy,Var("pAddr",FTy 40)),LS"] <- ", Call("log_cap_write",sTy,Var("cap",CTy"Capability"))]) ; +val log_load_cap_def = Def + ("log_load_cap",TP[Var("pAddr",FTy 40),Var("cap",CTy"Capability")], + CC[Call("log_cap_write",sTy,Var("cap",CTy"Capability")),LS" <- MEM[0x", + Call("hex40",sTy,Var("pAddr",FTy 40)),LS"]"]) +; val log_cap_exce_def = Def ("log_cap_exce",TP[Var("e",F8),Var("cr",F8)], Close @@ -8425,20 +8430,25 @@ val write'CPR_def = Def Mop(Fst, Apply (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s")), - Apply - (Call - ("write'CP0",ATy(qTy,PTy(uTy,qTy)), - Rupd - ("Cause", - TP[Var("v",CTy"CP0"), - Call - ("write'reg'CauseRegister", - CTy"CauseRegister", - TP[Dest - ("Cause",CTy"CauseRegister", - Var("v",CTy"CP0")), - EX(Var("value",F64),LN 31,LN 0,F32)])])), - qVar"s"))), + Let(Var("x0",CTy"CauseRegister"), + Dest("Cause",CTy"CauseRegister",Var("v",CTy"CP0")), + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Cause", + TP[Var("v",CTy"CP0"), + Rupd + ("IP", + TP[Var("x0",CTy"CauseRegister"), + BFI(LN 1,LN 0, + EX(Var("value",F64),LN 9, + LN 8,FTy 2), + Dest + ("IP",F8, + Var("x0", + CTy"CauseRegister")))])])), + qVar"s")))), (TP[LN 0,LW(14,5),LW(0,3)], Apply (Call @@ -9664,18 +9674,74 @@ val LoadMemoryCap_def = Def PTy(F64, PTy(FTy 40, qTy))))), - TP[Mop(Fst, - Mop(Snd, + Let(Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy)))), + TP[Mop(Fst, Var("s", PTy(bTy, PTy(F64, PTy(FTy 40, - qTy)))))), - Var("s", - PTy(bTy, - PTy(F64, - PTy(FTy 40, - qTy))))])))), + qTy))))), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy)))))), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy))))))), + Mop(Snd, + Apply + (Call + ("mark_log", + ATy(qTy, + PTy(uTy, + qTy)), + TP[LN + 2, + CC[LS + "Load of ", + Mop(Cast + sTy, + Bop(Add, + Mop(Cast + nTy, + Var("MemType", + FTy 3)), + LN + 1)), + LS + " byte(s)"]]), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy)))))))))], + TP[Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy)))))), + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy))))]))))), TP[Var("r",F64), Mop(Snd, Var("s1", @@ -10226,13 +10292,44 @@ val LoadCap_def = Def Var("s", PTy(CTy"Capability", qTy)))))], - TP[Mop(Fst, + Let(Var("s", + PTy(CTy"Capability", + qTy)), + TP[Mop(Fst, + Var("s", + PTy(CTy"Capability", + qTy))), + Mop(Snd, + Apply + (Call + ("mark_log", + ATy(qTy, + PTy(uTy, + qTy)), + TP[LN + 2, + CC[LS + "Load cap: ", + Call + ("log_load_cap", + sTy, + TP[Var("pAddr", + FTy 40), + Mop(Fst, + Var("s", + PTy(CTy"Capability", + qTy)))])]]), + Mop(Snd, + Var("s", + PTy(CTy"Capability", + qTy)))))], + TP[Mop(Fst, + Var("s", + PTy(CTy"Capability", + qTy))), Var("s", PTy(CTy"Capability", - qTy))), - Var("s", - PTy(CTy"Capability", - qTy))]))))))), + qTy))])))))))), TP[Var("r",CTy"Capability"), Mop(Snd,Var("s1",PTy(CTy"Capability",qTy)))])), TP[LX(CTy"Capability"),qVar"s"]))))) @@ -11230,307 +11327,372 @@ val StoreMemoryCap_def = Def PTy(bTy, PTy(FTy 40, qTy)))))))))], - ITE(Mop(Not, - Mop(Fst, - Var("s", + Let(Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))), + ITE(Mop(Not, + Mop(Fst, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))))), + Let(Var("s", PTy(bTy, PTy(bTy, PTy(FTy 40, - qTy)))))), - Let(Var("s", - PTy(bTy, - PTy(bTy, - PTy(FTy 40, - qTy)))), - Mop(Snd, - Apply - (For(TP[LN - 0, - Bop(Sub, - Dest - ("totalCore", - nTy, - Mop(Snd, + qTy)))), + Mop(Snd, + Apply + (For(TP[LN + 0, + Bop(Sub, + Dest + ("totalCore", + nTy, Mop(Snd, Mop(Snd, - Var("s", - PTy(bTy, + Mop(Snd, + Var("s", PTy(bTy, - PTy(FTy 40, - qTy)))))))), - LN - 1), - Close - (nVar"core", - Close - (Var("state", - PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))))))), + LN + 1), + Close + (nVar"core", + Close + (Var("state", PTy(bTy, - PTy(FTy 40, - qTy)))), - TP[LU, - ITE(Bop(And, - Bop(And, - Mop(Not, - EQ(nVar"core", - Mop(Cast - nTy, - Dest - ("procID", - F8, - Mop(Snd, - Mop(Snd, + PTy(bTy, + PTy(FTy 40, + qTy)))), + TP[LU, + ITE(Bop(And, + Bop(And, + Bop(And, + Mop(Not, + EQ(nVar"core", + Mop(Cast + nTy, + Dest + ("procID", + F8, Mop(Snd, - Var("state", - PTy(bTy, - PTy(bTy, - PTy(FTy 40, - qTy))))))))))), - EQ(Apply - (Dest - ("c_LLbit", - ATy(F8, - OTy bTy), - Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("state", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy))))))))))), + Bop(Or, + Mop(Not, + bVar"cond"), + Mop(Fst, + Mop(Snd, + Var("state", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))))))), + EQ(Apply + (Dest + ("c_LLbit", + ATy(F8, + OTy bTy), Mop(Snd, Mop(Snd, - Var("state", - PTy(bTy, + Mop(Snd, + Var("state", PTy(bTy, - PTy(FTy 40, - qTy)))))))), - Mop(Cast - F8, - nVar"core")), - Mop(Some, - LT))), - EQ(EX(Dest - ("LLAddr", - F64, - Apply - (Dest - ("c_CP0", - ATy(F8, - CTy"CP0"), - Mop(Snd, + PTy(bTy, + PTy(FTy 40, + qTy)))))))), + Mop(Cast + F8, + nVar"core")), + Mop(Some, + LT))), + EQ(EX(Dest + ("LLAddr", + F64, + Apply + (Dest + ("c_CP0", + ATy(F8, + CTy"CP0"), Mop(Snd, Mop(Snd, - Var("state", - PTy(bTy, + Mop(Snd, + Var("state", PTy(bTy, - PTy(FTy 40, - qTy)))))))), - Mop(Cast - F8, - nVar"core"))), - LN - 39, - LN - 5, - FTy 35), - EX(Mop(Fst, - Mop(Snd, + PTy(bTy, + PTy(FTy 40, + qTy)))))))), + Mop(Cast + F8, + nVar"core"))), + LN + 39, + LN + 5, + FTy 35), + EX(Mop(Fst, Mop(Snd, - Var("state", - PTy(bTy, + Mop(Snd, + Var("state", PTy(bTy, - PTy(FTy 40, - qTy))))))), - LN - 39, - LN - 5, - FTy 35))), - TP[Mop(Fst, - Var("state", - PTy(bTy, - PTy(bTy, - PTy(FTy 40, - qTy))))), - Let(Var("s0", - PTy(bTy, - PTy(FTy 40, - qTy))), - Mop(Snd, + PTy(bTy, + PTy(FTy 40, + qTy))))))), + LN + 39, + LN + 5, + FTy 35))), + TP[Mop(Fst, Var("state", PTy(bTy, PTy(bTy, PTy(FTy 40, qTy))))), - TP[Mop(Fst, - Var("s0", - PTy(bTy, - PTy(FTy 40, - qTy)))), - Let(Var("s0", - PTy(FTy 40, - qTy)), - Mop(Snd, + Let(Var("s0", + PTy(bTy, + PTy(FTy 40, + qTy))), + Mop(Snd, + Var("state", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy))))), + TP[Mop(Fst, Var("s0", PTy(bTy, PTy(FTy 40, qTy)))), - TP[Mop(Fst, - Var("s0", - PTy(FTy 40, - qTy))), - Rupd - ("c_LLbit", - TP[Mop(Snd, - Var("s0", - PTy(FTy 40, - qTy))), - Fupd - (Dest - ("c_LLbit", - ATy(F8, - OTy bTy), - Mop(Snd, + Let(Var("s0", + PTy(FTy 40, + qTy)), + Mop(Snd, + Var("s0", + PTy(bTy, + PTy(FTy 40, + qTy)))), + TP[Mop(Fst, + Var("s0", + PTy(FTy 40, + qTy))), + Rupd + ("c_LLbit", + TP[Mop(Snd, + Var("s0", + PTy(FTy 40, + qTy))), + Fupd + (Dest + ("c_LLbit", + ATy(F8, + OTy bTy), Mop(Snd, Mop(Snd, - Var("state", - PTy(bTy, + Mop(Snd, + Var("state", PTy(bTy, - PTy(FTy 40, - qTy)))))))), - Mop(Cast - F8, - nVar"core"), - Mop(Some, - LF))])])])], - Var("state", - PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))))))), + Mop(Cast + F8, + nVar"core"), + Mop(Some, + LF))])])])], + Var("state", PTy(bTy, - PTy(FTy 40, - qTy)))))]))]), - Var("s", - PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))))]))]), + Var("s", PTy(bTy, - PTy(FTy 40, - qTy)))))), - ITE(Bop(Or, - Mop(Not, - bVar"cond"), - Mop(Fst, - Mop(Snd, - Var("s", - PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))))), + ITE(Bop(Or, + Mop(Not, + bVar"cond"), + Mop(Fst, + Mop(Snd, + Var("s", PTy(bTy, - PTy(FTy 40, - qTy))))))), - Let(Var("s", - PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy))))))), + Let(Var("s", PTy(bTy, - PTy(FTy 40, - qTy)))), - TP[Mop(Fst, - Var("s", - PTy(bTy, - PTy(bTy, - PTy(FTy 40, - qTy))))), - Mop(Fst, - Mop(Snd, + PTy(bTy, + PTy(FTy 40, + qTy)))), + TP[Mop(Fst, Var("s", PTy(bTy, PTy(bTy, PTy(FTy 40, - qTy)))))), - Mop(Fst, - Mop(Snd, + qTy))))), + Mop(Fst, Mop(Snd, Var("s", PTy(bTy, PTy(bTy, PTy(FTy 40, - qTy))))))), - Mop(Snd, - Apply - (Call - ("WriteData", - ATy(qTy, - PTy(uTy, - qTy)), - TP[Var("v", - FTy 37), - Var("MemElem", - F64), - Var("mask", - F64)]), - Mop(Snd, + qTy)))))), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy))))))), + Mop(Snd, + Apply + (Call + ("WriteData", + ATy(qTy, + PTy(uTy, + qTy)), + TP[Var("v", + FTy 37), + Var("MemElem", + F64), + Var("mask", + F64)]), Mop(Snd, Mop(Snd, - Var("s", - PTy(bTy, + Mop(Snd, + Var("s", PTy(bTy, - PTy(FTy 40, - qTy)))))))))], - Let(Var("s0", - PTy(bTy, - PTy(FTy 40, - qTy))), - Mop(Snd, - Var("s", - PTy(bTy, - PTy(bTy, - PTy(FTy 40, - qTy))))), + PTy(bTy, + PTy(FTy 40, + qTy)))))))))], TP[Mop(Fst, - Var("s0", + Var("s", PTy(bTy, - PTy(FTy 40, - qTy)))), + PTy(bTy, + PTy(FTy 40, + qTy))))), Let(Var("s0", - PTy(FTy 40, - qTy)), + PTy(bTy, + PTy(FTy 40, + qTy))), Mop(Snd, - Var("s0", + Var("s", PTy(bTy, - PTy(FTy 40, - qTy)))), + PTy(bTy, + PTy(FTy 40, + qTy))))), TP[Mop(Fst, Var("s0", + PTy(bTy, + PTy(FTy 40, + qTy)))), + Let(Var("s0", PTy(FTy 40, - qTy))), - Rupd - ("TAG", - TP[Mop(Snd, - Var("s0", - PTy(FTy 40, - qTy))), - Fupd - (Dest - ("TAG", - ATy(FTy 35, - bTy), - Mop(Snd, - Mop(Snd, - Mop(Snd, - Var("s", - PTy(bTy, - PTy(bTy, - PTy(FTy 40, - qTy)))))))), - EX(Var("v", - FTy 37), - LN - 36, - LN - 2, - FTy 35), - LF)])])])), - Mop(Snd, + qTy)), + Mop(Snd, + Var("s0", + PTy(bTy, + PTy(FTy 40, + qTy)))), + TP[Mop(Fst, + Var("s0", + PTy(FTy 40, + qTy))), + Rupd + ("TAG", + TP[Mop(Snd, + Var("s0", + PTy(FTy 40, + qTy))), + Fupd + (Dest + ("TAG", + ATy(FTy 35, + bTy), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))))))), + EX(Var("v", + FTy 37), + LN + 36, + LN + 2, + FTy 35), + LF)])])])]), Var("s", PTy(bTy, PTy(bTy, PTy(FTy 40, - qTy))))))), - Mop(Snd, + qTy)))))), Var("s", PTy(bTy, PTy(bTy, PTy(FTy 40, - qTy))))))))))))), + qTy))))), + TP[Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))))), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy))))))), + Mop(Snd, + Apply + (Call + ("mark_log", + ATy(qTy, + PTy(uTy, + qTy)), + TP[LN + 2, + CC[LS + "Store of ", + Mop(Cast + sTy, + Bop(Add, + Mop(Cast + nTy, + Var("AccessLength", + FTy 3)), + LN + 1)), + LS + " byte(s)"]]), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))))))))])))))))), Var("s", PTy(bTy, PTy(FTy 40,qTy)))), @@ -11865,13 +12027,15 @@ val StoreCap_def = Def qTy)), TP[LN 2, - Call - ("log_store_cap", - sTy, - TP[Var("pAddr", - FTy 40), - Var("Capability", - CTy"Capability")])]), + CC[LS + "Store cap: ", + Call + ("log_store_cap", + sTy, + TP[Var("pAddr", + FTy 40), + Var("Capability", + CTy"Capability")])]]), Mop(Snd, Apply (For(TP[LN @@ -19783,7 +19947,7 @@ val dfn'CLLD_def = Def ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), TP[LC("capExcLength",CTy"CapException"), Var("cb",FTy 5)]),qVar"state")), - (Mop(Not,EQ(EX(Var("v",F64),LN 3,LN 0,F4),LW(0,4))), + (Mop(Not,EQ(EX(Var("v",F64),LN 2,LN 0,FTy 3),LW(0,3))), Apply (Call ("SignalException",ATy(qTy,PTy(uTy,qTy)), @@ -22591,7 +22755,7 @@ val dfn'CSCD_def = Def (Call ("GPR",ATy(qTy,PTy(F64,qTy)), Var("rt",FTy 5)),qVar"state"))]), - LW(32,65)), + LW(8,65)), CC[LW(0,1), Dest ("length",F64, @@ -22620,7 +22784,7 @@ val dfn'CSCD_def = Def ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), TP[LC("capExcLength",CTy"CapException"), Var("cb",FTy 5)]),qVar"state")), - (Mop(Not,EQ(EX(Var("v",F64),LN 4,LN 0,FTy 5),LW(0,5))), + (Mop(Not,EQ(EX(Var("v",F64),LN 2,LN 0,FTy 3),LW(0,3))), Apply (Call ("SignalException",ATy(qTy,PTy(uTy,qTy)), @@ -33557,6 +33721,88 @@ val Decode_def = Def bVar"b'3",bVar"b'2",bVar"b'1",bVar"b'0"])])))], Const("ReservedInstruction",CTy"instruction")))) ; +val pad_def = Def ("pad",sVar"s",Mop(PadRight,TP[LSC #" ",LN 12,sVar"s"])) +; +val gr_def = Def + ("gr",Var("n",FTy 5), + CC[LS"$",Mop(Cast sTy,Mop(Cast nTy,Var("n",FTy 5)))]) +; +val cr_def = Def + ("cr",Var("n",FTy 5), + CC[LS"c",Mop(Cast sTy,Mop(Cast nTy,Var("n",FTy 5)))]) +; +val imm_def = Def + ("imm",Var("n",BTy"N"), + ITE(Bop(Ult,Var("n",BTy"N"),LY(10,"N")),Mop(Cast sTy,Var("n",BTy"N")), + CC[LS"0x",Mop(Cast sTy,Var("n",BTy"N"))])) +; +val op_cr_def = Def + ("op_cr",TP[sVar"op",Var("cr1",FTy 5)], + CC[Call("pad",sTy,sVar"op"),Call("cr",sTy,Var("cr1",FTy 5))]) +; +val op_gr_def = Def + ("op_gr",TP[sVar"op",Var("r1",FTy 5)], + CC[Call("pad",sTy,sVar"op"),Call("gr",sTy,Var("r1",FTy 5))]) +; +val op_cr_imm_def = Def + ("op_cr_imm",TP[sVar"op",Var("cr1",FTy 5),Var("i",BTy"N")], + CC[Call("pad",sTy,sVar"op"),Call("cr",sTy,Var("cr1",FTy 5)),LS", ", + Call("imm",sTy,Var("i",BTy"N"))]) +; +val op_cr_gr_def = Def + ("op_cr_gr",TP[sVar"op",Var("cr1",FTy 5),Var("r1",FTy 5)], + CC[Call("pad",sTy,sVar"op"),Call("cr",sTy,Var("cr1",FTy 5)),LS", ", + Call("gr",sTy,Var("r1",FTy 5))]) +; +val op_gr_cr_def = Def + ("op_gr_cr",TP[sVar"op",Var("r1",FTy 5),Var("cr1",FTy 5)], + CC[Call("pad",sTy,sVar"op"),Call("gr",sTy,Var("r1",FTy 5)),LS", ", + Call("cr",sTy,Var("cr1",FTy 5))]) +; +val op_cr_cr_def = Def + ("op_cr_cr",TP[sVar"op",Var("cr1",FTy 5),Var("cr2",FTy 5)], + CC[Call("pad",sTy,sVar"op"),Call("cr",sTy,Var("cr1",FTy 5)),LS", ", + Call("cr",sTy,Var("cr2",FTy 5))]) +; +val op_cr_cr_gr_def = Def + ("op_cr_cr_gr", + TP[sVar"op",Var("cr1",FTy 5),Var("cr2",FTy 5),Var("r1",FTy 5)], + CC[Call("pad",sTy,sVar"op"),Call("cr",sTy,Var("cr1",FTy 5)),LS", ", + Call("cr",sTy,Var("cr2",FTy 5)),LS", ", + Call("gr",sTy,Var("r1",FTy 5))]) +; +val op_cr_cr_cr_def = Def + ("op_cr_cr_cr", + TP[sVar"op",Var("cr1",FTy 5),Var("cr2",FTy 5),Var("cr3",FTy 5)], + CC[Call("pad",sTy,sVar"op"),Call("cr",sTy,Var("cr1",FTy 5)),LS", ", + Call("cr",sTy,Var("cr2",FTy 5)),LS", ", + Call("cr",sTy,Var("cr3",FTy 5))]) +; +val op_gr_cr_cr_def = Def + ("op_gr_cr_cr", + TP[sVar"op",Var("r1",FTy 5),Var("cr1",FTy 5),Var("cr2",FTy 5)], + CC[Call("pad",sTy,sVar"op"),Call("gr",sTy,Var("r1",FTy 5)),LS", ", + Call("cr",sTy,Var("cr1",FTy 5)),LS", ", + Call("cr",sTy,Var("cr2",FTy 5))]) +; +val op_gr_cr_gr_imm_def = Def + ("op_gr_cr_gr_imm", + TP[sVar"op",Var("r1",FTy 5),Var("cr1",FTy 5),Var("r2",FTy 5), + Var("i",BTy"N")], + CC[Call("pad",sTy,sVar"op"),Call("gr",sTy,Var("r1",FTy 5)),LS", ", + Call("cr",sTy,Var("cr1",FTy 5)),LS", ", + Call("gr",sTy,Var("r2",FTy 5)),LS", ", + Call("imm",sTy,Var("i",BTy"N"))]) +; +val op_cr_cr_gr_imm_def = Def + ("op_cr_cr_gr_imm", + TP[sVar"op",Var("cr1",FTy 5),Var("cr2",FTy 5),Var("r1",FTy 5), + Var("i",BTy"N")], + CC[Call("pad",sTy,sVar"op"),Call("cr",sTy,Var("cr1",FTy 5)),LS", ", + Call("cr",sTy,Var("cr2",FTy 5)),LS", ", + Call("gr",sTy,Var("r1",FTy 5)),LS", ", + Call("imm",sTy,Var("i",BTy"N"))]) +; val COP2InstructionToString_def = Def ("COP2InstructionToString",Var("i",CTy"instruction"), CS(Var("i",CTy"instruction"), @@ -33571,7 +33817,7 @@ val COP2InstructionToString_def = Def ("CGetBase",CTy"CGet", TP[Var("rd",FTy 5),Var("cb",FTy 5)])), Call - ("op2r",sTy, + ("op_gr_cr",sTy, TP[LS"cgetbase",Var("rd",FTy 5),Var("cb",FTy 5)])), (Call ("CGet",CTy"CHERICOP2", @@ -33579,27 +33825,29 @@ val COP2InstructionToString_def = Def ("CGetOffset",CTy"CGet", TP[Var("rd",FTy 5),Var("cb",FTy 5)])), Call - ("op2r",sTy, + ("op_gr_cr",sTy, TP[LS"cgetoffset",Var("rd",FTy 5),Var("cb",FTy 5)])), (Call ("CGet",CTy"CHERICOP2", Call ("CGetLen",CTy"CGet",TP[Var("rd",FTy 5),Var("cb",FTy 5)])), Call - ("op2r",sTy,TP[LS"cgetlen",Var("rd",FTy 5),Var("cb",FTy 5)])), + ("op_gr_cr",sTy, + TP[LS"cgetlen",Var("rd",FTy 5),Var("cb",FTy 5)])), (Call ("CGet",CTy"CHERICOP2", Call ("CGetTag",CTy"CGet",TP[Var("rd",FTy 5),Var("cb",FTy 5)])), Call - ("op2r",sTy,TP[LS"cgettag",Var("rd",FTy 5),Var("cb",FTy 5)])), + ("op_gr_cr",sTy, + TP[LS"cgettag",Var("rd",FTy 5),Var("cb",FTy 5)])), (Call ("CGet",CTy"CHERICOP2", Call ("CGetSealed",CTy"CGet", TP[Var("rd",FTy 5),Var("cb",FTy 5)])), Call - ("op2r",sTy, + ("op_gr_cr",sTy, TP[LS"cgetsealed",Var("rd",FTy 5),Var("cb",FTy 5)])), (Call ("CGet",CTy"CHERICOP2", @@ -33607,7 +33855,7 @@ val COP2InstructionToString_def = Def ("CGetPerm",CTy"CGet", TP[Var("rd",FTy 5),Var("cb",FTy 5)])), Call - ("op2r",sTy, + ("op_gr_cr",sTy, TP[LS"cgetperm",Var("rd",FTy 5),Var("cb",FTy 5)])), (Call ("CGet",CTy"CHERICOP2", @@ -33615,27 +33863,27 @@ val COP2InstructionToString_def = Def ("CGetType",CTy"CGet", TP[Var("rd",FTy 5),Var("cb",FTy 5)])), Call - ("op2r",sTy, + ("op_gr_cr",sTy, TP[LS"cgettype",Var("rd",FTy 5),Var("cb",FTy 5)])), (Call ("CGet",CTy"CHERICOP2", Call("CGetPCC",CTy"CGet",Var("cd",FTy 5))), - Call("op1r",sTy,TP[LS"cgetpcc",Var("cd",FTy 5)])), + Call("op_cr",sTy,TP[LS"cgetpcc",Var("cd",FTy 5)])), (Call ("CGet",CTy"CHERICOP2", Call("CGetCause",CTy"CGet",Var("rd",FTy 5))), - Call("op1r",sTy,TP[LS"cgetcause",Var("rd",FTy 5)])), + Call("op_gr",sTy,TP[LS"cgetcause",Var("rd",FTy 5)])), (Call ("CSet",CTy"CHERICOP2", Call("CSetCause",CTy"CSet",Var("rt",FTy 5))), - Call("op1r",sTy,TP[LS"csetcause",Var("rt",FTy 5)])), + Call("op_gr",sTy,TP[LS"csetcause",Var("rt",FTy 5)])), (Call ("CSet",CTy"CHERICOP2", Call ("CIncBase",CTy"CSet", TP[Var("cd",FTy 5),Var("cb",FTy 5),Var("rt",FTy 5)])), Call - ("op3r",sTy, + ("op_cr_cr_gr",sTy, TP[LS"cincbase",Var("cd",FTy 5),Var("cb",FTy 5), Var("rt",FTy 5)])), (Call @@ -33644,7 +33892,7 @@ val COP2InstructionToString_def = Def ("CIncOffset",CTy"CSet", TP[Var("cd",FTy 5),Var("cb",FTy 5),Var("rt",FTy 5)])), Call - ("op3r",sTy, + ("op_cr_cr_gr",sTy, TP[LS"cincoffset",Var("cd",FTy 5),Var("cb",FTy 5), Var("rt",FTy 5)])), (Call @@ -33653,7 +33901,7 @@ val COP2InstructionToString_def = Def ("CSetLen",CTy"CSet", TP[Var("cd",FTy 5),Var("cb",FTy 5),Var("rt",FTy 5)])), Call - ("op3r",sTy, + ("op_cr_cr_gr",sTy, TP[LS"csetlen",Var("cd",FTy 5),Var("cb",FTy 5), Var("rt",FTy 5)])), (Call @@ -33662,7 +33910,7 @@ val COP2InstructionToString_def = Def ("CClearTag",CTy"CSet", TP[Var("cd",FTy 5),Var("cb",FTy 5)])), Call - ("op2r",sTy, + ("op_cr_cr",sTy, TP[LS"ccleartag",Var("cd",FTy 5),Var("cb",FTy 5)])), (Call ("CSet",CTy"CHERICOP2", @@ -33670,7 +33918,7 @@ val COP2InstructionToString_def = Def ("CAndPerm",CTy"CSet", TP[Var("cd",FTy 5),Var("cb",FTy 5),Var("rt",FTy 5)])), Call - ("op3r",sTy, + ("op_cr_cr_gr",sTy, TP[LS"candperm",Var("cd",FTy 5),Var("cb",FTy 5), Var("rt",FTy 5)])), (Call @@ -33679,7 +33927,7 @@ val COP2InstructionToString_def = Def ("CSetOffset",CTy"CSet", TP[Var("cd",FTy 5),Var("cb",FTy 5),Var("rt",FTy 5)])), Call - ("op3r",sTy, + ("op_cr_cr_gr",sTy, TP[LS"csetoffset",Var("cd",FTy 5),Var("cb",FTy 5), Var("rt",FTy 5)])), (Call @@ -33688,7 +33936,7 @@ val COP2InstructionToString_def = Def ("CCheckPerm",CTy"CCheck", TP[Var("cs",FTy 5),Var("rt",FTy 5)])), Call - ("op2r",sTy, + ("op_cr_gr",sTy, TP[LS"ccheckperm",Var("cs",FTy 5),Var("rt",FTy 5)])), (Call ("CCheck",CTy"CHERICOP2", @@ -33696,7 +33944,7 @@ val COP2InstructionToString_def = Def ("CCheckType",CTy"CCheck", TP[Var("cs",FTy 5),Var("cb",FTy 5)])), Call - ("op2r",sTy, + ("op_cr_cr",sTy, TP[LS"cchecktype",Var("cs",FTy 5),Var("cb",FTy 5)])), (Call ("CSet",CTy"CHERICOP2", @@ -33704,7 +33952,7 @@ val COP2InstructionToString_def = Def ("CFromPtr",CTy"CSet", TP[Var("cd",FTy 5),Var("cb",FTy 5),Var("rt",FTy 5)])), Call - ("op3r",sTy, + ("op_cr_cr_gr",sTy, TP[LS"cfromptr",Var("cd",FTy 5),Var("cb",FTy 5), Var("rt",FTy 5)])), (Call @@ -33713,7 +33961,7 @@ val COP2InstructionToString_def = Def ("CToPtr",CTy"CGet", TP[Var("rd",FTy 5),Var("cb",FTy 5),Var("ct",FTy 5)])), Call - ("op3r",sTy, + ("op_gr_cr_cr",sTy, TP[LS"ctoptr",Var("rd",FTy 5),Var("cb",FTy 5), Var("ct",FTy 5)])), (Call @@ -33723,32 +33971,32 @@ val COP2InstructionToString_def = Def CS(Var("t",FTy 3), [(LW(0,3), Call - ("op3r",sTy, + ("op_gr_cr_cr",sTy, TP[LS"ceq",Var("rd",FTy 5),Var("cb",FTy 5), Var("ct",FTy 5)])), (LW(1,3), Call - ("op3r",sTy, + ("op_gr_cr_cr",sTy, TP[LS"cne",Var("rd",FTy 5),Var("cb",FTy 5), Var("ct",FTy 5)])), (LW(2,3), Call - ("op3r",sTy, + ("op_gr_cr_cr",sTy, TP[LS"clt",Var("rd",FTy 5),Var("cb",FTy 5), Var("ct",FTy 5)])), (LW(3,3), Call - ("op3r",sTy, + ("op_gr_cr_cr",sTy, TP[LS"cle",Var("rd",FTy 5),Var("cb",FTy 5), Var("ct",FTy 5)])), (LW(4,3), Call - ("op3r",sTy, + ("op_gr_cr_cr",sTy, TP[LS"cltu",Var("rd",FTy 5),Var("cb",FTy 5), Var("ct",FTy 5)])), (LW(5,3), Call - ("op3r",sTy, + ("op_gr_cr_cr",sTy, TP[LS"cleu",Var("rd",FTy 5),Var("cb",FTy 5), Var("ct",FTy 5)])), (AVar(FTy 3),LS"unmatched_cap_inst")])), @@ -33756,36 +34004,40 @@ val COP2InstructionToString_def = Def ("CBTU",CTy"CHERICOP2", TP[Var("cb",FTy 5),Var("offset",F16)]), Call - ("op1ri",sTy,TP[LS"cbtu",Var("cb",FTy 5),Var("offset",F16)])), + ("op_cr_imm",sTy, + TP[LS"cbtu",Var("cb",FTy 5),Var("offset",F16)])), (Call ("CBTS",CTy"CHERICOP2", TP[Var("cb",FTy 5),Var("offset",F16)]), Call - ("op1ri",sTy,TP[LS"cbts",Var("cb",FTy 5),Var("offset",F16)])), + ("op_cr_imm",sTy, + TP[LS"cbts",Var("cb",FTy 5),Var("offset",F16)])), (Call("CJR",CTy"CHERICOP2",Var("cb",FTy 5)), - Call("op1r",sTy,TP[LS"cjr",Var("cb",FTy 5)])), + Call("op_cr",sTy,TP[LS"cjr",Var("cb",FTy 5)])), (Call ("CJALR",CTy"CHERICOP2",TP[Var("cd",FTy 5),Var("cb",FTy 5)]), Call - ("op2r",sTy,TP[LS"cjalr",Var("cd",FTy 5),Var("cb",FTy 5)])), + ("op_cr_cr",sTy, + TP[LS"cjalr",Var("cd",FTy 5),Var("cb",FTy 5)])), (Call ("CSeal",CTy"CHERICOP2", TP[Var("cd",FTy 5),Var("cs",FTy 5),Var("ct",FTy 5)]), Call - ("op3r",sTy, + ("op_cr_cr_cr",sTy, TP[LS"cseal",Var("cd",FTy 5),Var("cs",FTy 5), Var("ct",FTy 5)])), (Call ("CUnseal",CTy"CHERICOP2", TP[Var("cd",FTy 5),Var("cs",FTy 5),Var("ct",FTy 5)]), Call - ("op3r",sTy, + ("op_cr_cr_cr",sTy, TP[LS"cunseal",Var("cd",FTy 5),Var("cs",FTy 5), Var("ct",FTy 5)])), (Call ("CCall",CTy"CHERICOP2",TP[Var("cs",FTy 5),Var("cb",FTy 5)]), Call - ("op2r",sTy,TP[LS"ccall",Var("cs",FTy 5),Var("cb",FTy 5)])), + ("op_cr_cr",sTy, + TP[LS"ccall",Var("cs",FTy 5),Var("cb",FTy 5)])), (Const("CReturn",CTy"CHERICOP2"),LS"creturn"), (Const("UnknownCapInstruction",CTy"CHERICOP2"), LS"unknown_cap_inst")])), @@ -33805,22 +34057,22 @@ val LWC2InstructionToString_def = Def CS(Var("t",FTy 2), [(LW(0,2), Call - ("op3ro",sTy, + ("op_gr_cr_gr_imm",sTy, TP[LS"clbu",Var("rd",FTy 5),Var("cb",FTy 5), Var("rt",FTy 5),Var("offset",F8)])), (LW(1,2), Call - ("op3ro",sTy, + ("op_gr_cr_gr_imm",sTy, TP[LS"clhu",Var("rd",FTy 5),Var("cb",FTy 5), Var("rt",FTy 5),Var("offset",F8)])), (LW(2,2), Call - ("op3ro",sTy, + ("op_gr_cr_gr_imm",sTy, TP[LS"clwu",Var("rd",FTy 5),Var("cb",FTy 5), Var("rt",FTy 5),Var("offset",F8)])), (LW(3,2), Call - ("op3ro",sTy, + ("op_gr_cr_gr_imm",sTy, TP[LS"cld",Var("rd",FTy 5),Var("cb",FTy 5), Var("rt",FTy 5),Var("offset",F8)]))])), (Call @@ -33828,7 +34080,7 @@ val LWC2InstructionToString_def = Def TP[Var("rd",FTy 5),Var("cb",FTy 5),Var("rt",FTy 5), Var("offset",F8),LW(1,1),LW(0,2)]), Call - ("op3ro",sTy, + ("op_gr_cr_gr_imm",sTy, TP[LS"clb",Var("rd",FTy 5),Var("cb",FTy 5), Var("rt",FTy 5),Var("offset",F8)])), (Call @@ -33836,7 +34088,7 @@ val LWC2InstructionToString_def = Def TP[Var("rd",FTy 5),Var("cb",FTy 5),Var("rt",FTy 5), Var("offset",F8),LW(1,1),LW(1,2)]), Call - ("op3ro",sTy, + ("op_gr_cr_gr_imm",sTy, TP[LS"clh",Var("rd",FTy 5),Var("cb",FTy 5), Var("rt",FTy 5),Var("offset",F8)])), (Call @@ -33844,7 +34096,7 @@ val LWC2InstructionToString_def = Def TP[Var("rd",FTy 5),Var("cb",FTy 5),Var("rt",FTy 5), Var("offset",F8),LW(1,1),LW(2,2)]), Call - ("op3ro",sTy, + ("op_gr_cr_gr_imm",sTy, TP[LS"clw",Var("rd",FTy 5),Var("cb",FTy 5), Var("rt",FTy 5),Var("offset",F8)])), (Call @@ -33852,7 +34104,7 @@ val LWC2InstructionToString_def = Def TP[Var("rd",FTy 5),Var("cb",FTy 5),Var("rt",FTy 5), Var("offset",F8)]), Call - ("op3ro",sTy, + ("op_gr_cr_gr_imm",sTy, TP[LS"clld",Var("rd",FTy 5),Var("cb",FTy 5), Var("rt",FTy 5),Var("offset",F8)])), (AVar(CTy"CHERILWC2"),LS"unmatched_cap_inst")])), @@ -33870,7 +34122,7 @@ val LDC2InstructionToString_def = Def TP[Var("cd",FTy 5),Var("cb",FTy 5),Var("rt",FTy 5), Var("offset",FTy 11)]), Call - ("op3ro",sTy, + ("op_cr_cr_gr_imm",sTy, TP[LS"clc",Var("cd",FTy 5),Var("cb",FTy 5), Var("rt",FTy 5),Var("offset",FTy 11)]))])), (AVar(CTy"instruction"),LS"unmatched_cap_inst")])) @@ -33889,22 +34141,22 @@ val SWC2InstructionToString_def = Def CS(Var("t",FTy 2), [(LW(0,2), Call - ("op3ro",sTy, + ("op_gr_cr_gr_imm",sTy, TP[LS"csb",Var("rs",FTy 5),Var("cb",FTy 5), Var("rt",FTy 5),Var("offset",F8)])), (LW(1,2), Call - ("op3ro",sTy, + ("op_gr_cr_gr_imm",sTy, TP[LS"csh",Var("rs",FTy 5),Var("cb",FTy 5), Var("rt",FTy 5),Var("offset",F8)])), (LW(2,2), Call - ("op3ro",sTy, + ("op_gr_cr_gr_imm",sTy, TP[LS"csw",Var("rs",FTy 5),Var("cb",FTy 5), Var("rt",FTy 5),Var("offset",F8)])), (LW(3,2), Call - ("op3ro",sTy, + ("op_gr_cr_gr_imm",sTy, TP[LS"csd",Var("rs",FTy 5),Var("cb",FTy 5), Var("rt",FTy 5),Var("offset",F8)]))])), (Call @@ -33912,7 +34164,7 @@ val SWC2InstructionToString_def = Def TP[Var("rs",FTy 5),Var("cb",FTy 5),Var("rt",FTy 5), Var("offset",F8)]), Call - ("op3ro",sTy, + ("op_gr_cr_gr_imm",sTy, TP[LS"cscd",Var("rs",FTy 5),Var("cb",FTy 5), Var("rt",FTy 5),Var("offset",F8)]))])), (AVar(CTy"instruction"),LS"unmatched_cap_inst")])) @@ -33929,7 +34181,7 @@ val SDC2InstructionToString_def = Def TP[Var("cs",FTy 5),Var("cb",FTy 5),Var("rt",FTy 5), Var("offset",FTy 11)]), Call - ("op3ro",sTy, + ("op_cr_cr_gr_imm",sTy, TP[LS"csc",Var("cs",FTy 5),Var("cb",FTy 5), Var("rt",FTy 5),Var("offset",FTy 11)]))])), (AVar(CTy"instruction"),LS"unmatched_cap_inst")])) @@ -36890,7 +37142,7 @@ val initMips_def = Def CTy"ConfigRegister2", Var("v", CTy"CP0")), - LW(8, + LW(1, 4)])])), qVar"s")), Let(Var("v", @@ -36922,7 +37174,7 @@ val initMips_def = Def CTy"ConfigRegister2", Var("v", CTy"CP0")), - LW(4, + LW(6, 4)])])), qVar"s")), Let(Var("v", @@ -36954,7 +37206,7 @@ val initMips_def = Def CTy"ConfigRegister2", Var("v", CTy"CP0")), - LW(0, + LW(3, 4)])])), qVar"s")), Let(Var("v", From ab8c7904894aff8894ff6c6dbfcc0f7995c1557b Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 23 Feb 2015 10:01:05 +1100 Subject: [PATCH 192/718] Test-case for Holmake, currently broken. Thanks to Ramana for the test. --- tools/Holmake/tests/depchain2/dir1/Holmakefile | 1 + tools/Holmake/tests/depchain2/dir1/dir2/Holmakefile | 1 + .../Holmake/tests/depchain2/dir1/dir2/thy2Script.sml | 11 +++++++++++ tools/Holmake/tests/depchain2/dir1/thy3Script.sml | 9 +++++++++ tools/Holmake/tests/depchain2/thy1Script.sml | 7 +++++++ tools/sequences/kernel | 3 ++- 6 files changed, 31 insertions(+), 1 deletion(-) create mode 100644 tools/Holmake/tests/depchain2/dir1/Holmakefile create mode 100644 tools/Holmake/tests/depchain2/dir1/dir2/Holmakefile create mode 100644 tools/Holmake/tests/depchain2/dir1/dir2/thy2Script.sml create mode 100644 tools/Holmake/tests/depchain2/dir1/thy3Script.sml create mode 100644 tools/Holmake/tests/depchain2/thy1Script.sml diff --git a/tools/Holmake/tests/depchain2/dir1/Holmakefile b/tools/Holmake/tests/depchain2/dir1/Holmakefile new file mode 100644 index 0000000000..61d60f8316 --- /dev/null +++ b/tools/Holmake/tests/depchain2/dir1/Holmakefile @@ -0,0 +1 @@ +INCLUDES = dir2 diff --git a/tools/Holmake/tests/depchain2/dir1/dir2/Holmakefile b/tools/Holmake/tests/depchain2/dir1/dir2/Holmakefile new file mode 100644 index 0000000000..2abceed35f --- /dev/null +++ b/tools/Holmake/tests/depchain2/dir1/dir2/Holmakefile @@ -0,0 +1 @@ +INCLUDES = ../.. diff --git a/tools/Holmake/tests/depchain2/dir1/dir2/thy2Script.sml b/tools/Holmake/tests/depchain2/dir1/dir2/thy2Script.sml new file mode 100644 index 0000000000..13ce7252b3 --- /dev/null +++ b/tools/Holmake/tests/depchain2/dir1/dir2/thy2Script.sml @@ -0,0 +1,11 @@ +open HolKernel Parse boolLib + +open thy1Theory + +val _ = new_theory "thy2"; + +val g_def = new_definition("g_def", + ``g x y = y /\ f x``); + + +val _ = export_theory(); diff --git a/tools/Holmake/tests/depchain2/dir1/thy3Script.sml b/tools/Holmake/tests/depchain2/dir1/thy3Script.sml new file mode 100644 index 0000000000..adc1b7b3b7 --- /dev/null +++ b/tools/Holmake/tests/depchain2/dir1/thy3Script.sml @@ -0,0 +1,9 @@ +open HolKernel Parse boolLib + +open thy2Theory + +val _ = new_theory "thy3"; + +val _ = save_thm("TRUTH", TRUTH) + +val _ = export_theory(); diff --git a/tools/Holmake/tests/depchain2/thy1Script.sml b/tools/Holmake/tests/depchain2/thy1Script.sml new file mode 100644 index 0000000000..7cfc1b99fd --- /dev/null +++ b/tools/Holmake/tests/depchain2/thy1Script.sml @@ -0,0 +1,7 @@ +open HolKernel Parse boolLib + +val _ = new_theory "thy1"; + +val f_def = new_definition("f_def", ``f x = x``) + +val _ = export_theory(); diff --git a/tools/sequences/kernel b/tools/sequences/kernel index da916bb7d4..32f662f9cf 100644 --- a/tools/sequences/kernel +++ b/tools/sequences/kernel @@ -10,8 +10,9 @@ src/postkernel src/parse src/bool src/1 -!src/1/theory_tests !tools/Holmake/tests/depchain1/dir3 +!tools/Holmake/tests/depchain2/dir1 !tools/Holmake/tests/altquote1/ +!src/1/theory_tests src/proofman [poly]bin/hol.bare From 36e19d76c330afc9b55354208af71db835f3b951 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 23 Feb 2015 10:21:48 +1100 Subject: [PATCH 193/718] Remove unnecessary print_list function within Holmake.sml --- tools-poly/Holmake/Holmake.sml | 22 ++++++++++------------ tools/Holmake/Holmake.sml | 23 +++++++++++------------ 2 files changed, 21 insertions(+), 24 deletions(-) diff --git a/tools-poly/Holmake/Holmake.sml b/tools-poly/Holmake/Holmake.sml index 6263bc2c95..8aebf50724 100644 --- a/tools-poly/Holmake/Holmake.sml +++ b/tools-poly/Holmake/Holmake.sml @@ -107,10 +107,6 @@ fun remove_duplicates [] = [] | remove_duplicates (x::xs) = x::(remove_duplicates (delete x xs)) fun alltrue [] = true | alltrue (x::xs) = x andalso alltrue xs -fun print_list0 [] = "]" - | print_list0 [x] = x^"]" - | print_list0 (x::xs) = x^", "^print_list0 xs -fun print_list l = "["^print_list0 l fun I x = x (*** parse command line *) @@ -693,8 +689,9 @@ val _ = if (debug) then let in print ("HOLDIR = "^HOLDIR^"\n"); print ("POLYMLLIBDIR = "^POLYMLLIBDIR^"\n"); - print ("Targets = "^print_list targets^"\n"); - print ("Additional includes = "^print_list additional_includes^"\n"); + print ("Targets = [" ^ String.concatWith ", " targets ^ "]\n"); + print ("Additional includes = " ^ String.concatWith ", " additional_includes ^ + "]\n"); print ("Using HOL sigobj dir = "^Bool.toString (not no_sigobj) ^"\n") end else () @@ -979,9 +976,9 @@ in set_union (get_implicit_dependencies incinfo target) (get_explicit_dependencies target) val _ = - (print ("Secondary dependencies for "^fromFile target^ - " are: "); - print (print_list (map fromFile secondaries) ^ "\n")) + print ("Secondary dependencies for "^fromFile target^ + " are: [" ^ + String.concatWith ", " (map fromFile secondaries) ^ "\n") in if List.all (make_up_to_date (target::ctxt)) secondaries then let fun testthis dep = @@ -1025,8 +1022,8 @@ in end | SOME {dependencies, commands, ...} => let val _ = - (print ("Secondary dependencies for "^tgt_str^" are: "); - print (print_list dependencies ^ "\n")) + print ("Secondary dependencies for "^tgt_str^" are: [" ^ + String.concatWith ", " dependencies ^ "]\n") val depfiles = map toFile dependencies in if List.all (make_up_to_date (target::ctxt)) depfiles @@ -1157,7 +1154,8 @@ in map (fn s => if OS.FileSys.access(s, []) then s else s ^ "(*)") targets in - print("Generated targets are: "^print_list tgtstrings ^ "\n") + print("Generated targets are: [" ^ + String.concatWith ", " tgtstrings ^ "]\n") end else () in diff --git a/tools/Holmake/Holmake.sml b/tools/Holmake/Holmake.sml index 795c12551d..0c321e9ea2 100644 --- a/tools/Holmake/Holmake.sml +++ b/tools/Holmake/Holmake.sml @@ -106,10 +106,6 @@ fun remove_duplicates [] = [] | remove_duplicates (x::xs) = x::(remove_duplicates (delete x xs)) fun alltrue [] = true | alltrue (x::xs) = x andalso alltrue xs -fun print_list0 [] = "]" - | print_list0 [x] = x^"]" - | print_list0 (x::xs) = x^", "^print_list0 xs -fun print_list l = "["^print_list0 l fun I x = x (*** parse command line *) @@ -498,8 +494,9 @@ val _ = if (debug) then let in print ("HOLDIR = "^HOLDIR^"\n"); print ("MOSMLDIR = "^MOSMLDIR^"\n"); - print ("Targets = "^print_list targets^"\n"); - print ("Additional includes = "^print_list additional_includes^"\n"); + print ("Targets = ["^String.concatWith ", " targets^"]\n"); + print ("Additional includes = [" ^ + String.concatWith ", " additional_includes ^ "]\n"); print ("Using HOL sigobj dir = "^Bool.toString (not no_sigobj) ^"\n") end else () @@ -819,9 +816,10 @@ in set_union (get_implicit_dependencies incinfo target) (get_explicit_dependencies target) val _ = - (print ("Secondary dependencies for "^fromFile target^ - " are: "); - print (print_list (map fromFile secondaries) ^ "\n")) + print ("Secondary dependencies for "^fromFile target^ + " are: [" ^ + String.concatWith ", " (map fromFile secondaries) ^ + "]\n") in if List.all (make_up_to_date (target::ctxt)) secondaries then let fun testthis dep = @@ -865,8 +863,8 @@ in end | SOME {dependencies, commands, ...} => let val _ = - (print ("Secondary dependencies for "^tgt_str^" are: "); - print (print_list dependencies ^ "\n")) + print ("Secondary dependencies for "^tgt_str^" are: [" ^ + String.concatWith ", " dependencies ^ "]\n") val depfiles = map toFile dependencies in if List.all (make_up_to_date (target::ctxt)) depfiles @@ -997,7 +995,8 @@ in map (fn s => if OS.FileSys.access(s,[]) then s else s ^ "(*)") targets in - print("Generated targets are: "^print_list tgtstrings ^ "\n") + print("Generated targets are: [" ^ + String.concatWith ", " tgtstrings ^ "]\n") end else () in From bf2f604a2e262a7cfe98b2f84b320d5e70eb96b5 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 23 Feb 2015 11:31:26 +1100 Subject: [PATCH 194/718] Isolate some parsing within boolLib.sml It's possible to get a (perhaps only Moscow ML) build to clash with the code here if there are theories around that make constants of names like "f" and "g". --- src/1/boolLib.sml | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/1/boolLib.sml b/src/1/boolLib.sml index db02801f42..fb2bde532c 100644 --- a/src/1/boolLib.sml +++ b/src/1/boolLib.sml @@ -28,6 +28,12 @@ val _ = DefnBase.write_congs (DefnBase.read_congs() @ ---------------------------------------------------------------------------*) local open HolKernel Ho_Rewrite (* signature control *) + structure Parse = + struct + open Parse + val (Type,Term) = parse_from_grammars bool_grammars + end + open Parse in (*---------------------------------------------------------------------------*) (* The first canjunct is useful when rewriting assumptions, but not when *) From c64ed77a3b2229427c2dc17a732e40811ef49ce1 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 23 Feb 2015 11:35:56 +1100 Subject: [PATCH 195/718] Make qcompile.sh copy the Holmake binary to HOL's bin directory --- tools/Holmake/qcompile.sh | 1 + 1 file changed, 1 insertion(+) diff --git a/tools/Holmake/qcompile.sh b/tools/Holmake/qcompile.sh index d745d71651..f04f6bea64 100755 --- a/tools/Holmake/qcompile.sh +++ b/tools/Holmake/qcompile.sh @@ -25,3 +25,4 @@ mosmlc -c ReadHMF.sig mosmlc -c basis2002.ui ReadHMF.sml mosmlc -c basis2002.ui Holmake.sml mosmlc -o Holmake Holmake.uo +cp Holmake ../../bin From 227f47086cedff564d749684b658e6d44d47a474 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 23 Feb 2015 11:36:24 +1100 Subject: [PATCH 196/718] More progress with Holmake and recursive dependencies Both depchain selftests pass now on both Poly and Moscow ML. The treatment of relative and absolute directories is more careful, for which see the hmdir structure within Holmake_tools. This stuff is really only as complicated as it is for cosmetic reasons: the various messages printed to the user try to avoid absolute paths for as long as possible. However, more/most/all internal uses will now be with absolute paths, which should help. --- tools-poly/Holmake/Holmake.sml | 50 ++++----- tools/Holmake/Holmake.sml | 53 ++++----- tools/Holmake/Holmake_tools.sig | 34 +++--- tools/Holmake/Holmake_tools.sml | 186 ++++++++++++++++++++++---------- 4 files changed, 206 insertions(+), 117 deletions(-) diff --git a/tools-poly/Holmake/Holmake.sml b/tools-poly/Holmake/Holmake.sml index 8aebf50724..fc7b22274e 100644 --- a/tools-poly/Holmake/Holmake.sml +++ b/tools-poly/Holmake/Holmake.sml @@ -330,10 +330,9 @@ end (* directory specific stuff here *) -fun Holmake dirinfo cline_additional_includes targets : holmake_result = let - val {abspath=dir, relpath=dirnm, visited = visiteddirs} = dirinfo - val _ = OS.FileSys.chDir dir - +fun Holmake dirinfo cline_additional_includes targets = let + val {dir, visited = visiteddirs} = dirinfo + val _ = OS.FileSys.chDir (hmdir.toAbsPath dir) (* prepare to do logging *) val () = if do_logging_flag then @@ -690,8 +689,8 @@ in print ("HOLDIR = "^HOLDIR^"\n"); print ("POLYMLLIBDIR = "^POLYMLLIBDIR^"\n"); print ("Targets = [" ^ String.concatWith ", " targets ^ "]\n"); - print ("Additional includes = " ^ String.concatWith ", " additional_includes ^ - "]\n"); + print ("Additional includes = [" ^ + String.concatWith ", " additional_includes ^ "]\n"); print ("Using HOL sigobj dir = "^Bool.toString (not no_sigobj) ^"\n") end else () @@ -1121,25 +1120,26 @@ fun add_sigobj {includes,preincludes} = {includes = std_include_flags @ includes, preincludes = preincludes} -val dirinfo = let - val f = make_best_relative{relpath=dirnm,absdir=dir} -in +val dirinfo = {visited = visiteddirs, - includes = map f allincludes, - preincludes = map f hmake_preincludes} -end + includes = allincludes, + preincludes = hmake_preincludes} val purelocal_incinfo = add_sigobj {includes = allincludes, preincludes = hmake_preincludes} -fun hm_recur ctgt k = - maybe_recurse - {warn = warn, - diag = diag, - no_prereqs = no_prereqs, hm = Holmake, - dirinfo = dirinfo, - dir = {abspath = dir, relpath = dirnm}, - local_build = k, cleantgt = ctgt} +fun hm_recur ctgt k = let + fun hm {dir, visited, targets} = + Holmake {dir = dir, visited = visited} [] targets +in + maybe_recurse + {warn = warn, + diag = diag, + no_prereqs = no_prereqs, hm = hm, + dirinfo = dirinfo, + dir = dir, + local_build = k, cleantgt = ctgt} +end fun stdcont tgts ii = finish_logging (strategy (add_sigobj ii) tgts) @@ -1164,10 +1164,13 @@ in | xs => let fun isPhony x = member x ["clean", "cleanDeps", "cleanAll"] orelse x in_target ".PHONY" + fun canon i = hmdir.extendp {base = dir, extension = i} in if List.all isPhony xs andalso not cline_recursive then if finish_logging (strategy purelocal_incinfo xs) then - SOME dirinfo + SOME {visited = visiteddirs, + includes = map canon allincludes, + preincludes = map canon hmake_preincludes} else NONE else let @@ -1215,9 +1218,8 @@ in else let open OS.Process val result = - Holmake {relpath = SOME (OS.Path.currentArc), - abspath = OS.FileSys.getDir(), - visited = Binaryset.empty String.compare} + Holmake {dir = hmdir.curdir(), + visited = Binaryset.empty hmdir.compare} cline_additional_includes targets handle Fail s => (print ("Fail exception: "^s^"\n"); diff --git a/tools/Holmake/Holmake.sml b/tools/Holmake/Holmake.sml index 0c321e9ea2..990f6c9af4 100644 --- a/tools/Holmake/Holmake.sml +++ b/tools/Holmake/Holmake.sml @@ -319,9 +319,9 @@ in end (* directory specific stuff here *) -fun Holmake dirinfo cline_additional_includes targets : holmake_result = let - val {abspath=dir,relpath=dirnm, visited = visiteddirs} = dirinfo - val _ = OS.FileSys.chDir dir +fun Holmake dirinfo cline_additional_includes targets : hmdir.t holmake_result = let + val {dir,visited = visiteddirs} = dirinfo + val _ = OS.FileSys.chDir (hmdir.toAbsPath dir) (* prepare to do logging *) @@ -961,22 +961,21 @@ fun add_sigobj {includes,preincludes} = {includes = std_include_flags @ includes, preincludes = preincludes} -val dirinfo = let - val f = make_best_relative{relpath=dirnm,absdir=dir} -in +val dirinfo = {visited = visiteddirs, - includes = map f allincludes, - preincludes = map f hmake_preincludes} -end + includes = allincludes, + preincludes = hmake_preincludes} -fun hm_recur ctgt k : holmake_result = - maybe_recurse - {warn = warn, - diag = diag, - no_prereqs = no_prereqs, hm = Holmake, - dirinfo = dirinfo, - dir = {abspath = dir, relpath = dirnm}, - local_build = k, cleantgt = ctgt} +fun hm_recur ctgt k : hmdir.t holmake_result = let + fun hm {dir, visited, targets} = + Holmake {dir = dir, visited = visited} [] targets +in + maybe_recurse + {warn = warn, diag = diag, + no_prereqs = no_prereqs, hm = hm, + dirinfo = dirinfo, dir = dir, + local_build = k, cleantgt = ctgt} +end fun stdcont tgts ii = finish_logging (strategy (add_sigobj ii) tgts) @@ -1005,9 +1004,13 @@ in | xs => let fun isPhony x = member x ["clean", "cleanDeps", "cleanAll"] orelse x in_target ".PHONY" + fun canon i = hmdir.extendp {base = dir, extension = i} in if List.all isPhony xs andalso not cline_recursive then - if finish_logging (strategy purelocal_includes xs) then SOME dirinfo + if finish_logging (strategy purelocal_includes xs) then + SOME {visited = visiteddirs, + includes = map canon allincludes, + preincludes = map canon hmake_preincludes} else NONE else let @@ -1053,13 +1056,13 @@ val _ = else let open Process val result = - Holmake {relpath = SOME (OS.Path.currentArc), - abspath = OS.FileSys.getDir(), - visited = Binaryset.empty String.compare} - cline_additional_includes - targets - handle Fail s => (print ("Fail exception: "^s^"\n"); - exit failure) + Holmake + {dir = hmdir.curdir(), + visited = Binaryset.empty hmdir.compare} + cline_additional_includes + targets + handle Fail s => (print ("Fail exception: "^s^"\n"); + exit failure) in if isSome result then exit success else exit failure diff --git a/tools/Holmake/Holmake_tools.sig b/tools/Holmake/Holmake_tools.sig index 40e2832f55..37174994ca 100644 --- a/tools/Holmake/Holmake_tools.sig +++ b/tools/Holmake/Holmake_tools.sig @@ -48,27 +48,37 @@ sig val clean_dir : {extra_cleans: string list} -> unit val clean_depdir : {depdirname : string} -> bool - val make_best_relative : - {relpath : string option, absdir : string} -> string -> string + structure hmdir : sig + type t + val extendp : {base : t, extension : string} -> t + val extend : {base : t, extension : t} -> t + val toString : t -> string + val toAbsPath : t -> string + val fromPath : {origin: string, path : string} -> t + val sort : t list -> t list + val curdir : unit -> t + val compare : t * t -> order + end type include_info = {includes : string list, preincludes : string list} - type holmake_dirinfo = {visited : string Binaryset.set, - includes : string list, - preincludes : string list } - type holmake_result = holmake_dirinfo option + type 'dir holmake_dirinfo = {visited : hmdir.t Binaryset.set, + includes : 'dir list, + preincludes : 'dir list} + type 'dir holmake_result = 'dir holmake_dirinfo option val maybe_recurse : {warn: string -> unit, diag : string -> unit, no_prereqs : bool, - hm: {relpath : string option, abspath : string, - visited : string Binaryset.set} -> - string list -> string list -> holmake_result, - dirinfo : holmake_dirinfo, - dir : {abspath: string, relpath: string option}, + hm: {dir : hmdir.t, + visited : hmdir.t Binaryset.set, + targets : string list} -> + hmdir.t holmake_result, + dirinfo : string holmake_dirinfo, + dir : hmdir.t, local_build : include_info -> bool, cleantgt : string option} -> - holmake_result + hmdir.t holmake_result val holdep_arg : File -> File option diff --git a/tools/Holmake/Holmake_tools.sml b/tools/Holmake/Holmake_tools.sml index 5dfbd2a2be..67bf71037a 100644 --- a/tools/Holmake/Holmake_tools.sml +++ b/tools/Holmake/Holmake_tools.sml @@ -288,92 +288,166 @@ val terminal_log = if Systeml.isUnix then xterm_log else (fn s => ()) -fun make_best_relative {relpath, absdir} extension = - if Path.isAbsolute extension then extension +structure hmdir = +struct + +type t = {absdir : string, relpath : string option} + +fun op+ (d, e) = Path.mkCanonical (Path.concat(d, e)) + +fun curdir () = {relpath = SOME (OS.Path.currentArc), + absdir = OS.FileSys.getDir()} + +fun compare ({absdir = d1, ...} : t, {absdir = d2, ...} : t) = + String.compare (d1, d2) + +fun toString {relpath,absdir} = + case relpath of + NONE => absdir + | SOME p => p + +fun toAbsPath {relpath,absdir} = absdir + +fun fromPath {origin,path} = + if Path.isAbsolute path then {relpath = NONE, absdir = path} else + {relpath = SOME path, absdir = origin + path} + +fun extendp {base = {relpath, absdir}, extension} = let + val relpath_str = case relpath of NONE => "NONE" + | SOME s => "SOME("^s^")" +in + if Path.isAbsolute extension then {relpath = NONE, absdir = extension} + else case relpath of - NONE => Path.mkCanonical (Path.concat(absdir, extension)) - | SOME p => Path.mkCanonical (Path.concat(p, extension)) + NONE => {absdir = absdir + extension, relpath = NONE} + | SOME p => {relpath = SOME (p + extension), + absdir = absdir + extension} +end + +fun extend {base, extension} = + extendp {base = base, extension = toString extension} + +fun sort l = let + fun foldthis1 ({absdir,relpath}, acc) = + case Binarymap.peek (acc, absdir) of + NONE => Binarymap.insert(acc, absdir, relpath) + | SOME NONE => Binarymap.insert(acc, absdir, relpath) + | _ => acc + val m = foldl foldthis1 (Binarymap.mkDict String.compare) l + fun foldthis2 (abs,rel,acc) = {absdir = abs, relpath = rel} :: acc +in + Binarymap.foldr foldthis2 [] m +end + +end (* hmdir struct *) type include_info = {includes : string list, preincludes : string list } -type holmake_dirinfo = {visited : string Binaryset.set, includes : string list, - preincludes : string list } -type holmake_result = holmake_dirinfo option - -(* this function doesn't handle all recursion, just one level's worth. In - other words, the master Holmake calls this function, and this then arranges the - recursive calls into the various include directories that need to happen. - The holmake that gets called in those directories will in turn call this function for - recursion at that level in the "tree" -*) +type 'dir holmake_dirinfo = {visited : hmdir.t Binaryset.set, includes : 'dir list, + preincludes : 'dir list} +type 'dir holmake_result = 'dir holmake_dirinfo option + +(* ---------------------------------------------------------------------- + + maybe_recurse + + this function doesn't handle all recursion, just one level's + worth. In other words, the master Holmake calls this function, and + this then arranges the recursive calls into the various include + directories that need to happen. The holmake that gets called in + those directories (via the hm parameter) will in turn call this + function for recursion at that level in the "tree". + + The local_build/k parameter is how the maybe_recurse function + finishes off; this parameter is called when all of the necessary + recursion has been performed and work should be done in the + current ("local") directory. + + Finally, what of the dirinfo? + + This record includes + origin: the absolute path to the very first directory + includes: the includes that the local directory knows about + (which will have come from the command-line or + INCLUDES lines in the local Holmakefile + preincludes: similarly + visited: a set of visited directories (with directories + expressed as absolute paths) + + The includes and preincludes are clearly useful when it comes time to + do any local work, but also specify how the recursion is to happen. + + Now, the recursion into those directories may result in extra + includes and preincludes. + ---------------------------------------------------------------------- *) fun maybe_recurse {warn,diag,no_prereqs,hm,dirinfo,dir,local_build=k,cleantgt} = let - val {abspath=dir,relpath} = dir val {includes,preincludes,visited} = dirinfo - val k = fn ii => (terminal_log ("Holmake: "^nice_dir dir); k ii) + val _ = diag ("maybe_recurse: includes = [" ^ + String.concatWith ", " includes ^ "]") + val _ = diag ("maybe_recurse: preincludes = [" ^ + String.concatWith ", " preincludes ^ "]") + val k = fn ii => (terminal_log ("Holmake: "^nice_dir (hmdir.toString dir)); + k ii) val tgts = case cleantgt of SOME s => [s] | NONE => [] - fun recurse acc (newdir,nm) = let - val {visited, includes, preincludes} = acc + fun recurse (acc as {visited,includes,preincludes}) newdir = let in if Binaryset.member(visited, newdir) then SOME acc else let - val newrelpath = - if Path.isAbsolute nm then NONE - else - case relpath of - NONE => NONE - | SOME d => SOME (Path.mkCanonical (Path.concat(d, nm))) - val nm = case newrelpath of NONE => newdir | SOME d => d - val _ = warn ("Recursively calling Holmake in "^nm) - val _ = terminal_log ("Holmake: "^nice_dir nm) + val _ = warn ("Recursively calling Holmake in " ^ hmdir.toString newdir) + val _ = terminal_log ("Holmake: "^nice_dir (hmdir.toString newdir)) val result = - case hm {relpath=newrelpath,abspath=newdir,visited=visited} [] tgts - of + case hm {dir = newdir, visited = visited, targets = tgts} of NONE => NONE | SOME {visited,includes = inc0, preincludes = pre0} => - SOME{visited = visited, includes = includes @ inc0, - preincludes = preincludes @ pre0} + SOME {visited = visited, + includes = hmdir.sort (includes @ inc0), + preincludes = hmdir.sort (preincludes @ pre0)} in - warn ("Finished recursive invocation in "^nm); - terminal_log ("Holmake: "^nice_dir dir); - FileSys.chDir dir; + warn ("Finished recursive invocation in "^hmdir.toString newdir); + terminal_log ("Holmake: "^nice_dir (hmdir.toString dir)); + FileSys.chDir (hmdir.toAbsPath dir); case result of SOME{includes=incs,preincludes=pre,...} => (diag ("Recursively computed includes = " ^ - String.concatWith ", " incs); + String.concatWith ", " (map hmdir.toString incs)); diag ("Recursively computed pre-includes = " ^ - String.concatWith ", " pre)) + String.concatWith ", " (map hmdir.toString pre))) | NONE => (); result end end - fun do_em (accg as {includes,preincludes,...}) [] = - if k {includes=includes,preincludes=preincludes} then SOME accg - else NONE - | do_em accg (x::xs) = let - in - case recurse accg x of - SOME result => do_em result xs - | NONE => NONE - end + fun do_em (accg as {includes,preincludes,...}) dirs = + case dirs of + [] => + let + val f = map hmdir.toAbsPath + in + if k {includes=f includes,preincludes=f preincludes} then SOME accg + else NONE + end + | x::xs => + let + in + case recurse accg x of + SOME result => do_em result xs + | NONE => NONE + end val visited = Binaryset.add(visited, dir) + fun canon i = hmdir.extendp {base = dir, extension = i} + val canonl = map canon in if no_prereqs then if k {includes = #includes dirinfo, preincludes = #preincludes dirinfo} then - SOME dirinfo + SOME {visited = visited, includes = map canon includes, + preincludes = map canon preincludes} else NONE else let - fun foldthis (dir, m) = - Binarymap.insert(m, FileSys.fullPath dir, dir) - handle OS.SysErr _ => - (warn ("Includes path "^dir^" looks bogus"); - m) - val possible_calls = List.foldr foldthis - (Binarymap.mkDict String.compare) - (preincludes @ includes) + fun f idirs = map canon idirs + val possible_calls = hmdir.sort (f (preincludes @ includes)) in - do_em {visited = visited, includes = includes, preincludes = preincludes} - (Binarymap.listItems possible_calls) + do_em {visited = visited, includes = f includes, preincludes = f preincludes} + possible_calls end end From 7781cbdcfa94ab3467a1f243cfcc2259eef86ace Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 23 Feb 2015 16:49:28 +1100 Subject: [PATCH 197/718] Delete some unused code in tools-poly/Holmake/Holmake.sml --- tools-poly/Holmake/Holmake.sml | 21 --------------------- 1 file changed, 21 deletions(-) diff --git a/tools-poly/Holmake/Holmake.sml b/tools-poly/Holmake/Holmake.sml index fc7b22274e..1134e1992c 100644 --- a/tools-poly/Holmake/Holmake.sml +++ b/tools-poly/Holmake/Holmake.sml @@ -35,17 +35,6 @@ val SYSTEML = Systeml.systeml Support for handling the preprocessing of files containing `` ---------------------------------------------------------------------------*) -fun variant str = (* get an unused file name in the current directory *) - if OS.FileSys.access(str,[]) - then let fun vary i = - let val s = str^Int.toString i - in if OS.FileSys.access(s,[]) then vary (i+1) else s - end - in vary 0 - end - else str; - - fun fromFileNoSuf f = case f of UO c => codeToString c @@ -85,11 +74,6 @@ end (** Command line parsing *) (*** list functions *) -fun butlast0 _ [] = raise Fail "butlast - empty list" - | butlast0 acc [x] = List.rev acc - | butlast0 acc (h::t) = butlast0 (h::acc) t -fun butlast l = butlast0 [] l - fun member m [] = false | member m (x::xs) = if x = m then true else member m xs fun set_union s1 s2 = @@ -105,14 +89,9 @@ fun delete m [] = [] fun set_diff s1 s2 = foldl (fn (s2e, s1') => delete s2e s1') s1 s2 fun remove_duplicates [] = [] | remove_duplicates (x::xs) = x::(remove_duplicates (delete x xs)) -fun alltrue [] = true - | alltrue (x::xs) = x andalso alltrue xs fun I x = x (*** parse command line *) -fun includify [] = [] - | includify (h::t) = "-I" :: h :: includify t - fun parse_command_line list = let fun find_pairs0 tag rem inc [] = (List.rev rem, List.rev inc) | find_pairs0 tag rem inc [x] = (List.rev (x::rem), List.rev inc) From 9a5d60914990120bb864803ac863b9f7aa9b84b9 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 25 Feb 2015 16:41:17 +1100 Subject: [PATCH 198/718] Make Holmake follow INCLUDES recursively, even when given PHONY target Closes #145 --- doc/next-release.md | 2 ++ tools-poly/Holmake/Holmake.sml | 13 ++++--------- tools/Holmake/Holmake.sml | 13 ++++--------- 3 files changed, 10 insertions(+), 18 deletions(-) diff --git a/doc/next-release.md b/doc/next-release.md index 47bb4237d7..5990a85e6b 100644 --- a/doc/next-release.md +++ b/doc/next-release.md @@ -27,6 +27,8 @@ Bugs fixed: - Theorems can now have names that are the same as SML constructor names (*e.g.*, `Empty`). ([Github issue](http://github.com/HOL-Theorem-Prover/HOL/issues/225)) +- `Holmake` will now follow `INCLUDES` specifications from `Holmakefiles` when given “phony” targets to build on the command-line. (A typical phony target is `all`.) As in the past, it will still act only locally if given just a clean target (`clean`, `cleanDeps` or `cleanAll`). To clean recursively, you must also pass the `-r` flag to `Holmake`. ([Github issue](http://github.com/HOL-Theorem-Prover/HOL/issues/145)) + New theories: ------------- diff --git a/tools-poly/Holmake/Holmake.sml b/tools-poly/Holmake/Holmake.sml index 1134e1992c..d541654163 100644 --- a/tools-poly/Holmake/Holmake.sml +++ b/tools-poly/Holmake/Holmake.sml @@ -1141,23 +1141,18 @@ in hm_recur NONE (stdcont targets) end | xs => let - fun isPhony x = member x ["clean", "cleanDeps", "cleanAll"] orelse - x in_target ".PHONY" + val cleanTarget_opt = + List.find (fn x => member x ["clean", "cleanDeps", "cleanAll"]) xs fun canon i = hmdir.extendp {base = dir, extension = i} in - if List.all isPhony xs andalso not cline_recursive then + if isSome cleanTarget_opt andalso not cline_recursive then if finish_logging (strategy purelocal_incinfo xs) then SOME {visited = visiteddirs, includes = map canon allincludes, preincludes = map canon hmake_preincludes} else NONE else - let - val ctgt = - List.find (fn s => member s ["clean", "cleanDeps", "cleanAll"]) xs - in - hm_recur ctgt (stdcont xs) - end + hm_recur cleanTarget_opt (stdcont xs) end end diff --git a/tools/Holmake/Holmake.sml b/tools/Holmake/Holmake.sml index 990f6c9af4..4ba6f32955 100644 --- a/tools/Holmake/Holmake.sml +++ b/tools/Holmake/Holmake.sml @@ -1002,23 +1002,18 @@ in hm_recur NONE (stdcont targets) end | xs => let - fun isPhony x = member x ["clean", "cleanDeps", "cleanAll"] orelse - x in_target ".PHONY" + val cleanTarget_opt = + List.find (fn x => member x ["clean", "cleanDeps", "cleanAll"]) xs fun canon i = hmdir.extendp {base = dir, extension = i} in - if List.all isPhony xs andalso not cline_recursive then + if isSome cleanTarget_opt andalso not cline_recursive then if finish_logging (strategy purelocal_includes xs) then SOME {visited = visiteddirs, includes = map canon allincludes, preincludes = map canon hmake_preincludes} else NONE else - let - val ctgt = - List.find (fn s => member s ["clean", "cleanDeps", "cleanAll"]) xs - in - hm_recur ctgt (stdcont xs) - end + hm_recur cleanTarget_opt (stdcont xs) end end From c494dbc28dce3b6a5cbfd7a996b5bb41320542ab Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 25 Feb 2015 16:44:18 +1100 Subject: [PATCH 199/718] Properly sort list of Holmake's commandline options in Description --- Manual/Description/misc.tex | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/Manual/Description/misc.tex b/Manual/Description/misc.tex index 07761ffb7b..bab708fd50 100644 --- a/Manual/Description/misc.tex +++ b/Manual/Description/misc.tex @@ -310,11 +310,6 @@ \subsection{\holmake{}'s command-line arguments} \noindent Finally, users can directly affect the workings of \holmake{} with the following command-line options: \begin{description} -\item[\tt -I ] Look in specified directory for additional - Moscow~ML object files, including other HOL theories. This option - can be repeated, with multiple {\tt -I}'s to allow for multiple - directories to be referenced. As above, directories specified in - this way will also be rebuilt before the current targets are built. \item[\tt -d ] Ignore the given file and don't try to build it. The file may be rebuilt anyway if other files you have specified depend on it. This is useful to stop Holmake from attempting to @@ -327,9 +322,6 @@ \subsection{\holmake{}'s command-line arguments} \texttt{fast\_proof} oracle tag. This tag will appear on all theorems proved in this way and all subsequent theorems that depend on such theorems. \holmake's default is not to build in fast mode. -\item[\texttt{-r}]% -\index{Holmake@\holmake!recursive invocation}% -Forces \holmake{} to behave recursively, overriding the \texttt{--no\_prereqs} option, and also causing \holmake{} to clean recursively in the ``includes'' directories (which is not done otherwise). \item[\texttt{--fast}] Makes \holmake's default be to build in fast mode (see above). \item[{\tt --help} or {\tt -h}] Prints out a useful option summary and @@ -339,6 +331,11 @@ \subsection{\holmake{}'s command-line arguments} configured to use by default. \item[\tt --holmakefile ] Use the given file as a make-file. See section~\ref{sec:using-Holmakefiles} below for more on this. +\item[\tt -I ] Look in specified directory for additional + Moscow~ML object files, including other HOL theories. This option + can be repeated, with multiple {\tt -I}'s to allow for multiple + directories to be referenced. As above, directories specified in + this way will also be rebuilt before the current targets are built. \item[\texttt{--interactive} or \texttt{-i}] Causes the HOL code that runs when a theory building file is executed to have the flag \texttt{Globals.interactive} set to true. This will alter the diagnostic @@ -383,6 +380,9 @@ \subsection{\holmake{}'s command-line arguments} \holmake{}. Fatal error messages will still be written to the standard error stream. Note that other programs called by \holmake{} will not be affected. +\item[\texttt{-r}]% +\index{Holmake@\holmake!recursive invocation}% +Forces \holmake{} to behave recursively, overriding the \texttt{--no\_prereqs} option, and also causing \holmake{} to clean recursively in the ``includes'' directories (which is not done otherwise). \item[{\tt --rebuild\_deps}] Forces \holmake{} to always rebuild the dependency information for files it examines, whether or not it thinks it needs to. This option is implemented by having From 432af5c8320d7b0f2f25398c311c7de6078de564 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 25 Feb 2015 16:48:44 +1100 Subject: [PATCH 200/718] Remove some language insinuating that HOL uses only Moscow ML --- Manual/Description/misc.tex | 21 +++++++++------------ 1 file changed, 9 insertions(+), 12 deletions(-) diff --git a/Manual/Description/misc.tex b/Manual/Description/misc.tex index bab708fd50..7d40d6bd6a 100644 --- a/Manual/Description/misc.tex +++ b/Manual/Description/misc.tex @@ -331,11 +331,10 @@ \subsection{\holmake{}'s command-line arguments} configured to use by default. \item[\tt --holmakefile ] Use the given file as a make-file. See section~\ref{sec:using-Holmakefiles} below for more on this. -\item[\tt -I ] Look in specified directory for additional - Moscow~ML object files, including other HOL theories. This option - can be repeated, with multiple {\tt -I}'s to allow for multiple - directories to be referenced. As above, directories specified in - this way will also be rebuilt before the current targets are built. +\item[\tt -I ] + Look in specified directory for additional object files, including other HOL theories. + This option can be repeated, with multiple {\tt -I}'s to allow for multiple directories to be referenced. + As above, directories specified in this way will also be rebuilt before the current targets are built. \item[\texttt{--interactive} or \texttt{-i}] Causes the HOL code that runs when a theory building file is executed to have the flag \texttt{Globals.interactive} set to true. This will alter the diagnostic @@ -363,13 +362,11 @@ \subsection{\holmake{}'s command-line arguments} \item[\texttt{--no\_prereqs}]% \index{Holmake@\holmake!recursive invocation}% Do not recursively attempt to build ``include'' directories before working in the current directory. -\item[\texttt{--no\_sigobj}] Do not link against HOL system's - directory of HOL system files. Use of this option goes some way - towards turning - \holmake{} into a general Moscow~ML \textsf{make} system. However, - it will still attempt to do ``HOL things'' with files whose names - end in \texttt{Script} and \texttt{Theory}. This option implies - \texttt{--no\_overlay}. +\item[\texttt{--no\_sigobj}] + Do not link against \HOL{} system's directory of \HOL{} system files. + Use of this option goes some way towards turning \holmake{} into a general \ML{} \textsf{make} system. + However, it will still attempt to do ``\HOL{} things'' with files whose names end in \texttt{Script} and \texttt{Theory}. + This option implies \texttt{--no\_overlay}. \item[\texttt{--overlay }] Use the given file as the overlay rather than the default. \item[\texttt{--qof}] Standing for ``quit on failure''. If a tactic From e70fe82997cd24c9b7f3f131e2c11250d33edac4 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Thu, 26 Feb 2015 11:47:33 +1100 Subject: [PATCH 201/718] UNDISCH_TM, which also returns the term made an assumption --- help/Docfiles/Drule.UNDISCH.doc | 4 +++- help/Docfiles/Drule.UNDISCH_TM.doc | 35 ++++++++++++++++++++++++++++++ src/1/Drule.sig | 1 + src/1/Drule.sml | 5 +++++ 4 files changed, 44 insertions(+), 1 deletion(-) create mode 100644 help/Docfiles/Drule.UNDISCH_TM.doc diff --git a/help/Docfiles/Drule.UNDISCH.doc b/help/Docfiles/Drule.UNDISCH.doc index 645854edc5..e5018d5f14 100644 --- a/help/Docfiles/Drule.UNDISCH.doc +++ b/help/Docfiles/Drule.UNDISCH.doc @@ -24,6 +24,8 @@ If the antecedent already appears in (or is alpha-equivalent to one of) the hypotheses, it will not be duplicated. \SEEALSO -Thm.DISCH, Drule.DISCH_ALL, Tactic.DISCH_TAC, Thm_cont.DISCH_THEN, Tactic.FILTER_DISCH_TAC, Thm_cont.FILTER_DISCH_THEN, Drule.NEG_DISCH, Tactic.STRIP_TAC, Drule.UNDISCH_ALL, Tactic.UNDISCH_TAC. +Thm.DISCH, Drule.DISCH_ALL, Tactic.DISCH_TAC, Thm_cont.DISCH_THEN, +Tactic.FILTER_DISCH_TAC, Thm_cont.FILTER_DISCH_THEN, Drule.NEG_DISCH, +Tactic.STRIP_TAC, Drule.UNDISCH_ALL, Drule.UNDISCH_TM, Tactic.UNDISCH_TAC. \ENDDOC diff --git a/help/Docfiles/Drule.UNDISCH_TM.doc b/help/Docfiles/Drule.UNDISCH_TM.doc new file mode 100644 index 0000000000..4668d6ede5 --- /dev/null +++ b/help/Docfiles/Drule.UNDISCH_TM.doc @@ -0,0 +1,35 @@ +\DOC UNDISCH_TM + +\TYPE {UNDISCH_TM : thm -> term * thm} + +\SYNOPSIS +Undischarges the antecedent of an implicative theorem, +also returning that antecedent. + +\KEYWORDS +rule, undischarge, antecedent. + +\DESCRIBE +{ + A |- t1 ==> t2 + ---------------- UNDISCH_TM + A, t1 |- t2 +} +Note that {UNDISCH_TM} treats {"~u"} as {"u ==> F"}. + +\FAILURE +{UNDISCH_TM} will fail on theorems which are not implications or negations. + +\COMMENTS +If the antecedent already appears in (or is alpha-equivalent to one of) the +hypotheses, it will not be duplicated. + +{UNDISCH_TM} is similar to {UNDISCH} except that it also returns the antecedent +concerned, which may be useful, for example, when the new assumption +is subsequently to be discharged + +\SEEALSO +Drule.UNDISCH, Thm.DISCH. + +\ENDDOC + diff --git a/src/1/Drule.sig b/src/1/Drule.sig index e36bce12e3..05ea64f152 100644 --- a/src/1/Drule.sig +++ b/src/1/Drule.sig @@ -19,6 +19,7 @@ sig val IMP_ANTISYM_RULE : thm -> thm -> thm val CONTR : term -> thm -> thm val UNDISCH : thm -> thm + val UNDISCH_TM : thm -> term * thm val EQT_ELIM : thm -> thm val SPECL : term list -> thm -> thm val SELECT_INTRO : thm -> thm diff --git a/src/1/Drule.sml b/src/1/Drule.sml index fd3b9197e2..be5b063aed 100644 --- a/src/1/Drule.sml +++ b/src/1/Drule.sml @@ -270,6 +270,11 @@ fun UNDISCH th = MP th (ASSUME (fst (dest_imp (concl th)))) handle HOL_ERR _ => raise ERR "UNDISCH" "" +fun UNDISCH_TM th = + let val (ant, conseq) = dest_imp (concl th) ; + in (ant, MP th (ASSUME ant)) end + handle HOL_ERR _ => raise ERR "UNDISCH_TM" "" + (*---------------------------------------------------------------------------* * =T elimination * * * From 29e101bac684af67765b36e086e2fe846306f011 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Thu, 26 Feb 2015 14:07:58 +1100 Subject: [PATCH 202/718] Drule.EXISTS_LEFT, Drule.EXISTS_LEFT1 added to existentially quantify hypotheses in a theorem --- help/Docfiles/Drule.EXISTS_LEFT.doc | 59 ++++++++++++++++++++++++ help/Docfiles/Drule.EXISTS_LEFT1.doc | 46 +++++++++++++++++++ src/1/Drule.sig | 2 + src/1/Drule.sml | 68 ++++++++++++++++++++++++++++ 4 files changed, 175 insertions(+) create mode 100644 help/Docfiles/Drule.EXISTS_LEFT.doc create mode 100644 help/Docfiles/Drule.EXISTS_LEFT1.doc diff --git a/help/Docfiles/Drule.EXISTS_LEFT.doc b/help/Docfiles/Drule.EXISTS_LEFT.doc new file mode 100644 index 0000000000..97de29b4b9 --- /dev/null +++ b/help/Docfiles/Drule.EXISTS_LEFT.doc @@ -0,0 +1,59 @@ +\DOC EXISTS_LEFT + +\TYPE {EXISTS_LEFT : term list -> thm -> thm} + +\SYNOPSIS +Existentially quantifes hypotheses of a theorem. + +\KEYWORDS +existential, assumption, hypothesis + +\DESCRIBE +In this example, assume that {h1} and {h3} (only) involve the free variable {x}. +{ + h1, h2, h3 |- t + --------------------- EXISTS_LEFT [``x``] + ?x. h1 /\ h3, h2 |- t +} + +\FAILURE +{EXISTS_LEFT} will fail if the term list supplied does not consist only of free +variables + +\EXAMPLE +Where {th} is {[p, q, g x, h y, f x y] |- r}, and {fvx} and {fvy} are +{``x``} and {``y``}, + +{EXISTS_LEFT [fvx, fvy] th} is {[p, q, ?y. (?x. g x /\ f x y) /\ h y] |- r} + +{EXISTS_LEFT [fvy, fvx] th} is {[p, q, ?x. (?y. h y /\ f x y) /\ g x] |- r} + +\USES +Where {EQ_TRANS} is +{[] |- !x y z. (x = y) /\ (y = z) ==> (x = z)} +and the current goal is {a = b}, +the tactic {MATCH_MP_TAC EQ_TRANS} gives a new goal +{?y. (a = y) /\ (y = b)} +by virtue of the smart features built into {MATCH_MP_TAC}. + +Where {trans_thm} is +{[] |- !x y z. (x = y) ==> (y = z) ==> (x = z)} +the same result could of course be achieved by rewriting it with +{AND_IMP_INTRO}. +But more generally, {EXISTS_LEFT} could be used as a building-block for a more +flexible tactic. +In this instance, one might start with +{ +val trans_thm_h = UNDISCH_ALL (SPEC_ALL trans_thm) ; +EXISTS_LEFT (thm_frees trans_thm_h) trans_thm_h ; +} +giving {[?y. (x = y) /\ (y = z)] |- x = z} + +\SEEALSO +Drule.EXISTS_LEFT1, Thm.CHOOSE, Thm.EXISTS, Tactic.CHOOSE_TAC, Tactic.EXISTS_TAC + +\ENDDOC + + + + diff --git a/help/Docfiles/Drule.EXISTS_LEFT1.doc b/help/Docfiles/Drule.EXISTS_LEFT1.doc new file mode 100644 index 0000000000..c0dddf72ab --- /dev/null +++ b/help/Docfiles/Drule.EXISTS_LEFT1.doc @@ -0,0 +1,46 @@ +\DOC EXISTS_LEFT1 + +\TYPE {EXISTS_LEFT1 : term -> thm -> thm} + +\SYNOPSIS +Existentially quantifes hypotheses of a theorem. + +\KEYWORDS +existential, assumption, hypothesis + +\DESCRIBE +In this example, assume that {h1} and {h3} (only) involve the free variable {x}. +{ + h1, h2, h3 |- t + --------------------- EXISTS_LEFT1 ``x`` + ?x. h1 /\ h3, h2 |- t +} + +\FAILURE +{EXISTS_LEFT1} will fail unless the term supplied is a free variable +which appears in one or more hypotheses but not the conclusion of the given +theorem + +\EXAMPLE +Where {th} is {[p, q, g x, h y, f x y] |- r}, and {fvx} and {fvy} are +{``x``} and {``y``}, + +{EXISTS_LEFT1 fvx th} is {[p, q, h y, ?x. g x /\ f x y] |- r} + +{EXISTS_LEFT1 fvy th} is {[p, q, g x, ?y. h y /\ f x y] |- r} + +\COMMENTS +{EXISTS_LEFT1 fv} is just like {EXISTS_LEFT [fv]} except that +{EXISTS_LEFT1 fv} fails where {EXISTS_LEFT [fv]} returns the theorem unchanged + +See {EXISTS_LEFT} for further discussion + + +\SEEALSO +Drule.EXISTS_LEFT, Thm.CHOOSE, Thm.EXISTS, Tactic.CHOOSE_TAC, Tactic.EXISTS_TAC + +\ENDDOC + + + + diff --git a/src/1/Drule.sig b/src/1/Drule.sig index 05ea64f152..81b8f8e844 100644 --- a/src/1/Drule.sig +++ b/src/1/Drule.sig @@ -10,6 +10,8 @@ sig val LIST_MK_EXISTS : term list -> thm -> thm val SIMPLE_EXISTS : term -> thm -> thm val SIMPLE_CHOOSE : term -> thm -> thm + val EXISTS_LEFT : term list -> thm -> thm + val EXISTS_LEFT1 : term -> thm -> thm val EQT_INTRO : thm -> thm val GSUBS : ((term,term)subst -> term -> term) -> thm list -> thm -> thm diff --git a/src/1/Drule.sml b/src/1/Drule.sml index be5b063aed..91286a2fef 100644 --- a/src/1/Drule.sml +++ b/src/1/Drule.sml @@ -1229,6 +1229,74 @@ fun PART_MATCH partfn th = fn tm => INST_TY_TERM (matchfn tm) th end +(* --------------------------------------------------------------------------* + EXISTS_LEFT, EXISTS_LEFT1 + existentially quantifying variables which appear only in the hypotheses + + [x = y, y = z] |- x = z + (eg) -------------------------------- EXISTS_LEFT1 ``y`` + [∃y. (x = y) ∧ (y = z)] |- x = z + + * --------------------------------------------------------------------------*) + +(* EXISTS_LEFT' : bool -> + term list -> {fvs: term list, hyp: term} list -> term list -> thm -> thm + used below, saves hyps, their free vars, and free vars of conclusion, + across recursive calls + arg1 - whether to ignore errors, ie, free vars which are either in the + conclusion or not in any hypothesis + arg2 - list of free vars in the conclusion + arg3 - list of assumptions of the theorem, each with the list of free vars + which it contains + arg4 - list of free vars to become existentially quantified +*) + +fun EXISTS_LEFT' strict fvs_c hfvs [] th = th + | EXISTS_LEFT' strict fvs_c hfvs (fv :: fvs) th = + let + val _ = if is_var fv then () + else raise mk_HOL_ERR "Drule" "EXISTS_LEFT'" "not free variable" ; + (* following raises Bind if fv in conclusion *) + val false = List.exists (Lib.equal fv) fvs_c ; + fun hyp_ctns_fv {hyp, fvs} = List.exists (Lib.equal fv) fvs ; + (* following raises Bind if fv not in any hypothesis *) + val (hyps_ctg_fv as _ :: _, hyps_nc) = List.partition hyp_ctns_fv hfvs ; + val conj_tm = list_mk_conj (map #hyp hyps_ctg_fv) ; + val conj_th = ASSUME conj_tm ; + (* CONJ_LIST gives original hyps, even if they are conjunctions *) + val sep_ths = CONJ_LIST (length hyps_ctg_fv) conj_th ; + val th2 = Lib.itlist PROVE_HYP sep_ths th ; + val ex_conj_tm = mk_exists (fv, conj_tm) ; + val ex_conj_th = ASSUME ex_conj_tm ; + val the = CHOOSE (fv, ex_conj_th) th2 ; + val thex = EXISTS_LEFT' strict fvs_c + ({hyp = ex_conj_tm, fvs = free_vars ex_conj_tm} :: hyps_nc) fvs the ; + in thex end + handle exn => if strict then raise + raise mk_HOL_ERR "Drule" "EXISTS_LEFT'" + "free variable in conclusion or not in any hypothesis" + else EXISTS_LEFT' strict fvs_c hfvs fvs th ; + +(* EXISTS_LEFT : term list -> thm -> thm + for each free var in turn, do the following: + replace hyps containing the free var by their conjunction, + existentially quantified over the free var; + ignore free vars for which this can't be done *) +fun EXISTS_LEFT [] th = th + | EXISTS_LEFT fvs th = + let val hfvs = map (fn h => {hyp = h, fvs = free_vars h}) (Thm.hyp th) ; + val fvs_c = free_vars (concl th) ; + in EXISTS_LEFT' false fvs_c hfvs fvs th end ; + +(* EXISTS_LEFT1 : term -> thm -> thm + for the free var argument, replace hyps containing the free var + by their conjunction, existentially quantified over the free var; + error if this can't be done for a free var *) +fun EXISTS_LEFT1 fv th = + let val hfvs = map (fn h => {hyp = h, fvs = free_vars h}) (Thm.hyp th) ; + val fvs_c = free_vars (concl th) ; + in EXISTS_LEFT' true fvs_c hfvs [fv] th end ; + (* --------------------------------------------------------------------------* * MATCH_MP: Matching Modus Ponens for implications. * * * From 93e4e2b92bd5ab30c97b12904345c20ef45ed9a8 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 26 Feb 2015 16:07:22 +1100 Subject: [PATCH 203/718] Fix a bunch of URLs referring to old github address --- Manual/Description/HolQbf.tex | 2 +- Manual/Description/HolSat.tex | 2 +- Manual/Description/HolSmt.tex | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/Manual/Description/HolQbf.tex b/Manual/Description/HolQbf.tex index 272e19aad5..1cbf063736 100644 --- a/Manual/Description/HolQbf.tex +++ b/Manual/Description/HolQbf.tex @@ -174,7 +174,7 @@ \subsection{Interface} \subsection{Wishlist} The following features have not been implemented yet. -Please submit additional feature requests (or code contributions) via \url{http://github.com/mn200/HOL}. +Please submit additional feature requests (or code contributions) via \url{http://github.com/HOL-Theorem-Prover/HOL}. \paragraph{Support for other QBF solvers} diff --git a/Manual/Description/HolSat.tex b/Manual/Description/HolSat.tex index 5b59421f3d..6f5b94a175 100644 --- a/Manual/Description/HolSat.tex +++ b/Manual/Description/HolSat.tex @@ -122,7 +122,7 @@ \subsection{Support for other SAT solvers}\label{subsec:hs-zchaff} A file \texttt{resolve\_trace} may be created in the current working directory, when working with ZChaff. This is the proof trace file produced by ZChaff, and is hardwired. -Other SAT solvers are currently not supported. If you would like such support to be added for your favourite solver, please send a feature request via \url{http://github.com/mn200/HOL}. +Other SAT solvers are currently not supported. If you would like such support to be added for your favourite solver, please send a feature request via \url{http://github.com/HOL-Theorem-Prover/HOL}. \subsection{The general interface} diff --git a/Manual/Description/HolSmt.tex b/Manual/Description/HolSmt.tex index 1544ee9436..6e116c1a99 100644 --- a/Manual/Description/HolSmt.tex +++ b/Manual/Description/HolSmt.tex @@ -221,7 +221,7 @@ \subsection{Wishlist} The following features have not been implemented yet. Please submit additional feature requests (or code contributions) via -\url{http://github.com/mn200/HOL}. +\url{http://github.com/HOL-Theorem-Prover/HOL}. \paragraph{Counterexamples} From 17a5f64b8a110b4237c78e197302dcf236a3cf08 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 26 Feb 2015 16:08:26 +1100 Subject: [PATCH 204/718] Implement, document new form of substitution for LaTeX munging --- Manual/Description/misc.tex | 8 +++++++- src/TeX/mungeTools.sml | 19 +++++++++++++++++-- 2 files changed, 24 insertions(+), 3 deletions(-) diff --git a/Manual/Description/misc.tex b/Manual/Description/misc.tex index 7d40d6bd6a..ef1b3da4e4 100644 --- a/Manual/Description/misc.tex +++ b/Manual/Description/misc.tex @@ -1249,7 +1249,7 @@ \subsection{Munging Commands} The \texttt{\indentoption} option lets the pretty-printer know that it is printing with a given indentation, affecting all lines of its output. -\item[$\mathit{nm}_1$\texttt{/}$\mathit{nm}_2$] (For use with \holtm{} +\item[$\mathit{nm}_1\mathtt{/}\mathit{nm}_2$] (For use with \holtm{} and \holthm{}.) % Causes name $\mathit{nm}_1$ to be substituted for name $\mathit{nm}_2$ in the term or theorem. @@ -1261,6 +1261,12 @@ \subsection{Munging Commands} (Hypotheses are not printed by default anyway of course.) If $\mathit{nm}_1$ and $\mathit{nm}_2$ both begin with the colon character then they are parsed as types, and type instantiation is performed on the term or theorem argument instead of variable substitution. + +\item[$s\mathtt{//}t$] (For use with \holtm{}, \holthm, and \holty) Causes \LaTeX{} string $s$ to be substituted for token $t$. +This allows one-off manipulation of the override map (see Section~\ref{sec:running-munger} below). +The difference between this operation and the ``normal substitution'' done with a single slash (as above) is that it happens as the \HOL{} entity is printed, whereas normal substitution happens before pretty-printing is done. +If printing depends on particular variable name choices, the ``last minute'' manipulations possible with this form of substitution may be preferable. +The width of the \LaTeX{} string is taken to be the width of the original token $t$. \end{description} \subsection{Math-Mode Munging} diff --git a/src/TeX/mungeTools.sml b/src/TeX/mungeTools.sml index c713d9db70..5356baf316 100644 --- a/src/TeX/mungeTools.sml +++ b/src/TeX/mungeTools.sml @@ -7,6 +7,7 @@ datatype command = Theorem | Term | Type datatype opt = Turnstile | Case | TT | Def | SpacedDef | TypeOf | TermThm | Indent of int | NoSpec | Inst of string * string + | OverrideUpd of (string * int) * string | NoTurnstile | Width of int | Mathmode of string | NoMath | AllTT | ShowTypes of int @@ -117,7 +118,10 @@ fun stringOpt pos s = (warn (pos, s ^ " is not a valid option"); NONE) else (warn (pos, s ^ " is not a valid option"); NONE) - else SOME (Inst (rmws pfx, rmws (slice(sfx,1,NONE)))) + else if size sfx > 2 andalso sub(sfx,1) = #"/" then + SOME(OverrideUpd((rmws pfx, size sfx - 2), rmws (slice(sfx,2,NONE)))) + else + SOME (Inst (rmws pfx, rmws (slice(sfx,1,NONE)))) end end @@ -214,7 +218,8 @@ val optset_unoverloads = val HOL = !EmitTeX.texPrefix val user_overrides = ref (Binarymap.mkDict String.compare) - +fun diag s = (TextIO.output(TextIO.stdErr, s ^ "\n"); + TextIO.flushOut TextIO.stdErr) fun overrides s = Binarymap.peek (!user_overrides, s) fun isChar x y = x = y @@ -270,6 +275,8 @@ end fun depth1_conv c t = (TRY_CONV c THENC TRY_CONV (SUB_CONV (depth1_conv c))) t +fun updatef ((k, v), f) x = if x = k then SOME v else f x + fun do_thminsts loc opts th = let val (insts, tytheta, theta) = mkinst loc opts (concl th) val th = INST_TYPE tytheta th @@ -382,6 +389,14 @@ in [] => (fn f => f) | slist => clear_overloads slist) + val overrides = let + fun foldthis (opt, acc) = + case opt of + OverrideUpd (newsz,old) => updatef ((old,newsz), acc) + | _ => acc + in + OptSet.fold foldthis overrides opts + end fun stdtermprint pps t = optprintermod (raw_pp_term_as_tex overrides) pps t fun clear_abbrevs slist f = let From f6413f419f97485580216bd3d0b240f1d729b954 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Fri, 27 Feb 2015 22:36:46 +1100 Subject: [PATCH 205/718] documentation for Drule.SIMPLE_EXISTS --- help/Docfiles/Drule.SIMPLE_EXISTS.doc | 41 +++++++++++++++++++++++++++ help/Docfiles/Thm.EXISTS.doc | 2 +- 2 files changed, 42 insertions(+), 1 deletion(-) create mode 100644 help/Docfiles/Drule.SIMPLE_EXISTS.doc diff --git a/help/Docfiles/Drule.SIMPLE_EXISTS.doc b/help/Docfiles/Drule.SIMPLE_EXISTS.doc new file mode 100644 index 0000000000..d5fb24139a --- /dev/null +++ b/help/Docfiles/Drule.SIMPLE_EXISTS.doc @@ -0,0 +1,41 @@ +\DOC SIMPLE_EXISTS + +\TYPE {SIMPLE_EXISTS : term -> thm -> thm} + +\SYNOPSIS +Introduces existential quantification using as witness a given free variable. + +\KEYWORDS +rule, existential. + +\DESCRIBE +When applied to a free variable term and a theorem, +{SIMPLE_EXISTS} gives the theorem made by existentially quantifying the +conclusion of the given theorem over the given free variable. +{ + A |- p + ------------- SIMPLE_EXISTS ``x`` + A |- ?x. p +} + + +\FAILURE +Fails if the term argument is not a free variable. + +\COMMENTS +The free variable need not appear in the conclusion of the theorem, +and may appear in the hypotheses. + +\EXAMPLE +{ + - SIMPLE_EXISTS (Term `x`) (REFL (Term `x`)); + > val it = |- ?x. x = x : thm + + - SIMPLE_EXISTS (Term `x`) (REFL T); + > val it = |- ?x. T = T : thm +} + + +\SEEALSO +Thm.EXISTS, Thm.CHOOSE, Tactic.EXISTS_TAC. +\ENDDOC diff --git a/help/Docfiles/Thm.EXISTS.doc b/help/Docfiles/Thm.EXISTS.doc index 80ef806c21..3d73a561e8 100644 --- a/help/Docfiles/Thm.EXISTS.doc +++ b/help/Docfiles/Thm.EXISTS.doc @@ -37,5 +37,5 @@ things from the same theorem: \SEEALSO -Thm.CHOOSE, Tactic.EXISTS_TAC. +Thm.CHOOSE, Drule.SIMPLE_EXISTS, Tactic.EXISTS_TAC. \ENDDOC From 48345816bfc0d48980d2c70272a924fce3d4f55e Mon Sep 17 00:00:00 2001 From: Thomas Tuerk Date: Sat, 28 Feb 2015 10:44:43 +0100 Subject: [PATCH 206/718] add manual pattern match heuristic / improve exhaustive one Implement a new pattern match heuristic that allows manually specifying in which order to do case splits. This one prints a lot of debugging information in order to allow the user to make decent choices. The techniques for producing this debug have also been added to the exhaustive tactic. It now prints debugging information on how far the exhaustive search progressed and on intermediate results --- src/1/Pmatch.sig | 3 ++ src/1/PmatchHeuristics.sig | 12 +++++ src/1/PmatchHeuristics.sml | 100 +++++++++++++++++++++++++++++++++---- 3 files changed, 105 insertions(+), 10 deletions(-) diff --git a/src/1/Pmatch.sig b/src/1/Pmatch.sig index b550abf7fb..8030793137 100644 --- a/src/1/Pmatch.sig +++ b/src/1/Pmatch.sig @@ -28,4 +28,7 @@ sig val set_default_heuristic : unit -> unit val set_classic_heuristic : unit -> unit val with_classic_heuristic : ('a -> 'b) -> ('a -> 'b) + + (* provide choices manually *) + val with_manual_heuristic : int list -> ('a -> 'b) -> ('a -> 'b) end diff --git a/src/1/PmatchHeuristics.sig b/src/1/PmatchHeuristics.sig index 5e940264c9..643a1d2aba 100644 --- a/src/1/PmatchHeuristics.sig +++ b/src/1/PmatchHeuristics.sig @@ -19,6 +19,16 @@ sig val pheu_first_col : pmatch_heuristic val pheu_last_col : pmatch_heuristic + (* A manual heuristic. For each decision, it prints the columns and + takes the column-number from the provided list of explicit + choices. If the list is too short, the first column is + chosen. One should run this heuristic first with an empty list + as argument. Then look at the choices and add 0s for all the + initial choices you liked to be 0 an then a different choice you + prefer. Rerun again (because the following choices will change) + and iterate. This provided very fine control, but is tedious. *) + val pheu_manual : int list -> pmatch_heuristic + (* A heuristic based on column ranks. Given a pattern match matrix like p_11 ... p_1n @@ -61,6 +71,7 @@ sig Only usable for very small examples! *) val exhaustive_heuristic_fun : pmatch_heuristic_res_compare -> pmatch_heuristic_fun + (* custom pmatch_heuristic_fun can be easiest constructed by an explicit list of heuristics and a compare function *) val pmatch_heuristic_list : pmatch_heuristic_res_compare -> pmatch_heuristic list -> pmatch_heuristic_fun @@ -81,5 +92,6 @@ sig val with_classic_heuristic : ('a -> 'b) -> ('a -> 'b) val with_heuristic : pmatch_heuristic -> ('a -> 'b) -> ('a -> 'b) + val with_manual_heuristic : int list -> ('a -> 'b) -> ('a -> 'b) val is_classic : unit -> bool end diff --git a/src/1/PmatchHeuristics.sml b/src/1/PmatchHeuristics.sml index 2bdccb427e..a3d3a759a8 100644 --- a/src/1/PmatchHeuristics.sml +++ b/src/1/PmatchHeuristics.sml @@ -196,24 +196,50 @@ val classic_heuristic_fun = (pmatch_heuristic_list pmatch_heuristic_cases_cmp [p (*----------------------------------- an exhaustive search heuristic-fun ------------------------------------*) + fun exhaustive_heuristic_fun cmp = let val heuristicL_ref = ref ([]:pmatch_heuristic list) fun add_heu heu = (heuristicL_ref := heu :: (!heuristicL_ref)) - fun heu (prefix : int list) : pmatch_heuristic = + fun heu (prefix : (bool * int * int) list) : pmatch_heuristic = let val current_prefix = ref prefix val remaining_prefix = ref prefix - fun colfun thry rowL = + + fun colfun_print thry rowL = case (!remaining_prefix) of (i :: is) => (remaining_prefix := is; i) - | [] => let - val _ = Lib.appi (fn i => fn _ => add_heu (heu ((!current_prefix) @ [i+1]))) (tl (hd rowL)) - val _ = current_prefix := (!current_prefix) @ [0] - in - 0 - end + | [] => + let + fun all_vars n = List.all is_var (List.map + (fn r => List.nth (r, n)) rowL) + fun col_fun n _ = if (all_vars n orelse + (List.null rowL) orelse + (List.length (List.hd rowL) < 2)) then + SOME n else NONE + in + case (Lib.first_opt col_fun rowL) of + SOME r => let + val _ = current_prefix := (!current_prefix) @ [(false, r, 1)] + in + (false, r, 1) + end + | NONE => let + val l = List.length (hd rowL) + val _ = Lib.appi (fn i => fn _ => add_heu (heu ((!current_prefix) @ [(true, i+1, l)]))) (tl (hd rowL)) + val _ = current_prefix := (!current_prefix) @ [(true, 0, l)] + in + (true, 0, l) + end + end + + fun colfun thry rowL = let + val (do_it, r, l) = colfun_print thry rowL + val _ = if do_it then (print (int_to_string (r+1)); print "/"; print (int_to_string l); print " ") else () + in + r + end in { skip_rows = true, collapse_cases = true, col_fun = colfun } end @@ -221,18 +247,69 @@ let fun next_heu () = case (!heuristicL_ref) of [] => NONE - | (h :: hs) => (heuristicL_ref := hs; SOME h) + | (h :: hs) => (print "\n"; heuristicL_ref := hs; SOME h) fun init () = let val _ = heuristicL_ref := [heu []] + fun cmp' (r1, r2) = ( + print "\nCases in Result: "; + print (int_to_string (length (fst r2))); + print " (best so far "; + print (int_to_string (length (fst r1))); + print ")"; + cmp (r1, r2) + ) in - (cmp, next_heu) + (cmp', next_heu) end in init end +(* A manual one taking an explicit order *) +fun pheu_manual (res_input : int list) : pmatch_heuristic = +let + fun pr ts = let + val ts_sl = List.map (fn t => "``" ^ (Hol_pp.term_to_string t) ^ "``") ts + val ts_s = String.concatWith ", " ts_sl + in + print ts_s; + print "\n" + end + val res = ref res_input + fun man_choice rowL = + let + val r = case (!res) of + [] => 0 + | (i::is) => + let + val _ = res := is + in + if (i < List.length (List.hd rowL)) then i else + (print ("Error, can't use "^(int_to_string i)^"\n");0) + end + val _ = List.map pr rowL + val _ = print ("Using "^(int_to_string r)^"\n\n\n") + in + r + end + + fun colfun thry rowL = + if ((null rowL) orelse (length (hd rowL) < 2)) then 0 else + let + fun all_vars n = List.all is_var (List.map + (fn r => List.nth (r, n)) rowL) + fun col_fun n _ = if all_vars n then SOME n else NONE + in + case (Lib.first_opt col_fun rowL) of + SOME r => r + | NONE => man_choice rowL + end +in + { skip_rows = true, collapse_cases = true, col_fun = colfun } +end + (*---------------------------------------------------------------------------- A reference to store the current heuristic_fun @@ -268,4 +345,7 @@ fun with_classic_heuristic f = with_flag (classic, true) (with_flag (pmatch_heuristic, classic_heuristic_fun) f) +fun with_manual_heuristic choices = + with_heuristic (pheu_manual choices) + end; From ef375495e01669184e8863720b7a616a73fb63bf Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 2 Mar 2015 16:49:31 +1100 Subject: [PATCH 207/718] Set arbitrary traces while LaTeX munging. Closes #141. That issue calls for a slightly different interface to get much the same effect. This approach has the advantage that it keeps the effect of the trace changing localised. --- Manual/Description/misc.tex | 4 ++++ Manual/LaTeX/commands.tex | 2 ++ src/TeX/mungeTools.sml | 14 ++++++++++++++ 3 files changed, 20 insertions(+) diff --git a/Manual/Description/misc.tex b/Manual/Description/misc.tex index ef1b3da4e4..c3aac46b4b 100644 --- a/Manual/Description/misc.tex +++ b/Manual/Description/misc.tex @@ -1189,6 +1189,10 @@ \subsection{Munging Commands} For adding a name to the rule, see the \texttt{rulename} option. +\item[\texttt{tr\apost}$\mathit{tracename}$\texttt{\apost=}$n$] +This option allows the temporary setting of the provided trace to the integer value $n$. +For example, one can set \texttt{pp\_unambiguous\_comprehensions} to $1$ to ensure that set comprehensions are printed with bound variables explicitly identified (see Section~\ref{sec:theory-of-sets}). + \item[\texttt{tt}] % Causes the term to be type-set as the argument to a \LaTeX{} command \texttt{\bs{}HOLinline}. % diff --git a/Manual/LaTeX/commands.tex b/Manual/LaTeX/commands.tex index 3b1a914d3d..f43cc2de61 100644 --- a/Manual/LaTeX/commands.tex +++ b/Manual/LaTeX/commands.tex @@ -13,6 +13,7 @@ \newcommand\REFERENCE{{\footnotesize\sl REFERENCE}} \newcommand\LOGIC{{\footnotesize\sl LOGIC}} \newcommand\LIBRARIES{{\footnotesize\sl LIBRARIES}} +\usepackage{textcomp} \newcommand{\bs}{\texttt{\char'134}} % backslash \newcommand{\lb}{\texttt{\char'173}} % left brace @@ -21,6 +22,7 @@ \newcommand{\lt}{\texttt{\char'74}} % less than \newcommand{\gt}{\texttt{\char'76}} % greater than \newcommand{\dol}{\texttt{\char'44}} % dollar +\newcommand{\apost}{\texttt{\textquotesingle}} % double back quotes `` \newcommand{\dq}{\texttt{\char'140\char'140}} %These macros were included by slind: diff --git a/src/TeX/mungeTools.sml b/src/TeX/mungeTools.sml index 5356baf316..ee3b4d604c 100644 --- a/src/TeX/mungeTools.sml +++ b/src/TeX/mungeTools.sml @@ -8,6 +8,7 @@ datatype opt = Turnstile | Case | TT | Def | SpacedDef | TypeOf | TermThm | Indent of int | NoSpec | Inst of string * string | OverrideUpd of (string * int) * string + | TraceSet of string * int | NoTurnstile | Width of int | Mathmode of string | NoMath | AllTT | ShowTypes of int @@ -65,6 +66,15 @@ fun stringOpt pos s = NONE => (warn(pos, s ^ " is not a valid option"); NONE) | SOME i => SOME (ShowTypes i) end + else if String.isPrefix "tr'" s then let + val sfx = String.extract(s, 3, NONE) + val (pfx,eqsfx) = Substring.position "'=" (Substring.full sfx) + val numpart_s = String.extract (Substring.string eqsfx, 2, NONE) + in + case Int.fromString numpart_s of + NONE => (warn(pos, s ^ " is not a valid option"); NONE) + | SOME i => SOME(TraceSet(Substring.string pfx, i)) + end else if String.isPrefix ">>" s then let val numpart_s = String.extract(s,2,NONE) in @@ -215,6 +225,9 @@ fun optset_nomath s = OptSet.has NoMath s val optset_unoverloads = OptSet.fold (fn (e,l) => case e of Unoverload s => s :: l | _ => l) [] +fun optset_traces opts f = + OptSet.fold (fn (e, f) => case e of TraceSet p => trace p f | _ => f) f opts + val HOL = !EmitTeX.texPrefix val user_overrides = ref (Binarymap.mkDict String.compare) @@ -388,6 +401,7 @@ in |> (case optset_unoverloads opts of [] => (fn f => f) | slist => clear_overloads slist) + |> optset_traces opts val overrides = let fun foldthis (opt, acc) = From 8584dbbef43db0f0efbbe6d811adea3f71e01a41 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 2 Mar 2015 16:56:42 +1100 Subject: [PATCH 208/718] Making parsing of trace-setting munger option a bit more robust --- src/TeX/mungeTools.sml | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/src/TeX/mungeTools.sml b/src/TeX/mungeTools.sml index ee3b4d604c..fb81790e8d 100644 --- a/src/TeX/mungeTools.sml +++ b/src/TeX/mungeTools.sml @@ -69,11 +69,17 @@ fun stringOpt pos s = else if String.isPrefix "tr'" s then let val sfx = String.extract(s, 3, NONE) val (pfx,eqsfx) = Substring.position "'=" (Substring.full sfx) - val numpart_s = String.extract (Substring.string eqsfx, 2, NONE) in - case Int.fromString numpart_s of - NONE => (warn(pos, s ^ " is not a valid option"); NONE) - | SOME i => SOME(TraceSet(Substring.string pfx, i)) + if Substring.size eqsfx = 0 then + (warn(pos, s ^ " is not a valid option"); NONE) + else + let + val numpart_s = String.extract (Substring.string eqsfx, 2, NONE) + in + case Int.fromString numpart_s of + NONE => (warn(pos, s ^ " is not a valid option"); NONE) + | SOME i => SOME(TraceSet(Substring.string pfx, i)) + end end else if String.isPrefix ">>" s then let val numpart_s = String.extract(s,2,NONE) From 23e5f3ec09bc72584d8a14fe605786866124e8f1 Mon Sep 17 00:00:00 2001 From: Thomas Tuerk Date: Tue, 3 Mar 2015 00:14:55 +0100 Subject: [PATCH 209/718] deep_matches example: work on pattern compilation and constructor families --- examples/deep_matches/Holmakefile | 6 +- examples/deep_matches/README | 25 ++- examples/deep_matches/constrFamiliesLib.sig | 87 +++++++- examples/deep_matches/constrFamiliesLib.sml | 200 ++++++++++++++++-- examples/deep_matches/deepMatchesExamples.sml | 79 +++++++ examples/deep_matches/deepMatchesLib.sig | 18 ++ examples/deep_matches/deepMatchesLib.sml | 146 +++++++++---- examples/deep_matches/deepMatchesSyntax.sig | 5 + examples/deep_matches/deepMatchesSyntax.sml | 35 ++- 9 files changed, 517 insertions(+), 84 deletions(-) diff --git a/examples/deep_matches/Holmakefile b/examples/deep_matches/Holmakefile index eaeddd064f..8696e81185 100644 --- a/examples/deep_matches/Holmakefile +++ b/examples/deep_matches/Holmakefile @@ -1,9 +1,9 @@ -test: selftest.exe - ./$< - .PHONY: test selftest.exe: selftest.uo deepMatchesSyntax.uo deepMatchesTheory.uo deepMatchesLib.uo constrFamiliesLib.uo $(HOLMOSMLC) -o $@ $< +test: selftest.exe + ./$< + EXTRA_CLEANS = selftest.exe diff --git a/examples/deep_matches/README b/examples/deep_matches/README index edccabbf85..e3d2abacb0 100644 --- a/examples/deep_matches/README +++ b/examples/deep_matches/README @@ -1,9 +1,5 @@ This directory contains a deep embedding of pattern matching. -************************************************* -It is work in progress and still far from stable. -************************************************* - Normally, pattern matches are removed from the input by the parser of HOL4. An implementation of a pattern-match compilation algorithm replaces them with decision trees using primitive case-split functions @@ -22,12 +18,15 @@ example consider the ARM disassembler function `arm_decode` in of the pattern match compilation in such definitions? This pattern matching library tries to solve this problem. It provides -a deep embedding of pattern matches. The parsing and pretty printing -of these deeply embedded matches is much simpler and therefore more -trustworthy. The complicated, untrusted pattern match compilation can -then be performed inside the logic. Therefore, the need to trust the -implementation of the pattern match compilation is removed. Moreover, -the deep embedding provides some additional features like guards, -views, free variables in patterns or multiple occurrences of a bound -variable inside a pattern. There is also tool support for working with -deeply embedded pattern matches inside the logic. \ No newline at end of file +an internal representation of case-expressions that closely follows +the input synatx. The parsing and pretty printing of these deeply +case-expressions is much simpler and therefore more trustworthy. The +complicated, untrusted pattern match compilation can then be performed +inside the logic. Therefore, the need to trust the implementation of +the pattern match compilation is removed. In some sense, we have a +deep pattern compilation now. + +Moreover, the new case-expressions provide additional features like +guards, views, free variables in patterns or multiple occurrences of a +bound variable inside a pattern. There is also tool support for +working with the new case-expressions inside the logic. \ No newline at end of file diff --git a/examples/deep_matches/constrFamiliesLib.sig b/examples/deep_matches/constrFamiliesLib.sig index 3ae069395a..4290f99ba3 100644 --- a/examples/deep_matches/constrFamiliesLib.sig +++ b/examples/deep_matches/constrFamiliesLib.sig @@ -11,6 +11,10 @@ sig a list of names for all it's arguments *) type constructor + (* [mk_constructor c arg_names] generate a constructor [c] + with argument names [arg_names] *) + val mk_constructor : term -> string list -> constructor + (* check whether a constructor has no arguments *) val constructor_is_const : constructor -> bool @@ -26,9 +30,10 @@ sig type that should only be used via [make_constructorList]. *) type constructorList - (* [make_constructorList exh constrs] makes a new constructorList. - *) - val make_constructorList : bool -> (term * string list) list -> constructorList + (* [mk_constructorList exh constrs] makes a new constructorList. + [exh] states whether the list is exhaustive, i.e. wether all values + of the type can be constructed via a constructor in this list *) + val mk_constructorList : bool -> constructor list -> constructorList (************************) @@ -59,16 +64,80 @@ sig val mk_constructorFamily : constructorList * term * tactic -> constructorFamily (* [get_constructorFamily_proofObligations] returns the - proof obligations that occur when creating a new constructor family. *) + proof obligations that occur when creating a new constructor family + via [mk_constructorFamily]. *) val get_constructorFamily_proofObligations : constructorList * term -> term - (* [set_constructorFamily] sets the proof obligations - using goalStack *) - val set_constructorFamily : constructorList * term -> Manager.proof + (* [set_constructorFamily] sets the proof obligations that occur when + ruung [mk_constructorFamily] using goalStack. *) + val set_constructorFamily : constructorList * term -> Manager.proofs + (* [constructorFamily_of_typebase ty] extracts the constructor family + for the given type [ty] from typebase. *) + val constructorFamily_of_typebase : hol_type -> constructorFamily + + (************************) + (* Compile DBs *) + (************************) + (* A compile database combines constructor families, + an ssfrag and arbitrary compilation funs. *) + + + (* A compilation fun gets a column, i.e. a list of + terms together with a list of free variables in this term. + For this column a expansion theorem of the form + ``!ff x. ff x = ...`` + and an ssfrag should be returned. *) + type pmatch_compile_fun = (term list * term) list -> (thm * simpLib.ssfrag) option + + (* A database for pattern compilation *) + type pmatch_compile_db = { + pcdb_compile_funs : pmatch_compile_fun list, + pcdb_constrFams : (constructorFamily list) TypeNet.typenet, + pcdb_ss : simpLib.ssfrag + } + + (* empty db *) + val empty : pmatch_compile_db + + (* a default db implemented as a reference *) + val thePmatchCompileDB : pmatch_compile_db ref + + (* A database represents essentially a compile fun. + This functions combines all the contents of a db to + turn it into a compile fun. *) + val pmatch_compile_db_compile : pmatch_compile_db -> pmatch_compile_fun + + (* add a compile fun to a db *) + val pmatch_compile_db_add_compile_fun : + pmatch_compile_db -> pmatch_compile_fun -> pmatch_compile_db + + (* add a constructorFamily to a db *) + val pmatch_compile_db_add_constrFam : + pmatch_compile_db -> constructorFamily -> pmatch_compile_db + + (* add a ssfrag to a db *) + val pmatch_compile_db_add_ssfrag : + pmatch_compile_db -> simpLib.ssfrag -> pmatch_compile_db + + (* add a compile_fun to default db *) + val pmatch_compile_db_register_compile_fun : pmatch_compile_fun -> unit + (* add a constructor family to default db *) + val pmatch_compile_db_register_constrFam : constructorFamily -> unit + + (* add a ssfrag to default db *) + val pmatch_compile_db_register_ssfrag : simpLib.ssfrag -> unit + + + (************************) + (* Compile Funs *) + (************************) + + (* Compilation fun that turns a column of literals into + a large if-then-else case distinction. It is + present automatically in the default db. *) + val literals_compile_fun : pmatch_compile_fun - val constructorFamily_of_typebase : hol_type -> constructorFamily - end diff --git a/examples/deep_matches/constrFamiliesLib.sml b/examples/deep_matches/constrFamiliesLib.sml index 2108aea42b..b99167344e 100644 --- a/examples/deep_matches/constrFamiliesLib.sml +++ b/examples/deep_matches/constrFamiliesLib.sml @@ -3,6 +3,11 @@ struct open HolKernel boolLib simpLib bossLib +(***************************************************) +(* Auxiliary definitions *) +(***************************************************) + + fun failwith f x = raise (mk_HOL_ERR "constrFamiliesLib" f x) @@ -14,7 +19,7 @@ in List.rev vs' end - +(* list_mk_comb with build-in beta reduction *) fun list_mk_comb_subst (c, args) = (case args of [] => c | (a::args') => let @@ -25,10 +30,13 @@ fun list_mk_comb_subst (c, args) = (case args of list_mk_comb_subst (mk_comb (c, a), args') ) +(*-----------------------------------------*) +(* normalise free type variables in a type *) +(* in order to use it as a map key *) +(*-----------------------------------------*) fun next_ty ty = mk_vartype(Lexis.tyvar_vary (dest_vartype ty)); - fun normalise_ty ty = let fun recurse (acc as (dict,usethis)) tylist = case tylist of @@ -56,11 +64,18 @@ in end -(***************************************************) -(* Encoding theorem lists *) -(***************************************************) +fun base_ty ty = let + val (tn, targs) = dest_type ty + val targs' = List.rev (snd (List.foldl (fn (_, (v, l)) => (next_ty v, v::l)) (Type.alpha, []) targs)) +in + mk_type (tn, targs') +end + + +(*------------------------*) +(* Encoding theorem lists *) +(*------------------------*) - fun encode_term_opt_list tl = let val tl' = List.map (fn t => markerSyntax.mk_label ("THM_PART", Option.getOpt (t, T))) tl val t = list_mk_conj tl' @@ -85,7 +100,7 @@ end fun set_goal_list tl = let val thm = encode_term_opt_list tl in - Manager.set_goal ([], rhs (concl thm)) + proofManagerLib.set_goal ([], rhs (concl thm)) end @@ -107,8 +122,9 @@ end a list of names for all it's arguments *) datatype constructor = CONSTR of term * (string list) -fun constructor_is_const (CONSTR (_, sl)) = - null sl +fun mk_constructor t args = CONSTR (t, args) + +fun constructor_is_const (CONSTR (_, sl)) = null sl fun mk_constructor_term vs (CONSTR (c, args)) = let val (arg_tys, b_ty) = strip_fun (type_of c) @@ -123,9 +139,6 @@ in (t, arg_vars') end - - - (* Multiple constructors for a single type are usually grouped. These can be exhaustive or not. *) type constructorList = { @@ -134,8 +147,7 @@ type constructorList = { cl_is_exhaustive : bool } -fun make_constructorList is_exhaustive constrs' = let - val constrs = List.map CONSTR constrs' +fun mk_constructorList is_exhaustive constrs = let val ts = List.map (fst o (mk_constructor_term [])) constrs val _ = if null ts then failwith "make_constructorList" "no constructors given" else () val ty = type_of (hd ts) @@ -313,8 +325,6 @@ in end - - (***************************************************) (* Connection to typebase *) (***************************************************) @@ -351,8 +361,7 @@ fun constructorFamily_of_typebase ty = let val thm_one_one = TypeBase.one_one_of ty val thm_case = TypeBase.case_def_of ty - -(* set_constructorFamily (crL, case_split_tm) *) + (* set_constructorFamily (crL, case_split_tm) *) val cf = mk_constructorFamily (crL, case_split_tm, SIMP_TAC std_ss [thm_distinct, thm_one_one] THEN REPEAT STRIP_TAC THEN ( @@ -366,9 +375,162 @@ end (***************************************************) -(* Build a on to typebase *) +(* Collections of constructorFamilies + *) +(* extra matching info *) +(***************************************************) + +type pmatch_compile_fun = (term list * term) list -> (thm * simpLib.ssfrag) option + +val typeConstrFamsDB = ref (TypeNet.empty : constructorFamily TypeNet.typenet) + +type pmatch_compile_db = { + pcdb_compile_funs : pmatch_compile_fun list, + pcdb_constrFams : (constructorFamily list) TypeNet.typenet, + pcdb_ss : simpLib.ssfrag +} + +val empty : pmatch_compile_db = { + pcdb_compile_funs = [], + pcdb_constrFams = TypeNet.empty, + pcdb_ss = (simpLib.rewrites []) +} + +val thePmatchCompileDB = ref empty + +fun lookup_typeBase_constructorFamily ty = let + val b_ty = base_ty ty +in + SOME (b_ty, TypeNet.find (!typeConstrFamsDB, b_ty)) handle + NotFound => let + val cf = constructorFamily_of_typebase b_ty + val net = !typeConstrFamsDB + val net'= TypeNet.insert (net, b_ty, cf) + val _ = typeConstrFamsDB := net' + in + SOME (b_ty, cf) + end +end handle HOL_ERR _ => NONE + +fun lookup_constructorFamilies (db : pmatch_compile_db) col = let + val _ = if (List.null col) then (failwith "constructorFamiliesLib" "lookup_constructorFamilies: null col") else () + val ty = type_of (snd (hd col)) + + val cts_fams = let + val cts_fams = TypeNet.match (#pcdb_constrFams db, ty) + val cts_fams' = Lib.flatten (List.map (fn (ty, l) => + List.map (fn cf => (ty, cf)) l) cts_fams) + val cty_opt = lookup_typeBase_constructorFamily ty + val cty_l = case cty_opt of + NONE => [] + | SOME (ty, cf) => [(ty, cf)] + in cts_fams' @ cty_l end +in + case cts_fams of + [] => NONE + | cs::_ => SOME cs +end; + + +fun pmatch_compile_db_compile db col = ( + if (List.null col) then failwith "pmatch_compile_db_compile" "col 0" else + case (get_first (fn f => f col handle HOL_ERR _ => NONE) (#pcdb_compile_funs db)) of + SOME r => SOME r | NONE => ( + case lookup_constructorFamilies db col of + NONE => NONE | SOME (ty, cf) => ( + let + val ty_s = match_type ty (type_of (snd (hd col))) + val thm = constructorFamily_get_case_split cf + val thm' = INST_TYPE ty_s thm + in + SOME (thm', merge_ss [(#pcdb_ss db), simpLib.rewrites [ + (constructorFamily_get_rewrites cf)]]) + end + ))); + +fun pmatch_compile_db_add_ssfrag (db : pmatch_compile_db) ss = { + pcdb_compile_funs = #pcdb_compile_funs db, + pcdb_constrFams = #pcdb_constrFams db, + pcdb_ss = (simpLib.merge_ss [#pcdb_ss db, ss]) +} : pmatch_compile_db + +fun pmatch_compile_db_register_ssfrag ss = + thePmatchCompileDB := pmatch_compile_db_add_ssfrag (!thePmatchCompileDB) ss + +fun pmatch_compile_db_add_compile_fun (db : pmatch_compile_db) cf = { + pcdb_compile_funs = cf::(#pcdb_compile_funs db), + pcdb_constrFams = #pcdb_constrFams db, + pcdb_ss = #pcdb_ss db +} : pmatch_compile_db + +fun pmatch_compile_db_register_compile_fun cf = + thePmatchCompileDB := pmatch_compile_db_add_compile_fun (!thePmatchCompileDB) cf + +fun pmatch_compile_db_add_constrFam (db : pmatch_compile_db) cf = { + pcdb_compile_funs = #pcdb_compile_funs db, + pcdb_constrFams = let + val cl = (#constructors cf) + val ty = #cl_type cl + val net = #pcdb_constrFams db + val cfs = TypeNet.find (net, ty) handle NotFound => [] + val net' = TypeNet.insert (net, ty, cf::cfs) + in + net' + end, + pcdb_ss = #pcdb_ss db +} : pmatch_compile_db + +fun pmatch_compile_db_register_constrFam cf = + thePmatchCompileDB := pmatch_compile_db_add_constrFam (!thePmatchCompileDB) cf + + + +(***************************************************) +(* complilation funs *) (***************************************************) +val COND_CONG_APPLY = prove (``(if (x:'a) = c then (ff x):'b else ff x) = + (if x = c then ff c else ff x)``, +Cases_on `x = c` THEN ASM_REWRITE_TAC[]) + +fun literals_compile_fun (col:(term list * term) list) = let + + fun extract_literal ((vs, c), ts) = let + val vars = FVL [c] empty_tmset + val is_lit = not (List.exists (fn v => HOLset.member (vars, v)) vs) + in + if is_lit then HOLset.add(ts,c) else + (if is_var c then ts else failwith "" "extract_literal") + end + + val ts = List.foldl extract_literal empty_tmset col + val lits = HOLset.listItems ts + val _ = if (List.null lits) then (failwith "" "no lits") else () + + val rty = gen_tyvar () + val lit_ty = type_of (snd (List.hd col)) + val split_arg = mk_var ("x", lit_ty) + val split_fun = mk_var ("ff", lit_ty --> rty) + val arg = mk_comb (split_fun, split_arg) + + + fun mk_expand_thm lits = case lits of + [] => REFL arg + | (l :: lits') => let + val b = mk_eq (split_arg, l) + val thm0 = GSYM (ISPEC arg (SPEC b COND_ID)) + val thm1 = CONV_RULE (RHS_CONV (REWR_CONV COND_CONG_APPLY)) thm0 + val thm2a = mk_expand_thm lits' + val thm2 = CONV_RULE (RHS_CONV (RAND_CONV (K thm2a))) thm1 + in + thm2 + end + + val thm0 = mk_expand_thm lits + val thm1 = GEN split_fun (GEN split_arg thm0) +in + SOME (thm1, simpLib.rewrites [Cong boolTheory.COND_CONG]) +end +val _ = pmatch_compile_db_register_compile_fun literals_compile_fun end diff --git a/examples/deep_matches/deepMatchesExamples.sml b/examples/deep_matches/deepMatchesExamples.sml index f6ac4b143b..97bdc19501 100644 --- a/examples/deep_matches/deepMatchesExamples.sml +++ b/examples/deep_matches/deepMatchesExamples.sml @@ -3,6 +3,9 @@ open deepMatchesLib open deepMatchesTheory open deepMatchesSyntax open pred_setTheory +open constrFamiliesLib +open stringTheory +open pred_setLib (* Introducing case expressions *) @@ -173,6 +176,82 @@ val my_d_thms3 = PMATCH_TO_TOP_RULE my_d_def thm *) +(*********************************) +(* Compiling *) +(*********************************) + +val _ = Datatype ` + tree = Empty + | Red tree 'a tree + | Black tree 'a tree`; + +val balance_black_def = Define `balance_black a n b = + CASE (a,b) OF [ + || (a,x,b,y,c,d). (Red (Red a x b) y c,d) ~> + (Red (Black a x b) y (Black c n d)); + || (a,x,b,y,c,d). (Red a x (Red b y c),d) ~> + (Red (Black a x b) y (Black c n d)); + || (a,b,y,c,z,d). (a,Red (Red b y c) z d) ~> + (Red (Black a n b) y (Black c z d)); + || (a,b,y,c,z,d). (a,Red b y (Red c z d)) ~> + (Red (Black a n b) y (Black c z d)); + || other. other ~> (Black a n b) + ]` + +(* try to compile to a tree inside the logic *) +val balance_black_dectree_def = CONV_RULE + (TOP_SWEEP_CONV (PMATCH_CASE_SPLIT_CONV (fn _ => 0))) + balance_black_def + +open stringTheory +val string_match_def = Define `string_match s x = + CASE (s, x) OF [ + || x. ("SUC", x) ~> SUC x; + || x. ("DOUBLE", x) ~> (x * 2); + || (s, x). (s, x) ~> x + ]` + +val string_match_dectree_def = CONV_RULE + (TOP_SWEEP_CONV (PMATCH_CASE_SPLIT_CONV (fn _ => 0))) + string_match_def + + +(*********************************) +(* Constructor families *) +(*********************************) + +val list_REVCASE_def = Define ` + list_REVCASE l c_nil c_snoc = + (if l = [] then c_nil else ( + c_snoc (LAST l) (BUTLAST l)))` + +val list_REVCASE_THM = prove (`` + ((list_REVCASE [] c_nil c_snoc) = c_nil) /\ + ((list_REVCASE (SNOC x xs) c_nil c_snoc) = c_snoc x xs)``, +SIMP_TAC list_ss [list_REVCASE_def, rich_listTheory.NOT_SNOC_NIL]) + +val c_nil = mk_constructor ``[]:'a list`` [] +val c_snoc = mk_constructor ``SNOC: 'a -> 'a list -> 'a list`` + ["x", "xs"] + +val cl = mk_constructorList true [c_nil, c_snoc] + +val cf = mk_constructorFamily (cl, ``list_REVCASE``, + SIMP_TAC list_ss [rich_listTheory.NOT_SNOC_NIL] THEN + REPEAT STRIP_TAC THENL [ + ASSUME_TAC (Q.SPEC `x` listTheory.SNOC_CASES) THEN + FULL_SIMP_TAC std_ss [list_REVCASE_THM], + + PROVE_TAC [listTheory.SNOC_CASES] + ] +) + +val t = ``CASE l OF [ + ||. [] ~> 0; + || (x, xs). SNOC x xs ~> x + ]`` + + (*********************************) (* Using non-injective patterns *) (*********************************) diff --git a/examples/deep_matches/deepMatchesLib.sig b/examples/deep_matches/deepMatchesLib.sig index 9153878820..595cf28256 100644 --- a/examples/deep_matches/deepMatchesLib.sig +++ b/examples/deep_matches/deepMatchesLib.sig @@ -109,4 +109,22 @@ sig val PMATCH_TO_TOP_RULE_GEN : ssfrag list -> rule val PMATCH_TO_TOP_RULE : rule + + (********************************) + (* CASE SPLIT (pattern compile) *) + (********************************) + + val PMATCH_CASE_SPLIT_CONV : + ((term * (term list * term) list) list -> int) -> term -> thm + + val PMATCH_CASE_SPLIT_CONV_GEN : + ssfrag list -> + constrFamiliesLib.pmatch_compile_db -> + ((term * (term list * term) list) list -> int) -> term -> thm + + val PMATCH_CASE_SPLIT_CONV_GENCALL : + ssfrag list * (term -> thm) option -> + constrFamiliesLib.pmatch_compile_db -> + ((term * (term list * term) list) list -> int) -> term -> thm + end diff --git a/examples/deep_matches/deepMatchesLib.sml b/examples/deep_matches/deepMatchesLib.sml index 3cf4cb474b..841b2c9d52 100644 --- a/examples/deep_matches/deepMatchesLib.sml +++ b/examples/deep_matches/deepMatchesLib.sml @@ -10,6 +10,7 @@ open deepMatchesSyntax open Traverse open constrFamiliesLib + (***********************************************) (* Simpset to evaluate PMATCH_ROWS *) (***********************************************) @@ -18,7 +19,6 @@ val PAIR_EQ_COLLAPSE = prove ( ``(((FST x = (a:'a)) /\ (SND x = (b:'b))) = (x = (a, b)))``, Cases_on `x` THEN SIMP_TAC std_ss [] THEN METIS_TAC[]) - fun is_FST_eq x t = let val (l, r) = dest_eq t val pred = aconv (pairSyntax.mk_fst x) @@ -1271,40 +1271,29 @@ fun PMATCH_TO_TOP_RULE thm = PMATCH_TO_TOP_RULE_GEN [] thm; (***********************************************) (* -val t = `` -PMATCH (a,x,xs) - [PMATCH_ROW (\x. (NONE,x,[])) (\x. T) (\x. x); - PMATCH_ROW (\x. (NONE,x,[2])) (\x. T) (\x. x); - PMATCH_ROW (\ (x,v18). (NONE,x,[v18])) (\ (x, v18). T) (\ (x, v18). 3); - PMATCH_ROW (\ (x,v12,v16,v17). (NONE,x,v12::v16::v17)) - (\ (x,v12,v16,v17). T) - (\ (x,v12,v16,v17). 3); - PMATCH_ROW (\ (y,x,z,zs). (SOME y,x,[z])) - (\ (y,x,z,zs). T) - (\ (y,x,z,zs). x+5+z); - PMATCH_ROW (\ (y,v23,v24). (SOME y,0,v23::v24)) - (\ (y,v23,v24). T) - (\ (y,v23,v24). v23+y); - PMATCH_ROW (\ (y,z,v23). (SOME y,SUC z,[v23])) - (\ (y,z,v23). y > 5) - (\ (y,z,v23). 3); - PMATCH_ROW (\ (y,z). (SOME y,SUC z,[1; 2])) - (\ (y,z). T) - (\ (y,z). y + z) - ]`` +val t = ``CASE (a,x,xs) OF [ + || x. (NONE,x,[]) ~> x; + || x. (NONE,x,[2]) ~> x; + || (x,v18). (NONE,x,[v18]) ~> 3; + || (x,v12,v16,v17). (NONE,x,v12::v16::v17) ~> 3; + || (y,x,z,zs). (SOME y,x,[z]) ~> (x + 5 + z); + || (y,v23,v24). (SOME y,0,v23::v24) ~> (v23 + y); + || (y,z,v23). (SOME y,SUC z,[v23]) when (y > 5) ~> 3; + || (y,z). (SOME y,SUC z,[1; 2]) ~> (y + z) + ]`` *) fun STRIP_ABS_CONV conv t = if (is_abs t) then ABS_CONV (STRIP_ABS_CONV conv) t else conv t -fun PMATCH_CASE_SPLIT_AUX col expand_thm conv t = let +fun PMATCH_CASE_SPLIT_AUX rc_arg col_no expand_thm t = let val (v, rows) = dest_PMATCH t val vs = pairSyntax.strip_pair v - val arg = el (col+1) vs + val arg = el (col_no+1) vs val arg_v = genvar (type_of arg) - val vs' = pairSyntax.list_mk_pair (List.take (vs, col) @ (arg_v :: (List.drop (vs, col+1)))) + val vs' = pairSyntax.list_mk_pair (List.take (vs, col_no) @ (arg_v :: (List.drop (vs, col_no+1)))) val ff = let val (x, xs) = strip_comb t @@ -1316,33 +1305,112 @@ fun PMATCH_CASE_SPLIT_AUX col expand_thm conv t = let val thm0 = ISPEC arg (ISPEC ff expand_thm) val thm1 = CONV_RULE (LHS_CONV BETA_CONV) thm0 - fun is_case_conv_end t = - is_comb (fst (dest_comb t)) handle HOL_ERR _ => false - fun case_conv conv t = - if not (is_case_conv_end t) then REFL t else - (RAND_CONV (STRIP_ABS_CONV conv) THENC RATOR_CONV (case_conv conv)) t + val c = SIMP_CONV + (std_ss++PMATCH_SIMP_GEN_ss (fst rc_arg)) [] + val thm2 = CONV_RULE (RHS_CONV c) thm1 - val thm2 = CONV_RULE (RHS_CONV (case_conv (BETA_CONV THENC TRY_CONV conv))) thm1 + (* check whether it got simpler *) + val _ = let + val r = rhs (concl thm2) + val i = ((find_term (aconv t) r; true) handle HOL_ERR _ => false) + in + if i then raise UNCHANGED else () + end in thm2 end (* -fun PMATCH_CASE_SPLIT_CONV_GENCALL rc_arg col_no t = let - val thm0 = QCHANGED_CONV ( - PMATCH_SIMP_CONV_GENCALL rc_arg) t handle HOL_ERR _ => REFL t +val t = t' +val col_no = 1 +val rc_arg = ([], NONE) +val db = !thePmatchCompileDB +fun col_heu _ = 0 +*) + +fun PMATCH_CASE_SPLIT_CONV_GENCALL_STEP (gl, callback_opt) db col_heu t = let + val _ = if (is_PMATCH t) then () else raise UNCHANGED + + fun find_col cols = if (List.null cols) then raise UNCHANGED else let + val col_no = col_heu cols + val (v, col) = el (col_no+1) cols + val res = pmatch_compile_db_compile db col + in + case res of + SOME (expand_thm, expand_ss) => (col_no, expand_thm, expand_ss) + | NONE => let + val cols' = List.take (cols, col_no) @ List.drop (cols, col_no+1) + val (col_no', expand_thm, expand_ss) = find_col cols' + val col_no'' = if (col_no' < col_no) then col_no' else col_no'+1 + in + (col_no'', expand_thm, expand_ss) + end + end + val (col_no, expand_thm, expand_ss) = find_col (dest_PMATCH_COLS t) + val thm1 = QCHANGED_CONV (PMATCH_CASE_SPLIT_AUX + (expand_ss::gl, callback_opt) col_no expand_thm) t +in + thm1 +end + + +val pair_CASE_tm = mk_const ("pair_CASE", ``:'a # 'b -> ('a -> 'b -> 'c) -> 'c``) + +fun PMATCH_CASE_SPLIT_CONV_GENCALL rc_arg db col_heu t = let + val thm0 = PMATCH_SIMP_CONV_GENCALL rc_arg t handle + HOL_ERR _ => REFL t + | UNCHANGED => REFL t val t' = rhs (concl thm0) - val (v, col) = el (col_no+1) (dest_PMATCH_COLS t') + val cols = dest_PMATCH_COLS t' + val col_no = length cols + val (v, rows) = dest_PMATCH t' - val expand_thm = get_case_expand_thm (v, col) + fun mk_pair avoid acc col_no v = if (col_no <= 1) then ( + let + val vs = List.rev (v::acc) + val p = pairSyntax.list_mk_pair vs + val rows_tm = listSyntax.mk_list (rows, type_of (hd rows)) + in + mk_PMATCH p rows_tm + end + ) else ( + let + val (ty1, ty2) = pairSyntax.dest_prod (type_of v) + val v1 = variant avoid (mk_var ("v", ty1)) + val v2 = variant (v1::avoid) (mk_var ("v", ty2)) + + val t0 = inst [alpha |-> ty1, beta |-> ty2, gamma |-> type_of t] pair_CASE_tm + val t1 = mk_comb (t0, v) + val t2a = mk_pair (v1::v2::avoid) (v1::acc) (col_no-1) v2 + val t2b = list_mk_abs ([v1, v2], t2a) + val t2c = mk_comb (t1, t2b) + in + t2c + end + ) - val thm1 = QCHANGED_CONV (PMATCH_CASE_SPLIT_AUX col_no expand_thm (PMATCH_SIMP_CONV_GENCALL rc_arg)) t' handle HOL_ERR _ => (REFL t') + + val t'' = mk_pair (free_vars t') [] col_no v + val thm1_tm = mk_eq (t', t'') + val thm1 = prove (thm1_tm, SIMP_TAC std_ss [pairTheory.pair_case_def]) + + val thm2 = CONV_RULE (RHS_CONV ( + (TOP_SWEEP_CONV ( + CHANGED_CONV (PMATCH_CASE_SPLIT_CONV_GENCALL_STEP rc_arg db col_heu) + )))) thm1 + + val thm3 = TRANS thm0 thm2 + val thm4 = CONV_RULE (RHS_CONV REMOVE_REBIND_CONV) thm3 in - TRANS thm0 thm1 + thm4 end -*) + +fun PMATCH_CASE_SPLIT_CONV_GEN ssl = PMATCH_CASE_SPLIT_CONV_GENCALL (ssl, NONE) + +fun PMATCH_CASE_SPLIT_CONV colHeu t = + PMATCH_CASE_SPLIT_CONV_GEN [] (!thePmatchCompileDB) colHeu t end diff --git a/examples/deep_matches/deepMatchesSyntax.sig b/examples/deep_matches/deepMatchesSyntax.sig index f47e85f64d..7ef8c05b77 100644 --- a/examples/deep_matches/deepMatchesSyntax.sig +++ b/examples/deep_matches/deepMatchesSyntax.sig @@ -10,6 +10,11 @@ sig free vars of a thm *) val FRESH_TY_VARS_RULE : rule + (* transforms a term to a alpha-equivalent + one that does not use the same variable name in + different bindings in the term. *) + val REMOVE_REBIND_CONV : conv + (******************) (* PMATCH_ROW *) (******************) diff --git a/examples/deep_matches/deepMatchesSyntax.sml b/examples/deep_matches/deepMatchesSyntax.sml index 145604bd11..5762590250 100644 --- a/examples/deep_matches/deepMatchesSyntax.sml +++ b/examples/deep_matches/deepMatchesSyntax.sml @@ -52,6 +52,28 @@ val PMATCH_gtm = inst ty_var_subst PMATCH_tm fun FRESH_TY_VARS_RULE thm = INST_TYPE ty_var_subst thm +val t = ``\x. P (\x. ss x) x`` + +fun REMOVE_REBIND_CONV_AUX avoid t = let + val (v, t') = dest_abs t + val v' = variant avoid v + val t'' = subst [v |-> v'] t' + val (t''', avoid') = REMOVE_REBIND_CONV_AUX (v'::avoid) t'' +in + (mk_abs (v', t'''), avoid') +end handle HOL_ERR _ => let + val (t1, t2) = dest_comb t + val (t1', avoid1) = REMOVE_REBIND_CONV_AUX avoid t1 + val (t2', avoid2) = REMOVE_REBIND_CONV_AUX avoid t2 +in + (mk_comb (t1', t2'), avoid2) +end handle HOL_ERR _ => (t, avoid) + +fun REMOVE_REBIND_CONV t = let + val (t', _) = REMOVE_REBIND_CONV_AUX [] t +in + ALPHA t t' +end (***********************************************) (* PMATCH_ROW *) @@ -181,7 +203,6 @@ fun is_PMATCH t = can dest_PMATCH t fun dest_PMATCH_COLS t = let val (v, rows) = dest_PMATCH t - val vs = pairSyntax.strip_pair v fun split_row r = let val (vars_tm, pt, gt, rh) = dest_PMATCH_ROW_ABS r @@ -192,6 +213,18 @@ fun dest_PMATCH_COLS t = let end val rows' = map split_row rows + val col_no = length (hd rows') + fun aux acc v col_no = if (col_no <= 1) then List.rev (v::acc) else ( + let + val (v1, v2) = pairSyntax.dest_pair v handle HOL_ERR _ => + (pairSyntax.mk_fst v, pairSyntax.mk_snd v) + in + aux (v1::acc) v2 (col_no-1) + end + ) + + val vs = aux [] v col_no + fun get_cols acc vs rows = case vs of [] => List.rev acc | (v::vs') => let From 1c98da10bafe1947580c807676ec3944613453b7 Mon Sep 17 00:00:00 2001 From: Thomas Tuerk Date: Wed, 4 Mar 2015 02:28:16 +0100 Subject: [PATCH 210/718] deep matches example: converting between PMATCH and case - implement PMATCH_ELIM_CONV - rename "convert_case" -> "case2pmatch" - add "pmatch2case" - fix bug in lifting code - divmod example added --- examples/deep_matches/deepMatchesExamples.sml | 39 +++++++++- examples/deep_matches/deepMatchesLib.sig | 9 ++- examples/deep_matches/deepMatchesLib.sml | 72 ++++++++++++++++--- 3 files changed, 104 insertions(+), 16 deletions(-) diff --git a/examples/deep_matches/deepMatchesExamples.sml b/examples/deep_matches/deepMatchesExamples.sml index 97bdc19501..3286e8d22a 100644 --- a/examples/deep_matches/deepMatchesExamples.sml +++ b/examples/deep_matches/deepMatchesExamples.sml @@ -10,12 +10,18 @@ open pred_setLib (* Introducing case expressions *) val t = ``case x of (NONE, []) => 0`` -val t' = convert_case t +val t' = case2pmatch t val thm_t = PMATCH_INTRO_CONV t (* check that SIMP works *) val thm_t' = PMATCH_REMOVE_ARB_CONV t' val thm_t' = PMATCH_SIMP_CONV t' +val t2' = rhs (concl thm_t') + +(* and turn it back *) +val t'' = pmatch2case t' +val thm_t'' = PMATCH_ELIM_CONV t' +val thm_t2'' = PMATCH_ELIM_CONV t2' (* more fancy *) @@ -24,7 +30,7 @@ val t = ``case x of | (SOME 2, []) => 2 | (SOME 3, (x :: xs)) => 3 + x | (SOME _, (x :: xs)) => x`` -val t' = convert_case t +val t' = case2pmatch t val thm_t = PMATCH_INTRO_CONV t val thm_t' = PMATCH_REMOVE_ARB_CONV t' @@ -45,6 +51,9 @@ val example1 = `` || (y,z). (SOME y,SUC z,[1; 2]) ~> y + z ]``; +(* due to guards, the following fails *) +val _ = pmatch2case example1 + val example2 = ``PMATCH (h::t) [PMATCH_ROW (\_ . []) (\_. T) (\_. x); PMATCH_ROW (\_. [2]) (\_. T) (\_. x); @@ -54,6 +63,8 @@ val example2 = ``PMATCH (h::t) (\ (v12,v16,v17). 3); PMATCH_ROW (\_. [2; 4; 3]) (\_. T) (\_. 3 + x)]`` +val _ = pmatch2case example2 + val example3 = `` CASE (NONE,x,xs) OF [ || x. (NONE,x,[]) ~> x; @@ -252,6 +263,30 @@ val t = ``CASE l OF [ ]`` +(*********************************) +(* DIV / MOD *) +(*********************************) + +val my_divmod_def = Define `my_divmod (n:num) c = + CASE n OF [ + || (q, r). q * c + r when r < c ~> (q,r) + ]` + +val my_divmod_THM_AUX = PMATCH_TO_TOP_RULE my_divmod_def + +val my_divmod_THM = store_thm ("my_divmod_THM", +``0 < c ==> (my_divmod n c = (n DIV c, n MOD c))``, + +REPEAT STRIP_TAC THEN +MP_TAC (SPECL [``n:num``, ``c:num``] (CONJUNCT1 my_divmod_THM_AUX)) THEN +Tactical.REVERSE (Cases_on `?q r. (q:num) * c + r = n /\ r < c`) THEN1 ( + METIS_TAC [arithmeticTheory.DIVISION] +) THEN +ASM_REWRITE_TAC[] THEN +REPEAT STRIP_TAC THEN +ASM_SIMP_TAC std_ss [arithmeticTheory.DIV_MULT, arithmeticTheory.MOD_MULT]) + + (*********************************) (* Using non-injective patterns *) (*********************************) diff --git a/examples/deep_matches/deepMatchesLib.sig b/examples/deep_matches/deepMatchesLib.sig index 595cf28256..27eb1bfcb0 100644 --- a/examples/deep_matches/deepMatchesLib.sig +++ b/examples/deep_matches/deepMatchesLib.sig @@ -24,12 +24,15 @@ sig (********************************) - (* turn shallow case-terms into *) - (* deeply embedded ones *) + (* convert between *) + (* case and pmatch *) (********************************) - val convert_case : term -> term + val case2pmatch : term -> term + val pmatch2case : term -> term + val PMATCH_INTRO_CONV : conv + val PMATCH_ELIM_CONV : conv (********************************) diff --git a/examples/deep_matches/deepMatchesLib.sml b/examples/deep_matches/deepMatchesLib.sml index 841b2c9d52..a5cef7c017 100644 --- a/examples/deep_matches/deepMatchesLib.sml +++ b/examples/deep_matches/deepMatchesLib.sml @@ -111,7 +111,7 @@ fun PMATCH_ROW_ARGS_CONV c = (***********************************************) -(* converting case-splits to PMATCH *) +(* converting between case-splits to PMATCH *) (***********************************************) (* @@ -180,14 +180,14 @@ end fun dest_case_fun t = dest_case_fun_aux1 t handle HOL_ERR _ => dest_case_fun_aux2 t -fun convert_case_aux x t = let +fun case2pmatch_aux x t = let val (a, ps) = dest_case_fun t fun process_arg (p, rh) = let val x' = subst [a |-> p] x in (* recursive call *) - case convert_case_aux x' rh of + case case2pmatch_aux x' rh of NONE => [(x', rh)] | SOME resl => resl end @@ -198,7 +198,7 @@ in end handle HOL_ERR _ => NONE; (* convert a case-term into a PMATCH-term, without any proofs *) -fun convert_case t = let +fun case2pmatch t = let val (f, args) = strip_comb t val _ = if (List.null args) then failwith "not a case-split" else () @@ -207,7 +207,7 @@ fun convert_case t = let val v = genvar (type_of p) val t0 = if is_literal_case t then list_mk_comb (f, patterns @ [v]) else list_mk_comb (f, v::patterns) - val ps = case convert_case_aux v t0 of + val ps = case case2pmatch_aux v t0 of NONE => failwith "not a case-split" | SOME ps => ps @@ -224,15 +224,15 @@ in mk_PMATCH p rows_tm_p end -fun PMATCH_INTRO_CONV t = let - val t' = convert_case t +fun case_pmatch_eq_prove t t' = let val tm = mk_eq (t, t') (* very slow, simple approach. Just brute force. TODO: change implementation to get more runtime-speed *) val my_tac = ( CASE_TAC THEN - FULL_SIMP_TAC (rc_ss []) [PMATCH_EVAL, PMATCH_ROW_COND_def] + FULL_SIMP_TAC (rc_ss []) [PMATCH_EVAL, PMATCH_ROW_COND_def, + PMATCH_INCOMPLETE_def] ) in (* set_goal ([], tm) *) @@ -240,6 +240,57 @@ in end handle HOL_ERR _ => raise UNCHANGED +fun PMATCH_INTRO_CONV t = + case_pmatch_eq_prove t (case2pmatch t) + + +(* convert a case-term into a PMATCH-term, without any proofs *) +val t = ``CASE x OF [ + ||. ([], NONE) ~> 0; + || (x,xs,z). (x::xs, SOME z) ~> (x+z); + || (x,xs). (x::xs, NONE) ~> x +]`` + +fun pmatch2case t = let + val (v, rows) = dest_PMATCH t + val fv = genvar (type_of v --> type_of t) + + fun process_row r = let + val (vars_tm, pt, gt, rh) = dest_PMATCH_ROW_ABS r + val _ = if (aconv gt T) then () else + failwith ("guard present in row " ^ + (term_to_string r)) + + val vars = FVL [vars_tm] empty_tmset + val used_vars = FVL [pt] empty_tmset + val free_vars = HOLset.difference (used_vars, vars) + val _ = if (HOLset.isEmpty free_vars) then () else + failwith ("free variables in pattern " ^ (term_to_string pt)) + in + mk_eq (mk_comb (fv, pt), rh) + end + + val row_eqs = map process_row rows + val rows_tm = list_mk_conj row_eqs + + (* compile patterns with parse deep cases turned off *) + val parse_pp = Feedback.current_trace "parse deep cases" + val _ = Feedback.set_trace "parse deep cases" 0 + val case_tm0 = GrammarSpecials.compile_pattern_match rows_tm + val _ = Feedback.set_trace "parse deep cases" parse_pp + + + (* nearly there, now remove lambda's *) + val (vs, case_tm1) = strip_abs case_tm0 + val case_tm = subst [el 2 vs |-> v] case_tm1 +in + case_tm +end + +fun PMATCH_ELIM_CONV t = + case_pmatch_eq_prove t (pmatch2case t) + + (***********************************************) (* removing ARB rows *) (***********************************************) @@ -1174,7 +1225,6 @@ val PMATCH_LIFT_BOOL_CONV_GENCALL_AUX_THM = prove ( ((P1 ==> X1) /\ ((P1 /\ P2) ==> X2))``, REWRITE_TAC [IMP_CONJ_THM, AND_IMP_INTRO]); - fun PMATCH_LIFT_BOOL_CONV_GENCALL rc_arg tm = let (* check whether we should really process tm *) val _ = if type_of tm = bool then () else raise UNCHANGED @@ -1194,12 +1244,12 @@ fun PMATCH_LIFT_BOOL_CONV_GENCALL rc_arg tm = let (* do real work *) val thm0 = PMATCH_LIFT_BOOL_CONV_AUX rc_arg (mk_comb (P_v, p_tm)) - + (* create conjuncts *) val thm1 = let fun c t = (REWR_CONV PMATCH_LIFT_BOOL_CONV_GENCALL_AUX_THM THENC TRY_CONV (RAND_CONV c)) t - val thm1a = CONV_RULE (RHS_CONV (RAND_CONV c)) thm0 + val thm1a = CONV_RULE (RHS_CONV (RAND_CONV c)) thm0 handle HOL_ERR _ => thm0 val c = SIMP_CONV (std_ss++boolSimps.CONJ_ss) [AND_IMP_INTRO, GSYM RIGHT_FORALL_IMP_THM, GSYM CONJ_ASSOC] val thm1b = CONV_RULE (RHS_CONV (EVERY_CONJ_CONV c)) thm1a From 9264e1a20e029446ea07fb4d3d1e13b52a258a8d Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 4 Mar 2015 14:21:20 +1100 Subject: [PATCH 211/718] Improve complexity of charset comparison in regexpMatch --- tools/Holmake/regexpMatch.sml | 15 +++------------ 1 file changed, 3 insertions(+), 12 deletions(-) diff --git a/tools/Holmake/regexpMatch.sml b/tools/Holmake/regexpMatch.sml index 24cc470139..2bbc19b8ca 100644 --- a/tools/Holmake/regexpMatch.sml +++ b/tools/Holmake/regexpMatch.sml @@ -38,22 +38,13 @@ val univ_cset = allchars fun charset_compare(cset1,cset2) = let open Binaryset - fun maxlist m [] = (m,[]) - | maxlist m (h::t) = - let val n = Char.ord h - in if m < n then maxlist n t else maxlist m t - end fun compare [] [] = EQUAL | compare [] _ = LESS | compare _ [] = GREATER | compare (h1::t1) (h2::t2) = - let val (max1,rst1) = maxlist (Char.ord h1) t1 - val (max2,rst2) = maxlist (Char.ord h2) t2 - in - if max1 < max2 then LESS else - if max2 < max1 then GREATER - else compare rst1 rst2 - end + if h1 < h2 then LESS else + if h1 > h2 then GREATER + else compare t1 t2 in if Systeml.pointer_eq(cset1,cset2) then EQUAL else compare (listItems cset1) (listItems cset2) From 5b674df8d3c2bd56783b543f95a61a9354621b8a Mon Sep 17 00:00:00 2001 From: Thomas Tuerk Date: Wed, 4 Mar 2015 08:20:09 +0100 Subject: [PATCH 212/718] deep matches example: provide support for wildcards add some parsing and pretty printing magic to support wildcards in PMATCH patterns --- examples/deep_matches/deepMatchesExamples.sml | 2 +- examples/deep_matches/deepMatchesSyntax.sml | 36 +++++++++++++++++-- 2 files changed, 35 insertions(+), 3 deletions(-) diff --git a/examples/deep_matches/deepMatchesExamples.sml b/examples/deep_matches/deepMatchesExamples.sml index 3286e8d22a..cd93ebcaa4 100644 --- a/examples/deep_matches/deepMatchesExamples.sml +++ b/examples/deep_matches/deepMatchesExamples.sml @@ -40,7 +40,7 @@ val thm_t' = PMATCH_SIMP_CONV t' val example1 = `` CASE (a,x,xs) OF [ - ||. (NONE,4,[]) ~> 0; + ||. (NONE,_,[]) ~> 0; || x. (NONE,x,[]) when x < 10 ~> x; || x. (NONE,x,[2]) ~> x; || (x,v18). (NONE,x,[v18]) ~> 3; diff --git a/examples/deep_matches/deepMatchesSyntax.sml b/examples/deep_matches/deepMatchesSyntax.sml index 5762590250..6e7e87397e 100644 --- a/examples/deep_matches/deepMatchesSyntax.sml +++ b/examples/deep_matches/deepMatchesSyntax.sml @@ -26,6 +26,12 @@ in (t', sub) end; +fun varname_starts_with_uscore v = let + val (s, _) = dest_var v +in + String.sub(s, 0) = #"_" +end handle HOL_ERR _ => false + (***********************************************) (* Terms *) @@ -251,6 +257,29 @@ end val use_pmatch_pp = ref true val _ = Feedback.register_btrace ("use pmatch_pp", use_pmatch_pp); +fun pmatch_printer_fix_wildcards (vars, pat, guard, rh) = let + val var_l = pairSyntax.strip_pair vars + val (wc_l, var_l') = partition varname_starts_with_uscore var_l + + fun mk_fake wc = mk_var (GrammarSpecials.mk_fakeconst_name {fake = "_", original = NONE}, type_of wc) + + val fake_subst = map (fn wc => (wc |-> mk_fake wc)) wc_l + + val vars' = + if (List.null var_l') then + variant (free_varsl [pat, guard, rh]) ``uv:unit`` + else + pairSyntax.list_mk_pair var_l' + + val pat' = Term.subst fake_subst pat + val guard' = Term.subst fake_subst guard + val rh' = Term.subst fake_subst rh +in + (vars', pat', guard', rh') +end handle HOL_ERR _ => (vars, pat, guard, rh) + + + fun pmatch_printer GS backend sys (ppfns:term_pp_types.ppstream_funs) gravs d t = let open Portable term_pp_types smpp @@ -258,8 +287,7 @@ fun pmatch_printer GS backend sys (ppfns:term_pp_types.ppstream_funs) gravs d t val _ = if (!use_pmatch_pp) then () else raise term_pp_types.UserPP_Failed val {add_string,add_break,ublock,add_newline,ustyle,...} = ppfns val (v,rows) = dest_PMATCH t; - - val rows' = map dest_PMATCH_ROW_ABS rows + val rows' = map (fn t => pmatch_printer_fix_wildcards (dest_PMATCH_ROW_ABS t)) rows fun pp_row (vars, pat, guard, rh) = ( term_pp_utils.record_bvars (pairSyntax.strip_pair vars) ( @@ -438,6 +466,10 @@ fun fix_CASE tm = let else if (same_const b_c PMATCH_ROW_magic_3_tm) then (el 1 b_args, T, el 2 b_args) else failwith "unexpected constant"; + val wildcards = List.filter varname_starts_with_uscore ( + free_vars p + ) + val vars = vars @ wildcards in mk_PMATCH_ROW_PABS vars (p, g, r) end From 6f5a96794a427a40271fa706a5c583ed259d98ad Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 5 Mar 2015 13:51:59 +1100 Subject: [PATCH 213/718] Give type annotation so Moscow ML overloads < properly in regexpMatch --- tools/Holmake/regexpMatch.sml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/Holmake/regexpMatch.sml b/tools/Holmake/regexpMatch.sml index 2bbc19b8ca..dda0fdd1a8 100644 --- a/tools/Holmake/regexpMatch.sml +++ b/tools/Holmake/regexpMatch.sml @@ -41,7 +41,7 @@ fun charset_compare(cset1,cset2) = fun compare [] [] = EQUAL | compare [] _ = LESS | compare _ [] = GREATER - | compare (h1::t1) (h2::t2) = + | compare ((h1:char)::t1) (h2::t2) = if h1 < h2 then LESS else if h1 > h2 then GREATER else compare t1 t2 From cd6c9672f7cd60cc17271df86224ebddd1e00743 Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Thu, 5 Mar 2015 16:27:53 +0000 Subject: [PATCH 214/718] Towards decompilation of MIPS. Fails for code with branches. Contains minor changes elsewhere (e.g. handling of endianness and quotations). --- .../l3-machine-code/arm/prog/arm_progLib.sml | 8 +- .../arm/step/arm_stepScript.sml | 4 +- examples/l3-machine-code/common/stateLib.sml | 10 +- examples/l3-machine-code/common/utilsLib.sig | 1 + examples/l3-machine-code/common/utilsLib.sml | 12 ++ .../mips/decompiler/Holmakefile | 22 +++ .../mips/decompiler/mips_decompLib.sig | 5 + .../mips/decompiler/mips_decompLib.sml | 74 +++++++++++ .../mips/prog/mips_progLib.sig | 1 + .../mips/prog/mips_progLib.sml | 125 ++++++++++++++++-- .../mips/prog/mips_progScript.sml | 28 +++- .../mips/step/mips_stepScript.sml | 54 ++++++++ .../x64/decompiler/x64_decompLib.sig | 2 +- .../machine-code/decompiler/decompilerLib.sig | 2 +- .../machine-code/decompiler/decompilerLib.sml | 2 +- 15 files changed, 325 insertions(+), 25 deletions(-) create mode 100644 examples/l3-machine-code/mips/decompiler/Holmakefile create mode 100644 examples/l3-machine-code/mips/decompiler/mips_decompLib.sig create mode 100644 examples/l3-machine-code/mips/decompiler/mips_decompLib.sml diff --git a/examples/l3-machine-code/arm/prog/arm_progLib.sml b/examples/l3-machine-code/arm/prog/arm_progLib.sml index 5d7a095d4d..1f6f6d2a50 100644 --- a/examples/l3-machine-code/arm/prog/arm_progLib.sml +++ b/examples/l3-machine-code/arm/prog/arm_progLib.sml @@ -780,12 +780,6 @@ local List.last o pred_setSyntax.strip_set o temporal_stateSyntax.dest_code' o Thm.concl - val reverse_endian = - fn [a1, a2, a3, a4, a5, a6, a7, a8, b1, b2, b3, b4, b5, b6, b7, b8, - c1, c2, c3, c4, c5, c6, c7, c8, d1, d2, d3, d4, d5, d6, d7, d8] => - [d1, d2, d3, d4, d5, d6, d7, d8, c1, c2, c3, c4, c5, c6, c7, c8, - b1, b2, b3, b4, b5, b6, b7, b8, a1, a2, a3, a4, a5, a6, a7, a8] - | _ => raise ERR "reverse_endian" "" val rev_endian = ref (Lib.I : term list -> term list) val is_be_tm = Term.aconv ``s.CPSR.E`` fun set_endian opt = @@ -793,7 +787,7 @@ local val l = arm_configLib.mk_config_terms opt in if List.exists is_be_tm l - then rev_endian := reverse_endian + then rev_endian := utilsLib.rev_endian else rev_endian := Lib.I end val (reset_db, set_current_opt, get_current_opt, add1_pending, find_spec, diff --git a/examples/l3-machine-code/arm/step/arm_stepScript.sml b/examples/l3-machine-code/arm/step/arm_stepScript.sml index 153b25079b..f882ebb8b4 100644 --- a/examples/l3-machine-code/arm/step/arm_stepScript.sml +++ b/examples/l3-machine-code/arm/step/arm_stepScript.sml @@ -729,8 +729,8 @@ val Aligned_eq = Q.prove( ) val Aligned_numeric = Q.store_thm("Aligned_numeric", - `(!x. Aligned (0w: word32, 4)) /\ - (!x. Aligned (0w: word32, 2)) /\ + `Aligned (0w: word32, 4) /\ + Aligned (0w: word32, 2) /\ (!x. Aligned (n2w (NUMERAL (BIT2 (BIT1 x))): word32, 4)) /\ (!x. Aligned (n2w (NUMERAL (BIT2 x)): word32, 2)) /\ (!x y f. Aligned (y + n2w (NUMERAL (BIT1 (BIT1 (f x)))): word32, 4) = diff --git a/examples/l3-machine-code/common/stateLib.sml b/examples/l3-machine-code/common/stateLib.sml index 667032b56f..98645c2e67 100644 --- a/examples/l3-machine-code/common/stateLib.sml +++ b/examples/l3-machine-code/common/stateLib.sml @@ -1163,13 +1163,19 @@ fun get_pc_delta is_pc = local val ARITH_SUB_CONV = wordsLib.WORD_ARITH_CONV THENC wordsLib.WORD_SUB_CONV + fun is_word_lit tm = + case Lib.total wordsSyntax.dest_mod_word_literal tm of + SOME (n, s) => + n = wordsSyntax.dest_word_literal tm andalso + Lib.funpow (Arbnum.toInt s - 1) Arbnum.div2 n = Arbnum.zero + | NONE => false fun is_irreducible tm = Term.is_var tm orelse (case Lib.total wordsSyntax.dest_word_add tm of - SOME (p, i) => Term.is_var p andalso wordsSyntax.is_word_literal i + SOME (p, i) => Term.is_var p andalso is_word_lit i | NONE => false) orelse (case Lib.total wordsSyntax.dest_word_sub tm of - SOME (p, i) => Term.is_var p andalso wordsSyntax.is_word_literal i + SOME (p, i) => Term.is_var p andalso is_word_lit i | NONE => false) orelse (case Lib.total boolSyntax.dest_cond tm of SOME (_, x, y) => is_irreducible x andalso is_irreducible y diff --git a/examples/l3-machine-code/common/utilsLib.sig b/examples/l3-machine-code/common/utilsLib.sig index 3659f7813b..f63ab44139 100644 --- a/examples/l3-machine-code/common/utilsLib.sig +++ b/examples/l3-machine-code/common/utilsLib.sig @@ -84,6 +84,7 @@ sig val qm_tac: thm list -> tactic val removeSpaces: string -> string val resetStepConv: unit -> unit + val rev_endian: 'a list -> 'a list val rhsc: thm -> term val rng: hol_type -> hol_type val save_as: string -> thm -> thm diff --git a/examples/l3-machine-code/common/utilsLib.sml b/examples/l3-machine-code/common/utilsLib.sml index 621abbd43f..55a91a92e4 100644 --- a/examples/l3-machine-code/common/utilsLib.sml +++ b/examples/l3-machine-code/common/utilsLib.sml @@ -78,6 +78,18 @@ fun classes eq = (* ------------------------------------------------------------------------- *) +local + fun loop a = + fn [] => a + | r => (case Lib.total (Lib.split_after 8) r of + SOME (x, y) => loop (x :: a) y + | NONE => r :: a) +in + fun rev_endian l = List.concat (loop [] l) +end + +(* ------------------------------------------------------------------------- *) + local fun find_pos P = let diff --git a/examples/l3-machine-code/mips/decompiler/Holmakefile b/examples/l3-machine-code/mips/decompiler/Holmakefile new file mode 100644 index 0000000000..f9d253ee31 --- /dev/null +++ b/examples/l3-machine-code/mips/decompiler/Holmakefile @@ -0,0 +1,22 @@ +INCLUDES = ../../common ../prog \ + $(HOLDIR)/examples/machine-code/hoare-triple \ + $(HOLDIR)/examples/machine-code/decompiler +OPTIONS = QUIT_ON_FAILURE + +ifdef POLY +HOLHEAP = local-hol-heap +EXTRA_CLEANS = $(HOLHEAP) $(HOLHEAP).o + +BARE_THYS = ../prog/mips_progLib $(HOLDIR)/examples/machine-code/decompiler/decompilerLib +DEPS = $(patsubst %,%.uo,$(BARE_THYS)) + +THYFILES = $(patsubst %Script.sml,%Theory.uo,$(wildcard *.sml)) +TARGETS = $(patsubst %.sml,%.uo,$(THYFILES)) + +all: $(TARGETS) $(HOLHEAP) +.PHONY: all + +$(HOLHEAP): $(DEPS) + $(protect $(HOLDIR)/bin/buildheap) -b ../prog/mips-step-heap -o $(HOLHEAP) $(BARE_THYS) + +endif diff --git a/examples/l3-machine-code/mips/decompiler/mips_decompLib.sig b/examples/l3-machine-code/mips/decompiler/mips_decompLib.sig new file mode 100644 index 0000000000..608f79f522 --- /dev/null +++ b/examples/l3-machine-code/mips/decompiler/mips_decompLib.sig @@ -0,0 +1,5 @@ +signature mips_decompLib = +sig + val mips_decompile: string -> string quotation -> Thm.thm * Thm.thm + val mips_tools: helperLib.decompiler_tools +end diff --git a/examples/l3-machine-code/mips/decompiler/mips_decompLib.sml b/examples/l3-machine-code/mips/decompiler/mips_decompLib.sml new file mode 100644 index 0000000000..39bdbf4696 --- /dev/null +++ b/examples/l3-machine-code/mips/decompiler/mips_decompLib.sml @@ -0,0 +1,74 @@ +structure mips_decompLib :> mips_decompLib = +struct + +open HolKernel Parse boolLib bossLib +open helperLib set_sepTheory addressTheory progTheory +open pred_setTheory combinTheory +open mips_progLib decompilerLib + +val ERR = Feedback.mk_HOL_ERR "mips_decompLib" + +(* automation *) + +local + fun format_thm th = + let + val c = progSyntax.dest_code (Thm.concl th) + val n = List.length (pred_setSyntax.strip_set c) * 4 + in + (th, n, + stateLib.get_pc_delta + (Lib.equal "mips_prog$MIPS_PC" o fst o + boolSyntax.dest_strip_comb) th) + end +in + fun format_mips_spec hex = + case List.map format_thm (mips_progLib.mips_spec_hex2 hex) of + [x] => (x, NONE) + | [x1, x2] => (x1, SOME x2) + | _ => raise ERR "format_mips_spec" "" +end + +val mips_pc = Term.prim_mk_const {Thy = "mips_prog", Name = "MIPS_PC"} + +val mips_tools = + (format_mips_spec, fn _ => fail(), TRUTH, mips_pc): decompiler_tools + +val mips_decompile = decompilerLib.decompile mips_tools + +(* testing and debugging + +open mips_decompLib + +List.map mips.encodeInstruction + [ + "ori $1, $0, 10", + "daddiu $1, $1, 10" + ] + +List.map mips.encodeInstruction + [ + "ori $1, $0, 10", + "beq $1, $0, 1", + "nop", + "nop" + ] + +val test_def = mips_decompile "test" + `3401000A + 10200001 00000000 + 00000000` + + +val q = (helperLib.quote_to_strings: term quotation -> string list) +val tools = mips_tools +val name = "test" +val fio = NONE: (term * term) option +val code = + `3401000A + 10200001 00000000 + 00000000` + +*) + +end diff --git a/examples/l3-machine-code/mips/prog/mips_progLib.sig b/examples/l3-machine-code/mips/prog/mips_progLib.sig index a172e56a48..570bbbcd9a 100644 --- a/examples/l3-machine-code/mips/prog/mips_progLib.sig +++ b/examples/l3-machine-code/mips/prog/mips_progLib.sig @@ -4,4 +4,5 @@ sig val mips_spec: Term.term -> Thm.thm list val mips_spec_code: string -> Thm.thm list val mips_spec_hex: string -> Thm.thm list + val mips_spec_hex2: string -> Thm.thm list end diff --git a/examples/l3-machine-code/mips/prog/mips_progLib.sml b/examples/l3-machine-code/mips/prog/mips_progLib.sml index 6c20ebf92d..3dcfe826fe 100644 --- a/examples/l3-machine-code/mips/prog/mips_progLib.sml +++ b/examples/l3-machine-code/mips/prog/mips_progLib.sml @@ -27,6 +27,8 @@ val byte = wordsSyntax.mk_int_word_type 8 val word5 = wordsSyntax.mk_int_word_type 5 val word = wordsSyntax.mk_int_word_type 32 val dword = wordsSyntax.mk_int_word_type 64 +val (_, _, dest_BranchTo, _) = mips_1 "mips_BranchTo" +val (_, _, dest_BranchDelay, _) = mips_1 "mips_BranchDelay" val (_, mk_mips_PC, _, _) = mips_1 "mips_PC" val (_, mk_mips_MEM, dest_mips_MEM, is_mips_MEM) = mips_2 "mips_MEM" val (_, mk_mips_gpr, dest_mips_gpr, is_mips_gpr) = mips_2 "mips_gpr" @@ -273,6 +275,22 @@ in val mips_rename = stateLib.rename_vars (mips_rename1, mips_rename2, ["b"]) end +fun spec_BranchTo th = + let + val p = + progSyntax.strip_star (temporal_stateSyntax.dest_pre' (Thm.concl th)) + in + case List.mapPartial (Lib.total dest_BranchTo) p of + [v] => if Term.is_var v + then let + val ty = optionSyntax.dest_option (Term.type_of v) + in + Thm.INST [v |-> optionSyntax.mk_none ty] th + end + else th + | _ => th + end + local fun check_unique_reg_CONV tm = let @@ -446,6 +464,9 @@ local val STATE_TAC = ASM_REWRITE_TAC mips_rwts in val spec = + PURE_REWRITE_RULE [GSYM mips_LE_def, GSYM mips_BE_def] o + stateLib.introduce_triple_definition (false, mips_CONFIG_def) o + spec_BranchTo o stateLib.spec mips_progTheory.MIPS_IMP_SPEC mips_progTheory.MIPS_IMP_TEMPORAL @@ -492,7 +513,8 @@ local Thm.concl val the_spec = ref (mips_spec_opt false) val spec_label_set = ref (Redblackset.empty String.compare) - val spec_rwts = ref (utilsLib.mk_rw_net get_opcode []) + val init_net = utilsLib.mk_rw_net (fn _ => raise ERR "" "") [] + val spec_rwts = ref init_net val add1 = utilsLib.add_to_rw_net get_opcode val add_specs = List.app (fn thm => spec_rwts := add1 (thm, !spec_rwts)) fun find_spec opc = Lib.total (utilsLib.find_rw (!spec_rwts)) opc @@ -504,20 +526,28 @@ local simp_triple_rule (Thm.INST a thm) end fun err e s = raise ERR "mips_spec_hex" (e ^ ": " ^ s) + fun reverse_endian tm = + let + val (l, ty) = listSyntax.dest_list tm + in + listSyntax.mk_list (utilsLib.rev_endian l, ty) + end + val rev_endian = ref (Lib.I: term -> term) in fun mips_config be = - (the_spec := mips_spec_opt be - ; spec_label_set := Redblackset.empty String.compare - ; spec_rwts := utilsLib.mk_rw_net get_opcode []) + ( the_spec := mips_spec_opt be + ; spec_label_set := Redblackset.empty String.compare + ; spec_rwts := init_net + ; rev_endian := (if be then reverse_endian else Lib.I) + ) fun mips_spec s = (!the_spec) s fun addInstruction (s, tm) = if Redblackset.member (!spec_label_set, s) then false - else (print s - ; add_specs (mips_spec tm) - ; print "\n" - ; spec_label_set := Redblackset.add (!spec_label_set, s) - ; true) + else ( print s + ; add_specs (mips_spec tm) + ; spec_label_set := Redblackset.add (!spec_label_set, s) + ; true) fun mips_spec_hex () = (* utilsLib.cache 1000 String.compare *) (fn s => @@ -527,10 +557,11 @@ in let val l = mips_stepLib.mips_find_opc opc in - if List.exists addInstruction l + if (print "\n"; List.exists addInstruction l) then mips_spec_hex () s else err e s end + val opc = !rev_endian opc in case find_spec opc of SOME thms => @@ -545,6 +576,80 @@ in val mips_spec_code = mips_spec_hex o mips.encodeInstruction end +local + val MIPS_PC_INTRO0 = + MIPS_PC_INTRO |> Q.INST [`p1`|->`emp`, `p2`|->`emp`] + |> PURE_REWRITE_RULE [set_sepTheory.SEP_CLAUSES] + fun MP_MIPS_PC_INTRO th = + Lib.tryfind (fn thm => MATCH_MP thm th) + [MIPS_PC_INTRO, MIPS_PC_INTRO0] +in + val mips_pc_intro_rule = + Conv.CONV_RULE + (stateLib.PRE_COND_CONV + (SIMP_CONV (bool_ss++boolSimps.CONJ_ss) []) + THENC helperLib.POST_CONV (stateLib.PC_CONV "mips_prog$MIPS_PC")) o + helperLib.MERGE_CONDS_RULE o + Conv.CONV_RULE + (PURE_REWRITE_CONV [mips_stepTheory.Aligned_numeric] + THENC (Conv.REWR_CONV + (Thm.CONJUNCT1 (Drule.SPEC_ALL boolTheory.IMP_CLAUSES)) + ORELSEC MOVE_COND_CONV)) o + MP_MIPS_PC_INTRO o + Conv.CONV_RULE + (helperLib.POST_CONV + (helperLib.MOVE_OUT_CONV ``mips_BranchDelay`` + THENC helperLib.MOVE_OUT_CONV ``mips_PC``)) o + stateLib.introduce_triple_definition + (false, mips_progTheory.MIPS_PC_def) o + helperLib.MERGE_CONDS_RULE + val spec_join_rule = helperLib.SPEC_COMPOSE_RULE o Lib.list_of_pair +end + +local + val rule = + Conv.CONV_RULE + (Conv.REWR_CONV + (GSYM (REWRITE_RULE [GSYM set_sepTheory.precond_def] + progTheory.SPEC_MOVE_COND))) o Lib.uncurry Thm.DISCH + fun spec_cases b th = + let + val nb = boolSyntax.mk_neg b + val pt = Drule.EQT_INTRO (Thm.ASSUME b) + val nt = Drule.EQF_INTRO (Thm.ASSUME nb) + val pth = PURE_REWRITE_RULE [pt, boolTheory.COND_CLAUSES] th + val _ = Thm.hyp pth = [b] orelse raise ERR "spec_cases" "" + val nth = PURE_REWRITE_RULE [nt, boolTheory.COND_CLAUSES] th + in + [rule (b, pth), rule (nb, nth)] + end +in + fun split_BranchDelay th = + let + val p = progSyntax.strip_star (progSyntax.dest_post (Thm.concl th)) + in + case List.mapPartial (Lib.total dest_BranchDelay) p of + [t] => (case Lib.total boolSyntax.dest_cond t of + SOME (b, _, _) => spec_cases b th + | NONE => [th]) + | _ => [th] + end +end + +fun mips_spec_hex2 s = + List.map mips_pc_intro_rule + (case String.tokens Char.isSpace s of + [s1] => + (case mips_spec_hex s1 of + [th, _] => [th] + | l => raise ERR "mips_spec2_hex" ("Expecting two theorems: " ^ s1)) + | [s1, s2] => + (case (mips_spec_hex s1, mips_spec_hex s2) of + ([th1], [_, th2]) => + List.map (fn t => spec_join_rule (t, th2)) (split_BranchDelay th1) + | _ => raise ERR "mips_spec2_hex" ("Expecting three theorems: " ^ s)) + | _ => raise ERR "mips_spec2_hex" ("More than two strings: " ^ s)) + (* ------------------------------------------------------------------------ *) (* Testing... diff --git a/examples/l3-machine-code/mips/prog/mips_progScript.sml b/examples/l3-machine-code/mips/prog/mips_progScript.sml index 2ff2d7a7f3..dad4f72ab9 100644 --- a/examples/l3-machine-code/mips/prog/mips_progScript.sml +++ b/examples/l3-machine-code/mips/prog/mips_progScript.sml @@ -1,5 +1,5 @@ open HolKernel boolLib bossLib -open stateLib mips_stepTheory +open lcsymtacs stateLib set_sepTheory progTheory mips_stepTheory val () = new_theory "mips_prog" @@ -37,4 +37,30 @@ val MIPS_IMP_TEMPORAL = Theory.save_thm ("MIPS_IMP_TEMPORAL", (* ------------------------------------------------------------------------ *) +val mips_CONFIG_def = Define` + mips_CONFIG be = + mips_exception NoException * mips_exceptionSignalled F * + mips_CP0_Status_RE F * mips_CP0_Config_BE be * mips_BranchTo NONE` + +val mips_LE_def = Define `mips_LE = mips_CONFIG F` +val mips_BE_def = Define `mips_BE = mips_CONFIG T` + +val MIPS_PC_def = Define` + MIPS_PC pc = + mips_BranchDelay NONE * mips_PC pc * cond ((1 >< 0) pc = 0w: word2)` + +(* ------------------------------------------------------------------------ *) + +val MIPS_PC_INTRO = Q.store_thm("MIPS_PC_INTRO", + `SPEC m (p1 * MIPS_PC pc) code + (p2 * mips_BranchDelay NONE * mips_PC pc') ==> + (((1 >< 0) pc = 0w: word2) ==> ((1 >< 0) pc' = 0w: word2)) ==> + SPEC m (p1 * MIPS_PC pc) code (p2 * MIPS_PC pc')`, + REPEAT STRIP_TAC + \\ FULL_SIMP_TAC std_ss + [MIPS_PC_def, SPEC_MOVE_COND, STAR_ASSOC, SEP_CLAUSES] + ) + +(* ------------------------------------------------------------------------ *) + val () = export_theory() diff --git a/examples/l3-machine-code/mips/step/mips_stepScript.sml b/examples/l3-machine-code/mips/step/mips_stepScript.sml index bdfa8784e4..9093cdf0e4 100644 --- a/examples/l3-machine-code/mips/step/mips_stepScript.sml +++ b/examples/l3-machine-code/mips/step/mips_stepScript.sml @@ -652,6 +652,60 @@ val branch_delay = Q.store_thm("branch_delay", (!x. x + 4w + 4w = x + 8w)`, rw [] \\ fs []) +val BIT_lem = Q.prove( + `(!x. NUMERAL (BIT2 x) = 2 * (x + 1)) /\ + (!x. NUMERAL (BIT1 x) = 2 * x + 1) /\ + (!x. NUMERAL (BIT1 (BIT1 x)) = 4 * x + 3) /\ + (!x. NUMERAL (BIT1 (BIT2 x)) = 4 * (x + 1) + 1) /\ + (!x. NUMERAL (BIT2 (BIT1 x)) = 4 * (x + 1)) /\ + (!x. NUMERAL (BIT2 (BIT2 x)) = 4 * (x + 1) + 2)`, + REPEAT strip_tac + \\ CONV_TAC (Conv.LHS_CONV + (REWRITE_CONV [arithmeticTheory.BIT1, arithmeticTheory.BIT2, + arithmeticTheory.NUMERAL_DEF])) + \\ DECIDE_TAC + ) + +val Aligned_eq = Q.prove( + `!a b. (((1 >< 0) (a: word64) = 0w:word2) = + ((1 >< 0) (b: word64) = 0w:word2)) = + (~a ' 0 /\ ~a ' 1 = ~b ' 0 /\ ~b ' 1)`, + blastLib.BBLAST_TAC + ) + +val Aligned_numeric = Q.store_thm("Aligned_numeric", + `((1 >< 0) (0w: word64) = 0w:word2) /\ + (!x. ((1 >< 0) (n2w (NUMERAL (BIT2 (BIT1 x))): word64) = 0w:word2)) /\ + (!x y f. + ((1 >< 0) (y + n2w (NUMERAL (BIT1 (BIT1 (f x)))): word64) = 0w:word2) = + ((1 >< 0) (y + 3w) = 0w:word2)) /\ + (!x y. ((1 >< 0) (y + n2w (NUMERAL (BIT1 (BIT2 x))): word64) = 0w:word2) = + ((1 >< 0) (y + 1w) = 0w:word2)) /\ + (!x y. ((1 >< 0) (y + n2w (NUMERAL (BIT2 (BIT1 x))): word64) = 0w:word2) = + ((1 >< 0) (y) = 0w:word2)) /\ + (!x y. ((1 >< 0) (y + n2w (NUMERAL (BIT2 (BIT2 x))): word64) = 0w:word2) = + ((1 >< 0) (y + 2w) = 0w:word2)) /\ + (!x y f. + ((1 >< 0) (y - n2w (NUMERAL (BIT1 (BIT1 (f x)))): word64) = 0w:word2) = + ((1 >< 0) (y - 3w) = 0w:word2)) /\ + (!x y. ((1 >< 0) (y - n2w (NUMERAL (BIT1 (BIT2 x))): word64) = 0w:word2) = + ((1 >< 0) (y - 1w) = 0w:word2)) /\ + (!x y. ((1 >< 0) (y - n2w (NUMERAL (BIT2 (BIT1 x))): word64) = 0w:word2) = + ((1 >< 0) (y) = 0w:word2)) /\ + (!x y. ((1 >< 0) (y - n2w (NUMERAL (BIT2 (BIT2 x))): word64) = 0w:word2) = + ((1 >< 0) (y - 2w) = 0w:word2))`, + Q.ABBREV_TAC `z = ((1 >< 0) : word64 -> word2)` + \\ REPEAT strip_tac + \\ CONV_TAC (LHS_CONV (ONCE_REWRITE_CONV [BIT_lem])) + \\ Q.UNABBREV_TAC `z` + \\ rewrite_tac [Aligned_eq, GSYM wordsTheory.word_mul_n2w, + GSYM wordsTheory.word_add_n2w] + \\ TRY (markerLib.PAT_ABBREV_TAC (HOLset.empty Term.compare) + ``q = n2w x + 1w : word64``) + \\ TRY (Q.ABBREV_TAC `r = n2w (f x) : word64`) + \\ blastLib.BBLAST_TAC + ) + (* ------------------------------------------------------------------------ *) diff --git a/examples/l3-machine-code/x64/decompiler/x64_decompLib.sig b/examples/l3-machine-code/x64/decompiler/x64_decompLib.sig index a468d2ff52..e19053b9f2 100644 --- a/examples/l3-machine-code/x64/decompiler/x64_decompLib.sig +++ b/examples/l3-machine-code/x64/decompiler/x64_decompLib.sig @@ -1,5 +1,5 @@ signature x64_decompLib = sig - val x64_decompile: string -> Term.term quotation -> Thm.thm * Thm.thm + val x64_decompile: string -> string quotation -> Thm.thm * Thm.thm val x64_decompile_code: string -> string quotation -> Thm.thm * Thm.thm end diff --git a/examples/machine-code/decompiler/decompilerLib.sig b/examples/machine-code/decompiler/decompilerLib.sig index ff6478dce1..411e18bd99 100644 --- a/examples/machine-code/decompiler/decompilerLib.sig +++ b/examples/machine-code/decompiler/decompilerLib.sig @@ -5,7 +5,7 @@ sig val decompile_with : ('a -> string list) -> decompiler_tools -> string -> 'a -> thm * thm - val decompile : decompiler_tools -> string -> term quotation -> thm * thm + val decompile : decompiler_tools -> string -> string quotation -> thm * thm val decompile_strings : decompiler_tools -> string -> string list -> thm * thm diff --git a/examples/machine-code/decompiler/decompilerLib.sml b/examples/machine-code/decompiler/decompilerLib.sml index f7d77f4bac..819217cb29 100644 --- a/examples/machine-code/decompiler/decompilerLib.sml +++ b/examples/machine-code/decompiler/decompilerLib.sml @@ -1856,7 +1856,7 @@ val decompile_io = decompile_io_with (helperLib.quote_to_strings: term quotation -> string list) val decompile = - decompile_with (helperLib.quote_to_strings: term quotation -> string list) + decompile_with (helperLib.quote_to_strings: string quotation -> string list) val decompile_io_strings = decompile_io_with I val decompile_strings = decompile_with I From 89820a56c85cc0bdf308e6579565541a5761c6fd Mon Sep 17 00:00:00 2001 From: Thomas Tuerk Date: Thu, 5 Mar 2015 20:13:55 +0100 Subject: [PATCH 215/718] deep matches example: more work on pattern compilation - choose between different selector families - work on congruence theorems for non-exhaustive families There is still plenty more to do. Basic pattern compilation works, but the details are unstable. Especially with respect to congruence rules, renaming variables and even potentially looping. --- examples/deep_matches/constrFamiliesLib.sig | 4 + examples/deep_matches/constrFamiliesLib.sml | 64 ++++++++++++- examples/deep_matches/deepMatchesExamples.sml | 94 +++++++++++++++++-- examples/deep_matches/deepMatchesLib.sml | 19 +++- examples/deep_matches/deepMatchesSyntax.sml | 4 +- 5 files changed, 168 insertions(+), 17 deletions(-) diff --git a/examples/deep_matches/constrFamiliesLib.sig b/examples/deep_matches/constrFamiliesLib.sig index 4290f99ba3..9d713b3096 100644 --- a/examples/deep_matches/constrFamiliesLib.sig +++ b/examples/deep_matches/constrFamiliesLib.sig @@ -35,6 +35,10 @@ sig of the type can be constructed via a constructor in this list *) val mk_constructorList : bool -> constructor list -> constructorList + (* [make_constructorList exh constrs] is a convenience functions + that maps [mk_constructor] over constrs before calling + [mk_constructorList]. *) + val make_constructorList : bool -> (term * string list) list -> constructorList (************************) (* Constructor Families *) diff --git a/examples/deep_matches/constrFamiliesLib.sml b/examples/deep_matches/constrFamiliesLib.sml index b99167344e..1a55f3d5ab 100644 --- a/examples/deep_matches/constrFamiliesLib.sml +++ b/examples/deep_matches/constrFamiliesLib.sml @@ -159,6 +159,9 @@ in cl_is_exhaustive = is_exhaustive }:constructorList end +fun make_constructorList is_exhaustive constrs = + mk_constructorList is_exhaustive (List.map + (uncurry mk_constructor) constrs) (***************************************************) (* Constructor Families *) @@ -411,6 +414,58 @@ in end end handle HOL_ERR _ => NONE +(* Datatype for representing how well a constructorFamily + matches a column. *) +type constructorFamily_col_stats = { + cfcs_missed_rows : int, + (* how many rows of the col are not constructor applications + or bound vars? *) + + cfcs_missed_constr : int + (* how many constructors of the family do not appear in the column *) +} + +fun measure_constructorFamily (cf : constructorFamily) col = let + fun list_count p col = + foldl (fn (r, c) => if (p r) then c+1 else c) 0 col + + (* extract the constructors of the family *) + val crs = List.map (fn (CONSTR (c, _)) => c) ( + #cl_constructors (#constructors cf)) + + fun row_is_missed (vs, p) = + if (is_var p andalso mem p vs) then + (* bound variables are fine *) + false + else let + val (f, _) = strip_comb p + in + not (List.exists (same_const f) crs) + end handle HOL_ERR _ => true + + fun constr_is_missed c = + not (List.exists (fn (vs, p) => let + val (f, _) = strip_comb p + in + same_const f c + end handle HOL_ERR _ => false) col) + +in + { + cfcs_missed_rows = list_count row_is_missed col, + cfcs_missed_constr = list_count constr_is_missed crs + } +end + +fun constructorFamily_col_stats_compare + (st1:constructorFamily_col_stats) + (st2 : constructorFamily_col_stats) = + + (#cfcs_missed_rows st1 < #cfcs_missed_rows st2) orelse + ( (#cfcs_missed_rows st1 = #cfcs_missed_rows st2) andalso + (#cfcs_missed_constr st1 < #cfcs_missed_constr st2) ) + + fun lookup_constructorFamilies (db : pmatch_compile_db) col = let val _ = if (List.null col) then (failwith "constructorFamiliesLib" "lookup_constructorFamilies: null col") else () val ty = type_of (snd (hd col)) @@ -424,10 +479,15 @@ fun lookup_constructorFamilies (db : pmatch_compile_db) col = let NONE => [] | SOME (ty, cf) => [(ty, cf)] in cts_fams' @ cty_l end + + val weighted_fams = List.map (fn (ty, cf) => + ((ty, cf), measure_constructorFamily cf col)) cts_fams + val weighted_fams_sorted = sort (fn (_, w1) => fn (_, w2) => + constructorFamily_col_stats_compare w1 w2) weighted_fams in - case cts_fams of + case weighted_fams_sorted of [] => NONE - | cs::_ => SOME cs + | (cs, _)::_ => SOME cs end; diff --git a/examples/deep_matches/deepMatchesExamples.sml b/examples/deep_matches/deepMatchesExamples.sml index cd93ebcaa4..9c4cb9a592 100644 --- a/examples/deep_matches/deepMatchesExamples.sml +++ b/examples/deep_matches/deepMatchesExamples.sml @@ -240,13 +240,13 @@ val list_REVCASE_THM = prove (`` ((list_REVCASE [] c_nil c_snoc) = c_nil) /\ ((list_REVCASE (SNOC x xs) c_nil c_snoc) = c_snoc x xs)``, SIMP_TAC list_ss [list_REVCASE_def, rich_listTheory.NOT_SNOC_NIL]) + +val cl = make_constructorList true [ + (``[]:'a list``, []), + (``SNOC: 'a -> 'a list -> 'a list``, ["x", "xs"]) +] -val c_nil = mk_constructor ``[]:'a list`` [] -val c_snoc = mk_constructor ``SNOC: 'a -> 'a list -> 'a list`` - ["x", "xs"] - -val cl = mk_constructorList true [c_nil, c_snoc] - +(* set_constructorFamily (cl, ``list_REVCASE``) *) val cf = mk_constructorFamily (cl, ``list_REVCASE``, SIMP_TAC list_ss [rich_listTheory.NOT_SNOC_NIL] THEN REPEAT STRIP_TAC THENL [ @@ -257,11 +257,91 @@ val cf = mk_constructorFamily (cl, ``list_REVCASE``, ] ) +(* add this family *) +val _ = pmatch_compile_db_register_constrFam cf + val t = ``CASE l OF [ ||. [] ~> 0; - || (x, xs). SNOC x xs ~> x + || x. SNOC x _ ~> x + ]`` + +val thm = PMATCH_CASE_SPLIT_CONV (fn _ => 0) t + +val t = ``CASE lx OF [ + ||. ([], NONE) ~> 0; + || (x, y). (SNOC x _, SOME y) ~> x + y + ]``; + +val thm = PMATCH_CASE_SPLIT_CONV (fn _ => 0) t; + +val t = ``CASE lx OF [ + ||. [] ~> 0; + || x. x::_ ~> x + y ]`` +val thm = PMATCH_CASE_SPLIT_CONV (fn _ => 0) t; + + +(* A nonexhaustive family *) + +val tree_case_def = DB.fetch "-" "tree_case_def"; + +val tree_red_CASE_def = Define ` + tree_red_CASE tr f_red f_else = + tree_CASE tr (f_else Empty) f_red + (\t1 n t2. f_else (Black t1 n t2))` + +val tree_red_CASE_THM = prove (`` + (tree_red_CASE Empty f_red f_else = f_else Empty) /\ + (tree_red_CASE (Red t1 n t2) f_red f_else = f_red t1 n t2) /\ + (tree_red_CASE (Black t1 n t2) f_red f_else = f_else (Black t1 n t2))``, +SIMP_TAC list_ss [tree_red_CASE_def, tree_case_def]) + +(* for now the congurence needs to be set up manually, + this will be automated soon *) +val tree_red_CASE_cong = store_thm ("tree_red_CASE_cong", +``!M M' f f1 f' f1'. + (M = M') ==> + (!a0 a1 a2. (M' = Red a0 a1 a2) ==> (f a0 a1 a2 = f' a0 a1 a2)) ==> + (!x. (x = M') /\ (!a0 a1 a2. ~(M' = Red a0 a1 a2)) ==> (f1 x = f1' x)) ==> + (tree_red_CASE M f f1 = tree_red_CASE M' f' f1')``, + +SIMP_TAC std_ss [tree_red_CASE_def] THEN +Cases_on `M'` THEN +SIMP_TAC (srw_ss()) []); + +val cl = make_constructorList false [ + (``Red``, ["t1", "n", "t2"]) +] + +(* set_constructorFamily (cl, ``tree_red_CASE``) *) +val cf = mk_constructorFamily (cl, ``tree_red_CASE``, + SIMP_TAC (srw_ss()) [tree_red_CASE_def] THEN + Cases_on `x` THEN + SIMP_TAC (srw_ss()) [tree_red_CASE_def]); + +val _ = pmatch_compile_db_register_constrFam cf; + +val _ = pmatch_compile_db_register_ssfrag + (simpLib.rewrites [Cong tree_red_CASE_cong]); + +val my_conv = ( + (PMATCH_CASE_SPLIT_CONV (fn _ => 0)) THENC + (SIMP_CONV (std_ss++PMATCH_SIMP_ss) [Cong tree_red_CASE_cong])) + +val balance_black_dectree_def2 = CONV_RULE + ((TOP_SWEEP_CONV my_conv) THENC + (SIMP_CONV std_ss [pairTheory.pair_case_thm])) + balance_black_def + +val balance_black_dectree_def3 = CONV_RULE + (TOP_SWEEP_CONV PMATCH_ELIM_CONV) + balance_black_def + +val size_new = term_size (rhs (snd (strip_forall (concl balance_black_dectree_def2)))) +val size_old = term_size (rhs (snd (strip_forall (concl balance_black_dectree_def)))) +val size_classic = term_size (rhs (snd (strip_forall (concl balance_black_dectree_def3)))) + (*********************************) (* DIV / MOD *) diff --git a/examples/deep_matches/deepMatchesLib.sml b/examples/deep_matches/deepMatchesLib.sml index a5cef7c017..ed32e1ef50 100644 --- a/examples/deep_matches/deepMatchesLib.sml +++ b/examples/deep_matches/deepMatchesLib.sml @@ -1445,7 +1445,7 @@ fun PMATCH_CASE_SPLIT_CONV_GENCALL rc_arg db col_heu t = let val t'' = mk_pair (free_vars t') [] col_no v val thm1_tm = mk_eq (t', t'') - val thm1 = prove (thm1_tm, SIMP_TAC std_ss [pairTheory.pair_case_def]) + val thm1 = prove (thm1_tm, SIMP_TAC std_ss [pairTheory.pair_CASE_def]) val thm2 = CONV_RULE (RHS_CONV ( (TOP_SWEEP_CONV ( @@ -1453,14 +1453,23 @@ fun PMATCH_CASE_SPLIT_CONV_GENCALL rc_arg db col_heu t = let )))) thm1 val thm3 = TRANS thm0 thm2 - val thm4 = CONV_RULE (RHS_CONV REMOVE_REBIND_CONV) thm3 + + (* check whether it got simpler *) + val _ = let + val r = rhs (concl thm3) + val i = ((find_term (aconv t) r; true) handle HOL_ERR _ => false) + in + if i then failwith "loop" else () + end + +(* val thm4 = CONV_RULE (RHS_CONV REMOVE_REBIND_CONV) thm3 *) in - thm4 + thm3 end fun PMATCH_CASE_SPLIT_CONV_GEN ssl = PMATCH_CASE_SPLIT_CONV_GENCALL (ssl, NONE) -fun PMATCH_CASE_SPLIT_CONV colHeu t = - PMATCH_CASE_SPLIT_CONV_GEN [] (!thePmatchCompileDB) colHeu t +fun PMATCH_CASE_SPLIT_CONV col_heu t = + PMATCH_CASE_SPLIT_CONV_GEN [] (!thePmatchCompileDB) col_heu t end diff --git a/examples/deep_matches/deepMatchesSyntax.sml b/examples/deep_matches/deepMatchesSyntax.sml index 6e7e87397e..c622eb0df6 100644 --- a/examples/deep_matches/deepMatchesSyntax.sml +++ b/examples/deep_matches/deepMatchesSyntax.sml @@ -58,8 +58,6 @@ val PMATCH_gtm = inst ty_var_subst PMATCH_tm fun FRESH_TY_VARS_RULE thm = INST_TYPE ty_var_subst thm -val t = ``\x. P (\x. ss x) x`` - fun REMOVE_REBIND_CONV_AUX avoid t = let val (v, t') = dest_abs t val v' = variant avoid v @@ -70,7 +68,7 @@ in end handle HOL_ERR _ => let val (t1, t2) = dest_comb t val (t1', avoid1) = REMOVE_REBIND_CONV_AUX avoid t1 - val (t2', avoid2) = REMOVE_REBIND_CONV_AUX avoid t2 + val (t2', avoid2) = REMOVE_REBIND_CONV_AUX avoid1 t2 in (mk_comb (t1', t2'), avoid2) end handle HOL_ERR _ => (t, avoid) From 5ec545e687254f858950218bad8df5a9e9bbfd72 Mon Sep 17 00:00:00 2001 From: Magnus Myreen Date: Thu, 5 Mar 2015 19:36:03 +0000 Subject: [PATCH 216/718] show bug (and its fix) in the new MIPS-decomp tools --- .../mips/decompiler/mips_decompLib.sml | 21 +++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/examples/l3-machine-code/mips/decompiler/mips_decompLib.sml b/examples/l3-machine-code/mips/decompiler/mips_decompLib.sml index 39bdbf4696..22411be9f0 100644 --- a/examples/l3-machine-code/mips/decompiler/mips_decompLib.sml +++ b/examples/l3-machine-code/mips/decompiler/mips_decompLib.sml @@ -69,6 +69,27 @@ val code = 10200001 00000000 00000000` +val MIPS_PC_SIMP = prove( + ``(r * MIPS_PC pc * cond ((1 >< 0) pc = 0w:word2) = r * MIPS_PC pc) /\ + (MIPS_PC pc * cond ((1 >< 0) pc = 0w:word2) = MIPS_PC pc)``, + FULL_SIMP_TAC (std_ss++sep_cond_ss) [mips_progTheory.MIPS_PC_def]); + +local + val f = #1 mips_tools + fun map_inst r ((th1,x1,x2),NONE) = ((r th1,x1,x2),NONE) + | map_inst r ((th1,x1,x2),SOME (th2,y1,y2)) = + ((r th1,x1,x2),SOME (r th2,y1,y2)) +in + val new_mips_tools = + (map_inst (REWRITE_RULE [MIPS_PC_SIMP]) o f, + #2 mips_tools, #3 mips_tools, #4 mips_tools) +end + +val res = decompilerLib.decompile new_mips_tools "test" + `3401000A + 10200001 00000000 + 00000000` + *) end From 29db124917825f61e5aa04bded3b7b59ff07006d Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 6 Mar 2015 14:27:37 +1100 Subject: [PATCH 217/718] Some test-cases for LaTeX munging with/without type abbreviations Inspired by a message to hol-info by Ramana Kumar. --- src/TeX/theory_tests/.gitignore | 2 ++ src/TeX/theory_tests/Holmakefile | 27 +++++++++++++++++++++-- src/TeX/theory_tests/tyabb_input | 1 + src/TeX/theory_tests/tyabbexpected | 1 + src/TeX/theory_tests/tyabbrevScript.sml | 9 ++++++++ src/TeX/theory_tests/untyabbrevScript.sml | 10 +++++++++ src/TeX/theory_tests/utyabbexpected | 1 + 7 files changed, 49 insertions(+), 2 deletions(-) create mode 100644 src/TeX/theory_tests/tyabb_input create mode 100644 src/TeX/theory_tests/tyabbexpected create mode 100644 src/TeX/theory_tests/tyabbrevScript.sml create mode 100644 src/TeX/theory_tests/untyabbrevScript.sml create mode 100644 src/TeX/theory_tests/utyabbexpected diff --git a/src/TeX/theory_tests/.gitignore b/src/TeX/theory_tests/.gitignore index 53752db253..397aaad032 100644 --- a/src/TeX/theory_tests/.gitignore +++ b/src/TeX/theory_tests/.gitignore @@ -1 +1,3 @@ output +tyabb_output +utyabb_output diff --git a/src/TeX/theory_tests/Holmakefile b/src/TeX/theory_tests/Holmakefile index 3e9eb045a5..3b9d182be0 100644 --- a/src/TeX/theory_tests/Holmakefile +++ b/src/TeX/theory_tests/Holmakefile @@ -2,15 +2,38 @@ CMPDIR = $(protect $(HOLDIR)/tools/cmp) INCLUDES = $(CMPDIR) -.PHONY: check_output +THYFILES = $(patsubst %Script.sml,%Theory.uo,$(wildcard *.sml)) +TARGETS = $(patsubst %.sml,%.uo,$(THYFILES)) + +all: check_output check_utyabb_output check_tyabb_output $(TARGETS) check_output: output expected-output $(CMPDIR)/cmp.exe output expected-output +check_utyabb_output: utyabb_output utyabbexpected + $(CMPDIR)/cmp.exe utyabb_output utyabbexpected + +check_tyabb_output: tyabb_output tyabbexpected + $(CMPDIR)/cmp.exe tyabb_output tyabbexpected + output: input munge.exe ./munge.exe < $< > $@ +tyabb_output: tyabb_input tymunge.exe + ./tymunge.exe < $< > $@ + +utyabb_output: tyabb_input utymunge.exe + ./utymunge.exe < $< > $@ + munge.exe: mdtTheory.uo $(protect $(HOLDIR)/bin/mkmunge.exe) mdtTheory -EXTRA_CLEANS = output munge.exe +tymunge.exe: tyabbrevTheory.uo + $(protect $(HOLDIR)/bin/mkmunge.exe) -o $@ tyabbrevTheory + +utymunge.exe: untyabbrevTheory.uo + $(protect $(HOLDIR)/bin/mkmunge.exe) -o $@ untyabbrevTheory + +.PHONY: all check_output check_utyabb_output check_tyabb_output + +EXTRA_CLEANS = munge.exe tymunge.exe utymunge.exe output utyabb_output tyabb_output diff --git a/src/TeX/theory_tests/tyabb_input b/src/TeX/theory_tests/tyabb_input new file mode 100644 index 0000000000..85d2796748 --- /dev/null +++ b/src/TeX/theory_tests/tyabb_input @@ -0,0 +1 @@ +\HOLty[of]{(=)} diff --git a/src/TeX/theory_tests/tyabbexpected b/src/TeX/theory_tests/tyabbexpected new file mode 100644 index 0000000000..c8e581fef4 --- /dev/null +++ b/src/TeX/theory_tests/tyabbexpected @@ -0,0 +1 @@ +\HOLinline{\ensuremath{\alpha} \HOLTyOp{reln}} diff --git a/src/TeX/theory_tests/tyabbrevScript.sml b/src/TeX/theory_tests/tyabbrevScript.sml new file mode 100644 index 0000000000..5629b0a411 --- /dev/null +++ b/src/TeX/theory_tests/tyabbrevScript.sml @@ -0,0 +1,9 @@ +open HolKernel Parse boolLib bossLib; + +val _ = new_theory "tyabbrev"; + +val _ = type_abbrev("reln", ``:'a -> 'a -> bool``) + +val thm1 = save_thm("thm1", TRUTH) + +val _ = export_theory(); diff --git a/src/TeX/theory_tests/untyabbrevScript.sml b/src/TeX/theory_tests/untyabbrevScript.sml new file mode 100644 index 0000000000..a9750359f9 --- /dev/null +++ b/src/TeX/theory_tests/untyabbrevScript.sml @@ -0,0 +1,10 @@ +open HolKernel Parse boolLib bossLib; + +open tyabbrevTheory + +val _ = new_theory "untyabbrev"; + +val _ = Parse.disable_tyabbrev_printing "reln" + + +val _ = export_theory(); diff --git a/src/TeX/theory_tests/utyabbexpected b/src/TeX/theory_tests/utyabbexpected new file mode 100644 index 0000000000..441f17f058 --- /dev/null +++ b/src/TeX/theory_tests/utyabbexpected @@ -0,0 +1 @@ +\HOLinline{\ensuremath{\alpha} -> \ensuremath{\alpha} -> \HOLTyOp{bool}} From e9d0138fd1b52b267d55b5d7e79327e0290b9a7f Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Fri, 6 Mar 2015 13:27:09 +0000 Subject: [PATCH 218/718] Fix for MIPS decompilation. Basic programs seem to be decompiling now. --- .../mips/decompiler/mips_decompLib.sml | 49 +++--------- .../mips/prog/mips_progLib.sml | 14 ++-- .../mips/step/mips_stepLib.sml | 76 ++++++++++--------- 3 files changed, 60 insertions(+), 79 deletions(-) diff --git a/examples/l3-machine-code/mips/decompiler/mips_decompLib.sml b/examples/l3-machine-code/mips/decompiler/mips_decompLib.sml index 22411be9f0..bf25e30aa7 100644 --- a/examples/l3-machine-code/mips/decompiler/mips_decompLib.sml +++ b/examples/l3-machine-code/mips/decompiler/mips_decompLib.sml @@ -43,52 +43,27 @@ open mips_decompLib List.map mips.encodeInstruction [ "ori $1, $0, 10", - "daddiu $1, $1, 10" + "bne $1, $0, 0xFFFF", + "daddiu $1, $1, 0xFFFF" ] +val (text_cert, test_def) = mips_decompile "test" + `3401000A + 1420FFFF 6421FFFF` + +val () = computeLib.add_funs [test_def] + +EVAL ``test 0w`` + List.map mips.encodeInstruction [ "ori $1, $0, 10", - "beq $1, $0, 1", - "nop", - "nop" + "beq $1, $0, 1" ] val test_def = mips_decompile "test" `3401000A - 10200001 00000000 - 00000000` - - -val q = (helperLib.quote_to_strings: term quotation -> string list) -val tools = mips_tools -val name = "test" -val fio = NONE: (term * term) option -val code = - `3401000A - 10200001 00000000 - 00000000` - -val MIPS_PC_SIMP = prove( - ``(r * MIPS_PC pc * cond ((1 >< 0) pc = 0w:word2) = r * MIPS_PC pc) /\ - (MIPS_PC pc * cond ((1 >< 0) pc = 0w:word2) = MIPS_PC pc)``, - FULL_SIMP_TAC (std_ss++sep_cond_ss) [mips_progTheory.MIPS_PC_def]); - -local - val f = #1 mips_tools - fun map_inst r ((th1,x1,x2),NONE) = ((r th1,x1,x2),NONE) - | map_inst r ((th1,x1,x2),SOME (th2,y1,y2)) = - ((r th1,x1,x2),SOME (r th2,y1,y2)) -in - val new_mips_tools = - (map_inst (REWRITE_RULE [MIPS_PC_SIMP]) o f, - #2 mips_tools, #3 mips_tools, #4 mips_tools) -end - -val res = decompilerLib.decompile new_mips_tools "test" - `3401000A - 10200001 00000000 - 00000000` + 10200001 00000000` *) diff --git a/examples/l3-machine-code/mips/prog/mips_progLib.sml b/examples/l3-machine-code/mips/prog/mips_progLib.sml index 3dcfe826fe..831512ebca 100644 --- a/examples/l3-machine-code/mips/prog/mips_progLib.sml +++ b/examples/l3-machine-code/mips/prog/mips_progLib.sml @@ -586,15 +586,11 @@ local in val mips_pc_intro_rule = Conv.CONV_RULE - (stateLib.PRE_COND_CONV - (SIMP_CONV (bool_ss++boolSimps.CONJ_ss) []) - THENC helperLib.POST_CONV (stateLib.PC_CONV "mips_prog$MIPS_PC")) o - helperLib.MERGE_CONDS_RULE o - Conv.CONV_RULE - (PURE_REWRITE_CONV [mips_stepTheory.Aligned_numeric] + (Conv.LAND_CONV (REWRITE_CONV [mips_stepTheory.Aligned_numeric]) THENC (Conv.REWR_CONV (Thm.CONJUNCT1 (Drule.SPEC_ALL boolTheory.IMP_CLAUSES)) - ORELSEC MOVE_COND_CONV)) o + ORELSEC MOVE_COND_CONV) + THENC helperLib.POST_CONV (stateLib.PC_CONV "mips_prog$MIPS_PC")) o MP_MIPS_PC_INTRO o Conv.CONV_RULE (helperLib.POST_CONV @@ -602,6 +598,10 @@ in THENC helperLib.MOVE_OUT_CONV ``mips_PC``)) o stateLib.introduce_triple_definition (false, mips_progTheory.MIPS_PC_def) o + Conv.CONV_RULE + (stateLib.PRE_COND_CONV + (SIMP_CONV (bool_ss++boolSimps.CONJ_ss) + [mips_stepTheory.Aligned_numeric])) o helperLib.MERGE_CONDS_RULE val spec_join_rule = helperLib.SPEC_COMPOSE_RULE o Lib.list_of_pair end diff --git a/examples/l3-machine-code/mips/step/mips_stepLib.sml b/examples/l3-machine-code/mips/step/mips_stepLib.sml index 37dc2fde49..c58416ef89 100644 --- a/examples/l3-machine-code/mips/step/mips_stepLib.sml +++ b/examples/l3-machine-code/mips/step/mips_stepLib.sml @@ -217,13 +217,19 @@ val dEV = ``~NotWordValue (^st.gpr (rs))``, ``~NotWordValue (^st.gpr (rt))``]] [[], [`rs` |-> r0]] +val bbEV = + EVC [dfn'BEQ_def, dfn'BNE_def, dfn'BEQL_def, dfn'BNEL_def, + ConditionalBranch_def, ConditionalBranchLikely_def] + [[``^st.BranchDelay = NONE``, ``rs <> 0w: word5``, ``rt <> 0w: word5``]] + (all_comb [`rt` |-> r0, `rs` |-> r0]) + val bEV = - EVC [dfn'BEQ_def, dfn'BEQ_def, dfn'BNE_def, dfn'BLEZ_def, dfn'BGTZ_def, - dfn'BLTZ_def, dfn'BGEZ_def, dfn'BLTZAL_def, dfn'BGEZAL_def, - dfn'BEQL_def, dfn'BNEL_def, dfn'BLEZL_def, dfn'BGTZL_def, + EVC [dfn'BLEZ_def, dfn'BGTZ_def, dfn'BLTZ_def, dfn'BGEZ_def, + dfn'BLTZAL_def, dfn'BGEZAL_def, dfn'BLEZL_def, dfn'BGTZL_def, dfn'BLTZL_def, dfn'BGEZL_def, dfn'BLTZALL_def, dfn'BGEZALL_def, ConditionalBranch_def, ConditionalBranchLikely_def] - [[``^st.BranchDelay = NONE``]] [] + [[``^st.BranchDelay = NONE``, ``rs <> 0w: word5``]] + [[], [`rs` |-> r0]] (* ------------------------------------------------------------------------- *) @@ -308,16 +314,16 @@ val J = EV [dfn'J_def] [] [] ``dfn'J (instr_index)`` val JAL = EV [dfn'JAL_def] [] [] ``dfn'JAL (instr_index)`` val JR = EV [dfn'JR_def] [] [] ``dfn'JR (instr_index)`` val JALR = hEV ``dfn'JALR (rs, rd)`` -val BEQ = bEV ``dfn'BEQ (rs, rt, offset)`` -val BNE = bEV ``dfn'BNE (rs, rt, offset)`` +val BEQ = bbEV ``dfn'BEQ (rs, rt, offset)`` +val BNE = bbEV ``dfn'BNE (rs, rt, offset)`` +val BEQL = bbEV ``dfn'BEQL (rs, rt, offset)`` +val BNEL = bbEV ``dfn'BNEL (rs, rt, offset)`` val BLEZ = bEV ``dfn'BLEZ (rs, offset)`` val BGTZ = bEV ``dfn'BGTZ (rs, offset)`` val BLTZ = bEV ``dfn'BLTZ (rs, offset)`` val BGEZ = bEV ``dfn'BGEZ (rs, offset)`` val BLTZAL = bEV ``dfn'BLTZAL (rs, offset)`` val BGEZAL = bEV ``dfn'BGEZAL (rs, offset)`` -val BEQL = bEV ``dfn'BEQL (rs, rt, offset)`` -val BNEL = bEV ``dfn'BNEL (rs, rt, offset)`` val BLEZL = bEV ``dfn'BLEZL (rs, offset)`` val BGTZL = bEV ``dfn'BGTZL (rs, offset)`` val BLTZL = bEV ``dfn'BLTZL (rs, offset)`` @@ -702,7 +708,11 @@ val mips_ipatterns = List.map (I ## utilsLib.pattern) ("MADDU", "FTTTFF__________FFFFFFFFFFFFFFFT"), ("MSUB", "FTTTFF__________FFFFFFFFFFFFFTFF"), ("MSUBU", "FTTTFF__________FFFFFFFFFFFFFTFT"), - ("MUL", "FTTTFF_______________FFFFFFFFFTF") + ("MUL", "FTTTFF_______________FFFFFFFFFTF"), + ("BEQ", "FFFTFF__________________________"), + ("BNE", "FFFTFT__________________________"), + ("BEQL", "FTFTFF__________________________"), + ("BNEL", "FTFTFT__________________________") ] val mips_dpatterns = List.map (I ## utilsLib.pattern) @@ -751,26 +761,15 @@ val mips_jpatterns = List.map (I ## utilsLib.pattern) val mips_patterns0 = List.map (I ## utilsLib.pattern) [ - ("LUI", "FFTTTTFFFFF_____________________"), - ("DIV", "FFFFFF__________FFFFFFFFFFFTTFTF"), - ("DIVU", "FFFFFF__________FFFFFFFFFFFTTFTT"), - ("DDIV", "FFFFFF__________FFFFFFFFFFFTTTTF"), - ("DDIVU", "FFFFFF__________FFFFFFFFFFFTTTTT"), - ("MTHI", "FFFFFF_____FFFFFFFFFFFFFFFFTFFFT"), - ("MTLO", "FFFFFF_____FFFFFFFFFFFFFFFFTFFTT"), - ("MFHI", "FFFFFFFFFFFFFFFF_____FFFFFFTFFFF"), - ("MFLO", "FFFFFFFFFFFFFFFF_____FFFFFFTFFTF") - ] - -val mips_cpatterns = List.map (I ## utilsLib.pattern) - [ - ("MFC0", "FTFFFFFFFFF__________FFFFFFFF___"), - ("MTC0", "FTFFFFFFTFF__________FFFFFFFF___") - ] - -val mips_patterns = List.map (I ## utilsLib.pattern) - [ - ("JR", "FFFFFF_____FFFFFFFFFF_____FFTFFF"), + ("LUI", "FFTTTTFFFFF_____________________"), + ("DIV", "FFFFFF__________FFFFFFFFFFFTTFTF"), + ("DIVU", "FFFFFF__________FFFFFFFFFFFTTFTT"), + ("DDIV", "FFFFFF__________FFFFFFFFFFFTTTTF"), + ("DDIVU", "FFFFFF__________FFFFFFFFFFFTTTTT"), + ("MTHI", "FFFFFF_____FFFFFFFFFFFFFFFFTFFFT"), + ("MTLO", "FFFFFF_____FFFFFFFFFFFFFFFFTFFTT"), + ("MFHI", "FFFFFFFFFFFFFFFF_____FFFFFFTFFFF"), + ("MFLO", "FFFFFFFFFFFFFFFF_____FFFFFFTFFTF"), ("BLTZ", "FFFFFT_____FFFFF________________"), ("BGEZ", "FFFFFT_____FFFFT________________"), ("BLTZL", "FFFFFT_____FFFTF________________"), @@ -779,16 +778,23 @@ val mips_patterns = List.map (I ## utilsLib.pattern) ("BGEZAL", "FFFFFT_____TFFFT________________"), ("BLTZALL", "FFFFFT_____TFFTF________________"), ("BGEZALL", "FFFFFT_____TFFTT________________"), - ("J", "FFFFTF__________________________"), - ("JAL", "FFFFTT__________________________"), - ("BEQ", "FFFTFF__________________________"), - ("BNE", "FFFTFT__________________________"), ("BLEZ", "FFFTTF_____FFFFF________________"), ("BGTZ", "FFFTTT_____FFFFF________________"), - ("BEQL", "FTFTFF__________________________"), - ("BNEL", "FTFTFT__________________________"), ("BLEZL", "FTFTTF_____FFFFF________________"), ("BGTZL", "FTFTTT_____FFFFF________________"), + ("JR", "FFFFFF_____FFFFFFFFFF_____FFTFFF") + ] + +val mips_cpatterns = List.map (I ## utilsLib.pattern) + [ + ("MFC0", "FTFFFFFFFFF__________FFFFFFFF___"), + ("MTC0", "FTFFFFFFTFF__________FFFFFFFF___") + ] + +val mips_patterns = List.map (I ## utilsLib.pattern) + [ + ("J", "FFFFTF__________________________"), + ("JAL", "FFFFTT__________________________"), ("LDL", "FTTFTF__________________________"), ("LDR", "FTTFTT__________________________"), ("LB", "TFFFFF__________________________"), From 6af2c0fd5e3c290476e6c8c8ac1b93a962b2506d Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Fri, 6 Mar 2015 15:30:33 +0000 Subject: [PATCH 219/718] Improve mips_decompile. Branch opcodes are automatically combined with the following opcode (the instruction in the delay slot). --- .../mips/decompiler/mips_decompLib.sml | 28 +++++++++++++++++-- 1 file changed, 25 insertions(+), 3 deletions(-) diff --git a/examples/l3-machine-code/mips/decompiler/mips_decompLib.sml b/examples/l3-machine-code/mips/decompiler/mips_decompLib.sml index bf25e30aa7..9f7832de33 100644 --- a/examples/l3-machine-code/mips/decompiler/mips_decompLib.sml +++ b/examples/l3-machine-code/mips/decompiler/mips_decompLib.sml @@ -34,7 +34,27 @@ val mips_pc = Term.prim_mk_const {Thy = "mips_prog", Name = "MIPS_PC"} val mips_tools = (format_mips_spec, fn _ => fail(), TRUTH, mips_pc): decompiler_tools -val mips_decompile = decompilerLib.decompile mips_tools +local + fun is_branch h = + case BitsN.fromHexString (h, 32) of + SOME opc => + (case mips.Decode opc of mips.Branch _ => true | _ => false) + | NONE => false +in + fun mips_parse (q: string quotation) = + let + fun fill_delay a = + fn x :: y :: r => + if is_branch x + then fill_delay (x ^ " " ^ y :: a) r + else fill_delay (x :: a) (y :: r) + | r => r @ a + in + List.rev (fill_delay [] (helperLib.quote_to_strings q)) + end +end + +val mips_decompile = decompilerLib.decompile_with mips_parse mips_tools (* testing and debugging @@ -49,7 +69,8 @@ List.map mips.encodeInstruction val (text_cert, test_def) = mips_decompile "test" `3401000A - 1420FFFF 6421FFFF` + 1420FFFF + 6421FFFF` val () = computeLib.add_funs [test_def] @@ -63,7 +84,8 @@ List.map mips.encodeInstruction val test_def = mips_decompile "test" `3401000A - 10200001 00000000` + 10200001 + 00000000` *) From 44d722c84a0cea94a09b39c4c3f556e7bb8f14f6 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Fri, 6 Mar 2015 17:03:50 +0000 Subject: [PATCH 220/718] make \HOLty[of] respect instantiation options so, for example, \HOLty[of,:'b/:'a]{MAP} will print a specialised type for MAP on a 'b->'b function rather than the general 'a->'b version, without requiring the user to type the full instantiated type as an annotation. --- src/TeX/mungeTools.sml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/TeX/mungeTools.sml b/src/TeX/mungeTools.sml index fb81790e8d..39fcd15513 100644 --- a/src/TeX/mungeTools.sml +++ b/src/TeX/mungeTools.sml @@ -514,7 +514,9 @@ in end | Type => let val typ = if OptSet.has TypeOf opts - then Term.type_of (Parse.Term [QQ parse_start, QQ spec]) + then Parse.Term [QQ parse_start, QQ spec] + |> do_tminsts pos opts + |> Term.type_of else Parse.Type [QQ parse_start, QQ spec] in add_string pps (optset_indent opts); From 5a9feb1189513cfce357b6c0bd7299f8aba94a10 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Sat, 7 Mar 2015 17:39:40 +1100 Subject: [PATCH 221/718] Let unambigous comprehensions trace be set (to 2) to force short printing form. --- src/parse/term_pp.sml | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/src/parse/term_pp.sml b/src/parse/term_pp.sml index e2efaceb18..f483afed3a 100644 --- a/src/parse/term_pp.sml +++ b/src/parse/term_pp.sml @@ -200,8 +200,8 @@ end A flag controlling printing of set comprehensions ---------------------------------------------------------------------- *) -val unamb_comp = ref false -val _ = Feedback.register_btrace ("pp_unambiguous_comprehensions", unamb_comp) +val unamb_comp = ref 0 +val _ = Feedback.register_trace ("pp_unambiguous_comprehensions", unamb_comp, 2) fun grav_name (Prec(n, s)) = s | grav_name _ = "" fun grav_prec (Prec(n,s)) = n | grav_prec _ = ~1 @@ -1696,10 +1696,11 @@ fun pp_term (G : grammar) TyG backend = let val rfrees = FVL [r] empty_tmset open HOLset in - if (equal(intersection(lfrees,rfrees), vfrees) orelse - (isEmpty lfrees andalso equal(rfrees, vfrees)) orelse - (isEmpty rfrees andalso equal(lfrees, vfrees))) - andalso not (!unamb_comp) + if ((equal(intersection(lfrees,rfrees), vfrees) orelse + (isEmpty lfrees andalso equal(rfrees, vfrees)) orelse + (isEmpty rfrees andalso equal(lfrees, vfrees))) + andalso !unamb_comp = 0) orelse + !unamb_comp = 2 then block CONSISTENT 0 (record_bvars bvars_seen_here From 6d13616405552d94165e3f55effbf4f91859af10 Mon Sep 17 00:00:00 2001 From: Thomas Tuerk Date: Sat, 7 Mar 2015 09:16:29 +0100 Subject: [PATCH 222/718] deep matches example: better better compilation - handle congruences properly - implement ssfrags - implement various heurstics - various minor improvements --- examples/deep_matches/constrFamiliesLib.sig | 30 ++- examples/deep_matches/constrFamiliesLib.sml | 174 ++++++++++++- examples/deep_matches/deepMatchesExamples.sml | 88 +++++-- examples/deep_matches/deepMatchesLib.sig | 73 +++++- examples/deep_matches/deepMatchesLib.sml | 231 ++++++++++++++---- examples/deep_matches/deepMatchesScript.sml | 16 ++ 6 files changed, 531 insertions(+), 81 deletions(-) diff --git a/examples/deep_matches/constrFamiliesLib.sig b/examples/deep_matches/constrFamiliesLib.sig index 9d713b3096..37aa2adbbb 100644 --- a/examples/deep_matches/constrFamiliesLib.sig +++ b/examples/deep_matches/constrFamiliesLib.sig @@ -53,6 +53,13 @@ sig to each other and injective. *) val constructorFamily_get_rewrites : constructorFamily -> thm + (* Get the case-cong stored in a constructor family. *) + val constructorFamily_get_case_cong : constructorFamily -> thm + + (* Get the ssfrag resulting form all the stuff + in a constructor family. *) + val constructorFamily_get_ssfrag : constructorFamily -> simpLib.ssfrag + (* Get the case-split theorem for the family. *) val constructorFamily_get_case_split : constructorFamily -> thm @@ -60,6 +67,8 @@ sig this exhaustiveness. *) val constructorFamily_get_nchotomy_thm_opt : constructorFamily -> thm option + (* Get the constructors of the family. *) + val constructorFamily_get_constructors : constructorFamily -> bool * (term * string list) list (* [mk_constructorFamily (constrL, case_split_tm, tac)] make a new constructor family. It consists of the constructors @@ -111,8 +120,15 @@ sig (* A database represents essentially a compile fun. This functions combines all the contents of a db to - turn it into a compile fun. *) + turn it into a compile fun. *) val pmatch_compile_db_compile : pmatch_compile_db -> pmatch_compile_fun + (* This tries to find the family used by a call to + [pmatch_compile_db_compile]. If this call picks a + use a hand-written compile-fun, [NONE] is returned. Similarly, + if no constructor family is found for this column. *) + val pmatch_compile_db_compile_cf : pmatch_compile_db -> + (term list * term) list -> constructorFamily option + (* add a compile fun to a db *) val pmatch_compile_db_add_compile_fun : @@ -126,6 +142,12 @@ sig val pmatch_compile_db_add_ssfrag : pmatch_compile_db -> simpLib.ssfrag -> pmatch_compile_db + (* add a congruence rules to a db *) + val pmatch_compile_db_add_congs : pmatch_compile_db -> thm list -> pmatch_compile_db + + (* removes all information for type from a db *) + val pmatch_compile_db_remove_type : pmatch_compile_db -> hol_type -> pmatch_compile_db + (* add a compile_fun to default db *) val pmatch_compile_db_register_compile_fun : pmatch_compile_fun -> unit (* add a constructor family to default db *) @@ -134,6 +156,12 @@ sig (* add a ssfrag to default db *) val pmatch_compile_db_register_ssfrag : simpLib.ssfrag -> unit + (* add a congruence rules to default db *) + val pmatch_compile_db_register_congs : thm list -> unit + + (* removes all information for type from default db *) + val pmatch_compile_db_clear_type : hol_type -> unit + (************************) (* Compile Funs *) diff --git a/examples/deep_matches/constrFamiliesLib.sml b/examples/deep_matches/constrFamiliesLib.sml index 1a55f3d5ab..4f05783d26 100644 --- a/examples/deep_matches/constrFamiliesLib.sml +++ b/examples/deep_matches/constrFamiliesLib.sml @@ -7,6 +7,14 @@ open HolKernel boolLib simpLib bossLib (* Auxiliary definitions *) (***************************************************) +fun cong_ss thms = simpLib.SSFRAG { + name = NONE, + convs = [], + rewrs = [], + ac = [], + filter = NONE, + dprocs = [], + congs = thms} fun failwith f x = raise (mk_HOL_ERR "constrFamiliesLib" f x) @@ -177,6 +185,7 @@ type constructorFamily = { one_one_thm : thm option, distinct_thm : thm option, case_split_thm: thm, + case_cong_thm : thm, nchotomy_thm : thm option } @@ -187,9 +196,24 @@ fun constructorFamily_get_rewrites (cf : constructorFamily) = | (NONE, SOME thm2) => thm2 | (SOME thm1, SOME thm2) => CONJ thm1 thm2 +fun constructorFamily_get_ssfrag (cf : constructorFamily) = + simpLib.merge_ss [simpLib.rewrites [constructorFamily_get_rewrites cf], + cong_ss [#case_cong_thm cf]] + +fun constructorFamily_get_constructors (cf : constructorFamily) = let + val cl = #constructors cf + val cs = #cl_constructors cl + val ts = List.map (fn (CONSTR (a, b)) => (a, b)) cs +in + (#cl_is_exhaustive cl, ts) +end + fun constructorFamily_get_case_split (cf: constructorFamily) = (#case_split_thm cf) +fun constructorFamily_get_case_cong (cf: constructorFamily) = + (#case_cong_thm cf) + fun constructorFamily_get_nchotomy_thm_opt (cf: constructorFamily) = (#nchotomy_thm cf) @@ -277,6 +301,91 @@ in eq end + +fun mk_case_const_cong_thm_term case_const (constrL : constructorList) = let + val (arg_tys, res_ty) = strip_fun (type_of case_const) + + val (args_l, args_r) = let + fun mk_args avoid = let + fun mk_arg (a_ty, (i, avoid, vs)) = + let + val v = variant avoid (mk_var ("f"^(int_to_string i), a_ty)) + in + (i+1, v::avoid, v::vs) + end + val (_, _, vs_rev) = foldl mk_arg (1, avoid, []) (tl arg_tys) + in + List.rev vs_rev + end + + val r0 = mk_var ("x", hd arg_tys) + val l0 = variant [r0] r0 + val args_l = mk_args [r0, l0] + val args_r = mk_args (r0::l0::args_l) + in + (l0::args_l, r0::args_r) + end + + val cong_0 = mk_eq (hd args_l, hd args_r) + val base = mk_eq ( + list_mk_comb (case_const, args_l), + list_mk_comb (case_const, args_r)) + + (* + fun extract n = + (el n (#cl_constructors constrL), + el (n+1) args_l, + el (n+1) args_r) + + val (CONSTR (c, vns), al, ar) = extract 2 + + *) + val congs_main = let + fun mk_arg_vars acc avoid (a_ty, vns) = case vns of + [] => List.rev acc + | (vn::vns') => let + val (_, atys) = dest_type a_ty + val v = variant avoid (mk_var (vn, hd atys)) + in + mk_arg_vars (v::acc) (v::avoid) (el 2 atys, vns') + end + + fun process_all acc neg_pres crs als ars = + case (crs, als, ars) of + ([], [], []) => List.rev acc + | ([], [al], [ar]) => let + val arg_ts = mk_arg_vars [] [al, ar] (type_of al, ["x"]) + val eq_t = mk_eq (list_mk_comb (al, arg_ts), + list_mk_comb (ar, arg_ts)) + + + val pre_t = list_mk_conj neg_pres + val t_full = list_mk_forall (arg_ts, mk_imp (pre_t, eq_t)) + in + List.rev (t_full :: acc) + end + | ((CONSTR (c, vns))::crs', al::als', ar::ars') => let + val arg_ts = mk_arg_vars [] [al, ar] (type_of al, vns) + val eq_t = mk_eq (list_mk_comb (al, arg_ts), + list_mk_comb (ar, arg_ts)) + + val pre_t = mk_eq (hd args_r, list_mk_comb (c, arg_ts)) + val t_full = list_mk_forall (arg_ts, mk_imp (pre_t, eq_t)) + val t_exp = list_mk_forall (arg_ts, mk_neg pre_t) + in + process_all (t_full::acc) (t_exp::neg_pres) crs' als' ars' + end + | _ => failwith "" "Something is wrong with the constructors/case constant. Wrong arity somewhere?" + in + process_all [] [] (#cl_constructors constrL) (tl args_l) (tl args_r) + end + +in + list_mk_forall (args_l @ args_r, + list_mk_imp (cong_0 :: congs_main, base)) +end + + fun mk_nchotomy_thm_term_opt (constrL : constructorList) = if not (#cl_is_exhaustive constrL) then NONE else let val v = mk_var ("x", #cl_type constrL) @@ -299,9 +408,10 @@ fun mk_constructorFamily_terms case_const constrL = let val t1 = mk_one_one_thm_term_opt constrL val t2 = mk_distinct_thm_term_opt constrL val t3 = SOME (mk_case_expand_thm_term case_const constrL) - val t4 = mk_nchotomy_thm_term_opt constrL + val t4 = SOME (mk_case_const_cong_thm_term case_const constrL) + val t5 = mk_nchotomy_thm_term_opt constrL in - [t1, t2, t3, t4] + [t1, t2, t3, t4, t5] end fun get_constructorFamily_proofObligations (constrL, case_const) = let @@ -323,7 +433,8 @@ in one_one_thm = el 1 thms, distinct_thm = el 2 thms, case_split_thm = valOf (el 3 thms), - nchotomy_thm = el 4 thms + case_cong_thm = valOf (el 4 thms), + nchotomy_thm = el 5 thms }:constructorFamily end @@ -332,6 +443,7 @@ end (* Connection to typebase *) (***************************************************) + (* given a type try to extract the constructors of a type from typebase. Do not use the default type-base functions for this but destruct the nchotomy_thm in order to get @@ -363,10 +475,11 @@ fun constructorFamily_of_typebase ty = let val thm_distinct = TypeBase.distinct_of ty val thm_one_one = TypeBase.one_one_of ty val thm_case = TypeBase.case_def_of ty + val thm_case_cong = TypeBase.case_cong_of ty (* set_constructorFamily (crL, case_split_tm) *) val cf = mk_constructorFamily (crL, case_split_tm, - SIMP_TAC std_ss [thm_distinct, thm_one_one] THEN + SIMP_TAC std_ss [thm_distinct, thm_one_one, thm_case_cong] THEN REPEAT STRIP_TAC THEN ( Cases_on `x` THEN SIMP_TAC std_ss [thm_distinct, thm_one_one, thm_case] @@ -480,8 +593,21 @@ fun lookup_constructorFamilies (db : pmatch_compile_db) col = let | SOME (ty, cf) => [(ty, cf)] in cts_fams' @ cty_l end + fun is_old_fam (ty, cf) = let + val (_, cl) = constructorFamily_get_constructors cf + fun is_old_const c = let + val (cn, _) = dest_const c + in + String.isSuffix "<-old" cn + end handle HOL_ERR _ => false + in + (List.exists (fn (c, _) => is_old_const c) cl) orelse + (is_old_const (#case_const cf)) + end + + val cts_fams' = List.filter (fn cf => not (is_old_fam cf)) cts_fams val weighted_fams = List.map (fn (ty, cf) => - ((ty, cf), measure_constructorFamily cf col)) cts_fams + ((ty, cf), measure_constructorFamily cf col)) cts_fams' val weighted_fams_sorted = sort (fn (_, w1) => fn (_, w2) => constructorFamily_col_stats_compare w1 w2) weighted_fams in @@ -507,14 +633,29 @@ fun pmatch_compile_db_compile db col = ( end ))); +fun pmatch_compile_db_compile_cf db col = ( + if (List.null col) then failwith "pmatch_compile_db_compile_cf" "col 0" else + case (get_first (fn f => f col handle HOL_ERR _ => NONE) (#pcdb_compile_funs db)) of + SOME r => NONE | NONE => ( + case (lookup_constructorFamilies db col) of + NONE => NONE + | SOME (_, cf) => SOME cf)) + + fun pmatch_compile_db_add_ssfrag (db : pmatch_compile_db) ss = { pcdb_compile_funs = #pcdb_compile_funs db, pcdb_constrFams = #pcdb_constrFams db, - pcdb_ss = (simpLib.merge_ss [#pcdb_ss db, ss]) + pcdb_ss = (simpLib.merge_ss [ss, #pcdb_ss db]) } : pmatch_compile_db +fun pmatch_compile_db_add_congs db thms = + pmatch_compile_db_add_ssfrag db (cong_ss thms); + fun pmatch_compile_db_register_ssfrag ss = - thePmatchCompileDB := pmatch_compile_db_add_ssfrag (!thePmatchCompileDB) ss + thePmatchCompileDB := pmatch_compile_db_add_ssfrag (!thePmatchCompileDB) ss; + +fun pmatch_compile_db_register_congs thms = + pmatch_compile_db_register_ssfrag (cong_ss thms) fun pmatch_compile_db_add_compile_fun (db : pmatch_compile_db) cf = { pcdb_compile_funs = cf::(#pcdb_compile_funs db), @@ -529,19 +670,34 @@ fun pmatch_compile_db_add_constrFam (db : pmatch_compile_db) cf = { pcdb_compile_funs = #pcdb_compile_funs db, pcdb_constrFams = let val cl = (#constructors cf) - val ty = #cl_type cl + val ty = normalise_ty (#cl_type cl) val net = #pcdb_constrFams db val cfs = TypeNet.find (net, ty) handle NotFound => [] val net' = TypeNet.insert (net, ty, cf::cfs) in net' end, - pcdb_ss = #pcdb_ss db + pcdb_ss = merge_ss [constructorFamily_get_ssfrag cf, (#pcdb_ss db)] } : pmatch_compile_db fun pmatch_compile_db_register_constrFam cf = thePmatchCompileDB := pmatch_compile_db_add_constrFam (!thePmatchCompileDB) cf +fun pmatch_compile_db_remove_type (db : pmatch_compile_db) ty = { + pcdb_compile_funs = #pcdb_compile_funs db, + pcdb_constrFams = let + val ty = normalise_ty ty + val net = #pcdb_constrFams db + val net' = TypeNet.insert (net, ty, []) + in + net' + end, + pcdb_ss = #pcdb_ss db +} : pmatch_compile_db + +fun pmatch_compile_db_clear_type ty = + thePmatchCompileDB := pmatch_compile_db_remove_type (!thePmatchCompileDB) ty + (***************************************************) diff --git a/examples/deep_matches/deepMatchesExamples.sml b/examples/deep_matches/deepMatchesExamples.sml index 9c4cb9a592..e4c8b29793 100644 --- a/examples/deep_matches/deepMatchesExamples.sml +++ b/examples/deep_matches/deepMatchesExamples.sml @@ -7,6 +7,8 @@ open constrFamiliesLib open stringTheory open pred_setLib +val _ = Globals.priming := SOME "_" + (* Introducing case expressions *) val t = ``case x of (NONE, []) => 0`` @@ -211,7 +213,11 @@ val balance_black_def = Define `balance_black a n b = (* try to compile to a tree inside the logic *) val balance_black_dectree_def = CONV_RULE - (TOP_SWEEP_CONV (PMATCH_CASE_SPLIT_CONV (fn _ => 0))) + (TOP_SWEEP_CONV PMATCH_CASE_SPLIT_CONV) + balance_black_def + +val balance_black_dectree_def' = + SIMP_RULE (std_ss++PMATCH_CASE_SPLIT_ss ()) [] balance_black_def open stringTheory @@ -223,10 +229,40 @@ val string_match_def = Define `string_match s x = ]` val string_match_dectree_def = CONV_RULE - (TOP_SWEEP_CONV (PMATCH_CASE_SPLIT_CONV (fn _ => 0))) + (TOP_SWEEP_CONV PMATCH_CASE_SPLIT_CONV) string_match_def +(*********************************) +(* Heuristics *) +(*********************************) + +val dummy_bool_tm = + ``CASE (a,b,c) OF [ + ||. (_, 0, _) ~> 1; + ||. (0, _, 0) ~> 1; + ||. (_, _, _) ~> 0 + ]`` + +(* try to compile to a tree inside the logic *) +val dummy_bool_eq1 = + PMATCH_CASE_SPLIT_CONV_HEU colHeu_first_col dummy_bool_tm + +val dummy_bool_eq2 = + PMATCH_CASE_SPLIT_CONV_HEU colHeu_last_col dummy_bool_tm + +val dummy_bool_eq3 = + PMATCH_CASE_SPLIT_CONV_HEU colHeu_default dummy_bool_tm + + +val dummy_bool_tm = Define `f a b c = + CASE (a,b,c) OF [ + ||. (_, 0, _) ~> 1; + ||. (0, _, 0) ~> 1; + ||. (_, _, _) ~> 0 + ]` + + (*********************************) (* Constructor families *) (*********************************) @@ -253,6 +289,8 @@ val cf = mk_constructorFamily (cl, ``list_REVCASE``, ASSUME_TAC (Q.SPEC `x` listTheory.SNOC_CASES) THEN FULL_SIMP_TAC std_ss [list_REVCASE_THM], + ASSUME_TAC (Q.SPEC `x` listTheory.SNOC_CASES) THEN + FULL_SIMP_TAC std_ss [list_REVCASE_THM], PROVE_TAC [listTheory.SNOC_CASES] ] ) @@ -265,21 +303,22 @@ val t = ``CASE l OF [ || x. SNOC x _ ~> x ]`` -val thm = PMATCH_CASE_SPLIT_CONV (fn _ => 0) t +val thm = PMATCH_CASE_SPLIT_CONV t val t = ``CASE lx OF [ ||. ([], NONE) ~> 0; || (x, y). (SNOC x _, SOME y) ~> x + y ]``; -val thm = PMATCH_CASE_SPLIT_CONV (fn _ => 0) t; +val thm = PMATCH_CASE_SPLIT_CONV t; +val thm2 = PMATCH_CASE_SPLIT_CONV t; val t = ``CASE lx OF [ ||. [] ~> 0; || x. x::_ ~> x + y ]`` -val thm = PMATCH_CASE_SPLIT_CONV (fn _ => 0) t; +val thm = PMATCH_CASE_SPLIT_CONV t; (* A nonexhaustive family *) @@ -317,21 +356,15 @@ val cl = make_constructorList false [ (* set_constructorFamily (cl, ``tree_red_CASE``) *) val cf = mk_constructorFamily (cl, ``tree_red_CASE``, SIMP_TAC (srw_ss()) [tree_red_CASE_def] THEN - Cases_on `x` THEN - SIMP_TAC (srw_ss()) [tree_red_CASE_def]); + CONJ_TAC THEN ( + Cases_on `x` THEN + SIMP_TAC (srw_ss()) [tree_red_CASE_def] + )); val _ = pmatch_compile_db_register_constrFam cf; -val _ = pmatch_compile_db_register_ssfrag - (simpLib.rewrites [Cong tree_red_CASE_cong]); - -val my_conv = ( - (PMATCH_CASE_SPLIT_CONV (fn _ => 0)) THENC - (SIMP_CONV (std_ss++PMATCH_SIMP_ss) [Cong tree_red_CASE_cong])) - val balance_black_dectree_def2 = CONV_RULE - ((TOP_SWEEP_CONV my_conv) THENC - (SIMP_CONV std_ss [pairTheory.pair_case_thm])) + (TOP_SWEEP_CONV PMATCH_CASE_SPLIT_CONV) balance_black_def val balance_black_dectree_def3 = CONV_RULE @@ -343,6 +376,27 @@ val size_old = term_size (rhs (snd (strip_forall (concl balance_black_dectree_de val size_classic = term_size (rhs (snd (strip_forall (concl balance_black_dectree_def3)))) +(* even with the family for red, the full cases are + still available when needed (notice the added row above + the last one) *) +val t = `` + CASE (a,b) OF [ + || (a,x,b,y,c,d). (Red (Red a x b) y c,d) ~> + (Red (Black a x b) y (Black c n d)); + || (a,x,b,y,c,d). (Red a x (Red b y c),d) ~> + (Red (Black a x b) y (Black c n d)); + || (a,b,y,c,z,d). (a,Red (Black b y c) z d) ~> + (Red (Black a n b) y (Black c z d)); + || (a,b,y,c,z,d). (a,Red b y (Red c z d)) ~> + (Red (Black a n b) y (Black c z d)); + || (a, x, b, c). (Black a x b, c) ~> (Black a x b); + || other. other ~> (Black a n b) + ]`` + +val thm = PMATCH_CASE_SPLIT_CONV t; + + + (*********************************) (* DIV / MOD *) (*********************************) @@ -359,7 +413,7 @@ val my_divmod_THM = store_thm ("my_divmod_THM", REPEAT STRIP_TAC THEN MP_TAC (SPECL [``n:num``, ``c:num``] (CONJUNCT1 my_divmod_THM_AUX)) THEN -Tactical.REVERSE (Cases_on `?q r. (q:num) * c + r = n /\ r < c`) THEN1 ( +Tactical.REVERSE (Cases_on `?q r. ((q:num) * c + r = n) /\ (r < c)`) THEN1 ( METIS_TAC [arithmeticTheory.DIVISION] ) THEN ASM_REWRITE_TAC[] THEN diff --git a/examples/deep_matches/deepMatchesLib.sig b/examples/deep_matches/deepMatchesLib.sig index 27eb1bfcb0..886e04c836 100644 --- a/examples/deep_matches/deepMatchesLib.sig +++ b/examples/deep_matches/deepMatchesLib.sig @@ -117,17 +117,76 @@ sig (* CASE SPLIT (pattern compile) *) (********************************) - val PMATCH_CASE_SPLIT_CONV : - ((term * (term list * term) list) list -> int) -> term -> thm - + (*------------*) + (* Heuristics *) + (*------------*) + + (* A column heuristic is used to figure out, in + which order to process columns. It gets a list of columns + and returns, which one to pick. *) + type column_heuristic = (term * (term list * term) list) list -> int + + (* Many heuristics are build on ranking funs. + A ranking fun assigns an integer to a column. Larger + numbers are prefered. If two columns have the same + value, either another ranking fun is used to decide or + just the first one is used, if no ranking fun is available. *) + type column_ranking_fun = term * (term list * term) list -> int + val colHeu_rank : column_ranking_fun list -> column_heuristic + + val colRank_first_row : column_ranking_fun + val colRank_first_row_constr : constrFamiliesLib.pmatch_compile_db -> column_ranking_fun + val colRank_arity : constrFamiliesLib.pmatch_compile_db -> column_ranking_fun + val colRank_constr_prefix : column_ranking_fun + val colRank_small_branching_factor : constrFamiliesLib.pmatch_compile_db -> column_ranking_fun + + (* Some heuristics *) + val colHeu_first_col : column_heuristic + val colHeu_last_col : column_heuristic + val colHeu_first_row : column_heuristic + val colHeu_constr_prefix : column_heuristic + val colHeu_cqba : constrFamiliesLib.pmatch_compile_db -> column_heuristic + val colHeu_qba : constrFamiliesLib.pmatch_compile_db -> column_heuristic + + (* the default heuristic, currently it is + colHeu_qba applied to the default db. However, + this might change. You can just rely on a decent heuristic, + that often works. No specific properties guarenteed. *) + val colHeu_default : column_heuristic + + (*-------------*) + (* COMPILATION *) + (*-------------*) + + (* [PMATCH_CASE_SPLIT_CONV_GEN ssl db col_heu] + is a conversion that tries to compile PMATCH expressions + to decision trees using database [db], column heuristic + [col_heu] and additional ssfrags [ssl]. *) val PMATCH_CASE_SPLIT_CONV_GEN : ssfrag list -> constrFamiliesLib.pmatch_compile_db -> - ((term * (term list * term) list) list -> int) -> term -> thm + column_heuristic -> conv + + (* A simplified version of PMATCH_CASE_SPLIT_CONV that + uses the default database and default column heuristic as + well as no extra ssfrags. *) + val PMATCH_CASE_SPLIT_CONV : conv + + (* lets choose at least the heuristic *) + val PMATCH_CASE_SPLIT_CONV_HEU : column_heuristic -> conv - val PMATCH_CASE_SPLIT_CONV_GENCALL : - ssfrag list * (term -> thm) option -> + (* ssfrag corresponding to PMATCH_CASE_SPLIT_CONV_GEN *) + val PMATCH_CASE_SPLIT_GEN_ss : + ssfrag list -> constrFamiliesLib.pmatch_compile_db -> - ((term * (term list * term) list) list -> int) -> term -> thm + column_heuristic -> ssfrag + + (* ssfrag corresponding to PMATCH_CASE_SPLIT_CONV, since + it needs to get the current version of the default db, + it gets a unit argument. *) + val PMATCH_CASE_SPLIT_ss : unit -> ssfrag + + (* lets choose at least the heuristic *) + val PMATCH_CASE_SPLIT_HEU_ss : column_heuristic -> ssfrag end diff --git a/examples/deep_matches/deepMatchesLib.sml b/examples/deep_matches/deepMatchesLib.sml index ed32e1ef50..644ecc6ba7 100644 --- a/examples/deep_matches/deepMatchesLib.sml +++ b/examples/deep_matches/deepMatchesLib.sml @@ -10,6 +10,42 @@ open deepMatchesSyntax open Traverse open constrFamiliesLib +(***********************************************) +(* Auxiliary stuff *) +(***********************************************) + +fun make_gen_conv_ss c name ssl = let + exception genconv_reducer_exn + fun addcontext (context,thms) = context + fun apply {solver,conv,context,stack,relation} tm = ( + QCHANGED_CONV (c (ssl, SOME (conv stack))) tm + ) + in simpLib.dproc_ss (REDUCER {name=SOME name, + addcontext=addcontext, apply=apply, + initial=genconv_reducer_exn}) + end; + + +fun has_subterm p t = ((find_term p t; true) handle HOL_ERR _ => false) + +(* We have a problem with conversions that loop in a fancy way. + They add some pattern matching on the input variables and + in the body the original term with renamed variables. The + following function tries to detect this situation. *) +fun does_conv_loop thm = let + val (l, r) = dest_eq (concl thm) + fun my_mk_abs t = list_mk_abs (free_vars_lr t, t) + val l' = my_mk_abs l + val const_check = let + val (l_c, _) = strip_comb l + in + fn t => (same_const (fst (strip_comb t)) l_c) + end handle HOL_ERR _ => (fn t => true) + fun is_similar t = const_check t andalso (aconv l' (my_mk_abs t)) + val i = ((find_term is_similar r; true) handle HOL_ERR _ => false) + in + i + end (***********************************************) (* Simpset to evaluate PMATCH_ROWS *) @@ -84,6 +120,8 @@ val static_ss = simpLib.merge_ss elim_fst_snd_select_ss, boolSimps.EQUIV_EXTRACT_ss, simpLib.rewrites [ + some_var_bool_T, some_var_bool_F, + GSYM boolTheory.F_DEF, pairTheory.EXISTS_PROD, pairTheory.FORALL_PROD, PMATCH_ROW_EQ_NONE, @@ -245,12 +283,6 @@ fun PMATCH_INTRO_CONV t = (* convert a case-term into a PMATCH-term, without any proofs *) -val t = ``CASE x OF [ - ||. ([], NONE) ~> 0; - || (x,xs,z). (x::xs, SOME z) ~> (x+z); - || (x,xs). (x::xs, NONE) ~> x -]`` - fun pmatch2case t = let val (v, rows) = dest_PMATCH t val fv = genvar (type_of v --> type_of t) @@ -427,7 +459,7 @@ PMATCH (NONE,x,l) ]`` val t = ``PMATCH y [PMATCH_ROW (\_0_1. _0_1) (\_0_1. T) (\_0_1. F)]`` -val rc_arg = [] +val rc_arg = ([], NONE) val t' = rhs (concl (PMATCH_CLEANUP_CONV t)) *) @@ -1093,7 +1125,7 @@ PMATCH (SOME y,x,l) ]`` *) -fun PMATCH_SIMP_CONV_GENCALL rc_arg = +fun PMATCH_SIMP_CONV_GENCALL_AUX rc_arg = REPEATC (FIRST_CONV [ CHANGED_CONV (PMATCH_CLEANUP_PVARS_CONV), CHANGED_CONV (PMATCH_CLEANUP_CONV_GENCALL rc_arg), @@ -1103,21 +1135,16 @@ REPEATC (FIRST_CONV [ CHANGED_CONV PMATCH_FORCE_SAME_VARS_CONV ]); +fun PMATCH_SIMP_CONV_GENCALL rc_arg t = + if (is_PMATCH t) then PMATCH_SIMP_CONV_GENCALL_AUX rc_arg t else + raise UNCHANGED + fun PMATCH_SIMP_CONV_GEN ssl = PMATCH_SIMP_CONV_GENCALL (ssl, NONE) val PMATCH_SIMP_CONV = PMATCH_SIMP_CONV_GEN []; -fun PMATCH_SIMP_GEN_ss ssl = let - exception pmatch_simp_reducer_exn - fun addcontext (context,thms) = context - fun apply {solver,conv,context,stack,relation} tm = ( - if not (is_PMATCH tm) then failwith "not a PMATCH" else - QCHANGED_CONV (PMATCH_SIMP_CONV_GENCALL (ssl, SOME (conv stack))) tm - ) - in simpLib.dproc_ss (REDUCER {name=SOME"PMATCH_SIMP_REDUCER", - addcontext=addcontext, apply=apply, - initial=pmatch_simp_reducer_exn}) - end; +fun PMATCH_SIMP_GEN_ss ssl = + make_gen_conv_ss PMATCH_SIMP_CONV_GENCALL "PMATCH_SIMP_REDUCER" ssl val PMATCH_SIMP_ss = PMATCH_SIMP_GEN_ss [] @@ -1277,16 +1304,8 @@ fun PMATCH_LIFT_BOOL_CONV_GEN ssl = PMATCH_LIFT_BOOL_CONV_GENCALL (ssl, NONE) val PMATCH_LIFT_BOOL_CONV = PMATCH_LIFT_BOOL_CONV_GEN []; -fun PMATCH_LIFT_BOOL_GEN_ss ssl = let - exception pmatch_simp_reducer_exn - fun addcontext (context,thms) = context - fun apply {solver,conv,context,stack,relation} tm = ( - QCHANGED_CONV (PMATCH_LIFT_BOOL_CONV_GENCALL (ssl, SOME (conv stack))) tm - ) - in simpLib.dproc_ss (REDUCER {name=SOME"PMATCH_LIFT_BOOL_REDUCER", - addcontext=addcontext, apply=apply, - initial=pmatch_simp_reducer_exn}) - end; +fun PMATCH_LIFT_BOOL_GEN_ss ssl = + make_gen_conv_ss PMATCH_LIFT_BOOL_CONV_GENCALL "PMATCH_LIFT_BOOL_REDUCER" ssl val PMATCH_LIFT_BOOL_ss = PMATCH_LIFT_BOOL_GEN_ss [] @@ -1320,6 +1339,115 @@ fun PMATCH_TO_TOP_RULE thm = PMATCH_TO_TOP_RULE_GEN [] thm; (* This is work in progress *) (***********************************************) +type column_heuristic = + (term * (term list * term) list) list -> int + +(* one that uses always the first column *) +val colHeu_first_col : column_heuristic = (fn _ => 0) + +(* one that uses always the last column *) +val colHeu_last_col : column_heuristic = (fn cols => length cols - 1) + +(* A heuristic based on ranking functions *) +type column_ranking_fun = (term * (term list * term) list) -> int + +fun colHeu_rank (rankL : column_ranking_fun list) = (fn colL => let + val ncolL = Lib.enumerate 0 colL + fun step rank ncolL = let + val ranked_cols = List.map (fn (i, c) => ((i, c), rank c)) ncolL + val max = List.foldl (fn ((_, r), m) => if r > m then r else m) (snd (hd ranked_cols)) (tl ranked_cols) + val ranked_cols' = List.filter (fn (_, r) => r = max) ranked_cols + val ncolL' = List.map fst ranked_cols' + in + ncolL' + end + fun steps [] ncolL = ncolL + | steps _ [] = [] + | steps _ [e] = [e] + | steps (rf :: rankL) ncolL = steps rankL (step rf ncolL) + val ncolL' = steps rankL ncolL +in + case ncolL' of + [] => 0 (* something went wrong, should not happen *) + | ((i, _) :: _) => i +end) : column_heuristic + + +(* ranking functions *) +fun colRank_first_row (_:term, rows) = ( + case rows of + [] => 0 + | (vs, p) :: _ => + if (is_var p andalso mem p vs) then 0 else 1); + +fun colRank_first_row_constr db (_, rows) = case rows of + [] => 0 + | ((vs, p) :: _) => if (is_var p andalso mem p vs) then 0 else + case pmatch_compile_db_compile_cf db rows of + NONE => 0 + | SOME cf => let + val (exh, constrL) = constructorFamily_get_constructors cf; + val p_c = fst (strip_comb p) + val cL_cf = List.map fst constrL; + val p_c_ok = op_mem same_const p_c cL_cf + in + (if p_c_ok then 1 else 0) + end handle HOL_ERR _ => 0; + +val colRank_constr_prefix : column_ranking_fun = (fn (_, rows) => + let fun aux n [] = n + | aux n ((vs, p) :: pL) = if (is_var p andalso mem p vs) + then n else aux (n+1) pL + in aux 0 rows end) + + +fun col_get_constr_set db (_, rows) = + case pmatch_compile_db_compile_cf db rows of + NONE => NONE + | SOME cf => let + val (exh, constrL) = constructorFamily_get_constructors cf; + val cL_rows = List.map (fn (_, p) => fst (strip_comb p)) rows; + val cL_cf = List.map fst constrL; + + val cL_rows' = List.filter (fn c => op_mem same_const c cL_cf) cL_rows; + val cL_rows'' = Lib.mk_set cL_rows'; + in + SOME (cL_rows'', cL_cf, exh) + end + +fun col_get_nonvar_set (_, rows) = + let + val cL' = List.filter (fn (vs, p) => + not (is_var p andalso mem p vs)) rows; + val cL'' = Lib.mk_set cL'; + in + cL'' + end + +fun colRank_small_branching_factor db : column_ranking_fun = (fn col => + case col_get_constr_set db col of + SOME (cL, full_constrL, exh) => + (~(length cL + (if exh then 0 else 1) + (if length cL = length full_constrL then 0 else 1))) + | NONE => (~(length (col_get_nonvar_set col) + 2))) + +fun colRank_arity db : column_ranking_fun = (fn col => + case col_get_constr_set db col of + SOME (cL, full_constrL, exh) => + List.foldl (fn (c, s) => s + length (fst (strip_fun (type_of c)))) 0 cL + | NONE => 0) + + +(* heuristics defined using ranking functions *) +val colHeu_first_row = colHeu_rank [colRank_first_row] +val colHeu_constr_prefix = colHeu_rank [colRank_constr_prefix] +fun colHeu_qba db = colHeu_rank [colRank_constr_prefix, colRank_small_branching_factor db, colRank_arity db] +fun colHeu_cqba db = colHeu_rank [colRank_first_row_constr db, + colRank_constr_prefix, colRank_small_branching_factor db, colRank_arity db] + +(* A list of all the standard heuristics *) +fun colHeu_default cols = colHeu_qba (!thePmatchCompileDB) cols + + (* val t = ``CASE (a,x,xs) OF [ || x. (NONE,x,[]) ~> x; @@ -1355,18 +1483,12 @@ fun PMATCH_CASE_SPLIT_AUX rc_arg col_no expand_thm t = let val thm0 = ISPEC arg (ISPEC ff expand_thm) val thm1 = CONV_RULE (LHS_CONV BETA_CONV) thm0 - val c = SIMP_CONV - (std_ss++PMATCH_SIMP_GEN_ss (fst rc_arg)) [] + (std_ss++simpLib.merge_ss (fst rc_arg) ++ PMATCH_SIMP_GEN_ss (fst rc_arg)) [] val thm2 = CONV_RULE (RHS_CONV c) thm1 (* check whether it got simpler *) - val _ = let - val r = rhs (concl thm2) - val i = ((find_term (aconv t) r; true) handle HOL_ERR _ => false) - in - if i then raise UNCHANGED else () - end + val _ = if (does_conv_loop thm2) then raise UNCHANGED else () in thm2 end @@ -1401,6 +1523,9 @@ fun PMATCH_CASE_SPLIT_CONV_GENCALL_STEP (gl, callback_opt) db col_heu t = let val (col_no, expand_thm, expand_ss) = find_col (dest_PMATCH_COLS t) val thm1 = QCHANGED_CONV (PMATCH_CASE_SPLIT_AUX (expand_ss::gl, callback_opt) col_no expand_thm) t + + (* check whether it got simpler *) + val _ = if (does_conv_loop thm1) then raise UNCHANGED else () in thm1 end @@ -1449,27 +1574,39 @@ fun PMATCH_CASE_SPLIT_CONV_GENCALL rc_arg db col_heu t = let val thm2 = CONV_RULE (RHS_CONV ( (TOP_SWEEP_CONV ( - CHANGED_CONV (PMATCH_CASE_SPLIT_CONV_GENCALL_STEP rc_arg db col_heu) + PMATCH_CASE_SPLIT_CONV_GENCALL_STEP rc_arg db col_heu )))) thm1 val thm3 = TRANS thm0 thm2 (* check whether it got simpler *) - val _ = let - val r = rhs (concl thm3) - val i = ((find_term (aconv t) r; true) handle HOL_ERR _ => false) - in - if i then failwith "loop" else () - end + val _ = if (does_conv_loop thm3) then raise UNCHANGED else () -(* val thm4 = CONV_RULE (RHS_CONV REMOVE_REBIND_CONV) thm3 *) + val thm4 = if (has_subterm is_PMATCH (rhs (concl thm3))) then + thm3 + else + CONV_RULE (RHS_CONV REMOVE_REBIND_CONV) thm3 in - thm3 + thm4 end fun PMATCH_CASE_SPLIT_CONV_GEN ssl = PMATCH_CASE_SPLIT_CONV_GENCALL (ssl, NONE) -fun PMATCH_CASE_SPLIT_CONV col_heu t = +fun PMATCH_CASE_SPLIT_CONV_HEU col_heu t = PMATCH_CASE_SPLIT_CONV_GEN [] (!thePmatchCompileDB) col_heu t +fun PMATCH_CASE_SPLIT_CONV t = + PMATCH_CASE_SPLIT_CONV_HEU colHeu_default t + +fun PMATCH_CASE_SPLIT_GEN_ss ssl db col_heu = + make_gen_conv_ss (fn rc_arg => + PMATCH_CASE_SPLIT_CONV_GENCALL rc_arg db col_heu) + "PMATCH_CASE_SPLIT_REDUCER" ssl + +fun PMATCH_CASE_SPLIT_HEU_ss col_heu = + PMATCH_CASE_SPLIT_GEN_ss [] (!thePmatchCompileDB) col_heu + +fun PMATCH_CASE_SPLIT_ss () = + PMATCH_CASE_SPLIT_HEU_ss colHeu_default + end diff --git a/examples/deep_matches/deepMatchesScript.sml b/examples/deep_matches/deepMatchesScript.sml index 85c29701d4..367a2f1268 100644 --- a/examples/deep_matches/deepMatchesScript.sml +++ b/examples/deep_matches/deepMatchesScript.sml @@ -22,6 +22,22 @@ REPEAT STRIP_TAC THEN SELECT_ELIM_TAC THEN PROVE_TAC[]) +val some_var_bool_T = store_thm ("some_var_bool_T", + ``(some x. x) = SOME T``, + `(some x. x) = (some x. (x = T))` by REWRITE_TAC[] THEN + ONCE_ASM_REWRITE_TAC[] THEN + PURE_REWRITE_TAC[optionTheory.some_EQ] THEN + REWRITE_TAC[] +) + +val some_var_bool_F = store_thm ("some_var_bool_F", + ``(some x. ~x) = SOME F``, + `(some x. ~x) = (some x. (x = F))` by REWRITE_TAC[] THEN + ONCE_ASM_REWRITE_TAC[] THEN + PURE_REWRITE_TAC[optionTheory.some_EQ] THEN + REWRITE_TAC[] +) + val some_eq_NONE = prove ( ``!P. ((some x. P x) = NONE) <=> (!x. ~(P x))``, SIMP_TAC std_ss [some_def]) From b01102be4c1f52eaf98672ab8d48073bf5627978 Mon Sep 17 00:00:00 2001 From: Thomas Tuerk Date: Sun, 8 Mar 2015 08:04:42 +0100 Subject: [PATCH 223/718] fix issue #241 --- src/tfl/src/Defn.sml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/tfl/src/Defn.sml b/src/tfl/src/Defn.sml index 5f59db3ad2..ea81db1bc3 100644 --- a/src/tfl/src/Defn.sml +++ b/src/tfl/src/Defn.sml @@ -1582,9 +1582,9 @@ in fun munge eq (eqs,fset,V) = let val (vlist,body) = Absyn.strip_forall eq val (lhs0,rhs) = multi_dest_eq body - val _ = if exists wildcard (names_of rhs []) then +(* val _ = if exists wildcard (names_of rhs []) then raise ERRloc "munge" (Absyn.locn_of_absyn rhs) - "wildcards on rhs" else () + "wildcards on rhs" else () *) val (tys, lhs) = strip_tyannote lhs0 val (f,pats) = Absyn.strip_app lhs val (pats',V') = rev_itlist expand_wildcards pats From 1e722db3c5e7773983523732d2a32481d93f857b Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Wed, 11 Mar 2015 13:28:21 +0000 Subject: [PATCH 224/718] Update CHERI model. --- .../l3-machine-code/cheri/cheriScript.sml | 7202 +++++++++-------- 1 file changed, 3737 insertions(+), 3465 deletions(-) diff --git a/examples/l3-machine-code/cheri/cheriScript.sml b/examples/l3-machine-code/cheri/cheriScript.sml index b728d29908..517a8d72c4 100644 --- a/examples/l3-machine-code/cheri/cheriScript.sml +++ b/examples/l3-machine-code/cheri/cheriScript.sml @@ -1,4 +1,4 @@ -(* cheriScript.sml - generated by L<3> - Fri Feb 20 10:52:48 2015 *) +(* cheriScript.sml - generated by L<3> - Wed Mar 11 13:23:40 2015 *) open HolKernel boolLib bossLib Import val () = Import.start "cheri" @@ -79,8 +79,8 @@ val _ = Record ; val _ = Record ("HWREna", - [("CC",bTy),("CCRes",bTy),("CPUNum",bTy),("UL",bTy), - ("hwrena'rst",FTy 28)]) + [("CC",bTy),("CCRes",bTy),("CPUNum",bTy),("DS",bTy),("KS",bTy), + ("RS",bTy),("UL",bTy),("hwrena'rst",FTy 25)]) ; val _ = Record ("CP0", @@ -96,6 +96,9 @@ val _ = Record ("Status",CTy"StatusRegister"),("UsrLocal",F64),("Wired",CTy"Wired"), ("XContext",CTy"XContext")]) ; +val _ = Record + ("CoreStats",[("branch_not_taken",nTy),("branch_taken",nTy)]) +; val _ = Record ("PIC_Config_Reg", [("EN",bTy),("IRQ",FTy 3),("pic_config_reg'rst",FTy 60)]) @@ -152,6 +155,11 @@ val _ = Construct ("capExcPermSetType",[]),("capExcAccEPCC",[]),("capExcAccKDC",[]), ("capExcAccKCC",[]),("capExcAccKR1C",[]),("capExcAccKR2C",[])])] ; +val _ = Record + ("MemStats", + [("cap_reads",nTy),("cap_writes",nTy),("data_reads",nTy), + ("data_writes",nTy),("inst_reads",nTy)]) +; val _ = Construct [("Branch", [("BEQ",[PTy(FTy 5,PTy(FTy 5,F16))]), @@ -346,17 +354,18 @@ val _ = Construct ; val _ = Record ("cheri_state", - [("JTAG_UART",CTy"JTAG_UART"),("MEM",ATy(FTy 37,F64)), + [("JTAG_UART",CTy"JTAG_UART"),("MEM",ATy(FTy 35,FTy 257)), ("PIC_base_address",ATy(F8,FTy 37)), ("PIC_config_regs",ATy(F8,ATy(FTy 7,CTy"PIC_Config_Reg"))), ("PIC_external_intrs",ATy(F8,F64)),("PIC_ip_bits",ATy(F8,FTy 128)), - ("TAG",ATy(FTy 35,bTy)),("UNPREDICTABLE_HI",ATy(uTy,uTy)), - ("UNPREDICTABLE_LO",ATy(uTy,uTy)),("c_BranchDelay",ATy(F8,OTy F64)), + ("UNPREDICTABLE_HI",ATy(uTy,uTy)),("UNPREDICTABLE_LO",ATy(uTy,uTy)), + ("c_BranchDelay",ATy(F8,OTy F64)), ("c_BranchDelayPCC",ATy(F8,OTy(PTy(F64,CTy"Capability")))), ("c_BranchTo",ATy(F8,OTy F64)), ("c_BranchToPCC",ATy(F8,OTy(PTy(F64,CTy"Capability")))), - ("c_CP0",ATy(F8,CTy"CP0")),("c_LLbit",ATy(F8,OTy bTy)), - ("c_PC",ATy(F8,F64)),("c_TLB_assoc",ATy(F8,ATy(F4,CTy"TLBEntry"))), + ("c_CP0",ATy(F8,CTy"CP0")),("c_CoreStats",ATy(F8,CTy"CoreStats")), + ("c_LLbit",ATy(F8,OTy bTy)),("c_PC",ATy(F8,F64)), + ("c_TLB_assoc",ATy(F8,ATy(F4,CTy"TLBEntry"))), ("c_TLB_direct",ATy(F8,ATy(FTy 7,CTy"TLBEntry"))), ("c_capcause",ATy(F8,CTy"CapCause")), ("c_capr",ATy(F8,ATy(FTy 5,CTy"Capability"))), @@ -364,8 +373,9 @@ val _ = Record ("c_hi",ATy(F8,OTy F64)),("c_lo",ATy(F8,OTy F64)), ("c_pcc",ATy(F8,CTy"Capability")),("currentInst",OTy F32), ("done",bTy),("exception",CTy"exception"),("instCnt",nTy), - ("log",ATy(nTy,LTy sTy)),("print",ATy(sTy,uTy)), - ("println",ATy(sTy,uTy)),("procID",F8),("totalCore",nTy)]) + ("log",ATy(nTy,LTy sTy)),("memStats",CTy"MemStats"), + ("print",ATy(sTy,uTy)),("println",ATy(sTy,uTy)),("procID",F8), + ("totalCore",nTy),("watchPaddr",OTy(FTy 40))]) ; val qTy = CTy "cheri_state"; fun qVar v = Term.mk_var (v, ParseDatatype.pretypeToType qTy); @@ -1688,79 +1698,78 @@ val rec'HWREna_def = Def ("rec'HWREna",Var("x",F32), Rec(CTy"HWREna", [Bop(Bit,Var("x",F32),LN 2),Bop(Bit,Var("x",F32),LN 3), - Bop(Bit,Var("x",F32),LN 0),Bop(Bit,Var("x",F32),LN 29), + Bop(Bit,Var("x",F32),LN 0),Bop(Bit,Var("x",F32),LN 28), + Bop(Bit,Var("x",F32),LN 26),Bop(Bit,Var("x",F32),LN 27), + Bop(Bit,Var("x",F32),LN 29), CC[EX(Var("x",F32),LN 1,LN 1,F1), - EX(Var("x",F32),LN 28,LN 4,FTy 25), + EX(Var("x",F32),LN 25,LN 4,FTy 22), EX(Var("x",F32),LN 31,LN 30,FTy 2)]])) ; val reg'HWREna_def = Def ("reg'HWREna",Var("x",CTy"HWREna"), CS(Var("x",CTy"HWREna"), [(Rec(CTy"HWREna", - [bVar"CC",bVar"CCRes",bVar"CPUNum",bVar"UL", - Var("hwrena'rst",FTy 28)]), + [bVar"CC",bVar"CCRes",bVar"CPUNum",bVar"DS",bVar"KS",bVar"RS", + bVar"UL",Var("hwrena'rst",FTy 25)]), Bop(Mdfy, Close (TP[nVar"i",AVar bTy], ITB([(EQ(nVar"i",LN 31), - Bop(Bit,Var("hwrena'rst",FTy 28),LN 1)), + Bop(Bit,Var("hwrena'rst",FTy 25),LN 1)), (EQ(nVar"i",LN 30), - Bop(Bit,Var("hwrena'rst",FTy 28),LN 0)), + Bop(Bit,Var("hwrena'rst",FTy 25),LN 0)), (EQ(nVar"i",LN 29),bVar"UL"), - (EQ(nVar"i",LN 28), - Bop(Bit,Var("hwrena'rst",FTy 28),LN 26)), - (EQ(nVar"i",LN 27), - Bop(Bit,Var("hwrena'rst",FTy 28),LN 25)), - (EQ(nVar"i",LN 26), - Bop(Bit,Var("hwrena'rst",FTy 28),LN 24)), + (EQ(nVar"i",LN 28),bVar"DS"), + (EQ(nVar"i",LN 27),bVar"RS"), + (EQ(nVar"i",LN 26),bVar"KS"), (EQ(nVar"i",LN 25), - Bop(Bit,Var("hwrena'rst",FTy 28),LN 23)), + Bop(Bit,Var("hwrena'rst",FTy 25),LN 23)), (EQ(nVar"i",LN 24), - Bop(Bit,Var("hwrena'rst",FTy 28),LN 22)), + Bop(Bit,Var("hwrena'rst",FTy 25),LN 22)), (EQ(nVar"i",LN 23), - Bop(Bit,Var("hwrena'rst",FTy 28),LN 21)), + Bop(Bit,Var("hwrena'rst",FTy 25),LN 21)), (EQ(nVar"i",LN 22), - Bop(Bit,Var("hwrena'rst",FTy 28),LN 20)), + Bop(Bit,Var("hwrena'rst",FTy 25),LN 20)), (EQ(nVar"i",LN 21), - Bop(Bit,Var("hwrena'rst",FTy 28),LN 19)), + Bop(Bit,Var("hwrena'rst",FTy 25),LN 19)), (EQ(nVar"i",LN 20), - Bop(Bit,Var("hwrena'rst",FTy 28),LN 18)), + Bop(Bit,Var("hwrena'rst",FTy 25),LN 18)), (EQ(nVar"i",LN 19), - Bop(Bit,Var("hwrena'rst",FTy 28),LN 17)), + Bop(Bit,Var("hwrena'rst",FTy 25),LN 17)), (EQ(nVar"i",LN 18), - Bop(Bit,Var("hwrena'rst",FTy 28),LN 16)), + Bop(Bit,Var("hwrena'rst",FTy 25),LN 16)), (EQ(nVar"i",LN 17), - Bop(Bit,Var("hwrena'rst",FTy 28),LN 15)), + Bop(Bit,Var("hwrena'rst",FTy 25),LN 15)), (EQ(nVar"i",LN 16), - Bop(Bit,Var("hwrena'rst",FTy 28),LN 14)), + Bop(Bit,Var("hwrena'rst",FTy 25),LN 14)), (EQ(nVar"i",LN 15), - Bop(Bit,Var("hwrena'rst",FTy 28),LN 13)), + Bop(Bit,Var("hwrena'rst",FTy 25),LN 13)), (EQ(nVar"i",LN 14), - Bop(Bit,Var("hwrena'rst",FTy 28),LN 12)), + Bop(Bit,Var("hwrena'rst",FTy 25),LN 12)), (EQ(nVar"i",LN 13), - Bop(Bit,Var("hwrena'rst",FTy 28),LN 11)), + Bop(Bit,Var("hwrena'rst",FTy 25),LN 11)), (EQ(nVar"i",LN 12), - Bop(Bit,Var("hwrena'rst",FTy 28),LN 10)), + Bop(Bit,Var("hwrena'rst",FTy 25),LN 10)), (EQ(nVar"i",LN 11), - Bop(Bit,Var("hwrena'rst",FTy 28),LN 9)), + Bop(Bit,Var("hwrena'rst",FTy 25),LN 9)), (EQ(nVar"i",LN 10), - Bop(Bit,Var("hwrena'rst",FTy 28),LN 8)), + Bop(Bit,Var("hwrena'rst",FTy 25),LN 8)), (EQ(nVar"i",LN 9), - Bop(Bit,Var("hwrena'rst",FTy 28),LN 7)), + Bop(Bit,Var("hwrena'rst",FTy 25),LN 7)), (EQ(nVar"i",LN 8), - Bop(Bit,Var("hwrena'rst",FTy 28),LN 6)), + Bop(Bit,Var("hwrena'rst",FTy 25),LN 6)), (EQ(nVar"i",LN 7), - Bop(Bit,Var("hwrena'rst",FTy 28),LN 5)), + Bop(Bit,Var("hwrena'rst",FTy 25),LN 5)), (EQ(nVar"i",LN 6), - Bop(Bit,Var("hwrena'rst",FTy 28),LN 4)), + Bop(Bit,Var("hwrena'rst",FTy 25),LN 4)), (EQ(nVar"i",LN 5), - Bop(Bit,Var("hwrena'rst",FTy 28),LN 3)), + Bop(Bit,Var("hwrena'rst",FTy 25),LN 3)), (EQ(nVar"i",LN 4), - Bop(Bit,Var("hwrena'rst",FTy 28),LN 2)), + Bop(Bit,Var("hwrena'rst",FTy 25),LN 2)), (EQ(nVar"i",LN 3),bVar"CCRes"), (EQ(nVar"i",LN 2),bVar"CC"), (EQ(nVar"i",LN 1), - Bop(Bit,Var("hwrena'rst",FTy 28),LN 27))], + Bop(Bit,Var("hwrena'rst",FTy 25),LN 24))], bVar"CPUNum")),LW(0,32)))])) ; val write'rec'HWREna_def = Def @@ -1779,333 +1788,6 @@ val WORD_def = Def0 ("WORD",LW(3,3)) ; val DOUBLEWORD_def = Def0 ("DOUBLEWORD",LW(7,3)) ; -val gpr_def = Def - ("gpr",Var("n",FTy 5), - Close - (qVar"state", - TP[Apply - (Apply - (Dest("c_gpr",ATy(F8,ATy(FTy 5,F64)),qVar"state"), - Dest("procID",F8,qVar"state")),Var("n",FTy 5)),qVar"state"])) -; -val write'gpr_def = Def - ("write'gpr",TP[Var("value",F64),Var("n",FTy 5)], - Close - (qVar"state", - TP[LU, - Let(Var("s",PTy(ATy(FTy 5,F64),qTy)), - TP[Fupd - (Apply - (Dest("c_gpr",ATy(F8,ATy(FTy 5,F64)),qVar"state"), - Dest("procID",F8,qVar"state")),Var("n",FTy 5), - Var("value",F64)),qVar"state"], - Rupd - ("c_gpr", - TP[Mop(Snd,Var("s",PTy(ATy(FTy 5,F64),qTy))), - Fupd - (Dest - ("c_gpr",ATy(F8,ATy(FTy 5,F64)), - Mop(Snd,Var("s",PTy(ATy(FTy 5,F64),qTy)))), - Dest - ("procID",F8, - Mop(Snd,Var("s",PTy(ATy(FTy 5,F64),qTy)))), - Mop(Fst,Var("s",PTy(ATy(FTy 5,F64),qTy))))]))])) -; -val PC_def = Def - ("PC",qVar"state", - TP[Apply - (Dest("c_PC",ATy(F8,F64),qVar"state"), - Dest("procID",F8,qVar"state")),qVar"state"]) -; -val write'PC_def = Def - ("write'PC",Var("value",F64), - Close - (qVar"state", - TP[LU, - Rupd - ("c_PC", - TP[qVar"state", - Fupd - (Dest("c_PC",ATy(F8,F64),qVar"state"), - Dest("procID",F8,qVar"state"),Var("value",F64))])])) -; -val hi_def = Def - ("hi",qVar"state", - TP[Apply - (Dest("c_hi",ATy(F8,OTy F64),qVar"state"), - Dest("procID",F8,qVar"state")),qVar"state"]) -; -val write'hi_def = Def - ("write'hi",Var("value",OTy F64), - Close - (qVar"state", - TP[LU, - Rupd - ("c_hi", - TP[qVar"state", - Fupd - (Dest("c_hi",ATy(F8,OTy F64),qVar"state"), - Dest("procID",F8,qVar"state"),Var("value",OTy F64))])])) -; -val lo_def = Def - ("lo",qVar"state", - TP[Apply - (Dest("c_lo",ATy(F8,OTy F64),qVar"state"), - Dest("procID",F8,qVar"state")),qVar"state"]) -; -val write'lo_def = Def - ("write'lo",Var("value",OTy F64), - Close - (qVar"state", - TP[LU, - Rupd - ("c_lo", - TP[qVar"state", - Fupd - (Dest("c_lo",ATy(F8,OTy F64),qVar"state"), - Dest("procID",F8,qVar"state"),Var("value",OTy F64))])])) -; -val CP0_def = Def - ("CP0",qVar"state", - TP[Apply - (Dest("c_CP0",ATy(F8,CTy"CP0"),qVar"state"), - Dest("procID",F8,qVar"state")),qVar"state"]) -; -val write'CP0_def = Def - ("write'CP0",Var("value",CTy"CP0"), - Close - (qVar"state", - TP[LU, - Rupd - ("c_CP0", - TP[qVar"state", - Fupd - (Dest("c_CP0",ATy(F8,CTy"CP0"),qVar"state"), - Dest("procID",F8,qVar"state"),Var("value",CTy"CP0"))])])) -; -val BranchDelay_def = Def - ("BranchDelay",qVar"state", - TP[Apply - (Dest("c_BranchDelay",ATy(F8,OTy F64),qVar"state"), - Dest("procID",F8,qVar"state")),qVar"state"]) -; -val write'BranchDelay_def = Def - ("write'BranchDelay",Var("value",OTy F64), - Close - (qVar"state", - TP[LU, - Rupd - ("c_BranchDelay", - TP[qVar"state", - Fupd - (Dest("c_BranchDelay",ATy(F8,OTy F64),qVar"state"), - Dest("procID",F8,qVar"state"),Var("value",OTy F64))])])) -; -val BranchTo_def = Def - ("BranchTo",qVar"state", - TP[Apply - (Dest("c_BranchTo",ATy(F8,OTy F64),qVar"state"), - Dest("procID",F8,qVar"state")),qVar"state"]) -; -val write'BranchTo_def = Def - ("write'BranchTo",Var("value",OTy F64), - Close - (qVar"state", - TP[LU, - Rupd - ("c_BranchTo", - TP[qVar"state", - Fupd - (Dest("c_BranchTo",ATy(F8,OTy F64),qVar"state"), - Dest("procID",F8,qVar"state"),Var("value",OTy F64))])])) -; -val LLbit_def = Def - ("LLbit",qVar"state", - TP[Apply - (Dest("c_LLbit",ATy(F8,OTy bTy),qVar"state"), - Dest("procID",F8,qVar"state")),qVar"state"]) -; -val write'LLbit_def = Def - ("write'LLbit",Var("value",OTy bTy), - Close - (qVar"state", - TP[LU, - Rupd - ("c_LLbit", - TP[qVar"state", - Fupd - (Dest("c_LLbit",ATy(F8,OTy bTy),qVar"state"), - Dest("procID",F8,qVar"state"),Var("value",OTy bTy))])])) -; -val exceptionSignalled_def = Def - ("exceptionSignalled",qVar"state", - TP[Apply - (Dest("c_exceptionSignalled",ATy(F8,bTy),qVar"state"), - Dest("procID",F8,qVar"state")),qVar"state"]) -; -val write'exceptionSignalled_def = Def - ("write'exceptionSignalled",bVar"value", - Close - (qVar"state", - TP[LU, - Rupd - ("c_exceptionSignalled", - TP[qVar"state", - Fupd - (Dest("c_exceptionSignalled",ATy(F8,bTy),qVar"state"), - Dest("procID",F8,qVar"state"),bVar"value")])])) -; -val UserMode_def = Def - ("UserMode",qVar"state", - TP[Bop(And, - EQ(Dest - ("KSU",FTy 2, - Dest - ("Status",CTy"StatusRegister", - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"state")))),LW(2,2)), - Mop(Not, - Bop(Or, - Dest - ("EXL",bTy, - Dest - ("Status",CTy"StatusRegister", - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"state")))), - Dest - ("ERL",bTy, - Dest - ("Status",CTy"StatusRegister", - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"state"))))))),qVar"state"]) -; -val SupervisorMode_def = Def - ("SupervisorMode",qVar"state", - TP[Bop(And, - EQ(Dest - ("KSU",FTy 2, - Dest - ("Status",CTy"StatusRegister", - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"state")))),LW(1,2)), - Mop(Not, - Bop(Or, - Dest - ("EXL",bTy, - Dest - ("Status",CTy"StatusRegister", - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"state")))), - Dest - ("ERL",bTy, - Dest - ("Status",CTy"StatusRegister", - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"state"))))))),qVar"state"]) -; -val KernelMode_def = Def - ("KernelMode",qVar"state", - TP[Bop(Or, - Bop(Or, - EQ(Dest - ("KSU",FTy 2, - Dest - ("Status",CTy"StatusRegister", - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"state")))),LW(0,2)), - Dest - ("EXL",bTy, - Dest - ("Status",CTy"StatusRegister", - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"state"))))), - Dest - ("ERL",bTy, - Dest - ("Status",CTy"StatusRegister", - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"state"))))), - qVar"state"]) -; -val BigEndianMem_def = Def - ("BigEndianMem",qVar"state", - TP[Dest - ("BE",bTy, - Dest - ("Config",CTy"ConfigRegister", - Mop(Fst, - Apply(Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"state")))), - qVar"state"]) -; -val ReverseEndian_def = Def - ("ReverseEndian",qVar"state", - TP[Mop(Cast F1, - Bop(And, - Dest - ("RE",bTy, - Dest - ("Status",CTy"StatusRegister", - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"state")))), - Mop(Fst, - Apply - (Const("UserMode",ATy(qTy,PTy(bTy,qTy))),qVar"state")))), - qVar"state"]) -; -val BigEndianCPU_def = Def - ("BigEndianCPU",qVar"state", - TP[Bop(BXor, - Mop(Cast F1, - Mop(Fst, - Apply - (Const("BigEndianMem",ATy(qTy,PTy(bTy,qTy))), - qVar"state"))), - Mop(Fst, - Apply - (Const("ReverseEndian",ATy(qTy,PTy(F1,qTy))),qVar"state"))), - qVar"state"]) -; -val NotWordValue_def = Def - ("NotWordValue",Var("value",F64), - Let(Var("top",F32),EX(Var("value",F64),LN 63,LN 32,F32), - ITE(Bop(Bit,Var("value",F64),LN 31), - Mop(Not,EQ(Var("top",F32),LW(4294967295,32))), - Mop(Not,EQ(Var("top",F32),LW(0,32)))))) -; -val CheckBranch_def = Def - ("CheckBranch",qVar"state", - ITE(Mop(IsSome, - Mop(Fst, - Apply - (Const("BranchDelay",ATy(qTy,PTy(OTy F64,qTy))), - qVar"state"))), - Apply - (Call - ("raise'exception",ATy(qTy,PTy(uTy,qTy)), - Call - ("UNPREDICTABLE",CTy"exception", - LS"Not permitted in delay slot")),qVar"state"), - TP[LU,qVar"state"])) -; val cpr_def = Def ("cpr",Var("r",FTy 5), CC[LS"c0_", @@ -2222,6 +1904,499 @@ val hex64_def = Def ("hex64",Var("x",F64), Mop(PadLeft,TP[LSC #"0",LN 16,Mop(Cast sTy,Var("x",F64))])) ; +val gpr_def = Def + ("gpr",Var("n",FTy 5), + Close + (qVar"state", + TP[Apply + (Apply + (Dest("c_gpr",ATy(F8,ATy(FTy 5,F64)),qVar"state"), + Dest("procID",F8,qVar"state")),Var("n",FTy 5)),qVar"state"])) +; +val write'gpr_def = Def + ("write'gpr",TP[Var("value",F64),Var("n",FTy 5)], + Close + (qVar"state", + TP[LU, + Let(Var("s",PTy(ATy(FTy 5,F64),qTy)), + TP[Fupd + (Apply + (Dest("c_gpr",ATy(F8,ATy(FTy 5,F64)),qVar"state"), + Dest("procID",F8,qVar"state")),Var("n",FTy 5), + Var("value",F64)),qVar"state"], + Rupd + ("c_gpr", + TP[Mop(Snd,Var("s",PTy(ATy(FTy 5,F64),qTy))), + Fupd + (Dest + ("c_gpr",ATy(F8,ATy(FTy 5,F64)), + Mop(Snd,Var("s",PTy(ATy(FTy 5,F64),qTy)))), + Dest + ("procID",F8, + Mop(Snd,Var("s",PTy(ATy(FTy 5,F64),qTy)))), + Mop(Fst,Var("s",PTy(ATy(FTy 5,F64),qTy))))]))])) +; +val GPR_def = Def + ("GPR",Var("n",FTy 5), + Close + (qVar"state", + TP[ITE(EQ(Var("n",FTy 5),LW(0,5)),LW(0,64), + Mop(Fst, + Apply + (Call("gpr",ATy(qTy,PTy(F64,qTy)),Var("n",FTy 5)), + qVar"state"))),qVar"state"])) +; +val write'GPR_def = Def + ("write'GPR",TP[Var("value",F64),Var("n",FTy 5)], + Close + (qVar"state", + ITE(Mop(Not,EQ(Var("n",FTy 5),LW(0,5))), + Apply + (Call + ("mark_log",ATy(qTy,PTy(uTy,qTy)), + TP[LN 2, + Call + ("log_w_gpr",sTy,TP[Var("n",FTy 5),Var("value",F64)])]), + Mop(Snd, + Apply + (Call + ("write'gpr",ATy(qTy,PTy(uTy,qTy)), + TP[Var("value",F64),Var("n",FTy 5)]),qVar"state"))), + TP[LU,qVar"state"]))) +; +val PC_def = Def + ("PC",qVar"state", + TP[Apply + (Dest("c_PC",ATy(F8,F64),qVar"state"), + Dest("procID",F8,qVar"state")),qVar"state"]) +; +val write'PC_def = Def + ("write'PC",Var("value",F64), + Close + (qVar"state", + TP[LU, + Rupd + ("c_PC", + TP[qVar"state", + Fupd + (Dest("c_PC",ATy(F8,F64),qVar"state"), + Dest("procID",F8,qVar"state"),Var("value",F64))])])) +; +val hi_def = Def + ("hi",qVar"state", + TP[Apply + (Dest("c_hi",ATy(F8,OTy F64),qVar"state"), + Dest("procID",F8,qVar"state")),qVar"state"]) +; +val write'hi_def = Def + ("write'hi",Var("value",OTy F64), + Close + (qVar"state", + TP[LU, + Rupd + ("c_hi", + TP[qVar"state", + Fupd + (Dest("c_hi",ATy(F8,OTy F64),qVar"state"), + Dest("procID",F8,qVar"state"),Var("value",OTy F64))])])) +; +val lo_def = Def + ("lo",qVar"state", + TP[Apply + (Dest("c_lo",ATy(F8,OTy F64),qVar"state"), + Dest("procID",F8,qVar"state")),qVar"state"]) +; +val write'lo_def = Def + ("write'lo",Var("value",OTy F64), + Close + (qVar"state", + TP[LU, + Rupd + ("c_lo", + TP[qVar"state", + Fupd + (Dest("c_lo",ATy(F8,OTy F64),qVar"state"), + Dest("procID",F8,qVar"state"),Var("value",OTy F64))])])) +; +val CP0_def = Def + ("CP0",qVar"state", + TP[Apply + (Dest("c_CP0",ATy(F8,CTy"CP0"),qVar"state"), + Dest("procID",F8,qVar"state")),qVar"state"]) +; +val write'CP0_def = Def + ("write'CP0",Var("value",CTy"CP0"), + Close + (qVar"state", + TP[LU, + Rupd + ("c_CP0", + TP[qVar"state", + Fupd + (Dest("c_CP0",ATy(F8,CTy"CP0"),qVar"state"), + Dest("procID",F8,qVar"state"),Var("value",CTy"CP0"))])])) +; +val BranchDelay_def = Def + ("BranchDelay",qVar"state", + TP[Apply + (Dest("c_BranchDelay",ATy(F8,OTy F64),qVar"state"), + Dest("procID",F8,qVar"state")),qVar"state"]) +; +val write'BranchDelay_def = Def + ("write'BranchDelay",Var("value",OTy F64), + Close + (qVar"state", + TP[LU, + Rupd + ("c_BranchDelay", + TP[qVar"state", + Fupd + (Dest("c_BranchDelay",ATy(F8,OTy F64),qVar"state"), + Dest("procID",F8,qVar"state"),Var("value",OTy F64))])])) +; +val BranchTo_def = Def + ("BranchTo",qVar"state", + TP[Apply + (Dest("c_BranchTo",ATy(F8,OTy F64),qVar"state"), + Dest("procID",F8,qVar"state")),qVar"state"]) +; +val write'BranchTo_def = Def + ("write'BranchTo",Var("value",OTy F64), + Close + (qVar"state", + TP[LU, + Rupd + ("c_BranchTo", + TP[qVar"state", + Fupd + (Dest("c_BranchTo",ATy(F8,OTy F64),qVar"state"), + Dest("procID",F8,qVar"state"),Var("value",OTy F64))])])) +; +val LLbit_def = Def + ("LLbit",qVar"state", + TP[Apply + (Dest("c_LLbit",ATy(F8,OTy bTy),qVar"state"), + Dest("procID",F8,qVar"state")),qVar"state"]) +; +val write'LLbit_def = Def + ("write'LLbit",Var("value",OTy bTy), + Close + (qVar"state", + TP[LU, + Rupd + ("c_LLbit", + TP[qVar"state", + Fupd + (Dest("c_LLbit",ATy(F8,OTy bTy),qVar"state"), + Dest("procID",F8,qVar"state"),Var("value",OTy bTy))])])) +; +val exceptionSignalled_def = Def + ("exceptionSignalled",qVar"state", + TP[Apply + (Dest("c_exceptionSignalled",ATy(F8,bTy),qVar"state"), + Dest("procID",F8,qVar"state")),qVar"state"]) +; +val write'exceptionSignalled_def = Def + ("write'exceptionSignalled",bVar"value", + Close + (qVar"state", + TP[LU, + Rupd + ("c_exceptionSignalled", + TP[qVar"state", + Fupd + (Dest("c_exceptionSignalled",ATy(F8,bTy),qVar"state"), + Dest("procID",F8,qVar"state"),bVar"value")])])) +; +val UserMode_def = Def + ("UserMode",qVar"state", + TP[Bop(And, + EQ(Dest + ("KSU",FTy 2, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state")))),LW(2,2)), + Mop(Not, + Bop(Or, + Dest + ("EXL",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state")))), + Dest + ("ERL",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state"))))))),qVar"state"]) +; +val SupervisorMode_def = Def + ("SupervisorMode",qVar"state", + TP[Bop(And, + EQ(Dest + ("KSU",FTy 2, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state")))),LW(1,2)), + Mop(Not, + Bop(Or, + Dest + ("EXL",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state")))), + Dest + ("ERL",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state"))))))),qVar"state"]) +; +val KernelMode_def = Def + ("KernelMode",qVar"state", + TP[Bop(Or, + Bop(Or, + EQ(Dest + ("KSU",FTy 2, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state")))),LW(0,2)), + Dest + ("EXL",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state"))))), + Dest + ("ERL",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"state"))))), + qVar"state"]) +; +val BigEndianMem_def = Def + ("BigEndianMem",qVar"state", + TP[Dest + ("BE",bTy, + Dest + ("Config",CTy"ConfigRegister", + Mop(Fst, + Apply(Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"state")))), + qVar"state"]) +; +val ReverseEndian_def = Def + ("ReverseEndian",qVar"state", + TP[Mop(Cast F1, + Bop(And, + Dest + ("RE",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state")))), + Mop(Fst, + Apply + (Const("UserMode",ATy(qTy,PTy(bTy,qTy))),qVar"state")))), + qVar"state"]) +; +val BigEndianCPU_def = Def + ("BigEndianCPU",qVar"state", + TP[Bop(BXor, + Mop(Cast F1, + Mop(Fst, + Apply + (Const("BigEndianMem",ATy(qTy,PTy(bTy,qTy))), + qVar"state"))), + Mop(Fst, + Apply + (Const("ReverseEndian",ATy(qTy,PTy(F1,qTy))),qVar"state"))), + qVar"state"]) +; +val NotWordValue_def = Def + ("NotWordValue",Var("value",F64), + Let(Var("top",F32),EX(Var("value",F64),LN 63,LN 32,F32), + ITE(Bop(Bit,Var("value",F64),LN 31), + Mop(Not,EQ(Var("top",F32),LW(4294967295,32))), + Mop(Not,EQ(Var("top",F32),LW(0,32)))))) +; +val CheckBranch_def = Def + ("CheckBranch",qVar"state", + ITE(Mop(IsSome, + Mop(Fst, + Apply + (Const("BranchDelay",ATy(qTy,PTy(OTy F64,qTy))), + qVar"state"))), + Apply + (Call + ("raise'exception",ATy(qTy,PTy(uTy,qTy)), + Call + ("UNPREDICTABLE",CTy"exception", + LS"Not permitted in delay slot")),qVar"state"), + TP[LU,qVar"state"])) +; +val dumpRegs_def = Def + ("dumpRegs",AVar uTy, + Close + (qVar"state", + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("mark_log",ATy(qTy,PTy(uTy,qTy)), + TP[LN 0,LS"====== Registers ======"]),qVar"state")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("mark_log",ATy(qTy,PTy(uTy,qTy)), + TP[LN 0, + CC[LS"Core = ", + Mop(Cast sTy, + Mop(Cast nTy,Dest("procID",F8,qVar"s")))]]), + qVar"s")), + Apply + (For(TP[LN 0,LN 31, + Close + (nVar"i", + Close + (qVar"state", + Apply + (Call + ("mark_log",ATy(qTy,PTy(uTy,qTy)), + TP[LN 0, + CC[LS"Reg ", + ITE(Bop(Lt,nVar"i",LN 10),LS" ", + LS""),Mop(Cast sTy,nVar"i"), + LS" ", + Call + ("hex64",sTy, + Mop(Fst, + Apply + (Call + ("GPR", + ATy(qTy, + PTy(F64,qTy)), + Mop(Cast(FTy 5), + nVar"i")), + qVar"state")))]]), + qVar"state")))]), + Mop(Snd, + Apply + (Call + ("mark_log",ATy(qTy,PTy(uTy,qTy)), + TP[LN 0, + CC[LS"PC ", + Call + ("hex64",sTy, + Mop(Fst, + Apply + (Const + ("PC",ATy(qTy,PTy(F64,qTy))), + qVar"s")))]]),qVar"s"))))))) +; +val coreStats_def = Def + ("coreStats",qVar"state", + TP[Apply + (Dest("c_CoreStats",ATy(F8,CTy"CoreStats"),qVar"state"), + Dest("procID",F8,qVar"state")),qVar"state"]) +; +val write'coreStats_def = Def + ("write'coreStats",Var("value",CTy"CoreStats"), + Close + (qVar"state", + TP[LU, + Let(Var("s",PTy(CTy"CoreStats",qTy)), + TP[Var("value",CTy"CoreStats"),qVar"state"], + Rupd + ("c_CoreStats", + TP[Mop(Snd,Var("s",PTy(CTy"CoreStats",qTy))), + Fupd + (Dest + ("c_CoreStats",ATy(F8,CTy"CoreStats"), + Mop(Snd,Var("s",PTy(CTy"CoreStats",qTy)))), + Dest + ("procID",F8, + Mop(Snd,Var("s",PTy(CTy"CoreStats",qTy)))), + Mop(Fst,Var("s",PTy(CTy"CoreStats",qTy))))]))])) +; +val initCoreStats_def = Def + ("initCoreStats",qVar"state", + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'coreStats",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("branch_taken", + TP[Mop(Fst, + Apply + (Const + ("coreStats", + ATy(qTy,PTy(CTy"CoreStats",qTy))), + qVar"state")),LN 0])),qVar"state")), + Apply + (Call + ("write'coreStats",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("branch_not_taken", + TP[Mop(Fst, + Apply + (Const + ("coreStats",ATy(qTy,PTy(CTy"CoreStats",qTy))), + qVar"s")),LN 0])),qVar"s"))) +; +val printCoreStats_def = Def + ("printCoreStats",qVar"state", + TP[CC[Mop(PadRight,TP[LSC #" ",LN 16,LS"branch_taken"]),LS" = ", + Mop(PadLeft, + TP[LSC #" ",LN 9, + Mop(Cast sTy, + Dest + ("branch_taken",nTy, + Mop(Fst, + Apply + (Const + ("coreStats", + ATy(qTy,PTy(CTy"CoreStats",qTy))), + qVar"state"))))]),LS"\n", + Mop(PadRight,TP[LSC #" ",LN 16,LS"branch_not_taken"]),LS" = ", + Mop(PadLeft, + TP[LSC #" ",LN 9, + Mop(Cast sTy, + Dest + ("branch_not_taken",nTy, + Mop(Fst, + Apply + (Const + ("coreStats", + ATy(qTy,PTy(CTy"CoreStats",qTy))), + qVar"state"))))])],qVar"state"]) +; val rec'PIC_Config_Reg_def = Def ("rec'PIC_Config_Reg",Var("x",F64), Rec(CTy"PIC_Config_Reg", @@ -7599,135 +7774,371 @@ val form6_def = Def CC[LW(31,6),LW(0,5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), Var("function",FTy 6)]) ; -val PSIZE_def = Def0 ("PSIZE",LN 40) +val initMemStats_def = Def + ("initMemStats",qVar"state", + Let(qVar"s", + Rupd + ("memStats", + TP[qVar"state", + Rupd + ("data_reads", + TP[Dest("memStats",CTy"MemStats",qVar"state"),LN 0])]), + Let(qVar"s", + Rupd + ("memStats", + TP[qVar"s", + Rupd + ("data_writes", + TP[Dest("memStats",CTy"MemStats",qVar"s"),LN 0])]), + Let(qVar"s", + Rupd + ("memStats", + TP[qVar"s", + Rupd + ("inst_reads", + TP[Dest("memStats",CTy"MemStats",qVar"s"),LN 0])]), + Let(qVar"s", + Rupd + ("memStats", + TP[qVar"s", + Rupd + ("cap_reads", + TP[Dest("memStats",CTy"MemStats",qVar"s"),LN 0])]), + TP[LU, + Rupd + ("memStats", + TP[qVar"s", + Rupd + ("cap_writes", + TP[Dest("memStats",CTy"MemStats",qVar"s"), + LN 0])])]))))) +; +val printMemStats_def = Def + ("printMemStats",qVar"state", + TP[CC[Mop(PadRight,TP[LSC #" ",LN 16,LS"data_reads"]),LS" = ", + Mop(PadLeft, + TP[LSC #" ",LN 9, + Mop(Cast sTy, + Dest + ("data_reads",nTy, + Dest("memStats",CTy"MemStats",qVar"state")))]), + LS"\n",Mop(PadRight,TP[LSC #" ",LN 16,LS"data_writes"]),LS" = ", + Mop(PadLeft, + TP[LSC #" ",LN 9, + Mop(Cast sTy, + Dest + ("data_writes",nTy, + Dest("memStats",CTy"MemStats",qVar"state")))]), + LS"\n",Mop(PadRight,TP[LSC #" ",LN 16,LS"inst_reads"]),LS" = ", + Mop(PadLeft, + TP[LSC #" ",LN 9, + Mop(Cast sTy, + Dest + ("inst_reads",nTy, + Dest("memStats",CTy"MemStats",qVar"state")))]), + LS"\n",Mop(PadRight,TP[LSC #" ",LN 16,LS"cap_reads"]),LS" = ", + Mop(PadLeft, + TP[LSC #" ",LN 9, + Mop(Cast sTy, + Dest + ("cap_reads",nTy, + Dest("memStats",CTy"MemStats",qVar"state")))]), + LS"\n",Mop(PadRight,TP[LSC #" ",LN 16,LS"cap_writes"]),LS" = ", + Mop(PadLeft, + TP[LSC #" ",LN 9, + Mop(Cast sTy, + Dest + ("cap_writes",nTy, + Dest("memStats",CTy"MemStats",qVar"state")))])], + qVar"state"]) ; -val GPR_def = Def - ("GPR",Var("n",FTy 5), +val InitMEM_def = Def + ("InitMEM",qVar"state", + TP[LU, + Rupd + ("MEM", + TP[Mop(Snd, + Apply + (Const("initMemStats",ATy(qTy,PTy(uTy,qTy))),qVar"state")), + Mop(K1(FTy 35),LX(FTy 257))])]) +; +val ReadData_def = Def + ("ReadData",Var("pAddr",FTy 37), Close (qVar"state", - TP[ITE(EQ(Var("n",FTy 5),LW(0,5)),LW(0,64), - Mop(Fst, - Apply - (Call("gpr",ATy(qTy,PTy(F64,qTy)),Var("n",FTy 5)), - qVar"state"))),qVar"state"])) + Let(qVar"s", + Rupd + ("memStats", + TP[qVar"state", + Rupd + ("data_reads", + TP[Dest("memStats",CTy"MemStats",qVar"state"), + Bop(Add, + Dest + ("data_reads",nTy, + Dest("memStats",CTy"MemStats",qVar"state")), + LN 1)])]), + Let(Var("v",FTy 257), + Apply + (Dest("MEM",ATy(FTy 35,FTy 257),qVar"s"), + EX(Var("pAddr",FTy 37),LN 36,LN 2,FTy 35)), + TP[CS(EX(Var("pAddr",FTy 37),LN 1,LN 0,FTy 2), + [(LW(0,2),EX(Var("v",FTy 257),LN 63,LN 0,F64)), + (LW(1,2),EX(Var("v",FTy 257),LN 127,LN 64,F64)), + (LW(2,2),EX(Var("v",FTy 257),LN 191,LN 128,F64)), + (LW(3,2),EX(Var("v",FTy 257),LN 255,LN 192,F64))]), + qVar"s"])))) ; -val write'GPR_def = Def - ("write'GPR",TP[Var("value",F64),Var("n",FTy 5)], +val WriteData_def = Def + ("WriteData",TP[Var("pAddr",FTy 37),Var("data",F64),Var("mask",F64)], Close (qVar"state", - ITE(Mop(Not,EQ(Var("n",FTy 5),LW(0,5))), - Apply - (Call - ("mark_log",ATy(qTy,PTy(uTy,qTy)), - TP[LN 2, - Call - ("log_w_gpr",sTy,TP[Var("n",FTy 5),Var("value",F64)])]), - Mop(Snd, - Apply - (Call - ("write'gpr",ATy(qTy,PTy(uTy,qTy)), - TP[Var("value",F64),Var("n",FTy 5)]),qVar"state"))), - TP[LU,qVar"state"]))) + Let(qVar"s", + Rupd + ("memStats", + TP[qVar"state", + Rupd + ("data_writes", + TP[Dest("memStats",CTy"MemStats",qVar"state"), + Bop(Add, + Dest + ("data_writes",nTy, + Dest("memStats",CTy"MemStats",qVar"state")), + LN 1)])]), + Let(Var("v",FTy 257), + Apply + (Dest("MEM",ATy(FTy 35,FTy 257),qVar"s"), + EX(Var("pAddr",FTy 37),LN 36,LN 2,FTy 35)), + CS(EX(Var("pAddr",FTy 37),LN 1,LN 0,FTy 2), + [(LW(0,2), + TP[LU, + Rupd + ("MEM", + TP[qVar"s", + Fupd + (Dest("MEM",ATy(FTy 35,FTy 257),qVar"s"), + EX(Var("pAddr",FTy 37),LN 36,LN 2,FTy 35), + CC[LW(0,1), + EX(Var("v",FTy 257),LN 255,LN 64,FTy 192), + Bop(BOr, + Bop(BAnd, + EX(Var("v",FTy 257),LN 63,LN 0, + F64), + Mop(BNot,Var("mask",F64))), + Bop(BAnd,Var("data",F64), + Var("mask",F64)))])])]), + (LW(1,2), + TP[LU, + Rupd + ("MEM", + TP[qVar"s", + Fupd + (Dest("MEM",ATy(FTy 35,FTy 257),qVar"s"), + EX(Var("pAddr",FTy 37),LN 36,LN 2,FTy 35), + CC[LW(0,1), + EX(Var("v",FTy 257),LN 255,LN 128, + FTy 128), + Bop(BOr, + Bop(BAnd, + EX(Var("v",FTy 257),LN 127, + LN 64,F64), + Mop(BNot,Var("mask",F64))), + Bop(BAnd,Var("data",F64), + Var("mask",F64))), + EX(Var("v",FTy 257),LN 63,LN 0,F64)])])]), + (LW(2,2), + TP[LU, + Rupd + ("MEM", + TP[qVar"s", + Fupd + (Dest("MEM",ATy(FTy 35,FTy 257),qVar"s"), + EX(Var("pAddr",FTy 37),LN 36,LN 2,FTy 35), + CC[LW(0,1), + EX(Var("v",FTy 257),LN 255,LN 192,F64), + Bop(BOr, + Bop(BAnd, + EX(Var("v",FTy 257),LN 191, + LN 128,F64), + Mop(BNot,Var("mask",F64))), + Bop(BAnd,Var("data",F64), + Var("mask",F64))), + EX(Var("v",FTy 257),LN 127,LN 0,FTy 128)])])]), + (LW(3,2), + TP[LU, + Rupd + ("MEM", + TP[qVar"s", + Fupd + (Dest("MEM",ATy(FTy 35,FTy 257),qVar"s"), + EX(Var("pAddr",FTy 37),LN 36,LN 2,FTy 35), + CC[LW(0,1), + Bop(BOr, + Bop(BAnd, + EX(Var("v",FTy 257),LN 255, + LN 192,F64), + Mop(BNot,Var("mask",F64))), + Bop(BAnd,Var("data",F64), + Var("mask",F64))), + EX(Var("v",FTy 257),LN 191,LN 0,FTy 192)])])])]))))) ; -val dumpRegs_def = Def - ("dumpRegs",AVar uTy, +val ReadInst_def = Def + ("ReadInst",Var("a",FTy 40), Close (qVar"state", Let(qVar"s", - Mop(Snd, + Rupd + ("memStats", + TP[qVar"state", + Rupd + ("inst_reads", + TP[Dest("memStats",CTy"MemStats",qVar"state"), + Bop(Add, + Dest + ("inst_reads",nTy, + Dest("memStats",CTy"MemStats",qVar"state")), + LN 1)])]), + Let(Var("v",FTy 257), Apply - (Call - ("mark_log",ATy(qTy,PTy(uTy,qTy)), - TP[LN 0,LS"====== Registers ======"]),qVar"state")), - Let(qVar"s", - Mop(Snd, - Apply - (Call - ("mark_log",ATy(qTy,PTy(uTy,qTy)), - TP[LN 0, - CC[LS"Core = ", - Mop(Cast sTy, - Mop(Cast nTy,Dest("procID",F8,qVar"s")))]]), - qVar"s")), + (Dest("MEM",ATy(FTy 35,FTy 257),qVar"s"), + EX(Var("a",FTy 40),LN 39,LN 5,FTy 35)), + TP[CS(EX(Var("a",FTy 40),LN 4,LN 2,FTy 3), + [(LW(0,3),EX(Var("v",FTy 257),LN 63,LN 32,F32)), + (LW(1,3),EX(Var("v",FTy 257),LN 31,LN 0,F32)), + (LW(2,3),EX(Var("v",FTy 257),LN 127,LN 96,F32)), + (LW(3,3),EX(Var("v",FTy 257),LN 95,LN 64,F32)), + (LW(4,3),EX(Var("v",FTy 257),LN 191,LN 160,F32)), + (LW(5,3),EX(Var("v",FTy 257),LN 159,LN 128,F32)), + (LW(6,3),EX(Var("v",FTy 257),LN 255,LN 224,F32)), + (LW(7,3),EX(Var("v",FTy 257),LN 223,LN 192,F32))]), + qVar"s"])))) +; +val ReadCap_def = Def + ("ReadCap",Var("capAddr",FTy 35), + Close + (qVar"state", + Let(qVar"s", + Rupd + ("memStats", + TP[qVar"state", + Rupd + ("cap_reads", + TP[Dest("memStats",CTy"MemStats",qVar"state"), + Bop(Add, + Dest + ("cap_reads",nTy, + Dest("memStats",CTy"MemStats",qVar"state")), + LN 1)])]), + Let(Var("v",FTy 257), Apply - (For(TP[LN 0,LN 31, - Close - (nVar"i", - Close - (qVar"state", - Apply - (Call - ("mark_log",ATy(qTy,PTy(uTy,qTy)), - TP[LN 0, - CC[LS"Reg ", - ITE(Bop(Lt,nVar"i",LN 10),LS" ", - LS""),Mop(Cast sTy,nVar"i"), - LS" ", - Call - ("hex64",sTy, - Mop(Fst, - Apply - (Call - ("GPR", - ATy(qTy, - PTy(F64,qTy)), - Mop(Cast(FTy 5), - nVar"i")), - qVar"state")))]]), - qVar"state")))]), - Mop(Snd, - Apply - (Call - ("mark_log",ATy(qTy,PTy(uTy,qTy)), - TP[LN 0, - CC[LS"PC ", - Call - ("hex64",sTy, - Mop(Fst, - Apply - (Const - ("PC",ATy(qTy,PTy(F64,qTy))), - qVar"s")))]]),qVar"s"))))))) -; -val HI_def = Def - ("HI",qVar"state", - CS(Mop(Fst,Apply(Const("hi",ATy(qTy,PTy(OTy F64,qTy))),qVar"state")), - [(Mop(Some,Var("v",F64)),TP[Var("v",F64),qVar"state"]), - (LO F64,TP[LX F64,qVar"state"])])) -; -val write'HI_def = Def - ("write'HI",Var("value",F64), + (Dest("MEM",ATy(FTy 35,FTy 257),qVar"s"), + Var("capAddr",FTy 35)), + TP[Call + ("rec'Capability",CTy"Capability", + CC[ITE(Bop(Bit,Var("v",FTy 257),LN 256),LW(1,1), + LW(0,1)),EX(Var("v",FTy 257),LN 63,LN 0,F64), + EX(Var("v",FTy 257),LN 127,LN 64,F64), + EX(Var("v",FTy 257),LN 191,LN 128,F64), + EX(Var("v",FTy 257),LN 255,LN 192,F64)]),qVar"s"])))) +; +val WriteCap_def = Def + ("WriteCap",TP[Var("capAddr",FTy 35),Var("cap",CTy"Capability")], Close (qVar"state", - Apply - (Call - ("mark_log",ATy(qTy,PTy(uTy,qTy)), - TP[LN 2,Call("log_w_hi",sTy,Var("value",F64))]), - Mop(Snd, - Apply - (Call - ("write'hi",ATy(qTy,PTy(uTy,qTy)), - Mop(Some,Var("value",F64))),qVar"state"))))) + Let(qVar"s", + Rupd + ("memStats", + TP[qVar"state", + Rupd + ("cap_writes", + TP[Dest("memStats",CTy"MemStats",qVar"state"), + Bop(Add, + Dest + ("cap_writes",nTy, + Dest("memStats",CTy"MemStats",qVar"state")), + LN 1)])]), + Let(Var("raw",FTy 257), + Call("reg'Capability",FTy 257,Var("cap",CTy"Capability")), + TP[LU, + Rupd + ("MEM", + TP[qVar"s", + Fupd + (Dest("MEM",ATy(FTy 35,FTy 257),qVar"s"), + Var("capAddr",FTy 35), + CC[ITE(Bop(Bit,Var("raw",FTy 257),LN 256), + LW(1,1),LW(0,1)), + EX(Var("raw",FTy 257),LN 63,LN 0,F64), + EX(Var("raw",FTy 257),LN 127,LN 64,F64), + EX(Var("raw",FTy 257),LN 191,LN 128,F64), + EX(Var("raw",FTy 257),LN 255,LN 192,F64)])])])))) ; -val LO_def = Def - ("LO",qVar"state", - CS(Mop(Fst,Apply(Const("lo",ATy(qTy,PTy(OTy F64,qTy))),qVar"state")), - [(Mop(Some,Var("v",F64)),TP[Var("v",F64),qVar"state"]), - (LO F64,TP[LX F64,qVar"state"])])) +val WriteDWORD_def = Def + ("WriteDWORD",TP[Var("pAddr",FTy 37),Var("data",F64)], + Close + (qVar"state", + Let(Var("v",FTy 257), + Apply + (Dest("MEM",ATy(FTy 35,FTy 257),qVar"state"), + EX(Var("pAddr",FTy 37),LN 36,LN 2,FTy 35)), + CS(EX(Var("pAddr",FTy 37),LN 1,LN 0,FTy 2), + [(LW(0,2), + TP[LU, + Rupd + ("MEM", + TP[qVar"state", + Fupd + (Dest("MEM",ATy(FTy 35,FTy 257),qVar"state"), + EX(Var("pAddr",FTy 37),LN 36,LN 2,FTy 35), + CC[LW(0,1), + EX(Var("v",FTy 257),LN 255,LN 64,FTy 192), + Var("data",F64)])])]), + (LW(1,2), + TP[LU, + Rupd + ("MEM", + TP[qVar"state", + Fupd + (Dest("MEM",ATy(FTy 35,FTy 257),qVar"state"), + EX(Var("pAddr",FTy 37),LN 36,LN 2,FTy 35), + CC[LW(0,1), + EX(Var("v",FTy 257),LN 255,LN 128,FTy 128), + Var("data",F64), + EX(Var("v",FTy 257),LN 63,LN 0,F64)])])]), + (LW(2,2), + TP[LU, + Rupd + ("MEM", + TP[qVar"state", + Fupd + (Dest("MEM",ATy(FTy 35,FTy 257),qVar"state"), + EX(Var("pAddr",FTy 37),LN 36,LN 2,FTy 35), + CC[LW(0,1), + EX(Var("v",FTy 257),LN 255,LN 192,F64), + Var("data",F64), + EX(Var("v",FTy 257),LN 127,LN 0,FTy 128)])])]), + (LW(3,2), + TP[LU, + Rupd + ("MEM", + TP[qVar"state", + Fupd + (Dest("MEM",ATy(FTy 35,FTy 257),qVar"state"), + EX(Var("pAddr",FTy 37),LN 36,LN 2,FTy 35), + CC[LW(0,1),Var("data",F64), + EX(Var("v",FTy 257),LN 191,LN 0,FTy 192)])])])])))) ; -val write'LO_def = Def - ("write'LO",Var("value",F64), +val Write256_def = Def + ("Write256",TP[Var("addr",FTy 35),Var("data",FTy 256)], Close (qVar"state", - Apply - (Call - ("mark_log",ATy(qTy,PTy(uTy,qTy)), - TP[LN 2,Call("log_w_lo",sTy,Var("value",F64))]), - Mop(Snd, - Apply - (Call - ("write'lo",ATy(qTy,PTy(uTy,qTy)), - Mop(Some,Var("value",F64))),qVar"state"))))) + TP[LU, + Rupd + ("MEM", + TP[qVar"state", + Fupd + (Dest("MEM",ATy(FTy 35,FTy 257),qVar"state"), + Var("addr",FTy 35),CC[LW(0,1),Var("data",FTy 256)])])])) ; val flip_endian_word_def = Def ("flip_endian_word",Var("w",F32), @@ -7751,1193 +8162,216 @@ val flip_endian_word_def = Def LL[bVar"a'7",bVar"a'6",bVar"a'5",bVar"a'4",bVar"a'3", bVar"a'2",bVar"a'1",bVar"a'0"])])])) ; -val flip_endian_dword_def = Def - ("flip_endian_dword",Var("dw",F64), - CS(BL(64,Var("dw",F64)), - [(TP[bVar"a'7",bVar"a'6",bVar"a'5",bVar"a'4",bVar"a'3",bVar"a'2", - bVar"a'1",bVar"a'0",bVar"b'7",bVar"b'6",bVar"b'5",bVar"b'4", - bVar"b'3",bVar"b'2",bVar"b'1",bVar"b'0",bVar"c'7",bVar"c'6", - bVar"c'5",bVar"c'4",bVar"c'3",bVar"c'2",bVar"c'1",bVar"c'0", - bVar"d'7",bVar"d'6",bVar"d'5",bVar"d'4",bVar"d'3",bVar"d'2", - bVar"d'1",bVar"d'0",bVar"e'7",bVar"e'6",bVar"e'5",bVar"e'4", - bVar"e'3",bVar"e'2",bVar"e'1",bVar"e'0",bVar"f'7",bVar"f'6", - bVar"f'5",bVar"f'4",bVar"f'3",bVar"f'2",bVar"f'1",bVar"f'0", - bVar"g'7",bVar"g'6",bVar"g'5",bVar"g'4",bVar"g'3",bVar"g'2", - bVar"g'1",bVar"g'0",bVar"h'7",bVar"h'6",bVar"h'5",bVar"h'4", - bVar"h'3",bVar"h'2",bVar"h'1",bVar"h'0"], - CC[Mop(Cast F8, - LL[bVar"h'7",bVar"h'6",bVar"h'5",bVar"h'4",bVar"h'3", - bVar"h'2",bVar"h'1",bVar"h'0"]), - Mop(Cast F8, - LL[bVar"g'7",bVar"g'6",bVar"g'5",bVar"g'4",bVar"g'3", - bVar"g'2",bVar"g'1",bVar"g'0"]), - Mop(Cast F8, - LL[bVar"f'7",bVar"f'6",bVar"f'5",bVar"f'4",bVar"f'3", - bVar"f'2",bVar"f'1",bVar"f'0"]), - Mop(Cast F8, - LL[bVar"e'7",bVar"e'6",bVar"e'5",bVar"e'4",bVar"e'3", - bVar"e'2",bVar"e'1",bVar"e'0"]), - Mop(Cast F8, - LL[bVar"d'7",bVar"d'6",bVar"d'5",bVar"d'4",bVar"d'3", - bVar"d'2",bVar"d'1",bVar"d'0"]), - Mop(Cast F8, - LL[bVar"c'7",bVar"c'6",bVar"c'5",bVar"c'4",bVar"c'3", - bVar"c'2",bVar"c'1",bVar"c'0"]), - Mop(Cast F8, - LL[bVar"b'7",bVar"b'6",bVar"b'5",bVar"b'4",bVar"b'3", - bVar"b'2",bVar"b'1",bVar"b'0"]), - Mop(Cast F8, - LL[bVar"a'7",bVar"a'6",bVar"a'5",bVar"a'4",bVar"a'3", - bVar"a'2",bVar"a'1",bVar"a'0"])])])) +val watchForLoad_def = Def + ("watchForLoad",TP[Var("addr",FTy 40),Var("data",F64)], + Close + (qVar"state", + CS(Dest("watchPaddr",OTy(FTy 40),qVar"state"), + [(Mop(Some,Var("watch_paddr",FTy 40)), + TP[ITE(EQ(EX(Var("addr",FTy 40),LN 39,LN 3,FTy 37), + EX(Var("watch_paddr",FTy 40),LN 39,LN 3,FTy 37)), + Apply + (Dest("println",ATy(sTy,uTy),qVar"state"), + CC[LS"watching --> load 0x", + Mop(PadLeft, + TP[LSC #"0",LN 16, + Mop(Cast sTy,Var("data",F64))]), + LS" from 0x", + Mop(PadLeft, + TP[LSC #"0",LN 10, + Mop(Cast sTy,Var("addr",FTy 40))])]),LU), + qVar"state"]),(LO(FTy 40),TP[LU,qVar"state"])]))) +; +val watchForCapLoad_def = Def + ("watchForCapLoad",TP[Var("addr",FTy 40),Var("cap",CTy"Capability")], + Close + (qVar"state", + CS(Dest("watchPaddr",OTy(FTy 40),qVar"state"), + [(Mop(Some,Var("watch_paddr",FTy 40)), + TP[ITE(EQ(EX(Var("addr",FTy 40),LN 39,LN 5,FTy 35), + EX(Var("watch_paddr",FTy 40),LN 39,LN 5,FTy 35)), + Apply + (Dest("println",ATy(sTy,uTy),qVar"state"), + CC[LS"watching --> load ", + Call + ("log_cap_write",sTy,Var("cap",CTy"Capability")), + LS" from 0x", + Mop(PadLeft, + TP[LSC #"0",LN 10, + Mop(Cast sTy,Var("addr",FTy 40))])]),LU), + qVar"state"]),(LO(FTy 40),TP[LU,qVar"state"])]))) +; +val watchForStore_def = Def + ("watchForStore",TP[Var("addr",FTy 40),Var("data",F64),Var("mask",F64)], + Close + (qVar"state", + CS(Dest("watchPaddr",OTy(FTy 40),qVar"state"), + [(Mop(Some,Var("watch_paddr",FTy 40)), + TP[ITE(EQ(EX(Var("addr",FTy 40),LN 39,LN 3,FTy 37), + EX(Var("watch_paddr",FTy 40),LN 39,LN 3,FTy 37)), + Apply + (Dest("println",ATy(sTy,uTy),qVar"state"), + CC[LS"watching --> Store 0x", + Mop(PadLeft, + TP[LSC #"0",LN 16, + Mop(Cast sTy,Var("data",F64))]),LS"(mask:", + Mop(PadLeft, + TP[LSC #"0",LN 16, + Mop(Cast sTy,Var("mask",F64))]), + LS") at 0x", + Mop(PadLeft, + TP[LSC #"0",LN 10, + Mop(Cast sTy,Var("addr",FTy 40))])]),LU), + qVar"state"]),(LO(FTy 40),TP[LU,qVar"state"])]))) +; +val watchForCapStore_def = Def + ("watchForCapStore",TP[Var("addr",FTy 40),Var("cap",CTy"Capability")], + Close + (qVar"state", + CS(Dest("watchPaddr",OTy(FTy 40),qVar"state"), + [(Mop(Some,Var("watch_paddr",FTy 40)), + TP[ITE(EQ(EX(Var("addr",FTy 40),LN 39,LN 5,FTy 35), + EX(Var("watch_paddr",FTy 40),LN 39,LN 5,FTy 35)), + Apply + (Dest("println",ATy(sTy,uTy),qVar"state"), + CC[LS"watching --> Store 0x", + Call + ("log_cap_write",sTy,Var("cap",CTy"Capability")), + LS") at 0x", + Mop(PadLeft, + TP[LSC #"0",LN 10, + Mop(Cast sTy,Var("addr",FTy 40))])]),LU), + qVar"state"]),(LO(FTy 40),TP[LU,qVar"state"])]))) ; -val CPR_def = Def - ("CPR",TP[nVar"n",Var("reg",FTy 5),Var("sel",FTy 3)], +val LoadMemoryCap_def = Def + ("LoadMemoryCap", + TP[Var("MemType",FTy 3),Var("vAddr",F64),Var("IorD",CTy"IorD"), + Var("AccessType",CTy"AccessType"),bVar"link"], Close (qVar"state", - CS(TP[nVar"n",Var("reg",FTy 5),Var("sel",FTy 3)], - [(TP[LN 0,LW(0,5),LW(0,3)], - TP[Mop(Cast F64, - Call - ("reg'Index",F32, - Dest - ("Index",CTy"Index", - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"state"))))),qVar"state"]), - (TP[LN 0,LW(1,5),LW(0,3)], - TP[Mop(Cast F64, - Call - ("reg'Random",F32, - Dest - ("Random",CTy"Random", - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"state"))))),qVar"state"]), - (TP[LN 0,LW(2,5),LW(0,3)], - TP[Call - ("reg'EntryLo",F64, - Dest - ("EntryLo0",CTy"EntryLo", - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"state")))),qVar"state"]), - (TP[LN 0,LW(3,5),LW(0,3)], - TP[Call - ("reg'EntryLo",F64, - Dest - ("EntryLo1",CTy"EntryLo", - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"state")))),qVar"state"]), - (TP[LN 0,LW(4,5),LW(0,3)], - TP[Call - ("reg'Context",F64, - Dest - ("Context",CTy"Context", - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"state")))),qVar"state"]), - (TP[LN 0,LW(4,5),LW(2,3)], - TP[Dest - ("UsrLocal",F64, - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"state"))),qVar"state"]), - (TP[LN 0,LW(5,5),LW(0,3)], - TP[Mop(Cast F64, - Call - ("reg'PageMask",F32, - Dest - ("PageMask",CTy"PageMask", - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"state"))))),qVar"state"]), - (TP[LN 0,LW(6,5),LW(0,3)], - TP[Mop(Cast F64, - Call - ("reg'Wired",F32, - Dest - ("Wired",CTy"Wired", - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"state"))))),qVar"state"]), - (TP[LN 0,LW(7,5),LW(0,3)], - TP[Mop(Cast F64, - Call - ("reg'HWREna",F32, - Dest - ("HWREna",CTy"HWREna", - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"state"))))),qVar"state"]), - (TP[LN 0,LW(8,5),LW(0,3)], - TP[Dest - ("BadVAddr",F64, - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"state"))),qVar"state"]), - (TP[LN 0,LW(8,5),LW(1,3)], - TP[Mop(Cast F64, - Dest - ("EInstr",F32, - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"state")))),qVar"state"]), - (TP[LN 0,LW(9,5),LW(0,3)], - TP[Mop(Cast F64, - Dest - ("Count",F32, - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"state")))),qVar"state"]), - (TP[LN 0,LW(10,5),LW(0,3)], - TP[Call - ("reg'EntryHi",F64, - Dest - ("EntryHi",CTy"EntryHi", - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"state")))),qVar"state"]), - (TP[LN 0,LW(11,5),LW(0,3)], - TP[Mop(Cast F64, - Dest - ("Compare",F32, - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"state")))),qVar"state"]), - (TP[LN 0,LW(12,5),LW(0,3)], - TP[Mop(Cast F64, - Call - ("reg'StatusRegister",F32, - Dest - ("Status",CTy"StatusRegister", - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"state"))))),qVar"state"]), - (TP[LN 0,LW(13,5),LW(0,3)], - TP[Mop(Cast F64, - Call - ("reg'CauseRegister",F32, - Dest - ("Cause",CTy"CauseRegister", - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"state"))))),qVar"state"]), - (TP[LN 0,LW(14,5),LW(0,3)], - TP[Dest - ("EPC",F64, - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"state"))),qVar"state"]), - (TP[LN 0,LW(15,5),LW(0,3)], - TP[Mop(Cast F64, - Dest - ("PRId",F32, - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"state")))),qVar"state"]), - (TP[LN 0,LW(15,5),LW(1,3)], - TP[Mop(Cast F64, - CC[Mop(Cast F16, - Bop(Sub,Dest("totalCore",nTy,qVar"state"),LN 1)), - Mop(Cast F16,Dest("procID",F8,qVar"state"))]), - qVar"state"]), - (TP[LN 0,LW(15,5),LW(6,3)], - TP[Mop(Cast F64, - CC[Mop(Cast F16, - Bop(Sub,Dest("totalCore",nTy,qVar"state"),LN 1)), - Mop(Cast F16,Dest("procID",F8,qVar"state"))]), - qVar"state"]), - (TP[LN 0,LW(16,5),LW(0,3)], - TP[Mop(Cast F64, - Call - ("reg'ConfigRegister",F32, - Dest - ("Config",CTy"ConfigRegister", - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"state"))))),qVar"state"]), - (TP[LN 0,LW(16,5),LW(1,3)], - TP[Mop(Cast F64, - Call - ("reg'ConfigRegister1",F32, - Dest - ("Config1",CTy"ConfigRegister1", - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"state"))))),qVar"state"]), - (TP[LN 0,LW(16,5),LW(2,3)], - TP[Mop(Cast F64, - Call - ("reg'ConfigRegister2",F32, - Dest - ("Config2",CTy"ConfigRegister2", - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"state"))))),qVar"state"]), - (TP[LN 0,LW(16,5),LW(3,3)], - TP[Mop(Cast F64, - Call - ("reg'ConfigRegister3",F32, - Dest - ("Config3",CTy"ConfigRegister3", - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"state"))))),qVar"state"]), - (TP[LN 0,LW(16,5),LW(4,3)],TP[LW(1,64),qVar"state"]), - (TP[LN 0,LW(16,5),LW(5,3)],TP[LW(1,64),qVar"state"]), - (TP[LN 0,LW(16,5),LW(6,3)], - TP[Mop(Cast F64, - Call - ("reg'ConfigRegister6",F32, - Dest - ("Config6",CTy"ConfigRegister6", - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"state"))))),qVar"state"]), - (TP[LN 0,LW(17,5),LW(0,3)], - TP[Mop(Cast F64, - Dest - ("LLAddr",F64, - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"state")))),qVar"state"]), - (TP[LN 0,LW(20,5),LW(0,3)], - TP[Call - ("reg'XContext",F64, - Dest - ("XContext",CTy"XContext", - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"state")))),qVar"state"]), - (TP[LN 0,LW(23,5),LW(0,3)], - TP[Mop(Cast F64, - Dest - ("Debug",F32, - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"state")))),qVar"state"]), - (TP[LN 0,LW(26,5),LW(0,3)], - TP[Mop(Cast F64, - Dest - ("ErrCtl",F32, - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"state")))),qVar"state"]), - (TP[LN 0,LW(30,5),LW(0,3)], - TP[Dest - ("ErrorEPC",F64, - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"state"))),qVar"state"]), - (AVar(PTy(nTy,PTy(FTy 5,FTy 3))),TP[LX F64,qVar"state"])]))) -; -val write'CPR_def = Def - ("write'CPR", - TP[Var("value",F64),nVar"n",Var("reg",FTy 5),Var("sel",FTy 3)], - Close - (qVar"state", - Let(qVar"s", - Mop(Snd, - Apply - (Call - ("mark_log",ATy(qTy,PTy(uTy,qTy)), - TP[LN 2, - Call - ("log_w_c0",sTy, - TP[Var("reg",FTy 5),Var("value",F64)])]), - qVar"state")), - CS(TP[nVar"n",Var("reg",FTy 5),Var("sel",FTy 3)], - [(TP[LN 0,LW(0,5),LW(0,3)], - Let(Var("v",CTy"CP0"), - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s")), - Apply - (Call - ("write'CP0",ATy(qTy,PTy(uTy,qTy)), - Rupd - ("Index", - TP[Var("v",CTy"CP0"), - Rupd - ("Index", - TP[Dest - ("Index",CTy"Index", - Var("v",CTy"CP0")), - EX(Var("value",F64),LN 7,LN 0,F8)])])), - qVar"s"))), - (TP[LN 0,LW(2,5),LW(0,3)], - Let(Var("v",CTy"CP0"), - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s")), - Apply - (Call - ("write'CP0",ATy(qTy,PTy(uTy,qTy)), - Rupd - ("EntryLo0", - TP[Var("v",CTy"CP0"), - Call - ("write'reg'EntryLo",CTy"EntryLo", - TP[Dest - ("EntryLo0",CTy"EntryLo", - Var("v",CTy"CP0")), - Var("value",F64)])])),qVar"s"))), - (TP[LN 0,LW(3,5),LW(0,3)], - Let(Var("v",CTy"CP0"), - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s")), - Apply - (Call - ("write'CP0",ATy(qTy,PTy(uTy,qTy)), - Rupd - ("EntryLo1", - TP[Var("v",CTy"CP0"), - Call - ("write'reg'EntryLo",CTy"EntryLo", - TP[Dest - ("EntryLo1",CTy"EntryLo", - Var("v",CTy"CP0")), - Var("value",F64)])])),qVar"s"))), - (TP[LN 0,LW(4,5),LW(0,3)], - Let(Var("v",CTy"CP0"), - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s")), - Apply - (Call - ("write'CP0",ATy(qTy,PTy(uTy,qTy)), - Rupd - ("Context", - TP[Var("v",CTy"CP0"), - Rupd - ("PTEBase", - TP[Dest - ("Context",CTy"Context", - Var("v",CTy"CP0")), - EX(Var("value",F64),LN 63,LN 23, - FTy 41)])])),qVar"s"))), - (TP[LN 0,LW(4,5),LW(2,3)], - Apply - (Call - ("write'CP0",ATy(qTy,PTy(uTy,qTy)), - Rupd - ("UsrLocal", - TP[Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"s")),Var("value",F64)])),qVar"s")), - (TP[LN 0,LW(5,5),LW(0,3)], - Let(Var("v",CTy"CP0"), - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s")), - Apply - (Call - ("write'CP0",ATy(qTy,PTy(uTy,qTy)), - Rupd - ("PageMask", - TP[Var("v",CTy"CP0"), - Rupd - ("Mask", - TP[Dest - ("PageMask",CTy"PageMask", - Var("v",CTy"CP0")), - EX(Var("value",F64),LN 24,LN 13, - FTy 12)])])),qVar"s"))), - (TP[LN 0,LW(6,5),LW(0,3)], - Let(Var("v",CTy"CP0"), - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s")), - Let(qVar"s", - Mop(Snd, - Apply - (Call - ("write'CP0",ATy(qTy,PTy(uTy,qTy)), - Rupd - ("Wired", - TP[Var("v",CTy"CP0"), - Rupd - ("Wired", - TP[Dest - ("Wired",CTy"Wired", - Var("v",CTy"CP0")), - EX(Var("value",F64),LN 7, - LN 0,F8)])])),qVar"s")), - Let(Var("v",CTy"CP0"), - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"s")), - Apply - (Call - ("write'CP0",ATy(qTy,PTy(uTy,qTy)), - Rupd - ("Random", - TP[Var("v",CTy"CP0"), - Rupd - ("Random", - TP[Dest - ("Random",CTy"Random", - Var("v",CTy"CP0")), - Mop(Cast F8, - Bop(Sub, - Const - ("TLBEntries",nTy), - LN 1))])])),qVar"s"))))), - (TP[LN 0,LW(7,5),LW(0,3)], - Let(Var("v",CTy"CP0"), - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s")), - Let(qVar"s", - Mop(Snd, - Apply - (Call - ("write'CP0",ATy(qTy,PTy(uTy,qTy)), - Rupd - ("HWREna", - TP[Var("v",CTy"CP0"), - Rupd - ("CPUNum", - TP[Dest - ("HWREna",CTy"HWREna", - Var("v",CTy"CP0")), - Bop(Bit,Var("value",F64),LN 0)])])), - qVar"s")), - Let(Var("v",CTy"CP0"), - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"s")), - Let(qVar"s", - Mop(Snd, - Apply - (Call - ("write'CP0", - ATy(qTy,PTy(uTy,qTy)), - Rupd - ("HWREna", - TP[Var("v",CTy"CP0"), - Rupd - ("CC", - TP[Dest - ("HWREna", - CTy"HWREna", - Var("v",CTy"CP0")), - Bop(Bit, - Var("value",F64), - LN 2)])])), - qVar"s")), - Let(Var("v",CTy"CP0"), - Mop(Fst, - Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"s")), - Let(qVar"s", - Mop(Snd, - Apply - (Call - ("write'CP0", - ATy(qTy,PTy(uTy,qTy)), - Rupd - ("HWREna", - TP[Var("v",CTy"CP0"), - Rupd - ("CCRes", - TP[Dest - ("HWREna", - CTy"HWREna", - Var("v", - CTy"CP0")), - Bop(Bit, - Var("value", - F64), - LN 3)])])), - qVar"s")), - Let(Var("v",CTy"CP0"), - Mop(Fst, - Apply - (Const - ("CP0", - ATy(qTy, - PTy(CTy"CP0",qTy))), - qVar"s")), - Apply - (Call - ("write'CP0", - ATy(qTy,PTy(uTy,qTy)), - Rupd - ("HWREna", - TP[Var("v",CTy"CP0"), - Rupd - ("UL", - TP[Dest - ("HWREna", - CTy"HWREna", - Var("v", - CTy"CP0")), - Bop(Bit, - Var("value", - F64), - LN 29)])])), - qVar"s"))))))))), - (TP[LN 0,LW(9,5),LW(0,3)], - Apply - (Call - ("write'CP0",ATy(qTy,PTy(uTy,qTy)), - Rupd - ("Count", - TP[Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"s")), - EX(Var("value",F64),LN 31,LN 0,F32)])),qVar"s")), - (TP[LN 0,LW(10,5),LW(0,3)], - Let(Var("v",CTy"CP0"), - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s")), - Apply - (Call - ("write'CP0",ATy(qTy,PTy(uTy,qTy)), - Rupd - ("EntryHi", - TP[Var("v",CTy"CP0"), - Call - ("write'reg'EntryHi",CTy"EntryHi", - TP[Dest - ("EntryHi",CTy"EntryHi", - Var("v",CTy"CP0")), - Var("value",F64)])])),qVar"s"))), - (TP[LN 0,LW(11,5),LW(0,3)], - Let(qVar"s", - Mop(Snd, - Apply - (Call - ("write'CP0",ATy(qTy,PTy(uTy,qTy)), - Rupd - ("Compare", - TP[Mop(Fst, - Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"s")), - EX(Var("value",F64),LN 31,LN 0,F32)])), - qVar"s")), - Let(Var("v",CTy"CP0"), - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"s")), - Let(qVar"s", - Let(Var("x0",CTy"CauseRegister"), - Dest - ("Cause",CTy"CauseRegister", - Var("v",CTy"CP0")), - Mop(Snd, - Apply - (Call - ("write'CP0", - ATy(qTy,PTy(uTy,qTy)), - Rupd - ("Cause", - TP[Var("v",CTy"CP0"), - Rupd - ("IP", - TP[Var("x0", - CTy"CauseRegister"), - BFI(LN 7,LN 7, - Mop(Cast F1,LF), - Dest - ("IP",F8, - Var("x0", - CTy"CauseRegister")))])])), - qVar"s"))), - Let(Var("v",CTy"CP0"), - Mop(Fst, - Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"s")), - Apply - (Call - ("write'CP0",ATy(qTy,PTy(uTy,qTy)), - Rupd - ("Cause", - TP[Var("v",CTy"CP0"), - Rupd - ("TI", - TP[Dest - ("Cause", - CTy"CauseRegister", - Var("v",CTy"CP0")),LF])])), - qVar"s")))))), - (TP[LN 0,LW(12,5),LW(0,3)], - Let(Var("v",CTy"CP0"), - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s")), - Apply - (Call - ("write'CP0",ATy(qTy,PTy(uTy,qTy)), - Rupd - ("Status", - TP[Var("v",CTy"CP0"), - Call - ("write'reg'StatusRegister", - CTy"StatusRegister", - TP[Dest - ("Status",CTy"StatusRegister", - Var("v",CTy"CP0")), - EX(Var("value",F64),LN 31,LN 0,F32)])])), - qVar"s"))), - (TP[LN 0,LW(13,5),LW(0,3)], - Let(Var("v",CTy"CP0"), - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s")), - Let(Var("x0",CTy"CauseRegister"), - Dest("Cause",CTy"CauseRegister",Var("v",CTy"CP0")), - Apply - (Call - ("write'CP0",ATy(qTy,PTy(uTy,qTy)), - Rupd - ("Cause", - TP[Var("v",CTy"CP0"), - Rupd - ("IP", - TP[Var("x0",CTy"CauseRegister"), - BFI(LN 1,LN 0, - EX(Var("value",F64),LN 9, - LN 8,FTy 2), - Dest - ("IP",F8, - Var("x0", - CTy"CauseRegister")))])])), - qVar"s")))), - (TP[LN 0,LW(14,5),LW(0,3)], - Apply - (Call - ("write'CP0",ATy(qTy,PTy(uTy,qTy)), - Rupd - ("EPC", - TP[Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"s")),Var("value",F64)])),qVar"s")), - (TP[LN 0,LW(16,5),LW(0,3)], - Let(Var("v",CTy"CP0"), - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s")), - Apply - (Call - ("write'CP0",ATy(qTy,PTy(uTy,qTy)), - Rupd - ("Config", - TP[Var("v",CTy"CP0"), - Rupd - ("K0", - TP[Dest - ("Config",CTy"ConfigRegister", - Var("v",CTy"CP0")), - EX(Var("value",F64),LN 2,LN 0,FTy 3)])])), - qVar"s"))), - (TP[LN 0,LW(16,5),LW(2,3)], - Let(Var("v",CTy"CP0"), - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s")), - Apply - (Call - ("write'CP0",ATy(qTy,PTy(uTy,qTy)), - Rupd - ("Config2", - TP[Var("v",CTy"CP0"), - Rupd - ("SU", - TP[Dest - ("Config2",CTy"ConfigRegister2", - Var("v",CTy"CP0")), - EX(Var("value",F64),LN 15,LN 12,F4)])])), - qVar"s"))), - (TP[LN 0,LW(16,5),LW(6,3)], - Let(Var("v",CTy"CP0"), - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s")), - Apply - (Call - ("write'CP0",ATy(qTy,PTy(uTy,qTy)), - Rupd - ("Config6", - TP[Var("v",CTy"CP0"), - Rupd - ("LTLB", - TP[Dest - ("Config6",CTy"ConfigRegister6", - Var("v",CTy"CP0")), - Bop(Bit,Var("value",F64),LN 2)])])), - qVar"s"))), - (TP[LN 0,LW(20,5),LW(0,3)], - Let(Var("v",CTy"CP0"), - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s")), - Apply - (Call - ("write'CP0",ATy(qTy,PTy(uTy,qTy)), - Rupd - ("XContext", - TP[Var("v",CTy"CP0"), - Rupd - ("PTEBase", - TP[Dest - ("XContext",CTy"XContext", - Var("v",CTy"CP0")), - EX(Var("value",F64),LN 63,LN 33, - FTy 31)])])),qVar"s"))), - (TP[LN 0,LW(23,5),LW(0,3)], - TP[LU, - Rupd - ("done", - TP[Mop(Snd, - Apply - (Call - ("write'CP0",ATy(qTy,PTy(uTy,qTy)), - Rupd - ("Debug", - TP[Mop(Fst, - Apply - (Const - ("CP0", - ATy(qTy, - PTy(CTy"CP0",qTy))), - qVar"s")), - EX(Var("value",F64),LN 31,LN 0,F32)])), - qVar"s")),LT])]), - (TP[LN 0,LW(26,5),LW(0,3)], - Apply - (Call("dumpRegs",ATy(qTy,PTy(uTy,qTy)),LU), - Mop(Snd, - Apply - (Call - ("write'CP0",ATy(qTy,PTy(uTy,qTy)), - Rupd - ("ErrCtl", - TP[Mop(Fst, - Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"s")), - EX(Var("value",F64),LN 31,LN 0,F32)])), - qVar"s")))), - (TP[LN 0,LW(30,5),LW(0,3)], - Apply - (Call - ("write'CP0",ATy(qTy,PTy(uTy,qTy)), - Rupd - ("ErrorEPC", - TP[Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"s")),Var("value",F64)])),qVar"s")), - (AVar(PTy(nTy,PTy(FTy 5,FTy 3))), - Apply - (Call("unmark_log",ATy(qTy,PTy(uTy,qTy)),LN 2),qVar"s"))])))) -; -val dfn'CACHE_def = Def - ("dfn'CACHE",TP[Var("base",FTy 5),Var("opn",FTy 5),Var("offset",F16)], - Close - (qVar"state", - ITE(Bop(And, - Mop(Not, - Dest - ("CU0",bTy, - Dest - ("Status",CTy"StatusRegister", - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"state"))))), - Mop(Not, - Mop(Fst, - Apply - (Const("KernelMode",ATy(qTy,PTy(bTy,qTy))), - qVar"state")))), - Apply - (Call - ("SignalException",ATy(qTy,PTy(uTy,qTy)), - LC("CpU",CTy"ExceptionType")),qVar"state"), - Let(TP[Var("v",PTy(FTy 40,PTy(FTy 3,PTy(bTy,bTy)))),qVar"s"], - Apply - (Call - ("AddressTranslation", - ATy(qTy,PTy(PTy(FTy 40,PTy(FTy 3,PTy(bTy,bTy))),qTy)), - TP[Bop(Add, - Mop(Fst, - Apply - (Call - ("GPR",ATy(qTy,PTy(F64,qTy)), - Var("base",FTy 5)),qVar"state")), - Mop(SE F64,Var("offset",F16))), - LC("DATA",CTy"IorD"),LC("LOAD",CTy"AccessType")]), - qVar"state"),TP[LU,qVar"s"])))) -; -val dfn'RDHWR_def = Def - ("dfn'RDHWR",TP[Var("rt",FTy 5),Var("rd",FTy 5)], - Close - (qVar"state", - ITE(Bop(Or, - Bop(Or, - Dest - ("CU0",bTy, - Dest - ("Status",CTy"StatusRegister", - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"state")))), - Mop(Fst, - Apply - (Const("KernelMode",ATy(qTy,PTy(bTy,qTy))), - qVar"state"))), - Bop(Bit, - Call - ("reg'HWREna",F32, - Dest - ("HWREna",CTy"HWREna", - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"state")))), - Mop(Cast nTy,Var("rd",FTy 5)))), - CS(Var("rd",FTy 5), - [(LW(0,5), - Apply - (Call - ("write'GPR",ATy(qTy,PTy(uTy,qTy)), - TP[Mop(Cast F64,Dest("procID",F8,qVar"state")), - Var("rt",FTy 5)]),qVar"state")), - (LW(2,5), - Apply - (Call - ("write'GPR",ATy(qTy,PTy(uTy,qTy)), - TP[Mop(SE F64, - Dest - ("Count",F32, - Mop(Fst, - Apply - (Const - ("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"state")))),Var("rt",FTy 5)]), - qVar"state")), - (LW(3,5), - Apply - (Call - ("write'GPR",ATy(qTy,PTy(uTy,qTy)), - TP[LW(1,64),Var("rt",FTy 5)]),qVar"state")), - (LW(29,5), - Apply - (Call - ("write'GPR",ATy(qTy,PTy(uTy,qTy)), - TP[Dest - ("UsrLocal",F64, - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"state"))),Var("rt",FTy 5)]), - qVar"state")), - (LW(30,5), - Apply - (Call - ("write'GPR",ATy(qTy,PTy(uTy,qTy)), - TP[Mop(Cast F64, - Bop(Sub,Dest("totalCore",nTy,qVar"state"),LN 1)), - Var("rt",FTy 5)]),qVar"state")), - (AVar(FTy 5), - Apply - (Call - ("SignalException",ATy(qTy,PTy(uTy,qTy)), - LC("ResI",CTy"ExceptionType")),qVar"state"))]), - Apply - (Call - ("SignalException",ATy(qTy,PTy(uTy,qTy)), - LC("ResI",CTy"ExceptionType")),qVar"state")))) -; -val InitMEM_def = Def - ("InitMEM",qVar"state", - TP[LU,Rupd("MEM",TP[qVar"state",Mop(K1(FTy 37),LW(0,64))])]) -; -val ReadData_def = Def - ("ReadData",Var("pAddr",FTy 37), - Close - (qVar"state", - Let(Var("v",F64), - Apply - (Dest("MEM",ATy(FTy 37,F64),qVar"state"),Var("pAddr",FTy 37)), - TP[Var("v",F64), - Mop(Snd, - Apply - (Call - ("mark_log",ATy(qTy,PTy(uTy,qTy)), - TP[LN 2, - Call - ("log_r_mem",sTy, - TP[Var("pAddr",FTy 37),Var("v",F64)])]), - qVar"state"))]))) -; -val WriteData_def = Def - ("WriteData",TP[Var("pAddr",FTy 37),Var("data",F64),Var("mask",F64)], - Close - (qVar"state", - Apply - (Call - ("mark_log",ATy(qTy,PTy(uTy,qTy)), - TP[LN 2, - Call - ("log_w_mem",sTy, - TP[Var("pAddr",FTy 37),Var("mask",F64),Var("data",F64)])]), - Rupd - ("MEM", - TP[qVar"state", - Fupd - (Dest("MEM",ATy(FTy 37,F64),qVar"state"), - Var("pAddr",FTy 37), - Bop(BOr, - Bop(BAnd, - Apply - (Dest("MEM",ATy(FTy 37,F64),qVar"state"), - Var("pAddr",FTy 37)), - Mop(BNot,Var("mask",F64))), - Bop(BAnd,Var("data",F64),Var("mask",F64))))])))) -; -val ReadInst_def = Def - ("ReadInst",Var("a",FTy 40), - Close - (qVar"state", - TP[ITE(Bop(Bit,Var("a",FTy 40),LN 2), - EX(Apply - (Dest("MEM",ATy(FTy 37,F64),qVar"state"), - EX(Var("a",FTy 40),LN 39,LN 3,FTy 37)),LN 31,LN 0,F32), - EX(Apply - (Dest("MEM",ATy(FTy 37,F64),qVar"state"), - EX(Var("a",FTy 40),LN 39,LN 3,FTy 37)),LN 63,LN 32,F32)), - qVar"state"])) -; -val WriteDWORD_def = Def - ("WriteDWORD",TP[Var("pAddr",FTy 37),Var("data",F64)], - Close - (qVar"state", - TP[LU, - Rupd - ("MEM", - TP[qVar"state", - Fupd - (Dest("MEM",ATy(FTy 37,F64),qVar"state"), - Var("pAddr",FTy 37),Var("data",F64))])])) -; -val Write256_def = Def - ("Write256",TP[Var("pAddr",FTy 35),Var("data",FTy 256)], - Close - (qVar"state", - Let(qVar"s", - Rupd - ("MEM", - TP[qVar"state", - Fupd - (Dest("MEM",ATy(FTy 37,F64),qVar"state"), - CC[Var("pAddr",FTy 35),LW(0,2)], - EX(Var("data",FTy 256),LN 63,LN 0,F64))]), - Let(qVar"s", - Rupd - ("MEM", - TP[qVar"s", - Fupd - (Dest("MEM",ATy(FTy 37,F64),qVar"s"), - CC[Var("pAddr",FTy 35),LW(1,2)], - EX(Var("data",FTy 256),LN 127,LN 64,F64))]), - Let(qVar"s", - Rupd - ("MEM", - TP[qVar"s", - Fupd - (Dest("MEM",ATy(FTy 37,F64),qVar"s"), - CC[Var("pAddr",FTy 35),LW(2,2)], - EX(Var("data",FTy 256),LN 191,LN 128,F64))]), - TP[LU, - Rupd - ("MEM", - TP[qVar"s", - Fupd - (Dest("MEM",ATy(FTy 37,F64),qVar"s"), - CC[Var("pAddr",FTy 35),LW(3,2)], - EX(Var("data",FTy 256),LN 255,LN 192,F64))])]))))) -; -val LoadMemoryCap_def = Def - ("LoadMemoryCap", - TP[Var("MemType",FTy 3),Var("vAddr",F64),Var("IorD",CTy"IorD"), - Var("AccessType",CTy"AccessType"),bVar"link"], - Close - (qVar"state", - Let(TP[Var("r",F64),Var("s1",PTy(FTy 40,qTy))], - Let(TP[Var("v",PTy(FTy 40,PTy(FTy 3,PTy(bTy,bTy)))), - Var("s",PTy(FTy 40,qTy))], - Let(TP[Var("v",PTy(FTy 40,PTy(FTy 3,PTy(bTy,bTy)))),qVar"s3"], - Apply - (Call - ("AddressTranslation", - ATy(qTy, - PTy(PTy(FTy 40,PTy(FTy 3,PTy(bTy,bTy))),qTy)), - TP[Var("vAddr",F64),LC("DATA",CTy"IorD"), - LC("LOAD",CTy"AccessType")]),qVar"state"), - TP[Var("v",PTy(FTy 40,PTy(FTy 3,PTy(bTy,bTy)))), - LX(FTy 40),qVar"s3"]), - Let(TP[Var("tmp",FTy 40),Var("CCA",FTy 3),bVar"S",bVar"L"], - Var("v",PTy(FTy 40,PTy(FTy 3,PTy(bTy,bTy)))), - Let(Var("s",PTy(FTy 40,qTy)), - TP[Var("tmp",FTy 40), - Mop(Snd,Var("s",PTy(FTy 40,qTy)))], - Let(Var("s",PTy(FTy 40,qTy)), - Let(TP[Var("v",FTy 40),Var("s",PTy(FTy 40,qTy))], - Let(TP[Var("v0",FTy 3), - Var("s0",PTy(FTy 40,qTy))], - CS(Var("MemType",FTy 3), - [(LW(0,3), - Let(TP[Var("v0",F1), - Var("s0",PTy(FTy 40,qTy))], - Let(TP[Var("v",F1),qVar"s3"], - TP[Mop(Fst, - Apply - (Const - ("ReverseEndian", - ATy(qTy, - PTy(F1,qTy))), - Mop(Snd, - Var("s", - PTy(FTy 40, - qTy))))), - Mop(Snd, - Var("s", - PTy(FTy 40,qTy)))], - TP[Var("v",F1), - Mop(Fst, - Var("s", - PTy(FTy 40,qTy))), - qVar"s3"]), - TP[Bop(BXor, - EX(Mop(Fst, - Var("s", - PTy(FTy 40, - qTy))), - LN 2,LN 0,FTy 3), - REP(Var("v0",F1),LN 3, - FTy 3)), - Var("s0",PTy(FTy 40,qTy))])), - (LW(1,3), - Let(TP[Var("v0",F1), - Var("s0",PTy(FTy 40,qTy))], - Let(TP[Var("v",F1),qVar"s3"], - TP[Mop(Fst, - Apply - (Const - ("ReverseEndian", - ATy(qTy, - PTy(F1,qTy))), - Mop(Snd, - Var("s", - PTy(FTy 40, - qTy))))), - Mop(Snd, - Var("s", - PTy(FTy 40,qTy)))], - TP[Var("v",F1), - Mop(Fst, - Var("s", - PTy(FTy 40,qTy))), - qVar"s3"]), - TP[Bop(BXor, - EX(Mop(Fst, - Var("s", - PTy(FTy 40, - qTy))), - LN 2,LN 0,FTy 3), - CC[REP(Var("v0",F1), - LN 2,FTy 2), - LW(0,1)]), - Var("s0",PTy(FTy 40,qTy))])), - (LW(3,3), - Let(TP[Var("v0",F1), - Var("s0",PTy(FTy 40,qTy))], - Let(TP[Var("v",F1),qVar"s3"], - TP[Mop(Fst, - Apply - (Const - ("ReverseEndian", - ATy(qTy, - PTy(F1,qTy))), - Mop(Snd, - Var("s", - PTy(FTy 40, - qTy))))), - Mop(Snd, - Var("s", - PTy(FTy 40,qTy)))], - TP[Var("v",F1), - Mop(Fst, - Var("s", - PTy(FTy 40,qTy))), - qVar"s3"]), - TP[Bop(BXor, - EX(Mop(Fst, - Var("s", - PTy(FTy 40, - qTy))), - LN 2,LN 0,FTy 3), - CC[Var("v0",F1),LW(0,2)]), - Var("s0",PTy(FTy 40,qTy))])), - (LW(7,3), - TP[EX(Mop(Fst, - Var("s",PTy(FTy 40,qTy))), - LN 2,LN 0,FTy 3), - Var("s",PTy(FTy 40,qTy))]), - (AVar(FTy 3), - Let(TP[Var("v",FTy 3),qVar"s3"], + Let(TP[Var("r",F64),Var("s1",PTy(FTy 40,qTy))], + Let(TP[Var("v",PTy(FTy 40,PTy(FTy 3,PTy(bTy,bTy)))), + Var("s",PTy(FTy 40,qTy))], + Let(TP[Var("v",PTy(FTy 40,PTy(FTy 3,PTy(bTy,bTy)))),qVar"s3"], + Apply + (Call + ("AddressTranslation", + ATy(qTy, + PTy(PTy(FTy 40,PTy(FTy 3,PTy(bTy,bTy))),qTy)), + TP[Var("vAddr",F64),LC("DATA",CTy"IorD"), + LC("LOAD",CTy"AccessType")]),qVar"state"), + TP[Var("v",PTy(FTy 40,PTy(FTy 3,PTy(bTy,bTy)))), + LX(FTy 40),qVar"s3"]), + Let(TP[Var("tmp",FTy 40),Var("CCA",FTy 3),bVar"S",bVar"L"], + Var("v",PTy(FTy 40,PTy(FTy 3,PTy(bTy,bTy)))), + Let(Var("s",PTy(FTy 40,qTy)), + TP[Var("tmp",FTy 40), + Mop(Snd,Var("s",PTy(FTy 40,qTy)))], + Let(Var("s",PTy(FTy 40,qTy)), + Let(TP[Var("v",FTy 40),Var("s",PTy(FTy 40,qTy))], + Let(TP[Var("v0",FTy 3), + Var("s0",PTy(FTy 40,qTy))], + CS(Var("MemType",FTy 3), + [(LW(0,3), + Let(TP[Var("v0",F1), + Var("s0",PTy(FTy 40,qTy))], + Let(TP[Var("v",F1),qVar"s3"], + TP[Mop(Fst, + Apply + (Const + ("ReverseEndian", + ATy(qTy, + PTy(F1,qTy))), + Mop(Snd, + Var("s", + PTy(FTy 40, + qTy))))), + Mop(Snd, + Var("s", + PTy(FTy 40,qTy)))], + TP[Var("v",F1), + Mop(Fst, + Var("s", + PTy(FTy 40,qTy))), + qVar"s3"]), + TP[Bop(BXor, + EX(Mop(Fst, + Var("s", + PTy(FTy 40, + qTy))), + LN 2,LN 0,FTy 3), + REP(Var("v0",F1),LN 3, + FTy 3)), + Var("s0",PTy(FTy 40,qTy))])), + (LW(1,3), + Let(TP[Var("v0",F1), + Var("s0",PTy(FTy 40,qTy))], + Let(TP[Var("v",F1),qVar"s3"], + TP[Mop(Fst, + Apply + (Const + ("ReverseEndian", + ATy(qTy, + PTy(F1,qTy))), + Mop(Snd, + Var("s", + PTy(FTy 40, + qTy))))), + Mop(Snd, + Var("s", + PTy(FTy 40,qTy)))], + TP[Var("v",F1), + Mop(Fst, + Var("s", + PTy(FTy 40,qTy))), + qVar"s3"]), + TP[Bop(BXor, + EX(Mop(Fst, + Var("s", + PTy(FTy 40, + qTy))), + LN 2,LN 0,FTy 3), + CC[REP(Var("v0",F1), + LN 2,FTy 2), + LW(0,1)]), + Var("s0",PTy(FTy 40,qTy))])), + (LW(3,3), + Let(TP[Var("v0",F1), + Var("s0",PTy(FTy 40,qTy))], + Let(TP[Var("v",F1),qVar"s3"], + TP[Mop(Fst, + Apply + (Const + ("ReverseEndian", + ATy(qTy, + PTy(F1,qTy))), + Mop(Snd, + Var("s", + PTy(FTy 40, + qTy))))), + Mop(Snd, + Var("s", + PTy(FTy 40,qTy)))], + TP[Var("v",F1), + Mop(Fst, + Var("s", + PTy(FTy 40,qTy))), + qVar"s3"]), + TP[Bop(BXor, + EX(Mop(Fst, + Var("s", + PTy(FTy 40, + qTy))), + LN 2,LN 0,FTy 3), + CC[Var("v0",F1),LW(0,2)]), + Var("s0",PTy(FTy 40,qTy))])), + (LW(7,3), + TP[EX(Mop(Fst, + Var("s",PTy(FTy 40,qTy))), + LN 2,LN 0,FTy 3), + Var("s",PTy(FTy 40,qTy))]), + (AVar(FTy 3), + Let(TP[Var("v",FTy 3),qVar"s3"], Apply (Call ("raise'exception", @@ -9730,18 +9164,52 @@ val LoadMemoryCap_def = Def PTy(F64, PTy(FTy 40, qTy)))))))))], - TP[Mop(Fst, - Mop(Snd, + Let(Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy)))), + TP[Mop(Fst, Var("s", PTy(bTy, PTy(F64, PTy(FTy 40, - qTy)))))), - Var("s", - PTy(bTy, - PTy(F64, - PTy(FTy 40, - qTy))))]))))), + qTy))))), + Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy)))))), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy))))))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy)))))))], + TP[Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy)))))), + Var("s", + PTy(bTy, + PTy(F64, + PTy(FTy 40, + qTy))))])))))), TP[Var("r",F64), Mop(Snd, Var("s1", @@ -9900,44 +9368,61 @@ val LoadCap_def = Def qVar"s"))), Let(Var("a",FTy 35), EX(Var("pAddr",FTy 40),LN 39,LN 5,FTy 35), - Let(TP[Var("r",CTy"Capability"), - Var("s1",PTy(CTy"Capability",qTy))], - Let(Var("s",PTy(CTy"Capability",qTy)), - TP[LX(CTy"Capability"), - ITE(EQ(Var("a",FTy 35), - EX(Dest - ("base_address",FTy 37, - Dest - ("JTAG_UART", - CTy"JTAG_UART",qVar"s")), - LN 36,LN 2,FTy 35)), - Mop(Snd, - Apply - (Call - ("raise'exception", - ATy(qTy,PTy(uTy,qTy)), - Call - ("UNPREDICTABLE", - CTy"exception", - LS - "Capability load attempted on UART")), - qVar"s")), - Mop(Snd, - Apply - (For(TP[LN 0, - Bop(Sub, - Dest - ("totalCore",nTy, - qVar"s"),LN 1), - Close - (nVar"core", - Close - (qVar"state", - ITE(Bop(And, - Bop(Uge, - Var("a", - FTy 35), - EX(Apply + Let(TP[Var("v",CTy"Capability"),qVar"s"], + Apply + (Call + ("ReadCap", + ATy(qTy,PTy(CTy"Capability",qTy)), + Var("a",FTy 35)), + ITE(EQ(Var("a",FTy 35), + EX(Dest + ("base_address",FTy 37, + Dest + ("JTAG_UART",CTy"JTAG_UART", + qVar"s")),LN 36,LN 2,FTy 35)), + Mop(Snd, + Apply + (Call + ("raise'exception", + ATy(qTy,PTy(uTy,qTy)), + Call + ("UNPREDICTABLE", + CTy"exception", + LS + "Capability load attempted on UART")), + qVar"s")), + Mop(Snd, + Apply + (For(TP[LN 0, + Bop(Sub, + Dest + ("totalCore",nTy, + qVar"s"),LN 1), + Close + (nVar"core", + Close + (qVar"state", + ITE(Bop(And, + Bop(Uge, + Var("a", + FTy 35), + EX(Apply + (Dest + ("PIC_base_address", + ATy(F8, + FTy 37), + qVar"state"), + Mop(Cast + F8, + nVar"core")), + LN 36, + LN 2, + FTy 35)), + Bop(Ult, + Var("a", + FTy 35), + EX(Bop(Add, + Apply (Dest ("PIC_base_address", ATy(F8, @@ -9946,392 +9431,94 @@ val LoadCap_def = Def Mop(Cast F8, nVar"core")), - LN - 36, - LN - 2, - FTy 35)), - Bop(Ult, - Var("a", - FTy 35), - EX(Bop(Add, - Apply - (Dest - ("PIC_base_address", - ATy(F8, - FTy 37), - qVar"state"), - Mop(Cast - F8, - nVar"core")), - LW(1072, - 37)), - LN - 36, - LN - 2, - FTy 35))), - Apply - (Call - ("raise'exception", - ATy(qTy, - PTy(uTy, - qTy)), - Call - ("UNPREDICTABLE", - CTy"exception", - LS - "Capability load attempted on PIC")), - qVar"state"), - TP[LU, - qVar"state"])))]), - qVar"s")))], + LW(1072, + 37)), + LN 36, + LN 2, + FTy 35))), + Apply + (Call + ("raise'exception", + ATy(qTy, + PTy(uTy, + qTy)), + Call + ("UNPREDICTABLE", + CTy"exception", + LS + "Capability load attempted on PIC")), + qVar"state"), + TP[LU,qVar"state"])))]), + qVar"s")))), + Let(TP[Var("r",CTy"Capability"), + Var("s1",PTy(CTy"Capability",qTy))], Let(Var("s",PTy(CTy"Capability",qTy)), - Let(TP[Var("v",CTy"Capability"), - Var("s",PTy(CTy"Capability",qTy))], - Let(TP[Var("v", - PTy(CTy"Capability", - FTy 257)), - Var("s", - PTy(CTy"Capability",qTy))], - Let(TP[Var("v0",F64), - Var("s0", - PTy(CTy"Capability", - qTy))], - Let(TP[Var("v",F64),qVar"s3"], - Apply - (Call - ("ReadData", - ATy(qTy, - PTy(F64,qTy)), - CC[Var("a",FTy 35), - LW(0,2)]), - Mop(Snd, - Var("s", - PTy(CTy"Capability", - qTy)))), - TP[Var("v",F64), - Mop(Fst, - Var("s", - PTy(CTy"Capability", - qTy))), - qVar"s3"]), - TP[TP[Mop(Fst, - Var("s", - PTy(CTy"Capability", - qTy))), - BFI(LN 255,LN 192, - Var("v0",F64), - Call - ("reg'Capability", - FTy 257, - LX(CTy"Capability")))], - Var("s0", - PTy(CTy"Capability", - qTy))]), - TP[Call - ("write'reg'Capability", - CTy"Capability", - Var("v", - PTy(CTy"Capability", - FTy 257))), - Var("s", - PTy(CTy"Capability",qTy))]), - TP[Var("v",CTy"Capability"), - Mop(Snd, - Var("s", - PTy(CTy"Capability",qTy)))]), + TP[ITE(bVar"L", + Rupd + ("tag", + TP[Var("v",CTy"Capability"),LF]), + Var("v",CTy"Capability")),qVar"s"], Let(Var("s",PTy(CTy"Capability",qTy)), - Let(TP[Var("v",CTy"Capability"), + TP[Mop(Fst, Var("s", - PTy(CTy"Capability",qTy))], - Let(TP[Var("v", - PTy(CTy"Capability", - FTy 257)), - Var("s", - PTy(CTy"Capability", - qTy))], - Let(TP[Var("v0",F64), - Var("s0", - PTy(CTy"Capability", - qTy))], - Let(TP[Var("v",F64), - qVar"s3"], - Apply - (Call - ("ReadData", - ATy(qTy, - PTy(F64, - qTy)), - CC[Var("a", - FTy 35), - LW(1,2)]), - Mop(Snd, - Var("s", - PTy(CTy"Capability", - qTy)))), - TP[Var("v",F64), - Mop(Fst, - Var("s", - PTy(CTy"Capability", - qTy))), - qVar"s3"]), - TP[TP[Mop(Fst, - Var("s", - PTy(CTy"Capability", - qTy))), - BFI(LN 191,LN 128, - Var("v0",F64), - Call - ("reg'Capability", - FTy 257, - Mop(Fst, - Var("s", - PTy(CTy"Capability", - qTy)))))], - Var("s0", - PTy(CTy"Capability", - qTy))]), - TP[Call - ("write'reg'Capability", - CTy"Capability", - Var("v", + PTy(CTy"Capability",qTy))), + Mop(Snd, + Apply + (Call + ("write'LLbit", + ATy(qTy,PTy(uTy,qTy)), + LO bTy), + Mop(Snd, + Var("s", PTy(CTy"Capability", - FTy 257))), - Var("s", - PTy(CTy"Capability", - qTy))]), - TP[Var("v",CTy"Capability"), - Mop(Snd, - Var("s", - PTy(CTy"Capability", - qTy)))]), + qTy)))))], Let(Var("s",PTy(CTy"Capability",qTy)), - Let(TP[Var("v",CTy"Capability"), + TP[Mop(Fst, Var("s", PTy(CTy"Capability", - qTy))], - Let(TP[Var("v", - PTy(CTy"Capability", - FTy 257)), - Var("s", - PTy(CTy"Capability", - qTy))], - Let(TP[Var("v0",F64), - Var("s0", - PTy(CTy"Capability", - qTy))], - Let(TP[Var("v",F64), - qVar"s3"], - Apply - (Call - ("ReadData", - ATy(qTy, - PTy(F64, - qTy)), - CC[Var("a", - FTy 35), - LW(2,2)]), - Mop(Snd, - Var("s", - PTy(CTy"Capability", - qTy)))), - TP[Var("v",F64), - Mop(Fst, - Var("s", - PTy(CTy"Capability", - qTy))), - qVar"s3"]), - TP[TP[Mop(Fst, - Var("s", - PTy(CTy"Capability", - qTy))), - BFI(LN 127, - LN 64, - Var("v0", - F64), - Call - ("reg'Capability", - FTy 257, + qTy))), + Mop(Snd, + Apply + (Call + ("mark_log", + ATy(qTy, + PTy(uTy,qTy)), + TP[LN 2, + CC[LS + "Load cap: ", + Call + ("log_load_cap", + sTy, + TP[Var("pAddr", + FTy 40), Mop(Fst, Var("s", PTy(CTy"Capability", - qTy)))))], - Var("s0", - PTy(CTy"Capability", - qTy))]), - TP[Call - ("write'reg'Capability", - CTy"Capability", - Var("v", + qTy)))])]]), + Mop(Snd, + Var("s", PTy(CTy"Capability", - FTy 257))), + qTy)))))], + Let(Var("s", + PTy(CTy"Capability",qTy)), + TP[Mop(Fst, Var("s", PTy(CTy"Capability", - qTy))]), - TP[Var("v",CTy"Capability"), + qTy))), Mop(Snd, Var("s", PTy(CTy"Capability", - qTy)))]), - Let(Var("s", - PTy(CTy"Capability",qTy)), - Let(TP[Var("v", - CTy"Capability"), + qTy)))], + TP[Mop(Fst, Var("s", PTy(CTy"Capability", - qTy))], - Let(TP[Var("v", - PTy(CTy"Capability", - FTy 257)), - Var("s", - PTy(CTy"Capability", - qTy))], - Let(TP[Var("v0",F64), - Var("s0", - PTy(CTy"Capability", - qTy))], - Let(TP[Var("v", - F64), - qVar"s3"], - Apply - (Call - ("ReadData", - ATy(qTy, - PTy(F64, - qTy)), - CC[Var("a", - FTy 35), - LW(3, - 2)]), - Mop(Snd, - Var("s", - PTy(CTy"Capability", - qTy)))), - TP[Var("v", - F64), - Mop(Fst, - Var("s", - PTy(CTy"Capability", - qTy))), - qVar"s3"]), - TP[TP[Mop(Fst, - Var("s", - PTy(CTy"Capability", - qTy))), - BFI(LN 63, - LN 0, - Var("v0", - F64), - Call - ("reg'Capability", - FTy 257, - Mop(Fst, - Var("s", - PTy(CTy"Capability", - qTy)))))], - Var("s0", - PTy(CTy"Capability", - qTy))]), - TP[Call - ("write'reg'Capability", - CTy"Capability", - Var("v", - PTy(CTy"Capability", - FTy 257))), - Var("s", - PTy(CTy"Capability", - qTy))]), - TP[Var("v", - CTy"Capability"), - Mop(Snd, - Var("s", - PTy(CTy"Capability", - qTy)))]), - Let(Var("s", - PTy(CTy"Capability", - qTy)), - TP[Rupd - ("tag", - TP[Mop(Fst, - Var("s", - PTy(CTy"Capability", - qTy))), - ITE(bVar"L",LF, - Apply - (Dest - ("TAG", - ATy(FTy 35, - bTy), - Mop(Snd, - Var("s", - PTy(CTy"Capability", - qTy)))), - Var("a", - FTy 35)))]), - Mop(Snd, - Var("s", - PTy(CTy"Capability", - qTy)))], - Let(Var("s", - PTy(CTy"Capability", - qTy)), - TP[Mop(Fst, - Var("s", - PTy(CTy"Capability", - qTy))), - Mop(Snd, - Apply - (Call - ("write'LLbit", - ATy(qTy, - PTy(uTy, - qTy)), - LO bTy), - Mop(Snd, - Var("s", - PTy(CTy"Capability", - qTy)))))], - Let(Var("s", - PTy(CTy"Capability", - qTy)), - TP[Mop(Fst, - Var("s", - PTy(CTy"Capability", - qTy))), - Mop(Snd, - Apply - (Call - ("mark_log", - ATy(qTy, - PTy(uTy, - qTy)), - TP[LN - 2, - CC[LS - "Load cap: ", - Call - ("log_load_cap", - sTy, - TP[Var("pAddr", - FTy 40), - Mop(Fst, - Var("s", - PTy(CTy"Capability", - qTy)))])]]), - Mop(Snd, - Var("s", - PTy(CTy"Capability", - qTy)))))], - TP[Mop(Fst, - Var("s", - PTy(CTy"Capability", - qTy))), - Var("s", - PTy(CTy"Capability", - qTy))])))))))), - TP[Var("r",CTy"Capability"), - Mop(Snd,Var("s1",PTy(CTy"Capability",qTy)))])), + qTy))), + Var("s", + PTy(CTy"Capability", + qTy))])))), + TP[Var("r",CTy"Capability"), + Mop(Snd, + Var("s1",PTy(CTy"Capability",qTy)))]))), TP[LX(CTy"Capability"),qVar"s"]))))) ; val StoreMemoryCap_def = Def @@ -11531,113 +10718,48 @@ val StoreMemoryCap_def = Def PTy(bTy, PTy(FTy 40, qTy))))))), - Let(Var("s", - PTy(bTy, - PTy(bTy, - PTy(FTy 40, - qTy)))), - TP[Mop(Fst, - Var("s", + TP[Mop(Fst, + Var("s", + PTy(bTy, PTy(bTy, - PTy(bTy, - PTy(FTy 40, - qTy))))), - Mop(Fst, - Mop(Snd, - Var("s", - PTy(bTy, - PTy(bTy, - PTy(FTy 40, - qTy)))))), - Mop(Fst, - Mop(Snd, - Mop(Snd, - Var("s", - PTy(bTy, - PTy(bTy, - PTy(FTy 40, - qTy))))))), + PTy(FTy 40, + qTy))))), + Mop(Fst, Mop(Snd, - Apply - (Call - ("WriteData", - ATy(qTy, - PTy(uTy, - qTy)), - TP[Var("v", - FTy 37), - Var("MemElem", - F64), - Var("mask", - F64)]), - Mop(Snd, - Mop(Snd, - Mop(Snd, - Var("s", - PTy(bTy, - PTy(bTy, - PTy(FTy 40, - qTy)))))))))], - TP[Mop(Fst, Var("s", PTy(bTy, PTy(bTy, PTy(FTy 40, - qTy))))), - Let(Var("s0", - PTy(bTy, - PTy(FTy 40, - qTy))), + qTy)))))), + Mop(Fst, + Mop(Snd, Mop(Snd, Var("s", PTy(bTy, PTy(bTy, PTy(FTy 40, - qTy))))), - TP[Mop(Fst, - Var("s0", - PTy(bTy, - PTy(FTy 40, - qTy)))), - Let(Var("s0", - PTy(FTy 40, - qTy)), + qTy))))))), + Mop(Snd, + Apply + (Call + ("WriteData", + ATy(qTy, + PTy(uTy, + qTy)), + TP[Var("v", + FTy 37), + Var("MemElem", + F64), + Var("mask", + F64)]), + Mop(Snd, + Mop(Snd, Mop(Snd, - Var("s0", + Var("s", PTy(bTy, - PTy(FTy 40, - qTy)))), - TP[Mop(Fst, - Var("s0", - PTy(FTy 40, - qTy))), - Rupd - ("TAG", - TP[Mop(Snd, - Var("s0", - PTy(FTy 40, - qTy))), - Fupd - (Dest - ("TAG", - ATy(FTy 35, - bTy), - Mop(Snd, - Mop(Snd, - Mop(Snd, - Var("s", - PTy(bTy, - PTy(bTy, - PTy(FTy 40, - qTy)))))))), - EX(Var("v", - FTy 37), - LN - 36, - LN - 2, - FTy 35), - LF)])])])]), + PTy(bTy, + PTy(FTy 40, + qTy)))))))))], Var("s", PTy(bTy, PTy(bTy, @@ -11648,555 +10770,1617 @@ val StoreMemoryCap_def = Def PTy(bTy, PTy(FTy 40, qTy))))), - TP[Mop(Fst, - Mop(Snd, + Let(Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))), + TP[Mop(Fst, Var("s", PTy(bTy, PTy(bTy, PTy(FTy 40, - qTy)))))), - Mop(Fst, - Mop(Snd, + qTy))))), + Mop(Fst, Mop(Snd, Var("s", PTy(bTy, PTy(bTy, PTy(FTy 40, - qTy))))))), - Mop(Snd, - Apply - (Call - ("mark_log", - ATy(qTy, - PTy(uTy, - qTy)), - TP[LN - 2, - CC[LS - "Store of ", - Mop(Cast - sTy, - Bop(Add, - Mop(Cast - nTy, - Var("AccessLength", - FTy 3)), - LN - 1)), - LS - " byte(s)"]]), - Mop(Snd, + qTy)))))), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy))))))), + Mop(Snd, + Apply + (Call + ("mark_log", + ATy(qTy, + PTy(uTy, + qTy)), + TP[LN + 2, + CC[LS + "Store of ", + Mop(Cast + sTy, + Bop(Add, + Mop(Cast + nTy, + Var("AccessLength", + FTy 3)), + LN + 1)), + LS + " byte(s)"]]), Mop(Snd, Mop(Snd, - Var("s", - PTy(bTy, + Mop(Snd, + Var("s", PTy(bTy, - PTy(FTy 40, - qTy)))))))))])))))))), + PTy(bTy, + PTy(FTy 40, + qTy)))))))))], + TP[Mop(Fst, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))))), + Mop(Fst, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy))))))), + Mop(Snd, + Mop(Snd, + Mop(Snd, + Var("s", + PTy(bTy, + PTy(bTy, + PTy(FTy 40, + qTy)))))))]))))))))), Var("s", PTy(bTy, PTy(FTy 40,qTy)))), TP[Mop(Fst, - Var("s", - PTy(bTy, - PTy(FTy 40, - qTy)))), - Var("s", - PTy(bTy, - PTy(FTy 40,qTy)))])))))))), - TP[bVar"r",Mop(Snd,Var("s1",PTy(bTy,PTy(FTy 40,qTy))))]), - TP[bVar"r",Mop(Snd,Var("s1",PTy(FTy 40,qTy)))]))) + Var("s", + PTy(bTy, + PTy(FTy 40, + qTy)))), + Var("s", + PTy(bTy, + PTy(FTy 40,qTy)))])))))))), + TP[bVar"r",Mop(Snd,Var("s1",PTy(bTy,PTy(FTy 40,qTy))))]), + TP[bVar"r",Mop(Snd,Var("s1",PTy(FTy 40,qTy)))]))) +; +val StoreMemory_def = Def + ("StoreMemory", + TP[Var("MemType",FTy 3),Var("AccessLength",FTy 3),Var("MemElem",F64), + Var("vAddr",F64),Var("IorD",CTy"IorD"), + Var("AccessType",CTy"AccessType"),bVar"cond"], + Close + (qVar"state", + Let(Var("v",F64), + Bop(Add, + Bop(Add,Var("vAddr",F64), + Dest + ("base",F64, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + LW(0,5)),qVar"state")))), + Dest + ("offset",F64, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + LW(0,5)),qVar"state")))), + ITB([(Mop(Not, + Dest + ("tag",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + LW(0,5)),qVar"state")))), + TP[LX bTy, + Mop(Snd, + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcTag",CTy"CapException"),LW(0,5)]), + qVar"state"))]), + (Dest + ("sealed",bTy, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + LW(0,5)),qVar"state"))), + TP[LX bTy, + Mop(Snd, + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcSeal",CTy"CapException"),LW(0,5)]), + qVar"state"))]), + (Bop(Ult,Var("v",F64), + Dest + ("base",F64, + Mop(Fst, + Apply + (Call + ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), + LW(0,5)),qVar"state")))), + TP[LX bTy, + Mop(Snd, + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcLength",CTy"CapException"), + LW(0,5)]),qVar"state"))]), + (Bop(Ugt,Var("v",F64), + Bop(Add, + Dest + ("base",F64, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + LW(0,5)),qVar"state"))), + Dest + ("length",F64, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + LW(0,5)),qVar"state"))))), + TP[LX bTy, + Mop(Snd, + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcLength",CTy"CapException"), + LW(0,5)]),qVar"state"))]), + (Mop(Not, + Dest + ("Permit_Store",bTy, + Call + ("rec'Perms",CTy"Perms", + Dest + ("perms",FTy 31, + Mop(Fst, + Apply + (Call + ("CAPR", + ATy(qTy,PTy(CTy"Capability",qTy)), + LW(0,5)),qVar"state")))))), + TP[LX bTy, + Mop(Snd, + Apply + (Call + ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), + TP[LC("capExcPermStore",CTy"CapException"), + LW(0,5)]),qVar"state"))])], + Apply + (Call + ("StoreMemoryCap",ATy(qTy,PTy(bTy,qTy)), + TP[Var("MemType",FTy 3),Var("AccessLength",FTy 3), + Var("MemElem",F64),Var("v",F64), + Var("IorD",CTy"IorD"), + Var("AccessType",CTy"AccessType"),bVar"cond"]), + qVar"state"))))) +; +val StoreCap_def = Def + ("StoreCap",TP[Var("vAddr",F64),Var("Capability",CTy"Capability")], + Close + (qVar"state", + Let(TP[Var("v",PTy(FTy 40,PTy(FTy 3,PTy(bTy,bTy)))),qVar"s"], + Apply + (Call + ("AddressTranslation", + ATy(qTy,PTy(PTy(FTy 40,PTy(FTy 3,PTy(bTy,bTy))),qTy)), + TP[Var("vAddr",F64),LC("DATA",CTy"IorD"), + LC("CSTORE",CTy"AccessType")]),qVar"state"), + Let(TP[Var("pAddr",FTy 40),Var("CCA",FTy 3),bVar"S",bVar"L"], + Var("v",PTy(FTy 40,PTy(FTy 3,PTy(bTy,bTy)))), + ITE(Mop(Not, + Mop(Fst, + Apply + (Const + ("exceptionSignalled",ATy(qTy,PTy(bTy,qTy))), + qVar"s"))), + Let(Var("a",FTy 35), + EX(Var("pAddr",FTy 40),LN 39,LN 5,FTy 35), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'LLbit",ATy(qTy,PTy(uTy,qTy)), + LO bTy), + ITE(EQ(Var("a",FTy 35), + EX(Dest + ("base_address",FTy 37, + Dest + ("JTAG_UART", + CTy"JTAG_UART",qVar"s")), + LN 36,LN 2,FTy 35)), + Mop(Snd, + Apply + (Call + ("raise'exception", + ATy(qTy,PTy(uTy,qTy)), + Call + ("UNPREDICTABLE", + CTy"exception", + LS + "Capability store attempted on UART")), + qVar"s")), + Mop(Snd, + Apply + (For(TP[LN 0, + Bop(Sub, + Dest + ("totalCore",nTy, + qVar"s"),LN 1), + Close + (nVar"core", + Close + (qVar"state", + ITE(Bop(And, + Bop(Uge, + Var("a", + FTy 35), + EX(Apply + (Dest + ("PIC_base_address", + ATy(F8, + FTy 37), + qVar"state"), + Mop(Cast + F8, + nVar"core")), + LN + 36, + LN + 2, + FTy 35)), + Bop(Ult, + Var("a", + FTy 35), + EX(Bop(Add, + Apply + (Dest + ("PIC_base_address", + ATy(F8, + FTy 37), + qVar"state"), + Mop(Cast + F8, + nVar"core")), + LW(1072, + 37)), + LN + 36, + LN + 2, + FTy 35))), + Apply + (Call + ("raise'exception", + ATy(qTy, + PTy(uTy, + qTy)), + Call + ("UNPREDICTABLE", + CTy"exception", + LS + "Capability store attempted on PIC")), + qVar"state"), + TP[LU, + qVar"state"])))]), + qVar"s"))))), + ITE(Bop(And,bVar"S", + Dest + ("tag",bTy, + Var("Capability",CTy"Capability"))), + Apply + (Call + ("SignalCapException_noReg", + ATy(qTy,PTy(uTy,qTy)), + LC("capExcTLBNoStore", + CTy"CapException")),qVar"s"), + Apply + (Call + ("WriteCap",ATy(qTy,PTy(uTy,qTy)), + TP[Var("a",FTy 35), + Var("Capability",CTy"Capability")]), + Mop(Snd, + Apply + (Call + ("mark_log", + ATy(qTy,PTy(uTy,qTy)), + TP[LN 2, + CC[LS"Store cap: ", + Call + ("log_store_cap",sTy, + TP[Var("pAddr",FTy 40), + Var("Capability", + CTy"Capability")])]]), + Mop(Snd, + Apply + (For(TP[LN 0, + Bop(Sub, + Dest + ("totalCore", + nTy,qVar"s"), + LN 1), + Close + (nVar"core", + Close + (qVar"state", + TP[LU, + ITE(Bop(And, + Bop(And, + Mop(Not, + EQ(nVar"core", + Mop(Cast + nTy, + Dest + ("procID", + F8, + qVar"state")))), + EQ(Apply + (Dest + ("c_LLbit", + ATy(F8, + OTy bTy), + qVar"state"), + Mop(Cast + F8, + nVar"core")), + Mop(Some, + LT))), + EQ(EX(Dest + ("LLAddr", + F64, + Apply + (Dest + ("c_CP0", + ATy(F8, + CTy"CP0"), + qVar"state"), + Mop(Cast + F8, + nVar"core"))), + LN + 39, + LN + 5, + FTy 35), + EX(Var("pAddr", + FTy 40), + LN + 39, + LN + 5, + FTy 35))), + Rupd + ("c_LLbit", + TP[qVar"state", + Fupd + (Dest + ("c_LLbit", + ATy(F8, + OTy bTy), + qVar"state"), + Mop(Cast + F8, + nVar"core"), + Mop(Some, + LF))]), + qVar"state")]))]), + qVar"s")))))))), + TP[LU,qVar"s"]))))) +; +val Fetch_def = Def + ("Fetch",qVar"state", + Let(Var("v",CTy"CP0"), + Mop(Fst,Apply(Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"state")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Random", + TP[Var("v",CTy"CP0"), + Rupd + ("Random", + TP[Dest + ("Random",CTy"Random",Var("v",CTy"CP0")), + ITE(EQ(Dest + ("Random",F8, + Dest + ("Random",CTy"Random", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0", + qTy))), + qVar"state")))), + Dest + ("Wired",F8, + Dest + ("Wired",CTy"Wired", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0", + qTy))), + qVar"state"))))), + Mop(Cast F8, + Bop(Sub,Const("TLBEntries",nTy), + LN 1)), + Bop(Sub, + Dest + ("Random",F8, + Dest + ("Random",CTy"Random", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0", + qTy))), + qVar"state")))), + LW(1,8)))])])),qVar"state")), + Let(qVar"s", + ITE(EQ(Dest + ("Compare",F32, + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"s"))), + Dest + ("Count",F32, + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"s")))), + Let(Var("v",CTy"CP0"), + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"s")), + Let(qVar"s", + Let(Var("x0",CTy"CauseRegister"), + Dest + ("Cause",CTy"CauseRegister", + Var("v",CTy"CP0")), + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Cause", + TP[Var("v",CTy"CP0"), + Rupd + ("IP", + TP[Var("x0", + CTy"CauseRegister"), + BFI(LN 7,LN 7, + Mop(Cast F1,LT), + Dest + ("IP",F8, + Var("x0", + CTy"CauseRegister")))])])), + qVar"s"))), + Let(Var("v",CTy"CP0"), + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"s")), + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Cause", + TP[Var("v",CTy"CP0"), + Rupd + ("TI", + TP[Dest + ("Cause", + CTy"CauseRegister", + Var("v",CTy"CP0")), + LT])])),qVar"s"))))), + qVar"s"), + Let(qVar"s", + ITE(Bop(And, + Dest + ("IE",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"s")))), + Mop(Not, + Bop(Or, + Dest + ("EXL",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0",qTy))), + qVar"s")))), + Dest + ("ERL",bTy, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0",qTy))), + qVar"s"))))))), + ITE(Mop(Not, + EQ(Bop(BAnd, + EX(Dest + ("IM",F8, + Dest + ("Status", + CTy"StatusRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0", + qTy))), + qVar"s")))),LN 7, + LN 2,FTy 6), + EX(Dest + ("IP",F8, + Dest + ("Cause",CTy"CauseRegister", + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0", + qTy))), + qVar"s")))),LN 7, + LN 2,FTy 6)),LW(0,6))), + Mop(Snd, + Apply + (Call + ("SignalException", + ATy(qTy,PTy(uTy,qTy)), + LC("Int",CTy"ExceptionType")),qVar"s")), + qVar"s"),qVar"s"), + ITB([(Mop(Fst, + Apply + (Const + ("exceptionSignalled", + ATy(qTy,PTy(bTy,qTy))),qVar"s")), + TP[LO F32,qVar"s"]), + (EQ(EX(Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))), + qVar"s")),LN 1,LN 0,FTy 2),LW(0,2)), + Let(Var("v",F64), + Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))), + qVar"s")), + Dest + ("base",F64, + Mop(Fst, + Apply + (Const + ("PCC", + ATy(qTy, + PTy(CTy"Capability",qTy))), + qVar"s")))), + ITB([(Mop(Not, + Dest + ("tag",bTy, + Mop(Fst, + Apply + (Const + ("PCC", + ATy(qTy, + PTy(CTy"Capability", + qTy))),qVar"s")))), + TP[LO F32, + Mop(Snd, + Apply + (Call + ("SignalCapException_noReg", + ATy(qTy,PTy(uTy,qTy)), + LC("capExcTag", + CTy"CapException")), + qVar"s"))]), + (Dest + ("sealed",bTy, + Mop(Fst, + Apply + (Const + ("PCC", + ATy(qTy, + PTy(CTy"Capability", + qTy))),qVar"s"))), + TP[LO F32, + Mop(Snd, + Apply + (Call + ("SignalCapException_noReg", + ATy(qTy,PTy(uTy,qTy)), + LC("capExcSeal", + CTy"CapException")), + qVar"s"))]), + (Bop(Ugt,Var("v",F64), + Bop(Add, + Dest + ("base",F64, + Mop(Fst, + Apply + (Const + ("PCC", + ATy(qTy, + PTy(CTy"Capability", + qTy))), + qVar"s"))), + Dest + ("length",F64, + Mop(Fst, + Apply + (Const + ("PCC", + ATy(qTy, + PTy(CTy"Capability", + qTy))), + qVar"s"))))), + TP[LO F32, + Mop(Snd, + Apply + (Call + ("SignalCapException_noReg", + ATy(qTy,PTy(uTy,qTy)), + LC("capExcLength", + CTy"CapException")), + qVar"s"))]), + (Bop(Ult,Var("v",F64), + Dest + ("base",F64, + Mop(Fst, + Apply + (Const + ("PCC", + ATy(qTy, + PTy(CTy"Capability", + qTy))),qVar"s")))), + TP[LO F32, + Mop(Snd, + Apply + (Call + ("SignalCapException_noReg", + ATy(qTy,PTy(uTy,qTy)), + LC("capExcLength", + CTy"CapException")), + qVar"s"))]), + (Mop(Not, + Dest + ("Permit_Execute",bTy, + Call + ("rec'Perms",CTy"Perms", + Dest + ("perms",FTy 31, + Mop(Fst, + Apply + (Const + ("PCC", + ATy(qTy, + PTy(CTy"Capability", + qTy))), + qVar"s")))))), + TP[LO F32, + Mop(Snd, + Apply + (Call + ("SignalCapException_noReg", + ATy(qTy,PTy(uTy,qTy)), + LC("capExcPermExe", + CTy"CapException")), + qVar"s"))])], + Let(TP[Var("v", + PTy(FTy 40, + PTy(FTy 3,PTy(bTy,bTy)))), + qVar"s"], + Apply + (Call + ("AddressTranslation", + ATy(qTy, + PTy(PTy(FTy 40, + PTy(FTy 3, + PTy(bTy,bTy))), + qTy)), + TP[Var("v",F64), + LC("INSTRUCTION",CTy"IorD"), + LC("LOAD",CTy"AccessType")]), + qVar"s"), + Let(TP[Var("pc",FTy 40), + Var("cca", + PTy(FTy 3,PTy(bTy,bTy)))], + Var("v", + PTy(FTy 40, + PTy(FTy 3,PTy(bTy,bTy)))), + ITE(Mop(Fst, + Apply + (Const + ("exceptionSignalled", + ATy(qTy, + PTy(bTy,qTy))), + qVar"s")), + TP[LO F32,qVar"s"], + Let(TP[Var("v",F32),qVar"s"], + Apply + (Call + ("ReadInst", + ATy(qTy, + PTy(F32,qTy)), + Var("pc",FTy 40)), + qVar"s"), + TP[Mop(Some,Var("v",F32)), + qVar"s"])))))))], + TP[LO F32, + Mop(Snd, + Apply + (Call + ("SignalException", + ATy(qTy,PTy(uTy,qTy)), + LC("AdEL",CTy"ExceptionType")), + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy,PTy(uTy,qTy)), + Rupd + ("BadVAddr", + TP[Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0", + qTy))), + qVar"s")), + Bop(Add, + Dest + ("base",F64, + Mop(Fst, + Apply + (Const + ("PCC", + ATy(qTy, + PTy(CTy"Capability", + qTy))), + qVar"s"))), + Mop(Fst, + Apply + (Const + ("PC", + ATy(qTy, + PTy(F64, + qTy))), + qVar"s")))])), + qVar"s"))))])))))) ; -val StoreMemory_def = Def - ("StoreMemory", - TP[Var("MemType",FTy 3),Var("AccessLength",FTy 3),Var("MemElem",F64), - Var("vAddr",F64),Var("IorD",CTy"IorD"), - Var("AccessType",CTy"AccessType"),bVar"cond"], +val dfn'JALR_def = Def + ("dfn'JALR",TP[Var("rs",FTy 5),Var("rd",FTy 5)], Close (qVar"state", - Let(Var("v",F64), - Bop(Add, - Bop(Add,Var("vAddr",F64), + Apply + (Call + ("write'BranchTo",ATy(qTy,PTy(uTy,qTy)), + Mop(Some, + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")))), + Mop(Snd, + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))), + qVar"state")),LW(8,64)),Var("rd",FTy 5)]), + qVar"state"))))) +; +val PSIZE_def = Def0 ("PSIZE",LN 40) +; +val resetStats_def = Def + ("resetStats",qVar"state", + Apply + (Const("initMemStats",ATy(qTy,PTy(uTy,qTy))), + Mop(Snd, + Apply(Const("initCoreStats",ATy(qTy,PTy(uTy,qTy))),qVar"state")))) +; +val dumpStats_def = Def + ("dumpStats",qVar"state", + Let(TP[sVar"r",Var("s1",PTy(sTy,qTy))], + Let(Var("s",PTy(sTy,qTy)), + Mop(Snd, + Apply + (For(TP[LN 0, + Bop(Sub,Dest("totalCore",nTy,qVar"state"),LN 1), + Close + (nVar"i", + Close + (Var("state",PTy(sTy,qTy)), + Let(TP[sVar"v",Var("s",PTy(sTy,qTy))], + Let(TP[sVar"v0",Var("s",PTy(sTy,qTy))], + CS(TP[Mop(Fst, + Apply + (Const + ("printCoreStats", + ATy(qTy, + PTy(sTy,qTy))), + Mop(Snd, + Var("state", + PTy(sTy,qTy))))), + Mop(Snd, + Var("state",PTy(sTy,qTy)))], + [(TP[sVar"v",qVar"s3"], + TP[sVar"v", + Mop(Fst, + Var("state", + PTy(sTy,qTy))), + qVar"s3"])]), + TP[CC[Mop(Fst, + Var("state",PTy(sTy,qTy))), + LS"-- Core ", + Mop(Cast sTy,nVar"i"), + LS" stats --\n",sVar"v0", + LS"\n"],Var("s",PTy(sTy,qTy))]), + TP[LU,sVar"v", + Mop(Snd,Var("s",PTy(sTy,qTy)))])))]), + TP[LNL cTy,qVar"state"])), + Let(Var("s",PTy(sTy,qTy)), + Let(TP[sVar"v",Var("s",PTy(sTy,qTy))], + Let(TP[sVar"v0",Var("s0",PTy(sTy,qTy))], + CS(TP[Mop(Fst, + Apply + (Const + ("printMemStats", + ATy(qTy,PTy(sTy,qTy))), + Mop(Snd,Var("s",PTy(sTy,qTy))))), + Mop(Snd,Var("s",PTy(sTy,qTy)))], + [(TP[sVar"v",qVar"s3"], + TP[sVar"v",Mop(Fst,Var("s",PTy(sTy,qTy))), + qVar"s3"])]), + TP[CC[Mop(Fst,Var("s",PTy(sTy,qTy))), + LS" -- Memory stats --\n",sVar"v0",LS"\n"], + Var("s0",PTy(sTy,qTy))]), + TP[sVar"v",Mop(Snd,Var("s",PTy(sTy,qTy)))]), + TP[Mop(Fst,Var("s",PTy(sTy,qTy))),Var("s",PTy(sTy,qTy))])), + TP[sVar"r",Mop(Snd,Var("s1",PTy(sTy,qTy)))])) +; +val HI_def = Def + ("HI",qVar"state", + CS(Mop(Fst,Apply(Const("hi",ATy(qTy,PTy(OTy F64,qTy))),qVar"state")), + [(Mop(Some,Var("v",F64)),TP[Var("v",F64),qVar"state"]), + (LO F64,TP[LX F64,qVar"state"])])) +; +val write'HI_def = Def + ("write'HI",Var("value",F64), + Close + (qVar"state", + Apply + (Call + ("mark_log",ATy(qTy,PTy(uTy,qTy)), + TP[LN 2,Call("log_w_hi",sTy,Var("value",F64))]), + Mop(Snd, + Apply + (Call + ("write'hi",ATy(qTy,PTy(uTy,qTy)), + Mop(Some,Var("value",F64))),qVar"state"))))) +; +val LO_def = Def + ("LO",qVar"state", + CS(Mop(Fst,Apply(Const("lo",ATy(qTy,PTy(OTy F64,qTy))),qVar"state")), + [(Mop(Some,Var("v",F64)),TP[Var("v",F64),qVar"state"]), + (LO F64,TP[LX F64,qVar"state"])])) +; +val write'LO_def = Def + ("write'LO",Var("value",F64), + Close + (qVar"state", + Apply + (Call + ("mark_log",ATy(qTy,PTy(uTy,qTy)), + TP[LN 2,Call("log_w_lo",sTy,Var("value",F64))]), + Mop(Snd, + Apply + (Call + ("write'lo",ATy(qTy,PTy(uTy,qTy)), + Mop(Some,Var("value",F64))),qVar"state"))))) +; +val CPR_def = Def + ("CPR",TP[nVar"n",Var("reg",FTy 5),Var("sel",FTy 3)], + Close + (qVar"state", + CS(TP[nVar"n",Var("reg",FTy 5),Var("sel",FTy 3)], + [(TP[LN 0,LW(0,5),LW(0,3)], + TP[Mop(Cast F64, + Call + ("reg'Index",F32, + Dest + ("Index",CTy"Index", + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state"))))),qVar"state"]), + (TP[LN 0,LW(1,5),LW(0,3)], + TP[Mop(Cast F64, + Call + ("reg'Random",F32, + Dest + ("Random",CTy"Random", + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state"))))),qVar"state"]), + (TP[LN 0,LW(2,5),LW(0,3)], + TP[Call + ("reg'EntryLo",F64, + Dest + ("EntryLo0",CTy"EntryLo", + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state")))),qVar"state"]), + (TP[LN 0,LW(3,5),LW(0,3)], + TP[Call + ("reg'EntryLo",F64, + Dest + ("EntryLo1",CTy"EntryLo", + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state")))),qVar"state"]), + (TP[LN 0,LW(4,5),LW(0,3)], + TP[Call + ("reg'Context",F64, + Dest + ("Context",CTy"Context", + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state")))),qVar"state"]), + (TP[LN 0,LW(4,5),LW(2,3)], + TP[Dest + ("UsrLocal",F64, + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state"))),qVar"state"]), + (TP[LN 0,LW(5,5),LW(0,3)], + TP[Mop(Cast F64, + Call + ("reg'PageMask",F32, + Dest + ("PageMask",CTy"PageMask", + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state"))))),qVar"state"]), + (TP[LN 0,LW(6,5),LW(0,3)], + TP[Mop(Cast F64, + Call + ("reg'Wired",F32, + Dest + ("Wired",CTy"Wired", + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state"))))),qVar"state"]), + (TP[LN 0,LW(7,5),LW(0,3)], + TP[Mop(Cast F64, + Call + ("reg'HWREna",F32, + Dest + ("HWREna",CTy"HWREna", + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state"))))),qVar"state"]), + (TP[LN 0,LW(8,5),LW(0,3)], + TP[Dest + ("BadVAddr",F64, + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state"))),qVar"state"]), + (TP[LN 0,LW(8,5),LW(1,3)], + TP[Mop(Cast F64, Dest - ("base",F64, + ("EInstr",F32, Mop(Fst, Apply - (Call - ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), - LW(0,5)),qVar"state")))), - Dest - ("offset",F64, + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state")))),qVar"state"]), + (TP[LN 0,LW(9,5),LW(0,3)], + TP[Mop(Cast F64, + Dest + ("Count",F32, + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state")))),qVar"state"]), + (TP[LN 0,LW(10,5),LW(0,3)], + TP[Call + ("reg'EntryHi",F64, + Dest + ("EntryHi",CTy"EntryHi", + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state")))),qVar"state"]), + (TP[LN 0,LW(11,5),LW(0,3)], + TP[Mop(Cast F64, + Dest + ("Compare",F32, + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state")))),qVar"state"]), + (TP[LN 0,LW(12,5),LW(0,3)], + TP[Mop(Cast F64, + Call + ("reg'StatusRegister",F32, + Dest + ("Status",CTy"StatusRegister", + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state"))))),qVar"state"]), + (TP[LN 0,LW(13,5),LW(0,3)], + TP[Mop(Cast F64, + Call + ("reg'CauseRegister",F32, + Dest + ("Cause",CTy"CauseRegister", + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state"))))),qVar"state"]), + (TP[LN 0,LW(14,5),LW(0,3)], + TP[Dest + ("EPC",F64, Mop(Fst, Apply - (Call - ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), - LW(0,5)),qVar"state")))), - ITB([(Mop(Not, - Dest - ("tag",bTy, - Mop(Fst, - Apply - (Call - ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), - LW(0,5)),qVar"state")))), - TP[LX bTy, - Mop(Snd, + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state"))),qVar"state"]), + (TP[LN 0,LW(15,5),LW(0,3)], + TP[Mop(Cast F64, + Dest + ("PRId",F32, + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state")))),qVar"state"]), + (TP[LN 0,LW(15,5),LW(1,3)], + TP[Mop(Cast F64, + CC[Mop(Cast F16, + Bop(Sub,Dest("totalCore",nTy,qVar"state"),LN 1)), + Mop(Cast F16,Dest("procID",F8,qVar"state"))]), + qVar"state"]), + (TP[LN 0,LW(15,5),LW(6,3)], + TP[Mop(Cast F64, + CC[Mop(Cast F16, + Bop(Sub,Dest("totalCore",nTy,qVar"state"),LN 1)), + Mop(Cast F16,Dest("procID",F8,qVar"state"))]), + qVar"state"]), + (TP[LN 0,LW(16,5),LW(0,3)], + TP[Mop(Cast F64, + Call + ("reg'ConfigRegister",F32, + Dest + ("Config",CTy"ConfigRegister", + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state"))))),qVar"state"]), + (TP[LN 0,LW(16,5),LW(1,3)], + TP[Mop(Cast F64, + Call + ("reg'ConfigRegister1",F32, + Dest + ("Config1",CTy"ConfigRegister1", + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state"))))),qVar"state"]), + (TP[LN 0,LW(16,5),LW(2,3)], + TP[Mop(Cast F64, + Call + ("reg'ConfigRegister2",F32, + Dest + ("Config2",CTy"ConfigRegister2", + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state"))))),qVar"state"]), + (TP[LN 0,LW(16,5),LW(3,3)], + TP[Mop(Cast F64, + Call + ("reg'ConfigRegister3",F32, + Dest + ("Config3",CTy"ConfigRegister3", + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state"))))),qVar"state"]), + (TP[LN 0,LW(16,5),LW(4,3)],TP[LW(1,64),qVar"state"]), + (TP[LN 0,LW(16,5),LW(5,3)],TP[LW(1,64),qVar"state"]), + (TP[LN 0,LW(16,5),LW(6,3)], + TP[Mop(Cast F64, + Call + ("reg'ConfigRegister6",F32, + Dest + ("Config6",CTy"ConfigRegister6", + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state"))))),qVar"state"]), + (TP[LN 0,LW(17,5),LW(0,3)], + TP[Mop(Cast F64, + Dest + ("LLAddr",F64, + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state")))),qVar"state"]), + (TP[LN 0,LW(20,5),LW(0,3)], + TP[Call + ("reg'XContext",F64, + Dest + ("XContext",CTy"XContext", + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state")))),qVar"state"]), + (TP[LN 0,LW(23,5),LW(0,3)], + TP[Mop(Cast F64, + Dest + ("Debug",F32, + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state")))),qVar"state"]), + (TP[LN 0,LW(26,5),LW(0,3)], + TP[Mop(Cast F64, + Dest + ("ErrCtl",F32, + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state")))),qVar"state"]), + (TP[LN 0,LW(30,5),LW(0,3)], + TP[Dest + ("ErrorEPC",F64, + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state"))),qVar"state"]), + (AVar(PTy(nTy,PTy(FTy 5,FTy 3))),TP[LX F64,qVar"state"])]))) +; +val write'CPR_def = Def + ("write'CPR", + TP[Var("value",F64),nVar"n",Var("reg",FTy 5),Var("sel",FTy 3)], + Close + (qVar"state", + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("mark_log",ATy(qTy,PTy(uTy,qTy)), + TP[LN 2, + Call + ("log_w_c0",sTy, + TP[Var("reg",FTy 5),Var("value",F64)])]), + qVar"state")), + CS(TP[nVar"n",Var("reg",FTy 5),Var("sel",FTy 3)], + [(TP[LN 0,LW(0,5),LW(0,3)], + Let(Var("v",CTy"CP0"), + Mop(Fst, Apply - (Call - ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), - TP[LC("capExcTag",CTy"CapException"),LW(0,5)]), - qVar"state"))]), - (Dest - ("sealed",bTy, + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s")), + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Index", + TP[Var("v",CTy"CP0"), + Rupd + ("Index", + TP[Dest + ("Index",CTy"Index", + Var("v",CTy"CP0")), + EX(Var("value",F64),LN 7,LN 0,F8)])])), + qVar"s"))), + (TP[LN 0,LW(2,5),LW(0,3)], + Let(Var("v",CTy"CP0"), + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s")), + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("EntryLo0", + TP[Var("v",CTy"CP0"), + Call + ("write'reg'EntryLo",CTy"EntryLo", + TP[Dest + ("EntryLo0",CTy"EntryLo", + Var("v",CTy"CP0")), + Var("value",F64)])])),qVar"s"))), + (TP[LN 0,LW(3,5),LW(0,3)], + Let(Var("v",CTy"CP0"), + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s")), + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("EntryLo1", + TP[Var("v",CTy"CP0"), + Call + ("write'reg'EntryLo",CTy"EntryLo", + TP[Dest + ("EntryLo1",CTy"EntryLo", + Var("v",CTy"CP0")), + Var("value",F64)])])),qVar"s"))), + (TP[LN 0,LW(4,5),LW(0,3)], + Let(Var("v",CTy"CP0"), + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s")), + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Context", + TP[Var("v",CTy"CP0"), + Rupd + ("PTEBase", + TP[Dest + ("Context",CTy"Context", + Var("v",CTy"CP0")), + EX(Var("value",F64),LN 63,LN 23, + FTy 41)])])),qVar"s"))), + (TP[LN 0,LW(4,5),LW(2,3)], + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("UsrLocal", + TP[Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"s")),Var("value",F64)])),qVar"s")), + (TP[LN 0,LW(5,5),LW(0,3)], + Let(Var("v",CTy"CP0"), Mop(Fst, Apply - (Call - ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), - LW(0,5)),qVar"state"))), - TP[LX bTy, - Mop(Snd, + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s")), + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("PageMask", + TP[Var("v",CTy"CP0"), + Rupd + ("Mask", + TP[Dest + ("PageMask",CTy"PageMask", + Var("v",CTy"CP0")), + EX(Var("value",F64),LN 24,LN 13, + FTy 12)])])),qVar"s"))), + (TP[LN 0,LW(6,5),LW(0,3)], + Let(Var("v",CTy"CP0"), + Mop(Fst, Apply - (Call - ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), - TP[LC("capExcSeal",CTy"CapException"),LW(0,5)]), - qVar"state"))]), - (Bop(Ult,Var("v",F64), - Dest - ("base",F64, - Mop(Fst, + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s")), + Let(qVar"s", + Mop(Snd, Apply (Call - ("CAPR",ATy(qTy,PTy(CTy"Capability",qTy)), - LW(0,5)),qVar"state")))), - TP[LX bTy, - Mop(Snd, - Apply - (Call - ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), - TP[LC("capExcLength",CTy"CapException"), - LW(0,5)]),qVar"state"))]), - (Bop(Ugt,Var("v",F64), - Bop(Add, - Dest - ("base",F64, + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Wired", + TP[Var("v",CTy"CP0"), + Rupd + ("Wired", + TP[Dest + ("Wired",CTy"Wired", + Var("v",CTy"CP0")), + EX(Var("value",F64),LN 7, + LN 0,F8)])])),qVar"s")), + Let(Var("v",CTy"CP0"), Mop(Fst, Apply - (Call - ("CAPR", - ATy(qTy,PTy(CTy"Capability",qTy)), - LW(0,5)),qVar"state"))), - Dest - ("length",F64, + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"s")), + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Random", + TP[Var("v",CTy"CP0"), + Rupd + ("Random", + TP[Dest + ("Random",CTy"Random", + Var("v",CTy"CP0")), + Mop(Cast F8, + Bop(Sub, + Const + ("TLBEntries",nTy), + LN 1))])])),qVar"s"))))), + (TP[LN 0,LW(7,5),LW(0,3)], + Let(Var("v",CTy"CP0"), + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("HWREna", + TP[Var("v",CTy"CP0"), + Rupd + ("CPUNum", + TP[Dest + ("HWREna",CTy"HWREna", + Var("v",CTy"CP0")), + Bop(Bit,Var("value",F64),LN 0)])])), + qVar"s")), + Let(Var("v",CTy"CP0"), Mop(Fst, Apply - (Call - ("CAPR", - ATy(qTy,PTy(CTy"Capability",qTy)), - LW(0,5)),qVar"state"))))), - TP[LX bTy, - Mop(Snd, - Apply - (Call - ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), - TP[LC("capExcLength",CTy"CapException"), - LW(0,5)]),qVar"state"))]), - (Mop(Not, - Dest - ("Permit_Store",bTy, - Call - ("rec'Perms",CTy"Perms", - Dest - ("perms",FTy 31, - Mop(Fst, - Apply - (Call - ("CAPR", - ATy(qTy,PTy(CTy"Capability",qTy)), - LW(0,5)),qVar"state")))))), - TP[LX bTy, - Mop(Snd, - Apply - (Call - ("SignalCapException",ATy(qTy,PTy(uTy,qTy)), - TP[LC("capExcPermStore",CTy"CapException"), - LW(0,5)]),qVar"state"))])], - Apply - (Call - ("StoreMemoryCap",ATy(qTy,PTy(bTy,qTy)), - TP[Var("MemType",FTy 3),Var("AccessLength",FTy 3), - Var("MemElem",F64),Var("v",F64), - Var("IorD",CTy"IorD"), - Var("AccessType",CTy"AccessType"),bVar"cond"]), - qVar"state"))))) -; -val StoreCap_def = Def - ("StoreCap",TP[Var("vAddr",F64),Var("Capability",CTy"Capability")], - Close - (qVar"state", - Let(TP[Var("v",PTy(FTy 40,PTy(FTy 3,PTy(bTy,bTy)))),qVar"s"], - Apply - (Call - ("AddressTranslation", - ATy(qTy,PTy(PTy(FTy 40,PTy(FTy 3,PTy(bTy,bTy))),qTy)), - TP[Var("vAddr",F64),LC("DATA",CTy"IorD"), - LC("CSTORE",CTy"AccessType")]),qVar"state"), - Let(TP[Var("pAddr",FTy 40),Var("CCA",FTy 3),bVar"S",bVar"L"], - Var("v",PTy(FTy 40,PTy(FTy 3,PTy(bTy,bTy)))), - ITE(Mop(Not, - Mop(Fst, - Apply - (Const - ("exceptionSignalled",ATy(qTy,PTy(bTy,qTy))), - qVar"s"))), - Let(Var("a",FTy 35), - EX(Var("pAddr",FTy 40),LN 39,LN 5,FTy 35), - Let(qVar"s", - Mop(Snd, - Apply - (Call - ("write'LLbit",ATy(qTy,PTy(uTy,qTy)), - LO bTy), - ITE(EQ(Var("a",FTy 35), - EX(Dest - ("base_address",FTy 37, - Dest - ("JTAG_UART", - CTy"JTAG_UART",qVar"s")), - LN 36,LN 2,FTy 35)), - Mop(Snd, - Apply - (Call - ("raise'exception", - ATy(qTy,PTy(uTy,qTy)), - Call - ("UNPREDICTABLE", - CTy"exception", - LS - "Capability store attempted on UART")), - qVar"s")), - Mop(Snd, - Apply - (For(TP[LN 0, - Bop(Sub, - Dest - ("totalCore",nTy, - qVar"s"),LN 1), - Close - (nVar"core", - Close - (qVar"state", - ITE(Bop(And, - Bop(Uge, - Var("a", - FTy 35), - EX(Apply - (Dest - ("PIC_base_address", - ATy(F8, - FTy 37), - qVar"state"), - Mop(Cast - F8, - nVar"core")), - LN - 36, - LN - 2, - FTy 35)), - Bop(Ult, - Var("a", - FTy 35), - EX(Bop(Add, - Apply - (Dest - ("PIC_base_address", - ATy(F8, - FTy 37), - qVar"state"), - Mop(Cast - F8, - nVar"core")), - LW(1072, - 37)), - LN - 36, - LN - 2, - FTy 35))), - Apply - (Call - ("raise'exception", - ATy(qTy, - PTy(uTy, - qTy)), - Call - ("UNPREDICTABLE", - CTy"exception", - LS - "Capability store attempted on PIC")), - qVar"state"), - TP[LU, - qVar"state"])))]), - qVar"s"))))), - ITE(Bop(And,bVar"S", - Dest - ("tag",bTy, - Var("Capability",CTy"Capability"))), - Apply - (Call - ("SignalCapException_noReg", - ATy(qTy,PTy(uTy,qTy)), - LC("capExcTLBNoStore", - CTy"CapException")),qVar"s"), - Let(qVar"s", - Mop(Snd, - Apply - (Call - ("WriteData", - ATy(qTy,PTy(uTy,qTy)), - TP[CC[Var("a",FTy 35),LW(3,2)], - EX(Call - ("reg'Capability", - FTy 257, - Var("Capability", - CTy"Capability")), - LN 63,LN 0,F64), - Mop(BNot,LW(0,64))]), - Mop(Snd, - Apply - (Call - ("WriteData", - ATy(qTy,PTy(uTy,qTy)), - TP[CC[Var("a",FTy 35), - LW(2,2)], - EX(Call - ("reg'Capability", - FTy 257, - Var("Capability", - CTy"Capability")), - LN 127,LN 64,F64), - Mop(BNot,LW(0,64))]), - Mop(Snd, - Apply - (Call - ("WriteData", - ATy(qTy, - PTy(uTy,qTy)), - TP[CC[Var("a", - FTy 35), - LW(1,2)], - EX(Call - ("reg'Capability", - FTy 257, - Var("Capability", - CTy"Capability")), - LN 191, - LN 128,F64), - Mop(BNot, - LW(0,64))]), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy,PTy(uTy,qTy)), + Rupd + ("HWREna", + TP[Var("v",CTy"CP0"), + Rupd + ("CC", + TP[Dest + ("HWREna", + CTy"HWREna", + Var("v",CTy"CP0")), + Bop(Bit, + Var("value",F64), + LN 2)])])), + qVar"s")), + Let(Var("v",CTy"CP0"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy,PTy(uTy,qTy)), + Rupd + ("HWREna", + TP[Var("v",CTy"CP0"), + Rupd + ("CCRes", + TP[Dest + ("HWREna", + CTy"HWREna", + Var("v", + CTy"CP0")), + Bop(Bit, + Var("value", + F64), + LN 3)])])), + qVar"s")), + Let(Var("v",CTy"CP0"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0",qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy,qTy)), + Rupd + ("HWREna", + TP[Var("v", + CTy"CP0"), + Rupd + ("RS", + TP[Dest + ("HWREna", + CTy"HWREna", + Var("v", + CTy"CP0")), + Bop(Bit, + Var("value", + F64), + LN + 27)])])), + qVar"s")), + Let(Var("v",CTy"CP0"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0", + qTy))), + qVar"s")), + Let(qVar"s", Mop(Snd, Apply (Call - ("WriteData", + ("write'CP0", ATy(qTy, PTy(uTy, qTy)), - TP[CC[Var("a", - FTy 35), - LW(0, - 2)], - EX(Call - ("reg'Capability", - FTy 257, - Var("Capability", - CTy"Capability")), - LN - 255, - LN - 192, - F64), - Mop(BNot, - LW(0, - 64))]), - Mop(Snd, - Apply - (Call - ("mark_log", - ATy(qTy, - PTy(uTy, - qTy)), - TP[LN - 2, - CC[LS - "Store cap: ", - Call - ("log_store_cap", - sTy, - TP[Var("pAddr", - FTy 40), - Var("Capability", - CTy"Capability")])]]), - Mop(Snd, - Apply - (For(TP[LN - 0, - Bop(Sub, - Dest - ("totalCore", - nTy, - qVar"s"), - LN - 1), - Close - (nVar"core", - Close - (qVar"state", - TP[LU, - ITE(Bop(And, - Bop(And, - Mop(Not, - EQ(nVar"core", - Mop(Cast - nTy, - Dest - ("procID", - F8, - qVar"state")))), - EQ(Apply - (Dest - ("c_LLbit", - ATy(F8, - OTy bTy), - qVar"state"), - Mop(Cast - F8, - nVar"core")), - Mop(Some, - LT))), - EQ(EX(Dest - ("LLAddr", - F64, - Apply - (Dest - ("c_CP0", - ATy(F8, - CTy"CP0"), - qVar"state"), - Mop(Cast - F8, - nVar"core"))), - LN - 39, - LN - 5, - FTy 35), - EX(Var("pAddr", - FTy 40), - LN - 39, - LN - 5, - FTy 35))), - Rupd - ("c_LLbit", - TP[qVar"state", - Fupd - (Dest - ("c_LLbit", - ATy(F8, - OTy bTy), - qVar"state"), - Mop(Cast - F8, - nVar"core"), - Mop(Some, - LF))]), - qVar"state")]))]), - qVar"s")))))))))))), - TP[LU, - Rupd - ("TAG", - TP[qVar"s", - Fupd - (Dest - ("TAG",ATy(FTy 35,bTy), - qVar"s"),Var("a",FTy 35), - Dest - ("tag",bTy, - Var("Capability", - CTy"Capability")))])])))), - TP[LU,qVar"s"]))))) -; -val Fetch_def = Def - ("Fetch",qVar"state", - Let(Var("v",CTy"CP0"), - Mop(Fst,Apply(Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"state")), - Let(qVar"s", - Mop(Snd, + Rupd + ("HWREna", + TP[Var("v", + CTy"CP0"), + Rupd + ("DS", + TP[Dest + ("HWREna", + CTy"HWREna", + Var("v", + CTy"CP0")), + Bop(Bit, + Var("value", + F64), + LN + 28)])])), + qVar"s")), + Let(Var("v", + CTy"CP0"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0", + qTy))), + qVar"s")), + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("HWREna", + TP[Var("v", + CTy"CP0"), + Rupd + ("UL", + TP[Dest + ("HWREna", + CTy"HWREna", + Var("v", + CTy"CP0")), + Bop(Bit, + Var("value", + F64), + LN + 29)])])), + qVar"s"))))))))))))), + (TP[LN 0,LW(9,5),LW(0,3)], Apply (Call ("write'CP0",ATy(qTy,PTy(uTy,qTy)), Rupd - ("Random", - TP[Var("v",CTy"CP0"), - Rupd - ("Random", - TP[Dest - ("Random",CTy"Random",Var("v",CTy"CP0")), - ITE(EQ(Dest - ("Random",F8, - Dest - ("Random",CTy"Random", - Mop(Fst, - Apply - (Const - ("CP0", - ATy(qTy, - PTy(CTy"CP0", - qTy))), - qVar"state")))), - Dest - ("Wired",F8, - Dest - ("Wired",CTy"Wired", - Mop(Fst, - Apply - (Const - ("CP0", - ATy(qTy, - PTy(CTy"CP0", - qTy))), - qVar"state"))))), - Mop(Cast F8, - Bop(Sub,Const("TLBEntries",nTy), - LN 1)), - Bop(Sub, - Dest - ("Random",F8, - Dest - ("Random",CTy"Random", - Mop(Fst, - Apply - (Const - ("CP0", - ATy(qTy, - PTy(CTy"CP0", - qTy))), - qVar"state")))), - LW(1,8)))])])),qVar"state")), - Let(qVar"s", - ITE(EQ(Dest - ("Compare",F32, - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"s"))), - Dest - ("Count",F32, - Mop(Fst, - Apply - (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"s")))), + ("Count", + TP[Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"s")), + EX(Var("value",F64),LN 31,LN 0,F32)])),qVar"s")), + (TP[LN 0,LW(10,5),LW(0,3)], + Let(Var("v",CTy"CP0"), + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s")), + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("EntryHi", + TP[Var("v",CTy"CP0"), + Call + ("write'reg'EntryHi",CTy"EntryHi", + TP[Dest + ("EntryHi",CTy"EntryHi", + Var("v",CTy"CP0")), + Var("value",F64)])])),qVar"s"))), + (TP[LN 0,LW(11,5),LW(0,3)], + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Compare", + TP[Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"s")), + EX(Var("value",F64),LN 31,LN 0,F32)])), + qVar"s")), Let(Var("v",CTy"CP0"), Mop(Fst, Apply @@ -12220,7 +12404,7 @@ val Fetch_def = Def TP[Var("x0", CTy"CauseRegister"), BFI(LN 7,LN 7, - Mop(Cast F1,LT), + Mop(Cast F1,LF), Dest ("IP",F8, Var("x0", @@ -12232,336 +12416,193 @@ val Fetch_def = Def (Const ("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), qVar"s")), - Mop(Snd, - Apply - (Call - ("write'CP0", - ATy(qTy,PTy(uTy,qTy)), - Rupd - ("Cause", - TP[Var("v",CTy"CP0"), - Rupd - ("TI", - TP[Dest - ("Cause", - CTy"CauseRegister", - Var("v",CTy"CP0")), - LT])])),qVar"s"))))), - qVar"s"), - Let(qVar"s", - ITE(Bop(And, - Dest - ("IE",bTy, - Dest - ("Status",CTy"StatusRegister", - Mop(Fst, - Apply - (Const - ("CP0", - ATy(qTy,PTy(CTy"CP0",qTy))), - qVar"s")))), - Mop(Not, - Bop(Or, - Dest - ("EXL",bTy, - Dest - ("Status",CTy"StatusRegister", - Mop(Fst, - Apply - (Const - ("CP0", - ATy(qTy, - PTy(CTy"CP0",qTy))), - qVar"s")))), - Dest - ("ERL",bTy, - Dest - ("Status",CTy"StatusRegister", - Mop(Fst, - Apply - (Const - ("CP0", - ATy(qTy, - PTy(CTy"CP0",qTy))), - qVar"s"))))))), - ITE(Mop(Not, - EQ(Bop(BAnd, - EX(Dest - ("IM",F8, - Dest - ("Status", - CTy"StatusRegister", - Mop(Fst, - Apply - (Const - ("CP0", - ATy(qTy, - PTy(CTy"CP0", - qTy))), - qVar"s")))),LN 7, - LN 2,FTy 6), - EX(Dest - ("IP",F8, - Dest - ("Cause",CTy"CauseRegister", - Mop(Fst, - Apply - (Const - ("CP0", - ATy(qTy, - PTy(CTy"CP0", - qTy))), - qVar"s")))),LN 7, - LN 2,FTy 6)),LW(0,6))), - Mop(Snd, Apply (Call - ("SignalException", - ATy(qTy,PTy(uTy,qTy)), - LC("Int",CTy"ExceptionType")),qVar"s")), - qVar"s"),qVar"s"), - ITB([(Mop(Fst, - Apply - (Const - ("exceptionSignalled", - ATy(qTy,PTy(bTy,qTy))),qVar"s")), - TP[LO F32,qVar"s"]), - (EQ(EX(Mop(Fst, - Apply - (Const("PC",ATy(qTy,PTy(F64,qTy))), - qVar"s")),LN 1,LN 0,FTy 2),LW(0,2)), - Let(Var("v",F64), - Bop(Add, - Mop(Fst, - Apply - (Const("PC",ATy(qTy,PTy(F64,qTy))), - qVar"s")), - Dest - ("base",F64, - Mop(Fst, - Apply - (Const - ("PCC", - ATy(qTy, - PTy(CTy"Capability",qTy))), - qVar"s")))), - ITB([(Mop(Not, - Dest - ("tag",bTy, - Mop(Fst, - Apply - (Const - ("PCC", - ATy(qTy, - PTy(CTy"Capability", - qTy))),qVar"s")))), - TP[LO F32, - Mop(Snd, - Apply - (Call - ("SignalCapException_noReg", - ATy(qTy,PTy(uTy,qTy)), - LC("capExcTag", - CTy"CapException")), - qVar"s"))]), - (Dest - ("sealed",bTy, - Mop(Fst, - Apply - (Const - ("PCC", - ATy(qTy, - PTy(CTy"Capability", - qTy))),qVar"s"))), - TP[LO F32, - Mop(Snd, - Apply - (Call - ("SignalCapException_noReg", - ATy(qTy,PTy(uTy,qTy)), - LC("capExcSeal", - CTy"CapException")), - qVar"s"))]), - (Bop(Ugt,Var("v",F64), - Bop(Add, - Dest - ("base",F64, - Mop(Fst, - Apply - (Const - ("PCC", - ATy(qTy, - PTy(CTy"Capability", - qTy))), - qVar"s"))), - Dest - ("length",F64, - Mop(Fst, - Apply - (Const - ("PCC", - ATy(qTy, - PTy(CTy"Capability", - qTy))), - qVar"s"))))), - TP[LO F32, - Mop(Snd, - Apply - (Call - ("SignalCapException_noReg", - ATy(qTy,PTy(uTy,qTy)), - LC("capExcLength", - CTy"CapException")), - qVar"s"))]), - (Bop(Ult,Var("v",F64), - Dest - ("base",F64, - Mop(Fst, - Apply - (Const - ("PCC", - ATy(qTy, - PTy(CTy"Capability", - qTy))),qVar"s")))), - TP[LO F32, - Mop(Snd, - Apply - (Call - ("SignalCapException_noReg", - ATy(qTy,PTy(uTy,qTy)), - LC("capExcLength", - CTy"CapException")), - qVar"s"))]), - (Mop(Not, - Dest - ("Permit_Execute",bTy, - Call - ("rec'Perms",CTy"Perms", - Dest - ("perms",FTy 31, - Mop(Fst, - Apply - (Const - ("PCC", - ATy(qTy, - PTy(CTy"Capability", - qTy))), - qVar"s")))))), - TP[LO F32, - Mop(Snd, - Apply - (Call - ("SignalCapException_noReg", - ATy(qTy,PTy(uTy,qTy)), - LC("capExcPermExe", - CTy"CapException")), - qVar"s"))])], - Let(TP[Var("v", - PTy(FTy 40, - PTy(FTy 3,PTy(bTy,bTy)))), - qVar"s"], - Apply - (Call - ("AddressTranslation", - ATy(qTy, - PTy(PTy(FTy 40, - PTy(FTy 3, - PTy(bTy,bTy))), - qTy)), - TP[Var("v",F64), - LC("INSTRUCTION",CTy"IorD"), - LC("LOAD",CTy"AccessType")]), - qVar"s"), - Let(TP[Var("pc",FTy 40), - Var("cca", - PTy(FTy 3,PTy(bTy,bTy)))], - Var("v", - PTy(FTy 40, - PTy(FTy 3,PTy(bTy,bTy)))), - TP[ITE(Mop(Fst, - Apply - (Const - ("exceptionSignalled", - ATy(qTy, - PTy(bTy,qTy))), - qVar"s")),LO F32, - Mop(Some, - Mop(Fst, - Apply - (Call - ("ReadInst", - ATy(qTy, - PTy(F32, - qTy)), - Var("pc", - FTy 40)), - qVar"s")))), - qVar"s"])))))], - TP[LO F32, - Mop(Snd, - Apply - (Call - ("SignalException", - ATy(qTy,PTy(uTy,qTy)), - LC("AdEL",CTy"ExceptionType")), - Mop(Snd, - Apply - (Call - ("write'CP0", - ATy(qTy,PTy(uTy,qTy)), + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Cause", + TP[Var("v",CTy"CP0"), Rupd - ("BadVAddr", - TP[Mop(Fst, - Apply - (Const - ("CP0", - ATy(qTy, - PTy(CTy"CP0", - qTy))), - qVar"s")), - Bop(Add, - Dest - ("base",F64, - Mop(Fst, - Apply - (Const - ("PCC", - ATy(qTy, - PTy(CTy"Capability", - qTy))), - qVar"s"))), - Mop(Fst, - Apply - (Const - ("PC", - ATy(qTy, - PTy(F64, - qTy))), - qVar"s")))])), - qVar"s"))))])))))) -; -val dfn'JALR_def = Def - ("dfn'JALR",TP[Var("rs",FTy 5),Var("rd",FTy 5)], - Close - (qVar"state", - Apply - (Call - ("write'BranchTo",ATy(qTy,PTy(uTy,qTy)), - Mop(Some, - Mop(Fst, - Apply - (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), - qVar"state")))), - Mop(Snd, - Apply - (Call - ("write'GPR",ATy(qTy,PTy(uTy,qTy)), - TP[Bop(Add, - Mop(Fst, - Apply - (Const("PC",ATy(qTy,PTy(F64,qTy))), - qVar"state")),LW(8,64)),Var("rd",FTy 5)]), - qVar"state"))))) + ("TI", + TP[Dest + ("Cause", + CTy"CauseRegister", + Var("v",CTy"CP0")),LF])])), + qVar"s")))))), + (TP[LN 0,LW(12,5),LW(0,3)], + Let(Var("v",CTy"CP0"), + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s")), + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Status", + TP[Var("v",CTy"CP0"), + Call + ("write'reg'StatusRegister", + CTy"StatusRegister", + TP[Dest + ("Status",CTy"StatusRegister", + Var("v",CTy"CP0")), + EX(Var("value",F64),LN 31,LN 0,F32)])])), + qVar"s"))), + (TP[LN 0,LW(13,5),LW(0,3)], + Let(Var("v",CTy"CP0"), + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s")), + Let(Var("x0",CTy"CauseRegister"), + Dest("Cause",CTy"CauseRegister",Var("v",CTy"CP0")), + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Cause", + TP[Var("v",CTy"CP0"), + Rupd + ("IP", + TP[Var("x0",CTy"CauseRegister"), + BFI(LN 1,LN 0, + EX(Var("value",F64),LN 9, + LN 8,FTy 2), + Dest + ("IP",F8, + Var("x0", + CTy"CauseRegister")))])])), + qVar"s")))), + (TP[LN 0,LW(14,5),LW(0,3)], + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("EPC", + TP[Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"s")),Var("value",F64)])),qVar"s")), + (TP[LN 0,LW(16,5),LW(0,3)], + Let(Var("v",CTy"CP0"), + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s")), + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Config", + TP[Var("v",CTy"CP0"), + Rupd + ("K0", + TP[Dest + ("Config",CTy"ConfigRegister", + Var("v",CTy"CP0")), + EX(Var("value",F64),LN 2,LN 0,FTy 3)])])), + qVar"s"))), + (TP[LN 0,LW(16,5),LW(2,3)], + Let(Var("v",CTy"CP0"), + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s")), + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Config2", + TP[Var("v",CTy"CP0"), + Rupd + ("SU", + TP[Dest + ("Config2",CTy"ConfigRegister2", + Var("v",CTy"CP0")), + EX(Var("value",F64),LN 15,LN 12,F4)])])), + qVar"s"))), + (TP[LN 0,LW(16,5),LW(6,3)], + Let(Var("v",CTy"CP0"), + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s")), + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Config6", + TP[Var("v",CTy"CP0"), + Rupd + ("LTLB", + TP[Dest + ("Config6",CTy"ConfigRegister6", + Var("v",CTy"CP0")), + Bop(Bit,Var("value",F64),LN 2)])])), + qVar"s"))), + (TP[LN 0,LW(20,5),LW(0,3)], + Let(Var("v",CTy"CP0"), + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))),qVar"s")), + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("XContext", + TP[Var("v",CTy"CP0"), + Rupd + ("PTEBase", + TP[Dest + ("XContext",CTy"XContext", + Var("v",CTy"CP0")), + EX(Var("value",F64),LN 63,LN 33, + FTy 31)])])),qVar"s"))), + (TP[LN 0,LW(23,5),LW(0,3)], + TP[LU, + Rupd + ("done", + TP[Mop(Snd, + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("Debug", + TP[Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0",qTy))), + qVar"s")), + EX(Var("value",F64),LN 31,LN 0,F32)])), + qVar"s")),LT])]), + (TP[LN 0,LW(26,5),LW(0,3)], + Apply + (Call("dumpRegs",ATy(qTy,PTy(uTy,qTy)),LU), + Mop(Snd, + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("ErrCtl", + TP[Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"s")), + EX(Var("value",F64),LN 31,LN 0,F32)])), + qVar"s")))), + (TP[LN 0,LW(30,5),LW(0,3)], + Apply + (Call + ("write'CP0",ATy(qTy,PTy(uTy,qTy)), + Rupd + ("ErrorEPC", + TP[Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"s")),Var("value",F64)])),qVar"s")), + (AVar(PTy(nTy,PTy(FTy 5,FTy 3))), + Apply + (Call("unmark_log",ATy(qTy,PTy(uTy,qTy)),LN 2),qVar"s"))])))) ; val register_inaccessible_def = Def ("register_inaccessible",Var("cb",FTy 5), @@ -27872,316 +27913,446 @@ val dfn'BGEZAL_def = Def qVar"s")),LW(4,64)), Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))), qVar"s"), - Apply(Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))),qVar"s"))))) -; -val dfn'BEQL_def = Def - ("dfn'BEQL",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("offset",F16)], - Close - (qVar"state", - ITE(EQ(Mop(Fst, - Apply - (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), - qVar"state")), - Mop(Fst, - Apply - (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), - qVar"state"))), - Apply - (Call - ("write'BranchTo",ATy(qTy,PTy(uTy,qTy)), - Mop(Some, - Bop(Add, - Bop(Add, - Mop(Fst, - Apply - (Const("PC",ATy(qTy,PTy(F64,qTy))), - qVar"state")),LW(4,64)), - Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))), - qVar"state"), - Let(qVar"s", - Mop(Snd, + Apply(Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))),qVar"s"))))) +; +val dfn'BEQL_def = Def + ("dfn'BEQL",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("offset",F16)], + Close + (qVar"state", + ITE(EQ(Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state"))), + Apply + (Call + ("write'BranchTo",ATy(qTy,PTy(uTy,qTy)), + Mop(Some, + Bop(Add, + Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))), + qVar"state")),LW(4,64)), + Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))), + qVar"state"), + Let(qVar"s", + Mop(Snd, + Apply + (Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))), + qVar"state")), + Apply + (Call + ("write'PC",ATy(qTy,PTy(uTy,qTy)), + Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))),qVar"s")), + LW(4,64))),qVar"s"))))) +; +val dfn'BNEL_def = Def + ("dfn'BNEL",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("offset",F16)], + Close + (qVar"state", + ITE(Mop(Not, + EQ(Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")), + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), + qVar"state")))), + Apply + (Call + ("write'BranchTo",ATy(qTy,PTy(uTy,qTy)), + Mop(Some, + Bop(Add, + Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))), + qVar"state")),LW(4,64)), + Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))), + qVar"state"), + Let(qVar"s", + Mop(Snd, + Apply + (Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))), + qVar"state")), + Apply + (Call + ("write'PC",ATy(qTy,PTy(uTy,qTy)), + Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))),qVar"s")), + LW(4,64))),qVar"s"))))) +; +val dfn'BLEZL_def = Def + ("dfn'BLEZL",TP[Var("rs",FTy 5),Var("offset",F16)], + Close + (qVar"state", + ITE(Bop(Le, + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")),LW(0,64)), + Apply + (Call + ("write'BranchTo",ATy(qTy,PTy(uTy,qTy)), + Mop(Some, + Bop(Add, + Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))), + qVar"state")),LW(4,64)), + Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))), + qVar"state"), + Let(qVar"s", + Mop(Snd, + Apply + (Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))), + qVar"state")), + Apply + (Call + ("write'PC",ATy(qTy,PTy(uTy,qTy)), + Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))),qVar"s")), + LW(4,64))),qVar"s"))))) +; +val dfn'BGTZL_def = Def + ("dfn'BGTZL",TP[Var("rs",FTy 5),Var("offset",F16)], + Close + (qVar"state", + ITE(Bop(Gt, + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")),LW(0,64)), + Apply + (Call + ("write'BranchTo",ATy(qTy,PTy(uTy,qTy)), + Mop(Some, + Bop(Add, + Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))), + qVar"state")),LW(4,64)), + Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))), + qVar"state"), + Let(qVar"s", + Mop(Snd, + Apply + (Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))), + qVar"state")), + Apply + (Call + ("write'PC",ATy(qTy,PTy(uTy,qTy)), + Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))),qVar"s")), + LW(4,64))),qVar"s"))))) +; +val dfn'BLTZL_def = Def + ("dfn'BLTZL",TP[Var("rs",FTy 5),Var("offset",F16)], + Close + (qVar"state", + ITE(Bop(Lt, + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")),LW(0,64)), + Apply + (Call + ("write'BranchTo",ATy(qTy,PTy(uTy,qTy)), + Mop(Some, + Bop(Add, + Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))), + qVar"state")),LW(4,64)), + Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))), + qVar"state"), + Let(qVar"s", + Mop(Snd, + Apply + (Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))), + qVar"state")), + Apply + (Call + ("write'PC",ATy(qTy,PTy(uTy,qTy)), + Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))),qVar"s")), + LW(4,64))),qVar"s"))))) +; +val dfn'BGEZL_def = Def + ("dfn'BGEZL",TP[Var("rs",FTy 5),Var("offset",F16)], + Close + (qVar"state", + ITE(Bop(Ge, + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")),LW(0,64)), + Apply + (Call + ("write'BranchTo",ATy(qTy,PTy(uTy,qTy)), + Mop(Some, + Bop(Add, + Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))), + qVar"state")),LW(4,64)), + Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))), + qVar"state"), + Let(qVar"s", + Mop(Snd, + Apply + (Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))), + qVar"state")), + Apply + (Call + ("write'PC",ATy(qTy,PTy(uTy,qTy)), + Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))),qVar"s")), + LW(4,64))),qVar"s"))))) +; +val dfn'BLTZALL_def = Def + ("dfn'BLTZALL",TP[Var("rs",FTy 5),Var("offset",F16)], + Close + (qVar"state", + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))), + qVar"state")),LW(8,64)),LW(31,5)]), + qVar"state")), + ITE(Bop(Lt, + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")),LW(0,64)), + Apply + (Call + ("write'BranchTo",ATy(qTy,PTy(uTy,qTy)), + Mop(Some, + Bop(Add, + Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))), + qVar"s")),LW(4,64)), + Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))), + qVar"s"), + Let(qVar"s", + Mop(Snd, + Apply + (Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))), + qVar"s")), + Apply + (Call + ("write'PC",ATy(qTy,PTy(uTy,qTy)), + Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))), + qVar"s")),LW(4,64))),qVar"s")))))) +; +val dfn'BGEZALL_def = Def + ("dfn'BGEZALL",TP[Var("rs",FTy 5),Var("offset",F16)], + Close + (qVar"state", + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))), + qVar"state")),LW(8,64)),LW(31,5)]), + qVar"state")), + ITE(Bop(Ge, + Mop(Fst, + Apply + (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), + qVar"state")),LW(0,64)), + Apply + (Call + ("write'BranchTo",ATy(qTy,PTy(uTy,qTy)), + Mop(Some, + Bop(Add, + Bop(Add, + Mop(Fst, + Apply + (Const("PC",ATy(qTy,PTy(F64,qTy))), + qVar"s")),LW(4,64)), + Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))), + qVar"s"), + Let(qVar"s", + Mop(Snd, + Apply + (Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))), + qVar"s")), Apply - (Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))), - qVar"state")), - Apply - (Call - ("write'PC",ATy(qTy,PTy(uTy,qTy)), - Bop(Add, - Mop(Fst, - Apply - (Const("PC",ATy(qTy,PTy(F64,qTy))),qVar"s")), - LW(4,64))),qVar"s"))))) -; -val dfn'BNEL_def = Def - ("dfn'BNEL",TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("offset",F16)], - Close - (qVar"state", - ITE(Mop(Not, - EQ(Mop(Fst, - Apply - (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), - qVar"state")), - Mop(Fst, - Apply - (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rt",FTy 5)), - qVar"state")))), - Apply - (Call - ("write'BranchTo",ATy(qTy,PTy(uTy,qTy)), - Mop(Some, - Bop(Add, + (Call + ("write'PC",ATy(qTy,PTy(uTy,qTy)), Bop(Add, Mop(Fst, Apply (Const("PC",ATy(qTy,PTy(F64,qTy))), - qVar"state")),LW(4,64)), - Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))), - qVar"state"), - Let(qVar"s", - Mop(Snd, - Apply - (Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))), - qVar"state")), - Apply - (Call - ("write'PC",ATy(qTy,PTy(uTy,qTy)), - Bop(Add, - Mop(Fst, - Apply - (Const("PC",ATy(qTy,PTy(F64,qTy))),qVar"s")), - LW(4,64))),qVar"s"))))) + qVar"s")),LW(4,64))),qVar"s")))))) ; -val dfn'BLEZL_def = Def - ("dfn'BLEZL",TP[Var("rs",FTy 5),Var("offset",F16)], +val dfn'RDHWR_def = Def + ("dfn'RDHWR",TP[Var("rt",FTy 5),Var("rd",FTy 5)], Close (qVar"state", - ITE(Bop(Le, - Mop(Fst, - Apply - (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), - qVar"state")),LW(0,64)), - Apply - (Call - ("write'BranchTo",ATy(qTy,PTy(uTy,qTy)), - Mop(Some, - Bop(Add, - Bop(Add, - Mop(Fst, - Apply - (Const("PC",ATy(qTy,PTy(F64,qTy))), - qVar"state")),LW(4,64)), - Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))), - qVar"state"), - Let(qVar"s", - Mop(Snd, - Apply - (Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))), - qVar"state")), - Apply - (Call - ("write'PC",ATy(qTy,PTy(uTy,qTy)), - Bop(Add, + ITE(Bop(Or, + Bop(Or, + Dest + ("CU0",bTy, + Dest + ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const("PC",ATy(qTy,PTy(F64,qTy))),qVar"s")), - LW(4,64))),qVar"s"))))) -; -val dfn'BGTZL_def = Def - ("dfn'BGTZL",TP[Var("rs",FTy 5),Var("offset",F16)], - Close - (qVar"state", - ITE(Bop(Gt, - Mop(Fst, - Apply - (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), - qVar"state")),LW(0,64)), - Apply - (Call - ("write'BranchTo",ATy(qTy,PTy(uTy,qTy)), - Mop(Some, - Bop(Add, - Bop(Add, - Mop(Fst, - Apply - (Const("PC",ATy(qTy,PTy(F64,qTy))), - qVar"state")),LW(4,64)), - Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))), - qVar"state"), - Let(qVar"s", - Mop(Snd, - Apply - (Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))), - qVar"state")), - Apply - (Call - ("write'PC",ATy(qTy,PTy(uTy,qTy)), - Bop(Add, + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state")))), + Mop(Fst, + Apply + (Const("KernelMode",ATy(qTy,PTy(bTy,qTy))), + qVar"state"))), + Bop(Bit, + Call + ("reg'HWREna",F32, + Dest + ("HWREna",CTy"HWREna", Mop(Fst, Apply - (Const("PC",ATy(qTy,PTy(F64,qTy))),qVar"s")), - LW(4,64))),qVar"s"))))) -; -val dfn'BLTZL_def = Def - ("dfn'BLTZL",TP[Var("rs",FTy 5),Var("offset",F16)], - Close - (qVar"state", - ITE(Bop(Lt, - Mop(Fst, - Apply - (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), - qVar"state")),LW(0,64)), + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state")))), + Mop(Cast nTy,Var("rd",FTy 5)))), + CS(Var("rd",FTy 5), + [(LW(0,5), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Cast F64,Dest("procID",F8,qVar"state")), + Var("rt",FTy 5)]),qVar"state")), + (LW(2,5), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(SE F64, + Dest + ("Count",F32, + Mop(Fst, + Apply + (Const + ("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state")))),Var("rt",FTy 5)]), + qVar"state")), + (LW(3,5), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[LW(1,64),Var("rt",FTy 5)]),qVar"state")), + (LW(26,5),TP[LU,Rupd("done",TP[qVar"state",LT])]), + (LW(27,5), + Apply + (Const("resetStats",ATy(qTy,PTy(uTy,qTy))),qVar"state")), + (LW(28,5), + TP[Apply + (Dest("print",ATy(sTy,uTy),qVar"state"), + Mop(Fst, + Apply + (Const("dumpStats",ATy(qTy,PTy(sTy,qTy))), + qVar"state"))),qVar"state"]), + (LW(29,5), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Dest + ("UsrLocal",F64, + Mop(Fst, + Apply + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state"))),Var("rt",FTy 5)]), + qVar"state")), + (LW(30,5), + Apply + (Call + ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Cast F64, + Bop(Sub,Dest("totalCore",nTy,qVar"state"),LN 1)), + Var("rt",FTy 5)]),qVar"state")), + (AVar(FTy 5), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("ResI",CTy"ExceptionType")),qVar"state"))]), Apply (Call - ("write'BranchTo",ATy(qTy,PTy(uTy,qTy)), - Mop(Some, - Bop(Add, - Bop(Add, - Mop(Fst, - Apply - (Const("PC",ATy(qTy,PTy(F64,qTy))), - qVar"state")),LW(4,64)), - Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))), - qVar"state"), - Let(qVar"s", - Mop(Snd, - Apply - (Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))), - qVar"state")), - Apply - (Call - ("write'PC",ATy(qTy,PTy(uTy,qTy)), - Bop(Add, - Mop(Fst, - Apply - (Const("PC",ATy(qTy,PTy(F64,qTy))),qVar"s")), - LW(4,64))),qVar"s"))))) + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("ResI",CTy"ExceptionType")),qVar"state")))) ; -val dfn'BGEZL_def = Def - ("dfn'BGEZL",TP[Var("rs",FTy 5),Var("offset",F16)], +val dfn'CACHE_def = Def + ("dfn'CACHE",TP[Var("base",FTy 5),Var("opn",FTy 5),Var("offset",F16)], Close (qVar"state", - ITE(Bop(Ge, - Mop(Fst, - Apply - (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), - qVar"state")),LW(0,64)), - Apply - (Call - ("write'BranchTo",ATy(qTy,PTy(uTy,qTy)), - Mop(Some, - Bop(Add, - Bop(Add, - Mop(Fst, - Apply - (Const("PC",ATy(qTy,PTy(F64,qTy))), - qVar"state")),LW(4,64)), - Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))), - qVar"state"), - Let(qVar"s", - Mop(Snd, - Apply - (Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))), - qVar"state")), - Apply - (Call - ("write'PC",ATy(qTy,PTy(uTy,qTy)), - Bop(Add, + ITE(Bop(And, + Mop(Not, + Dest + ("CU0",bTy, + Dest + ("Status",CTy"StatusRegister", Mop(Fst, Apply - (Const("PC",ATy(qTy,PTy(F64,qTy))),qVar"s")), - LW(4,64))),qVar"s"))))) -; -val dfn'BLTZALL_def = Def - ("dfn'BLTZALL",TP[Var("rs",FTy 5),Var("offset",F16)], - Close - (qVar"state", - Let(qVar"s", - Mop(Snd, - Apply - (Call - ("write'GPR",ATy(qTy,PTy(uTy,qTy)), - TP[Bop(Add, - Mop(Fst, - Apply - (Const("PC",ATy(qTy,PTy(F64,qTy))), - qVar"state")),LW(8,64)),LW(31,5)]), - qVar"state")), - ITE(Bop(Lt, + (Const("CP0",ATy(qTy,PTy(CTy"CP0",qTy))), + qVar"state"))))), + Mop(Not, Mop(Fst, Apply - (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), - qVar"state")),LW(0,64)), - Apply - (Call - ("write'BranchTo",ATy(qTy,PTy(uTy,qTy)), - Mop(Some, - Bop(Add, - Bop(Add, - Mop(Fst, - Apply - (Const("PC",ATy(qTy,PTy(F64,qTy))), - qVar"s")),LW(4,64)), - Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))), - qVar"s"), - Let(qVar"s", - Mop(Snd, - Apply - (Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))), - qVar"s")), - Apply - (Call - ("write'PC",ATy(qTy,PTy(uTy,qTy)), - Bop(Add, - Mop(Fst, - Apply - (Const("PC",ATy(qTy,PTy(F64,qTy))), - qVar"s")),LW(4,64))),qVar"s")))))) -; -val dfn'BGEZALL_def = Def - ("dfn'BGEZALL",TP[Var("rs",FTy 5),Var("offset",F16)], - Close - (qVar"state", - Let(qVar"s", - Mop(Snd, + (Const("KernelMode",ATy(qTy,PTy(bTy,qTy))), + qVar"state")))), + Apply + (Call + ("SignalException",ATy(qTy,PTy(uTy,qTy)), + LC("CpU",CTy"ExceptionType")),qVar"state"), + Let(TP[Var("v",PTy(FTy 40,PTy(FTy 3,PTy(bTy,bTy)))),qVar"s"], Apply (Call - ("write'GPR",ATy(qTy,PTy(uTy,qTy)), + ("AddressTranslation", + ATy(qTy,PTy(PTy(FTy 40,PTy(FTy 3,PTy(bTy,bTy))),qTy)), TP[Bop(Add, Mop(Fst, Apply - (Const("PC",ATy(qTy,PTy(F64,qTy))), - qVar"state")),LW(8,64)),LW(31,5)]), - qVar"state")), - ITE(Bop(Ge, - Mop(Fst, - Apply - (Call("GPR",ATy(qTy,PTy(F64,qTy)),Var("rs",FTy 5)), - qVar"state")),LW(0,64)), - Apply - (Call - ("write'BranchTo",ATy(qTy,PTy(uTy,qTy)), - Mop(Some, - Bop(Add, - Bop(Add, - Mop(Fst, - Apply - (Const("PC",ATy(qTy,PTy(F64,qTy))), - qVar"s")),LW(4,64)), - Bop(Lsl,Mop(SE F64,Var("offset",F16)),LN 2)))), - qVar"s"), - Let(qVar"s", - Mop(Snd, - Apply - (Const("CheckBranch",ATy(qTy,PTy(uTy,qTy))), - qVar"s")), - Apply - (Call - ("write'PC",ATy(qTy,PTy(uTy,qTy)), - Bop(Add, - Mop(Fst, - Apply - (Const("PC",ATy(qTy,PTy(F64,qTy))), - qVar"s")),LW(4,64))),qVar"s")))))) + (Call + ("GPR",ATy(qTy,PTy(F64,qTy)), + Var("base",FTy 5)),qVar"state")), + Mop(SE F64,Var("offset",F16))), + LC("DATA",CTy"IorD"),LC("LOAD",CTy"AccessType")]), + qVar"state"),TP[LU,qVar"s"])))) ; val dfn'WAIT_def = Def0 ("dfn'WAIT",LU) ; @@ -36130,8 +36301,7 @@ val COP2Init_def = Def (qVar"state", TP[LU, Let(Var("s",PTy(CTy"CapCause",qTy)), - TP[Rupd("ExcCode",TP[LX(CTy"CapCause"),LW(0,8)]), - Rupd("TAG",TP[qVar"state",Mop(K1(FTy 35),LF)])], + TP[Rupd("ExcCode",TP[LX(CTy"CapCause"),LW(0,8)]),qVar"state"], Let(Var("s",PTy(CTy"CapCause",qTy)), TP[Rupd ("RegNum", @@ -36338,7 +36508,7 @@ val initTLB_def = Def TP[Var("r",CTy"TLBEntry"),Mop(Snd,Var("s1",PTy(CTy"TLBEntry",qTy)))])) ; val initMips_def = Def - ("initMips",TP[nVar"pc",nVar"uart"], + ("initMips",TP[nVar"pc",nVar"uart",bVar"rdhwr_extra"], Close (qVar"state", Let(Var("v",CTy"CP0"), @@ -38042,180 +38212,282 @@ val initMips_def = Def Let(qVar"s", Mop(Snd, Apply - (For(TP[LN - 0, - LN - 31, - Close - (nVar"i", - Close - (qVar"state", - Apply - (Call - ("write'gpr", - ATy(qTy, - PTy(uTy, - qTy)), - TP[LW(12297829382473034410, - 64), - Mop(Cast - (FTy 5), - nVar"i")]), - qVar"state")))]), - Rupd - ("done", - TP[Mop(Snd, - Apply - (Call - ("COP2Init", - ATy(qTy, - PTy(uTy, - qTy)), - LU), - Mop(Snd, + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("HWREna", + TP[Var("v", + CTy"CP0"), + Call + ("write'reg'HWREna", + CTy"HWREna", + TP[Dest + ("HWREna", + CTy"HWREna", + Var("v", + CTy"CP0")), + LW(0, + 32)])])), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (For(TP[LN + 0, + LN + 31, + Close + (nVar"i", + Close + (qVar"state", Apply (Call - ("write'PC", + ("write'gpr", ATy(qTy, PTy(uTy, qTy)), - Mop(Cast - F64, - nVar"pc")), - Mop(Snd, - Apply - (Call - ("write'lo", - ATy(qTy, - PTy(uTy, - qTy)), - LO F64), - Mop(Snd, - Apply - (Call - ("write'hi", - ATy(qTy, - PTy(uTy, - qTy)), - LO F64), - Mop(Snd, - Apply - (Call - ("write'LLbit", - ATy(qTy, - PTy(uTy, - qTy)), - LO bTy), - Mop(Snd, - Apply - (Call - ("write'BranchTo", - ATy(qTy, - PTy(uTy, - qTy)), - LO F64), - Mop(Snd, - Apply - (Call - ("write'BranchDelay", - ATy(qTy, - PTy(uTy, - qTy)), - LO F64), - Mop(Snd, - Apply - (For(TP[LN - 0, - LN - 127, - Close - (nVar"i", - Close - (qVar"state", - Apply - (Call - ("write'TLB_assoc", - ATy(qTy, - PTy(uTy, - qTy)), - TP[Mop(Fst, - Apply - (Const - ("initTLB", - ATy(qTy, - PTy(CTy"TLBEntry", - qTy))), - qVar"state")), - Mop(Cast - F4, - nVar"i")]), - qVar"state")))]), - Mop(Snd, - Apply - (Call - ("write'CP0", - ATy(qTy, - PTy(uTy, - qTy)), - Rupd - ("HWREna", - TP[Var("v", - CTy"CP0"), - Call - ("write'reg'HWREna", - CTy"HWREna", - TP[Dest - ("HWREna", - CTy"HWREna", - Var("v", - CTy"CP0")), - LW(0, - 32)])])), - qVar"s")))))))))))))))))), - LF]))), - Let(qVar"s", - Mop(Snd, - Apply - (Call - ("PIC_initialise", - ATy(qTy, - PTy(uTy, - qTy)), - Bop(Add, - LN - 2139111424, - Bop(Mul, - Mop(Cast - nTy, - Dest - ("procID", - F8, - qVar"s")), - LN - 16384))), - qVar"s")), - ITE(EQ(Dest - ("procID", - F8, - qVar"s"), - LW(0, - 8)), - Apply - (Const - ("InitMEM", - ATy(qTy, - PTy(uTy, - qTy))), - Mop(Snd, - Apply - (Call - ("JTAG_UART_initialise", - ATy(qTy, - PTy(uTy, - qTy)), - nVar"uart"), - qVar"s"))), - TP[LU, - qVar"s"]))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) + TP[LW(12297829382473034410, + 64), + Mop(Cast + (FTy 5), + nVar"i")]), + qVar"state")))]), + Rupd + ("done", + TP[Mop(Snd, + Apply + (Call + ("COP2Init", + ATy(qTy, + PTy(uTy, + qTy)), + LU), + Mop(Snd, + Apply + (Call + ("write'PC", + ATy(qTy, + PTy(uTy, + qTy)), + Mop(Cast + F64, + nVar"pc")), + Mop(Snd, + Apply + (Call + ("write'lo", + ATy(qTy, + PTy(uTy, + qTy)), + LO F64), + Mop(Snd, + Apply + (Call + ("write'hi", + ATy(qTy, + PTy(uTy, + qTy)), + LO F64), + Mop(Snd, + Apply + (Call + ("write'LLbit", + ATy(qTy, + PTy(uTy, + qTy)), + LO bTy), + Mop(Snd, + Apply + (Call + ("write'BranchTo", + ATy(qTy, + PTy(uTy, + qTy)), + LO F64), + Mop(Snd, + Apply + (Call + ("write'BranchDelay", + ATy(qTy, + PTy(uTy, + qTy)), + LO F64), + Mop(Snd, + Apply + (For(TP[LN + 0, + LN + 127, + Close + (nVar"i", + Close + (qVar"state", + Apply + (Call + ("write'TLB_assoc", + ATy(qTy, + PTy(uTy, + qTy)), + TP[Mop(Fst, + Apply + (Const + ("initTLB", + ATy(qTy, + PTy(CTy"TLBEntry", + qTy))), + qVar"state")), + Mop(Cast + F4, + nVar"i")]), + qVar"state")))]), + ITE(bVar"rdhwr_extra", + Let(Var("v", + CTy"CP0"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("HWREna", + TP[Var("v", + CTy"CP0"), + Rupd + ("KS", + TP[Dest + ("HWREna", + CTy"HWREna", + Var("v", + CTy"CP0")), + LT])])), + qVar"s")), + Let(Var("v", + CTy"CP0"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0", + qTy))), + qVar"s")), + Let(qVar"s", + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("HWREna", + TP[Var("v", + CTy"CP0"), + Rupd + ("RS", + TP[Dest + ("HWREna", + CTy"HWREna", + Var("v", + CTy"CP0")), + LT])])), + qVar"s")), + Let(Var("v", + CTy"CP0"), + Mop(Fst, + Apply + (Const + ("CP0", + ATy(qTy, + PTy(CTy"CP0", + qTy))), + qVar"s")), + Mop(Snd, + Apply + (Call + ("write'CP0", + ATy(qTy, + PTy(uTy, + qTy)), + Rupd + ("HWREna", + TP[Var("v", + CTy"CP0"), + Rupd + ("DS", + TP[Dest + ("HWREna", + CTy"HWREna", + Var("v", + CTy"CP0")), + LT])])), + qVar"s"))))))), + qVar"s"))))))))))))))))), + LF]))), + Let(qVar"s", + Mop(Snd, + Apply + (Const + ("initCoreStats", + ATy(qTy, + PTy(uTy, + qTy))), + Mop(Snd, + Apply + (Call + ("PIC_initialise", + ATy(qTy, + PTy(uTy, + qTy)), + Bop(Add, + LN + 2139111424, + Bop(Mul, + Mop(Cast + nTy, + Dest + ("procID", + F8, + qVar"s")), + LN + 16384))), + qVar"s")))), + ITE(EQ(Dest + ("procID", + F8, + qVar"s"), + LW(0, + 8)), + Apply + (Const + ("InitMEM", + ATy(qTy, + PTy(uTy, + qTy))), + Mop(Snd, + Apply + (Call + ("JTAG_UART_initialise", + ATy(qTy, + PTy(uTy, + qTy)), + nVar"uart"), + qVar"s"))), + TP[LU, + qVar"s"])))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) val () = Import.finish 1 \ No newline at end of file From e45760499b16a540d2c603786148b33e47db8c8c Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 12 Mar 2015 10:58:27 +1100 Subject: [PATCH 225/718] Make 'o' map to existing \HOLTokenCompose in TeX_notation map. Closes #242 --- src/TeX/theory_tests/.gitignore | 1 + src/TeX/theory_tests/Holmakefile | 10 +++++++--- src/TeX/theory_tests/gh242_expected | 1 + src/TeX/theory_tests/gh242_input | 1 + src/combin/combinScript.sml | 1 + 5 files changed, 11 insertions(+), 3 deletions(-) create mode 100644 src/TeX/theory_tests/gh242_expected create mode 100644 src/TeX/theory_tests/gh242_input diff --git a/src/TeX/theory_tests/.gitignore b/src/TeX/theory_tests/.gitignore index 397aaad032..b927c6d2a6 100644 --- a/src/TeX/theory_tests/.gitignore +++ b/src/TeX/theory_tests/.gitignore @@ -1,3 +1,4 @@ output tyabb_output utyabb_output +gh242_output diff --git a/src/TeX/theory_tests/Holmakefile b/src/TeX/theory_tests/Holmakefile index 3b9d182be0..0dd1f124a3 100644 --- a/src/TeX/theory_tests/Holmakefile +++ b/src/TeX/theory_tests/Holmakefile @@ -5,7 +5,7 @@ INCLUDES = $(CMPDIR) THYFILES = $(patsubst %Script.sml,%Theory.uo,$(wildcard *.sml)) TARGETS = $(patsubst %.sml,%.uo,$(THYFILES)) -all: check_output check_utyabb_output check_tyabb_output $(TARGETS) +all: check_output check_utyabb_output check_tyabb_output check_gh242 $(TARGETS) check_output: output expected-output $(CMPDIR)/cmp.exe output expected-output @@ -34,6 +34,10 @@ tymunge.exe: tyabbrevTheory.uo utymunge.exe: untyabbrevTheory.uo $(protect $(HOLDIR)/bin/mkmunge.exe) -o $@ untyabbrevTheory -.PHONY: all check_output check_utyabb_output check_tyabb_output +check_gh242: gh242_input gh242_expected munge.exe + ./munge.exe < $< > gh242_output + $(CMPDIR)/cmp.exe gh242_expected gh242_output -EXTRA_CLEANS = munge.exe tymunge.exe utymunge.exe output utyabb_output tyabb_output +.PHONY: all check_output check_utyabb_output check_tyabb_output check_gh242 + +EXTRA_CLEANS = munge.exe tymunge.exe utymunge.exe output utyabb_output tyabb_output gh242_output diff --git a/src/TeX/theory_tests/gh242_expected b/src/TeX/theory_tests/gh242_expected new file mode 100644 index 0000000000..56917db645 --- /dev/null +++ b/src/TeX/theory_tests/gh242_expected @@ -0,0 +1 @@ +\HOLinline{(\HOLFreeVar{f} \HOLConst{\HOLTokenCompose} \HOLFreeVar{g}) \HOLFreeVar{x}} diff --git a/src/TeX/theory_tests/gh242_input b/src/TeX/theory_tests/gh242_input new file mode 100644 index 0000000000..7582c1dd58 --- /dev/null +++ b/src/TeX/theory_tests/gh242_input @@ -0,0 +1 @@ +\HOLtm{(f o g) x} diff --git a/src/combin/combinScript.sml b/src/combin/combinScript.sml index b8201a2fec..aa90a8d18b 100644 --- a/src/combin/combinScript.sml +++ b/src/combin/combinScript.sml @@ -32,6 +32,7 @@ val UPDATE_def = Q.new_definition("UPDATE_def", val _ = set_fixity ":>" (Infixl 310); val _ = set_fixity "=+" (Infix(NONASSOC, 320)); val _ = overload_on("=+", ``UPDATE``); +val _ = TeX_notation {hol = "o", TeX = ("\\HOLTokenCompose", 1)} local open OpenTheoryMap in val _ = OpenTheory_const_name {const={Thy="combin",Name="I"},name=(["Function"],"id")} From d43c79ba26807c70f52a1974188037f9281ba00b Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 12 Mar 2015 16:40:31 +1100 Subject: [PATCH 226/718] DOT_PATH can now be overridden with Poly/ML Failure to find an executable dot tool at the end of the build process also produces a more helpful error/warning message. --- tools-poly/smart-configure.sml | 9 +++++---- tools/buildutils.sml | 13 +++++++++++-- 2 files changed, 16 insertions(+), 6 deletions(-) diff --git a/tools-poly/smart-configure.sml b/tools-poly/smart-configure.sml index 9e55caa37b..d226da9755 100644 --- a/tools-poly/smart-configure.sml +++ b/tools-poly/smart-configure.sml @@ -61,6 +61,7 @@ print "\nHOL smart configuration.\n\n"; val poly = "" val polymllibdir = ""; +val DOT_PATH = ""; val _ = let val override = "tools-poly/poly-includes.ML" @@ -121,7 +122,7 @@ in end val polyinstruction = - "Please write file tools-poly/poly-includes.ML to specify it\ + "Please write file tools-poly/poly-includes.ML to specify it \ \properly.\n\ \This file should include a line of the form\n\n\ \ val poly = \"path-to-poly\";" @@ -206,14 +207,14 @@ val polymllibdir = | NONE => die ("\n\nYour overrides file specifies bogus location '" ^polymllibdir ^ "'\nas the location of libpolymain.a\n" ^ - polylibinstruction) + polylibinstruction); + +val DOT_PATH = if DOT_PATH = "" then "/usr/bin/dot" else DOT_PATH; val dynlib_available = false; print "\n"; -val DOT_PATH = "/usr/bin/dot" - fun verdict (prompt, value) = if value = "" then (print ("\n*** No value for "^prompt^ diff --git a/tools/buildutils.sml b/tools/buildutils.sml index 245300e1ab..38cfb330a6 100644 --- a/tools/buildutils.sml +++ b/tools/buildutils.sml @@ -662,8 +662,17 @@ fun write_theory_graph () = let val dotexec = Systeml.DOT_PATH in if not (FileSys.access (dotexec, [FileSys.A_EXEC])) then - (* of course, this will always be the case on Windows *) - warn ("*** Can't see dot executable at "^dotexec^"; not generating theory-graph\n") + (* of course, this will likely be the case on Windows *) + warn ("*** Can't see dot executable at "^dotexec^"; not generating \ + \theory-graph\n\ + \*** You can try reconfiguring and providing an explicit path \n\ + \*** (val DOT_PATH = \"....\") in\n\ + \*** tools-poly/poly-includes.ML (Poly/ML)\n\ + \*** or\n\ + \*** config-override (Moscow ML)\n\ + \***\n\ + \*** (Under Poly/ML you will have to delete bin/hol.builder0 as \ + \well)\n") else let val _ = print "Generating theory-graph and HTML theory signatures; this may take a while\n" val _ = print " (Use build's -nograph option to skip this step.)\n" From e52538bd9725757f41e7bad22c9884af7ac33f20 Mon Sep 17 00:00:00 2001 From: Piotr Trojanek Date: Mon, 16 Feb 2015 12:01:52 +0000 Subject: [PATCH 227/718] emit: improved whitespace in autogenerated ML code --- src/emit/EmitML.sml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/emit/EmitML.sml b/src/emit/EmitML.sml index 80b3569937..649c139f36 100644 --- a/src/emit/EmitML.sml +++ b/src/emit/EmitML.sml @@ -1280,7 +1280,7 @@ fun pp_struct strm (s,elems,cnames) = (s::opens()) strm (concl thm) | pp_el (iDEFN_NOSIG thm) = pp_el (iDEFN thm) | pp_el (iMLSIG s) = () - | pp_el (iMLSTRUCT s) = add_string s + | pp_el (iMLSTRUCT s) = (add_string s; add_newline ()) | pp_el (iOPEN slist) = (openthys := union slist (!openthys); begin_block CONSISTENT 0; pr_list (add_string o curry String.^ "open " o ML) From 4a96a18afd48d0cbed7f91919e6359685bd2c273 Mon Sep 17 00:00:00 2001 From: Piotr Trojanek Date: Tue, 17 Feb 2015 11:51:53 +0000 Subject: [PATCH 228/718] whitespace cleanup (align with spaces not tabs) --- src/simp/src/Sequence.sig | 40 +++++++++++++++++++-------------------- 1 file changed, 20 insertions(+), 20 deletions(-) diff --git a/src/simp/src/Sequence.sig b/src/simp/src/Sequence.sig index 5ea1686924..bad5e1cf45 100644 --- a/src/simp/src/Sequence.sig +++ b/src/simp/src/Sequence.sig @@ -16,25 +16,25 @@ Modified by Donald Syme, November 1995, for inclusion in HOL. signature Sequence = sig type 'a seq - val seq_append : 'a seq * 'a seq -> 'a seq - val seq_chop : int * 'a seq -> 'a list * 'a seq - val seq_cons : 'a * 'a seq -> 'a seq - val seq_filter : ('a -> bool) -> 'a seq -> 'a seq - val seq_flat : 'a seq seq -> 'a seq - val seq_hd : 'a seq -> 'a - val seq_interleave: 'a seq * 'a seq -> 'a seq - val seq_iterate : ('a * 'b seq -> 'b seq) -> 'a seq * 'b seq -> 'b seq - val list_of_seq : 'a seq -> 'a list - val seq_mapp : ('a -> 'b) -> 'a seq -> 'b seq -> 'b seq - val seq_map : ('a -> 'b) -> 'a seq -> 'b seq - val seq_mapfilter : ('a -> 'b) -> 'a seq -> 'b seq - val seq_nil : 'a seq - val seq_print : (int -> 'a -> unit) -> int -> 'a seq -> unit - val seq_pull : 'a seq -> ('a * 'a seq) option - val seq_of_list : 'a list -> 'a seq - val mk_seq : (unit -> ('a * 'a seq) option) -> 'a seq - val seq_single : 'a -> 'a seq - val seq_tl : 'a seq -> 'a seq - val seq_diagonalize : 'a seq -> 'b seq -> ('a * 'b) seq + val seq_append : 'a seq * 'a seq -> 'a seq + val seq_chop : int * 'a seq -> 'a list * 'a seq + val seq_cons : 'a * 'a seq -> 'a seq + val seq_filter : ('a -> bool) -> 'a seq -> 'a seq + val seq_flat : 'a seq seq -> 'a seq + val seq_hd : 'a seq -> 'a + val seq_interleave : 'a seq * 'a seq -> 'a seq + val seq_iterate : ('a * 'b seq -> 'b seq) -> 'a seq * 'b seq -> 'b seq + val list_of_seq : 'a seq -> 'a list + val seq_mapp : ('a -> 'b) -> 'a seq -> 'b seq -> 'b seq + val seq_map : ('a -> 'b) -> 'a seq -> 'b seq + val seq_mapfilter : ('a -> 'b) -> 'a seq -> 'b seq + val seq_nil : 'a seq + val seq_print : (int -> 'a -> unit) -> int -> 'a seq -> unit + val seq_pull : 'a seq -> ('a * 'a seq) option + val seq_of_list : 'a list -> 'a seq + val mk_seq : (unit -> ('a * 'a seq) option) -> 'a seq + val seq_single : 'a -> 'a seq + val seq_tl : 'a seq -> 'a seq + val seq_diagonalize : 'a seq -> 'b seq -> ('a * 'b) seq val seq_permutations : 'a list -> 'a list seq end (* sig *) From b7681c5d9f3e4eaec02b5f8b4d9316daa00986af Mon Sep 17 00:00:00 2001 From: Piotr Trojanek Date: Tue, 24 Feb 2015 12:38:01 +0000 Subject: [PATCH 229/718] compute: minor grammar fixes in (unused) manual --- src/compute/Manual/description.tex | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/compute/Manual/description.tex b/src/compute/Manual/description.tex index ed44cf98ff..51a1f67c84 100644 --- a/src/compute/Manual/description.tex +++ b/src/compute/Manual/description.tex @@ -11,7 +11,7 @@ \section{Strategy} The \ml{CBV\_CONV} conversion rewrites the equations in a call-by-value strategy, that is completely evaluates the arguments before the ``function call'' (the application of a rewrite which left-hand side -has this constant in his head). The reduction is weak, which means +has this constant in its head). The reduction is weak, which means that reduction under abstractions are delayed as long as possible. However, when we know that an abstraction will never be applied, reductions are performed under it, so that we can actually @@ -51,7 +51,7 @@ \section{Simplification sets} The \ml{compute} library has its own type of simplification sets, that can be as usual built from a list of theorems. These theorems must be -conjunctions of possibly quantified equations, whose left-hand side +conjunctions of possibly quantified equations, whose left-hand sides satisfy some condition to be defined below. Conjuncts not in the requested form are not used. From 241299a6b64db4decbb3f397627f4f1ae726de3d Mon Sep 17 00:00:00 2001 From: Piotr Trojanek Date: Thu, 12 Mar 2015 20:46:22 +0000 Subject: [PATCH 230/718] doc: use "an" article before words that start with a vowel sound --- help/Docfiles/ConseqConv.EXISTS_CONSEQ_CONV.doc | 4 ++-- help/Docfiles/ConseqConv.FORALL_CONSEQ_CONV.doc | 2 +- help/Docfiles/ConseqConv.QUANT_CONSEQ_CONV.doc | 2 +- help/Docfiles/PairRules.PSELECT_CONV.doc | 2 +- help/Docfiles/Q.MATCH_ABBREV_TAC.doc | 2 +- help/Docfiles/Q.MATCH_ASSUM_ABBREV_TAC.doc | 2 +- help/Docfiles/Q.PAT_ABBREV_TAC.doc | 2 +- help/Docfiles/Q.REFINE_EXISTS_TAC.doc | 2 +- help/Docfiles/boolSyntax.dest_exists.doc | 4 ++-- help/Docfiles/bossLib.Hol_defn.doc | 2 +- help/Docfiles/simpLib.SSFRAG.doc | 2 +- 11 files changed, 13 insertions(+), 13 deletions(-) diff --git a/help/Docfiles/ConseqConv.EXISTS_CONSEQ_CONV.doc b/help/Docfiles/ConseqConv.EXISTS_CONSEQ_CONV.doc index d7bc377e10..b1c6ba53e3 100644 --- a/help/Docfiles/ConseqConv.EXISTS_CONSEQ_CONV.doc +++ b/help/Docfiles/ConseqConv.EXISTS_CONSEQ_CONV.doc @@ -3,7 +3,7 @@ \TYPE {EXISTS_CONSEQ_CONV : (conseq_conv -> conseq_conv)} \SYNOPSIS -Applies a consequence conversion to the body of a existentially +Applies a consequence conversion to the body of an existentially quantified term. \DESCRIBE @@ -14,7 +14,7 @@ to a theorem {|- t x = t' x}, {|- t' x ==> t x} or {|- ?x. t x ==> ?x. t' x}, respectively. \FAILURE -{EXISTS_CONSEQ_CONV c t} fails, if {t} is not a existentially +{EXISTS_CONSEQ_CONV c t} fails, if {t} is not an existentially quantified term or if {c} fails on the body of {t}. \SEEALSO diff --git a/help/Docfiles/ConseqConv.FORALL_CONSEQ_CONV.doc b/help/Docfiles/ConseqConv.FORALL_CONSEQ_CONV.doc index 80900fe98d..7c1fc043d0 100644 --- a/help/Docfiles/ConseqConv.FORALL_CONSEQ_CONV.doc +++ b/help/Docfiles/ConseqConv.FORALL_CONSEQ_CONV.doc @@ -14,7 +14,7 @@ to a theorem {|- t x = t' x}, {|- t' x ==> t x} or {|- t x ==> t' x}, then {|- !x. t x ==> !x. t' x}, respectively. \FAILURE -{FORALL_CONSEQ_CONV c t} fails, if {t} is not a all-quantified term or +{FORALL_CONSEQ_CONV c t} fails, if {t} is not an all-quantified term or if {c} fails on the body of {t}. \SEEALSO diff --git a/help/Docfiles/ConseqConv.QUANT_CONSEQ_CONV.doc b/help/Docfiles/ConseqConv.QUANT_CONSEQ_CONV.doc index 53b37bb7b1..1b5bab57ce 100644 --- a/help/Docfiles/ConseqConv.QUANT_CONSEQ_CONV.doc +++ b/help/Docfiles/ConseqConv.QUANT_CONSEQ_CONV.doc @@ -4,7 +4,7 @@ \SYNOPSIS -Applies a consequence conversion to the body of a existentially or +Applies a consequence conversion to the body of an existentially or universally quantified term. \SEEALSO diff --git a/help/Docfiles/PairRules.PSELECT_CONV.doc b/help/Docfiles/PairRules.PSELECT_CONV.doc index f63238ef21..c3c2152360 100644 --- a/help/Docfiles/PairRules.PSELECT_CONV.doc +++ b/help/Docfiles/PairRules.PSELECT_CONV.doc @@ -9,7 +9,7 @@ conversion, epsilon. pair \SYNOPSIS -Eliminates a paired epsilon term by introducing a existential quantifier. +Eliminates a paired epsilon term by introducing an existential quantifier. \DESCRIBE The conversion {PSELECT_CONV} expects a boolean term of the form diff --git a/help/Docfiles/Q.MATCH_ABBREV_TAC.doc b/help/Docfiles/Q.MATCH_ABBREV_TAC.doc index 9db9139ffc..ec10991a76 100644 --- a/help/Docfiles/Q.MATCH_ABBREV_TAC.doc +++ b/help/Docfiles/Q.MATCH_ABBREV_TAC.doc @@ -14,7 +14,7 @@ pattern and the goal are treated as ``local constants'', and will not acquire instantiations. For each variable {v} in the pattern that has not been treated as a -local constant, there will be a instantiation term {t}, such that the +local constant, there will be an instantiation term {t}, such that the substitution {pattern[v1 |-> t1, v2 |-> t2, ...]} produces {w}. The effect of the tactic is to then perform abbreviations in the goal, replacing each {t} with the corresponding {v}, and adding assumptions diff --git a/help/Docfiles/Q.MATCH_ASSUM_ABBREV_TAC.doc b/help/Docfiles/Q.MATCH_ASSUM_ABBREV_TAC.doc index c1bdb4d768..ce9caeb852 100644 --- a/help/Docfiles/Q.MATCH_ASSUM_ABBREV_TAC.doc +++ b/help/Docfiles/Q.MATCH_ASSUM_ABBREV_TAC.doc @@ -14,7 +14,7 @@ Variables that occur in both the pattern and the goal are treated as ``local constants'', and will not acquire instantiations. For each variable {v} in the pattern that has not been treated as a local -constant, there will be a instantiation term {t}, such that the substitution +constant, there will be an instantiation term {t}, such that the substitution {pattern[v1 |-> t1, v2 |-> t2, ...]} produces {a}. The effect of the tactic is to then perform abbreviations in the goal, replacing each {t} with the corresponding {v}, and adding assumptions of the form {Abbrev(v = t)} to the diff --git a/help/Docfiles/Q.PAT_ABBREV_TAC.doc b/help/Docfiles/Q.PAT_ABBREV_TAC.doc index fe2d108672..c21371578f 100644 --- a/help/Docfiles/Q.PAT_ABBREV_TAC.doc +++ b/help/Docfiles/Q.PAT_ABBREV_TAC.doc @@ -7,7 +7,7 @@ Introduces an abbreviation within the goal statement. \DESCRIBE When applied to the goal {(asl, w)}, the tactic {Q.PAT_ABBREV_TAC q} parses the -quotation {q} in the context of the goal, producing a equality term {v = p}. +quotation {q} in the context of the goal, producing an equality term {v = p}. The tactic then uses {HolKernel.find_term} to search for a sub-term of {w} that {p} matches against. If such a sub-term {t} is found then all occurrences of {t} (in {asl} and {w}) will be replaced by {v} and an assumption diff --git a/help/Docfiles/Q.REFINE_EXISTS_TAC.doc b/help/Docfiles/Q.REFINE_EXISTS_TAC.doc index 5a62d0522e..79da3dfb3b 100644 --- a/help/Docfiles/Q.REFINE_EXISTS_TAC.doc +++ b/help/Docfiles/Q.REFINE_EXISTS_TAC.doc @@ -44,7 +44,7 @@ existentially quantified in the new goal: \USES -{Q.REFINE_EXISTS_TAC} is useful if it is clear that a existential goal +{Q.REFINE_EXISTS_TAC} is useful if it is clear that an existential goal will be solved by a term of particular form, while it is not yet clear precisely what term this will be. Further proof activity should be able to exploit the additional structure that has appeared in the diff --git a/help/Docfiles/boolSyntax.dest_exists.doc b/help/Docfiles/boolSyntax.dest_exists.doc index 66d8805479..e275bf2dc7 100644 --- a/help/Docfiles/boolSyntax.dest_exists.doc +++ b/help/Docfiles/boolSyntax.dest_exists.doc @@ -3,13 +3,13 @@ \TYPE {dest_exists : term -> term * term} \SYNOPSIS -Breaks apart a existentially quantified term into quantified variable and body. +Breaks apart an existentially quantified term into quantified variable and body. \DESCRIBE If {M} has the form {?x. t}, then {dest_exists M} returns {(x,t)}. \FAILURE -Fails if {M} is not a existential quantification. +Fails if {M} is not an existential quantification. \SEEALSO boolSyntax.mk_exists, boolSyntax.is_exists, boolSyntax.strip_exists. diff --git a/help/Docfiles/bossLib.Hol_defn.doc b/help/Docfiles/bossLib.Hol_defn.doc index 11ae1b7320..49f51d85be 100644 --- a/help/Docfiles/bossLib.Hol_defn.doc +++ b/help/Docfiles/bossLib.Hol_defn.doc @@ -205,7 +205,7 @@ function. For example, suppose we define a higher-order function {SIGMA} for summing the results of a function in a list. We then use {SIGMA} in the definition of a function for summing the results of a function -in a arbitrarily (finitely) branching tree. +in an arbitrarily (finitely) branching tree. { - Define `(SIGMA f [] = 0) /\ (SIGMA f (h::t) = f h + SIGMA f t)`; diff --git a/help/Docfiles/simpLib.SSFRAG.doc b/help/Docfiles/simpLib.SSFRAG.doc index a74166f601..bd09f1cafc 100644 --- a/help/Docfiles/simpLib.SSFRAG.doc +++ b/help/Docfiles/simpLib.SSFRAG.doc @@ -55,7 +55,7 @@ proceeds, producing {Q'}. Another example is a rule for conjunction: |- (P ==> (Q = Q')) ==> (Q' ==> (P = P')) ==> ((P /\ Q) = (P' /\ Q')) } Here {P} is assumed while {Q} is simplified to {Q'}. Then, -{Q'} is assumed while {P} is simplified to {P'}. If a antecedent +{Q'} is assumed while {P} is simplified to {P'}. If an antecedent doesn't involve the relation in question (here, equality) then it is treated as a side-condition, and the simplifier will be recursively invoked to try and solve it. From 54146e69b9475379a08eaaa31f2a564c8b3da89b Mon Sep 17 00:00:00 2001 From: Piotr Trojanek Date: Thu, 12 Mar 2015 22:03:19 +0000 Subject: [PATCH 231/718] help: minor fixes in some .doc files --- help/Docfiles/Q.FIND_CASE_TAC.doc | 2 +- help/Docfiles/Q.MATCH_ABBREV_TAC.doc | 2 +- help/Docfiles/Tactic.HO_MATCH_MP_TAC.doc | 2 +- help/Docfiles/Tactical.FIRST_ASSUM.doc | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/help/Docfiles/Q.FIND_CASE_TAC.doc b/help/Docfiles/Q.FIND_CASE_TAC.doc index 375de5a14f..d679dc1b60 100644 --- a/help/Docfiles/Q.FIND_CASE_TAC.doc +++ b/help/Docfiles/Q.FIND_CASE_TAC.doc @@ -4,7 +4,7 @@ \SYNOPSIS Finds an instance of a pattern in a goal, and renames to use names -from the pattern +from the pattern. \KEYWORDS diff --git a/help/Docfiles/Q.MATCH_ABBREV_TAC.doc b/help/Docfiles/Q.MATCH_ABBREV_TAC.doc index ec10991a76..1b14de8ceb 100644 --- a/help/Docfiles/Q.MATCH_ABBREV_TAC.doc +++ b/help/Docfiles/Q.MATCH_ABBREV_TAC.doc @@ -15,7 +15,7 @@ acquire instantiations. For each variable {v} in the pattern that has not been treated as a local constant, there will be an instantiation term {t}, such that the -substitution {pattern[v1 |-> t1, v2 |-> t2, ...]} produces {w}. The +substitution pattern {[v1 |-> t1, v2 |-> t2, ...]} produces {w}. The effect of the tactic is to then perform abbreviations in the goal, replacing each {t} with the corresponding {v}, and adding assumptions of the form {Abbrev(v = t)} to the goal. diff --git a/help/Docfiles/Tactic.HO_MATCH_MP_TAC.doc b/help/Docfiles/Tactic.HO_MATCH_MP_TAC.doc index 6c4fa2aa0a..2a2f499a26 100644 --- a/help/Docfiles/Tactic.HO_MATCH_MP_TAC.doc +++ b/help/Docfiles/Tactic.HO_MATCH_MP_TAC.doc @@ -19,7 +19,7 @@ instance of {s}. Any variables free in {s} but not in {t} will be existentially quantified in the resulting subgoal: { A ?- t' - ====================== MATCH_MP_TAC (A' |- !x1...xn. s ==> t) + ====================== HO_MATCH_MP_TAC (A' |- !x1...xn. s ==> t) A ?- ?z1...zp. s' } where {z1}, ..., {zp} are (type instances of) those variables among diff --git a/help/Docfiles/Tactical.FIRST_ASSUM.doc b/help/Docfiles/Tactical.FIRST_ASSUM.doc index e5f5b5094f..4b8b9b9909 100644 --- a/help/Docfiles/Tactical.FIRST_ASSUM.doc +++ b/help/Docfiles/Tactical.FIRST_ASSUM.doc @@ -26,7 +26,7 @@ applied to the goal. \EXAMPLE The tactic { - FIRST_ASSUM (\asm. CONTR_TAC asm ORELSE ACCEPT_TAC asm) + FIRST_ASSUM (fn asm => CONTR_TAC asm ORELSE ACCEPT_TAC asm) } searches the assumptions for either a contradiction or the desired conclusion. The tactic From b25e78fc74628eee424fa6cb4ec1991481773d6a Mon Sep 17 00:00:00 2001 From: Thomas Tuerk Date: Mon, 16 Mar 2015 00:59:01 +0100 Subject: [PATCH 232/718] more work on deep_matches example improve case2pmatch by implementing various post-processing rules that lead to much smaller results. There is a an extra parameter now for turning these optimisations on and off. Moreover some work on automatically replacing vars with wildcards. --- examples/deep_matches/deepMatchesExamples.sml | 32 +++-- examples/deep_matches/deepMatchesLib.sig | 10 +- examples/deep_matches/deepMatchesLib.sml | 120 ++++++++++++++++-- examples/deep_matches/deepMatchesScript.sml | 24 ++++ examples/deep_matches/deepMatchesSyntax.sig | 14 ++ examples/deep_matches/deepMatchesSyntax.sml | 75 ++++++++++- 6 files changed, 253 insertions(+), 22 deletions(-) diff --git a/examples/deep_matches/deepMatchesExamples.sml b/examples/deep_matches/deepMatchesExamples.sml index e4c8b29793..5ac9efe0d0 100644 --- a/examples/deep_matches/deepMatchesExamples.sml +++ b/examples/deep_matches/deepMatchesExamples.sml @@ -12,17 +12,19 @@ val _ = Globals.priming := SOME "_" (* Introducing case expressions *) val t = ``case x of (NONE, []) => 0`` -val t' = case2pmatch t +val t' = ``CASE x OF [ ||. (NONE, []) ~> 0 ]`` +val t'' = case2pmatch true t +val t''' = case2pmatch false t val thm_t = PMATCH_INTRO_CONV t (* check that SIMP works *) -val thm_t' = PMATCH_REMOVE_ARB_CONV t' -val thm_t' = PMATCH_SIMP_CONV t' +val thm_t' = PMATCH_REMOVE_ARB_CONV t''' +val thm_t' = PMATCH_SIMP_CONV t''' val t2' = rhs (concl thm_t') (* and turn it back *) -val t'' = pmatch2case t' -val thm_t'' = PMATCH_ELIM_CONV t' +val t'''' = pmatch2case t''' +val thm_t'' = PMATCH_ELIM_CONV t''' val thm_t2'' = PMATCH_ELIM_CONV t2' @@ -32,12 +34,9 @@ val t = ``case x of | (SOME 2, []) => 2 | (SOME 3, (x :: xs)) => 3 + x | (SOME _, (x :: xs)) => x`` -val t' = case2pmatch t +val t' = case2pmatch true t val thm_t = PMATCH_INTRO_CONV t -val thm_t' = PMATCH_REMOVE_ARB_CONV t' -val thm_t' = PMATCH_SIMP_CONV t' - (* Playing around with some examples *) val example1 = `` @@ -220,6 +219,14 @@ val balance_black_dectree_def' = SIMP_RULE (std_ss++PMATCH_CASE_SPLIT_ss ()) [] balance_black_def +val t = rhs (snd (strip_forall (concl balance_black_def))) + +val t_comp = PmatchHeuristics.with_heuristic + PmatchHeuristics.pheu_last_col + pmatch2case t + +val t2 = case2pmatch true t_comp + open stringTheory val string_match_def = Define `string_match s x = CASE (s, x) OF [ @@ -244,6 +251,13 @@ val dummy_bool_tm = ||. (_, _, _) ~> 0 ]`` +val dummy_bool_def = Define `dummy_bool _ v0 a b c _ _ = + CASE (a,b,c) OF [ + ||. (_, 0, _) ~> 1; + ||. (0, _, 0) ~> 1; + ||. (_, _, _) ~> v0 + ]` + (* try to compile to a tree inside the logic *) val dummy_bool_eq1 = PMATCH_CASE_SPLIT_CONV_HEU colHeu_first_col dummy_bool_tm diff --git a/examples/deep_matches/deepMatchesLib.sig b/examples/deep_matches/deepMatchesLib.sig index 886e04c836..2aa73275f5 100644 --- a/examples/deep_matches/deepMatchesLib.sig +++ b/examples/deep_matches/deepMatchesLib.sig @@ -28,10 +28,18 @@ sig (* case and pmatch *) (********************************) - val case2pmatch : term -> term + (* without proof convert a case to a pmatch expression. + If the flag is set, optimise the result by + introducing wildcards reordering rows ... *) + val case2pmatch : bool -> term -> term + + (* convert a pmatch expression to a case expression. + Fails, if the pmatch expression uses guards or + non-constructor patterns. *) val pmatch2case : term -> term val PMATCH_INTRO_CONV : conv + val PMATCH_INTRO_CONV_NO_OPTIMISE : conv val PMATCH_ELIM_CONV : conv diff --git a/examples/deep_matches/deepMatchesLib.sml b/examples/deep_matches/deepMatchesLib.sml index 644ecc6ba7..876a0ebeb9 100644 --- a/examples/deep_matches/deepMatchesLib.sml +++ b/examples/deep_matches/deepMatchesLib.sml @@ -218,14 +218,52 @@ end fun dest_case_fun t = dest_case_fun_aux1 t handle HOL_ERR _ => dest_case_fun_aux2 t -fun case2pmatch_aux x t = let +(* try to collapse rows by introducing a catchall at end*) +fun dest_case_fun_collapse (a, ps) = let + + (* find all possible catch-all clauses *) + fun check_collapsable (p, rh) = let + val p_vs = FVL [p] empty_tmset + val rh' = if HOLset.isEmpty p_vs then rh else + Term.subst [p |-> a] rh + val ok = HOLset.isEmpty (HOLset.intersection (FVL [rh'] empty_tmset, p_vs)) + in + if ok then SOME rh' else NONE + end + + val catch_all_cands = List.foldl (fn (prh, cs) => + case check_collapsable prh of + NONE => cs + | SOME rh => rh::cs) [] ps + + (* really collapse *) + fun is_not_cought ca (p, rh) = + not (aconv rh (Term.subst [a |-> p] ca)) + + val all_collapse_opts = List.map (fn ca => (ca, filter (is_not_cought ca) ps)) catch_all_cands + + val all_collapse_opts_sorted = sort (fn (_, l1) => fn (_, l2) => List.length l1 < List.length l2) all_collapse_opts + + (* could we collapse 2 cases? *) +in + if (List.null all_collapse_opts) then (a, ps) else + let + val (ca', ps') = hd all_collapse_opts_sorted + in if (List.length ps' + 1 < List.length ps) then + (a, (ps' @ [(a, ca')])) + else (a, ps) + end +end + +fun case2pmatch_aux optimise x t = let val (a, ps) = dest_case_fun t + val (a, ps) = if optimise then (dest_case_fun_collapse (a, ps)) else (a, ps) fun process_arg (p, rh) = let val x' = subst [a |-> p] x in (* recursive call *) - case case2pmatch_aux x' rh of + case case2pmatch_aux optimise x' rh of NONE => [(x', rh)] | SOME resl => resl end @@ -235,8 +273,59 @@ in SOME ps end handle HOL_ERR _ => NONE; +fun case2pmatch_remove_unnessary_rows ps = let + fun mk_distinct_rows (p1, _) (p2, rh2) = let + val avoid = free_vars p1 + val (s, _) = List.foldl (fn (v, (s, av)) => + let val v' = variant av v in + ((v |-> v')::s, v'::av) end) ([], avoid) (free_vars p2) + val p2' = Term.subst s p2 + val rh2' = Term.subst s rh2 + in + (p2', rh2') + end + + fun pats_unify (p1, _) (p2, _) = ( + (Unify.simp_unify_terms [] p1 p2; true) handle HOL_ERR _ => false + ) + + fun row_subsumed (p1, rh1) (p2, rh2) = let + val (s, _) = match_term p2 p1 + val rh2' = Term.subst s rh2 + in aconv rh2' rh1 end handle HOL_ERR _ => false + + fun row_is_needed r1 rs = case rs of + [] => true + | r2::rs' => let + val r2' = mk_distinct_rows r1 r2 + in + if pats_unify r1 r2' then ( + not (row_subsumed r1 r2') + ) else row_is_needed r1 rs' + end + + fun check_rows acc rs = case rs of + [] => List.rev acc + | [_] => (* drop last one *) List.rev acc + | r::rs' => check_rows (if row_is_needed r rs' then r::acc else acc) + rs' + + val ps' = case ps of + [] => [] + | (p, rh)::_ => (ps @ [(genvar (type_of p), mk_arb (type_of rh))]) + +in + check_rows [] ps' +end + +(* +val (p1, rh1) = el 5 ps +val (p2, rh2) = mk_distinct_rows (p1, rh1) (el 6 ps) +ps +*) + (* convert a case-term into a PMATCH-term, without any proofs *) -fun case2pmatch t = let +fun case2pmatch opt t = let val (f, args) = strip_comb t val _ = if (List.null args) then failwith "not a case-split" else () @@ -245,30 +334,39 @@ fun case2pmatch t = let val v = genvar (type_of p) val t0 = if is_literal_case t then list_mk_comb (f, patterns @ [v]) else list_mk_comb (f, v::patterns) - val ps = case case2pmatch_aux v t0 of + val ps = case case2pmatch_aux opt v t0 of NONE => failwith "not a case-split" | SOME ps => ps + val ps = if opt then case2pmatch_remove_unnessary_rows ps else ps + fun process_pattern (p, rh) = let val fvs = List.rev (free_vars p) in - mk_PMATCH_ROW_PABS fvs (p, T, rh) + if opt then + snd (mk_PMATCH_ROW_PABS_WILDCARDS fvs (p, T, rh)) + else + mk_PMATCH_ROW_PABS fvs (p, T, rh) end val rows = List.map process_pattern ps val rows_tm = listSyntax.mk_list (rows, type_of (hd rows)) - val rows_tm_p = subst [v |-> p] rows_tm + val rows_tm_p = Term.subst [v |-> p] rows_tm in mk_PMATCH p rows_tm_p end +val COND_CONG_STOP = prove (`` + (c = c') ==> ((if c then x else y) = (if c' then x else y))``, +SIMP_TAC std_ss []) + fun case_pmatch_eq_prove t t' = let val tm = mk_eq (t, t') (* very slow, simple approach. Just brute force. TODO: change implementation to get more runtime-speed *) val my_tac = ( - CASE_TAC THEN + BasicProvers.PURE_CASE_TAC THEN FULL_SIMP_TAC (rc_ss []) [PMATCH_EVAL, PMATCH_ROW_COND_def, PMATCH_INCOMPLETE_def] ) @@ -279,8 +377,10 @@ end handle HOL_ERR _ => raise UNCHANGED fun PMATCH_INTRO_CONV t = - case_pmatch_eq_prove t (case2pmatch t) + case_pmatch_eq_prove t (case2pmatch true t) +fun PMATCH_INTRO_CONV_NO_OPTIMISE t = + case_pmatch_eq_prove t (case2pmatch false t) (* convert a case-term into a PMATCH-term, without any proofs *) fun pmatch2case t = let @@ -1132,9 +1232,11 @@ REPEATC (FIRST_CONV [ CHANGED_CONV (PMATCH_REMOVE_ARB_CONV_GENCALL rc_arg), CHANGED_CONV (PMATCH_SIMP_COLS_CONV_GENCALL rc_arg), CHANGED_CONV (PMATCH_EXPAND_COLS_CONV), - CHANGED_CONV PMATCH_FORCE_SAME_VARS_CONV + CHANGED_CONV PMATCH_FORCE_SAME_VARS_CONV, + CHANGED_CONV PMATCH_INTRO_WILDCARDS_CONV ]); + fun PMATCH_SIMP_CONV_GENCALL rc_arg t = if (is_PMATCH t) then PMATCH_SIMP_CONV_GENCALL_AUX rc_arg t else raise UNCHANGED diff --git a/examples/deep_matches/deepMatchesScript.sml b/examples/deep_matches/deepMatchesScript.sml index 367a2f1268..b778628992 100644 --- a/examples/deep_matches/deepMatchesScript.sml +++ b/examples/deep_matches/deepMatchesScript.sml @@ -747,6 +747,30 @@ FULL_SIMP_TAC std_ss [PMATCH_ROW_COND_def] THEN METIS_TAC[]); +(***************************************************) +(* ELIMINATE GUARDS *) +(***************************************************) + +val GUARDS_ELIM_THM = store_thm ("GUARDS_ELIM_THM", +``!v rs1 rs2 p g r. + (!x1 x2. (p x1 = p x2) ==> (x1 = x2)) ==> ( + PMATCH v (rs1++(PMATCH_ROW p g r)::rs2) = + PMATCH v (rs1++(PMATCH_ROW p (\x. T) (\x. + if g x then r x else + PMATCH v rs2))::rs2))``, + +SIMP_TAC std_ss [PMATCH_APPEND_SEM] THEN +Cases_on `?r. MEM r rs1 /\ IS_SOME (r v)` THEN ( + ASM_REWRITE_TAC[] +) THEN +REPEAT STRIP_TAC THEN +SIMP_TAC std_ss [PMATCH_EVAL, PMATCH_ROW_COND_def] THEN +Tactical.REVERSE (Cases_on `?x. p x = v`) THEN ( + FULL_SIMP_TAC std_ss [] +) THEN +`!x'. (p x' = v) <=> (x' = x)` by METIS_TAC[] THEN +ASM_SIMP_TAC (std_ss++boolSimps.CONJ_ss) []); + (***************************************************) (* THEOREMS ABOUT FLATTENING *) diff --git a/examples/deep_matches/deepMatchesSyntax.sig b/examples/deep_matches/deepMatchesSyntax.sig index 7ef8c05b77..ff6dff0a27 100644 --- a/examples/deep_matches/deepMatchesSyntax.sig +++ b/examples/deep_matches/deepMatchesSyntax.sig @@ -33,6 +33,13 @@ sig ``PMATCH_ROW (\vars. p) (\vars. g) (\vars. rh)``. *) val mk_PMATCH_ROW_PABS : term list -> term * term * term -> term + (* a wrapper for [mk_PMATCH_ROW_PABS] automatically renames + the used variables to mark them as wildcards. Moreover + it removes unused vars. + It returns the constructed term with a flag of whether + the result differs from a naive call of [mk_PMATCH_ROW_PABS]. *) + val mk_PMATCH_ROW_PABS_WILDCARDS : term list -> term * term * term -> (bool * term) + (* dest_PMATCH_ROW_ABS ``PMATCH_ROW (\(x,y). p x y) (\(x,y). g x y) (\(x,y). r x y)`` returns (``(x,y)``, ``p x y``, ``g x y``, ``r x y``). @@ -64,6 +71,13 @@ sig val PMATCH_ROW_FORCE_SAME_VARS_CONV : conv val PMATCH_FORCE_SAME_VARS_CONV : conv + (* [PMATCH_ROW_INTRO_WILDCARDS_CONV] renames the + abstracted variables for the pattern, guard and right hand side + where appropriate to start with '_'. This is printed + as a wildcard. *) + val PMATCH_ROW_INTRO_WILDCARDS_CONV : conv + val PMATCH_INTRO_WILDCARDS_CONV : conv + (******************) (* PMATCH *) (******************) diff --git a/examples/deep_matches/deepMatchesSyntax.sml b/examples/deep_matches/deepMatchesSyntax.sml index c622eb0df6..dbcc0513f7 100644 --- a/examples/deep_matches/deepMatchesSyntax.sml +++ b/examples/deep_matches/deepMatchesSyntax.sml @@ -32,6 +32,25 @@ in String.sub(s, 0) = #"_" end handle HOL_ERR _ => false +fun mk_wildcard_gen avoid = let + val c = ref 0 + val avoidL = List.map (fst o dest_var) avoid + fun next_name () = let + val vn = "_" ^ (int_to_string (!c)) + val _ = c := !c + 1 + val ok = not (mem vn avoidL) + in + if ok then vn else next_name () + end +in + fn ty => mk_var (next_name (), ty) +end + +fun list_CONV c t = + if not (listSyntax.is_cons t) then raise UNCHANGED else ( + (RATOR_CONV (RAND_CONV c) THENC + RAND_CONV (list_CONV c)) t) + (***********************************************) (* Terms *) @@ -108,6 +127,33 @@ fun mk_PMATCH_ROW_PABS vars (p_t, g_t, r_t) = let mk_PMATCH_ROW (mk_pabs p_t, mk_pabs g_t, mk_pabs r_t) end + +fun mk_PMATCH_ROW_PABS_WILDCARDS vars (p_t, g_t, r_t) = let + val gr_s = FVL [g_t, r_t] empty_tmset + val p_s = FVL [p_t] empty_tmset + + val mk_wc = mk_wildcard_gen (HOLset.listItems + (HOLset.union (gr_s, p_s))) + + fun apply (v, (vars', subst)) = ( + if (not (HOLset.member (gr_s, v)) andalso + not (varname_starts_with_uscore v)) then let + val v' = mk_wc (type_of v) + in + (v'::vars', (v |-> v')::subst) + end else + (v::vars', subst) + ) + + val (vars'_rev, subst) = List.foldl apply ([], []) vars + val vars' = List.rev vars'_rev + val p_t' = Term.subst subst p_t + val use_wc = not (List.null subst) + in + (use_wc, mk_PMATCH_ROW_PABS vars' (p_t', g_t, r_t)) + end + + fun dest_PMATCH_ROW_ABS row = let val (p_t, g_t, r_t) = dest_PMATCH_ROW row @@ -129,12 +175,15 @@ in (p_vars', subst sub p_body, subst sub g_body, subst sub r_body) end; +val K_elim = prove (``K x = (\y. x)``, SIMP_TAC std_ss [ + combinTheory.K_DEF]) fun PMATCH_ROW_PABS_ELIM_CONV row = let val (p, _, _) = dest_PMATCH_ROW row val (vars, _) = pairSyntax.dest_pabs p - val c = TRY_CONV pairTools.PABS_ELIM_CONV + val c = TRY_CONV (REWR_CONV K_elim) THENC (TRY_CONV pairTools.PABS_ELIM_CONV) + val thm = ((RAND_CONV c) THENC (RATOR_CONV (RAND_CONV c)) THENC (RATOR_CONV (RATOR_CONV (RAND_CONV c)))) row @@ -159,13 +208,25 @@ end; fun PMATCH_ROW_FORCE_SAME_VARS_CONV row = let val _ = if not (is_PMATCH_ROW row) then raise UNCHANGED else () val _ = if can dest_PMATCH_ROW_ABS row then raise UNCHANGED else () - val (vars, thm0) = PMATCH_ROW_PABS_ELIM_CONV row val thm1 = PMATCH_ROW_PABS_INTRO_CONV vars (rhs (concl thm0)) in TRANS thm0 thm1 end handle HOL_ERR _ => raise UNCHANGED +val row = `` PMATCH_ROW (\(v12,v16,v17). v12::v16::v17) (\(v12,v16,v17). T) + (\(v12,v16,v17). 3) +`` + +fun PMATCH_ROW_INTRO_WILDCARDS_CONV row = let + val (vars_tm, p_t, g_t, r_t) = dest_PMATCH_ROW_ABS row + val vars = pairSyntax.strip_pair vars_tm + val (ch, row') = mk_PMATCH_ROW_PABS_WILDCARDS vars (p_t, g_t, r_t) + val _ = if ch then () else raise UNCHANGED +in + ALPHA row row' +end handle HOL_ERR _ => raise UNCHANGED + (* val row = `` PMATCH_ROW (\ (y,z). (SOME y,SUC z,[1; 2])) @@ -245,9 +306,17 @@ end handle Empty => failwith "dest_PMATCH_COLS" fun PMATCH_FORCE_SAME_VARS_CONV t = let val _ = if not (is_PMATCH t) then raise UNCHANGED else () in - DEPTH_CONV PMATCH_ROW_FORCE_SAME_VARS_CONV t + RAND_CONV (list_CONV PMATCH_ROW_FORCE_SAME_VARS_CONV) t end +fun PMATCH_INTRO_WILDCARDS_CONV t = let + val _ = if not (is_PMATCH t) then raise UNCHANGED else () +in + RAND_CONV (list_CONV PMATCH_ROW_INTRO_WILDCARDS_CONV) t +end + + + (***********************************************) (* Pretty Printing *) (***********************************************) From 12e7d0062ec02599b202f65a51e3187b99831d12 Mon Sep 17 00:00:00 2001 From: Thomas Tuerk Date: Mon, 16 Mar 2015 22:40:38 +0100 Subject: [PATCH 233/718] deep_matches example: fix bug in parser - there was a bug in the postprocessing of PMATCH terms spotted by Ramana - added ||! as input syntax after request by Ramana --- examples/deep_matches/deepMatchesExamples.sml | 11 ++++--- examples/deep_matches/deepMatchesScript.sml | 3 ++ examples/deep_matches/deepMatchesSyntax.sml | 31 ++++++++++++++++--- 3 files changed, 36 insertions(+), 9 deletions(-) diff --git a/examples/deep_matches/deepMatchesExamples.sml b/examples/deep_matches/deepMatchesExamples.sml index 5ac9efe0d0..9df3e954a7 100644 --- a/examples/deep_matches/deepMatchesExamples.sml +++ b/examples/deep_matches/deepMatchesExamples.sml @@ -44,7 +44,8 @@ val example1 = `` ||. (NONE,_,[]) ~> 0; || x. (NONE,x,[]) when x < 10 ~> x; || x. (NONE,x,[2]) ~> x; - || (x,v18). (NONE,x,[v18]) ~> 3; + ||! (NONE,x,[v18]) ~> 3; + ||! (NONE,x,[_;_]) ~> 3; || (x,v12,v16,v17). (NONE,x,v12::v16::v17) ~> 3; || (y,x,z,zs). (SOME y,x,[z]) ~> x + 5 + z; || (y,v23,v24). (SOME y,0,v23::v24) ~> (v23 + y); @@ -58,13 +59,15 @@ val _ = pmatch2case example1 val example2 = ``PMATCH (h::t) [PMATCH_ROW (\_ . []) (\_. T) (\_. x); PMATCH_ROW (\_. [2]) (\_. T) (\_. x); - PMATCH_ROW (\v18. [v18]) (\v18. T) (\v18. 3); + PMATCH_ROW (\v18. [v18]) (\v19. T) (\v18. 3); PMATCH_ROW (\ (v12,v16,v17). (v12::v16::v17)) - (\ (v12,v16,v17). T) + (K T) (\ (v12,v16,v17). 3); PMATCH_ROW (\_. [2; 4; 3]) (\_. T) (\_. 3 + x)]`` -val _ = pmatch2case example2 +val t = rhs (concl (PMATCH_FORCE_SAME_VARS_CONV example2)) +val example2_tm = pmatch2case example2 +PMATCH_INTRO_WILDCARDS_CONV t val example3 = `` CASE (NONE,x,xs) OF [ diff --git a/examples/deep_matches/deepMatchesScript.sml b/examples/deep_matches/deepMatchesScript.sml index b778628992..7c60726542 100644 --- a/examples/deep_matches/deepMatchesScript.sml +++ b/examples/deep_matches/deepMatchesScript.sml @@ -107,6 +107,9 @@ val _ = new_constant ("PMATCH_ROW_magic_1", type_of val _ = new_constant ("PMATCH_ROW_magic_0", type_of ``\abc. PMATCH_ROW (\x:unit. FST abc) (\x. FST (SND abc)) (\x. SND (SND (abc)))``) +val _ = new_constant ("PMATCH_ROW_magic_4", type_of + ``\abc. PMATCH_ROW (\x:unit. FST abc) (\x. FST (SND abc)) (\x. SND (SND (abc)))``) + val _ = new_constant ("PMATCH_ROW_magic_2", type_of ``\(pat:'a) (g:bool) (res:'b). (pat,g,res)``) diff --git a/examples/deep_matches/deepMatchesSyntax.sml b/examples/deep_matches/deepMatchesSyntax.sml index dbcc0513f7..633e792705 100644 --- a/examples/deep_matches/deepMatchesSyntax.sml +++ b/examples/deep_matches/deepMatchesSyntax.sml @@ -458,6 +458,8 @@ val PMATCH_ROW_magic_2_tm = mk_const("PMATCH_ROW_magic_2", ``:'a -> bool -> 'b -> 'a # bool # 'b``); val PMATCH_ROW_magic_3_tm = mk_const("PMATCH_ROW_magic_3", ``:'a -> 'b -> 'a # bool # 'b``); +val PMATCH_ROW_magic_4_tm = mk_const ("PMATCH_ROW_magic_4", + ``:'a # bool # 'b -> 'a -> 'b option``); val _ = temp_add_rule{pp_elements = [TOK "~>"], fixity = Infix (NONASSOC, 3), @@ -486,6 +488,13 @@ val _ = temp_add_rule{term_name = "PMATCH_ROW_magic_0", block_style = (AroundEachPhrase, (PP.INCONSISTENT, 0))}; +val _ = temp_add_rule{term_name = "PMATCH_ROW_magic_4", + fixity = Prefix 2, + pp_elements = [TOK "||!"], + paren_style = OnlyIfNecessary, + block_style = (AroundEachPhrase, + (PP.INCONSISTENT, 0))}; + val _ = temp_add_rule{term_name = "PMATCH_magic_1", fixity = Closefix, pp_elements = [TOK "CASE", TM, TOK "OF"], @@ -514,19 +523,28 @@ fun fix_CASE tm = let in if (same_const c PMATCH_magic_1_tm) then let - val (arg_tys, base_ty) = strip_fun (type_of c) - val c' = inst [(alpha |-> hd arg_tys), (beta |-> base_ty)] PMATCH_tm; + val tys = match_type (type_of PMATCH_magic_1_tm) (type_of c) + val c' = inst tys PMATCH_tm; val args' = map (traverse fix_CASE) args in list_mk_comb (c', args') end - else if (same_const c PMATCH_ROW_magic_1_tm) orelse (same_const c PMATCH_ROW_magic_0_tm) then + else if (same_const c PMATCH_ROW_magic_1_tm) orelse (same_const c PMATCH_ROW_magic_0_tm) orelse (same_const c PMATCH_ROW_magic_4_tm) then let val args' = map (traverse fix_CASE) args - val (vars, b) = if (same_const c PMATCH_ROW_magic_1_tm) then let + val (vars, b) = + if (same_const c PMATCH_ROW_magic_1_tm) then let val (p_var, b) = dest_pabs (hd args') val vars = pairSyntax.strip_pair p_var - in (vars, b) end else ([], hd args'); + in + (vars, b) + end else if (same_const c PMATCH_ROW_magic_4_tm) then let + val b = hd args' + val vars = List.filter (not o varname_starts_with_uscore) + (free_vars_lr b) + in + (vars, b) + end else (* magic 0 *) ([], hd args'); val (b_c, b_args) = strip_comb b; val (p, g, r) = if (same_const b_c PMATCH_ROW_magic_2_tm) then (el 1 b_args, el 2 b_args, el 3 b_args) @@ -548,6 +566,9 @@ Preterm.post_process_term := I *) val old_f = !Preterm.post_process_term; val _ = (Preterm.post_process_term := (fn tm => (traverse fix_CASE (old_f tm)))); + + + end From dcbb5262131437d11aa5aeda205257a10bd9f7bc Mon Sep 17 00:00:00 2001 From: Thomas Tuerk Date: Mon, 16 Mar 2015 22:57:21 +0100 Subject: [PATCH 234/718] deep matches example: fix unwanted behaviour of ||! variables of the guard and rhs were added to the bound vars as well. This is not intended --- examples/deep_matches/deepMatchesExamples.sml | 2 +- examples/deep_matches/deepMatchesSyntax.sml | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/examples/deep_matches/deepMatchesExamples.sml b/examples/deep_matches/deepMatchesExamples.sml index 9df3e954a7..b1d405291b 100644 --- a/examples/deep_matches/deepMatchesExamples.sml +++ b/examples/deep_matches/deepMatchesExamples.sml @@ -45,7 +45,7 @@ val example1 = `` || x. (NONE,x,[]) when x < 10 ~> x; || x. (NONE,x,[2]) ~> x; ||! (NONE,x,[v18]) ~> 3; - ||! (NONE,x,[_;_]) ~> 3; + ||! (NONE,_,[_;_]) ~> x; || (x,v12,v16,v17). (NONE,x,v12::v16::v17) ~> 3; || (y,x,z,zs). (SOME y,x,[z]) ~> x + 5 + z; || (y,v23,v24). (SOME y,0,v23::v24) ~> (v23 + y); diff --git a/examples/deep_matches/deepMatchesSyntax.sml b/examples/deep_matches/deepMatchesSyntax.sml index 633e792705..0af354c0ea 100644 --- a/examples/deep_matches/deepMatchesSyntax.sml +++ b/examples/deep_matches/deepMatchesSyntax.sml @@ -540,8 +540,9 @@ fun fix_CASE tm = let (vars, b) end else if (same_const c PMATCH_ROW_magic_4_tm) then let val b = hd args' + val (_, b_args) = strip_comb b; val vars = List.filter (not o varname_starts_with_uscore) - (free_vars_lr b) + (free_vars_lr (el 1 b_args)) in (vars, b) end else (* magic 0 *) ([], hd args'); From 226708236c10664ba5cf3088c1af8820f85f9008 Mon Sep 17 00:00:00 2001 From: Thomas Tuerk Date: Tue, 17 Mar 2015 23:56:41 +0100 Subject: [PATCH 235/718] deep_matches examples: implement eliminating double variable binds and guards --- examples/deep_matches/deepMatchesExamples.sml | 64 ++++-- examples/deep_matches/deepMatchesLib.sig | 23 +++ examples/deep_matches/deepMatchesLib.sml | 195 +++++++++++++++++- examples/deep_matches/deepMatchesScript.sml | 32 ++- examples/deep_matches/deepMatchesSyntax.sig | 3 + examples/deep_matches/deepMatchesSyntax.sml | 28 ++- 6 files changed, 313 insertions(+), 32 deletions(-) diff --git a/examples/deep_matches/deepMatchesExamples.sml b/examples/deep_matches/deepMatchesExamples.sml index b1d405291b..b140dc54f9 100644 --- a/examples/deep_matches/deepMatchesExamples.sml +++ b/examples/deep_matches/deepMatchesExamples.sml @@ -155,9 +155,9 @@ Cases_on `x=y` THEN ( val my_d_def = Define `my_d xx = CASE xx OF [ - || x. (x, []) when x > 3 ~> x; - || x. (x, []) ~> 0; - || (x, y, ys). (x, y::ys) ~> my_d (x + y, ys)]` + ||! (x, []) when x > 3 ~> x; + ||! (x, []) ~> 0; + ||! (x, y::ys) ~> my_d (x + y, ys)]` val my_d_thms = store_thm ("my_d_thms", ``(!x. x > 3 ==> (my_d (x, []) = x)) /\ @@ -191,6 +191,42 @@ val my_d_thms3 = PMATCH_TO_TOP_RULE my_d_def thm *) + +(*********************************) +(* Removing DOUBLE-binds *) +(*********************************) + +val t = + ``CASE l OF [ + ||. [] ~> 0; + ||! x::y::x::y::_ ~> x+y; + ||! x::x::x::y::_ ~> x+x+x; + ||! x::_ ~> 1 + ]`` + +val thm0 = PMATCH_REMOVE_DOUBLE_BIND_CONV t + + +(*********************************) +(* Removing Guards *) +(*********************************) + +val thm1 = PMATCH_REMOVE_GUARDS_CONV (rhs (concl thm0)) +val thm1b = SIMP_CONV (std_ss++PMATCH_REMOVE_GUARDS_ss) [] (rhs (concl thm0)) + +val t = + ``CASE (y,x,l) OF [ + || x. (SOME 0,x,[]) ~> x; + || z. (SOME 1,z,[2]) when F ~> z; + || x. (SOME 3,x,[2]) when (IS_SOME x) ~> x; + || (z,y). (y,z,[2]) when (IS_SOME y) ~> y; + || z. (SOME 1,z,[2]) when F ~> z; + || x. (SOME 3,x,[2]) when (IS_SOME x) ~> x + ]`` + +val thm0 = PMATCH_REMOVE_GUARDS_CONV t + + (*********************************) (* Compiling *) (*********************************) @@ -202,15 +238,15 @@ val _ = Datatype ` val balance_black_def = Define `balance_black a n b = CASE (a,b) OF [ - || (a,x,b,y,c,d). (Red (Red a x b) y c,d) ~> + ||! (Red (Red a x b) y c,d) ~> (Red (Black a x b) y (Black c n d)); - || (a,x,b,y,c,d). (Red a x (Red b y c),d) ~> + ||! (Red a x (Red b y c),d) ~> (Red (Black a x b) y (Black c n d)); - || (a,b,y,c,z,d). (a,Red (Red b y c) z d) ~> + ||! (a,Red (Red b y c) z d) ~> (Red (Black a n b) y (Black c z d)); - || (a,b,y,c,z,d). (a,Red b y (Red c z d)) ~> + ||! (a,Red b y (Red c z d)) ~> (Red (Black a n b) y (Black c z d)); - || other. other ~> (Black a n b) + ||! other ~> (Black a n b) ]` (* try to compile to a tree inside the logic *) @@ -317,7 +353,7 @@ val _ = pmatch_compile_db_register_constrFam cf val t = ``CASE l OF [ ||. [] ~> 0; - || x. SNOC x _ ~> x + ||! SNOC x _ ~> x ]`` val thm = PMATCH_CASE_SPLIT_CONV t @@ -450,9 +486,9 @@ ASM_SIMP_TAC std_ss [arithmeticTheory.DIV_MULT, arithmeticTheory.MOD_MULT]) val simple_card_def = Define ` simple_card s = CASE s OF [ ||. {} ~> SOME 0; - || x. {x} ~> SOME 1; - || (x, y). {x; y} ~> SOME 2; - || s. s ~> NONE + ||! {x} ~> SOME 1; + ||! {x; y} ~> SOME 2; + ||! s ~> NONE ]`; val simple_card_THM_AUX = PMATCH_TO_TOP_RULE simple_card_def; @@ -507,9 +543,9 @@ Cases_on `t'` THEN1 ( val CARD2_defn = Defn.Hol_defn "CARD2" ` CARD2 s = CASE s OF [ ||. {} ~> 0; - || (x, s'). x INSERT s' when (FINITE s' /\ ~(x IN s')) ~> + ||! x INSERT s' when (FINITE s' /\ ~(x IN s')) ~> SUC (CARD2 s'); - || s'. s' ~> 0 + ||! s' ~> 0 ]` val (CARD2_def, _) = Defn.tprove (CARD2_defn, diff --git a/examples/deep_matches/deepMatchesLib.sig b/examples/deep_matches/deepMatchesLib.sig index 2aa73275f5..b6063482e0 100644 --- a/examples/deep_matches/deepMatchesLib.sig +++ b/examples/deep_matches/deepMatchesLib.sig @@ -80,6 +80,29 @@ sig val PMATCH_EXPAND_COLS_CONV : conv + (********************************) + (* removing double variable *) + (* bindings *) + (********************************) + + val PMATCH_REMOVE_DOUBLE_BIND_CONV_GEN : ssfrag list -> conv + val PMATCH_REMOVE_DOUBLE_BIND_CONV : conv + val PMATCH_REMOVE_DOUBLE_BIND_GEN_ss : ssfrag list -> ssfrag + val PMATCH_REMOVE_DOUBLE_BIND_ss : ssfrag + + + (********************************) + (* removing GUARDS *) + (********************************) + + val PMATCH_REMOVE_GUARDS_CONV_GEN : ssfrag list -> conv + val PMATCH_REMOVE_GUARDS_CONV : conv + val PMATCH_REMOVE_GUARDS_GEN_ss : ssfrag list -> ssfrag + val PMATCH_REMOVE_GUARDS_ss : ssfrag + + + + (********************************) (* removing PMATCH-terms *) (* via lifting it to the nearest*) diff --git a/examples/deep_matches/deepMatchesLib.sml b/examples/deep_matches/deepMatchesLib.sml index 876a0ebeb9..184dac1367 100644 --- a/examples/deep_matches/deepMatchesLib.sml +++ b/examples/deep_matches/deepMatchesLib.sml @@ -433,7 +433,7 @@ fun PMATCH_ELIM_CONV t = not needed for PMATCH and can be removed. *) (* -val rc_arg = [] +val rc_arg = ([], NONE) set_trace "parse deep cases" 0 val t = convert_case ``case x of NONE => 0`` @@ -1233,7 +1233,8 @@ REPEATC (FIRST_CONV [ CHANGED_CONV (PMATCH_SIMP_COLS_CONV_GENCALL rc_arg), CHANGED_CONV (PMATCH_EXPAND_COLS_CONV), CHANGED_CONV PMATCH_FORCE_SAME_VARS_CONV, - CHANGED_CONV PMATCH_INTRO_WILDCARDS_CONV + CHANGED_CONV PMATCH_INTRO_WILDCARDS_CONV, + REWR_CONV (CONJUNCT1 PMATCH_def) ]); @@ -1251,6 +1252,196 @@ fun PMATCH_SIMP_GEN_ss ssl = val PMATCH_SIMP_ss = PMATCH_SIMP_GEN_ss [] +(***********************************************) +(* Remove double var bindings *) +(***********************************************) + +fun force_unique_vars s no_change avoid t = + case Psyntax.dest_term t of + Psyntax.VAR (_, _) => + if (mem t no_change) then (s, avoid, t) else + let + val v' = variant avoid t + val avoid' = v'::avoid + val s' = if (v' = t) then s else ((v', t)::s) + in (s', avoid', v') end + | Psyntax.CONST _ => (s, avoid, t) + | Psyntax.LAMB (v, t') => let + val (s', avoid', t'') = force_unique_vars s (v::no_change) + (v::avoid) t' + in + (s', avoid', mk_abs (v, t'')) + end + | Psyntax.COMB (t1, t2) => let + val (s', avoid', t1') = force_unique_vars s no_change avoid t1 + val (s'', avoid'', t2') = force_unique_vars s' no_change avoid' t2 + in + (s'', avoid'', mk_comb (t1', t2')) + end; + +(* +val row = ``PMATCH_ROW (\ (x,y). (x, SOME y, SOME x, SOME z, (x+z))) + (\ (x, y). P x y) (\ (x, y). f x y)`` + +val row = ``PMATCH_ROW (\ (x,y). (x, SOME y, SOME z, SOME z, (z+z))) + (\ (x, y). P x y) (\ (x, y). f x y)`` +*) + +fun PMATCH_ROW_REMOVE_DOUBLE_BIND_CONV_GENCALL rc_arg row = let + val _ = if not (is_PMATCH_ROW row) then raise UNCHANGED else () + val (p_t, g_t, r_t) = dest_PMATCH_ROW row + val (vars_tm, p_tb) = pairSyntax.dest_pabs p_t + val vars = pairSyntax.strip_pair vars_tm + + val (new_binds, _, p_tb') = force_unique_vars [] (free_vars p_t) [] p_tb + val _ = if List.null new_binds then raise UNCHANGED else () + + val vars' = vars @ (List.map fst new_binds) + val g_v = genvar (type_of g_t) + val r_v = genvar (type_of r_t) + + + val g_t' = list_mk_conj ((List.map mk_eq new_binds)@[mk_comb (g_v, vars_tm)]) + val r_t' = mk_comb (r_v, vars_tm) + + val row' = mk_PMATCH_ROW_PABS vars' (p_tb', g_t', r_t') + val row0 = mk_PMATCH_ROW (p_t, g_v, r_v) + + val thm0_tm = mk_eq (row0, row') + val thm0 = let + val thm0 = FRESH_TY_VARS_RULE PMATCH_ROW_REMOVE_DOUBLE_BINDS_THM + val g_tm = pairSyntax.mk_pabs (vars_tm, + subst (List.map (fn (v, v') => (v |-> v')) new_binds) + (pairSyntax.list_mk_pair vars')) + val thm1 = ISPEC g_tm thm0 + val thm2 = PART_MATCH rand thm1 thm0_tm + + val pre = rand (rator (concl thm2)) + val pre_thm = prove (pre, rc_tac rc_arg) + val thm3 = MP thm2 pre_thm + in + thm3 + end + + val thm1 = INST [(g_v |-> g_t), (r_v |-> r_t)] thm0 + + val thm1a_tm = mk_eq (row, lhs (concl thm1)) + val thm1a = prove (thm1a_tm, rc_tac rc_arg) + + val thm2 = TRANS thm1a thm1 + + val thm3 = CONV_RULE (RHS_CONV (DEPTH_CONV pairLib.GEN_BETA_CONV)) + thm2 +in + thm3 +end handle HOL_ERR _ => raise UNCHANGED + +fun PMATCH_REMOVE_DOUBLE_BIND_CONV_GENCALL rc_arg t = + PMATCH_ROWS_CONV (PMATCH_ROW_REMOVE_DOUBLE_BIND_CONV_GENCALL + rc_arg) t + +fun PMATCH_REMOVE_DOUBLE_BIND_CONV_GEN ssl = + PMATCH_REMOVE_DOUBLE_BIND_CONV_GENCALL (ssl, NONE) + +val PMATCH_REMOVE_DOUBLE_BIND_CONV = PMATCH_REMOVE_DOUBLE_BIND_CONV_GEN []; + +fun PMATCH_REMOVE_DOUBLE_BIND_GEN_ss ssl = + make_gen_conv_ss PMATCH_ROW_REMOVE_DOUBLE_BIND_CONV_GENCALL "PMATCH_REMOVE_DOUBLE_BIND_REDUCER" ssl + +val PMATCH_REMOVE_DOUBLE_BIND_ss = PMATCH_REMOVE_DOUBLE_BIND_GEN_ss [] + + +(***********************************************) +(* Remove a GUARD *) +(***********************************************) + +(* +val t = `` +PMATCH (y,x,l) + [PMATCH_ROW (\x. (SOME 0,x,[])) (\x. T) (\x. x); + PMATCH_ROW (\z. (SOME 1,z,[2])) (\z. F) (\z. z); + PMATCH_ROW (\x. (SOME 3,x,[2])) (\x. IS_SOME x) (\x. x); + PMATCH_ROW (\(z,y). (y,z,[2])) (\(z, y). IS_SOME y) (\(z, y). y); + PMATCH_ROW (\z. (SOME 1,z,[2])) (\z. F) (\z. z); + PMATCH_ROW (\x. (SOME 3,x,[2])) (\x. IS_SOME x) (\x. x) + ]`` + +val rc_arg = ([], NONE) +val rows = 0 +*) + + +fun PMATCH_REMOVE_GUARD_AUX rc_arg t = let + val (v, rows) = dest_PMATCH t + + fun find_row_to_split rs1 rs = case rs of + [] => raise UNCHANGED (* nothing found *) + | (r:: rs') => let + val (_, _, g, _) = dest_PMATCH_ROW_ABS r + val g_simple = ((g = T) orelse (g = F)) + in + if g_simple then + find_row_to_split (r::rs1) rs' + else let + val r_ty = type_of r + val rs1_tm = listSyntax.mk_list (List.rev rs1, r_ty) + val rs2_tm = listSyntax.mk_list (rs', r_ty) + in + (rs1_tm, r, rs2_tm) + end + end + + val (rs1, r, rs2) = find_row_to_split [] rows + + val thm = let + val thm0 = FRESH_TY_VARS_RULE GUARDS_ELIM_THM + val (p_tm, g_tm, r_tm) = dest_PMATCH_ROW r + val thm1 = ISPECL [v, rs1, rs2, p_tm, g_tm, r_tm] thm0 + + val pre = rand (rator (concl thm1)) + val pre_thm = prove (pre, rc_tac rc_arg) + val thm2 = MP thm1 pre_thm + + val t_eq_thm = prove (mk_eq (t, lhs (concl thm2)), + CONV_TAC (DEPTH_CONV listLib.APPEND_CONV) THEN + REWRITE_TAC []) + + val thm3 = TRANS t_eq_thm thm2 + in + thm3 + end + + val thm2 = CONV_RULE (RHS_CONV (RAND_CONV (RAND_CONV (RATOR_CONV (RAND_CONV PMATCH_ROW_FORCE_SAME_VARS_CONV))))) thm + + val thm3 = CONV_RULE (RHS_CONV (RAND_CONV listLib.APPEND_CONV)) thm2 + +in + thm3 +end handle HOL_ERR _ => raise UNCHANGED + + + +fun PMATCH_REMOVE_GUARDS_CONV_GENCALL rc_arg t = let + val thm0 = REPEATC (PMATCH_REMOVE_GUARD_AUX rc_arg) t + val m_ss = simpLib.merge_ss (fst rc_arg) + val c = SIMP_CONV (std_ss ++ m_ss ++ + PMATCH_SIMP_GEN_ss (fst rc_arg)) [] + val thm1 = CONV_RULE (RHS_CONV c) thm0 +in + thm1 +end handle HOL_ERR _ => raise UNCHANGED + + +fun PMATCH_REMOVE_GUARDS_CONV_GEN ssl = PMATCH_REMOVE_GUARDS_CONV_GENCALL (ssl, NONE) + +val PMATCH_REMOVE_GUARDS_CONV = PMATCH_REMOVE_GUARDS_CONV_GEN []; + +fun PMATCH_REMOVE_GUARDS_GEN_ss ssl = + make_gen_conv_ss PMATCH_REMOVE_GUARDS_CONV_GENCALL "PMATCH_REMOVE_GUARDS_REDUCER" ssl + +val PMATCH_REMOVE_GUARDS_ss = PMATCH_REMOVE_GUARDS_GEN_ss [] + + (***********************************************) (* Lifting to lowest boolean level *) (***********************************************) diff --git a/examples/deep_matches/deepMatchesScript.sml b/examples/deep_matches/deepMatchesScript.sml index 7c60726542..f75fe5782e 100644 --- a/examples/deep_matches/deepMatchesScript.sml +++ b/examples/deep_matches/deepMatchesScript.sml @@ -139,7 +139,7 @@ ASM_SIMP_TAC std_ss []) val PMATCH_CONG = store_thm ("PMATCH_CONG", -``!v v' rows rows'. ((v = v') /\ (r v' = r' v') /\ +``!v v' rows rows'. ((v = v') /\ (!x. x = v' ==> (r x = r' x)) /\ (PMATCH v' rows = PMATCH v' rows')) ==> (PMATCH v (r :: rows) = PMATCH v' (r' :: rows'))``, SIMP_TAC std_ss [PMATCH_def]) @@ -750,6 +750,35 @@ FULL_SIMP_TAC std_ss [PMATCH_ROW_COND_def] THEN METIS_TAC[]); +(***************************************************) +(* ELIMINATE DOUBLE VAR-BINDS *) +(***************************************************) + +val PMATCH_ROW_REMOVE_DOUBLE_BINDS_THM = + store_thm ("PMATCH_ROW_REMOVE_DOUBLE_BINDS_THM", +``!g p1 g1 r1 p2 g2 r2. + ((!x y. (p1 x = p1 y) ==> (x = y)) /\ + (!x. (p2 (g x) = p1 x)) /\ + (!x'. g2 x' = (?x. (x' = g x) /\ g1 x)) /\ + (!x. r2 (g x) = r1 x)) ==> + + (PMATCH_ROW p1 g1 r1 = PMATCH_ROW p2 g2 r2)``, + +SIMP_TAC (std_ss++boolSimps.CONJ_ss) [PMATCH_ROW_def, FUN_EQ_THM, + optionTheory.some_def, PMATCH_ROW_COND_def, + GSYM RIGHT_EXISTS_AND_THM] THEN +REPEAT STRIP_TAC THEN +Cases_on `?x'. (p1 x' = x) ∧ g1 x'` THEN ( + ASM_REWRITE_TAC[optionTheory.OPTION_MAP_DEF] +) THEN +SELECT_ELIM_TAC THEN ASM_REWRITE_TAC[] THEN +SELECT_ELIM_TAC THEN +REPEAT STRIP_TAC THEN ( + METIS_TAC[] +)) + + + (***************************************************) (* ELIMINATE GUARDS *) (***************************************************) @@ -775,6 +804,7 @@ Tactical.REVERSE (Cases_on `?x. p x = v`) THEN ( ASM_SIMP_TAC (std_ss++boolSimps.CONJ_ss) []); + (***************************************************) (* THEOREMS ABOUT FLATTENING *) (***************************************************) diff --git a/examples/deep_matches/deepMatchesSyntax.sig b/examples/deep_matches/deepMatchesSyntax.sig index ff6dff0a27..2c3ec02977 100644 --- a/examples/deep_matches/deepMatchesSyntax.sig +++ b/examples/deep_matches/deepMatchesSyntax.sig @@ -95,6 +95,9 @@ sig for each row. *) val dest_PMATCH_COLS : term -> (term * (term list * term) list) list + (* applies a conversion to all rows of a pmatch *) + val PMATCH_ROWS_CONV : conv -> conv + (******************) (* Pretty printer *) diff --git a/examples/deep_matches/deepMatchesSyntax.sml b/examples/deep_matches/deepMatchesSyntax.sml index 0af354c0ea..784171578d 100644 --- a/examples/deep_matches/deepMatchesSyntax.sml +++ b/examples/deep_matches/deepMatchesSyntax.sml @@ -46,11 +46,6 @@ in fn ty => mk_var (next_name (), ty) end -fun list_CONV c t = - if not (listSyntax.is_cons t) then raise UNCHANGED else ( - (RATOR_CONV (RAND_CONV c) THENC - RAND_CONV (list_CONV c)) t) - (***********************************************) (* Terms *) @@ -98,6 +93,7 @@ in ALPHA t t' end + (***********************************************) (* PMATCH_ROW *) (***********************************************) @@ -214,9 +210,6 @@ in TRANS thm0 thm1 end handle HOL_ERR _ => raise UNCHANGED -val row = `` PMATCH_ROW (\(v12,v16,v17). v12::v16::v17) (\(v12,v16,v17). T) - (\(v12,v16,v17). 3) -`` fun PMATCH_ROW_INTRO_WILDCARDS_CONV row = let val (vars_tm, p_t, g_t, r_t) = dest_PMATCH_ROW_ABS row @@ -303,18 +296,23 @@ in cols end handle Empty => failwith "dest_PMATCH_COLS" -fun PMATCH_FORCE_SAME_VARS_CONV t = let - val _ = if not (is_PMATCH t) then raise UNCHANGED else () -in - RAND_CONV (list_CONV PMATCH_ROW_FORCE_SAME_VARS_CONV) t -end +fun list_CONV c t = + if not (listSyntax.is_cons t) then raise UNCHANGED else ( + (RATOR_CONV (RAND_CONV c) THENC + RAND_CONV (list_CONV c)) t) -fun PMATCH_INTRO_WILDCARDS_CONV t = let +fun PMATCH_ROWS_CONV c t = let val _ = if not (is_PMATCH t) then raise UNCHANGED else () in - RAND_CONV (list_CONV PMATCH_ROW_INTRO_WILDCARDS_CONV) t + RAND_CONV (list_CONV c) t end +val PMATCH_FORCE_SAME_VARS_CONV = + PMATCH_ROWS_CONV PMATCH_ROW_FORCE_SAME_VARS_CONV + +val PMATCH_INTRO_WILDCARDS_CONV = + PMATCH_ROWS_CONV PMATCH_ROW_INTRO_WILDCARDS_CONV + (***********************************************) From 60449c301bc01d55d8fcaac292203b2f18f40f23 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 18 Mar 2015 11:43:23 +1100 Subject: [PATCH 236/718] Remove vacuous quantification in SUBSET_MAX_SET There was a stray universally quantified variable that didn't appear in the statement of the theorem. Also slightly simplify proof. --- src/pred_set/src/pred_setScript.sml | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/pred_set/src/pred_setScript.sml b/src/pred_set/src/pred_setScript.sml index ff66c279c8..3624462ec9 100644 --- a/src/pred_set/src/pred_setScript.sml +++ b/src/pred_set/src/pred_setScript.sml @@ -4281,9 +4281,8 @@ val SUBSET_MIN_SET = Q.store_thm val SUBSET_MAX_SET = Q.store_thm ("SUBSET_MAX_SET", - `!I J n. FINITE I /\ FINITE J /\ I SUBSET J ==> MAX_SET I <= MAX_SET J`, - CONV_TAC (RENAME_VARS_CONV ["s1", "s2"]) THEN - REPEAT GEN_TAC THEN REPEAT STRIP_TAC THEN + `!I J. FINITE I /\ FINITE J /\ I SUBSET J ==> MAX_SET I <= MAX_SET J`, + MAP_EVERY Q.X_GEN_TAC [`s1`, `s2`] THEN STRIP_TAC THEN Q.ASM_CASES_TAC `s1 = {}` THEN1 ASM_SIMP_TAC (srw_ss()) [] THEN Q.ASM_CASES_TAC `s2 = {}` THEN1 FULL_SIMP_TAC (srw_ss()) [] THEN METIS_TAC [SUBSET_DEF,MAX_SET_DEF]); From 0150c0c01600e958a8ee5d1795f4f8d08aea3c0e Mon Sep 17 00:00:00 2001 From: Thomas Tuerk Date: Wed, 18 Mar 2015 07:33:03 +0100 Subject: [PATCH 237/718] fix bug in deepMatchesScript I was not careful and checked in an experimental version of a theorem with a broken proof in 226708236c10664ba5cf3088c1af8820f85f9008. This commit restores the old form. --- examples/deep_matches/deepMatchesScript.sml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/deep_matches/deepMatchesScript.sml b/examples/deep_matches/deepMatchesScript.sml index f75fe5782e..d2ac794dba 100644 --- a/examples/deep_matches/deepMatchesScript.sml +++ b/examples/deep_matches/deepMatchesScript.sml @@ -139,7 +139,7 @@ ASM_SIMP_TAC std_ss []) val PMATCH_CONG = store_thm ("PMATCH_CONG", -``!v v' rows rows'. ((v = v') /\ (!x. x = v' ==> (r x = r' x)) /\ +``!v v' rows rows' r r'. ((v = v') /\ (r v' = r' v') /\ (PMATCH v' rows = PMATCH v' rows')) ==> (PMATCH v (r :: rows) = PMATCH v' (r' :: rows'))``, SIMP_TAC std_ss [PMATCH_def]) From 5cfd16eb28240a93a5611345d079ca9968d60f28 Mon Sep 17 00:00:00 2001 From: Thomas Tuerk Date: Thu, 19 Mar 2015 00:02:24 +0100 Subject: [PATCH 238/718] deep matches example: implement simple removal of redundant rows --- examples/deep_matches/deepMatchesLib.sig | 3 + examples/deep_matches/deepMatchesLib.sml | 111 ++++++++++++++++- examples/deep_matches/deepMatchesScript.sml | 129 +++++++++++++++++--- 3 files changed, 226 insertions(+), 17 deletions(-) diff --git a/examples/deep_matches/deepMatchesLib.sig b/examples/deep_matches/deepMatchesLib.sig index b6063482e0..276090260d 100644 --- a/examples/deep_matches/deepMatchesLib.sig +++ b/examples/deep_matches/deepMatchesLib.sig @@ -69,6 +69,9 @@ sig val PMATCH_REMOVE_ARB_CONV : conv val PMATCH_REMOVE_ARB_CONV_GEN : ssfrag list -> conv + val PMATCH_REMOVE_REDUNDANT_CONV : conv + val PMATCH_REMOVE_REDUNDANT_CONV_GEN : ssfrag list -> conv + val PMATCH_CLEANUP_PVARS_CONV : conv val PMATCH_CLEANUP_CONV : conv diff --git a/examples/deep_matches/deepMatchesLib.sml b/examples/deep_matches/deepMatchesLib.sml index 184dac1367..ba434e3d5c 100644 --- a/examples/deep_matches/deepMatchesLib.sml +++ b/examples/deep_matches/deepMatchesLib.sml @@ -28,6 +28,9 @@ fun make_gen_conv_ss c name ssl = let fun has_subterm p t = ((find_term p t; true) handle HOL_ERR _ => false) +(* like proof, but less verbose, since we expect that it might fail *) +val prove_attempt = Lib.with_flag (Feedback.emit_MESG, false) prove + (* We have a problem with conversions that loop in a fancy way. They add some pattern matching on the input variables and in the body the original term with renamed variables. The @@ -423,6 +426,111 @@ fun PMATCH_ELIM_CONV t = case_pmatch_eq_prove t (pmatch2case t) +(***********************************************) +(* removing redundant rows *) +(***********************************************) + +(* +val rc_arg = ([], NONE) + +set_trace "parse deep cases" 0 + +val t = `` + CASE l OF [ + ||. [] ~> 0; + || (x,y). x::y::x::y::_ ~> (x + y); + ||! x::x::x::x::_ when (x > 10) ~> x; + ||! x::x::x::x::x::_ ~> 9; + ||. [] ~> 1; + ||! x::x::x::y::_ ~> (x + x + x); + || x. x::_ ~> 1; + ||! x::y::z::_ ~> (x + x + x) + ]`` + +*) + +fun PMATCH_REMOVE_REDUNDANT_CONV_GENCALL_SINGLE rc_arg t = let + val (v, rows) = dest_PMATCH t + + (* get pats with fresh vars to do a quick prefiltering *) + val pats_unique = Lib.enumerate 0 (Lib.mapfilter (fn r => let + val (p, _, _) = dest_PMATCH_ROW r + val (vars_tm, pb) = pairSyntax.dest_pabs p + val vars = pairSyntax.strip_pair vars_tm + val s = List.map (fn v => (v |-> genvar (type_of v))) vars + val pb' = subst s pb + in + pb' + end) rows) + + (* get all pairs, first component always appears before second *) + val candidates = let + fun aux acc l = case l of + [] => acc + | (x::xs) => aux ((List.map (fn y => (x, y)) xs) @ acc) xs + in + aux [] pats_unique + end + + (* quick filter on matching *) + val candidates_match = let + fun does_match ((_, p1), (_, p2)) = + can (match_term p1) p2 + in + List.filter does_match candidates + end + + (* filtering finished, now try it for real *) + val cands = List.map (fn ((p1, _), (p2, _)) => (p1, p2)) candidates_match + (* val (r_no1, r_no2) = el 1 cands *) + fun try_pair (r_no1, r_no2) = let + val tm0 = let + val rows1 = List.take (rows, r_no1) + val r1 = List.nth (rows, r_no1) + val rows_rest = List.drop (rows, r_no1+1) + val rows2 = List.take (rows_rest, (r_no2 - r_no1 - 1)) + val r2 = List.nth (rows, r_no2) + val rows3 = List.drop (rows_rest, r_no2 - r_no1) + + val rows1_tm = listSyntax.mk_list (rows1, type_of r1) + val rows2_tm = listSyntax.mk_list (rows2, type_of r1) + val r1rows2_tm = listSyntax.mk_cons (r1, rows2_tm) + val rows3_tm = listSyntax.mk_list (rows3, type_of r1) + val r2rows3_tm = listSyntax.mk_cons (r2, rows3_tm) + + val arg = listSyntax.list_mk_append [rows1_tm, r1rows2_tm, r2rows3_tm] + in + mk_PMATCH v arg + end + + val thm0 = FRESH_TY_VARS_RULE PMATCH_ROWS_DROP_REDUNDANT_PMATCH_ROWS + val thm1 = PART_MATCH (lhs o rand) thm0 tm0 + + val pre = rand (rator (concl thm1)) + val pre_thm = prove_attempt (pre, rc_tac rc_arg) + val thm2 = MP thm1 pre_thm + + val t_eq_thm = prove (mk_eq (t, lhs (concl thm2)), + CONV_TAC (DEPTH_CONV listLib.APPEND_CONV) THEN + rc_tac rc_arg) + + val thm3 = TRANS t_eq_thm thm2 + val c = RATOR_CONV (RAND_CONV listLib.APPEND_CONV) THENC + listLib.APPEND_CONV + val thm4 = CONV_RULE (RHS_CONV (RAND_CONV + c)) thm3 + in + thm4 + end +in + Lib.tryfind try_pair ((2, 3)::cands) +end handle HOL_ERR _ => raise UNCHANGED + +fun PMATCH_REMOVE_REDUNDANT_CONV_GENCALL rc_arg = REPEATC (PMATCH_REMOVE_REDUNDANT_CONV_GENCALL_SINGLE rc_arg) +fun PMATCH_REMOVE_REDUNDANT_CONV_GEN ssl = PMATCH_REMOVE_REDUNDANT_CONV_GENCALL (ssl, NONE) +val PMATCH_REMOVE_REDUNDANT_CONV = PMATCH_REMOVE_REDUNDANT_CONV_GEN [] + + (***********************************************) (* removing ARB rows *) (***********************************************) @@ -1229,6 +1337,7 @@ fun PMATCH_SIMP_CONV_GENCALL_AUX rc_arg = REPEATC (FIRST_CONV [ CHANGED_CONV (PMATCH_CLEANUP_PVARS_CONV), CHANGED_CONV (PMATCH_CLEANUP_CONV_GENCALL rc_arg), + CHANGED_CONV (PMATCH_REMOVE_REDUNDANT_CONV_GENCALL rc_arg), CHANGED_CONV (PMATCH_REMOVE_ARB_CONV_GENCALL rc_arg), CHANGED_CONV (PMATCH_SIMP_COLS_CONV_GENCALL rc_arg), CHANGED_CONV (PMATCH_EXPAND_COLS_CONV), @@ -1482,7 +1591,7 @@ in val thm00 = FRESH_TY_VARS_RULE PMATCH_PRED_UNROLL_CONS val thm01 = ISPECL [p_tm, v, pt, gt, rh, rows'_tm] thm00 val pre = fst (dest_imp (concl thm01)) - val pre_thm = Lib.with_flag (Feedback.emit_MESG, false) prove (pre, rc_tac rc_arg) + val pre_thm = prove_attempt (pre, rc_tac rc_arg) in (MP thm01 pre_thm, true) end handle HOL_ERR _ => let diff --git a/examples/deep_matches/deepMatchesScript.sml b/examples/deep_matches/deepMatchesScript.sml index d2ac794dba..46af27be24 100644 --- a/examples/deep_matches/deepMatchesScript.sml +++ b/examples/deep_matches/deepMatchesScript.sml @@ -117,7 +117,7 @@ val _ = new_constant ("PMATCH_ROW_magic_3", type_of ``\(pat:'a) (res:'b). (pat,T,res)``) (***************************************************) -(* Congruences *) +(* Congruences for termination *) (***************************************************) val PMATCH_ROW_CONG = store_thm ("PMATCH_ROW_CONG", @@ -610,6 +610,108 @@ MATCH_MP_TAC PMATCH_ROWS_DROP_REDUNDANT_TRIVIAL_SOUNDNESS_EQUIV THEN ASM_REWRITE_TAC[]) +val PMATCH_ROWS_DROP_REDUNDANT = store_thm ( + "PMATCH_ROWS_DROP_REDUNDANT", +``!r1 r2 rows1 rows2 rows3 v. + (IS_SOME (r2 v) ==> IS_SOME (r1 v)) ==> + (PMATCH v (rows1 ++ (r1 :: rows2) ++ (r2 :: rows3)) = + PMATCH v (rows1 ++ (r1 :: rows2) ++ rows3))``, + +REPEAT STRIP_TAC THEN +SIMP_TAC (list_ss++boolSimps.CONJ_ss) [PMATCH_APPEND_SEM, RIGHT_AND_OVER_OR, EXISTS_OR_THM] THEN + +Cases_on `?r. MEM r rows1 ∧ IS_SOME (r v)` THEN ( + ASM_REWRITE_TAC [] +) THEN +Cases_on `IS_SOME (r1 v)` THEN ASM_REWRITE_TAC[] THEN +Cases_on `?r. MEM r rows2 ∧ IS_SOME (r v)` THEN ( + ASM_REWRITE_TAC [] +) THEN +FULL_SIMP_TAC std_ss [PMATCH_def]); + + +val PMATCH_ROWS_DROP_REDUNDANT_PMATCH_ROWS = store_thm ( + "PMATCH_ROWS_DROP_REDUNDANT_PMATCH_ROWS", +``!p g r p' g' r' rows1 rows2 rows3 v. + (!x'. (v = p' x') /\ (g' x') ==> (?x. (p' x' = p x) /\ (g x))) ==> + (PMATCH v (rows1 ++ (PMATCH_ROW p g r :: rows2) ++ (PMATCH_ROW p' g' r' :: rows3)) = + PMATCH v (rows1 ++ (PMATCH_ROW p g r :: rows2) ++ rows3))``, + +REPEAT STRIP_TAC THEN +MATCH_MP_TAC PMATCH_ROWS_DROP_REDUNDANT THEN +SIMP_TAC std_ss [PMATCH_ROW_def, optionTheory.some_def, + PMATCH_ROW_COND_def, IS_SOME_OPTION_MAP] THEN +Cases_on `?x'. (p' x' = v) ∧ g' x'` THEN ( + ASM_SIMP_TAC std_ss [] +) THEN +METIS_TAC[IS_SOME_DEF]); + +(* Some rows are not redundant in the classical sense, but can + safely be dropped nevertheless. A redundant row never matches, + because it is shaddowed by a previous row. One can also also + drop rows, if a later row matches if they match and return the + same value. I will call such rows subsumed. *) +val PMATCH_ROWS_DROP_SUBSUMED = store_thm ( + "PMATCH_ROWS_DROP_SUBSUMED", +``!r1 r2 rows1 rows2 rows3 v. + ((!x. (r1 v = SOME x) ==> (r2 v = SOME x)) /\ + (IS_SOME (r1 v) ==> EVERY (\row. (row v = NONE)) rows2)) ==> + (PMATCH v (rows1 ++ (r1 :: rows2) ++ (r2 :: rows3)) = + PMATCH v (rows1 ++ rows2 ++ (r2 :: rows3)))``, + +REPEAT STRIP_TAC THEN +SIMP_TAC (list_ss++boolSimps.CONJ_ss) [PMATCH_APPEND_SEM, RIGHT_AND_OVER_OR, EXISTS_OR_THM] THEN + +Cases_on `?r. MEM r rows1 ∧ IS_SOME (r v)` THEN ( + ASM_REWRITE_TAC [] +) THEN +Cases_on `?r. MEM r rows2 ∧ IS_SOME (r v)` THEN ( + ASM_REWRITE_TAC [] +) THENL [ + SIMP_TAC std_ss [PMATCH_def] THEN + Cases_on `r1 v` THEN ( + FULL_SIMP_TAC std_ss [EVERY_MEM] + ) THEN + RES_TAC THEN + FULL_SIMP_TAC std_ss [], + + Cases_on `r1 v` THEN ( + ASM_SIMP_TAC std_ss [] + ) THEN + FULL_SIMP_TAC std_ss [PMATCH_def] +]); + +val PMATCH_ROWS_DROP_SUBSUMED_PMATCH_ROWS = store_thm ( + "PMATCH_ROWS_DROP_SUBSUMED_PMATCH_ROWS", +``!p g r p' g' r' rows1 rows2 rows3 v. + ((!x. (v = p x) /\ (g x) ==> (?x'. (p x = p' x') /\ (g' x'))) /\ + (!x x'. ((v = p x) /\ (p x = p' x') /\ g x /\ g' x') ==> + (r x = r' x')) /\ + (!x. ((v = p x) /\ (g x)) ==> EVERY (\row. (row (p x) = NONE)) rows2)) ==> + (PMATCH v (rows1 ++ (PMATCH_ROW p g r :: rows2) ++ (PMATCH_ROW p' g' r' :: rows3)) = + PMATCH v (rows1 ++ rows2 ++ (PMATCH_ROW p' g' r' :: rows3)))``, + +REPEAT STRIP_TAC THEN +MATCH_MP_TAC PMATCH_ROWS_DROP_SUBSUMED THEN +SIMP_TAC std_ss [PMATCH_ROW_def, optionTheory.some_def, + PMATCH_ROW_COND_def, IS_SOME_OPTION_MAP] THEN +Cases_on `?x. (p x = v) ∧ g x` THEN ( + ASM_SIMP_TAC std_ss [] +) THEN +REPEAT STRIP_TAC THENL [ + PROVE_TAC[], + + SELECT_ELIM_TAC THEN + CONJ_TAC THEN1 PROVE_TAC[] THEN + REPEAT STRIP_TAC THEN + SELECT_ELIM_TAC THEN + PROVE_TAC[], + + FULL_SIMP_TAC std_ss [] THEN + METIS_TAC[] +]); + + val PMATCH_REMOVE_ARB = store_thm ("PMATCH_REMOVE_ARB", ``(!x. r x = ARB) ==> (PMATCH v (SNOC (PMATCH_ROW p g r) rows) = @@ -620,8 +722,12 @@ Induct_on `rows` THENL [ ASM_SIMP_TAC list_ss [PMATCH_def] ]) -(* ARB rows can be removed, since a match failiure is the same - as ARB *) +(* Introduce explicit catch-all at end *) +val PMATCH_INTRO_CATCHALL = store_thm ("PMATCH_INTRO_CATCHALL", +``PMATCH v rows = PMATCH v (SNOC (PMATCH_ROW (\_0. _0) (\_0. T) (\_0. ARB)) rows)``, +SIMP_TAC std_ss [PMATCH_REMOVE_ARB]); + + val PMATCH_REMOVE_ARB_NO_OVERLAP = store_thm ("PMATCH_REMOVE_ARB_NO_OVERLAP", ``!v p g r rows1 rows2. ((!x. (r x = ARB)) /\ @@ -630,19 +736,10 @@ val PMATCH_REMOVE_ARB_NO_OVERLAP = store_thm ("PMATCH_REMOVE_ARB_NO_OVERLAP", PMATCH v (rows1 ++ rows2))``, REPEAT STRIP_TAC THEN -Tactical.REVERSE (Induct_on `rows1`) THEN ( - ASM_SIMP_TAC list_ss [PMATCH_def] -) THEN - -Cases_on `PMATCH_ROW p g r v` THEN ( - ASM_SIMP_TAC std_ss [] -) THEN -IMP_RES_TAC PMATCH_ROW_EQ_SOME THEN -Q.PAT_ASSUM `!x. P x ==> Q x` (MP_TAC o Q.SPEC `x'`) THEN -FULL_SIMP_TAC std_ss [PMATCH_ROW_COND_def] THEN -Induct_on `rows2` THEN ( - ASM_SIMP_TAC list_ss [PMATCH_def, PMATCH_INCOMPLETE_def] -)) +ONCE_REWRITE_TAC [PMATCH_INTRO_CATCHALL] THEN +SIMP_TAC list_ss [SNOC_APPEND] THEN +MATCH_MP_TAC PMATCH_ROWS_DROP_SUBSUMED_PMATCH_ROWS THEN +ASM_SIMP_TAC std_ss []) From e9c2d26b6d9a781bcdcd56208026ac3a29235e7a Mon Sep 17 00:00:00 2001 From: Thomas Tuerk Date: Thu, 19 Mar 2015 01:21:35 +0100 Subject: [PATCH 239/718] deepMatches: improve removing guards After trying to get congruence rules for the simplifier working for PMATCH for some time, I finally understood, I don't need them for removing guards. In this case, I can propagate the information statically by just providing a better input theorem. This is the better solution anyhow. --- examples/deep_matches/deepMatchesScript.sml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/examples/deep_matches/deepMatchesScript.sml b/examples/deep_matches/deepMatchesScript.sml index 46af27be24..a053888d1f 100644 --- a/examples/deep_matches/deepMatchesScript.sml +++ b/examples/deep_matches/deepMatchesScript.sml @@ -886,13 +886,13 @@ val GUARDS_ELIM_THM = store_thm ("GUARDS_ELIM_THM", PMATCH v (rs1++(PMATCH_ROW p g r)::rs2) = PMATCH v (rs1++(PMATCH_ROW p (\x. T) (\x. if g x then r x else - PMATCH v rs2))::rs2))``, + PMATCH (p x) rs2))::rs2))``, +REPEAT STRIP_TAC THEN SIMP_TAC std_ss [PMATCH_APPEND_SEM] THEN Cases_on `?r. MEM r rs1 /\ IS_SOME (r v)` THEN ( ASM_REWRITE_TAC[] ) THEN -REPEAT STRIP_TAC THEN SIMP_TAC std_ss [PMATCH_EVAL, PMATCH_ROW_COND_def] THEN Tactical.REVERSE (Cases_on `?x. p x = v`) THEN ( FULL_SIMP_TAC std_ss [] From dabb8381f277e7240abd7246e2ac3e0b4e080bfe Mon Sep 17 00:00:00 2001 From: Thomas Tuerk Date: Fri, 20 Mar 2015 07:06:00 +0100 Subject: [PATCH 240/718] deep matches: cleaning examples --- examples/deep_matches/deepMatchesExamples.sml | 92 +++++++++---------- examples/deep_matches/deepMatchesLib.sml | 5 +- 2 files changed, 45 insertions(+), 52 deletions(-) diff --git a/examples/deep_matches/deepMatchesExamples.sml b/examples/deep_matches/deepMatchesExamples.sml index b140dc54f9..70bf7b20f6 100644 --- a/examples/deep_matches/deepMatchesExamples.sml +++ b/examples/deep_matches/deepMatchesExamples.sml @@ -35,7 +35,7 @@ val t = ``case x of | (SOME 3, (x :: xs)) => 3 + x | (SOME _, (x :: xs)) => x`` val t' = case2pmatch true t -val thm_t = PMATCH_INTRO_CONV t +val thm_t = PMATCH_INTRO_CONV t; (* Playing around with some examples *) @@ -54,7 +54,7 @@ val example1 = `` ]``; (* due to guards, the following fails *) -val _ = pmatch2case example1 +val _ = pmatch2case example1; val example2 = ``PMATCH (h::t) [PMATCH_ROW (\_ . []) (\_. T) (\_. x); @@ -65,9 +65,8 @@ val example2 = ``PMATCH (h::t) (\ (v12,v16,v17). 3); PMATCH_ROW (\_. [2; 4; 3]) (\_. T) (\_. 3 + x)]`` -val t = rhs (concl (PMATCH_FORCE_SAME_VARS_CONV example2)) -val example2_tm = pmatch2case example2 -PMATCH_INTRO_WILDCARDS_CONV t +val thm0 = PMATCH_FORCE_SAME_VARS_CONV example2 +val thm1 = CONV_RULE (RHS_CONV PMATCH_INTRO_WILDCARDS_CONV) thm0 val example3 = `` CASE (NONE,x,xs) OF [ @@ -87,9 +86,9 @@ set_trace "use pmatch_pp" 1; example1; -PMATCH_SIMP_CONV example1 -PMATCH_SIMP_CONV example2 -PMATCH_SIMP_CONV example3 +val thm1 = PMATCH_SIMP_CONV example1 +val thm2 = PMATCH_SIMP_CONV example2 +val thm3 = PMATCH_SIMP_CONV example3 set_goal ([], ``^example1 = XXX``); @@ -100,7 +99,8 @@ e (CONV_TAC (DEPTH_CONV PMATCH_SIMP_CONV)) proofManagerLib.restart () -e (Cases_on `xs`) +e (SIMP_TAC (std_ss++PMATCH_SIMP_ss) []) +e (Cases_on `xs`); e (CONV_TAC (DEPTH_CONV PMATCH_SIMP_CONV)) proofManagerLib.restart () @@ -127,6 +127,19 @@ val ex1 = ``case (x, y, z) of | (x, [], SOME y) => x+y | (_, z::zs, _) => z`` +(* or directly *) +val ex1' = ``CASE (x, y, z) OF [ + || x. (x, [], NONE) ~> x; + || (x, y). (x, [], SOME y) ~> x+y; + || (z, zs). (_, z::zs, _) ~> z]`` + +(* They are not alpha-equivalent though because order of + wildcards differs. check via + +set_trace "use pmatch_pp" 0 +set_trace "use pmatch_pp" 1 +*) + (* there are new features as well. Multiple occurences of the same variable in a pattern are fine *) @@ -141,12 +154,16 @@ val ex2 = ``case (x, y) of simplify the PMATCH. *) val ex2_thm = prove (``^ex2 = (x = y)``, - SIMP_TAC (std_ss++PMATCH_SIMP_ss) [] THEN Cases_on `x=y` THEN ( ASM_SIMP_TAC (std_ss++PMATCH_SIMP_ss) [] )) +(* Or use specialised tools *) +val ex2_thm' = prove (``^ex2 = (x = y)``, +SIMP_TAC (std_ss++PMATCH_REMOVE_DOUBLE_BIND_ss++PMATCH_REMOVE_GUARDS_ss) [] THEN +PROVE_TAC[]) + (**************************************) (* PMATCH has necessary congruences *) @@ -155,9 +172,9 @@ Cases_on `x=y` THEN ( val my_d_def = Define `my_d xx = CASE xx OF [ - ||! (x, []) when x > 3 ~> x; - ||! (x, []) ~> 0; - ||! (x, y::ys) ~> my_d (x + y, ys)]` + || x. (x,[]) when (x > 3) ~> x; + || x. (x,[]) ~> 0; + || (x,y,ys). (x,y::ys) ~> (my_d (x + y,ys))]` val my_d_thms = store_thm ("my_d_thms", ``(!x. x > 3 ==> (my_d (x, []) = x)) /\ @@ -199,9 +216,9 @@ val my_d_thms3 = PMATCH_TO_TOP_RULE my_d_def val t = ``CASE l OF [ ||. [] ~> 0; - ||! x::y::x::y::_ ~> x+y; - ||! x::x::x::y::_ ~> x+x+x; - ||! x::_ ~> 1 + ||(x,y). x::y::x::y::_ ~> x+y; + ||(x,y). x::x::x::y::_ ~> x+x+x; + || x. x::_ ~> 1 ]`` val thm0 = PMATCH_REMOVE_DOUBLE_BIND_CONV t @@ -211,8 +228,8 @@ val thm0 = PMATCH_REMOVE_DOUBLE_BIND_CONV t (* Removing Guards *) (*********************************) -val thm1 = PMATCH_REMOVE_GUARDS_CONV (rhs (concl thm0)) -val thm1b = SIMP_CONV (std_ss++PMATCH_REMOVE_GUARDS_ss) [] (rhs (concl thm0)) +val thm1 = CONV_RULE (RHS_CONV PMATCH_REMOVE_GUARDS_CONV) thm0 +val thm2 = CONV_RULE (RHS_CONV (SIMP_CONV (std_ss++PMATCH_REMOVE_GUARDS_ss) [])) thm0 val t = ``CASE (y,x,l) OF [ @@ -283,20 +300,15 @@ val string_match_dectree_def = CONV_RULE (* Heuristics *) (*********************************) -val dummy_bool_tm = - ``CASE (a,b,c) OF [ - ||. (_, 0, _) ~> 1; - ||. (0, _, 0) ~> 1; - ||. (_, _, _) ~> 0 - ]`` - -val dummy_bool_def = Define `dummy_bool _ v0 a b c _ _ = +val dummy_bool_def = Define `dummy_bool a b c = CASE (a,b,c) OF [ ||. (_, 0, _) ~> 1; ||. (0, _, 0) ~> 1; - ||. (_, _, _) ~> v0 + ||. (_, _, _) ~> c ]` +val dummy_bool_tm = rhs (concl (SPEC_ALL dummy_bool_def)) + (* try to compile to a tree inside the logic *) val dummy_bool_eq1 = PMATCH_CASE_SPLIT_CONV_HEU colHeu_first_col dummy_bool_tm @@ -308,13 +320,6 @@ val dummy_bool_eq3 = PMATCH_CASE_SPLIT_CONV_HEU colHeu_default dummy_bool_tm -val dummy_bool_tm = Define `f a b c = - CASE (a,b,c) OF [ - ||. (_, 0, _) ~> 1; - ||. (0, _, 0) ~> 1; - ||. (_, _, _) ~> 0 - ]` - (*********************************) (* Constructor families *) @@ -363,7 +368,6 @@ val t = ``CASE lx OF [ || (x, y). (SNOC x _, SOME y) ~> x + y ]``; -val thm = PMATCH_CASE_SPLIT_CONV t; val thm2 = PMATCH_CASE_SPLIT_CONV t; val t = ``CASE lx OF [ @@ -389,19 +393,6 @@ val tree_red_CASE_THM = prove (`` (tree_red_CASE (Black t1 n t2) f_red f_else = f_else (Black t1 n t2))``, SIMP_TAC list_ss [tree_red_CASE_def, tree_case_def]) -(* for now the congurence needs to be set up manually, - this will be automated soon *) -val tree_red_CASE_cong = store_thm ("tree_red_CASE_cong", -``!M M' f f1 f' f1'. - (M = M') ==> - (!a0 a1 a2. (M' = Red a0 a1 a2) ==> (f a0 a1 a2 = f' a0 a1 a2)) ==> - (!x. (x = M') /\ (!a0 a1 a2. ~(M' = Red a0 a1 a2)) ==> (f1 x = f1' x)) ==> - (tree_red_CASE M f f1 = tree_red_CASE M' f' f1')``, - -SIMP_TAC std_ss [tree_red_CASE_def] THEN -Cases_on `M'` THEN -SIMP_TAC (srw_ss()) []); - val cl = make_constructorList false [ (``Red``, ["t1", "n", "t2"]) ] @@ -421,8 +412,8 @@ val balance_black_dectree_def2 = CONV_RULE balance_black_def val balance_black_dectree_def3 = CONV_RULE - (TOP_SWEEP_CONV PMATCH_ELIM_CONV) - balance_black_def + (RHS_CONV PMATCH_ELIM_CONV) + (SPEC_ALL balance_black_def) val size_new = term_size (rhs (snd (strip_forall (concl balance_black_dectree_def2)))) val size_old = term_size (rhs (snd (strip_forall (concl balance_black_dectree_def)))) @@ -493,6 +484,7 @@ val simple_card_def = Define ` val simple_card_THM_AUX = PMATCH_TO_TOP_RULE simple_card_def; +val _ = Globals.priming := NONE val simple_card_ALT_DEF = prove (``simple_card s = if (INFINITE s \/ CARD s > 2) then NONE else SOME (CARD s)``, diff --git a/examples/deep_matches/deepMatchesLib.sml b/examples/deep_matches/deepMatchesLib.sml index ba434e3d5c..2b52613c76 100644 --- a/examples/deep_matches/deepMatchesLib.sml +++ b/examples/deep_matches/deepMatchesLib.sml @@ -369,7 +369,8 @@ fun case_pmatch_eq_prove t t' = let (* very slow, simple approach. Just brute force. TODO: change implementation to get more runtime-speed *) val my_tac = ( - BasicProvers.PURE_CASE_TAC THEN + REPEAT (BasicProvers.TOP_CASE_TAC THEN + ASM_REWRITE_TAC[]) THEN FULL_SIMP_TAC (rc_ss []) [PMATCH_EVAL, PMATCH_ROW_COND_def, PMATCH_INCOMPLETE_def] ) @@ -1342,7 +1343,7 @@ REPEATC (FIRST_CONV [ CHANGED_CONV (PMATCH_SIMP_COLS_CONV_GENCALL rc_arg), CHANGED_CONV (PMATCH_EXPAND_COLS_CONV), CHANGED_CONV PMATCH_FORCE_SAME_VARS_CONV, - CHANGED_CONV PMATCH_INTRO_WILDCARDS_CONV, + PMATCH_INTRO_WILDCARDS_CONV, REWR_CONV (CONJUNCT1 PMATCH_def) ]); From 4dcfbc1f95b1e05ccf5d1ba7c21b89e6793e6aef Mon Sep 17 00:00:00 2001 From: Magnus Myreen Date: Fri, 20 Mar 2015 12:12:10 +0100 Subject: [PATCH 241/718] functional big-step opsem with example compiler proof --- examples/fun-op-sem/forScript.sml | 1018 ++++++++++++++++ examples/fun-op-sem/for_compileScript.sml | 843 ++++++++++++++ examples/fun-op-sem/impScript.sml | 104 ++ examples/fun-op-sem/non_det/Holmakefile | 2 + examples/fun-op-sem/non_det/funScript.sml | 537 +++++++++ examples/fun-op-sem/non_det/langScript.sml | 95 ++ .../fun-op-sem/non_det/lang_compileScript.sml | 1020 +++++++++++++++++ 7 files changed, 3619 insertions(+) create mode 100644 examples/fun-op-sem/forScript.sml create mode 100644 examples/fun-op-sem/for_compileScript.sml create mode 100644 examples/fun-op-sem/impScript.sml create mode 100644 examples/fun-op-sem/non_det/Holmakefile create mode 100644 examples/fun-op-sem/non_det/funScript.sml create mode 100644 examples/fun-op-sem/non_det/langScript.sml create mode 100644 examples/fun-op-sem/non_det/lang_compileScript.sml diff --git a/examples/fun-op-sem/forScript.sml b/examples/fun-op-sem/forScript.sml new file mode 100644 index 0000000000..516a1f693b --- /dev/null +++ b/examples/fun-op-sem/forScript.sml @@ -0,0 +1,1018 @@ +open HolKernel Parse boolLib bossLib; + +val _ = new_theory "for"; + +open optionTheory pairTheory pred_setTheory finite_mapTheory stringTheory; +open integerTheory; +open lcsymtacs; + +val _ = temp_tight_equality (); + +val ect = BasicProvers.EVERY_CASE_TAC; + +val OMIT_def = Define `OMIT x = x`; + +val OMIT_INTRO = prove( + ``(P1 ==> P2 ==> Q) ==> (P1 /\ OMIT P2 ==> Q)``, + fs [OMIT_def]); + +val _ = Datatype ` +e = Var string + | Num int + | Add e e + | Assign string e`; + +val _ = Datatype ` +t = + | Dec string t + | Exp e + | Break + | Seq t t + | If e t t + | For e e t`; + +val _ = Datatype ` +r = Rval int + | Rbreak + | Rtimeout + | Rfail`; + +val r_distinct = fetch "-" "r_distinct"; +val r_11 = fetch "-" "r_11"; + +val _ = Datatype ` +state = <| store : string |-> int; clock : num |>`; + +val state_component_equality = fetch "-" "state_component_equality"; + +val store_var_def = Define ` + store_var v x s = s with store := s.store |+ (v,x)`; + +val _ = augment_srw_ss[rewrites[store_var_def]]; + +val state_rw = Q.prove ( +`(!s c. <| store := s; clock := c |>.store = s) ∧ + (!s. <| store := s.store; clock := s.clock |> = s)`, + rw [state_component_equality]); + +val sem_e_def = Define ` +(sem_e s (Var x) = + case FLOOKUP s.store x of + | NONE => (Rfail, s) + | SOME n => (Rval n, s)) ∧ +(sem_e s (Num num) = + (Rval num, s)) ∧ +(sem_e s (Add e1 e2) = + case sem_e s e1 of + | (Rval n1, s1) => + (case sem_e s1 e2 of + | (Rval n2, s2) => + (Rval (n1 + n2), s2) + | r => r) + | r => r) ∧ +(sem_e s (Assign x e) = + case sem_e s e of + | (Rval n1, s1) => + (Rval n1, store_var x n1 s1) + | r => r)`; + +val sem_e_clock = Q.store_thm ("sem_e_clock", +`!s e r s'. sem_e s e = (r, s') ⇒ s.clock = s'.clock`, + Induct_on `e` >> + rw [sem_e_def] >> + ect >> + fs [] >> + rw [] >> + metis_tac []); + +val sem_e_store = Q.prove ( +`!s e r s'. sem_e s e = (r, s') ⇒ FDOM s.store ⊆ FDOM s'.store`, + Induct_on `e` >> + rw [sem_e_def] >> + ect >> + fs [SUBSET_DEF] >> + rw [] >> + metis_tac []); + +val sem_e_res = Q.prove ( +`!s e r s'. sem_e s e = (r, s') ⇒ r ≠ Rbreak ∧ r ≠ Rtimeout`, + Induct_on `e` >> + rw [sem_e_def] >> + ect >> + fs [] >> + rw [] >> + metis_tac []); + +val check_clock_def = Define ` +check_clock s' s = + s' with clock := (if s'.clock ≤ s.clock then s'.clock else s.clock)`; + +val dec_clock_def = Define ` +dec_clock s = s with clock := s.clock - 1`; + +val dec_clock_store = Q.store_thm ("dec_clock_store[simp]", +`!s. (dec_clock s).store = s.store`, + rw [dec_clock_def]); + +val sem_t_def = tDefine "sem_t" ` +(sem_t s (Exp e) = sem_e s e) ∧ +(sem_t s (Dec x t) = + sem_t (store_var x 0 s) t) ∧ +(sem_t s Break = (Rbreak, s)) ∧ +(sem_t s (Seq t1 t2) = + case sem_t s t1 of + | (Rval _, s1) => + sem_t (check_clock s1 s) t2 + | r => r) ∧ +(sem_t s (If e t1 t2) = + case sem_e s e of + | (Rval n1, s1) => sem_t s1 (if n1 = 0 then t2 else t1) + | r => r) ∧ +(sem_t s (For e1 e2 t) = + case sem_e s e1 of + | (Rval n1, s1) => + if n1 = 0 then + (Rval 0, s1) + else + (case sem_t s1 t of + | (Rval _, s2) => + (case sem_e s2 e2 of + | (Rval _, s3) => + if s.clock ≠ 0 ∧ s3.clock ≠ 0 then + sem_t (dec_clock (check_clock s3 s)) (For e1 e2 t) + else + (Rtimeout, s3) + | r => r) + | (Rbreak, s2) => + (Rval 0, s2) + | r => r) + | r => r)` + (WF_REL_TAC `(inv_image (measure I LEX measure t_size) + (\(s,t). (s.clock,t)))` + \\ REPEAT STRIP_TAC \\ TRY DECIDE_TAC + \\ fs [check_clock_def, dec_clock_def, LET_THM] + \\ rw [] + \\ imp_res_tac sem_e_clock + \\ DECIDE_TAC); + +val sem_t_clock = Q.store_thm ("sem_t_clock", +`!s t r s'. sem_t s t = (r, s') ⇒ s'.clock ≤ s.clock`, + ho_match_mp_tac (fetch "-" "sem_t_ind") >> + reverse (rpt strip_tac) >> + pop_assum mp_tac >> + rw [Once sem_t_def] >> + ect >> + imp_res_tac sem_e_clock >> + fs [] >> + fs [check_clock_def, dec_clock_def, LET_THM] >> + TRY decide_tac >> + rfs [] >> + res_tac >> + decide_tac); + +val check_clock_id = Q.prove ( +`!s s'. s.clock ≤ s'.clock ⇒ check_clock s s' = s`, + rw [check_clock_def, state_component_equality]); + +val STOP_def = Define ` + STOP x = x`; + +val sem_t_def_with_stop = Q.store_thm ("sem_t_def_with_stop", +`(sem_t s (Exp e) = sem_e s e) ∧ + (sem_t s (Dec x t) = sem_t (store_var x 0 s) t) ∧ + (sem_t s Break = (Rbreak, s)) ∧ + (sem_t s (Seq t1 t2) = + case sem_t s t1 of + | (Rval _, s1) => + sem_t s1 t2 + | r => r) ∧ + (sem_t s (If e t1 t2) = + case sem_e s e of + | (Rval n1, s1) => sem_t s1 (if n1 = 0 then t2 else t1) + | r => r) ∧ + (sem_t s (For e1 e2 t) = + case sem_e s e1 of + | (Rval n1, s1) => + if n1 = 0 then + (Rval 0, s1) + else + (case sem_t s1 t of + | (Rval _, s2) => + (case sem_e s2 e2 of + | (Rval _, s3) => + if s3.clock ≠ 0 then + sem_t (dec_clock s3) (STOP (For e1 e2 t)) + else + (Rtimeout, s3) + | r => r) + | (Rbreak, s2) => + (Rval 0, s2) + | r => r) + | r => r)`, + rpt strip_tac >> + rw [Once sem_t_def,STOP_def] >> + ect >> + fs [] >> + imp_res_tac sem_t_clock >> + fs [dec_clock_def, LET_THM, check_clock_id] >> + rpt (AP_TERM_TAC ORELSE AP_THM_TAC) >> + rw [state_component_equality] >> + rw [check_clock_def] >> + imp_res_tac sem_e_clock >> + fs [] >> + `F` by decide_tac); + +val sem_t_def = + save_thm("sem_t_def",REWRITE_RULE [STOP_def] sem_t_def_with_stop); + +val sem_t_ind = Q.store_thm("sem_t_ind", + `!P. + (!s e. P s (Exp e)) /\ + (!s x t. + P (store_var x 0 s) t ==> P s (Dec x t)) /\ + (!s. P s Break) /\ + (!s t1 t2. + (!s1 v5. sem_t s t1 = (Rval v5,s1) ==> P s1 t2) /\ P s t1 ==> + P s (Seq t1 t2)) /\ + (!s e t1 t2. + (!s1 n1. sem_e s e = (Rval n1,s1) ==> + P s1 (if n1 = 0 then t2 else t1)) ==> + P s (If e t1 t2)) /\ + (!s e1 e2 t. + (!s1 n1. + sem_e s e1 = (Rval n1,s1) /\ n1 <> 0 ==> + P s1 t /\ + !s2 n2 s3 n3. + sem_t s1 t = (Rval n2,s2) /\ sem_e s2 e2 = (Rval n3,s3) /\ + s3.clock <> 0 ==> + P (dec_clock s3) (For e1 e2 t)) ==> + P s (For e1 e2 t)) ==> + !s t. P s t`, + ntac 2 strip_tac >> + ho_match_mp_tac (fetch "-" "sem_t_ind") >> + rw [] >> + first_x_assum match_mp_tac >> + rw [] >> + fs [] >> + res_tac >> + imp_res_tac sem_t_clock >> + imp_res_tac sem_e_clock >> + fs [dec_clock_def, check_clock_id, LET_THM] >> + first_x_assum match_mp_tac >> + decide_tac) + +val sem_t_store = Q.prove ( +`!s t r s'. sem_t s t = (r, s') ⇒ FDOM s.store ⊆ FDOM s'.store`, + ho_match_mp_tac sem_t_ind >> + rpt conj_tac >> + rpt gen_tac >> + DISCH_TAC >> + ONCE_REWRITE_TAC [sem_t_def] + >- (fs [sem_t_def] >> + metis_tac [sem_e_store]) + >- (fs [sem_t_def] >> + metis_tac []) + >- (fs [sem_t_def] >> + metis_tac []) + >- (ect >> + rw [] >> + metis_tac [sem_e_store, SUBSET_DEF]) + >- (ect >> + rw [] >> + metis_tac [sem_e_store, SUBSET_DEF]) + >- (Cases_on `sem_e s e1` >> + fs [] >> + Cases_on `q` >> + reverse (fs []) + >- (Cases_on `i = 0` >> + fs [] + >- metis_tac [sem_e_store, SUBSET_TRANS] >> + Cases_on `sem_t r t` >> + fs [] >> + Cases_on `q` >> + reverse (fs []) + >- (ect >> + fs [] >> + rw [] >> + rfs [] >> + metis_tac [sem_e_store, SUBSET_TRANS]) >> + metis_tac [sem_e_store, SUBSET_TRANS]) >> + metis_tac [sem_e_store, SUBSET_TRANS])); + +val type_e_def = Define ` +(type_e s (Var x) ⇔ x ∈ s) ∧ +(type_e s (Num num) ⇔ T) ∧ +(type_e s (Add e1 e2) ⇔ type_e s e1 ∧ type_e s e2) ∧ +(type_e s (Assign x e) ⇔ x ∈ s ∧ type_e s e)`; + +val type_t_def = Define ` +(type_t in_for s (Exp e) ⇔ type_e s e) ∧ +(type_t in_for s (Dec x t) ⇔ type_t in_for (x INSERT s) t) ∧ +(type_t in_for s Break ⇔ in_for) ∧ +(type_t in_for s (Seq t1 t2) ⇔ type_t in_for s t1 ∧ type_t in_for s t2) ∧ +(type_t in_for s (If e t1 t2) ⇔ type_e s e ∧ type_t in_for s t1 ∧ type_t in_for s t2) ∧ +(type_t in_for s (For e1 e2 t) ⇔ type_e s e1 ∧ type_e s e2 ∧ type_t T s t)`; + +val type_weakening_e = Q.prove ( +`!s e s' s1. type_e s e ∧ s ⊆ s1 ⇒ type_e s1 e`, + Induct_on `e` >> + rw [type_e_def, SUBSET_DEF] >> + ect >> + fs [] >> + rw [EXTENSION] >> + metis_tac [SUBSET_DEF, NOT_SOME_NONE, SOME_11]); + +val type_sound_e = Q.prove ( +`!s e s1 c. + type_e s e ∧ s ⊆ FDOM s1 + ⇒ + ?r s1'. + r ≠ Rfail ∧ + sem_e <| store := s1; clock := c |> e = (r, s1')`, + Induct_on `e` >> + rw [type_e_def, sem_e_def] + >- (ect >> + fs [FLOOKUP_DEF, SUBSET_DEF] >> + rw [] >> + metis_tac []) + >- (res_tac >> + ntac 2 (pop_assum (qspec_then `c` mp_tac)) >> + rw [] >> + rw [] >> + `type_e (FDOM s1''.store) e'` + by (rw [] >> + match_mp_tac type_weakening_e >> + metis_tac [sem_e_store, SUBSET_TRANS, state_rw]) >> + first_x_assum (fn th => pop_assum (fn th' => assume_tac (MATCH_MP (SIMP_RULE (srw_ss()) [GSYM AND_IMP_INTRO] th) th'))) >> + pop_assum (qspecl_then [`s1''.store`, `s1''.clock`] mp_tac) >> + rw [] >> + fs [state_rw] >> + ect >> + rw []) + >- (ect >> + fs [] >> + res_tac >> + pop_assum (qspec_then `c` mp_tac) >> + fs [])); + +val type_weakening_t = Q.prove ( +`!in_for s t s' s1. type_t in_for s t ∧ s ⊆ s1 ⇒ type_t in_for s1 t`, + Induct_on `t` >> + rw [type_t_def, SUBSET_DEF] >> + ect >> + fs [] >> + rw [EXTENSION] >> + metis_tac [SUBSET_DEF, NOT_SOME_NONE, SOME_11, type_weakening_e, INSERT_SUBSET]); + +(* Have to use sem_t_ind, and not type_t_ind or t_induction. This is different + * than small-step-based type soundness *) +val type_sound_t = Q.prove ( +`!s1 t in_for s. + type_t in_for s t ∧ s ⊆ FDOM s1.store + ⇒ + ?r s1'. + r ≠ Rfail ∧ + (~in_for ⇒ r ≠ Rbreak) ∧ + sem_t s1 t = (r, s1')`, + ho_match_mp_tac sem_t_ind >> + rw [type_t_def] >> + ONCE_REWRITE_TAC [sem_t_def] >> + rw [] + >- (imp_res_tac type_sound_e >> + pop_assum (qspec_then `s1.clock` mp_tac) >> + rw [state_rw] >> + metis_tac [sem_e_res]) + >- (res_tac >> + fs [SUBSET_DEF]) + >- (res_tac >> + rw [] >> + Cases_on `r'` >> + rw [] >> + fs [] >> + rw [] >> + pop_assum match_mp_tac >> + metis_tac [type_weakening_t, sem_t_store]) + >- (imp_res_tac type_sound_e >> + pop_assum (qspec_then `s1.clock` mp_tac) >> + rw [state_rw] >> + rw [] >> + Cases_on `r` >> + fs [] + >- (Cases_on `i = 0` >> + fs [] >> + first_x_assum match_mp_tac >> + metis_tac [type_weakening_t, sem_e_store]) + >- metis_tac [sem_e_res]) + >- (imp_res_tac type_sound_e >> + rpt (pop_assum (qspec_then `s1.clock` mp_tac)) >> + rw [state_rw] >> + rw [] >> + reverse (Cases_on `r'`) >> + fs [] >> + Cases_on `i = 0` >> + fs [] + >- metis_tac [sem_e_res] + >- metis_tac [sem_e_res] >> + `type_t T (FDOM s1''.store) t` + by (rw [] >> + match_mp_tac type_weakening_t >> + metis_tac [sem_e_store, sem_t_store, SUBSET_TRANS, state_rw]) >> + res_tac >> + fs [] >> + Cases_on `r'` >> + rw [] >> + fs [] >> + rw [] >> + `type_e (FDOM s1'''.store) e2` + by (rw [] >> + match_mp_tac type_weakening_e >> + metis_tac [sem_e_store, sem_t_store, SUBSET_TRANS, state_rw]) >> + imp_res_tac type_sound_e >> + first_x_assum (qspec_then `s1'''.store` mp_tac) >> + rw [] >> + pop_assum (qspec_then `s1'''.clock` mp_tac) >> + rw [state_rw] >> + rw [] >> + Cases_on `r'` >> + rw [] >> + fs [] + >- (first_x_assum match_mp_tac >> + qexists_tac `s` >> + rw [] >> + imp_res_tac sem_e_store >> + imp_res_tac sem_t_store >> + metis_tac [SUBSET_TRANS]) >> + metis_tac [sem_e_res])); + +val _ = Datatype ` + observation = Terminate | Diverge | Crash`; + +val s_with_clock_def = Define ` + s_with_clock c = <| store := FEMPTY; clock := c |>`; + +val semantics_def = Define ` + semantics t = + if (?c v s. sem_t (s_with_clock c) t = (Rval v,s)) then + Terminate + else if (!c. ?s. sem_t (s_with_clock c) t = (Rtimeout,s)) then + Diverge + else Crash` + +val semantics_thm = save_thm("semantics_thm",semantics_def); + +(* This proof is disgusting *) +val type_soundness = Q.store_thm("type_soundness", +`!t. type_t F {} t ⇒ semantics t ≠ Crash`, + rw [semantics_def] >> + REPEAT STRIP_TAC >> + imp_res_tac type_sound_t >> + fs [] + \\ POP_ASSUM (MP_TAC o Q.SPEC `s_with_clock c`) + \\ REPEAT STRIP_TAC + \\ fs [] + \\ Cases_on `r` \\ fs[] + \\ METIS_TAC []); + +val is_rval_def = Define ` +(is_rval (Rval _) = T) ∧ +(is_rval _ = F)`; + +val (sem_e_reln_rules, sem_e_reln_ind, sem_e_reln_cases) = Hol_reln ` +(!s x n. + FLOOKUP s.store x = SOME n + ⇒ + sem_e_reln s (Var x) (Rval n, s)) ∧ +(!s x. + FLOOKUP s.store x = NONE + ⇒ + sem_e_reln s (Var x) (Rfail, s)) ∧ +(!s n. + sem_e_reln s (Num n) (Rval n, s)) ∧ +(∀s s1 s2 e1 e2 n1 n2. + sem_e_reln s e1 (Rval n1, s1) ∧ + sem_e_reln s1 e2 (Rval n2, s2) + ⇒ + sem_e_reln s (Add e1 e2) (Rval (n1 + n2), s2)) ∧ +(∀s s1 e1 e2 r. + ~is_rval r ∧ + sem_e_reln s e1 (r, s1) + ⇒ + sem_e_reln s (Add e1 e2) (r, s1)) ∧ +(∀s s1 s2 e1 e2 n1 r. + sem_e_reln s e1 (Rval n1, s1) ∧ + ~is_rval r ∧ + sem_e_reln s1 e2 (r, s2) + ⇒ + sem_e_reln s (Add e1 e2) (r, s2)) ∧ +(!s s1 x e n1. + sem_e_reln s e (Rval n1, s1) + ⇒ + sem_e_reln s (Assign x e) (Rval n1, s1 with store := s1.store |+ (x,n1))) ∧ +(!s s1 x e r. + ~is_rval r ∧ + sem_e_reln s e (r, s1) + ⇒ + sem_e_reln s (Assign x e) (r, s1))`; + +val (sem_t_reln_rules, sem_t_reln_ind, sem_t_reln_cases) = Hol_reln ` +(!s e r. + sem_e_reln s e r + ⇒ + sem_t_reln c s (Exp e) r) ∧ +(!s x t r. + sem_t_reln c (s with store := s.store |+ (x,0)) t r + ⇒ + sem_t_reln c s (Dec x t) r) ∧ +(!s. + sem_t_reln c s Break (Rbreak, s)) ∧ +(!s s1 t1 t2 n1 r. + sem_t_reln c s t1 (Rval n1, s1) ∧ + sem_t_reln c s1 t2 r + ⇒ + sem_t_reln c s (Seq t1 t2) r) ∧ +(!s s1 t1 t2 r. + sem_t_reln c s t1 (r, s1) ∧ + ~is_rval r + ⇒ + sem_t_reln c s (Seq t1 t2) (r, s1)) ∧ +(!s s1 e t1 t2 r. + sem_e_reln s e (Rval 0, s1) ∧ + sem_t_reln c s1 t2 r + ⇒ + sem_t_reln c s (If e t1 t2) r) ∧ +(!s s1 e t1 t2 n r. + sem_e_reln s e (Rval n, s1) ∧ + n ≠ 0 ∧ + sem_t_reln c s1 t1 r + ⇒ + sem_t_reln c s (If e t1 t2) r) ∧ +(!s s1 e t1 t2 r. + sem_e_reln s e (r, s1) ∧ + ~is_rval r + ⇒ + sem_t_reln c s (If e t1 t2) (r, s1)) ∧ +(!s s1 e1 e2 t. + sem_e_reln s e1 (Rval 0, s1) + ⇒ + sem_t_reln c s (For e1 e2 t) (Rval 0, s1)) ∧ +(!s s1 s2 s3 e1 e2 t n1 n2 n3 r. + sem_e_reln s e1 (Rval n1, s1) ∧ + n1 ≠ 0 ∧ + sem_t_reln c s1 t (Rval n2, s2) ∧ + sem_e_reln s2 e2 (Rval n3, s3) ∧ + sem_t_reln c (dec_clock s3) (For e1 e2 t) r ∧ + (c ⇒ s3.clock ≠ 0) + ⇒ + sem_t_reln c s (For e1 e2 t) r) ∧ +(!s s1 s2 e1 e2 t n1. + sem_e_reln s e1 (Rval n1, s1) ∧ + n1 ≠ 0 ∧ + sem_t_reln c s1 t (Rbreak, s2) + ⇒ + sem_t_reln c s (For e1 e2 t) (Rval 0, s2)) ∧ +(!s s1 s2 s3 e1 e2 t n1 n2 n3. + sem_e_reln s e1 (Rval n1, s1) ∧ + n1 ≠ 0 ∧ + sem_t_reln c s1 t (Rval n2, s2) ∧ + sem_e_reln s2 e2 (Rval n3, s3) ∧ + s3.clock = 0 ∧ + c + ⇒ + sem_t_reln c s (For e1 e2 t) (Rtimeout, s3)) ∧ +(!s s1 s2 s3 e1 e2 t n1 n2 r. + sem_e_reln s e1 (Rval n1, s1) ∧ + n1 ≠ 0 ∧ + sem_t_reln c s1 t (Rval n2, s2) ∧ + sem_e_reln s2 e2 (r, s3) ∧ + ~is_rval r + ⇒ + sem_t_reln c s (For e1 e2 t) (r, s3)) ∧ +(!s s1 s2 e1 e2 t n1 r. + sem_e_reln s e1 (Rval n1, s1) ∧ + n1 ≠ 0 ∧ + sem_t_reln c s1 t (r, s2) ∧ + ~is_rval r ∧ + r ≠ Rbreak + ⇒ + sem_t_reln c s (For e1 e2 t) (r, s2)) ∧ +(!s s1 e1 e2 t r. + sem_e_reln s e1 (r, s1) ∧ + ~is_rval r + ⇒ + sem_t_reln c s (For e1 e2 t) (r, s1))`; + +val (simple_sem_t_reln_rules, simple_sem_t_reln_ind, simple_sem_t_reln_cases) = + Hol_reln ` +(!s e r. + sem_e_reln s e r + ⇒ + simple_sem_t_reln s (Exp e) r) ∧ +(!s x t r. + simple_sem_t_reln (s with store := s.store |+ (x,0)) t r + ⇒ + simple_sem_t_reln s (Dec x t) r) ∧ +(!s. + simple_sem_t_reln s Break (Rbreak, s)) ∧ +(!s s1 t1 t2 n1 r. + simple_sem_t_reln s t1 (Rval n1, s1) ∧ + simple_sem_t_reln s1 t2 r + ⇒ + simple_sem_t_reln s (Seq t1 t2) r) ∧ +(!s s1 t1 t2 r. + simple_sem_t_reln s t1 (r, s1) ∧ + ~is_rval r + ⇒ + simple_sem_t_reln s (Seq t1 t2) (r, s1)) ∧ +(!s s1 e t1 t2 r. + sem_e_reln s e (Rval 0, s1) ∧ + simple_sem_t_reln s1 t2 r + ⇒ + simple_sem_t_reln s (If e t1 t2) r) ∧ +(!s s1 e t1 t2 n r. + sem_e_reln s e (Rval n, s1) ∧ + n ≠ 0 ∧ + simple_sem_t_reln s1 t1 r + ⇒ + simple_sem_t_reln s (If e t1 t2) r) ∧ +(!s s1 e t1 t2 r. + sem_e_reln s e (r, s1) ∧ + ~is_rval r + ⇒ + simple_sem_t_reln s (If e t1 t2) (r, s1)) ∧ +(!s s1 e1 e2 t. + sem_e_reln s e1 (Rval 0, s1) + ⇒ + simple_sem_t_reln s (For e1 e2 t) (Rval 0, s1)) ∧ +(!s s1 e1 e2 t r. + sem_e_reln s e1 (r, s1) ∧ + ~is_rval r + ⇒ + simple_sem_t_reln s (For e1 e2 t) (r, s1)) ∧ +(!s s1 s2 s3 e1 e2 t n1 n2 n3 r. + sem_e_reln s e1 (Rval n1, s1) ∧ + n1 ≠ 0 ∧ + simple_sem_t_reln s1 t (Rval n2, s2) ∧ + sem_e_reln s2 e2 (Rval n3, s3) ∧ + simple_sem_t_reln s3 (For e1 e2 t) r + ⇒ + simple_sem_t_reln s (For e1 e2 t) r) ∧ +(!s s1 s2 e1 e2 t n1. + sem_e_reln s e1 (Rval n1, s1) ∧ + n1 ≠ 0 ∧ + simple_sem_t_reln s1 t (Rbreak, s2) + ⇒ + simple_sem_t_reln s (For e1 e2 t) (Rval 0, s2)) ∧ +(!s s1 s2 s3 e1 e2 t n1 n2 r. + sem_e_reln s e1 (Rval n1, s1) ∧ + n1 ≠ 0 ∧ + simple_sem_t_reln s1 t (Rval n2, s2) ∧ + sem_e_reln s2 e2 (r, s3) ∧ + ~is_rval r + ⇒ + simple_sem_t_reln s (For e1 e2 t) (r, s3)) ∧ +(!s s1 s2 e1 e2 t n1 r. + sem_e_reln s e1 (Rval n1, s1) ∧ + n1 ≠ 0 ∧ + simple_sem_t_reln s1 t (r, s2) ∧ + ~is_rval r ∧ + r ≠ Rbreak + ⇒ + simple_sem_t_reln s (For e1 e2 t) (r, s2))`; + +val _ = Parse.add_infix("DOWNARROWe",450,Parse.NONASSOC) +val _ = Parse.add_infix("DOWNARROWt",450,Parse.NONASSOC) + +val DOWNARROWe_def = Define `$DOWNARROWe (y,x) z = sem_e_reln x y z`; +val DOWNARROWt_def = Define `$DOWNARROWt (y,x) z = simple_sem_t_reln x y z`; + +val simple_sem_t_reln_rules = save_thm("simple_sem_t_reln_rules", + simple_sem_t_reln_rules |> REWRITE_RULE [GSYM DOWNARROWe_def, + GSYM DOWNARROWt_def]); + +val simple_sem_t_reln_ind = save_thm("simple_sem_t_reln_ind", + simple_sem_t_reln_ind + |> REWRITE_RULE [GSYM DOWNARROWe_def, GSYM DOWNARROWt_def] + |> Q.SPEC `P` |> UNDISCH_ALL + |> Q.SPECL [`s`,`t`,`r`] |> Q.GENL [`r`,`s`,`t`] + |> DISCH_ALL |> Q.GEN `P` |> Q.SPEC `\s t r. P (t,s) r` + |> SIMP_RULE std_ss [] |> Q.GEN `P` + |> SPEC_ALL + |> REWRITE_RULE [GSYM AND_IMP_INTRO] |> DISCH T + |> MATCH_MP OMIT_INTRO + |> MATCH_MP OMIT_INTRO + |> MATCH_MP OMIT_INTRO + |> MATCH_MP OMIT_INTRO + |> MATCH_MP OMIT_INTRO + |> MATCH_MP OMIT_INTRO + |> MATCH_MP OMIT_INTRO + |> MATCH_MP OMIT_INTRO + |> REWRITE_RULE [AND_IMP_INTRO] + |> UNDISCH + |> Q.SPECL [`FST (ts:t # state)`,`SND (ts:t # state)`,`rs`] + |> Q.GEN `rs` + |> Q.GEN `ts` + |> SIMP_RULE std_ss [] + |> DISCH_ALL + |> Q.GEN `P` + |> REWRITE_RULE [GSYM CONJ_ASSOC]); + +val (compact_sem_t_reln_rules, compact_sem_t_reln_ind, compact_sem_t_reln_cases) = + Hol_reln ` +(!s e r. + sem_e_reln s e r + ⇒ + compact_sem_t_reln s (Exp e) r) ∧ +(!s x t r. + compact_sem_t_reln (s with store := s.store |+ (x,0)) t r + ⇒ + compact_sem_t_reln s (Dec x t) r) ∧ +(!s. + compact_sem_t_reln s Break (Rbreak, s)) ∧ +(!s s1 t1 t2 n1 r. + compact_sem_t_reln s t1 (Rval n1, s1) ∧ + compact_sem_t_reln s1 t2 r + ⇒ + compact_sem_t_reln s (Seq t1 t2) r) ∧ +(!s s1 t1 t2 r. + compact_sem_t_reln s t1 (r, s1) ∧ + ~is_rval r + ⇒ + compact_sem_t_reln s (Seq t1 t2) (r, s1)) ∧ +(!s s1 e t1 t2 r. + sem_e_reln s e (Rval 0, s1) ∧ + compact_sem_t_reln s1 t2 r + ⇒ + compact_sem_t_reln s (If e t1 t2) r) ∧ +(!s s1 e t1 t2 n r. + sem_e_reln s e (Rval n, s1) ∧ + n ≠ 0 ∧ + compact_sem_t_reln s1 t1 r + ⇒ + compact_sem_t_reln s (If e t1 t2) r) ∧ +(!s s1 e t1 t2 r. + sem_e_reln s e (r, s1) ∧ + ~is_rval r + ⇒ + compact_sem_t_reln s (If e t1 t2) (r, s1)) ∧ +(!s s1 e1 e2 t. + sem_e_reln s e1 (r1, s1) /\ + (if (r1 = Rval n1) \/ n1 <> 0 then + compact_sem_t_reln s1 t (r2, s2) /\ + (if r2 = Rval n2 then + sem_e_reln s2 e2 (r3, s3) /\ + (if r3 = Rval n3 then + compact_sem_t_reln s3 (For e1 e2 t) result + else + (result = (r3, s3))) + else + (result = (r2, s2))) + else + (result = (r1, s1))) + ⇒ + compact_sem_t_reln s (For e1 e2 t) result)`; + +val _ = Parse.add_infix("C_DOWNARROWt",450,Parse.NONASSOC) + +val C_DOWNARROWt_def = Define `$C_DOWNARROWt (y,x) z = compact_sem_t_reln x y z`; + +val compact_sem_t_reln_rules = save_thm("compact_sem_t_reln_rules", + compact_sem_t_reln_rules |> REWRITE_RULE [GSYM DOWNARROWe_def, + GSYM C_DOWNARROWt_def]); + +val compact_sem_t_reln_ind = save_thm("compact_sem_t_reln_ind", + compact_sem_t_reln_ind + |> REWRITE_RULE [GSYM DOWNARROWe_def, GSYM C_DOWNARROWt_def] + |> Q.SPEC `P` |> UNDISCH_ALL + |> Q.SPECL [`s`,`t`,`r`] |> Q.GENL [`r`,`s`,`t`] + |> DISCH_ALL |> Q.GEN `P` |> Q.SPEC `\s t r. P (t,s) r` + |> SIMP_RULE std_ss [] |> Q.GEN `P` + |> SPEC_ALL + |> REWRITE_RULE [GSYM AND_IMP_INTRO] |> DISCH T + |> MATCH_MP OMIT_INTRO + |> MATCH_MP OMIT_INTRO + |> MATCH_MP OMIT_INTRO + |> MATCH_MP OMIT_INTRO + |> MATCH_MP OMIT_INTRO + |> MATCH_MP OMIT_INTRO + |> MATCH_MP OMIT_INTRO + |> MATCH_MP OMIT_INTRO + |> REWRITE_RULE [AND_IMP_INTRO] + |> UNDISCH + |> Q.SPECL [`FST (ts:t # state)`,`SND (ts:t # state)`,`rs`] + |> Q.GEN `rs` + |> Q.GEN `ts` + |> SIMP_RULE std_ss [] + |> DISCH_ALL + |> Q.GEN `P` + |> REWRITE_RULE [GSYM CONJ_ASSOC]); + +val semantics_reln_def = Define ` +semantics_reln t = + case some (r,s). ?c. r ≠ Rtimeout ∧ sem_t_reln T <| store := FEMPTY; clock := c |> t (r, s) of + | NONE => Diverge + | SOME (Rval _, _) => Terminate + | _ => Crash`; + +val big_sem_correct_lem1 = Q.prove ( +`∀s e r. + sem_e_reln s e r + ⇒ + sem_e s e = r`, + ho_match_mp_tac sem_e_reln_ind >> + rw [sem_e_def] >> + ect >> + fs [is_rval_def] >> + imp_res_tac sem_e_res >> + fs []); + +val big_sem_correct_lem2 = Q.prove ( +`∀s e r. + sem_e s e = r + ⇒ + sem_e_reln s e r`, + Induct_on `e` >> + rw [sem_e_def] >> + rw [Once sem_e_reln_cases] >> + ect >> + fs [is_rval_def] >> + imp_res_tac sem_e_res >> + fs [] >> + metis_tac []); + +val big_sem_correct_lem3 = Q.prove ( +`∀s e r. + sem_e_reln s e r + ⇔ + sem_e s e = r`, + metis_tac [big_sem_correct_lem1, big_sem_correct_lem2]); + +val big_sem_correct_lem4 = Q.prove ( +`∀s t r. + sem_t_reln T s t r + ⇔ + sem_t s t = r`, + ho_match_mp_tac sem_t_ind >> + rpt conj_tac + >- (rw [sem_t_def, Once sem_t_reln_cases] >> + metis_tac [big_sem_correct_lem1, big_sem_correct_lem2]) + >- (rw [sem_t_def] >> + rw [Once sem_t_reln_cases]) + >- (rw [sem_t_def] >> + rw [Once sem_t_reln_cases] >> + metis_tac []) + >- (rw [sem_t_def] >> + rw [Once sem_t_reln_cases] >> + ect >> + fs [] >> + metis_tac [is_rval_def, big_sem_correct_lem1, PAIR_EQ, r_distinct, r_11]) + >- (rw [sem_t_def] >> + rw [Once sem_t_reln_cases] >> + ect >> + fs [] >> + eq_tac >> + rw [] >> + imp_res_tac big_sem_correct_lem1 >> + fs [] >> + rw [] >> + rfs [] + >- metis_tac [is_rval_def, big_sem_correct_lem1, big_sem_correct_lem2, PAIR_EQ, r_distinct, r_11, pair_CASES] + >- (disj1_tac >> + imp_res_tac big_sem_correct_lem2 >> + qexists_tac `r'` >> + rw []) + >- metis_tac [is_rval_def, big_sem_correct_lem1, big_sem_correct_lem2, PAIR_EQ, r_distinct, r_11, pair_CASES] + >- (disj2_tac >> + disj1_tac >> + imp_res_tac big_sem_correct_lem2 >> + qexists_tac `r'` >> + qexists_tac `i` >> + rw []) >> + metis_tac [is_rval_def, big_sem_correct_lem1, big_sem_correct_lem2, PAIR_EQ, r_distinct, r_11, pair_CASES]) + >- (rw [] >> + rw [Once sem_t_reln_cases, Once sem_t_def] >> + Cases_on `sem_e s e1` >> + rw [] >> + Cases_on `q` >> + rw [] >> + PairCases_on `r` >> + fs [big_sem_correct_lem3] >> + rw [] + >- metis_tac [is_rval_def, big_sem_correct_lem1, big_sem_correct_lem2, PAIR_EQ, r_distinct, r_11, pair_CASES, PAIR_EQ] + >- (ect >> + rw [] >> + rfs [] >> + metis_tac [dec_clock_def, is_rval_def, big_sem_correct_lem1, big_sem_correct_lem2, PAIR_EQ, r_distinct, r_11, pair_CASES]) >> + metis_tac [is_rval_def, big_sem_correct_lem1, big_sem_correct_lem2, PAIR_EQ, r_distinct, r_11, pair_CASES, PAIR_EQ])); + +val sem_e_ignores_clock = Q.prove ( +`!s t r. + sem_e_reln s t r + ⇒ + !c. sem_e_reln (s with clock := c) t (FST r, SND r with clock := c)`, + ho_match_mp_tac sem_e_reln_ind >> + rw [] >> + ONCE_REWRITE_TAC [sem_e_reln_cases] >> + rw [is_rval_def] + >- metis_tac [] + >- metis_tac [] >> + qexists_tac `s1 with clock := c` >> + rw []); + +val big_sem_correct_lem5 = Q.prove ( +`∀s e r. + sem_e_reln (s with clock := (SND r).clock) e r + ⇔ + (?c. FST r ≠ Rtimeout ∧ sem_e (s with clock := c) e = r)`, + rw [] >> + PairCases_on `r` >> + fs [] >> + eq_tac >> + rw [] >> + imp_res_tac sem_e_clock >> + fs [] >> + metis_tac [big_sem_correct_lem1, big_sem_correct_lem2, sem_e_ignores_clock, FST, SND, sem_e_res]); + (* + +val big_sem_correct_lem6 = Q.prove ( +`∀s t r. + sem_t_reln F (s with clock := (SND r).clock) t r + ⇔ + (?c. FST r ≠ Rtimeout ∧ sem_t (s with clock := c) t = r)`, + ho_match_mp_tac sem_t_ind >> + rpt conj_tac + >- (rw [sem_t_def, Once sem_t_reln_cases] >> + metis_tac [big_sem_correct_lem5]) + >- (rw [sem_t_def] >> + rw [Once sem_t_reln_cases]) + >- (rw [sem_t_def] >> + rw [Once sem_t_reln_cases] >> + PairCases_on `r` >> + fs [] >> + eq_tac >> + rw [] >> + rw [] >> + metis_tac []) + >- (rw [sem_t_def] >> + rw [Once sem_t_reln_cases] >> + PairCases_on `r` >> + fs [] >> + eq_tac >> + rw [] >> + ect >> + fs [] >> + metis_tac [is_rval_def, big_sem_correct_lem1, PAIR_EQ, r_distinct, r_11, + SND] + + >- (rw [sem_t_def] >> + rw [Once sem_t_reln_cases] >> + ect >> + fs [] >> + eq_tac >> + rw [] >> + imp_res_tac big_sem_correct_lem1 >> + fs [] >> + rw [] >> + rfs [] + >- metis_tac [is_rval_def, big_sem_correct_lem1, big_sem_correct_lem2, PAIR_EQ, r_distinct, r_11, pair_CASES] + >- (disj1_tac >> + imp_res_tac big_sem_correct_lem2 >> + qexists_tac `r'` >> + rw []) + >- metis_tac [is_rval_def, big_sem_correct_lem1, big_sem_correct_lem2, PAIR_EQ, r_distinct, r_11, pair_CASES] + >- (disj2_tac >> + disj1_tac >> + imp_res_tac big_sem_correct_lem2 >> + qexists_tac `r'` >> + qexists_tac `i` >> + rw []) >> + metis_tac [is_rval_def, big_sem_correct_lem1, big_sem_correct_lem2, PAIR_EQ, r_distinct, r_11, pair_CASES]) + >- (rw [] >> + rw [Once sem_t_reln_cases, Once sem_t_def] >> + Cases_on `sem_e s e1` >> + rw [] >> + Cases_on `q` >> + rw [] >> + PairCases_on `r` >> + fs [big_sem_correct_lem3] >> + rw [] + >- metis_tac [is_rval_def, big_sem_correct_lem1, big_sem_correct_lem2, PAIR_EQ, r_distinct, r_11, pair_CASES, PAIR_EQ] + >- (ect >> + rw [] >> + rfs [] >> + metis_tac [dec_clock_def, is_rval_def, big_sem_correct_lem1, big_sem_correct_lem2, PAIR_EQ, r_distinct, r_11, pair_CASES]) >> + metis_tac [is_rval_def, big_sem_correct_lem1, big_sem_correct_lem2, PAIR_EQ, r_distinct, r_11, pair_CASES, PAIR_EQ])); + +val big_sem_correct = Q.prove ( +`!t. semantics_reln t = semantics t`, + rw [semantics_def, semantics_reln_def, big_sem_correct_lem4] + \\ ect \\ fs []); + +val semantics_reln_no_clock_def = Define ` +semantics_reln_no_clock t = + case some (r,s). sem_t_reln F <| store := FEMPTY; clock := 0 |> t (r, s) of + | NONE => Diverge + | SOME (Rval _, _) => Terminate + | _ => Crash`; + *) + +val _ = export_theory (); diff --git a/examples/fun-op-sem/for_compileScript.sml b/examples/fun-op-sem/for_compileScript.sml new file mode 100644 index 0000000000..649f4ce381 --- /dev/null +++ b/examples/fun-op-sem/for_compileScript.sml @@ -0,0 +1,843 @@ +open HolKernel Parse boolLib bossLib; + +val _ = new_theory "for_compile"; + +open optionTheory pairTheory pred_setTheory finite_mapTheory stringTheory; +open lcsymtacs forTheory listTheory arithmeticTheory; + +val _ = temp_tight_equality (); + +val ect = BasicProvers.EVERY_CASE_TAC; + +val IMP_IMP = METIS_PROVE [] ``b /\ (b1 ==> b2) ==> ((b ==> b1) ==> b2)`` + +(* verification of PASS 1, which reduces complexity of For and removes Dec *) + +val sem_t_Dec = store_thm("sem_t_Dec", + ``sem_t s (Dec v t) = + sem_t s (Seq (Exp (Assign v (Num 0))) t)``, + fs [sem_t_def,sem_e_def]); + +val sem_t_pull_if = prove( + ``sem_t s1 (if b then t1 else t2) = + (if b then sem_t s1 t1 else sem_t s1 t2)``, + SRW_TAC [] []); + +val sem_t_eval = save_thm("sem_t_eval", + (EVAL THENC REWRITE_CONV [sem_t_pull_if] THENC EVAL) + ``sem_t s (If b (Exp (Num 0)) Break)``); + +val Loop_def = Define ` + Loop t = For (Num 1) (Num 1) t`; + +val sem_t_Loop = save_thm("sem_t_Loop", + ``sem_t s (Loop t)`` + |> (SIMP_CONV (srw_ss()) [Once sem_t_def,sem_e_def,Loop_def] THENC + REWRITE_CONV [GSYM Loop_def])); + +val sem_e_break = prove( + ``!b1 s. ~(sem_e s b1 = (Rbreak,r)) /\ ~(sem_e s b1 = (Rtimeout,r))``, + Induct \\ REPEAT STRIP_TAC + \\ fs [sem_e_def] \\ ect + \\ fs [] \\ rfs []); + +val sem_t_For_swap_body = prove( + ``(!s. sem_t s t1 = sem_t s t2) ==> + (sem_t s (For b1 b2 t1) = sem_t s (For b1 b2 t2))``, + STRIP_TAC + \\ completeInduct_on `s.clock` + \\ rw [sem_t_def_with_stop,sem_e_def,Once sem_t_Loop] + \\ ect \\ fs [PULL_FORALL,STOP_def] + \\ FIRST_X_ASSUM MATCH_MP_TAC + \\ fs [dec_clock_def] + \\ imp_res_tac sem_e_clock + \\ imp_res_tac sem_t_clock + \\ decide_tac); + +val sem_t_For = store_thm("sem_t_For", + ``!s b1 b2 t. sem_t s (For b1 b2 t) = + sem_t s (Loop (If b1 (Seq t (Exp b2)) Break))``, + REPEAT STRIP_TAC + \\ completeInduct_on `s.clock` + \\ rw [sem_t_def_with_stop,sem_e_def,Once sem_t_Loop] + \\ Cases_on `sem_e s b1` \\ fs [] + \\ Cases_on `q` \\ fs [] + \\ SRW_TAC [] [sem_t_def_with_stop] + \\ Cases_on `sem_t r t` \\ fs [] + \\ Cases_on `q` \\ fs [] + \\ Cases_on `sem_e r' b2` \\ fs [] + \\ Cases_on `q` \\ fs [] + \\ SRW_TAC [] [] + \\ fs [sem_e_break] + \\ fs [PULL_FORALL,STOP_def] + \\ FIRST_X_ASSUM MATCH_MP_TAC + \\ fs [dec_clock_def] + \\ imp_res_tac sem_e_clock + \\ imp_res_tac sem_t_clock + \\ decide_tac); + +val pass1_def = Define ` + (pass1 (Exp e) = Exp e) /\ + (pass1 (Dec x t) = Seq (Exp (Assign x (Num 0))) (pass1 t)) /\ + (pass1 (Break) = Break) /\ + (pass1 (Seq t1 t2) = Seq (pass1 t1) (pass1 t2)) /\ + (pass1 (If e t1 t2) = If e (pass1 t1) (pass1 t2)) /\ + (pass1 (For e1 e2 t) = Loop (If e1 (Seq (pass1 t) (Exp e2)) Break))`; + +val pass1_correct = store_thm("pass1_correct", + ``!t s. sem_t s (pass1 t) = sem_t s t``, + Induct \\ fs [pass1_def,sem_t_def_with_stop,GSYM sem_t_For,GSYM sem_t_Dec] + \\ REPEAT STRIP_TAC \\ ect \\ fs [STOP_def] + \\ MATCH_MP_TAC sem_t_For_swap_body \\ fs []); + +val pass1_pres = store_thm("pass1_pres", + ``!t. semantics (pass1 t) = semantics t``, + fs [semantics_def,pass1_correct]); + + +(* verification of PASS 2, which flattens all expressions *) + +val comp_exp_def = Define ` + (comp_exp (Var v) s = Exp (Assign s (Var v))) /\ + (comp_exp (Num i) s = Exp (Assign s (Num i))) /\ + (comp_exp (Assign v e) s = + (Seq (comp_exp e s) (Exp (Assign v (Var s))))) /\ + (comp_exp (Add x y) s = + (Seq (comp_exp x s) + (Seq (comp_exp y (s++"'")) + (Exp (Assign s (Add (Var s) (Var (s++"'"))))))))`; + +val flatten_t_def = Define ` + (flatten_t (Exp e) n = comp_exp e n) /\ + (flatten_t (Dec x t) n = t) /\ + (flatten_t (Break) n = Break) /\ + (flatten_t (Seq t1 t2) n = Seq (flatten_t t1 n) (flatten_t t2 n)) /\ + (flatten_t (For e1 e2 t) n = For e1 e2 (flatten_t t n)) /\ + (flatten_t (If e t1 t2) n = + Seq (comp_exp e n) (If (Var n) (flatten_t t1 n) (flatten_t t2 n)))`; + +val MAX_def = Define `MAX n m = if n < m then m else n:num` + +val exp_max_def = Define ` + (exp_max (Var v) = LENGTH v) /\ + (exp_max (Add x y) = MAX (exp_max x) (exp_max y)) /\ + (exp_max (Assign v e) = MAX (LENGTH v) (exp_max e)) /\ + (exp_max _ = 0)`; + +val t_max_def = Define ` + (t_max (Exp e) = exp_max e) /\ + (t_max (Dec x t) = MAX (LENGTH x) (t_max t)) /\ + (t_max (Break) = 0) /\ + (t_max (Seq t1 t2) = MAX (t_max t1) (t_max t2)) /\ + (t_max (For e1 e2 t) = MAX (exp_max e1) (MAX (exp_max e2) (t_max t))) /\ + (t_max (If e t1 t2) = MAX (exp_max e) (MAX (t_max t1) (t_max t2)))`; + +val pass2_def = Define ` + pass2 t = flatten_t t ("temp" ++ REPLICATE (t_max t - 3) #"'")`; + +val possible_var_name_def = Define ` + possible_var_name v s = !n. ~(v ++ REPLICATE n #"'" IN FDOM s)`; + +val possible_var_name_IMP_SUBMAP = prove( + ``possible_var_name n s.store /\ s.store SUBMAP t.store ==> + s.store SUBMAP t.store |+ (n,i)``, + fs [FLOOKUP_DEF,SUBMAP_DEF,FAPPLY_FUPDATE_THM] + \\ fs [possible_var_name_def] \\ REPEAT STRIP_TAC + \\ SRW_TAC [] [] \\ fs [] + \\ METIS_TAC [APPEND_NIL,rich_listTheory.REPLICATE]); + +val MAX_LESS = prove( + ``MAX n m < k <=> n < k /\ m < k``, + SRW_TAC [] [MAX_def] \\ DECIDE_TAC); + +val sem_e_possible_var_name = prove( + ``!e s i r. + (sem_e s e = (Rval i,r)) /\ exp_max e < STRLEN k ==> + possible_var_name k s.store ==> + possible_var_name k r.store``, + Induct \\ fs [sem_e_def] \\ REPEAT STRIP_TAC \\ ect \\ fs [] + THEN1 + (FIRST_X_ASSUM (MP_TAC o Q.SPEC `r'`) + \\ FIRST_X_ASSUM (MP_TAC o Q.SPEC `s`) + \\ fs [exp_max_def,MAX_LESS]) + \\ SRW_TAC [] [] \\ fs [exp_max_def,MAX_LESS] + \\ FIRST_X_ASSUM (MP_TAC o Q.SPEC `s'`) \\ fs [] + \\ fs [store_var_def,possible_var_name_def] + \\ REPEAT STRIP_TAC \\ SRW_TAC [] [] + \\ fs [] \\ DECIDE_TAC); + +val comp_exp_correct = prove( + ``!e s t n res s1. + sem_e s e = (res,s1) /\ res <> Rfail /\ + possible_var_name n s.store /\ + s.store SUBMAP t.store /\ (t.clock = s.clock) /\ + exp_max e < LENGTH n ==> + ?t1. (sem_t t (comp_exp e n) = (res,t1)) /\ + s1.store SUBMAP t1.store /\ (t1.clock = s1.clock) /\ + (!v. (res = Rval v) ==> FLOOKUP t1.store n = SOME v) /\ + possible_var_name n s1.store /\ + (!k v. possible_var_name k s.store /\ + exp_max e < LENGTH k /\ LENGTH k < LENGTH n /\ + FLOOKUP t.store k = SOME v ==> + FLOOKUP t1.store k = SOME v)``, + Induct \\ fs [sem_e_def,comp_exp_def,sem_t_def,store_var_def] + \\ REPEAT STRIP_TAC + THEN1 + (Cases_on `FLOOKUP s'.store s` \\ fs [] \\ SRW_TAC [] [] + \\ IMP_RES_TAC FLOOKUP_SUBMAP \\ fs [] + \\ IMP_RES_TAC possible_var_name_IMP_SUBMAP \\ fs [] + \\ fs [FLOOKUP_DEF,SUBMAP_DEF,FAPPLY_FUPDATE_THM] + \\ SRW_TAC [] []) + \\ TRY (IMP_RES_TAC possible_var_name_IMP_SUBMAP \\ fs [] + \\ fs [FLOOKUP_DEF,SUBMAP_DEF,FAPPLY_FUPDATE_THM] + \\ SRW_TAC [] [] \\ fs [] \\ NO_TAC) + THEN1 + (Cases_on `sem_e s e` \\ Cases_on `q` \\ fs [sem_e_break] + \\ Cases_on `sem_e r e'` \\ Cases_on `q` \\ fs [sem_e_break] + \\ fs [exp_max_def] + \\ FIRST_X_ASSUM (MP_TAC o Q.SPEC `r`) + \\ FIRST_X_ASSUM (MP_TAC o Q.SPECL [`s`,`t`,`n`]) + \\ `exp_max e < STRLEN n /\ + exp_max e' < STRLEN n /\ + exp_max e' < STRLEN (STRCAT n "'")` by + (fs [MAX_LESS] \\ DECIDE_TAC) + \\ fs [] \\ REPEAT STRIP_TAC \\ fs [] + \\ POP_ASSUM (MP_TAC o Q.SPECL [`t1`,`STRCAT n "'"`]) + \\ `possible_var_name (STRCAT n "'") r.store` by ALL_TAC THEN1 + (fs [possible_var_name_def] + \\ REPEAT STRIP_TAC + \\ FIRST_X_ASSUM (MP_TAC o Q.SPEC `SUC n'`) + \\ FULL_SIMP_TAC std_ss [rich_listTheory.REPLICATE, + APPEND,GSYM APPEND_ASSOC]) + \\ fs [] \\ REPEAT STRIP_TAC \\ fs [] + \\ Q.MATCH_ASSUM_RENAME_TAC `s1.store SUBMAP t2.store` + \\ `FLOOKUP t2.store n = SOME i` by (FIRST_X_ASSUM MATCH_MP_TAC \\ fs []) + \\ fs [] \\ SRW_TAC [] [] + \\ `possible_var_name n r'.store` by + IMP_RES_TAC sem_e_possible_var_name + THEN1 (MATCH_MP_TAC possible_var_name_IMP_SUBMAP \\ fs []) + \\ fs [FLOOKUP_DEF,FAPPLY_FUPDATE_THM] + \\ Cases_on `k = n` \\ fs [] + \\ `v = t1.store ' k` by (SRW_TAC [] [] \\ METIS_TAC [MAX_LESS]) + \\ POP_ASSUM (fn th => SIMP_TAC std_ss [th]) + \\ FIRST_X_ASSUM MATCH_MP_TAC + \\ fs [MAX_LESS] + \\ REVERSE (REPEAT STRIP_TAC) THEN1 DECIDE_TAC + \\ IMP_RES_TAC sem_e_possible_var_name) + THEN1 + (FIRST_X_ASSUM (MP_TAC o Q.SPEC `s'`) + \\ Cases_on `sem_e s' e` \\ Cases_on `q` \\ fs [sem_e_break] + \\ SRW_TAC [] [] \\ fs [exp_max_def,MAX_LESS] + \\ FIRST_X_ASSUM (MP_TAC o Q.SPECL [`t`,`n`]) + \\ fs [] \\ REPEAT STRIP_TAC \\ fs [] + \\ REPEAT STRIP_TAC + \\ fs [SUBMAP_DEF,FAPPLY_FUPDATE_THM,FLOOKUP_DEF] + \\ REPEAT STRIP_TAC \\ fs [] + \\ SRW_TAC [] [] \\ fs [] + \\ fs [possible_var_name_def] + \\ REPEAT STRIP_TAC + \\ SRW_TAC [] [] \\ fs [] \\ DECIDE_TAC)); + +val pass2_subset_def = Define ` + (pass2_subset (Dec v t) = F) /\ + (pass2_subset (Exp e) = T) /\ + (pass2_subset Break = T) /\ + (pass2_subset (Seq t1 t2) = (pass2_subset t1 /\ pass2_subset t2)) /\ + (pass2_subset (If e t1 t2) = (pass2_subset t1 /\ pass2_subset t2)) /\ + (pass2_subset (For e1 e2 t) = ((e1 = Num 1) /\ (e2 = Num 1) /\ + pass2_subset t))` + +val sem_t_possible_var_name = prove( + ``!s e i r. + (sem_t s e = (i,r)) /\ t_max e < STRLEN k /\ i <> Rfail ==> + possible_var_name k s.store ==> + possible_var_name k r.store``, + HO_MATCH_MP_TAC sem_t_ind \\ REVERSE (REPEAT STRIP_TAC) + THEN1 + (NTAC 4 (POP_ASSUM MP_TAC) + \\ ONCE_REWRITE_TAC [sem_t_def] + \\ fs [t_max_def,MAX_LESS] + \\ REPEAT STRIP_TAC + \\ Cases_on `sem_e s e1` \\ fs [] + \\ Cases_on `q` \\ fs [sem_e_break] + \\ Cases_on `i' = 0` \\ fs [] + \\ SRW_TAC [] [] \\ fs [t_max_def,MAX_LESS] + THEN1 (METIS_TAC [sem_e_possible_var_name]) + \\ Cases_on `sem_t r' e` \\ fs [] + \\ REVERSE (Cases_on `q`) \\ fs [] + \\ SRW_TAC [] [] \\ fs [] + THEN1 (METIS_TAC [sem_e_possible_var_name]) + THEN1 (METIS_TAC [sem_e_possible_var_name]) + \\ Cases_on `sem_e r'' e2` \\ Cases_on `q` \\ fs [sem_e_break] + \\ Cases_on `r'''.clock = 0` \\ fs[] + \\ METIS_TAC [sem_e_possible_var_name]) + \\ fs [sem_t_def,t_max_def,MAX_LESS] + THEN1 + (Cases_on `sem_e s e` \\ fs [] \\ Cases_on `q` \\ fs [sem_e_break] + \\ Cases_on `i' = 0` \\ fs [] + \\ METIS_TAC [sem_e_possible_var_name]) + THEN1 (Cases_on `sem_t s e` \\ fs [] \\ Cases_on `q` \\ fs [sem_e_break]) + THEN1 (SRW_TAC [] []) + THEN1 + (fs [store_var_def] + \\ FIRST_X_ASSUM MATCH_MP_TAC + \\ fs [possible_var_name_def] + \\ CCONTR_TAC \\ fs [] + \\ SRW_TAC [] [] \\ fs [] \\ DECIDE_TAC) + THEN1 + (Cases_on `i` \\ fs [sem_e_break] + \\ IMP_RES_TAC sem_e_possible_var_name)) + |> Q.SPECL [`s`,`e`,`Rval i`,`r`] + |> SIMP_RULE (srw_ss()) []; + +val flatten_t_correct = prove( + ``!s e t n res s1. + sem_t s e = (res,s1) /\ res <> Rfail /\ pass2_subset e /\ + possible_var_name n s.store /\ + s.store SUBMAP t.store /\ (t.clock = s.clock) /\ + t_max e < LENGTH n ==> + ?t1. (sem_t t (flatten_t e n) = (res,t1)) /\ + s1.store SUBMAP t1.store /\ (t1.clock = s1.clock) /\ + possible_var_name n s1.store /\ + (!k v. possible_var_name k s.store /\ + t_max e < LENGTH k /\ LENGTH k < LENGTH n /\ + FLOOKUP t.store k = SOME v ==> + FLOOKUP t1.store k = SOME v)``, + HO_MATCH_MP_TAC sem_t_ind \\ REPEAT STRIP_TAC \\ fs [pass2_subset_def] + THEN1 (* Exp *) + (fs [flatten_t_def,sem_t_def,t_max_def] + \\ MP_TAC (SPEC_ALL comp_exp_correct) + \\ fs [] \\ REPEAT STRIP_TAC \\ fs []) + THEN1 (* Break *) + (fs [sem_t_def,flatten_t_def] \\ SRW_TAC [] []) + THEN1 (* Seq *) + (fs [sem_t_def,flatten_t_def] \\ SRW_TAC [] [] + \\ fs [t_max_def,MAX_LESS] + \\ Cases_on `sem_t s e` \\ fs [] + \\ FIRST_X_ASSUM (MP_TAC o Q.SPECL [`t`,`n`]) + \\ `q <> Rfail` by (REPEAT STRIP_TAC \\ fs []) \\ fs [] + \\ REPEAT STRIP_TAC \\ fs [] + \\ Cases_on `q` \\ fs [] \\ SRW_TAC [] [] + \\ FIRST_X_ASSUM (MP_TAC o Q.SPECL [`t1:state`,`n`]) + \\ fs [] \\ REPEAT STRIP_TAC \\ fs [] + \\ REPEAT STRIP_TAC + \\ FIRST_X_ASSUM MATCH_MP_TAC \\ fs [] + \\ IMP_RES_TAC sem_t_possible_var_name) + THEN1 (* If *) + (fs [sem_t_def,flatten_t_def] + \\ Cases_on `sem_e s e` \\ fs [] + \\ `q <> Rfail` by (REPEAT STRIP_TAC \\ fs []) + \\ MP_TAC (Q.SPECL [`e`,`s`] comp_exp_correct) \\ fs [] + \\ REPEAT STRIP_TAC \\ POP_ASSUM (MP_TAC o Q.SPECL [`t`,`n`]) + \\ fs [MAX_LESS,t_max_def] \\ REPEAT STRIP_TAC \\ fs [sem_e_def] + \\ REVERSE (Cases_on `q`) \\ fs [] \\ TRY (SRW_TAC [] [] \\ NO_TAC) + \\ Q.MATCH_ASSUM_RENAME_TAC `FLOOKUP t3.store n = SOME i` + \\ FIRST_X_ASSUM (MP_TAC o Q.SPECL [`t3:state`,`n`]) \\ fs [] + \\ Cases_on `i = 0` \\ fs [] \\ REPEAT STRIP_TAC \\ fs [] + \\ REPEAT STRIP_TAC + \\ FIRST_X_ASSUM MATCH_MP_TAC \\ fs [] + \\ IMP_RES_TAC sem_e_possible_var_name) + THEN1 (* For *) + (ASM_SIMP_TAC (srw_ss()) [sem_t_def_with_stop,flatten_t_def,sem_e_def] + \\ fs [sem_e_def,t_max_def] \\ SRW_TAC [] [] + \\ Q.PAT_ASSUM `sem_t s (For (Num 1) (Num 1) e) = (res,s1)` MP_TAC + \\ ONCE_REWRITE_TAC [sem_t_def] \\ fs [sem_e_def] + \\ REPEAT STRIP_TAC \\ Cases_on `sem_t s e` \\ fs [] + \\ `q <> Rfail` by (REPEAT STRIP_TAC \\ fs []) + \\ FIRST_X_ASSUM (MP_TAC o Q.SPECL [`t`,`n`]) + \\ fs [MAX_LESS,t_max_def] \\ REPEAT STRIP_TAC \\ fs [sem_e_def] + \\ REVERSE (Cases_on `q`) \\ fs [] \\ TRY (SRW_TAC [] [] \\ NO_TAC) + \\ Cases_on `r.clock = 0` \\ fs [] THEN1 (SRW_TAC [] []) + \\ fs [STOP_def] + \\ FIRST_X_ASSUM (MP_TAC o Q.SPECL [`dec_clock t1`,`n`]) + \\ MATCH_MP_TAC IMP_IMP \\ STRIP_TAC + THEN1 (fs [dec_clock_def]) \\ REPEAT STRIP_TAC \\ fs [] + \\ fs [flatten_t_def] \\ REPEAT STRIP_TAC + \\ FIRST_X_ASSUM MATCH_MP_TAC \\ fs [] + \\ IMP_RES_TAC sem_t_possible_var_name)); + +val pass2_correct = flatten_t_correct + |> Q.SPECL [`s`,`t`,`s`,`"temp" ++ REPLICATE (t_max t - 3) #"'"`] + |> DISCH ``s.store = FEMPTY`` + |> SIMP_RULE (srw_ss()) [GSYM pass2_def,Once possible_var_name_def, + rich_listTheory.LENGTH_REPLICATE,DECIDE ``n < 4 + (n - 3:num)``, + PULL_FORALL] |> GEN_ALL; + +val pair_eq = prove( + ``(x = (y1,y2)) <=> (FST x = y1) /\ (SND x = y2)``, + Cases_on `x` \\ fs [] \\ METIS_TAC []); + +val pass2_correct_FST = prove( + ``pass2_subset t ==> + (FST (sem_t (s_with_clock c) t) = Rfail) \/ + (FST (sem_t (s_with_clock c) (pass2 t)) = + FST (sem_t (s_with_clock c) t))``, + REPEAT STRIP_TAC \\ CCONTR_TAC \\ fs [] + \\ MP_TAC (pass2_correct + |> Q.SPECL [`t`,`s_with_clock c`] + |> SIMP_RULE std_ss [pair_eq]) + \\ fs [s_with_clock_def]); + +val lemma = prove( + ``((if b then x1 else x2) <> x2) <=> (x1 <> x2) /\ b``, + Cases_on `b` \\ fs []) + +val pass2_pres = store_thm("pass2_pres", + ``!t. semantics t <> Crash /\ pass2_subset t ==> + semantics (pass2 t) = semantics t``, + REPEAT STRIP_TAC \\ fs [semantics_thm] + \\ REVERSE (SRW_TAC [] []) \\ fs [lemma] \\ fs [pair_eq] + \\ REPEAT (FIRST_X_ASSUM (MP_TAC o Q.SPEC `c:num`)) + \\ REPEAT STRIP_TAC \\ fs [] + \\ MP_TAC pass2_correct_FST \\ fs []); + + +(* verification of PASS 3, which generates assmebly programs *) + +val _ = Datatype ` +reg = Reg string` + +val _ = Datatype ` +instr = + Add reg reg reg + | Int reg int + | Jmp num + | JmpIf reg num + | Halt`; + +val _ = Datatype ` +state_a = <| state : state; pc : num; instrs : instr list |>`; + +val do_jump_def = Define ` +do_jump s n = + if n > s.pc then + (Rval 0, s with pc := n) + else if s.state.clock = 0 then + (Rtimeout, s) + else + let st' = s.state with clock := s.state.clock - 1 in + (Rval 0, s with <| state := st'; pc := n |>)`; + +val inc_pc_def = Define ` +inc_pc s = s with pc := s.pc + 1`; + +val sem_e_clock = prove( + ``!e x st' st. (sem_e st e = (x,st')) ==> (st'.clock = st.clock)``, + Induct \\ fs [sem_e_def] \\ REPEAT STRIP_TAC + \\ ect \\ SRW_TAC [] [] \\ fs [store_var_def] \\ METIS_TAC []) |> GSYM; + +val sem_a_def = tDefine "sem_a" ` +sem_a s = + if s.pc < LENGTH s.instrs then + case EL s.pc s.instrs of + | Halt => (Rval 0, s) + | Int (Reg r) i => + let (r,st) = sem_e s.state (Assign r (Num i)) in + let s' = s with state := st in + (case r of + | Rval _ => sem_a (inc_pc s') + | _ => (r, s')) + | Add (Reg r) (Reg r1) (Reg r2) => + let (r,st) = sem_e s.state (Assign r (Add (Var r1) (Var r2))) in + let s' = s with state := st in + (case r of + | Rval _ => sem_a (inc_pc s') + | _ => (r, s')) + | Jmp n' => + (case do_jump s n' of + | (Rval _, s') => sem_a s' + | r => r) + | JmpIf (Reg r) n' => + let (r,st) = sem_e s.state (Var r) in + let s' = s with state := st in + case r of + | Rval n => + if n <> 0 then + sem_a (inc_pc s') + else + (case do_jump s' n' of + | (Rval _, s') => sem_a s' + | r => r) + | _ => (r, s') + else + (Rfail, s)` + (WF_REL_TAC `inv_image (measure I LEX measure I) + (\s. (s.state.clock,LENGTH s.instrs - s.pc))` + \\ fs [inc_pc_def,do_jump_def,LET_DEF] + \\ REPEAT STRIP_TAC + \\ ect \\ fs [] + \\ SRW_TAC [] [] \\ fs [] + \\ IMP_RES_TAC sem_e_clock + \\ DECIDE_TAC); + +val a_state_def = Define ` + a_state code clock = + <| state := s_with_clock clock; pc := 0; instrs := code |>`; + +val asm_semantics_def = Define ` + asm_semantics code = + if (?c s. sem_a (a_state code c) = (Rval 0,s)) then Terminate + else if (!c. ?s. sem_a (a_state code c) = (Rtimeout,s)) then Diverge + else Crash`; + +val pass3_aux_def = Define ` + (pass3_aux n (Dec v t) b = []) /\ + (pass3_aux n (Exp e) b = + case e of + | Assign v (Var x) => + if x = v then [] else [Int (Reg v) 0; Add (Reg v) (Reg x) (Reg v)] + | Assign v (Add (Var v1) (Var v2)) => [Add (Reg v) (Reg v1) (Reg v2)] + | Assign v (Num i) => [Int (Reg v) i] + | _ => []) /\ + (pass3_aux n Break b = [Jmp b]) /\ + (pass3_aux n (Seq t1 t2) b = + let c1 = pass3_aux n t1 b in + let c2 = pass3_aux (n + LENGTH c1) t2 b in + c1 ++ c2) /\ + (pass3_aux n (If e t1 t2) b = + let c1 = pass3_aux (n + 1) t1 b in + let c2 = pass3_aux (n + 2 + LENGTH c1) t2 b in + [JmpIf (case e of Var v => Reg v | _ => Reg "") + (n + 2 + LENGTH c1)] ++ c1 ++ + [Jmp (n + 2 + LENGTH c1 + LENGTH c2)] ++ c2) /\ + (pass3_aux n (For e1 e2 t) b = + let c1 = pass3_aux n t 0 in + let c2 = pass3_aux n t (n + 1 + LENGTH c1) in + c2 ++ [Jmp n])` + +val pass3_def = Define ` + pass3 t = pass3_aux 0 t 0 ++ [Halt]`; + +val LENGTH_pass3_aux = prove( + ``!t n b. LENGTH (pass3_aux n t b) = LENGTH (pass3_aux 0 t 0)``, + Induct \\ fs [pass3_aux_def,LET_DEF]); + +val pass3_subset_def = Define ` + (pass3_subset (Dec v t) = F) /\ + (pass3_subset (Exp e) <=> + (?v x. e = Assign v (Var x)) \/ + (?v i. e = Assign v (Num i)) \/ + (?v x y. e = Assign v (Add (Var x) (Var y)))) /\ + (pass3_subset Break = T) /\ + (pass3_subset (Seq t1 t2) = (pass3_subset t1 /\ pass3_subset t2)) /\ + (pass3_subset (If e t1 t2) <=> + (?w. e = Var w) /\ pass3_subset t1 /\ pass3_subset t2) /\ + (pass3_subset (For e1 e2 t) = ((e1 = Num 1) /\ (e2 = Num 1) /\ pass3_subset t))` + +val instr_lookup_lemma = prove( + ``(x.pc = LENGTH xs) /\ (x.instrs = xs ++ [y] ++ ys) ==> + x.pc < LENGTH x.instrs /\ (EL x.pc x.instrs = y)``, + fs [DECIDE ``n < n + 1 + m:num``,rich_listTheory.EL_LENGTH_APPEND] + \\ FULL_SIMP_TAC std_ss [GSYM APPEND_ASSOC,APPEND] + \\ fs [rich_listTheory.EL_LENGTH_APPEND]); + +val EL_LENGTH_APPEND_LEMMA = + rich_listTheory.EL_LENGTH_APPEND + |> Q.SPECL [`[y] ++ ys`,`xs1++xs2`] + |> SIMP_RULE (srw_ss()) [] + +val EL_LEMMA = prove( + ``(LENGTH (xs1 ++ xs2 ++ xs3) = n) ==> + (EL n (xs1 ++ xs2 ++ xs3 ++ [y] ++ ys1 ++ ys2) = y)``, + Q.SPEC_TAC (`(xs1 ++ xs2 ++ xs3)`,`zs`) \\ SRW_TAC [] [] + \\ FULL_SIMP_TAC std_ss [GSYM APPEND_ASSOC,APPEND] + \\ fs [rich_listTheory.EL_LENGTH_APPEND]); + +val state_rel_def = Define ` + state_rel s x = (x.state = s)`; + +val pass3_aux_thm = store_thm("pass3_aux_thm", + ``!s1 t res s2 x xs ys b. + (sem_t s1 t = (res,s2)) /\ pass3_subset t /\ + state_rel s1 x /\ + (x.pc = LENGTH xs) /\ + (x.instrs = xs ++ pass3_aux (LENGTH xs) t b ++ ys) /\ + res <> Rfail /\ + (res = Rbreak ==> OMIT (LENGTH (xs ++ pass3_aux (LENGTH xs) t b) <= b)) ==> + ?x'. + (sem_a x = sem_a x') /\ + state_rel s2 x' /\ OMIT ( + (x'.instrs = x.instrs) /\ + (case res of + | Rfail => T + | Rbreak => (x'.pc = b) + | Rtimeout => (sem_a x' = (Rtimeout,x')) + | Rval v => (x'.pc = LENGTH (xs ++ pass3_aux (LENGTH xs) t b))))``, + REWRITE_TAC [state_rel_def,OMIT_def] + \\ HO_MATCH_MP_TAC sem_t_ind \\ REPEAT STRIP_TAC \\ fs [pass3_subset_def] + THEN1 (* Exp 1 *) + (fs [pass3_aux_def,sem_t_def] \\ rfs [] + \\ Cases_on `v = x'` \\ fs [] THEN1 + (fs [sem_e_def] + \\ Cases_on `FLOOKUP s1.store x'` \\ fs [] \\ SRW_TAC [] [] + \\ Q.EXISTS_TAC `x` \\ fs [store_var_def,state_component_equality] + \\ fs [FLOOKUP_DEF,fmap_EXT,FAPPLY_FUPDATE_THM] + \\ SRW_TAC [] [] \\ fs [EXTENSION] \\ METIS_TAC []) + \\ SIMP_TAC std_ss [Once sem_a_def] + \\ FULL_SIMP_TAC std_ss [GSYM APPEND_ASSOC,APPEND] + \\ imp_res_tac (instr_lookup_lemma |> REWRITE_RULE [GSYM APPEND_ASSOC,APPEND]) + \\ fs [LET_DEF,rich_listTheory.EL_LENGTH_APPEND] + \\ fs [sem_e_def] \\ SRW_TAC [] [] + \\ Cases_on `FLOOKUP x.state.store x'` \\ fs [] \\ SRW_TAC [] [] + \\ SIMP_TAC std_ss [Once sem_a_def] + \\ fs [inc_pc_def,DECIDE ``n + 1 < n + 2 + m:num``] + \\ FULL_SIMP_TAC std_ss [GSYM APPEND_ASSOC,APPEND, + rich_listTheory.EL_LENGTH_APPEND + |> Q.SPECL [`y::ys`,`xs ++ [x]`] + |> SIMP_RULE (srw_ss()) [] + |> SIMP_RULE std_ss [APPEND,GSYM APPEND_ASSOC]] + \\ fs [sem_e_def,store_var_def,FLOOKUP_DEF,FAPPLY_FUPDATE_THM,LET_DEF] + \\ Q.EXISTS_TAC `(x with + <|state := + x.state with store := x.state.store |+ (v,x''); + pc := LENGTH xs + 1 + 1|>)` + \\ fs [GSYM ADD_ASSOC]) + THEN1 (* Exp 2 *) + (fs [pass3_aux_def,sem_t_def] \\ rfs [] + \\ SIMP_TAC std_ss [Once sem_a_def] + \\ FULL_SIMP_TAC std_ss [GSYM APPEND_ASSOC,APPEND] + \\ imp_res_tac (instr_lookup_lemma |> REWRITE_RULE [GSYM APPEND_ASSOC,APPEND]) + \\ fs [LET_DEF,rich_listTheory.EL_LENGTH_APPEND] + \\ fs [sem_e_def] \\ SRW_TAC [] [] + \\ Q.EXISTS_TAC `(inc_pc (x with state := store_var v i x.state))` + \\ fs [inc_pc_def]) + THEN1 (* Exp 2 *) + (fs [pass3_aux_def,sem_t_def] \\ rfs [] + \\ SIMP_TAC std_ss [Once sem_a_def] + \\ FULL_SIMP_TAC std_ss [GSYM APPEND_ASSOC,APPEND] + \\ imp_res_tac (instr_lookup_lemma |> REWRITE_RULE [GSYM APPEND_ASSOC,APPEND]) + \\ fs [LET_DEF,rich_listTheory.EL_LENGTH_APPEND] + \\ fs [sem_e_def] \\ SRW_TAC [] [] + \\ ect \\ fs [] \\ SRW_TAC [] [] + \\ Q.EXISTS_TAC `(inc_pc (x with state := store_var v (i'' + i') x.state))` + \\ fs [inc_pc_def]) + THEN1 (* Break *) + (fs [sem_t_def] \\ SRW_TAC [] [] \\ fs [pass3_aux_def,LET_DEF] + \\ SIMP_TAC std_ss [Once sem_a_def] + \\ imp_res_tac instr_lookup_lemma \\ fs [LET_DEF] + \\ fs [do_jump_def] + \\ `b > LENGTH xs` by DECIDE_TAC \\ fs [] + \\ Q.EXISTS_TAC `x with pc := b` + \\ fs [] \\ fs [state_component_equality]) + THEN1 (* Seq *) + (fs [sem_t_def] \\ SRW_TAC [] [] \\ fs [pass3_aux_def,LET_DEF] + \\ Cases_on `sem_t x.state t` \\ fs [] + \\ FIRST_X_ASSUM (MP_TAC o Q.SPECL [`x`,`xs`, + `pass3_aux (LENGTH xs + LENGTH (pass3_aux (LENGTH (xs:instr list)) t b)) t' b + ++ ys`,`b`]) \\ fs [] + \\ MATCH_MP_TAC IMP_IMP \\ STRIP_TAC + THEN1 (Cases_on `q` \\ fs [] \\ SRW_TAC [] [] \\ DECIDE_TAC) + \\ REPEAT STRIP_TAC \\ fs [] + \\ Q.MATCH_ASSUM_RENAME_TAC `x2.state = r` + \\ REVERSE (Cases_on `q`) \\ fs [] \\ SRW_TAC [] [] + \\ TRY (Q.EXISTS_TAC `x2` \\ fs [] \\ NO_TAC) + \\ FIRST_X_ASSUM (MP_TAC o Q.SPECL [`x2`,`xs ++ pass3_aux (LENGTH xs) t b`, + `ys`,`b`]) \\ fs [] + \\ MATCH_MP_TAC IMP_IMP \\ STRIP_TAC + THEN1 (REPEAT STRIP_TAC \\ fs [] \\ DECIDE_TAC) + \\ REPEAT STRIP_TAC + \\ Q.MATCH_ASSUM_RENAME_TAC `x3.state = s2` + \\ Q.EXISTS_TAC `x3` \\ fs [] + \\ fs [ADD_ASSOC]) + THEN1 (* If *) + (fs [pass3_aux_def,sem_t_def] + \\ SIMP_TAC std_ss [Once sem_a_def] \\ fs [LET_DEF] + \\ FULL_SIMP_TAC std_ss [GSYM APPEND_ASSOC] + \\ imp_res_tac (instr_lookup_lemma |> REWRITE_RULE [GSYM APPEND_ASSOC]) + \\ rfs [] \\ POP_ASSUM (K ALL_TAC) + \\ REVERSE (Cases_on `sem_e s1 (Var w)`) \\ fs [] + \\ REVERSE (Cases_on `q`) \\ fs [] + \\ SRW_TAC [] [] \\ fs [sem_e_break] + \\ REPEAT (POP_ASSUM MP_TAC) + \\ ONCE_REWRITE_TAC [LENGTH_pass3_aux] \\ fs [] + \\ REPEAT STRIP_TAC + \\ Q.ABBREV_TAC `gg = (LENGTH xs + 2 + LENGTH (pass3_aux 0 t1 0) + + LENGTH (pass3_aux 0 t2 0))` + THEN1 (* false case *) + (FIRST_X_ASSUM (MP_TAC o Q.SPECL [`(inc_pc (x with state := r))`, + `xs ++ [JmpIf (Reg w) (LENGTH (xs:instr list) + 2 + LENGTH (pass3_aux 0 t1 0))]`, + `[Jmp gg] ++ pass3_aux (LENGTH (xs:instr list) + 2 + LENGTH (pass3_aux 0 t1 0)) + t2 b ++ ys`,`b`]) \\ fs [] + \\ MATCH_MP_TAC IMP_IMP \\ STRIP_TAC + THEN1 (fs [inc_pc_def] \\ REPEAT STRIP_TAC \\ fs [] \\ DECIDE_TAC) + \\ REPEAT STRIP_TAC \\ fs [] + \\ Q.MATCH_ASSUM_RENAME_TAC `x2.state = s2` + \\ REVERSE (Cases_on `res`) \\ fs [] + \\ TRY (Q.EXISTS_TAC `x2` \\ fs [] \\ NO_TAC) + \\ SIMP_TAC std_ss [Once sem_a_def] \\ fs [LET_DEF] + \\ `LENGTH xs + 1 + LENGTH (pass3_aux 0 t1 0) < + LENGTH xs + 1 + LENGTH (pass3_aux (LENGTH xs + 1) t1 b) + 1 + + LENGTH (pass3_aux (LENGTH xs + 2 + LENGTH (pass3_aux 0 t1 0)) t2 b) + + LENGTH ys /\ + (EL (LENGTH xs + 1 + LENGTH (pass3_aux 0 t1 0)) + (xs ++ [JmpIf (Reg w) (LENGTH xs + 2 + LENGTH (pass3_aux 0 t1 0))] ++ + pass3_aux (LENGTH xs + 1) t1 b ++ [Jmp gg] ++ + pass3_aux (LENGTH xs + 2 + LENGTH (pass3_aux 0 t1 0)) t2 b ++ ys) = + Jmp gg)` by ALL_TAC THEN1 + (ONCE_REWRITE_TAC [LENGTH_pass3_aux] \\ fs [] + \\ REPEAT STRIP_TAC THEN1 DECIDE_TAC + \\ MATCH_MP_TAC EL_LEMMA + \\ fs [] \\ ONCE_REWRITE_TAC [LENGTH_pass3_aux] \\ fs []) + \\ fs [do_jump_def] + \\ UNABBREV_ALL_TAC + \\ SRW_TAC [] [] + \\ TRY (`F` by DECIDE_TAC) + \\ Q.EXISTS_TAC `(x2 with pc := + LENGTH xs + 2 + LENGTH (pass3_aux 0 t1 0) + LENGTH (pass3_aux 0 t2 0))` + \\ fs [AC ADD_COMM ADD_ASSOC,ADD1] \\ DECIDE_TAC) + (* true case *) + \\ fs [do_jump_def,DECIDE ``n + 2 + m > n:num``] + \\ FIRST_X_ASSUM (MP_TAC o Q.SPECL [ + `(x with <|state := r; pc := LENGTH (xs:instr list) + + 2 + LENGTH (pass3_aux 0 t1 0)|>)`, + `xs ++ [JmpIf (Reg w) (LENGTH xs + 2 + LENGTH (pass3_aux 0 t1 0))] ++ + pass3_aux (LENGTH xs + 1) t1 b ++ [Jmp gg]`, `ys`,`b`]) \\ fs [] + \\ MATCH_MP_TAC IMP_IMP \\ STRIP_TAC THEN1 + (fs [AC ADD_COMM ADD_ASSOC,DECIDE ``1+(1+n) = 2 + n:num``] + \\ ONCE_REWRITE_TAC [LENGTH_pass3_aux] \\ fs [] + \\ REPEAT STRIP_TAC \\ fs [] \\ DECIDE_TAC) + \\ REPEAT STRIP_TAC \\ fs [] + \\ Q.MATCH_ASSUM_RENAME_TAC `x2.state = s2` + \\ REPEAT (POP_ASSUM MP_TAC) + \\ ONCE_REWRITE_TAC [LENGTH_pass3_aux] \\ fs [] + \\ REPEAT STRIP_TAC + \\ Q.EXISTS_TAC `x2` \\ fs [] + \\ fs [AC ADD_COMM ADD_ASSOC,DECIDE ``1+(1+n) = 2 + n:num``,ADD1] + \\ Cases_on `res` \\ fs []) + THEN1 (* For *) + (fs [sem_e_def] \\ SRW_TAC [] [] + \\ Q.PAT_ASSUM `sem_t x.state (For (Num 1) (Num 1) t) = (res,s2)` MP_TAC + \\ SIMP_TAC (srw_ss()) [sem_t_def_with_stop,sem_e_def] + \\ SIMP_TAC std_ss [STOP_def] + \\ Cases_on `sem_t x.state t` \\ fs [pass3_aux_def,LET_DEF] + \\ STRIP_TAC + \\ FIRST_X_ASSUM (MP_TAC o Q.SPECL [`x`,`xs`, + `[Jmp (LENGTH (xs:instr list))] ++ ys`,`(LENGTH (xs:instr list) + 1 + + LENGTH (pass3_aux (LENGTH (xs:instr list)) t 0))`]) \\ fs [] + \\ ONCE_REWRITE_TAC [LENGTH_pass3_aux] \\ fs [] + \\ MATCH_MP_TAC IMP_IMP \\ STRIP_TAC + THEN1 (REPEAT STRIP_TAC \\ fs []) + \\ REPEAT STRIP_TAC \\ fs [] + \\ Q.MATCH_ASSUM_RENAME_TAC `x2.state = r` + \\ REVERSE (Cases_on `q`) \\ fs [] \\ SRW_TAC [] [] + \\ TRY (Q.EXISTS_TAC `x2` \\ fs [AC ADD_COMM ADD_ASSOC] \\ NO_TAC) + \\ SIMP_TAC std_ss [Once sem_a_def] + \\ `x2.pc < LENGTH x2.instrs` by + (fs [] \\ ONCE_REWRITE_TAC [LENGTH_pass3_aux] \\ fs [] \\ DECIDE_TAC) \\ fs [] + \\ `(EL (LENGTH xs + LENGTH (pass3_aux 0 t 0)) (xs ++ + pass3_aux (LENGTH xs) t (LENGTH xs + 1 + LENGTH (pass3_aux 0 t 0)) ++ + [Jmp (LENGTH xs)] ++ ys) = Jmp (LENGTH xs))` by + (`LENGTH (pass3_aux 0 t 0) = + LENGTH (pass3_aux (LENGTH (xs:instr list)) t + (LENGTH (xs:instr list) + 1 + LENGTH (pass3_aux 0 t 0)))` by + (fs [] \\ ONCE_REWRITE_TAC [LENGTH_pass3_aux] \\ fs []) + \\ POP_ASSUM (fn th => SIMP_TAC std_ss [Once th]) + \\ fs [EL_LENGTH_APPEND_LEMMA]) + \\ fs [do_jump_def,DECIDE ``~(n > n + k:num)``,LET_DEF] + \\ Cases_on `x2.state.clock = 0` \\ fs [] THEN1 + (SRW_TAC [] [] \\ fs [] + \\ Q.EXISTS_TAC `x2` \\ fs [] + \\ SIMP_TAC std_ss [EQ_SYM_EQ] \\ fs [] + \\ ONCE_REWRITE_TAC [sem_a_def] + \\ fs [do_jump_def,DECIDE ``~(n > n + k:num)``,LET_DEF]) + \\ Q.PAT_ASSUM `!x. bb` MP_TAC + \\ ONCE_REWRITE_TAC [LENGTH_pass3_aux] \\ fs [] + \\ REPEAT STRIP_TAC + \\ FIRST_X_ASSUM MATCH_MP_TAC + \\ fs [dec_clock_def] + \\ REPEAT STRIP_TAC \\ fs [] + \\ Q.PAT_ASSUM `xxx <= b` MP_TAC + \\ ONCE_REWRITE_TAC [LENGTH_pass3_aux] \\ fs [])) + |> REWRITE_RULE [state_rel_def,OMIT_def]; + +val pass3_correct = store_thm("pass3_correct", + ``!s1 t res s2 x xs ys b. + (sem_t s1 t = (res,s2)) /\ pass3_subset t /\ + (x.state = s1) /\ + (x.pc = 0) /\ + (x.instrs = pass3 t) /\ + res <> Rfail /\ res <> Rbreak ==> + ?res' x'. + (sem_a x = (res', x')) /\ + (x'.state = s2) /\ + (case res of + | Rval v => (res' = Rval 0) + | _ => (res' = res))``, + REPEAT STRIP_TAC + \\ MP_TAC (SPEC_ALL pass3_aux_thm + |> Q.INST [`xs`|->`[]`,`ys`|->`[Halt]`,`b`|->`0`]) + \\ fs [pass3_def] \\ REPEAT STRIP_TAC \\ fs [] + \\ Cases_on `res` \\ fs [rich_listTheory.EL_LENGTH_APPEND] + \\ SIMP_TAC std_ss [Once sem_a_def] + \\ fs [rich_listTheory.EL_LENGTH_APPEND]); + +val pass3_pres = store_thm("pass3_pres", + ``!t. semantics t <> Crash /\ pass3_subset t ==> + asm_semantics (pass3 t) = semantics t``, + REPEAT STRIP_TAC \\ fs [semantics_thm] + \\ REVERSE (SRW_TAC [] []) + THEN1 METIS_TAC [] + THEN1 + (fs [asm_semantics_def] + \\ REVERSE (`!c. ?s. sem_a (a_state (pass3 t) c) = (Rtimeout,s)` by ALL_TAC) + THEN1 (fs [] \\ SRW_TAC [] [] + \\ FIRST_X_ASSUM (MP_TAC o Q.SPEC `c`) \\ fs []) + \\ REPEAT STRIP_TAC + \\ POP_ASSUM (STRIP_ASSUME_TAC o Q.SPEC `c`) + \\ MP_TAC (Q.SPECL [`s_with_clock c`,`t`] pass3_correct) \\ fs [] + \\ REPEAT STRIP_TAC + \\ POP_ASSUM (MP_TAC o Q.SPEC `a_state (pass3 t) c`) + \\ fs [a_state_def] \\ REPEAT STRIP_TAC \\ fs []) + \\ fs [asm_semantics_def] + \\ MATCH_MP_TAC (METIS_PROVE [] ``b ==> ((if b then x else y) = x)``) + \\ Q.EXISTS_TAC `c` + \\ MP_TAC (Q.SPECL [`s_with_clock c`,`t`] pass3_correct) \\ fs [] + \\ REPEAT STRIP_TAC + \\ POP_ASSUM (MP_TAC o Q.SPEC `a_state (pass3 t) c`) + \\ fs [a_state_def] \\ REPEAT STRIP_TAC \\ fs []); + +(* the entire compiler *) + +val compile_def = Define ` + compile t = pass3 (pass2 (pass1 t))`; + +val pass2_subset_pass1 = prove( + ``!t. pass2_subset (pass1 t)``, + Induct \\ fs [pass1_def,pass2_subset_def,Loop_def]); + +val pass3_subset_comp_exp = prove( + ``!e n. pass3_subset (comp_exp e n)``, + Induct \\ fs [pass3_subset_def,comp_exp_def]); + +val pass3_subset_flatten_t = prove( + ``!t n. pass2_subset t ==> pass3_subset (flatten_t t n)``, + Induct \\ fs [pass2_subset_def,flatten_t_def,pass3_subset_def] + \\ fs [pass3_subset_comp_exp]); + +val pass3_subset_pass2_pass1 = prove( + ``!t. pass3_subset (pass2 (pass1 t))``, + fs [pass2_def] \\ REPEAT STRIP_TAC + \\ MATCH_MP_TAC pass3_subset_flatten_t + \\ fs [pass2_subset_pass1]); + +val compile_pres = store_thm("compile_pres", + ``!t. semantics t <> Crash ==> + (asm_semantics (compile t) = semantics t)``, + fs [compile_def] + \\ ONCE_REWRITE_TAC [GSYM pass1_pres] + \\ REPEAT STRIP_TAC + \\ IMP_RES_TAC pass2_pres + \\ fs [pass2_subset_pass1] + \\ POP_ASSUM (fn th => ONCE_REWRITE_TAC [GSYM th]) + \\ MATCH_MP_TAC pass3_pres + \\ fs [pass2_pres,pass2_subset_pass1,pass3_subset_pass2_pass1]); + +val syntax_ok_def = Define ` + syntax_ok t = type_t F {} t`; + +val compile_correct = store_thm("compile_correct", + ``!t. syntax_ok t ==> + (asm_semantics (compile t) = semantics t)``, + METIS_TAC [type_soundness,syntax_ok_def,compile_pres]); + +val _ = export_theory (); diff --git a/examples/fun-op-sem/impScript.sml b/examples/fun-op-sem/impScript.sml new file mode 100644 index 0000000000..bcd379bbba --- /dev/null +++ b/examples/fun-op-sem/impScript.sml @@ -0,0 +1,104 @@ + +open HolKernel Parse boolLib bossLib; +open stringLib integerTheory; +open lcsymtacs; +val ect = BasicProvers.EVERY_CASE_TAC; + +val _ = new_theory "imp"; + +val _ = temp_type_abbrev("vname",``:string``); + +val _ = Datatype ` + aexp = N int | V vname | Plus aexp aexp`; + +val _ = Datatype ` + bexp = Bc bool | Not bexp | And bexp bexp | Less aexp aexp`; + +val _ = Datatype ` + com = SKIP + | Assign vname aexp + | Seq com com + | If bexp com com + | While bexp com` + +val aval_def = Define ` + (aval (N n) s = n) /\ + (aval (V x) s = s x) /\ + (aval (Plus a1 a2) s = aval a1 s + aval a2 s)`; + +val bval_def = Define ` + (bval (Bc v) s = v) /\ + (bval (Not b) s = ~bval b s) /\ + (bval (And b1 b2) s = bval b1 s /\ bval b2 s) /\ + (bval (Less a1 a2) s = aval a1 s < aval a2 s)`; + +val STOP_def = Define `STOP x = x`; + +val cval_def = tDefine "cval" ` + (cval SKIP s (t:num) = SOME (s,t)) /\ + (cval (Assign x a) s t = SOME ((x =+ aval a s) s,t)) /\ + (cval (Seq c1 c2) s t = + case cval c1 s t of + | NONE => NONE + | SOME (s2,t2) => cval c2 s2 (if t < t2 then t else t2)) /\ + (cval (If b c1 c2) s t = + cval (if bval b s then c1 else c2) s t) /\ + (cval (While b c) s t = + if bval b s then + if t = 0 then NONE else cval (Seq c (STOP (While b c))) s (t - 1) + else SOME (s,t))` + (WF_REL_TAC `inv_image (measure I LEX measure com_size) + (\(c,s,t). (t,c))` + \\ SRW_TAC [] [] \\ DECIDE_TAC) + +val clock_bound = prove( + ``!c s t s' t'. (cval c s t = SOME (s',t')) ==> t' <= t``, + recInduct (theorem "cval_ind") + \\ REPEAT STRIP_TAC + \\ fs [cval_def] + \\ ect \\ fs [] + \\ DECIDE_TAC); + +val cval_def_with_stop = store_thm("cval_def_with_stop", + ``(cval SKIP s (t:num) = SOME (s,t)) /\ + (cval (Assign x a) s t = SOME ((x =+ aval a s) s,t)) /\ + (cval (Seq c1 c2) s t = + case cval c1 s t of + | NONE => NONE + | SOME (s2,t2) => cval c2 s2 t2) /\ + (cval (If b c1 c2) s t = + cval (if bval b s then c1 else c2) s t) /\ + (cval (While b c) s t = + if bval b s then + if t = 0 then NONE else cval (Seq c (STOP (While b c))) s (t - 1) + else SOME (s,t))``, + REPEAT STRIP_TAC \\ SIMP_TAC std_ss [Once cval_def] + \\ ect \\ imp_res_tac clock_bound \\ `r = t` by DECIDE_TAC \\ fs []); + +val cval_def = + save_thm("cval_def",REWRITE_RULE [STOP_def] cval_def_with_stop); + +val cval_ind = store_thm("cval_ind", + ``!P. + (!s t. P SKIP s t) /\ (!x a s t. P (Assign x a) s t) /\ + (!c1 c2 s t. + (!v s2 t2. + (cval c1 s t = SOME v) /\ (v = (s2,t2)) ==> P c2 s2 t2) /\ + P c1 s t ==> + P (Seq c1 c2) s t) /\ + (!b c1 c2 s t. + P (if bval b s then c1 else c2) s t ==> P (If b c1 c2) s t) /\ + (!b c s t. + (bval b s /\ t <> 0 ==> + P (Seq c (While b c)) s (t - 1)) ==> + P (While b c) s t) ==> + !v v1 v2. P v v1 v2``, + NTAC 2 STRIP_TAC \\ HO_MATCH_MP_TAC (theorem "cval_ind") + \\ REPEAT STRIP_TAC \\ fs [] + \\ FIRST_X_ASSUM MATCH_MP_TAC \\ fs [] + \\ REPEAT STRIP_TAC \\ fs [STOP_def] + \\ RES_TAC \\ imp_res_tac clock_bound + \\ Cases_on `t < t2` \\ fs [] + \\ `t = t2` by DECIDE_TAC \\ fs []); + +val _ = export_theory(); diff --git a/examples/fun-op-sem/non_det/Holmakefile b/examples/fun-op-sem/non_det/Holmakefile new file mode 100644 index 0000000000..a145d3a74a --- /dev/null +++ b/examples/fun-op-sem/non_det/Holmakefile @@ -0,0 +1,2 @@ +INCLUDES = .. +OPTIONS = QUIT_ON_FAILURE diff --git a/examples/fun-op-sem/non_det/funScript.sml b/examples/fun-op-sem/non_det/funScript.sml new file mode 100644 index 0000000000..b147e5d30e --- /dev/null +++ b/examples/fun-op-sem/non_det/funScript.sml @@ -0,0 +1,537 @@ +open HolKernel Parse boolLib bossLib; + +val _ = new_theory "fun"; + +open optionTheory pairTheory pred_setTheory finite_mapTheory stringTheory; +open llistTheory integerTheory; +open langTheory; +open lcsymtacs; + +val ect = BasicProvers.EVERY_CASE_TAC; + +val _ = temp_tight_equality (); + +(* The result of running a program. Rtimeout indicates an attempt to loop with + * no clock left. Rfail indicates an undeclared variable access or a Break not + * in a For. + *) +val _ = Datatype ` +r = Rval int + | Rbreak + | Rtimeout + | Rfail`; + +val r_distinct = fetch "-" "r_distinct"; +val r_11 = fetch "-" "r_11"; + +val _ = type_abbrev ("oracle", ``:(num -> 'a)``); + +val oracle_get_def = Define ` +oracle_get (f:'a oracle) = (f 0, f o ((+) 1))`; + +(* The state of the semantics. + * io_trace records all IO done. input is the input stream, and non_det_o is an + * oracle used to decide which subexpression of Add to evaluate first. + *) +val _ = Datatype ` +state = <| store : string |-> int; clock : num; io_trace : io_tag list; + input : char llist; non_det_o : bool oracle |>`; + +val state_component_equality = fetch "-" "state_component_equality"; + +val state_rw = Q.prove ( +`(!s c out n nd. <| store := s; clock := c; io_trace := out; input := n; non_det_o := nd |>.store = s) ∧ + (!s nd. (s with non_det_o := nd).store = s.store) ∧ + (!s. <| store := s.store; clock := s.clock; io_trace := s.io_trace; input := s.input; non_det_o := s.non_det_o |> = s)`, + rw [state_component_equality]); + +val permute_pair_def = Define ` +permute_pair oracle (x,y) = + let (switch, oracle') = oracle_get oracle in + ((if switch then (y,x) else (x,y)), oracle', switch)`; + +val unpermute_pair_def = Define ` +unpermute_pair (x,y) switch = + if switch then + (y,x) + else + (x,y)`; + +val sem_e_def = tDefine "sem_e" ` +(sem_e s (Var x) = + case FLOOKUP s.store x of + | NONE => (Rfail, s) + | SOME n => (Rval n, s)) ∧ +(sem_e s (Num num) = + (Rval num, s)) ∧ +(sem_e s (Add e1 e2) = + let ((fst_e, snd_e), nd_o, switch) = permute_pair s.non_det_o (e1, e2) in + case sem_e (s with non_det_o := nd_o) fst_e of + | (Rval fst_n, s1) => + (case sem_e s1 snd_e of + | (Rval snd_n, s2) => + let (n1, n2) = unpermute_pair (fst_n, snd_n) switch in + (Rval (n1 + n2), s2) + | r => r) + | r => r) ∧ +(sem_e s (Assign x e) = + case sem_e s e of + | (Rval n1, s1) => + (Rval n1, s1 with store := s1.store |+ (x, n1)) + | r => r) ∧ +(sem_e s Getchar = + let (v, rest) = getchar s.input in + (Rval v, s with <| input := rest; io_trace := s.io_trace ++ [Itag v] |>)) ∧ +(sem_e s (Putchar e) = + case sem_e s e of + | (Rval n1, s1) => (Rval n1, s1 with io_trace := s1.io_trace ++ [Otag n1]) + | r => r)` + (WF_REL_TAC `measure (e_size o SND)` >> + srw_tac [ARITH_ss] [] >> + fs [permute_pair_def, LET_THM, oracle_get_def] >> + ect >> + fs [] >> + srw_tac [ARITH_ss] []); + +val sem_e_ind = fetch "-" "sem_e_ind"; + +val sem_e_clock = Q.store_thm ("sem_e_clock", +`!s e r s'. sem_e s e = (r, s') ⇒ s.clock = s'.clock`, + ho_match_mp_tac sem_e_ind >> + rw [sem_e_def] >> + ect >> + fs [LET_THM, permute_pair_def, oracle_get_def, unpermute_pair_def, getchar_def] >> + rw [] >> + ect >> + fs [] >> + ect >> + fs [] >> + rw []); + +val sem_e_store = Q.prove ( +`!s e r s'. sem_e s e = (r, s') ⇒ FDOM s.store ⊆ FDOM s'.store`, + ho_match_mp_tac sem_e_ind >> + rw [sem_e_def] >> + ect >> + fs [SUBSET_DEF, LET_THM, permute_pair_def, oracle_get_def, unpermute_pair_def, getchar_def] >> + rw [] >> + ect >> + fs [] >> + ect >> + fs [] >> + rw [] >> + metis_tac []); + +val sem_e_res = Q.store_thm ("sem_e_res", +`!s e r s'. sem_e s e = (r, s') ⇒ r ≠ Rbreak ∧ r ≠ Rtimeout`, + ho_match_mp_tac sem_e_ind >> + rw [sem_e_def] >> + ect >> + fs [LET_THM, permute_pair_def, oracle_get_def, unpermute_pair_def, getchar_def] >> + rw [] >> + ect >> + fs [] >> + ect >> + fs [] >> + rw [] >> + metis_tac []); + +val check_clock_def = Define ` +check_clock s' s = + s' with clock := (if s'.clock ≤ s.clock then s'.clock else s.clock)`; + +val dec_clock_def = Define ` +dec_clock s = s with clock := s.clock - 1`; + +val dec_clock_store = Q.store_thm ("dec_clock_store[simp]", +`!s. (dec_clock s).store = s.store`, + rw [dec_clock_def]); + +val sem_t_def = tDefine "sem_t" ` +(sem_t s (Exp e) = sem_e s e) ∧ +(sem_t s (Dec x t) = + sem_t (s with store := s.store |+ (x, 0)) t) ∧ +(sem_t s Break = (Rbreak, s)) ∧ +(sem_t s (Seq t1 t2) = + case sem_t s t1 of + | (Rval _, s1) => + sem_t (check_clock s1 s) t2 + | r => r) ∧ +(sem_t s (If e t1 t2) = + case sem_e s e of + | (Rval n1, s1) => + if n1 = 0 then + sem_t s1 t2 + else + sem_t s1 t1 + | r => r) ∧ +(sem_t s (For e1 e2 t) = + case sem_e s e1 of + | (Rval n1, s1) => + if n1 = 0 then + (Rval 0, s1) + else + (case sem_t s1 t of + | (Rval _, s2) => + (case sem_e s2 e2 of + | (Rval _, s3) => + if s.clock ≠ 0 ∧ s3.clock ≠ 0 then + sem_t (dec_clock (check_clock s3 s)) (For e1 e2 t) + else + (Rtimeout, s3) + | r => r) + | (Rbreak, s2) => + (Rval 0, s2) + | r => r) + | r => r)` + (WF_REL_TAC `(inv_image (measure I LEX measure t_size) + (\(s,t). (s.clock,t)))` + \\ REPEAT STRIP_TAC \\ TRY DECIDE_TAC + \\ fs [check_clock_def, dec_clock_def, LET_THM] + \\ rw [] + \\ imp_res_tac sem_e_clock + \\ DECIDE_TAC); + +val sem_t_clock = Q.store_thm ("sem_t_clock", +`!s t r s'. sem_t s t = (r, s') ⇒ s'.clock ≤ s.clock`, + ho_match_mp_tac (fetch "-" "sem_t_ind") >> + reverse (rpt strip_tac) >> + pop_assum mp_tac >> + rw [Once sem_t_def] >> + ect >> + imp_res_tac sem_e_clock >> + fs [] >> + fs [check_clock_def, dec_clock_def, LET_THM] >> + TRY decide_tac >> + rfs [] >> + res_tac >> + decide_tac); + +val check_clock_id = Q.store_thm ("check_clock_id", +`!s s'. s.clock ≤ s'.clock ⇒ check_clock s s' = s`, + rw [check_clock_def, state_component_equality]); + +val STOP_def = Define ` + STOP x = x`; + +val sem_t_def_with_stop = Q.store_thm ("sem_t_def_with_stop", +`(sem_t s (Exp e) = sem_e s e) ∧ + (sem_t s (Dec x t) = sem_t (s with store := s.store |+ (x, 0)) t) ∧ + (sem_t s Break = (Rbreak, s)) ∧ + (sem_t s (Seq t1 t2) = + case sem_t s t1 of + | (Rval _, s1) => + sem_t s1 t2 + | r => r) ∧ + (sem_t s (If e t1 t2) = + case sem_e s e of + | (Rval n1, s1) => + if n1 = 0 then + sem_t s1 t2 + else + sem_t s1 t1 + | r => r) ∧ + (sem_t s (For e1 e2 t) = + case sem_e s e1 of + | (Rval n1, s1) => + if n1 = 0 then + (Rval 0, s1) + else + (case sem_t s1 t of + | (Rval _, s2) => + (case sem_e s2 e2 of + | (Rval _, s3) => + if s3.clock ≠ 0 then + sem_t (dec_clock s3) (STOP (For e1 e2 t)) + else + (Rtimeout, s3) + | r => r) + | (Rbreak, s2) => + (Rval 0, s2) + | r => r) + | r => r)`, + rpt strip_tac >> + rw [Once sem_t_def,STOP_def] >> + ect >> + fs [] >> + imp_res_tac sem_t_clock >> + fs [dec_clock_def, LET_THM, check_clock_id] >> + rpt (AP_TERM_TAC ORELSE AP_THM_TAC) >> + rw [state_component_equality] >> + rw [check_clock_def] >> + imp_res_tac sem_e_clock >> + fs [] >> + `F` by decide_tac); + +val sem_t_def = + save_thm("sem_t_def",REWRITE_RULE [STOP_def] sem_t_def_with_stop); + +val sem_t_ind = Q.store_thm ("sem_t_ind", +`∀P. + (∀s e. P s (Exp e)) ∧ + (∀s x t. P (s with store := s.store |+ (x,0)) t ⇒ P s (Dec x t)) ∧ + (∀s. P s Break) ∧ + (∀s t1 t2. + (∀v2 s1 v5. + sem_t s t1 = (v2,s1) ∧ v2 = Rval v5 ⇒ + P s1 t2) ∧ P s t1 ⇒ + P s (Seq t1 t2)) ∧ + (∀s e t1 t2. + (∀v2 s1 n1. + sem_e s e = (v2,s1) ∧ v2 = Rval n1 ∧ n1 = 0 ⇒ P s1 t2) ∧ + (∀v2 s1 n1. + sem_e s e = (v2,s1) ∧ v2 = Rval n1 ∧ n1 ≠ 0 ⇒ P s1 t1) ⇒ + P s (If e t1 t2)) ∧ + (∀s e1 e2 t. + (∀v2 s1 n1 v2' s2 n1' v2'' s3 n1''. + sem_e s e1 = (v2,s1) ∧ v2 = Rval n1 ∧ n1 ≠ 0 ∧ + sem_t s1 t = (v2',s2) ∧ v2' = Rval n1' ∧ + sem_e s2 e2 = (v2'',s3) ∧ v2'' = Rval n1'' ∧ + s3.clock ≠ 0 ⇒ + P (dec_clock s3) (For e1 e2 t)) ∧ + (∀v2 s1 n1. + sem_e s e1 = (v2,s1) ∧ v2 = Rval n1 ∧ n1 ≠ 0 ⇒ P s1 t) ⇒ + P s (For e1 e2 t)) ⇒ + ∀v v1. P v v1`, + ntac 2 strip_tac >> + ho_match_mp_tac (fetch "-" "sem_t_ind") >> + rw [] >> + first_x_assum match_mp_tac >> + rw [] >> + fs [] >> + res_tac >> + imp_res_tac sem_t_clock >> + imp_res_tac sem_e_clock >> + fs [dec_clock_def, check_clock_id, LET_THM] >> + first_x_assum match_mp_tac >> + decide_tac); + +val sem_t_store = Q.prove ( +`!s t r s'. sem_t s t = (r, s') ⇒ FDOM s.store ⊆ FDOM s'.store`, + ho_match_mp_tac sem_t_ind >> + rpt conj_tac >> + rpt gen_tac >> + DISCH_TAC >> + ONCE_REWRITE_TAC [sem_t_def] + >- (fs [sem_t_def] >> + metis_tac [sem_e_store]) + >- (fs [sem_t_def] >> + metis_tac []) + >- (fs [sem_t_def] >> + metis_tac []) + >- (ect >> + rw [] >> + metis_tac [sem_e_store, SUBSET_DEF]) + >- (ect >> + rw [] >> + metis_tac [sem_e_store, SUBSET_DEF]) + >- (Cases_on `sem_e s e1` >> + fs [] >> + Cases_on `q` >> + reverse (fs []) + >- (Cases_on `i = 0` >> + fs [] + >- metis_tac [sem_e_store, SUBSET_TRANS] >> + Cases_on `sem_t r t` >> + fs [] >> + Cases_on `q` >> + reverse (fs []) + >- (ect >> + fs [] >> + rw [] >> + rfs [] >> + metis_tac [sem_e_store, SUBSET_TRANS]) >> + metis_tac [sem_e_store, SUBSET_TRANS]) >> + metis_tac [sem_e_store, SUBSET_TRANS])); + +val sem_for_not_break = Q.store_thm ("sem_for_not_break", +`!s t' t e1 e2 s' r. + sem_t s t' = (r, s') ∧ + t' = For e1 e2 t + ⇒ + r ≠ Rbreak`, + ho_match_mp_tac sem_t_ind >> + reverse (rpt conj_tac) + >- (rw [] >> + rw [sem_t_def_with_stop] >> + ect >> + fs [] >> + imp_res_tac sem_e_res >> + fs [STOP_def]) >> + rw [sem_t_def_with_stop] >> + ect >> + fs [] >> + imp_res_tac sem_e_res >> + fs []); + +(* Define a top-level semantic function that maps programs and their input to + * their observable behaviours. + *) +val init_st_def = Define ` +init_st c nd i = + <| store := FEMPTY; clock := c; input := i; io_trace := []; non_det_o := nd |>`; + +(* There can be many observable behaviours because the semantics is + * non-deterministic *) +val semantics_def = Define ` +(semantics t input (Terminate io_trace) = + (* Terminate when there is a clock and some non-determinism oracle that gives a value result *) + ?c nd i s. + sem_t (init_st c nd input) t = (Rval i, s) ∧ + s.io_trace = io_trace) ∧ +(semantics t input Crash = + (* Crash when there is a clock that gives a non-value, non-timeout result *) + ?c nd r s. + sem_t (init_st c nd input) t = (r, s) ∧ + (r = Rbreak ∨ r = Rfail)) ∧ +(semantics t input (Diverge io_trace) = + (* Diverge when all clocks give timeout results. Ensure that the IO trace to + * the timeout point is a prefix of the whole trace. *) + ?nd. + (!c. ?s. + sem_t (init_st c nd input) t = (Rtimeout, s) ∧ + (!n. n < LENGTH s.io_trace ⇒ LNTH n io_trace = SOME (EL n s.io_trace))) ∧ + (* Check that the whole IO trace is reachable, but maybe not for just 1 + * clock value*) + (!n x. + LNTH n io_trace = SOME x ⇒ + ?c s. sem_t (init_st c nd input) t = (Rtimeout, s) ∧ + n < LENGTH s.io_trace ∧ EL n s.io_trace = x))`; + +(* A type soundness proof *) + +val type_permute_pair_lem = Q.prove ( +`!s s1 e1 e2 fst_e snd_e new_nd. + type_e s e1 ∧ + type_e s e2 ∧ + permute_pair s1.non_det_o (e1,e2) = ((fst_e,snd_e),new_nd) + ⇒ + type_e s fst_e ∧ + type_e s snd_e`, + rw [permute_pair_def, LET_THM, oracle_get_def] >> + rw []); + +val type_sound_e = Q.prove ( +`!s1 e s. + type_e s e ∧ s ⊆ FDOM s1.store + ⇒ + ?r s1'. + r ≠ Rfail ∧ + sem_e s1 e = (r, s1')`, + ho_match_mp_tac (fetch "-" "sem_e_ind") >> + rw [sem_e_def, type_e_def] + >- (ect >> + fs [FLOOKUP_DEF, SUBSET_DEF] >> + rw [] >> + metis_tac []) + >- (`?fst_e snd_e new_nd switch. permute_pair s1.non_det_o (e1, e2) = ((fst_e, snd_e), new_nd, switch)` + by metis_tac [pair_CASES] >> + fs [] >> + `type_e s fst_e ∧ type_e s snd_e` by metis_tac [type_permute_pair_lem] >> + res_tac >> + `type_e (FDOM s1''.store) snd_e` + by (rw [] >> + match_mp_tac type_weakening_e >> + metis_tac [sem_e_store, SUBSET_TRANS, state_rw]) >> + fs [] >> + Cases_on `r` >> + fs [] >> + first_x_assum (fn th => pop_assum (fn th' => assume_tac (MATCH_MP (SIMP_RULE (srw_ss()) [GSYM AND_IMP_INTRO] th) th'))) >> + fs [state_rw] >> + ect >> + rw [] >> + fs [SUBSET_DEF, unpermute_pair_def] >> + rw []) >> + fs [getchar_def] >> + ect >> + fs [LET_THM] >> + rw [] >> + metis_tac []); + +(* Have to use sem_t_ind, and not type_t_ind or t_induction. This is different + * than small-step-based type soundness *) +val type_sound_t = Q.prove ( +`!s1 t in_for s. + type_t in_for s t ∧ s ⊆ FDOM s1.store + ⇒ + ?r s1'. + r ≠ Rfail ∧ + (~in_for ⇒ r ≠ Rbreak) ∧ + sem_t s1 t = (r, s1')`, + ho_match_mp_tac sem_t_ind >> + rw [type_t_def] >> + ONCE_REWRITE_TAC [sem_t_def] >> + rw [] + >- (imp_res_tac type_sound_e >> + rw [state_rw] >> + metis_tac [sem_e_res]) + >- (res_tac >> + fs [SUBSET_DEF]) + >- (res_tac >> + rw [] >> + Cases_on `r'` >> + rw [] >> + fs [] >> + rw [] >> + pop_assum match_mp_tac >> + metis_tac [type_weakening_t, sem_t_store]) + >- (imp_res_tac type_sound_e >> + rw [state_rw] >> + rw [] >> + Cases_on `r` >> + fs [] + >- (Cases_on `i = 0` >> + fs [] >> + first_x_assum match_mp_tac >> + metis_tac [type_weakening_t, sem_e_store]) + >- metis_tac [sem_e_res]) + >- (imp_res_tac type_sound_e >> + rw [state_rw] >> + reverse (Cases_on `r'''`) >> + fs [] >> + Cases_on `i = 0` >> + fs [] >> + rw [] + >- metis_tac [sem_e_res] + >- metis_tac [sem_e_res] >> + rfs [] >> + `type_t T (FDOM s1''.store) t` + by (rw [] >> + match_mp_tac type_weakening_t >> + metis_tac [sem_e_store, sem_t_store, SUBSET_TRANS, state_rw]) >> + res_tac >> + fs [] >> + Cases_on `r'` >> + rw [] >> + fs [] >> + rw [] >> + `type_e (FDOM s1'''.store) e2` + by (rw [] >> + match_mp_tac type_weakening_e >> + metis_tac [sem_e_store, sem_t_store, SUBSET_TRANS, state_rw]) >> + imp_res_tac type_sound_e >> + first_x_assum (qspec_then `s1'''` mp_tac) >> + rw [] >> + rw [state_rw] >> + rw [] >> + Cases_on `r'''''` >> + rw [] >> + fs [] + >- (first_x_assum match_mp_tac >> + qexists_tac `s` >> + rw [] >> + imp_res_tac sem_e_store >> + imp_res_tac sem_t_store >> + metis_tac [SUBSET_TRANS]) >> + metis_tac [sem_e_res])); + +val type_soundness = Q.prove ( +`!t input. type_t F {} t ⇒ Crash ∉ semantics t input`, + rw [IN_DEF, semantics_def] >> + imp_res_tac type_sound_t >> + fs [] >> + first_x_assum (qspec_then `init_st c nd input` assume_tac) >> + fs [] >> + metis_tac []); + +val _ = export_theory (); diff --git a/examples/fun-op-sem/non_det/langScript.sml b/examples/fun-op-sem/non_det/langScript.sml new file mode 100644 index 0000000000..ae95c4e32b --- /dev/null +++ b/examples/fun-op-sem/non_det/langScript.sml @@ -0,0 +1,95 @@ +(* Define the syntax of a simple imperative language of For loops with IO and + * non-determinism. A simple type system ensures that all breaks are inside of + * for loops, and that no undeclared variables are accessed + *) + +open HolKernel Parse boolLib bossLib; + +val _ = new_theory "lang"; + +open pred_setTheory optionTheory stringTheory llistTheory integerTheory; +open lcsymtacs; + +val _ = temp_tight_equality (); +val ect = BasicProvers.EVERY_CASE_TAC; + +(* Expressions + * Evaluation order of Add is unspecified, but one subexpression must be + * completely evaluated before the other. + * Getchar returns -1 to signal the end of file. + *) +val _ = Datatype ` +e = Var string + | Num int + | Add e e + | Assign string e + | Getchar + | Putchar e`; + +(* Statements *) +val _ = Datatype ` +t = + | Dec string t + | Exp e + | Break + | Seq t t + | If e t t + | For e e t`; + +(* What is observable about program behaviour. It can terminate after doing a + * finite amount of I/O; it can diverge doing a potentially infinite amount of IO + * (llist is the lazy list type constructor of lists that can be either finite or + * infinite); or it can crash. We don't bother with the pre-crash IO because + * well-typed programs won't crash. + *) + +val _ = Datatype ` + io_tag = Itag int | Otag int`; + +val _ = Datatype ` + observation = Terminate (io_tag list) | Diverge (io_tag llist) | Crash`; + +val getchar_def = Define ` +getchar stream = + case LTL stream of + | NONE => (-1, stream) + | SOME rest => + let v = &(ORD (THE (LHD stream))) in + (v, rest)`; + +(* A simple type system to check for Break statements and variable accesses *) +val type_e_def = Define ` +(type_e s (Var x) ⇔ x ∈ s) ∧ +(type_e s (Num num) ⇔ T) ∧ +(type_e s (Add e1 e2) ⇔ type_e s e1 ∧ type_e s e2) ∧ +(type_e s (Assign x e) ⇔ x ∈ s ∧ type_e s e) ∧ +(type_e s Getchar ⇔ T) ∧ +(type_e s (Putchar e) ⇔ type_e s e)`; + +val type_t_def = Define ` +(type_t in_for s (Exp e) ⇔ type_e s e) ∧ +(type_t in_for s (Dec x t) ⇔ type_t in_for (x INSERT s) t) ∧ +(type_t in_for s Break ⇔ in_for) ∧ +(type_t in_for s (Seq t1 t2) ⇔ type_t in_for s t1 ∧ type_t in_for s t2) ∧ +(type_t in_for s (If e t1 t2) ⇔ type_e s e ∧ type_t in_for s t1 ∧ type_t in_for s t2) ∧ +(type_t in_for s (For e1 e2 t) ⇔ type_e s e1 ∧ type_e s e2 ∧ type_t T s t)`; + +val type_weakening_e = Q.store_thm ("type_weakening_e", +`!s e s' s1. type_e s e ∧ s ⊆ s1 ⇒ type_e s1 e`, + Induct_on `e` >> + rw [type_e_def, SUBSET_DEF] >> + ect >> + fs [] >> + rw [EXTENSION] >> + metis_tac [SUBSET_DEF, NOT_SOME_NONE, SOME_11]); + +val type_weakening_t = Q.store_thm ("type_weakening_t", +`!in_for s t s' s1. type_t in_for s t ∧ s ⊆ s1 ⇒ type_t in_for s1 t`, + Induct_on `t` >> + rw [type_t_def, SUBSET_DEF] >> + ect >> + fs [] >> + rw [EXTENSION] >> + metis_tac [SUBSET_DEF, NOT_SOME_NONE, SOME_11, type_weakening_e, INSERT_SUBSET]); + +val _ = export_theory (); diff --git a/examples/fun-op-sem/non_det/lang_compileScript.sml b/examples/fun-op-sem/non_det/lang_compileScript.sml new file mode 100644 index 0000000000..93e6be6d15 --- /dev/null +++ b/examples/fun-op-sem/non_det/lang_compileScript.sml @@ -0,0 +1,1020 @@ +open HolKernel Parse boolLib bossLib; + +val _ = new_theory "lang_compile"; + +open optionTheory pairTheory pred_setTheory finite_mapTheory stringTheory; +open lcsymtacs langTheory funTheory listTheory arithmeticTheory; + +val _ = temp_tight_equality (); + +val ect = BasicProvers.EVERY_CASE_TAC; + +val IMP_IMP = METIS_PROVE [] ``b /\ (b1 ==> b2) ==> ((b ==> b1) ==> b2)`` + +(* verification of PASS 1, which reduces complexity of For and removes Dec *) + +val sem_t_Dec = store_thm("sem_t_Dec", + ``sem_t s (Dec v t) = + sem_t s (Seq (Exp (Assign v (Num 0))) t)``, + fs [sem_t_def,sem_e_def]); + +val sem_t_pull_if = prove( + ``sem_t s1 (if b then t1 else t2) = + (if b then sem_t s1 t1 else sem_t s1 t2)``, + SRW_TAC [] []); + +val sem_t_eval = save_thm("sem_t_eval", + (EVAL THENC REWRITE_CONV [sem_t_pull_if] THENC EVAL) + ``sem_t s (If b (Exp (Num 0)) Break)``); + +val Loop_def = Define ` + Loop t = For (Num 1) (Num 1) t`; + +val sem_t_Loop = save_thm("sem_t_Loop", + ``sem_t s (Loop t)`` + |> (SIMP_CONV (srw_ss()) [Once sem_t_def,sem_e_def,Loop_def] THENC + REWRITE_CONV [GSYM Loop_def])); + +val sem_e_break = prove( + ``!b1 s. ~(sem_e s b1 = (Rbreak,r)) /\ ~(sem_e s b1 = (Rtimeout,r))``, + Induct \\ REPEAT STRIP_TAC + \\ fs [sem_e_def,permute_pair_def,LET_DEF,oracle_get_def, + unpermute_pair_def,getchar_def] + \\ ect \\ fs [] \\ rfs [] \\ ect \\ fs [] \\ rfs []); + +val sem_t_For_swap_body = prove( + ``(!s. sem_t s t1 = sem_t s t2) ==> + (sem_t s (For b1 b2 t1) = sem_t s (For b1 b2 t2))``, + STRIP_TAC + \\ completeInduct_on `s.clock` + \\ rw [sem_t_def_with_stop,sem_e_def,Once sem_t_Loop] + \\ ect \\ fs [PULL_FORALL,STOP_def] + \\ FIRST_X_ASSUM MATCH_MP_TAC + \\ fs [dec_clock_def] + \\ imp_res_tac sem_e_clock + \\ imp_res_tac sem_t_clock + \\ decide_tac); + +val sem_t_For = store_thm("sem_t_For", + ``!s b1 b2 t. sem_t s (For b1 b2 t) = + sem_t s (Loop (If b1 (Seq t (Exp b2)) Break))``, + REPEAT STRIP_TAC + \\ completeInduct_on `s.clock` + \\ rw [sem_t_def_with_stop,sem_e_def,Once sem_t_Loop] + \\ Cases_on `sem_e s b1` \\ fs [] + \\ Cases_on `q` \\ fs [] + \\ SRW_TAC [] [sem_t_def_with_stop] + \\ Cases_on `sem_t r t` \\ fs [] + \\ Cases_on `q` \\ fs [] + \\ Cases_on `sem_e r' b2` \\ fs [] + \\ Cases_on `q` \\ fs [] + \\ SRW_TAC [] [] + \\ fs [sem_e_break] + \\ fs [PULL_FORALL,STOP_def] + \\ FIRST_X_ASSUM MATCH_MP_TAC + \\ fs [dec_clock_def] + \\ imp_res_tac sem_e_clock + \\ imp_res_tac sem_t_clock + \\ decide_tac); + +val pass1_def = Define ` + (pass1 (Exp e) = Exp e) /\ + (pass1 (Dec x t) = Seq (Exp (Assign x (Num 0))) (pass1 t)) /\ + (pass1 (Break) = Break) /\ + (pass1 (Seq t1 t2) = Seq (pass1 t1) (pass1 t2)) /\ + (pass1 (If e t1 t2) = If e (pass1 t1) (pass1 t2)) /\ + (pass1 (For e1 e2 t) = Loop (If e1 (Seq (pass1 t) (Exp e2)) Break))`; + +val pass1_correct = store_thm("pass1_correct", + ``!t s. sem_t s (pass1 t) = sem_t s t``, + Induct \\ fs [pass1_def,sem_t_def_with_stop,GSYM sem_t_For,GSYM sem_t_Dec] + \\ REPEAT STRIP_TAC \\ ect \\ fs [STOP_def] + \\ MATCH_MP_TAC sem_t_For_swap_body \\ fs []); + +val pass1_pres = store_thm("pass1_pres", + ``!t. semantics (pass1 t) = semantics t``, + REPEAT STRIP_TAC \\ fs [FUN_EQ_THM] \\ Cases_on `x'` + \\ fs [semantics_def,pass1_correct]); + + +(* verification of PASS 2, which flattens all expressions *) + +val comp_exp_def = Define ` + (comp_exp (Var v) s = Exp (Assign s (Var v))) /\ + (comp_exp (Num i) s = Exp (Assign s (Num i))) /\ + (comp_exp (Assign v e) s = + (Seq (comp_exp e s) (Exp (Assign v (Var s))))) /\ + (comp_exp Getchar s = Exp (Assign s Getchar)) /\ + (comp_exp (Putchar x) s = + Seq (comp_exp x s) (Exp (Putchar (Var s)))) /\ + (comp_exp (Add x y) s = + (Seq (comp_exp x s) + (Seq (comp_exp y (s++"'")) + (Exp (Assign s (Add (Var s) (Var (s++"'"))))))))`; + +val flatten_t_def = Define ` + (flatten_t (Exp e) n = comp_exp e n) /\ + (flatten_t (Dec x t) n = t) /\ + (flatten_t (Break) n = Break) /\ + (flatten_t (Seq t1 t2) n = Seq (flatten_t t1 n) (flatten_t t2 n)) /\ + (flatten_t (For e1 e2 t) n = For e1 e2 (flatten_t t n)) /\ + (flatten_t (If e t1 t2) n = + Seq (comp_exp e n) (If (Var n) (flatten_t t1 n) (flatten_t t2 n)))`; + +val MAX_def = Define `MAX n m = if n < m then m else n:num` + +val exp_max_def = Define ` + (exp_max (Var v) = LENGTH v) /\ + (exp_max (Putchar e) = exp_max e) /\ + (exp_max (Add x y) = MAX (exp_max x) (exp_max y)) /\ + (exp_max (Assign v e) = MAX (LENGTH v) (exp_max e)) /\ + (exp_max _ = 0)`; + +val t_max_def = Define ` + (t_max (Exp e) = exp_max e) /\ + (t_max (Dec x t) = MAX (LENGTH x) (t_max t)) /\ + (t_max (Break) = 0) /\ + (t_max (Seq t1 t2) = MAX (t_max t1) (t_max t2)) /\ + (t_max (For e1 e2 t) = MAX (exp_max e1) (MAX (exp_max e2) (t_max t))) /\ + (t_max (If e t1 t2) = MAX (exp_max e) (MAX (t_max t1) (t_max t2)))`; + +val pass2_def = Define ` + pass2 t = flatten_t t ("temp" ++ REPLICATE (t_max t - 3) #"'")`; + +val possible_var_name_def = Define ` + possible_var_name v s = !n. ~(v ++ REPLICATE n #"'" IN FDOM s)`; + +val possible_var_name_IMP_SUBMAP = prove( + ``possible_var_name n s.store /\ s.store SUBMAP t.store ==> + s.store SUBMAP t.store |+ (n,i)``, + fs [FLOOKUP_DEF,SUBMAP_DEF,FAPPLY_FUPDATE_THM] + \\ fs [possible_var_name_def] \\ REPEAT STRIP_TAC + \\ SRW_TAC [] [] \\ fs [] + \\ METIS_TAC [APPEND_NIL,rich_listTheory.REPLICATE]); + +val MAX_LESS = prove( + ``MAX n m < k <=> n < k /\ m < k``, + SRW_TAC [] [MAX_def] \\ DECIDE_TAC); + +val store_var_def = Define ` + store_var v x s = s with store := s.store |+ (v,x)`; + +val sem_e_def = sem_e_def |> REWRITE_RULE [GSYM store_var_def] + +val sem_e_possible_var_name = prove( + ``!e s i r. + (sem_e s e = (Rval i,r)) /\ exp_max e < STRLEN k ==> + possible_var_name k s.store ==> + possible_var_name k r.store``, + Induct \\ fs [sem_e_def] \\ REPEAT STRIP_TAC \\ ect \\ fs [] + THEN1 + (fs [permute_pair_def] + \\ Cases_on `oracle_get s.non_det_o` \\ fs [LET_DEF] + \\ Cases_on `q` \\ fs [] + THEN1 + (FIRST_X_ASSUM (MP_TAC o Q.SPEC `s with non_det_o := r'`) + \\ Cases_on `sem_e (s with non_det_o := r') e'` \\ fs [] + \\ FIRST_X_ASSUM (MP_TAC o Q.SPEC `r''`) + \\ ect \\ fs [exp_max_def,MAX_LESS,unpermute_pair_def]) + \\ Q.PAT_ASSUM `!x. bbb` MP_TAC + \\ FIRST_X_ASSUM (MP_TAC o Q.SPEC `s with non_det_o := r'`) + \\ Cases_on `sem_e (s with non_det_o := r') e` \\ fs [] + \\ REPEAT STRIP_TAC + \\ FIRST_X_ASSUM (MP_TAC o Q.SPEC `r'':state`) + \\ ect \\ fs [exp_max_def,MAX_LESS,unpermute_pair_def]) + \\ SRW_TAC [] [] \\ fs [exp_max_def,MAX_LESS,getchar_def] + \\ ect \\ fs [LET_DEF] \\ SRW_TAC [] [] + \\ FIRST_X_ASSUM (fn th => MP_TAC (Q.SPEC `s'` th) THEN + MP_TAC (Q.SPEC `s` th)) \\ fs [] + \\ fs [store_var_def,possible_var_name_def] + \\ REPEAT STRIP_TAC \\ SRW_TAC [] [] + \\ fs [] \\ DECIDE_TAC); + +val comp_exp_correct = prove( + ``!e s t n res s1. + sem_e s e = (res,s1) /\ res <> Rfail /\ + possible_var_name n s.store /\ + s.store SUBMAP t.store /\ (t.clock = s.clock) /\ + (s.non_det_o = K F) /\ + (s.io_trace = t.io_trace) /\ + (s.input = t.input) /\ + exp_max e < LENGTH n ==> + ?t1. (sem_t t (comp_exp e n) = (res,t1)) /\ + s1.store SUBMAP t1.store /\ (t1.clock = s1.clock) /\ + (s1.non_det_o = K F) /\ + (s1.io_trace = t1.io_trace) /\ + (s1.input = t1.input) /\ + (!v. (res = Rval v) ==> FLOOKUP t1.store n = SOME v) /\ + possible_var_name n s1.store /\ + (!k v. possible_var_name k s.store /\ + exp_max e < LENGTH k /\ LENGTH k < LENGTH n /\ + FLOOKUP t.store k = SOME v ==> + FLOOKUP t1.store k = SOME v)``, + Induct \\ fs [sem_e_def,comp_exp_def,sem_t_def,store_var_def] + \\ REPEAT STRIP_TAC + THEN1 + (Cases_on `FLOOKUP s'.store s` \\ fs [] \\ SRW_TAC [] [] + \\ IMP_RES_TAC FLOOKUP_SUBMAP \\ fs [] + \\ IMP_RES_TAC possible_var_name_IMP_SUBMAP \\ fs [] + \\ fs [FLOOKUP_DEF,SUBMAP_DEF,FAPPLY_FUPDATE_THM] + \\ SRW_TAC [] []) + \\ TRY (IMP_RES_TAC possible_var_name_IMP_SUBMAP \\ fs [] + \\ fs [FLOOKUP_DEF,SUBMAP_DEF,FAPPLY_FUPDATE_THM] + \\ SRW_TAC [] [] \\ fs [] \\ NO_TAC) + THEN1 + (fs [permute_pair_def,oracle_get_def,LET_DEF,unpermute_pair_def] + \\ `(s with non_det_o := K F) = s` by + (fs [state_component_equality]) \\ fs [] \\ POP_ASSUM (K ALL_TAC) + \\ Cases_on `sem_e s e` \\ Cases_on `q` \\ fs [sem_e_break] + \\ Cases_on `sem_e r e'` \\ Cases_on `q` \\ fs [sem_e_break] + \\ fs [exp_max_def] + \\ FIRST_X_ASSUM (MP_TAC o Q.SPEC `r`) + \\ FIRST_X_ASSUM (MP_TAC o Q.SPECL [`s`,`t`,`n`]) + \\ `exp_max e < STRLEN n /\ + exp_max e' < STRLEN n /\ + exp_max e' < STRLEN (STRCAT n "'")` by + (fs [MAX_LESS] \\ DECIDE_TAC) + \\ fs [] \\ REPEAT STRIP_TAC \\ fs [] + \\ POP_ASSUM (MP_TAC o Q.SPECL [`t1`,`STRCAT n "'"`]) + \\ `possible_var_name (STRCAT n "'") r.store` by ALL_TAC THEN1 + (fs [possible_var_name_def] + \\ REPEAT STRIP_TAC + \\ FIRST_X_ASSUM (MP_TAC o Q.SPEC `SUC n'`) + \\ FULL_SIMP_TAC std_ss [rich_listTheory.REPLICATE, + APPEND,GSYM APPEND_ASSOC]) + \\ fs [] \\ REPEAT STRIP_TAC \\ fs [] + \\ Q.MATCH_ASSUM_RENAME_TAC `s1.store SUBMAP t2.store` + \\ `FLOOKUP t2.store n = SOME i` by (FIRST_X_ASSUM MATCH_MP_TAC \\ fs []) + \\ fs [] \\ SRW_TAC [] [] + \\ fs [sem_e_def,AC integerTheory.INT_ADD_ASSOC integerTheory.INT_ADD_COMM] + \\ `possible_var_name n r'.store` by + IMP_RES_TAC sem_e_possible_var_name + \\ REPEAT STRIP_TAC + \\ TRY (MATCH_MP_TAC possible_var_name_IMP_SUBMAP \\ fs [] \\ NO_TAC) + \\ fs [FLOOKUP_DEF,FAPPLY_FUPDATE_THM] + \\ Cases_on `k = n` \\ fs [] + \\ `v = t1.store ' k` by (SRW_TAC [] [] \\ METIS_TAC [MAX_LESS]) + \\ POP_ASSUM (fn th => SIMP_TAC std_ss [th]) + \\ FIRST_X_ASSUM MATCH_MP_TAC + \\ fs [MAX_LESS] \\ REPEAT STRIP_TAC + \\ IMP_RES_TAC sem_e_possible_var_name \\ DECIDE_TAC) + THEN1 + (FIRST_X_ASSUM (MP_TAC o Q.SPEC `s'`) + \\ Cases_on `sem_e s' e` \\ Cases_on `q` \\ fs [sem_e_break] + \\ SRW_TAC [] [] \\ fs [exp_max_def,MAX_LESS] + \\ FIRST_X_ASSUM (MP_TAC o Q.SPECL [`t`,`n`]) + \\ fs [] \\ REPEAT STRIP_TAC \\ fs [] + \\ REPEAT STRIP_TAC + \\ fs [SUBMAP_DEF,FAPPLY_FUPDATE_THM,FLOOKUP_DEF] + \\ REPEAT STRIP_TAC \\ fs [] + \\ SRW_TAC [] [] \\ fs [] + \\ fs [possible_var_name_def] + \\ REPEAT STRIP_TAC + \\ SRW_TAC [] [] \\ fs [] \\ DECIDE_TAC) + THEN1 + (fs [] \\ Cases_on `getchar t.input` \\ fs [LET_DEF] + \\ SRW_TAC [] [] \\ fs [] + \\ IMP_RES_TAC possible_var_name_IMP_SUBMAP \\ fs [] + \\ fs [FLOOKUP_DEF,SUBMAP_DEF,FAPPLY_FUPDATE_THM] + \\ SRW_TAC [] [] \\ fs []) + THEN1 + (FIRST_X_ASSUM (MP_TAC o Q.SPEC `s`) + \\ Cases_on `sem_e s e` \\ Cases_on `q` \\ fs [sem_e_break] + \\ SRW_TAC [] [] \\ fs [exp_max_def,MAX_LESS] + \\ FIRST_X_ASSUM (MP_TAC o Q.SPECL [`t`,`n`]) + \\ fs [] \\ REPEAT STRIP_TAC \\ fs [] + \\ REPEAT STRIP_TAC + \\ fs [SUBMAP_DEF,FAPPLY_FUPDATE_THM,FLOOKUP_DEF])); + +val pass2_subset_def = Define ` + (pass2_subset (Dec v t) = F) /\ + (pass2_subset (Exp e) = T) /\ + (pass2_subset Break = T) /\ + (pass2_subset (Seq t1 t2) = (pass2_subset t1 /\ pass2_subset t2)) /\ + (pass2_subset (If e t1 t2) = (pass2_subset t1 /\ pass2_subset t2)) /\ + (pass2_subset (For e1 e2 t) = ((e1 = Num 1) /\ (e2 = Num 1) /\ + pass2_subset t))` + +val sem_t_possible_var_name = prove( + ``!s e i r. + (sem_t s e = (i,r)) /\ t_max e < STRLEN k /\ i <> Rfail ==> + possible_var_name k s.store ==> + possible_var_name k r.store``, + HO_MATCH_MP_TAC sem_t_ind \\ REVERSE (REPEAT STRIP_TAC) + THEN1 + (NTAC 4 (POP_ASSUM MP_TAC) + \\ ONCE_REWRITE_TAC [sem_t_def] + \\ fs [t_max_def,MAX_LESS] + \\ REPEAT STRIP_TAC + \\ Cases_on `sem_e s e1` \\ fs [] + \\ Cases_on `q` \\ fs [sem_e_break] + \\ Cases_on `i' = 0` \\ fs [] + \\ SRW_TAC [] [] \\ fs [t_max_def,MAX_LESS] + THEN1 (METIS_TAC [sem_e_possible_var_name]) + \\ Cases_on `sem_t r' e` \\ fs [] + \\ REVERSE (Cases_on `q`) \\ fs [] + \\ SRW_TAC [] [] \\ fs [] + THEN1 (METIS_TAC [sem_e_possible_var_name]) + THEN1 (METIS_TAC [sem_e_possible_var_name]) + \\ Cases_on `sem_e r'' e2` \\ Cases_on `q` \\ fs [sem_e_break] + \\ Cases_on `r'''.clock = 0` \\ fs[] + \\ METIS_TAC [sem_e_possible_var_name]) + \\ fs [sem_t_def,t_max_def,MAX_LESS] + THEN1 + (Cases_on `sem_e s e` \\ fs [] \\ Cases_on `q` \\ fs [sem_e_break] + \\ Cases_on `i' = 0` \\ fs [] + \\ METIS_TAC [sem_e_possible_var_name]) + THEN1 (Cases_on `sem_t s e` \\ fs [] \\ Cases_on `q` \\ fs [sem_e_break]) + THEN1 (SRW_TAC [] []) + THEN1 + (fs [store_var_def] + \\ FIRST_X_ASSUM MATCH_MP_TAC + \\ fs [possible_var_name_def] + \\ CCONTR_TAC \\ fs [] + \\ SRW_TAC [] [] \\ fs [] \\ DECIDE_TAC) + THEN1 + (Cases_on `i` \\ fs [sem_e_break] + \\ IMP_RES_TAC sem_e_possible_var_name)) + |> Q.SPECL [`s`,`e`,`Rval i`,`r`] + |> SIMP_RULE (srw_ss()) []; + +val flatten_t_correct = prove( + ``!s e t n res s1. + sem_t s e = (res,s1) /\ res <> Rfail /\ pass2_subset e /\ + possible_var_name n s.store /\ + s.store SUBMAP t.store /\ (t.clock = s.clock) /\ + (s.non_det_o = K F) /\ + (s.io_trace = t.io_trace) /\ + (s.input = t.input) /\ + t_max e < LENGTH n ==> + ?t1. (sem_t t (flatten_t e n) = (res,t1)) /\ + s1.store SUBMAP t1.store /\ (t1.clock = s1.clock) /\ + (s1.non_det_o = K F) /\ + (s1.io_trace = t1.io_trace) /\ + (s1.input = t1.input) /\ + possible_var_name n s1.store /\ + (!k v. possible_var_name k s.store /\ + t_max e < LENGTH k /\ LENGTH k < LENGTH n /\ + FLOOKUP t.store k = SOME v ==> + FLOOKUP t1.store k = SOME v)``, + HO_MATCH_MP_TAC sem_t_ind \\ REPEAT STRIP_TAC \\ fs [pass2_subset_def] + THEN1 (* Exp *) + (fs [flatten_t_def,sem_t_def,t_max_def] + \\ MP_TAC (SPEC_ALL comp_exp_correct) + \\ fs [] \\ REPEAT STRIP_TAC \\ fs []) + THEN1 (* Break *) + (fs [sem_t_def,flatten_t_def] \\ SRW_TAC [] []) + THEN1 (* Seq *) + (fs [sem_t_def,flatten_t_def] \\ SRW_TAC [] [] + \\ fs [t_max_def,MAX_LESS] + \\ Cases_on `sem_t s e` \\ fs [] + \\ FIRST_X_ASSUM (MP_TAC o Q.SPECL [`t`,`n`]) + \\ `q <> Rfail` by (REPEAT STRIP_TAC \\ fs []) \\ fs [] + \\ REPEAT STRIP_TAC \\ fs [] + \\ Cases_on `q` \\ fs [] \\ SRW_TAC [] [] + \\ FIRST_X_ASSUM (MP_TAC o Q.SPECL [`t1:state`,`n`]) + \\ fs [] \\ REPEAT STRIP_TAC \\ fs [] + \\ REPEAT STRIP_TAC + \\ FIRST_X_ASSUM MATCH_MP_TAC \\ fs [] + \\ IMP_RES_TAC sem_t_possible_var_name) + THEN1 (* If *) + (fs [sem_t_def,flatten_t_def] + \\ Cases_on `sem_e s e` \\ fs [] + \\ `q <> Rfail` by (REPEAT STRIP_TAC \\ fs []) + \\ MP_TAC (Q.SPECL [`e`,`s`] comp_exp_correct) \\ fs [] + \\ REPEAT STRIP_TAC \\ POP_ASSUM (MP_TAC o Q.SPECL [`t`,`n`]) + \\ fs [MAX_LESS,t_max_def] \\ REPEAT STRIP_TAC \\ fs [sem_e_def] + \\ REVERSE (Cases_on `q`) \\ fs [] \\ TRY (SRW_TAC [] [] \\ NO_TAC) + \\ Cases_on `i = 0` \\ fs [] \\ REPEAT STRIP_TAC \\ fs [] + \\ FIRST_X_ASSUM (MP_TAC o Q.SPECL [`t1:state`,`n`]) \\ fs [] + \\ REPEAT STRIP_TAC \\ fs [] \\ REPEAT STRIP_TAC + \\ FIRST_X_ASSUM MATCH_MP_TAC \\ fs [] + \\ IMP_RES_TAC sem_e_possible_var_name) + THEN1 (* For *) + (ASM_SIMP_TAC (srw_ss()) [sem_t_def_with_stop,flatten_t_def,sem_e_def] + \\ fs [sem_e_def,t_max_def] \\ SRW_TAC [] [] + \\ Q.PAT_ASSUM `sem_t s (For (Num 1) (Num 1) e) = (res,s1)` MP_TAC + \\ ONCE_REWRITE_TAC [sem_t_def] \\ fs [sem_e_def] + \\ REPEAT STRIP_TAC \\ Cases_on `sem_t s e` \\ fs [] + \\ `q <> Rfail` by (REPEAT STRIP_TAC \\ fs []) + \\ FIRST_X_ASSUM (MP_TAC o Q.SPECL [`t`,`n`]) + \\ fs [MAX_LESS,t_max_def] \\ REPEAT STRIP_TAC \\ fs [sem_e_def] + \\ REVERSE (Cases_on `q`) \\ fs [] \\ TRY (SRW_TAC [] [] \\ NO_TAC) + \\ Cases_on `r.clock = 0` \\ fs [] THEN1 (SRW_TAC [] []) + \\ fs [STOP_def] + \\ FIRST_X_ASSUM (MP_TAC o Q.SPECL [`dec_clock t1`,`n`]) + \\ MATCH_MP_TAC IMP_IMP \\ STRIP_TAC + THEN1 (fs [dec_clock_def]) \\ REPEAT STRIP_TAC \\ fs [] + \\ fs [flatten_t_def] \\ REPEAT STRIP_TAC + \\ FIRST_X_ASSUM MATCH_MP_TAC \\ fs [] + \\ IMP_RES_TAC sem_t_possible_var_name)); + +val pass2_correct = flatten_t_correct + |> Q.SPECL [`s`,`t`,`s3`,`"temp" ++ REPLICATE (t_max t - 3) #"'"`] + |> DISCH ``s.store = FEMPTY`` + |> DISCH ``s1.store = FEMPTY`` + |> SIMP_RULE (srw_ss()) [GSYM pass2_def,Once possible_var_name_def, + rich_listTheory.LENGTH_REPLICATE,DECIDE ``n < 4 + (n - 3:num)``, + PULL_FORALL] |> GEN_ALL; + +val pair_eq = prove( + ``(x = (y1,y2)) <=> (FST x = y1) /\ (SND x = y2)``, + Cases_on `x` \\ fs [] \\ METIS_TAC []); + +val s_with_clock_def = Define ` + s_with_clock c input = <| store := FEMPTY; clock := c; + input := input ; io_trace := []; + non_det_o := K F |>`; + +val lemma = prove( + ``((if b then x1 else x2) <> x2) <=> (x1 <> x2) /\ b``, + Cases_on `b` \\ fs []) + +val pass2_pres = store_thm("pass2_pres", + ``!t input. ~(Crash IN semantics t input) /\ pass2_subset t ==> + semantics (pass2 t) input SUBSET semantics t input``, + REPEAT STRIP_TAC \\ fs [semantics_def,IN_DEF,SUBSET_DEF] + \\ Cases \\ fs [semantics_def] + \\ TRY + (SRW_TAC [] [] + \\ MP_TAC (pass2_correct |> Q.SPECL [`t`,`init_st c nd input`, + `s_with_clock c input`,`s_with_clock c input`]) \\ fs [] + \\ Cases_on `sem_t (s_with_clock c input) t` \\ fs [] + \\ fs [AND_IMP_INTRO] + \\ MATCH_MP_TAC IMP_IMP \\ STRIP_TAC + THEN1 (fs [s_with_clock_def,init_st_def] \\ METIS_TAC []) + \\ TRY (fs [s_with_clock_def,init_st_def] \\ METIS_TAC []) + \\ STRIP_TAC + \\ Q.LIST_EXISTS_TAC [`c`,`K F`] \\ fs [] + \\ fs [s_with_clock_def,init_st_def] + \\ SRW_TAC [] [] \\ NO_TAC) + \\ REPEAT STRIP_TAC + \\ fs [semantics_def] \\ Q.EXISTS_TAC `K F` \\ fs [] \\ REPEAT STRIP_TAC + THEN1 + (POP_ASSUM (K ALL_TAC) + \\ POP_ASSUM (MP_TAC o Q.SPEC `c`) \\ REPEAT STRIP_TAC + \\ MP_TAC (pass2_correct |> Q.SPECL [`t`,`init_st c nd input`, + `s_with_clock c input`,`s_with_clock c input`]) \\ fs [] + \\ Cases_on `sem_t (s_with_clock c input) t` \\ fs [] + \\ fs [AND_IMP_INTRO] + \\ MATCH_MP_TAC IMP_IMP \\ STRIP_TAC + THEN1 (fs [s_with_clock_def,init_st_def] \\ METIS_TAC []) + \\ STRIP_TAC \\ fs [s_with_clock_def,init_st_def]) + \\ RES_TAC + \\ MP_TAC (pass2_correct |> Q.SPECL [`t`,`init_st c nd input`, + `s_with_clock c input`,`s_with_clock c input`]) \\ fs [] + \\ Cases_on `sem_t (s_with_clock c input) t` \\ fs [] + \\ fs [AND_IMP_INTRO] + \\ MATCH_MP_TAC IMP_IMP \\ STRIP_TAC + THEN1 (fs [s_with_clock_def,init_st_def] \\ METIS_TAC []) + \\ STRIP_TAC \\ fs [s_with_clock_def,init_st_def] + \\ METIS_TAC []); + + +(* verification of PASS 3, which generates assmebly programs *) + +val _ = Datatype ` +reg = Reg string` + +val _ = Datatype ` +instr = + Add reg reg reg + | Mov reg reg + | Int reg int + | Read reg + | Write reg + | Jmp num + | JmpIf reg num + | Halt`; + +val _ = Datatype ` +state_a = <| state : state; pc : num; instrs : instr list |>`; + +val do_jump_def = Define ` +do_jump s n = + if n > s.pc then + (Rval 0, s with pc := n) + else if s.state.clock = 0 then + (Rtimeout, s) + else + let st' = s.state with clock := s.state.clock - 1 in + (Rval 0, s with <| state := st'; pc := n |>)`; + +val inc_pc_def = Define ` +inc_pc s = s with pc := s.pc + 1`; + +val sem_a_def = tDefine "sem_a" ` +sem_a s = + if s.pc < LENGTH s.instrs then + case EL s.pc s.instrs of + | Halt => (Rval 0, s) + | Int (Reg r) i => + let (r,st) = sem_e s.state (Assign r (Num i)) in + let s' = s with state := st in + (case r of + | Rval _ => sem_a (inc_pc s') + | _ => (r, s')) + | Add (Reg r) (Reg r1) (Reg r2) => + let (r,st) = sem_e s.state (Assign r (Add (Var r1) (Var r2))) in + let s' = s with state := st in + (case r of + | Rval _ => sem_a (inc_pc s') + | _ => (r, s')) + | Mov (Reg r) (Reg r1) => + let (r,st) = sem_e s.state (Assign r (Var r1)) in + let s' = s with state := st in + (case r of + | Rval _ => sem_a (inc_pc s') + | _ => (r, s')) + | Read (Reg r) => + let (r,st) = sem_e s.state (Assign r Getchar) in + let s' = s with state := st in + (case r of + | Rval _ => sem_a (inc_pc s') + | _ => (r, s')) + | Write (Reg r) => + let (r,st) = sem_e s.state (Putchar (Var r)) in + let s' = s with state := st in + (case r of + | Rval _ => sem_a (inc_pc s') + | _ => (r, s')) + | Jmp n' => + (case do_jump s n' of + | (Rval _, s') => sem_a s' + | r => r) + | JmpIf (Reg r) n' => + let (r,st) = sem_e s.state (Var r) in + let s' = s with state := st in + case r of + | Rval n => + if n <> 0 then + sem_a (inc_pc s') + else + (case do_jump s' n' of + | (Rval _, s') => sem_a s' + | r => r) + | _ => (r, s') + else + (Rfail, s)` + (WF_REL_TAC `inv_image (measure I LEX measure I) + (\s. (s.state.clock,LENGTH s.instrs - s.pc))` + \\ fs [inc_pc_def,do_jump_def,LET_DEF] + \\ REPEAT STRIP_TAC + \\ ect \\ fs [] + \\ SRW_TAC [] [] \\ fs [] + \\ IMP_RES_TAC sem_e_clock + \\ IMP_RES_TAC (GSYM sem_e_clock) + \\ TRY DECIDE_TAC); + +val a_state_def = Define ` + a_state code clock input = + <| state := s_with_clock clock input; pc := 0; instrs := code |>`; + +val asm_semantics_def = Define ` +(asm_semantics code input (Terminate io_trace) = + (* Terminate when there is a clock and some non-determinism oracle that gives a value result *) + ?c i s. + sem_a (a_state code c input) = (Rval i, s) /\ + s.state.io_trace = io_trace) /\ +(asm_semantics code input Crash = + (* Crash when there is a clock that gives a non-value, non-timeout result *) + ?c r s. + sem_a (a_state code c input) = (r, s) /\ + (r = Rbreak \/ r = Rfail)) /\ +(asm_semantics code input (Diverge io_trace) <=> + (* Diverge when all clocks give timeout results. Ensure that the IO trace to + * the timeout point is a prefix of the whole trace. *) + (!c. ?s. + sem_a (a_state code c input) = (Rtimeout, s) /\ + (!n. n < LENGTH s.state.io_trace ==> + LNTH n io_trace = SOME (EL n s.state.io_trace))) /\ + (* Check that the whole IO trace is reachable, but maybe not for just 1 + * clock value*) + (!n x. + LNTH n io_trace = SOME x ==> + ?c s. sem_a (a_state code c input) = (Rtimeout, s) /\ + n < LENGTH s.state.io_trace /\ EL n s.state.io_trace = x))`; + +val pass3_aux_def = Define ` + (pass3_aux n (Dec v t) b = []) /\ + (pass3_aux n (Exp e) b = + case e of + | Assign v (Var x) => + if x = v then [] else [Mov (Reg v) (Reg x)] + | Assign v (Add (Var v1) (Var v2)) => [Add (Reg v) (Reg v1) (Reg v2)] + | Assign v (Num i) => [Int (Reg v) i] + | Assign v Getchar => [Read (Reg v)] + | Putchar (Var v) => [Write (Reg v)] + | _ => []) /\ + (pass3_aux n Break b = [Jmp b]) /\ + (pass3_aux n (Seq t1 t2) b = + let c1 = pass3_aux n t1 b in + let c2 = pass3_aux (n + LENGTH c1) t2 b in + c1 ++ c2) /\ + (pass3_aux n (If e t1 t2) b = + let c1 = pass3_aux (n + 1) t1 b in + let c2 = pass3_aux (n + 2 + LENGTH c1) t2 b in + [JmpIf (case e of Var v => Reg v | _ => Reg "") + (n + 2 + LENGTH c1)] ++ c1 ++ + [Jmp (n + 2 + LENGTH c1 + LENGTH c2)] ++ c2) /\ + (pass3_aux n (For e1 e2 t) b = + let c1 = pass3_aux n t 0 in + let c2 = pass3_aux n t (n + 1 + LENGTH c1) in + c2 ++ [Jmp n])` + +val pass3_def = Define ` + pass3 t = pass3_aux 0 t 0 ++ [Halt]`; + +val LENGTH_pass3_aux = prove( + ``!t n b. LENGTH (pass3_aux n t b) = LENGTH (pass3_aux 0 t 0)``, + Induct \\ fs [pass3_aux_def,LET_DEF]); + +val pass3_subset_def = Define ` + (pass3_subset (Dec v t) = F) /\ + (pass3_subset (Exp e) <=> + (?v. e = Assign v (Getchar)) \/ + (?v. e = Putchar (Var v)) \/ + (?v x. e = Assign v (Var x)) \/ + (?v i. e = Assign v (Num i)) \/ + (?v x y. e = Assign v (Add (Var x) (Var y)))) /\ + (pass3_subset Break = T) /\ + (pass3_subset (Seq t1 t2) = (pass3_subset t1 /\ pass3_subset t2)) /\ + (pass3_subset (If e t1 t2) <=> + (?w. e = Var w) /\ pass3_subset t1 /\ pass3_subset t2) /\ + (pass3_subset (For e1 e2 t) = ((e1 = Num 1) /\ (e2 = Num 1) /\ pass3_subset t))` + +val instr_lookup_lemma = prove( + ``(x.pc = LENGTH xs) /\ (x.instrs = xs ++ [y] ++ ys) ==> + x.pc < LENGTH x.instrs /\ (EL x.pc x.instrs = y)``, + fs [DECIDE ``n < n + 1 + m:num``,rich_listTheory.EL_LENGTH_APPEND] + \\ FULL_SIMP_TAC std_ss [GSYM APPEND_ASSOC,APPEND] + \\ fs [rich_listTheory.EL_LENGTH_APPEND]); + +val EL_LENGTH_APPEND_LEMMA = + rich_listTheory.EL_LENGTH_APPEND + |> Q.SPECL [`[y] ++ ys`,`xs1++xs2`] + |> SIMP_RULE (srw_ss()) [] + +val EL_LEMMA = prove( + ``(LENGTH (xs1 ++ xs2 ++ xs3) = n) ==> + (EL n (xs1 ++ xs2 ++ xs3 ++ [y] ++ ys1 ++ ys2) = y)``, + Q.SPEC_TAC (`(xs1 ++ xs2 ++ xs3)`,`zs`) \\ SRW_TAC [] [] + \\ FULL_SIMP_TAC std_ss [GSYM APPEND_ASSOC,APPEND] + \\ fs [rich_listTheory.EL_LENGTH_APPEND]); + +val state_rel_def = Define ` + state_rel s x = (x.state = s)`; + +val pass3_aux_thm = store_thm("pass3_aux_thm", + ``!s1 t res s2 x xs ys b. + (sem_t s1 t = (res,s2)) /\ pass3_subset t /\ + state_rel s1 x /\ + (x.pc = LENGTH xs) /\ + (x.instrs = xs ++ pass3_aux (LENGTH xs) t b ++ ys) /\ + res <> Rfail /\ + (res = Rbreak ==> (LENGTH (xs ++ pass3_aux (LENGTH xs) t b) <= b)) ==> + ?x'. + (sem_a x = sem_a x') /\ + state_rel s2 x' /\ + (x'.instrs = x.instrs) /\ + (case res of + | Rfail => T + | Rbreak => (x'.pc = b) + | Rtimeout => (sem_a x' = (Rtimeout,x')) + | Rval v => (x'.pc = LENGTH (xs ++ pass3_aux (LENGTH xs) t b)))``, + REWRITE_TAC [state_rel_def] + \\ HO_MATCH_MP_TAC sem_t_ind \\ REPEAT STRIP_TAC \\ fs [pass3_subset_def] + THEN1 (* Exp 1 *) + (fs [pass3_aux_def,sem_t_def] \\ rfs [] + \\ SIMP_TAC std_ss [Once sem_a_def] + \\ FULL_SIMP_TAC std_ss [GSYM APPEND_ASSOC,APPEND] + \\ imp_res_tac (instr_lookup_lemma |> REWRITE_RULE [GSYM APPEND_ASSOC,APPEND]) + \\ fs [LET_DEF,rich_listTheory.EL_LENGTH_APPEND] + \\ fs [sem_e_def,LET_DEF] \\ SRW_TAC [] [] + \\ Cases_on `getchar x.state.input` \\ fs [] + \\ fs [sem_e_def,LET_DEF] \\ SRW_TAC [] [] + \\ Q.EXISTS_TAC `(inc_pc + (x with + state := + store_var v q + (x.state with + <|io_trace := x.state.io_trace ++ [Itag q]; + input := r|>)))` + \\ fs [inc_pc_def]) + THEN1 (* Exp 2 *) + (fs [pass3_aux_def,sem_t_def] \\ rfs [] + \\ SIMP_TAC std_ss [Once sem_a_def] + \\ FULL_SIMP_TAC std_ss [GSYM APPEND_ASSOC,APPEND] + \\ imp_res_tac (instr_lookup_lemma |> REWRITE_RULE [GSYM APPEND_ASSOC,APPEND]) + \\ fs [LET_DEF,rich_listTheory.EL_LENGTH_APPEND] + \\ fs [sem_e_def,LET_DEF] + \\ Cases_on `FLOOKUP s1.store v` \\ fs [] + \\ SRW_TAC [] [] + \\ Q.EXISTS_TAC `(inc_pc + (x with + state := + x.state with io_trace := x.state.io_trace ++ [Otag x']))` + \\ fs [inc_pc_def]) + THEN1 (* Exp 3 *) + (fs [pass3_aux_def,sem_t_def] \\ rfs [] + \\ Cases_on `v = x'` \\ fs [] THEN1 + (fs [sem_e_def] + \\ Cases_on `FLOOKUP s1.store x'` \\ fs [] \\ SRW_TAC [] [] + \\ Q.EXISTS_TAC `x` \\ fs [store_var_def,state_component_equality] + \\ fs [FLOOKUP_DEF,fmap_EXT,FAPPLY_FUPDATE_THM] + \\ SRW_TAC [] [] \\ fs [EXTENSION] \\ METIS_TAC []) + \\ SIMP_TAC std_ss [Once sem_a_def] + \\ FULL_SIMP_TAC std_ss [GSYM APPEND_ASSOC,APPEND] + \\ imp_res_tac (instr_lookup_lemma |> REWRITE_RULE [GSYM APPEND_ASSOC,APPEND]) + \\ fs [LET_DEF,rich_listTheory.EL_LENGTH_APPEND] + \\ fs [sem_e_def,LET_DEF] + \\ Cases_on `FLOOKUP s1.store x'` \\ fs [] + \\ SRW_TAC [] [] + \\ Q.EXISTS_TAC `(inc_pc (x with state := store_var v x'' x.state))` + \\ fs [inc_pc_def]) + THEN1 (* Exp 4 *) + (fs [pass3_aux_def,sem_t_def] \\ rfs [] + \\ SIMP_TAC std_ss [Once sem_a_def] + \\ FULL_SIMP_TAC std_ss [GSYM APPEND_ASSOC,APPEND] + \\ imp_res_tac (instr_lookup_lemma |> REWRITE_RULE [GSYM APPEND_ASSOC,APPEND]) + \\ fs [LET_DEF,rich_listTheory.EL_LENGTH_APPEND] + \\ fs [sem_e_def] \\ SRW_TAC [] [] + \\ Q.EXISTS_TAC `(inc_pc (x with state := store_var v i x.state))` + \\ fs [inc_pc_def]) + THEN1 (* Exp 5 *) + (fs [pass3_aux_def,sem_t_def] \\ rfs [] + \\ SIMP_TAC std_ss [Once sem_a_def] + \\ FULL_SIMP_TAC std_ss [GSYM APPEND_ASSOC,APPEND] + \\ imp_res_tac (instr_lookup_lemma |> REWRITE_RULE [GSYM APPEND_ASSOC,APPEND]) + \\ fs [LET_DEF,rich_listTheory.EL_LENGTH_APPEND] + \\ fs [sem_e_def] \\ SRW_TAC [] [] + \\ ect \\ fs [] \\ SRW_TAC [] [] + \\ fs [permute_pair_def,oracle_get_def,LET_DEF] + \\ Cases_on `x.state.non_det_o 0` \\ fs [sem_e_def] + \\ Cases_on `FLOOKUP x.state.store y` \\ fs [] + \\ Cases_on `FLOOKUP x.state.store x'` \\ fs [unpermute_pair_def] + \\ Q.EXISTS_TAC `(inc_pc (x with state := store_var v i r))` \\ fs [] + \\ SRW_TAC [] [inc_pc_def]) + THEN1 (* Break *) + (fs [sem_t_def] \\ SRW_TAC [] [] \\ fs [pass3_aux_def,LET_DEF] + \\ SIMP_TAC std_ss [Once sem_a_def] + \\ imp_res_tac instr_lookup_lemma \\ fs [LET_DEF] + \\ fs [do_jump_def] + \\ `b > LENGTH xs` by DECIDE_TAC \\ fs [] + \\ Q.EXISTS_TAC `x with pc := b` + \\ fs [] \\ fs [state_component_equality]) + THEN1 (* Seq *) + (fs [sem_t_def] \\ SRW_TAC [] [] \\ fs [pass3_aux_def,LET_DEF] + \\ Cases_on `sem_t x.state t` \\ fs [] + \\ FIRST_X_ASSUM (MP_TAC o Q.SPECL [`x`,`xs`, + `pass3_aux (LENGTH xs + LENGTH (pass3_aux (LENGTH (xs:instr list)) t b)) t' b + ++ ys`,`b`]) \\ fs [] + \\ MATCH_MP_TAC IMP_IMP \\ STRIP_TAC + THEN1 (Cases_on `q` \\ fs [] \\ SRW_TAC [] [] \\ DECIDE_TAC) + \\ REPEAT STRIP_TAC \\ fs [] + \\ Q.MATCH_ASSUM_RENAME_TAC `x2.state = r` + \\ REVERSE (Cases_on `q`) \\ fs [] \\ SRW_TAC [] [] + \\ TRY (Q.EXISTS_TAC `x2` \\ fs [] \\ NO_TAC) + \\ FIRST_X_ASSUM (MP_TAC o Q.SPECL [`x2`,`xs ++ pass3_aux (LENGTH xs) t b`, + `ys`,`b`]) \\ fs [] + \\ MATCH_MP_TAC IMP_IMP \\ STRIP_TAC + THEN1 (REPEAT STRIP_TAC \\ fs [] \\ DECIDE_TAC) + \\ REPEAT STRIP_TAC + \\ Q.MATCH_ASSUM_RENAME_TAC `x3.state = s2` + \\ Q.EXISTS_TAC `x3` \\ fs [] + \\ fs [ADD_ASSOC]) + THEN1 (* If *) + (Q.MATCH_ASSUM_RENAME_TAC `sem_t s1 (If e t1 t2) = (res,s2)` + \\ fs [pass3_aux_def,sem_t_def] + \\ SIMP_TAC std_ss [Once sem_a_def] \\ fs [LET_DEF] + \\ FULL_SIMP_TAC std_ss [GSYM APPEND_ASSOC] + \\ imp_res_tac (instr_lookup_lemma |> REWRITE_RULE [GSYM APPEND_ASSOC]) + \\ rfs [] \\ POP_ASSUM (K ALL_TAC) + \\ REVERSE (Cases_on `sem_e s1 (Var w)`) \\ fs [] + \\ REVERSE (Cases_on `q`) \\ fs [] + \\ SRW_TAC [] [] \\ fs [sem_e_break] + \\ REPEAT (POP_ASSUM MP_TAC) + \\ ONCE_REWRITE_TAC [LENGTH_pass3_aux] \\ fs [] + \\ REPEAT STRIP_TAC + \\ Q.ABBREV_TAC `gg = (LENGTH xs + 2 + LENGTH (pass3_aux 0 t1 0) + + LENGTH (pass3_aux 0 t2 0))` + \\ REPEAT (POP_ASSUM MP_TAC) + \\ ONCE_REWRITE_TAC [LENGTH_pass3_aux] \\ fs [] + \\ REPEAT STRIP_TAC + THEN1 (* false case *) + (FIRST_X_ASSUM (MP_TAC o Q.SPECL [`(inc_pc (x with state := r))`, + `xs ++ [JmpIf (Reg w) (LENGTH (xs:instr list) + 2 + + LENGTH (pass3_aux 0 t1 0))]`, + `[Jmp gg] ++ pass3_aux (LENGTH (xs:instr list) + 2 + + LENGTH (pass3_aux 0 t1 0)) + t2 b ++ ys`,`b`]) \\ fs [] + \\ MATCH_MP_TAC IMP_IMP \\ STRIP_TAC + THEN1 (fs [inc_pc_def] \\ REPEAT STRIP_TAC \\ fs [] + \\ ONCE_REWRITE_TAC [LENGTH_pass3_aux] \\ fs [] + \\ DECIDE_TAC) + \\ REPEAT STRIP_TAC \\ fs [] + \\ Q.MATCH_ASSUM_RENAME_TAC `x2.state = s2` + \\ REVERSE (Cases_on `res`) \\ fs [] + \\ TRY (Q.EXISTS_TAC `x2` \\ fs [] \\ NO_TAC) + \\ SIMP_TAC std_ss [Once sem_a_def] \\ fs [LET_DEF] + \\ `LENGTH xs + 1 + LENGTH (pass3_aux 0 t1 0) < + LENGTH xs + 1 + LENGTH (pass3_aux (LENGTH xs + 1) t1 b) + 1 + + LENGTH (pass3_aux (LENGTH xs + 2 + LENGTH (pass3_aux 0 t1 0)) t2 b) + + LENGTH ys /\ + (EL (LENGTH xs + 1 + LENGTH (pass3_aux 0 t1 0)) + (xs ++ [JmpIf (Reg w) (LENGTH xs + 2 + LENGTH (pass3_aux 0 t1 0))] ++ + pass3_aux (LENGTH xs + 1) t1 b ++ [Jmp gg] ++ + pass3_aux (LENGTH xs + 2 + LENGTH (pass3_aux 0 t1 0)) t2 b ++ ys) = + Jmp gg)` by ALL_TAC THEN1 + (ONCE_REWRITE_TAC [LENGTH_pass3_aux] \\ fs [] + \\ REPEAT STRIP_TAC THEN1 DECIDE_TAC + \\ MATCH_MP_TAC EL_LEMMA + \\ fs [] \\ ONCE_REWRITE_TAC [LENGTH_pass3_aux] \\ fs []) + \\ fs [do_jump_def] + \\ UNABBREV_ALL_TAC + \\ SRW_TAC [] [] + \\ TRY (`F` by DECIDE_TAC) + \\ Q.EXISTS_TAC `(x2 with pc := + LENGTH xs + 2 + LENGTH (pass3_aux 0 t1 0) + LENGTH (pass3_aux 0 t2 0))` + \\ fs [AC ADD_COMM ADD_ASSOC,ADD1] \\ DECIDE_TAC) + (* true case *) + \\ fs [do_jump_def,DECIDE ``n + 2 + m > n:num``] + \\ FIRST_X_ASSUM (MP_TAC o Q.SPECL [ + `(x with <|state := r; pc := LENGTH (xs:instr list) + + 2 + LENGTH (pass3_aux 0 t1 0)|>)`, + `xs ++ [JmpIf (Reg w) (LENGTH xs + 2 + LENGTH (pass3_aux 0 t1 0))] ++ + pass3_aux (LENGTH xs + 1) t1 b ++ [Jmp gg]`, `ys`,`b`]) \\ fs [] + \\ MATCH_MP_TAC IMP_IMP \\ STRIP_TAC THEN1 + (fs [AC ADD_COMM ADD_ASSOC,DECIDE ``1+(1+n) = 2 + n:num``] + \\ ONCE_REWRITE_TAC [LENGTH_pass3_aux] \\ fs [] + \\ REPEAT STRIP_TAC \\ fs [] \\ DECIDE_TAC) + \\ REPEAT STRIP_TAC \\ fs [] + \\ Q.MATCH_ASSUM_RENAME_TAC `x2.state = s2` + \\ REPEAT (POP_ASSUM MP_TAC) + \\ ONCE_REWRITE_TAC [LENGTH_pass3_aux] \\ fs [] + \\ REPEAT STRIP_TAC + \\ Q.EXISTS_TAC `x2` \\ fs [] + \\ fs [AC ADD_COMM ADD_ASSOC,DECIDE ``1+(1+n) = 2 + n:num``,ADD1] + \\ Cases_on `res` \\ fs []) + THEN1 (* For *) + (fs [sem_e_def] \\ SRW_TAC [] [] + \\ Q.PAT_ASSUM `sem_t x.state (For (Num 1) (Num 1) t) = (res,s2)` MP_TAC + \\ SIMP_TAC (srw_ss()) [sem_t_def_with_stop,sem_e_def] + \\ SIMP_TAC std_ss [STOP_def] + \\ Cases_on `sem_t x.state t` \\ fs [pass3_aux_def,LET_DEF] + \\ STRIP_TAC + \\ FIRST_X_ASSUM (MP_TAC o Q.SPECL [`x`,`xs`, + `[Jmp (LENGTH (xs:instr list))] ++ ys`,`(LENGTH (xs:instr list) + 1 + + LENGTH (pass3_aux (LENGTH (xs:instr list)) t 0))`]) \\ fs [] + \\ ONCE_REWRITE_TAC [LENGTH_pass3_aux] \\ fs [] + \\ MATCH_MP_TAC IMP_IMP \\ STRIP_TAC + THEN1 (REPEAT STRIP_TAC \\ fs []) + \\ REPEAT STRIP_TAC \\ fs [] + \\ Q.MATCH_ASSUM_RENAME_TAC `x2.state = r` + \\ REVERSE (Cases_on `q`) \\ fs [] \\ SRW_TAC [] [] + \\ TRY (Q.EXISTS_TAC `x2` \\ fs [AC ADD_COMM ADD_ASSOC] \\ NO_TAC) + \\ SIMP_TAC std_ss [Once sem_a_def] + \\ `x2.pc < LENGTH x2.instrs` by + (fs [] \\ ONCE_REWRITE_TAC [LENGTH_pass3_aux] \\ fs [] \\ DECIDE_TAC) \\ fs [] + \\ `(EL (LENGTH xs + LENGTH (pass3_aux 0 t 0)) (xs ++ + pass3_aux (LENGTH xs) t (LENGTH xs + 1 + LENGTH (pass3_aux 0 t 0)) ++ + [Jmp (LENGTH xs)] ++ ys) = Jmp (LENGTH xs))` by + (`LENGTH (pass3_aux 0 t 0) = + LENGTH (pass3_aux (LENGTH (xs:instr list)) t + (LENGTH (xs:instr list) + 1 + LENGTH (pass3_aux 0 t 0)))` by + (fs [] \\ ONCE_REWRITE_TAC [LENGTH_pass3_aux] \\ fs []) + \\ POP_ASSUM (fn th => SIMP_TAC std_ss [Once th]) + \\ fs [EL_LENGTH_APPEND_LEMMA]) + \\ fs [do_jump_def,DECIDE ``~(n > n + k:num)``,LET_DEF] + \\ Cases_on `x2.state.clock = 0` \\ fs [] THEN1 + (SRW_TAC [] [] \\ fs [] + \\ Q.EXISTS_TAC `x2` \\ fs [] + \\ SIMP_TAC std_ss [EQ_SYM_EQ] \\ fs [] + \\ ONCE_REWRITE_TAC [sem_a_def] + \\ fs [do_jump_def,DECIDE ``~(n > n + k:num)``,LET_DEF]) + \\ Q.PAT_ASSUM `!x. bb` MP_TAC + \\ ONCE_REWRITE_TAC [LENGTH_pass3_aux] \\ fs [] + \\ REPEAT STRIP_TAC + \\ FIRST_X_ASSUM MATCH_MP_TAC + \\ fs [dec_clock_def] + \\ REPEAT STRIP_TAC \\ fs [] + \\ Q.PAT_ASSUM `xxx <= b` MP_TAC + \\ ONCE_REWRITE_TAC [LENGTH_pass3_aux] \\ fs [])) + |> REWRITE_RULE [state_rel_def]; + +val pass3_correct = store_thm("pass3_correct", + ``!s1 t res s2 x xs ys b. + (sem_t s1 t = (res,s2)) /\ pass3_subset t /\ + (x.state = s1) /\ + (x.pc = 0) /\ + (x.instrs = pass3 t) /\ + res <> Rfail /\ res <> Rbreak ==> + ?res' x'. + (sem_a x = (res', x')) /\ + (x'.state = s2) /\ + (case res of + | Rval v => (res' = Rval 0) + | _ => (res' = res))``, + REPEAT STRIP_TAC + \\ MP_TAC (SPEC_ALL pass3_aux_thm + |> Q.INST [`xs`|->`[]`,`ys`|->`[Halt]`,`b`|->`0`]) + \\ fs [pass3_def] \\ REPEAT STRIP_TAC \\ fs [] + \\ Cases_on `res` \\ fs [rich_listTheory.EL_LENGTH_APPEND] + \\ SIMP_TAC std_ss [Once sem_a_def] + \\ fs [rich_listTheory.EL_LENGTH_APPEND]); + +val pass3_pres = store_thm("pass3_pres", + ``!t input. ~(Crash IN semantics t input) /\ pass3_subset t ==> + asm_semantics (pass3 t) input SUBSET semantics t input``, + REPEAT STRIP_TAC \\ fs [semantics_def,IN_DEF,SUBSET_DEF] + \\ Cases \\ fs [asm_semantics_def] + \\ TRY + (SRW_TAC [] [] + \\ MP_TAC (pass3_correct |> Q.SPECL [`s_with_clock c input`,`t`]) + \\ Cases_on `sem_t (s_with_clock c input) t` \\ fs [] + \\ STRIP_TAC \\ POP_ASSUM (MP_TAC o Q.SPEC `(a_state (pass3 t) c input)`) + \\ MATCH_MP_TAC IMP_IMP \\ STRIP_TAC + THEN1 (fs [a_state_def,init_st_def] + \\ fs [s_with_clock_def] \\ METIS_TAC []) + \\ TRY (fs [a_state_def,s_with_clock_def,init_st_def] \\ METIS_TAC []) + \\ REPEAT STRIP_TAC \\ SRW_TAC [] [] + \\ Cases_on `q` \\ fs [] \\ SRW_TAC [] [] + \\ fs [semantics_def] + \\ fs [s_with_clock_def,init_st_def,a_state_def] + \\ Q.LIST_EXISTS_TAC [`c`,`K F`] \\ fs [] \\ NO_TAC) + \\ REPEAT STRIP_TAC + \\ fs [semantics_def] \\ Q.EXISTS_TAC `K F` \\ fs [] \\ REPEAT STRIP_TAC + THEN1 + (POP_ASSUM (K ALL_TAC) + \\ POP_ASSUM (MP_TAC o Q.SPEC `c`) \\ REPEAT STRIP_TAC + \\ MP_TAC (pass3_correct |> Q.SPECL [`s_with_clock c input`,`t`]) + \\ Cases_on `sem_t (s_with_clock c input) t` \\ fs [] + \\ STRIP_TAC \\ POP_ASSUM (MP_TAC o Q.SPEC `(a_state (pass3 t) c input)`) + \\ MATCH_MP_TAC IMP_IMP \\ STRIP_TAC + THEN1 (fs [a_state_def,init_st_def] + \\ fs [s_with_clock_def] \\ METIS_TAC []) + \\ REPEAT STRIP_TAC \\ SRW_TAC [] [] + \\ Cases_on `q` \\ fs [] \\ SRW_TAC [] [] + \\ fs [s_with_clock_def,init_st_def,a_state_def]) + \\ RES_TAC + \\ MP_TAC (pass3_correct |> Q.SPECL [`s_with_clock c input`,`t`]) + \\ Cases_on `sem_t (s_with_clock c input) t` \\ fs [] + \\ STRIP_TAC \\ POP_ASSUM (MP_TAC o Q.SPEC `(a_state (pass3 t) c input)`) + \\ MATCH_MP_TAC IMP_IMP \\ STRIP_TAC + THEN1 (fs [a_state_def,init_st_def] + \\ fs [s_with_clock_def] \\ METIS_TAC []) + \\ REPEAT STRIP_TAC \\ SRW_TAC [] [] + \\ Cases_on `q` \\ fs [] \\ SRW_TAC [] [] + \\ fs [s_with_clock_def,init_st_def,a_state_def] + \\ Q.LIST_EXISTS_TAC [`c`] \\ fs []); + +(* the entire compiler *) + +val compile_def = Define ` + compile t = pass3 (pass2 (pass1 t))`; + +val pass2_subset_pass1 = prove( + ``!t. pass2_subset (pass1 t)``, + Induct \\ fs [pass1_def,pass2_subset_def,Loop_def]); + +val pass3_subset_comp_exp = prove( + ``!e n. pass3_subset (comp_exp e n)``, + Induct \\ fs [pass3_subset_def,comp_exp_def]); + +val pass3_subset_flatten_t = prove( + ``!t n. pass2_subset t ==> pass3_subset (flatten_t t n)``, + Induct \\ fs [pass2_subset_def,flatten_t_def,pass3_subset_def] + \\ fs [pass3_subset_comp_exp]); + +val pass3_subset_pass2_pass1 = prove( + ``!t. pass3_subset (pass2 (pass1 t))``, + fs [pass2_def] \\ REPEAT STRIP_TAC + \\ MATCH_MP_TAC pass3_subset_flatten_t + \\ fs [pass2_subset_pass1]); + +val compile_pres = store_thm("compile_pres", + ``!t input. ~(Crash IN semantics t input) ==> + asm_semantics (compile t) input SUBSET semantics t input``, + fs [compile_def] + \\ ONCE_REWRITE_TAC [GSYM pass1_pres] + \\ REPEAT STRIP_TAC + \\ MATCH_MP_TAC SUBSET_TRANS + \\ Q.EXISTS_TAC `semantics (pass2 (pass1 t)) input` + \\ REPEAT STRIP_TAC + THEN1 + (MATCH_MP_TAC pass3_pres + \\ fs [pass3_subset_pass2_pass1] + \\ IMP_RES_TAC pass2_pres + \\ fs [pass2_subset_pass1,SUBSET_DEF] + \\ METIS_TAC []) + \\ MATCH_MP_TAC pass2_pres \\ fs [pass2_subset_pass1]); + +val syntax_ok_def = Define ` + syntax_ok t = !input. ~(Crash IN semantics t input)`; + +val compile_correct = store_thm("compile_correct", + ``!t i. syntax_ok t ==> + asm_semantics (compile t) i SUBSET semantics t i``, + METIS_TAC [syntax_ok_def,compile_pres]); + +val _ = export_theory (); From f91458fbf896132a582418e9e39d1b731834c0e0 Mon Sep 17 00:00:00 2001 From: Thomas Tuerk Date: Fri, 20 Mar 2015 21:12:58 +0100 Subject: [PATCH 242/718] deepMatch example: improved simplification generalise removal of ARB rows. Now all subsumed rows, i.e. all rows that are unnecessary, because a later row is more general, are removed. --- examples/deep_matches/deepMatchesLib.sig | 6 +- examples/deep_matches/deepMatchesLib.sml | 212 ++++++++++++-------- examples/deep_matches/deepMatchesScript.sml | 8 +- 3 files changed, 139 insertions(+), 87 deletions(-) diff --git a/examples/deep_matches/deepMatchesLib.sig b/examples/deep_matches/deepMatchesLib.sig index 276090260d..375e51456f 100644 --- a/examples/deep_matches/deepMatchesLib.sig +++ b/examples/deep_matches/deepMatchesLib.sig @@ -66,12 +66,12 @@ sig (* PMATCH_SIMP_CONV consists of various component conversions. These can be used independently as well. *) - val PMATCH_REMOVE_ARB_CONV : conv - val PMATCH_REMOVE_ARB_CONV_GEN : ssfrag list -> conv - val PMATCH_REMOVE_REDUNDANT_CONV : conv val PMATCH_REMOVE_REDUNDANT_CONV_GEN : ssfrag list -> conv + val PMATCH_REMOVE_SUBSUMED_CONV : bool -> conv + val PMATCH_REMOVE_SUBSUMED_CONV_GEN : bool -> ssfrag list -> conv + val PMATCH_CLEANUP_PVARS_CONV : conv val PMATCH_CLEANUP_CONV : conv diff --git a/examples/deep_matches/deepMatchesLib.sml b/examples/deep_matches/deepMatchesLib.sml index 2b52613c76..8146f4c750 100644 --- a/examples/deep_matches/deepMatchesLib.sml +++ b/examples/deep_matches/deepMatchesLib.sml @@ -145,6 +145,37 @@ fun rc_conv (gl, callback_opt) = REPEATC ( fun rc_tac (gl, callback_opt) = CONV_TAC (rc_conv (gl, callback_opt)) +fun rc_elim_precond rc_arg thm = let + val pre = rand (rator (concl thm)) + val pre_thm = prove_attempt (pre, rc_tac rc_arg) + val thm2 = MP thm pre_thm +in + thm2 +end + +(* evaluate APPEND on both sides to get the theorem back in shape *) + +fun fix_appends rc_arg l thm = let + val t_eq_thm = prove (mk_eq (l, lhs (concl thm)), + CONV_TAC (DEPTH_CONV listLib.APPEND_CONV) THEN + rc_tac rc_arg) + + val thm2 = TRANS t_eq_thm thm + + fun my_append_conv t = let + val _ = if listSyntax.is_append t then () else raise UNCHANGED + in + (BINOP_CONV (TRY_CONV my_append_conv) THENC + listLib.APPEND_CONV) t + end + + val thm3 = CONV_RULE (RHS_CONV (RAND_CONV my_append_conv)) thm2 + handle HOL_ERR _ => thm2 + | UNCHANGED => thm2 +in + thm3 +end + fun PMATCH_ROW_ARGS_CONV c = RATOR_CONV (RAND_CONV (TRY_CONV c)) THENC RATOR_CONV (RATOR_CONV (RAND_CONV (TRY_CONV c))) THENC @@ -450,9 +481,7 @@ val t = `` *) -fun PMATCH_REMOVE_REDUNDANT_CONV_GENCALL_SINGLE rc_arg t = let - val (v, rows) = dest_PMATCH t - +fun compute_row_pat_pairs rows = let (* get pats with fresh vars to do a quick prefiltering *) val pats_unique = Lib.enumerate 0 (Lib.mapfilter (fn r => let val (p, _, _) = dest_PMATCH_ROW r @@ -472,6 +501,14 @@ fun PMATCH_REMOVE_REDUNDANT_CONV_GENCALL_SINGLE rc_arg t = let in aux [] pats_unique end +in + candidates +end + + +fun PMATCH_REMOVE_REDUNDANT_CONV_GENCALL_SINGLE rc_arg t = let + val (v, rows) = dest_PMATCH t + val candidates = compute_row_pat_pairs rows (* quick filter on matching *) val candidates_match = let @@ -507,24 +544,13 @@ fun PMATCH_REMOVE_REDUNDANT_CONV_GENCALL_SINGLE rc_arg t = let val thm0 = FRESH_TY_VARS_RULE PMATCH_ROWS_DROP_REDUNDANT_PMATCH_ROWS val thm1 = PART_MATCH (lhs o rand) thm0 tm0 - val pre = rand (rator (concl thm1)) - val pre_thm = prove_attempt (pre, rc_tac rc_arg) - val thm2 = MP thm1 pre_thm - - val t_eq_thm = prove (mk_eq (t, lhs (concl thm2)), - CONV_TAC (DEPTH_CONV listLib.APPEND_CONV) THEN - rc_tac rc_arg) - - val thm3 = TRANS t_eq_thm thm2 - val c = RATOR_CONV (RAND_CONV listLib.APPEND_CONV) THENC - listLib.APPEND_CONV - val thm4 = CONV_RULE (RHS_CONV (RAND_CONV - c)) thm3 + val thm2 = rc_elim_precond rc_arg thm1 + val thm3 = fix_appends rc_arg t thm2 in - thm4 + thm3 end in - Lib.tryfind try_pair ((2, 3)::cands) + Lib.tryfind try_pair cands end handle HOL_ERR _ => raise UNCHANGED fun PMATCH_REMOVE_REDUNDANT_CONV_GENCALL rc_arg = REPEATC (PMATCH_REMOVE_REDUNDANT_CONV_GENCALL_SINGLE rc_arg) @@ -533,75 +559,112 @@ val PMATCH_REMOVE_REDUNDANT_CONV = PMATCH_REMOVE_REDUNDANT_CONV_GEN [] (***********************************************) -(* removing ARB rows *) +(* removing subsumed rows *) (***********************************************) -(* when converting CASE expressions into PMATCH, - often ARB rows are introduced for the not - covered cases. These ARB rows are - not needed for PMATCH and can be removed. *) - (* val rc_arg = ([], NONE) set_trace "parse deep cases" 0 -val t = convert_case ``case x of NONE => 0`` +val t = case2pmatch false ``case x of NONE => 0`` -val t = convert_case ``case (x, y, z) of +val t = case2pmatch false ``case (x, y, z) of (0, y, z) => 2 | (x, NONE, []) => x | (x, SOME y, l) => x+y`` +val t = + ``CASE (x,y,z) OF [ + || v1. (0,v1) ~> 2; + || v4. (SUC v4,NONE,[]) ~> (SUC v4); + || (v4,v10,v11). (SUC v4,NONE,v10::v11) ~> ARB; + || v4. (v4,NONE,_) ~> v4; + || (v4,v10,v11). (0,SOME _ ,_) ~> ARB; + || (v4,v9,v8). (SUC v4,SOME v9,v8) ~> (SUC v4 + v9) + ]`` + *) -fun PMATCH_REMOVE_ARB_CONV_GENCALL_SINGLE rc_arg t = let +(* When removing subsumed rows, i.e. rows that can be dropped, + because a following rule covers them, we can sometimes drop rows with + right-hand-side ARB, because PMATCH v [] evalutates to ARB. + This is semantically fine, but changes the users-view. The resulting + case expression might e.g. not be exhaustive any more. This can + also cause trouble for code generation. Therefore the parameter + [exploit_match_exp] determines, whether this optimisation is performed. *) +fun PMATCH_REMOVE_SUBSUMED_CONV_GENCALL_SINGLE + exploit_match_exp rc_arg t = let val (v, rows) = dest_PMATCH t - val rows_rev = List.rev rows + val candidates = compute_row_pat_pairs rows + + (* quick filter on matching *) + val candidates_match = let + fun does_match ((_, p1), (_, p2)) = + can (match_term p2) p1 + in + List.filter does_match candidates + end - val i_rev = index (fn row => ( - is_arb (#4(dest_PMATCH_ROW_ABS row))) - handle HOL_ERR _ => false) rows_rev - val i = length rows - (i_rev + 1) + (* filtering finished, now try it for real *) + val cands_sub = List.map (fn ((p1, _), (p2, _)) => (p1, SOME p2)) candidates_match - val rows1 = List.take (rows, i) - val r = List.nth (rows, i) - val rows2 = List.drop (rows, i+1) + val cands_arb = Lib.mapfilter (fn (i, r) => let + val (_, _, _, r) = dest_PMATCH_ROW_ABS r in + (dest_arb r; (i, (NONE : int option))) end) (Lib.enumerate 0 rows) - val r_ty = type_of r - val rows1_tm = listSyntax.mk_list (rows1, r_ty) - val rows2_tm = listSyntax.mk_list (rows2, r_ty) - val r_thm = (snd (PMATCH_ROW_PABS_ELIM_CONV r)) handle - UNCHANGED => REFL r + val cands = if exploit_match_exp then (cands_sub @ cands_arb) else + cands_sub - val input_rows = - listSyntax.mk_append (rows1_tm, - listSyntax.mk_cons (rhs (concl r_thm), rows2_tm)) + (* val (r_no1, r_no2_opt) = el 2 cands_arb *) + fun try_pair (r_no1, r_no2_opt) = let + fun mk_row_list rs = listSyntax.mk_list (rs, type_of (hd rows)) - val thm0 = PART_MATCH (rand o lhs o snd o dest_imp o #2 o strip_forall) ( - ISPEC v (FRESH_TY_VARS_RULE PMATCH_REMOVE_ARB_NO_OVERLAP) - ) input_rows + fun extract_el_n n rs = let + val rows1 = List.take (rs, n) + val r1 = List.nth (rs, r_no1) + val rows_rest = List.drop (rs, r_no1+1) + val rows1_tm = mk_row_list rows1 + fun build_tm rest_tm = + listSyntax.mk_append (rows1_tm, + (listSyntax.mk_cons (r1, rest_tm))) + in + (rows_rest, build_tm) + end - val pre = rand (rator (concl thm0)) - val pre_thm = prove (pre, rc_tac rc_arg) - val thm1 = MP thm0 pre_thm - val thm2 = CONV_RULE - ((RHS_CONV o RAND_CONV) listLib.APPEND_CONV) - thm1 + val tm0 = let + val (rs_rest, bf_1) = extract_el_n r_no1 rows + + val rs2 = case r_no2_opt of + NONE => mk_row_list rs_rest + | SOME n => let + val n' = n - r_no1 - 1 + val (rs_rest', bf_2) = extract_el_n n' rs_rest + in + bf_2 (mk_row_list rs_rest') + end + in + mk_PMATCH v (bf_1 rs2) + end - val thm2_lhs_tm = mk_eq (t, lhs (concl thm2)) - val thm2_lhs = prove (thm2_lhs_tm, - MP_TAC r_thm THEN - rc_tac rc_arg) + val thm_base = case r_no2_opt of + NONE => PMATCH_REMOVE_ARB_NO_OVERLAP + | SOME _ => PMATCH_ROWS_DROP_SUBSUMED_PMATCH_ROWS + val thm0 = FRESH_TY_VARS_RULE thm_base + val thm1 = PART_MATCH (lhs o rand) thm0 tm0 - val thm3 = TRANS thm2_lhs thm2 + val thm2 = rc_elim_precond rc_arg thm1 + val thm3 = fix_appends rc_arg t thm2 + in + thm3 + end in - thm3 + Lib.tryfind try_pair cands end handle HOL_ERR _ => raise UNCHANGED -fun PMATCH_REMOVE_ARB_CONV_GENCALL rc_arg = REPEATC (PMATCH_REMOVE_ARB_CONV_GENCALL_SINGLE rc_arg) -fun PMATCH_REMOVE_ARB_CONV_GEN ssl = PMATCH_REMOVE_ARB_CONV_GENCALL (ssl, NONE) -val PMATCH_REMOVE_ARB_CONV = PMATCH_REMOVE_ARB_CONV_GEN [] +fun PMATCH_REMOVE_SUBSUMED_CONV_GENCALL eme rc_arg = REPEATC (PMATCH_REMOVE_SUBSUMED_CONV_GENCALL_SINGLE eme rc_arg) +fun PMATCH_REMOVE_SUBSUMED_CONV_GEN eme ssl = PMATCH_REMOVE_SUBSUMED_CONV_GENCALL eme (ssl, NONE) +fun PMATCH_REMOVE_SUBSUMED_CONV eme = PMATCH_REMOVE_SUBSUMED_CONV_GEN eme [] (***********************************************) @@ -1339,7 +1402,7 @@ REPEATC (FIRST_CONV [ CHANGED_CONV (PMATCH_CLEANUP_PVARS_CONV), CHANGED_CONV (PMATCH_CLEANUP_CONV_GENCALL rc_arg), CHANGED_CONV (PMATCH_REMOVE_REDUNDANT_CONV_GENCALL rc_arg), - CHANGED_CONV (PMATCH_REMOVE_ARB_CONV_GENCALL rc_arg), + CHANGED_CONV (PMATCH_REMOVE_SUBSUMED_CONV_GENCALL true rc_arg), CHANGED_CONV (PMATCH_SIMP_COLS_CONV_GENCALL rc_arg), CHANGED_CONV (PMATCH_EXPAND_COLS_CONV), CHANGED_CONV PMATCH_FORCE_SAME_VARS_CONV, @@ -1425,10 +1488,7 @@ fun PMATCH_ROW_REMOVE_DOUBLE_BIND_CONV_GENCALL rc_arg row = let (pairSyntax.list_mk_pair vars')) val thm1 = ISPEC g_tm thm0 val thm2 = PART_MATCH rand thm1 thm0_tm - - val pre = rand (rator (concl thm2)) - val pre_thm = prove (pre, rc_tac rc_arg) - val thm3 = MP thm2 pre_thm + val thm3 = rc_elim_precond rc_arg thm2 in thm3 end @@ -1508,25 +1568,16 @@ fun PMATCH_REMOVE_GUARD_AUX rc_arg t = let val (p_tm, g_tm, r_tm) = dest_PMATCH_ROW r val thm1 = ISPECL [v, rs1, rs2, p_tm, g_tm, r_tm] thm0 - val pre = rand (rator (concl thm1)) - val pre_thm = prove (pre, rc_tac rc_arg) - val thm2 = MP thm1 pre_thm - - val t_eq_thm = prove (mk_eq (t, lhs (concl thm2)), - CONV_TAC (DEPTH_CONV listLib.APPEND_CONV) THEN - REWRITE_TAC []) - - val thm3 = TRANS t_eq_thm thm2 + val thm2 = rc_elim_precond rc_arg thm1 + val thm3 = fix_appends rc_arg t thm2 in thm3 end val thm2 = CONV_RULE (RHS_CONV (RAND_CONV (RAND_CONV (RATOR_CONV (RAND_CONV PMATCH_ROW_FORCE_SAME_VARS_CONV))))) thm - val thm3 = CONV_RULE (RHS_CONV (RAND_CONV listLib.APPEND_CONV)) thm2 - in - thm3 + thm2 end handle HOL_ERR _ => raise UNCHANGED @@ -1591,10 +1642,9 @@ in val (thm1, is_inj) = let val thm00 = FRESH_TY_VARS_RULE PMATCH_PRED_UNROLL_CONS val thm01 = ISPECL [p_tm, v, pt, gt, rh, rows'_tm] thm00 - val pre = fst (dest_imp (concl thm01)) - val pre_thm = prove_attempt (pre, rc_tac rc_arg) + val thm02 = rc_elim_precond rc_arg thm01 in - (MP thm01 pre_thm, true) + (thm02, true) end handle HOL_ERR _ => let (* proving precond failed, try fallback theorem *) val thm00 = FRESH_TY_VARS_RULE PMATCH_PRED_UNROLL_CONS_NO_INJ diff --git a/examples/deep_matches/deepMatchesScript.sml b/examples/deep_matches/deepMatchesScript.sml index a053888d1f..e7ce4e399f 100644 --- a/examples/deep_matches/deepMatchesScript.sml +++ b/examples/deep_matches/deepMatchesScript.sml @@ -656,10 +656,11 @@ val PMATCH_ROWS_DROP_SUBSUMED = store_thm ( ``!r1 r2 rows1 rows2 rows3 v. ((!x. (r1 v = SOME x) ==> (r2 v = SOME x)) /\ (IS_SOME (r1 v) ==> EVERY (\row. (row v = NONE)) rows2)) ==> - (PMATCH v (rows1 ++ (r1 :: rows2) ++ (r2 :: rows3)) = + (PMATCH v (rows1 ++ (r1 :: (rows2 ++ (r2 :: rows3)))) = PMATCH v (rows1 ++ rows2 ++ (r2 :: rows3)))``, REPEAT STRIP_TAC THEN +REWRITE_TAC [GSYM rich_listTheory.APPEND_ASSOC_CONS] THEN SIMP_TAC (list_ss++boolSimps.CONJ_ss) [PMATCH_APPEND_SEM, RIGHT_AND_OVER_OR, EXISTS_OR_THM] THEN Cases_on `?r. MEM r rows1 ∧ IS_SOME (r v)` THEN ( @@ -688,7 +689,7 @@ val PMATCH_ROWS_DROP_SUBSUMED_PMATCH_ROWS = store_thm ( (!x x'. ((v = p x) /\ (p x = p' x') /\ g x /\ g' x') ==> (r x = r' x')) /\ (!x. ((v = p x) /\ (g x)) ==> EVERY (\row. (row (p x) = NONE)) rows2)) ==> - (PMATCH v (rows1 ++ (PMATCH_ROW p g r :: rows2) ++ (PMATCH_ROW p' g' r' :: rows3)) = + (PMATCH v (rows1 ++ (PMATCH_ROW p g r :: (rows2 ++ (PMATCH_ROW p' g' r' :: rows3)))) = PMATCH v (rows1 ++ rows2 ++ (PMATCH_ROW p' g' r' :: rows3)))``, REPEAT STRIP_TAC THEN @@ -737,7 +738,8 @@ val PMATCH_REMOVE_ARB_NO_OVERLAP = store_thm ("PMATCH_REMOVE_ARB_NO_OVERLAP", REPEAT STRIP_TAC THEN ONCE_REWRITE_TAC [PMATCH_INTRO_CATCHALL] THEN -SIMP_TAC list_ss [SNOC_APPEND] THEN +SIMP_TAC list_ss [SNOC_APPEND, + rich_listTheory.APPEND_ASSOC_CONS] THEN MATCH_MP_TAC PMATCH_ROWS_DROP_SUBSUMED_PMATCH_ROWS THEN ASM_SIMP_TAC std_ss []) From efca65d50a22d3f43ee0a71042bb3774aa7a6244 Mon Sep 17 00:00:00 2001 From: Magnus Myreen Date: Sat, 21 Mar 2015 07:47:32 +0100 Subject: [PATCH 243/718] fun-op-sem: improved file structure, more comments --- examples/fun-op-sem/Holmakefile | 1 + .../fun-op-sem/{non_det => for}/Holmakefile | 1 - examples/fun-op-sem/for/for.sml | 69 + examples/fun-op-sem/{ => for}/forScript.sml | 200 +-- .../{ => for}/for_compileScript.sml | 75 +- .../langScript.sml => for/for_ndScript.sml} | 57 +- .../for_nd_compileScript.sml} | 102 +- .../for_nd_semScript.sml} | 195 ++- examples/fun-op-sem/{ => imp}/impScript.sml | 20 + examples/fun-op-sem/ml/typeSoundScript.sml | 1383 +++++++++++++++++ 10 files changed, 1819 insertions(+), 284 deletions(-) create mode 100644 examples/fun-op-sem/Holmakefile rename examples/fun-op-sem/{non_det => for}/Holmakefile (65%) create mode 100644 examples/fun-op-sem/for/for.sml rename examples/fun-op-sem/{ => for}/forScript.sml (89%) rename examples/fun-op-sem/{ => for}/for_compileScript.sml (95%) rename examples/fun-op-sem/{non_det/langScript.sml => for/for_ndScript.sml} (62%) rename examples/fun-op-sem/{non_det/lang_compileScript.sml => for/for_nd_compileScript.sml} (94%) rename examples/fun-op-sem/{non_det/funScript.sml => for/for_nd_semScript.sml} (85%) rename examples/fun-op-sem/{ => imp}/impScript.sml (82%) create mode 100644 examples/fun-op-sem/ml/typeSoundScript.sml diff --git a/examples/fun-op-sem/Holmakefile b/examples/fun-op-sem/Holmakefile new file mode 100644 index 0000000000..18dc9a53d7 --- /dev/null +++ b/examples/fun-op-sem/Holmakefile @@ -0,0 +1 @@ +INCLUDES = imp for ml diff --git a/examples/fun-op-sem/non_det/Holmakefile b/examples/fun-op-sem/for/Holmakefile similarity index 65% rename from examples/fun-op-sem/non_det/Holmakefile rename to examples/fun-op-sem/for/Holmakefile index a145d3a74a..e64c77e7f7 100644 --- a/examples/fun-op-sem/non_det/Holmakefile +++ b/examples/fun-op-sem/for/Holmakefile @@ -1,2 +1 @@ -INCLUDES = .. OPTIONS = QUIT_ON_FAILURE diff --git a/examples/fun-op-sem/for/for.sml b/examples/fun-op-sem/for/for.sml new file mode 100644 index 0000000000..bd9950098a --- /dev/null +++ b/examples/fun-op-sem/for/for.sml @@ -0,0 +1,69 @@ + + datatype e = + Var of string + | Num of int + | Add of e * e + | Assign of string * e; + + datatype t = + Dec of string * t + | Exp of e + | Break + | Seq of t * t + | If of e * t * t + | For of e * e * t; + + datatype r = + Rval of int + | Rbreak + | Rtimeout + | Rfail; + + fun lookup y [] = NONE + | lookup y ((x,v)::xs) = if y = x then SOME v else lookup y xs + + fun run_e s (Var x) = + (case lookup x s of + NONE => (Rfail,s) + | SOME v => (Rval v,s)) + | run_e s (Num i) = (Rval i,s) + | run_e s (Add (e1, e2)) = + (case run_e s e1 of + (Rval n1, s1) => + (case run_e s1 e2 of + (Rval n2, s2) => (Rval (n1+n2), s2) + | r => r) + | r => r) + | run_e s (Assign (x, e)) = + (case run_e s e of + (Rval n1, s1) => (Rval n1, (x,n1)::s1) + | r => r) + + fun run_t s (Exp e) = run_e s e + | run_t s (Dec (x, t)) = run_t ((x,0)::s) t + | run_t s Break = (Rbreak, s) + | run_t s (Seq (t1, t2)) = + (case run_t s t1 of + (Rval _, s1) => run_t s1 t2 + | r => r) + | run_t s (If (e, t1, t2)) = + (case run_e s e of + (Rval n1, s1) => + if n1 = 0 then + run_t s1 t2 + else + run_t s1 t1 + | r => r) + | run_t s (For (e1, e2, t)) = + (case run_e s e1 of + (Rval n1, s1) => + if n1 = 0 then (Rval 0, s1) else + (case run_t s1 t of + (Rval _, s2) => + (case run_e s2 e2 of + (Rval _, s3) => run_t s3 (For (e1, e2, t)) + | r => r) + | (Rbreak, s2) => + (Rval 0, s2) + | r => r) + | r => r) diff --git a/examples/fun-op-sem/forScript.sml b/examples/fun-op-sem/for/forScript.sml similarity index 89% rename from examples/fun-op-sem/forScript.sml rename to examples/fun-op-sem/for/forScript.sml index 516a1f693b..a92b7a04cb 100644 --- a/examples/fun-op-sem/forScript.sml +++ b/examples/fun-op-sem/for/forScript.sml @@ -2,19 +2,31 @@ open HolKernel Parse boolLib bossLib; val _ = new_theory "for"; +(* + +This file defines a simple FOR language that's very similar to the FOR +language used by Arthur Charguéraud in his ESOP'13 paper: + + Pretty-Big-Step Semantics + http://www.chargueraud.org/research/2012/pretty/ + +This file defines: + - the syntax of the language, + - a functional big-step semantics (an interpreter with a clock), + - a conventional relational big-step semantics, and + - a very simple type checker (that is proved sound) + +*) + open optionTheory pairTheory pred_setTheory finite_mapTheory stringTheory; -open integerTheory; -open lcsymtacs; +open integerTheory lcsymtacs; val _ = temp_tight_equality (); val ect = BasicProvers.EVERY_CASE_TAC; -val OMIT_def = Define `OMIT x = x`; -val OMIT_INTRO = prove( - ``(P1 ==> P2 ==> Q) ==> (P1 /\ OMIT P2 ==> Q)``, - fs [OMIT_def]); +(* === Syntax === *) val _ = Datatype ` e = Var string @@ -40,6 +52,9 @@ r = Rval int val r_distinct = fetch "-" "r_distinct"; val r_11 = fetch "-" "r_11"; + +(* === Functional big-step semantics === *) + val _ = Datatype ` state = <| store : string |-> int; clock : num |>`; @@ -55,6 +70,8 @@ val state_rw = Q.prove ( (!s. <| store := s.store; clock := s.clock |> = s)`, rw [state_component_equality]); +(* Expression evaluation *) + val sem_e_def = Define ` (sem_e s (Var x) = case FLOOKUP s.store x of @@ -76,32 +93,26 @@ val sem_e_def = Define ` (Rval n1, store_var x n1 s1) | r => r)`; +(* HOL4's definition requires a little help with the definition. In + particular, we need to help it see that the clock does not + decrease. To do this, we add a few redundant checks (check_clock) + to the definition of the sem_t function. These redundant checks are + removed later in the script. *) + val sem_e_clock = Q.store_thm ("sem_e_clock", `!s e r s'. sem_e s e = (r, s') ⇒ s.clock = s'.clock`, - Induct_on `e` >> - rw [sem_e_def] >> - ect >> - fs [] >> - rw [] >> - metis_tac []); + Induct_on `e` >> rw [sem_e_def] >> ect >> + fs [] >> rw [] >> metis_tac []); val sem_e_store = Q.prove ( `!s e r s'. sem_e s e = (r, s') ⇒ FDOM s.store ⊆ FDOM s'.store`, - Induct_on `e` >> - rw [sem_e_def] >> - ect >> - fs [SUBSET_DEF] >> - rw [] >> - metis_tac []); + Induct_on `e` >> rw [sem_e_def] >> ect >> + fs [SUBSET_DEF] >> rw [] >> metis_tac []); val sem_e_res = Q.prove ( `!s e r s'. sem_e s e = (r, s') ⇒ r ≠ Rbreak ∧ r ≠ Rtimeout`, - Induct_on `e` >> - rw [sem_e_def] >> - ect >> - fs [] >> - rw [] >> - metis_tac []); + Induct_on `e` >> rw [sem_e_def] >> ect >> + fs [] >> rw [] >> metis_tac []); val check_clock_def = Define ` check_clock s' s = @@ -114,6 +125,8 @@ val dec_clock_store = Q.store_thm ("dec_clock_store[simp]", `!s. (dec_clock s).store = s.store`, rw [dec_clock_def]); +(* Statement evaluation -- with redundant check_clock *) + val sem_t_def = tDefine "sem_t" ` (sem_t s (Exp e) = sem_e s e) ∧ (sem_t s (Dec x t) = @@ -177,6 +190,8 @@ val check_clock_id = Q.prove ( val STOP_def = Define ` STOP x = x`; +(* Statement evaluation -- without any redundant checks *) + val sem_t_def_with_stop = Q.store_thm ("sem_t_def_with_stop", `(sem_t s (Exp e) = sem_e s e) ∧ (sem_t s (Dec x t) = sem_t (store_var x 0 s) t) ∧ @@ -225,6 +240,8 @@ val sem_t_def_with_stop = Q.store_thm ("sem_t_def_with_stop", val sem_t_def = save_thm("sem_t_def",REWRITE_RULE [STOP_def] sem_t_def_with_stop); +(* We also remove the redundant checks from the induction theorem. *) + val sem_t_ind = Q.store_thm("sem_t_ind", `!P. (!s e. P s (Exp e)) /\ @@ -299,6 +316,27 @@ val sem_t_store = Q.prove ( metis_tac [sem_e_store, SUBSET_TRANS]) >> metis_tac [sem_e_store, SUBSET_TRANS])); +(* The top-level semantics defines what is externally observable *) + +val _ = Datatype ` + observation = Terminate | Diverge | Crash`; + +val s_with_clock_def = Define ` + s_with_clock c = <| store := FEMPTY; clock := c |>`; + +val semantics_def = Define ` + semantics t = + if (?c v s. sem_t (s_with_clock c) t = (Rval v,s)) then + Terminate + else if (!c. ?s. sem_t (s_with_clock c) t = (Rtimeout,s)) then + Diverge + else Crash` + +val semantics_thm = save_thm("semantics_thm",semantics_def); + + +(* === A simple type checker === *) + val type_e_def = Define ` (type_e s (Var x) ⇔ x ∈ s) ∧ (type_e s (Num num) ⇔ T) ∧ @@ -365,7 +403,7 @@ val type_weakening_t = Q.prove ( metis_tac [SUBSET_DEF, NOT_SOME_NONE, SOME_11, type_weakening_e, INSERT_SUBSET]); (* Have to use sem_t_ind, and not type_t_ind or t_induction. This is different - * than small-step-based type soundness *) + * from small-step-based type soundness *) val type_sound_t = Q.prove ( `!s1 t in_for s. type_t in_for s t ∧ s ⊆ FDOM s1.store @@ -444,23 +482,8 @@ val type_sound_t = Q.prove ( metis_tac [SUBSET_TRANS]) >> metis_tac [sem_e_res])); -val _ = Datatype ` - observation = Terminate | Diverge | Crash`; - -val s_with_clock_def = Define ` - s_with_clock c = <| store := FEMPTY; clock := c |>`; - -val semantics_def = Define ` - semantics t = - if (?c v s. sem_t (s_with_clock c) t = (Rval v,s)) then - Terminate - else if (!c. ?s. sem_t (s_with_clock c) t = (Rtimeout,s)) then - Diverge - else Crash` - -val semantics_thm = save_thm("semantics_thm",semantics_def); +(* A type checked program does not Crash. *) -(* This proof is disgusting *) val type_soundness = Q.store_thm("type_soundness", `!t. type_t F {} t ⇒ semantics t ≠ Crash`, rw [semantics_def] >> @@ -473,6 +496,9 @@ val type_soundness = Q.store_thm("type_soundness", \\ Cases_on `r` \\ fs[] \\ METIS_TAC []); + +(* === A relational big-step semantics === *) + val is_rval_def = Define ` (is_rval (Rval _) = T) ∧ (is_rval _ = F)`; @@ -514,6 +540,7 @@ val (sem_e_reln_rules, sem_e_reln_ind, sem_e_reln_cases) = Hol_reln ` ⇒ sem_e_reln s (Assign x e) (r, s1))`; +(* The first argument indicates whether this is a clocked semantics or not *) val (sem_t_reln_rules, sem_t_reln_ind, sem_t_reln_cases) = Hol_reln ` (!s e r. sem_e_reln s e r @@ -679,6 +706,12 @@ val (simple_sem_t_reln_rules, simple_sem_t_reln_ind, simple_sem_t_reln_cases) = ⇒ simple_sem_t_reln s (For e1 e2 t) (r, s2))`; +val OMIT_def = Define `OMIT x = x`; + +val OMIT_INTRO = prove( + ``(P1 ==> P2 ==> Q) ==> (P1 /\ OMIT P2 ==> Q)``, + fs [OMIT_def]); + val _ = Parse.add_infix("DOWNARROWe",450,Parse.NONASSOC) val _ = Parse.add_infix("DOWNARROWt",450,Parse.NONASSOC) @@ -813,6 +846,8 @@ semantics_reln t = | SOME (Rval _, _) => Terminate | _ => Crash`; +(* Some proofs relating the relational and functional semantics *) + val big_sem_correct_lem1 = Q.prove ( `∀s e r. sem_e_reln s e r @@ -931,88 +966,5 @@ val big_sem_correct_lem5 = Q.prove ( imp_res_tac sem_e_clock >> fs [] >> metis_tac [big_sem_correct_lem1, big_sem_correct_lem2, sem_e_ignores_clock, FST, SND, sem_e_res]); - (* - -val big_sem_correct_lem6 = Q.prove ( -`∀s t r. - sem_t_reln F (s with clock := (SND r).clock) t r - ⇔ - (?c. FST r ≠ Rtimeout ∧ sem_t (s with clock := c) t = r)`, - ho_match_mp_tac sem_t_ind >> - rpt conj_tac - >- (rw [sem_t_def, Once sem_t_reln_cases] >> - metis_tac [big_sem_correct_lem5]) - >- (rw [sem_t_def] >> - rw [Once sem_t_reln_cases]) - >- (rw [sem_t_def] >> - rw [Once sem_t_reln_cases] >> - PairCases_on `r` >> - fs [] >> - eq_tac >> - rw [] >> - rw [] >> - metis_tac []) - >- (rw [sem_t_def] >> - rw [Once sem_t_reln_cases] >> - PairCases_on `r` >> - fs [] >> - eq_tac >> - rw [] >> - ect >> - fs [] >> - metis_tac [is_rval_def, big_sem_correct_lem1, PAIR_EQ, r_distinct, r_11, - SND] - - >- (rw [sem_t_def] >> - rw [Once sem_t_reln_cases] >> - ect >> - fs [] >> - eq_tac >> - rw [] >> - imp_res_tac big_sem_correct_lem1 >> - fs [] >> - rw [] >> - rfs [] - >- metis_tac [is_rval_def, big_sem_correct_lem1, big_sem_correct_lem2, PAIR_EQ, r_distinct, r_11, pair_CASES] - >- (disj1_tac >> - imp_res_tac big_sem_correct_lem2 >> - qexists_tac `r'` >> - rw []) - >- metis_tac [is_rval_def, big_sem_correct_lem1, big_sem_correct_lem2, PAIR_EQ, r_distinct, r_11, pair_CASES] - >- (disj2_tac >> - disj1_tac >> - imp_res_tac big_sem_correct_lem2 >> - qexists_tac `r'` >> - qexists_tac `i` >> - rw []) >> - metis_tac [is_rval_def, big_sem_correct_lem1, big_sem_correct_lem2, PAIR_EQ, r_distinct, r_11, pair_CASES]) - >- (rw [] >> - rw [Once sem_t_reln_cases, Once sem_t_def] >> - Cases_on `sem_e s e1` >> - rw [] >> - Cases_on `q` >> - rw [] >> - PairCases_on `r` >> - fs [big_sem_correct_lem3] >> - rw [] - >- metis_tac [is_rval_def, big_sem_correct_lem1, big_sem_correct_lem2, PAIR_EQ, r_distinct, r_11, pair_CASES, PAIR_EQ] - >- (ect >> - rw [] >> - rfs [] >> - metis_tac [dec_clock_def, is_rval_def, big_sem_correct_lem1, big_sem_correct_lem2, PAIR_EQ, r_distinct, r_11, pair_CASES]) >> - metis_tac [is_rval_def, big_sem_correct_lem1, big_sem_correct_lem2, PAIR_EQ, r_distinct, r_11, pair_CASES, PAIR_EQ])); - -val big_sem_correct = Q.prove ( -`!t. semantics_reln t = semantics t`, - rw [semantics_def, semantics_reln_def, big_sem_correct_lem4] - \\ ect \\ fs []); - -val semantics_reln_no_clock_def = Define ` -semantics_reln_no_clock t = - case some (r,s). sem_t_reln F <| store := FEMPTY; clock := 0 |> t (r, s) of - | NONE => Diverge - | SOME (Rval _, _) => Terminate - | _ => Crash`; - *) val _ = export_theory (); diff --git a/examples/fun-op-sem/for_compileScript.sml b/examples/fun-op-sem/for/for_compileScript.sml similarity index 95% rename from examples/fun-op-sem/for_compileScript.sml rename to examples/fun-op-sem/for/for_compileScript.sml index 649f4ce381..19170fdb5b 100644 --- a/examples/fun-op-sem/for_compileScript.sml +++ b/examples/fun-op-sem/for/for_compileScript.sml @@ -2,6 +2,20 @@ open HolKernel Parse boolLib bossLib; val _ = new_theory "for_compile"; +(* + +This file proves correctness of a compiler for the FOR language +defined in forScript.sml. The compiler targets a simple assembly-like +language. We prove that the compiler preserves the top-level +observable semantics. + +The compiler consists of three passes: + - the first pass simplifies For loops and removes Dec + - the second pass compiles expressions into very simple assignments + - the third pass maps the FOR language into assmembly code + +*) + open optionTheory pairTheory pred_setTheory finite_mapTheory stringTheory; open lcsymtacs forTheory listTheory arithmeticTheory; @@ -11,7 +25,21 @@ val ect = BasicProvers.EVERY_CASE_TAC; val IMP_IMP = METIS_PROVE [] ``b /\ (b1 ==> b2) ==> ((b ==> b1) ==> b2)`` -(* verification of PASS 1, which reduces complexity of For and removes Dec *) + +(* === PASS 1 : simplifies For loops and removes Dec === *) + +val Loop_def = Define ` + Loop t = For (Num 1) (Num 1) t`; + +val pass1_def = Define ` + (pass1 (Exp e) = Exp e) /\ + (pass1 (Dec x t) = Seq (Exp (Assign x (Num 0))) (pass1 t)) /\ + (pass1 (Break) = Break) /\ + (pass1 (Seq t1 t2) = Seq (pass1 t1) (pass1 t2)) /\ + (pass1 (If e t1 t2) = If e (pass1 t1) (pass1 t2)) /\ + (pass1 (For e1 e2 t) = Loop (If e1 (Seq (pass1 t) (Exp e2)) Break))`; + +(* Verification of pass 1 *) val sem_t_Dec = store_thm("sem_t_Dec", ``sem_t s (Dec v t) = @@ -27,9 +55,6 @@ val sem_t_eval = save_thm("sem_t_eval", (EVAL THENC REWRITE_CONV [sem_t_pull_if] THENC EVAL) ``sem_t s (If b (Exp (Num 0)) Break)``); -val Loop_def = Define ` - Loop t = For (Num 1) (Num 1) t`; - val sem_t_Loop = save_thm("sem_t_Loop", ``sem_t s (Loop t)`` |> (SIMP_CONV (srw_ss()) [Once sem_t_def,sem_e_def,Loop_def] THENC @@ -76,14 +101,6 @@ val sem_t_For = store_thm("sem_t_For", \\ imp_res_tac sem_t_clock \\ decide_tac); -val pass1_def = Define ` - (pass1 (Exp e) = Exp e) /\ - (pass1 (Dec x t) = Seq (Exp (Assign x (Num 0))) (pass1 t)) /\ - (pass1 (Break) = Break) /\ - (pass1 (Seq t1 t2) = Seq (pass1 t1) (pass1 t2)) /\ - (pass1 (If e t1 t2) = If e (pass1 t1) (pass1 t2)) /\ - (pass1 (For e1 e2 t) = Loop (If e1 (Seq (pass1 t) (Exp e2)) Break))`; - val pass1_correct = store_thm("pass1_correct", ``!t s. sem_t s (pass1 t) = sem_t s t``, Induct \\ fs [pass1_def,sem_t_def_with_stop,GSYM sem_t_For,GSYM sem_t_Dec] @@ -95,7 +112,7 @@ val pass1_pres = store_thm("pass1_pres", fs [semantics_def,pass1_correct]); -(* verification of PASS 2, which flattens all expressions *) +(* === PASS 2 : compiles expressions into very simple assignments === *) val comp_exp_def = Define ` (comp_exp (Var v) s = Exp (Assign s (Var v))) /\ @@ -135,6 +152,8 @@ val t_max_def = Define ` val pass2_def = Define ` pass2 t = flatten_t t ("temp" ++ REPLICATE (t_max t - 3) #"'")`; +(* Verification of pass 2 *) + val possible_var_name_def = Define ` possible_var_name v s = !n. ~(v ++ REPLICATE n #"'" IN FDOM s)`; @@ -382,6 +401,11 @@ val lemma = prove( ``((if b then x1 else x2) <> x2) <=> (x1 <> x2) /\ b``, Cases_on `b` \\ fs []) +(* We prove that pass 2 preserves semantics if the source semantics + does not Crash (implied by successful type check) and if the syntax + of the compiler program fits with pass2_subset (i.e. syntax + produced by pass1) *) + val pass2_pres = store_thm("pass2_pres", ``!t. semantics t <> Crash /\ pass2_subset t ==> semantics (pass2 t) = semantics t``, @@ -392,7 +416,9 @@ val pass2_pres = store_thm("pass2_pres", \\ MP_TAC pass2_correct_FST \\ fs []); -(* verification of PASS 3, which generates assmebly programs *) +(* === PASS 3 : maps the FOR language into assmembly code === *) + +(* We define the tagert assembly language *) val _ = Datatype ` reg = Reg string` @@ -480,6 +506,8 @@ val asm_semantics_def = Define ` else if (!c. ?s. sem_a (a_state code c) = (Rtimeout,s)) then Diverge else Crash`; +(* Definition of pass3 *) + val pass3_aux_def = Define ` (pass3_aux n (Dec v t) b = []) /\ (pass3_aux n (Exp e) b = @@ -508,6 +536,8 @@ val pass3_aux_def = Define ` val pass3_def = Define ` pass3 t = pass3_aux 0 t 0 ++ [Halt]`; +(* Verification of pass3 *) + val LENGTH_pass3_aux = prove( ``!t n b. LENGTH (pass3_aux n t b) = LENGTH (pass3_aux 0 t 0)``, Induct \\ fs [pass3_aux_def,LET_DEF]); @@ -771,6 +801,10 @@ val pass3_correct = store_thm("pass3_correct", \\ SIMP_TAC std_ss [Once sem_a_def] \\ fs [rich_listTheory.EL_LENGTH_APPEND]); +(* We prove that pass3 preserves semantics if the source does not + crash and if the syntax fits within the subset defined by + pass3_subset. *) + val pass3_pres = store_thm("pass3_pres", ``!t. semantics t <> Crash /\ pass3_subset t ==> asm_semantics (pass3 t) = semantics t``, @@ -796,11 +830,14 @@ val pass3_pres = store_thm("pass3_pres", \\ POP_ASSUM (MP_TAC o Q.SPEC `a_state (pass3 t) c`) \\ fs [a_state_def] \\ REPEAT STRIP_TAC \\ fs []); -(* the entire compiler *) + +(* === The end-to-end compiler === *) val compile_def = Define ` compile t = pass3 (pass2 (pass1 t))`; +(* Verification of the compile function *) + val pass2_subset_pass1 = prove( ``!t. pass2_subset (pass1 t)``, Induct \\ fs [pass1_def,pass2_subset_def,Loop_def]); @@ -820,6 +857,10 @@ val pass3_subset_pass2_pass1 = prove( \\ MATCH_MP_TAC pass3_subset_flatten_t \\ fs [pass2_subset_pass1]); +(* The compile function produces code that has observable behaviour + that is identical to the source program, if the course program does + not Crash. *) + val compile_pres = store_thm("compile_pres", ``!t. semantics t <> Crash ==> (asm_semantics (compile t) = semantics t)``, @@ -832,6 +873,10 @@ val compile_pres = store_thm("compile_pres", \\ MATCH_MP_TAC pass3_pres \\ fs [pass2_pres,pass2_subset_pass1,pass3_subset_pass2_pass1]); +(* The simple type checker (defined in forScript.sml) ensures that the + source program cannot Crash. This leads to a cleaner top-level + correctness theorem for compile. *) + val syntax_ok_def = Define ` syntax_ok t = type_t F {} t`; diff --git a/examples/fun-op-sem/non_det/langScript.sml b/examples/fun-op-sem/for/for_ndScript.sml similarity index 62% rename from examples/fun-op-sem/non_det/langScript.sml rename to examples/fun-op-sem/for/for_ndScript.sml index ae95c4e32b..bacec2a39e 100644 --- a/examples/fun-op-sem/non_det/langScript.sml +++ b/examples/fun-op-sem/for/for_ndScript.sml @@ -1,11 +1,21 @@ -(* Define the syntax of a simple imperative language of For loops with IO and - * non-determinism. A simple type system ensures that all breaks are inside of - * for loops, and that no undeclared variables are accessed - *) - open HolKernel Parse boolLib bossLib; -val _ = new_theory "lang"; +val _ = new_theory "for_nd"; + +(* + +This file defines a FOR language that's very similar to the language +used by Arthur Charguéraud in his ESOP'13 paper: + + Pretty-Big-Step Semantics + http://www.chargueraud.org/research/2012/pretty/ + +In this non-deterministic (nd) version of Charguéraud's FOR language, +we add basic I/O and non-deterministic evaluation order. + +A simpler version of this language can be found in forScript.sml. + +*) open pred_setTheory optionTheory stringTheory llistTheory integerTheory; open lcsymtacs; @@ -13,11 +23,14 @@ open lcsymtacs; val _ = temp_tight_equality (); val ect = BasicProvers.EVERY_CASE_TAC; -(* Expressions - * Evaluation order of Add is unspecified, but one subexpression must be - * completely evaluated before the other. - * Getchar returns -1 to signal the end of file. - *) + +(* === Syntax === *) + +(* Expressions: + - Evaluation order of Add is unspecified, but one subexpression + must be completely evaluated before the other. + - Getchar returns -1 to signal the end of file. *) + val _ = Datatype ` e = Var string | Num int @@ -26,7 +39,7 @@ e = Var string | Getchar | Putchar e`; -(* Statements *) +(* Statements: *) val _ = Datatype ` t = | Dec string t @@ -36,12 +49,15 @@ t = | If e t t | For e e t`; -(* What is observable about program behaviour. It can terminate after doing a - * finite amount of I/O; it can diverge doing a potentially infinite amount of IO - * (llist is the lazy list type constructor of lists that can be either finite or - * infinite); or it can crash. We don't bother with the pre-crash IO because - * well-typed programs won't crash. - *) + +(* === Types used in semantics (given in for_nd_semScript.sml) === *) + +(* What is observable about program behaviour. A program can terminate + after doing a finite amount of I/O; it can diverge doing a + potentially infinite amount of IO (llist is the lazy list type + constructor of lists that can be either finite or infinite); or it + can crash. We don't bother with the pre-crash IO because well-typed + programs won't crash. *) val _ = Datatype ` io_tag = Itag int | Otag int`; @@ -57,7 +73,10 @@ getchar stream = let v = &(ORD (THE (LHD stream))) in (v, rest)`; -(* A simple type system to check for Break statements and variable accesses *) + +(* === A simple type system === *) + +(* This type system checks for Break statements and variable accesses. *) val type_e_def = Define ` (type_e s (Var x) ⇔ x ∈ s) ∧ (type_e s (Num num) ⇔ T) ∧ diff --git a/examples/fun-op-sem/non_det/lang_compileScript.sml b/examples/fun-op-sem/for/for_nd_compileScript.sml similarity index 94% rename from examples/fun-op-sem/non_det/lang_compileScript.sml rename to examples/fun-op-sem/for/for_nd_compileScript.sml index 93e6be6d15..3e7cbec356 100644 --- a/examples/fun-op-sem/non_det/lang_compileScript.sml +++ b/examples/fun-op-sem/for/for_nd_compileScript.sml @@ -1,9 +1,23 @@ open HolKernel Parse boolLib bossLib; -val _ = new_theory "lang_compile"; +val _ = new_theory "for_nd_compile"; + +(* + +This file proves correctness of a compiler for the FOR language +defined in for_ndScript.sml and for_nd_semScript.sml. The compiler +targets a simple assembly-like language. We prove that the compiler +preserves the top-level observable semantics. + +The compiler consists of three passes: + - the first pass simplifies For loops and removes Dec + - the second pass compiles expressions into very simple assignments + - the third pass maps the FOR language into assmembly code + +*) open optionTheory pairTheory pred_setTheory finite_mapTheory stringTheory; -open lcsymtacs langTheory funTheory listTheory arithmeticTheory; +open lcsymtacs for_ndTheory for_nd_semTheory listTheory arithmeticTheory; val _ = temp_tight_equality (); @@ -11,7 +25,21 @@ val ect = BasicProvers.EVERY_CASE_TAC; val IMP_IMP = METIS_PROVE [] ``b /\ (b1 ==> b2) ==> ((b ==> b1) ==> b2)`` -(* verification of PASS 1, which reduces complexity of For and removes Dec *) + +(* === PASS 1 : simplifies For loops and removes Dec === *) + +val Loop_def = Define ` + Loop t = For (Num 1) (Num 1) t`; + +val pass1_def = Define ` + (pass1 (Exp e) = Exp e) /\ + (pass1 (Dec x t) = Seq (Exp (Assign x (Num 0))) (pass1 t)) /\ + (pass1 (Break) = Break) /\ + (pass1 (Seq t1 t2) = Seq (pass1 t1) (pass1 t2)) /\ + (pass1 (If e t1 t2) = If e (pass1 t1) (pass1 t2)) /\ + (pass1 (For e1 e2 t) = Loop (If e1 (Seq (pass1 t) (Exp e2)) Break))`; + +(* Verification of pass 1 *) val sem_t_Dec = store_thm("sem_t_Dec", ``sem_t s (Dec v t) = @@ -27,9 +55,6 @@ val sem_t_eval = save_thm("sem_t_eval", (EVAL THENC REWRITE_CONV [sem_t_pull_if] THENC EVAL) ``sem_t s (If b (Exp (Num 0)) Break)``); -val Loop_def = Define ` - Loop t = For (Num 1) (Num 1) t`; - val sem_t_Loop = save_thm("sem_t_Loop", ``sem_t s (Loop t)`` |> (SIMP_CONV (srw_ss()) [Once sem_t_def,sem_e_def,Loop_def] THENC @@ -77,14 +102,6 @@ val sem_t_For = store_thm("sem_t_For", \\ imp_res_tac sem_t_clock \\ decide_tac); -val pass1_def = Define ` - (pass1 (Exp e) = Exp e) /\ - (pass1 (Dec x t) = Seq (Exp (Assign x (Num 0))) (pass1 t)) /\ - (pass1 (Break) = Break) /\ - (pass1 (Seq t1 t2) = Seq (pass1 t1) (pass1 t2)) /\ - (pass1 (If e t1 t2) = If e (pass1 t1) (pass1 t2)) /\ - (pass1 (For e1 e2 t) = Loop (If e1 (Seq (pass1 t) (Exp e2)) Break))`; - val pass1_correct = store_thm("pass1_correct", ``!t s. sem_t s (pass1 t) = sem_t s t``, Induct \\ fs [pass1_def,sem_t_def_with_stop,GSYM sem_t_For,GSYM sem_t_Dec] @@ -97,7 +114,7 @@ val pass1_pres = store_thm("pass1_pres", \\ fs [semantics_def,pass1_correct]); -(* verification of PASS 2, which flattens all expressions *) +(* === PASS 2 : compiles expressions into very simple assignments === *) val comp_exp_def = Define ` (comp_exp (Var v) s = Exp (Assign s (Var v))) /\ @@ -141,6 +158,8 @@ val t_max_def = Define ` val pass2_def = Define ` pass2 t = flatten_t t ("temp" ++ REPLICATE (t_max t - 3) #"'")`; +(* Verification of pass 2 *) + val possible_var_name_def = Define ` possible_var_name v s = !n. ~(v ++ REPLICATE n #"'" IN FDOM s)`; @@ -430,6 +449,12 @@ val lemma = prove( ``((if b then x1 else x2) <> x2) <=> (x1 <> x2) /\ b``, Cases_on `b` \\ fs []) +(* We prove that pass 2 preserves semantics: any behaviour that the + generated code has must also be behaviour of the input program, if + the source semantics does not contain Crash (implied by successful + type check) and if the syntax of the compiler program fits with + pass2_subset (i.e. syntax produced by pass1) *) + val pass2_pres = store_thm("pass2_pres", ``!t input. ~(Crash IN semantics t input) /\ pass2_subset t ==> semantics (pass2 t) input SUBSET semantics t input``, @@ -471,7 +496,9 @@ val pass2_pres = store_thm("pass2_pres", \\ METIS_TAC []); -(* verification of PASS 3, which generates assmebly programs *) +(* === PASS 3 : maps the FOR language into assmembly code === *) + +(* We define the tagert deterministic assembly language *) val _ = Datatype ` reg = Reg string` @@ -572,29 +599,33 @@ val a_state_def = Define ` val asm_semantics_def = Define ` (asm_semantics code input (Terminate io_trace) = - (* Terminate when there is a clock and some non-determinism oracle that gives a value result *) + (* Terminate when there is a clock and some non-determinism oracle + that gives a value result *) ?c i s. sem_a (a_state code c input) = (Rval i, s) /\ s.state.io_trace = io_trace) /\ (asm_semantics code input Crash = - (* Crash when there is a clock that gives a non-value, non-timeout result *) + (* Crash when there is a clock that gives a non-value, non-timeout + result *) ?c r s. sem_a (a_state code c input) = (r, s) /\ (r = Rbreak \/ r = Rfail)) /\ (asm_semantics code input (Diverge io_trace) <=> - (* Diverge when all clocks give timeout results. Ensure that the IO trace to - * the timeout point is a prefix of the whole trace. *) + (* Diverge when all clocks give timeout results. Ensure that the IO + trace to the timeout point is a prefix of the whole trace. *) (!c. ?s. sem_a (a_state code c input) = (Rtimeout, s) /\ (!n. n < LENGTH s.state.io_trace ==> LNTH n io_trace = SOME (EL n s.state.io_trace))) /\ - (* Check that the whole IO trace is reachable, but maybe not for just 1 - * clock value*) + (* Check that the whole IO trace is reachable, but maybe not for + just 1 clock value *) (!n x. LNTH n io_trace = SOME x ==> ?c s. sem_a (a_state code c input) = (Rtimeout, s) /\ n < LENGTH s.state.io_trace /\ EL n s.state.io_trace = x))`; +(* Definition of pass3 *) + val pass3_aux_def = Define ` (pass3_aux n (Dec v t) b = []) /\ (pass3_aux n (Exp e) b = @@ -625,6 +656,8 @@ val pass3_aux_def = Define ` val pass3_def = Define ` pass3 t = pass3_aux 0 t 0 ++ [Halt]`; +(* Verification of pass3 *) + val LENGTH_pass3_aux = prove( ``!t n b. LENGTH (pass3_aux n t b) = LENGTH (pass3_aux 0 t 0)``, Induct \\ fs [pass3_aux_def,LET_DEF]); @@ -923,6 +956,10 @@ val pass3_correct = store_thm("pass3_correct", \\ SIMP_TAC std_ss [Once sem_a_def] \\ fs [rich_listTheory.EL_LENGTH_APPEND]); +(* We prove that pass3 preserves semantics if the source does not + contain Crash and if the syntax fits within the subset defined by + pass3_subset. *) + val pass3_pres = store_thm("pass3_pres", ``!t input. ~(Crash IN semantics t input) /\ pass3_subset t ==> asm_semantics (pass3 t) input SUBSET semantics t input``, @@ -968,11 +1005,14 @@ val pass3_pres = store_thm("pass3_pres", \\ fs [s_with_clock_def,init_st_def,a_state_def] \\ Q.LIST_EXISTS_TAC [`c`] \\ fs []); -(* the entire compiler *) + +(* === The end-to-end compiler === *) val compile_def = Define ` compile t = pass3 (pass2 (pass1 t))`; +(* Verification of the compile function *) + val pass2_subset_pass1 = prove( ``!t. pass2_subset (pass1 t)``, Induct \\ fs [pass1_def,pass2_subset_def,Loop_def]); @@ -992,6 +1032,10 @@ val pass3_subset_pass2_pass1 = prove( \\ MATCH_MP_TAC pass3_subset_flatten_t \\ fs [pass2_subset_pass1]); +(* Any observable behaviour of the compiled code is also observable + behaviour of the source code, if Crash is not an observable + behaviour of the course program. *) + val compile_pres = store_thm("compile_pres", ``!t input. ~(Crash IN semantics t input) ==> asm_semantics (compile t) input SUBSET semantics t input``, @@ -1009,12 +1053,16 @@ val compile_pres = store_thm("compile_pres", \\ METIS_TAC []) \\ MATCH_MP_TAC pass2_pres \\ fs [pass2_subset_pass1]); +(* The simple type checker (defined in for_nd_semScript.sml) ensures + that the source program cannot Crash. This leads to a cleaner + top-level correctness theorem for compile. *) + val syntax_ok_def = Define ` - syntax_ok t = !input. ~(Crash IN semantics t input)`; + syntax_ok t = type_t F {} t`; val compile_correct = store_thm("compile_correct", - ``!t i. syntax_ok t ==> - asm_semantics (compile t) i SUBSET semantics t i``, - METIS_TAC [syntax_ok_def,compile_pres]); + ``!t inp. syntax_ok t ==> + asm_semantics (compile t) inp SUBSET semantics t inp``, + METIS_TAC [type_soundness,syntax_ok_def,compile_pres]); val _ = export_theory (); diff --git a/examples/fun-op-sem/non_det/funScript.sml b/examples/fun-op-sem/for/for_nd_semScript.sml similarity index 85% rename from examples/fun-op-sem/non_det/funScript.sml rename to examples/fun-op-sem/for/for_nd_semScript.sml index b147e5d30e..bfaeb7ae80 100644 --- a/examples/fun-op-sem/non_det/funScript.sml +++ b/examples/fun-op-sem/for/for_nd_semScript.sml @@ -1,20 +1,30 @@ open HolKernel Parse boolLib bossLib; -val _ = new_theory "fun"; +val _ = new_theory "for_nd_sem"; + +(* + +This file defines a functional big-step semantics for the FOR language +syntax given in for_ndScript.sml. The language has basic I/O and +non-deterministic evaluation order. + +A simpler version of this language can be found in forScript.sml. + +*) open optionTheory pairTheory pred_setTheory finite_mapTheory stringTheory; open llistTheory integerTheory; -open langTheory; +open for_ndTheory; open lcsymtacs; val ect = BasicProvers.EVERY_CASE_TAC; val _ = temp_tight_equality (); -(* The result of running a program. Rtimeout indicates an attempt to loop with - * no clock left. Rfail indicates an undeclared variable access or a Break not - * in a For. - *) +(* The result of running a program. Rtimeout indicates an attempt to + loop with no clock left. Rfail indicates an undeclared variable + access or a Break not in a For. *) + val _ = Datatype ` r = Rval int | Rbreak @@ -29,10 +39,10 @@ val _ = type_abbrev ("oracle", ``:(num -> 'a)``); val oracle_get_def = Define ` oracle_get (f:'a oracle) = (f 0, f o ((+) 1))`; -(* The state of the semantics. - * io_trace records all IO done. input is the input stream, and non_det_o is an - * oracle used to decide which subexpression of Add to evaluate first. - *) +(* The state of the semantics. Here io_trace records all I/O that has + been done, input is the input stream, and non_det_o is an oracle + used to decide which subexpression of Add to evaluate first. *) + val _ = Datatype ` state = <| store : string |-> int; clock : num; io_trace : io_tag list; input : char llist; non_det_o : bool oracle |>`; @@ -57,6 +67,8 @@ unpermute_pair (x,y) switch = else (x,y)`; +(* Expression evaluation *) + val sem_e_def = tDefine "sem_e" ` (sem_e s (Var x) = case FLOOKUP s.store x of @@ -95,46 +107,33 @@ val sem_e_def = tDefine "sem_e" ` val sem_e_ind = fetch "-" "sem_e_ind"; +(* HOL4's definition requires a little help with the definition. In + particular, we need to help it see that the clock does not + decrease. To do this, we add a few redundant checks (check_clock) + to the definition of the sem_t function. These redundant checks are + removed later in the script. *) + val sem_e_clock = Q.store_thm ("sem_e_clock", `!s e r s'. sem_e s e = (r, s') ⇒ s.clock = s'.clock`, - ho_match_mp_tac sem_e_ind >> - rw [sem_e_def] >> - ect >> + ho_match_mp_tac sem_e_ind >> rw [sem_e_def] >> ect >> fs [LET_THM, permute_pair_def, oracle_get_def, unpermute_pair_def, getchar_def] >> - rw [] >> - ect >> - fs [] >> - ect >> - fs [] >> - rw []); + rw [] >> ect >> fs [] >> + ect >> fs [] >> rw []); val sem_e_store = Q.prove ( `!s e r s'. sem_e s e = (r, s') ⇒ FDOM s.store ⊆ FDOM s'.store`, - ho_match_mp_tac sem_e_ind >> - rw [sem_e_def] >> - ect >> - fs [SUBSET_DEF, LET_THM, permute_pair_def, oracle_get_def, unpermute_pair_def, getchar_def] >> - rw [] >> - ect >> - fs [] >> - ect >> - fs [] >> - rw [] >> - metis_tac []); + ho_match_mp_tac sem_e_ind >> rw [sem_e_def] >> ect >> + fs [SUBSET_DEF, LET_THM, permute_pair_def, oracle_get_def, + unpermute_pair_def, getchar_def] >> + rw [] >> ect >> fs [] >> + ect >> fs [] >> rw [] >> metis_tac []); val sem_e_res = Q.store_thm ("sem_e_res", `!s e r s'. sem_e s e = (r, s') ⇒ r ≠ Rbreak ∧ r ≠ Rtimeout`, - ho_match_mp_tac sem_e_ind >> - rw [sem_e_def] >> - ect >> + ho_match_mp_tac sem_e_ind >> rw [sem_e_def] >> ect >> fs [LET_THM, permute_pair_def, oracle_get_def, unpermute_pair_def, getchar_def] >> - rw [] >> - ect >> - fs [] >> - ect >> - fs [] >> - rw [] >> - metis_tac []); + rw [] >> ect >> fs [] >> + ect >> fs [] >> rw [] >> metis_tac []); val check_clock_def = Define ` check_clock s' s = @@ -147,6 +146,8 @@ val dec_clock_store = Q.store_thm ("dec_clock_store[simp]", `!s. (dec_clock s).store = s.store`, rw [dec_clock_def]); +(* Statement evaluation -- with redundant check_clock *) + val sem_t_def = tDefine "sem_t" ` (sem_t s (Exp e) = sem_e s e) ∧ (sem_t s (Dec x t) = @@ -195,17 +196,11 @@ val sem_t_def = tDefine "sem_t" ` val sem_t_clock = Q.store_thm ("sem_t_clock", `!s t r s'. sem_t s t = (r, s') ⇒ s'.clock ≤ s.clock`, ho_match_mp_tac (fetch "-" "sem_t_ind") >> - reverse (rpt strip_tac) >> - pop_assum mp_tac >> - rw [Once sem_t_def] >> - ect >> - imp_res_tac sem_e_clock >> - fs [] >> + reverse (rpt strip_tac) >> pop_assum mp_tac >> + rw [Once sem_t_def] >> ect >> + imp_res_tac sem_e_clock >> fs [] >> fs [check_clock_def, dec_clock_def, LET_THM] >> - TRY decide_tac >> - rfs [] >> - res_tac >> - decide_tac); + TRY decide_tac >> rfs [] >> res_tac >> decide_tac); val check_clock_id = Q.store_thm ("check_clock_id", `!s s'. s.clock ≤ s'.clock ⇒ check_clock s s' = s`, @@ -214,6 +209,8 @@ val check_clock_id = Q.store_thm ("check_clock_id", val STOP_def = Define ` STOP x = x`; +(* Statement evaluation -- with redundant check_clock *) + val sem_t_def_with_stop = Q.store_thm ("sem_t_def_with_stop", `(sem_t s (Exp e) = sem_e s e) ∧ (sem_t s (Dec x t) = sem_t (s with store := s.store |+ (x, 0)) t) ∧ @@ -250,22 +247,20 @@ val sem_t_def_with_stop = Q.store_thm ("sem_t_def_with_stop", (Rval 0, s2) | r => r) | r => r)`, - rpt strip_tac >> - rw [Once sem_t_def,STOP_def] >> - ect >> - fs [] >> + rpt strip_tac >> rw [Once sem_t_def,STOP_def] >> ect >> fs [] >> imp_res_tac sem_t_clock >> fs [dec_clock_def, LET_THM, check_clock_id] >> rpt (AP_TERM_TAC ORELSE AP_THM_TAC) >> rw [state_component_equality] >> rw [check_clock_def] >> imp_res_tac sem_e_clock >> - fs [] >> - `F` by decide_tac); + fs [] >> `F` by decide_tac); val sem_t_def = save_thm("sem_t_def",REWRITE_RULE [STOP_def] sem_t_def_with_stop); +(* We also remove the redundant checks from the induction theorem. *) + val sem_t_ind = Q.store_thm ("sem_t_ind", `∀P. (∀s e. P s (Exp e)) ∧ @@ -294,18 +289,54 @@ val sem_t_ind = Q.store_thm ("sem_t_ind", P s (For e1 e2 t)) ⇒ ∀v v1. P v v1`, ntac 2 strip_tac >> - ho_match_mp_tac (fetch "-" "sem_t_ind") >> - rw [] >> + ho_match_mp_tac (fetch "-" "sem_t_ind") >> rw [] >> first_x_assum match_mp_tac >> - rw [] >> - fs [] >> - res_tac >> + rw [] >> fs [] >> res_tac >> imp_res_tac sem_t_clock >> imp_res_tac sem_e_clock >> fs [dec_clock_def, check_clock_id, LET_THM] >> first_x_assum match_mp_tac >> decide_tac); +(* The top-level semantics defines what is externally observable. *) + +val init_st_def = Define ` +init_st c nd i = + <| store := FEMPTY; clock := c; input := i; io_trace := []; non_det_o := nd |>`; + +(* There can be many observable behaviours because the semantics is + non-deterministic. *) + +val semantics_def = Define ` +(semantics t input (Terminate io_trace) = + (* Terminate when there is a clock and some non-determinism oracle + that gives a value result *) + ?c nd i s. + sem_t (init_st c nd input) t = (Rval i, s) ∧ + s.io_trace = io_trace) ∧ +(semantics t input Crash = + (* Crash when there is a clock that gives a non-value, non-timeout + result. *) + ?c nd r s. + sem_t (init_st c nd input) t = (r, s) ∧ + (r = Rbreak ∨ r = Rfail)) ∧ +(semantics t input (Diverge io_trace) = + (* Diverge when all clocks give timeout results. Ensure that the IO + trace to the timeout point is a prefix of the whole trace. *) + ?nd. + (!c. ?s. + sem_t (init_st c nd input) t = (Rtimeout, s) ∧ + (!n. n < LENGTH s.io_trace ⇒ LNTH n io_trace = SOME (EL n s.io_trace))) ∧ + (* Check that the whole IO trace is reachable, but maybe not for + just 1 clock value *) + (!n x. + LNTH n io_trace = SOME x ⇒ + ?c s. sem_t (init_st c nd input) t = (Rtimeout, s) ∧ + n < LENGTH s.io_trace ∧ EL n s.io_trace = x))`; + + +(* === Misc lemmas === *) + val sem_t_store = Q.prove ( `!s t r s'. sem_t s t = (r, s') ⇒ FDOM s.store ⊆ FDOM s'.store`, ho_match_mp_tac sem_t_ind >> @@ -364,41 +395,8 @@ val sem_for_not_break = Q.store_thm ("sem_for_not_break", imp_res_tac sem_e_res >> fs []); -(* Define a top-level semantic function that maps programs and their input to - * their observable behaviours. - *) -val init_st_def = Define ` -init_st c nd i = - <| store := FEMPTY; clock := c; input := i; io_trace := []; non_det_o := nd |>`; - -(* There can be many observable behaviours because the semantics is - * non-deterministic *) -val semantics_def = Define ` -(semantics t input (Terminate io_trace) = - (* Terminate when there is a clock and some non-determinism oracle that gives a value result *) - ?c nd i s. - sem_t (init_st c nd input) t = (Rval i, s) ∧ - s.io_trace = io_trace) ∧ -(semantics t input Crash = - (* Crash when there is a clock that gives a non-value, non-timeout result *) - ?c nd r s. - sem_t (init_st c nd input) t = (r, s) ∧ - (r = Rbreak ∨ r = Rfail)) ∧ -(semantics t input (Diverge io_trace) = - (* Diverge when all clocks give timeout results. Ensure that the IO trace to - * the timeout point is a prefix of the whole trace. *) - ?nd. - (!c. ?s. - sem_t (init_st c nd input) t = (Rtimeout, s) ∧ - (!n. n < LENGTH s.io_trace ⇒ LNTH n io_trace = SOME (EL n s.io_trace))) ∧ - (* Check that the whole IO trace is reachable, but maybe not for just 1 - * clock value*) - (!n x. - LNTH n io_trace = SOME x ⇒ - ?c s. sem_t (init_st c nd input) t = (Rtimeout, s) ∧ - n < LENGTH s.io_trace ∧ EL n s.io_trace = x))`; -(* A type soundness proof *) +(* === A simple type checker and its soundness === *) val type_permute_pair_lem = Q.prove ( `!s s1 e1 e2 fst_e snd_e new_nd. @@ -448,8 +446,9 @@ val type_sound_e = Q.prove ( rw [] >> metis_tac []); -(* Have to use sem_t_ind, and not type_t_ind or t_induction. This is different - * than small-step-based type soundness *) +(* Have to use sem_t_ind, and not type_t_ind or t_induction. This is + different from small-step-based type soundness *) + val type_sound_t = Q.prove ( `!s1 t in_for s. type_t in_for s t ∧ s ⊆ FDOM s1.store @@ -525,7 +524,7 @@ val type_sound_t = Q.prove ( metis_tac [SUBSET_TRANS]) >> metis_tac [sem_e_res])); -val type_soundness = Q.prove ( +val type_soundness = Q.store_thm ("type_soundness", `!t input. type_t F {} t ⇒ Crash ∉ semantics t input`, rw [IN_DEF, semantics_def] >> imp_res_tac type_sound_t >> diff --git a/examples/fun-op-sem/impScript.sml b/examples/fun-op-sem/imp/impScript.sml similarity index 82% rename from examples/fun-op-sem/impScript.sml rename to examples/fun-op-sem/imp/impScript.sml index bcd379bbba..105e6cc02a 100644 --- a/examples/fun-op-sem/impScript.sml +++ b/examples/fun-op-sem/imp/impScript.sml @@ -6,6 +6,15 @@ val ect = BasicProvers.EVERY_CASE_TAC; val _ = new_theory "imp"; +(* + +This file defines a funcional big-step semantics for the IMP languages +of Nipkow and Klein's book Concrete Semantics. + +http://www.concrete-semantics.org/ + +*) + val _ = temp_type_abbrev("vname",``:string``); val _ = Datatype ` @@ -34,6 +43,15 @@ val bval_def = Define ` val STOP_def = Define `STOP x = x`; +(* The following function defines the semantics of statement evaluation. + The clock decreases when entering the body of the While loop. + + NB: the definition mechanism in HOL4 is not smart enough to notice + that the clock doesn't increase. In order to make the termination + simple, we insert an extra `if t < t2 then t else t2` in the Seq + case. In cval_def_with_stop below, we remove this redundant + if-statement. *) + val cval_def = tDefine "cval" ` (cval SKIP s (t:num) = SOME (s,t)) /\ (cval (Assign x a) s t = SOME ((x =+ aval a s) s,t)) /\ @@ -78,6 +96,8 @@ val cval_def_with_stop = store_thm("cval_def_with_stop", val cval_def = save_thm("cval_def",REWRITE_RULE [STOP_def] cval_def_with_stop); +(* We also remove the redundant if-statement from the induction theorem. *) + val cval_ind = store_thm("cval_ind", ``!P. (!s t. P SKIP s t) /\ (!x a s t. P (Assign x a) s t) /\ diff --git a/examples/fun-op-sem/ml/typeSoundScript.sml b/examples/fun-op-sem/ml/typeSoundScript.sml new file mode 100644 index 0000000000..e63cbbaeb9 --- /dev/null +++ b/examples/fun-op-sem/ml/typeSoundScript.sml @@ -0,0 +1,1383 @@ +open HolKernel boolLib bossLib lcsymtacs Parse + integerTheory stringTheory alistTheory listTheory pred_setTheory + pairTheory optionTheory finite_mapTheory arithmeticTheory + +(* +In this file, we demonstrate that the Functional Big-Step semantics +style is suitable for proofs of type soundness. In particular, we +define an ML-like language, heavily inspired by Core ML in Wright and +Felleisen's "A Syntactic Approach to Type Soundness" (1992) (hereafter +W&F), using functional big-step semantics rather than small-step +semantics. We then prove the type soundness using the induction +theorem generated from the definition of the functional big-step +semantics. +*) + +(* TODO: from CakeML's miscLib.sml *) +val _ = set_trace"Goalstack.print_goal_at_top"0 +val SWAP_IMP = PROVE[]``(P ==> Q ==> R) ==> (Q ==> P ==> R)`` +val IMP_IMP = METIS_PROVE[]``(P /\ (Q ==> R)) ==> ((P ==> Q) ==> R)`` +val discharge_hyps = match_mp_tac IMP_IMP >> conj_tac +fun match_exists_tac tm (g as (_,w)) = + let + val (vs,b) = strip_exists w + val vs = map (fst o dest_var o variant (free_vars tm)) vs + fun k (g as (_,w)) = + let + val (_,b) = strip_exists w + val cs = strip_conj b val c = hd cs + val (tms,_) = match_term c tm + val xs = map #redex tms + val ys = map #residue tms + fun sorter ls = xs@(List.filter(not o Lib.C Lib.mem xs)ls) + in + CONV_TAC(RESORT_EXISTS_CONV sorter) >> + map_every exists_tac ys + end g + in + CONV_TAC(RENAME_VARS_CONV vs) >> k + end g +(* -- *) + +val _ = new_theory"typeSound" + +(* TODO: move to HOL standard lib *) +val LUPDATE_ID = store_thm("LUPDATE_ID", + ``∀n ls. n < LENGTH ls ⇒ (LUPDATE (EL n ls) n ls = ls)``, + rw[LIST_EQ_REWRITE,EL_LUPDATE] >> rw[]) +(* -- *) + +val _ = ParseExtras.temp_tight_equality() + +(* Syntax *) + +val _ = Datatype`lit = + Int int | Unit` + +val _ = Datatype`exp = + | Lit lit + | Var string + | App exp exp + | Let string exp exp + | Fun string exp + | Funrec string string exp + | Ref exp + | Deref exp + | Assign exp exp + | Letexn string exp + | Raise exp exp + | Handle exp exp exp` + +(* Differences from W&F: + - we have specific constants (ints and unit) + - we bind one exception at a time + - we use Funrec rather than Y + - we use explicit syntactic forms for applications of primitives like Ref, + Raise, whereas they treat them as curried function values and re-use App to + apply them; in our syntax we can of course achieve the same in e by: + Let "ref" (Fun "x" (Ref (Var "x"))) e. *) + +(* +The major difference is our separate class of values, which are not in mutual +recursion with expressions, and include closures. Using closures/environments +is a stylistic choice that works well with functional big-step and lets us +avoid defining capture-avoiding substitution over terms (which W&F gloss over +anyway). +*) + +(* Values *) + +val _ = Datatype`v = + | Litv lit + | Clos ((string,v) alist) string exp + | Closrec ((string,v) alist) string string exp + | Loc num + | Exn num` + +val v_induction = theorem"v_induction" +val v_ind = + v_induction + |> Q.SPECL[`P`,`EVERY (P o SND)`,`P o SND`] + |> SIMP_RULE (srw_ss()) [] + |> UNDISCH |> CONJUNCT1 |> DISCH_ALL + |> GEN_ALL + |> curry save_thm "v_ind" +val v_size_def = definition"v_size_def" + +val _ = type_abbrev("env",``:(string,v) alist``) + +(* Semantics *) + +(* +The semantics has a state containing the clock, the store, and the number of +exceptions that have been created. Whereas W&F's treatment of exceptions is +intimately tied up with the mechanics of their small-step semantics, we simply +generate a new exception value for every (dynamic) Letexn expression. +*) + +val _ = Datatype` + state = <| clock : num; refs : v list; next_exn : num |>` + +val state_component_equality = theorem"state_component_equality" + +(* machinery for the functional big-step definition *) + +val check_clock_def = Define ` + check_clock s' s = + s' with clock := (if s'.clock ≤ s.clock then s'.clock else s.clock)`; + +val check_clock_id = prove( + ``!s s'. s.clock ≤ s'.clock ⇒ check_clock s s' = s``, + rw [check_clock_def, state_component_equality]); + +val dec_clock_def = Define ` + dec_clock s = s with clock := s.clock - 1`; + +val dec_clock_refs = store_thm("dec_clock_refs[simp]", + ``(dec_clock s).refs = s.refs``, + rw[dec_clock_def]) + +val dec_clock_next_exn = store_thm("dec_clock_next_exn[simp]", + ``(dec_clock s).next_exn = s.next_exn``, + rw[dec_clock_def]) + +val is_closure_def = Define` + is_closure (Clos _ _ _) = T ∧ + is_closure (Closrec _ _ _ _) = T ∧ + is_closure _ = F` +val _ = export_rewrites["is_closure_def"] + +(* results *) + +val _ = Datatype` + r = Rval v + | Rraise num v + | Rfail + | Rtimeout` + +(* big-step semantics as a function *) + +val sem_def = tDefine"sem"` + (sem env s (Lit i) = (Rval (Litv i), s)) ∧ + (sem env s (Var x) = + case ALOOKUP env x of + | NONE => (Rfail, s) + | SOME v => (Rval v, s)) ∧ + (sem env s (App e1 e2) = + case sem env s e1 of + | (Rval v1, s1) => + (case sem env (check_clock s1 s) e2 of + | (Rval v2, s2) => + if s.clock ≠ 0 ∧ s2.clock ≠ 0 then + (case v1 of + | Clos env' x e => + sem ((x,v2)::env') (dec_clock (check_clock s2 s)) e + | Closrec env' f x e => + sem ((x,v2)::(f,v1)::env') (dec_clock (check_clock s2 s)) e + | _ => (Rfail, s2)) + else (Rtimeout, s2) + | res => res) + | res => res) ∧ + (sem env s (Let x e1 e2) = + case sem env s e1 of + | (Rval v1, s1) => sem ((x,v1)::env) (check_clock s1 s) e2 + | res => res) ∧ + (sem env s (Fun x e) = (Rval (Clos env x e), s)) ∧ + (sem env s (Funrec f x e) = (Rval (Closrec env f x e), s)) ∧ + (sem env s (Ref e) = + case sem env s e of + | (Rval v, s) => (Rval (Loc (LENGTH s.refs)), s with refs := s.refs ++ [v]) + | res => res) ∧ + (sem env s (Deref e) = + case sem env s e of + | (Rval (Loc n), s) => (if n < LENGTH s.refs then Rval (EL n s.refs) else Rfail, s) + | (Rval _, s) => (Rfail, s) + | res => res) ∧ + (sem env s (Assign e1 e2) = + case sem env s e1 of + | (Rval v1, s1) => + (case sem env (check_clock s1 s) e2 of + | (Rval v2, s2) => + (case v1 of + | Loc n => + if n < LENGTH s2.refs then + (Rval (Litv Unit), s2 with refs := LUPDATE v2 n s2.refs) + else (Rfail, s2) + | _ => (Rfail, s2)) + | res => res) + | res => res) ∧ + (sem env s (Letexn x e) = + sem ((x,Exn (s.next_exn))::env) (s with next_exn := s.next_exn + 1) e) ∧ + (sem env s (Raise e1 e2) = + case sem env s e1 of + | (Rval v1, s1) => + (case sem env (check_clock s1 s) e2 of + | (Rval v2, s2) => + (case v1 of + | Exn n => (Rraise n v2, s2) + | _ => (Rfail, s2)) + | res => res) + | res => res) ∧ + (sem env s (Handle e3 e1 e2) = + case sem env s e1 of + | (Rval v1, s1) => + (case v1 of + | Exn n => + (case sem env (check_clock s1 s) e2 of + | (Rval v2, s2) => + if is_closure v2 then + (case sem env (check_clock s2 s) e3 of + | (Rraise n3 v3, s3) => + if n3 = n then + if s.clock ≠ 0 ∧ s3.clock ≠ 0 then + (case v2 of + | Clos env' x e => + sem ((x,v3)::env') (dec_clock (check_clock s3 s)) e + | Closrec env' f x e => + sem ((x,v3)::(f,v2)::env') (dec_clock (check_clock s3 s)) e) + else (Rtimeout, s3) + else (Rraise n3 v3, s3) + | res => res) + else (Rfail, s2) + | res => res) + | _ => (Rfail, s1)) + | res => res)` +(WF_REL_TAC`inv_image (measure I LEX measure exp_size) + (λ(env,s,e). (s.clock,e))` >> + rpt strip_tac >> TRY DECIDE_TAC >> + fs[check_clock_def,dec_clock_def] >> + rw[] >> fsrw_tac[ARITH_ss][]) + +(* +clean-up of the definition and induction theorem, removing the check_clock +machinery that was used to get the function through the termination checker +*) + +val sem_ind = theorem"sem_ind" + +val sem_clock = store_thm("sem_clock", + ``∀env s e r s'. sem env s e = (r, s') ⇒ s'.clock ≤ s.clock``, + ho_match_mp_tac sem_ind >> + rpt conj_tac >> + simp[sem_def] >> + rpt gen_tac >> + BasicProvers.EVERY_CASE_TAC >> + simp[check_clock_def,dec_clock_def] >> + rpt(IF_CASES_TAC >> simp[]) >> + rpt strip_tac >> res_tac >> simp[] >> fs[]) + +val sem_def = store_thm("sem_def",`` + (sem env s (Lit i) = (Rval (Litv i), s)) ∧ + (sem env s (Var x) = + case ALOOKUP env x of + | NONE => (Rfail, s) + | SOME v => (Rval v, s)) ∧ + (sem env s (App e1 e2) = + case sem env s e1 of + | (Rval v1, s) => + (case sem env s e2 of + | (Rval v2, s) => + if s.clock ≠ 0 then + (case v1 of + | Clos env' x e => + sem ((x,v2)::env') (dec_clock s) e + | Closrec env' f x e => + sem ((x,v2)::(f,v1)::env') (dec_clock s) e + | _ => (Rfail, s)) + else (Rtimeout, s) + | res => res) + | res => res) ∧ + (sem env s (Let x e1 e2) = + case sem env s e1 of + | (Rval v1, s) => sem ((x,v1)::env) s e2 + | res => res) ∧ + (sem env s (Fun x e) = (Rval (Clos env x e), s)) ∧ + (sem env s (Funrec f x e) = (Rval (Closrec env f x e), s)) ∧ + (sem env s (Ref e) = + case sem env s e of + | (Rval v, s) => (Rval (Loc (LENGTH s.refs)), s with refs := s.refs ++ [v]) + | res => res) ∧ + (sem env s (Deref e) = + case sem env s e of + | (Rval (Loc n), s) => (if n < LENGTH s.refs then Rval (EL n s.refs) else Rfail, s) + | (Rval _, s) => (Rfail, s) + | res => res) ∧ + (sem env s (Assign e1 e2) = + case sem env s e1 of + | (Rval v1, s) => + (case sem env s e2 of + | (Rval v2, s) => + (case v1 of + | Loc n => + if n < LENGTH s.refs then + (Rval (Litv Unit), s with refs := LUPDATE v2 n s.refs) + else (Rfail, s) + | _ => (Rfail, s)) + | res => res) + | res => res) ∧ + (sem env s (Letexn x e) = + sem ((x,Exn (s.next_exn))::env) (s with next_exn := s.next_exn + 1) e) ∧ + (sem env s (Raise e1 e2) = + case sem env s e1 of + | (Rval v1, s) => + (case sem env s e2 of + | (Rval v2, s) => + (case v1 of + | Exn n => (Rraise n v2, s) + | _ => (Rfail, s)) + | res => res) + | res => res) ∧ + (sem env s (Handle e3 e1 e2) = + case sem env s e1 of + | (Rval v1, s) => + (case v1 of + | Exn n => + (case sem env s e2 of + | (Rval v2, s) => + if is_closure v2 then + (case sem env s e3 of + | (Rraise n3 v3, s) => + if n3 = n then + if s.clock ≠ 0 then + (case v2 of + | Clos env' x e => + sem ((x,v3)::env') (dec_clock s) e + | Closrec env' f x e => + sem ((x,v3)::(f,v2)::env') (dec_clock s) e) + else (Rtimeout, s) + else (Rraise n3 v3, s) + | res => res) + else (Rfail, s) + | res => res) + | _ => (Rfail, s)) + | res => res)``, + rpt strip_tac >> + rw[Once sem_def] >> + BasicProvers.CASE_TAC >> + imp_res_tac sem_clock >> + simp[check_clock_id] >> + BasicProvers.CASE_TAC >> + imp_res_tac sem_clock >> + simp[check_clock_id] >> + BasicProvers.EVERY_CASE_TAC >> fs[] >> + imp_res_tac sem_clock >> + simp[check_clock_id] >> + `F` suffices_by rw[] >> + DECIDE_TAC) + +val sem_ind = store_thm("sem_ind",`` + ∀P. + (∀env s i. P env s (Lit i)) ∧ (∀env s x. P env s (Var x)) ∧ + (∀env s e1 e2. + (∀v3 s1 v1 v4 s2 v2 env' x e. + sem env s e1 = (v3,s1) ∧ v3 = Rval v1 ∧ + sem env s1 e2 = (v4,s2) ∧ v4 = Rval v2 ∧ + (s2.clock ≠ 0) ∧ v1 = Clos env' x e ⇒ + P ((x,v2)::env') (dec_clock s2) e) ∧ + (∀v3 s1 v1 v4 s2 v2 env'' f x' e'. + sem env s e1 = (v3,s1) ∧ v3 = Rval v1 ∧ + sem env s1 e2 = (v4,s2) ∧ v4 = Rval v2 ∧ + (s2.clock ≠ 0) ∧ v1 = Closrec env'' f x' e' ⇒ + P ((x',v2)::(f,v1)::env'') (dec_clock s2) + e') ∧ + (∀v3 s1 v1. + sem env s e1 = (v3,s1) ∧ v3 = Rval v1 ⇒ + P env s1 e2) ∧ P env s e1 ⇒ + P env s (App e1 e2)) ∧ + (∀env s x e1 e2. + (∀v3 s1 v1. + sem env s e1 = (v3,s1) ∧ v3 = Rval v1 ⇒ + P ((x,v1)::env) s1 e2) ∧ P env s e1 ⇒ + P env s (Let x e1 e2)) ∧ (∀env s x e. P env s (Fun x e)) ∧ + (∀env s f x e. P env s (Funrec f x e)) ∧ + (∀env s e. P env s e ⇒ P env s (Ref e)) ∧ + (∀env s e. P env s e ⇒ P env s (Deref e)) ∧ + (∀env s e1 e2. + (∀v3 s1 v1. + sem env s e1 = (v3,s1) ∧ v3 = Rval v1 ⇒ + P env s1 e2) ∧ P env s e1 ⇒ + P env s (Assign e1 e2)) ∧ + (∀env s x e. + P ((x,Exn s.next_exn)::env) (s with next_exn := s.next_exn + 1) e ⇒ P env s (Letexn x e)) ∧ + (∀env s e1 e2. + (∀v3 s1 v1. + sem env s e1 = (v3,s1) ∧ v3 = Rval v1 ⇒ + P env s1 e2) ∧ P env s e1 ⇒ + P env s (Raise e1 e2)) ∧ + (∀env s e3 e1 e2. + (∀v3'' v4' v8 n v3' s2 v2 v4 s3 n3 v3 env' x e. + sem env s e1 = (v3'',v4') ∧ v3'' = Rval v8 ∧ v8 = Exn n ∧ + sem env v4' e2 = (v3',s2) ∧ v3' = Rval v2 ∧ + is_closure v2 ∧ sem env s2 e3 = (v4,s3) ∧ + v4 = Rraise n3 v3 ∧ n3 = n ∧ s3.clock ≠ 0 ∧ + v2 = Clos env' x e ⇒ + P ((x,v3)::env') (dec_clock s3) e) ∧ + (∀v3'' v4' v8 n v3' s2 v2 v4 s3 n3 v3 env'' f x' e'. + sem env s e1 = (v3'',v4') ∧ v3'' = Rval v8 ∧ v8 = Exn n ∧ + sem env v4' e2 = (v3',s2) ∧ v3' = Rval v2 ∧ + is_closure v2 ∧ sem env s2 e3 = (v4,s3) ∧ + v4 = Rraise n3 v3 ∧ n3 = n ∧ s3.clock ≠ 0 ∧ + v2 = Closrec env'' f x' e' ⇒ + P ((x',v3)::(f,v2)::env'') (dec_clock s3) + e') ∧ + (∀v3 v4 v8 n v3' s2 v2. + sem env s e1 = (v3,v4) ∧ v3 = Rval v8 ∧ v8 = Exn n ∧ + sem env v4 e2 = (v3',s2) ∧ v3' = Rval v2 ∧ + is_closure v2 ⇒ + P env s2 e3) ∧ + (∀v3 v4 v8 n. + sem env s e1 = (v3,v4) ∧ v3 = Rval v8 ∧ v8 = Exn n ⇒ + P env v4 e2) ∧ P env s e1 ⇒ + P env s (Handle e3 e1 e2)) + ⇒ + ∀v v1 v2. P v v1 v2``, + ntac 2 strip_tac >> + ho_match_mp_tac sem_ind >> + rw[] >> + first_x_assum match_mp_tac >> + rw[] >> fs[] >> + res_tac >> + imp_res_tac sem_clock >> + fsrw_tac[ARITH_ss][check_clock_id] >> rfs[] >> + fsrw_tac[ARITH_ss][check_clock_id]) + +(* Typing *) + +(* +Whereas W&F use two categories of type variables (applicative and imperative), +we follow the more modern approach to making let-polymorphism sound with a +value restriction. +*) + +val is_value_def = Define` + is_value (Lit _) = T ∧ + is_value (Var _) = T ∧ + is_value (Fun _ _) = T ∧ + is_value (Funrec _ _ _) = T ∧ + is_value _ = F` +val _ = export_rewrites["is_value_def"] + +(* syntax of types *) + +val _ = Datatype`tctor = + | TC_int + | TC_fn + | TC_ref + | TC_unit + | TC_exn` + +val _ = Datatype`t = + | Tvar string + | Tapp (t list) tctor` + +val t_size_def = definition"t_size_def" +val t_induction = theorem"t_induction" + +val t_ind = + t_induction + |> Q.SPECL[`P`,`EVERY P`] + |> SIMP_RULE (srw_ss()) [] + |> UNDISCH |> CONJUNCT1 |> DISCH_ALL + |> GEN_ALL + |> curry save_thm "t_ind" + +val _ = overload_on("Tint",``Tapp [] TC_int``) +val _ = overload_on("Tfn",``λt1 t2. Tapp [t1;t2] TC_fn``) +val _ = overload_on("Tref",``λt. Tapp [t] TC_ref``) +val _ = overload_on("Tunit",``Tapp [] TC_unit``) +val _ = overload_on("Texn",``λt. Tapp [t] TC_exn``) + +(* substitution for variables in a type *) + +val tysubst_def = tDefine"tysubst"` + (tysubst s (Tvar x) = + (case FLOOKUP s x of + | SOME t => t + | NONE => Tvar x)) ∧ + tysubst s (Tapp ts tc) = + Tapp (MAP (tysubst s) ts) tc` +(WF_REL_TAC`measure (t_size o SND)` >> + rpt gen_tac >> Induct_on`ts` >> + rw[t_size_def] >> res_tac >>simp[]) +val tysubst_def = + tysubst_def + |> SIMP_RULE (std_ss++boolSimps.ETA_ss)[] + |> curry save_thm "tysubst_def" +val _ = export_rewrites["tysubst_def"] + +val tysubst_ind = theorem"tysubst_ind" + +(* free variables in a type *) + +val tyvars_def = tDefine"tyvars"` + (tyvars (Tvar x) = {x}) ∧ + (tyvars (Tapp ts _) = BIGUNION (IMAGE tyvars (set ts)))` +(WF_REL_TAC`measure (t_size)` >> + rpt gen_tac >> Induct_on`ts` >> + rw[t_size_def] >> res_tac >>simp[]) +val tyvars_def = + tyvars_def + |> SIMP_RULE (std_ss++boolSimps.ETA_ss)[] + |> curry save_thm "tyvars_def" +val _ = export_rewrites["tyvars_def"] + +(* +A type environment is a map from (expression) variables to type schemes, where +a type scheme is a type some of whose variables are considered bound. We +represent a type scheme by (tvs:string set, t:t), which is t with the variables +in tvs bound. +*) + +(* free variables in a type environment *) + +val tenv_vars_def = Define` + tenv_vars tenv = + BIGUNION (IMAGE ((λ(tvs,t). tyvars t DIFF tvs) o SND) (set tenv))` + +(* typing relation *) + +val (type_e_rules,type_e_ind,type_e_cases) = Hol_reln` + (type_e tenv (Lit (Int i)) Tint) ∧ + (type_e tenv (Lit Unit) Tunit) ∧ + (ALOOKUP tenv x = SOME (tvs,t) ∧ FDOM s ⊆ tvs + ⇒ type_e tenv (Var x) (tysubst s t)) ∧ + (type_e tenv e1 (Tfn t1 t2) ∧ + type_e tenv e2 t1 + ⇒ type_e tenv (App e1 e2) t2) ∧ + (is_value e1 ∧ + type_e tenv e1 t1 ∧ + type_e ((x,(tyvars t1 DIFF (tenv_vars tenv),t1))::tenv) e2 t2 + ⇒ type_e tenv (Let x e1 e2) t2) ∧ + (¬is_value e1 ∧ + type_e tenv e1 t1 ∧ + type_e ((x,({},t1))::tenv) e2 t2 + ⇒ type_e tenv (Let x e1 e2) t2) ∧ + (type_e ((x,({},t1))::tenv) e t2 + ⇒ type_e tenv (Fun x e) (Tfn t1 t2)) ∧ + (type_e ((x,({},t1))::(f,({},Tfn t1 t2))::tenv) e t2 + ⇒ type_e tenv (Funrec f x e) (Tfn t1 t2)) ∧ + (type_e tenv e t ⇒ + type_e tenv (Ref e) (Tref t)) ∧ + (type_e tenv e (Tref t) ⇒ + type_e tenv (Deref e) t) ∧ + (type_e tenv e1 (Tref t) ∧ + type_e tenv e2 t ⇒ + type_e tenv (Assign e1 e2) Tunit) ∧ + (type_e ((x,({},Texn t1))::tenv) e t2 + ⇒ type_e tenv (Letexn x e) t2) ∧ + (type_e tenv e1 (Texn t) ∧ + type_e tenv e2 t + ⇒ type_e tenv (Raise e1 e2) t2) ∧ + (type_e tenv e3 t3 ∧ + type_e tenv e1 (Texn t1) ∧ + type_e tenv e2 (Tfn t1 t3) + ⇒ type_e tenv (Handle e3 e1 e2) t3)` + +(* +To state the type soundness theorem, we also need a typing relation on values. +The typing relation on values has two parameters, rt and et, indicating the +types of references and exceptions. +*) + +val (type_v_rules,type_v_ind,type_v_cases) = Hol_reln` + (type_v rt et (Litv (Int i)) Tint) ∧ + (type_v rt et (Litv (Unit)) Tunit) ∧ + (type_env rt et env tenv ∧ + type_e ((x,({},t1))::tenv) e t2 + ⇒ type_v rt et (Clos env x e) (Tfn t1 t2)) ∧ + (type_env rt et env tenv ∧ + type_e ((x,({},t1))::(f,({},Tfn t1 t2))::tenv) e t2 + ⇒ type_v rt et (Closrec env f x e) (Tfn t1 t2)) ∧ + (n < LENGTH rt + ⇒ type_v rt et (Loc n) (Tref (EL n rt))) ∧ + (n < LENGTH et + ⇒ type_v rt et (Exn n) (Texn (EL n et))) ∧ + (type_env rt et [] []) ∧ + ((∀s. FDOM s ⊆ tvs ⇒ type_v rt et v (tysubst s t)) ∧ + type_env rt et env tenv + ⇒ type_env rt et ((x,v)::env) ((x,(tvs,t))::tenv))` + +(* we now have a series of lemmas about the type system *) + +val type_e_clauses = + [``type_e tenv (Lit i) t`` + ,``type_e tenv (Var x) t`` + ,``type_e tenv (App e1 e2) t`` + ,``type_e tenv (Let x e1 e2) t`` + ,``type_e tenv (Fun x e) t`` + ,``type_e tenv (Funrec f x e) t`` + ,``type_e tenv (Ref e) t`` + ,``type_e tenv (Deref e) t`` + ,``type_e tenv (Assign e1 e2) t`` + ,``type_e tenv (Letexc x e) t`` + ,``type_e tenv (Raise e1 e2) t`` + ,``type_e tenv (Handle e3 e1 e2) t`` + ] + |> List.map (SIMP_CONV (srw_ss()) [Once type_e_cases]) + |> LIST_CONJ + +val type_v_clauses = + [``type_v s z (Litv i) t`` + ,``type_v s z (Clos env x e) t`` + ,``type_v s z (Closrec env f x e) t`` + ,``type_v s z (Loc n) t`` + ,``type_v s z (Exn n) t`` + ] + |> List.map (SIMP_CONV (srw_ss()) [Once type_v_cases]) + |> LIST_CONJ + +val type_env_clauses = + [``type_env s z [] tenv`` + ,``type_env s z (x::y) tenv`` + ] + |> List.map (SIMP_CONV (srw_ss()) [Once type_v_cases]) + |> LIST_CONJ + +val type_v_extend = store_thm("type_v_extend", + ``(∀v t. type_v s e v t ⇒ type_v (s++s') (e++e') v t) ∧ + (∀env tenv. type_env s e env tenv ⇒ type_env (s++s') (e++e') env tenv)``, + ho_match_mp_tac type_v_ind >> + simp[type_v_clauses,type_env_clauses] >> + rw[] >> simp[rich_listTheory.EL_APPEND1] >> metis_tac[]) + +val FINITE_tyvars = store_thm("FINITE_tyvars[simp]", + ``∀t. FINITE (tyvars t)``, + ho_match_mp_tac t_ind >> simp[] >> + simp[EVERY_MEM,PULL_EXISTS]) + +val tysubst_tysubst = store_thm("tysubst_tysubst", + ``∀s t s'. tysubst s' (tysubst s t) = tysubst ((tysubst s' o_f s) ⊌ s') t``, + ho_match_mp_tac tysubst_ind >> + conj_tac >- ( + simp[] >> + rpt gen_tac >> + simp[FLOOKUP_o_f,FLOOKUP_FUNION] >> + BasicProvers.CASE_TAC >> simp[] ) >> + rw[MAP_MAP_o,MAP_EQ_f]) + +val tysubst_nil = store_thm("tysubst_nil[simp]", + ``∀t. tysubst FEMPTY t = t``, + ho_match_mp_tac t_ind >> + simp[EVERY_MEM,LIST_EQ_REWRITE,EL_MAP,MEM_EL,PULL_EXISTS]) + +val tyvars_tysubst = store_thm("tyvars_tysubst", + ``∀t. tyvars (tysubst s t) = (tyvars t DIFF FDOM s) ∪ BIGUNION { tyvars u | ∃x. x ∈ tyvars t ∧ FLOOKUP s x = SOME u }``, + ho_match_mp_tac t_ind >> simp[] >> rw[] >> + TRY BasicProvers.CASE_TAC >> + TRY (fs[FLOOKUP_DEF] >> NO_TAC) >> rw[] >- ( + rw[Once EXTENSION,PULL_EXISTS] ) >> + fs[PULL_EXISTS,EVERY_MEM] >> + fs[Once EXTENSION,PULL_EXISTS,MEM_MAP] >> + metis_tac[]) + +val tysubst_frees = store_thm("tysubst_frees", + ``∀t. (∀x. x ∈ tyvars t ⇒ FLOOKUP s1 x = FLOOKUP s2 x) ⇒ + tysubst s1 t = tysubst s2 t``, + ho_match_mp_tac t_ind >> simp[] >> + rw[LIST_EQ_REWRITE,EL_MAP] >> + fs[EVERY_MEM,PULL_EXISTS,MEM_EL] >> + metis_tac[]) + +(* alpha-equivalence of type schemes *) + +val raconv_def = tDefine"raconv"` + (raconv f tvs1 tvs2 (Tvar x1) (Tvar x2) ⇔ + if x1 ∈ tvs1 then f x1 = x2 + else x2 = x1 ∧ x1 ∉ tvs2) ∧ + (raconv f tvs1 tvs2 (Tapp ts1 tc1) (Tapp ts2 tc2) ⇔ + tc2 = tc1 ∧ LIST_REL (raconv f tvs1 tvs2) ts1 ts2) ∧ + (raconv _ _ _ _ _ = F)` +(WF_REL_TAC`measure (t_size o SND o SND o SND o SND)` >> + rpt gen_tac >> Induct_on`ts2` >> simp[t_size_def] >> + rw[] >> res_tac >> simp[]) +val raconv_def = + raconv_def + |> SIMP_RULE (std_ss++boolSimps.ETA_ss) [] + |> curry save_thm "raconv_def" +val _ = export_rewrites["raconv_def"] +val raconv_ind = theorem"raconv_ind" + +val tsaconv_def = Define` + tsaconv (tvs1,t1) (tvs2,t2) ⇔ + ∃f. BIJ f tvs1 tvs2 ∧ + raconv f tvs1 tvs2 t1 t2` + +val tsaconv_refl = store_thm("tsaconv_refl[simp]", + ``∀ts. tsaconv ts ts``, + Cases >> simp[tsaconv_def] >> + qexists_tac`λx. x` >> + conj_tac >- simp[BIJ_ID] >> + qid_spec_tac`r` >> + ho_match_mp_tac t_ind >> + simp[LIST_REL_EL_EQN,EVERY_MEM,MEM_EL,PULL_EXISTS]) + +val tsaconv_sym = store_thm("tsaconv_sym", + ``∀t1 t2. tsaconv t1 t2 ⇒ tsaconv t2 t1``, + Cases >> Cases >> simp[tsaconv_def] >> + strip_tac >> + qexists_tac`LINV f q` >> + conj_tac >- simp[BIJ_LINV_BIJ] >> + pop_assum mp_tac >> + map_every qid_spec_tac[`r'`,`r`] >> + ho_match_mp_tac t_ind >> + conj_tac >- ( + gen_tac >> Cases >> simp[] >> + `INJ f q q'` by fs[BIJ_DEF] >> + rw[] >> + imp_res_tac LINV_DEF >> + imp_res_tac BIJ_LINV_INV >> + metis_tac[INJ_DEF]) >> + gen_tac >> strip_tac >> + gen_tac >> Cases >> simp[] >> + fs[EVERY_MEM,LIST_REL_EL_EQN,MEM_EL,PULL_EXISTS]) + +val raconv_tyvars_eq = prove( + ``∀f tvs1 tvs2 t1 t2. + BIJ f tvs1 tvs2 ⇒ + raconv f tvs1 tvs2 t1 t2 ⇒ + tyvars t1 DIFF tvs1 = + tyvars t2 DIFF tvs2``, + ho_match_mp_tac raconv_ind >> reverse(rw[]) >- ( + fs[Once EXTENSION,PULL_EXISTS] >> + fs[LIST_REL_EL_EQN,MEM_EL,PULL_EXISTS] >> + metis_tac[] ) >> + fs[BIJ_DEF,INJ_DEF] >> metis_tac[] ) + +val tsaconv_tyvars_eq = store_thm("tsaconv_tyvars_eq", + ``∀t1 t2. tsaconv t1 t2 ⇒ + tyvars (SND t1) DIFF (FST t1) = + tyvars (SND t2) DIFF (FST t2)``, + Cases >> Cases >> rw[tsaconv_def] >> + metis_tac[raconv_tyvars_eq]) + +val raconv_imp_tysubst = store_thm("raconv_imp_tysubst", + ``∀f tvs1 tvs2 t1 t2. + FINITE tvs1 ⇒ + BIJ f tvs1 tvs2 ⇒ + raconv f tvs1 tvs2 t1 t2 ⇒ + tysubst (FUN_FMAP (Tvar o f) tvs1) t1 = t2``, + ho_match_mp_tac raconv_ind >> + rw[] >> + simp[FUN_FMAP_DEF,FLOOKUP_FUN_FMAP] >> + fs[LIST_REL_EL_EQN,MEM_EL,PULL_EXISTS,LIST_EQ_REWRITE,EL_MAP]) + +val tsaconv_imp_tysubst = store_thm("tsaconv_imp_tysubst", + ``∀t1 t2. tsaconv t1 t2 ⇒ + FINITE (FST t1) ⇒ + ∃s. FDOM s = FST t1 ∧ + FRANGE s = IMAGE Tvar (FST t2) ∧ + tysubst s (SND t1) = SND t2``, + Cases >> Cases >> rw[tsaconv_def] >> + imp_res_tac raconv_imp_tysubst >> rw[] >> + qexists_tac`FUN_FMAP (Tvar o f) q` >> rw[] >> + fs[BIJ_DEF,IMAGE_COMPOSE,IMAGE_SURJ]) + +val dest_Tvar_def = Define` + dest_Tvar (Tvar x) = x` +val _ = export_rewrites["dest_Tvar_def"] + +val tysubst_imp_raconv = store_thm("tysubst_imp_raconv", + ``∀f tvs1 tvs2 t1 t2. + FINITE tvs1 ∧ + tysubst (FUN_FMAP (Tvar o f) tvs1) t1 = t2 ∧ + BIJ f tvs1 tvs2 ∧ + DISJOINT tvs2 (tyvars t1) + ⇒ + raconv f tvs1 tvs2 t1 t2``, + ho_match_mp_tac raconv_ind >> simp[] >> + conj_tac >- ( + rw[] >> rfs[FLOOKUP_DEF,FLOOKUP_FUN_FMAP] ) >> + rw[] >> fs[] >- ( + rw[LIST_REL_EL_EQN,EL_MAP] >> + first_x_assum(match_mp_tac o MP_CANON) >> + simp[MEM_MAP,PULL_EXISTS] >> + qexists_tac`EL n ts1` >> + simp[MEM_EL] >> + fs[PULL_EXISTS,MEM_EL] >> + metis_tac[] ) >> + spose_not_then strip_assume_tac >> + rfs[FLOOKUP_FUN_FMAP] >> + BasicProvers.EVERY_CASE_TAC >> fs[]) + +val tysubst_imp_aconv = store_thm("tysubst_imp_aconv", + ``∀f tvs1 t1 tvs2. + FINITE tvs1 ∧ + BIJ f tvs1 tvs2 ∧ + DISJOINT tvs2 (tyvars t1) + ⇒ + tsaconv (tvs1,t1) (tvs2,tysubst (FUN_FMAP (Tvar o f) tvs1) t1)``, + rw[tsaconv_def] >> + qexists_tac`f` >> rw[] >> + match_mp_tac tysubst_imp_raconv >> + rw[]) + +val ALOOKUP_MAP_FST_EQ_MAP_SND_REL = store_thm("ALOOKUP_MAP_FST_EQ_MAP_SND_REL", + ``∀l1 l2 x y1. + MAP FST l1 = MAP FST l2 ∧ + LIST_REL R (MAP SND l1) (MAP SND l2) ∧ + ALOOKUP l1 x = SOME y1 ⇒ + ∃y2. ALOOKUP l2 x = SOME y2 ∧ R y1 y2``, + Induct >> simp[] >> + Cases >> Cases >> simp[] >> + Cases_on`h`>>rw[] >> rw[]) + +(* the typing rules respect alpha-equivalence *) + +val type_e_aconv = store_thm("type_e_aconv", + ``∀tenv e t. type_e tenv e t ⇒ + EVERY (FINITE o FST o SND) tenv ⇒ + ∀tenv'. + MAP FST tenv = MAP FST tenv' ∧ + LIST_REL tsaconv (MAP SND tenv) (MAP SND tenv') ⇒ + type_e tenv' e t``, + ho_match_mp_tac type_e_ind >> + conj_tac >- simp[type_e_clauses] >> + conj_tac >- simp[type_e_clauses] >> + conj_tac >- ( + simp[type_e_clauses] >> rw[] >> + `∃z. ALOOKUP tenv' x = SOME z ∧ tsaconv (tvs,t) z` by + metis_tac[ALOOKUP_MAP_FST_EQ_MAP_SND_REL] >> + Cases_on`z`>>simp[]>> + first_x_assum(strip_assume_tac o MATCH_MP tsaconv_sym) >> + first_assum(mp_tac o MATCH_MP tsaconv_imp_tysubst) >> simp[] >> + `FINITE tvs` by ( + imp_res_tac ALOOKUP_MEM >> + fs[EVERY_MEM,FORALL_PROD] >> + metis_tac[] ) >> + discharge_hyps >- metis_tac[tsaconv_def,FINITE_INJ,BIJ_DEF] >> + rw[] >> rw[tysubst_tysubst] >> + qexists_tac`tysubst s o_f s'` >> simp[] >> + match_mp_tac tysubst_frees >> + simp[FLOOKUP_FUNION] >> + simp[FLOOKUP_o_f] >> + gen_tac >> BasicProvers.CASE_TAC >> + strip_tac >> + imp_res_tac tsaconv_tyvars_eq >> fs[] >> + pop_assum mp_tac >> + simp[EXTENSION] >> + qmatch_assum_rename_tac`z ∈ tyvars r` >> + disch_then(qspec_then`z`mp_tac) >> simp[] >> + `z ∉ FDOM s'` by fs[FLOOKUP_DEF] >> simp[] >> + simp[tyvars_tysubst] >> strip_tac >> + simp[FLOOKUP_DEF] >> + fs[SUBSET_DEF] >> + metis_tac[] ) >> + conj_tac >- ( + simp[type_e_clauses] >> + rw[] >> fs[] >> metis_tac[] ) >> + conj_tac >- ( + simp[type_e_clauses] >> rw[] >> fs[] >> + `tenv_vars tenv = tenv_vars tenv'` by ( + simp[tenv_vars_def,IMAGE_COMPOSE,GSYM LIST_TO_SET_MAP] >> + simp[MAP_MAP_o] >> + AP_TERM_TAC >> AP_TERM_TAC >> + simp[MAP_EQ_f] >> + pop_assum mp_tac >> + simp[LIST_REL_EL_EQN,LIST_EQ_REWRITE,EL_MAP,GSYM AND_IMP_INTRO] >> + rw[] >> res_tac >> + imp_res_tac tsaconv_tyvars_eq >> + simp[UNCURRY] ) >> + qexists_tac`t` >> simp[] >> + first_x_assum match_mp_tac >> + simp[] ) >> + conj_tac >- ( + simp[type_e_clauses] >> rw[] >> fs[] >> + qexists_tac`t` >> simp[] ) >> + conj_tac >- ( simp[type_e_clauses] ) >> + conj_tac >- ( simp[type_e_clauses] ) >> + conj_tac >- ( simp[type_e_clauses] ) >> + conj_tac >- ( simp[type_e_clauses] ) >> + conj_tac >- ( + simp[type_e_clauses] >> + rw[] >> fs[] >> + metis_tac[]) >> + conj_tac >- ( + simp[type_e_clauses] >> rw[] >> fs[] >> + `tenv_vars tenv = tenv_vars tenv'` by ( + simp[tenv_vars_def,IMAGE_COMPOSE,GSYM LIST_TO_SET_MAP] >> + simp[MAP_MAP_o] >> + AP_TERM_TAC >> AP_TERM_TAC >> + simp[MAP_EQ_f] >> + pop_assum mp_tac >> + simp[LIST_REL_EL_EQN,LIST_EQ_REWRITE,EL_MAP,GSYM AND_IMP_INTRO] >> + rw[] >> res_tac >> + imp_res_tac tsaconv_tyvars_eq >> + simp[UNCURRY] ) >> + qexists_tac`t1` >> simp[]) >> + conj_tac >- ( + simp[type_e_clauses] >> + rw[] >> fs[] >> + metis_tac[]) >> + simp[type_e_clauses] >> + rw[] >> fs[] >> + metis_tac[]) + +(* a type scheme that is fresh for any finite set of variables exists *) + +val fresh_def = new_specification("fresh_def",["fresh"], + IN_INFINITE_NOT_FINITE + |> Q.ISPECL[`UNIV:string set`,`s:string set`] + |> REWRITE_RULE[INST_TYPE[alpha|->``:char``]INFINITE_LIST_UNIV,IN_UNIV] + |> SIMP_RULE(srw_ss())[GSYM RIGHT_EXISTS_IMP_THM] + |> Q.GEN`s` + |> SIMP_RULE(srw_ss())[SKOLEM_THM]) + +val fresh_seq_def = tDefine"fresh_seq"` + fresh_seq avoid n = fresh (avoid ∪ (IMAGE (fresh_seq avoid) (count n)))` +(WF_REL_TAC`measure (I o SND)` >> simp[]) +val fresh_seq_def = + fresh_seq_def + |> SIMP_RULE (std_ss++boolSimps.ETA_ss)[] + |> curry save_thm "fresh_seq_def" + +val fresh_seq_thm = store_thm("fresh_seq_thm", + ``∀avoid n. + FINITE avoid ⇒ + fresh_seq avoid n ∉ avoid ∧ + ∀k. k < n ⇒ fresh_seq avoid n ≠ fresh_seq avoid k``, + simp[fresh_seq_def] >> + rpt gen_tac >> strip_tac >> + Q.PAT_ABBREV_TAC`s = avoid ∪ X` >> + `FINITE s` by simp[Abbr`s`] >> + qspec_then`s`mp_tac fresh_def >> + simp[Abbr`s`] >> rw[] >> + fs[fresh_seq_def] >> + metis_tac[]) + +val ALL_DISTINCT_fresh_seq = prove( + ``∀n avoid. FINITE avoid ⇒ ALL_DISTINCT (GENLIST (fresh_seq avoid) n)``, + Induct >> simp[GENLIST,ALL_DISTINCT_SNOC,MEM_GENLIST] >> + metis_tac[fresh_seq_thm]) + +val DISJOINT_fresh_seq = prove( + ``∀n avoid. FINITE avoid ⇒ DISJOINT (set (GENLIST (fresh_seq avoid) n)) avoid``, + Induct >> simp[GENLIST,LIST_TO_SET_SNOC] >> + metis_tac[fresh_seq_thm]) + +(* not yet proved (but not yet needed either) +val fresh_ts_exists = prove( + ``∃f. ∀avoid ts. + FINITE avoid ∧ + FINITE (FST ts) ⇒ + DISJOINT avoid (FST (f avoid ts)) ∧ + tsaconv ts (f avoid ts)``, + simp[GSYM SKOLEM_THM] >> + rw[RIGHT_EXISTS_IMP_THM] >> + `∃f tvs2. BIJ f (FST ts) tvs2 ∧ DISJOINT tvs2 (tyvars (SND ts) ∪ avoid)` by cheat >> + qspecl_then[`f`,`FST ts`,`SND ts`,`tvs2`]mp_tac tysubst_imp_aconv >> + simp[] >> fs[] >> simp[Once DISJOINT_SYM] >> + strip_tac >> + simp[EXISTS_PROD] >> + metis_tac[]) +val fresh_ts_def = new_specification("fresh_ts_def",["fresh_ts"],fresh_ts_exists) +*) + +(* +We have not yet proved the following properties of the type system. The proofs +will likely require much tedious reasoning about capture-avoiding substitution +over type schemes. Since they are solely about the type system, and not the +semantics, this does not depend on whether functional big-step or small-step +semantics is used. However, these are the only proofs where the value +restriction is relevant. +*) + +val generalisation_lemma1 = prove( + ``type_env rt et env tenv ∧ type_v rt et v t ∧ + MEM v (MAP SND env) ∧ + FDOM s ⊆ tyvars t DIFF tenv_vars tenv ⇒ + type_v rt et v (tysubst s t)``, + cheat) + +val generalisation_lemma2 = prove( + ``type_env rt et env tenv ∧ + type_env rt et env tenv2 ∧ + type_e ((x,{},t1)::tenv) e t2 ∧ + FDOM s ⊆ tyvars (Tfn t1 t2) DIFF tenv_vars tenv2 + ⇒ + ∃tenv'. + type_env rt et env tenv' ∧ + type_e ((x,{},tysubst s t1)::tenv') e (tysubst s t2)``, + cheat) + +val generalisation_lemma3 = prove( + ``type_env rt et env tenv ∧ + type_env rt et env tenv2 ∧ + type_e ((x,{},t1)::(f,{},Tfn t1 t2)::tenv) e t2 ∧ + FDOM s ⊆ tyvars (Tfn t1 t2) DIFF tenv_vars tenv2 + ⇒ + ∃tenv'. + type_env rt et env tenv' ∧ + type_e ((x,{},tysubst s t1)::(f,{},tysubst s (Tfn t1 t2))::tenv') e (tysubst s t2)``, + cheat) + +(* lemma about type environment's relationship to value environment *) + +val type_env_ALOOKUP_tenv_SOME = prove( + ``∀env tenv. type_env rt et env tenv ⇒ + ∀x tvs t. + ALOOKUP tenv x = SOME (tvs,t) ⇒ + ∃v. ALOOKUP env x = SOME v ∧ + ∀s. FDOM s ⊆ tvs ⇒ + type_v rt et v (tysubst s t)``, + Induct >> simp[type_env_clauses] >> + Cases >> simp[] >> + Cases >> simp[] >> + PairCases_on`h`>>simp[] >> + rw[] >> rw[] >> fs[] >> + metis_tac[]) + +(* +We prove type soundness by induction on the semantics. This works because both +the typing relation and the semantics are syntax-directed. We establish that +well-typed expressions do not fail, if they terminate with a value then the +value has the same type as the original expression, and if they terminate with +an exception, the exception's parameter matches the type of the exception. +*) + +val type_soundness = store_thm("type_soundness", + ``∀env s e tenv rt et t. type_e tenv e t ⇒ + LIST_REL (type_v rt et) s.refs rt ⇒ + type_env rt et env tenv ⇒ + LENGTH et = s.next_exn ⇒ + let (r,s') = sem env s e in + ∃rt' et'. + LIST_REL (type_v (rt++rt') (et++et')) s'.refs (rt++rt') ∧ + type_env (rt++rt') (et++et') env tenv ∧ + LENGTH (et++et') = s'.next_exn ∧ + case r of + | Rfail => F + | Rval v => type_v (rt++rt') (et++et') v t + | Rraise n v => + n < LENGTH (et++et') ∧ + type_v (rt++rt') (et++et') v (EL n (et++et')) + | _ => T``, + ho_match_mp_tac sem_ind >> + conj_tac >- ( simp[sem_def,type_v_clauses,type_e_clauses,LENGTH_NIL] >> metis_tac[APPEND_NIL]) >> + conj_tac >- ( + rpt gen_tac >> + simp[sem_def,type_e_clauses] >> + rpt strip_tac >> + imp_res_tac type_env_ALOOKUP_tenv_SOME >> + simp[] >> rw[LENGTH_NIL] >> + qexists_tac`[]`>>rw[]) >> + conj_tac >- ( + rpt gen_tac >> + ntac 3 strip_tac >> + simp[type_e_clauses,sem_def] >> + ntac 6 strip_tac >> + `∃r s1. sem env s e = (r,s1)` by metis_tac[pairTheory.PAIR] >> simp[] >> + reverse(Cases_on`r`)>>fs[]>-( + fs[LET_THM] >> metis_tac[ADD_COMM] ) >- ( + fs[LET_THM] >> metis_tac[] ) >- ( + fs[LET_THM] >> metis_tac[ADD_COMM] ) >> + `∃r' s2. sem env s1 e' = (r',s2)` by metis_tac[pairTheory.PAIR] >> simp[] >> + fs[LET_THM] >> + reverse(Cases_on`r'`)>>fs[] >- ( + first_x_assum(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + disch_then(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + simp[] >> strip_tac >> + first_x_assum(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + disch_then(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + discharge_hyps >- metis_tac[type_v_extend] >> strip_tac >> + rev_full_simp_tac(srw_ss()++ARITH_ss)[] >> + qexists_tac`rt''++rt'''` >> + qexists_tac`et''++et'''` >> + simp[]) + >- ( + first_x_assum(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + disch_then(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + simp[] >> strip_tac >> + spose_not_then strip_assume_tac >> + first_x_assum(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + disch_then(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + simp[] ) + >- ( + first_x_assum(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + disch_then(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + simp[] >> strip_tac >> + first_x_assum(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + disch_then(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + simp[] >> strip_tac >> + qexists_tac`rt''++rt'''` >> + qexists_tac`et''++et'''` >> + simp[]) >> + reverse IF_CASES_TAC >> simp[] >- ( + first_x_assum(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + disch_then(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + simp[] >> strip_tac >> + first_x_assum(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + disch_then(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + simp[] >> strip_tac >> + qexists_tac`rt''++rt'''` >> + qexists_tac`et''++et'''` >> + simp[]) >> + BasicProvers.CASE_TAC >> fs[] >> TRY ( + fs[type_v_clauses] >> res_tac >> fs[] >> NO_TAC) >> + rfs[] >> + first_x_assum(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + disch_then(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + simp[] >> strip_tac >> + first_x_assum(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + disch_then(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + simp[] >> strip_tac >> + fs[type_v_clauses] >> + first_x_assum(fn th => first_assum(mp_tac o MATCH_MP th)) >> + disch_then(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + simp[type_env_clauses,type_v_clauses,FDOM_EQ_EMPTY] >> + (discharge_hyps >- metis_tac[type_v_extend]) >> strip_tac >> + fs[UNCURRY] >> + BasicProvers.CASE_TAC >> fs[] >> + qexists_tac`rt''++rt'''++rt''''` >> + qexists_tac`et''++et'''++et''''` >> + simp[] >> + metis_tac[APPEND_ASSOC,type_v_extend]) >> + conj_tac >- ( + rpt gen_tac >> + ntac 2 strip_tac >> + simp[type_e_clauses,sem_def] >> + `∃r s1. sem env s e = (r,s1)` by metis_tac[pairTheory.PAIR] >> simp[] >> + reverse(Cases_on`r`)>>fs[]>-( + fs[LET_THM] >> metis_tac[ADD_COMM] ) >- ( + fs[LET_THM] >> metis_tac[] ) >- ( + fs[LET_THM] >> metis_tac[ADD_COMM] ) >> + `∃r' s2. sem ((x,v)::env) s1 e' = (r',s2)` by metis_tac[pairTheory.PAIR] >> simp[] >> + fs[LET_THM] >> + rpt gen_tac >> rpt strip_tac >> + first_x_assum(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + disch_then(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + simp[] >> strip_tac >> + first_x_assum(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + disch_then(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + fs[type_env_clauses,PULL_EXISTS] >> simp[FDOM_EQ_EMPTY] >> + TRY(discharge_hyps >- ( + Cases_on`e`>>fs[sem_def]>>BasicProvers.EVERY_CASE_TAC>>fs[]>> + rw[]>>fs[type_v_clauses,LENGTH_NIL]>>rw[]>>fs[] + >- ( + `MEM v (MAP SND env)` by ( + imp_res_tac ALOOKUP_MEM >> + simp[MEM_MAP,EXISTS_PROD] >> + metis_tac[] ) >> + metis_tac[generalisation_lemma1]) + >- ( metis_tac[generalisation_lemma2, + SIMP_CONV(srw_ss())[]``tyvars (Tfn t1 t2)``] ) + >- ( + match_mp_tac (GEN_ALL(SIMP_RULE(srw_ss())[]generalisation_lemma3))>> + metis_tac[]))) >> + strip_tac >> + BasicProvers.CASE_TAC >> fs[] >> + qexists_tac`rt'++rt''` >> + qexists_tac`et'++et''` >> + simp[]) >> + conj_tac >- ( + simp[type_e_clauses,sem_def,type_v_clauses] >> + rw[LENGTH_NIL] >> metis_tac[APPEND_NIL] ) >> + conj_tac >- ( + simp[type_e_clauses,sem_def,type_v_clauses] >> + rw[LENGTH_NIL] >> metis_tac[APPEND_NIL]) >> + conj_tac >- ( + simp[type_e_clauses,sem_def,type_v_clauses] >> + rw[] >> + `∃r s1. sem env s e = (r,s1)` by metis_tac[pairTheory.PAIR] >> simp[] >> + reverse(Cases_on`r`)>>fs[]>-( + fs[LET_THM] >> metis_tac[] ) >- ( + fs[LET_THM] >> metis_tac[] ) >- ( + fs[LET_THM] >> metis_tac[] ) >> + simp[type_v_clauses] >> + first_x_assum(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + disch_then(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + simp[] >> strip_tac >> + qexists_tac`rt''++[t']` >> + qexists_tac`et''` >> + conj_tac >- ( + ONCE_REWRITE_TAC[APPEND_ASSOC] >> + match_mp_tac rich_listTheory.EVERY2_APPEND_suff >> + simp[] >> + reverse conj_tac >- metis_tac[type_v_extend,APPEND_NIL] >> + match_mp_tac(MP_CANON(GEN_ALL LIST_REL_mono)) >> + metis_tac[type_v_extend,APPEND_NIL] ) >> + imp_res_tac LIST_REL_LENGTH >> + simp[rich_listTheory.EL_APPEND2] >> + metis_tac[type_v_extend,APPEND_NIL]) >> + conj_tac >- ( + simp[type_e_clauses,sem_def,type_v_clauses] >> + rw[] >> + `∃r s1. sem env s e = (r,s1)` by metis_tac[pairTheory.PAIR] >> simp[] >> + reverse(Cases_on`r`)>>fs[]>-( + fs[LET_THM] >> metis_tac[] ) >- ( + fs[LET_THM] >> metis_tac[] ) >- ( + fs[LET_THM] >> metis_tac[] ) >> + BasicProvers.CASE_TAC >> fs[] >> + TRY(res_tac >> fs[type_v_clauses]>>NO_TAC) >> + rw[] >> + res_tac >> + fs[type_v_clauses] >> + fs[LIST_REL_EL_EQN] >> + metis_tac[] ) >> + conj_tac >- ( + rpt gen_tac >> + ntac 3 strip_tac >> + simp[type_e_clauses,sem_def] >> + ntac 6 strip_tac >> + `∃r s1. sem env s e = (r,s1)` by metis_tac[pairTheory.PAIR] >> simp[] >> + reverse(Cases_on`r`)>>fs[]>-( + fs[LET_THM] >> metis_tac[ADD_COMM] ) >- ( + fs[LET_THM] >> metis_tac[] ) >- ( + fs[LET_THM] >> metis_tac[ADD_COMM] ) >> + `∃r' s2. sem env s1 e' = (r',s2)` by metis_tac[pairTheory.PAIR] >> simp[] >> + fs[LET_THM] >> + reverse(Cases_on`r'`)>>fs[] >- ( + first_x_assum(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + disch_then(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + simp[] >> strip_tac >> + first_x_assum(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + disch_then(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + discharge_hyps >- metis_tac[type_v_extend] >> strip_tac >> + metis_tac[APPEND_ASSOC,ADD_ASSOC,ADD_COMM,LENGTH_APPEND] ) + >- ( + first_x_assum(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + disch_then(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + simp[] >> strip_tac >> + metis_tac[type_v_extend,APPEND_ASSOC,ADD_ASSOC,LENGTH_APPEND,ADD_COMM] ) + >- ( + first_x_assum(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + disch_then(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + simp[] >> strip_tac >> + first_x_assum(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + disch_then(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + simp[] >> strip_tac >> + qexists_tac`rt''++rt'''` >> + qexists_tac`et''++et'''` >> + simp[]) >> + BasicProvers.CASE_TAC >> fs[] >> TRY ( + fs[type_v_clauses] >> res_tac >> fs[] >> NO_TAC) >> + first_x_assum(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + disch_then(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + simp[] >> strip_tac >> + first_x_assum(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + disch_then(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + discharge_hyps >- metis_tac[] >> strip_tac >> + fs[type_v_clauses] >> + rev_full_simp_tac(srw_ss()++ARITH_ss)[] >> + reverse IF_CASES_TAC >> fs[type_v_clauses] >- ( + imp_res_tac LIST_REL_LENGTH >> fs[] >> DECIDE_TAC ) >> + Cases_on`n < LENGTH rt` >- ( + qexists_tac`rt'' ++ rt'''` >> + qexists_tac`et'' ++ et'''` >> simp[] >> + fs[LIST_REL_EL_EQN,EL_LUPDATE] >> rw[] >> + fs[rich_listTheory.EL_APPEND1] ) >> + qexists_tac`LUPDATE t' (n-LENGTH rt) (rt'' ++ rt''')` >> + qexists_tac`et''++et'''` >> + reverse conj_tac >- metis_tac[type_v_extend,LENGTH_APPEND,ADD_ASSOC,ADD_COMM] >> + simp[GSYM rich_listTheory.LUPDATE_APPEND2] >> + match_mp_tac EVERY2_LUPDATE_same >> + simp[rich_listTheory.EL_APPEND1,rich_listTheory.EL_APPEND2] >> + simp[rich_listTheory.LUPDATE_APPEND1,rich_listTheory.LUPDATE_APPEND2] >> + simp[LUPDATE_ID] >> rw[] >> + qpat_assum`type_v A X Y Z`mp_tac >> + simp[rich_listTheory.EL_APPEND2]) >> + conj_tac >- ( + rpt gen_tac >> + strip_tac >> + simp[type_e_clauses,sem_def] >> + rpt gen_tac >> rpt strip_tac >> + Q.PAT_ABBREV_TAC`env' =X::env` >> + Q.PAT_ABBREV_TAC`s' = s with next_exn := Y` >> + `∃r s1. sem env' s' e = (r,s1)` by metis_tac[pairTheory.PAIR] >> simp[] >> + fs[LET_THM,Abbr`s'`,Abbr`env'`,type_env_clauses,PULL_EXISTS,type_v_clauses] >> + first_x_assum(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + disch_then(qspecl_then[`rt`,`et++[t1]`]mp_tac) >> + discharge_hyps >- ( + match_mp_tac(MP_CANON(GEN_ALL LIST_REL_mono)) >> + metis_tac[type_v_extend,APPEND_NIL] ) >> + simp[rich_listTheory.EL_APPEND2,FDOM_EQ_EMPTY] >> + discharge_hyps >- metis_tac[type_v_extend,APPEND_NIL] >> + strip_tac >> + qexists_tac`rt''` >> + qexists_tac`[t1]++et''` >> + simp[] >> + Cases_on`r`>>fs[]>> + simp[]) >> + conj_tac >- ( + rpt gen_tac >> + ntac 2 strip_tac >> + simp[type_e_clauses,sem_def] >> + rpt strip_tac >> + `∃r s1. sem env s e = (r,s1)` by metis_tac[pairTheory.PAIR] >> simp[] >> + (Cases_on`r`)>>fs[LET_THM]>>TRY(metis_tac[ADD_COMM])>> + `∃r s2. sem env s1 e' = (r,s2)` by metis_tac[pairTheory.PAIR] >> simp[] >> + first_x_assum(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + disch_then(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + simp[] >> strip_tac>> + first_x_assum(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + disch_then(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + discharge_hyps >- metis_tac[] >> strip_tac >> rfs[] >> + rev_full_simp_tac(srw_ss()++ARITH_ss)[] >> + reverse(Cases_on`r`)>>fs[LET_THM] + >-(metis_tac[APPEND_ASSOC,LENGTH_APPEND,ADD_ASSOC,ADD_COMM]) + >-(qexists_tac`rt''++rt'''`>> + qexists_tac`et''++et'''`>> + simp[] ) >> + Cases_on`v`>>fs[type_v_clauses]>> + qexists_tac`rt''++rt'''`>> + qexists_tac`et''++et'''`>> + simp[] >> simp[rich_listTheory.EL_APPEND1] >> + metis_tac[] ) >> + rpt gen_tac >> + ntac 3 strip_tac >> + simp[type_e_clauses,sem_def] >> + rpt strip_tac >> + `∃r s1. sem env s e' = (r,s1)` by metis_tac[pairTheory.PAIR] >> simp[] >> + (Cases_on`r`)>>fs[LET_THM]>>TRY(metis_tac[ADD_COMM])>> + `∃r s2. sem env s1 e'' = (r,s2)` by metis_tac[pairTheory.PAIR] >> simp[] >> + first_x_assum(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + disch_then(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + simp[] >> strip_tac>> + Cases_on`v`>>TRY(fs[type_v_clauses]>>NO_TAC)>>simp[]>> fs[] >> + first_x_assum(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + disch_then(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + discharge_hyps >- metis_tac[] >> strip_tac >> rfs[] >> + rev_full_simp_tac(srw_ss()++ARITH_ss)[] >> + reverse(Cases_on`r`)>>fs[LET_THM] + >-(qexists_tac`rt''++rt'''`>> + qexists_tac`et''++et'''`>> + simp[] ) + >-(qexists_tac`rt''++rt'''`>> + qexists_tac`et''++et'''`>> + simp[] ) >> + `∃r s3. sem env s2 e = (r,s3)` by metis_tac[pairTheory.PAIR] >> simp[] >> + reverse IF_CASES_TAC >> fs[] >- ( + Cases_on`v`>>fs[type_v_clauses] ) >> + first_x_assum(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + disch_then(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + discharge_hyps >- metis_tac[] >> strip_tac >> rfs[] >> + rev_full_simp_tac(srw_ss()++ARITH_ss)[] >> + reverse(Cases_on`r`)>>fs[LET_THM] + >-(qexists_tac`rt''++rt'''++rt''''`>> + qexists_tac`et''++et'''++et''''`>> + simp[] ) + >-( + reverse IF_CASES_TAC >> fs[] >-(qexists_tac`rt''++rt'''++rt''''`>> + qexists_tac`et''++et'''++et''''`>> + simp[] ) >> + reverse IF_CASES_TAC >> fs[] >-(qexists_tac`rt''++rt'''++rt''''`>> + qexists_tac`et''++et'''++et''''`>> + simp[] ) >> + Cases_on`v`>>fs[type_v_clauses] >> + first_x_assum(fn th => first_assum(mp_tac o MATCH_MP th)) >> + disch_then(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + simp[type_env_clauses,FDOM_EQ_EMPTY] >> + (discharge_hyps >- ( + rev_full_simp_tac(srw_ss()++ARITH_ss)[rich_listTheory.EL_APPEND1] >> + simp[type_v_clauses] >> + metis_tac[type_v_extend,APPEND_ASSOC] ) ) >> + simp[UNCURRY] >> strip_tac >> + BasicProvers.CASE_TAC >> fs[] >> + qexists_tac`rt''++rt'''++rt''''++rt'''''`>> + qexists_tac`et''++et'''++et''''++et'''''`>> + simp[] >> + metis_tac[type_v_extend,APPEND_ASSOC] ) + >-(qexists_tac`rt''++rt'''++rt''''`>> + qexists_tac`et''++et'''++et''''`>> + simp[] )) + +val _ = export_theory() From 203d9724c916fd76ec34a381bc9cd99088d792e6 Mon Sep 17 00:00:00 2001 From: Magnus Myreen Date: Sat, 21 Mar 2015 07:51:13 +0100 Subject: [PATCH 244/718] added !!examples/fun-op-sem to build-seq --- tools/sequences/final-examples | 1 + 1 file changed, 1 insertion(+) diff --git a/tools/sequences/final-examples b/tools/sequences/final-examples index 4b2e9654bc..e97695ea19 100644 --- a/tools/sequences/final-examples +++ b/tools/sequences/final-examples @@ -8,6 +8,7 @@ !!examples/miller/ho_prover !!examples/miller/miller !!examples/ARM_security_properties +!!examples/fun-op-sem # Crypto examples !!examples/Crypto/AES From c7effb6ef9a3525e471be2617730c27e7a69277a Mon Sep 17 00:00:00 2001 From: Magnus Myreen Date: Sat, 21 Mar 2015 11:30:28 +0100 Subject: [PATCH 245/718] fun-op-sem only builds with standard kernel --- tools/sequences/final-examples | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/sequences/final-examples b/tools/sequences/final-examples index e97695ea19..7d8b38dabd 100644 --- a/tools/sequences/final-examples +++ b/tools/sequences/final-examples @@ -8,7 +8,7 @@ !!examples/miller/ho_prover !!examples/miller/miller !!examples/ARM_security_properties -!!examples/fun-op-sem +## !!examples/fun-op-sem works only with the standard kernel # Crypto examples !!examples/Crypto/AES From 9cc44ac0fe87f8fe058fb9c17e7de593f830e101 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 23 Mar 2015 12:13:07 +1100 Subject: [PATCH 246/718] Clarify language on Induct_on with inductive relations Closes #245 --- Manual/Description/definitions.tex | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/Manual/Description/definitions.tex b/Manual/Description/definitions.tex index da91330a3d..1e9ac7bc52 100644 --- a/Manual/Description/definitions.tex +++ b/Manual/Description/definitions.tex @@ -2122,7 +2122,8 @@ \subsection{Proofs with Inductive Relations} HO_MATCH_MP_TAC R_ind \end{verbatim} \index{Induct_on (ML induction tactic)@\ml{Induct\_on} (\ML{} induction tactic)} -A slightly more high-level approach is use the \ml{Induct\_on} tactic. +A slightly more high-level approach is use the \ml{Induct\_on} tactic, which will actually use the automatically generated ``strong'' induction principle.% +\footnote{Thus, to get the equivalent of the \ml{Induct_on} call, one might write something like \ml{HO_MATCH_MP_TAC~(theorem "R_strongind")}.} (This tactic is also used to perform structural inductions over algebraic data types; see Section~\ref{sec:bossLib}.) When performing a rule induction, the quotation passed to \ml{Induct\_on} should be of the constant being used. For the sake of aesthetics, the constant may also be applied to arguments. From 893569d90483585395a62ff378d4103e327a0dfa Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 23 Mar 2015 12:49:11 +1100 Subject: [PATCH 247/718] UTF8.getChar was too liberal. In particular, it allowed UTF8 encodings that used more bytes than they should. Fixed this and added a bunch of test-cases. Also, stopped getChar from decoding past the maximum allowed code-point. Thanks to Rob Arthan for the bug report. Closes #237 --- src/portableML/UTF8.sml | 12 +++++++++++- src/portableML/selftest.sml | 21 ++++++++++++++++++++- 2 files changed, 31 insertions(+), 2 deletions(-) diff --git a/src/portableML/UTF8.sml b/src/portableML/UTF8.sml index 1b9ab6efb8..a5912c0a0d 100644 --- a/src/portableML/UTF8.sml +++ b/src/portableML/UTF8.sml @@ -55,6 +55,13 @@ fun isCont_char c = let val i = Char.ord c in 128 <= i andalso i < 192 end fun pow2 i = Word.toInt (Word.<<(0w1, Word.fromInt i)) fun getChar s = let + fun rangeCheck cnt (res as ((_, i), _)) = + if case cnt of 2 => 0x80 <= i + | 3 => 0x800 <= i + | 4 => 0x10000 <= i andalso i <= Umax + | _ => false + then res + else raise BadUTF8 s open Substring fun ucontinue acc pos limit ss = if pos = limit then let @@ -81,7 +88,10 @@ fun getChar s = let val cnt = byte1_count c in if cnt = 1 then raise BadUTF8 (str c) - else ucontinue (i + pow2 (8 - cnt) - 256) 1 cnt ss + else + Option.map + (rangeCheck cnt) + (ucontinue (i + pow2 (8 - cnt) - 256) 1 cnt ss) end end in diff --git a/src/portableML/selftest.sml b/src/portableML/selftest.sml index d6f9986d24..0e64cdc64a 100644 --- a/src/portableML/selftest.sml +++ b/src/portableML/selftest.sml @@ -17,12 +17,31 @@ val em10 = empty m10cmp val em3 = add(em10, 3) val em13 = add(em3, 13) +fun gcSucceeds s res () = UTF8.getChar s = res +fun gcFails s () = (UTF8.getChar s ; false) handle UTF8.BadUTF8 _ => true + val _ = List.app assert [ ("Redblackset.isSubset({},{})", fn () => isSubset(es,es)), ("Redblackset.isSubset({}, {1})", (fn () => isSubset(es,addList(es,[1])))), ("Redblackset.add replaces EQUAL elements", - (fn () => listItems em13 = [13])) + (fn () => listItems em13 = [13])), + ("UTF8.getChar \"\" = NONE", gcSucceeds "" NONE), + ("UTF8.getChar 0x41 = #\"A\"", gcSucceeds "A" (SOME(("A", 65), ""))), + ("UTF8.getChar A\000 = #\"A\"", + gcSucceeds "A\000" (SOME(("A", 65), "\000"))), + ("UTF8.getChar 0x2200 = #\"\226\136\128\"", + gcSucceeds "\226\136\128" (SOME(("\226\136\128", 8704), ""))), + ("UTF8.getChar 0x2200A = #\"\226\136\128\"", + gcSucceeds "\226\136\128A" (SOME(("\226\136\128", 8704), "A"))), + ("UTF8.getChar 0x2200-0x2000 = #\"\226\136\128\"", + gcSucceeds "\226\136\128\226\136\128" + (SOME(("\226\136\128", 8704), "\226\136\128"))), + ("UTF8.getChar 0x8F fails", gcFails "\128"), + ("UTF8.getChar \"\\192\\128\" fails", gcFails "\192\168"), + ("UTF8.getChar \"\\252\\129\\129\\129\\129\\129\" fails", + gcFails "\252\129\129\129\129\129"), + ("UF8.getChar \"\\244\\129\" fails", gcFails "\244\129") ] val _ = OS.Process.exit OS.Process.success From 9208e9ef86970e2dd1dc37ba7e496334a3a47b31 Mon Sep 17 00:00:00 2001 From: Piotr Trojanek Date: Sun, 15 Mar 2015 00:17:59 +0000 Subject: [PATCH 248/718] help: trivial typo --- help/Docfiles/bossLib.Induct_on.doc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/help/Docfiles/bossLib.Induct_on.doc b/help/Docfiles/bossLib.Induct_on.doc index e986c312d1..a8eeb61f01 100644 --- a/help/Docfiles/bossLib.Induct_on.doc +++ b/help/Docfiles/bossLib.Induct_on.doc @@ -28,7 +28,7 @@ and quantifies all free variables of {M} before universally quantifying {v} and then finally inducting on {v}. {Induct_on} may also be used to apply an induction theorem coming from -declaration of a mutually recursive datattype. +declaration of a mutually recursive datatype. \FAILURE From 13b2274a9f0118a8fd4edea3b9f6235200958e4e Mon Sep 17 00:00:00 2001 From: Piotr Trojanek Date: Mon, 16 Mar 2015 23:18:47 +0000 Subject: [PATCH 249/718] description: spacing fixups --- Manual/Description/HolSat.tex | 12 ++++++------ Manual/Description/enumfset.tex | 8 ++++---- Manual/Description/libraries.tex | 2 +- 3 files changed, 11 insertions(+), 11 deletions(-) diff --git a/Manual/Description/HolSat.tex b/Manual/Description/HolSat.tex index 6f5b94a175..af3ea5fc4f 100644 --- a/Manual/Description/HolSat.tex +++ b/Manual/Description/HolSat.tex @@ -129,22 +129,22 @@ \subsection{The general interface} The functions described above are wrappers for the function \texttt{GEN\_SAT}, which is the single entry point for {\tt{HolSatLib}}. \texttt{GEN\_SAT} can be used directly if more flexibility is required. \texttt{GEN\_SAT} takes a single argument, of type \texttt{sat\_config}, defined in \texttt{satConfig.sml}. This is an opaque record type, currently containing the following fields: \begin{enumerate} -\item{\texttt{term : Term.term}} +\item{\texttt{term~:~Term.term}} The input term. -\item{\texttt{solver : SatSolvers.sat\_solver}} +\item{\texttt{solver~:~SatSolvers.sat\_solver}} The external SAT solver to use. The default is \texttt{SatSolvers.minisatp}. If ZChaff is installed (see \S\ref{subsec:hs-zchaff}), then \texttt{SatSolvers.zchaff} may also be used. -\item{\texttt{infile : string option}} +\item{\texttt{infile~:~string option}} The name of a file in DIMACS format.\footnote{\url{http://www.satlib.org/Benchmarks/SAT/satformat.ps}} Overrides \texttt{term} if set. The input term is instead read from the file. -\item{\texttt{proof : string option}} +\item{\texttt{proof~:~string option}} The name of a proof trace file. Overrides \texttt{solver} if set. The file must be in the native format of {\tt{HolSatLib}}, and must correspond to a proof for \texttt{infile}, which must also be set. The included version of MiniSat has been modified to produce proofs in the native format, and ZChaff proofs are translated to this format using the included proof translator \texttt{src/HolSat/sat\_solvers/zc2hs} (type \texttt{zc2hs -h} for usage help). \texttt{zc2hs} is used internally by \texttt{ZSAT\_PROVE} etc. -\item{\texttt{is\_cnf : bool}} +\item{\texttt{is\_cnf~:~bool}} If true then the input term is expected to be a negated CNF term. This is set automatically if \texttt{infile} is set. Typically a user will never need to modify this field directly. -\item{\texttt{is\_proved : bool}} +\item{\texttt{is\_proved~:~bool}} If true then \HOL{} will prove the SAT solver's results. \end{enumerate} diff --git a/Manual/Description/enumfset.tex b/Manual/Description/enumfset.tex index 0058ea39b7..178be48dda 100644 --- a/Manual/Description/enumfset.tex +++ b/Manual/Description/enumfset.tex @@ -102,7 +102,7 @@ \num\ that should in principle be quicker to compute on {\tt NUMERAL} terms than the usual order) with corresponding conversions {\tt numto_CONV}, etc. Also, for lexicographic order on pairs, there are the -object language function {\tt lextoto : 'a toto -> 'b toto -> ('a\#'b)toto} +object language function {\tt lextoto~:~'a toto -> 'b toto -> ('a\#'b)toto} and the \ml\ function {\tt lextoto_CONV : conv -> conv -> conv}; if {\tt cva} and {\tt cvb} are conversions for evaluating terms that start {\tt apto toa} \dots\ and {\tt apto tob} \dots\ respectively, @@ -159,7 +159,7 @@ \headingthree{Translating between set representations} \HOL\ offers two notations for explicit finite sets: the display notation {\tt\{x1; ...~; xn\}}, which is short for -{\tt x1 INSERT ... INSERT xn INSERT \{\}}, and notation with an explicit list: +{\tt x1 INSERT~...~INSERT xn INSERT \{\}}, and notation with an explicit list: {\tt set [x1; ...~; xn]}. We provide here conversions back and forth between these: \begin{verbatim} @@ -169,7 +169,7 @@ and to create {\tt ENUMERAL} sets from either: \begin{verbatim} set_TO_ENUMERAL_CONV: conv -> term -> conv - DISPLAY_TO_ENUMERAL_CONV:conv -> term -> conv + DISPLAY_TO_ENUMERAL_CONV: conv -> term -> conv \end{verbatim} (these demanding a {\tt toto} order on the element type and a conversion for evaluating it), @@ -182,7 +182,7 @@ \begin{verbatim} TO_set_CONV: conv -> conv \end{verbatim} -will normalize any of the three forms to the {\tt set [ ... ]} form. +will normalize any of the three forms to the {\tt set [~...~]} form. ({\tt NO_CONV} will suffice as the conversion argument if it is not an {\tt ENUMERAL} that is to be normalized.) The conversions from the {\tt ENUMERAL} form have to execute, for a diff --git a/Manual/Description/libraries.tex b/Manual/Description/libraries.tex index 76ad17b64a..496ec5a2d7 100644 --- a/Manual/Description/libraries.tex +++ b/Manual/Description/libraries.tex @@ -1444,7 +1444,7 @@ \subsection{Support for high-level proof steps} \begin{description} \item [\ml{completeInduct\_on}] performs complete induction on the term denoted by the given quotation. Complete induction allows a - seemingly \footnote{Complete induction and ordinary mathematical + seemingly\footnote{Complete induction and ordinary mathematical induction are each derivable from the other.} stronger induction hypothesis than ordinary mathematical induction: to wit, when inducting on $n$, one is allowed to assume the property holds for From 54c51f257709b73be4494a19cdcd8c65a93d1b35 Mon Sep 17 00:00:00 2001 From: Magnus Myreen Date: Mon, 23 Mar 2015 15:51:51 +0100 Subject: [PATCH 250/718] typo in m0_decompLib.sig --- examples/l3-machine-code/m0/decompiler/m0_decompLib.sig | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/l3-machine-code/m0/decompiler/m0_decompLib.sig b/examples/l3-machine-code/m0/decompiler/m0_decompLib.sig index 4f97f8a10f..cb6a5d1125 100644 --- a/examples/l3-machine-code/m0/decompiler/m0_decompLib.sig +++ b/examples/l3-machine-code/m0/decompiler/m0_decompLib.sig @@ -8,6 +8,6 @@ sig val l3_m0_tools_mapped: helperLib.decompiler_tools val l3_m0_tools_mapped_no_status: helperLib.decompiler_tools val l3_m0_tools_no_status: helperLib.decompiler_tools - val m0_decompile : string -> Term.term quotation -> Thm.thm * Thm.thm + val m0_decompile : string -> string quotation -> Thm.thm * Thm.thm val m0_decompile_code : string -> string quotation -> Thm.thm * Thm.thm end From 2f10f68c429c4ef2baa22197a6b35cd1b603528c Mon Sep 17 00:00:00 2001 From: Thomas Tuerk Date: Tue, 24 Mar 2015 23:27:22 +0100 Subject: [PATCH 251/718] deep_matches add multi-row redundancy detection implement a check for redundant rows that considers multiple rows. The previous one considers only single other rows and is therefore faster, but not as powerful. Detecting redundancy is complicated and for doing it some generation of nchotomy theorems using pattern compilation was implemented. These nchotomies are handy for other problems as well. --- examples/deep_matches/constrFamiliesLib.sig | 24 +- examples/deep_matches/constrFamiliesLib.sml | 197 ++++- examples/deep_matches/deepMatchesExamples.sml | 48 +- examples/deep_matches/deepMatchesLib.sig | 52 +- examples/deep_matches/deepMatchesLib.sml | 690 ++++++++++++++- examples/deep_matches/deepMatchesScript.sml | 817 ++++++++++-------- examples/deep_matches/deepMatchesSyntax.sig | 144 ++- examples/deep_matches/deepMatchesSyntax.sml | 322 ++++++- 8 files changed, 1851 insertions(+), 443 deletions(-) diff --git a/examples/deep_matches/constrFamiliesLib.sig b/examples/deep_matches/constrFamiliesLib.sig index 37aa2adbbb..e81f82ce34 100644 --- a/examples/deep_matches/constrFamiliesLib.sig +++ b/examples/deep_matches/constrFamiliesLib.sig @@ -101,13 +101,20 @@ sig (* A compilation fun gets a column, i.e. a list of terms together with a list of free variables in this term. For this column a expansion theorem of the form - ``!ff x. ff x = ...`` - and an ssfrag should be returned. *) - type pmatch_compile_fun = (term list * term) list -> (thm * simpLib.ssfrag) option + ``!ff x. ff x = ...``, the number of cases in this expansion + theorem and an ssfrag should be returned. *) + type pmatch_compile_fun = (term list * term) list -> (thm * int * simpLib.ssfrag) option + + (* A compilation fun gets a column, i.e. a list of + terms together with a list of free variables in this term. + For this column an nchotomy theorem as well as the number of + entries in this nchotomy should be returned. *) + type pmatch_nchotomy_fun = (term list * term) list -> (thm * int) option (* A database for pattern compilation *) type pmatch_compile_db = { pcdb_compile_funs : pmatch_compile_fun list, + pcdb_nchotomy_funs : pmatch_nchotomy_fun list, pcdb_constrFams : (constructorFamily list) TypeNet.typenet, pcdb_ss : simpLib.ssfrag } @@ -129,11 +136,18 @@ sig val pmatch_compile_db_compile_cf : pmatch_compile_db -> (term list * term) list -> constructorFamily option + (* This tries to find an nchotony theorem for the given column. *) + val pmatch_compile_db_compile_nchotomy : pmatch_compile_db -> + (term list * term) list -> thm option (* add a compile fun to a db *) val pmatch_compile_db_add_compile_fun : pmatch_compile_db -> pmatch_compile_fun -> pmatch_compile_db + (* add an nchotomy fun to a db *) + val pmatch_compile_db_add_nchotomy_fun : + pmatch_compile_db -> pmatch_nchotomy_fun -> pmatch_compile_db + (* add a constructorFamily to a db *) val pmatch_compile_db_add_constrFam : pmatch_compile_db -> constructorFamily -> pmatch_compile_db @@ -150,6 +164,10 @@ sig (* add a compile_fun to default db *) val pmatch_compile_db_register_compile_fun : pmatch_compile_fun -> unit + + (* add a nchotomy_fun to default db *) + val pmatch_compile_db_register_nchotomy_fun : pmatch_nchotomy_fun -> unit + (* add a constructor family to default db *) val pmatch_compile_db_register_constrFam : constructorFamily -> unit diff --git a/examples/deep_matches/constrFamiliesLib.sml b/examples/deep_matches/constrFamiliesLib.sml index 4f05783d26..cf019f3677 100644 --- a/examples/deep_matches/constrFamiliesLib.sml +++ b/examples/deep_matches/constrFamiliesLib.sml @@ -495,18 +495,50 @@ end (* extra matching info *) (***************************************************) -type pmatch_compile_fun = (term list * term) list -> (thm * simpLib.ssfrag) option +(* Datatype for representing how well a constructorFamily or + a hand-written function matches a column. *) +type matchcol_stats = { + colstat_missed_rows : int, + (* how many rows of the col are not constructor applications + or bound vars? *) + + colstat_cases : int, + (* how many cases are covered ? *) + + colstat_missed_constr : int + (* how many constructors of the family do not appear in the column *) +} + +fun matchcol_stats_compare + (st1 : matchcol_stats) + (st2 : matchcol_stats) = let + fun lex_ord (i1, i2) b = + (i1 < i2) orelse ((i1 = i2) andalso b) +in + lex_ord (#colstat_missed_rows st1, #colstat_missed_rows st2) ( + lex_ord (#colstat_cases st1, #colstat_cases st2) ( + op> (#colstat_missed_constr st1, #colstat_missed_constr st2) + ) + ) +end + + +type pmatch_compile_fun = (term list * term) list -> (thm * int * simpLib.ssfrag) option + +type pmatch_nchotomy_fun = (term list * term) list -> (thm * int) option val typeConstrFamsDB = ref (TypeNet.empty : constructorFamily TypeNet.typenet) type pmatch_compile_db = { pcdb_compile_funs : pmatch_compile_fun list, + pcdb_nchotomy_funs : pmatch_nchotomy_fun list, pcdb_constrFams : (constructorFamily list) TypeNet.typenet, pcdb_ss : simpLib.ssfrag } val empty : pmatch_compile_db = { pcdb_compile_funs = [], + pcdb_nchotomy_funs = [], pcdb_constrFams = TypeNet.empty, pcdb_ss = (simpLib.rewrites []) } @@ -527,16 +559,6 @@ in end end handle HOL_ERR _ => NONE -(* Datatype for representing how well a constructorFamily - matches a column. *) -type constructorFamily_col_stats = { - cfcs_missed_rows : int, - (* how many rows of the col are not constructor applications - or bound vars? *) - - cfcs_missed_constr : int - (* how many constructors of the family do not appear in the column *) -} fun measure_constructorFamily (cf : constructorFamily) col = let fun list_count p col = @@ -563,23 +585,18 @@ fun measure_constructorFamily (cf : constructorFamily) col = let same_const f c end handle HOL_ERR _ => false) col) -in + val cases_no = List.length (#cl_constructors (#constructors cf)) + val cases_no' = if (#cl_is_exhaustive (#constructors cf)) then cases_no else (cases_no+1) +in { - cfcs_missed_rows = list_count row_is_missed col, - cfcs_missed_constr = list_count constr_is_missed crs + colstat_missed_rows = list_count row_is_missed col, + colstat_missed_constr = list_count constr_is_missed crs, + colstat_cases = cases_no' } end -fun constructorFamily_col_stats_compare - (st1:constructorFamily_col_stats) - (st2 : constructorFamily_col_stats) = - - (#cfcs_missed_rows st1 < #cfcs_missed_rows st2) orelse - ( (#cfcs_missed_rows st1 = #cfcs_missed_rows st2) andalso - (#cfcs_missed_constr st1 < #cfcs_missed_constr st2) ) - -fun lookup_constructorFamilies (db : pmatch_compile_db) col = let +fun lookup_constructorFamilies force_exh (db : pmatch_compile_db) col = let val _ = if (List.null col) then (failwith "constructorFamiliesLib" "lookup_constructorFamilies: null col") else () val ty = type_of (snd (hd col)) @@ -606,44 +623,83 @@ fun lookup_constructorFamilies (db : pmatch_compile_db) col = let end val cts_fams' = List.filter (fn cf => not (is_old_fam cf)) cts_fams + + val cts_fams' = if not force_exh then + cts_fams' + else + List.filter (fn (_, cf) => isSome (#nchotomy_thm cf)) cts_fams + val weighted_fams = List.map (fn (ty, cf) => ((ty, cf), measure_constructorFamily cf col)) cts_fams' val weighted_fams_sorted = sort (fn (_, w1) => fn (_, w2) => - constructorFamily_col_stats_compare w1 w2) weighted_fams + matchcol_stats_compare w1 w2) weighted_fams in case weighted_fams_sorted of - [] => NONE - | (cs, _)::_ => SOME cs + [] => NONE + | wcf::_ => SOME wcf end; -fun pmatch_compile_db_compile db col = ( - if (List.null col) then failwith "pmatch_compile_db_compile" "col 0" else - case (get_first (fn f => f col handle HOL_ERR _ => NONE) (#pcdb_compile_funs db)) of - SOME r => SOME r | NONE => ( - case lookup_constructorFamilies db col of - NONE => NONE | SOME (ty, cf) => ( - let +fun pmatch_compile_db_compile_aux db col = ( + if (List.null col) then failwith "pmatch_compile_db_compile" "col 0" else let + val fun_res = get_first (fn f => f col handle HOL_ERR _ => NONE) (#pcdb_compile_funs db) + val cf_res = lookup_constructorFamilies false db col + + fun process_cf_res (ty, cf) w = let val ty_s = match_type ty (type_of (snd (hd col))) val thm = constructorFamily_get_case_split cf val thm' = INST_TYPE ty_s thm in - SOME (thm', merge_ss [(#pcdb_ss db), simpLib.rewrites [ + (thm',#colstat_cases w, merge_ss [(#pcdb_ss db), simpLib.rewrites [ (constructorFamily_get_rewrites cf)]]) end - ))); + in case (fun_res, cf_res) of + (NONE, NONE) => (NONE, NONE) + | (NONE, SOME (tycf, w)) => (SOME (process_cf_res tycf w), SOME tycf) + | (SOME (thm, c_no, ss), NONE) => (SOME (thm, c_no, ss), NONE) + | (SOME (thm, c_no, ss), SOME (tycf, w)) => if (c_no < #colstat_cases w) then + (SOME (thm, c_no, ss), NONE) else (SOME (process_cf_res tycf w), SOME tycf) + end +); + +fun pmatch_compile_db_compile db col = ( + fst (pmatch_compile_db_compile_aux db col)) fun pmatch_compile_db_compile_cf db col = ( + case (snd (pmatch_compile_db_compile_aux db col)) of + NONE => NONE + | SOME (_, cf) => SOME cf +) + +(* +fun pmatch_compile_db_compile_nchotomy db col = ( if (List.null col) then failwith "pmatch_compile_db_compile_cf" "col 0" else - case (get_first (fn f => f col handle HOL_ERR _ => NONE) (#pcdb_compile_funs db)) of - SOME r => NONE | NONE => ( - case (lookup_constructorFamilies db col) of + case (get_first (fn f => f col handle HOL_ERR _ => NONE) (#pcdb_nchotomy_funs db)) of + SOME r => r | NONE => ( + case (lookup_constructorFamilies true db col) of NONE => NONE - | SOME (_, cf) => SOME cf)) + | SOME (_, cf) => #nchotomy_thm cf)) +*) + +fun pmatch_compile_db_compile_nchotomy db col = ( + if (List.null col) then failwith "pmatch_compile_db_compile_nchotomy" "col 0" else let + val fun_res = get_first (fn f => f col handle HOL_ERR _ => NONE) (#pcdb_nchotomy_funs db) + val cf_res = lookup_constructorFamilies true db col + + fun process_cf_res (_, cf) = #nchotomy_thm cf + in case (fun_res, cf_res) of + (NONE, NONE) => NONE + | (NONE, SOME (tycf, _)) => process_cf_res tycf + | (SOME (thm, _), NONE) => SOME thm + | (SOME (thm, _), SOME (tycf, w)) => if (0 < #colstat_missed_rows w) then + (SOME thm) else (process_cf_res tycf) + end +); fun pmatch_compile_db_add_ssfrag (db : pmatch_compile_db) ss = { pcdb_compile_funs = #pcdb_compile_funs db, + pcdb_nchotomy_funs = #pcdb_nchotomy_funs db, pcdb_constrFams = #pcdb_constrFams db, pcdb_ss = (simpLib.merge_ss [ss, #pcdb_ss db]) } : pmatch_compile_db @@ -659,6 +715,7 @@ fun pmatch_compile_db_register_congs thms = fun pmatch_compile_db_add_compile_fun (db : pmatch_compile_db) cf = { pcdb_compile_funs = cf::(#pcdb_compile_funs db), + pcdb_nchotomy_funs = #pcdb_nchotomy_funs db, pcdb_constrFams = #pcdb_constrFams db, pcdb_ss = #pcdb_ss db } : pmatch_compile_db @@ -666,8 +723,19 @@ fun pmatch_compile_db_add_compile_fun (db : pmatch_compile_db) cf = { fun pmatch_compile_db_register_compile_fun cf = thePmatchCompileDB := pmatch_compile_db_add_compile_fun (!thePmatchCompileDB) cf +fun pmatch_compile_db_add_nchotomy_fun (db : pmatch_compile_db) cf = { + pcdb_compile_funs = #pcdb_compile_funs db, + pcdb_nchotomy_funs = cf::(#pcdb_nchotomy_funs db), + pcdb_constrFams = #pcdb_constrFams db, + pcdb_ss = #pcdb_ss db +} : pmatch_compile_db + +fun pmatch_compile_db_register_nchotomy_fun f = + thePmatchCompileDB := pmatch_compile_db_add_nchotomy_fun (!thePmatchCompileDB) f + fun pmatch_compile_db_add_constrFam (db : pmatch_compile_db) cf = { pcdb_compile_funs = #pcdb_compile_funs db, + pcdb_nchotomy_funs = #pcdb_nchotomy_funs db, pcdb_constrFams = let val cl = (#constructors cf) val ty = normalise_ty (#cl_type cl) @@ -685,6 +753,7 @@ fun pmatch_compile_db_register_constrFam cf = fun pmatch_compile_db_remove_type (db : pmatch_compile_db) ty = { pcdb_compile_funs = #pcdb_compile_funs db, + pcdb_nchotomy_funs = #pcdb_nchotomy_funs db, pcdb_constrFams = let val ty = normalise_ty ty val net = #pcdb_constrFams db @@ -720,6 +789,7 @@ fun literals_compile_fun (col:(term list * term) list) = let val ts = List.foldl extract_literal empty_tmset col val lits = HOLset.listItems ts + val cases_no = List.length lits + 1 val _ = if (List.null lits) then (failwith "" "no lits") else () val rty = gen_tyvar () @@ -744,9 +814,56 @@ fun literals_compile_fun (col:(term list * term) list) = let val thm0 = mk_expand_thm lits val thm1 = GEN split_fun (GEN split_arg thm0) in - SOME (thm1, simpLib.rewrites [Cong boolTheory.COND_CONG]) + SOME (thm1, cases_no, simpLib.rewrites [Cong boolTheory.COND_CONG]) end val _ = pmatch_compile_db_register_compile_fun literals_compile_fun + +(***************************************************) +(* nchotomy funs *) +(***************************************************) + +fun literals_nchotomy_fun (col:(term list * term) list) = let + fun extract_literal ((vs, c), ts) = let + val vars = FVL [c] empty_tmset + val is_lit = not (List.exists (fn v => HOLset.member (vars, v)) vs) + in + if is_lit then HOLset.add(ts,c) else + (if is_var c then ts else failwith "" "extract_literal") + end + + val ts = List.foldl extract_literal empty_tmset col + val lits = HOLset.listItems ts + val cases_no = List.length lits + 1 + val _ = if (List.null lits) then (failwith "" "no lits") else () + + val lit_ty = type_of (snd (List.hd col)) + val split_arg = mk_var ("x", lit_ty) + val wc_arg = mk_var ("y", lit_ty) + + val lit_tms = List.map (fn l => mk_eq (split_arg, l)) lits + val wc_tm = let + val not_tms = + List.map (fn l => mk_neg (mk_eq (wc_arg, l))) lits + val eq_tm = mk_eq (split_arg, wc_arg) + val b_tm = mk_conj (eq_tm, list_mk_conj not_tms) + in + mk_exists (wc_arg, b_tm) + end + + val nchot_tm = list_mk_disj (lit_tms @ [wc_tm]) + val nchot_thm = prove(nchot_tm, + SIMP_TAC std_ss [] THEN + EVERY (List.map (fn t => + (BOOL_CASES_TAC t THEN REWRITE_TAC[])) lit_tms)) + val nchot_thm' = GEN split_arg nchot_thm +in + SOME (nchot_thm', cases_no) +end handle HOL_ERR _ => NONE + +val _ = pmatch_compile_db_register_nchotomy_fun literals_nchotomy_fun + + + end diff --git a/examples/deep_matches/deepMatchesExamples.sml b/examples/deep_matches/deepMatchesExamples.sml index 70bf7b20f6..cd4622510f 100644 --- a/examples/deep_matches/deepMatchesExamples.sml +++ b/examples/deep_matches/deepMatchesExamples.sml @@ -18,7 +18,6 @@ val t''' = case2pmatch false t val thm_t = PMATCH_INTRO_CONV t (* check that SIMP works *) -val thm_t' = PMATCH_REMOVE_ARB_CONV t''' val thm_t' = PMATCH_SIMP_CONV t''' val t2' = rhs (concl thm_t') @@ -594,3 +593,50 @@ Q.PAT_ASSUM `x INSERT t = _` (K ALL_TAC) THEN ASM_SIMP_TAC std_ss [CARD_INSERT]) + + + +(*********************************) +(* Fancy redundancy removal *) +(*********************************) + +val t = ``CASE (x, z) OF [ + ||. (NONE, NONE) ~> 0; + ||. (SOME _, _) ~> 1; + ||. (_, NONE) ~> 2 +]`` + +(* The last row is redundant, but it needs both first + rows to show this. Therefore, the fast test, + which only considers single rows, fails. *) + +val _ = PMATCH_REMOVE_FAST_REDUNDANT_CONV t +val thm = PMATCH_SIMP_CONV t + +(* but the full tests catch it *) +val thm = PMATCH_REMOVE_REDUNDANT_CONV t + + +(* Let's consider something more fancy *) + +val t = ``CASE x OF [ + || x. x when EVEN x ~> "EVEN"; + ||. 2 ~> "2"; + || x. x when ODD x ~> "ODD"; + ||. _ ~> "???" + ]`` + +(* Here both the fast and full test catch + only the 2nd row. *) +val thm = PMATCH_REMOVE_FAST_REDUNDANT_CONV t +val thm = PMATCH_REMOVE_REDUNDANT_CONV t + +(* So let's prove the redundancy of the 4th row + with some manual help *) + +val info_thm = COMPUTE_REDUNDANT_ROWS_INFO_OF_PMATCH t +val info_thm' = IS_REDUNDANT_ROWS_INFO_SHOW_ROW_IS_REDUNDANT info_thm 3 ( + SIMP_TAC std_ss [LEFT_FORALL_IMP_THM] THEN + METIS_TAC [arithmeticTheory.EVEN_OR_ODD] +) + diff --git a/examples/deep_matches/deepMatchesLib.sig b/examples/deep_matches/deepMatchesLib.sig index 375e51456f..6f5f931214 100644 --- a/examples/deep_matches/deepMatchesLib.sig +++ b/examples/deep_matches/deepMatchesLib.sig @@ -66,8 +66,8 @@ sig (* PMATCH_SIMP_CONV consists of various component conversions. These can be used independently as well. *) - val PMATCH_REMOVE_REDUNDANT_CONV : conv - val PMATCH_REMOVE_REDUNDANT_CONV_GEN : ssfrag list -> conv + val PMATCH_REMOVE_FAST_REDUNDANT_CONV : conv + val PMATCH_REMOVE_FAST_REDUNDANT_CONV_GEN : ssfrag list -> conv val PMATCH_REMOVE_SUBSUMED_CONV : bool -> conv val PMATCH_REMOVE_SUBSUMED_CONV_GEN : bool -> ssfrag list -> conv @@ -188,6 +188,7 @@ sig that often works. No specific properties guarenteed. *) val colHeu_default : column_heuristic + (*-------------*) (* COMPILATION *) (*-------------*) @@ -223,4 +224,51 @@ sig (* lets choose at least the heuristic *) val PMATCH_CASE_SPLIT_HEU_ss : column_heuristic -> ssfrag + + (* Pattern compilation builds for a list of patterns, implicitly + a nchotomy theorem, i.e. a list of patterns that cover all the + original ones and are exhaustive. Moreover these patterns useually + have some nice properties like e.g. not overlapping with each other. + Such a nchotomy theorem is often handy. We use it to check for + exhaustiveness for example. The interface is exponsed here as well. *) + + (* [nchotomy_of_pats_GEN db colHeu pats] computes an nchotomy-theorem + for a list of patterns. A pattern is written as for PMATCH, i.e. in the form ``\(v1, ..., vn). p v1 ... vn``. *) + val nchotomy_of_pats_GEN : constrFamiliesLib.pmatch_compile_db -> column_heuristic -> term list -> thm + val nchotomy_of_pats : term list -> thm + + + (*-----------------------*) + (* Remove redundant rows *) + (*-----------------------*) + + (* fancy, slow conversion for decting and removing + redundant rows. Internally this uses [nchotomy_of_pats] and + therefore requires a pmatch-compile db and a column-heuristic. *) + val PMATCH_REMOVE_REDUNDANT_CONV_GEN : + constrFamiliesLib.pmatch_compile_db -> column_heuristic -> ssfrag list -> conv + val PMATCH_REMOVE_REDUNDANT_CONV : conv + + val PMATCH_REMOVE_REDUNDANT_GEN_ss : + constrFamiliesLib.pmatch_compile_db -> column_heuristic -> ssfrag list -> ssfrag + val PMATCH_REMOVE_REDUNDANT_ss : unit -> ssfrag + + + (* The redundancy removal conversion works by + first creating a is-redundant-rows-info theorem and + then turning it into a PMATCH equation. One can + separate these steps, this allows using interactive proofs + for showing that a row is redundant. *) + val COMPUTE_REDUNDANT_ROWS_INFO_OF_PMATCH_GEN : + ssfrag list -> constrFamiliesLib.pmatch_compile_db -> column_heuristic -> term -> thm + val COMPUTE_REDUNDANT_ROWS_INFO_OF_PMATCH : term -> thm + val IS_REDUNDANT_ROWS_INFO_TO_PMATCH_EQ_THM : thm -> thm + + + (* prove redundancy of given row given an info-thm *) + val IS_REDUNDANT_ROWS_INFO_SHOW_ROW_IS_REDUNDANT : + thm -> int -> tactic -> thm + val IS_REDUNDANT_ROWS_INFO_SHOW_ROW_IS_REDUNDANT_set_goal : + thm -> int -> Manager.proof + end diff --git a/examples/deep_matches/deepMatchesLib.sml b/examples/deep_matches/deepMatchesLib.sml index 8146f4c750..e1234a0bd6 100644 --- a/examples/deep_matches/deepMatchesLib.sml +++ b/examples/deep_matches/deepMatchesLib.sml @@ -25,12 +25,6 @@ fun make_gen_conv_ss c name ssl = let initial=genconv_reducer_exn}) end; - -fun has_subterm p t = ((find_term p t; true) handle HOL_ERR _ => false) - -(* like proof, but less verbose, since we expect that it might fail *) -val prove_attempt = Lib.with_flag (Feedback.emit_MESG, false) prove - (* We have a problem with conversions that loop in a fancy way. They add some pattern matching on the input variables and in the body the original term with renamed variables. The @@ -129,6 +123,7 @@ val static_ss = simpLib.merge_ss pairTheory.FORALL_PROD, PMATCH_ROW_EQ_NONE, PMATCH_ROW_COND_def, + PMATCH_ROW_COND_EX_def, PAIR_EQ_COLLAPSE, oneTheory.one]]; @@ -138,10 +133,12 @@ fun callback_CONV cb_opt t = (case cb_opt of NONE => NO_CONV t | SOME cb => cb t) -fun rc_conv (gl, callback_opt) = REPEATC ( - SIMP_CONV (rc_ss gl) [] THENC +fun rc_conv_rws (gl, callback_opt) thms = REPEATC ( + SIMP_CONV (rc_ss gl) thms THENC TRY_CONV (callback_CONV callback_opt)) +fun rc_conv rc_arg = rc_conv_rws rc_arg [] + fun rc_tac (gl, callback_opt) = CONV_TAC (rc_conv (gl, callback_opt)) @@ -506,7 +503,7 @@ in end -fun PMATCH_REMOVE_REDUNDANT_CONV_GENCALL_SINGLE rc_arg t = let +fun PMATCH_REMOVE_FAST_REDUNDANT_CONV_GENCALL_SINGLE rc_arg t = let val (v, rows) = dest_PMATCH t val candidates = compute_row_pat_pairs rows @@ -553,9 +550,9 @@ in Lib.tryfind try_pair cands end handle HOL_ERR _ => raise UNCHANGED -fun PMATCH_REMOVE_REDUNDANT_CONV_GENCALL rc_arg = REPEATC (PMATCH_REMOVE_REDUNDANT_CONV_GENCALL_SINGLE rc_arg) -fun PMATCH_REMOVE_REDUNDANT_CONV_GEN ssl = PMATCH_REMOVE_REDUNDANT_CONV_GENCALL (ssl, NONE) -val PMATCH_REMOVE_REDUNDANT_CONV = PMATCH_REMOVE_REDUNDANT_CONV_GEN [] +fun PMATCH_REMOVE_FAST_REDUNDANT_CONV_GENCALL rc_arg = REPEATC (PMATCH_REMOVE_FAST_REDUNDANT_CONV_GENCALL_SINGLE rc_arg) +fun PMATCH_REMOVE_FAST_REDUNDANT_CONV_GEN ssl = PMATCH_REMOVE_FAST_REDUNDANT_CONV_GENCALL (ssl, NONE) +val PMATCH_REMOVE_FAST_REDUNDANT_CONV = PMATCH_REMOVE_FAST_REDUNDANT_CONV_GEN [] (***********************************************) @@ -1401,7 +1398,7 @@ fun PMATCH_SIMP_CONV_GENCALL_AUX rc_arg = REPEATC (FIRST_CONV [ CHANGED_CONV (PMATCH_CLEANUP_PVARS_CONV), CHANGED_CONV (PMATCH_CLEANUP_CONV_GENCALL rc_arg), - CHANGED_CONV (PMATCH_REMOVE_REDUNDANT_CONV_GENCALL rc_arg), + CHANGED_CONV (PMATCH_REMOVE_FAST_REDUNDANT_CONV_GENCALL rc_arg), CHANGED_CONV (PMATCH_REMOVE_SUBSUMED_CONV_GENCALL true rc_arg), CHANGED_CONV (PMATCH_SIMP_COLS_CONV_GENCALL rc_arg), CHANGED_CONV (PMATCH_EXPAND_COLS_CONV), @@ -1788,8 +1785,7 @@ fun PMATCH_TO_TOP_RULE thm = PMATCH_TO_TOP_RULE_GEN [] thm; (***********************************************) -(* Case_splits *) -(* This is work in progress *) +(* PATTERN COMPILATION *) (***********************************************) type column_heuristic = @@ -1914,10 +1910,6 @@ val t = ``CASE (a,x,xs) OF [ ]`` *) -fun STRIP_ABS_CONV conv t = - if (is_abs t) then ABS_CONV (STRIP_ABS_CONV conv) t else - conv t - fun PMATCH_CASE_SPLIT_AUX rc_arg col_no expand_thm t = let val (v, rows) = dest_PMATCH t val vs = pairSyntax.strip_pair v @@ -1951,7 +1943,7 @@ val t = t' val col_no = 1 val rc_arg = ([], NONE) val db = !thePmatchCompileDB -fun col_heu _ = 0 +val col_heu = colHeu_default *) fun PMATCH_CASE_SPLIT_CONV_GENCALL_STEP (gl, callback_opt) db col_heu t = let @@ -1963,7 +1955,7 @@ fun PMATCH_CASE_SPLIT_CONV_GENCALL_STEP (gl, callback_opt) db col_heu t = let val res = pmatch_compile_db_compile db col in case res of - SOME (expand_thm, expand_ss) => (col_no, expand_thm, expand_ss) + SOME (expand_thm, _, expand_ss) => (col_no, expand_thm, expand_ss) | NONE => let val cols' = List.take (cols, col_no) @ List.drop (cols, col_no+1) val (col_no', expand_thm, expand_ss) = find_col cols' @@ -2062,4 +2054,660 @@ fun PMATCH_CASE_SPLIT_HEU_ss col_heu = fun PMATCH_CASE_SPLIT_ss () = PMATCH_CASE_SPLIT_HEU_ss colHeu_default + +(***********************************************) +(* COMPUTE CASE-DISTINCTION based on pats *) +(***********************************************) + +(* +val t = `` + CASE (a,x,xs) OF [ + ||. (NONE,_,[]) ~> 0; + || x. (NONE,x,[]) when x < 10 ~> x; + || x. (NONE,x,[2]) ~> x; + ||! (NONE,x,[v18]) ~> 3; + ||! (NONE,_,[_;_]) ~> x; + || (x,v12,v16,v17). (NONE,x,v12::v16::v17) ~> 3; + || (y,x,z,zs). (SOME y,x,[z]) ~> x + 5 + z; + || (y,v23,v24). (SOME y,0,v23::v24) ~> (v23 + y); + || (y,z,v23). (SOME y,SUC z,[v23]) when y > 5 ~> 3; + || (y,z). (SOME y,SUC z,[1; 2]) ~> y + z + ]``; + + val (v, rows) = dest_PMATCH t + val pats = List.map (#1 o dest_PMATCH_ROW) rows + + val col_heu = colHeu_default + val db = !thePmatchCompileDB + + val pats = [``\(x:num). 2``] + val pats = [``\(x:num). [2;3;4]``] + +*) + +local + + val case_dist_exists_thm = prove (``!Q. ( + (!(x:'a). Q x) ==> + !P. (?x. P x) = (?x. Q x /\ P x))``, + SIMP_TAC std_ss []); + + val label_over_or_thm = prove ( + ``(lbl :- (t1 \/ t2)) <=> (lbl :- t1) \/ (lbl :- t2)``, + REWRITE_TAC[markerTheory.label_def]); + + fun find_nchotomy_for_cols db col_heu cols = let + val _ = if (List.null cols) then + raise failwith "compile failed" else () + val col_no = col_heu cols + val (v, col) = el (col_no+1) cols + val nchot_thm_opt = pmatch_compile_db_compile_nchotomy db col + in + case nchot_thm_opt of + SOME nchot_thm => (v, ISPEC v nchot_thm) + | NONE => let + val cols' = List.take (cols, col_no) @ List.drop (cols, col_no+1) + in + find_nchotomy_for_cols db col_heu cols' + end + end + + + fun mk_initial_state var_gen lbl_gen pats = let + val (_, p) = pairSyntax.dest_pabs (hd pats) + val cs = pairLib.strip_pair p + val vs = List.map (fn p => var_gen (type_of p)) cs + val initial_value = pairLib.list_mk_pair vs + val cols = dest_PATLIST_COLS initial_value pats + + val lbl = lbl_gen () + val initial_thm = let + val x_tm = mk_var ("x", type_of initial_value) + val tm = mk_forall (x_tm, markerSyntax.mk_label (lbl, list_mk_exists (vs, mk_eq (x_tm, initial_value)))) + val thm = prove (tm, + SIMP_TAC std_ss [pairTheory.FORALL_PROD, markerTheory.label_def]) + in thm end + in + (initial_thm, cols, lbl) + end + + + fun compute_cases_info var_gen lbl_gen v nthm = let + val disjuncts = ref ([] : (string * term * term list) list) + + (* val d = el 2 ds *) + fun process_disj d = let + val lbl = lbl_gen () + + (* intro fresh vars *) + val d_thm = let + val (evs, d_b) = strip_exists d + val s = List.map (fn v => (v |-> var_gen (type_of v))) evs + val evs = List.map (Term.subst s) evs + val d_b = Term.subst s d_b + val d' = list_mk_exists (evs, d_b) + val d_thm = ALPHA d d' + in + d_thm + end + + (* add label *) + val ld_thm = RIGHT_CONV_RULE (add_labels_CONV [lbl]) d_thm + + + (* figure out constructor and free variables and add them + to list of disjuncts *) + val _ = let + val d' = rhs (concl d_thm) + val (evs, b) = strip_exists d' + val b_conjs = strip_conj b + val main_conj = first (fn c' => + aconv (lhs c') v handle HOL_ERR _ => false) b_conjs + val r = rhs main_conj + val (c, _) = strip_comb_bounded (List.length evs) r + val _ = disjuncts := (lbl, c, evs) :: !disjuncts + in () end handle HOL_ERR _ => () + in + ld_thm + end handle HOL_ERR _ => raise UNCHANGED + + (* val ds = strip_disj (concl nthm) *) + val nthm' = CONV_RULE (ALL_DISJ_CONV process_disj) nthm + in + (nthm', List.rev (!disjuncts)) + end + + fun exists_left_and_label_CONV t = let + val (lbls_left, _) = (strip_labels o fst o dest_conj o snd o dest_exists) t + val (lbls_right, _) = (strip_labels o snd o dest_conj o snd o dest_exists) t + + val c_remove = QUANT_CONV (BINOP_CONV (REPEATC markerLib.DEST_LABEL_CONV)) + + val thm0 = (c_remove THENC (add_labels_CONV (lbls_left @ lbls_right))) t + in + thm0 + end + + fun expand_disjunction_CONV v nthm_expand d_tm = let + val thm00 = RESORT_EXISTS_CONV (fn vs => + let val (v', vs') = pick_element (aconv v) vs in + (v'::vs') end) d_tm + + val thm01a = HO_PART_MATCH (lhs o snd o strip_forall) nthm_expand (rhs (concl thm00)) + val thm01 = TRANS thm00 thm01a + + val thm02 = RIGHT_CONV_RULE (PURE_REWRITE_CONV [RIGHT_AND_OVER_OR]) thm01 + val thm03 = RIGHT_CONV_RULE (DECEND_CONV BINOP_CONV (TRY_CONV EXISTS_OR_CONV)) thm02 + + val thm04 = RIGHT_CONV_RULE (ALL_DISJ_CONV exists_left_and_label_CONV) thm03 + + val LEFT_RIGHT_AND_LIST_EXISTS_CONV = (DECEND_CONV QUANT_CONV ((RIGHT_AND_EXISTS_CONV ORELSEC LEFT_AND_EXISTS_CONV))) + val thm05 = RIGHT_CONV_RULE (ALL_DISJ_CONV (strip_labels_CONV (STRIP_QUANT_CONV LEFT_RIGHT_AND_LIST_EXISTS_CONV))) thm04 + val thm06 = RIGHT_CONV_RULE (ALL_DISJ_CONV (strip_labels_CONV (Unwind.UNWIND_EXISTS_CONV))) thm05 + in + thm06 + end + + fun expand_cases_in_thm lbl (v, nthm') thm = let + val nthm_expand = HO_MATCH_MP case_dist_exists_thm (GEN v nthm') + + val thm01 = CONV_RULE (QUANT_CONV (ALL_DISJ_CONV ( + guarded_strip_labels_CONV [lbl] ( + (expand_disjunction_CONV v nthm_expand))))) thm + + val thm02 = CONV_RULE (PURE_REWRITE_CONV [label_over_or_thm, GSYM DISJ_ASSOC]) thm01 + + in + thm02 + end handle HOL_ERR _ => thm + + + fun get_columns_for_constructor current_col (c, evs) cols' = let + fun process_current_col (cs : (term list * term) list list, kl : bool list) ps = case ps of + [] => (List.map List.rev cs, List.rev kl) + | (vs, p)::ps' => let + val (cs', kl') = + if (Term.is_var p) andalso List.exists (aconv p) vs then + (Lib.map2 (fn v => fn l => ([v], v)::l) evs cs, + true::kl) + else let + val (c', args) = strip_comb_bounded (List.length evs) p + in + if not (aconv c c') then (cs, false::kl) else + (Lib.map2 (fn a => fn l => (vs, a)::l) args cs, + true::kl) + end + in process_current_col (cs', kl') ps' end + + val ps = (snd current_col) + val (cs, kl) = process_current_col (List.map (K []) evs, []) ps + val cols1 = zip evs cs + + val cols2 = List.map (fn (v, rs) => + (v, List.map snd (Lib.filter fst (zip kl rs)))) cols' + + val cols'' = cols1 @ cols2 + + (* remove cols consisting of only vars *) + val cols''' = filter (fn (_, ps) => not (List.all (fn (vs, p) => is_var p andalso List.exists (aconv p) vs) ps)) cols'' + in + cols''' + end + + + (* extract the column for variable v from the list of columns *) + fun pick_current_column v cols = + pick_element (fn (v', _) => aconv v v') cols + +in (* in of local *) + + fun nchotomy_of_pats_GEN db col_heu pats = let + val var_gen = mk_var_gen "v" [] + val lbl_gen = mk_new_label_gen "case_" + + (* + val (thm, cols, lbl) = mk_initial_state var_gen lbl_gen pats + val (thm, cols, lbl) = (thm1, cols'', lbl) + val xxx = !args + val (thm, cols, lbl) = el 3 xxx +*) + + val args = ref [] + fun compile (thm, cols, lbl) = let + val _ = args := (thm, cols, lbl) :: (!args) + val (v, nthm) = find_nchotomy_for_cols db col_heu cols + val (current_col, cols_rest) = pick_current_column v cols + val (nthm', cases_info) = compute_cases_info var_gen lbl_gen v nthm + + (* Expand all labeled with [lbl] cases *) + val thm1 = expand_cases_in_thm lbl (v, nthm') thm + + (* Call recursively *) + val thm2 = let +(* val ((lbl, c, evs), current_thm) = ((el 2 cases_info, thm1)) *) + fun process_case ((lbl, c, evs), current_thm) = let + val cols' = get_columns_for_constructor current_col (c, evs) cols_rest + in + compile (current_thm, cols', lbl) + end + in + List.foldl process_case thm1 cases_info + end + in + thm2 + end handle HOL_ERR _ => thm + + (* compile it *) + val thm3 = compile (mk_initial_state var_gen lbl_gen pats) + + (* get rid of labels *) + val thm4 = CONV_RULE markerLib.DEST_LABELS_CONV thm3 + in + thm4 + end + + fun nchotomy_of_pats pats = + nchotomy_of_pats_GEN (!thePmatchCompileDB) colHeu_default pats + +end + + +(********************************************) +(* Prune disjunctions of PMATCH_ROW_COND_EX *) +(********************************************) + +(* Given a list of disjunctions of PMATCH_ROW_COND_EX and + a theorem stating that a certain PMATCH_ROW_COND_EX does not + hold, prune the disjunction by removing all patterns + covered by the one we know does not hold. *) + + +fun PMATCH_ROW_COND_EX_ELIM_FALSE_GUARD_CONV tt = let + val (_, _, g) = dest_PMATCH_ROW_COND_EX tt + val (_, g_b) = pairLib.dest_pabs g + val _ = if (aconv g_b F) then () else raise UNCHANGED + + val thm00 = PART_MATCH (lhs o rand) PMATCH_ROW_COND_EX_FALSE tt + val pre = (rand o rator o concl) thm00 + (* set_goal ([], pre) *) + val pre_thm = prove (pre, + SIMP_TAC (std_ss++pairSimps.gen_beta_ss) [pairTheory.FORALL_PROD] + ) + val thm01 = MP thm00 pre_thm +in + thm01 +end handle HOL_ERR _ => raise UNCHANGED + + +(* +val t = `` + CASE (x,y,z) OF [ + ||. (NONE,_,[]) ~> 0; + || x. (NONE,x,[]) when x < 10 ~> x; + || x. (NONE,x,[2]) ~> x; + || (x, v18). (NONE,x,[v18]) ~> 3; + ||. (NONE,_,[_;_]) ~> 4; + || (x,v12,v16,v17). (NONE,x,v12::v16::v17) ~> 3; + || (y,x,z,zs). (SOME y,x,[z]) ~> x + 5 + z; + || (y,v23,v24). (SOME y,0,v23::v24) ~> (v23 + y); + || (y,z,v23). (SOME y,SUC z,[v23]) when y > 5 ~> 3; + || (y,z). (SOME y,SUC z,[1; 2]) ~> y + z + ]``; + + val (v, rows) = dest_PMATCH t + val pats = List.map (#1 o dest_PMATCH_ROW) rows + + +val thm = CONV_RULE (nchotomy2PMATCH_ROW_COND_EX_CONV) (nchotomy_of_pats pats) + +val cs = (strip_disj o concl o SPEC v) thm + +val t = (concl o SPEC v) thm + +val row_cs = List.map (mk_PMATCH_ROW_COND_EX_ROW v) rows + +val weaken_ce = el 4 row_cs +val weaken_thm = ASSUME (mk_neg weaken_ce) +val ce = el 4 cs + +val rc_arg = ([], NONE) +*) + +(* apply thm PMATCH_ROW_COND_EX_WEAKEN *) +fun PMATCH_ROW_COND_EX_WEAKEN_CONV_GENCALL rc_arg (weaken_thm, v_w, p_w', vars_w') ce = let + val (v, p_t, _) = dest_PMATCH_ROW_COND_EX ce + val (vars, p) = pairLib.dest_pabs p_t + val _ = if (aconv v v_w) then () else raise UNCHANGED + + (* try to match *) + val s = let + val (s_tm, s_ty) = Term.match_term p_w' p + val _ = if List.null s_ty then () else failwith "bound too much" + val vars_w'_l = pairSyntax.strip_pair vars_w' + val _ = if List.exists (fn s => not (List.exists + (aconv (#redex s)) vars_w'_l)) s_tm then + failwith "bound too much" else () + in s_tm end + + (* construct f *) + val f_tm = pairSyntax.mk_pabs (vars, subst s vars_w') + + (* instantiate the thm *) + val thm0 = let + val thm00 = FRESH_TY_VARS_RULE PMATCH_ROW_COND_EX_WEAKEN + val thm01 = MATCH_MP thm00 weaken_thm + val thm02 = ISPEC f_tm thm01 + val thm03 = PART_MATCH (lhs o rand) thm02 ce + val thm04 = rc_elim_precond rc_arg thm03 + in + thm04 + end + + (* Simplify guard *) + val thm1 = let + val c = TRY_CONV (rc_conv rc_arg) THENC + pairTools.PABS_INTRO_CONV vars + in + RIGHT_CONV_RULE (RAND_CONV c) thm0 + end + + (* elim false *) + val thm2 = RIGHT_CONV_RULE + PMATCH_ROW_COND_EX_ELIM_FALSE_GUARD_CONV thm1 + handle HOL_ERR _ => thm1 +in + thm2 +end handle HOL_ERR _ => raise UNCHANGED + + +fun PMATCH_ROW_COND_EX_DISJ_WEAKEN_CONV_GENCALL rc_arg weaken_thm t = let + val (v_w, p_tw, _) = + dest_PMATCH_ROW_COND_EX (dest_neg (concl weaken_thm)) + val (vars_w, p_w) = pairLib.dest_pabs p_tw + + (* get fresh vars in p_w before matching *) + val (p_w', vars_w') = let + val vars'_l = pairSyntax.strip_pair vars_w + val s = List.map (fn v => (v |-> genvar (type_of v))) vars'_l + val p_w' = subst s p_w + val vars_w' = subst s vars_w + in + (p_w', vars_w') + end + + val thm0 = ALL_DISJ_CONV (PMATCH_ROW_COND_EX_WEAKEN_CONV_GENCALL rc_arg (weaken_thm, v_w, p_w', vars_w')) t + + + val thm1 = RIGHT_CONV_RULE (PURE_REWRITE_CONV [boolTheory.OR_CLAUSES]) thm0 +in + thm1 +end + + +(*************************************) +(* Compute redundant rows info for a *) +(* PMATCH *) +(*************************************) + +(* val tt = el 3 cjs *) + +fun SIMPLIFY_PMATCH_ROW_COND_EX_IMP_CONV rc_arg tt = let + (* destruct everything *) + val (v, vars', p', g', vars, p, g) = let + val (pre, cl_neg) = dest_imp tt + val (v', p', g') = dest_PMATCH_ROW_COND_EX pre + val (vars', _) = pairSyntax.dest_pabs p' + val cl = dest_neg cl_neg + val (v, p, g) = dest_PMATCH_ROW_COND_EX cl + val _ = if (aconv v v') then () else raise UNCHANGED + val (vars, _) = pairSyntax.dest_pabs p + in + (v, vars', p', g', vars, p, g) + end + + val thm00 = FRESH_TY_VARS_RULE PMATCH_ROW_COND_EX_IMP_REWRITE + val thm01 = ISPECL [v, p', g', p, g] thm00 + + val thm02 = RIGHT_CONV_RULE ( + (QUANT_CONV (RAND_CONV (pairTools.PABS_INTRO_CONV vars))) THENC + (RAND_CONV (pairTools.PABS_INTRO_CONV vars'))) thm01 + val thm03 = RIGHT_CONV_RULE (DEPTH_CONV pairLib.GEN_BETA_CONV) thm02 + val thm04 = RIGHT_CONV_RULE (TRY_CONV (pairTools.ELIM_TUPLED_QUANT_CONV) THENC + TRY_CONV (STRIP_QUANT_CONV (pairTools.ELIM_TUPLED_QUANT_CONV))) thm03 + + fun imp_or_no_imp_CONV c t = + if (is_imp t) then + (RAND_CONV c) t + else c t + + val thm05 = RIGHT_CONV_RULE ( + (STRIP_QUANT_CONV (imp_or_no_imp_CONV (RATOR_CONV (RAND_CONV (SIMP_CONV (rc_ss []) []))))) THENC + REWRITE_CONV[]) thm04 + + val rr = rhs (concl thm05) + val thm06 = if aconv rr T then thm05 else let + val thm_rr = prove_attempt (rr, rc_tac rc_arg) + in + TRANS thm05 (EQT_INTRO thm_rr) + end handle HOL_ERR _ => thm05 +in + thm06 +end + +(* val ttts = strip_disj pre + val ttt = el 1 ttts + val rc_arg = ([], NONE) *) + +fun SIMPLIFY_PMATCH_ROW_COND_EX_IMP_CONV rc_arg cc_thm v ttt = let + + val (v', p, g) = dest_PMATCH_ROW_COND_EX ttt + val _ = if (aconv v v') then () else raise UNCHANGED + + val thm00 = FRESH_TY_VARS_RULE PMATCH_ROW_COND_EX_IMP_REWRITE + val thm01 = MATCH_MP thm00 cc_thm + val thm02 = ISPECL [p, g] thm01 + + val (x, pre, l) = let + val (x, body) = (dest_forall o rand o rator o snd o strip_forall o concl) thm02 + val (pre, body') = dest_imp body + val l = lhs body' + in + (x, pre, l) + end + + val l_thm0 = rc_conv_rws rc_arg [ASSUME pre] l + val r = rhs (concl l_thm0) + val _ = if (aconv r T) orelse (aconv r F) then () else + (* we don't want complicated intermediate results *) + raise UNCHANGED + val l_thm1 = GEN x (DISCH pre l_thm0) + + val thm03 = ISPEC r thm02 + val thm04 = MP thm03 l_thm1 +in + thm04 +end + + +(* val thm = it + val (tts, _) = (listSyntax.dest_list o rand o concl) thm + val tt = el 2 tts *) + +val simple_imp_thm = prove ( ``!X Y X'. ((Y ==> (X = X')) ==> ((X ==> ~Y) = (X' ==> ~Y)))``, +PROVE_TAC[]) + +fun SIMPLIFY_REDUNDANT_ROWS_INFO_AUX rc_arg tt = let + val (pre, cc_neg) = dest_imp tt + val cc = dest_neg cc_neg + + val (v, _, _) = dest_PMATCH_ROW_COND_EX cc + val cc_thm = ASSUME cc + val pre_thm0 = + (ALL_DISJ_TF_ELIM_CONV (SIMPLIFY_PMATCH_ROW_COND_EX_IMP_CONV rc_arg cc_thm v)) pre handle UNCHANGED => REFL pre + val pre_thm = DISCH cc pre_thm0 + + val thm0 = SPECL [pre, cc] simple_imp_thm + val thm1 = MATCH_MP thm0 pre_thm + + val thm2 = RIGHT_CONV_RULE (REWRITE_CONV [] THENC DEPTH_CONV + PMATCH_ROW_COND_EX_ELIM_CONV) thm1 +in + thm2 +end handle HOL_ERR _ => raise UNCHANGED + + +fun COMPUTE_REDUNDANT_ROWS_INFO_OF_PMATCH_GENCALL rc_arg db col_heu t = +let + val (v, rows) = dest_PMATCH t + val rc_arg = case rc_arg of + (sl, cb_opt) => ((#pcdb_ss db)::sl, cb_opt) + + + (* compute initial enchotomy *) + val nchot_thm = let + val pats = List.map (#1 o dest_PMATCH_ROW) rows + val thm01 = nchotomy_of_pats_GEN db col_heu pats + val thm02 = CONV_RULE (nchotomy2PMATCH_ROW_COND_EX_CONV) thm01 + val thm03 = ISPEC v thm02 + in + thm03 + end + + (* get initial info *) + val init_info = let + val row_ty = listSyntax.dest_list_type (type_of (rand t)) + val s_ty = match_type (``:'a -> 'b option``) row_ty + val thm00 = INST_TYPE s_ty IS_REDUNDANT_ROWS_INFO_NIL + val thm01 = SPEC v thm00 + + val nthm = GSYM (EQT_INTRO nchot_thm) + val thm02 = CONV_RULE (RATOR_CONV (RAND_CONV (K nthm))) thm01 + in + thm02 + end + + (* add a row to the info *) + fun add_row (r, info_thm) = let + val (p, g, r) = dest_PMATCH_ROW r + val thm00 = FRESH_TY_VARS_RULE IS_REDUNDANT_ROWS_INFO_SNOC_PMATCH_ROW + val thm01 = MATCH_MP thm00 info_thm + val thm02 = ISPECL [p, g, r] thm01 + + (* simplify the condition we carry around *) + val c'_thm = let + val pthm = ASSUME (mk_neg (mk_PMATCH_ROW_COND_EX (v, p, g))) + val c_tm = (rand o rator o concl) info_thm + val c'_thm0 = PMATCH_ROW_COND_EX_DISJ_WEAKEN_CONV_GENCALL rc_arg pthm c_tm handle UNCHANGED => REFL c_tm + val c'_thm = DISCH (concl pthm) c'_thm0 + in + c'_thm + end + + val thm03 = MATCH_MP thm02 c'_thm + val thm04 = CONV_RULE (RATOR_CONV (RATOR_CONV (RAND_CONV listLib.SNOC_CONV))) thm03 + + val new_cond_CONV = SIMPLIFY_REDUNDANT_ROWS_INFO_AUX rc_arg + val thm05 = CONV_RULE (RAND_CONV (RATOR_CONV (RAND_CONV new_cond_CONV))) thm04 + + val thm06 = CONV_RULE (RAND_CONV (listLib.SNOC_CONV)) thm05 + in + thm06 + end +in + List.foldl add_row init_info rows +end + +fun COMPUTE_REDUNDANT_ROWS_INFO_OF_PMATCH_GEN ss db col_heu = + COMPUTE_REDUNDANT_ROWS_INFO_OF_PMATCH_GENCALL (ss, NONE) db col_heu + +fun COMPUTE_REDUNDANT_ROWS_INFO_OF_PMATCH t = + COMPUTE_REDUNDANT_ROWS_INFO_OF_PMATCH_GENCALL ([], NONE) + (!thePmatchCompileDB) colHeu_default t + + +(* +val t = ``CASE (x, z) OF [ + ||. (NONE, NONE) ~> 0; + ||. (SOME _, _) ~> 1; + ||. (_, SOME _) ~> 2 +]`` + +val t = ``CASE (x, z) OF [ + ||. (NONE, NONE) ~> 0; + ||. (SOME _, _) ~> 1; + ||. (_, NONE) ~> 2 +]`` + +val t = ``CASE (x, z) OF [ + ||. (NONE, 1) ~> 0; + ||. (SOME _, 2) ~> 1; + || x. (_, x) when x > 5 ~> 2 +]`` +*) + +fun IS_REDUNDANT_ROWS_INFO_WEAKEN_RULE info_thm = let + val (conds, _) = listSyntax.dest_list (rand (concl info_thm)) + val conds' = List.map (fn c => if (aconv c T) then T else F) conds + val conds'_tm = listSyntax.mk_list (conds', bool) + + val thm00 = REDUNDANT_ROWS_INFOS_CONJ_THM + val thm01 = MATCH_MP thm00 info_thm + val thm02 = SPECL [F, conds'_tm] thm01 + + val thm03 = let + val pre = rand (rator (concl thm02)) + val pre_thm = prove (pre, SIMP_TAC list_ss []) + in + MP thm02 pre_thm + end + + val thm04 = CONV_RULE (RATOR_CONV (RAND_CONV (REWRITE_CONV []))) thm03 + + val thm05 = CONV_RULE (RAND_CONV (REWRITE_CONV [ + REDUNDANT_ROWS_INFOS_CONJ_REWRITE])) thm04 +in + thm05 +end + +fun IS_REDUNDANT_ROWS_INFO_TO_PMATCH_EQ_THM info_thm = let + val info_thm' = IS_REDUNDANT_ROWS_INFO_WEAKEN_RULE info_thm + val thm0 = MATCH_MP REDUNDANT_ROWS_INFO_TO_PMATCH_EQ info_thm' + val c = PURE_REWRITE_CONV [APPLY_REDUNDANT_ROWS_INFO_THMS] + val thm1 = RIGHT_CONV_RULE (RAND_CONV c) thm0 +in + thm1 +end + + +fun PMATCH_REMOVE_REDUNDANT_CONV_GENCALL db col_heu rc_arg t = let + val info_thm = COMPUTE_REDUNDANT_ROWS_INFO_OF_PMATCH_GENCALL rc_arg db col_heu t +in + IS_REDUNDANT_ROWS_INFO_TO_PMATCH_EQ_THM info_thm +end + +fun PMATCH_REMOVE_REDUNDANT_CONV_GEN db col_heu ssl = + PMATCH_REMOVE_REDUNDANT_CONV_GENCALL db col_heu (ssl, NONE) + +fun PMATCH_REMOVE_REDUNDANT_CONV t = PMATCH_REMOVE_REDUNDANT_CONV_GEN + (!thePmatchCompileDB) colHeu_default [] t; + +fun PMATCH_REMOVE_REDUNDANT_GEN_ss db col_heu ssl = + make_gen_conv_ss (PMATCH_REMOVE_REDUNDANT_CONV_GENCALL db col_heu) "PMATCH_REMOVE_REDUNDANT_REDUCER" ssl + +fun PMATCH_REMOVE_REDUNDANT_ss () = + PMATCH_REMOVE_REDUNDANT_GEN_ss (!thePmatchCompileDB) colHeu_default [] + + +fun IS_REDUNDANT_ROWS_INFO_SHOW_ROW_IS_REDUNDANT thm i tac = + CONV_RULE (RAND_CONV (list_nth_CONV i (fn t => + EQT_INTRO (prove (t, tac))))) thm + +fun IS_REDUNDANT_ROWS_INFO_SHOW_ROW_IS_REDUNDANT_set_goal thm i = let + val (l, _) = (listSyntax.dest_list o rand o concl) thm + val t = List.nth (l, i) +in + Manager.set_goal ([], t) +end + + end diff --git a/examples/deep_matches/deepMatchesScript.sml b/examples/deep_matches/deepMatchesScript.sml index e7ce4e399f..0fa94ceac5 100644 --- a/examples/deep_matches/deepMatchesScript.sml +++ b/examples/deep_matches/deepMatchesScript.sml @@ -215,6 +215,7 @@ SIMP_TAC std_ss [PMATCH_EVAL, + (***************************************************) (* Changing rows and removing redundant ones *) (***************************************************) @@ -249,6 +250,115 @@ SIMP_TAC std_ss [PMATCH_def]) +(***************************************************) +(* Simplifying case expressions *) +(***************************************************) + +(* Add an injective function to the pattern and the value. + This can be used to eliminate constructors. *) +val PMATCH_ROW_REMOVE_FUN = store_thm ("PMATCH_ROW_REMOVE_FUN", +``!ff v p g r. (!x y. (ff x = ff y) ==> (x = y)) ==> + + (PMATCH_ROW (\x. (ff (p x))) g r (ff v) = + PMATCH_ROW (\x. (p x)) g r v)``, + +REPEAT STRIP_TAC THEN +`!x y. (ff x = ff y) = (x = y)` by PROVE_TAC[] THEN +ASM_SIMP_TAC std_ss [PMATCH_ROW_def, PMATCH_ROW_COND_def]) + +(* +val PMATCH_ROW_REMOVE_FUN_EXT = store_thm ("PMATCH_ROW_REMOVE_FUN_EXT", +``!ff v f f' g g'. + + ((?x. f' x = ff v) = (?x. f x = v)) ==> + (!x x'. (f' x = ff v) ==> (f x' = v) ==> (g x v = g' x')) ==> + + (PMATCH_ROW (\x. (f' x, g x v)) (ff v) = + PMATCH_ROW (\x. (f x, g' x)) v)``, + +REPEAT STRIP_TAC THEN +ASM_SIMP_TAC std_ss [PMATCH_ROW_def] THEN +Cases_on `?x. f x = v` THEN ( + ASM_REWRITE_TAC[] +) THEN +SELECT_ELIM_TAC THEN +ASM_REWRITE_TAC [] THEN +REPEAT STRIP_TAC THEN +SELECT_ELIM_TAC THEN +ASM_REWRITE_TAC [] THEN +REPEAT STRIP_TAC THEN +PROVE_TAC[]) + +*) + +(* The following lemma looks rather complicated. It is + intended to work together with PMATCH_ROW_REMOVE_FUN to + propagate information in the var cases. + + as an example consider + + val t = ``PMATCH (SOME x, y) [ + PMATCH_ROW (\x. (SOME x, 0)) (K T) (\x. (SOME (x + y))); + PMATCH_ROW (\(x', y). (x', y)) (K T) (\(x', y). x') + ]`` + + We want to simplify this to + + val t = ``PMATCH (x, y) [ + PMATCH_ROW (\x. (x, 0)) (K T) (\x. (SOME (x + y))); + PMATCH_ROW (\(x'', y). (x'', y)) (K T) (\(x'', y). SOME x'') + ]`` + + This is done via PMATCH_ROWS_SIMP and PMATCH_ROWS_SIMP_SOUNDNESS. + We need to show that the rows correspond to each other. + + For the first row, PMATCH_ROW_REMOVE_FUN is used with + + v := (x, y) + ff (x, y) := (SOME x, y) + + p x := (x, 0) + r x := SOME (x + y) + + + For the second row, PMATCH_ROW_REMOVE_FUN is used with + + v := (SOME x, y) + v' := (x, y) + p (x', y) := (x', y) + r (x', y) := x' + p' (x'', y) = (x'', y) + f (x'', y) := (SOME x'', y) +*) + +val PMATCH_ROW_REMOVE_FUN_VAR = store_thm ("PMATCH_ROW_REMOVE_FUN_VAR", +``!v v' f p g r p' . + ((!x'. (p' x' = v') = (p (f x') = v)) /\ + ((!x. (p x = v) ==> ?x'. f x' = x)) /\ + ((!x y. (p x = p y) ==> (x = y)))) ==> + (PMATCH_ROW p g r v = + PMATCH_ROW p' (\x. g (f x)) (\x. r (f x)) v')``, + +REPEAT STRIP_TAC THEN +ASM_SIMP_TAC std_ss [PMATCH_ROW_def] THEN +`IS_SOME (some x. PMATCH_ROW_COND p' (\x. g (f x)) v' x) = + IS_SOME (some x. PMATCH_ROW_COND p g v x)` by ALL_TAC THEN1 ( + ASM_SIMP_TAC std_ss [some_IS_SOME, PMATCH_ROW_COND_def] THEN + EQ_TAC THEN1 PROVE_TAC[] THEN + REPEAT STRIP_TAC THEN + `?x'. f x' = x` by PROVE_TAC[] THEN + Q.EXISTS_TAC `x'` THEN + ASM_REWRITE_TAC[] +) THEN +Tactical.REVERSE (Cases_on `IS_SOME (some x. PMATCH_ROW_COND p g v x)`) THEN ( + FULL_SIMP_TAC std_ss [] +) THEN +FULL_SIMP_TAC std_ss [some_IS_SOME_EXISTS] THEN +FULL_SIMP_TAC std_ss [PMATCH_ROW_COND_def] THEN +METIS_TAC[]); + + + (***************************************************) (* Equivalent sets of rows *) (***************************************************) @@ -322,262 +432,10 @@ SIMP_TAC list_ss [GSYM PMATCH_EQUIV_ROWS_EQUIV_EXPAND, EXISTS_OR_THM, PMATCH_def]) -val IS_REDUNDANT_ROWS_INFO_def = Define ` - IS_REDUNDANT_ROWS_INFO v rows infos <=> ( - (LENGTH rows = LENGTH infos) /\ - (!i. i < LENGTH rows ==> EL i infos ==> - PMATCH_ROW_REDUNDANT v rows i))` - - -val IS_REDUNDANT_ROWS_INFO_CONS = store_thm ( - "IS_REDUNDANT_ROWS_INFO_CONS", -`` - IS_REDUNDANT_ROWS_INFO v (row::rows) (i::infos') = ( - (LENGTH rows = LENGTH infos') /\ - (i ==> ((row v) = NONE)) /\ - ((row v = NONE) ==> IS_REDUNDANT_ROWS_INFO v rows infos') -)``, - -EQ_TAC THEN SIMP_TAC list_ss [IS_REDUNDANT_ROWS_INFO_def] THEN -REPEAT STRIP_TAC THENL [ - Q.PAT_ASSUM `!i'. _` (MP_TAC o SPEC ``0``) THEN - ASM_SIMP_TAC list_ss [PMATCH_ROW_REDUNDANT_def], - - Q.PAT_ASSUM `!i'. _` (MP_TAC o Q.SPEC `SUC i'`) THEN - FULL_SIMP_TAC list_ss [PMATCH_ROW_REDUNDANT_def] THEN - REPEAT STRIP_TAC THEN - FULL_SIMP_TAC std_ss [] THEN - Q.PAT_ASSUM `row v = NONE` ASSUME_TAC THEN - Q.EXISTS_TAC `PRE j` THEN - Cases_on `j` THEN ( - FULL_SIMP_TAC list_ss [] - ), - - FULL_SIMP_TAC list_ss [PMATCH_ROW_REDUNDANT_def] THEN - `(i'=0) \/ (?i''. (i' = SUC i''))` by ALL_TAC THENL [ - Cases_on `i'` THEN SIMP_TAC std_ss [], - FULL_SIMP_TAC list_ss [], - ALL_TAC - ] THEN - FULL_SIMP_TAC list_ss [] THEN - STRIP_TAC THEN - Tactical.REVERSE (Cases_on `row v`) THEN1 ( - Q.EXISTS_TAC `0` THEN - ASM_SIMP_TAC list_ss [] - ) THEN - FULL_SIMP_TAC std_ss [] THEN - Q.PAT_ASSUM `!i. _` (MP_TAC o Q.SPEC `i''`) THEN - ASM_SIMP_TAC std_ss [] THEN - STRIP_TAC THEN - Q.EXISTS_TAC `SUC j` THEN - ASM_SIMP_TAC list_ss [] -]) - - -val APPLY_REDUNDANT_ROWS_INFO_def = Define ` - (APPLY_REDUNDANT_ROWS_INFO is xs = MAP SND ( - FILTER (\x. ~ (FST x)) (ZIP (is, xs))))` - -val APPLY_REDUNDANT_ROWS_INFO_THMS = store_thm ( - "APPLY_REDUNDANT_ROWS_INFO_THMS", -``(APPLY_REDUNDANT_ROWS_INFO [] [] = []) /\ - (!is x xs. (APPLY_REDUNDANT_ROWS_INFO (T::is) (x::xs) = - (APPLY_REDUNDANT_ROWS_INFO is xs))) /\ - (!is x xs. (APPLY_REDUNDANT_ROWS_INFO (F::is) (x::xs) = - x::(APPLY_REDUNDANT_ROWS_INFO is xs)))``, - -SIMP_TAC list_ss [APPLY_REDUNDANT_ROWS_INFO_def]); - - -val PMATCH_ROWS_DROP_REDUNDANT_EQUIV = store_thm ("PMATCH_ROWS_DROP_REDUNDANT_EQUIV", -``!v rows infos. IS_REDUNDANT_ROWS_INFO v rows infos ==> - (PMATCH_EQUIV_ROWS v rows (APPLY_REDUNDANT_ROWS_INFO infos rows))``, - -GEN_TAC THEN -Induct_on `rows` THEN1 ( - SIMP_TAC (list_ss++QUANT_INST_ss [std_qp]) [ - IS_REDUNDANT_ROWS_INFO_def, - APPLY_REDUNDANT_ROWS_INFO_def, - PMATCH_EQUIV_ROWS_is_equiv_1] -) THEN -CONV_TAC (RENAME_VARS_CONV ["row"]) THEN -REPEAT STRIP_TAC THEN -`?i infos'. infos = i::infos'` by ALL_TAC THEN1 ( - Cases_on `infos` THEN - FULL_SIMP_TAC list_ss [IS_REDUNDANT_ROWS_INFO_def] -) THEN -FULL_SIMP_TAC std_ss [IS_REDUNDANT_ROWS_INFO_CONS] THEN -Q.PAT_ASSUM `!infos. _` (MP_TAC o Q.SPEC `infos'`) THEN -Cases_on `i` THENL [ - FULL_SIMP_TAC std_ss [APPLY_REDUNDANT_ROWS_INFO_THMS, - PMATCH_EQUIV_ROWS_CONS_NONE], - - Cases_on `row v` THEN ( - FULL_SIMP_TAC std_ss [APPLY_REDUNDANT_ROWS_INFO_THMS, - PMATCH_EQUIV_ROWS_CONS_NONE, PMATCH_EQUIV_ROWS_EQUIV_EXPAND] - ) THEN - STRIP_TAC THEN - ASM_SIMP_TAC list_ss [PMATCH_EQUIV_ROWS_def, - GSYM PMATCH_EQUIV_ROWS_EQUIV_EXPAND, RIGHT_AND_OVER_OR, - EXISTS_OR_THM, PMATCH_def] -]) - - -val IS_REDUNDANT_ROWS_INFO_GEN_def = Define ` - IS_REDUNDANT_ROWS_INFO_GEN vf gf rows infos = ( - (LENGTH rows = LENGTH infos) /\ - (!x. gf x ==> IS_REDUNDANT_ROWS_INFO (vf x) rows infos))`; - - -val IS_REDUNDANT_ROWS_INFO_GEN_NIL = store_thm ("IS_REDUNDANT_ROWS_INFO_GEN_NIL", - ``!vf gf. IS_REDUNDANT_ROWS_INFO_GEN vf gf [] []``, -SIMP_TAC list_ss [IS_REDUNDANT_ROWS_INFO_GEN_def, - IS_REDUNDANT_ROWS_INFO_def]); - - -val IS_REDUNDANT_ROWS_INFO_GEN_CONS_NONE = store_thm ("IS_REDUNDANT_ROWS_INFO_GEN_CONS_NONE", - ``!vf gf row rows infos pats. (!x. gf x ==> (row (vf x) = NONE)) ==> - IS_REDUNDANT_ROWS_INFO_GEN vf gf rows infos ==> - IS_REDUNDANT_ROWS_INFO_GEN vf gf (row::rows) (T::infos)``, - -SIMP_TAC list_ss [IS_REDUNDANT_ROWS_INFO_GEN_def, - IS_REDUNDANT_ROWS_INFO_def, FORALL_AND_THM, - IMP_CONJ_THM, GSYM RIGHT_FORALL_IMP_THM] THEN -REPEAT STRIP_TAC THEN -`(i=0) \/ (?i'. (i = SUC i'))` by ALL_TAC THENL [ - Cases_on `i` THEN SIMP_TAC std_ss [], - FULL_SIMP_TAC list_ss [PMATCH_ROW_REDUNDANT_def], - - FULL_SIMP_TAC list_ss [PMATCH_ROW_REDUNDANT_def, FORALL_AND_THM] THEN - Q.PAT_ASSUM `!x i''. _` (MP_TAC o Q.SPECL [`x`, `i'`]) THEN - ASM_SIMP_TAC std_ss [] THEN - REPEAT STRIP_TAC THEN - FULL_SIMP_TAC std_ss [] THEN - Q.EXISTS_TAC `SUC j` THEN - ASM_SIMP_TAC list_ss [] -]); - - -val IS_REDUNDANT_ROWS_INFO_GEN_CONS_SOME = store_thm ("IS_REDUNDANT_ROWS_INFO_GEN_CONS_SOME", - ``!vf gf row rows. (!x. gf x ==> IS_SOME (row (vf x))) ==> - IS_REDUNDANT_ROWS_INFO_GEN vf gf (row::rows) (F::(MAP (\x. T) rows))``, - -SIMP_TAC list_ss [IS_REDUNDANT_ROWS_INFO_GEN_def, - IS_REDUNDANT_ROWS_INFO_def, combinTheory.o_DEF] THEN -REPEAT STRIP_TAC THEN -`(i=0) \/ (?i'. (i = SUC i'))` by ALL_TAC THENL [ - Cases_on `i` THEN SIMP_TAC std_ss [], - FULL_SIMP_TAC list_ss [], - - FULL_SIMP_TAC list_ss [PMATCH_ROW_REDUNDANT_def] THEN - STRIP_TAC THEN - Q.EXISTS_TAC `0` THEN - ASM_SIMP_TAC list_ss [] -]) - - -val COMBINE_REDUNDANT_ROWS_INFOS_def = Define ` - COMBINE_REDUNDANT_ROWS_INFOS ip1 ip2 = - (MAP2 (\i1 i2. i1 /\ i2) ip1 ip2)`; - -val COMBINE_REDUNDANT_ROWS_INFOS_LIST_def = Define ` - (COMBINE_REDUNDANT_ROWS_INFOS_LIST [ip] = ip) /\ - (COMBINE_REDUNDANT_ROWS_INFOS_LIST (ip1::ip2::ips) = - COMBINE_REDUNDANT_ROWS_INFOS ip1 ( - COMBINE_REDUNDANT_ROWS_INFOS_LIST (ip2::ips)))`; - -val EL_MAP2 = store_thm ("EL_MAP2", -``!n l1 l2. n < LENGTH l1 /\ n < LENGTH l2 ==> - (!f. EL n (MAP2 f l1 l2) = f (EL n l1) (EL n l2))``, - -Induct_on `n` THEN1 ( - SIMP_TAC (list_ss++QUANT_INST_ss[std_qp]) [] -) THEN -REPEAT STRIP_TAC THEN -Cases_on `l1` THEN Cases_on `l2` THEN ( - FULL_SIMP_TAC list_ss [] -)) - - -val COMBINE_REDUNDANT_ROWS_INFOS_LIST_LENGTH_INFOS = store_thm ( -"COMBINE_REDUNDANT_ROWS_INFOS_LIST_LENGTH_INFOS", -``!l ips infos. - ~(ips = []) ==> - EVERY (\ip. (LENGTH ip = l)) ips ==> - (COMBINE_REDUNDANT_ROWS_INFOS_LIST ips = infos) ==> - ((LENGTH infos = l) /\ - (!i. i < l ==> EL i infos ==> - EVERY (\ip. EL i ip) ips))``, - -GEN_TAC THEN -Induct_on `ips` THEN SIMP_TAC list_ss [] THEN -CONV_TAC (RENAME_VARS_CONV ["ip"]) THEN -Cases_on `ips = []` THEN1 ( - FULL_SIMP_TAC list_ss [COMBINE_REDUNDANT_ROWS_INFOS_LIST_def] -) THEN -`?ip' ips'. ips = ip'::ips'` by (Cases_on `ips` THEN FULL_SIMP_TAC list_ss []) THEN -FULL_SIMP_TAC list_ss [COMBINE_REDUNDANT_ROWS_INFOS_LIST_def] THEN -REPEAT GEN_TAC THEN REPEAT DISCH_TAC THEN -`?infos'. - COMBINE_REDUNDANT_ROWS_INFOS_LIST (ip'::ips') = infos'` by - ALL_TAC THEN1 ( - PROVE_TAC[] -) THEN -FULL_SIMP_TAC list_ss [COMBINE_REDUNDANT_ROWS_INFOS_def] THEN -ASM_SIMP_TAC list_ss [rich_listTheory.LENGTH_MAP2, - EL_MAP2]); - - -val IS_REDUNDANT_ROWS_INFO_GEN_SPLIT = store_thm ("IS_REDUNDANT_ROWS_INFO_GEN_SPLIT", - ``!vf gf vips rows infos pats. ( - ~(vips = []) /\ - (EVERY (\ ((vf', gf'), infos'). - IS_REDUNDANT_ROWS_INFO_GEN vf' gf' rows infos') vips) /\ - (!x. gf x ==> - EXISTS (\ ((vf', gf'), infos'). ?x'. (gf' x') /\ (vf' x' = vf x)) vips) /\ - (COMBINE_REDUNDANT_ROWS_INFOS_LIST (MAP SND vips) = - infos)) ==> - - IS_REDUNDANT_ROWS_INFO_GEN vf gf rows infos``, - -REPEAT STRIP_TAC THEN -FULL_SIMP_TAC std_ss [IS_REDUNDANT_ROWS_INFO_GEN_def, - GSYM FORALL_AND_THM] THEN -`EVERY (\vip. LENGTH (SND vip) = LENGTH rows) vips` by ALL_TAC THEN1 ( - Q.PAT_ASSUM `EVERY _ vips` MP_TAC THEN - REPEAT (POP_ASSUM (K ALL_TAC)) THEN - SIMP_TAC (std_ss++pairSimps.gen_beta_ss) [EVERY_MEM] -) THEN -MP_TAC (Q.ISPECL [`LENGTH (rows : ('b -> 'd option) list)`, - `MAP SND (vips : ((('c -> 'b) # ('c -> bool)) # bool list) list)`] - COMBINE_REDUNDANT_ROWS_INFOS_LIST_LENGTH_INFOS) THEN -ASM_SIMP_TAC list_ss [MAP_EQ_NIL, EVERY_MAP] THEN -REPEAT STRIP_TAC THEN -`?vf' gf' infos' x'. (MEM ((vf', gf'), infos') vips) /\ - gf' x' /\ (vf' x' = vf x)` by ALL_TAC THEN1 ( - RES_TAC THEN - FULL_SIMP_TAC std_ss [EXISTS_MEM] THEN - Cases_on `e` THEN Cases_on `q` THEN - FULL_SIMP_TAC std_ss [] THEN - METIS_TAC[] -) THEN -`IS_REDUNDANT_ROWS_INFO (vf x) rows infos'` by ALL_TAC THEN1 ( - FULL_SIMP_TAC std_ss [EVERY_MEM] THEN - RES_TAC THEN - FULL_SIMP_TAC std_ss [] THEN - METIS_TAC[] -) THEN -Q.PAT_ASSUM `IS_REDUNDANT_ROWS_INFO _ _ _` MP_TAC THEN -ASM_SIMP_TAC std_ss [IS_REDUNDANT_ROWS_INFO_def, - AND_IMP_INTRO] THEN -REPEAT STRIP_TAC THEN -Q.PAT_ASSUM `!i. _ ==> _` MATCH_MP_TAC THEN -Q.PAT_ASSUM `!i. _` (MP_TAC o Q.SPEC `i`) THEN -ASM_SIMP_TAC std_ss [EVERY_MEM] THEN -REPEAT STRIP_TAC THEN -RES_TAC THEN -FULL_SIMP_TAC std_ss []); +(***************************************************) +(* Simple removal of redundant rows *) +(***************************************************) (* If we have a row that matches, everything after it can be dropped *) val PMATCH_ROWS_DROP_REDUNDANT_TRIVIAL_SOUNDNESS_EQUIV = store_thm ("PMATCH_ROWS_DROP_REDUNDANT_TRIVIAL_SOUNDNESS_EQUIV", @@ -610,6 +468,10 @@ MATCH_MP_TAC PMATCH_ROWS_DROP_REDUNDANT_TRIVIAL_SOUNDNESS_EQUIV THEN ASM_REWRITE_TAC[]) + +(* A row is redundant, if it is made redundant by exactly one + row above. This is simple to test and often already very + helful. More fancy tests involving multiple rows follow below *) val PMATCH_ROWS_DROP_REDUNDANT = store_thm ( "PMATCH_ROWS_DROP_REDUNDANT", ``!r1 r2 rows1 rows2 rows3 v. @@ -646,6 +508,12 @@ Cases_on `?x'. (p' x' = v) ∧ g' x'` THEN ( ) THEN METIS_TAC[IS_SOME_DEF]); + + +(***************************************************) +(* Simple removal of subsumed rows *) +(***************************************************) + (* Some rows are not redundant in the classical sense, but can safely be dropped nevertheless. A redundant row never matches, because it is shaddowed by a previous row. One can also also @@ -745,108 +613,380 @@ ASM_SIMP_TAC std_ss []) -(* Add an injective function to the pattern and the value. - This can be used to eliminate constructors. *) -val PMATCH_ROW_REMOVE_FUN = store_thm ("PMATCH_ROW_REMOVE_FUN", -``!ff v p g r. (!x y. (ff x = ff y) ==> (x = y)) ==> +(***************************************************) +(* Fancy redundancy check *) +(***************************************************) + +val PMATCH_ROW_COND_EX_def = Define `PMATCH_ROW_COND_EX i p g = +?x. PMATCH_ROW_COND p g i x` + +val PMATCH_ROW_COND_EX_FULL_DEF = store_thm ("PMATCH_ROW_COND_EX_FULL_DEF", + ``PMATCH_ROW_COND_EX i p g = + ?x. (i = p x) /\ g x``, +SIMP_TAC std_ss [PMATCH_ROW_COND_EX_def, PMATCH_ROW_COND_def] THEN +METIS_TAC[]) + +val IS_REDUNDANT_ROWS_INFO_def = Define ` + IS_REDUNDANT_ROWS_INFO v rows c infos <=> ( + (LENGTH rows = LENGTH infos) /\ + (!i. i < LENGTH rows ==> EL i infos ==> + PMATCH_ROW_REDUNDANT v rows i) /\ + (EVERY (\r. r v = NONE) rows ==> c))` + + +val IS_REDUNDANT_ROWS_INFO_NIL = store_thm ( + "IS_REDUNDANT_ROWS_INFO_NIL", +``!v. IS_REDUNDANT_ROWS_INFO v [] T []``, +SIMP_TAC list_ss [IS_REDUNDANT_ROWS_INFO_def]) - (PMATCH_ROW (\x. (ff (p x))) g r (ff v) = - PMATCH_ROW (\x. (p x)) g r v)``, + +val IS_REDUNDANT_ROWS_INFO_SNOC = store_thm ( + "IS_REDUNDANT_ROWS_INFO_SNOC", +``!v rows c infos r i c'. + IS_REDUNDANT_ROWS_INFO v rows c infos ==> + ((r v = NONE) ==> c ==> c') ==> + (c ==> i ==> (r v = NONE)) ==> + IS_REDUNDANT_ROWS_INFO v (SNOC r rows) c' (SNOC i infos) +``, REPEAT STRIP_TAC THEN -`!x y. (ff x = ff y) = (x = y)` by PROVE_TAC[] THEN -ASM_SIMP_TAC std_ss [PMATCH_ROW_def, PMATCH_ROW_COND_def]) +FULL_SIMP_TAC list_ss [IS_REDUNDANT_ROWS_INFO_def, SNOC_APPEND] THEN +REPEAT STRIP_TAC THEN +Cases_on `i' < LENGTH infos` THEN1 ( + Q.PAT_ASSUM `!i. _` (MP_TAC o Q.SPEC `i'`) THEN + FULL_SIMP_TAC (list_ss++boolSimps.CONJ_ss) [PMATCH_ROW_REDUNDANT_def, + rich_listTheory.EL_APPEND1] +) THEN -(* -val PMATCH_ROW_REMOVE_FUN_EXT = store_thm ("PMATCH_ROW_REMOVE_FUN_EXT", -``!ff v f f' g g'. +`i' = LENGTH infos` by DECIDE_TAC THEN +FULL_SIMP_TAC list_ss [rich_listTheory.EL_APPEND2] THEN +ASM_SIMP_TAC (list_ss++boolSimps.CONJ_ss) [PMATCH_ROW_REDUNDANT_def, + rich_listTheory.EL_APPEND2, rich_listTheory.EL_APPEND1] THEN +Cases_on `c` THEN FULL_SIMP_TAC std_ss [] THEN +REPEAT STRIP_TAC THEN +FULL_SIMP_TAC std_ss [EVERY_MEM, MEM_EL] THEN +Q.EXISTS_TAC `n` THEN +FULL_SIMP_TAC list_ss [] THEN +Q.PAT_ASSUM `r' = _` (ASSUME_TAC o GSYM) THEN +Cases_on `r' v` THEN ( + FULL_SIMP_TAC std_ss [] +)) - ((?x. f' x = ff v) = (?x. f x = v)) ==> - (!x x'. (f' x = ff v) ==> (f x' = v) ==> (g x v = g' x')) ==> - (PMATCH_ROW (\x. (f' x, g x v)) (ff v) = - PMATCH_ROW (\x. (f x, g' x)) v)``, + +val IS_REDUNDANT_ROWS_INFO_SNOC_PMATCH_ROW = store_thm ( + "IS_REDUNDANT_ROWS_INFO_SNOC_PMATCH_ROW", +``!v rows c infos p g r c'. + IS_REDUNDANT_ROWS_INFO v rows c infos ==> + (~(PMATCH_ROW_COND_EX v p g) ==> (c = c')) ==> + IS_REDUNDANT_ROWS_INFO v (SNOC (PMATCH_ROW p g r) rows) c' (SNOC (c ==> ~(PMATCH_ROW_COND_EX v p g)) infos) +``, REPEAT STRIP_TAC THEN -ASM_SIMP_TAC std_ss [PMATCH_ROW_def] THEN -Cases_on `?x. f x = v` THEN ( - ASM_REWRITE_TAC[] +MATCH_MP_TAC (REWRITE_RULE [AND_IMP_INTRO] IS_REDUNDANT_ROWS_INFO_SNOC) THEN +Q.EXISTS_TAC `c` THEN +FULL_SIMP_TAC std_ss [PMATCH_ROW_EQ_NONE, PMATCH_ROW_COND_EX_def] THEN +METIS_TAC[]) + +val IS_REDUNDANT_ROWS_INFO_CONS = store_thm ( + "IS_REDUNDANT_ROWS_INFO_CONS", +`` + IS_REDUNDANT_ROWS_INFO v (row::rows) c (i::infos') = ( + (LENGTH rows = LENGTH infos') /\ + (i ==> ((row v) = NONE)) /\ + ((row v = NONE) ==> IS_REDUNDANT_ROWS_INFO v rows c infos') +)``, + +EQ_TAC THEN SIMP_TAC list_ss [IS_REDUNDANT_ROWS_INFO_def] THEN +REPEAT STRIP_TAC THENL [ + Q.PAT_ASSUM `!i'. _` (MP_TAC o SPEC ``0``) THEN + ASM_SIMP_TAC list_ss [PMATCH_ROW_REDUNDANT_def], + + Q.PAT_ASSUM `!i'. _` (MP_TAC o Q.SPEC `SUC i'`) THEN + FULL_SIMP_TAC list_ss [PMATCH_ROW_REDUNDANT_def] THEN + REPEAT STRIP_TAC THEN + FULL_SIMP_TAC std_ss [] THEN + Q.PAT_ASSUM `row v = NONE` ASSUME_TAC THEN + Q.EXISTS_TAC `PRE j` THEN + Cases_on `j` THEN ( + FULL_SIMP_TAC list_ss [] + ), + + FULL_SIMP_TAC list_ss [PMATCH_ROW_REDUNDANT_def] THEN + `(i'=0) \/ (?i''. (i' = SUC i''))` by ALL_TAC THENL [ + Cases_on `i'` THEN SIMP_TAC std_ss [], + FULL_SIMP_TAC list_ss [], + ALL_TAC + ] THEN + FULL_SIMP_TAC list_ss [] THEN + STRIP_TAC THEN + Tactical.REVERSE (Cases_on `row v`) THEN1 ( + Q.EXISTS_TAC `0` THEN + ASM_SIMP_TAC list_ss [] + ) THEN + FULL_SIMP_TAC std_ss [] THEN + Q.PAT_ASSUM `!i. _` (MP_TAC o Q.SPEC `i''`) THEN + ASM_SIMP_TAC std_ss [] THEN + STRIP_TAC THEN + Q.EXISTS_TAC `SUC j` THEN + ASM_SIMP_TAC list_ss [] +]) + + +val APPLY_REDUNDANT_ROWS_INFO_def = Define ` + (APPLY_REDUNDANT_ROWS_INFO is xs = MAP SND ( + FILTER (\x. ~ (FST x)) (ZIP (is, xs))))` + +val APPLY_REDUNDANT_ROWS_INFO_THMS = store_thm ( + "APPLY_REDUNDANT_ROWS_INFO_THMS", +``(APPLY_REDUNDANT_ROWS_INFO [] [] = []) /\ + (!is x xs. (APPLY_REDUNDANT_ROWS_INFO (T::is) (x::xs) = + (APPLY_REDUNDANT_ROWS_INFO is xs))) /\ + (!is x xs. (APPLY_REDUNDANT_ROWS_INFO (F::is) (x::xs) = + x::(APPLY_REDUNDANT_ROWS_INFO is xs)))``, + +SIMP_TAC list_ss [APPLY_REDUNDANT_ROWS_INFO_def]); + + +val PMATCH_ROWS_DROP_REDUNDANT_ROWS_INFO_EQUIV = store_thm ("PMATCH_ROWS_DROP_REDUNDANT_ROWS_INFO_EQUIV", +``!v c rows infos. IS_REDUNDANT_ROWS_INFO v rows c infos ==> + (PMATCH_EQUIV_ROWS v rows (APPLY_REDUNDANT_ROWS_INFO infos rows))``, + +GEN_TAC THEN +Induct_on `rows` THEN1 ( + SIMP_TAC (list_ss++QUANT_INST_ss [std_qp]) [ + IS_REDUNDANT_ROWS_INFO_def, + APPLY_REDUNDANT_ROWS_INFO_def, + PMATCH_EQUIV_ROWS_is_equiv_1] ) THEN -SELECT_ELIM_TAC THEN -ASM_REWRITE_TAC [] THEN +CONV_TAC (RENAME_VARS_CONV ["row"]) THEN REPEAT STRIP_TAC THEN -SELECT_ELIM_TAC THEN -ASM_REWRITE_TAC [] THEN +`?i infos'. infos = i::infos'` by ALL_TAC THEN1 ( + Cases_on `infos` THEN + FULL_SIMP_TAC list_ss [IS_REDUNDANT_ROWS_INFO_def] +) THEN +FULL_SIMP_TAC std_ss [IS_REDUNDANT_ROWS_INFO_CONS] THEN +Q.PAT_ASSUM `!c infos. _` (MP_TAC o Q.SPECL [`c`, `infos'`]) THEN +Cases_on `i` THENL [ + FULL_SIMP_TAC std_ss [APPLY_REDUNDANT_ROWS_INFO_THMS, + PMATCH_EQUIV_ROWS_CONS_NONE], + + Cases_on `row v` THEN ( + FULL_SIMP_TAC std_ss [APPLY_REDUNDANT_ROWS_INFO_THMS, + PMATCH_EQUIV_ROWS_CONS_NONE, PMATCH_EQUIV_ROWS_EQUIV_EXPAND] + ) THEN + STRIP_TAC THEN + ASM_SIMP_TAC list_ss [PMATCH_EQUIV_ROWS_def, + GSYM PMATCH_EQUIV_ROWS_EQUIV_EXPAND, RIGHT_AND_OVER_OR, + EXISTS_OR_THM, PMATCH_def] +]) + +val REDUNDANT_ROWS_INFO_TO_PMATCH_EQ = store_thm ("REDUNDANT_ROWS_INFO_TO_PMATCH_EQ", +``!v c rows infos. IS_REDUNDANT_ROWS_INFO v rows c infos ==> + (PMATCH v rows = + PMATCH v (APPLY_REDUNDANT_ROWS_INFO infos rows))``, + REPEAT STRIP_TAC THEN +MATCH_MP_TAC PMATCH_EQUIV_ROWS_MATCH THEN +MATCH_MP_TAC PMATCH_ROWS_DROP_REDUNDANT_ROWS_INFO_EQUIV THEN PROVE_TAC[]) -*) -(* The following lemma looks rather complicated. It is - intended to work together with PMATCH_ROW_REMOVE_FUN to - propagate information in the var cases. +(* One can easily mark rows as not redundant without proof *) +val REDUNDANT_ROWS_INFOS_CONJ_def = Define ` + REDUNDANT_ROWS_INFOS_CONJ ip1 ip2 = + (MAP2 (\i1 i2. i1 /\ i2) ip1 ip2)`; - as an example consider +val REDUNDANT_ROWS_INFOS_CONJ_REWRITE = store_thm ( + "REDUNDANT_ROWS_INFOS_CONJ_REWRITE", +``(REDUNDANT_ROWS_INFOS_CONJ [] [] = []) /\ + (REDUNDANT_ROWS_INFOS_CONJ (i1 :: is1) (i2::is2) = + (i1 /\ i2) :: (REDUNDANT_ROWS_INFOS_CONJ is1 is2))``, +SIMP_TAC list_ss [REDUNDANT_ROWS_INFOS_CONJ_def]) - val t = ``PMATCH (SOME x, y) [ - PMATCH_ROW (\x. (SOME x, 0)) (K T) (\x. (SOME (x + y))); - PMATCH_ROW (\(x', y). (x', y)) (K T) (\(x', y). x') - ]`` - We want to simplify this to +val REDUNDANT_ROWS_INFOS_CONJ_THM = store_thm ("REDUNDANT_ROWS_INFOS_CONJ_THM", +``!v rows c infos c' infos'. + IS_REDUNDANT_ROWS_INFO v rows c infos ==> + (LENGTH infos' = LENGTH infos) ==> + IS_REDUNDANT_ROWS_INFO v rows (c \/ c') (REDUNDANT_ROWS_INFOS_CONJ infos infos')``, - val t = ``PMATCH (x, y) [ - PMATCH_ROW (\x. (x, 0)) (K T) (\x. (SOME (x + y))); - PMATCH_ROW (\(x'', y). (x'', y)) (K T) (\(x'', y). SOME x'') - ]`` +SIMP_TAC list_ss [IS_REDUNDANT_ROWS_INFO_def, + REDUNDANT_ROWS_INFOS_CONJ_def, MAP2_MAP, EL_MAP, EL_ZIP]) - This is done via PMATCH_ROWS_SIMP and PMATCH_ROWS_SIMP_SOUNDNESS. - We need to show that the rows correspond to each other. - For the first row, PMATCH_ROW_REMOVE_FUN is used with +(* Strengthening requires proof though *) +val REDUNDANT_ROWS_INFOS_DISJ_def = Define ` + REDUNDANT_ROWS_INFOS_DISJ ip1 ip2 = + (MAP2 (\i1 i2. i1 \/ i2) ip1 ip2)`; - v := (x, y) - ff (x, y) := (SOME x, y) +val REDUNDANT_ROWS_INFOS_DISJ_THM = store_thm ("REDUNDANT_ROWS_INFOS_DISJ_THM", +``!v rows c infos c' infos'. + IS_REDUNDANT_ROWS_INFO v rows c infos ==> + IS_REDUNDANT_ROWS_INFO v rows c' infos' ==> + IS_REDUNDANT_ROWS_INFO v rows (c /\ c') (REDUNDANT_ROWS_INFOS_DISJ infos infos')``, - p x := (x, 0) - r x := SOME (x + y) +SIMP_TAC list_ss [IS_REDUNDANT_ROWS_INFO_def, + REDUNDANT_ROWS_INFOS_DISJ_def, MAP2_MAP, EL_MAP, EL_ZIP] THEN +METIS_TAC[]) +(* One can use the always correct, but usually much too complicated + strongest redundant_rows_info for strengthening *) + +val STRONGEST_REDUNDANT_ROWS_INFO_AUX_def = Define ` + (STRONGEST_REDUNDANT_ROWS_INFO_AUX v [] p infos = (p, infos)) /\ + (STRONGEST_REDUNDANT_ROWS_INFO_AUX v (r::rows) p infos = + STRONGEST_REDUNDANT_ROWS_INFO_AUX v rows (p /\ (r v = NONE)) + (SNOC (p ==> (r v = NONE)) infos))` + +val STRONGEST_REDUNDANT_ROWS_INFO_def = Define ` + STRONGEST_REDUNDANT_ROWS_INFO v rows = + SND (STRONGEST_REDUNDANT_ROWS_INFO_AUX v rows T [])` + +val LENGTH_STRONGEST_REDUNDANT_ROWS_INFO_AUX = store_thm ( + "LENGTH_STRONGEST_REDUNDANT_ROWS_INFO_AUX", + ``!v rows p infos. + LENGTH (SND (STRONGEST_REDUNDANT_ROWS_INFO_AUX v rows p infos)) = + (LENGTH rows + LENGTH infos)``, + +Induct_on `rows` THEN ( + ASM_SIMP_TAC list_ss [STRONGEST_REDUNDANT_ROWS_INFO_AUX_def] +)) - For the second row, PMATCH_ROW_REMOVE_FUN is used with +val FST_STRONGEST_REDUNDANT_ROWS_INFO_AUX = store_thm ( + "FST_STRONGEST_REDUNDANT_ROWS_INFO_AUX", + ``!v rows p infos. + FST (STRONGEST_REDUNDANT_ROWS_INFO_AUX v rows p infos) = + (p /\ EVERY (\r. r v = NONE) rows)``, - v := (SOME x, y) - v' := (x, y) - p (x', y) := (x', y) - r (x', y) := x' - p' (x'', y) = (x'', y) - f (x'', y) := (SOME x'', y) -*) +Induct_on `rows` THEN ( + ASM_SIMP_TAC (list_ss++boolSimps.EQUIV_EXTRACT_ss) [STRONGEST_REDUNDANT_ROWS_INFO_AUX_def] +)) + + + +val EL1_STRONGEST_REDUNDANT_ROWS_INFO_AUX = store_thm ( + "EL1_STRONGEST_REDUNDANT_ROWS_INFO_AUX", + ``!v rows p infos i. + (i < LENGTH infos) ==> + (EL i (SND (STRONGEST_REDUNDANT_ROWS_INFO_AUX v rows p infos)) = + EL i infos)``, + +Induct_on `rows` THEN ( + ASM_SIMP_TAC (list_ss++boolSimps.EQUIV_EXTRACT_ss) [STRONGEST_REDUNDANT_ROWS_INFO_AUX_def, SNOC_APPEND, rich_listTheory.EL_APPEND1] +)) -val PMATCH_ROW_REMOVE_FUN_VAR = store_thm ("PMATCH_ROW_REMOVE_FUN_VAR", -``!v v' f p g r p' . - ((!x'. (p' x' = v') = (p (f x') = v)) /\ - ((!x. (p x = v) ==> ?x'. f x' = x)) /\ - ((!x y. (p x = p y) ==> (x = y)))) ==> - (PMATCH_ROW p g r v = - PMATCH_ROW p' (\x. g (f x)) (\x. r (f x)) v')``, +val EL2_STRONGEST_REDUNDANT_ROWS_INFO_AUX = store_thm ( + "EL2_STRONGEST_REDUNDANT_ROWS_INFO_AUX", + ``!v rows p infos i. + (i >= LENGTH infos /\ i < LENGTH rows + LENGTH infos) ==> + (EL i (SND (STRONGEST_REDUNDANT_ROWS_INFO_AUX v rows p infos)) = + ((p /\ EVERY (\r. r v = NONE) (TAKE (i - LENGTH infos) rows)) ==> ((EL (i - LENGTH infos) rows) v = NONE)))``, + +GEN_TAC THEN +Induct_on `rows` THEN1 ( + SIMP_TAC list_ss [] +) THEN +SIMP_TAC list_ss [STRONGEST_REDUNDANT_ROWS_INFO_AUX_def] THEN REPEAT STRIP_TAC THEN -ASM_SIMP_TAC std_ss [PMATCH_ROW_def] THEN -`IS_SOME (some x. PMATCH_ROW_COND p' (\x. g (f x)) v' x) = - IS_SOME (some x. PMATCH_ROW_COND p g v x)` by ALL_TAC THEN1 ( - ASM_SIMP_TAC std_ss [some_IS_SOME, PMATCH_ROW_COND_def] THEN - EQ_TAC THEN1 PROVE_TAC[] THEN - REPEAT STRIP_TAC THEN - `?x'. f x' = x` by PROVE_TAC[] THEN - Q.EXISTS_TAC `x'` THEN - ASM_REWRITE_TAC[] +Cases_on `i = LENGTH infos` THEN1 ( + ASM_SIMP_TAC list_ss [SNOC_APPEND, EL1_STRONGEST_REDUNDANT_ROWS_INFO_AUX, rich_listTheory.EL_APPEND2] ) THEN -Tactical.REVERSE (Cases_on `IS_SOME (some x. PMATCH_ROW_COND p g v x)`) THEN ( - FULL_SIMP_TAC std_ss [] +Q.PAT_ASSUM `!p infos. _` (MP_TAC o Q.SPECL [ + `p /\ (h (v:'a) = NONE)`, `SNOC (p ==> (h (v:'a) = NONE)) infos`, `i`]) THEN +ASM_SIMP_TAC list_ss [SNOC_APPEND, GSYM arithmeticTheory.ADD1] THEN +REPEAT STRIP_TAC THEN +ASM_SIMP_TAC (std_ss++boolSimps.EQUIV_EXTRACT_ss) [] THEN +REPEAT STRIP_TAC THEN +`(i − LENGTH infos) = SUC (i − SUC (LENGTH infos))` by DECIDE_TAC THEN +ASM_SIMP_TAC list_ss []) + + +val LENGTH_STRONGEST_REDUNDANT_ROWS_INFO = store_thm ( + "LENGTH_STRONGEST_REDUNDANT_ROWS_INFO", + ``LENGTH (STRONGEST_REDUNDANT_ROWS_INFO v rows) = LENGTH rows``, + +SIMP_TAC list_ss [STRONGEST_REDUNDANT_ROWS_INFO_def, + LENGTH_STRONGEST_REDUNDANT_ROWS_INFO_AUX]) + +val FST_STRONGEST_REDUNDANT_ROWS_INFO_AUX = store_thm ( + "FST_STRONGEST_REDUNDANT_ROWS_INFO_AUX", + ``!v rows p infos. + FST (STRONGEST_REDUNDANT_ROWS_INFO_AUX v rows p infos) = + (p /\ EVERY (\r. r v = NONE) rows)``, + +Induct_on `rows` THEN ( + ASM_SIMP_TAC (list_ss++boolSimps.EQUIV_EXTRACT_ss) [STRONGEST_REDUNDANT_ROWS_INFO_AUX_def] +)) + +val EL_STRONGEST_REDUNDANT_ROWS_INFO = store_thm ( + "EL_STRONGEST_REDUNDANT_ROWS_INFO", + ``!v rows p infos i. + (i < LENGTH rows) ==> + (EL i (STRONGEST_REDUNDANT_ROWS_INFO v rows) = + ((EVERY (\r. r v = NONE) (TAKE i rows)) ==> + ((EL i rows) v = NONE)))``, + +SIMP_TAC list_ss [STRONGEST_REDUNDANT_ROWS_INFO_def, + EL2_STRONGEST_REDUNDANT_ROWS_INFO_AUX]) + + +val STRONGEST_REDUNDANT_ROWS_INFO_OK = store_thm ("STRONGEST_REDUNDANT_ROWS_INFO_OK", + + ``IS_REDUNDANT_ROWS_INFO v rows (EVERY (\r. r v = NONE) rows) + (STRONGEST_REDUNDANT_ROWS_INFO v rows)``, + +SIMP_TAC std_ss [IS_REDUNDANT_ROWS_INFO_def, + EL_STRONGEST_REDUNDANT_ROWS_INFO, + LENGTH_STRONGEST_REDUNDANT_ROWS_INFO, + PMATCH_ROW_REDUNDANT_def] THEN +REPEAT STRIP_TAC THEN +Cases_on `EL i rows v` THEN1 ( + FULL_SIMP_TAC list_ss [] ) THEN -FULL_SIMP_TAC std_ss [some_IS_SOME_EXISTS] THEN -FULL_SIMP_TAC std_ss [PMATCH_ROW_COND_def] THEN -METIS_TAC[]); +FULL_SIMP_TAC list_ss [EXISTS_MEM] THEN +Tactical.REVERSE (`?j. j < i /\ (EL j rows = e)` by ALL_TAC) THEN1 ( + Q.EXISTS_TAC `j` THEN + ASM_SIMP_TAC std_ss [] THEN + Cases_on `e v` THEN FULL_SIMP_TAC std_ss [] +) THEN +Q.PAT_ASSUM `MEM e _` MP_TAC THEN +ASM_SIMP_TAC (list_ss++boolSimps.CONJ_ss) [MEM_EL,rich_listTheory.EL_TAKE] THEN +PROVE_TAC[]) + + + + +val PMATCH_ROW_COND_EX_WEAKEN = store_thm ("PMATCH_ROW_COND_EX_WEAKEN", +``!f v p g p' g'. + + ~(PMATCH_ROW_COND_EX v p g) ==> + (!x. p' x = p (f x)) ==> + (PMATCH_ROW_COND_EX v p' g' = + PMATCH_ROW_COND_EX v p' (\x. g' x /\ ~(g (f x))))``, + +SIMP_TAC std_ss [PMATCH_ROW_COND_EX_def, PMATCH_ROW_COND_def] THEN +REPEAT STRIP_TAC THEN +CONSEQ_CONV_TAC (K EXISTS_EQ___CONSEQ_CONV) THEN +SIMP_TAC (std_ss++boolSimps.EQUIV_EXTRACT_ss) [] THEN +METIS_TAC[]) + +val PMATCH_ROW_COND_EX_FALSE = store_thm ("PMATCH_ROW_COND_EX_FALSE", +``!v p g. + (!x. ~(g x)) ==> + (PMATCH_ROW_COND_EX v p g = F)``, + +SIMP_TAC std_ss [PMATCH_ROW_COND_EX_def, PMATCH_ROW_COND_def]) + +val PMATCH_ROW_COND_EX_IMP_REWRITE = store_thm ("PMATCH_ROW_COND_EX_IMP_REWRITE", +``!v p g p' g' RES. + PMATCH_ROW_COND_EX v p g ==> + (!x. g x ==> ((?x'. (p' x' = p x) /\ g' x') = RES)) ==> + (PMATCH_ROW_COND_EX v p' g' = RES)``, + +SIMP_TAC std_ss [PMATCH_ROW_COND_EX_def, PMATCH_ROW_COND_def, + GSYM LEFT_FORALL_IMP_THM]) (***************************************************) @@ -1039,29 +1179,6 @@ Cases_on `?x. PMATCH_ROW_COND p g v x` THENL [ METIS_TAC[] ]) - -val PMATCH_PRED_UNROLL_CONS = store_thm ("PMATCH_PRED_UNROLL_CONS", -``!P v p g r rows. - (!x1 x2. (g x1 /\ g x2 /\ (p x1 = p x2)) ==> (x1 = x2)) ==> - - (P (PMATCH v ((PMATCH_ROW p g r)::rows)) <=> - (!x. ((v = p x) /\ g x) ==> P (r x)) /\ - ((!x. (v = p x) ==> ~(g x)) ==> P (PMATCH v rows)))``, - -SIMP_TAC (std_ss++boolSimps.EQUIV_EXTRACT_ss) [PMATCH_PRED_UNROLL_CONS_NO_INJ, GSYM LEFT_FORALL_IMP_THM] THEN -REPEAT STRIP_TAC THEN -CONSEQ_CONV_TAC (K FORALL_EQ___CONSEQ_CONV) THEN -SIMP_TAC (std_ss++boolSimps.EQUIV_EXTRACT_ss) [] THEN -REPEAT STRIP_TAC THEN -Tactical.REVERSE (`(@x'. PMATCH_ROW_COND p g v x') = x` by ALL_TAC) THEN1 ( - POP_ASSUM MP_TAC THEN - ASM_SIMP_TAC std_ss [] -) THEN -SELECT_ELIM_TAC THEN -SIMP_TAC std_ss [PMATCH_ROW_COND_def] THEN -METIS_TAC[]); - - val _ = export_theory();; diff --git a/examples/deep_matches/deepMatchesSyntax.sig b/examples/deep_matches/deepMatchesSyntax.sig index 2c3ec02977..f0616d9d1e 100644 --- a/examples/deep_matches/deepMatchesSyntax.sig +++ b/examples/deep_matches/deepMatchesSyntax.sig @@ -2,22 +2,12 @@ signature deepMatchesSyntax = sig include Abbrev - val PMATCH_tm : term - val PMATCH_ROW_tm : term - - (* auxiliary function that introduces fresh - typevars for all type-vars used by - free vars of a thm *) - val FRESH_TY_VARS_RULE : rule - - (* transforms a term to a alpha-equivalent - one that does not use the same variable name in - different bindings in the term. *) - val REMOVE_REBIND_CONV : conv (******************) (* PMATCH_ROW *) (******************) + + val PMATCH_ROW_tm : term (* dest_PMATCH_ROW ``PMATCH_ROW p g r`` returns (``p``, ``g``, ``r``). *) @@ -29,7 +19,7 @@ sig ``PMATCH_ROW p g rh``. *) val mk_PMATCH_ROW : term * term * term -> term - (* [mk_PMATCH_ROW vars (p, g, rh)] constructs the term + (* [mk_PMATCH_ROW_PABS vars (p, g, rh)] constructs the term ``PMATCH_ROW (\vars. p) (\vars. g) (\vars. rh)``. *) val mk_PMATCH_ROW_PABS : term list -> term * term * term -> term @@ -78,10 +68,13 @@ sig val PMATCH_ROW_INTRO_WILDCARDS_CONV : conv val PMATCH_INTRO_WILDCARDS_CONV : conv + (******************) (* PMATCH *) (******************) + val PMATCH_tm : term + (* [dest_PMATCH ``PMATCH v rows``] returns (``v``, ``rows``). *) val dest_PMATCH : term -> (term * term list) @@ -94,11 +87,39 @@ sig the free variables in the pattern and the column of the pattern for each row. *) val dest_PMATCH_COLS : term -> (term * (term list * term) list) list + + (* internally, the columns come from a list of atterns. Sometimes + this interface is useful as well. *) + val dest_PATLIST_COLS : term -> term list -> (term * (term list * term) list) list (* applies a conversion to all rows of a pmatch *) val PMATCH_ROWS_CONV : conv -> conv + (*******************) + (* PMATCH_ROW_COND *) + (*******************) + + val PMATCH_ROW_COND_tm : term + val dest_PMATCH_ROW_COND : term -> (term * term * term * term) + val is_PMATCH_ROW_COND : term -> bool + val mk_PMATCH_ROW_COND : term * term * term * term -> term + val mk_PMATCH_ROW_COND_PABS : term list -> term * term * term * term -> term + val dest_PMATCH_ROW_COND_ABS : term -> (term * term * term * term * term) + + val PMATCH_ROW_COND_EX_tm : term + val dest_PMATCH_ROW_COND_EX : term -> term * term * term + val dest_PMATCH_ROW_COND_EX_ABS : term -> term * term * term * term + val is_PMATCH_ROW_COND_EX : term -> bool + val mk_PMATCH_ROW_COND_EX : term * term * term -> term + val mk_PMATCH_ROW_COND_EX_PABS : term list -> term * term * term -> term + val mk_PMATCH_ROW_COND_EX_pat : term -> term -> term + val mk_PMATCH_ROW_COND_EX_ROW : term -> term -> term + + val PMATCH_ROW_COND_EX_INTRO_CONV : term -> conv + val nchotomy2PMATCH_ROW_COND_EX_CONV : conv + val PMATCH_ROW_COND_EX_ELIM_CONV : conv + (******************) (* Pretty printer *) (******************) @@ -118,4 +139,101 @@ sig one can be used however. If the trace "parse deep cases" is set to true, standard case-expressions are parsed to deep-matches, otherwise the default state-expressions. *) + + + (**************************) + (* Labels (see markerLib) *) + (**************************) + + (* strips multiple applications of labels *) + val strip_labels : term -> string list * term + + (* add a list of labels to a term *) + val add_labels_CONV : string list -> conv + + (* apply a conversion under a sequence + of labels *) + val strip_labels_CONV : conv -> conv + + (* similar to [strip_labels_CONV] but fails if not at least + one of the stripped labels has a lbl in the given list *) + val guarded_strip_labels_CONV : + string list -> conv -> conv + + + (*******************) + (* Auxiliary stuff *) + (*******************) + + (* [pick_element p l] gets the first element of l that satisfies p + and removes this occurence from the list. + If no such element exists, the function fails. *) + val pick_element : ('a -> bool) -> ('a list) -> 'a * 'a list + + (* [has_subterm p t] checks whether [t] has a subterm satisfying + predicate [p]. *) + val has_subterm : (term -> bool) -> term -> bool + + (* Like [prove], but quiet in case it fails. This is useful, + when trying to prove things and are not sure, whether they + hold. *) + val prove_attempt : term * tactic -> thm + + (* List strip_comb, but with a maximum bound. *) + val strip_comb_bounded : int -> term -> term * term list + + (* auxiliary function that introduces fresh + typevars for all type-vars used by + free vars of a thm *) + val FRESH_TY_VARS_RULE : rule + + (* transforms a term to a alpha-equivalent + one that does not use the same variable name in + different bindings in the term. *) + val REMOVE_REBIND_CONV : conv + + (* strips lambda abstractions *) + val STRIP_ABS_CONV : conv -> conv + + (* strip a large disjunction and apply a conversion to all + leafs. *) + val ALL_DISJ_CONV : conv -> conv + + (* strip a large disjunction and apply a conversion to all + leafs. Eliminate T and F from the resulting term by + applying rewrites. This might be more efficient than + ALL_DISJ_CONV, since it stops, once a T-disjunct is found. *) + val ALL_DISJ_TF_ELIM_CONV : conv -> conv + + (* strip a large conjunction and apply a conversion to all + leafs. *) + val ALL_CONJ_CONV : conv -> conv + + (* [DECEND_CONV c_desc c] applies [c] and then uses + [c_desc] to descend into the result via [c_desc] and + repeat. *) + val DECEND_CONV : (conv -> conv) -> conv -> conv + + (* Apply a conversion to all elements of a list (build + only by cons and nil) *) + val list_CONV : conv -> conv + + (* Apply a conversion to the nth elements of a list. + Counting starts with 0. *) + val list_nth_CONV : int -> conv -> conv + + (* Given a prefix [pr] and a list of variables to avoid [avoid], + [mk_var_gen pr avoid] generates a variable generator that + generates variable, whose name starts with [pr] and who + are all distinct to each other and the vars in list [avoid]. *) + val mk_var_gen : string -> term list -> (hol_type -> term) + + (* Given a prefix [pr], [mk_new_label_gen pr] generate a string + generator for strings starting with [pr], which are all distinct + from each other *) + val mk_new_label_gen : string -> (unit -> string) + + + + end diff --git a/examples/deep_matches/deepMatchesSyntax.sml b/examples/deep_matches/deepMatchesSyntax.sml index 784171578d..73db8b6c5b 100644 --- a/examples/deep_matches/deepMatchesSyntax.sml +++ b/examples/deep_matches/deepMatchesSyntax.sml @@ -4,8 +4,13 @@ struct open HolKernel Parse boolLib bossLib open deepMatchesTheory open pairSyntax +open ConseqConv +(***********************************************) +(* Auxiliary stuff *) +(***********************************************) + (* Stolen from pairTools. TODO: add it to interface there. *) fun variant_of_term vs t = @@ -32,11 +37,22 @@ in String.sub(s, 0) = #"_" end handle HOL_ERR _ => false -fun mk_wildcard_gen avoid = let +fun mk_new_label_gen prefix = let + val c = ref 0 +in + fn () => let + val l = prefix ^ int_to_string (!c) + val _ = c := !c + 1 + in + l + end +end + +fun mk_var_gen prefix avoid = let val c = ref 0 val avoidL = List.map (fst o dest_var) avoid fun next_name () = let - val vn = "_" ^ (int_to_string (!c)) + val vn = prefix ^ (int_to_string (!c)) val _ = c := !c + 1 val ok = not (mem vn avoidL) in @@ -46,6 +62,137 @@ in fn ty => mk_var (next_name (), ty) end +fun mk_wildcard_gen avoid = mk_var_gen "_" avoid + + +(* Get the first element of l that satisfies p and + move it to the first position. *) +fun pick_element p l = let + fun aux acc l = + case l of + [] => failwith "no element found" + | e::l => (if p e then (e, List.rev acc @ l) + else aux (e::acc) l) + in + aux [] l + end + +fun strip_comb_bounded_aux acc n t = if (n > 0) then (let + val (t', a) = dest_comb t + in + strip_comb_bounded_aux (a::acc) (n - 1) t' +end handle HOL_ERR _ => (t, acc)) else (t, acc) + +fun strip_comb_bounded n t = strip_comb_bounded_aux [] n t + +fun ALL_DISJ_CONV c t = if (is_disj t) then ( + (BINOP_CONV (ALL_DISJ_CONV c)) t +) else (TRY_CONV c) t + +fun ALL_DISJ_TF_ELIM_CONV c t = let + val (t1, t2) = dest_disj t +in + if (aconv t1 T) then + SPEC t2 (ConseqConvTheory.OR_CLAUSES_TX) + else if (aconv t2 T) then + SPEC t1 (ConseqConvTheory.OR_CLAUSES_XT) + else let + val thm1_opt = SOME (ALL_DISJ_TF_ELIM_CONV c t1) handle UNCHANGED => NONE + val thm1_opt_eq_T = case thm1_opt of + NONE => false + | SOME thm1 => (aconv (rhs (concl thm1)) T) + val thm2_opt = if thm1_opt_eq_T then NONE else SOME (ALL_DISJ_TF_ELIM_CONV c t2) handle UNCHANGED => NONE + + val thm0 = case (thm1_opt, thm2_opt) of + (NONE, NONE) => raise UNCHANGED + | (SOME thm1, NONE) => RATOR_CONV (RAND_CONV (K thm1)) t + | (NONE, SOME thm2) => RAND_CONV (K thm2) t + | (SOME thm1, SOME thm2) => ( + (RATOR_CONV (RAND_CONV (K thm1))) THENC + (RAND_CONV (K thm2))) t + + val (t1', t2') = dest_disj (rhs (concl thm0)) + + val rewr_thm_opt = if (aconv t1' T) then + SOME (ConseqConvTheory.OR_CLAUSES_TX) + else if (aconv t1' F) then + SOME (ConseqConvTheory.OR_CLAUSES_FX) + else if (aconv t2' T) then + SOME (ConseqConvTheory.OR_CLAUSES_XT) + else if (aconv t2' F) then + SOME (ConseqConvTheory.OR_CLAUSES_XF) + else NONE + + val thm1 = case rewr_thm_opt of + NONE => thm0 + | SOME thm_rw => RIGHT_CONV_RULE (REWR_CONV thm_rw) thm0 + in + thm1 + end +end handle HOL_ERR _ => (TRY_CONV c) t + + + + +fun ALL_CONJ_CONV c t = if (is_conj t) then ( + (BINOP_CONV (ALL_CONJ_CONV c)) t +) else (TRY_CONV c) t + +fun DECEND_CONV c_desc c t = + (c THENC TRY_CONV (c_desc (DECEND_CONV c_desc c))) t + +fun STRIP_ABS_CONV conv t = + if (is_abs t) then ABS_CONV (STRIP_ABS_CONV conv) t else + conv t + +fun has_subterm p t = ((find_term p t; true) handle HOL_ERR _ => false) + +(* like proof, but less verbose, since we expect that it might fail *) +val prove_attempt = Lib.with_flag (Feedback.emit_MESG, false) prove + +(***********************************************) +(* Labels from markerLib *) +(***********************************************) + +fun add_labels_CONV lbls t = let + val lbl_tm = List.foldl markerSyntax.mk_label t lbls +in + GSYM ((REPEATC markerLib.DEST_LABEL_CONV) lbl_tm) +end + +(* + val mk_new_label = mk_new_label_generator "disj" + val lbl_tm = markerSyntax.mk_label (mk_new_label (), lbl_tm) + val t = lbl_tm +*) + +fun strip_labels t = let + fun aux acc t = let + val (l, t') = markerSyntax.dest_label t + in + aux (l::acc) t' + end handle HOL_ERR _ => (List.rev acc, t) +in + aux [] t +end + +(* conversion underneath a list of labels *) +fun strip_labels_CONV c t = + if (markerSyntax.is_label t) then + RAND_CONV (strip_labels_CONV c) t + else + c t + +(* conversion underneath a list of labels containing at least + one label from list [lbls]. *) +fun guarded_strip_labels_CONV lbls c t = let + val (lbls_found, _) = strip_labels t + val found = List.exists (fn l1 => List.exists (fn l2 => (l1 = l2)) lbls) lbls_found +in + if not found then raise UNCHANGED else + strip_labels_CONV c t +end + (***********************************************) (* Terms *) @@ -66,6 +213,12 @@ val ty_var_subst = [alpha |-> gen_tyvar (), val PMATCH_ROW_tm = ``PMATCH_ROW`` val PMATCH_ROW_gtm = inst ty_var_subst PMATCH_ROW_tm; +val PMATCH_ROW_COND_tm = ``PMATCH_ROW_COND`` +val PMATCH_ROW_COND_gtm = inst ty_var_subst PMATCH_ROW_COND_tm; + +val PMATCH_ROW_COND_EX_tm = ``PMATCH_ROW_COND_EX`` +val PMATCH_ROW_COND_EX_gtm = inst ty_var_subst PMATCH_ROW_COND_EX_tm; + val PMATCH_tm = ``PMATCH`` val PMATCH_gtm = inst ty_var_subst PMATCH_tm @@ -110,15 +263,17 @@ fun is_PMATCH_ROW t = can dest_PMATCH_ROW t fun mk_PMATCH_ROW (p_t, g_t, r_t) = list_mk_icomb (PMATCH_ROW_gtm, [p_t, g_t, r_t]) -fun mk_PMATCH_ROW_PABS vars (p_t, g_t, r_t) = let - val mk_pabs = case vars of +fun mk_pabs_from_vars vars tl = case vars of [] => let - val uv = variant (free_varsl [p_t, g_t, r_t]) ``uv:unit`` + val uv = variant (free_varsl tl) ``uv:unit`` in fn t => mk_abs (uv, t) end | [v] => (fn t => mk_abs (v, t)) | _ => (fn t => pairSyntax.mk_pabs (pairSyntax.list_mk_pair vars, t)) + +fun mk_PMATCH_ROW_PABS vars (p_t, g_t, r_t) = let + val mk_pabs = mk_pabs_from_vars vars [p_t, g_t, r_t] in mk_PMATCH_ROW (mk_pabs p_t, mk_pabs g_t, mk_pabs r_t) end @@ -259,17 +414,15 @@ end fun is_PMATCH t = can dest_PMATCH t -fun dest_PMATCH_COLS t = let - val (v, rows) = dest_PMATCH t - - fun split_row r = let - val (vars_tm, pt, gt, rh) = dest_PMATCH_ROW_ABS r +fun dest_PATLIST_COLS v ps = let + fun split_pat p = let + val (vars_tm, pt) = pairSyntax.dest_pabs p val vars = pairSyntax.strip_pair vars_tm val pts = pairSyntax.strip_pair pt in List.map (fn x => (vars, x)) pts end - val rows' = map split_row rows + val rows' = map split_pat ps val col_no = length (hd rows') fun aux acc v col_no = if (col_no <= 1) then List.rev (v::acc) else ( @@ -294,13 +447,27 @@ fun dest_PMATCH_COLS t = let val cols = get_cols [] vs rows' in cols -end handle Empty => failwith "dest_PMATCH_COLS" +end handle Empty => failwith "dest_PATLIST_COLS" + + +fun dest_PMATCH_COLS t = let + val (v, rows) = dest_PMATCH t + val ps = List.map (#1 o dest_PMATCH_ROW) rows +in + dest_PATLIST_COLS v ps +end fun list_CONV c t = if not (listSyntax.is_cons t) then raise UNCHANGED else ( (RATOR_CONV (RAND_CONV c) THENC RAND_CONV (list_CONV c)) t) +fun list_nth_CONV n c t = + if not (listSyntax.is_cons t) then raise UNCHANGED else + if (n < 0) then raise UNCHANGED else + if (n = 0) then RATOR_CONV (RAND_CONV c) t else + (RAND_CONV (list_nth_CONV (n-1) c)) t + fun PMATCH_ROWS_CONV c t = let val _ = if not (is_PMATCH t) then raise UNCHANGED else () in @@ -314,6 +481,136 @@ val PMATCH_INTRO_WILDCARDS_CONV = PMATCH_ROWS_CONV PMATCH_ROW_INTRO_WILDCARDS_CONV +(***********************************************) +(* PMATCH_ROW_COND *) +(***********************************************) + +fun dest_PMATCH_ROW_COND rc = let + val (f, args) = strip_comb rc + val _ = if (same_const f PMATCH_ROW_COND_tm) andalso (List.length args = 4) then () else failwith "dest_PMATCH_ROW_COND" +in + (el 1 args, el 2 args, el 3 args, el 4 args) +end + +fun is_PMATCH_ROW_COND t = can dest_PMATCH_ROW_COND t + +fun mk_PMATCH_ROW_COND (p_t, g_t, i, x) = + list_mk_icomb (PMATCH_ROW_COND_gtm, [p_t, g_t, i, x]) + +fun mk_PMATCH_ROW_COND_PABS vars (p_t, g_t, i, x) = let + val mk_pabs = mk_pabs_from_vars vars [p_t, g_t, x] + in + mk_PMATCH_ROW_COND (mk_pabs p_t, mk_pabs g_t, i, x) + end + +fun dest_PMATCH_ROW_COND_ABS rc = let + val (p_t, g_t, i_t, x_t) = dest_PMATCH_ROW_COND rc + + val (p_vars, p_body) = pairSyntax.dest_pabs p_t + val (g_vars, g_body) = pairSyntax.dest_pabs g_t + + val _ = if (aconv p_vars g_vars) then + () else failwith "dest_PMATCH_ROW_COND_ABS" +in + (p_vars, p_body, g_body, i_t, x_t) +end + + +(***********************************************) +(* PMATCH_ROW_COND_EX *) +(***********************************************) + +fun dest_PMATCH_ROW_COND_EX rc = let + val (f, args) = strip_comb rc + val _ = if (same_const f PMATCH_ROW_COND_EX_tm) andalso (List.length args = 3) then () else failwith "dest_PMATCH_ROW_COND_EX" +in + (el 1 args, el 2 args, el 3 args) +end + +fun is_PMATCH_ROW_COND_EX t = can dest_PMATCH_ROW_COND_EX t + +fun mk_PMATCH_ROW_COND_EX (i, p_t, g_t) = + list_mk_icomb (PMATCH_ROW_COND_EX_gtm, [i, p_t, g_t]) + +fun mk_PMATCH_ROW_COND_EX_PABS vars (i, p_t, g_t) = let + val mk_pabs = mk_pabs_from_vars vars [p_t, g_t] + in + mk_PMATCH_ROW_COND_EX (i, mk_pabs p_t, mk_pabs g_t) + end + +fun mk_PMATCH_ROW_COND_EX_pat i p = let + val (vars, _) = pairSyntax.dest_pabs p + val g = pairSyntax.mk_pabs (vars, T) + in + mk_PMATCH_ROW_COND_EX (i, p, g) + end + +fun mk_PMATCH_ROW_COND_EX_ROW i r = let + val (p, g, _) = dest_PMATCH_ROW r + in + mk_PMATCH_ROW_COND_EX (i, p, g) + end + +fun dest_PMATCH_ROW_COND_EX_ABS rc = let + val (i_t, p_t, g_t) = dest_PMATCH_ROW_COND_EX rc + + val (p_vars, p_body) = pairSyntax.dest_pabs p_t + val (g_vars, g_body) = pairSyntax.dest_pabs g_t + + val _ = if (aconv p_vars g_vars) then + () else failwith "dest_PMATCH_ROW_COND_EX_ABS" +in + (i_t, p_vars, p_body, g_body) +end + + +(* +val t = (el 4 o strip_disj o snd o strip_forall o concl) thm +val v = (fst o dest_forall o concl) thm +*) + +fun PMATCH_ROW_COND_EX_INTRO_CONV v t = let + val (vs, b) = strip_exists t + val b_conjs = strip_conj b + val (peq_t, guards) = pick_element (fn c => (aconv (lhs c) v handle HOL_ERR _ => false)) b_conjs + + val p_t = rhs peq_t + val g_t = if List.null guards then T else list_mk_conj guards + + val rc = mk_PMATCH_ROW_COND_EX_PABS vs (v, p_t, g_t) + + val rc_eq_tm = mk_eq (t, rc) + (* set_goal ([], rc_eq_tm) *) + val rc_eq_thm = prove (rc_eq_tm, + SIMP_TAC std_ss [PMATCH_ROW_COND_EX_def, PMATCH_ROW_COND_def, pairTheory.EXISTS_PROD] THEN + TRY (REDEPTH_CONSEQ_CONV_TAC (K EXISTS_EQ___CONSEQ_CONV)) THEN + SIMP_TAC (std_ss++boolSimps.EQUIV_EXTRACT_ss) [] + ) +in + rc_eq_thm +end + + +fun nchotomy2PMATCH_ROW_COND_EX_CONV t = let + val (v, _) = dest_forall t +in + (QUANT_CONV (ALL_DISJ_CONV (PMATCH_ROW_COND_EX_INTRO_CONV v))) t +end + +fun PMATCH_ROW_COND_EX_ELIM_CONV t = let + val (_, p_t, _) = dest_PMATCH_ROW_COND_EX t + val (vars, _) = pairSyntax.dest_pabs p_t + + val thm0 = REWR_CONV PMATCH_ROW_COND_EX_FULL_DEF t + val thm1 = RIGHT_CONV_RULE (RAND_CONV (pairTools.PABS_INTRO_CONV vars)) thm0 + val thm2 = RIGHT_CONV_RULE pairTools.ELIM_TUPLED_QUANT_CONV thm1 handle HOL_ERR _ => thm1 + val thm3 = RIGHT_CONV_RULE (STRIP_QUANT_CONV (DEPTH_CONV pairLib.GEN_BETA_CONV)) thm2 + val thm4 = RIGHT_CONV_RULE (PURE_REWRITE_CONV [AND_CLAUSES]) thm3 +in + thm4 +end + + (***********************************************) (* Pretty Printing *) @@ -393,7 +690,6 @@ fun pmatch_printer GS backend sys (ppfns:term_pp_types.ppstream_funs) gravs d t val _ = temp_add_user_printer ("PMATCH", ``PMATCH v l``, pmatch_printer); - (***********************************************) (* Parser *) (***********************************************) From 60c1b2eed18e39802fb80ee1983c00cdbd77b36c Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 25 Mar 2015 09:38:40 +1100 Subject: [PATCH 252/718] Improve spacing by putting big session into figure The HolQbf section includes a session that is really too large to be in the normal flow of paragraphs. --- Manual/Description/HolQbf.tex | 3 +++ 1 file changed, 3 insertions(+) diff --git a/Manual/Description/HolQbf.tex b/Manual/Description/HolQbf.tex index 1cbf063736..d2e31489f8 100644 --- a/Manual/Description/HolQbf.tex +++ b/Manual/Description/HolQbf.tex @@ -65,6 +65,7 @@ \subsection{Interface} Finally, \ml{decide} does the same job as \ml{decide\_prenex} but accepts QBFs in a less restricted form. Restrictions on $\phi$ are described below. +\begin{figure} \begin{session} \begin{verbatim} - load "HolQbfLib"; @@ -110,6 +111,8 @@ \subsection{Interface} - val it = [] |- ?x. x: thm \end{verbatim} \end{session} +\caption{\ml{HolQbfLib} in action.} +\end{figure} \paragraph{Supported subset of higher-order logic} The argument given to \ml{decide} must be a Boolean term built using only conjunction, disjunction, implication, negation, universal/existential quantification, and variables. Free variables are considered universally quantified. Every quantified variable must occur. From d8207408e3634647da9a7d3c21b5aafbae4ce82d Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 25 Mar 2015 09:56:10 +1100 Subject: [PATCH 253/718] Minor tweaks and typo corrections in holindex docs --- Manual/Description/misc.tex | 25 +++++++++++++------------ 1 file changed, 13 insertions(+), 12 deletions(-) diff --git a/Manual/Description/misc.tex b/Manual/Description/misc.tex index c3aac46b4b..03e6f9ee2f 100644 --- a/Manual/Description/misc.tex +++ b/Manual/Description/misc.tex @@ -1503,15 +1503,15 @@ \subsection{Holindex} \end{description} -\paragraph{Defining and formating Terms, Types and Theorems} +\paragraph{Defining and Formatting Terms, Types and Theorems} Most of the Holindex commands require an identifier of a theorem, term or type as arguments. Theorem identifiers of the form \texttt{theory.theorem} are predefined. All other identifiers need defining. Additionally one might want to change the default - formating options for these new identifiers as well as the old ones. + formatting options for these new identifiers as well as the old ones. \HOL{} definition files can be used for defining and - setting the formating options of identifiers. They are used by + setting the formatting options of identifiers. They are used by putting the command \texttt{\bs{}useHOLfile\{\textit{filename.hdf}\}} in the header of your latex source file. These file use a syntax similar to BibTex. They consist of a list of entries of the form @@ -1536,13 +1536,14 @@ \subsection{Holindex} used to define and format a term. \item[\texttt{Type}] used to define and format a type. - \item[\texttt{Thms}, \texttt{Theorems}] used to set formating options for + \item[\texttt{Thms}, \texttt{Theorems}] used to set formatting options for a list of theorems. For example one might want to print long index entries for all theorems in a specific theory. For the \texttt{Theorems} entry the \texttt{id} part of the entry is given in the form \texttt{ids = [id,id,...]}. These \texttt{ids} may be theorem ids or special - ids of the form \texttt{theorem.thmprefix*}. The id - \texttt{arithmetic.LESS\_EQ*} for example represents all theorem in + ids of the form \texttt{theorem.thmprefix*}. + For example, the id + \texttt{arithmetic.LESS\_EQ*} represents all theorems in theory \texttt{arithmetic} whose name starts with \texttt{LESS\_EQ}. \end{description} Options are name/value pairs. The value has to be quoted using @@ -1550,23 +1551,23 @@ \subsection{Holindex} option names available: \begin{description} \item[\texttt{content}] - the content. For a term or type that's it's \HOL{}\ definition. + the content. For a term or type that's its \HOL{}\ definition. For theorems it is of the form \texttt{theory.theorem}. \item[\texttt{options}] - formating options for the munger as described in section~\ref{sec:munging-commands}. + formatting options for the munger as described in section~\ref{sec:munging-commands}. Please use the Holindex commands for typsetting inline or as a block instead of the options \texttt{tt} or \texttt{alltt}. \item[\texttt{label}] the label that will appear in the index. For - theorems the label is by default it's name and the label given here + theorems the label is by default its name and the label given here will be added after the name. - \item[\texttt{comment}] latex code that gets typeset as a comment / description + \item[\texttt{comment}] \LaTeX{} code that gets typeset as a comment / description for long index entries. - \item[\texttt{latex}] the latex code for the item. There are very rare cases, + \item[\texttt{latex}] the \LaTeX{} code for the item. There are very rare cases, when it might be useful to provide handwritten \LaTeX{} code instead of the one generated by the munger. This option overrides the \LaTeX{} produced by the munger. It is recommended to use it very carefully. \end{description} -Besides options, there are also boolean flags that change the formating of entries: +Besides options, there are also boolean flags that change the formatting of entries: \begin{description} \item[\texttt{force-index}] adds the entry to the index, even if it is not cited in the document. From 4532a4eff0b4db97f62c7e7484cf0083959c7a51 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 25 Mar 2015 10:31:03 +1100 Subject: [PATCH 254/718] Document use of suffixes for closures in relationTheory --- Manual/Description/libraries.tex | 8 ++--- Manual/Description/theories.tex | 58 ++++++++++++++++++-------------- 2 files changed, 36 insertions(+), 30 deletions(-) diff --git a/Manual/Description/libraries.tex b/Manual/Description/libraries.tex index 496ec5a2d7..946ed82cfe 100644 --- a/Manual/Description/libraries.tex +++ b/Manual/Description/libraries.tex @@ -774,9 +774,9 @@ \subsubsection{Fixities} \paragraph{Suffixes} -Suffixes appear after their arguments. There are no suffixes -introduced into the standard theories available in \HOL{}, but users -are always able to introduce their own if they choose. Suffixes are +Suffixes appear after their arguments. +There are suffixes \holtxt{\^{}+}, \holtxt{\^{}*} and \holtxt{\^{}=} corresponding to the transitive, the reflexive and transitive, and the ``equivalence'' closure used in \ml{relationTheory} (Section~\ref{relation}). +Suffixes are associated with a precedence just as infixes and prefixes are. If \holtxt{p} is a prefix, \holtxt{i} an infix, and \holtxt{s} a suffix, then there are six possible orderings for the three different @@ -2826,7 +2826,7 @@ \subsubsection{Embedding code} When an embedded reducer is applied to a term, the provided \ml{apply} function is called. As well as the term to be transformed, the \ml{apply} function is also passed a record containing a -side-condition solver, a more general call-back to the simplifier, +side-condition solver, a more general call-back to the simplifier, the decision procedure's current context, and the stack of side-conditions attempted so far. The stack and solver are the same as the additional arguments provided to user-supplied diff --git a/Manual/Description/theories.tex b/Manual/Description/theories.tex index 1b64f31b65..a7a9cb0ae9 100644 --- a/Manual/Description/theories.tex +++ b/Manual/Description/theories.tex @@ -4250,18 +4250,22 @@ \subsection{Relations (\theoryimp{relation})}\label{relation} The transitive closure (\holtxt{TC}) of a relation $R : \alpha \to\alpha\to\konst{bool}$ is defined inductively, as the least -relation including $R$ and closed under transitivity. Similarly, the +relation including $R$ and closed under transitivity. +Similarly, the reflexive-transitive closure (\holtxt{RTC}) is defined to be the least relation closed under transitivity and reflexivity. +The ASCII syntax for the transitive closure \holtxt{R\^{}+} is meant to suggest the prettier \holtxt{R${}^+$}. +Similarly, \holtxt{R\^{}*} is meant to suggest \holtxt{R${}^*$}. +Indeed, with Unicode enabled, transitive closure will print with a superscript \texttt{+}. % \begin{hol} \begin{verbatim} TC_DEF - |- TC R a b = + |- R^+ a b = !P. (!x y. R x y ==> P x y) /\ (!x y z. P x y /\ P y z ==> P x z) ==> P a b RTC_DEF - |- RTC R a b = + |- R^* a b = !P. (!x. P x x) /\ (!x y z. R x y /\ P y z ==> P x z) ==> P a b \end{verbatim} @@ -4273,47 +4277,47 @@ \subsection{Relations (\theoryimp{relation})}\label{relation} \begin{hol} \begin{verbatim} TC_RULES - |- !R. (!x y. R x y ==> TC R x y) /\ - (!x y z. TC R x y /\ TC R y z ==> TC R x z) + |- !R. (!x y. R x y ==> R^+ x y) /\ + (!x y z. R^+ x y /\ R^+ y z ==> R^+ x z) RTC_RULES - |- !R. (!x. RTC R x x) /\ - (!x y z. R x y /\ RTC R y z ==> RTC R x z) + |- !R. (!x. R^* x x) /\ + (!x y z. R x y /\ R^* y z ==> R^* x z) RTC_RULES_RIGHT1 - |- !R. (!x. RTC R x x) /\ - (!x y z. RTC R x y /\ R y z ==> RTC R x z) + |- !R. (!x. R^* x x) /\ + (!x y z. R^* x y /\ R y z ==> R^* x z) \end{verbatim} \end{hol} % Notice that {\small\verb+RTC_RULES+}, in keeping with the definition of {\small\verb+RTC+}, extends an \verb+R+-step from \verb+x+ to \verb+y+ with a sequence of \verb+R+-steps from \verb+y+ to \verb+z+ -to construct \verb+RTC x z+. The theorem +to construct \verb+R^* x z+. The theorem {\small\verb+RTC_RULES_RIGHT1+} first makes a sequence of \verb+R+ -steps and then a single \verb+R+ step to form \verb+RTC x z+. Similar +steps and then a single \verb+R+ step to form \verb+R^* x z+. Similar alternative theorems are proved for case analysis and induction. For example, {\small\verb+TC_CASES1+} and {\small\verb+TC_CASES2+} in the -following decompose {\small\verb+RTC R x z+} to either -{\small\verb+R x y+} followed by {\small\verb+RTC R y z+} +following decompose {\small\verb!R^+ x z!} to either +{\small\verb+R x y+} followed by {\small\verb!R^+ y z!} ({\small\verb+TC_CASES1+}) or -{\small\verb+RTC R x y+} followed by {\small\verb+R y z+} +{\small\verb!R^+ x y!} followed by {\small\verb+R y z+} ({\small\verb+TC_CASES2+}). % \begin{hol} \begin{verbatim} TC_CASES1 - |- !R x z. TC R x z ==> R x z \/ ?y. R x y /\ TC R y z + |- !R x z. R^+ x z ==> R x z \/ ?y. R x y /\ R^+ y z TC_CASES2 - |- !R x z. TC R x z ==> R x z \/ ?y. TC R x y /\ R y z + |- !R x z. R^+ x z ==> R x z \/ ?y. R^+ x y /\ R y z RTC_CASES1 - |- !R x y. RTC R x y = (x = y) \/ ?u. R x u /\ RTC R u y + |- !R x y. R^* x y = (x = y) \/ ?u. R x u /\ R^* u y RTC_CASES2 - |- !R x y. RTC R x y = (x = y) \/ ?u. RTC R x u /\ R u y + |- !R x y. R^* x y = (x = y) \/ ?u. R^* x u /\ R u y RTC_CASES_RTC_TWICE - |- !R x y. RTC R x y = ?u. RTC R x u /\ RTC R u y + |- !R x y. R^* x y = ?u. R^* x u /\ R^* u y \end{verbatim} \end{hol} @@ -4326,19 +4330,19 @@ \subsection{Relations (\theoryimp{relation})}\label{relation} TC_INDUCT |- !R P. (!x y. R x y ==> P x y) /\ (!x y z. P x y /\ P y z ==> P x z) - ==> !u v. TC R u v ==> P u v + ==> !u v. R^+ u v ==> P u v RTC_INDUCT |- ! R P. (!x. P x x) /\ (!x y z. R x y /\ P y z ==> P x z) ==> - (!x y. RTC R x y ==> P x y) + (!x y. R^* x y ==> P x y) TC_STRONG_INDUCT |- !R P. (!x y. R x y ==> P x y) /\ - (!x y z. P x y /\ P y z /\ TC R x y /\ TC R y z ==> P x z) ==> - (!u v. TC R u v ==> P u v) + (!x y z. P x y /\ P y z /\ R^+ x y /\ R^+ y z ==> P x z) ==> + (!u v. R^+ u v ==> P u v) RTC_STRONG_INDUCT |- !R P. (!x. P x x) /\ - (!x y z. R x y /\ RTC R y z /\ P y z ==> P x z) ==> - (!x y. RTC R x y ==> P x y) + (!x y z. R x y /\ R^* y z /\ P y z ==> P x z) ==> + (!x y. R^* x y ==> P x y) \end{verbatim} \end{hol} Variants of these induction theorems are also available which break @@ -4350,12 +4354,14 @@ \subsection{Relations (\theoryimp{relation})}\label{relation} straightforward to define. The equivalence closure ({\small\verb+EQC+}) is the symmetric then transitive then reflexive closure of $R$. +When applied to an argument, as in \holtxt{EQC~R}, \holtxt{EQC} is written with the suffix \holtxt{\^{}=}. +Note how the suffix binds more tightly than function application, so that in \ml{EQC_DEF}, \holtxt{RC} really is applied to the transitive closure of the symmetric closure of \holtxt{R}. % \begin{hol} \begin{verbatim} RC_DEF |- RC R x y = (x = y) \/ R x y SC_DEF |- SC R x y = R x y \/ R y x - EQC_DEF |- EQC R = RC (TC (SC R)) + EQC_DEF |- R^= = RC (SC R)^+ \end{verbatim} \end{hol} From 4fc62fdc569cec0edd5738e6062868d0dae771e8 Mon Sep 17 00:00:00 2001 From: Thomas Tuerk Date: Wed, 25 Mar 2015 01:12:30 +0100 Subject: [PATCH 255/718] document deep_matches example in release notes --- doc/next-release.md | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/doc/next-release.md b/doc/next-release.md index 5990a85e6b..82b4cd33af 100644 --- a/doc/next-release.md +++ b/doc/next-release.md @@ -40,6 +40,30 @@ New examples: - A theory of balanced binary trees (`examples/balanced_bst`), based on Haskell code by Leijen and Palamarchuk, and mechanised by Scott Owens. The type supports operations such as `insert`, `union`, `delete`, filters and folds. Operations are parameterised by comparison operators for comparing keys. Balanced trees can themselves be compared. +- A formalisation of pattern matches (`examples/deep_matches`). + Pattern matching it is not directly supported by higher-order logic. + HOL4's parser therefore compiles case-expressions (`case x of ...`) + to decision trees based on case constants are used. For non-trivial + case expressions, there is a big discrepancy between the user's view + and this internal representation. The `deep_matches` example + defines a new general-purpose representation for case expressions + that mirrors the input syntax in the internal representation + closely. Because of this close connection, the new representation + is more intuitive and often much more compact. Complicated parsers + and pretty-printers are no longer required. Proofs can more closely + follow the user's intentions, and code generators (like CakeML) can + produce better code. Moreover, the new representation is strictly + more general than the currently used representation. The new + representation allows for guards, Haskell-style views, patterns with + multiple occurrences of the same bound variable, unbound variables, + arithmetic expressions in patterns, and more. The example provides + the definitions as well as tools to work with the new + case-expressions. These tools include support for evaluating and + simplifying them, a highly configurable pattern compilation + algorithm inside the logic and optimisation like detecting redundant + rows and eliminating them. + + Incompatibilities: ------------------ From aa04c7d4dd133ba0cfd47b0d3ab1824e16a3cbe5 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 25 Mar 2015 14:40:27 +1100 Subject: [PATCH 256/718] Fix doc to use BIT{1,2} instead of NUMERAL_BIT{1,2} The latter names were changed a while back (in 3b9afa98410). Thanks to Jeremy Dawson for the bug report. --- .../numLib.SUC_TO_NUMERAL_DEFN_CONV.doc | 22 +++++++------------ 1 file changed, 8 insertions(+), 14 deletions(-) diff --git a/help/Docfiles/numLib.SUC_TO_NUMERAL_DEFN_CONV.doc b/help/Docfiles/numLib.SUC_TO_NUMERAL_DEFN_CONV.doc index de2ccbeab7..c984183884 100644 --- a/help/Docfiles/numLib.SUC_TO_NUMERAL_DEFN_CONV.doc +++ b/help/Docfiles/numLib.SUC_TO_NUMERAL_DEFN_CONV.doc @@ -15,12 +15,10 @@ the argument term is a numeral. This procedure uses the following theorem: { |- !f g. (!n. f (SUC n) = g n (SUC n)) = - (!n. f (NUMERAL (NUMERAL_BIT1 n)) = - g (NUMERAL (NUMERAL_BIT1 n)) - (NUMERAL (NUMERAL_BIT1 n) - 1)) /\ - (!n. f (NUMERAL (NUMERAL_BIT2 n)) = - g (NUMERAL (NUMERAL_BIT2 n)) - (NUMERAL (NUMERAL_BIT1 n))) + (!n. f (NUMERAL (BIT1 n)) = + g (NUMERAL (BIT1 n)) (NUMERAL (BIT1 n) - 1)) /\ + (!n. f (NUMERAL (BIT2 n)) = + g (NUMERAL (BIT2 n)) (NUMERAL (BIT1 n))) } \EXAMPLE @@ -29,13 +27,11 @@ This procedure uses the following theorem: > val it = |- (FACT 0 = 1) /\ (!n. - FACT (NUMERAL (NUMERAL_BIT1 n)) = - NUMERAL (NUMERAL_BIT1 n) * - FACT (NUMERAL (NUMERAL_BIT1 n) - 1)) /\ + FACT (NUMERAL (BIT1 n)) = + NUMERAL (BIT1 n) * FACT (NUMERAL (BIT1 n) - 1)) /\ !n. - FACT (NUMERAL (NUMERAL_BIT2 n)) = - NUMERAL (NUMERAL_BIT2 n) * - FACT (NUMERAL (NUMERAL_BIT1 n)) : thm + FACT (NUMERAL (BIT2 n)) = + NUMERAL (BIT2 n) * FACT (NUMERAL (BIT1 n)) : thm } \FAILURE @@ -53,5 +49,3 @@ easily. numLib.num_CONV. \ENDDOC - - From fdd405c32ca1db73d4c68f9287ebb6e6c7a0ddb4 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 25 Mar 2015 14:49:44 +1100 Subject: [PATCH 257/718] Tweaks to pattern-match example release notes Including - use Unicode apostrophe - put one sentence per line - indent so as to make pandoc happy - some grammar --- doc/next-release.md | 34 ++++++++++++---------------------- 1 file changed, 12 insertions(+), 22 deletions(-) diff --git a/doc/next-release.md b/doc/next-release.md index 82b4cd33af..bec5904ee8 100644 --- a/doc/next-release.md +++ b/doc/next-release.md @@ -40,28 +40,18 @@ New examples: - A theory of balanced binary trees (`examples/balanced_bst`), based on Haskell code by Leijen and Palamarchuk, and mechanised by Scott Owens. The type supports operations such as `insert`, `union`, `delete`, filters and folds. Operations are parameterised by comparison operators for comparing keys. Balanced trees can themselves be compared. -- A formalisation of pattern matches (`examples/deep_matches`). - Pattern matching it is not directly supported by higher-order logic. - HOL4's parser therefore compiles case-expressions (`case x of ...`) - to decision trees based on case constants are used. For non-trivial - case expressions, there is a big discrepancy between the user's view - and this internal representation. The `deep_matches` example - defines a new general-purpose representation for case expressions - that mirrors the input syntax in the internal representation - closely. Because of this close connection, the new representation - is more intuitive and often much more compact. Complicated parsers - and pretty-printers are no longer required. Proofs can more closely - follow the user's intentions, and code generators (like CakeML) can - produce better code. Moreover, the new representation is strictly - more general than the currently used representation. The new - representation allows for guards, Haskell-style views, patterns with - multiple occurrences of the same bound variable, unbound variables, - arithmetic expressions in patterns, and more. The example provides - the definitions as well as tools to work with the new - case-expressions. These tools include support for evaluating and - simplifying them, a highly configurable pattern compilation - algorithm inside the logic and optimisation like detecting redundant - rows and eliminating them. +- A formalisation of pattern matches (`examples/deep_matches`). + Pattern matching is not directly supported by higher-order logic. + HOL4’s parser therefore compiles case-expressions (`case x of ...`) to decision trees based on case constants. + For non-trivial case expressions, there is a big discrepancy between the user’s view and this internal representation. + The `deep_matches` example defines a new general-purpose representation for case expressions that mirrors the input syntax in the internal representation closely. + Because of this close connection, the new representation is more intuitive and often much more compact. + Complicated parsers and pretty-printers are no longer required. + Proofs can more closely follow the user’s intentions, and code generators (like CakeML) can produce better code. + Moreover, the new representation is strictly more general than the currently used representation. + The new representation allows for guards, Haskell-style views, patterns with multiple occurrences of the same bound variable, unbound variables, arithmetic expressions in patterns, and more. + The example provides the definitions as well as tools to work with the new case-expressions. + These tools include support for evaluating and simplifying them, a highly configurable pattern compilation algorithm inside the logic, and optimisations like detecting redundant rows and eliminating them. Incompatibilities: From db6f90caf683907842af676b9d5d920978473285 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Wed, 25 Mar 2015 15:29:32 +1100 Subject: [PATCH 258/718] Drule.ASSUME_CONJS Constructs a theorem proving a conjunction from its individual conjuncts --- help/Docfiles/Drule.ASSUME_CONJS.doc | 28 ++++++++++++++++++++++++++++ src/1/Drule.sig | 1 + src/1/Drule.sml | 11 +++++++++++ 3 files changed, 40 insertions(+) create mode 100644 help/Docfiles/Drule.ASSUME_CONJS.doc diff --git a/help/Docfiles/Drule.ASSUME_CONJS.doc b/help/Docfiles/Drule.ASSUME_CONJS.doc new file mode 100644 index 0000000000..eb1a5b160c --- /dev/null +++ b/help/Docfiles/Drule.ASSUME_CONJS.doc @@ -0,0 +1,28 @@ +\DOC ASSUME_CONJS + +\TYPE {ASSUME_CONJS : term -> thm} + +\SYNOPSIS +Constructs a theorem proving a conjunction from its individual conjuncts + +\KEYWORDS +conjunction. + +\DESCRIBE +Takes a term which should be a conjunction, and returns a theorem whose +hypotheses are the individual conjuncts, and whose conclusion is the argument +term, the conjunction. + +\FAILURE +Never fails. + +\EXAMPLE +{ASSUME_CONJS (``t1 /\ t2 /\ ... /\ tn``)} returns +{ [t1, t2, ..., tn] |- t1 /\ t2 /\ ... /\ tn } + +To split up conjuncts in selected hypotheses {hyps} of a theorem {th}, +use {Lib.itlist (PROVE_HYP o ASSUME_CONJS) hyps th} + +\SEEALSO +Drule.CONJUNCTS, Thm.CONJ, Drule.CONJUNCTS_AC +\ENDDOC diff --git a/src/1/Drule.sig b/src/1/Drule.sig index 81b8f8e844..9474ce1442 100644 --- a/src/1/Drule.sig +++ b/src/1/Drule.sig @@ -36,6 +36,7 @@ sig val RIGHT_BETA : thm -> thm val LIST_BETA_CONV : term -> thm val RIGHT_LIST_BETA : thm -> thm + val ASSUME_CONJS : term -> thm val CONJUNCTS_AC : term * term -> thm val DISJUNCTS_AC : term * term -> thm val CONJ_DISCH : term -> thm -> thm diff --git a/src/1/Drule.sml b/src/1/Drule.sml index 91286a2fef..22b8ccb1df 100644 --- a/src/1/Drule.sml +++ b/src/1/Drule.sml @@ -450,6 +450,17 @@ val CONJUNCTS = aux [] end +(*---------------------------------------------------------------------------* + * "t1 /\ ... /\ tn" ---> [t1, ..., tn] |- t1 /\ ... /\ tn * + * * + * constructs a theorem proving conjunction from individual conjuncts * + *---------------------------------------------------------------------------*) + +fun ASSUME_CONJS tm = + let val (tm1, tm2) = dest_conj tm ; + in CONJ (ASSUME_CONJS tm1) (ASSUME_CONJS tm2) end + handle _ => ASSUME tm ; + (*---------------------------------------------------------------------------* * |- t1 = t2 if t1 and t2 are equivalent using idempotence, symmetry and * * associativity of /\. * From c9dd804ee74617d2db8362be17e0d5a854be888c Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Wed, 25 Mar 2015 17:33:19 +1100 Subject: [PATCH 259/718] Tactic.irule, also prim_irule_tac and Drule.SPEC_UNDISCH_EXL --- src/1/Drule.sig | 1 + src/1/Drule.sml | 10 ++++++++++ src/1/Tactic.sig | 2 ++ src/1/Tactic.sml | 23 +++++++++++++++++++++++ 4 files changed, 36 insertions(+) diff --git a/src/1/Drule.sig b/src/1/Drule.sig index 9474ce1442..092a7cbde0 100644 --- a/src/1/Drule.sig +++ b/src/1/Drule.sig @@ -28,6 +28,7 @@ sig val SELECT_ELIM : thm -> term * thm -> thm val SELECT_RULE : thm -> thm val SPEC_VAR : thm -> term * thm + val SPEC_UNDISCH_EXL : thm -> thm val FORALL_EQ : term -> thm -> thm val EXISTS_EQ : term -> thm -> thm val SELECT_EQ : term -> thm -> thm diff --git a/src/1/Drule.sml b/src/1/Drule.sml index 22b8ccb1df..c2e710160a 100644 --- a/src/1/Drule.sml +++ b/src/1/Drule.sml @@ -1308,6 +1308,16 @@ fun EXISTS_LEFT1 fv th = val fvs_c = free_vars (concl th) ; in EXISTS_LEFT' true fvs_c hfvs [fv] th end ; +(* --------------------------------------------------------------------------* + * SPEC_UNDISCH_EXL: strips !x, ant ==>, then EXISTS_LEFT for stripped vars * + * --------------------------------------------------------------------------*) + +fun SPEC_UNDISCH_EXL thm = + let val (fvs, th1) = strip_gen_left (SPEC_VAR o UNDISCH_ALL) thm ; + val th2 = UNDISCH_ALL th1 ; + val th3 = EXISTS_LEFT fvs th2 ; + in th3 end ; + (* --------------------------------------------------------------------------* * MATCH_MP: Matching Modus Ponens for implications. * * * diff --git a/src/1/Tactic.sig b/src/1/Tactic.sig index 6543b702cf..c11685d37d 100644 --- a/src/1/Tactic.sig +++ b/src/1/Tactic.sig @@ -58,6 +58,8 @@ sig val WEAKEN_TAC : (term -> bool) -> tactic val MATCH_ACCEPT_TAC : thm -> tactic val MATCH_MP_TAC : thm -> tactic + val prim_irule_tac : thm -> tactic + val irule : thm -> tactic val HO_MATCH_ACCEPT_TAC : thm -> tactic val HO_BACKCHAIN_TAC : thm -> tactic val HO_MATCH_MP_TAC : thm -> tactic diff --git a/src/1/Tactic.sml b/src/1/Tactic.sml index e199a25272..08a757d221 100644 --- a/src/1/Tactic.sml +++ b/src/1/Tactic.sml @@ -708,6 +708,17 @@ fun MATCH_ACCEPT_TAC thm : tactic = end handle HOL_ERR _ => raise ERR "MATCH_ACCEPT_TAC" "" +(* ---------------------------------------------------------------------* + * prim_irule_tac : Similar to MATCH_ACCEPT_TAC but * + * (1) allows substitution in hypotheses of the supplied theorem * + * (2) adds new subgoals for those hypotheses * + * ---------------------------------------------------------------------*) + +fun prim_irule_tac thm (asl, w) = + let val matchsub = match_terml [] empty_tmset (concl thm) w ; + val subthm = INST_TY_TERM matchsub thm ; + in GEN_VALIDATE false (ACCEPT_TAC subthm) (asl, w) end ; + (* --------------------------------------------------------------------------* * MATCH_MP_TAC: Takes a theorem of the form * * * @@ -767,6 +778,18 @@ in end end +(* --------------------------------------------------------------------------* + * irule: similar to MATCH_MP_TAC, but * + * (1) uses conclusion following more than one ==> * + * (2) where multiple assumptions involve the same variable that is not in * + * the conclusion (as y in x = y ==> y = z ==> x = z), collects them * + * and existentially quantifies * + * (3) hypotheses of the theorem provided also become new subgoals * + * --------------------------------------------------------------------------*) + +fun irule thm = prim_irule_tac (SPEC_UNDISCH_EXL thm) ; + + (* ----------------------------------------------------------------------* * Definition of the standard resolution tactics IMP_RES_TAC and RES_TAC * * * From 2940fe8ea3e272ec34fa58d14d68039aceeb1d20 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Wed, 25 Mar 2015 19:16:34 +1100 Subject: [PATCH 260/718] docs for irule, prim_irule_tac, SPEC_UNDISCH_EXL --- help/Docfiles/Drule.SPEC_UNDISCH_EXL.doc | 42 +++++++++++++++ help/Docfiles/Tactic.irule.doc | 65 ++++++++++++++++++++++++ help/Docfiles/Tactic.prim_irule_tac.doc | 32 ++++++++++++ src/1/Drule.sml | 2 +- 4 files changed, 140 insertions(+), 1 deletion(-) create mode 100644 help/Docfiles/Drule.SPEC_UNDISCH_EXL.doc create mode 100644 help/Docfiles/Tactic.irule.doc create mode 100644 help/Docfiles/Tactic.prim_irule_tac.doc diff --git a/help/Docfiles/Drule.SPEC_UNDISCH_EXL.doc b/help/Docfiles/Drule.SPEC_UNDISCH_EXL.doc new file mode 100644 index 0000000000..1c794cead3 --- /dev/null +++ b/help/Docfiles/Drule.SPEC_UNDISCH_EXL.doc @@ -0,0 +1,42 @@ +\DOC SPEC_UNDISCH_EXL + +\TYPE {SPEC_UNDISCH_EXL : thm -> thm} + +\SYNOPSIS +Strips universal quantifiers and antecedents of implications, +then where possible replaces the formerly quantified variables +as existentials in the new hypotheses. + +\KEYWORDS +universal, existential, quantifier, assumption, hypothesis + +\DESCRIBE +In this example, assume that {a1} and {a3} (only) involve the free variable {x}. +{ + |- !x. a1 ==> !y. a2 ==> !z. a3 ==> !u. t + ----------------------------------------- SPEC_UNDISCH_EXL + ?x. a1 /\ a3, a2 |- t +} + +\FAILURE +No failure. Can leave the supplied theorem unchanged. + +\COMMENTS +See {EXISTS_LEFT} for more on the existential quantification aspect. +Note that the existential quantification happens only for variables +which were universally quantified in the supplied theorem. + +\EXAMPLE +Where {trans_thm} is {[] |- !x y z. (x = y) ==> (y = z) ==> (x = z)} + +{SPEC_UNDISCH_EXL trans_thm} is {[?y. (x = y) /\ (y = z)] |- x = z} + +\SEEALSO +Drule.EXISTS_LEFT, Tactic.irule + +\ENDDOC + + + + + diff --git a/help/Docfiles/Tactic.irule.doc b/help/Docfiles/Tactic.irule.doc new file mode 100644 index 0000000000..ea1035a6d3 --- /dev/null +++ b/help/Docfiles/Tactic.irule.doc @@ -0,0 +1,65 @@ +\DOC irule + +\TYPE {irule : thm_tactic} + +\SYNOPSIS +Reduces the goal using a supplied implication, with matching. + +\KEYWORDS +tactic, modus ponens, implication. + +\DESCRIBE +When applied to a theorem of the form +{ + A' |- !x1...xn. s ==> !y1...ym. t ==> !z1...zk. u +} +{irule} produces a tactic that reduces a goal whose conclusion +{u'} is a substitution and/or type instance of {t} to the corresponding +instances of {s} and of {t}. +Any variables free in {s} or {t} but not in {u} will be existentially +quantified in the resulting subgoal, and +a variable free in both {s} and {t} will result in a subgoal +which is {s /\ t}, existentially quantified + +The following diagram is simplified: more implications and quantified variables +than shown are allowed. +{ + A ?- u' + ========================= irule (A' |- !x. s ==> !y. t ==> u) + A ?- ?z. s' A ?- ?w. t' +} +where {z} and {w} are (type instances of) variables among +{x}, {y} that do not occur free in {s}, {t}. +The assumptions {A'}, instantiated, are added as further new subgoals. + +\FAILURE +Fails unless the theorem, when stripped of universal quantification and +antecedents of implications, can be instantiated to match the goal. + +\COMMENTS +The supplied theorem is pre-processed using {SPEC_UNDISCH_EXL}, +which removes the universal quantifiers and antecedents of implications, +and applies {EXISTS_LEFT} which +existentially quantifies variables which were instantiated but appeared +only in the antecedents of implications. +See {SPEC_UNDISCH_EXL} for details. + +Then {prim_irule_tac} is applied. To avoid this preprocessing +just use {prim_irule_tac} + +\EXAMPLE +With goal {R a (f b)} and theorem +{thm = |- !x u. P u x ==> !y. Q w x y ==> R x (f y)} +the proof step {e (irule thm)} gives +new goals {Q w a b} and {?u. P u a} + +With goal {a = b} and theorem +{trans = |- !x y. (x = y) ==> !z. (y = z) ==> (x = z)} +the proof step {e (irule trans)} gives +new goal {?y. (a = y) /\ (y = b)} + +\SEEALSO +Tactic.MATCH_MP_TAC, Tactic.prim_irule_tac, Drule.SPEC_UNDISCH_EXL, +Drule.EXISTS_LEFT +\ENDDOC + diff --git a/help/Docfiles/Tactic.prim_irule_tac.doc b/help/Docfiles/Tactic.prim_irule_tac.doc new file mode 100644 index 0000000000..eec1d8e31f --- /dev/null +++ b/help/Docfiles/Tactic.prim_irule_tac.doc @@ -0,0 +1,32 @@ +\DOC prim_irule_tac + +\TYPE {prim_irule_tac : thm_tactic} + +\SYNOPSIS +For a goal which is an instance of the conclusion of the supplied theorem, +replace the goal by the instantiated hypotheses of the supplied theorem. + +\KEYWORDS +tactic. + +\DESCRIBE +When given a theorem {A' |- t} and a goal {A ?- t'} where {t} can be matched +to {t'} by instantiating free variables, +including appropriate type instantiation, +{prim_irule_tac} replaces the goal by new subgoals which are the hypotheses +{A'}, instantiated + +\FAILURE +Fails unless the theorem has a conclusion which is instantiable to match that +of the goal. + +\COMMENTS +{irule} also pre-processes the supplied theorem, which will normally be useful + +{irule} differs from {MATCH_ACCEPT_TAC} in that hypotheses of the supplied +theorem may also be substituted, and will appear as new subgoals + +\SEEALSO +Tactic.irule, Tactic.MATCH_ACCEPT_TAC, Tactic.ACCEPT_TAC +\ENDDOC + diff --git a/src/1/Drule.sml b/src/1/Drule.sml index c2e710160a..b44f5a1cf5 100644 --- a/src/1/Drule.sml +++ b/src/1/Drule.sml @@ -1315,7 +1315,7 @@ fun EXISTS_LEFT1 fv th = fun SPEC_UNDISCH_EXL thm = let val (fvs, th1) = strip_gen_left (SPEC_VAR o UNDISCH_ALL) thm ; val th2 = UNDISCH_ALL th1 ; - val th3 = EXISTS_LEFT fvs th2 ; + val th3 = EXISTS_LEFT (rev fvs) th2 ; in th3 end ; (* --------------------------------------------------------------------------* From 36edf2ba7c12c88c83b946385c3623ac7e890883 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Thu, 26 Mar 2015 14:24:08 +1100 Subject: [PATCH 261/718] renamed prim_irule_tac to prim_irule --- help/Docfiles/Tactic.irule.doc | 6 +++--- .../{Tactic.prim_irule_tac.doc => Tactic.prim_irule.doc} | 8 ++++---- src/1/Tactic.sig | 2 +- src/1/Tactic.sml | 7 +++---- 4 files changed, 11 insertions(+), 12 deletions(-) rename help/Docfiles/{Tactic.prim_irule_tac.doc => Tactic.prim_irule.doc} (77%) diff --git a/help/Docfiles/Tactic.irule.doc b/help/Docfiles/Tactic.irule.doc index ea1035a6d3..6bdc9a8ab6 100644 --- a/help/Docfiles/Tactic.irule.doc +++ b/help/Docfiles/Tactic.irule.doc @@ -44,8 +44,8 @@ existentially quantifies variables which were instantiated but appeared only in the antecedents of implications. See {SPEC_UNDISCH_EXL} for details. -Then {prim_irule_tac} is applied. To avoid this preprocessing -just use {prim_irule_tac} +Then {prim_irule} is applied. To avoid this preprocessing +just use {prim_irule} \EXAMPLE With goal {R a (f b)} and theorem @@ -59,7 +59,7 @@ the proof step {e (irule trans)} gives new goal {?y. (a = y) /\ (y = b)} \SEEALSO -Tactic.MATCH_MP_TAC, Tactic.prim_irule_tac, Drule.SPEC_UNDISCH_EXL, +Tactic.MATCH_MP_TAC, Tactic.prim_irule, Drule.SPEC_UNDISCH_EXL, Drule.EXISTS_LEFT \ENDDOC diff --git a/help/Docfiles/Tactic.prim_irule_tac.doc b/help/Docfiles/Tactic.prim_irule.doc similarity index 77% rename from help/Docfiles/Tactic.prim_irule_tac.doc rename to help/Docfiles/Tactic.prim_irule.doc index eec1d8e31f..e25a07c958 100644 --- a/help/Docfiles/Tactic.prim_irule_tac.doc +++ b/help/Docfiles/Tactic.prim_irule.doc @@ -1,6 +1,6 @@ -\DOC prim_irule_tac +\DOC prim_irule -\TYPE {prim_irule_tac : thm_tactic} +\TYPE {prim_irule : thm_tactic} \SYNOPSIS For a goal which is an instance of the conclusion of the supplied theorem, @@ -13,7 +13,7 @@ tactic. When given a theorem {A' |- t} and a goal {A ?- t'} where {t} can be matched to {t'} by instantiating free variables, including appropriate type instantiation, -{prim_irule_tac} replaces the goal by new subgoals which are the hypotheses +{prim_irule} replaces the goal by new subgoals which are the hypotheses {A'}, instantiated \FAILURE @@ -23,7 +23,7 @@ of the goal. \COMMENTS {irule} also pre-processes the supplied theorem, which will normally be useful -{irule} differs from {MATCH_ACCEPT_TAC} in that hypotheses of the supplied +{prim_irule} differs from {MATCH_ACCEPT_TAC} in that hypotheses of the supplied theorem may also be substituted, and will appear as new subgoals \SEEALSO diff --git a/src/1/Tactic.sig b/src/1/Tactic.sig index c11685d37d..d498ae7e1f 100644 --- a/src/1/Tactic.sig +++ b/src/1/Tactic.sig @@ -58,7 +58,7 @@ sig val WEAKEN_TAC : (term -> bool) -> tactic val MATCH_ACCEPT_TAC : thm -> tactic val MATCH_MP_TAC : thm -> tactic - val prim_irule_tac : thm -> tactic + val prim_irule : thm -> tactic val irule : thm -> tactic val HO_MATCH_ACCEPT_TAC : thm -> tactic val HO_BACKCHAIN_TAC : thm -> tactic diff --git a/src/1/Tactic.sml b/src/1/Tactic.sml index 08a757d221..65bbf4d772 100644 --- a/src/1/Tactic.sml +++ b/src/1/Tactic.sml @@ -709,12 +709,12 @@ fun MATCH_ACCEPT_TAC thm : tactic = handle HOL_ERR _ => raise ERR "MATCH_ACCEPT_TAC" "" (* ---------------------------------------------------------------------* - * prim_irule_tac : Similar to MATCH_ACCEPT_TAC but * + * prim_irule : Similar to MATCH_ACCEPT_TAC but * * (1) allows substitution in hypotheses of the supplied theorem * * (2) adds new subgoals for those hypotheses * * ---------------------------------------------------------------------*) -fun prim_irule_tac thm (asl, w) = +fun prim_irule thm (asl, w) = let val matchsub = match_terml [] empty_tmset (concl thm) w ; val subthm = INST_TY_TERM matchsub thm ; in GEN_VALIDATE false (ACCEPT_TAC subthm) (asl, w) end ; @@ -787,8 +787,7 @@ end * (3) hypotheses of the theorem provided also become new subgoals * * --------------------------------------------------------------------------*) -fun irule thm = prim_irule_tac (SPEC_UNDISCH_EXL thm) ; - +fun irule thm = prim_irule (SPEC_UNDISCH_EXL thm) ; (* ----------------------------------------------------------------------* * Definition of the standard resolution tactics IMP_RES_TAC and RES_TAC * From 73fd7bd5801fdf6817a96b30b1bc68a4ec4b207b Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 26 Mar 2015 16:38:07 +1100 Subject: [PATCH 262/718] Ignore another LaTeX-generated file --- .gitignore | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitignore b/.gitignore index 6708364b61..5c3c0f3f1b 100644 --- a/.gitignore +++ b/.gitignore @@ -29,6 +29,7 @@ *.tix *.hix *.fdb_latexmk +*.synctex.gz #Generated Verilog from Iyoda/Gordon hw compilation *.vl From c3e3e54e322b8f382087894b159d64f34c2709c0 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 26 Mar 2015 16:45:43 +1100 Subject: [PATCH 263/718] Delete trailing whitespace in src/ --- src/1/Drule.sml | 14 +++++----- src/1/PmatchHeuristics.sig | 2 +- src/1/PmatchHeuristics.sml | 24 ++++++++-------- src/1/Tactic.sml | 2 +- src/1/selftest.sml | 18 ++++++------ src/bool/DB.sig | 4 +-- src/bool/DB.sml | 6 ++-- src/bool/selftest.sml | 4 +-- src/boss/lcsymtacs.sig | 2 +- src/postkernel/HolKernel.sml | 6 ++-- src/proofman/Manager.sml | 4 +-- src/proofman/selftest.sml | 2 +- src/simp/src/Traverse.sig | 2 +- src/simp/src/Traverse.sml | 2 +- src/tfl/src/RW.sml | 54 ++++++++++++++++++------------------ 15 files changed, 73 insertions(+), 73 deletions(-) diff --git a/src/1/Drule.sml b/src/1/Drule.sml index b44f5a1cf5..b68977a1ef 100644 --- a/src/1/Drule.sml +++ b/src/1/Drule.sml @@ -272,7 +272,7 @@ fun UNDISCH th = fun UNDISCH_TM th = let val (ant, conseq) = dest_imp (concl th) ; - in (ant, MP th (ASSUME ant)) end + in (ant, MP th (ASSUME ant)) end handle HOL_ERR _ => raise ERR "UNDISCH_TM" "" (*---------------------------------------------------------------------------* @@ -459,7 +459,7 @@ val CONJUNCTS = fun ASSUME_CONJS tm = let val (tm1, tm2) = dest_conj tm ; in CONJ (ASSUME_CONJS tm1) (ASSUME_CONJS tm2) end - handle _ => ASSUME tm ; + handle _ => ASSUME tm ; (*---------------------------------------------------------------------------* * |- t1 = t2 if t1 and t2 are equivalent using idempotence, symmetry and * @@ -1241,9 +1241,9 @@ fun PART_MATCH partfn th = end (* --------------------------------------------------------------------------* - EXISTS_LEFT, EXISTS_LEFT1 + EXISTS_LEFT, EXISTS_LEFT1 existentially quantifying variables which appear only in the hypotheses - + [x = y, y = z] |- x = z (eg) -------------------------------- EXISTS_LEFT1 ``y`` [∃y. (x = y) ∧ (y = z)] |- x = z @@ -1253,13 +1253,13 @@ fun PART_MATCH partfn th = (* EXISTS_LEFT' : bool -> term list -> {fvs: term list, hyp: term} list -> term list -> thm -> thm used below, saves hyps, their free vars, and free vars of conclusion, - across recursive calls - arg1 - whether to ignore errors, ie, free vars which are either in the + across recursive calls + arg1 - whether to ignore errors, ie, free vars which are either in the conclusion or not in any hypothesis arg2 - list of free vars in the conclusion arg3 - list of assumptions of the theorem, each with the list of free vars which it contains - arg4 - list of free vars to become existentially quantified + arg4 - list of free vars to become existentially quantified *) fun EXISTS_LEFT' strict fvs_c hfvs [] th = th diff --git a/src/1/PmatchHeuristics.sig b/src/1/PmatchHeuristics.sig index 643a1d2aba..833873628c 100644 --- a/src/1/PmatchHeuristics.sig +++ b/src/1/PmatchHeuristics.sig @@ -26,7 +26,7 @@ sig as argument. Then look at the choices and add 0s for all the initial choices you liked to be 0 an then a different choice you prefer. Rerun again (because the following choices will change) - and iterate. This provided very fine control, but is tedious. *) + and iterate. This provided very fine control, but is tedious. *) val pheu_manual : int list -> pmatch_heuristic (* A heuristic based on column ranks. Given a pattern match matrix like diff --git a/src/1/PmatchHeuristics.sml b/src/1/PmatchHeuristics.sml index a3d3a759a8..953876daab 100644 --- a/src/1/PmatchHeuristics.sml +++ b/src/1/PmatchHeuristics.sml @@ -210,13 +210,13 @@ let fun colfun_print thry rowL = case (!remaining_prefix) of (i :: is) => (remaining_prefix := is; i) - | [] => + | [] => let - fun all_vars n = List.all is_var (List.map + fun all_vars n = List.all is_var (List.map (fn r => List.nth (r, n)) rowL) fun col_fun n _ = if (all_vars n orelse (List.null rowL) orelse - (List.length (List.hd rowL) < 2)) then + (List.length (List.hd rowL) < 2)) then SOME n else NONE in case (Lib.first_opt col_fun rowL) of @@ -226,7 +226,7 @@ let (false, r, 1) end | NONE => let - val l = List.length (hd rowL) + val l = List.length (hd rowL) val _ = Lib.appi (fn i => fn _ => add_heu (heu ((!current_prefix) @ [(true, i+1, l)]))) (tl (hd rowL)) val _ = current_prefix := (!current_prefix) @ [(true, 0, l)] in @@ -235,7 +235,7 @@ let end fun colfun thry rowL = let - val (do_it, r, l) = colfun_print thry rowL + val (do_it, r, l) = colfun_print thry rowL val _ = if do_it then (print (int_to_string (r+1)); print "/"; print (int_to_string l); print " ") else () in r @@ -271,9 +271,9 @@ end fun pheu_manual (res_input : int list) : pmatch_heuristic = let fun pr ts = let - val ts_sl = List.map (fn t => "``" ^ (Hol_pp.term_to_string t) ^ "``") ts + val ts_sl = List.map (fn t => "``" ^ (Hol_pp.term_to_string t) ^ "``") ts val ts_s = String.concatWith ", " ts_sl - in + in print ts_s; print "\n" end @@ -281,12 +281,12 @@ let fun man_choice rowL = let val r = case (!res) of - [] => 0 - | (i::is) => + [] => 0 + | (i::is) => let val _ = res := is in - if (i < List.length (List.hd rowL)) then i else + if (i < List.length (List.hd rowL)) then i else (print ("Error, can't use "^(int_to_string i)^"\n");0) end val _ = List.map pr rowL @@ -295,10 +295,10 @@ let r end - fun colfun thry rowL = + fun colfun thry rowL = if ((null rowL) orelse (length (hd rowL) < 2)) then 0 else let - fun all_vars n = List.all is_var (List.map + fun all_vars n = List.all is_var (List.map (fn r => List.nth (r, n)) rowL) fun col_fun n _ = if all_vars n then SOME n else NONE in diff --git a/src/1/Tactic.sml b/src/1/Tactic.sml index 65bbf4d772..6c1e6384ed 100644 --- a/src/1/Tactic.sml +++ b/src/1/Tactic.sml @@ -787,7 +787,7 @@ end * (3) hypotheses of the theorem provided also become new subgoals * * --------------------------------------------------------------------------*) -fun irule thm = prim_irule (SPEC_UNDISCH_EXL thm) ; +fun irule thm = prim_irule (SPEC_UNDISCH_EXL thm) ; (* ----------------------------------------------------------------------* * Definition of the standard resolution tactics IMP_RES_TAC and RES_TAC * diff --git a/src/1/selftest.sml b/src/1/selftest.sml index 81c4dda37e..b3eb78c12e 100644 --- a/src/1/selftest.sml +++ b/src/1/selftest.sml @@ -506,23 +506,23 @@ fun test s = (save_thm(s, TRUTH); die "FAILED!") handle HOL_ERR _ => () val _ = List.app test badnames val _ = print "OK\n" -val _ = let +val _ = let val _ = tprint "Testing VALIDATE (1)" val th' = Thm.mk_oracle_thm "Testing" ([], ``p' ==> q``) ; val th = Thm.mk_oracle_thm "Testing" ([], ``p ==> q``) ; val uth' = UNDISCH_ALL th' ; val uth = UNDISCH_ALL th ; - val g = ([], ``p ==> q``) : goal ; + val g = ([], ``p ==> q``) : goal ; val ([g'], _) = STRIP_TAC g ; val ([], _) = (FIRST (map (VALID o ACCEPT_TAC) [uth', uth])) g' ; val ([_], _) = (VALIDATE (FIRST (map ACCEPT_TAC [uth', uth]))) g' ; val true = (VALID (FIRST (map ACCEPT_TAC [uth', uth])) g' ; false) handle HOL_ERR _ => true ; -in print "OK\n" +in print "OK\n" end handle _ => die "FAILED!" -val _ = let +val _ = let val _ = tprint "Testing VALIDATE (2)" val g = ([], ``(p ==> q) ==> r``) : goal ; val tac = STRIP_TAC THEN VALIDATE (POP_ASSUM (ASSUME_TAC o UNDISCH)) ; @@ -534,10 +534,10 @@ val _ = let val (ngs1, _) = VALID tac1 g ; val (ngs2, _) = VALID tac2 g ; val true = ngs1 = ngs2 ; -in print "OK\n" +in print "OK\n" end handle _ => die "FAILED!" -val _ = let +val _ = let val _ = tprint "Testing structural list-tactics" val tac = REPEAT DISCH_TAC THEN REPEAT CONJ_TAC THEN_LT EVERY_LT [ (ROTATE_LT 2), @@ -549,7 +549,7 @@ val _ = let in if hyp th = [] then print "OK\n" else die "FAILED" end handle _ => die "FAILED!" -val _ = let +val _ = let val _ = tprint "Testing USE_SG_THEN" val tac = REPEAT DISCH_TAC THEN CONJ_TAC THEN_LT USE_SG_THEN ASSUME_TAC 1 2 THENL [POP_ASSUM MATCH_MP_TAC THEN CONJ_TAC, DISJ1_TAC] @@ -558,7 +558,7 @@ val _ = let in if hyp th = [] then print "OK\n" else die "FAILED" end handle _ => die "FAILED!" -val _ = let +val _ = let val _ = tprint "Testing USE_SG_THEN and VALIDATE_LT" val tac = CONJ_TAC THEN REPEAT DISCH_TAC THEN_LT EVERY_LT [VALIDATE_LT (USE_SG_THEN ACCEPT_TAC 1 2), @@ -567,7 +567,7 @@ val _ = let THEN_LT NTH_GOAL CONJ_TAC 2 THEN (FIRST_ASSUM ACCEPT_TAC) val g = ``(p ==> q ==> (p /\ q ==> r) ==> r) /\ - (p ==> q ==> (p ==> r) ==> r)`` + (p ==> q ==> (p ==> r) ==> r)`` val th = prove (g, tac) ; in if hyp th = [] then print "OK\n" else die "FAILED" end handle _ => die "FAILED!" diff --git a/src/bool/DB.sig b/src/bool/DB.sig index 4a8e894ca8..44d4a2c24c 100644 --- a/src/bool/DB.sig +++ b/src/bool/DB.sig @@ -49,8 +49,8 @@ sig val bindl : string -> (string * thm * class) list -> unit - val CT : unit -> (string, (string, data list) Redblackmap.dict * - (string, data list) Redblackmap.dict) Redblackmap.dict + val CT : unit -> (string, (string, data list) Redblackmap.dict * + (string, data list) Redblackmap.dict) Redblackmap.dict end diff --git a/src/bool/DB.sml b/src/bool/DB.sml index b1bdee96ef..aa734f20a7 100644 --- a/src/bool/DB.sml +++ b/src/bool/DB.sml @@ -209,15 +209,15 @@ val apropos = match []; (* matches : term -> thm -> bool tests whether theorem matches pattern *) -fun matches pat th = +fun matches pat th = can (find_term (can (ho_match_term [] empty_tmset pat))) (concl th) ; fun apropos_in pat dbdata = List.filter (fn (_, (th, _)) => matches pat th) dbdata ; -fun find_in s = +fun find_in s = let val lows = toLower s ; - fun finds dbdata = + fun finds dbdata = List.filter (fn ((_, name), _) => occurs lows (toLower name)) dbdata ; in finds end ; diff --git a/src/bool/selftest.sml b/src/bool/selftest.sml index 76395a72fb..88a2959325 100644 --- a/src/bool/selftest.sml +++ b/src/bool/selftest.sml @@ -1,5 +1,5 @@ -open HolKernel Parse DB +open HolKernel Parse DB (* open testutils NOT YET BUILT - therefore need following lines *) fun die s = (print (s ^ "\n"); OS.Process.exit OS.Process.failure) @@ -11,7 +11,7 @@ val _ = set_trace "Unicode" 0 val _ = tprint "test of apropos_in, find_in" -val _ = let +val _ = let val str = "THM" ; val tm = ``$/\`` ; val find1 = find str ; diff --git a/src/boss/lcsymtacs.sig b/src/boss/lcsymtacs.sig index 0b51ff3be1..0ee54e2649 100644 --- a/src/boss/lcsymtacs.sig +++ b/src/boss/lcsymtacs.sig @@ -98,7 +98,7 @@ sig val >| : ('a -> goal list * (thm list -> 'b)) * tactic list -> 'a -> goal list * (thm list -> 'b) - (* ie, tactic * tactic list -> tactic OR + (* ie, tactic * tactic list -> tactic OR list_tactic * tactic list -> list_tactic *) val >- : tactic * tactic -> tactic diff --git a/src/postkernel/HolKernel.sml b/src/postkernel/HolKernel.sml index 8ae10b821e..2ae57a1588 100644 --- a/src/postkernel/HolKernel.sml +++ b/src/postkernel/HolKernel.sml @@ -120,10 +120,10 @@ fun strip_binop dest = strip [] o Lib.list_of_singleton end -(* For right-associative binary operators, +(* For right-associative binary operators, or such as dest_abs, SPEC_VAR, dom_rng, dest_imp. Tail recursive. *) -local +local fun spine_binop' dest = let fun strip A tm = @@ -136,7 +136,7 @@ fun spine_binop' dest = in fun spine_binop dest tm = rev ((op ::) (spine_binop' dest tm)) ; -fun strip_gen_left_opt dest t = +fun strip_gen_left_opt dest t = let val (tm, A) = spine_binop' dest t in (rev A, tm) end ; end (* local fun spine_binop' *) diff --git a/src/proofman/Manager.sml b/src/proofman/Manager.sml index ff4c1b2bce..b39b96c9a3 100644 --- a/src/proofman/Manager.sml +++ b/src/proofman/Manager.sml @@ -89,12 +89,12 @@ fun expand tac (GOALSTACK s) = GOALSTACK (apply (goalStack.expand tac) s) fun expand_listf ltac (GOALSTACK s) = GOALSTACK (apply (goalStack.expand_listf ltac) s) - | expand_listf _ _ = + | expand_listf _ _ = raise ERR "expand_listf" "not implemented for goal trees"; fun expand_list ltac (GOALSTACK s) = GOALSTACK (apply (goalStack.expand_list ltac) s) - | expand_list _ _ = + | expand_list _ _ = raise ERR "expand_list" "not implemented for goal trees"; fun expandv (s,tac) (GOALTREE t) = diff --git a/src/proofman/selftest.sml b/src/proofman/selftest.sml index 61f9af9f91..7613e918f8 100644 --- a/src/proofman/selftest.sml +++ b/src/proofman/selftest.sml @@ -8,7 +8,7 @@ val _ = set_trace "Unicode" 0 val _ = tprint "test of flatn" -val _ = let +val _ = let val g = ([], ``a ==> b ==> c ==> d ==> e ==> a /\ b /\ c /\ d /\ e``) : goal val gstk = new_goal g Lib.I ; val gstk = expand (REPEAT DISCH_TAC) gstk ; diff --git a/src/simp/src/Traverse.sig b/src/simp/src/Traverse.sig index f3751e58aa..620c95336b 100644 --- a/src/simp/src/Traverse.sig +++ b/src/simp/src/Traverse.sig @@ -54,7 +54,7 @@ sig * to the solver are made. * * conv: - * A continuation function, to be used if the reducer + * A continuation function, to be used if the reducer * wants to continue traversing. The continuation invokes traversal * under equality. Similar to solver, but does not call EQT_ELIM. * diff --git a/src/simp/src/Traverse.sml b/src/simp/src/Traverse.sml index 6b62bc9ac2..c8feeb1cda 100644 --- a/src/simp/src/Traverse.sml +++ b/src/simp/src/Traverse.sml @@ -37,7 +37,7 @@ datatype reducer = REDUCER of {name : string option, initial: context, addcontext : context * Thm.thm list -> context, - apply: {solver:term list -> term -> thm, + apply: {solver:term list -> term -> thm, conv: term list -> term -> thm, context: context, stack: term list, relation : term * (term -> thm)} -> conv diff --git a/src/tfl/src/RW.sml b/src/tfl/src/RW.sml index 75b5e95a1c..69275dd336 100644 --- a/src/tfl/src/RW.sml +++ b/src/tfl/src/RW.sml @@ -429,7 +429,7 @@ end; fun TRY_QCONV cnv = ORELSEQC cnv ALL_QCONV; -datatype delta = CHANGE of thm | NO_CHANGE of thm; +datatype delta = CHANGE of thm | NO_CHANGE of thm; fun unchanged (NO_CHANGE _) = true | unchanged _ = false; @@ -527,31 +527,31 @@ fun add_cntxt ADD = add_rws | add_cntxt DONT_ADD = Lib.K; (* with this causes some clutter in the code. *) (*---------------------------------------------------------------------------*) -fun no_change V L tm = +fun no_change V L tm = NO_CHANGE (itlist GEN V (itlist DISCH L (REFL tm))) -fun try_cong cnv (cps as {context,prover,simpls}) tm = - let - fun simple cnv (cps as {context as (cntxt,b),prover,simpls}) (ant,rst) = - case total ((I##dest_eq) o strip_imp_only) ant +fun try_cong cnv (cps as {context,prover,simpls}) tm = + let + fun simple cnv (cps as {context as (cntxt,b),prover,simpls}) (ant,rst) = + case total ((I##dest_eq) o strip_imp_only) ant of NONE (* Not an equality, so just assume *) => (CHANGE(ASSUME ant), rst) - | SOME (L,(lhs,rhs)) + | SOME (L,(lhs,rhs)) => let val outcome = if aconv lhs rhs then no_change [] L lhs else let val cps' = if null L then cps else {context = (map ASSUME L @ cntxt,b), prover = prover, simpls = add_cntxt b simpls (map ASSUME L)} - in CHANGE(cnv cps' lhs) + in CHANGE(cnv cps' lhs) handle HOL_ERR _ => no_change [] L lhs | UNCHANGED => no_change [] L lhs end in - case outcome - of CHANGE th => + case outcome + of CHANGE th => let val Mnew = boolSyntax.rhs(concl th) - in (CHANGE (itlist DISCH L th), + in (CHANGE (itlist DISCH L th), map (subst [rhs |-> Mnew]) rst) end | NO_CHANGE _ => (outcome, map (subst [rhs |-> lhs]) rst) @@ -570,31 +570,31 @@ fun try_cong cnv (cps as {context,prover,simpls}) tm = val vstructs = vstrl_variants (union ant_frees context_frees) vstrl val ceqn' = if null vstrl then ceqn else subst (map (op|->) (zip args vstructs)) ceqn val (L,(lhs,rhs)) = (I##dest_eq) (strip_imp_only ceqn') - val outcome = - if aconv lhs rhs + val outcome = + if aconv lhs rhs then no_change vlist L lhs else let val lhs_beta_maybe = Conv.QCONV (Conv.DEPTH_CONV GEN_BETA_CONV) lhs val lhs' = boolSyntax.rhs(concl lhs_beta_maybe) - val cps' = case L + val cps' = case L of [] => cps | otherwise => - {context = (map ASSUME L @ cntxt,b), - prover = prover, + {context = (map ASSUME L @ cntxt,b), + prover = prover, simpls = add_cntxt b simpls (map ASSUME L)} in CHANGE(TRANS lhs_beta_maybe (cnv cps' lhs')) - handle HOL_ERR _ => - if aconv lhs lhs' - then no_change vlist L lhs + handle HOL_ERR _ => + if aconv lhs lhs' + then no_change vlist L lhs else CHANGE lhs_beta_maybe - | UNCHANGED => if aconv lhs lhs' - then no_change vlist L lhs + | UNCHANGED => if aconv lhs lhs' + then no_change vlist L lhs else CHANGE lhs_beta_maybe end in - case outcome + case outcome of NO_CHANGE _ => (outcome, map (subst [rhsv |-> f]) rst) - | CHANGE th => + | CHANGE th => let (*------------------------------------------------------------*) (* Function eta_rhs packages up the new rhs, eta-expanding it *) (* if need be, i.e. if the lhs is an application of a lambda *) @@ -605,7 +605,7 @@ fun try_cong cnv (cps as {context,prover,simpls}) tm = (* that has function syntax. This will allow the final *) (* MATCH_MP icong ... to succeed. *) (*------------------------------------------------------------*) - fun eta_rhs th = + fun eta_rhs th = let val r = boolSyntax.rhs(concl th) val not_lambda_app = null vstrl val rcore = if not_lambda_app @@ -634,9 +634,9 @@ fun try_cong cnv (cps as {context,prover,simpls}) tm = val icong = CONG_STEP simpls tm val ants = strip_conj (fst(dest_imp (concl icong))) - (* loop proves each antecedent in turn and propagates + (* loop proves each antecedent in turn and propagates instantiations to the remainder. *) - fun loop [] = [] + fun loop [] = [] | loop (ant::rst) = let val (outcome,rst') = if is_forall ant @@ -658,7 +658,7 @@ fun try_cong cnv (cps as {context,prover,simpls}) tm = fun SUB_QCONV cnv cps tm = case dest_term tm of COMB(Rator,Rand) => - (try_cong cnv cps tm + (try_cong cnv cps tm handle UNCHANGED => raise UNCHANGED | HOL_ERR _ => let val th = cnv cps Rator From b4559232857d1fb42f4d9bc0f848520e35cb2a46 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 26 Mar 2015 16:53:56 +1100 Subject: [PATCH 264/718] Make hol.builder0 heap depend on Drule.uo --- src/proofman/Holmakefile | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/proofman/Holmakefile b/src/proofman/Holmakefile index a254f1dc0c..ba75ead74e 100644 --- a/src/proofman/Holmakefile +++ b/src/proofman/Holmakefile @@ -19,6 +19,7 @@ DEPS = $(BOOLLIB) $(BOOLTHEORY) $(PRIMREC) $(TERMPP) \ $(dprot $(SIGOBJ)/Preterm.uo) \ $(dprot $(SIGOBJ)/type_pp.uo) \ $(dprot $(SIGOBJ)/ParseExtras.uo) \ + $(dprot $(SIGOBJ)/Drule.uo) \ $(dprot $(SIGOBJ)/TheoryPP.uo) EXTRA_CLEANS = $(TARGET) @@ -32,7 +33,7 @@ $(TARGET): $(DEPS) all: selftest.exe $(TARGET) .PHONY: all -selftest.exe: selftest.uo +selftest.exe: selftest.uo $(HOLMOSMLC) -o $@ $< endif From b28238529400caaece6ef74e8954907ab6853c83 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 26 Mar 2015 17:01:19 +1100 Subject: [PATCH 265/718] Tweak new code in Drule to avoid compiler warnings --- src/1/Drule.sml | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/src/1/Drule.sml b/src/1/Drule.sml index b68977a1ef..48ceda82b9 100644 --- a/src/1/Drule.sml +++ b/src/1/Drule.sml @@ -1268,10 +1268,11 @@ fun EXISTS_LEFT' strict fvs_c hfvs [] th = th val _ = if is_var fv then () else raise mk_HOL_ERR "Drule" "EXISTS_LEFT'" "not free variable" ; (* following raises Bind if fv in conclusion *) - val false = List.exists (Lib.equal fv) fvs_c ; + val _ = List.all (not o aconv fv) fvs_c orelse raise Bind fun hyp_ctns_fv {hyp, fvs} = List.exists (Lib.equal fv) fvs ; + val (hyps_ctg_fv, hyps_nc) = List.partition hyp_ctns_fv hfvs ; (* following raises Bind if fv not in any hypothesis *) - val (hyps_ctg_fv as _ :: _, hyps_nc) = List.partition hyp_ctns_fv hfvs ; + val _ = not (null hyps_ctg_fv) orelse raise Bind val conj_tm = list_mk_conj (map #hyp hyps_ctg_fv) ; val conj_th = ASSUME conj_tm ; (* CONJ_LIST gives original hyps, even if they are conjunctions *) @@ -1283,10 +1284,11 @@ fun EXISTS_LEFT' strict fvs_c hfvs [] th = th val thex = EXISTS_LEFT' strict fvs_c ({hyp = ex_conj_tm, fvs = free_vars ex_conj_tm} :: hyps_nc) fvs the ; in thex end - handle exn => if strict then raise - raise mk_HOL_ERR "Drule" "EXISTS_LEFT'" - "free variable in conclusion or not in any hypothesis" - else EXISTS_LEFT' strict fvs_c hfvs fvs th ; + handle Bind => + if strict then + raise mk_HOL_ERR "Drule" "EXISTS_LEFT'" + "free variable in conclusion or not in any hypothesis" + else EXISTS_LEFT' strict fvs_c hfvs fvs th ; (* EXISTS_LEFT : term list -> thm -> thm for each free var in turn, do the following: From 3d42631c7d337a1e1b6bb17d0fab683c29761e5c Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 26 Mar 2015 17:01:39 +1100 Subject: [PATCH 266/718] Fill paragraphs in irule help entry. Also fix one error (I believe): the conclusion {u'} is a substitution and/or type instance of {u}, not {t}. --- help/Docfiles/Tactic.irule.doc | 63 ++++++++++++++++++---------------- 1 file changed, 33 insertions(+), 30 deletions(-) diff --git a/help/Docfiles/Tactic.irule.doc b/help/Docfiles/Tactic.irule.doc index 6bdc9a8ab6..bf302b58b2 100644 --- a/help/Docfiles/Tactic.irule.doc +++ b/help/Docfiles/Tactic.irule.doc @@ -13,53 +13,56 @@ When applied to a theorem of the form { A' |- !x1...xn. s ==> !y1...ym. t ==> !z1...zk. u } -{irule} produces a tactic that reduces a goal whose conclusion -{u'} is a substitution and/or type instance of {t} to the corresponding -instances of {s} and of {t}. -Any variables free in {s} or {t} but not in {u} will be existentially -quantified in the resulting subgoal, and -a variable free in both {s} and {t} will result in a subgoal -which is {s /\ t}, existentially quantified +{irule} produces a tactic that reduces a goal whose conclusion {u'} is +a substitution and/or type instance of {u} to the corresponding +instances of {s} and of {t}. Any variables free in {s} or {t} but not +in {u} will be existentially quantified in the resulting subgoal, and +a variable free in both {s} and {t} will result in a subgoal which is +{s /\ t}, existentially quantified -The following diagram is simplified: more implications and quantified variables -than shown are allowed. +The following diagram is simplified: more implications and quantified +variables than shown are allowed. { A ?- u' ========================= irule (A' |- !x. s ==> !y. t ==> u) A ?- ?z. s' A ?- ?w. t' } -where {z} and {w} are (type instances of) variables among -{x}, {y} that do not occur free in {s}, {t}. -The assumptions {A'}, instantiated, are added as further new subgoals. +where {z} and {w} are (type instances of) variables among {x}, {y} +that do not occur free in {s}, {t}. The assumptions {A'}, +instantiated, are added as further new subgoals. \FAILURE Fails unless the theorem, when stripped of universal quantification and antecedents of implications, can be instantiated to match the goal. \COMMENTS -The supplied theorem is pre-processed using {SPEC_UNDISCH_EXL}, -which removes the universal quantifiers and antecedents of implications, -and applies {EXISTS_LEFT} which -existentially quantifies variables which were instantiated but appeared -only in the antecedents of implications. -See {SPEC_UNDISCH_EXL} for details. +The supplied theorem is pre-processed using {SPEC_UNDISCH_EXL}, which +removes the universal quantifiers and antecedents of implications, and +applies {EXISTS_LEFT} which existentially quantifies variables which +were instantiated but appeared only in the antecedents of +implications. See {SPEC_UNDISCH_EXL} for details. -Then {prim_irule} is applied. To avoid this preprocessing -just use {prim_irule} +Then {prim_irule} is applied. To avoid this preprocessing just use +{prim_irule}. -\EXAMPLE -With goal {R a (f b)} and theorem -{thm = |- !x u. P u x ==> !y. Q w x y ==> R x (f y)} -the proof step {e (irule thm)} gives -new goals {Q w a b} and {?u. P u a} +\EXAMPLE +With goal {R a (f b)} and theorem {thm} being +{ + |- !x u. P u x ==> !y. Q w x y ==> R x (f y) +} +the proof step {e (irule thm)} gives new goals {Q w a b} and +{?u. P u a}. -With goal {a = b} and theorem -{trans = |- !x y. (x = y) ==> !z. (y = z) ==> (x = z)} -the proof step {e (irule trans)} gives -new goal {?y. (a = y) /\ (y = b)} +With goal {a = b} and theorem {trans} +{ + |- !x y. (x = y) ==> !z. (y = z) ==> (x = z) +} +the proof step {e (irule trans)} gives new goal +{ + ?y. (a = y) /\ (y = b) +} \SEEALSO Tactic.MATCH_MP_TAC, Tactic.prim_irule, Drule.SPEC_UNDISCH_EXL, Drule.EXISTS_LEFT \ENDDOC - From d063ac905a9a974cf96cbf1956d23fdfe6e911e8 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Sat, 28 Mar 2015 02:04:16 +0000 Subject: [PATCH 267/718] update fun-op-sem type soundness example, cheats proved --- examples/fun-op-sem/ml/typeSoundScript.sml | 677 ++++++++++++++++++--- 1 file changed, 591 insertions(+), 86 deletions(-) diff --git a/examples/fun-op-sem/ml/typeSoundScript.sml b/examples/fun-op-sem/ml/typeSoundScript.sml index e63cbbaeb9..00ba41f35f 100644 --- a/examples/fun-op-sem/ml/typeSoundScript.sml +++ b/examples/fun-op-sem/ml/typeSoundScript.sml @@ -45,6 +45,14 @@ val _ = new_theory"typeSound" val LUPDATE_ID = store_thm("LUPDATE_ID", ``∀n ls. n < LENGTH ls ⇒ (LUPDATE (EL n ls) n ls = ls)``, rw[LIST_EQ_REWRITE,EL_LUPDATE] >> rw[]) + +val FLOOKUP_f_o_f = store_thm("FLOOKUP_f_o_f", + ``FLOOKUP (f1 f_o_f f2) k = + case FLOOKUP f2 k of + | NONE => NONE + | SOME v => FLOOKUP f1 v``, + simp[FLOOKUP_DEF] >> + simp[f_o_f_DEF] >> rw[] >> fs[]) (* -- *) val _ = ParseExtras.temp_tight_equality() @@ -534,6 +542,11 @@ val tenv_vars_def = Define` tenv_vars tenv = BIGUNION (IMAGE ((λ(tvs,t). tyvars t DIFF tvs) o SND) (set tenv))` +val tenv_vars_cons = store_thm("tenv_vars_cons", + ``tenv_vars ((x,tvs,t)::tenv) = + tyvars t DIFF tvs ∪ tenv_vars tenv``, + rw[tenv_vars_def]) + (* typing relation *) val (type_e_rules,type_e_ind,type_e_cases) = Hol_reln` @@ -593,10 +606,14 @@ val (type_v_rules,type_v_ind,type_v_cases) = Hol_reln` (n < LENGTH et ⇒ type_v rt et (Exn n) (Texn (EL n et))) ∧ (type_env rt et [] []) ∧ - ((∀s. FDOM s ⊆ tvs ⇒ type_v rt et v (tysubst s t)) ∧ + (tvs ⊆ tyvars t ∧ + (∀s. FDOM s ⊆ tvs ⇒ type_v rt et v (tysubst s t)) ∧ type_env rt et env tenv ⇒ type_env rt et ((x,v)::env) ((x,(tvs,t))::tenv))` +(* abbreviation for: a value has all the types represented by a type scheme *) +val _ = overload_on("type_v_ts",``λrt et v tvs t. ∀s. FDOM s ⊆ tvs ⇒ type_v rt et v (tysubst s t)``) + (* we now have a series of lemmas about the type system *) val type_e_clauses = @@ -645,6 +662,10 @@ val FINITE_tyvars = store_thm("FINITE_tyvars[simp]", ho_match_mp_tac t_ind >> simp[] >> simp[EVERY_MEM,PULL_EXISTS]) +val FINITE_tenv_vars = store_thm("FINITE_tenv_vars[simp]", + ``FINITE (tenv_vars tenv)``, + rw[tenv_vars_def,EXISTS_PROD] >> rw[]) + val tysubst_tysubst = store_thm("tysubst_tysubst", ``∀s t s'. tysubst s' (tysubst s t) = tysubst ((tysubst s' o_f s) ⊌ s') t``, ho_match_mp_tac tysubst_ind >> @@ -671,13 +692,26 @@ val tyvars_tysubst = store_thm("tyvars_tysubst", metis_tac[]) val tysubst_frees = store_thm("tysubst_frees", - ``∀t. (∀x. x ∈ tyvars t ⇒ FLOOKUP s1 x = FLOOKUP s2 x) ⇒ + ``∀t. (∀x. x ∈ tyvars t ⇒ + FLOOKUP s1 x = FLOOKUP s2 x) ⇒ tysubst s1 t = tysubst s2 t``, ho_match_mp_tac t_ind >> simp[] >> rw[LIST_EQ_REWRITE,EL_MAP] >> fs[EVERY_MEM,PULL_EXISTS,MEM_EL] >> metis_tac[]) +val tysubst_frees_gen = store_thm("tysubst_frees_gen", + ``∀t. (∀x. x ∈ tyvars t ⇒ + FLOOKUP (s1 ⊌ FUN_FMAP Tvar {x}) x = FLOOKUP (s2 ⊌ FUN_FMAP Tvar {x}) x) ⇒ + tysubst s1 t = tysubst s2 t``, + ho_match_mp_tac t_ind >> + conj_tac >- ( + simp[FLOOKUP_FUNION,FLOOKUP_FUN_FMAP] >> + gen_tac >> BasicProvers.EVERY_CASE_TAC ) >> + rw[LIST_EQ_REWRITE,EL_MAP] >> + fs[EVERY_MEM,PULL_EXISTS,MEM_EL] >> + metis_tac[]) + (* alpha-equivalence of type schemes *) val raconv_def = tDefine"raconv"` @@ -698,31 +732,39 @@ val _ = export_rewrites["raconv_def"] val raconv_ind = theorem"raconv_ind" val tsaconv_def = Define` - tsaconv (tvs1,t1) (tvs2,t2) ⇔ + tsaconv (ftvs1,t1) (ftvs2,t2) ⇔ + let tvs1 = ftvs1 ∩ tyvars t1 in + let tvs2 = ftvs2 ∩ tyvars t2 in ∃f. BIJ f tvs1 tvs2 ∧ raconv f tvs1 tvs2 t1 t2` +val raconv_refl = store_thm("raconv_refl", + ``∀tvs t. raconv (λx. x) tvs tvs t t``, + gen_tac >> ho_match_mp_tac t_ind >> + simp[LIST_REL_EL_EQN,EVERY_MEM,MEM_EL,PULL_EXISTS]) + val tsaconv_refl = store_thm("tsaconv_refl[simp]", ``∀ts. tsaconv ts ts``, Cases >> simp[tsaconv_def] >> + qspec_tac(`q ∩ tyvars r`,`tvs`) >> gen_tac >> qexists_tac`λx. x` >> conj_tac >- simp[BIJ_ID] >> - qid_spec_tac`r` >> - ho_match_mp_tac t_ind >> - simp[LIST_REL_EL_EQN,EVERY_MEM,MEM_EL,PULL_EXISTS]) + metis_tac[raconv_refl]) val tsaconv_sym = store_thm("tsaconv_sym", ``∀t1 t2. tsaconv t1 t2 ⇒ tsaconv t2 t1``, Cases >> Cases >> simp[tsaconv_def] >> + qspec_tac(`q ∩ tyvars r`,`tvs1`) >> gen_tac >> + qspec_tac(`q' ∩ tyvars r'`,`tvs2`) >> gen_tac >> strip_tac >> - qexists_tac`LINV f q` >> + qexists_tac`LINV f tvs1` >> conj_tac >- simp[BIJ_LINV_BIJ] >> pop_assum mp_tac >> map_every qid_spec_tac[`r'`,`r`] >> ho_match_mp_tac t_ind >> conj_tac >- ( gen_tac >> Cases >> simp[] >> - `INJ f q q'` by fs[BIJ_DEF] >> + `INJ f tvs1 tvs2` by fs[BIJ_DEF] >> rw[] >> imp_res_tac LINV_DEF >> imp_res_tac BIJ_LINV_INV >> @@ -731,6 +773,32 @@ val tsaconv_sym = store_thm("tsaconv_sym", gen_tac >> Cases >> simp[] >> fs[EVERY_MEM,LIST_REL_EL_EQN,MEM_EL,PULL_EXISTS]) +val raconv_trans = store_thm("raconv_trans", + ``∀f1 tvs1 tvs2 t1 t2 t3. + BIJ f1 tvs1 tvs2 ⇒ + raconv f1 tvs1 tvs2 t1 t2 ⇒ + BIJ f2 tvs2 tvs3 ⇒ + raconv f2 tvs2 tvs3 t2 t3 ⇒ + raconv (f2 o f1) tvs1 tvs3 t1 t3``, + ho_match_mp_tac raconv_ind >> + conj_tac >- ( + ntac 5 gen_tac >> + Cases >> simp[] >> + rw[] >> fs[] >> + metis_tac[BIJ_DEF,INJ_DEF] ) >> + conj_tac >- ( + rpt gen_tac >> strip_tac >> + Cases >> simp[] >> rw[] >> + fs[LIST_REL_EL_EQN,MEM_EL,PULL_EXISTS] >> + rw[] >> first_x_assum (match_mp_tac o MP_CANON) >> + metis_tac[] ) >> + simp[]) + +val tsaconv_trans = store_thm("tsaconv_trans", + ``∀t1 t2 t3. tsaconv t1 t2 ∧ tsaconv t2 t3 ⇒ tsaconv t1 t3``, + Cases >> Cases >> Cases >> rw[tsaconv_def] >> fs[LET_THM] >> + PROVE_TAC[raconv_trans,BIJ_COMPOSE]) + val raconv_tyvars_eq = prove( ``∀f tvs1 tvs2 t1 t2. BIJ f tvs1 tvs2 ⇒ @@ -747,13 +815,14 @@ val tsaconv_tyvars_eq = store_thm("tsaconv_tyvars_eq", ``∀t1 t2. tsaconv t1 t2 ⇒ tyvars (SND t1) DIFF (FST t1) = tyvars (SND t2) DIFF (FST t2)``, - Cases >> Cases >> rw[tsaconv_def] >> - metis_tac[raconv_tyvars_eq]) + Cases >> Cases >> simp[tsaconv_def] >> + strip_tac >> imp_res_tac raconv_tyvars_eq >> + fs[EXTENSION] >> metis_tac[]) val raconv_imp_tysubst = store_thm("raconv_imp_tysubst", ``∀f tvs1 tvs2 t1 t2. - FINITE tvs1 ⇒ BIJ f tvs1 tvs2 ⇒ + FINITE tvs1 ⇒ raconv f tvs1 tvs2 t1 t2 ⇒ tysubst (FUN_FMAP (Tvar o f) tvs1) t1 = t2``, ho_match_mp_tac raconv_ind >> @@ -764,18 +833,15 @@ val raconv_imp_tysubst = store_thm("raconv_imp_tysubst", val tsaconv_imp_tysubst = store_thm("tsaconv_imp_tysubst", ``∀t1 t2. tsaconv t1 t2 ⇒ FINITE (FST t1) ⇒ - ∃s. FDOM s = FST t1 ∧ - FRANGE s = IMAGE Tvar (FST t2) ∧ + ∃s. FDOM s = FST t1 ∩ tyvars (SND t1) ∧ + FRANGE s = IMAGE Tvar (FST t2 ∩ tyvars (SND t2)) ∧ tysubst s (SND t1) = SND t2``, - Cases >> Cases >> rw[tsaconv_def] >> - imp_res_tac raconv_imp_tysubst >> rw[] >> - qexists_tac`FUN_FMAP (Tvar o f) q` >> rw[] >> + Cases >> Cases >> simp[tsaconv_def] >> rw[] >> + qmatch_assum_rename_tac`BIJ f (tvs1 ∩ tyvars t1) (tvs2 ∩ tyvars t2)` >> + imp_res_tac raconv_imp_tysubst >> rfs[] >> + qexists_tac`FUN_FMAP (Tvar o f) (tvs1 ∩ tyvars t1)` >> rw[] >> fs[BIJ_DEF,IMAGE_COMPOSE,IMAGE_SURJ]) -val dest_Tvar_def = Define` - dest_Tvar (Tvar x) = x` -val _ = export_rewrites["dest_Tvar_def"] - val tysubst_imp_raconv = store_thm("tysubst_imp_raconv", ``∀f tvs1 tvs2 t1 t2. FINITE tvs1 ∧ @@ -807,9 +873,39 @@ val tysubst_imp_aconv = store_thm("tysubst_imp_aconv", ⇒ tsaconv (tvs1,t1) (tvs2,tysubst (FUN_FMAP (Tvar o f) tvs1) t1)``, rw[tsaconv_def] >> - qexists_tac`f` >> rw[] >> + qexists_tac`f` >> + conj_asm1_tac >- ( + unabbrev_all_tac >> + fs[BIJ_IFF_INV,tyvars_tysubst,PULL_EXISTS,FLOOKUP_FUN_FMAP,IN_DISJOINT] >> + qexists_tac`g` >> + metis_tac[]) >> match_mp_tac tysubst_imp_raconv >> - rw[]) + unabbrev_all_tac >> rw[] >- ( + match_mp_tac tysubst_frees >> + simp[FLOOKUP_FUN_FMAP] ) >> + fs[IN_DISJOINT,tyvars_tysubst,FLOOKUP_FUN_FMAP,PULL_EXISTS] >> + metis_tac[]) + +val raconv_eq = prove( + ``∀t1 t2. raconv f ∅ ∅ t1 t2 ⇒ t1 = t2``, + ho_match_mp_tac t_ind >> + conj_tac >- ( + gen_tac >> Cases >> simp[] ) >> + gen_tac >> strip_tac >> gen_tac >> + Cases >> simp[] >> rw[] >> + fs[LIST_REL_EL_EQN,EVERY_MEM,MEM_EL,PULL_EXISTS] >> + rw[LIST_EQ_REWRITE]) + +val tsaconv_eq = store_thm("tsaconv_eq", + ``tsaconv ({},t1) ({},t2) ⇔ t1 = t2``, + reverse EQ_TAC >- metis_tac[tsaconv_refl] >> + rw[tsaconv_def] >> metis_tac[raconv_eq]) + +val tsaconv_empty_imp = prove( + ``tsaconv (∅,t) ts ⇒ FST ts ∩ tyvars (SND ts) = ∅``, + Cases_on`ts`>> simp[tsaconv_def] >> rw[]) + +(* the typing rules respect alpha-equivalence *) val ALOOKUP_MAP_FST_EQ_MAP_SND_REL = store_thm("ALOOKUP_MAP_FST_EQ_MAP_SND_REL", ``∀l1 l2 x y1. @@ -821,12 +917,11 @@ val ALOOKUP_MAP_FST_EQ_MAP_SND_REL = store_thm("ALOOKUP_MAP_FST_EQ_MAP_SND_REL", Cases >> Cases >> simp[] >> Cases_on`h`>>rw[] >> rw[]) -(* the typing rules respect alpha-equivalence *) - val type_e_aconv = store_thm("type_e_aconv", ``∀tenv e t. type_e tenv e t ⇒ EVERY (FINITE o FST o SND) tenv ⇒ ∀tenv'. + EVERY (FINITE o FST o SND) tenv' ∧ MAP FST tenv = MAP FST tenv' ∧ LIST_REL tsaconv (MAP SND tenv) (MAP SND tenv') ⇒ type_e tenv' e t``, @@ -840,27 +935,26 @@ val type_e_aconv = store_thm("type_e_aconv", Cases_on`z`>>simp[]>> first_x_assum(strip_assume_tac o MATCH_MP tsaconv_sym) >> first_assum(mp_tac o MATCH_MP tsaconv_imp_tysubst) >> simp[] >> - `FINITE tvs` by ( + discharge_hyps >- ( imp_res_tac ALOOKUP_MEM >> fs[EVERY_MEM,FORALL_PROD] >> metis_tac[] ) >> - discharge_hyps >- metis_tac[tsaconv_def,FINITE_INJ,BIJ_DEF] >> rw[] >> rw[tysubst_tysubst] >> qexists_tac`tysubst s o_f s'` >> simp[] >> - match_mp_tac tysubst_frees >> - simp[FLOOKUP_FUNION] >> - simp[FLOOKUP_o_f] >> + match_mp_tac tysubst_frees_gen >> + simp[FLOOKUP_FUNION,FLOOKUP_o_f,FLOOKUP_FUN_FMAP] >> gen_tac >> BasicProvers.CASE_TAC >> strip_tac >> + BasicProvers.CASE_TAC >> + qmatch_assum_rename_tac`z ∈ tyvars t` >> + `z ∉ q` by (rfs[FLOOKUP_DEF]>>fs[]) >> imp_res_tac tsaconv_tyvars_eq >> fs[] >> pop_assum mp_tac >> simp[EXTENSION] >> - qmatch_assum_rename_tac`z ∈ tyvars r` >> disch_then(qspec_then`z`mp_tac) >> simp[] >> `z ∉ FDOM s'` by fs[FLOOKUP_DEF] >> simp[] >> simp[tyvars_tysubst] >> strip_tac >> - simp[FLOOKUP_DEF] >> - fs[SUBSET_DEF] >> + fs[SUBSET_DEF,PULL_EXISTS,FLOOKUP_DEF] >> metis_tac[] ) >> conj_tac >- ( simp[type_e_clauses] >> @@ -912,6 +1006,25 @@ val type_e_aconv = store_thm("type_e_aconv", rw[] >> fs[] >> metis_tac[]) +val type_v_ts_aconv = store_thm("type_v_ts_aconv", + ``FINITE tvs ∧ + type_v_ts rt et v tvs t ∧ tsaconv (tvs,t) (tvs',t') ⇒ + type_v_ts rt et v tvs' t'``, + rw[] >> + imp_res_tac tsaconv_imp_tysubst >> + rfs[] >> rw[] >> + rw[tysubst_tysubst] >> + Q.PAT_ABBREV_TAC`ss = X ⊌ s` >> + `tysubst ss t = tysubst (DRESTRICT ss (tyvars t)) t` by ( + match_mp_tac tysubst_frees >> simp[FLOOKUP_DRESTRICT] ) >> + pop_assum SUBST1_TAC >> + first_x_assum match_mp_tac >> + simp[FDOM_DRESTRICT,Abbr`ss`] >> + imp_res_tac tsaconv_tyvars_eq >> + fs[EXTENSION] >> + fs[SUBSET_DEF] >> rw[] >> + metis_tac[]) + (* a type scheme that is fresh for any finite set of variables exists *) val fresh_def = new_specification("fresh_def",["fresh"], @@ -954,63 +1067,276 @@ val DISJOINT_fresh_seq = prove( Induct >> simp[GENLIST,LIST_TO_SET_SNOC] >> metis_tac[fresh_seq_thm]) -(* not yet proved (but not yet needed either) +val BIJ_UPDATE_NOTIN = store_thm("BIJ_UPDATE_NOTIN", + ``BIJ f s t ∧ x ∉ s ⇒ BIJ ((x =+ y) f) s t``, + rw[BIJ_DEF,INJ_DEF,SURJ_DEF,combinTheory.APPLY_UPDATE_THM] >> rw[] >> + metis_tac[]) + +val BIJ_fresh_seq = prove( + ``∀s. FINITE s ⇒ ∀a. FINITE a ⇒ + ∃f. BIJ f s (set (GENLIST (fresh_seq a) (CARD s)))``, + ho_match_mp_tac FINITE_INDUCT >> + conj_tac >- simp[] >> + gen_tac >> strip_tac >> + gen_tac >> strip_tac >> + gen_tac >> strip_tac >> + first_x_assum(qspec_then`a`(fn th => first_assum(strip_assume_tac o MATCH_MP th))) >> + simp[GENLIST,LIST_TO_SET_SNOC,BIJ_INSERT] >> + qexists_tac`(e =+ fresh_seq a (CARD s)) f` >> + simp[combinTheory.APPLY_UPDATE_THM] >> + qmatch_assum_abbrev_tac`BIJ f s t` >> + simp[DELETE_INSERT] >> + Q.PAT_ABBREV_TAC`n = fresh_seq a Z` >> + `n ∉ t` by ( + simp[Abbr`t`,MEM_GENLIST,Abbr`n`] >> + spose_not_then strip_assume_tac >> + qspecl_then[`SUC(CARD s)`,`a`]mp_tac ALL_DISTINCT_fresh_seq >> + simp[ALL_DISTINCT_GENLIST] >> + qexists_tac`CARD s` >> + qexists_tac`m` >> + simp[]) >> + pop_assum(SUBST1_TAC o REWRITE_RULE[DELETE_NON_ELEMENT]) >> + match_mp_tac BIJ_UPDATE_NOTIN >> rw[]) + val fresh_ts_exists = prove( ``∃f. ∀avoid ts. FINITE avoid ∧ FINITE (FST ts) ⇒ DISJOINT avoid (FST (f avoid ts)) ∧ - tsaconv ts (f avoid ts)``, + tsaconv ts (f avoid ts) ∧ + FST(f avoid ts) ⊆ tyvars (SND(f avoid ts))``, simp[GSYM SKOLEM_THM] >> rw[RIGHT_EXISTS_IMP_THM] >> - `∃f tvs2. BIJ f (FST ts) tvs2 ∧ DISJOINT tvs2 (tyvars (SND ts) ∪ avoid)` by cheat >> + `∃f tvs2. BIJ f (FST ts) tvs2 ∧ DISJOINT tvs2 (tyvars (SND ts) ∪ avoid)` by ( + Q.PAT_ABBREV_TAC`a = X ∪ avoid` >> + Q.PAT_ABBREV_TAC`s = FST ts` >> + qabbrev_tac`ls = GENLIST (fresh_seq a) (CARD s)` >> + Q.ISPEC_THEN`s`mp_tac BIJ_fresh_seq >> simp[] >> + disch_then(qspec_then`a`mp_tac) >> + discharge_hyps >- simp[Abbr`a`] >> strip_tac >> + first_assum(match_exists_tac o concl) >> + conj_tac >- simp[] >> + simp[Abbr`ls`,DISJOINT_fresh_seq,Abbr`a`] ) >> qspecl_then[`f`,`FST ts`,`SND ts`,`tvs2`]mp_tac tysubst_imp_aconv >> simp[] >> fs[] >> simp[Once DISJOINT_SYM] >> strip_tac >> simp[EXISTS_PROD] >> - metis_tac[]) + qmatch_assum_abbrev_tac`tsaconv ts (tvs2,t2)` >> + qexists_tac`tvs2 ∩ tyvars t2` >> qexists_tac`t2` >> + fs[IN_DISJOINT] >> + conj_tac >- metis_tac[] >> + Cases_on`ts`>> fs[tsaconv_def,LET_THM] >> + metis_tac[INTER_IDEMPOT,INTER_ASSOC]) val fresh_ts_def = new_specification("fresh_ts_def",["fresh_ts"],fresh_ts_exists) -*) - -(* -We have not yet proved the following properties of the type system. The proofs -will likely require much tedious reasoning about capture-avoiding substitution -over type schemes. Since they are solely about the type system, and not the -semantics, this does not depend on whether functional big-step or small-step -semantics is used. However, these are the only proofs where the value -restriction is relevant. -*) -val generalisation_lemma1 = prove( - ``type_env rt et env tenv ∧ type_v rt et v t ∧ - MEM v (MAP SND env) ∧ - FDOM s ⊆ tyvars t DIFF tenv_vars tenv ⇒ - type_v rt et v (tysubst s t)``, - cheat) - -val generalisation_lemma2 = prove( - ``type_env rt et env tenv ∧ - type_env rt et env tenv2 ∧ - type_e ((x,{},t1)::tenv) e t2 ∧ - FDOM s ⊆ tyvars (Tfn t1 t2) DIFF tenv_vars tenv2 +(* capture-avoiding substitution on type schemes and environments *) + +val tssubst_def = Define` + tssubst s (tvs,t) (tvs2,t2) ⇔ + ∃t'. + tvs2 ⊆ tyvars t2 ∧ + tsaconv (tvs,t) (tvs2,t') ∧ + DISJOINT (BIGUNION (IMAGE tyvars (FRANGE (DRESTRICT s (tyvars t' DIFF tvs2))))) tvs2 ∧ + t2 = tysubst (DRESTRICT s (tyvars t' DIFF tvs2)) t'` + +val tssubst_tysubst = store_thm("tssubst_tysubst", + ``tssubst s ({},t) ({},tysubst s t)``, + simp[tssubst_def] >> + qexists_tac`t` >> simp[] >> + match_mp_tac tysubst_frees >> + simp[FLOOKUP_DRESTRICT]) + +val tssubst_FINITE = store_thm("tssubst_FINITE", + ``FINITE (FST ts) ∧ tssubst s ts ts' ⇒ FINITE (FST ts')``, + Cases_on`ts`>>Cases_on`ts'`>>simp[tssubst_def] >> + metis_tac[FINITE_tyvars,SUBSET_FINITE]) + +val tysubst_tssubst = store_thm("tysubst_tssubst", + ``FINITE tvs ∧ + FDOM s ⊆ tvs ∧ + tssubst s' (tvs,t) (tvs',t') ⇒ - ∃tenv'. - type_env rt et env tenv' ∧ - type_e ((x,{},tysubst s t1)::tenv') e (tysubst s t2)``, - cheat) - -val generalisation_lemma3 = prove( - ``type_env rt et env tenv ∧ - type_env rt et env tenv2 ∧ - type_e ((x,{},t1)::(f,{},Tfn t1 t2)::tenv) e t2 ∧ - FDOM s ⊆ tyvars (Tfn t1 t2) DIFF tenv_vars tenv2 + ∃s''. FDOM s'' ⊆ tvs' ∧ + tysubst s' (tysubst s t) = tysubst s'' t'``, + rw[tssubst_def,PULL_EXISTS] >> + fs[tsaconv_def,LET_THM] >> + imp_res_tac raconv_imp_tysubst >> rfs[] >> res_tac >> + BasicProvers.VAR_EQ_TAC >> pop_assum kall_tac >> + Q.PAT_ABBREV_TAC`tvs1 = tyvars (tysubst X Y)` >> + `tvs1 = IMAGE f (tvs ∩ tyvars t) ∪ (tyvars t DIFF tvs)` by ( + simp[Abbr`tvs1`,tyvars_tysubst,Once EXTENSION,PULL_EXISTS,FLOOKUP_FUN_FMAP] >> + metis_tac[] ) >> + BasicProvers.VAR_EQ_TAC >> + pop_assum kall_tac >> + qexists_tac`(tysubst s' o_f s ⊌ s' ⊌ FUN_FMAP Tvar tvs) f_o_f FUN_FMAP (LINV f (tvs ∩ tyvars t)) tvs'` >> + `FINITE tvs'` by metis_tac[SUBSET_FINITE,FINITE_tyvars] >> + conj_tac >- ( simp[f_o_f_DEF,FUN_FMAP_DEF] ) >> + simp[tysubst_tysubst] >> + match_mp_tac tysubst_frees_gen >> + gen_tac >> strip_tac >> + simp[FLOOKUP_FUNION,FLOOKUP_o_f,FLOOKUP_FUN_FMAP,FLOOKUP_f_o_f,FLOOKUP_DRESTRICT] >> + IF_CASES_TAC >> simp[FLOOKUP_FUNION,FLOOKUP_o_f,FLOOKUP_f_o_f,FLOOKUP_FUN_FMAP,FLOOKUP_DRESTRICT] >- ( + `f x ∈ tvs'` by fs[BIJ_DEF,INJ_DEF] >> fs[] >> + `LINV f (tvs ∩ tyvars t) (f x) = x` by metis_tac[LINV_DEF,BIJ_DEF,IN_INTER] >> + simp[] >> + BasicProvers.CASE_TAC >> simp[] >> + BasicProvers.CASE_TAC >> simp[] ) >> + `FLOOKUP s x = NONE` by ( + fs[FLOOKUP_DEF,SUBSET_DEF,GSYM SUBSET_INTER_ABSORPTION] >> + metis_tac[] ) >> + simp[] >> + `x ∉ tvs'` by ( + imp_res_tac raconv_tyvars_eq >> + fs[EXTENSION] >> + metis_tac[] ) >> + simp[] >> + BasicProvers.CASE_TAC >> simp[] >> + CONV_TAC(LAND_CONV(REWR_CONV(GSYM tysubst_nil))) >> + match_mp_tac tysubst_frees_gen >> + simp[FLOOKUP_FUNION,FLOOKUP_FUN_FMAP,FLOOKUP_f_o_f,FLOOKUP_o_f] >> + rw[] >> + fs[IN_FRANGE_FLOOKUP,FLOOKUP_DRESTRICT,PULL_EXISTS,IN_DISJOINT] >> + metis_tac[]) + +val tssubst_frees = store_thm("tssubst_frees", + ``FINITE (FST ts) ∧ + (∀x. x ∈ tyvars (SND ts) DIFF (FST ts) ⇒ + FLOOKUP s1 x = FLOOKUP s2 x) ∧ + tssubst s1 ts ts' ⇒ + tssubst s2 ts ts'``, + map_every Cases_on[`ts`,`ts'`] >> + rw[tssubst_def,PULL_EXISTS] >> + first_assum(match_exists_tac o concl) >> + simp[] >> + imp_res_tac tsaconv_tyvars_eq >> fs[EXTENSION] >> + conj_tac >- ( + fs[IN_FRANGE_FLOOKUP,FLOOKUP_DRESTRICT,PULL_EXISTS] >> + metis_tac[] ) >> + match_mp_tac tysubst_frees >> + simp[FLOOKUP_DRESTRICT]) + +val tssubst_exists = store_thm("tssubst_exists", + ``∀s ts. FINITE (FST ts) ⇒ ∃ts'. tssubst s ts ts'``, + rw[EXISTS_PROD] >> + `∃tvs t. ts = (tvs,t)` by metis_tac[PAIR] >> + rw[tssubst_def,PULL_EXISTS] >> + qabbrev_tac`a = BIGUNION (IMAGE tyvars (FRANGE s))` >> + qspecl_then[`a`,`tvs,t`]mp_tac fresh_ts_def >> + discharge_hyps >- ( simp[PULL_EXISTS,Abbr`a`] ) >> + strip_tac >> + `∃tvs' t'. fresh_ts a (tvs,t) = (tvs',t')` by metis_tac[PAIR] >> fs[] >> + rw[Once CONJ_COMM] >> + first_assum(match_exists_tac o concl) >> + simp[IN_FRANGE_FLOOKUP,tyvars_tysubst,PULL_EXISTS,FLOOKUP_DRESTRICT,FDOM_DRESTRICT] >> + fs[SUBSET_DEF,IN_DISJOINT,Abbr`a`,PULL_EXISTS,IN_FRANGE_FLOOKUP] >> + metis_tac[]) + +val tenv_subst_def = Define` + tenv_subst s tenv tenv' ⇔ + MAP FST tenv = MAP FST tenv' ∧ + LIST_REL (tssubst s) (MAP SND tenv) (MAP SND tenv')` + +val tenv_subst_cons = store_thm("tenv_subst_cons", + ``tenv_subst s tenv tenv' ∧ + tssubst s ts ts' + ⇒ tenv_subst s ((x,ts)::tenv) ((x,ts')::tenv')``, + rw[tenv_subst_def]) + +val tenv_subst_exists = store_thm("tenv_subst_exists", + ``EVERY (FINITE o FST o SND) tenv ⇒ + ∃tenv'. tenv_subst s tenv tenv'``, + rw[tenv_subst_def] >> + simp[exists_list_GENLIST] >> + qexists_tac`LENGTH tenv` >> + qexists_tac`λn. FST(EL n tenv), @ts'. tssubst s (SND (EL n tenv)) ts'` >> + simp[LIST_EQ_REWRITE,EL_MAP,EVERY2_MAP] >> + simp[LIST_REL_EL_EQN] >> rw[] >> + SELECT_ELIM_TAC >> simp[] >> + fs[EVERY_MEM,MEM_EL,PULL_EXISTS] >> + metis_tac[tssubst_exists]) + +val tyvars_tssubst_eq = store_thm("tyvars_tssubst_eq", + ``tssubst s ts (bvs,b) ⇒ FINITE (FST ts) ⇒ + tyvars b DIFF bvs = + (tyvars (SND ts) DIFF (FST ts ∪ FDOM s)) ∪ + BIGUNION (IMAGE tyvars (FRANGE (DRESTRICT s (tyvars (SND ts) DIFF (FST ts)))))``, + `∃tvs t. ts = (tvs,t)` by metis_tac[PAIR] >> + simp[tssubst_def,PULL_EXISTS] >> rw[] >> + simp[Once EXTENSION,PULL_EXISTS,tyvars_tysubst,FLOOKUP_DRESTRICT,FDOM_DRESTRICT,IN_FRANGE_FLOOKUP] >> + imp_res_tac tsaconv_tyvars_eq >> fs[] >> + fs[tyvars_tysubst,SUBSET_DEF,PULL_EXISTS,FDOM_DRESTRICT,FLOOKUP_DRESTRICT,EXTENSION,IN_FRANGE_FLOOKUP,IN_DISJOINT] >> + metis_tac[] ) + +val tenv_vars_tenv_subst_eq = store_thm("tenv_vars_tenv_subst_eq", + ``EVERY (FINITE o FST o SND) tenv ⇒ + tenv_subst s tenv tenv' ⇒ + tenv_vars tenv' = + (tenv_vars tenv DIFF FDOM s) ∪ + BIGUNION (IMAGE tyvars (FRANGE (DRESTRICT s (tenv_vars tenv))))``, + qid_spec_tac`tenv'` >> + Induct_on`tenv` >- simp[tenv_subst_def,tenv_vars_def,DRESTRICT_IS_FEMPTY] >> + simp[FORALL_PROD] >> + qx_genl_tac[`x`,`tvs`,`t`] >> + fs[tenv_subst_def] >> + Cases>>simp[]>> + PairCases_on`h`>>simp[] >> rw[] >> fs[] >> + first_x_assum(qspec_then`t'`mp_tac) >> + rw[tenv_vars_cons] >> + imp_res_tac tyvars_tssubst_eq >> + simp[] >> + pop_assum kall_tac >> + fs[Once EXTENSION,PULL_EXISTS] >> + fs[IN_FRANGE_FLOOKUP,FLOOKUP_DRESTRICT,PULL_EXISTS] >> + `∀k v. FLOOKUP s k = SOME v ⇒ k ∈ FDOM s` by simp[FLOOKUP_DEF] >> + metis_tac[]) + +val tssubst_id = store_thm("tssubst_id", + ``FST ts ⊆ tyvars (SND ts) ∧ + DISJOINT (FDOM s) (tyvars (SND ts) DIFF (FST ts)) + ⇒ tssubst s ts ts``, + Cases_on`ts`>>simp[tssubst_def] >> rw[] >> + qexists_tac`r` >> rw[] >- ( + fs[IN_FRANGE_FLOOKUP,FLOOKUP_DRESTRICT,IN_DISJOINT] >> + fs[FLOOKUP_DEF] >> metis_tac[] ) >> + `DRESTRICT s (tyvars r DIFF q) = FEMPTY` by ( + simp[fmap_eq_flookup,FLOOKUP_DRESTRICT] >> + fs[IN_DISJOINT,FLOOKUP_DEF] >> + metis_tac[] ) >> + rw[]) + +val tenv_subst_id = store_thm("tenv_subst_id", + ``EVERY (λ(tvs,t). tvs ⊆ tyvars t) (MAP SND tenv) ∧ + DISJOINT (FDOM s) (tenv_vars tenv) ⇒ - ∃tenv'. - type_env rt et env tenv' ∧ - type_e ((x,{},tysubst s t1)::(f,{},tysubst s (Tfn t1 t2))::tenv') e (tysubst s t2)``, - cheat) + tenv_subst s tenv tenv``, + Induct_on`tenv`>-simp[tenv_subst_def] >> + Cases >> rw[] >> fs[] >> + match_mp_tac tenv_subst_cons >> + Cases_on`r` >> fs[tenv_vars_cons] >> + conj_tac >- ( + first_x_assum match_mp_tac >> + fs[IN_DISJOINT,SUBSET_DEF] >> + metis_tac[] ) >> + match_mp_tac tssubst_id >> + fs[IN_DISJOINT] >> + metis_tac[]) -(* lemma about type environment's relationship to value environment *) +(* lemmas about type environment and its relationship to value environment *) + +val type_env_EVERY_SUBSET = prove( + ``type_env rt et env tenv ⇒ + EVERY (λ(tvs,t). tvs ⊆ tyvars t) (MAP SND tenv)``, + qid_spec_tac`tenv`>> + Induct_on`env`>> simp[type_env_clauses] >> + simp[PULL_EXISTS] >> rw[]) + +val type_env_EVERY_FINITE = prove( + ``type_env rt et env tenv ⇒ + EVERY (FINITE o FST o SND) tenv``, + rw[] >> + imp_res_tac type_env_EVERY_SUBSET >> + fs[EVERY_MEM,MEM_MAP,PULL_EXISTS,FORALL_PROD] >> + metis_tac[FINITE_tyvars,SUBSET_FINITE]) val type_env_ALOOKUP_tenv_SOME = prove( ``∀env tenv. type_env rt et env tenv ⇒ @@ -1026,6 +1352,182 @@ val type_env_ALOOKUP_tenv_SOME = prove( rw[] >> rw[] >> fs[] >> metis_tac[]) +val type_env_ALOOKUP_env_SOME = prove( + ``∀env tenv. type_env rt et env tenv ⇒ + ∀x v. + ALOOKUP env x = SOME v ⇒ + ∃tvs t. ALOOKUP tenv x = SOME (tvs,t) ∧ + ∀s. FDOM s ⊆ tvs ⇒ + type_v rt et v (tysubst s t)``, + Induct >> simp[type_env_clauses] >> + Cases >> simp[] >> + Cases >> simp[] >> + PairCases_on`h`>>simp[] >> + rw[] >> rw[] >> fs[] >> + metis_tac[]) + +(* substitution lemma: typing rules respect substitution *) + +val tysubst_Tfn = SIMP_CONV(srw_ss())[]``tysubst s (Tfn t1 t2)`` +val tysubst_Texn = SIMP_CONV(srw_ss())[]``tysubst s (Texn t1)`` + +val type_e_subst = store_thm("type_e_subst", + ``∀tenv e t. type_e tenv e t ⇒ EVERY (FINITE o FST o SND) tenv + ⇒ ∀s tenv'. tenv_subst s tenv tenv' ⇒ type_e tenv' e (tysubst s t)``, + ho_match_mp_tac type_e_ind >> + rpt conj_tac >> + (* most cases *) + TRY ( + simp[type_e_clauses] >> rw[] >> fs[] >> + PROVE_TAC[tenv_subst_cons,tssubst_tysubst,tysubst_Tfn,tysubst_Texn]) >> + (* var *) + TRY ( + simp[type_e_clauses] >> rw[] >> + fs[tenv_subst_def] >> + imp_res_tac ALOOKUP_MAP_FST_EQ_MAP_SND_REL >> + fs[] >> rw[] >> fs[] >> rw[] >> + `∃tvs' t'. y2 = (tvs',t')` by metis_tac[PAIR] >> + simp[] >> + `FINITE tvs` by ( + imp_res_tac ALOOKUP_MEM >> + fs[EVERY_MEM,FORALL_PROD] >> + metis_tac[] ) >> + metis_tac[tysubst_tssubst] ) >> + (* let value *) + TRY ( + qx_genl_tac[`e1`,`e2`,`t1`,`t2`] >> + simp[type_e_clauses] >> rw[] >> fs[] >> + qabbrev_tac`s1 = DRESTRICT s (tenv_vars tenv)` >> + qabbrev_tac`a = BIGUNION (IMAGE tyvars (FRANGE s1)) ∪ tenv_vars tenv` >> + qspecl_then[`a`,`tyvars t1 DIFF tenv_vars tenv,t1`]mp_tac fresh_ts_def >> + discharge_hyps >- ( + simp[Abbr`a`,PULL_EXISTS] ) >> + Q.PAT_ABBREV_TAC`tvs = tyvars t1 DIFF _` >> + `∃tvs' t'. fresh_ts a (tvs,t1) = (tvs',t')` by metis_tac[PAIR] >> + simp[] >> strip_tac >> + `FINITE tvs` by simp[Abbr`tvs`] >> + imp_res_tac tsaconv_imp_tysubst >> rfs[] >> + qmatch_assum_rename_tac`FDOM r = _` >> + qexists_tac`tysubst (s1 ⊌ r) t1` >> + conj_tac >- ( + first_x_assum match_mp_tac >> + fs[tenv_subst_def] >> + match_mp_tac EVERY2_MEM_MONO >> + qexists_tac`tssubst s` >> + imp_res_tac LIST_REL_LENGTH >> fs[] >> + simp[ZIP_MAP,MEM_MAP,PULL_EXISTS,FORALL_PROD] >> + rw[] >> + match_mp_tac (GEN_ALL tssubst_frees) >> simp[] >> + simp[RIGHT_EXISTS_AND_THM] >> + conj_tac >- ( + rfs[MEM_ZIP,EVERY_MEM,MEM_EL,PULL_EXISTS] >> + metis_tac[FST,SND] ) >> + simp[Once CONJ_COMM] >> + first_assum(match_exists_tac o concl) >> simp[] >> + simp[FLOOKUP_FUNION] >> rw[] >> + simp[Abbr`s1`,FLOOKUP_DRESTRICT] >> + IF_CASES_TAC >> simp[] >- ( + BasicProvers.CASE_TAC >> + simp[FLOOKUP_DEF,Abbr`tvs`] ) >> + imp_res_tac MEM_ZIP_MEM_MAP >> rfs[] >> + fs[tenv_vars_def,FORALL_PROD,PULL_EXISTS] >> + metis_tac[]) >> + `tvs' ⊆ tyvars (tysubst (s1 ⊌ r) t1)` by ( + BasicProvers.VAR_EQ_TAC >> + fs[tyvars_tysubst,SUBSET_DEF,PULL_EXISTS,Abbr`s1`,FDOM_DRESTRICT,FLOOKUP_DRESTRICT,FLOOKUP_FUNION] >> + qx_gen_tac`z` >> strip_tac >> + fs[IN_DISJOINT,Abbr`a`,PULL_EXISTS,IN_FRANGE_FLOOKUP,FLOOKUP_DRESTRICT,Abbr`tvs`] >> + first_x_assum(qspec_then`z`mp_tac) >> simp[] >> + imp_res_tac tsaconv_tyvars_eq >> + fs[EXTENSION,PULL_EXISTS,tyvars_tysubst] >> + strip_tac >- metis_tac[] >> + disj2_tac >> + first_assum(match_exists_tac o concl) >> simp[] >> + first_assum(match_exists_tac o concl) >> simp[] >> + IF_CASES_TAC >> simp[] >> + fs[FLOOKUP_DEF] >> + metis_tac[] ) >> + `tssubst s (tvs,t1) (tvs',tysubst (s1 ⊌ r) t1)` by ( + simp[tssubst_def,PULL_EXISTS] >> + qexists_tac`t'` >> simp[] >> + conj_tac >- ( + BasicProvers.VAR_EQ_TAC >> + imp_res_tac tsaconv_tyvars_eq >> + simp[IN_FRANGE_FLOOKUP,FLOOKUP_DRESTRICT,PULL_EXISTS] >> + fs[IN_DISJOINT,Abbr`a`,PULL_EXISTS,Abbr`s1`,IN_FRANGE_FLOOKUP,FLOOKUP_DRESTRICT] >> rw[] >> + first_x_assum match_mp_tac >> + qexists_tac`k` >> simp[] >> + fs[EXTENSION,Abbr`tvs`] >> + metis_tac[] ) >> + BasicProvers.VAR_EQ_TAC >> + simp[tysubst_tysubst] >> + match_mp_tac tysubst_frees >> + simp[FLOOKUP_FUNION,FLOOKUP_DRESTRICT,FLOOKUP_o_f] >> + qx_gen_tac`z` >> strip_tac >> + simp[Abbr`s1`,FLOOKUP_DRESTRICT] >> + IF_CASES_TAC >- ( + `FLOOKUP r z = NONE` by ( + simp[FLOOKUP_DEF,Abbr`tvs`] ) >> + simp[] >> + BasicProvers.CASE_TAC >> simp[] >> + simp[tyvars_tysubst,PULL_EXISTS,Abbr`tvs`] >> + fs[Abbr`a`,IN_DISJOINT,PULL_EXISTS,IN_FRANGE_FLOOKUP,FLOOKUP_DRESTRICT] >> + metis_tac[] ) >> + simp[] >> + BasicProvers.CASE_TAC >- ( + IF_CASES_TAC >> simp[] >> + imp_res_tac tsaconv_tyvars_eq >> + fs[Abbr`tvs`] >> + fs[EXTENSION] >> + metis_tac[] ) >> + CONV_TAC(LAND_CONV(REWR_CONV(GSYM tysubst_nil))) >> + match_mp_tac tysubst_frees >> + simp[FLOOKUP_DRESTRICT] >> + imp_res_tac tsaconv_tyvars_eq >> + fs[Abbr`tvs`] >> + qmatch_assum_rename_tac`FLOOKUP r z = SOME u` >> + `u ∈ FRANGE r` by (simp[IN_FRANGE_FLOOKUP]>>metis_tac[])>> + rfs[] ) >> + first_x_assum match_mp_tac >> + match_mp_tac tenv_subst_cons >> + simp[] >> + BasicProvers.VAR_EQ_TAC >> + `tyvars (tysubst (s1 ⊌ r) t1) DIFF tenv_vars tenv' = tvs'` suffices_by simp[] >> + simp[SET_EQ_SUBSET] >> + conj_tac >- ( + imp_res_tac tsaconv_tyvars_eq >> + pop_assum mp_tac >> + qpat_assum`DISJOINT a tvs'`mp_tac >> + simp[tyvars_tysubst,SUBSET_DEF,PULL_EXISTS,FLOOKUP_FUNION,Abbr`s1`,FLOOKUP_DRESTRICT,FDOM_DRESTRICT] >> + simp[Abbr`a`,IN_DISJOINT,EXTENSION,IN_FRANGE_FLOOKUP,FLOOKUP_DRESTRICT,PULL_EXISTS,Abbr`tvs`] >> + rw[] >> + pop_assum mp_tac >> + imp_res_tac tenv_vars_tenv_subst_eq >> + simp[PULL_EXISTS] >> + simp[IN_FRANGE_FLOOKUP,FLOOKUP_DRESTRICT,PULL_EXISTS] >> + pop_assum kall_tac >> + pop_assum mp_tac >> + IF_CASES_TAC >> simp[] >- ( + qmatch_assum_rename_tac`y ∈ tenv_vars tenv` >> + `FLOOKUP r y = NONE` by ( + simp[FLOOKUP_DEF] ) >> + BasicProvers.CASE_TAC >> simp[] >> + strip_tac >> BasicProvers.VAR_EQ_TAC >> + metis_tac[] ) >> + qmatch_assum_rename_tac`y ∉ tenv_vars tenv` >> + strip_tac >> + `u ∈ FRANGE r` by ( + simp[IN_FRANGE_FLOOKUP] >> + metis_tac[] ) >> + pop_assum mp_tac >> simp[PULL_EXISTS] >> + gen_tac >> strip_tac >> fs[] ) >> + fs[SUBSET_DEF] >> + imp_res_tac tenv_vars_tenv_subst_eq >> + spose_not_then strip_assume_tac >> + pop_assum mp_tac >> simp[] >> + fs[IN_DISJOINT,Abbr`a`,PULL_EXISTS,IN_FRANGE_FLOOKUP,Abbr`s1`,FLOOKUP_DRESTRICT] >> + metis_tac[] )) + (* We prove type soundness by induction on the semantics. This works because both the typing relation and the semantics are syntax-directed. We establish that @@ -1143,26 +1645,29 @@ val type_soundness = store_thm("type_soundness", `∃r' s2. sem ((x,v)::env) s1 e' = (r',s2)` by metis_tac[pairTheory.PAIR] >> simp[] >> fs[LET_THM] >> rpt gen_tac >> rpt strip_tac >> - first_x_assum(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> + first_x_assum(fn th => first_assum(mp_tac o MATCH_MP th)) >> disch_then(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> simp[] >> strip_tac >> first_x_assum(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> disch_then(fn th => first_x_assum(mp_tac o MATCH_MP th)) >> fs[type_env_clauses,PULL_EXISTS] >> simp[FDOM_EQ_EMPTY] >> TRY(discharge_hyps >- ( + rw[] >> + qmatch_assum_rename_tac`FDOM ss ⊆ _` >> + `tenv_subst ss tenv tenv` by ( + match_mp_tac tenv_subst_id >> + conj_tac >- metis_tac[type_env_EVERY_SUBSET] >> + fs[SUBSET_DEF,IN_DISJOINT] >> + metis_tac[] ) >> + `type_e tenv e (tysubst ss t1)` by ( + match_mp_tac (MP_CANON type_e_subst) >> + metis_tac[type_env_EVERY_FINITE] ) >> Cases_on`e`>>fs[sem_def]>>BasicProvers.EVERY_CASE_TAC>>fs[]>> - rw[]>>fs[type_v_clauses,LENGTH_NIL]>>rw[]>>fs[] - >- ( - `MEM v (MAP SND env)` by ( - imp_res_tac ALOOKUP_MEM >> - simp[MEM_MAP,EXISTS_PROD] >> - metis_tac[] ) >> - metis_tac[generalisation_lemma1]) - >- ( metis_tac[generalisation_lemma2, - SIMP_CONV(srw_ss())[]``tyvars (Tfn t1 t2)``] ) - >- ( - match_mp_tac (GEN_ALL(SIMP_RULE(srw_ss())[]generalisation_lemma3))>> - metis_tac[]))) >> + rw[]>>fs[type_v_clauses,LENGTH_NIL]>>rw[]>>fs[]>> + fs[type_e_clauses] >- ( + imp_res_tac type_env_ALOOKUP_tenv_SOME >> + fs[] >> rw[] ) >> + metis_tac[])) >> strip_tac >> BasicProvers.CASE_TAC >> fs[] >> qexists_tac`rt'++rt''` >> From f63ebdccc5bd8fb9aa530301f446fd05871f1991 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Sun, 29 Mar 2015 21:07:07 +1100 Subject: [PATCH 268/718] change irule to do GEN_ALL to argument theorem first links from help pages for MATCH_{ACCEPT,MP}_tac to [prim_]irule --- help/Docfiles/Drule.SPEC_UNDISCH_EXL.doc | 3 ++- help/Docfiles/Tactic.MATCH_ACCEPT_TAC.doc | 3 ++- help/Docfiles/Tactic.MATCH_MP_TAC.doc | 5 ++++- src/1/Tactic.sml | 2 +- 4 files changed, 9 insertions(+), 4 deletions(-) diff --git a/help/Docfiles/Drule.SPEC_UNDISCH_EXL.doc b/help/Docfiles/Drule.SPEC_UNDISCH_EXL.doc index 1c794cead3..7048d90b71 100644 --- a/help/Docfiles/Drule.SPEC_UNDISCH_EXL.doc +++ b/help/Docfiles/Drule.SPEC_UNDISCH_EXL.doc @@ -24,7 +24,8 @@ No failure. Can leave the supplied theorem unchanged. \COMMENTS See {EXISTS_LEFT} for more on the existential quantification aspect. Note that the existential quantification happens only for variables -which were universally quantified in the supplied theorem. +which were universally quantified in the supplied theorem +(to get around this limitation, first apply {GEN_ALL} to the supplied theorem). \EXAMPLE Where {trans_thm} is {[] |- !x y z. (x = y) ==> (y = z) ==> (x = z)} diff --git a/help/Docfiles/Tactic.MATCH_ACCEPT_TAC.doc b/help/Docfiles/Tactic.MATCH_ACCEPT_TAC.doc index 5382ce0dc0..0e3655cc47 100644 --- a/help/Docfiles/Tactic.MATCH_ACCEPT_TAC.doc +++ b/help/Docfiles/Tactic.MATCH_ACCEPT_TAC.doc @@ -39,7 +39,8 @@ simply by: MATCH_ACCEPT_TAC HD } +\COMMENTS {prim_irule} is similar, with differences in the details \SEEALSO -Tactic.ACCEPT_TAC. +Tactic.ACCEPT_TAC, Tactic.prim_irule \ENDDOC diff --git a/help/Docfiles/Tactic.MATCH_MP_TAC.doc b/help/Docfiles/Tactic.MATCH_MP_TAC.doc index 1ddb1b952d..5b4dc8e056 100644 --- a/help/Docfiles/Tactic.MATCH_MP_TAC.doc +++ b/help/Docfiles/Tactic.MATCH_MP_TAC.doc @@ -32,6 +32,9 @@ whose consequent can be instantiated to match the goal. The generalized variables {v1}, ..., {vi} must occur in {s'} in order for the conclusion {t} of the supplied theorem to match {t'}. +\COMMENTS {irule} is similar, with differences in the details + \SEEALSO -Thm.EQ_MP, Drule.MATCH_MP, Thm.MP, Tactic.MP_TAC, ConseqConv.CONSEQ_CONV_TAC. +Tactic.irule, Thm.EQ_MP, Drule.MATCH_MP, Thm.MP, Tactic.MP_TAC, +ConseqConv.CONSEQ_CONV_TAC. \ENDDOC diff --git a/src/1/Tactic.sml b/src/1/Tactic.sml index 6c1e6384ed..f28abeaf8a 100644 --- a/src/1/Tactic.sml +++ b/src/1/Tactic.sml @@ -787,7 +787,7 @@ end * (3) hypotheses of the theorem provided also become new subgoals * * --------------------------------------------------------------------------*) -fun irule thm = prim_irule (SPEC_UNDISCH_EXL thm) ; +fun irule thm = prim_irule (SPEC_UNDISCH_EXL (GEN_ALL thm)) ; (* ----------------------------------------------------------------------* * Definition of the standard resolution tactics IMP_RES_TAC and RES_TAC * From 2c011a77c25184348205fa771fec45964b1f3088 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Mon, 30 Mar 2015 10:39:09 +0100 Subject: [PATCH 269/718] failing test corresponding to github issue #248 --- src/TeX/theory_tests/.gitignore | 1 + src/TeX/theory_tests/Holmakefile | 9 ++++++++- src/TeX/theory_tests/foo248Script.sml | 5 +++++ src/TeX/theory_tests/gh248_expected | 1 + src/TeX/theory_tests/gh248_input | 1 + src/TeX/theory_tests/overrides248 | 4 ++++ src/TeX/theory_tests/pp248Script.sml | 4 ++++ 7 files changed, 24 insertions(+), 1 deletion(-) create mode 100644 src/TeX/theory_tests/foo248Script.sml create mode 100644 src/TeX/theory_tests/gh248_expected create mode 100644 src/TeX/theory_tests/gh248_input create mode 100644 src/TeX/theory_tests/overrides248 create mode 100644 src/TeX/theory_tests/pp248Script.sml diff --git a/src/TeX/theory_tests/.gitignore b/src/TeX/theory_tests/.gitignore index b927c6d2a6..bc92d8c3c7 100644 --- a/src/TeX/theory_tests/.gitignore +++ b/src/TeX/theory_tests/.gitignore @@ -2,3 +2,4 @@ output tyabb_output utyabb_output gh242_output +gh248_output diff --git a/src/TeX/theory_tests/Holmakefile b/src/TeX/theory_tests/Holmakefile index 0dd1f124a3..4515ef364c 100644 --- a/src/TeX/theory_tests/Holmakefile +++ b/src/TeX/theory_tests/Holmakefile @@ -5,7 +5,7 @@ INCLUDES = $(CMPDIR) THYFILES = $(patsubst %Script.sml,%Theory.uo,$(wildcard *.sml)) TARGETS = $(patsubst %.sml,%.uo,$(THYFILES)) -all: check_output check_utyabb_output check_tyabb_output check_gh242 $(TARGETS) +all: check_output check_utyabb_output check_tyabb_output check_gh242 check_gh248 $(TARGETS) check_output: output expected-output $(CMPDIR)/cmp.exe output expected-output @@ -34,10 +34,17 @@ tymunge.exe: tyabbrevTheory.uo utymunge.exe: untyabbrevTheory.uo $(protect $(HOLDIR)/bin/mkmunge.exe) -o $@ untyabbrevTheory +munge248.exe: pp248Theory.uo + $(protect $(HOLDIR)/bin/mkmunge.exe) -o $@ pp248Theory + check_gh242: gh242_input gh242_expected munge.exe ./munge.exe < $< > gh242_output $(CMPDIR)/cmp.exe gh242_expected gh242_output +check_gh248: gh248_input gh248_expected munge248.exe + ./munge248.exe overrides248 < $< > gh248_output + $(CMPDIR)/cmp.exe gh248_expected gh248_output + .PHONY: all check_output check_utyabb_output check_tyabb_output check_gh242 EXTRA_CLEANS = munge.exe tymunge.exe utymunge.exe output utyabb_output tyabb_output gh242_output diff --git a/src/TeX/theory_tests/foo248Script.sml b/src/TeX/theory_tests/foo248Script.sml new file mode 100644 index 0000000000..391e61ca34 --- /dev/null +++ b/src/TeX/theory_tests/foo248Script.sml @@ -0,0 +1,5 @@ +open HolKernel boolLib bossLib Parse +val _ = new_theory"foo248" +val _ = Define`foo a b = a < b` +val _ = overload_on("<:",``λa b. foo b a``) +val _ = export_theory() diff --git a/src/TeX/theory_tests/gh248_expected b/src/TeX/theory_tests/gh248_expected new file mode 100644 index 0000000000..ca15cf1681 --- /dev/null +++ b/src/TeX/theory_tests/gh248_expected @@ -0,0 +1 @@ +\HOLinline{\HOLFreeVar{a} \ensuremath{\lessdot} \HOLFreeVar{b}} diff --git a/src/TeX/theory_tests/gh248_input b/src/TeX/theory_tests/gh248_input new file mode 100644 index 0000000000..3e6df55739 --- /dev/null +++ b/src/TeX/theory_tests/gh248_input @@ -0,0 +1 @@ +\HOLtm{foo b a} diff --git a/src/TeX/theory_tests/overrides248 b/src/TeX/theory_tests/overrides248 new file mode 100644 index 0000000000..f18205fcc9 --- /dev/null +++ b/src/TeX/theory_tests/overrides248 @@ -0,0 +1,4 @@ +\HOLTokenIn{}: 1 \ensuremath{\lessdot} +<: 1 \ensuremath{\lessdot} +∈: 1 \ensuremath{\lessdot} +\HOLSymConst{\HOLTokenIn{}:} 1 \ensuremath{lessdot} diff --git a/src/TeX/theory_tests/pp248Script.sml b/src/TeX/theory_tests/pp248Script.sml new file mode 100644 index 0000000000..d059e06bef --- /dev/null +++ b/src/TeX/theory_tests/pp248Script.sml @@ -0,0 +1,4 @@ +open HolKernel boolLib foo248Theory bagTheory +val _ = new_theory"pp248" +val _ = TeX_notation{hol="<:", TeX=("\\ensuremath{\\lessdot}",1)} +val _ = export_theory() From e39e234f86c37cc573869a38797e04cd43ed841e Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 31 Mar 2015 10:46:35 +1100 Subject: [PATCH 270/718] Fix test-case for issue #248 There wasn't a bug here, but create a test-case demonstrating how the new [tr''=n] option is supposed to work, and showing also that overriding the TeX token map for U+22F2 does allow for variations in its printing. --- src/TeX/theory_tests/Holmakefile | 2 +- src/TeX/theory_tests/bag248Script.sml | 17 +++++++++++++++++ src/TeX/theory_tests/gh248_expected | 3 ++- src/TeX/theory_tests/gh248_input | 1 + src/TeX/theory_tests/overrides248 | 4 ---- src/TeX/theory_tests/pp248Script.sml | 5 +++-- 6 files changed, 24 insertions(+), 8 deletions(-) create mode 100644 src/TeX/theory_tests/bag248Script.sml delete mode 100644 src/TeX/theory_tests/overrides248 diff --git a/src/TeX/theory_tests/Holmakefile b/src/TeX/theory_tests/Holmakefile index 4515ef364c..308c55ea55 100644 --- a/src/TeX/theory_tests/Holmakefile +++ b/src/TeX/theory_tests/Holmakefile @@ -42,7 +42,7 @@ check_gh242: gh242_input gh242_expected munge.exe $(CMPDIR)/cmp.exe gh242_expected gh242_output check_gh248: gh248_input gh248_expected munge248.exe - ./munge248.exe overrides248 < $< > gh248_output + ./munge248.exe < $< > gh248_output $(CMPDIR)/cmp.exe gh248_expected gh248_output .PHONY: all check_output check_utyabb_output check_tyabb_output check_gh242 diff --git a/src/TeX/theory_tests/bag248Script.sml b/src/TeX/theory_tests/bag248Script.sml new file mode 100644 index 0000000000..3b2972fd68 --- /dev/null +++ b/src/TeX/theory_tests/bag248Script.sml @@ -0,0 +1,17 @@ +open HolKernel Parse boolLib bossLib; + +val _ = new_theory "bag248"; + +val BAG_IN = new_definition ( + "BAG_IN", + ``BAG_IN (e:'a) b = 1 <= b e``); + +val _ = set_fixity "<:" (Infix(NONASSOC, 425)) +val _ = overload_on ("<:", ``BAG_IN``) +val _ = Unicode.unicode_version {tmnm = "<:", u = UTF8.chr 0x22F2} + (* U+22F2 looks like ⋲ in your current font; unfortunately this + symbol doesn't seem to correspond to anything in LaTeX... *) +val _ = TeX_notation {hol = "<:", TeX = ("\\HOLTokenIn{}:",2)} +val _ = TeX_notation {hol = UTF8.chr 0x22F2, TeX = ("\\HOLTokenIn{}:",2)} + +val _ = export_theory(); diff --git a/src/TeX/theory_tests/gh248_expected b/src/TeX/theory_tests/gh248_expected index ca15cf1681..d7478a6dcb 100644 --- a/src/TeX/theory_tests/gh248_expected +++ b/src/TeX/theory_tests/gh248_expected @@ -1 +1,2 @@ -\HOLinline{\HOLFreeVar{a} \ensuremath{\lessdot} \HOLFreeVar{b}} +\HOLinline{\HOLFreeVar{a} \HOLSymConst{\ensuremath{\le}} \HOLFreeVar{b}} +\HOLinline{\HOLFreeVar{a} \HOLSymConst{\ensuremath{\lessdot}} \HOLFreeVar{b}} diff --git a/src/TeX/theory_tests/gh248_input b/src/TeX/theory_tests/gh248_input index 3e6df55739..aa8f6af82c 100644 --- a/src/TeX/theory_tests/gh248_input +++ b/src/TeX/theory_tests/gh248_input @@ -1 +1,2 @@ +\HOLtm[tr'Unicode'=0]{foo b a} \HOLtm{foo b a} diff --git a/src/TeX/theory_tests/overrides248 b/src/TeX/theory_tests/overrides248 deleted file mode 100644 index f18205fcc9..0000000000 --- a/src/TeX/theory_tests/overrides248 +++ /dev/null @@ -1,4 +0,0 @@ -\HOLTokenIn{}: 1 \ensuremath{\lessdot} -<: 1 \ensuremath{\lessdot} -∈: 1 \ensuremath{\lessdot} -\HOLSymConst{\HOLTokenIn{}:} 1 \ensuremath{lessdot} diff --git a/src/TeX/theory_tests/pp248Script.sml b/src/TeX/theory_tests/pp248Script.sml index d059e06bef..d421047f7e 100644 --- a/src/TeX/theory_tests/pp248Script.sml +++ b/src/TeX/theory_tests/pp248Script.sml @@ -1,4 +1,5 @@ -open HolKernel boolLib foo248Theory bagTheory +open HolKernel boolLib foo248Theory bag248Theory val _ = new_theory"pp248" -val _ = TeX_notation{hol="<:", TeX=("\\ensuremath{\\lessdot}",1)} +val _ = TeX_notation{hol="<:", TeX=("\\ensuremath{\\le}",1)} +val _ = TeX_notation{hol="⋲", TeX=("\\ensuremath{\\lessdot}",1)} val _ = export_theory() From d4cc4184eb15af163b08a2d3f3c7d3c7d7bedfb0 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Tue, 31 Mar 2015 12:18:35 +1100 Subject: [PATCH 271/718] added cross-refs in help files --- help/Docfiles/Term.match_term.doc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/help/Docfiles/Term.match_term.doc b/help/Docfiles/Term.match_term.doc index 2957866bc9..63eb15896b 100644 --- a/help/Docfiles/Term.match_term.doc +++ b/help/Docfiles/Term.match_term.doc @@ -41,5 +41,5 @@ conclusion of a theorem to a term. For instantiating theorems {PART_MATCH} is usually easier to use. \SEEALSO -Type.match_type, Drule.INST_TY_TERM, Drule.PART_MATCH. +Term.match_terml, Type.match_type, Drule.INST_TY_TERM, Drule.PART_MATCH. \ENDDOC From 9bde291aaa6a3836dba3da846c99122f9fb5e8f9 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Tue, 31 Mar 2015 13:01:02 +1100 Subject: [PATCH 272/718] CHOOSE_TAC help page note about how to do it with multiple existentials (courtesy of Michael!) --- help/Docfiles/Tactic.CHOOSE_TAC.doc | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/help/Docfiles/Tactic.CHOOSE_TAC.doc b/help/Docfiles/Tactic.CHOOSE_TAC.doc index 7c1aba4671..570f0bf9b0 100644 --- a/help/Docfiles/Tactic.CHOOSE_TAC.doc +++ b/help/Docfiles/Tactic.CHOOSE_TAC.doc @@ -43,7 +43,10 @@ Then the goal can be solved by the application of: THEN MATCH_ACCEPT_TAC th2 } +\COMMENTS +To do similarly with several existentially quantified variables, use +{REPEAT_TCL CHOOSE_THEN ASSUME_TAC} in place of {CHOOSE_TAC} \SEEALSO -Thm_cont.CHOOSE_THEN, Tactic.X_CHOOSE_TAC. +Thm_cont.CHOOSE_THEN, Tactic.X_CHOOSE_TAC, Thm_cont.REPEAT_TCL. \ENDDOC From a4c672fc0b795555eaac9ed68de7fa2b8ac74d48 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Tue, 31 Mar 2015 13:39:17 +1100 Subject: [PATCH 273/718] added cross-refs in help files --- help/Docfiles/Tactical.FIRST_ASSUM.doc | 3 ++- help/Docfiles/Tactical.FIRST_X_ASSUM.doc | 4 +++- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/help/Docfiles/Tactical.FIRST_ASSUM.doc b/help/Docfiles/Tactical.FIRST_ASSUM.doc index 4b8b9b9909..9bfa6343a0 100644 --- a/help/Docfiles/Tactical.FIRST_ASSUM.doc +++ b/help/Docfiles/Tactical.FIRST_ASSUM.doc @@ -38,5 +38,6 @@ matches the goal, reducing the goal to the antecedent of the corresponding instance of this implication. \SEEALSO -Tactical.ASSUM_LIST, Tactical.EVERY, Tactical.EVERY_ASSUM, Tactical.FIRST, Tactical.MAP_EVERY, Tactical.MAP_FIRST. +Tactical.FIRST_X_ASSUM, Tactical.ASSUM_LIST, Tactical.EVERY, +Tactical.EVERY_ASSUM, Tactical.FIRST, Tactical.MAP_EVERY, Tactical.MAP_FIRST. \ENDDOC diff --git a/help/Docfiles/Tactical.FIRST_X_ASSUM.doc b/help/Docfiles/Tactical.FIRST_X_ASSUM.doc index 06ad0890a5..19a2225803 100644 --- a/help/Docfiles/Tactical.FIRST_X_ASSUM.doc +++ b/help/Docfiles/Tactical.FIRST_X_ASSUM.doc @@ -50,5 +50,7 @@ The ``X'' in the name of this tactic is a mnemonic for the ``crossing out'' or removal of the assumption found. \SEEALSO -Tactical.ASSUM_LIST, Tactical.EVERY, Tactical.PAT_ASSUM, Tactical.EVERY_ASSUM, Tactical.FIRST, Tactical.MAP_EVERY, Tactical.MAP_FIRST, Thm_cont.UNDISCH_THEN. +Tactical.FIRST_ASSUM, Tactical.ASSUM_LIST, Tactical.EVERY, +Tactical.PAT_ASSUM, Tactical.EVERY_ASSUM, Tactical.FIRST, +Tactical.MAP_EVERY, Tactical.MAP_FIRST, Thm_cont.UNDISCH_THEN. \ENDDOC From 53c3db6627eb62685119fe77c8bbd0d24b02a50d Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 31 Mar 2015 18:16:34 +1100 Subject: [PATCH 274/718] Delete doc for match_typel, which doesn't exist. Thanks to Jeremy Dawson for pointing this out. --- help/Docfiles/Type.match_typel.doc | 62 ------------------------------ 1 file changed, 62 deletions(-) delete mode 100644 help/Docfiles/Type.match_typel.doc diff --git a/help/Docfiles/Type.match_typel.doc b/help/Docfiles/Type.match_typel.doc deleted file mode 100644 index 2761b56742..0000000000 --- a/help/Docfiles/Type.match_typel.doc +++ /dev/null @@ -1,62 +0,0 @@ -\DOC match_typel - -\BLTYPE -match_typel : hol_type list -> hol_type -> hol_type - -> (hol_type, hol_type) subst -\ELTYPE - -\SYNOPSIS -Match types with restrictions. - -\KEYWORDS -type, matching. - -\DESCRIBE -An invocation {match_typel away pat ty} matches {pat} to {ty} in the -same way as {match_type}, but prohibits any of the type variables in {away} -from being instantiated. In effect, the elements of {away}, although -type variables, are treated as constants in {pat} during the matching -process. - -\FAILURE -An invocation of {match_typel away pat ty} will fail -if {match_type pat ty} would fail. It will also fail if {match_type pat ty} -would succeed giving a substitution -{[{redex_1,residue_1},...,{redex_n,residue_n}]} where one or more of the -{redex_i} are members of {away}. - -\EXAMPLE -In the first example, we perform a normal match operation -{ - - match_typel [] (alpha --> beta --> gamma) - (bool --> ind --> delta); - > val it = [{redex = `:'c`, residue = `:'d`}, - {redex = `:'b`, residue = `:ind`}, - {redex = `:'a`, residue = `:bool`}] : ... -} -Now we require that {gamma}, although a type variable in the -pattern, not be instantiable. In the first try, the match succeeds because -{'c} is mapped only to itself. In the second, it fails because an -association is made between {'c} and {'d}. -{ - - match_typel [gamma] (alpha --> beta --> gamma) - (bool --> ind --> gamma); - > val it = [{redex = `:'b`, residue = `:ind`}, - {redex = `:'a`, residue = `:bool`}] : ... - - - match_typel [gamma] (alpha --> beta --> gamma) - (bool --> ind --> delta); - ! Uncaught exception: - ! HOL_ERR -} - - -\COMMENTS -The use of {away} allows matching to take account of type variables that -are 'frozen' (by occurring in the hypotheses of a theorem, for example). -This allows certain fruitless proof attempts to be avoided at the matching -stage. - -\SEEALSO -Type.match_type, Term.match_term., HolKernel.ho_match_term, Type.type_subst. -\ENDDOC From f46c9c0202a77d251d2accaeae0fc2d3593d0536 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 2 Apr 2015 13:55:28 +1100 Subject: [PATCH 275/718] Fix bug in Moscow ML version of LaTeX munger Issue was that Moscow ML mungers start by executing the SML code in the various theories that are built into them. This can cause warning messages, and these warnings were written to standard out. This then causes the output to be other than desired. (Standard out should only contain the munged LaTeX source.) There's code that runs before the lexing loop starts to switch HOL warnings to standard error, but this is executed after the theories load. So, yes, it would be nice if theory structures were side-effect free, but we actually want theories to induce all sorts of side effects as they load, and thus code needs to execute, and that code might cause messages to go to standard out. By contrast, in Poly/ML things are staged: the theories are loaded once and put into the heap that is then executed to implement the munger's lexing. This makes things more efficient of course, and also means that warnings on theory loads are emitted when the munger is built, not when it is run. The fix in the Moscow ML world is to make the final munger executable include an object file (warning_stream.uo) that sets the warning stream appropriately. Because Moscow ML loads things in the order they appear on the compilation command-line (to the extent that this is possible), this is executed before the theories are executed, and all is well. --- src/TeX/Holmakefile | 2 +- src/TeX/mkmkmunge.sml | 1 + src/TeX/warning_stream.sml | 1 + 3 files changed, 3 insertions(+), 1 deletion(-) create mode 100644 src/TeX/warning_stream.sml diff --git a/src/TeX/Holmakefile b/src/TeX/Holmakefile index ce1e0a4b95..3690974459 100644 --- a/src/TeX/Holmakefile +++ b/src/TeX/Holmakefile @@ -8,7 +8,7 @@ EXTRA_CLEANS = munger.lex.sml $(EXE) mkmunge.o munger.o $(TARGET) \ holindex.grm-sig.sml holindex.grm.sml holindex.lex.sig \ holindex.lex.sml holindex.grm.sig -mosml_MKMUNGE_DEP = mkmkmunge.uo mungeTools.uo +mosml_MKMUNGE_DEP = mkmkmunge.uo mungeTools.uo warning_stream.uo poly_MKMUNGE_DEP = mkmunge.o mungeTools.uo mosml_MKMUNGE_COMM = $(HOLMOSMLC) -o $@ $< diff --git a/src/TeX/mkmkmunge.sml b/src/TeX/mkmkmunge.sml index 94118dbbb3..cdbfe9a75b 100644 --- a/src/TeX/mkmkmunge.sml +++ b/src/TeX/mkmkmunge.sml @@ -17,5 +17,6 @@ val _ = systeml (if Systeml.isUnix andalso staticp then ["-standalone"] else []) @ ["-o", exe, "-I", HOLDIR ++ "sigobj", "-I", HOLDIR ++ "src" ++ "TeX"] @ + ["warning_stream.uo"] @ toload @ [HOLDIR ++ "src" ++ "TeX" ++ "mosmlmunge.uo"]) diff --git a/src/TeX/warning_stream.sml b/src/TeX/warning_stream.sml new file mode 100644 index 0000000000..95d8f82ddb --- /dev/null +++ b/src/TeX/warning_stream.sml @@ -0,0 +1 @@ +val () = Feedback.WARNING_outstream := TextIO.stdErr From d38bfe3c2deaabadf3d5f37b47acaceaf219636a Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Tue, 31 Mar 2015 17:35:59 +1100 Subject: [PATCH 276/718] new tactic RULE_L_ASSUM_TAC like RULE_ASSUM_TAC but f produces list of theorems --- help/Docfiles/Tactic.RULE_ASSUM_TAC.doc | 3 +- help/Docfiles/Tactic.RULE_L_ASSUM_TAC.doc | 61 +++++++++++++++++++++++ src/1/Tactic.sig | 1 + src/1/Tactic.sml | 4 ++ 4 files changed, 68 insertions(+), 1 deletion(-) create mode 100644 help/Docfiles/Tactic.RULE_L_ASSUM_TAC.doc diff --git a/help/Docfiles/Tactic.RULE_ASSUM_TAC.doc b/help/Docfiles/Tactic.RULE_ASSUM_TAC.doc index 061b7a1c19..6e975cc1fb 100644 --- a/help/Docfiles/Tactic.RULE_ASSUM_TAC.doc +++ b/help/Docfiles/Tactic.RULE_ASSUM_TAC.doc @@ -28,5 +28,6 @@ It does not matter if the goal has no assumptions, but in this case {RULE_ASSUM_TAC} has no effect. \SEEALSO -Tactical.ASSUM_LIST, Tactical.MAP_EVERY, Tactical.MAP_FIRST, Tactical.POP_ASSUM_LIST. +Tactic.RULE_L_ASSUM_TAC, Tactical.ASSUM_LIST, Tactical.MAP_EVERY, +Tactical.MAP_FIRST, Tactical.POP_ASSUM_LIST. \ENDDOC diff --git a/help/Docfiles/Tactic.RULE_L_ASSUM_TAC.doc b/help/Docfiles/Tactic.RULE_L_ASSUM_TAC.doc new file mode 100644 index 0000000000..6258c2257d --- /dev/null +++ b/help/Docfiles/Tactic.RULE_L_ASSUM_TAC.doc @@ -0,0 +1,61 @@ +\DOC RULE_L_ASSUM_TAC + +\TYPE {RULE_L_ASSUM_TAC : ((thm -> thm list) -> tactic)} + +\SYNOPSIS +Maps an inference rule, which produces a list of result theorems, +over the assumptions of a goal. + +\KEYWORDS +tactic, assumption, rule. + +\DESCRIBE +When applied to an inference rule {f} and a goal {({A1,...,An} ?- t)}, +the {RULE_L_ASSUM_TAC} tactical applies the inference rule to each of the +{ASSUME}d assumptions to give a new goal. +{ + {A1,...,An} ?- t + ==================================== RULE_L_ASSUM_TAC f + {f(A1 |- A1),...,f(An |- An)} ?- t +} +Here each {f(Ai |- Ai)} is a list of assumptions. + +\FAILURE +The application of {RULE_L_ASSUM_TAC f} to a goal fails iff {f} fails when +applied to any of the assumptions of the goal. + +\COMMENTS +It does not matter if the goal has no assumptions, but in this case +{RULE_L_ASSUM_TAC} has no effect. + +\EXAMPLE +With a goal +{ +g +------------------------------------ + 0. a /\ b + 1. c + 2. d /\ e /\ f +} + +the tactic {RULE_L_ASSUM_TAC CONJUNCTS} gives the new goal +{ +g +------------------------------------ + 0. a + 1. b + 2. c + 3. d + 4. e + 5. f +} + +{RULE_L_ASSUM_TAC} can also be used to delete unwanted assumptions: +let {f ass = [ass]} for an assumption which is to be kept, +and {f ass = []} for an assumption which is to be deleted. + +\SEEALSO +Tactic.RULE_ASSUM_TAC, Tactical.ASSUM_LIST, Tactical.MAP_EVERY, +Tactical.MAP_FIRST, Tactical.POP_ASSUM_LIST. +\ENDDOC + diff --git a/src/1/Tactic.sig b/src/1/Tactic.sig index d498ae7e1f..fcd21a2fa0 100644 --- a/src/1/Tactic.sig +++ b/src/1/Tactic.sig @@ -26,6 +26,7 @@ sig val SUBST_OCCS_TAC : (int list * thm) list -> tactic val SUBST1_TAC : thm -> tactic val RULE_ASSUM_TAC : (thm -> thm) -> tactic + val RULE_L_ASSUM_TAC : (thm -> thm list) -> tactic val SUBST_ALL_TAC : thm -> tactic val CHECK_ASSUME_TAC : thm_tactic val STRIP_ASSUME_TAC : thm_tactic diff --git a/src/1/Tactic.sml b/src/1/Tactic.sml index f28abeaf8a..fa6b3a31fb 100644 --- a/src/1/Tactic.sml +++ b/src/1/Tactic.sml @@ -374,6 +374,10 @@ fun RULE_ASSUM_TAC rule : tactic = POP_ASSUM_LIST (fn asl => MAP_EVERY ASSUME_TAC (rev_itlist (cons o rule) asl [])) +fun RULE_L_ASSUM_TAC rule : tactic = + POP_ASSUM_LIST + (fn asl => MAP_EVERY ASSUME_TAC (rev_itlist (append o rule) asl [])) + (*---------------------------------------------------------------------------* * Substitute throughout the goal and its assumptions. * *---------------------------------------------------------------------------*) From bc9e117764b5f1c5009a75626ad29917e837ae66 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Sun, 5 Apr 2015 21:54:41 +1000 Subject: [PATCH 277/718] trivial simplification - uses match_term, not match_terml --- src/1/Tactic.sml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/1/Tactic.sml b/src/1/Tactic.sml index fa6b3a31fb..89c8c49fbd 100644 --- a/src/1/Tactic.sml +++ b/src/1/Tactic.sml @@ -719,7 +719,7 @@ fun MATCH_ACCEPT_TAC thm : tactic = * ---------------------------------------------------------------------*) fun prim_irule thm (asl, w) = - let val matchsub = match_terml [] empty_tmset (concl thm) w ; + let val matchsub = match_term (concl thm) w ; val subthm = INST_TY_TERM matchsub thm ; in GEN_VALIDATE false (ACCEPT_TAC subthm) (asl, w) end ; From 0c99419fe2a6fae97017e6bed77e9277faf67a2a Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Wed, 22 Apr 2015 16:15:28 +0100 Subject: [PATCH 278/718] Correct Lib to lib. --- examples/l3-machine-code/arm8/step/Holmakefile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/l3-machine-code/arm8/step/Holmakefile b/examples/l3-machine-code/arm8/step/Holmakefile index a384c00b38..22195c666b 100644 --- a/examples/l3-machine-code/arm8/step/Holmakefile +++ b/examples/l3-machine-code/arm8/step/Holmakefile @@ -5,7 +5,7 @@ ifdef POLY HOLHEAP = arm8-heap EXTRA_CLEANS = $(HOLHEAP) $(HOLHEAP).o -BARE_THYS = ../model/arm8Lib ../../Lib/MutableMap ../model/arm8 ../model/arm8AssemblerLib +BARE_THYS = ../model/arm8Lib ../../lib/MutableMap ../model/arm8 ../model/arm8AssemblerLib DEPS = $(patsubst %,%.uo,$(BARE_THYS)) THYFILES = $(patsubst %Script.sml,%Theory.uo,$(wildcard *.sml)) From 103c7011a406251be102590c96c178f433e2a4f2 Mon Sep 17 00:00:00 2001 From: Hannes Mehnert Date: Thu, 23 Apr 2015 16:50:54 +0100 Subject: [PATCH 279/718] use /bin/sh instead of /bin/bash (which is not available on all UNIX systems) also, use cc instead of gcc (no need to compile HOL4 with gcc) --- src/integer/testing/number.sh | 2 +- src/opentheory/logging/term2thm.cgi | 2 +- tools-poly/configure.sml | 2 +- tools/Holmake/Holmake_tools.sml | 2 +- tools/configure.sml | 2 +- tools/mllex/Holmakefile | 2 +- tools/quote-filter/Holmakefile | 2 +- 7 files changed, 7 insertions(+), 7 deletions(-) diff --git a/src/integer/testing/number.sh b/src/integer/testing/number.sh index 3f7caa0927..a0ea6ae52f 100755 --- a/src/integer/testing/number.sh +++ b/src/integer/testing/number.sh @@ -1,3 +1,3 @@ -#! /bin/bash +#!/bin/sh perl -e '$/ = "\n\n"; while (<>) { print $i++, " ", $_; }' diff --git a/src/opentheory/logging/term2thm.cgi b/src/opentheory/logging/term2thm.cgi index a95c460d68..bf9427dbd7 100755 --- a/src/opentheory/logging/term2thm.cgi +++ b/src/opentheory/logging/term2thm.cgi @@ -1,4 +1,4 @@ -#!/bin/bash +#!/bin/sh case $REQUEST_METHOD in 'POST') export PATH="$HOME/bin:$PATH" diff --git a/tools-poly/configure.sml b/tools-poly/configure.sml index 41ef707a6f..cf3c6fe455 100644 --- a/tools-poly/configure.sml +++ b/tools-poly/configure.sml @@ -41,7 +41,7 @@ val OS :string = val _ = PolyML.print_depth 0; -val CC:string = "gcc"; (* C compiler *) +val CC:string = "cc"; (* C compiler *) val GNUMAKE:string = "make"; (* for bdd library and SMV *) val DEPDIR:string = ".HOLMK"; (* where Holmake dependencies kept *) diff --git a/tools/Holmake/Holmake_tools.sml b/tools/Holmake/Holmake_tools.sml index 67bf71037a..b88dac758d 100644 --- a/tools/Holmake/Holmake_tools.sml +++ b/tools/Holmake/Holmake_tools.sml @@ -282,7 +282,7 @@ val nice_dir = | NONE => (fn s => s) fun xterm_log s = - ignore (OS.Process.system ("/bin/bash -c 'echo -ne \"\\033]0;" ^ s ^ "\\007\"'")) + ignore (OS.Process.system ("/bin/sh -c 'echo -ne \"\\033]0;" ^ s ^ "\\007\"'")) val terminal_log = if Systeml.isUnix then xterm_log diff --git a/tools/configure.sml b/tools/configure.sml index f62876a22d..18752f4b77 100644 --- a/tools/configure.sml +++ b/tools/configure.sml @@ -41,7 +41,7 @@ val OS :string = *) -val CC:string = "gcc"; (* C compiler *) +val CC:string = "cc"; (* C compiler *) val GNUMAKE:string = "make"; (* for bdd library and SMV *) val DEPDIR:string = ".HOLMK"; (* where Holmake dependencies kept *) diff --git a/tools/mllex/Holmakefile b/tools/mllex/Holmakefile index 314528d19e..86e09622a5 100644 --- a/tools/mllex/Holmakefile +++ b/tools/mllex/Holmakefile @@ -10,7 +10,7 @@ OBJ_DEPS = $(if $(MOSMLC),mllex.uo mosmlmain.uo,mllex.sml poly-mllex.ML) $(OBJ): $(OBJ_DEPS) $(if $(MOSMLC),$(MOSMLC) -o $@ $(OBJ_DEPS),\ poly < poly-mllex.ML && \ - gcc -o $@ mllex.o $(POLYLIBS) -lpolymain -lpolyml) + cc -o $@ mllex.o $(POLYLIBS) -lpolymain -lpolyml) mosmlmain.uo mosmlmain.ui: mosmlmain.sml mllex.ui $(MOSMLC) -c mllex.ui $< diff --git a/tools/quote-filter/Holmakefile b/tools/quote-filter/Holmakefile index 8723ee398a..f6c3f2a6f5 100644 --- a/tools/quote-filter/Holmakefile +++ b/tools/quote-filter/Holmakefile @@ -7,7 +7,7 @@ all: quote-filter selftest quote-filter: $(DEPS) $(if $(MOSMLC), $(HOLMOSMLC) -o quote-filter quote-filter.uo,\ poly < poly-unquote.ML && \ - gcc -o quote-filter unquote.o $(POLYLIBS) -lpolymain -lpolyml) + cc -o quote-filter unquote.o $(POLYLIBS) -lpolymain -lpolyml) filter.sml : filter $(if $(MOSMLC),$(protect $(HOLDIR)/tools/mllex/mllex.exe),../mllex/mllex.exe) filter From 8943432822b38608f514a814b914d7b35dc511d7 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Sun, 26 Apr 2015 16:51:57 +1000 Subject: [PATCH 280/718] added and amended doc pages re REV_FULL_SIMP_TAC and VAR_EQ_TAC --- help/Docfiles/BasicProvers.VAR_EQ_TAC.doc | 27 +++++++++++++++++++++ help/Docfiles/Rewrite.ASM_REWRITE_TAC.doc | 2 +- help/Docfiles/bossLib.ASM_SIMP_TAC.doc | 3 ++- help/Docfiles/bossLib.FULL_SIMP_TAC.doc | 9 ++++++- help/Docfiles/bossLib.REV_FULL_SIMP_TAC.doc | 27 +++++++++++++++++++++ 5 files changed, 65 insertions(+), 3 deletions(-) create mode 100644 help/Docfiles/BasicProvers.VAR_EQ_TAC.doc create mode 100644 help/Docfiles/bossLib.REV_FULL_SIMP_TAC.doc diff --git a/help/Docfiles/BasicProvers.VAR_EQ_TAC.doc b/help/Docfiles/BasicProvers.VAR_EQ_TAC.doc new file mode 100644 index 0000000000..e344824523 --- /dev/null +++ b/help/Docfiles/BasicProvers.VAR_EQ_TAC.doc @@ -0,0 +1,27 @@ +\DOC VAR_EQ_TAC + +\TYPE {VAR_EQ_TAC : tactic} + +\SYNOPSIS +Simplifies a goal using any assumption of +the form {v = t} or {t = v}, where {v} is a variable + +\KEYWORDS +simplification, rewriting, tactic. + +\DESCRIBE +{VAR_EQ_TAC} simplifies the goal, including its assumptions, +using one assumption of +the form {v = t} or {t = v}, where {v} is a variable. + +In both cases, {v} is replaced throughout by {t}, +and the relevant assumption is deleted. + +\FAILURE +{VAR_EQ_TAC} fails if there are no such assumptions + +\SEEALSO +bossLib.FULL_SIMP_TAC, bossLib.ASM_SIMP_TAC, Rewrite.ASM_REWRITE_TAC + +\ENDDOC + diff --git a/help/Docfiles/Rewrite.ASM_REWRITE_TAC.doc b/help/Docfiles/Rewrite.ASM_REWRITE_TAC.doc index c7e2baffda..563d91799f 100644 --- a/help/Docfiles/Rewrite.ASM_REWRITE_TAC.doc +++ b/help/Docfiles/Rewrite.ASM_REWRITE_TAC.doc @@ -55,6 +55,6 @@ Rewrite.FILTER_ASM_REWRITE_TAC, Rewrite.FILTER_ONCE_ASM_REWRITE_TAC, Rewrite.GEN_REWRITE_TAC, Rewrite.ONCE_ASM_REWRITE_TAC, Rewrite.ONCE_REWRITE_TAC, Rewrite.PURE_ASM_REWRITE_TAC, Rewrite.PURE_ONCE_ASM_REWRITE_TAC, Rewrite.PURE_REWRITE_TAC, -Rewrite.REWRITE_TAC, Tactic.SUBST_TAC. +Rewrite.REWRITE_TAC, Tactic.SUBST_TAC, BasicProvers.VAR_EQ_TAC \ENDDOC diff --git a/help/Docfiles/bossLib.ASM_SIMP_TAC.doc b/help/Docfiles/bossLib.ASM_SIMP_TAC.doc index 7aaf3ca3ae..379edd7e65 100644 --- a/help/Docfiles/bossLib.ASM_SIMP_TAC.doc +++ b/help/Docfiles/bossLib.ASM_SIMP_TAC.doc @@ -33,6 +33,7 @@ The simple goal {x < y ?- x + y < y + y} can be proved by using \SEEALSO bossLib.++, bossLib.bool_ss, bossLib.FULL_SIMP_TAC, -simpLib.mk_simpset, bossLib.SIMP_CONV, bossLib.SIMP_TAC. +simpLib.mk_simpset, bossLib.SIMP_CONV, bossLib.SIMP_TAC, +Rewrite.ASM_REWRITE_TAC, BasicProvers.VAR_EQ_TAC \ENDDOC diff --git a/help/Docfiles/bossLib.FULL_SIMP_TAC.doc b/help/Docfiles/bossLib.FULL_SIMP_TAC.doc index 2741dbaca1..5af5de4130 100644 --- a/help/Docfiles/bossLib.FULL_SIMP_TAC.doc +++ b/help/Docfiles/bossLib.FULL_SIMP_TAC.doc @@ -60,7 +60,14 @@ list. If one wants to apply the simplifier to assumptions without this occurring, the best approach seems to be the use of {RULE_ASSUM_TAC} and {SIMP_RULE}. +Each assumption is used to rewrite lower-numbered assumptions. +To get the opposite effect, where +each assumption is used to rewrite higher-numbered assumptions, +use {REV_FULL_SIMP_TAC}. + \SEEALSO -bossLib.ASM_SIMP_TAC, bossLib.SIMP_CONV, bossLib.SIMP_RULE, bossLib.SIMP_TAC. +bossLib.REV_FULL_SIMP_TAC, bossLib.ASM_SIMP_TAC, +bossLib.SIMP_CONV, bossLib.SIMP_RULE, bossLib.SIMP_TAC, +BasicProvers.VAR_EQ_TAC. \ENDDOC diff --git a/help/Docfiles/bossLib.REV_FULL_SIMP_TAC.doc b/help/Docfiles/bossLib.REV_FULL_SIMP_TAC.doc new file mode 100644 index 0000000000..769d2d092d --- /dev/null +++ b/help/Docfiles/bossLib.REV_FULL_SIMP_TAC.doc @@ -0,0 +1,27 @@ +\DOC REV_FULL_SIMP_TAC + +\TYPE {REV_FULL_SIMP_TAC : simpset -> thm list -> tactic} + +\SYNOPSIS +Simplifies the goal (assumptions as well as conclusion) with the given +simpset. + +\KEYWORDS +simplification, tactic. + +\LIBRARY +simpLib + +\DESCRIBE +{REV_FULL_SIMP_TAC} is the same as {FULL_SIMP_TAC} +except that it simplifies the assumptions in the opposite order. + +That is, in {REV_FULL_SIMP_TAC}, +each assumption is used to rewrite higher-numbered assumptions, +whereas in {FULL_SIMP_TAC}, +each assumption is used to rewrite lower-numbered assumptions. + +\SEEALSO +bossLib.FULL_SIMP_TAC, bossLib.ASM_SIMP_TAC, bossLib.SIMP_TAC + +\ENDDOC From 350b6eee8cb668a20dd4e6b8892927574aa94628 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Sun, 26 Apr 2015 19:48:15 +1000 Subject: [PATCH 281/718] doc page for PRED_ASSUM, correction to UNDISCH_THEN a lot of cut-and-paste here, it seems UNDISCH_THEN = PRED_ASSUM o aconv --- help/Docfiles/Tactical.PRED_ASSUM.doc | 41 +++++++++++++++++++++++++ help/Docfiles/Thm_cont.UNDISCH_THEN.doc | 8 ++--- 2 files changed, 45 insertions(+), 4 deletions(-) create mode 100644 help/Docfiles/Tactical.PRED_ASSUM.doc diff --git a/help/Docfiles/Tactical.PRED_ASSUM.doc b/help/Docfiles/Tactical.PRED_ASSUM.doc new file mode 100644 index 0000000000..7836d4ab5d --- /dev/null +++ b/help/Docfiles/Tactical.PRED_ASSUM.doc @@ -0,0 +1,41 @@ +\DOC PRED_ASSUM + +\TYPE {PRED_ASSUM : (term -> bool) -> thm_tactic -> tactic} + +\SYNOPSIS +Discharges a selected assumption and passes it to a theorem-tactic. + +\KEYWORDS +theorem-tactic, discharge. + +\DESCRIBE +{PRED_ASSUM} finds the first assumption satisfying the prediate given, +removes it from the assumption list, {ASSUME}s it, passes it to +the theorem-tactic and then applies the consequent tactic. Thus, +where {t} is the first assumption satisfying {p}, +{ + PRED_ASSUM p f ([a1,... ai, t, aj, ... an], goal) = + f (ASSUME t) ([a1,... ai, aj,... an], goal) +} +For example (again, where {t} is the first assumption in {A u {t}} +satisfying {p}), if +{ + A ?- c + ======== f (ASSUME t) + B ?- v +} +then +{ + A u {t} ?- c + =============== PRED_ASSUM p f + B ?- v +} + +\FAILURE +{PRED_ASSUM p} will fail on goals where no +assumption safisfies {p}. + +\SEEALSO +Thm_cont.UNDISCH_THEN, Tactical.PAT_ASSUM, Tactical.POP_ASSUM, +Tactic.UNDISCH_TAC. +\ENDDOC diff --git a/help/Docfiles/Thm_cont.UNDISCH_THEN.doc b/help/Docfiles/Thm_cont.UNDISCH_THEN.doc index 08b2efb5dc..cfb8720bc0 100644 --- a/help/Docfiles/Thm_cont.UNDISCH_THEN.doc +++ b/help/Docfiles/Thm_cont.UNDISCH_THEN.doc @@ -18,9 +18,9 @@ the theorem-tactic and then applies the consequent tactic. Thus: } For example, if { - A u {t1} ?- t - =============== f (ASSUME t1) - B u {t1} ?- v + A ?- t + ======== f (ASSUME t1) + B ?- v } then { @@ -35,5 +35,5 @@ then assumption list. \SEEALSO -Tactical.PAT_ASSUM, Thm.DISCH, Drule.DISCH_ALL, Tactic.DISCH_TAC, Thm_cont.DISCH_THEN, Drule.NEG_DISCH, Tactic.FILTER_DISCH_TAC, Thm_cont.FILTER_DISCH_THEN, Tactic.STRIP_TAC, Drule.UNDISCH, Drule.UNDISCH_ALL, Tactic.UNDISCH_TAC. +Tactical.PRED_ASSUM, Tactical.PAT_ASSUM, Thm.DISCH, Drule.DISCH_ALL, Tactic.DISCH_TAC, Thm_cont.DISCH_THEN, Drule.NEG_DISCH, Tactic.FILTER_DISCH_TAC, Thm_cont.FILTER_DISCH_THEN, Tactic.STRIP_TAC, Drule.UNDISCH, Drule.UNDISCH_ALL, Tactic.UNDISCH_TAC. \ENDDOC From 7e6d619b2be3895fc3e1da6f4daeead673c0f351 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Sun, 26 Apr 2015 23:04:44 +1000 Subject: [PATCH 282/718] alternative definition of PERM --- src/sort/sortingScript.sml | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) diff --git a/src/sort/sortingScript.sml b/src/sort/sortingScript.sml index 3d5fd4a31a..8cf66fff52 100644 --- a/src/sort/sortingScript.sml +++ b/src/sort/sortingScript.sml @@ -165,6 +165,31 @@ RW_TAC bool_ss [o_DEF] THEN RW_TAC list_ss [FILTER,PERM_REFL] THEN PROVE_TAC [APPEND,PERM_MONO,CONS_PERM]); +(* ---------------------------------------------------------------------- + Alternative definition of PERM + ---------------------------------------------------------------------- *) + +val FILTER_EQ_REP = + prove (``FILTER ($= x) l = REPLICATE (LENGTH (FILTER ($= x) l)) x``, + EVERY [(Induct_on `l`), + (SIMP_TAC list_ss [rich_listTheory.REPLICATE]), GEN_TAC, + COND_CASES_TAC THENL [ BasicProvers.VAR_EQ_TAC, ALL_TAC], + (ASM_SIMP_TAC list_ss [rich_listTheory.REPLICATE]) ]) ; + +val FILTER_EQ_LENGTHS_EQ = store_thm ("FILTER_EQ_LENGTHS_EQ", + ``(LENGTH (FILTER ($= x) l1) = LENGTH (FILTER ($= x) l2)) ==> + (FILTER ($= x) l1 = FILTER ($= x) l2)``, + EVERY [ DISCH_TAC, ONCE_REWRITE_TAC [FILTER_EQ_REP], + (ASM_SIMP_TAC bool_ss []) ]) ; + +val PERM_alt = store_thm ("PERM_alt", + ``!L1 L2. PERM L1 L2 = + !x. LENGTH (FILTER ($= x) L1) = LENGTH (FILTER ($= x) L2)``, + EVERY [(REWRITE_TAC [PERM_DEF]), (REPEAT GEN_TAC), + (irule IMP_ANTISYM_AX), (REPEAT STRIP_TAC) ] THENL [ + (ASM_SIMP_TAC bool_ss []), + (irule FILTER_EQ_LENGTHS_EQ) THEN (ASM_REWRITE_TAC []) ]) ; + (* ---------------------------------------------------------------------- Inductive characterisation of PERM ---------------------------------------------------------------------- *) From 69c69a28e306ea7bc3a8dcb048406ece180159ea Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Sun, 26 Apr 2015 23:55:01 +1000 Subject: [PATCH 283/718] PERM_alt permits some simpler proofs --- src/sort/sortingScript.sml | 70 +++++++++++++++----------------------- 1 file changed, 28 insertions(+), 42 deletions(-) diff --git a/src/sort/sortingScript.sml b/src/sort/sortingScript.sml index 8cf66fff52..a3b93000f6 100644 --- a/src/sort/sortingScript.sml +++ b/src/sort/sortingScript.sml @@ -326,6 +326,19 @@ val PERM_SWAP_AT_FRONT = store_thm( METIS_TAC [remove_eq_asm (List.nth(CONJUNCTS perm_rules, 2)), PERM_REFL, PERM_TRANS, PERM_CONS_IFF]); +val PERM_SWAP_L_AT_FRONT = store_thm( + "PERM_SWAP_L_AT_FRONT", + ``!x y. PERM (x++y++l1) (y++x++l2) = PERM l1 l2``, + SIMP_TAC list_ss + [PERM_alt, FILTER_APPEND_DISTRIB]) ; + +(* alternative proof of PERM_SWAP_AT_FRONT +val PERM_SWAP_AT_FRONT' = SPECL [``[x]``, ``[y]``] PERM_SWAP_L_AT_FRONT ; + +val PERM_SWAP_AT_FRONT = save_thm( "PERM_SWAP_AT_FRONT", + SIMP_RULE list_ss [] PERM_SWAP_AT_FRONT') ; +*) + val PERM_SWAP = PERM_SWAP_AT_FRONT |> EQ_IMP_RULE |> #2 |> Q.GENL [`l2`, `l1`, `y`, `x`] @@ -601,11 +614,7 @@ val _ = val PERM_APPEND_IFF = store_thm ("PERM_APPEND_IFF", ``(!l:'a list l1 l2. PERM (l++l1) (l++l2) = PERM l1 l2) /\ (!l:'a list l1 l2. PERM (l1++l) (l2++l) = PERM l1 l2)``, - - MATCH_MP_TAC (prove (``(a /\ (a ==> b)) ==> (a /\ b)``, PROVE_TAC[])) THEN - Tactical.REVERSE CONJ_TAC THEN1 PROVE_TAC [PERM_APPEND, PERM_TRANS] THEN - Induct_on `l` THEN ASM_SIMP_TAC list_ss [PERM_CONS_IFF] -); + SIMP_TAC list_ss [PERM_alt, FILTER_APPEND_DISTRIB]) ; val PERM_SINGLE_SWAP_DEF = Define `PERM_SINGLE_SWAP l1 l2 = ?x1 x2 x3. (l1 = x1 ++ x2 ++ x3) /\ (l2 = x1 ++ x3 ++ x2)`; @@ -796,11 +805,7 @@ val PERM_FILTER = store_thm ("PERM_FILTER", val PERM_REVERSE = Q.store_thm( "PERM_REVERSE", `PERM ls (REVERSE ls)`, -Induct_on `ls` THEN SRW_TAC [][] THEN -`PERM ([h] ++ REVERSE ls) (REVERSE ls ++ [h])` -by SRW_TAC [][PERM_APPEND] THEN -FULL_SIMP_TAC (srw_ss()) [] THEN -METIS_TAC [PERM_CONS_IFF,PERM_TRANS]); + SIMP_TAC list_ss [PERM_alt, FILTER_REVERSE]) ; val PERM_REVERSE_EQ = store_thm( "PERM_REVERSE_EQ", @@ -1038,7 +1043,6 @@ val PERM_FUN_CONS_11_SWAP_AT_FRONT = store_thm ( ``!y l1 x l2. (PERM l1 = PERM (x::l2)) ==> (PERM (y::l1) = PERM (x::y::l2))``, - REPEAT STRIP_TAC THEN ASSUME_TAC (Q.SPECL [`x`, `y`,`l2`] PERM_FUN_SWAP_AT_FRONT) THEN ASM_REWRITE_TAC[] THEN @@ -1050,61 +1054,43 @@ val PERM_FUN_CONS_11_APPEND = store_thm ( ``!y l1 l2 l3. (PERM l1 = PERM (l2++l3)) ==> (PERM (y::l1) = PERM (l2++(y::l3)))``, - -REPEAT STRIP_TAC THEN -REWRITE_TAC[PERM_FUN_APPEND_CONS] THEN -FULL_SIMP_TAC std_ss [GSYM PERM_EQUIVALENCE_ALT_DEF, - PERM_CONS_IFF, APPEND]); - - - +EVERY [SIMP_TAC list_ss + [GSYM PERM_EQUIVALENCE_ALT_DEF, PERM_alt, FILTER_APPEND_DISTRIB], + REPEAT STRIP_TAC, COND_CASES_TAC, (ASM_SIMP_TAC list_ss []) ]) ; val PERM_FUN_CONS_APPEND_1 = store_thm ( "PERM_FUN_CONS_APPEND_1", ``!l l1 x l2. (PERM l1 = PERM (x::l2)) ==> (PERM (l1 ++ l) = PERM (x::(l2++l)))``, - -REPEAT STRIP_TAC THEN -MP_TAC (Q.SPECL [`l1`, `l`, `x::l2`,`l`] PERM_CONG) THEN -ASM_REWRITE_TAC[PERM_EQUIVALENCE_ALT_DEF, APPEND]); - +EVERY [SIMP_TAC list_ss + [GSYM PERM_EQUIVALENCE_ALT_DEF, PERM_alt, FILTER_APPEND_DISTRIB], + REPEAT STRIP_TAC, COND_CASES_TAC, (ASM_SIMP_TAC list_ss []) ]) ; val PERM_FUN_CONS_APPEND_2 = store_thm ( "PERM_FUN_CONS_APPEND_2", ``!l l1 x l2. (PERM l1 = PERM (x::l2)) ==> (PERM (l ++ l1) = PERM (x::(l ++ l2)))``, - -REPEAT STRIP_TAC THEN -MP_TAC (Q.SPECL [`l`,`l1`,`l`, `x::l2`] PERM_CONG) THEN -ASM_REWRITE_TAC[PERM_EQUIVALENCE_ALT_DEF,APPEND, - PERM_FUN_APPEND_CONS]); - +EVERY [SIMP_TAC list_ss + [GSYM PERM_EQUIVALENCE_ALT_DEF, PERM_alt, FILTER_APPEND_DISTRIB], + REPEAT STRIP_TAC, COND_CASES_TAC, (ASM_SIMP_TAC list_ss []) ]) ; val PERM_FUN_APPEND_APPEND_1 = store_thm ( "PERM_FUN_APPEND_APPEND_1", ``!l1 l2 l3 l4. (PERM l1 = PERM (l2++l3)) ==> (PERM (l1 ++ l4) = PERM (l2++(l3++l4)))``, - -REPEAT STRIP_TAC THEN -MP_TAC (Q.SPECL [`l1`, `l4`, `l2++l3`, `l4`] PERM_CONG) THEN -ASM_REWRITE_TAC[PERM_EQUIVALENCE_ALT_DEF, APPEND_ASSOC]); - +SIMP_TAC list_ss + [GSYM PERM_EQUIVALENCE_ALT_DEF, PERM_alt, FILTER_APPEND_DISTRIB]) ; val PERM_FUN_APPEND_APPEND_2 = store_thm ( "PERM_FUN_APPEND_APPEND_2", ``!l1 l2 l3 l4. (PERM l1 = PERM (l2++l3)) ==> (PERM (l4 ++ l1) = PERM (l2++(l4++l3)))``, - -REPEAT STRIP_TAC THEN -ASSUME_TAC (Q.SPECL [`l4`, `l1`, `l4`, `l2++l3`] PERM_CONG) THEN -FULL_SIMP_TAC std_ss [PERM_EQUIVALENCE_ALT_DEF, APPEND_ASSOC] THEN -REWRITE_TAC[GSYM PERM_EQUIVALENCE_ALT_DEF, PERM_APPEND_IFF, - PERM_APPEND]); - +SIMP_TAC list_ss + [GSYM PERM_EQUIVALENCE_ALT_DEF, PERM_alt, FILTER_APPEND_DISTRIB]) ; val PERM_FUN_APPEND = store_thm ( "PERM_FUN_APPEND", From 8e9939d17b0f4f35d13cb5c85b7d20f91e6a0f62 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Mon, 27 Apr 2015 01:11:21 +1000 Subject: [PATCH 284/718] alternative definition of LIST_TO_BAG, lemmas, shorter proofs --- src/bag/containerScript.sml | 77 ++++++++++++++++++++----------------- src/sort/sortingScript.sml | 4 +- 2 files changed, 44 insertions(+), 37 deletions(-) diff --git a/src/bag/containerScript.sml b/src/bag/containerScript.sml index ef2c666d84..c634cd32a5 100644 --- a/src/bag/containerScript.sml +++ b/src/bag/containerScript.sml @@ -58,6 +58,13 @@ val LIST_TO_BAG_def = /\ (LIST_TO_BAG (h::t) = BAG_INSERT h (LIST_TO_BAG t))`; val _ = export_rewrites ["LIST_TO_BAG_def"] +val LIST_TO_BAG_alt = store_thm ("LIST_TO_BAG_alt", + ``!l x. LIST_TO_BAG l x = LENGTH (FILTER ($= x) l)``, + EVERY [ REPEAT GEN_TAC, (Induct_on `l`), + (SIMP_TAC list_ss [LIST_TO_BAG_def, EMPTY_BAG_alt, BAG_INSERT]), + GEN_TAC, COND_CASES_TAC THENL [ BasicProvers.VAR_EQ_TAC, ALL_TAC], + (ASM_SIMP_TAC arith_ss [LENGTH]) ]) ; + val BAG_TO_LIST = Hol_defn "BAG_TO_LIST" `BAG_TO_LIST bag = if FINITE_BAG bag @@ -88,20 +95,6 @@ val BAG_TO_LIST_INV = Q.store_thm("BAG_TO_LIST_INV", THEN RW_TAC bool_ss [LIST_TO_BAG_def] THEN PROVE_TAC [BAG_INSERT_CHOICE_REST,FINITE_SUB_BAG,SUB_BAG_REST]); - -val BAG_TO_LIST_CARD = Q.store_thm("BAG_TO_LIST_CARD", -`!b. FINITE_BAG b ==> (LENGTH (BAG_TO_LIST b) = BAG_CARD b)`, - recInduct BAG_TO_LIST_IND - THEN RW_TAC bool_ss [] - THEN ONCE_REWRITE_TAC [UNDISCH BAG_TO_LIST_THM] - THEN RW_TAC bool_ss [listTheory.LENGTH,CONJUNCT1 BAG_CARD_THM] - THEN `FINITE_BAG (BAG_REST bag)` by PROVE_TAC [FINITE_SUB_BAG,SUB_BAG_REST] - THEN RW_TAC bool_ss [] - THEN `BAG_CARD bag = BAG_CARD (BAG_REST bag) + 1` by - PROVE_TAC [BAG_INSERT_CHOICE_REST, BAG_CARD_THM] - THEN RW_TAC bool_ss [arithmeticTheory.ADD1]); - - val BAG_IN_MEM = Q.store_thm("BAG_IN_MEM", `!b. FINITE_BAG b ==> !x. BAG_IN x b = MEM x (BAG_TO_LIST b)`, recInduct BAG_TO_LIST_IND @@ -143,6 +136,20 @@ Induct_on `l1` THENL [ ASM_SIMP_TAC list_ss [LIST_TO_BAG_def, BAG_UNION_INSERT] ]); +val LIST_TO_BAG_MAP = store_thm ("LIST_TO_BAG_MAP", + ``LIST_TO_BAG (MAP f b) = BAG_IMAGE f (LIST_TO_BAG b)``, + EVERY [ (Induct_on `b`), + (ASM_SIMP_TAC list_ss [LIST_TO_BAG_def, BAG_IMAGE_EMPTY]), + GEN_TAC, (irule (GSYM BAG_IMAGE_FINITE_INSERT)), + (irule FINITE_LIST_TO_BAG)] ) ; + +val LIST_TO_BAG_FILTER = store_thm ("LIST_TO_BAG_FILTER", + ``LIST_TO_BAG (FILTER f b) = BAG_FILTER f (LIST_TO_BAG b)``, + EVERY [ (Induct_on `b`), + (ASM_SIMP_TAC list_ss [LIST_TO_BAG_def, BAG_FILTER_EMPTY]), + GEN_TAC, COND_CASES_TAC, + (ASM_SIMP_TAC list_ss [LIST_TO_BAG_def, BAG_FILTER_BAG_INSERT]) ] ) ; + val INN_LIST_TO_BAG = store_thm ("IN_LIST_TO_BAG", ``!n h l. BAG_INN h n (LIST_TO_BAG l) = (LENGTH (FILTER ($= h) l) >= n)``, @@ -159,6 +166,11 @@ Induct_on `l` THENL [ ASM_SIMP_TAC list_ss [LIST_TO_BAG_def, BAG_IN_BAG_INSERT] ]); +val LIST_TO_BAG_DISTINCT = store_thm ("LIST_TO_BAG_DISTINCT", + ``BAG_ALL_DISTINCT (LIST_TO_BAG b) = ALL_DISTINCT b``, + (Induct_on `b`) THEN + (ASM_SIMP_TAC (srw_ss ()) [LIST_TO_BAG_def, IN_LIST_TO_BAG])) ; + val LIST_TO_BAG_EQ_EMPTY = store_thm ("LIST_TO_BAG_EQ_EMPTY", ``!l. (LIST_TO_BAG l = EMPTY_BAG) = (l = [])``, Cases_on `l` THEN @@ -166,27 +178,14 @@ SIMP_TAC list_ss [LIST_TO_BAG_def, BAG_INSERT_NOT_EMPTY]); val PERM_LIST_TO_BAG = store_thm ("PERM_LIST_TO_BAG", -``!l1 l2. (LIST_TO_BAG l1 = LIST_TO_BAG l2) = PERM l1 l2``, -SIMP_TAC std_ss [BAG_EXTENSION, INN_LIST_TO_BAG, PERM_DEF] THEN -REPEAT GEN_TAC THEN EQ_TAC THEN SIMP_TAC std_ss [] THEN -REWRITE_TAC[LIST_EQ_REWRITE] THEN -STRIP_TAC THEN GEN_TAC THEN - -POP_ASSUM (ASSUME_TAC o Q.GEN `m` o Q.SPECL [`m`, `x`]) THEN -Q.ABBREV_TAC `m1 = LENGTH (FILTER ($= x) l1)` THEN -Q.ABBREV_TAC `m2 = LENGTH (FILTER ($= x) l2)` THEN -Q.PAT_ASSUM `!m. X` (fn thm => - ASSUME_TAC (Q.SPEC `m1` thm) THEN - ASSUME_TAC (Q.SPEC `m2` thm)) THEN -FULL_SIMP_TAC arith_ss [] THEN -REPEAT STRIP_TAC THEN -`MEM (EL x' (FILTER ($= x) l1)) (FILTER ($= x) l1) /\ - MEM (EL x' (FILTER ($= x) l2)) (FILTER ($= x) l2)` by ALL_TAC THEN1 ( - `x' < m2` by bossLib.DECIDE_TAC THEN - METIS_TAC[MEM_EL] -) THEN -FULL_SIMP_TAC list_ss [MEM_FILTER] THEN -METIS_TAC[]); + ``!l1 l2. (LIST_TO_BAG l1 = LIST_TO_BAG l2) = PERM l1 l2``, + (REPEAT GEN_TAC THEN SIMP_TAC std_ss [PERM_DEF]) THEN + (irule IMP_ANTISYM_AX) THENL [ + DISCH_TAC THEN irule EQ_EXT THEN (ASM_SIMP_TAC std_ss [LIST_TO_BAG_alt]), + EVERY [ REPEAT STRIP_TAC, + (POP_ASSUM (fn th => ASSUME_TAC (Q.AP_THM th `x`))), + (FULL_SIMP_TAC std_ss [LIST_TO_BAG_alt]), + (ONCE_REWRITE_TAC [FILTER_EQ_REP]), (ASM_SIMP_TAC std_ss []) ]]) ; val CARD_LIST_TO_BAG = Q.store_thm( "CARD_LIST_TO_BAG", @@ -194,6 +193,14 @@ val CARD_LIST_TO_BAG = Q.store_thm( Induct_on `ls` THEN SRW_TAC [][BAG_CARD_THM,arithmeticTheory.ADD1]) before export_rewrites ["CARD_LIST_TO_BAG"]; +val EQ_TRANS' = REWRITE_RULE [GSYM AND_IMP_INTRO] EQ_TRANS ; +val th = MATCH_MP EQ_TRANS' (SYM CARD_LIST_TO_BAG) ; + +val BAG_TO_LIST_CARD = store_thm ("BAG_TO_LIST_CARD", + ``!b. FINITE_BAG b ⇒ (LENGTH (BAG_TO_LIST b) = BAG_CARD b)``, + EVERY [(REPEAT STRIP_TAC), (irule th), + (ASM_SIMP_TAC bool_ss [BAG_TO_LIST_INV]) ]) ; + val BAG_TO_LIST_EQ_NIL = Q.store_thm( "BAG_TO_LIST_EQ_NIL", `FINITE_BAG b ==> diff --git a/src/sort/sortingScript.sml b/src/sort/sortingScript.sml index a3b93000f6..27c6f471f5 100644 --- a/src/sort/sortingScript.sml +++ b/src/sort/sortingScript.sml @@ -169,8 +169,8 @@ RW_TAC bool_ss [o_DEF] Alternative definition of PERM ---------------------------------------------------------------------- *) -val FILTER_EQ_REP = - prove (``FILTER ($= x) l = REPLICATE (LENGTH (FILTER ($= x) l)) x``, +val FILTER_EQ_REP = store_thm ("FILTER_EQ_REP", + ``FILTER ($= x) l = REPLICATE (LENGTH (FILTER ($= x) l)) x``, EVERY [(Induct_on `l`), (SIMP_TAC list_ss [rich_listTheory.REPLICATE]), GEN_TAC, COND_CASES_TAC THENL [ BasicProvers.VAR_EQ_TAC, ALL_TAC], From 8e70374fd45e51aac0ff5fbe3ea260224c4f4417 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 27 Apr 2015 17:05:53 +1000 Subject: [PATCH 285/718] Remove unused number.sh 'script'. I believe this little thing is equivalent to cat -n --- src/integer/testing/number.sh | 3 --- 1 file changed, 3 deletions(-) delete mode 100755 src/integer/testing/number.sh diff --git a/src/integer/testing/number.sh b/src/integer/testing/number.sh deleted file mode 100755 index a0ea6ae52f..0000000000 --- a/src/integer/testing/number.sh +++ /dev/null @@ -1,3 +0,0 @@ -#!/bin/sh - -perl -e '$/ = "\n\n"; while (<>) { print $i++, " ", $_; }' From 431befc508134f3da00bd646737167e9188df2b7 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Wed, 29 Apr 2015 20:50:27 +1000 Subject: [PATCH 286/718] changed first occurrence of name PERM_FUN_APPEND to PERM_FUN_APPEND_C found two theorems with same name in sortingScript, this change makes the first one accessible --- src/sort/sortingScript.sml | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/sort/sortingScript.sml b/src/sort/sortingScript.sml index 27c6f471f5..0486be585e 100644 --- a/src/sort/sortingScript.sml +++ b/src/sort/sortingScript.sml @@ -1003,8 +1003,9 @@ PROVE_TAC[QSORT_PERM,QSORT_SORTED,SORTED_PERM_EQ,PERM_TRANS,PERM_SYM]) (*Perm theorems for the simplication*) -val PERM_FUN_APPEND = store_thm ( -"PERM_FUN_APPEND", +(* was PERM_FUN_APPEND but this name is used again lower down *) +val PERM_FUN_APPEND_C = store_thm ( +"PERM_FUN_APPEND_C", ``!l1 l1' l2 l2'. (PERM l1 = PERM l1') ==> (PERM l2 = PERM l2') ==> From 480ae0bfff2d7b71efafa29eca4d9ceb8c26dcce Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Wed, 29 Apr 2015 20:54:29 +1000 Subject: [PATCH 287/718] fix garbled comment in source code only the comment is changed --- src/1/Tactical.sml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/1/Tactical.sml b/src/1/Tactical.sml index 280f8b9346..83745805ab 100644 --- a/src/1/Tactical.sml +++ b/src/1/Tactical.sml @@ -385,7 +385,7 @@ end * GEN_VALIDATE true tac * * is the same as "tac", except that where "tac" returns a proof which is - * because if proves a theorem with extra hypotheses, it returns those + * invalid because it proves a theorem with extra hypotheses, it returns those * hypotheses as extra goals * * VALIDATE_LT ltac From 750873d852c9b7266df858f997bcd40e13782213 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Wed, 29 Apr 2015 22:00:27 +1000 Subject: [PATCH 288/718] added to VAR_EQ_TAC doc, v = ... v ... ignored --- help/Docfiles/BasicProvers.VAR_EQ_TAC.doc | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/help/Docfiles/BasicProvers.VAR_EQ_TAC.doc b/help/Docfiles/BasicProvers.VAR_EQ_TAC.doc index e344824523..399b5bd334 100644 --- a/help/Docfiles/BasicProvers.VAR_EQ_TAC.doc +++ b/help/Docfiles/BasicProvers.VAR_EQ_TAC.doc @@ -12,7 +12,8 @@ simplification, rewriting, tactic. \DESCRIBE {VAR_EQ_TAC} simplifies the goal, including its assumptions, using one assumption of -the form {v = t} or {t = v}, where {v} is a variable. +the form {v = t} or {t = v}, where {v} is a variable +which is not contained in {t}. In both cases, {v} is replaced throughout by {t}, and the relevant assumption is deleted. From cb2c02ca7a2da50b5405373acad9c659099e4d88 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Wed, 29 Apr 2015 22:01:49 +1000 Subject: [PATCH 289/718] removed extraneous parens, also irule IMP_ANTISYM_AX -> EQ_TAC --- src/bag/containerScript.sml | 39 ++++++++++++++++++------------------- src/sort/sortingScript.sml | 33 +++++++++++++------------------ 2 files changed, 33 insertions(+), 39 deletions(-) diff --git a/src/bag/containerScript.sml b/src/bag/containerScript.sml index c634cd32a5..fb7c596ae1 100644 --- a/src/bag/containerScript.sml +++ b/src/bag/containerScript.sml @@ -60,10 +60,10 @@ val _ = export_rewrites ["LIST_TO_BAG_def"] val LIST_TO_BAG_alt = store_thm ("LIST_TO_BAG_alt", ``!l x. LIST_TO_BAG l x = LENGTH (FILTER ($= x) l)``, - EVERY [ REPEAT GEN_TAC, (Induct_on `l`), - (SIMP_TAC list_ss [LIST_TO_BAG_def, EMPTY_BAG_alt, BAG_INSERT]), + EVERY [ REPEAT GEN_TAC, Induct_on `l`, + SIMP_TAC list_ss [LIST_TO_BAG_def, EMPTY_BAG_alt, BAG_INSERT], GEN_TAC, COND_CASES_TAC THENL [ BasicProvers.VAR_EQ_TAC, ALL_TAC], - (ASM_SIMP_TAC arith_ss [LENGTH]) ]) ; + ASM_SIMP_TAC arith_ss [LENGTH] ]) ; val BAG_TO_LIST = Hol_defn "BAG_TO_LIST" `BAG_TO_LIST bag = @@ -138,17 +138,17 @@ Induct_on `l1` THENL [ val LIST_TO_BAG_MAP = store_thm ("LIST_TO_BAG_MAP", ``LIST_TO_BAG (MAP f b) = BAG_IMAGE f (LIST_TO_BAG b)``, - EVERY [ (Induct_on `b`), - (ASM_SIMP_TAC list_ss [LIST_TO_BAG_def, BAG_IMAGE_EMPTY]), - GEN_TAC, (irule (GSYM BAG_IMAGE_FINITE_INSERT)), - (irule FINITE_LIST_TO_BAG)] ) ; + EVERY [ Induct_on `b`, + ASM_SIMP_TAC list_ss [LIST_TO_BAG_def, BAG_IMAGE_EMPTY], + GEN_TAC, irule (GSYM BAG_IMAGE_FINITE_INSERT), + irule FINITE_LIST_TO_BAG] ) ; val LIST_TO_BAG_FILTER = store_thm ("LIST_TO_BAG_FILTER", ``LIST_TO_BAG (FILTER f b) = BAG_FILTER f (LIST_TO_BAG b)``, - EVERY [ (Induct_on `b`), - (ASM_SIMP_TAC list_ss [LIST_TO_BAG_def, BAG_FILTER_EMPTY]), + EVERY [ Induct_on `b`, + ASM_SIMP_TAC list_ss [LIST_TO_BAG_def, BAG_FILTER_EMPTY], GEN_TAC, COND_CASES_TAC, - (ASM_SIMP_TAC list_ss [LIST_TO_BAG_def, BAG_FILTER_BAG_INSERT]) ] ) ; + ASM_SIMP_TAC list_ss [LIST_TO_BAG_def, BAG_FILTER_BAG_INSERT] ] ) ; val INN_LIST_TO_BAG = store_thm ("IN_LIST_TO_BAG", @@ -168,8 +168,8 @@ Induct_on `l` THENL [ val LIST_TO_BAG_DISTINCT = store_thm ("LIST_TO_BAG_DISTINCT", ``BAG_ALL_DISTINCT (LIST_TO_BAG b) = ALL_DISTINCT b``, - (Induct_on `b`) THEN - (ASM_SIMP_TAC (srw_ss ()) [LIST_TO_BAG_def, IN_LIST_TO_BAG])) ; + Induct_on `b` THEN + ASM_SIMP_TAC (srw_ss ()) [LIST_TO_BAG_def, IN_LIST_TO_BAG]) ; val LIST_TO_BAG_EQ_EMPTY = store_thm ("LIST_TO_BAG_EQ_EMPTY", ``!l. (LIST_TO_BAG l = EMPTY_BAG) = (l = [])``, @@ -179,13 +179,12 @@ SIMP_TAC list_ss [LIST_TO_BAG_def, BAG_INSERT_NOT_EMPTY]); val PERM_LIST_TO_BAG = store_thm ("PERM_LIST_TO_BAG", ``!l1 l2. (LIST_TO_BAG l1 = LIST_TO_BAG l2) = PERM l1 l2``, - (REPEAT GEN_TAC THEN SIMP_TAC std_ss [PERM_DEF]) THEN - (irule IMP_ANTISYM_AX) THENL [ - DISCH_TAC THEN irule EQ_EXT THEN (ASM_SIMP_TAC std_ss [LIST_TO_BAG_alt]), + REPEAT GEN_TAC THEN SIMP_TAC std_ss [PERM_DEF] THEN EQ_TAC THENL [ EVERY [ REPEAT STRIP_TAC, - (POP_ASSUM (fn th => ASSUME_TAC (Q.AP_THM th `x`))), - (FULL_SIMP_TAC std_ss [LIST_TO_BAG_alt]), - (ONCE_REWRITE_TAC [FILTER_EQ_REP]), (ASM_SIMP_TAC std_ss []) ]]) ; + POP_ASSUM (fn th => ASSUME_TAC (Q.AP_THM th `x`)), + FULL_SIMP_TAC std_ss [LIST_TO_BAG_alt], + ONCE_REWRITE_TAC [FILTER_EQ_REP], ASM_SIMP_TAC std_ss [] ], + DISCH_TAC THEN irule EQ_EXT THEN ASM_SIMP_TAC std_ss [LIST_TO_BAG_alt] ]) ; val CARD_LIST_TO_BAG = Q.store_thm( "CARD_LIST_TO_BAG", @@ -198,8 +197,8 @@ val th = MATCH_MP EQ_TRANS' (SYM CARD_LIST_TO_BAG) ; val BAG_TO_LIST_CARD = store_thm ("BAG_TO_LIST_CARD", ``!b. FINITE_BAG b ⇒ (LENGTH (BAG_TO_LIST b) = BAG_CARD b)``, - EVERY [(REPEAT STRIP_TAC), (irule th), - (ASM_SIMP_TAC bool_ss [BAG_TO_LIST_INV]) ]) ; + EVERY [REPEAT STRIP_TAC, irule th, + ASM_SIMP_TAC bool_ss [BAG_TO_LIST_INV] ]) ; val BAG_TO_LIST_EQ_NIL = Q.store_thm( "BAG_TO_LIST_EQ_NIL", diff --git a/src/sort/sortingScript.sml b/src/sort/sortingScript.sml index 0486be585e..bdd435257b 100644 --- a/src/sort/sortingScript.sml +++ b/src/sort/sortingScript.sml @@ -171,24 +171,24 @@ RW_TAC bool_ss [o_DEF] val FILTER_EQ_REP = store_thm ("FILTER_EQ_REP", ``FILTER ($= x) l = REPLICATE (LENGTH (FILTER ($= x) l)) x``, - EVERY [(Induct_on `l`), - (SIMP_TAC list_ss [rich_listTheory.REPLICATE]), GEN_TAC, + EVERY [Induct_on `l`, + SIMP_TAC list_ss [rich_listTheory.REPLICATE], GEN_TAC, COND_CASES_TAC THENL [ BasicProvers.VAR_EQ_TAC, ALL_TAC], - (ASM_SIMP_TAC list_ss [rich_listTheory.REPLICATE]) ]) ; + ASM_SIMP_TAC list_ss [rich_listTheory.REPLICATE] ]) ; val FILTER_EQ_LENGTHS_EQ = store_thm ("FILTER_EQ_LENGTHS_EQ", ``(LENGTH (FILTER ($= x) l1) = LENGTH (FILTER ($= x) l2)) ==> (FILTER ($= x) l1 = FILTER ($= x) l2)``, EVERY [ DISCH_TAC, ONCE_REWRITE_TAC [FILTER_EQ_REP], - (ASM_SIMP_TAC bool_ss []) ]) ; + ASM_SIMP_TAC bool_ss [] ]) ; val PERM_alt = store_thm ("PERM_alt", ``!L1 L2. PERM L1 L2 = !x. LENGTH (FILTER ($= x) L1) = LENGTH (FILTER ($= x) L2)``, - EVERY [(REWRITE_TAC [PERM_DEF]), (REPEAT GEN_TAC), - (irule IMP_ANTISYM_AX), (REPEAT STRIP_TAC) ] THENL [ - (ASM_SIMP_TAC bool_ss []), - (irule FILTER_EQ_LENGTHS_EQ) THEN (ASM_REWRITE_TAC []) ]) ; + EVERY [REWRITE_TAC [PERM_DEF], REPEAT GEN_TAC, + EQ_TAC, REPEAT STRIP_TAC ] THENL [ + ASM_SIMP_TAC bool_ss [], + irule FILTER_EQ_LENGTHS_EQ THEN ASM_REWRITE_TAC [] ]) ; (* ---------------------------------------------------------------------- Inductive characterisation of PERM @@ -329,8 +329,7 @@ val PERM_SWAP_AT_FRONT = store_thm( val PERM_SWAP_L_AT_FRONT = store_thm( "PERM_SWAP_L_AT_FRONT", ``!x y. PERM (x++y++l1) (y++x++l2) = PERM l1 l2``, - SIMP_TAC list_ss - [PERM_alt, FILTER_APPEND_DISTRIB]) ; + SIMP_TAC list_ss [PERM_alt, FILTER_APPEND_DISTRIB]) ; (* alternative proof of PERM_SWAP_AT_FRONT val PERM_SWAP_AT_FRONT' = SPECL [``[x]``, ``[y]``] PERM_SWAP_L_AT_FRONT ; @@ -1010,9 +1009,7 @@ val PERM_FUN_APPEND_C = store_thm ( (PERM l1 = PERM l1') ==> (PERM l2 = PERM l2') ==> (PERM (l1 ++ l2) = PERM (l1' ++ l2'))``, - -SIMP_TAC std_ss [GSYM PERM_EQUIVALENCE_ALT_DEF, - PERM_CONG]); +SIMP_TAC std_ss [GSYM PERM_EQUIVALENCE_ALT_DEF, PERM_CONG]); val PERM_FUN_CONS = store_thm ( @@ -1020,9 +1017,7 @@ val PERM_FUN_CONS = store_thm ( ``!x l1 l1'. (PERM l1 = PERM l1') ==> (PERM (x::l1) = PERM (x::l1'))``, - -SIMP_TAC std_ss [GSYM PERM_EQUIVALENCE_ALT_DEF, - PERM_CONS_IFF]); +SIMP_TAC std_ss [GSYM PERM_EQUIVALENCE_ALT_DEF, PERM_CONS_IFF]); val PERM_FUN_APPEND_CONS = store_thm ( @@ -1057,7 +1052,7 @@ val PERM_FUN_CONS_11_APPEND = store_thm ( (PERM (y::l1) = PERM (l2++(y::l3)))``, EVERY [SIMP_TAC list_ss [GSYM PERM_EQUIVALENCE_ALT_DEF, PERM_alt, FILTER_APPEND_DISTRIB], - REPEAT STRIP_TAC, COND_CASES_TAC, (ASM_SIMP_TAC list_ss []) ]) ; + REPEAT STRIP_TAC, COND_CASES_TAC, ASM_SIMP_TAC list_ss [] ]) ; val PERM_FUN_CONS_APPEND_1 = store_thm ( "PERM_FUN_CONS_APPEND_1", @@ -1066,7 +1061,7 @@ val PERM_FUN_CONS_APPEND_1 = store_thm ( (PERM (l1 ++ l) = PERM (x::(l2++l)))``, EVERY [SIMP_TAC list_ss [GSYM PERM_EQUIVALENCE_ALT_DEF, PERM_alt, FILTER_APPEND_DISTRIB], - REPEAT STRIP_TAC, COND_CASES_TAC, (ASM_SIMP_TAC list_ss []) ]) ; + REPEAT STRIP_TAC, COND_CASES_TAC, ASM_SIMP_TAC list_ss [] ]) ; val PERM_FUN_CONS_APPEND_2 = store_thm ( "PERM_FUN_CONS_APPEND_2", @@ -1075,7 +1070,7 @@ val PERM_FUN_CONS_APPEND_2 = store_thm ( (PERM (l ++ l1) = PERM (x::(l ++ l2)))``, EVERY [SIMP_TAC list_ss [GSYM PERM_EQUIVALENCE_ALT_DEF, PERM_alt, FILTER_APPEND_DISTRIB], - REPEAT STRIP_TAC, COND_CASES_TAC, (ASM_SIMP_TAC list_ss []) ]) ; + REPEAT STRIP_TAC, COND_CASES_TAC, ASM_SIMP_TAC list_ss [] ]) ; val PERM_FUN_APPEND_APPEND_1 = store_thm ( "PERM_FUN_APPEND_APPEND_1", From 003bd6a305b6f5b3a6af64b986ae09bd3639d3d5 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Wed, 29 Apr 2015 23:26:35 +1000 Subject: [PATCH 290/718] trivial change to comment in source file purpose is to trigger another attempt at buiding on github --- src/1/Tactical.sml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/1/Tactical.sml b/src/1/Tactical.sml index 83745805ab..ccfd9fce11 100644 --- a/src/1/Tactical.sml +++ b/src/1/Tactical.sml @@ -385,8 +385,8 @@ end * GEN_VALIDATE true tac * * is the same as "tac", except that where "tac" returns a proof which is - * invalid because it proves a theorem with extra hypotheses, it returns those - * hypotheses as extra goals + * invalid because it proves a theorem with extra hypotheses, + * it returns those hypotheses as extra goals * * VALIDATE_LT ltac * GEN_VALIDATE_LT true ltac From 1c6d68e0d427885b6eed08bb4a7ffc2dde6738e3 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Thu, 30 Apr 2015 17:02:12 +1000 Subject: [PATCH 291/718] fix construction of error value in NTH_GOAL --- src/1/Tactical.sml | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/1/Tactical.sml b/src/1/Tactical.sml index ccfd9fce11..46a4d2d3d6 100644 --- a/src/1/Tactical.sml +++ b/src/1/Tactical.sml @@ -224,7 +224,9 @@ fun op THEN1 (tac1: tactic, tac2: tactic) : tactic = fun NTH_GOAL tac n gl1 = let val (gl_before, ggl_after) = Lib.split_after (n-1) gl1 + handle _ => raise ERR "NTH_GOAL" "no nth subgoal in list" ; val (g, gl_after) = valOf (List.getItem ggl_after) + handle _ => raise ERR "NTH_GOAL" "no nth subgoal in list" ; val (gl2, vf2) = tac g ; val gl_result = gl_before @ gl2 @ gl_after ; fun vf thl = @@ -232,8 +234,7 @@ fun NTH_GOAL tac n gl1 = val (th2, th_after) = Lib.split_after (length gl2) th_rest ; val th_result = th_before @ vf2 th2 :: th_after ; in th_result end ; - in (gl_result, vf) end - handle _ => raise ERR "NTH_GOAL" "no nth subgoal in list" ; + in (gl_result, vf) end ; fun LASTGOAL tac gl1 = NTH_GOAL tac (length gl1) gl1 ; fun HEADGOAL tac gl1 = NTH_GOAL tac 1 gl1 ; From 0603cdeb0e38f6673aa39fb3aeb3681f342117aa Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Sat, 2 May 2015 13:12:11 +1000 Subject: [PATCH 292/718] stronger versions of MEM_TAKE/DROP etc --- src/list/src/rich_listScript.sml | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/src/list/src/rich_listScript.sml b/src/list/src/rich_listScript.sml index 2f4a21f845..83eae1534f 100644 --- a/src/list/src/rich_listScript.sml +++ b/src/list/src/rich_listScript.sml @@ -2113,6 +2113,20 @@ val EXISTS_SEG = Q.store_thm ("EXISTS_SEG", SUBST1_TAC (numLib.DECIDE ``m + SUC k = SUC m + k``) THEN REPEAT STRIP_TAC THEN DISJ2_TAC THEN RES_TAC]); +val EXISTS_TAKE_IMP = Q.store_thm ("EXISTS_TAKE_IMP", + `!l m P. EXISTS P (TAKE m l) ==> EXISTS P l`, + EVERY [Induct, ASM_SIMP_TAC list_ss [], + REPEAT GEN_TAC, COND_CASES_TAC, + ASM_SIMP_TAC list_ss [EXISTS_DEF], + PROVE_TAC [EXISTS_DEF] ]) ; + +val EXISTS_DROP_IMP = Q.store_thm ("EXISTS_DROP_IMP", + `!l m P. EXISTS P (DROP m l) ==> EXISTS P l`, + EVERY [Induct, ASM_SIMP_TAC list_ss [], + REPEAT GEN_TAC, COND_CASES_TAC, + ASM_SIMP_TAC list_ss [EXISTS_DEF], + PROVE_TAC [EXISTS_DEF] ]) ; + val EXISTS_TAKE = Q.store_thm ("EXISTS_TAKE", `!m l. m <= LENGTH l ==> !P. EXISTS P (TAKE m l) ==> EXISTS P l`, REPEAT GEN_TAC @@ -2168,6 +2182,18 @@ val MEM_SEG = Q.store_thm ("MEM_SEG", THEN DISJ2_TAC THEN RES_TAC]); +val MEM_TAKE_IMP = Q.store_thm ("MEM_TAKE_IMP", + `!l m x. MEM x (TAKE m l) ==> MEM x l`, + EVERY [Induct, ASM_SIMP_TAC list_ss [], + REPEAT GEN_TAC, COND_CASES_TAC, + ASM_SIMP_TAC list_ss [], PROVE_TAC [] ]) ; + +val MEM_DROP_IMP = Q.store_thm ("MEM_DROP_IMP", + `!l m x. MEM x (DROP m l) ==> MEM x l`, + EVERY [Induct, ASM_SIMP_TAC list_ss [], + REPEAT GEN_TAC, COND_CASES_TAC, + ASM_SIMP_TAC list_ss [], PROVE_TAC [] ]) ; + val MEM_TAKE = Q.store_thm ("MEM_TAKE", `!m l. m <= LENGTH l ==> !x. MEM x (TAKE m l) ==> MEM x l`, PURE_ONCE_REWRITE_TAC [MEM_EXISTS] From 3120ad1455f4f2d6123dcbfa759f35c80bf7bc18 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Sat, 2 May 2015 22:05:24 +1000 Subject: [PATCH 293/718] INST_TT_HYPS - as INST_TY_TERM but also retuns hyps in the order they are returned by hyp (original theorem) needed so that irule will give new subgoals in predictable order temporary change to Drule.INST_TY_TERM is for testing --- src/0/Thm.sml | 21 +++++++++++++++++++++ src/1/Drule.sml | 8 ++++++++ src/TeX/warning_stream.sml | 1 + src/prekernel/FinalThm-sig.sml | 2 ++ 4 files changed, 32 insertions(+) create mode 100644 src/TeX/warning_stream.sml diff --git a/src/0/Thm.sml b/src/0/Thm.sml index 6742a9b439..ef4e486a9c 100644 --- a/src/0/Thm.sml +++ b/src/0/Thm.sml @@ -955,6 +955,27 @@ fun INST [] th = th else raise ERR "INST" "can only instantiate variables" +(*---------------------------------------------------------------------------* + * Instantiate terms and types of a theorem, also returning a list of * + * substituted hypotheses in the same order as in hyp th * + *---------------------------------------------------------------------------*) + +fun INST_TT_HYPS (Stm, Sty) (th as THM (ocl, asl, c)) = + let + val _ = if List.all (is_var o #redex) Stm then () + else raise ERR "INST" "can only instantiate variables" ; + val hyps = HOLset.listItems asl ; + (* instantiate types *) + val hyps_sty = map (inst Sty) hyps ; + val c_sty = inst Sty c ; + (* instantiate terms *) + val hyps_stt = map (subst Stm) hyps_sty ; + val c_stt = subst Stm c_sty ; + (* construct the theorem *) + val seq = (ocl, HOLset.addList (empty_hyp, hyps_stt), c_stt) ; + val THM seq' = make_thm Count.InstType seq ; + val thm = make_thm Count.Inst seq' ; + in (thm, hyps_stt) end ; (*---------------------------------------------------------------------------* * Now some derived rules optimized for computations, avoiding most * diff --git a/src/1/Drule.sml b/src/1/Drule.sml index 48ceda82b9..2139780355 100644 --- a/src/1/Drule.sml +++ b/src/1/Drule.sml @@ -1207,7 +1207,15 @@ fun EXISTS_IMP x th = * it makes two full traversals of the theorem. * *---------------------------------------------------------------------------*) +(* fun INST_TY_TERM (Stm, Sty) th = INST Stm (INST_TYPE Sty th) +*) +fun INST_TY_TERM (Stm, Sty) th = + let val (sth', _) = (Thm.INST_TT_HYPS (Stm, Sty) th) ; + val sth = INST Stm (INST_TYPE Sty th) ; + val check = if (hyp sth, concl sth) = (hyp sth', concl sth') then () + else raise ERR "INST_TY_TERM" "INST_TT_HYPS check failed" ; + in sth' end ; (*---------------------------------------------------------------------------* * |- !x y z. w ---> |- w[g1/x][g2/y][g3/z] * diff --git a/src/TeX/warning_stream.sml b/src/TeX/warning_stream.sml new file mode 100644 index 0000000000..95d8f82ddb --- /dev/null +++ b/src/TeX/warning_stream.sml @@ -0,0 +1 @@ +val () = Feedback.WARNING_outstream := TextIO.stdErr diff --git a/src/prekernel/FinalThm-sig.sml b/src/prekernel/FinalThm-sig.sml index 898b4a9633..b0dbdf4f05 100644 --- a/src/prekernel/FinalThm-sig.sml +++ b/src/prekernel/FinalThm-sig.sml @@ -54,6 +54,8 @@ sig (* Free variable instantiation *) val INST : (term,term)Lib.subst -> thm -> thm + val INST_TT_HYPS : (term,term)Lib.subst * (hol_type,hol_type)Lib.subst -> + thm -> thm * term list (* Universal quantification *) From 5b2ce89be9d0b6a3ac11b21bb2eda78dc08f28c0 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Sat, 2 May 2015 23:29:42 +1000 Subject: [PATCH 294/718] reverting INST_TY_TERM to original version this removes temporary code which tested INST_TT_HYPS every time INST_TY_TERM was called --- src/1/Drule.sml | 8 -------- 1 file changed, 8 deletions(-) diff --git a/src/1/Drule.sml b/src/1/Drule.sml index 2139780355..48ceda82b9 100644 --- a/src/1/Drule.sml +++ b/src/1/Drule.sml @@ -1207,15 +1207,7 @@ fun EXISTS_IMP x th = * it makes two full traversals of the theorem. * *---------------------------------------------------------------------------*) -(* fun INST_TY_TERM (Stm, Sty) th = INST Stm (INST_TYPE Sty th) -*) -fun INST_TY_TERM (Stm, Sty) th = - let val (sth', _) = (Thm.INST_TT_HYPS (Stm, Sty) th) ; - val sth = INST Stm (INST_TYPE Sty th) ; - val check = if (hyp sth, concl sth) = (hyp sth', concl sth') then () - else raise ERR "INST_TY_TERM" "INST_TT_HYPS check failed" ; - in sth' end ; (*---------------------------------------------------------------------------* * |- !x y z. w ---> |- w[g1/x][g2/y][g3/z] * From b54e6e2706d19d1cdee8288aec96580336d73fa2 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Sat, 2 May 2015 23:55:36 +1000 Subject: [PATCH 295/718] new irule, order of new subgoals is consistent, regardless of how the substitution may change the internal order of hypothesis in the argument theorem also new tactical ADD_SGS_TAC - like VALIDATE but new terms to be proved need to be specified --- src/1/Tactic.sml | 4 ++-- src/1/Tactical.sig | 1 + src/1/Tactical.sml | 15 +++++++++++++++ 3 files changed, 18 insertions(+), 2 deletions(-) diff --git a/src/1/Tactic.sml b/src/1/Tactic.sml index 89c8c49fbd..5ab8558f9a 100644 --- a/src/1/Tactic.sml +++ b/src/1/Tactic.sml @@ -720,8 +720,8 @@ fun MATCH_ACCEPT_TAC thm : tactic = fun prim_irule thm (asl, w) = let val matchsub = match_term (concl thm) w ; - val subthm = INST_TY_TERM matchsub thm ; - in GEN_VALIDATE false (ACCEPT_TAC subthm) (asl, w) end ; + val (subthm, subhyps) = INST_TT_HYPS matchsub thm ; + in ADD_SGS_TAC subhyps (ACCEPT_TAC subthm) (asl, w) end ; (* --------------------------------------------------------------------------* * MATCH_MP_TAC: Takes a theorem of the form * diff --git a/src/1/Tactical.sig b/src/1/Tactical.sig index 3561d897ba..165c081f00 100644 --- a/src/1/Tactical.sig +++ b/src/1/Tactical.sig @@ -53,6 +53,7 @@ sig val VALIDATE_LT : list_tactic -> list_tactic val GEN_VALIDATE : bool -> tactic -> tactic val GEN_VALIDATE_LT : bool -> list_tactic -> list_tactic + val ADD_SGS_TAC : term list -> tactic -> tactic val EVERY : tactic list -> tactic val EVERY_LT : list_tactic list -> list_tactic val FIRST : tactic list -> tactic diff --git a/src/1/Tactical.sml b/src/1/Tactical.sml index 46a4d2d3d6..173fff327d 100644 --- a/src/1/Tactical.sml +++ b/src/1/Tactical.sml @@ -336,6 +336,21 @@ fun TRYALL tac = ALLGOALS (TRY tac) ; fun REPEAT tac g = ((tac THEN REPEAT tac) ORELSE ALL_TAC) g fun REPEAT_LT ltac gl = ((ltac THEN_LT REPEAT_LT ltac) ORELSE_LT ALL_LT) gl +(*--------------------------------------------------------------------------- + * Add extra subgoals, which may be needed to make a tactic valid; + * similar to VALIDATE, but you can control the order of the extra goals + *---------------------------------------------------------------------------*) +fun ADD_SGS_TAC (tms : term list) (tac : tactic) (g as (asl, w) : goal) = + let val (glist, prf) = tac g ; + val extra_goals = map (fn tm => (asl, tm)) tms ; + val nextra = length extra_goals ; + (* new validation: apply the theorems proving the additional goals to + eliminate the extra hyps in the theorem proved by the given validation *) + fun eprf ethlist = + let val (extra_thms, thlist) = split_after nextra ethlist ; + in itlist PROVE_HYP extra_thms (prf thlist) end ; + in (extra_goals @ glist, eprf) end ; + (*--------------------------------------------------------------------------- * Tacticals to make any tactic or list_tactic valid. * From 6c27787ee725c0e300c2a6f51206e290ee381022 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Sun, 3 May 2015 23:05:46 +1000 Subject: [PATCH 296/718] docs for changes to irule and functions it uses --- help/Docfiles/Drule.INST_TY_TERM.doc | 2 +- help/Docfiles/Tactic.irule.doc | 4 ++ help/Docfiles/Tactic.prim_irule.doc | 7 ++- help/Docfiles/Tactical.ADD_SGS_TAC.doc | 78 +++++++++++++++++++++++++ help/Docfiles/Tactical.GEN_VALIDATE.doc | 2 +- help/Docfiles/Tactical.VALIDATE.doc | 2 +- help/Docfiles/Thm.INST_TT_HYPS.doc | 26 +++++++++ 7 files changed, 116 insertions(+), 5 deletions(-) create mode 100644 help/Docfiles/Tactical.ADD_SGS_TAC.doc create mode 100644 help/Docfiles/Thm.INST_TT_HYPS.doc diff --git a/help/Docfiles/Drule.INST_TY_TERM.doc b/help/Docfiles/Drule.INST_TY_TERM.doc index e83b70f792..aaea04861d 100644 --- a/help/Docfiles/Drule.INST_TY_TERM.doc +++ b/help/Docfiles/Drule.INST_TY_TERM.doc @@ -27,5 +27,5 @@ original ones. Use {norm_subst} to achieve this. \SEEALSO Thm.INST, Thm.INST_TYPE, Drule.ISPEC, Thm.SPEC, Drule.SUBS, Thm.SUBST, -Term.norm_subst +Term.norm_subst, Thm.INST_TT_HYPS \ENDDOC diff --git a/help/Docfiles/Tactic.irule.doc b/help/Docfiles/Tactic.irule.doc index bf302b58b2..7f9571b73f 100644 --- a/help/Docfiles/Tactic.irule.doc +++ b/help/Docfiles/Tactic.irule.doc @@ -45,6 +45,10 @@ implications. See {SPEC_UNDISCH_EXL} for details. Then {prim_irule} is applied. To avoid this preprocessing just use {prim_irule}. +The order of the new subgoals depends on the order in which the hypotheses of +the pre-processed theorem (before the substitution) are stored. +See {prim_irule}. + \EXAMPLE With goal {R a (f b)} and theorem {thm} being { diff --git a/help/Docfiles/Tactic.prim_irule.doc b/help/Docfiles/Tactic.prim_irule.doc index e25a07c958..e81e30aead 100644 --- a/help/Docfiles/Tactic.prim_irule.doc +++ b/help/Docfiles/Tactic.prim_irule.doc @@ -10,12 +10,15 @@ replace the goal by the instantiated hypotheses of the supplied theorem. tactic. \DESCRIBE -When given a theorem {A' |- t} and a goal {A ?- t'} where {t} can be matched -to {t'} by instantiating free variables, +When given a theorem {th = A' |- t} and a goal {A ?- t'} +where {t} can be matched to {t'} by instantiating free variables, including appropriate type instantiation, {prim_irule} replaces the goal by new subgoals which are the hypotheses {A'}, instantiated +The order of the new subgoals corresponds to the order in which +{hyp th} returns the hypotheses {A'} + \FAILURE Fails unless the theorem has a conclusion which is instantiable to match that of the goal. diff --git a/help/Docfiles/Tactical.ADD_SGS_TAC.doc b/help/Docfiles/Tactical.ADD_SGS_TAC.doc new file mode 100644 index 0000000000..97b984e95c --- /dev/null +++ b/help/Docfiles/Tactical.ADD_SGS_TAC.doc @@ -0,0 +1,78 @@ +\DOC ADD_SGS_TAC + +\TYPE {ADD_SGS_TAC : term list -> tactic -> tactic} + +\SYNOPSIS +Adds extra sub-goals to the outcome of a tactic, +as may be required to make an invalid tactic valid. + +\DESCRIBE +Suppose {tac} applied to the goal {(asl,w)} produces new goal list {gl}. +Then {ADD_SGS_TAC tml tac (asl,w)} produces, as new goals, +{gl} and, additionally, {(asl,tm)} for each {tm} in {tml}. + +Then, if the justification returned by {tac}, +when applied to the proved goals {gl}, +gives a theorem which uses some additional assumption {tm} in {tml}, +then the proved goal {(asl,tm)} is used to remove {tm} from the assumption list +of that theorem. + +\FAILURE +{ADD_SGS_TAC tml tac (asl,w)} fails if {tac (asl,w)} fails. + +\USES +Where a tactic {tac} requires certain assumptions {tml} +to be present in the goal, +which are not present but are capable of being proved, +{ADD_SGS_TAC tml tac} will conveniently set up new subgoals to prove the missing +assumptions. + +\COMMENTS +{VALIDATE tac} is similar and will usually be easier to use, +but its extra new subgoals may occur in an unpredictable order. + +\EXAMPLE +Given a goal with an implication in the assumptions, +one can split it into two subgoals, defining an auxiliary function +{ +fun split_imp_asm th = + let val (tm, thu) = UNDISCH_TM th ; + in ADD_SGS_TAC [tm] (ASSUME_TAC thu) end ; +} +This can be used as follows: +{ +1 subgoal: +val it = + +r +------------------------------------ + p ==> q +: + proof + +> e (FIRST_X_ASSUM split_imp_asm) ; + +OK.. +2 subgoals: +val it = + +r +------------------------------------ + q + +p + +2 subgoals +: + proof +} + +To propose a term, prove it as a subgoal and then use it to prove +the goal, as is done using {SUBGOAL_THEN tm ASSUME_TAC}, +can also be done by {ADD_SGS_TAC [tm] (ASSUME_TAC (ASSUME tm))} + +\SEEALSO +Tactical.VALIDATE, Tactical.GEN_VALIDATE + +\ENDDOC + diff --git a/help/Docfiles/Tactical.GEN_VALIDATE.doc b/help/Docfiles/Tactical.GEN_VALIDATE.doc index 2bbcdfbc97..b90f31f5c4 100644 --- a/help/Docfiles/Tactical.GEN_VALIDATE.doc +++ b/help/Docfiles/Tactical.GEN_VALIDATE.doc @@ -70,6 +70,6 @@ what the resulting subgoals will be, regardless of what the assumptions of the goal are. \SEEALSO -Tactical.VALID, Tactical.VALIDATE +Tactical.VALID, Tactical.VALIDATE, Tactical.ADD_SGS_TAC \ENDDOC diff --git a/help/Docfiles/Tactical.VALIDATE.doc b/help/Docfiles/Tactical.VALIDATE.doc index 291c2fbbb5..0e1790fe45 100644 --- a/help/Docfiles/Tactical.VALIDATE.doc +++ b/help/Docfiles/Tactical.VALIDATE.doc @@ -98,6 +98,6 @@ assumptions. \SEEALSO proofManagerLib.expand, Tactical.VALID, Tactical.GEN_VALIDATE, -Tactical.SUBGOAL_THEN. +Tactical.ADD_SGS_TAC, Tactical.SUBGOAL_THEN. \ENDDOC diff --git a/help/Docfiles/Thm.INST_TT_HYPS.doc b/help/Docfiles/Thm.INST_TT_HYPS.doc new file mode 100644 index 0000000000..2b786e919f --- /dev/null +++ b/help/Docfiles/Thm.INST_TT_HYPS.doc @@ -0,0 +1,26 @@ +\DOC INST_TT_HYPS + +\BLTYPE +INST_TT_HYPS : +(term,term)subst * (hol_type,hol_type)subst -> thm -> thm * term list +\ELTYPE + +\SYNOPSIS +Instantiates terms and types of a theorem. + +\KEYWORDS +rule, type, instantiate. + +\DESCRIBE +{INST_TT_HYPS} instantiates types and terms in a theorem {thm}, +in the same way {INST_TY_TERM} does. +It also returns a list of the instantiated hypotheses, in the same order +as the uninstantiated hypotheses appear in the list {hyp thm}. + +\FAILURE +{INST_TT_HYPS} fails under the same conditions as {INST_TY_TERM}. + +\SEEALSO +Drule.INST_TY_TERM, Thm.hyp +\ENDDOC + From c7cd8118abc92a3251145858a501434162c43d3f Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Mon, 4 May 2015 13:45:49 +1000 Subject: [PATCH 297/718] INST_TT_HYPS also in other kernels --- src/experimental-kernel/Thm.sml | 22 ++++++++++++++++++++++ src/logging-kernel/Thm.sml | 23 +++++++++++++++++++++++ 2 files changed, 45 insertions(+) diff --git a/src/experimental-kernel/Thm.sml b/src/experimental-kernel/Thm.sml index 3b98368d91..cf3685743c 100644 --- a/src/experimental-kernel/Thm.sml +++ b/src/experimental-kernel/Thm.sml @@ -944,6 +944,28 @@ fun INST [] th = th else raise ERR "INST" "can only instantiate variables" +(*---------------------------------------------------------------------------* + * Instantiate terms and types of a theorem, also returning a list of * + * substituted hypotheses in the same order as in hyp th * + *---------------------------------------------------------------------------*) + +fun INST_TT_HYPS (Stm, Sty) (th as THM (ocl, asl, c)) = + let + val _ = if List.all (is_var o #redex) Stm then () + else raise ERR "INST" "can only instantiate variables" ; + val hyps = HOLset.listItems asl ; + (* instantiate types *) + val hyps_sty = map (inst Sty) hyps ; + val c_sty = inst Sty c ; + (* instantiate terms *) + val hyps_stt = map (subst Stm) hyps_sty ; + val c_stt = subst Stm c_sty ; + (* construct the theorem *) + val seq = (ocl, HOLset.addList (empty_hyp, hyps_stt), c_stt) ; + val THM seq' = make_thm Count.InstType seq ; + val thm = make_thm Count.Inst seq' ; + in (thm, hyps_stt) end ; + (*---------------------------------------------------------------------------* * Now some derived rules optimized for computations, avoiding most * diff --git a/src/logging-kernel/Thm.sml b/src/logging-kernel/Thm.sml index db819b41ad..03674b1780 100644 --- a/src/logging-kernel/Thm.sml +++ b/src/logging-kernel/Thm.sml @@ -991,6 +991,29 @@ fun INST [] th = th else raise ERR "INST" "can only instantiate variables" +(*---------------------------------------------------------------------------* + * Instantiate terms and types of a theorem, also returning a list of * + * substituted hypotheses in the same order as in hyp th * + *---------------------------------------------------------------------------*) + +fun INST_TT_HYPS (Stm, Sty) (th as THM (ocl, asl, c, _)) = + let + val _ = if List.all (is_var o #redex) Stm then () + else raise ERR "INST" "can only instantiate variables" ; + val hyps = HOLset.listItems asl ; + (* instantiate types *) + val hyps_sty = map (inst Sty) hyps ; + val c_sty = inst Sty c ; + val thm_sty = make_thm Count.InstType + (ocl, HOLset.addList (empty_hyp, hyps_sty), c_sty, + INST_TYPE_prf(Sty,th)) ; + (* instantiate terms *) + val hyps_stt = map (subst Stm) hyps_sty ; + val c_stt = subst Stm c_sty ; + val thm_stt = make_thm Count.Inst + (ocl, HOLset.addList (empty_hyp, hyps_stt), c_stt, + INST_prf(Stm,thm_sty)) ; + in (thm_stt, hyps_stt) end ; (*---------------------------------------------------------------------------* * Now some derived rules optimized for computations, avoiding most * From c2427f5ae3a3b0aeba3c9eea69b60fff9d627c6f Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Mon, 4 May 2015 17:18:24 +1000 Subject: [PATCH 298/718] Revert "INST_TT_HYPS also in other kernels" This reverts commit c7cd8118abc92a3251145858a501434162c43d3f. --- src/experimental-kernel/Thm.sml | 22 ---------------------- src/logging-kernel/Thm.sml | 23 ----------------------- 2 files changed, 45 deletions(-) diff --git a/src/experimental-kernel/Thm.sml b/src/experimental-kernel/Thm.sml index cf3685743c..3b98368d91 100644 --- a/src/experimental-kernel/Thm.sml +++ b/src/experimental-kernel/Thm.sml @@ -944,28 +944,6 @@ fun INST [] th = th else raise ERR "INST" "can only instantiate variables" -(*---------------------------------------------------------------------------* - * Instantiate terms and types of a theorem, also returning a list of * - * substituted hypotheses in the same order as in hyp th * - *---------------------------------------------------------------------------*) - -fun INST_TT_HYPS (Stm, Sty) (th as THM (ocl, asl, c)) = - let - val _ = if List.all (is_var o #redex) Stm then () - else raise ERR "INST" "can only instantiate variables" ; - val hyps = HOLset.listItems asl ; - (* instantiate types *) - val hyps_sty = map (inst Sty) hyps ; - val c_sty = inst Sty c ; - (* instantiate terms *) - val hyps_stt = map (subst Stm) hyps_sty ; - val c_stt = subst Stm c_sty ; - (* construct the theorem *) - val seq = (ocl, HOLset.addList (empty_hyp, hyps_stt), c_stt) ; - val THM seq' = make_thm Count.InstType seq ; - val thm = make_thm Count.Inst seq' ; - in (thm, hyps_stt) end ; - (*---------------------------------------------------------------------------* * Now some derived rules optimized for computations, avoiding most * diff --git a/src/logging-kernel/Thm.sml b/src/logging-kernel/Thm.sml index 03674b1780..db819b41ad 100644 --- a/src/logging-kernel/Thm.sml +++ b/src/logging-kernel/Thm.sml @@ -991,29 +991,6 @@ fun INST [] th = th else raise ERR "INST" "can only instantiate variables" -(*---------------------------------------------------------------------------* - * Instantiate terms and types of a theorem, also returning a list of * - * substituted hypotheses in the same order as in hyp th * - *---------------------------------------------------------------------------*) - -fun INST_TT_HYPS (Stm, Sty) (th as THM (ocl, asl, c, _)) = - let - val _ = if List.all (is_var o #redex) Stm then () - else raise ERR "INST" "can only instantiate variables" ; - val hyps = HOLset.listItems asl ; - (* instantiate types *) - val hyps_sty = map (inst Sty) hyps ; - val c_sty = inst Sty c ; - val thm_sty = make_thm Count.InstType - (ocl, HOLset.addList (empty_hyp, hyps_sty), c_sty, - INST_TYPE_prf(Sty,th)) ; - (* instantiate terms *) - val hyps_stt = map (subst Stm) hyps_sty ; - val c_stt = subst Stm c_sty ; - val thm_stt = make_thm Count.Inst - (ocl, HOLset.addList (empty_hyp, hyps_stt), c_stt, - INST_prf(Stm,thm_sty)) ; - in (thm_stt, hyps_stt) end ; (*---------------------------------------------------------------------------* * Now some derived rules optimized for computations, avoiding most * From 8d1dccdd64345c9f72648217dd59e0c81018c1a7 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Mon, 4 May 2015 17:31:48 +1000 Subject: [PATCH 299/718] INST_TT_HYPS in Drule instead of Thm --- src/0/Thm.sml | 22 ---------------------- src/1/Drule.sig | 2 ++ src/1/Drule.sml | 16 ++++++++++++++++ src/prekernel/FinalThm-sig.sml | 2 -- 4 files changed, 18 insertions(+), 24 deletions(-) diff --git a/src/0/Thm.sml b/src/0/Thm.sml index ef4e486a9c..b8fb2c5b1b 100644 --- a/src/0/Thm.sml +++ b/src/0/Thm.sml @@ -955,28 +955,6 @@ fun INST [] th = th else raise ERR "INST" "can only instantiate variables" -(*---------------------------------------------------------------------------* - * Instantiate terms and types of a theorem, also returning a list of * - * substituted hypotheses in the same order as in hyp th * - *---------------------------------------------------------------------------*) - -fun INST_TT_HYPS (Stm, Sty) (th as THM (ocl, asl, c)) = - let - val _ = if List.all (is_var o #redex) Stm then () - else raise ERR "INST" "can only instantiate variables" ; - val hyps = HOLset.listItems asl ; - (* instantiate types *) - val hyps_sty = map (inst Sty) hyps ; - val c_sty = inst Sty c ; - (* instantiate terms *) - val hyps_stt = map (subst Stm) hyps_sty ; - val c_stt = subst Stm c_sty ; - (* construct the theorem *) - val seq = (ocl, HOLset.addList (empty_hyp, hyps_stt), c_stt) ; - val THM seq' = make_thm Count.InstType seq ; - val thm = make_thm Count.Inst seq' ; - in (thm, hyps_stt) end ; - (*---------------------------------------------------------------------------* * Now some derived rules optimized for computations, avoiding most * * of useless type-checking, using pointer equality and delayed * diff --git a/src/1/Drule.sig b/src/1/Drule.sig index 092a7cbde0..0e113fe99c 100644 --- a/src/1/Drule.sig +++ b/src/1/Drule.sig @@ -75,6 +75,8 @@ sig val EXISTS_IMP : term -> thm -> thm val INST_TY_TERM : (term,term)subst * (hol_type,hol_type)subst -> thm -> thm + val INST_TT_HYPS : (term,term)subst * (hol_type,hol_type)subst + -> thm -> thm * term list val GSPEC : thm -> thm val PART_MATCH : (term -> term) -> thm -> term -> thm diff --git a/src/1/Drule.sml b/src/1/Drule.sml index 48ceda82b9..bfbdd0ee0b 100644 --- a/src/1/Drule.sml +++ b/src/1/Drule.sml @@ -1209,6 +1209,22 @@ fun EXISTS_IMP x th = fun INST_TY_TERM (Stm, Sty) th = INST Stm (INST_TYPE Sty th) +(*---------------------------------------------------------------------------* + * Instantiate terms and types of a theorem, also returning a list of * + * substituted hypotheses in the same order as in hyp th * + * (required for predictability of order of new subgoals from (prim_)irule) * + *---------------------------------------------------------------------------*) + +fun INST_TT_HYPS subs th = + let val nhyps = HOLset.numItems (hypset th) ; + val thd = DISCH_ALL th ; + val thdsub = INST_TY_TERM subs thd ; + (* UNDISCH_TM nhyps times only *) + fun UNDISCH_TM_L (th, tms) = + let val (tm, th') = UNDISCH_TM th ; + in (th', tm :: tms) end ; + in Lib.funpow nhyps UNDISCH_TM_L (thdsub, []) end ; + (*---------------------------------------------------------------------------* * |- !x y z. w ---> |- w[g1/x][g2/y][g3/z] * *---------------------------------------------------------------------------*) diff --git a/src/prekernel/FinalThm-sig.sml b/src/prekernel/FinalThm-sig.sml index b0dbdf4f05..898b4a9633 100644 --- a/src/prekernel/FinalThm-sig.sml +++ b/src/prekernel/FinalThm-sig.sml @@ -54,8 +54,6 @@ sig (* Free variable instantiation *) val INST : (term,term)Lib.subst -> thm -> thm - val INST_TT_HYPS : (term,term)Lib.subst * (hol_type,hol_type)Lib.subst -> - thm -> thm * term list (* Universal quantification *) From 5fb6e2b08e41c93479151cb2e64270002c21c9aa Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Tue, 5 May 2015 11:23:46 +1000 Subject: [PATCH 300/718] doc changes re moving INST_TT_HYPS from Thm to Drule --- help/Docfiles/{Thm.INST_TT_HYPS.doc => Drule.INST_TT_HYPS.doc} | 0 help/Docfiles/Drule.INST_TY_TERM.doc | 2 +- 2 files changed, 1 insertion(+), 1 deletion(-) rename help/Docfiles/{Thm.INST_TT_HYPS.doc => Drule.INST_TT_HYPS.doc} (100%) diff --git a/help/Docfiles/Thm.INST_TT_HYPS.doc b/help/Docfiles/Drule.INST_TT_HYPS.doc similarity index 100% rename from help/Docfiles/Thm.INST_TT_HYPS.doc rename to help/Docfiles/Drule.INST_TT_HYPS.doc diff --git a/help/Docfiles/Drule.INST_TY_TERM.doc b/help/Docfiles/Drule.INST_TY_TERM.doc index aaea04861d..b84da3cdeb 100644 --- a/help/Docfiles/Drule.INST_TY_TERM.doc +++ b/help/Docfiles/Drule.INST_TY_TERM.doc @@ -27,5 +27,5 @@ original ones. Use {norm_subst} to achieve this. \SEEALSO Thm.INST, Thm.INST_TYPE, Drule.ISPEC, Thm.SPEC, Drule.SUBS, Thm.SUBST, -Term.norm_subst, Thm.INST_TT_HYPS +Term.norm_subst, Drule.INST_TT_HYPS \ENDDOC From 3ba0a168a6e1263a67ba7af51a71a5a721a951cd Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Wed, 6 May 2015 11:39:36 +0100 Subject: [PATCH 301/718] Update MIPS model and tools. The model now includes an instruction encoder. --- .../mips/decompiler/mips_decompLib.sml | 12 + examples/l3-machine-code/mips/model/mips.sig | 26 +- examples/l3-machine-code/mips/model/mips.sml | 410 ++++---- .../l3-machine-code/mips/model/mipsScript.sml | 896 +++++++++++++++++- .../mips/prog/mips_progLib.sml | 46 +- .../mips/step/mips_stepScript.sml | 10 + 6 files changed, 1160 insertions(+), 240 deletions(-) diff --git a/examples/l3-machine-code/mips/decompiler/mips_decompLib.sml b/examples/l3-machine-code/mips/decompiler/mips_decompLib.sml index 9f7832de33..28b405bac7 100644 --- a/examples/l3-machine-code/mips/decompiler/mips_decompLib.sml +++ b/examples/l3-machine-code/mips/decompiler/mips_decompLib.sml @@ -87,6 +87,18 @@ val test_def = mips_decompile "test" 10200001 00000000` +(* These decompile under the assumption that arithmetic exceptions do not + occur *) +List.map mips.encodeInstruction + [ + "dadd $1, $2, $3", + "dmult $1, $3" + ] + +val test_def = mips_decompile "test" + `0043082C + 0023001C` + *) end diff --git a/examples/l3-machine-code/mips/model/mips.sig b/examples/l3-machine-code/mips/model/mips.sig index a62b79c485..21b7eb7c92 100644 --- a/examples/l3-machine-code/mips/model/mips.sig +++ b/examples/l3-machine-code/mips/model/mips.sig @@ -1,4 +1,4 @@ -(* mips - generated by L<3> - Tue Nov 25 12:48:12 2014 *) +(* mips - generated by L<3> - Wed Apr 08 15:52:11 2015 *) signature mips = sig @@ -710,6 +710,18 @@ val dfn'Unpredictable: unit -> unit val Run: instruction -> unit val Decode: BitsN.nbit -> instruction val Next: unit -> unit +val form1: + (BitsN.nbit * (BitsN.nbit * (BitsN.nbit * (BitsN.nbit * BitsN.nbit)))) -> + BitsN.nbit +val form2: (BitsN.nbit * (BitsN.nbit * BitsN.nbit)) -> BitsN.nbit +val form3: + (BitsN.nbit * (BitsN.nbit * (BitsN.nbit * BitsN.nbit))) -> BitsN.nbit +val form4: + (BitsN.nbit * (BitsN.nbit * (BitsN.nbit * BitsN.nbit))) -> BitsN.nbit +val form5: + (BitsN.nbit * (BitsN.nbit * (BitsN.nbit * BitsN.nbit))) -> BitsN.nbit +val form6: (BitsN.nbit * (BitsN.nbit * BitsN.nbit)) -> BitsN.nbit +val Encode: instruction -> BitsN.nbit val cpr: BitsN.nbit -> string val r: BitsN.nbit -> string val c: BitsN.nbit -> string @@ -727,18 +739,6 @@ val op2roi:Nat.nat-> val opmem:Nat.nat-> (string * (BitsN.nbit * (BitsN.nbit * BitsN.nbit))) -> string val instructionToString: instruction -> string -val form1: - (BitsN.nbit * (BitsN.nbit * (BitsN.nbit * (BitsN.nbit * BitsN.nbit)))) -> - BitsN.nbit -val form2: (BitsN.nbit * (BitsN.nbit * BitsN.nbit)) -> BitsN.nbit -val form3: - (BitsN.nbit * (BitsN.nbit * (BitsN.nbit * BitsN.nbit))) -> BitsN.nbit -val form4: - (BitsN.nbit * (BitsN.nbit * (BitsN.nbit * BitsN.nbit))) -> BitsN.nbit -val form5: - (BitsN.nbit * (BitsN.nbit * (BitsN.nbit * BitsN.nbit))) -> BitsN.nbit -val form6: (BitsN.nbit * (BitsN.nbit * BitsN.nbit)) -> BitsN.nbit -val Encode: instruction -> BitsN.nbit val skipSpaces: string -> string val stripSpaces: string -> string val p_number: string -> (Nat.nat option) diff --git a/examples/l3-machine-code/mips/model/mips.sml b/examples/l3-machine-code/mips/model/mips.sml index 18fa4dc421..ab69e9ede0 100644 --- a/examples/l3-machine-code/mips/model/mips.sml +++ b/examples/l3-machine-code/mips/model/mips.sml @@ -1,4 +1,4 @@ -(* mips - generated by L<3> - Tue Nov 25 12:48:12 2014 *) +(* mips - generated by L<3> - Wed Apr 08 15:52:11 2015 *) structure mips :> mips = struct @@ -9308,210 +9308,6 @@ fun Next () = (CP0_Count_rupd((!CP0),BitsN.+((#Count) (!CP0),BitsN.B(0x1,32)))) ); -fun cpr r = - ("c0_") - ^ - (case r of - BitsN.B(0x0,5) => "index" - | BitsN.B(0x1,5) => "random" - | BitsN.B(0x2,5) => "entrylo0" - | BitsN.B(0x3,5) => "entrylo1" - | BitsN.B(0x4,5) => "context" - | BitsN.B(0x5,5) => "pagemask" - | BitsN.B(0x6,5) => "wired" - | BitsN.B(0x7,5) => "hwrena" - | BitsN.B(0x8,5) => "badvaddr" - | BitsN.B(0x9,5) => "count" - | BitsN.B(0xA,5) => "entryhi" - | BitsN.B(0xB,5) => "compare" - | BitsN.B(0xC,5) => "status" - | BitsN.B(0xD,5) => "cause" - | BitsN.B(0xE,5) => "epc" - | BitsN.B(0xF,5) => "prid" - | BitsN.B(0x10,5) => "config" - | BitsN.B(0x11,5) => "lladdr" - | BitsN.B(0x12,5) => "watchlo" - | BitsN.B(0x13,5) => "watchhi" - | BitsN.B(0x14,5) => "xcontext" - | BitsN.B(0x15,5) => "21" - | BitsN.B(0x16,5) => "22" - | BitsN.B(0x17,5) => "debug" - | BitsN.B(0x18,5) => "depc" - | BitsN.B(0x19,5) => "perfcnt" - | BitsN.B(0x1A,5) => "errctl" - | BitsN.B(0x1B,5) => "cacheerr" - | BitsN.B(0x1C,5) => "taglo" - | BitsN.B(0x1D,5) => "taghi" - | BitsN.B(0x1E,5) => "errorepc" - | BitsN.B(0x1F,5) => "kscratch" - | _ => raise General.Bind); - -fun r n = ("$") ^ (Nat.toString(BitsN.toNat n)); - -fun c n = (", ") ^ (r n); - -fun i N n = - String.concat - [", ",if BitsN.<+(n,BitsN.B(0xA,N)) then "" else "0x", - BitsN.toHexString n]; - -fun oi N n = if n = (BitsN.B(0x0,N)) then "" else i N n; - -fun op1i N (s,n) = - String.concat[L3.padRightString(#" ",(8,s)),"0x",BitsN.toHexString n]; - -fun op1r (s,n) = (L3.padRightString(#" ",(8,s))) ^ (r n); - -fun op1ri N (s,(r1,n)) = (op1r(s,r1)) ^ (i N n); - -fun op2r (s,(r1,r2)) = (op1r(s,r1)) ^ (c r2); - -fun op2ri N (s,(r1,(r2,n))) = (op2r(s,(r1,r2))) ^ (i N n); - -fun op3r (s,(r1,(r2,r3))) = (op2r(s,(r1,r2))) ^ (c r3); - -fun op2roi N (s,(r1,(r2,n))) = - String.concat[op1r(s,r1),", ",cpr r2,oi N n]; - -fun opmem N (s,(r1,(r2,n))) = - String.concat[op1ri N (s,(r1,n)),"(",r r2,")"]; - -fun instructionToString i = - case i of - Shift(SLL(BitsN.B(0x0,5),(BitsN.B(0x0,5),BitsN.B(0x0,5)))) => "nop" - | Shift(SLL(BitsN.B(0x0,5),(BitsN.B(0x0,5),BitsN.B(0x1,5)))) => "ssnop" - | Shift(SLL(rt,(rd,imm5))) => op2ri 5 ("sll",(rd,(rt,imm5))) - | Shift(SRL(rt,(rd,imm5))) => op2ri 5 ("srl",(rd,(rt,imm5))) - | Shift(SRA(rt,(rd,imm5))) => op2ri 5 ("sra",(rd,(rt,imm5))) - | Shift(SLLV(rs,(rt,rd))) => op3r("sllv",(rd,(rt,rs))) - | Shift(SRLV(rs,(rt,rd))) => op3r("srlv",(rd,(rt,rs))) - | Shift(SRAV(rs,(rt,rd))) => op3r("srav",(rd,(rt,rs))) - | Branch(JR rs) => op1r("jr",rs) - | Branch(JALR(rs,rd)) => op2r("jalr",(rd,rs)) - | MultDiv(MFHI rd) => op1r("mfhi",rd) - | MultDiv(MTHI rd) => op1r("mthi",rd) - | MultDiv(MFLO rs) => op1r("mflo",rs) - | MultDiv(MTLO rs) => op1r("mtlo",rs) - | Shift(DSLLV(rs,(rt,rd))) => op3r("dsllv",(rd,(rt,rs))) - | Shift(DSRLV(rs,(rt,rd))) => op3r("dsrlv",(rd,(rt,rs))) - | Shift(DSRAV(rs,(rt,rd))) => op3r("dsrav",(rd,(rt,rs))) - | MultDiv(MADD(rs,rt)) => op2r("madd",(rs,rt)) - | MultDiv(MADDU(rs,rt)) => op2r("maddu",(rs,rt)) - | MultDiv(MSUB(rs,rt)) => op2r("msub",(rs,rt)) - | MultDiv(MSUBU(rs,rt)) => op2r("msubu",(rs,rt)) - | MultDiv(MUL(rs,(rt,rd))) => op3r("mul",(rd,(rs,rt))) - | MultDiv(MULT(rs,rt)) => op2r("mult",(rs,rt)) - | MultDiv(MULTU(rs,rt)) => op2r("multu",(rs,rt)) - | MultDiv(DIV(rs,rt)) => op2r("div",(rs,rt)) - | MultDiv(DIVU(rs,rt)) => op2r("divu",(rs,rt)) - | MultDiv(DMULT(rs,rt)) => op2r("dmult",(rs,rt)) - | MultDiv(DMULTU(rs,rt)) => op2r("dmultu",(rs,rt)) - | MultDiv(DDIV(rs,rt)) => op2r("ddiv",(rs,rt)) - | MultDiv(DDIVU(rs,rt)) => op2r("ddivu",(rs,rt)) - | ArithR(MOVN(rs,(rt,rd))) => op3r("movn",(rd,(rs,rt))) - | ArithR(MOVZ(rs,(rt,rd))) => op3r("movz",(rd,(rs,rt))) - | ArithR(ADD(rs,(rt,rd))) => op3r("add",(rd,(rs,rt))) - | ArithR(ADDU(rs,(rt,rd))) => op3r("addu",(rd,(rs,rt))) - | ArithR(SUB(rs,(rt,rd))) => op3r("sub",(rd,(rs,rt))) - | ArithR(SUBU(rs,(rt,rd))) => op3r("subu",(rd,(rs,rt))) - | ArithR(AND(rs,(rt,rd))) => op3r("and",(rd,(rs,rt))) - | ArithR(OR(rs,(rt,rd))) => op3r("or",(rd,(rs,rt))) - | ArithR(XOR(rs,(rt,rd))) => op3r("xor",(rd,(rs,rt))) - | ArithR(NOR(rs,(rt,rd))) => op3r("nor",(rd,(rs,rt))) - | ArithR(SLT(rs,(rt,rd))) => op3r("slt",(rd,(rs,rt))) - | ArithR(SLTU(rs,(rt,rd))) => op3r("sltu",(rd,(rs,rt))) - | ArithR(DADD(rs,(rt,rd))) => op3r("dadd",(rd,(rs,rt))) - | ArithR(DADDU(rs,(rt,rd))) => op3r("daddu",(rd,(rs,rt))) - | ArithR(DSUB(rs,(rt,rd))) => op3r("dsub",(rd,(rs,rt))) - | ArithR(DSUBU(rs,(rt,rd))) => op3r("dsubu",(rd,(rs,rt))) - | Trap(TGE(rs,rt)) => op2r("tge",(rs,rt)) - | Trap(TGEU(rs,rt)) => op2r("tgeu",(rs,rt)) - | Trap(TLT(rs,rt)) => op2r("tlt",(rs,rt)) - | Trap(TLTU(rs,rt)) => op2r("tltu",(rs,rt)) - | Trap(TEQ(rs,rt)) => op2r("teq",(rs,rt)) - | Trap(TNE(rs,rt)) => op2r("tne",(rs,rt)) - | Shift(DSLL(rt,(rd,imm5))) => op2ri 5 ("dsll",(rd,(rt,imm5))) - | Shift(DSRL(rt,(rd,imm5))) => op2ri 5 ("dsrl",(rd,(rt,imm5))) - | Shift(DSRA(rt,(rd,imm5))) => op2ri 5 ("dsra",(rd,(rt,imm5))) - | Shift(DSLL32(rt,(rd,imm5))) => op2ri 5 ("dsll32",(rd,(rt,imm5))) - | Shift(DSRL32(rt,(rd,imm5))) => op2ri 5 ("dsrl32",(rd,(rt,imm5))) - | Shift(DSRA32(rt,(rd,imm5))) => op2ri 5 ("dsra32",(rd,(rt,imm5))) - | Branch(BLTZ(rs,imm)) => op1ri 16 ("bltz",(rs,imm)) - | Branch(BGEZ(rs,imm)) => op1ri 16 ("bgez",(rs,imm)) - | Branch(BLTZL(rs,imm)) => op1ri 16 ("bltzl",(rs,imm)) - | Branch(BGEZL(rs,imm)) => op1ri 16 ("bgezl",(rs,imm)) - | Trap(TGEI(rs,imm)) => op1ri 16 ("tgei",(rs,imm)) - | Trap(TGEIU(rs,imm)) => op1ri 16 ("tgeiu",(rs,imm)) - | Trap(TLTI(rs,imm)) => op1ri 16 ("tlti",(rs,imm)) - | Trap(TLTIU(rs,imm)) => op1ri 16 ("tltiu",(rs,imm)) - | Trap(TEQI(rs,imm)) => op1ri 16 ("teqi",(rs,imm)) - | Trap(TNEI(rs,imm)) => op1ri 16 ("tnei",(rs,imm)) - | Branch(BLTZAL(rs,imm)) => op1ri 16 ("bltzal",(rs,imm)) - | Branch(BGEZAL(rs,imm)) => op1ri 16 ("bgezal",(rs,imm)) - | Branch(BLTZALL(rs,imm)) => op1ri 16 ("bltzall",(rs,imm)) - | Branch(BGEZALL(rs,imm)) => op1ri 16 ("bgezall",(rs,imm)) - | Branch(J imm) => op1i 26 ("j",imm) - | Branch(JAL imm) => op1i 26 ("jal",imm) - | CP(MFC0(rt,(rd,sel))) => op2roi 3 ("mfc0",(rt,(rd,sel))) - | CP(DMFC0(rt,(rd,sel))) => op2roi 3 ("dmfc0",(rt,(rd,sel))) - | CP(MTC0(rt,(rd,sel))) => op2roi 3 ("mtc0",(rt,(rd,sel))) - | CP(DMTC0(rt,(rd,sel))) => op2roi 3 ("dmtc0",(rt,(rd,sel))) - | Branch(BEQ(BitsN.B(0x0,5),(BitsN.B(0x0,5),imm))) => op1i 16 ("b",imm) - | Branch(BEQ(rs,(rt,imm))) => op2ri 16 ("beq",(rs,(rt,imm))) - | Branch(BNE(rs,(rt,imm))) => op2ri 16 ("bne",(rs,(rt,imm))) - | Branch(BLEZ(rs,imm)) => op1ri 16 ("blez",(rs,imm)) - | Branch(BGTZ(rs,imm)) => op1ri 16 ("bgtz",(rs,imm)) - | ArithI(ADDI(rs,(rt,imm))) => op2ri 16 ("addi",(rt,(rs,imm))) - | ArithI(ADDIU(rs,(rt,imm))) => op2ri 16 ("addiu",(rt,(rs,imm))) - | ArithI(SLTI(rs,(rt,imm))) => op2ri 16 ("slti",(rt,(rs,imm))) - | ArithI(SLTIU(rs,(rt,imm))) => op2ri 16 ("sltiu",(rt,(rs,imm))) - | ArithI(ANDI(rs,(rt,imm))) => op2ri 16 ("andi",(rt,(rs,imm))) - | ArithI(ORI(rs,(rt,imm))) => op2ri 16 ("ori",(rt,(rs,imm))) - | ArithI(XORI(rs,(rt,imm))) => op2ri 16 ("xori",(rt,(rs,imm))) - | ArithI(LUI(rt,imm)) => op1ri 16 ("lui",(rt,imm)) - | Branch(BEQL(rs,(rt,imm))) => op2ri 16 ("beql",(rs,(rt,imm))) - | Branch(BNEL(rs,(rt,imm))) => op2ri 16 ("bnel",(rs,(rt,imm))) - | Branch(BLEZL(rs,imm)) => op1ri 16 ("blezl",(rs,imm)) - | Branch(BGTZL(rs,imm)) => op1ri 16 ("bgtzl",(rs,imm)) - | ArithI(DADDI(rs,(rt,imm))) => op2ri 16 ("daddi",(rt,(rs,imm))) - | ArithI(DADDIU(rs,(rt,imm))) => op2ri 16 ("daddiu",(rt,(rs,imm))) - | Load(LDL(rs,(rt,imm))) => opmem 16 ("ldl",(rt,(rs,imm))) - | Load(LDR(rs,(rt,imm))) => opmem 16 ("ldr",(rt,(rs,imm))) - | Load(LB(rs,(rt,imm))) => opmem 16 ("lb",(rt,(rs,imm))) - | Load(LH(rs,(rt,imm))) => opmem 16 ("lh",(rt,(rs,imm))) - | Load(LWL(rs,(rt,imm))) => opmem 16 ("lwl",(rt,(rs,imm))) - | Load(LW(rs,(rt,imm))) => opmem 16 ("lw",(rt,(rs,imm))) - | Load(LBU(rs,(rt,imm))) => opmem 16 ("lbu",(rt,(rs,imm))) - | Load(LHU(rs,(rt,imm))) => opmem 16 ("lhu",(rt,(rs,imm))) - | Load(LWR(rs,(rt,imm))) => opmem 16 ("lwr",(rt,(rs,imm))) - | Load(LWU(rs,(rt,imm))) => opmem 16 ("lwu",(rt,(rs,imm))) - | Store(SB(rs,(rt,imm))) => opmem 16 ("sb",(rt,(rs,imm))) - | Store(SH(rs,(rt,imm))) => opmem 16 ("sh",(rt,(rs,imm))) - | Store(SWL(rs,(rt,imm))) => opmem 16 ("swl",(rt,(rs,imm))) - | Store(SW(rs,(rt,imm))) => opmem 16 ("sw",(rt,(rs,imm))) - | Store(SDL(rs,(rt,imm))) => opmem 16 ("sdl",(rt,(rs,imm))) - | Store(SDR(rs,(rt,imm))) => opmem 16 ("sdr",(rt,(rs,imm))) - | Store(SWR(rs,(rt,imm))) => opmem 16 ("swr",(rt,(rs,imm))) - | Load(LL(rs,(rt,imm))) => opmem 16 ("ll",(rt,(rs,imm))) - | Load(LLD(rs,(rt,imm))) => opmem 16 ("lld",(rt,(rs,imm))) - | Load(LD(rs,(rt,imm))) => opmem 16 ("ld",(rt,(rs,imm))) - | Store(SC(rs,(rt,imm))) => opmem 16 ("sc",(rt,(rs,imm))) - | Store(SCD(rs,(rt,imm))) => opmem 16 ("scd",(rt,(rs,imm))) - | Store(SD(rs,(rt,imm))) => opmem 16 ("sd",(rt,(rs,imm))) - | CACHE(rs,(opn,imm)) => opmem 16 ("cache",(opn,(rs,imm))) - | SYSCALL => "syscall" - | BREAK => "break" - | SYNC imm5 => ("sync ") ^ (BitsN.toHexString imm5) - | TLBR => "tlbr" - | TLBWI => "tlbwi" - | TLBWR => "tlbwr" - | TLBP => "tlbp" - | ERET => "eret" - | RDHWR(rt,rd) => op2r("rdhwr",(rt,rd)) - | WAIT => "wait" - | Unpredictable => "???" - | ReservedInstruction => "???"; - fun form1 (rs,(rt,(rd,(imm5,function)))) = BitsN.concat[BitsN.B(0x0,6),rs,rt,rd,imm5,function]; @@ -9734,6 +9530,210 @@ fun Encode i = | Unpredictable => BitsN.B(0x7F00000,32) | ReservedInstruction => BitsN.B(0x0,32); +fun cpr r = + ("c0_") + ^ + (case r of + BitsN.B(0x0,5) => "index" + | BitsN.B(0x1,5) => "random" + | BitsN.B(0x2,5) => "entrylo0" + | BitsN.B(0x3,5) => "entrylo1" + | BitsN.B(0x4,5) => "context" + | BitsN.B(0x5,5) => "pagemask" + | BitsN.B(0x6,5) => "wired" + | BitsN.B(0x7,5) => "hwrena" + | BitsN.B(0x8,5) => "badvaddr" + | BitsN.B(0x9,5) => "count" + | BitsN.B(0xA,5) => "entryhi" + | BitsN.B(0xB,5) => "compare" + | BitsN.B(0xC,5) => "status" + | BitsN.B(0xD,5) => "cause" + | BitsN.B(0xE,5) => "epc" + | BitsN.B(0xF,5) => "prid" + | BitsN.B(0x10,5) => "config" + | BitsN.B(0x11,5) => "lladdr" + | BitsN.B(0x12,5) => "watchlo" + | BitsN.B(0x13,5) => "watchhi" + | BitsN.B(0x14,5) => "xcontext" + | BitsN.B(0x15,5) => "21" + | BitsN.B(0x16,5) => "22" + | BitsN.B(0x17,5) => "debug" + | BitsN.B(0x18,5) => "depc" + | BitsN.B(0x19,5) => "perfcnt" + | BitsN.B(0x1A,5) => "errctl" + | BitsN.B(0x1B,5) => "cacheerr" + | BitsN.B(0x1C,5) => "taglo" + | BitsN.B(0x1D,5) => "taghi" + | BitsN.B(0x1E,5) => "errorepc" + | BitsN.B(0x1F,5) => "kscratch" + | _ => raise General.Bind); + +fun r n = ("$") ^ (Nat.toString(BitsN.toNat n)); + +fun c n = (", ") ^ (r n); + +fun i N n = + String.concat + [", ",if BitsN.<+(n,BitsN.B(0xA,N)) then "" else "0x", + BitsN.toHexString n]; + +fun oi N n = if n = (BitsN.B(0x0,N)) then "" else i N n; + +fun op1i N (s,n) = + String.concat[L3.padRightString(#" ",(8,s)),"0x",BitsN.toHexString n]; + +fun op1r (s,n) = (L3.padRightString(#" ",(8,s))) ^ (r n); + +fun op1ri N (s,(r1,n)) = (op1r(s,r1)) ^ (i N n); + +fun op2r (s,(r1,r2)) = (op1r(s,r1)) ^ (c r2); + +fun op2ri N (s,(r1,(r2,n))) = (op2r(s,(r1,r2))) ^ (i N n); + +fun op3r (s,(r1,(r2,r3))) = (op2r(s,(r1,r2))) ^ (c r3); + +fun op2roi N (s,(r1,(r2,n))) = + String.concat[op1r(s,r1),", ",cpr r2,oi N n]; + +fun opmem N (s,(r1,(r2,n))) = + String.concat[op1ri N (s,(r1,n)),"(",r r2,")"]; + +fun instructionToString i = + case i of + Shift(SLL(BitsN.B(0x0,5),(BitsN.B(0x0,5),BitsN.B(0x0,5)))) => "nop" + | Shift(SLL(BitsN.B(0x0,5),(BitsN.B(0x0,5),BitsN.B(0x1,5)))) => "ssnop" + | Shift(SLL(rt,(rd,imm5))) => op2ri 5 ("sll",(rd,(rt,imm5))) + | Shift(SRL(rt,(rd,imm5))) => op2ri 5 ("srl",(rd,(rt,imm5))) + | Shift(SRA(rt,(rd,imm5))) => op2ri 5 ("sra",(rd,(rt,imm5))) + | Shift(SLLV(rs,(rt,rd))) => op3r("sllv",(rd,(rt,rs))) + | Shift(SRLV(rs,(rt,rd))) => op3r("srlv",(rd,(rt,rs))) + | Shift(SRAV(rs,(rt,rd))) => op3r("srav",(rd,(rt,rs))) + | Branch(JR rs) => op1r("jr",rs) + | Branch(JALR(rs,rd)) => op2r("jalr",(rd,rs)) + | MultDiv(MFHI rd) => op1r("mfhi",rd) + | MultDiv(MTHI rd) => op1r("mthi",rd) + | MultDiv(MFLO rs) => op1r("mflo",rs) + | MultDiv(MTLO rs) => op1r("mtlo",rs) + | Shift(DSLLV(rs,(rt,rd))) => op3r("dsllv",(rd,(rt,rs))) + | Shift(DSRLV(rs,(rt,rd))) => op3r("dsrlv",(rd,(rt,rs))) + | Shift(DSRAV(rs,(rt,rd))) => op3r("dsrav",(rd,(rt,rs))) + | MultDiv(MADD(rs,rt)) => op2r("madd",(rs,rt)) + | MultDiv(MADDU(rs,rt)) => op2r("maddu",(rs,rt)) + | MultDiv(MSUB(rs,rt)) => op2r("msub",(rs,rt)) + | MultDiv(MSUBU(rs,rt)) => op2r("msubu",(rs,rt)) + | MultDiv(MUL(rs,(rt,rd))) => op3r("mul",(rd,(rs,rt))) + | MultDiv(MULT(rs,rt)) => op2r("mult",(rs,rt)) + | MultDiv(MULTU(rs,rt)) => op2r("multu",(rs,rt)) + | MultDiv(DIV(rs,rt)) => op2r("div",(rs,rt)) + | MultDiv(DIVU(rs,rt)) => op2r("divu",(rs,rt)) + | MultDiv(DMULT(rs,rt)) => op2r("dmult",(rs,rt)) + | MultDiv(DMULTU(rs,rt)) => op2r("dmultu",(rs,rt)) + | MultDiv(DDIV(rs,rt)) => op2r("ddiv",(rs,rt)) + | MultDiv(DDIVU(rs,rt)) => op2r("ddivu",(rs,rt)) + | ArithR(MOVN(rs,(rt,rd))) => op3r("movn",(rd,(rs,rt))) + | ArithR(MOVZ(rs,(rt,rd))) => op3r("movz",(rd,(rs,rt))) + | ArithR(ADD(rs,(rt,rd))) => op3r("add",(rd,(rs,rt))) + | ArithR(ADDU(rs,(rt,rd))) => op3r("addu",(rd,(rs,rt))) + | ArithR(SUB(rs,(rt,rd))) => op3r("sub",(rd,(rs,rt))) + | ArithR(SUBU(rs,(rt,rd))) => op3r("subu",(rd,(rs,rt))) + | ArithR(AND(rs,(rt,rd))) => op3r("and",(rd,(rs,rt))) + | ArithR(OR(rs,(rt,rd))) => op3r("or",(rd,(rs,rt))) + | ArithR(XOR(rs,(rt,rd))) => op3r("xor",(rd,(rs,rt))) + | ArithR(NOR(rs,(rt,rd))) => op3r("nor",(rd,(rs,rt))) + | ArithR(SLT(rs,(rt,rd))) => op3r("slt",(rd,(rs,rt))) + | ArithR(SLTU(rs,(rt,rd))) => op3r("sltu",(rd,(rs,rt))) + | ArithR(DADD(rs,(rt,rd))) => op3r("dadd",(rd,(rs,rt))) + | ArithR(DADDU(rs,(rt,rd))) => op3r("daddu",(rd,(rs,rt))) + | ArithR(DSUB(rs,(rt,rd))) => op3r("dsub",(rd,(rs,rt))) + | ArithR(DSUBU(rs,(rt,rd))) => op3r("dsubu",(rd,(rs,rt))) + | Trap(TGE(rs,rt)) => op2r("tge",(rs,rt)) + | Trap(TGEU(rs,rt)) => op2r("tgeu",(rs,rt)) + | Trap(TLT(rs,rt)) => op2r("tlt",(rs,rt)) + | Trap(TLTU(rs,rt)) => op2r("tltu",(rs,rt)) + | Trap(TEQ(rs,rt)) => op2r("teq",(rs,rt)) + | Trap(TNE(rs,rt)) => op2r("tne",(rs,rt)) + | Shift(DSLL(rt,(rd,imm5))) => op2ri 5 ("dsll",(rd,(rt,imm5))) + | Shift(DSRL(rt,(rd,imm5))) => op2ri 5 ("dsrl",(rd,(rt,imm5))) + | Shift(DSRA(rt,(rd,imm5))) => op2ri 5 ("dsra",(rd,(rt,imm5))) + | Shift(DSLL32(rt,(rd,imm5))) => op2ri 5 ("dsll32",(rd,(rt,imm5))) + | Shift(DSRL32(rt,(rd,imm5))) => op2ri 5 ("dsrl32",(rd,(rt,imm5))) + | Shift(DSRA32(rt,(rd,imm5))) => op2ri 5 ("dsra32",(rd,(rt,imm5))) + | Branch(BLTZ(rs,imm)) => op1ri 16 ("bltz",(rs,imm)) + | Branch(BGEZ(rs,imm)) => op1ri 16 ("bgez",(rs,imm)) + | Branch(BLTZL(rs,imm)) => op1ri 16 ("bltzl",(rs,imm)) + | Branch(BGEZL(rs,imm)) => op1ri 16 ("bgezl",(rs,imm)) + | Trap(TGEI(rs,imm)) => op1ri 16 ("tgei",(rs,imm)) + | Trap(TGEIU(rs,imm)) => op1ri 16 ("tgeiu",(rs,imm)) + | Trap(TLTI(rs,imm)) => op1ri 16 ("tlti",(rs,imm)) + | Trap(TLTIU(rs,imm)) => op1ri 16 ("tltiu",(rs,imm)) + | Trap(TEQI(rs,imm)) => op1ri 16 ("teqi",(rs,imm)) + | Trap(TNEI(rs,imm)) => op1ri 16 ("tnei",(rs,imm)) + | Branch(BLTZAL(rs,imm)) => op1ri 16 ("bltzal",(rs,imm)) + | Branch(BGEZAL(rs,imm)) => op1ri 16 ("bgezal",(rs,imm)) + | Branch(BLTZALL(rs,imm)) => op1ri 16 ("bltzall",(rs,imm)) + | Branch(BGEZALL(rs,imm)) => op1ri 16 ("bgezall",(rs,imm)) + | Branch(J imm) => op1i 26 ("j",imm) + | Branch(JAL imm) => op1i 26 ("jal",imm) + | CP(MFC0(rt,(rd,sel))) => op2roi 3 ("mfc0",(rt,(rd,sel))) + | CP(DMFC0(rt,(rd,sel))) => op2roi 3 ("dmfc0",(rt,(rd,sel))) + | CP(MTC0(rt,(rd,sel))) => op2roi 3 ("mtc0",(rt,(rd,sel))) + | CP(DMTC0(rt,(rd,sel))) => op2roi 3 ("dmtc0",(rt,(rd,sel))) + | Branch(BEQ(BitsN.B(0x0,5),(BitsN.B(0x0,5),imm))) => op1i 16 ("b",imm) + | Branch(BEQ(rs,(rt,imm))) => op2ri 16 ("beq",(rs,(rt,imm))) + | Branch(BNE(rs,(rt,imm))) => op2ri 16 ("bne",(rs,(rt,imm))) + | Branch(BLEZ(rs,imm)) => op1ri 16 ("blez",(rs,imm)) + | Branch(BGTZ(rs,imm)) => op1ri 16 ("bgtz",(rs,imm)) + | ArithI(ADDI(rs,(rt,imm))) => op2ri 16 ("addi",(rt,(rs,imm))) + | ArithI(ADDIU(rs,(rt,imm))) => op2ri 16 ("addiu",(rt,(rs,imm))) + | ArithI(SLTI(rs,(rt,imm))) => op2ri 16 ("slti",(rt,(rs,imm))) + | ArithI(SLTIU(rs,(rt,imm))) => op2ri 16 ("sltiu",(rt,(rs,imm))) + | ArithI(ANDI(rs,(rt,imm))) => op2ri 16 ("andi",(rt,(rs,imm))) + | ArithI(ORI(rs,(rt,imm))) => op2ri 16 ("ori",(rt,(rs,imm))) + | ArithI(XORI(rs,(rt,imm))) => op2ri 16 ("xori",(rt,(rs,imm))) + | ArithI(LUI(rt,imm)) => op1ri 16 ("lui",(rt,imm)) + | Branch(BEQL(rs,(rt,imm))) => op2ri 16 ("beql",(rs,(rt,imm))) + | Branch(BNEL(rs,(rt,imm))) => op2ri 16 ("bnel",(rs,(rt,imm))) + | Branch(BLEZL(rs,imm)) => op1ri 16 ("blezl",(rs,imm)) + | Branch(BGTZL(rs,imm)) => op1ri 16 ("bgtzl",(rs,imm)) + | ArithI(DADDI(rs,(rt,imm))) => op2ri 16 ("daddi",(rt,(rs,imm))) + | ArithI(DADDIU(rs,(rt,imm))) => op2ri 16 ("daddiu",(rt,(rs,imm))) + | Load(LDL(rs,(rt,imm))) => opmem 16 ("ldl",(rt,(rs,imm))) + | Load(LDR(rs,(rt,imm))) => opmem 16 ("ldr",(rt,(rs,imm))) + | Load(LB(rs,(rt,imm))) => opmem 16 ("lb",(rt,(rs,imm))) + | Load(LH(rs,(rt,imm))) => opmem 16 ("lh",(rt,(rs,imm))) + | Load(LWL(rs,(rt,imm))) => opmem 16 ("lwl",(rt,(rs,imm))) + | Load(LW(rs,(rt,imm))) => opmem 16 ("lw",(rt,(rs,imm))) + | Load(LBU(rs,(rt,imm))) => opmem 16 ("lbu",(rt,(rs,imm))) + | Load(LHU(rs,(rt,imm))) => opmem 16 ("lhu",(rt,(rs,imm))) + | Load(LWR(rs,(rt,imm))) => opmem 16 ("lwr",(rt,(rs,imm))) + | Load(LWU(rs,(rt,imm))) => opmem 16 ("lwu",(rt,(rs,imm))) + | Store(SB(rs,(rt,imm))) => opmem 16 ("sb",(rt,(rs,imm))) + | Store(SH(rs,(rt,imm))) => opmem 16 ("sh",(rt,(rs,imm))) + | Store(SWL(rs,(rt,imm))) => opmem 16 ("swl",(rt,(rs,imm))) + | Store(SW(rs,(rt,imm))) => opmem 16 ("sw",(rt,(rs,imm))) + | Store(SDL(rs,(rt,imm))) => opmem 16 ("sdl",(rt,(rs,imm))) + | Store(SDR(rs,(rt,imm))) => opmem 16 ("sdr",(rt,(rs,imm))) + | Store(SWR(rs,(rt,imm))) => opmem 16 ("swr",(rt,(rs,imm))) + | Load(LL(rs,(rt,imm))) => opmem 16 ("ll",(rt,(rs,imm))) + | Load(LLD(rs,(rt,imm))) => opmem 16 ("lld",(rt,(rs,imm))) + | Load(LD(rs,(rt,imm))) => opmem 16 ("ld",(rt,(rs,imm))) + | Store(SC(rs,(rt,imm))) => opmem 16 ("sc",(rt,(rs,imm))) + | Store(SCD(rs,(rt,imm))) => opmem 16 ("scd",(rt,(rs,imm))) + | Store(SD(rs,(rt,imm))) => opmem 16 ("sd",(rt,(rs,imm))) + | CACHE(rs,(opn,imm)) => opmem 16 ("cache",(opn,(rs,imm))) + | SYSCALL => "syscall" + | BREAK => "break" + | SYNC imm5 => ("sync ") ^ (BitsN.toHexString imm5) + | TLBR => "tlbr" + | TLBWI => "tlbwi" + | TLBWR => "tlbwr" + | TLBP => "tlbp" + | ERET => "eret" + | RDHWR(rt,rd) => op2r("rdhwr",(rt,rd)) + | WAIT => "wait" + | Unpredictable => "???" + | ReservedInstruction => "???"; + fun skipSpaces s = L3.snd(L3.splitl(fn c => Char.isSpace c,s)); fun stripSpaces s = diff --git a/examples/l3-machine-code/mips/model/mipsScript.sml b/examples/l3-machine-code/mips/model/mipsScript.sml index 6f15881594..6637e764c6 100644 --- a/examples/l3-machine-code/mips/model/mipsScript.sml +++ b/examples/l3-machine-code/mips/model/mipsScript.sml @@ -1,4 +1,4 @@ -(* mipsScript.sml - generated by L<3> - Thu Oct 30 16:32:12 2014 *) +(* mipsScript.sml - generated by L<3> - Wed Apr 08 15:50:42 2015 *) open HolKernel boolLib bossLib Import val () = Import.start "mips" @@ -11565,5 +11565,899 @@ val Next_def = Def ("Count",F32, Dest("CP0",CTy"CP0",qVar"s")), LW(1,32))])])])))) +; +val form1_def = Def + ("form1", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5), + Var("function",FTy 6)], + CC[LW(0,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5), + Var("imm5",FTy 5),Var("function",FTy 6)]) +; +val form2_def = Def + ("form2",TP[Var("rs",FTy 5),Var("function",FTy 5),Var("imm",F16)], + CC[LW(1,6),Var("rs",FTy 5),Var("function",FTy 5),Var("imm",F16)]) +; +val form3_def = Def + ("form3", + TP[Var("function",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5), + Var("sel",FTy 3)], + CC[LW(16,6),Var("function",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5), + LW(0,8),Var("sel",FTy 3)]) +; +val form4_def = Def + ("form4", + TP[Var("function",FTy 6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)], + CC[Var("function",FTy 6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)]) +; +val form5_def = Def + ("form5", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5), + Var("function",FTy 6)], + CC[LW(28,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + Var("function",FTy 6)]) +; +val form6_def = Def + ("form6",TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("function",FTy 6)], + CC[LW(31,6),LW(0,5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + Var("function",FTy 6)]) +; +val Encode_def = Def + ("Encode",Var("i",CTy"instruction"), + CS(Var("i",CTy"instruction"), + [(Call + ("Shift",CTy"instruction", + Call + ("SLL",CTy"Shift", + TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5)])), + Call + ("form1",F32, + TP[LW(0,5),Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5), + LW(0,6)])), + (Call + ("Shift",CTy"instruction", + Call + ("SRL",CTy"Shift", + TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5)])), + Call + ("form1",F32, + TP[LW(0,5),Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5), + LW(2,6)])), + (Call + ("Shift",CTy"instruction", + Call + ("SRA",CTy"Shift", + TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5)])), + Call + ("form1",F32, + TP[LW(0,5),Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5), + LW(3,6)])), + (Call + ("Shift",CTy"instruction", + Call + ("SLLV",CTy"Shift", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + LW(4,6)])), + (Call + ("Shift",CTy"instruction", + Call + ("SRLV",CTy"Shift", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + LW(6,6)])), + (Call + ("Shift",CTy"instruction", + Call + ("SRAV",CTy"Shift", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + LW(7,6)])), + (Call + ("Branch",CTy"instruction", + Call("JR",CTy"Branch",Var("rs",FTy 5))), + Call + ("form1",F32,TP[Var("rs",FTy 5),LW(0,5),LW(0,5),LW(0,5),LW(8,6)])), + (Call + ("Branch",CTy"instruction", + Call("JALR",CTy"Branch",TP[Var("rs",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),LW(0,5),Var("rd",FTy 5),LW(0,5),LW(9,6)])), + (Call + ("MultDiv",CTy"instruction", + Call("MFHI",CTy"MultDiv",Var("rd",FTy 5))), + Call + ("form1",F32, + TP[LW(0,5),LW(0,5),Var("rd",FTy 5),LW(0,5),LW(16,6)])), + (Call + ("MultDiv",CTy"instruction", + Call("MTHI",CTy"MultDiv",Var("rs",FTy 5))), + Call + ("form1",F32, + TP[Var("rs",FTy 5),LW(0,5),LW(0,5),LW(0,5),LW(17,6)])), + (Call + ("MultDiv",CTy"instruction", + Call("MFLO",CTy"MultDiv",Var("rd",FTy 5))), + Call + ("form1",F32, + TP[LW(0,5),LW(0,5),Var("rd",FTy 5),LW(0,5),LW(18,6)])), + (Call + ("MultDiv",CTy"instruction", + Call("MTLO",CTy"MultDiv",Var("rs",FTy 5))), + Call + ("form1",F32, + TP[Var("rs",FTy 5),LW(0,5),LW(0,5),LW(0,5),LW(19,6)])), + (Call + ("Shift",CTy"instruction", + Call + ("DSLLV",CTy"Shift", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + LW(20,6)])), + (Call + ("Shift",CTy"instruction", + Call + ("DSRLV",CTy"Shift", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + LW(22,6)])), + (Call + ("Shift",CTy"instruction", + Call + ("DSRAV",CTy"Shift", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + LW(23,6)])), + (Call + ("MultDiv",CTy"instruction", + Call("MADD",CTy"MultDiv",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call + ("form5",F32,TP[Var("rs",FTy 5),Var("rt",FTy 5),LW(0,5),LW(0,6)])), + (Call + ("MultDiv",CTy"instruction", + Call("MADDU",CTy"MultDiv",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call + ("form5",F32,TP[Var("rs",FTy 5),Var("rt",FTy 5),LW(0,5),LW(1,6)])), + (Call + ("MultDiv",CTy"instruction", + Call("MSUB",CTy"MultDiv",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call + ("form5",F32,TP[Var("rs",FTy 5),Var("rt",FTy 5),LW(0,5),LW(4,6)])), + (Call + ("MultDiv",CTy"instruction", + Call("MSUBU",CTy"MultDiv",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call + ("form5",F32,TP[Var("rs",FTy 5),Var("rt",FTy 5),LW(0,5),LW(5,6)])), + (Call + ("MultDiv",CTy"instruction", + Call + ("MUL",CTy"MultDiv", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form5",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(2,6)])), + (Call + ("MultDiv",CTy"instruction", + Call("MULT",CTy"MultDiv",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),LW(0,5),LW(0,5),LW(24,6)])), + (Call + ("MultDiv",CTy"instruction", + Call("MULTU",CTy"MultDiv",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),LW(0,5),LW(0,5),LW(25,6)])), + (Call + ("MultDiv",CTy"instruction", + Call("DIV",CTy"MultDiv",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),LW(0,5),LW(0,5),LW(26,6)])), + (Call + ("MultDiv",CTy"instruction", + Call("DIVU",CTy"MultDiv",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),LW(0,5),LW(0,5),LW(27,6)])), + (Call + ("MultDiv",CTy"instruction", + Call("DMULT",CTy"MultDiv",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),LW(0,5),LW(0,5),LW(28,6)])), + (Call + ("MultDiv",CTy"instruction", + Call("DMULTU",CTy"MultDiv",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),LW(0,5),LW(0,5),LW(29,6)])), + (Call + ("MultDiv",CTy"instruction", + Call("DDIV",CTy"MultDiv",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),LW(0,5),LW(0,5),LW(30,6)])), + (Call + ("MultDiv",CTy"instruction", + Call("DDIVU",CTy"MultDiv",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),LW(0,5),LW(0,5),LW(31,6)])), + (Call + ("ArithR",CTy"instruction", + Call + ("MOVZ",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + LW(10,6)])), + (Call + ("ArithR",CTy"instruction", + Call + ("MOVN",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + LW(11,6)])), + (Call + ("ArithR",CTy"instruction", + Call + ("ADD",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + LW(32,6)])), + (Call + ("ArithR",CTy"instruction", + Call + ("ADDU",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + LW(33,6)])), + (Call + ("ArithR",CTy"instruction", + Call + ("SUB",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + LW(34,6)])), + (Call + ("ArithR",CTy"instruction", + Call + ("SUBU",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + LW(35,6)])), + (Call + ("ArithR",CTy"instruction", + Call + ("AND",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + LW(36,6)])), + (Call + ("ArithR",CTy"instruction", + Call + ("OR",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + LW(37,6)])), + (Call + ("ArithR",CTy"instruction", + Call + ("XOR",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + LW(38,6)])), + (Call + ("ArithR",CTy"instruction", + Call + ("NOR",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + LW(39,6)])), + (Call + ("ArithR",CTy"instruction", + Call + ("SLT",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + LW(42,6)])), + (Call + ("ArithR",CTy"instruction", + Call + ("SLTU",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + LW(43,6)])), + (Call + ("ArithR",CTy"instruction", + Call + ("DADD",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + LW(44,6)])), + (Call + ("ArithR",CTy"instruction", + Call + ("DADDU",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + LW(45,6)])), + (Call + ("ArithR",CTy"instruction", + Call + ("DSUB",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + LW(46,6)])), + (Call + ("ArithR",CTy"instruction", + Call + ("DSUBU",CTy"ArithR", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("rd",FTy 5),LW(0,5), + LW(47,6)])), + (Call + ("Trap",CTy"instruction", + Call("TGE",CTy"Trap",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),LW(0,5),LW(0,5),LW(48,6)])), + (Call + ("Trap",CTy"instruction", + Call("TGEU",CTy"Trap",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),LW(0,5),LW(0,5),LW(49,6)])), + (Call + ("Trap",CTy"instruction", + Call("TLT",CTy"Trap",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),LW(0,5),LW(0,5),LW(50,6)])), + (Call + ("Trap",CTy"instruction", + Call("TLTU",CTy"Trap",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),LW(0,5),LW(0,5),LW(51,6)])), + (Call + ("Trap",CTy"instruction", + Call("TEQ",CTy"Trap",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),LW(0,5),LW(0,5),LW(52,6)])), + (Call + ("Trap",CTy"instruction", + Call("TNE",CTy"Trap",TP[Var("rs",FTy 5),Var("rt",FTy 5)])), + Call + ("form1",F32, + TP[Var("rs",FTy 5),Var("rt",FTy 5),LW(0,5),LW(0,5),LW(54,6)])), + (Call + ("Shift",CTy"instruction", + Call + ("DSLL",CTy"Shift", + TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5)])), + Call + ("form1",F32, + TP[LW(0,5),Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5), + LW(56,6)])), + (Call + ("Shift",CTy"instruction", + Call + ("DSRL",CTy"Shift", + TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5)])), + Call + ("form1",F32, + TP[LW(0,5),Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5), + LW(58,6)])), + (Call + ("Shift",CTy"instruction", + Call + ("DSRA",CTy"Shift", + TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5)])), + Call + ("form1",F32, + TP[LW(0,5),Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5), + LW(59,6)])), + (Call + ("Shift",CTy"instruction", + Call + ("DSLL32",CTy"Shift", + TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5)])), + Call + ("form1",F32, + TP[LW(0,5),Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5), + LW(60,6)])), + (Call + ("Shift",CTy"instruction", + Call + ("DSRL32",CTy"Shift", + TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5)])), + Call + ("form1",F32, + TP[LW(0,5),Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5), + LW(62,6)])), + (Call + ("Shift",CTy"instruction", + Call + ("DSRA32",CTy"Shift", + TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5)])), + Call + ("form1",F32, + TP[LW(0,5),Var("rt",FTy 5),Var("rd",FTy 5),Var("imm5",FTy 5), + LW(63,6)])), + (Call + ("Branch",CTy"instruction", + Call("BLTZ",CTy"Branch",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("form2",F32,TP[Var("rs",FTy 5),LW(0,5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call("BGEZ",CTy"Branch",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("form2",F32,TP[Var("rs",FTy 5),LW(1,5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call("BLTZL",CTy"Branch",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("form2",F32,TP[Var("rs",FTy 5),LW(2,5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call("BGEZL",CTy"Branch",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("form2",F32,TP[Var("rs",FTy 5),LW(3,5),Var("imm",F16)])), + (Call + ("Trap",CTy"instruction", + Call("TGEI",CTy"Trap",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("form2",F32,TP[Var("rs",FTy 5),LW(8,5),Var("imm",F16)])), + (Call + ("Trap",CTy"instruction", + Call("TGEIU",CTy"Trap",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("form2",F32,TP[Var("rs",FTy 5),LW(9,5),Var("imm",F16)])), + (Call + ("Trap",CTy"instruction", + Call("TLTI",CTy"Trap",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("form2",F32,TP[Var("rs",FTy 5),LW(10,5),Var("imm",F16)])), + (Call + ("Trap",CTy"instruction", + Call("TLTIU",CTy"Trap",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("form2",F32,TP[Var("rs",FTy 5),LW(11,5),Var("imm",F16)])), + (Call + ("Trap",CTy"instruction", + Call("TEQI",CTy"Trap",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("form2",F32,TP[Var("rs",FTy 5),LW(12,5),Var("imm",F16)])), + (Call + ("Trap",CTy"instruction", + Call("TNEI",CTy"Trap",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("form2",F32,TP[Var("rs",FTy 5),LW(14,5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call("BLTZAL",CTy"Branch",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("form2",F32,TP[Var("rs",FTy 5),LW(16,5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call("BGEZAL",CTy"Branch",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("form2",F32,TP[Var("rs",FTy 5),LW(17,5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call("BLTZALL",CTy"Branch",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("form2",F32,TP[Var("rs",FTy 5),LW(18,5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call("BGEZALL",CTy"Branch",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call("form2",F32,TP[Var("rs",FTy 5),LW(19,5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call("J",CTy"Branch",Var("imm",FTy 26))), + CC[LW(2,6),Var("imm",FTy 26)]), + (Call + ("Branch",CTy"instruction", + Call("JAL",CTy"Branch",Var("imm",FTy 26))), + CC[LW(3,6),Var("imm",FTy 26)]), + (Call + ("CP",CTy"instruction", + Call + ("MFC0",CTy"CP", + TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("sel",FTy 3)])), + Call + ("form3",F32, + TP[LW(0,5),Var("rt",FTy 5),Var("rd",FTy 5),Var("sel",FTy 3)])), + (Call + ("CP",CTy"instruction", + Call + ("DMFC0",CTy"CP", + TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("sel",FTy 3)])), + Call + ("form3",F32, + TP[LW(1,5),Var("rt",FTy 5),Var("rd",FTy 5),Var("sel",FTy 3)])), + (Call + ("CP",CTy"instruction", + Call + ("MTC0",CTy"CP", + TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("sel",FTy 3)])), + Call + ("form3",F32, + TP[LW(4,5),Var("rt",FTy 5),Var("rd",FTy 5),Var("sel",FTy 3)])), + (Call + ("CP",CTy"instruction", + Call + ("DMTC0",CTy"CP", + TP[Var("rt",FTy 5),Var("rd",FTy 5),Var("sel",FTy 3)])), + Call + ("form3",F32, + TP[LW(5,5),Var("rt",FTy 5),Var("rd",FTy 5),Var("sel",FTy 3)])), + (Call + ("Branch",CTy"instruction", + Call + ("BEQ",CTy"Branch", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(4,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call + ("BNE",CTy"Branch", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(5,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call("BLEZ",CTy"Branch",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call + ("form4",F32,TP[LW(6,6),Var("rs",FTy 5),LW(0,5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call("BGTZ",CTy"Branch",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call + ("form4",F32,TP[LW(7,6),Var("rs",FTy 5),LW(0,5),Var("imm",F16)])), + (Call + ("ArithI",CTy"instruction", + Call + ("ADDI",CTy"ArithI", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(8,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("ArithI",CTy"instruction", + Call + ("ADDIU",CTy"ArithI", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(9,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("ArithI",CTy"instruction", + Call + ("SLTI",CTy"ArithI", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(10,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("ArithI",CTy"instruction", + Call + ("SLTIU",CTy"ArithI", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(11,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("ArithI",CTy"instruction", + Call + ("ANDI",CTy"ArithI", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(12,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("ArithI",CTy"instruction", + Call + ("ORI",CTy"ArithI", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(13,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("ArithI",CTy"instruction", + Call + ("XORI",CTy"ArithI", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(14,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("ArithI",CTy"instruction", + Call("LUI",CTy"ArithI",TP[Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32,TP[LW(15,6),LW(0,5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call + ("BEQL",CTy"Branch", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(20,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call + ("BNEL",CTy"Branch", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(21,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call("BLEZL",CTy"Branch",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call + ("form4",F32,TP[LW(22,6),Var("rs",FTy 5),LW(0,5),Var("imm",F16)])), + (Call + ("Branch",CTy"instruction", + Call("BGTZL",CTy"Branch",TP[Var("rs",FTy 5),Var("imm",F16)])), + Call + ("form4",F32,TP[LW(23,6),Var("rs",FTy 5),LW(0,5),Var("imm",F16)])), + (Call + ("ArithI",CTy"instruction", + Call + ("DADDI",CTy"ArithI", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(24,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("ArithI",CTy"instruction", + Call + ("DADDIU",CTy"ArithI", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(25,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Load",CTy"instruction", + Call + ("LDL",CTy"Load", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(26,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Load",CTy"instruction", + Call + ("LDR",CTy"Load", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(27,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Load",CTy"instruction", + Call + ("LB",CTy"Load", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(32,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Load",CTy"instruction", + Call + ("LH",CTy"Load", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(33,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Load",CTy"instruction", + Call + ("LWL",CTy"Load", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(34,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Load",CTy"instruction", + Call + ("LW",CTy"Load", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(35,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Load",CTy"instruction", + Call + ("LBU",CTy"Load", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(36,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Load",CTy"instruction", + Call + ("LHU",CTy"Load", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(37,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Load",CTy"instruction", + Call + ("LWR",CTy"Load", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(38,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Load",CTy"instruction", + Call + ("LWU",CTy"Load", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(39,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Store",CTy"instruction", + Call + ("SB",CTy"Store", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(40,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Store",CTy"instruction", + Call + ("SH",CTy"Store", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(41,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Store",CTy"instruction", + Call + ("SWL",CTy"Store", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(42,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Store",CTy"instruction", + Call + ("SW",CTy"Store", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(43,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Store",CTy"instruction", + Call + ("SDL",CTy"Store", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(44,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Store",CTy"instruction", + Call + ("SDR",CTy"Store", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(45,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Store",CTy"instruction", + Call + ("SWR",CTy"Store", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(46,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Load",CTy"instruction", + Call + ("LL",CTy"Load", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(48,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Load",CTy"instruction", + Call + ("LLD",CTy"Load", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(52,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Load",CTy"instruction", + Call + ("LD",CTy"Load", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(55,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Store",CTy"instruction", + Call + ("SC",CTy"Store", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(56,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Store",CTy"instruction", + Call + ("SCD",CTy"Store", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(60,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("Store",CTy"instruction", + Call + ("SD",CTy"Store", + TP[Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + Call + ("form4",F32, + TP[LW(63,6),Var("rs",FTy 5),Var("rt",FTy 5),Var("imm",F16)])), + (Call + ("CACHE",CTy"instruction", + TP[Var("rs",FTy 5),Var("opn",FTy 5),Var("imm",F16)]), + Call + ("form4",F32, + TP[LW(47,6),Var("rs",FTy 5),Var("opn",FTy 5),Var("imm",F16)])), + (Const("SYSCALL",CTy"instruction"),Mop(Cast F32,LW(12,6))), + (Const("BREAK",CTy"instruction"),Mop(Cast F32,LW(13,6))), + (Call("SYNC",CTy"instruction",Var("imm5",FTy 5)), + Mop(Cast F32,CC[Var("imm5",FTy 5),LW(15,6)])), + (Const("TLBR",CTy"instruction"),LW(1107296257,32)), + (Const("TLBWI",CTy"instruction"),LW(1107296258,32)), + (Const("TLBWR",CTy"instruction"),LW(1107296262,32)), + (Const("TLBP",CTy"instruction"),LW(1107296264,32)), + (Const("ERET",CTy"instruction"),LW(1107296280,32)), + (Call("RDHWR",CTy"instruction",TP[Var("rt",FTy 5),Var("rd",FTy 5)]), + Call("form6",F32,TP[Var("rt",FTy 5),Var("rd",FTy 5),LW(59,6)])), + (Const("WAIT",CTy"instruction"),LW(1107296288,32)), + (Const("Unpredictable",CTy"instruction"),LW(133169152,32)), + (Const("ReservedInstruction",CTy"instruction"),LW(0,32))])) val () = Import.finish 1 \ No newline at end of file diff --git a/examples/l3-machine-code/mips/prog/mips_progLib.sml b/examples/l3-machine-code/mips/prog/mips_progLib.sml index 831512ebca..5d53b245b2 100644 --- a/examples/l3-machine-code/mips/prog/mips_progLib.sml +++ b/examples/l3-machine-code/mips/prog/mips_progLib.sml @@ -29,7 +29,7 @@ val word = wordsSyntax.mk_int_word_type 32 val dword = wordsSyntax.mk_int_word_type 64 val (_, _, dest_BranchTo, _) = mips_1 "mips_BranchTo" val (_, _, dest_BranchDelay, _) = mips_1 "mips_BranchDelay" -val (_, mk_mips_PC, _, _) = mips_1 "mips_PC" +val (_, mk_mips_PC, dest_mips_PC, _) = mips_1 "mips_PC" val (_, mk_mips_MEM, dest_mips_MEM, is_mips_MEM) = mips_2 "mips_MEM" val (_, mk_mips_gpr, dest_mips_gpr, is_mips_gpr) = mips_2 "mips_gpr" val st = Term.mk_var ("s", ``:mips_state``) @@ -88,6 +88,7 @@ val state_id = ["CP0", "PC", "exceptionSignalled", "gpr"], ["CP0", "PC", "exceptionSignalled"], ["CP0", "PC", "exceptionSignalled", "hi", "lo"], + ["CP0", "PC", "exceptionSignalled", "gpr", "hi", "lo"], ["CP0", "LLbit", "PC"], ["CP0", "LLbit", "PC", "exceptionSignalled"], ["CP0", "LLbit", "PC", "exceptionSignalled", "gpr"], @@ -310,6 +311,7 @@ local else raise ERR "COND_CONV" "") val POST_CONV = Conv.RAND_CONV val POOL_CONV = Conv.RATOR_CONV o Conv.RAND_CONV + val OPT_CONV = REWRITE_CONV [optionTheory.IS_SOME_DEF] val OPC_CONV = POOL_CONV o Conv.RATOR_CONV o Conv.RAND_CONV o Conv.RAND_CONV exception FalseTerm fun NOT_F_CONV tm = @@ -330,7 +332,7 @@ local THENC PRE_COND_CONV THENC PRE_CONV WGROUND_RW_CONV THENC OPC_CONV bitstringLib.v2w_n2w_CONV - THENC POST_CONV WGROUND_RW_CONV + THENC POST_CONV (WGROUND_RW_CONV THENC OPT_CONV) in fun simp_triple_rule thm = mips_rename (Conv.CONV_RULE cnv thm) @@ -498,12 +500,6 @@ in end end -(* -val l = (List.concat thm_ts) -val x as (thm, t) = List.nth (l, 0) -spec x -*) - local val get_opcode = fst o bitstringSyntax.dest_v2w o @@ -511,7 +507,7 @@ local hd o pred_setSyntax.strip_set o temporal_stateSyntax.dest_code' o Thm.concl - val the_spec = ref (mips_spec_opt false) + val the_spec = ref (mips_spec_opt true) val spec_label_set = ref (Redblackset.empty String.compare) val init_net = utilsLib.mk_rw_net (fn _ => raise ERR "" "") [] val spec_rwts = ref init_net @@ -532,7 +528,7 @@ local in listSyntax.mk_list (utilsLib.rev_endian l, ty) end - val rev_endian = ref (Lib.I: term -> term) + val rev_endian = ref reverse_endian in fun mips_config be = ( the_spec := mips_spec_opt be @@ -586,7 +582,11 @@ local in val mips_pc_intro_rule = Conv.CONV_RULE - (Conv.LAND_CONV (REWRITE_CONV [mips_stepTheory.Aligned_numeric]) + (Conv.LAND_CONV + (REWRITE_CONV [mips_stepTheory.Aligned_numeric] + (* mips_stepTheory.Aligned_cond] + THENC utilsLib.WGROUND_CONV + THENC REWRITE_CONV [boolTheory.EXCLUDED_MIDDLE] *)) THENC (Conv.REWR_CONV (Thm.CONJUNCT1 (Drule.SPEC_ALL boolTheory.IMP_CLAUSES)) ORELSEC MOVE_COND_CONV) @@ -607,13 +607,15 @@ in end local - val rule = + val move_cond = GSYM progTheory.SPEC_MOVE_COND + val move_precond = REWRITE_RULE [GSYM set_sepTheory.precond_def] move_cond + fun rule pre = Conv.CONV_RULE (Conv.REWR_CONV - (GSYM (REWRITE_RULE [GSYM set_sepTheory.precond_def] - progTheory.SPEC_MOVE_COND))) o Lib.uncurry Thm.DISCH - fun spec_cases b th = + (if pre then move_precond else move_cond)) o Lib.uncurry Thm.DISCH + fun spec_cases pre b th = let + val r = (if pre then Lib.I else helperLib.MERGE_CONDS_RULE) o rule pre val nb = boolSyntax.mk_neg b val pt = Drule.EQT_INTRO (Thm.ASSUME b) val nt = Drule.EQF_INTRO (Thm.ASSUME nb) @@ -621,19 +623,21 @@ local val _ = Thm.hyp pth = [b] orelse raise ERR "spec_cases" "" val nth = PURE_REWRITE_RULE [nt, boolTheory.COND_CLAUSES] th in - [rule (b, pth), rule (nb, nth)] + [r (b, pth), r (nb, nth)] end -in - fun split_BranchDelay th = + fun split pre f th = let val p = progSyntax.strip_star (progSyntax.dest_post (Thm.concl th)) in - case List.mapPartial (Lib.total dest_BranchDelay) p of + case List.mapPartial (Lib.total f) p of [t] => (case Lib.total boolSyntax.dest_cond t of - SOME (b, _, _) => spec_cases b th + SOME (b, _, _) => spec_cases pre b th | NONE => [th]) | _ => [th] end +in + val split_BranchDelay = split true dest_BranchDelay + val split_exception = split false dest_mips_PC end fun mips_spec_hex2 s = @@ -641,7 +645,7 @@ fun mips_spec_hex2 s = (case String.tokens Char.isSpace s of [s1] => (case mips_spec_hex s1 of - [th, _] => [th] + [th, _] => [List.last (split_exception th)] | l => raise ERR "mips_spec2_hex" ("Expecting two theorems: " ^ s1)) | [s1, s2] => (case (mips_spec_hex s1, mips_spec_hex s2) of diff --git a/examples/l3-machine-code/mips/step/mips_stepScript.sml b/examples/l3-machine-code/mips/step/mips_stepScript.sml index 9093cdf0e4..2062676331 100644 --- a/examples/l3-machine-code/mips/step/mips_stepScript.sml +++ b/examples/l3-machine-code/mips/step/mips_stepScript.sml @@ -706,6 +706,16 @@ val Aligned_numeric = Q.store_thm("Aligned_numeric", \\ blastLib.BBLAST_TAC ) +(* Simplify alignment condition for exception calls + +val Aligned_cond = Q.store_thm("Aligned_cond", + `!a: 34 word b:word30 c d. + ((1 >< 0) ((a @@ if d then b else c): word64) = 0w: word2) = + d /\ ((1 >< 0) b = 0w: word2) \/ ~d /\ ((1 >< 0) c = 0w: word2)`, + rw [] \\ blastLib.BBLAST_TAC + ) +*) + (* ------------------------------------------------------------------------ *) From f11b63568a7de5720be0ad0f1c593a9a19c2033d Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 7 May 2015 11:58:13 +1000 Subject: [PATCH 302/718] Use printf instead of echo for added portability --- tools/Holmake/Holmake_tools.sml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/Holmake/Holmake_tools.sml b/tools/Holmake/Holmake_tools.sml index b88dac758d..5487b77e46 100644 --- a/tools/Holmake/Holmake_tools.sml +++ b/tools/Holmake/Holmake_tools.sml @@ -282,7 +282,7 @@ val nice_dir = | NONE => (fn s => s) fun xterm_log s = - ignore (OS.Process.system ("/bin/sh -c 'echo -ne \"\\033]0;" ^ s ^ "\\007\"'")) + ignore (OS.Process.system ("/bin/sh -c 'printf \"\\033]0;" ^ s ^ "\\007\"'")) val terminal_log = if Systeml.isUnix then xterm_log From ac8175183e0ede77abfc56f443cca5e5599ffef6 Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Mon, 11 May 2015 14:34:26 +0100 Subject: [PATCH 303/718] Modify the type of HolKernel.syntax_fns and add some documentation. This is in response to issue #247. The change to the type makes things a little more natural when using partial applications - for example, HolKernel.syntax_fns1 can be used to provide syntax support for regular unary operations. --- .../l3-machine-code/arm/prog/arm_progLib.sml | 11 ++- .../arm8/prog/arm8_progLib.sml | 10 +-- .../arm8/step/arm8_stepLib.sml | 3 +- .../common/core_decompilerLib.sml | 4 +- examples/l3-machine-code/common/stateLib.sml | 5 +- .../common/temporal_stateSyntax.sml | 3 +- .../l3-machine-code/common/tripleSyntax.sml | 6 +- .../l3-machine-code/m0/prog/m0_progLib.sml | 13 ++- .../mips/prog/mips_progLib.sml | 7 +- .../l3-machine-code/x64/prog/x64_progLib.sml | 7 +- .../machine-code/hoare-triple/progSyntax.sml | 11 +-- .../hoare-triple/temporalSyntax.sml | 14 ++-- help/Docfiles/HolKernel.syntax_fns.doc | 82 +++++++++++++++++++ src/finite_map/finite_mapSyntax.sml | 6 +- src/floating-point/binary_ieeeSyntax.sml | 69 ++++++++-------- src/floating-point/fp-functor.sml | 10 +-- src/integer/integer_wordSyntax.sml | 13 +-- src/list/src/listSyntax.sml | 2 +- src/list/src/numposrepSyntax.sml | 11 +-- src/list/src/rich_listSyntax.sml | 11 +-- src/monad/state_transformerSyntax.sml | 3 +- src/n-bit/bitstringLib.sml | 6 +- src/n-bit/bitstringSyntax.sml | 22 ++--- src/n-bit/wordsSyntax.sml | 10 +-- src/num/extra_theories/bitSyntax.sml | 15 +--- src/patricia/sptreeSyntax.sml | 10 +-- src/postkernel/HolKernel.sml | 36 ++++---- src/postkernel/HolKernelDoc.sig | 4 +- src/pred_set/src/pred_setSyntax.sml | 15 ++-- src/real/transcSyntax.sml | 12 +-- src/sort/sortingSyntax.sml | 11 +-- src/string/ASCIInumbersSyntax.sml | 11 +-- src/string/stringSyntax.sml | 7 +- src/sum/sumSyntax.sml | 32 ++++---- src/update/updateSyntax.sml | 12 +-- 35 files changed, 271 insertions(+), 233 deletions(-) create mode 100644 help/Docfiles/HolKernel.syntax_fns.doc diff --git a/examples/l3-machine-code/arm/prog/arm_progLib.sml b/examples/l3-machine-code/arm/prog/arm_progLib.sml index 1f6f6d2a50..e18ca4cd2e 100644 --- a/examples/l3-machine-code/arm/prog/arm_progLib.sml +++ b/examples/l3-machine-code/arm/prog/arm_progLib.sml @@ -22,12 +22,15 @@ val arm_comp_defs = arm_progTheory.component_defs local val pc = Term.prim_mk_const {Thy = "arm", Name = "RName_PC"} in - val step_1 = - HolKernel.syntax_fns "arm_step" 1 HolKernel.dest_monop HolKernel.mk_monop + val step_1 = HolKernel.syntax_fns1 "arm_step" val arm_1 = - HolKernel.syntax_fns "arm_prog" 2 HolKernel.dest_monop HolKernel.mk_monop + HolKernel.syntax_fns + {n = 2, dest = HolKernel.dest_monop, make = HolKernel.mk_monop} + "arm_prog" val arm_2 = - HolKernel.syntax_fns "arm_prog" 3 HolKernel.dest_binop HolKernel.mk_binop + HolKernel.syntax_fns + {n = 3, dest = HolKernel.dest_binop, make = HolKernel.mk_binop} + "arm_prog" val word5 = wordsSyntax.mk_int_word_type 5 val word = wordsSyntax.mk_int_word_type 32 val dword = wordsSyntax.mk_int_word_type 64 diff --git a/examples/l3-machine-code/arm8/prog/arm8_progLib.sml b/examples/l3-machine-code/arm8/prog/arm8_progLib.sml index 8d873504aa..c71d059c4a 100644 --- a/examples/l3-machine-code/arm8/prog/arm8_progLib.sml +++ b/examples/l3-machine-code/arm8/prog/arm8_progLib.sml @@ -18,12 +18,10 @@ val ERR = Feedback.mk_HOL_ERR "arm8_progLib" val arm_proj_def = arm8_progTheory.arm8_proj_def val arm_comp_defs = arm8_progTheory.component_defs -val step_1 = - HolKernel.syntax_fns "arm8_step" 1 HolKernel.dest_monop HolKernel.mk_monop -val arm_1 = - HolKernel.syntax_fns "arm8_prog" 2 HolKernel.dest_monop HolKernel.mk_monop -val arm_2 = - HolKernel.syntax_fns "arm8_prog" 3 HolKernel.dest_binop HolKernel.mk_binop +val step_1 = HolKernel.syntax_fns1 "arm8_step" +fun syn n d m = HolKernel.syntax_fns {n = n, dest = d, make = m} "arm8_prog" +val arm_1 = syn 2 HolKernel.dest_monop HolKernel.mk_monop +val arm_2 = syn 3 HolKernel.dest_binop HolKernel.mk_binop val word5 = wordsSyntax.mk_int_word_type 5 val word = wordsSyntax.mk_int_word_type 32 val dword = wordsSyntax.mk_int_word_type 64 diff --git a/examples/l3-machine-code/arm8/step/arm8_stepLib.sml b/examples/l3-machine-code/arm8/step/arm8_stepLib.sml index 0dcb1a1708..526b3bb889 100644 --- a/examples/l3-machine-code/arm8/step/arm8_stepLib.sml +++ b/examples/l3-machine-code/arm8/step/arm8_stepLib.sml @@ -39,8 +39,7 @@ fun reg_var v = Term.mk_var (v, reg_ty) val r31 = wordsSyntax.mk_wordii (31, 5) fun NetFromList l = List.foldl (Lib.uncurry Net.insert) Net.empty l -val arm8_monop = - HolKernel.syntax_fns "arm8" 1 HolKernel.dest_monop HolKernel.mk_monop +val arm8_monop = HolKernel.syntax_fns1 "arm8" (* ---------------------------- *) diff --git a/examples/l3-machine-code/common/core_decompilerLib.sml b/examples/l3-machine-code/common/core_decompilerLib.sml index 5533eb54a4..f15d70ea2c 100644 --- a/examples/l3-machine-code/common/core_decompilerLib.sml +++ b/examples/l3-machine-code/common/core_decompilerLib.sml @@ -450,9 +450,7 @@ fun is_rec (Repeat _) = true | is_rec (ConsMerge (_, _, _, t)) = is_rec t local - val (_, _, _, is_abbrev) = - HolKernel.syntax_fns "marker" 1 HolKernel.dest_monop HolKernel.mk_monop - "Abbrev" + val (_, _, _, is_abbrev) = HolKernel.syntax_fns1 "marker" "Abbrev" fun get_Abbrev th = case Thm.hyp th of [h] => Lib.with_exn (Term.rand o HolKernel.find_term is_abbrev) h diff --git a/examples/l3-machine-code/common/stateLib.sml b/examples/l3-machine-code/common/stateLib.sml index 98645c2e67..ad77f3bdb5 100644 --- a/examples/l3-machine-code/common/stateLib.sml +++ b/examples/l3-machine-code/common/stateLib.sml @@ -1361,8 +1361,9 @@ fun chunks_intro be m_def = local val (sep_array_tm, mk_sep_array, dest_sep_array, _) = - HolKernel.syntax_fns "set_sep" 5 HolKernel.dest_quadop HolKernel.mk_quadop - "SEP_ARRAY" + HolKernel.syntax_fns + {n = 5, dest = HolKernel.dest_quadop, make = HolKernel.mk_quadop} + "set_sep" "SEP_ARRAY" val list_mk_concat = HolKernel.list_mk_rbinop (Lib.curry wordsSyntax.mk_word_concat) val list_mk_add = diff --git a/examples/l3-machine-code/common/temporal_stateSyntax.sml b/examples/l3-machine-code/common/temporal_stateSyntax.sml index c60bf1bbce..876135f105 100644 --- a/examples/l3-machine-code/common/temporal_stateSyntax.sml +++ b/examples/l3-machine-code/common/temporal_stateSyntax.sml @@ -6,8 +6,7 @@ open Abbrev HolKernel progSyntax temporal_stateTheory (* ----------------------------------------------------------------------- *) val (temporal_next_tm, mk_temporal_next, dest_temporal_next, is_temporal_next) = - HolKernel.syntax_fns "temporal_state" 4 - HolKernel.dest_quadop HolKernel.mk_quadop "TEMPORAL_NEXT" + HolKernel.syntax_fns4 "temporal_state" "TEMPORAL_NEXT" fun dest_pre tm = let val (_, p, _, _) = dest_temporal_next tm in p end fun dest_code tm = let val (_, _, c, _) = dest_temporal_next tm in c end diff --git a/examples/l3-machine-code/common/tripleSyntax.sml b/examples/l3-machine-code/common/tripleSyntax.sml index c4ceeeb509..ea89d9e3d6 100644 --- a/examples/l3-machine-code/common/tripleSyntax.sml +++ b/examples/l3-machine-code/common/tripleSyntax.sml @@ -7,12 +7,10 @@ open tripleTheory (* ----------------------------------------------------------------------- *) val (triple_tm, mk_triple, dest_triple, is_triple) = - HolKernel.syntax_fns "triple" 4 HolKernel.dest_quadop HolKernel.mk_quadop - "TRIPLE" + HolKernel.syntax_fns4 "triple" "TRIPLE" val (case_sum_tm, mk_case_sum, dest_case_sum, is_case_sum) = - HolKernel.syntax_fns "triple" 3 - HolKernel.dest_triop HolKernel.mk_triop "case_sum" + HolKernel.syntax_fns3 "triple" "case_sum" fun dest_model tm = let val (m, _, _, _) = dest_triple tm in m end fun dest_pre tm = let val (_, p, _, _) = dest_triple tm in p end diff --git a/examples/l3-machine-code/m0/prog/m0_progLib.sml b/examples/l3-machine-code/m0/prog/m0_progLib.sml index 55dac6789b..376c2ddc0f 100644 --- a/examples/l3-machine-code/m0/prog/m0_progLib.sml +++ b/examples/l3-machine-code/m0/prog/m0_progLib.sml @@ -21,15 +21,12 @@ val m0_comp_defs = m0_progTheory.component_defs local val pc = Term.prim_mk_const {Thy = "m0", Name = "RName_PC"} - val step_1 = - HolKernel.syntax_fns "m0_step" 1 HolKernel.dest_monop HolKernel.mk_monop - val m0_0 = - HolKernel.syntax_fns "m0_prog" 1 HolKernel.dest_monop HolKernel.mk_monop + val step_1 = HolKernel.syntax_fns1 "m0_step" + fun syn n d m = HolKernel.syntax_fns {n = n, dest = d, make = m} "m0_prog" + val m0_0 = syn 1 HolKernel.dest_monop HolKernel.mk_monop in - val m0_1 = - HolKernel.syntax_fns "m0_prog" 2 HolKernel.dest_monop HolKernel.mk_monop - val m0_2 = - HolKernel.syntax_fns "m0_prog" 3 HolKernel.dest_binop HolKernel.mk_binop + val m0_1 = syn 2 HolKernel.dest_monop HolKernel.mk_monop + val m0_2 = syn 3 HolKernel.dest_binop HolKernel.mk_binop val byte = wordsSyntax.mk_int_word_type 8 val half = wordsSyntax.mk_int_word_type 16 val word = wordsSyntax.mk_int_word_type 32 diff --git a/examples/l3-machine-code/mips/prog/mips_progLib.sml b/examples/l3-machine-code/mips/prog/mips_progLib.sml index 5d53b245b2..caffdacd59 100644 --- a/examples/l3-machine-code/mips/prog/mips_progLib.sml +++ b/examples/l3-machine-code/mips/prog/mips_progLib.sml @@ -19,10 +19,9 @@ val ERR = Feedback.mk_HOL_ERR "mips_progLib" val mips_proj_def = mips_progTheory.mips_proj_def val mips_comp_defs = mips_progTheory.component_defs -val mips_1 = - HolKernel.syntax_fns "mips_prog" 2 HolKernel.dest_monop HolKernel.mk_monop -val mips_2 = - HolKernel.syntax_fns "mips_prog" 3 HolKernel.dest_binop HolKernel.mk_binop +fun syn n d m = HolKernel.syntax_fns {n = n, dest = d, make = m} "mips_prog" +val mips_1 = syn 2 HolKernel.dest_monop HolKernel.mk_monop +val mips_2 = syn 3 HolKernel.dest_binop HolKernel.mk_binop val byte = wordsSyntax.mk_int_word_type 8 val word5 = wordsSyntax.mk_int_word_type 5 val word = wordsSyntax.mk_int_word_type 32 diff --git a/examples/l3-machine-code/x64/prog/x64_progLib.sml b/examples/l3-machine-code/x64/prog/x64_progLib.sml index 0b7ae4aa3c..d76af1fc28 100644 --- a/examples/l3-machine-code/x64/prog/x64_progLib.sml +++ b/examples/l3-machine-code/x64/prog/x64_progLib.sml @@ -19,10 +19,9 @@ val ERR = Feedback.mk_HOL_ERR "x64_progLib" val x64_proj_def = x64_progTheory.x64_proj_def val x64_comp_defs = x64_progTheory.component_defs -val x64_1 = - HolKernel.syntax_fns "x64_prog" 2 HolKernel.dest_monop HolKernel.mk_monop -val x64_2 = - HolKernel.syntax_fns "x64_prog" 3 HolKernel.dest_binop HolKernel.mk_binop +fun syn n d m = HolKernel.syntax_fns {n = n, dest = d, make = m} "x64_prog" +val x64_1 = syn 2 HolKernel.dest_monop HolKernel.mk_monop +val x64_2 = syn 3 HolKernel.dest_binop HolKernel.mk_binop val byte = wordsSyntax.mk_int_word_type 8 val word = wordsSyntax.mk_int_word_type 16 val dword = wordsSyntax.mk_int_word_type 32 diff --git a/examples/machine-code/hoare-triple/progSyntax.sml b/examples/machine-code/hoare-triple/progSyntax.sml index 9a704c0ea1..d75b46ed1d 100644 --- a/examples/machine-code/hoare-triple/progSyntax.sml +++ b/examples/machine-code/hoare-triple/progSyntax.sml @@ -5,12 +5,14 @@ open Abbrev HolKernel progTheory (* ----------------------------------------------------------------------- *) +fun syntax_fns n d m = + HolKernel.syntax_fns {n = n, dest = d, make = m} "set_sep" + val (cond_tm, mk_cond, dest_cond, is_cond) = - HolKernel.syntax_fns "set_sep" 2 HolKernel.dest_monop HolKernel.mk_monop - "cond" + syntax_fns 2 HolKernel.dest_monop HolKernel.mk_monop "cond" val (star_tm, mk_star, dest_star, is_star) = - HolKernel.syntax_fns "set_sep" 3 HolKernel.dest_binop + syntax_fns 3 HolKernel.dest_binop (fn tm => fn (tm1, tm2) => boolSyntax.list_mk_icomb (tm, [tm1, tm2])) "STAR" @@ -18,8 +20,7 @@ val list_mk_star = HolKernel.list_mk_lbinop (Lib.curry mk_star) val strip_star = HolKernel.strip_binop (Lib.total dest_star) val (spec_tm, mk_spec, dest_spec, is_spec) = - HolKernel.syntax_fns "prog" 4 HolKernel.dest_quadop HolKernel.mk_quadop - "SPEC" + HolKernel.syntax_fns4 "prog" "SPEC" fun dest_pre tm = let val (_, p, _, _) = dest_spec tm in p end fun dest_code tm = let val (_, _, c, _) = dest_spec tm in c end diff --git a/examples/machine-code/hoare-triple/temporalSyntax.sml b/examples/machine-code/hoare-triple/temporalSyntax.sml index c112a22bf3..38fb9ec7c9 100644 --- a/examples/machine-code/hoare-triple/temporalSyntax.sml +++ b/examples/machine-code/hoare-triple/temporalSyntax.sml @@ -7,16 +7,14 @@ val ERR = Feedback.mk_HOL_ERR "tripleSyntax" (* ----------------------------------------------------------------------- *) -val s1 = - HolKernel.syntax_fns "temporal" 3 HolKernel.dest_monop HolKernel.mk_monop +fun syntax_fns n d m = + HolKernel.syntax_fns {n = n, dest = d, make = m} "temporal" -val s2 = - HolKernel.syntax_fns "temporal" 4 HolKernel.dest_binop HolKernel.mk_binop +val s1 = syntax_fns 3 HolKernel.dest_monop HolKernel.mk_monop +val s2 = syntax_fns 4 HolKernel.dest_binop HolKernel.mk_binop -val s3 = - HolKernel.syntax_fns "temporal" 3 HolKernel.dest_triop HolKernel.mk_triop - -val (temporal_tm, mk_temporal, dest_temporal, is_temporal) = s3 "TEMPORAL" +val (temporal_tm, mk_temporal, dest_temporal, is_temporal) = + HolKernel.syntax_fns3 "temporal" "TEMPORAL" val (now_tm, mk_now, dest_now, is_now) = s1 "NOW" val (next_tm, mk_next, dest_next, is_next) = s1 "NEXT" val (eventually_tm, mk_eventually, dest_eventually, is_eventually) = diff --git a/help/Docfiles/HolKernel.syntax_fns.doc b/help/Docfiles/HolKernel.syntax_fns.doc new file mode 100644 index 0000000000..80c9f7938a --- /dev/null +++ b/help/Docfiles/HolKernel.syntax_fns.doc @@ -0,0 +1,82 @@ +\DOC + +\TYPE {syntax_fns : {dest: term -> exn -> term -> 'a, make: term -> 'b -> term, n: int} -> string -> string -> + term * ('b -> term) * (term -> 'a) * (term -> bool)} + +\SYNOPSIS +Helps in providing syntax support for theory constants. + +\KEYWORDS +Syntax. + +\DESCRIBE +{syntax_fns syntax thy name} returns a 4-tuple, consisting of: a term, a term destructor function, a term constructor function and a term recogniser function. These provide syntax support for operation {name} from theory {thy}. The record argument {syntax} consists of {dest: term -> exn -> term -> 'a} and {make: term -> 'b -> term} functions, together with an "expected arity" value {n}. +Through a sequence of instantiations, the {syntax_fns} function can be used to quickly and reliably write a {thySyntax.sml} file. + +\EXAMPLE + +To provide syntax support for unary operations from the theory {num}, one can use the following function: +{ +> val num1 = HolKernel.syntax_fns {n = 1, make = HolKernel.mk_monop, dest = HolKernel.dest_monop} "num"; +val num1 = fn: + string -> term * (term -> term) * (term -> term) * (term -> bool) +} +The following call then provides support for the {SUC} constant: +{ +> val (suc_tm, mk_suc, dest_suc, is_suc) = num1 "SUC"; +val dest_suc = fn: term -> term +val is_suc = fn: term -> bool +val mk_suc = fn: term -> term +val suc_tm = ``SUC``: term +} +A {SUC} term can be constructed with +{ +> val tm = mk_suc ``4n``; +val tm = ``SUC 4``: term +} +The resulting term {tm} can be identified and destructed as follows: +{ +> is_suc tm; +val it = true: bool +> val v = dest_suc tm; +val v = ``4``: term +} +A standard error message is raised when {dest_suc} fails, e.g. +{ +> is_suc ``SUC``; +val it = false: bool +> val v = dest_suc ``SUC``; +Exception- + HOL_ERR + {message = "", origin_function = "dest_SUC", origin_structure = + "numSyntax"} raised +} + +The value {n} in the call to {syntax_fns} acts purely as a sanity check. For example, the following fails because {SUC} is not a binary operation: +{ +> HolKernel.syntax_fns {n = 2, make = HolKernel.mk_binop, dest = HolKernel.dest_binop} "num" "SUC"; +Exception- + HOL_ERR + {message = "bad number of arguments", origin_function = "systax_fns", + origin_structure = "numSyntax"} raised +} +Typically, the {dest} and {make} functions will be complementary (with type variables {'a} and {'b} being the same), however this need not be the case. Advanced uses of {syntax_fns} can take types into consideration. For example, the constant {bitstring$v2w} with type {bitstring->'a word} is supported as follows: +{ +> val tm = bitstringSyntax.mk_v2w (``l:bitstring``, ``:32``); +val tm = ``v2w l``: term +> type_of tm; +val it = ``:word32``: hol_type +> bitstringSyntax.dest_v2w tm; +val it = (``l``, ``:32``): term * hol_type +} +This is implemented as follows: +{ +val (v2w_tm, mk_v2w, dest_v2w, is_v2w) = + HolKernel.syntax_fns + {n = 1, + dest = fn tm1 => fn e => fn w => (HolKernel.dest_monop tm1 e w, wordsSyntax.dim_of w), + make = fn tm => fn (v, ty) => Term.mk_comb (Term.inst [Type.alpha |-> ty] tm, v)} + "bitstring" "v2w" +} + +\ENDDOC diff --git a/src/finite_map/finite_mapSyntax.sml b/src/finite_map/finite_mapSyntax.sml index 3e404b8f43..3efe034aee 100644 --- a/src/finite_map/finite_mapSyntax.sml +++ b/src/finite_map/finite_mapSyntax.sml @@ -116,9 +116,7 @@ val is_fevery = same_const fevery_t val dest_fevery = dest_binop fevery_t "fevery" val is_fevery = can dest_fevery -val bop = - HolKernel.syntax_fns "finite_map" 2 HolKernel.dest_binop HolKernel.mk_binop - -val (flookup_t, mk_flookup, dest_flookup, is_flookup) = bop "FLOOKUP" +val (flookup_t, mk_flookup, dest_flookup, is_flookup) = + HolKernel.syntax_fns2 "finite_map" "FLOOKUP" end diff --git a/src/floating-point/binary_ieeeSyntax.sml b/src/floating-point/binary_ieeeSyntax.sml index 4b234b941f..4e2adb70e6 100644 --- a/src/floating-point/binary_ieeeSyntax.sml +++ b/src/floating-point/binary_ieeeSyntax.sml @@ -75,42 +75,40 @@ fun is_ground_real tm = (* ------------------------------------------------------------------------- *) -val monop = - HolKernel.syntax_fns "binary_ieee" 1 HolKernel.dest_monop - (Lib.curry boolSyntax.mk_icomb) +val monop = HolKernel.syntax_fns1 "binary_ieee" +val binop = HolKernel.syntax_fns2 "binary_ieee" +val triop = HolKernel.syntax_fns3 "binary_ieee" +val quadop = HolKernel.syntax_fns4 "binary_ieee" -val binop = - HolKernel.syntax_fns "binary_ieee" 2 HolKernel.dest_binop HolKernel.mk_binop - -val triop = - HolKernel.syntax_fns "binary_ieee" 3 HolKernel.dest_triop HolKernel.mk_triop - -val quadop = - HolKernel.syntax_fns - "binary_ieee" 4 HolKernel.dest_quadop HolKernel.mk_quadop +fun syntax_fns x = HolKernel.syntax_fns x "binary_ieee" val tw_monop = - HolKernel.syntax_fns "binary_ieee" 1 - (fn tm1 => fn e => fn tm2 => + syntax_fns + {n = 1, + dest = + fn tm1 => fn e => fn tm2 => let val ty = boolSyntax.dest_itself (HolKernel.dest_monop tm1 e tm2) val (t, w) = pairSyntax.dest_prod ty in (fcpSyntax.dest_int_numeric_type t, fcpSyntax.dest_int_numeric_type w) - end) - (fn tm1 => fn (t, w) => + end, + make = + fn tm1 => fn (t, w) => let val t_ty = fcpSyntax.mk_int_numeric_type t val w_ty = fcpSyntax.mk_int_numeric_type w val p_ty = pairSyntax.mk_prod (t_ty, w_ty) in boolSyntax.mk_icomb (tm1, boolSyntax.mk_itself p_ty) - end) + end} val etw_monop = - HolKernel.syntax_fns "binary_ieee" 1 - (fn tm1 => fn e => fn tm2 => + syntax_fns + {n = 1, + dest = + fn tm1 => fn e => fn tm2 => let val (t1, t2) = pairSyntax.dest_pair (HolKernel.dest_monop tm1 e tm2) @@ -120,40 +118,47 @@ val etw_monop = (wordsSyntax.uint_of_word t1, fcpSyntax.dest_int_numeric_type t, Arbnum.toInt w) - end) - (fn tm1 => fn (i, t, w) => + end, + make = + fn tm1 => fn (i, t, w) => let val t1 = wordsSyntax.mk_wordii (i, w) val t2 = boolSyntax.mk_itself (fcpSyntax.mk_int_numeric_type t) in boolSyntax.mk_icomb (tm1, pairSyntax.mk_pair (t1, t2)) - end) + end} val tw_binop = - HolKernel.syntax_fns "binary_ieee" 2 - (fn tm1 => fn e => fn tm2 => + syntax_fns + {n = 2, + dest = + fn tm1 => fn e => fn tm2 => let val (a, b) = HolKernel.dest_binop tm1 e tm2 val (ty1, ty2) = dest_float_ty (Term.type_of tm2) in (a, b, ty1, ty2) - end) - (fn tm1 => fn (tm2, tm3, t, w) => + end, + make = + fn tm1 => fn (tm2, tm3, t, w) => Term.inst [``:'w`` |-> w, ``:'t`` |-> t] - (HolKernel.mk_binop tm1 (tm2, tm3))) + (HolKernel.mk_binop tm1 (tm2, tm3))} val tw_triop = - HolKernel.syntax_fns "binary_ieee" 3 - (fn tm1 => fn e => fn tm2 => + syntax_fns + {n = 3, + dest = + fn tm1 => fn e => fn tm2 => let val (a, b, c) = HolKernel.dest_triop tm1 e tm2 val (ty1, ty2) = dest_float_ty (Term.type_of tm2) in (a, b, c, ty1, ty2) - end) - (fn tm1 => fn (tm2, tm3, tm4, t, w) => + end, + make = + fn tm1 => fn (tm2, tm3, tm4, t, w) => Term.inst [``:'w`` |-> w, ``:'t`` |-> t] - (HolKernel.mk_triop tm1 (tm2, tm3, tm4))) + (HolKernel.mk_triop tm1 (tm2, tm3, tm4))} (* ------------------------------------------------------------------------- *) diff --git a/src/floating-point/fp-functor.sml b/src/floating-point/fp-functor.sml index dd79e21657..d3dcfda642 100644 --- a/src/floating-point/fp-functor.sml +++ b/src/floating-point/fp-functor.sml @@ -5,11 +5,8 @@ struct open Abbrev HolKernel open machine_ieeeTheory - val monop = HolKernel.syntax_fns thy 1 HolKernel.dest_monop - (Lib.curry boolSyntax.mk_icomb) - - val binop = - HolKernel.syntax_fns thy 2 HolKernel.dest_binop HolKernel.mk_binop + val monop = HolKernel.syntax_fns1 thy + val binop = HolKernel.syntax_fns2 thy val (float_to_fp_tm, mk_float_to_fp, dest_float_to_fp, is_float_to_fp) = monop ("float_to_" ^ fp) @@ -22,8 +19,7 @@ struct fun const name = Term.mk_thy_const {Ty = ty, Thy = thy, Name = pre name} val monop = monop o pre val binop = binop o pre - val triop = - HolKernel.syntax_fns thy 3 HolKernel.dest_triop HolKernel.mk_triop o pre + val triop = HolKernel.syntax_fns3 thy o pre val (fp_abs_tm, mk_fp_abs, dest_fp_abs, is_fp_abs) = monop "abs" val (fp_add_tm, mk_fp_add, dest_fp_add, is_fp_add) = triop "add" diff --git a/src/integer/integer_wordSyntax.sml b/src/integer/integer_wordSyntax.sml index 2fca4759ec..2c025888d5 100644 --- a/src/integer/integer_wordSyntax.sml +++ b/src/integer/integer_wordSyntax.sml @@ -6,11 +6,12 @@ open wordsSyntax integer_wordTheory val ERR = Feedback.mk_HOL_ERR "integer_wordSyntax" -val syntax_fns = HolKernel.syntax_fns +fun syntax_fns n d m = + HolKernel.syntax_fns {n = n, dest = d, make = m} "integer_word" (*------------------------------------------------------------------------- *) -val s = syntax_fns "integer_word" 1 HolKernel.dest_monop HolKernel.mk_monop +val s = HolKernel.syntax_fns1 "integer_word" val (toString_tm, mk_toString, dest_toString, is_toString) = s "toString" @@ -21,7 +22,7 @@ val (w2i_tm, mk_w2i, dest_w2i, is_w2i) = s "w2i" (* - - - - - - - - - - - - - - - - - - - - - - - *) -val s = syntax_fns "integer_word" 1 +val s = syntax_fns 1 (fn tm1 => fn e => boolSyntax.dest_itself o HolKernel.dest_monop tm1 e) (fn tm => fn ty => Term.mk_comb (Term.inst [Type.alpha |-> ty] tm, boolSyntax.mk_itself ty)) @@ -32,7 +33,7 @@ val (uint_max_tm, mk_uint_max, dest_uint_max, is_uint_max) = s "UINT_MAX" (* - - - - - - - - - - - - - - - - - - - - - - - *) -val s = syntax_fns "integer_word" 1 +val s = syntax_fns 1 (fn tm1 => fn e => fn w => (HolKernel.dest_monop tm1 e w, dim_of w)) (fn tm => fn (w, ty) => Term.mk_comb (Term.inst [Type.alpha |-> ty] tm, w)) @@ -46,7 +47,7 @@ val (saturate_i2w_tm, mk_saturate_i2w, dest_saturate_i2w, is_saturate_i2w) = (* - - - - - - - - - - - - - - - - - - - - - - - *) -val s = syntax_fns "integer_word" 1 +val s = syntax_fns 1 (fn tm1 => fn e => fn w => (HolKernel.dest_monop tm1 e w, dim_of w)) (fn tm => fn (w, ty) => Term.mk_comb (Term.inst [Type.alpha |-> wordsSyntax.dim_of w, @@ -63,7 +64,7 @@ val (saturate_w2sw_tm, mk_saturate_w2sw, (* - - - - - - - - - - - - - - - - - - - - - - - *) -val s = syntax_fns "integer_word" 2 HolKernel.dest_binop HolKernel.mk_binop +val s = HolKernel.syntax_fns2 "integer_word" val (signed_saturate_add_tm, mk_signed_saturate_add, dest_signed_saturate_add, is_signed_saturate_add) = s "signed_saturate_add" diff --git a/src/list/src/listSyntax.sml b/src/list/src/listSyntax.sml index 60f4cbe4a4..f3d34d739d 100644 --- a/src/list/src/listSyntax.sml +++ b/src/list/src/listSyntax.sml @@ -217,7 +217,7 @@ val is_list_case = can dest_list_case val is_genlist = can dest_genlist val is_nub = can dest_nub -val s3 = HolKernel.syntax_fns "list" 3 HolKernel.dest_triop HolKernel.mk_triop +val s3 = HolKernel.syntax_fns3 "list" val (pad_left_tm, mk_pad_left, dest_pad_left, is_pad_left) = s3 "PAD_LEFT" val (pad_right_tm, mk_pad_right, dest_pad_right, is_pad_right) = s3 "PAD_RIGHT" diff --git a/src/list/src/numposrepSyntax.sml b/src/list/src/numposrepSyntax.sml index eedeb8ed77..2eb8c6c805 100644 --- a/src/list/src/numposrepSyntax.sml +++ b/src/list/src/numposrepSyntax.sml @@ -3,14 +3,9 @@ struct open Abbrev HolKernel numposrepTheory -val monop = - HolKernel.syntax_fns "numposrep" 1 HolKernel.dest_monop HolKernel.mk_monop - -val binop = - HolKernel.syntax_fns "numposrep" 2 HolKernel.dest_binop HolKernel.mk_binop - -val triop = - HolKernel.syntax_fns "numposrep" 3 HolKernel.dest_triop HolKernel.mk_triop +val monop = HolKernel.syntax_fns1 "numposrep" +val binop = HolKernel.syntax_fns2 "numposrep" +val triop = HolKernel.syntax_fns3 "numposrep" val (num_from_bin_list_tm,mk_num_from_bin_list, dest_num_from_bin_list,is_num_from_bin_list) = monop "num_from_bin_list" diff --git a/src/list/src/rich_listSyntax.sml b/src/list/src/rich_listSyntax.sml index abad114c05..d3346fe12e 100644 --- a/src/list/src/rich_listSyntax.sml +++ b/src/list/src/rich_listSyntax.sml @@ -8,14 +8,9 @@ struct Syntax functions for rich_list ---------------------------------------------------------------------------*) -val monop = - HolKernel.syntax_fns "rich_list" 1 HolKernel.dest_monop HolKernel.mk_monop - -val binop = - HolKernel.syntax_fns "rich_list" 2 HolKernel.dest_binop HolKernel.mk_binop - -val triop = - HolKernel.syntax_fns "rich_list" 3 HolKernel.dest_triop HolKernel.mk_triop +val monop = HolKernel.syntax_fns1 "rich_list" +val binop = HolKernel.syntax_fns2 "rich_list" +val triop = HolKernel.syntax_fns3 "rich_list" val (and_el_tm, mk_and_el, dest_and_el, is_and_el) = monop "AND_EL" val (count_list_tm, mk_count_list, dest_count_list, is_count_list) = diff --git a/src/monad/state_transformerSyntax.sml b/src/monad/state_transformerSyntax.sml index ed7f9116b4..8d8707b112 100644 --- a/src/monad/state_transformerSyntax.sml +++ b/src/monad/state_transformerSyntax.sml @@ -7,7 +7,8 @@ val ERR = Feedback.mk_HOL_ERR "state_transformerSyntax" (*---------------------------------------------------------------------------*) -fun syntax n m d = HolKernel.syntax_fns "state_transformer" n m d +fun syntax n d m = + HolKernel.syntax_fns {n = n, dest = d, make = m} "state_transformer" val s1 = syntax 2 HolKernel.dest_monop HolKernel.mk_monop val s2 = syntax 3 HolKernel.dest_binop HolKernel.mk_binop diff --git a/src/n-bit/bitstringLib.sml b/src/n-bit/bitstringLib.sml index 42b4cc2f97..d03b45713a 100644 --- a/src/n-bit/bitstringLib.sml +++ b/src/n-bit/bitstringLib.sml @@ -477,8 +477,6 @@ local |> fst of [((thy, _), (thm, _))] => SOME (thy, thm) | _ => NONE - fun syntax_monop thy = - HolKernel.syntax_fns thy 1 HolKernel.dest_monop HolKernel.mk_monop in fun bitify_boolify i = let @@ -499,9 +497,9 @@ in ((thy, thm1), (thy, thm2)) end val (bitify_tm, mk_bitify, dest_bitify, is_bitify) = - syntax_monop thy1 bitify + HolKernel.syntax_fns1 thy1 bitify val (boolify_tm, mk_boolify, dest_boolify, is_boolify) = - syntax_monop thy2 boolify + HolKernel.syntax_fns1 thy2 boolify in { bitify_def = bitify_def, bitify_tm = bitify_tm, diff --git a/src/n-bit/bitstringSyntax.sml b/src/n-bit/bitstringSyntax.sml index a120e7f18a..a1efa9f482 100644 --- a/src/n-bit/bitstringSyntax.sml +++ b/src/n-bit/bitstringSyntax.sml @@ -5,11 +5,9 @@ open Abbrev HolKernel wordsSyntax bitstringTheory val ERR = mk_HOL_ERR "bitstringSyntax" -fun syntax_fns n d m = HolKernel.syntax_fns "bitstring" n d m - (* ----------------------------------------------------------------------- *) -val s = syntax_fns 1 HolKernel.dest_monop HolKernel.mk_monop +val s = HolKernel.syntax_fns1 "bitstring" val (n2v_tm, mk_n2v, dest_n2v, is_n2v) = s "n2v" val (v2n_tm, mk_v2n, dest_v2n, is_v2n) = s "v2n" @@ -20,15 +18,17 @@ val (w2v_tm, mk_w2v, dest_w2v, is_w2v) = s "w2v" (* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . *) -val s = syntax_fns 1 - (fn tm1 => fn e => fn w => (HolKernel.dest_monop tm1 e w, dim_of w)) - (fn tm => fn (v, ty) => Term.mk_comb (Term.inst [Type.alpha |-> ty] tm, v)) - -val (v2w_tm, mk_v2w, dest_v2w, is_v2w) = s "v2w" +val (v2w_tm, mk_v2w, dest_v2w, is_v2w) = + HolKernel.syntax_fns + {n = 1, + dest = fn tm1 => fn e => fn w => (HolKernel.dest_monop tm1 e w, dim_of w), + make = fn tm => fn (v, ty) => + Term.mk_comb (Term.inst [Type.alpha |-> ty] tm, v)} + "bitstring" "v2w" (* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . *) -val s = syntax_fns 2 HolKernel.dest_binop HolKernel.mk_binop +val s = HolKernel.syntax_fns2 "bitstring" val (zero_extend_tm, mk_zero_extend, dest_zero_extend, is_zero_extend) = s "zero_extend" @@ -52,14 +52,14 @@ val (replicate_tm, mk_replicate, dest_replicate, is_replicate) = s "replicate" (* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . *) -val s = syntax_fns 3 HolKernel.dest_triop HolKernel.mk_triop +val s = HolKernel.syntax_fns3 "bitstring" val (field_tm, mk_field, dest_field, is_field) = s "field" val (bitwise_tm, mk_bitwise, dest_bitwise, is_bitwise) = s "bitwise" (* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . *) -val s = syntax_fns 4 HolKernel.dest_quadop HolKernel.mk_quadop +val s = HolKernel.syntax_fns4 "bitstring" val (field_insert_tm, mk_field_insert, dest_field_insert, is_field_insert) = s "field_insert" diff --git a/src/n-bit/wordsSyntax.sml b/src/n-bit/wordsSyntax.sml index 583d03dd7b..4cfe5f70b5 100644 --- a/src/n-bit/wordsSyntax.sml +++ b/src/n-bit/wordsSyntax.sml @@ -6,7 +6,7 @@ open bitSyntax fcpSyntax fcpLib wordsTheory val ERR = mk_HOL_ERR "wordsSyntax" -fun syntax_fns n d m = HolKernel.syntax_fns "words" n d m +fun syntax_fns n d m = HolKernel.syntax_fns {n = n, dest = d, make = m} "words" (*---------------------------------------------------------------------------*) (* Word types *) @@ -75,7 +75,7 @@ val (int_max_tm, mk_int_max, dest_int_max, is_int_max) = s "INT_MAX" (* - - - - - - - - - - - - - - - - - - - - - - *) -val s = syntax_fns 1 HolKernel.dest_monop HolKernel.mk_monop +val s = HolKernel.syntax_fns1 "words" val (w2n_tm, mk_w2n, dest_w2n, is_w2n) = s "w2n" val (word_abs_tm, mk_word_abs, dest_word_abs, is_word_abs) = s "word_abs" @@ -230,7 +230,7 @@ val (concat_word_list_tm, mk_concat_word_list, (* - - - - - - - - - - - - - - - - - - - - - - *) -val s = syntax_fns 2 HolKernel.dest_binop HolKernel.mk_binop +val s = HolKernel.syntax_fns2 "words" val (w2l_tm, mk_w2l, dest_w2l, is_w2l) = s "w2l" val (nzcv_tm, mk_nzcv, dest_nzcv, is_nzcv) = s "nzcv" @@ -367,7 +367,7 @@ val (bit_set_tm, mk_bit_set, dest_bit_set, is_bit_set) = (* - - - - - - - - - - - - - - - - - - - - - - *) -val s = syntax_fns 3 HolKernel.dest_triop HolKernel.mk_triop +val s = HolKernel.syntax_fns3 "words" val (word_bits_tm, mk_word_bits, dest_word_bits, is_word_bits) = s "word_bits" @@ -409,7 +409,7 @@ val (word_extract_tm, mk_word_extract, dest_word_extract, is_word_extract) = (* - - - - - - - - - - - - - - - - - - - - - - *) -val s = syntax_fns 4 HolKernel.dest_quadop HolKernel.mk_quadop +val s = HolKernel.syntax_fns4 "words" val (bit_field_insert_tm, mk_bit_field_insert, dest_bit_field_insert, is_bit_field_insert) = s "bit_field_insert" diff --git a/src/num/extra_theories/bitSyntax.sml b/src/num/extra_theories/bitSyntax.sml index ea4df85523..26a55843ed 100644 --- a/src/num/extra_theories/bitSyntax.sml +++ b/src/num/extra_theories/bitSyntax.sml @@ -3,17 +3,10 @@ struct open Abbrev HolKernel bitTheory -val monop = - HolKernel.syntax_fns "bit" 1 HolKernel.dest_monop (Lib.curry Term.mk_comb) - -val binop = - HolKernel.syntax_fns "bit" 2 HolKernel.dest_binop HolKernel.mk_binop - -val triop = - HolKernel.syntax_fns "bit" 3 HolKernel.dest_triop HolKernel.mk_triop - -val quadop = - HolKernel.syntax_fns "bit" 4 HolKernel.dest_quadop HolKernel.mk_quadop +val monop = HolKernel.syntax_fns1 "bit" +val binop = HolKernel.syntax_fns2 "bit" +val triop = HolKernel.syntax_fns3 "bit" +val quadop = HolKernel.syntax_fns4 "bit" val (log2_tm,mk_log2,dest_log2,is_log2) = monop "LOG2" val (bit_tm,mk_bit,dest_bit,is_bit) = binop "BIT" diff --git a/src/patricia/sptreeSyntax.sml b/src/patricia/sptreeSyntax.sml index 71615fa8c9..24c77b0bcd 100644 --- a/src/patricia/sptreeSyntax.sml +++ b/src/patricia/sptreeSyntax.sml @@ -6,7 +6,7 @@ open sptreeTheory val ERR = Feedback.mk_HOL_ERR "sptreeSyntax" -fun syntax_fns n d m = HolKernel.syntax_fns "sptree" n d m +fun syntax_fns n d m = HolKernel.syntax_fns {n = n, dest = d, make = m} "sptree" (* ------------------------------------------------------------------------- *) @@ -31,7 +31,7 @@ val (ln_tm, mk_ln, dest_ln, is_ln) = s0 "LN" (* ------------------------------------------------------------------------- *) -val s1 = syntax_fns 1 HolKernel.dest_monop HolKernel.mk_monop +val s1 = HolKernel.syntax_fns1 "sptree" val s1' = syntax_fns 2 HolKernel.dest_monop HolKernel.mk_monop val (domain_tm, mk_domain, dest_domain, is_domain) = s1' "domain" @@ -47,7 +47,7 @@ val (wf_tm, mk_wf, dest_wf, is_wf) = s1 "wf" (* ------------------------------------------------------------------------- *) -val s2 = syntax_fns 2 HolKernel.dest_binop HolKernel.mk_binop +val s2 = HolKernel.syntax_fns2 "sptree" val (bn_tm, mk_bn, dest_bn, is_bn) = s2 "BN" val (delete_tm, mk_delete, dest_delete, is_delete) = s2 "delete" @@ -61,7 +61,7 @@ val (union_tm, mk_union, dest_union, is_union) = s2 "union" (* ------------------------------------------------------------------------- *) -val s3 = syntax_fns 3 HolKernel.dest_triop HolKernel.mk_triop +val s3 = HolKernel.syntax_fns3 "sptree" val (bs_tm, mk_bs, dest_bs, is_bs) = s3 "BS" val (mk_bs_tm, mk_mk_bs, dest_mk_bs, is_mk_bs) = s3 "mk_BS" @@ -69,7 +69,7 @@ val (insert_tm, mk_insert, dest_insert, is_insert) = s3 "insert" (* ------------------------------------------------------------------------- *) -val s4 = syntax_fns 4 HolKernel.dest_quadop HolKernel.mk_quadop +val s4 = HolKernel.syntax_fns4 "sptree" val (foldi_tm, mk_foldi, dest_foldi, is_foldi) = s4 "foldi" diff --git a/src/postkernel/HolKernel.sml b/src/postkernel/HolKernel.sml index 2ae57a1588..4d79b4d855 100644 --- a/src/postkernel/HolKernel.sml +++ b/src/postkernel/HolKernel.sml @@ -218,21 +218,22 @@ in end handle HOL_ERR {message, ...} => raise ERR "list_mk_icomb" message - fun syntax_fns thy n dest make = - fn name => - let - val ERR = Feedback.mk_HOL_ERR (thy ^ "Syntax") - val tm = Term.prim_mk_const {Name = name, Thy = thy} - val () = - ignore (List.length (args tm) = n - orelse raise ERR "systax_fns" "bad number of arguments") - val d = dest tm (ERR ("dest_" ^ name) "") - in - (tm, - fn v => Lib.with_exn (make tm) v (ERR ("mk_" ^ name) ""): term, - d: term -> 'a, - can d) - end + fun syntax_fns + {n: int, make: term -> 'a -> term, dest: term -> exn -> term -> 'b} + thy name = + let + val ERR = Feedback.mk_HOL_ERR (thy ^ "Syntax") + val tm = Term.prim_mk_const {Name = name, Thy = thy} + val () = + ignore (List.length (args tm) = n + orelse raise ERR "systax_fns" "bad number of arguments") + val d = dest tm (ERR ("dest_" ^ name) "") + in + (tm, + fn v => Lib.with_exn (make tm) v (ERR ("mk_" ^ name) ""): term, + d: term -> 'b, + can d) + end end fun mk_monop tm = list_mk_icomb tm o Lib.list_of_singleton @@ -240,6 +241,11 @@ fun mk_binop tm = list_mk_icomb tm o Lib.list_of_pair fun mk_triop tm = list_mk_icomb tm o Lib.list_of_triple fun mk_quadop tm = list_mk_icomb tm o Lib.list_of_quadruple +val syntax_fns1 = syntax_fns {n = 1, make = mk_monop, dest = dest_monop} +val syntax_fns2 = syntax_fns {n = 2, make = mk_binop, dest = dest_binop} +val syntax_fns3 = syntax_fns {n = 3, make = mk_triop, dest = dest_triop} +val syntax_fns4 = syntax_fns {n = 4, make = mk_quadop, dest = dest_quadop} + datatype lambda = VAR of string * hol_type | CONST of {Name: string, Thy: string, Ty: hol_type} diff --git a/src/postkernel/HolKernelDoc.sig b/src/postkernel/HolKernelDoc.sig index 24a6d45f95..061cfd1b6f 100644 --- a/src/postkernel/HolKernelDoc.sig +++ b/src/postkernel/HolKernelDoc.sig @@ -60,8 +60,8 @@ sig val subst_occs: int list list -> {redex: term, residue: term} list -> term -> term val syntax_fns: - string -> int -> (term -> exn -> term -> 'a) -> (term * 'b -> term) -> - string -> term * ('b -> term) * (term -> 'a) * (term -> bool) + {n: int, make: term -> 'a -> term, dest: term -> exn -> term -> 'b} -> + string -> string -> term * ('b -> term) * (term -> 'a) * (term -> bool) val term_size: term -> int end diff --git a/src/pred_set/src/pred_setSyntax.sml b/src/pred_set/src/pred_setSyntax.sml index 624d3c7d22..187a2e7c7e 100644 --- a/src/pred_set/src/pred_setSyntax.sml +++ b/src/pred_set/src/pred_setSyntax.sml @@ -33,16 +33,15 @@ fun eltype tm = dest_set_type (type_of tm) (* Set constants. Note that "IN" is alredy defined in boolTheory. *) (*---------------------------------------------------------------------------*) -fun syntax_fns n d m = HolKernel.syntax_fns "pred_set" n d m -val t1 = syntax_fns 1 HolKernel.dest_monop HolKernel.mk_monop -val t2 = syntax_fns 2 HolKernel.dest_binop HolKernel.mk_binop -val s1 = syntax_fns 2 HolKernel.dest_monop HolKernel.mk_monop -val s2 = syntax_fns 3 HolKernel.dest_binop HolKernel.mk_binop -val t3 = syntax_fns 3 HolKernel.dest_triop HolKernel.mk_triop +val t1 = HolKernel.syntax_fns1 "pred_set" +val t2 = HolKernel.syntax_fns2 "pred_set" +val t3 = HolKernel.syntax_fns3 "pred_set" -val (in_tm, mk_in, dest_in, is_in) = - HolKernel.syntax_fns "bool" 2 HolKernel.dest_binop HolKernel.mk_binop "IN" +fun syn s = HolKernel.syntax_fns s "pred_set" +val s1 = syn {n = 2, dest = HolKernel.dest_monop, make = HolKernel.mk_monop} +val s2 = syn {n = 3, dest = HolKernel.dest_binop, make = HolKernel.mk_binop} +val (in_tm, mk_in, dest_in, is_in) = HolKernel.syntax_fns2 "bool" "IN" val (insert_tm, mk_insert, dest_insert, is_insert) = s2 "INSERT" val (inter_tm, mk_inter, dest_inter, is_inter) = s2 "INTER" val (union_tm, mk_union, dest_union, is_union) = s2 "UNION" diff --git a/src/real/transcSyntax.sml b/src/real/transcSyntax.sml index 7d8dfd9596..0a21b9acd8 100644 --- a/src/real/transcSyntax.sml +++ b/src/real/transcSyntax.sml @@ -6,15 +6,9 @@ open realSyntax transcTheory (* ------------------------------------------------------------------------- *) -val monop = - HolKernel.syntax_fns "transc" 1 HolKernel.dest_monop - (Lib.curry boolSyntax.mk_icomb) - -val binop = - HolKernel.syntax_fns "transc" 2 HolKernel.dest_binop HolKernel.mk_binop - -val triop = - HolKernel.syntax_fns "transc" 3 HolKernel.dest_triop HolKernel.mk_triop +val monop = HolKernel.syntax_fns1 "transc" +val binop = HolKernel.syntax_fns2 "transc" +val triop = HolKernel.syntax_fns3 "transc" (* ------------------------------------------------------------------------- *) diff --git a/src/sort/sortingSyntax.sml b/src/sort/sortingSyntax.sml index b486d63b41..86da2352ab 100644 --- a/src/sort/sortingSyntax.sml +++ b/src/sort/sortingSyntax.sml @@ -3,14 +3,9 @@ struct open Abbrev HolKernel sortingTheory -val binop = - HolKernel.syntax_fns "sorting" 2 HolKernel.dest_binop HolKernel.mk_binop - -val triop = - HolKernel.syntax_fns "sorting" 3 HolKernel.dest_triop HolKernel.mk_triop - -val quadop = - HolKernel.syntax_fns "sorting" 4 HolKernel.dest_quadop HolKernel.mk_quadop +val binop = HolKernel.syntax_fns2 "sorting" +val triop = HolKernel.syntax_fns3 "sorting" +val quadop = HolKernel.syntax_fns4 "sorting" val (perm_tm, mk_perm, dest_perm, is_perm) = binop "PERM" val (sorted_tm, mk_sorted, dest_sorted, is_sorted) = binop "SORTED" diff --git a/src/string/ASCIInumbersSyntax.sml b/src/string/ASCIInumbersSyntax.sml index f7079a46f8..151ea0990e 100644 --- a/src/string/ASCIInumbersSyntax.sml +++ b/src/string/ASCIInumbersSyntax.sml @@ -7,14 +7,9 @@ open Abbrev HolKernel ASCIInumbersTheory (* Helper functions *) (*---------------------------------------------------------------------------*) -val monop = - HolKernel.syntax_fns "ASCIInumbers" 1 HolKernel.dest_monop HolKernel.mk_monop - -val binop = - HolKernel.syntax_fns "ASCIInumbers" 2 HolKernel.dest_binop HolKernel.mk_binop - -val triop = - HolKernel.syntax_fns "ASCIInumbers" 3 HolKernel.dest_triop HolKernel.mk_triop +val monop = HolKernel.syntax_fns1 "ASCIInumbers" +val binop = HolKernel.syntax_fns2 "ASCIInumbers" +val triop = HolKernel.syntax_fns3 "ASCIInumbers" val (hex_tm,mk_hex,dest_hex,is_hex) = monop "HEX" val (unhex_tm,mk_unhex,dest_unhex,is_unhex) = monop "UNHEX" diff --git a/src/string/stringSyntax.sml b/src/string/stringSyntax.sml index 8459cfe143..fe4bd4ebfd 100644 --- a/src/string/stringSyntax.sml +++ b/src/string/stringSyntax.sml @@ -14,11 +14,8 @@ val ERR = Feedback.mk_HOL_ERR "stringSyntax"; val char_ty = Type.mk_thy_type {Tyop = "char", Thy = "string", Args = []} val string_ty = Type.mk_thy_type {Tyop = "list", Thy = "list", Args = [char_ty]} -val monop = - HolKernel.syntax_fns "string" 1 HolKernel.dest_monop (Lib.curry Term.mk_comb) - -val binop = - HolKernel.syntax_fns "string" 2 HolKernel.dest_binop HolKernel.mk_binop +val monop = HolKernel.syntax_fns1 "string" +val binop = HolKernel.syntax_fns2 "string" val (chr_tm,mk_chr,dest_chr,is_chr) = monop "CHR" val (ord_tm,mk_ord,dest_ord,is_ord) = monop "ORD" diff --git a/src/sum/sumSyntax.sml b/src/sum/sumSyntax.sml index b00c595a11..53ad35f8ae 100644 --- a/src/sum/sumSyntax.sml +++ b/src/sum/sumSyntax.sml @@ -35,7 +35,7 @@ fun mk_sum_case (f, g, s) = (inst [alpha |-> r, beta |-> df, gamma |-> dg] sum_case_tm, [s, f, g]) end -val monop = HolKernel.syntax_fns "sum" 1 HolKernel.dest_monop HolKernel.mk_monop +val monop = HolKernel.syntax_fns1 "sum" val (isl_tm, mk_isl, dest_isl, is_isl) = monop "ISL" val (isr_tm, mk_isr, dest_isr, is_isr) = monop "ISR" @@ -43,22 +43,24 @@ val (outl_tm, mk_outl, dest_outl, is_outl) = monop "OUTL" val (outr_tm, mk_outr, dest_outr, is_outr) = monop "OUTR" val (inl_tm, mk_inl, dest_inl, is_inl) = - HolKernel.syntax_fns "sum" 1 - (fn tm1 => fn e => fn t => - (HolKernel.dest_monop tm1 e t, snd (dest_sum (type_of t)))) - (fn tm => fn (t, ty) => - Term.mk_comb - (Term.inst [Type.alpha |-> type_of t, Type.beta |-> ty] tm, t)) - "INL" + HolKernel.syntax_fns + {n = 1, + dest = fn tm1 => fn e => fn t => + (HolKernel.dest_monop tm1 e t, snd (dest_sum (type_of t))), + make = fn tm => fn (t, ty) => + Term.mk_comb + (Term.inst [Type.alpha |-> type_of t, Type.beta |-> ty] tm, t)} + "sum" "INL" val (inr_tm, mk_inr, dest_inr, is_inr) = - HolKernel.syntax_fns "sum" 1 - (fn tm1 => fn e => fn t => - (HolKernel.dest_monop tm1 e t, fst (dest_sum (type_of t)))) - (fn tm => fn (t, ty) => - Term.mk_comb - (Term.inst [Type.alpha |-> ty, Type.beta |-> type_of t] tm, t)) - "INR" + HolKernel.syntax_fns + {n = 1, + dest = fn tm1 => fn e => fn t => + (HolKernel.dest_monop tm1 e t, fst (dest_sum (type_of t))), + make = fn tm => fn (t, ty) => + Term.mk_comb + (Term.inst [Type.alpha |-> ty, Type.beta |-> type_of t] tm, t)} + "sum" "INR" (*---------------------------------------------------------------------------*) (* Lifting sums *) diff --git a/src/update/updateSyntax.sml b/src/update/updateSyntax.sml index 0e4c6cfb2a..f7345503ef 100644 --- a/src/update/updateSyntax.sml +++ b/src/update/updateSyntax.sml @@ -3,16 +3,12 @@ struct open Abbrev HolKernel updateTheory -val monop = - HolKernel.syntax_fns "update" 1 HolKernel.dest_monop - (Lib.curry boolSyntax.mk_icomb) +val monop = HolKernel.syntax_fns1 "update" +val binop = HolKernel.syntax_fns2 "update" val monop3 = - HolKernel.syntax_fns "update" 3 HolKernel.dest_monop - (Lib.curry boolSyntax.mk_icomb) - -val binop = - HolKernel.syntax_fns "update" 2 HolKernel.dest_binop HolKernel.mk_binop + HolKernel.syntax_fns {n = 3, dest = HolKernel.dest_monop, + make = Lib.curry boolSyntax.mk_icomb} "update" val (find_tm, mk_find, dest_find, is_find) = binop "FIND" From ddee89784f46e1a983614b090b8c9833687a788e Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Tue, 12 May 2015 11:57:46 +0100 Subject: [PATCH 304/718] L3 now supports the list update operation. --- examples/l3-machine-code/common/Import.sig | 1 + examples/l3-machine-code/common/Import.sml | 3 +++ examples/l3-machine-code/lib/L3.sig | 2 ++ examples/l3-machine-code/lib/L3.sml | 6 ++++++ 4 files changed, 12 insertions(+) diff --git a/examples/l3-machine-code/common/Import.sig b/examples/l3-machine-code/common/Import.sig index 570c3b8bd8..28184d79f7 100644 --- a/examples/l3-machine-code/common/Import.sig +++ b/examples/l3-machine-code/common/Import.sig @@ -62,6 +62,7 @@ sig | ToLower | ToUpper | Union + | Update | ValOf datatype binop = diff --git a/examples/l3-machine-code/common/Import.sml b/examples/l3-machine-code/common/Import.sml index 368e31e166..07f5588b30 100644 --- a/examples/l3-machine-code/common/Import.sml +++ b/examples/l3-machine-code/common/Import.sml @@ -511,6 +511,7 @@ datatype monop = | ToLower | ToUpper | Union + | Update | ValOf datatype binop = @@ -639,6 +640,7 @@ local val mk_ismember = mk_uncurry ``\(x:'a, l). x IN list$LIST_TO_SET l`` val mk_take = mk_uncurry ``\(x, l:'a list). list$TAKE x l`` val mk_drop = mk_uncurry ``\(x, l:'a list). list$DROP x l`` + val mk_update = mk_uncurry ``\(e, x, l:'a list). list$LUPDATE e x l`` val mk_element = mk_uncurry ``\(x, l:'a list). list$EL x l`` val mk_remove = mk_uncurry ``\(l1, l2). list$FILTER (\x. ~MEM x l1) l2`` val mk_remove_e = mk_uncurry ``\(l1, l2). list$FILTER (\x. MEM x l1) l2`` @@ -980,6 +982,7 @@ in | ToLower => mk_lower | ToUpper => mk_upper | Union => mk_union + | Update => mk_update | ValOf => optionSyntax.mk_the | _ => mk_fp_triop m ) x diff --git a/examples/l3-machine-code/lib/L3.sig b/examples/l3-machine-code/lib/L3.sig index 09a5222d29..33f7970621 100644 --- a/examples/l3-machine-code/lib/L3.sig +++ b/examples/l3-machine-code/lib/L3.sig @@ -15,6 +15,7 @@ sig val indexOfString : char * string -> int option val fst : 'a * 'b -> 'a val listCompare : ('a * 'a -> order) -> 'a list * 'a list -> order + val listUpdate : 'a * (int * 'a list) -> 'a list val lowercase : string -> string val memString : char * string -> bool val padLeft : 'a * (int * 'a list) -> 'a list @@ -36,6 +37,7 @@ sig val strHd : string -> char val strTl : string -> string val stringToChar : string -> char + val stringUpdate : char * (int * string) -> string val swap : 'a * 'b -> 'b * 'a val take : int * 'a list -> 'a list val takeString : int * string -> string diff --git a/examples/l3-machine-code/lib/L3.sml b/examples/l3-machine-code/lib/L3.sml index 24fd0831eb..ecfb0da009 100644 --- a/examples/l3-machine-code/lib/L3.sml +++ b/examples/l3-machine-code/lib/L3.sml @@ -61,6 +61,10 @@ struct fun splitr (p, s) = liftSubstring (Substring.splitr p, s) end + fun listUpdate (e, (i, [])) = [] + | listUpdate (e, (0, _::l)) = e::l + | listUpdate (e, (n, h::l)) = h :: listUpdate (e, (n - 1, l)) + fun padLeft (e, (n, l)) = List.tabulate (Nat.- (n, List.length l), fn _ => e) @ l fun padRight (e, (n, l)) = @@ -74,6 +78,8 @@ struct fun stringToChar s = if String.size s = 1 then String.sub (s, 0) else raise Domain fun memString (c, s) = String.isSubstring (String.str c) s + fun stringUpdate (e, (i, s)) = + String.implode (listUpdate (e, (i, String.explode s))) local fun trans P (s, r) = From 823cfb09236b4f32a0fe889af3bc99f8de8b021a Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 18 May 2015 16:24:32 +1000 Subject: [PATCH 305/718] Better errors when use can't make a .HOLMK dir --- tools-poly/poly/poly-init2.ML | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/tools-poly/poly/poly-init2.ML b/tools-poly/poly/poly-init2.ML index 03ad83636b..7c0a4bacf0 100644 --- a/tools-poly/poly/poly-init2.ML +++ b/tools-poly/poly/poly-init2.ML @@ -44,7 +44,9 @@ fun quse s = let else FS.mkDir ".HOLMK" handle OS.SysErr (msg, _) => - die ("Couldn't make .HOLMK directory: "^msg) + die ("While using " ^ s ^ + ", couldn't make .HOLMK directory in " ^ + FS.getDir() ^ ": " ^ msg) fun holtemp s = (mkHOLMK(); OS.Path.concat(".HOLMK", OS.Path.file s)) val _ = if FS.access (s, [FS.A_READ]) then () From 65aec315985f4acc4a52db228ad6169e8e998cc9 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Mon, 18 May 2015 21:54:13 +0100 Subject: [PATCH 306/718] define a map function on sptrees plus a few simple properties --- src/patricia/sptreeScript.sml | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/src/patricia/sptreeScript.sml b/src/patricia/sptreeScript.sml index d7e1fbcd4a..52b3dfeb4f 100644 --- a/src/patricia/sptreeScript.sml +++ b/src/patricia/sptreeScript.sml @@ -1120,4 +1120,25 @@ val fromAList_toAList = store_thm("fromAList_toAList", ``!t. wf t ==> (fromAList (toAList t) = t)``, metis_tac[wf_fromAList,lookup_fromAList_toAList,spt_eq_thm]) +val map_def = Define` + (map f LN = LN) /\ + (map f (LS a) = (LS (f a))) /\ + (map f (BN t1 t2) = BN (map f t1) (map f t2)) /\ + (map f (BS t1 a t2) = BS (map f t1) (f a) (map f t2))` + +val toList_map = store_thm("toList_map", + ``∀s. toList (map f s) = MAP f (toList s)``, + Induct >> + fs[toList_def,map_def,toListA_def] >> + simp[Once toListA_append] >> + simp[Once toListA_append,SimpRHS]) + +val domain_map = store_thm("domain_map", + ``∀s. domain (map f s) = domain s``, + Induct >> simp[map_def]) + +val lookup_map = store_thm("lookup_map", + ``∀s x. lookup x (map f s) = OPTION_MAP f (lookup x s)``, + Induct >> simp[map_def,lookup_def] >> rw[]) + val _ = export_theory(); From 7b0adeb778318835dd43066e950409292dbd80e4 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 21 May 2015 12:28:45 +1000 Subject: [PATCH 307/718] =?UTF-8?q?Tweak=20thms=20on=20link=20between=20?= =?UTF-8?q?=CE=BB-calc=20and=20rec.=20fns?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../computability/lambda/prtermScript.sml | 32 +++++++++++++++++-- examples/computability/recursivefnsScript.sml | 17 +++++++--- 2 files changed, 42 insertions(+), 7 deletions(-) diff --git a/examples/computability/lambda/prtermScript.sml b/examples/computability/lambda/prtermScript.sml index 006f6b6f0b..deb5b06dc9 100644 --- a/examples/computability/lambda/prtermScript.sml +++ b/examples/computability/lambda/prtermScript.sml @@ -5,6 +5,8 @@ open enumerationsTheory primrecfnsTheory open rich_listTheory arithmeticTheory open reductionEval churchnumTheory churchboolTheory +open lcsymtacs + fun Store_thm (trip as (n,t,tac)) = store_thm trip before export_rewrites [n] val _ = new_theory "prterm" @@ -1407,13 +1409,31 @@ val recfn_recPhi = Store_thm( SRW_TAC [][primrec_recfn] THEN intro primrec_recfn THEN SRW_TAC [][primrec_rules]); -val recPhi_correct = Store_thm( +val recfn_recPhi_applied = Store_thm( + "recfn_recPhi_applied", + ``recfn (recPhi o CONS i) 1``, + `recPhi o CONS i = recCn recPhi [K (SOME i); SOME o proj 0]` + suffices_by (simp[] >> strip_tac >> + FIRST (map irule (CONJUNCTS recfn_rules)) >> + simp[recfn_recPhi, recfn_rules]) >> + simp[FUN_EQ_THM, recCn_def] >> simp[recPhi_def, recCn_def]); + + +val recPhi_correct = store_thm( "recPhi_correct", ``recPhi [i; n] = Phi i n``, SRW_TAC [][Phi_def, recPhi_def, recCn_def, LET_THM] THEN Cases_on `bnf_of (toTerm (numdB i) @@ church n)` THEN FULL_SIMP_TAC (srw_ss()) []); +val recPhi_rec2Phi = store_thm( + "recPhi_rec2Phi[simp]", + ``recPhi = rec2 Phi``, + simp[FUN_EQ_THM] >> Cases + >- simp[recPhi_def, recCn_def, GSYM recPhi_correct] >> + qcase_tac `recPhi (h::rest)` >> Cases_on `rest` >> + simp[recPhi_def, recCn_def, GSYM recPhi_correct]) + (* the other way - every recursive function can be emulated in the λ-calculus *) val cnel_def = Define` cnel = @@ -1737,7 +1757,6 @@ val crecPr_cons0 = store_thm( cnhd_behaviour, cntl_behaviour, natrec_behaviour, cchurch_behaviour]); -open lcsymtacs val crecPr_consSUC = store_thm( "crecPr_consSUC", ``bnf_of (crecPr @@ church b @@ church s @@ church (nlist_of (SUC n::t))) = @@ -2100,4 +2119,13 @@ val recfns_in_Phi = store_thm( first_x_assum (Q.SPEC_THEN `n` MP_TAC) >> srw_tac [ARITH_ss][] ]); +(* "universal machine index" *) +val UMi_def = new_specification( + "UMi_def", ["UMi"], + MATCH_MP recfns_in_Phi recfn_recPhi |> SIMP_RULE (srw_ss()) []) + +val UMi_works = save_thm( + "UMi_works", + UMi_def |> Q.SPEC `[m;n]` |> SIMP_RULE (srw_ss()) [SimpRHS]); + val _ = export_theory() diff --git a/examples/computability/recursivefnsScript.sml b/examples/computability/recursivefnsScript.sml index 534847e945..e15da645dd 100644 --- a/examples/computability/recursivefnsScript.sml +++ b/examples/computability/recursivefnsScript.sml @@ -3,6 +3,8 @@ open HolKernel Parse boolLib bossLib open listTheory rich_listTheory open primrecfnsTheory +open lcsymtacs + val _ = new_theory "recursivefns" val minimise_def = Define` @@ -71,11 +73,16 @@ val totalrec_def = Define` totalrec f n = recfn f n ∧ ∀l. (LENGTH l = n) ⇒ ∃m. f l = SOME m `; +val rec2_def = Define` + (rec2 f [] = f 0 0 : num option) ∧ + (rec2 f [x] = f x 0) ∧ + (rec2 f (x::y::t) = f x y) +`; +val _ = export_rewrites ["rec2_def"] - - - - - +val recfn_K = store_thm( + "recfn_K[simp]", + ``recfn (K (SOME i)) 1``, + `recfn (SOME o K i) 1` by simp[primrec_recfn] >> fs[]); val _ = export_theory() From 70ecb60975779b8785d9bfacfb32c06b20f366d7 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 22 May 2015 11:31:45 +1000 Subject: [PATCH 308/718] Document the .PHONY target. Closes #256 --- Manual/Description/misc.tex | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/Manual/Description/misc.tex b/Manual/Description/misc.tex index 03e6f9ee2f..2039ac7c59 100644 --- a/Manual/Description/misc.tex +++ b/Manual/Description/misc.tex @@ -505,6 +505,15 @@ \subsection{Using a make-file with \holmake} comments on command-lines, and such ``comments'' will be passed to the shell, which may or may not treat them as comments when it sees them. +\paragraph{Special Targets} +Some target names for rules are handled specially by \holmake{}: +\begin{itemize} +\item Dependencies associated with the target name \texttt{.PHONY} are taken to be list of other targets in the make-file that are not actually the name of files to be built. +For example, targets naming conceptual collections of files such as \texttt{all} should be marked as ``phony''. +If a target is phony, then its dependencies will be built even if a file of that name exists and is newer than the dependencies. +\item The special way that command-line arguments \texttt{clean}, \texttt{cleanAll} and \texttt{cleanDeps} are handled means that targets of those names will not work. +In order to extend cleaning behaviour, use the \texttt{EXTRA\_CLEANS} variable (see below). +\end{itemize} \paragraph{Functions} \index{Holmake@\holmake!functions for text-manipulation} \holmake{} supports some simple functions for manipulating text. All From 8ba29cb7eb83f272c3abfd20c8bc289cad015b95 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 22 May 2015 13:56:37 +1000 Subject: [PATCH 309/718] Add COMB2_CONV to Conv structure. This is an import from HOL Light, changed only to handle the UNCHANGED exception appropriately. In passing, update COMB_CONV documentation to * mention COMB2_CONV as a see also; * close a parenthesised aside; * describe its behaviour in the face of UNCHANGED --- help/Docfiles/Conv.COMB2_CONV.doc | 37 +++++++++++++++++++++++++++++++ help/Docfiles/Conv.COMB_CONV.doc | 9 ++++++-- src/1/Conv.sig | 1 + src/1/Conv.sml | 10 +++++---- 4 files changed, 51 insertions(+), 6 deletions(-) create mode 100644 help/Docfiles/Conv.COMB2_CONV.doc diff --git a/help/Docfiles/Conv.COMB2_CONV.doc b/help/Docfiles/Conv.COMB2_CONV.doc new file mode 100644 index 0000000000..55b427e46d --- /dev/null +++ b/help/Docfiles/Conv.COMB2_CONV.doc @@ -0,0 +1,37 @@ +\DOC + +\TYPE {COMB2_CONV : conv * conv -> conv} + +\SYNOPSIS +Applies two conversions to an application's subterms. + +\KEYWORDS +rewriting. + +\DESCRIBE + +A call to {COMB2_CONV(c1,c2) t}, when {t} is an application term of +the form {f x}, causes conversion {c1} to be applied to term {f}, and +conversion {c2} to be applied to term {x}. If the results of these +calls are theorems of the form {|- f = f’} and {|- x = x’}, then the +result of the call to {COMB2_CONV} is the theorem {|- f x = f’ x’}. + +If one of the two sub-calls raises the {UNCHANGED} exception, then the +result of that call is taken to be the reflexive theorem ({|- x = x} +if {c2} raises the exception, for example). If both conversions raise +the {UNCHANGED} exception, then so too does {COMB2_CONV(c1,c2) t}. + +\FAILURE +Fails if the term is not a combination term, or if either conversion fails when applied to the respective sub-terms. + +\EXAMPLE +{ +> COMB2_CONV (ALL_CONV, numLib.REDUCE_CONV) ``f (10 * 3)``; +<> +val it = |- f (10 * 3) = f 30 : thm +} + +\SEEALSO +Conv.ABS_CONV, Conv.COMB_CONV, Conv.FORK_CONV, Conv.RAND_CONV, Conv.RATOR_CONV. + +\ENDDOC diff --git a/help/Docfiles/Conv.COMB_CONV.doc b/help/Docfiles/Conv.COMB_CONV.doc index b5e64721ec..f85f12a0e8 100644 --- a/help/Docfiles/Conv.COMB_CONV.doc +++ b/help/Docfiles/Conv.COMB_CONV.doc @@ -13,13 +13,18 @@ If {t} is an application term of the form {f x}, and {c} is a conversion, such that {c} maps {f} to {|- f = f'} and {x} to {|- x = x'}, then {COMB_CONV c} maps {t} to {|- f x = f' x'}. +If one of the two sub-calls raises the {UNCHANGED} exception, then the +result of that call is taken to be the reflexive theorem ({|- x = x} +if {c x} raises the exception, for example). If both conversions raise +the {UNCHANGED} exception, then so too does {COMB_CONV c t}. + \FAILURE {COMB_CONV c t} fails if {t} is not an application term, or if {c} fails when applied to the rator and rand of {t}, or if {c} is not in fact a conversion (i.e., a function which maps terms {t} to a theorem -{|- t = t'}. +{|- t = t'}). \SEEALSO -Conv.ABS_CONV, Conv.SUB_CONV. +Conv.ABS_CONV, Conv.COMB2_CONV, Conv.SUB_CONV. \ENDDOC diff --git a/src/1/Conv.sig b/src/1/Conv.sig index a2c8d783e1..efab3b16b5 100644 --- a/src/1/Conv.sig +++ b/src/1/Conv.sig @@ -12,6 +12,7 @@ sig val RATOR_CONV : conv -> conv val ABS_CONV : conv -> conv val COMB_CONV : conv -> conv + val COMB2_CONV : conv * conv -> conv val FORK_CONV : conv * conv -> conv val BINOP_CONV : conv -> conv val EVERY_DISJ_CONV : conv -> conv diff --git a/src/1/Conv.sml b/src/1/Conv.sml index c94e300e60..48482777fa 100644 --- a/src/1/Conv.sml +++ b/src/1/Conv.sml @@ -265,18 +265,20 @@ fun REPEATC conv tm = fun TRY_CONV conv = conv ORELSEC ALL_CONV -fun COMB_CONV conv tm = +fun COMB2_CONV (c1,c2) tm = let val {Rator, Rand} = dest_comb tm in let - val th = conv Rator + val th = c1 Rator in - MK_COMB (th, conv Rand) handle UNCHANGED => AP_THM th Rand + MK_COMB (th, c2 Rand) handle UNCHANGED => AP_THM th Rand end - handle UNCHANGED => AP_TERM Rator (conv Rand) + handle UNCHANGED => AP_TERM Rator (c2 Rand) end +fun COMB_CONV c = COMB2_CONV(c,c) + fun SUB_CONV conv = TRY_CONV (COMB_CONV conv ORELSEC ABS_CONV conv) fun FORK_CONV (conv1, conv2) tm = From ecf69c5b1e26ee0b9e911bb28e373c8fe5e2c821 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 22 May 2015 13:59:11 +1000 Subject: [PATCH 310/718] Record hol.builder0 heap's dependency on Conv.uo --- src/proofman/Holmakefile | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/proofman/Holmakefile b/src/proofman/Holmakefile index ba75ead74e..c6f757f337 100644 --- a/src/proofman/Holmakefile +++ b/src/proofman/Holmakefile @@ -20,7 +20,8 @@ DEPS = $(BOOLLIB) $(BOOLTHEORY) $(PRIMREC) $(TERMPP) \ $(dprot $(SIGOBJ)/type_pp.uo) \ $(dprot $(SIGOBJ)/ParseExtras.uo) \ $(dprot $(SIGOBJ)/Drule.uo) \ - $(dprot $(SIGOBJ)/TheoryPP.uo) + $(dprot $(SIGOBJ)/TheoryPP.uo) \ + $(dprot $(SIGOBJ)/Conv.uo) EXTRA_CLEANS = $(TARGET) From 1a41e14807f206645951310e7ffad71483fe4d7c Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 22 May 2015 14:29:38 +1000 Subject: [PATCH 311/718] Implement HOL Light's {PAT,PATH}_CONV. Closes #255 --- doc/next-release.md | 2 ++ help/Docfiles/Conv.PATH_CONV.doc | 40 +++++++++++++++++++++++++++ help/Docfiles/Conv.PAT_CONV.doc | 47 ++++++++++++++++++++++++++++++++ src/1/Conv.sig | 2 ++ src/1/Conv.sml | 30 ++++++++++++++++++++ 5 files changed, 121 insertions(+) create mode 100644 help/Docfiles/Conv.PATH_CONV.doc create mode 100644 help/Docfiles/Conv.PAT_CONV.doc diff --git a/doc/next-release.md b/doc/next-release.md index bec5904ee8..ad3f05a6d9 100644 --- a/doc/next-release.md +++ b/doc/next-release.md @@ -20,6 +20,8 @@ Contents New features: ------------- +- We have ported HOL Light’s `PAT_CONV` and `PATH_CONV` “conversionals”, providing nice machinery for applying conversions to specific sub-terms. + Bugs fixed: ----------- diff --git a/help/Docfiles/Conv.PATH_CONV.doc b/help/Docfiles/Conv.PATH_CONV.doc new file mode 100644 index 0000000000..bbd222edab --- /dev/null +++ b/help/Docfiles/Conv.PATH_CONV.doc @@ -0,0 +1,40 @@ +\DOC + +\TYPE {PATH_CONV : string -> conv -> conv} + +\SYNOPSIS +Applies a conversion to the subterm indicated by a path string. + +\KEYWORDS +rewriting + +\DESCRIBE + +A call to {PATH_CONV p c} returns a new conversion that applies {c} to +the subterm of a term identified by the path string {p}. This path +string is interpreted as a sequence of direction indications: {"a"}: +take the body of an abstraction; {"b"}: take the body of an abstraction +or binder (such as universal or existential quantification); {"l"}: take +the left (rator) path in an application; {"r"}: take the right (rand) +path in an application. + +\FAILURE +The call to the path string and conversion fails if the provided string includes characters other than {a}, {b}, {l} or {r}. When applied to a term the resulting conversion will fail if the path is not meaningful or if the conversion itself fails on the indicated subterm. + +\EXAMPLE +{ +> PATH_CONV "lrr" numLib.REDUCE_CONV ``(1 + 2) + (3 + 4) + (5 + 6)``; +val it = |- 1 + 2 + (3 + 4) + (5 + 6) = 1 + 2 + 7 + (5 + 6) : thm + +> PATH_CONV "br" numLib.REDUCE_CONV ``!x. x > 10 + 3``; +val it = |- (!x. x > 10 + 3) <=> !x. x > 13 : thm +} + +\COMMENTS +This function provides a more concise indication of sub-conversion +application than by composing {RATOR_CONV}, {RAND_CONV} and {ABS_CONV}. + +\SEEALSO +Conv.ABS_CONV, Conv.BINDER_CONV, Conv.RAND_CONV, Conv.RATOR_CONV. + +\ENDDOC diff --git a/help/Docfiles/Conv.PAT_CONV.doc b/help/Docfiles/Conv.PAT_CONV.doc new file mode 100644 index 0000000000..193eb91e8f --- /dev/null +++ b/help/Docfiles/Conv.PAT_CONV.doc @@ -0,0 +1,47 @@ +\DOC + +\TYPE {PAT_CONV : term -> conv -> conv} + +\SYNOPSIS +Applies a conversion at specific sub-terms, following a pattern + +\KEYWORDS +rewriting + +\DESCRIBE +The call {PAT_CONV ``\x1 ... xn. t[x1,...,xn]`` cnv} returns a new +conversion that applies {cnv} to subterms of the target term +corresponding to the free instances of any {xi} in the pattern +{t[x1,...,xn]}. The fact that the pattern is a function has no logical +significance; it is just used as a convenient format for the pattern. + + +\FAILURE +Never fails until applied to a term, but then it may fail if the core conversion does on the chosen subterms, or if the pattern doesn’t match the structure of the term. + + +\EXAMPLE +Here we choose to evaluate just two subterms: +{ + > PAT_CONV ``\x. x + a + x`` numLib.REDUCE_CONV + ``(1 + 2) + (3 + 4) + (5 + 6)``; + val it : thm = |- 1 + 2 + (3 + 4) + (5 + 6) = 3 + (3 + 4) + 11 +} +while here we swap two particular quantifiers in a long chain: +{ + > PAT_CONV ``\x. !x1 x2 x3 x4 x5. x`` SWAP_FORALL_CONV + ``!a b c d e f g h. something`` + <> + val it = + |- (!a b c d e f g h. something) <=> + !a b c d e g f h. something: thm +} + +\COMMENTS +Multiple bound variables will only be necessary if the conversion +needs to be applied to sub-terms of different types. + +\SEEALSO +Conv.ABS_CONV, Conv.COMB_CONV, Conv.PATH_CONV, Conv.RAND_CONV, Conv.RATOR_CONV, Conv.SUB_CONV. + +\ENDDOC diff --git a/src/1/Conv.sig b/src/1/Conv.sig index efab3b16b5..9a5ebf66b7 100644 --- a/src/1/Conv.sig +++ b/src/1/Conv.sig @@ -108,6 +108,8 @@ sig val AC_CONV : thm * thm -> conv val GSYM : thm -> thm val RENAME_VARS_CONV : string list -> conv + val PAT_CONV : term -> conv -> conv val PRINT_CONV : conv val MAP_THM : conv -> thm -> thm + val PATH_CONV : string -> conv -> conv end diff --git a/src/1/Conv.sml b/src/1/Conv.sml index 48482777fa..099dafb1fa 100644 --- a/src/1/Conv.sml +++ b/src/1/Conv.sml @@ -2446,4 +2446,34 @@ in handle HOL_ERR _ => raise ERR "MAP_THM" "" end +val PAT_CONV = let + fun PCONV (xs, pat) conv = + if mem pat xs then conv + else if not(exists (fn x => free_in x pat) xs) then ALL_CONV + else if is_comb pat then + COMB2_CONV (PCONV (xs, rator pat) conv, PCONV (xs, rand pat) conv) + else + ABS_CONV (PCONV (xs, body pat) conv) +in + fn pat => PCONV (strip_abs pat) +end + +fun PATH_CONV path c = + let + val limit = size path + fun recurse i = + if i = limit then c + else + case String.sub(path, i) of + #"a" => ABS_CONV (recurse (i + 1)) + | #"b" => BINDER_CONV (recurse (i + 1)) + | #"l" => RATOR_CONV (recurse (i + 1)) + | #"r" => RAND_CONV (recurse (i + 1)) + | c => raise ERR + "PATH_CONV" + ("Illegal character '"^str c^ "' in path") + in + recurse 0 + end + end (* Conv *) From 1fffd4b27e1badf94c3028bfec1239f2573bf726 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 25 May 2015 15:48:21 +1000 Subject: [PATCH 312/718] Define a very simple precedence-parser constant. I think there should be soundness and completeness results possible for this constant wrt CFGs that encode the right sort of grammar. --- examples/parsing/precparserScript.sml | 179 ++++++++++++++++++++++++++ 1 file changed, 179 insertions(+) create mode 100644 examples/parsing/precparserScript.sml diff --git a/examples/parsing/precparserScript.sml b/examples/parsing/precparserScript.sml new file mode 100644 index 0000000000..f392d6cf6e --- /dev/null +++ b/examples/parsing/precparserScript.sml @@ -0,0 +1,179 @@ +open HolKernel Parse boolLib bossLib; + +open optionTheory listTheory +open finite_mapTheory + +open lcsymtacs + +(* simple (infixes + function application via juxtaposition) precedence + parser + + This is all that is needed to handle the precedence parsing done by + SML, where one can assume that handling of parentheses has already + been done, and there are only binary infixes to worry about. + +*) + +val _ = new_theory "precparser"; + +val _ = ParseExtras.tight_equality() + +val bool_case_eq = prove_case_eq_thm{ + case_def= TypeBase.case_def_of ``:bool``, + nchotomy = TypeBase.nchotomy_of ``:bool`` +}; + +val option_case_eq = prove_case_eq_thm{ + case_def= option_case_def, + nchotomy = option_CASES + |> ONCE_REWRITE_RULE [DISJ_COMM] +}; + +val sum_case_eq = prove_case_eq_thm { + case_def = sumTheory.sum_case_def, + nchotomy = sumTheory.sum_CASES +}; + +val list_case_eq = prove_case_eq_thm{ + case_def = listTheory.list_case_def, + nchotomy = listTheory.list_CASES +}; + + + +val _ = Datatype`tokrel = Reduce | Shift` + +val tokrel_case_eq = prove_case_eq_thm { + case_def = theorem "tokrel_case_def", + nchotomy = theorem "tokrel_nchotomy" +}; + +val _ = Datatype` + pMachine = <| rules : 'tok # 'tok |-> tokrel ; (* stk tok # strm tok *) + reduce : 'trm -> 'tok -> 'trm -> 'trm ; + lift : 'tok -> 'trm ; + isOp : 'tok -> bool ; + mkApp : 'trm -> 'trm -> 'trm |> +`; + + +(* stack is list of tokens + terms *) +val precparse1_def = Define` + precparse1 pM (stk, strm) = + case strm of + [] => + (case stk of + INR tm2 :: INL opn :: INR tm1 :: rest => + SOME(INR (pM.reduce tm1 opn tm2) :: rest, []) + | _ => NONE) + | tok :: strm_rest => + if pM.isOp tok then + case stk of + INR tm2 :: INL opn :: INR tm1 :: stk_rest => + (case FLOOKUP pM.rules (opn, tok) of + SOME Shift => + SOME(INL tok :: INR tm2 :: INL opn :: INR tm1 :: stk_rest, + strm_rest) + | SOME Reduce => + SOME(INR (pM.reduce tm1 opn tm2) :: stk_rest, + tok :: strm_rest) + | NONE => NONE) + | [INR tm] => SOME([INL tok; INR tm], strm_rest) + | _ => NONE + else + case stk of + [] => SOME([INR (pM.lift tok)], strm_rest) + | INR ftm :: stk_rest => + SOME(INR (pM.mkApp ftm (pM.lift tok)) :: stk_rest, strm_rest) + | INL _ :: _ => SOME(INR (pM.lift tok) :: stk, strm_rest) +`; + +val wfStk_def = Define` + (wfStk [] ⇔ T) ∧ + (wfStk [INR _] ⇔ T) ∧ + (wfStk [INL _] ⇔ F) ∧ + (wfStk (INL _ :: INR tm :: rest) ⇔ wfStk (INR tm :: rest)) ∧ + (wfStk (INR _ :: INL t :: rest) ⇔ wfStk (INL t :: rest)) ∧ + (wfStk _ ⇔ F) +`; +val _ = export_rewrites ["wfStk_def"] + +val wfStk_ignores_hdvalues = store_thm( + "wfStk_ignores_hdvalues[simp]", + ``wfStk (INL l::t) = wfStk (INL ARB :: t) ∧ + wfStk (INR r::t) = wfStk (INR ARB :: t)``, + Cases_on `t` >> simp[] >> qcase_tac `wfStk (INL ARB :: el2 :: tl)` >> + Cases_on `el2` >> simp[]); + +val precparse1_preserves_wfStk = store_thm( + "precparse1_preserves_wfStk", + ``wfStk stk0 ∧ precparse1 pM (stk0, strm0) = SOME (stk, strm) ⇒ + wfStk stk``, + Cases_on `strm0` >> Cases_on `stk0` >> + dsimp[precparse1_def, list_case_eq, sum_case_eq, bool_case_eq, + option_case_eq, tokrel_case_eq] >> + rw[] >> fs[]); + +val LT_SUC = store_thm( + "LT_SUC", + ``x < SUC y ⇔ (x = 0) ∨ ∃m. x = SUC m ∧ m < y``, + Cases_on `x` >> simp[]); + +val wfStk_ALT = store_thm( + "wfStk_ALT", + ``wfStk l ⇔ (l ≠ [] ⇒ ∀opn. LAST l ≠ INL opn) ∧ + (∀i. i + 1 < LENGTH l ⇒ ISR (EL i l) ≠ ISR (EL (i + 1) l))``, + Induct_on `l` >> simp[] >> Cases >> simp[] >> qcase_tac `wfStk (_ :: stk)` >> + Cases_on `stk` >> simp[] >> fs[] >> qcase_tac `wfStk (_ :: el2 :: stk)` >> + Cases_on `el2` >> simp[] >- (disj2_tac >> qexists_tac `0` >> simp[]) >> + simp[DECIDE ``x + 1 < SUC y ⇔ x < y``] >> + dsimp[LT_SUC, DECIDE ``x + 1 = SUC x``]) + +val precparse1_reduces = store_thm( + "precparse1_reduces", + ``precparse1 pM (stk0,strm0) = SOME (stk,strm) ⇒ + LENGTH strm < LENGTH strm0 ∨ strm = strm0 ∧ LENGTH stk < LENGTH stk0``, + Cases_on `strm0` >> Cases_on `stk0` >> + dsimp[precparse1_def, list_case_eq, sum_case_eq, bool_case_eq, + option_case_eq, tokrel_case_eq] >> rw[] >> simp[]); + +val isFinal_def = Define` + (isFinal ([INR _],[]) ⇔ T) ∧ + (isFinal _ ⇔ F) +`; +val _ = export_rewrites ["isFinal_def"] + + +val precparse_def = tDefine "precparse" ` + precparse pM (stk0,strm0) = + if isFinal (stk0,strm0) then SOME (OUTR (HD stk0)) + else + case precparse1 pM (stk0, strm0) of + NONE => NONE + | SOME (stk, strm) => precparse pM (stk, strm) +` (WF_REL_TAC + `inv_image (measure LENGTH LEX measure LENGTH) (λ(_,y,z). (z,y))` >> + metis_tac[precparse1_reduces]); + +(* test case +local open stringTheory in end +val _ = Datatype`ast = Plus ast ast | Times ast ast | App ast ast | C char` +val fm = ``FEMPTY |+ ((#"+",#"*"), Shift) |+ ((#"*",#"+"), Reduce) + |+ ((#"+",#"+"), Reduce) |+ ((#"*",#"*"), Reduce)`` + +val isOp = ``λc. c = #"*" ∨ c = #"+"`` +val reduce = ``λtm1 c tm2. if c = #"*" then Times tm1 tm2 else Plus tm1 tm2`` +val lift = ``C`` + +val m = ``<| rules := ^fm ; + reduce := ^reduce ; + lift := C; + isOp := ^isOp; + mkApp := App |>`` + +EVAL ``precparse ^m ([],"3*fx*7+9")``; +EVAL ``precparse ^m ([],"3+fx*7+9")``; +EVAL ``precparse ^m ([],"3++7")`` (* fails *); +*) + +val _ = export_theory(); From 543e8590bdec82ae27ad5196a4cb85e299bca930 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 26 May 2015 09:17:12 +1000 Subject: [PATCH 313/718] Tidy up Datatype selftest --- src/datatype/selftest.sml | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/src/datatype/selftest.sml b/src/datatype/selftest.sml index 1293039dc6..8d445f19d1 100644 --- a/src/datatype/selftest.sml +++ b/src/datatype/selftest.sml @@ -188,7 +188,7 @@ val _ = Hol_datatype `u3 = d3 of u4 u2 u1 ; val _ = Hol_datatype `foo = fooC of 'a` val _ = Hol_datatype `foo = fooC' of num` -fun tprint s = print (StringCvt.padRight #" " 70 s) +open testutils val _ = tprint "Testing independence of case variables" val t = Lib.total Parse.Term `case (x:valbind) of @@ -201,7 +201,7 @@ val _ = case t of NONE => (print "FAILED!\n"; Process.exit Process.failure) val _ = set_trace "Unicode" 0 fun pptest (nm, t, expected) = let - val _ = tprint ("Testing pretty-printing of "^nm) + val _ = tprint ("Pretty-printing of "^nm) val s = Parse.term_to_string t in if s = expected then print "OK\n" @@ -240,13 +240,17 @@ val _ = List.app pptest ("overloaded var.fld with args", ``inv x``, "inv x") ] +val _ = Feedback.emit_MESG := false + (* a test for Hol_defn that requires a datatype: *) (* mutrec defs with sums *) +val _ = tprint "Mutrec defn with sums" val _ = Hol_datatype `foo = F1 of unit | F2 of foo + num` val _ = Defn.Hol_defn "foo"` (foo1 (F1 ()) = F1 ()) /\ (foo1 (F2 sf) = F2 (foo2 sf)) /\ (foo2 (INR n) = INL (F1 ())) /\ -(foo2 (INL f) = INL (foo1 f))` +(foo2 (INL f) = INL (foo1 f))` handle HOL_ERR _ => die "FAILED!" +val _ = print "OK\n" val _ = Process.exit Process.success; From 1e90aa92b679d2b9b2f760a4e5960e83660f8a71 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 26 May 2015 09:18:18 +1000 Subject: [PATCH 314/718] Datatype: qual-ids stop creation of recursive type Closes #257 --- doc/next-release.md | 8 ++++++++ src/datatype/Datatype.sml | 3 ++- src/datatype/selftest.sml | 10 ++++++++++ 3 files changed, 20 insertions(+), 1 deletion(-) diff --git a/doc/next-release.md b/doc/next-release.md index ad3f05a6d9..63d6ca7591 100644 --- a/doc/next-release.md +++ b/doc/next-release.md @@ -31,6 +31,14 @@ Bugs fixed: - `Holmake` will now follow `INCLUDES` specifications from `Holmakefiles` when given “phony” targets to build on the command-line. (A typical phony target is `all`.) As in the past, it will still act only locally if given just a clean target (`clean`, `cleanDeps` or `cleanAll`). To clean recursively, you must also pass the `-r` flag to `Holmake`. ([Github issue](http://github.com/HOL-Theorem-Prover/HOL/issues/145)) +- `Datatype` will no longer create a recursive type if the recursive instance is qualified with a theory name other than the current one. +In other words, + + Datatype`num = C1 num$num | C2` + + won’t create a recursive type (assuming this is not called in theory `num`). + Thanks to Ramana Kumar for the [bug report](http://github.com/HOL-Theorem-Prover/HOL/issues/257). + New theories: ------------- diff --git a/src/datatype/Datatype.sml b/src/datatype/Datatype.sml index bf0250d8c6..d98b9121d9 100644 --- a/src/datatype/Datatype.sml +++ b/src/datatype/Datatype.sml @@ -244,7 +244,8 @@ fun to_tyspecs ASTs = fun mk_hol_ty (dAQ ty) = ty | mk_hol_ty (dVartype s) = mk_vartype s | mk_hol_ty (dTyop{Tyop=s, Args, Thy}) = - if Lib.mem s new_type_names + if Lib.mem s new_type_names andalso + (Thy = NONE orelse Thy = SOME (current_theory())) then if null Args then tyname_as_tyvar s else raise ERR "to_tyspecs" ("Omit arguments to new type:"^Lib.quote s) diff --git a/src/datatype/selftest.sml b/src/datatype/selftest.sml index 8d445f19d1..738b0c0a18 100644 --- a/src/datatype/selftest.sml +++ b/src/datatype/selftest.sml @@ -253,4 +253,14 @@ val _ = Defn.Hol_defn "foo"` (foo2 (INL f) = INL (foo1 f))` handle HOL_ERR _ => die "FAILED!" val _ = print "OK\n" +val _ = tprint "Non-recursive num" +val _ = Datatype.Datatype `num = C10 num$num | C11 num | C12 scratch$num`; +val (d,r) = dom_rng (type_of ``C10``) +val _ = Type.compare(d, numSyntax.num) = EQUAL orelse die "FAILED!" +val (d,r) = dom_rng (type_of ``C11``) +val _ = Type.compare(d, numSyntax.num) <> EQUAL orelse die "FAILED!" +val (d,r) = dom_rng (type_of ``C12``) +val _ = Type.compare(d, numSyntax.num) <> EQUAL orelse die "FAILED!" +val _ = print "OK\n" + val _ = Process.exit Process.success; From 05e84e67cce9865a21fb9b69a21dbcea0d47b8ca Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 26 May 2015 09:50:01 +1000 Subject: [PATCH 315/718] Make hol.builder0 heap depend on ParseDatatype.uo --- src/proofman/Holmakefile | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/proofman/Holmakefile b/src/proofman/Holmakefile index c6f757f337..9aa43b9734 100644 --- a/src/proofman/Holmakefile +++ b/src/proofman/Holmakefile @@ -21,7 +21,8 @@ DEPS = $(BOOLLIB) $(BOOLTHEORY) $(PRIMREC) $(TERMPP) \ $(dprot $(SIGOBJ)/ParseExtras.uo) \ $(dprot $(SIGOBJ)/Drule.uo) \ $(dprot $(SIGOBJ)/TheoryPP.uo) \ - $(dprot $(SIGOBJ)/Conv.uo) + $(dprot $(SIGOBJ)/Conv.uo) \ + $(dprot $(SIGOBJ)/ParseDatatype.uo) EXTRA_CLEANS = $(TARGET) From 0ad7ad882f1600af06e442003812ae1265c69af6 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 26 May 2015 09:52:45 +1000 Subject: [PATCH 316/718] Datatype now handles antiquotations. Closes #258 --- doc/next-release.md | 11 +++++++---- src/datatype/selftest.sml | 5 +++++ src/parse/ParseDatatype.sml | 2 +- 3 files changed, 13 insertions(+), 5 deletions(-) diff --git a/doc/next-release.md b/doc/next-release.md index 63d6ca7591..887864bad5 100644 --- a/doc/next-release.md +++ b/doc/next-release.md @@ -31,13 +31,16 @@ Bugs fixed: - `Holmake` will now follow `INCLUDES` specifications from `Holmakefiles` when given “phony” targets to build on the command-line. (A typical phony target is `all`.) As in the past, it will still act only locally if given just a clean target (`clean`, `cleanDeps` or `cleanAll`). To clean recursively, you must also pass the `-r` flag to `Holmake`. ([Github issue](http://github.com/HOL-Theorem-Prover/HOL/issues/145)) -- `Datatype` will no longer create a recursive type if the recursive instance is qualified with a theory name other than the current one. -In other words, +- We fixed two problems with `Datatype`. Thanks to Ramana Kumar for both reports. + [First](http://github.com/HOL-Theorem-Prover/HOL/issues/257), `Datatype` will no longer create a recursive type if the recursive instance is qualified with a theory name other than the current one. + In other words, - Datatype`num = C1 num$num | C2` + Datatype`num = C1 num$num | C2` won’t create a recursive type (assuming this is not called in theory `num`). - Thanks to Ramana Kumar for the [bug report](http://github.com/HOL-Theorem-Prover/HOL/issues/257). + (`Hol_datatype` had the same problem.) + + [Second](http://github.com/HOL-Theorem-Prover/HOL/issues/257), `Datatype` will handle antiquotations in its input properly (`Hol_datatype` already did). New theories: ------------- diff --git a/src/datatype/selftest.sml b/src/datatype/selftest.sml index 738b0c0a18..2380168139 100644 --- a/src/datatype/selftest.sml +++ b/src/datatype/selftest.sml @@ -263,4 +263,9 @@ val (d,r) = dom_rng (type_of ``C12``) val _ = Type.compare(d, numSyntax.num) <> EQUAL orelse die "FAILED!" val _ = print "OK\n" +val _ = tprint "Datatype and antiquote (should be quick)" +val num = numSyntax.num +val _ = Datatype.Datatype `dtypeAQ = C13 ^num bool | C14 (^num -> bool)` +val _ = print "OK\n" + val _ = Process.exit Process.success; diff --git a/src/parse/ParseDatatype.sml b/src/parse/ParseDatatype.sml index b01b28d4e8..7885570215 100644 --- a/src/parse/ParseDatatype.sml +++ b/src/parse/ParseDatatype.sml @@ -239,7 +239,7 @@ fun parse_harg qb = in qbuf.advance qb; parse_type qb' end - | (base_tokens.BT_AQ ty, _) => dAQ ty + | (base_tokens.BT_AQ ty, _) => (qbuf.advance qb; dAQ ty) | (_, locn) => raise ERRloc "parse_harg" locn "Unexpected token in constructor's argument" From 70bcf8efd82b98e29a54be00a110c85e11d3cd18 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 26 May 2015 15:36:56 +1000 Subject: [PATCH 317/718] Let PAT_ABBREV_TAC use patterns that are more polymorphic than the goal Closes #252 --- doc/next-release.md | 2 ++ src/marker/markerLib.sml | 16 ++++++++++------ src/q/selftest.sml | 8 ++++++++ 3 files changed, 20 insertions(+), 6 deletions(-) diff --git a/doc/next-release.md b/doc/next-release.md index 887864bad5..f2177a2522 100644 --- a/doc/next-release.md +++ b/doc/next-release.md @@ -22,6 +22,8 @@ New features: - We have ported HOL Light’s `PAT_CONV` and `PATH_CONV` “conversionals”, providing nice machinery for applying conversions to specific sub-terms. +- The tactic `PAT_ABBREV_TAC` (also available in the `Q` module) can now use patterns that are more polymorphic than the sub-term in the goal that is ultimately matched. ([Github issue](http://github.com/HOL-Theorem-Prover/HOL/issues/252)) + Bugs fixed: ----------- diff --git a/src/marker/markerLib.sml b/src/marker/markerLib.sml index 8cb4da8286..26c2f185e6 100644 --- a/src/marker/markerLib.sml +++ b/src/marker/markerLib.sml @@ -103,14 +103,18 @@ in let val (l, r) = dest_eq eq val l' = variant (HOLset.listItems (FVL [r] fv_set)) l - fun matchr t = raw_match [] fv_set r t ([],[]) - fun finder t = - (!match_var_or_const orelse not (is_var t orelse is_const t)) - andalso can matchr t + fun matchr t = raw_match [] fv_set r t ([],[]) |> #2 |> #1 + fun finder (_, t) = + if (is_var t orelse is_const t) andalso + not (!match_var_or_const) + then + NONE + else + Lib.total (fn st => (st, matchr st)) t in - case Lib.total (find_term finder) w of + case gen_find_term finder w of NONE => raise ERR "PAT_ABBREV_TAC" "No matching term found" - | SOME t => ABB l' t g + | SOME (t, tysub) => ABB (Term.inst tysub l') t g end end diff --git a/src/q/selftest.sml b/src/q/selftest.sml index 5cc1590449..d502f93460 100644 --- a/src/q/selftest.sml +++ b/src/q/selftest.sml @@ -26,6 +26,9 @@ val _ = if aconv (concl result) goal then | _ => die "FAILED!" else die "FAILED!" +(* combinator *) +val _ = new_definition("I_DEF", ``I = \x:'a. x``); + (* fake arithmetic *) val _ = new_type ("num", 0) val _ = new_constant ("*", ``:num -> num -> num``) @@ -146,4 +149,9 @@ val _ = case sgs of | _ => die "FAILED!" +val _ = tprint "Q.PAT_ABBREV_TAC (gh252)" +val (sgs, _) = Q.PAT_ABBREV_TAC `v = I x` ([], ``I p /\ v``) +val _ = print "OK\n" + + val _ = Process.exit Process.success; From e8330675120f463d0f5ff8701732eb94097b0c49 Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Tue, 26 May 2015 15:16:00 +0100 Subject: [PATCH 318/718] Improve the interface to stateLib.update_frame_state_thm. Also add some explanatory comments within stateScript.sml. --- .../l3-machine-code/arm/prog/arm_progLib.sml | 72 +----- .../arm8/prog/arm8_progLib.sml | 25 +- examples/l3-machine-code/common/stateLib.sig | 3 +- examples/l3-machine-code/common/stateLib.sml | 77 +++++-- .../l3-machine-code/common/stateScript.sml | 216 +++++++++++++++--- .../l3-machine-code/m0/prog/m0_progLib.sml | 21 +- .../mips/prog/mips_progLib.sml | 60 +---- .../l3-machine-code/x64/prog/x64_progLib.sml | 12 +- 8 files changed, 267 insertions(+), 219 deletions(-) diff --git a/examples/l3-machine-code/arm/prog/arm_progLib.sml b/examples/l3-machine-code/arm/prog/arm_progLib.sml index e18ca4cd2e..7727bd9dc8 100644 --- a/examples/l3-machine-code/arm/prog/arm_progLib.sml +++ b/examples/l3-machine-code/arm/prog/arm_progLib.sml @@ -70,75 +70,15 @@ val state_id = val fp_id = utilsLib.mk_state_id_thm armTheory.FP_component_equality - [["FPSCR"]] + [["REG"], ["FPSCR"]] val arm_frame = stateLib.update_frame_state_thm arm_proj_def - [(`K arm_c_CPSR_N`, - `\s:arm_state a w. s with CPSR := cpsr with N := w`, - `\s:arm_state. s with CPSR := cpsr`), - (`K arm_c_CPSR_Z`, - `\s:arm_state a w. s with CPSR := cpsr with Z := w`, - `\s:arm_state. s with CPSR := cpsr`), - (`K arm_c_CPSR_C`, - `\s:arm_state a w. s with CPSR := cpsr with C := w`, - `\s:arm_state. s with CPSR := cpsr`), - (`K arm_c_CPSR_V`, - `\s:arm_state a w. s with CPSR := cpsr with V := w`, - `\s:arm_state. s with CPSR := cpsr`), - (`K arm_c_CPSR_Q`, - `\s:arm_state a w. s with CPSR := cpsr with Q := w`, - `\s:arm_state. s with CPSR := cpsr`), - (`K arm_c_CPSR_A`, - `\s:arm_state a w. s with CPSR := cpsr with A := w`, - `\s:arm_state. s with CPSR := cpsr`), - (`K arm_c_CPSR_I`, - `\s:arm_state a w. s with CPSR := cpsr with I := w`, - `\s:arm_state. s with CPSR := cpsr`), - (`K arm_c_CPSR_F`, - `\s:arm_state a w. s with CPSR := cpsr with F := w`, - `\s:arm_state. s with CPSR := cpsr`), - (`K arm_c_CPSR_J`, - `\s:arm_state a w. s with CPSR := cpsr with J := w`, - `\s:arm_state. s with CPSR := cpsr`), - (`K arm_c_CPSR_T`, - `\s:arm_state a w. s with CPSR := cpsr with T := w`, - `\s:arm_state. s with CPSR := cpsr`), - (`K arm_c_CPSR_E`, - `\s:arm_state a w. s with CPSR := cpsr with E := w`, - `\s:arm_state. s with CPSR := cpsr`), - (`K arm_c_CPSR_M`, - `\s:arm_state a w. s with CPSR := cpsr with M := w`, - `\s:arm_state. s with CPSR := cpsr`), - (`K arm_c_CPSR_GE`, - `\s:arm_state a w. s with CPSR := cpsr with GE := w`, - `\s:arm_state. s with CPSR := cpsr`), - (`K arm_c_CPSR_IT`, - `\s:arm_state a w. s with CPSR := cpsr with IT := w`, - `\s:arm_state. s with CPSR := cpsr`), - (`K arm_c_CPSR_psr'rst`, - `\s:arm_state a w. s with CPSR := cpsr with psr'rst := w`, - `\s:arm_state. s with CPSR := cpsr`), - (`K arm_c_FP_FPSCR_N`, - `\s:arm_state a w. s with FP := fp with FPSCR := fpscr with N := w`, - `\s:arm_state. s with FP := fp with FPSCR := fpscr`), - (`K arm_c_FP_FPSCR_Z`, - `\s:arm_state a w. s with FP := fp with FPSCR := fpscr with Z := w`, - `\s:arm_state. s with FP := fp with FPSCR := fpscr`), - (`K arm_c_FP_FPSCR_C`, - `\s:arm_state a w. s with FP := fp with FPSCR := fpscr with C := w`, - `\s:arm_state. s with FP := fp with FPSCR := fpscr`), - (`K arm_c_FP_FPSCR_V`, - `\s:arm_state a w. s with FP := fp with FPSCR := fpscr with V := w`, - `\s:arm_state. s with FP := fp with FPSCR := fpscr`), - (`arm_c_REG`, `\s:arm_state a w. s with REG := (a =+ w) r`, - `\s:arm_state. s with REG := r`), - (`arm_c_MEM`, `\s:arm_state a w. s with MEM := (a =+ w) r`, - `\s:arm_state. s with MEM := r`), - (`arm_c_FP_REG`, - `\s:arm_state a w. s with FP := fp with REG := (a =+ w) fp.REG`, - `\s:arm_state. s with FP := fp`) - ] + (List.map (fn s => "CPSR." ^ s) + ["N", "Z", "C", "V", "Q", "A", "I", "F", "J", "T", "E", "M", "GE", + "IT", "psr'rst"] @ + List.map (fn s => "FP.FPSCR." ^ s) ["N", "Z", "C", "V"] @ + ["REG", "MEM", "FP.REG"]) val arm_frame_hidden = stateLib.update_hidden_frame_state_thm arm_proj_def diff --git a/examples/l3-machine-code/arm8/prog/arm8_progLib.sml b/examples/l3-machine-code/arm8/prog/arm8_progLib.sml index c71d059c4a..fdc322994f 100644 --- a/examples/l3-machine-code/arm8/prog/arm8_progLib.sml +++ b/examples/l3-machine-code/arm8/prog/arm8_progLib.sml @@ -59,29 +59,8 @@ val state_id = val arm_frame = stateLib.update_frame_state_thm arm_proj_def - [(`K arm8_c_PSTATE_N`, - `\s:arm8_state a w. s with PSTATE := cpsr with N := w`, - `\s:arm8_state. s with PSTATE := cpsr`), - (`K arm8_c_PSTATE_Z`, - `\s:arm8_state a w. s with PSTATE := cpsr with Z := w`, - `\s:arm8_state. s with PSTATE := cpsr`), - (`K arm8_c_PSTATE_C`, - `\s:arm8_state a w. s with PSTATE := cpsr with C := w`, - `\s:arm8_state. s with PSTATE := cpsr`), - (`K arm8_c_PSTATE_V`, - `\s:arm8_state a w. s with PSTATE := cpsr with V := w`, - `\s:arm8_state. s with PSTATE := cpsr`), - (`K arm8_c_SP_EL0`, - `\s:arm8_state a w. s with SP_EL0 := w`, - `\s:arm8_state. s`), - (`K arm8_c_PC`, - `\s:arm8_state a w. s with PC := w`, - `\s:arm8_state. s`), - (`arm8_c_REG`, `\s:arm8_state a w. s with REG := (a =+ w) r`, - `\s:arm8_state. s with REG := r`), - (`arm8_c_MEM`, `\s:arm8_state a w. s with MEM := (a =+ w) r`, - `\s:arm8_state. s with MEM := r`) - ] + ["PSTATE.N", "PSTATE.Z", "PSTATE.C", "PSTATE.V", "SP_EL0", "PC", "REG", + "MEM"] val arm_frame_hidden = stateLib.update_hidden_frame_state_thm arm_proj_def diff --git a/examples/l3-machine-code/common/stateLib.sig b/examples/l3-machine-code/common/stateLib.sig index 28f1341c19..f319257afc 100644 --- a/examples/l3-machine-code/common/stateLib.sig +++ b/examples/l3-machine-code/common/stateLib.sig @@ -44,8 +44,7 @@ sig thm -> thm -> thm list -> thm list -> thm list -> thm list -> thm list -> hol_type list -> tactic -> tactic -> thm * term -> thm val star_select_state_thm: thm -> thm list -> term list * thm -> thm - val update_frame_state_thm: - thm -> (Q.tmquote * Q.tmquote * Q.tmquote) list -> thm + val update_frame_state_thm: thm -> string list -> thm val update_hidden_frame_state_thm: thm -> term list -> thm val vvar: hol_type -> term val varReset: unit -> unit diff --git a/examples/l3-machine-code/common/stateLib.sml b/examples/l3-machine-code/common/stateLib.sml index ad77f3bdb5..32db2053c6 100644 --- a/examples/l3-machine-code/common/stateLib.sml +++ b/examples/l3-machine-code/common/stateLib.sml @@ -88,25 +88,70 @@ fun mk_state_pred x = ------------------------------------------------------------------------ *) local - fun tac t = Cases THEN SRW_TAC [] [t, combinTheory.APPLY_UPDATE_THM] - fun frame_state_thm def (f, u, r) = + val concat_ = String.concat o Lib.separate "_" + val dom_of = utilsLib.dom o Term.type_of + val rng_of = utilsLib.rng o Term.type_of + val ty_name = #Tyop o Type.dest_thy_type o Term.type_of +in + fun update_frame_state_thm proj_def = let - val n = utilsLib.get_function def - val thm = - UPDATE_FRAME_STATE - |> Drule.ISPEC n - |> Q.ISPECL [f, u, r] - |> SIMP_RULE (srw_ss()) [] - val p = fst (boolSyntax.dest_imp (Thm.concl thm)) - val p_thm = Tactical.prove (p, tac def) + val tac = + Cases THEN SRW_TAC [] [proj_def, combinTheory.APPLY_UPDATE_THM] + val proj = utilsLib.get_function proj_def + val th = Drule.ISPEC proj stateTheory.UPDATE_FRAME_STATE + val {Thy = p_thy, Name = n, Ty = ty, ...} = Term.dest_thy_const proj + val isa = if String.isSuffix "_proj" n + then String.extract (n, 0, SOME (String.size n - 5)) + else raise ERR "update_frame_state_thm" + "unexpected proj name" + val state_ty = fst (Type.dom_rng ty) + val {Thy = thy, ...} = Type.dest_thy_type state_ty + val s = Term.mk_var ("s", state_ty) + fun frame_state_thm component = + let + val l = String.tokens (Lib.equal #".") component + val c_name = concat_ (isa :: "c" :: l) + val c = Term.prim_mk_const {Name = c_name, Thy = p_thy} + val (f, aty, not_map) = + case Lib.total dom_of c of + SOME ty => (c, ty, false) + | NONE => + (combinSyntax.mk_K_1 (c, Type.alpha), Type.alpha, true) + val a = Term.mk_var ("a", aty) + val w = ref boolSyntax.T + fun iter rest tm = + fn [] => if rest + then tm + else if not_map + then (w := Term.mk_var ("w", Term.type_of tm); !w) + else ( w := Term.mk_var ("w", rng_of tm) + ; Term.mk_comb + (combinSyntax.mk_update (a, !w), tm) + ) + | h :: t => + let + val fupd_name = concat_ [ty_name tm, h, "fupd"] + val fupd = + Term.prim_mk_const {Name = fupd_name, Thy = thy} + val d = utilsLib.dom (dom_of fupd) + val v = Term.mk_var (utilsLib.lowercase h, d) + in + Term.list_mk_comb + (fupd, [combinSyntax.mk_K_1 (iter rest v t, d), tm]) + end + val u = iter false s l + val u = Term.list_mk_abs ([s, a, !w], u) + val l = if not_map then Lib.butlast l else l + val r = Term.mk_abs (s, iter true s l) + val thm = th |> Drule.ISPECL [f, u, r] |> SIMP_RULE (srw_ss()) [] + val p = fst (boolSyntax.dest_imp (Thm.concl thm)) + val p_thm = Tactical.prove (p, tac) + in + Drule.GEN_ALL (MATCH_MP thm p_thm) + end in - Drule.GEN_ALL (MATCH_MP thm p_thm) + Drule.LIST_CONJ o List.map frame_state_thm end -in - fun update_frame_state_thm proj_def = - Drule.LIST_CONJ o - List.map (Feedback.trace ("notify type variable guesses", 0) - (frame_state_thm proj_def)) end (* ------------------------------------------------------------------------ diff --git a/examples/l3-machine-code/common/stateScript.sml b/examples/l3-machine-code/common/stateScript.sml index 67a67b4d9c..02ec4dcccd 100644 --- a/examples/l3-machine-code/common/stateScript.sml +++ b/examples/l3-machine-code/common/stateScript.sml @@ -6,36 +6,187 @@ val _ = new_theory "state" infix \\ val op \\ = op THEN; -(* ------------------------------------------------------------------------ *) +(* ------------------------------------------------------------------------ + We use Hoare triples defined in examples/machine-code/hoare-triple/progTheory + These are of the form: -val NEXT_REL_def = Define `NEXT_REL r next s t = ?u. r s u /\ (next u = SOME t)` + SPEC (to_set,next,instr,less,allow) p c q -val SELECT_STATE_def = Define `SELECT_STATE m d s = fun2set (m s, d)` + 'a the state type + 'b set the "set view" of states + 'c the code-pool type -val STATE_def = Define `STATE m = SELECT_STATE m UNIV` + to_set : 'a -> 'b set maps states to a set view. + (This will be specialized to ``STATE m`` for + a map ``m: 'a -> ('name # 'value) set``. + The tool stateLib.sep_definitions helps + automatically define m, 'name and 'value for + L3 specifications.) -val FRAME_STATE_def = Define `FRAME_STATE m d = SELECT_STATE m (COMPL d)` + next : 'a -> 'a -> bool next-state relation. + (This will be specialized to + ``NEXT_REL (=) next`` for some next-state + function "next".) -(* ------------------------------------------------------------------------ *) + instr : 'c -> 'b set maps the code pool to a set view. + + less : 'a -> 'a -> bool ordering on states. + (This will be specialized to ``(=)``.) + + allow : 'a -> bool "always valid" states. + (This will be specialized to ``K F``, i.e. + "Just use the supplied pre-condition and + post-condition predicates".) + + p : 'b set -> bool pre-condition. + + c : 'c -> bool code-pool. + + q : 'b set -> bool post-condition. + ------------------------------------------------------------------------ *) + +(* ------------------------------------------------------------------------ + NEXT_REL is used to capture valid sequences of states, as determined by a + next-state function "next" (and state relation "r"). The next-state relation + supplied to SPEC is ``NEXT_REL r next : 'a -> 'a -> bool``. + + We are only really interested in cases where "r" is pre-order on states. + The tools (in stateLib) go further and assume "r" is "=". Thus, the + specified sequence of states for + + seq_relation (NEXT_REL (=) next) seq s + + is + + seq 0 = s, + seq 1 = THE (next s), + seq 2 = THE (next (THE (next s))), ... + + If ``next (seq n) = NONE`` for some "n" then this final state is repeated + ad infinitum. + ------------------------------------------------------------------------ *) + +val NEXT_REL_def = Define` + NEXT_REL (r: 's -> 's -> bool) (next: 's -> 's option) s t = + ?u. r s u /\ (next u = SOME t)` val NEXT_REL_EQ = Q.store_thm ("NEXT_REL_EQ", `!next. NEXT_REL (=) next = \s t. next s = SOME t`, rw [NEXT_REL_def, FUN_EQ_THM]) -val PreOrder_EQ = Q.store_thm ("PreOrder_EQ", - `PreOrder (=)`, - rw [relationTheory.PreOrder, relationTheory.reflexive_def, - relationTheory.transitive_def]) +(* ------------------------------------------------------------------------ + SELECT_STATE is used to construct a "set view" of states. -val FRAME_SET_EQ = Q.store_thm ("FRAME_SET_EQ", - `!m x y s t. (FRAME_STATE m x s = FRAME_STATE m y t) ==> (x = y)`, - simp [pred_setTheory.EXTENSION, FRAME_STATE_def, SELECT_STATE_def, - fun2set_def] - \\ metis_tac [pairTheory.FST]) + 'a the state type + 'b state component name type + 'c state component value type + ('b # 'c) set the type for the set view of states -val SEP_EQ_SINGLETON = Q.store_thm ("SEP_EQ_SINGLETON", - `!x. SEP_EQ x = { x }`, - rw [SEP_EQ_def, pred_setTheory.EXTENSION, boolTheory.IN_DEF]) + m : 'a -> 'b -> 'c converts a state into a map from names to values + d : 'b set the domain (component names) of interest + + The set view is the graph of the map "m", i.e. + + { (name, m s name) | name IN d } + + Thus, ``SELECT_STATE m UNIV : 'a -> ('b # 'c) set`` is a suitable "to_set" + map in instances of SPEC. + + For example, for ARM we have + + 'a is arm_state + 'b is arm_component + 'c is arm_data + m is arm_proj + + The term ``SELECT_STATE arm_proj {arm_c_CPSR_Z} s`` then represents the set + + {(arm_c_CPSR_Z, arm_proj s arm_c_CPSR_Z)} + + which is defined to be + + {(arm_c_CPSR_Z, arm_d_bool s.CPSR.Z)} + + Thus, component ``arm_c_CPSR_Z`` is associated with the value ``s.CPSR.Z``. + + A predicate arm_CPSR_Z is defined as follows + + !d. arm_CPSR_Z d = {{(arm_c_CPSR_Z,arm_d_bool d)}} + + ------------------------------------------------------------------------ *) + +val SELECT_STATE_def = Define `SELECT_STATE m d s = fun2set (m s, d)` + +(* The "universal" to-set map *) + +val STATE_def = Define `STATE m = SELECT_STATE m UNIV` + +(* The "complement" to-set map *) + +val FRAME_STATE_def = Define `FRAME_STATE m d = SELECT_STATE m (COMPL d)` + +(* ------------------------------------------------------------------------ + We now show that + + PreOrder r ==> + (!y s t1. + p (SELECT_STATE m y t1) /\ r t1 s ==> + ?v t2. + p (SELECT_STATE m y s) /\ + (next s = SOME v) /\ + q (SELECT_STATE m y t2) /\ r t2 v /\ + (FRAME_STATE m y t1 = FRAME_STATE m y t2)) ==> + SPEC (STATE m, NEXT_REL r next, instr, r, K F) p {} q`, + + and this is then used to show that + + (!y s. + (p * CODE_POOL instr c) (SELECT_STATE m y s) ==> + ?v. + (next s = SOME v) /\ + (q * CODE_POOL instr c) (SELECT_STATE m y v) /\ + (FRAME_STATE m y s = FRAME_STATE m y v)) ==> + SPEC (STATE m,NEXT_REL $= next,instr,$=,K F) p c q + + This theorem is used to derive SPEC theorems for machine-code instructions. + Given a next-state theorem of the form + + p1 /\ ... /\ pn ==> (next s = SOME v), + + the procedure is as follows: + + - Use MATCH_MP and proceed to show the antecedent is true. + + - Use GEN_TAC and STIP_TAC, so that we assume assertions for "s" from + pre-condition "p" and "CODE_POOL instr c". + + Assertion "p" will normally consist of a starred collection of + state component assertions. These are expanded using the theorem + STAR_SELECT_STATE below. The definition of "m" is also used. + For example, if we have + + (arm_CPSR_Z v * p) (SELECT_STATE arm_proj y s) + + then this can be used to deduce ``arm_c_CPSR_Z IN y`` and + ``s.CPSR.Z = v``. We then iterate on the remaining "p". + + - We now have three sub-goals. + + 1. Prove the existance of a next-state for "s". The witness comes + from the RHS of the supplied next-state theorem. The main task + is to verify that each condition "p1, ..., pn" is satisfied by + the assumptions (pre-condition assertions). + + 2. Show that state "v" satisfies the post-condition assertions in "q". + Again, this uses the STAR_SELECT_STATE. This time extra rewrites + are needed to reason about state (record and map) updates. + + 3. Show that the "s" and "v" do not differ for components that are not + mentioned in "y". This is based on using theorem UPDATE_FRAME_STATE + below. The tool stateLib.update_frame_state_thm can be used to + generate appropriate theorem instances for an L3 specification + + ------------------------------------------------------------------------ *) val SPLIT_STATE = Q.store_thm ("SPLIT_STATE", `!m s u v. @@ -57,7 +208,11 @@ val SPLIT_STATE_cor = METIS_PROVE [SPLIT_STATE] ``p (SELECT_STATE m y s) ==> ?u v. SPLIT (STATE m s) (u, v) /\ p u /\ (\v. v = FRAME_STATE m y s) v`` -(* ........................................................................ *) +val FRAME_SET_EQ = Q.store_thm ("FRAME_SET_EQ", + `!m x y s t. (FRAME_STATE m x s = FRAME_STATE m y t) ==> (x = y)`, + simp [pred_setTheory.EXTENSION, FRAME_STATE_def, SELECT_STATE_def, + fun2set_def] + \\ metis_tac [pairTheory.FST]) val R_STATE_SEMANTICS = Q.store_thm ("R_STATE_SEMANTICS", `!m next instr r p q. @@ -129,6 +284,11 @@ val IMP_R_SPEC = Q.prove( \\ metis_tac [optionTheory.SOME_11] ) +val PreOrder_EQ = Q.store_thm ("PreOrder_EQ", + `PreOrder (=)`, + rw [relationTheory.PreOrder, relationTheory.reflexive_def, + relationTheory.transitive_def]) + val IMP_SPEC = Q.prove( `!m next instr p q. (!y s. @@ -174,6 +334,10 @@ val IMP_SPEC = Theory.save_thm ("IMP_SPEC", |> Q.GENL [`q`, `p`, `c`, `instr`, `next`, `m`] ) +val SEP_EQ_SINGLETON = Q.store_thm ("SEP_EQ_SINGLETON", + `!x. SEP_EQ x = { x }`, + rw [SEP_EQ_def, pred_setTheory.EXTENSION, boolTheory.IN_DEF]) + val CODE_POOL = Theory.save_thm ("CODE_POOL", REWRITE_RULE [GSYM SEP_EQ_def, SEP_EQ_SINGLETON] CODE_POOL_def) @@ -264,13 +428,6 @@ val emp_SELECT_STATE = Q.store_thm ("emp_SELECT_STATE", (* ........................................................................ *) -val cond_true_elim = Theory.save_thm("cond_true_elim", - simpLib.SIMP_PROVE bool_ss [set_sepTheory.SEP_CLAUSES] - ``(!p:'a set set. p * cond T = p) /\ - (!p:'a set set. cond T * p = p)``) - -(* ........................................................................ *) - val UPDATE_FRAME_STATE = Q.store_thm ("UPDATE_FRAME_STATE", `!m f u r. (!b s a w. b <> f a ==> (m (u s a w) b = m (r s) b)) ==> @@ -280,7 +437,12 @@ val UPDATE_FRAME_STATE = Q.store_thm ("UPDATE_FRAME_STATE", \\ metis_tac [] ) -(* ........................................................................ *) +(* ------------------------------------------------------------------------ *) + +val cond_true_elim = Theory.save_thm("cond_true_elim", + simpLib.SIMP_PROVE bool_ss [set_sepTheory.SEP_CLAUSES] + ``(!p:'a set set. p * cond T = p) /\ + (!p:'a set set. cond T * p = p)``) val UNION_STAR = Q.store_thm("UNION_STAR", `!a b c. DISJOINT a b ==> ({a UNION b} * c = {a} * {b} * c)`, diff --git a/examples/l3-machine-code/m0/prog/m0_progLib.sml b/examples/l3-machine-code/m0/prog/m0_progLib.sml index 376c2ddc0f..711f9a4804 100644 --- a/examples/l3-machine-code/m0/prog/m0_progLib.sml +++ b/examples/l3-machine-code/m0/prog/m0_progLib.sml @@ -64,26 +64,7 @@ val state_id = val m0_frame = stateLib.update_frame_state_thm m0_proj_def - [(`K m0_c_PSR_N`, - `\s:m0_state a w. s with PSR := psr with N := w`, - `\s:m0_state. s with PSR := psr`), - (`K m0_c_PSR_Z`, - `\s:m0_state a w. s with PSR := psr with Z := w`, - `\s:m0_state. s with PSR := psr`), - (`K m0_c_PSR_C`, - `\s:m0_state a w. s with PSR := psr with C := w`, - `\s:m0_state. s with PSR := psr`), - (`K m0_c_PSR_V`, - `\s:m0_state a w. s with PSR := psr with V := w`, - `\s:m0_state. s with PSR := psr`), - (`K m0_c_count`, - `\s:m0_state a w. s with count := c`, - `\s:m0_state. s`), - (`m0_c_REG`, `\s:m0_state a w. s with REG := (a =+ w) r`, - `\s:m0_state. s with REG := r`), - (`m0_c_MEM`, `\s:m0_state a w. s with MEM := (a =+ w) r`, - `\s:m0_state. s with MEM := r`) - ] + ["PSR.N", "PSR.Z", "PSR.C", "PSR.V", "count", "REG", "MEM"] val m0_frame_hidden = stateLib.update_hidden_frame_state_thm m0_proj_def diff --git a/examples/l3-machine-code/mips/prog/mips_progLib.sml b/examples/l3-machine-code/mips/prog/mips_progLib.sml index caffdacd59..3b676a4b61 100644 --- a/examples/l3-machine-code/mips/prog/mips_progLib.sml +++ b/examples/l3-machine-code/mips/prog/mips_progLib.sml @@ -109,60 +109,12 @@ val CP0_id = utilsLib.mk_state_id_thm mipsTheory.CP0_component_equality [["Status"]] val mips_frame = - update_frame_state_thm mips_proj_def - [ - (`K mips_c_CP0_Count`, - `\s:mips_state a w. s with CP0 := cp0 with Count := w`, - `\s:mips_state. s with CP0 := cp0`), - (`K mips_c_CP0_Cause`, - `\s:mips_state a w. s with CP0 := cp0 with Cause := w`, - `\s:mips_state. s with CP0 := cp0`), - (`K mips_c_CP0_EPC`, - `\s:mips_state a w. s with CP0 := cp0 with EPC := w`, - `\s:mips_state. s with CP0 := cp0`), - (`K mips_c_CP0_Debug`, - `\s:mips_state a w. s with CP0 := cp0 with Debug := w`, - `\s:mips_state. s with CP0 := cp0`), - (`K mips_c_CP0_ErrCtl`, - `\s:mips_state a w. s with CP0 := cp0 with ErrCtl := w`, - `\s:mips_state. s with CP0 := cp0`), - (`K mips_c_CP0_LLAddr`, - `\s:mips_state a w. s with CP0 := cp0 with LLAddr := w`, - `\s:mips_state. s with CP0 := cp0`), - (`K mips_c_CP0_Status_ERL`, - `\s:mips_state a w. - s with CP0 := cp0 with Status := status with ERL := w`, - `\s:mips_state. s with CP0 := cp0 with Status := status`), - (`K mips_c_CP0_Status_EXL`, - `\s:mips_state a w. - s with CP0 := cp0 with Status := status with EXL := w`, - `\s:mips_state. s with CP0 := cp0 with Status := status`), - (`K mips_c_PC`, - `\s:mips_state a w. s with PC := w`, - `I: mips_state -> mips_state`), - (`K mips_c_BranchDelay`, - `\s:mips_state a w. s with BranchDelay := w`, - `I: mips_state -> mips_state`), - (`K mips_c_BranchTo`, - `\s:mips_state a w. s with BranchTo := w`, - `I: mips_state -> mips_state`), - (`K mips_c_exceptionSignalled`, - `\s:mips_state a w. s with exceptionSignalled := w`, - `I: mips_state -> mips_state`), - (`K mips_c_LLbit`, - `\s:mips_state a w. s with LLbit := w`, - `I: mips_state -> mips_state`), - (`K mips_c_hi`, - `\s:mips_state a w. s with hi := w`, - `I: mips_state -> mips_state`), - (`K mips_c_lo`, - `\s:mips_state a w. s with lo := w`, - `I: mips_state -> mips_state`), - (`mips_c_gpr`, `\s:mips_state a w. s with gpr := (a =+ w) r`, - `\s:mips_state. s with gpr := r`), - (`mips_c_MEM`, `\s:mips_state a w. s with MEM := (a =+ w) r`, - `\s:mips_state. s with MEM := r`) - ] + stateLib.update_frame_state_thm mips_proj_def + (List.map (fn s => "CP0." ^ s) + ["Count", "Cause", "EPC", "Debug", "ErrCtl", "LLAddr", + "Status.ERL", "Status.EXL"] @ + ["PC", "BranchDelay", "BranchTo", "exceptionSignalled", "LLbit", + "hi", "lo", "gpr", "MEM"]) (* -- *) diff --git a/examples/l3-machine-code/x64/prog/x64_progLib.sml b/examples/l3-machine-code/x64/prog/x64_progLib.sml index d76af1fc28..4d5c602c5a 100644 --- a/examples/l3-machine-code/x64/prog/x64_progLib.sml +++ b/examples/l3-machine-code/x64/prog/x64_progLib.sml @@ -71,17 +71,7 @@ val state_id = val x64_frame = stateLib.update_frame_state_thm x64_proj_def - [(`K x64_c_RIP`, - `\s:x64_state a w. s with RIP := w`, - `I : x64_state -> x64_state`), - (`x64_c_REG`, `\s:x64_state a w. s with REG := (a =+ w) r`, - `\s:x64_state. s with REG := r`), - (`x64_c_MEM`, `\s:x64_state a w. s with MEM := (a =+ w) r`, - `\s:x64_state. s with MEM := r`), - (`x64_c_ICACHE`, `\s:x64_state a w. s with ICACHE := (a =+ w) r`, - `\s:x64_state. s with ICACHE := r`), - (`x64_c_EFLAGS`, `\s:x64_state a w. s with EFLAGS := (a =+ w) r`, - `\s:x64_state. s with EFLAGS := r`)] + ["RIP", "REG", "MEM", "ICACHE", "EFLAGS"] (* -- *) From 1ee64d37244e6b8dccc310b82d9d44798fefb419 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 28 May 2015 10:54:08 +1000 Subject: [PATCH 319/718] Make metis's hol->fol mapping of types injective. Previously this mapping used dest_type, thereby throwing away theory information for type operators. Possibly a fix for github issue #259 --- src/metis/folMapping.sml | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/src/metis/folMapping.sml b/src/metis/folMapping.sml index d1e647c353..3df05698b3 100644 --- a/src/metis/folMapping.sml +++ b/src/metis/folMapping.sml @@ -444,6 +444,23 @@ end; (* Translate a HOL type to FOL, and back again. *) (* ------------------------------------------------------------------------- *) +local + fun dest_type ty = + let + val {Args, Thy, Tyop} = dest_thy_type ty + in + (Thy ^ "$" ^ Tyop, Args) + end + fun mk_type (nm, args) = + let + val (ss1, ss2) = Substring.position "$" (Substring.full nm) + val thy = Substring.string ss1 + val nm = Substring.slice(ss2, 1, NONE) |> Substring.string + in + mk_thy_type {Tyop = nm, Thy = thy, Args = args} + end +in + fun hol_type_to_fol tyV = let fun ty_to_fol hol_ty = @@ -462,6 +479,7 @@ fun fol_type_to_hol (mlibTerm.Var v) = fake_new_tyvar (possibly dest_prime v) | fol_type_to_hol (mlibTerm.Fn (f, a)) = if not (is_prime f) then mk_type (f, map fol_type_to_hol a) else (assert (null a) (ERR "fol_type_to_hol" "bad prime"); mk_vartype f); +end (* local *) val fol_bool = hol_type_to_fol [] bool; From 105c319049ca5b82c2939bde5baad40f03df2429 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 1 Jun 2015 12:43:20 +1000 Subject: [PATCH 320/718] grammarLib: improve errors when parsing grammars --- examples/parsing/grammarLib.sml | 106 ++++++++++++++++++++++++-------- 1 file changed, 80 insertions(+), 26 deletions(-) diff --git a/examples/parsing/grammarLib.sml b/examples/parsing/grammarLib.sml index 8d78c1b1ce..c471b71de7 100644 --- a/examples/parsing/grammarLib.sml +++ b/examples/parsing/grammarLib.sml @@ -13,31 +13,66 @@ fun (m1 >>-* m2) = m1 >-* (fn _ => m2) fun (m1 <- m2) = m1 >- (fn v => m2 >> return v) fun get s = (s, Some s) -type 'a tt = (term frag list, 'a, string) t +type posn = int * int +type posnmsg = posn * (posn * string) option +type 'a tt = (posnmsg * term frag list, 'a, string) t + +fun ((m1 : 'a tt) ++ (m2 : 'a tt)) : 'a tt = + fn (s0 as ((p0, m0), qb0)) => + case m1 s0 of + (((p, m), qb), Error e) => m2 ((p0, m), qb0) + | x => x + +fun repeat (m : 'a tt) s = ((m >> repeat m) ++ ok) s datatype stringt = S of string | TMnm of string datatype sym = NT of string | TOK of stringt datatype clause = Syms of sym list | TmAQ of term type t = (string * clause list) list -fun aq0 error frags = +fun newline ((col, line), msg) = ((0, line + 1), msg) +fun add1col ((col, line), msg) = ((col + 1, line), msg) +fun advance c p = if c = #"\n" then newline p else add1col p +fun posn_toString (col, line) = Int.toString line ^ "." ^ Int.toString col +fun posn_compare(p1 : posn, p2 : posn) = + case Int.compare (#2 p1, #2 p2) of + EQUAL => Int.compare(#1 p1, #1 p2) + | x => x +val startposn :posnmsg = ((0, 1), NONE) + +fun fail s ((p0,m0), i) = + let + val msg0 = posn_toString p0 ^ ": " ^ s + fun finish m = errormonad.fail msg0 ((p0, SOME m), i) + in + case m0 of + NONE => finish (p0,s) + | SOME(m as (p2, _)) => + if posn_compare(p0,p2) <> LESS then finish (p0,msg0) else finish m + end + +fun setPosn (line,col) ((_, m), i) = ((((col,line), m), i), Some ()) + +fun aq0 error (st as (posn:posnmsg, frags)) = case frags of - [] => (frags, Error error) - | QUOTE s :: rest => if s = "" then aq0 error rest - else (frags, Error error) - | ANTIQUOTE t :: rest => (rest, Some t) - -fun getc error frags = - case frags of - [] => (frags, Error error) + [] => (st, Error error) + | QUOTE s :: rest => if s = "" then aq0 error (posn, rest) + else (st, Error error) + | ANTIQUOTE t :: rest => ((posn, rest), Some t) + +fun getc error (st as (posn, i0)) = + case i0 of + [] => fail error st | QUOTE s :: rest => - if s = "" then getc error rest + if s = "" then getc error (posn, rest) else let val i' = if size s = 1 then rest else QUOTE (String.extract(s,1,NONE)) :: rest + val c = String.sub(s,0) + val posn' = advance c posn in - (i', Some (String.sub(s,0))) + ((posn', i'), Some (String.sub(s,0))) end - | ANTIQUOTE _ :: _ => (frags, Error error) + | ANTIQUOTE _ :: _ => fail error st fun dropP P = repeat (getc "" >- (fn c => if P c then ok else fail "")) @@ -53,7 +88,7 @@ fun token0 s = let else let val c = String.sub(s,i) in - getc "" >- + getc ("EOF while looking for "^str c^" of "^s) >- (fn c' => if c' = c then recurse (i + 1) else fail ("token: didn't find "^str c^" of "^s)) end @@ -69,22 +104,39 @@ in | Error _ => ok s end -fun comment s = - (token0 "(*" >> repeat (mnot (token0 "*)") >> getc "") >> - token0 "*)") s +(* needs to be eta-expanded to make it suitably polymorphic + (ware the value restriction!) +*) +fun barecomment s = + (token0 "(*" >> repeat (mnot (token0 "*)") >> getc "") >> token0 "*)") s + +fun mrpt m = + let + fun recurse acc = + (m >- (fn v => recurse (v::acc))) ++ return (List.rev acc) + in + recurse [] + end + +fun mrpt1 m = + (m >>-* mrpt m) >- (fn (x,xs) => return (x::xs)) + +val int = mrpt1 (getP Char.isDigit) >- + (fn clist => + return (valOf (Int.fromString (String.implode clist)))) + +val posn_comment = + token0 "(*#loc " >> (int >>-* (getP Char.isSpace >> int)) >- setPosn >> + token0 "*)" + +val comment = posn_comment ++ barecomment + fun lex m = repeat ((getP Char.isSpace >> ok) ++ comment) >> m fun complete m = m <- repeat ((getP Char.isSpace >> ok) ++ comment) fun token s = lex (token0 s) fun aq s = lex (aq0 s) -fun mrpt m = let - fun recurse acc = (m >- (fn v => recurse (v::acc))) ++ - return (List.rev acc) -in - recurse [] -end - fun ident_constituent c = Char.isAlphaNum c orelse c = #"'" orelse c = #"_" @@ -141,8 +193,10 @@ val grammar0 = fail "Couldn't make sense of remaining input") fun grammar fs = - case grammar0 fs of - (_, Error s) => raise Fail s + case grammar0 (startposn, fs) of + (((_,SOME(p,m)), _), Error _) => raise Fail m + | (((_, NONE), _), Error s) => + raise Fail ("Invariant failure, (and "^s^")") | (_, Some v) => v fun allnts f (g: t) : string HOLset.set = let From a4b66f03f245c67061a74c71eaecaf8fd99e72f1 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 2 Jun 2015 16:34:53 +1000 Subject: [PATCH 321/718] Better docs/indexing of set-comprehension traces --- Manual/Description/misc.tex | 4 +++- Manual/Description/theories.tex | 11 ++++++----- 2 files changed, 9 insertions(+), 6 deletions(-) diff --git a/Manual/Description/misc.tex b/Manual/Description/misc.tex index 2039ac7c59..613cb3c364 100644 --- a/Manual/Description/misc.tex +++ b/Manual/Description/misc.tex @@ -1200,7 +1200,9 @@ \subsection{Munging Commands} \item[\texttt{tr\apost}$\mathit{tracename}$\texttt{\apost=}$n$] This option allows the temporary setting of the provided trace to the integer value $n$. -For example, one can set \texttt{pp\_unambiguous\_comprehensions} to $1$ to ensure that set comprehensions are printed with bound variables explicitly identified (see Section~\ref{sec:theory-of-sets}). +For example, one can set \texttt{pp\_unambiguous\_comprehensions} to $1$ to ensure that set comprehensions are printed with bound variables explicitly identified. +See Section~\ref{sec:set-syntax} for more on set comprehensions, and Section~\ref{sec:traces} for more on traces. +\index{traces, controlling HOL feedback@traces, controlling \HOL{} feedback!when munging to LaTeX@when munging to \LaTeX{}} \item[\texttt{tt}] % Causes the term to be type-set as the argument to a \LaTeX{} command \texttt{\bs{}HOLinline}. diff --git a/Manual/Description/theories.tex b/Manual/Description/theories.tex index a7a9cb0ae9..4eeb035a66 100644 --- a/Manual/Description/theories.tex +++ b/Manual/Description/theories.tex @@ -2904,7 +2904,7 @@ \subsubsection{List permutations and sorting} The \theoryimp{sorting} theory defines a notion of two lists being permutations of each other, then defines a general notion of sorting, -then shows that Quicksort is a sorting function. The +then shows that Quicksort is a sorting function. The \theoryimp{mergesort} theory defines Merge sort and shows that it is a stable sorting function. @@ -3487,7 +3487,7 @@ \subsection{Sets (\theoryimp{pred\_set})} The Unicode syntax \holtxt{$\mathbb{U}$(:'a)} means the same. The Unicode symbol for $\mathbb{U}$ is U+1D54C, and may not exist in many fonts. -One of these forms will be used to print \holtxt{UNIV} by default. +\index{traces, controlling HOL feedback@traces, controlling \HOL{} feedback!universal sets}One of these forms will be used to print \holtxt{UNIV} by default. The user trace (see Section~\ref{sec:traces}) \ml{"Univ~pretty-printing"} can be set to zero to cancel this behaviour. Additionally, the trace \ml{"Unicode Univ printing"} can be used to stop the U+1D54C syntax from being used, even if the Unicode trace is set. @@ -3742,7 +3742,7 @@ \subsection{Sets (\theoryimp{pred\_set})} \end{hol} -\subsubsection{Syntax for sets}\index{set theory notation} +\subsubsection{Syntax for sets}\index{set theory notation}\label{sec:set-syntax} The special purpose set-theoretic notations {\small\verb%{%}$t_1 ;t_2 ; \ldots ; t_n${\small\verb%}%} and @@ -3892,8 +3892,9 @@ \subsubsection{Syntax for sets}\index{set theory notation} The unambiguous notation is printed by the pretty-printer whenever the set to be printed can not be expressed with the default notation, or if the trace variable with name \ml{pp\_unambiguous\_comprehensions} -is set to \ml{true}. - +is set to \ml{1}. +(If the same trace is set to \ml{2}, then the unambiguous notation will never be used.) +\index{traces, controlling HOL feedback@traces, controlling \HOL{} feedback!set comprehensions} \subsection{Multisets (\theoryimp{bag})}\label{multiset} From abc8e7442c34375e51a32c9e7c49c0a4fd4c018c Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 2 Jun 2015 16:35:28 +1000 Subject: [PATCH 322/718] Test-case for repeated record def'n issue This is github issue #260. I don't see an error when attempting this; I do see warnings that I don't think should be there. --- src/datatype/theory_tests/gh260aScript.sml | 8 ++++++++ src/datatype/theory_tests/gh260bScript.sml | 10 ++++++++++ 2 files changed, 18 insertions(+) create mode 100644 src/datatype/theory_tests/gh260aScript.sml create mode 100644 src/datatype/theory_tests/gh260bScript.sml diff --git a/src/datatype/theory_tests/gh260aScript.sml b/src/datatype/theory_tests/gh260aScript.sml new file mode 100644 index 0000000000..e6737687ba --- /dev/null +++ b/src/datatype/theory_tests/gh260aScript.sml @@ -0,0 +1,8 @@ +open HolKernel Parse boolLib Datatype + +val _ = new_theory "gh260a"; + +val _ = Datatype`foo = <| fld : num |>`; + + +val _ = export_theory(); diff --git a/src/datatype/theory_tests/gh260bScript.sml b/src/datatype/theory_tests/gh260bScript.sml new file mode 100644 index 0000000000..bd389fe343 --- /dev/null +++ b/src/datatype/theory_tests/gh260bScript.sml @@ -0,0 +1,10 @@ +open HolKernel Parse boolLib Datatype + +open gh260aTheory + +val _ = new_theory "gh260b"; + +val _ = Datatype`foo = <| fld : num |>` + + +val _ = export_theory(); From 40f6b6ec497fb013a51e0ee0e6928e9bc0af26ab Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 2 Jun 2015 21:30:58 +1000 Subject: [PATCH 323/718] Improved test-cases for record redefinition bug For github issue #260 --- src/datatype/theory_tests/bar260Script.sml | 4 ++++ src/datatype/theory_tests/foo260Script.sml | 4 ++++ src/datatype/theory_tests/gh260aScript.sml | 8 -------- src/datatype/theory_tests/gh260bScript.sml | 10 ---------- 4 files changed, 8 insertions(+), 18 deletions(-) create mode 100644 src/datatype/theory_tests/bar260Script.sml create mode 100644 src/datatype/theory_tests/foo260Script.sml delete mode 100644 src/datatype/theory_tests/gh260aScript.sml delete mode 100644 src/datatype/theory_tests/gh260bScript.sml diff --git a/src/datatype/theory_tests/bar260Script.sml b/src/datatype/theory_tests/bar260Script.sml new file mode 100644 index 0000000000..f5ad0dce19 --- /dev/null +++ b/src/datatype/theory_tests/bar260Script.sml @@ -0,0 +1,4 @@ +open HolKernel Datatype foo260Theory; +val _ = new_theory"bar260"; +val _ = Datatype`foo = <| f : bool |>`; +val _ = export_theory(); diff --git a/src/datatype/theory_tests/foo260Script.sml b/src/datatype/theory_tests/foo260Script.sml new file mode 100644 index 0000000000..ff06070bb2 --- /dev/null +++ b/src/datatype/theory_tests/foo260Script.sml @@ -0,0 +1,4 @@ +open HolKernel Datatype +val _ = new_theory"foo260"; +val _ = Datatype`foo = <| f : bool |>`; +val _ = export_theory(); diff --git a/src/datatype/theory_tests/gh260aScript.sml b/src/datatype/theory_tests/gh260aScript.sml deleted file mode 100644 index e6737687ba..0000000000 --- a/src/datatype/theory_tests/gh260aScript.sml +++ /dev/null @@ -1,8 +0,0 @@ -open HolKernel Parse boolLib Datatype - -val _ = new_theory "gh260a"; - -val _ = Datatype`foo = <| fld : num |>`; - - -val _ = export_theory(); diff --git a/src/datatype/theory_tests/gh260bScript.sml b/src/datatype/theory_tests/gh260bScript.sml deleted file mode 100644 index bd389fe343..0000000000 --- a/src/datatype/theory_tests/gh260bScript.sml +++ /dev/null @@ -1,10 +0,0 @@ -open HolKernel Parse boolLib Datatype - -open gh260aTheory - -val _ = new_theory "gh260b"; - -val _ = Datatype`foo = <| fld : num |>` - - -val _ = export_theory(); From 70888e0cd78cbddb92186beb03d97bc70191717a Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 2 Jun 2015 21:34:21 +1000 Subject: [PATCH 324/718] RecordType: use mk_thy_const instead of mk_const Closes #260 --- src/datatype/record/RecordType.sml | 1 + 1 file changed, 1 insertion(+) diff --git a/src/datatype/record/RecordType.sml b/src/datatype/record/RecordType.sml index 06ad12246b..983021f8ed 100644 --- a/src/datatype/record/RecordType.sml +++ b/src/datatype/record/RecordType.sml @@ -178,6 +178,7 @@ fun prove_recordtype_thms (tyinfo, fields) = let (access_fn_names, access_defn_terms) val accessor_thm = save_thm(typename^"_accessors", LIST_CONJ access_defns) + fun mk_const(n,ty) = mk_thy_const{Thy=current_theory(), Name = n, Ty = ty} val accfn_terms = ListPair.map mk_const (access_fn_names, accfn_types) (* generate functional update functions *) From 58df742f5f710f64af891afde54b7f12a31d5acf Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 2 Jun 2015 21:35:27 +1000 Subject: [PATCH 325/718] Ignore *.fls files (LaTeX cruft) in Manual and below --- Manual/.gitignore | 1 + 1 file changed, 1 insertion(+) create mode 100644 Manual/.gitignore diff --git a/Manual/.gitignore b/Manual/.gitignore new file mode 100644 index 0000000000..074fd90120 --- /dev/null +++ b/Manual/.gitignore @@ -0,0 +1 @@ +*.fls From f5ff96e6510c12555c8b93cf935f2e957f6a3881 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 2 Jun 2015 21:38:27 +1000 Subject: [PATCH 326/718] Mention github issue #260 in release notes --- doc/next-release.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/doc/next-release.md b/doc/next-release.md index f2177a2522..c2a39d06a2 100644 --- a/doc/next-release.md +++ b/doc/next-release.md @@ -33,7 +33,7 @@ Bugs fixed: - `Holmake` will now follow `INCLUDES` specifications from `Holmakefiles` when given “phony” targets to build on the command-line. (A typical phony target is `all`.) As in the past, it will still act only locally if given just a clean target (`clean`, `cleanDeps` or `cleanAll`). To clean recursively, you must also pass the `-r` flag to `Holmake`. ([Github issue](http://github.com/HOL-Theorem-Prover/HOL/issues/145)) -- We fixed two problems with `Datatype`. Thanks to Ramana Kumar for both reports. +- We fixed three problems with `Datatype`. Thanks to Ramana Kumar for the reports. [First](http://github.com/HOL-Theorem-Prover/HOL/issues/257), `Datatype` will no longer create a recursive type if the recursive instance is qualified with a theory name other than the current one. In other words, @@ -44,6 +44,8 @@ Bugs fixed: [Second](http://github.com/HOL-Theorem-Prover/HOL/issues/257), `Datatype` will handle antiquotations in its input properly (`Hol_datatype` already did). + [Third](http://github.com/HOL-Theorem-Prover/HOL/issues/260), `Datatype` (and `Hol_datatype`) allows the definition of identical record types in different theories. + New theories: ------------- From 77b25b3951caf8903c496d997ad0f61c708449f2 Mon Sep 17 00:00:00 2001 From: Thomas Tuerk Date: Thu, 4 Jun 2015 12:59:46 +0200 Subject: [PATCH 327/718] cleanup deep_matches example --- examples/deep_matches/README | 6 +- examples/deep_matches/constrFamiliesLib.sig | 10 + examples/deep_matches/constrFamiliesLib.sml | 48 ++- examples/deep_matches/deepMatchesExamples.sml | 73 +++- examples/deep_matches/deepMatchesLib.sig | 82 +++- examples/deep_matches/deepMatchesLib.sml | 373 +++++++++++++++++- examples/deep_matches/deepMatchesScript.sml | 202 +++++++--- examples/deep_matches/deepMatchesSyntax.sig | 24 +- examples/deep_matches/deepMatchesSyntax.sml | 77 +++- 9 files changed, 781 insertions(+), 114 deletions(-) diff --git a/examples/deep_matches/README b/examples/deep_matches/README index e3d2abacb0..dee88c3e9b 100644 --- a/examples/deep_matches/README +++ b/examples/deep_matches/README @@ -1,4 +1,4 @@ -This directory contains a deep embedding of pattern matching. +This directory contains a formalisation of pattern matching. Normally, pattern matches are removed from the input by the parser of HOL4. An implementation of a pattern-match compilation algorithm @@ -18,8 +18,8 @@ example consider the ARM disassembler function `arm_decode` in of the pattern match compilation in such definitions? This pattern matching library tries to solve this problem. It provides -an internal representation of case-expressions that closely follows -the input synatx. The parsing and pretty printing of these deeply +a representation of case-expressions that closely follows +the input syntax. The parsing and pretty printing of these case-expressions is much simpler and therefore more trustworthy. The complicated, untrusted pattern match compilation can then be performed inside the logic. Therefore, the need to trust the implementation of diff --git a/examples/deep_matches/constrFamiliesLib.sig b/examples/deep_matches/constrFamiliesLib.sig index e81f82ce34..c741406216 100644 --- a/examples/deep_matches/constrFamiliesLib.sig +++ b/examples/deep_matches/constrFamiliesLib.sig @@ -25,6 +25,10 @@ sig The resulting term as well the used argument vars are returned. *) val mk_constructor_term : term list -> constructor -> (term * term list) + (* [match_constructor constr t] tries destruct [t] as a constructor + of [constr]. It returns NONE, if there is no match. Otherwise + the main constructor functions + labelled args. *) + val match_constructor : constructor -> term -> (term * (string * term) list) option (* We usually consider lists of constructors. It is an abstract type that should only be used via [make_constructorList]. *) @@ -140,6 +144,12 @@ sig val pmatch_compile_db_compile_nchotomy : pmatch_compile_db -> (term list * term) list -> thm option + (* This tries to destruct a term as a destructor. It looks + up in the given DB all possible constructors and tries to + apply match_constructor. *) + val pmatch_compile_db_dest_constr_term : pmatch_compile_db -> + term -> (term * (string * term) list) option + (* add a compile fun to a db *) val pmatch_compile_db_add_compile_fun : pmatch_compile_db -> pmatch_compile_fun -> pmatch_compile_db diff --git a/examples/deep_matches/constrFamiliesLib.sml b/examples/deep_matches/constrFamiliesLib.sml index cf019f3677..6a7134a907 100644 --- a/examples/deep_matches/constrFamiliesLib.sml +++ b/examples/deep_matches/constrFamiliesLib.sml @@ -1,7 +1,7 @@ structure constrFamiliesLib :> constrFamiliesLib = struct -open HolKernel boolLib simpLib bossLib +open HolKernel boolLib simpLib bossLib deepMatchesSyntax (***************************************************) (* Auxiliary definitions *) @@ -147,6 +147,15 @@ in (t, arg_vars') end +fun match_constructor (CONSTR (cr, args)) t = let + val (t', args') = strip_comb_bounded (List.length args) t +in + if (same_const t' cr) then + SOME (t', zip args args') + else NONE +end + + (* Multiple constructors for a single type are usually grouped. These can be exhaustive or not. *) type constructorList = { @@ -594,12 +603,8 @@ in colstat_cases = cases_no' } end - - -fun lookup_constructorFamilies force_exh (db : pmatch_compile_db) col = let - val _ = if (List.null col) then (failwith "constructorFamiliesLib" "lookup_constructorFamilies: null col") else () - val ty = type_of (snd (hd col)) - + +fun lookup_constructorFamilies_for_type (db : pmatch_compile_db) ty = let val cts_fams = let val cts_fams = TypeNet.match (#pcdb_constrFams db, ty) val cts_fams' = Lib.flatten (List.map (fn (ty, l) => @@ -623,9 +628,17 @@ fun lookup_constructorFamilies force_exh (db : pmatch_compile_db) col = let end val cts_fams' = List.filter (fn cf => not (is_old_fam cf)) cts_fams +in + cts_fams' +end +fun lookup_constructorFamily force_exh (db : pmatch_compile_db) col = let + val _ = if (List.null col) then (failwith "constructorFamiliesLib" "lookup_constructorFamilies: null col") else () + val ty = type_of (snd (hd col)) + + val cts_fams = lookup_constructorFamilies_for_type db ty val cts_fams' = if not force_exh then - cts_fams' + cts_fams else List.filter (fn (_, cf) => isSome (#nchotomy_thm cf)) cts_fams @@ -643,7 +656,7 @@ end; fun pmatch_compile_db_compile_aux db col = ( if (List.null col) then failwith "pmatch_compile_db_compile" "col 0" else let val fun_res = get_first (fn f => f col handle HOL_ERR _ => NONE) (#pcdb_compile_funs db) - val cf_res = lookup_constructorFamilies false db col + val cf_res = lookup_constructorFamily false db col fun process_cf_res (ty, cf) w = let val ty_s = match_type ty (type_of (snd (hd col))) @@ -669,7 +682,7 @@ fun pmatch_compile_db_compile_cf db col = ( case (snd (pmatch_compile_db_compile_aux db col)) of NONE => NONE | SOME (_, cf) => SOME cf -) +); (* fun pmatch_compile_db_compile_nchotomy db col = ( @@ -684,7 +697,7 @@ fun pmatch_compile_db_compile_nchotomy db col = ( fun pmatch_compile_db_compile_nchotomy db col = ( if (List.null col) then failwith "pmatch_compile_db_compile_nchotomy" "col 0" else let val fun_res = get_first (fn f => f col handle HOL_ERR _ => NONE) (#pcdb_nchotomy_funs db) - val cf_res = lookup_constructorFamilies true db col + val cf_res = lookup_constructorFamily true db col fun process_cf_res (_, cf) = #nchotomy_thm cf @@ -697,6 +710,19 @@ fun pmatch_compile_db_compile_nchotomy db col = ( end ); +fun pmatch_compile_db_dest_constr_term (db : pmatch_compile_db) t = let + val ty = type_of t + val cfs = lookup_constructorFamilies_for_type db ty + val cstrs = flatten (List.map (#cl_constructors o #constructors o snd) cfs) +in + first_opt (fn _ => fn cr => match_constructor cr t) cstrs +end + + +(***************************************************) +(* updating dbs *) +(***************************************************) + fun pmatch_compile_db_add_ssfrag (db : pmatch_compile_db) ss = { pcdb_compile_funs = #pcdb_compile_funs db, pcdb_nchotomy_funs = #pcdb_nchotomy_funs db, diff --git a/examples/deep_matches/deepMatchesExamples.sml b/examples/deep_matches/deepMatchesExamples.sml index cd4622510f..c8f2c60327 100644 --- a/examples/deep_matches/deepMatchesExamples.sml +++ b/examples/deep_matches/deepMatchesExamples.sml @@ -1,3 +1,8 @@ +(**************************************) +(* Examples for interactively playing *) +(* around with the pattern match lib *) +(**************************************) + open bossLib open deepMatchesLib open deepMatchesTheory @@ -9,7 +14,11 @@ open pred_setLib val _ = Globals.priming := SOME "_" -(* Introducing case expressions *) + +(********************************) +(* Parsing / Pretty Printing *) +(* Conversions *) +(********************************) val t = ``case x of (NONE, []) => 0`` val t' = ``CASE x OF [ ||. (NONE, []) ~> 0 ]`` @@ -618,7 +627,6 @@ val thm = PMATCH_REMOVE_REDUNDANT_CONV t (* Let's consider something more fancy *) - val t = ``CASE x OF [ || x. x when EVEN x ~> "EVEN"; ||. 2 ~> "2"; @@ -635,8 +643,69 @@ val thm = PMATCH_REMOVE_REDUNDANT_CONV t with some manual help *) val info_thm = COMPUTE_REDUNDANT_ROWS_INFO_OF_PMATCH t + +(* IS_REDUNDANT_ROWS_INFO_SHOW_ROW_IS_REDUNDANT_set_goal info_thm 3 *) val info_thm' = IS_REDUNDANT_ROWS_INFO_SHOW_ROW_IS_REDUNDANT info_thm 3 ( SIMP_TAC std_ss [LEFT_FORALL_IMP_THM] THEN METIS_TAC [arithmeticTheory.EVEN_OR_ODD] ) +val thm = IS_REDUNDANT_ROWS_INFO_TO_PMATCH_EQ_THM info_thm' + + + +(*********************************) +(* The same techniques can be *) +(* used to show exhaustiveness *) +(*********************************) + +val t = ``CASE (x, z) OF [ + ||. (NONE, NONE) ~> 0; + ||. (SOME _, _) ~> 1; + ||. (_, SOME _) ~> 2 +]`` + +val thm = PMATCH_IS_EXHAUSTIVE_CONSEQ_CONV t + +(* Now a case of a non-exhaustive match *) +val t = ``CASE (x, z) OF [ + ||. (NONE, NONE) ~> 0; + ||. (SOME _, _) ~> 1; + ||. (_, NONE) ~> 2 +]`` + +val thm = PMATCH_IS_EXHAUSTIVE_CONSEQ_CONV t + +(* We can automatically add the missing rows *) +val thm = PMATCH_COMPLETE_CONV true t + + +(* Let's consider something more fancy *) +val t = ``CASE x OF [ + || x. x when EVEN x ~> "EVEN"; + ||. 2 ~> "2"; + || x. x when ODD x ~> "ODD"; + ||. _ ~> "???" + ]`` + +(* The last row saves us :-) *) +val thm = PMATCH_IS_EXHAUSTIVE_CONSEQ_CONV t + +(* So without it, we need some manual effort *) +val t = ``CASE x OF [ + || x. x when EVEN x ~> "EVEN"; + || x. x when ODD x ~> "ODD" + ]`` + +val thm = PMATCH_IS_EXHAUSTIVE_CONSEQ_CONV t + +(* More interestingly, adding missing patterns works with + guards. *) + +val t = ``CASE x OF [ + || x. x when EVEN x ~> "EVEN" + ]`` + +val thm = PMATCH_IS_EXHAUSTIVE_CONSEQ_CONV t +val thm = PMATCH_COMPLETE_CONV true t +val thm = PMATCH_COMPLETE_CONV false t diff --git a/examples/deep_matches/deepMatchesLib.sig b/examples/deep_matches/deepMatchesLib.sig index 6f5f931214..28c26156a2 100644 --- a/examples/deep_matches/deepMatchesLib.sig +++ b/examples/deep_matches/deepMatchesLib.sig @@ -38,6 +38,10 @@ sig non-constructor patterns. *) val pmatch2case : term -> term + (* The following conversions call + case2pmatch and pmatch2case and + afterwards prove the equivalence of + the result. *) val PMATCH_INTRO_CONV : conv val PMATCH_INTRO_CONV_NO_OPTIMISE : conv val PMATCH_ELIM_CONV : conv @@ -138,11 +142,10 @@ sig (* A special case of lifting are function definitons, which use PMATCH. In order to use such definitions - with the rewritig tools, it is often handy to + with the rewriting tools, it is often handy to move the PMATCH to the toplevel and introduce multiple cases, one case for each row of the PMATCH. This is automated by the following rules. *) - val PMATCH_TO_TOP_RULE_GEN : ssfrag list -> rule val PMATCH_TO_TOP_RULE : rule @@ -189,9 +192,9 @@ sig val colHeu_default : column_heuristic - (*-------------*) - (* COMPILATION *) - (*-------------*) + (*---------------------*) + (* PATTERN COMPILATION *) + (*---------------------*) (* [PMATCH_CASE_SPLIT_CONV_GEN ssl db col_heu] is a conversion that tries to compile PMATCH expressions @@ -227,10 +230,11 @@ sig (* Pattern compilation builds for a list of patterns, implicitly a nchotomy theorem, i.e. a list of patterns that cover all the - original ones and are exhaustive. Moreover these patterns useually + original ones and are exhaustive. Moreover these patterns usually have some nice properties like e.g. not overlapping with each other. Such a nchotomy theorem is often handy. We use it to check for - exhaustiveness for example. The interface is exponsed here as well. *) + exhaustiveness for example. The interface + to compute such an nchotomy is exponsed here as well. *) (* [nchotomy_of_pats_GEN db colHeu pats] computes an nchotomy-theorem for a list of patterns. A pattern is written as for PMATCH, i.e. in the form ``\(v1, ..., vn). p v1 ... vn``. *) @@ -262,13 +266,77 @@ sig val COMPUTE_REDUNDANT_ROWS_INFO_OF_PMATCH_GEN : ssfrag list -> constrFamiliesLib.pmatch_compile_db -> column_heuristic -> term -> thm val COMPUTE_REDUNDANT_ROWS_INFO_OF_PMATCH : term -> thm + + (* Apply the resulting redundant rows-info *) val IS_REDUNDANT_ROWS_INFO_TO_PMATCH_EQ_THM : thm -> thm (* prove redundancy of given row given an info-thm *) val IS_REDUNDANT_ROWS_INFO_SHOW_ROW_IS_REDUNDANT : thm -> int -> tactic -> thm + val IS_REDUNDANT_ROWS_INFO_SHOW_ROW_IS_REDUNDANT_set_goal : thm -> int -> Manager.proof + + (*-----------------------*) + (* Exhaustiveness *) + (*-----------------------*) + + (* One can easily use a redundant rows info to + show that a pattern match is exhaustive. This + is done in the form of a consequence conversion. + So the user has to take care of a precondition (which is + ideally true) *) + + val PMATCH_IS_EXHAUSTIVE_CONSEQ_CONV : ConseqConv.conseq_conv; + + val PMATCH_IS_EXHAUSTIVE_CONSEQ_CONV_GEN : + constrFamiliesLib.pmatch_compile_db -> column_heuristic -> + ssfrag list -> ConseqConv.conseq_conv; + + + (* More interesting than just computing whether a PMATCH + expression is exhaustive might be adding at the end + additional rows that explicitly list the missing pats + and return ARB for them. This is achieved by the following + functions. + + The additional patterns can use guards or not. If not + guards are used, the added patterns are more coarse, but + simpler. *) + + val PMATCH_COMPLETE_CONV : bool -> conv + val PMATCH_COMPLETE_ss : bool -> ssfrag + + (* and as usual more general versions that allows using + own pattern compilation settings *) + val PMATCH_COMPLETE_CONV_GEN : ssfrag list -> + constrFamiliesLib.pmatch_compile_db -> column_heuristic -> + bool -> conv + val PMATCH_COMPLETE_GEN_ss : + ssfrag list -> + constrFamiliesLib.pmatch_compile_db -> + column_heuristic -> bool -> ssfrag + + + (*-----------------------*) + (* Show nchotomy *) + (*-----------------------*) + + (* [show_nchotomy t] tries to prove an nchotomy-theorem. + Given an nchotomy theorem of the form + ``!x. (?xs1. v = p1 xs1 /\ g1 xs1) \/ ... \/ + (?xsn. v = pn xsn /\ gn xsn)``. + It returns a theorem that is an implication with + the input as conclusion. *) + val SHOW_NCHOTOMY_CONSEQ_CONV : ConseqConv.conseq_conv + + (* A generalised version that allows specifying additional + parameters. *) + val SHOW_NCHOTOMY_CONSEQ_CONV_GEN : + ssfrag list -> constrFamiliesLib.pmatch_compile_db -> + column_heuristic -> ConseqConv.conseq_conv + + end diff --git a/examples/deep_matches/deepMatchesLib.sml b/examples/deep_matches/deepMatchesLib.sml index e1234a0bd6..66c58bf500 100644 --- a/examples/deep_matches/deepMatchesLib.sml +++ b/examples/deep_matches/deepMatchesLib.sml @@ -44,6 +44,7 @@ fun does_conv_loop thm = let i end + (***********************************************) (* Simpset to evaluate PMATCH_ROWS *) (***********************************************) @@ -52,6 +53,10 @@ val PAIR_EQ_COLLAPSE = prove ( ``(((FST x = (a:'a)) /\ (SND x = (b:'b))) = (x = (a, b)))``, Cases_on `x` THEN SIMP_TAC std_ss [] THEN METIS_TAC[]) +val PAIR_EQ_COLLAPSE = prove ( +``(((FST x = (a:'a)) /\ (SND x = (b:'b))) = (x = (a, b)))``, +Cases_on `x` THEN SIMP_TAC std_ss []) + fun is_FST_eq x t = let val (l, r) = dest_eq t val pred = aconv (pairSyntax.mk_fst x) @@ -107,7 +112,9 @@ val select_conj_ss = key = SOME ([],``$@ (f:'a -> bool)``), conv = K (K (SIMP_CONV (std_ss++boolSimps.CONJ_ss) []))}; - +(* A basic simpset-fragment with a lot of useful stuff + to automatically show the validity of preconditions + as produced by functions in this library. *) val static_ss = simpLib.merge_ss [pabs_elim_ss, pairSimps.paired_forall_ss, @@ -127,8 +134,17 @@ val static_ss = simpLib.merge_ss PAIR_EQ_COLLAPSE, oneTheory.one]]; +(* We add the stateful rewrite set (to simplify + e.g. case-constants or constructors) and a + custum component as well. *) fun rc_ss gl = srw_ss() ++ simpLib.merge_ss (static_ss :: gl) +(* finally we add a call-back component. This is an + external conversion that is used at the end if + everything else fails. This is used to have nested calls + of the simplifier. The simplifier executes some conversion that + uses rs_ss. At the end, we might want to use the external + simplifier. This is realised with these call-backs. *) fun callback_CONV cb_opt t = (case cb_opt of NONE => NO_CONV t | SOME cb => cb t) @@ -137,6 +153,8 @@ fun rc_conv_rws (gl, callback_opt) thms = REPEATC ( SIMP_CONV (rc_ss gl) thms THENC TRY_CONV (callback_CONV callback_opt)) +(* So, now combine it to get some convenient high-level + functions. *) fun rc_conv rc_arg = rc_conv_rws rc_arg [] fun rc_tac (gl, callback_opt) = @@ -150,8 +168,22 @@ in thm2 end -(* evaluate APPEND on both sides to get the theorem back in shape *) +(* fix_appends expects a theorem of the form + PMATCH v rows = PMATCH v' rows' + + and a term l of form + PMATCH v rows0. + + It tries to get the appends in rows and rows' in + a nice form. To do this, it tries to prove that + l and the lhs of the theorem are equal. + Then it tries to simplify appends in rows' + resulting in rows''. + + It returns a theorem of the form + l = PMATCH v' rows''. +*) fun fix_appends rc_arg l thm = let val t_eq_thm = prove (mk_eq (l, lhs (concl thm)), CONV_TAC (DEPTH_CONV listLib.APPEND_CONV) THEN @@ -173,6 +205,9 @@ in thm3 end +(* Apply a conversion to all args of a PMATCH_ROW, i.e. given + a term of the form ``PMATCH_ROW pat guard rhs i`` + it applies a conversion to ``pat`` ``guard`` and ``rhs``. *) fun PMATCH_ROW_ARGS_CONV c = RATOR_CONV (RAND_CONV (TRY_CONV c)) THENC RATOR_CONV (RATOR_CONV (RAND_CONV (TRY_CONV c))) THENC @@ -183,6 +218,11 @@ fun PMATCH_ROW_ARGS_CONV c = (* converting between case-splits to PMATCH *) (***********************************************) +(* ----------------------- *) +(* Auxiliary functions for *) +(* case2pmatch *) +(* ----------------------- *) + (* val t = ``case x of (NONE, []) => 0`` *) @@ -349,6 +389,12 @@ in check_rows [] ps' end + +(* ----------------------- *) +(* End Auxiliary functions *) +(* for case2pmatch *) +(* ----------------------- *) + (* val (p1, rh1) = el 5 ps val (p2, rh2) = mk_distinct_rows (p1, rh1) (el 6 ps) @@ -387,6 +433,12 @@ in mk_PMATCH p rows_tm_p end +(* So far, we converted a classical case-expression + to a PMATCH without any proof. The following is used + to prove the equivalence of the result via repeated + case-splits and evaluation. This allows to + define some conversions then. *) + val COND_CONG_STOP = prove (`` (c = c') ==> ((if c then x else y) = (if c' then x else y))``, SIMP_TAC std_ss []) @@ -414,6 +466,11 @@ fun PMATCH_INTRO_CONV t = fun PMATCH_INTRO_CONV_NO_OPTIMISE t = case_pmatch_eq_prove t (case2pmatch false t) + +(* ------------------------- *) +(* pmatch2case *) +(* ------------------------- *) + (* convert a case-term into a PMATCH-term, without any proofs *) fun pmatch2case t = let val (v, rows) = dest_PMATCH t @@ -455,6 +512,7 @@ fun PMATCH_ELIM_CONV t = case_pmatch_eq_prove t (pmatch2case t) + (***********************************************) (* removing redundant rows *) (***********************************************) @@ -476,8 +534,16 @@ val t = `` ||! x::y::z::_ ~> (x + x + x) ]`` +val (rows, _) = listSyntax.dest_list (rand t) *) +(* For removing redundant rows we want to check whether + the pattern of a row is overlapped by the pattern of a + previous row. In preparation for this, we extract all + patterns and generate fresh variables for it. The we + build for all rows the pair of the pattern + the patterns + of all following rows. This allows for simple checks + via matching later. *) fun compute_row_pat_pairs rows = let (* get pats with fresh vars to do a quick prefiltering *) val pats_unique = Lib.enumerate 0 (Lib.mapfilter (fn r => let @@ -502,7 +568,7 @@ in candidates end - +(* Now do the real filtering *) fun PMATCH_REMOVE_FAST_REDUNDANT_CONV_GENCALL_SINGLE rc_arg t = let val (v, rows) = dest_PMATCH t val candidates = compute_row_pat_pairs rows @@ -857,6 +923,8 @@ val PMATCH_CLEANUP_CONV = PMATCH_CLEANUP_CONV_GEN []; (* simplify a column *) (***********************************************) +(* This can also be considered partial evaluation *) + fun pair_get_col col v = let val vs = pairSyntax.strip_pair v val c_v = List.nth (vs, col) @@ -1604,6 +1672,29 @@ val PMATCH_REMOVE_GUARDS_ss = PMATCH_REMOVE_GUARDS_GEN_ss [] (* Lifting to lowest boolean level *) (***********************************************) +(* One can replace pattern matches with a big-conjunction. + Each row becomes one conjunct. Since the conjunction is + of type bool, this needs to be done at a boolean level. + So we can replace an arbitry term + + P (PMATCH i rows) with + + (row_cond 1 i -> P (row_rhs 1)) /\ + ... + (row_cond n i -> P (row_rhs n)) /\ + + The row-cond contains that the pattern does not overlap with + any previous pattern, that the guard holds. + + The most common use-case of lifting are function definitions. + of the form + + f x = PMATCH x rows + + which can be turned into a conjunction of top-level + rewrite rules for the function f. +*) + (* @@ -1788,8 +1879,14 @@ fun PMATCH_TO_TOP_RULE thm = PMATCH_TO_TOP_RULE_GEN [] thm; (* PATTERN COMPILATION *) (***********************************************) -type column_heuristic = - (term * (term list * term) list) list -> int +(* A column heuristic is a function that chooses the + next column to perform a case split on. + It gets a list of columns of the pattern match, i.e. + the input value + a list of the patterns in each row. + The patterns are represented as a pair of + a list of free variables and the real pattern. *) +type column = (term * (term list * term) list) +type column_heuristic = column list -> int (* one that uses always the first column *) val colHeu_first_col : column_heuristic = (fn _ => 0) @@ -1897,6 +1994,9 @@ fun colHeu_cqba db = colHeu_rank [colRank_first_row_constr db, fun colHeu_default cols = colHeu_qba (!thePmatchCompileDB) cols +(* Now we can define a case-split function that performs + case-splits using such heuristics. *) + (* val t = ``CASE (a,x,xs) OF [ || x. (NONE,x,[]) ~> x; @@ -2556,6 +2656,23 @@ in end handle HOL_ERR _ => raise UNCHANGED +fun find_non_constructor_pattern db vs t = let + fun aux l = case l of + [] => NONE + | (t::ts) => if (mem t vs) then aux ts else ( + if (pairSyntax.is_pair t) then + aux ((pairSyntax.strip_pair t)@ts) + else ( + case pmatch_compile_db_dest_constr_term db t of + NONE => SOME t + | SOME (_, args) => aux ((map snd args) @ ts) + ) + ) +in + aux [t] +end + + fun COMPUTE_REDUNDANT_ROWS_INFO_OF_PMATCH_GENCALL rc_arg db col_heu t = let val (v, rows) = dest_PMATCH t @@ -2567,7 +2684,9 @@ let val nchot_thm = let val pats = List.map (#1 o dest_PMATCH_ROW) rows val thm01 = nchotomy_of_pats_GEN db col_heu pats - val thm02 = CONV_RULE (nchotomy2PMATCH_ROW_COND_EX_CONV) thm01 + val thm02 = CONV_RULE (nchotomy2PMATCH_ROW_COND_EX_CONV_GEN + (find_non_constructor_pattern db) + ) thm01 val thm03 = ISPEC v thm02 in thm03 @@ -2710,4 +2829,246 @@ in end +(*************************************) +(* Exhaustiveness *) +(*************************************) + +(* +val db = !thePmatchCompileDB +val col_heu = colHeu_default +val rc_arg = ([], NONE) +*) + + +(* +val t = ``CASE (x, z) OF [ + ||. (NONE, NONE) ~> 0; + ||. (_, SOME _) ~> 2 +]`` + +val t = ``CASE (x, z) OF [ + ||. (NONE, NONE) ~> 0; + ||. (SOME _, _) ~> 1; + ||. (_, NONE) ~> 2 +]`` + +val t = ``CASE (x, z) OF [ + ||. (NONE, 1) ~> 0; + ||. (SOME _, 2) ~> 1; + || x. (_, x) when x > 5 ~> 2 +]`` + +val info_thm = COMPUTE_REDUNDANT_ROWS_INFO_OF_PMATCH t + +*) + + +fun IS_REDUNDANT_ROWS_INFO_TO_PMATCH_IS_EXHAUSTIVE info_thm = let + val thm0 = MATCH_MP IS_REDUNDANT_ROWS_INFO_EXTRACT_IS_EXHAUSTIVE + info_thm +in + thm0 +end + + +fun PMATCH_IS_EXHAUSTIVE_CONSEQ_CONV_GEN db col_heu ssl t = let + val info_thm = COMPUTE_REDUNDANT_ROWS_INFO_OF_PMATCH_GENCALL (ssl, NONE) db col_heu t +in + IS_REDUNDANT_ROWS_INFO_TO_PMATCH_IS_EXHAUSTIVE info_thm +end + +fun PMATCH_IS_EXHAUSTIVE_CONSEQ_CONV t = + PMATCH_IS_EXHAUSTIVE_CONSEQ_CONV_GEN + (!thePmatchCompileDB) colHeu_default [] t; + + + + +(*************************************) +(* Nchotomy *) +(*************************************) + +(* +val db = !thePmatchCompileDB +val col_heu = colHeu_default +val rc_arg = ([], NONE) +*) + + +val neg_imp_rewr = prove (``(~A ==> B) = (~B ==> A)``, + Cases_on `A` THEN Cases_on `B` THEN REWRITE_TAC[]); + +fun nchotomy_PMATCH_ROW_COND_EX_CONSEQ_CONV_GEN rc_arg db col_heu tt = let + (* destruct everything *) + val (v, disjs) = let + val disjs = strip_disj tt + val (v, _, _) = dest_PMATCH_ROW_COND_EX (hd disjs) + in + (v, disjs) + end + + (* Sanity check *) + val _ = List.map (fn r => let + val (v', _, _) = dest_PMATCH_ROW_COND_EX r + val _ = if (aconv v v') then () else failwith "illformed input" + in () end) disjs + + (* derive nchot thm *) + val nchot_thm = let + val pats = List.map (#2 o dest_PMATCH_ROW_COND_EX) disjs + val thm01 = nchotomy_of_pats_GEN db col_heu pats + val thm02 = CONV_RULE (nchotomy2PMATCH_ROW_COND_EX_CONV_GEN + (find_non_constructor_pattern db)) thm01 + val thm03 = ISPEC v thm02 + in + thm03 + end + + (* prepare assumptions *) + val neg_tt = mk_neg tt + val pre_thms = let + val thm00 = ASSUME neg_tt + val thm01 = PURE_REWRITE_RULE [DE_MORGAN_THM] thm00 + in BODY_CONJUNCTS thm01 end + + + (* apply these assumptions to the nchot_thm *) + val nchot_thm' = let + fun step (pre_thm, thm) = + CONV_RULE (PMATCH_ROW_COND_EX_DISJ_WEAKEN_CONV_GENCALL rc_arg pre_thm) thm + val thm00 = foldl step nchot_thm pre_thms + val thm01 = DISCH neg_tt thm00 + in + thm01 + end + + val nchot_thm'' = let + val thm00 = CONV_RULE (REWR_CONV neg_imp_rewr) nchot_thm' + val thm01 = CONV_RULE (RATOR_CONV (RAND_CONV (REWRITE_CONV []))) thm00 + in thm01 end + +in + nchot_thm'' +end + + +fun SHOW_NCHOTOMY_CONSEQ_CONV_GEN ssl db col_heu tt = let + val (x, b) = dest_forall tt + val b_thm = ALL_DISJ_CONV (PMATCH_ROW_COND_EX_INTRO_CONV_GEN + (find_non_constructor_pattern db) x) b + + val thm2 = nchotomy_PMATCH_ROW_COND_EX_CONSEQ_CONV_GEN (ssl, NONE) db col_heu (rhs (concl b_thm)) + + val thm3 = CONV_RULE (RAND_CONV (K (GSYM b_thm))) thm2 + + val thm4 = CONV_RULE (RATOR_CONV (RAND_CONV (DEPTH_CONV (PMATCH_ROW_COND_EX_ELIM_CONV)))) thm3 + + val thm5 = GEN x thm4 +in + thm5 +end + +fun SHOW_NCHOTOMY_CONSEQ_CONV tt = + SHOW_NCHOTOMY_CONSEQ_CONV_GEN [] (!thePmatchCompileDB) colHeu_default tt + + + +(*************************************) +(* Add missing patterns *) +(*************************************) + +(* +val use_guards = true +val rc_arg = ([], NONE) +val db = !thePmatchCompileDB +val col_heu = colHeu_default +*) + +fun PMATCH_COMPLETE_CONV_GENCALL rc_arg db col_heu use_guards t = let + val (v, rows) = dest_PMATCH t + fun row_to_cond_ex r = let + val (vs_t, p, g, _) = dest_PMATCH_ROW_ABS r + val vs = pairSyntax.strip_pair vs_t + in + mk_PMATCH_ROW_COND_EX_PABS_MOVE_TO_GUARDS (find_non_constructor_pattern db) vs (v, p, g) + end + val disjs = List.map row_to_cond_ex rows + val disjs_tm = list_mk_disj disjs + + val thm_nchot = nchotomy_PMATCH_ROW_COND_EX_CONSEQ_CONV_GEN rc_arg db col_heu disjs_tm + + val missing_list = let + val pre = fst (dest_imp (concl thm_nchot)) + val disj = dest_neg pre + in + strip_disj disj + end handle HOL_ERR _ => raise UNCHANGED + + fun add_missing_pat (missing_t, thm) = let + val (_, vs, p_t0, g_t0) = dest_PMATCH_ROW_COND_EX_ABS missing_t + val g_t1 = if use_guards then g_t0 else T + val g_t = pairSyntax.mk_pabs (vs, g_t1) + val p_t = pairSyntax.mk_pabs (vs, p_t0) + val r_t = pairSyntax.mk_pabs (vs, mk_arb (type_of t)) + + val thm00 = FRESH_TY_VARS_RULE PMATCH_REMOVE_ARB + val rows_t = (rand o rhs o concl) thm + val thm01 = ISPECL [p_t, g_t, r_t, v, rows_t] thm00 + val thm02 = rc_elim_precond rc_arg thm01 + val thm03 = GSYM thm02 + val thm04 = RIGHT_CONV_RULE (RAND_CONV (listLib.SNOC_CONV)) thm03 + in + TRANS thm thm04 + end + +in + foldl add_missing_pat (REFL t) missing_list +end + +fun PMATCH_COMPLETE_CONV_GEN ssl = + PMATCH_COMPLETE_CONV_GENCALL (ssl, NONE); + +val PMATCH_COMPLETE_CONV = + PMATCH_COMPLETE_CONV_GEN [] (!thePmatchCompileDB) colHeu_default; + +fun PMATCH_COMPLETE_GEN_ss ssl db colHeu use_guards = + make_gen_conv_ss (fn rc_arg => + PMATCH_COMPLETE_CONV_GENCALL rc_arg db colHeu use_guards) + "PMATCH_COMPLETE_REDUCER" ssl; + +val PMATCH_COMPLETE_ss = PMATCH_COMPLETE_GEN_ss [] (!thePmatchCompileDB) colHeu_default; + + +(* + + +val tt = rhs (concl thm) +val x = el 2 (free_vars tt) +val tt = mk_forall(v, tt) + +val thm = DEPTH_CONV (PMATCH_ROW_COND_EX_ELIM_CONV) tt + +val t = dest_forall ``!x y. XXX`` +val t = ``PMATCH (x,z) [ + ||. (NONE, c) ~> 0 +]`` + +val t = ``PMATCH (x, z) [ + ||. (NONE, c) ~> 0; + ||. (SOME _, _) ~> 1; + ||. (_, NONE) ~> 2 +]`` + +val (v, rows) = dest_PMATCH t +fun mk_xx r = let + val (p, g, _) = dest_PMATCH_ROW r +in + mk_PMATCH_ROW_COND_EX (v, p, g) +end +val disjs = List.map mk_xx rows +val disjs_tm = list_mk_disj disjs +val tt = list_mk_disj disjs +*) + + end diff --git a/examples/deep_matches/deepMatchesScript.sml b/examples/deep_matches/deepMatchesScript.sml index 0fa94ceac5..5867015c64 100644 --- a/examples/deep_matches/deepMatchesScript.sml +++ b/examples/deep_matches/deepMatchesScript.sml @@ -69,38 +69,40 @@ Cases_on `x` THEN Cases_on `x'` THEN ( (* Main Definitions *) (***************************************************) -(* rows of a pattern match are pairs of a pattern to match - against pat, a guard and a result value. *) -val PMATCH_ROW_COND_def = Define `PMATCH_ROW_COND pat guard i x = - (pat x = i) /\ (guard x)` +(* rows of a case-expression consist of a + - pattern p + - guard g + - rhs r -val PMATCH_ROW_def = Define `PMATCH_ROW pat guard res i = - (OPTION_MAP res (some x. PMATCH_ROW_COND pat guard i x))` + A row matches an input value i with a variable + binding v, iff the following + predicate holds. *) +val PMATCH_ROW_COND_def = Define `PMATCH_ROW_COND pat guard inp v = + (pat v = inp) /\ (guard v)` + +(* With this we can easily define the semantics of a row *) +val PMATCH_ROW_def = Define `PMATCH_ROW pat guard rhs i = + (OPTION_MAP rhs (some v. PMATCH_ROW_COND pat guard i v))` (* We defined semantics of single rows. Let's extend - it to multiple ones, i.e. full pattern matches now *) + it to multiple ones, i.e. full pattern matches now. *) val PMATCH_INCOMPLETE_def = Define `PMATCH_INCOMPLETE = ARB` val PMATCH_def = Define ` (PMATCH v [] = PMATCH_INCOMPLETE) /\ (PMATCH v (r::rs) = option_CASE (r v) (PMATCH v rs) I)` -val PMATCH_IS_EXHAUSTIVE_def = Define ` - PMATCH_IS_EXHAUSTIVE v rs = ( - EXISTS (\r. IS_SOME (r v)) rs)` - -val PMATCH_ROW_REDUNDANT_def = Define ` - PMATCH_ROW_REDUNDANT v rs i = ( - (i < LENGTH rs /\ (IS_SOME ((EL i rs) v) ==> - (?j. ((j < i) /\ IS_SOME ((EL j rs) v))))))` - - (***************************************************) (* Constants for parsing magic *) (***************************************************) +(* We need some dummy constant without any semnatic meaning + for setting up some parser magic. It is HOL 4 specific + and boring technical stuff. You can safely ignore the following. *) + val _ = new_constant ("PMATCH_magic_1", type_of ``PMATCH``) + val _ = new_constant ("PMATCH_ROW_magic_1", type_of ``\abc. PMATCH_ROW (\x. FST (abc x)) (\x. FST (SND (abc x))) (\x. SND (SND ((abc x))))``) @@ -116,10 +118,18 @@ val _ = new_constant ("PMATCH_ROW_magic_2", type_of val _ = new_constant ("PMATCH_ROW_magic_3", type_of ``\(pat:'a) (res:'b). (pat,T,res)``) + + (***************************************************) (* Congruences for termination *) (***************************************************) +(* Pattern matches expressed via PMATCH should + be usable in recursive function defintions. In order + to be able to do this, we need to set up some + congruence theorems that guide the automatic + wellfoundedness (termination) checker. *) + val PMATCH_ROW_CONG = store_thm ("PMATCH_ROW_CONG", ``!p p' g g' r r' v v'. (p = p') /\ (v = v') /\ @@ -220,10 +230,15 @@ SIMP_TAC std_ss [PMATCH_EVAL, (* Changing rows and removing redundant ones *) (***************************************************) -(* An easy way is to start with an empty list of rows - and then step by step add rows to either one or both - sides till the desired correspondance is shown. This - is achieved by the following theorems. *) +(* For many of automatic methods, we need to show + that two PMATCH expressions which are derived from + each other by modifying or dropping rows are equivalent. + We want to perform these proofs in an a way that can be + automated nicely. In the following, we provide lemmata that + given an established equivalence, allow adding + a row to both or a single side. + By starting with an empty list and iterating, one can + use this method to construct the desired correspondance. *) val PMATCH_EXTEND_BASE = store_thm ("PMATCH_EXTEND_BASE", ``!v_old v_new. (PMATCH v_old [] = PMATCH v_new [])``, SIMP_TAC std_ss [PMATCH_def]) @@ -254,6 +269,10 @@ SIMP_TAC std_ss [PMATCH_def]) (* Simplifying case expressions *) (***************************************************) +(* We can now construct equivalences of case expressions, provided + we can reason about the semantics of single rows. So, + let's now consider useful theorems for single rows. *) + (* Add an injective function to the pattern and the value. This can be used to eliminate constructors. *) val PMATCH_ROW_REMOVE_FUN = store_thm ("PMATCH_ROW_REMOVE_FUN", @@ -266,30 +285,6 @@ REPEAT STRIP_TAC THEN `!x y. (ff x = ff y) = (x = y)` by PROVE_TAC[] THEN ASM_SIMP_TAC std_ss [PMATCH_ROW_def, PMATCH_ROW_COND_def]) -(* -val PMATCH_ROW_REMOVE_FUN_EXT = store_thm ("PMATCH_ROW_REMOVE_FUN_EXT", -``!ff v f f' g g'. - - ((?x. f' x = ff v) = (?x. f x = v)) ==> - (!x x'. (f' x = ff v) ==> (f x' = v) ==> (g x v = g' x')) ==> - - (PMATCH_ROW (\x. (f' x, g x v)) (ff v) = - PMATCH_ROW (\x. (f x, g' x)) v)``, - -REPEAT STRIP_TAC THEN -ASM_SIMP_TAC std_ss [PMATCH_ROW_def] THEN -Cases_on `?x. f x = v` THEN ( - ASM_REWRITE_TAC[] -) THEN -SELECT_ELIM_TAC THEN -ASM_REWRITE_TAC [] THEN -REPEAT STRIP_TAC THEN -SELECT_ELIM_TAC THEN -ASM_REWRITE_TAC [] THEN -REPEAT STRIP_TAC THEN -PROVE_TAC[]) - -*) (* The following lemma looks rather complicated. It is intended to work together with PMATCH_ROW_REMOVE_FUN to @@ -469,9 +464,10 @@ ASM_REWRITE_TAC[]) -(* A row is redundant, if it is made redundant by exactly one +(* A row is redundant, if (but not(!) only if) it is made + redundant by exactly one row above. This is simple to test and often already very - helful. More fancy tests involving multiple rows follow below *) + helful. More fancy tests involving multiple rows follow below. *) val PMATCH_ROWS_DROP_REDUNDANT = store_thm ( "PMATCH_ROWS_DROP_REDUNDANT", ``!r1 r2 rows1 rows2 rows3 v. @@ -516,9 +512,10 @@ METIS_TAC[IS_SOME_DEF]); (* Some rows are not redundant in the classical sense, but can safely be dropped nevertheless. A redundant row never matches, - because it is shaddowed by a previous row. One can also also - drop rows, if a later row matches if they match and return the + because it is shaddowed by a previous row. One can also + drop rows, if a later row matches if they match and returns the same value. I will call such rows subsumed. *) + val PMATCH_ROWS_DROP_SUBSUMED = store_thm ( "PMATCH_ROWS_DROP_SUBSUMED", ``!r1 r2 rows1 rows2 rows3 v. @@ -581,8 +578,12 @@ REPEAT STRIP_TAC THENL [ ]); +(* A common case for removing subsumed rows + is removing ARB rows that are introduced by + translating a classical case-expression naively. *) val PMATCH_REMOVE_ARB = store_thm ("PMATCH_REMOVE_ARB", -``(!x. r x = ARB) ==> +``!p g r v rows. + (!x. r x = ARB) ==> (PMATCH v (SNOC (PMATCH_ROW p g r) rows) = PMATCH v rows)``, @@ -617,15 +618,24 @@ ASM_SIMP_TAC std_ss []) (* Fancy redundancy check *) (***************************************************) -val PMATCH_ROW_COND_EX_def = Define `PMATCH_ROW_COND_EX i p g = -?x. PMATCH_ROW_COND p g i x` +(* Let's first define when a row is redundant. + The predicate PMATCH_ROW_REDUNDANT v rs i holds, + iff row number i is redundant for input v in the + list of rows rs. *) +val PMATCH_ROW_REDUNDANT_def = Define ` + PMATCH_ROW_REDUNDANT v rs i = ( + (i < LENGTH rs /\ (IS_SOME ((EL i rs) v) ==> + (?j. ((j < i) /\ IS_SOME ((EL j rs) v))))))`; -val PMATCH_ROW_COND_EX_FULL_DEF = store_thm ("PMATCH_ROW_COND_EX_FULL_DEF", - ``PMATCH_ROW_COND_EX i p g = - ?x. (i = p x) /\ g x``, -SIMP_TAC std_ss [PMATCH_ROW_COND_EX_def, PMATCH_ROW_COND_def] THEN -METIS_TAC[]) +(* We can accumulate redundancy information for all rows. + This is done via IS_REDUNDANT_ROWS_INFO v rows c infos. + If the n-th entry of list infos is true, then the n-th + row of rows is redundant for input v. If it is not true, + it may or may not be redundant. + The parameter c is used for accumulating information + of all rows already in the info. If none of the rows + in rows matches, c holds. *) val IS_REDUNDANT_ROWS_INFO_def = Define ` IS_REDUNDANT_ROWS_INFO v rows c infos <=> ( (LENGTH rows = LENGTH infos) /\ @@ -634,6 +644,9 @@ val IS_REDUNDANT_ROWS_INFO_def = Define ` (EVERY (\r. r v = NONE) rows ==> c))` +(* This setup allows to build up such an info + row by row. We start with a list of empty rows + and add new rows at the end using the information in c. *) val IS_REDUNDANT_ROWS_INFO_NIL = store_thm ( "IS_REDUNDANT_ROWS_INFO_NIL", ``!v. IS_REDUNDANT_ROWS_INFO v [] T []``, @@ -673,6 +686,12 @@ Cases_on `r' v` THEN ( )) +(* However, we still need to specialise this for + rows of the from PMATCH_ROW. For this case, it is handy + to use an auxiliary definition. *) +val PMATCH_ROW_COND_EX_def = Define `PMATCH_ROW_COND_EX i p g = +?x. PMATCH_ROW_COND p g i x` + val IS_REDUNDANT_ROWS_INFO_SNOC_PMATCH_ROW = store_thm ( "IS_REDUNDANT_ROWS_INFO_SNOC_PMATCH_ROW", @@ -687,7 +706,8 @@ MATCH_MP_TAC (REWRITE_RULE [AND_IMP_INTRO] IS_REDUNDANT_ROWS_INFO_SNOC) THEN Q.EXISTS_TAC `c` THEN FULL_SIMP_TAC std_ss [PMATCH_ROW_EQ_NONE, PMATCH_ROW_COND_EX_def] THEN METIS_TAC[]) - + +(* A rewrite rule useful for proofs. *) val IS_REDUNDANT_ROWS_INFO_CONS = store_thm ( "IS_REDUNDANT_ROWS_INFO_CONS", `` @@ -733,6 +753,9 @@ REPEAT STRIP_TAC THENL [ ]) +(* We can use such a REDUNDANT_ROWS_INFO to prune + the a pattern match *) + val APPLY_REDUNDANT_ROWS_INFO_def = Define ` (APPLY_REDUNDANT_ROWS_INFO is xs = MAP SND ( FILTER (\x. ~ (FST x)) (ZIP (is, xs))))` @@ -792,7 +815,29 @@ MATCH_MP_TAC PMATCH_ROWS_DROP_REDUNDANT_ROWS_INFO_EQUIV THEN PROVE_TAC[]) -(* One can easily mark rows as not redundant without proof *) +(* We get exhautiveness information for free using + the accumulated information in c *) +val PMATCH_IS_EXHAUSTIVE_def = Define ` + PMATCH_IS_EXHAUSTIVE v rs = ( + EXISTS (\r. IS_SOME (r v)) rs)` + +val IS_REDUNDANT_ROWS_INFO_EXTRACT_IS_EXHAUSTIVE = + store_thm ("IS_REDUNDANT_ROWS_INFO_EXTRACT_IS_EXHAUSTIVE", + ``!v rows c infos. + IS_REDUNDANT_ROWS_INFO v rows c infos ==> + ~c ==> PMATCH_IS_EXHAUSTIVE v rows``, + +SIMP_TAC list_ss [IS_REDUNDANT_ROWS_INFO_def, + PMATCH_IS_EXHAUSTIVE_def, combinTheory.o_DEF, + quantHeuristicsTheory.IS_SOME_EQ_NOT_NONE +]) + + +(* One can easily mark rows as not redundant without proof. + This is handy for avoiding complicated procedures to check, + whether some element of infos is true or false. If in doub + replace it with false. Technically this is done by + building a pairwise conjunction with a given list. *) val REDUNDANT_ROWS_INFOS_CONJ_def = Define ` REDUNDANT_ROWS_INFOS_CONJ ip1 ip2 = (MAP2 (\i1 i2. i1 /\ i2) ip1 ip2)`; @@ -804,7 +849,7 @@ val REDUNDANT_ROWS_INFOS_CONJ_REWRITE = store_thm ( (i1 /\ i2) :: (REDUNDANT_ROWS_INFOS_CONJ is1 is2))``, SIMP_TAC list_ss [REDUNDANT_ROWS_INFOS_CONJ_def]) - +(* So, we can weaken an existing REDUNDANT_ROWS_INFOS *) val REDUNDANT_ROWS_INFOS_CONJ_THM = store_thm ("REDUNDANT_ROWS_INFOS_CONJ_THM", ``!v rows c infos c' infos'. IS_REDUNDANT_ROWS_INFO v rows c infos ==> @@ -830,6 +875,7 @@ SIMP_TAC list_ss [IS_REDUNDANT_ROWS_INFO_def, REDUNDANT_ROWS_INFOS_DISJ_def, MAP2_MAP, EL_MAP, EL_ZIP] THEN METIS_TAC[]) + (* One can use the always correct, but usually much too complicated strongest redundant_rows_info for strengthening *) @@ -956,7 +1002,14 @@ ASM_SIMP_TAC (list_ss++boolSimps.CONJ_ss) [MEM_EL,rich_listTheory.EL_TAKE] THEN PROVE_TAC[]) +(* IN order to automate this procedure, we need a few + simple, additional lemmata *) +val PMATCH_ROW_COND_EX_FULL_DEF = store_thm ("PMATCH_ROW_COND_EX_FULL_DEF", + ``PMATCH_ROW_COND_EX i p g = + ?x. (i = p x) /\ g x``, +SIMP_TAC std_ss [PMATCH_ROW_COND_EX_def, PMATCH_ROW_COND_def] THEN +METIS_TAC[]) val PMATCH_ROW_COND_EX_WEAKEN = store_thm ("PMATCH_ROW_COND_EX_WEAKEN", ``!f v p g p' g'. @@ -970,7 +1023,7 @@ SIMP_TAC std_ss [PMATCH_ROW_COND_EX_def, PMATCH_ROW_COND_def] THEN REPEAT STRIP_TAC THEN CONSEQ_CONV_TAC (K EXISTS_EQ___CONSEQ_CONV) THEN SIMP_TAC (std_ss++boolSimps.EQUIV_EXTRACT_ss) [] THEN -METIS_TAC[]) +METIS_TAC[]); val PMATCH_ROW_COND_EX_FALSE = store_thm ("PMATCH_ROW_COND_EX_FALSE", ``!v p g. @@ -986,13 +1039,30 @@ val PMATCH_ROW_COND_EX_IMP_REWRITE = store_thm ("PMATCH_ROW_COND_EX_IMP_REWRITE" (PMATCH_ROW_COND_EX v p' g' = RES)``, SIMP_TAC std_ss [PMATCH_ROW_COND_EX_def, PMATCH_ROW_COND_def, - GSYM LEFT_FORALL_IMP_THM]) + GSYM LEFT_FORALL_IMP_THM]); + +(* Use this simple contradiction to bring + PMATCH_IS_EXHAUSTIVE in the form we need for + automation *) +val PMATCH_IS_EXHAUSTIVE_CONTRADICT = store_thm ( + "PMATCH_IS_EXHAUSTIVE_CONTRADICT", +``!v rs. + (EVERY (\r. r v = NONE) rs ==> F) ==> + (PMATCH_IS_EXHAUSTIVE v rs)``, + +REPEAT STRIP_TAC THEN +FULL_SIMP_TAC list_ss [PMATCH_IS_EXHAUSTIVE_def, + combinTheory.o_DEF, quantHeuristicsTheory.IS_SOME_EQ_NOT_NONE]) (***************************************************) (* ELIMINATE DOUBLE VAR-BINDS *) (***************************************************) +(* If a variable is used multiple times in a pattern, + we can via the following theorem introduce a fresh variable + and add the connection between the old and the newly created + var to the guard. *) val PMATCH_ROW_REMOVE_DOUBLE_BINDS_THM = store_thm ("PMATCH_ROW_REMOVE_DOUBLE_BINDS_THM", ``!g p1 g1 r1 p2 g2 r2. @@ -1022,6 +1092,12 @@ REPEAT STRIP_TAC THEN ( (* ELIMINATE GUARDS *) (***************************************************) +(* We can eliminate guards by replacing them with true + and add the guard in form of a conditional. + Notice that all the rows after the guard are + duplicated. We heavily rely on simplification + of PMATCH to avoid a huge blowup of term-size, + when applying the following rule. *) val GUARDS_ELIM_THM = store_thm ("GUARDS_ELIM_THM", ``!v rs1 rs2 p g r. (!x1 x2. (p x1 = p x2) ==> (x1 = x2)) ==> ( @@ -1048,6 +1124,8 @@ ASM_SIMP_TAC (std_ss++boolSimps.CONJ_ss) []); (* THEOREMS ABOUT FLATTENING *) (***************************************************) +(* The content of this section is still experimental. + It is likely to chnage quite a bit still. *) val PMATCH_FLATTEN_FUN_def = Define ` PMATCH_FLATTEN_FUN p g row v = ( option_CASE (some x. PMATCH_ROW_COND p g v x) diff --git a/examples/deep_matches/deepMatchesSyntax.sig b/examples/deep_matches/deepMatchesSyntax.sig index f0616d9d1e..99bd91a192 100644 --- a/examples/deep_matches/deepMatchesSyntax.sig +++ b/examples/deep_matches/deepMatchesSyntax.sig @@ -116,9 +116,28 @@ sig val mk_PMATCH_ROW_COND_EX_pat : term -> term -> term val mk_PMATCH_ROW_COND_EX_ROW : term -> term -> term + val PMATCH_ROW_COND_EX_ELIM_CONV : conv + + (* [PMATCH_ROW_COND_EX_INTRO_CONV_GEN find_guard_term v t] tries + to introduce [PMATCH_ROW_COND_EX] terms. For + t of the form ``?x1 ... xn. v = f x1 ... xn /\ g1 x1 ... xn /\ ...`` + it extracts the pattern [f x1 ... xn] and guard [g1 x1 ... xn /\ ...]. + + The function [find_guard_term] is used to find subterms of [f x1 + ... xn] that should be abbreviated by a new variable and moved to + the guard. It gets the list of free variables and the pattern. + *) + val PMATCH_ROW_COND_EX_INTRO_CONV_GEN : (term list -> term -> term option) -> term -> conv val PMATCH_ROW_COND_EX_INTRO_CONV : term -> conv + + (* apply PMATCH_ROW_COND_EX_INTRO_CONV to all disjuncts of an nchotomy theorem. *) + val nchotomy2PMATCH_ROW_COND_EX_CONV_GEN : (term list -> term -> term option) -> conv val nchotomy2PMATCH_ROW_COND_EX_CONV : conv - val PMATCH_ROW_COND_EX_ELIM_CONV : conv + + (* A version of making PMATCH_ROW_COND_EX that does the move to guards. *) + val mk_PMATCH_ROW_COND_EX_PABS_MOVE_TO_GUARDS : + (term list -> term -> term option) -> + term list -> term * term * term -> term (******************) (* Pretty printer *) @@ -233,7 +252,4 @@ sig from each other *) val mk_new_label_gen : string -> (unit -> string) - - - end diff --git a/examples/deep_matches/deepMatchesSyntax.sml b/examples/deep_matches/deepMatchesSyntax.sml index 73db8b6c5b..f2676e0eda 100644 --- a/examples/deep_matches/deepMatchesSyntax.sml +++ b/examples/deep_matches/deepMatchesSyntax.sml @@ -37,16 +37,6 @@ in String.sub(s, 0) = #"_" end handle HOL_ERR _ => false -fun mk_new_label_gen prefix = let - val c = ref 0 -in - fn () => let - val l = prefix ^ int_to_string (!c) - val _ = c := !c + 1 - in - l - end -end fun mk_var_gen prefix avoid = let val c = ref 0 @@ -66,7 +56,7 @@ fun mk_wildcard_gen avoid = mk_var_gen "_" avoid (* Get the first element of l that satisfies p and - move it to the first position. *) + remove it from the list.. *) fun pick_element p l = let fun aux acc l = case l of @@ -77,6 +67,7 @@ fun pick_element p l = let aux [] l end +(* strip_comb with a maximum number of splits *) fun strip_comb_bounded_aux acc n t = if (n > 0) then (let val (t', a) = dest_comb t in @@ -85,10 +76,13 @@ end handle HOL_ERR _ => (t, acc)) else (t, acc) fun strip_comb_bounded n t = strip_comb_bounded_aux [] n t +(* apply a conversion to all leafs of a disjunct *) fun ALL_DISJ_CONV c t = if (is_disj t) then ( (BINOP_CONV (ALL_DISJ_CONV c)) t ) else (TRY_CONV c) t +(* apply a conversion to all leafs of a disjunct + and simplify the result by removing T and F. *) fun ALL_DISJ_TF_ELIM_CONV c t = let val (t1, t2) = dest_disj t in @@ -132,15 +126,16 @@ in end handle HOL_ERR _ => (TRY_CONV c) t - - +(* apply a conversion to all leafs of a conjunct. *) fun ALL_CONJ_CONV c t = if (is_conj t) then ( (BINOP_CONV (ALL_CONJ_CONV c)) t ) else (TRY_CONV c) t + fun DECEND_CONV c_desc c t = (c THENC TRY_CONV (c_desc (DECEND_CONV c_desc c))) t + fun STRIP_ABS_CONV conv t = if (is_abs t) then ABS_CONV (STRIP_ABS_CONV conv) t else conv t @@ -150,10 +145,24 @@ fun has_subterm p t = ((find_term p t; true) handle HOL_ERR _ => false) (* like proof, but less verbose, since we expect that it might fail *) val prove_attempt = Lib.with_flag (Feedback.emit_MESG, false) prove + (***********************************************) (* Labels from markerLib *) (***********************************************) +(* generating fresh labels and vars using + a counter *) +fun mk_new_label_gen prefix = let + val c = ref 0 +in + fn () => let + val l = prefix ^ int_to_string (!c) + val _ = c := !c + 1 + in + l + end +end + fun add_labels_CONV lbls t = let val lbl_tm = List.foldl markerSyntax.mk_label t lbls in @@ -538,6 +547,28 @@ fun mk_PMATCH_ROW_COND_EX_PABS vars (i, p_t, g_t) = let mk_PMATCH_ROW_COND_EX (i, mk_pabs p_t, mk_pabs g_t) end +fun mk_PMATCH_ROW_COND_EX_PABS_MOVE_TO_GUARDS find vars (i, p_t, g_t) = let + val fr_vs = free_vars i @ free_vars p_t @ free_vars g_t + fun move_to_guard (vars, p_t, g_t) = let + val (p: term) = case find vars p_t of + NONE => failwith "not found" + | SOME p => p + val _ = if (mem p vars) then failwith "loop" else () + val x = mk_var ("x", type_of p) + val x = variant (fr_vs @ vars) x + val p_t' = Term.subst [p |-> x] p_t + val g_t' = mk_conj (mk_eq (x, p), g_t) + val vars' = x :: vars + in + move_to_guard (vars', p_t', g_t') + end handle HOL_ERR _ => (vars, p_t, g_t) + + val (vars', p_t', g_t') = move_to_guard (vars, p_t, g_t) +in + mk_PMATCH_ROW_COND_EX_PABS vars' (i, p_t', g_t') +end + + fun mk_PMATCH_ROW_COND_EX_pat i p = let val (vars, _) = pairSyntax.dest_pabs p val g = pairSyntax.mk_pabs (vars, T) @@ -567,9 +598,12 @@ end (* val t = (el 4 o strip_disj o snd o strip_forall o concl) thm val v = (fst o dest_forall o concl) thm +val t = ``x = (NONE,c)`` +val v = lhs t +fun P vs x = NONE *) -fun PMATCH_ROW_COND_EX_INTRO_CONV v t = let +fun PMATCH_ROW_COND_EX_INTRO_CONV_GEN P v t = let val (vs, b) = strip_exists t val b_conjs = strip_conj b val (peq_t, guards) = pick_element (fn c => (aconv (lhs c) v handle HOL_ERR _ => false)) b_conjs @@ -590,12 +624,17 @@ in rc_eq_thm end +fun PMATCH_ROW_COND_EX_INTRO_CONV v t = + PMATCH_ROW_COND_EX_INTRO_CONV_GEN (fn _ => fn _ => NONE) v t; -fun nchotomy2PMATCH_ROW_COND_EX_CONV t = let +fun nchotomy2PMATCH_ROW_COND_EX_CONV_GEN P t = let val (v, _) = dest_forall t in - (QUANT_CONV (ALL_DISJ_CONV (PMATCH_ROW_COND_EX_INTRO_CONV v))) t -end + (QUANT_CONV (ALL_DISJ_CONV (PMATCH_ROW_COND_EX_INTRO_CONV_GEN P v))) t +end; + +fun nchotomy2PMATCH_ROW_COND_EX_CONV t = + nchotomy2PMATCH_ROW_COND_EX_CONV_GEN (fn _ => fn _ => NONE) t; fun PMATCH_ROW_COND_EX_ELIM_CONV t = let val (_, p_t, _) = dest_PMATCH_ROW_COND_EX t @@ -606,12 +645,12 @@ fun PMATCH_ROW_COND_EX_ELIM_CONV t = let val thm2 = RIGHT_CONV_RULE pairTools.ELIM_TUPLED_QUANT_CONV thm1 handle HOL_ERR _ => thm1 val thm3 = RIGHT_CONV_RULE (STRIP_QUANT_CONV (DEPTH_CONV pairLib.GEN_BETA_CONV)) thm2 val thm4 = RIGHT_CONV_RULE (PURE_REWRITE_CONV [AND_CLAUSES]) thm3 + val thm5 = RIGHT_CONV_RULE (REWR_CONV boolTheory.EXISTS_SIMP) thm4 handle HOL_ERR _ => thm4 in - thm4 + thm5 end - (***********************************************) (* Pretty Printing *) (***********************************************) From 729db81662d4d4b2d9bbfb215f4d8e9af74247ce Mon Sep 17 00:00:00 2001 From: Thomas Tuerk Date: Thu, 4 Jun 2015 13:30:07 +0200 Subject: [PATCH 328/718] rename example "deep_matches" to "pattern_matches" The name is confusing. The pattern compilation is in some rather vague sense deep, not the case-expressions. Moreoever, the lib grew since it was named such that the deep pattern compilation is not its most prominent feature any more. --- doc/next-release.md | 6 +++--- examples/deep_matches/Holmakefile | 9 --------- examples/deep_matches/selftest.sml | 3 --- examples/pattern_matches/Holmakefile | 9 +++++++++ examples/{deep_matches => pattern_matches}/README | 10 ++++++++-- .../constrFamiliesLib.sig | 0 .../constrFamiliesLib.sml | 2 +- .../patternMatchesExamples.sml} | 6 +++--- .../patternMatchesLib.sig} | 2 +- .../patternMatchesLib.sml} | 6 +++--- .../patternMatchesScript.sml} | 2 +- .../patternMatchesSyntax.sig} | 2 +- .../patternMatchesSyntax.sml} | 4 ++-- examples/pattern_matches/selftest.sml | 3 +++ tools/sequences/large-theories | 2 +- 15 files changed, 36 insertions(+), 30 deletions(-) delete mode 100644 examples/deep_matches/Holmakefile delete mode 100644 examples/deep_matches/selftest.sml create mode 100644 examples/pattern_matches/Holmakefile rename examples/{deep_matches => pattern_matches}/README (81%) rename examples/{deep_matches => pattern_matches}/constrFamiliesLib.sig (100%) rename examples/{deep_matches => pattern_matches}/constrFamiliesLib.sml (99%) rename examples/{deep_matches/deepMatchesExamples.sml => pattern_matches/patternMatchesExamples.sml} (99%) rename examples/{deep_matches/deepMatchesLib.sig => pattern_matches/patternMatchesLib.sig} (99%) rename examples/{deep_matches/deepMatchesLib.sml => pattern_matches/patternMatchesLib.sml} (99%) rename examples/{deep_matches/deepMatchesScript.sml => pattern_matches/patternMatchesScript.sml} (99%) rename examples/{deep_matches/deepMatchesSyntax.sig => pattern_matches/patternMatchesSyntax.sig} (99%) rename examples/{deep_matches/deepMatchesSyntax.sml => pattern_matches/patternMatchesSyntax.sml} (99%) create mode 100644 examples/pattern_matches/selftest.sml diff --git a/doc/next-release.md b/doc/next-release.md index c2a39d06a2..30149ae338 100644 --- a/doc/next-release.md +++ b/doc/next-release.md @@ -57,16 +57,16 @@ New examples: - A theory of balanced binary trees (`examples/balanced_bst`), based on Haskell code by Leijen and Palamarchuk, and mechanised by Scott Owens. The type supports operations such as `insert`, `union`, `delete`, filters and folds. Operations are parameterised by comparison operators for comparing keys. Balanced trees can themselves be compared. -- A formalisation of pattern matches (`examples/deep_matches`). +- A formalisation of pattern matches (`examples/pattern_matches`). Pattern matching is not directly supported by higher-order logic. HOL4’s parser therefore compiles case-expressions (`case x of ...`) to decision trees based on case constants. For non-trivial case expressions, there is a big discrepancy between the user’s view and this internal representation. - The `deep_matches` example defines a new general-purpose representation for case expressions that mirrors the input syntax in the internal representation closely. + The `pattern_matches` example defines a new general-purpose representation for case expressions that mirrors the input syntax in the internal representation closely. Because of this close connection, the new representation is more intuitive and often much more compact. Complicated parsers and pretty-printers are no longer required. Proofs can more closely follow the user’s intentions, and code generators (like CakeML) can produce better code. Moreover, the new representation is strictly more general than the currently used representation. - The new representation allows for guards, Haskell-style views, patterns with multiple occurrences of the same bound variable, unbound variables, arithmetic expressions in patterns, and more. + The new representation allows for guards, patterns with multiple occurrences of the same bound variable, unbound variables, arithmetic expressions in patterns, and more. The example provides the definitions as well as tools to work with the new case-expressions. These tools include support for evaluating and simplifying them, a highly configurable pattern compilation algorithm inside the logic, and optimisations like detecting redundant rows and eliminating them. diff --git a/examples/deep_matches/Holmakefile b/examples/deep_matches/Holmakefile deleted file mode 100644 index 8696e81185..0000000000 --- a/examples/deep_matches/Holmakefile +++ /dev/null @@ -1,9 +0,0 @@ -.PHONY: test - -selftest.exe: selftest.uo deepMatchesSyntax.uo deepMatchesTheory.uo deepMatchesLib.uo constrFamiliesLib.uo - $(HOLMOSMLC) -o $@ $< - -test: selftest.exe - ./$< - -EXTRA_CLEANS = selftest.exe diff --git a/examples/deep_matches/selftest.sml b/examples/deep_matches/selftest.sml deleted file mode 100644 index 055a805944..0000000000 --- a/examples/deep_matches/selftest.sml +++ /dev/null @@ -1,3 +0,0 @@ -open constrFamiliesLib deepMatchesLib - -val _ = print "OK\n" diff --git a/examples/pattern_matches/Holmakefile b/examples/pattern_matches/Holmakefile new file mode 100644 index 0000000000..888d89a024 --- /dev/null +++ b/examples/pattern_matches/Holmakefile @@ -0,0 +1,9 @@ +.PHONY: test + +selftest.exe: selftest.uo patternMatchesSyntax.uo patternMatchesTheory.uo patternMatchesLib.uo constrFamiliesLib.uo + $(HOLMOSMLC) -o $@ $< + +test: selftest.exe + ./$< + +EXTRA_CLEANS = selftest.exe diff --git a/examples/deep_matches/README b/examples/pattern_matches/README similarity index 81% rename from examples/deep_matches/README rename to examples/pattern_matches/README index dee88c3e9b..8b11a723b4 100644 --- a/examples/deep_matches/README +++ b/examples/pattern_matches/README @@ -28,5 +28,11 @@ deep pattern compilation now. Moreover, the new case-expressions provide additional features like guards, views, free variables in patterns or multiple occurrences of a -bound variable inside a pattern. There is also tool support for -working with the new case-expressions inside the logic. \ No newline at end of file +bound variable inside a pattern. + +Most of the example consists of tool support for working with the new +case-expressions inside the logic. There are simplification and +(partial) evaluation tools, tools that convert between the classical +and new representation. A tool for exhaustiveness checks. Tools that +remove redundant rows or eliminate guards to double variable bindings +and much more. \ No newline at end of file diff --git a/examples/deep_matches/constrFamiliesLib.sig b/examples/pattern_matches/constrFamiliesLib.sig similarity index 100% rename from examples/deep_matches/constrFamiliesLib.sig rename to examples/pattern_matches/constrFamiliesLib.sig diff --git a/examples/deep_matches/constrFamiliesLib.sml b/examples/pattern_matches/constrFamiliesLib.sml similarity index 99% rename from examples/deep_matches/constrFamiliesLib.sml rename to examples/pattern_matches/constrFamiliesLib.sml index 6a7134a907..259331940f 100644 --- a/examples/deep_matches/constrFamiliesLib.sml +++ b/examples/pattern_matches/constrFamiliesLib.sml @@ -1,7 +1,7 @@ structure constrFamiliesLib :> constrFamiliesLib = struct -open HolKernel boolLib simpLib bossLib deepMatchesSyntax +open HolKernel boolLib simpLib bossLib patternMatchesSyntax (***************************************************) (* Auxiliary definitions *) diff --git a/examples/deep_matches/deepMatchesExamples.sml b/examples/pattern_matches/patternMatchesExamples.sml similarity index 99% rename from examples/deep_matches/deepMatchesExamples.sml rename to examples/pattern_matches/patternMatchesExamples.sml index c8f2c60327..c555c60ea5 100644 --- a/examples/deep_matches/deepMatchesExamples.sml +++ b/examples/pattern_matches/patternMatchesExamples.sml @@ -4,9 +4,9 @@ (**************************************) open bossLib -open deepMatchesLib -open deepMatchesTheory -open deepMatchesSyntax +open patternMatchesLib +open patternMatchesTheory +open patternMatchesSyntax open pred_setTheory open constrFamiliesLib open stringTheory diff --git a/examples/deep_matches/deepMatchesLib.sig b/examples/pattern_matches/patternMatchesLib.sig similarity index 99% rename from examples/deep_matches/deepMatchesLib.sig rename to examples/pattern_matches/patternMatchesLib.sig index 28c26156a2..e689bff04b 100644 --- a/examples/deep_matches/deepMatchesLib.sig +++ b/examples/pattern_matches/patternMatchesLib.sig @@ -1,4 +1,4 @@ -signature deepMatchesLib = +signature patternMatchesLib = sig include Abbrev type ssfrag = simpLib.ssfrag diff --git a/examples/deep_matches/deepMatchesLib.sml b/examples/pattern_matches/patternMatchesLib.sml similarity index 99% rename from examples/deep_matches/deepMatchesLib.sml rename to examples/pattern_matches/patternMatchesLib.sml index 66c58bf500..117b274930 100644 --- a/examples/deep_matches/deepMatchesLib.sml +++ b/examples/pattern_matches/patternMatchesLib.sml @@ -1,12 +1,12 @@ -structure deepMatchesLib :> deepMatchesLib = +structure patternMatchesLib :> patternMatchesLib = struct open HolKernel boolLib bossLib -open deepMatchesTheory +open patternMatchesTheory open simpLib open quantHeuristicsLib open DatatypeSimps -open deepMatchesSyntax +open patternMatchesSyntax open Traverse open constrFamiliesLib diff --git a/examples/deep_matches/deepMatchesScript.sml b/examples/pattern_matches/patternMatchesScript.sml similarity index 99% rename from examples/deep_matches/deepMatchesScript.sml rename to examples/pattern_matches/patternMatchesScript.sml index 5867015c64..a38465f499 100644 --- a/examples/deep_matches/deepMatchesScript.sml +++ b/examples/pattern_matches/patternMatchesScript.sml @@ -4,7 +4,7 @@ open optionTheory open listTheory open ConseqConv -val _ = new_theory "deepMatches" +val _ = new_theory "patternMatches" (***************************************************) (* Auxiliary stuff *) diff --git a/examples/deep_matches/deepMatchesSyntax.sig b/examples/pattern_matches/patternMatchesSyntax.sig similarity index 99% rename from examples/deep_matches/deepMatchesSyntax.sig rename to examples/pattern_matches/patternMatchesSyntax.sig index 99bd91a192..271c19a92a 100644 --- a/examples/deep_matches/deepMatchesSyntax.sig +++ b/examples/pattern_matches/patternMatchesSyntax.sig @@ -1,4 +1,4 @@ -signature deepMatchesSyntax = +signature patternMatchesSyntax = sig include Abbrev diff --git a/examples/deep_matches/deepMatchesSyntax.sml b/examples/pattern_matches/patternMatchesSyntax.sml similarity index 99% rename from examples/deep_matches/deepMatchesSyntax.sml rename to examples/pattern_matches/patternMatchesSyntax.sml index f2676e0eda..9e06d533a8 100644 --- a/examples/deep_matches/deepMatchesSyntax.sml +++ b/examples/pattern_matches/patternMatchesSyntax.sml @@ -1,8 +1,8 @@ -structure deepMatchesSyntax :> deepMatchesSyntax = +structure patternMatchesSyntax :> patternMatchesSyntax = struct open HolKernel Parse boolLib bossLib -open deepMatchesTheory +open patternMatchesTheory open pairSyntax open ConseqConv diff --git a/examples/pattern_matches/selftest.sml b/examples/pattern_matches/selftest.sml new file mode 100644 index 0000000000..ead6fe572e --- /dev/null +++ b/examples/pattern_matches/selftest.sml @@ -0,0 +1,3 @@ +open constrFamiliesLib patternMatchesLib + +val _ = print "OK\n" diff --git a/tools/sequences/large-theories b/tools/sequences/large-theories index 0422644e6d..302124bc63 100644 --- a/tools/sequences/large-theories +++ b/tools/sequences/large-theories @@ -19,7 +19,7 @@ src/HolSmt !!examples/computability/lambda !!examples/computability/register !!examples/balanced_bst -!examples/deep_matches +!examples/pattern_matches src/Boolify/src src/float [poly]src/floating-point From dad8089c2046a3b530ad0bfc51418a9d3eef9307 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Fri, 5 Jun 2015 07:44:41 +0100 Subject: [PATCH 329/718] strengthen rich_listTheory.EVERY2_DROP --- src/list/src/rich_listScript.sml | 22 ++++++++++++++-------- 1 file changed, 14 insertions(+), 8 deletions(-) diff --git a/src/list/src/rich_listScript.sml b/src/list/src/rich_listScript.sml index 83eae1534f..9f7bc6a85f 100644 --- a/src/list/src/rich_listScript.sml +++ b/src/list/src/rich_listScript.sml @@ -2907,6 +2907,7 @@ local val rw = SRW_TAC [] val metis_tac = METIS_TAC val fs = FULL_SIMP_TAC (srw_ss()) + val rfs = REV_FULL_SIMP_TAC (srw_ss()) val simp = ASM_SIMP_TAC (srw_ss()++boolSimps.LET_ss++numSimps.ARITH_ss) open pred_setTheory open listTheory pairTheory; in @@ -3004,14 +3005,6 @@ val TAKE_EL_SNOC = Q.store_thm("TAKE_EL_SNOC", THEN rw[TAKE_SNOC,TAKE_APPEND1,EL_APPEND1] THEN FULL_SIMP_TAC arith_ss [ADD1, LENGTH_SNOC, TAKE_APPEND1, SNOC_APPEND]) -val EVERY2_DROP = Q.store_thm("EVERY2_DROP", - `!R l1 l2 n. - EVERY2 R l1 l2 /\ n <= LENGTH l1 ==> EVERY2 R (DROP n l1) (DROP n l2)`, - rw[EVERY2_EVERY,ZIP_DROP] - >> MATCH_MP_TAC (MP_CANON EVERY_DROP) - >> rw[] - >> PROVE_TAC[]) - val REVERSE_DROP = Q.store_thm("REVERSE_DROP", `!ls n. n <= LENGTH ls ==> (REVERSE (DROP n ls) = REVERSE (LASTN (LENGTH ls - n) ls))`, @@ -3042,6 +3035,19 @@ val EVERY2_APPEND_suff = Q.store_thm("EVERY2_APPEND_suff", `EVERY2 R l1 l2 /\ EVERY2 R l3 l4 ==> EVERY2 R (l1 ++ l3) (l2 ++ l4)`, metis_tac[EVERY2_APPEND]) +val EVERY2_DROP = Q.store_thm("EVERY2_DROP", + `!R l1 l2 n. + EVERY2 R l1 l2 ==> EVERY2 R (DROP n l1) (DROP n l2)`, + REPEAT STRIP_TAC THEN IMP_RES_TAC LIST_REL_LENGTH + THEN Q.PAT_ASSUM `LIST_REL P xs ys` MP_TAC + THEN ONCE_REWRITE_TAC [GSYM TAKE_DROP] THEN REPEAT STRIP_TAC + THEN ONCE_REWRITE_TAC [TAKE_DROP] + THEN Cases_on `n <= LENGTH l1` + THEN1 (METIS_TAC [EVERY2_APPEND,LENGTH_DROP,LENGTH_TAKE]) + THEN fs [GSYM NOT_LESS] THEN `LENGTH l1 <= n` by numLib.DECIDE_TAC + THEN fs [DROP_LENGTH_TOO_LONG] + THEN rfs [DROP_LENGTH_TOO_LONG]); + val LIST_REL_APPEND_SING = Q.store_thm("LIST_REL_APPEND_SING", `LIST_REL R (l1 ++ [x1]) (l2 ++ [x2]) <=> LIST_REL R l1 l2 /\ R x1 x2`, rw[EQ_IMP_THM] From dfcaa46671eebb3d98869b2ce6250b88f5399b7d Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Fri, 5 Jun 2015 07:53:07 +0100 Subject: [PATCH 330/718] add rich_listTheory.EVERY2_TAKE --- src/list/src/rich_listScript.sml | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/src/list/src/rich_listScript.sml b/src/list/src/rich_listScript.sml index 9f7bc6a85f..cd1b7e7f4c 100644 --- a/src/list/src/rich_listScript.sml +++ b/src/list/src/rich_listScript.sml @@ -3048,6 +3048,18 @@ val EVERY2_DROP = Q.store_thm("EVERY2_DROP", THEN fs [DROP_LENGTH_TOO_LONG] THEN rfs [DROP_LENGTH_TOO_LONG]); +val EVERY2_TAKE = store_thm("EVERY2_TAKE", + ``!P xs ys n. EVERY2 P xs ys ==> EVERY2 P (TAKE n xs) (TAKE n ys)``, + REPEAT STRIP_TAC THEN IMP_RES_TAC EVERY2_LENGTH + THEN Q.PAT_ASSUM `LIST_REL P xs ys` MP_TAC + THEN ONCE_REWRITE_TAC [GSYM TAKE_DROP] THEN REPEAT STRIP_TAC + THEN ONCE_REWRITE_TAC [TAKE_DROP] + THEN Cases_on `n <= LENGTH xs` + THEN1 (METIS_TAC [EVERY2_APPEND,LENGTH_DROP,LENGTH_TAKE]) + THEN fs [GSYM NOT_LESS] THEN `LENGTH xs <= n` by DECIDE_TAC + THEN fs [TAKE_LENGTH_TOO_LONG] + THEN rfs [TAKE_LENGTH_TOO_LONG]); + val LIST_REL_APPEND_SING = Q.store_thm("LIST_REL_APPEND_SING", `LIST_REL R (l1 ++ [x1]) (l2 ++ [x2]) <=> LIST_REL R l1 l2 /\ R x1 x2`, rw[EQ_IMP_THM] From 6181643681e3acebcd7e8c6efe18dabbacc7a12a Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Sun, 7 Jun 2015 23:34:45 +1000 Subject: [PATCH 331/718] shorter proof of SORTED_transitive_APPEND_IFF via stronger result SORTED_APPEND_IFF --- src/sort/sortingScript.sml | 43 +++++++++++++------------------------- 1 file changed, 14 insertions(+), 29 deletions(-) diff --git a/src/sort/sortingScript.sml b/src/sort/sortingScript.sml index bdd435257b..39270fae86 100644 --- a/src/sort/sortingScript.sml +++ b/src/sort/sortingScript.sml @@ -921,41 +921,26 @@ FULL_SIMP_TAC (srw_ss()) [MEM_EL] THEN FIRST_X_ASSUM (Q.SPECL_THEN [`0`,`SUC n`] MP_TAC) THEN SRW_TAC [][]) +val SORTED_APPEND_IFF = Q.store_thm ("SORTED_APPEND_IFF", + `!R. !L1 L2. SORTED R (L1 ++ L2) = + SORTED R L1 /\ SORTED R L2 /\ + ((L1 = []) \/ (L2 = []) \/ (R (LAST L1) (HD L2)))`, + EVERY [ REPEAT STRIP_TAC, Induct_on `L1`, + ASM_SIMP_TAC list_ss [SORTED_DEF], GEN_TAC, + Cases_on `L1`, Cases_on `L2`, + FULL_SIMP_TAC list_ss [SORTED_DEF] ] THENL [ + SIMP_TAC bool_ss [CONJ_COMM], + SIMP_TAC bool_ss [CONJ_ASSOC] ] ) ; + +(* note, assumption transitive R not needed, see SORTED_APPEND_IFF *) val SORTED_transitive_APPEND_IFF = store_thm( "SORTED_transitive_APPEND_IFF", ``!R. transitive R ==> !L1 L2. SORTED R (L1 ++ L2) = SORTED R L1 /\ SORTED R L2 /\ ((L1 = []) \/ (L2 = []) \/ (R (LAST L1) (HD L2)))``, -GEN_TAC THEN STRIP_TAC THEN -Induct THEN SRW_TAC[][] THEN -SRW_TAC[][SORTED_EQ] THEN -Cases_on `L1` THEN SRW_TAC[][] THEN1 ( - SRW_TAC[][EQ_IMP_THM] THEN - FULL_SIMP_TAC (srw_ss()) [] THEN1 ( - Cases_on `L2` THEN FULL_SIMP_TAC (srw_ss()) [] ) THEN - Q.PAT_ASSUM `SORTED R L2` MP_TAC THEN - SRW_TAC[][SORTED_EL_LESS] THEN - FULL_SIMP_TAC (srw_ss()) [MEM_EL,transitive_def] THEN - Cases_on `n` THEN1 SRW_TAC[][] THEN - METIS_TAC[prim_recTheory.LESS_0,EL] ) THEN -SRW_TAC[][GSYM CONJ_ASSOC] THEN -Q.MATCH_ABBREV_TAC `P1 /\ P2 /\ P3 /\ P4 = P1 /\ P6 /\ P2 /\ P3` THEN -Q_TAC SUFF_TAC `P1 /\ P2 /\ P3 ==> (P4 = P6)` THEN1 SRW_TAC[][EQ_IMP_THM] THEN -UNABBREV_ALL_TAC THEN SRW_TAC[][] THEN1 SRW_TAC[][] THEN -EQ_TAC THEN1 METIS_TAC[] THEN -STRIP_TAC THEN Q.X_GEN_TAC `x` THEN -REVERSE (Cases_on `MEM x L2`) THEN1 METIS_TAC[] THEN -Q.MATCH_ASSUM_RENAME_TAC `R (LAST (y::t)) (HD L2)` THEN -`R h (LAST (y::t))` by ( - FIRST_X_ASSUM MATCH_MP_TAC THEN - Cases_on `t` THEN1 SRW_TAC[][] THEN - SIMP_TAC bool_ss [LAST_CONS,rich_listTheory.MEM_LAST] ) THEN -`R h (EL 0 L2)` by METIS_TAC [transitive_def,EL] THEN -Q.PAT_ASSUM `MEM x L2` MP_TAC THEN -SRW_TAC[][MEM_EL] THEN -Cases_on `n` THEN1 SRW_TAC[][] THEN -METIS_TAC [prim_recTheory.LESS_0,SORTED_EL_LESS,transitive_def]) + EVERY [ GEN_TAC, DISCH_TAC, MATCH_ACCEPT_TAC SORTED_APPEND_IFF ]) ; + val MEM_PERM = store_thm( From 03a1f11fd22125a300ddf89bdc886a1acb215017 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Mon, 8 Jun 2015 01:04:19 +1000 Subject: [PATCH 332/718] shorter proof of SORTED_PERM_EQ, new theorem SORTED_TL --- src/sort/sortingScript.sml | 50 +++++++++++++++----------------------- 1 file changed, 20 insertions(+), 30 deletions(-) diff --git a/src/sort/sortingScript.sml b/src/sort/sortingScript.sml index 39270fae86..4eb90089ce 100644 --- a/src/sort/sortingScript.sml +++ b/src/sort/sortingScript.sml @@ -885,6 +885,10 @@ val SORTED_SING = store_thm( SRW_TAC[][SORTED_DEF]) val _ = export_rewrites["SORTED_SING"] +val SORTED_TL = store_thm ("SORTED_TL", + ``SORTED R (x :: xs) ==> SORTED R xs``, + Cases_on `xs` THEN (SIMP_TAC list_ss [SORTED_DEF])) ; + val SORTED_EL_SUC = store_thm( "SORTED_EL_SUC", ``!R ls. SORTED R ls = @@ -948,36 +952,22 @@ val MEM_PERM = ``!l1 l2. PERM l1 l2 ==> (!a. MEM a l1 = MEM a l2)``, METIS_TAC [Q.SPEC `$= a` MEM_FILTER, PERM_DEF]); -val SORTED_PERM_EQ = store_thm( -"SORTED_PERM_EQ", -``!R. transitive R /\ antisymmetric R ==> - !l1 l2. SORTED R l1 /\ SORTED R l2 /\ PERM l1 l2 ==> (l1 = l2)``, -GEN_TAC THEN STRIP_TAC THEN -Induct THEN1 SRW_TAC[][] THEN -SRW_TAC[][SORTED_EQ,PERM_CONS_EQ_APPEND] THEN -`!x. MEM x M ==> (x = h)` by ( - Q.PAT_ASSUM `SORTED R (aa++bb)` MP_TAC THEN - SRW_TAC[][SORTED_transitive_APPEND_IFF] THEN - FULL_SIMP_TAC (srw_ss()) [] THEN - `R h x` by METIS_TAC [MEM_PERM,MEM_APPEND] THEN - Cases_on `M = []` THEN FULL_SIMP_TAC (srw_ss()) [] THEN - FULL_SIMP_TAC (srw_ss()) [LAST_EL,MEM_EL] THEN - `R x h` by ( - Cases_on `n = PRE (LENGTH M)` THEN1 SRW_TAC[][] THEN - `n < PRE (LENGTH M)` by DECIDE_TAC THEN - `PRE (LENGTH M) < LENGTH M` by DECIDE_TAC THEN - METIS_TAC [SORTED_EL_LESS,transitive_def] ) THEN - METIS_TAC [antisymmetric_def] ) THEN -`M ++ [h] = h::M` by ( - POP_ASSUM MP_TAC THEN - Q.ID_SPEC_TAC `h` THEN - REPEAT (POP_ASSUM (K ALL_TAC)) THEN - Induct_on `M` THEN SRW_TAC[][] ) THEN -SRW_TAC[][] THEN -FIRST_X_ASSUM MATCH_MP_TAC THEN -FULL_SIMP_TAC (srw_ss()) [] THEN -Q.PAT_ASSUM `SORTED R (h::N)` MP_TAC THEN -SRW_TAC[][SORTED_EQ]) + +val SORTED_PERM_EQ = Q.store_thm ("SORTED_PERM_EQ", + `!R. transitive R /\ antisymmetric R ==> + !l1 l2. SORTED R l1 /\ SORTED R l2 /\ PERM l1 l2 ==> (l1 = l2)`, + EVERY [ GEN_TAC, STRIP_TAC, + Induct THEN1 SIMP_TAC list_ss [PERM_NIL], + REPEAT STRIP_TAC, + Cases_on `l2` THEN1 FULL_SIMP_TAC list_ss [PERM_NIL], + SIMP_TAC list_ss [], CONJ_ASM1_TAC ] THENL [ + EVERY [ IMP_RES_TAC SORTED_EQ, IMP_RES_TAC MEM_PERM, + POP_ASSUM (ASSUME_TAC o Q.SPEC `h'`), + FIRST_X_ASSUM (ASSUME_TAC o Q.SPEC `h`), + FULL_SIMP_TAC list_ss [relationTheory.antisymmetric_def] ], + EVERY [ FIRST_X_ASSUM MATCH_MP_TAC, + BasicProvers.VAR_EQ_TAC, IMP_RES_TAC SORTED_TL, + FULL_SIMP_TAC list_ss [PERM_CONS_IFF] ] ]) ; val QSORT_eq_if_PERM = store_thm( "QSORT_eq_if_PERM", From 4cb34bdee02dce87e6cbc6716817d4860c86a8ef Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Mon, 8 Jun 2015 15:16:33 +1000 Subject: [PATCH 333/718] changes to proof formatting, using >> rather than EVERY --- src/sort/sortingScript.sml | 42 ++++++++++++++++++++------------------ 1 file changed, 22 insertions(+), 20 deletions(-) diff --git a/src/sort/sortingScript.sml b/src/sort/sortingScript.sml index 4eb90089ce..05f83ccd2a 100644 --- a/src/sort/sortingScript.sml +++ b/src/sort/sortingScript.sml @@ -7,7 +7,7 @@ struct open HolKernel Parse boolLib bossLib; open combinTheory pairTheory relationTheory listTheory - markerLib metisLib BasicProvers; + markerLib metisLib BasicProvers lcsymtacs ; val _ = new_theory "sorting"; @@ -929,12 +929,13 @@ val SORTED_APPEND_IFF = Q.store_thm ("SORTED_APPEND_IFF", `!R. !L1 L2. SORTED R (L1 ++ L2) = SORTED R L1 /\ SORTED R L2 /\ ((L1 = []) \/ (L2 = []) \/ (R (LAST L1) (HD L2)))`, - EVERY [ REPEAT STRIP_TAC, Induct_on `L1`, - ASM_SIMP_TAC list_ss [SORTED_DEF], GEN_TAC, - Cases_on `L1`, Cases_on `L2`, - FULL_SIMP_TAC list_ss [SORTED_DEF] ] THENL [ - SIMP_TAC bool_ss [CONJ_COMM], - SIMP_TAC bool_ss [CONJ_ASSOC] ] ) ; + REPEAT STRIP_TAC >> Induct_on `L1` >> + ASM_SIMP_TAC list_ss [SORTED_DEF] >> GEN_TAC >> + Cases_on `L1` >> Cases_on `L2` >> + FULL_SIMP_TAC list_ss [SORTED_DEF] + THENL [ + SIMP_TAC bool_ss [CONJ_COMM], + SIMP_TAC bool_ss [CONJ_ASSOC] ] ) ; (* note, assumption transitive R not needed, see SORTED_APPEND_IFF *) val SORTED_transitive_APPEND_IFF = store_thm( @@ -943,7 +944,7 @@ val SORTED_transitive_APPEND_IFF = store_thm( !L1 L2. SORTED R (L1 ++ L2) = SORTED R L1 /\ SORTED R L2 /\ ((L1 = []) \/ (L2 = []) \/ (R (LAST L1) (HD L2)))``, - EVERY [ GEN_TAC, DISCH_TAC, MATCH_ACCEPT_TAC SORTED_APPEND_IFF ]) ; + GEN_TAC >> DISCH_TAC >> MATCH_ACCEPT_TAC SORTED_APPEND_IFF ) ; val MEM_PERM = @@ -956,18 +957,19 @@ val MEM_PERM = val SORTED_PERM_EQ = Q.store_thm ("SORTED_PERM_EQ", `!R. transitive R /\ antisymmetric R ==> !l1 l2. SORTED R l1 /\ SORTED R l2 /\ PERM l1 l2 ==> (l1 = l2)`, - EVERY [ GEN_TAC, STRIP_TAC, - Induct THEN1 SIMP_TAC list_ss [PERM_NIL], - REPEAT STRIP_TAC, - Cases_on `l2` THEN1 FULL_SIMP_TAC list_ss [PERM_NIL], - SIMP_TAC list_ss [], CONJ_ASM1_TAC ] THENL [ - EVERY [ IMP_RES_TAC SORTED_EQ, IMP_RES_TAC MEM_PERM, - POP_ASSUM (ASSUME_TAC o Q.SPEC `h'`), - FIRST_X_ASSUM (ASSUME_TAC o Q.SPEC `h`), - FULL_SIMP_TAC list_ss [relationTheory.antisymmetric_def] ], - EVERY [ FIRST_X_ASSUM MATCH_MP_TAC, - BasicProvers.VAR_EQ_TAC, IMP_RES_TAC SORTED_TL, - FULL_SIMP_TAC list_ss [PERM_CONS_IFF] ] ]) ; + GEN_TAC >> STRIP_TAC >> + Induct THEN1 SIMP_TAC list_ss [PERM_NIL] >> + REPEAT STRIP_TAC >> + Cases_on `l2` THEN1 FULL_SIMP_TAC list_ss [PERM_NIL] >> + SIMP_TAC list_ss [] >> CONJ_ASM1_TAC + THENL [ + IMP_RES_TAC SORTED_EQ >> IMP_RES_TAC MEM_PERM >> + POP_ASSUM (ASSUME_TAC o Q.SPEC `h'`) >> + FIRST_X_ASSUM (ASSUME_TAC o Q.SPEC `h`) >> + FULL_SIMP_TAC list_ss [relationTheory.antisymmetric_def], + FIRST_X_ASSUM MATCH_MP_TAC >> + BasicProvers.VAR_EQ_TAC >> IMP_RES_TAC SORTED_TL >> + FULL_SIMP_TAC list_ss [PERM_CONS_IFF] ]) ; val QSORT_eq_if_PERM = store_thm( "QSORT_eq_if_PERM", From 32b250e5de0247603619a32ee94e9f7f024e7705 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 11 Jun 2015 15:59:27 +1000 Subject: [PATCH 334/718] Q.PAT_ABBREV_TAC fails rather than bind a bound variable Documentation updated. Previous behaviour would be to attempt to bind a bound variable in an abbreviation and end up creating a vacuous abbreviation. Closes #262 --- help/Docfiles/Q.PAT_ABBREV_TAC.doc | 35 +++++++++++++--------- src/marker/markerLib.sml | 36 +++++++++++++++++------ src/q/selftest.sml | 47 ++++++++++++++++++++++++++++++ 3 files changed, 96 insertions(+), 22 deletions(-) diff --git a/help/Docfiles/Q.PAT_ABBREV_TAC.doc b/help/Docfiles/Q.PAT_ABBREV_TAC.doc index c21371578f..9467f3d428 100644 --- a/help/Docfiles/Q.PAT_ABBREV_TAC.doc +++ b/help/Docfiles/Q.PAT_ABBREV_TAC.doc @@ -6,21 +6,23 @@ Introduces an abbreviation within the goal statement. \DESCRIBE -When applied to the goal {(asl, w)}, the tactic {Q.PAT_ABBREV_TAC q} parses the -quotation {q} in the context of the goal, producing an equality term {v = p}. -The tactic then uses {HolKernel.find_term} to search for a sub-term of {w} that -{p} matches against. If such a sub-term {t} is found then all occurrences of -{t} (in {asl} and {w}) will be replaced by {v} and an assumption -{Abbrev(v = t)} is added to the goal. - -The trace variable {"PAT_ABBREV_TAC: match var/const"} controls whether or not -trivial matches (with constants or variables) are allowed. By default trivial -matches are permitted but when the trace variable is false the tactic will -ignore trivial matches, which could result in failure. +When applied to the goal {(asl, w)}, the tactic {Q.PAT_ABBREV_TAC q} +parses the quotation {q} in the context of the goal, producing an +equality term {v = p}. The tactic then uses {HolKernel.gen_find_term} +to search for a sub-term of {w} that {p} matches against. If such a +sub-term {t} is found then all occurrences of {t} (in {asl} and {w}) +will be replaced by {v} and an assumption {Abbrev(v = t)} is added to +the goal. + +The trace variable {"PAT_ABBREV_TAC: match var/const"} controls +whether or not trivial matches (with constants or variables) are +allowed. By default trivial matches are permitted but when the trace +variable is false the tactic will ignore trivial matches, which could +result in failure. \FAILURE {PAT_ABBREV_TAC} fails if {q} does not successfully parse as an equality or if -no matching sub-term is found in the goal. +no matching sub-term is found in the goal, or if the only matching sub-terms would bind pattern variables to variables that are bound in the goal. \EXAMPLE If the current goal is @@ -54,8 +56,15 @@ and applying {Q.PAT_ABBREV_TAC `X = a: num`} will give ?- y <= X } +If the current goal is +{ + ?- !x. x < 3 +} +then applying {Q.PAT_ABBREV_TAC `v = (a < b)`} will result in a +failure because the pattern's variable {a} would have to bind the +bound variable {x} in the goal. \SEEALSO -Q.ABBREV_TAC, Q.MATCH_ABBREV_TAC. +Q.ABBREV_TAC, HolKernel.gen_find_term, Q.MATCH_ABBREV_TAC. \ENDDOC diff --git a/src/marker/markerLib.sml b/src/marker/markerLib.sml index 26c2f185e6..f039c3171e 100644 --- a/src/marker/markerLib.sml +++ b/src/marker/markerLib.sml @@ -101,16 +101,34 @@ in fun PAT_ABBREV_TAC fv_set eq (g as (asl, w)) = let + open HOLset val (l, r) = dest_eq eq - val l' = variant (HOLset.listItems (FVL [r] fv_set)) l - fun matchr t = raw_match [] fv_set r t ([],[]) |> #2 |> #1 - fun finder (_, t) = - if (is_var t orelse is_const t) andalso - not (!match_var_or_const) - then - NONE - else - Lib.total (fn st => (st, matchr st)) t + val rvs = FVL [r] empty_tmset + val l' = variant (listItems(union(fv_set, rvs))) l + fun matchr t = + case raw_match [] fv_set r t ([],[]) of + ((tmsub, _), (tysub, _)) => (tmsub, tysub) + fun finder (bvs, t) = + case List.find (fn v => HOLset.member(rvs, v)) bvs of + SOME _ => NONE + | NONE => + if (is_var t orelse is_const t) andalso not (!match_var_or_const) + then NONE + else + case Lib.total matchr t of + NONE => NONE + | SOME (tmsub, tysub) => + let + open HOLset + val bv_set = addList(empty_tmset, bvs) + fun badt t = + not (isEmpty (intersection (FVL [t] empty_tmset, + bv_set))) + in + case List.find (fn {redex,residue=t} => badt t) tmsub of + NONE => SOME(t, tysub) + | SOME _ => NONE + end in case gen_find_term finder w of NONE => raise ERR "PAT_ABBREV_TAC" "No matching term found" diff --git a/src/q/selftest.sml b/src/q/selftest.sml index d502f93460..1c138c6b37 100644 --- a/src/q/selftest.sml +++ b/src/q/selftest.sml @@ -153,5 +153,52 @@ val _ = tprint "Q.PAT_ABBREV_TAC (gh252)" val (sgs, _) = Q.PAT_ABBREV_TAC `v = I x` ([], ``I p /\ v``) val _ = print "OK\n" +fun shouldfail f x = + (f x ; die "FAILED!") handle HOL_ERR _ => print "OK\n" + +val _ = tprint "Q.PAT_ABBREV_TAC (gh262) 1" +val (sgs, _) = + Q.PAT_ABBREV_TAC `v = (x < SUC w)` ([], ``y < SUC zero ==> y < z``) +val _ = case sgs of + [([abb], sg)] => + if Term.aconv abb ``Abbrev(v = y < SUC zero)`` andalso + Term.aconv sg ``v ==> y < z`` + then print "OK\n" + else die "FAILED!" + | _ => die "FAILED!" + +val _ = tprint "Q.PAT_ABBREV_TAC (gh262) 2" +val _ = shouldfail (Q.PAT_ABBREV_TAC `v = (x < SUC z)`) + ([], ``!x. x < SUC zero``) + +val _ = tprint "Q.PAT_ABBREV_TAC (gh262) 3" +val _ = shouldfail (Q.PAT_ABBREV_TAC `v = (x < SUC z)`) + ([], ``!y. y < SUC zero``) + +val _ = tprint "Q.PAT_ABBREV_TAC (gh262) 4" +val _ = shouldfail (Q.PAT_ABBREV_TAC `v = (x < SUC z)`) + ([], ``(!y. y < SUC zero) /\ y < zero``) + +val _ = tprint "Q.PAT_ABBREV_TAC (gh262) 5" +val (sgs,_) = Q.PAT_ABBREV_TAC `v = (x < SUC z)` + ([], ``(!y. y < SUC zero) /\ u < SUC (SUC zero)``) +val _ = case sgs of + [([abb], sg)] => + if Term.aconv abb ``Abbrev (v = u < SUC (SUC zero))`` andalso + Term.aconv sg ``(!y. y < SUC zero) /\ v`` + then print "OK\n" + else die "FAILED!" + | _ => die "FAILED!" + +val _ = tprint "Q.PAT_ABBREV_TAC (gh262) 6" +val (sgs,_) = Q.PAT_ABBREV_TAC `v = (x < SUC z)` + ([], ``(!x. x < SUC zero) /\ u < SUC (SUC zero)``) +val _ = case sgs of + [([abb], sg)] => + if Term.aconv abb ``Abbrev (v = u < SUC (SUC zero))`` andalso + Term.aconv sg ``(!y. y < SUC zero) /\ v`` + then print "OK\n" + else die "FAILED!" + | _ => die "FAILED!" val _ = Process.exit Process.success; From ef7a837eb59e24d744c0af95c49bb16bfe3c8803 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Thu, 11 Jun 2015 23:31:56 +1000 Subject: [PATCH 335/718] DROP_DROP_T, like DROP_DROP without condition, as DROP is total also total version TL_T of TL, lemma DROP_FUNPOW_TL --- src/list/src/rich_listScript.sml | 24 ++++++++++++++++++++---- 1 file changed, 20 insertions(+), 4 deletions(-) diff --git a/src/list/src/rich_listScript.sml b/src/list/src/rich_listScript.sml index cd1b7e7f4c..b9df4e2ffb 100644 --- a/src/list/src/rich_listScript.sml +++ b/src/list/src/rich_listScript.sml @@ -127,6 +127,11 @@ val COUNT_LIST_AUX_def = TotalDefn.Define` (COUNT_LIST_AUX 0 l = l) /\ (COUNT_LIST_AUX (SUC n) l = COUNT_LIST_AUX n (n::l))`; +(* total version of TL *) +val TL_T_def = TotalDefn.Define` + (TL_T [] = []) /\ + (TL_T (h::t) = t)`; + (* ------------------------------------------------------------------------ *) val TAKE = Q.store_thm("TAKE", @@ -139,6 +144,16 @@ val DROP = Q.store_thm("DROP", (!n x l:'a list. DROP (SUC n) (CONS x l) = DROP n l)`, SRW_TAC [] []); +val tlt_lem = Q.prove ( + `FUNPOW TL_T n [] = []`, + Induct_on `n` THEN ASM_SIMP_TAC list_ss [FUNPOW, TL_T_def]) ; + +val DROP_FUNPOW_TL = Q.store_thm("DROP_FUNPOW_TL", + `(!n l. DROP n l = FUNPOW TL_T n l)`, + Induct THEN1 SIMP_TAC list_ss [DROP, FUNPOW] + THEN Cases_on `l` THEN1 SIMP_TAC list_ss [listTheory.DROP_def, tlt_lem] + THEN ASM_SIMP_TAC list_ss [DROP, FUNPOW, TL_T_def]) ; + val NOT_NULL_SNOC = Q.store_thm("NOT_NULL_SNOC", `!x l. ~NULL (SNOC x l)`, BasicProvers.Induct_on `l` @@ -1467,12 +1482,13 @@ val DROP_APPEND2 = Q.store_thm ("DROP_APPEND2", THEN BasicProvers.Induct THEN ASM_REWRITE_TAC [NOT_SUC_LESS_EQ_0, LESS_EQ_MONO, SUB_MONO_EQ, DROP]) +val DROP_DROP_T = Q.store_thm ("DROP_DROP_T", + `!n m l. DROP n (DROP m l) = DROP (n + m) l`, + SIMP_TAC list_ss [DROP_FUNPOW_TL, GSYM FUNPOW_ADD]) ; + val DROP_DROP = Q.store_thm ("DROP_DROP", `!n m l. n + m <= LENGTH l ==> (DROP n (DROP m l) = DROP (n + m) l)`, - REPEAT BasicProvers.Induct - THEN REWRITE_TAC [LENGTH, DROP, NOT_SUC_LESS_EQ_0, NOT_LESS_0, ADD, ADD_0] - THEN REWRITE_TAC [ADD_SUC_lem, LESS_EQ_MONO] - THEN FIRST_ASSUM MATCH_ACCEPT_TAC); + SIMP_TAC list_ss [DROP_DROP_T]) ; val LASTN_SEG = Q.store_thm ("LASTN_SEG", `!n l. n <= LENGTH l ==> (LASTN n l = SEG n (LENGTH l - n) l)`, From b6dc3c4243bd36ae89ae6223ff3f1d2221056a70 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Thu, 11 Jun 2015 23:38:09 +1000 Subject: [PATCH 336/718] TAKE_TAKE_T, like TAKE_TAKE without condition, as TAKE is total --- src/list/src/rich_listScript.sml | 26 ++++++++------------------ 1 file changed, 8 insertions(+), 18 deletions(-) diff --git a/src/list/src/rich_listScript.sml b/src/list/src/rich_listScript.sml index b9df4e2ffb..be25524b19 100644 --- a/src/list/src/rich_listScript.sml +++ b/src/list/src/rich_listScript.sml @@ -1436,26 +1436,16 @@ val EVERY_BUTLASTN = Q.store_thm ("EVERY_BUTLASTN", THEN RES_TAC THEN ASM_REWRITE_TAC []]]); +val TAKE_TAKE_T = Q.store_thm ("TAKE_TAKE", + `!m l n. n <= m ==> (TAKE n (TAKE m l) = TAKE n l)`, + Induct THEN1 SIMP_TAC list_ss [TAKE, listTheory.TAKE_def] + THEN Cases THEN1 SIMP_TAC list_ss [TAKE, listTheory.TAKE_def] + THEN Cases THEN1 SIMP_TAC list_ss [TAKE, listTheory.TAKE_def] + THEN ASM_SIMP_TAC list_ss [TAKE, listTheory.TAKE_def]) ; + val TAKE_TAKE = Q.store_thm ("TAKE_TAKE", `!m l. m <= LENGTH l ==> !n. n <= m ==> (TAKE n (TAKE m l) = TAKE n l)`, - INDUCT_TAC - THEN LIST_INDUCT_TAC - THEN REWRITE_TAC [LENGTH, TAKE] - THENL [ - GEN_TAC - THEN DISCH_TAC - THEN INDUCT_TAC - THEN REWRITE_TAC [NOT_SUC_LESS_EQ_0, TAKE], - REWRITE_TAC [NOT_SUC_LESS_EQ_0], - GEN_TAC - THEN REWRITE_TAC [LESS_EQ_MONO] - THEN DISCH_TAC - THEN INDUCT_TAC - THEN REWRITE_TAC [TAKE] - THEN REWRITE_TAC [LESS_EQ_MONO] - THEN DISCH_TAC - THEN RES_TAC - THEN ASM_REWRITE_TAC []]); + SIMP_TAC bool_ss [TAKE_TAKE_T]) ; val DROP_LENGTH_NIL = Q.store_thm ("DROP_LENGTH_NIL", `!l. DROP (LENGTH l) l = []`, From 7c9dedecc013c0d56b49e9dfe30d7e6380404d78 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Thu, 11 Jun 2015 23:42:33 +1000 Subject: [PATCH 337/718] DROP_APPEND, generalises DROP_APPEND1 and DROP_APPEND2 --- src/list/src/rich_listScript.sml | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/list/src/rich_listScript.sml b/src/list/src/rich_listScript.sml index be25524b19..c9890d3163 100644 --- a/src/list/src/rich_listScript.sml +++ b/src/list/src/rich_listScript.sml @@ -1456,6 +1456,12 @@ val BUTLASTN_LENGTH_NIL = Q.store_thm ("BUTLASTN_LENGTH_NIL", SNOC_INDUCT_TAC THEN ASM_REWRITE_TAC [LENGTH, LENGTH_SNOC, BUTLASTN]); +val DROP_APPEND = Q.store_thm ("DROP_APPEND", + `!n l1 l2. DROP n (APPEND l1 l2) = DROP n l1 ++ DROP (n - LENGTH l1) l2`, + Induct THEN1 SIMP_TAC list_ss [DROP, listTheory.DROP_def] + THEN Cases THEN1 SIMP_TAC list_ss [DROP, listTheory.DROP_def] + THEN ASM_SIMP_TAC list_ss [DROP, listTheory.DROP_def]) ; + val DROP_APPEND1 = Q.store_thm ("DROP_APPEND1", `!n l1. n <= LENGTH l1 ==> !l2. DROP n (APPEND l1 l2) = APPEND (DROP n l1) l2`, From b8a57867d471413bd3024691851e105c6e154274 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Thu, 11 Jun 2015 23:46:34 +1000 Subject: [PATCH 338/718] TAKE_APPEND, generalises TAKE_APPEND1 and TAKE_APPEND2 --- src/list/src/rich_listScript.sml | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/list/src/rich_listScript.sml b/src/list/src/rich_listScript.sml index c9890d3163..2538a4502f 100644 --- a/src/list/src/rich_listScript.sml +++ b/src/list/src/rich_listScript.sml @@ -2002,6 +2002,12 @@ val DROP_LENGTH_APPEND = Q.store_thm ("DROP_LENGTH_APPEND", `!l1 l2. DROP (LENGTH l1) (APPEND l1 l2) = l2`, LIST_INDUCT_TAC THEN ASM_REWRITE_TAC [LENGTH, DROP, APPEND]); +val TAKE_APPEND = Q.store_thm ("TAKE_APPEND", + `!n l1 l2. TAKE n (APPEND l1 l2) = TAKE n l1 ++ TAKE (n - LENGTH l1) l2`, + Induct THEN1 SIMP_TAC list_ss [TAKE, listTheory.TAKE_def] + THEN Cases THEN1 SIMP_TAC list_ss [TAKE, listTheory.TAKE_def] + THEN ASM_SIMP_TAC list_ss [TAKE, listTheory.TAKE_def]) ; + val TAKE_APPEND1 = Q.store_thm ("TAKE_APPEND1", `!n l1. n <= LENGTH l1 ==> !l2. TAKE n (APPEND l1 l2) = TAKE n l1`, INDUCT_TAC From eb33451997ea35e0e19471ffd33e864bd489e096 Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Fri, 12 Jun 2015 11:24:11 +0100 Subject: [PATCH 339/718] Add two more variants of FULL_SIMP_TAC. The tactics NO_STRIP_FULL_SIMP_TAC and NO_STRIP_REV_FULL_SIMP_TAC don't use STRIP_THM_THEN. This means that simplifying with an assumption ``a \/ b`` will not split the current goal into two sub-goals. --- src/boss/bossLib.sig | 3 +++ src/simp/src/simpLib.sig | 5 ++++- src/simp/src/simpLib.sml | 20 +++++++++++--------- 3 files changed, 18 insertions(+), 10 deletions(-) diff --git a/src/boss/bossLib.sig b/src/boss/bossLib.sig index d4e847bcbb..2b3138eaf5 100644 --- a/src/boss/bossLib.sig +++ b/src/boss/bossLib.sig @@ -82,6 +82,9 @@ sig val RW_TAC : simpset -> thm list -> tactic val SRW_TAC : ssfrag list -> thm list -> tactic + val NO_STRIP_FULL_SIMP_TAC : simpset -> thm list -> tactic + val NO_STRIP_REV_FULL_SIMP_TAC : simpset -> thm list -> tactic + (* Call-by-value evaluation *) val EVAL : term -> thm val EVAL_RULE : thm -> thm diff --git a/src/simp/src/simpLib.sig b/src/simp/src/simpLib.sig index 221a6d9862..410ab58e40 100644 --- a/src/simp/src/simpLib.sig +++ b/src/simp/src/simpLib.sig @@ -169,7 +169,10 @@ sig val SIMP_TAC : simpset -> thm list -> tactic val ASM_SIMP_TAC : simpset -> thm list -> tactic val FULL_SIMP_TAC : simpset -> thm list -> tactic - val REV_FULL_SIMP_TAC : simpset -> thm list -> tactic + + val REV_FULL_SIMP_TAC : simpset -> thm list -> tactic + val NO_STRIP_FULL_SIMP_TAC : simpset -> thm list -> tactic + val NO_STRIP_REV_FULL_SIMP_TAC : simpset -> thm list -> tactic (* --------------------------------------------------------------------- * SIMP_RULE : simpset -> tactic diff --git a/src/simp/src/simpLib.sml b/src/simp/src/simpLib.sml index 5af1430624..e02e88687d 100644 --- a/src/simp/src/simpLib.sml +++ b/src/simp/src/simpLib.sml @@ -597,9 +597,8 @@ fun ASM_SIMP_TAC ss = local (* differs only in that it doesn't call OPPOSITE_TAC or DISCARD_TAC *) - val STRIP_ASSUME_TAC' = - REPEAT_TCL STRIP_THM_THEN - (fn th => FIRST [CONTR_TAC th, ACCEPT_TAC th, ASSUME_TAC th]) + fun caa_tac th = FIRST [CONTR_TAC th, ACCEPT_TAC th, ASSUME_TAC th] + val STRIP_ASSUME_TAC' = REPEAT_TCL STRIP_THM_THEN caa_tac fun drop r = fn n => POP_ASSUM_LIST @@ -607,20 +606,23 @@ local MAP_EVERY ASSUME_TAC (Lib.with_exn (r o List.take) (l, List.length l - n) (Feedback.mk_HOL_ERR "simpLib" "drop" "Bad cut off number"))) - fun GEN_FULL_SIMP_TAC (drop, r) = + fun GEN_FULL_SIMP_TAC (drop, r) tac = fn ss => fn thms => let fun simp_asm (t, l') = SIMP_RULE ss (l' @ thms) t :: l' - fun f asms = - MAP_EVERY STRIP_ASSUME_TAC' (List.foldl simp_asm [] (r asms)) - THEN drop (List.length asms) + fun f asms = MAP_EVERY tac (List.foldl simp_asm [] (r asms)) + THEN drop (List.length asms) in markerLib.ABBRS_THEN (fn l => ASSUM_LIST f THEN ASM_SIMP_TAC ss l) thms end + val full_tac = GEN_FULL_SIMP_TAC (drop List.rev, Lib.I) + val rev_full_tac = GEN_FULL_SIMP_TAC (drop Lib.I, List.rev) in - val FULL_SIMP_TAC = GEN_FULL_SIMP_TAC (drop List.rev, Lib.I) - val REV_FULL_SIMP_TAC = GEN_FULL_SIMP_TAC (drop Lib.I, List.rev) + val FULL_SIMP_TAC = full_tac STRIP_ASSUME_TAC' + val REV_FULL_SIMP_TAC = rev_full_tac STRIP_ASSUME_TAC' + val NO_STRIP_FULL_SIMP_TAC = full_tac caa_tac + val NO_STRIP_REV_FULL_SIMP_TAC = rev_full_tac caa_tac end fun track f x = From b2f6c17e3394a34b40a99837ab1a3b90e4e0555d Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Fri, 12 Jun 2015 11:26:14 +0100 Subject: [PATCH 340/718] Simplify the x86-64 model under L3 examples. The instruction cache has been removed, together with the CPUID instruction. Also, the memory now has type ``: word64 -> word8`` instead of ``: word64 -> word8 option``. --- examples/l3-machine-code/common/stateLib.sml | 2 +- examples/l3-machine-code/x64/model/x64.sig | 10 +- examples/l3-machine-code/x64/model/x64.sml | 65 +- .../l3-machine-code/x64/model/x64Script.sml | 835 ++++++++---------- .../l3-machine-code/x64/prog/x64_progLib.sml | 32 +- .../x64/prog/x64_progScript.sml | 13 +- .../l3-machine-code/x64/step/x64_stepLib.sml | 94 +- .../x64/step/x64_stepScript.sml | 169 ++-- 8 files changed, 479 insertions(+), 741 deletions(-) diff --git a/examples/l3-machine-code/common/stateLib.sml b/examples/l3-machine-code/common/stateLib.sml index 32db2053c6..5f02889b25 100644 --- a/examples/l3-machine-code/common/stateLib.sml +++ b/examples/l3-machine-code/common/stateLib.sml @@ -1702,7 +1702,7 @@ local Conv.REDEPTH_CONV (Conv.REWR_CONV (GSYM set_sepTheory.STAR_ASSOC)) val cond_STAR1_I = utilsLib.qm [cond_STAR1, combinTheory.I_THM] - ``(cond c * p) (s:'a set) = I c /\ p s`` + ``(set_sep$cond c * p) (s:'a set) = I c /\ p s`` in fun spec imp_spec imp_temp read_thms write_thms select_state_thms frame_thms component_11 map_tys EXTRA_TAC STATE_TAC = diff --git a/examples/l3-machine-code/x64/model/x64.sig b/examples/l3-machine-code/x64/model/x64.sig index e241d45e14..f2ebdc3622 100644 --- a/examples/l3-machine-code/x64/model/x64.sig +++ b/examples/l3-machine-code/x64/model/x64.sig @@ -1,4 +1,4 @@ -(* x64 - generated by L<3> - Tue Nov 18 15:39:44 2014 *) +(* x64 - generated by L<3> - Wed Jun 10 13:04:41 2015 *) signature x64 = sig @@ -46,7 +46,6 @@ datatype instruction = Zbinop of Zbinop_name * (Zsize * Zdest_src) | Zcall of Zimm_rm | Zcmpxchg of Zsize * (Zrm * Zreg) - | Zcpuid | Zdiv of Zsize * Zrm | Zjcc of Zcond * BitsN.nbit | Zjmp of Zrm @@ -117,9 +116,8 @@ val ZcondToString:Zcond-> string end -val EFLAGS: (bool option Map.map) ref -val ICACHE: (BitsN.nbit option Map.map) ref -val MEM: (BitsN.nbit option Map.map) ref +val EFLAGS: ((bool option) Map.map) ref +val MEM: (BitsN.nbit Map.map) ref val REG: (BitsN.nbit Map.map) ref val RIP: BitsN.nbit ref val REX_B_rupd: REX * bool -> REX @@ -207,7 +205,6 @@ val x64_drop: BitsN.nbit -> unit val dfn'Zbinop: (Zbinop_name * (Zsize * Zdest_src)) -> unit val dfn'Zcall: Zimm_rm -> unit val dfn'Zcmpxchg: (Zsize * (Zrm * Zreg)) -> unit -val dfn'Zcpuid: unit -> unit val dfn'Zdiv: (Zsize * Zrm) -> unit val dfn'Zjcc: (Zcond * BitsN.nbit) -> unit val dfn'Zjmp: Zrm -> unit @@ -261,7 +258,6 @@ val OpSize: (bool * (bool * (BitsN.nbit * bool))) -> Zsize val isZm: Zrm -> bool val x64_decode: (BitsN.nbit list) -> Zinst val x64_fetch: unit -> (BitsN.nbit list) -val checkIcache: Nat.nat -> unit val x64_next: unit -> unit val e_imm8: BitsN.nbit -> (BitsN.nbit list) val e_imm16: BitsN.nbit -> (BitsN.nbit list) diff --git a/examples/l3-machine-code/x64/model/x64.sml b/examples/l3-machine-code/x64/model/x64.sml index f34a318271..e3f77f99f4 100644 --- a/examples/l3-machine-code/x64/model/x64.sml +++ b/examples/l3-machine-code/x64/model/x64.sml @@ -1,4 +1,4 @@ -(* x64 - generated by L<3> - Tue Nov 18 15:39:44 2014 *) +(* x64 - generated by L<3> - Wed Jun 10 13:04:41 2015 *) structure x64 :> x64 = struct @@ -46,7 +46,6 @@ datatype instruction = Zbinop of Zbinop_name * (Zsize * Zdest_src) | Zcall of Zimm_rm | Zcmpxchg of Zsize * (Zrm * Zreg) - | Zcpuid | Zdiv of Zsize * Zrm | Zjcc of Zcond * BitsN.nbit | Zjmp of Zrm @@ -409,13 +408,10 @@ exception FAILURE of string Global variables (state) ------------------------------------------------------------------------- *) -val EFLAGS = ref (Map.mkMap(SOME 6,NONE)): (bool option Map.map) ref +val EFLAGS = ref (Map.mkMap(SOME 6,NONE)): ((bool option) Map.map) ref -val ICACHE = ref (Map.mkMap(SOME 18446744073709551616,NONE)) - : (BitsN.nbit option Map.map) ref - -val MEM = ref (Map.mkMap(SOME 18446744073709551616,NONE)) - : (BitsN.nbit option Map.map) ref +val MEM = ref (Map.mkMap(SOME 18446744073709551616,BitsN.B(0x0,8))) + : (BitsN.nbit Map.map) ref val REG = ref (Map.mkMap(SOME 16,BitsN.B(0x0,64))) : (BitsN.nbit Map.map) ref @@ -434,15 +430,9 @@ in val boolify'8 = tuple'8 o BitsN.toList end -fun mem8 addr = - case Map.lookup((!MEM),BitsN.toNat addr) of - Option.SOME b => b - | NONE => raise BadMemAccess addr; +fun mem8 addr = Map.lookup((!MEM),BitsN.toNat addr); -fun write'mem8 (b,addr) = - if Option.isSome(Map.lookup((!MEM),BitsN.toNat addr)) - then MEM := (Map.update((!MEM),BitsN.toNat addr,Option.SOME b)) - else raise BadMemAccess addr; +fun write'mem8 (b,addr) = MEM := (Map.update((!MEM),BitsN.toNat addr,b)); fun mem16 addr = BitsN.@@(mem8(BitsN.+(addr,BitsN.B(0x1,64))),mem8 addr); @@ -984,14 +974,6 @@ fun dfn'Zcmpxchg (size,(rm,r)) = ) end; -fun dfn'Zcpuid () = - ( ICACHE := (!MEM) - ; REG := (Map.update((!REG),Cast.ZregToNat RAX,BitsN.B(0x0,64))) - ; REG := (Map.update((!REG),Cast.ZregToNat RBX,BitsN.B(0x0,64))) - ; REG := (Map.update((!REG),Cast.ZregToNat RCX,BitsN.B(0x0,64))) - ; REG := (Map.update((!REG),Cast.ZregToNat RDX,BitsN.B(0x0,64))) - ); - fun dfn'Zdiv (size,rm) = let val w = value_width size @@ -1131,8 +1113,7 @@ fun dfn'Zxchg (size,(rm,r)) = fun Run v0 = case v0 of - Zcpuid => dfn'Zcpuid () - | Zleave => dfn'Zleave () + Zleave => dfn'Zleave () | Znop => dfn'Znop | Zbinop v1 => dfn'Zbinop v1 | Zcall v2 => dfn'Zcall v2 @@ -1873,10 +1854,6 @@ fun x64_decode strm = (BitsN.fromBitstring ([c'3,c'2,c'1,c'0],4)),imm),strm3)) end - | (true, - (false, - (true,(false,(false,(false,(true,false))))))) => - Zfull_inst(p,(Zcpuid,strm2)) | (true, (false, (true,(true,(false,(false,(false,v'0))))))) => @@ -1954,38 +1931,21 @@ fun x64_fetch () = (19,0, fn i => strm := - ((Option.valOf - (Map.lookup - ((!MEM),BitsN.toNat(BitsN.+((!RIP),BitsN.fromNat(i,64)))))) + ((Map.lookup + ((!MEM),BitsN.toNat(BitsN.+((!RIP),BitsN.fromNat(i,64))))) :: (!strm))) ; (!strm) ) end; -fun checkIcache n = - L3.for - (0,Nat.-(n,1), - fn i => - let - val addr = BitsN.+((!RIP),BitsN.fromNat(i,64)) - in - if not((Map.lookup((!MEM),BitsN.toNat addr)) = - (Map.lookup((!ICACHE),BitsN.toNat addr))) - then raise FAILURE ("icache miss") - else () - end); - fun x64_next () = case x64_decode(x64_fetch ()) of Zfull_inst(_,(i,strm1)) => let val len = Nat.-(20,List.length strm1) in - ( checkIcache len - ; RIP := (BitsN.+((!RIP),BitsN.fromNat(len,64))) - ; Run i - ) + ( RIP := (BitsN.+((!RIP),BitsN.fromNat(len,64))); Run i ) end | Zdec_fail s => raise FAILURE s; @@ -2319,7 +2279,6 @@ fun encode i = (rm, (BitsN.fromNat(Cast.ZregToNat r,4), ([BitsN.B(0xF,8)],BitsN.B(0xB0,8))))) - | Zcpuid => [BitsN.B(0xF,8),BitsN.B(0xA2,8)] | Zdiv(sz,rm) => e_rm_reg(sz,(rm,(BitsN.B(0x6,4),([],BitsN.B(0xF6,8))))) | Zjcc(cond,imm) => @@ -3260,8 +3219,7 @@ fun instructionFromString s = FAIL("Unrecognised op-code or wrong number of args")) | [] => (case v'0 of - "cpuid" => OK Zcpuid - | "leave" => OK Zleave + "leave" => OK Zleave | "nop" => OK Znop | "ret" => OK(Zret(BitsN.B(0x0,64))) | v'2 => @@ -3420,7 +3378,6 @@ fun instructionToString (i,width) = | Zcall(Zrm rm) => ("call",s_rm(Z64,rm)) | Zcmpxchg(sz,(rm,r)) => ("cmpxchg",String.concat[s_rm(sz,rm),", ",s_register(sz,r)]) - | Zcpuid => ("cpuid","") | Zdiv sz_rm => ("div",s_sz_rm sz_rm) | Zjcc(Z_ALWAYS,imm) => ("jmp",s_qword(BitsN.+(imm,BitsN.fromNat(width,64)))) diff --git a/examples/l3-machine-code/x64/model/x64Script.sml b/examples/l3-machine-code/x64/model/x64Script.sml index ea426fd7bd..19fde2f8e0 100644 --- a/examples/l3-machine-code/x64/model/x64Script.sml +++ b/examples/l3-machine-code/x64/model/x64Script.sml @@ -1,4 +1,4 @@ -(* x64Script.sml - generated by L<3> - Fri Aug 29 10:13:38 2014 *) +(* x64Script.sml - generated by L<3> - Wed Jun 10 13:04:51 2015 *) open HolKernel boolLib bossLib Import val () = Import.start "x64" @@ -57,7 +57,7 @@ val _ = Construct [("instruction", [("Zbinop",[PTy(CTy"Zbinop_name",PTy(CTy"Zsize",CTy"Zdest_src"))]), ("Zcall",[CTy"Zimm_rm"]), - ("Zcmpxchg",[PTy(CTy"Zsize",PTy(CTy"Zrm",CTy"Zreg"))]),("Zcpuid",[]), + ("Zcmpxchg",[PTy(CTy"Zsize",PTy(CTy"Zrm",CTy"Zreg"))]), ("Zdiv",[PTy(CTy"Zsize",CTy"Zrm")]),("Zjcc",[PTy(CTy"Zcond",F64)]), ("Zjmp",[CTy"Zrm"]),("Zlea",[PTy(CTy"Zsize",CTy"Zdest_src")]), ("Zleave",[]),("Zloop",[PTy(CTy"Zcond",F64)]), @@ -84,9 +84,8 @@ val _ = Construct ; val _ = Record ("x64_state", - [("EFLAGS",ATy(CTy"Zeflags",OTy bTy)),("ICACHE",ATy(F64,OTy F8)), - ("MEM",ATy(F64,OTy F8)),("REG",ATy(CTy"Zreg",F64)),("RIP",F64), - ("exception",CTy"exception")]) + [("EFLAGS",ATy(CTy"Zeflags",OTy bTy)),("MEM",ATy(F64,F8)), + ("REG",ATy(CTy"Zreg",F64)),("RIP",F64),("exception",CTy"exception")]) ; val qTy = CTy "x64_state"; fun qVar v = Term.mk_var (v, ParseDatatype.pretypeToType qTy); @@ -104,48 +103,34 @@ val mem8_def = Def ("mem8",Var("addr",F64), Close (qVar"state", - CS(Apply(Dest("MEM",ATy(F64,OTy F8),qVar"state"),Var("addr",F64)), - [(Mop(Some,Var("b",F8)),TP[Var("b",F8),qVar"state"]), - (LO F8, - Apply - (Call - ("raise'exception",ATy(qTy,PTy(F8,qTy)), - Call("BadMemAccess",CTy"exception",Var("addr",F64))), - qVar"state"))]))) + TP[Apply(Dest("MEM",ATy(F64,F8),qVar"state"),Var("addr",F64)), + qVar"state"])) ; val write'mem8_def = Def ("write'mem8",TP[Var("b",F8),Var("addr",F64)], Close (qVar"state", - ITE(Mop(IsSome, - Apply - (Dest("MEM",ATy(F64,OTy F8),qVar"state"),Var("addr",F64))), - TP[LU, - Rupd - ("MEM", - TP[qVar"state", - Fupd - (Dest("MEM",ATy(F64,OTy F8),qVar"state"), - Var("addr",F64),Mop(Some,Var("b",F8)))])], - Apply - (Call - ("raise'exception",ATy(qTy,PTy(uTy,qTy)), - Call("BadMemAccess",CTy"exception",Var("addr",F64))), - qVar"state")))) + TP[LU, + Rupd + ("MEM", + TP[qVar"state", + Fupd + (Dest("MEM",ATy(F64,F8),qVar"state"),Var("addr",F64), + Var("b",F8))])])) ; val mem16_def = Def ("mem16",Var("addr",F64), Close (qVar"state", - Let(TP[Var("v",F8),qVar"s"], - Apply - (Call - ("mem8",ATy(qTy,PTy(F8,qTy)), - Bop(Add,Var("addr",F64),LW(1,64))),qVar"state"), - Let(TP[Var("v0",F8),qVar"s"], - Apply - (Call("mem8",ATy(qTy,PTy(F8,qTy)),Var("addr",F64)),qVar"s"), - TP[CC[Var("v",F8),Var("v0",F8)],qVar"s"])))) + TP[CC[Mop(Fst, + Apply + (Call + ("mem8",ATy(qTy,PTy(F8,qTy)), + Bop(Add,Var("addr",F64),LW(1,64))),qVar"state")), + Mop(Fst, + Apply + (Call("mem8",ATy(qTy,PTy(F8,qTy)),Var("addr",F64)), + qVar"state"))],qVar"state"])) ; val write'mem16_def = Def ("write'mem16",TP[Var("w",F16),Var("addr",F64)], @@ -167,15 +152,15 @@ val mem32_def = Def ("mem32",Var("addr",F64), Close (qVar"state", - Let(TP[Var("v",F16),qVar"s"], - Apply - (Call - ("mem16",ATy(qTy,PTy(F16,qTy)), - Bop(Add,Var("addr",F64),LW(2,64))),qVar"state"), - Let(TP[Var("v0",F16),qVar"s"], - Apply - (Call("mem16",ATy(qTy,PTy(F16,qTy)),Var("addr",F64)), - qVar"s"),TP[CC[Var("v",F16),Var("v0",F16)],qVar"s"])))) + TP[CC[Mop(Fst, + Apply + (Call + ("mem16",ATy(qTy,PTy(F16,qTy)), + Bop(Add,Var("addr",F64),LW(2,64))),qVar"state")), + Mop(Fst, + Apply + (Call("mem16",ATy(qTy,PTy(F16,qTy)),Var("addr",F64)), + qVar"state"))],qVar"state"])) ; val write'mem32_def = Def ("write'mem32",TP[Var("w",F32),Var("addr",F64)], @@ -197,15 +182,15 @@ val mem64_def = Def ("mem64",Var("addr",F64), Close (qVar"state", - Let(TP[Var("v",F32),qVar"s"], - Apply - (Call - ("mem32",ATy(qTy,PTy(F32,qTy)), - Bop(Add,Var("addr",F64),LW(4,64))),qVar"state"), - Let(TP[Var("v0",F32),qVar"s"], - Apply - (Call("mem32",ATy(qTy,PTy(F32,qTy)),Var("addr",F64)), - qVar"s"),TP[CC[Var("v",F32),Var("v0",F32)],qVar"s"])))) + TP[CC[Mop(Fst, + Apply + (Call + ("mem32",ATy(qTy,PTy(F32,qTy)), + Bop(Add,Var("addr",F64),LW(4,64))),qVar"state")), + Mop(Fst, + Apply + (Call("mem32",ATy(qTy,PTy(F32,qTy)),Var("addr",F64)), + qVar"state"))],qVar"state"])) ; val write'mem64_def = Def ("write'mem64",TP[Var("w",F64),Var("addr",F64)], @@ -529,23 +514,28 @@ val EA_def = Def (Call ("Zea_m",CTy"Zea", TP[Call("Z8",CTy"Zsize",AVar bTy),Var("a",F64)]), - Let(TP[Var("v",F8),qVar"s"], - Apply - (Call("mem8",ATy(qTy,PTy(F8,qTy)),Var("a",F64)), - qVar"state"),TP[Mop(Cast F64,Var("v",F8)),qVar"s"])), + TP[Mop(Cast F64, + Mop(Fst, + Apply + (Call("mem8",ATy(qTy,PTy(F8,qTy)),Var("a",F64)), + qVar"state"))),qVar"state"]), (Call("Zea_m",CTy"Zea",TP[Const("Z16",CTy"Zsize"),Var("a",F64)]), - Let(TP[Var("v",F16),qVar"s"], - Apply - (Call("mem16",ATy(qTy,PTy(F16,qTy)),Var("a",F64)), - qVar"state"),TP[Mop(Cast F64,Var("v",F16)),qVar"s"])), + TP[Mop(Cast F64, + Mop(Fst, + Apply + (Call("mem16",ATy(qTy,PTy(F16,qTy)),Var("a",F64)), + qVar"state"))),qVar"state"]), (Call("Zea_m",CTy"Zea",TP[Const("Z32",CTy"Zsize"),Var("a",F64)]), - Let(TP[Var("v",F32),qVar"s"], - Apply - (Call("mem32",ATy(qTy,PTy(F32,qTy)),Var("a",F64)), - qVar"state"),TP[Mop(Cast F64,Var("v",F32)),qVar"s"])), + TP[Mop(Cast F64, + Mop(Fst, + Apply + (Call("mem32",ATy(qTy,PTy(F32,qTy)),Var("a",F64)), + qVar"state"))),qVar"state"]), (Call("Zea_m",CTy"Zea",TP[Const("Z64",CTy"Zsize"),Var("a",F64)]), - Apply - (Call("mem64",ATy(qTy,PTy(F64,qTy)),Var("a",F64)),qVar"state"))]))) + TP[Mop(Fst, + Apply + (Call("mem64",ATy(qTy,PTy(F64,qTy)),Var("a",F64)), + qVar"state")),qVar"state"])]))) ; val write'EA_def = Def ("write'EA",TP[Var("w",F64),Var("ea",CTy"Zea")], @@ -665,25 +655,22 @@ val read_dest_src_ea_def = Def (Call ("ea_Zdest",ATy(qTy,PTy(CTy"Zea",qTy)), Var("sd",PTy(CTy"Zsize",CTy"Zdest_src"))),qVar"state")), - Let(TP[Var("v0",F64),qVar"s"], - Apply - (Call("EA",ATy(qTy,PTy(F64,qTy)),Var("v",CTy"Zea")), - qVar"state"), - Let(TP[Var("v0",PTy(F64,F64)),qVar"s"], - Let(TP[Var("v1",F64),qVar"s"], - Apply - (Call - ("EA",ATy(qTy,PTy(F64,qTy)), - Mop(Fst, - Apply - (Call - ("ea_Zsrc", - ATy(qTy,PTy(CTy"Zea",qTy)), - Var("sd", - PTy(CTy"Zsize",CTy"Zdest_src"))), - qVar"s"))),qVar"s"), - TP[TP[Var("v0",F64),Var("v1",F64)],qVar"s"]), - TP[TP[Var("v",CTy"Zea"),Var("v0",PTy(F64,F64))],qVar"s"]))))) + TP[TP[Var("v",CTy"Zea"), + Mop(Fst, + Apply + (Call("EA",ATy(qTy,PTy(F64,qTy)),Var("v",CTy"Zea")), + qVar"state")), + Mop(Fst, + Apply + (Call + ("EA",ATy(qTy,PTy(F64,qTy)), + Mop(Fst, + Apply + (Call + ("ea_Zsrc",ATy(qTy,PTy(CTy"Zea",qTy)), + Var("sd", + PTy(CTy"Zsize",CTy"Zdest_src"))), + qVar"state"))),qVar"state"))],qVar"state"]))) ; val call_dest_from_ea_def = Def ("call_dest_from_ea",Var("ea",CTy"Zea"), @@ -698,8 +685,10 @@ val call_dest_from_ea_def = Def (Dest("REG",ATy(CTy"Zreg",F64),qVar"state"), Var("r",CTy"Zreg")),qVar"state"]), (Call("Zea_m",CTy"Zea",TP[AVar(CTy"Zsize"),Var("a",F64)]), - Apply - (Call("mem64",ATy(qTy,PTy(F64,qTy)),Var("a",F64)),qVar"state"))]))) + TP[Mop(Fst, + Apply + (Call("mem64",ATy(qTy,PTy(F64,qTy)),Var("a",F64)), + qVar"state")),qVar"state"])]))) ; val get_ea_address_def = Def ("get_ea_address",Var("ea",CTy"Zea"), @@ -714,12 +703,15 @@ val jump_to_ea_def = Def ("jump_to_ea",Var("ea",CTy"Zea"), Close (qVar"state", - Let(TP[Var("v",F64),qVar"s"], - Apply - (Call - ("call_dest_from_ea",ATy(qTy,PTy(F64,qTy)), - Var("ea",CTy"Zea")),qVar"state"), - TP[LU,Rupd("RIP",TP[qVar"s",Var("v",F64)])]))) + TP[LU, + Rupd + ("RIP", + TP[qVar"state", + Mop(Fst, + Apply + (Call + ("call_dest_from_ea",ATy(qTy,PTy(F64,qTy)), + Var("ea",CTy"Zea")),qVar"state"))])])) ; val ByteParity_def = Def ("ByteParity",Var("b",F8), @@ -1447,16 +1439,16 @@ val x64_pop_aux_def = Def Let(Var("v",F64), Apply (Dest("REG",ATy(CTy"Zreg",F64),qVar"state"),LC("RSP",CTy"Zreg")), - Let(TP[Var("v0",F64),qVar"s"], - Apply - (Call("mem64",ATy(qTy,PTy(F64,qTy)),Var("v",F64)),qVar"state"), - TP[Var("v0",F64), - Rupd - ("REG", - TP[qVar"s", - Fupd - (Dest("REG",ATy(CTy"Zreg",F64),qVar"s"), - LC("RSP",CTy"Zreg"),Bop(Add,Var("v",F64),LW(8,64)))])]))) + TP[Mop(Fst, + Apply + (Call("mem64",ATy(qTy,PTy(F64,qTy)),Var("v",F64)), + qVar"state")), + Rupd + ("REG", + TP[qVar"state", + Fupd + (Dest("REG",ATy(CTy"Zreg",F64),qVar"state"), + LC("RSP",CTy"Zreg"),Bop(Add,Var("v",F64),LW(8,64)))])])) ; val x64_pop_def = Def ("x64_pop",Var("rm",CTy"Zrm"), @@ -1505,20 +1497,20 @@ val x64_push_def = Def ("x64_push",Var("imm_rm",CTy"Zimm_rm"), Close (qVar"state", - Let(TP[Var("v",F64),qVar"s"], - Apply - (Call - ("EA",ATy(qTy,PTy(F64,qTy)), - Mop(Fst, - Apply - (Call - ("ea_Zimm_rm",ATy(qTy,PTy(CTy"Zea",qTy)), - TP[Const("Z64",CTy"Zsize"), - Var("imm_rm",CTy"Zimm_rm")]),qVar"state"))), - qVar"state"), - Apply - (Call("x64_push_aux",ATy(qTy,PTy(uTy,qTy)),Var("v",F64)), - qVar"s")))) + Apply + (Call + ("x64_push_aux",ATy(qTy,PTy(uTy,qTy)), + Mop(Fst, + Apply + (Call + ("EA",ATy(qTy,PTy(F64,qTy)), + Mop(Fst, + Apply + (Call + ("ea_Zimm_rm",ATy(qTy,PTy(CTy"Zea",qTy)), + TP[Const("Z64",CTy"Zsize"), + Var("imm_rm",CTy"Zimm_rm")]), + qVar"state"))),qVar"state"))),qVar"state"))) ; val x64_push_rip_def = Def ("x64_push_rip",qVar"state", @@ -1557,21 +1549,20 @@ val dfn'Zbinop_def = Def Var("dst_src",CTy"Zdest_src")], Close (qVar"state", - Let(TP[Var("v",PTy(CTy"Zea",PTy(F64,F64))),qVar"s"], - Apply - (Call - ("read_dest_src_ea", - ATy(qTy,PTy(PTy(CTy"Zea",PTy(F64,F64)),qTy)), - TP[Var("size",CTy"Zsize"),Var("dst_src",CTy"Zdest_src")]), - qVar"state"), - Let(TP[Var("ea",CTy"Zea"),Var("val_dst",F64),Var("val_src",F64)], - Var("v",PTy(CTy"Zea",PTy(F64,F64))), + Let(TP[Var("ea",CTy"Zea"),Var("val_dst",F64),Var("val_src",F64)], + Mop(Fst, Apply (Call - ("write_binop",ATy(qTy,PTy(uTy,qTy)), - TP[Var("size",CTy"Zsize"),Var("bop",CTy"Zbinop_name"), - Var("val_dst",F64),Var("val_src",F64), - Var("ea",CTy"Zea")]),qVar"s"))))) + ("read_dest_src_ea", + ATy(qTy,PTy(PTy(CTy"Zea",PTy(F64,F64)),qTy)), + TP[Var("size",CTy"Zsize"), + Var("dst_src",CTy"Zdest_src")]),qVar"state")), + Apply + (Call + ("write_binop",ATy(qTy,PTy(uTy,qTy)), + TP[Var("size",CTy"Zsize"),Var("bop",CTy"Zbinop_name"), + Var("val_dst",F64),Var("val_src",F64), + Var("ea",CTy"Zea")]),qVar"state")))) ; val dfn'Zcall_def = Def ("dfn'Zcall",Var("imm_rm",CTy"Zimm_rm"), @@ -1608,15 +1599,18 @@ val dfn'Zcmpxchg_def = Def ("ea_Zrm",ATy(qTy,PTy(CTy"Zea",qTy)), TP[Var("size",CTy"Zsize"),Var("rm",CTy"Zrm")]), qVar"state")), - Let(TP[Var("v0",F64),qVar"s"], - Apply - (Call("EA",ATy(qTy,PTy(F64,qTy)),Var("v",CTy"Zea")), - qVar"state"), - Let(TP[Var("v1",F64),qVar"s"], + Let(Var("v0",F64), + Mop(Fst, Apply (Call - ("EA",ATy(qTy,PTy(F64,qTy)), - Var("ea_src",CTy"Zea")),qVar"s"), + ("EA",ATy(qTy,PTy(F64,qTy)),Var("v",CTy"Zea")), + qVar"state")), + Let(Var("v1",F64), + Mop(Fst, + Apply + (Call + ("EA",ATy(qTy,PTy(F64,qTy)), + Var("ea_src",CTy"Zea")),qVar"state")), Let(qVar"s", Mop(Snd, Apply @@ -1625,18 +1619,20 @@ val dfn'Zcmpxchg_def = Def TP[Var("size",CTy"Zsize"), LC("Zcmp",CTy"Zbinop_name"), Var("v1",F64),Var("v0",F64), - Var("ea_src",CTy"Zea")]),qVar"s")), + Var("ea_src",CTy"Zea")]), + qVar"state")), ITE(EQ(Var("v1",F64),Var("v0",F64)), - Let(TP[Var("v0",F64),qVar"s"], - Apply - (Call - ("EA",ATy(qTy,PTy(F64,qTy)), - Var("ea_src",CTy"Zea")),qVar"s"), - Apply - (Call - ("write'EA",ATy(qTy,PTy(uTy,qTy)), - TP[Var("v0",F64),Var("v",CTy"Zea")]), - qVar"s")), + Apply + (Call + ("write'EA",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Fst, + Apply + (Call + ("EA", + ATy(qTy,PTy(F64,qTy)), + Var("ea_src",CTy"Zea")), + qVar"s")),Var("v",CTy"Zea")]), + qVar"s"), Apply (Call ("write'EA",ATy(qTy,PTy(uTy,qTy)), @@ -1647,40 +1643,6 @@ val dfn'Zcmpxchg_def = Def LC("RAX",CTy"Zreg")])]), qVar"s"))))))))) ; -val dfn'Zcpuid_def = Def - ("dfn'Zcpuid",qVar"state", - Let(qVar"s", - Rupd - ("ICACHE",TP[qVar"state",Dest("MEM",ATy(F64,OTy F8),qVar"state")]), - Let(qVar"s", - Rupd - ("REG", - TP[qVar"s", - Fupd - (Dest("REG",ATy(CTy"Zreg",F64),qVar"s"), - LC("RAX",CTy"Zreg"),LX F64)]), - Let(qVar"s", - Rupd - ("REG", - TP[qVar"s", - Fupd - (Dest("REG",ATy(CTy"Zreg",F64),qVar"s"), - LC("RBX",CTy"Zreg"),LX F64)]), - Let(qVar"s", - Rupd - ("REG", - TP[qVar"s", - Fupd - (Dest("REG",ATy(CTy"Zreg",F64),qVar"s"), - LC("RCX",CTy"Zreg"),LX F64)]), - TP[LU, - Rupd - ("REG", - TP[qVar"s", - Fupd - (Dest("REG",ATy(CTy"Zreg",F64),qVar"s"), - LC("RDX",CTy"Zreg"),LX F64)])]))))) -; val dfn'Zdiv_def = Def ("dfn'Zdiv",TP[Var("size",CTy"Zsize"),Var("rm",CTy"Zrm")], Close @@ -1694,23 +1656,26 @@ val dfn'Zdiv_def = Def Call ("Zea_r",CTy"Zea", TP[Var("size",CTy"Zsize"),LC("RAX",CTy"Zreg")]), - Let(TP[Var("v",F64),qVar"s"], - Apply - (Call - ("EA",ATy(qTy,PTy(F64,qTy)), - Var("ea_eax",CTy"Zea")),qVar"state"), - Let(TP[nVar"v",qVar"s"], - Let(TP[Var("v0",F64),qVar"s"], - Apply - (Call - ("EA",ATy(qTy,PTy(F64,qTy)), - Var("ea_edx",CTy"Zea")),qVar"s"), - TP[Bop(Add, - Bop(Mul,Mop(Cast nTy,Var("v",F64)), - nVar"w"), - Mop(Cast nTy,Var("v0",F64))),qVar"s"]), - Let(TP[nVar"v0",qVar"s"], - Let(TP[Var("v",F64),qVar"s"], + Let(nVar"v", + Bop(Add, + Bop(Mul, + Mop(Cast nTy, + Mop(Fst, + Apply + (Call + ("EA",ATy(qTy,PTy(F64,qTy)), + Var("ea_eax",CTy"Zea")), + qVar"state"))),nVar"w"), + Mop(Cast nTy, + Mop(Fst, + Apply + (Call + ("EA",ATy(qTy,PTy(F64,qTy)), + Var("ea_edx",CTy"Zea")), + qVar"state")))), + Let(nVar"v0", + Mop(Cast nTy, + Mop(Fst, Apply (Call ("EA",ATy(qTy,PTy(F64,qTy)), @@ -1722,50 +1687,44 @@ val dfn'Zdiv_def = Def PTy(CTy"Zea",qTy)), TP[Var("size",CTy"Zsize"), Var("rm",CTy"Zrm")]), - qVar"s"))),qVar"s"), - TP[Mop(Cast nTy,Var("v",F64)),qVar"s"]), - Let(nVar"q",Bop(Div,nVar"v",nVar"v0"), - Apply - (Const - ("erase_eflags", - ATy(qTy,PTy(uTy,qTy))), - Mop(Snd, - Apply - (Call - ("write'EA", - ATy(qTy,PTy(uTy,qTy)), - TP[Mop(Cast F64, - Bop(Mod,nVar"v", - nVar"v0")), - Var("ea_edx",CTy"Zea")]), - Mop(Snd, - Apply - (Call - ("write'EA", - ATy(qTy,PTy(uTy,qTy)), - TP[Mop(Cast F64, - nVar"q"), - Var("ea_eax", - CTy"Zea")]), - ITE(Bop(Or, - EQ(nVar"v0", - LN 0), - Bop(Le,nVar"w", - nVar"q")), - Mop(Snd, - Apply - (Call - ("raise'exception", - ATy(qTy, - PTy(uTy, - qTy)), - Call - ("FAILURE", - CTy"exception", - LS - "division")), - qVar"s")), - qVar"s"))))))))))))))) + qVar"state"))),qVar"state"))), + Let(nVar"q",Bop(Div,nVar"v",nVar"v0"), + Apply + (Const + ("erase_eflags",ATy(qTy,PTy(uTy,qTy))), + Mop(Snd, + Apply + (Call + ("write'EA", + ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Cast F64, + Bop(Mod,nVar"v",nVar"v0")), + Var("ea_edx",CTy"Zea")]), + Mop(Snd, + Apply + (Call + ("write'EA", + ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Cast F64,nVar"q"), + Var("ea_eax",CTy"Zea")]), + ITE(Bop(Or, + EQ(nVar"v0",LN 0), + Bop(Le,nVar"w", + nVar"q")), + Mop(Snd, + Apply + (Call + ("raise'exception", + ATy(qTy, + PTy(uTy, + qTy)), + Call + ("FAILURE", + CTy"exception", + LS + "division")), + qVar"state")), + qVar"state")))))))))))))) ; val dfn'Zjcc_def = Def ("dfn'Zjcc",TP[Var("cond",CTy"Zcond"),Var("imm",F64)], @@ -1788,17 +1747,21 @@ val dfn'Zjmp_def = Def ("dfn'Zjmp",Var("rm",CTy"Zrm"), Close (qVar"state", - Let(TP[Var("v",F64),qVar"s"], - Apply - (Call - ("EA",ATy(qTy,PTy(F64,qTy)), - Mop(Fst, - Apply - (Call - ("ea_Zrm",ATy(qTy,PTy(CTy"Zea",qTy)), - TP[Const("Z64",CTy"Zsize"),Var("rm",CTy"Zrm")]), - qVar"state"))),qVar"state"), - TP[LU,Rupd("RIP",TP[qVar"s",Var("v",F64)])]))) + TP[LU, + Rupd + ("RIP", + TP[qVar"state", + Mop(Fst, + Apply + (Call + ("EA",ATy(qTy,PTy(F64,qTy)), + Mop(Fst, + Apply + (Call + ("ea_Zrm",ATy(qTy,PTy(CTy"Zea",qTy)), + TP[Const("Z64",CTy"Zsize"), + Var("rm",CTy"Zrm")]),qVar"state"))), + qVar"state"))])])) ; val dfn'Zlea_def = Def ("dfn'Zlea",TP[Var("size",CTy"Zsize"),Var("dst_src",CTy"Zdest_src")], @@ -1880,15 +1843,15 @@ val dfn'Zmonop_def = Def ("ea_Zrm",ATy(qTy,PTy(CTy"Zea",qTy)), TP[Var("size",CTy"Zsize"),Var("rm",CTy"Zrm")]), qVar"state")), - Let(TP[Var("v0",F64),qVar"s"], - Apply - (Call("EA",ATy(qTy,PTy(F64,qTy)),Var("v",CTy"Zea")), - qVar"state"), - Apply - (Call - ("write_monop",ATy(qTy,PTy(uTy,qTy)), - TP[Var("size",CTy"Zsize"),Var("mop",CTy"Zmonop_name"), - Var("v0",F64),Var("v",CTy"Zea")]),qVar"s"))))) + Apply + (Call + ("write_monop",ATy(qTy,PTy(uTy,qTy)), + TP[Var("size",CTy"Zsize"),Var("mop",CTy"Zmonop_name"), + Mop(Fst, + Apply + (Call + ("EA",ATy(qTy,PTy(F64,qTy)),Var("v",CTy"Zea")), + qVar"state")),Var("v",CTy"Zea")]),qVar"state")))) ; val dfn'Zmov_def = Def ("dfn'Zmov", @@ -1902,29 +1865,28 @@ val dfn'Zmov_def = Def ("read_cond",ATy(qTy,PTy(bTy,qTy)),Var("cond",CTy"Zcond")), qVar"state"), ITE(bVar"v", - Let(TP[Var("v0",F64),qVar"s0"], - Apply - (Call - ("EA",ATy(qTy,PTy(F64,qTy)), - Mop(Fst, - Apply - (Call - ("ea_Zsrc",ATy(qTy,PTy(CTy"Zea",qTy)), - TP[Var("size",CTy"Zsize"), - Var("dst_src",CTy"Zdest_src")]), - qVar"s"))),qVar"s"), - Apply - (Call - ("write'EA",ATy(qTy,PTy(uTy,qTy)), - TP[Var("v0",F64), - Mop(Fst, - Apply - (Call - ("ea_Zdest", - ATy(qTy,PTy(CTy"Zea",qTy)), - TP[Var("size",CTy"Zsize"), - Var("dst_src",CTy"Zdest_src")]), - qVar"s"))]),qVar"s0")),TP[LU,qVar"s"])))) + Apply + (Call + ("write'EA",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Fst, + Apply + (Call + ("EA",ATy(qTy,PTy(F64,qTy)), + Mop(Fst, + Apply + (Call + ("ea_Zsrc", + ATy(qTy,PTy(CTy"Zea",qTy)), + TP[Var("size",CTy"Zsize"), + Var("dst_src",CTy"Zdest_src")]), + qVar"s"))),qVar"s")), + Mop(Fst, + Apply + (Call + ("ea_Zdest",ATy(qTy,PTy(CTy"Zea",qTy)), + TP[Var("size",CTy"Zsize"), + Var("dst_src",CTy"Zdest_src")]), + qVar"s"))]),qVar"s"),TP[LU,qVar"s"])))) ; val dfn'Zmovsx_def = Def ("dfn'Zmovsx", @@ -1934,26 +1896,23 @@ val dfn'Zmovsx_def = Def (qVar"state", Let(TP[Var("v",PTy(F64,CTy"Zea")),qVar"s"], Let(TP[Var("v0",F64),qVar"s"], - Let(TP[Var("v",PTy(F64,PTy(CTy"Zsize",CTy"Zsize"))),qVar"s"], - Let(TP[Var("v",F64),qVar"s"], - Apply - (Call - ("EA",ATy(qTy,PTy(F64,qTy)), - Mop(Fst, - Apply - (Call - ("ea_Zsrc", - ATy(qTy,PTy(CTy"Zea",qTy)), - TP[Var("size1",CTy"Zsize"), - Var("dst_src",CTy"Zdest_src")]), - qVar"state"))),qVar"state"), - TP[TP[Var("v",F64),Var("size1",CTy"Zsize"), - Var("size2",CTy"Zsize")],qVar"s"]), - Apply - (Call - ("SignExtension",ATy(qTy,PTy(F64,qTy)), - Var("v",PTy(F64,PTy(CTy"Zsize",CTy"Zsize")))), - qVar"s")), + Apply + (Call + ("SignExtension",ATy(qTy,PTy(F64,qTy)), + TP[Mop(Fst, + Apply + (Call + ("EA",ATy(qTy,PTy(F64,qTy)), + Mop(Fst, + Apply + (Call + ("ea_Zsrc", + ATy(qTy,PTy(CTy"Zea",qTy)), + TP[Var("size1",CTy"Zsize"), + Var("dst_src",CTy"Zdest_src")]), + qVar"state"))),qVar"state")), + Var("size1",CTy"Zsize"),Var("size2",CTy"Zsize")]), + qVar"state"), TP[TP[Var("v0",F64), Mop(Fst, Apply @@ -1973,30 +1932,27 @@ val dfn'Zmovzx_def = Def Var("size2",CTy"Zsize")], Close (qVar"state", - Let(TP[Var("v",PTy(F64,CTy"Zea")),qVar"s"], - Let(TP[Var("v0",F64),qVar"s"], - Apply - (Call - ("EA",ATy(qTy,PTy(F64,qTy)), - Mop(Fst, - Apply - (Call - ("ea_Zsrc",ATy(qTy,PTy(CTy"Zea",qTy)), - TP[Var("size1",CTy"Zsize"), - Var("dst_src",CTy"Zdest_src")]), - qVar"state"))),qVar"state"), - TP[TP[Var("v0",F64), - Mop(Fst, - Apply - (Call - ("ea_Zdest",ATy(qTy,PTy(CTy"Zea",qTy)), - TP[Var("size2",CTy"Zsize"), - Var("dst_src",CTy"Zdest_src")]), - qVar"state"))],qVar"s"]), - Apply - (Call - ("write'EA",ATy(qTy,PTy(uTy,qTy)), - Var("v",PTy(F64,CTy"Zea"))),qVar"s")))) + Apply + (Call + ("write'EA",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Fst, + Apply + (Call + ("EA",ATy(qTy,PTy(F64,qTy)), + Mop(Fst, + Apply + (Call + ("ea_Zsrc",ATy(qTy,PTy(CTy"Zea",qTy)), + TP[Var("size1",CTy"Zsize"), + Var("dst_src",CTy"Zdest_src")]), + qVar"state"))),qVar"state")), + Mop(Fst, + Apply + (Call + ("ea_Zdest",ATy(qTy,PTy(CTy"Zea",qTy)), + TP[Var("size2",CTy"Zsize"), + Var("dst_src",CTy"Zdest_src")]),qVar"state"))]), + qVar"state"))) ; val dfn'Zmul_def = Def ("dfn'Zmul",TP[Var("size",CTy"Zsize"),Var("rm",CTy"Zrm")], @@ -2006,21 +1962,24 @@ val dfn'Zmul_def = Def Call ("Zea_r",CTy"Zea", TP[Var("size",CTy"Zsize"),LC("RAX",CTy"Zreg")]), - Let(TP[Var("v",F64),qVar"s"], - Apply - (Call("EA",ATy(qTy,PTy(F64,qTy)),Var("ea_eax",CTy"Zea")), - qVar"state"), - Let(TP[Var("v0",F64),qVar"s"], + Let(Var("v",F64), + Mop(Fst, Apply (Call - ("EA",ATy(qTy,PTy(F64,qTy)), - Mop(Fst, - Apply - (Call - ("ea_Zrm",ATy(qTy,PTy(CTy"Zea",qTy)), - TP[Var("size",CTy"Zsize"), - Var("rm",CTy"Zrm")]),qVar"s"))), - qVar"s"), + ("EA",ATy(qTy,PTy(F64,qTy)),Var("ea_eax",CTy"Zea")), + qVar"state")), + Let(Var("v0",F64), + Mop(Fst, + Apply + (Call + ("EA",ATy(qTy,PTy(F64,qTy)), + Mop(Fst, + Apply + (Call + ("ea_Zrm",ATy(qTy,PTy(CTy"Zea",qTy)), + TP[Var("size",CTy"Zsize"), + Var("rm",CTy"Zrm")]),qVar"state"))), + qVar"state")), Apply (Const("erase_eflags",ATy(qTy,PTy(uTy,qTy))), CS(Var("size",CTy"Zsize"), @@ -2034,7 +1993,7 @@ val dfn'Zmul_def = Def ("Zea_r",CTy"Zea", TP[Const("Z16",CTy"Zsize"), LC("RAX",CTy"Zreg")])]), - qVar"s"))), + qVar"state"))), (AVar(CTy"Zsize"), Mop(Snd, Apply @@ -2062,7 +2021,7 @@ val dfn'Zmul_def = Def TP[Bop(Mul,Var("v",F64), Var("v0",F64)), Var("ea_eax",CTy"Zea")]), - qVar"s")))))]))))))) + qVar"state")))))]))))))) ; val dfn'Znop_def = Def0 ("dfn'Znop",LU) ; @@ -2107,28 +2066,29 @@ val dfn'Zxadd_def = Def ("ea_Zrm",ATy(qTy,PTy(CTy"Zea",qTy)), TP[Var("size",CTy"Zsize"),Var("rm",CTy"Zrm")]), qVar"state")), - Let(TP[Var("v0",F64),qVar"s"], - Apply - (Call - ("EA",ATy(qTy,PTy(F64,qTy)),Var("ea_src",CTy"Zea")), - qVar"state"), - Let(TP[Var("v1",F64),qVar"s"], + Let(Var("v0",F64), + Mop(Fst, Apply (Call ("EA",ATy(qTy,PTy(F64,qTy)),Var("v",CTy"Zea")), - qVar"s"), - Apply - (Call - ("write_binop",ATy(qTy,PTy(uTy,qTy)), - TP[Var("size",CTy"Zsize"), - LC("Zadd",CTy"Zbinop_name"),Var("v0",F64), - Var("v1",F64),Var("v",CTy"Zea")]), - Mop(Snd, - Apply - (Call - ("write'EA",ATy(qTy,PTy(uTy,qTy)), - TP[Var("v1",F64),Var("ea_src",CTy"Zea")]), - qVar"s"))))))))) + qVar"state")), + Apply + (Call + ("write_binop",ATy(qTy,PTy(uTy,qTy)), + TP[Var("size",CTy"Zsize"), + LC("Zadd",CTy"Zbinop_name"), + Mop(Fst, + Apply + (Call + ("EA",ATy(qTy,PTy(F64,qTy)), + Var("ea_src",CTy"Zea")),qVar"state")), + Var("v0",F64),Var("v",CTy"Zea")]), + Mop(Snd, + Apply + (Call + ("write'EA",ATy(qTy,PTy(uTy,qTy)), + TP[Var("v0",F64),Var("ea_src",CTy"Zea")]), + qVar"state")))))))) ; val dfn'Zxchg_def = Def ("dfn'Zxchg", @@ -2146,35 +2106,32 @@ val dfn'Zxchg_def = Def ("ea_Zrm",ATy(qTy,PTy(CTy"Zea",qTy)), TP[Var("size",CTy"Zsize"),Var("rm",CTy"Zrm")]), qVar"state")), - Let(TP[Var("v0",F64),qVar"s"], - Apply - (Call - ("EA",ATy(qTy,PTy(F64,qTy)),Var("ea_src",CTy"Zea")), - qVar"state"), - Let(TP[Var("v1",F64),qVar"s"], - Apply - (Call - ("EA",ATy(qTy,PTy(F64,qTy)),Var("v",CTy"Zea")), - qVar"s"), - Apply - (Call - ("write'EA",ATy(qTy,PTy(uTy,qTy)), - TP[Var("v0",F64),Var("v",CTy"Zea")]), - Mop(Snd, - Apply - (Call - ("write'EA",ATy(qTy,PTy(uTy,qTy)), - TP[Var("v1",F64),Var("ea_src",CTy"Zea")]), - qVar"s"))))))))) + Apply + (Call + ("write'EA",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Fst, + Apply + (Call + ("EA",ATy(qTy,PTy(F64,qTy)), + Var("ea_src",CTy"Zea")),qVar"state")), + Var("v",CTy"Zea")]), + Mop(Snd, + Apply + (Call + ("write'EA",ATy(qTy,PTy(uTy,qTy)), + TP[Mop(Fst, + Apply + (Call + ("EA",ATy(qTy,PTy(F64,qTy)), + Var("v",CTy"Zea")),qVar"state")), + Var("ea_src",CTy"Zea")]),qVar"state"))))))) ; val Run_def = Def ("Run",Var("v0",CTy"instruction"), Close (qVar"state", CS(Var("v0",CTy"instruction"), - [(Const("Zcpuid",CTy"instruction"), - Apply(Const("dfn'Zcpuid",ATy(qTy,PTy(uTy,qTy))),qVar"state")), - (Const("Zleave",CTy"instruction"), + [(Const("Zleave",CTy"instruction"), Apply(Const("dfn'Zleave",ATy(qTy,PTy(uTy,qTy))),qVar"state")), (Const("Znop",CTy"instruction"), TP[Const("dfn'Znop",uTy),qVar"state"]), @@ -3694,27 +3651,6 @@ val x64_decode_def = Def bVar"b'0"])), Var("imm",F64)]), Var("strm3",LTy F8)]))), - (Bop(And,bVar"b'7", - Bop(And,Mop(Not,bVar"b'6"), - Bop(And,bVar"b'5", - Bop(And, - Mop(Not,bVar"b'4"), - Bop(And, - Mop(Not, - bVar"b'3"), - Bop(And, - Mop(Not, - bVar"b'2"), - Bop(And, - bVar"b'1", - Mop(Not, - bVar"b'0")))))))), - Call - ("Zfull_inst",CTy"Zinst", - TP[Var("p",LTy F8), - Const - ("Zcpuid",CTy"instruction"), - Var("strm2",LTy F8)])), (Bop(And,bVar"b'7", Bop(And,Mop(Not,bVar"b'6"), Bop(And,bVar"b'5", @@ -3895,58 +3831,25 @@ val x64_fetch_def = Def Close (Var("state",PTy(LTy F8,qTy)), TP[LU, - LLC([Mop(ValOf, - Apply - (Dest - ("MEM",ATy(F64,OTy F8), + LLC([Apply + (Dest + ("MEM",ATy(F64,F8), + Mop(Snd, + Var("state", + PTy(LTy F8,qTy)))), + Bop(Add, + Dest + ("RIP",F64, Mop(Snd, Var("state", PTy(LTy F8,qTy)))), - Bop(Add, - Dest - ("RIP",F64, - Mop(Snd, - Var("state", - PTy(LTy F8, - qTy)))), - Mop(Cast F64,nVar"i"))))], + Mop(Cast F64,nVar"i")))], Mop(Fst,Var("state",PTy(LTy F8,qTy)))), Mop(Snd,Var("state",PTy(LTy F8,qTy)))]))]), TP[LNL F8,qVar"state"])), TP[Mop(Fst,Var("s",PTy(LTy F8,qTy))),Var("s",PTy(LTy F8,qTy))]), TP[Var("r",LTy F8),Mop(Snd,Var("s1",PTy(LTy F8,qTy)))])) ; -val checkIcache_def = Def - ("checkIcache",nVar"n", - Close - (qVar"state", - Apply - (For(TP[LN 0,Bop(Sub,nVar"n",LN 1), - Close - (nVar"i", - Close - (qVar"state", - Let(Var("v",F64), - Bop(Add,Dest("RIP",F64,qVar"state"), - Mop(Cast F64,nVar"i")), - ITE(Mop(Not, - EQ(Apply - (Dest - ("MEM",ATy(F64,OTy F8), - qVar"state"),Var("v",F64)), - Apply - (Dest - ("ICACHE",ATy(F64,OTy F8), - qVar"state"),Var("v",F64)))), - Apply - (Call - ("raise'exception", - ATy(qTy,PTy(uTy,qTy)), - Call - ("FAILURE",CTy"exception", - LS"icache miss")),qVar"state"), - TP[LU,qVar"state"]))))]),qVar"state"))) -; val x64_next_def = Def ("x64_next",qVar"state", CS(Call @@ -3957,21 +3860,14 @@ val x64_next_def = Def [(Call ("Zfull_inst",CTy"Zinst", TP[AVar(LTy F8),Var("i",CTy"instruction"),Var("strm1",LTy F8)]), - Let(nVar"len",Bop(Sub,LN 20,Mop(Length,Var("strm1",LTy F8))), - Let(qVar"s", - Mop(Snd, - Apply - (Call("checkIcache",ATy(qTy,PTy(uTy,qTy)),nVar"len"), - qVar"state")), - Apply - (Call - ("Run",ATy(qTy,PTy(uTy,qTy)), - Var("i",CTy"instruction")), - Rupd - ("RIP", - TP[qVar"s", - Bop(Add,Dest("RIP",F64,qVar"s"), - Mop(Cast F64,nVar"len"))]))))), + Apply + (Call("Run",ATy(qTy,PTy(uTy,qTy)),Var("i",CTy"instruction")), + Rupd + ("RIP", + TP[qVar"state", + Bop(Add,Dest("RIP",F64,qVar"state"), + Mop(Cast F64, + Bop(Sub,LN 20,Mop(Length,Var("strm1",LTy F8)))))]))), (Call("Zdec_fail",CTy"Zinst",sVar"s0"), Apply (Call @@ -4396,7 +4292,6 @@ val encode_def = Def ("e_rm_reg",LTy F8, TP[Var("sz",CTy"Zsize"),Var("rm",CTy"Zrm"), Mop(Cast F4,Var("r",CTy"Zreg")),LL[LW(15,8)],LW(176,8)])), - (Const("Zcpuid",CTy"instruction"),LL[LW(15,8),LW(162,8)]), (Call ("Zdiv",CTy"instruction", TP[Var("sz",CTy"Zsize"),Var("rm",CTy"Zrm")]), diff --git a/examples/l3-machine-code/x64/prog/x64_progLib.sml b/examples/l3-machine-code/x64/prog/x64_progLib.sml index 4d5c602c5a..23ca4adc72 100644 --- a/examples/l3-machine-code/x64/prog/x64_progLib.sml +++ b/examples/l3-machine-code/x64/prog/x64_progLib.sml @@ -70,8 +70,7 @@ val state_id = ] val x64_frame = - stateLib.update_frame_state_thm x64_proj_def - ["RIP", "REG", "MEM", "ICACHE", "EFLAGS"] + stateLib.update_frame_state_thm x64_proj_def ["RIP", "REG", "MEM", "EFLAGS"] (* -- *) @@ -90,15 +89,7 @@ local case Lib.total boolSyntax.dest_eq tm of SOME (l, r) => stateLib.is_code_access ("x64$x64_state_MEM", v) l andalso - (case Lib.total optionSyntax.dest_some r of - SOME w => is_opc_byte w - | NONE => false) - | NONE => false - fun is_icache_access v tm = - case Lib.total boolSyntax.dest_eq tm of - SOME (l, r) => - stateLib.is_code_access ("x64$x64_state_ICACHE", v) l andalso - stateLib.is_code_access ("x64$x64_state_MEM", v) r + is_opc_byte r | NONE => false in fun mk_x64_code_pool thm = @@ -109,9 +100,6 @@ in val rip_subst = Term.subst [``s.RIP`` |-> rip] val a = List.map rip_subst a val (m, a) = List.partition (is_mem_access rip) a - val (i, a) = List.partition (is_icache_access rip) a - val _ = List.length m = List.length i orelse - raise ERR "mk_x64_code_pool" "icache mismatch" val m = List.map dest_code_access m val m = mlibUseful.sort_map fst Int.compare m in @@ -168,9 +156,9 @@ in end val x64_extras = - [((``x64_mem16 v``, ``read_mem16 s.MEM v``), I, optionSyntax.mk_some), - ((``x64_mem32 v``, ``read_mem32 s.MEM v``), I, optionSyntax.mk_some), - ((``x64_mem64 v``, ``read_mem64 s.MEM v``), I, optionSyntax.mk_some)] + [((``x64_mem16 v``, ``read_mem16 s.MEM v``), I, I), + ((``x64_mem32 v``, ``read_mem32 s.MEM v``), I, I), + ((``x64_mem64 v``, ``read_mem64 s.MEM v``), I, I)] : footprint_extra list val x64_mk_pre_post = @@ -223,10 +211,7 @@ end (* ------------------------------------------------------------------------ *) local - val component_11 = - case Drule.CONJUNCTS x64_progTheory.x64_component_11 of - [r, m, _, e] => [r, m, e] - | _ => raise ERR "component_11" "" + val component_11 = Drule.CONJUNCTS x64_progTheory.x64_component_11 val x64_rwts = Thm.INST_TYPE [Type.alpha |-> ``:Zreg``] boolTheory.COND_RATOR :: List.drop (utilsLib.datatype_rewrites true "x64" ["x64_state"], 1) @@ -288,6 +273,8 @@ val thms = x64_spec_code mov r15, [rdi-0xF0] ; 4c 8b bf 10 ff ff ff mov ecx, [rsi+rax*4+0x4] ; 8b 4c 86 04` +x64AssemblerLib.print_x64_code `mov [rsp+rax], ax` + x64AssemblerLib.print_x64_disassemble `48C3 440F42C1 @@ -331,12 +318,15 @@ val () = val next_def = x64_stepTheory.NextStateX64_def val instr_def = x64_instr_def val proj_def = x64_proj_def +val model_def = x64_progTheory.X64_MODEL_def val comp_defs = x64_comp_defs val cpool = mk_x64_code_pool val extras = x64_extras +val write_fn = x64_write_footprint val q = [] : term list val imp_spec = X64_IMP_SPEC +val imp_temp = x64_progTheory.X64_IMP_TEMPORAL val read_thms = [x64_stepTheory.read_mem16, x64_stepTheory.read_mem32, x64_stepTheory.read_mem64, combinTheory.I_THM] diff --git a/examples/l3-machine-code/x64/prog/x64_progScript.sml b/examples/l3-machine-code/x64/prog/x64_progScript.sml index d5ca3db3fb..4ba3821f60 100644 --- a/examples/l3-machine-code/x64/prog/x64_progScript.sml +++ b/examples/l3-machine-code/x64/prog/x64_progScript.sml @@ -13,13 +13,9 @@ val _ = stateLib.sep_definitions "x64" [] [] x64_stepTheory.NextStateX64_def val x64_mem_def = Define` x64_mem a (l: word8 list) = set (GENLIST (\i. (x64_c_MEM (a + n2w i), - x64_d_word8_option (SOME (EL i l)))) (LENGTH l))` + x64_d_word8 (EL i l))) (LENGTH l))` -val x64_instr_def = Define` - x64_instr (a, i) = - x64_mem a i UNION - set (GENLIST (\x. (x64_c_ICACHE (a + n2w x), - x64_d_word8_option (SOME (EL x i)))) (LENGTH i))` +val x64_instr_def = Define`x64_instr (a, i) = x64_mem a i` val x64_mem16_def = Define` x64_mem16 a (v: word16) = { x64_mem a [(7 >< 0) v; (15 >< 8) v] }` @@ -63,8 +59,7 @@ val x64_MEMORY_def = Define` x64_MEMORY dmem mem = { BIGUNION { BIGUNION (x64_mem64 a (mem a)) | a IN dmem /\ (a && 7w = 0w)} }` -val x64_PC_def = Define` - x64_PC pc = x64_RIP pc * x64_exception NoException` +val x64_PC_def = Define `x64_PC pc = x64_RIP pc * x64_exception NoException` val x64_ALL_EFLAGS_def = Define ` x64_ALL_EFLAGS = @@ -82,7 +77,7 @@ val thm = (stateTheory.MAPPED_COMPONENT_INSERT |> Q.ISPECL [`\a:word64. a && 7w = 0w`, `8`, `\a i. x64_c_MEM (a + n2w i)`, - `\v:word64 i. x64_d_word8_option (SOME (EL i ^v8))`, `x64_mem64`, + `\v:word64 i. x64_d_word8 (EL i ^v8)`, `x64_mem64`, `x64_MEMORY`] |> Conv.CONV_RULE (Conv.LAND_CONV (SIMP_CONV std_ss []))) (REWRITE_RULE [x64_mem_def, EVAL ``LENGTH [a; b; c; d; e; f; g; h]``] diff --git a/examples/l3-machine-code/x64/step/x64_stepLib.sml b/examples/l3-machine-code/x64/step/x64_stepLib.sml index e415494ef5..9c435f916a 100644 --- a/examples/l3-machine-code/x64/step/x64_stepLib.sml +++ b/examples/l3-machine-code/x64/step/x64_stepLib.sml @@ -142,14 +142,15 @@ end (* ------------------------------------------------------------------------ *) val mem8_rwt = - EV [mem8_def] [[``^st.MEM a = SOME v``]] [] + EV [mem8_def] [[``^st.MEM a = v``]] [] ``mem8 a`` |> hd val write'mem8_rwt = - EV [write'mem8_def] [[``^st.MEM addr = SOME wv``]] [] + EV [write'mem8_def] [] [] ``write'mem8 (d, addr)`` |> hd + |> Drule.ADD_ASSUM ``^st.MEM addr = wv`` (* ------------------------------------------------------------------------ *) @@ -482,11 +483,6 @@ val Zcall_rm_rwts = |> data_hyp_rule |> addThms -val Zcpuid_rwts = - EV [dfn'Zcpuid_def] [] [] - ``dfn'Zcpuid`` - |> addThms - val Zjcc_rwts = EV ([dfn'Zjcc_def, unit_state_cond] @ read_cond_rwts) [] (mapl (`c`, conds)) @@ -629,11 +625,11 @@ local (fn (b, (i, thm)) => let val rwt = if i = 0 - then ``^st.MEM (^st.RIP) = SOME ^b`` + then ``^st.MEM (^st.RIP) = ^b`` else let val j = numSyntax.term_of_int i in - ``^st.MEM (^st.RIP + n2w ^j) = SOME ^b`` + ``^st.MEM (^st.RIP + n2w ^j) = ^b`` end in (i + 1, PURE_REWRITE_RULE [ASSUME rwt, optionTheory.THE_DEF] thm) @@ -677,7 +673,7 @@ in (case listSyntax.dest_list l of ([], _) => thm | (h :: _, _) => - (optionSyntax.is_the h + (not (wordsSyntax.is_n2w h) orelse raise decode_err "trailing bytes"; thm)) | _ => raise decode_err "decode failed") | _ => (Parse.print_thm thm; raise decode_err "too few bytes") @@ -685,36 +681,11 @@ in val x64_decode_hex = x64_decode o get_bytes end -local - val Icache_CONV = - x64_CONV - THENC REWRITE_CONV - (wordsTheory.WORD_ADD_0 :: - List.tabulate - (20, fn 0 => ASSUME ``^st.ICACHE (^st.RIP) = ^st.MEM (^st.RIP)`` - | i => let - val j = numSyntax.term_of_int i - in - ASSUME ``^st.ICACHE (^st.RIP + n2w ^j) = - ^st.MEM (^st.RIP + n2w ^j)`` - end)) -in - val checkIcache_rwts = - List.tabulate - (20, fn i => let - val j = numSyntax.term_of_int (i + 1) - in - utilsLib.NCONV (i + 1) Icache_CONV - ``checkIcache ^j s`` - end) -end - (* ------------------------------------------------------------------------ *) local fun is_some_wv tm = ((tm |> boolSyntax.dest_eq |> snd - |> optionSyntax.dest_some |> Term.dest_var |> fst) = "wv") handle HOL_ERR _ => false in @@ -723,11 +694,9 @@ in ([], _) => thm | ([t], rst) => let - val (l, r) = boolSyntax.dest_eq t - val wv = optionSyntax.dest_some r + val (l, wv) = boolSyntax.dest_eq t val v = Term.mk_var ("v", Term.type_of wv) - val sv = optionSyntax.mk_some v - val tv = boolSyntax.mk_eq (l, sv) + val tv = boolSyntax.mk_eq (l, v) in if List.exists (Lib.equal tv) rst then Thm.INST [wv |-> v] thm @@ -749,17 +718,9 @@ local Term.prim_mk_const {Thy = "x64", Name = "x64_state_exception"} fun mk_proj_exception r = Term.mk_comb (state_exception_tm, r) val twenty = numSyntax.term_of_int 20 - fun mk_len_icache_thms thm1 = - let - val strm1 = get_strm1 thm1 - val len_thm = - (Conv.RAND_CONV listLib.LENGTH_CONV THENC numLib.REDUCE_CONV) - (numSyntax.mk_minus (twenty, listSyntax.mk_length strm1)) - val len = utilsLib.rhsc len_thm - val n = numSyntax.int_of_term len - in - (len_thm, List.nth (checkIcache_rwts, n - 1), len) - end + fun mk_len_thm thm1 = + (Conv.RAND_CONV listLib.LENGTH_CONV THENC numLib.REDUCE_CONV) + (numSyntax.mk_minus (twenty, listSyntax.mk_length (get_strm1 thm1))) fun bump_rip len = Term.subst [st |-> ``^st with RIP := ^st.RIP + n2w ^len``] val run_CONV = utilsLib.Run_CONV ("x64", st) o get_ast val run = utilsLib.ALL_HYP_CONV_RULE utilsLib.WGROUND_CONV o @@ -774,7 +735,6 @@ local raise ERR "x64_step" ("Failed to evaluate: " ^ Hol_pp.term_to_string (listSyntax.mk_list (l, ``:word8``))) - val cache = ref (Redblackmap.mkDict String.compare: (string, thm) Redblackmap.dict) fun addToCache (s, thm) = (cache := Redblackmap.insert (!cache, s, thm); thm) @@ -783,11 +743,11 @@ in fun x64_step l = let val thm1 = x64_decode l - val (thm2, thm3, len) = mk_len_icache_thms thm1 + val thm2 = mk_len_thm thm1 val thm4 = run_CONV thm1 val thm5 = (thm4 |> Drule.SPEC_ALL |> utilsLib.rhsc - |> bump_rip len + |> bump_rip (utilsLib.rhsc thm2) |> run) handle Conv.UNCHANGED => unchanged l val r = get_state thm5 @@ -796,7 +756,7 @@ in ; print "\n" ; raise ERR "eval" "failed to fully evaluate") val thm6 = STATE_CONV (mk_proj_exception r) - val thm = Drule.LIST_CONJ [thm1, thm2, thm3, thm4, thm5, thm6] + val thm = Drule.LIST_CONJ [thm1, thm2, thm4, thm5, thm6] in MP_Next thm handle HOL_ERR {message = "different constructors", ...} => @@ -832,22 +792,22 @@ val thms = Count.apply x64_step_code movsx eax, al ; 0f be c0 movzx eax, al ; 0f b6 c0` -Count.apply x64_step "90"; -Count.apply x64_step "418803"; -Count.apply x64_step "487207"; -Count.apply x64_step "8345F801"; -Count.apply x64_step "4863D0"; -Count.apply x64_step "0FBEC0"; -Count.apply x64_step "0FB6C0"; +Count.apply x64_step_hex "90"; +Count.apply x64_step_hex "418803"; +Count.apply x64_step_hex "487207"; +Count.apply x64_step_hex "8345F801"; +Count.apply x64_step_hex "4863D0"; +Count.apply x64_step_hex "0FBEC0"; +Count.apply x64_step_hex "0FB6C0"; -Count.apply x64_step "48BA________________"; -Count.apply x64_decode "48BA________________" +Count.apply x64_step_hex "48BA________________"; +Count.apply x64_decode_hex "48BA________________" -Count.apply x64_step "41B8________"; -Count.apply x64_decode "41B8________" +Count.apply x64_step_hex "41B8________"; +Count.apply x64_decode_hex "41B8________" -Count.apply x64_decode "8345F8__"; -Count.apply x64_step "8345F8__" +Count.apply x64_decode_hex "8345F8__"; +Count.apply x64_step_hex "8345F8__" *) diff --git a/examples/l3-machine-code/x64/step/x64_stepScript.sml b/examples/l3-machine-code/x64/step/x64_stepScript.sml index 1047903e7f..eaedeeec38 100644 --- a/examples/l3-machine-code/x64/step/x64_stepScript.sml +++ b/examples/l3-machine-code/x64/step/x64_stepScript.sml @@ -30,7 +30,6 @@ val NextStateX64_0 = utilsLib.ustore_thm("NextStateX64_0", `(s.exception = NoException) ==> (x64_decode (FST (x64_fetch s)) = Zfull_inst (p, ast, strm1)) /\ (20 - LENGTH strm1 = len) /\ - (checkIcache len s = ((), s)) /\ (!s. Run ast s = f s) /\ (f (s with RIP := s.RIP + n2w len) = ((), s1)) /\ (s1.exception = s.exception) ==> @@ -41,7 +40,6 @@ val NextStateX64 = utilsLib.ustore_thm("NextStateX64", `(s.exception = NoException) ==> (x64_decode (FST (x64_fetch s)) = Zfull_inst (p, ast, strm1)) /\ (20 - LENGTH strm1 = len) /\ - (checkIcache len s = ((), s)) /\ (!s. Run ast s = f x s) /\ (f x (s with RIP := s.RIP + n2w len) = ((), s1)) /\ (s1.exception = s.exception) ==> @@ -51,120 +49,83 @@ val NextStateX64 = utilsLib.ustore_thm("NextStateX64", (* ------------------------------------------------------------------------ *) val read_mem16_def = Lib.with_flag (Feedback.emit_MESG, false) Define` - read_mem16 (m: word64 -> word8 option) a = - case (m a, m (a + 1w)) of - (SOME v1, SOME v2) => SOME (v2 @@ v1) - | _ => NONE`; + read_mem16 (m: word64 -> word8) a = m (a + 1w) @@ m a` val read_mem32_def = Lib.with_flag (Feedback.emit_MESG, false) Define` - read_mem32 (m: word64 -> word8 option) a = - case (m a, m (a + 1w), m (a + 2w), m (a + 3w)) of - (SOME v1, SOME v2, SOME v3, SOME v4) => SOME (v4 @@ v3 @@ v2 @@ v1) - | _ => NONE`; + read_mem32 (m: word64 -> word8) a = + m (a + 3w) @@ m (a + 2w) @@ m (a + 1w) @@ m a` val read_mem64_def = Lib.with_flag (Feedback.emit_MESG, false) Define` - read_mem64 (m: word64 -> word8 option) a = - case (m a, m (a + 1w), m (a + 2w), m (a + 3w), - m (a + 4w), m (a + 5w), m (a + 6w), m (a + 7w)) of - (SOME v1, SOME v2, SOME v3, SOME v4, - SOME v5, SOME v6, SOME v7, SOME v8) => - SOME (v8 @@ v7 @@ v6 @@ v5 @@ v4 @@ v3 @@ v2 @@ v1) - | _ => NONE`; + read_mem64 (m: word64 -> word8) a = + m (a + 7w) @@ m (a + 6w) @@ m (a + 5w) @@ m (a + 4w) @@ + m (a + 3w) @@ m (a + 2w) @@ m (a + 1w) @@ m a` val write_mem16_def = Define` - write_mem16 (m: word64 -> word8 option) a (v: word16) = - (a + 1w =+ SOME ((15 >< 8) v)) - ((a =+ SOME ((7 >< 0) v)) m)`; + write_mem16 (m: word64 -> word8) a (v: word16) = + (a + 1w =+ (15 >< 8) v) + ((a =+ (7 >< 0) v) m)`; val write_mem32_def = Define` - write_mem32 (m: word64 -> word8 option) a (v: word32) = - (a + 3w =+ SOME ((31 >< 24) v)) - ((a + 2w =+ SOME ((23 >< 16) v)) - ((a + 1w =+ SOME ((15 >< 8) v)) - ((a =+ SOME ((7 >< 0) v)) m)))`; + write_mem32 (m: word64 -> word8) a (v: word32) = + (a + 3w =+ (31 >< 24) v) + ((a + 2w =+ (23 >< 16) v) + ((a + 1w =+ (15 >< 8) v) + ((a =+ (7 >< 0) v) m)))`; val write_mem64_def = Define` - write_mem64 (m: word64 -> word8 option) a (v: word64) = - (a + 7w =+ SOME ((63 >< 56) v)) - ((a + 6w =+ SOME ((55 >< 48) v)) - ((a + 5w =+ SOME ((47 >< 40) v)) - ((a + 4w =+ SOME ((39 >< 32) v)) - ((a + 3w =+ SOME ((31 >< 24) v)) - ((a + 2w =+ SOME ((23 >< 16) v)) - ((a + 1w =+ SOME ((15 >< 8) v)) - ((a =+ SOME ((7 >< 0) v)) m)))))))`; + write_mem64 (m: word64 -> word8) a (v: word64) = + (a + 7w =+ (63 >< 56) v) + ((a + 6w =+ (55 >< 48) v) + ((a + 5w =+ (47 >< 40) v) + ((a + 4w =+ (39 >< 32) v) + ((a + 3w =+ (31 >< 24) v) + ((a + 2w =+ (23 >< 16) v) + ((a + 1w =+ (15 >< 8) v) + ((a =+ (7 >< 0) v) m)))))))`; val mem16_rwt = ustore_thm("mem16_rwt", - `(read_mem16 s.MEM a = SOME v) ==> (mem16 a s = (v, s))`, - Cases_on `s.MEM a` - \\ Cases_on `s.MEM (a + 1w)` - \\ simp [mem16_def, mem8_def, read_mem16_def] + `(read_mem16 s.MEM a = v) ==> (mem16 a s = (v, s))`, + simp [mem16_def, mem8_def, read_mem16_def] ) val mem32_rwt = ustore_thm("mem32_rwt", - `(read_mem32 s.MEM a = SOME v) ==> (mem32 a s = (v, s))`, - Cases_on `s.MEM a` - \\ Cases_on `s.MEM (a + 1w)` - \\ Cases_on `s.MEM (a + 2w)` - \\ Cases_on `s.MEM (a + 3w)` - \\ simp [mem32_def, mem16_def, mem8_def, read_mem32_def] + `(read_mem32 s.MEM a = v) ==> (mem32 a s = (v, s))`, + simp [mem32_def, mem16_def, mem8_def, read_mem32_def] \\ blastLib.BBLAST_TAC ) val mem64_rwt = ustore_thm("mem64_rwt", - `(read_mem64 s.MEM a = SOME v) ==> (mem64 a s = (v, s))`, - Cases_on `s.MEM a` - \\ Cases_on `s.MEM (a + 1w)` - \\ Cases_on `s.MEM (a + 2w)` - \\ Cases_on `s.MEM (a + 3w)` - \\ Cases_on `s.MEM (a + 4w)` - \\ Cases_on `s.MEM (a + 5w)` - \\ Cases_on `s.MEM (a + 6w)` - \\ Cases_on `s.MEM (a + 7w)` - \\ simp [mem64_def, mem32_def, mem16_def, mem8_def, read_mem64_def] + `(read_mem64 s.MEM a = v) ==> (mem64 a s = (v, s))`, + simp [mem64_def, mem32_def, mem16_def, mem8_def, read_mem64_def] \\ blastLib.BBLAST_TAC ) val write'mem16_rwt = ustore_thm("write'mem16_rwt", - `(read_mem16 s.MEM a = SOME wv) ==> + `(read_mem16 s.MEM a = wv) ==> (write'mem16 (d, a) s = ((), s with MEM := write_mem16 s.MEM a d))`, - Cases_on `s.MEM a` - \\ Cases_on `s.MEM (a + 1w)` - \\ simp [combinTheory.APPLY_UPDATE_THM, - blastLib.BBLAST_PROVE ``a <> a + 1w: word64``, - write'mem16_def, write'mem8_def, write_mem16_def, read_mem16_def] + simp [combinTheory.APPLY_UPDATE_THM, + blastLib.BBLAST_PROVE ``a <> a + 1w: word64``, + write'mem16_def, write'mem8_def, write_mem16_def, read_mem16_def] ) val write'mem32_rwt = ustore_thm("write'mem32_rwt", - `(read_mem32 s.MEM a = SOME wv) ==> + `(read_mem32 s.MEM a = wv) ==> (write'mem32 (d, a) s = ((), s with MEM := write_mem32 s.MEM a d))`, - Cases_on `s.MEM a` - \\ Cases_on `s.MEM (a + 1w)` - \\ Cases_on `s.MEM (a + 2w)` - \\ Cases_on `s.MEM (a + 3w)` - \\ simp [combinTheory.APPLY_UPDATE_THM, - blastLib.BBLAST_PROVE ``a <> a + 1w: word64``, - blastLib.BBLAST_PROVE ``a <> a + 2w: word64``, - blastLib.BBLAST_PROVE ``a <> a + 3w: word64``, - write'mem32_def, write'mem16_def, write'mem8_def, - write_mem32_def, read_mem32_def] + simp [combinTheory.APPLY_UPDATE_THM, + blastLib.BBLAST_PROVE ``a <> a + 1w: word64``, + blastLib.BBLAST_PROVE ``a <> a + 2w: word64``, + blastLib.BBLAST_PROVE ``a <> a + 3w: word64``, + write'mem32_def, write'mem16_def, write'mem8_def, + write_mem32_def, read_mem32_def] \\ srw_tac [wordsLib.WORD_EXTRACT_ss] [] ) val write'mem64_rwt = ustore_thm("write'mem64_rwt", - `(read_mem64 s.MEM a = SOME wv) ==> + `(read_mem64 s.MEM a = wv) ==> (write'mem64 (d, a) s = ((), s with MEM := write_mem64 s.MEM a d))`, simp [write'mem64_def, write'mem32_def, write'mem16_def, write_mem64_def, read_mem64_def] \\ simp_tac (srw_ss()++wordsLib.WORD_EXTRACT_ss) [] - \\ Cases_on `s.MEM a` - \\ Cases_on `s.MEM (a + 1w)` - \\ Cases_on `s.MEM (a + 2w)` - \\ Cases_on `s.MEM (a + 3w)` - \\ Cases_on `s.MEM (a + 4w)` - \\ Cases_on `s.MEM (a + 5w)` - \\ Cases_on `s.MEM (a + 6w)` - \\ Cases_on `s.MEM (a + 7w)` \\ ASM_REWRITE_TAC [optionTheory.NOT_NONE_SOME, optionTheory.option_case_def] \\ simp [combinTheory.APPLY_UPDATE_THM, blastLib.BBLAST_PROVE ``a <> a + 1w: word64``, @@ -178,53 +139,37 @@ val write'mem64_rwt = ustore_thm("write'mem64_rwt", ) val read_mem16 = Q.store_thm("read_mem16", - `!m a v. - (read_mem16 m a = SOME v) = - (m a = SOME ((7 >< 0) v)) /\ - (m (a + 1w) = SOME ((15 >< 8) v))`, + `!m a v. (read_mem16 m a = v) = + (m a = (7 >< 0) v) /\ (m (a + 1w) = (15 >< 8) v)`, REPEAT strip_tac - \\ Cases_on `m a` - \\ Cases_on `m (a + 1w)` \\ simp [read_mem16_def] \\ blastLib.BBLAST_TAC ) val read_mem32 = Q.store_thm("read_mem32", `!m a v. - (read_mem32 m a = SOME v) = - (m a = SOME ((7 >< 0) v)) /\ - (m (a + 1w) = SOME ((15 >< 8) v)) /\ - (m (a + 2w) = SOME ((23 >< 16) v)) /\ - (m (a + 3w) = SOME ((31 >< 24) v))`, + (read_mem32 m a = v) = + (m a = (7 >< 0) v) /\ + (m (a + 1w) = (15 >< 8) v) /\ + (m (a + 2w) = (23 >< 16) v) /\ + (m (a + 3w) = (31 >< 24) v)`, REPEAT strip_tac - \\ Cases_on `m a` - \\ Cases_on `m (a + 1w)` - \\ Cases_on `m (a + 2w)` - \\ Cases_on `m (a + 3w)` \\ simp [read_mem32_def] \\ blastLib.BBLAST_TAC ) val read_mem64 = Q.store_thm("read_mem64", `!m a v. - (read_mem64 m a = SOME v) = - (m a = SOME ((7 >< 0) v)) /\ - (m (a + 1w) = SOME ((15 >< 8) v)) /\ - (m (a + 2w) = SOME ((23 >< 16) v)) /\ - (m (a + 3w) = SOME ((31 >< 24) v)) /\ - (m (a + 4w) = SOME ((39 >< 32) v)) /\ - (m (a + 5w) = SOME ((47 >< 40) v)) /\ - (m (a + 6w) = SOME ((55 >< 48) v)) /\ - (m (a + 7w) = SOME ((63 >< 56) v))`, + (read_mem64 m a = v) = + (m a = (7 >< 0) v) /\ + (m (a + 1w) = (15 >< 8) v) /\ + (m (a + 2w) = (23 >< 16) v) /\ + (m (a + 3w) = (31 >< 24) v) /\ + (m (a + 4w) = (39 >< 32) v) /\ + (m (a + 5w) = (47 >< 40) v) /\ + (m (a + 6w) = (55 >< 48) v) /\ + (m (a + 7w) = (63 >< 56) v)`, REPEAT strip_tac - \\ Cases_on `m a` - \\ Cases_on `m (a + 1w)` - \\ Cases_on `m (a + 2w)` - \\ Cases_on `m (a + 3w)` - \\ Cases_on `m (a + 4w)` - \\ Cases_on `m (a + 5w)` - \\ Cases_on `m (a + 6w)` - \\ Cases_on `m (a + 7w)` \\ simp [read_mem64_def] \\ blastLib.BBLAST_TAC ) From f37ce4586a14f738f2d9d75a4ce131acca679c0f Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 17 Jun 2015 09:04:46 +1000 Subject: [PATCH 341/718] New theorem about ordinal arithmetic MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit That: α + β = β ⇔ α * ω ≤ β (A homework exercise.) --- .../set-theory/hol_sets/ordinalScript.sml | 28 +++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/examples/set-theory/hol_sets/ordinalScript.sml b/examples/set-theory/hol_sets/ordinalScript.sml index 3ff3c94d8b..92f652b69d 100644 --- a/examples/set-theory/hol_sets/ordinalScript.sml +++ b/examples/set-theory/hol_sets/ordinalScript.sml @@ -1806,6 +1806,34 @@ val expbound_add = store_thm( `y < ω ** b` by metis_tac [ordlte_TRANS] >> metis_tac[]) +val downduct = prove( + ``(∀n. n ≤ m ∧ P (SUC n) ⇒ P n) ∧ P m ⇒ + (∀n. n ≤ m ⇒ P n)``, + strip_tac >> fs[arithmeticTheory.LESS_EQ_EXISTS] >> + full_simp_tac (srw_ss() ++ DNF_ss) [] >> CONV_TAC SWAP_FORALL_CONV >> + Induct >> rw[] >> simp[]); + +val addL_fixpoint_iff = store_thm( + "addL_fixpoint_iff", + ``α + β = β ⇔ α * ω ≤ β``, + eq_tac + >- (simp[omega_islimit, ordMULT_def, EQ_IMP_THM, sup_thm, IMAGE_cardleq_rwt, + preds_inj_univ, lt_omega] >> strip_tac >> + qx_gen_tac `γ` >> Cases_on `β < γ` >> simp[] >> + qx_gen_tac `δ` >> Cases_on `γ = α * δ` >> simp[] >> qx_gen_tac `m` >> + strip_tac >> rw[] >> + `∀n. n ≤ m ⇒ β < α * &n` suffices_by + (disch_then (qspec_then `0` mp_tac) >> simp[]) >> + ho_match_mp_tac downduct >> simp[] >> + qx_gen_tac `n`>> + `α * &n + α = α + α * &n` suffices_by metis_tac[ordlt_CANCEL] >> + Induct_on `n` >> simp[] >> metis_tac[ordADD_ASSOC]) + >- (simp[ordle_EXISTS_ADD] >> + disch_then (qx_choose_then `c` SUBST_ALL_TAC) >> + simp[ordADD_ASSOC] >> + `α + α * ω = α * (1 + ω)` by simp[ordMULT_LDISTRIB] >> + simp[ordADD_fromNat_omega, omega_islimit])) + (* And so, arithmetic (addition, multiplication and exponentiation) is closed under ε₀ *) val ordADD_under_epsilon0 = store_thm( From 1403e15777f962564136dae7b9be65b23ca3c339 Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Wed, 17 Jun 2015 12:02:39 +0100 Subject: [PATCH 342/718] Add a theorem about fun2set. --- examples/machine-code/hoare-triple/set_sepScript.sml | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/examples/machine-code/hoare-triple/set_sepScript.sml b/examples/machine-code/hoare-triple/set_sepScript.sml index b3b9ed81ca..de18eab276 100644 --- a/examples/machine-code/hoare-triple/set_sepScript.sml +++ b/examples/machine-code/hoare-triple/set_sepScript.sml @@ -191,6 +191,18 @@ val write_fun2set = store_thm("write_fun2set", \\ Cases_on `q = a` \\ ASM_SIMP_TAC std_ss [combinTheory.APPLY_UPDATE_THM] \\ METIS_TAC []); +val fun2set_eq = Q.store_thm("fun2set_eq", + `!f g d. (fun2set (f, d) = fun2set (g, d)) = (!a. a IN d ==> (f a = g a))`, + SRW_TAC [] [FUN_EQ_THM] + \\ EQ_TAC + \\ REPEAT STRIP_TAC + THENL [ + Q.PAT_ASSUM `!x. P` (Q.SPEC_THEN `(a, f a)` ASSUME_TAC), + Cases_on `x` \\ Cases_on `q IN d` + ] + \\ REV_FULL_SIMP_TAC std_ss [fun2set_thm] + ) + val one_fun2set = store_thm("one_fun2set", ``!a x p f. (one (a,x) * p) (fun2set (f,d)) = (f a = x) /\ a IN d /\ p (fun2set (f,d DELETE a))``, From 51799312e7f4ef726f56473907bb763d69e2d9b2 Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Wed, 17 Jun 2015 12:03:10 +0100 Subject: [PATCH 343/718] Fix problem with ARMv8 decompilation. --- examples/l3-machine-code/arm8/decompiler/arm8_decompLib.sml | 4 ++++ examples/l3-machine-code/arm8/prog/arm8_progLib.sml | 2 +- 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/examples/l3-machine-code/arm8/decompiler/arm8_decompLib.sml b/examples/l3-machine-code/arm8/decompiler/arm8_decompLib.sml index f32e416cf3..b5889f6f46 100644 --- a/examples/l3-machine-code/arm8/decompiler/arm8_decompLib.sml +++ b/examples/l3-machine-code/arm8/decompiler/arm8_decompLib.sml @@ -86,6 +86,10 @@ val (test_cert, test_def) = arm8_decompile_code_no_status "test" add x2, x3, x4 str x2, [x1, #8]! ` +val (ex_cert, ex_def) = arm8_decompLib.arm8_decompile_code "ex" + `loop: mul x1, x1, x2 + subs x0, x0, #1 + b.ne loop` *) diff --git a/examples/l3-machine-code/arm8/prog/arm8_progLib.sml b/examples/l3-machine-code/arm8/prog/arm8_progLib.sml index fdc322994f..8bb09735fc 100644 --- a/examples/l3-machine-code/arm8/prog/arm8_progLib.sml +++ b/examples/l3-machine-code/arm8/prog/arm8_progLib.sml @@ -454,7 +454,7 @@ local CONJUNCT1 arm8_stepTheory.Aligned, optionTheory.NOT_NONE_SOME] THENC NOT_F_CONV) - THENC helperLib.POST_CONV (stateLib.PC_CONV "arm8_prog$arm_PC") + THENC helperLib.POST_CONV (stateLib.PC_CONV "arm8_prog$arm8_pc") in fun simp_triple_rule thm = arm_rename (DecodeBitMasks_RULE (Conv.CONV_RULE cnv thm)) From 06cb4d723102aa658f9f704941d36fc1ce878d1b Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Thu, 18 Jun 2015 11:10:55 +1000 Subject: [PATCH 344/718] clearer shorter proof of sortingTheory.PERM_TC --- src/sort/sortingScript.sml | 118 +++++++++++++++++-------------------- 1 file changed, 53 insertions(+), 65 deletions(-) diff --git a/src/sort/sortingScript.sml b/src/sort/sortingScript.sml index 05f83ccd2a..1e7698d622 100644 --- a/src/sort/sortingScript.sml +++ b/src/sort/sortingScript.sml @@ -618,77 +618,65 @@ val PERM_APPEND_IFF = store_thm ("PERM_APPEND_IFF", val PERM_SINGLE_SWAP_DEF = Define `PERM_SINGLE_SWAP l1 l2 = ?x1 x2 x3. (l1 = x1 ++ x2 ++ x3) /\ (l2 = x1 ++ x3 ++ x2)`; - -val PERM_SINGLE_SWAP_REFL = store_thm ("PERM_SINGLE_SWAP_REFL", -``!l. PERM_SINGLE_SWAP l l``, - GEN_TAC THEN REWRITE_TAC [PERM_SINGLE_SWAP_DEF] THEN - Q.EXISTS_TAC `l` THEN Q.EXISTS_TAC `[]` THEN Q.EXISTS_TAC `[]` THEN - REWRITE_TAC[APPEND_NIL]); - val PERM_SINGLE_SWAP_SYM = store_thm ("PERM_SINGLE_SWAP_SYM", ``!l1 l2. PERM_SINGLE_SWAP l1 l2 = PERM_SINGLE_SWAP l2 l1``, PROVE_TAC[PERM_SINGLE_SWAP_DEF]); +val PERM_SINGLE_SWAP_I = Q.store_thm ("PERM_SINGLE_SWAP_I", + `PERM_SINGLE_SWAP (x1 ++ x2 ++ x3) (x1 ++ x3 ++ x2)`, + PROVE_TAC [PERM_SINGLE_SWAP_DEF]) ; + +val PERM_SINGLE_SWAP_APPEND = save_thm ("PERM_SINGLE_SWAP_APPEND", + REWRITE_RULE [APPEND] (Q.INST [`x1` |-> `NIL`] PERM_SINGLE_SWAP_I)) ; + +val PERM_SINGLE_SWAP_REFL = save_thm ("PERM_SINGLE_SWAP_REFL", + GEN_ALL (REWRITE_RULE [APPEND, APPEND_NIL] + (Q.INST [`x2` |-> `NIL`, `x3` |-> `l`] PERM_SINGLE_SWAP_APPEND))) ; + +val [_, TC_TRANS] = CONJUNCTS (SPEC_ALL TC_RULES) ; + +val PERM_SINGLE_SWAP_CONS = Q.store_thm ("PERM_SINGLE_SWAP_CONS", + `PERM_SINGLE_SWAP M N ==> PERM_SINGLE_SWAP (x :: M) (x :: N)`, + SIMP_TAC list_ss [PERM_SINGLE_SWAP_DEF] >> REPEAT STRIP_TAC >> + Q.EXISTS_TAC `x :: x1` >> Q.EXISTS_TAC `x2` >> Q.EXISTS_TAC `x3` >> + ASM_SIMP_TAC list_ss [] ) ; + +val PERM_SINGLE_SWAP_TC_CONS = Q.store_thm ("PERM_SINGLE_SWAP_TC_CONS", + `!M N. TC PERM_SINGLE_SWAP M N ==> TC PERM_SINGLE_SWAP (x :: M) (x :: N)`, + HO_MATCH_MP_TAC TC_INDUCT >> + REVERSE CONJ_TAC THEN1 MATCH_ACCEPT_TAC TC_TRANS >> + REPEAT STRIP_TAC >> irule TC_SUBSET >> + irule PERM_SINGLE_SWAP_CONS >> FIRST_ASSUM ACCEPT_TAC) ; + +val PERM_is_TC_PSS = Q.prove ( + `!l1 l2. PERM l1 l2 ==> TC PERM_SINGLE_SWAP l1 l2`, + Induct THEN1 (SIMP_TAC list_ss [PERM_NIL] >> + irule TC_SUBSET >> irule PERM_SINGLE_SWAP_REFL) >> + REPEAT STRIP_TAC >> IMP_RES_TAC PERM_CONS_EQ_APPEND >> + BasicProvers.VAR_EQ_TAC >> irule TC_TRANS >> + Q.EXISTS_TAC `(h :: N) ++ M` >> CONJ_TAC + THENL [ + SIMP_TAC list_ss [] >> irule PERM_SINGLE_SWAP_TC_CONS >> + RES_TAC >> irule TC_TRANS >> Q.EXISTS_TAC `M ++ N` >> + CONJ_TAC THEN1 POP_ASSUM ACCEPT_TAC >> + irule TC_SUBSET >> irule PERM_SINGLE_SWAP_APPEND, + irule TC_SUBSET >> irule PERM_SINGLE_SWAP_APPEND ] ) ; + +val PSS_is_PERM = Q.prove ( + `!l1 l2. PERM_SINGLE_SWAP l1 l2 ==> PERM l1 l2`, + SIMP_TAC list_ss [PERM_SINGLE_SWAP_DEF, PERM_alt] >> + REPEAT STRIP_TAC >> + ASM_SIMP_TAC list_ss [FILTER_APPEND_DISTRIB]) ; +val TC_PSS_is_PERM = + REWRITE_RULE [MATCH_MP transitive_TC_identity PERM_transitive] + (MATCH_MP TC_MONOTONE PSS_is_PERM) ; -val PERM_TC = store_thm ("PERM_TC", - ``PERM = TC PERM_SINGLE_SWAP``, - -SIMP_TAC std_ss [FUN_EQ_THM] THEN -REPEAT GEN_TAC THEN EQ_TAC THENL [ - Q.SPEC_TAC (`x'`, `l2`) THEN Q.SPEC_TAC (`x`, `l1`) THEN - HO_MATCH_MP_TAC PERM_IND THEN - REPEAT CONJ_TAC THENL [ - MATCH_MP_TAC TC_SUBSET THEN REWRITE_TAC[PERM_SINGLE_SWAP_REFL], - - GEN_TAC THEN - MATCH_MP_TAC relationTheory.TC_lifts_monotonicities THEN - SIMP_TAC std_ss [PERM_SINGLE_SWAP_DEF, GSYM LEFT_FORALL_IMP_THM] THEN - REPEAT STRIP_TAC THEN - Q.EXISTS_TAC `x::x1` THEN Q.EXISTS_TAC `x2` THEN Q.EXISTS_TAC `x3` THEN - SIMP_TAC list_ss [], - - REPEAT STRIP_TAC THEN - MATCH_MP_TAC (CONJUNCT2 (SIMP_RULE std_ss [FORALL_AND_THM] TC_RULES)) THEN - Q.EXISTS_TAC `y::x::l1` THEN - CONJ_TAC THENL [ - Tactical.REVERSE (`PERM_SINGLE_SWAP (x::y::l1) ((y::l1) ++ [x]) /\ - PERM_SINGLE_SWAP ((y::l1) ++ [x]) (y::x::l1)` by ALL_TAC) THEN1 ( - PROVE_TAC[TC_RULES] - ) THEN - SIMP_TAC std_ss [PERM_SINGLE_SWAP_DEF] THEN - REPEAT STRIP_TAC THENL [ - Q.EXISTS_TAC `[]` THEN Q.EXISTS_TAC `[x]` THEN Q.EXISTS_TAC `y::l1` THEN - SIMP_TAC list_ss [], - - Q.EXISTS_TAC `[y]` THEN Q.EXISTS_TAC `l1` THEN Q.EXISTS_TAC `[x]` THEN - SIMP_TAC list_ss [] - ], - - - POP_ASSUM MP_TAC THEN - Q.SPEC_TAC (`l2`, `l2`) THEN Q.SPEC_TAC (`l1`, `l1`) THEN - HO_MATCH_MP_TAC relationTheory.TC_lifts_monotonicities THEN - SIMP_TAC list_ss [PERM_SINGLE_SWAP_DEF, GSYM LEFT_FORALL_IMP_THM] THEN - REPEAT STRIP_TAC THEN - Q.EXISTS_TAC `y::x::x1` THEN Q.EXISTS_TAC `x2` THEN Q.EXISTS_TAC `x3` THEN - SIMP_TAC list_ss [] - ], - - - PROVE_TAC[TC_TRANSITIVE, transitive_def] - ], - - - Q.SPEC_TAC (`x'`, `l2`) THEN Q.SPEC_TAC (`x`, `l1`) THEN - HO_MATCH_MP_TAC TC_INDUCT THEN - REWRITE_TAC[PERM_TRANS] THEN - SIMP_TAC std_ss [PERM_SINGLE_SWAP_DEF, GSYM LEFT_FORALL_IMP_THM, - PERM_APPEND_IFF, GSYM APPEND_ASSOC, - PERM_APPEND] -]); - - +val PERM_TC = Q.store_thm ("PERM_TC", + `PERM = TC PERM_SINGLE_SWAP`, + SIMP_TAC std_ss [FUN_EQ_THM] >> REPEAT STRIP_TAC >> EQ_TAC + THENL [ MATCH_ACCEPT_TAC PERM_is_TC_PSS, + MATCH_ACCEPT_TAC TC_PSS_is_PERM ]) ; val PERM_RTC = store_thm ("PERM_RTC", ``PERM = RTC PERM_SINGLE_SWAP``, From 453ab647cd971ec92aa8401e78701ad0e08b47ee Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Thu, 18 Jun 2015 11:31:50 +1000 Subject: [PATCH 345/718] faster clearer proof of perm_cons_append in sortingScript --- src/sort/sortingScript.sml | 32 ++++++++++++++------------------ 1 file changed, 14 insertions(+), 18 deletions(-) diff --git a/src/sort/sortingScript.sml b/src/sort/sortingScript.sml index 1e7698d622..5006a948e7 100644 --- a/src/sort/sortingScript.sml +++ b/src/sort/sortingScript.sml @@ -270,28 +270,24 @@ val perm_PERM = UNDISCH perm_PERM val _ = print "Proving perm has primitive recursive characterisation\n" +val perm_cons_append' = Q.prove + (`^perm_t ==> !M. perm (h::M ++ N) (M ++ [h] ++ N)`, + STRIP_TAC >> ASSUME_TAC perm_rules >> ASSUME_TAC perm_refl >> + RULE_L_ASSUM_TAC CONJUNCTS >> + Induct >> ASM_SIMP_TAC list_ss [] >> GEN_TAC >> + MATCH_MP_TAC perm_trans >> Q.EXISTS_TAC `h'::h::(M ++ N)` >> + RES_TAC >> ASM_SIMP_TAC list_ss []) ; + val perm_cons_append = prove( ``^perm_t ==> !l1 l2. perm l1 l2 ==> !M N. (l2 = M ++ N) ==> !h. perm (h::l1) (M ++ [h] ++ N)``, - STRIP_TAC THEN HO_MATCH_MP_TAC perm_ind THEN SRW_TAC [][] THENL [ - SRW_TAC [][perm_rules], - Cases_on `M` THEN SRW_TAC [][] THENL [ - FULL_SIMP_TAC (srw_ss()) [] THEN SRW_TAC [][] THEN - METIS_TAC [perm_rules, APPEND], - FULL_SIMP_TAC (srw_ss()) [] THEN SRW_TAC [][] THEN - METIS_TAC [perm_rules, perm_refl] - ], - `(M = []) \/ (?m1 ms. M = m1::ms)` by (Cases_on `M` THEN SRW_TAC [][]) THEN - SRW_TAC [][] THEN FULL_SIMP_TAC (srw_ss()) [] THEN SRW_TAC [][] THENL [ - METIS_TAC [perm_rules, APPEND, perm_refl], - `(ms = []) \/ (?m2 mss. ms = m2::mss)` - by (Cases_on `ms` THEN SRW_TAC [][]) THEN - SRW_TAC [][] THEN FULL_SIMP_TAC (srw_ss()) [] THEN SRW_TAC [][] THEN - METIS_TAC [perm_rules, APPEND, perm_refl] - ], - METIS_TAC [perm_trans, APPEND] - ]) + REPEAT STRIP_TAC >> MATCH_MP_TAC perm_trans >> + Q.EXISTS_TAC `h :: l2` >> CONJ_TAC + THENL [ ASSUME_TAC perm_rules >> ASM_SIMP_TAC list_ss [], + BasicProvers.VAR_EQ_TAC >> + MATCH_ACCEPT_TAC (REWRITE_RULE [APPEND] (UNDISCH perm_cons_append')) ]) ; + val perm_cons_append = SIMP_RULE (bool_ss ++ boolSimps.DNF_ss) [] (UNDISCH perm_cons_append) From 22535f079f84ee09ce8c531091e74aad80b567e9 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 24 Jun 2015 17:14:09 +1000 Subject: [PATCH 346/718] New theory of error-state monad. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Modelled on state_transformer example. Not committed to, or sure about name of theory. Didn't bring across the "monadic while" constant, but prove most of the rest of things. Also show it to be "applicative" as per option, and the zipper example. If α → (β × α) option is "error state", is α → (β option × α) "state error"? Should probably write a functor or something to automate these to some extent. --- src/monad/errorStateMonadScript.sml | 323 ++++++++++++++++++++++++++++ 1 file changed, 323 insertions(+) create mode 100644 src/monad/errorStateMonadScript.sml diff --git a/src/monad/errorStateMonadScript.sml b/src/monad/errorStateMonadScript.sml new file mode 100644 index 0000000000..fb03b93d46 --- /dev/null +++ b/src/monad/errorStateMonadScript.sml @@ -0,0 +1,323 @@ +open HolKernel Parse boolLib pairTheory pairSyntax combinTheory + optionTheory listTheory; + +val _ = new_theory "errorStateMonad" + +val DEF = Lib.with_flag (boolLib.def_suffix, "_DEF") TotalDefn.Define + +(* ------------------------------------------------------------------------- *) +(* Definitions. *) +(* ------------------------------------------------------------------------- *) + +val () = Parse.temp_type_abbrev ("M",``:'state -> ('a # 'state) option``) + +val UNIT_DEF = DEF `UNIT (x:'b) : ('b,'a) M = \(s:'a). SOME (x, s)`; + +val BIND_DEF = DEF ` + BIND (g: ('b, 'a) M) (f: 'b -> ('c, 'a) M) (s0:'a) = + case g s0 of + NONE => NONE + | SOME (b,s) => f b s +` + +val IGNORE_BIND_DEF = DEF ` + IGNORE_BIND (f:('a,'b)M) (g:('c,'b)M) : ('c,'b)M = BIND f (\x. g)`; + +val MMAP_DEF = DEF `MMAP (f: 'c -> 'b) (m: ('c, 'a) M) = BIND m (UNIT o f)`; + +val JOIN_DEF = DEF `JOIN (z: (('b, 'a) M, 'a) M) = BIND z I`; + +val FOR_def = TotalDefn.tDefine "FOR" + `(FOR : num # num # (num -> (unit, 'state) M) -> (unit, 'state) M) (i, j, a) = + if i = j then + a i + else + BIND (a i) (\u. FOR (if i < j then i + 1 else i - 1, j, a))` + (TotalDefn.WF_REL_TAC `measure (\(i, j, a). if i < j then j - i else i - j)`) + +val FOREACH_def = TotalDefn.Define` + ((FOREACH : 'a list # ('a -> (unit, 'state) M) -> (unit, 'state) M) ([], a) = + UNIT ()) /\ + (FOREACH (h :: t, a) = BIND (a h) (\u. FOREACH (t, a)))` + +val READ_def = TotalDefn.Define` + (READ : ('state -> 'a) -> ('a, 'state) M) f = \s. SOME (f s, s)`; + +val WRITE_def = TotalDefn.Define` + (WRITE : ('state -> 'state) -> (unit, 'state) M) f = \s. SOME ((), f s)`; + +val NARROW_def = TotalDefn.Define` + (NARROW : 'b -> ('a, 'b # 'state) M -> ('a, 'state) M) v f = + \s. case f (v, s) of + NONE => NONE + | SOME (r, s1) => SOME (r, SND s1)` + +val WIDEN_def = TotalDefn.Define` + (WIDEN : ('a, 'state) M -> ('a, 'b # 'state) M) f = + \(s1, s2). case f s2 of + NONE => NONE + | SOME (r, s3) => SOME (r, (s1, s3))` + +val sequence_def = TotalDefn.Define` + sequence = FOLDR (\m ms. BIND m (\x. BIND ms (\xs. UNIT (x::xs)))) (UNIT [])` + +val mapM_def = TotalDefn.Define` + mapM f = sequence o MAP f` + +open simpLib BasicProvers boolSimps metisLib + +(* +val mwhile_exists = prove( + ``!g b. ?f. + f = BIND g (\gv. if gv then IGNORE_BIND b f else UNIT ())``, + MAP_EVERY Q.X_GEN_TAC [`g`, `b`] THEN + Q.EXISTS_TAC + `\s0. if ?n. ~FST (g (FUNPOW (SND o b o SND o g) n s0)) then + let n = LEAST n. ~FST (g (FUNPOW (SND o b o SND o g) n s0)) + in + ((), SND (g (FUNPOW (SND o b o SND o g) n s0))) + else ARB` THEN + SIMP_TAC (srw_ss()) [FUN_EQ_THM] THEN Q.X_GEN_TAC `s` THEN + COND_CASES_TAC THENL [ + POP_ASSUM (Q.X_CHOOSE_THEN `n0` ASSUME_TAC) THEN + SIMP_TAC (srw_ss()) [SimpLHS, LET_THM] THEN + numLib.LEAST_ELIM_TAC THEN CONJ_TAC THEN1 METIS_TAC[] THEN + Q.X_GEN_TAC `n` THEN SIMP_TAC (srw_ss()) [] THEN STRIP_TAC THEN + SIMP_TAC (srw_ss()) [BIND_DEF] THEN + Q.ISPEC_THEN `g s` (Q.X_CHOOSE_THEN `gv1` + (Q.X_CHOOSE_THEN `s1` ASSUME_TAC)) + pairTheory.pair_CASES THEN + ASM_SIMP_TAC (srw_ss()) [] THEN REVERSE (Cases_on `gv1`) + THEN1 (`n = 0` + by (SPOSE_NOT_THEN ASSUME_TAC THEN + `0 < n` by SRW_TAC [numSimps.ARITH_ss][] THEN + FIRST_X_ASSUM (Q.SPEC_THEN `0` MP_TAC) THEN + SRW_TAC [][]) THEN + SRW_TAC [][UNIT_DEF]) THEN + ASM_SIMP_TAC (srw_ss()) [IGNORE_BIND_DEF, BIND_DEF] THEN + Q.ISPEC_THEN `b s1` (Q.X_CHOOSE_THEN `bv1` + (Q.X_CHOOSE_THEN `s2` ASSUME_TAC)) + pairTheory.pair_CASES THEN + ASM_SIMP_TAC (srw_ss()) [] THEN + `?m. n = SUC m` + by (Cases_on `n` THEN FULL_SIMP_TAC (srw_ss()) []) THEN + Q.SUBGOAL_THEN `?n. ~FST (g (FUNPOW (SND o b o SND o g) n s2))` + ASSUME_TAC + THEN1 (Q.EXISTS_TAC `m` THEN + FULL_SIMP_TAC (srw_ss()) [arithmeticTheory.FUNPOW]) THEN + ASM_SIMP_TAC (srw_ss()) [arithmeticTheory.FUNPOW] THEN + Q_TAC SUFF_TAC + `(LEAST n. ~FST (g (FUNPOW (SND o b o SND o g) n s2))) = m` + THEN1 SRW_TAC [][] THEN + numLib.LEAST_ELIM_TAC THEN CONJ_TAC THEN1 SRW_TAC [][] THEN + Q.X_GEN_TAC `p` THEN SRW_TAC [][] THEN + Q_TAC SUFF_TAC `~(m < p) /\ ~(p < m)` THEN1 numLib.ARITH_TAC THEN + REPEAT STRIP_TAC THENL [ + `FST (g (FUNPOW (SND o b o SND o g) m s2))` by METIS_TAC[] THEN + `FST (g (FUNPOW (SND o b o SND o g) (SUC m) s))` + by (SIMP_TAC (srw_ss())[arithmeticTheory.FUNPOW] THEN + SRW_TAC [][]), + `SUC p < SUC m` by SRW_TAC [numSimps.ARITH_ss][] THEN + RES_THEN MP_TAC THEN + SIMP_TAC (srw_ss()) [arithmeticTheory.FUNPOW] THEN + SRW_TAC [][] + ], + FULL_SIMP_TAC (srw_ss()) [BIND_DEF] THEN + Q.ISPEC_THEN `g s` (Q.X_CHOOSE_THEN `gv1` + (Q.X_CHOOSE_THEN `s1` ASSUME_TAC)) + pairTheory.pair_CASES THEN + REVERSE (SRW_TAC [][]) + THEN1(FIRST_X_ASSUM (Q.SPEC_THEN `0` MP_TAC) THEN SRW_TAC [][]) THEN + SRW_TAC [][IGNORE_BIND_DEF, BIND_DEF] THEN + Q.ISPEC_THEN `b s1` (Q.X_CHOOSE_THEN `bv1` + (Q.X_CHOOSE_THEN `s2` ASSUME_TAC)) + pairTheory.pair_CASES THEN + SRW_TAC [][] THEN + FIRST_X_ASSUM (Q.SPEC_THEN `SUC m` (MP_TAC o Q.GEN `m`)) THEN + SRW_TAC [][arithmeticTheory.FUNPOW] + ]) + +val MWHILE_DEF = new_specification( + "MWHILE_DEF", ["MWHILE"], + mwhile_exists |> SIMP_RULE bool_ss [SKOLEM_THM]); +*) + +(* ------------------------------------------------------------------------- *) +(* Theorems. *) +(* ------------------------------------------------------------------------- *) + +open BasicProvers +val BIND_LEFT_UNIT = store_thm + ("BIND_LEFT_UNIT[simp]", + ``!k x. BIND (UNIT x) k = k x``, + SRW_TAC [][BIND_DEF, UNIT_DEF, FUN_EQ_THM]); + +val option_case_eq = prove_case_eq_thm{ + case_def= option_case_def, + nchotomy = option_CASES + |> ONCE_REWRITE_RULE [DISJ_COMM] +}; +val pair_case_eq = prove_case_eq_thm{ + case_def= TypeBase.case_def_of ``:'a # 'b`` + |> INST_TYPE [alpha |-> gamma, beta |-> alpha, gamma |-> beta] + |> GENL [``x:'a``, ``y:'b``, ``f:'a -> 'b -> 'c``] , + nchotomy = TypeBase.nchotomy_of ``:'a # 'b`` +}; + + +val BIND_RIGHT_UNIT = store_thm + ("BIND_RIGHT_UNIT[simp]", + ``!k. BIND k UNIT = k``, + SRW_TAC [boolSimps.CONJ_ss] + [BIND_DEF, UNIT_DEF, FUN_EQ_THM, option_case_eq, pair_case_eq] THEN + (Q.FIND_CASE_TAC `k v = NONE` ORELSE Q.FIND_CASE_TAC `NONE = k v`) THEN + Cases_on `k v` THEN SRW_TAC [][] THEN + metisLib.METIS_TAC [TypeBase.nchotomy_of ``:'a # 'b``]); + +val BIND_ASSOC = store_thm + ("BIND_ASSOC", + ``!k m n. BIND k (\a. BIND (m a) n) = BIND (BIND k m) n``, + SRW_TAC [][BIND_DEF, FUN_EQ_THM] THEN + Q.FIND_CASE_TAC `option_CASE (k v) NONE _` THEN + Cases_on `k v` THEN SRW_TAC [][] THEN + Q.FIND_CASE_TAC `pair_CASE p _` THEN Cases_on `p` THEN + SRW_TAC [][]); + +val MMAP_ID = store_thm + ("MMAP_ID[simp]", + ``MMAP I = I``, + SRW_TAC[][FUN_EQ_THM, MMAP_DEF]); + +val MMAP_COMP = store_thm + ("MMAP_COMP", + ``!f g. MMAP (f o g) = MMAP f o MMAP g``, + SRW_TAC[][FUN_EQ_THM, MMAP_DEF, o_DEF, GSYM BIND_ASSOC]); + +val MMAP_UNIT = store_thm + ("MMAP_UNIT", + ``!f. MMAP f o UNIT = UNIT o f``, + SRW_TAC[][FUN_EQ_THM, MMAP_DEF]); + +val MMAP_JOIN = store_thm + ("MMAP_JOIN", + ``!f. MMAP f o JOIN = JOIN o MMAP (MMAP f)``, + SRW_TAC [][MMAP_DEF, o_DEF, JOIN_DEF, FUN_EQ_THM, GSYM BIND_ASSOC]); + +val JOIN_UNIT = store_thm + ("JOIN_UNIT", + ``JOIN o UNIT = I``, + SRW_TAC[][FUN_EQ_THM, JOIN_DEF, o_DEF]); + +val JOIN_MMAP_UNIT = store_thm + ("JOIN_MMAP_UNIT[simp]", + ``JOIN o MMAP UNIT = I``, + SRW_TAC[boolSimps.ETA_ss] + [JOIN_DEF, o_DEF, MMAP_DEF, FUN_EQ_THM, GSYM BIND_ASSOC]); + +val JOIN_MAP_JOIN = store_thm + ("JOIN_MAP_JOIN", + ``JOIN o MMAP JOIN = JOIN o JOIN``, + SRW_TAC [][FUN_EQ_THM, JOIN_DEF, o_DEF, MMAP_DEF, GSYM BIND_ASSOC]); + +val JOIN_MAP = store_thm + ("JOIN_MAP", + ``!k m. BIND k m = JOIN (MMAP m k)``, + SRW_TAC [boolSimps.ETA_ss] + [JOIN_DEF, o_DEF, MMAP_DEF, FUN_EQ_THM, GSYM BIND_ASSOC]); + +val sequence_nil = store_thm("sequence_nil[simp]", + ``sequence [] = UNIT []``, + SRW_TAC[][sequence_def]) + +val mapM_nil = store_thm("mapM_nil[simp]", + ``mapM f [] = UNIT []``, + SRW_TAC[][mapM_def]) + +val mapM_cons = store_thm("mapM_cons", + ``mapM f (x::xs) = BIND (f x) (\y. BIND (mapM f xs) (\ys. UNIT (y::ys)))``, + SRW_TAC[][mapM_def,sequence_def]) + +(* fail and choice *) +val ES_FAIL_DEF = DEF` + ES_FAIL s = NONE +`; + +val ES_CHOICE_DEF = DEF` + ES_CHOICE xM yM s = + case xM s of + NONE => yM s + | xr => xr +`; + +val ES_GUARD_DEF = DEF` + ES_GUARD b = if b then UNIT () else ES_FAIL +` + +val ES_CHOICE_ASSOC = store_thm( + "ES_CHOICE_ASSOC", + ``ES_CHOICE xM (ES_CHOICE yM zM) = ES_CHOICE (ES_CHOICE xM yM) zM``, + SRW_TAC[][FUN_EQ_THM, ES_CHOICE_DEF] THEN + Q.FIND_CASE_TAC `option_CASE (xM s)` THEN Cases_on `xM s` THEN SRW_TAC[][]); + +val ES_CHOICE_FAIL_LID = store_thm( + "ES_CHOICE_FAIL_LID[simp]", + ``ES_CHOICE ES_FAIL xM = xM``, + SRW_TAC[][FUN_EQ_THM, ES_CHOICE_DEF, ES_FAIL_DEF]); + +val ES_CHOICE_FAIL_RID = store_thm( + "ES_CHOICE_FAIL_RID[simp]", + ``ES_CHOICE xM ES_FAIL = xM``, + SRW_TAC[][FUN_EQ_THM, ES_CHOICE_DEF, ES_FAIL_DEF] THEN + Q.FIND_CASE_TAC `option_CASE (xM s)` THEN Cases_on `xM s` THEN SRW_TAC[][]); + +val BIND_FAIL = store_thm( + "BIND_FAIL_L[simp]", + ``BIND ES_FAIL fM = ES_FAIL``, + SRW_TAC[][FUN_EQ_THM, ES_FAIL_DEF, BIND_DEF]); + +val BIND_ESGUARD = store_thm( + "BIND_ESGUARD[simp]", + ``(BIND (ES_GUARD F) fM = ES_FAIL) /\ + (BIND (ES_GUARD T) fM = fM ())``, + SRW_TAC[][ES_GUARD_DEF]); + +val IGNORE_BIND_ESGUARD = store_thm( + "IGNORE_BIND_ESGUARD[simp]", + ``(IGNORE_BIND (ES_GUARD F) xM = ES_FAIL) /\ + (IGNORE_BIND (ES_GUARD T) xM = xM)``, + SRW_TAC[][ES_GUARD_DEF, IGNORE_BIND_DEF]); + +val IGNORE_BIND_FAIL = store_thm( + "IGNORE_BIND_FAIL[simp]", + ``(IGNORE_BIND ES_FAIL xM = ES_FAIL) /\ + (IGNORE_BIND xM ES_FAIL = ES_FAIL)``, + SRW_TAC[][IGNORE_BIND_DEF] THEN + SRW_TAC[][ES_FAIL_DEF, BIND_DEF, FUN_EQ_THM] THEN + Q.FIND_CASE_TAC `option_CASE (xM s)` THEN Cases_on `xM s` THEN + SRW_TAC [][] THEN Q.FIND_CASE_TAC `xM s = SOME rs` THEN Cases_on `rs` THEN + SRW_TAC[][]) + +(* applicative *) +val ES_APPLY_DEF = DEF` + ES_APPLY fM xM = BIND fM (\f. BIND xM (\x. UNIT (f x))) +` +val _ = overload_on ("APPLICATIVE_FAPPLY", ``ES_APPLY``) + +val APPLY_UNIT = store_thm( + "APPLY_UNIT", + ``UNIT f <*> xM = MMAP f xM``, + SRW_TAC[][ES_APPLY_DEF, MMAP_DEF, o_DEF]); + +val APPLY_UNIT_UNIT = store_thm( + "APPLY_UNIT_UNIT[simp]", + ``UNIT f <*> UNIT x = UNIT (f x)``, + SRW_TAC[][ES_APPLY_DEF]); + +val ES_LIFT2_DEF = DEF` + ES_LIFT2 f xM yM = MMAP f xM <*> yM +`; + + +(* ------------------------------------------------------------------------- *) + +val _ = export_theory () From 7403ede5561859688fb42d11fa7c68439f6c8fab Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 24 Jun 2015 21:43:33 +1000 Subject: [PATCH 347/718] Copy SUC_SUB thm from theory "bit" to "arithmetic" Theorem states: !a. SUC a - a = 1 Make it automatic (appearing in srw_ss()). --- src/num/extra_theories/bitScript.sml | 3 +-- src/num/theories/arithmeticScript.sml | 8 ++++++++ 2 files changed, 9 insertions(+), 2 deletions(-) diff --git a/src/num/extra_theories/bitScript.sml b/src/num/extra_theories/bitScript.sml index f6fde320d1..fe8761a0d2 100644 --- a/src/num/extra_theories/bitScript.sml +++ b/src/num/extra_theories/bitScript.sml @@ -98,8 +98,7 @@ val DIVMOD_2EXP = save_thm("DIVMOD_2EXP", REWRITE_RULE [GSYM DIV_2EXP_def, GSYM MOD_2EXP_def] DIVMOD_2EXP_def) (* |- !a. SUC a - a = 1 *) -val SUC_SUB = save_thm("SUC_SUB", - GEN_ALL (SIMP_CONV arith_ss [ADD1] ``SUC a - a``)) +val SUC_SUB = save_thm("SUC_SUB", arithmeticTheory.SUC_SUB); (* |- !n r. r < n ==> ((n + r) DIV n = 1) *) val DIV_MULT_1 = save_thm("DIV_MULT_1", diff --git a/src/num/theories/arithmeticScript.sml b/src/num/theories/arithmeticScript.sml index c995d3ecd7..f9136ca5e0 100644 --- a/src/num/theories/arithmeticScript.sml +++ b/src/num/theories/arithmeticScript.sml @@ -1020,6 +1020,14 @@ val SUB_MONO_EQ = store_thm ("SUB_MONO_EQ", PURE_ONCE_REWRITE_TAC[LESS_MONO_EQ] THEN ASM_REWRITE_TAC[]]); +val SUC_SUB = store_thm( + "SUC_SUB[simp]", + ``!a. SUC a - a = 1``, + INDUCT_TAC THENL [ + REWRITE_TAC [SUB, LESS_REFL, ONE], + ASM_REWRITE_TAC [SUB_MONO_EQ] + ]); + val SUB_PLUS = store_thm ("SUB_PLUS", ``!a b c. a - (b + c) = (a - b) - c``, REPEAT INDUCT_TAC THEN From 6267d6df161aa42de5dfe002fa18b1cc9d7f3589 Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Fri, 26 Jun 2015 22:58:41 +0100 Subject: [PATCH 348/718] Update L3 import. --- examples/l3-machine-code/common/Import.sig | 1 + examples/l3-machine-code/common/Import.sml | 5 +++++ 2 files changed, 6 insertions(+) diff --git a/examples/l3-machine-code/common/Import.sig b/examples/l3-machine-code/common/Import.sig index 28184d79f7..8260fa1044 100644 --- a/examples/l3-machine-code/common/Import.sig +++ b/examples/l3-machine-code/common/Import.sig @@ -46,6 +46,7 @@ sig | Nub | PadLeft | PadRight + | QuotRem | Remove | RemoveExcept | RemoveDuplicates diff --git a/examples/l3-machine-code/common/Import.sml b/examples/l3-machine-code/common/Import.sml index 07f5588b30..d8d775fbd8 100644 --- a/examples/l3-machine-code/common/Import.sml +++ b/examples/l3-machine-code/common/Import.sml @@ -495,6 +495,7 @@ datatype monop = | Nub | PadLeft | PadRight + | QuotRem | Remove | RemoveExcept | RemoveDuplicates @@ -661,6 +662,9 @@ local val mk_difference = mk_uncurry ``\(s1:'a set, s2). pred_set$DIFF s1 s2`` val mk_issubset = mk_uncurry ``\(s1:'a set, s2). pred_set$SUBSET s1 s2`` + val mk_quot_rem = + mk_uncurry ``\(m, n). (integer$int_quot m n, integer$int_rem m n)`` + fun mk_rev tm = (if Lib.can wordsSyntax.dim_of tm then wordsSyntax.mk_word_reverse @@ -966,6 +970,7 @@ in | Not => boolSyntax.mk_neg | PadLeft => mk_pad_left | PadRight => mk_pad_right + | QuotRem => mk_quot_rem | Remove => mk_remove | RemoveExcept => mk_remove_e | RemoveDuplicates => listSyntax.mk_nub From a4b878779e982ed4edf2ca4ef5bff5deb2fd5f9b Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 29 Jun 2015 15:36:17 +1000 Subject: [PATCH 349/718] Improve pretty-printing of seq values in Poly/ML. Poly/ML will pretty-print with the (hidden) constructors otherwise, and large sequences look moderately dreadful. Moscow ML already knows to print opaquified types opaquely. --- tools-poly/prelude.ML | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/tools-poly/prelude.ML b/tools-poly/prelude.ML index 4282c579f7..12ae07cd2d 100644 --- a/tools-poly/prelude.ML +++ b/tools-poly/prelude.ML @@ -39,10 +39,12 @@ in HOLPP.add_string pps "" fun pp_redblackset pps (_:'a Redblackset.set) = HOLPP.add_string pps "" + fun pp_seq pps (_ : 'a seq.seq) = HOLPP.add_string pps "" in install_pp (pp2polypp (with_pp HOLset.pp_holset)); install_pp (pp2polypp (with_pp pp_redblackmap)); - install_pp (pp2polypp (with_pp pp_redblackset)) + install_pp (pp2polypp (with_pp pp_redblackset)); + install_pp (pp2polypp (with_pp pp_seq)) end else (); install_pp (pp2polypp From 609a398dcc84673fb0a6c521117df245b9250644 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 1 Jul 2015 19:42:33 +1000 Subject: [PATCH 350/718] Add some Unicode parentheses to emacs mode --- tools/hol-unicode.el | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/tools/hol-unicode.el b/tools/hol-unicode.el index a1a7e88d63..b16c88afb2 100644 --- a/tools/hol-unicode.el +++ b/tools/hol-unicode.el @@ -25,12 +25,16 @@ (define-prefix-command 'hol-unicode-subscript-map) (define-prefix-command 'hol-unicode-superscript-map) (define-prefix-command 'hol-unicode-U-map) +(define-prefix-command 'hol-unicode-lparen-map) +(define-prefix-command 'hol-unicode-rparen-map) (define-key global-map (kbd "C-S-p") 'hol-unicode-p-map) (define-key global-map (kbd "C-M-S-p") 'hol-unicode-P-map) (define-key global-map (kbd "C-M-|") 'hol-unicode-not-map) (define-key global-map (kbd "C-M-_") 'hol-unicode-subscript-map) (define-key global-map (kbd "C-M-^") 'hol-unicode-superscript-map) (define-key global-map (kbd "C-S-M-u") 'hol-unicode-U-map) +(define-key global-map (kbd "C-(") 'hol-unicode-lparen-map) +(define-key global-map (kbd "C-)") 'hol-unicode-rparen-map) ;; Greek : C-S- for lower case version of Greek ;; add the Meta modifier for upper case Greek letter. @@ -150,3 +154,15 @@ (define-key hol-unicode-U-map "u" "𝕌") (define-key hol-unicode-U-map "+" "⊎") ; U+228E "multiset union" (define-key hol-unicode-U-map "<" "⊌") ; U+228C called simply "multiset", used in HOL for FUNION + +; parenthesis map - for various forms of parenthesis +(define-key hol-unicode-lparen-map (kbd "C-|") "⦇") +(define-key hol-unicode-rparen-map (kbd "C-|") "⦈") +(define-key hol-unicode-lparen-map (kbd "C-(") "⦅") +(define-key hol-unicode-rparen-map (kbd "C-)") "⦆") +(define-key hol-unicode-lparen-map (kbd "C-<") "⟨") +(define-key hol-unicode-rparen-map (kbd "C->") "⟩") +(define-key hol-unicode-lparen-map (kbd "C-M-<") "⟪") +(define-key hol-unicode-rparen-map (kbd "C-M->") "⟫") +(define-key hol-unicode-lparen-map (kbd "C-^") "⎡") +(define-key hol-unicode-rparen-map (kbd "C-^") "⎤") From 7e7280ece1fa9411acbd6e200abdc637725ad40b Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 2 Jul 2015 15:40:57 +1000 Subject: [PATCH 351/718] Provide a UTF8-aware padRight function This can then be used in the testing routines that want pretty output that might include non-ASCII characters. --- src/1/testutils.sml | 2 +- src/portableML/UTF8.sig | 1 + src/portableML/UTF8.sml | 8 ++++++++ src/portableML/selftest.sml | 9 +++++---- 4 files changed, 15 insertions(+), 5 deletions(-) diff --git a/src/1/testutils.sml b/src/1/testutils.sml index da4c3d3f95..955be79109 100644 --- a/src/1/testutils.sml +++ b/src/1/testutils.sml @@ -7,7 +7,7 @@ val linewidth = ref 80 fun die s = (print (s ^ "\n"); OS.Process.exit OS.Process.failure) -fun tprint s = print (StringCvt.padRight #" " 65 (s ^ " ... ")) +fun tprint s = print (UTF8.padRight #" " 65 (s ^ " ... ")) fun unicode_off f = Feedback.trace ("Unicode", 0) f fun raw_backend f = diff --git a/src/portableML/UTF8.sig b/src/portableML/UTF8.sig index 3ac2307d82..33ab2f85c3 100644 --- a/src/portableML/UTF8.sig +++ b/src/portableML/UTF8.sig @@ -6,6 +6,7 @@ sig val lastChar : string -> (string * int) option val size : string -> int val chr : int -> string (* May raise Chr *) + val padRight : char -> int -> string -> string val translate : (string -> string) -> string -> string end diff --git a/src/portableML/UTF8.sml b/src/portableML/UTF8.sml index a5912c0a0d..317caadfbb 100644 --- a/src/portableML/UTF8.sml +++ b/src/portableML/UTF8.sml @@ -175,4 +175,12 @@ in recurse 0 false [] s end +fun padRight c len s = + let + val slen = size s + in + if slen > len then s + else s ^ CharVector.tabulate(len - slen, fn _ => c) + end + end (* struct *) diff --git a/src/portableML/selftest.sml b/src/portableML/selftest.sml index 0e64cdc64a..3fc7408904 100644 --- a/src/portableML/selftest.sml +++ b/src/portableML/selftest.sml @@ -4,9 +4,8 @@ val _ =print "\n" fun die s = (print (s^"\n"); OS.Process.exit OS.Process.failure) fun assert (s, b) = - (print (StringCvt.padRight #" " 65 s); - if b() then print "OK\n" - else die "FAILED!") + (print (UTF8.padRight #" " 65 s); + if b() then print "OK\n" else die "FAILED!") open Redblackset @@ -41,7 +40,9 @@ val _ = List.app assert [ ("UTF8.getChar \"\\192\\128\" fails", gcFails "\192\168"), ("UTF8.getChar \"\\252\\129\\129\\129\\129\\129\" fails", gcFails "\252\129\129\129\129\129"), - ("UF8.getChar \"\\244\\129\" fails", gcFails "\244\129") + ("UF8.getChar \"\\244\\129\" fails", gcFails "\244\129"), + ("padRight #\" \" on ∀", fn () => UTF8.padRight #" " 5 "∀" = "∀ "), + ("padRight #\"a\" on ∀", fn () => UTF8.padRight #"a" 5 "∀" = "∀aaaa") ] val _ = OS.Process.exit OS.Process.success From a540f29e965301df4b7906ac34bf475ee9eb657e Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 2 Jul 2015 15:42:14 +1000 Subject: [PATCH 352/718] Fix blemish in output from portableML/selftest.sml --- src/portableML/selftest.sml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/portableML/selftest.sml b/src/portableML/selftest.sml index 3fc7408904..b221572ce6 100644 --- a/src/portableML/selftest.sml +++ b/src/portableML/selftest.sml @@ -27,7 +27,7 @@ val _ = List.app assert [ (fn () => listItems em13 = [13])), ("UTF8.getChar \"\" = NONE", gcSucceeds "" NONE), ("UTF8.getChar 0x41 = #\"A\"", gcSucceeds "A" (SOME(("A", 65), ""))), - ("UTF8.getChar A\000 = #\"A\"", + ("UTF8.getChar A\\000 = #\"A\"", gcSucceeds "A\000" (SOME(("A", 65), "\000"))), ("UTF8.getChar 0x2200 = #\"\226\136\128\"", gcSucceeds "\226\136\128" (SOME(("\226\136\128", 8704), ""))), From 3a51e6fce1d3677beda13843e47a90ec827db0f6 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 2 Jul 2015 16:00:54 +1000 Subject: [PATCH 353/718] New example within examples/parsing: s-expressions MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The s-expression type has constructors, SX_CONS, SX_STR, SX_NUM and SX_SYM. There is pretty HOL-level syntax for the first of these, using ⦇ ... ⦈ to delimit lists, and with elements separated by ; as is usual for HOL list-forms. (Such lists are internally terminated with SX_SYM "nil"). There is also notational support so that SX_CONS s1 s2 can be written ⦇ s1 • s2 ⦈ The SX_NUM constructor is admitted as a numeral form, so ``SX_NUM 10``, can just be written as ``10``. The PEG and grammar define what I think is a fairly traditional Lisp-syntax, including 's as syntax for (quote s). This latter is there mainly for the hell of it, as I don't suppose we are likely to want to give the type an operational semantics like Lisp's. Getting the PEG to parse efficiently with EVAL is demonstrated and tested in the self-test. Some new generic facilities are moved into pegLib and the pegScript. Rather more is still possible. For example, the provided PEG parses directly from strings to sexps. In order to show a connection with the sexp grammar in simpleSexpTheory, one would have to write another PEG that parsed to parse-trees. One could then write functions to convert from those parse-trees to sexps, and show that the composition of these with the parse-tree parser gave the same result as the direct-to-sexp parser. --- examples/parsing/Holmakefile | 9 ++ examples/parsing/grammarScript.sml | 6 + examples/parsing/pegLib.sig | 5 + examples/parsing/pegLib.sml | 55 +++++++++ examples/parsing/pegScript.sml | 24 ++++ examples/parsing/selftest.sml | 55 +++++++++ examples/parsing/simpleSexpPEGScript.sml | 65 +++++++++++ examples/parsing/simpleSexpScript.sml | 135 +++++++++++++++++++++++ 8 files changed, 354 insertions(+) create mode 100644 examples/parsing/Holmakefile create mode 100644 examples/parsing/selftest.sml create mode 100644 examples/parsing/simpleSexpPEGScript.sml create mode 100644 examples/parsing/simpleSexpScript.sml diff --git a/examples/parsing/Holmakefile b/examples/parsing/Holmakefile new file mode 100644 index 0000000000..c5a451f3da --- /dev/null +++ b/examples/parsing/Holmakefile @@ -0,0 +1,9 @@ +THYFILES = $(patsubst %Script.sml,%Theory.uo,$(wildcard *.sml)) +TARGETS = $(patsubst %.sml,%.uo,$(THYFILES)) + +all: $(TARGETS) selftest.exe +.PHONY: all + + +selftest.exe: selftest.uo pegexecTheory.uo simpleSexpPEGTheory.uo pegLib.uo + $(HOLMOSMLC) -o $@ $< diff --git a/examples/parsing/grammarScript.sml b/examples/parsing/grammarScript.sml index 95efe9718f..f4c8560323 100644 --- a/examples/parsing/grammarScript.sml +++ b/examples/parsing/grammarScript.sml @@ -18,6 +18,12 @@ val _ = Datatype `symbol = TOK 'a | NT ('b inf)`; val isTOK_def = Define`(isTOK (TOK tok) = T) ∧ (isTOK (NT n) = F)` val _ = export_rewrites ["isTOK_def"] +val destTOK_def = Define` + (destTOK (TOK tk) = SOME tk) ∧ + (destTOK _ = NONE) +`; +val _ = export_rewrites ["destTOK_def"] + val _ = Datatype` grammar = <| start : 'b inf; diff --git a/examples/parsing/pegLib.sig b/examples/parsing/pegLib.sig index d666a7d196..5178ddc02b 100644 --- a/examples/parsing/pegLib.sig +++ b/examples/parsing/pegLib.sig @@ -1,6 +1,11 @@ signature pegLib = sig +include Abbrev + val add_peg_compset : computeLib.compset -> unit +val derive_compset_distincts : hol_type -> thm +val derive_lookup_ths : + {pegth : thm, ntty : hol_type, simp : thm list -> conv} -> thm list end diff --git a/examples/parsing/pegLib.sml b/examples/parsing/pegLib.sml index 6c9eb83937..8fd97cc5e3 100644 --- a/examples/parsing/pegLib.sml +++ b/examples/parsing/pegLib.sml @@ -1,6 +1,8 @@ structure pegLib :> pegLib = struct +open HolKernel Parse boolLib + fun add_peg_compset cs = (computeLib.add_thms [grammarTheory.isTOK_def @@ -30,4 +32,57 @@ fun add_peg_compset cs = ,``:('a,'b,'c)evalcase`` ]) +fun derive_compset_distincts ty = + let + val ax = TypeBase.axiom_of ty + val th = Prim_rec.prove_constructors_distinct ax |> hd |> valOf + in + CONJ th (GSYM th) + end + +val peg_rules_t = prim_mk_const{Thy = "peg", Name = "peg_rules"} + +fun strip_insert t = let + open pred_setSyntax + fun recurse acc t = + case Lib.total dest_insert t of + NONE => acc + | SOME (e,s) => recurse (e::acc) s +in + recurse [] t +end + +fun derive_lookup_ths {pegth, ntty, simp} = + let + open finite_mapSyntax pred_setTheory finite_mapTheory + val pegc = lhs (concl pegth) + val nt_thm = pegexecTheory.peg_nt_thm |> Q.GEN `n` |> Q.GEN `G` |> ISPEC pegc + val NT_ty = sumSyntax.mk_sum (ntty, numSyntax.num) + val mkNT_t = Term.inst [alpha |-> ntty, beta |-> numSyntax.num] + sumSyntax.inl_tm + val Grules_t = mk_icomb(peg_rules_t, pegc) + val fdomrules_t = mk_fdom Grules_t + val fdom_thm = simp[pegth, FUPDATE_LIST] fdomrules_t + val cs = strip_insert (rhs (concl fdom_thm)) + fun fdom c = + AP_TERM (mk_icomb(pred_setSyntax.in_tm, c)) fdom_thm + |> CONV_RULE + (RAND_CONV + (PURE_REWRITE_CONV [IN_INSERT, OR_CLAUSES, REFL_CLAUSE])) + val fdoms = map fdom cs + fun fapp c = + mk_fapply(Grules_t, c) + |> simp[pegth, FUPDATE_LIST, FAPPLY_FUPDATE_THM] + val fapps = map fapp cs + fun final c = CONV_RULE + (RAND_CONV + (PURE_REWRITE_CONV (COND_CLAUSES :: fdoms @ fapps))) + (SPEC c nt_thm) + in + map final cs + end + + + + end diff --git a/examples/parsing/pegScript.sml b/examples/parsing/pegScript.sml index 6b02ba2731..90c95a7f0d 100644 --- a/examples/parsing/pegScript.sml +++ b/examples/parsing/pegScript.sml @@ -329,4 +329,28 @@ val peg_eval_total = store_thm( `LENGTH s' < LENGTH s` by metis_tac [peg_eval_suffix'] >> metis_tac [peg_eval_rules, reducing_peg_eval_makes_list]) +(* derived and useful PEG forms *) +val pegf_def = Define`pegf sym f = seq sym (empty ARB) (λl1 l2. f l1)` + +val ignoreL_def = Define` + ignoreL s1 s2 = seq s1 s2 (λa b. b) +`; +val _ = set_mapped_fixity{fixity = Infixl 500, term_name = "ignoreL", + tok = ">>"} + +val ignoreR_def = Define` + ignoreR s1 s2 = seq s1 s2 (λa b. a) +`; +val _ = set_mapped_fixity{fixity = Infixl 500, term_name = "ignoreR", + tok = "<<"} + +val choicel_def = Define` + (choicel [] = not (empty ARB) ARB) ∧ + (choicel (h::t) = choice h (choicel t) (λs. sum_CASE s I I)) +`; + +val checkAhead_def = Define` + checkAhead P s = not (not (tok P ARB) ARB) ARB >> s +`; + val _ = export_theory() diff --git a/examples/parsing/selftest.sml b/examples/parsing/selftest.sml new file mode 100644 index 0000000000..8e1c438438 --- /dev/null +++ b/examples/parsing/selftest.sml @@ -0,0 +1,55 @@ +open HolKernel Parse boolLib simpLib bossLib +open testutils + +local + open pegLib simpleSexpPEGTheory pegexecTheory + val ds = derive_compset_distincts ``:sexpNT`` + val lookups = derive_lookup_ths {pegth = sexpPEG_def, ntty = ``:sexpNT``, + simp = SIMP_CONV (srw_ss())} + val _ = computeLib.add_funs (ds::lookups) + val _ = let + open computeLib + in + set_skip the_compset ``evalcase_CASE`` (SOME 1); + set_skip the_compset ``option_CASE`` (SOME 1); + set_skip the_compset ``COND`` (SOME 1) + end +in +fun test0 nt s = let + val str_t = stringSyntax.fromMLstring s + val th = EVAL ``peg_exec sexpPEG (pnt ^nt) ^str_t [] done failed`` +in + rhs (concl th) +end +end (* local *) + +fun test (s, exp) = let + val result = test0 ``sxnt_sexp`` s + val exp_t = ``Result (SOME ("", ^exp)) : (char, sexpNT, sexp) evalcase`` +in + tprint (s ^ " --> " ^ term_to_string result); + if aconv exp_t result then print "OK\n" else die "FAILED\n" +end +val _ = temp_overload_on ("Ok", ``λt. Result (SOME ("", t))``) + +val _ = print "\n" before app test [ + ("123", ``123s``), + ("(123)", ``⦇123⦈``), + (" (123 10) ", ``⦇123; 10⦈``), + (" (123 10 (1 2 3)) ", ``⦇ 123; 10; ⦇1; 2; 3⦈ ⦈``), + (" ( (123 10 )) ", ``⦇ ⦇ 123; 10 ⦈ ⦈``), + ("'(1 2)", ``’ ⦇1; 2⦈``), + ("(1(2(3)))", ``⦇1; ⦇ 2; ⦇ 3 ⦈ ⦈ ⦈``), + ("'1", ``’ 1``), + ("foo", ``SX_SYM "foo"``), + ("(foo)", ``⦇SX_SYM "foo"⦈``), + ("()", ``nil``), + ("(foo )", ``⦇SX_SYM "foo"⦈``), + ("foo2", ``SX_SYM "foo2"``), + ("(foo bar 3 4)", ``⦇ SX_SYM "foo"; SX_SYM "bar"; 3; 4 ⦈``), + ("(3 . 4)", ``SX_CONS 3 4``), + ("\"foo bar\"", ``SX_STR "foo bar"``), + ("( \" foo \" \"bar\" )", ``⦇ SX_STR " foo "; SX_STR "bar" ⦈``), + ("\"foo\\\"\"", ``SX_STR "foo\""``), + ("\"foo\\\\\"", ``SX_STR "foo\\"``) +] diff --git a/examples/parsing/simpleSexpPEGScript.sml b/examples/parsing/simpleSexpPEGScript.sml new file mode 100644 index 0000000000..59f1ddb993 --- /dev/null +++ b/examples/parsing/simpleSexpPEGScript.sml @@ -0,0 +1,65 @@ +open HolKernel Parse boolLib bossLib; + +open simpleSexpTheory + +val _ = new_theory "simpleSexpPEG"; + +val tokeq_def = Define`tokeq t = tok ((=) t) (K (SX_SYM [t]))` +val grabWS_def = Define` + grabWS s = rpt (tok isSpace ARB) (K ARB) >> s +`; + +val pnt_def = Define`pnt ntsym = nt (mkNT ntsym) I` + +val isFirstSymChar_def = Define` + isFirstSymChar c ⇔ isGraph c ∧ ¬isDigit c ∧ c ∉ {#"("; #"'"; #")"; #"."} +`; + +val sexpPEG_def = zDefine` + sexpPEG : (char, sexpNT, sexp) peg = <| + start := pnt sxnt_sexp ; + rules := + FEMPTY |++ + [(mkNT sxnt_sexp, pnt sxnt_WSsexp << rpt (tok isSpace ARB) (K ARB)); + (mkNT sxnt_sexp0, + choicel [ + pnt sxnt_sexpnum ; + tokeq #"(" >> pnt sxnt_sexpseq << grabWS (tokeq #")") ; + seq (tokeq #"(" >> pnt sxnt_WSsexp) + (grabWS (tokeq #".") >> pnt sxnt_WSsexp << grabWS (tokeq #")")) + SX_CONS ; + tokeq #"\"" >> pnt sxnt_strcontents << tokeq #"\"" ; + pegf (tokeq #"'" >> grabWS (pnt sxnt_sexp0)) + (λs. ⦇ SX_SYM "quote"; s⦈) ; + pnt sxnt_sexpsym + ]); + (mkNT sxnt_sexpseq, + rpt (pnt sxnt_WSsexp) (FOLDR SX_CONS (SX_SYM "nil"))); + (mkNT sxnt_WSsexp, + rpt (tok isSpace ARB) (K ARB) >> pnt sxnt_sexp0); + (mkNT sxnt_sexpnum, + checkAhead isDigit + (rpt (pnt sxnt_digit) + (SX_NUM o FOLDL (λa d. 10 * a + destSXNUM d) 0))) ; + (mkNT sxnt_digit, tok isDigit (λc. SX_NUM (ORD c - ORD #"0"))) ; + (mkNT sxnt_sexpsym, + seq (tok isFirstSymChar (λc. SX_SYM [c])) + (rpt (tok (λc. isGraph c ∧ c ∉ {#"("; #")"; #"'"}) (λc. SX_SYM [c])) + (SX_SYM o FOLDR (λs a. destSXSYM s ++ a) [])) + (λs1 s2. SX_SYM (destSXSYM s1 ++ destSXSYM s2))); + (mkNT sxnt_strcontents, + rpt (pnt sxnt_strchar) (SX_STR o FOLDR (λs a. destSXSYM s ++ a) [])); + (mkNT sxnt_strchar, + choicel [ + tokeq #"\\" >> pnt sxnt_escapedstrchar ; + pnt sxnt_normstrchar + ]); + (mkNT sxnt_escapedstrchar, choicel [tokeq #"\\"; tokeq #"\""]); + (mkNT sxnt_normstrchar, + tok (λc. isPrint c ∧ c ≠ #"\"" ∧ c ≠ #"\\") (λc. SX_SYM [c])) + ] + |> +`; + + +val _ = export_theory(); diff --git a/examples/parsing/simpleSexpScript.sml b/examples/parsing/simpleSexpScript.sml new file mode 100644 index 0000000000..9d7fd194b5 --- /dev/null +++ b/examples/parsing/simpleSexpScript.sml @@ -0,0 +1,135 @@ +open HolKernel Parse boolLib bossLib; + +local open stringLib in end + +open grammarLib +open monadsyntax lcsymtacs pegTheory + +val _ = new_theory "simpleSexp"; + +val _ = overload_on ("monad_bind", ``OPTION_BIND``) +val _ = overload_on ("monad_unitbind", ``OPTION_IGNORE_BIND``) +val _ = temp_overload_on ("return", ``SOME``) +val _ = temp_overload_on ("SOME", ``SOME``) + +val _ = computeLib.add_persistent_funs ["option.OPTION_BIND_def", + "option.OPTION_IGNORE_BIND_def", + "option.OPTION_GUARD_def", + "option.OPTION_CHOICE_def"] + +val _ = overload_on ("assert", ``option$OPTION_GUARD : bool -> unit option``) +val _ = overload_on ("++", ``option$OPTION_CHOICE``) + + +val _ = Datatype` + sexp = SX_CONS sexp sexp + | SX_SYM string + | SX_NUM num + | SX_STR string +`; + +val _ = add_numeral_form(#"s", SOME "SX_NUM") +val _ = overload_on ("nil", ``SX_SYM "nil"``) +val _ = add_listform { block_info = (PP.INCONSISTENT, 0), + cons = "SX_CONS", leftdelim = [Parse.TOK "⦇"], + nilstr = "nil", rightdelim = [Parse.TOK "⦈"], + separator = [Parse.TOK ";", BreakSpace(1,0)]} + +val _ = add_rule { block_style = (AroundEachPhrase, (PP.INCONSISTENT, 0)), + fixity = Closefix, + paren_style = OnlyIfNecessary, + pp_elements = [Parse.TOK "⦇", TM, HardSpace 1, + Parse.TOK "•", BreakSpace(1, 0), TM, + Parse.TOK "⦈"], + term_name = "SX_CONS" } + + +val _ = overload_on ("’", ``λs. ⦇ SX_SYM "quote" ; s ⦈``) + +val destSXNUM_def = Define` + destSXNUM (SX_NUM n) = n +`; + +val destSXSYM_def = Define` + destSXSYM (SX_SYM s) = s +`; + +val tokmap = List.foldl (fn ((s,t), acc) => Binarymap.insert(acc, s, t)) + (Binarymap.mkDict String.compare) + [("(", ``#"("``), (")", ``#")"``), ("'", ``#"'"``), + ("\"", ``#"\""``), ("\\", ``#"\\"``), (".", ``#"."``)] + +fun toklookup s = + Binarymap.find(tokmap, s) + handle Binarymap.NotFound => raise Fail ("No tok def for "^s) + +val ginfo = { tokmap = toklookup, + tokty = ``:char``, nt_tyname = "sexpNT", start = "sexp", + gname = "sexpG", mkntname = (fn s => "sxnt_" ^ s) } + + +val sexpG_def = mk_grammar_def ginfo ` + sexp ::= WSsexp grabWS ; + WSsexp ::= grabWS sexp0 ; + grabWS ::= WS grabWS | ; + WS ::= ^(``{ c | isSpace c }``) ; + sexp0 ::= sexpsym | sexpnum | sexpstr | "(" sexpseq grabWS ")" + | "(" sexp "." sexp ")" | "'" WSsexp ; + + sexpseq ::= WSsexp sexpseq | ; + + sexpnum ::= sexpnum digit | digit ; + digit ::= ^(``{ c | isDigit c}``); + + sexpstr ::= "\"" strcontents "\"" ; + strcontents ::= | strchar strcontents ; + strchar ::= normstrchar | escapedstrchar ; + normstrchar ::= ^(``{ c | isPrint c ∧ c ≠ #"\\" ∧ c ≠ #"\"" }``) ; + escapedstrchar ::= "\\" escapablechar ; + escapablechar ::= "\\" | "\"" ; + + sexpsym ::= first_symchar symchars ; + first_symchar ::= + ^(``{ c | isGraph c ∧ c ∉ {#"'"; #"("; #")"} ∧ ¬isDigit c}``) ; + symchars ::= symchar symchars | ; + symchar ::= ^(``{ c | isGraph c ∧ c ∉ {#"'"; #"("; #")"}}``); +`; + +val _ = type_abbrev("NT", ``:sexpNT inf``) +val _ = overload_on("mkNT", ``INL : sexpNT -> NT``) +val _ = overload_on ("TK", ``TOK : char -> (char,sexpNT)symbol``) + + +val ptree_digit_def = Define` + (ptree_digit (Lf _) = NONE) ∧ + (ptree_digit (Nd ntm args) = + if ntm ≠ mkNT sxnt_digit then NONE + else + case args of + [Lf tksym] => + do + c <- destTOK tksym ; + return (ORD c - ORD #"0") + od + | _ => NONE) +`; + +val ptree_sexpnum_def = Define` + (ptree_sexpnum (Lf _) = NONE) ∧ + (ptree_sexpnum (Nd ntm args) = + if ntm ≠ mkNT sxnt_sexpnum then NONE + else + case args of + [d] => ptree_digit d + | [sn; d] => + do + dn <- ptree_digit d ; + snn <- ptree_sexpnum sn ; + return (10 * snn + dn) + od + | _ => NONE) +`; + + + +val _ = export_theory() From d9207a999b47064ef15eeb3b85f6ecfc858e6a73 Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Thu, 2 Jul 2015 10:06:13 +0100 Subject: [PATCH 354/718] Allow matching over integer literals. Changes the mechanism for supporting new literals. --- src/integer/integerScript.sml | 16 +++++++++++++--- src/n-bit/wordsLib.sml | 7 +------ src/parse/Literal.sig | 2 +- src/parse/Literal.sml | 11 ++++++----- 4 files changed, 21 insertions(+), 15 deletions(-) diff --git a/src/integer/integerScript.sml b/src/integer/integerScript.sml index 43fe952d54..cb1c312b6f 100644 --- a/src/integer/integerScript.sml +++ b/src/integer/integerScript.sml @@ -3400,8 +3400,18 @@ val _ = adjoin_to_theory {sig_ps = NONE, ["val _ = TypeBase.write [TypeBasePure.mk_nondatatype_info", " (``:int``, {nchotomy = SOME INT_NUM_CASES,", " induction = NONE,", - " encode = NONE, size = NONE})];"])} - -val _ = export_theory(); + " encode = NONE, size = NONE})];", + "", + "val () = Literal.add_literal", + " (fn tm =>", + " case Lib.total boolSyntax.dest_strip_comb tm of", + " SOME (\"integer$int_of_num\", [n]) => numSyntax.is_numeral n", + " | SOME (\"integer$int_neg\", [n]) =>", + " (case Lib.total boolSyntax.dest_strip_comb n of", + " SOME (\"integer$int_of_num\", [n]) => numSyntax.is_numeral n", + " | _ => false)", + " | _ => false)"])} + +val _ = export_theory() end diff --git a/src/n-bit/wordsLib.sml b/src/n-bit/wordsLib.sml index f274ed3514..7f8ab85328 100644 --- a/src/n-bit/wordsLib.sml +++ b/src/n-bit/wordsLib.sml @@ -43,12 +43,7 @@ fun is_uintmax t = (* Tell the function definition mechanism about words. *) (*---------------------------------------------------------------------------*) -val () = - let - val others = !Literal.other_literals - in - Literal.other_literals := (fn x => others x orelse is_word_literal x) - end +val () = Literal.add_literal is_word_literal (* ------------------------------------------------------------------------- *) diff --git a/src/parse/Literal.sig b/src/parse/Literal.sig index abd3052b00..bc4b1f6b44 100644 --- a/src/parse/Literal.sig +++ b/src/parse/Literal.sig @@ -26,7 +26,7 @@ sig val is_literal : term -> bool val is_pure_literal : term -> bool - val other_literals : (term -> bool) ref + val add_literal : (term -> bool) -> unit val relaxed_dest_numeral : term -> Arbnum.num val relaxed_dest_string_lit : term -> String.string diff --git a/src/parse/Literal.sml b/src/parse/Literal.sml index f106450606..8f878c8b76 100644 --- a/src/parse/Literal.sml +++ b/src/parse/Literal.sml @@ -232,11 +232,12 @@ end (* patterns. *) (*---------------------------------------------------------------------------*) -val other_literals = ref (fn _:term => false); - -fun is_literal tm = - is_numeral tm orelse is_string_lit tm orelse is_char_lit tm - orelse !other_literals tm +local + val literals = ref [is_numeral, is_string_lit, is_char_lit] +in + fun add_literal is_lit = literals := !literals @ [is_lit] + fun is_literal tm = List.exists (fn f => f tm) (!literals) +end fun is_pure_literal x = is_literal x andalso not (is_zero x) andalso not (is_string_lit x); From 4a31d995c10b4ca25550e7aed0b972ea0cd0cbc6 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 3 Jul 2015 11:18:56 +1000 Subject: [PATCH 355/718] Document dest_strip_comb and dest_term --- help/Docfiles/HolKernel.dest_term.doc | 33 ++++++++++++++++++ help/Docfiles/boolSyntax.dest_strip_comb.doc | 35 ++++++++++++++++++++ 2 files changed, 68 insertions(+) create mode 100644 help/Docfiles/HolKernel.dest_term.doc create mode 100644 help/Docfiles/boolSyntax.dest_strip_comb.doc diff --git a/help/Docfiles/HolKernel.dest_term.doc b/help/Docfiles/HolKernel.dest_term.doc new file mode 100644 index 0000000000..1c8ff9ec20 --- /dev/null +++ b/help/Docfiles/HolKernel.dest_term.doc @@ -0,0 +1,33 @@ +\DOC + +\TYPE {dest_term : term -> lambda} + +\SYNOPSIS +Breaks terms into a type with SML constructors for pattern-matching. + +\KEYWORDS + +\DESCRIBE +A call to {dest_term t} returns a value of type {lambda}, which has SML definition +{ + datatype lambda = + VAR of string * term + | CONST of {Name:string, Thy:string, Ty:hol_type} + | COMB of term * term + | LAMB of term * term +} +This type encodes all possible forms of {term}. + +\FAILURE +Never fails. + +\EXAMPLE +{ +> dest_term ``SUC 2``; +val it = COMB (``SUC``, ``2``) : lambda +} + +\SEEALSO +Term.dest_abs, Term.dest_comb, Term.dest_const, boolSyntax.dest_strip_comb, Term.dest_thy_const, Term.dest_var. + +\ENDDOC diff --git a/help/Docfiles/boolSyntax.dest_strip_comb.doc b/help/Docfiles/boolSyntax.dest_strip_comb.doc new file mode 100644 index 0000000000..65b14e198f --- /dev/null +++ b/help/Docfiles/boolSyntax.dest_strip_comb.doc @@ -0,0 +1,35 @@ +\DOC + +\TYPE {dest_strip_comb : term -> string * term list} + +\SYNOPSIS +Strips a function application, and breaks head constant. + +\KEYWORDS + +\DESCRIBE +If {t} is a term of the form {c t1 t2 .. tn}, with {c} a constant, +then a call to {dest_strip_comb t} returns a pair {(s,[t1,...,tn])}, +where {s} is a string of the form {thy$name}. The {thy} prefix +identifies the theory where the constant was defined, and the {name} +suffix is the constant’s name. + +\FAILURE +Fails if the term is not a constant applied to zero or more arguments. + +\EXAMPLE +{ +> dest_strip_comb ``SUC 2``; +val it = ("num$SUC", [``2``]) : string * term list +} + +\COMMENTS +Useful for pattern-matching at the ML level, where doing a {case} on +{Lib.total dest_strip_comb t} allows patterns of interest to be +idiomatically identified. In the absence of view-patterns in SML, one +has to use custom destructors. + +\SEEALSO +HolKernel.dest_term. + +\ENDDOC From e18e7151f99ae7f96ee62d53f5c5293c11777bd1 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 3 Jul 2015 11:20:57 +1000 Subject: [PATCH 356/718] Fill a paragraph in documentation of dest_term Should probably adjust Doc2Txt to do this for us (other output formats don't care about newlines as they do their own filling). --- help/Docfiles/HolKernel.dest_term.doc | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/help/Docfiles/HolKernel.dest_term.doc b/help/Docfiles/HolKernel.dest_term.doc index 1c8ff9ec20..2ddce59a4a 100644 --- a/help/Docfiles/HolKernel.dest_term.doc +++ b/help/Docfiles/HolKernel.dest_term.doc @@ -8,7 +8,8 @@ Breaks terms into a type with SML constructors for pattern-matching. \KEYWORDS \DESCRIBE -A call to {dest_term t} returns a value of type {lambda}, which has SML definition +A call to {dest_term t} returns a value of type {lambda}, which has +SML definition { datatype lambda = VAR of string * term From 07421c10dcef8567dc01c52f473f34ac0a72ad7f Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Fri, 3 Jul 2015 11:14:04 +0100 Subject: [PATCH 357/718] Add a small theory about address alignment. This will eventually be used to rationalise examples in l3-machine-code/. --- src/n-bit/alignmentScript.sml | 333 ++++++++++++++++++++++++++++++++++ src/n-bit/wordsScript.sml | 8 + 2 files changed, 341 insertions(+) create mode 100644 src/n-bit/alignmentScript.sml diff --git a/src/n-bit/alignmentScript.sml b/src/n-bit/alignmentScript.sml new file mode 100644 index 0000000000..9a5ddef271 --- /dev/null +++ b/src/n-bit/alignmentScript.sml @@ -0,0 +1,333 @@ +(* ========================================================================= *) +(* FILE : alignmentScript.sml *) +(* DESCRIPTION : Theory for address alignment. *) +(* ========================================================================= *) + +open HolKernel Parse boolLib bossLib Q +open lcsymtacs +open wordsLib + +val () = Theory.new_theory "alignment"; + +(* ------------------------------------------------------------------------- + Constant definitions + ------------------------------------------------------------------------- *) + +val align_def = Define `align p (w: 'a word) = (dimindex (:'a) - 1 '' p) w` +val aligned_def = Define `aligned p w = (align p w = w)` + +val byte_align_def = Define` + byte_align (w: 'a word) = align (LOG2 (dimindex(:'a) DIV 8)) w` + +val byte_aligned_def = Define` + byte_aligned (w: 'a word) = aligned (LOG2 (dimindex(:'a) DIV 8)) w` + +(* ------------------------------------------------------------------------- + Theorems + ------------------------------------------------------------------------- *) + +val align_0 = Q.store_thm("align_0", + `!w. align 0 w = w`, + lrw [wordsTheory.WORD_SLICE_BITS_THM, wordsTheory.WORD_ALL_BITS, align_def] + ) + +val align_align = Q.store_thm("align_align", + `!p w. align p (align p w) = align p w`, + srw_tac [wordsLib.WORD_BIT_EQ_ss, boolSimps.CONJ_ss] [align_def] + ) + +val aligned_align = Q.store_thm ("aligned_align", + `!p w. aligned p (align p w)`, + rewrite_tac [aligned_def, align_align] + ) + +val align_bitwise_and = Q.store_thm("align_bitwise_and", + `!p w. align p w = w && UINT_MAXw << p`, + srw_tac [wordsLib.WORD_BIT_EQ_ss] [align_def] + \\ decide_tac + ) + +val align_shift = Q.store_thm("align_shift", + `!p w. align p w = w >>> p << p`, + srw_tac [wordsLib.WORD_BIT_EQ_ss] [align_def] + \\ Cases_on `p <= i` + \\ simp [] + ) + +val align_w2n = Q.store_thm("align_w2n", + `!p w. align p w = n2w (w2n w DIV 2 ** p * 2 ** p)`, + strip_tac + \\ Cases + \\ lrw [align_shift, GSYM wordsTheory.n2w_DIV, wordsTheory.word_lsl_n2w, + wordsTheory.dimword_def] + \\ `dimindex(:'a) <= p` by decide_tac + \\ imp_res_tac arithmeticTheory.LESS_EQUAL_ADD + \\ simp [arithmeticTheory.EXP_ADD, arithmeticTheory.MOD_EQ_0] + ) + +val ths = [GSYM wordsTheory.WORD_w2w_EXTRACT, wordsTheory.w2w_id] + +val lem = + wordsTheory.EXTRACT_JOIN_ADD + |> Thm.INST_TYPE [Type.beta |-> Type.alpha] + |> Q.SPECL [`dimindex(:'a) - 1`, `p - 1`, `p`, `0`, `p`, `w`] + |> Q.DISCH `0 < p` + |> SIMP_RULE (srw_ss()) (DECIDE ``0 < p ==> (p = p - 1 + 1)`` :: ths) + |> GSYM + +val align_sub = Q.store_thm("align_sub", + `!p w. align p w = if p = 0 then w else w - (p - 1 >< 0) w`, + rw_tac bool_ss [align_0] + \\ Cases_on `dimindex(:'a) <= p - 1` + >- ( + `(p − 1 >< 0) w : 'a word = (dimindex (:'a) - 1 >< 0) w` + by simp [wordsTheory.WORD_EXTRACT_MIN_HIGH] + \\ rule_assum_tac (SIMP_RULE (srw_ss()) ths) + \\ asm_rewrite_tac [] + \\ srw_tac [wordsLib.WORD_BIT_EQ_ss] [align_def] + ) + \\ Cases_on `p = dimindex(:'a)` + >- srw_tac [wordsLib.WORD_BIT_EQ_ss] (align_def :: ths) + \\ `0 < p /\ p <= dimindex (:'a) - 1` by decide_tac + \\ imp_res_tac lem + \\ pop_assum (qspec_then `w` (CONV_TAC o Conv.PATH_CONV "rlr" o Lib.K)) + \\ srw_tac [wordsLib.WORD_EXTRACT_ss] [align_def] + ) + +val aligned_extract = Q.store_thm ("aligned_extract", + `!p w. aligned p (w: 'a word) = (p = 0) \/ ((p - 1 >< 0) w = 0w: 'a word)`, + rewrite_tac [aligned_def] + \\ Cases + >- rewrite_tac [align_0] + \\ srw_tac [wordsLib.WORD_BIT_EQ_ss] [align_def] + \\ eq_tac + \\ lrw [] + \\ res_tac + \\ Cases_on `i <= n` + \\ Cases_on `w ' i` + \\ fs [] + \\ decide_tac + ) + +val aligned_0 = Q.store_thm ("aligned_0", + `(!p. aligned p 0w) /\ (!w. aligned 0 w)`, + srw_tac [wordsLib.WORD_BIT_EQ_ss] [aligned_extract] + ) + +val aligned_1_lsb = Q.store_thm ("aligned_1_lsb", + `!w. aligned 1 w = ~word_lsb w`, + srw_tac [wordsLib.WORD_BIT_EQ_ss] [aligned_extract] + ) + +val aligned_ge_dim = Q.store_thm ("aligned_ge_dim", + `!p w:'a word. dimindex(:'a) <= p ==> (aligned p w = (w = 0w))`, + Cases \\ srw_tac [wordsLib.WORD_BIT_EQ_ss] [aligned_extract] + ) + +val aligned_bitwise_and = Q.store_thm("aligned_bitwise_and", + `!p w. aligned p (w: 'a word) = (w && n2w (2 ** p - 1) = 0w)`, + simp [aligned_def, align_bitwise_and] + \\ srw_tac [wordsLib.WORD_BIT_EQ_ss] + [wordsTheory.word_index, bitTheory.BIT_EXP_SUB1] + \\ eq_tac + \\ lrw [] + \\ res_tac + \\ Cases_on `i < SUC n` + \\ Cases_on `w ' i` + \\ fs [] + \\ decide_tac + ) + +val aligned_bit_count_upto = Q.store_thm ("aligned_bit_count_upto", + `!p w. + aligned p (w: 'a word) = (bit_count_upto (MIN (dimindex(:'a)) p) w = 0)`, + lrw [aligned_extract, wordsTheory.bit_count_upto_is_zero] + \\ srw_tac [wordsLib.WORD_BIT_EQ_ss] [] + \\ Cases_on `p = 0` + \\ simp [] + \\ eq_tac + \\ lrw [] + \\ res_tac + >- decide_tac + \\ Cases_on `i < p` + \\ fs [] + \\ decide_tac + ) + +val aligned_add_sub = Q.store_thm("aligned_add_sub", + `!p a: 'a word b. + aligned p b ==> + (aligned p (a + b) = aligned p a) /\ + (aligned p (a - b) = aligned p a)`, + strip_tac + \\ Cases_on `dimindex(:'a) <= p` + >- simp [aligned_ge_dim] + \\ `p < dimindex(:'a)` by decide_tac + \\ Cases_on `p` + \\ simp [aligned_extract] + \\ Cases_on `SUC n = dimindex(:'a)` + \\ srw_tac [wordsLib.WORD_EXTRACT_ss] [] + \\ simp [Once (GSYM wordsTheory.WORD_EXTRACT_OVER_ADD2), + Once (GSYM wordsTheory.WORD_EXTRACT_OVER_MUL2)] + \\ lrw [wordsTheory.WORD_EXTRACT_COMP_THM, arithmeticTheory.MIN_DEF] + \\ metis_tac [arithmeticTheory.SUC_SUB1] + ) + +val aligned_add_sub_cor = Q.store_thm("aligned_add_sub_cor", + `!p a: 'a word b. + aligned p a /\ aligned p b ==> aligned p (a + b) /\ aligned p (a - b)`, + metis_tac [aligned_add_sub] + ) + +val aligned_mul_shift_1 = Q.store_thm ("aligned_mul_shift_1", + `!p w: 'a word. aligned p (1w << p * w)`, + strip_tac + \\ Cases_on `dimindex(:'a) <= p` + >- simp [aligned_ge_dim] + \\ `p < dimindex(:'a)` by decide_tac + \\ Cases_on `p` + \\ srw_tac [ARITH_ss] + [aligned_extract, + Once (GSYM wordsTheory.WORD_EXTRACT_OVER_MUL2)] + \\ `(n >< 0) ((1w:'a word) << SUC n) = 0w: 'a word` + by lrw [wordsTheory.WORD_MUL_LSL, wordsTheory.word_extract_n2w, + arithmeticTheory.MIN_DEF, + bitTheory.BITS_SUM2 + |> Q.SPECL [`n`, `0`, `1`, `0`] + |> SIMP_RULE (srw_ss()) []] + \\ simp [wordsTheory.WORD_EXTRACT_COMP_THM, arithmeticTheory.MIN_DEF] + ) + +val aligned_add_sub_prod = Q.store_thm("aligned_add_sub_prod", + `!p w: 'a word x. + (aligned p (w + (1w << p) * x) = aligned p w) /\ + (aligned p (w - (1w << p) * x) = aligned p w)`, + metis_tac [aligned_add_sub, aligned_mul_shift_1, wordsTheory.WORD_ADD_COMM] + ) + +(* ------------------------------------------------------------------------- + Theorems for standard alignment lengths of 1, 2 and 3 bits + ------------------------------------------------------------------------- *) + +fun f p = + let + val th1 = + aligned_add_sub_prod + |> Q.SPEC p + |> SIMP_RULE std_ss [fcpTheory.DIMINDEX_GE_1, wordsTheory.word_1_lsl] + val th2 = th1 |> Q.SPEC `0w` |> SIMP_RULE (srw_ss()) [aligned_0] + in + [th1, th2] + end + +val aligned_add_sub_123 = Theory.save_thm ("aligned_add_sub_123", + LIST_CONJ (List.concat (List.map f [`1`, `2`, `3`])) + ) + +local + val bit_lem = Q.prove( + `(!x. NUMERAL (BIT2 x) = 2 * (x + 1)) /\ + (!x. NUMERAL (BIT1 x) = 2 * x + 1) /\ + (!x. NUMERAL (BIT1 (BIT1 x)) = 4 * x + 3) /\ + (!x. NUMERAL (BIT1 (BIT2 x)) = 4 * (x + 1) + 1) /\ + (!x. NUMERAL (BIT2 (BIT1 x)) = 4 * (x + 1)) /\ + (!x. NUMERAL (BIT2 (BIT2 x)) = 4 * (x + 1) + 2) /\ + (!x. NUMERAL (BIT1 (BIT1 (BIT1 x))) = 8 * x + 7) /\ + (!x. NUMERAL (BIT1 (BIT1 (BIT2 x))) = 8 * (x + 1) + 3) /\ + (!x. NUMERAL (BIT1 (BIT2 (BIT1 x))) = 8 * (x + 1) + 1) /\ + (!x. NUMERAL (BIT1 (BIT2 (BIT2 x))) = 8 * (x + 1) + 5) /\ + (!x. NUMERAL (BIT2 (BIT1 (BIT1 x))) = 8 * (x + 1)) /\ + (!x. NUMERAL (BIT2 (BIT1 (BIT2 x))) = 8 * (x + 1) + 4) /\ + (!x. NUMERAL (BIT2 (BIT2 (BIT1 x))) = 8 * (x + 1) + 2) /\ + (!x. NUMERAL (BIT2 (BIT2 (BIT2 x))) = 8 * (x + 1) + 6)`, + REPEAT strip_tac + \\ CONV_TAC (Conv.LHS_CONV + (REWRITE_CONV [arithmeticTheory.BIT1, arithmeticTheory.BIT2, + arithmeticTheory.NUMERAL_DEF])) + \\ decide_tac + ) + val (_, _, dest_num, _) = HolKernel.syntax_fns1 "arithmetic" "NUMERAL" +in + fun bit_lem_conv tm = + let + val x = dest_num (fst (wordsSyntax.dest_n2w tm)) + in + if List.null (Term.free_vars x) + then raise ERR "bit_lem_conv" "" + else Conv.RAND_CONV (ONCE_REWRITE_CONV [bit_lem]) tm + end +end + +val aligned_numeric = Q.store_thm("aligned_numeric", + `(!x. aligned 3 (n2w (NUMERAL (BIT2 (BIT1 (BIT1 x)))))) /\ + (!x. aligned 2 (n2w (NUMERAL (BIT2 (BIT1 x))))) /\ + (!x. aligned 1 (n2w (NUMERAL (BIT2 x)))) /\ + (!x. aligned 3 (-n2w (NUMERAL (BIT2 (BIT1 (BIT1 x)))))) /\ + (!x. aligned 2 (-n2w (NUMERAL (BIT2 (BIT1 x))))) /\ + (!x. aligned 1 (-n2w (NUMERAL (BIT2 x)))) /\ + (!x y f. aligned 3 (y + n2w (NUMERAL (BIT1 (BIT1 (BIT1 (f x)))))) = + aligned 3 (y + 7w)) /\ + (!x y f. aligned 3 (y + n2w (NUMERAL (BIT1 (BIT1 (BIT2 x))))) = + aligned 3 (y + 3w)) /\ + (!x y f. aligned 3 (y + n2w (NUMERAL (BIT1 (BIT2 (BIT1 x))))) = + aligned 3 (y + 1w)) /\ + (!x y f. aligned 3 (y + n2w (NUMERAL (BIT1 (BIT2 (BIT2 x))))) = + aligned 3 (y + 5w)) /\ + (!x y f. aligned 3 (y + n2w (NUMERAL (BIT2 (BIT1 (BIT1 x))))) = + aligned 3 (y)) /\ + (!x y f. aligned 3 (y + n2w (NUMERAL (BIT2 (BIT1 (BIT2 x))))) = + aligned 3 (y + 4w)) /\ + (!x y f. aligned 3 (y + n2w (NUMERAL (BIT2 (BIT2 (BIT1 x))))) = + aligned 3 (y + 2w)) /\ + (!x y f. aligned 3 (y + n2w (NUMERAL (BIT2 (BIT2 (BIT2 x))))) = + aligned 3 (y + 6w)) /\ + (!x y f. aligned 3 (y - n2w (NUMERAL (BIT1 (BIT1 (BIT1 (f x)))))) = + aligned 3 (y - 7w)) /\ + (!x y f. aligned 3 (y - n2w (NUMERAL (BIT1 (BIT1 (BIT2 x))))) = + aligned 3 (y - 3w)) /\ + (!x y f. aligned 3 (y - n2w (NUMERAL (BIT1 (BIT2 (BIT1 x))))) = + aligned 3 (y - 1w)) /\ + (!x y f. aligned 3 (y - n2w (NUMERAL (BIT1 (BIT2 (BIT2 x))))) = + aligned 3 (y - 5w)) /\ + (!x y f. aligned 3 (y - n2w (NUMERAL (BIT2 (BIT1 (BIT1 x))))) = + aligned 3 (y)) /\ + (!x y f. aligned 3 (y - n2w (NUMERAL (BIT2 (BIT1 (BIT2 x))))) = + aligned 3 (y - 4w)) /\ + (!x y f. aligned 3 (y - n2w (NUMERAL (BIT2 (BIT2 (BIT1 x))))) = + aligned 3 (y - 2w)) /\ + (!x y f. aligned 3 (y - n2w (NUMERAL (BIT2 (BIT2 (BIT2 x))))) = + aligned 3 (y - 6w)) /\ + (!x y f. aligned 2 (y + n2w (NUMERAL (BIT1 (BIT1 (f x))))) = + aligned 2 (y + 3w)) /\ + (!x y. aligned 2 (y + n2w (NUMERAL (BIT1 (BIT2 x)))) = + aligned 2 (y + 1w)) /\ + (!x y. aligned 2 (y + n2w (NUMERAL (BIT2 (BIT1 x)))) = + aligned 2 (y)) /\ + (!x y. aligned 2 (y + n2w (NUMERAL (BIT2 (BIT2 x)))) = + aligned 2 (y + 2w)) /\ + (!x y f. aligned 2 (y - n2w (NUMERAL (BIT1 (BIT1 (f x))))) = + aligned 2 (y - 3w)) /\ + (!x y. aligned 2 (y - n2w (NUMERAL (BIT1 (BIT2 x)))) = + aligned 2 (y - 1w)) /\ + (!x y. aligned 2 (y - n2w (NUMERAL (BIT2 (BIT1 x)))) = + aligned 2 (y)) /\ + (!x y. aligned 2 (y - n2w (NUMERAL (BIT2 (BIT2 x)))) = + aligned 2 (y - 2w)) /\ + (!x y f. aligned 1 (y + n2w (NUMERAL (BIT1 (f x)))) = + aligned 1 (y + 1w)) /\ + (!x y f. aligned 1 (y - n2w (NUMERAL (BIT1 (f x)))) = + aligned 1 (y - 1w)) /\ + (!x y. aligned 1 (y + n2w (NUMERAL (BIT2 x))) = aligned 1 y) /\ + (!x y. aligned 1 (y - n2w (NUMERAL (BIT2 x))) = aligned 1 y)`, + REPEAT strip_tac + \\ CONV_TAC (DEPTH_CONV bit_lem_conv) + \\ rewrite_tac + [GSYM wordsTheory.word_mul_n2w, GSYM wordsTheory.word_add_n2w, + wordsLib.WORD_DECIDE ``a + (b * c + d) : 'a word = (a + d) + b * c``, + wordsLib.WORD_DECIDE ``a - (b * c + d) : 'a word = (a - d) - b * c``, + wordsTheory.WORD_NEG_LMUL, aligned_add_sub_123] + ) + +(* ------------------------------------------------------------------------- *) + +val () = Theory.export_theory () diff --git a/src/n-bit/wordsScript.sml b/src/n-bit/wordsScript.sml index 1b2856f752..5e1c90d3f2 100644 --- a/src/n-bit/wordsScript.sml +++ b/src/n-bit/wordsScript.sml @@ -2967,6 +2967,14 @@ val word_lsl_n2w = store_thm("word_lsl_n2w", \\ ASM_SIMP_TAC (std_ss++numSimps.ARITH_AC_ss) [GSYM EXP,SUB1_SUC, MOD_EQ_0,ZERO_MOD,ZERO_LT_TWOEXP,DIMINDEX_GT_0,dimword_def]); +val word_1_lsl = Q.store_thm("word_1_lsl", + `!n. 1w << n = n2w (2 ** n)`, + lrw [word_lsl_n2w, dimword_def] + \\ `dimindex (:'a) <= n` by decide_tac + \\ imp_res_tac arithmeticTheory.LESS_EQUAL_ADD + \\ simp [arithmeticTheory.EXP_ADD, arithmeticTheory.MOD_EQ_0] + ) + val word_lsr_n2w = store_thm("word_lsr_n2w", `!w:'a word n. w >>> n = (^HB -- n) w`, SIMP_TAC arith_ss [word_lsr_def,word_bits_def,MIN_IDEM,DIMINDEX_GT_0, From 0297f747322a56a40d3feb56d8b0e0c1976f3a3e Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 6 Jul 2015 11:34:26 +1000 Subject: [PATCH 358/718] C-{(,)} bindings for paren maps have to go to C-M-{(,)} This is because C-) is already taken for the various "things in circles symbols". --- tools/hol-unicode.el | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/tools/hol-unicode.el b/tools/hol-unicode.el index b16c88afb2..81b7a98de0 100644 --- a/tools/hol-unicode.el +++ b/tools/hol-unicode.el @@ -33,8 +33,8 @@ (define-key global-map (kbd "C-M-_") 'hol-unicode-subscript-map) (define-key global-map (kbd "C-M-^") 'hol-unicode-superscript-map) (define-key global-map (kbd "C-S-M-u") 'hol-unicode-U-map) -(define-key global-map (kbd "C-(") 'hol-unicode-lparen-map) -(define-key global-map (kbd "C-)") 'hol-unicode-rparen-map) +(define-key global-map (kbd "C-M-(") 'hol-unicode-lparen-map) +(define-key global-map (kbd "C-M-)") 'hol-unicode-rparen-map) ;; Greek : C-S- for lower case version of Greek ;; add the Meta modifier for upper case Greek letter. @@ -156,13 +156,13 @@ (define-key hol-unicode-U-map "<" "⊌") ; U+228C called simply "multiset", used in HOL for FUNION ; parenthesis map - for various forms of parenthesis -(define-key hol-unicode-lparen-map (kbd "C-|") "⦇") -(define-key hol-unicode-rparen-map (kbd "C-|") "⦈") -(define-key hol-unicode-lparen-map (kbd "C-(") "⦅") -(define-key hol-unicode-rparen-map (kbd "C-)") "⦆") +(define-key hol-unicode-lparen-map (kbd "C-M-|") "⦇") +(define-key hol-unicode-rparen-map (kbd "C-M-|") "⦈") +(define-key hol-unicode-lparen-map (kbd "C-M-(") "⦅") +(define-key hol-unicode-rparen-map (kbd "C-M-)") "⦆") (define-key hol-unicode-lparen-map (kbd "C-<") "⟨") (define-key hol-unicode-rparen-map (kbd "C->") "⟩") (define-key hol-unicode-lparen-map (kbd "C-M-<") "⟪") (define-key hol-unicode-rparen-map (kbd "C-M->") "⟫") -(define-key hol-unicode-lparen-map (kbd "C-^") "⎡") -(define-key hol-unicode-rparen-map (kbd "C-^") "⎤") +(define-key hol-unicode-lparen-map (kbd "C-M-^") "⎡") +(define-key hol-unicode-rparen-map (kbd "C-M-^") "⎤") From c66b265eaaaaaf640de8a54251786eac158d13e9 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 7 Jul 2015 09:23:05 +1000 Subject: [PATCH 359/718] Add some useful functions for taking apart sexps --- examples/parsing/simpleSexpScript.sml | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/examples/parsing/simpleSexpScript.sml b/examples/parsing/simpleSexpScript.sml index 9d7fd194b5..39afc46409 100644 --- a/examples/parsing/simpleSexpScript.sml +++ b/examples/parsing/simpleSexpScript.sml @@ -54,6 +54,27 @@ val destSXSYM_def = Define` destSXSYM (SX_SYM s) = s `; +val strip_sxcons_def = Define` + strip_sxcons s = + case s of + SX_CONS h t => OPTION_MAP (CONS h) (strip_sxcons t) + | SX_SYM s => if s = "nil" then SOME [] + else NONE + | _ => NONE +`; + +val sxMEM_def = Define` + sxMEM e s ⇔ ∃l. strip_sxcons s = SOME l ∧ MEM e l +`; + +val dstrip_sexp_def = Define` + (dstrip_sexp (SX_CONS sym args) = + case sym of + SX_SYM s => OPTION_MAP (λt. (s, t)) (strip_sxcons args) + | _ => NONE) ∧ + (dstrip_sexp _ = NONE) +`; + val tokmap = List.foldl (fn ((s,t), acc) => Binarymap.insert(acc, s, t)) (Binarymap.mkDict String.compare) [("(", ``#"("``), (")", ``#")"``), ("'", ``#"'"``), From 1a2b32b4e8dd9093a70d847679634cc56fefdb70 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 8 Jul 2015 12:08:32 +1000 Subject: [PATCH 360/718] Replace {<<,>>} with {<~,~>} to avoid clash with words I wanted different fixities for these operators, and there's no real need to get confused with word shift operators. --- examples/parsing/pegScript.sml | 6 +++--- examples/parsing/simpleSexpPEGScript.sml | 18 +++++++++--------- 2 files changed, 12 insertions(+), 12 deletions(-) diff --git a/examples/parsing/pegScript.sml b/examples/parsing/pegScript.sml index 90c95a7f0d..8ab2806f6e 100644 --- a/examples/parsing/pegScript.sml +++ b/examples/parsing/pegScript.sml @@ -336,13 +336,13 @@ val ignoreL_def = Define` ignoreL s1 s2 = seq s1 s2 (λa b. b) `; val _ = set_mapped_fixity{fixity = Infixl 500, term_name = "ignoreL", - tok = ">>"} + tok = "~>"} val ignoreR_def = Define` ignoreR s1 s2 = seq s1 s2 (λa b. a) `; val _ = set_mapped_fixity{fixity = Infixl 500, term_name = "ignoreR", - tok = "<<"} + tok = "<~"} val choicel_def = Define` (choicel [] = not (empty ARB) ARB) ∧ @@ -350,7 +350,7 @@ val choicel_def = Define` `; val checkAhead_def = Define` - checkAhead P s = not (not (tok P ARB) ARB) ARB >> s + checkAhead P s = not (not (tok P ARB) ARB) ARB ~> s `; val _ = export_theory() diff --git a/examples/parsing/simpleSexpPEGScript.sml b/examples/parsing/simpleSexpPEGScript.sml index 59f1ddb993..c7b133fdf1 100644 --- a/examples/parsing/simpleSexpPEGScript.sml +++ b/examples/parsing/simpleSexpPEGScript.sml @@ -6,7 +6,7 @@ val _ = new_theory "simpleSexpPEG"; val tokeq_def = Define`tokeq t = tok ((=) t) (K (SX_SYM [t]))` val grabWS_def = Define` - grabWS s = rpt (tok isSpace ARB) (K ARB) >> s + grabWS s = rpt (tok isSpace ARB) (K ARB) ~> s `; val pnt_def = Define`pnt ntsym = nt (mkNT ntsym) I` @@ -20,23 +20,23 @@ val sexpPEG_def = zDefine` start := pnt sxnt_sexp ; rules := FEMPTY |++ - [(mkNT sxnt_sexp, pnt sxnt_WSsexp << rpt (tok isSpace ARB) (K ARB)); + [(mkNT sxnt_sexp, pnt sxnt_WSsexp <~ rpt (tok isSpace ARB) (K ARB)); (mkNT sxnt_sexp0, choicel [ pnt sxnt_sexpnum ; - tokeq #"(" >> pnt sxnt_sexpseq << grabWS (tokeq #")") ; - seq (tokeq #"(" >> pnt sxnt_WSsexp) - (grabWS (tokeq #".") >> pnt sxnt_WSsexp << grabWS (tokeq #")")) + tokeq #"(" ~> pnt sxnt_sexpseq <~ grabWS (tokeq #")") ; + seq (tokeq #"(" ~> pnt sxnt_WSsexp) + (grabWS (tokeq #".") ~> pnt sxnt_WSsexp <~ grabWS (tokeq #")")) SX_CONS ; - tokeq #"\"" >> pnt sxnt_strcontents << tokeq #"\"" ; - pegf (tokeq #"'" >> grabWS (pnt sxnt_sexp0)) + tokeq #"\"" ~> pnt sxnt_strcontents <~ tokeq #"\"" ; + pegf (tokeq #"'" ~> grabWS (pnt sxnt_sexp0)) (λs. ⦇ SX_SYM "quote"; s⦈) ; pnt sxnt_sexpsym ]); (mkNT sxnt_sexpseq, rpt (pnt sxnt_WSsexp) (FOLDR SX_CONS (SX_SYM "nil"))); (mkNT sxnt_WSsexp, - rpt (tok isSpace ARB) (K ARB) >> pnt sxnt_sexp0); + rpt (tok isSpace ARB) (K ARB) ~> pnt sxnt_sexp0); (mkNT sxnt_sexpnum, checkAhead isDigit (rpt (pnt sxnt_digit) @@ -51,7 +51,7 @@ val sexpPEG_def = zDefine` rpt (pnt sxnt_strchar) (SX_STR o FOLDR (λs a. destSXSYM s ++ a) [])); (mkNT sxnt_strchar, choicel [ - tokeq #"\\" >> pnt sxnt_escapedstrchar ; + tokeq #"\\" ~> pnt sxnt_escapedstrchar ; pnt sxnt_normstrchar ]); (mkNT sxnt_escapedstrchar, choicel [tokeq #"\\"; tokeq #"\""]); From a98923f3515ffe8bf746533d5141f1d5990b7242 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 9 Jul 2015 12:10:55 +1000 Subject: [PATCH 361/718] Allow pretty-printing backends to modify grammar If you know that you are targetting a particular backend, you may wish to also modify the grammars that control pretty-printing. For the moment, just use the identity update in all our backends, so that nothing changes in terms of what the user sees. --- src/TeX/EmitTeX.sml | 2 ++ src/parse/PPBackEnd.sig | 53 ++++-------------------------- src/parse/PPBackEnd.sml | 52 +++++++---------------------- src/parse/smpp.sig | 2 +- src/parse/term_grammar.sig | 3 +- src/parse/term_grammar.sml | 9 ++--- src/parse/term_pp.sml | 2 ++ src/parse/term_pp_types.sml | 65 ++++++++++++++++++++++++++++++++++--- 8 files changed, 90 insertions(+), 98 deletions(-) diff --git a/src/TeX/EmitTeX.sml b/src/TeX/EmitTeX.sml index 355eaced85..d913928740 100644 --- a/src/TeX/EmitTeX.sml +++ b/src/TeX/EmitTeX.sml @@ -386,6 +386,8 @@ in end_block = PP.end_block, begin_style = fn pps => fn sty => () , end_style = fn pps => () , + tm_grammar_upd = (fn g => g), + ty_grammar_upd = (fn g => g), name = "emit_latex"} end; diff --git a/src/parse/PPBackEnd.sig b/src/parse/PPBackEnd.sig index 5109a6f4c7..78e74dc3e0 100644 --- a/src/parse/PPBackEnd.sig +++ b/src/parse/PPBackEnd.sig @@ -5,55 +5,14 @@ sig type ppstream = PP.ppstream type break_style = PP.break_style - datatype pp_color = - Black - | RedBrown - | Green - | BrownGreen - | DarkBlue - | Purple - | BlueGreen - | DarkGrey - | LightGrey - | OrangeRed - | VividGreen - | Yellow - | Blue - | PinkPurple - | LightBlue - | White - datatype pp_style = - FG of pp_color - | BG of pp_color - | Bold - | Underline - | UserStyle of string + datatype lit_type = datatype term_pp_types.lit_type + datatype pp_color = datatype term_pp_types.pp_color + datatype pp_style = datatype term_pp_types.pp_style + datatype annotation = datatype term_pp_types.annotation - datatype lit_type = FldName | StringLit | NumLit | CharLit - - datatype annotation = - BV of hol_type * (unit -> string) - | FV of hol_type * (unit -> string) - | TyV - | TyOp of (unit -> string) - | TySyn of (unit -> string) - | Const of {Thy:string,Name:string,Ty:hol_type * (unit -> string)} - | SymConst of {Thy:string,Name:string,Ty:hol_type * (unit -> string)} - | Note of string - | Literal of lit_type - - type xstring = {s:string,sz:int option,ann:annotation option} - - type t = {add_string : ppstream -> string -> unit, - add_xstring : ppstream -> xstring -> unit, - begin_block : ppstream -> PP.break_style -> int -> unit, - end_block : ppstream -> unit, - add_break : ppstream -> int * int -> unit, - add_newline : ppstream -> unit, - begin_style : ppstream -> pp_style list -> unit, - end_style : ppstream -> unit, - name : string} + type xstring = term_pp_types.xstring + type t = term_grammar.grammar term_pp_types.ppbackend val with_ppstream : t -> ppstream -> {add_break : int * int -> unit, diff --git a/src/parse/PPBackEnd.sml b/src/parse/PPBackEnd.sml index 30a538db98..9c1ecdd39b 100644 --- a/src/parse/PPBackEnd.sml +++ b/src/parse/PPBackEnd.sml @@ -4,52 +4,14 @@ struct type hol_type = Type.hol_type open Portable - +open term_pp_types (* ========================================================================== *) (* Datatypes used by the backends *) (* ========================================================================== *) - datatype lit_type = FldName | StringLit | NumLit | CharLit - - datatype annotation = - BV of hol_type * (unit -> string) - | FV of hol_type * (unit -> string) - | TyV - | TyOp of (unit -> string) - | TySyn of (unit -> string) - | Const of {Thy:string,Name:string,Ty:hol_type * (unit -> string)} - | SymConst of {Thy:string,Name:string,Ty:hol_type * (unit -> string)} - | Note of string - | Literal of lit_type - -(* The default 16 color palette *) -datatype pp_color = - Black | RedBrown | Green | BrownGreen - | DarkBlue | Purple | BlueGreen | DarkGrey - | LightGrey | OrangeRed | VividGreen | Yellow - | Blue | PinkPurple | LightBlue | White; - -datatype pp_style = - FG of pp_color - | BG of pp_color - | Bold - | Underline - | UserStyle of string; - -type xstring = {s:string,sz:int option,ann:annotation option} - -type t = {add_string : ppstream -> string -> unit, - add_xstring : ppstream -> xstring -> unit, - begin_block : ppstream -> PP.break_style -> int -> unit, - end_block : ppstream -> unit, - add_break : ppstream -> int * int -> unit, - add_newline : ppstream -> unit, - begin_style : ppstream -> pp_style list -> unit, - end_style : ppstream -> unit, - name : string} - +type t = term_grammar.grammar term_pp_types.ppbackend (* ========================================================================== *) (* with_pp_stream *) @@ -196,6 +158,8 @@ fun add_ssz pps (s,sz) = val raw_terminal : t = { name = "raw_terminal", + tm_grammar_upd = (fn g => g), + ty_grammar_upd = (fn g => g), add_break = PP.add_break, add_string = PP.add_string, add_xstring = (fn pps => fn {s,sz,...} => add_ssz pps (s,sz)), @@ -287,6 +251,8 @@ let | _ => add_ssz pps (s,sz) in {name = name, + tm_grammar_upd = (fn g => g), + ty_grammar_upd = (fn g => g), add_break = #add_break raw_terminal, add_newline = #add_newline raw_terminal, begin_block = #begin_block raw_terminal, @@ -387,6 +353,8 @@ val emacs_terminal = let in {name = name, + tm_grammar_upd = (fn g => g), + ty_grammar_upd = (fn g => g), add_break = #add_break raw_terminal, add_newline = #add_newline raw_terminal, begin_block = #begin_block raw_terminal, @@ -525,6 +493,8 @@ let else add_ann_string___simple) pps ((s,sz), valOf ann) in {name = name, + tm_grammar_upd = (fn g => g), + ty_grammar_upd = (fn g => g), add_break = #add_break raw_terminal, add_newline = #add_newline raw_terminal, begin_block = #begin_block raw_terminal, @@ -540,6 +510,8 @@ val debug_blocks_terminal : t = let | sty_to_string (PP.INCONSISTENT, n) = "I" ^ Int.toString n in {name = "debug_blocks", + tm_grammar_upd = (fn g => g), + ty_grammar_upd = (fn g => g), add_break = PP.add_break, add_string = PP.add_string, add_xstring = (fn pps => fn {s,sz,...} => add_ssz pps (s,sz)), diff --git a/src/parse/smpp.sig b/src/parse/smpp.sig index 7b283fd3b8..92a9c66a79 100644 --- a/src/parse/smpp.sig +++ b/src/parse/smpp.sig @@ -1,7 +1,7 @@ signature smpp = sig - type ('a,'b) t = ('a * HOLPP.ppstream) -> ('b * ('a * HOLPP.ppstream)) option + type ('a,'b) t = ('a,'b) term_pp_types.smppt val add_string : string -> ('a,unit) t val add_newline : ('a,unit) t diff --git a/src/parse/term_grammar.sig b/src/parse/term_grammar.sig index 227e5c7ce3..380e01a7aa 100644 --- a/src/parse/term_grammar.sig +++ b/src/parse/term_grammar.sig @@ -111,7 +111,8 @@ sig (* User code additions *) (* Users can add special-purpose printers and parsers to grammars *) type term = Term.term - type userprinter = (type_grammar.grammar * grammar) term_pp_types.userprinter + type userprinter = + (type_grammar.grammar * grammar,grammar) term_pp_types.userprinter val add_user_printer : (string * term * userprinter) -> grammar -> grammar diff --git a/src/parse/term_grammar.sml b/src/parse/term_grammar.sml index ea447a4cb1..100f030723 100644 --- a/src/parse/term_grammar.sml +++ b/src/parse/term_grammar.sml @@ -127,8 +127,8 @@ fun userdelta_name ud = type overload_info = Overload.overload_info -type 'a printer_info = - (term * string * 'a term_pp_types.userprinter) Net.net * string Binaryset.set +type ('a,'b) printer_info = + (term * string * ('a,'b) term_pp_types.userprinter) Net.net * string Binaryset.set type special_info = {type_intro : string, lambda : string list, endbinding : string, @@ -141,11 +141,12 @@ datatype grammar = GCONS of specials : special_info, numeral_info : (char * string option) list, overload_info : overload_info, - user_printers : (type_grammar.grammar * grammar) printer_info, + user_printers : (type_grammar.grammar * grammar, grammar) printer_info, absyn_postprocessors : (string * (Absyn.absyn -> Absyn.absyn)) list } -type userprinter = (type_grammar.grammar * grammar) term_pp_types.userprinter +type userprinter = + (type_grammar.grammar * grammar, grammar) term_pp_types.userprinter fun specials (GCONS G) = #specials G fun numeral_info (GCONS G) = #numeral_info G diff --git a/src/parse/term_pp.sml b/src/parse/term_pp.sml index f483afed3a..18bc12b008 100644 --- a/src/parse/term_pp.sml +++ b/src/parse/term_pp.sml @@ -389,6 +389,8 @@ end handle HOL_ERR _ => false fun is_constish tm = is_const tm orelse is_fakeconst tm fun pp_term (G : grammar) TyG backend = let + val G = #tm_grammar_upd backend G + val TyG = #ty_grammar_upd backend TyG fun block x = backend_block backend x fun tystr ty = PP.pp_to_string 10000 (type_pp.pp_type TyG PPBackEnd.raw_terminal) ty diff --git a/src/parse/term_pp_types.sml b/src/parse/term_pp_types.sml index 0f40151b19..2020360901 100644 --- a/src/parse/term_pp_types.sml +++ b/src/parse/term_pp_types.sml @@ -1,4 +1,6 @@ structure term_pp_types = struct + type ('a,'b) smppt = + ('a * HOLPP.ppstream) -> ('b * ('a * HOLPP.ppstream)) option datatype grav = Top | RealTop | Prec of (int * string) type printing_info = @@ -6,20 +8,73 @@ structure term_pp_types = struct current_bvars : Term.term HOLset.set, last_string : string, in_gspec : bool} - type 'a printer = (printing_info,'a)smpp.t + type 'a printer = (printing_info,'a)smppt type uprinter = unit printer type sysprinter = (grav * grav * grav) -> int -> Term.term -> uprinter + datatype lit_type = FldName | StringLit | NumLit | CharLit + + datatype annotation = + BV of Type.hol_type * (unit -> string) + | FV of Type.hol_type * (unit -> string) + | TyV + | TyOp of (unit -> string) + | TySyn of (unit -> string) + | Const of {Thy:string,Name:string,Ty:Type.hol_type * (unit -> string)} + | SymConst of {Thy:string,Name:string,Ty:Type.hol_type * (unit -> string)} + | Note of string + | Literal of lit_type + + type xstring = {s:string,sz:int option,ann:annotation option} + + datatype pp_color = + Black + | RedBrown + | Green + | BrownGreen + | DarkBlue + | Purple + | BlueGreen + | DarkGrey + | LightGrey + | OrangeRed + | VividGreen + | Yellow + | Blue + | PinkPurple + | LightBlue + | White + + datatype pp_style = + FG of pp_color + | BG of pp_color + | Bold + | Underline + | UserStyle of string + type ppstream_funs = {add_break : int * int -> uprinter, add_newline : uprinter, add_string : string -> uprinter, - add_xstring : PPBackEnd.xstring -> uprinter, - ustyle : PPBackEnd.pp_style list -> uprinter -> uprinter, + add_xstring : xstring -> uprinter, + ustyle : pp_style list -> uprinter -> uprinter, ublock : PP.break_style -> int -> uprinter -> uprinter} - type 'a userprinter = - 'a -> PPBackEnd.t -> sysprinter -> ppstream_funs -> + type 'tmg ppbackend = + {add_string : ppstream -> string -> unit, + add_xstring : ppstream -> xstring -> unit, + begin_block : ppstream -> PP.break_style -> int -> unit, + end_block : ppstream -> unit, + add_break : ppstream -> int * int -> unit, + add_newline : ppstream -> unit, + begin_style : ppstream -> pp_style list -> unit, + end_style : ppstream -> unit, + tm_grammar_upd : 'tmg -> 'tmg, + ty_grammar_upd : type_grammar.grammar -> type_grammar.grammar, + name : string} + + type ('a,'tmg) userprinter = + 'a -> 'tmg ppbackend -> sysprinter -> ppstream_funs -> (grav * grav * grav) -> int -> Term.term -> uprinter exception UserPP_Failed end; From d5832463617b1f56e3b72146c44d99c243d0fcae Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 9 Jul 2015 12:12:52 +1000 Subject: [PATCH 362/718] Make build usage info more accurate about selftest option In particular, you don't have to write build -selftest 1 but can also just write build -selftest --- tools/buildhelp.txt | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/tools/buildhelp.txt b/tools/buildhelp.txt index 3dc84b45a7..d51c7073ea 100644 --- a/tools/buildhelp.txt +++ b/tools/buildhelp.txt @@ -1,5 +1,5 @@ Usage: - build [-stdknl|-expk|..] [-nograph|..] [-seq FNAME|-fullbuild] [-selftest N] + build [-stdknl|-expk|..] [-nograph|..] [-seq FNAME|-fullbuild] [-selftest [N]] builds the system OR @@ -19,16 +19,16 @@ OR shows this message Options to the first version of the command include - -dir DIR : builds just the directory DIR instead of a provided sequence - -expk : builds the "experimental" kernel - -fullbuild : builds with the default "full" build-sequence - -graph : requires the building of the help system's theory-graph - -nograph : omits the building of the help system's theory-graph - -otknl : builds the OpenTheory or "logging" kernel - -selftest N : builds include regression test level N - -seq FNAME : builds using build-sequence file FNAME - -stdknl : builds the "standard" kernel - -symlink : no useful effect (retained for backwards compatibility) + -dir DIR : builds just the directory DIR instead of a provided sequence + -expk : builds the "experimental" kernel + -fullbuild : builds with the default "full" build-sequence + -graph : requires the building of the help system's theory-graph + -nograph : omits the building of the help system's theory-graph + -otknl : builds the OpenTheory or "logging" kernel + -selftest [N] : builds include regression test level N (N=1 if omitted) + -seq FNAME : builds using build-sequence file FNAME + -stdknl : builds the "standard" kernel + -symlink : no useful effect (retained for backwards compatibility) Commands clean and cleanAll can be given with leading hyphens. The symlink option can be given without its leading hyphen. From a593c230f3327e1c1eee92a9e63ef6166ec936b4 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 9 Jul 2015 12:16:52 +1000 Subject: [PATCH 363/718] Tidy up emacs code for filtering HOL output It's hard to test this code systematically --- tools/hol-mode.src | 81 ++++++++++++++++++++-------------------------- 1 file changed, 35 insertions(+), 46 deletions(-) diff --git a/tools/hol-mode.src b/tools/hol-mode.src index df809dd8a2..0681239a22 100644 --- a/tools/hol-mode.src +++ b/tools/hol-mode.src @@ -1439,54 +1439,43 @@ second is to show the new term. (defun holpp-output-filter (s) "Converts a munged emacs_terminal string into a pretty one with text properties." (interactive "sinput: ") - (let* ((tmpbuf (or temp-hol-output-buf - (generate-new-buffer " *HOL output filter*)"))) - end) - (setq temp-hol-output-buf tmpbuf) - (save-excursion - (set-buffer tmpbuf) - (unwind-protect + (with-temp-buffer + (insert s) + (let (end) + (goto-char (point-min)) + (while (and (not end) (search-forward "(*(*(*" nil t)) + (let ((uptoann (- (point) 6)) + (start (point))) + (if (not (holpp-find-comment-end 1)) + (progn + (goto-char uptoann) + (setq end t)) + (delete-region uptoann start) + (let* + ((start (- start 6)) + (code (buffer-substring start (+ start 2))) + (argument + (save-excursion + (goto-char (+ start 2)) + (if (equal (following-char) 0) + (progn + (goto-char (+ (point) 1)) + (skip-chars-forward "^\^@") + (prog1 + (if (equal (+ start 3) (point)) nil + (buffer-substring (+ start 3) + (point))) + (delete-region (+ start 2) (1+ (point))))) + nil)))) + (holpp-execute-code code argument (+ start 2) (- (point) 6)) + (delete-region start (+ start 2)) + (delete-region (- (point) 6) (point)) + (goto-char start))))) + (if (not end) (progn (goto-char (point-max)) - (insert s) - (goto-char (point-min)) - (while (and (not end) (search-forward "(*(*(*" nil t)) - (let ((uptoann (- (point) 6)) - (start (point))) - (if (not (holpp-find-comment-end 1)) - (progn - (goto-char uptoann) - (setq end t)) - (delete-region uptoann start) - (let* - ((start (- start 6)) - (code (buffer-substring start (+ start 2))) - (argument - (save-excursion - (goto-char (+ start 2)) - (if (equal (following-char) 0) - (progn - (goto-char (+ (point) 1)) - (skip-chars-forward "^\^@") - (prog1 - (if (equal (+ start 3) (point)) nil - (buffer-substring (+ start 3) - (point))) - (delete-region (+ start 2) (1+ (point))))) - nil)))) - (holpp-execute-code code argument - (+ start 2) - (- (point) 6)) - (delete-region start (+ start 2)) - (delete-region (- (point) 6) (point)) - (goto-char start))))) - (if (not end) - (progn - (goto-char (point-max)) - (skip-chars-backward "(*"))) - (prog1 - (buffer-substring (point-min) (point)) - (delete-region (point-min) (point)))))))) + (skip-chars-backward "(*")))) + (buffer-string))) (defun holmakepp-mark-error (start end) (add-text-properties start end '(face holmake-error))) From 93467dfc47ab16e963b46f40062d5296225886ca Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 9 Jul 2015 15:00:29 +1000 Subject: [PATCH 364/718] Fix src/parse Holmakefile dependency info for selftest Problem only becomes apparent in Moscow ML, which actually does a real linking step. (Problem would appear in Poly/ML if you tried to run the selftest.exe file immediately after building it.) --- src/parse/Holmakefile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/parse/Holmakefile b/src/parse/Holmakefile index c2a3d6d928..211395091e 100644 --- a/src/parse/Holmakefile +++ b/src/parse/Holmakefile @@ -2,7 +2,7 @@ EXTRA_CLEANS = base_lexer.sml SELFTEST_DEPS = $(dprot $(SIGOBJ)/Lib.uo) $(dprot $(SIGOBJ)/Type.uo) \ PPBackEnd.uo $(dprot $(SIGOBJ)/Overlay.uo) base_tokens.uo \ - qbuf.uo term_tokens.uo MLstring.uo CharSet.uo + qbuf.uo term_tokens.uo MLstring.uo CharSet.uo term_grammar.uo UOFILES = $(patsubst %.sml,%.uo,$(wildcard *.sml)) From 6b27ec85a071f75c8a504da9dbbb02d7690b7e7b Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 9 Jul 2015 17:07:33 +1000 Subject: [PATCH 365/718] Really "fix" src/parse Holmakefile dependency info Sledgehammer it, and say it depends on every possible uo file in the directory. --- src/parse/Holmakefile | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/parse/Holmakefile b/src/parse/Holmakefile index 211395091e..a349756308 100644 --- a/src/parse/Holmakefile +++ b/src/parse/Holmakefile @@ -1,8 +1,8 @@ EXTRA_CLEANS = base_lexer.sml SELFTEST_DEPS = $(dprot $(SIGOBJ)/Lib.uo) $(dprot $(SIGOBJ)/Type.uo) \ - PPBackEnd.uo $(dprot $(SIGOBJ)/Overlay.uo) base_tokens.uo \ - qbuf.uo term_tokens.uo MLstring.uo CharSet.uo term_grammar.uo + $(dprot $(SIGOBJ)/Overlay.uo) \ + $(patsubst %.sml,%.uo,$(wildcard *.sml)) UOFILES = $(patsubst %.sml,%.uo,$(wildcard *.sml)) From 80fc730e2ce237bcede15345d89300515156f1ac Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 10 Jul 2015 16:06:01 +1000 Subject: [PATCH 366/718] Fix for Hol_dep lexer bug. Code used to insist that first whitespace following a backslash had to be a newline, when any space at all is permissible, including inter alia a carriage return, which is something you might see if your file has been contaminated by Windows. Thanks to Konrad for the bug report. --- tools/Holmake/Holdep_tokens.sml | 2 ++ tools/Holmake/tests/brokenstrings/AST.sml | 18 ++++++++++++++++++ tools/sequences/kernel | 3 ++- 3 files changed, 22 insertions(+), 1 deletion(-) create mode 100644 tools/Holmake/tests/brokenstrings/AST.sml diff --git a/tools/Holmake/Holdep_tokens.sml b/tools/Holmake/Holdep_tokens.sml index 9937de1378..a4a02fa61b 100644 --- a/tools/Holmake/Holdep_tokens.sml +++ b/tools/Holmake/Holdep_tokens.sml @@ -383,6 +383,8 @@ and STRINGslash scr = | SOME #"v" => STRING (inc scr) | SOME c => if Char.isDigit c then STRINGslashdigit 1 (inc scr) + else if Char.isSpace c then + STRINGelidews (inc scr) else Error(scr, "Illegal backslash escape >" ^ str c ^ "< in string literal") and STRINGelidews scr = diff --git a/tools/Holmake/tests/brokenstrings/AST.sml b/tools/Holmake/tests/brokenstrings/AST.sml new file mode 100644 index 0000000000..cd86bde18c --- /dev/null +++ b/tools/Holmake/tests/brokenstrings/AST.sml @@ -0,0 +1,18 @@ +structure AST = +struct + + open HolKernel + fun f() = let + (* carriage return character on end of next line is deliberate *) + val estr = "Unary Minus: expected argument to be an int \ + \(either \ \fixed width or unbounded)" + in + dest_var ``SUC : num -> num`` handle HOL_ERR _ => raise Fail estr + end +end (* struct *) + +(* +Local variables: +mn-delete-trailing-whitespace-p: nil +End: +*) diff --git a/tools/sequences/kernel b/tools/sequences/kernel index 32f662f9cf..59bbe01f5b 100644 --- a/tools/sequences/kernel +++ b/tools/sequences/kernel @@ -12,7 +12,8 @@ src/bool src/1 !tools/Holmake/tests/depchain1/dir3 !tools/Holmake/tests/depchain2/dir1 -!tools/Holmake/tests/altquote1/ +!tools/Holmake/tests/altquote1 +!tools/Holmake/tests/brokenstrings !src/1/theory_tests src/proofman [poly]bin/hol.bare From 0050e5c5b1d4a9ba9d9947dba7d0793b8004304e Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Sun, 12 Jul 2015 11:36:41 +0800 Subject: [PATCH 367/718] Another holdep bug; "functor" is an SML keyword --- tools/Holmake/Holdep_tokens.sml | 17 ++++++++++++++++- tools/Holmake/tests/brokenstrings/functor.sml | 5 +++++ 2 files changed, 21 insertions(+), 1 deletion(-) create mode 100644 tools/Holmake/tests/brokenstrings/functor.sml diff --git a/tools/Holmake/Holdep_tokens.sml b/tools/Holmake/Holdep_tokens.sml index a4a02fa61b..71533755f1 100644 --- a/tools/Holmake/Holdep_tokens.sml +++ b/tools/Holmake/Holdep_tokens.sml @@ -97,7 +97,7 @@ fun clean_open scr = NONE => scr | SOME #"d" => openTermPFX "datatype" 1 (inc scr) | SOME #"e" => opene (inc scr) (* exception, end *) - | SOME #"f" => openTermPFX "fun" 1 (inc scr) + | SOME #"f" => openf (inc scr) (* fun, functor *) | SOME #"i" => openi (inc scr) (* in, infixl, infix, infixr *) | SOME #"l" => openTermPFX "local" 1 (inc scr) | SOME #"n" => openTermPFX "nonfix" 1 (inc scr) @@ -125,6 +125,21 @@ and opene scr = | SOME #"n" => openTermPFX "end" 2 (inc scr) | SOME #"x" => openTermPFX "exception" 2 (inc scr) | SOME c => extend_openAlpha "e" c scr +and openf scr = + case currentChar scr of + NONE => scr |> completeID "f" + | SOME #"u" => openfu (inc scr) + | SOME c => extend_openAlpha "f" c scr +and openfu scr = + case currentChar scr of + NONE => scr |> completeID "fu" + | SOME #"n" => openfun (inc scr) + | SOME c => extend_openAlpha "fu" c scr +and openfun scr = + case currentChar scr of + NONE => scr + | SOME #"c" => openTermPFX "functor" 4 (inc scr) + | SOME c => openOnKWord "fun" scr and openi scr = case currentChar scr of NONE => scr |> completeID "i" diff --git a/tools/Holmake/tests/brokenstrings/functor.sml b/tools/Holmake/tests/brokenstrings/functor.sml new file mode 100644 index 0000000000..7ae70f65df --- /dev/null +++ b/tools/Holmake/tests/brokenstrings/functor.sml @@ -0,0 +1,5 @@ +open HolKernel +functor x(val y : int) = +struct + val z = y + 1 +end From 13c998f19359f0de64b3c29f428b0b1790abd8ac Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Tue, 14 Jul 2015 13:37:43 +0100 Subject: [PATCH 368/718] Add syntax support for alignmentTheory. --- src/n-bit/alignmentScript.sml | 15 +++++++++++++++ src/n-bit/alignmentSyntax.sig | 26 ++++++++++++++++++++++++++ src/n-bit/alignmentSyntax.sml | 16 ++++++++++++++++ 3 files changed, 57 insertions(+) create mode 100644 src/n-bit/alignmentSyntax.sig create mode 100644 src/n-bit/alignmentSyntax.sml diff --git a/src/n-bit/alignmentScript.sml b/src/n-bit/alignmentScript.sml index 9a5ddef271..c5251f9579 100644 --- a/src/n-bit/alignmentScript.sml +++ b/src/n-bit/alignmentScript.sml @@ -41,6 +41,11 @@ val aligned_align = Q.store_thm ("aligned_align", rewrite_tac [aligned_def, align_align] ) +val align_aligned = Q.store_thm ("align_aligned", + `!p w. aligned p w ==> (align p w = w)`, + rewrite_tac [aligned_def] + ) + val align_bitwise_and = Q.store_thm("align_bitwise_and", `!p w. align p w = w && UINT_MAXw << p`, srw_tac [wordsLib.WORD_BIT_EQ_ss] [align_def] @@ -205,6 +210,16 @@ val aligned_add_sub_prod = Q.store_thm("aligned_add_sub_prod", metis_tac [aligned_add_sub, aligned_mul_shift_1, wordsTheory.WORD_ADD_COMM] ) +val aligned_imp = Q.store_thm("aligned_imp", + `!p q w. p < q /\ aligned q w ==> aligned p w`, + srw_tac [wordsLib.WORD_BIT_EQ_ss] [aligned_extract] + >- fs [] + \\ Cases_on `p` + \\ lrw [] + \\ res_tac + \\ simp [] + ) + (* ------------------------------------------------------------------------- Theorems for standard alignment lengths of 1, 2 and 3 bits ------------------------------------------------------------------------- *) diff --git a/src/n-bit/alignmentSyntax.sig b/src/n-bit/alignmentSyntax.sig new file mode 100644 index 0000000000..775d3e82bc --- /dev/null +++ b/src/n-bit/alignmentSyntax.sig @@ -0,0 +1,26 @@ +signature alignmentSyntax = +sig + + include Abbrev + + val align_tm: term + val aligned_tm: term + val byte_align_tm: term + val byte_aligned_tm: term + + val dest_align: term -> term * term + val dest_aligned: term -> term * term + val dest_byte_align: term -> term + val dest_byte_aligned: term -> term + + val is_align: term -> bool + val is_aligned: term -> bool + val is_byte_align: term -> bool + val is_byte_aligned: term -> bool + + val mk_align: term * term -> term + val mk_aligned: term * term -> term + val mk_byte_align: term -> term + val mk_byte_aligned: term -> term + +end diff --git a/src/n-bit/alignmentSyntax.sml b/src/n-bit/alignmentSyntax.sml new file mode 100644 index 0000000000..79333e57b8 --- /dev/null +++ b/src/n-bit/alignmentSyntax.sml @@ -0,0 +1,16 @@ +structure alignmentSyntax :> alignmentSyntax = +struct + +open Abbrev HolKernel alignmentTheory + +val s = HolKernel.syntax_fns1 "alignment" +val (byte_align_tm, mk_byte_align, dest_byte_align, is_byte_align) = + s "byte_align" +val (byte_aligned_tm, mk_byte_aligned, dest_byte_aligned, is_byte_aligned) = + s "byte_aligned" + +val s = HolKernel.syntax_fns2 "alignment" +val (align_tm, mk_align, dest_align, is_align) = s "align" +val (aligned_tm, mk_aligned, dest_aligned, is_aligned) = s "aligned" + +end From 0559f3bdcbd1e398c669fd7601a62beb456d0073 Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Tue, 14 Jul 2015 13:38:53 +0100 Subject: [PATCH 369/718] Make use of alignmentTheory in the l3-machine-code examples. --- examples/l3-machine-code/arm/model/arm.sml | 52 ++- .../l3-machine-code/arm/model/armScript.sml | 14 +- .../l3-machine-code/arm/prog/arm_progLib.sml | 7 +- .../arm/prog/arm_progScript.sml | 31 +- .../l3-machine-code/arm/step/arm_stepLib.sml | 308 +++++++------- .../arm/step/arm_stepScript.sml | 382 ++++++------------ .../arm8/decompiler/arm8_decompLib.sml | 1 + .../arm8/prog/arm8_progLib.sml | 10 +- .../arm8/prog/arm8_progScript.sml | 47 +-- .../arm8/step/arm8_stepLib.sml | 4 +- .../arm8/step/arm8_stepScript.sml | 185 ++------- .../m0/decompiler/m0_core_decompLib.sml | 4 +- .../l3-machine-code/m0/prog/m0_progLib.sml | 6 +- .../l3-machine-code/m0/prog/m0_progScript.sml | 9 +- .../l3-machine-code/m0/step/m0_stepLib.sml | 55 +-- .../l3-machine-code/m0/step/m0_stepScript.sml | 165 ++------ .../mips/step/mips_stepScript.sml | 3 - .../x64/step/x64_stepScript.sml | 8 +- 18 files changed, 466 insertions(+), 825 deletions(-) diff --git a/examples/l3-machine-code/arm/model/arm.sml b/examples/l3-machine-code/arm/model/arm.sml index 4fd59903de..7e82de863f 100644 --- a/examples/l3-machine-code/arm/model/arm.sml +++ b/examples/l3-machine-code/arm/model/arm.sml @@ -1,4 +1,4 @@ -(* arm - generated by L<3> - Fri Nov 21 16:33:11 2014 *) +(* arm - generated by L3 - Mon Jul 13 13:33:29 2015 *) structure arm :> arm = struct @@ -18303,14 +18303,14 @@ fun e_branch (c,(ast,e)) = (if e = Enc_ARM then if ((BitsN.<=(BitsN.neg(BitsN.B(0x2000000,32)),imm32)) andalso (BitsN.<=(imm32,BitsN.B(0x1FFFFFC,32)))) andalso - ((BitsN.bits(imm32,1,0)) = (BitsN.B(0x0,2))) + (Aligned 32 (imm32,4)) then let val imm24 = BitsN.bits(imm32,25,2) in ARM(BitsN.concat[c,BitsN.B(0xA,4),imm24]) end else BadCode("B: bad offset") - else if BitsN.bit(imm32,0) + else if not(Aligned 32 (imm32,2)) then BadCode("BranchTarget: bad offset") else if Set.mem(c,[BitsN.B(0xE,4),BitsN.B(0xF,4)]) then if ((BitsN.<=(BitsN.neg(BitsN.B(0x800,32)),imm32)) andalso @@ -18374,7 +18374,7 @@ fun e_branch (c,(ast,e)) = then if ((BitsN.<= (BitsN.neg(BitsN.B(0x2000000,32)),imm32)) andalso (BitsN.<=(imm32,BitsN.B(0x1FFFFFC,32)))) andalso - ((BitsN.bits(imm32,1,0)) = (BitsN.B(0x0,2))) + (Aligned 32 (imm32,4)) then let val imm24 = BitsN.bits(imm32,25,2) in @@ -18385,7 +18385,7 @@ fun e_branch (c,(ast,e)) = else if ((BitsN.<= (BitsN.neg(BitsN.B(0x2000000,32)),imm32)) andalso (BitsN.<=(imm32,BitsN.B(0x1FFFFFE,32)))) andalso - (not(BitsN.bit(imm32,0))) + (Aligned 32 (imm32,2)) then let val imm24 = BitsN.bits(imm32,25,2) val H = BitsN.bits(imm32,1,1) @@ -18397,8 +18397,7 @@ fun e_branch (c,(ast,e)) = else if targetInstrSet = InstrSet_ARM then if (((BitsN.<=(BitsN.neg(BitsN.B(0x1000000,32)),imm32)) andalso (BitsN.<=(imm32,BitsN.B(0xFFFFFC,32)))) andalso - ((BitsN.bits(imm32,1,0)) = (BitsN.B(0x0,2)))) andalso - (not(e = Enc_Narrow)) + (Aligned 32 (imm32,4))) andalso (not(e = Enc_Narrow)) then let val S = BitsN.bits(imm32,24,24) val I1 = BitsN.bits(imm32,23,23) @@ -18415,9 +18414,9 @@ fun e_branch (c,(ast,e)) = BitsN.B(0x0,1)]) end else BadCode("BLX (immediate): bad offset") - else if ((BitsN.<=(BitsN.neg(BitsN.B(0x1000000,32)),imm32)) andalso - (BitsN.<=(imm32,BitsN.B(0xFFFFFE,32)))) andalso - (not((BitsN.bit(imm32,0)) orelse (e = Enc_Narrow))) + else if (((BitsN.<=(BitsN.neg(BitsN.B(0x1000000,32)),imm32)) andalso + (BitsN.<=(imm32,BitsN.B(0xFFFFFE,32)))) andalso + (Aligned 32 (imm32,2))) andalso (not(e = Enc_Narrow)) then let val S = BitsN.bits(imm32,24,24) val I1 = BitsN.bits(imm32,23,23) @@ -18439,8 +18438,8 @@ fun e_branch (c,(ast,e)) = then Thumb(BitsN.concat[BitsN.B(0x8F,9),Rm,BitsN.B(0x0,3)]) else BadCode("no wide BLX (register)")) | CompareBranch(nonzero,(n,imm32)) => - (if ((BitsN.<=+(imm32,BitsN.B(0x7E,32))) andalso - (not((BitsN.bit(imm32,0)) orelse (BitsN.bit(n,3))))) andalso + (if (((BitsN.<=+(imm32,BitsN.B(0x7E,32))) andalso + (Aligned 32 (imm32,2))) andalso (not(BitsN.bit(n,3)))) andalso (Set.mem(e,[Enc_Thumb,Enc_Narrow])) then let val op' = BitsN.fromBit nonzero @@ -20368,7 +20367,7 @@ fun e_load (c,(ast,e)) = else if (index andalso add) andalso (not wback) then if (((n = (BitsN.B(0xD,4))) andalso (BitsN.<=+(imm32,BitsN.B(0x3FC,32)))) andalso - ((BitsN.bits(imm32,1,0)) = (BitsN.B(0x0,2)))) andalso + (Aligned 32 (imm32,4))) andalso (not((BitsN.bit(t,3)) orelse (e = Enc_Wide))) then let val Rt = BitsN.bits(t,2,0) @@ -20377,7 +20376,7 @@ fun e_load (c,(ast,e)) = Thumb(BitsN.concat[BitsN.B(0x13,5),Rt,imm8]) end else if ((BitsN.<=+(imm32,BitsN.B(0x7C,32))) andalso - ((BitsN.bits(imm32,1,0)) = (BitsN.B(0x0,2)))) andalso + (Aligned 32 (imm32,4))) andalso (not(((BitsN.bit(t,3)) orelse (BitsN.bit(n,3))) orelse (e = Enc_Wide))) then let @@ -20471,7 +20470,7 @@ fun e_load (c,(ast,e)) = end else BadCode("LoadLiteral") else if ((add andalso (BitsN.<=+(imm32,BitsN.B(0x3FC,32)))) andalso - ((BitsN.bits(imm32,1,0)) = (BitsN.B(0x0,2)))) andalso + (Aligned 32 (imm32,4))) andalso (not((BitsN.bit(t,3)) orelse (e = Enc_Wide))) then let val Rt = BitsN.bits(t,2,0) @@ -20778,7 +20777,7 @@ fun e_load (c,(ast,e)) = else BadCode("LoadHalf") else if (index andalso add) andalso (not wback) then if ((unsigned andalso (BitsN.<=+(imm32,BitsN.B(0x3E,32)))) andalso - (not(BitsN.bit(imm32,0)))) andalso + (Aligned 32 (imm32,2))) andalso (not(((BitsN.bit(t,3)) orelse (BitsN.bit(n,3))) orelse (e = Enc_Wide))) then let @@ -21039,8 +21038,7 @@ fun e_load (c,(ast,e)) = end else BadCode("LoadDual") else if ((BitsN.<=+(imm32,BitsN.B(0x3FC,32))) andalso - ((BitsN.bits(imm32,1,0)) = (BitsN.B(0x0,2)))) andalso - (not(e = Enc_Narrow)) + (Aligned 32 (imm32,4))) andalso (not(e = Enc_Narrow)) then let val W = BitsN.fromBit wback val imm8 = BitsN.bits(imm32,9,2) @@ -21081,8 +21079,7 @@ fun e_load (c,(ast,e)) = end else BadCode("LoadDualLiteral") else if ((BitsN.<=+(imm32,BitsN.B(0x3FC,32))) andalso - ((BitsN.bits(imm32,1,0)) = (BitsN.B(0x0,2)))) andalso - (not(e = Enc_Narrow)) + (Aligned 32 (imm32,4))) andalso (not(e = Enc_Narrow)) then let val imm8 = BitsN.bits(imm32,9,2) in @@ -21099,8 +21096,7 @@ fun e_load (c,(ast,e)) = [c,BitsN.B(0x19,8),Rn,Rt,BitsN.B(0xF9F,12)]) else BadCode("LoadExclusive") else if ((BitsN.<=+(imm32,BitsN.B(0x3FC,32))) andalso - ((BitsN.bits(imm32,1,0)) = (BitsN.B(0x0,2)))) andalso - (not(e = Enc_Narrow)) + (Aligned 32 (imm32,4))) andalso (not(e = Enc_Narrow)) then let val imm8 = BitsN.bits(imm32,9,2) in @@ -21159,7 +21155,7 @@ fun e_store (c,(ast,e)) = else if (index andalso add) andalso (not wback) then if (((n = (BitsN.B(0xD,4))) andalso (BitsN.<=+(imm32,BitsN.B(0x3FC,32)))) andalso - ((BitsN.bits(imm32,1,0)) = (BitsN.B(0x0,2)))) andalso + (Aligned 32 (imm32,4))) andalso (not((BitsN.bit(t,3)) orelse (e = Enc_Wide))) then let val Rt = BitsN.bits(t,2,0) @@ -21168,7 +21164,7 @@ fun e_store (c,(ast,e)) = Thumb(BitsN.concat[BitsN.B(0x12,5),Rt,imm8]) end else if ((BitsN.<=+(imm32,BitsN.B(0x7C,32))) andalso - ((BitsN.bits(imm32,1,0)) = (BitsN.B(0x0,2)))) andalso + (Aligned 32 (imm32,4))) andalso (not(((BitsN.bit(t,3)) orelse (BitsN.bit(n,3))) orelse (e = Enc_Wide))) then let @@ -21434,7 +21430,7 @@ fun e_store (c,(ast,e)) = else BadCode("StoreHalf") else if (index andalso add) andalso (not wback) then if ((BitsN.<=+(imm32,BitsN.B(0x3E,32))) andalso - (not(BitsN.bit(imm32,0)))) andalso + (Aligned 32 (imm32,2))) andalso (not(((BitsN.bit(t,3)) orelse (BitsN.bit(n,3))) orelse (e = Enc_Wide))) then let @@ -21628,8 +21624,7 @@ fun e_store (c,(ast,e)) = end else BadCode("StoreDual") else if ((BitsN.<=+(imm32,BitsN.B(0x3FC,32))) andalso - ((BitsN.bits(imm32,1,0)) = (BitsN.B(0x0,2)))) andalso - (not(e = Enc_Narrow)) + (Aligned 32 (imm32,4))) andalso (not(e = Enc_Narrow)) then let val W = BitsN.fromBit wback val imm8 = BitsN.bits(imm32,9,2) @@ -21660,8 +21655,7 @@ fun e_store (c,(ast,e)) = [c,BitsN.B(0x18,8),Rn,Rd,BitsN.B(0xF9,8),Rt]) else BadCode("StoreExclusive") else if ((BitsN.<=+(imm32,BitsN.B(0x3FC,32))) andalso - ((BitsN.bits(imm32,1,0)) = (BitsN.B(0x0,2)))) andalso - (not(e = Enc_Narrow)) + (Aligned 32 (imm32,4))) andalso (not(e = Enc_Narrow)) then let val imm8 = BitsN.bits(imm32,9,2) in diff --git a/examples/l3-machine-code/arm/model/armScript.sml b/examples/l3-machine-code/arm/model/armScript.sml index 0467df2f4d..bc2f4cf8cd 100644 --- a/examples/l3-machine-code/arm/model/armScript.sml +++ b/examples/l3-machine-code/arm/model/armScript.sml @@ -1,4 +1,4 @@ -(* armScript.sml - generated by L<3> - Fri Nov 21 15:10:03 2014 *) +(* armScript.sml - generated by L3 - Mon Jul 13 13:32:29 2015 *) open HolKernel boolLib bossLib Import val () = Import.start "arm" @@ -43130,7 +43130,7 @@ val e_branch_def = Def ITE(Bop(And, Bop(And,Bop(Le,Mop(Neg,LW(33554432,32)),Var("imm32",F32)), Bop(Le,Var("imm32",F32),LW(33554428,32))), - EQ(EX(Var("imm32",F32),LN 1,LN 0,FTy 2),LW(0,2))), + Call("Aligned",bTy,TP[Var("imm32",F32),LN 4])), Call ("ARM",CTy"MachineCode", CC[Var("c",F4),LW(10,4), @@ -43151,7 +43151,7 @@ val e_branch_def = Def Bop(Le,Mop(Neg,LW(33554432,32)), Var("imm32",F32)), Bop(Le,Var("imm32",F32),LW(33554428,32))), - EQ(EX(Var("imm32",F32),LN 1,LN 0,FTy 2),LW(0,2))), + Call("Aligned",bTy,TP[Var("imm32",F32),LN 4])), Call ("ARM",CTy"MachineCode", CC[Var("c",F4),LW(11,4), @@ -43161,7 +43161,7 @@ val e_branch_def = Def Bop(And, Bop(Le,Mop(Neg,LW(33554432,32)),Var("imm32",F32)), Bop(Le,Var("imm32",F32),LW(33554430,32))), - Mop(Not,Bop(Bit,Var("imm32",F32),LN 0))), + Call("Aligned",bTy,TP[Var("imm32",F32),LN 2])), Call ("ARM",CTy"MachineCode", CC[LW(125,7),EX(Var("imm32",F32),LN 1,LN 1,F1), @@ -43406,8 +43406,7 @@ val e_vfp_def = Def ("vldr",CTy"VFP", TP[bVar"single_register",bVar"add",Var("d",FTy 5),Var("n",F4), Var("imm32",F32)]), - ITE(Bop(Or, - Mop(Not,EQ(EX(Var("imm32",F32),LN 1,LN 0,FTy 2),LW(0,2))), + ITE(Bop(Or,Mop(Not,Call("Aligned",bTy,TP[Var("imm32",F32),LN 4])), Mop(Not, EQ(EX(Var("imm32",F32),LN 31,LN 10,FTy 22),LW(0,22)))), Call("BadCode",CTy"MachineCode",LS"VLDR: bad immediate"), @@ -43425,8 +43424,7 @@ val e_vfp_def = Def ("vstr",CTy"VFP", TP[bVar"single_register",bVar"add",Var("d",FTy 5),Var("n",F4), Var("imm32",F32)]), - ITE(Bop(Or, - Mop(Not,EQ(EX(Var("imm32",F32),LN 1,LN 0,FTy 2),LW(0,2))), + ITE(Bop(Or,Mop(Not,Call("Aligned",bTy,TP[Var("imm32",F32),LN 4])), Mop(Not, EQ(EX(Var("imm32",F32),LN 31,LN 10,FTy 22),LW(0,22)))), Call("BadCode",CTy"MachineCode",LS"VSTR: bad immediate"), diff --git a/examples/l3-machine-code/arm/prog/arm_progLib.sml b/examples/l3-machine-code/arm/prog/arm_progLib.sml index 7727bd9dc8..5fc328292b 100644 --- a/examples/l3-machine-code/arm/prog/arm_progLib.sml +++ b/examples/l3-machine-code/arm/prog/arm_progLib.sml @@ -433,7 +433,8 @@ local Lib.tryfind (fn thm => MATCH_MP thm th) [arm_PC_INTRO, arm_TEMPORAL_PC_INTRO, arm_PC_INTRO0, arm_TEMPORAL_PC_INTRO0] - val cnv = REWRITE_CONV [arm_stepTheory.Aligned_numeric, Aligned_Branch] + val cnv = REWRITE_CONV [alignmentTheory.aligned_numeric, + arm_progTheory.Aligned_Branch] val arm_PC_bump_intro = SPEC_IMP_RULE o Conv.CONV_RULE (Conv.LAND_CONV cnv) o @@ -480,7 +481,7 @@ in Conv.CONV_RULE (stateLib.PRE_COND_CONV (SIMP_CONV (bool_ss++boolSimps.CONJ_ss) - [arm_stepTheory.Aligned_numeric])) o + [alignmentTheory.aligned_numeric])) o concat_bytes_rule o stateLib.pick_endian_rule (is_big_end, be_word_memory_introduction, le_word_memory_introduction) @@ -552,7 +553,7 @@ local THENC WGROUND_RW_CONV THENC stateLib.PRE_COND_CONV (DEPTH_CONV DISJOINT_CONV - THENC REWRITE_CONV [arm_stepTheory.Aligned_numeric] + THENC REWRITE_CONV [alignmentTheory.aligned_numeric] THENC numLib.REDUCE_CONV THENC NOT_F_CONV) THENC helperLib.POST_CONV diff --git a/examples/l3-machine-code/arm/prog/arm_progScript.sml b/examples/l3-machine-code/arm/prog/arm_progScript.sml index c77018973c..847525ede9 100644 --- a/examples/l3-machine-code/arm/prog/arm_progScript.sml +++ b/examples/l3-machine-code/arm/prog/arm_progScript.sml @@ -2,9 +2,6 @@ open HolKernel boolLib bossLib open lcsymtacs blastLib stateLib open set_sepTheory progTheory temporal_stateTheory arm_stepTheory -infix \\ -val op \\ = op THEN; - val () = new_theory "arm_prog" (* ------------------------------------------------------------------------ *) @@ -72,11 +69,11 @@ val arm_BE_WORD_def = Define` val arm_WORD_MEMORY_def = Define` arm_WORD_MEMORY dmem mem = - {BIGUNION { BIGUNION (arm_WORD a (mem a)) | a IN dmem /\ Aligned (a, 4)}}` + {BIGUNION { BIGUNION (arm_WORD a (mem a)) | a IN dmem /\ aligned 2 a}}` val arm_BE_WORD_MEMORY_def = Define` arm_BE_WORD_MEMORY dmem mem = - {BIGUNION { BIGUNION (arm_BE_WORD a (mem a)) | a IN dmem /\ Aligned (a, 4)}}` + {BIGUNION { BIGUNION (arm_BE_WORD a (mem a)) | a IN dmem /\ aligned 2 a}}` val arm_CONFIG_def = Define` arm_CONFIG (vfp, arch, bigend, thumb, mode) = @@ -88,7 +85,7 @@ val arm_CONFIG_def = Define` arm_CPSR_M mode * cond (GoodMode mode)`; val arm_PC_def = Define` - arm_PC pc = arm_REG RName_PC pc * cond (Aligned (pc,4))`; + arm_PC pc = arm_REG RName_PC pc * cond (aligned 2 pc)`; val aS_def = Define ` aS (n,z,c,v) = arm_CPSR_N n * arm_CPSR_Z z * arm_CPSR_C c * arm_CPSR_V v`; @@ -118,7 +115,7 @@ val arm_CPSR_T_F = Q.store_thm("arm_CPSR_T_F", val arm_PC_INTRO = Q.store_thm("arm_PC_INTRO", `SPEC m (p1 * arm_PC pc) code (p2 * arm_REG RName_PC pc') ==> - (Aligned (pc,4) ==> Aligned (pc',4)) ==> + (aligned 2 pc ==> aligned 2 pc') ==> SPEC m (p1 * arm_PC pc) code (p2 * arm_PC pc')`, REPEAT STRIP_TAC \\ FULL_SIMP_TAC std_ss [arm_PC_def, SPEC_MOVE_COND, STAR_ASSOC, SEP_CLAUSES] @@ -126,7 +123,7 @@ val arm_PC_INTRO = Q.store_thm("arm_PC_INTRO", val arm_TEMPORAL_PC_INTRO = Q.store_thm("arm_TEMPORAL_PC_INTRO", `TEMPORAL_NEXT m (p1 * arm_PC pc) code (p2 * arm_REG RName_PC pc') ==> - (Aligned (pc,4) ==> Aligned (pc',4)) ==> + (aligned 2 pc ==> aligned 2 pc') ==> TEMPORAL_NEXT m (p1 * arm_PC pc) code (p2 * arm_PC pc')`, REPEAT STRIP_TAC \\ FULL_SIMP_TAC std_ss @@ -144,9 +141,9 @@ val x = mk_addr (boolSyntax.T, "x") val y = mk_addr (boolSyntax.F, "y") val Aligned_Branch = Q.store_thm("Aligned_Branch", - `(Aligned (pc:word32, 4) ==> - Aligned ((if b then pc - (^x + 1w) else pc + ^y), 4)) = T`, - rw [Aligned] + `(aligned 2 (pc:word32) ==> + aligned 2 (if b then pc - (^x + 1w) else pc + ^y)) = T`, + rw [alignmentTheory.aligned_extract] \\ blastLib.FULL_BBLAST_TAC ) @@ -166,17 +163,17 @@ val lem1 = Q.prove( simp [wordsTheory.word_lo_n2w]) val lem2 = Q.prove( - `Aligned (a: word32, 4) /\ Aligned (b, 4) /\ x <+ 4w /\ y <+ 4w ==> + `aligned 2 (a: word32) /\ aligned 2 b /\ x <+ 4w /\ y <+ 4w ==> ((a + x = b + y) = (a = b) /\ (x = y))`, - simp [arm_stepTheory.Aligned] + simp [alignmentTheory.aligned_extract] \\ blastLib.BBLAST_TAC ) fun thm v x y = stateTheory.MAPPED_COMPONENT_INSERT |> Q.ISPECL - [`\a:word32. Aligned (a, 4)`, `4`, `\a i. arm_c_MEM (a + n2w i)`, - `\v:word32 i. arm_d_word8 (EL i ^v)`, x, y] + [`\a:word32. aligned 2 a`, `4n`, `\a i. arm_c_MEM (a + n2w i)`, + `\v:word32 i. arm_d_word8 (EL i ^v)`, x, y] |> Conv.CONV_RULE (Conv.LAND_CONV (SIMP_CONV (srw_ss()) @@ -197,7 +194,7 @@ val be_v4 = ``[(31 >< 24) v; (23 >< 16) v; (* Need ``(\a. ..) c`` below for automation to work *) val arm_WORD_MEMORY_INSERT = Q.store_thm("arm_WORD_MEMORY_INSERT", `!f df c d. - c IN df /\ (\a. Aligned (a, 4)) c ==> + c IN df /\ (\a. aligned 2 a) c ==> (arm_WORD c d * arm_WORD_MEMORY (df DELETE c) f = arm_WORD_MEMORY df ((c =+ d) f))`, match_mp_tac (thm v4 `arm_WORD` `arm_WORD_MEMORY`) @@ -210,7 +207,7 @@ val arm_WORD_MEMORY_INSERT = Q.store_thm("arm_WORD_MEMORY_INSERT", val arm_BE_WORD_MEMORY_INSERT = Q.store_thm("arm_BE_WORD_MEMORY_INSERT", `!f df c d. - c IN df /\ (\a. Aligned (a, 4)) c ==> + c IN df /\ (\a. aligned 2 a) c ==> (arm_BE_WORD c d * arm_BE_WORD_MEMORY (df DELETE c) f = arm_BE_WORD_MEMORY df ((c =+ d) f))`, match_mp_tac (thm be_v4 `arm_BE_WORD` `arm_BE_WORD_MEMORY`) diff --git a/examples/l3-machine-code/arm/step/arm_stepLib.sml b/examples/l3-machine-code/arm/step/arm_stepLib.sml index 416329e32d..bbfc13045f 100644 --- a/examples/l3-machine-code/arm/step/arm_stepLib.sml +++ b/examples/l3-machine-code/arm/step/arm_stepLib.sml @@ -6,6 +6,7 @@ structure arm_stepLib :> arm_stepLib = struct open HolKernel boolLib bossLib + open lcsymtacs armTheory arm_stepTheory arm_configLib open state_transformerSyntax blastLib @@ -22,9 +23,6 @@ end open Parse val _ = Parse.hide "add" -infix \\ -val op \\ = op THEN - val ERR = Feedback.mk_HOL_ERR "arm_stepLib" val WARN = Feedback.HOL_WARNING "arm_stepLib" @@ -82,7 +80,8 @@ end (* ARM datatype theorems/conversions *) fun datatype_thms thms = - thms @ cond_thms @ [cond_rand_thms, snd_exception_thms, FST_SWAP] @ + [cond_rand_thms, snd_exception_thms, FST_SWAP, + arm_stepTheory.Align, arm_stepTheory.Aligned] @ thms @ cond_thms @ utilsLib.datatype_rewrites true "arm" ["arm_state", "Architecture", "RName", "InstrSet", "SRType", "Encoding", "PSR", "VFPNegMul"] @@ -178,7 +177,7 @@ local val thms = [merge_cond, cond_rand_thms, isnot15, IsSecure_def, CurrentInstrSet_rwt, NotMon, HaveSecurityExt_def, Rmode_def, - write'Rmode_def, LookUpRName_rwt, GSYM Aligned] + write'Rmode_def, LookUpRName_rwt, arm_stepTheory.aligned_23] val Rmode_rwt = EV thms [[``Extension_Security NOTIN ^st.Extensions``]] [] @@ -187,7 +186,7 @@ local val write'Rmode_rwt = EV thms [[``Extension_Security NOTIN ^st.Extensions``, ``n <> 15w: word4``, - ``~(((n = 13w: word4) /\ ~Aligned (v: word32, 4)) /\ ^st.CPSR.T)``]] + ``~(((n = 13w: word4) /\ ~aligned 2 (v: word32)) /\ ^st.CPSR.T)``]] [] ``write'Rmode (v, n, m)`` |> hd @@ -215,7 +214,7 @@ in ~^st.Extensions Extension_Security==> ~^st.CPSR.J ==> n <> 15w ==> - ((n <> 13w) \/ Aligned (v, 4) \/ ~^st.CPSR.T) ==> + ((n <> 13w) \/ aligned 2 v \/ ~^st.CPSR.T) ==> (write'R (v, n) ^st = ((), ^st with REG := (R_mode (^st.CPSR.M) n =+ v) ^st.REG))`, rewrite_tac [in_ext] @@ -223,7 +222,7 @@ in \\ DISCH_THEN (fn th => IMP_RES_TAC (MATCH_MP (DISCH_ALL write'Rmode_rwt) th)) \\ simp [write'R_def] - \\ pop_assum (K all_tac) + \\ pop_assum kall_tac \\ lrw [R_mode_def, CurrentInstrSet_rwt] \\ fs [GoodMode_def] \\ blastLib.FULL_BBLAST_TAC @@ -257,12 +256,13 @@ local val a = ``(^st.Architecture <> ARMv4) /\ (^st.Architecture <> ARMv4T) /\ (^st.Architecture <> ARMv5T) /\ (^st.Architecture <> ARMv5TE) \/ - (Aligned (imm32: word32, 4))`` + aligned 2 (imm32: word32)`` val rwt = a |> boolSyntax.mk_neg |> utilsLib.SRW_CONV [] |> Thm.SYM in val BranchWritePC_rwt = EV [BranchWritePC_def, CurrentInstrSet_rwt, BranchTo_rwt, - ArchVersion_rwts, GSYM Aligned, not_cond, rwt] + ArchVersion_rwts, arm_stepTheory.aligned_23, not_cond, rwt, + Align_LoadWritePC] [[``^st.CPSR.T``], [``~^st.CPSR.T``, a]] [] ``BranchWritePC imm32`` end @@ -280,12 +280,14 @@ in ``BXWritePC imm32`` |> hd end +val align_aligned = UNDISCH_ALL (SPEC_ALL alignmentTheory.align_aligned) + local val rwt = Q.prove( `(^st.Architecture = ARMv4) \/ (^st.Architecture = ARMv4T) ==> (^st.Architecture <> ARMv4 /\ ^st.Architecture <> ARMv4T /\ ^st.Architecture <> ARMv5T /\ ^st.Architecture <> ARMv5TE \/ - Aligned (imm32: word32,4) = Aligned (imm32, 4))`, + aligned 2 (imm32: word32) = aligned 2 imm32)`, lrw [] \\ lfs []) |> Drule.UNDISCH val LoadWritePC_rwt1 = @@ -306,7 +308,7 @@ local val LoadWritePC_rwt3 = EV [LoadWritePC_def, hd (tl (BranchWritePC_rwt)), CurrentInstrSet_rwt, - ArchVersion_rwts, arm_stepTheory.Align_LoadWritePC] + ArchVersion_rwts, arm_stepTheory.Align_LoadWritePC, align_aligned] [[``~(^st.Architecture <> ARMv4 /\ ^st.Architecture <> ARMv4T)``]] [] ``LoadWritePC imm32`` |> hd @@ -346,59 +348,55 @@ val BigEndianReverse_rwt = local val rwts = [MemA_with_priv_def, cond_rand_thms, snd_exception_thms, - wordsTheory.WORD_ADD_0, bitstringTheory.v2w_w2v] @ + wordsTheory.WORD_ADD_0, bitstringTheory.v2w_w2v, + AlignedAlign, alignmentTheory.aligned_0, alignmentTheory.align_0] @ mem_rwt @ BigEndianReverse_rwt in val MemA_with_priv_1_rwt = - EV (rwts @ [Thm.CONJUNCT1 Aligned, bitstringTheory.field_fixwidth, - fixwidth_for ``:8``]) + EV (rwts @ [bitstringTheory.field_fixwidth, fixwidth_for ``:8``]) [] [] ``MemA_with_priv (v, 1, priv) : arm_state -> word8 # arm_state`` |> hd val MemU_with_priv_1_rwt = - EV (tl rwts @ [MemU_with_priv_def, MemA_with_priv_1_rwt, - Thm.CONJUNCT1 Aligned, Align]) + EV (tl rwts @ [MemU_with_priv_def, MemA_with_priv_1_rwt]) [] [] ``MemU_with_priv (v, 1, priv) : arm_state -> word8 # arm_state`` |> hd val MemA_with_priv_2_rwt = EV (extract16 :: rwts) - [[``Aligned (v:word32,2)``]] [] + [[``aligned 1 (v:word32)``]] [] ``MemA_with_priv (v, 2, priv) : arm_state -> word16 # arm_state`` |> hd val MemU_with_priv_2_rwt = - EV ([extract16, MemU_with_priv_def, AlignedAlign_2, MemA_with_priv_2_rwt] @ - tl rwts) - [[``Aligned (v:word32,2)``]] [] + EV ([extract16, MemU_with_priv_def, MemA_with_priv_2_rwt] @ tl rwts) + [[``aligned 1 (v:word32)``]] [] ``MemU_with_priv (v, 2, priv) : arm_state -> word16 # arm_state`` |> hd val MemA_with_priv_4_rwt = EV (extract32 :: rwts) - [[``Aligned (v:word32,4)``]] [] + [[``aligned 2 (v:word32)``]] [] ``MemA_with_priv (v, 4, priv) : arm_state -> word32 # arm_state`` |> hd val MemU_with_priv_4_rwt = - EV ([extract16, MemU_with_priv_def, AlignedAlign_4, MemA_with_priv_4_rwt] @ - tl rwts) - [[``Aligned (v:word32,4)``]] [] + EV ([extract16, MemU_with_priv_def, MemA_with_priv_4_rwt] @ tl rwts) + [[``aligned 2 (v:word32)``]] [] ``MemU_with_priv (v, 4, priv) : arm_state -> word32 # arm_state`` |> hd val MemA_with_priv_8_rwt = EV (extract64 :: rwts) - [[``Aligned (v:word32,8)``]] [] + [[``aligned 3 (v:word32)``]] [] ``MemA_with_priv (v, 8, priv) : arm_state -> word64 # arm_state`` |> hd val MemU_with_priv_8_rwt = - EV ([extract16, MemU_with_priv_def, AlignedAlign_8, MemA_with_priv_8_rwt] @ - tl rwts) - [[``Aligned (v:word32,8)``]] [] + EV ([extract16, MemU_with_priv_def, MemA_with_priv_8_rwt] @ tl rwts) + [[``aligned 3 (v:word32)``]] [] ``MemU_with_priv (v, 8, priv) : arm_state -> word64 # arm_state`` |> hd end @@ -479,8 +477,9 @@ local val field_cond_rand = Drule.ISPEC ``field h l`` boolTheory.COND_RAND val rwts = [write'MemA_with_priv_def, cond_rand_thms, snd_exception_thms, - wordsTheory.WORD_ADD_0, bitstringTheory.v2w_w2v, Thm.CONJUNCT1 Aligned, - field_cond_rand] @ write'mem_rwt @ BigEndianReverse_rwt + wordsTheory.WORD_ADD_0, bitstringTheory.v2w_w2v, field_cond_rand, + AlignedAlign, alignmentTheory.aligned_0, alignmentTheory.align_0] @ + write'mem_rwt @ BigEndianReverse_rwt in val write'MemA_with_priv_1_rwt = EV (rwts @ [fixwidth_for ``:8``, bitstringTheory.field_fixwidth]) [] [] @@ -495,26 +494,24 @@ in |> hd val write'MemA_with_priv_2_rwt = - EV (field16 :: rwts) [[``Aligned (v:word32,2)``]] [] + EV (field16 :: rwts) [[``aligned 1 (v:word32)``]] [] ``write'MemA_with_priv (w:word16, v, 2, priv)`` |> hd val write'MemU_with_priv_2_rwt = - EV ([write'MemU_with_priv_def, AlignedAlign_2, - write'MemA_with_priv_2_rwt] @ tl rwts) - [[``Aligned (v:word32,2)``]] [] + EV ([write'MemU_with_priv_def, write'MemA_with_priv_2_rwt] @ tl rwts) + [[``aligned 1 (v:word32)``]] [] ``write'MemU_with_priv (w: word16, v, 2, priv)`` |> hd val write'MemA_with_priv_4_rwt = - EV (field32 :: rwts) [[``Aligned (v:word32,4)``]] [] + EV (field32 :: rwts) [[``aligned 2 (v:word32)``]] [] ``write'MemA_with_priv (w:word32, v, 4, priv)`` |> hd val write'MemU_with_priv_4_rwt = - EV ([write'MemU_with_priv_def, AlignedAlign_4, - write'MemA_with_priv_4_rwt] @ tl rwts) - [[``Aligned (v:word32,4)``]] [] + EV ([write'MemU_with_priv_def, write'MemA_with_priv_4_rwt] @ tl rwts) + [[``aligned 2 (v:word32)``]] [] ``write'MemU_with_priv (w: word32, v, 4, priv)`` |> hd end @@ -667,12 +664,12 @@ fun regEV npcs thms ctxt s tm = fun memEV rl mem thms ctxt s tm = let - val thms = [NullCheckIfThumbEE_rwt, IncPC_rwt, PC_rwt, + val thms = [NullCheckIfThumbEE_rwt, IncPC_rwt, PC_rwt, R_rwt, armTheory.offset1_case_def, armTheory.offset2_case_def, pairTheory.pair_case_thm, - Shift_C_DecodeImmShift_rwt, Shift_C_LSL_rwt, - Aligned_plus, Shift_def, R_rwt] @ thms + Shift_C_DecodeImmShift_rwt, Shift_C_LSL_rwt, Shift_def, + alignmentTheory.aligned_add_sub_123] @ thms in List.map (fn r => EV ([r] @ thms) ctxt s tm |> List.map rl) mem |> List.concat @@ -761,7 +758,7 @@ local val cond_write'R_13_rwt = Q.prove( `~^st.CPSR.J ==> GoodMode (^st.CPSR.M) ==> ~^st.Extensions Extension_Security ==> - (p ==> (Aligned (w, 4) \/ ~^st.CPSR.T)) ==> + (p ==> (aligned 2 w \/ ~^st.CPSR.T)) ==> ((if p then ((), a, SND (write'R (w, 13w) s)) else @@ -795,50 +792,50 @@ local LDM_UPTO_0, LDM_UPTO_SUC]) tm end - fun LDM a i = - LDM_thm - |> Q.INST [`increment` |-> a, `index` |-> i] - |> Conv.RIGHT_CONV_RULE - (REWRITE_CONV [R_rwt, - ASSUME ``~word_bit 15 (registers: word16)``, - ASSUME ``n <> 15w: word4``] - THENC Conv.EVERY_CONV - (List.tabulate - (15, fn i => Conv.ONCE_DEPTH_CONV (FOR_BETA_CONV i)))) - |> utilsLib.ALL_HYP_CONV_RULE - (utilsLib.WGROUND_CONV - THENC REWRITE_CONV - [Aligned_plus, Aligned_concat4, LDM_UPTO_components] - THENC numLib.REDUCE_CONV) - |> REWRITE_RULE [rearrange] + val pc_conv = + Conv.RAND_CONV + (PairedLambda.let_CONV + THENC utilsLib.INST_REWRITE_CONV [hd MemA_4_rwt] + THENC REWRITE_CONV + [pairTheory.pair_case_thm, EVAL ``14 + 1n``, + alignmentTheory.aligned_numeric, + alignmentTheory.aligned_add_sub_123, + arm_stepTheory.Aligned_concat4, + LDM_UPTO_components] + THENC Conv.RAND_CONV + (Conv.RAND_CONV + (Conv.RATOR_CONV PairedLambda.GEN_BETA_CONV + THENC PairedLambda.GEN_BETA_CONV) + THENC PairedLambda.let_CONV)) + + val pc_tm = ``word_bit 15 (registers: word16)`` + + fun LDM ispc a i = + let + val (tm, cnv) = if ispc then (pc_tm, pc_conv) + else (boolSyntax.mk_neg pc_tm, ALL_CONV) + in + LDM_thm + |> Q.INST [`increment` |-> a, `index` |-> i] + |> Conv.RIGHT_CONV_RULE + (REWRITE_CONV [R_rwt, ASSUME tm, ASSUME ``n <> 15w: word4``] + THENC Conv.EVERY_CONV + (List.tabulate + (15, fn i => Conv.ONCE_DEPTH_CONV (FOR_BETA_CONV i))) + THENC cnv) + |> utilsLib.ALL_HYP_CONV_RULE + (utilsLib.WGROUND_CONV + THENC REWRITE_CONV + [alignmentTheory.aligned_numeric, + alignmentTheory.aligned_add_sub_123, + arm_stepTheory.Aligned_concat4, + LDM_UPTO_components] + THENC numLib.REDUCE_CONV) + |> REWRITE_RULE [rearrange] + end - fun LDM_PC a i = - LDM_thm - |> Q.INST [`increment` |-> a, `index` |-> i] - |> Conv.RIGHT_CONV_RULE - (REWRITE_CONV [R_rwt, - ASSUME ``word_bit 15 (registers: word16)``, - ASSUME ``n <> 15w: word4``] - THENC Conv.EVERY_CONV - (List.tabulate - (15, fn i => Conv.ONCE_DEPTH_CONV (FOR_BETA_CONV i))) - THENC Conv.RAND_CONV - (PairedLambda.let_CONV - THENC utilsLib.INST_REWRITE_CONV [hd MemA_4_rwt] - THENC REWRITE_CONV - [pairTheory.pair_case_thm, EVAL ``14 + 1n``, - LDM_UPTO_components] - THENC Conv.RAND_CONV - (Conv.RAND_CONV - (Conv.RATOR_CONV PairedLambda.GEN_BETA_CONV - THENC PairedLambda.GEN_BETA_CONV) - THENC PairedLambda.let_CONV))) - |> utilsLib.ALL_HYP_CONV_RULE - (utilsLib.WGROUND_CONV - THENC REWRITE_CONV - [Aligned_plus, Aligned_concat4, LDM_UPTO_components] - THENC numLib.REDUCE_CONV) - |> REWRITE_RULE [rearrange] + val LDM_PC = LDM true + val LDM = LDM false val LDMDA_PC = LDM_PC `F` `F` val LDMDB_PC = LDM_PC `F` `T` @@ -849,6 +846,17 @@ local val LDMDB = LDM `F` `T` val LDMIA = LDM `T` `F` val LDMIB = LDM `T` `T` + + val rule = + REWRITE_RULE [count_list_15] o + utilsLib.ALL_HYP_CONV_RULE + (DATATYPE_CONV + THENC REWRITE_CONV + [ASSUME ``aligned 2 (^st.REG (arm_step$R_mode ^st.CPSR.M n))``, + alignmentTheory.aligned_numeric, + alignmentTheory.aligned_add_sub_123, + arm_stepTheory.Aligned_concat4, + LDM_UPTO_components]) in fun ldmEV wb = EV [LDMDA, LDMDB, LDMIA, LDMIB, LDM_UPTO_def, IncPC_rwt, LDM_UPTO_PC, @@ -862,8 +870,7 @@ in [`inc` |-> ``T``, `index` |-> ``T``]] ``dfn'LoadMultiple (inc, index, ^(bitstringSyntax.mk_b wb), n, registers)`` - |> List.map (REWRITE_RULE [count_list_15] o - utilsLib.ALL_HYP_CONV_RULE DATATYPE_CONV) + |> List.map rule |> addThms fun ldm_pcEV wb = @@ -879,15 +886,7 @@ in [`inc` |-> ``T``, `index` |-> ``T``]] ``dfn'LoadMultiple (inc, index, ^(bitstringSyntax.mk_b wb), n, registers)`` - |> List.map - (REWRITE_RULE [count_list_15] o - utilsLib.ALL_HYP_CONV_RULE - (DATATYPE_CONV - THENC REWRITE_CONV - [ASSUME - ``Aligned - (^st.REG (arm_step$R_mode ^st.CPSR.M n),4)``, - Aligned_plus, LDM_UPTO_components]))) + |> List.map rule) LoadWritePC_rwt |> List.concat |> addThms @@ -954,7 +953,10 @@ in |> utilsLib.ALL_HYP_CONV_RULE (numLib.REDUCE_CONV THENC REWRITE_CONV - [Aligned_plus, Aligned_concat4, STM_UPTO_components] + [alignmentTheory.aligned_numeric, + alignmentTheory.aligned_add_sub_123, + arm_stepTheory.Aligned_concat4, + STM_UPTO_components] THENC utilsLib.INST_REWRITE_CONV [R_rwt] THENC DATATYPE_CONV) |> utilsLib.ALL_HYP_CONV_RULE (REWRITE_CONV [STM_UPTO_components]) @@ -1004,11 +1006,16 @@ in ``a \/ b \/ c : bool`` o utilsLib.ALL_HYP_CONV_RULE (DATATYPE_CONV - THENC REWRITE_CONV [boolTheory.COND_ID, Aligned_plus]) o + THENC REWRITE_CONV + [boolTheory.COND_ID, + alignmentTheory.aligned_numeric, + alignmentTheory.aligned_add_sub_123]) o utilsLib.ALL_HYP_CONV_RULE (DATATYPE_CONV THENC SIMP_CONV std_ss - [pairTheory.pair_case_thm, Aligned_plus] + [pairTheory.pair_case_thm, + alignmentTheory.aligned_numeric, + alignmentTheory.aligned_add_sub_123] THENC utilsLib.INST_REWRITE_CONV [hd write'MemA_4_rwt])) |> addThms end @@ -1325,8 +1332,10 @@ local utilsLib.ALL_HYP_CONV_RULE DATATYPE_CONV val ALIGNED_PLUS_RULE = - utilsLib.MATCH_HYP_CONV_RULE (REWRITE_CONV [Aligned_plus]) - ``Aligned (a + b : 'a word, c)`` + utilsLib.MATCH_HYP_CONV_RULE + (REWRITE_CONV [alignmentTheory.aligned_numeric, + alignmentTheory.aligned_add_sub_123]) + ``aligned c (a + b : 'a word)`` val thumb2_test_tm = fix_datatype @@ -2590,25 +2599,35 @@ val Setend_rwt = (* ---------------------------- *) val BranchTarget_rwts = - List.map (fn b => - EV [dfn'BranchTarget_def, PC_rwt, b, not_cond] [] [] - ``dfn'BranchTarget imm32``) BranchWritePC_rwt - |> List.concat - |> List.map - (utilsLib.MATCH_HYP_RULE - (utilsLib.INST_REWRITE_RULE [AlignedPC_plus] o - ASM_REWRITE_RULE []) ``a \/ b : bool`` o - utilsLib.INST_REWRITE_RULE - [AlignedPC_plus_thumb, AlignedPC_plus_arm] o - ASM_REWRITE_RULE [] o - FULL_DATATYPE_RULE) + let + val thms = [dfn'BranchTarget_def, PC_rwt, not_cond, align_aligned] + val tm = + ``aligned 2 (s.REG RName_PC + (if s.CPSR.T then 4w else 8w) + imm32)`` + in + ( + EV (hd BranchWritePC_rwt :: thms) [] [] + ``dfn'BranchTarget imm32`` + |> List.map (utilsLib.ALL_HYP_RULE + (utilsLib.INST_REWRITE_RULE [Aligned_BranchTarget_thumb])) + ) + @ + ( + EV (tl BranchWritePC_rwt @ thms) [] [] + ``dfn'BranchTarget imm32`` + |> List.map (utilsLib.ALL_HYP_CONV_RULE + (utilsLib.INST_REWRITE_CONV [ASSUME tm] + THENC REWRITE_CONV [])) + |> List.map (utilsLib.ALL_HYP_RULE + (utilsLib.INST_REWRITE_RULE [Aligned_BranchTarget_arm])) + ) |> addThms + end (* ---------------------------- *) val BranchExchange_rwt = - EV ([dfn'BranchExchange_def, R_rwt, BXWritePC_rwt, CurrentInstrSet_rwt] @ - SelectInstrSet_rwt) + EV ([dfn'BranchExchange_def, R_rwt, BXWritePC_rwt, CurrentInstrSet_rwt, + Align_LoadWritePC] @ SelectInstrSet_rwt) [[``m <> 15w: word4``]] [] ``dfn'BranchExchange m`` |> List.map COND_UPDATE_RULE @@ -2623,24 +2642,19 @@ val BranchExchange_pc_arm_rwt = (utilsLib.MATCH_HYP_CONV_RULE (utilsLib.INST_REWRITE_CONV [arm_stepTheory.Aligned4_bit0, arm_stepTheory.Aligned4_bit1] - THENC REWRITE_CONV []) ``a ==> b`` o - COND_UPDATE_RULE) - |> addThms + THENC REWRITE_CONV []) ``a ==> b``) val BranchExchange_pc_thumb_rwt = EV ([dfn'BranchExchange_def, BXWritePC_rwt, R15_rwt, - arm_stepTheory.Aligned2_bit0, CurrentInstrSet_rwt] @ SelectInstrSet_rwt) + Aligned4_bit0_t, CurrentInstrSet_rwt] @ SelectInstrSet_rwt) [[``^st.CPSR.T``]] [] ``dfn'BranchExchange 15w`` |> List.map (utilsLib.MATCH_HYP_CONV_RULE (utilsLib.INST_REWRITE_CONV - [arm_stepTheory.Aligned2_bit0, - blastLib.BBLAST_PROVE - ``word_bit 1 (pc + 4w: word32) = word_bit 1 pc``] - THENC REWRITE_CONV []) ``a ==> b`` o - COND_UPDATE_RULE) - |> addThms + [arm_stepTheory.Aligned4_bit0_t, + arm_stepTheory.Aligned4_bit1_t] + THENC REWRITE_CONV []) ``a ==> b``) (* ---------------------------- *) @@ -2652,7 +2666,7 @@ val R_x_14_not_pc = val BranchLinkExchangeRegister_rwt = EV ([dfn'BranchLinkExchangeRegister_def, R_rwt, write'R_rwt, PC_rwt, BXWritePC_rwt, CurrentInstrSet_rwt, write'LR_def, R_x_14_not_pc, - not_cond] @ SelectInstrSet_rwt) + not_cond, Align_LoadWritePC] @ SelectInstrSet_rwt) [[``m <> 15w: word4``]] [] ``dfn'BranchLinkExchangeRegister m`` |> List.map @@ -2811,7 +2825,7 @@ val ArithLogicImmediate_rwt = ExpandImm_C_rwt] @ al) [[``d <> 15w: word4``]] (mapl (`op`, arithlogic)) ``dfn'ArithLogicImmediate - (op, s, d, n, ^(bitstringSyntax.mk_vec 12 0))`` + (op, setflags, d, n, ^(bitstringSyntax.mk_vec 12 0))`` |> addThms (* ---------------------------- *) @@ -3025,7 +3039,7 @@ val align_base_pc_rule = (utilsLib.INST_REWRITE_CONV [Aligned2_base_pc_plus, Aligned2_base_pc_minus, Aligned4_base_pc_plus, Aligned4_base_pc_minus]) - ``Aligned (w: word32, n)`` + ``aligned n (w: word32)`` val rule_base_pc = align_base_pc_rule o @@ -3037,12 +3051,12 @@ val rule_base_pc = val rule_literal_pc = utilsLib.MATCH_HYP_CONV_RULE (REWRITE_CONV [Aligned_Align_plus_minus]) - ``Aligned (w: word32, 4)`` o + ``aligned 2 (w: word32)`` o ASM_REWRITE_RULE [] val rule_literal = utilsLib.MATCH_HYP_CONV_RULE (REWRITE_CONV [Aligned_Align_plus_minus]) - ``Aligned (w: word32, n)`` o + ``aligned n (w: word32)`` o utilsLib.INST_REWRITE_RULE [Align4_base_pc_plus, Align4_base_pc_minus] o REWRITE_RULE (npc_thm [`t`]) o DATATYPE_RULE o @@ -3054,7 +3068,8 @@ val rule_npc2 = utilsLib.ALL_HYP_CONV_RULE (Conv.DEPTH_CONV (utilsLib.INST_REWRITE_CONV [write'R_rwt]) THENC DATATYPE_CONV - THENC REWRITE_CONV [Aligned_plus]) o + THENC REWRITE_CONV [alignmentTheory.aligned_numeric, + alignmentTheory.aligned_add_sub_123]) o REWRITE_RULE (npc_thm [`t`, `t2`, `n`]) o FULL_DATATYPE_RULE o Conv.CONV_RULE (Conv.DEPTH_CONV (utilsLib.INST_REWRITE_CONV [write'R_rwt])) o @@ -3064,7 +3079,8 @@ val rule_base_pc2 = utilsLib.ALL_HYP_CONV_RULE (Conv.DEPTH_CONV (utilsLib.INST_REWRITE_CONV [write'R_rwt]) THENC DATATYPE_CONV - THENC REWRITE_CONV [Aligned_plus] + THENC REWRITE_CONV [alignmentTheory.aligned_numeric, + alignmentTheory.aligned_add_sub_123] THENC utilsLib.INST_REWRITE_CONV [Aligned4_base_pc_plus, Aligned4_base_pc_minus]) o REWRITE_RULE (npc_thm [`t`, `t2`]) o @@ -3075,12 +3091,13 @@ val rule_base_pc2 = val rule_literal2 = utilsLib.MATCH_HYP_CONV_RULE (REWRITE_CONV [Aligned_Align_plus_minus]) - ``Aligned (w: word32, n)`` o + ``aligned n (w: word32)`` o utilsLib.INST_REWRITE_RULE [Align4_base_pc_plus, Align4_base_pc_minus] o utilsLib.ALL_HYP_CONV_RULE (Conv.DEPTH_CONV (utilsLib.INST_REWRITE_CONV [write'R_rwt]) THENC DATATYPE_CONV - THENC REWRITE_CONV [Aligned_plus]) o + THENC REWRITE_CONV [alignmentTheory.aligned_numeric, + alignmentTheory.aligned_add_sub_123]) o REWRITE_RULE (npc_thm [`t`, `t2`]) o FULL_DATATYPE_RULE o Conv.CONV_RULE (Conv.DEPTH_CONV (utilsLib.INST_REWRITE_CONV [write'R_rwt])) o @@ -3219,7 +3236,8 @@ val rule_npc2 = utilsLib.ALL_HYP_CONV_RULE (Conv.DEPTH_CONV (utilsLib.INST_REWRITE_CONV [R_rwt]) THENC DATATYPE_CONV - THENC REWRITE_CONV [Aligned_plus]) o + THENC REWRITE_CONV [alignmentTheory.aligned_numeric, + alignmentTheory.aligned_add_sub_123]) o rule_sp o utilsLib.MATCH_HYP_CONV_RULE (utilsLib.INST_REWRITE_CONV [Aligned_plus_minus]) ``a \/ b \/ c : bool`` o @@ -3322,7 +3340,7 @@ val StoreHalf_base_pc_rwt = val StoreDual_rwt = storeEV rule_npc2 - write'MemA_4_rwt [dfn'StoreDual_def, Aligned_plus] + write'MemA_4_rwt [dfn'StoreDual_def, alignmentTheory.aligned_add_sub_123] [[``Aligned (^st.REG (R_mode ^st.CPSR.M n), 4)``, ``Aligned (^st.REG (R_mode ^st.CPSR.M n) + FST (FST (Shift_C (^st.REG (R_mode ^st.CPSR.M r), @@ -3342,17 +3360,9 @@ val StoreDual_rwt = (* ---------------------------- *) -val align4_rwt = - arm_stepTheory.Aligned - |> Drule.CONJUNCTS - |> tl |> tl |> hd - |> Drule.SPEC_ALL - |> Thm.EQ_IMP_RULE |> fst - |> Drule.UNDISCH - val Swap_rwts = EV ([R_rwt, write'R_rwt, Q.INST [`d` |-> `t`] arm_stepTheory.R_x_not_pc, - dfn'Swap_def, IncPC_rwt, ROR_rwt, align4_rwt, + dfn'Swap_def, IncPC_rwt, ROR_rwt, EVAL ``(a: word32) #>> (8 * w2n (0w: word2))``] @ MemA_1_rwt @ write'MemA_1_rwt @ MemA_4_rwt @ write'MemA_4_rwt) [[``^st.Encoding = Encoding_ARM``, ``~^st.CPSR.T``, @@ -3399,7 +3409,8 @@ fun fpMemEV c tm = (DATATYPE_CONV THENC REWRITE_CONV [arm_stepTheory.Aligned_Align_plus_minus, - arm_stepTheory.Aligned_plus]) o rule) + alignmentTheory.aligned_add_sub_123, + alignmentTheory.aligned_numeric]) o rule) fun fpEV c tm = EV [dfn'vadd_def, dfn'vsub_def, dfn'vmul_def, dfn'vneg_mul_def, @@ -3748,7 +3759,8 @@ val ReturnFromException_le_rwts = utilsLib.ALL_HYP_CONV_RULE (DATATYPE_CONV THENC REWRITE_CONV - [arm_stepTheory.Aligned_numeric, + [alignmentTheory.aligned_add_sub_123, + alignmentTheory.aligned_numeric, ASSUME ``^st.CPSR.M <> 16w``])) |> addThms diff --git a/examples/l3-machine-code/arm/step/arm_stepScript.sml b/examples/l3-machine-code/arm/step/arm_stepScript.sml index f882ebb8b4..0e8cac13a3 100644 --- a/examples/l3-machine-code/arm/step/arm_stepScript.sml +++ b/examples/l3-machine-code/arm/step/arm_stepScript.sml @@ -6,7 +6,7 @@ open HolKernel boolLib bossLib open lcsymtacs utilsLib open wordsLib blastLib -open state_transformerTheory updateTheory armTheory +open state_transformerTheory updateTheory alignmentTheory armTheory val _ = new_theory "arm_step" @@ -15,9 +15,6 @@ val _ = new_theory "arm_step" val _ = List.app (fn f => f ()) [numLib.prefer_num, wordsLib.prefer_word, wordsLib.guess_lengths] -infix \\ -val op \\ = op THEN; - (* ------------------------------------------------------------------------ *) val NextStateARM_def = Define` @@ -524,257 +521,180 @@ val bit_count_lt_1 = Q.store_thm("bit_count_lt_1", (* ------------------------------------------------------------------------ *) -val Align_slice = Q.prove( - `!n a : 'a word. Align (a, 2 ** n) = (dimindex(:'a) - 1 '' n) a`, - strip_tac - \\ Cases - \\ lrw [Align_def, wordsTheory.word_slice_n2w, - bitTheory.SLICE_THM, bitTheory.BITS_THM2, - DECIDE ``0 < n ==> (SUC (n - 1) = n)``] - \\ lfs [wordsTheory.dimword_def] - ) - -val slice_all = Q.prove( - `!a:'a word. (dimindex(:'a) - 1 '' 0) a = a`, - simp [wordsTheory.WORD_SLICE_BITS_THM, wordsTheory.WORD_ALL_BITS]) - -val Align = Theory.save_thm ("Align", - (REWRITE_RULE [slice_all] o numLib.REDUCE_RULE o Drule.LIST_CONJ) - (List.map (fn t => Q.SPEC t Align_slice) [`0`,`1`,`2`,`3`])) - -val Aligned = Q.store_thm ("Aligned", - `(!a : word32. Aligned (a, 1)) /\ - (!a : word32. Aligned (a, 2) = ~word_lsb a) /\ - (!a : word32. Aligned (a, 4) = ((1 >< 0) a = 0w:word2)) /\ - (!a : word32. Aligned (a, 8) = ((2 >< 0) a = 0w:word3)) /\ - (!a : word8. Aligned (a, 4) = ((1 >< 0) a = 0w:word2))`, - lrw [Aligned_def, Align] \\ blastLib.BBLAST_TAC - ) +val Align = Q.store_thm("Align", + `(!w. Align (w, 1) = align 0 w) /\ + (!w. Align (w, 2) = align 1 w) /\ + (!w. Align (w, 4) = align 2 w) /\ + (!w. Align (w, 8) = align 3 w) /\ + (!w. Align (w, 16) = align 4 w)`, + simp [armTheory.Align_def, alignmentTheory.align_w2n] + ) -val AlignAlign = Q.store_thm ("AlignAlign", - `(!v : word32. Align (Align (v,2),2) = Align (v,2)) /\ - (!v : word32. Align (Align (v,4),4) = Align (v,4)) /\ - (!v : word32. Align (Align (v,8),8) = Align (v,8))`, - srw_tac [wordsLib.WORD_EXTRACT_ss] [Align] - ) +val Aligned = Q.store_thm("Aligned", + `(!w. Aligned (w, 1) = aligned 0 w) /\ + (!w. Aligned (w, 2) = aligned 1 w) /\ + (!w. Aligned (w, 4) = aligned 2 w) /\ + (!w. Aligned (w, 8) = aligned 3 w) /\ + (!w. Aligned (w, 16) = aligned 4 w)`, + simp [armTheory.Aligned_def, Align, alignmentTheory.aligned_def, + boolTheory.EQ_SYM_EQ] + ) -val AlignedAlign_2 = ustore_thm("AlignedAlign_2", - `Aligned (v:word32, 2) ==> ((if b then Align (v, 2) else v) = v)`, - lrw [Aligned_def, AlignAlign] +val aligned_23 = Q.store_thm("aligned_23", + `(!w: word32. ((1 >< 0) w = 0w: word2) = aligned 2 w) /\ + (!w: word32. ((2 >< 0) w = 0w: word3) = aligned 3 w)`, + simp [alignmentTheory.aligned_extract] + \\ blastLib.BBLAST_TAC ) -val AlignedAlign_4 = ustore_thm("AlignedAlign_4", - `Aligned (v:word32, 4) ==> ((if b then Align (v, 4) else v) = v)`, - lrw [Aligned_def, AlignAlign] +val AlignedAlign = ustore_thm("AlignedAlign", + `aligned p v ==> ((if b then align p v else v) = v)`, + lrw [alignmentTheory.aligned_def, alignmentTheory.align_align] ) -val AlignedAlign_8 = ustore_thm("AlignedAlign_8", - `Aligned (v:word32, 8) ==> ((if b then Align (v, 8) else v) = v)`, - lrw [Aligned_def, AlignAlign] +val Aligned_concat4 = Q.store_thm("Aligned_concat4", + `!p a: word8 b: word8 c: word8 d: word8. + aligned 2 (if p then a @@ b @@ c @@ d else d @@ c @@ b @@ a) = + aligned 2 (if p then d else a)`, + lrw [alignmentTheory.aligned_extract] + \\ blastLib.BBLAST_TAC ) -val Aligned_plus = Q.store_thm("Aligned_plus", - `(!w: word32. Aligned (w + 2w, 2) = Aligned (w, 2)) /\ - (!w: word32. Aligned (w + 4w, 4) = Aligned (w, 4)) /\ - (!w x: word32. Aligned (w - 4w * x, 4) = Aligned (w, 4)) /\ - (!w x: word32. Aligned (w + 4w * x, 4) = Aligned (w, 4))`, - rw [Aligned] \\ blastLib.BBLAST_TAC +val Aligned4_bit0_t = utilsLib.ustore_thm ("Aligned4_bit0_t", + `aligned 2 (pc: word32) ==> ~word_bit 0 (pc + 4w)`, + simp [alignmentTheory.aligned_extract] + \\ blastLib.BBLAST_TAC ) -val AlignedPC_plus = ustore_thm("AlignedPC_plus", - `Aligned (pc: word32, 4) ==> - (Aligned (pc + 8w + imm, 4) = Aligned (imm, 4))`, - simp [Aligned] \\ blastLib.BBLAST_TAC +val Aligned4_bit1_t = utilsLib.ustore_thm ("Aligned4_bit1_t", + `aligned 2 (pc: word32) ==> ~word_bit 1 (pc + 4w)`, + simp [alignmentTheory.aligned_extract] + \\ blastLib.BBLAST_TAC ) -val AlignedPC_plus_thumb = ustore_thm("AlignedPC_plus_thumb", - `Aligned (w: word32, 2) ==> - (((31 >< 1) (w + 4w + v): 31 word) @@ (0w: word1) = w + Align (v, 2) + 4w)`, - simp [Aligned, Align] \\ blastLib.BBLAST_TAC +val Aligned4_bit0 = utilsLib.ustore_thm ("Aligned4_bit0", + `aligned 2 (pc: word32) ==> ~word_bit 0 (pc + 8w)`, + simp [alignmentTheory.aligned_extract] + \\ blastLib.BBLAST_TAC ) -val AlignedPC_plus_xthumb = ustore_thm("AlignedPC_plus_xthumb", - `Aligned (w: word32, 2) ==> - (((31 >< 1) (w + 4w): 31 word) @@ (1w: word1) = w + 5w)`, - simp [Aligned] \\ blastLib.BBLAST_TAC +val Aligned4_bit1 = utilsLib.ustore_thm ("Aligned4_bit1", + `aligned 2 (pc: word32) ==> ~word_bit 1 (pc + 8w)`, + simp [alignmentTheory.aligned_extract] + \\ blastLib.BBLAST_TAC ) -val AlignedPC_plus_arm = ustore_thm("AlignedPC_plus_arm", - `Aligned (w: word32, 4) ==> - (((31 >< 2) (w + 8w + v): 30 word) @@ (0w: word2) = w + Align (v, 4) + 8w)`, - simp [Aligned, Align] \\ blastLib.BBLAST_TAC +val Aligned_BranchTarget_thumb = + utilsLib.ustore_thm("Aligned_BranchTarget_thumb", + `aligned 1 (pc: word32) ==> + (aligned 1 (pc + (if b then 4w else 8w) + imm32) = aligned 1 imm32)`, + Cases_on `b` + \\ simp [alignmentTheory.aligned_extract] + \\ blastLib.BBLAST_TAC ) -val AlignedPC_plus_xarm = ustore_thm("AlignedPC_plus_xarm", - `Aligned (w: word32, 4) ==> - (((31 >< 1) (w + 8w + v): 31 word) @@ (0w: word1) = w + Align (v, 2) + 8w)`, - simp [Aligned, Align] \\ blastLib.BBLAST_TAC +val Aligned_BranchTarget_arm = utilsLib.ustore_thm("Aligned_BranchTarget_arm", + `aligned 2 (pc: word32) ==> + (aligned 2 (pc + (if b then 4w else 8w) + imm32) = aligned 2 imm32)`, + Cases_on `b` + \\ simp [alignmentTheory.aligned_extract] + \\ blastLib.BBLAST_TAC ) -val AlignedPC_plus_align_arm = ustore_thm("AlignedPC_plus_align_arm", - `Aligned (w: word32, 4) ==> - (((31 >< 2) (Align (w + 8w: word32, 4) + v): 30 word) @@ (0w: word2) = - w + Align (v, 4) + 8w)`, - simp [Aligned, Align] \\ blastLib.BBLAST_TAC +val Aligned_Align_plus_minus = Q.store_thm("Aligned_Align_plus_minus", + `(!w x: word32. aligned 2 (align 2 w + x) = aligned 2 x) /\ + (!w x: word32. aligned 2 (align 2 w - x) = aligned 2 x) /\ + (!w x: word32. aligned 1 (align 2 w + x) = aligned 1 x) /\ + (!w x: word32. aligned 1 (align 2 w - x) = aligned 1 x)`, + lrw [alignmentTheory.aligned_extract, alignmentTheory.align_def] + \\ blastLib.BBLAST_TAC ) -val Aligned_plus_minus = ustore_thm("Aligned_plus_minus", - `Aligned (x: word32, 4) ==> - (Aligned (if a then x + y else x - y, 4) = Aligned (y, 4))`, - lrw [Aligned] \\ blastLib.FULL_BBLAST_TAC +val AlignedPC_plus_thumb = utilsLib.ustore_thm("AlignedPC_plus_thumb", + `aligned 1 (w: word32) ==> (align 1 (w + 4w + v) = w + align 1 v + 4w)`, + simp [alignmentTheory.aligned_extract, alignmentTheory.align_def] + \\ blastLib.BBLAST_TAC ) -val Aligned4_base_pc_plus = ustore_thm("Aligned4_base_pc_plus", - `Aligned (pc: word32, if t then 2 else 4) ==> - (Aligned (pc + (if t then 4w else 8w) + x, 4) = - if t then Aligned (pc + x, 4) else Aligned (x, 4))`, - lrw [Aligned, Align] - \\ blastLib.FULL_BBLAST_TAC +val AlignedPC_plus_xthumb = utilsLib.ustore_thm("AlignedPC_plus_xthumb", + `aligned 1 (w: word32) ==> + (((31 >< 1) (w + 4w): 31 word) @@ (1w: word1) = w + 5w)`, + simp [alignmentTheory.aligned_extract] \\ blastLib.BBLAST_TAC ) -val Aligned4_base_pc_minus = ustore_thm("Aligned4_base_pc_minus", - `Aligned (pc: word32, if t then 2 else 4) ==> - (Aligned (pc + (if t then 4w else 8w) - x, 4) = - if t then Aligned (pc - x, 4) else Aligned (x, 4))`, - lrw [Aligned, Align] - \\ blastLib.FULL_BBLAST_TAC +val AlignedPC_plus_align_arm = utilsLib.ustore_thm("AlignedPC_plus_align_arm", + `aligned 2 (w: word32) ==> + (align 2 (align 2 (w + 8w) + v) = w + align 2 v + 8w)`, + simp [alignmentTheory.aligned_extract, alignmentTheory.align_def] + \\ blastLib.BBLAST_TAC ) -val Aligned2_base_pc_plus = ustore_thm("Aligned2_base_pc_plus", - `Aligned (pc: word32, if t then 2 else 4) ==> - (Aligned (pc + (if t then 4w else 8w) + x, 2) = Aligned (x, 2))`, - lrw [Aligned, Align] - \\ blastLib.FULL_BBLAST_TAC +val AlignedPC_plus_xarm = utilsLib.ustore_thm("AlignedPC_plus_xarm", + `aligned 2 (w: word32) ==> (align 1 (w + 8w + v) = w + align 1 v + 8w)`, + simp [alignmentTheory.aligned_extract, alignmentTheory.align_def] + \\ blastLib.BBLAST_TAC ) -val Aligned2_base_pc_minus = ustore_thm("Aligned2_base_pc_minus", - `Aligned (pc: word32, if t then 2 else 4) ==> - (Aligned (pc + (if t then 4w else 8w) - x, 2) = Aligned (x, 2))`, - lrw [Aligned, Align] - \\ blastLib.FULL_BBLAST_TAC +val Aligned_plus_minus = utilsLib.ustore_thm("Aligned_plus_minus", + `aligned 2 (x: word32) ==> + (aligned 2 (if a then x + y else x - y) = aligned 2 y)`, + lrw [alignmentTheory.aligned_extract] \\ blastLib.FULL_BBLAST_TAC ) -val Align4_base_pc_plus = ustore_thm("Align4_base_pc_plus", - `Aligned (pc: word32, if t then 2 else 4) ==> - (Align (pc + if t then 4w else 8w, 4) + x = - if t then Align (pc, 4) + (x + 4w) else pc + (x + 8w))`, - lrw [Aligned, Align] +val Aligned4_base_pc_plus = utilsLib.ustore_thm("Aligned4_base_pc_plus", + `aligned (if t then 1 else 2) (pc: word32) ==> + (aligned 2 (pc + (if t then 4w else 8w) + x) = + if t then aligned 2 (pc + x) else aligned 2 x)`, + lrw [alignmentTheory.aligned_extract] \\ blastLib.FULL_BBLAST_TAC ) -val Align4_base_pc_minus = ustore_thm("Align4_base_pc_minus", - `Aligned (pc: word32, if t then 2 else 4) ==> - (Align (pc + if t then 4w else 8w, 4) - x = - if t then Align (pc, 4) - (x - 4w) else pc - (x - 8w))`, - lrw [Aligned, Align] +val Aligned4_base_pc_minus = utilsLib.ustore_thm("Aligned4_base_pc_minus", + `aligned (if t then 1 else 2) (pc: word32) ==> + (aligned 2 (pc + (if t then 4w else 8w) - x) = + if t then aligned 2 (pc - x) else aligned 2 x)`, + lrw [alignmentTheory.aligned_extract] \\ blastLib.FULL_BBLAST_TAC ) -val Aligned_Align_plus_minus = Q.store_thm("Aligned_Align_plus_minus", - `(!w x: word32. Aligned (Align (w, 4) + x, 4) = Aligned (x, 4)) /\ - (!w x: word32. Aligned (Align (w, 4) - x, 4) = Aligned (x, 4)) /\ - (!w x: word32. Aligned (Align (w, 4) + x, 2) = Aligned (x, 2)) /\ - (!w x: word32. Aligned (Align (w, 4) - x, 2) = Aligned (x, 2))`, - lrw [Aligned, Align] \\ blastLib.BBLAST_TAC - ) - -val Aligned_concat4 = Q.store_thm("Aligned_concat4", - `!p a: word8 b: word8 c: word8 d: word8. - Aligned (if p then a @@ b @@ c @@ d else d @@ c @@ b @@ a, 4) = - Aligned (if p then d else a, 4)`, - lrw [Aligned] \\ blastLib.BBLAST_TAC - ) - -val Aligned2_bit0 = utilsLib.ustore_thm ("Aligned2_bit0", - `Aligned (pc: word32, 2) ==> ~word_bit 0 (pc + 4w)`, - simp [Aligned] - \\ blastLib.BBLAST_TAC - ) - -val Aligned4_bit0 = utilsLib.ustore_thm ("Aligned4_bit0", - `Aligned (pc: word32, 4) ==> ~word_bit 0 (pc + 8w)`, - simp [Aligned] - \\ blastLib.BBLAST_TAC - ) - -val Aligned4_bit1 = utilsLib.ustore_thm ("Aligned4_bit1", - `Aligned (pc: word32, 4) ==> ~word_bit 1 (pc + 8w)`, - simp [Aligned] - \\ blastLib.BBLAST_TAC +val Aligned2_base_pc_plus = utilsLib.ustore_thm("Aligned2_base_pc_plus", + `aligned (if t then 1 else 2) (pc: word32) ==> + (aligned 1 (pc + (if t then 4w else 8w) + x) = aligned 1 x)`, + lrw [alignmentTheory.aligned_extract] + \\ blastLib.FULL_BBLAST_TAC ) -(* ------------------------------------------------------------------------ *) - -val BIT_lem = Q.prove( - `(!x. NUMERAL (BIT2 x) = 2 * (x + 1)) /\ - (!x. NUMERAL (BIT1 x) = 2 * x + 1) /\ - (!x. NUMERAL (BIT1 (BIT1 x)) = 4 * x + 3) /\ - (!x. NUMERAL (BIT1 (BIT2 x)) = 4 * (x + 1) + 1) /\ - (!x. NUMERAL (BIT2 (BIT1 x)) = 4 * (x + 1)) /\ - (!x. NUMERAL (BIT2 (BIT2 x)) = 4 * (x + 1) + 2)`, - REPEAT strip_tac - \\ CONV_TAC (Conv.LHS_CONV - (REWRITE_CONV [arithmeticTheory.BIT1, arithmeticTheory.BIT2, - arithmeticTheory.NUMERAL_DEF])) - \\ DECIDE_TAC +val Aligned2_base_pc_minus = utilsLib.ustore_thm("Aligned2_base_pc_minus", + `aligned (if t then 1 else 2) (pc: word32) ==> + (aligned 1 (pc + (if t then 4w else 8w) - x) = aligned 1 x)`, + lrw [alignmentTheory.aligned_extract] + \\ blastLib.FULL_BBLAST_TAC ) -val Aligned_eq = Q.prove( - `(!a b. (Aligned (a: word32, 4) = Aligned (b: word32, 4)) = - (~a ' 0 /\ ~a ' 1 = ~b ' 0 /\ ~b ' 1)) /\ - (!a b. (Aligned (a: word32, 2) = Aligned (b: word32, 2)) = - (a ' 0 = b ' 0))`, - lrw [Aligned] - \\ blastLib.BBLAST_TAC +val Align4_base_pc_plus = utilsLib.ustore_thm("Align4_base_pc_plus", + `aligned (if t then 1 else 2) (pc: word32) ==> + (align 2 (pc + if t then 4w else 8w) + x = + if t then align 2 pc + (x + 4w) else pc + (x + 8w))`, + lrw [alignmentTheory.aligned_extract, alignmentTheory.align_def] + \\ blastLib.FULL_BBLAST_TAC ) -val Aligned_numeric = Q.store_thm("Aligned_numeric", - `Aligned (0w: word32, 4) /\ - Aligned (0w: word32, 2) /\ - (!x. Aligned (n2w (NUMERAL (BIT2 (BIT1 x))): word32, 4)) /\ - (!x. Aligned (n2w (NUMERAL (BIT2 x)): word32, 2)) /\ - (!x y f. Aligned (y + n2w (NUMERAL (BIT1 (BIT1 (f x)))): word32, 4) = - Aligned (y + 3w, 4)) /\ - (!x y. Aligned (y + n2w (NUMERAL (BIT1 (BIT2 x))): word32, 4) = - Aligned (y + 1w, 4)) /\ - (!x y. Aligned (y + n2w (NUMERAL (BIT2 (BIT1 x))): word32, 4) = - Aligned (y, 4)) /\ - (!x y. Aligned (y + n2w (NUMERAL (BIT2 (BIT2 x))): word32, 4) = - Aligned (y + 2w, 4)) /\ - (!x y f. Aligned (y - n2w (NUMERAL (BIT1 (BIT1 (f x)))): word32, 4) = - Aligned (y - 3w, 4)) /\ - (!x y. Aligned (y - n2w (NUMERAL (BIT1 (BIT2 x))): word32, 4) = - Aligned (y - 1w, 4)) /\ - (!x y. Aligned (y - n2w (NUMERAL (BIT2 (BIT1 x))): word32, 4) = - Aligned (y, 4)) /\ - (!x y. Aligned (y - n2w (NUMERAL (BIT2 (BIT2 x))): word32, 4) = - Aligned (y - 2w, 4)) /\ - (!x y f. Aligned (y + n2w (NUMERAL (BIT1 (f x))): word32, 2) = - Aligned (y + 1w, 2)) /\ - (!x y f. Aligned (y - n2w (NUMERAL (BIT1 (f x))): word32, 2) = - Aligned (y - 1w, 2)) /\ - (!x y. Aligned (y + n2w (NUMERAL (BIT2 x)): word32, 2) = Aligned (y, 2)) /\ - (!x y. Aligned (y - n2w (NUMERAL (BIT2 x)): word32, 2) = Aligned (y, 2))`, - REPEAT strip_tac - \\ (CONV_TAC (LHS_CONV (RAND_CONV (LAND_CONV (ONCE_REWRITE_CONV [BIT_lem])))) - ORELSE CONV_TAC (RAND_CONV (LAND_CONV (ONCE_REWRITE_CONV [BIT_lem])))) - \\ rewrite_tac [Aligned_eq, GSYM wordsTheory.word_mul_n2w, - GSYM wordsTheory.word_add_n2w] - \\ rewrite_tac [Aligned] - \\ TRY (markerLib.PAT_ABBREV_TAC (HOLset.empty Term.compare) - ``q = n2w x + 1w : word32``) - \\ TRY (Q.ABBREV_TAC `r = n2w (f x) : word32`) - \\ blastLib.BBLAST_TAC +val Align4_base_pc_minus = utilsLib.ustore_thm("Align4_base_pc_minus", + `aligned (if t then 1 else 2) (pc: word32) ==> + (align 2 (pc + if t then 4w else 8w) - x = + if t then align 2 pc - (x - 4w) else pc - (x - 8w))`, + lrw [alignmentTheory.aligned_extract, alignmentTheory.align_def] + \\ blastLib.FULL_BBLAST_TAC ) (* ------------------------------------------------------------------------ *) val Align_branch_immediate = Q.store_thm("Align_branch_immediate", `a + - Align + align 2 (sw2sw ((v2w [x0; x1; x2; x3; x4; x5; x6; x7; x8; x9; x10; x11; x12; x13; x14; x15; x16; x17; x18; x19; x20; x21; - x22; x23]: word24 @@ (0w: word2)): 26 word): word32,4) = + x22; x23]: word24 @@ (0w: word2)): 26 word): word32) = if x0 then a - (v2w [~x1; ~x2; ~x3; ~x4; ~x5; ~x6; ~x7; ~x8; ~x9; ~x10; ~x11; ~x12; @@ -784,35 +704,18 @@ val Align_branch_immediate = Q.store_thm("Align_branch_immediate", a + v2w [x1; x2; x3; x4; x5; x6; x7; x8; x9; x10; x11; x12; x13; x14; x15; x16; x17; x18; x19; x20; x21; x22; x23; F; F]`, - lrw [Align] + lrw [alignmentTheory.align_def] \\ blastLib.FULL_BBLAST_TAC ) -(* -val Align_branch_immediate = Q.store_thm("Align_branch_immediate", - `Align - (sw2sw ((v2w [x0; x1; x2; x3; x4; x5; x6; x7; x8; x9; x10; x11; - x12; x13; x14; x15; x16; x17; x18; x19; x20; x21; - x22; x23]: word24 @@ (0w: word2)): 26 word): word32,4) = - if x0 then - v2w [T; T; T; T; T; T; T; x1; x2; x3; x4; x5; x6; x7; x8; x9; x10; x11; - x12; x13; x14; x15; x16; x17; x18; x19; x20; x21; x22; x23; F; F] - else - v2w [F; x1; x2; x3; x4; x5; x6; x7; x8; x9; x10; x11; - x12; x13; x14; x15; x16; x17; x18; x19; x20; x21; x22; x23; F; F]`, - lrw [Align] - \\ blastLib.FULL_BBLAST_TAC - ) -*) - val Align_branch_exchange_immediate = Q.store_thm("Align_branch_exchange_immediate", `a + - Align + align 1 (sw2sw ((v2w [x0; x1; x2; x3; x4; x5; x6; x7; x8; x9; x10; x11; x12; x13; x14; x15; x16; x17; x18; x19; x20; x21; x22; x23]: word24 @@ - (v2w [x24; F]: word2)): 26 word): word32,2) = + (v2w [x24; F]: word2)): 26 word): word32) = if x0 then a - (v2w [~x1; ~x2; ~x3; ~x4; ~x5; ~x6; ~x7; ~x8; ~x9; ~x10; ~x11; ~x12; @@ -822,42 +725,21 @@ val Align_branch_exchange_immediate = a + v2w [x1; x2; x3; x4; x5; x6; x7; x8; x9; x10; x11; x12; x13; x14; x15; x16; x17; x18; x19; x20; x21; x22; x23; x24; F]`, - lrw [Align] - \\ blastLib.FULL_BBLAST_TAC - ) - -(* -val Align_branch_exchange_immediate = - Q.store_thm("Align_branch_exchange_immediate", - `Align - (sw2sw - ((v2w [x0; x1; x2; x3; x4; x5; x6; x7; x8; x9; x10; x11; - x12; x13; x14; x15; x16; x17; x18; x19; x20; x21; - x22; x23]: word24 @@ - (v2w [x24; F]: word2)): 26 word): word32,2) = - if x0 then - v2w [T; T; T; T; T; T; T; x1; x2; x3; x4; x5; x6; x7; x8; x9; x10; x11; - x12; x13; x14; x15; x16; x17; x18; x19; x20; x21; x22; x23; x24; F] - else - v2w [F; x1; x2; x3; x4; x5; x6; x7; x8; x9; x10; x11; - x12; x13; x14; x15; x16; x17; x18; x19; x20; x21; - x22; x23; x24; F]`, - lrw [Align] + lrw [alignmentTheory.align_def] \\ blastLib.FULL_BBLAST_TAC ) -*) local val t2 = ``(((31 >< 1) (i: word32) : 31 word) @@ (0w: word1)): word32`` val lem = Q.prove( - `(!i:word32. ^t2 = Align (i, 2)) /\ - (!i:word32. ((31 >< 2) i : 30 word) @@ (0w: word2) = Align (i, 4))`, - simp [Align] + `(!i:word32. ^t2 = align 1 i) /\ + (!i:word32. ((31 >< 2) i : 30 word) @@ (0w: word2) = align 2 i)`, + simp [alignmentTheory.align_def] \\ blastLib.BBLAST_TAC ) val lem2 = Q.prove( - `(!i: word32. (if word_bit 0 i then ^t2 else i) = Align (i, 2))`, - lrw [lem, Align] + `(!i: word32. (if word_bit 0 i then ^t2 else i) = align 1 i)`, + lrw [lem, alignmentTheory.align_def] \\ blastLib.FULL_BBLAST_TAC ) in diff --git a/examples/l3-machine-code/arm8/decompiler/arm8_decompLib.sml b/examples/l3-machine-code/arm8/decompiler/arm8_decompLib.sml index b5889f6f46..e95512cd5e 100644 --- a/examples/l3-machine-code/arm8/decompiler/arm8_decompLib.sml +++ b/examples/l3-machine-code/arm8/decompiler/arm8_decompLib.sml @@ -86,6 +86,7 @@ val (test_cert, test_def) = arm8_decompile_code_no_status "test" add x2, x3, x4 str x2, [x1, #8]! ` + val (ex_cert, ex_def) = arm8_decompLib.arm8_decompile_code "ex" `loop: mul x1, x1, x2 subs x0, x0, #1 diff --git a/examples/l3-machine-code/arm8/prog/arm8_progLib.sml b/examples/l3-machine-code/arm8/prog/arm8_progLib.sml index 8bb09735fc..a1e88e5dd5 100644 --- a/examples/l3-machine-code/arm8/prog/arm8_progLib.sml +++ b/examples/l3-machine-code/arm8/prog/arm8_progLib.sml @@ -300,8 +300,8 @@ local Conv.CONV_RULE (stateLib.PRE_COND_CONV (SIMP_CONV (bool_ss++boolSimps.CONJ_ss) - [arm8_stepTheory.Aligned_numeric, - arm8_stepTheory.Aligned_8_4])) o + [alignmentTheory.aligned_numeric, + alignmentTheory.aligned_imp, DECIDE ``2 < 3n``])) o PURE_REWRITE_RULE [arm8_stepTheory.concat_bytes] val chunk64 = chunks_intro_pre_process arm8_progTheory.arm8_DWORD_def in @@ -353,7 +353,7 @@ local Lib.tryfind (fn thm => MATCH_MP thm th) [arm8_PC_INTRO, arm8_TEMPORAL_PC_INTRO, arm8_PC_INTRO0, arm8_TEMPORAL_PC_INTRO0] - val cnv = REWRITE_CONV [arm8_stepTheory.Aligned_numeric] + val cnv = REWRITE_CONV [alignmentTheory.aligned_numeric] val arm_PC_bump_intro = SPEC_IMP_RULE o Conv.CONV_RULE (Conv.LAND_CONV cnv) o @@ -450,8 +450,8 @@ local THENC stateLib.PRE_COND_CONV (Conv.DEPTH_CONV DISJOINT_CONV THENC REWRITE_CONV - [arm8_stepTheory.Aligned_numeric, - CONJUNCT1 arm8_stepTheory.Aligned, + [alignmentTheory.aligned_numeric, + alignmentTheory.aligned_0, optionTheory.NOT_NONE_SOME] THENC NOT_F_CONV) THENC helperLib.POST_CONV (stateLib.PC_CONV "arm8_prog$arm8_pc") diff --git a/examples/l3-machine-code/arm8/prog/arm8_progScript.sml b/examples/l3-machine-code/arm8/prog/arm8_progScript.sml index b8aefde18e..9cb4c6b7c2 100644 --- a/examples/l3-machine-code/arm8/prog/arm8_progScript.sml +++ b/examples/l3-machine-code/arm8/prog/arm8_progScript.sml @@ -60,7 +60,7 @@ val arm8_WORD_def = Define` val arm8_WORD_MEMORY_def = Define` arm8_WORD_MEMORY dmem mem = - {BIGUNION { BIGUNION (arm8_WORD a (mem a)) | a IN dmem /\ Aligned (a, 4)}}` + {BIGUNION { BIGUNION (arm8_WORD a (mem a)) | a IN dmem /\ aligned 2 a}}` val arm8_DWORD_def = Define` arm8_DWORD a (i: word64) = @@ -75,13 +75,13 @@ val arm8_DWORD_def = Define` val arm8_DWORD_MEMORY_def = Define` arm8_DWORD_MEMORY dmem mem = - {BIGUNION { BIGUNION (arm8_DWORD a (mem a)) | a IN dmem /\ Aligned (a, 8)}}` + {BIGUNION { BIGUNION (arm8_DWORD a (mem a)) | a IN dmem /\ aligned 3 a}}` val arm8_pc_def = Define` arm8_pc pc = arm8_PC pc * arm8_exception NoException * arm8_PSTATE_EL 0w * arm8_SCTLR_EL1_E0E F * arm8_TCR_EL1_TBI0 F * arm8_TCR_EL1_TBI1 F * - arm8_SCTLR_EL1_SA0 F * set_sep$cond (Aligned (pc,4))`; + arm8_SCTLR_EL1_SA0 F * set_sep$cond (aligned 2 pc)`; val aS_def = Define ` aS (n,z,c,v) = @@ -115,7 +115,7 @@ val arm8_PC_INTRO = Q.store_thm("arm8_PC_INTRO", (p2 * arm8_PC pc' * arm8_exception NoException * arm8_PSTATE_EL 0w * arm8_SCTLR_EL1_E0E F * arm8_TCR_EL1_TBI0 F * arm8_TCR_EL1_TBI1 F * arm8_SCTLR_EL1_SA0 F) ==> - (Aligned (pc,4) ==> Aligned (pc',4)) ==> + (aligned 2 pc ==> aligned 2 pc') ==> SPEC m (p1 * arm8_pc pc) code (p2 * arm8_pc pc')`, REPEAT STRIP_TAC \\ FULL_SIMP_TAC std_ss @@ -127,32 +127,13 @@ val arm8_TEMPORAL_PC_INTRO = Q.store_thm("arm8_TEMPORAL_PC_INTRO", (p2 * arm8_PC pc' * arm8_exception NoException * arm8_PSTATE_EL 0w * arm8_SCTLR_EL1_E0E F * arm8_TCR_EL1_TBI0 F * arm8_TCR_EL1_TBI1 F * arm8_SCTLR_EL1_SA0 F) ==> - (Aligned (pc,4) ==> Aligned (pc',4)) ==> + (aligned 2 pc ==> aligned 2 pc') ==> TEMPORAL_NEXT m (p1 * arm8_pc pc) code (p2 * arm8_pc pc')`, REPEAT STRIP_TAC \\ FULL_SIMP_TAC std_ss [arm8_pc_def, TEMPORAL_NEXT_MOVE_COND, STAR_ASSOC, SEP_CLAUSES] ) -(* -fun mk_addr (b, s) = - List.tabulate - (25, fn i => if i < 2 then b - else Term.mk_var (s ^ Int.toString i, Type.bool)) - |> (fn l => bitstringSyntax.mk_v2w - (listSyntax.mk_list (List.rev l, Type.bool), ``:32``)) - -val x = mk_addr (boolSyntax.T, "x") -val y = mk_addr (boolSyntax.F, "y") - -val Aligned_Branch = Q.store_thm("Aligned_Branch", - `(Aligned (pc:word32, 4) ==> - Aligned ((if b then pc - (^x + 1w) else pc + ^y), 4)) = T`, - rw [Aligned] - \\ blastLib.FULL_BBLAST_TAC - ) -*) - (* ------------------------------------------------------------------------ *) val lem = Q.prove( @@ -167,7 +148,7 @@ val lem = Q.prove( fun thm v n x y = stateTheory.MAPPED_COMPONENT_INSERT |> Q.ISPECL - [`\a:word64. Aligned (a, ^n)`, `^n`, `\a i. arm8_c_MEM (a + n2w i)`, + [`\a:word64. aligned ^n a`, `2n ** ^n`, `\a i. arm8_c_MEM (a + n2w i)`, `\v i. arm8_d_word8 (EL i ^v)`, x, y] |> Conv.CONV_RULE (Conv.LAND_CONV @@ -185,9 +166,9 @@ val lem1 = Q.prove( simp [wordsTheory.word_lo_n2w]) val lem2 = Q.prove( - `Aligned (a: word64, 4) /\ Aligned (b, 4) /\ x <+ 4w /\ y <+ 4w ==> + `aligned 2 (a: word64) /\ aligned 2 b /\ x <+ 4w /\ y <+ 4w ==> ((a + x = b + y) = (a = b) /\ (x = y))`, - simp [arm8_stepTheory.Aligned] + simp [alignmentTheory.aligned_extract] \\ blastLib.BBLAST_TAC ) @@ -198,10 +179,10 @@ val v4 = ``[( 7 >< 0) v; (15 >< 8) v; (* Need ``(\a. ..) c`` below for automation to work *) val arm8_WORD_MEMORY_INSERT = Q.store_thm("arm8_WORD_MEMORY_INSERT", `!f df c d. - c IN df /\ (\a. Aligned (a, 4)) c ==> + c IN df /\ (\a. aligned 2 a) c ==> (arm8_WORD c d * arm8_WORD_MEMORY (df DELETE c) f = arm8_WORD_MEMORY df ((c =+ d) f))`, - match_mp_tac (thm v4 ``4n`` `arm8_WORD` `arm8_WORD_MEMORY`) + match_mp_tac (thm v4 ``2n`` `arm8_WORD` `arm8_WORD_MEMORY`) \\ rw [arm8_WORD_MEMORY_def] \\ `(i = j) = (n2w i = n2w j: word64)` by simp [] \\ asm_rewrite_tac [] @@ -214,9 +195,9 @@ val lem1 = Q.prove( simp [wordsTheory.word_lo_n2w]) val lem2 = Q.prove( - `Aligned (a: word64, 8) /\ Aligned (b, 8) /\ x <+ 8w /\ y <+ 8w ==> + `aligned 3 (a: word64) /\ aligned 3 b /\ x <+ 8w /\ y <+ 8w ==> ((a + x = b + y) = (a = b) /\ (x = y))`, - simp [arm8_stepTheory.Aligned] + simp [alignmentTheory.aligned_extract] \\ blastLib.BBLAST_TAC ) @@ -227,10 +208,10 @@ val v8 = ``[( 7 >< 0) v; (15 >< 8) v; val arm8_DWORD_MEMORY_INSERT = Q.store_thm("arm8_DWORD_MEMORY_INSERT", `!f df c d. - c IN df /\ (\a. Aligned (a, 8)) c ==> + c IN df /\ (\a. aligned 3 a) c ==> (arm8_DWORD c d * arm8_DWORD_MEMORY (df DELETE c) f = arm8_DWORD_MEMORY df ((c =+ d) f))`, - match_mp_tac (thm v8 ``8n`` `arm8_DWORD` `arm8_DWORD_MEMORY`) + match_mp_tac (thm v8 ``3n`` `arm8_DWORD` `arm8_DWORD_MEMORY`) \\ rw [arm8_DWORD_MEMORY_def] \\ `(i = j) = (n2w i = n2w j: word64)` by simp [] \\ asm_rewrite_tac [] diff --git a/examples/l3-machine-code/arm8/step/arm8_stepLib.sml b/examples/l3-machine-code/arm8/step/arm8_stepLib.sml index 526b3bb889..e8a1637f71 100644 --- a/examples/l3-machine-code/arm8/step/arm8_stepLib.sml +++ b/examples/l3-machine-code/arm8/step/arm8_stepLib.sml @@ -344,7 +344,9 @@ val LoadLiteral_rwt = val map_sp_rule = List.map (utilsLib.ALL_HYP_CONV_RULE - (DATATYPE_CONV THENC SIMP_CONV std_ss [Aligned_plus]) o sp_rule) + (DATATYPE_CONV + THENC SIMP_CONV std_ss [alignmentTheory.aligned_numeric]) o + sp_rule) val LoadStorePair_rwt = List.map diff --git a/examples/l3-machine-code/arm8/step/arm8_stepScript.sml b/examples/l3-machine-code/arm8/step/arm8_stepScript.sml index dcff85b95b..5322539643 100644 --- a/examples/l3-machine-code/arm8/step/arm8_stepScript.sml +++ b/examples/l3-machine-code/arm8/step/arm8_stepScript.sml @@ -6,7 +6,7 @@ open HolKernel boolLib bossLib open lcsymtacs utilsLib open wordsLib blastLib -open state_transformerTheory updateTheory arm8Theory +open state_transformerTheory updateTheory alignmentTheory arm8Theory val _ = new_theory "arm8_step" @@ -363,160 +363,24 @@ val CountLeadingZeroBits32 = Q.store_thm("CountLeadingZeroBits32", (* ------------------------------------------------------------------------ *) -val Align_slice = Q.prove( - `!n a : 'a word. Align (a, 2 ** n) = (dimindex(:'a) - 1 '' n) a`, - strip_tac - \\ Cases - \\ lrw [Align_def, wordsTheory.word_slice_n2w, - bitTheory.SLICE_THM, bitTheory.BITS_THM2, - DECIDE ``0 < n ==> (SUC (n - 1) = n)``] - \\ lfs [wordsTheory.dimword_def] - ) - -val slice_all = Q.prove( - `!a:'a word. (dimindex(:'a) - 1 '' 0) a = a`, - simp [wordsTheory.WORD_SLICE_BITS_THM, wordsTheory.WORD_ALL_BITS]) - -val Align = Theory.save_thm ("Align", - (REWRITE_RULE [slice_all] o numLib.REDUCE_RULE o Drule.LIST_CONJ) - (List.map (fn t => Q.SPEC t Align_slice) [`0`,`1`,`2`,`3`])) - -val Aligned = Q.store_thm ("Aligned", - `(!a : word64. Aligned (a, 1)) /\ - (!a : word64. Aligned (a, 2) = ~word_lsb a) /\ - (!a : word64. Aligned (a, 4) = ((1 >< 0) a = 0w:word2)) /\ - (!a : word64. Aligned (a, 8) = ((2 >< 0) a = 0w:word3))`, - lrw [Aligned_def, Align] \\ blastLib.BBLAST_TAC - ) - -val Aligned_plus = Q.store_thm("Aligned_plus", - `(!w: word64. Aligned (w + 4w, 4) = Aligned (w, 4)) /\ - (!w: word64. Aligned (w + 8w, 8) = Aligned (w, 8))`, - rw [Aligned] \\ blastLib.BBLAST_TAC - ) - -(* -val AlignAlign = Q.store_thm ("AlignAlign", - `(!v : word64. Align (Align (v,2),2) = Align (v,2)) /\ - (!v : word64. Align (Align (v,4),4) = Align (v,4)) /\ - (!v : word64. Align (Align (v,8),8) = Align (v,8))`, - srw_tac [wordsLib.WORD_EXTRACT_ss] [Align] - ) -*) - -(* ------------------------------------------------------------------------ *) - -val BIT_lem = Q.prove( - `(!x. NUMERAL (BIT2 x) = 2 * (x + 1)) /\ - (!x. NUMERAL (BIT1 x) = 2 * x + 1) /\ - (!x. NUMERAL (BIT1 (BIT1 x)) = 4 * x + 3) /\ - (!x. NUMERAL (BIT1 (BIT2 x)) = 4 * (x + 1) + 1) /\ - (!x. NUMERAL (BIT2 (BIT1 x)) = 4 * (x + 1)) /\ - (!x. NUMERAL (BIT2 (BIT2 x)) = 4 * (x + 1) + 2) /\ - (!x. NUMERAL (BIT1 (BIT1 (BIT1 x))) = 8 * x + 7) /\ - (!x. NUMERAL (BIT1 (BIT1 (BIT2 x))) = 8 * (x + 1) + 3) /\ - (!x. NUMERAL (BIT1 (BIT2 (BIT1 x))) = 8 * (x + 1) + 1) /\ - (!x. NUMERAL (BIT1 (BIT2 (BIT2 x))) = 8 * (x + 1) + 5) /\ - (!x. NUMERAL (BIT2 (BIT1 (BIT1 x))) = 8 * (x + 1)) /\ - (!x. NUMERAL (BIT2 (BIT1 (BIT2 x))) = 8 * (x + 1) + 4) /\ - (!x. NUMERAL (BIT2 (BIT2 (BIT1 x))) = 8 * (x + 1) + 2) /\ - (!x. NUMERAL (BIT2 (BIT2 (BIT2 x))) = 8 * (x + 1) + 6)`, - REPEAT strip_tac - \\ CONV_TAC (Conv.LHS_CONV - (REWRITE_CONV [arithmeticTheory.BIT1, arithmeticTheory.BIT2, - arithmeticTheory.NUMERAL_DEF])) - \\ DECIDE_TAC - ) - -val Aligned_eq = Q.prove( - `(!a b. (Aligned (a: word64, 8) = Aligned (b: word64, 8)) = - (~a ' 0 /\ ~a ' 1 /\ ~a ' 2 = ~b ' 0 /\ ~b ' 1 /\ ~b ' 2)) /\ - (!a b. (Aligned (a: word64, 4) = Aligned (b: word64, 4)) = - (~a ' 0 /\ ~a ' 1 = ~b ' 0 /\ ~b ' 1)) /\ - (!a b. (Aligned (a: word64, 2) = Aligned (b: word64, 2)) = - (a ' 0 = b ' 0))`, - lrw [Aligned] - \\ blastLib.BBLAST_TAC - ) - -val Aligned_numeric = Q.store_thm("Aligned_numeric", - `(!x. Aligned (0w: word64, 8)) /\ - (!x. Aligned (0w: word64, 4)) /\ - (!x. Aligned (0w: word64, 2)) /\ - (!x. Aligned (n2w (NUMERAL (BIT2 (BIT1 (BIT1 x)))): word64, 8)) /\ - (!x. Aligned (n2w (NUMERAL (BIT2 (BIT1 x))): word64, 4)) /\ - (!x. Aligned (n2w (NUMERAL (BIT2 x)): word64, 2)) /\ - (!x y f. Aligned (y + n2w (NUMERAL (BIT1 (BIT1 (BIT1 (f x))))): word64, 8) = - Aligned (y + 7w, 8)) /\ - (!x y f. Aligned (y + n2w (NUMERAL (BIT1 (BIT1 (BIT2 x)))): word64, 8) = - Aligned (y + 3w, 8)) /\ - (!x y f. Aligned (y + n2w (NUMERAL (BIT1 (BIT2 (BIT1 x)))): word64, 8) = - Aligned (y + 1w, 8)) /\ - (!x y f. Aligned (y + n2w (NUMERAL (BIT1 (BIT2 (BIT2 x)))): word64, 8) = - Aligned (y + 5w, 8)) /\ - (!x y f. Aligned (y + n2w (NUMERAL (BIT2 (BIT1 (BIT1 x)))): word64, 8) = - Aligned (y, 8)) /\ - (!x y f. Aligned (y + n2w (NUMERAL (BIT2 (BIT1 (BIT2 x)))): word64, 8) = - Aligned (y + 4w, 8)) /\ - (!x y f. Aligned (y + n2w (NUMERAL (BIT2 (BIT2 (BIT1 x)))): word64, 8) = - Aligned (y + 2w, 8)) /\ - (!x y f. Aligned (y + n2w (NUMERAL (BIT2 (BIT2 (BIT2 x)))): word64, 8) = - Aligned (y + 6w, 8)) /\ - (!x y f. Aligned (y - n2w (NUMERAL (BIT1 (BIT1 (BIT1 (f x))))): word64, 8) = - Aligned (y - 7w, 8)) /\ - (!x y f. Aligned (y - n2w (NUMERAL (BIT1 (BIT1 (BIT2 x)))): word64, 8) = - Aligned (y - 3w, 8)) /\ - (!x y f. Aligned (y - n2w (NUMERAL (BIT1 (BIT2 (BIT1 x)))): word64, 8) = - Aligned (y - 1w, 8)) /\ - (!x y f. Aligned (y - n2w (NUMERAL (BIT1 (BIT2 (BIT2 x)))): word64, 8) = - Aligned (y - 5w, 8)) /\ - (!x y f. Aligned (y - n2w (NUMERAL (BIT2 (BIT1 (BIT1 x)))): word64, 8) = - Aligned (y, 8)) /\ - (!x y f. Aligned (y - n2w (NUMERAL (BIT2 (BIT1 (BIT2 x)))): word64, 8) = - Aligned (y - 4w, 8)) /\ - (!x y f. Aligned (y - n2w (NUMERAL (BIT2 (BIT2 (BIT1 x)))): word64, 8) = - Aligned (y - 2w, 8)) /\ - (!x y f. Aligned (y - n2w (NUMERAL (BIT2 (BIT2 (BIT2 x)))): word64, 8) = - Aligned (y - 6w, 8)) /\ - (!x y f. Aligned (y + n2w (NUMERAL (BIT1 (BIT1 (f x)))): word64, 4) = - Aligned (y + 3w, 4)) /\ - (!x y. Aligned (y + n2w (NUMERAL (BIT1 (BIT2 x))): word64, 4) = - Aligned (y + 1w, 4)) /\ - (!x y. Aligned (y + n2w (NUMERAL (BIT2 (BIT1 x))): word64, 4) = - Aligned (y, 4)) /\ - (!x y. Aligned (y + n2w (NUMERAL (BIT2 (BIT2 x))): word64, 4) = - Aligned (y + 2w, 4)) /\ - (!x y f. Aligned (y - n2w (NUMERAL (BIT1 (BIT1 (f x)))): word64, 4) = - Aligned (y - 3w, 4)) /\ - (!x y. Aligned (y - n2w (NUMERAL (BIT1 (BIT2 x))): word64, 4) = - Aligned (y - 1w, 4)) /\ - (!x y. Aligned (y - n2w (NUMERAL (BIT2 (BIT1 x))): word64, 4) = - Aligned (y, 4)) /\ - (!x y. Aligned (y - n2w (NUMERAL (BIT2 (BIT2 x))): word64, 4) = - Aligned (y - 2w, 4)) /\ - (!x y f. Aligned (y + n2w (NUMERAL (BIT1 (f x))): word64, 2) = - Aligned (y + 1w, 2)) /\ - (!x y f. Aligned (y - n2w (NUMERAL (BIT1 (f x))): word64, 2) = - Aligned (y - 1w, 2)) /\ - (!x y. Aligned (y + n2w (NUMERAL (BIT2 x)): word64, 2) = Aligned (y, 2)) /\ - (!x y. Aligned (y - n2w (NUMERAL (BIT2 x)): word64, 2) = Aligned (y, 2))`, - REPEAT strip_tac - \\ (CONV_TAC (LHS_CONV (RAND_CONV (LAND_CONV (ONCE_REWRITE_CONV [BIT_lem])))) - ORELSE CONV_TAC (RAND_CONV (LAND_CONV (ONCE_REWRITE_CONV [BIT_lem])))) - \\ rewrite_tac [Aligned_eq, GSYM wordsTheory.word_mul_n2w, - GSYM wordsTheory.word_add_n2w] - \\ rewrite_tac [Aligned] - \\ TRY (markerLib.PAT_ABBREV_TAC (HOLset.empty Term.compare) - ``q = n2w x + 1w : word64``) - \\ TRY (Q.ABBREV_TAC `r = n2w (f x) : word64`) - \\ blastLib.BBLAST_TAC - ) - -val Aligned_8_4 = Q.store_thm("Aligned_8_4", - `!w: word64. Aligned (w, 8) ==> Aligned (w, 4)`, - simp [Aligned] - \\ blastLib.BBLAST_TAC - ) +val Align = Q.store_thm("Align", + `(!w. Align (w, 1) = align 0 w) /\ + (!w. Align (w, 2) = align 1 w) /\ + (!w. Align (w, 4) = align 2 w) /\ + (!w. Align (w, 8) = align 3 w) /\ + (!w. Align (w, 16) = align 4 w)`, + simp [arm8Theory.Align_def, alignmentTheory.align_w2n] + ) + +val Aligned = Q.store_thm("Aligned", + `(!w. Aligned (w, 1) = aligned 0 w) /\ + (!w. Aligned (w, 2) = aligned 1 w) /\ + (!w. Aligned (w, 4) = aligned 2 w) /\ + (!w. Aligned (w, 8) = aligned 3 w) /\ + (!w. Aligned (w, 16) = aligned 4 w)`, + simp [arm8Theory.Aligned_def, Align, alignmentTheory.aligned_def, + boolTheory.EQ_SYM_EQ] + ) (* ------------------------------------------------------------------------ *) @@ -613,10 +477,13 @@ val BigEndian_rwt = (* read mem *) -fun mem_ev s = - utilsLib.save_as ("mem" ^ s) o +val align_rule = utilsLib.ALL_HYP_CONV_RULE - (SIMP_CONV std_ss [CONJUNCT1 Aligned]) o HYP_DATATYPE_RULE o hd o + (SIMP_CONV std_ss [Aligned, alignmentTheory.aligned_0]) o + HYP_DATATYPE_RULE o hd + +fun mem_ev s = + utilsLib.save_as ("mem" ^ s) o align_rule o EV0 [Mem_def, BigEndian_rwt, CheckAlignment_rwt, wordsTheory.WORD_ADD_0, state_transformerTheory.FOR_def, state_transformerTheory.BIND_DEF, listTheory.APPEND_NIL, bitstringTheory.v2w_w2v, @@ -639,7 +506,7 @@ val mem8 = mem_ev "8" (* write mem *) fun mem_ev s = - utilsLib.save_as ("write'mem" ^ s) o HYP_DATATYPE_RULE o hd o + utilsLib.save_as ("write'mem" ^ s) o align_rule o EV0 [write'Mem_def, BigEndian_rwt, CheckAlignment_rwt, fields, state_transformerTheory.FOR_def, state_transformerTheory.BIND_DEF] [] [] diff --git a/examples/l3-machine-code/m0/decompiler/m0_core_decompLib.sml b/examples/l3-machine-code/m0/decompiler/m0_core_decompLib.sml index 14006d8ae4..9325a00c3a 100644 --- a/examples/l3-machine-code/m0/decompiler/m0_core_decompLib.sml +++ b/examples/l3-machine-code/m0/decompiler/m0_core_decompLib.sml @@ -47,7 +47,7 @@ local THENC utilsLib.WALPHA_CONV val cnv1 = m0_progLib.REG_CONV THENC WGROUND_RW_CONV - THENC REWRITE_CONV [m0_stepTheory.Aligned_numeric] + THENC REWRITE_CONV [alignmentTheory.aligned_numeric] val cnv2 = tripleLib.CODE_CONV (Conv.DEPTH_CONV bitstringLib.v2w_n2w_CONV) THENC tripleLib.POST_CONV (Conv.RAND_CONV PC_CONV) @@ -245,7 +245,7 @@ l1: ldr r2, [r0, #4] ; load data val () = utilsLib.add_datatypes [``:RName``] computeLib.the_compset val () = computeLib.add_funs - [test_def, m0Theory.Aligned_def, m0Theory.Align_def] + [test_def, alignmentTheory.aligned_def, alignmentTheory.align_def] val eval = EVAL THENC ONCE_DEPTH_CONV (updateLib.SORT_ENUM_UPDATES_CONV ``:RName``) diff --git a/examples/l3-machine-code/m0/prog/m0_progLib.sml b/examples/l3-machine-code/m0/prog/m0_progLib.sml index 711f9a4804..d757c12049 100644 --- a/examples/l3-machine-code/m0/prog/m0_progLib.sml +++ b/examples/l3-machine-code/m0/prog/m0_progLib.sml @@ -112,7 +112,7 @@ in end local - val pc_tm = ``m0$Align (pc + 4w: word32, 4)`` + val pc_tm = ``alignment$align 2 (pc + 4w: word32)`` fun is_pc_relative tm = case Lib.total dest_m0_MEM tm of SOME (t, _) => fst (utilsLib.strip_add_or_sub t) = pc_tm @@ -343,7 +343,7 @@ local [m0_PC_INTRO, m0_TEMPORAL_PC_INTRO, m0_PC_INTRO0, m0_TEMPORAL_PC_INTRO0] val cnv = - REWRITE_CONV [m0_stepTheory.Aligned_numeric, + REWRITE_CONV [alignmentTheory.aligned_numeric, m0_stepTheory.Aligned_Branch, m0_stepTheory.Aligned_LoadStore] val m0_PC_bump_intro = @@ -414,7 +414,7 @@ local val PRE_COND_CONV = helperLib.PRE_CONV (DEPTH_COND_CONV - (REWRITE_CONV [m0_stepTheory.Aligned_numeric] + (REWRITE_CONV [alignmentTheory.aligned_numeric] THENC NOT_F_CONV) THENC PURE_ONCE_REWRITE_CONV [stateTheory.cond_true_elim]) val cnv = diff --git a/examples/l3-machine-code/m0/prog/m0_progScript.sml b/examples/l3-machine-code/m0/prog/m0_progScript.sml index bc67e604e1..eee41c9d0e 100644 --- a/examples/l3-machine-code/m0/prog/m0_progScript.sml +++ b/examples/l3-machine-code/m0/prog/m0_progScript.sml @@ -3,9 +3,6 @@ open lcsymtacs blastLib stateLib set_sepTheory progTheory m0_stepTheory val () = new_theory "m0_prog" -infix \\ -val op \\ = op THEN; - (* ------------------------------------------------------------------------ *) val _ = stateLib.sep_definitions "m0" @@ -70,7 +67,7 @@ val m0_CONFIG_def = Define` m0_CONTROL_SPSEL spsel` val m0_PC_def = Define` - m0_PC pc = m0_REG RName_PC pc * cond (Aligned (pc,2))` + m0_PC pc = m0_REG RName_PC pc * cond (aligned 1 pc)` val m0_NZCV_def = Define` m0_NZCV (n,z,c,v) = m0_PSR_N n * m0_PSR_Z z * m0_PSR_C c * m0_PSR_V v` @@ -98,7 +95,7 @@ val m0_PSR_T_F = Q.store_thm("m0_PSR_T_F", val m0_PC_INTRO = Q.store_thm("m0_PC_INTRO", `SPEC m (p1 * m0_PC pc) code (p2 * m0_REG RName_PC pc') ==> - (Aligned (pc,2) ==> Aligned (pc',2)) ==> + (aligned 1 pc ==> aligned 1 pc') ==> SPEC m (p1 * m0_PC pc) code (p2 * m0_PC pc')`, REPEAT STRIP_TAC \\ FULL_SIMP_TAC std_ss [m0_PC_def, SPEC_MOVE_COND, STAR_ASSOC, SEP_CLAUSES] @@ -106,7 +103,7 @@ val m0_PC_INTRO = Q.store_thm("m0_PC_INTRO", val m0_TEMPORAL_PC_INTRO = Q.store_thm("m0_TEMPORAL_PC_INTRO", `TEMPORAL_NEXT m (p1 * m0_PC pc) code (p2 * m0_REG RName_PC pc') ==> - (Aligned (pc,2) ==> Aligned (pc',2)) ==> + (aligned 1 pc ==> aligned 1 pc') ==> TEMPORAL_NEXT m (p1 * m0_PC pc) code (p2 * m0_PC pc')`, REPEAT STRIP_TAC \\ FULL_SIMP_TAC std_ss diff --git a/examples/l3-machine-code/m0/step/m0_stepLib.sml b/examples/l3-machine-code/m0/step/m0_stepLib.sml index 7ebaf5196e..d05406cd96 100644 --- a/examples/l3-machine-code/m0/step/m0_stepLib.sml +++ b/examples/l3-machine-code/m0/step/m0_stepLib.sml @@ -6,6 +6,7 @@ structure m0_stepLib :> m0_stepLib = struct open HolKernel boolLib bossLib + open lcsymtacs m0Theory m0_stepTheory open state_transformerSyntax blastLib @@ -16,9 +17,6 @@ struct end open Parse -infix \\ -val op \\ = op THEN - val ERR = Feedback.mk_HOL_ERR "m0_stepLib" val WARN = Feedback.HOL_WARNING "m0_stepLib" @@ -66,7 +64,8 @@ end (* ARM datatype theorems/conversions *) fun datatype_thms thms = - thms @ [cond_rand_thms, snd_exception_thms, FST_SWAP] @ + thms @ [cond_rand_thms, snd_exception_thms, FST_SWAP, + m0_stepTheory.Align, m0_stepTheory.Aligned] @ utilsLib.datatype_rewrites true "m0" ["m0_state", "RName", "SRType", "PSR"] val DATATYPE_CONV = REWRITE_CONV (datatype_thms []) @@ -224,26 +223,22 @@ val BigEndianReverse_rwt = local val rwts = - [MemA_def, cond_rand_thms, snd_exception_thms, + [MemA_def, cond_rand_thms, snd_exception_thms, alignmentTheory.aligned_0, wordsTheory.WORD_ADD_0, bitstringTheory.v2w_w2v] @ mem_rwt @ BigEndianReverse_rwt in val MemA_1_rwt = - EV (rwts @ [Thm.CONJUNCT1 Aligned, bitstringTheory.field_fixwidth, - fixwidth_for ``:8``]) - [] [] + EV (rwts @ [bitstringTheory.field_fixwidth, fixwidth_for ``:8``]) [] [] ``MemA (v, 1) : m0_state -> word8 # m0_state`` |> hd val MemA_2_rwt = - EV (extract16 :: rwts) - [[``Aligned (v:word32,2)``]] [] + EV (extract16 :: rwts) [[``aligned 1 (v:word32)``]] [] ``MemA (v, 2) : m0_state -> word16 # m0_state`` |> hd val MemA_4_rwt = - EV (extract32 :: rwts) - [[``Aligned (v:word32,4)``]] [] + EV (extract32 :: rwts) [[``aligned 2 (v:word32)``]] [] ``MemA (v, 4) : m0_state -> word32 # m0_state`` |> hd @@ -275,8 +270,9 @@ local val field_cond_rand = Drule.ISPEC ``field h l`` boolTheory.COND_RAND val rwts = [write'MemA_def, cond_rand_thms, snd_exception_thms, - wordsTheory.WORD_ADD_0, bitstringTheory.v2w_w2v, Thm.CONJUNCT1 Aligned, - field_cond_rand] @ write'mem_rwt @ BigEndianReverse_rwt + wordsTheory.WORD_ADD_0, bitstringTheory.v2w_w2v, + alignmentTheory.aligned_0, field_cond_rand] @ + write'mem_rwt @ BigEndianReverse_rwt in val write'MemA_1_rwt = EV (rwts @ [fixwidth_for ``:8``, bitstringTheory.field_fixwidth]) [] [] @@ -284,12 +280,12 @@ in |> hd val write'MemA_2_rwt = - EV (field16 :: rwts) [[``Aligned (v:word32,2)``]] [] + EV (field16 :: rwts) [[``aligned 1 (v:word32)``]] [] ``write'MemA (w:word16, v, 2)`` |> hd val write'MemA_4_rwt = - EV (field32 :: rwts) [[``Aligned (v:word32,4)``]] [] + EV (field32 :: rwts) [[``aligned 2 (v:word32)``]] [] ``write'MemA (w:word32, v, 4)`` |> hd @@ -433,7 +429,8 @@ local |> utilsLib.ALL_HYP_CONV_RULE (utilsLib.WGROUND_CONV THENC REWRITE_CONV - [Aligned_plus, Aligned_concat4, LDM_UPTO_components] + [alignmentTheory.aligned_add_sub_123, Aligned_concat4, + LDM_UPTO_components] THENC numLib.REDUCE_CONV) val lem = Q.prove( @@ -453,8 +450,8 @@ in utilsLib.ALL_HYP_CONV_RULE (DATATYPE_CONV THENC SIMP_CONV std_ss - [Aligned_plus, word_bit_0_of_load, - wordsTheory.word_mul_n2w] + [alignmentTheory.aligned_add_sub_123, + word_bit_0_of_load, wordsTheory.word_mul_n2w] THENC DATATYPE_CONV)) |> addThms val LoadMultiple_rwt = @@ -537,7 +534,8 @@ local |> utilsLib.ALL_HYP_CONV_RULE (numLib.REDUCE_CONV THENC REWRITE_CONV - [Aligned_plus, Aligned_concat4, STM_UPTO_components] + [alignmentTheory.aligned_add_sub_123, Aligned_concat4, + STM_UPTO_components] THENC wordsLib.WORD_EVAL_CONV) val STM = rule STM_thm @@ -555,7 +553,8 @@ in ``dfn'Push (registers)`` |> List.map (utilsLib.ALL_HYP_CONV_RULE - (REWRITE_CONV [Aligned_plus] THENC wordsLib.WORD_EVAL_CONV) o + (REWRITE_CONV [alignmentTheory.aligned_add_sub_123] + THENC wordsLib.WORD_EVAL_CONV) o SIMP_RULE bool_ss [wordsTheory.WORD_MULT_CLAUSES, wordsTheory.word_mul_n2w, bit_count_9_m_8] o @@ -967,7 +966,9 @@ local bitstringTheory.word_extract_v2w, bitstringTheory.word_bits_v2w] val ALIGNED_PLUS_RULE = - MATCH_HYP_RW [Aligned_plus] ``Aligned (a + b : 'a word, c)`` + MATCH_HYP_RW [alignmentTheory.aligned_add_sub_123, + alignmentTheory.aligned_numeric] + ``aligned c (a + b : 'a word)`` val thumb2_test_tm = fix_datatype @@ -1552,7 +1553,9 @@ val NoOperation_rwt = local val f = rand o rand o rand o rator o utilsLib.lhsc -in + val cnv = REWRITE_CONV [alignmentTheory.aligned_add_sub_123, + alignmentTheory.aligned_numeric] + in val BranchTarget_rwt = EV [dfn'BranchTarget_def, PC_rwt, BranchWritePC_rwt, Aligned_Branch9, Aligned_Branch12, Aligned_Branch_Wide6, @@ -1562,7 +1565,7 @@ in [`imm32` |-> f Aligned_Branch_Wide6], [`imm32` |-> f Aligned_Branch_Wide10]] ``dfn'BranchTarget imm32`` - |> List.map (utilsLib.ALL_HYP_CONV_RULE (REWRITE_CONV [Aligned_plus])) + |> List.map (utilsLib.ALL_HYP_CONV_RULE cnv) |> addThms val BranchLinkImmediate_rwt = EV [dfn'BranchLinkImmediate_def, BranchWritePC_rwt, R_name_rwt, @@ -1574,7 +1577,7 @@ in (EVAL_DATATYPE_CONV THENC REWRITE_CONV [R_x_pc] THENC utilsLib.WGROUND_CONV - THENC REWRITE_CONV [Aligned_plus]) o + THENC cnv) o utilsLib.MATCH_HYP_CONV_RULE wordsLib.WORD_EVAL_CONV ``~(n2w a = b: word4)``) |> addThms @@ -1812,7 +1815,7 @@ fun memEV ctxt tm = PC_rwt, IncPC_rwt, write'R_name_rwt, R_name_rwt, m0_stepTheory.R_x_not_pc, m0Theory.offset_case_def, pairTheory.pair_case_thm, Shift_C_DecodeImmShift_rwt, Shift_C_LSL_rwt, - Aligned_plus, Shift_def, Extend_rwt, Extract_rwt] + alignmentTheory.aligned_add_sub_123, Shift_def, Extend_rwt, Extract_rwt] [[``t <> 13w:word4``]] ctxt tm |> List.map (utilsLib.ALL_HYP_CONV_RULE (REWRITE_CONV [] diff --git a/examples/l3-machine-code/m0/step/m0_stepScript.sml b/examples/l3-machine-code/m0/step/m0_stepScript.sml index 456d2ca084..cf3df37936 100644 --- a/examples/l3-machine-code/m0/step/m0_stepScript.sml +++ b/examples/l3-machine-code/m0/step/m0_stepScript.sml @@ -6,7 +6,7 @@ open HolKernel boolLib bossLib open lcsymtacs utilsLib open wordsLib blastLib updateTheory -open state_transformerTheory m0Theory +open state_transformerTheory alignmentTheory m0Theory val _ = new_theory "m0_step" @@ -15,9 +15,6 @@ val _ = new_theory "m0_step" val _ = List.app (fn f => f ()) [numLib.prefer_num, wordsLib.prefer_word, wordsLib.guess_lengths] -infix \\ -val op \\ = op THEN; - (* ------------------------------------------------------------------------ *) val NextStateM0_def = Define` @@ -361,56 +358,36 @@ val bit_count_lt_1 = Q.store_thm("bit_count_lt_1", (* ------------------------------------------------------------------------ *) -val Align_slice = Q.prove( - `!n a : 'a word. Align (a, 2 ** n) = (dimindex(:'a) - 1 '' n) a`, - strip_tac - \\ Cases - \\ lrw [Align_def, wordsTheory.word_slice_n2w, - bitTheory.SLICE_THM, bitTheory.BITS_THM2, - DECIDE ``0 < n ==> (SUC (n - 1) = n)``] - \\ lfs [wordsTheory.dimword_def] - ) - -val slice_all = Q.prove( - `!a:'a word. (dimindex(:'a) - 1 '' 0) a = a`, - simp [wordsTheory.WORD_SLICE_BITS_THM, wordsTheory.WORD_ALL_BITS]) - -val Align = Theory.save_thm ("Align", - (REWRITE_RULE [slice_all] o numLib.REDUCE_RULE o Drule.LIST_CONJ) - (List.map (fn t => Q.SPEC t Align_slice) [`0`,`1`,`2`,`3`])) - -val Aligned = Q.store_thm ("Aligned", - `(!a : word32. Aligned (a, 1)) /\ - (!a : word32. Aligned (a, 2) = ~word_lsb a) /\ - (!a : word32. Aligned (a, 4) = ((1 >< 0) a = 0w:word2)) /\ - (!a : word8. Aligned (a, 4) = ((1 >< 0) a = 0w:word2))`, - lrw [Aligned_def, Align] \\ blastLib.BBLAST_TAC - ) +val Align = Q.store_thm("Align", + `(!w. Align (w, 1) = align 0 w) /\ + (!w. Align (w, 2) = align 1 w) /\ + (!w. Align (w, 4) = align 2 w)`, + simp [m0Theory.Align_def, alignmentTheory.align_w2n] + ) -val Aligned_plus = Q.store_thm("Aligned_plus", - `(!w: word32. Aligned (w + 2w, 2) = Aligned (w, 2)) /\ - (!w: word32. Aligned (w + 4w, 2) = Aligned (w, 2)) /\ - (!w: word32. Aligned (w + 4w, 4) = Aligned (w, 4)) /\ - (!w x: word32. Aligned (w - 4w * x, 4) = Aligned (w, 4)) /\ - (!w x: word32. Aligned (w + 4w * x, 4) = Aligned (w, 4))`, - rw [Aligned] \\ blastLib.BBLAST_TAC - ) +val Aligned = Q.store_thm("Aligned", + `(!w. Aligned (w, 1) = aligned 0 w) /\ + (!w. Aligned (w, 2) = aligned 1 w) /\ + (!w. Aligned (w, 4) = aligned 2 w)`, + simp [m0Theory.Aligned_def, Align, alignmentTheory.aligned_def, + boolTheory.EQ_SYM_EQ] + ) val Aligned_concat4 = Q.store_thm("Aligned_concat4", `!p a: word8 b: word8 c: word8 d: word8. - Aligned (if p then a @@ b @@ c @@ d else d @@ c @@ b @@ a, 4) = - Aligned (if p then d else a, 4)`, - lrw [Aligned] \\ blastLib.BBLAST_TAC + aligned 2 (if p then a @@ b @@ c @@ d else d @@ c @@ b @@ a) = + aligned 2 (if p then d else a)`, + lrw [alignmentTheory.aligned_extract] \\ blastLib.BBLAST_TAC ) val Aligned_SP = utilsLib.ustore_thm("Aligned_SP", - `Aligned (sp:word32, 4) ==> (sp + 4w * a && 0xFFFFFFFCw = sp + 4w * a)`, - simp [Aligned] + `aligned 2 (sp:word32) ==> (sp + 4w * a && 0xFFFFFFFCw = sp + 4w * a)`, + simp [alignmentTheory.aligned_extract] \\ blastLib.BBLAST_TAC ) val Aligned_Branch9 = utilsLib.ustore_thm("Aligned_Branch9", - `Aligned (w:word32, 2) ==> + `aligned 1 (w:word32) ==> (((31 >< 1) (w + sw2sw (v2w [x0; x1; x2; x3; x4; x5; x6; x7; F]: word9))) @@ -418,12 +395,12 @@ val Aligned_Branch9 = utilsLib.ustore_thm("Aligned_Branch9", w + v2w [x0; x0; x0; x0; x0; x0; x0; x0; x0; x0; x0; x0; x0; x0; x0; x0; x0; x0; x0; x0; x0; x0; x0; x0; x1; x2; x3; x4; x5; x6; x7; F])`, - simp [Aligned] + simp [alignmentTheory.aligned_extract] \\ blastLib.BBLAST_TAC ) val Aligned_Branch12 = utilsLib.ustore_thm("Aligned_Branch12", - `Aligned (w:word32, 2) ==> + `aligned 1 (w:word32) ==> (((31 >< 1) (w + sw2sw (v2w [x0; x1; x2; x3; x4; x5; x6; x7; x8; x9; x10; F]: word12))) @@ -431,12 +408,12 @@ val Aligned_Branch12 = utilsLib.ustore_thm("Aligned_Branch12", w + v2w [x0; x0; x0; x0; x0; x0; x0; x0; x0; x0; x0; x0; x0; x0; x0; x0; x0; x0; x0; x0; x0; x1; x2; x3; x4; x5; x6; x7; x8; x9; x10; F])`, - simp [Aligned] + simp [alignmentTheory.aligned_extract] \\ blastLib.BBLAST_TAC ) val Aligned_Branch_Wide6 = utilsLib.ustore_thm("Aligned_Branch_Wide6", - `Aligned (w:word32, 2) ==> + `aligned 1 (w:word32) ==> (((31 >< 1) (w + sw2sw ((v2w [x0]:word1) @@ (v2w [x1]:word1) @@ (v2w [x2]:word1) @@ @@ -448,12 +425,12 @@ val Aligned_Branch_Wide6 = utilsLib.ustore_thm("Aligned_Branch_Wide6", v2w [x0; x0; x0; x0; x0; x0; x0; x0; x0; x0; x0; x0; x1; x2; x3; x4; x5; x6; x7; x8; x9; x10; x11; x12; x13; x14; x15; x16; x17; x18; x19; F])`, - simp [Aligned] + simp [alignmentTheory.aligned_extract] \\ blastLib.BBLAST_TAC ) val Aligned_Branch_Wide10 = utilsLib.ustore_thm("Aligned_Branch_Wide10", - `Aligned (w:word32, 2) ==> + `aligned 1 (w:word32) ==> (((31 >< 1) (w + sw2sw ((v2w [x0]:word1) @@ ~(v2w [x1a] ?? v2w [x1b] : word1) @@ @@ -466,7 +443,7 @@ val Aligned_Branch_Wide10 = utilsLib.ustore_thm("Aligned_Branch_Wide10", v2w [x0; x0; x0; x0; x0; x0; x0; x0; x1a = x1b; x2a = x2b; x3; x4; x5; x6; x7; x8; x9; x10; x11; x12; x13; x14; x15; x16; x17; x18; x19; x20; x21; x22; x23; F])`, - simp [Aligned] + simp [alignmentTheory.aligned_extract] \\ blastLib.BBLAST_TAC ) @@ -479,107 +456,43 @@ val Aligned_BranchEx = utilsLib.ustore_thm("Aligned_BranchEx", *) val Aligned_BranchLink = utilsLib.ustore_thm("Aligned_BranchLink", - `Aligned (w:word32, 2) ==> + `aligned 1 (w:word32) ==> (((31 >< 1) (w + 4w) : 31 word @@ (1w: word1)) = (w + 4w) !! 1w)`, - simp [Aligned] + simp [alignmentTheory.aligned_extract] \\ blastLib.BBLAST_TAC ) val Aligned_BranchLinkEx = utilsLib.ustore_thm("Aligned_BranchLinkEx", - `Aligned (w:word32, 2) ==> + `aligned 1 (w:word32) ==> (((31 >< 1) (w + 4w - 2w) : 31 word @@ (1w: word1)) = (w + 2w) !! 1w)`, - simp [Aligned] + simp [alignmentTheory.aligned_extract] \\ blastLib.BBLAST_TAC ) val tm = Term.subst [``b0:bool`` |-> boolSyntax.F] (bitstringSyntax.mk_vec 32 0) val Aligned_Branch = Q.store_thm("Aligned_Branch", - `(Aligned (pc:word32, 2) ==> Aligned (pc + 4w + ^tm, 2)) = T`, - rw [Aligned] + `(aligned 1 (pc:word32) ==> aligned 1 (pc + 4w + ^tm)) = T`, + rw [alignmentTheory.aligned_extract] \\ blastLib.FULL_BBLAST_TAC ) val Aligned_LoadStore = Q.store_thm("Aligned_LoadStore", - `Aligned (w: 31 word @@ (0w: word1), 2)`, - rw [Aligned] + `aligned 1 (w: 31 word @@ (0w: word1))`, + rw [alignmentTheory.aligned_extract] \\ blastLib.FULL_BBLAST_TAC ) val Aligned4_base_pc = Q.store_thm("Aligned4_base_pc", - `Aligned - (Align (pc, 4) + - w2w (v2w [b7; b6; b5; b4; b3; b2; b1; b0; F; F] : word10): word32, 4)`, - simp [Aligned, Align] + `aligned 2 + (align 2 pc + + w2w (v2w [b7; b6; b5; b4; b3; b2; b1; b0; F; F] : word10): word32)`, + simp [alignmentTheory.aligned_extract, alignmentTheory.align_def] \\ blastLib.FULL_BBLAST_TAC ) (* ------------------------------------------------------------------------ *) -val BIT_lem = Q.prove( - `(!x. NUMERAL (BIT2 x) = 2 * (x + 1)) /\ - (!x. NUMERAL (BIT1 x) = 2 * x + 1) /\ - (!x. NUMERAL (BIT1 (BIT1 x)) = 4 * x + 3) /\ - (!x. NUMERAL (BIT1 (BIT2 x)) = 4 * (x + 1) + 1) /\ - (!x. NUMERAL (BIT2 (BIT1 x)) = 4 * (x + 1)) /\ - (!x. NUMERAL (BIT2 (BIT2 x)) = 4 * (x + 1) + 2)`, - REPEAT strip_tac - \\ CONV_TAC (Conv.LHS_CONV - (REWRITE_CONV [arithmeticTheory.BIT1, arithmeticTheory.BIT2, - arithmeticTheory.NUMERAL_DEF])) - \\ DECIDE_TAC - ) - -val Aligned_eq = Q.prove( - `(!a b. (Aligned (a: word32, 4) = Aligned (b: word32, 4)) = - (~a ' 0 /\ ~a ' 1 = ~b ' 0 /\ ~b ' 1)) /\ - (!a b. (Aligned (a: word32, 2) = Aligned (b: word32, 2)) = - (a ' 0 = b ' 0))`, - lrw [Aligned] - \\ blastLib.BBLAST_TAC - ) - -val Aligned_numeric = Q.store_thm("Aligned_numeric", - `(!x. Aligned (0w: word32, 4)) /\ - (!x. Aligned (0w: word32, 2)) /\ - (!x. Aligned (n2w (NUMERAL (BIT2 (BIT1 x))): word32, 4)) /\ - (!x. Aligned (n2w (NUMERAL (BIT2 x)): word32, 2)) /\ - (!x y f. Aligned (y + n2w (NUMERAL (BIT1 (BIT1 (f x)))): word32, 4) = - Aligned (y + 3w, 4)) /\ - (!x y. Aligned (y + n2w (NUMERAL (BIT1 (BIT2 x))): word32, 4) = - Aligned (y + 1w, 4)) /\ - (!x y. Aligned (y + n2w (NUMERAL (BIT2 (BIT1 x))): word32, 4) = - Aligned (y, 4)) /\ - (!x y. Aligned (y + n2w (NUMERAL (BIT2 (BIT2 x))): word32, 4) = - Aligned (y + 2w, 4)) /\ - (!x y f. Aligned (y - n2w (NUMERAL (BIT1 (BIT1 (f x)))): word32, 4) = - Aligned (y - 3w, 4)) /\ - (!x y. Aligned (y - n2w (NUMERAL (BIT1 (BIT2 x))): word32, 4) = - Aligned (y - 1w, 4)) /\ - (!x y. Aligned (y - n2w (NUMERAL (BIT2 (BIT1 x))): word32, 4) = - Aligned (y, 4)) /\ - (!x y. Aligned (y - n2w (NUMERAL (BIT2 (BIT2 x))): word32, 4) = - Aligned (y - 2w, 4)) /\ - (!x y f. Aligned (y + n2w (NUMERAL (BIT1 (f x))): word32, 2) = - Aligned (y + 1w, 2)) /\ - (!x y f. Aligned (y - n2w (NUMERAL (BIT1 (f x))): word32, 2) = - Aligned (y - 1w, 2)) /\ - (!x y. Aligned (y + n2w (NUMERAL (BIT2 x)): word32, 2) = Aligned (y, 2)) /\ - (!x y. Aligned (y - n2w (NUMERAL (BIT2 x)): word32, 2) = Aligned (y, 2))`, - REPEAT strip_tac - \\ (CONV_TAC (LHS_CONV (RAND_CONV (LAND_CONV (ONCE_REWRITE_CONV [BIT_lem])))) - ORELSE CONV_TAC (RAND_CONV (LAND_CONV (ONCE_REWRITE_CONV [BIT_lem])))) - \\ rewrite_tac [Aligned_eq, GSYM wordsTheory.word_mul_n2w, - GSYM wordsTheory.word_add_n2w] - \\ rewrite_tac [Aligned] - \\ TRY (markerLib.PAT_ABBREV_TAC (HOLset.empty Term.compare) - ``q = n2w x + 1w : word32``) - \\ TRY (Q.ABBREV_TAC `r = n2w (f x) : word32`) - \\ blastLib.BBLAST_TAC - ) - -(* ------------------------------------------------------------------------ *) - val word_bit_0_of_load = Q.store_thm("word_bit_0_of_load", `!x a:word8 b:word8 c:word8 d:word8. word_bit 0 (if x then a @@ b @@ c @@ d else d @@ c @@ b @@ a) = diff --git a/examples/l3-machine-code/mips/step/mips_stepScript.sml b/examples/l3-machine-code/mips/step/mips_stepScript.sml index 2062676331..c780c749f3 100644 --- a/examples/l3-machine-code/mips/step/mips_stepScript.sml +++ b/examples/l3-machine-code/mips/step/mips_stepScript.sml @@ -15,9 +15,6 @@ val _ = new_theory "mips_step" val _ = List.app (fn f => f ()) [numLib.prefer_num, wordsLib.prefer_word, wordsLib.guess_lengths] -infix \\ -val op \\ = op THEN; - (* ------------------------------------------------------------------------ *) val NextStateMIPS_def = Define` diff --git a/examples/l3-machine-code/x64/step/x64_stepScript.sml b/examples/l3-machine-code/x64/step/x64_stepScript.sml index eaedeeec38..9e42cb879e 100644 --- a/examples/l3-machine-code/x64/step/x64_stepScript.sml +++ b/examples/l3-machine-code/x64/step/x64_stepScript.sml @@ -12,12 +12,8 @@ val _ = new_theory "x64_step" (* ------------------------------------------------------------------------ *) -val () = (numLib.prefer_num () - ; wordsLib.prefer_word () - ; wordsLib.guess_lengths ()) - -infix \\ -val op \\ = op THEN; +val () = + (numLib.prefer_num (); wordsLib.prefer_word (); wordsLib.guess_lengths ()) (* ------------------------------------------------------------------------ *) From 840c5991aa07ea883e582cf04a928b1f2a2dee09 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 15 Jul 2015 14:53:25 +0800 Subject: [PATCH 370/718] define_new_type_bijections raises more info about how it was called --- src/1/Drule.sml | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/1/Drule.sml b/src/1/Drule.sml index bfbdd0ee0b..bc5b302e42 100644 --- a/src/1/Drule.sml +++ b/src/1/Drule.sml @@ -2064,7 +2064,10 @@ fun define_new_type_bijections {name, ABS, REP, tyax} = consts = [{const_name = REP, fixity = NONE}, {const_name = ABS, fixity = NONE}]} end - handle e => raise (wrap_exn "Drule" "define_new_type_bijections" e) + handle e => + raise (wrap_exn "Drule" + ("define_new_type_bijections {name=\""^name^"\"...}") + e) (* --------------------------------------------------------------------------* * NAME: prove_rep_fn_one_one * From 7d7c7fed6097ffbdd064b425ec1397b6faf6c84a Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 15 Jul 2015 15:08:40 +0800 Subject: [PATCH 371/718] Prevent bad constant names at Definition level Enforces a constraint I'd long assumed to be true. Closes #268 --- doc/next-release.md | 5 +++++ src/IndDef/selftest.sml | 14 +++++++++++--- src/datatype/ind_types.sml | 6 ++++-- src/postkernel/Theory.sml | 25 +++++++++++++++++++++++-- 4 files changed, 43 insertions(+), 7 deletions(-) diff --git a/doc/next-release.md b/doc/next-release.md index 30149ae338..1b5384f875 100644 --- a/doc/next-release.md +++ b/doc/next-release.md @@ -46,6 +46,11 @@ Bugs fixed: [Third](http://github.com/HOL-Theorem-Prover/HOL/issues/260), `Datatype` (and `Hol_datatype`) allows the definition of identical record types in different theories. +- Attempts to define constants or types with invalid names are now caught much earlier. + An invalid name is one that contains “non-graphical” characters (as *per* SML’s `Char.isGraph`) or parentheses. + This means that Unicode cannot be used in the kernel’s name for a constant, but certainly doesn’t prevent Unicode being used in overloaded notation. + Functions such as `overload_on`, `add_rule` and `set_mapped_fixity` can still be used to create pretty notation with as many Unicode characters included as desired. + New theories: ------------- diff --git a/src/IndDef/selftest.sml b/src/IndDef/selftest.sml index 3345468fe6..87ebf05b6a 100644 --- a/src/IndDef/selftest.sml +++ b/src/IndDef/selftest.sml @@ -1,8 +1,7 @@ open HolKernel Parse boolLib IndDefLib -fun die s = (if !Globals.interactive then - raise Fail s - else print (s^"\n"); OS.Process.exit OS.Process.failure) +open testutils + fun checkhyps th = if null (hyp th) then () else die "FAILED - Hyps in theorem!" @@ -88,4 +87,13 @@ val _ = Hol_reln `(foo p x x) /\ ((if p y then foo p y x else foo p y y) ==> foo p x y)` + +val _ = tprint "With Unicode should fail" +val _ = if (xHol_reln "tr" ` + (!x. ▷ x Z) /\ + (!x y. ▷ (SUC x) (SUC y) ==> ▷ x y) + ` ; false) handle HOL_ERR _ => true then print "OK\n" + else die "FAILED" + + val _ = OS.Process.exit OS.Process.success diff --git a/src/datatype/ind_types.sml b/src/datatype/ind_types.sml index 1355936c20..d98b2d5995 100644 --- a/src/datatype/ind_types.sml +++ b/src/datatype/ind_types.sml @@ -139,8 +139,10 @@ fun new_basic_type_definition tyname (mkname, destname) thm = val x = mk_var("x", dom_ty) val witness_exists = EXISTS(mk_exists(x, mk_comb(pred,x)),witness) thm val tyax = new_type_definition(tyname,witness_exists) - val (mk_dest, dest_mk) = CONJ_PAIR(define_new_type_bijections - {name=(tyname^"_repfns"), ABS=mkname, REP=destname, tyax=tyax}) + val (mk_dest, dest_mk) = + CONJ_PAIR(define_new_type_bijections + {name=temp_binding (tyname^"_repfns"), + ABS=mkname, REP=destname, tyax=tyax}) in (SPEC_ALL mk_dest, SPEC_ALL dest_mk) end; diff --git a/src/postkernel/Theory.sml b/src/postkernel/Theory.sml index 5d92313886..c76af95a42 100644 --- a/src/postkernel/Theory.sml +++ b/src/postkernel/Theory.sml @@ -513,9 +513,13 @@ fun scrubCT() = (scrub(); theCT()); * WRITING AXIOMS, DEFINITIONS, AND THEOREMS INTO THE CURRENT SEGMENT * *---------------------------------------------------------------------------*) -local +val is_temp_binding = let val temp_binding_pfx = "@temp" - val is_temp_binding = String.isPrefix temp_binding_pfx +in + String.isPrefix temp_binding_pfx +end + +local fun check_name tempok (fname,s) = if Lexis.ok_sml_identifier s andalso not (Lib.mem s ["ref", "true", "false", "::", "nil", "="]) orelse @@ -1070,12 +1074,21 @@ val new_definition_hook = ref if null V then th else raise ERR "new_definition" "bare post-processing phase")); +fun okChar c = Char.isGraph c andalso c <> #"(" andalso c <> #")" + +fun check_name princ_name name = + if CharVector.all okChar name then true + else raise ERR + princ_name + ("Entity name >"^name^"< includes non-printable/bad character") + (*---------------------------------------------------------------------------*) (* DEFINITION PRINCIPLES *) (*---------------------------------------------------------------------------*) fun new_type_definition (name,thm) = let val Thy = current_theory() + val _ = is_temp_binding name orelse check_name "new_type_definition" name val tydef = Thm.prim_type_definition({Thy = Thy, Tyop = name}, thm) in store_definition (name^"_TY_DEF", tydef) before @@ -1087,6 +1100,12 @@ fun new_type_definition (name,thm) = let fun new_definition(name,M) = let val (dest,post) = !new_definition_hook val (V,eq) = dest M + val (nm, _) = eq |> dest_eq |> #1 |> dest_atom + handle HOL_ERR _ => + raise ERR "Definition.new_definition" + "Definition not an equality" + val _ = is_temp_binding name orelse + check_name "new_definition" nm val def_th = Thm.prim_constant_definition (current_theory()) eq val {Name,Thy,...} = dest_thy_const (rand (rator (concl def_th))) in @@ -1097,6 +1116,8 @@ fun new_definition(name,M) = fun new_specification (name, cnames, th) = let val thy = current_theory() + val _ = is_temp_binding name orelse + List.all (check_name "new_specification") cnames val def = Thm.prim_specification thy cnames th val final = store_definition (name, def) in From 8f1ae54ee570b7f14f5ef8c73708875967e3e007 Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Wed, 15 Jul 2015 15:54:34 +0100 Subject: [PATCH 372/718] Update SML files generated by L3. The BitsN library has been sped up by removing word size checks. --- examples/l3-machine-code/arm/model/arm.sig | 2 +- examples/l3-machine-code/arm/model/arm.sml | 1427 +++++++++-------- .../arm/model/armAssemblerLib.sml | 6 +- examples/l3-machine-code/arm8/model/arm8.sig | 2 +- examples/l3-machine-code/arm8/model/arm8.sml | 180 ++- examples/l3-machine-code/lib/BitsN.sig | 4 +- examples/l3-machine-code/lib/BitsN.sml | 225 +-- examples/l3-machine-code/lib/Bitstring.sig | 4 +- examples/l3-machine-code/lib/Bitstring.sml | 57 +- examples/l3-machine-code/lib/FP64.sml | 4 +- examples/l3-machine-code/m0/model/m0.sig | 2 +- examples/l3-machine-code/m0/model/m0.sml | 402 ++--- .../m0/model/m0AssemblerLib.sml | 6 +- examples/l3-machine-code/mips/model/mips.sig | 2 +- examples/l3-machine-code/mips/model/mips.sml | 550 +++---- examples/l3-machine-code/x64/model/x64.sig | 2 +- examples/l3-machine-code/x64/model/x64.sml | 152 +- 17 files changed, 1481 insertions(+), 1546 deletions(-) diff --git a/examples/l3-machine-code/arm/model/arm.sig b/examples/l3-machine-code/arm/model/arm.sig index e6360dada0..ecef1f9476 100644 --- a/examples/l3-machine-code/arm/model/arm.sig +++ b/examples/l3-machine-code/arm/model/arm.sig @@ -1,4 +1,4 @@ -(* arm - generated by L<3> - Fri Nov 21 16:33:11 2014 *) +(* arm - generated by L3 - Wed Jul 15 10:38:11 2015 *) signature arm = sig diff --git a/examples/l3-machine-code/arm/model/arm.sml b/examples/l3-machine-code/arm/model/arm.sml index 7e82de863f..46945dbc34 100644 --- a/examples/l3-machine-code/arm/model/arm.sml +++ b/examples/l3-machine-code/arm/model/arm.sml @@ -1,4 +1,4 @@ -(* arm - generated by L3 - Mon Jul 13 13:33:29 2015 *) +(* arm - generated by L3 - Wed Jul 15 10:38:11 2015 *) structure arm :> arm = struct @@ -1758,11 +1758,11 @@ fun HaveVirtExt () = fun rec'PSR x = {A = BitsN.bit(x,8), C = BitsN.bit(x,29), E = BitsN.bit(x,9), - F = BitsN.bit(x,6), GE = BitsN.bits(x,19,16), I = BitsN.bit(x,7), - IT = BitsN.@@(BitsN.bits(x,15,10),BitsN.bits(x,26,25)), - J = BitsN.bit(x,24), M = BitsN.bits(x,4,0), N = BitsN.bit(x,31), + F = BitsN.bit(x,6), GE = BitsN.bits(19,16) x, I = BitsN.bit(x,7), + IT = BitsN.@@(BitsN.bits(15,10) x,BitsN.bits(26,25) x), + J = BitsN.bit(x,24), M = BitsN.bits(4,0) x, N = BitsN.bit(x,31), Q = BitsN.bit(x,27), T = BitsN.bit(x,5), V = BitsN.bit(x,28), - Z = BitsN.bit(x,30), psr'rst = BitsN.bits(x,23,20)}; + Z = BitsN.bit(x,30), psr'rst = BitsN.bits(23,20) x}; fun reg'PSR x = case x of @@ -1846,9 +1846,9 @@ fun rec'SCTLR x = V = BitsN.bit(x,13), VE = BitsN.bit(x,24), Z = BitsN.bit(x,11), sctlr'rst = BitsN.concat - [BitsN.bits(x,6,3),BitsN.bits(x,9,8),BitsN.bits(x,16,15), - BitsN.bits(x,18,18),BitsN.bits(x,20,20),BitsN.bits(x,23,23), - BitsN.bits(x,26,26),BitsN.bits(x,29,28)]}; + [BitsN.bits(6,3) x,BitsN.bits(9,8) x,BitsN.bits(16,15) x, + BitsN.bits(18,18) x,BitsN.bits(20,20) x,BitsN.bits(23,23) x, + BitsN.bits(26,26) x,BitsN.bits(29,28) x]}; fun reg'SCTLR x = case x of @@ -1928,9 +1928,9 @@ fun rec'HSCTLR x = M = BitsN.bit(x,0), TE = BitsN.bit(x,30), WXN = BitsN.bit(x,19), hsctlr'rst = BitsN.concat - [BitsN.bits(x,4,3),BitsN.bits(x,11,6),BitsN.bits(x,18,13), - BitsN.bits(x,20,20),BitsN.bits(x,24,22),BitsN.bits(x,29,26), - BitsN.bits(x,31,31)]}; + [BitsN.bits(4,3) x,BitsN.bits(11,6) x,BitsN.bits(18,13) x, + BitsN.bits(20,20) x,BitsN.bits(24,22) x,BitsN.bits(29,26) x, + BitsN.bits(31,31) x]}; fun reg'HSCTLR x = case x of @@ -2004,8 +2004,8 @@ fun write'rec'HSCTLR (_,x) = reg'HSCTLR x; fun write'reg'HSCTLR (_,x) = rec'HSCTLR x; fun rec'HSR x = - {EC = BitsN.bits(x,31,26), IL = BitsN.bit(x,25), - ISS = BitsN.bits(x,24,0)}; + {EC = BitsN.bits(31,26) x, IL = BitsN.bit(x,25), + ISS = BitsN.bits(24,0) x}; fun reg'HSR x = case x of @@ -2083,7 +2083,7 @@ fun rec'SCR x = {AW = BitsN.bit(x,5), EA = BitsN.bit(x,3), FIQ = BitsN.bit(x,2), FW = BitsN.bit(x,4), HCE = BitsN.bit(x,8), IRQ = BitsN.bit(x,1), NS = BitsN.bit(x,0), SCD = BitsN.bit(x,7), SIF = BitsN.bit(x,9), - nET = BitsN.bit(x,6), scr'rst = BitsN.bits(x,31,10)}; + nET = BitsN.bit(x,6), scr'rst = BitsN.bits(31,10) x}; fun reg'SCR x = case x of @@ -2159,8 +2159,8 @@ fun write'reg'SCR (_,x) = rec'SCR x; fun rec'NSACR x = {NSASEDIS = BitsN.bit(x,15), NSD32DIS = BitsN.bit(x,14), NSTRCDIS = BitsN.bit(x,20), RFR = BitsN.bit(x,19), - cp = BitsN.bits(x,13,0), - nsacr'rst = BitsN.@@(BitsN.bits(x,18,16),BitsN.bits(x,31,21))}; + cp = BitsN.bits(13,0) x, + nsacr'rst = BitsN.@@(BitsN.bits(18,16) x,BitsN.bits(31,21) x)}; fun reg'NSACR x = case x of @@ -2236,15 +2236,15 @@ fun write'rec'NSACR (_,x) = reg'NSACR x; fun write'reg'NSACR (_,x) = rec'NSACR x; fun rec'HCR x = - {AMO = BitsN.bit(x,5), BSU = BitsN.bits(x,11,10), DC = BitsN.bit(x,12), + {AMO = BitsN.bit(x,5), BSU = BitsN.bits(11,10) x, DC = BitsN.bit(x,12), FB = BitsN.bit(x,9), FMO = BitsN.bit(x,3), IMO = BitsN.bit(x,4), PTW = BitsN.bit(x,2), SWIO = BitsN.bit(x,1), TAC = BitsN.bit(x,21), - TGE = BitsN.bit(x,27), TID = BitsN.bits(x,18,15), + TGE = BitsN.bit(x,27), TID = BitsN.bits(18,15) x, TIDCP = BitsN.bit(x,20), TPC = BitsN.bit(x,23), TPU = BitsN.bit(x,24), TSC = BitsN.bit(x,19), TSW = BitsN.bit(x,22), TTLB = BitsN.bit(x,25), TVM = BitsN.bit(x,26), TWE = BitsN.bit(x,14), TWI = BitsN.bit(x,13), VA = BitsN.bit(x,8), VF = BitsN.bit(x,6), VI = BitsN.bit(x,7), - VM = BitsN.bit(x,0), hcr'rst = BitsN.bits(x,31,28)}; + VM = BitsN.bit(x,0), hcr'rst = BitsN.bits(31,28) x}; fun reg'HCR x = case x of @@ -2406,26 +2406,26 @@ fun write'ITSTATE value = CPSR := (PSR_IT_rupd((!CPSR),value)); fun ITAdvance () = if (HaveThumb2 ()) andalso (not((!Encoding) = Encoding_ARM)) - then if (BitsN.bits(ITSTATE (),2,0)) = (BitsN.B(0x0,3)) + then if (BitsN.bits(2,0) (ITSTATE ())) = (BitsN.B(0x0,3)) then write'ITSTATE(BitsN.B(0x0,8)) else let val w = ITSTATE () in write'ITSTATE - (BitsN.bitFieldInsert - (w,BitsN.<<(BitsN.bits(ITSTATE (),4,0),1),4,0)) + (BitsN.bitFieldInsert(4,0) + (w,BitsN.<<(BitsN.bits(4,0) (ITSTATE ()),1))) end else (); -fun InITBlock () = not((BitsN.bits(ITSTATE (),3,0)) = (BitsN.B(0x0,4))); +fun InITBlock () = not((BitsN.bits(3,0) (ITSTATE ())) = (BitsN.B(0x0,4))); -fun LastInITBlock () = (BitsN.bits(ITSTATE (),3,0)) = (BitsN.B(0x8,4)); +fun LastInITBlock () = (BitsN.bits(3,0) (ITSTATE ())) = (BitsN.B(0x8,4)); fun ThumbCondition () = if (ITSTATE ()) = (BitsN.B(0x0,8)) then BitsN.B(0xE,4) - else if not((BitsN.bits((#IT) (!CPSR),3,0)) = (BitsN.B(0x0,4))) - then BitsN.bits((#IT) (!CPSR),7,4) + else if not((BitsN.bits(3,0) ((#IT) (!CPSR))) = (BitsN.B(0x0,4))) + then BitsN.bits(7,4) ((#IT) (!CPSR)) else raise UNPREDICTABLE ("ThumbCondition"); fun BigEndian () = (#E) (!CPSR); @@ -2442,7 +2442,7 @@ fun ConditionPassed () = let val cond = CurrentCond () val result = - case BitsN.bits(cond,3,1) of + case BitsN.bits(3,1) cond of BitsN.B(0x0,3) => (#Z) (!CPSR) | BitsN.B(0x1,3) => (#C) (!CPSR) | BitsN.B(0x2,3) => (#N) (!CPSR) @@ -2499,7 +2499,8 @@ fun CPSRWriteByInstr (value,(bytemask,is_excpt_return)) = CPSR := (write'reg'PSR ((!CPSR), - BitsN.bitFieldInsert(w,BitsN.bits(value,31,27),31,27))) + BitsN.bitFieldInsert(31,27) + (w,BitsN.bits(31,27) value))) end ; if is_excpt_return then let @@ -2508,8 +2509,8 @@ fun CPSRWriteByInstr (value,(bytemask,is_excpt_return)) = CPSR := (write'reg'PSR ((!CPSR), - BitsN.bitFieldInsert - (w,BitsN.bits(value,26,24),26,24))) + BitsN.bitFieldInsert(26,24) + (w,BitsN.bits(26,24) value))) end else () ) @@ -2521,7 +2522,7 @@ fun CPSRWriteByInstr (value,(bytemask,is_excpt_return)) = CPSR := (write'reg'PSR ((!CPSR), - BitsN.bitFieldInsert(w,BitsN.bits(value,19,16),19,16))) + BitsN.bitFieldInsert(19,16) (w,BitsN.bits(19,16) value))) end else () ; if BitsN.bit(bytemask,1) @@ -2532,8 +2533,8 @@ fun CPSRWriteByInstr (value,(bytemask,is_excpt_return)) = CPSR := (write'reg'PSR ((!CPSR), - BitsN.bitFieldInsert - (w,BitsN.bits(value,15,10),15,10))) + BitsN.bitFieldInsert(15,10) + (w,BitsN.bits(15,10) value))) end else () ; let @@ -2542,8 +2543,8 @@ fun CPSRWriteByInstr (value,(bytemask,is_excpt_return)) = CPSR := (write'reg'PSR ((!CPSR), - BitsN.bitFieldInsert - (w,BitsN.fromBit(BitsN.bit(value,9)),9,9))) + BitsN.bitFieldInsert(9,9) + (w,BitsN.fromBit(BitsN.bit(value,9))))) end ; if privileged andalso ((IsSecure ()) orelse ((#AW)((#SCR) (!CP15)))) @@ -2553,8 +2554,8 @@ fun CPSRWriteByInstr (value,(bytemask,is_excpt_return)) = CPSR := (write'reg'PSR ((!CPSR), - BitsN.bitFieldInsert - (w,BitsN.fromBit(BitsN.bit(value,8)),8,8))) + BitsN.bitFieldInsert(8,8) + (w,BitsN.fromBit(BitsN.bit(value,8))))) end else () ) @@ -2567,8 +2568,8 @@ fun CPSRWriteByInstr (value,(bytemask,is_excpt_return)) = CPSR := (write'reg'PSR ((!CPSR), - BitsN.bitFieldInsert - (w,BitsN.fromBit(BitsN.bit(value,7)),7,7))) + BitsN.bitFieldInsert(7,7) + (w,BitsN.fromBit(BitsN.bit(value,7))))) end else () ; if (privileged andalso @@ -2581,8 +2582,8 @@ fun CPSRWriteByInstr (value,(bytemask,is_excpt_return)) = CPSR := (write'reg'PSR ((!CPSR), - BitsN.bitFieldInsert - (w,BitsN.fromBit(BitsN.bit(value,6)),6,6))) + BitsN.bitFieldInsert(6,6) + (w,BitsN.fromBit(BitsN.bit(value,6))))) end else () ; if is_excpt_return @@ -2592,45 +2593,45 @@ fun CPSRWriteByInstr (value,(bytemask,is_excpt_return)) = CPSR := (write'reg'PSR ((!CPSR), - BitsN.bitFieldInsert - (w,BitsN.fromBit(BitsN.bit(value,5)),5,5))) + BitsN.bitFieldInsert(5,5) + (w,BitsN.fromBit(BitsN.bit(value,5))))) end else () ; if privileged - then if BadMode(BitsN.bits(value,4,0)) + then if BadMode(BitsN.bits(4,0) value) then raise UNPREDICTABLE (("CPSRWriteByInstr: BadMode: ") ^ (BitsN.toHexString - (BitsN.bits(value,4,0)))) + (BitsN.bits(4,0) value))) else ( if (not(IsSecure ())) andalso - ((BitsN.bits(value,4,0)) = + ((BitsN.bits(4,0) value) = (BitsN.B(0x16,5))) then raise UNPREDICTABLE ("CPSRWriteByInstr") else () ; if ((not(IsSecure ())) andalso - ((BitsN.bits(value,4,0)) = + ((BitsN.bits(4,0) value) = (BitsN.B(0x11,5)))) andalso ((#RFR)((#NSACR) (!CP15))) then raise UNPREDICTABLE ("CPSRWriteByInstr") else () ; if (not((#NS)((#SCR) (!CP15)))) andalso - ((BitsN.bits(value,4,0)) = + ((BitsN.bits(4,0) value) = (BitsN.B(0x1A,5))) then raise UNPREDICTABLE ("CPSRWriteByInstr") else () ; if ((not(IsSecure ())) andalso (not(((#M) (!CPSR)) = (BitsN.B(0x1A,5))))) andalso - ((BitsN.bits(value,4,0)) = + ((BitsN.bits(4,0) value) = (BitsN.B(0x1A,5))) then raise UNPREDICTABLE ("CPSRWriteByInstr") else () ; if ((((#M) (!CPSR)) = (BitsN.B(0x1A,5))) andalso - (not((BitsN.bits(value,4,0)) = + (not((BitsN.bits(4,0) value) = (BitsN.B(0x1A,5))))) andalso (not is_excpt_return) then raise UNPREDICTABLE @@ -2642,8 +2643,8 @@ fun CPSRWriteByInstr (value,(bytemask,is_excpt_return)) = CPSR := (write'reg'PSR ((!CPSR), - BitsN.bitFieldInsert - (w,BitsN.bits(value,4,0),4,0))) + BitsN.bitFieldInsert(4,0) + (w,BitsN.bits(4,0) value))) end ) else () @@ -2663,7 +2664,8 @@ fun SPSRWriteByInstr (value,bytemask) = in write'SPSR (write'reg'PSR - (x,BitsN.bitFieldInsert(w,BitsN.bits(value,31,24),31,24))) + (x, + BitsN.bitFieldInsert(31,24) (w,BitsN.bits(31,24) value))) end else () ; if BitsN.bit(bytemask,2) @@ -2673,7 +2675,8 @@ fun SPSRWriteByInstr (value,bytemask) = in write'SPSR (write'reg'PSR - (x,BitsN.bitFieldInsert(w,BitsN.bits(value,19,16),19,16))) + (x, + BitsN.bitFieldInsert(19,16) (w,BitsN.bits(19,16) value))) end else () ; if BitsN.bit(bytemask,1) @@ -2683,7 +2686,7 @@ fun SPSRWriteByInstr (value,bytemask) = in write'SPSR (write'reg'PSR - (x,BitsN.bitFieldInsert(w,BitsN.bits(value,15,8),15,8))) + (x,BitsN.bitFieldInsert(15,8) (w,BitsN.bits(15,8) value))) end else () ; if BitsN.bit(bytemask,0) @@ -2693,13 +2696,13 @@ fun SPSRWriteByInstr (value,bytemask) = in write'SPSR (write'reg'PSR - (x,BitsN.bitFieldInsert(w,BitsN.bits(value,7,5),7,5))) + (x,BitsN.bitFieldInsert(7,5) (w,BitsN.bits(7,5) value))) end - ; if BadMode(BitsN.bits(value,4,0)) + ; if BadMode(BitsN.bits(4,0) value) then raise UNPREDICTABLE (("SPSRWriteByInstr: BadMode: ") ^ - (BitsN.toHexString(BitsN.bits(value,4,0)))) + (BitsN.toHexString(BitsN.bits(4,0) value))) else let val x = SPSR () val w = reg'PSR x @@ -2707,8 +2710,8 @@ fun SPSRWriteByInstr (value,bytemask) = write'SPSR (write'reg'PSR (x, - BitsN.bitFieldInsert - (w,BitsN.bits(value,4,0),4,0))) + BitsN.bitFieldInsert(4,0) + (w,BitsN.bits(4,0) value))) end ) else () @@ -2794,7 +2797,7 @@ fun write'Rmode (value,(n,mode)) = then raise UNPREDICTABLE ("Rmode") else () ; if ((n = (BitsN.B(0xD,4))) andalso - (not((BitsN.bits(value,1,0)) = (BitsN.B(0x0,2))))) andalso + (not((BitsN.bits(1,0) value) = (BitsN.B(0x0,2))))) andalso (not((CurrentInstrSet ()) = InstrSet_ARM)) then raise UNPREDICTABLE ("Rmode") else () @@ -2839,22 +2842,22 @@ fun PCStoreValue () = PC (); fun BranchWritePC address = if (CurrentInstrSet ()) = InstrSet_ARM then ( if (Nat.<(ArchVersion (),6)) andalso - (not((BitsN.bits(address,1,0)) = (BitsN.B(0x0,2)))) + (not((BitsN.bits(1,0) address) = (BitsN.B(0x0,2)))) then raise UNPREDICTABLE ("BranchWritePC") else () - ; BranchTo(BitsN.@@(BitsN.bits(address,31,2),BitsN.B(0x0,2))) + ; BranchTo(BitsN.@@(BitsN.bits(31,2) address,BitsN.B(0x0,2))) ) - else BranchTo(BitsN.@@(BitsN.bits(address,31,1),BitsN.B(0x0,1))); + else BranchTo(BitsN.@@(BitsN.bits(31,1) address,BitsN.B(0x0,1))); fun BXWritePC address = if (CurrentInstrSet ()) = InstrSet_ThumbEE then if BitsN.bit(address,0) then BranchTo - (BitsN.@@(BitsN.bits(address,31,1),BitsN.B(0x0,1))) + (BitsN.@@(BitsN.bits(31,1) address,BitsN.B(0x0,1))) else raise UNPREDICTABLE ("BXWritePC") else if BitsN.bit(address,0) then ( SelectInstrSet InstrSet_Thumb - ; BranchTo(BitsN.@@(BitsN.bits(address,31,1),BitsN.B(0x0,1))) + ; BranchTo(BitsN.@@(BitsN.bits(31,1) address,BitsN.B(0x0,1))) ) else if not(BitsN.bit(address,1)) then ( SelectInstrSet InstrSet_ARM; BranchTo address ) @@ -2886,30 +2889,30 @@ fun mem1 address = fun mem (address,size) = case size of - 1 => Bitstring.bits(mem1(BitsN.+(address,BitsN.B(0x0,32))),7,0) + 1 => Bitstring.bits(7,0) (mem1(BitsN.+(address,BitsN.B(0x0,32)))) | 2 => - Bitstring.bits + Bitstring.bits(15,0) ((mem1(BitsN.+(address,BitsN.B(0x1,32)))) - @ - (mem1(BitsN.+(address,BitsN.B(0x0,32)))),15,0) + @ + (mem1(BitsN.+(address,BitsN.B(0x0,32))))) | 4 => - Bitstring.bits + Bitstring.bits(31,0) (List.concat - [mem1(BitsN.+(address,BitsN.B(0x3,32))), - mem1(BitsN.+(address,BitsN.B(0x2,32))), - mem1(BitsN.+(address,BitsN.B(0x1,32))), - mem1(BitsN.+(address,BitsN.B(0x0,32)))],31,0) + [mem1(BitsN.+(address,BitsN.B(0x3,32))), + mem1(BitsN.+(address,BitsN.B(0x2,32))), + mem1(BitsN.+(address,BitsN.B(0x1,32))), + mem1(BitsN.+(address,BitsN.B(0x0,32)))]) | 8 => - Bitstring.bits + Bitstring.bits(63,0) (List.concat - [mem1(BitsN.+(address,BitsN.B(0x7,32))), - mem1(BitsN.+(address,BitsN.B(0x6,32))), - mem1(BitsN.+(address,BitsN.B(0x5,32))), - mem1(BitsN.+(address,BitsN.B(0x4,32))), - mem1(BitsN.+(address,BitsN.B(0x3,32))), - mem1(BitsN.+(address,BitsN.B(0x2,32))), - mem1(BitsN.+(address,BitsN.B(0x1,32))), - mem1(BitsN.+(address,BitsN.B(0x0,32)))],63,0) + [mem1(BitsN.+(address,BitsN.B(0x7,32))), + mem1(BitsN.+(address,BitsN.B(0x6,32))), + mem1(BitsN.+(address,BitsN.B(0x5,32))), + mem1(BitsN.+(address,BitsN.B(0x4,32))), + mem1(BitsN.+(address,BitsN.B(0x3,32))), + mem1(BitsN.+(address,BitsN.B(0x2,32))), + mem1(BitsN.+(address,BitsN.B(0x1,32))), + mem1(BitsN.+(address,BitsN.B(0x0,32)))]) | _ => raise ASSERT ("mem: size in {1, 2, 4, 8}"); fun write'mem (value,(address,size)) = @@ -2921,7 +2924,7 @@ fun write'mem (value,(address,size)) = MEM := (Map.update ((!MEM),BitsN.toNat x, - BitsN.fromBitstring(Bitstring.bits(value,7,0),8))) + BitsN.fromBitstring(Bitstring.bits(7,0) value,8))) end | 2 => ( let @@ -2930,7 +2933,7 @@ fun write'mem (value,(address,size)) = MEM := (Map.update ((!MEM),BitsN.toNat x, - BitsN.fromBitstring(Bitstring.bits(value,7,0),8))) + BitsN.fromBitstring(Bitstring.bits(7,0) value,8))) end ; let val x = BitsN.+(address,BitsN.B(0x1,32)) @@ -2938,7 +2941,7 @@ fun write'mem (value,(address,size)) = MEM := (Map.update ((!MEM),BitsN.toNat x, - BitsN.fromBitstring(Bitstring.bits(value,15,8),8))) + BitsN.fromBitstring(Bitstring.bits(15,8) value,8))) end ) | 4 => @@ -2948,7 +2951,7 @@ fun write'mem (value,(address,size)) = MEM := (Map.update ((!MEM),BitsN.toNat x, - BitsN.fromBitstring(Bitstring.bits(value,7,0),8))) + BitsN.fromBitstring(Bitstring.bits(7,0) value,8))) end ; let val x = BitsN.+(address,BitsN.B(0x1,32)) @@ -2956,7 +2959,7 @@ fun write'mem (value,(address,size)) = MEM := (Map.update ((!MEM),BitsN.toNat x, - BitsN.fromBitstring(Bitstring.bits(value,15,8),8))) + BitsN.fromBitstring(Bitstring.bits(15,8) value,8))) end ; let val x = BitsN.+(address,BitsN.B(0x2,32)) @@ -2964,7 +2967,7 @@ fun write'mem (value,(address,size)) = MEM := (Map.update ((!MEM),BitsN.toNat x, - BitsN.fromBitstring(Bitstring.bits(value,23,16),8))) + BitsN.fromBitstring(Bitstring.bits(23,16) value,8))) end ; let val x = BitsN.+(address,BitsN.B(0x3,32)) @@ -2972,7 +2975,7 @@ fun write'mem (value,(address,size)) = MEM := (Map.update ((!MEM),BitsN.toNat x, - BitsN.fromBitstring(Bitstring.bits(value,31,24),8))) + BitsN.fromBitstring(Bitstring.bits(31,24) value,8))) end ) | 8 => @@ -2982,7 +2985,7 @@ fun write'mem (value,(address,size)) = MEM := (Map.update ((!MEM),BitsN.toNat x, - BitsN.fromBitstring(Bitstring.bits(value,7,0),8))) + BitsN.fromBitstring(Bitstring.bits(7,0) value,8))) end ; let val x = BitsN.+(address,BitsN.B(0x1,32)) @@ -2990,7 +2993,7 @@ fun write'mem (value,(address,size)) = MEM := (Map.update ((!MEM),BitsN.toNat x, - BitsN.fromBitstring(Bitstring.bits(value,15,8),8))) + BitsN.fromBitstring(Bitstring.bits(15,8) value,8))) end ; let val x = BitsN.+(address,BitsN.B(0x2,32)) @@ -2998,7 +3001,7 @@ fun write'mem (value,(address,size)) = MEM := (Map.update ((!MEM),BitsN.toNat x, - BitsN.fromBitstring(Bitstring.bits(value,23,16),8))) + BitsN.fromBitstring(Bitstring.bits(23,16) value,8))) end ; let val x = BitsN.+(address,BitsN.B(0x3,32)) @@ -3006,7 +3009,7 @@ fun write'mem (value,(address,size)) = MEM := (Map.update ((!MEM),BitsN.toNat x, - BitsN.fromBitstring(Bitstring.bits(value,31,24),8))) + BitsN.fromBitstring(Bitstring.bits(31,24) value,8))) end ; let val x = BitsN.+(address,BitsN.B(0x4,32)) @@ -3014,7 +3017,7 @@ fun write'mem (value,(address,size)) = MEM := (Map.update ((!MEM),BitsN.toNat x, - BitsN.fromBitstring(Bitstring.bits(value,39,32),8))) + BitsN.fromBitstring(Bitstring.bits(39,32) value,8))) end ; let val x = BitsN.+(address,BitsN.B(0x5,32)) @@ -3022,7 +3025,7 @@ fun write'mem (value,(address,size)) = MEM := (Map.update ((!MEM),BitsN.toNat x, - BitsN.fromBitstring(Bitstring.bits(value,47,40),8))) + BitsN.fromBitstring(Bitstring.bits(47,40) value,8))) end ; let val x = BitsN.+(address,BitsN.B(0x6,32)) @@ -3030,7 +3033,7 @@ fun write'mem (value,(address,size)) = MEM := (Map.update ((!MEM),BitsN.toNat x, - BitsN.fromBitstring(Bitstring.bits(value,55,48),8))) + BitsN.fromBitstring(Bitstring.bits(55,48) value,8))) end ; let val x = BitsN.+(address,BitsN.B(0x7,32)) @@ -3038,25 +3041,25 @@ fun write'mem (value,(address,size)) = MEM := (Map.update ((!MEM),BitsN.toNat x, - BitsN.fromBitstring(Bitstring.bits(value,63,56),8))) + BitsN.fromBitstring(Bitstring.bits(63,56) value,8))) end ) | _ => raise ASSERT ("mem: size in {1, 2, 4, 8}"); fun BigEndianReverse (value,n) = case n of - 1 => Bitstring.bits(value,7,0) - | 2 => (Bitstring.bits(value,7,0)) @ (Bitstring.bits(value,15,8)) + 1 => Bitstring.bits(7,0) value + | 2 => (Bitstring.bits(7,0) value) @ (Bitstring.bits(15,8) value) | 4 => List.concat - [Bitstring.bits(value,7,0),Bitstring.bits(value,15,8), - Bitstring.bits(value,23,16),Bitstring.bits(value,31,24)] + [Bitstring.bits(7,0) value,Bitstring.bits(15,8) value, + Bitstring.bits(23,16) value,Bitstring.bits(31,24) value] | 8 => List.concat - [Bitstring.bits(value,7,0),Bitstring.bits(value,15,8), - Bitstring.bits(value,23,16),Bitstring.bits(value,31,24), - Bitstring.bits(value,39,32),Bitstring.bits(value,47,40), - Bitstring.bits(value,55,48),Bitstring.bits(value,63,56)] + [Bitstring.bits(7,0) value,Bitstring.bits(15,8) value, + Bitstring.bits(23,16) value,Bitstring.bits(31,24) value, + Bitstring.bits(39,32) value,Bitstring.bits(47,40) value, + Bitstring.bits(55,48) value,Bitstring.bits(63,56) value] | _ => raise ASSERT ("BigEndianReverse: n in {1, 2, 4, 8}"); fun Align N (w,n) = BitsN.fromNat(Nat.*(n,Nat.div(BitsN.toNat w,n)),N); @@ -3149,12 +3152,12 @@ fun MemU_with_priv N (address,(size,privileged)) = val l = Nat.*(8,i) in value := - (Bitstring.bitFieldInsert + (Bitstring.bitFieldInsert(h,l) ((!value), - BitsN.toBitstring - (MemA_with_priv 8 - (BitsN.+(VA,BitsN.fromNat(i,32)), - (1,privileged))),h,l)) + BitsN.toBitstring + (MemA_with_priv 8 + (BitsN.+(VA,BitsN.fromNat(i,32)), + (1,privileged))))) end) ; if (#E) (!CPSR) then value := (BigEndianReverse((!value),size)) @@ -3195,7 +3198,7 @@ fun write'MemU_with_priv N (value,(address,(size,privileged))) = in write'MemA_with_priv 8 (BitsN.fromBitstring - (Bitstring.bits(v,Nat.+(Nat.*(8,i),7),Nat.*(8,i)),8), + (Bitstring.bits(Nat.+(Nat.*(8,i),7),Nat.*(8,i)) v,8), x) end) end @@ -3236,7 +3239,7 @@ fun NullCheckIfThumbEE n = else () else if (R n) = (BitsN.B(0x0,32)) then ( write'LR - (BitsN.@@(BitsN.bits(PC (),31,1),BitsN.B(0x1,1))) + (BitsN.@@(BitsN.bits(31,1) (PC ()),BitsN.B(0x1,1))) ; write'ITSTATE(BitsN.B(0x0,8)) ; BranchWritePC (BitsN.-((#TEEHBR) (!CP14),BitsN.B(0x4,32))) @@ -3359,8 +3362,8 @@ fun RRX_C N (x,carry_in) = BitsN.fromBitstring ((Bitstring.fromBool carry_in) @ - (Bitstring.bits - (BitsN.toBitstring x,Nat.-(BitsN.size(BitsN.B(0x0,N)),1),1)),N) + (Bitstring.bits(Nat.-(BitsN.size(BitsN.B(0x0,N)),1),1) + (BitsN.toBitstring x)),N) in (result,BitsN.bit(x,0)) end; @@ -3405,40 +3408,40 @@ fun Shift N (value,(typ,(amount,carry_in))) = fun ARMExpandImm_C (imm12,carry_in) = let - val unroatated_value = BitsN.zeroExtend 32 (BitsN.bits(imm12,7,0)) + val unroatated_value = BitsN.zeroExtend 32 (BitsN.bits(7,0) imm12) in Shift_C 32 (unroatated_value, - (SRType_ROR,(Nat.*(2,BitsN.toNat(BitsN.bits(imm12,11,8))),carry_in))) + (SRType_ROR,(Nat.*(2,BitsN.toNat(BitsN.bits(11,8) imm12)),carry_in))) end; fun ARMExpandImm imm12 = L3.fst(ARMExpandImm_C(imm12,(#C) (!CPSR))); fun ThumbExpandImm_C (imm12,carry_in) = - if (BitsN.bits(imm12,11,10)) = (BitsN.B(0x0,2)) + if (BitsN.bits(11,10) imm12) = (BitsN.B(0x0,2)) then let val imm32 = - case BitsN.bits(imm12,9,8) of + case BitsN.bits(9,8) imm12 of BitsN.B(0x0,2) => - BitsN.zeroExtend 32 (BitsN.bits(imm12,7,0)) + BitsN.zeroExtend 32 (BitsN.bits(7,0) imm12) | BitsN.B(0x1,2) => - if (BitsN.bits(imm12,7,0)) = (BitsN.B(0x0,8)) + if (BitsN.bits(7,0) imm12) = (BitsN.B(0x0,8)) then raise UNPREDICTABLE ("ThumbExpandImm_C") else BitsN.concat - [BitsN.B(0x0,8),BitsN.bits(imm12,7,0), - BitsN.B(0x0,8),BitsN.bits(imm12,7,0)] + [BitsN.B(0x0,8),BitsN.bits(7,0) imm12, + BitsN.B(0x0,8),BitsN.bits(7,0) imm12] | BitsN.B(0x2,2) => - if (BitsN.bits(imm12,7,0)) = (BitsN.B(0x0,8)) + if (BitsN.bits(7,0) imm12) = (BitsN.B(0x0,8)) then raise UNPREDICTABLE ("ThumbExpandImm_C") else BitsN.concat - [BitsN.bits(imm12,7,0),BitsN.B(0x0,8), - BitsN.bits(imm12,7,0),BitsN.B(0x0,8)] + [BitsN.bits(7,0) imm12,BitsN.B(0x0,8), + BitsN.bits(7,0) imm12,BitsN.B(0x0,8)] | BitsN.B(0x3,2) => - if (BitsN.bits(imm12,7,0)) = (BitsN.B(0x0,8)) + if (BitsN.bits(7,0) imm12) = (BitsN.B(0x0,8)) then raise UNPREDICTABLE ("ThumbExpandImm_C") else BitsN.concat - [BitsN.bits(imm12,7,0),BitsN.bits(imm12,7,0), - BitsN.bits(imm12,7,0),BitsN.bits(imm12,7,0)] + [BitsN.bits(7,0) imm12,BitsN.bits(7,0) imm12, + BitsN.bits(7,0) imm12,BitsN.bits(7,0) imm12] | _ => raise General.Bind in (imm32,carry_in) @@ -3446,9 +3449,9 @@ fun ThumbExpandImm_C (imm12,carry_in) = else let val unroatated_value = BitsN.zeroExtend 32 - (BitsN.@@(BitsN.B(0x1,1),BitsN.bits(imm12,6,0))) + (BitsN.@@(BitsN.B(0x1,1),BitsN.bits(6,0) imm12)) in - ROR_C 32 (unroatated_value,BitsN.toNat(BitsN.bits(imm12,11,7))) + ROR_C 32 (unroatated_value,BitsN.toNat(BitsN.bits(11,7) imm12)) end; fun ExpandImm_C (imm12,carry_in) = @@ -3980,44 +3983,44 @@ fun WriteHSR (ec,HSRString) = let val HSRValue = ref (BitsN.B(0x0,32)) in - ( HSRValue := (BitsN.bitFieldInsert((!HSRValue),ec,31,26)) - ; if (not((BitsN.bits(ec,5,3)) = (BitsN.B(0x4,3)))) orelse + ( HSRValue := (BitsN.bitFieldInsert(31,26) ((!HSRValue),ec)) + ; if (not((BitsN.bits(5,3) ec) = (BitsN.B(0x4,3)))) orelse ((BitsN.bit(ec,2)) andalso (BitsN.bit(HSRString,24))) then HSRValue := - (BitsN.bitFieldInsert - ((!HSRValue),BitsN.fromBit((ThisInstrLength ()) = 32),25, - 25)) + (BitsN.bitFieldInsert(25,25) + ((!HSRValue),BitsN.fromBit((ThisInstrLength ()) = 32))) else () - ; if ((BitsN.bits(ec,5,4)) = (BitsN.B(0x0,2))) andalso - (not((BitsN.bits(ec,3,0)) = (BitsN.B(0x0,4)))) + ; if ((BitsN.bits(5,4) ec) = (BitsN.B(0x0,2))) andalso + (not((BitsN.bits(3,0) ec) = (BitsN.B(0x0,4)))) then if (CurrentInstrSet ()) = InstrSet_ARM then ( HSRValue := - (BitsN.bitFieldInsert - ((!HSRValue),BitsN.fromBit true,24,24)) + (BitsN.bitFieldInsert(24,24) + ((!HSRValue),BitsN.fromBit true)) ; HSRValue := - (BitsN.bitFieldInsert - ((!HSRValue),CurrentCond (),23,20)) + (BitsN.bitFieldInsert(23,20) + ((!HSRValue),CurrentCond ())) ) else ( HSRValue := - (BitsN.bitFieldInsert - ((!HSRValue),BitsN.fromBit false,24,24)) + (BitsN.bitFieldInsert(24,24) + ((!HSRValue),BitsN.fromBit false)) ; if BitsN.bit((!HSRValue),24) then if ConditionPassed () then HSRValue := - (BitsN.bitFieldInsert + (BitsN.bitFieldInsert(23,20) ((!HSRValue), - if false - then CurrentCond () - else BitsN.B(0xE,4),23,20)) + if false + then CurrentCond () + else BitsN.B(0xE,4))) else HSRValue := - (BitsN.bitFieldInsert - ((!HSRValue),CurrentCond (),23,20)) + (BitsN.bitFieldInsert(23,20) + ((!HSRValue),CurrentCond ())) else () ; HSRValue := - (BitsN.bitFieldInsert - ((!HSRValue),BitsN.bits(HSRString,19,0),19,0)) + (BitsN.bitFieldInsert(19,0) + ((!HSRValue),BitsN.bits(19,0) HSRString)) ) - else HSRValue := (BitsN.bitFieldInsert((!HSRValue),HSRString,24,0)) + else HSRValue := + (BitsN.bitFieldInsert(24,0) ((!HSRValue),HSRString)) ; let val x0 = (#HSR) (!CP15) in @@ -4034,11 +4037,11 @@ fun CallSupervisor immediate = val HSRString = ref (BitsN.B(0x0,25)) in ( HSRString := - (BitsN.bitFieldInsert + (BitsN.bitFieldInsert(15,0) ((!HSRString), - if (CurrentCond ()) = (BitsN.B(0xE,4)) - then immediate - else BitsN.B(0x0,16),15,0)) + if (CurrentCond ()) = (BitsN.B(0xE,4)) + then immediate + else BitsN.B(0x0,16))) ; WriteHSR(BitsN.B(0x12,6),(!HSRString)) ) end @@ -4054,27 +4057,27 @@ fun CallHypervisor immediate = end; fun BankedRegisterAccessValid (SYSm,mode) = - if (BitsN.bits(SYSm,4,3)) = (BitsN.B(0x0,2)) - then if (BitsN.bits(SYSm,2,0)) = (BitsN.B(0x7,3)) + if (BitsN.bits(4,3) SYSm) = (BitsN.B(0x0,2)) + then if (BitsN.bits(2,0) SYSm) = (BitsN.B(0x7,3)) then raise UNPREDICTABLE ("BankedRegisterAccessValid") - else if (BitsN.bits(SYSm,2,0)) = (BitsN.B(0x6,3)) + else if (BitsN.bits(2,0) SYSm) = (BitsN.B(0x6,3)) then if Set.mem(mode,[BitsN.B(0x1A,5),BitsN.B(0x1F,5)]) then raise UNPREDICTABLE ("BankedRegisterAccessValid") else () - else if (BitsN.bits(SYSm,2,0)) = (BitsN.B(0x5,3)) + else if (BitsN.bits(2,0) SYSm) = (BitsN.B(0x5,3)) then if mode = (BitsN.B(0x1F,5)) then raise UNPREDICTABLE ("BankedRegisterAccessValid") else () else if not(mode = (BitsN.B(0x11,5))) then raise UNPREDICTABLE ("BankedRegisterAccessValid") else () - else if (BitsN.bits(SYSm,4,3)) = (BitsN.B(0x1,2)) - then if (((BitsN.bits(SYSm,2,0)) = (BitsN.B(0x7,3))) orelse + else if (BitsN.bits(4,3) SYSm) = (BitsN.B(0x1,2)) + then if (((BitsN.bits(2,0) SYSm) = (BitsN.B(0x7,3))) orelse (mode = (BitsN.B(0x11,5)))) orelse (((#RFR)((#NSACR) (!CP15))) andalso (not(IsSecure ()))) then raise UNPREDICTABLE ("BankedRegisterAccessValid") else () - else if (BitsN.bits(SYSm,4,3)) = (BitsN.B(0x3,2)) + else if (BitsN.bits(4,3) SYSm) = (BitsN.B(0x3,2)) then if not(BitsN.bit(SYSm,2)) then raise UNPREDICTABLE ("BankedRegisterAccessValid") else if not(BitsN.bit(SYSm,1)) @@ -4126,7 +4129,7 @@ fun dfn'BranchExchange m = BXWritePC(R m); fun dfn'BranchLinkExchangeImmediate (targetInstrSet,imm32) = ( if (CurrentInstrSet ()) = InstrSet_ARM then write'LR(BitsN.-(PC (),BitsN.B(0x4,32))) - else write'LR(BitsN.@@(BitsN.bits(PC (),31,1),BitsN.B(0x1,1))) + else write'LR(BitsN.@@(BitsN.bits(31,1) (PC ()),BitsN.B(0x1,1))) ; let val targetAddress = if targetInstrSet = InstrSet_ARM @@ -4151,7 +4154,7 @@ fun dfn'BranchLinkExchangeRegister m = val next_instr_addr = BitsN.-(PC (),BitsN.B(0x2,32)) in write'LR - (BitsN.@@(BitsN.bits(next_instr_addr,31,1),BitsN.B(0x1,1))) + (BitsN.@@(BitsN.bits(31,1) next_instr_addr,BitsN.B(0x1,1))) end ; BXWritePC target ) @@ -4181,7 +4184,7 @@ fun dfn'TableBranchByte (is_tbh,(m,n)) = fun dfn'CheckArray (m,n) = if BitsN.<=+(R n,R m) - then ( write'LR(BitsN.@@(BitsN.bits(PC (),31,1),BitsN.B(0x1,1))) + then ( write'LR(BitsN.@@(BitsN.bits(31,1) (PC ()),BitsN.B(0x1,1))) ; write'ITSTATE(BitsN.B(0x0,8)) ; BranchWritePC(BitsN.-((#TEEHBR) (!CP14),BitsN.B(0x8,32))) ) @@ -4193,7 +4196,7 @@ fun dfn'HandlerBranchLink (generate_link,handler_offset) = val next_instr_addr = BitsN.-(PC (),BitsN.B(0x2,32)) in write'LR - (BitsN.@@(BitsN.bits(next_instr_addr,31,1),BitsN.B(0x1,1))) + (BitsN.@@(BitsN.bits(31,1) next_instr_addr,BitsN.B(0x1,1))) end else () ; BranchWritePC(BitsN.+((#TEEHBR) (!CP14),handler_offset)) @@ -4205,7 +4208,7 @@ fun dfn'HandlerBranchLinkParameter (imm32,handler_offset) = val next_instr_addr = BitsN.-(PC (),BitsN.B(0x2,32)) in ( write'LR - (BitsN.@@(BitsN.bits(next_instr_addr,31,1),BitsN.B(0x1,1))) + (BitsN.@@(BitsN.bits(31,1) next_instr_addr,BitsN.B(0x1,1))) ; BranchWritePC(BitsN.+((#TEEHBR) (!CP14),handler_offset)) ) end @@ -4237,7 +4240,7 @@ fun dfn'MoveHalfword (high,(d,imm16)) = then let val w = R d in - write'R(BitsN.bitFieldInsert(w,imm16,31,16),d) + write'R(BitsN.bitFieldInsert(31,16) (w,imm16),d) end else write'R(BitsN.zeroExtend 32 imm16,d) ; IncPC () @@ -4256,7 +4259,7 @@ fun DataProcessing (opc,(setflags,(d,(n,(imm32,C))))) = val (result,(carry,overflow)) = DataProcessingALU(opc,(rn,(imm32,(#C) (!CPSR)))) in - ( if not((BitsN.bits(opc,3,2)) = (BitsN.B(0x2,2))) + ( if not((BitsN.bits(3,2) opc) = (BitsN.B(0x2,2))) then write'R(result,d) else () ; if setflags @@ -4359,7 +4362,7 @@ fun doRegisterShiftedRegister (opc,(setflags,(d,(n,(m,(shift_t,s)))))) = let val (shifted,carry) = Shift_C 32 - (R m,(shift_t,(BitsN.toNat(BitsN.bits(R s,7,0)),(#C) (!CPSR)))) + (R m,(shift_t,(BitsN.toNat(BitsN.bits(7,0) (R s)),(#C) (!CPSR)))) in DataProcessing(opc,(setflags,(d,(n,(shifted,carry))))) end; @@ -4490,8 +4493,8 @@ fun dfn'MultiplyLong (accumulate,(signed,(setflags,(dhi,(dlo,(n,m)))))) = else BitsN.*(BitsN.zeroExtend 64 rn,BitsN.zeroExtend 64 rm), if accumulate then BitsN.@@(rdhi,rdlo) else BitsN.B(0x0,64)) in - ( write'R(BitsN.bits(result,63,32),dhi) - ; write'R(BitsN.bits(result,31,0),dlo) + ( write'R(BitsN.bits(63,32) result,dhi) + ; write'R(BitsN.bits(31,0) result,dlo) ; if setflags then ( CPSR := (PSR_N_rupd((!CPSR),BitsN.bit(result,63))) ; CPSR := (PSR_Z_rupd((!CPSR),result = (BitsN.B(0x0,64)))) @@ -4522,8 +4525,8 @@ fun dfn'MultiplyAccumulateAccumulate (dhi,(dlo,(n,m))) = (BitsN.*(BitsN.zeroExtend 64 (R n),BitsN.zeroExtend 64 (R m)), BitsN.zeroExtend 64 (R dhi)),BitsN.zeroExtend 64 (R dlo)) in - ( write'R(BitsN.bits(result,63,32),dhi) - ; write'R(BitsN.bits(result,31,0),dlo) + ( write'R(BitsN.bits(63,32) result,dhi) + ; write'R(BitsN.bits(31,0) result,dlo) ; IncPC () ) end; @@ -4534,9 +4537,9 @@ fun dfn'MultiplySubtract (d,(n,(m,a))) = fun dfn'Signed16Multiply32Accumulate (m_high,(n_high,(d,(n,(m,a))))) = let val operand1 = - if n_high then BitsN.bits(R n,31,16) else BitsN.bits(R n,15,0) + if n_high then BitsN.bits(31,16) (R n) else BitsN.bits(15,0) (R n) val operand2 = - if m_high then BitsN.bits(R m,31,16) else BitsN.bits(R m,15,0) + if m_high then BitsN.bits(31,16) (R m) else BitsN.bits(15,0) (R m) val result = Int.+ (Int.*(BitsN.toInt operand1,BitsN.toInt operand2),BitsN.toInt(R a)) @@ -4553,9 +4556,9 @@ fun dfn'Signed16Multiply32Accumulate (m_high,(n_high,(d,(n,(m,a))))) = fun dfn'Signed16Multiply32Result (m_high,(n_high,(d,(n,m)))) = let val operand1 = - if n_high then BitsN.bits(R n,31,16) else BitsN.bits(R n,15,0) + if n_high then BitsN.bits(31,16) (R n) else BitsN.bits(15,0) (R n) val operand2 = - if m_high then BitsN.bits(R m,31,16) else BitsN.bits(R m,15,0) + if m_high then BitsN.bits(31,16) (R m) else BitsN.bits(15,0) (R m) val result = Int.*(BitsN.toInt operand1,BitsN.toInt operand2) in ( write'R(BitsN.fromInt(result,32),d); IncPC () ) @@ -4564,7 +4567,7 @@ fun dfn'Signed16Multiply32Result (m_high,(n_high,(d,(n,m)))) = fun dfn'Signed16x32Multiply32Accumulate (m_high,(d,(n,(m,a)))) = let val operand2 = - if m_high then BitsN.bits(R m,31,16) else BitsN.bits(R m,15,0) + if m_high then BitsN.bits(31,16) (R m) else BitsN.bits(15,0) (R m) val sh16 = IntInf.pow(2,16) val result = Int.div @@ -4584,7 +4587,7 @@ fun dfn'Signed16x32Multiply32Accumulate (m_high,(d,(n,(m,a)))) = fun dfn'Signed16x32Multiply32Result (m_high,(d,(n,m))) = let val operand2 = - if m_high then BitsN.bits(R m,31,16) else BitsN.bits(R m,15,0) + if m_high then BitsN.bits(31,16) (R m) else BitsN.bits(15,0) (R m) val result = Int.div (Int.*(BitsN.toInt(R n),BitsN.toInt operand2),IntInf.pow(2,16)) @@ -4595,17 +4598,17 @@ fun dfn'Signed16x32Multiply32Result (m_high,(d,(n,m))) = fun dfn'Signed16Multiply64Accumulate (m_high,(n_high,(dhi,(dlo,(n,m))))) = let val operand1 = - if n_high then BitsN.bits(R n,31,16) else BitsN.bits(R n,15,0) + if n_high then BitsN.bits(31,16) (R n) else BitsN.bits(15,0) (R n) val operand2 = - if m_high then BitsN.bits(R m,31,16) else BitsN.bits(R m,15,0) + if m_high then BitsN.bits(31,16) (R m) else BitsN.bits(15,0) (R m) val result = Int.+ (Int.*(BitsN.toInt operand1,BitsN.toInt operand2), BitsN.toInt(BitsN.@@(R dhi,R dlo))) val result64 = BitsN.fromInt(result,64) in - ( write'R(BitsN.bits(result64,63,32),dhi) - ; write'R(BitsN.bits(result64,31,0),dlo) + ( write'R(BitsN.bits(63,32) result64,dhi) + ; write'R(BitsN.bits(31,0) result64,dlo) ; IncPC () ) end; @@ -4615,12 +4618,12 @@ fun dfn'SignedMultiplyDual (sub,(m_swap,(d,(n,(m,a))))) = val operand2 = if m_swap then ROR 32 (R m,16) else R m val product1 = Int.* - (BitsN.toInt(BitsN.bits(R n,15,0)), - BitsN.toInt(BitsN.bits(operand2,15,0))) + (BitsN.toInt(BitsN.bits(15,0) (R n)), + BitsN.toInt(BitsN.bits(15,0) operand2)) val product2 = Int.* - (BitsN.toInt(BitsN.bits(R n,31,16)), - BitsN.toInt(BitsN.bits(operand2,31,16))) + (BitsN.toInt(BitsN.bits(31,16) (R n)), + BitsN.toInt(BitsN.bits(31,16) operand2)) val acc = if a = (BitsN.B(0xF,4)) then BitsN.B(0x0,32) else R a val result = if sub @@ -4642,12 +4645,12 @@ fun dfn'SignedMultiplyLongDual (sub,(m_swap,(dhi,(dlo,(n,m))))) = val operand2 = if m_swap then ROR 32 (R m,16) else R m val product1 = Int.* - (BitsN.toInt(BitsN.bits(Rn,15,0)), - BitsN.toInt(BitsN.bits(operand2,15,0))) + (BitsN.toInt(BitsN.bits(15,0) Rn), + BitsN.toInt(BitsN.bits(15,0) operand2)) val product2 = Int.* - (BitsN.toInt(BitsN.bits(Rn,31,16)), - BitsN.toInt(BitsN.bits(operand2,31,16))) + (BitsN.toInt(BitsN.bits(31,16) Rn), + BitsN.toInt(BitsN.bits(31,16) operand2)) val acc = BitsN.@@(R dhi,R dlo) val result = if sub @@ -4655,8 +4658,8 @@ fun dfn'SignedMultiplyLongDual (sub,(m_swap,(dhi,(dlo,(n,m))))) = else Int.+(Int.+(product1,product2),BitsN.toInt acc) val result64 = BitsN.fromInt(result,64) in - ( write'R(BitsN.bits(result64,63,32),dhi) - ; write'R(BitsN.bits(result64,31,0),dlo) + ( write'R(BitsN.bits(63,32) result64,dhi) + ; write'R(BitsN.bits(31,0) result64,dlo) ; IncPC () ) end; @@ -4670,7 +4673,7 @@ fun dfn'SignedMostSignificantMultiply (round,(d,(n,(m,a)))) = Int.*(BitsN.toInt(R n),BitsN.toInt(R m))) val result = if round then Int.+(result,2147483648) else result in - ( write'R(BitsN.bits(BitsN.fromInt(result,64),63,32),d); IncPC () ) + ( write'R(BitsN.bits(63,32) (BitsN.fromInt(result,64)),d); IncPC () ) end; fun dfn'SignedMostSignificantMultiplySubtract (round,(d,(n,(m,a)))) = @@ -4681,7 +4684,7 @@ fun dfn'SignedMostSignificantMultiplySubtract (round,(d,(n,(m,a)))) = Int.*(BitsN.toInt(R n),BitsN.toInt(R m))) val result = if round then Int.+(result,2147483648) else result in - ( write'R(BitsN.bits(BitsN.fromInt(result,64),63,32),d); IncPC () ) + ( write'R(BitsN.bits(63,32) (BitsN.fromInt(result,64)),d); IncPC () ) end; fun SignedParallelAddSub16 (op',(n,m)) = @@ -4692,32 +4695,32 @@ fun SignedParallelAddSub16 (op',(n,m)) = case op' of BitsN.B(0x0,2) => (Int.+ - (BitsN.toInt(BitsN.bits(Rn,15,0)), - BitsN.toInt(BitsN.bits(Rm,15,0))), + (BitsN.toInt(BitsN.bits(15,0) Rn), + BitsN.toInt(BitsN.bits(15,0) Rm)), Int.+ - (BitsN.toInt(BitsN.bits(Rn,31,16)), - BitsN.toInt(BitsN.bits(Rm,31,16)))) + (BitsN.toInt(BitsN.bits(31,16) Rn), + BitsN.toInt(BitsN.bits(31,16) Rm))) | BitsN.B(0x1,2) => (Int.- - (BitsN.toInt(BitsN.bits(Rn,15,0)), - BitsN.toInt(BitsN.bits(Rm,31,16))), + (BitsN.toInt(BitsN.bits(15,0) Rn), + BitsN.toInt(BitsN.bits(31,16) Rm)), Int.+ - (BitsN.toInt(BitsN.bits(Rn,31,16)), - BitsN.toInt(BitsN.bits(Rm,15,0)))) + (BitsN.toInt(BitsN.bits(31,16) Rn), + BitsN.toInt(BitsN.bits(15,0) Rm))) | BitsN.B(0x2,2) => (Int.+ - (BitsN.toInt(BitsN.bits(Rn,15,0)), - BitsN.toInt(BitsN.bits(Rm,31,16))), + (BitsN.toInt(BitsN.bits(15,0) Rn), + BitsN.toInt(BitsN.bits(31,16) Rm)), Int.- - (BitsN.toInt(BitsN.bits(Rn,31,16)), - BitsN.toInt(BitsN.bits(Rm,15,0)))) + (BitsN.toInt(BitsN.bits(31,16) Rn), + BitsN.toInt(BitsN.bits(15,0) Rm))) | BitsN.B(0x3,2) => (Int.- - (BitsN.toInt(BitsN.bits(Rn,15,0)), - BitsN.toInt(BitsN.bits(Rm,15,0))), + (BitsN.toInt(BitsN.bits(15,0) Rn), + BitsN.toInt(BitsN.bits(15,0) Rm)), Int.- - (BitsN.toInt(BitsN.bits(Rn,31,16)), - BitsN.toInt(BitsN.bits(Rm,31,16)))) + (BitsN.toInt(BitsN.bits(31,16) Rn), + BitsN.toInt(BitsN.bits(31,16) Rm))) | _ => raise General.Bind end; @@ -4732,10 +4735,8 @@ fun dfn'SignedAddSub16 (op',(d,(n,m))) = CPSR := (PSR_GE_rupd ((!CPSR), - BitsN.bitFieldInsert - (w, - if Int.>=(res1,0) then BitsN.B(0x3,2) else BitsN.B(0x0,2), - 1,0))) + BitsN.bitFieldInsert(1,0) + (w,if Int.>=(res1,0) then BitsN.B(0x3,2) else BitsN.B(0x0,2)))) end ; let val w = (#GE) (!CPSR) @@ -4743,10 +4744,8 @@ fun dfn'SignedAddSub16 (op',(d,(n,m))) = CPSR := (PSR_GE_rupd ((!CPSR), - BitsN.bitFieldInsert - (w, - if Int.>=(res2,0) then BitsN.B(0x3,2) else BitsN.B(0x0,2), - 3,2))) + BitsN.bitFieldInsert(3,2) + (w,if Int.>=(res2,0) then BitsN.B(0x3,2) else BitsN.B(0x0,2)))) end ; IncPC () ) @@ -4780,29 +4779,29 @@ fun SignedParallelAddSub8 (sub,(n,m)) = in if sub then (Int.- - (BitsN.toInt(BitsN.bits(Rn,7,0)), - BitsN.toInt(BitsN.bits(Rm,7,0))), + (BitsN.toInt(BitsN.bits(7,0) Rn), + BitsN.toInt(BitsN.bits(7,0) Rm)), (Int.- - (BitsN.toInt(BitsN.bits(Rn,15,8)), - BitsN.toInt(BitsN.bits(Rm,15,8))), + (BitsN.toInt(BitsN.bits(15,8) Rn), + BitsN.toInt(BitsN.bits(15,8) Rm)), (Int.- - (BitsN.toInt(BitsN.bits(Rn,23,16)), - BitsN.toInt(BitsN.bits(Rm,23,16))), + (BitsN.toInt(BitsN.bits(23,16) Rn), + BitsN.toInt(BitsN.bits(23,16) Rm)), Int.- - (BitsN.toInt(BitsN.bits(Rn,31,24)), - BitsN.toInt(BitsN.bits(Rm,31,24)))))) + (BitsN.toInt(BitsN.bits(31,24) Rn), + BitsN.toInt(BitsN.bits(31,24) Rm))))) else (Int.+ - (BitsN.toInt(BitsN.bits(Rn,7,0)), - BitsN.toInt(BitsN.bits(Rm,7,0))), + (BitsN.toInt(BitsN.bits(7,0) Rn), + BitsN.toInt(BitsN.bits(7,0) Rm)), (Int.+ - (BitsN.toInt(BitsN.bits(Rn,15,8)), - BitsN.toInt(BitsN.bits(Rm,15,8))), + (BitsN.toInt(BitsN.bits(15,8) Rn), + BitsN.toInt(BitsN.bits(15,8) Rm)), (Int.+ - (BitsN.toInt(BitsN.bits(Rn,23,16)), - BitsN.toInt(BitsN.bits(Rm,23,16))), + (BitsN.toInt(BitsN.bits(23,16) Rn), + BitsN.toInt(BitsN.bits(23,16) Rm)), Int.+ - (BitsN.toInt(BitsN.bits(Rn,31,24)), - BitsN.toInt(BitsN.bits(Rm,31,24)))))) + (BitsN.toInt(BitsN.bits(31,24) Rn), + BitsN.toInt(BitsN.bits(31,24) Rm))))) end; fun dfn'SignedAddSub8 (sub,(d,(n,m))) = @@ -4819,7 +4818,7 @@ fun dfn'SignedAddSub8 (sub,(d,(n,m))) = CPSR := (PSR_GE_rupd ((!CPSR), - BitsN.bitFieldInsert(w,BitsN.fromBit(Int.>=(res1,0)),0,0))) + BitsN.bitFieldInsert(0,0) (w,BitsN.fromBit(Int.>=(res1,0))))) end ; let val w = (#GE) (!CPSR) @@ -4827,7 +4826,7 @@ fun dfn'SignedAddSub8 (sub,(d,(n,m))) = CPSR := (PSR_GE_rupd ((!CPSR), - BitsN.bitFieldInsert(w,BitsN.fromBit(Int.>=(res2,0)),1,1))) + BitsN.bitFieldInsert(1,1) (w,BitsN.fromBit(Int.>=(res2,0))))) end ; let val w = (#GE) (!CPSR) @@ -4835,7 +4834,7 @@ fun dfn'SignedAddSub8 (sub,(d,(n,m))) = CPSR := (PSR_GE_rupd ((!CPSR), - BitsN.bitFieldInsert(w,BitsN.fromBit(Int.>=(res3,0)),2,2))) + BitsN.bitFieldInsert(2,2) (w,BitsN.fromBit(Int.>=(res3,0))))) end ; let val w = (#GE) (!CPSR) @@ -4843,7 +4842,7 @@ fun dfn'SignedAddSub8 (sub,(d,(n,m))) = CPSR := (PSR_GE_rupd ((!CPSR), - BitsN.bitFieldInsert(w,BitsN.fromBit(Int.>=(res4,0)),3,3))) + BitsN.bitFieldInsert(3,3) (w,BitsN.fromBit(Int.>=(res4,0))))) end ; IncPC () ) @@ -4883,26 +4882,26 @@ fun UnsignedParallelAddSub16 (op',(n,m)) = case op' of BitsN.B(0x0,2) => (Int.+ - (UInt 16 (BitsN.bits(Rn,15,0)),UInt 16 (BitsN.bits(Rm,15,0))), + (UInt 16 (BitsN.bits(15,0) Rn),UInt 16 (BitsN.bits(15,0) Rm)), Int.+ - (UInt 16 (BitsN.bits(Rn,31,16)), - UInt 16 (BitsN.bits(Rm,31,16)))) + (UInt 16 (BitsN.bits(31,16) Rn), + UInt 16 (BitsN.bits(31,16) Rm))) | BitsN.B(0x1,2) => (Int.- - (UInt 16 (BitsN.bits(Rn,15,0)),UInt 16 (BitsN.bits(Rm,31,16))), + (UInt 16 (BitsN.bits(15,0) Rn),UInt 16 (BitsN.bits(31,16) Rm)), Int.+ - (UInt 16 (BitsN.bits(Rn,31,16)),UInt 16 (BitsN.bits(Rm,15,0)))) + (UInt 16 (BitsN.bits(31,16) Rn),UInt 16 (BitsN.bits(15,0) Rm))) | BitsN.B(0x2,2) => (Int.+ - (UInt 16 (BitsN.bits(Rn,15,0)),UInt 16 (BitsN.bits(Rm,31,16))), + (UInt 16 (BitsN.bits(15,0) Rn),UInt 16 (BitsN.bits(31,16) Rm)), Int.- - (UInt 16 (BitsN.bits(Rn,31,16)),UInt 16 (BitsN.bits(Rm,15,0)))) + (UInt 16 (BitsN.bits(31,16) Rn),UInt 16 (BitsN.bits(15,0) Rm))) | BitsN.B(0x3,2) => (Int.- - (UInt 16 (BitsN.bits(Rn,15,0)),UInt 16 (BitsN.bits(Rm,15,0))), + (UInt 16 (BitsN.bits(15,0) Rn),UInt 16 (BitsN.bits(15,0) Rm)), Int.- - (UInt 16 (BitsN.bits(Rn,31,16)), - UInt 16 (BitsN.bits(Rm,31,16)))) + (UInt 16 (BitsN.bits(31,16) Rn), + UInt 16 (BitsN.bits(31,16) Rm))) | _ => raise General.Bind end; @@ -4917,15 +4916,15 @@ fun dfn'UnsignedAddSub16 (op',(d,(n,m))) = CPSR := (PSR_GE_rupd ((!CPSR), - BitsN.bitFieldInsert + BitsN.bitFieldInsert(1,0) (w, - if Int.>= - (res1, - if Set.mem(op',[BitsN.B(0x1,2),BitsN.B(0x3,2)]) - then 0 - else 65536) - then BitsN.B(0x3,2) - else BitsN.B(0x0,2),1,0))) + if Int.>= + (res1, + if Set.mem(op',[BitsN.B(0x1,2),BitsN.B(0x3,2)]) + then 0 + else 65536) + then BitsN.B(0x3,2) + else BitsN.B(0x0,2)))) end ; let val w = (#GE) (!CPSR) @@ -4933,15 +4932,15 @@ fun dfn'UnsignedAddSub16 (op',(d,(n,m))) = CPSR := (PSR_GE_rupd ((!CPSR), - BitsN.bitFieldInsert + BitsN.bitFieldInsert(3,2) (w, - if Int.>= - (res2, - if Set.mem(op',[BitsN.B(0x2,2),BitsN.B(0x3,2)]) - then 0 - else 65536) - then BitsN.B(0x3,2) - else BitsN.B(0x0,2),3,2))) + if Int.>= + (res2, + if Set.mem(op',[BitsN.B(0x2,2),BitsN.B(0x3,2)]) + then 0 + else 65536) + then BitsN.B(0x3,2) + else BitsN.B(0x0,2)))) end ; IncPC () ) @@ -4975,22 +4974,22 @@ fun UnsignedParallelAddSub8 (sub,(n,m)) = val Rm = R m in if sub - then (Int.-(UInt 8 (BitsN.bits(Rn,7,0)),UInt 8 (BitsN.bits(Rm,7,0))), + then (Int.-(UInt 8 (BitsN.bits(7,0) Rn),UInt 8 (BitsN.bits(7,0) Rm)), (Int.- - (UInt 8 (BitsN.bits(Rn,15,8)),UInt 8 (BitsN.bits(Rm,15,8))), + (UInt 8 (BitsN.bits(15,8) Rn),UInt 8 (BitsN.bits(15,8) Rm)), (Int.- - (UInt 8 (BitsN.bits(Rn,23,16)), - UInt 8 (BitsN.bits(Rm,23,16))), + (UInt 8 (BitsN.bits(23,16) Rn), + UInt 8 (BitsN.bits(23,16) Rm)), Int.- - (UInt 8 (BitsN.bits(Rn,31,24)), - UInt 8 (BitsN.bits(Rm,31,24)))))) - else (Int.+(UInt 8 (BitsN.bits(Rn,7,0)),UInt 8 (BitsN.bits(Rm,7,0))), + (UInt 8 (BitsN.bits(31,24) Rn), + UInt 8 (BitsN.bits(31,24) Rm))))) + else (Int.+(UInt 8 (BitsN.bits(7,0) Rn),UInt 8 (BitsN.bits(7,0) Rm)), (Int.+ - (UInt 8 (BitsN.bits(Rn,15,8)),UInt 8 (BitsN.bits(Rm,15,8))), + (UInt 8 (BitsN.bits(15,8) Rn),UInt 8 (BitsN.bits(15,8) Rm)), (Int.+ - (UInt 8 (BitsN.bits(Rn,23,16)),UInt 8 (BitsN.bits(Rm,23,16))), + (UInt 8 (BitsN.bits(23,16) Rn),UInt 8 (BitsN.bits(23,16) Rm)), Int.+ - (UInt 8 (BitsN.bits(Rn,31,24)),UInt 8 (BitsN.bits(Rm,31,24)))))) + (UInt 8 (BitsN.bits(31,24) Rn),UInt 8 (BitsN.bits(31,24) Rm))))) end; fun dfn'UnsignedAddSub8 (sub,(d,(n,m))) = @@ -5010,8 +5009,8 @@ fun dfn'UnsignedAddSub8 (sub,(d,(n,m))) = CPSR := (PSR_GE_rupd ((!CPSR), - BitsN.bitFieldInsert - (w,BitsN.fromBit(Int.>=(res1,ge_lim)),0,0))) + BitsN.bitFieldInsert(0,0) + (w,BitsN.fromBit(Int.>=(res1,ge_lim))))) end ; let val w = (#GE) (!CPSR) @@ -5019,8 +5018,8 @@ fun dfn'UnsignedAddSub8 (sub,(d,(n,m))) = CPSR := (PSR_GE_rupd ((!CPSR), - BitsN.bitFieldInsert - (w,BitsN.fromBit(Int.>=(res2,ge_lim)),1,1))) + BitsN.bitFieldInsert(1,1) + (w,BitsN.fromBit(Int.>=(res2,ge_lim))))) end ; let val w = (#GE) (!CPSR) @@ -5028,8 +5027,8 @@ fun dfn'UnsignedAddSub8 (sub,(d,(n,m))) = CPSR := (PSR_GE_rupd ((!CPSR), - BitsN.bitFieldInsert - (w,BitsN.fromBit(Int.>=(res3,ge_lim)),2,2))) + BitsN.bitFieldInsert(2,2) + (w,BitsN.fromBit(Int.>=(res3,ge_lim))))) end ; let val w = (#GE) (!CPSR) @@ -5037,8 +5036,8 @@ fun dfn'UnsignedAddSub8 (sub,(d,(n,m))) = CPSR := (PSR_GE_rupd ((!CPSR), - BitsN.bitFieldInsert - (w,BitsN.fromBit(Int.>=(res4,ge_lim)),3,3))) + BitsN.bitFieldInsert(3,3) + (w,BitsN.fromBit(Int.>=(res4,ge_lim))))) end ; IncPC () ) @@ -5079,18 +5078,18 @@ fun dfn'UnsignedSumAbsoluteDifferences (d,(n,(m,a))) = val Rm = R m val absdiff1 = Int.abs - (Int.-(UInt 8 (BitsN.bits(Rn,7,0)),UInt 8 (BitsN.bits(Rm,7,0)))) + (Int.-(UInt 8 (BitsN.bits(7,0) Rn),UInt 8 (BitsN.bits(7,0) Rm))) val absdiff2 = Int.abs - (Int.-(UInt 8 (BitsN.bits(Rn,15,8)),UInt 8 (BitsN.bits(Rm,15,8)))) + (Int.-(UInt 8 (BitsN.bits(15,8) Rn),UInt 8 (BitsN.bits(15,8) Rm))) val absdiff3 = Int.abs (Int.- - (UInt 8 (BitsN.bits(Rn,23,16)),UInt 8 (BitsN.bits(Rm,23,16)))) + (UInt 8 (BitsN.bits(23,16) Rn),UInt 8 (BitsN.bits(23,16) Rm))) val absdiff4 = Int.abs (Int.- - (UInt 8 (BitsN.bits(Rn,31,24)),UInt 8 (BitsN.bits(Rm,31,24)))) + (UInt 8 (BitsN.bits(31,24) Rn),UInt 8 (BitsN.bits(31,24) Rm))) val result = Int.+ (Int.+(Int.+(Int.+(UInt 32 acc,absdiff1),absdiff2),absdiff3), @@ -5115,9 +5114,11 @@ fun dfn'PackHalfword (shift_t,(shift_n,(tbform,(d,(n,m))))) = let val operand2 = Shift 32 (R m,(shift_t,(shift_n,(#C) (!CPSR)))) val bot = - if tbform then BitsN.bits(operand2,15,0) else BitsN.bits(R n,15,0) + if tbform then BitsN.bits(15,0) operand2 else BitsN.bits(15,0) (R n) val top = - if tbform then BitsN.bits(R n,31,16) else BitsN.bits(operand2,31,16) + if tbform + then BitsN.bits(31,16) (R n) + else BitsN.bits(31,16) operand2 in ( write'R(BitsN.@@(top,bot),d); IncPC () ) end; @@ -5145,11 +5146,11 @@ fun dfn'Saturate16 (saturate_to,(unsigned,(d,n))) = val ((result1,sat1),(result2,sat2)) = if unsigned then (UnsignedSatQ 16 - (BitsN.toInt(BitsN.bits(Rn,15,0)),saturate_to), + (BitsN.toInt(BitsN.bits(15,0) Rn),saturate_to), UnsignedSatQ 16 - (BitsN.toInt(BitsN.bits(Rn,31,16)),saturate_to)) - else (SignedSatQ 16 (BitsN.toInt(BitsN.bits(Rn,15,0)),saturate_to), - SignedSatQ 16 (BitsN.toInt(BitsN.bits(Rn,31,16)),saturate_to)) + (BitsN.toInt(BitsN.bits(31,16) Rn),saturate_to)) + else (SignedSatQ 16 (BitsN.toInt(BitsN.bits(15,0) Rn),saturate_to), + SignedSatQ 16 (BitsN.toInt(BitsN.bits(31,16) Rn),saturate_to)) in ( write'R (if unsigned @@ -5168,7 +5169,7 @@ fun dfn'ExtendByte (unsigned,(d,(n,(m,rotation)))) = val rotated = ROR 32 (R m,rotation) in ( write'R - (BitsN.+(acc,Extend (8,32) (unsigned,BitsN.bits(rotated,7,0))),d) + (BitsN.+(acc,Extend (8,32) (unsigned,BitsN.bits(7,0) rotated)),d) ; IncPC () ) end; @@ -5179,12 +5180,12 @@ fun dfn'ExtendByte16 (unsigned,(d,(n,(m,rotation)))) = val rotated = ROR 32 (R m,rotation) val r1 = BitsN.+ - (BitsN.bits(acc,15,0), - Extend (8,16) (unsigned,BitsN.bits(rotated,7,0))) + (BitsN.bits(15,0) acc, + Extend (8,16) (unsigned,BitsN.bits(7,0) rotated)) val r2 = BitsN.+ - (BitsN.bits(acc,31,16), - Extend (8,16) (unsigned,BitsN.bits(rotated,23,16))) + (BitsN.bits(31,16) acc, + Extend (8,16) (unsigned,BitsN.bits(23,16) rotated)) in ( write'R(BitsN.@@(r2,r1),d); IncPC () ) end; @@ -5195,7 +5196,7 @@ fun dfn'ExtendHalfword (unsigned,(d,(n,(m,rotation)))) = val rotated = ROR 32 (R m,rotation) in ( write'R - (BitsN.+(acc,Extend (16,32) (unsigned,BitsN.bits(rotated,15,0))),d) + (BitsN.+(acc,Extend (16,32) (unsigned,BitsN.bits(15,0) rotated)),d) ; IncPC () ) end; @@ -5206,20 +5207,20 @@ fun dfn'SelectBytes (d,(n,m)) = val Rm = R m val r1 = if BitsN.bit((#GE) (!CPSR),0) - then BitsN.bits(Rn,7,0) - else BitsN.bits(Rm,7,0) + then BitsN.bits(7,0) Rn + else BitsN.bits(7,0) Rm val r2 = if BitsN.bit((#GE) (!CPSR),1) - then BitsN.bits(Rn,15,8) - else BitsN.bits(Rm,15,8) + then BitsN.bits(15,8) Rn + else BitsN.bits(15,8) Rm val r3 = if BitsN.bit((#GE) (!CPSR),2) - then BitsN.bits(Rn,23,16) - else BitsN.bits(Rm,23,16) + then BitsN.bits(23,16) Rn + else BitsN.bits(23,16) Rm val r4 = if BitsN.bit((#GE) (!CPSR),3) - then BitsN.bits(Rn,31,24) - else BitsN.bits(Rm,31,24) + then BitsN.bits(31,24) Rn + else BitsN.bits(31,24) Rm in ( write'R(BitsN.concat[r4,r3,r2,r1],d); IncPC () ) end; @@ -5230,8 +5231,8 @@ fun dfn'ByteReverse (d,m) = in ( write'R (BitsN.concat - [BitsN.bits(Rm,7,0),BitsN.bits(Rm,15,8),BitsN.bits(Rm,23,16), - BitsN.bits(Rm,31,24)],d) + [BitsN.bits(7,0) Rm,BitsN.bits(15,8) Rm,BitsN.bits(23,16) Rm, + BitsN.bits(31,24) Rm],d) ; IncPC () ) end; @@ -5242,8 +5243,8 @@ fun dfn'ByteReversePackedHalfword (d,m) = in ( write'R (BitsN.concat - [BitsN.bits(Rm,23,16),BitsN.bits(Rm,31,24),BitsN.bits(Rm,7,0), - BitsN.bits(Rm,15,8)],d) + [BitsN.bits(23,16) Rm,BitsN.bits(31,24) Rm,BitsN.bits(7,0) Rm, + BitsN.bits(15,8) Rm],d) ; IncPC () ) end; @@ -5254,7 +5255,7 @@ fun dfn'ByteReverseSignedHalfword (d,m) = in ( write'R (BitsN.@@ - (BitsN.signExtend 24 (BitsN.bits(Rm,7,0)),BitsN.bits(Rm,15,8)), + (BitsN.signExtend 24 (BitsN.bits(7,0) Rm),BitsN.bits(15,8) Rm), d) ; IncPC () ) @@ -5268,9 +5269,9 @@ fun dfn'BitFieldExtract (unsigned,(d,(n,(lsbit,widthminus1)))) = in ( write'R (if unsigned - then BitsN.bits(R n,msbit,lsbit) - else SignExtendFrom 32 (BitsN.bits(R n,msbit,lsbit),widthminus1), - d) + then BitsN.bits(msbit,lsbit) (R n) + else SignExtendFrom 32 + (BitsN.bits(msbit,lsbit) (R n),widthminus1),d) ; IncPC () ) end; @@ -5285,9 +5286,8 @@ fun dfn'BitFieldClearOrInsert (d,(n,(lsbit,msbit))) = val result = ref (BitsN.toBitstring(R d)) in ( result := - (Bitstring.bitFieldInsert - ((!result),Bitstring.bits(field,Nat.-(msbit,lsbit),0),msbit, - lsbit)) + (Bitstring.bitFieldInsert(msbit,lsbit) + ((!result),Bitstring.bits(Nat.-(msbit,lsbit),0) field)) ; write'R(BitsN.fromBitstring((!result),32),d) ; IncPC () ) @@ -5321,7 +5321,7 @@ fun dfn'LoadWord (add,(index,(wback,(t,(n,m))))) = then ROR 32 (data, Nat.* - (8,BitsN.toNat(BitsN.bits(address,1,0)))) + (8,BitsN.toNat(BitsN.bits(1,0) address))) else BitsN.B(0x0,32),t) ; IncPC () ) @@ -5349,7 +5349,7 @@ fun dfn'LoadLiteral (add,(t,imm32)) = then ROR 32 (data, Nat.* - (8,BitsN.toNat(BitsN.bits(address,1,0)))) + (8,BitsN.toNat(BitsN.bits(1,0) address))) else BitsN.B(0x0,32),t) ; IncPC () ) @@ -5377,7 +5377,7 @@ fun dfn'LoadUnprivileged (add,(postindex,(t,(n,m)))) = else if (!Encoding) = Encoding_ARM then ROR 32 (data, - Nat.*(8,BitsN.toNat(BitsN.bits(address,1,0)))) + Nat.*(8,BitsN.toNat(BitsN.bits(1,0) address))) else BitsN.B(0x0,32),t) ; IncPC () ) @@ -5732,12 +5732,12 @@ fun dfn'LoadExclusiveDoubleword (t,(t2,n)) = in ( write'R (if BigEndian () - then BitsN.bits(value,63,32) - else BitsN.bits(value,31,0),t) + then BitsN.bits(63,32) value + else BitsN.bits(31,0) value,t) ; write'R (if BigEndian () - then BitsN.bits(value,31,0) - else BitsN.bits(value,63,32),t2) + then BitsN.bits(31,0) value + else BitsN.bits(63,32) value,t2) ; IncPC () ) end @@ -5823,7 +5823,7 @@ fun dfn'StoreByte (add,(index,(wback,(t,(n,m))))) = ( let val x = (address,1) in - write'MemU 8 (BitsN.bits(R t,7,0),x) + write'MemU 8 (BitsN.bits(7,0) (R t),x) end ; if wback then write'R(offset_addr,n) else () ; IncPC () @@ -5847,7 +5847,7 @@ fun dfn'StoreByteUnprivileged (add,(postindex,(t,(n,m)))) = ( let val x = (address,1) in - write'MemU_unpriv 8 (BitsN.bits(R t,7,0),x) + write'MemU_unpriv 8 (BitsN.bits(7,0) (R t),x) end ; if postindex then write'R(offset_addr,n) else () ; IncPC () @@ -5872,7 +5872,7 @@ fun dfn'StoreHalf (add,(index,(wback,(t,(n,m))))) = then let val x = (address,2) in - write'MemU 16 (BitsN.bits(R t,15,0),x) + write'MemU 16 (BitsN.bits(15,0) (R t),x) end else let val x = (address,2) @@ -5901,7 +5901,7 @@ fun dfn'StoreHalfUnprivileged (add,(postindex,(t,(n,m)))) = then let val x = (address,2) in - write'MemU_unpriv 16 (BitsN.bits(R t,15,0),x) + write'MemU_unpriv 16 (BitsN.bits(15,0) (R t),x) end else let val x = (address,2) @@ -6061,7 +6061,7 @@ fun dfn'StoreExclusiveByte (d,(t,n)) = then ( let val x = (address,1) in - write'MemA 8 (BitsN.bits(R t,7,0),x) + write'MemA 8 (BitsN.bits(7,0) (R t),x) end ; write'R(BitsN.B(0x0,32),d) ) @@ -6080,7 +6080,7 @@ fun dfn'StoreExclusiveHalf (d,(t,n)) = then ( let val x = (address,2) in - write'MemA 16 (BitsN.bits(R t,15,0),x) + write'MemA 16 (BitsN.bits(15,0) (R t),x) end ; write'R(BitsN.B(0x0,32),d) ) @@ -6127,7 +6127,7 @@ fun dfn'Swap (b,(t,(t2,n))) = ( let val x = (Rn,1) in - write'MemA 8 (BitsN.bits(R t2,7,0),x) + write'MemA 8 (BitsN.bits(7,0) (R t2),x) end ; write'R(BitsN.zeroExtend 32 data,t) ) @@ -6137,7 +6137,7 @@ fun dfn'Swap (b,(t,(t2,n))) = in ( let val x = (Rn,4) in write'MemA 32 (R t2,x) end ; write'R - (ROR 32 (data,Nat.*(8,BitsN.toNat(BitsN.bits(Rn,1,0)))),t) + (ROR 32 (data,Nat.*(8,BitsN.toNat(BitsN.bits(1,0) Rn))),t) ) end ; IncPC () @@ -6244,27 +6244,27 @@ fun dfn'MoveToRegisterFromBankedOrSpecial (read_spsr,(SYSm,d)) = | _ => () ) else ( BankedRegisterAccessValid(SYSm,mode) - ; if (BitsN.bits(SYSm,4,3)) = (BitsN.B(0x0,2)) + ; if (BitsN.bits(4,3) SYSm) = (BitsN.B(0x0,2)) then let val m = BitsN.+ (BitsN.fromNat - (BitsN.toNat(BitsN.bits(SYSm,2,0)),4), + (BitsN.toNat(BitsN.bits(2,0) SYSm),4), BitsN.B(0x8,4)) in write'R(Rmode(m,BitsN.B(0x10,5)),d) end - else if (BitsN.bits(SYSm,4,3)) = (BitsN.B(0x1,2)) + else if (BitsN.bits(4,3) SYSm) = (BitsN.B(0x1,2)) then let val m = BitsN.+ (BitsN.fromNat - (BitsN.toNat(BitsN.bits(SYSm,2,0)),4), + (BitsN.toNat(BitsN.bits(2,0) SYSm),4), BitsN.B(0x8,4)) in write'R(Rmode(m,BitsN.B(0x11,5)),d) end - else if (BitsN.bits(SYSm,4,3)) = (BitsN.B(0x3,2)) + else if (BitsN.bits(4,3) SYSm) = (BitsN.B(0x3,2)) then if not(BitsN.bit(SYSm,1)) then let val m = @@ -6283,29 +6283,29 @@ fun dfn'MoveToRegisterFromBankedOrSpecial (read_spsr,(SYSm,d)) = val targetmode = ref (BitsN.B(0x0,5)) in ( targetmode := - (BitsN.bitFieldInsert + (BitsN.bitFieldInsert(0,0) ((!targetmode), - BitsN.fromBit - ((BitsN.bit(SYSm,2)) orelse - (BitsN.bit(SYSm,1))),0,0)) + BitsN.fromBit + ((BitsN.bit(SYSm,2)) orelse + (BitsN.bit(SYSm,1))))) ; targetmode := - (BitsN.bitFieldInsert - ((!targetmode),BitsN.fromBit true,1,1)) + (BitsN.bitFieldInsert(1,1) + ((!targetmode),BitsN.fromBit true)) ; targetmode := - (BitsN.bitFieldInsert + (BitsN.bitFieldInsert(2,2) ((!targetmode), - BitsN.fromBit - ((BitsN.bit(SYSm,2)) andalso - (not(BitsN.bit(SYSm,1)))),2,2)) + BitsN.fromBit + ((BitsN.bit(SYSm,2)) andalso + (not(BitsN.bit(SYSm,1)))))) ; targetmode := - (BitsN.bitFieldInsert + (BitsN.bitFieldInsert(3,3) ((!targetmode), - BitsN.fromBit - ((BitsN.bit(SYSm,2)) andalso - (BitsN.bit(SYSm,1))),3,3)) + BitsN.fromBit + ((BitsN.bit(SYSm,2)) andalso + (BitsN.bit(SYSm,1))))) ; targetmode := - (BitsN.bitFieldInsert - ((!targetmode),BitsN.fromBit true,4,4)) + (BitsN.bitFieldInsert(4,4) + ((!targetmode),BitsN.fromBit true)) ; if mode = (!targetmode) then raise UNPREDICTABLE ("MoveToRegisterFromBankedOrSpecial") @@ -6375,29 +6375,29 @@ fun dfn'MoveToBankedOrSpecialRegister (write_spsr,(SYSm,n)) = | _ => () ) else ( BankedRegisterAccessValid(SYSm,mode) - ; if (BitsN.bits(SYSm,4,3)) = (BitsN.B(0x0,2)) + ; if (BitsN.bits(4,3) SYSm) = (BitsN.B(0x0,2)) then let val m = BitsN.+ (BitsN.fromNat - (BitsN.toNat(BitsN.bits(SYSm,2,0)),4), + (BitsN.toNat(BitsN.bits(2,0) SYSm),4), BitsN.B(0x8,4)) val x = (m,BitsN.B(0x10,5)) in write'Rmode(R n,x) end - else if (BitsN.bits(SYSm,4,3)) = (BitsN.B(0x1,2)) + else if (BitsN.bits(4,3) SYSm) = (BitsN.B(0x1,2)) then let val m = BitsN.+ (BitsN.fromNat - (BitsN.toNat(BitsN.bits(SYSm,2,0)),4), + (BitsN.toNat(BitsN.bits(2,0) SYSm),4), BitsN.B(0x8,4)) val x = (m,BitsN.B(0x11,5)) in write'Rmode(R n,x) end - else if (BitsN.bits(SYSm,4,3)) = (BitsN.B(0x3,2)) + else if (BitsN.bits(4,3) SYSm) = (BitsN.B(0x3,2)) then if not(BitsN.bit(SYSm,1)) then let val m = @@ -6420,29 +6420,29 @@ fun dfn'MoveToBankedOrSpecialRegister (write_spsr,(SYSm,n)) = val targetmode = ref (BitsN.B(0x0,5)) in ( targetmode := - (BitsN.bitFieldInsert + (BitsN.bitFieldInsert(0,0) ((!targetmode), - BitsN.fromBit - ((BitsN.bit(SYSm,2)) orelse - (BitsN.bit(SYSm,1))),0,0)) + BitsN.fromBit + ((BitsN.bit(SYSm,2)) orelse + (BitsN.bit(SYSm,1))))) ; targetmode := - (BitsN.bitFieldInsert - ((!targetmode),BitsN.fromBit true,1,1)) + (BitsN.bitFieldInsert(1,1) + ((!targetmode),BitsN.fromBit true)) ; targetmode := - (BitsN.bitFieldInsert + (BitsN.bitFieldInsert(2,2) ((!targetmode), - BitsN.fromBit - ((BitsN.bit(SYSm,2)) andalso - (not(BitsN.bit(SYSm,1)))),2,2)) + BitsN.fromBit + ((BitsN.bit(SYSm,2)) andalso + (not(BitsN.bit(SYSm,1)))))) ; targetmode := - (BitsN.bitFieldInsert + (BitsN.bitFieldInsert(3,3) ((!targetmode), - BitsN.fromBit - ((BitsN.bit(SYSm,2)) andalso - (BitsN.bit(SYSm,1))),3,3)) + BitsN.fromBit + ((BitsN.bit(SYSm,2)) andalso + (BitsN.bit(SYSm,1))))) ; targetmode := - (BitsN.bitFieldInsert - ((!targetmode),BitsN.fromBit true,4,4)) + (BitsN.bitFieldInsert(4,4) + ((!targetmode),BitsN.fromBit true)) ; if mode = (!targetmode) then raise UNPREDICTABLE ("MoveToBankedOrSpecialRegister") @@ -6517,7 +6517,7 @@ fun dfn'SecureMonitorCall imm4 = else TakeSMCException () else TakeUndefInstrException (); -fun dfn'SupervisorCall imm32 = CallSupervisor(BitsN.bits(imm32,15,0)); +fun dfn'SupervisorCall imm32 = CallSupervisor(BitsN.bits(15,0) imm32); fun dfn'StoreReturnState (increment,(wordhigher,(wback,mode))) = if CurrentModeIsHyp () @@ -6601,12 +6601,12 @@ fun rec'FPSCR x = IDC = BitsN.bit(x,7), IDE = BitsN.bit(x,15), IOC = BitsN.bit(x,0), IOE = BitsN.bit(x,8), IXC = BitsN.bit(x,4), IXE = BitsN.bit(x,12), N = BitsN.bit(x,31), OFC = BitsN.bit(x,2), OFE = BitsN.bit(x,10), - QC = BitsN.bit(x,27), RMode = BitsN.bits(x,23,22), + QC = BitsN.bit(x,27), RMode = BitsN.bits(23,22) x, UFC = BitsN.bit(x,3), UFE = BitsN.bit(x,11), V = BitsN.bit(x,28), Z = BitsN.bit(x,30), fpscr'rst = BitsN.concat - [BitsN.bits(x,6,5),BitsN.bits(x,14,13),BitsN.bits(x,21,16)]}; + [BitsN.bits(6,5) x,BitsN.bits(14,13) x,BitsN.bits(21,16) x]}; fun reg'FPSCR x = case x of @@ -6715,8 +6715,8 @@ fun write'D (value,n) = fun S n = if BitsN.bit(n,0) - then BitsN.bits(D(BitsN.div(n,BitsN.B(0x2,5))),63,32) - else BitsN.bits(D(BitsN.div(n,BitsN.B(0x2,5))),31,0); + then BitsN.bits(63,32) (D(BitsN.div(n,BitsN.B(0x2,5)))) + else BitsN.bits(31,0) (D(BitsN.div(n,BitsN.B(0x2,5)))); fun write'S (value,n) = if BitsN.bit(n,0) @@ -6724,27 +6724,27 @@ fun write'S (value,n) = val x = BitsN.div(n,BitsN.B(0x2,5)) val w = D x in - write'D(BitsN.bitFieldInsert(w,value,63,32),x) + write'D(BitsN.bitFieldInsert(63,32) (w,value),x) end else let val x = BitsN.div(n,BitsN.B(0x2,5)) val w = D x in - write'D(BitsN.bitFieldInsert(w,value,31,0),x) + write'D(BitsN.bitFieldInsert(31,0) (w,value),x) end; fun VFPExpandImm (imm8,single) = if single then BitsN.zeroExtend 64 (BitsN.concat - [BitsN.bits(imm8,7,7),BitsN.~(BitsN.bits(imm8,6,6)), - BitsN.resize_replicate 5 (BitsN.bits(imm8,6,6),5), - BitsN.bits(imm8,5,0), + [BitsN.bits(7,7) imm8,BitsN.~(BitsN.bits(6,6) imm8), + BitsN.resize_replicate 5 (BitsN.bits(6,6) imm8,5), + BitsN.bits(5,0) imm8, BitsN.resize_replicate 19 (BitsN.B(0x0,1),19)]) else BitsN.concat - [BitsN.bits(imm8,7,7),BitsN.~(BitsN.bits(imm8,6,6)), - BitsN.resize_replicate 8 (BitsN.bits(imm8,6,6),8), - BitsN.bits(imm8,5,0), + [BitsN.bits(7,7) imm8,BitsN.~(BitsN.bits(6,6) imm8), + BitsN.resize_replicate 8 (BitsN.bits(6,6) imm8,8), + BitsN.bits(5,0) imm8, BitsN.resize_replicate 48 (BitsN.B(0x0,1),48)]; fun FPCompare32 (op1,op2) = @@ -6770,7 +6770,7 @@ fun FPZero64 sign = BitsN.@@(sign,BitsN.B(0x0,63)); fun dfn'vmov_imm (single_register,(d,imm64)) = ( if single_register - then write'S(BitsN.bits(imm64,31,0),d) + then write'S(BitsN.bits(31,0) imm64,d) else write'D(imm64,d) ; IncPC () ); @@ -6792,7 +6792,8 @@ fun dfn'vcmp (dp_operation,(d,m_with_zero)) = (FP_FPSCR_rupd ((!FP), write'reg'FPSCR - (x0,BitsN.bitFieldInsert(w,FPCompare64(D d,op2),31,28)))) + (x0, + BitsN.bitFieldInsert(31,28) (w,FPCompare64(D d,op2))))) end else let val op2 = @@ -6806,7 +6807,7 @@ fun dfn'vcmp (dp_operation,(d,m_with_zero)) = (FP_FPSCR_rupd ((!FP), write'reg'FPSCR - (x0,BitsN.bitFieldInsert(w,FPCompare32(S d,op2),31,28)))) + (x0,BitsN.bitFieldInsert(31,28) (w,FPCompare32(S d,op2))))) end ; IncPC () ); @@ -6928,16 +6929,16 @@ fun dfn'vstr (single_reg,(add,(d,(n,imm32)))) = in write'MemA 32 (if BigEndian () - then BitsN.bits(word,63,32) - else BitsN.bits(word,31,0),x) + then BitsN.bits(63,32) word + else BitsN.bits(31,0) word,x) end ; let val x = (BitsN.+(address,BitsN.B(0x4,32)),4) in write'MemA 32 (if BigEndian () - then BitsN.bits(word,31,0) - else BitsN.bits(word,63,32),x) + then BitsN.bits(31,0) word + else BitsN.bits(63,32) word,x) end ) end @@ -7149,8 +7150,8 @@ fun Fetch () = val fpc = Map.lookup((!REG),Cast.RNameToNat RName_PC) val ireg = MemA 16 (fpc,2) in - if ((BitsN.bits(ireg,15,13)) = (BitsN.B(0x7,3))) andalso - (not((BitsN.bits(ireg,12,11)) = (BitsN.B(0x0,2)))) + if ((BitsN.bits(15,13) ireg) = (BitsN.B(0x7,3))) andalso + (not((BitsN.bits(12,11) ireg) = (BitsN.B(0x0,2)))) then ( Encoding := Encoding_Thumb2 ; Thumb2(ireg,MemA 16 (BitsN.+(fpc,BitsN.B(0x2,32)),2)) ) @@ -7202,7 +7203,7 @@ fun DECODE_UNPREDICTABLE (mc,s) = fun DecodeHint (cond,op') = if ((!Architecture) = ARMv6T2) orelse - ((((BitsN.bits(op',7,4)) = (BitsN.B(0xF,4))) andalso + ((((BitsN.bits(7,4) op') = (BitsN.B(0xF,4))) andalso ((!Encoding) = Encoding_ARM)) andalso ((!Architecture) = ARMv6K)) then NoOperation else if Do(cond, @@ -7282,7 +7283,7 @@ fun DecodeParallelAdditionSubtraction (op1,(op2,(U,(Rd,(Rn,Rm))))) = | _ => Undefined(BitsN.B(0x0,32)); fun DecodeVFP w = - case boolify'28(BitsN.bits(w,27,0)) of + case boolify'28(BitsN.bits(27,0) w) of (true, (true, (false, @@ -7563,10 +7564,10 @@ fun DecodeVFP w = fun DecodeARM w = let val mc = ARM w - val cond = BitsN.bits(w,31,28) + val cond = BitsN.bits(31,28) w in if cond = (BitsN.B(0xF,4)) - then case boolify'28(BitsN.bits(w,27,0)) of + then case boolify'28(BitsN.bits(27,0) w) of (false, (false, (false, @@ -8157,7 +8158,7 @@ fun DecodeARM w = else ( DECODE_UNPREDICTABLE(mc,"") ; Branch(BranchExchange(BitsN.B(0x0,4))) )) - else case boolify'28(BitsN.bits(w,27,0)) of + else case boolify'28(BitsN.bits(27,0) w) of (false, (true, (true, @@ -8965,10 +8966,10 @@ fun DecodeARM w = BitsN.fromBitstring ([imm5'4,imm5'3,imm5'2,imm5'1,imm5'0],5)) in - if (BitsN.bits(opc,3,2)) = (BitsN.B(0x2,2)) + if (BitsN.bits(3,2) opc) = (BitsN.B(0x2,2)) then Data (TestCompareRegister - (BitsN.bits(opc,1,0), + (BitsN.bits(1,0) opc, (Rn,(Rm,(shift_t,shift_n))))) else if Set.mem (opc,[BitsN.B(0xD,4),BitsN.B(0xF,4)]) @@ -9016,7 +9017,7 @@ fun DecodeARM w = in if Do(cond,true) then ( if ((((Rd = (BitsN.B(0xF,4))) andalso - (not((BitsN.bits(opc,3,2)) = + (not((BitsN.bits(3,2) opc) = (BitsN.B(0x2,2))))) orelse (Rn = (BitsN.B(0xF,4)))) orelse (Rm = (BitsN.B(0xF,4)))) orelse @@ -12824,7 +12825,7 @@ fun DecodeThumb h = in Data (TestCompareRegister - (BitsN.bits(opc,1,0), + (BitsN.bits(1,0) opc, (n,(m,(shift_t,shift_n))))) end | BitsN.B(0xA,4) => @@ -12836,7 +12837,7 @@ fun DecodeThumb h = in Data (TestCompareRegister - (BitsN.bits(opc,1,0), + (BitsN.bits(1,0) opc, (n,(m,(shift_t,shift_n))))) end | BitsN.B(0xB,4) => @@ -12848,7 +12849,7 @@ fun DecodeThumb h = in Data (TestCompareRegister - (BitsN.bits(opc,1,0), + (BitsN.bits(1,0) opc, (n,(m,(shift_t,shift_n))))) end | BitsN.B(0x9,4) => @@ -18227,16 +18228,16 @@ fun EncodeThumbImmediate x = (BitsN.+ (BitsN.- (BitsN.B(0x1F,5),BitsN.fromNat(m,5)), - BitsN.B(0x8,5)),BitsN.bits(n,6,0))) + BitsN.B(0x8,5)),BitsN.bits(6,0) n)) else NONE end end end; fun EncodeARMImmediate_aux (n,x) = - if (BitsN.bits(x,31,8)) = (BitsN.B(0x0,24)) + if (BitsN.bits(31,8) x) = (BitsN.B(0x0,24)) then Option.SOME - (BitsN.@@(BitsN.-(BitsN.B(0xF,4),n),BitsN.bits(x,7,0))) + (BitsN.@@(BitsN.-(BitsN.B(0xF,4),n),BitsN.bits(7,0) x)) else if n = (BitsN.B(0x0,4)) then NONE else EncodeARMImmediate_aux(BitsN.-(n,BitsN.B(0x1,4)),BitsN.#<<(x,2)); @@ -18273,29 +18274,29 @@ fun EncodeAddSubOpc opc = fun EncodeVFPImmediate (imm64,single_register) = if single_register - then if ((((BitsN.bits(imm64,18,0)) = (BitsN.B(0x0,19))) andalso + then if ((((BitsN.bits(18,0) imm64) = (BitsN.B(0x0,19))) andalso (Set.mem - (BitsN.bits(imm64,29,25),[BitsN.B(0x0,5),BitsN.B(0x1F,5)]))) andalso + (BitsN.bits(29,25) imm64,[BitsN.B(0x0,5),BitsN.B(0x1F,5)]))) andalso (not((BitsN.bit(imm64,25)) = (BitsN.bit(imm64,30))))) andalso - ((BitsN.bits(imm64,63,32)) = (BitsN.B(0x0,32))) + ((BitsN.bits(63,32) imm64) = (BitsN.B(0x0,32))) then Option.SOME (BitsN.concat - [BitsN.bits(imm64,31,31),BitsN.bits(imm64,25,25), - BitsN.bits(imm64,24,19)]) + [BitsN.bits(31,31) imm64,BitsN.bits(25,25) imm64, + BitsN.bits(24,19) imm64]) else NONE - else if (((BitsN.bits(imm64,47,0)) = (BitsN.B(0x0,48))) andalso - (Set.mem(BitsN.bits(imm64,61,54),[BitsN.B(0x0,8),BitsN.B(0xFF,8)]))) andalso + else if (((BitsN.bits(47,0) imm64) = (BitsN.B(0x0,48))) andalso + (Set.mem(BitsN.bits(61,54) imm64,[BitsN.B(0x0,8),BitsN.B(0xFF,8)]))) andalso (not((BitsN.bit(imm64,61)) = (BitsN.bit(imm64,62)))) then Option.SOME (BitsN.concat - [BitsN.bits(imm64,63,63),BitsN.bits(imm64,54,54), - BitsN.bits(imm64,53,48)]) + [BitsN.bits(63,63) imm64,BitsN.bits(54,54) imm64, + BitsN.bits(53,48) imm64]) else NONE; fun EncodeVFPReg (d,single_register) = if single_register - then (BitsN.bits(d,0,0),BitsN.bits(d,4,1)) - else (BitsN.bits(d,4,4),BitsN.bits(d,3,0)); + then (BitsN.bits(0,0) d,BitsN.bits(4,1) d) + else (BitsN.bits(4,4) d,BitsN.bits(3,0) d); fun e_branch (c,(ast,e)) = case ast of @@ -18305,7 +18306,7 @@ fun e_branch (c,(ast,e)) = (BitsN.<=(imm32,BitsN.B(0x1FFFFFC,32)))) andalso (Aligned 32 (imm32,4)) then let - val imm24 = BitsN.bits(imm32,25,2) + val imm24 = BitsN.bits(25,2) imm32 in ARM(BitsN.concat[c,BitsN.B(0xA,4),imm24]) end @@ -18317,7 +18318,7 @@ fun e_branch (c,(ast,e)) = (BitsN.<=(imm32,BitsN.B(0x7FE,32)))) andalso (not(e = Enc_Wide)) then let - val imm11 = BitsN.bits(imm32,11,1) + val imm11 = BitsN.bits(11,1) imm32 in Thumb(BitsN.@@(BitsN.B(0x1C,5),imm11)) end @@ -18325,13 +18326,13 @@ fun e_branch (c,(ast,e)) = (BitsN.<=(imm32,BitsN.B(0xFFFFFE,32)))) andalso (not(e = Enc_Narrow)) then let - val S = BitsN.bits(imm32,24,24) - val I1 = BitsN.bits(imm32,23,23) - val I2 = BitsN.bits(imm32,22,22) + val S = BitsN.bits(24,24) imm32 + val I1 = BitsN.bits(23,23) imm32 + val I2 = BitsN.bits(22,22) imm32 val J1 = BitsN.fromBit(I1 = S) val J2 = BitsN.fromBit(I2 = S) - val imm10 = BitsN.bits(imm32,21,12) - val imm11 = BitsN.bits(imm32,11,1) + val imm10 = BitsN.bits(21,12) imm32 + val imm11 = BitsN.bits(11,1) imm32 in Thumb2 (BitsN.concat[BitsN.B(0x1E,5),S,imm10], @@ -18342,7 +18343,7 @@ fun e_branch (c,(ast,e)) = else if ((BitsN.<=(BitsN.neg(BitsN.B(0x100,32)),imm32)) andalso (BitsN.<=(imm32,BitsN.B(0xFE,32)))) andalso (not(e = Enc_Wide)) then let - val imm8 = BitsN.bits(imm32,8,1) + val imm8 = BitsN.bits(8,1) imm32 in Thumb(BitsN.concat[BitsN.B(0xD,4),c,imm8]) end @@ -18350,11 +18351,11 @@ fun e_branch (c,(ast,e)) = (BitsN.<=(imm32,BitsN.B(0xFFFFE,32)))) andalso (not(e = Enc_Narrow)) then let - val S = BitsN.bits(imm32,20,20) - val J2 = BitsN.bits(imm32,19,19) - val J1 = BitsN.bits(imm32,18,18) - val imm6 = BitsN.bits(imm32,17,12) - val imm11 = BitsN.bits(imm32,11,1) + val S = BitsN.bits(20,20) imm32 + val J2 = BitsN.bits(19,19) imm32 + val J1 = BitsN.bits(18,18) imm32 + val imm6 = BitsN.bits(17,12) imm32 + val imm11 = BitsN.bits(11,1) imm32 in Thumb2 (BitsN.concat[BitsN.B(0x1E,5),S,c,imm6], @@ -18376,7 +18377,7 @@ fun e_branch (c,(ast,e)) = (BitsN.<=(imm32,BitsN.B(0x1FFFFFC,32)))) andalso (Aligned 32 (imm32,4)) then let - val imm24 = BitsN.bits(imm32,25,2) + val imm24 = BitsN.bits(25,2) imm32 in ARM(BitsN.concat [c,BitsN.B(0xB,4),imm24]) @@ -18387,8 +18388,8 @@ fun e_branch (c,(ast,e)) = (BitsN.<=(imm32,BitsN.B(0x1FFFFFE,32)))) andalso (Aligned 32 (imm32,2)) then let - val imm24 = BitsN.bits(imm32,25,2) - val H = BitsN.bits(imm32,1,1) + val imm24 = BitsN.bits(25,2) imm32 + val H = BitsN.bits(1,1) imm32 in ARM(BitsN.concat[BitsN.B(0x7D,7),H,imm24]) end @@ -18399,13 +18400,13 @@ fun e_branch (c,(ast,e)) = (BitsN.<=(imm32,BitsN.B(0xFFFFFC,32)))) andalso (Aligned 32 (imm32,4))) andalso (not(e = Enc_Narrow)) then let - val S = BitsN.bits(imm32,24,24) - val I1 = BitsN.bits(imm32,23,23) - val I2 = BitsN.bits(imm32,22,22) + val S = BitsN.bits(24,24) imm32 + val I1 = BitsN.bits(23,23) imm32 + val I2 = BitsN.bits(22,22) imm32 val J1 = BitsN.fromBit(I1 = S) val J2 = BitsN.fromBit(I2 = S) - val imm10H = BitsN.bits(imm32,21,12) - val imm10L = BitsN.bits(imm32,11,2) + val imm10H = BitsN.bits(21,12) imm32 + val imm10L = BitsN.bits(11,2) imm32 in Thumb2 (BitsN.concat[BitsN.B(0x1E,5),S,imm10H], @@ -18418,13 +18419,13 @@ fun e_branch (c,(ast,e)) = (BitsN.<=(imm32,BitsN.B(0xFFFFFE,32)))) andalso (Aligned 32 (imm32,2))) andalso (not(e = Enc_Narrow)) then let - val S = BitsN.bits(imm32,24,24) - val I1 = BitsN.bits(imm32,23,23) - val I2 = BitsN.bits(imm32,22,22) + val S = BitsN.bits(24,24) imm32 + val I1 = BitsN.bits(23,23) imm32 + val I2 = BitsN.bits(22,22) imm32 val J1 = BitsN.fromBit(I1 = S) val J2 = BitsN.fromBit(I2 = S) - val imm10 = BitsN.bits(imm32,21,12) - val imm11 = BitsN.bits(imm32,11,1) + val imm10 = BitsN.bits(21,12) imm32 + val imm11 = BitsN.bits(11,1) imm32 in Thumb2 (BitsN.concat[BitsN.B(0x1E,5),S,imm10], @@ -18443,9 +18444,9 @@ fun e_branch (c,(ast,e)) = (Set.mem(e,[Enc_Thumb,Enc_Narrow])) then let val op' = BitsN.fromBit nonzero - val i = BitsN.bits(imm32,6,6) - val imm5 = BitsN.bits(imm32,5,1) - val Rn = BitsN.bits(n,2,0) + val i = BitsN.bits(6,6) imm32 + val imm5 = BitsN.bits(5,1) imm32 + val Rn = BitsN.bits(2,0) n in Thumb (BitsN.concat @@ -18466,19 +18467,19 @@ fun e_branch (c,(ast,e)) = | CheckArray(Rm,n) => (if Set.mem(e,[Enc_Thumb,Enc_Narrow]) then let - val N = BitsN.bits(n,3,3) - val Rn = BitsN.bits(n,2,0) + val N = BitsN.bits(3,3) n + val Rn = BitsN.bits(2,0) n in ThumbEE(BitsN.concat[BitsN.B(0xCA,8),N,Rm,Rn]) end else BadCode("CHKA")) | HandlerBranchLink(generate_link,handler_offset) => (if ((BitsN.<=+(handler_offset,BitsN.B(0x1FE0,32))) andalso - ((BitsN.bits(handler_offset,4,0)) = (BitsN.B(0x0,5)))) andalso + ((BitsN.bits(4,0) handler_offset) = (BitsN.B(0x0,5)))) andalso (Set.mem(e,[Enc_Thumb,Enc_Narrow])) then let val L = BitsN.fromBit generate_link - val handler = BitsN.bits(handler_offset,12,5) + val handler = BitsN.bits(12,5) handler_offset in ThumbEE(BitsN.concat[BitsN.B(0x61,7),L,handler]) end @@ -18486,11 +18487,11 @@ fun e_branch (c,(ast,e)) = | HandlerBranchLinkParameter(imm32,handler_offset) => (if (((BitsN.<+(imm32,BitsN.B(0x20,32))) andalso (BitsN.<=+(handler_offset,BitsN.B(0x3E0,32)))) andalso - ((BitsN.bits(handler_offset,4,0)) = (BitsN.B(0x0,5)))) andalso + ((BitsN.bits(4,0) handler_offset) = (BitsN.B(0x0,5)))) andalso (Set.mem(e,[Enc_Thumb,Enc_Narrow])) then let - val imm5 = BitsN.bits(imm32,4,0) - val handler = BitsN.bits(handler_offset,9,5) + val imm5 = BitsN.bits(4,0) imm32 + val handler = BitsN.bits(9,5) handler_offset in ThumbEE(BitsN.concat[BitsN.B(0x31,6),imm5,handler]) end @@ -18498,11 +18499,11 @@ fun e_branch (c,(ast,e)) = | HandlerBranchParameter(imm32,handler_offset) => (if (((BitsN.<+(imm32,BitsN.B(0x8,32))) andalso (BitsN.<=+(handler_offset,BitsN.B(0x3E0,32)))) andalso - ((BitsN.bits(handler_offset,4,0)) = (BitsN.B(0x0,5)))) andalso + ((BitsN.bits(4,0) handler_offset) = (BitsN.B(0x0,5)))) andalso (Set.mem(e,[Enc_Thumb,Enc_Narrow])) then let - val imm3 = BitsN.bits(imm32,2,0) - val handler = BitsN.bits(handler_offset,9,5) + val imm3 = BitsN.bits(2,0) imm32 + val handler = BitsN.bits(9,5) handler_offset in ThumbEE(BitsN.concat[BitsN.B(0xC0,8),imm3,handler]) end @@ -18650,11 +18651,11 @@ fun e_vfp (c,(ast,e)) = else BadCode("VMLA")) | vldr(single_register,(add,(d,(n,imm32)))) => (if e = Enc_ARM - then if (not((BitsN.bits(imm32,1,0)) = (BitsN.B(0x0,2)))) orelse - (not((BitsN.bits(imm32,31,10)) = (BitsN.B(0x0,22)))) + then if (not((BitsN.bits(1,0) imm32) = (BitsN.B(0x0,2)))) orelse + (not((BitsN.bits(31,10) imm32) = (BitsN.B(0x0,22)))) then BadCode("VLDR: bad immediate") else let - val imm8 = BitsN.bits(imm32,9,2) + val imm8 = BitsN.bits(9,2) imm32 val (D,Vd) = EncodeVFPReg(d,single_register) in ARM(BitsN.concat @@ -18665,11 +18666,11 @@ fun e_vfp (c,(ast,e)) = else BadCode("VLDR")) | vstr(single_register,(add,(d,(n,imm32)))) => (if e = Enc_ARM - then if (not((BitsN.bits(imm32,1,0)) = (BitsN.B(0x0,2)))) orelse - (not((BitsN.bits(imm32,31,10)) = (BitsN.B(0x0,22)))) + then if (not((BitsN.bits(1,0) imm32) = (BitsN.B(0x0,2)))) orelse + (not((BitsN.bits(31,10) imm32) = (BitsN.B(0x0,22)))) then BadCode("VSTR: bad immediate") else let - val imm8 = BitsN.bits(imm32,9,2) + val imm8 = BitsN.bits(9,2) imm32 val (D,Vd) = EncodeVFPReg(d,single_register) in ARM(BitsN.concat @@ -18699,18 +18700,18 @@ fun e_data (c,(ast,e)) = in if e = Enc_ARM then let - val imm4 = BitsN.bits(imm16,15,12) - val imm12 = BitsN.bits(imm16,11,0) + val imm4 = BitsN.bits(15,12) imm16 + val imm12 = BitsN.bits(11,0) imm16 in ARM(BitsN.concat [c,BitsN.B(0x6,5),H,BitsN.B(0x0,2),imm4,Rd,imm12]) end else if not(e = Enc_Narrow) then let - val imm4 = BitsN.bits(imm16,15,12) - val i = BitsN.bits(imm16,11,11) - val imm3 = BitsN.bits(imm16,10,8) - val imm8 = BitsN.bits(imm16,7,0) + val imm4 = BitsN.bits(15,12) imm16 + val i = BitsN.bits(11,11) imm16 + val imm3 = BitsN.bits(10,8) imm16 + val imm8 = BitsN.bits(7,0) imm16 in Thumb2 (BitsN.concat @@ -18730,12 +18731,12 @@ fun e_data (c,(ast,e)) = [c,BitsN.B(0x7,5),N,BitsN.B(0x1,1),S,BitsN.B(0x0,4), Rd,imm12]) end - else if ((BitsN.bits(imm12,11,8)) = (BitsN.B(0x0,4))) andalso + else if ((BitsN.bits(11,8) imm12) = (BitsN.B(0x0,4))) andalso (not(((negate orelse (setflags = (not(c = (BitsN.B(0xE,4)))))) orelse (BitsN.bit(d,3))) orelse (e = Enc_Wide))) then let - val Rd = BitsN.bits(d,2,0) - val imm8 = BitsN.bits(imm12,7,0) + val Rd = BitsN.bits(2,0) d + val imm8 = BitsN.bits(7,0) imm12 in Thumb(BitsN.concat[BitsN.B(0x4,5),Rd,imm8]) end @@ -18743,9 +18744,9 @@ fun e_data (c,(ast,e)) = then let val Rd = d val S = BitsN.fromBit setflags - val i = BitsN.bits(imm12,11,11) - val imm3 = BitsN.bits(imm12,10,8) - val imm8 = BitsN.bits(imm12,7,0) + val i = BitsN.bits(11,11) imm12 + val imm3 = BitsN.bits(10,8) imm12 + val imm8 = BitsN.bits(7,0) imm12 val N = BitsN.fromBit negate in Thumb2 @@ -18757,9 +18758,9 @@ fun e_data (c,(ast,e)) = | AddSub(sub,(Rd,(Rn,imm12))) => (if Set.mem(e,[Enc_Thumb,Enc_Wide]) then let - val i = BitsN.bits(imm12,11,11) - val imm3 = BitsN.bits(imm12,10,8) - val imm8 = BitsN.bits(imm12,7,0) + val i = BitsN.bits(11,11) imm12 + val imm3 = BitsN.bits(10,8) imm12 + val imm8 = BitsN.bits(7,0) imm12 val S = BitsN.fromBit sub in Thumb2 @@ -18775,19 +18776,19 @@ fun e_data (c,(ast,e)) = [c,BitsN.B(0x6,5),op',BitsN.B(0x1,1),Rn, BitsN.B(0x0,4),imm12]) else if ((op' = (BitsN.B(0x2,2))) andalso - ((BitsN.bits(imm12,11,8)) = (BitsN.B(0x0,4)))) andalso + ((BitsN.bits(11,8) imm12) = (BitsN.B(0x0,4)))) andalso (not((BitsN.bit(Rn,3)) orelse (e = Enc_Wide))) then let - val n = BitsN.bits(Rn,2,0) - val imm8 = BitsN.bits(imm12,7,0) + val n = BitsN.bits(2,0) Rn + val imm8 = BitsN.bits(7,0) imm12 in Thumb(BitsN.concat[BitsN.B(0x5,5),n,imm8]) end else if not(e = Enc_Narrow) then let - val i = BitsN.bits(imm12,11,11) - val imm3 = BitsN.bits(imm12,10,8) - val imm8 = BitsN.bits(imm12,7,0) + val i = BitsN.bits(11,11) imm12 + val imm3 = BitsN.bits(10,8) imm12 + val imm8 = BitsN.bits(7,0) imm12 val opc = case op' of BitsN.B(0x0,2) => BitsN.B(0x0,4) @@ -18813,26 +18814,26 @@ fun e_data (c,(ast,e)) = ARM(BitsN.concat[c,BitsN.B(0x1,3),opc,S,Rn,Rd,imm12]) end else if ((Set.mem(opc,[BitsN.B(0x4,4),BitsN.B(0x2,4)])) andalso - ((BitsN.bits(imm12,11,3)) = (BitsN.B(0x0,9)))) andalso + ((BitsN.bits(11,3) imm12) = (BitsN.B(0x0,9)))) andalso (not((((setflags = (not(c = (BitsN.B(0xE,4))))) orelse (BitsN.bit(d,3))) orelse (BitsN.bit(n,3))) orelse (e = Enc_Wide))) then let - val Rd = BitsN.bits(d,2,0) - val Rn = BitsN.bits(n,2,0) - val imm3 = BitsN.bits(imm12,2,0) - val S = BitsN.bits(opc,1,1) + val Rd = BitsN.bits(2,0) d + val Rn = BitsN.bits(2,0) n + val imm3 = BitsN.bits(2,0) imm12 + val S = BitsN.bits(1,1) opc in Thumb(BitsN.concat[BitsN.B(0x7,6),S,imm3,Rn,Rd]) end else if (((Set.mem(opc,[BitsN.B(0x4,4),BitsN.B(0x2,4)])) andalso - (d = n)) andalso ((BitsN.bits(imm12,11,8)) = (BitsN.B(0x0,4)))) andalso + (d = n)) andalso ((BitsN.bits(11,8) imm12) = (BitsN.B(0x0,4)))) andalso (not(((setflags = (not(c = (BitsN.B(0xE,4))))) orelse (BitsN.bit(d,3))) orelse (e = Enc_Wide))) then let - val Rdn = BitsN.bits(d,2,0) - val imm8 = BitsN.bits(imm12,7,0) - val S = BitsN.bits(opc,1,1) + val Rdn = BitsN.bits(2,0) d + val imm8 = BitsN.bits(7,0) imm12 + val S = BitsN.bits(1,1) opc in Thumb(BitsN.concat[BitsN.B(0x3,4),S,Rdn,imm8]) end @@ -18842,38 +18843,38 @@ fun e_data (c,(ast,e)) = (BitsN.bit(d,3))) orelse (BitsN.bit(n,3))) orelse (e = Enc_Wide))) then let - val Rd = BitsN.bits(d,2,0) - val Rn = BitsN.bits(n,2,0) + val Rd = BitsN.bits(2,0) d + val Rn = BitsN.bits(2,0) n in Thumb(BitsN.concat[BitsN.B(0x109,10),Rn,Rd]) end else if ((((opc = (BitsN.B(0x4,4))) andalso (not setflags)) andalso (Set.mem(n,[BitsN.B(0xD,4),BitsN.B(0xF,4)]))) andalso - ((BitsN.bits(imm12,11,8)) = (BitsN.B(0xF,4)))) andalso + ((BitsN.bits(11,8) imm12) = (BitsN.B(0xF,4)))) andalso (not((BitsN.bit(d,3)) orelse (e = Enc_Wide))) then let - val Rd = BitsN.bits(d,2,0) - val imm8 = BitsN.bits(imm12,7,0) + val Rd = BitsN.bits(2,0) d + val imm8 = BitsN.bits(7,0) imm12 val S = BitsN.fromBit(n = (BitsN.B(0xD,4))) in Thumb(BitsN.concat[BitsN.B(0xA,4),S,Rd,imm8]) end else if ((((Set.mem(opc,[BitsN.B(0x4,4),BitsN.B(0x2,4)])) andalso (d = (BitsN.B(0xD,4)))) andalso (n = (BitsN.B(0xD,4)))) andalso - ((BitsN.bits(imm12,11,7)) = (BitsN.B(0x1E,5)))) andalso + ((BitsN.bits(11,7) imm12) = (BitsN.B(0x1E,5)))) andalso (not(setflags orelse (e = Enc_Wide))) then let - val imm7 = BitsN.bits(imm12,6,0) - val S = BitsN.bits(opc,1,1) + val imm7 = BitsN.bits(6,0) imm12 + val S = BitsN.bits(1,1) opc in Thumb(BitsN.concat[BitsN.B(0xB0,8),S,imm7]) end else if (((((opc = (BitsN.B(0x2,4))) andalso setflags) andalso (d = (BitsN.B(0xF,4)))) andalso (n = (BitsN.B(0xE,4)))) andalso - ((BitsN.bits(imm12,11,8)) = (BitsN.B(0x0,4)))) andalso + ((BitsN.bits(11,8) imm12) = (BitsN.B(0x0,4)))) andalso (not(e = Enc_Narrow)) then let - val imm8 = BitsN.bits(imm12,7,0) + val imm8 = BitsN.bits(7,0) imm12 in Thumb2(BitsN.B(0xF3DF,16),BitsN.@@(BitsN.B(0x8F,8),imm8)) end @@ -18881,9 +18882,9 @@ fun e_data (c,(ast,e)) = then let val Rd = d val Rn = n - val i = BitsN.bits(imm12,11,11) - val imm3 = BitsN.bits(imm12,10,8) - val imm8 = BitsN.bits(imm12,7,0) + val i = BitsN.bits(11,11) imm12 + val imm3 = BitsN.bits(10,8) imm12 + val imm8 = BitsN.bits(7,0) imm12 val S = BitsN.fromBit setflags val op' = case opc of @@ -18929,9 +18930,9 @@ fun e_data (c,(ast,e)) = (BitsN.bit(d,3))) orelse (BitsN.bit(n,3))) orelse (BitsN.bit(m,3))) orelse (e = Enc_Wide))) then let - val Rn = BitsN.bits(n,2,0) - val Rd = BitsN.bits(d,2,0) - val Rm = BitsN.bits(m,2,0) + val Rn = BitsN.bits(2,0) n + val Rd = BitsN.bits(2,0) d + val Rm = BitsN.bits(2,0) m val S = BitsN.fromBit(opc = (BitsN.B(0x2,4))) in Thumb(BitsN.concat[BitsN.B(0x6,6),S,Rm,Rn,Rd]) @@ -18946,8 +18947,8 @@ fun e_data (c,(ast,e)) = (BitsN.bit(d,3))) orelse (BitsN.bit(m,3))) orelse (e = Enc_Wide))) then let - val Rdn = BitsN.bits(d,2,0) - val Rm = BitsN.bits(m,2,0) + val Rdn = BitsN.bits(2,0) d + val Rm = BitsN.bits(2,0) m in Thumb(BitsN.concat[BitsN.B(0x10,6),opc,Rm,Rdn]) end @@ -18955,8 +18956,8 @@ fun e_data (c,(ast,e)) = (not(setflags orelse (e = Enc_Wide)))) andalso (shift_t = SRType_LSL)) andalso (shift_n = 0) then let - val DN = BitsN.bits(d,3,3) - val Rdn = BitsN.bits(d,2,0) + val DN = BitsN.bits(3,3) d + val Rdn = BitsN.bits(2,0) d val Rm = m in Thumb(BitsN.concat[BitsN.B(0x44,8),DN,Rm,Rdn]) @@ -18968,8 +18969,8 @@ fun e_data (c,(ast,e)) = val Rn = n val Rm = m val (typ,imm5) = EncodeImmShift(shift_t,shift_n) - val imm3 = BitsN.bits(imm5,4,2) - val imm2 = BitsN.bits(imm5,1,0) + val imm3 = BitsN.bits(4,2) imm5 + val imm2 = BitsN.bits(1,0) imm5 val op' = case opc of BitsN.B(0x0,4) => BitsN.B(0x0,4) @@ -19007,16 +19008,16 @@ fun e_data (c,(ast,e)) = (not((((opc = (BitsN.B(0x1,2))) orelse (BitsN.bit(n,3))) orelse (BitsN.bit(m,3))) orelse (e = Enc_Wide))) then let - val Rn = BitsN.bits(n,2,0) - val Rm = BitsN.bits(m,2,0) + val Rn = BitsN.bits(2,0) n + val Rm = BitsN.bits(2,0) m in Thumb(BitsN.concat[BitsN.B(0x42,8),opc,Rm,Rn]) end else if (((not(e = Enc_Wide)) andalso (shift_t = SRType_LSL)) andalso (shift_n = 0)) andalso (opc = (BitsN.B(0x2,2))) then let - val N = BitsN.bits(n,3,3) - val Rn = BitsN.bits(n,2,0) + val N = BitsN.bits(3,3) n + val Rn = BitsN.bits(2,0) n val Rm = m in Thumb(BitsN.concat[BitsN.B(0x45,8),N,Rm,Rn]) @@ -19026,8 +19027,8 @@ fun e_data (c,(ast,e)) = val Rn = n val Rm = m val (typ,imm5) = EncodeImmShift(shift_t,shift_n) - val imm3 = BitsN.bits(imm5,4,2) - val imm2 = BitsN.bits(imm5,1,0) + val imm3 = BitsN.bits(4,2) imm5 + val imm2 = BitsN.bits(1,0) imm5 val op' = case opc of BitsN.B(0x0,2) => BitsN.B(0x0,4) @@ -19061,8 +19062,8 @@ fun e_data (c,(ast,e)) = (BitsN.bit(m,3))) orelse (BitsN.bit(d,3))) orelse (e = Enc_Wide))) then let - val Rm = BitsN.bits(m,2,0) - val Rd = BitsN.bits(d,2,0) + val Rm = BitsN.bits(2,0) m + val Rd = BitsN.bits(2,0) d in Thumb(BitsN.concat[BitsN.B(0x10F,10),Rm,Rd]) end @@ -19071,8 +19072,8 @@ fun e_data (c,(ast,e)) = (BitsN.bit(m,3))) orelse (BitsN.bit(d,3))) orelse (e = Enc_Wide))) then let - val Rm = BitsN.bits(m,2,0) - val Rd = BitsN.bits(d,2,0) + val Rm = BitsN.bits(2,0) m + val Rd = BitsN.bits(2,0) d val (typ,imm5) = EncodeImmShift(shift_t,shift_n) in Thumb(BitsN.concat[BitsN.B(0x0,3),typ,imm5,Rm,Rd]) @@ -19081,8 +19082,8 @@ fun e_data (c,(ast,e)) = (not(((negate orelse setflags) orelse (e = Enc_Wide)) orelse ((d = (BitsN.B(0xF,4))) andalso (not(c = (BitsN.B(0xE,4))))))) then let - val D = BitsN.bits(d,3,3) - val Rd = BitsN.bits(d,2,0) + val D = BitsN.bits(3,3) d + val Rd = BitsN.bits(2,0) d val Rm = m in Thumb(BitsN.concat[BitsN.B(0x46,8),D,Rm,Rd]) @@ -19093,8 +19094,8 @@ fun e_data (c,(ast,e)) = val Rm = m val Rd = d val (typ,imm5) = EncodeImmShift(shift_t,shift_n) - val imm3 = BitsN.bits(imm5,4,2) - val imm2 = BitsN.bits(imm5,1,0) + val imm3 = BitsN.bits(4,2) imm5 + val imm2 = BitsN.bits(1,0) imm5 val N = BitsN.fromBit negate in Thumb2 @@ -19140,8 +19141,8 @@ fun e_data (c,(ast,e)) = (setflags = (not(c = (BitsN.B(0xE,4)))))) orelse (e = Enc_Wide))) then let - val Rm = BitsN.bits(m,2,0) - val Rdn = BitsN.bits(d,2,0) + val Rm = BitsN.bits(2,0) m + val Rdn = BitsN.bits(2,0) d val opc = case shift_t of SRType_LSL => BitsN.B(0x2,3) @@ -19185,15 +19186,15 @@ fun e_media (c,(ast,e)) = | PackHalfword(shift_t,(shift_n,(tbform,(Rd,(Rn,Rm))))) => let val (typ,imm5) = EncodeImmShift(shift_t,shift_n) - val tb = BitsN.bits(typ,1,1) + val tb = BitsN.bits(1,1) typ in if e = Enc_ARM then ARM(BitsN.concat [c,BitsN.B(0x68,8),Rn,Rd,imm5,tb,BitsN.B(0x1,2),Rm]) else if not(e = Enc_Narrow) then let - val imm3 = BitsN.bits(imm5,4,2) - val imm2 = BitsN.bits(imm5,1,0) + val imm3 = BitsN.bits(4,2) imm5 + val imm2 = BitsN.bits(1,0) imm5 in Thumb2 (BitsN.@@(BitsN.B(0xEAC,12),Rn), @@ -19205,7 +19206,7 @@ fun e_media (c,(ast,e)) = | Saturate(shift_t,(shift_n,(saturate_to,(unsigned,(Rd,Rn))))) => let val (typ,imm5) = EncodeImmShift(shift_t,shift_n) - val sh = BitsN.bits(typ,1,1) + val sh = BitsN.bits(1,1) typ val sat_imm = if unsigned then BitsN.fromNat(saturate_to,5) @@ -19218,8 +19219,8 @@ fun e_media (c,(ast,e)) = sh,BitsN.B(0x1,2),Rn]) else if not(e = Enc_Narrow) then let - val imm3 = BitsN.bits(imm5,4,2) - val imm2 = BitsN.bits(imm5,1,0) + val imm3 = BitsN.bits(4,2) imm5 + val imm2 = BitsN.bits(1,0) imm5 in Thumb2 (BitsN.concat @@ -19251,7 +19252,7 @@ fun e_media (c,(ast,e)) = | ExtendByte(unsigned,(d,(Rn,(m,rotation)))) => let val rot = BitsN.fromNat(rotation,5) - val rotate = BitsN.bits(rot,4,3) + val rotate = BitsN.bits(4,3) rot val U = BitsN.fromBit unsigned in if e = Enc_ARM @@ -19267,8 +19268,8 @@ fun e_media (c,(ast,e)) = (not(((BitsN.bit(d,3)) orelse (BitsN.bit(m,3))) orelse (e = Enc_Wide))) then let - val Rd = BitsN.bits(d,2,0) - val Rm = BitsN.bits(m,2,0) + val Rd = BitsN.bits(2,0) d + val Rm = BitsN.bits(2,0) m in Thumb (BitsN.concat[BitsN.B(0xB2,8),U,BitsN.B(0x1,1),Rm,Rd]) @@ -19288,7 +19289,7 @@ fun e_media (c,(ast,e)) = | ExtendHalfword(unsigned,(d,(Rn,(m,rotation)))) => let val rot = BitsN.fromNat(rotation,5) - val rotate = BitsN.bits(rot,4,3) + val rotate = BitsN.bits(4,3) rot val U = BitsN.fromBit unsigned in if e = Enc_ARM @@ -19304,8 +19305,8 @@ fun e_media (c,(ast,e)) = (not(((BitsN.bit(d,3)) orelse (BitsN.bit(m,3))) orelse (e = Enc_Wide))) then let - val Rd = BitsN.bits(d,2,0) - val Rm = BitsN.bits(m,2,0) + val Rd = BitsN.bits(2,0) d + val Rm = BitsN.bits(2,0) m in Thumb (BitsN.concat[BitsN.B(0xB2,8),U,BitsN.B(0x0,1),Rm,Rd]) @@ -19325,7 +19326,7 @@ fun e_media (c,(ast,e)) = | ExtendByte16(unsigned,(Rd,(Rn,(Rm,rotation)))) => let val rot = BitsN.fromNat(rotation,5) - val rotate = BitsN.bits(rot,4,3) + val rotate = BitsN.bits(4,3) rot val U = BitsN.fromBit unsigned in if e = Enc_ARM @@ -19358,8 +19359,8 @@ fun e_media (c,(ast,e)) = else if not(((BitsN.bit(d,3)) orelse (BitsN.bit(m,3))) orelse (e = Enc_Wide)) then let - val Rd = BitsN.bits(d,2,0) - val Rm = BitsN.bits(m,2,0) + val Rd = BitsN.bits(2,0) d + val Rm = BitsN.bits(2,0) m in Thumb(BitsN.concat[BitsN.B(0x2E8,10),Rm,Rd]) end @@ -19385,8 +19386,8 @@ fun e_media (c,(ast,e)) = else if not(((BitsN.bit(d,3)) orelse (BitsN.bit(m,3))) orelse (e = Enc_Wide)) then let - val Rd = BitsN.bits(d,2,0) - val Rm = BitsN.bits(m,2,0) + val Rd = BitsN.bits(2,0) d + val Rm = BitsN.bits(2,0) m in Thumb(BitsN.concat[BitsN.B(0x2E9,10),Rm,Rd]) end @@ -19412,8 +19413,8 @@ fun e_media (c,(ast,e)) = else if not(((BitsN.bit(d,3)) orelse (BitsN.bit(m,3))) orelse (e = Enc_Wide)) then let - val Rd = BitsN.bits(d,2,0) - val Rm = BitsN.bits(m,2,0) + val Rd = BitsN.bits(2,0) d + val Rm = BitsN.bits(2,0) m in Thumb(BitsN.concat[BitsN.B(0x2EB,10),Rm,Rd]) end @@ -19447,8 +19448,8 @@ fun e_media (c,(ast,e)) = BitsN.B(0x5,3),Rn]) else if not(e = Enc_Narrow) then let - val imm3 = BitsN.bits(lsb,4,2) - val imm2 = BitsN.bits(lsb,1,0) + val imm3 = BitsN.bits(4,2) lsb + val imm2 = BitsN.bits(1,0) lsb in Thumb2 (BitsN.concat[BitsN.B(0xF3,8),U,BitsN.B(0x4,3),Rn], @@ -19467,8 +19468,8 @@ fun e_media (c,(ast,e)) = [c,BitsN.B(0x3E,7),msb,Rd,lsb,BitsN.B(0x1,3),Rn]) else if not(e = Enc_Narrow) then let - val imm3 = BitsN.bits(lsb,4,2) - val imm2 = BitsN.bits(lsb,1,0) + val imm3 = BitsN.bits(4,2) lsb + val imm2 = BitsN.bits(1,0) lsb in Thumb2 (BitsN.@@(BitsN.B(0xF36,12),Rn), @@ -19483,15 +19484,15 @@ fun e_hint (c,(ast,e)) = Breakpoint imm32 => (if e = Enc_ARM then let - val imm12 = BitsN.bits(imm32,15,4) - val imm4 = BitsN.bits(imm32,3,0) + val imm12 = BitsN.bits(15,4) imm32 + val imm4 = BitsN.bits(3,0) imm32 in ARM(BitsN.concat [c,BitsN.B(0x12,8),imm12,BitsN.B(0x7,4),imm4]) end else if not(e = Enc_Wide) then let - val imm8 = BitsN.bits(imm32,7,0) + val imm8 = BitsN.bits(7,0) imm32 in Thumb(BitsN.@@(BitsN.B(0xBE,8),imm8)) end @@ -19559,7 +19560,7 @@ fun e_hint (c,(ast,e)) = then let val U = BitsN.fromBit add val R = BitsN.fromBit(not is_pldw) - val imm12 = BitsN.bits(imm32,11,0) + val imm12 = BitsN.bits(11,0) imm32 in ARM(BitsN.concat [BitsN.B(0xF5,8),U,R,BitsN.B(0x1,2),Rn, @@ -19571,7 +19572,7 @@ fun e_hint (c,(ast,e)) = in if add then let - val imm12 = BitsN.bits(imm32,11,0) + val imm12 = BitsN.bits(11,0) imm32 in Thumb2 (BitsN.concat @@ -19579,7 +19580,7 @@ fun e_hint (c,(ast,e)) = BitsN.@@(BitsN.B(0xF,4),imm12)) end else let - val imm8 = BitsN.bits(imm32,7,0) + val imm8 = BitsN.bits(7,0) imm32 in Thumb2 (BitsN.concat @@ -19614,7 +19615,7 @@ fun e_hint (c,(ast,e)) = else BadCode("PreloadData")) | PreloadDataLiteral(add,imm32) => let - val imm12 = BitsN.bits(imm32,11,0) + val imm12 = BitsN.bits(11,0) imm32 val U = BitsN.fromBit add in if e = Enc_ARM @@ -19631,7 +19632,7 @@ fun e_hint (c,(ast,e)) = | PreloadInstruction(add,(Rn,immediate_form1 imm32)) => let val U = BitsN.fromBit add - val imm12 = BitsN.bits(imm32,11,0) + val imm12 = BitsN.bits(11,0) imm32 in if e = Enc_ARM then if c = (BitsN.B(0xE,4)) @@ -19649,7 +19650,7 @@ fun e_hint (c,(ast,e)) = (BitsN.@@(BitsN.B(0xF99,12),Rn), BitsN.@@(BitsN.B(0xF,4),imm12)) else let - val imm8 = BitsN.bits(imm32,7,0) + val imm8 = BitsN.bits(7,0) imm32 in Thumb2 (BitsN.@@(BitsN.B(0xF91,12),Rn), @@ -19749,16 +19750,16 @@ fun e_system (c,(ast,e)) = | HypervisorCall imm16 => (if e = Enc_ARM then let - val imm12 = BitsN.bits(imm16,15,4) - val imm4 = BitsN.bits(imm16,3,0) + val imm12 = BitsN.bits(15,4) imm16 + val imm4 = BitsN.bits(3,0) imm16 in ARM(BitsN.concat [c,BitsN.B(0x14,8),imm12,BitsN.B(0x7,4),imm4]) end else if not(e = Enc_Narrow) then let - val imm4 = BitsN.bits(imm16,15,12) - val imm12 = BitsN.bits(imm16,11,0) + val imm4 = BitsN.bits(15,12) imm16 + val imm12 = BitsN.bits(11,0) imm16 in Thumb2 (BitsN.@@(BitsN.B(0xF7E,12),imm4), @@ -19781,8 +19782,8 @@ fun e_system (c,(ast,e)) = | MoveToRegisterFromBankedOrSpecial(read_spsr,(SYSm,Rd)) => let val R = BitsN.fromBit read_spsr - val m = BitsN.bits(SYSm,4,4) - val m1 = BitsN.bits(SYSm,3,0) + val m = BitsN.bits(4,4) SYSm + val m1 = BitsN.bits(3,0) SYSm in if e = Enc_ARM then ARM(BitsN.concat @@ -19825,8 +19826,8 @@ fun e_system (c,(ast,e)) = | MoveToBankedOrSpecialRegister(write_spsr,(SYSm,Rn)) => let val R = BitsN.fromBit write_spsr - val m = BitsN.bits(SYSm,4,4) - val m1 = BitsN.bits(SYSm,3,0) + val m = BitsN.bits(4,4) SYSm + val m1 = BitsN.bits(3,0) SYSm in if e = Enc_ARM then ARM(BitsN.concat @@ -19892,13 +19893,13 @@ fun e_system (c,(ast,e)) = | SupervisorCall imm32 => (if e = Enc_ARM then let - val imm24 = BitsN.bits(imm32,23,0) + val imm24 = BitsN.bits(23,0) imm32 in ARM(BitsN.concat[c,BitsN.B(0xF,4),imm24]) end else if not(e = Enc_Wide) then let - val imm8 = BitsN.bits(imm32,7,0) + val imm8 = BitsN.bits(7,0) imm32 in Thumb(BitsN.@@(BitsN.B(0xDF,8),imm8)) end @@ -19946,8 +19947,8 @@ fun e_multiply (c,(ast,e)) = (not(((setflags = (not(c = (BitsN.B(0xE,4))))) orelse (BitsN.bit(d,3))) orelse (e = Enc_Wide))) then let - val Rn = BitsN.bits(n,2,0) - val Rdm = BitsN.bits(d,2,0) + val Rn = BitsN.bits(2,0) n + val Rdm = BitsN.bits(2,0) d in Thumb(BitsN.concat[BitsN.B(0x10D,10),Rn,Rdm]) end @@ -20357,7 +20358,7 @@ fun e_load (c,(ast,e)) = val P = BitsN.fromBit index val U = BitsN.fromBit add val W = BitsN.fromBit(index andalso wback) - val imm12 = BitsN.bits(imm32,11,0) + val imm12 = BitsN.bits(11,0) imm32 in ARM(BitsN.concat [c,BitsN.B(0x2,3),P,U,BitsN.B(0x0,1),W, @@ -20370,8 +20371,8 @@ fun e_load (c,(ast,e)) = (Aligned 32 (imm32,4))) andalso (not((BitsN.bit(t,3)) orelse (e = Enc_Wide))) then let - val Rt = BitsN.bits(t,2,0) - val imm8 = BitsN.bits(imm32,9,2) + val Rt = BitsN.bits(2,0) t + val imm8 = BitsN.bits(9,2) imm32 in Thumb(BitsN.concat[BitsN.B(0x13,5),Rt,imm8]) end @@ -20380,9 +20381,9 @@ fun e_load (c,(ast,e)) = (not(((BitsN.bit(t,3)) orelse (BitsN.bit(n,3))) orelse (e = Enc_Wide))) then let - val Rt = BitsN.bits(t,2,0) - val Rn = BitsN.bits(n,2,0) - val imm5 = BitsN.bits(imm32,6,2) + val Rt = BitsN.bits(2,0) t + val Rn = BitsN.bits(2,0) n + val imm5 = BitsN.bits(6,2) imm32 in Thumb(BitsN.concat[BitsN.B(0xD,5),imm5,Rn,Rt]) end @@ -20391,7 +20392,7 @@ fun e_load (c,(ast,e)) = then let val Rt = t val Rn = n - val imm12 = BitsN.bits(imm32,11,0) + val imm12 = BitsN.bits(11,0) imm32 in Thumb2 (BitsN.@@(BitsN.B(0xF8D,12),Rn), @@ -20406,7 +20407,7 @@ fun e_load (c,(ast,e)) = val P = BitsN.fromBit index val U = BitsN.fromBit add val W = BitsN.fromBit wback - val imm8 = BitsN.bits(imm32,7,0) + val imm8 = BitsN.bits(7,0) imm32 in Thumb2 (BitsN.@@(BitsN.B(0xF85,12),Rn), @@ -20437,9 +20438,9 @@ fun e_load (c,(ast,e)) = (not((((BitsN.bit(m,3)) orelse (BitsN.bit(n,3))) orelse (BitsN.bit(t,3))) orelse (e = Enc_Wide))) then let - val Rm = BitsN.bits(m,2,0) - val Rn = BitsN.bits(n,2,0) - val Rt = BitsN.bits(t,2,0) + val Rm = BitsN.bits(2,0) m + val Rn = BitsN.bits(2,0) n + val Rt = BitsN.bits(2,0) t in Thumb(BitsN.concat[BitsN.B(0x2C,7),Rm,Rn,Rt]) end @@ -20448,7 +20449,7 @@ fun e_load (c,(ast,e)) = val Rn = n val Rt = t val Rm = m - val imm2 = BitsN.bits(imm5,1,0) + val imm2 = BitsN.bits(1,0) imm5 in Thumb2 (BitsN.@@(BitsN.B(0xF85,12),Rn), @@ -20463,7 +20464,7 @@ fun e_load (c,(ast,e)) = then let val Rt = t val U = BitsN.fromBit add - val imm12 = BitsN.bits(imm32,11,0) + val imm12 = BitsN.bits(11,0) imm32 in ARM(BitsN.concat [c,BitsN.B(0x5,4),U,BitsN.B(0x1F,7),Rt,imm12]) @@ -20473,8 +20474,8 @@ fun e_load (c,(ast,e)) = (Aligned 32 (imm32,4))) andalso (not((BitsN.bit(t,3)) orelse (e = Enc_Wide))) then let - val Rt = BitsN.bits(t,2,0) - val imm8 = BitsN.bits(imm32,9,2) + val Rt = BitsN.bits(2,0) t + val imm8 = BitsN.bits(9,2) imm32 in Thumb(BitsN.concat[BitsN.B(0x9,5),Rt,imm8]) end @@ -20483,7 +20484,7 @@ fun e_load (c,(ast,e)) = then let val Rt = t val U = BitsN.fromBit add - val imm12 = BitsN.bits(imm32,11,0) + val imm12 = BitsN.bits(11,0) imm32 in Thumb2 (BitsN.concat[BitsN.B(0xF8,8),U,BitsN.B(0x5F,7)], @@ -20494,7 +20495,7 @@ fun e_load (c,(ast,e)) = (if ((e = Enc_ARM) andalso postindex) andalso (BitsN.<=+(imm32,BitsN.B(0xFFF,32))) then let - val imm12 = BitsN.bits(imm32,11,0) + val imm12 = BitsN.bits(11,0) imm32 val U = BitsN.fromBit add in ARM(BitsN.concat @@ -20503,7 +20504,7 @@ fun e_load (c,(ast,e)) = else if (((Set.mem(e,[Enc_Thumb,Enc_Wide])) andalso add) andalso (not postindex)) andalso (BitsN.<=+(imm32,BitsN.B(0xFF,32))) then let - val imm8 = BitsN.bits(imm32,7,0) + val imm8 = BitsN.bits(7,0) imm32 in Thumb2 (BitsN.@@(BitsN.B(0xF85,12),Rn), @@ -20535,7 +20536,7 @@ fun e_load (c,(ast,e)) = in if unsigned andalso (BitsN.<=+(imm32,BitsN.B(0xFFF,32))) then let - val imm12 = BitsN.bits(imm32,11,0) + val imm12 = BitsN.bits(11,0) imm32 in ARM(BitsN.concat [c,BitsN.B(0x2,3),P,U,BitsN.B(0x1,1),W, @@ -20543,8 +20544,8 @@ fun e_load (c,(ast,e)) = end else if BitsN.<=+(imm32,BitsN.B(0xFF,32)) then let - val imm4H = BitsN.bits(imm32,7,4) - val imm4L = BitsN.bits(imm32,3,0) + val imm4H = BitsN.bits(7,4) imm32 + val imm4L = BitsN.bits(3,0) imm32 in ARM(BitsN.concat [c,BitsN.B(0x0,3),P,U,BitsN.B(0x1,1),W, @@ -20558,9 +20559,9 @@ fun e_load (c,(ast,e)) = (not(((BitsN.bit(t,3)) orelse (BitsN.bit(n,3))) orelse (e = Enc_Wide))) then let - val Rt = BitsN.bits(t,2,0) - val Rn = BitsN.bits(n,2,0) - val imm5 = BitsN.bits(imm32,4,0) + val Rt = BitsN.bits(2,0) t + val Rn = BitsN.bits(2,0) n + val imm5 = BitsN.bits(4,0) imm32 in Thumb(BitsN.concat[BitsN.B(0xF,5),imm5,Rn,Rt]) end @@ -20569,7 +20570,7 @@ fun e_load (c,(ast,e)) = then let val Rt = t val Rn = n - val imm12 = BitsN.bits(imm32,11,0) + val imm12 = BitsN.bits(11,0) imm32 val S = BitsN.fromBit(not unsigned) in Thumb2 @@ -20586,7 +20587,7 @@ fun e_load (c,(ast,e)) = val P = BitsN.fromBit index val U = BitsN.fromBit add val W = BitsN.fromBit wback - val imm8 = BitsN.bits(imm32,7,0) + val imm8 = BitsN.bits(7,0) imm32 val S = BitsN.fromBit(not unsigned) in Thumb2 @@ -20626,9 +20627,9 @@ fun e_load (c,(ast,e)) = (not((((BitsN.bit(m,3)) orelse (BitsN.bit(n,3))) orelse (BitsN.bit(t,3))) orelse (e = Enc_Wide))) then let - val Rm = BitsN.bits(m,2,0) - val Rn = BitsN.bits(n,2,0) - val Rt = BitsN.bits(t,2,0) + val Rm = BitsN.bits(2,0) m + val Rn = BitsN.bits(2,0) n + val Rt = BitsN.bits(2,0) t val U = BitsN.fromBit unsigned val S = BitsN.~ U in @@ -20641,7 +20642,7 @@ fun e_load (c,(ast,e)) = val Rt = t val Rn = n val Rm = m - val imm2 = BitsN.bits(imm5,1,0) + val imm2 = BitsN.bits(1,0) imm5 val S = BitsN.fromBit(not unsigned) in Thumb2 @@ -20659,7 +20660,7 @@ fun e_load (c,(ast,e)) = in if unsigned andalso (BitsN.<=+(imm32,BitsN.B(0xFFF,32))) then let - val imm12 = BitsN.bits(imm32,11,0) + val imm12 = BitsN.bits(11,0) imm32 in ARM(BitsN.concat [c,BitsN.B(0x5,4),U,BitsN.B(0x5F,7),Rt, @@ -20667,8 +20668,8 @@ fun e_load (c,(ast,e)) = end else if BitsN.<=+(imm32,BitsN.B(0xFF,32)) then let - val imm4H = BitsN.bits(imm32,7,4) - val imm4L = BitsN.bits(imm32,3,0) + val imm4H = BitsN.bits(7,4) imm32 + val imm4L = BitsN.bits(3,0) imm32 in ARM(BitsN.concat [c,BitsN.B(0x1,4),U,BitsN.B(0x5F,7),Rt, @@ -20681,7 +20682,7 @@ fun e_load (c,(ast,e)) = then let val U = BitsN.fromBit add val S = BitsN.fromBit(not unsigned) - val imm12 = BitsN.bits(imm32,11,0) + val imm12 = BitsN.bits(11,0) imm32 in Thumb2 (BitsN.concat[BitsN.B(0x7C,7),S,U,BitsN.B(0x1F,7)], @@ -20692,7 +20693,7 @@ fun e_load (c,(ast,e)) = (if ((e = Enc_ARM) andalso postindex) andalso (BitsN.<=+(imm32,BitsN.B(0xFFF,32))) then let - val imm12 = BitsN.bits(imm32,11,0) + val imm12 = BitsN.bits(11,0) imm32 val U = BitsN.fromBit add in ARM(BitsN.concat @@ -20701,7 +20702,7 @@ fun e_load (c,(ast,e)) = else if (((Set.mem(e,[Enc_Thumb,Enc_Wide])) andalso add) andalso (not postindex)) andalso (BitsN.<=+(imm32,BitsN.B(0xFF,32))) then let - val imm8 = BitsN.bits(imm32,7,0) + val imm8 = BitsN.bits(7,0) imm32 in Thumb2 (BitsN.@@(BitsN.B(0xF81,12),Rn), @@ -20725,8 +20726,8 @@ fun e_load (c,(ast,e)) = (if ((e = Enc_ARM) andalso postindex) andalso (BitsN.<=+(imm32,BitsN.B(0xFF,32))) then let - val imm4H = BitsN.bits(imm32,7,4) - val imm4L = BitsN.bits(imm32,3,0) + val imm4H = BitsN.bits(7,4) imm32 + val imm4L = BitsN.bits(3,0) imm32 val U = BitsN.fromBit add in ARM(BitsN.concat @@ -20736,7 +20737,7 @@ fun e_load (c,(ast,e)) = else if (((Set.mem(e,[Enc_Thumb,Enc_Wide])) andalso add) andalso (not postindex)) andalso (BitsN.<=+(imm32,BitsN.B(0xFF,32))) then let - val imm8 = BitsN.bits(imm32,7,0) + val imm8 = BitsN.bits(7,0) imm32 in Thumb2 (BitsN.@@(BitsN.B(0xF91,12),Rn), @@ -20766,8 +20767,8 @@ fun e_load (c,(ast,e)) = val U = BitsN.fromBit add val W = BitsN.fromBit(index andalso wback) val S = BitsN.fromBit(not unsigned) - val imm4H = BitsN.bits(imm32,7,4) - val imm4L = BitsN.bits(imm32,3,0) + val imm4H = BitsN.bits(7,4) imm32 + val imm4L = BitsN.bits(3,0) imm32 in ARM(BitsN.concat [c,BitsN.B(0x0,3),P,U,BitsN.B(0x1,1),W, @@ -20781,9 +20782,9 @@ fun e_load (c,(ast,e)) = (not(((BitsN.bit(t,3)) orelse (BitsN.bit(n,3))) orelse (e = Enc_Wide))) then let - val Rt = BitsN.bits(t,2,0) - val Rn = BitsN.bits(n,2,0) - val imm5 = BitsN.bits(imm32,5,1) + val Rt = BitsN.bits(2,0) t + val Rn = BitsN.bits(2,0) n + val imm5 = BitsN.bits(5,1) imm32 in Thumb(BitsN.concat[BitsN.B(0x11,5),imm5,Rn,Rt]) end @@ -20792,7 +20793,7 @@ fun e_load (c,(ast,e)) = then let val Rt = t val Rn = n - val imm12 = BitsN.bits(imm32,11,0) + val imm12 = BitsN.bits(11,0) imm32 val S = BitsN.fromBit(not unsigned) in Thumb2 @@ -20809,7 +20810,7 @@ fun e_load (c,(ast,e)) = val P = BitsN.fromBit index val U = BitsN.fromBit add val W = BitsN.fromBit wback - val imm8 = BitsN.bits(imm32,7,0) + val imm8 = BitsN.bits(7,0) imm32 val S = BitsN.fromBit(not unsigned) in Thumb2 @@ -20845,9 +20846,9 @@ fun e_load (c,(ast,e)) = (not((((BitsN.bit(m,3)) orelse (BitsN.bit(n,3))) orelse (BitsN.bit(t,3))) orelse (e = Enc_Wide))) then let - val Rm = BitsN.bits(m,2,0) - val Rn = BitsN.bits(n,2,0) - val Rt = BitsN.bits(t,2,0) + val Rm = BitsN.bits(2,0) m + val Rn = BitsN.bits(2,0) n + val Rt = BitsN.bits(2,0) t in Thumb (BitsN.concat @@ -20859,7 +20860,7 @@ fun e_load (c,(ast,e)) = val Rn = n val Rm = m val imm5 = BitsN.fromNat(shift_n,5) - val imm2 = BitsN.bits(imm5,1,0) + val imm2 = BitsN.bits(1,0) imm5 in Thumb2 (BitsN.concat @@ -20877,8 +20878,8 @@ fun e_load (c,(ast,e)) = if e = Enc_ARM then if BitsN.<=+(imm32,BitsN.B(0xFF,32)) then let - val imm4H = BitsN.bits(imm32,7,4) - val imm4L = BitsN.bits(imm32,3,0) + val imm4H = BitsN.bits(7,4) imm32 + val imm4L = BitsN.bits(3,0) imm32 in ARM(BitsN.concat [c,BitsN.B(0x1,4),U,BitsN.B(0x5F,7),Rt, @@ -20888,7 +20889,7 @@ fun e_load (c,(ast,e)) = else if (BitsN.<=+(imm32,BitsN.B(0xFFF,32))) andalso (not(e = Enc_Narrow)) then let - val imm12 = BitsN.bits(imm32,11,0) + val imm12 = BitsN.bits(11,0) imm32 in Thumb2 (BitsN.concat[BitsN.B(0x7C,7),S,U,BitsN.B(0x3F,7)], @@ -20906,8 +20907,8 @@ fun e_load (c,(ast,e)) = then BadCode("LoadHalfUnprivileged: bad immediate") else if (e = Enc_ARM) andalso postindex then let - val imm4H = BitsN.bits(imm32,7,4) - val imm4L = BitsN.bits(imm32,3,0) + val imm4H = BitsN.bits(7,4) imm32 + val imm4L = BitsN.bits(3,0) imm32 in ARM(BitsN.concat [c,BitsN.B(0x0,4),U,BitsN.B(0x7,3),Rn,Rt,imm4H, @@ -20916,7 +20917,7 @@ fun e_load (c,(ast,e)) = else if ((Set.mem(e,[Enc_Thumb,Enc_Wide])) andalso add) andalso (not postindex) then let - val imm8 = BitsN.bits(imm32,7,0) + val imm8 = BitsN.bits(7,0) imm32 in Thumb2 (BitsN.concat[BitsN.B(0x7C,7),S,BitsN.B(0x3,4),Rn], @@ -20950,22 +20951,22 @@ fun e_load (c,(ast,e)) = end else if (((((n = (BitsN.B(0xD,4))) andalso increment) andalso (not index)) andalso wback) andalso - ((BitsN.bits(registers,14,8)) = (BitsN.B(0x0,7)))) andalso + ((BitsN.bits(14,8) registers) = (BitsN.B(0x0,7)))) andalso (not(e = Enc_Wide)) then let - val P = BitsN.bits(registers,15,15) - val register_list = BitsN.bits(registers,7,0) + val P = BitsN.bits(15,15) registers + val register_list = BitsN.bits(7,0) registers in Thumb(BitsN.concat[BitsN.B(0x5E,7),P,register_list]) end else if (((((not(BitsN.bit(n,3))) andalso increment) andalso (not index)) andalso (not(wback = (BitsN.bit(registers,BitsN.toNat n))))) andalso - ((BitsN.bits(registers,15,8)) = (BitsN.B(0x0,8)))) andalso + ((BitsN.bits(15,8) registers) = (BitsN.B(0x0,8)))) andalso (not(e = Enc_Wide)) then let - val Rn = BitsN.bits(n,2,0) - val register_list = BitsN.bits(registers,7,0) + val Rn = BitsN.bits(2,0) n + val register_list = BitsN.bits(7,0) registers in Thumb(BitsN.concat[BitsN.B(0x19,5),Rn,register_list]) end @@ -21028,8 +21029,8 @@ fun e_load (c,(ast,e)) = (BitsN.<=+(imm32,BitsN.B(0xFF,32))) then let val W = BitsN.fromBit(index andalso wback) - val imm4H = BitsN.bits(imm32,7,4) - val imm4L = BitsN.bits(imm32,3,0) + val imm4H = BitsN.bits(7,4) imm32 + val imm4L = BitsN.bits(3,0) imm32 in ARM(BitsN.concat [c,BitsN.B(0x0,3),P,U,BitsN.B(0x1,1),W, @@ -21041,7 +21042,7 @@ fun e_load (c,(ast,e)) = (Aligned 32 (imm32,4))) andalso (not(e = Enc_Narrow)) then let val W = BitsN.fromBit wback - val imm8 = BitsN.bits(imm32,9,2) + val imm8 = BitsN.bits(9,2) imm32 in Thumb2 (BitsN.concat @@ -21070,8 +21071,8 @@ fun e_load (c,(ast,e)) = then if ((BitsN.+(Rt,BitsN.B(0x1,4))) = Rt2) andalso (BitsN.<=+(imm32,BitsN.B(0xFF,32))) then let - val imm4H = BitsN.bits(imm32,7,4) - val imm4L = BitsN.bits(imm32,3,0) + val imm4H = BitsN.bits(7,4) imm32 + val imm4L = BitsN.bits(3,0) imm32 in ARM(BitsN.concat [c,BitsN.B(0x1,4),U,BitsN.B(0x4F,7),Rt, @@ -21081,7 +21082,7 @@ fun e_load (c,(ast,e)) = else if ((BitsN.<=+(imm32,BitsN.B(0x3FC,32))) andalso (Aligned 32 (imm32,4))) andalso (not(e = Enc_Narrow)) then let - val imm8 = BitsN.bits(imm32,9,2) + val imm8 = BitsN.bits(9,2) imm32 in Thumb2 (BitsN.concat[BitsN.B(0xE9,8),U,BitsN.B(0x5F,7)], @@ -21098,7 +21099,7 @@ fun e_load (c,(ast,e)) = else if ((BitsN.<=+(imm32,BitsN.B(0x3FC,32))) andalso (Aligned 32 (imm32,4))) andalso (not(e = Enc_Narrow)) then let - val imm8 = BitsN.bits(imm32,9,2) + val imm8 = BitsN.bits(9,2) imm32 in Thumb2 (BitsN.@@(BitsN.B(0xE85,12),Rn), @@ -21145,7 +21146,7 @@ fun e_store (c,(ast,e)) = val P = BitsN.fromBit index val U = BitsN.fromBit add val W = BitsN.fromBit(index andalso wback) - val imm12 = BitsN.bits(imm32,11,0) + val imm12 = BitsN.bits(11,0) imm32 in ARM(BitsN.concat [c,BitsN.B(0x2,3),P,U,BitsN.B(0x0,1),W, @@ -21158,8 +21159,8 @@ fun e_store (c,(ast,e)) = (Aligned 32 (imm32,4))) andalso (not((BitsN.bit(t,3)) orelse (e = Enc_Wide))) then let - val Rt = BitsN.bits(t,2,0) - val imm8 = BitsN.bits(imm32,9,2) + val Rt = BitsN.bits(2,0) t + val imm8 = BitsN.bits(9,2) imm32 in Thumb(BitsN.concat[BitsN.B(0x12,5),Rt,imm8]) end @@ -21168,9 +21169,9 @@ fun e_store (c,(ast,e)) = (not(((BitsN.bit(t,3)) orelse (BitsN.bit(n,3))) orelse (e = Enc_Wide))) then let - val Rt = BitsN.bits(t,2,0) - val Rn = BitsN.bits(n,2,0) - val imm5 = BitsN.bits(imm32,6,2) + val Rt = BitsN.bits(2,0) t + val Rn = BitsN.bits(2,0) n + val imm5 = BitsN.bits(6,2) imm32 in Thumb(BitsN.concat[BitsN.B(0xC,5),imm5,Rn,Rt]) end @@ -21179,7 +21180,7 @@ fun e_store (c,(ast,e)) = then let val Rt = t val Rn = n - val imm12 = BitsN.bits(imm32,11,0) + val imm12 = BitsN.bits(11,0) imm32 in Thumb2 (BitsN.@@(BitsN.B(0xF8C,12),Rn), @@ -21194,7 +21195,7 @@ fun e_store (c,(ast,e)) = val P = BitsN.fromBit index val U = BitsN.fromBit add val W = BitsN.fromBit wback - val imm8 = BitsN.bits(imm32,7,0) + val imm8 = BitsN.bits(7,0) imm32 in Thumb2 (BitsN.@@(BitsN.B(0xF84,12),Rn), @@ -21225,9 +21226,9 @@ fun e_store (c,(ast,e)) = (not((((BitsN.bit(m,3)) orelse (BitsN.bit(n,3))) orelse (BitsN.bit(t,3))) orelse (e = Enc_Wide))) then let - val Rm = BitsN.bits(m,2,0) - val Rn = BitsN.bits(n,2,0) - val Rt = BitsN.bits(t,2,0) + val Rm = BitsN.bits(2,0) m + val Rn = BitsN.bits(2,0) n + val Rt = BitsN.bits(2,0) t in Thumb(BitsN.concat[BitsN.B(0x28,7),Rm,Rn,Rt]) end @@ -21236,7 +21237,7 @@ fun e_store (c,(ast,e)) = val Rn = n val Rt = t val Rm = m - val imm2 = BitsN.bits(imm5,1,0) + val imm2 = BitsN.bits(1,0) imm5 in Thumb2 (BitsN.@@(BitsN.B(0xF84,12),Rn), @@ -21249,7 +21250,7 @@ fun e_store (c,(ast,e)) = (if ((e = Enc_ARM) andalso postindex) andalso (BitsN.<=+(imm32,BitsN.B(0xFFF,32))) then let - val imm12 = BitsN.bits(imm32,11,0) + val imm12 = BitsN.bits(11,0) imm32 val U = BitsN.fromBit add in ARM(BitsN.concat @@ -21258,7 +21259,7 @@ fun e_store (c,(ast,e)) = else if (((Set.mem(e,[Enc_Thumb,Enc_Wide])) andalso add) andalso (not postindex)) andalso (BitsN.<=+(imm32,BitsN.B(0xFF,32))) then let - val imm8 = BitsN.bits(imm32,7,0) + val imm8 = BitsN.bits(7,0) imm32 in Thumb2 (BitsN.@@(BitsN.B(0xF84,12),Rn), @@ -21287,7 +21288,7 @@ fun e_store (c,(ast,e)) = val P = BitsN.fromBit index val U = BitsN.fromBit add val W = BitsN.fromBit(index andalso wback) - val imm12 = BitsN.bits(imm32,11,0) + val imm12 = BitsN.bits(11,0) imm32 in ARM(BitsN.concat [c,BitsN.B(0x2,3),P,U,BitsN.B(0x1,1),W, @@ -21299,9 +21300,9 @@ fun e_store (c,(ast,e)) = (not(((BitsN.bit(t,3)) orelse (BitsN.bit(n,3))) orelse (e = Enc_Wide))) then let - val Rt = BitsN.bits(t,2,0) - val Rn = BitsN.bits(n,2,0) - val imm5 = BitsN.bits(imm32,4,0) + val Rt = BitsN.bits(2,0) t + val Rn = BitsN.bits(2,0) n + val imm5 = BitsN.bits(4,0) imm32 in Thumb(BitsN.concat[BitsN.B(0xE,5),imm5,Rn,Rt]) end @@ -21310,7 +21311,7 @@ fun e_store (c,(ast,e)) = then let val Rt = t val Rn = n - val imm12 = BitsN.bits(imm32,11,0) + val imm12 = BitsN.bits(11,0) imm32 in Thumb2 (BitsN.@@(BitsN.B(0xF88,12),Rn), @@ -21325,7 +21326,7 @@ fun e_store (c,(ast,e)) = val P = BitsN.fromBit index val U = BitsN.fromBit add val W = BitsN.fromBit wback - val imm8 = BitsN.bits(imm32,7,0) + val imm8 = BitsN.bits(7,0) imm32 in Thumb2 (BitsN.@@(BitsN.B(0xF80,12),Rn), @@ -21356,9 +21357,9 @@ fun e_store (c,(ast,e)) = (not((((BitsN.bit(m,3)) orelse (BitsN.bit(n,3))) orelse (BitsN.bit(t,3))) orelse (e = Enc_Wide))) then let - val Rm = BitsN.bits(m,2,0) - val Rn = BitsN.bits(n,2,0) - val Rt = BitsN.bits(t,2,0) + val Rm = BitsN.bits(2,0) m + val Rn = BitsN.bits(2,0) n + val Rt = BitsN.bits(2,0) t in Thumb(BitsN.concat[BitsN.B(0x2A,7),Rm,Rn,Rt]) end @@ -21367,7 +21368,7 @@ fun e_store (c,(ast,e)) = val Rt = t val Rn = n val Rm = m - val imm2 = BitsN.bits(imm5,1,0) + val imm2 = BitsN.bits(1,0) imm5 in Thumb2 (BitsN.@@(BitsN.B(0xF80,12),Rn), @@ -21381,7 +21382,7 @@ fun e_store (c,(ast,e)) = (if ((e = Enc_ARM) andalso postindex) andalso (BitsN.<=+(imm32,BitsN.B(0xFFF,32))) then let - val imm12 = BitsN.bits(imm32,11,0) + val imm12 = BitsN.bits(11,0) imm32 val U = BitsN.fromBit add in ARM(BitsN.concat @@ -21390,7 +21391,7 @@ fun e_store (c,(ast,e)) = else if (((Set.mem(e,[Enc_Thumb,Enc_Wide])) andalso add) andalso (not postindex)) andalso (BitsN.<=+(imm32,BitsN.B(0xFF,32))) then let - val imm8 = BitsN.bits(imm32,7,0) + val imm8 = BitsN.bits(7,0) imm32 in Thumb2 (BitsN.@@(BitsN.B(0xF80,12),Rn), @@ -21419,8 +21420,8 @@ fun e_store (c,(ast,e)) = val P = BitsN.fromBit index val U = BitsN.fromBit add val W = BitsN.fromBit(index andalso wback) - val imm4H = BitsN.bits(imm32,7,4) - val imm4L = BitsN.bits(imm32,3,0) + val imm4H = BitsN.bits(7,4) imm32 + val imm4L = BitsN.bits(3,0) imm32 in ARM(BitsN.concat [c,BitsN.B(0x0,3),P,U,BitsN.B(0x1,1),W, @@ -21434,9 +21435,9 @@ fun e_store (c,(ast,e)) = (not(((BitsN.bit(t,3)) orelse (BitsN.bit(n,3))) orelse (e = Enc_Wide))) then let - val Rt = BitsN.bits(t,2,0) - val Rn = BitsN.bits(n,2,0) - val imm5 = BitsN.bits(imm32,5,1) + val Rt = BitsN.bits(2,0) t + val Rn = BitsN.bits(2,0) n + val imm5 = BitsN.bits(5,1) imm32 in Thumb(BitsN.concat[BitsN.B(0x10,5),imm5,Rn,Rt]) end @@ -21445,7 +21446,7 @@ fun e_store (c,(ast,e)) = then let val Rt = t val Rn = n - val imm12 = BitsN.bits(imm32,11,0) + val imm12 = BitsN.bits(11,0) imm32 in Thumb2 (BitsN.@@(BitsN.B(0xF8A,12),Rn), @@ -21460,7 +21461,7 @@ fun e_store (c,(ast,e)) = val P = BitsN.fromBit index val U = BitsN.fromBit add val W = BitsN.fromBit wback - val imm8 = BitsN.bits(imm32,7,0) + val imm8 = BitsN.bits(7,0) imm32 in Thumb2 (BitsN.@@(BitsN.B(0xF82,12),Rn), @@ -21490,9 +21491,9 @@ fun e_store (c,(ast,e)) = (not((((BitsN.bit(m,3)) orelse (BitsN.bit(n,3))) orelse (BitsN.bit(t,3))) orelse (e = Enc_Wide))) then let - val Rm = BitsN.bits(m,2,0) - val Rn = BitsN.bits(n,2,0) - val Rt = BitsN.bits(t,2,0) + val Rm = BitsN.bits(2,0) m + val Rn = BitsN.bits(2,0) n + val Rt = BitsN.bits(2,0) t in Thumb(BitsN.concat[BitsN.B(0x29,7),Rm,Rn,Rt]) end @@ -21502,7 +21503,7 @@ fun e_store (c,(ast,e)) = val Rn = n val Rm = m val imm5 = BitsN.fromNat(shift_n,5) - val imm2 = BitsN.bits(imm5,1,0) + val imm2 = BitsN.bits(1,0) imm5 in Thumb2 (BitsN.@@(BitsN.B(0xF82,12),Rn), @@ -21519,8 +21520,8 @@ fun e_store (c,(ast,e)) = then BadCode("StoreHalfUnprivileged: bad immediate") else if (e = Enc_ARM) andalso postindex then let - val imm4H = BitsN.bits(imm32,7,4) - val imm4L = BitsN.bits(imm32,3,0) + val imm4H = BitsN.bits(7,4) imm32 + val imm4L = BitsN.bits(3,0) imm32 in ARM(BitsN.concat [c,BitsN.B(0x0,4),U,BitsN.B(0x6,3),Rn,Rt,imm4H, @@ -21529,7 +21530,7 @@ fun e_store (c,(ast,e)) = else if ((Set.mem(e,[Enc_Thumb,Enc_Wide])) andalso add) andalso (not postindex) then let - val imm8 = BitsN.bits(imm32,7,0) + val imm8 = BitsN.bits(7,0) imm32 in Thumb2 (BitsN.@@(BitsN.B(0xF82,12),Rn), @@ -21561,21 +21562,21 @@ fun e_store (c,(ast,e)) = end else if ((((((n = (BitsN.B(0xD,4))) andalso (not increment)) andalso index) andalso wback) andalso (not(BitsN.bit(registers,15)))) andalso - ((BitsN.bits(registers,13,8)) = (BitsN.B(0x0,6)))) andalso + ((BitsN.bits(13,8) registers) = (BitsN.B(0x0,6)))) andalso (not(e = Enc_Wide)) then let - val M = BitsN.bits(registers,14,14) - val register_list = BitsN.bits(registers,7,0) + val M = BitsN.bits(14,14) registers + val register_list = BitsN.bits(7,0) registers in Thumb(BitsN.concat[BitsN.B(0x5A,7),M,register_list]) end else if (((((not(BitsN.bit(n,3))) andalso increment) andalso (not index)) andalso wback) andalso - ((BitsN.bits(registers,15,8)) = (BitsN.B(0x0,8)))) andalso + ((BitsN.bits(15,8) registers) = (BitsN.B(0x0,8)))) andalso (not(e = Enc_Wide)) then let - val Rn = BitsN.bits(n,2,0) - val register_list = BitsN.bits(registers,7,0) + val Rn = BitsN.bits(2,0) n + val register_list = BitsN.bits(7,0) registers in Thumb(BitsN.concat[BitsN.B(0x18,5),Rn,register_list]) end @@ -21614,8 +21615,8 @@ fun e_store (c,(ast,e)) = (BitsN.<=+(imm32,BitsN.B(0xFF,32))) then let val W = BitsN.fromBit(index andalso wback) - val imm4H = BitsN.bits(imm32,7,4) - val imm4L = BitsN.bits(imm32,3,0) + val imm4H = BitsN.bits(7,4) imm32 + val imm4L = BitsN.bits(3,0) imm32 in ARM(BitsN.concat [c,BitsN.B(0x0,3),P,U,BitsN.B(0x1,1),W, @@ -21627,7 +21628,7 @@ fun e_store (c,(ast,e)) = (Aligned 32 (imm32,4))) andalso (not(e = Enc_Narrow)) then let val W = BitsN.fromBit wback - val imm8 = BitsN.bits(imm32,9,2) + val imm8 = BitsN.bits(9,2) imm32 in Thumb2 (BitsN.concat @@ -21657,7 +21658,7 @@ fun e_store (c,(ast,e)) = else if ((BitsN.<=+(imm32,BitsN.B(0x3FC,32))) andalso (Aligned 32 (imm32,4))) andalso (not(e = Enc_Narrow)) then let - val imm8 = BitsN.bits(imm32,9,2) + val imm8 = BitsN.bits(9,2) imm32 in Thumb2 (BitsN.@@(BitsN.B(0xE84,12),Rn),BitsN.concat[Rt,Rd,imm8]) @@ -21738,23 +21739,23 @@ fun instructionEncode (c,(ast,e)) = | Undefined imm32 => (if e = Enc_ARM then let - val imm12 = BitsN.bits(imm32,15,4) - val imm4 = BitsN.bits(imm32,3,0) + val imm12 = BitsN.bits(15,4) imm32 + val imm4 = BitsN.bits(3,0) imm32 in ARM(BitsN.concat [BitsN.B(0xE7F,12),imm12,BitsN.B(0xF,4),imm4]) end else if (not(e = Enc_Wide)) andalso - ((BitsN.bits(imm32,31,8)) = (BitsN.B(0x0,24))) + ((BitsN.bits(31,8) imm32) = (BitsN.B(0x0,24))) then let - val imm8 = BitsN.bits(imm32,7,0) + val imm8 = BitsN.bits(7,0) imm32 in Thumb(BitsN.@@(BitsN.B(0xDE,8),imm8)) end else if not(e = Enc_Narrow) then let - val imm4 = BitsN.bits(imm32,15,12) - val imm12 = BitsN.bits(imm32,11,0) + val imm4 = BitsN.bits(15,12) imm32 + val imm12 = BitsN.bits(11,0) imm32 in Thumb2 (BitsN.@@(BitsN.B(0xF7F,12),imm4), @@ -23366,13 +23367,13 @@ fun p_ldm_stm (c,(load,(inc,(index,l)))) = (LoadMultipleExceptionReturn (inc, (index = inc, - (wb = ("!"),(rn,BitsN.bits(w,14,0))))))) + (wb = ("!"),(rn,BitsN.bits(14,0) w)))))) else if wb = ("") then OK(c, Load (LoadMultipleUserRegisters (inc, - (index = inc,(rn,BitsN.bits(w,14,0)))))) + (index = inc,(rn,BitsN.bits(14,0) w))))) else FAIL ("write-back not allowed for LDM (user registers)") else if wb = ("") @@ -24461,8 +24462,8 @@ fun EncodeThumb s = ("", Option.SOME (String.concat - [halfString(BitsN.bits(w,31,16))," ", - halfString(BitsN.bits(w,15,0))])) + [halfString(BitsN.bits(31,16) w)," ", + halfString(BitsN.bits(15,0) w)])) | PENDING _ => ("Contains label",NONE) | FAIL err => (("Parse error: ") ^ err,NONE); @@ -24697,7 +24698,7 @@ fun s_data (c,ast) = else (", #") ^ (Nat.toString shift_n))) | RegisterShiftedRegister(opc,(setflags,(d,(n,(m,(shift_t,s)))))) => let - val tstcmp = (BitsN.bits(opc,3,2)) = (BitsN.B(0x2,2)) + val tstcmp = (BitsN.bits(3,2) opc) = (BitsN.B(0x2,2)) in (String.concat [s_arith_logic opc, diff --git a/examples/l3-machine-code/arm/model/armAssemblerLib.sml b/examples/l3-machine-code/arm/model/armAssemblerLib.sml index 49be902672..337245814a 100644 --- a/examples/l3-machine-code/arm/model/armAssemblerLib.sml +++ b/examples/l3-machine-code/arm/model/armAssemblerLib.sml @@ -226,7 +226,7 @@ local fun code3 s = let val w = assemblerLib.word 32 s - val c = BitsN.bits (w, 31, 28) + val c = BitsN.bits (31, 28) w val () = arm.SetPassCondition c val h = StringCvt.padLeft #"0" 8 (L3.lowercase s) val (m, a) = arm.instructionToString (c, arm.DecodeARM w) @@ -345,7 +345,7 @@ local arm.Data (arm.RegisterShiftedRegister (opc', (setflags', (d', (n', (m', (shift_t', s')))))))) => opc = opc' andalso setflags = setflags' andalso - (BitsN.bits (opc, 3, 2) = BitsN.fromNat (2, 2) orelse d = d') + (BitsN.bits (3, 2) opc = BitsN.fromNat (2, 2) orelse d = d') andalso n = n' andalso m = m' andalso shift_t = shift_t' andalso s = s' | _ => false @@ -354,7 +354,7 @@ local fun test1 () = let val w = random32 () - val c = BitsN.bits (w, 31, 28) + val c = BitsN.bits (31, 28) w val i = arm.DecodeARM w val (m, a) = arm.instructionToString (c, i) val c = if c = BitsN.fromNat (15, 4) then BitsN.fromNat (14, 4) else c diff --git a/examples/l3-machine-code/arm8/model/arm8.sig b/examples/l3-machine-code/arm8/model/arm8.sig index 77926d606e..731c96d893 100644 --- a/examples/l3-machine-code/arm8/model/arm8.sig +++ b/examples/l3-machine-code/arm8/model/arm8.sig @@ -1,4 +1,4 @@ -(* arm8 - generated by L<3> - Mon Jan 12 16:38:36 2015 *) +(* arm8 - generated by L3 - Wed Jul 15 11:01:45 2015 *) signature arm8 = sig diff --git a/examples/l3-machine-code/arm8/model/arm8.sml b/examples/l3-machine-code/arm8/model/arm8.sml index 0dd964a212..517dd950bc 100644 --- a/examples/l3-machine-code/arm8/model/arm8.sml +++ b/examples/l3-machine-code/arm8/model/arm8.sml @@ -1,4 +1,4 @@ -(* arm8 - generated by L<3> - Mon Jan 12 16:38:36 2015 *) +(* arm8 - generated by L3 - Wed Jul 15 11:01:45 2015 *) structure arm8 :> arm8 = struct @@ -915,7 +915,7 @@ end fun rec'TCR_EL1 x = {TBI0 = BitsN.bit(x,37), TBI1 = BitsN.bit(x,38), - tcr_el1'rst = BitsN.@@(BitsN.bits(x,36,0),BitsN.bits(x,63,39))}; + tcr_el1'rst = BitsN.@@(BitsN.bits(36,0) x,BitsN.bits(63,39) x)}; fun reg'TCR_EL1 x = case x of @@ -1056,7 +1056,7 @@ fun write'reg'TCR_EL1 (_,x) = rec'TCR_EL1 x; fun rec'TCR_EL2_EL3 x = {TBI = BitsN.bit(x,20), - tcr_el2_el3'rst = BitsN.@@(BitsN.bits(x,19,0),BitsN.bits(x,31,21))}; + tcr_el2_el3'rst = BitsN.@@(BitsN.bits(19,0) x,BitsN.bits(31,21) x)}; fun reg'TCR_EL2_EL3 x = case x of @@ -1136,8 +1136,8 @@ fun rec'SCTLRType x = SA = BitsN.bit(x,3), SA0 = BitsN.bit(x,4), sctlrtype'rst = BitsN.concat - [BitsN.bits(x,0,0),BitsN.bits(x,2,2),BitsN.bits(x,23,5), - BitsN.bits(x,31,26)]}; + [BitsN.bits(0,0) x,BitsN.bits(2,2) x,BitsN.bits(23,5) x, + BitsN.bits(31,26) x]}; fun reg'SCTLRType x = case x of @@ -1283,36 +1283,38 @@ fun BranchTo (target0,branch_type) = BitsN.B(0x0,2) => ( if (BitsN.bit((!target),55)) andalso ((#TBI1) (!TCR_EL1)) then target := - (BitsN.bitFieldInsert - ((!target),BitsN.B(0xFF,8),63,56)) + (BitsN.bitFieldInsert(63,56) + ((!target),BitsN.B(0xFF,8))) else () ; if (not(BitsN.bit((!target),55))) andalso ((#TBI0) (!TCR_EL1)) then target := - (BitsN.bitFieldInsert((!target),BitsN.B(0x0,8),63,56)) + (BitsN.bitFieldInsert(63,56) + ((!target),BitsN.B(0x0,8))) else () ) | BitsN.B(0x1,2) => ( if (BitsN.bit((!target),55)) andalso ((#TBI1) (!TCR_EL1)) then target := - (BitsN.bitFieldInsert - ((!target),BitsN.B(0xFF,8),63,56)) + (BitsN.bitFieldInsert(63,56) + ((!target),BitsN.B(0xFF,8))) else () ; if (not(BitsN.bit((!target),55))) andalso ((#TBI0) (!TCR_EL1)) then target := - (BitsN.bitFieldInsert((!target),BitsN.B(0x0,8),63,56)) + (BitsN.bitFieldInsert(63,56) + ((!target),BitsN.B(0x0,8))) else () ) | BitsN.B(0x2,2) => if (#TBI) (!TCR_EL2) then target := - (BitsN.bitFieldInsert((!target),BitsN.B(0x0,8),63,56)) + (BitsN.bitFieldInsert(63,56) ((!target),BitsN.B(0x0,8))) else () | BitsN.B(0x3,2) => if (#TBI) (!TCR_EL3) then target := - (BitsN.bitFieldInsert((!target),BitsN.B(0x0,8),63,56)) + (BitsN.bitFieldInsert(63,56) ((!target),BitsN.B(0x0,8))) else () | _ => raise General.Bind ; PC := (!target) @@ -1402,14 +1404,14 @@ fun write'Mem N (value,(address,(size,acctype))) = (Map.update ((!MEM),BitsN.toNat x, BitsN.fromBitstring - (Bitstring.bits(value,Nat.+(Nat.*(8,i),7),Nat.*(8,i)),8))) + (Bitstring.bits(Nat.+(Nat.*(8,i),7),Nat.*(8,i)) value,8))) end) end; fun ConditionTest (cond,(N,(Z,(C,V)))) = let val result = - case BitsN.bits(cond,3,1) of + case BitsN.bits(3,1) cond of BitsN.B(0x0,3) => Z | BitsN.B(0x1,3) => C | BitsN.B(0x2,3) => N @@ -1460,10 +1462,10 @@ fun Poly32Mod2_loop (i,(data,poly)) = else let val data = if Bitstring.bit(data,i) - then (Bitstring.bits(data,Nat.-(List.length data,1),i)) + then (Bitstring.bits(Nat.-(List.length data,1),i) data) @ (Bitstring.?? - (Bitstring.bits(data,Nat.-(i,1),0), + (Bitstring.bits(Nat.-(i,1),0) data, L3.padRight(false,(i,poly)))) else data in @@ -1472,10 +1474,9 @@ fun Poly32Mod2_loop (i,(data,poly)) = fun Poly32Mod2 (data,poly) = BitsN.fromBitstring - (Bitstring.bits + (Bitstring.bits(31,0) (Poly32Mod2_loop - (Nat.-(List.length data,1),(data,BitsN.toBitstring poly)),31,0), - 32); + (Nat.-(List.length data,1),(data,BitsN.toBitstring poly))),32); fun AddWithCarry N (x,(y,carry_in)) = let @@ -1547,7 +1548,7 @@ fun ExtendValue N (value,(ty,sh)) = val len = Nat.min(len,Nat.-(BitsN.size(BitsN.B(0x0,N)),sh)) in Extend N - (Bitstring.<<(Bitstring.bits(value,Nat.-(len,1),0),sh),unsigned) + (Bitstring.<<(Bitstring.bits(Nat.-(len,1),0) value,sh),unsigned) end; fun ExtendReg N (reg,(ty,sh)) = ExtendValue N (X N reg,(ty,sh)); @@ -1569,7 +1570,7 @@ fun DecodeBitMasks M (immN,(imms,(immr,immediate))) = else let val diff = BitsN.toBitstring(BitsN.-(S,R)) val esize = Nat.pow(2,len) - val d = Bitstring.bits(diff,Nat.-(len,1),0) + val d = Bitstring.bits(Nat.-(len,1),0) diff val welem = L3.padLeft(false,(esize,Ones(Nat.+(BitsN.toNat S,1)))) val telem = @@ -1589,7 +1590,8 @@ fun dfn'Address (page,(imm,d)) = val base = ref (!PC) in ( if page - then base := (BitsN.bitFieldInsert((!base),BitsN.B(0x0,12),11,0)) + then base := + (BitsN.bitFieldInsert(11,0) ((!base),BitsN.B(0x0,12))) else () ; write'X 64 (BitsN.+((!base),imm),d) ) @@ -1711,7 +1713,7 @@ fun dfn'MoveWide N (sf,(opcode,(hw,(imm,d)))) = ( let val h = Nat.+(pos,15) in - result := (BitsN.bitFieldInsert((!result),imm,h,pos)) + result := (BitsN.bitFieldInsert(h,pos) ((!result),imm)) end ; let val result = @@ -1873,7 +1875,7 @@ fun dfn'MultiplyHigh (signed,(m,(n,d))) = (ExtendWord (64,128) (operand1,signed), ExtendWord (64,128) (operand2,signed)) in - write'X 64 (BitsN.bits(result,127,64),d) + write'X 64 (BitsN.bits(127,64) result,d) end; fun dfn'Reverse N (sf,(op',(n,d))) = @@ -1885,12 +1887,12 @@ fun dfn'Reverse N (sf,(op',(n,d))) = RevOp_RBIT => BitsN.reverse v | RevOp_REV16 => BitsN.concat - [BitsN.bits(v,23,16),BitsN.bits(v,31,24), - BitsN.bits(v,7,0),BitsN.bits(v,15,8)] + [BitsN.bits(23,16) v,BitsN.bits(31,24) v, + BitsN.bits(7,0) v,BitsN.bits(15,8) v] | RevOp_REV32 => BitsN.concat - [BitsN.bits(v,7,0),BitsN.bits(v,15,8), - BitsN.bits(v,23,16),BitsN.bits(v,31,24)] + [BitsN.bits(7,0) v,BitsN.bits(15,8) v, + BitsN.bits(23,16) v,BitsN.bits(31,24) v] | RevOp_REV64 => BitsN.B(0x0,32) in write'X 32 (result,d) @@ -1902,22 +1904,22 @@ fun dfn'Reverse N (sf,(op',(n,d))) = RevOp_RBIT => BitsN.reverse v | RevOp_REV16 => BitsN.concat - [BitsN.bits(v,55,48),BitsN.bits(v,63,56), - BitsN.bits(v,39,32),BitsN.bits(v,47,40), - BitsN.bits(v,23,16),BitsN.bits(v,31,24), - BitsN.bits(v,7,0),BitsN.bits(v,15,8)] + [BitsN.bits(55,48) v,BitsN.bits(63,56) v, + BitsN.bits(39,32) v,BitsN.bits(47,40) v, + BitsN.bits(23,16) v,BitsN.bits(31,24) v, + BitsN.bits(7,0) v,BitsN.bits(15,8) v] | RevOp_REV32 => BitsN.concat - [BitsN.bits(v,39,32),BitsN.bits(v,47,40), - BitsN.bits(v,55,48),BitsN.bits(v,63,56), - BitsN.bits(v,7,0),BitsN.bits(v,15,8), - BitsN.bits(v,23,16),BitsN.bits(v,31,24)] + [BitsN.bits(39,32) v,BitsN.bits(47,40) v, + BitsN.bits(55,48) v,BitsN.bits(63,56) v, + BitsN.bits(7,0) v,BitsN.bits(15,8) v, + BitsN.bits(23,16) v,BitsN.bits(31,24) v] | RevOp_REV64 => BitsN.concat - [BitsN.bits(v,7,0),BitsN.bits(v,15,8), - BitsN.bits(v,23,16),BitsN.bits(v,31,24), - BitsN.bits(v,39,32),BitsN.bits(v,47,40), - BitsN.bits(v,55,48),BitsN.bits(v,63,56)] + [BitsN.bits(7,0) v,BitsN.bits(15,8) v, + BitsN.bits(23,16) v,BitsN.bits(31,24) v, + BitsN.bits(39,32) v,BitsN.bits(47,40) v, + BitsN.bits(55,48) v,BitsN.bits(63,56) v] in write'X 64 (result,d) end; @@ -2258,11 +2260,11 @@ fun dfn'LoadStoreAcquirePair N val data = Mem N (address,(dbytes,acctype)) in if BigEndian () - then ( write'X 32 (BitsN.bits(data,63,32),t) - ; write'X 32 (BitsN.bits(data,31,0),t2) + then ( write'X 32 (BitsN.bits(63,32) data,t) + ; write'X 32 (BitsN.bits(31,0) data,t2) ) - else ( write'X 32 (BitsN.bits(data,31,0),t) - ; write'X 32 (BitsN.bits(data,63,32),t2) + else ( write'X 32 (BitsN.bits(31,0) data,t) + ; write'X 32 (BitsN.bits(63,32) data,t2) ) end else ( if not(Aligned 64 (address,dbytes)) @@ -6374,14 +6376,14 @@ fun e_data i = then ARM8 (BitsN.concat [e_sf 32 sf,BitsN.fromBit opc,BitsN.fromBit s, - BitsN.B(0x45,7),BitsN.bits(imm,23,12),rn,rd]) + BitsN.B(0x45,7),BitsN.bits(23,12) imm,rn,rd]) else BadCode("AddSubImmediate") else if (BitsN.&&(imm,BitsN.~(BitsN.B(0xFFF,32)))) = (BitsN.B(0x0,32)) then ARM8 (BitsN.concat [e_sf 32 sf,BitsN.fromBit opc,BitsN.fromBit s, - BitsN.B(0x44,7),BitsN.bits(imm,11,0),rn,rd]) + BitsN.B(0x44,7),BitsN.bits(11,0) imm,rn,rd]) else BadCode("AddSubImmediate")) | AddSubImmediate''64(sf,(opc,(s,(imm,(rn,rd))))) => (if (BitsN.&&(imm,BitsN.B(0xFFF,64))) = (BitsN.B(0x0,64)) @@ -6390,14 +6392,14 @@ fun e_data i = then ARM8 (BitsN.concat [e_sf 64 sf,BitsN.fromBit opc,BitsN.fromBit s, - BitsN.B(0x45,7),BitsN.bits(imm,23,12),rn,rd]) + BitsN.B(0x45,7),BitsN.bits(23,12) imm,rn,rd]) else BadCode("AddSubImmediate") else if (BitsN.&&(imm,BitsN.~(BitsN.B(0xFFF,64)))) = (BitsN.B(0x0,64)) then ARM8 (BitsN.concat [e_sf 64 sf,BitsN.fromBit opc,BitsN.fromBit s, - BitsN.B(0x44,7),BitsN.bits(imm,11,0),rn,rd]) + BitsN.B(0x44,7),BitsN.bits(11,0) imm,rn,rd]) else BadCode("AddSubImmediate")) | AddSubCarry''32(_,(opc,(s,(rm,(rn,rd))))) => ARM8 @@ -6666,7 +6668,7 @@ fun e_branch i = case i of BranchConditional(imm,cd) => let - val imm19 = BitsN.bits(imm,20,2) + val imm19 = BitsN.bits(20,2) imm in if imm = (BitsN.signExtend 64 (BitsN.@@(imm19,BitsN.B(0x0,2)))) then ARM8(BitsN.concat[BitsN.B(0x54,8),imm19,BitsN.B(0x0,1),cd]) @@ -6674,7 +6676,7 @@ fun e_branch i = end | BranchImmediate(imm,btype) => let - val imm26 = BitsN.bits(imm,27,2) + val imm26 = BitsN.bits(27,2) imm in if (imm = (BitsN.signExtend 64 (BitsN.@@(imm26,BitsN.B(0x0,2))))) andalso (Set.mem(btype,[BranchType_CALL,BranchType_JMP])) @@ -6702,7 +6704,7 @@ fun e_branch i = end | CompareAndBranch''32(_,(iszero,(offset,rt))) => let - val imm19 = BitsN.bits(offset,20,2) + val imm19 = BitsN.bits(20,2) offset in if offset = (BitsN.signExtend 64 (BitsN.@@(imm19,BitsN.B(0x0,2)))) then ARM8 @@ -6712,7 +6714,7 @@ fun e_branch i = end | CompareAndBranch''64(_,(iszero,(offset,rt))) => let - val imm19 = BitsN.bits(offset,20,2) + val imm19 = BitsN.bits(20,2) offset in if offset = (BitsN.signExtend 64 (BitsN.@@(imm19,BitsN.B(0x0,2)))) then ARM8 @@ -6722,7 +6724,7 @@ fun e_branch i = end | TestBitAndBranch''32(_,(bit_pos,(bit_val,(offset,rt)))) => let - val imm14 = BitsN.bits(offset,15,2) + val imm14 = BitsN.bits(15,2) offset in if (offset = (BitsN.signExtend 64 (BitsN.@@(imm14,BitsN.B(0x0,2))))) andalso @@ -6730,12 +6732,12 @@ fun e_branch i = then ARM8 (BitsN.concat [BitsN.B(0x1B,7),BitsN.fromBit bit_val, - BitsN.bits(bit_pos,4,0),imm14,rt]) + BitsN.bits(4,0) bit_pos,imm14,rt]) else BadCode("TestBitAndBranch32") end | TestBitAndBranch''64(_,(bit_pos,(bit_val,(offset,rt)))) => let - val imm14 = BitsN.bits(offset,15,2) + val imm14 = BitsN.bits(15,2) offset in if (offset = (BitsN.signExtend 64 (BitsN.@@(imm14,BitsN.B(0x0,2))))) andalso @@ -6743,7 +6745,7 @@ fun e_branch i = then ARM8 (BitsN.concat [BitsN.B(0x5B,7),BitsN.fromBit bit_val, - BitsN.bits(bit_pos,4,0),imm14,rt]) + BitsN.bits(4,0) bit_pos,imm14,rt]) else BadCode("TestBitAndBranch64") end; @@ -6780,8 +6782,8 @@ fun e_LoadStoreImmediate (signed,(wback,(postindex,(unsigned_offset,(offset,(rn,rt)))))))))) = let val sz = if memop = MemOp_PREFETCH then BitsN.B(0x3,2) else size - val imm9 = BitsN.bits(offset,8,0) - val imm12 = BitsN.bits(LSR 64 (offset,BitsN.toNat sz),11,0) + val imm9 = BitsN.bits(8,0) offset + val imm12 = BitsN.bits(11,0) (LSR 64 (offset,BitsN.toNat sz)) val opc = if memop = MemOp_STORE then BitsN.B(0x0,2) @@ -6918,7 +6920,7 @@ fun e_load_store i = (regsize_word,(memop,(signed,(rm,(extend_type,(shift,(rn,rt)))))))) | LoadLiteral''32(_,(memop,(signed,(offset,rt)))) => let - val imm19 = BitsN.bits(offset,20,2) + val imm19 = BitsN.bits(20,2) offset val opc = case (memop,signed) of (MemOp_LOAD,false) => Option.SOME(BitsN.B(0x0,2)) @@ -6935,7 +6937,7 @@ fun e_load_store i = end | LoadLiteral''64(_,(MemOp_LOAD,(false,(offset,rt)))) => let - val imm19 = BitsN.bits(offset,20,2) + val imm19 = BitsN.bits(20,2) offset in if offset = (BitsN.signExtend 64 (BitsN.@@(imm19,BitsN.B(0x0,2)))) then ARM8(BitsN.concat[BitsN.B(0x58,8),imm19,rt]) @@ -6952,7 +6954,7 @@ fun e_load_store i = let val sf = BitsN.fromNat(BitsN.toNat size,1) val scale = Nat.+(2,BitsN.toNat sf) - val imm7 = BitsN.bits(LSR 64 (offset,scale),6,0) + val imm7 = BitsN.bits(6,0) (LSR 64 (offset,scale)) in if ((((sf = (BitsN.B(0x1,1))) = ((BitsN.size size) = 64)) andalso (Set.mem(memop,[MemOp_LOAD,MemOp_STORE]))) andalso @@ -6975,7 +6977,7 @@ fun e_load_store i = let val sf = BitsN.fromNat(BitsN.toNat size,1) val scale = Nat.+(2,BitsN.toNat sf) - val imm7 = BitsN.bits(LSR 64 (offset,scale),6,0) + val imm7 = BitsN.bits(6,0) (LSR 64 (offset,scale)) in if ((((sf = (BitsN.B(0x1,1))) = ((BitsN.size size) = 64)) andalso (Set.mem(memop,[MemOp_LOAD,MemOp_STORE]))) andalso @@ -7120,8 +7122,8 @@ fun Encode i = Address(page,(imm,rd)) => (if page then let - val immlo = BitsN.bits(imm,13,12) - val immhi = BitsN.bits(imm,32,14) + val immlo = BitsN.bits(13,12) imm + val immhi = BitsN.bits(32,14) imm in if (BitsN.signExtend 64 (BitsN.concat[immhi,immlo,BitsN.B(0x0,12)])) = imm @@ -7131,8 +7133,8 @@ fun Encode i = else BadCode("Address") end else let - val immlo = BitsN.bits(imm,1,0) - val immhi = BitsN.bits(imm,20,2) + val immlo = BitsN.bits(1,0) imm + val immhi = BitsN.bits(20,2) imm in if (BitsN.signExtend 64 (BitsN.@@(immhi,immlo))) = imm then ARM8 @@ -8429,27 +8431,27 @@ fun wzr_xzr s = if is_wide_reg s then "xzr" else "wzr"; fun convert_immediate (wide,imm) = if wide - then if (BitsN.bits(imm,63,16)) = (BitsN.B(0x0,48)) - then [("#0x") ^ (BitsN.toHexString(BitsN.bits(imm,15,0))), + then if (BitsN.bits(63,16) imm) = (BitsN.B(0x0,48)) + then [("#0x") ^ (BitsN.toHexString(BitsN.bits(15,0) imm)), "lsl #0"] else if (BitsN.&&(imm,BitsN.B(0xFFFFFFFF0000FFFF,64))) = (BitsN.B(0x0,64)) - then [("#0x") ^ (BitsN.toHexString(BitsN.bits(imm,31,16))), + then [("#0x") ^ (BitsN.toHexString(BitsN.bits(31,16) imm)), "lsl #16"] else if (BitsN.&&(imm,BitsN.B(0xFFFF0000FFFFFFFF,64))) = (BitsN.B(0x0,64)) - then [("#0x") ^ (BitsN.toHexString(BitsN.bits(imm,47,32))), + then [("#0x") ^ (BitsN.toHexString(BitsN.bits(47,32) imm)), "lsl #32"] - else if (BitsN.bits(imm,47,0)) = (BitsN.B(0x0,48)) - then [("#0x") ^ (BitsN.toHexString(BitsN.bits(imm,63,48))), + else if (BitsN.bits(47,0) imm) = (BitsN.B(0x0,48)) + then [("#0x") ^ (BitsN.toHexString(BitsN.bits(63,48) imm)), "lsl #48"] else [] - else if (BitsN.bits(imm,63,32)) = (BitsN.B(0x0,32)) - then if (BitsN.bits(imm,31,16)) = (BitsN.B(0x0,16)) - then [("#0x") ^ (BitsN.toHexString(BitsN.bits(imm,15,0))), + else if (BitsN.bits(63,32) imm) = (BitsN.B(0x0,32)) + then if (BitsN.bits(31,16) imm) = (BitsN.B(0x0,16)) + then [("#0x") ^ (BitsN.toHexString(BitsN.bits(15,0) imm)), "lsl #0"] - else if (BitsN.bits(imm,15,0)) = (BitsN.B(0x0,16)) - then [("#0x") ^ (BitsN.toHexString(BitsN.bits(imm,31,16))), + else if (BitsN.bits(15,0) imm) = (BitsN.B(0x0,16)) + then [("#0x") ^ (BitsN.toHexString(BitsN.bits(31,16) imm)), "lsl #16"] else [] else []; @@ -8969,7 +8971,7 @@ fun s_shifted_imm N imm = val top = BitsN.>>+(imm,12) in if (not(top = (BitsN.B(0x0,N)))) andalso - ((BitsN.bits(imm,11,0)) = (BitsN.B(0x0,12))) + ((BitsN.bits(11,0) imm) = (BitsN.B(0x0,12))) then (s_imm N top) ^ (", lsl #12") else s_imm N imm end; @@ -9476,12 +9478,12 @@ fun s_data ast = String.concat[s_reg3z(wide,(d,(n,m))),", ",s_cond cd]) | (false,true) => if ((n = m) andalso (not(n = (BitsN.B(0x1F,5))))) andalso - (not((BitsN.bits(cd,3,1)) = (BitsN.B(0x7,3)))) + (not((BitsN.bits(3,1) cd) = (BitsN.B(0x7,3)))) then ("cinc", String.concat [s_reg2z(wide,(d,n)),", ",invert_cond(s_cond cd)]) else if ((n = m) andalso (n = (BitsN.B(0x1F,5)))) andalso - (not((BitsN.bits(cd,3,1)) = (BitsN.B(0x7,3)))) + (not((BitsN.bits(3,1) cd) = (BitsN.B(0x7,3)))) then ("cset", String.concat [s_regz(wide,d),", ",invert_cond(s_cond cd)]) @@ -9489,12 +9491,12 @@ fun s_data ast = String.concat[s_reg3z(wide,(d,(n,m))),", ",s_cond cd]) | (true,false) => if ((n = m) andalso (not(n = (BitsN.B(0x1F,5))))) andalso - (not((BitsN.bits(cd,3,1)) = (BitsN.B(0x7,3)))) + (not((BitsN.bits(3,1) cd) = (BitsN.B(0x7,3)))) then ("cinv", String.concat [s_reg2z(wide,(d,n)),", ",invert_cond(s_cond cd)]) else if ((n = m) andalso (n = (BitsN.B(0x1F,5)))) andalso - (not((BitsN.bits(cd,3,1)) = (BitsN.B(0x7,3)))) + (not((BitsN.bits(3,1) cd) = (BitsN.B(0x7,3)))) then ("csetm", String.concat [s_regz(wide,d),", ",invert_cond(s_cond cd)]) @@ -9502,7 +9504,7 @@ fun s_data ast = String.concat[s_reg3z(wide,(d,(n,m))),", ",s_cond cd]) | (true,true) => if (n = m) andalso - (not((BitsN.bits(cd,3,1)) = (BitsN.B(0x7,3)))) + (not((BitsN.bits(3,1) cd) = (BitsN.B(0x7,3)))) then ("cneg", String.concat [s_reg2z(wide,(d,n)),", ",invert_cond(s_cond cd)]) @@ -9519,12 +9521,12 @@ fun s_data ast = String.concat[s_reg3z(wide,(d,(n,m))),", ",s_cond cd]) | (false,true) => if ((n = m) andalso (not(n = (BitsN.B(0x1F,5))))) andalso - (not((BitsN.bits(cd,3,1)) = (BitsN.B(0x7,3)))) + (not((BitsN.bits(3,1) cd) = (BitsN.B(0x7,3)))) then ("cinc", String.concat [s_reg2z(wide,(d,n)),", ",invert_cond(s_cond cd)]) else if ((n = m) andalso (n = (BitsN.B(0x1F,5)))) andalso - (not((BitsN.bits(cd,3,1)) = (BitsN.B(0x7,3)))) + (not((BitsN.bits(3,1) cd) = (BitsN.B(0x7,3)))) then ("cset", String.concat [s_regz(wide,d),", ",invert_cond(s_cond cd)]) @@ -9532,12 +9534,12 @@ fun s_data ast = String.concat[s_reg3z(wide,(d,(n,m))),", ",s_cond cd]) | (true,false) => if ((n = m) andalso (not(n = (BitsN.B(0x1F,5))))) andalso - (not((BitsN.bits(cd,3,1)) = (BitsN.B(0x7,3)))) + (not((BitsN.bits(3,1) cd) = (BitsN.B(0x7,3)))) then ("cinv", String.concat [s_reg2z(wide,(d,n)),", ",invert_cond(s_cond cd)]) else if ((n = m) andalso (n = (BitsN.B(0x1F,5)))) andalso - (not((BitsN.bits(cd,3,1)) = (BitsN.B(0x7,3)))) + (not((BitsN.bits(3,1) cd) = (BitsN.B(0x7,3)))) then ("csetm", String.concat [s_regz(wide,d),", ",invert_cond(s_cond cd)]) @@ -9545,7 +9547,7 @@ fun s_data ast = String.concat[s_reg3z(wide,(d,(n,m))),", ",s_cond cd]) | (true,true) => if (n = m) andalso - (not((BitsN.bits(cd,3,1)) = (BitsN.B(0x7,3)))) + (not((BitsN.bits(3,1) cd) = (BitsN.B(0x7,3)))) then ("cneg", String.concat [s_reg2z(wide,(d,n)),", ",invert_cond(s_cond cd)]) diff --git a/examples/l3-machine-code/lib/BitsN.sig b/examples/l3-machine-code/lib/BitsN.sig index 171eae6df6..029a638333 100644 --- a/examples/l3-machine-code/lib/BitsN.sig +++ b/examples/l3-machine-code/lib/BitsN.sig @@ -63,8 +63,8 @@ sig val UINT_MAX: Nat.nat -> nbit val abs: nbit -> nbit val bit: nbit * Nat.nat -> bool - val bitFieldInsert: nbit * nbit * Nat.nat * Nat.nat -> nbit - val bits: nbit * Nat.nat * Nat.nat -> nbit + val bitFieldInsert: Nat.nat * Nat.nat -> nbit * nbit -> nbit + val bits: Nat.nat * Nat.nat -> nbit -> nbit val concat: nbit list -> nbit val div: nbit * nbit -> nbit val fromList: bool list -> nbit diff --git a/examples/l3-machine-code/lib/BitsN.sml b/examples/l3-machine-code/lib/BitsN.sml index a72e095fd2..e54a18d851 100644 --- a/examples/l3-machine-code/lib/BitsN.sml +++ b/examples/l3-machine-code/lib/BitsN.sml @@ -11,19 +11,19 @@ struct datatype nbit = B of (int * Nat.nat) - fun checkSize s = if s = Nat.zero then raise Fail "Size must be >= 1." else s fun size (B (_, s)) = s fun dim s = IntInf.<< (1, Word.fromInt s) - fun modDim s n = IntInf.andb (n, dim s - 1) + fun pdim s = dim s - 1 + fun modDim s n = IntInf.andb (n, pdim s) - fun UINT_MAX s = B (dim s - 1, checkSize s) - fun INT_MIN s = B (dim (s - 1), checkSize s) - fun INT_MAX s = B (dim (s - 1) - 1, checkSize s) - fun zero s = B (0, checkSize s) - fun one s = B (1, checkSize s) + fun UINT_MAX s = B (pdim s, s) + fun INT_MIN s = B (dim (s - 1), s) + fun INT_MAX s = B (pdim (s - 1), s) + fun zero s = B (0, s) + fun one s = B (1, s) - fun fromInt (n, s) = B (modDim s n, checkSize s) + fun fromInt (n, s) = B (modDim s n, s) fun fromNat (n, s) = fromInt (Nat.toInt n, s) fun toNat (B (i, _)) = Nat.fromInt i val toUInt = Nat.toInt o toNat @@ -62,18 +62,17 @@ struct ; w end) (Nat.fromLit s) - fun bits (B (i, s), h, l) = + fun bits (h,l) = let val w = h + 1 - l + val l = Word.fromInt l + val mask = pdim w in - 0 < w andalso 0 <= l andalso h < s orelse - raise Fail ("bits invalid: (" ^ Nat.toString s ^ "-bit)<" ^ - Nat.toString h ^ ":" ^ Nat.toString l ^ ">") - ; B (modDim w (IntInf.~>> (i, Word.fromInt l)), w) + fn B (i, _) => B (IntInf.andb (mask,IntInf.~>> (i, l)), w) end - fun bit (a, n) = bits (a, n, n) = B (1, 1) - fun lsb (B (a, _)) = IntInf.andb (a, 1) = 1 + fun bit (B (a, _), n) = Int.rem (IntInf.~>> (a, Word.fromInt n), 2) = 1 + fun lsb (B (a, _)) = Int.rem (a, 2) = 1 fun msb a = bit (a, Nat.- (size a, Nat.one)) fun neg (B (a, s)) = B (modDim s (Int.- (dim s, a)), s) @@ -109,40 +108,32 @@ struct val fromHexString = fromBaseString (IntExtra.fromHexString, Nat.fromHexString) - fun toList (B (a, s)) = - let - fun iter (l, n, b) = - if b <= 0 orelse n = 0 - then List.tabulate (b, fn _ => false) @ l - else let - val (r, v) = IntInf.divMod (n, 2) - in - iter ((v = 1) :: l, r, b - 1) - end - in - iter ([], a, Nat.toInt s) - end - - fun fromList l = - let - val s = List.length l - val _ = 0 < s orelse raise Fail ("List must be non-empty") - fun iter a = - fn [] => a - | (h::t) => iter (2 * a + (if h then 1 else 0)) t - in - B (iter 0 l, Nat.fromInt s) - end + local + fun iter (l, n, b) = + if n = 0 orelse b <= 0 + then Bitstring.zero b @ l + else let + val (r, v) = IntInf.quotRem (n, 2) + in + iter ((v = 1) :: l, r, b - 1) + end + in + fun toList (B (a, s)) = iter ([], a, Nat.toInt s) + end + + local + fun iter a = + fn [] => a + | (false::t) => iter (IntInf.<< (a, 0w1)) t + | (true::t) => iter (IntInf.orb (IntInf.<< (a, 0w1), 1)) t + in + fun fromList l = B (iter 0 l, Nat.fromInt (List.length l)) + end fun modify (f: Nat.nat * bool -> bool, a) = - let - val s = Nat.toInt (size a) - val l = toList a - val n = List.tabulate (s, fn i => Nat.fromInt (s - 1 - i)) - val z = ListPair.zip (n, l) - in - fromList (List.map f z) - end + fromList + (#1 (List.foldr (fn (b, (l, i)) => (f (i, b) :: l, i + 1)) ([], 0) + (toList a))) fun tabulate (s, f: Nat.nat -> bool) = let @@ -156,17 +147,10 @@ struct fun log2 (B (a, s)) = B (IntInf.log2 a, s) - fun zeroExtend s2 (B (n, s1)) = - if Nat.<= (s1, s2) - then B (n, s2) - else raise Fail ("Bad zeroExtend: `" ^ Nat.toString s1 ^ " -> `" ^ - Nat.toString s2) + fun zeroExtend s (B (n, _)) = B (n, s) fun signExtend s2 (a as B (n, s1)) = - if Nat.<= (s1, s2) - then B (Int.+ (if msb a then (Int.- (dim s2, dim s1)) else 0, n), s2) - else raise Fail ("Bad signExtend: `" ^ Nat.toString s1 ^ " -> `" ^ - Nat.toString s2) + B (Int.+ (if msb a then (Int.- (dim s2, dim s1)) else 0, n), s2) fun op @@ (a as B (v1, s1), b as B (v2, s2)) = B (IntInf.orb (IntInf.<< (v1, Word.fromInt s2), v2), Int.+ (s1, s2)) @@ -186,85 +170,46 @@ struct fun resize_replicate i = resize i o replicate - fun bitFieldInsert (x, y, h, l) = - modify (fn (i, b) => - if Nat.<= (l, i) andalso Nat.<= (i, h) - then bit (y, Nat.- (i, l)) - else b, x) - - fun checkSameSize opn = + fun bitFieldInsert (h,l) = let - val err = opn ^ " : Bit widths do not match: " + val dl = dim l + val dh = dim (h + 1) + val wl = Word.fromInt l in - fn (s1, s2) => - s1 = s2 orelse - raise Fail (err ^ Nat.toString s1 ^ " <> " ^ Nat.toString s2) + fn (B (v, s), B (w, _)) => + let + val mask = Int.max (Int.min (dim s, dh) - dl, 0) + val w' = IntInf.<< (w, wl) + in + B (IntInf.orb (IntInf.andb (IntInf.notb mask, v), + IntInf.andb (mask, w')), s) + end end - fun op <+ (B (v1, s1), B (v2, s2)) = - ( checkSameSize "<+" (s1, s2); Int.< (v1, v2) ) - - fun op <=+ (B (v1, s1), B (v2, s2)) = - ( checkSameSize "<=+" (s1, s2); Int.<= (v1, v2) ) - - fun op >+ (B (v1, s1), B (v2, s2)) = - ( checkSameSize ">+" (s1, s2); Int.> (v1, v2) ) + fun op <+ (B (v1, _), B (v2, _)) = Int.< (v1, v2) + fun op <=+ (B (v1, _), B (v2, _)) = Int.<= (v1, v2) + fun op >+ (B (v1, _), B (v2, _)) = Int.> (v1, v2) + fun op >=+ (B (v1, _), B (v2, _)) = Int.>= (v1, v2) - fun op >=+ (B (v1, s1), B (v2, s2)) = - ( checkSameSize ">=+" (s1, s2); Int.>= (v1, v2) ) + fun op < (w1, w2) = Int.< (toInt w1, toInt w2) + fun op <= (w1, w2) = Int.<= (toInt w1, toInt w2) + fun op > (w1, w2) = Int.> (toInt w1, toInt w2) + fun op >= (w1, w2) = Int.>= (toInt w1, toInt w2) - fun op < (w1 as B (_, s1), w2 as B (_, s2)) = - ( checkSameSize "<" (s1, s2); Int.< (toInt w1, toInt w2) ) + fun op && (B (v1, _), B (v2, s)) = B (IntInf.andb (v1, v2), s) + fun op || (B (v1, _), B (v2, s)) = B (IntInf.orb (v1, v2), s) + fun op ?? (B (v1, _), B (v2, s)) = B (IntInf.xorb (v1, v2), s) + fun op div (B (v1, _), B (v2, s)) = B (Int.div (v1, v2), s) + fun op mod (B (v1, _), B (v2, s)) = B (Int.mod (v1, v2), s) - fun op <= (w1 as B (_, s1), w2 as B (_, s2)) = - ( checkSameSize "<=" (s1, s2); Int.<= (toInt w1, toInt w2) ) + fun op quot (a, b as B (_, s)) = fromInt (Int.quot (toInt a, toInt b), s) + fun op rem (a, b as B (_, s)) = fromInt (Int.rem (toInt a, toInt b), s) - fun op > (w1 as B (_, s1), w2 as B (_, s2)) = - ( checkSameSize ">" (s1, s2); Int.> (toInt w1, toInt w2) ) + fun min (B (v1, _), B (v2, s)) = B (Int.min (v1, v2), s) + fun max (B (v1, _), B (v2, s)) = B (Int.max (v1, v2), s) - fun op >= (w1 as B (_, s1), w2 as B (_, s2)) = - ( checkSameSize ">=" (s1, s2); Int.>= (toInt w1, toInt w2) ) - - fun op && (B (v1, s1), B (v2, s2)) = - ( checkSameSize "&&" (s1, s2); B (IntInf.andb (v1, v2), s1) ) - - fun op || (B (v1, s1), B (v2, s2)) = - ( checkSameSize "||" (s1, s2); B (IntInf.orb (v1, v2), s1) ) - - fun op ?? (B (v1, s1), B (v2, s2)) = - ( checkSameSize "??" (s1, s2); B (IntInf.xorb (v1, v2), s1) ) - - fun op div (B (v1, s1), B (v2, s2)) = - ( checkSameSize "div" (s1, s2); B (Int.div (v1, v2), s1) ) - - fun op mod (B (v1, s1), B (v2, s2)) = - ( checkSameSize "mod" (s1, s2); B (Int.mod (v1, v2), s1) ) - - fun op quot (a as B (_, s1), b as B (_, s2)) = - ( checkSameSize "quot" (s1, s2) - ; fromInt (Int.quot (toInt a, toInt b), s1) - ) - - fun op rem (a as B (_, s1), b as B (_, s2)) = - ( checkSameSize "quot" (s1, s2) - ; fromInt (Int.rem (toInt a, toInt b), s1) - ) - - fun min (B (v1, s1), B (v2, s2)) = - ( checkSameSize "min" (s1, s2); B (Int.min (v1, v2), s1) ) - - fun max (B (v1, s1), B (v2, s2)) = - ( checkSameSize "max" (s1, s2); B (Int.max (v1, v2), s1) ) - - fun smin (w1 as B (_, s1), w2 as B (_, s2)) = - ( checkSameSize "smin" (s1, s2) - ; fromInt (Int.min (toInt w1, toInt w2), s1) - ) - - fun smax (w1 as B (_, s1), w2 as B (_, s2)) = - ( checkSameSize "smax" (s1, s2) - ; fromInt (Int.max (toInt w1, toInt w2), s1) - ) + fun smin (w1, w2 as B (_, s)) = fromInt (Int.min (toInt w1, toInt w2), s) + fun smax (w1, w2 as B (_, s)) = fromInt (Int.max (toInt w1, toInt w2), s) fun op << (B (v, s), n) = B (modDim s (IntInf.<< (v, Word.fromInt (Int.min (n, s)))), s) @@ -281,31 +226,19 @@ struct open Nat val x = n mod s in - if x = 0 then a else bits (a, pred x, zero) @@ bits (a, pred s, x) + if x = 0 then a else bits (pred x, zero) a @@ bits (pred s, x) a end fun op #<< (a as B (_, s), n) = let open Nat in a #>> (s - n mod s) end - fun op <<^ (w as B (_, s1), v as B (_, s2)) = - ( checkSameSize "<<^" (s1, s2); w << toNat v ) - - fun op >>^ (w as B (_, s1), v as B (_, s2)) = - ( checkSameSize ">>^" (s1, s2); w >> toNat v ) - - fun op >>+^ (w as B (_, s1), v as B (_, s2)) = - ( checkSameSize ">>+^" (s1, s2); w >>+ toNat v ) - - fun op #>>^ (w as B (_, s1), v as B (_, s2)) = - ( checkSameSize "#>>^" (s1, s2); w #>> toNat v ) - - fun op #<<^ (w as B (_, s1), v as B (_, s2)) = - ( checkSameSize "#<<^" (s1, s2); w #<< toNat v ) - - fun op * (B (v1, s1), B (v2, s2)) = - ( checkSameSize "*" (s1, s2); B (modDim s1 (Int.* (v1, v2)), s1) ) + fun op <<^ (w, v) = w << toNat v + fun op >>^ (w, v) = w >> toNat v + fun op >>+^ (w, v) = w >>+ toNat v + fun op #>>^ (w, v) = w #>> toNat v + fun op #<<^ (w, v) = w #<< toNat v - fun op + (B (v1, s1), B (v2, s2)) = - ( checkSameSize "+" (s1, s2); B (modDim s1 (Int.+ (v1, v2)), s1) ) + fun op * (B (v1, _), B (v2, s)) = B (modDim s (Int.* (v1, v2)), s) + fun op + (B (v1, _), B (v2, s)) = B (modDim s (Int.+ (v1, v2)), s) fun op ~ (B (a, s)) = B (modDim s (IntInf.notb a), s) diff --git a/examples/l3-machine-code/lib/Bitstring.sig b/examples/l3-machine-code/lib/Bitstring.sig index af98d3d70d..8deeef7f3b 100644 --- a/examples/l3-machine-code/lib/Bitstring.sig +++ b/examples/l3-machine-code/lib/Bitstring.sig @@ -25,7 +25,7 @@ sig val toList: bitstring -> bool list val fromList: bool list -> bitstring - val bitFieldInsert: bitstring * bitstring * Nat.nat * Nat.nat -> bitstring + val bitFieldInsert: Nat.nat * Nat.nat -> bitstring * bitstring -> bitstring val modify: (Nat.nat * bool -> bool) -> bitstring -> bitstring val zero: Nat.nat -> bitstring @@ -35,7 +35,7 @@ sig val setSize: int -> bitstring -> bitstring val replicate: bitstring * Nat.nat -> bitstring - val bits: bitstring * Nat.nat * Nat.nat -> bitstring + val bits: Nat.nat * Nat.nat -> bitstring -> bitstring val bit: bitstring * Nat.nat -> bool val << : bitstring * Nat.nat -> bitstring diff --git a/examples/l3-machine-code/lib/Bitstring.sml b/examples/l3-machine-code/lib/Bitstring.sml index f3856c684d..944b6a6516 100644 --- a/examples/l3-machine-code/lib/Bitstring.sml +++ b/examples/l3-machine-code/lib/Bitstring.sml @@ -17,20 +17,18 @@ struct val compare = L3.listCompare boolCompare fun zero n = List.tabulate (Nat.toInt n, fn _ => false) - - fun one n = - let - val i = Nat.toInt n - in - if i = 0 - then [] - else List.tabulate (i - 1, fn _ => false) @ [true] - end + fun one n = if n < 1 then [] else zero (n - 1) @ [true] val size: bitstring -> Nat.nat = Nat.fromInt o List.length local - fun iter a i = if i <= 0 then a else iter ((i mod 2 = 1) :: a) (i div 2) + fun iter a i = + if i <= 0 then a + else let + val (q, r) = IntInf.quotRem (i, 2) + in + iter ((r = 1) :: a) q + end in fun fromInt i = if i < 0 @@ -92,10 +90,10 @@ struct val v = String.extract (s, 1, NONE) in case String.sub (s, 0) of - #"d" => fromDecString v - | #"b" => fromBinString v - | #"x" => fromHexString v - | _ => NONE + #"d" => fromDecString v + | #"b" => fromBinString v + | #"x" => fromHexString v + | _ => NONE end val toBinString = String.implode o List.map (fn false => #"0" | true => #"1") @@ -140,15 +138,9 @@ struct fun fromList l = l fun modify (f: Nat.nat * bool -> bool) a = - let - val s = List.length a - val n = List.tabulate (s, fn i => Nat.fromInt (s - 1 - i)) - val z = ListPair.zip (n, a) - in - List.map f z - end + #1 (List.foldr (fn (b, (l, i)) => (f (i, b) :: l, i + 1)) ([], 0) a) - fun op << (l, s) = l @ List.tabulate (Nat.toInt s, fn _ => false) + fun op << (l, s) = l @ zero s fun op >>+ (l, s) = List.take (l, List.length l - Nat.toInt s) handle General.Subscript => [] @@ -165,26 +157,23 @@ struct let val n = List.length l in - if n < s - then List.tabulate (s - n, fn _ => false) @ l - else List.drop (l, n - s) + if n < s then zero (s - n) @ l else List.drop (l, n - s) end - fun bits (b, h, l) = + fun bits (h, l) = let val s = Nat.- (Nat.suc h, l) in - if s = Nat.zero then [false] else setSize (Nat.toInt s) (b >>+ l) + fn b => + if s = Nat.zero then [false] else setSize (Nat.toInt s) (b >>+ l) end - fun bit (a, n) = bits (a, n, n) = [true] + fun bit (a, n) = bits (n, n) a = [true] - fun bitFieldInsert (x, y, h, l) = - modify - (fn (i, b) => - if Nat.<= (l, i) andalso Nat.<= (i, h) - then bit (y, Nat.- (i, l)) - else b) x + fun bitFieldInsert (h,l) (x, y) = + modify (fn (i, b) => if Nat.<= (l, i) andalso Nat.<= (i, h) + then bit (y, Nat.- (i, l)) + else b) x fun maxLength (l1, l2) = Int.max (List.length l1, List.length l2) diff --git a/examples/l3-machine-code/lib/FP64.sml b/examples/l3-machine-code/lib/FP64.sml index 329e8ca29e..83755659ed 100644 --- a/examples/l3-machine-code/lib/FP64.sml +++ b/examples/l3-machine-code/lib/FP64.sml @@ -5,14 +5,14 @@ structure FP64 :> FP64 = struct - val byte = Word8.fromInt o BitsN.toNat o BitsN.bits + val byte = Word8.fromInt o BitsN.toNat o L3.uncurry BitsN.bits fun unbyte b = BitsN.fromNat (Word8.toInt b, 8) fun bitsToReal w = ( BitsN.size w = 64 orelse raise Fail "bitsToReal: not 64-bit word" ; (PackRealBig.fromBytes o Word8Vector.fromList o List.rev) (List.tabulate - (8, fn i => let val j = 8 * i in byte (w, j + 7, j) end)) + (8, fn i => let val j = 8 * i in byte ((j + 7, j), w) end)) ) fun realToBits r = diff --git a/examples/l3-machine-code/m0/model/m0.sig b/examples/l3-machine-code/m0/model/m0.sig index 168fac2e3b..8126d09406 100644 --- a/examples/l3-machine-code/m0/model/m0.sig +++ b/examples/l3-machine-code/m0/model/m0.sig @@ -1,4 +1,4 @@ -(* m0 - generated by L<3> - Tue Nov 18 15:29:59 2014 *) +(* m0 - generated by L3 - Wed Jul 15 10:42:46 2015 *) signature m0 = sig diff --git a/examples/l3-machine-code/m0/model/m0.sml b/examples/l3-machine-code/m0/model/m0.sml index b2d39badd9..0ceb3eb0d5 100644 --- a/examples/l3-machine-code/m0/model/m0.sml +++ b/examples/l3-machine-code/m0/model/m0.sml @@ -1,4 +1,4 @@ -(* m0 - generated by L<3> - Tue Nov 18 15:29:59 2014 *) +(* m0 - generated by L3 - Wed Jul 15 10:42:46 2015 *) structure m0 :> m0 = struct @@ -515,7 +515,7 @@ in end fun rec'PRIMASK x = - {PM = BitsN.bit(x,0), primask'rst = BitsN.bits(x,31,1)}; + {PM = BitsN.bit(x,0), primask'rst = BitsN.bits(31,1) x}; fun reg'PRIMASK x = case x of @@ -590,10 +590,10 @@ fun write'rec'PRIMASK (_,x) = reg'PRIMASK x; fun write'reg'PRIMASK (_,x) = rec'PRIMASK x; fun rec'PSR x = - {C = BitsN.bit(x,29), ExceptionNumber = BitsN.bits(x,5,0), + {C = BitsN.bit(x,29), ExceptionNumber = BitsN.bits(5,0) x, N = BitsN.bit(x,31), T = BitsN.bit(x,24), V = BitsN.bit(x,28), Z = BitsN.bit(x,30), - psr'rst = BitsN.@@(BitsN.bits(x,23,6),BitsN.bits(x,27,25))}; + psr'rst = BitsN.@@(BitsN.bits(23,6) x,BitsN.bits(27,25) x)}; fun reg'PSR x = case x of @@ -687,8 +687,8 @@ fun write'reg'CONTROL (_,x) = rec'CONTROL x; fun rec'AIRCR x = {ENDIANNESS = BitsN.bit(x,15), SYSRESETREQ = BitsN.bit(x,2), - VECTCLRACTIVE = BitsN.bit(x,1), VECTKEY = BitsN.bits(x,31,16), - aircr'rst = BitsN.@@(BitsN.bits(x,0,0),BitsN.bits(x,14,3))}; + VECTCLRACTIVE = BitsN.bit(x,1), VECTKEY = BitsN.bits(31,16) x, + aircr'rst = BitsN.@@(BitsN.bits(0,0) x,BitsN.bits(14,3) x)}; fun reg'AIRCR x = case x of @@ -767,7 +767,7 @@ fun write'reg'AIRCR (_,x) = rec'AIRCR x; fun rec'CCR x = {STKALIGN = BitsN.bit(x,9), UNALIGN_TRP = BitsN.bit(x,3), ccr'rst = - BitsN.concat[BitsN.bits(x,2,0),BitsN.bits(x,8,4),BitsN.bits(x,31,10)]}; + BitsN.concat[BitsN.bits(2,0) x,BitsN.bits(8,4) x,BitsN.bits(31,10) x]}; fun reg'CCR x = case x of @@ -843,7 +843,7 @@ fun write'rec'CCR (_,x) = reg'CCR x; fun write'reg'CCR (_,x) = rec'CCR x; fun rec'SHPR2 x = - {PRI_11 = BitsN.bits(x,31,30), shpr2'rst = BitsN.bits(x,29,0)}; + {PRI_11 = BitsN.bits(31,30) x, shpr2'rst = BitsN.bits(29,0) x}; fun reg'SHPR2 x = case x of @@ -919,8 +919,8 @@ fun write'rec'SHPR2 (_,x) = reg'SHPR2 x; fun write'reg'SHPR2 (_,x) = rec'SHPR2 x; fun rec'SHPR3 x = - {PRI_14 = BitsN.bits(x,23,22), PRI_15 = BitsN.bits(x,31,30), - shpr3'rst = BitsN.@@(BitsN.bits(x,21,0),BitsN.bits(x,29,24))}; + {PRI_14 = BitsN.bits(23,22) x, PRI_15 = BitsN.bits(31,30) x, + shpr3'rst = BitsN.@@(BitsN.bits(21,0) x,BitsN.bits(29,24) x)}; fun reg'SHPR3 x = case x of @@ -996,12 +996,12 @@ fun write'rec'SHPR3 (_,x) = reg'SHPR3 x; fun write'reg'SHPR3 (_,x) = rec'SHPR3 x; fun rec'IPR x = - {PRI_N0 = BitsN.bits(x,7,6), PRI_N1 = BitsN.bits(x,15,14), - PRI_N2 = BitsN.bits(x,23,22), PRI_N3 = BitsN.bits(x,31,30), + {PRI_N0 = BitsN.bits(7,6) x, PRI_N1 = BitsN.bits(15,14) x, + PRI_N2 = BitsN.bits(23,22) x, PRI_N3 = BitsN.bits(31,30) x, ipr'rst = BitsN.concat - [BitsN.bits(x,5,0),BitsN.bits(x,13,8),BitsN.bits(x,21,16), - BitsN.bits(x,29,24)]}; + [BitsN.bits(5,0) x,BitsN.bits(13,8) x,BitsN.bits(21,16) x, + BitsN.bits(29,24) x]}; fun reg'IPR x = case x of @@ -1082,7 +1082,7 @@ fun ProcessorID () = 0; fun ConditionPassed cond = let val result = - case BitsN.bits(cond,3,1) of + case BitsN.bits(3,1) cond of BitsN.B(0x0,3) => (#Z) (!PSR) | BitsN.B(0x1,3) => (#C) (!PSR) | BitsN.B(0x2,3) => (#N) (!PSR) @@ -1130,7 +1130,7 @@ fun write'R (value,n) = REG := (Map.update ((!REG),Cast.RNameToNat x, - BitsN.@@(BitsN.bits(value,31,2),BitsN.B(0x0,2)))) + BitsN.@@(BitsN.bits(31,2) value,BitsN.B(0x0,2)))) end else let val x = (Cast.natToRName o BitsN.toNat) n @@ -1166,19 +1166,19 @@ fun mem1 address = fun mem (address,size) = case size of - 1 => Bitstring.bits(mem1(BitsN.+(address,BitsN.B(0x0,32))),7,0) + 1 => Bitstring.bits(7,0) (mem1(BitsN.+(address,BitsN.B(0x0,32)))) | 2 => - Bitstring.bits + Bitstring.bits(15,0) ((mem1(BitsN.+(address,BitsN.B(0x1,32)))) - @ - (mem1(BitsN.+(address,BitsN.B(0x0,32)))),15,0) + @ + (mem1(BitsN.+(address,BitsN.B(0x0,32))))) | 4 => - Bitstring.bits + Bitstring.bits(31,0) (List.concat - [mem1(BitsN.+(address,BitsN.B(0x3,32))), - mem1(BitsN.+(address,BitsN.B(0x2,32))), - mem1(BitsN.+(address,BitsN.B(0x1,32))), - mem1(BitsN.+(address,BitsN.B(0x0,32)))],31,0) + [mem1(BitsN.+(address,BitsN.B(0x3,32))), + mem1(BitsN.+(address,BitsN.B(0x2,32))), + mem1(BitsN.+(address,BitsN.B(0x1,32))), + mem1(BitsN.+(address,BitsN.B(0x0,32)))]) | _ => raise ASSERT ("mem: size in {1, 2, 4}"); fun write'mem (value,(address,size)) = @@ -1190,7 +1190,7 @@ fun write'mem (value,(address,size)) = MEM := (Map.update ((!MEM),BitsN.toNat x, - BitsN.fromBitstring(Bitstring.bits(value,7,0),8))) + BitsN.fromBitstring(Bitstring.bits(7,0) value,8))) end | 2 => ( let @@ -1199,7 +1199,7 @@ fun write'mem (value,(address,size)) = MEM := (Map.update ((!MEM),BitsN.toNat x, - BitsN.fromBitstring(Bitstring.bits(value,7,0),8))) + BitsN.fromBitstring(Bitstring.bits(7,0) value,8))) end ; let val x = BitsN.+(address,BitsN.B(0x1,32)) @@ -1207,7 +1207,7 @@ fun write'mem (value,(address,size)) = MEM := (Map.update ((!MEM),BitsN.toNat x, - BitsN.fromBitstring(Bitstring.bits(value,15,8),8))) + BitsN.fromBitstring(Bitstring.bits(15,8) value,8))) end ) | 4 => @@ -1217,7 +1217,7 @@ fun write'mem (value,(address,size)) = MEM := (Map.update ((!MEM),BitsN.toNat x, - BitsN.fromBitstring(Bitstring.bits(value,7,0),8))) + BitsN.fromBitstring(Bitstring.bits(7,0) value,8))) end ; let val x = BitsN.+(address,BitsN.B(0x1,32)) @@ -1225,7 +1225,7 @@ fun write'mem (value,(address,size)) = MEM := (Map.update ((!MEM),BitsN.toNat x, - BitsN.fromBitstring(Bitstring.bits(value,15,8),8))) + BitsN.fromBitstring(Bitstring.bits(15,8) value,8))) end ; let val x = BitsN.+(address,BitsN.B(0x2,32)) @@ -1233,7 +1233,7 @@ fun write'mem (value,(address,size)) = MEM := (Map.update ((!MEM),BitsN.toNat x, - BitsN.fromBitstring(Bitstring.bits(value,23,16),8))) + BitsN.fromBitstring(Bitstring.bits(23,16) value,8))) end ; let val x = BitsN.+(address,BitsN.B(0x3,32)) @@ -1241,19 +1241,19 @@ fun write'mem (value,(address,size)) = MEM := (Map.update ((!MEM),BitsN.toNat x, - BitsN.fromBitstring(Bitstring.bits(value,31,24),8))) + BitsN.fromBitstring(Bitstring.bits(31,24) value,8))) end ) | _ => raise ASSERT ("mem: size in {1, 2, 4}"); fun BigEndianReverse (value,n) = case n of - 1 => Bitstring.bits(value,7,0) - | 2 => (Bitstring.bits(value,7,0)) @ (Bitstring.bits(value,15,8)) + 1 => Bitstring.bits(7,0) value + | 2 => (Bitstring.bits(7,0) value) @ (Bitstring.bits(15,8) value) | 4 => List.concat - [Bitstring.bits(value,7,0),Bitstring.bits(value,15,8), - Bitstring.bits(value,23,16),Bitstring.bits(value,31,24)] + [Bitstring.bits(7,0) value,Bitstring.bits(15,8) value, + Bitstring.bits(23,16) value,Bitstring.bits(31,24) value] | _ => raise ASSERT ("BigEndianReverse: n in {1, 2, 4}"); fun Align N (w,n) = BitsN.fromNat(Nat.*(n,Nat.div(BitsN.toNat w,n)),N); @@ -1402,14 +1402,14 @@ fun PushStack () = val frameptr = ref (BitsN.B(0x0,32)) in ( if ((#SPSEL) (!CONTROL)) andalso ((!CurrentMode) = Mode_Thread) - then ( frameptralign := (BitsN.bits(SP_process (),2,2)) + then ( frameptralign := (BitsN.bits(2,2) (SP_process ())) ; write'SP_process (BitsN.&& (BitsN.-(SP_process (),BitsN.B(0x20,32)), BitsN.~(BitsN.zeroExtend 32 (BitsN.B(0x4,3))))) ; frameptr := (SP_process ()) ) - else ( frameptralign := (BitsN.bits(SP_main (),2,2)) + else ( frameptralign := (BitsN.bits(2,2) (SP_main ())) ; write'SP_process (BitsN.&& (BitsN.-(SP_main (),BitsN.B(0x20,32)), @@ -1456,8 +1456,8 @@ fun PushStack () = in write'MemA 32 (BitsN.concat - [BitsN.bits(reg'PSR (!PSR),31,10),(!frameptralign), - BitsN.bits(reg'PSR (!PSR),8,0)],x) + [BitsN.bits(31,10) (reg'PSR (!PSR)),(!frameptralign), + BitsN.bits(8,0) (reg'PSR (!PSR))],x) end ; if (!CurrentMode) = Mode_Handler then write'LR(BitsN.B(0xFFFFFFF1,32)) @@ -1515,9 +1515,9 @@ fun PopStack (frameptr,EXC_RETURN) = ; let val psr = MemA 32 (BitsN.+(frameptr,BitsN.B(0x1C,32)),4) val spmask = - BitsN.zeroExtend 32 (BitsN.@@(BitsN.bits(psr,9,9),BitsN.B(0x0,2))) + BitsN.zeroExtend 32 (BitsN.@@(BitsN.bits(9,9) psr,BitsN.B(0x0,2))) in - ( case boolify'4(BitsN.bits(EXC_RETURN,3,0)) of + ( case boolify'4(BitsN.bits(3,0) EXC_RETURN) of (_,(false,(false,true))) => write'SP_main (BitsN.||(BitsN.+(SP_main (),BitsN.B(0x20,32)),spmask)) @@ -1530,7 +1530,7 @@ fun PopStack (frameptr,EXC_RETURN) = in PSR := (write'reg'PSR - ((!PSR),BitsN.bitFieldInsert(w,BitsN.bits(psr,31,27),31,27))) + ((!PSR),BitsN.bitFieldInsert(31,27) (w,BitsN.bits(31,27) psr))) end ; let val w = reg'PSR (!PSR) @@ -1538,15 +1538,15 @@ fun PopStack (frameptr,EXC_RETURN) = PSR := (write'reg'PSR ((!PSR), - BitsN.bitFieldInsert - (w,BitsN.fromBit(BitsN.bit(psr,24)),24,24))) + BitsN.bitFieldInsert(24,24) + (w,BitsN.fromBit(BitsN.bit(psr,24))))) end ; let val w = reg'PSR (!PSR) in PSR := (write'reg'PSR - ((!PSR),BitsN.bitFieldInsert(w,BitsN.bits(psr,5,0),5,0))) + ((!PSR),BitsN.bitFieldInsert(5,0) (w,BitsN.bits(5,0) psr))) end ) end @@ -1578,7 +1578,7 @@ fun ExceptionReturn EXC_RETURN = ( if not((!CurrentMode) = Mode_Handler) then raise ASSERT ("CurrentMode == Mode_Handler") else () - ; if not(IsOnes 24 (BitsN.bits(EXC_RETURN,27,4))) + ; if not(IsOnes 24 (BitsN.bits(27,4) EXC_RETURN)) then raise UNPREDICTABLE ("ExceptionReturn") else () ; let @@ -1591,7 +1591,7 @@ fun ExceptionReturn EXC_RETURN = else let val frameptr = ref (BitsN.B(0x0,32)) in - ( case BitsN.bits(EXC_RETURN,3,0) of + ( case BitsN.bits(3,0) EXC_RETURN of BitsN.B(0x1,4) => if NestedActivation = 1 then raise UNPREDICTABLE ("ExceptionReturn") @@ -1636,19 +1636,19 @@ fun CallSupervisor () = Raise SVCall; fun BranchTo address = write'PC address; fun BranchWritePC address = - BranchTo(BitsN.@@(BitsN.bits(address,31,1),BitsN.B(0x0,1))); + BranchTo(BitsN.@@(BitsN.bits(31,1) address,BitsN.B(0x0,1))); fun BXWritePC address = if ((!CurrentMode) = Mode_Handler) andalso - ((BitsN.bits(address,31,28)) = (BitsN.B(0xF,4))) - then ExceptionReturn(BitsN.bits(address,27,0)) + ((BitsN.bits(31,28) address) = (BitsN.B(0xF,4))) + then ExceptionReturn(BitsN.bits(27,0) address) else ( if not(BitsN.bit(address,0)) then Raise HardFault else () - ; BranchTo(BitsN.@@(BitsN.bits(address,31,1),BitsN.B(0x0,1))) + ; BranchTo(BitsN.@@(BitsN.bits(31,1) address,BitsN.B(0x0,1))) ); fun BLXWritePC address = ( if not(BitsN.bit(address,0)) then Raise HardFault else () - ; BranchTo(BitsN.@@(BitsN.bits(address,31,1),BitsN.B(0x0,1))) + ; BranchTo(BitsN.@@(BitsN.bits(31,1) address,BitsN.B(0x0,1))) ); fun LoadWritePC address = BXWritePC address; @@ -1735,8 +1735,8 @@ fun RRX_C N (x,carry_in) = BitsN.fromBitstring ((Bitstring.fromBool carry_in) @ - (Bitstring.bits - (BitsN.toBitstring x,Nat.-(BitsN.size(BitsN.B(0x0,N)),1),1)),N) + (Bitstring.bits(Nat.-(BitsN.size(BitsN.B(0x0,N)),1),1) + (BitsN.toBitstring x)),N) in (result,BitsN.bit(x,0)) end; @@ -1826,7 +1826,7 @@ fun dfn'BranchLinkImmediate imm32 = let val next_instr_addr = PC () in - ( write'LR(BitsN.@@(BitsN.bits(next_instr_addr,31,1),BitsN.B(0x1,1))) + ( write'LR(BitsN.@@(BitsN.bits(31,1) next_instr_addr,BitsN.B(0x1,1))) ; BranchWritePC(BitsN.+(PC (),imm32)) ; count := (Nat.+((!count),4)) ) @@ -1837,7 +1837,7 @@ fun dfn'BranchLinkExchangeRegister m = val target = R m val next_instr_addr = BitsN.-(PC (),BitsN.B(0x2,32)) in - ( write'LR(BitsN.@@(BitsN.bits(next_instr_addr,31,1),BitsN.B(0x1,1))) + ( write'LR(BitsN.@@(BitsN.bits(31,1) next_instr_addr,BitsN.B(0x1,1))) ; BLXWritePC target ; count := (Nat.+((!count),3)) ) @@ -1854,7 +1854,7 @@ fun DataProcessing (opc,(setflags,(d,(n,(imm32,C))))) = else R n val (result,(carry,overflow)) = DataProcessingALU(opc,(rn,(imm32,C))) in - ( if not((BitsN.bits(opc,3,2)) = (BitsN.B(0x2,2))) + ( if not((BitsN.bits(3,2) opc) = (BitsN.B(0x2,2))) then write'R(result,d) else () ; if setflags @@ -1922,7 +1922,7 @@ fun dfn'ShiftImmediate (negate,(setflags,(d,(m,(shift_t,shift_n))))) = fun dfn'ShiftRegister (d,(n,(shift_t,m))) = let - val shift_n = BitsN.toNat(BitsN.bits(R m,7,0)) + val shift_n = BitsN.toNat(BitsN.bits(7,0) (R m)) val (shifted,carry) = Shift_C 32 (R n,(shift_t,(shift_n,(#C) (!PSR)))) in DataProcessing @@ -1942,13 +1942,13 @@ fun dfn'Multiply32 (d,(n,m)) = end; fun dfn'ExtendByte (unsigned,(d,m)) = - ( write'R(Extend (8,32) (unsigned,BitsN.bits(R m,7,0)),d) + ( write'R(Extend (8,32) (unsigned,BitsN.bits(7,0) (R m)),d) ; IncPC () ; count := (Nat.+((!count),1)) ); fun dfn'ExtendHalfword (unsigned,(d,m)) = - ( write'R(Extend (16,32) (unsigned,BitsN.bits(R m,15,0)),d) + ( write'R(Extend (16,32) (unsigned,BitsN.bits(15,0) (R m)),d) ; IncPC () ; count := (Nat.+((!count),1)) ); @@ -1959,8 +1959,8 @@ fun dfn'ByteReverse (d,m) = in ( write'R (BitsN.concat - [BitsN.bits(Rm,7,0),BitsN.bits(Rm,15,8),BitsN.bits(Rm,23,16), - BitsN.bits(Rm,31,24)],d) + [BitsN.bits(7,0) Rm,BitsN.bits(15,8) Rm,BitsN.bits(23,16) Rm, + BitsN.bits(31,24) Rm],d) ; IncPC () ; count := (Nat.+((!count),1)) ) @@ -1972,8 +1972,8 @@ fun dfn'ByteReversePackedHalfword (d,m) = in ( write'R (BitsN.concat - [BitsN.bits(Rm,23,16),BitsN.bits(Rm,31,24),BitsN.bits(Rm,7,0), - BitsN.bits(Rm,15,8)],d) + [BitsN.bits(23,16) Rm,BitsN.bits(31,24) Rm,BitsN.bits(7,0) Rm, + BitsN.bits(15,8) Rm],d) ; IncPC () ; count := (Nat.+((!count),1)) ) @@ -1985,7 +1985,7 @@ fun dfn'ByteReverseSignedHalfword (d,m) = in ( write'R (BitsN.@@ - (BitsN.signExtend 24 (BitsN.bits(Rm,7,0)),BitsN.bits(Rm,15,8)), + (BitsN.signExtend 24 (BitsN.bits(7,0) Rm),BitsN.bits(15,8) Rm), d) ; IncPC () ; count := (Nat.+((!count),1)) @@ -2104,7 +2104,11 @@ fun dfn'StoreByte (t,(n,m)) = | immediate_form imm32 => imm32 val address = BitsN.+(R n,offset) in - ( let val x = (address,1) in write'MemU 8 (BitsN.bits(R t,7,0),x) end + ( let + val x = (address,1) + in + write'MemU 8 (BitsN.bits(7,0) (R t),x) + end ; IncPC () ; count := (Nat.+((!count),2)) ) @@ -2121,7 +2125,7 @@ fun dfn'StoreHalf (t,(n,m)) = ( let val x = (address,2) in - write'MemU 16 (BitsN.bits(R t,15,0),x) + write'MemU 16 (BitsN.bits(15,0) (R t),x) end ; IncPC () ; count := (Nat.+((!count),2)) @@ -2208,15 +2212,15 @@ fun dfn'ChangeProcessorState im = fun dfn'MoveToRegisterFromSpecial (SYSm,d) = ( write'R(BitsN.B(0x0,32),d) - ; case BitsN.bits(SYSm,7,3) of + ; case BitsN.bits(7,3) SYSm of BitsN.B(0x0,5) => ( if BitsN.bit(SYSm,0) then let val w = R d in write'R - (BitsN.bitFieldInsert - (w,BitsN.bits(reg'PSR (!PSR),8,0),8,0),d) + (BitsN.bitFieldInsert(8,0) + (w,BitsN.bits(8,0) (reg'PSR (!PSR))),d) end else () ; if BitsN.bit(SYSm,1) @@ -2224,8 +2228,8 @@ fun dfn'MoveToRegisterFromSpecial (SYSm,d) = val w = R d in write'R - (BitsN.bitFieldInsert(w,BitsN.fromBit false,24,24), - d) + (BitsN.bitFieldInsert(24,24) + (w,BitsN.fromBit false),d) end else () ; if not(BitsN.bit(SYSm,2)) @@ -2233,33 +2237,33 @@ fun dfn'MoveToRegisterFromSpecial (SYSm,d) = val w = R d in write'R - (BitsN.bitFieldInsert - (w,BitsN.bits(reg'PSR (!PSR),31,27),31,27),d) + (BitsN.bitFieldInsert(31,27) + (w,BitsN.bits(31,27) (reg'PSR (!PSR))),d) end else () ) | BitsN.B(0x1,5) => - (case BitsN.bits(SYSm,2,0) of + (case BitsN.bits(2,0) SYSm of BitsN.B(0x0,3) => write'R(SP_main (),d) | BitsN.B(0x1,3) => write'R(SP_process (),d) | _ => ()) | BitsN.B(0x2,5) => - (case BitsN.bits(SYSm,2,0) of + (case BitsN.bits(2,0) SYSm of BitsN.B(0x0,3) => let val w = R d in write'R - (BitsN.bitFieldInsert - (w,BitsN.fromBit((#PM) (!PRIMASK)),0,0),d) + (BitsN.bitFieldInsert(0,0) + (w,BitsN.fromBit((#PM) (!PRIMASK))),d) end | BitsN.B(0x4,3) => let val w = R d in write'R - (BitsN.bitFieldInsert - (w,BitsN.bits(reg'CONTROL (!CONTROL),1,0),1,0),d) + (BitsN.bitFieldInsert(1,0) + (w,BitsN.bits(1,0) (reg'CONTROL (!CONTROL))),d) end | _ => ()) | _ => () @@ -2271,7 +2275,7 @@ fun dfn'MoveToSpecialRegister (SYSm,n) = let val Rn = R n in - ( case BitsN.bits(SYSm,7,3) of + ( case BitsN.bits(7,3) SYSm of BitsN.B(0x0,5) => if not(BitsN.bit(SYSm,2)) then let @@ -2280,24 +2284,24 @@ fun dfn'MoveToSpecialRegister (SYSm,n) = PSR := (write'reg'PSR ((!PSR), - BitsN.bitFieldInsert - (w,BitsN.bits(Rn,31,27),31,27))) + BitsN.bitFieldInsert(31,27) + (w,BitsN.bits(31,27) Rn))) end else () | BitsN.B(0x1,5) => if CurrentModeIsPrivileged () - then case BitsN.bits(SYSm,2,0) of + then case BitsN.bits(2,0) SYSm of BitsN.B(0x0,3) => write'SP_main - (BitsN.@@(BitsN.bits(Rn,31,2),BitsN.B(0x0,2))) + (BitsN.@@(BitsN.bits(31,2) Rn,BitsN.B(0x0,2))) | BitsN.B(0x1,3) => write'SP_process - (BitsN.@@(BitsN.bits(Rn,31,2),BitsN.B(0x0,2))) + (BitsN.@@(BitsN.bits(31,2) Rn,BitsN.B(0x0,2))) | _ => () else () | BitsN.B(0x2,5) => if CurrentModeIsPrivileged () - then case BitsN.bits(SYSm,2,0) of + then case BitsN.bits(2,0) SYSm of BitsN.B(0x0,3) => PRIMASK := (PRIMASK_PM_rupd((!PRIMASK),BitsN.bit(Rn,0))) @@ -2411,8 +2415,8 @@ fun Fetch () = val fpc = Map.lookup((!REG),Cast.RNameToNat RName_PC) val ireg = MemA 16 (fpc,2) in - if ((BitsN.bits(ireg,15,13)) = (BitsN.B(0x7,3))) andalso - (not((BitsN.bits(ireg,12,11)) = (BitsN.B(0x0,2)))) + if ((BitsN.bits(15,13) ireg) = (BitsN.B(0x7,3))) andalso + (not((BitsN.bits(12,11) ireg) = (BitsN.B(0x0,2)))) then Thumb2(ireg,MemA 16 (BitsN.+(fpc,BitsN.B(0x2,32)),2)) else Thumb ireg end; @@ -2705,21 +2709,21 @@ fun DecodeThumb h = val n = BitsN.fromNat(BitsN.toNat Ry,4) val m = BitsN.fromNat(BitsN.toNat Rx,4) in - Data(TestCompareRegister(BitsN.bits(opc,1,0),(n,m))) + Data(TestCompareRegister(BitsN.bits(1,0) opc,(n,m))) end | BitsN.B(0xA,4) => let val n = BitsN.fromNat(BitsN.toNat Ry,4) val m = BitsN.fromNat(BitsN.toNat Rx,4) in - Data(TestCompareRegister(BitsN.bits(opc,1,0),(n,m))) + Data(TestCompareRegister(BitsN.bits(1,0) opc,(n,m))) end | BitsN.B(0xB,4) => let val n = BitsN.fromNat(BitsN.toNat Ry,4) val m = BitsN.fromNat(BitsN.toNat Rx,4) in - Data(TestCompareRegister(BitsN.bits(opc,1,0),(n,m))) + Data(TestCompareRegister(BitsN.bits(1,0) opc,(n,m))) end | BitsN.B(0x9,4) => let @@ -3633,15 +3637,15 @@ fun e_branch (c,(ast,e)) = (BitsN.<=(imm32,BitsN.B(0x7FE,32)))) andalso (not(e = Enc_Wide)) then Thumb16 - (BitsN.@@(BitsN.B(0x1C,5),BitsN.bits(imm32,11,1))) + (BitsN.@@(BitsN.B(0x1C,5),BitsN.bits(11,1) imm32)) else let - val S = BitsN.bits(imm32,24,24) - val I1 = BitsN.bits(imm32,23,23) - val I2 = BitsN.bits(imm32,22,22) + val S = BitsN.bits(24,24) imm32 + val I1 = BitsN.bits(23,23) imm32 + val I2 = BitsN.bits(22,22) imm32 val J1 = BitsN.fromBit(I1 = S) val J2 = BitsN.fromBit(I2 = S) - val imm10 = BitsN.bits(imm32,21,12) - val imm11 = BitsN.bits(imm32,11,1) + val imm10 = BitsN.bits(21,12) imm32 + val imm11 = BitsN.bits(11,1) imm32 in Thumb32 (BitsN.concat[BitsN.B(0x1E,5),S,imm10], @@ -3651,7 +3655,7 @@ fun e_branch (c,(ast,e)) = else if ((BitsN.<=(BitsN.neg(BitsN.B(0x100,32)),imm32)) andalso (BitsN.<=(imm32,BitsN.B(0xFE,32)))) andalso (not(e = Enc_Wide)) then Thumb16 - (BitsN.concat[BitsN.B(0xD,4),c,BitsN.bits(imm32,8,1)]) + (BitsN.concat[BitsN.B(0xD,4),c,BitsN.bits(8,1) imm32]) else BadCode("BranchTarget")) | BranchExchange Rm => Thumb16(BitsN.concat[BitsN.B(0x8E,9),Rm,BitsN.B(0x0,3)]) @@ -3659,13 +3663,13 @@ fun e_branch (c,(ast,e)) = Thumb16(BitsN.concat[BitsN.B(0x8F,9),Rm,BitsN.B(0x0,3)]) | BranchLinkImmediate imm32 => let - val S = BitsN.bits(imm32,24,24) - val I1 = BitsN.bits(imm32,23,23) - val I2 = BitsN.bits(imm32,22,22) + val S = BitsN.bits(24,24) imm32 + val I1 = BitsN.bits(23,23) imm32 + val I2 = BitsN.bits(22,22) imm32 val J1 = BitsN.fromBit(I1 = S) val J2 = BitsN.fromBit(I2 = S) - val imm10 = BitsN.bits(imm32,21,12) - val imm11 = BitsN.bits(imm32,11,1) + val imm10 = BitsN.bits(21,12) imm32 + val imm11 = BitsN.bits(11,1) imm32 in Thumb32 (BitsN.concat[BitsN.B(0x1E,5),S,imm10], @@ -3677,16 +3681,16 @@ fun e_data ast = Move(d,imm32) => Thumb16 (BitsN.concat - [BitsN.B(0x4,5),BitsN.bits(d,2,0),BitsN.bits(imm32,7,0)]) + [BitsN.B(0x4,5),BitsN.bits(2,0) d,BitsN.bits(7,0) imm32]) | ArithLogicImmediate(opc,(setflags,(d,(n,imm32)))) => (if (((Set.mem(opc,[BitsN.B(0x4,4),BitsN.B(0x2,4)])) andalso (BitsN.<=+(imm32,BitsN.B(0x7,32)))) andalso setflags) andalso (not((BitsN.bit(d,3)) orelse (BitsN.bit(n,3)))) then let - val Rd = BitsN.bits(d,2,0) - val Rn = BitsN.bits(n,2,0) - val imm3 = BitsN.bits(imm32,2,0) - val S = BitsN.bits(opc,1,1) + val Rd = BitsN.bits(2,0) d + val Rn = BitsN.bits(2,0) n + val imm3 = BitsN.bits(2,0) imm32 + val S = BitsN.bits(1,1) opc in Thumb16(BitsN.concat[BitsN.B(0x7,6),S,imm3,Rn,Rd]) end @@ -3694,9 +3698,9 @@ fun e_data ast = (d = n)) andalso (BitsN.<=+(imm32,BitsN.B(0xFF,32)))) andalso setflags) andalso (not(BitsN.bit(d,3))) then let - val Rdn = BitsN.bits(d,2,0) - val imm8 = BitsN.bits(imm32,7,0) - val S = BitsN.bits(opc,1,1) + val Rdn = BitsN.bits(2,0) d + val imm8 = BitsN.bits(7,0) imm32 + val S = BitsN.bits(1,1) opc in Thumb16(BitsN.concat[BitsN.B(0x3,4),S,Rdn,imm8]) end @@ -3704,8 +3708,8 @@ fun e_data ast = (imm32 = (BitsN.B(0x0,32)))) andalso setflags) andalso (not((BitsN.bit(d,3)) orelse (BitsN.bit(n,3)))) then let - val Rd = BitsN.bits(d,2,0) - val Rn = BitsN.bits(n,2,0) + val Rd = BitsN.bits(2,0) d + val Rn = BitsN.bits(2,0) n in Thumb16(BitsN.concat[BitsN.B(0x109,10),Rn,Rd]) end @@ -3715,8 +3719,8 @@ fun e_data ast = ((BitsN.&&(imm32,BitsN.B(0xFFFFFC03,32))) = (BitsN.B(0x0,32)))) andalso (not(BitsN.bit(d,3))) then let - val Rd = BitsN.bits(d,2,0) - val imm8 = BitsN.bits(imm32,9,2) + val Rd = BitsN.bits(2,0) d + val imm8 = BitsN.bits(9,2) imm32 val S = BitsN.fromBit(n = (BitsN.B(0xD,4))) in Thumb16(BitsN.concat[BitsN.B(0xA,4),S,Rd,imm8]) @@ -3727,8 +3731,8 @@ fun e_data ast = ((BitsN.&&(imm32,BitsN.B(0xFFFFFE03,32))) = (BitsN.B(0x0,32)))) andalso (not setflags) then let - val imm7 = BitsN.bits(imm32,8,2) - val S = BitsN.bits(opc,1,1) + val imm7 = BitsN.bits(8,2) imm32 + val S = BitsN.bits(1,1) opc in Thumb16(BitsN.concat[BitsN.B(0xB0,8),S,imm7]) end @@ -3738,9 +3742,9 @@ fun e_data ast = (not(((BitsN.bit(d,3)) orelse (BitsN.bit(n,3))) orelse (BitsN.bit(m,3)))) then let - val Rn = BitsN.bits(n,2,0) - val Rd = BitsN.bits(d,2,0) - val Rm = BitsN.bits(m,2,0) + val Rn = BitsN.bits(2,0) n + val Rd = BitsN.bits(2,0) d + val Rm = BitsN.bits(2,0) m val S = BitsN.fromBit(opc = (BitsN.B(0x2,4))) in Thumb16(BitsN.concat[BitsN.B(0x6,6),S,Rm,Rn,Rd]) @@ -3752,16 +3756,16 @@ fun e_data ast = setflags) andalso (d = n)) andalso (not((BitsN.bit(d,3)) orelse (BitsN.bit(m,3)))) then let - val Rdn = BitsN.bits(d,2,0) - val Rm = BitsN.bits(m,2,0) + val Rdn = BitsN.bits(2,0) d + val Rm = BitsN.bits(2,0) m in Thumb16(BitsN.concat[BitsN.B(0x10,6),opc,Rm,Rdn]) end else if ((opc = (BitsN.B(0x4,4))) andalso (d = n)) andalso (not setflags) then let - val DN = BitsN.bits(d,3,3) - val Rdn = BitsN.bits(d,2,0) + val DN = BitsN.bits(3,3) d + val Rdn = BitsN.bits(2,0) d val Rm = m in Thumb16(BitsN.concat[BitsN.B(0x44,8),DN,Rm,Rdn]) @@ -3771,15 +3775,15 @@ fun e_data ast = (if not(((opc = (BitsN.B(0x1,2))) orelse (BitsN.bit(n,3))) orelse (BitsN.bit(m,3))) then let - val Rn = BitsN.bits(n,2,0) - val Rm = BitsN.bits(m,2,0) + val Rn = BitsN.bits(2,0) n + val Rm = BitsN.bits(2,0) m in Thumb16(BitsN.concat[BitsN.B(0x42,8),opc,Rm,Rn]) end else if opc = (BitsN.B(0x2,2)) then let - val N = BitsN.bits(n,3,3) - val Rn = BitsN.bits(n,2,0) + val N = BitsN.bits(3,3) n + val Rn = BitsN.bits(2,0) n val Rm = m in Thumb16(BitsN.concat[BitsN.B(0x45,8),N,Rm,Rn]) @@ -3788,14 +3792,14 @@ fun e_data ast = | CompareImmediate(n,imm32) => Thumb16 (BitsN.concat - [BitsN.B(0x5,5),BitsN.bits(n,2,0),BitsN.bits(imm32,7,0)]) + [BitsN.B(0x5,5),BitsN.bits(2,0) n,BitsN.bits(7,0) imm32]) | ShiftImmediate(negate,(setflags,(d,(m,(shift_t,shift_n))))) => (if (((negate andalso (shift_t = SRType_LSL)) andalso (shift_n = 0)) andalso setflags) andalso (not((BitsN.bit(m,3)) orelse (BitsN.bit(d,3)))) then let - val Rm = BitsN.bits(m,2,0) - val Rd = BitsN.bits(d,2,0) + val Rm = BitsN.bits(2,0) m + val Rd = BitsN.bits(2,0) d in Thumb16(BitsN.concat[BitsN.B(0x10F,10),Rm,Rd]) end @@ -3803,8 +3807,8 @@ fun e_data ast = setflags) andalso (not((negate orelse (BitsN.bit(m,3))) orelse (BitsN.bit(d,3)))) then let - val Rm = BitsN.bits(m,2,0) - val Rd = BitsN.bits(d,2,0) + val Rm = BitsN.bits(2,0) m + val Rd = BitsN.bits(2,0) d val (typ,imm5) = EncodeImmShift(shift_t,shift_n) in Thumb16(BitsN.concat[BitsN.B(0x0,3),typ,imm5,Rm,Rd]) @@ -3812,8 +3816,8 @@ fun e_data ast = else if ((shift_t = SRType_LSL) andalso (shift_n = 0)) andalso (not(negate orelse setflags)) then let - val D = BitsN.bits(d,3,3) - val Rd = BitsN.bits(d,2,0) + val D = BitsN.bits(3,3) d + val Rd = BitsN.bits(2,0) d val Rm = m in Thumb16(BitsN.concat[BitsN.B(0x46,8),D,Rm,Rd]) @@ -3822,8 +3826,8 @@ fun e_data ast = | ShiftRegister(_,(_,(SRType_RRX,_))) => BadCode("ShiftRegister: rrx") | ShiftRegister(d,(n,(shift_t,m))) => let - val Rm = BitsN.bits(m,2,0) - val Rdn = BitsN.bits(d,2,0) + val Rm = BitsN.bits(2,0) m + val Rdn = BitsN.bits(2,0) d val opc = case shift_t of SRType_LSL => BitsN.B(0x2,3) @@ -3840,36 +3844,36 @@ fun e_media ast = ExtendByte(unsigned,(d,m)) => let val U = BitsN.fromBit unsigned - val Rd = BitsN.bits(d,2,0) - val Rm = BitsN.bits(m,2,0) + val Rd = BitsN.bits(2,0) d + val Rm = BitsN.bits(2,0) m in Thumb16(BitsN.concat[BitsN.B(0xB2,8),U,BitsN.B(0x1,1),Rm,Rd]) end | ExtendHalfword(unsigned,(d,m)) => let val U = BitsN.fromBit unsigned - val Rd = BitsN.bits(d,2,0) - val Rm = BitsN.bits(m,2,0) + val Rd = BitsN.bits(2,0) d + val Rm = BitsN.bits(2,0) m in Thumb16(BitsN.concat[BitsN.B(0xB2,8),U,BitsN.B(0x0,1),Rm,Rd]) end | ByteReverse(d,m) => Thumb16 (BitsN.concat - [BitsN.B(0x2E8,10),BitsN.bits(m,2,0),BitsN.bits(d,2,0)]) + [BitsN.B(0x2E8,10),BitsN.bits(2,0) m,BitsN.bits(2,0) d]) | ByteReversePackedHalfword(d,m) => Thumb16 (BitsN.concat - [BitsN.B(0x2E9,10),BitsN.bits(m,2,0),BitsN.bits(d,2,0)]) + [BitsN.B(0x2E9,10),BitsN.bits(2,0) m,BitsN.bits(2,0) d]) | ByteReverseSignedHalfword(d,m) => Thumb16 (BitsN.concat - [BitsN.B(0x2EB,10),BitsN.bits(m,2,0),BitsN.bits(d,2,0)]); + [BitsN.B(0x2EB,10),BitsN.bits(2,0) m,BitsN.bits(2,0) d]); fun e_hint (ast,e) = case ast of Breakpoint imm32 => - Thumb16(BitsN.@@(BitsN.B(0xBE,8),BitsN.bits(imm32,7,0))) + Thumb16(BitsN.@@(BitsN.B(0xBE,8),BitsN.bits(7,0) imm32)) | DataMemoryBarrier option => Thumb32(BitsN.B(0xF3BF,16),BitsN.@@(BitsN.B(0x8F5,12),option)) | DataSynchronizationBarrier option => @@ -3905,15 +3909,15 @@ fun e_system ast = Thumb32 (BitsN.@@(BitsN.B(0xF38,12),Rn),BitsN.@@(BitsN.B(0x88,8),SYSm)) | SupervisorCall imm32 => - Thumb16(BitsN.@@(BitsN.B(0xDF,8),BitsN.bits(imm32,7,0))); + Thumb16(BitsN.@@(BitsN.B(0xDF,8),BitsN.bits(7,0) imm32)); fun e_multiply ast = case ast of Multiply32(d,(n,m)) => (if d = m then let - val Rn = BitsN.bits(n,2,0) - val Rdm = BitsN.bits(d,2,0) + val Rn = BitsN.bits(2,0) n + val Rdm = BitsN.bits(2,0) d in Thumb16(BitsN.concat[BitsN.B(0x10D,10),Rn,Rdm]) end @@ -3925,31 +3929,31 @@ fun e_load ast = (if n = (BitsN.B(0xD,4)) then Thumb16 (BitsN.concat - [BitsN.B(0x13,5),BitsN.bits(t,2,0), - BitsN.bits(imm32,9,2)]) + [BitsN.B(0x13,5),BitsN.bits(2,0) t, + BitsN.bits(9,2) imm32]) else Thumb16 (BitsN.concat - [BitsN.B(0xD,5),BitsN.bits(imm32,6,2),BitsN.bits(n,2,0), - BitsN.bits(t,2,0)])) + [BitsN.B(0xD,5),BitsN.bits(6,2) imm32,BitsN.bits(2,0) n, + BitsN.bits(2,0) t])) | LoadWord(t,(n,register_form m)) => Thumb16 (BitsN.concat - [BitsN.B(0x2C,7),BitsN.bits(m,2,0),BitsN.bits(n,2,0), - BitsN.bits(t,2,0)]) + [BitsN.B(0x2C,7),BitsN.bits(2,0) m,BitsN.bits(2,0) n, + BitsN.bits(2,0) t]) | LoadLiteral(t,imm32) => Thumb16 (BitsN.concat - [BitsN.B(0x9,5),BitsN.bits(t,2,0),BitsN.bits(imm32,9,2)]) + [BitsN.B(0x9,5),BitsN.bits(2,0) t,BitsN.bits(9,2) imm32]) | LoadByte(unsigned,(t,(n,immediate_form imm32))) => Thumb16 (BitsN.concat - [BitsN.B(0xF,5),BitsN.bits(imm32,4,0),BitsN.bits(n,2,0), - BitsN.bits(t,2,0)]) + [BitsN.B(0xF,5),BitsN.bits(4,0) imm32,BitsN.bits(2,0) n, + BitsN.bits(2,0) t]) | LoadByte(unsigned,(t,(n,register_form m))) => let - val Rm = BitsN.bits(m,2,0) - val Rn = BitsN.bits(n,2,0) - val Rt = BitsN.bits(t,2,0) + val Rm = BitsN.bits(2,0) m + val Rn = BitsN.bits(2,0) n + val Rt = BitsN.bits(2,0) t val U = BitsN.fromBit unsigned val S = BitsN.~ U in @@ -3958,20 +3962,20 @@ fun e_load ast = | LoadHalf(unsigned,(t,(n,immediate_form imm32))) => Thumb16 (BitsN.concat - [BitsN.B(0x11,5),BitsN.bits(imm32,5,1),BitsN.bits(n,2,0), - BitsN.bits(t,2,0)]) + [BitsN.B(0x11,5),BitsN.bits(5,1) imm32,BitsN.bits(2,0) n, + BitsN.bits(2,0) t]) | LoadHalf(unsigned,(t,(n,register_form m))) => Thumb16 (BitsN.concat [BitsN.B(0xB,5),BitsN.fromBit(not unsigned),BitsN.B(0x1,1), - BitsN.bits(m,2,0),BitsN.bits(n,2,0),BitsN.bits(t,2,0)]) + BitsN.bits(2,0) m,BitsN.bits(2,0) n,BitsN.bits(2,0) t]) | LoadMultiple(wback,(n,registers)) => (if n = (BitsN.B(0xD,4)) then Thumb16(BitsN.@@(BitsN.B(0x5E,7),registers)) else Thumb16 (BitsN.concat - [BitsN.B(0x19,5),BitsN.bits(n,2,0), - BitsN.bits(registers,7,0)])); + [BitsN.B(0x19,5),BitsN.bits(2,0) n, + BitsN.bits(7,0) registers])); fun e_store ast = case ast of @@ -3979,40 +3983,40 @@ fun e_store ast = (if n = (BitsN.B(0xD,4)) then Thumb16 (BitsN.concat - [BitsN.B(0x12,5),BitsN.bits(t,2,0), - BitsN.bits(imm32,9,2)]) + [BitsN.B(0x12,5),BitsN.bits(2,0) t, + BitsN.bits(9,2) imm32]) else Thumb16 (BitsN.concat - [BitsN.B(0xC,5),BitsN.bits(imm32,6,2),BitsN.bits(n,2,0), - BitsN.bits(t,2,0)])) + [BitsN.B(0xC,5),BitsN.bits(6,2) imm32,BitsN.bits(2,0) n, + BitsN.bits(2,0) t])) | StoreWord(t,(n,register_form m)) => Thumb16 (BitsN.concat - [BitsN.B(0x28,7),BitsN.bits(m,2,0),BitsN.bits(n,2,0), - BitsN.bits(t,2,0)]) + [BitsN.B(0x28,7),BitsN.bits(2,0) m,BitsN.bits(2,0) n, + BitsN.bits(2,0) t]) | StoreByte(t,(n,immediate_form imm32)) => Thumb16 (BitsN.concat - [BitsN.B(0xE,5),BitsN.bits(imm32,4,0),BitsN.bits(n,2,0), - BitsN.bits(t,2,0)]) + [BitsN.B(0xE,5),BitsN.bits(4,0) imm32,BitsN.bits(2,0) n, + BitsN.bits(2,0) t]) | StoreByte(t,(n,register_form m)) => Thumb16 (BitsN.concat - [BitsN.B(0x2A,7),BitsN.bits(m,2,0),BitsN.bits(n,2,0), - BitsN.bits(t,2,0)]) + [BitsN.B(0x2A,7),BitsN.bits(2,0) m,BitsN.bits(2,0) n, + BitsN.bits(2,0) t]) | StoreHalf(t,(n,immediate_form imm32)) => Thumb16 (BitsN.concat - [BitsN.B(0x10,5),BitsN.bits(imm32,5,1),BitsN.bits(n,2,0), - BitsN.bits(t,2,0)]) + [BitsN.B(0x10,5),BitsN.bits(5,1) imm32,BitsN.bits(2,0) n, + BitsN.bits(2,0) t]) | StoreHalf(t,(n,register_form m)) => Thumb16 (BitsN.concat - [BitsN.B(0x29,7),BitsN.bits(m,2,0),BitsN.bits(n,2,0), - BitsN.bits(t,2,0)]) + [BitsN.B(0x29,7),BitsN.bits(2,0) m,BitsN.bits(2,0) n, + BitsN.bits(2,0) t]) | Push registers => Thumb16(BitsN.@@(BitsN.B(0x5A,7),registers)) | StoreMultiple(n,registers) => - Thumb16(BitsN.concat[BitsN.B(0x18,5),BitsN.bits(n,2,0),registers]); + Thumb16(BitsN.concat[BitsN.B(0x18,5),BitsN.bits(2,0) n,registers]); fun instructionEncode (c,(ast,e)) = case ast of @@ -4026,16 +4030,16 @@ fun instructionEncode (c,(ast,e)) = | Hint h => e_hint(h,e) | Undefined imm32 => (if (not(e = Enc_Wide)) andalso - ((BitsN.bits(imm32,31,8)) = (BitsN.B(0x0,24))) + ((BitsN.bits(31,8) imm32) = (BitsN.B(0x0,24))) then let - val imm8 = BitsN.bits(imm32,7,0) + val imm8 = BitsN.bits(7,0) imm32 in Thumb16(BitsN.@@(BitsN.B(0xDE,8),imm8)) end else if not(e = Enc_Narrow) then let - val imm4 = BitsN.bits(imm32,15,12) - val imm12 = BitsN.bits(imm32,11,0) + val imm4 = BitsN.bits(15,12) imm32 + val imm12 = BitsN.bits(11,0) imm32 in Thumb32 (BitsN.@@(BitsN.B(0xF7F,12),imm4), @@ -4746,12 +4750,12 @@ fun p_pop_push (c,(pop,l)) = (true, (BitsN.B(0xD,4), BitsN.@@ - (BitsN.bits(w,15,15),BitsN.bits(w,7,0)))))) + (BitsN.bits(15,15) w,BitsN.bits(7,0) w))))) else FAIL("bad register list") else if (BitsN.&&(w,BitsN.B(0xBF00,16))) = (BitsN.B(0x0,16)) then OK(c, Store - (Push(BitsN.@@(BitsN.bits(w,14,14),BitsN.bits(w,7,0))))) + (Push(BitsN.@@(BitsN.bits(14,14) w,BitsN.bits(7,0) w)))) else FAIL("bad register list")) | (NONE,_) => FAIL("syntax error") | _ => FAIL("bad register list"); @@ -4764,7 +4768,7 @@ fun p_ldm_stm (c,(load,l)) = in case (p_register r,(p_registers t,Set.mem(wb,["","!"]))) of (Option.SOME rn,(Option.SOME w,true)) => - (if (BitsN.bits(w,15,8)) = (BitsN.B(0x0,8)) + (if (BitsN.bits(15,8) w) = (BitsN.B(0x0,8)) then let val wback = wb = ("!") in @@ -4772,7 +4776,7 @@ fun p_ldm_stm (c,(load,l)) = then OK(c, Load (LoadMultiple - (wback,(rn,BitsN.bits(w,8,0))))) + (wback,(rn,BitsN.bits(8,0) w)))) else if wback then if (rn = (BitsN.B(0xD,4))) andalso ((BitsN.&&(w,BitsN.B(0xBF00,16))) = @@ -4781,12 +4785,12 @@ fun p_ldm_stm (c,(load,l)) = Store (Push (BitsN.@@ - (BitsN.bits(w,14,14), - BitsN.bits(w,7,0))))) + (BitsN.bits(14,14) w, + BitsN.bits(7,0) w)))) else OK(c, Store (StoreMultiple - (rn,BitsN.bits(w,7,0)))) + (rn,BitsN.bits(7,0) w))) else FAIL("syntax error") end else FAIL("bad register list")) @@ -5268,16 +5272,16 @@ fun s_load ast = ("pop", s_registers 16 (BitsN.concat - [BitsN.bits(registers,8,8),BitsN.B(0x0,7), - BitsN.bits(registers,7,0)])) + [BitsN.bits(8,8) registers,BitsN.B(0x0,7), + BitsN.bits(7,0) registers])) | LoadMultiple(wback,(n,registers)) => ("ldm", String.concat [s_reg n,if wback then "!" else "",", ", s_registers 16 (BitsN.concat - [BitsN.bits(registers,8,8),BitsN.B(0x0,7), - BitsN.bits(registers,7,0)])]); + [BitsN.bits(8,8) registers,BitsN.B(0x0,7), + BitsN.bits(7,0) registers])]); fun s_store ast = case ast of @@ -5294,8 +5298,8 @@ fun s_store ast = ("push", s_registers 15 (BitsN.concat - [BitsN.bits(registers,8,8),BitsN.B(0x0,6), - BitsN.bits(registers,7,0)])) + [BitsN.bits(8,8) registers,BitsN.B(0x0,6), + BitsN.bits(7,0) registers])) | StoreMultiple(n,registers) => ("stm",String.concat[s_reg n,"!, ",s_registers 8 registers]); diff --git a/examples/l3-machine-code/m0/model/m0AssemblerLib.sml b/examples/l3-machine-code/m0/model/m0AssemblerLib.sml index efd9152108..795f14f812 100644 --- a/examples/l3-machine-code/m0/model/m0AssemblerLib.sml +++ b/examples/l3-machine-code/m0/model/m0AssemblerLib.sml @@ -15,7 +15,7 @@ end val ERR = Feedback.mk_HOL_ERR "m0AssemblerLib" val hex = assemblerLib.hex -fun hex32 w = hex (BitsN.bits (w, 31, 16)) ^ " " ^ hex (BitsN.bits (w, 15, 0)) +fun hex32 w = hex (BitsN.bits (31, 16) w) ^ " " ^ hex (BitsN.bits (15, 0) w) val w16 = assemblerLib.word 16 fun isBranchLink (m0.Branch (m0.BranchLinkImmediate _)) = true @@ -193,9 +193,9 @@ local fun pad16 s = StringCvt.padLeft #"0" 4 (L3.lowercase s) in fun thumbCondition opc = - if BitsN.toNat (BitsN.bits (opc, 15, 12)) = 13 + if BitsN.toNat (BitsN.bits (15, 12) opc) = 13 then let - val code = BitsN.bits (opc, 11, 8) + val code = BitsN.bits (11, 8) opc in m0.SetPassCondition code ; code diff --git a/examples/l3-machine-code/mips/model/mips.sig b/examples/l3-machine-code/mips/model/mips.sig index 21b7eb7c92..f957c1f886 100644 --- a/examples/l3-machine-code/mips/model/mips.sig +++ b/examples/l3-machine-code/mips/model/mips.sig @@ -1,4 +1,4 @@ -(* mips - generated by L<3> - Wed Apr 08 15:52:11 2015 *) +(* mips - generated by L3 - Wed Jul 15 10:47:21 2015 *) signature mips = sig diff --git a/examples/l3-machine-code/mips/model/mips.sml b/examples/l3-machine-code/mips/model/mips.sml index ab69e9ede0..bcd3b05ff1 100644 --- a/examples/l3-machine-code/mips/model/mips.sml +++ b/examples/l3-machine-code/mips/model/mips.sml @@ -1,4 +1,4 @@ -(* mips - generated by L<3> - Wed Apr 08 15:52:11 2015 *) +(* mips - generated by L3 - Wed Jul 15 10:47:21 2015 *) structure mips :> mips = struct @@ -1309,8 +1309,8 @@ in end fun rec'Index x = - {Index = BitsN.bits(x,7,0), P = BitsN.bit(x,31), - index'rst = BitsN.bits(x,30,8)}; + {Index = BitsN.bits(7,0) x, P = BitsN.bit(x,31), + index'rst = BitsN.bits(30,8) x}; fun reg'Index x = case x of @@ -1385,7 +1385,7 @@ fun write'rec'Index (_,x) = reg'Index x; fun write'reg'Index (_,x) = rec'Index x; fun rec'Random x = - {Random = BitsN.bits(x,7,0), random'rst = BitsN.bits(x,31,8)}; + {Random = BitsN.bits(7,0) x, random'rst = BitsN.bits(31,8) x}; fun reg'Random x = case x of @@ -1460,7 +1460,7 @@ fun write'rec'Random (_,x) = reg'Random x; fun write'reg'Random (_,x) = rec'Random x; fun rec'Wired x = - {Wired = BitsN.bits(x,7,0), wired'rst = BitsN.bits(x,31,8)}; + {Wired = BitsN.bits(7,0) x, wired'rst = BitsN.bits(31,8) x}; fun reg'Wired x = case x of @@ -1535,9 +1535,9 @@ fun write'rec'Wired (_,x) = reg'Wired x; fun write'reg'Wired (_,x) = rec'Wired x; fun rec'EntryLo x = - {C = BitsN.bits(x,5,3), D = BitsN.bit(x,2), G = BitsN.bit(x,0), - PFN = BitsN.bits(x,33,6), V = BitsN.bit(x,1), - entrylo'rst = BitsN.bits(x,63,34)}; + {C = BitsN.bits(5,3) x, D = BitsN.bit(x,2), G = BitsN.bit(x,0), + PFN = BitsN.bits(33,6) x, V = BitsN.bit(x,1), + entrylo'rst = BitsN.bits(63,34) x}; fun reg'EntryLo x = case x of @@ -1674,8 +1674,8 @@ fun write'rec'EntryLo (_,x) = reg'EntryLo x; fun write'reg'EntryLo (_,x) = rec'EntryLo x; fun rec'PageMask x = - {Mask = BitsN.bits(x,24,13), - pagemask'rst = BitsN.@@(BitsN.bits(x,12,0),BitsN.bits(x,31,25))}; + {Mask = BitsN.bits(24,13) x, + pagemask'rst = BitsN.@@(BitsN.bits(12,0) x,BitsN.bits(31,25) x)}; fun reg'PageMask x = case x of @@ -1751,9 +1751,9 @@ fun write'rec'PageMask (_,x) = reg'PageMask x; fun write'reg'PageMask (_,x) = rec'PageMask x; fun rec'EntryHi x = - {ASID = BitsN.bits(x,7,0), R = BitsN.bits(x,63,62), - VPN2 = BitsN.bits(x,39,13), - entryhi'rst = BitsN.@@(BitsN.bits(x,12,8),BitsN.bits(x,61,40))}; + {ASID = BitsN.bits(7,0) x, R = BitsN.bits(63,62) x, + VPN2 = BitsN.bits(39,13) x, + entryhi'rst = BitsN.@@(BitsN.bits(12,8) x,BitsN.bits(61,40) x)}; fun reg'EntryHi x = case x of @@ -1894,12 +1894,12 @@ fun write'reg'EntryHi (_,x) = rec'EntryHi x; fun rec'StatusRegister x = {BEV = BitsN.bit(x,22), CU0 = BitsN.bit(x,28), ERL = BitsN.bit(x,2), EXL = BitsN.bit(x,1), FR = BitsN.bit(x,26), IE = BitsN.bit(x,0), - IM = BitsN.bits(x,15,8), KSU = BitsN.bits(x,4,3), KX = BitsN.bit(x,7), + IM = BitsN.bits(15,8) x, KSU = BitsN.bits(4,3) x, KX = BitsN.bit(x,7), RE = BitsN.bit(x,25), SX = BitsN.bit(x,6), UX = BitsN.bit(x,5), statusregister'rst = BitsN.concat - [BitsN.bits(x,21,16),BitsN.bits(x,24,23),BitsN.bits(x,27,27), - BitsN.bits(x,31,29)]}; + [BitsN.bits(21,16) x,BitsN.bits(24,23) x,BitsN.bits(27,27) x, + BitsN.bits(31,29) x]}; fun reg'StatusRegister x = case x of @@ -1974,10 +1974,10 @@ fun write'rec'StatusRegister (_,x) = reg'StatusRegister x; fun write'reg'StatusRegister (_,x) = rec'StatusRegister x; fun rec'ConfigRegister x = - {AR = BitsN.bits(x,12,10), AT = BitsN.bits(x,14,13), - BE = BitsN.bit(x,15), K0 = BitsN.bits(x,2,0), M = BitsN.bit(x,31), - MT = BitsN.bits(x,9,7), - configregister'rst = BitsN.@@(BitsN.bits(x,6,3),BitsN.bits(x,30,16))}; + {AR = BitsN.bits(12,10) x, AT = BitsN.bits(14,13) x, + BE = BitsN.bit(x,15), K0 = BitsN.bits(2,0) x, M = BitsN.bit(x,31), + MT = BitsN.bits(9,7) x, + configregister'rst = BitsN.@@(BitsN.bits(6,3) x,BitsN.bits(30,16) x)}; fun reg'ConfigRegister x = case x of @@ -2053,12 +2053,12 @@ fun write'rec'ConfigRegister (_,x) = reg'ConfigRegister x; fun write'reg'ConfigRegister (_,x) = rec'ConfigRegister x; fun rec'ConfigRegister1 x = - {C2 = BitsN.bit(x,6), CA = BitsN.bit(x,2), DA = BitsN.bits(x,9,7), - DL = BitsN.bits(x,12,10), DS = BitsN.bits(x,15,13), - EP = BitsN.bit(x,1), FP = BitsN.bit(x,0), IA = BitsN.bits(x,18,16), - IL = BitsN.bits(x,21,19), IS = BitsN.bits(x,24,22), + {C2 = BitsN.bit(x,6), CA = BitsN.bit(x,2), DA = BitsN.bits(9,7) x, + DL = BitsN.bits(12,10) x, DS = BitsN.bits(15,13) x, + EP = BitsN.bit(x,1), FP = BitsN.bit(x,0), IA = BitsN.bits(18,16) x, + IL = BitsN.bits(21,19) x, IS = BitsN.bits(24,22) x, M = BitsN.bit(x,31), MD = BitsN.bit(x,5), - MMUSize = BitsN.bits(x,30,25), PC = BitsN.bit(x,4), WR = BitsN.bit(x,3)}; + MMUSize = BitsN.bits(30,25) x, PC = BitsN.bit(x,4), WR = BitsN.bit(x,3)}; fun reg'ConfigRegister1 x = case x of @@ -2133,10 +2133,10 @@ fun write'rec'ConfigRegister1 (_,x) = reg'ConfigRegister1 x; fun write'reg'ConfigRegister1 (_,x) = rec'ConfigRegister1 x; fun rec'ConfigRegister2 x = - {M = BitsN.bit(x,31), SA = BitsN.bits(x,3,0), SL = BitsN.bits(x,7,4), - SS = BitsN.bits(x,11,8), SU = BitsN.bits(x,15,12), - TA = BitsN.bits(x,19,16), TL = BitsN.bits(x,23,20), - TS = BitsN.bits(x,27,24), TU = BitsN.bits(x,30,28)}; + {M = BitsN.bit(x,31), SA = BitsN.bits(3,0) x, SL = BitsN.bits(7,4) x, + SS = BitsN.bits(11,8) x, SU = BitsN.bits(15,12) x, + TA = BitsN.bits(19,16) x, TL = BitsN.bits(23,20) x, + TS = BitsN.bits(27,24) x, TU = BitsN.bits(30,28) x}; fun reg'ConfigRegister2 x = case x of @@ -2218,8 +2218,8 @@ fun rec'ConfigRegister3 x = VInt = BitsN.bit(x,5), configregister3'rst = BitsN.concat - [BitsN.bits(x,3,3),BitsN.bits(x,9,8),BitsN.bits(x,12,11), - BitsN.bits(x,30,14)]}; + [BitsN.bits(3,3) x,BitsN.bits(9,8) x,BitsN.bits(12,11) x, + BitsN.bits(30,14) x]}; fun reg'ConfigRegister3 x = case x of @@ -2294,8 +2294,8 @@ fun write'rec'ConfigRegister3 (_,x) = reg'ConfigRegister3 x; fun write'reg'ConfigRegister3 (_,x) = rec'ConfigRegister3 x; fun rec'ConfigRegister6 x = - {LTLB = BitsN.bit(x,2), TLBSize = BitsN.bits(x,31,16), - configregister6'rst = BitsN.@@(BitsN.bits(x,1,0),BitsN.bits(x,15,3))}; + {LTLB = BitsN.bit(x,2), TLBSize = BitsN.bits(31,16) x, + configregister6'rst = BitsN.@@(BitsN.bits(1,0) x,BitsN.bits(15,3) x)}; fun reg'ConfigRegister6 x = case x of @@ -2372,10 +2372,10 @@ fun write'rec'ConfigRegister6 (_,x) = reg'ConfigRegister6 x; fun write'reg'ConfigRegister6 (_,x) = rec'ConfigRegister6 x; fun rec'CauseRegister x = - {BD = BitsN.bit(x,31), ExcCode = BitsN.bits(x,6,2), - IP = BitsN.bits(x,15,8), TI = BitsN.bit(x,30), + {BD = BitsN.bit(x,31), ExcCode = BitsN.bits(6,2) x, + IP = BitsN.bits(15,8) x, TI = BitsN.bit(x,30), causeregister'rst = - BitsN.concat[BitsN.bits(x,1,0),BitsN.bits(x,7,7),BitsN.bits(x,29,16)]}; + BitsN.concat[BitsN.bits(1,0) x,BitsN.bits(7,7) x,BitsN.bits(29,16) x]}; fun reg'CauseRegister x = case x of @@ -2452,8 +2452,8 @@ fun write'rec'CauseRegister (_,x) = reg'CauseRegister x; fun write'reg'CauseRegister (_,x) = rec'CauseRegister x; fun rec'Context x = - {BadVPN2 = BitsN.bits(x,22,4), PTEBase = BitsN.bits(x,63,23), - context'rst = BitsN.bits(x,3,0)}; + {BadVPN2 = BitsN.bits(22,4) x, PTEBase = BitsN.bits(63,23) x, + context'rst = BitsN.bits(3,0) x}; fun reg'Context x = case x of @@ -2593,8 +2593,8 @@ fun write'rec'Context (_,x) = reg'Context x; fun write'reg'Context (_,x) = rec'Context x; fun rec'XContext x = - {BadVPN2 = BitsN.bits(x,30,4), PTEBase = BitsN.bits(x,63,33), - R = BitsN.bits(x,32,31), xcontext'rst = BitsN.bits(x,3,0)}; + {BadVPN2 = BitsN.bits(30,4) x, PTEBase = BitsN.bits(63,33) x, + R = BitsN.bits(32,31) x, xcontext'rst = BitsN.bits(3,0) x}; fun reg'XContext x = case x of @@ -2739,7 +2739,7 @@ fun rec'HWREna x = UL = BitsN.bit(x,29), hwrena'rst = BitsN.concat - [BitsN.bits(x,1,1),BitsN.bits(x,28,4),BitsN.bits(x,31,30)]}; + [BitsN.bits(1,1) x,BitsN.bits(28,4) x,BitsN.bits(31,30) x]}; fun reg'HWREna x = case x of @@ -2888,8 +2888,8 @@ fun SignalException ExceptionType = ; PC := (BitsN.- (BitsN.@@ - (BitsN.bits(vectorBase,63,30), - BitsN.+(BitsN.bits(vectorBase,29,0),vectorOffset)), + (BitsN.bits(63,30) vectorBase, + BitsN.+(BitsN.bits(29,0) vectorBase,vectorOffset)), BitsN.B(0x4,64))) ; exceptionSignalled := true ) @@ -2976,16 +2976,16 @@ fun CPR (n,(reg,sel)) = fun write'CPR (value,(n,(reg,sel))) = case (n,(reg,sel)) of (0,(BitsN.B(0x9,5),BitsN.B(0x0,3))) => - CP0 := (CP0_Count_rupd((!CP0),BitsN.bits(value,31,0))) + CP0 := (CP0_Count_rupd((!CP0),BitsN.bits(31,0) value)) | (0,(BitsN.B(0xB,5),BitsN.B(0x0,3))) => - CP0 := (CP0_Compare_rupd((!CP0),BitsN.bits(value,31,0))) + CP0 := (CP0_Compare_rupd((!CP0),BitsN.bits(31,0) value)) | (0,(BitsN.B(0xC,5),BitsN.B(0x0,3))) => let val x0 = (#Status) (!CP0) in CP0 := (CP0_Status_rupd - ((!CP0),write'reg'StatusRegister(x0,BitsN.bits(value,31,0)))) + ((!CP0),write'reg'StatusRegister(x0,BitsN.bits(31,0) value))) end | (0,(BitsN.B(0xD,5),BitsN.B(0x0,3))) => let @@ -2993,7 +2993,7 @@ fun write'CPR (value,(n,(reg,sel))) = in CP0 := (CP0_Cause_rupd - ((!CP0),write'reg'CauseRegister(x0,BitsN.bits(value,31,0)))) + ((!CP0),write'reg'CauseRegister(x0,BitsN.bits(31,0) value))) end | (0,(BitsN.B(0xE,5),BitsN.B(0x0,3))) => CP0 := (CP0_EPC_rupd((!CP0),value)) @@ -3003,12 +3003,12 @@ fun write'CPR (value,(n,(reg,sel))) = in CP0 := (CP0_Config_rupd - ((!CP0),write'reg'ConfigRegister(x0,BitsN.bits(value,31,0)))) + ((!CP0),write'reg'ConfigRegister(x0,BitsN.bits(31,0) value))) end | (0,(BitsN.B(0x17,5),BitsN.B(0x0,3))) => - CP0 := (CP0_Debug_rupd((!CP0),BitsN.bits(value,31,0))) + CP0 := (CP0_Debug_rupd((!CP0),BitsN.bits(31,0) value)) | (0,(BitsN.B(0x1A,5),BitsN.B(0x0,3))) => - CP0 := (CP0_ErrCtl_rupd((!CP0),BitsN.bits(value,31,0))) + CP0 := (CP0_ErrCtl_rupd((!CP0),BitsN.bits(31,0) value)) | (0,(BitsN.B(0x1E,5),BitsN.B(0x0,3))) => CP0 := (CP0_ErrorEPC_rupd((!CP0),value)) | _ => (); @@ -3045,14 +3045,14 @@ fun LoadMemory (CCA,(AccessLength,(pAddr,(vAddr,IorD)))) = fun StoreMemory (CCA,(AccessLength,(MemElem,(pAddr,(vAddr,IorD))))) = let val a = BitsN.&&(pAddr,BitsN.~(BitsN.B(0x7,64))) - val l = BitsN.bits(pAddr,2,0) + val l = BitsN.bits(2,0) pAddr val h = BitsN.+(l,AccessLength) in if BigEndianMem () then ( if l = (BitsN.B(0x0,3)) then MEM := (Map.update - ((!MEM),BitsN.toNat a,BitsN.bits(MemElem,63,56))) + ((!MEM),BitsN.toNat a,BitsN.bits(63,56) MemElem)) else () ; if (BitsN.<=+(l,BitsN.B(0x1,3))) andalso (BitsN.<=+(BitsN.B(0x1,3),h)) @@ -3061,7 +3061,7 @@ fun StoreMemory (CCA,(AccessLength,(MemElem,(pAddr,(vAddr,IorD))))) = in MEM := (Map.update - ((!MEM),BitsN.toNat x,BitsN.bits(MemElem,55,48))) + ((!MEM),BitsN.toNat x,BitsN.bits(55,48) MemElem)) end else () ; if (BitsN.<=+(l,BitsN.B(0x2,3))) andalso @@ -3071,7 +3071,7 @@ fun StoreMemory (CCA,(AccessLength,(MemElem,(pAddr,(vAddr,IorD))))) = in MEM := (Map.update - ((!MEM),BitsN.toNat x,BitsN.bits(MemElem,47,40))) + ((!MEM),BitsN.toNat x,BitsN.bits(47,40) MemElem)) end else () ; if (BitsN.<=+(l,BitsN.B(0x3,3))) andalso @@ -3081,7 +3081,7 @@ fun StoreMemory (CCA,(AccessLength,(MemElem,(pAddr,(vAddr,IorD))))) = in MEM := (Map.update - ((!MEM),BitsN.toNat x,BitsN.bits(MemElem,39,32))) + ((!MEM),BitsN.toNat x,BitsN.bits(39,32) MemElem)) end else () ; if (BitsN.<=+(l,BitsN.B(0x4,3))) andalso @@ -3091,7 +3091,7 @@ fun StoreMemory (CCA,(AccessLength,(MemElem,(pAddr,(vAddr,IorD))))) = in MEM := (Map.update - ((!MEM),BitsN.toNat x,BitsN.bits(MemElem,31,24))) + ((!MEM),BitsN.toNat x,BitsN.bits(31,24) MemElem)) end else () ; if (BitsN.<=+(l,BitsN.B(0x5,3))) andalso @@ -3101,7 +3101,7 @@ fun StoreMemory (CCA,(AccessLength,(MemElem,(pAddr,(vAddr,IorD))))) = in MEM := (Map.update - ((!MEM),BitsN.toNat x,BitsN.bits(MemElem,23,16))) + ((!MEM),BitsN.toNat x,BitsN.bits(23,16) MemElem)) end else () ; if (BitsN.<=+(l,BitsN.B(0x6,3))) andalso @@ -3111,7 +3111,7 @@ fun StoreMemory (CCA,(AccessLength,(MemElem,(pAddr,(vAddr,IorD))))) = in MEM := (Map.update - ((!MEM),BitsN.toNat x,BitsN.bits(MemElem,15,8))) + ((!MEM),BitsN.toNat x,BitsN.bits(15,8) MemElem)) end else () ; if (BitsN.<=+(l,BitsN.B(0x7,3))) andalso @@ -3121,7 +3121,7 @@ fun StoreMemory (CCA,(AccessLength,(MemElem,(pAddr,(vAddr,IorD))))) = in MEM := (Map.update - ((!MEM),BitsN.toNat x,BitsN.bits(MemElem,7,0))) + ((!MEM),BitsN.toNat x,BitsN.bits(7,0) MemElem)) end else () ) @@ -3132,7 +3132,7 @@ fun StoreMemory (CCA,(AccessLength,(MemElem,(pAddr,(vAddr,IorD))))) = in MEM := (Map.update - ((!MEM),BitsN.toNat x,BitsN.bits(MemElem,63,56))) + ((!MEM),BitsN.toNat x,BitsN.bits(63,56) MemElem)) end else () ; if (BitsN.<=+(l,BitsN.B(0x6,3))) andalso @@ -3142,7 +3142,7 @@ fun StoreMemory (CCA,(AccessLength,(MemElem,(pAddr,(vAddr,IorD))))) = in MEM := (Map.update - ((!MEM),BitsN.toNat x,BitsN.bits(MemElem,55,48))) + ((!MEM),BitsN.toNat x,BitsN.bits(55,48) MemElem)) end else () ; if (BitsN.<=+(l,BitsN.B(0x5,3))) andalso @@ -3152,7 +3152,7 @@ fun StoreMemory (CCA,(AccessLength,(MemElem,(pAddr,(vAddr,IorD))))) = in MEM := (Map.update - ((!MEM),BitsN.toNat x,BitsN.bits(MemElem,47,40))) + ((!MEM),BitsN.toNat x,BitsN.bits(47,40) MemElem)) end else () ; if (BitsN.<=+(l,BitsN.B(0x4,3))) andalso @@ -3162,7 +3162,7 @@ fun StoreMemory (CCA,(AccessLength,(MemElem,(pAddr,(vAddr,IorD))))) = in MEM := (Map.update - ((!MEM),BitsN.toNat x,BitsN.bits(MemElem,39,32))) + ((!MEM),BitsN.toNat x,BitsN.bits(39,32) MemElem)) end else () ; if (BitsN.<=+(l,BitsN.B(0x3,3))) andalso @@ -3172,7 +3172,7 @@ fun StoreMemory (CCA,(AccessLength,(MemElem,(pAddr,(vAddr,IorD))))) = in MEM := (Map.update - ((!MEM),BitsN.toNat x,BitsN.bits(MemElem,31,24))) + ((!MEM),BitsN.toNat x,BitsN.bits(31,24) MemElem)) end else () ; if (BitsN.<=+(l,BitsN.B(0x2,3))) andalso @@ -3182,7 +3182,7 @@ fun StoreMemory (CCA,(AccessLength,(MemElem,(pAddr,(vAddr,IorD))))) = in MEM := (Map.update - ((!MEM),BitsN.toNat x,BitsN.bits(MemElem,23,16))) + ((!MEM),BitsN.toNat x,BitsN.bits(23,16) MemElem)) end else () ; if (BitsN.<=+(l,BitsN.B(0x1,3))) andalso @@ -3192,19 +3192,19 @@ fun StoreMemory (CCA,(AccessLength,(MemElem,(pAddr,(vAddr,IorD))))) = in MEM := (Map.update - ((!MEM),BitsN.toNat x,BitsN.bits(MemElem,15,8))) + ((!MEM),BitsN.toNat x,BitsN.bits(15,8) MemElem)) end else () ; if l = (BitsN.B(0x0,3)) then MEM := (Map.update - ((!MEM),BitsN.toNat a,BitsN.bits(MemElem,7,0))) + ((!MEM),BitsN.toNat a,BitsN.bits(7,0) MemElem)) else () ) end; fun Fetch () = - if (BitsN.bits((!PC),1,0)) = (BitsN.B(0x0,2)) + if (BitsN.bits(1,0) (!PC)) = (BitsN.B(0x0,2)) then let val vAddr = (!PC) val (pAddr,CCA) = AddressTranslation(vAddr,(INSTRUCTION,LOAD)) @@ -3212,12 +3212,13 @@ fun Fetch () = LoadMemory(CCA,(WORD,(pAddr,(vAddr,INSTRUCTION)))) val bytesel = BitsN.?? - (BitsN.bits(vAddr,2,0), + (BitsN.bits(2,0) vAddr, BitsN.@@(BigEndianCPU (),BitsN.B(0x0,2))) val memword = BitsN.bits - (memdoubleword,Nat.+(31,Nat.*(8,BitsN.toNat bytesel)), + (Nat.+(31,Nat.*(8,BitsN.toNat bytesel)), Nat.*(8,BitsN.toNat bytesel)) + memdoubleword in Option.SOME memword end @@ -3225,7 +3226,7 @@ fun Fetch () = fun NotWordValue value = let - val top = BitsN.bits(value,63,32) + val top = BitsN.bits(63,32) value in if BitsN.bit(value,31) then not(top = (BitsN.B(0xFFFFFFFF,32))) @@ -3238,11 +3239,11 @@ fun dfn'ADDI (rs,(rt,immediate)) = else () ; let val temp = - BitsN.+(BitsN.bits(GPR rs,32,0),BitsN.signExtend 33 immediate) + BitsN.+(BitsN.bits(32,0) (GPR rs),BitsN.signExtend 33 immediate) in if not((BitsN.bit(temp,32)) = (BitsN.bit(temp,31))) then SignalException Ov - else write'GPR(BitsN.signExtend 64 (BitsN.bits(temp,31,0)),rt) + else write'GPR(BitsN.signExtend 64 (BitsN.bits(31,0) temp),rt) end ); @@ -3252,7 +3253,7 @@ fun dfn'ADDIU (rs,(rt,immediate)) = else () ; let val temp = - BitsN.+(BitsN.bits(GPR rs,31,0),BitsN.signExtend 32 immediate) + BitsN.+(BitsN.bits(31,0) (GPR rs),BitsN.signExtend 32 immediate) in write'GPR(BitsN.signExtend 64 temp,rt) end @@ -3265,7 +3266,7 @@ fun dfn'DADDI (rs,(rt,immediate)) = in if not((BitsN.bit(temp,64)) = (BitsN.bit(temp,63))) then SignalException Ov - else write'GPR(BitsN.bits(temp,63,0),rt) + else write'GPR(BitsN.bits(63,0) temp,rt) end; fun dfn'DADDIU (rs,(rt,immediate)) = @@ -3296,11 +3297,12 @@ fun dfn'ADD (rs,(rt,rd)) = then raise UNPREDICTABLE ("ADD: NotWordValue") else () ; let - val temp = BitsN.+(BitsN.bits(GPR rs,32,0),BitsN.bits(GPR rt,32,0)) + val temp = + BitsN.+(BitsN.bits(32,0) (GPR rs),BitsN.bits(32,0) (GPR rt)) in if not((BitsN.bit(temp,32)) = (BitsN.bit(temp,31))) then SignalException Ov - else write'GPR(BitsN.signExtend 64 (BitsN.bits(temp,31,0)),rd) + else write'GPR(BitsN.signExtend 64 (BitsN.bits(31,0) temp),rd) end ); @@ -3309,7 +3311,8 @@ fun dfn'ADDU (rs,(rt,rd)) = then raise UNPREDICTABLE ("ADDU: NotWordValue") else () ; let - val temp = BitsN.+(BitsN.bits(GPR rs,31,0),BitsN.bits(GPR rt,31,0)) + val temp = + BitsN.+(BitsN.bits(31,0) (GPR rs),BitsN.bits(31,0) (GPR rt)) in write'GPR(BitsN.signExtend 64 temp,rd) end @@ -3320,11 +3323,12 @@ fun dfn'SUB (rs,(rt,rd)) = then raise UNPREDICTABLE ("SUB: NotWordValue") else () ; let - val temp = BitsN.-(BitsN.bits(GPR rs,32,0),BitsN.bits(GPR rt,32,0)) + val temp = + BitsN.-(BitsN.bits(32,0) (GPR rs),BitsN.bits(32,0) (GPR rt)) in if not((BitsN.bit(temp,32)) = (BitsN.bit(temp,31))) then SignalException Ov - else write'GPR(BitsN.signExtend 64 (BitsN.bits(temp,31,0)),rd) + else write'GPR(BitsN.signExtend 64 (BitsN.bits(31,0) temp),rd) end ); @@ -3333,7 +3337,8 @@ fun dfn'SUBU (rs,(rt,rd)) = then raise UNPREDICTABLE ("SUBU: NotWordValue") else () ; let - val temp = BitsN.-(BitsN.bits(GPR rs,31,0),BitsN.bits(GPR rt,31,0)) + val temp = + BitsN.-(BitsN.bits(31,0) (GPR rs),BitsN.bits(31,0) (GPR rt)) in write'GPR(BitsN.signExtend 64 temp,rd) end @@ -3346,7 +3351,7 @@ fun dfn'DADD (rs,(rt,rd)) = in if not((BitsN.bit(temp,64)) = (BitsN.bit(temp,63))) then SignalException Ov - else write'GPR(BitsN.bits(temp,63,0),rd) + else write'GPR(BitsN.bits(63,0) temp,rd) end; fun dfn'DADDU (rs,(rt,rd)) = write'GPR(BitsN.+(GPR rs,GPR rt),rd); @@ -3358,7 +3363,7 @@ fun dfn'DSUB (rs,(rt,rd)) = in if not((BitsN.bit(temp,64)) = (BitsN.bit(temp,63))) then SignalException Ov - else write'GPR(BitsN.bits(temp,63,0),rd) + else write'GPR(BitsN.bits(63,0) temp,rd) end; fun dfn'DSUBU (rs,(rt,rd)) = write'GPR(BitsN.-(GPR rs,GPR rt),rd); @@ -3390,13 +3395,13 @@ fun dfn'MADD (rs,rt) = ; let val temp = BitsN.+ - (BitsN.@@(BitsN.bits(HI (),31,0),BitsN.bits(LO (),31,0)), + (BitsN.@@(BitsN.bits(31,0) (HI ()),BitsN.bits(31,0) (LO ())), BitsN.* - (BitsN.signExtend 64 (BitsN.bits(GPR rs,31,0)), - BitsN.signExtend 64 (BitsN.bits(GPR rt,31,0)))) + (BitsN.signExtend 64 (BitsN.bits(31,0) (GPR rs)), + BitsN.signExtend 64 (BitsN.bits(31,0) (GPR rt)))) in - ( write'HI(BitsN.signExtend 64 (BitsN.bits(temp,63,32))) - ; write'LO(BitsN.signExtend 64 (BitsN.bits(temp,31,0))) + ( write'HI(BitsN.signExtend 64 (BitsN.bits(63,32) temp)) + ; write'LO(BitsN.signExtend 64 (BitsN.bits(31,0) temp)) ) end ); @@ -3408,13 +3413,13 @@ fun dfn'MADDU (rs,rt) = ; let val temp = BitsN.+ - (BitsN.@@(BitsN.bits(HI (),31,0),BitsN.bits(LO (),31,0)), + (BitsN.@@(BitsN.bits(31,0) (HI ()),BitsN.bits(31,0) (LO ())), BitsN.* - (BitsN.zeroExtend 64 (BitsN.bits(GPR rs,31,0)), - BitsN.zeroExtend 64 (BitsN.bits(GPR rt,31,0)))) + (BitsN.zeroExtend 64 (BitsN.bits(31,0) (GPR rs)), + BitsN.zeroExtend 64 (BitsN.bits(31,0) (GPR rt)))) in - ( write'HI(BitsN.signExtend 64 (BitsN.bits(temp,63,32))) - ; write'LO(BitsN.signExtend 64 (BitsN.bits(temp,31,0))) + ( write'HI(BitsN.signExtend 64 (BitsN.bits(63,32) temp)) + ; write'LO(BitsN.signExtend 64 (BitsN.bits(31,0) temp)) ) end ); @@ -3426,13 +3431,13 @@ fun dfn'MSUB (rs,rt) = ; let val temp = BitsN.- - (BitsN.@@(BitsN.bits(HI (),31,0),BitsN.bits(LO (),31,0)), + (BitsN.@@(BitsN.bits(31,0) (HI ()),BitsN.bits(31,0) (LO ())), BitsN.* - (BitsN.signExtend 64 (BitsN.bits(GPR rs,31,0)), - BitsN.signExtend 64 (BitsN.bits(GPR rt,31,0)))) + (BitsN.signExtend 64 (BitsN.bits(31,0) (GPR rs)), + BitsN.signExtend 64 (BitsN.bits(31,0) (GPR rt)))) in - ( write'HI(BitsN.signExtend 64 (BitsN.bits(temp,63,32))) - ; write'LO(BitsN.signExtend 64 (BitsN.bits(temp,31,0))) + ( write'HI(BitsN.signExtend 64 (BitsN.bits(63,32) temp)) + ; write'LO(BitsN.signExtend 64 (BitsN.bits(31,0) temp)) ) end ); @@ -3444,13 +3449,13 @@ fun dfn'MSUBU (rs,rt) = ; let val temp = BitsN.- - (BitsN.@@(BitsN.bits(HI (),31,0),BitsN.bits(LO (),31,0)), + (BitsN.@@(BitsN.bits(31,0) (HI ()),BitsN.bits(31,0) (LO ())), BitsN.* - (BitsN.zeroExtend 64 (BitsN.bits(GPR rs,31,0)), - BitsN.zeroExtend 64 (BitsN.bits(GPR rt,31,0)))) + (BitsN.zeroExtend 64 (BitsN.bits(31,0) (GPR rs)), + BitsN.zeroExtend 64 (BitsN.bits(31,0) (GPR rt)))) in - ( write'HI(BitsN.signExtend 64 (BitsN.bits(temp,63,32))) - ; write'LO(BitsN.signExtend 64 (BitsN.bits(temp,31,0))) + ( write'HI(BitsN.signExtend 64 (BitsN.bits(63,32) temp)) + ; write'LO(BitsN.signExtend 64 (BitsN.bits(31,0) temp)) ) end ); @@ -3461,7 +3466,7 @@ fun dfn'MUL (rs,(rt,rd)) = else () ; write'GPR (BitsN.signExtend 64 - (BitsN.*(BitsN.bits(GPR rs,31,0),BitsN.bits(GPR rt,31,0))),rd) + (BitsN.*(BitsN.bits(31,0) (GPR rs),BitsN.bits(31,0) (GPR rt))),rd) ; lo := NONE ; hi := NONE ); @@ -3473,11 +3478,11 @@ fun dfn'MULT (rs,rt) = ; let val prod = BitsN.* - (BitsN.signExtend 64 (BitsN.bits(GPR rs,31,0)), - BitsN.signExtend 64 (BitsN.bits(GPR rt,31,0))) + (BitsN.signExtend 64 (BitsN.bits(31,0) (GPR rs)), + BitsN.signExtend 64 (BitsN.bits(31,0) (GPR rt))) in - ( write'LO(BitsN.signExtend 64 (BitsN.bits(prod,31,0))) - ; write'HI(BitsN.signExtend 64 (BitsN.bits(prod,63,32))) + ( write'LO(BitsN.signExtend 64 (BitsN.bits(31,0) prod)) + ; write'HI(BitsN.signExtend 64 (BitsN.bits(63,32) prod)) ) end ); @@ -3489,11 +3494,11 @@ fun dfn'MULTU (rs,rt) = ; let val prod = BitsN.* - (BitsN.zeroExtend 64 (BitsN.bits(GPR rs,31,0)), - BitsN.zeroExtend 64 (BitsN.bits(GPR rt,31,0))) + (BitsN.zeroExtend 64 (BitsN.bits(31,0) (GPR rs)), + BitsN.zeroExtend 64 (BitsN.bits(31,0) (GPR rt))) in - ( write'LO(BitsN.signExtend 64 (BitsN.bits(prod,31,0))) - ; write'HI(BitsN.signExtend 64 (BitsN.bits(prod,63,32))) + ( write'LO(BitsN.signExtend 64 (BitsN.bits(31,0) prod)) + ; write'HI(BitsN.signExtend 64 (BitsN.bits(63,32) prod)) ) end ); @@ -3503,7 +3508,7 @@ fun dfn'DMULT (rs,rt) = val prod = BitsN.*(BitsN.signExtend 128 (GPR rs),BitsN.signExtend 128 (GPR rt)) in - ( write'LO(BitsN.bits(prod,63,0)); write'HI(BitsN.bits(prod,127,64)) ) + ( write'LO(BitsN.bits(63,0) prod); write'HI(BitsN.bits(127,64) prod) ) end; fun dfn'DMULTU (rs,rt) = @@ -3511,7 +3516,7 @@ fun dfn'DMULTU (rs,rt) = val prod = BitsN.*(BitsN.zeroExtend 128 (GPR rs),BitsN.zeroExtend 128 (GPR rt)) in - ( write'LO(BitsN.bits(prod,63,0)); write'HI(BitsN.bits(prod,127,64)) ) + ( write'LO(BitsN.bits(63,0) prod); write'HI(BitsN.bits(127,64) prod) ) end; fun dfn'DIV (rs,rt) = @@ -3525,8 +3530,8 @@ fun dfn'DIV (rs,rt) = ; if t = (BitsN.B(0x0,64)) then ( lo := NONE; hi := NONE ) else let - val q = BitsN.quot(BitsN.bits(s,31,0),BitsN.bits(t,31,0)) - val r = BitsN.rem(BitsN.bits(s,31,0),BitsN.bits(t,31,0)) + val q = BitsN.quot(BitsN.bits(31,0) s,BitsN.bits(31,0) t) + val r = BitsN.rem(BitsN.bits(31,0) s,BitsN.bits(31,0) t) in ( write'LO(BitsN.signExtend 64 q) ; write'HI(BitsN.signExtend 64 r) @@ -3546,8 +3551,8 @@ fun dfn'DIVU (rs,rt) = ; if t = (BitsN.B(0x0,64)) then ( lo := NONE; hi := NONE ) else let - val q = BitsN.div(BitsN.bits(s,31,0),BitsN.bits(t,31,0)) - val r = BitsN.mod(BitsN.bits(s,31,0),BitsN.bits(t,31,0)) + val q = BitsN.div(BitsN.bits(31,0) s,BitsN.bits(31,0) t) + val r = BitsN.mod(BitsN.bits(31,0) s,BitsN.bits(31,0) t) in ( write'LO(BitsN.signExtend 64 q) ; write'HI(BitsN.signExtend 64 r) @@ -3593,7 +3598,7 @@ fun dfn'MTLO rs = write'LO(GPR rs); fun dfn'SLL (rt,(rd,sa)) = write'GPR (BitsN.signExtend 64 - (BitsN.<<(BitsN.bits(GPR rt,31,0),BitsN.toNat sa)),rd); + (BitsN.<<(BitsN.bits(31,0) (GPR rt),BitsN.toNat sa)),rd); fun dfn'SRL (rt,(rd,sa)) = ( if NotWordValue(GPR rt) @@ -3601,7 +3606,7 @@ fun dfn'SRL (rt,(rd,sa)) = else () ; write'GPR (BitsN.signExtend 64 - (BitsN.>>+(BitsN.bits(GPR rt,31,0),BitsN.toNat sa)),rd) + (BitsN.>>+(BitsN.bits(31,0) (GPR rt),BitsN.toNat sa)),rd) ); fun dfn'SRA (rt,(rd,sa)) = @@ -3610,16 +3615,16 @@ fun dfn'SRA (rt,(rd,sa)) = else () ; write'GPR (BitsN.signExtend 64 - (BitsN.>>(BitsN.bits(GPR rt,31,0),BitsN.toNat sa)),rd) + (BitsN.>>(BitsN.bits(31,0) (GPR rt),BitsN.toNat sa)),rd) ); fun dfn'SLLV (rs,(rt,rd)) = let - val sa = BitsN.bits(GPR rs,4,0) + val sa = BitsN.bits(4,0) (GPR rs) in write'GPR (BitsN.signExtend 64 - (BitsN.<<(BitsN.bits(GPR rt,31,0),BitsN.toNat sa)),rd) + (BitsN.<<(BitsN.bits(31,0) (GPR rt),BitsN.toNat sa)),rd) end; fun dfn'SRLV (rs,(rt,rd)) = @@ -3627,11 +3632,11 @@ fun dfn'SRLV (rs,(rt,rd)) = then raise UNPREDICTABLE ("SRLV: NotWordValue") else () ; let - val sa = BitsN.bits(GPR rs,4,0) + val sa = BitsN.bits(4,0) (GPR rs) in write'GPR (BitsN.signExtend 64 - (BitsN.>>+(BitsN.bits(GPR rt,31,0),BitsN.toNat sa)),rd) + (BitsN.>>+(BitsN.bits(31,0) (GPR rt),BitsN.toNat sa)),rd) end ); @@ -3640,11 +3645,11 @@ fun dfn'SRAV (rs,(rt,rd)) = then raise UNPREDICTABLE ("SRAV: NotWordValue") else () ; let - val sa = BitsN.bits(GPR rs,4,0) + val sa = BitsN.bits(4,0) (GPR rs) in write'GPR (BitsN.signExtend 64 - (BitsN.>>(BitsN.bits(GPR rt,31,0),BitsN.toNat sa)),rd) + (BitsN.>>(BitsN.bits(31,0) (GPR rt),BitsN.toNat sa)),rd) end ); @@ -3657,21 +3662,21 @@ fun dfn'DSRA (rt,(rd,sa)) = write'GPR(BitsN.>>(GPR rt,BitsN.toNat sa),rd); fun dfn'DSLLV (rs,(rt,rd)) = let - val sa = BitsN.bits(GPR rs,5,0) + val sa = BitsN.bits(5,0) (GPR rs) in write'GPR(BitsN.<<(GPR rt,BitsN.toNat sa),rd) end; fun dfn'DSRLV (rs,(rt,rd)) = let - val sa = BitsN.bits(GPR rs,5,0) + val sa = BitsN.bits(5,0) (GPR rs) in write'GPR(BitsN.>>+(GPR rt,BitsN.toNat sa),rd) end; fun dfn'DSRAV (rs,(rt,rd)) = let - val sa = BitsN.bits(GPR rs,5,0) + val sa = BitsN.bits(5,0) (GPR rs) in write'GPR(BitsN.>>(GPR rt,BitsN.toNat sa),rd) end; @@ -3742,20 +3747,21 @@ fun loadByte (base,(rt,(offset,unsigned))) = then let val pAddr = BitsN.@@ - (BitsN.bits(pAddr,Nat.-(PSIZE,1),3), + (BitsN.bits(Nat.-(PSIZE,1),3) pAddr, BitsN.?? - (BitsN.bits(pAddr,2,0), + (BitsN.bits(2,0) pAddr, BitsN.resize_replicate 3 (ReverseEndian (),3))) val memdoubleword = LoadMemory(CCA,(BYTE,(pAddr,(vAddr,DATA)))) val byte = BitsN.?? - (BitsN.bits(vAddr,2,0), + (BitsN.bits(2,0) vAddr, BitsN.resize_replicate 3 (BigEndianCPU (),3)) val membyte = BitsN.bits - (memdoubleword,Nat.+(7,Nat.*(8,BitsN.toNat byte)), + (Nat.+(7,Nat.*(8,BitsN.toNat byte)), Nat.*(8,BitsN.toNat byte)) + memdoubleword in ( write'GPR (if unsigned @@ -3782,9 +3788,9 @@ fun loadHalf (base,(rt,(offset,unsigned))) = then let val pAddr = BitsN.@@ - (BitsN.bits(pAddr,Nat.-(PSIZE,1),3), + (BitsN.bits(Nat.-(PSIZE,1),3) pAddr, BitsN.?? - (BitsN.bits(pAddr,2,0), + (BitsN.bits(2,0) pAddr, BitsN.@@ (BitsN.resize_replicate 2 (ReverseEndian (),2),BitsN.B(0x0,1)))) @@ -3792,15 +3798,15 @@ fun loadHalf (base,(rt,(offset,unsigned))) = LoadMemory(CCA,(HALFWORD,(pAddr,(vAddr,DATA)))) val byte = BitsN.?? - (BitsN.bits(vAddr,2,0), + (BitsN.bits(2,0) vAddr, BitsN.@@ (BitsN.resize_replicate 2 (BigEndianCPU (),2), BitsN.B(0x0,1))) val memhalf = BitsN.bits - (memdoubleword, - Nat.+(15,Nat.*(8,BitsN.toNat byte)), + (Nat.+(15,Nat.*(8,BitsN.toNat byte)), Nat.*(8,BitsN.toNat byte)) + memdoubleword in ( write'GPR (if unsigned @@ -3817,7 +3823,7 @@ fun loadWord (link,(base,(rt,(offset,unsigned)))) = let val vAddr = BitsN.+(BitsN.signExtend 64 offset,GPR base) in - if not((BitsN.bits(vAddr,1,0)) = (BitsN.B(0x0,2))) + if not((BitsN.bits(1,0) vAddr) = (BitsN.B(0x0,2))) then ( CP0 := (CP0_BadVAddr_rupd((!CP0),vAddr)) ; SignalException AdEL ) @@ -3828,21 +3834,21 @@ fun loadWord (link,(base,(rt,(offset,unsigned)))) = then let val pAddr = BitsN.@@ - (BitsN.bits(pAddr,Nat.-(PSIZE,1),3), + (BitsN.bits(Nat.-(PSIZE,1),3) pAddr, BitsN.?? - (BitsN.bits(pAddr,2,0), + (BitsN.bits(2,0) pAddr, BitsN.@@(ReverseEndian (),BitsN.B(0x0,2)))) val memdoubleword = LoadMemory(CCA,(WORD,(pAddr,(vAddr,DATA)))) val byte = BitsN.?? - (BitsN.bits(vAddr,2,0), + (BitsN.bits(2,0) vAddr, BitsN.@@(BigEndianCPU (),BitsN.B(0x0,2))) val memword = BitsN.bits - (memdoubleword, - Nat.+(31,Nat.*(8,BitsN.toNat byte)), + (Nat.+(31,Nat.*(8,BitsN.toNat byte)), Nat.*(8,BitsN.toNat byte)) + memdoubleword in ( write'GPR (if unsigned @@ -3866,7 +3872,7 @@ fun loadDoubleword (link,(base,(rt,offset))) = let val vAddr = BitsN.+(BitsN.signExtend 64 offset,GPR base) in - if not((BitsN.bits(vAddr,2,0)) = (BitsN.B(0x0,3))) + if not((BitsN.bits(2,0) vAddr) = (BitsN.B(0x0,3))) then ( CP0 := (CP0_BadVAddr_rupd((!CP0),vAddr)) ; SignalException AdEL ) @@ -3922,9 +3928,9 @@ fun dfn'LWL (base,(rt,offset)) = then let val pAddr = BitsN.@@ - (BitsN.bits(pAddr,Nat.-(PSIZE,1),3), + (BitsN.bits(Nat.-(PSIZE,1),3) pAddr, BitsN.?? - (BitsN.bits(pAddr,2,0), + (BitsN.bits(2,0) pAddr, BitsN.resize_replicate 3 (ReverseEndian (),3))) val pAddr = if BigEndianMem () @@ -3932,9 +3938,9 @@ fun dfn'LWL (base,(rt,offset)) = else BitsN.&&(pAddr,BitsN.~(BitsN.B(0x7,64))) val byte = BitsN.?? - (BitsN.bits(vAddr,1,0), + (BitsN.bits(1,0) vAddr, BitsN.resize_replicate 2 (BigEndianCPU (),2)) - val word = BitsN.??(BitsN.bits(vAddr,2,2),BigEndianCPU ()) + val word = BitsN.??(BitsN.bits(2,2) vAddr,BigEndianCPU ()) val memdoubleword = LoadMemory (CCA,(BitsN.@@(BitsN.B(0x0,1),byte),(pAddr,(vAddr,DATA)))) @@ -3942,32 +3948,32 @@ fun dfn'LWL (base,(rt,offset)) = case (word,byte) of (BitsN.B(0x0,1),BitsN.B(0x0,2)) => BitsN.@@ - (BitsN.bits(memdoubleword,7,0), - BitsN.bits(GPR rt,23,0)) + (BitsN.bits(7,0) memdoubleword, + BitsN.bits(23,0) (GPR rt)) | (BitsN.B(0x0,1),BitsN.B(0x1,2)) => BitsN.@@ - (BitsN.bits(memdoubleword,15,0), - BitsN.bits(GPR rt,15,0)) + (BitsN.bits(15,0) memdoubleword, + BitsN.bits(15,0) (GPR rt)) | (BitsN.B(0x0,1),BitsN.B(0x2,2)) => BitsN.@@ - (BitsN.bits(memdoubleword,23,0), - BitsN.bits(GPR rt,7,0)) + (BitsN.bits(23,0) memdoubleword, + BitsN.bits(7,0) (GPR rt)) | (BitsN.B(0x0,1),BitsN.B(0x3,2)) => - BitsN.bits(memdoubleword,31,0) + BitsN.bits(31,0) memdoubleword | (BitsN.B(0x1,1),BitsN.B(0x0,2)) => BitsN.@@ - (BitsN.bits(memdoubleword,39,32), - BitsN.bits(GPR rt,23,0)) + (BitsN.bits(39,32) memdoubleword, + BitsN.bits(23,0) (GPR rt)) | (BitsN.B(0x1,1),BitsN.B(0x1,2)) => BitsN.@@ - (BitsN.bits(memdoubleword,47,32), - BitsN.bits(GPR rt,15,0)) + (BitsN.bits(47,32) memdoubleword, + BitsN.bits(15,0) (GPR rt)) | (BitsN.B(0x1,1),BitsN.B(0x2,2)) => BitsN.@@ - (BitsN.bits(memdoubleword,55,32), - BitsN.bits(GPR rt,7,0)) + (BitsN.bits(55,32) memdoubleword, + BitsN.bits(7,0) (GPR rt)) | (BitsN.B(0x1,1),BitsN.B(0x3,2)) => - BitsN.bits(memdoubleword,63,32) + BitsN.bits(63,32) memdoubleword in ( write'GPR(BitsN.signExtend 64 temp,rt); LLbit := NONE ) end @@ -3983,9 +3989,9 @@ fun dfn'LWR (base,(rt,offset)) = then let val pAddr = BitsN.@@ - (BitsN.bits(pAddr,Nat.-(PSIZE,1),3), + (BitsN.bits(Nat.-(PSIZE,1),3) pAddr, BitsN.?? - (BitsN.bits(pAddr,2,0), + (BitsN.bits(2,0) pAddr, BitsN.resize_replicate 3 (ReverseEndian (),3))) val pAddr = if BigEndianMem () @@ -3993,9 +3999,9 @@ fun dfn'LWR (base,(rt,offset)) = else BitsN.&&(pAddr,BitsN.~(BitsN.B(0x7,64))) val byte = BitsN.?? - (BitsN.bits(vAddr,1,0), + (BitsN.bits(1,0) vAddr, BitsN.resize_replicate 2 (BigEndianCPU (),2)) - val word = BitsN.??(BitsN.bits(vAddr,2,2),BigEndianCPU ()) + val word = BitsN.??(BitsN.bits(2,2) vAddr,BigEndianCPU ()) val memdoubleword = LoadMemory (CCA, @@ -4004,33 +4010,33 @@ fun dfn'LWR (base,(rt,offset)) = val temp = case (word,byte) of (BitsN.B(0x0,1),BitsN.B(0x0,2)) => - BitsN.bits(memdoubleword,31,0) + BitsN.bits(31,0) memdoubleword | (BitsN.B(0x0,1),BitsN.B(0x1,2)) => BitsN.@@ - (BitsN.bits(GPR rt,31,24), - BitsN.bits(memdoubleword,31,8)) + (BitsN.bits(31,24) (GPR rt), + BitsN.bits(31,8) memdoubleword) | (BitsN.B(0x0,1),BitsN.B(0x2,2)) => BitsN.@@ - (BitsN.bits(GPR rt,31,16), - BitsN.bits(memdoubleword,31,16)) + (BitsN.bits(31,16) (GPR rt), + BitsN.bits(31,16) memdoubleword) | (BitsN.B(0x0,1),BitsN.B(0x3,2)) => BitsN.@@ - (BitsN.bits(GPR rt,31,8), - BitsN.bits(memdoubleword,31,24)) + (BitsN.bits(31,8) (GPR rt), + BitsN.bits(31,24) memdoubleword) | (BitsN.B(0x1,1),BitsN.B(0x0,2)) => - BitsN.bits(memdoubleword,63,32) + BitsN.bits(63,32) memdoubleword | (BitsN.B(0x1,1),BitsN.B(0x1,2)) => BitsN.@@ - (BitsN.bits(GPR rt,31,24), - BitsN.bits(memdoubleword,63,40)) + (BitsN.bits(31,24) (GPR rt), + BitsN.bits(63,40) memdoubleword) | (BitsN.B(0x1,1),BitsN.B(0x2,2)) => BitsN.@@ - (BitsN.bits(GPR rt,31,16), - BitsN.bits(memdoubleword,63,48)) + (BitsN.bits(31,16) (GPR rt), + BitsN.bits(63,48) memdoubleword) | (BitsN.B(0x1,1),BitsN.B(0x3,2)) => BitsN.@@ - (BitsN.bits(GPR rt,31,8), - BitsN.bits(memdoubleword,63,56)) + (BitsN.bits(31,8) (GPR rt), + BitsN.bits(63,56) memdoubleword) in ( write'GPR(BitsN.signExtend 64 temp,rt); LLbit := NONE ) end @@ -4046,9 +4052,9 @@ fun dfn'LDL (base,(rt,offset)) = then let val pAddr = BitsN.@@ - (BitsN.bits(pAddr,Nat.-(PSIZE,1),3), + (BitsN.bits(Nat.-(PSIZE,1),3) pAddr, BitsN.?? - (BitsN.bits(pAddr,2,0), + (BitsN.bits(2,0) pAddr, BitsN.resize_replicate 3 (ReverseEndian (),3))) val pAddr = if BigEndianMem () @@ -4056,7 +4062,7 @@ fun dfn'LDL (base,(rt,offset)) = else BitsN.&&(pAddr,BitsN.~(BitsN.B(0x7,64))) val byte = BitsN.?? - (BitsN.bits(vAddr,2,0), + (BitsN.bits(2,0) vAddr, BitsN.resize_replicate 3 (BigEndianCPU (),3)) val memdoubleword = LoadMemory(CCA,(byte,(pAddr,(vAddr,DATA)))) @@ -4065,33 +4071,33 @@ fun dfn'LDL (base,(rt,offset)) = (case byte of BitsN.B(0x0,3) => BitsN.@@ - (BitsN.bits(memdoubleword,7,0), - BitsN.bits(GPR rt,55,0)) + (BitsN.bits(7,0) memdoubleword, + BitsN.bits(55,0) (GPR rt)) | BitsN.B(0x1,3) => BitsN.@@ - (BitsN.bits(memdoubleword,15,0), - BitsN.bits(GPR rt,47,0)) + (BitsN.bits(15,0) memdoubleword, + BitsN.bits(47,0) (GPR rt)) | BitsN.B(0x2,3) => BitsN.@@ - (BitsN.bits(memdoubleword,23,0), - BitsN.bits(GPR rt,39,0)) + (BitsN.bits(23,0) memdoubleword, + BitsN.bits(39,0) (GPR rt)) | BitsN.B(0x3,3) => BitsN.@@ - (BitsN.bits(memdoubleword,31,0), - BitsN.bits(GPR rt,31,0)) + (BitsN.bits(31,0) memdoubleword, + BitsN.bits(31,0) (GPR rt)) | BitsN.B(0x4,3) => BitsN.@@ - (BitsN.bits(memdoubleword,39,0), - BitsN.bits(GPR rt,23,0)) + (BitsN.bits(39,0) memdoubleword, + BitsN.bits(23,0) (GPR rt)) | BitsN.B(0x5,3) => BitsN.@@ - (BitsN.bits(memdoubleword,47,0), - BitsN.bits(GPR rt,15,0)) + (BitsN.bits(47,0) memdoubleword, + BitsN.bits(15,0) (GPR rt)) | BitsN.B(0x6,3) => BitsN.@@ - (BitsN.bits(memdoubleword,55,0), - BitsN.bits(GPR rt,7,0)) - | BitsN.B(0x7,3) => BitsN.bits(memdoubleword,63,0) + (BitsN.bits(55,0) memdoubleword, + BitsN.bits(7,0) (GPR rt)) + | BitsN.B(0x7,3) => BitsN.bits(63,0) memdoubleword | _ => raise General.Bind,rt) ; LLbit := NONE ) @@ -4108,9 +4114,9 @@ fun dfn'LDR (base,(rt,offset)) = then let val pAddr = BitsN.@@ - (BitsN.bits(pAddr,Nat.-(PSIZE,1),3), + (BitsN.bits(Nat.-(PSIZE,1),3) pAddr, BitsN.?? - (BitsN.bits(pAddr,2,0), + (BitsN.bits(2,0) pAddr, BitsN.resize_replicate 3 (ReverseEndian (),3))) val pAddr = if BigEndianMem () @@ -4118,7 +4124,7 @@ fun dfn'LDR (base,(rt,offset)) = else BitsN.&&(pAddr,BitsN.~(BitsN.B(0x7,64))) val byte = BitsN.?? - (BitsN.bits(vAddr,2,0), + (BitsN.bits(2,0) vAddr, BitsN.resize_replicate 3 (BigEndianCPU (),3)) val memdoubleword = LoadMemory @@ -4126,35 +4132,35 @@ fun dfn'LDR (base,(rt,offset)) = in ( write'GPR (case byte of - BitsN.B(0x0,3) => BitsN.bits(memdoubleword,63,0) + BitsN.B(0x0,3) => BitsN.bits(63,0) memdoubleword | BitsN.B(0x1,3) => BitsN.@@ - (BitsN.bits(GPR rt,63,56), - BitsN.bits(memdoubleword,63,8)) + (BitsN.bits(63,56) (GPR rt), + BitsN.bits(63,8) memdoubleword) | BitsN.B(0x2,3) => BitsN.@@ - (BitsN.bits(GPR rt,63,48), - BitsN.bits(memdoubleword,63,16)) + (BitsN.bits(63,48) (GPR rt), + BitsN.bits(63,16) memdoubleword) | BitsN.B(0x3,3) => BitsN.@@ - (BitsN.bits(GPR rt,63,40), - BitsN.bits(memdoubleword,63,24)) + (BitsN.bits(63,40) (GPR rt), + BitsN.bits(63,24) memdoubleword) | BitsN.B(0x4,3) => BitsN.@@ - (BitsN.bits(GPR rt,63,32), - BitsN.bits(memdoubleword,63,32)) + (BitsN.bits(63,32) (GPR rt), + BitsN.bits(63,32) memdoubleword) | BitsN.B(0x5,3) => BitsN.@@ - (BitsN.bits(GPR rt,63,24), - BitsN.bits(memdoubleword,63,40)) + (BitsN.bits(63,24) (GPR rt), + BitsN.bits(63,40) memdoubleword) | BitsN.B(0x6,3) => BitsN.@@ - (BitsN.bits(GPR rt,63,16), - BitsN.bits(memdoubleword,63,48)) + (BitsN.bits(63,16) (GPR rt), + BitsN.bits(63,48) memdoubleword) | BitsN.B(0x7,3) => BitsN.@@ - (BitsN.bits(GPR rt,63,8), - BitsN.bits(memdoubleword,63,56)) + (BitsN.bits(63,8) (GPR rt), + BitsN.bits(63,56) memdoubleword) | _ => raise General.Bind,rt) ; LLbit := NONE ) @@ -4171,13 +4177,13 @@ fun dfn'SB (base,(rt,offset)) = then let val pAddr = BitsN.@@ - (BitsN.bits(pAddr,Nat.-(PSIZE,1),3), + (BitsN.bits(Nat.-(PSIZE,1),3) pAddr, BitsN.?? - (BitsN.bits(pAddr,2,0), + (BitsN.bits(2,0) pAddr, BitsN.resize_replicate 3 (ReverseEndian (),3))) val bytesel = BitsN.?? - (BitsN.bits(vAddr,2,0), + (BitsN.bits(2,0) vAddr, BitsN.resize_replicate 3 (BigEndianCPU (),3)) val datadoubleword = BitsN.<<(GPR rt,Nat.*(8,BitsN.toNat bytesel)) @@ -4205,15 +4211,15 @@ fun dfn'SH (base,(rt,offset)) = then let val pAddr = BitsN.@@ - (BitsN.bits(pAddr,Nat.-(PSIZE,1),3), + (BitsN.bits(Nat.-(PSIZE,1),3) pAddr, BitsN.?? - (BitsN.bits(pAddr,2,0), + (BitsN.bits(2,0) pAddr, BitsN.@@ (BitsN.resize_replicate 2 (ReverseEndian (),2),BitsN.B(0x0,1)))) val bytesel = BitsN.?? - (BitsN.bits(vAddr,2,0), + (BitsN.bits(2,0) vAddr, BitsN.@@ (BitsN.resize_replicate 2 (BigEndianCPU (),2), BitsN.B(0x0,1))) @@ -4234,7 +4240,7 @@ fun storeWord (base,(rt,offset)) = let val vAddr = BitsN.+(BitsN.signExtend 64 offset,GPR base) in - if not((BitsN.bits(vAddr,1,0)) = (BitsN.B(0x0,2))) + if not((BitsN.bits(1,0) vAddr) = (BitsN.B(0x0,2))) then ( CP0 := (CP0_BadVAddr_rupd((!CP0),vAddr)) ; SignalException AdES ) @@ -4245,13 +4251,13 @@ fun storeWord (base,(rt,offset)) = then let val pAddr = BitsN.@@ - (BitsN.bits(pAddr,Nat.-(PSIZE,1),3), + (BitsN.bits(Nat.-(PSIZE,1),3) pAddr, BitsN.?? - (BitsN.bits(pAddr,2,0), + (BitsN.bits(2,0) pAddr, BitsN.@@(ReverseEndian (),BitsN.B(0x0,2)))) val bytesel = BitsN.?? - (BitsN.bits(vAddr,2,0), + (BitsN.bits(2,0) vAddr, BitsN.@@(BigEndianCPU (),BitsN.B(0x0,2))) val datadoubleword = BitsN.<<(GPR rt,Nat.*(8,BitsN.toNat bytesel)) @@ -4267,7 +4273,7 @@ fun storeDoubleword (base,(rt,offset)) = let val vAddr = BitsN.+(BitsN.signExtend 64 offset,GPR base) in - if not((BitsN.bits(vAddr,2,0)) = (BitsN.B(0x0,3))) + if not((BitsN.bits(2,0) vAddr) = (BitsN.B(0x0,3))) then ( CP0 := (CP0_BadVAddr_rupd((!CP0),vAddr)) ; SignalException AdES ) @@ -4317,9 +4323,9 @@ fun dfn'SWL (base,(rt,offset)) = then let val pAddr = BitsN.@@ - (BitsN.bits(pAddr,Nat.-(PSIZE,1),3), + (BitsN.bits(Nat.-(PSIZE,1),3) pAddr, BitsN.?? - (BitsN.bits(pAddr,2,0), + (BitsN.bits(2,0) pAddr, BitsN.resize_replicate 3 (ReverseEndian (),3))) val pAddr = if BigEndianMem () @@ -4327,23 +4333,23 @@ fun dfn'SWL (base,(rt,offset)) = else BitsN.&&(pAddr,BitsN.~(BitsN.B(0x3,64))) val byte = BitsN.?? - (BitsN.bits(vAddr,1,0), + (BitsN.bits(1,0) vAddr, BitsN.resize_replicate 2 (BigEndianCPU (),2)) - val word = BitsN.??(BitsN.bits(vAddr,2,2),BigEndianCPU ()) + val word = BitsN.??(BitsN.bits(2,2) vAddr,BigEndianCPU ()) val datadoubleword = case byte of BitsN.B(0x0,2) => BitsN.fromNat - (BitsN.toNat(BitsN.bits(GPR rt,31,24)),64) + (BitsN.toNat(BitsN.bits(31,24) (GPR rt)),64) | BitsN.B(0x1,2) => BitsN.fromNat - (BitsN.toNat(BitsN.bits(GPR rt,31,16)),64) + (BitsN.toNat(BitsN.bits(31,16) (GPR rt)),64) | BitsN.B(0x2,2) => BitsN.fromNat - (BitsN.toNat(BitsN.bits(GPR rt,31,8)),64) + (BitsN.toNat(BitsN.bits(31,8) (GPR rt)),64) | BitsN.B(0x3,2) => BitsN.fromNat - (BitsN.toNat(BitsN.bits(GPR rt,31,0)),64) + (BitsN.toNat(BitsN.bits(31,0) (GPR rt)),64) | _ => raise General.Bind val datadoubleword = if word = (BitsN.B(0x1,1)) @@ -4367,9 +4373,9 @@ fun dfn'SWR (base,(rt,offset)) = then let val pAddr = BitsN.@@ - (BitsN.bits(pAddr,Nat.-(PSIZE,1),3), + (BitsN.bits(Nat.-(PSIZE,1),3) pAddr, BitsN.?? - (BitsN.bits(pAddr,2,0), + (BitsN.bits(2,0) pAddr, BitsN.resize_replicate 3 (ReverseEndian (),3))) val pAddr = if BigEndianMem () @@ -4377,42 +4383,42 @@ fun dfn'SWR (base,(rt,offset)) = else pAddr val byte = BitsN.?? - (BitsN.bits(vAddr,1,0), + (BitsN.bits(1,0) vAddr, BitsN.resize_replicate 2 (BigEndianCPU (),2)) - val word = BitsN.??(BitsN.bits(vAddr,2,2),BigEndianCPU ()) + val word = BitsN.??(BitsN.bits(2,2) vAddr,BigEndianCPU ()) val datadoubleword = case (word,byte) of (BitsN.B(0x0,1),BitsN.B(0x0,2)) => BitsN.fromNat - (BitsN.toNat(BitsN.bits(GPR rt,31,0)),64) + (BitsN.toNat(BitsN.bits(31,0) (GPR rt)),64) | (BitsN.B(0x0,1),BitsN.B(0x1,2)) => BitsN.<< (BitsN.fromNat - (BitsN.toNat(BitsN.bits(GPR rt,23,0)),64),8) + (BitsN.toNat(BitsN.bits(23,0) (GPR rt)),64),8) | (BitsN.B(0x0,1),BitsN.B(0x2,2)) => BitsN.<< (BitsN.fromNat - (BitsN.toNat(BitsN.bits(GPR rt,15,0)),64),16) + (BitsN.toNat(BitsN.bits(15,0) (GPR rt)),64),16) | (BitsN.B(0x0,1),BitsN.B(0x3,2)) => BitsN.<< (BitsN.fromNat - (BitsN.toNat(BitsN.bits(GPR rt,7,0)),64),24) + (BitsN.toNat(BitsN.bits(7,0) (GPR rt)),64),24) | (BitsN.B(0x1,1),BitsN.B(0x0,2)) => BitsN.<< (BitsN.fromNat - (BitsN.toNat(BitsN.bits(GPR rt,31,0)),64),32) + (BitsN.toNat(BitsN.bits(31,0) (GPR rt)),64),32) | (BitsN.B(0x1,1),BitsN.B(0x1,2)) => BitsN.<< (BitsN.fromNat - (BitsN.toNat(BitsN.bits(GPR rt,23,0)),64),40) + (BitsN.toNat(BitsN.bits(23,0) (GPR rt)),64),40) | (BitsN.B(0x1,1),BitsN.B(0x2,2)) => BitsN.<< (BitsN.fromNat - (BitsN.toNat(BitsN.bits(GPR rt,15,0)),64),48) + (BitsN.toNat(BitsN.bits(15,0) (GPR rt)),64),48) | (BitsN.B(0x1,1),BitsN.B(0x3,2)) => BitsN.<< (BitsN.fromNat - (BitsN.toNat(BitsN.bits(GPR rt,7,0)),64),56) + (BitsN.toNat(BitsN.bits(7,0) (GPR rt)),64),56) in StoreMemory (CCA, @@ -4431,9 +4437,9 @@ fun dfn'SDL (base,(rt,offset)) = then let val pAddr = BitsN.@@ - (BitsN.bits(pAddr,Nat.-(PSIZE,1),3), + (BitsN.bits(Nat.-(PSIZE,1),3) pAddr, BitsN.?? - (BitsN.bits(pAddr,2,0), + (BitsN.bits(2,0) pAddr, BitsN.resize_replicate 3 (ReverseEndian (),3))) val pAddr = if BigEndianMem () @@ -4441,31 +4447,31 @@ fun dfn'SDL (base,(rt,offset)) = else BitsN.&&(pAddr,BitsN.~(BitsN.B(0x7,64))) val byte = BitsN.?? - (BitsN.bits(vAddr,2,0), + (BitsN.bits(2,0) vAddr, BitsN.resize_replicate 3 (BigEndianCPU (),3)) val datadoubleword = case byte of BitsN.B(0x0,3) => BitsN.fromNat - (BitsN.toNat(BitsN.bits(GPR rt,63,56)),64) + (BitsN.toNat(BitsN.bits(63,56) (GPR rt)),64) | BitsN.B(0x1,3) => BitsN.fromNat - (BitsN.toNat(BitsN.bits(GPR rt,63,48)),64) + (BitsN.toNat(BitsN.bits(63,48) (GPR rt)),64) | BitsN.B(0x2,3) => BitsN.fromNat - (BitsN.toNat(BitsN.bits(GPR rt,63,40)),64) + (BitsN.toNat(BitsN.bits(63,40) (GPR rt)),64) | BitsN.B(0x3,3) => BitsN.fromNat - (BitsN.toNat(BitsN.bits(GPR rt,63,32)),64) + (BitsN.toNat(BitsN.bits(63,32) (GPR rt)),64) | BitsN.B(0x4,3) => BitsN.fromNat - (BitsN.toNat(BitsN.bits(GPR rt,63,24)),64) + (BitsN.toNat(BitsN.bits(63,24) (GPR rt)),64) | BitsN.B(0x5,3) => BitsN.fromNat - (BitsN.toNat(BitsN.bits(GPR rt,63,16)),64) + (BitsN.toNat(BitsN.bits(63,16) (GPR rt)),64) | BitsN.B(0x6,3) => BitsN.fromNat - (BitsN.toNat(BitsN.bits(GPR rt,63,8)),64) + (BitsN.toNat(BitsN.bits(63,8) (GPR rt)),64) | BitsN.B(0x7,3) => GPR rt | _ => raise General.Bind in @@ -4483,9 +4489,9 @@ fun dfn'SDR (base,(rt,offset)) = then let val pAddr = BitsN.@@ - (BitsN.bits(pAddr,Nat.-(PSIZE,1),3), + (BitsN.bits(Nat.-(PSIZE,1),3) pAddr, BitsN.?? - (BitsN.bits(pAddr,2,0), + (BitsN.bits(2,0) pAddr, BitsN.resize_replicate 3 (ReverseEndian (),3))) val pAddr = if BigEndianMem () @@ -4493,7 +4499,7 @@ fun dfn'SDR (base,(rt,offset)) = else pAddr val byte = BitsN.?? - (BitsN.bits(vAddr,2,0), + (BitsN.bits(2,0) vAddr, BitsN.resize_replicate 3 (BigEndianCPU (),3)) val datadoubleword = case byte of @@ -4501,31 +4507,31 @@ fun dfn'SDR (base,(rt,offset)) = | BitsN.B(0x1,3) => BitsN.<< (BitsN.fromNat - (BitsN.toNat(BitsN.bits(GPR rt,55,0)),64),8) + (BitsN.toNat(BitsN.bits(55,0) (GPR rt)),64),8) | BitsN.B(0x2,3) => BitsN.<< (BitsN.fromNat - (BitsN.toNat(BitsN.bits(GPR rt,47,0)),64),16) + (BitsN.toNat(BitsN.bits(47,0) (GPR rt)),64),16) | BitsN.B(0x3,3) => BitsN.<< (BitsN.fromNat - (BitsN.toNat(BitsN.bits(GPR rt,39,0)),64),24) + (BitsN.toNat(BitsN.bits(39,0) (GPR rt)),64),24) | BitsN.B(0x4,3) => BitsN.<< (BitsN.fromNat - (BitsN.toNat(BitsN.bits(GPR rt,31,0)),64),32) + (BitsN.toNat(BitsN.bits(31,0) (GPR rt)),64),32) | BitsN.B(0x5,3) => BitsN.<< (BitsN.fromNat - (BitsN.toNat(BitsN.bits(GPR rt,23,0)),64),40) + (BitsN.toNat(BitsN.bits(23,0) (GPR rt)),64),40) | BitsN.B(0x6,3) => BitsN.<< (BitsN.fromNat - (BitsN.toNat(BitsN.bits(GPR rt,15,0)),64),48) + (BitsN.toNat(BitsN.bits(15,0) (GPR rt)),64),48) | BitsN.B(0x7,3) => BitsN.<< (BitsN.fromNat - (BitsN.toNat(BitsN.bits(GPR rt,7,0)),64),56) + (BitsN.toNat(BitsN.bits(7,0) (GPR rt)),64),56) | _ => raise General.Bind in StoreMemory @@ -4582,7 +4588,7 @@ fun dfn'DMTC0 (rt,(rd,sel)) = fun dfn'MFC0 (rt,(rd,sel)) = if ((#CU0)((#Status) (!CP0))) orelse (KernelMode ()) then write'GPR - (BitsN.signExtend 64 (BitsN.bits(CPR(0,(rd,sel)),31,0)),rt) + (BitsN.signExtend 64 (BitsN.bits(31,0) (CPR(0,(rd,sel)))),rt) else SignalException CpU; fun dfn'DMFC0 (rt,(rd,sel)) = @@ -4594,14 +4600,14 @@ fun dfn'J instr_index = BranchTo := (Option.SOME (false, - BitsN.concat[BitsN.bits((!PC),63,28),instr_index,BitsN.B(0x0,2)])); + BitsN.concat[BitsN.bits(63,28) (!PC),instr_index,BitsN.B(0x0,2)])); fun dfn'JAL instr_index = ( write'GPR(BitsN.+((!PC),BitsN.B(0x8,64)),BitsN.B(0x1F,5)) ; BranchTo := (Option.SOME (false, - BitsN.concat[BitsN.bits((!PC),63,28),instr_index,BitsN.B(0x0,2)])) + BitsN.concat[BitsN.bits(63,28) (!PC),instr_index,BitsN.B(0x0,2)])) ); fun dfn'JR rs = BranchTo := (Option.SOME(false,GPR rs)); diff --git a/examples/l3-machine-code/x64/model/x64.sig b/examples/l3-machine-code/x64/model/x64.sig index f2ebdc3622..b0a9bb36e9 100644 --- a/examples/l3-machine-code/x64/model/x64.sig +++ b/examples/l3-machine-code/x64/model/x64.sig @@ -1,4 +1,4 @@ -(* x64 - generated by L<3> - Wed Jun 10 13:04:41 2015 *) +(* x64 - generated by L3 - Wed Jul 15 10:49:59 2015 *) signature x64 = sig diff --git a/examples/l3-machine-code/x64/model/x64.sml b/examples/l3-machine-code/x64/model/x64.sml index e3f77f99f4..9c234ce9a8 100644 --- a/examples/l3-machine-code/x64/model/x64.sml +++ b/examples/l3-machine-code/x64/model/x64.sml @@ -1,4 +1,4 @@ -(* x64 - generated by L<3> - Wed Jun 10 13:04:41 2015 *) +(* x64 - generated by L3 - Wed Jul 15 10:49:59 2015 *) structure x64 :> x64 = struct @@ -437,11 +437,11 @@ fun write'mem8 (b,addr) = MEM := (Map.update((!MEM),BitsN.toNat addr,b)); fun mem16 addr = BitsN.@@(mem8(BitsN.+(addr,BitsN.B(0x1,64))),mem8 addr); fun write'mem16 (w,addr) = - ( write'mem8(BitsN.bits(w,7,0),addr) + ( write'mem8(BitsN.bits(7,0) w,addr) ; let val x = BitsN.+(addr,BitsN.B(0x1,64)) in - write'mem8(BitsN.bits(w,15,8),x) + write'mem8(BitsN.bits(15,8) w,x) end ); @@ -449,11 +449,11 @@ fun mem32 addr = BitsN.@@(mem16(BitsN.+(addr,BitsN.B(0x2,64))),mem16 addr); fun write'mem32 (w,addr) = - ( write'mem16(BitsN.bits(w,15,0),addr) + ( write'mem16(BitsN.bits(15,0) w,addr) ; let val x = BitsN.+(addr,BitsN.B(0x2,64)) in - write'mem16(BitsN.bits(w,31,16),x) + write'mem16(BitsN.bits(31,16) w,x) end ); @@ -461,11 +461,11 @@ fun mem64 addr = BitsN.@@(mem32(BitsN.+(addr,BitsN.B(0x4,64))),mem32 addr); fun write'mem64 (w,addr) = - ( write'mem32(BitsN.bits(w,31,0),addr) + ( write'mem32(BitsN.bits(31,0) w,addr) ; let val x = BitsN.+(addr,BitsN.B(0x4,64)) in - write'mem32(BitsN.bits(w,63,32),x) + write'mem32(BitsN.bits(63,32) w,x) end ); @@ -577,7 +577,7 @@ fun write'EA (w,ea) = REG := (Map.update ((!REG),Cast.ZregToNat r, - BitsN.bitFieldInsert(w0,BitsN.bits(w,7,0),7,0))) + BitsN.bitFieldInsert(7,0) (w0,BitsN.bits(7,0) w))) end else let val x = Cast.natToZreg(Nat.-(Cast.ZregToNat r,4)) @@ -586,7 +586,7 @@ fun write'EA (w,ea) = REG := (Map.update ((!REG),Cast.ZregToNat x, - BitsN.bitFieldInsert(w0,BitsN.bits(w,7,0),15,8))) + BitsN.bitFieldInsert(15,8) (w0,BitsN.bits(7,0) w))) end) | Zea_r(Z16,r) => let @@ -595,16 +595,16 @@ fun write'EA (w,ea) = REG := (Map.update ((!REG),Cast.ZregToNat r, - BitsN.bitFieldInsert(w0,BitsN.bits(w,15,0),15,0))) + BitsN.bitFieldInsert(15,0) (w0,BitsN.bits(15,0) w))) end | Zea_r(Z32,r) => REG := (Map.update - ((!REG),Cast.ZregToNat r,BitsN.zeroExtend 64 (BitsN.bits(w,31,0)))) + ((!REG),Cast.ZregToNat r,BitsN.zeroExtend 64 (BitsN.bits(31,0) w))) | Zea_r(Z64,r) => REG := (Map.update((!REG),Cast.ZregToNat r,w)) - | Zea_m(Z8 _,a) => write'mem8(BitsN.bits(w,7,0),a) - | Zea_m(Z16,a) => write'mem16(BitsN.bits(w,15,0),a) - | Zea_m(Z32,a) => write'mem32(BitsN.bits(w,31,0),a) + | Zea_m(Z8 _,a) => write'mem8(BitsN.bits(7,0) w,a) + | Zea_m(Z16,a) => write'mem16(BitsN.bits(15,0) w,a) + | Zea_m(Z32,a) => write'mem32(BitsN.bits(31,0) w,a) | Zea_m(Z64,a) => write'mem64(w,a); fun read_dest_src_ea sd = @@ -650,7 +650,7 @@ fun Zsize_width size = fun word_size_msb (size,w) = BitsN.bit(w,Nat.-(Zsize_width size,1)); -fun write_PF w = write'PF(ByteParity(BitsN.bits(w,7,0))); +fun write_PF w = write'PF(ByteParity(BitsN.bits(7,0) w)); fun write_SF s_w = write'SF(word_size_msb s_w); @@ -720,19 +720,19 @@ fun SignExtension (w,(size1,size2)) = ( case (size1,size2) of (Z8 _,Z16) => v := - (BitsN.bitFieldInsert - ((!v),BitsN.signExtend 16 (BitsN.bits(w,7,0)),15,0)) + (BitsN.bitFieldInsert(15,0) + ((!v),BitsN.signExtend 16 (BitsN.bits(7,0) w))) | (Z8 _,Z32) => v := - (BitsN.bitFieldInsert - ((!v),BitsN.signExtend 32 (BitsN.bits(w,7,0)),31,0)) - | (Z8 _,Z64) => v := (BitsN.signExtend 64 (BitsN.bits(w,7,0))) + (BitsN.bitFieldInsert(31,0) + ((!v),BitsN.signExtend 32 (BitsN.bits(7,0) w))) + | (Z8 _,Z64) => v := (BitsN.signExtend 64 (BitsN.bits(7,0) w)) | (Z16,Z32) => v := - (BitsN.bitFieldInsert - ((!v),BitsN.signExtend 32 (BitsN.bits(w,15,0)),31,0)) - | (Z16,Z64) => v := (BitsN.signExtend 64 (BitsN.bits(w,15,0))) - | (Z32,Z64) => v := (BitsN.signExtend 64 (BitsN.bits(w,31,0))) + (BitsN.bitFieldInsert(31,0) + ((!v),BitsN.signExtend 32 (BitsN.bits(15,0) w))) + | (Z16,Z64) => v := (BitsN.signExtend 64 (BitsN.bits(15,0) w)) + | (Z32,Z64) => v := (BitsN.signExtend 64 (BitsN.bits(31,0) w)) | _ => raise FAILURE ("SignExtension") ; (!v) ) @@ -740,64 +740,64 @@ fun SignExtension (w,(size1,size2)) = fun maskShift (size,w) = if size = Z64 - then BitsN.toNat(BitsN.bits(w,5,0)) - else BitsN.toNat(BitsN.bits(w,4,0)); + then BitsN.toNat(BitsN.bits(5,0) w) + else BitsN.toNat(BitsN.bits(4,0) w); fun ROL (size,(x,y)) = case size of Z8 _ => BitsN.fromNat (BitsN.toNat - (BitsN.#<<(BitsN.bits(x,7,0),BitsN.toNat(BitsN.bits(y,4,0)))), + (BitsN.#<<(BitsN.bits(7,0) x,BitsN.toNat(BitsN.bits(4,0) y))), 64) | Z16 => BitsN.fromNat (BitsN.toNat - (BitsN.#<<(BitsN.bits(x,15,0),BitsN.toNat(BitsN.bits(y,4,0)))), + (BitsN.#<<(BitsN.bits(15,0) x,BitsN.toNat(BitsN.bits(4,0) y))), 64) | Z32 => BitsN.fromNat (BitsN.toNat - (BitsN.#<<(BitsN.bits(x,31,0),BitsN.toNat(BitsN.bits(y,4,0)))), + (BitsN.#<<(BitsN.bits(31,0) x,BitsN.toNat(BitsN.bits(4,0) y))), 64) - | Z64 => BitsN.#<<(x,BitsN.toNat(BitsN.bits(y,5,0))); + | Z64 => BitsN.#<<(x,BitsN.toNat(BitsN.bits(5,0) y)); fun ROR (size,(x,y)) = case size of Z8 _ => BitsN.fromNat (BitsN.toNat - (BitsN.#>>(BitsN.bits(x,7,0),BitsN.toNat(BitsN.bits(y,4,0)))), + (BitsN.#>>(BitsN.bits(7,0) x,BitsN.toNat(BitsN.bits(4,0) y))), 64) | Z16 => BitsN.fromNat (BitsN.toNat - (BitsN.#>>(BitsN.bits(x,15,0),BitsN.toNat(BitsN.bits(y,4,0)))), + (BitsN.#>>(BitsN.bits(15,0) x,BitsN.toNat(BitsN.bits(4,0) y))), 64) | Z32 => BitsN.fromNat (BitsN.toNat - (BitsN.#>>(BitsN.bits(x,31,0),BitsN.toNat(BitsN.bits(y,4,0)))), + (BitsN.#>>(BitsN.bits(31,0) x,BitsN.toNat(BitsN.bits(4,0) y))), 64) - | Z64 => BitsN.#>>(x,BitsN.toNat(BitsN.bits(y,5,0))); + | Z64 => BitsN.#>>(x,BitsN.toNat(BitsN.bits(5,0) y)); fun SAR (size,(x,y)) = case size of Z8 _ => BitsN.fromNat (BitsN.toNat - (BitsN.>>(BitsN.bits(x,7,0),BitsN.toNat(BitsN.bits(y,4,0)))),64) + (BitsN.>>(BitsN.bits(7,0) x,BitsN.toNat(BitsN.bits(4,0) y))),64) | Z16 => BitsN.fromNat (BitsN.toNat - (BitsN.>>(BitsN.bits(x,15,0),BitsN.toNat(BitsN.bits(y,4,0)))), + (BitsN.>>(BitsN.bits(15,0) x,BitsN.toNat(BitsN.bits(4,0) y))), 64) | Z32 => BitsN.fromNat (BitsN.toNat - (BitsN.>>(BitsN.bits(x,31,0),BitsN.toNat(BitsN.bits(y,4,0)))), + (BitsN.>>(BitsN.bits(31,0) x,BitsN.toNat(BitsN.bits(4,0) y))), 64) - | Z64 => BitsN.>>(x,BitsN.toNat(BitsN.bits(y,5,0))); + | Z64 => BitsN.>>(x,BitsN.toNat(BitsN.bits(5,0) y)); fun write_binop (s,(bop,(x,(y,ea)))) = case bop of @@ -940,7 +940,7 @@ fun x64_push imm_rm = x64_push_aux(EA(ea_Zimm_rm(Z64,imm_rm))); fun x64_push_rip () = x64_push_aux (!RIP); fun x64_drop imm = - ( if not((BitsN.bits(imm,7,0)) = (BitsN.B(0x0,8))) + ( if not((BitsN.bits(7,0) imm) = (BitsN.B(0x0,8))) then raise FAILURE ("x64_drop") else () ; REG := @@ -1308,7 +1308,7 @@ fun prefixGroup b = | BitsN.B(0x65,8) => 2 | BitsN.B(0x66,8) => 3 | BitsN.B(0x67,8) => 4 - | _ => (if (BitsN.bits(b,7,4)) = (BitsN.B(0x4,4)) then 5 else 0); + | _ => (if (BitsN.bits(7,4) b) = (BitsN.B(0x4,4)) then 5 else 0); fun readPrefix (s,(p,strm)) = case strm of @@ -1319,7 +1319,7 @@ fun readPrefix (s,(p,strm)) = if group = 0 then Option.SOME(p,(false,(rec'REX(BitsN.B(0x0,4)),strm))) else if group = 5 - then Option.SOME(p,(true,(rec'REX(BitsN.bits(h,3,0)),strm1))) + then Option.SOME(p,(true,(rec'REX(BitsN.bits(3,0) h),strm1))) else if Set.mem(group,s) then NONE else readPrefix(Set.insert(group,s),(h :: p,strm1)) @@ -1952,26 +1952,26 @@ fun x64_next () = fun e_imm8 imm = if (BitsN.<=(BitsN.B(0xFFFFFFFFFFFFFF80,64),imm)) andalso (BitsN.<=(imm,BitsN.B(0x7F,64))) - then [BitsN.bits(imm,7,0)] + then [BitsN.bits(7,0) imm] else []; fun e_imm16 imm = if (BitsN.<=(BitsN.B(0xFFFFFFFFFFFF8000,64),imm)) andalso (BitsN.<=(imm,BitsN.B(0x7FFF,64))) - then [BitsN.bits(imm,7,0),BitsN.bits(imm,15,8)] + then [BitsN.bits(7,0) imm,BitsN.bits(15,8) imm] else []; fun e_imm32 imm = if (BitsN.<=(BitsN.B(0xFFFFFFFF80000000,64),imm)) andalso (BitsN.<=(imm,BitsN.B(0x7FFFFFFF,64))) - then [BitsN.bits(imm,7,0),BitsN.bits(imm,15,8),BitsN.bits(imm,23,16), - BitsN.bits(imm,31,24)] + then [BitsN.bits(7,0) imm,BitsN.bits(15,8) imm,BitsN.bits(23,16) imm, + BitsN.bits(31,24) imm] else []; fun e_imm64 imm = - [BitsN.bits(imm,7,0),BitsN.bits(imm,15,8),BitsN.bits(imm,23,16), - BitsN.bits(imm,31,24),BitsN.bits(imm,39,32),BitsN.bits(imm,47,40), - BitsN.bits(imm,55,48),BitsN.bits(imm,63,56)]; + [BitsN.bits(7,0) imm,BitsN.bits(15,8) imm,BitsN.bits(23,16) imm, + BitsN.bits(31,24) imm,BitsN.bits(39,32) imm,BitsN.bits(47,40) imm, + BitsN.bits(55,48) imm,BitsN.bits(63,56) imm]; fun e_imm imm = case e_imm8 imm of @@ -1989,8 +1989,8 @@ fun e_imm_8_32 imm = fun e_ModRM (r,rm) = case rm of Zm(NONE,(ZripBase,displacement)) => - (BitsN.concat[BitsN.B(0x0,1),BitsN.bits(r,3,3),BitsN.B(0x0,2)], - (BitsN.concat[BitsN.B(0x0,2),BitsN.bits(r,2,0),BitsN.B(0x5,3)]) + (BitsN.concat[BitsN.B(0x0,1),BitsN.bits(3,3) r,BitsN.B(0x0,2)], + (BitsN.concat[BitsN.B(0x0,2),BitsN.bits(2,0) r,BitsN.B(0x5,3)]) :: (e_imm32 displacement)) | Zr rm => @@ -1998,17 +1998,17 @@ fun e_ModRM (r,rm) = val rm = BitsN.fromNat(Cast.ZregToNat rm,4) in (BitsN.concat - [BitsN.B(0x0,1),BitsN.bits(r,3,3),BitsN.B(0x0,1), - BitsN.bits(rm,3,3)], + [BitsN.B(0x0,1),BitsN.bits(3,3) r,BitsN.B(0x0,1), + BitsN.bits(3,3) rm], [BitsN.concat - [BitsN.B(0x3,2),BitsN.bits(r,2,0),BitsN.bits(rm,2,0)]]) + [BitsN.B(0x3,2),BitsN.bits(2,0) r,BitsN.bits(2,0) rm]]) end | Zm(NONE,(ZnoBase,imm)) => (case e_imm32 imm of [] => (BitsN.B(0x0,4),[]) | l => - (BitsN.concat[BitsN.B(0x0,1),BitsN.bits(r,3,3),BitsN.B(0x0,2)], - [BitsN.concat[BitsN.B(0x0,2),BitsN.bits(r,2,0),BitsN.B(0x4,3)], + (BitsN.concat[BitsN.B(0x0,1),BitsN.bits(3,3) r,BitsN.B(0x0,2)], + [BitsN.concat[BitsN.B(0x0,2),BitsN.bits(2,0) r,BitsN.B(0x4,3)], BitsN.B(0x25,8)] @ l)) @@ -2020,11 +2020,11 @@ fun e_ModRM (r,rm) = [] => (BitsN.B(0x0,4),[]) | l => (BitsN.concat - [BitsN.B(0x0,1),BitsN.bits(r,3,3),BitsN.bits(i,3,3), + [BitsN.B(0x0,1),BitsN.bits(3,3) r,BitsN.bits(3,3) i, BitsN.B(0x0,1)], [BitsN.concat - [BitsN.B(0x0,2),BitsN.bits(r,2,0),BitsN.B(0x4,3)], - BitsN.concat[ss,BitsN.bits(i,2,0),BitsN.B(0x5,3)]] + [BitsN.B(0x0,2),BitsN.bits(2,0) r,BitsN.B(0x4,3)], + BitsN.concat[ss,BitsN.bits(2,0) i,BitsN.B(0x5,3)]] @ l) end @@ -2032,7 +2032,7 @@ fun e_ModRM (r,rm) = let val b = BitsN.fromNat(Cast.ZregToNat base,4) val i = BitsN.fromNat(Cast.ZregToNat index,4) - val b20 = BitsN.bits(b,2,0) + val b20 = BitsN.bits(2,0) b val (s,l) = if (imm = (BitsN.B(0x0,64))) andalso (not(b20 = (BitsN.B(0x5,3)))) @@ -2041,14 +2041,14 @@ fun e_ModRM (r,rm) = in if Set.mem(s,[0,1,4]) then (BitsN.concat - [BitsN.B(0x0,1),BitsN.bits(r,3,3),BitsN.bits(i,3,3), - BitsN.bits(b,3,3)], + [BitsN.B(0x0,1),BitsN.bits(3,3) r,BitsN.bits(3,3) i, + BitsN.bits(3,3) b], [BitsN.concat [case s of 0 => BitsN.B(0x0,2) | 1 => BitsN.B(0x1,2) - | _ => BitsN.B(0x2,2),BitsN.bits(r,2,0), - BitsN.B(0x4,3)],BitsN.concat[ss,BitsN.bits(i,2,0),b20]] + | _ => BitsN.B(0x2,2),BitsN.bits(2,0) r, + BitsN.B(0x4,3)],BitsN.concat[ss,BitsN.bits(2,0) i,b20]] @ l) else (BitsN.B(0x0,4),[]) @@ -2056,7 +2056,7 @@ fun e_ModRM (r,rm) = | Zm(NONE,(ZregBase base,imm)) => let val base = BitsN.fromNat(Cast.ZregToNat base,4) - val base20 = BitsN.bits(base,2,0) + val base20 = BitsN.bits(2,0) base val (s,l) = if (imm = (BitsN.B(0x0,64))) andalso (not(base20 = (BitsN.B(0x5,3)))) @@ -2065,13 +2065,13 @@ fun e_ModRM (r,rm) = in if Set.mem(s,[0,1,4]) then (BitsN.concat - [BitsN.B(0x0,1),BitsN.bits(r,3,3),BitsN.B(0x0,1), - BitsN.bits(base,3,3)], + [BitsN.B(0x0,1),BitsN.bits(3,3) r,BitsN.B(0x0,1), + BitsN.bits(3,3) base], ((BitsN.concat [case s of 0 => BitsN.B(0x0,2) | 1 => BitsN.B(0x1,2) - | _ => BitsN.B(0x2,2),BitsN.bits(r,2,0),base20]) + | _ => BitsN.B(0x2,2),BitsN.bits(2,0) r,base20]) :: (if base20 = (BitsN.B(0x4,3)) then [BitsN.@@(BitsN.B(0x4,5),base20)] @@ -2226,7 +2226,7 @@ fun encode i = (sz, (imm, BitsN.concat - [BitsN.B(0x0,2),BitsN.bits(opc,2,0), + [BitsN.B(0x0,2),BitsN.bits(2,0) opc, BitsN.B(0x4,3)])) else e_rm_imm(sz,(rm,(imm,(opc,BitsN.B(0x80,8))))) end) @@ -2253,7 +2253,7 @@ fun encode i = (BitsN.fromNat(Cast.ZregToNat r,4), ([], BitsN.concat - [BitsN.B(0x0,2),BitsN.bits(opc,2,0), + [BitsN.B(0x0,2),BitsN.bits(2,0) opc, BitsN.B(0x0,3)])))) end) | Zbinop(bop,(sz,Zr_rm(r,rm))) => @@ -2268,7 +2268,7 @@ fun encode i = (BitsN.fromNat(Cast.ZregToNat r,4), ([], BitsN.concat - [BitsN.B(0x0,2),BitsN.bits(opc,2,0),BitsN.B(0x2,3)])))) + [BitsN.B(0x0,2),BitsN.bits(2,0) opc,BitsN.B(0x2,3)])))) end | Zcall(Zrm rm) => e_opc(BitsN.B(0xFF,8),(BitsN.B(0x2,3),rm)) | Zcall(Zimm imm) => @@ -2345,7 +2345,7 @@ fun encode i = [prefixes, [BitsN.concat [BitsN.B(0xB,4),BitsN.fromNat(BitsN.toNat v,1), - BitsN.bits(r,2,0)]],l] + BitsN.bits(2,0) r]],l] | NONE => [] end | Zmov(Z_ALWAYS,(sz,Zrm_i(rm,imm))) => @@ -2401,7 +2401,7 @@ fun encode i = in (if BitsN.bit(r,3) then [BitsN.B(0x49,8)] else []) @ - [BitsN.@@(BitsN.B(0xB,5),BitsN.bits(r,2,0))] + [BitsN.@@(BitsN.B(0xB,5),BitsN.bits(2,0) r)] end | Zpop rm => e_opc(BitsN.B(0x8F,8),(BitsN.B(0x0,3),rm)) | Zpush(Zrm(Zr reg)) => @@ -2410,7 +2410,7 @@ fun encode i = in (if BitsN.bit(r,3) then [BitsN.B(0x49,8)] else []) @ - [BitsN.@@(BitsN.B(0xA,5),BitsN.bits(r,2,0))] + [BitsN.@@(BitsN.B(0xA,5),BitsN.bits(2,0) r)] end | Zpush(Zrm rm) => e_opc(BitsN.B(0xFF,8),(BitsN.B(0x6,3),rm)) | Zpush(Zimm imm) => @@ -2443,7 +2443,7 @@ fun encode i = if v = (BitsN.B(0x1,8)) then prefixes @ - [BitsN.@@(BitsN.B(0x12,5),BitsN.bits(r,2,0))] + [BitsN.@@(BitsN.B(0x12,5),BitsN.bits(2,0) r)] else [] end else e_rm_reg @@ -2889,7 +2889,7 @@ fun p_dest_src (nfull_imm,(a,b)) = (case p_imm_of_size(sz,b) of Option.SOME imm => (if ((sz = Z64) andalso nfull_imm) andalso - (not((BitsN.signExtend 64 (BitsN.bits(imm,31,0))) = imm)) + (not((BitsN.signExtend 64 (BitsN.bits(31,0) imm)) = imm)) then ("syntax error: bad immediate",NONE) else ("",Option.SOME(sz,Zrm_i(Zr r,imm)))) | NONE => @@ -2907,7 +2907,7 @@ fun p_dest_src (nfull_imm,(a,b)) = (case p_imm_of_size(sz,b) of Option.SOME imm => (if (sz = Z64) andalso - (not((BitsN.signExtend 64 (BitsN.bits(imm,31,0))) = + (not((BitsN.signExtend 64 (BitsN.bits(31,0) imm)) = imm)) then ("syntax error: bad immediate",NONE) else ("",Option.SOME(sz,Zrm_i(Zm m,imm)))) From 8c47c9dfe8ce2ebd4819cd915f6675b078153d48 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 16 Jul 2015 13:23:52 +0800 Subject: [PATCH 373/718] Detect and abort on vacuous inductive relation clauses A vacuous clause is something like !x y. R x y where R is the relation being defined. Such a thing makes the relation the universal relation. If you really want such a thing, you can always write !x y. T ==> R x y Closes #269 --- src/IndDef/InductiveDefinition.sml | 6 +++++- src/IndDef/selftest.sml | 10 ++++++++++ 2 files changed, 15 insertions(+), 1 deletion(-) diff --git a/src/IndDef/InductiveDefinition.sml b/src/IndDef/InductiveDefinition.sml index 62d6ddde5a..f1dfe9e58d 100644 --- a/src/IndDef/InductiveDefinition.sml +++ b/src/IndDef/InductiveDefinition.sml @@ -212,7 +212,11 @@ fun canonicalize_clause clause carg = in IMP_ANTISYM_RULE (DISCH_ALL th5) (DISCH_ALL th8) end else - let val atm = list_mk_conj(map mk_eq_of_bind (yes@no)) + let val _ = not (null no) orelse + raise mk_HOL_ERR "InductiveDefinition" + "canonicalize_clause" + "Vacuous clause trivialises whole definition" + val atm = list_mk_conj(map mk_eq_of_bind (yes@no)) val ths = CONJUNCTS (ASSUME atm) val thl = map(fn t => first(fn th => lhs(concl th) = t) ths) carg val th0 = SPECL avs (ASSUME clause) diff --git a/src/IndDef/selftest.sml b/src/IndDef/selftest.sml index 87ebf05b6a..d997195036 100644 --- a/src/IndDef/selftest.sml +++ b/src/IndDef/selftest.sml @@ -95,5 +95,15 @@ val _ = if (xHol_reln "tr" ` ` ; false) handle HOL_ERR _ => true then print "OK\n" else die "FAILED" +val _ = tprint "Vacuous clause failure" +val _ = if (with_flag (Feedback.emit_ERR, false) + Hol_reln `(!x. rel x Z) /\ (!x y. rel x y)` ; false) + handle HOL_ERR {message,...} => + String.isSuffix + "Vacuous clause trivialises whole definition" + message + then print "OK\n" + else die "FAILED" + val _ = OS.Process.exit OS.Process.success From 087daedffe50690f51b777a1e43a409c0b050385 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 16 Jul 2015 15:12:10 +0800 Subject: [PATCH 374/718] Fix holdep test case for functor keyword. This dodges the Moscow ML compilation error caused by its attempt to compile functor.sml (now deleted) in its default mode. --- tools/Holmake/tests/brokenstrings/functor.sml | 5 ----- tools/Holmake/tests/holdep/Holmakefile | 2 +- tools/Holmake/tests/holdep/expected_output | 1 + tools/Holmake/tests/holdep/input | 3 +++ tools/sequences/kernel | 1 + 5 files changed, 6 insertions(+), 6 deletions(-) delete mode 100644 tools/Holmake/tests/brokenstrings/functor.sml diff --git a/tools/Holmake/tests/brokenstrings/functor.sml b/tools/Holmake/tests/brokenstrings/functor.sml deleted file mode 100644 index 7ae70f65df..0000000000 --- a/tools/Holmake/tests/brokenstrings/functor.sml +++ /dev/null @@ -1,5 +0,0 @@ -open HolKernel -functor x(val y : int) = -struct - val z = y + 1 -end diff --git a/tools/Holmake/tests/holdep/Holmakefile b/tools/Holmake/tests/holdep/Holmakefile index 7fe98a3557..a287c932fb 100644 --- a/tools/Holmake/tests/holdep/Holmakefile +++ b/tools/Holmake/tests/holdep/Holmakefile @@ -1,7 +1,7 @@ INCLUDES = ../../../cmp .PHONY: test -test: +test: input expected_output $(protect $(HOLDIR)/bin/holdeptool.exe) input > output $(protect $(HOLDIR)/tools/cmp/cmp.exe) output expected_output diff --git a/tools/Holmake/tests/holdep/expected_output b/tools/Holmake/tests/holdep/expected_output index 94b2274b34..8c9c009fd5 100644 --- a/tools/Holmake/tests/holdep/expected_output +++ b/tools/Holmake/tests/holdep/expected_output @@ -8,6 +8,7 @@ baz data1 data2 foo +functortest included1 included2 included3 diff --git a/tools/Holmake/tests/holdep/input b/tools/Holmake/tests/holdep/input index 525cec70e7..ad69f9d7ba 100644 --- a/tools/Holmake/tests/holdep/input +++ b/tools/Holmake/tests/holdep/input @@ -34,3 +34,6 @@ include included4 datatype datafoo include included5 where type t = int + +open functortest +functor funct(val x : int) = diff --git a/tools/sequences/kernel b/tools/sequences/kernel index 59bbe01f5b..4f1087cd4c 100644 --- a/tools/sequences/kernel +++ b/tools/sequences/kernel @@ -14,6 +14,7 @@ src/1 !tools/Holmake/tests/depchain2/dir1 !tools/Holmake/tests/altquote1 !tools/Holmake/tests/brokenstrings +!tools/Holmake/tests/holdep !src/1/theory_tests src/proofman [poly]bin/hol.bare From 8f856aa2d1aa5844381369eebae4344402460251 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 16 Jul 2015 19:44:13 +0800 Subject: [PATCH 375/718] Revert "Tidy up emacs code for filtering HOL output" This reverts commit a593c230f3327e1c1eee92a9e63ef6166ec936b4. Also add a comment explaining why the solution in a593c23 (with with-temp-buffer) can't work. --- tools/hol-mode.src | 90 ++++++++++++++++++++++++++++------------------ 1 file changed, 55 insertions(+), 35 deletions(-) diff --git a/tools/hol-mode.src b/tools/hol-mode.src index 0681239a22..ed01981c18 100644 --- a/tools/hol-mode.src +++ b/tools/hol-mode.src @@ -1436,46 +1436,66 @@ second is to show the new term. (holpp-quiet-reset) (send-raw-string-to-hol "print \"\\n\\n*** hol-mode reset ***\\n\";" nil nil)) +; this filter function is complicated by the fact that comint chunks +; output (in 1024 character chunks in my tests) and so doesn't +; necessarily give complete (in the sense of containing matching +; comment-blocks) strings to the filter. This means that a solution +; with with-temp-buffer won't work. Instead, there is a persistent +; working space buffer, and if the code finds a non-matching comment +; start (a "(*(*(*" substring), it just leaves that in the working +; space so that the next piece of output can be appended and processed +; properly. (defun holpp-output-filter (s) "Converts a munged emacs_terminal string into a pretty one with text properties." (interactive "sinput: ") - (with-temp-buffer - (insert s) - (let (end) - (goto-char (point-min)) - (while (and (not end) (search-forward "(*(*(*" nil t)) - (let ((uptoann (- (point) 6)) - (start (point))) - (if (not (holpp-find-comment-end 1)) - (progn - (goto-char uptoann) - (setq end t)) - (delete-region uptoann start) - (let* - ((start (- start 6)) - (code (buffer-substring start (+ start 2))) - (argument - (save-excursion - (goto-char (+ start 2)) - (if (equal (following-char) 0) - (progn - (goto-char (+ (point) 1)) - (skip-chars-forward "^\^@") - (prog1 - (if (equal (+ start 3) (point)) nil - (buffer-substring (+ start 3) - (point))) - (delete-region (+ start 2) (1+ (point))))) - nil)))) - (holpp-execute-code code argument (+ start 2) (- (point) 6)) - (delete-region start (+ start 2)) - (delete-region (- (point) 6) (point)) - (goto-char start))))) - (if (not end) + (let* ((tmpbuf (or temp-hol-output-buf + (generate-new-buffer " *HOL output filter*)"))) + end) + (setq temp-hol-output-buf tmpbuf) + (save-excursion + (set-buffer tmpbuf) + (unwind-protect (progn (goto-char (point-max)) - (skip-chars-backward "(*")))) - (buffer-string))) + (insert s) + (goto-char (point-min)) + (while (and (not end) (search-forward "(*(*(*" nil t)) + (let ((uptoann (- (point) 6)) + (start (point))) + (if (not (holpp-find-comment-end 1)) + (progn + (goto-char uptoann) + (setq end t)) + (delete-region uptoann start) + (let* + ((start (- start 6)) + (code (buffer-substring start (+ start 2))) + (argument + (save-excursion + (goto-char (+ start 2)) + (if (equal (following-char) 0) + (progn + (goto-char (+ (point) 1)) + (skip-chars-forward "^\^@") + (prog1 + (if (equal (+ start 3) (point)) nil + (buffer-substring (+ start 3) + (point))) + (delete-region (+ start 2) (1+ (point))))) + nil)))) + (holpp-execute-code code argument + (+ start 2) + (- (point) 6)) + (delete-region start (+ start 2)) + (delete-region (- (point) 6) (point)) + (goto-char start))))) + (if (not end) + (progn + (goto-char (point-max)) + (skip-chars-backward "(*"))) + (prog1 + (buffer-substring (point-min) (point)) + (delete-region (point-min) (point)))))))) (defun holmakepp-mark-error (start end) (add-text-properties start end '(face holmake-error))) From f7299be7a52f99c8cbfc66611f6acdcf4331caf8 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 27 Jul 2015 15:45:52 +1000 Subject: [PATCH 376/718] Let load work if current directory is unwritable --- doc/next-release.md | 4 ++++ tools-poly/poly/poly-init2.ML | 17 +++++++++++------ 2 files changed, 15 insertions(+), 6 deletions(-) diff --git a/doc/next-release.md b/doc/next-release.md index 1b5384f875..2074a5ee68 100644 --- a/doc/next-release.md +++ b/doc/next-release.md @@ -51,6 +51,10 @@ Bugs fixed: This means that Unicode cannot be used in the kernel’s name for a constant, but certainly doesn’t prevent Unicode being used in overloaded notation. Functions such as `overload_on`, `add_rule` and `set_mapped_fixity` can still be used to create pretty notation with as many Unicode characters included as desired. +- Loading theories under Poly/ML would fail unnecessarily if the current directory was unwritable. + Working in such directories will likely cause problems when and if an `export_theory` call is made, so there is a warning emitted in this situation, but the `load` now succeeds. + Thanks for Narges Khakpour for the bug report. + New theories: ------------- diff --git a/tools-poly/poly/poly-init2.ML b/tools-poly/poly/poly-init2.ML index 7c0a4bacf0..16ac6bbc87 100644 --- a/tools-poly/poly/poly-init2.ML +++ b/tools-poly/poly/poly-init2.ML @@ -10,6 +10,9 @@ local TextIO.flushOut TextIO.stdErr; raise Fail s) + fun warn s = (TextIO.output(TextIO.stdErr, "WARNING: " ^ s ^ "\n"); + TextIO.flushOut TextIO.stdErr) + val redirected_files = ["mlibOmegaint.sml"]; (* used to stand for "has double quote", but the same analysis is necessary @@ -40,14 +43,16 @@ structure FS = OS.FileSys fun quse s = let fun mkHOLMK () = if FS.access (".HOLMK", [FS.A_READ, FS.A_EXEC]) andalso FS.isDir ".HOLMK" - then () + then true else - FS.mkDir ".HOLMK" + (FS.mkDir ".HOLMK"; true) handle OS.SysErr (msg, _) => - die ("While using " ^ s ^ - ", couldn't make .HOLMK directory in " ^ - FS.getDir() ^ ": " ^ msg) - fun holtemp s = (mkHOLMK(); OS.Path.concat(".HOLMK", OS.Path.file s)) + (warn ("Couldn't make .HOLMK directory in " ^ + FS.getDir() ^ ": " ^ msg); + false) + fun holtemp s = + if mkHOLMK() then OS.Path.concat(".HOLMK", OS.Path.file s) + else OS.FileSys.tmpName() val _ = if FS.access (s, [FS.A_READ]) then () else die ("Use: non-existent file "^s) From 757671a23882926b83252d041724b39f7bc10f22 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 27 Jul 2015 15:53:28 +1000 Subject: [PATCH 377/718] Grammar correction in release notes --- doc/next-release.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/next-release.md b/doc/next-release.md index 2074a5ee68..274c6856e4 100644 --- a/doc/next-release.md +++ b/doc/next-release.md @@ -53,7 +53,7 @@ Bugs fixed: - Loading theories under Poly/ML would fail unnecessarily if the current directory was unwritable. Working in such directories will likely cause problems when and if an `export_theory` call is made, so there is a warning emitted in this situation, but the `load` now succeeds. - Thanks for Narges Khakpour for the bug report. + Thanks to Narges Khakpour for the bug report. New theories: ------------- From 8472a61466d810bba55921612c05ee122903dffb Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 27 Jul 2015 15:54:42 +1000 Subject: [PATCH 378/718] Correct URL in release notes --- doc/next-release.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/next-release.md b/doc/next-release.md index 274c6856e4..0ad0579e6c 100644 --- a/doc/next-release.md +++ b/doc/next-release.md @@ -42,7 +42,7 @@ Bugs fixed: won’t create a recursive type (assuming this is not called in theory `num`). (`Hol_datatype` had the same problem.) - [Second](http://github.com/HOL-Theorem-Prover/HOL/issues/257), `Datatype` will handle antiquotations in its input properly (`Hol_datatype` already did). + [Second](http://github.com/HOL-Theorem-Prover/HOL/issues/258), `Datatype` will handle antiquotations in its input properly (`Hol_datatype` already did). [Third](http://github.com/HOL-Theorem-Prover/HOL/issues/260), `Datatype` (and `Hol_datatype`) allows the definition of identical record types in different theories. From e8c3f035633d16e1e71bb493b523bb90d8a115db Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 27 Jul 2015 16:30:02 +1000 Subject: [PATCH 379/718] Improve docs for HOL heaps in Description --- Manual/Description/misc.tex | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/Manual/Description/misc.tex b/Manual/Description/misc.tex index 613cb3c364..2bce087d51 100644 --- a/Manual/Description/misc.tex +++ b/Manual/Description/misc.tex @@ -616,6 +616,9 @@ \subsection{Using a make-file with \holmake} expands to \texttt{/bin/cp}; under Windows, it expands to \texttt{copy}.) \item[\texttt{HOLDIR}] The root of the HOL installation. +\item[\texttt{HOLHEAP}] +Under Poly/ML, this variable expands to the name of the heap that should be used to build this directory (to be used instead of the heap that underlies the \texttt{hol} executable). +See Section~\ref{sec:polyml-heaps} below for more on using custom heaps with Poly/ML. \item[\texttt{HOLMOSMLC}] This variable is replaced by an invocation of the Moscow ML compiler along with the \texttt{-q} flag (necessary for handling quotations), and the usual \texttt{-I} include @@ -818,9 +821,8 @@ \subsection{Using \HOL{} Heaps} Finally, note that when using the \texttt{HOLHEAP} variable, heaps are required to be built before everything else in a directory, and that such heaps embody theories or \ML{} sources that are \emph{ancestral} to the directory in which the heap occurs. Thus, if one wanted to package up a heap embodying the standard theories for the real numbers, and to do it in \texttt{src/real} (which feels natural), this heap could be built using the method described here, but could only be referred to as a \texttt{HOLHEAP} in the directories that used it, \emph{not} in \texttt{src/real}'s \texttt{Holmakefile}. - -More realistically, such a ``real-embodying'' heap could be built in \texttt{src/real}, and \emph{subsequent} developments in other directories could use it by specifying\[ - \texttt{\$(HOLDIR)/src/real/myheap} +Subsequently, developments in other directories could use this heap by specifying\[ + \texttt{\$(HOLDIR)/src/real/realheap} \] as the value for their \texttt{HOLHEAP} variables. From 91edca0c0106112aea9d929051de838531a5c63d Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 27 Jul 2015 16:30:16 +1000 Subject: [PATCH 380/718] Improve pg breaks with blank line before samepage env --- Manual/Description/misc.tex | 1 + 1 file changed, 1 insertion(+) diff --git a/Manual/Description/misc.tex b/Manual/Description/misc.tex index 2bce087d51..6963fef2d2 100644 --- a/Manual/Description/misc.tex +++ b/Manual/Description/misc.tex @@ -804,6 +804,7 @@ \subsection{Using \HOL{} Heaps} If the standard \texttt{hol} executable is invoked in a directory where there is a \texttt{Holmakefile} specifying a heap, the default heap will not be used and the given heap will be used instead. The fact that this is happening is mentioned as the interactive session begins. For example: + \begin{samepage} \begin{alltt} --------------------------------------------------------------------- From 9673449930e83eedc22f6dee0405e809079d3a84 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 29 Jul 2015 12:15:51 +1000 Subject: [PATCH 381/718] Grammar-parse warns on unreachable & undefined NTs --- examples/parsing/grammarLib.sml | 64 +++++++++++++++++++++++++++++++++ 1 file changed, 64 insertions(+) diff --git a/examples/parsing/grammarLib.sml b/examples/parsing/grammarLib.sml index c471b71de7..bcde8c5c51 100644 --- a/examples/parsing/grammarLib.sml +++ b/examples/parsing/grammarLib.sml @@ -30,6 +30,63 @@ datatype sym = NT of string | TOK of stringt datatype clause = Syms of sym list | TmAQ of term type t = (string * clause list) list +datatype NTproblem = Unreachable of string | Undefined of string +val emptyNTset = HOLset.empty String.compare +fun clausesNTs (cs, acc) = let + fun symcase (NT s, acc) = HOLset.add(acc, s) + | symcase (TOK _, acc) = acc + fun clausecase (Syms syms, acc) = List.foldl symcase acc syms + | clausecase (TmAQ _, acc) = acc +in + List.foldl clausecase acc cs +end +fun usedNTs (g:t) = + List.foldl (fn ((_,cs), acc) => clausesNTs(cs,acc)) emptyNTset g +fun reachableNTs start (clauses : t) = + let + fun foldthis (c as (nt, cs), m) = + Binarymap.insert(m,nt,clausesNTs(cs, emptyNTset)) + val ntmap = List.foldl foldthis (Binarymap.mkDict String.compare) clauses + fun dfs visited tovisit = + case tovisit of + [] => visited + | nt::rest => let + val visited' = HOLset.add(visited, nt) + val neighbours = case Binarymap.peek(ntmap, nt) of + NONE => emptyNTset + | SOME s => s + fun foldthis (nt, acc) = + if HOLset.member(visited', nt) then acc + else nt::acc + val tovisit' = HOLset.foldl foldthis rest neighbours + in + dfs visited' tovisit' + end + in + dfs emptyNTset [start] + end +fun definedNTs (clauses : t) = + let + fun clausescase ((nt, _), acc) = HOLset.add(acc, nt) + in + List.foldl clausescase emptyNTset clauses + end + +fun NTproblems start g = + let + val used = usedNTs g + val reachable = reachableNTs start g + val defined = definedNTs g + val defined_less_reachable = HOLset.difference(defined, reachable) + val used_less_defined = HOLset.difference(used, defined) + in + HOLset.foldl (fn (s, acc) => Unreachable s :: acc) + (HOLset.foldl (fn (s, acc) => Undefined s :: acc) + [] + used_less_defined) + defined_less_reachable + end + fun newline ((col, line), msg) = ((0, line + 1), msg) fun add1col ((col, line), msg) = ((col + 1, line), msg) fun advance c p = if c = #"\n" then newline p else add1col p @@ -320,8 +377,15 @@ in end end + +val warn = HOL_WARNING "grammarLib" "grammar" +fun NTproblem_warn (Unreachable s) = warn ("Unused non-terminal: " ^ s) + | NTproblem_warn (Undefined s) = warn ("Undefined non-terminal: " ^ s) +fun reportNTproblems top g = List.app NTproblem_warn (NTproblems top g) + fun mk_grammar_def0 (gi:ginfo) (g:t) = let val {tokmap,nt_tyname,mkntname,tokty,start,gname,...} = gi + val _ = reportNTproblems start g val nt_names = allnts mkntname g val constructors = ParseDatatype.Constructors From ad021981c903133212f47646a76077cda7a2278b Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 31 Jul 2015 14:17:11 +1000 Subject: [PATCH 382/718] Remove use of finite maps in precparser. The lookup function for the precedence table might be implemented with FLOOKUP on some finite map, but it's simpler at this level to simply ask for a function. --- examples/parsing/precparserScript.sml | 18 ++++++++---------- 1 file changed, 8 insertions(+), 10 deletions(-) diff --git a/examples/parsing/precparserScript.sml b/examples/parsing/precparserScript.sml index f392d6cf6e..a27e8cdd88 100644 --- a/examples/parsing/precparserScript.sml +++ b/examples/parsing/precparserScript.sml @@ -1,7 +1,6 @@ open HolKernel Parse boolLib bossLib; open optionTheory listTheory -open finite_mapTheory open lcsymtacs @@ -40,7 +39,6 @@ val list_case_eq = prove_case_eq_thm{ }; - val _ = Datatype`tokrel = Reduce | Shift` val tokrel_case_eq = prove_case_eq_thm { @@ -49,7 +47,7 @@ val tokrel_case_eq = prove_case_eq_thm { }; val _ = Datatype` - pMachine = <| rules : 'tok # 'tok |-> tokrel ; (* stk tok # strm tok *) + pMachine = <| rules : 'tok # 'tok -> tokrel option ; (* stk tok , strm tok *) reduce : 'trm -> 'tok -> 'trm -> 'trm ; lift : 'tok -> 'trm ; isOp : 'tok -> bool ; @@ -70,10 +68,8 @@ val precparse1_def = Define` if pM.isOp tok then case stk of INR tm2 :: INL opn :: INR tm1 :: stk_rest => - (case FLOOKUP pM.rules (opn, tok) of - SOME Shift => - SOME(INL tok :: INR tm2 :: INL opn :: INR tm1 :: stk_rest, - strm_rest) + (case pM.rules (opn, tok) of + SOME Shift => SOME(INL tok :: stk, strm_rest) | SOME Reduce => SOME(INR (pM.reduce tm1 opn tm2) :: stk_rest, tok :: strm_rest) @@ -156,10 +152,10 @@ val precparse_def = tDefine "precparse" ` metis_tac[precparse1_reduces]); (* test case -local open stringTheory in end +local open stringTheory finite_mapTheory in end val _ = Datatype`ast = Plus ast ast | Times ast ast | App ast ast | C char` -val fm = ``FEMPTY |+ ((#"+",#"*"), Shift) |+ ((#"*",#"+"), Reduce) - |+ ((#"+",#"+"), Reduce) |+ ((#"*",#"*"), Reduce)`` +val fm = ``FLOOKUP (FEMPTY |+ ((#"+",#"*"), Shift) |+ ((#"*",#"+"), Reduce) + |+ ((#"+",#"+"), Reduce) |+ ((#"*",#"*"), Reduce))`` val isOp = ``λc. c = #"*" ∨ c = #"+"`` val reduce = ``λtm1 c tm2. if c = #"*" then Times tm1 tm2 else Plus tm1 tm2`` @@ -173,6 +169,8 @@ val m = ``<| rules := ^fm ; EVAL ``precparse ^m ([],"3*fx*7+9")``; EVAL ``precparse ^m ([],"3+fx*7+9")``; +EVAL ``precparse ^m ([],"fxy")``; +EVAL ``precparse ^m ([],"x*2")``; EVAL ``precparse ^m ([],"3++7")`` (* fails *); *) From 0a1ee292c557d95f21067e53dd719c280165e0a8 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Sun, 2 Aug 2015 10:37:44 +0200 Subject: [PATCH 383/718] Slight generalisation in precedence parser example In particular, allow for machine to have partial operations for doing application (creating f(x) terms), and for "reduction", which is when a binary operator combines with two arguments. --- examples/parsing/precparserScript.sml | 24 +++++++++++++----------- 1 file changed, 13 insertions(+), 11 deletions(-) diff --git a/examples/parsing/precparserScript.sml b/examples/parsing/precparserScript.sml index a27e8cdd88..a9df866d9f 100644 --- a/examples/parsing/precparserScript.sml +++ b/examples/parsing/precparserScript.sml @@ -48,10 +48,10 @@ val tokrel_case_eq = prove_case_eq_thm { val _ = Datatype` pMachine = <| rules : 'tok # 'tok -> tokrel option ; (* stk tok , strm tok *) - reduce : 'trm -> 'tok -> 'trm -> 'trm ; + reduce : 'trm -> 'tok -> 'trm -> 'trm option ; lift : 'tok -> 'trm ; isOp : 'tok -> bool ; - mkApp : 'trm -> 'trm -> 'trm |> + mkApp : 'trm -> 'trm -> 'trm option |> `; @@ -60,10 +60,10 @@ val precparse1_def = Define` precparse1 pM (stk, strm) = case strm of [] => - (case stk of - INR tm2 :: INL opn :: INR tm1 :: rest => - SOME(INR (pM.reduce tm1 opn tm2) :: rest, []) - | _ => NONE) + (case stk of + INR tm2 :: INL opn :: INR tm1 :: rest => + OPTION_MAP (λr. (INR r :: rest, [])) (pM.reduce tm1 opn tm2) + | _ => NONE) | tok :: strm_rest => if pM.isOp tok then case stk of @@ -71,8 +71,8 @@ val precparse1_def = Define` (case pM.rules (opn, tok) of SOME Shift => SOME(INL tok :: stk, strm_rest) | SOME Reduce => - SOME(INR (pM.reduce tm1 opn tm2) :: stk_rest, - tok :: strm_rest) + OPTION_MAP (λr. (INR r :: stk_rest, tok :: strm_rest)) + (pM.reduce tm1 opn tm2) | NONE => NONE) | [INR tm] => SOME([INL tok; INR tm], strm_rest) | _ => NONE @@ -80,7 +80,8 @@ val precparse1_def = Define` case stk of [] => SOME([INR (pM.lift tok)], strm_rest) | INR ftm :: stk_rest => - SOME(INR (pM.mkApp ftm (pM.lift tok)) :: stk_rest, strm_rest) + OPTION_MAP (λr. (INR r :: stk_rest, strm_rest)) + (pM.mkApp ftm (pM.lift tok)) | INL _ :: _ => SOME(INR (pM.lift tok) :: stk, strm_rest) `; @@ -158,14 +159,15 @@ val fm = ``FLOOKUP (FEMPTY |+ ((#"+",#"*"), Shift) |+ ((#"*",#"+"), Reduce) |+ ((#"+",#"+"), Reduce) |+ ((#"*",#"*"), Reduce))`` val isOp = ``λc. c = #"*" ∨ c = #"+"`` -val reduce = ``λtm1 c tm2. if c = #"*" then Times tm1 tm2 else Plus tm1 tm2`` +val reduce = ``λtm1 c tm2. if c = #"*" then SOME (Times tm1 tm2) + else SOME (Plus tm1 tm2)`` val lift = ``C`` val m = ``<| rules := ^fm ; reduce := ^reduce ; lift := C; isOp := ^isOp; - mkApp := App |>`` + mkApp := λt1 t2. SOME (App t1 t2) |>`` EVAL ``precparse ^m ([],"3*fx*7+9")``; EVAL ``precparse ^m ([],"3+fx*7+9")``; From 157d6a1a29cecfd09796cbdf1ac405457e2dc145 Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Mon, 3 Aug 2015 13:48:52 +0100 Subject: [PATCH 384/718] Minor update for BitsN library. --- examples/l3-machine-code/lib/BitsN.sml | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/examples/l3-machine-code/lib/BitsN.sml b/examples/l3-machine-code/lib/BitsN.sml index e54a18d851..659dd439b1 100644 --- a/examples/l3-machine-code/lib/BitsN.sml +++ b/examples/l3-machine-code/lib/BitsN.sml @@ -15,7 +15,7 @@ struct fun dim s = IntInf.<< (1, Word.fromInt s) fun pdim s = dim s - 1 - fun modDim s n = IntInf.andb (n, pdim s) + fun BV (n, s) = B (IntInf.andb (n, pdim s), s) fun UINT_MAX s = B (pdim s, s) fun INT_MIN s = B (dim (s - 1), s) @@ -23,7 +23,7 @@ struct fun zero s = B (0, s) fun one s = B (1, s) - fun fromInt (n, s) = B (modDim s n, s) + val fromInt = BV fun fromNat (n, s) = fromInt (Nat.toInt n, s) fun toNat (B (i, _)) = Nat.fromInt i val toUInt = Nat.toInt o toNat @@ -75,7 +75,7 @@ struct fun lsb (B (a, _)) = Int.rem (a, 2) = 1 fun msb a = bit (a, Nat.- (size a, Nat.one)) - fun neg (B (a, s)) = B (modDim s (Int.- (dim s, a)), s) + fun neg (B (a, s)) = BV (Int.- (dim s, a), s) fun toInt a = if msb a then Int.~ (toUInt (neg a)) else toUInt a @@ -212,7 +212,7 @@ struct fun smax (w1, w2 as B (_, s)) = fromInt (Int.max (toInt w1, toInt w2), s) fun op << (B (v, s), n) = - B (modDim s (IntInf.<< (v, Word.fromInt (Int.min (n, s)))), s) + BV (IntInf.<< (v, Word.fromInt (Int.min (n, s))), s) fun op >>+ (B (v, s), n) = B (IntInf.~>> (v, Word.fromInt n), s) @@ -237,12 +237,12 @@ struct fun op #>>^ (w, v) = w #>> toNat v fun op #<<^ (w, v) = w #<< toNat v - fun op * (B (v1, _), B (v2, s)) = B (modDim s (Int.* (v1, v2)), s) - fun op + (B (v1, _), B (v2, s)) = B (modDim s (Int.+ (v1, v2)), s) + fun op * (B (v1, _), B (v2, s)) = BV (Int.* (v1, v2), s) + fun op + (B (v1, _), B (v2, s)) = BV (Int.+ (v1, v2), s) - fun op ~ (B (a, s)) = B (modDim s (IntInf.notb a), s) + fun op ~ (B (a, s)) = BV (IntInf.notb a, s) - fun abs a = if a < B (0, size a) then neg a else a + fun abs a = if msb a then neg a else a fun op - (a, b) = a + neg b From 5fdfa19d9f90aafb8b2322e11c3b919e872bf43b Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Mon, 3 Aug 2015 13:50:12 +0100 Subject: [PATCH 385/718] Fix for STM instructions. Was failing when the PC was in the register list. --- examples/l3-machine-code/arm/step/arm_stepLib.sml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/l3-machine-code/arm/step/arm_stepLib.sml b/examples/l3-machine-code/arm/step/arm_stepLib.sml index bbfc13045f..6a7b5c4392 100644 --- a/examples/l3-machine-code/arm/step/arm_stepLib.sml +++ b/examples/l3-machine-code/arm/step/arm_stepLib.sml @@ -1247,7 +1247,7 @@ in then ground_mul_rule o rule o Conv.CONV_RULE (Conv.DEPTH_CONV FOLDL_LDM1_CONV) else if String.isPrefix "STM" s' - then stm_rule2 o stm_rule1 o rule o + then ground_mul_rule o stm_rule2 o stm_rule1 o rule o Conv.CONV_RULE (Conv.DEPTH_CONV FOLDL_STM1_CONV) else Lib.I end From 808aff1ab13b4064567850040b83e8c4f27ebd38 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Mon, 3 Aug 2015 16:12:14 +0200 Subject: [PATCH 386/718] add docfile for gen_new_specification --- .../Definition.gen_new_specification.doc | 43 +++++++++++++++++++ .../Docfiles/Definition.new_specification.doc | 1 + 2 files changed, 44 insertions(+) create mode 100644 help/Docfiles/Definition.gen_new_specification.doc diff --git a/help/Docfiles/Definition.gen_new_specification.doc b/help/Docfiles/Definition.gen_new_specification.doc new file mode 100644 index 0000000000..96664fa4f7 --- /dev/null +++ b/help/Docfiles/Definition.gen_new_specification.doc @@ -0,0 +1,43 @@ +\DOC gen_new_specification + +\TYPE {gen_new_specification : string * thm -> thm} + +\SYNOPSIS +Introduce a constant or constants satisfying a given property. + +\DESCRIBE +The ML function {gen_new_specification} implements the generalised primitive +rule of constant specification for the HOL logic. + +Evaluating: +{ + gen_new_specification (name, [x1=t1,...,xn=tn] |- t) +} +simultaneously introduces new constants named {x1},...,{xn} +satisfying the property: +{ + |- t +} +where the variables {x1},...,{xn} in {t} are replaced by the new constants. + +This theorem is stored, with name {name}, as a definition in +the current theory segment. It is also returned by the call to +{gen_new_specification}. + +\FAILURE +{gen_new_specification} fails if any of the hypotheses of the input theorem are +not of the right form: they must be equations each with a variable on the +left-hand side and no free variables on the right-hand side. It also fails if +the supplied variables (equivalently, the desired constant names) {x1},...,{xn} +are not distinct. Finally, failure occurs if the type of some {ti} does not +contain all the type variables occurring in the term {ti} itself. + +\COMMENTS +The generalised version is described in Rob Arthan's ITP 2014 paper, HOL +Constant Definition Done Right, available from +{http://www.lemma-one.com/papers/hcddr.pdf}. + +\SEEALSO +Definition.new_specification. + +\ENDDOC diff --git a/help/Docfiles/Definition.new_specification.doc b/help/Docfiles/Definition.new_specification.doc index 72cc4e57f5..818d65b78e 100644 --- a/help/Docfiles/Definition.new_specification.doc +++ b/help/Docfiles/Definition.new_specification.doc @@ -51,6 +51,7 @@ use {set_fixity}. Typical fixity values are {Prefix}, {Binder}, {Infixl n}, {Infixr n}, {Suffix n}, {TruePrefix n} or {Closefix}. \SEEALSO +Definition.gen_new_specification, Definition.new_definition, boolSyntax.new_binder_definition, boolSyntax.new_infixl_definition, boolSyntax.new_infixr_definition, TotalDefn.Define, Parse.set_fixity. From 26cab26b0aa8bfed1397cd034f0556ac00c5fdcd Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Mon, 3 Aug 2015 16:00:51 +0100 Subject: [PATCH 387/718] Update some links. --- Manual/Quick/quick.tex | 2 +- README | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Manual/Quick/quick.tex b/Manual/Quick/quick.tex index f711cf5691..4f88f2484b 100644 --- a/Manual/Quick/quick.tex +++ b/Manual/Quick/quick.tex @@ -7,7 +7,7 @@ \usepackage{underscore} % http://www.tex.ac.uk/tex-archive/help/Catalogue/entries/underscore.html -\newcommand{\hol}[2]{{\sffamily #1.\href{http://hol.sourceforge.net/kananaskis-9-helpdocs/help/Docfiles/HTML/#1.#2.html}{#2}}} +\newcommand{\hol}[2]{{\sffamily #1.\href{http://hol-theorem-prover.org/kananaskis-10-helpdocs/help/Docfiles/HTML/#1.#2.html}{#2}}} \newcommand{\holnoref}[2]{{\sffamily #1.#2}} % You can customise the above e.g. without hyperlinks and full path.. %\newcommand{\hol}[2]{{\sffamily #2}} diff --git a/README b/README index 34776f28e3..6e48076d6f 100644 --- a/README +++ b/README @@ -1,5 +1,5 @@ This is the distribution directory for the Kananaskis release of HOL4. -See http://hol.sourceforge.net for online resources. +See http://hol-theorem-prover.org for online resources. The following is a brief listing of what's available in the distribution. From 13060d5be4b9e3825bb0bf85be41eee146a94984 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 3 Aug 2015 22:20:41 +0200 Subject: [PATCH 388/718] Implement & document which fn for Holmakefiles --- Manual/Description/misc.tex | 3 +++ tools/Holmake/internal_functions.sml | 33 ++++++++++++++++++++++++++++ 2 files changed, 36 insertions(+) diff --git a/Manual/Description/misc.tex b/Manual/Description/misc.tex index 6963fef2d2..d34f9da58b 100644 --- a/Manual/Description/misc.tex +++ b/Manual/Description/misc.tex @@ -574,6 +574,9 @@ \subsection{Using a make-file with \holmake} so that the above will be read as one unit by the underlying shell. \item[\texttt{\$(subst arg1,arg2,text)}] replaces every occurrence of \texttt{arg1} in \texttt{text} with \texttt{arg2}. +\item[\texttt{\$(which arg)}] is replaced by the full path to an executable and readable occurrence of a file called \texttt{arg} within a directory in the list of directories in the \texttt{PATH} environment variable. +For example \texttt{\$(which cat)} will usually expand to \texttt{/bin/cat} on Unix-like systems. +If there is no occurrence of \texttt{arg} in any directory in \texttt{PATH}, this function call expands to the empty string. \item[\texttt{\$(wildcard pattern)}] expands the shell ``glob'' pattern (\eg, \texttt{*Script.sml}) into the list of matching filenames. If the pattern doesn't match any files, then the function returns \texttt{pattern} unchanged. \end{description} diff --git a/tools/Holmake/internal_functions.sml b/tools/Holmake/internal_functions.sml index 2516259a3f..a2eb995006 100644 --- a/tools/Holmake/internal_functions.sml +++ b/tools/Holmake/internal_functions.sml @@ -238,6 +238,32 @@ fun wildcard s = | _ => (case recurse pfx starting_dir rest of [] => [s] | x => x) end +fun get_first f [] = NONE + | get_first f (h::t) = (case f h of NONE => get_first f t | x => x) + +fun which arg = + let + open OS.FileSys Systeml + val sepc = if isUnix then #":" else #";" + fun check p = + let + val fname = OS.Path.concat(p, arg) + in + if access (fname, [A_READ, A_EXEC]) then SOME fname else NONE + end + fun smash NONE = "" | smash (SOME s) = s + in + case OS.Process.getEnv "PATH" of + SOME path => + let + val paths = (if isUnix then [] else ["."]) @ + String.fields (fn c => c = sepc) path + in + smash (get_first check paths) + end + | NONE => if isUnix then "" else smash (check ".") + end + fun function_call (fnname, args, eval) = let open Substring in @@ -294,6 +320,13 @@ in in if size sfx = 0 then "" else findstr end + | "which" => if length args <> 1 then + raise Fail "Bad number of arguments to 'which' function" + else let + val arg_evalled = eval (hd args) + in + which arg_evalled + end | "wildcard" => if length args <> 1 then raise Fail "Bad number of arguments to 'wildcard' function" else let From 99ba622341437ba4f3ba99ca9f25b0cf7afd8fd7 Mon Sep 17 00:00:00 2001 From: Thibault Gauthier Date: Tue, 4 Aug 2015 12:50:54 +0200 Subject: [PATCH 389/718] holyhammer 1.0 --- developers/travis/before_install.sh | 11 + src/0/Thm.sml | 30 +- src/experimental-kernel/Thm.sml | 29 +- src/holyhammer/COPYRIGHT | 43 + src/holyhammer/README | 53 ++ src/holyhammer/examples/example.sml | 120 +++ src/holyhammer/examples/presentation.sml | 35 + src/holyhammer/hh/Holmakefile | 46 + src/holyhammer/hh/README | 15 + src/holyhammer/hh/accessibility.ml | 174 ++++ src/holyhammer/hh/dependency.ml | 218 +++++ src/holyhammer/hh/fof_lexer.mll | 78 ++ src/holyhammer/hh/fof_parse.mly | 69 ++ src/holyhammer/hh/hh1/Holmakefile | 47 + src/holyhammer/hh/hh1/LICENSE | 33 + src/holyhammer/hh/hh1/basics.ml | 384 ++++++++ src/holyhammer/hh/hh1/bool.ml | 313 +++++++ src/holyhammer/hh/hh1/canon.ml | 412 ++++++++ src/holyhammer/hh/hh1/drule.ml | 314 +++++++ src/holyhammer/hh/hh1/equal.ml | 318 +++++++ src/holyhammer/hh/hh1/features_dt.ml | 235 +++++ src/holyhammer/hh/hh1/fol.ml | 280 ++++++ src/holyhammer/hh/hh1/follist.ml | 266 ++++++ src/holyhammer/hh/hh1/fusion.ml | 600 ++++++++++++ src/holyhammer/hh/hh1/hh_symbols.ml | 340 +++++++ src/holyhammer/hh/hh1/hh_tac.ml | 395 ++++++++ src/holyhammer/hh/hh1/hh_write.ml | 696 ++++++++++++++ src/holyhammer/hh/hh1/hl_parser.ml | 504 ++++++++++ src/holyhammer/hh/hh1/lib.ml | 841 +++++++++++++++++ src/holyhammer/hh/hh1/main.ml | 3 + src/holyhammer/hh/hh1/meson.ml | 328 +++++++ src/holyhammer/hh/hh1/preterm.ml | 455 +++++++++ src/holyhammer/hh/hh1/printer.ml | 540 +++++++++++ src/holyhammer/hh/hh1/simp.ml | 216 +++++ src/holyhammer/hh/hh1/tactics.ml | 374 ++++++++ src/holyhammer/hh/hh1/theorems.ml | 265 ++++++ src/holyhammer/hh/hh_lexer.mll | 51 + src/holyhammer/hh/hh_parse.mly | 75 ++ src/holyhammer/hh/init.ml | 105 +++ src/holyhammer/hh/main.ml | 75 ++ src/holyhammer/hh/predict.ml | 99 ++ src/holyhammer/hh/prepredict.ml | 110 +++ src/holyhammer/hh/preprocess.ml | 181 ++++ src/holyhammer/hh/proto.ml | 100 ++ src/holyhammer/hh/read.ml | 155 ++++ src/holyhammer/hh/thf0.ml | 142 +++ src/holyhammer/hh/thf0hh1.ml | 139 +++ src/holyhammer/hh/thf1hh1.ml | 135 +++ src/holyhammer/hh/write.ml | 25 + src/holyhammer/hhReconstruct.sig | 8 + src/holyhammer/hhReconstruct.sml | 176 ++++ src/holyhammer/hhWriter.sig | 14 + src/holyhammer/hhWriter.sml | 495 ++++++++++ src/holyhammer/holyHammer.sig | 19 + src/holyhammer/holyHammer.sml | 190 ++++ src/holyhammer/predict/Holmakefile | 7 + src/holyhammer/predict/README | 10 + src/holyhammer/predict/dtree.cpp | 196 ++++ src/holyhammer/predict/format.cpp | 166 ++++ src/holyhammer/predict/knn.cpp | 93 ++ src/holyhammer/predict/main.cpp | 210 +++++ src/holyhammer/predict/mepo/Holmakefile | 10 + src/holyhammer/predict/mepo/format.cpp | 153 +++ src/holyhammer/predict/mepo/formatnow.cpp | 147 +++ src/holyhammer/predict/mepo/geo.cpp | 81 ++ src/holyhammer/predict/mepo/mepo3.cpp | 151 +++ src/holyhammer/predict/nbayes.cpp | 103 ++ src/holyhammer/predict/predictor.cpp | 67 ++ src/holyhammer/predict/rforest.cpp | 425 +++++++++ src/holyhammer/predict/tfidf.cpp | 52 ++ src/holyhammer/provers/eprover.sh | 24 + .../provers/eprover/COPYING_eprover | 877 ++++++++++++++++++ src/holyhammer/provers/vampire.sh | 23 + src/holyhammer/provers/vampire/README | 2 + src/holyhammer/provers/z3.sh | 25 + src/holyhammer/provers/z3/LICENSE.txt | 7 + src/holyhammer/provers/z3/README | 2 + src/holyhammer/scripts/hh.sh | 8 + src/holyhammer/scripts/hh_clean.sh | 14 + src/holyhammer/scripts/hh_eprover.sh | 16 + src/holyhammer/scripts/hh_vampire.sh | 16 + src/holyhammer/scripts/hh_z3.sh | 16 + src/logging-kernel/Thm.sml | 29 +- src/postkernel/Theory.sml | 35 +- src/prekernel/Dep.sig | 29 + src/prekernel/Dep.sml | 142 +++ src/prekernel/FinalTag-sig.sml | 19 +- src/prekernel/FinalThm-sig.sml | 8 +- src/prekernel/Tag.sig | 22 +- src/prekernel/Tag.sml | 124 ++- tools/build-sequence | 1 + tools/sequences/holyhammer | 5 + 92 files changed, 14598 insertions(+), 91 deletions(-) create mode 100644 src/holyhammer/COPYRIGHT create mode 100644 src/holyhammer/README create mode 100644 src/holyhammer/examples/example.sml create mode 100644 src/holyhammer/examples/presentation.sml create mode 100644 src/holyhammer/hh/Holmakefile create mode 100644 src/holyhammer/hh/README create mode 100644 src/holyhammer/hh/accessibility.ml create mode 100644 src/holyhammer/hh/dependency.ml create mode 100644 src/holyhammer/hh/fof_lexer.mll create mode 100644 src/holyhammer/hh/fof_parse.mly create mode 100644 src/holyhammer/hh/hh1/Holmakefile create mode 100644 src/holyhammer/hh/hh1/LICENSE create mode 100644 src/holyhammer/hh/hh1/basics.ml create mode 100644 src/holyhammer/hh/hh1/bool.ml create mode 100644 src/holyhammer/hh/hh1/canon.ml create mode 100644 src/holyhammer/hh/hh1/drule.ml create mode 100644 src/holyhammer/hh/hh1/equal.ml create mode 100644 src/holyhammer/hh/hh1/features_dt.ml create mode 100644 src/holyhammer/hh/hh1/fol.ml create mode 100644 src/holyhammer/hh/hh1/follist.ml create mode 100644 src/holyhammer/hh/hh1/fusion.ml create mode 100644 src/holyhammer/hh/hh1/hh_symbols.ml create mode 100644 src/holyhammer/hh/hh1/hh_tac.ml create mode 100644 src/holyhammer/hh/hh1/hh_write.ml create mode 100644 src/holyhammer/hh/hh1/hl_parser.ml create mode 100644 src/holyhammer/hh/hh1/lib.ml create mode 100644 src/holyhammer/hh/hh1/main.ml create mode 100644 src/holyhammer/hh/hh1/meson.ml create mode 100644 src/holyhammer/hh/hh1/preterm.ml create mode 100644 src/holyhammer/hh/hh1/printer.ml create mode 100644 src/holyhammer/hh/hh1/simp.ml create mode 100644 src/holyhammer/hh/hh1/tactics.ml create mode 100644 src/holyhammer/hh/hh1/theorems.ml create mode 100644 src/holyhammer/hh/hh_lexer.mll create mode 100644 src/holyhammer/hh/hh_parse.mly create mode 100644 src/holyhammer/hh/init.ml create mode 100644 src/holyhammer/hh/main.ml create mode 100644 src/holyhammer/hh/predict.ml create mode 100644 src/holyhammer/hh/prepredict.ml create mode 100644 src/holyhammer/hh/preprocess.ml create mode 100644 src/holyhammer/hh/proto.ml create mode 100644 src/holyhammer/hh/read.ml create mode 100644 src/holyhammer/hh/thf0.ml create mode 100644 src/holyhammer/hh/thf0hh1.ml create mode 100644 src/holyhammer/hh/thf1hh1.ml create mode 100644 src/holyhammer/hh/write.ml create mode 100644 src/holyhammer/hhReconstruct.sig create mode 100644 src/holyhammer/hhReconstruct.sml create mode 100644 src/holyhammer/hhWriter.sig create mode 100644 src/holyhammer/hhWriter.sml create mode 100644 src/holyhammer/holyHammer.sig create mode 100644 src/holyhammer/holyHammer.sml create mode 100644 src/holyhammer/predict/Holmakefile create mode 100644 src/holyhammer/predict/README create mode 100644 src/holyhammer/predict/dtree.cpp create mode 100644 src/holyhammer/predict/format.cpp create mode 100644 src/holyhammer/predict/knn.cpp create mode 100644 src/holyhammer/predict/main.cpp create mode 100644 src/holyhammer/predict/mepo/Holmakefile create mode 100644 src/holyhammer/predict/mepo/format.cpp create mode 100644 src/holyhammer/predict/mepo/formatnow.cpp create mode 100644 src/holyhammer/predict/mepo/geo.cpp create mode 100644 src/holyhammer/predict/mepo/mepo3.cpp create mode 100644 src/holyhammer/predict/nbayes.cpp create mode 100644 src/holyhammer/predict/predictor.cpp create mode 100644 src/holyhammer/predict/rforest.cpp create mode 100644 src/holyhammer/predict/tfidf.cpp create mode 100644 src/holyhammer/provers/eprover.sh create mode 100644 src/holyhammer/provers/eprover/COPYING_eprover create mode 100644 src/holyhammer/provers/vampire.sh create mode 100644 src/holyhammer/provers/vampire/README create mode 100644 src/holyhammer/provers/z3.sh create mode 100644 src/holyhammer/provers/z3/LICENSE.txt create mode 100644 src/holyhammer/provers/z3/README create mode 100644 src/holyhammer/scripts/hh.sh create mode 100644 src/holyhammer/scripts/hh_clean.sh create mode 100644 src/holyhammer/scripts/hh_eprover.sh create mode 100644 src/holyhammer/scripts/hh_vampire.sh create mode 100644 src/holyhammer/scripts/hh_z3.sh create mode 100644 src/prekernel/Dep.sig create mode 100644 src/prekernel/Dep.sml create mode 100644 tools/sequences/holyhammer diff --git a/developers/travis/before_install.sh b/developers/travis/before_install.sh index c447539d99..a0ba1211bd 100755 --- a/developers/travis/before_install.sh +++ b/developers/travis/before_install.sh @@ -34,3 +34,14 @@ make compiler make install fi + +cd +# installing ocaml +echo "*** Installing Ocaml ***" +sudo apt-get install ocaml +# installing newer g++ +echo "*** Installing newer g++ version ***" +sudo add-apt-repository ppa:ubuntu-toolchain-r/test -y +sudo apt-get update +sudo apt-get install g++-4.8 + diff --git a/src/0/Thm.sml b/src/0/Thm.sml index b8fb2c5b1b..e6bd9d927f 100644 --- a/src/0/Thm.sml +++ b/src/0/Thm.sml @@ -15,9 +15,10 @@ structure Thm :> Thm = struct -open Feedback Lib Term KernelTypes Tag +open Feedback Lib Term KernelTypes Tag Dep type 'a set = 'a HOLset.set; +type depdisk = (string * int) * ((string * int list) list); val --> = Type.-->; infixr 3 -->; @@ -1222,15 +1223,38 @@ end +(* ---------------------------------------------------------------------- + Creating a theorem from disk + ---------------------------------------------------------------------- *) + local val mk_disk_thm = make_thm Count.Disk in -fun disk_thm (s, termlist) = let +fun disk_thm ((d,ocl), termlist) = let val c = hd termlist val asl = tl termlist in - mk_disk_thm(Tag.read_disk_tag s,list_hyp asl,c) + mk_disk_thm (Tag.read_disk_tag (d,ocl),list_hyp asl,c) end end; (* local *) +(* ---------------------------------------------------------------------- + Saving dependencies of a theorem + ---------------------------------------------------------------------- *) + +(* This reference is automatically reset to 0 each time you create + a theory. *) +val thm_order = ref 0 + +fun save_dep thy (th as (THM(t,h,c))) = + let + val did = (thy,!thm_order) + val dl = (transfer_thydepl o dep_of o tag) th + val dep = DEP_SAVED(did,dl) + in + thm_order := (!thm_order) + 1; + THM(Tag.set_dep dep t,h,c) + end + + end (* Thm *) diff --git a/src/experimental-kernel/Thm.sml b/src/experimental-kernel/Thm.sml index 3b98368d91..b5ede294fe 100644 --- a/src/experimental-kernel/Thm.sml +++ b/src/experimental-kernel/Thm.sml @@ -15,9 +15,10 @@ structure Thm :> Thm = struct -open Feedback Lib Term +open Feedback Lib Term Tag Dep type 'a set = 'a HOLset.set; +type depdisk = (string * int) * ((string * int list) list); type tag = Tag.tag val --> = Type.-->; @@ -1208,15 +1209,37 @@ in end +(* ---------------------------------------------------------------------- + Creating a theorem from disk + ---------------------------------------------------------------------- *) + local val mk_disk_thm = make_thm Count.Disk in -fun disk_thm (s, termlist) = let +fun disk_thm ((d,ocl), termlist) = let val c = hd termlist val asl = tl termlist in - mk_disk_thm(Tag.read_disk_tag s,list_hyp asl,c) + mk_disk_thm (Tag.read_disk_tag (d,ocl),list_hyp asl,c) end end; (* local *) +(* ---------------------------------------------------------------------- + Saving dependencies of a theorem + ---------------------------------------------------------------------- *) + +(* This reference is automatically reset to 0 each time you create + a theory. *) +val thm_order = ref 0 + +fun save_dep thy (th as (THM(t,h,c))) = + let + val did = (thy,!thm_order) + val dl = (transfer_thydepl o dep_of o tag) th + val dep = DEP_SAVED(did,dl) + in + thm_order := (!thm_order) + 1; + THM(Tag.set_dep dep t,h,c) + end + end (* Thm *) diff --git a/src/holyhammer/COPYRIGHT b/src/holyhammer/COPYRIGHT new file mode 100644 index 0000000000..900856249a --- /dev/null +++ b/src/holyhammer/COPYRIGHT @@ -0,0 +1,43 @@ +HOLYHAMMER COPYRIGHT NOTICE, LICENSE AND DISCLAIMER. + +Copyright 2014--2030 by Cezary Kalyszik and Thibault Gauthier. + +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in + the documentation and/or other materials provided with the + distribution. + + * The names of the copyright holders and contributors may not be + used to endorse or promote products derived from this software + without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS +OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR +TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE +USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH +DAMAGE. + +---------------------------------------------------------------------- +Some files we distribute with HOLYHAMMER are the work of others. +Their copyrights may differ from the above. +In particular, the following sub-directories are governed by +different copyright notices: + bin/eprover +---------------------------------------------------------------------- + diff --git a/src/holyhammer/README b/src/holyhammer/README new file mode 100644 index 0000000000..fae32d165e --- /dev/null +++ b/src/holyhammer/README @@ -0,0 +1,53 @@ +HOLyHammer is a machine learning for theorem proving framework. + +Requires: + +* OCaml >= 3.12 + sudo apt-get install ocaml +* g++ >= 4.8 (recent version with C++11 support) + Ubuntu 12.04: + sudo add-apt-repository ppa:ubuntu-toolchain-r/test -y + sudo apt-get update + sudo apt-get install g++-4.8 + +Install holyhammer: (done during the build) + + run Holmake in src/holyhammer + run Holmake in src/holyhammer/hh/hh1 + run Holmake in src/holyhammer/hh + run Holmake in src/holyhammer/predict + run Holmake in src/holyhammer/predict/mepo + +Adding provers: + + Eprover and Z3 are given by default are for linux 64 bit. + Please replace the binary in provers/eprover/eprover if necessary. + You may use different versions but parsing may need to be fixed in + provers/"prover".sh . + The name of the binary for Vampire has to be vampire. + +Removing provers: + + Delete the binaries (eprover,z3 or vampire) in + their respective directory provers/"prover". + +Predictors: + The two best predictors are KNN and Mepo. + Mepo works best for a definition based proof with small theorems + KNN learns from previous proofs so it is useful on well developed theories. + The default predictor is KNN. + Please switch between them if the proof fails by using + "set_predictors Mepo;" and "set_predictors Knn;" + +Example: + + load "holyHammer"; + open holyHammer; + hh [] ``1 + 1 = 2``; + METIS_PROVE lemmas ``1 + 1 = 2``; + load "complexTheory"; + hh_atp "eprover" [] ``0 <> 1``; + +Questions: + + If you have any question, you can send an email to thibault_gauthier@hotmail.fr. diff --git a/src/holyhammer/examples/example.sml b/src/holyhammer/examples/example.sml new file mode 100644 index 0000000000..9118f4a4b5 --- /dev/null +++ b/src/holyhammer/examples/example.sml @@ -0,0 +1,120 @@ +load "holyHammer"; +open holyHammer; + +(*-------------------------------------------------------------------------- + Example 1 + -------------------------------------------------------------------------- *) + +val cj = ``a ≤ b ⇒ (g ** (b − a) * g ** a = g ** b)`` + (* hh [] cj; *) +val lemmas = [fetch "arithmetic" "SUB_ADD", fetch "arithmetic" "EXP_ADD"]; +val th = save_thm ("EXP_NEG",METIS_PROVE (lemmas) cj); + +(*-------------------------------------------------------------------------- + Example 2 + -------------------------------------------------------------------------- *) + +new_theory "zerok"; + +val BASE_DEF = new_definition ("BASE_DEF",``BASE = @(x:num). x >= 2``); +val th0 = INST_TYPE [alpha |-> ``:num``] SELECT_AX; +val th1 = save_thm ("hh0",SPECL [``\x.x>=(2:num)``,``2:num``] th0); +val cj = ``BASE>=2``; + (* hh [th0,th1] cj; *) +val lemmas = [fetch "zerok" "BASE_DEF", fetch "numeral" "numeral_lte", + fetch "arithmetic" "GREATER_EQ", + fetch "arithmetic" "NUMERAL_DEF"]; + +val th = save_thm ("BASE_THM",METIS_PROVE ([th0,th1] @ lemmas) cj); + +(*-------------------------------------------------------------------------- + Example 3 + -------------------------------------------------------------------------- *) + +(* Tools to fetch rewrite theorems (could be programmed using DB.match) *) + +fun is_rwthm_of c (s,thm) = + let + val thml = CONJUNCTS thm + val th1 = SPEC_ALL (hd thml) + val tm1 = concl th1 + val (c1,_) = strip_comb (lhs tm1) + in + same_const c c1 + end + handle _ => false + +fun fetch_rwthm c = + let + val {Name,Thy,Ty} = dest_thy_const c + val thml = DB.thms Thy + val thml1 = filter (is_rwthm_of c) thml + in + (List.hd thml1) + end + +fun all_rwthm term = + let + val cl = filter (not o (same_const equality)) (find_terms is_const term) + val cl = mk_set cl + val thml = map fetch_rwthm cl; + in + thml + end + +(* Starting Proof *) + +load "complexTheory"; +val cj = ``i * i = -1``; +(* all_rwthm cj; *) +(* hh [complexTheory.complex_mul] cj; *) +val eqthm = REWRITE_CONV [complexTheory.complex_mul] cj; +val new_cj = rhs (concl eqthm); +(* hh [complexTheory.complex_mul] cj; *) +(* hh [] new_cj; *) +val lemmas = [fetch "complex" "complex_neg", fetch "real" "REAL_MUL_RZERO", + fetch "real" "REAL_ADD_LID", fetch "real" "REAL_MUL_RID", + fetch "complex" "RE", fetch "pair" "FST", + fetch "complex" "complex_of_num", + fetch "complex" "complex_of_real", fetch "complex" "IM", + fetch "pair" "SND", fetch "real" "real_sub", + fetch "real" "REAL_ADD_RINV", fetch "complex" "i"]; + +val th = METIS_PROVE lemmas new_cj; +val th1 = EQ_MP (SYM eqthm) th; + + +(*-------------------------------------------------------------------------- + Example 4 (turning off minimization) + -------------------------------------------------------------------------- *) + +load "complexTheory"; +val cj = ``(1:complex) + 1 = 2``; +hh [] cj; +hh [complexTheory.complex_add] cj; + +val lemmas = [fetch "real" "REAL_MUL_RZERO", fetch "real" "REAL_MUL_RID", + fetch "complex" "complex_scalar_lmul", + fetch "complex" "COMPLEX_DOUBLE", + fetch "complex" "complex_of_num", fetch "complex" "IM", + fetch "pair" "SND", fetch "complex" "RE", + fetch "complex" "complex_of_real", fetch "pair" "FST"]; + + +val th = METIS_PROVE (complexTheory.complex_add :: lemmas) cj; + +load "hhReconstruct"; +open hhReconstruct; +minimize_flag:= false; + +hh [complexTheory.complex_add] cj; +val lemmas = [fetch "pair" "FST", fetch "complex" "complex_of_real", + fetch "complex" "RE", fetch "pair" "SND", fetch "complex" "IM", + fetch "complex" "complex_of_num", + fetch "complex" "COMPLEX_DOUBLE", + fetch "complex" "complex_scalar_lmul", + fetch "complex" "complex_pow_def_compute", + fetch "real" "REAL_MUL_RID", fetch "real" "REAL_MUL_RZERO"]; + + + diff --git a/src/holyhammer/examples/presentation.sml b/src/holyhammer/examples/presentation.sml new file mode 100644 index 0000000000..6fa8dc7b56 --- /dev/null +++ b/src/holyhammer/examples/presentation.sml @@ -0,0 +1,35 @@ +load "holyHammer"; +open holyHammer; + +hh [] ``54 + 35 = 89``; + +load "transcTheory"; +M +val cj = ``1 = cos x * cos x + sin x * sin x``; + +val thm = save_thm ("LEM1",METIS_PROVE lemmas cj); + +val cj = ``cos (2 * x) + 1 = + cos x * cos x - sin x * sin x + + (cos x * cos x + sin x * sin x)``; +val thm = save_thm ("LEM2",METIS_PROVE lemmas cj); + +val cj = ``(a = b - c + (b + c)) ==> (a = b + b)``; +val thm = save_thm ("LEM3",METIS_PROVE lemmas cj); + +val cj = ``cos (2 * x) = 2 * cos x pow 2 - 1``; +set_predictors Mepo; +val thm = save_thm ("LEM4",METIS_PROVE (thm :: lemmas) cj); + +val cj = ``2 * cos x pow 2 = 1 + cos (2*x)``; +set_predictors KNN; +set_timeout 15; +val thm = save_thm ("LEM5",METIS_PROVE lemmas cj); + +val cj = ``(2:real * a:real = b) ==> (a:real = b/2:real)``; +set_predictors Mepo; +val thm = save_thm ("LEM6",METIS_PROVE lemmas cj); + +val cj = ``cos x pow 2 = (1 + cos (2*x))/2``; +val thm = save_thm ("COS_LIN",METIS_PROVE lemmas cj); + diff --git a/src/holyhammer/hh/Holmakefile b/src/holyhammer/hh/Holmakefile new file mode 100644 index 0000000000..eebab464c9 --- /dev/null +++ b/src/holyhammer/hh/Holmakefile @@ -0,0 +1,46 @@ +HH2_CMX=hh_parse.cmx hh_lexer.cmx read.cmx predict.cmx preprocess.cmx init.cmx \ +dependency.cmx thf1hh1.cmx prepredict.cmx write.cmx + +HL_CMX=hh1/lib.cmx hh1/fusion.cmx hh1/basics.cmx hh1/printer.cmx \ +hh1/preterm.cmx hh1/hl_parser.cmx hh1/equal.cmx hh1/bool.cmx \ +hh1/drule.cmx hh1/tactics.cmx hh1/simp.cmx hh1/theorems.cmx \ +hh1/canon.cmx hh1/fol.cmx hh1/follist.cmx hh1/meson.cmx \ +hh1/hh_symbols.cmx hh1/features_dt.cmx hh1/hh_tac.cmx hh1/hh_write.cmx + +ALL_CMX=$(HL_CMX) $(HH2_CMX) + +all: $(HH2_CMX) hh + +hh: main.ml + ocamlopt nums.cmxa str.cmxa unix.cmxa -o $@ -I hh1 $(ALL_CMX) $< + +hh_parse.ml: hh_parse.mly + ocamlyacc $< + rm hh_parse.mli + +hh_lexer.ml: hh_lexer.mll hh_parse.ml + ocamllex $< + +hh_parse.cmx: hh_parse.ml + ocamlopt -c $< +hh_lexer.cmx: hh_lexer.ml + ocamlopt -c $< +read.cmx: read.ml + ocamlopt -c -I hh1 $< +predict.cmx: predict.ml + ocamlopt -c -I hh1 $< +preprocess.cmx: preprocess.ml + ocamlopt -c -I hh1 $< +init.cmx: init.ml + ocamlopt -c -I hh1 $< +dependency.cmx: dependency.ml + ocamlopt -c -I hh1 $< +thf1hh1.cmx: thf1hh1.ml + ocamlopt -c -I hh1 $< +prepredict.cmx: prepredict.ml + ocamlopt -c -I hh1 $< +write.cmx: write.ml + ocamlopt -c -I hh1 $< + +clean: + rm -f hh *cmx *cmi *_lexer.ml *_parse.ml *.o *.mli diff --git a/src/holyhammer/hh/README b/src/holyhammer/hh/README new file mode 100644 index 0000000000..580468b690 --- /dev/null +++ b/src/holyhammer/hh/README @@ -0,0 +1,15 @@ +This is HH / THF0 batch processor. + +Requires: +* OCaml >= 3.12 (tested also with 4.01.0) +* g++ (recent version with C++11 support) +* eproof (the eprover proof-reconstruction script); needs to be in PATH + +To compile: +* run make in hh1 subdir +* run make in predict subdir +* run make + +To test fun for example: +./hhthf0 30 example/test_theorem.p +./hhthf0 3 example/test_timeout.p diff --git a/src/holyhammer/hh/accessibility.ml b/src/holyhammer/hh/accessibility.ml new file mode 100644 index 0000000000..ec5e0e1eb1 --- /dev/null +++ b/src/holyhammer/hh/accessibility.ml @@ -0,0 +1,174 @@ +(*-------------------------------------------------------------------------- *) +(* This files contains the necessary functions used in the accessibility *) +(* experiments. *) +(*-------------------------------------------------------------------------- *) + +open Read +open Hh_parse +open Thf1hh1 +open Dependency +open Predict_knn +open Write + +(* Output: writing fof problems *) + +let eval_dir = "../eval/" +let tmp_file = "predictions/predict_hh_";; +let acc_predictor = KNN + +let w_errors = ref [] + +let write_fof_exp file_name (cj_name, axioms) = + try write_fof file_name (cj_name, axioms) + with e -> w_errors := e :: !w_errors (* allowing errors (can't prove True) *) + +let mkdir s = try Unix.mkdir s 0o777 with Unix.Unix_error (Unix.EEXIST,_,_) -> () + +let rec mkdir_rec s = + if s = "." || s = ".." || s = "" || s = "/" then () + else (mkdir_rec (Filename.dirname s); mkdir s) + +(* +Initialisation need to be performed before experiments on a library +Warning: +- If a linear order is provided, + all theories that belong to this order are ignored +- thydep_file is a string option for the theory graph +- thylo_file is a string option for the theory linear order. +*) + + +let acc_predict n_preds (cj_name,l) = + let cj = term_of cj_name in + predict_interactive acc_predictor tmp_file n_preds cj l + +let init_acc_env thy_dir thydep_file thylo_file = + let ((tyl,cl,thml),(thmh,roleh,thmlo)) = Init.init_dir thy_dir in + let _ = init_dep_env thydep_file thylo_file (thmh,roleh,thmlo) in + Thf1hh1.parse (tyl,cl,thml) (* creating the term hash *) + +(* Experiment 1 *) +let write_dep_thy pdir thy = + let dir = pdir ^ "/" ^ thy in mkdir_rec dir; + let f x = + let fname = dir ^ "/" ^ Filename.basename x in + if role_of x = "def" then () + else write_fof_exp fname (x,gen_dep x) + in + print_string thy; + List.iter f (thml_of thy); + print_string "\n" + +let write_dep p = + let pdir = eval_dir ^ "/" ^ p ^ "_dep" in mkdir_rec pdir; + print_string "Writing dependencies:\n"; + List.iter (write_dep_thy pdir) (all_thys ()) + +(* Experiment 2 *) +let write_td_thy n pdir thy = + let dir = pdir ^ "/" ^ thy in mkdir_rec dir; + let f x = + let fname = dir ^ "/" ^ Filename.basename x in + if role_of x = "def" then () + else let l = gen_td x in + if l = [] then write_fof_exp fname (x,[]) + else write_fof_exp fname (x, acc_predict n (x,l)) + in + List.iter f (thml_of thy) + +let write_td n p = + let pdir = eval_dir ^ "/" ^ p ^ "_td_" ^ (string_of_int n) in mkdir_rec pdir; + print_string "Writing transitive dependencies:\n"; + List.iter (write_td_thy n pdir) (all_thys ()) + + +(* Experiment 3 *) +let write_loaded_thy n pdir thy = + let dir = pdir ^ "/" ^ thy in mkdir_rec dir; + let f x = + let fname = dir ^ "/" ^ Filename.basename x in + if role_of x = "def" then () + else write_fof_exp fname (x,acc_predict n (x, gen_loaded x)) + in + print_string thy; + List.iter f (thml_of thy); + print_string "\n" + +let write_loaded n p = + let pdir = eval_dir ^ "/" ^ p ^ "_loaded_" ^ (string_of_int n) in mkdir_rec pdir; + print_string "Writing loaded theorems:\n"; + List.iter (write_loaded_thy n pdir) (all_thys ()) + + +(* Experiment 4 *) +let write_lo_thy n pdir thy = + let dir = pdir ^ "/" ^ thy in mkdir_rec dir; + let f x = + let fname = dir ^ "/" ^ Filename.basename x in + if role_of x = "def" then () + else let l = gen_lo x in + if l = [] then write_fof_exp fname (x,[]) + else write_fof_exp fname (x, acc_predict n (x,l)) + in + print_string thy; + List.iter f (thml_of thy); + print_string "\n" + +let write_lo n p = + let pdir = eval_dir ^ "/" ^ p ^ "_lo_" ^ (string_of_int n) in mkdir_rec pdir; + print_string "Writing linear order:\n"; + List.iter (write_lo_thy n pdir) !thy_lo + + +(* Running +terminal command: rlwrap ./top -I hh1 +open Accessibility;; +open Read;; +open Dependency;; + +(* matching *) + + +(* hol4 *) +let thy_dir = dir_of_itp "h4";; +let thydep_file = Some (thydep_of_itp "h4");; +let thylo_file = None;; +let exp_name = "h4";; + + +init_acc_env thy_dir thydep_file thylo_file;; + +let cjname = "'list/APPEND_NIL_'";; +let axl = gen_loaded cjname;; +acc_predict 10000 (cjname,axl);; + +write_loaded 128 exp_name;; + +(* hollight *) +let thy_dir = dir_of_itp "hl";; +let thydep_file = None;; +let thylo_file = None;; + +init_acc_env thy_dir thydep_file thylo_file;; + +write_dep "hl";; +write_td "hl";; +write_loaded "hl";; +write_lo "hl";; (* any order is chosen here *) +*) + +(* Testing +open Dependency;; +let alist_of_hash hash = + Hashtbl.fold (fun k v l -> (k,v) :: l) hash [] ;; +let h = Read.read_thy_graph (thy_graph "h4");; +let h = (!term_hash);; +let h = (!role_hash);; +let h = (!dep_hash);; +let list = (!thm_lo);; +let f hash = Hashtbl.fold (fun k (v,r) l -> (k,v) :: l) hash [] ;; +let g hash = Hashtbl.fold (fun k (v,r) l -> (k,r) :: l) hash [] ;; +let al = alist_of_hash h;; +*) + + diff --git a/src/holyhammer/hh/dependency.ml b/src/holyhammer/hh/dependency.ml new file mode 100644 index 0000000000..8e5399c83d --- /dev/null +++ b/src/holyhammer/hh/dependency.ml @@ -0,0 +1,218 @@ + +(* These are structures specific to the relation between dependencies *) + +(* string sets *) +module Ss = Set.Make(struct type t = string let compare = compare end);; + +let rec mk_set l = match l with + [] -> Ss.empty + | a :: m -> Ss.add a (mk_set m) + +let rec xunion setl = + match setl with + [] -> Ss.empty + | set :: m -> Ss.union set (xunion m) + + +(***** Global references (to be initialised before usage) *****) +(* + dep_hash : thm -> (thy,dep) + role_hash : thm -> role + thm_lo : thy -> thml + thy_hash : thy -> thyl + seq_hash : thm -> int +*) + + +let (dep_hash : (string,(string * string list)) Hashtbl.t ref) = + ref (Hashtbl.create 20000) +let (role_hash : (string,string) Hashtbl.t ref) = + ref (Hashtbl.create 20000) +let thm_lo = ref [] +let (thy_hash : (string,string list) Hashtbl.t ref) = ref (Hashtbl.create 1000) +let (thy_td_hash : (string,string list) Hashtbl.t ref) = ref (Hashtbl.create 1000) +let (thm_td_hash : (string,string list) Hashtbl.t ref) = ref (Hashtbl.create 20000) +let (seq_hash : (string,int) Hashtbl.t ref ) = ref (Hashtbl.create 20000) +let thy_lo = ref [] + +(* Accessors *) +let thy_of thm = try fst (Hashtbl.find (!dep_hash) thm) + with _ -> failwith ("Not found theorem: " ^ thm) +let dep_of thm = try snd (Hashtbl.find (!dep_hash) thm) + with _ -> failwith ("Not found theorem: " ^ thm) +let role_of thm = try Hashtbl.find (!role_hash) thm + with _ -> failwith ("Not found theorem: " ^ thm) + +let thml_of thy = try List.assoc thy (!thm_lo) + with _ -> failwith ("Not found theory in thm_lo: " ^ thy) +let all_thys () = List.map fst (!thm_lo) +let dep_of_thy thy = try Hashtbl.find (!thy_hash) thy + with _ -> failwith ("Not found theory in thy_hash: " ^ thy) +let thml_of_thyl thyl = List.concat (List.map thml_of thyl) + +let all_thms () = thml_of_thyl (all_thys ()) + +let seq_of thm = try Hashtbl.find (!seq_hash) thm + with _ -> failwith ("Not found theorem: " ^ thm) + +let rec rm_dupl l = match l with + | [] -> [] + | a :: m -> if List.mem a m then rm_dupl m else a :: rm_dupl m + +let rec td_of_check thmog thm = + if thm = thmog then failwith ("Theorem loop: " ^ thm) else + try Hashtbl.find !thm_td_hash thm with Not_found -> + begin + let thml = dep_of thm in + let res = rm_dupl (List.concat (thml :: List.map (td_of_check thmog) thml)) in + Hashtbl.add !thm_td_hash thm res; res + end + +let rec td_of thm = + try Hashtbl.find !thm_td_hash thm with Not_found -> + begin + let thml = dep_of thm in + let res = rm_dupl (List.concat (thml :: List.map (td_of_check thm) thml)) in + Hashtbl.add !thm_td_hash thm res; res + end + +let rec td_of_thy_check thyog thy = + if thy = thyog then failwith ("Theory loop: " ^ thy) else + try Hashtbl.find !thy_td_hash thy with Not_found -> + begin + let thyl = dep_of_thy thy in + let res = rm_dupl (List.concat (thyl :: List.map (td_of_thy_check thyog) thyl)) in + Hashtbl.add !thy_td_hash thy res; res + end + +let rec td_of_thy thy = + try Hashtbl.find !thy_td_hash thy with Not_found -> + begin + let thyl = dep_of_thy thy in + let res = rm_dupl (List.concat (thyl :: List.map (td_of_thy_check thy) thyl)) in + Hashtbl.add !thy_td_hash thy res; res + end + +let rm_trans_edge l1 = + let s2 = xunion (List.map (Lib.o mk_set td_of_thy) l1) in + Ss.elements (Ss.diff (mk_set l1) s2) + +let rm_trans_thy_hash () = + let hmem = !thy_hash in + let hres = Hashtbl.create 1000 in + let f k v = Hashtbl.add hres k (rm_trans_edge v) in + Hashtbl.iter f hmem; thy_hash := hres + +(* Require dep_hash, thm_lo, optionally a thy_graph file *) +let init_thy_hash fname = + Hashtbl.clear !thy_hash; + match fname with + | Some s -> (print_string ("- loading theory graph from: " ^ s ^ "\n"); + thy_hash := Read.read_thy_graph s) + | None -> + begin + print_string ("- infering theory graph from dependencies\n"); + let add thy = + let nl = thml_of thy in + let dnl = List.concat (List.map dep_of nl) in + let thyset = mk_set (List.map thy_of dnl) in + Hashtbl.add (!thy_hash) thy (Ss.elements (Ss.remove thy thyset)) + in + List.iter add (all_thys ()) + end + +let init_thm_td_hash () = + print_string "- computing transitive dependencies of theorems\n"; + Hashtbl.clear (!thm_td_hash); + List.iter (Lib.o ignore td_of) (all_thms ()) + +let init_thy_td_hash () = + print_string "- computing transitive dependencies of theories\n"; + Hashtbl.clear (!thy_td_hash); + List.iter (Lib.o ignore td_of_thy) (all_thys ()) + + +(* Linear order *) +let rec prevl l e = match l with + [] -> failwith "prevl: Not_found" + | a :: m -> if a = e then [] else a :: prevl m e + +(* gives a sequential number to a theories and theorems *) +let rec sort_thyl thyl = match thyl with + | [] -> [] + | thy :: m -> let l = td_of_thy thy in + let (l1,l2) = List.partition (fun x -> List.mem x l) m in + sort_thyl l1 @ [thy] @ sort_thyl l2 + +let init_seq_hash fname = + let seq_n = ref 0 in + let add_thm_seq_hash thm = + Hashtbl.add !seq_hash thm !seq_n; + seq_n := !seq_n + 1 + in + let add_thy_seq_hash thy = + List.iter add_thm_seq_hash (thml_of thy) + in + Hashtbl.clear !seq_hash; + let thyl = match fname with + | Some s -> (print_string ("- loading theory order from: " ^ s ^ "\n"); + Read.read_thy_lo s) + | None -> (print_string ("- infering order of theories \n"); + sort_thyl (all_thys ())) + in + thy_lo := thyl; + List.iter add_thy_seq_hash thyl + +(* Environnement: +fname1 is a string option for the theory graph +fname2 is a string option for the theory linear order. +*) +let init_dep_env fname1 fname2 (deph,roleh,thmlo) = + print_string "Defining accessibility functions: \n"; + dep_hash := deph; + role_hash := roleh; + thm_lo := thmlo; + init_thy_hash fname1; + Hashtbl.clear (!thm_td_hash); + (* init_thm_td_hash (); *) + init_thy_td_hash (); + rm_trans_thy_hash (); + init_seq_hash fname2; (* initialize also thy_lo *) + (Hashtbl.copy !dep_hash, + Hashtbl.copy !role_hash, + !thm_lo, + Hashtbl.copy !thy_hash, + Hashtbl.copy !thy_td_hash, + Hashtbl.copy !thm_td_hash, + Hashtbl.copy !seq_hash, + !thy_lo) + +let set_dep_env (deph,roleh,thmlo,thyh,thytdh,thmtdh,seqh,thylo) = + dep_hash := deph; role_hash := roleh; thm_lo := thmlo; + thy_hash := thyh; + thy_td_hash := thytdh; + thm_td_hash := thmtdh; + seq_hash := seqh; + thy_lo := thylo + +(* Methods *) +let sort_thml thml = + let compare_thm thm1 thm2 = compare (seq_of thm1) (seq_of thm2) in + List.sort compare_thm thml + +let gen_dep thm = sort_thml (dep_of thm) +let gen_td thm = sort_thml (td_of thm) +let gen_loaded thm = + let thy = thy_of thm in + let pnl = prevl (thml_of thy) thm in + let anl = thml_of_thyl (td_of_thy thy) in + sort_thml (pnl @ anl) + +let gen_lo thm = + let thy = thy_of thm in + let pnl = prevl (thml_of thy) thm in + let anl = thml_of_thyl (prevl (!thy_lo) thy) in + sort_thml (pnl @ anl) + +let gen_all () = sort_thml (thml_of_thyl (all_thys())) + diff --git a/src/holyhammer/hh/fof_lexer.mll b/src/holyhammer/hh/fof_lexer.mll new file mode 100644 index 0000000000..c3daab3680 --- /dev/null +++ b/src/holyhammer/hh/fof_lexer.mll @@ -0,0 +1,78 @@ +{ + open Lexing;; + open Fof_parse;; +} + +let white = [' ' '\t' '\r' '\n'] +let letter = ['/' 'a'-'z' 'A'-'Z' '0'-'9' '_' '\''] +let any = [^ '\r' '\n'] + +rule hhlex = parse +| '%' any* {hhlex lexbuf} +| '#' any* {hhlex lexbuf} +| white+ {hhlex lexbuf} +| eof {Eof} +| '(' {(*Printf.printf "(%!"; *)Openp} +| ')' {(*Printf.printf ")%!"; *)Closep} +| '.' {Dot} +| ',' {Comma} +| '!' white* '[' {(*Printf.printf "!%!"; *)All (lex_ids lexbuf)} +| '?' white* '[' {Exists (lex_ids lexbuf)} +| '=' {Eq} +| "!=" {Neq} +| '~' {Tilde} +| "<=>" {Eqvt} +| "<~>" {Neqvt} +| "=>" {(*Printf.printf ">%!"; *)Impl} +| '&' {(*Printf.printf "&%!"; *)And} +| '|' {Or} +| '$' letter+ {Word (Lexing.lexeme lexbuf)} +| letter+ {(*Printf.printf ".%!"; *)Word (Lexing.lexeme lexbuf)} +| '\'' [^ '\'']+ '\'' {(*Printf.printf ".%!"; *)Word (Lexing.lexeme lexbuf)} + +and lex_ids = parse +| white+ {lex_ids lexbuf} +| letter+ {let i = Lexing.lexeme lexbuf in + i :: (lex_ids_more lexbuf)} + +and lex_ids_more = parse +| white+ {lex_ids_more lexbuf} +| ',' {lex_ids lexbuf} +| ']' white* ':' {[]} + +{ +Fusion.the_type_constants := ("$i", 0) :: !Fusion.the_type_constants;; +let read_fof fname = + let inc = + if fname = "-" then stdin else open_in fname in + let lexb = Lexing.from_channel inc in + let rec prf acc = + try + let v = + try Fof_parse.hhtop hhlex lexb + with Parsing.YYexit a -> Obj.magic a + in + prf (v :: acc) + with End_of_file -> close_in inc; acc + in + prf [] +;; + +let rec print_fof_term tm = + if Basics.is_forall tm then let (Fusion.Var(n,_),tm) = Basics.dest_forall tm in + (print_string "!["; print_string n; print_string "]:"; print_fof_term tm) else + if Basics.is_exists tm then let (Fusion.Var(n,_),tm) = Basics.dest_exists tm in + (print_string "?["; print_string n; print_string "]:"; print_fof_term tm) else + match tm with + Fusion.Comb (_, _) -> + begin match Basics.strip_comb tm with + (Fusion.Const (op, _), argh :: argt) -> + print_string (Hashtbl.find Fusion.hash_const_name op); print_string "("; print_fof_term argh; List.iter (fun i -> print_char ','; print_fof_term i) argt; print_char ')' + | (Fusion.Var (s, _), argh :: argt) -> + print_string s; print_string "("; print_fof_term argh; List.iter (fun i -> print_char ','; print_fof_term i) argt; print_char ')' + | _ -> failwith "print_fof_term" + end + | Fusion.Const (s, _) -> print_string (Hashtbl.find Fusion.hash_const_name s) + | Fusion.Var (s, _) -> print_string ("V" ^ s) +;; +} diff --git a/src/holyhammer/hh/fof_parse.mly b/src/holyhammer/hh/fof_parse.mly new file mode 100644 index 0000000000..f2906ff6bb --- /dev/null +++ b/src/holyhammer/hh/fof_parse.mly @@ -0,0 +1,69 @@ +%{ + open Fusion;; + open Bool;; + let ind_ty = Tyapp ("$i", []);; + let is_uppercase c = 'A' <= c.[0] && c.[0] <= 'Z';; + let domkconst name args rty = + if name = "$true" then Fusion.mk_const ("T", []) else + if name = "$false" then Fusion.mk_const ("F", []) else + let needty = List.fold_left (fun sofar _ -> mk_fun_ty ind_ty sofar) rty args in + (try + ignore (get_const_type name) + with Failure _ -> new_constant (name, needty)); + List.fold_left (fun sofar arg -> mk_comb (sofar, arg)) (mk_const (name, [])) args + ;; + let mk_indv s = mk_var (s, ind_ty);; + let quant q tm vars = List.fold_right (fun var tm -> (if q = "!" then mk_forall else mk_exists) (mk_indv var, tm)) vars tm;; + let mk_eq (a,b) = try mk_eq (a,b) with Failure _ -> mk_var ("fof_parse_error:eq", bool_ty);; + let mk_imp (a,b) = try mk_imp (a,b) with Failure _ -> mk_var ("fof_parse_error:imp", bool_ty);; + let mk_conj (a,b) = try mk_conj (a,b) with Failure _ -> mk_var ("fof_parse_error:conj", bool_ty);; + let mk_disj (a,b) = try Basics.mk_binary "\\/" (a,b) with Failure _ -> mk_var ("fof_parse_error:disj", bool_ty);; + let pnot = Hl_parser.parse_term "~";; + let mk_neg a = try Fusion.mk_comb (pnot, a) with Failure _ -> mk_var ("fof_parse_error:neg", bool_ty);; + let domkconst a b c = try domkconst a b c with Failure _ -> mk_var ("fof_parse_error:const", c);; + let quant a b c = try quant a b c with Failure _ -> mk_var ("fof_parse_error:quant", bool_ty);; +%} + +%token Word +%token All +%token Exists +%token Eof Openp Closep Dot Comma Eq Neq Tilde Eqvt Neqvt Impl And Or +%right Impl +%nonassoc Eqvt +%nonassoc Eq Neq +%right Or +%left And +%nonassoc Tilde +%nonassoc All Exists + +%start hhtop +%type <(string * string * string * term)> hhtop + +%% + +hhtop : + Word Openp Word Comma Word Comma formula Closep Dot { ($1, $3, $5, $7) } +| Eof { raise End_of_file }; + +formula : + Word { domkconst $1 [] bool_ty } +| Word Openp ts { domkconst $1 $3 bool_ty } +| fterm Eq fterm { mk_eq ($1, $3) } +| fterm Neq fterm { mk_neg (mk_eq ($1, $3)) } +| All formula { quant "!" $2 $1 } +| Exists formula { quant "?" $2 $1 } +| formula Eqvt formula { mk_eq ($1, $3) } +| formula Neqvt formula { mk_neg (mk_eq ($1, $3)) } +| formula Impl formula { mk_imp ($1, $3) } +| Tilde formula { mk_neg $2 } +| formula And formula { mk_conj ($1, $3) } +| formula Or formula { mk_disj ($1, $3) } +| Openp formula Closep { $2 } + +fterm : + Word { if is_uppercase $1 then mk_var ($1, ind_ty) else domkconst $1 [] ind_ty } +| Word Openp ts { domkconst $1 $3 ind_ty } + +ts : + fterm Comma ts { $1 :: $3 } +| fterm Closep { [$1] }; diff --git a/src/holyhammer/hh/hh1/Holmakefile b/src/holyhammer/hh/hh1/Holmakefile new file mode 100644 index 0000000000..23e3a4c684 --- /dev/null +++ b/src/holyhammer/hh/hh1/Holmakefile @@ -0,0 +1,47 @@ +FILES_CMX=lib.cmx fusion.cmx basics.cmx printer.cmx preterm.cmx hl_parser.cmx equal.cmx bool.cmx drule.cmx tactics.cmx simp.cmx theorems.cmx canon.cmx fol.cmx follist.cmx meson.cmx hh_symbols.cmx features_dt.cmx hh_tac.cmx hh_write.cmx + +all: $(FILES_CMX) + +lib.cmx: lib.ml + ocamlopt -c $< +fusion.cmx: fusion.ml + ocamlopt -c $< +basics.cmx: basics.ml + ocamlopt -c $< +printer.cmx: printer.ml + ocamlopt -c $< +preterm.cmx: preterm.ml + ocamlopt -c $< +hl_parser.cmx: hl_parser.ml + ocamlopt -c $< +equal.cmx: equal.ml + ocamlopt -c $< +bool.cmx: bool.ml + ocamlopt -c $< +drule.cmx: drule.ml + ocamlopt -c $< +tactics.cmx: tactics.ml + ocamlopt -c $< +simp.cmx: simp.ml + ocamlopt -c $< +theorems.cmx: theorems.ml + ocamlopt -c $< +canon.cmx: canon.ml + ocamlopt -c $< +fol.cmx: fol.ml + ocamlopt -c $< +follist.cmx: follist.ml + ocamlopt -c $< +meson.cmx: meson.ml + ocamlopt -c $< +hh_symbols.cmx: hh_symbols.ml + ocamlopt -c $< +features_dt.cmx: features_dt.ml + ocamlopt -c $< +hh_tac.cmx: hh_tac.ml + ocamlopt -c $< +hh_write.cmx: hh_write.ml + ocamlopt -c $< + +clean: + rm -f *cmx *cmi *.o diff --git a/src/holyhammer/hh/hh1/LICENSE b/src/holyhammer/hh/hh1/LICENSE new file mode 100644 index 0000000000..a6bdfdd6cc --- /dev/null +++ b/src/holyhammer/hh/hh1/LICENSE @@ -0,0 +1,33 @@ + HOL Light copyright notice, licence and disclaimer + + (c) University of Cambridge 1998 + (c) Copyright, John Harrison and others 1998-2012 + + Some files in this package are distributed under other licenses; + please check individual files or subdirectories for such cases. + + All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + o Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + o Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the + distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/src/holyhammer/hh/hh1/basics.ml b/src/holyhammer/hh/hh1/basics.ml new file mode 100644 index 0000000000..5a7b8f6a35 --- /dev/null +++ b/src/holyhammer/hh/hh1/basics.ml @@ -0,0 +1,384 @@ + + + + + + + + + +open Lib;; +open Fusion;; + + + + + +let genvar = + let gcounter = ref 0 in + fun ty -> let count = !gcounter in + (gcounter := count + 1; + mk_var("_"^(string_of_int count),ty));; + + + + + +let dest_fun_ty ty = + match ty with + Tyapp("fun",[ty1;ty2]) -> (ty1,ty2) + | _ -> failwith "dest_fun_ty";; + +let rec occurs_in ty bigty = + bigty = ty || + is_type bigty && exists (occurs_in ty) (snd(dest_type bigty));; + +let rec tysubst alist ty = + try rev_assoc ty alist with Failure _ -> + if is_vartype ty then ty else + let tycon,tyvars = dest_type ty in + mk_type(tycon,map (tysubst alist) tyvars);; + + + + + +let bndvar tm = + try fst(dest_abs tm) + with Failure _ -> failwith "bndvar: Not an abstraction";; + +let body tm = + try snd(dest_abs tm) + with Failure _ -> failwith "body: Not an abstraction";; + +let list_mk_comb(h,t) = rev_itlist (ccc (curry mk_comb)) t h;; + +let list_mk_abs(vs,bod) = itlist (curry mk_abs) vs bod;; + +let strip_comb = rev_splitlist dest_comb;; + +let strip_abs = splitlist dest_abs;; + + + + + + + +let is_binary s tm = + let s = try Hashtbl.find hash_name_const s with Not_found -> failwith "is_binary: nf "in + match tm with + Comb(Comb(Const(s',_),_),_) -> s' = s + | _ -> false;; + +let dest_binary s tm = + let s = try Hashtbl.find hash_name_const s with Not_found -> failwith "dest_binary: nf "in + match tm with + Comb(Comb(Const(s',_),l),r) when s' = s -> (l,r) + | _ -> failwith "dest_binary";; + +let mk_binary s = + let c = mk_const(s,[]) in + fun (l,r) -> try mk_comb(mk_comb(c,l),r) + with Failure _ -> failwith "mk_binary";; + + + + + +let rec variants av vs = + if vs = [] then [] else + let vh = variant av (hd vs) in vh::(variants (vh::av) (tl vs));; + + + + + +let variables = + let rec vars(acc,tm) = + if is_var tm then insert tm acc + else if is_const tm then acc + else if is_abs tm then + let v,bod = dest_abs tm in + vars(insert v acc,bod) + else + let l,r = dest_comb tm in + vars(vars(acc,l),r) in + fun tm -> vars([],tm);; + + + + + +let subst = + let rec ssubst ilist tm = + if ilist = [] then tm else + try fst (find (o (aconv tm) snd) ilist) with Failure _ -> + match tm with + Comb(f,x) -> let f' = ssubst ilist f and x' = ssubst ilist x in + if f' == f && x' == x then tm else mk_comb(f',x') + | Abs(v,bod) -> + let ilist' = filter (o not (o (vfree_in v) snd)) ilist in + mk_abs(v,ssubst ilist' bod) + | _ -> tm in + fun ilist -> + let theta = filter (fun (s,t) -> Pervasives.compare s t <> 0) ilist in + if theta = [] then (fun tm -> tm) else + let ts,xs = unzip theta in + fun tm -> + let gs = variants (variables tm) (map (o genvar type_of) xs) in + let tm' = ssubst (zip gs xs) tm in + if tm' == tm then tm else vsubst (zip ts gs) tm';; + + + + + +let alpha v tm = + let v0,bod = try dest_abs tm + with Failure _ -> failwith "alpha: Not an abstraction"in + if v = v0 then tm else + if type_of v = type_of v0 && not (vfree_in v bod) then + mk_abs(v,vsubst[v,v0]bod) + else failwith "alpha: Invalid new variable";; + + + + + +let rec type_match vty cty sofar = + if is_vartype vty then + try if rev_assoc vty sofar = cty then sofar else failwith "type_match" + with Failure "find" -> (cty,vty)::sofar + else + let vop,vargs = dest_type vty and cop,cargs = dest_type cty in + if vop = cop then itlist2 type_match vargs cargs sofar + else failwith "type_match";; + + + + + +let mk_mconst(c,ty) = + try let uty = get_const_type c in + let mat = type_match uty ty [] in + let con = mk_const(c,mat) in + if type_of con = ty then con else fail() + with Failure _ -> failwith "mk_const: generic type cannot be instantiated";; + + + + + +let mk_icomb(tm1,tm2) = + let "fun",[ty;_] = dest_type (type_of tm1) in + let tyins = type_match ty (type_of tm2) [] in + mk_comb(inst tyins tm1,tm2);; + + + + + +let list_mk_icomb cname args = + let atys,_ = nsplit dest_fun_ty args (get_const_type cname) in + let tyin = itlist2 (fun g a -> type_match g (type_of a)) atys args [] in + list_mk_comb(mk_const(cname,tyin),args);; + + + + + +let thm_frees th = + let asl,c = dest_thm th in + itlist (o union frees) asl (frees c);; + + + + + +let rec free_in tm1 tm2 = + if aconv tm1 tm2 then true + else if is_comb tm2 then + let l,r = dest_comb tm2 in free_in tm1 l || free_in tm1 r + else if is_abs tm2 then + let bv,bod = dest_abs tm2 in + not (vfree_in bv tm1) && free_in tm1 bod + else false;; + + + + + +let rec find_term p tm = + if p tm then tm else + if is_abs tm then find_term p (body tm) else + if is_comb tm then + let l,r = dest_comb tm in + try find_term p l with Failure _ -> find_term p r + else failwith "find_term";; + +let find_terms = + let rec accum tl p tm = + let tl' = if p tm then insert tm tl else tl in + if is_abs tm then + accum tl' p (body tm) + else if is_comb tm then + accum (accum tl' p (rator tm)) p (rand tm) + else tl' in + accum [];; + + + + + + + +let is_binder s tm = + let s = Hashtbl.find hash_name_const s in + match tm with + Comb(Const(s',_),Abs(_,_)) -> s' = s + | _ -> false;; + +let dest_binder s tm = + let s = Hashtbl.find hash_name_const s in + match tm with + Comb(Const(s',_),Abs(x,t)) when s' = s -> (x,t) + | _ -> failwith "dest_binder";; + +let mk_binder op = + let c = mk_const(op,[]) in + fun (v,tm) -> mk_comb(inst [type_of v,aty] c,mk_abs(v,tm));; + + + + + +let is_binop op tm = + match tm with + Comb(Comb(op',_),_) -> op' = op + | _ -> false;; + +let dest_binop op tm = + match tm with + Comb(Comb(op',l),r) when op' = op -> (l,r) + | _ -> failwith "dest_binop";; + +let mk_binop op tm1 = + let f = mk_comb(op,tm1) in + fun tm2 -> mk_comb(f,tm2);; + +let list_mk_binop op = end_itlist (mk_binop op);; + +let binops op = striplist (dest_binop op);; + + + + + +let is_conj = is_binary "/\\";; +let dest_conj = dest_binary "/\\";; +let conjuncts = striplist dest_conj;; + +let is_imp = is_binary "==>";; +let dest_imp = dest_binary "==>";; + +let is_forall = is_binder "!";; +let dest_forall = dest_binder "!";; +let strip_forall = splitlist dest_forall;; + +let is_exists = is_binder "?";; +let dest_exists = dest_binder "?";; +let strip_exists = splitlist dest_exists;; + +let is_disj = is_binary "\\/";; +let dest_disj = dest_binary "\\/";; +let disjuncts = striplist dest_disj;; + +let is_neg tm = + try fst(dest_const(rator tm)) = "~" + with Failure _ -> false;; + +let dest_neg tm = + try let n,p = dest_comb tm in + if fst(dest_const n) = "~" then p else fail() + with Failure _ -> failwith "dest_neg";; + +let is_uexists = is_binder "?!";; +let dest_uexists = dest_binder "?!";; + +let dest_cons = dest_binary "CONS";; +let is_cons = is_binary "CONS";; +let dest_list tm = + try let tms,nil = splitlist dest_cons tm in + if fst(dest_const nil) = "NIL" then tms else fail() + with Failure _ -> failwith "dest_list";; +let is_list = can dest_list;; + + + + + +open Num;; + +let dest_numeral = + let rec dest_num tm = + if try fst(dest_const tm) = "_0" with Failure _ -> false then num_0 else + let l,r = dest_comb tm in + let n = num_2 */ dest_num r in + let cn = fst(dest_const l) in + if cn = "BIT0" then n + else if cn = "BIT1" then n +/ num_1 + else fail() in + fun tm -> try let l,r = dest_comb tm in + if fst(dest_const l) = "NUMERAL" then dest_num r else fail() + with Failure _ -> failwith "dest_numeral";; + + + + + + + + + + +let dest_gabs = + let dest_geq = dest_binary "GEQ" in + fun tm -> + try if is_abs tm then dest_abs tm else + let l,r = dest_comb tm in + if not (fst(dest_const l) = "GABS") then fail() else + let ltm,rtm = dest_geq(snd(strip_forall(body r))) in + rand ltm,rtm + with Failure _ -> failwith "dest_gabs: Not a generalized abstraction";; + +let is_gabs = can dest_gabs;; + +let mk_gabs = + let mk_forall(v,t) = + let cop = mk_const("!",[type_of v,aty]) in + mk_comb(cop,mk_abs(v,t)) in + let list_mk_forall(vars,bod) = itlist (curry mk_forall) vars bod in + let mk_geq(t1,t2) = + let p = mk_const("GEQ",[type_of t1,aty]) in + mk_comb(mk_comb(p,t1),t2) in + fun (tm1,tm2) -> + if is_var tm1 then mk_abs(tm1,tm2) else + let fvs = frees tm1 in + let fty = mk_fun_ty (type_of tm1) (type_of tm2) in + let f = variant (frees tm1 @ frees tm2) (mk_var("f",fty)) in + let bod = mk_abs(f,list_mk_forall(fvs,mk_geq(mk_comb(f,tm1),tm2))) in + mk_comb(mk_const("GABS",[fty,aty]),bod);; + +let strip_gabs = splitlist dest_gabs;; + +let dest_let tm = + try let l,aargs = strip_comb tm in + if fst(dest_const l) <> "LET" then fail() else + let vars,lebod = strip_gabs (hd aargs) in + let eqs = zip vars (tl aargs) in + let le,bod = dest_comb lebod in + if fst(dest_const le) = "LET_END" then eqs,bod else fail() + with Failure _ -> failwith "dest_let: not a let-term";; + +let is_let = can dest_let;; diff --git a/src/holyhammer/hh/hh1/bool.ml b/src/holyhammer/hh/hh1/bool.ml new file mode 100644 index 0000000000..2ec92ff8a7 --- /dev/null +++ b/src/holyhammer/hh/hh1/bool.ml @@ -0,0 +1,313 @@ +open Printer;; +open Preterm;; +open Hl_parser;; +open Fusion;; +open Lib;; +open Equal;; +open Basics;; + +parse_as_prefix "~";; + +parse_as_binder "\\";; +parse_as_binder "!";; +parse_as_binder "?";; +parse_as_binder "?!";; + +parse_as_infix ("==>",(4,"right"));; +parse_as_infix ("\\/",(6,"right"));; +parse_as_infix ("/\\",(8,"right"));; + +parse_as_infix("<=>",(2,"right"));; +override_interface ("<=>",parse_term "(=):bool->bool->bool");; +parse_as_infix("=",(12,"right"));; + +let dest_iff tm = + match tm with + Comb(Comb(Const(0,Tyapp("fun",[Tyapp("bool",[]);_])),l),r) -> (l,r) + | _ -> failwith "dest_iff";; + +let pINST tyin tmin = + let iterm_fn = iNST (map (f_f iii (inst tyin)) tmin) + and itype_fn = iNST_TYPE tyin in + fun th -> try iterm_fn (itype_fn th) + with Failure _ -> failwith "PINST";; + + + + + +let pROVE_HYP ath bth = + if exists (aconv (concl ath)) (hyp bth) + then eQ_MP (dEDUCT_ANTISYM_RULE ath bth) ath + else bth;; + + + + + +let t_DEF = new_basic_definition + (parse_term "T = ((\\p:bool. p) = (\\p:bool. p))");; + +let tRUTH = eQ_MP (sYM t_DEF) (rEFL (parse_term "\\p:bool. p"));; + +let eQT_ELIM th = + try eQ_MP (sYM th) tRUTH + with Failure _ -> failwith "EQT_ELIM";; + +let eQT_INTRO = + let t = parse_term "t:bool" in + let pth = + let th1 = dEDUCT_ANTISYM_RULE (aSSUME t) tRUTH in + let th2 = eQT_ELIM(aSSUME(concl th1)) in + dEDUCT_ANTISYM_RULE th2 th1 in + fun th -> eQ_MP (iNST[concl th,t] pth) th;; + + + + + +let aND_DEF = new_basic_definition + (parse_term "(/\\) = \\p q. (\\f:bool->bool->bool. f p q) = (\\f. f T T)");; + +let mk_conj = mk_binary "/\\";; +let list_mk_conj = end_itlist (curry mk_conj);; + +let cONJ = + let f = parse_term "f:bool->bool->bool" + and p = parse_term "p:bool" + and q = parse_term "q:bool" in + let pth = + let pth = aSSUME p + and qth = aSSUME q in + let th1 = mK_COMB(aP_TERM f (eQT_INTRO pth),eQT_INTRO qth) in + let th2 = aBS f th1 in + let th3 = bETA_RULE (aP_THM (aP_THM aND_DEF p) q) in + eQ_MP (sYM th3) th2 in + fun th1 th2 -> + let th = iNST [concl th1,p; concl th2,q] pth in + pROVE_HYP th2 (pROVE_HYP th1 th);; + +let cONJUNCT1 = + let p = parse_term "P:bool" and q = parse_term "Q:bool" in + let pth = + let th1 = cONV_RULE (rAND_CONV bETA_CONV) (aP_THM aND_DEF (parse_term "P:bool")) in + let th2 = cONV_RULE (rAND_CONV bETA_CONV) (aP_THM th1 (parse_term "Q:bool")) in + let th3 = eQ_MP th2 (aSSUME (parse_term "P /\\ Q")) in + eQT_ELIM(bETA_RULE (aP_THM th3 (parse_term "\\(p:bool) (q:bool). p"))) in + fun th -> + try let l,r = dest_conj(concl th) in + pROVE_HYP th (iNST [l,p; r,q] pth) + with Failure _ -> failwith "CONJUNCT1";; + +let cONJUNCT2 = + let p = parse_term "P:bool" and q = parse_term "Q:bool" in + let pth = + let th1 = cONV_RULE (rAND_CONV bETA_CONV) (aP_THM aND_DEF (parse_term "P:bool")) in + let th2 = cONV_RULE (rAND_CONV bETA_CONV) (aP_THM th1 (parse_term "Q:bool")) in + let th3 = eQ_MP th2 (aSSUME (parse_term "P /\\ Q")) in + eQT_ELIM(bETA_RULE (aP_THM th3 (parse_term "\\(p:bool) (q:bool). q"))) in + fun th -> + try let l,r = dest_conj(concl th) in + pROVE_HYP th (iNST [l,p; r,q] pth) + with Failure _ -> failwith "CONJUNCT2";; + +let cONJ_PAIR th = + try cONJUNCT1 th,cONJUNCT2 th + with Failure _ -> failwith "CONJ_PAIR: not a conjunction";; + +let cONJUNCTS = striplist cONJ_PAIR;; + + + + + +let iMP_DEF = new_basic_definition + (parse_term "(==>) = \\p q. p /\\ q <=> p");; + +let mk_imp = mk_binary "==>";; + +let mP = + let p = parse_term "p:bool" + and q = parse_term "q:bool" in + let pth = + let th1 = bETA_RULE (aP_THM (aP_THM iMP_DEF p) q) in + let th2 = eQ_MP th1 (aSSUME (parse_term "p ==> q")) in + cONJUNCT2 (eQ_MP (sYM th2) (aSSUME p)) in + fun ith th -> + let ant,con = dest_imp (concl ith) in + if aconv ant (concl th) then + pROVE_HYP th (pROVE_HYP ith (iNST [ant,p; con,q] pth)) + else failwith "MP: theorems do not agree";; + +let dISCH = + let p = parse_term "p:bool" + and q = parse_term "q:bool" in + let pth = sYM(bETA_RULE (aP_THM (aP_THM iMP_DEF p) q)) in + fun a th -> + let th1 = cONJ (aSSUME a) th in + let th2 = cONJUNCT1 (aSSUME (concl th1)) in + let th3 = dEDUCT_ANTISYM_RULE th1 th2 in + let th4 = iNST [a,p; concl th,q] pth in + eQ_MP th4 th3;; + +let rec dISCH_ALL th = + try dISCH_ALL (dISCH (hd (hyp th)) th) + with Failure _ -> th;; + +let uNDISCH th = + try mP th (aSSUME(rand(rator(concl th)))) + with Failure _ -> failwith "UNDISCH";; + +let rec uNDISCH_ALL th = + if is_imp (concl th) then uNDISCH_ALL (uNDISCH th) + else th;; + +let iMP_ANTISYM_RULE th1 th2 = + dEDUCT_ANTISYM_RULE (uNDISCH th2) (uNDISCH th1);; + +let eQ_IMP_RULE = + let peq = parse_term "p <=> q" in + let p,q = dest_iff peq in + let pth1 = dISCH peq (dISCH p (eQ_MP (aSSUME peq) (aSSUME p))) + and pth2 = dISCH peq (dISCH q (eQ_MP (sYM(aSSUME peq)) (aSSUME q))) in + fun th -> let l,r = dest_iff(concl th) in + mP (iNST [l,p; r,q] pth1) th,mP (iNST [l,p; r,q] pth2) th;; + + + + + +let fORALL_DEF = new_basic_definition (parse_term "(!) = \\P:A->bool. P = \\x. T");; + +let mk_forall = mk_binder "!";; + +let sPEC = + let p = parse_term "P:A->bool" + and x = parse_term "x:A" in + let pth = + let th1 = eQ_MP(aP_THM fORALL_DEF p) (aSSUME (parse_term "(!)(P:A->bool)")) in + let th2 = aP_THM (cONV_RULE bETA_CONV th1) x in + let th3 = cONV_RULE (rAND_CONV bETA_CONV) th2 in + dISCH_ALL (eQT_ELIM th3) in + fun tm th -> + try let abs = rand(concl th) in + cONV_RULE bETA_CONV + (mP (pINST [snd(dest_var(bndvar abs)),aty] [abs,p; tm,x] pth) th) + with Failure _ -> failwith "SPEC";; + +let sPECL tms th = + try rev_itlist sPEC tms th + with Failure _ -> failwith "SPECL";; + +let sPEC_VAR th = + let bv = variant (thm_frees th) (bndvar(rand(concl th))) in + bv,sPEC bv th;; + +let rec sPEC_ALL th = + if is_forall(concl th) then sPEC_ALL(snd(sPEC_VAR th)) else th;; + +let gEN = + let pth = sYM(cONV_RULE (rAND_CONV bETA_CONV) + (aP_THM fORALL_DEF (parse_term "P:A->bool"))) in + fun x -> + let qth = iNST_TYPE[snd(dest_var x),aty] pth in + let ptm = rand(rand(concl qth)) in + fun th -> + let th' = aBS x (eQT_INTRO th) in + let phi = lhand(concl th') in + let rth = iNST[phi,ptm] qth in + eQ_MP rth th';; + +let gENL = itlist gEN;; + +let gEN_ALL th = + let asl,c = dest_thm th in + let vars = subtract (frees c) (freesl asl) in + gENL vars th;; + +let eXISTS_DEF = new_basic_definition + (parse_term "(?) = \\P:A->bool. !q. (!x. P x ==> q) ==> q");; + +let mk_exists = mk_binder "?";; + +let eXISTS = + let p = parse_term "P:A->bool" and x = parse_term "x:A" in + let pth = + let th1 = cONV_RULE (rAND_CONV bETA_CONV) (aP_THM eXISTS_DEF p) in + let th2 = sPEC x (aSSUME (parse_term "!x:A. P x ==> Q")) in + let th3 = dISCH (parse_term "!x:A. P x ==> Q") (mP th2 (aSSUME (parse_term "(P:A->bool) x"))) in + eQ_MP (sYM th1) (gEN (parse_term "Q:bool") th3) in + fun (etm,stm) th -> + try let qf,abs = dest_comb etm in + let bth = bETA_CONV(mk_comb(abs,stm)) in + let cth = pINST [type_of stm,aty] [abs,p; stm,x] pth in + pROVE_HYP (eQ_MP (sYM bth) th) cth + with Failure _ -> failwith "EXISTS";; + +let cHOOSE = + let p = parse_term "P:A->bool" and q = parse_term "Q:bool" in + let pth = + let th1 = cONV_RULE (rAND_CONV bETA_CONV) (aP_THM eXISTS_DEF p) in + let th2 = sPEC (parse_term "Q:bool") (uNDISCH(fst(eQ_IMP_RULE th1))) in + dISCH_ALL (dISCH (parse_term "(?) (P:A->bool)") (uNDISCH th2)) in + fun (v,th1) th2 -> + try let abs = rand(concl th1) in + let bv,bod = dest_abs abs in + let cmb = mk_comb(abs,v) in + let pat = vsubst[v,bv] bod in + let th3 = cONV_RULE bETA_CONV (aSSUME cmb) in + let th4 = gEN v (dISCH cmb (mP (dISCH pat th2) th3)) in + let th5 = pINST [snd(dest_var v),aty] [abs,p; concl th2,q] pth in + mP (mP th5 th4) th1 + with Failure _ -> failwith "CHOOSE";; + +let oR_DEF = new_basic_definition (parse_term "(\\/) = \\p q. !r. (p ==> r) ==> (q ==> r) ==> r");; + +let mk_disj = mk_binary "\\/";; +let list_mk_disj = end_itlist (curry mk_disj);; + +let f_DEF = new_basic_definition (parse_term "F = !p:bool. p");; +let nOT_DEF = new_basic_definition (parse_term "(~) = \\p. p ==> F");; + +let mk_neg = + let neg_tm = parse_term "(~)" in + fun tm -> try mk_comb(neg_tm,tm) + with Failure _ -> failwith "mk_neg";; + +let nOT_ELIM = + let p = parse_term "P:bool" in + let pth = cONV_RULE(rAND_CONV bETA_CONV) (aP_THM nOT_DEF p) in + fun th -> + try eQ_MP (iNST [rand(concl th),p] pth) th + with Failure _ -> failwith "NOT_ELIM";; + +let nOT_INTRO = + let p = parse_term "P:bool" in + let pth = sYM(cONV_RULE(rAND_CONV bETA_CONV) (aP_THM nOT_DEF p)) in + fun th -> + try eQ_MP (iNST [rand(rator(concl th)),p] pth) th + with Failure _ -> failwith "NOT_INTRO";; + +let eQF_INTRO = + let p = parse_term "P:bool" in + let pth = + let th1 = nOT_ELIM (aSSUME (parse_term "~ P")) + and th2 = dISCH (parse_term "F") (sPEC p (eQ_MP f_DEF (aSSUME (parse_term "F")))) in + dISCH_ALL (iMP_ANTISYM_RULE th1 th2) in + fun th -> + try mP (iNST [rand(concl th),p] pth) th + with Failure _ -> failwith "EQF_INTRO";; + +let eXISTS_UNIQUE_DEF = new_basic_definition + (parse_term "(?!) = \\P:A->bool. ((?) P) /\\ (!x y. P x /\\ P y ==> x = y)");; + +let cONTR = + let p = parse_term "P:bool" and f_tm = parse_term "F" in + let pth = sPEC p (eQ_MP f_DEF (aSSUME (parse_term "F"))) in + fun tm th -> + if concl th <> f_tm then failwith "CONTR" + else pROVE_HYP th (iNST [tm,p] pth);; + +let eXISTS_UNIQUE_THM = Sequent ([], parse_term "!P. (?!x:A. P x) <=> (?x. P x) /\\ (!x x'. P x /\\ P x' ==> (x = x'))");; +let fUN_EQ_THM = Sequent([],parse_term "!(f:A->B) g. f = g <=> (!x. f x = g x)");; +let bOOL_CASES_AX = Sequent([],parse_term "!t. (t <=> T) \\/ (t <=> F)");; diff --git a/src/holyhammer/hh/hh1/canon.ml b/src/holyhammer/hh/hh1/canon.ml new file mode 100644 index 0000000000..309c61c727 --- /dev/null +++ b/src/holyhammer/hh/hh1/canon.ml @@ -0,0 +1,412 @@ +open Lib;; +open Fusion;; +open Basics;; +open Hl_parser;; +open Equal;; +open Bool;; +open Drule;; +open Simp;; +open Theorems;; +open Tactics;; + +let cONJ_ACI_RULE = + let rec mk_fun th fn = + let tm = concl th in + if is_conj tm then + let th1,th2 = cONJ_PAIR th in + mk_fun th1 (mk_fun th2 fn) + else (tm |-> th) fn + and use_fun fn tm = + if is_conj tm then + let l,r = dest_conj tm in cONJ (use_fun fn l) (use_fun fn r) + else apply fn tm in + fun fm -> + let p,p' = dest_eq fm in + if p = p' then rEFL p else + let th = use_fun (mk_fun (aSSUME p) undefined) p' + and th' = use_fun (mk_fun (aSSUME p') undefined) p in + iMP_ANTISYM_RULE (dISCH_ALL th) (dISCH_ALL th');; + +let dISJ_ACI_RULE = + let pth_left = uNDISCH(Sequent ([],parse_term "~(a \\/ b) ==> ~a")) + and pth_right = uNDISCH(Sequent ([],parse_term "~(a \\/ b) ==> ~b")) + and pth = repeat uNDISCH (Sequent ([],parse_term "~a ==> ~b ==> ~(a \\/ b)")) + and pth_neg = uNDISCH(Sequent ([],parse_term "(~a <=> ~b) ==> (a <=> b)")) + and a_tm = parse_term "a:bool" and b_tm = parse_term "b:bool" in + let nOT_DISJ_PAIR th = + let p,q = dest_disj(rand(concl th)) in + let ilist = [p,a_tm; q,b_tm] in + pROVE_HYP th (iNST ilist pth_left), + pROVE_HYP th (iNST ilist pth_right) + and nOT_DISJ th1 th2 = + let th3 = iNST [rand(concl th1),a_tm; rand(concl th2),b_tm] pth in + pROVE_HYP th1 (pROVE_HYP th2 th3) in + let rec mk_fun th fn = + let tm = rand(concl th) in + if is_disj tm then + let th1,th2 = nOT_DISJ_PAIR th in + mk_fun th1 (mk_fun th2 fn) + else (tm |-> th) fn + and use_fun fn tm = + if is_disj tm then + let l,r = dest_disj tm in nOT_DISJ (use_fun fn l) (use_fun fn r) + else apply fn tm in + fun fm -> + let p,p' = dest_eq fm in + if p = p' then rEFL p else + let th = use_fun (mk_fun (aSSUME(mk_neg p)) undefined) p' + and th' = use_fun (mk_fun (aSSUME(mk_neg p')) undefined) p in + let th1 = iMP_ANTISYM_RULE (dISCH_ALL th) (dISCH_ALL th') in + pROVE_HYP th1 (iNST [p,a_tm; p',b_tm] pth_neg);; + +let cONJ_CANON_CONV tm = + let tm' = list_mk_conj(setify(conjuncts tm)) in + cONJ_ACI_RULE(mk_eq(tm,tm'));; + +let dISJ_CANON_CONV tm = + let tm' = list_mk_disj(setify(disjuncts tm)) in + dISJ_ACI_RULE(mk_eq(tm,tm'));; + +let (gEN_NNF_CONV:bool->conv*(term->thm*thm)->conv) = + let and_tm = parse_term "(/\\)" + and or_tm = parse_term "(\\/)" + and not_tm = parse_term "(~)" + and pth_not_not = Sequent([],parse_term "~ ~ p = p") + and pth_not_and = Sequent([],parse_term "~(p /\\ q) <=> ~p \\/ ~q") + and pth_not_or = Sequent([],parse_term "~(p \\/ q) <=> ~p /\\ ~q") + and pth_imp = Sequent([],parse_term "p ==> q <=> ~p \\/ q") + and pth_not_imp = Sequent([],parse_term "~(p ==> q) <=> p /\\ ~q") + and pth_eq = Sequent([],parse_term "(p <=> q) <=> p /\\ q \\/ ~p /\\ ~q") + and pth_not_eq = Sequent([],parse_term "~(p <=> q) <=> p /\\ ~q \\/ ~p /\\ q") + and pth_eq' = Sequent([],parse_term "(p <=> q) <=> (p \\/ ~q) /\\ (~p \\/ q)") + and pth_not_eq' = Sequent([],parse_term "~(p <=> q) <=> (p \\/ q) /\\ (~p \\/ ~q)") + and [pth_not_forall; pth_not_exists; pth_not_exu] = + (cONJUNCTS (Sequent ([], parse_term + "(~((!) P) <=> ?x:A. ~(P x)) /\\ + (~((?) P) <=> !x:A. ~(P x)) /\\ + (~((?!) P) <=> (!x:A. ~(P x)) \\/ ?x y. P x /\\ P y /\\ ~(y = x))"))) + and pth_exu = (Sequent ([], parse_term + "((?!) P) <=> (?x:A. P x) /\\ !x y. ~(P x) \\/ ~(P y) \\/ (y = x)")) + and p_tm = parse_term "p:bool" and q_tm = parse_term "q:bool" in + let rec nNF_DCONV cf baseconvs tm = + match tm with + Comb(Comb(Const(2,_),l),r) -> + let th_lp,th_ln = nNF_DCONV cf baseconvs l + and th_rp,th_rn = nNF_DCONV cf baseconvs r in + mK_COMB(aP_TERM and_tm th_lp,th_rp), + tRANS (iNST [l,p_tm; r,q_tm] pth_not_and) + (mK_COMB(aP_TERM or_tm th_ln,th_rn)) + | Comb(Comb(Const(6,_),l),r) -> + let th_lp,th_ln = nNF_DCONV cf baseconvs l + and th_rp,th_rn = nNF_DCONV cf baseconvs r in + mK_COMB(aP_TERM or_tm th_lp,th_rp), + tRANS (iNST [l,p_tm; r,q_tm] pth_not_or) + (mK_COMB(aP_TERM and_tm th_ln,th_rn)) + | Comb(Comb(Const(3,_),l),r) -> + let th_lp,th_ln = nNF_DCONV cf baseconvs l + and th_rp,th_rn = nNF_DCONV cf baseconvs r in + tRANS (iNST [l,p_tm; r,q_tm] pth_imp) + (mK_COMB(aP_TERM or_tm th_ln,th_rp)), + tRANS (iNST [l,p_tm; r,q_tm] pth_not_imp) + (mK_COMB(aP_TERM and_tm th_lp,th_rn)) + | Comb(Comb(Const(0,Tyapp("fun",Tyapp("bool",_)::_)),l),r) -> + let th_lp,th_ln = nNF_DCONV cf baseconvs l + and th_rp,th_rn = nNF_DCONV cf baseconvs r in + if cf then + tRANS (iNST [l,p_tm; r,q_tm] pth_eq') + (mK_COMB(aP_TERM and_tm (mK_COMB(aP_TERM or_tm th_lp,th_rn)), + mK_COMB(aP_TERM or_tm th_ln,th_rp))), + tRANS (iNST [l,p_tm; r,q_tm] pth_not_eq') + (mK_COMB(aP_TERM and_tm (mK_COMB(aP_TERM or_tm th_lp,th_rp)), + mK_COMB(aP_TERM or_tm th_ln,th_rn))) + else + tRANS (iNST [l,p_tm; r,q_tm] pth_eq) + (mK_COMB(aP_TERM or_tm (mK_COMB(aP_TERM and_tm th_lp,th_rp)), + mK_COMB(aP_TERM and_tm th_ln,th_rn))), + tRANS (iNST [l,p_tm; r,q_tm] pth_not_eq) + (mK_COMB(aP_TERM or_tm (mK_COMB(aP_TERM and_tm th_lp,th_rn)), + mK_COMB(aP_TERM and_tm th_ln,th_rp))) + | Comb(Const(4,Tyapp("fun",Tyapp("fun",ty::_)::_)) as q, + (Abs(x,t) as bod)) -> + let th_p,th_n = nNF_DCONV true baseconvs t in + aP_TERM q (aBS x th_p), + let th1 = iNST [bod,mk_var("P",mk_fun_ty ty bool_ty)] + (iNST_TYPE [ty,aty] pth_not_forall) + and th2 = tRANS (aP_TERM not_tm (bETA(mk_comb(bod,x)))) th_n in + tRANS th1 (mK_EXISTS x th2) + | Comb(Const(5,Tyapp("fun",Tyapp("fun",ty::_)::_)) as q, + (Abs(x,t) as bod)) -> + let th_p,th_n = nNF_DCONV cf baseconvs t in + aP_TERM q (aBS x th_p), + let th1 = iNST [bod,mk_var("P",mk_fun_ty ty bool_ty)] + (iNST_TYPE [ty,aty] pth_not_exists) + and th2 = tRANS (aP_TERM not_tm (bETA(mk_comb(bod,x)))) th_n in + tRANS th1 (mK_FORALL x th2) + | Comb(Const(9,Tyapp("fun",Tyapp("fun",ty::_)::_)), + (Abs(x,t) as bod)) -> + let y = variant (x::frees t) x + and th_p,th_n = nNF_DCONV cf baseconvs t in + let eq = mk_eq(y,x) in + let eth_p,eth_n = baseconvs eq + and bth = bETA (mk_comb(bod,x)) + and bth' = bETA_CONV(mk_comb(bod,y)) in + let th_p' = iNST [y,x] th_p and th_n' = iNST [y,x] th_n in + let th1 = iNST [bod,mk_var("P",mk_fun_ty ty bool_ty)] + (iNST_TYPE [ty,aty] pth_exu) + and th1' = iNST [bod,mk_var("P",mk_fun_ty ty bool_ty)] + (iNST_TYPE [ty,aty] pth_not_exu) + and th2 = + mK_COMB(aP_TERM and_tm + (mK_EXISTS x (tRANS bth th_p)), + mK_FORALL x (mK_FORALL y + (mK_COMB(aP_TERM or_tm (tRANS (aP_TERM not_tm bth) th_n), + mK_COMB(aP_TERM or_tm + (tRANS (aP_TERM not_tm bth') th_n'), + eth_p))))) + and th2' = + mK_COMB(aP_TERM or_tm + (mK_FORALL x (tRANS (aP_TERM not_tm bth) th_n)), + mK_EXISTS x (mK_EXISTS y + (mK_COMB(aP_TERM and_tm (tRANS bth th_p), + mK_COMB(aP_TERM and_tm (tRANS bth' th_p'), + eth_n))))) in + tRANS th1 th2,tRANS th1' th2' + | Comb(Const(8,_),t) -> + let th1,th2 = nNF_DCONV cf baseconvs t in + th2,tRANS (iNST [t,p_tm] pth_not_not) th1 + | _ -> try baseconvs tm + with Failure _ -> rEFL tm,rEFL(mk_neg tm) in + let rec nNF_CONV cf (base1,base2 as baseconvs) tm = + match tm with + Comb(Comb(Const(2,_),l),r) -> + let th_lp = nNF_CONV cf baseconvs l + and th_rp = nNF_CONV cf baseconvs r in + mK_COMB(aP_TERM and_tm th_lp,th_rp) + | Comb(Comb(Const(6,_),l),r) -> + let th_lp = nNF_CONV cf baseconvs l + and th_rp = nNF_CONV cf baseconvs r in + mK_COMB(aP_TERM or_tm th_lp,th_rp) + | Comb(Comb(Const(3,_),l),r) -> + let th_ln = nNF_CONV' cf baseconvs l + and th_rp = nNF_CONV cf baseconvs r in + tRANS (iNST [l,p_tm; r,q_tm] pth_imp) + (mK_COMB(aP_TERM or_tm th_ln,th_rp)) + | Comb(Comb(Const(0,Tyapp("fun",Tyapp("bool",_)::_)),l),r) -> + let th_lp,th_ln = nNF_DCONV cf base2 l + and th_rp,th_rn = nNF_DCONV cf base2 r in + if cf then + tRANS (iNST [l,p_tm; r,q_tm] pth_eq') + (mK_COMB(aP_TERM and_tm (mK_COMB(aP_TERM or_tm th_lp,th_rn)), + mK_COMB(aP_TERM or_tm th_ln,th_rp))) + else + tRANS (iNST [l,p_tm; r,q_tm] pth_eq) + (mK_COMB(aP_TERM or_tm (mK_COMB(aP_TERM and_tm th_lp,th_rp)), + mK_COMB(aP_TERM and_tm th_ln,th_rn))) + | Comb(Const(4,Tyapp("fun",Tyapp("fun",ty::_)::_)) as q, + (Abs(x,t))) -> + let th_p = nNF_CONV true baseconvs t in + aP_TERM q (aBS x th_p) + | Comb(Const(5,Tyapp("fun",Tyapp("fun",ty::_)::_)) as q, + (Abs(x,t))) -> + let th_p = nNF_CONV cf baseconvs t in + aP_TERM q (aBS x th_p) + | Comb(Const(9,Tyapp("fun",Tyapp("fun",ty::_)::_)), + (Abs(x,t) as bod)) -> + let y = variant (x::frees t) x + and th_p,th_n = nNF_DCONV cf base2 t in + let eq = mk_eq(y,x) in + let eth_p,eth_n = base2 eq + and bth = bETA (mk_comb(bod,x)) + and bth' = bETA_CONV(mk_comb(bod,y)) in + let th_n' = iNST [y,x] th_n in + let th1 = iNST [bod,mk_var("P",mk_fun_ty ty bool_ty)] + (iNST_TYPE [ty,aty] pth_exu) + and th2 = + mK_COMB(aP_TERM and_tm + (mK_EXISTS x (tRANS bth th_p)), + mK_FORALL x (mK_FORALL y + (mK_COMB(aP_TERM or_tm (tRANS (aP_TERM not_tm bth) th_n), + mK_COMB(aP_TERM or_tm + (tRANS (aP_TERM not_tm bth') th_n'), + eth_p))))) in + tRANS th1 th2 + | Comb(Const(8,_),t) -> nNF_CONV' cf baseconvs t + | _ -> try base1 tm with Failure _ -> rEFL tm + and nNF_CONV' cf (base1,base2 as baseconvs) tm = + match tm with + Comb(Comb(Const(2,_),l),r) -> + let th_ln = nNF_CONV' cf baseconvs l + and th_rn = nNF_CONV' cf baseconvs r in + tRANS (iNST [l,p_tm; r,q_tm] pth_not_and) + (mK_COMB(aP_TERM or_tm th_ln,th_rn)) + | Comb(Comb(Const(6,_),l),r) -> + let th_ln = nNF_CONV' cf baseconvs l + and th_rn = nNF_CONV' cf baseconvs r in + tRANS (iNST [l,p_tm; r,q_tm] pth_not_or) + (mK_COMB(aP_TERM and_tm th_ln,th_rn)) + | Comb(Comb(Const(3,_),l),r) -> + let th_lp = nNF_CONV cf baseconvs l + and th_rn = nNF_CONV' cf baseconvs r in + tRANS (iNST [l,p_tm; r,q_tm] pth_not_imp) + (mK_COMB(aP_TERM and_tm th_lp,th_rn)) + | Comb(Comb(Const(0,Tyapp("fun",Tyapp("bool",_)::_)),l),r) -> + let th_lp,th_ln = nNF_DCONV cf base2 l + and th_rp,th_rn = nNF_DCONV cf base2 r in + if cf then + tRANS (iNST [l,p_tm; r,q_tm] pth_not_eq') + (mK_COMB(aP_TERM and_tm (mK_COMB(aP_TERM or_tm th_lp,th_rp)), + mK_COMB(aP_TERM or_tm th_ln,th_rn))) + else + tRANS (iNST [l,p_tm; r,q_tm] pth_not_eq) + (mK_COMB(aP_TERM or_tm (mK_COMB(aP_TERM and_tm th_lp,th_rn)), + mK_COMB(aP_TERM and_tm th_ln,th_rp))) + | Comb(Const(4,Tyapp("fun",Tyapp("fun",ty::_)::_)), + (Abs(x,t) as bod)) -> + let th_n = nNF_CONV' cf baseconvs t in + let th1 = iNST [bod,mk_var("P",mk_fun_ty ty bool_ty)] + (iNST_TYPE [ty,aty] pth_not_forall) + and th2 = tRANS (aP_TERM not_tm (bETA(mk_comb(bod,x)))) th_n in + tRANS th1 (mK_EXISTS x th2) + | Comb(Const(5 ,Tyapp("fun",Tyapp("fun",ty::_)::_)), + (Abs(x,t) as bod)) -> + let th_n = nNF_CONV' true baseconvs t in + let th1 = iNST [bod,mk_var("P",mk_fun_ty ty bool_ty)] + (iNST_TYPE [ty,aty] pth_not_exists) + and th2 = tRANS (aP_TERM not_tm (bETA(mk_comb(bod,x)))) th_n in + tRANS th1 (mK_FORALL x th2) + | Comb(Const(9,Tyapp("fun",Tyapp("fun",ty::_)::_)), + (Abs(x,t) as bod)) -> + let y = variant (x::frees t) x + and th_p,th_n = nNF_DCONV cf base2 t in + let eq = mk_eq(y,x) in + let eth_p,eth_n = base2 eq + and bth = bETA (mk_comb(bod,x)) + and bth' = bETA_CONV(mk_comb(bod,y)) in + let th_p' = iNST [y,x] th_p in + let th1' = iNST [bod,mk_var("P",mk_fun_ty ty bool_ty)] + (iNST_TYPE [ty,aty] pth_not_exu) + and th2' = + mK_COMB(aP_TERM or_tm + (mK_FORALL x (tRANS (aP_TERM not_tm bth) th_n)), + mK_EXISTS x (mK_EXISTS y + (mK_COMB(aP_TERM and_tm (tRANS bth th_p), + mK_COMB(aP_TERM and_tm (tRANS bth' th_p'), + eth_n))))) in + tRANS th1' th2' + | Comb(Const(8,_),t) -> + let th1 = nNF_CONV cf baseconvs t in + tRANS (iNST [t,p_tm] pth_not_not) th1 + | _ -> let tm' = mk_neg tm in try base1 tm' with Failure _ -> rEFL tm' in + nNF_CONV;; + +let nNF_CONV = + (gEN_NNF_CONV false (aLL_CONV,fun t -> rEFL t,rEFL(mk_neg t)) :conv);; + +let nNFC_CONV = + (gEN_NNF_CONV true (aLL_CONV,fun t -> rEFL t,rEFL(mk_neg t)) :conv);; + +let sKOLEM_CONV = + tHENC + (gEN_REWRITE_CONV tOP_DEPTH_CONV + [eXISTS_OR_THM; lEFT_EXISTS_AND_THM; rIGHT_EXISTS_AND_THM; + fORALL_AND_THM; lEFT_FORALL_OR_THM; rIGHT_FORALL_OR_THM; + fORALL_SIMP; eXISTS_SIMP]) + (gEN_REWRITE_CONV rEDEPTH_CONV + [rIGHT_AND_EXISTS_THM; + lEFT_AND_EXISTS_THM; + oR_EXISTS_THM; + rIGHT_OR_EXISTS_THM; + lEFT_OR_EXISTS_THM; + sKOLEM_THM]);; + + +let pRENEX_CONV = + gEN_REWRITE_CONV rEDEPTH_CONV + [aND_FORALL_THM; lEFT_AND_FORALL_THM; rIGHT_AND_FORALL_THM; + lEFT_OR_FORALL_THM; rIGHT_OR_FORALL_THM; + oR_EXISTS_THM; lEFT_OR_EXISTS_THM; rIGHT_OR_EXISTS_THM; + lEFT_AND_EXISTS_THM; rIGHT_AND_EXISTS_THM];; + +let wEAK_DNF_CONV,dNF_CONV = + let pth1 = Sequent([], parse_term "a /\\ (b \\/ c) <=> a /\\ b \\/ a /\\ c") + and pth2 = Sequent([], parse_term "(a \\/ b) /\\ c <=> a /\\ c \\/ b /\\ c") + and a_tm = parse_term "a:bool" and b_tm = parse_term "b:bool" and c_tm = parse_term "c:bool" in + let rec distribute tm = + match tm with + Comb(Comb(Const(2,_),a),Comb(Comb(Const(6,_),b),c)) -> + let th = iNST [a,a_tm; b,b_tm; c,c_tm] pth1 in + tRANS th (bINOP_CONV distribute (rand(concl th))) + | Comb(Comb(Const(2,_),Comb(Comb(Const(6,_),a),b)),c) -> + let th = iNST [a,a_tm; b,b_tm; c,c_tm] pth2 in + tRANS th (bINOP_CONV distribute (rand(concl th))) + | _ -> rEFL tm in + let strengthen = + tHENC (dEPTH_BINOP_CONV (parse_term "(\\/)") cONJ_CANON_CONV) dISJ_CANON_CONV in + let rec weakdnf tm = + match tm with + Comb(Const(4,_),Abs(_,_)) + | Comb(Const(5,_),Abs(_,_)) -> bINDER_CONV weakdnf tm + | Comb(Comb(Const(6,_),_),_) -> bINOP_CONV weakdnf tm + | Comb(Comb(Const(2,_) as op,l),r) -> + let th = mK_COMB(aP_TERM op (weakdnf l),weakdnf r) in + tRANS th (distribute(rand(concl th))) + | _ -> rEFL tm + and substrongdnf tm = + match tm with + Comb(Const(4,_),Abs(_,_)) + | Comb(Const(5,_),Abs(_,_)) -> bINDER_CONV strongdnf tm + | Comb(Comb(Const(6,_),_),_) -> bINOP_CONV substrongdnf tm + | Comb(Comb(Const(2,_) as op,l),r) -> + let th = mK_COMB(aP_TERM op (substrongdnf l),substrongdnf r) in + tRANS th (distribute(rand(concl th))) + | _ -> rEFL tm + and strongdnf tm = + let th = substrongdnf tm in + tRANS th (strengthen(rand(concl th))) in + weakdnf,strongdnf;; + +let wEAK_CNF_CONV,cNF_CONV = + let pth1 = Sequent([], parse_term "a \\/ (b /\\ c) <=> (a \\/ b) /\\ (a \\/ c)") + and pth2 = Sequent([], parse_term "(a /\\ b) \\/ c <=> (a \\/ c) /\\ (b \\/ c)") + and a_tm = parse_term "a:bool" and b_tm = parse_term "b:bool" and c_tm = parse_term "c:bool" in + let rec distribute tm = + match tm with + Comb(Comb(Const(6,_),a),Comb(Comb(Const(2,_),b),c)) -> + let th = iNST [a,a_tm; b,b_tm; c,c_tm] pth1 in + tRANS th (bINOP_CONV distribute (rand(concl th))) + | Comb(Comb(Const(6,_),Comb(Comb(Const(2,_),a),b)),c) -> + let th = iNST [a,a_tm; b,b_tm; c,c_tm] pth2 in + tRANS th (bINOP_CONV distribute (rand(concl th))) + | _ -> rEFL tm in + let strengthen = + tHENC (dEPTH_BINOP_CONV (parse_term "(/\\)") dISJ_CANON_CONV) cONJ_CANON_CONV in + let rec weakcnf tm = + match tm with + Comb(Const(4,_),Abs(_,_)) + | Comb(Const(5,_),Abs(_,_)) -> bINDER_CONV weakcnf tm + | Comb(Comb(Const(2,_),_),_) -> bINOP_CONV weakcnf tm + | Comb(Comb(Const(6,_) as op,l),r) -> + let th = mK_COMB(aP_TERM op (weakcnf l),weakcnf r) in + tRANS th (distribute(rand(concl th))) + | _ -> rEFL tm + and substrongcnf tm = + match tm with + Comb(Const(4,_),Abs(_,_)) + | Comb(Const(5,_),Abs(_,_)) -> bINDER_CONV strongcnf tm + | Comb(Comb(Const(2,_),_),_) -> bINOP_CONV substrongcnf tm + | Comb(Comb(Const(6,_) as op,l),r) -> + let th = mK_COMB(aP_TERM op (substrongcnf l),substrongcnf r) in + tRANS th (distribute(rand(concl th))) + | _ -> rEFL tm + and strongcnf tm = + let th = substrongcnf tm in + tRANS th (strengthen(rand(concl th))) in + weakcnf,strongcnf;; + +let rEFUTE_THEN = + let f_tm = parse_term "F" + and conv = Simp.rEWR_CONV (Sequent ([], parse_term "p <=> ~p ==> F")) in + fun ttac (asl,w as gl) -> + if w = f_tm then aLL_TAC gl + else if is_neg w then dISCH_THEN ttac gl + else (cONV_TAC conv ++++ dISCH_THEN ttac) gl;; diff --git a/src/holyhammer/hh/hh1/drule.ml b/src/holyhammer/hh/hh1/drule.ml new file mode 100644 index 0000000000..d9b12446d9 --- /dev/null +++ b/src/holyhammer/hh/hh1/drule.ml @@ -0,0 +1,314 @@ +open Bool;; +open Fusion;; +open Lib;; +open Hl_parser;; +open Equal;; +open Basics;; +(*open Nets;;*) + +let mK_FORALL = + let atm = mk_const("!",[]) in + fun v th -> aP_TERM (inst [type_of v,aty] atm) (aBS v th);; + +let mK_EXISTS = + let atm = mk_const("?",[]) in + fun v th -> aP_TERM (inst [type_of v,aty] atm) (aBS v th);; + +type instantiation = + (int * term) list * (term * term) list * (hol_type * hol_type) list;; + + +let (instantiate :instantiation->term->term) = + let betas n tm = + let args,lam = funpow n (fun (l,t) -> (rand t)::l,rator t) ([],tm) in + rev_itlist (fun a l -> let v,b = dest_abs l in vsubst[a,v] b) args lam in + let rec ho_betas bcs pat tm = + if is_var pat or is_const pat then fail() else + try let bv,bod = dest_abs tm in + mk_abs(bv,ho_betas bcs (body pat) bod) + with Failure _ -> + let hop,args = strip_comb pat in + try let n = rev_assoc hop bcs in + if length args = n then betas n tm else fail() + with Failure _ -> + let lpat,rpat = dest_comb pat in + let ltm,rtm = dest_comb tm in + try let lth = ho_betas bcs lpat ltm in + try let rth = ho_betas bcs rpat rtm in + mk_comb(lth,rth) + with Failure _ -> + mk_comb(lth,rtm) + with Failure _ -> + let rth = ho_betas bcs rpat rtm in + mk_comb(ltm,rth) in + fun (bcs,tmin,tyin) tm -> + let itm = if tyin = [] then tm else inst tyin tm in + if tmin = [] then itm else + let ttm = vsubst tmin itm in + if bcs = [] then ttm else + try ho_betas bcs itm ttm with Failure _ -> ttm;; + +let (iNSTANTIATE : instantiation->thm->thm) = + let rec bETAS_CONV n tm = + if n = 1 then tRY_CONV bETA_CONV tm else + (tHENC (rATOR_CONV (bETAS_CONV (n-1))) (tRY_CONV bETA_CONV)) tm in + let rec hO_BETAS bcs pat tm = + if is_var pat or is_const pat then fail() else + try let bv,bod = dest_abs tm in + aBS bv (hO_BETAS bcs (body pat) bod) + with Failure _ -> + let hop,args = strip_comb pat in + try let n = rev_assoc hop bcs in + if length args = n then bETAS_CONV n tm else fail() + with Failure _ -> + let lpat,rpat = dest_comb pat in + let ltm,rtm = dest_comb tm in + try let lth = hO_BETAS bcs lpat ltm in + try let rth = hO_BETAS bcs rpat rtm in + mK_COMB(lth,rth) + with Failure _ -> + aP_THM lth rtm + with Failure _ -> + let rth = hO_BETAS bcs rpat rtm in + aP_TERM ltm rth in + fun (bcs,tmin,tyin) th -> + let ith = if tyin = [] then th else iNST_TYPE tyin th in + if tmin = [] then ith else + let tth = iNST tmin ith in + if hyp tth = hyp th then + if bcs = [] then tth else + try let eth = hO_BETAS bcs (concl ith) (concl tth) in + eQ_MP eth tth + with Failure _ -> tth + else failwith "INSTANTIATE: term or type var free in assumptions";; + +let (iNSTANTIATE_ALL : instantiation->thm->thm) = + fun ((_,tmin,tyin) as i) th -> + if tmin = [] & tyin = [] then th else + let hyps = hyp th in + if hyps = [] then iNSTANTIATE i th else + let tyrel,tyiirel = + if tyin = [] then [],hyps else + let tvs = itlist (o union (o tyvars snd)) tyin [] in + partition (fun tm -> let tvs' = type_vars_in_term tm in + not(intersect tvs tvs' = [])) hyps in + let tmrel,tmirrel = + if tmin = [] then [],tyiirel else + let vs = itlist (o union (o frees snd)) tmin [] in + partition (fun tm -> let vs' = frees tm in + not (intersect vs vs' = [])) tyiirel in + let rhyps = union tyrel tmrel in + let th1 = rev_itlist dISCH rhyps th in + let th2 = iNSTANTIATE i th1 in + funpow (length rhyps) uNDISCH th2;; + + + + + + + + + + +let (term_match:term list -> term -> term -> instantiation) = + let safe_inserta ((y,x) as n) l = + try let z = rev_assoc x l in + if aconv y z then l else failwith "safe_inserta" + with Failure "find" -> n::l in + + let safe_insert ((y,x) as n) l = + try let z = rev_assoc x l in + if Pervasives.compare y z = 0 then l else failwith "safe_insert" + with Failure "find" -> n::l in + + let mk_dummy = + let name = fst(dest_var(genvar aty)) in + fun ty -> mk_var(name,ty) in + + let rec term_pmatch lconsts env vtm ctm ((insts,homs) as sofar) = + match (vtm,ctm) with + Var(_,_),_ -> + (try let ctm' = rev_assoc vtm env in + if Pervasives.compare ctm' ctm = 0 then sofar + else failwith "term_pmatch" + with Failure "find" -> + if mem vtm lconsts then + if Pervasives.compare ctm vtm = 0 then sofar + else failwith "term_pmatch: can't instantiate local constant" + else safe_inserta (ctm,vtm) insts,homs) + | Const(vname,vty),Const(cname,cty) -> + if Pervasives.compare vname cname = 0 then + if Pervasives.compare vty cty = 0 then sofar + else safe_insert (mk_dummy cty,mk_dummy vty) insts,homs + else failwith "term_pmatch" + | Abs(vv,vbod),Abs(cv,cbod) -> + let sofar' = safe_insert + (mk_dummy(snd(dest_var cv)),mk_dummy(snd(dest_var vv))) insts,homs in + term_pmatch lconsts ((cv,vv)::env) vbod cbod sofar' + | _ -> + let vhop = repeat rator vtm in + if is_var vhop & not (mem vhop lconsts) & + not (can (rev_assoc vhop) env) then + let vty = type_of vtm and cty = type_of ctm in + let insts' = + if Pervasives.compare vty cty = 0 then insts + else safe_insert (mk_dummy cty,mk_dummy vty) insts in + (insts',(env,ctm,vtm)::homs) + else + let lv,rv = dest_comb vtm + and lc,rc = dest_comb ctm in + let sofar' = term_pmatch lconsts env lv lc sofar in + term_pmatch lconsts env rv rc sofar' in + + let get_type_insts insts = + itlist (fun (t,x) -> type_match (snd(dest_var x)) (type_of t)) insts in + + let separate_insts insts = + let realinsts,patterns = partition (o is_var snd) insts in + let betacounts = + if patterns = [] then [] else + itlist + (fun (_,p) sof -> + let hop,args = strip_comb p in + try safe_insert (length args,hop) sof with Failure _ -> + (warn true "Inconsistent patterning in higher order match"; sof)) + patterns [] in + let tyins = get_type_insts realinsts [] in + betacounts, + mapfilter (fun (t,x) -> + let x' = let xn,xty = dest_var x in + mk_var(xn,type_subst tyins xty) in + if Pervasives.compare t x' = 0 then fail() else (t,x')) realinsts, + tyins in + + let rec term_homatch lconsts tyins (insts,homs) = + if homs = [] then insts else + let (env,ctm,vtm) = hd homs in + if is_var vtm then + if Pervasives.compare ctm vtm = 0 + then term_homatch lconsts tyins (insts,tl homs) else + let newtyins = safe_insert (type_of ctm,snd(dest_var vtm)) tyins + and newinsts = (ctm,vtm)::insts in + term_homatch lconsts newtyins (newinsts,tl homs) else + let vhop,vargs = strip_comb vtm in + let afvs = freesl vargs in + let inst_fn = inst tyins in + try let tmins = map + (fun a -> (try rev_assoc a env with Failure _ -> try + rev_assoc a insts with Failure _ -> + if mem a lconsts then a else fail()), + inst_fn a) afvs in + let pats0 = map inst_fn vargs in + let pats = map (vsubst tmins) pats0 in + let vhop' = inst_fn vhop in + let ni = + let chop,cargs = strip_comb ctm in + if Pervasives.compare cargs pats = 0 then + if Pervasives.compare chop vhop = 0 + then insts else safe_inserta (chop,vhop) insts else + let ginsts = map + (fun p -> (if is_var p then p else genvar(type_of p)),p) pats in + let ctm' = subst ginsts ctm + and gvs = map fst ginsts in + let abstm = list_mk_abs(gvs,ctm') in + let vinsts = safe_inserta (abstm,vhop) insts in + let icpair = ctm',list_mk_comb(vhop',gvs) in + icpair::vinsts in + term_homatch lconsts tyins (ni,tl homs) + with Failure _ -> + let lc,rc = dest_comb ctm + and lv,rv = dest_comb vtm in + let pinsts_homs' = + term_pmatch lconsts env rv rc (insts,(env,lc,lv)::(tl homs)) in + let tyins' = get_type_insts (fst pinsts_homs') [] in + term_homatch lconsts tyins' pinsts_homs' in + + fun lconsts vtm ctm -> + let pinsts_homs = term_pmatch lconsts [] vtm ctm ([],[]) in + let tyins = get_type_insts (fst pinsts_homs) [] in + let insts = term_homatch lconsts tyins pinsts_homs in + separate_insts insts;; + + + + + + +let deep_alpha = + let tryalpha v tm = + try alpha v tm + with Failure _ -> try + let v' = variant (frees tm) v in + alpha v' tm + with Failure _ -> tm in + let rec deep_alpha env tm = + if env = [] then tm else + try let v,bod = dest_abs tm in + let vn,vty = dest_var v in + try let (vn',_),newenv = remove (fun (_,x) -> x = vn) env in + let v' = mk_var(vn',vty) in + let tm' = tryalpha v' tm in + let iv,ib = dest_abs tm' in + mk_abs(iv,deep_alpha newenv ib) + with Failure _ -> mk_abs(v,deep_alpha env bod) + with Failure _ -> try + let l,r = dest_comb tm in + mk_comb(deep_alpha env l,deep_alpha env r) + with Failure _ -> tm in + deep_alpha;; + + + + + + +let pART_MATCH = + let rec match_bvs t1 t2 acc = + try let v1,b1 = dest_abs t1 + and v2,b2 = dest_abs t2 in + let n1 = fst(dest_var v1) and n2 = fst(dest_var v2) in + let newacc = if n1 = n2 then acc else insert (n1,n2) acc in + match_bvs b1 b2 newacc + with Failure _ -> try + let l1,r1 = dest_comb t1 + and l2,r2 = dest_comb t2 in + match_bvs l1 l2 (match_bvs r1 r2 acc) + with Failure _ -> acc in + let pART_MATCH partfn th = + let sth = sPEC_ALL th in + let bod = concl sth in + let pbod = partfn bod in + let lconsts = intersect (frees (concl th)) (freesl(hyp th)) in + fun tm -> + let bvms = match_bvs tm pbod [] in + let abod = deep_alpha bvms bod in + let ath = eQ_MP (aLPHA bod abod) sth in + let insts = term_match lconsts (partfn abod) tm in + let fth = iNSTANTIATE insts ath in + if hyp fth <> hyp ath then failwith "PART_MATCH: instantiated hyps" else + let tm' = partfn (concl fth) in + if Pervasives.compare tm' tm = 0 then fth else + try sUBS[aLPHA tm' tm] fth + with Failure _ -> failwith "PART_MATCH: Sanity check failure" + in pART_MATCH;; + + + + + +let mATCH_MP ith = + let sth = + try let tm = concl ith in + let avs,bod = strip_forall tm in + let ant,con = dest_imp bod in + let svs,pvs = partition (ccc vfree_in ant) avs in + if pvs = [] then ith else + let th1 = sPECL avs (aSSUME tm) in + let th2 = gENL svs (dISCH ant (gENL pvs (uNDISCH th1))) in + mP (dISCH tm th2) ith + with Failure _ -> failwith "MATCH_MP: Not an implication" in + let match_fun = pART_MATCH (o fst dest_imp) sth in + fun th -> try mP (match_fun (concl th)) th + with Failure _ -> failwith "MATCH_MP: No match";; + diff --git a/src/holyhammer/hh/hh1/equal.ml b/src/holyhammer/hh/hh1/equal.ml new file mode 100644 index 0000000000..5f69a3f22e --- /dev/null +++ b/src/holyhammer/hh/hh1/equal.ml @@ -0,0 +1,318 @@ + + + + + + + + + + +open Lib;; +open Fusion;; +open Preterm;; +open Basics;; +(*open Nets;;*) + + + + + + +type conv = term->thm;; + + + + + +let lhand = o rand rator;; + +let lhs = o fst dest_eq;; + +let rhs = o snd dest_eq;; + + + + + +let mk_primed_var = + let rec svariant avoid s = + if mem s avoid || (can get_const_type s && not(is_hidden s)) then + svariant avoid (s^"'") + else s in + fun avoid v -> + let s,ty = dest_var v in + let s' = svariant (mapfilter (o fst dest_var) avoid) s in + mk_var(s',ty);; + + + + + +let bETA_CONV tm = + try bETA tm with Failure _ -> + try let f,arg = dest_comb tm in + let v = bndvar f in + iNST [arg,v] (bETA (mk_comb(f,v))) + with Failure _ -> failwith "BETA_CONV: Not a beta-redex";; + + + + + +let aP_TERM tm th = + try mK_COMB(rEFL tm,th) + with Failure _ -> failwith "AP_TERM";; + +let aP_THM th tm = + try mK_COMB(th,rEFL tm) + with Failure _ -> failwith "AP_THM";; + +let sYM th = + let tm = concl th in + let l,r = dest_eq tm in + let lth = rEFL l in + eQ_MP (mK_COMB(aP_TERM (rator (rator tm)) th,lth)) lth;; + +let aLPHA tm1 tm2 = + try tRANS (rEFL tm1) (rEFL tm2) + with Failure _ -> failwith "ALPHA";; + +let aLPHA_CONV v tm = + let res = alpha v tm in + aLPHA tm res;; + +let gEN_ALPHA_CONV v tm = + if is_abs tm then aLPHA_CONV v tm else + let b,abs = dest_comb tm in + aP_TERM b (aLPHA_CONV v abs);; + +let mK_BINOP op (lth,rth) = + mK_COMB(aP_TERM op lth,rth);; + + + + + +let (nO_CONV:conv) = fun tm -> failwith "NO_CONV";; + +let (aLL_CONV:conv) = rEFL;; + + + + + +let ((tHENC):conv -> conv -> conv) = + fun conv1 conv2 t -> + let th1 = conv1 t in + let th2 = conv2 (rand(concl th1)) in + tRANS th1 th2;; + +let ((oRELSEC):conv -> conv -> conv) = + fun conv1 conv2 t -> + try conv1 t with Failure _ -> conv2 t;; + +let (fIRST_CONV:conv list -> conv) = end_itlist (fun c1 c2 -> oRELSEC c1 c2);; + +let (eVERY_CONV:conv list -> conv) = + fun l -> itlist (fun c1 c2 -> tHENC c1 c2) l aLL_CONV;; + +let rEPEATC = + let rec rEPEATC conv t = + (oRELSEC (tHENC conv (rEPEATC conv)) aLL_CONV) t in + (rEPEATC:conv->conv);; + +let (cHANGED_CONV:conv->conv) = + fun conv tm -> + let th = conv tm in + let l,r = dest_eq (concl th) in + if aconv l r then failwith "CHANGED_CONV" else th;; + +let tRY_CONV conv = oRELSEC conv aLL_CONV;; + + + + + +let (rATOR_CONV:conv->conv) = + fun conv tm -> + let l,r = dest_comb tm in aP_THM (conv l) r;; + +let (rAND_CONV:conv->conv) = + fun conv tm -> + let l,r = dest_comb tm in aP_TERM l (conv r);; + +let lAND_CONV = o rATOR_CONV rAND_CONV;; + +let (cOMB2_CONV: conv->conv->conv) = + fun lconv rconv tm -> let l,r = dest_comb tm in mK_COMB(lconv l,rconv r);; + +let cOMB_CONV = www cOMB2_CONV;; + +let (aBS_CONV:conv->conv) = + fun conv tm -> + let v,bod = dest_abs tm in + let th = conv bod in + try aBS v th with Failure _ -> + let gv = genvar(type_of v) in + let gbod = vsubst[gv,v] bod in + let gth = aBS gv (conv gbod) in + let gtm = concl gth in + let l,r = dest_eq gtm in + let v' = variant (frees gtm) v in + let l' = alpha v' l and r' = alpha v' r in + eQ_MP (aLPHA gtm (mk_eq(l',r'))) gth;; + +let bINDER_CONV conv tm = + if is_abs tm then aBS_CONV conv tm + else rAND_CONV(aBS_CONV conv) tm;; + +let sUB_CONV conv tm = + match tm with + Comb(_,_) -> cOMB_CONV conv tm + | Abs(_,_) -> aBS_CONV conv tm + | _ -> rEFL tm;; + +let bINOP_CONV conv tm = + let lop,r = dest_comb tm in + let op,l = dest_comb lop in + mK_COMB(aP_TERM op (conv l),conv r);; + + + + + + +let (oNCE_DEPTH_CONV: conv->conv), + (dEPTH_CONV: conv->conv), + (rEDEPTH_CONV: conv->conv), + (tOP_DEPTH_CONV: conv->conv), + (tOP_SWEEP_CONV: conv->conv) = + let tHENQC conv1 conv2 tm = + try let th1 = conv1 tm in + try let th2 = conv2(rand(concl th1)) in tRANS th1 th2 + with Failure _ -> th1 + with Failure _ -> conv2 tm + and tHENCQC conv1 conv2 tm = + let th1 = conv1 tm in + try let th2 = conv2(rand(concl th1)) in tRANS th1 th2 + with Failure _ -> th1 + and cOMB_QCONV conv tm = + let l,r = dest_comb tm in + try let th1 = conv l in + try let th2 = conv r in mK_COMB(th1,th2) + with Failure _ -> aP_THM th1 r + with Failure _ -> aP_TERM l (conv r) in + let rec rEPEATQC conv tm = tHENCQC conv (rEPEATQC conv) tm in + let sUB_QCONV conv tm = + if is_abs tm then aBS_CONV conv tm + else cOMB_QCONV conv tm in + let rec oNCE_DEPTH_QCONV conv tm = + (oRELSEC conv (sUB_QCONV (oNCE_DEPTH_QCONV conv))) tm + and dEPTH_QCONV conv tm = + tHENQC (sUB_QCONV (dEPTH_QCONV conv)) + (rEPEATQC conv) tm + and rEDEPTH_QCONV conv tm = + tHENQC (sUB_QCONV (rEDEPTH_QCONV conv)) + (tHENCQC conv (rEDEPTH_QCONV conv)) tm + and tOP_DEPTH_QCONV conv tm = + tHENQC (rEPEATQC conv) + (tHENCQC (sUB_QCONV (tOP_DEPTH_QCONV conv)) + (tHENCQC conv (tOP_DEPTH_QCONV conv))) tm + and tOP_SWEEP_QCONV conv tm = + tHENQC (rEPEATQC conv) + (sUB_QCONV (tOP_SWEEP_QCONV conv)) tm in + (fun c -> tRY_CONV (oNCE_DEPTH_QCONV c)), + (fun c -> tRY_CONV (dEPTH_QCONV c)), + (fun c -> tRY_CONV (rEDEPTH_QCONV c)), + (fun c -> tRY_CONV (tOP_DEPTH_QCONV c)), + (fun c -> tRY_CONV (tOP_SWEEP_QCONV c));; + + + + + +let rec dEPTH_BINOP_CONV op conv tm = + match tm with + Comb(Comb(op',l),r) when op' = op -> + let l,r = dest_binop op tm in + let lth = dEPTH_BINOP_CONV op conv l + and rth = dEPTH_BINOP_CONV op conv r in + mK_COMB(aP_TERM op' lth,rth) + | _ -> conv tm;; + + + + + +let pATH_CONV = + let rec path_conv s cnv = + match s with + [] -> cnv + | "l"::t -> rATOR_CONV (path_conv t cnv) + | "r"::t -> rAND_CONV (path_conv t cnv) + | _::t -> aBS_CONV (path_conv t cnv) in + fun s cnv -> path_conv (explode s) cnv;; + + + + + +let pAT_CONV = + let rec pCONV xs pat conv = + if mem pat xs then conv + else if not(exists (fun x -> free_in x pat) xs) then aLL_CONV + else if is_comb pat then + cOMB2_CONV (pCONV xs (rator pat) conv) (pCONV xs (rand pat) conv) + else + aBS_CONV (pCONV xs (body pat) conv) in + fun pat -> let xs,pbod = strip_abs pat in pCONV xs pbod;; + + + + + +let sYM_CONV tm = + try let th1 = sYM(aSSUME tm) in + let tm' = concl th1 in + let th2 = sYM(aSSUME tm') in + dEDUCT_ANTISYM_RULE th2 th1 + with Failure _ -> failwith "SYM_CONV";; + + + + + +let cONV_RULE (conv:conv) th = + eQ_MP (conv(concl th)) th;; + + + + + +let sUBS_CONV ths tm = + try if ths = [] then rEFL tm else + let lefts = map (o lhand concl) ths in + let gvs = map (o genvar type_of) lefts in + let pat = subst (zip gvs lefts) tm in + let abs = list_mk_abs(gvs,pat) in + let th = rev_itlist + (fun y x -> cONV_RULE (tHENC (rAND_CONV bETA_CONV) (lAND_CONV bETA_CONV)) + (mK_COMB(x,y))) ths (rEFL abs) in + if rand(concl th) = tm then rEFL tm else th + with Failure _ -> failwith "SUBS_CONV";; + + + + + +let bETA_RULE = cONV_RULE(rEDEPTH_CONV bETA_CONV);; + +let gSYM = cONV_RULE(oNCE_DEPTH_CONV sYM_CONV);; + +let sUBS ths = cONV_RULE (sUBS_CONV ths);; + + + + + diff --git a/src/holyhammer/hh/hh1/features_dt.ml b/src/holyhammer/hh/hh1/features_dt.ml new file mode 100644 index 0000000000..7ffaa19a3d --- /dev/null +++ b/src/holyhammer/hh/hh1/features_dt.ml @@ -0,0 +1,235 @@ +(* This module defines Discrimination-Tree based features. + The implementation bases on the HOL Light Nets module. *) + +open Lib;; +open Basics;; +open Fusion;; + +type term_label = Vnet (* variable (instantiable) *) + | Lcnet of (string * int) (* local constant *) + | Cnet of (int * int) (* constant *) + | Lnet of int;; (* lambda term (abstraction) *) +module Tlm = Map.Make(struct type t = term_label let compare = compare end);; + +type 'a net = Netnode of ('a net) Tlm.t * 'a list;; + +let empty_net2 = Netnode (Tlm.empty,[]);; + +let num = ref 0;; +let next () = num := !num + 1; !num;; + +let enter2 = + let label_to_store tm = + let op,args = strip_comb tm in + match op with + Const (n, _) -> Cnet(n,List.length args),args + | Abs (bv, bod) -> Lnet(List.length args),bod::args + | _ -> Vnet,[] in + let rec sinsert x l = if l = [] then [x] else raise Exit in + let rec net_update (elem,tms,Netnode(edges,tips)) = + match tms with + [] -> Netnode(edges,sinsert elem tips) + | (tm::rtms) -> + let label,ntms = label_to_store tm in + let child,others = + try let ch = Tlm.find label edges + in (ch, Tlm.remove label edges) + with Not_found -> (empty_net2, edges) in + let new_child = net_update (elem,ntms@rtms,child) in + let others = Tlm.add label new_child others in + Netnode (others,tips) in + fun tm net -> net_update (tm,[tm],net);; + +(* ------------------------------------------------------------------------- *) +(* Look up a term in a net and return possible matches. *) +(* ------------------------------------------------------------------------- *) + +let lookup2 hash = + let label_for_lookup tm = + let op,args = strip_comb tm in + match op with + Const (n, _) -> Cnet(n,List.length args),args + | Abs (bv, bod) -> Lnet(List.length args),bod::args + | Var (vn, _) -> Lcnet(vn,List.length args),args + | _ -> failwith "should_not_happen" in + let rec follow (tms,Netnode(edges,tips)) = + match tms with + [] -> List.iter (fun x -> Hashtbl.replace hash x ()) tips + | (tm::rtms) -> + let label,ntms = label_for_lookup tm in + try + let child = Tlm.find label edges in + follow(ntms @ rtms, child) + with Not_found -> (); + if label <> Vnet then begin + try follow(rtms,Tlm.find Vnet edges) with Not_found -> () + end + in + fun tm net -> follow([tm],net);; + +let rec linearizer = function + Var _ -> raise Exit + | Const (s, t) -> Var ("X", t) + | Abs (t1, t2) -> (try Abs (t1, linearizer t2) with Exit -> Var ("X", mk_fun_ty (type_of t1) (type_of t2))) + | Comb (t1, t2) -> (try Comb (t1, linearizer t2) with Exit -> + try (let lt1 = linearizer t1 in if is_var lt1 then raise Exit; Comb (lt1, t2)) + with Exit -> Var ("X", snd (dest_fun_ty (type_of t1)))) +;; + +let rec linearizel = function + Var _ -> raise Exit + | Const (s, t) -> Var ("X", t) + | Abs (t1, t2) -> (try Abs (t1, linearizel t2) with Exit -> Var ("X", mk_fun_ty (type_of t1) (type_of t2))) + | (Comb (t1, t2) as t) -> + let (hop, args) = strip_comb t in + (try list_mk_comb (hop, linearizell args) with Exit -> + try (let lt1 = linearizel hop in if is_var lt1 then raise Exit; list_mk_comb (lt1, args)) + with Exit -> Var ("X", type_of t)) +and linearizell = function + [] -> raise Exit +| h :: t -> try (linearizel h) :: t with Exit -> h :: linearizell t +;; + +let rec linearize_each = function + Abs (t1, t2) -> List.map (fun x -> Abs (t1, x)) (linearize_each t2) + | Const (s, t) -> [mk_var ("X", t)] + | (Comb (l, r) as t) -> let ll = linearize_each l and rr = linearize_each r in + let lll = + List.map (fun x -> if is_var x then mk_var ("X", type_of t) else mk_comb (x, r)) ll + in List.map (fun x -> mk_comb (l, x)) rr @ lll + | Var _ -> [] +;; + +let rec enter_all_linearize left net t = + try + let n1 = enter2 t net in + try + let t2 = if left then linearizel t else linearizer t in + enter_all_linearize left n1 t2 + with Exit -> + n1 + with Exit -> + (* Optimize: net *) + try + let t2 = if left then linearizel t else linearizer t in + enter_all_linearize left net t2 + with Exit -> net +;; + +(*let enter_each net t = + let l = linearize_each2 t in + let net = try enter2 t net with Exit -> net in + List.fold_left (fun sf t -> try enter2 t sf with Exit -> sf) net l +;;*) + +(* Only for FOF *) +let rec fold_subterms fn net tm = + if is_neg tm then fold_subterms fn net (dest_neg tm) else + if is_exists tm then fold_subterms fn net (snd (dest_exists tm)) else + if is_forall tm then fold_subterms fn net (snd (dest_forall tm)) else + if is_conj tm then List.fold_left (fold_subterms fn) net (conjuncts tm) else + if is_imp tm then let l,r = dest_imp tm in fold_subterms fn (fold_subterms fn net r) l else + if is_disj tm then List.fold_left (fold_subterms fn) net (disjuncts tm) else + let net = fn net tm in + match strip_comb tm with + _, [] -> net + | op, args -> List.fold_left (fun sf a -> fold_subterms fn sf a) net args +;; + +(*let sublin net tm = + let fn net tm = enter_all_linearize true net tm in + let fn net tm = enter_all_linearize false net tm in + let fn net tm = enter_each net tm in + let fn net tm = try enter2 tm net with Exit -> net in + fold_subterms fn net tm +;;*) + +let make_net right left single pairs tms = + let enterl net tms = List.fold_left (fun sf t -> try enter2 t sf with Exit -> sf) net tms in + let fn net tm = + let net = try enter2 tm net with Exit -> net in + let net = if right then enter_all_linearize false net tm else net in + let net = if left then enter_all_linearize true net tm else net in + let net = if single then let l = linearize_each tm in enterl net l else net in + let net = if pairs then + let l = + let ts = linearize_each tm in + setify (List.concat (List.map linearize_each ts)) + in enterl net l else net + in + net + in + let sublin net tm = fold_subterms fn net tm in + List.fold_left (fun net t -> sublin net t) (empty_net2) tms +;; + +let find_terms = + let rec accum tl tm = + let tl' = tm :: tl in + if is_abs tm then + accum tl' (body tm) + else if is_comb tm then + accum (accum tl' (rator tm)) (rand tm) + else tl' in + accum [];; + +let features net tm = + let subs = setify2 (find_terms tm) in + let hash = Hashtbl.create 100 in + List.iter (fun t -> lookup2 hash t net) subs; + Hashtbl.fold (fun k _ sf -> k :: sf) hash [] +;; + +let rec patterns hash sf = function + Const (c, _) -> + let cn = Hashtbl.find Fusion.hash_const_name c in + Hashtbl.replace hash (sf ^ cn) (); Hashtbl.replace hash cn () + | Abs (x, t) -> + patterns hash (sf ^ "\\-") t + | (Comb (l, r) as tm) -> + if is_neg tm then patterns hash sf (dest_neg tm) else + if is_exists tm then patterns hash sf (snd (dest_exists tm)) else + if is_forall tm then patterns hash sf (snd (dest_forall tm)) else + if is_conj tm then List.iter (patterns hash sf) (conjuncts tm) else + if is_disj tm then List.iter (patterns hash sf) (disjuncts tm) else + if is_imp tm then let l,r = dest_imp tm in patterns hash sf l; patterns hash sf r else + let (hop, args) = strip_comb tm in + let hopa = if is_var hop then "V" else if is_abs hop then "\\" else (fst (dest_const hop)) in + List.iter (patterns hash (hopa ^ "-")) args; + List.iter (patterns hash (sf ^ hopa ^ "-")) args + | Var (x, t) -> + Hashtbl.replace hash (sf ^ "V") (); Hashtbl.replace hash "V" () +;; + +let patterns tm = + let hash = Hashtbl.create 100 in + patterns hash "" tm; + Hashtbl.fold (fun k _ sf -> k :: sf) hash [] +;; + +let rec patterns2 hash sf = function + Const (c, _) -> + let cn = Hashtbl.find Fusion.hash_const_name c in + Hashtbl.replace hash (sf ^ cn) (); Hashtbl.replace hash cn () + | Abs (x, t) -> + patterns2 hash "\\-" t + | (Comb (l, r) as tm) -> + if is_neg tm then patterns2 hash sf (dest_neg tm) else + if is_exists tm then patterns2 hash sf (snd (dest_exists tm)) else + if is_forall tm then patterns2 hash sf (snd (dest_forall tm)) else + if is_conj tm then List.iter (patterns2 hash sf) (conjuncts tm) else + if is_disj tm then List.iter (patterns2 hash sf) (disjuncts tm) else + if is_imp tm then let l,r = dest_imp tm in patterns2 hash sf l; patterns2 hash sf r else + let (hop, args) = strip_comb tm in + let hopa = if is_var hop then "V" else if is_abs hop then "\\" else (fst (dest_const hop)) in + List.iter (patterns2 hash (hopa ^ "-")) args +(* List.iter (patterns2 hash (sf ^ hopa ^ "-")) args*) + | Var (x, t) -> + Hashtbl.replace hash (sf ^ "V") (); Hashtbl.replace hash "V" () +;; + +let patterns tm = + let hash = Hashtbl.create 100 in + patterns2 hash "" tm; + Hashtbl.fold (fun k _ sf -> k :: sf) hash [] +;; diff --git a/src/holyhammer/hh/hh1/fol.ml b/src/holyhammer/hh/hh1/fol.ml new file mode 100644 index 0000000000..5351f593d9 --- /dev/null +++ b/src/holyhammer/hh/hh1/fol.ml @@ -0,0 +1,280 @@ +module Im = Map.Make(struct type t = int let compare = compare end);; + +open Lib;; + +type fol_term = Fvar of int + | Fnapp of int * fol_term list;; +type fol_lit = int * fol_term list;; + +let mk_negated (p,a) = -p,a;; + +let offinc = 10000;; + +let rec fol_ground = function + Fvar _ -> false + | Fnapp (_, l) -> Lib.forall fol_ground l;; + +let rec fol_subst_bump offset theta tm = + match tm with + Fvar v -> if v < offinc then + let v' = v + offset in + (try Im.find v' theta with Not_found -> (Fvar(v'))) + else + (try Im.find v theta with Not_found -> tm) + | Fnapp(f,args) -> + let args' = qmap (fol_subst_bump offset theta) args in + if args' == args then tm else Fnapp(f,args');; + +let fol_inst_bump offset theta ((p,args) as at:fol_lit) = + let args' = qmap (fol_subst_bump offset theta) args in + if args' == args then at else p,args';; + +let rec istriv env x t = + match t with + Fvar y -> y = x or + (try let t' = Im.find y env in istriv env x t' + with Not_found -> false) + | Fnapp(f,args) -> exists (istriv env x) args & failwith "cyclic";; + +let rec fol_unify offset tm1 tm2 ((subst, nv) as sofar) = + match tm1,tm2 with + Fnapp(f,fargs),Fnapp(g,gargs) -> + if f <> g then failwith "" else + itlist2 (fol_unify offset) fargs gargs sofar + | _,Fvar(x) -> + (let x' = x + offset in + try let tm2' = Im.find x' subst in + fol_unify 0 tm1 tm2' sofar + with Not_found -> + if istriv subst x' tm1 then sofar + else (Im.add x' tm1 subst, x' :: nv)) + | Fvar(x),_ -> + (try let tm1' = Im.find x subst in + fol_unify offset tm1' tm2 sofar + with Not_found -> + let tm2' = fol_subst_bump offset Im.empty tm2 in + if istriv subst x tm2' then sofar + else (Im.add x tm2' subst, nv));; + +let fol_unify_lit offset (h1, l1) (h2, l2) subst = + if h1 <> h2 then failwith "" else + List.fold_left (fun sf (t1, t2) -> fol_unify offset t1 t2 sf) (subst, []) (zip l1 l2) +;; + +let rec fol_subst theta tm = + match tm with + Fvar v -> (try Im.find v theta with Not_found -> tm) + | Fnapp(f,args) -> + let args' = qmap (fol_subst theta) args in + if args' == args then tm else Fnapp(f,args');; + +let fol_inst theta ((p,args) as at:fol_lit) = + let args' = qmap (fol_subst theta) args in + if args' == args then at else p,args';; + +let reset_vars,fol_of_var,hol_of_var = + let vstore = ref [] + and gstore = ref [] + and vcounter = ref 0 in + let inc_vcounter() = + let n = !vcounter in + let m = n + 1 in + if m >= offinc then failwith "inc_vcounter: too many variables" else + (vcounter := m; n) in + let reset_vars() = vstore := []; gstore := []; vcounter := 0 in + let fol_of_var v = + let currentvars = !vstore in + try assoc v currentvars with Failure _ -> + let n = inc_vcounter() in + vstore := (v,n)::currentvars; n in + let hol_of_var v = + try rev_assoc v (!vstore) + with Failure _ -> rev_assoc v (!gstore) in + let hol_of_bumped_var v = + try hol_of_var v with Failure _ -> + let v' = v mod offinc in + let hv' = hol_of_var v' in + let gv = Basics.genvar(Fusion.type_of hv') in + gstore := (gv,v)::(!gstore); gv in + reset_vars,fol_of_var,hol_of_bumped_var;; + +let reset_consts,fol_of_const,hol_of_const = + let false_tm = Hl_parser.parse_term "F" in + let cstore = ref ([]:(Fusion.term * int)list) + and ccounter = ref 2 in + let reset_consts() = cstore := [false_tm,1]; ccounter := 2 in + let fol_of_const c = + let currentconsts = !cstore in + try assoc c currentconsts with Failure _ -> + let n = !ccounter in + ccounter := n + 1; cstore := (c,n)::currentconsts; n in + let hol_of_const c = rev_assoc c (!cstore) in + reset_consts,fol_of_const,hol_of_const;; + + + +let rec fol_of_term cs_are_vars env consts tm = + if Fusion.is_var tm & (if cs_are_vars then mem tm consts else not (mem tm consts)) then + Fvar(fol_of_var tm) + else + let f,args = Basics.strip_comb tm in + if mem f env then failwith "fol_of_term: higher order" else + let ff = fol_of_const f in + Fnapp(ff,map (fol_of_term cs_are_vars env consts) args) +;; + +let fol_of_atom cs_are_vars env vars tm = + let f,args = Basics.strip_comb tm in + if mem f env then failwith "fol_of_atom: higher order" else + let ff = fol_of_const f in + ff,map (fol_of_term cs_are_vars env vars) args;; + +let fol_of_literal cs_are_vars env vars tm = + try let tm' = Basics.dest_neg tm in + let p,a = fol_of_atom cs_are_vars env vars tm' in + -p,a + with Failure _ -> fol_of_atom cs_are_vars env vars tm;; + +let rec hol_of_term tm = + match tm with + Fvar v -> hol_of_var v + | Fnapp(f,args) -> Basics.list_mk_comb(hol_of_const f,map hol_of_term args);; + +let hol_of_atom (p,args) = + Basics.list_mk_comb(hol_of_const p,map hol_of_term args);; + +let hol_of_literal (p,args) = + if p < 0 then Bool.mk_neg(hol_of_atom(-p,args)) + else hol_of_atom (p,args);; + +let rec fol_eq insts tm1 tm2 = + tm1 == tm2 or + match tm1,tm2 with + Fnapp(f,fargs),Fnapp(g,gargs) -> + f = g & forall2 (fol_eq insts) fargs gargs + | _,Fvar(x) -> + (try let tm2' = Im.find x insts in + fol_eq insts tm1 tm2' + with Not_found -> + try istriv insts x tm1 with Failure _ -> false) + | Fvar(x),_ -> + (try let tm1' = Im.find x insts in + fol_eq insts tm1' tm2 + with Not_found -> + try istriv insts x tm2 with Failure _ -> false);; + +let fol_atom_eq insts (p1,args1) (p2,args2) = + p1 = p2 & forall2 (fol_eq insts) args1 args2;; + +open Equal;; +open Simp;; +open Basics;; +open Bool;; +open Fusion;; +open Hl_parser;; +open Drule;; + +let create_equality_axioms = + let eq_thms = cONJUNCTS (Sequent ([], parse_term "(x:A = x) /\\ + (~(x:A = y) \\/ ~(x = z) \\/ (y = z))")) in + let imp_elim_CONV = rEWR_CONV + (Sequent ([], parse_term "(a ==> b) <=> ~a \\/ b")) in + let eq_elim_RULE = + mATCH_MP(Sequent ([], parse_term "(a <=> b) ==> b \\/ ~a")) in + let veq_tm = rator(rator(concl(hd eq_thms))) in + let create_equivalence_axioms (eq,_) = + let tyins = type_match (type_of veq_tm) (type_of eq) [] in + map (iNST_TYPE tyins) eq_thms in + let rec tm_consts tm acc = + let fn,args = strip_comb tm in + if args = [] then acc + else itlist tm_consts args (insert (fn,length args) acc) in + let rec fm_consts tm ((preds,funs) as acc) = + try fm_consts(snd(dest_forall tm)) acc with Failure _ -> + try fm_consts(snd(dest_exists tm)) acc with Failure _ -> + try let l,r = dest_conj tm in fm_consts l (fm_consts r acc) + with Failure _ -> try + let l,r = dest_disj tm in fm_consts l (fm_consts r acc) + with Failure _ -> try + let l,r = dest_imp tm in fm_consts l (fm_consts r acc) + with Failure _ -> try + fm_consts (dest_neg tm) acc with Failure _ -> + try let l,r = dest_eq tm in + if type_of l = bool_ty + then fm_consts r (fm_consts l acc) + else failwith "atomic equality" + with Failure _ -> + let pred,args = strip_comb tm in + if args = [] then acc else + insert (pred,length args) preds,itlist tm_consts args funs in + let create_congruence_axiom pflag (tm,len) = + let atys,rty = splitlist (fun ty -> let op,l = dest_type ty in + if op = "fun" then hd l,hd(tl l) + else fail()) + (type_of tm) in + let ctys = fst(chop_list len atys) in + let largs = map genvar ctys + and rargs = map genvar ctys in + let th1 = rev_itlist (ccc (curry mK_COMB)) (map (o aSSUME mk_eq) + (zip largs rargs)) (rEFL tm) in + let th2 = if pflag then eq_elim_RULE th1 else th1 in + itlist (fun e th -> cONV_RULE imp_elim_CONV (dISCH e th)) (hyp th2) th2 in + fun tms -> let preds,funs = itlist fm_consts tms ([],[]) in + let eqs0,noneqs = partition + (fun (t,_) -> is_const t & fst(dest_const t) = "=") preds in + if eqs0 = [] then [] else + let pcongs = map (create_congruence_axiom true) noneqs + and fcongs = map (create_congruence_axiom false) funs in + let preds1,_ = + itlist fm_consts (map concl (pcongs @ fcongs)) ([],[]) in + let eqs1 = filter + (fun (t,_) -> is_const t & fst(dest_const t) = "=") preds1 in + let eqs = union eqs0 eqs1 in + let equivs = + itlist (o (union' equals_thm) create_equivalence_axioms) + eqs [] in + equivs@pcongs@fcongs;; + +let rec fol_subst_partial insts tm = + match tm with + Fvar(v) -> (try let t = Im.find v insts in + fol_subst_partial insts t + with Not_found -> tm) + | Fnapp(f,args) -> Fnapp(f,map (fol_subst_partial insts) args);; + +let print_var i = Printf.printf "V%i" i;; +(* try print_string (String.uppercase (fst (Fusion.dest_var (hol_of_var i)))) with _ -> print_char 'V'; print_int i;;*) + +let rec print_foft = function + Fvar i -> print_var i + | Fnapp (i, l) -> (*Printf.printf "c%i" i;*) +(try print_string (String.lowercase (fst (Fusion.dest_const (hol_of_const i)))) + with Failure _ -> print_string (String.lowercase (fst (Fusion.dest_var (hol_of_const i))))); + match l with + [] -> () + | [h] -> print_char '('; print_foft h; print_char ')' + | h :: t -> print_char '('; print_foft h; List.iter (fun x -> print_char ','; print_foft x) t; print_char ')' +;; + +let print_fofl (i, l) = + if i < 0 then print_char '-'; + if fst (Fusion.dest_const (hol_of_const (abs i))) = "#" then print_string "#" else (*Printf.printf "p%i" (abs i);*) + print_string (fst (Fusion.dest_const (hol_of_const (abs i)))); + match l with + [] -> () + | [h] -> print_char '('; print_foft h; print_char ')' + | h :: t -> print_char '('; print_foft h; List.iter (fun x -> print_char ','; print_foft x) t; print_char ')' +;; + +let rec oiter oc fn sep = function + [] -> () + | [e] -> fn oc e + | h :: t -> fn oc h; output_string oc sep; oiter oc fn sep t;; + +let print_fof_clause l = + print_char '['; oiter stdout (fun _ i -> print_fofl i) ", " l; print_string "].";; + +let print_fol_subst s = + print_char '{'; Im.iter (fun v t -> print_var v; print_string ":="; print_foft t; print_char ' ') s; print_char '}' +;; + diff --git a/src/holyhammer/hh/hh1/follist.ml b/src/holyhammer/hh/hh1/follist.ml new file mode 100644 index 0000000000..d1e2d05b25 --- /dev/null +++ b/src/holyhammer/hh/hh1/follist.ml @@ -0,0 +1,266 @@ +open Lib;; + +type fol_term = Fvar of int + | Fnapp of int * fol_term list;; +type fol_lit = int * fol_term list;; + +let mk_negated (p,a) = -p,a;; + +let offinc = 100000;; + +let rec fol_subst_bump offset theta tm = + match tm with + Fvar v -> if v < offinc then + let v' = v + offset in + rev_assocd v' theta (Fvar(v')) + else + rev_assocd v theta tm + | Fnapp(f,args) -> + let args' = qmap (fol_subst_bump offset theta) args in + if args' == args then tm else Fnapp(f,args');; + +let fol_inst_bump offset theta ((p,args) as at:fol_lit) = + let args' = qmap (fol_subst_bump offset theta) args in + if args' == args then at else p,args';; + +let rec istriv env x t = + match t with + Fvar y -> y = x or + (try let t' = rev_assoc y env in istriv env x t' + with Failure "find" -> false) + | Fnapp(f,args) -> exists (istriv env x) args & failwith "cyclic";; + +let rec fol_unify offset tm1 tm2 sofar = + match tm1,tm2 with + Fnapp(f,fargs),Fnapp(g,gargs) -> + if f <> g then failwith "" else + itlist2 (fol_unify offset) fargs gargs sofar + | _,Fvar(x) -> + (let x' = x + offset in + try let tm2' = rev_assoc x' sofar in + fol_unify 0 tm1 tm2' sofar + with Failure "find" -> + if istriv sofar x' tm1 then sofar + else (tm1,x')::sofar) + | Fvar(x),_ -> + (try let tm1' = rev_assoc x sofar in + fol_unify offset tm1' tm2 sofar + with Failure "find" -> + let tm2' = fol_subst_bump offset [] tm2 in + if istriv sofar x tm2' then sofar + else (tm2',x)::sofar);; + +let fol_unify_lit offset (h1, l1) (h2, l2) sofar = + if h1 <> h2 then failwith "" else + List.fold_left (fun sf (t1, t2) -> fol_unify offset t1 t2 sf) sofar (zip l1 l2) +;; + +let rec fol_subst theta tm = + match tm with + Fvar v -> rev_assocd v theta tm + | Fnapp(f,args) -> + let args' = qmap (fol_subst theta) args in + if args' == args then tm else Fnapp(f,args');; + +let fol_inst theta ((p,args) as at:fol_lit) = + let args' = qmap (fol_subst theta) args in + if args' == args then at else p,args';; + +let reset_vars,fol_of_var,hol_of_var = + let vstore = ref [] + and gstore = ref [] + and vcounter = ref 0 in + let inc_vcounter() = + let n = !vcounter in + let m = n + 1 in + if m >= offinc then failwith "inc_vcounter: too many variables" else + (vcounter := m; n) in + let reset_vars() = vstore := []; gstore := []; vcounter := 0 in + let fol_of_var v = + let currentvars = !vstore in + try assoc v currentvars with Failure _ -> + let n = inc_vcounter() in + vstore := (v,n)::currentvars; n in + let hol_of_var v = + try rev_assoc v (!vstore) + with Failure _ -> rev_assoc v (!gstore) in + let hol_of_bumped_var v = + try hol_of_var v with Failure _ -> + let v' = v mod offinc in + let hv' = hol_of_var v' in + let gv = Basics.genvar(Fusion.type_of hv') in + gstore := (gv,v)::(!gstore); gv in + reset_vars,fol_of_var,hol_of_bumped_var;; + +let reset_consts,fol_of_const,hol_of_const = + let false_tm = Hl_parser.parse_term "F" in + let cstore = ref ([]:(Fusion.term * int)list) + and ccounter = ref 2 in + let reset_consts() = cstore := [false_tm,1]; ccounter := 2 in + let fol_of_const c = + let currentconsts = !cstore in + try assoc c currentconsts with Failure _ -> + let n = !ccounter in + ccounter := n + 1; cstore := (c,n)::currentconsts; n in + let hol_of_const c = rev_assoc c (!cstore) in + reset_consts,fol_of_const,hol_of_const;; + + + +let rec fol_of_term cs_are_vars env consts tm = + if Fusion.is_var tm & (if cs_are_vars then mem tm consts else not (mem tm consts)) then + Fvar(fol_of_var tm) + else + let f,args = Basics.strip_comb tm in + if mem f env then failwith "fol_of_term: higher order" else + let ff = fol_of_const f in + Fnapp(ff,map (fol_of_term cs_are_vars env consts) args) +;; + +let fol_of_atom cs_are_vars env vars tm = + let f,args = Basics.strip_comb tm in + if mem f env then failwith "fol_of_atom: higher order" else + let ff = fol_of_const f in + ff,map (fol_of_term cs_are_vars env vars) args;; + +let fol_of_literal cs_are_vars env vars tm = + try let tm' = Basics.dest_neg tm in + let p,a = fol_of_atom cs_are_vars env vars tm' in + -p,a + with Failure _ -> fol_of_atom cs_are_vars env vars tm;; + +let rec hol_of_term tm = + match tm with + Fvar v -> hol_of_var v + | Fnapp(f,args) -> Basics.list_mk_comb(hol_of_const f,map hol_of_term args);; + +let hol_of_atom (p,args) = + Basics.list_mk_comb(hol_of_const p,map hol_of_term args);; + +let hol_of_literal (p,args) = + if p < 0 then Bool.mk_neg(hol_of_atom(-p,args)) + else hol_of_atom (p,args);; + +let rec fol_eq insts tm1 tm2 = + tm1 == tm2 or + match tm1,tm2 with + Fnapp(f,fargs),Fnapp(g,gargs) -> + f = g & forall2 (fol_eq insts) fargs gargs + | _,Fvar(x) -> + (try let tm2' = rev_assoc x insts in + fol_eq insts tm1 tm2' + with Failure "find" -> + try istriv insts x tm1 with Failure _ -> false) + | Fvar(x),_ -> + (try let tm1' = rev_assoc x insts in + fol_eq insts tm1' tm2 + with Failure "find" -> + try istriv insts x tm2 with Failure _ -> false);; + +let fol_atom_eq insts (p1,args1) (p2,args2) = + p1 = p2 & forall2 (fol_eq insts) args1 args2;; + +open Equal;; +open Simp;; +open Basics;; +open Bool;; +open Fusion;; +open Hl_parser;; +open Drule;; + +let create_equality_axioms = + let eq_thms = cONJUNCTS (Sequent ([], parse_term "(x:A = x) /\\ + (~(x:A = y) \\/ ~(x = z) \\/ (y = z))")) in + let imp_elim_CONV = rEWR_CONV + (Sequent ([], parse_term "(a ==> b) <=> ~a \\/ b")) in + let eq_elim_RULE = + mATCH_MP(Sequent ([], parse_term "(a <=> b) ==> b \\/ ~a")) in + let veq_tm = rator(rator(concl(hd eq_thms))) in + let create_equivalence_axioms (eq,_) = + let tyins = type_match (type_of veq_tm) (type_of eq) [] in + map (iNST_TYPE tyins) eq_thms in + let rec tm_consts tm acc = + let fn,args = strip_comb tm in + if args = [] then acc + else itlist tm_consts args (insert (fn,length args) acc) in + let rec fm_consts tm ((preds,funs) as acc) = + try fm_consts(snd(dest_forall tm)) acc with Failure _ -> + try fm_consts(snd(dest_exists tm)) acc with Failure _ -> + try let l,r = dest_conj tm in fm_consts l (fm_consts r acc) + with Failure _ -> try + let l,r = dest_disj tm in fm_consts l (fm_consts r acc) + with Failure _ -> try + let l,r = dest_imp tm in fm_consts l (fm_consts r acc) + with Failure _ -> try + fm_consts (dest_neg tm) acc with Failure _ -> + try let l,r = dest_eq tm in + if type_of l = bool_ty + then fm_consts r (fm_consts l acc) + else failwith "atomic equality" + with Failure _ -> + let pred,args = strip_comb tm in + if args = [] then acc else + insert (pred,length args) preds,itlist tm_consts args funs in + let create_congruence_axiom pflag (tm,len) = + let atys,rty = splitlist (fun ty -> let op,l = dest_type ty in + if op = "fun" then hd l,hd(tl l) + else fail()) + (type_of tm) in + let ctys = fst(chop_list len atys) in + let largs = map genvar ctys + and rargs = map genvar ctys in + let th1 = rev_itlist (ccc (curry mK_COMB)) (map (o aSSUME mk_eq) + (zip largs rargs)) (rEFL tm) in + let th2 = if pflag then eq_elim_RULE th1 else th1 in + itlist (fun e th -> cONV_RULE imp_elim_CONV (dISCH e th)) (hyp th2) th2 in + fun tms -> let preds,funs = itlist fm_consts tms ([],[]) in + let eqs0,noneqs = partition + (fun (t,_) -> is_const t & fst(dest_const t) = "=") preds in + if eqs0 = [] then [] else + let pcongs = map (create_congruence_axiom true) noneqs + and fcongs = map (create_congruence_axiom false) funs in + let preds1,_ = + itlist fm_consts (map concl (pcongs @ fcongs)) ([],[]) in + let eqs1 = filter + (fun (t,_) -> is_const t & fst(dest_const t) = "=") preds1 in + let eqs = union eqs0 eqs1 in + let equivs = + itlist (o (union' equals_thm) create_equivalence_axioms) + eqs [] in + equivs@pcongs@fcongs;; + +let rec fol_subst_partial insts tm = + match tm with + Fvar(v) -> (try let t = rev_assoc v insts in + fol_subst_partial insts t + with Failure "find" -> tm) + | Fnapp(f,args) -> Fnapp(f,map (fol_subst_partial insts) args);; + + +let print_var i = try print_string (String.uppercase (fst (Fusion.dest_var (hol_of_var i)))) with _ -> print_char 'V'; print_int i;; + +let rec print_foft = function + Fvar i -> print_var i + | Fnapp (i, l) -> (try print_string (String.lowercase (fst (Fusion.dest_const (hol_of_const i)))) + with Failure _ -> print_string (String.lowercase (fst (Fusion.dest_var (hol_of_const i))))); + match l with + [] -> () + | [h] -> print_char '('; print_foft h; print_char ')' + | h :: t -> print_char '('; print_foft h; List.iter (fun x -> print_char ','; print_foft x) t; print_char ')' +;; + +let print_fofl (i, l) = + if i < 0 then print_char '~'; + print_string (fst (Fusion.dest_const (hol_of_const (abs i)))); + match l with + [] -> () + | [h] -> print_char '('; print_foft h; print_char ')' + | h :: t -> print_char '('; print_foft h; List.iter (fun x -> print_char ','; print_foft x) t; print_char ')' +;; + +let print_fof_clause l = + print_char '{'; List.iter (fun i -> print_fofl i; print_char ' ') l; print_char '}';; + +let print_fol_subst s = + print_char '{'; List.iter (fun (t,v) -> print_var v; print_string ":="; print_foft t; print_char ' ') s; print_char '}' +;; diff --git a/src/holyhammer/hh/hh1/fusion.ml b/src/holyhammer/hh/hh1/fusion.ml new file mode 100644 index 0000000000..53cfbdda9f --- /dev/null +++ b/src/holyhammer/hh/hh1/fusion.ml @@ -0,0 +1,600 @@ + + + + + + + + + +open Lib;; + + type hol_type = Tyvar of string + | Tyapp of string * hol_type list + + type term = Var of string * hol_type + | Const of int * hol_type + | Comb of term * term + | Abs of term * term + + type thm = Sequent of (term list * term) + + + + + + + + + + let the_type_constants = ref ["bool",0; "fun",2] + + + + + + let types() = !the_type_constants + + + + + + let get_type_arity s = assoc s (!the_type_constants) + + + + + + let new_type(name,arity) = + if Lib.can get_type_arity name then + failwith ("new_type: type "^name^" has already been declared") + else the_type_constants := (name,arity)::(!the_type_constants) + + + + + + let mk_type(tyop,args) = + let arity = try get_type_arity tyop with Failure _ -> + failwith ("mk_type: type "^tyop^" has not been defined") in + if arity = length args then + Tyapp(tyop,args) + else failwith ("mk_type: wrong number of arguments to "^tyop) + + let mk_vartype v = Tyvar(v) + + + + + + let dest_type = + function + (Tyapp (s,ty)) -> s,ty + | (Tyvar _) -> failwith "dest_type: type variable not a constructor" + + let dest_vartype = + function + (Tyapp(_,_)) -> failwith "dest_vartype: type constructor not a variable" + | (Tyvar s) -> s + + + + + + let is_type = Lib.can dest_type + + let is_vartype = Lib.can dest_vartype + + + + + + let rec tyvars = + function + (Tyapp(_,args)) -> Lib.itlist (Lib.o Lib.union tyvars) args [] + | (Tyvar v as tv) -> [tv] + + + + + + + + + let rec type_subst i ty = + match ty with + Tyapp(tycon,args) -> + let args' = Lib.qmap (type_subst i) args in + if args' == args then ty else Tyapp(tycon,args') + | _ -> rev_assocd ty i ty + + let bool_ty = Tyapp("bool",[]) + + let aty = Tyvar "A" + + + + + + + let the_term_constants = Hashtbl.create 1000;; + let hash_name_const = Hashtbl.create 1000;; + let hash_const_name = Hashtbl.create 1000;; + + Hashtbl.add hash_name_const "=" 0;; + Hashtbl.add hash_const_name 0 "=";; + Hashtbl.add the_term_constants 0 (Tyapp("fun",[aty;Tyapp("fun",[aty;bool_ty])]));; + let next_const_no = ref 0;; + + let constants() = + let i = ref 0 and ret = ref [] in + try while true do + ret := (Hashtbl.find hash_const_name !i, Hashtbl.find the_term_constants !i) :: !ret; + incr i + done; failwith "constants" with Not_found -> List.rev !ret + ;; + + let get_const_type s = try Hashtbl.find the_term_constants (Hashtbl.find hash_name_const s) with Not_found -> failwith "find";; + + + let new_constant(name,ty) = + if Hashtbl.mem hash_name_const name then + failwith ("new_constant: constant "^name^" has already been declared") + else begin + incr next_const_no; + let no = !next_const_no in + Hashtbl.add hash_name_const name no; + Hashtbl.add hash_const_name no name; + Hashtbl.add the_term_constants no ty + end + + + let set_term_constants l = + Hashtbl.clear the_term_constants; + Hashtbl.clear hash_name_const; + Hashtbl.clear hash_const_name; + next_const_no := -1; + List.iter new_constant l + ;; + + + + let rec type_of tm = + match tm with + Var(_,ty) -> ty + | Const(_,ty) -> ty + | Comb(s,_) -> hd(tl(snd(dest_type(type_of s)))) + | Abs(Var(_,ty),t) -> Tyapp("fun",[ty;type_of t]) + + + + + + let is_var = function (Var(_,_)) -> true | _ -> false + + let is_const = function (Const(_,_)) -> true | _ -> false + + let is_abs = function (Abs(_,_)) -> true | _ -> false + + let is_comb = function (Comb(_,_)) -> true | _ -> false + + + + + + let mk_var(v,ty) = Var(v,ty) + + let mk_const(name,theta) = + let no = try Hashtbl.find hash_name_const name with Not_found -> + failwith "mk_const: not a constant name" in + let uty = Hashtbl.find the_term_constants no in + Const(no,type_subst theta uty) + + let mk_abs(bvar,bod) = + match bvar with + Var(_,_) -> Abs(bvar,bod) + | _ -> failwith "mk_abs: not a variable" + + let mk_comb(f,a) = + match type_of f with + Tyapp("fun",[ty;_]) when Pervasives.compare ty (type_of a) = 0 + -> Comb(f,a) + | _ -> failwith "mk_comb: types do not agree" + + + + + + let dest_var = + function (Var(s,ty)) -> s,ty | _ -> failwith "dest_var: not a variable" + + let dest_const = + function (Const(s,ty)) -> + (try + Hashtbl.find hash_const_name s,ty + with Not_found -> failwith ("No const: " ^ string_of_int s)) + | _ -> failwith "dest_const: not a constant" + + let dest_comb = + function (Comb(f,x)) -> f,x | _ -> failwith "dest_comb: not a combination" + + let dest_abs = + function (Abs(v,b)) -> v,b | _ -> failwith "dest_abs: not an abstraction" + + + + + + let rec frees tm = + match tm with + Var(_,_) -> [tm] + | Const(_,_) -> [] + | Abs(bv,bod) -> subtract (frees bod) [bv] + | Comb(s,t) -> union (frees s) (frees t) + + let freesl tml = itlist (o union frees) tml [] + + + + + + let rec freesin acc tm = + match tm with + Var(_,_) -> mem tm acc + | Const(_,_) -> true + | Abs(bv,bod) -> freesin (bv::acc) bod + | Comb(s,t) -> freesin acc s && freesin acc t + + + + + + let rec vfree_in v tm = + match tm with + Abs(bv,bod) -> v <> bv && vfree_in v bod + | Comb(s,t) -> vfree_in v s || vfree_in v t + | _ -> Pervasives.compare tm v = 0 + + + + + + let rec type_vars_in_term tm = + match tm with + Var(_,ty) -> tyvars ty + | Const(_,ty) -> tyvars ty + | Comb(s,t) -> union (type_vars_in_term s) (type_vars_in_term t) + | Abs(Var(_,ty),t) -> union (tyvars ty) (type_vars_in_term t) + + + + + + let rec variant avoid v = + if not(exists (vfree_in v) avoid) then v else + match v with + Var(s,ty) -> variant avoid (Var(s^"'",ty)) + | _ -> failwith "variant: not a variable" + + + + + + let vsubst = + let rec vsubst ilist tm = + match tm with + Var(_,_) -> rev_assocd tm ilist tm + | Const(_,_) -> tm + | Comb(s,t) -> let s' = vsubst ilist s and t' = vsubst ilist t in + if s' == s && t' == t then tm else Comb(s',t') + | Abs(v,s) -> let ilist' = filter (fun (t,x) -> x <> v) ilist in + if ilist' = [] then tm else + let s' = vsubst ilist' s in + if s' == s then tm else + if exists (fun (t,x) -> vfree_in v t && vfree_in x s) ilist' + then let v' = variant [s'] v in + Abs(v',vsubst ((v',v)::ilist') s) + else Abs(v,s') in + fun theta -> + if theta = [] then (fun tm -> tm) else + if forall (fun (t,x) -> type_of t = snd(dest_var x)) theta + then vsubst theta else failwith "vsubst: Bad substitution list" + + + + + + exception Clash of term + + let inst = + let rec inst env tyin tm = + match tm with + Var(n,ty) -> let ty' = type_subst tyin ty in + let tm' = if ty' == ty then tm else Var(n,ty') in + if Pervasives.compare (rev_assocd tm' env tm) tm = 0 + then tm' + else raise (Clash tm') + | Const(c,ty) -> let ty' = type_subst tyin ty in + if ty' == ty then tm else Const(c,ty') + | Comb(f,x) -> let f' = inst env tyin f and x' = inst env tyin x in + if f' == f && x' == x then tm else Comb(f',x') + | Abs(y,t) -> let y' = inst [] tyin y in + let env' = (y,y')::env in + try let t' = inst env' tyin t in + if y' == y && t' == t then tm else Abs(y',t') + with (Clash(w') as ex) -> + if w' <> y' then raise ex else + let ifrees = map (inst [] tyin) (frees t) in + let y'' = variant ifrees y' in + let z = Var(fst(dest_var y''),snd(dest_var y)) in + inst env tyin (Abs(z,vsubst[z,y] t)) in + fun tyin -> if tyin = [] then fun tm -> tm else inst [] tyin + + + + + + let rator tm = + match tm with + Comb(l,r) -> l + | _ -> failwith "rator: Not a combination" + + let rand tm = + match tm with + Comb(l,r) -> r + | _ -> failwith "rand: Not a combination" + + + + + + let safe_mk_eq l r = + let ty = type_of l in + Comb(Comb(Const(0,Tyapp("fun",[ty;Tyapp("fun",[ty;bool_ty])])),l),r) + + let dest_eq tm = + match tm with + Comb(Comb(Const(0,_),l),r) -> l,r + | _ -> failwith "dest_eq" + + + + + + let rec ordav env x1 x2 = + match env with + [] -> Pervasives.compare x1 x2 + | (t1,t2)::oenv -> if Pervasives.compare x1 t1 = 0 + then if Pervasives.compare x2 t2 = 0 + then 0 else -1 + else if Pervasives.compare x2 t2 = 0 then 1 + else ordav oenv x1 x2 + + let rec orda env tm1 tm2 = + if tm1 == tm2 && forall (fun (x,y) -> x = y) env then 0 else + match (tm1,tm2) with + Var(x1,ty1),Var(x2,ty2) -> ordav env tm1 tm2 + | Const(x1,ty1),Const(x2,ty2) -> Pervasives.compare tm1 tm2 + | Comb(s1,t1),Comb(s2,t2) -> + let c = orda env s1 s2 in if c <> 0 then c else orda env t1 t2 + | Abs(Var(_,ty1) as x1,t1),Abs(Var(_,ty2) as x2,t2) -> + let c = Pervasives.compare ty1 ty2 in + if c <> 0 then c else orda ((x1,x2)::env) t1 t2 + | Const(_,_),_ -> -1 + | _,Const(_,_) -> 1 + | Var(_,_),_ -> -1 + | _,Var(_,_) -> 1 + | Comb(_,_),_ -> -1 + | _,Comb(_,_) -> 1 + + let alphaorder = orda [] + + let rec term_union l1 l2 = + match (l1,l2) with + ([],l2) -> l2 + | (l1,[]) -> l1 + | (h1::t1,h2::t2) -> let c = alphaorder h1 h2 in + if c = 0 then h1::(term_union t1 t2) + else if c < 0 then h1::(term_union t1 l2) + else h2::(term_union l1 t2) + + let rec term_remove t l = + match l with + s::ss -> let c = alphaorder t s in + if c > 0 then + let ss' = term_remove t ss in + if ss' == ss then l else s::ss' + else if c = 0 then ss else l + | [] -> l + + let rec term_image f l = + match l with + h::t -> let h' = f h and t' = term_image f t in + if h' == h && t' == t then l else term_union [h'] t' + | [] -> l + + + + + + let dest_thm (Sequent(asl,c)) = (asl,c) + + let hyp (Sequent(asl,c)) = asl + + let concl (Sequent(asl,c)) = c + + + + + + let rEFL tm = + Sequent([],safe_mk_eq tm tm) + + let tRANS (Sequent(asl1,c1)) (Sequent(asl2,c2)) = + match (c1,c2) with + Comb((Comb(Const(0,_),_) as eql),m1),Comb(Comb(Const(0,_),m2),r) + when alphaorder m1 m2 = 0 -> Sequent(term_union asl1 asl2,Comb(eql,r)) + | _ -> failwith "TRANS" + + + + + + let mK_COMB(Sequent(asl1,c1),Sequent(asl2,c2)) = + match (c1,c2) with + Comb(Comb(Const(0,_),l1),r1),Comb(Comb(Const(0,_),l2),r2) -> + (match type_of l1 with + Tyapp("fun",[ty;_]) when Pervasives.compare ty (type_of l2) = 0 + -> Sequent(term_union asl1 asl2, + safe_mk_eq (Comb(l1,l2)) (Comb(r1,r2))) + | _ -> failwith "MK_COMB: types do not agree") + | _ -> failwith "MK_COMB: not both equations" + + let aBS v (Sequent(asl,c)) = + match (v,c) with + Var(_,_),Comb(Comb(Const(0,_),l),r) when not(exists (vfree_in v) asl) + -> Sequent(asl,safe_mk_eq (Abs(v,l)) (Abs(v,r))) + | _ -> failwith "ABS";; + + + + + + let bETA tm = + match tm with + Comb(Abs(v,bod),arg) when Pervasives.compare arg v = 0 + -> Sequent([],safe_mk_eq tm bod) + | _ -> failwith "BETA: not a trivial beta-redex" + + + + + + let aSSUME tm = + if Pervasives.compare (type_of tm) bool_ty = 0 then Sequent([tm],tm) + else failwith "ASSUME: not a proposition" + + let eQ_MP (Sequent(asl1,eq)) (Sequent(asl2,c)) = + match eq with + Comb(Comb(Const(0,_),l),r) when alphaorder l c = 0 + -> Sequent(term_union asl1 asl2,r) + | _ -> failwith "EQ_MP" + + let dEDUCT_ANTISYM_RULE (Sequent(asl1,c1)) (Sequent(asl2,c2)) = + let asl1' = term_remove c2 asl1 and asl2' = term_remove c1 asl2 in + Sequent(term_union asl1' asl2',safe_mk_eq c1 c2) + + + + + + let iNST_TYPE theta (Sequent(asl,c)) = + let inst_fn = inst theta in + Sequent(term_image inst_fn asl,inst_fn c) + + let iNST theta (Sequent(asl,c)) = + let inst_fun = vsubst theta in + Sequent(term_image inst_fun asl,inst_fun c) + + + + + + let the_axioms = ref ([]:thm list) + + let axioms() = !the_axioms + + let new_axiom tm = + if Pervasives.compare (type_of tm) bool_ty = 0 then + let th = Sequent([],tm) in + (the_axioms := th::(!the_axioms); th) + else failwith "new_axiom: Not a proposition" + + + + + + let the_definitions = ref ([]:thm list) + + let definitions() = !the_definitions + + let new_basic_definition tm = + match tm with + Comb(Comb(Const(0,_),Var(cname,ty)),r) -> + if not(freesin [] r) then failwith "new_definition: term not closed" + else if not (subset (type_vars_in_term r) (tyvars ty)) + then failwith "new_definition: Type variables not reflected in constant" + else let c = new_constant(cname,ty); Const(Hashtbl.find hash_name_const cname,ty) in + let dth = Sequent([],safe_mk_eq c r) in + the_definitions := dth::(!the_definitions); dth + | _ -> failwith "new_basic_definition" + + + + + + + + + + + + + + + let new_basic_type_definition tyname (absname,repname) (Sequent(asl,c)) = + if exists (Hashtbl.mem hash_name_const) [absname; repname] then + failwith "new_basic_type_definition: Constant(s) already in use" else + if not (asl = []) then + failwith "new_basic_type_definition: Assumptions in theorem" else + let p,x = try dest_comb c + with Failure _ -> + failwith "new_basic_type_definition: Not a combination" in + if not(freesin [] p) then + failwith "new_basic_type_definition: Predicate is not closed" else + let tyvars = sort (<=) (type_vars_in_term p) in + let _ = try new_type(tyname,length tyvars) + with Failure _ -> + failwith "new_basic_type_definition: Type already defined" in + let aty = Tyapp(tyname,tyvars) + and rty = type_of x in + let absty = Tyapp("fun",[rty;aty]) and repty = Tyapp("fun",[aty;rty]) in + let abs = (new_constant(absname,absty); Const(Hashtbl.find hash_name_const absname,absty)) + and rep = (new_constant(repname,repty); Const(Hashtbl.find hash_name_const repname,repty)) in + let a = Var("a",aty) and r = Var("r",rty) in + Sequent([],safe_mk_eq (Comb(abs,mk_comb(rep,a))) a), + Sequent([],safe_mk_eq (Comb(p,r)) + (safe_mk_eq (mk_comb(rep,mk_comb(abs,r))) r)) + + + + + +let mk_fun_ty ty1 ty2 = mk_type("fun",[ty1; ty2]);; +let bty = mk_vartype "B";; + +let is_eq tm = + match tm with + Comb(Comb(Const(0,_),_),_) -> true + | _ -> false;; + +let mk_eq = + let eq = mk_const("=",[]) in + fun (l,r) -> + try let ty = type_of l in + let eq_tm = inst [ty,aty] eq in + mk_comb(mk_comb(eq_tm,l),r) + with Failure _ -> failwith "mk_eq";; + + + + + +let aconv s t = alphaorder s t = 0;; + + + + + + +let equals_thm th th' = dest_thm th = dest_thm th';; diff --git a/src/holyhammer/hh/hh1/hh_symbols.ml b/src/holyhammer/hh/hh1/hh_symbols.ml new file mode 100644 index 0000000000..b823c42d7a --- /dev/null +++ b/src/holyhammer/hh/hh1/hh_symbols.ml @@ -0,0 +1,340 @@ +open Fusion;; +open Format;; +open Printer;; +open Basics;; +open Lib;; +open Bool;; + +let theorems = ref [];; + + + +module Sm = Map.Make(struct type t = string let compare = compare end);; +module Tmm = Map.Make(struct type t = term let compare = compare end);; +let os = output_string;; + +let print_to_lstring printer = + let sbuff = ref "" in + let output s m n = if s <> "\n" then sbuff := (!sbuff)^(String.sub s m n) else () + and flush() = () in + let fmt = make_formatter output flush in + pp_set_max_boxes fmt 1; pp_set_margin fmt 1000000000; pp_set_max_indent fmt 1000000000; + fun i -> ignore(printer fmt i); ignore(pp_print_flush fmt ()); let s = !sbuff in sbuff := ""; s +;; +let lstring_of_type = print_to_lstring pp_print_type;; +let lstring_of_term = print_to_lstring pp_print_term;; +let lstring_of_thm = print_to_lstring pp_print_thm;; + +let rec fold_apps fn bnd tm sofar = + try let l,r = try dest_forall tm with Failure _ -> + try dest_exists tm with Failure _ -> + dest_abs tm in + fold_apps fn (l :: bnd) r sofar + with Failure _ -> try + let l,r = try dest_conj tm with Failure _ -> + try dest_disj tm with Failure _ -> + try (let l,r = dest_eq tm in if type_of l = bool_ty then failwith "equivalence" else (l,r)) with Failure _ -> + dest_imp tm in + fold_apps fn bnd r (fold_apps fn bnd l sofar) + with Failure _ -> try + let tm = dest_neg tm in fold_apps fn bnd tm sofar + with Failure _ -> + let hop, args = strip_comb tm in + let sofar = if is_abs hop then fold_apps fn bnd hop sofar else sofar in + itlist (fold_apps fn bnd) args (fn bnd hop args sofar);; + +let funtys_of_tm tm = + let mergel l = setify (List.concat l) in + let tys tm = map type_of (find_terms (fun x -> is_var x or is_const x) tm) in + let rec funtypes t = + if is_vartype t then [] else + let (s, l) = dest_type t in + mergel ([s]::(map funtypes l)) in + mergel (map funtypes (tys tm)) +;; + +let rec rename_bnds map min tm prfun = + try let l, r = dest_abs tm in + let _, ty = dest_var l in + let nl = mk_var (prfun min ty, ty) in + mk_abs (nl, rename_bnds (Tmm.add l nl (Tmm.remove l map)) (min + 1) r prfun) + with _ -> try let l, r = dest_comb tm in + mk_comb (rename_bnds map min l prfun, rename_bnds map min r prfun) + with _ -> try Tmm.find tm map with _ -> tm +;; +let rename_all tm prfun = + let fs = frees tm in + let tys = map (o snd dest_var) fs in + let s = Array.to_list (Array.init (List.length fs) (fun i -> prfun i (List.nth tys i))) in + let nfs = map mk_var (zip s tys) in + rename_bnds Tmm.empty (List.length fs) (vsubst (zip nfs fs) tm) prfun +;; +let get_subterms tm prfun = + let fold_apps_fn _ hop args ts = + Sm.add (lstring_of_term (rename_all (list_mk_comb (hop, args)) prfun)) () ts + in map fst (Sm.bindings (fold_apps fold_apps_fn [] tm Sm.empty)) +;; + +let prfun0 min ty = "A0";; +let prfun min ty = "A" ^ string_of_int min;; +let prfunt min ty = "A" ^ lstring_of_type ty;; +let prfunnt min ty = "A" ^ string_of_int min ^ lstring_of_type ty;; + +let retyvar tm = + let tvs = type_vars_in_term tm in + let tyvno = ref (Char.code 'A' - 1) in + let ins = List.map (fun x -> incr tyvno; (mk_vartype (String.make 1 (Char.chr !tyvno)),x)) tvs in + inst ins tm +;; + +let retyvar0 tm = + let tvs = type_vars_in_term tm in + let ins = List.map (fun x -> (mk_vartype "A",x)) tvs in + inst ins tm +;; + +let get_symbols tm = + let cns = find_terms (fun x -> is_const x) tm in + let names = subtract (setify (map (o fst dest_const) cns)) ["!";"?";"/\\";"\\/";"==>"] in + let tys = funtys_of_tm tm in +(* let subs0 = get_subterms tm prfun0 in + let subss = get_subterms tm prfun in*) + let subst = get_subterms (retyvar tm) prfunt in +(* let subsd = get_subterms tm prfunt in + let subsn = get_subterms tm prfunnt in*) +(* let r0 = List.rev_append tys (List.rev_append names subs0) in + let rs = List.rev_append tys (List.rev_append names subss) in*) + let rt = List.rev_append tys (List.rev_append names subst) in +(* let rd = List.rev_append tys (List.rev_append names subsd) in + let rn = List.rev_append tys (List.rev_append names subsn) in + (r0, rs, rt, rd, rn)*) + rt +;; + +(*let get_symbolst tm = let (_,_,r,_,_) = get_symbols tm in r;;*) + +let name2pairs acc (name, th) = + if is_conj (concl th) then + let fold_fun (no, acc) th = (no + 1, (name ^ "_conjunct" ^ (string_of_int no), th) :: acc) in + snd (List.fold_left fold_fun (0, acc) (cONJUNCTS th)) + else (name, th) :: acc +;; + +let name2pairsconjs acc (name, th) = + if is_conj (concl th) then + let fold_fun (no, acc) th = (no + 1, (name ^ "_conjunct" ^ (string_of_int no), th) :: acc) in + (name, th) :: snd (List.fold_left fold_fun (0, acc) (cONJUNCTS th)) + else (name, th) :: acc +;; + +let conjregex = Str.regexp "_conjunct";; +let best_name l = + if List.length l = 1 then List.hd l else + let notnew = List.filter (fun s -> String.length s < 6 or String.sub s 0 6 <> "NEWDEP") l in + let l = if List.length notnew > 0 then notnew else l in + let nodash = List.filter (fun s -> s <> "-") l in + let l = if List.length nodash > 0 then nodash else l in + let nodot = List.filter (fun s -> not (String.contains s '.')) l in + let l = if List.length nodot > 0 then nodot else l in + if List.length l = 1 then List.hd l else + let nocon = List.filter (fun s -> try ignore (Str.search_forward conjregex s 0); + false with Not_found -> true) l in + let l = if List.length nocon > 0 then nocon else l in + List.hd (List.sort compare l) +;; + +let write_theorems () = + let hash = Hashtbl.create 17000 in + let all_thms = List.fold_left name2pairsconjs [] !theorems in + List.iter (fun (a, b) -> Hashtbl.add hash (dest_thm b) a) all_thms; + let names = Hashtbl.create 17000 in + Hashtbl.iter (fun k _ -> + if Hashtbl.mem names k then () else Hashtbl.add names k (best_name (Hashtbl.find_all hash k))) hash; + let thms = Hashtbl.fold (fun k n l -> (n, k) :: l) names [] in + let thname = try Sys.getenv "EVAL" ^ "/theorems" with _ -> "HH/theorems" in + let oc = open_out thname in + output_value oc (List.map (fun (n,t) -> (n,t)) thms); + close_out oc +;; + +let md5 x = Digest.to_hex (Digest.string (Marshal.to_string x [Marshal.No_sharing]));; +type myterm = + Myvar of string * hol_type +| Myconst of string * hol_type +| Mycomb of myterm * myterm +| Myabs of myterm * myterm;; +let rec rename_consts f t = + try let l, r = dest_abs t in mk_abs (l, rename_consts f r) with _ -> + try let l, r = dest_comb t in mk_comb (rename_consts f l, rename_consts f r) with _ -> + try let c, ty = dest_const t in Obj.magic (Myconst (f c, ty)) with _ -> t +;; +let hash_const_name = + let defs = List.rev (List.map (o (fun (a,b) -> (fst (dest_const a), rename_all (retyvar b) prfun)) (o dest_eq concl)) (definitions ())) in + let recdefs = List.map (fun (a,b) -> (a, (try let (ba,bb) = dest_comb b in let (baa,_) = dest_comb ba in let (baac,_) = dest_const baa in if baac = "@" then ba else b with _ -> b))) defs in + let hash = Hashtbl.create 300 in + let renamec n = try Hashtbl.find hash n with Not_found -> n in + let hash_term t = md5 (rename_consts renamec (rename_all (retyvar t) prfun)) in + List.iter (fun (n, t) -> Hashtbl.add hash n (hash_term t)) recdefs; + renamec +;; +let hash_const_name_concat s = s ^ hash_const_name s;; + +let hash_th th = md5 (rename_consts hash_const_name (rename_all ((o retyvar (o concl (o gEN_ALL dISCH_ALL))) th) prfunnt));; + +(* +let hash_th_b th = md5 (rename_all ((retyvar o concl o GEN_ALL o DISCH_ALL) th) prfunnt);; +let thms = List.fold_left name2pairsconjs [] !theorems;; +let thhs = List.map (fun (_,th) -> dest_thm th, hash_th th) thms;; +let hash = Hashtbl.create 17000;; +List.iter (fun (a, b) -> Hashtbl.add hash (hash_th_b b) a) thms;; +let thms = List.fold_left name2pairsconjs [] !theorems;; +let thhs = List.map (fun (_,th) -> dest_thm th, hash_th th) thms;; +let names = Hashtbl.create 17000;; +Hashtbl.iter (fun k _ -> + if Hashtbl.mem names k then () else + Hashtbl.add names k (best_name (Hashtbl.find_all hash k))) hash;;#g* +let naname2 = try Sys.getenv "EVAL" ^ "/hashnamesnoconst" with _ -> "HH/hashnamesnoconst";; +let oc = open_out naname2;; +Hashtbl.iter (fun k v -> Printf.fprintf oc "%s %s\n" k v) names;; +close_out oc;; +*) + +let get_hashes () = + theorems := List.filter (fun (x,_) -> x <> "happ_def" && x <> "happ_conv_th") !theorems; + let thms = List.fold_left name2pairsconjs [] !theorems in + let hash = Hashtbl.create 17000 in + List.iter (fun (a, b) -> Hashtbl.add hash (hash_th b) a) thms; + let names = Hashtbl.create 17000 in + Hashtbl.iter (fun k _ -> + if Hashtbl.mem names k then () else + Hashtbl.add names k (best_name (Hashtbl.find_all hash k))) hash; + names;; + +(* +let write_hashes () = + theorems := List.filter (fun (x,_) -> x <> "happ_def" && x <> "happ_conv_th") !theorems; + let thms = List.fold_left name2pairsconjs [] !theorems in + let thhs = List.map (fun (_,th) -> dest_thm th, hash_th th) thms in + let hsname = try Sys.getenv "EVAL" ^ "/hashes" with _ -> "HH/hashes" in + let oc = open_out hsname in + output_value oc (setify thhs); + close_out oc; + let names = get_hashes () in + let naname = try Sys.getenv "EVAL" ^ "/hashnames" with _ -> "HH/hashnames" in + let oc = open_out naname in + Hashtbl.iter (fun k v -> Printf.fprintf oc "%s %s\n" k v) names; + close_out oc; + let coname = try Sys.getenv "EVAL" ^ "/constnames" with _ -> "HH/constnames" in + let cs = List.rev (List.filter (fun s -> s <> "happ") (List.map (fun x -> fst (dest_const (fst (dest_eq (concl x))))) (definitions ()))) in + let oc = open_out coname in + List.iter (fun c -> Printf.fprintf oc "%s %s\n" (hash_const_name c) c) cs; + close_out oc; + let hash = Hashtbl.create 10000 in + List.iter (fun (th, hs) -> Hashtbl.replace hash hs th) thhs; + let (oc0,ocs,oct,ocd,ocn,ocu) = + let hhs = (try Sys.getenv "EVAL" with _ -> "HH") ^ "/syms" in + open_out (hhs ^ "0"),open_out (hhs ^ "s"),open_out (hhs ^ "t"), + open_out (hhs ^ "d"),open_out (hhs ^ "n"),open_out (hhs ^ "u") in + let out_oc oc thn l = + os oc thn; output_char oc ':'; + if l <> [] then ( + output_char oc '\"'; + os oc (String.concat "\", \"" l); + os oc "\"\n") else output_char oc '\n' in + let out_tm (thn, (asms, gl)) = + let tm = itlist (curry mk_imp) asms gl in + let (s0,ss,st,sd,sn) = get_symbols tm in + out_oc oc0 thn (setify s0); + out_oc ocs thn (setify ss); + out_oc oct thn (setify st); + out_oc ocd thn (setify sd); + out_oc ocn thn (setify sn); + out_oc ocu thn (setify (List.concat [s0; ss; st; sn])); + in + Hashtbl.iter (fun hs th -> out_tm (hs, th)) hash; + close_out oc0; close_out ocs; close_out oct; close_out ocd; close_out ocn; close_out ocu +;; + +let write_symbols_fast () = + let hash = Hashtbl.create 17000 in + let all_thms = List.fold_left name2pairsconjs [] !theorems in + List.iter (fun (a, b) -> Hashtbl.add hash (dest_thm b) a) all_thms; + let names = Hashtbl.create 17000 in + Hashtbl.iter (fun k _ -> + if Hashtbl.mem names k then () else Hashtbl.add names k (best_name (Hashtbl.find_all hash k))) hash; + let oct = + let hhs = (try Sys.getenv "EVAL" with _ -> "HH") ^ "/syms" in open_out (hhs ^ "t") in + let out_oc oc thn l = + os oc thn; output_char oc ':'; + if l <> [] then ( + output_char oc '\"'; + os oc (String.concat "\", \"" l); + os oc "\"\n") else output_char oc '\n' in + let out_tm (thn, th) = + let (asms, gl) = dest_thm th in + let tm = itlist (curry mk_imp) asms gl in + let (s0,ss,st,sd,_) = get_symbols tm in + out_oc oct thn st; + in + List.iter out_tm all_thms; + close_out oct; + let conjs = List.filter (fun (_, th) -> is_conj (concl th)) all_thms in + let cname = try Sys.getenv "EVAL" ^ "/conjs" with _ -> "HH/conjs" in + let oc = open_out cname in + let iter_fun (n, th) = + let (asms,gl) = dest_thm th in + let gls = List.map (fun x -> (asms, x)) (conjuncts gl) in + let ns = setify (List.map (Hashtbl.find names) gls) in + os oc n; os oc ":"; os oc (String.concat " " ns); os oc "\n" + in + List.iter iter_fun conjs; + close_out oc +;; + +let write_symbols () = + let hash = Hashtbl.create 17000 in + let all_thms = List.fold_left name2pairsconjs [] !theorems in + List.iter (fun (a, b) -> Hashtbl.add hash (dest_thm b) a) all_thms; + let names = Hashtbl.create 17000 in + Hashtbl.iter (fun k _ -> + if Hashtbl.mem names k then () else Hashtbl.add names k (best_name (Hashtbl.find_all hash k))) hash; + let thms = Hashtbl.fold (fun k n l -> (n, k) :: l) names [] in + let (oc0,ocs,oct,ocd,ocu) = + let hhs = (try Sys.getenv "EVAL" with _ -> "HH") ^ "/syms" in + open_out (hhs ^ "0"),open_out (hhs ^ "s"),open_out (hhs ^ "t"), + open_out (hhs ^ "d"),open_out (hhs ^ "u") in + let out_oc oc thn l = + os oc thn; output_char oc ':'; + if l <> [] then ( + output_char oc '\"'; + os oc (String.concat "\", \"" l); + os oc "\"\n") else output_char oc '\n' in + let out_tm (thn, (asms, gl)) = + let tm = itlist (curry mk_imp) asms gl in + let (s0,ss,st,sd,_) = get_symbols tm in + out_oc oc0 thn s0; + out_oc ocs thn ss; + out_oc oct thn st; + out_oc ocd thn sd; + out_oc ocu thn (setify (List.concat [s0; ss; st])); + in + List.iter out_tm thms; + close_out oc0; close_out ocs; close_out oct; close_out ocd; close_out ocu; + let thname = try Sys.getenv "EVAL" ^ "/theorems" with _ -> "HH/theorems" in + let oc = open_out thname in + output_value oc (List.map (fun (n,t) -> (n,t)) thms); + close_out oc; +(* let names2 = Hashtbl.create 17000 in + Hashtbl.iter (fun k v -> Hashtbl.replace names2 (dest_thm k) v) names;*) + let conjs = List.filter (fun (_, (_,th)) -> is_conj th) thms in + let cname = try Sys.getenv "EVAL" ^ "/conjs" with _ -> "HH/conjs" in + let oc = open_out cname in + let iter_fun (n, (asms,gl)) = + let gls = List.map (fun x -> (asms, x)) (conjuncts gl) in + let ns = setify (List.map (Hashtbl.find names) gls) in + os oc n; os oc ":"; os oc (String.concat " " ns); os oc "\n" + in + List.iter iter_fun conjs; + close_out oc +;; +*) diff --git a/src/holyhammer/hh/hh1/hh_tac.ml b/src/holyhammer/hh/hh1/hh_tac.ml new file mode 100644 index 0000000000..b7ef95a2a5 --- /dev/null +++ b/src/holyhammer/hh/hh1/hh_tac.ml @@ -0,0 +1,395 @@ +(* Tactics to transform a problem to TPTP format. *) + +open Lib;; +open Hl_parser;; +open Tactics;; +open Simp;; +open Basics;; +open Drule;; +open Fusion;; +open Bool;; +open Equal;; +(*open Theorems;;*) + +(* Given a predicate as an argument of another predicate, the + conversion pRED_ARG_CONV changes it to an equivalent expression + that has the predicate only at top level, so it can be encoded + as tPTP; for example: + P(!x. Q x) Is rewritten to ?v. (v <=> !x. Q x) /\ P v *) +let pRED_ARG_THM = Sequent ([], parse_term "!f a. f a <=> (?v. (v <=> a) /\\ f v)");; + +let must_pred tm = + is_forall tm or is_exists tm or is_conj tm or is_disj tm or + is_imp tm or is_eq tm or is_neg tm or is_abs tm;; + +let rec pRED_ARG_TM build_tm t = + if must_pred t then + let v = (parse_term "dumvar:bool") in + bETA_RULE (sPEC t (sPEC (mk_abs (v, build_tm v)) pRED_ARG_THM)) + else + let f, a = dest_comb t in + if find_terms must_pred a <> [] then + let build_tm subt = build_tm (mk_comb (f, subt)) in + pRED_ARG_TM build_tm a + else + let build_tm subt = build_tm (mk_comb (subt, a)) in + pRED_ARG_TM build_tm f +;; + +let rec pRED_ARG_CONV tm = + if is_forall tm or is_exists tm then bINDER_CONV pRED_ARG_CONV tm else + if is_conj tm or is_disj tm or is_imp tm then bINOP_CONV pRED_ARG_CONV tm else + if is_neg tm then rAND_CONV pRED_ARG_CONV tm else + if is_eq tm then + let l, r = dest_eq tm in + if must_pred l or must_pred r then bINOP_CONV pRED_ARG_CONV tm + else + if find_terms must_pred l <> [] then + let build_tm subt = mk_eq (subt, r) in + (tHENC (pRED_ARG_TM build_tm) pRED_ARG_CONV) l + else if find_terms must_pred r <> [] then + let build_tm subt = mk_eq (l, subt) in + (tHENC (pRED_ARG_TM build_tm) pRED_ARG_CONV) r + else rEFL tm + else if find_terms must_pred tm = [] then rEFL tm + else let l, r = dest_comb tm in + if find_terms must_pred l <> [] then + let build_tm subt = mk_comb (subt, r) in + (tHENC (pRED_ARG_TM build_tm) pRED_ARG_CONV) l + else if find_terms must_pred r <> [] then + let build_tm subt = mk_comb (l, subt) in + (tHENC (pRED_ARG_TM build_tm) pRED_ARG_CONV) r + else rEFL tm;; + +(* Depth conversion that runs at most once per depth *) +let rec tOP_SWEEP_QCONV conv tm = + let cOMB_QCONV conv tm = + let l,r = dest_comb tm in + try let th1 = conv l in + try let th2 = conv r in mK_COMB(th1,th2) + with Failure _ -> aP_THM th1 r + with Failure _ -> aP_TERM l (conv r) in + let sUB_QCONV conv tm = + if is_abs tm then aBS_CONV conv tm + else cOMB_QCONV conv tm in + let tHENQC conv1 conv2 tm = + try let th1 = conv1 tm in + try let th2 = conv2(rand(concl th1)) in tRANS th1 th2 + with Failure _ -> th1 + with Failure _ -> conv2 tm in + tHENQC (tRY_CONV conv) (sUB_QCONV (tOP_SWEEP_QCONV conv)) tm;; + +(* Removes simple lambda-equalities before doing proper lambda-lifting *) +let eLIM_LAMBDA_EQ tm = + let (l, r) = dest_eq tm in + (if is_abs l or is_abs r then + (tHENC (oNCE_REWRITE_CONV [fUN_EQ_THM]) (tOP_DEPTH_CONV bETA_CONV)) + else aLL_CONV) tm;; + +(* fOL_TAC2 Tries to do more intelligent folification than fOL_TAC: + - better computation of minimum needed arguments + - does not use identity of the system to work with theorems that talk about I. + - handles both the assumptions and the goal + *) +let replace_smaller_assoc key newmin l = + if List.mem_assoc key l then + if newmin < assoc key l then + (key, newmin) :: (List.remove_assoc key l) + else l + else (key, newmin) :: l;; + +let rec fold_apps fn bnd tm sofar = + try let l,r = try dest_forall tm with Failure _ -> + try dest_exists tm with Failure _ -> + dest_abs tm in + fold_apps fn (l :: bnd) r sofar + with Failure _ -> try + let l,r = try dest_conj tm with Failure _ -> + try dest_disj tm with Failure _ -> + try dest_eq tm with Failure _ -> + dest_imp tm in + fold_apps fn bnd r (fold_apps fn bnd l sofar) + with Failure _ -> try + let tm = dest_neg tm in fold_apps fn bnd tm sofar + with Failure _ -> + let hop, args = strip_comb tm in + let sofar = if is_abs hop then fold_apps fn bnd hop sofar else sofar in + itlist (fold_apps fn bnd) args (fn bnd hop args sofar);; + +let get_minarg tm sofar = + let get_minarg_fold bnd hop args (cmin, vmin) = + let len = List.length args in + if is_var hop then if mem hop bnd then (cmin, vmin) + else (cmin, replace_smaller_assoc (fst (dest_var hop)) len vmin) + else (replace_smaller_assoc (fst (dest_const hop)) len cmin, vmin) in + fold_apps get_minarg_fold [] tm sofar;; + +(*let happ_def = new_definition (parse_term "(happ : ((A -> B) -> A -> B)) = I");;*) +let happ_conv_th = Sequent ([],parse_term "!(f:A->B) x. f x = happ f x");; + +let happ_conv = rEWR_CONV happ_conv_th;; +let rec happ_n_conv n tm = + if n = 1 then happ_conv tm + else (tHENC (rATOR_CONV (happ_n_conv (n - 1))) happ_conv) tm;; +let fol_conv_assoc op (cmin,vmin) = + if is_const op then assoc (fst (dest_const op)) cmin else + if is_var op then try assoc (fst (dest_var op)) vmin with _ -> 0 else failwith "fol_conv_assoc";; +let rec fOL_CONV ((cmin,vmin) as data) tm = + try let l,r = try dest_forall tm with _ -> try dest_exists tm with _ -> dest_abs tm in + bINDER_CONV (fOL_CONV (cmin, List.remove_assoc (fst (dest_var l)) vmin)) tm + with _ -> + if is_conj tm or is_disj tm or is_imp tm or is_eq tm then bINOP_CONV (fOL_CONV data) tm else + if is_neg tm then rAND_CONV (fOL_CONV data) tm else + let op,args = strip_comb tm in + let th = rev_itlist (ccc (curry mK_COMB)) (map (fOL_CONV data) args) (rEFL op) in + let tm' = rand(concl th) in + let n = List.length args - fol_conv_assoc op data in + if n = 0 then th + else tRANS th (happ_n_conv n tm');; + +let get_mindata (asms, gl) = + let (cmin, vmin) = itlist get_minarg (gl :: asms) ([],[]) in + let correct_min (c, min1) = + let ty = get_const_type c in + let min2 = List.length (fst (splitlist dest_fun_ty ty)) in + (c, min min1 min2) + in + let cmin = map correct_min cmin in (cmin, vmin) +;; + +let fOL_CONV2 tm = + let mindata = get_mindata ([], tm) in + fOL_CONV mindata tm;; + +let fOL_TAC2 ((ps,gl) as gs) = + let mindata = get_mindata (map (o concl snd) ps, gl) in + (cONV_TAC (fOL_CONV mindata) ++++ + rULE_ASSUM_TAC (cONV_RULE (fOL_CONV mindata))) gs;; + +(* Combined fOLification *) +let fOL_IT_TAC = cONV_TAC pRED_ARG_CONV ++++ rULE_ASSUM_TAC(cONV_RULE pRED_ARG_CONV) ++++ fOL_TAC2;; + +(* Escape characters not accepted by the TPTP format. *) +let escape_to_hex s = + let n = ref 0 in + for i = 0 to String.length s - 1 do + n := !n + (match String.unsafe_get s i with + 'a'|'b'|'c'|'d'|'e'|'f'|'g'|'h'|'i'|'j'|'k'|'l'|'m'|'n'|'o'|'p'|'q'|'r'|'s'|'t'|'u'|'v'|'w'|'x'|'y'|'z' + |'A'|'B'|'C'|'D'|'E'|'F'|'G'|'H'|'I'|'J'|'K'|'L'|'M'|'N'|'O'|'P'|'Q'|'R'|'S'|'T'|'U'|'V'|'W'|'X'|'Y'|'Z' + |'0'|'1'|'2'|'3'|'4'|'5'|'6'|'7'|'8'|'9' -> 1 + |'_' -> 2 | _ -> 3) + done; + if !n = String.length s then s else begin + let s' = String.create !n in + n := 0; + for i = 0 to String.length s - 1 do begin + match String.unsafe_get s i with + ('a'|'b'|'c'|'d'|'e'|'f'|'g'|'h'|'i'|'j'|'k'|'l'|'m'|'n'|'o'|'p'|'q'|'r'|'s'|'t'|'u'|'v'|'w'|'x'|'y'|'z' + |'A'|'B'|'C'|'D'|'E'|'F'|'G'|'H'|'I'|'J'|'K'|'L'|'M'|'N'|'O'|'P'|'Q'|'R'|'S'|'T'|'U'|'V'|'W'|'X'|'Y'|'Z' + |'0'|'1'|'2'|'3'|'4'|'5'|'6'|'7'|'8'|'9' as c) -> String.unsafe_set s' !n c + | '_' -> String.unsafe_set s' !n '_'; incr n; String.unsafe_set s' !n '_' + | c -> let c = Char.code c in + String.unsafe_set s' !n '_'; incr n; + String.unsafe_set s' !n (Printf.sprintf "%x" (c / 16)).[0]; incr n; + String.unsafe_set s' !n (Printf.sprintf "%x" (c mod 16)).[0] + end; incr n; done; + s' + end +;; + +let add_prime s = "\'" ^ s ^ "\'" + +let is_lowercase c = + let i = Char.code c in i >= Char.code 'a' && i <= Char.code 'z' +let is_uppercase c = + let i = Char.code c in i >= Char.code 'A' && i <= Char.code 'Z' +let is_letter c = + (is_lowercase c) or (is_uppercase c) + +(* We don't have complete control over the names of + the type variables so we escape them completely *) +let escape_var s = + let s1 = escape_to_hex s in + if is_letter s1.[0] + then String.capitalize s1 + else "V" ^ s1 + +let escape_obj s = + if (s.[0] = '\'') or (is_lowercase s.[0]) then s else add_prime s + + + +(* Less explosive version of pOLY_ASSUME_TAC *) +let rec fold_cs fn tm sofar = + try let l,r = try dest_forall tm with Failure _ -> + try dest_exists tm with Failure _ -> + dest_abs tm in fold_cs fn r sofar + with Failure _ -> try + let l,r = try dest_conj tm with Failure _ -> + try dest_disj tm with Failure _ -> + dest_imp tm in + fold_cs fn r (fold_cs fn l sofar) + with Failure _ -> try + let tm = dest_neg tm in fold_cs fn tm sofar + with Failure _ -> if is_eq tm then (* eq is last *) + let (c, [l; r]) = strip_comb tm in + fn (dest_const c) (fold_cs fn r (fold_cs fn l sofar)) + else try + let l, r = dest_comb tm in + fold_cs fn r (fold_cs fn l sofar) + with Failure _ -> + if is_var tm then sofar else fn (dest_const tm) sofar;; + + +let insts_as gcs tm = + let fold_fun (n, ty) insts = + try + let tys = List.assoc n gcs in + let inst_fun gty inst = + try [type_match ty gty inst] with _ -> [] in + let gty_fun gty = List.concat (map (inst_fun gty) insts) in + let ret = List.concat (map gty_fun tys) in + if ret = [] then insts else ret + with Not_found -> insts + in + fold_cs fold_fun tm [[]] +;; + +let rec uniq' eq = fun l -> + match l with + x::(y::_ as t) -> let t' = uniq' eq t in + if eq x y then t' else + if t'==t then l else x::t' + | _ -> l;; + +let polymorph gcs th = + let tyins = insts_as gcs (concl th) in + let setify' le eq s = uniq' eq (sort le s) in + let ths' = + setify' (fun th th' -> dest_thm th <= dest_thm th') + equals_thm (mapfilter (ccc iNST_TYPE th) tyins) in + if ths' = [] then ([th]) + else ths';; + +let gl_constants tms = + let fold_fun (n, ty) cs = + try (n, (insert ty (List.assoc n cs))) :: (List.remove_assoc n cs) + with Not_found -> (n, [ty]) :: cs + in + let consts = itlist (fun tm sofar -> fold_cs fold_fun tm sofar) tms [] in + filter (fun (n, tys) -> List.length (tyvars (get_const_type n)) > 0) (setify consts) +;; + +let pOLY_ASSUME_TAC names ths (asl,w as gl) = + let gcs = gl_constants (w :: map (o concl snd) asl) in + let ths = map (polymorph gcs) ths in + let ths2 = List.combine names ths in + let map_fun (n, ts) = + if List.length ts = 1 then [(n, List.hd ts)] else + let fold_fun (cno, clst) t = + (cno + 1, (n ^ "_monomorphized" ^ string_of_int cno, t) :: clst) in + snd (List.fold_left fold_fun (0, []) ts) + in + let ths3 = List.map map_fun ths2 in + let ths4 = List.concat ths3 in +(* let names, ths' = List.split ths4 in*) + mAP_EVERY (fun (n, th) -> lABEL_TAC (escape_obj n) th) ths4 gl;; + +let lABEL_ASSUME_TAC names ths = + mAP_EVERY (fun (n, th) -> lABEL_TAC (escape_obj n) th) (zip names ths);; + +(* lAMBDA_ELIM_CONV2 does less explosive lambda-lifting than lAMBDA_ELIM_CONV + for universally quantified theorems; all the quantified variables do not + need to be arguments of function that replaces the lambda expression. *) +let genvarsmall,genvarreset = + let gcounter = ref 0 in + ((fun ty -> let count = !gcounter in + (gcounter := count + 1; + mk_var("_"^(string_of_int count),ty))), + fun () -> gcounter := 0);; + +let rIGHT_BETAS = + rev_itlist (fun a -> o (cONV_RULE (rAND_CONV bETA_CONV)) (ccc aP_THM a));; + +let lAMBDA_ELIM_CONV = + let hALF_MK_ABS_CONV = + let pth = Sequent ([], parse_term "(s = \\x. t x) <=> (!x. s x = t x)") in + let rec conv vs tm = + if vs = [] then rEFL tm else + (tHENC (gEN_REWRITE_CONV iii [pth]) (bINDER_CONV(conv (tl vs)))) tm in + conv in + let rec find_lambda tm = + if is_abs tm then tm + else if is_var tm or is_const tm then failwith "find_lambda" + else if is_abs tm then tm else + if is_forall tm or is_exists tm or is_uexists tm + then find_lambda (body(rand tm)) else + let l,r = dest_comb tm in + try find_lambda l with Failure _ -> find_lambda r in + let rec eLIM_LAMBDA conv tm = + try conv tm with Failure _ -> + if is_abs tm then aBS_CONV (eLIM_LAMBDA conv) tm + else if is_var tm or is_const tm then rEFL tm else + if is_forall tm or is_exists tm or is_uexists tm + then bINDER_CONV (eLIM_LAMBDA conv) tm + else cOMB_CONV (eLIM_LAMBDA conv) tm in + let aPPLY_PTH = + let pth = Sequent ([], parse_term "(!a. (a = c) ==> (P = Q a)) ==> (P <=> !a. (a = c) ==> Q a)") in + mATCH_MP pth in + let lAMB1_CONV tm = + let atm = find_lambda tm in + let v,bod = dest_abs atm in + let vs = frees atm in + let vs' = vs @ [v] in + let aatm = list_mk_abs(vs,atm) in + let f = genvarsmall(type_of aatm) in + let eq = mk_eq(f,aatm) in + let th1 = sYM(rIGHT_BETAS vs (aSSUME eq)) in + let th2 = eLIM_LAMBDA(gEN_REWRITE_CONV iii [th1]) tm in + let th3 = aPPLY_PTH (gEN f (dISCH_ALL th2)) in + cONV_RULE(rAND_CONV(bINDER_CONV(lAND_CONV (hALF_MK_ABS_CONV vs')))) th3 in + let rec conv tm = + try (tHENC lAMB1_CONV conv) tm with Failure _ -> rEFL tm in + conv;; + + +let lAMBDA_ELIM_CONV2 = + let hALF_MK_ABS_CONV = + let pth = Sequent ([], parse_term "(s = \\x. t x) <=> (!x. s x = t x)") in + let rec conv vs tm = + if vs = [] then rEFL tm else + (tHENC (gEN_REWRITE_CONV iii [pth]) (bINDER_CONV(conv (tl vs)))) tm in + conv in + let rec find_lambda tm = + if is_abs tm then tm + else if is_var tm or is_const tm then failwith "find_lambda" + else if is_abs tm then tm else + if is_forall tm or is_exists tm or is_uexists tm + then find_lambda (body(rand tm)) else + let l,r = dest_comb tm in + try find_lambda l with Failure _ -> find_lambda r in + let rec eLIM_LAMBDA conv tm = + try conv tm with Failure _ -> + if is_abs tm then aBS_CONV (eLIM_LAMBDA conv) tm + else if is_var tm or is_const tm then rEFL tm else + if is_forall tm or is_exists tm or is_uexists tm + then bINDER_CONV (eLIM_LAMBDA conv) tm + else cOMB_CONV (eLIM_LAMBDA conv) tm in + let aPPLY_PTH = + let pth = Sequent ([], parse_term "(!a. (a = c) ==> (P = Q a)) ==> (P <=> !a. (a = c) ==> Q a)") in + mATCH_MP pth in + let lAMB2_CONV tm = + let atm = find_lambda tm in + let v,bod = dest_abs atm in + let vs = subtract (frees atm) (frees tm) in + let vs' = vs @ [v] in + let aatm = list_mk_abs(vs,atm) in + let f = genvarsmall(type_of aatm) in + let eq = mk_eq(f,aatm) in + let th1 = sYM(rIGHT_BETAS vs (aSSUME eq)) in + let th2 = eLIM_LAMBDA(gEN_REWRITE_CONV iii [th1]) tm in + let th3 = aPPLY_PTH (gEN f (dISCH_ALL th2)) in + cONV_RULE(rAND_CONV(bINDER_CONV(lAND_CONV (hALF_MK_ABS_CONV vs')))) th3 in + let rec conv tm = + try (tHENC lAMB2_CONV conv) tm with Failure _ -> rEFL tm in + conv;; diff --git a/src/holyhammer/hh/hh1/hh_write.ml b/src/holyhammer/hh/hh1/hh_write.ml new file mode 100644 index 0000000000..74c9581aac --- /dev/null +++ b/src/holyhammer/hh/hh1/hh_write.ml @@ -0,0 +1,696 @@ +(* hh_write module: write a given problem to various TPTP formats: + fof, tff1, thf0 and full thf *) + +open Lib;; +open Fusion;; +open Basics;; +open Bool;; +open Equal;; +open Hl_parser;; +open Tactics;; +open Simp;; +(*open Theorems;;*) +open Hh_symbols;; +open Hh_tac;; + +module Sm = Map.Make(struct type t = string let compare = compare end);; +module Tmm = Map.Make(struct type t = term let compare = compare end);; + +let variant_name_hash s used = + try let i = Hashtbl.find used s in + let rec new_name s i = + let si = s ^ string_of_int i in + if Hashtbl.mem used si then new_name s (i + 1) + else (Hashtbl.replace used si 0; Hashtbl.replace used si (i + 1); si) + in new_name s i + with Not_found -> Hashtbl.replace used s 0; s + +let variant_name_map s used = + try let i = Sm.find s used in + let rec new_name s i = + let si = s ^ string_of_int i in + if Sm.mem si used then new_name s (i + 1) + else (si, Sm.add s (i + 1) (Sm.add si 0 used)) + in new_name s i + with Not_found -> (s, Sm.add s 0 used) + +let print_vartype t = + let s = String.copy (dest_vartype t) in + escape_var s + +let os = output_string;; +let rec oiter oc fn sep = function + [] -> () + | [e] -> fn oc e + | h :: t -> fn oc h; os oc sep; oiter oc fn sep t;; + +let string_list_of_string str sep = + let rec slos_aux str ans = + if str = "" then ans else + try + let first_space = String.index str sep in + if first_space = 0 then + slos_aux (String.sub str 1 (String.length str - 1)) ans + else + slos_aux + (String.sub str (first_space + 1)(String.length str - 1 - first_space)) + ((String.sub str 0 (first_space)) :: ans) + with + Not_found -> + List.rev (str :: ans) + in slos_aux str [] +;; + +let rec chop_listnok acc n = function + [] -> (List.rev acc, []) + | h :: t -> if n = 0 then (List.rev acc, h :: t) else chop_listnok (h :: acc) (n - 1) t;; + +let rec chop_listn acc n = function + [] -> failwith "chop_listn" + | h :: t -> if n = 0 then (List.rev acc, h :: t) else chop_listn (h :: acc) (n - 1) t;; + +(* The HO-funtype `:(A -> B) list` will be lost *) +let name_tscs_mono_fold ho (tys, cs, used) tm () = + let ctys = if not ho then [type_of tm] else striplist dest_fun_ty (type_of tm) in + let rec name_ty ty = + if Hashtbl.mem tys ty then () else + let n = + if is_type ty then + let s, stys = dest_type ty in + List.iter name_ty stys; + String.concat "" (escape_obj s :: (map (fun x -> Hashtbl.find tys x) stys)) + else print_vartype ty in + let n = variant_name_hash n used in Hashtbl.replace tys ty n + in + List.iter name_ty ctys; + if Hashtbl.mem cs tm or is_var tm then () else + let n = escape_obj (fst (dest_const tm)) in + let n = variant_name_hash n used in + Hashtbl.replace cs tm n +;; + +let name_tscs_poly_fold (tys, cs, used) tm () = + let rec name_ty ty = + if is_type ty then + let s, stys = dest_type ty in + (if Hashtbl.mem tys s then () else + Hashtbl.replace tys s (variant_name_hash (escape_obj s) used)); + List.iter name_ty stys; + else + let s = dest_vartype ty in + (if Hashtbl.mem tys s then () else + Hashtbl.replace tys s (variant_name_hash (print_vartype ty) used)); + in + name_ty (type_of tm); + if is_var tm then + let s = fst (dest_var tm) in + if Hashtbl.mem cs ("`" ^ s) then () else + let n = variant_name_hash (escape_obj s) used in + Hashtbl.replace cs ("`" ^ s) n + else + let s, _ = dest_const tm in + if Hashtbl.mem cs s then () else + let n = variant_name_hash (escape_obj s) used in + Hashtbl.replace cs s n +;; + +let rec fold_cs_vs fn tm sofar = + try let l,r = try dest_forall tm with Failure _ -> + try dest_exists tm with Failure _ -> + dest_abs tm in + fold_cs_vs fn r (fold_cs_vs fn l sofar) + with Failure _ -> try + let l,r = try dest_conj tm with Failure _ -> + try dest_disj tm with Failure _ -> + try dest_eq tm with Failure _ -> + dest_imp tm in + fold_cs_vs fn r (fold_cs_vs fn l sofar) + with Failure _ -> try + let tm = dest_neg tm in fold_cs_vs fn tm sofar + with Failure _ -> try + let l, r = dest_comb tm in + fold_cs_vs fn r (fold_cs_vs fn l sofar) + with Failure _ -> fn tm sofar;; + +let name_tscs_mono ho data tm = + fold_cs_vs (name_tscs_mono_fold ho data) tm ();; +let name_tscs_poly data tm = + fold_cs_vs (name_tscs_poly_fold data) tm ();; + +let is_fun_ty = function Tyapp("fun",[ty1;ty2]) -> true | _ -> false;; + +let rec oty_mono ts order oc ty = + if is_fun_ty ty then + match order with + 0 -> os oc (Hashtbl.find ts ty) + | 1 -> + let t1, t2 = dest_fun_ty ty in + os oc "("; oty_mono ts 0 oc t1; os oc " > "; oty_mono ts 0 oc t2; os oc ")" + | _ -> + let args, res = splitlist dest_fun_ty ty in + os oc "("; oiter oc (oty_mono ts (order - 1)) " > " args; os oc " > "; + oty_mono ts (order - 1) oc res; os oc ")" + else os oc (Hashtbl.find ts ty);; + +let rec oty_poly ts order oc ty = + (* try is needed for constant types in TFF *) + if is_vartype ty then os oc (try Hashtbl.find ts (dest_vartype ty) with Not_found -> print_vartype ty) else + let pr_br ty = + let (s, tys) = dest_type ty in + if order < 0 then begin + if tys <> [] then os oc "("; + os oc (Hashtbl.find ts s); + List.iter (fun ty -> os oc " @ "; oty_poly ts order oc ty) tys; + if tys <> [] then os oc ")"; + end else begin + os oc (Hashtbl.find ts s); + if tys = [] then () else (os oc "("; oiter oc (oty_poly ts 0) "," tys; os oc ")") + end in + if is_fun_ty ty then + (match order with + 0 -> pr_br ty + | 1 -> + let args, res = splitlist dest_fun_ty ty in + (match args with + [a] -> oty_poly ts 0 oc a; os oc " > "; oty_poly ts 0 oc res + | _ -> os oc "("; oiter oc (oty_poly ts 0) " * " args; os oc " > "; oty_poly ts 0 oc res) + | _ -> + let args, res = splitlist dest_fun_ty ty in + os oc "("; oiter oc (oty_poly ts (order - 1)) " > " args; os oc " > "; + oty_poly ts (order - 1) oc res; os oc ")") + else pr_br ty;; + +let inst_const tm = + if is_const tm then + let (n, ty) = dest_const tm in + let gty = get_const_type n in + let inst = type_match gty ty [] in + let rinst = map (fun (a, b) -> (b, a)) inst in + let tvs = tyvars gty in + map (fun x -> assoc x rinst) tvs + else [];; + +let rec tff_tm oc (bnd, used) cs ts tm = + if is_var tm then begin + os oc (try Tmm.find tm bnd with Not_found -> Hashtbl.find cs ("`" ^ (o fst dest_var) tm)) + end else begin + let (f, args) = strip_comb tm in + os oc (Hashtbl.find cs (fst (dest_const f))); + let insts = inst_const f in + if args <> [] or insts <> [] then begin + os oc "("; + oiter oc (fun oc ty -> oty_poly ts 0 oc ty) "," insts; + (if args <> [] && insts <> [] then os oc "," else ()); + oiter oc (fun oc e -> tff_tm oc (bnd, used) cs ts e) "," args; + os oc ")" + end + end;; + +let bindv v (bnd, used) = + if Tmm.mem v bnd then (bnd, used) else + let n = escape_var (fst (dest_var v)) in + let (n, used) = variant_name_map n used in + (Tmm.add v n bnd, used) +;; + +let pr_bs_poly oc order bnd ts bs = + (os oc "["; oiter oc (fun oc v -> os oc (Tmm.find v bnd); os oc ":"; oty_poly ts order oc (type_of v)) "," bs; + os oc "]:");; + +let rec tff_pred oc (bnd, used) cs ts tm = + if is_forall tm then + let bs, bod = strip_forall tm in + let (bnd, used) = rev_itlist bindv bs (bnd, used) in + os oc "!"; pr_bs_poly oc 0 bnd ts bs; tff_pred oc (bnd, used) cs ts bod + else if is_exists tm then + let bs, bod = strip_exists tm in + let (bnd, used) = rev_itlist bindv bs (bnd, used) in + os oc "?"; pr_bs_poly oc 0 bnd ts bs; tff_pred oc (bnd, used) cs ts bod + else if is_conj tm then + (os oc "("; oiter oc (fun oc e -> tff_pred oc (bnd, used) cs ts e) " & " (conjuncts tm); os oc ")") + else if is_disj tm then + (os oc "("; oiter oc (fun oc e -> tff_pred oc (bnd, used) cs ts e) " | " (disjuncts tm); os oc ")") + else if is_imp tm then let l, r = dest_imp tm in + (os oc "("; tff_pred oc (bnd, used) cs ts l; os oc " => "; + tff_pred oc (bnd, used) cs ts r; os oc ")") + else if is_neg tm then + let t = dest_neg tm in (os oc "~ ("; tff_pred oc (bnd,used) cs ts t; os oc ")") + else if is_eq tm then let l,r = dest_eq tm in + if must_pred l or must_pred r then + (os oc "("; tff_pred oc (bnd, used) cs ts l; os oc " <=> "; + tff_pred oc (bnd, used) cs ts r; os oc ")") + else + (tff_tm oc (bnd, used) cs ts l; os oc " = "; tff_tm oc (bnd, used) cs ts r) + else + (os oc "p("; tff_tm oc (bnd, used) cs ts tm; os oc ")");; + +let tff_pred oc cs ts used_map t = + let tvs = type_vars_in_term t in + let stvs = map dest_vartype tvs in + let used_map = itlist (fun s m -> Sm.add s 0 m) stvs used_map in + (if tvs <> [] then (os oc "!["; oiter oc (fun oc e -> oty_poly ts 0 oc e; os oc " : $tType") "," tvs; os oc "]: ")); + tff_pred oc (Tmm.empty, used_map) cs ts t +;; + +let pr_bs_mono oc order bnd ts bs = + (os oc "["; oiter oc (fun oc v -> os oc (Tmm.find v bnd); os oc ":"; oty_mono ts order oc (type_of v)) "," bs; + os oc "]:");; + +let rec thf_tm oc (bnd, used) cs ts tm = + if is_forall tm then + let bs, bod = strip_forall tm in + let (bnd, used) = rev_itlist bindv bs (bnd, used) in + os oc "!"; pr_bs_mono oc (-1) bnd ts bs; thf_tm oc (bnd, used) cs ts bod + else if is_exists tm then + let bs, bod = strip_exists tm in + let (bnd, used) = rev_itlist bindv bs (bnd, used) in + os oc "?"; pr_bs_mono oc (-1) bnd ts bs; thf_tm oc (bnd, used) cs ts bod + else if is_abs tm then + let bs, bod = strip_abs tm in + let (bnd, used) = rev_itlist bindv bs (bnd, used) in + os oc "^"; pr_bs_mono oc (-1) bnd ts bs; thf_tm oc (bnd, used) cs ts bod + else if is_conj tm then + (os oc "("; oiter oc (fun oc e -> thf_tm oc (bnd, used) cs ts e) " & " (conjuncts tm); os oc ")") + else if is_disj tm then + (os oc "("; oiter oc (fun oc e -> thf_tm oc (bnd, used) cs ts e) " | " (disjuncts tm); os oc ")") + else if is_imp tm then let l, r = dest_imp tm in + (os oc "("; thf_tm oc (bnd, used) cs ts l; os oc " => "; + thf_tm oc (bnd, used) cs ts r; os oc ")") + else if is_neg tm then + let t = dest_neg tm in (os oc "~ ("; thf_tm oc (bnd,used) cs ts t; os oc ")") + else if is_eq tm then let l,r = dest_eq tm in + (os oc "("; thf_tm oc (bnd, used) cs ts l; + os oc (if type_of l = bool_ty then " <=> " else " = "); + thf_tm oc (bnd, used) cs ts r; os oc ")") + else if is_comb tm then let hop, args = strip_comb tm in + (os oc "("; oiter oc (fun oc e -> thf_tm oc (bnd, used) cs ts e) " @ " (hop :: args); os oc ")") + else if is_const tm then os oc (Hashtbl.find cs tm) + else os oc (try Tmm.find tm bnd with Not_found -> failwith "thf_tm");; + +let output_gs oc (asms, gl) = + let iter (s, thm) = os oc "% Assm ["; os oc s; os oc "]: "; os oc (lstring_of_term (concl thm)); os oc "\n" in + List.iter iter asms; + os oc "% Goal: "; os oc (lstring_of_term gl); os oc "\n";; + +let oi oc i = os oc (string_of_int i);; + +let thf_gl oc ls asms gl n = + let ts, cs, used = Hashtbl.create 20, Hashtbl.create 50, Hashtbl.create 50 in + Hashtbl.add used "lambda" 0; (* LeoII throws syntax errors with 'lambda' *) + List.iter (name_tscs_mono true (ts, cs, used)) (gl :: asms); + let ohdr s1 s2 = os oc "thf("; os oc s1; os oc ", "; os oc s2; os oc ", " in + let otl () = os oc ").\n" in + os oc "% TYPES\n"; + Hashtbl.remove ts (parse_type "bool"); + Hashtbl.iter (fun _ ty -> ohdr ty "type"; os oc ty; os oc " : $tType"; otl ()) ts; + Hashtbl.add ts (parse_type "bool") "$o"; + os oc "% CONSTS\n"; + Hashtbl.remove cs (parse_term "T"); Hashtbl.remove cs (parse_term "F"); + Hashtbl.iter (fun t s -> ohdr s "type"; os oc s; os oc " : "; oty_mono ts (-1) oc (type_of t); otl ()) cs; + Hashtbl.add cs (parse_term "T") "$true"; Hashtbl.add cs (parse_term "F") "$false"; + os oc "% AXIOMS\n"; + List.iter2 (fun n t -> ohdr n "axiom"; thf_tm oc (Tmm.empty, Sm.empty) cs ts t; otl ()) ls asms; + ohdr n "conjecture"; thf_tm oc (Tmm.empty, Sm.empty) cs ts gl; otl () +;; + +let rec thff_tm oc (bnd, used) cs ts tm = + if is_forall tm then + let bs, bod = strip_forall tm in + let (bnd, used) = rev_itlist bindv bs (bnd, used) in + os oc "!"; pr_bs_poly oc (-1) bnd ts bs; thff_tm oc (bnd, used) cs ts bod + else if is_exists tm then + let bs, bod = strip_exists tm in + let (bnd, used) = rev_itlist bindv bs (bnd, used) in + os oc "?"; pr_bs_poly oc (-1) bnd ts bs; thff_tm oc (bnd, used) cs ts bod + else if is_abs tm then + let bs, bod = strip_abs tm in + let (bnd, used) = rev_itlist bindv bs (bnd, used) in + os oc "^"; pr_bs_poly oc (-1) bnd ts bs; thff_tm oc (bnd, used) cs ts bod + else if is_conj tm then + (os oc "("; oiter oc (fun oc e -> thff_tm oc (bnd, used) cs ts e) " & " (conjuncts tm); os oc ")") + else if is_disj tm then + (os oc "("; oiter oc (fun oc e -> thff_tm oc (bnd, used) cs ts e) " | " (disjuncts tm); os oc ")") + else if is_imp tm then let l, r = dest_imp tm in + (os oc "("; thff_tm oc (bnd, used) cs ts l; os oc " => "; + thff_tm oc (bnd, used) cs ts r; os oc ")") + else if is_neg tm then + let t = dest_neg tm in (os oc "~ ("; thff_tm oc (bnd,used) cs ts t; os oc ")") + else if is_eq tm then let l,r = dest_eq tm in + (os oc "("; thff_tm oc (bnd, used) cs ts l; + os oc (if type_of l = bool_ty then " <=> " else " = "); + thff_tm oc (bnd, used) cs ts r; os oc ")") + else if is_comb tm then let hop, args = strip_comb tm in + (os oc "("; oiter oc (fun oc e -> thff_tm oc (bnd, used) cs ts e) " @ " (hop :: args); os oc ")") + else if is_const tm then begin + let insts = inst_const tm in + if insts <> [] then os oc "("; + os oc (Hashtbl.find cs (fst (dest_const tm))); + if insts <> [] then (List.iter (fun ty -> os oc " @ "; oty_poly ts (-1) oc ty) insts; os oc ")"); + end + else os oc (try Tmm.find tm bnd with Not_found -> failwith "thff_tm");; + + +let thff_pred oc used_map cs ts tm = + let tvs = type_vars_in_term tm in + (if tvs <> [] then (os oc "!["; oiter oc (fun oc e -> oty_poly ts (-1) oc e; os oc ":$tType") "," tvs; os oc "]: ")); + thff_tm oc (Tmm.empty, used_map) cs ts tm +;; + +let used_to_map h = Hashtbl.fold Sm.add h Sm.empty;; + +let otyquant oc ts tys = + if tys <> [] then begin + os oc "!>["; oiter oc (fun oc t -> os oc (print_vartype t); os oc ":$tType") + "," tys; os oc "]: " end;; + +let thff_gl oc ls asms gl = + let ts, cs, used = Hashtbl.create 20, Hashtbl.create 50, Hashtbl.create 50 in + List.iter (name_tscs_poly (ts, cs, used)) (gl :: asms); + let ohdr s1 s2 = os oc "thf("; os oc s1; os oc ", "; os oc s2; os oc ", " in + let otl () = os oc ").\n" in + os oc "% TYPES\n"; + Hashtbl.remove ts "bool"; + Hashtbl.remove ts "fun"; + Hashtbl.iter (fun t s -> + try + let ar = get_type_arity t in + ohdr t "type"; os oc s; os oc ":"; + let rec prty n = if n = 0 then os oc "$tType" else (os oc "$tType > "; prty (n - 1)) in + prty ar; otl () + with Failure _ -> ()) ts; (* Failure in get_type_arity for ` *) + Hashtbl.add ts "bool" "$o"; + os oc "% CONSTS\n"; + Hashtbl.remove cs "T"; Hashtbl.remove cs "F"; + (* only print constants and not types *) + Hashtbl.iter (fun t s -> if t.[0] <> '`' then (ohdr s "type"; os oc s; os oc " : "; + let ty = get_const_type t in + let tvs = tyvars ty in + otyquant oc ts tvs; + oty_poly ts (-1) oc ty; otl ())) cs; + Hashtbl.add cs "T" "$true"; Hashtbl.add cs "F" "$false"; + os oc "% AXIOMS\n"; + let used_map = used_to_map used in + List.iter2 (fun n t -> ohdr n "axiom"; thff_pred oc used_map cs ts t; otl ()) ls asms; + (* Something is wrong here (I may have erased something) *) + ohdr ("c") "conjecture"; thff_pred oc used_map cs ts gl; otl () +;; + + +let rec oty_isa ts oc ty = + if is_vartype ty then (os oc "'"; os oc (try Hashtbl.find ts (dest_vartype ty) + with Not_found -> print_vartype ty)) else + let (s, tys) = dest_type ty in + (if tys = [] then () else (os oc "("; oiter oc (oty_isa ts) "," tys; os oc ")")); + os oc (Hashtbl.find ts s);; + +let pr_bs_isa oc bnd ts bs = + os oc "("; + oiter oc (fun oc v -> os oc (Tmm.find v bnd); os oc "::"; oty_isa ts oc (type_of v)) ") (" bs; + os oc ").";; + +let rec otm_isa oc (bnd, used) cs ts tm = + if is_forall tm then + let bs, bod = strip_forall tm in + let (bnd, used) = rev_itlist bindv bs (bnd, used) in + os oc "(ALL"; pr_bs_isa oc bnd ts bs; otm_isa oc (bnd, used) cs ts bod; os oc ")" + else if is_exists tm then + let bs, bod = strip_exists tm in + let (bnd, used) = rev_itlist bindv bs (bnd, used) in + os oc "(EX"; pr_bs_isa oc bnd ts bs; otm_isa oc (bnd, used) cs ts bod; os oc ")" + else if is_abs tm then + let bs, bod = strip_abs tm in + let (bnd, used) = rev_itlist bindv bs (bnd, used) in + os oc "(%"; pr_bs_isa oc bnd ts bs; otm_isa oc (bnd, used) cs ts bod; os oc ")" + else if is_conj tm then + (os oc "("; oiter oc (fun oc e -> otm_isa oc (bnd, used) cs ts e) " & " (conjuncts tm); os oc ")") + else if is_disj tm then + (os oc "("; oiter oc (fun oc e -> otm_isa oc (bnd, used) cs ts e) " | " (disjuncts tm); os oc ")") + else if is_imp tm then let l, r = dest_imp tm in + (os oc "("; otm_isa oc (bnd, used) cs ts l; os oc " --> "; + otm_isa oc (bnd, used) cs ts r; os oc ")") + else if is_neg tm then + let t = dest_neg tm in (os oc "(~"; otm_isa oc (bnd,used) cs ts t; os oc ")") + else if is_eq tm then let l,r = dest_eq tm in + (os oc "("; otm_isa oc (bnd, used) cs ts l; os oc " = "; + otm_isa oc (bnd, used) cs ts r; os oc ")") + else if is_comb tm then let hop, args = strip_comb tm in + (os oc "("; oiter oc (fun oc e -> otm_isa oc (bnd, used) cs ts e) " " (hop :: args); os oc ")") + else if is_const tm then os oc (Hashtbl.find cs (fst (dest_const tm))) + else os oc (try Tmm.find tm bnd with Not_found -> failwith ("tm_isa:" ^ (fst (dest_var tm))));; + +let hash_to_list h = Hashtbl.fold (fun a b l -> (a,b) :: l) h [];; + +let isa_fix_names h u = + let l = Hashtbl.fold (fun a b c -> (a, b) :: c) h [] in + let itr (k, v) = + if v.[String.length v - 1] = '_' then + let n = variant_name_hash v u in + Hashtbl.replace h k n + in List.iter itr l +;; + +let isa_gl oc names asms gl = + os oc "theory Bla imports \"~~/src/HOL/TPTP/ATP_Problem_Import\" begin\n"; + let ts, cs, used = Hashtbl.create 20, Hashtbl.create 50, Hashtbl.create 50 in + Hashtbl.add used "bool" 0; Hashtbl.add used "fun" 0; + Hashtbl.add used "True" 0; Hashtbl.add used "False" 0; + Hashtbl.add used "in" 0; + List.iter (name_tscs_poly (ts, cs, used)) (gl :: asms); + isa_fix_names ts used; isa_fix_names cs used; + Hashtbl.remove ts "bool"; Hashtbl.remove ts "fun"; + Hashtbl.remove cs "T"; Hashtbl.remove cs "F"; + Hashtbl.iter (fun hty sty -> + try + let a = get_type_arity hty in + os oc "typedecl "; + (if a > 0 then (os oc "("; os oc + (String.concat "," (Array.to_list (Array.init a (fun i -> "'" ^ (String.make 1 (Char.chr (65 + i))))))); os oc ") ") else ()); + os oc sty; os oc "\n" + with Failure "find" -> () + ) ts; + Hashtbl.replace ts "bool" "bool"; Hashtbl.replace ts "fun" "fun"; + os oc "axiomatization\n"; + oiter oc (fun oc (t, s) -> os oc s; os oc " :: \""; oty_isa ts oc (get_const_type t); os oc "\"\n") "and " (hash_to_list cs); + Hashtbl.replace cs "T" "True"; Hashtbl.replace cs "F" "False"; + os oc "axiomatization where\n"; + oiter oc (fun oc (n, t) -> os oc n; os oc ": \""; otm_isa oc (Tmm.empty, Sm.empty) cs ts t; os oc "\"\n") "and " (zip (rev names) asms); + os oc "lemma conjecture:\n \""; + otm_isa oc (Tmm.empty, Sm.empty) cs ts gl; os oc "\"\n" +;; + + +let fileno = ref 0;; + +let rec fullsplitlist dest x = + try let l,r = dest x in + let ls = fullsplitlist dest r in (l::ls) + with Failure _ -> ([x]);; + +let rec otff_funtype oc ts t min = + if min = 0 then oty_poly ts 0 oc t else + let tys = fullsplitlist dest_fun_ty t in + let (tys1, tys2) = chop_listn [] min tys in + let ty2 = end_itlist mk_fun_ty tys2 in + os oc "("; (if List.length tys1 > 1 then os oc "(" else ()); + oiter oc (fun oc e -> oty_poly ts 0 oc e) " * " tys1; + (if List.length tys1 > 1 then os oc ")" else ()); + os oc " > "; oty_poly ts 0 oc ty2; os oc ")" +;; + +let funtys_of_tm tm = + let mergel l = setify (List.concat l) in + let tys tm = map type_of (find_terms (fun x -> is_var x or is_const x) tm) in + let rec funtypes t = + if is_vartype t then [] else + let (s, l) = dest_type t in + mergel ([s]::(map funtypes l)) in + mergel (map funtypes (tys tm)) +;; + +let funtys_of_tms tms = setify (List.concat (map funtys_of_tm tms));; + +let tff_gl_mk_hash terms = + let ts, cs, used = Hashtbl.create 20, Hashtbl.create 50, Hashtbl.create 50 in + Hashtbl.add used "p" 0; Hashtbl.add cs "happ" "i"; Hashtbl.add used "i" 0; + Hashtbl.add ts "fun" "fn"; Hashtbl.add used "fn" 0; Hashtbl.add used "fun" 0; + List.iter (name_tscs_poly (ts, cs, used)) terms; + (ts,cs,used_to_map used) +;; + +let tff_gl_hash oc names name asms gl (ts,cs,used) = + let ohdr s1 s2 = os oc "tff("; os oc s1; os oc ", "; os oc s2; os oc ", " in + let otl () = os oc ").\n" in + os oc "% TYPES\n"; + List.iter (fun t -> + let s = Hashtbl.find ts t in + ohdr t "type"; os oc s; os oc ":"; + begin match get_type_arity t with + 0 -> os oc "$tType" + | 1 -> os oc "$tType > $tType" + | n -> os oc "("; oiter oc (fun oc _ -> os oc "$tType") " * " (Array.to_list (Array.make n ())); + os oc ") > $tType" end; otl ()) (funtys_of_tms (gl::asms)); + os oc "% CONSTS\n"; + ohdr "cp" "type"; os oc "p : (bool > $o)"; otl (); + let output_const (c, argno) = + let ty = get_const_type c in let tvs = tyvars ty in + ohdr c "type"; os oc (Hashtbl.find cs c); os oc ":"; + otyquant oc ts tvs; otff_funtype oc ts ty argno; otl () + in + List.iter output_const (fst (get_mindata (asms, gl))); + os oc "% AXIOMS\n"; + List.iter2 (fun n t -> ohdr n "axiom"; tff_pred oc cs ts used t; otl ()) names asms; + ohdr (escape_obj name) "conjecture"; tff_pred oc cs ts used gl; otl (); +;; + +let tff_gl oc names name asms gl = + let tcu = tff_gl_mk_hash (gl :: asms) in + tff_gl_hash oc names name asms gl tcu +;; + +let oorig oc n ls ts gl g2 = + output_string oc ("% ORIGINAL: " ^ n ^ "\n"); + List.iter2 (fun n t -> + output_string oc ("% Assm: " ^ n ^ ": " ^ lstring_of_term (concl t) ^ "\n")) ls ts; + output_string oc ("% Goal: " ^ lstring_of_term gl ^ "\n"); + output_string oc "% PROCESSED\n"; + output_gs oc g2 +;; + +let rec fof_tm oc (bnd, used) cs ts tm = + if is_var tm then begin + os oc "s("; oty_poly ts 0 oc (type_of tm); os oc ","; os oc ( + try Tmm.find tm bnd with Not_found -> Hashtbl.find cs ("`" ^ (o fst dest_var) tm)); + os oc ")" + end else begin + let (f, args) = strip_comb tm in + os oc "s("; oty_poly ts 0 oc (type_of tm); os oc ","; os oc ( + try Hashtbl.find cs (fst (dest_const f)) with _ -> Hashtbl.find cs ("`" ^ (o fst dest_var) f)); + (if args <> [] then + (os oc "("; oiter oc (fun oc e -> fof_tm oc (bnd, used) cs ts e) "," args; os oc ")")); + os oc ")" + end;; + +(* Type unsafe version, currently not used *) +let rec fof_tm_unsafe oc (bnd, used) cs ts tm = + if is_var tm then os oc (Tmm.find tm bnd) + else + let (f, args) = strip_comb tm in + os oc (Hashtbl.find cs (fst (dest_const f))); + (if args <> [] then + (os oc "("; oiter oc (fun oc e -> fof_tm_unsafe oc (bnd, used) cs ts e) "," args; os oc ")"));; + +let rec fof_pred oc (bnd, used) cs ts tm = + if is_forall tm then + let vs, bod = strip_forall tm in + let (bnd, used) = rev_itlist bindv vs (bnd, used) in + os oc "![";oiter oc (fun oc v -> os oc (Tmm.find v bnd)) ", " vs;os oc "]: ";fof_pred oc (bnd, used) cs ts bod + else if is_exists tm then + let vs, bod = strip_exists tm in + let (bnd, used) = rev_itlist bindv vs (bnd, used) in + os oc "?[";oiter oc (fun oc v -> os oc (Tmm.find v bnd)) ", " vs;os oc "]: ";fof_pred oc (bnd, used) cs ts bod + else if is_conj tm then let l, r = dest_conj tm in + (os oc "("; fof_pred oc (bnd, used) cs ts l; os oc " & "; fof_pred oc (bnd, used) cs ts r; os oc ")") + else if is_disj tm then let l, r = dest_disj tm in + (os oc "("; fof_pred oc (bnd, used) cs ts l; os oc " | "; fof_pred oc (bnd, used) cs ts r; os oc ")") + else if is_imp tm then let l, r = dest_imp tm in + (os oc "("; fof_pred oc (bnd, used) cs ts l; os oc " => "; fof_pred oc (bnd, used) cs ts r; os oc ")") + else if is_neg tm then + let t = dest_neg tm in (os oc "~ ("; fof_pred oc (bnd,used) cs ts t; os oc ")") + else if is_eq tm then let l,r = dest_eq tm in + if must_pred l or must_pred r then + (os oc "("; fof_pred oc (bnd, used) cs ts l; os oc " <=> "; + fof_pred oc (bnd, used) cs ts r; os oc ")") + else + (fof_tm oc (bnd, used) cs ts l; os oc " = "; fof_tm oc (bnd, used) cs ts r) + else + (os oc "p("; fof_tm oc (bnd, used) cs ts tm; os oc ")");; + +let fof_pred oc cs ts used_map t = + let tvs = type_vars_in_term t in + (if tvs <> [] then (os oc "!["; oiter oc (fun oc e -> oty_poly ts 0 oc e) "," tvs; os oc "]: ")); + fof_pred oc (Tmm.empty, used_map) cs ts t +;; + +let fof_gl_hash oc names name asms gl (ts,cs,used) = + let ohdr s1 s2 = os oc "fof("; os oc s1; os oc ", "; os oc s2; os oc ", " in + let otl () = os oc ").\n" in + List.iter2 (fun n t -> ohdr n "axiom"; fof_pred oc cs ts used t; otl ()) names asms; + ohdr (escape_obj name) "conjecture"; fof_pred oc cs ts used gl; otl (); +;; + +let fof_gl_mk_hash terms = + let ts, cs, used = Hashtbl.create 20, Hashtbl.create 50, Hashtbl.create 50 in + Hashtbl.add used "p" 0; Hashtbl.add used "s" 0; + Hashtbl.add cs "happ" "i"; Hashtbl.add used "i" 0; + List.iter (name_tscs_poly (ts, cs, used)) terms; + (ts,cs,used_to_map used) +;; + +let fof_gl oc names name asms gl = + let (ts,cs,used) = fof_gl_mk_hash (gl :: asms) in + fof_gl_hash oc names name asms gl (ts,cs,used); + (ts,cs) +;; + +let pRE_HH_TAC = + eVERY_ASSUM (fun th -> if frees(concl th) = [] + then aLL_TAC else uNDISCH_TAC (concl th)) ++++ + www (fun (asl,w) -> mAP_EVERY (fun v -> sPEC_TAC(v,v)) (frees w)) +;; + +let pREP_HH_TAC names need_mono ths = + pURE_REWRITE_TAC [eXISTS_UNIQUE_THM; eXISTS_UNIQUE_DEF] ++++ + ((if need_mono then pOLY_ASSUME_TAC else lABEL_ASSUME_TAC) (rev names) (rev ths)) ++++ + rULE_ASSUM_TAC (pURE_REWRITE_RULE [eXISTS_UNIQUE_THM; eXISTS_UNIQUE_DEF]) +;; + +let pREP_TFF_TAC = + let tOP_DEPTH_CONV c tm = genvarreset (); tOP_DEPTH_CONV c tm in +(* sELECT_ELIM_TAC ++++*) + cONV_TAC(tOP_SWEEP_QCONV eLIM_LAMBDA_EQ) ++++ + rULE_ASSUM_TAC (cONV_RULE (tOP_SWEEP_QCONV eLIM_LAMBDA_EQ)) ++++ + cONV_TAC(tHENC (tOP_DEPTH_CONV bETA_CONV) (tHENC lAMBDA_ELIM_CONV2 lAMBDA_ELIM_CONV)) ++++ + rULE_ASSUM_TAC((cONV_RULE(tHENC (tOP_DEPTH_CONV bETA_CONV) (tHENC lAMBDA_ELIM_CONV2 lAMBDA_ELIM_CONV)))) +;; + +let write_atp_proof filen (ts, names) n gl = + let (_, [g], _) = mk_goalstate ([],gl) in + begin match (pREP_HH_TAC names false ts ++++ pREP_TFF_TAC ++++ fOL_IT_TAC) g with + (_, [g2], _) -> + let oc = open_out filen in + oorig oc n names ts gl g2; + let names = map fst (fst g2) in + ignore (fof_gl oc names n (map (o concl snd) (fst g2)) (snd g2)); + (*tff_gl oc names (map (o concl snd) (fst g2)) (snd g2);*) + close_out oc; + | _ -> failwith ("PREP_HH_TAC created more goals: " ^ n) + end;; + +let write_thf_proof filen (ts, names) n gl = + let (_, [g], _) = mk_goalstate ([],gl) in + begin match (pREP_HH_TAC names true ts) g with + (_, [g2], _) -> + let oc = open_out filen in + oorig oc n names ts gl g2; + ignore (thf_gl oc (map fst (fst g2)) (map (o concl snd) (fst g2)) (snd g2) n); + close_out oc + | _ -> failwith "PREP_HH_TAC created more goals" + end;; + +let write_isa_proof filen (ts, names) n gl = + let (_, [g], _) = mk_goalstate ([],gl) in + begin match (www(fun (asl,w) -> mAP_EVERY (fun v -> sPEC_TAC(v,v)) (frees w)) ++++ + lABEL_ASSUME_TAC names (map (o gEN_ALL dISCH_ALL) ts)) g with + (_, [g2], _) -> + let oc = open_out filen in + isa_gl oc names (map (o concl snd) (fst g2)) (snd g2); + close_out oc + | _ -> failwith "PREP_HH_TAC created more goals" + end +;; + +let rec cut_list md n = function + [] -> [] + | h :: t -> if n mod md = 0 then h :: (cut_list md (n + 1) t) else cut_list md (n + 1) t;; + +let normalize_th th = gEN_ALL (dISCH_ALL th);; diff --git a/src/holyhammer/hh/hh1/hl_parser.ml b/src/holyhammer/hh/hh1/hl_parser.ml new file mode 100644 index 0000000000..b340357b79 --- /dev/null +++ b/src/holyhammer/hh/hh1/hl_parser.ml @@ -0,0 +1,504 @@ + + + + + + + + + +open Printer;; +open Lib;; +open Preterm;; +open Fusion;; +open Num;; + + + + + +parse_as_infix (",",(14,"right"));; + + + + + +exception Noparse;; + +let (||) parser1 parser2 input = + try parser1 input + with Noparse -> parser2 input;; + +let (++) parser1 parser2 input = + let result1,rest1 = parser1 input in + let result2,rest2 = parser2 rest1 in + (result1,result2),rest2;; + +let rec many prs input = + try let result,next = prs input in + let results,rest = many prs next in + (result::results),rest + with Noparse -> [],input;; + +let (>>) prs treatment input = + let result,rest = prs input in + treatment(result),rest;; + +let fix err prs input = + try prs input + with Noparse -> failwith (err ^ " expected");; + +let rec listof prs sep err = + prs ++ many (sep ++ fix err prs >> snd) >> (fun (h,t) -> h::t);; + +let nothing input = [],input;; + +let elistof prs sep err = + listof prs sep err || nothing;; + +let leftbin prs sep cons err = + prs ++ many (sep ++ fix err prs) >> + (fun (x,opxs) -> let ops,xs = unzip opxs in + itlist2 (fun op y x -> cons op x y) (rev ops) (rev xs) x);; + +let rightbin prs sep cons err = + prs ++ many (sep ++ fix err prs) >> + (fun (x,opxs) -> if opxs = [] then x else + let ops,xs = unzip opxs in + itlist2 cons ops (x::butlast xs) (last xs));; + +let possibly prs input = + try let x,rest = prs input in [x],rest + with Noparse -> [],input;; + +let some p = + function + [] -> raise Noparse + | (h::t) -> if p h then (h,t) else raise Noparse;; + +let a tok = some (fun item -> item = tok);; + +let rec atleast n prs i = + (if n <= 0 then many prs + else prs ++ atleast (n - 1) prs >> (fun (h,t) -> h::t)) i;; + +let finished input = + if input = [] then 0,input else failwith "Unparsed input";; + + + + + +type lexcode = Ident of string + | Resword of string;; + + + + + + + +reserve_words ["//"];; + +let comment_token = ref (Resword "//");; + +let lex = + let collect (h,t) = end_itlist (^) (h::t) in + let reserve = + function + (Ident n as tok) -> + if is_reserved_word n then Resword(n) else tok + | t -> t in + let stringof p = atleast 1 p >> end_itlist (^) in + let simple_ident = stringof(some isalnum) || stringof(some issymb) in + let undertail = stringof (a "_") ++ possibly simple_ident >> collect in + let ident = (undertail || simple_ident) ++ many undertail >> collect in + let septok = stringof(some issep) in + let escapecode i = + match i with + "\\"::rst -> "\\",rst + | "\""::rst -> "\"",rst + | "\'"::rst -> "\'",rst + | "n"::rst -> "\n",rst + | "r"::rst -> "\r",rst + | "t"::rst -> "\t",rst + | "b"::rst -> "\b",rst + | " "::rst -> " ",rst + | "x"::h::l::rst -> + String.make 1 (Char.chr(int_of_string("0x"^h^l))),rst + | a::b::c::rst when forall isnum [a;b;c] -> + String.make 1 (Char.chr(int_of_string(a^b^c))),rst + | _ -> failwith "lex:unrecognized OCaml-style escape in string" in + let stringchar = + some (fun i -> i <> "\\" & i <> "\"") + || (a "\\" ++ escapecode >> snd) in + let string = a "\"" ++ many stringchar ++ a "\"" >> + (fun ((_,s),_) -> "\""^implode s^"\"") in + let rawtoken = (string || some isbra || septok || ident) >> + (fun x -> Ident x) in + let simptoken = many (some isspace) ++ rawtoken >> (o reserve snd) in + let rec tokens i = + try let (t,rst) = simptoken i in + if t = !comment_token then + (many (fun i -> if i <> [] & hd i <> "\n" then 1,tl i + else raise Noparse) ++ tokens >> snd) rst + else + let toks,rst1 = tokens rst in t::toks,rst1 + with Noparse -> [],i in + o fst (tokens ++ many (some isspace) ++ finished >> (o fst fst));; + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +let parse_pretype = + let btyop n n' x y = Ptycon(n,[x;y]) + and mk_apptype = + function + ([s],[]) -> s + | (tys,[c]) -> Ptycon(c,tys) + | _ -> failwith "Bad type construction" + and type_atom input = + match input with + (Ident s)::rest -> + (try pretype_of_type(assoc s (type_abbrevs())) with Failure _ -> + if try get_type_arity s = 0 with Failure _ -> false + then Ptycon(s,[]) else Utv(s)),rest + | _ -> raise Noparse + and type_constructor input = + match input with + (Ident s)::rest -> if try get_type_arity s > 0 with Failure _ -> false + then s,rest else raise Noparse + | _ -> raise Noparse in + let rec pretype i = rightbin sumtype (a (Resword "->")) (btyop "fun") "type" i + and sumtype i = rightbin prodtype (a (Ident "+")) (btyop "sum") "type" i + and prodtype i = rightbin carttype (a (Ident "#")) (btyop "prod") "type" i + and carttype i = leftbin apptype (a (Ident "^")) (btyop "cart") "type" i + and apptype i = (atomictypes ++ (type_constructor >> (fun x -> [x]) + || nothing) >> mk_apptype) i + and atomictypes i = + (((a (Resword "(")) ++ typelist ++ a (Resword ")") >> (o snd fst)) + || type_atom >> (fun x -> [x])) i + and typelist i = listof pretype (a (Ident ",")) "type" i in + pretype;; + + + + + +let install_parser,delete_parser,installed_parsers,try_user_parser = + let rec try_parsers ps i = + if ps = [] then raise Noparse else + try snd(hd ps) i with Noparse -> try_parsers (tl ps) i in + let parser_list = + ref([]:(string*(lexcode list -> preterm * lexcode list))list) in + (fun dat -> parser_list := dat::(!parser_list)), + (fun key -> try parser_list := snd (remove (fun (key',_) -> key = key') + (!parser_list)) + with Failure _ -> ()), + (fun () -> !parser_list), + (fun i -> try_parsers (!parser_list) i);; + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +let parse_preterm = + let rec pairwise r l = + match l with + [] -> true + | h::t -> forall (r h) t & pairwise r t in + let rec pfrees ptm acc = + match ptm with + Varp(v,pty) -> + if v = "" & pty = dpty then acc + else if can get_const_type v or can num_of_string v + or exists (fun (w,_) -> v = w) (!the_interface) then acc + else insert ptm acc + | Constp(_,_) -> acc + | Combp(p1,p2) -> pfrees p1 (pfrees p2 acc) + | Absp(p1,p2) -> subtract (pfrees p2 acc) (pfrees p1 []) + | Typing(p,_) -> pfrees p acc in + let pdest_eq (Combp(Combp(Varp(("="|"<=>"),_),l),r)) = l,r in + let pmk_let (letbindings,body) = + let vars,tms = unzip (map pdest_eq letbindings) in + let _ = warn(not + (pairwise (fun s t -> intersect(pfrees s []) (pfrees t []) = []) vars)) + "duplicate names on left of let-binding: latest is used" in + let lend = Combp(Varp("LET_END",dpty),body) in + let abs = itlist (fun v t -> Absp(v,t)) vars lend in + let labs = Combp(Varp("LET",dpty),abs) in + rev_itlist (fun x f -> Combp(f,x)) tms labs in + let pmk_vbinder(n,v,bod) = + if n = "\\" then Absp(v,bod) + else Combp(Varp(n,dpty),Absp(v,bod)) in + let pmk_binder(n,vs,bod) = + itlist (fun v b -> pmk_vbinder(n,v,b)) vs bod in + let pmk_set_enum ptms = + itlist (fun x t -> Combp(Combp(Varp("INSERT",dpty),x),t)) ptms + (Varp("EMPTY",dpty)) in + let pgenvar = + let gcounter = ref 0 in + fun () -> let count = !gcounter in + (gcounter := count + 1; + Varp("GEN%PVAR%"^(string_of_int count),dpty)) in + let pmk_exists(v,ptm) = Combp(Varp("?",dpty),Absp(v,ptm)) in + let pmk_list els = + itlist (fun x y -> Combp(Combp(Varp("CONS",dpty),x),y)) + els (Varp("NIL",dpty)) in + let pmk_bool = + let tt = Varp("T",dpty) and ff = Varp("F",dpty) in + fun b -> if b then tt else ff in + let pmk_char c = + let lis = map (fun i -> pmk_bool((c / (1 lsl i)) mod 2 = 1)) (0--7) in + itlist (fun x y -> Combp(y,x)) lis (Varp("ASCII",dpty)) in + let pmk_string s = + let ns = map (fun i -> Char.code(String.get s i)) + (0--(String.length s - 1)) in + pmk_list(map pmk_char ns) in + let pmk_setcompr (fabs,bvs,babs) = + let v = pgenvar() in + let bod = itlist (curry pmk_exists) bvs + (Combp(Combp(Combp(Varp("SETSPEC",dpty),v),babs),fabs)) in + Combp(Varp("GSPEC",dpty),Absp(v,bod)) in + let pmk_setabs (fabs,babs) = + let evs = + let fvs = pfrees fabs [] + and bvs = pfrees babs [] in + if length fvs <= 1 or bvs = [] then fvs + else intersect fvs bvs in + pmk_setcompr (fabs,evs,babs) in + let rec mk_precedence infxs prs inp = + match infxs with + (s,(p,at))::_ -> + let topins,rest = partition (fun (s',pat') -> pat' = (p,at)) infxs in + (if at = "right" then rightbin else leftbin) + (mk_precedence rest prs) + (end_itlist (||) (map (fun (s,_) -> a (Ident s)) topins)) + (fun (Ident op) x y -> Combp(Combp(Varp(op,dpty),x),y)) + ("term after binary operator") + inp + | _ -> prs inp in + let pmk_geq s t = Combp(Combp(Varp("GEQ",dpty),s),t) in + let pmk_pattern ((pat,guards),res) = + let x = pgenvar() and y = pgenvar() in + let vs = pfrees pat [] + and bod = + if guards = [] then + Combp(Combp(Varp("_UNGUARDED_PATTERN",dpty),pmk_geq pat x), + pmk_geq res y) + else + Combp(Combp(Combp(Varp("_GUARDED_PATTERN",dpty),pmk_geq pat x), + hd guards), + pmk_geq res y) in + Absp(x,Absp(y,itlist (curry pmk_exists) vs bod)) in + let pretype = parse_pretype + and string inp = + match inp with + Ident s::rst when String.length s >= 2 & + String.sub s 0 1 = "\"" & + String.sub s (String.length s - 1) 1 = "\"" + -> String.sub s 1 (String.length s - 2),rst + | _ -> raise Noparse + and singleton1 x = [x] + and lmk_ite (((((_,b),_),l),_),r) = + Combp(Combp(Combp(Varp("COND",dpty),b),l),r) + and lmk_typed = + function (p,[]) -> p | (p,[ty]) -> Typing(p,ty) | _ -> fail() + and lmk_let (((_,bnds),_),ptm) = pmk_let (bnds,ptm) + and lmk_binder ((((s,h),t),_),p) = pmk_binder(s,h::t,p) + and lmk_setenum(l,_) = pmk_set_enum l + and lmk_setabs(((l,_),r),_) = pmk_setabs(l,r) + and lmk_setcompr(((((f,_),vs),_),b),_) = + pmk_setcompr(f,pfrees vs [],b) + and lmk_decimal ((_,l0),ropt) = + let l,r = if ropt = [] then l0,"1" else + let r0 = hd ropt in + let n_l = num_of_string l0 + and n_r = num_of_string r0 in + let n_d = power_num (Int 10) (Int (String.length r0)) in + let n_n = n_l */ n_d +/ n_r in + string_of_num n_n,string_of_num n_d in + Combp(Combp(Varp("DECIMAL",dpty),Varp(l,dpty)),Varp(r,dpty)) + and lmk_univ((_,pty),_) = + Typing(Varp("UNIV",dpty),Ptycon("fun",[pty;Ptycon("bool",[])])) + and any_identifier = + function + ((Ident s):: rest) -> s,rest + | _ -> raise Noparse + and identifier = + function + ((Ident s):: rest) -> + if can get_infix_status s or is_prefix s or parses_as_binder s + then raise Noparse else s,rest + | _ -> raise Noparse + and binder = + function + ((Ident s):: rest) -> + if parses_as_binder s then s,rest else raise Noparse + | _ -> raise Noparse + and pre_fix = + function + ((Ident s):: rest) -> + if is_prefix s then s,rest else raise Noparse + | _ -> raise Noparse in + let rec preterm i = + mk_precedence (infixes()) typed_appl_preterm i + and nocommapreterm i = + let infs = filter (fun (s,_) -> s <> ",") (infixes()) in + mk_precedence infs typed_appl_preterm i + and typed_appl_preterm i = + (appl_preterm ++ + possibly (a (Resword ":") ++ pretype >> snd) + >> lmk_typed) i + and appl_preterm i = + (pre_fix ++ appl_preterm + >> (fun (x,y) -> Combp(Varp(x,dpty),y)) + || binder_preterm ++ many binder_preterm >> + (fun (h,t) -> itlist (fun x y -> Combp(y,x)) (rev t) h)) i + and binder_preterm i = + (a (Resword "let") ++ + leftbin (preterm >> singleton1) (a (Resword "and")) (kkk (@)) "binding" ++ + a (Resword "in") ++ + preterm + >> lmk_let + || binder ++ + typed_apreterm ++ + many typed_apreterm ++ + a (Resword ".") ++ + preterm + >> lmk_binder + || atomic_preterm) i + and typed_apreterm i = + (atomic_preterm ++ + possibly (a (Resword ":") ++ pretype >> snd) + >> lmk_typed) i + and atomic_preterm i = + (try_user_parser + || (a (Resword "(") ++ a (Resword ":")) ++ pretype ++ a (Resword ")") + >> lmk_univ + || string + >> pmk_string + || a (Resword "(") ++ + (any_identifier >> (fun s -> Varp(s,dpty))) ++ + a (Resword ")") + >> (o snd fst) + || a (Resword "(") ++ + preterm ++ + a (Resword ")") + >> (o snd fst) + || a (Resword "if") ++ + preterm ++ + a (Resword "then") ++ + preterm ++ + a (Resword "else") ++ + preterm + >> lmk_ite + || a (Resword "[") ++ + elistof preterm (a (Resword ";")) "term" ++ + a (Resword "]") + >> (o pmk_list (o snd fst)) + || a (Resword "{") ++ + (elistof nocommapreterm (a (Ident ",")) "term" ++ a (Resword "}") + >> lmk_setenum + || preterm ++ a (Resword "|") ++ preterm ++ a (Resword "}") + >> lmk_setabs + || preterm ++ a (Resword "|") ++ preterm ++ + a (Resword "|") ++ preterm ++ a (Resword "}") + >> lmk_setcompr) + >> snd + || a (Resword "match") ++ preterm ++ a (Resword "with") ++ clauses + >> (fun (((_,e),_),c) -> Combp(Combp(Varp("_MATCH",dpty),e),c)) + || a (Resword "function") ++ clauses + >> (fun (_,c) -> Combp(Varp("_FUNCTION",dpty),c)) + || a (Ident "#") ++ identifier ++ + possibly (a (Resword ".") ++ identifier >> snd) + >> lmk_decimal + || identifier + >> (fun s -> Varp(s,dpty))) i + and pattern i = + (preterm ++ possibly (a (Resword "when") ++ preterm >> snd)) i + and clause i = + ((pattern ++ (a (Resword "->") ++ preterm >> snd)) >> pmk_pattern) i + and clauses i = + ((possibly (a (Resword "|")) ++ + listof clause (a (Resword "|")) "pattern-match clause" >> snd) + >> end_itlist (fun s t -> Combp(Combp(Varp("_SEQPATTERN",dpty),s),t))) i in + (fun inp -> + match inp with + [Ident s] -> Varp(s,dpty),[] + | _ -> preterm inp);; + + + + + +let parse_type s = + let pty,l = (o parse_pretype (o lex explode)) s in + if l = [] then type_of_pretype pty + else failwith "Unparsed input following type";; + +let parse_term s = + let ptm,l = (o parse_preterm (o lex explode)) s in + if l = [] then + (o term_of_preterm (retypecheck [])) ptm + else failwith "Unparsed input following term";; diff --git a/src/holyhammer/hh/hh1/lib.ml b/src/holyhammer/hh/hh1/lib.ml new file mode 100644 index 0000000000..7be29c5593 --- /dev/null +++ b/src/holyhammer/hh/hh1/lib.ml @@ -0,0 +1,841 @@ + + + + + + + + + +let fail() = failwith "";; + + + + + +let curry f x y = f(x,y);; + +let uncurry f(x,y) = f x y;; + +let iii x = x;; + +let kkk x y = x;; + +let ccc f x y = f y x;; + +let www f x = f x x;; + +let o = fun f g x -> f(g x);; + +let (f_f) = fun f g (x,y) -> (f x,g y);; + + + + + +let hd l = + match l with + h::t -> h + | _ -> failwith "hd";; + +let tl l = + match l with + h::t -> t + | _ -> failwith "tl";; + +let map f = + let rec mapf l = + match l with + [] -> [] + | (x::t) -> let y = f x in y::(mapf t) in + mapf;; + +let rec last l = + match l with + [x] -> x + | (h::t) -> last t + | [] -> failwith "last";; + +let rec butlast l = + match l with + [_] -> [] + | (h::t) -> h::(butlast t) + | [] -> failwith "butlast";; + +let rec el n l = + if n = 0 then hd l else el (n - 1) (tl l);; + +let rev = + let rec rev_append acc l = + match l with + [] -> acc + | h::t -> rev_append (h::acc) t in + fun l -> rev_append [] l;; + +let rec map2 f l1 l2 = + match (l1,l2) with + [],[] -> [] + | (h1::t1),(h2::t2) -> let h = f h1 h2 in h::(map2 f t1 t2) + | _ -> failwith "map2: length mismatch";; + + + + + +let can f x = try (f x; true) with Failure _ -> false;; + +let check p x = if p x then x else failwith "check";; + + + + + +let rec funpow n f x = + if n < 1 then x else funpow (n-1) f (f x);; + +let rec repeat f x = + try let y = f x in repeat f y with Failure _ -> x;; + + + + + + +exception Unchanged;; + + + + + +let rec itlist f l b = + match l with + [] -> b + | (h::t) -> f h (itlist f t b);; + +let rec rev_itlist f l b = + match l with + [] -> b + | (h::t) -> rev_itlist f t (f h b);; + +let rec end_itlist f l = + match l with + [] -> failwith "end_itlist" + | [x] -> x + | (h::t) -> f h (end_itlist f t);; + +let rec itlist2 f l1 l2 b = + match (l1,l2) with + ([],[]) -> b + | (h1::t1,h2::t2) -> f h1 h2 (itlist2 f t1 t2 b) + | _ -> failwith "itlist2";; + +let rec rev_itlist2 f l1 l2 b = + match (l1,l2) with + ([],[]) -> b + | (h1::t1,h2::t2) -> rev_itlist2 f t1 t2 (f h1 h2 b) + | _ -> failwith "rev_itlist2";; + + + + + +let rec splitlist dest x = + try let l,r = dest x in + let ls,res = splitlist dest r in + (l::ls,res) + with Failure _ -> ([],x);; + +let rev_splitlist dest = + let rec rsplist ls x = + try let l,r = dest x in + rsplist (r::ls) l + with Failure _ -> (x,ls) in + fun x -> rsplist [] x;; + +let striplist dest = + let rec strip x acc = + try let l,r = dest x in + strip l (strip r acc) + with Failure _ -> x::acc in + fun x -> strip x [];; + + + + + +let rec nsplit dest clist x = + if clist = [] then [],x else + let l,r = dest x in + let ll,y = nsplit dest (tl clist) r in + l::ll,y;; + + + + + +let rec replicate x n = + if n < 1 then [] + else x::(replicate x (n - 1));; + +let rec (--) = fun m n -> if m > n then [] else m::((m + 1) -- n);; + + + + + +let rec forall p l = + match l with + [] -> true + | h::t -> p(h) && forall p t;; + +let rec forall2 p l1 l2 = + match (l1,l2) with + [],[] -> true + | (h1::t1,h2::t2) -> p h1 h2 && forall2 p t1 t2 + | _ -> false;; + +let rec exists p l = + match l with + [] -> false + | h::t -> p(h) || exists p t;; + +let length = + let rec len k l = + if l = [] then k else len (k + 1) (tl l) in + fun l -> len 0 l;; + +let rec filter p l = + match l with + [] -> l + | h::t -> let t' = filter p t in + if p(h) then if t'==t then l else h::t' + else t';; + +let rec partition p l = + match l with + [] -> [],l + | h::t -> let yes,no = partition p t in + if p(h) then (if yes == t then l,[] else h::yes,no) + else (if no == t then [],l else yes,h::no);; + +let rec mapfilter f l = + match l with + [] -> [] + | (h::t) -> let rest = mapfilter f t in + try (f h)::rest with Failure _ -> rest;; + +let rec find p l = + match l with + [] -> failwith "find" + | (h::t) -> if p(h) then h else find p t;; + +let rec tryfind f l = + match l with + [] -> failwith "tryfind" + | (h::t) -> try f h with Failure _ -> tryfind f t;; + +let flat l = itlist (@) l [];; + +let rec remove p l = + match l with + [] -> failwith "remove" + | (h::t) -> if p(h) then h,t else + let y,n = remove p t in y,h::n;; + +let rec chop_list n l = + if n = 0 then [],l else + try let m,l' = chop_list (n-1) (tl l) in (hd l)::m,l' + with Failure _ -> failwith "chop_list";; + +let index x = + let rec ind n l = + match l with + [] -> failwith "index" + | (h::t) -> if Pervasives.compare x h = 0 then n else ind (n + 1) t in + ind 0;; + + + + + +let rec mem x lis = + match lis with + [] -> false + | (h::t) -> Pervasives.compare x h = 0 || mem x t;; + +let insert x l = + if mem x l then l else x::l;; + +let union l1 l2 = itlist insert l1 l2;; + +let unions l = itlist union l [];; + +let intersect l1 l2 = filter (fun x -> mem x l2) l1;; + +let subtract l1 l2 = filter (fun x -> not (mem x l2)) l1;; + +let subset l1 l2 = forall (fun t -> mem t l2) l1;; + +let set_eq l1 l2 = subset l1 l2 && subset l2 l1;; + + + + + +let rec assoc a l = + match l with + (x,y)::t -> if Pervasives.compare x a = 0 then y else assoc a t + | [] -> failwith "find";; + +let rec rev_assoc a l = + match l with + (x,y)::t -> if Pervasives.compare y a = 0 then x else rev_assoc a t + | [] -> failwith "find";; + + + + + +let rec zip l1 l2 = + match (l1,l2) with + ([],[]) -> [] + | (h1::t1,h2::t2) -> (h1,h2)::(zip t1 t2) + | _ -> failwith "zip";; + +let rec unzip = + function [] -> [],[] + | ((a,b)::rest) -> let alist,blist = unzip rest in + (a::alist,b::blist);; + + + + + +let rec shareout pat all = + if pat = [] then [] else + let l,r = chop_list (length (hd pat)) all in + l::(shareout (tl pat) r);; + + + + + +let rec do_list f l = + match l with + [] -> () + | (h::t) -> (f h; do_list f t);; + + + + + +let rec sort cmp lis = + match lis with + [] -> [] + | piv::rest -> + let r,l = partition (cmp piv) rest in + (sort cmp l) @ (piv::(sort cmp r));; + + + + + +let uniq l = + let rec uniq2 acc = function + x::(y::_ as t) -> uniq2 (if Pervasives.compare x y = 0 then acc else x :: acc) t + | [x] -> rev (x :: acc) + | [] -> rev acc + in uniq2 [] l;; + +let setify s = uniq (List.sort Pervasives.compare s);; + + + + + +let implode l = itlist (^) l "";; + +let explode s = + let rec exap n l = + if n < 0 then l else + exap (n - 1) ((String.sub s n 1)::l) in + exap (String.length s - 1) [];; + + + + + +let gcd = + let rec gxd x y = + if y = 0 then x else gxd y (x mod y) in + fun x y -> let x' = abs x and y' = abs y in + if x' < y' then gxd y' x' else gxd x' y';; + + + + + +open Num;; +let num_0 = Int 0 +and num_1 = Int 1 +and num_2 = Int 2 +and num_10 = Int 10 + +let pow2 n = power_num num_2 (Int n);; +let pow10 n = power_num num_10 (Int n);; + +let numdom r = + let r' = Ratio.normalize_ratio (ratio_of_num r) in + num_of_big_int(Ratio.numerator_ratio r'), + num_of_big_int(Ratio.denominator_ratio r');; + +let numerator x = fst (numdom x) +and denominator x = snd (numdom x);; + +let gcd_num n1 n2 = + num_of_big_int(Big_int.gcd_big_int (big_int_of_num n1) (big_int_of_num n2));; + +let lcm_num x y = + if x =/ num_0 && y =/ num_0 then num_0 + else abs_num((x */ y) // gcd_num x y);; + + + + + +let rec allpairs f l1 l2 = + match l1 with + h1::t1 -> itlist (fun x a -> f h1 x :: a) l2 (allpairs f t1 l2) + | [] -> [];; + + + + + +let report s = + Format.print_string s; Format.print_newline();; + + + + + +let warn cond s = + if cond then report ("Warning: "^s) else ();; + + + + + +let verbose = ref true;; +let report_timing = ref true;; + + + + + +let remark s = + if !verbose then report s else ();; + + + + + +let time f x = + if not (!report_timing) then f x else + let start_time = Sys.time() in + try let result = f x in + let finish_time = Sys.time() in + report("CPU time (user): "^(string_of_float(finish_time -. start_time))); + result + with e -> + let finish_time = Sys.time() in + Format.print_string("Failed after (user) CPU time of "^ + (string_of_float(finish_time -. start_time))^": "); + raise e;; + + + + + +let rec assocd a l d = + match l with + [] -> d + | (x,y)::t -> if Pervasives.compare x a = 0 then y else assocd a t d;; + +let rec rev_assocd a l d = + match l with + [] -> d + | (x,y)::t -> if Pervasives.compare y a = 0 then x else rev_assocd a t d;; + + + + + +let rec qmap f l = + match l with + h::t -> let h' = f h and t' = qmap f t in + if h' == h && t' == t then l else h'::t' + | _ -> l;; + + + + + +let rec merge ord l1 l2 = + match l1 with + [] -> l2 + | h1::t1 -> match l2 with + [] -> l1 + | h2::t2 -> if ord h1 h2 then h1::(merge ord t1 l2) + else h2::(merge ord l1 t2);; + +let mergesort ord = + let rec mergepairs l1 l2 = + match (l1,l2) with + ([s],[]) -> s + | (l,[]) -> mergepairs [] l + | (l,[s1]) -> mergepairs (s1::l) [] + | (l,(s1::s2::ss)) -> mergepairs ((merge ord s1 s2)::l) ss in + fun l -> if l = [] then [] else mergepairs [] (map (fun x -> [x]) l);; + + + + + +let increasing f x y = Pervasives.compare (f x) (f y) < 0;; + +let decreasing f x y = Pervasives.compare (f x) (f y) > 0;; + + + + + + + + + + +type ('a,'b)func = + Empty + | Leaf of int * ('a*'b)list + | Branch of int * int * ('a,'b)func * ('a,'b)func;; + + + + + +let undefined = Empty;; + + + + + +let is_undefined f = + match f with + Empty -> true + | _ -> false;; + + + + + +let mapf = + let rec map_list f l = + match l with + [] -> [] + | (x,y)::t -> (x,f(y))::(map_list f t) in + let rec mapf f t = + match t with + Empty -> Empty + | Leaf(h,l) -> Leaf(h,map_list f l) + | Branch(p,b,l,r) -> Branch(p,b,mapf f l,mapf f r) in + mapf;; + + + + + +let foldl = + let rec foldl_list f a l = + match l with + [] -> a + | (x,y)::t -> foldl_list f (f a x y) t in + let rec foldl f a t = + match t with + Empty -> a + | Leaf(h,l) -> foldl_list f a l + | Branch(p,b,l,r) -> foldl f (foldl f a l) r in + foldl;; + +let foldr = + let rec foldr_list f l a = + match l with + [] -> a + | (x,y)::t -> f x y (foldr_list f t a) in + let rec foldr f t a = + match t with + Empty -> a + | Leaf(h,l) -> foldr_list f l a + | Branch(p,b,l,r) -> foldr f l (foldr f r a) in + foldr;; + + + + + +let graph f = setify (foldl (fun a x y -> (x,y)::a) [] f);; + +let dom f = setify(foldl (fun a x y -> x::a) [] f);; + +let ran f = setify(foldl (fun a x y -> y::a) [] f);; + + + + + +let applyd = + let rec apply_listd l d x = + match l with + (a,b)::t -> let c = Pervasives.compare x a in + if c = 0 then b else if c > 0 then apply_listd t d x else d x + | [] -> d x in + fun f d x -> + let k = Hashtbl.hash x in + let rec look t = + match t with + Leaf(h,l) when h = k -> apply_listd l d x + | Branch(p,b,l,r) when (k lxor p) land (b - 1) = 0 + -> look (if k land b = 0 then l else r) + | _ -> d x in + look f;; + +let apply f = applyd f (fun x -> failwith "apply");; + +let tryapplyd f a d = applyd f (fun x -> d) a;; + +let defined f x = try apply f x; true with Failure _ -> false;; + + + + + +let undefine = + let rec undefine_list x l = + match l with + (a,b as ab)::t -> + let c = Pervasives.compare x a in + if c = 0 then t + else if c < 0 then l else + let t' = undefine_list x t in + if t' == t then l else ab::t' + | [] -> [] in + fun x -> + let k = Hashtbl.hash x in + let rec und t = + match t with + Leaf(h,l) when h = k -> + let l' = undefine_list x l in + if l' == l then t + else if l' = [] then Empty + else Leaf(h,l') + | Branch(p,b,l,r) when k land (b - 1) = p -> + if k land b = 0 then + let l' = und l in + if l' == l then t + else (match l' with Empty -> r | _ -> Branch(p,b,l',r)) + else + let r' = und r in + if r' == r then t + else (match r' with Empty -> l | _ -> Branch(p,b,l,r')) + | _ -> t in + und;; + + + + + +let (|->),combine = + let newbranch p1 t1 p2 t2 = + let zp = p1 lxor p2 in + let b = zp land (-zp) in + let p = p1 land (b - 1) in + if p1 land b = 0 then Branch(p,b,t1,t2) + else Branch(p,b,t2,t1) in + let rec define_list (x,y as xy) l = + match l with + (a,b as ab)::t -> + let c = Pervasives.compare x a in + if c = 0 then xy::t + else if c < 0 then xy::l + else ab::(define_list xy t) + | [] -> [xy] + and combine_list op z l1 l2 = + match (l1,l2) with + [],_ -> l2 + | _,[] -> l1 + | ((x1,y1 as xy1)::t1,(x2,y2 as xy2)::t2) -> + let c = Pervasives.compare x1 x2 in + if c < 0 then xy1::(combine_list op z t1 l2) + else if c > 0 then xy2::(combine_list op z l1 t2) else + let y = op y1 y2 and l = combine_list op z t1 t2 in + if z(y) then l else (x1,y)::l in + let (|->) x y = + let k = Hashtbl.hash x in + let rec upd t = + match t with + Empty -> Leaf (k,[x,y]) + | Leaf(h,l) -> + if h = k then Leaf(h,define_list (x,y) l) + else newbranch h t k (Leaf(k,[x,y])) + | Branch(p,b,l,r) -> + if k land (b - 1) <> p then newbranch p t k (Leaf(k,[x,y])) + else if k land b = 0 then Branch(p,b,upd l,r) + else Branch(p,b,l,upd r) in + upd in + let rec combine op z t1 t2 = + match (t1,t2) with + Empty,_ -> t2 + | _,Empty -> t1 + | Leaf(h1,l1),Leaf(h2,l2) -> + if h1 = h2 then + let l = combine_list op z l1 l2 in + if l = [] then Empty else Leaf(h1,l) + else newbranch h1 t1 h2 t2 + | (Leaf(k,lis) as lf),(Branch(p,b,l,r) as br) -> + if k land (b - 1) = p then + if k land b = 0 then + (match combine op z lf l with + Empty -> r | l' -> Branch(p,b,l',r)) + else + (match combine op z lf r with + Empty -> l | r' -> Branch(p,b,l,r')) + else + newbranch k lf p br + | (Branch(p,b,l,r) as br),(Leaf(k,lis) as lf) -> + if k land (b - 1) = p then + if k land b = 0 then + (match combine op z l lf with + Empty -> r | l' -> Branch(p,b,l',r)) + else + (match combine op z r lf with + Empty -> l | r' -> Branch(p,b,l,r')) + else + newbranch p br k lf + | Branch(p1,b1,l1,r1),Branch(p2,b2,l2,r2) -> + if b1 < b2 then + if p2 land (b1 - 1) <> p1 then newbranch p1 t1 p2 t2 + else if p2 land b1 = 0 then + (match combine op z l1 t2 with + Empty -> r1 | l -> Branch(p1,b1,l,r1)) + else + (match combine op z r1 t2 with + Empty -> l1 | r -> Branch(p1,b1,l1,r)) + else if b2 < b1 then + if p1 land (b2 - 1) <> p2 then newbranch p1 t1 p2 t2 + else if p1 land b2 = 0 then + (match combine op z t1 l2 with + Empty -> r2 | l -> Branch(p2,b2,l,r2)) + else + (match combine op z t1 r2 with + Empty -> l2 | r -> Branch(p2,b2,l2,r)) + else if p1 = p2 then + (match (combine op z l1 l2,combine op z r1 r2) with + (Empty,r) -> r | (l,Empty) -> l | (l,r) -> Branch(p1,b1,l,r)) + else + newbranch p1 t1 p2 t2 in + (|->),combine;; + + + + + +let (|=>) = fun x y -> (x |-> y) undefined;; + + + + + +let rec choose t = + match t with + Empty -> failwith "choose: completely undefined function" + | Leaf(h,l) -> hd l + | Branch(b,p,t1,t2) -> choose t1;; + + + + + +let rec mem' eq = + let rec mem x lis = + match lis with + [] -> false + | (h::t) -> eq x h || mem x t + in mem;; + +let insert' eq x l = + if mem' eq x l then l else x::l;; + +let union' eq l1 l2 = itlist (insert' eq) l1 l2;; + +let unions' eq l = itlist (union' eq) l [];; + +let subtract' eq l1 l2 = filter (fun x -> not (mem' eq x l2)) l1;; + + + + + + +let num_of_string = + let values = + ["0",0; "1",1; "2",2; "3",3; "4",4; + "5",5; "6",6; "7",7; "8",8; "9",9; + "a",10; "A",10; "b",11; "B",11; + "c",12; "C",12; "d",13; "D",13; + "e",14; "E",14; "f",15; "F",15] in + let valof b s = + let v = Int(assoc s values) in + if v failwith "num_of_string: no digits after base indicator" + | [h] -> valof b h + | h::t -> valof b h +/ b */ num_of_stringlist b t in + fun s -> + match explode(s) with + [] -> failwith "num_of_string: no digits" + | "0"::"x"::hexdigits -> num_of_stringlist sixteen (rev hexdigits) + | "0"::"b"::bindigits -> num_of_stringlist two (rev bindigits) + | decdigits -> num_of_stringlist ten (rev decdigits);; + + + + + +let strings_of_file filename = + let fd = try Pervasives.open_in filename + with Sys_error _ -> + failwith("strings_of_file: can't open "^filename) in + let rec suck_lines acc = + try let l = Pervasives.input_line fd in + suck_lines (l::acc) + with End_of_file -> rev acc in + let data = suck_lines [] in + (Pervasives.close_in fd; data);; + +let string_of_file filename = + end_itlist (fun s t -> s^"\n"^t) (strings_of_file filename);; + +let file_of_string filename s = + let fd = Pervasives.open_out filename in + output_string fd s; close_out fd;; + +(* Tail-recursive *) +let uniq2 l = + let rec uniq2 acc = function + x::(y::_ as t) -> uniq2 (if Pervasives.compare x y = 0 then acc else x :: acc) t + | [x] -> List.rev (x :: acc) + | [] -> List.rev acc + in uniq2 [] l;; +let setify2 l = uniq2 (List.sort compare l);; diff --git a/src/holyhammer/hh/hh1/main.ml b/src/holyhammer/hh/hh1/main.ml new file mode 100644 index 0000000000..bef23b18f7 --- /dev/null +++ b/src/holyhammer/hh/hh1/main.ml @@ -0,0 +1,3 @@ +let l = input_line stdin;; +let t = Hl_parser.parse_term l;; +Hh_write.write_atp_proof "testo.p" ([Bool.tRUTH; Bool.bOOL_CASES_AX], ["TRUTH"; "BOOL_CASES"]) "conj" t;; diff --git a/src/holyhammer/hh/hh1/meson.ml b/src/holyhammer/hh/hh1/meson.ml new file mode 100644 index 0000000000..49a6d5dcb1 --- /dev/null +++ b/src/holyhammer/hh/hh1/meson.ml @@ -0,0 +1,328 @@ +open Follist;; +open Lib;; + +let meson_depth = ref false;; (* Use depth not inference bound. *) +let meson_prefine = ref true;; (* Use Plaisted's positive refinement. *) +let meson_dcutin = ref 1;; (* Min size for d-and-c optimization cut-in. *) +let meson_skew = ref 3;; (* Skew proof bias (one side is <= n / skew) *) + +(* ------------------------------------------------------------------------- *) +(* Prolog exception. *) +(* ------------------------------------------------------------------------- *) + +exception Cut;; + +let inferences = ref 0;; + +type fol_goal = + Subgoal of fol_lit * fol_goal list * (int * Fusion.thm) * + int * (fol_term * int)list;; + + let qpartition p m = + let rec qpartition l = + if l == m then raise Unchanged else + match l with + [] -> raise Unchanged + | (h::t) -> if p h then + try let yes,no = qpartition t in h::yes,no + with Unchanged -> [h],t + else + let yes,no = qpartition t in yes,h::no in + function l -> try qpartition l + with Unchanged -> [],l;; + + (* ----------------------------------------------------------------------- *) + (* Cacheing continuations. Very crude, but it works remarkably well. *) + (* ----------------------------------------------------------------------- *) + + let cacheconts f = + let memory = ref [] in + fun (gg,(insts,offset,size) as input) -> + if exists (fun (_,(insts',_,size')) -> + insts = insts' & (size <= size' or !meson_depth)) + (!memory) + then failwith "cachecont" + else memory := input::(!memory); f input;; + + (* ----------------------------------------------------------------------- *) + (* Check ancestor list for repetition. *) + (* ----------------------------------------------------------------------- *) + + let checkan insts (p,a) ancestors = + let p' = -p in + let t' = (p',a) in + try let ours = assoc p' ancestors in + if exists (fun u -> fol_atom_eq insts t' (snd(fst u))) ours + then failwith "checkan" + else ancestors + with Failure "find" -> ancestors;; + + (* ----------------------------------------------------------------------- *) + (* Insert new goal's negation in ancestor clause, given refinement. *) + (* ----------------------------------------------------------------------- *) + + let insertan insts (p,a) ancestors = + let p' = -p in + let t' = (p',a) in + let ourancp,otheranc = + try remove (fun (pr,_) -> pr = p') ancestors + with Failure _ -> (p',[]),ancestors in + let ouranc = snd ourancp in + if exists (fun u -> fol_atom_eq insts t' (snd(fst u))) ouranc + then failwith "insertan: loop" + else (p',(([],t'),(0,Bool.tRUTH))::ouranc)::otheranc;; + + (* ----------------------------------------------------------------------- *) + (* Tease apart local and global instantiations. *) + (* At the moment we also force a full evaluation; should eliminate this. *) + (* ----------------------------------------------------------------------- *) + + let separate_insts offset oldinsts newinsts = + let locins,globins = + qpartition (fun (_,v) -> offset <= v) oldinsts newinsts in + if globins = oldinsts then + map (fun (t,x) -> fol_subst_partial newinsts t,x) locins,oldinsts + else + map (fun (t,x) -> fol_subst_partial newinsts t,x) locins, + map (fun (t,x) -> fol_subst_partial newinsts t,x) globins;; + + (* ----------------------------------------------------------------------- *) + (* Perform basic MESON expansion. *) + (* ----------------------------------------------------------------------- *) + + let meson_single_expand loffset rule ((g,ancestors),(insts,offset,size)) = + let (hyps,conc),tag = rule in + let allins = rev_itlist2 (fol_unify loffset) (snd g) (snd conc) insts in + let locin,globin = separate_insts offset insts allins in + let mk_ihyp h = + let h' = fol_inst_bump offset locin h in + h',checkan insts h' ancestors in + let newhyps = map mk_ihyp hyps in + inferences := !inferences + 1; + newhyps,(globin,offset+offinc,size-length hyps);; + + (* ----------------------------------------------------------------------- *) + (* Perform first basic expansion which allows continuation call. *) + (* ----------------------------------------------------------------------- *) + + let meson_expand_cont loffset rules state cont = + tryfind + (fun r -> cont (snd r) (meson_single_expand loffset r state)) rules;; + + (* ----------------------------------------------------------------------- *) + (* Try expansion and continuation call with ancestor or initial rule. *) + (* ----------------------------------------------------------------------- *) + + let meson_expand rules ((g,ancestors),((insts,offset,size) as tup)) cont = + let pr = fst g in + let newancestors = insertan insts g ancestors in + let newstate = (g,newancestors),tup in + try if !meson_prefine & pr > 0 then failwith "meson_expand" else + let arules = assoc pr ancestors in + meson_expand_cont 0 arules newstate cont + with Cut -> failwith "meson_expand" | Failure _ -> + try let crules = + filter (fun ((h,_),_) -> length h <= size) (assoc pr rules) in + meson_expand_cont offset crules newstate cont + with Cut -> failwith "meson_expand" + | Failure _ -> failwith "meson_expand";; + + (* ----------------------------------------------------------------------- *) + (* Simple Prolog engine organizing search and backtracking. *) + (* ----------------------------------------------------------------------- *) + + let expand_goal rules = + let rec expand_goal depth ((g,_),(insts,offset,size) as state) cont = + if depth < 0 then failwith "expand_goal: too deep" else + meson_expand rules state + (fun apprule (_,(pinsts,_,_) as newstate) -> + expand_goals (depth-1) newstate + (cacheconts(fun (gs,(newinsts,newoffset,newsize)) -> + let locin,globin = separate_insts offset pinsts newinsts in + let g' = Subgoal(g,gs,apprule,offset,locin) in + if globin = insts & gs = [] then + try cont(g',(globin,newoffset,size)) + with Failure _ -> raise Cut + else + try cont(g',(globin,newoffset,newsize)) + with Cut -> failwith "expand_goal" + | Failure _ -> failwith "expand_goal"))) + + and expand_goals depth (gl,(insts,offset,size as tup)) cont = + match gl with + [] -> cont ([],tup) + + | [g] -> expand_goal depth (g,tup) (fun (g',stup) -> cont([g'],stup)) + + | gl -> if size >= !meson_dcutin then + let lsize = size / (!meson_skew) in + let rsize = size - lsize in + let lgoals,rgoals = chop_list (length gl / 2) gl in + try expand_goals depth (lgoals,(insts,offset,lsize)) + (cacheconts(fun (lg',(i,off,n)) -> + expand_goals depth (rgoals,(i,off,n + rsize)) + (cacheconts(fun (rg',ztup) -> cont (lg'@rg',ztup))))) + with Failure _ -> + expand_goals depth (rgoals,(insts,offset,lsize)) + (cacheconts(fun (rg',(i,off,n)) -> + expand_goals depth (lgoals,(i,off,n + rsize)) + (cacheconts (fun (lg',((_,_,fsize) as ztup)) -> + if n + rsize <= lsize + fsize + then failwith "repetition of demigoal pair" + else cont (lg'@rg',ztup))))) + else + let g::gs = gl in + expand_goal depth (g,tup) + (cacheconts(fun (g',stup) -> + expand_goals depth (gs,stup) + (cacheconts(fun (gs',ftup) -> cont(g'::gs',ftup))))) in + + fun g maxdep maxinf cont -> + expand_goal maxdep (g,([],2 * offinc,maxinf)) cont;; + + (* ----------------------------------------------------------------------- *) + (* With iterative deepening of inferences or depth. *) + (* ----------------------------------------------------------------------- *) + + let solve_goal rules incdepth min max incsize = + let rec solve n g = + if n > max then failwith "solve_goal: Too deep" else + try let gi = + if incdepth then expand_goal rules g n 100000 (fun x -> x) + else expand_goal rules g 100000 n (fun x -> x) in + gi + with Failure _ -> solve (n + incsize) g in + fun g -> solve min (g,[]);; + + let mk_negated (p,a) = -p,a;; + let rec mk_contraposes n th used unused sofar = + match unused with + [] -> sofar + | h::t -> let nw = (map mk_negated (used @ t),h),(n,th) in + mk_contraposes (n + 1) th (used@[h]) t (nw::sofar);; + + + let fol_of_hol_clause th = + let lconsts = Fusion.freesl (Fusion.hyp th) in + let tm = Fusion.concl th in + let hlits = Basics.disjuncts tm in + let flits = map (fol_of_literal false [] lconsts) hlits in + let basics = mk_contraposes 0 th [] flits [] in + if forall (fun (p,_) -> p < 0) flits then + ((map mk_negated flits,(1,[])),(-1,th))::basics + else basics;; + + let fol_of_hol_clauses = + let eqt (a1,(b1,c1)) (a2, (b2,c2)) = + ((a1 = a2) & (b1 = b2) & (Fusion.equals_thm c1 c2)) in + fun thms -> + let rawrules = itlist (fun x -> union' eqt (fol_of_hol_clause x)) thms [] in + let prs = setify (map (fun x -> fst (snd (fst x))) rawrules) in + let prules = + map (fun t -> t,filter (fun x -> t = fst (snd (fst x))) rawrules) prs in + let srules = sort (fun (p,_) (q,_) -> abs(p) <= abs(q)) prules in + srules;; + + let optimize_rules = + let optimize_clause_order cls = + sort (fun ((l1,_),_) ((l2,_),_) -> length l1 <= length l2) cls in + map (fun (a,b) -> a,optimize_clause_order b);; + +open Basics;; +open Bool;; +open Simp;; +open Fusion;; +open Theorems;; +open Hl_parser;; +open Equal;; +open Drule;; + + let clear_contrapos_cache,make_hol_contrapos = + let dISJ_AC = aC dISJ_ACI + and imp_CONV = rEWR_CONV(Sequent ([], parse_term "a \\/ b <=> ~b ==> a")) + and push_CONV = + gEN_REWRITE_CONV tOP_SWEEP_CONV + [Sequent ([], parse_term "~(a \\/ b) <=> ~a /\\ ~b"); Sequent ([], parse_term "~(~a) <=> a")] + and pull_CONV = gEN_REWRITE_CONV dEPTH_CONV + [Sequent ([], parse_term "~a \\/ ~b <=> ~(a /\\ b)")] + and imf_CONV = rEWR_CONV(Sequent ([], parse_term "~p <=> p ==> F")) in + let memory = ref [] in + let clear_contrapos_cache() = memory := [] in + let make_hol_contrapos (n,th) = + let tm = concl th in + let key = (n,tm) in + try assoc key (!memory) with Failure _ -> + if n < 0 then + cONV_RULE (tHENC pull_CONV imf_CONV) th + else + let djs = disjuncts tm in + let acth = + if n = 0 then th else + let ldjs,rdjs = chop_list n djs in + let ndjs = (hd rdjs)::(ldjs@(tl rdjs)) in + eQ_MP (dISJ_AC(mk_eq(tm,list_mk_disj ndjs))) th in + let fth = + if length djs = 1 then acth + else cONV_RULE (tHENC imp_CONV push_CONV) acth in + (memory := (key,fth)::(!memory); fth) in + clear_contrapos_cache,make_hol_contrapos;; + + let meson_to_hol = + let hol_negate tm = + try dest_neg tm with Failure _ -> mk_neg tm in + let merge_inst (t,x) current = + (fol_subst current t,x)::current in + let finish_RULE = + gEN_REWRITE_RULE iii + [Sequent ([], parse_term "(~p ==> p) <=> p"); Sequent ([], parse_term "(p ==> ~p) <=> ~p")] in + let rec meson_to_hol insts (Subgoal(g,gs,(n,th),offset,locin)) = + let newins = itlist merge_inst locin insts in + let g' = fol_inst newins g in + let hol_g = hol_of_literal g' in + let ths = map (meson_to_hol newins) gs in + let hth = + if th = tRUTH then aSSUME hol_g else + let cth = make_hol_contrapos(n,th) in + if ths = [] then cth else mATCH_MP cth (end_itlist cONJ ths) in + let ith = pART_MATCH iii hth hol_g in + finish_RULE (dISCH (hol_negate(concl ith)) ith) in + meson_to_hol;; + + + let sIMPLE_MESON_REFUTE min max inc ths = + clear_contrapos_cache (); + inferences := 0; + let old_dcutin = !meson_dcutin in + if !meson_depth then meson_dcutin := 100001 else (); + let ths' = ths @ create_equality_axioms (map Fusion.concl ths) in + let rules = optimize_rules(fol_of_hol_clauses ths') in + let proof,(insts,_,_) = + solve_goal rules (!meson_depth) min max inc (1,[]) in + meson_dcutin := old_dcutin; + meson_to_hol insts proof;; + + let pURE_MESON_TAC min max inc gl = + reset_vars(); reset_consts(); + (www(fun x -> Tactics.aCCEPT_TAC (sIMPLE_MESON_REFUTE min max inc (map snd (fst x)))) gl);; + +open Tactics;; +open Simp;; +open Canon;; + let cONJUNCTS_THEN' ttac cth = + ttac(Bool.cONJUNCT1 cth) ++++ ttac(Bool.cONJUNCT2 cth);; + +let gEN_MESON_TAC min max step ths = + rEFUTE_THEN aSSUME_TAC ++++ + (mAP_EVERY aSSUME_TAC ths) ++++ + rULE_ASSUM_TAC(Equal.cONV_RULE(Equal.tHENC nNF_CONV sKOLEM_CONV)) ++++ + rEPEAT (fIRST_X_ASSUM cHOOSE_TAC) ++++ + rULE_ASSUM_TAC(Equal.cONV_RULE(Equal.tHENC pRENEX_CONV cNF_CONV)) ++++ + rULE_ASSUM_TAC(repeat + (fun th -> Bool.sPEC(Basics.genvar(Fusion.type_of(fst(Basics.dest_forall(Fusion.concl th))))) th)) ++++ + rEPEAT (fIRST_X_ASSUM (cONJUNCTS_THEN' aSSUME_TAC)) ++++ + pURE_MESON_TAC min max step +;; + +let aSM_MESON_TAC = gEN_MESON_TAC 0 50 1;; +let mESON_TAC ths = pOP_ASSUM_LIST(kkk aLL_TAC) ++++ aSM_MESON_TAC ths;; +let mESON ths tm = Tactics.prove(tm,mESON_TAC ths);; diff --git a/src/holyhammer/hh/hh1/preterm.ml b/src/holyhammer/hh/hh1/preterm.ml new file mode 100644 index 0000000000..7969e83240 --- /dev/null +++ b/src/holyhammer/hh/hh1/preterm.ml @@ -0,0 +1,455 @@ + + + + + + + + + + + + +open Fusion;; +open Lib;; +open Printer;; +open Basics;; +open Num;; + + + + + +let ignore_constant_varstruct = ref true;; + + + + + + +let type_invention_warning = ref false;; + +let type_invention_error = ref false;; + + + + + +let the_implicit_types = ref ([]:(string*hol_type)list);; + + + + + +let make_overloadable s gty = + if can (assoc s) (!the_overload_skeletons) + then if assoc s (!the_overload_skeletons) = gty then () + else failwith "make_overloadable: differs from existing skeleton" + else the_overload_skeletons := (s,gty)::(!the_overload_skeletons);; + +let remove_interface sym = + let interface = filter (o (<>)sym fst) (!the_interface) in + the_interface := interface;; + +let reduce_interface (sym,tm) = + let namty = try dest_const tm with Failure _ -> dest_var tm in + the_interface := filter ((<>) (sym,namty)) (!the_interface);; + +let override_interface (sym,tm) = + let namty = try dest_const tm with Failure _ -> dest_var tm in + let interface = filter (o ((<>)sym) fst) (!the_interface) in + the_interface := (sym,namty)::interface;; + +let overload_interface (sym,tm) = + let gty = try assoc sym (!the_overload_skeletons) with Failure _ -> + failwith ("symbol \""^sym^"\" is not overloadable") in + let (name,ty) as namty = try dest_const tm with Failure _ -> dest_var tm in + if not (can (type_match gty ty) []) + then failwith "Not an instance of type skeleton" else + let interface = filter ((<>) (sym,namty)) (!the_interface) in + the_interface := (sym,namty)::interface;; + +let prioritize_overload ty = + do_list + (fun (s,gty) -> + try let _,(n,t) = find + (fun (s',(n,t)) -> s' = s & mem ty (map fst (type_match gty t []))) + (!the_interface) in + overload_interface(s,mk_var(n,t)) + with Failure _ -> ()) + (!the_overload_skeletons);; + + + + + +let new_type_abbrev,remove_type_abbrev,type_abbrevs = + let the_type_abbreviations = ref ([]:(string*hol_type)list) in + let remove_type_abbrev s = + the_type_abbreviations := + filter (fun (s',_) -> s' <> s) (!the_type_abbreviations) in + let new_type_abbrev(s,ty) = + (remove_type_abbrev s; + the_type_abbreviations := merge(<) [s,ty] (!the_type_abbreviations)) in + let type_abbrevs() = !the_type_abbreviations in + new_type_abbrev,remove_type_abbrev,type_abbrevs;; + + + + + +let hide_constant,unhide_constant,is_hidden = + let hcs = ref ([]:string list) in + let hide_constant c = hcs := union [c] (!hcs) + and unhide_constant c = hcs := subtract (!hcs) [c] + and is_hidden c = mem c (!hcs) in + hide_constant,unhide_constant,is_hidden;; + + + + + +type pretype = Utv of string + | Ptycon of string * pretype list + | Stv of int;; + + + + + +let dpty = Ptycon("",[]);; + + + + + +let rec pretype_of_type ty = + try let con,args = dest_type ty in + Ptycon(con,map pretype_of_type args) + with Failure _ -> Utv(dest_vartype ty);; + + + + + +type preterm = Varp of string * pretype + | Constp of string * pretype + | Combp of preterm * preterm + | Absp of preterm * preterm + | Typing of preterm * pretype;; + + + + + +let rec preterm_of_term tm = + try let n,ty = dest_var tm in + Varp(n,pretype_of_type ty) + with Failure _ -> try + let n,ty = dest_const tm in + Constp(n,pretype_of_type ty) + with Failure _ -> try + let v,bod = dest_abs tm in + Absp(preterm_of_term v,preterm_of_term bod) + with Failure _ -> + let l,r = dest_comb tm in + Combp(preterm_of_term l,preterm_of_term r);; + + + + + +let type_of_pretype,term_of_preterm,retypecheck = + let tyv_num = ref 0 in + let new_type_var() = let n = !tyv_num in (tyv_num := n + 1; Stv(n)) in + + let pmk_cv(s,pty) = + if can get_const_type s then Constp(s,pty) + else Varp(s,pty) in + + let pmk_numeral = + let num_pty = Ptycon("num",[]) in + let nUMERAL = Constp("NUMERAL",Ptycon("fun",[num_pty; num_pty])) + and bIT0 = Constp("BIT0",Ptycon("fun",[num_pty; num_pty])) + and bIT1 = Constp("BIT1",Ptycon("fun",[num_pty; num_pty])) + and t_0 = Constp("_0",num_pty) in + let rec pmk_numeral(n) = + if n =/ num_0 then t_0 else + let m = quo_num n (num_2) and b = mod_num n (num_2) in + let op = if b =/ num_0 then bIT0 else bIT1 in + Combp(op,pmk_numeral(m)) in + fun n -> Combp(nUMERAL,pmk_numeral n) in + + + + + + let rec pretype_subst th ty = + match ty with + Ptycon(tycon,args) -> Ptycon(tycon,map (pretype_subst th) args) + | Utv v -> rev_assocd ty th ty + | _ -> failwith "pretype_subst: Unexpected form of pretype" in + + + + + + let pretype_instance ty = + let gty = pretype_of_type ty + and tyvs = map pretype_of_type (tyvars ty) in + let subs = map (fun tv -> new_type_var(),tv) tyvs in + pretype_subst subs gty in + + + + + + let get_generic_type cname = + match filter (o ((=) cname) fst) (!the_interface) with + [_,(c,ty)] -> ty + | _::_::_ -> assoc cname (!the_overload_skeletons) + | [] -> get_const_type cname in + + + + + + let get_var_type vname = + assoc vname !the_implicit_types in + + + + + + let rec solve env pty = + match pty with + Ptycon(f,args) -> Ptycon(f,map (solve env) args) + | Stv(i) -> if defined env i then solve env (apply env i) else pty + | _ -> pty in + + + + + + + let free_stvs = + let rec free_stvs = function + |Stv n -> [n] + |Utv _ -> [] + |Ptycon(_,args) -> flat (map free_stvs args) + in + o setify free_stvs + in + + let string_of_pretype stvs = + let rec type_of_pretype' ns = function + |Stv n -> mk_vartype (if mem n ns then "?" ^ string_of_int n else "_") + |Utv v -> mk_vartype v + |Ptycon(con,args) -> mk_type(con,map (type_of_pretype' ns) args) + in + o string_of_type (type_of_pretype' stvs) + in + + let string_of_preterm = + let rec untyped_t_of_pt = function + |Varp(s,pty) -> mk_var(s,aty) + |Constp(s,pty) -> mk_mconst(s,get_const_type s) + |Combp(l,r) -> mk_comb(untyped_t_of_pt l,untyped_t_of_pt r) + |Absp(v,bod) -> mk_gabs(untyped_t_of_pt v,untyped_t_of_pt bod) + |Typing(ptm,pty) -> untyped_t_of_pt ptm + in + o string_of_term (untyped_t_of_pt) + in + + let string_of_ty_error env = function + |None -> + "unify: types cannot be unified " + ^ "(you should not see this message, please report)" + |Some(t,ty1,ty2) -> + let ty1 = solve env ty1 and ty2 = solve env ty2 in + let sty1 = string_of_pretype (free_stvs ty2) ty1 in + let sty2 = string_of_pretype (free_stvs ty1) ty2 in + let default_msg s = + " " ^ s ^ " cannot have type " ^ sty1 ^ " and " ^ sty2 + ^ " simultaneously" + in + match t with + |Constp(s,_) -> + " " ^ s ^ " has type " ^ string_of_type (get_const_type s) ^ ", " + ^ "it cannot be used with type " ^ sty2 + |Varp(s,_) -> default_msg s + |t -> default_msg (string_of_preterm t) + in + + + + + + let rec istrivial ptm env x = function + |Stv y as t -> + y = x or defined env y & istrivial ptm env x (apply env y) + |Ptycon(f,args) as t when exists (istrivial ptm env x) args -> + failwith (string_of_ty_error env ptm) + |(Ptycon _ | Utv _) -> false + in + + let unify ptm env ty1 ty2 = + let rec unify env = function + |[] -> env + |(ty1,ty2,_)::oth when ty1 = ty2 -> unify env oth + |(Ptycon(f,fargs),Ptycon(g,gargs),ptm)::oth -> + if f = g & length fargs = length gargs + then unify env (map2 (fun x y -> x,y,ptm) fargs gargs @ oth) + else failwith (string_of_ty_error env ptm) + |(Stv x,t,ptm)::oth -> + if defined env x then unify env ((apply env x,t,ptm)::oth) + else unify (if istrivial ptm env x t then env else (x|->t) env) oth + |(t,Stv x,ptm)::oth -> unify env ((Stv x,t,ptm)::oth) + |(_,_,ptm)::oth -> failwith (string_of_ty_error env ptm) + in + unify env [ty1,ty2,match ptm with None -> None | Some t -> Some(t,ty1,ty2)] + in + + + + + + let rec typify ty (ptm,venv,uenv) = + match ptm with + |Varp(s,_) when can (assoc s) venv -> + let ty' = assoc s venv in + Varp(s,ty'),[],unify (Some ptm) uenv ty' ty + |Varp(s,_) when can num_of_string s -> + let t = pmk_numeral(num_of_string s) in + let ty' = Ptycon("num",[]) in + t,[],unify (Some ptm) uenv ty' ty + |Varp(s,_) -> + warn (s <> "" & isnum s) "Non-numeral begins with a digit"; + if not(is_hidden s) & can get_generic_type s then + let pty = pretype_instance(get_generic_type s) in + let ptm = Constp(s,pty) in + ptm,[],unify (Some ptm) uenv pty ty + else + let ptm = Varp(s,ty) in + if not(can get_var_type s) then ptm,[s,ty],uenv + else + let pty = pretype_instance(get_var_type s) in + ptm,[s,ty],unify (Some ptm) uenv pty ty + |Combp(f,x) -> + let ty'' = new_type_var() in + let ty' = Ptycon("fun",[ty'';ty]) in + let f',venv1,uenv1 = typify ty' (f,venv,uenv) in + let x',venv2,uenv2 = typify ty'' (x,venv1@venv,uenv1) in + Combp(f',x'),(venv1@venv2),uenv2 + |Typing(tm,pty) -> typify ty (tm,venv,unify (Some tm) uenv ty pty) + |Absp(v,bod) -> + let ty',ty'' = + match ty with + |Ptycon("fun",[ty';ty'']) -> ty',ty'' + |_ -> new_type_var(),new_type_var() + in + let ty''' = Ptycon("fun",[ty';ty'']) in + let uenv0 = unify (Some ptm) uenv ty''' ty in + let v',venv1,uenv1 = + let v',venv1,uenv1 = typify ty' (v,[],uenv0) in + match v' with + |Constp(s,_) when !ignore_constant_varstruct -> + Varp(s,ty'),[s,ty'],uenv0 + |_ -> v',venv1,uenv1 + in + let bod',venv2,uenv2 = typify ty'' (bod,venv1@venv,uenv1) in + Absp(v',bod'),venv2,uenv2 + |_ -> failwith "typify: unexpected constant at this stage" + in + + + + + + let rec resolve_interface ptm cont env = + match ptm with + Combp(f,x) -> resolve_interface f (resolve_interface x cont) env + | Absp(v,bod) -> resolve_interface v (resolve_interface bod cont) env + | Varp(_,_) -> cont env + | Constp(s,ty) -> + let maps = filter (fun (s',_) -> s' = s) (!the_interface) in + if maps = [] then cont env else + tryfind (fun (_,(_,ty')) -> + let ty' = pretype_instance ty' in + cont(unify (Some ptm) env ty' ty)) maps + in + + + + + + let rec solve_preterm env ptm = + match ptm with + Varp(s,ty) -> Varp(s,solve env ty) + | Combp(f,x) -> Combp(solve_preterm env f,solve_preterm env x) + | Absp(v,bod) -> Absp(solve_preterm env v,solve_preterm env bod) + | Constp(s,ty) -> let tys = solve env ty in + try let _,(c',_) = find + (fun (s',(c',ty')) -> + s = s' & can (unify None env (pretype_instance ty')) ty) + (!the_interface) in + pmk_cv(c',tys) + with Failure _ -> Constp(s,tys) + in + + + + + + let stvs_translated = ref false in + + + + + + let rec type_of_pretype ty = + match ty with + Stv n -> stvs_translated := true; + let s = "?"^(string_of_int n) in + mk_vartype(s) + | Utv(v) -> mk_vartype(v) + | Ptycon(con,args) -> mk_type(con,map type_of_pretype args) in + + + + + + let term_of_preterm = + let rec term_of_preterm ptm = + match ptm with + Varp(s,pty) -> mk_var(s,type_of_pretype pty) + | Constp(s,pty) -> mk_mconst(s,type_of_pretype pty) + | Combp(l,r) -> mk_comb(term_of_preterm l,term_of_preterm r) + | Absp(v,bod) -> mk_gabs(term_of_preterm v,term_of_preterm bod) + | Typing(ptm,pty) -> term_of_preterm ptm in + let report_type_invention () = + if !stvs_translated then + if !type_invention_error + then failwith "typechecking error (cannot infer type of variables)" + else warn !type_invention_warning "inventing type variables" in + fun ptm -> stvs_translated := false; + let tm = term_of_preterm ptm in + report_type_invention (); tm in + + + + + + let retypecheck venv ptm = + let ty = new_type_var() in + let ptm',_,env = + try typify ty (ptm,venv,undefined) + with Failure e -> failwith + ("typechecking error (initial type assignment):" ^ e) in + let env' = + try resolve_interface ptm' (fun e -> e) env + with Failure _ -> failwith "typechecking error (overload resolution)" in + let ptm'' = solve_preterm env' ptm' in + ptm'' in + + type_of_pretype,term_of_preterm,retypecheck;; diff --git a/src/holyhammer/hh/hh1/printer.ml b/src/holyhammer/hh/hh1/printer.ml new file mode 100644 index 0000000000..9cd1414ebf --- /dev/null +++ b/src/holyhammer/hh/hh1/printer.ml @@ -0,0 +1,540 @@ + + + + + + + + + + +open Lib;; +open Fusion;; +open Basics;; +open Num;; + + + + + +let isspace,issep,isbra,issymb,isalpha,isnum,isalnum = + let charcode s = Char.code(String.get s 0) in + let spaces = " \t\n\r" + and separators = ",;" + and brackets = "()[]{}" + and symbs = "\\!@#$%^&*-+|\\<=>/?~.:" + and alphas = "'abcdefghijklmnopqrstuvwxyz_ABCDEFGHIJKLMNOPQRSTUVWXYZ" + and nums = "0123456789" in + let allchars = spaces^separators^brackets^symbs^alphas^nums in + let csetsize = itlist (o max charcode) (explode allchars) 256 in + let ctable = Array.make csetsize 0 in + do_list (fun c -> Array.set ctable (charcode c) 1) (explode spaces); + do_list (fun c -> Array.set ctable (charcode c) 2) (explode separators); + do_list (fun c -> Array.set ctable (charcode c) 4) (explode brackets); + do_list (fun c -> Array.set ctable (charcode c) 8) (explode symbs); + do_list (fun c -> Array.set ctable (charcode c) 16) (explode alphas); + do_list (fun c -> Array.set ctable (charcode c) 32) (explode nums); + let isspace c = Array.get ctable (charcode c) = 1 + and issep c = Array.get ctable (charcode c) = 2 + and isbra c = Array.get ctable (charcode c) = 4 + and issymb c = Array.get ctable (charcode c) = 8 + and isalpha c = Array.get ctable (charcode c) = 16 + and isnum c = Array.get ctable (charcode c) = 32 + and isalnum c = Array.get ctable (charcode c) >= 16 in + isspace,issep,isbra,issymb,isalpha,isnum,isalnum;; + + + + + +let reserve_words,unreserve_words,is_reserved_word,reserved_words = + let reswords = ref ["("; ")"; "["; "]"; "{"; "}"; + ":"; ";"; "."; "|"; + "let"; "in"; "and"; "if"; "then"; "else"; + "match"; "with"; "function"; "->"; "when"] in + (fun ns -> reswords := union (!reswords) ns), + (fun ns -> reswords := subtract (!reswords) ns), + (fun n -> mem n (!reswords)), + (fun () -> !reswords);; + + + + + + + + + + + + + + +let unparse_as_binder,parse_as_binder,parses_as_binder,binders = + let binder_list = ref ([]:string list) in + (fun n -> binder_list := subtract (!binder_list) [n]), + (fun n -> binder_list := union (!binder_list) [n]), + (fun n -> mem n (!binder_list)), + (fun () -> !binder_list);; + +let unparse_as_prefix,parse_as_prefix,is_prefix,prefixes = + let prefix_list = ref ([]:string list) in + (fun n -> prefix_list := subtract (!prefix_list) [n]), + (fun n -> prefix_list := union (!prefix_list) [n]), + (fun n -> mem n (!prefix_list)), + (fun () -> !prefix_list);; + +let unparse_as_infix,parse_as_infix,get_infix_status,infixes = + let cmp (s,(x,a)) (t,(y,b)) = + x < y or x = y & a > b or x = y & a = b & s < t in + let infix_list = ref ([]:(string * (int * string)) list) in + (fun n -> infix_list := filter (o ((<>) n) fst) (!infix_list)), + (fun (n,d) -> infix_list := sort cmp + ((n,d)::(filter (o ((<>) n) fst) (!infix_list)))), + (fun n -> assoc n (!infix_list)), + (fun () -> !infix_list);; + + + + + +let the_interface = ref ([] :(string * (string * hol_type)) list);; + +let the_overload_skeletons = ref ([] : (string * hol_type) list);; + + + + + +include Format;; + +set_max_boxes 100;; + + + + + +let reverse_interface_mapping = ref true;; + + + + + +let unspaced_binops = ref [","; ".."; "$"];; + + + + + +let prebroken_binops = ref ["==>"];; + + + + + +let print_unambiguous_comprehensions = ref false;; + + + + + +let typify_universal_set = ref true;; + + + + + +let print_all_thm = ref true;; + + + + + +let name_of tm = + match tm with + Var(x,ty) -> x + | Const(x,ty) -> Hashtbl.find hash_const_name x + | _ -> "";; + + + + + +let pp_print_type,pp_print_qtype = + let soc sep flag ss = + if ss = [] then "" else + let s = end_itlist (fun s1 s2 -> s1^sep^s2) ss in + if flag then "("^s^")" else s in + let rec sot pr ty = + try dest_vartype ty with Failure _ -> + match dest_type ty with + con,[] -> con + | "fun",[ty1;ty2] -> soc "->" (pr > 0) [sot 1 ty1; sot 0 ty2] + | "sum",[ty1;ty2] -> soc "+" (pr > 2) [sot 3 ty1; sot 2 ty2] + | "prod",[ty1;ty2] -> soc "#" (pr > 4) [sot 5 ty1; sot 4 ty2] + | "cart",[ty1;ty2] -> soc "^" (pr > 6) [sot 6 ty1; sot 7 ty2] + | con,args -> (soc "," true (map (sot 0) args))^con in + (fun fmt ty -> pp_print_string fmt (sot 0 ty)), + (fun fmt ty -> pp_print_string fmt ("`:" ^ sot 0 ty ^ "`"));; + + + + + +let install_user_printer,delete_user_printer,try_user_printer = + let user_printers = ref ([]:(string*(term->unit))list) in + (fun pr -> user_printers := pr::(!user_printers)), + (fun s -> user_printers := snd(remove (fun (s',_) -> s = s') + (!user_printers))), + (fun tm -> tryfind (fun (_,pr) -> pr tm) (!user_printers));; + + + + + +let pp_print_term = + let reverse_interface (s0,ty0) = + if not(!reverse_interface_mapping) then s0 else + try fst(find (fun (s,(s',ty)) -> s' = s0 & can (type_match ty ty0) []) + (!the_interface)) + with Failure _ -> s0 in + let dEST_BINARY c tm = + try let il,r = dest_comb tm in + let i,l = dest_comb il in + if i = c or + (is_const i & is_const c & + reverse_interface(dest_const i) = reverse_interface(dest_const c)) + then l,r else fail() + with Failure _ -> failwith "DEST_BINARY" + and aRIGHT s = + match snd(get_infix_status s) with + "right" -> true | _ -> false in + let rec powerof10 n = + if abs_num n true + | Const(7,_) -> false + | _ -> failwith "bool_of_term" in + let code_of_term t = + let f,tms = strip_comb t in + if not(is_const f & fst(dest_const f) = "ASCII") + or not(length tms = 8) then failwith "code_of_term" + else + itlist (fun b f -> if b then 1 + 2 * f else 2 * f) + (map bool_of_term (rev tms)) 0 in + let rec dest_clause tm = + let pbod = snd(strip_exists(body(body tm))) in + let s,args = strip_comb pbod in + if name_of s = "_UNGUARDED_PATTERN" & length args = 2 then + [rand(rator(hd args));rand(rator(hd(tl args)))] + else if name_of s = "_GUARDED_PATTERN" & length args = 3 then + [rand(rator(hd args)); hd(tl args); rand(rator(hd(tl(tl args))))] + else failwith "dest_clause" in + let rec dest_clauses tm = + let s,args = strip_comb tm in + if name_of s = "_SEQPATTERN" & length args = 2 then + dest_clause (hd args)::dest_clauses(hd(tl args)) + else [dest_clause tm] in + fun fmt -> + let rec print_term prec tm = + try try_user_printer tm with Failure _ -> + try pp_print_string fmt (string_of_num(dest_numeral tm)) with Failure _ -> + try (let tms = dest_list tm in + try if fst(dest_type(hd(snd(dest_type(type_of tm))))) <> "char" + then fail() else + let ccs = map (o (String.make 1) (o Char.chr code_of_term)) tms in + let s = "\"" ^ String.escaped (implode ccs) ^ "\"" in + pp_print_string fmt s + with Failure _ -> + pp_print_string fmt "["; + print_term_sequence "; " 0 tms; + pp_print_string fmt "]") + with Failure _ -> + if is_gabs tm then print_binder prec tm else + let hop,args = strip_comb tm in + let s0 = name_of hop + and ty0 = type_of hop in + let s = reverse_interface (s0,ty0) in + try if s = "EMPTY" & is_const tm & args = [] then + pp_print_string fmt "{}" else fail() + with Failure _ -> + try if s = "UNIV" & !typify_universal_set & is_const tm & args = [] then + let ty = fst(dest_fun_ty(type_of tm)) in + (pp_print_string fmt "(:"; + pp_print_type fmt ty; + pp_print_string fmt ")") + else fail() + with Failure _ -> + try if s <> "INSERT" then fail() else + let mems,oth = splitlist (dest_binary "INSERT") tm in + if is_const oth & fst(dest_const oth) = "EMPTY" then + (pp_print_string fmt "{"; + print_term_sequence ", " 14 mems; + pp_print_string fmt "}") + else fail() + with Failure _ -> + try if not (s = "GSPEC") then fail() else + let evs,bod = strip_exists(body(rand tm)) in + let bod1,fabs = dest_comb bod in + let bod2,babs = dest_comb bod1 in + let c = rator bod2 in + if fst(dest_const c) <> "SETSPEC" then fail() else + pp_print_string fmt "{"; + print_term 0 fabs; + pp_print_string fmt " | "; + (let fvs = frees fabs and bvs = frees babs in + if not(!print_unambiguous_comprehensions) & + set_eq evs + (if (length fvs <= 1 or bvs = []) then fvs + else intersect fvs bvs) + then () + else (print_term_sequence "," 14 evs; + pp_print_string fmt " | ")); + print_term 0 babs; + pp_print_string fmt "}" + with Failure _ -> + try let eqs,bod = dest_let tm in + (if prec = 0 then pp_open_hvbox fmt 0 + else (pp_open_hvbox fmt 1; pp_print_string fmt "("); + pp_print_string fmt "let "; + print_term 0 (mk_eq(hd eqs)); + do_list (fun (v,t) -> pp_print_break fmt 1 0; + pp_print_string fmt "and "; + print_term 0 (mk_eq(v,t))) + (tl eqs); + pp_print_string fmt " in"; + pp_print_break fmt 1 0; + print_term 0 bod; + if prec = 0 then () else pp_print_string fmt ")"; + pp_close_box fmt ()) + with Failure _ -> try + if s <> "DECIMAL" then fail() else + let n_num = dest_numeral (hd args) + and n_den = dest_numeral (hd(tl args)) in + if not(powerof10 n_den) then fail() else + let s_num = string_of_num(quo_num n_num n_den) in + let s_den = implode(tl(explode(string_of_num + (n_den +/ (mod_num n_num n_den))))) in + pp_print_string fmt("#"^s_num^(if n_den = Int 1 then "" else ".")^s_den) + with Failure _ -> try + if s <> "_MATCH" or length args <> 2 then failwith "" else + let cls = dest_clauses(hd(tl args)) in + (if prec = 0 then () else pp_print_string fmt "("; + pp_open_hvbox fmt 0; + pp_print_string fmt "match "; + print_term 0 (hd args); + pp_print_string fmt " with"; + pp_print_break fmt 1 2; + print_clauses cls; + pp_close_box fmt (); + if prec = 0 then () else pp_print_string fmt ")") + with Failure _ -> try + if s <> "_FUNCTION" or length args <> 1 then failwith "" else + let cls = dest_clauses(hd args) in + (if prec = 0 then () else pp_print_string fmt "("; + pp_open_hvbox fmt 0; + pp_print_string fmt "function"; + pp_print_break fmt 1 2; + print_clauses cls; + pp_close_box fmt (); + if prec = 0 then () else pp_print_string fmt ")") + with Failure _ -> + if s = "COND" & length args = 3 then + (if prec = 0 then () else pp_print_string fmt "("; + pp_open_hvbox fmt (-1); + pp_print_string fmt "if "; + print_term 0 (hd args); + pp_print_break fmt 0 0; + pp_print_string fmt " then "; + print_term 0 (hd(tl args)); + pp_print_break fmt 0 0; + pp_print_string fmt " else "; + print_term 0 (hd(tl(tl args))); + pp_close_box fmt (); + if prec = 0 then () else pp_print_string fmt ")") + else if is_prefix s & length args = 1 then + (if prec = 1000 then pp_print_string fmt "(" else (); + pp_print_string fmt s; + (if isalnum s or + s = "--" & + length args = 1 & + (try let l,r = dest_comb(hd args) in + let s0 = name_of l and ty0 = type_of l in + reverse_interface (s0,ty0) = "--" or + mem (fst(dest_const l)) ["real_of_num"; "int_of_num"] + with Failure _ -> false) or + s = "~" & length args = 1 & is_neg(hd args) + then pp_print_string fmt " " else ()); + print_term 999 (hd args); + if prec = 1000 then pp_print_string fmt ")" else ()) + else if parses_as_binder s & length args = 1 & is_gabs (hd args) then + print_binder prec tm + else if can get_infix_status s & length args = 2 then + let bargs = + if aRIGHT s then + let tms,tmt = splitlist (dEST_BINARY hop) tm in tms@[tmt] + else + let tmt,tms = rev_splitlist (dEST_BINARY hop) tm in tmt::tms in + let newprec = fst(get_infix_status s) in + (if newprec <= prec then + (pp_open_hvbox fmt 1; pp_print_string fmt "(") + else pp_open_hvbox fmt 0; + print_term newprec (hd bargs); + do_list (fun x -> if mem s (!unspaced_binops) then () + else if mem s (!prebroken_binops) + then pp_print_break fmt 1 0 + else pp_print_string fmt " "; + pp_print_string fmt s; + if mem s (!unspaced_binops) + then pp_print_break fmt 0 0 + else if mem s (!prebroken_binops) + then pp_print_string fmt " " + else pp_print_break fmt 1 0; + print_term newprec x) (tl bargs); + if newprec <= prec then pp_print_string fmt ")" else (); + pp_close_box fmt ()) + else if (is_const hop or is_var hop) & args = [] then + let s' = if parses_as_binder s or can get_infix_status s or is_prefix s + then "("^s^")" else s in + pp_print_string fmt s' + else + let l,r = dest_comb tm in + (pp_open_hvbox fmt 0; + if prec = 1000 then pp_print_string fmt "(" else (); + print_term 999 l; + (if try mem (fst(dest_const l)) ["real_of_num"; "int_of_num"] + with Failure _ -> false + then () else pp_print_space fmt ()); + print_term 1000 r; + if prec = 1000 then pp_print_string fmt ")" else (); + pp_close_box fmt ()) + + and print_term_sequence sep prec tms = + if tms = [] then () else + (print_term prec (hd tms); + let ttms = tl tms in + if ttms = [] then () + else (pp_print_string fmt sep; print_term_sequence sep prec ttms)) + + and print_binder prec tm = + let absf = is_gabs tm in + let s = if absf then "\\" else name_of(rator tm) in + let rec collectvs tm = + if absf then + if is_abs tm then + let v,t = dest_abs tm in + let vs,bod = collectvs t in (false,v)::vs,bod + else if is_gabs tm then + let v,t = dest_gabs tm in + let vs,bod = collectvs t in (true,v)::vs,bod + else [],tm + else if is_comb tm & name_of(rator tm) = s then + if is_abs(rand tm) then + let v,t = dest_abs(rand tm) in + let vs,bod = collectvs t in (false,v)::vs,bod + else if is_gabs(rand tm) then + let v,t = dest_gabs(rand tm) in + let vs,bod = collectvs t in (true,v)::vs,bod + else [],tm + else [],tm in + let vs,bod = collectvs tm in + ((if prec = 0 then pp_open_hvbox fmt 4 + else (pp_open_hvbox fmt 5; pp_print_string fmt "(")); + pp_print_string fmt s; + (if isalnum s then pp_print_string fmt " " else ()); + do_list (fun (b,x) -> + (if b then pp_print_string fmt "(" else ()); + print_term 0 x; + (if b then pp_print_string fmt ")" else ()); + pp_print_string fmt " ") (butlast vs); + (if fst(last vs) then pp_print_string fmt "(" else ()); + print_term 0 (snd(last vs)); + (if fst(last vs) then pp_print_string fmt ")" else ()); + pp_print_string fmt "."; + (if length vs = 1 then pp_print_string fmt " " + else pp_print_space fmt ()); + print_term 0 bod; + (if prec = 0 then () else pp_print_string fmt ")"); + pp_close_box fmt ()) + and print_clauses cls = + match cls with + [c] -> print_clause c + | c::cs -> (print_clause c; + pp_print_break fmt 1 0; + pp_print_string fmt "| "; + print_clauses cs) + and print_clause cl = + match cl with + [p;g;r] -> (print_term 1 p; + pp_print_string fmt " when "; + print_term 1 g; + pp_print_string fmt " -> "; + print_term 1 r) + | [p;r] -> (print_term 1 p; + pp_print_string fmt " -> "; + print_term 1 r) + in print_term 0;; + + + + + +let pp_print_qterm fmt tm = + pp_print_string fmt "`"; + pp_print_term fmt tm; + pp_print_string fmt "`";; + + + + + +let pp_print_thm fmt th = + let asl,tm = dest_thm th in + (if not (asl = []) then + (if !print_all_thm then + (pp_print_term fmt (hd asl); + do_list (fun x -> pp_print_string fmt ","; + pp_print_space fmt (); + pp_print_term fmt x) + (tl asl)) + else pp_print_string fmt "..."; + pp_print_space fmt ()) + else (); + pp_open_hbox fmt(); + pp_print_string fmt "|- "; + pp_print_term fmt tm; + pp_close_box fmt ());; + + + + + +let print_type = pp_print_type std_formatter;; +let print_qtype = pp_print_qtype std_formatter;; +let print_term = pp_print_term std_formatter;; +let print_qterm = pp_print_qterm std_formatter;; +let print_thm = pp_print_thm std_formatter;; + + + + + + + + + +let print_to_string printer = + let sbuff = ref "" in + let output s m n = sbuff := (!sbuff)^(String.sub s m n) and flush() = () in + let fmt = make_formatter output flush in + ignore(pp_set_max_boxes fmt 100); + fun i -> ignore(printer fmt i); + ignore(pp_print_flush fmt ()); + let s = !sbuff in sbuff := ""; s;; + +let string_of_type = print_to_string pp_print_type;; +let string_of_term = print_to_string pp_print_term;; +let string_of_thm = print_to_string pp_print_thm;; diff --git a/src/holyhammer/hh/hh1/simp.ml b/src/holyhammer/hh/hh1/simp.ml new file mode 100644 index 0000000000..11cb3ce1e2 --- /dev/null +++ b/src/holyhammer/hh/hh1/simp.ml @@ -0,0 +1,216 @@ +open Lib;; +open Fusion;; +open Basics;; +open Hl_parser;; +(*open Nets;;*) +open Equal;; +open Drule;; +open Tactics;; +open Bool;; + +type term_label = Vnet + | Lcnet of (string * int) + | Cnet of (string * int) + | Lnet of int;; + +type 'a net = Netnode of (term_label * 'a net) list * 'a list;; + +let empty_net = Netnode([],[]);; + +let enter = + let label_to_store lconsts tm = + let op,args = strip_comb tm in + if is_const op then Cnet(fst(dest_const op),length args),args + else if is_abs op then + let bv,bod = dest_abs op in + let bod' = if mem bv lconsts then vsubst [genvar(type_of bv),bv] bod + else bod in + Lnet(length args),bod'::args + else if mem op lconsts then Lcnet(fst(dest_var op),length args),args + else Vnet,[] in + let canon_eq x y = + try Pervasives.compare x y = 0 with Invalid_argument _ -> false + and canon_lt x y = + try Pervasives.compare x y < 0 with Invalid_argument _ -> false in + let rec sinsert x l = + if l = [] then [x] else + let h = hd l in + if canon_eq h x then failwith "sinsert" else + if canon_lt x h then x::l else + h::(sinsert x (tl l)) in + let set_insert x l = try sinsert x l with Failure "sinsert" -> l in + let rec net_update lconsts (elem,tms,Netnode(edges,tips)) = + match tms with + [] -> Netnode(edges,set_insert elem tips) + | (tm::rtms) -> + let label,ntms = label_to_store lconsts tm in + let child,others = + try (f_f snd iii) (remove (fun (x,y) -> x = label) edges) + with Failure _ -> (empty_net,edges) in + let new_child = net_update lconsts (elem,ntms@rtms,child) in + Netnode ((label,new_child)::others,tips) in + fun lconsts (tm,elem) net -> net_update lconsts (elem,[tm],net);; + +let lookup = + let label_for_lookup tm = + let op,args = strip_comb tm in + if is_const op then Cnet(fst(dest_const op),length args),args + else if is_abs op then Lnet(length args),(body op)::args + else Lcnet(fst(dest_var op),length args),args in + let rec follow (tms,Netnode(edges,tips)) = + match tms with + [] -> tips + | (tm::rtms) -> + let label,ntms = label_for_lookup tm in + let collection = + try let child = assoc label edges in + follow(ntms @ rtms, child) + with Failure _ -> [] in + if label = Vnet then collection else + try collection @ follow(rtms,assoc Vnet edges) + with Failure _ -> collection in + fun tm net -> follow([tm],net);; + +type gconv = int * conv;; +let rEWR_CONV = pART_MATCH lhs;; +let iMP_REWR_CONV = pART_MATCH (o lhs (o snd dest_imp));; +let oRDERED_REWR_CONV ord th = + let basic_conv = rEWR_CONV th in + fun tm -> + let thm = basic_conv tm in + let l,r = dest_eq(concl thm) in + if ord l r then thm + else failwith "ORDERED_REWR_CONV: wrong orientation";; +let oRDERED_IMP_REWR_CONV ord th = + let basic_conv = iMP_REWR_CONV th in + fun tm -> + let thm = basic_conv tm in + let l,r = dest_eq(rand(concl thm)) in + if ord l r then thm + else failwith "ORDERED_IMP_REWR_CONV: wrong orientation";; + + +let term_order = + let rec lexify ord l1 l2 = + if l1 = [] then false + else if l2 = [] then true else + let h1 = hd l1 and h2 = hd l2 in + ord h1 h2 or (h1 = h2 & lexify ord (tl l1) (tl l2)) in + let rec dyn_order top tm1 tm2 = + let f1,args1 = strip_comb tm1 + and f2,args2 = strip_comb tm2 in + if f1 = f2 then + lexify (dyn_order f1) args1 args2 + else + if f2 = top then false + else if f1 = top then true + else f1 > f2 in + dyn_order (parse_term "T");; +let net_of_thm rep th = + let tm = concl th in + let lconsts = freesl (hyp th) in + let matchable = o can (term_match lconsts) in + match tm with + Comb(Comb(Const(0,_),(Abs(x,Comb(Var(s,ty) as v,x')) as l)),v') + when x' = x & v' = v & not(x = v) -> + let conv tm = + match tm with + Abs(y,Comb(t,y')) when y = y' & not(free_in y t) -> + iNSTANTIATE(term_match [] v t) th + | _ -> failwith "REWR_CONV (eTA_AX special case)" in + enter lconsts (l,(1,conv)) + | Comb(Comb(Const(0,_),l),r) -> + if rep & free_in l r then + let th' = eQT_INTRO th in + enter lconsts (l,(1,rEWR_CONV th')) + else if rep & matchable l r & matchable r l then + enter lconsts (l,(1,oRDERED_REWR_CONV term_order th)) + else enter lconsts (l,(1,rEWR_CONV th)) + | Comb(Comb(_,t),Comb(Comb(Const(0,_),l),r)) -> + if rep & free_in l r then + let th' = dISCH t (eQT_INTRO(uNDISCH th)) in + enter lconsts (l,(3,iMP_REWR_CONV th')) + else if rep & matchable l r & matchable r l then + enter lconsts (l,(3,oRDERED_IMP_REWR_CONV term_order th)) + else enter lconsts(l,(3,iMP_REWR_CONV th));; +let net_of_conv tm conv sofar = + enter [] (tm,(2,conv)) sofar;; +let mk_rewrites = + let iMP_CONJ_CONV = rEWR_CONV(Sequent ([], parse_term "p ==> q ==> r <=> p /\\ q ==> r")) + and iMP_EXISTS_RULE = + let cnv = rEWR_CONV(Sequent ([], parse_term "(!x. P x ==> Q) <=> (?x. P x) ==> Q")) in + fun v th -> cONV_RULE cnv (gEN v th) in + let collect_condition oldhyps th = + let conds = subtract (hyp th) oldhyps in + if conds = [] then th else + let jth = itlist dISCH conds th in + let kth = cONV_RULE (rEPEATC iMP_CONJ_CONV) jth in + let cond,eqn = dest_imp(concl kth) in + let fvs = subtract (subtract (frees cond) (frees eqn)) (freesl oldhyps) in + itlist iMP_EXISTS_RULE fvs kth in + let rec split_rewrites oldhyps cf th sofar = + let tm = concl th in + if is_forall tm then + split_rewrites oldhyps cf (sPEC_ALL th) sofar + else if is_conj tm then + split_rewrites oldhyps cf (cONJUNCT1 th) + (split_rewrites oldhyps cf (cONJUNCT2 th) sofar) + else if is_imp tm & cf then + split_rewrites oldhyps cf (uNDISCH th) sofar + else if is_eq tm then + (if cf then collect_condition oldhyps th else th)::sofar + else if is_neg tm then + let ths = split_rewrites oldhyps cf (eQF_INTRO th) sofar in + if is_eq (rand tm) + then split_rewrites oldhyps cf (eQF_INTRO (gSYM th)) ths + else ths + else + split_rewrites oldhyps cf (eQT_INTRO th) sofar in + fun cf th sofar -> split_rewrites (hyp th) cf th sofar;; +let rEWRITES_CONV net tm = + let pconvs = lookup tm net in + try tryfind (fun (_,cnv) -> cnv tm) pconvs + with Failure _ -> failwith "REWRITES_CONV";; +let set_basic_rewrites,extend_basic_rewrites,basic_rewrites, + set_basic_convs,extend_basic_convs,basic_convs,basic_net = + let rewrites = ref ([]:thm list) + and conversions = ref ([]:(string*(term*conv))list) + and conv_net = ref (empty_net: gconv net) in + let rehash_convnet() = + conv_net := itlist (net_of_thm true) (!rewrites) + (itlist (fun (_,(pat,cnv)) -> net_of_conv pat cnv) (!conversions) + empty_net) in + let set_basic_rewrites thl = + let canon_thl = itlist (mk_rewrites false) thl [] in + (rewrites := canon_thl; rehash_convnet()) + and extend_basic_rewrites thl = + let canon_thl = itlist (mk_rewrites false) thl [] in + (rewrites := canon_thl @ !rewrites; rehash_convnet()) + and basic_rewrites() = !rewrites + and set_basic_convs cnvs = + (conversions := cnvs; rehash_convnet()) + and extend_basic_convs (name,patcong) = + (conversions := + (name,patcong)::filter(fun (name',_) -> name <> name') (!conversions); + rehash_convnet()) + and basic_convs() = !conversions + and basic_net() = !conv_net in + set_basic_rewrites,extend_basic_rewrites,basic_rewrites, + set_basic_convs,extend_basic_convs,basic_convs,basic_net;; +let gENERAL_REWRITE_CONV rep (cnvl:conv->conv) (builtin_net:gconv net) thl = + let thl_canon = itlist (mk_rewrites false) thl [] in + let final_net = itlist (net_of_thm rep) thl_canon builtin_net in + cnvl (rEWRITES_CONV final_net);; +let gEN_REWRITE_CONV (cnvl:conv->conv) thl = + gENERAL_REWRITE_CONV false cnvl empty_net thl;; + +let gEN_REWRITE_RULE cnvl thl = cONV_RULE(gEN_REWRITE_CONV cnvl thl);; + +let pURE_REWRITE_CONV thl = + gENERAL_REWRITE_CONV true tOP_DEPTH_CONV empty_net thl;; +let oNCE_REWRITE_CONV thl = + gENERAL_REWRITE_CONV false oNCE_DEPTH_CONV (basic_net()) thl;; +let pURE_REWRITE_RULE thl = cONV_RULE(pURE_REWRITE_CONV thl);; +let pURE_REWRITE_TAC thl = cONV_TAC(pURE_REWRITE_CONV thl);; +let (++++++) x y = oRELSE x y;; +let (++++) x y = tHEN x y;; diff --git a/src/holyhammer/hh/hh1/tactics.ml b/src/holyhammer/hh/hh1/tactics.ml new file mode 100644 index 0000000000..f200f819c2 --- /dev/null +++ b/src/holyhammer/hh/hh1/tactics.ml @@ -0,0 +1,374 @@ + + + + + + + + + + +open Lib;; +open Fusion;; +open Basics;; +open Printer;; +open Hl_parser;; +open Equal;; +open Bool;; +open Drule;; + + + + + +let null_inst = ([],[],[] :instantiation);; + +let null_meta = (([]:term list),null_inst);; + + + + + +type goal = (string * thm) list * term;; + +let equals_goal ((a,w):goal) ((a',w'):goal) = + forall2 (fun (s,th) (s',th') -> s = s' & equals_thm th th') a a' & w = w';; + + + + + + + + + +type justification = instantiation -> thm list -> thm;; + + + + + + +type goalstate = (term list * instantiation) * goal list * justification;; + + + + + +type goalstack = goalstate list;; + + + + + + + +type refinement = goalstate -> goalstate;; + + + + + + + + + + + +type tactic = goal -> goalstate;; + +type thm_tactic = thm -> tactic;; + +type thm_tactical = thm_tactic -> thm_tactic;; + + + + + +let (inst_goal:instantiation->goal->goal) = + fun p (thms,w) -> + map (f_f iii (iNSTANTIATE_ALL p)) thms,instantiate p w;; + + + + + +let (compose_insts :instantiation->instantiation->instantiation) = + fun (pats1,tmin1,tyin1) ((pats2,tmin2,tyin2) as i2) -> + let tmin = map (f_f (instantiate i2) (inst tyin2)) tmin1 + and tyin = map (f_f (type_subst tyin2) iii) tyin1 in + let tmin' = filter (fun (_,x) -> not (can (rev_assoc x) tmin)) tmin2 + and tyin' = filter (fun (_,a) -> not (can (rev_assoc a) tyin)) tyin2 in + pats1@pats2,tmin@tmin',tyin@tyin';; + + + + + + + + + +let (tHEN),(tHENL) = + let propagate_empty i [] = [] in + let propagate_thm th i [] = iNSTANTIATE_ALL i th in + let compose_justs n just1 just2 i ths = + let ths1,ths2 = chop_list n ths in + (just1 i ths1)::(just2 i ths2) in + let rec seqapply l1 l2 = match (l1,l2) with + ([],[]) -> null_meta,[],propagate_empty + | ((tac:tactic)::tacs),((goal:goal)::goals) -> + let ((mvs1,insts1),gls1,just1) = tac goal in + let goals' = map (inst_goal insts1) goals in + let ((mvs2,insts2),gls2,just2) = seqapply tacs goals' in + ((union mvs1 mvs2,compose_insts insts1 insts2), + gls1@gls2,compose_justs (length gls1) just1 just2) + | _,_ -> failwith "seqapply: Length mismatch" in + let justsequence just1 just2 insts2 i ths = + just1 (compose_insts insts2 i) (just2 i ths) in + let tacsequence ((mvs1,insts1),gls1,just1) tacl = + let ((mvs2,insts2),gls2,just2) = seqapply tacl gls1 in + let jst = justsequence just1 just2 insts2 in + let just = if gls2 = [] then propagate_thm (jst null_inst []) else jst in + ((union mvs1 mvs2,compose_insts insts1 insts2),gls2,just) in + let (then_: tactic -> tactic -> tactic) = + fun tac1 tac2 g -> + let _,gls,_ as gstate = tac1 g in + tacsequence gstate (replicate tac2 (length gls)) + and (thenl_: tactic -> tactic list -> tactic) = + fun tac1 tac2l g -> + let _,gls,_ as gstate = tac1 g in + if gls = [] then tacsequence gstate [] + else tacsequence gstate tac2l in + then_,thenl_;; + +let ((oRELSE): tactic -> tactic -> tactic) = + fun tac1 tac2 g -> + try tac1 g with Failure _ -> tac2 g;; + +let (fAIL_TAC: string -> tactic) = + fun tok g -> failwith tok;; + +let (nO_TAC: tactic) = + fAIL_TAC "NO_TAC";; + +let (aLL_TAC:tactic) = + fun g -> null_meta,[g],fun _ [th] -> th;; + +let rec rEPEAT tac g = + (oRELSE (tHEN tac (rEPEAT tac)) aLL_TAC) g;; + +let eVERY tacl = + itlist (fun t1 t2 -> tHEN t1 t2) tacl aLL_TAC;; + +let mAP_EVERY tacf lst = + eVERY (map tacf lst);; + +let (lABEL_TAC: string -> thm_tactic) = + fun s thm (asl,w) -> + null_meta,[(s,thm)::asl,w], + fun i [th] -> pROVE_HYP (iNSTANTIATE_ALL i thm) th;; + +let aSSUME_TAC = lABEL_TAC "";; + + + + + +let (pOP_ASSUM: thm_tactic -> tactic) = + fun ttac -> + function (((_,th)::asl),w) -> ttac th (asl,w) + | _ -> failwith "POP_ASSUM: No assumption to pop";; + +let (aSSUM_LIST: (thm list -> tactic) -> tactic) = + fun aslfun (asl,w) -> aslfun (map snd asl) (asl,w);; + +let (pOP_ASSUM_LIST: (thm list -> tactic) -> tactic) = + fun asltac (asl,w) -> asltac (map snd asl) ([],w);; + +let (eVERY_ASSUM: thm_tactic -> tactic) = + fun ttac -> aSSUM_LIST (mAP_EVERY ttac);; + +let (fIRST_ASSUM: thm_tactic -> tactic) = + fun ttac (asl,w as g) -> tryfind (fun (_,th) -> ttac th g) asl;; + +let (uNDISCH_THEN:term->thm_tactic->tactic) = + fun tm ttac (asl,w) -> + let thp,asl' = remove (fun (_,th) -> aconv (concl th) tm) asl in + ttac (snd thp) (asl',w);; + +let fIRST_X_ASSUM ttac = + fIRST_ASSUM(fun th -> uNDISCH_THEN (concl th) ttac);; + +let (rULE_ASSUM_TAC :(thm->thm)->tactic) = + fun rule (asl,w) -> (tHEN (pOP_ASSUM_LIST(kkk aLL_TAC)) + (mAP_EVERY (fun (s,th) -> lABEL_TAC s (rule th)) + (rev asl))) (asl,w);; + + + + + + + +let (aCCEPT_TAC: thm_tactic) = + let propagate_thm th i [] = iNSTANTIATE_ALL i th in + fun th (asl,w) -> + if aconv (concl th) w then + null_meta,[],propagate_thm th + else failwith "ACCEPT_TAC";; + + + + + + + +let (cONV_TAC: conv -> tactic) = + let t_tm = parse_term "T" in + fun conv ((asl,w) as g) -> + let th = conv w in + let tm = concl th in + if aconv tm w then aCCEPT_TAC th g else + let l,r = dest_eq tm in + if not(aconv l w) then failwith "CONV_TAC: bad equation" else + if r = t_tm then aCCEPT_TAC(eQT_ELIM th) g else + let th' = sYM th in + null_meta,[asl,r],fun i [th] -> eQ_MP (iNSTANTIATE_ALL i th') th;; + + +let (dISCH_TAC: tactic) = + let f_tm = parse_term "F" in + fun (asl,w) -> + try let ant,c = dest_imp w in + let th1 = aSSUME ant in + null_meta,[("",th1)::asl,c], + fun i [th] -> dISCH (instantiate i ant) th + with Failure _ -> try + let ant = dest_neg w in + let th1 = aSSUME ant in + null_meta,[("",th1)::asl,f_tm], + fun i [th] -> nOT_INTRO(dISCH (instantiate i ant) th) + with Failure _ -> failwith "DISCH_TAC";; + +let (uNDISCH_TAC: term -> tactic) = + fun tm (asl,w) -> + try let sthm,asl' = remove (fun (_,asm) -> aconv (concl asm) tm) asl in + let thm = snd sthm in + null_meta,[asl',mk_imp(tm,w)], + fun i [th] -> mP th (iNSTANTIATE_ALL i thm) + with Failure _ -> failwith "UNDISCH_TAC";; + +let (sPEC_TAC: term * term -> tactic) = + fun (t,x) (asl,w) -> + try null_meta,[asl, mk_forall(x,subst[x,t] w)], + fun i [th] -> sPEC (instantiate i t) th + with Failure _ -> failwith "SPEC_TAC";; + +let (x_GEN_TAC: term -> tactic), + (x_CHOOSE_TAC: term -> thm_tactic), + (eXISTS_TAC: term -> tactic) = + let tactic_type_compatibility_check pfx e g = + let et = type_of e and gt = type_of g in + if et = gt then () + else failwith(pfx ^ ": expected type :"^string_of_type et^" but got :"^ + string_of_type gt) in + let x_GEN_TAC x' = + if not(is_var x') then failwith "X_GEN_TAC: not a variable" else + fun (asl,w) -> + let x,bod = try dest_forall w + with Failure _ -> failwith "X_GEN_TAC: Not universally quantified" in + let _ = tactic_type_compatibility_check "X_GEN_TAC" x x' in + let avoids = itlist (fun x -> union (thm_frees (snd x))) asl (frees w) in + if mem x' avoids then failwith "X_GEN_TAC: invalid variable" else + let afn = cONV_RULE(gEN_ALPHA_CONV x) in + null_meta,[asl,vsubst[x',x] bod], + fun i [th] -> afn (gEN x' th) + and x_CHOOSE_TAC x' xth = + let xtm = concl xth in + let x,bod = try dest_exists xtm + with Failure _ -> failwith "X_CHOOSE_TAC: not existential" in + let _ = tactic_type_compatibility_check "X_CHOOSE_TAC" x x' in + let pat = vsubst[x',x] bod in + let xth' = aSSUME pat in + fun (asl,w) -> + let avoids = itlist (fun x -> union (frees ( concl ( snd x)))) asl + (union (frees w) (thm_frees xth)) in + if mem x' avoids then failwith "X_CHOOSE_TAC: invalid variable" else + null_meta,[("",xth')::asl,w], + fun i [th] -> cHOOSE(x',iNSTANTIATE_ALL i xth) th + and eXISTS_TAC t (asl,w) = + let v,bod = try dest_exists w with Failure _ -> + failwith "EXISTS_TAC: Goal not existentially quantified" in + let _ = tactic_type_compatibility_check "EXISTS_TAC" v t in + null_meta,[asl,vsubst[t,v] bod], + fun i [th] -> eXISTS (instantiate i w,instantiate i t) th in + x_GEN_TAC,x_CHOOSE_TAC,eXISTS_TAC;; + +(*let (GEN_TAC: tactic) = + fun (asl,w) -> + try let x = fst(dest_forall w) in + let avoids = itlist (union o thm_frees o snd) asl (frees w) in + let x' = mk_primed_var avoids x in + X_GEN_TAC x' (asl,w) + with Failure _ -> failwith "GEN_TAC";; +*) + +let (cHOOSE_TAC: thm_tactic) = + fun xth -> + try let x = fst(dest_exists(concl xth)) in + fun (asl,w) -> + let avoids = itlist (fun x -> union ( thm_frees ( snd x))) asl + (union (frees w) (thm_frees xth)) in + let x' = mk_primed_var avoids x in + x_CHOOSE_TAC x' xth (asl,w) + with Failure _ -> failwith "CHOOSE_TAC";; + + +let (cONTR_TAC: thm_tactic) = + let propagate_thm th i [] = iNSTANTIATE_ALL i th in + fun cth (asl,w) -> + try let th = cONTR w cth in + null_meta,[],propagate_thm th + with Failure _ -> failwith "CONTR_TAC";; + +let (dISCH_THEN: thm_tactic -> tactic) = + fun ttac -> tHEN dISCH_TAC (pOP_ASSUM ttac);; + +let (by:tactic->refinement) = + fun tac ((mvs,inst),gls,just) -> + if gls = [] then failwith "No goal set" else + let g = hd gls + and ogls = tl gls in + let ((newmvs,newinst),subgls,subjust) = tac g in + let n = length subgls in + let mvs' = union newmvs mvs + and inst' = compose_insts inst newinst + and gls' = subgls @ map (inst_goal newinst) ogls in + let just' i ths = + let i' = compose_insts inst' i in + let cths,oths = chop_list n ths in + let sths = (subjust i cths) :: oths in + just i' sths in + (mvs',inst'),gls',just';; + +let (mk_goalstate:goal->goalstate) = + fun (asl,w) -> + if type_of w = bool_ty then + null_meta,[asl,w], + (fun inst [th] -> iNSTANTIATE_ALL inst th) + else failwith "mk_goalstate: Non-boolean goal";; + +let (tAC_PROOF : goal * tactic -> thm) = + fun (g,tac) -> + let gstate = mk_goalstate g in + let _,sgs,just = by tac gstate in + if sgs = [] then just null_inst [] + else failwith "TAC_PROOF: Unsolved goals";; + +let prove(t,tac) = + let th = tAC_PROOF(([],t),tac) in + let t' = concl th in + if t' = t then th else + try eQ_MP (aLPHA t' t) th + with Failure _ -> failwith "prove: justification generated wrong theorem";; diff --git a/src/holyhammer/hh/hh1/theorems.ml b/src/holyhammer/hh/hh1/theorems.ml new file mode 100644 index 0000000000..cf65e19abc --- /dev/null +++ b/src/holyhammer/hh/hh1/theorems.ml @@ -0,0 +1,265 @@ +open Hl_parser;; +open Fusion;; +open Bool;; +open Simp;; + +let eQ_REFL = Sequent + ([],parse_term "!x:A. x = x");; + +let rEFL_CLAUSE = Sequent + ([],parse_term "!x:A. (x = x) <=> T");; + +let eQ_SYM = Sequent + ([],parse_term "!(x:A) y. (x = y) ==> (y = x)");; + +let eQ_SYM_EQ = Sequent + ([],parse_term "!(x:A) y. (x = y) <=> (y = x)");; + +let eQ_TRANS = Sequent + ([],parse_term "!(x:A) y z. (x = y) /\\ (y = z) ==> (x = z)");; + +let aC acsuite x = eQT_ELIM (pURE_REWRITE_CONV[acsuite; rEFL_CLAUSE] x);; + +let bETA_THM = Sequent + ([],parse_term "!(f:A->B) y. (\\x. (f:A->B) x) y = f y");; + +let aBS_SIMP = Sequent + ([],parse_term "!(t1:A) (t2:B). (\\x. t1) t2 = t1");; + +(* ------------------------------------------------------------------------- *) +(* A few "big name" intuitionistic tautologies. *) +(* ------------------------------------------------------------------------- *) + +let cONJ_ASSOC = Sequent + ([],parse_term "!t1 t2 t3. t1 /\\ t2 /\\ t3 <=> (t1 /\\ t2) /\\ t3");; + +let cONJ_SYM = Sequent + ([],parse_term "!t1 t2. t1 /\\ t2 <=> t2 /\\ t1");; + +let cONJ_ACI = Sequent + ([],parse_term "(p /\\ q <=> q /\\ p) /\\ + ((p /\\ q) /\\ r <=> p /\\ (q /\\ r)) /\\ + (p /\\ (q /\\ r) <=> q /\\ (p /\\ r)) /\\ + (p /\\ p <=> p) /\\ + (p /\\ (p /\\ q) <=> p /\\ q)");; + +let dISJ_ASSOC = Sequent + ([],parse_term "!t1 t2 t3. t1 \\/ t2 \\/ t3 <=> (t1 \\/ t2) \\/ t3");; + +let dISJ_SYM = Sequent + ([],parse_term "!t1 t2. t1 \\/ t2 <=> t2 \\/ t1");; + +let dISJ_ACI = Sequent + ([],parse_term "(p \\/ q <=> q \\/ p) /\\ + ((p \\/ q) \\/ r <=> p \\/ (q \\/ r)) /\\ + (p \\/ (q \\/ r) <=> q \\/ (p \\/ r)) /\\ + (p \\/ p <=> p) /\\ + (p \\/ (p \\/ q) <=> p \\/ q)");; + +let iMP_CONJ = Sequent + ([],parse_term "p /\\ q ==> r <=> p ==> q ==> r");; + +let iMP_IMP = Equal.gSYM iMP_CONJ;; + +let iMP_CONJ_ALT = Sequent + ([],parse_term "p /\\ q ==> r <=> q ==> p ==> r");; + +(* ------------------------------------------------------------------------- *) +(* A couple of "distribution" tautologies are useful. *) +(* ------------------------------------------------------------------------- *) + +let lEFT_OR_DISTRIB = Sequent + ([],parse_term "!p q r. p /\\ (q \\/ r) <=> p /\\ q \\/ p /\\ r");; + +let rIGHT_OR_DISTRIB = Sequent + ([],parse_term "!p q r. (p \\/ q) /\\ r <=> p /\\ r \\/ q /\\ r");; + +(* ------------------------------------------------------------------------- *) +(* Degenerate cases of quantifiers. *) +(* ------------------------------------------------------------------------- *) + +let fORALL_SIMP = Sequent + ([],parse_term "!t. (!x:A. t) = t");; + +let eXISTS_SIMP = Sequent + ([],parse_term "!t. (?x:A. t) = t");; + +(* ------------------------------------------------------------------------- *) +(* I also use this a lot (as a prelude to congruence reasoning). *) +(* ------------------------------------------------------------------------- *) + +let eQ_IMP = Sequent + ([],parse_term "(a <=> b) ==> a ==> b");; + +(* ------------------------------------------------------------------------- *) +(* Start building up the basic rewrites; we add a few more later. *) +(* ------------------------------------------------------------------------- *) + +let eQ_CLAUSES = Sequent + ([],parse_term "!t. ((T <=> t) <=> t) /\\ ((t <=> T) <=> t) /\\ + ((F <=> t) <=> ~t) /\\ ((t <=> F) <=> ~t)");; + +let nOT_CLAUSES_WEAK = Sequent + ([],parse_term "(~T <=> F) /\\ (~F <=> T)");; + +let aND_CLAUSES = Sequent + ([],parse_term "!t. (T /\\ t <=> t) /\\ (t /\\ T <=> t) /\\ (F /\\ t <=> F) /\\ + (t /\\ F <=> F) /\\ (t /\\ t <=> t)");; + +let oR_CLAUSES = Sequent + ([],parse_term "!t. (T \\/ t <=> T) /\\ (t \\/ T <=> T) /\\ (F \\/ t <=> t) /\\ + (t \\/ F <=> t) /\\ (t \\/ t <=> t)");; + +let iMP_CLAUSES = Sequent + ([],parse_term "!t. (T ==> t <=> t) /\\ (t ==> T <=> T) /\\ (F ==> t <=> T) /\\ + (t ==> t <=> T) /\\ (t ==> F <=> ~t)");; + +let eXISTS_UNIQUE_THM = Sequent + ([],parse_term "!P. (?!x:A. P x) <=> (?x. P x) /\\ (!x x'. P x /\\ P x' ==> (x = x'))");; + +(* ------------------------------------------------------------------------- *) +(* Trivial instances of existence. *) +(* ------------------------------------------------------------------------- *) + +let eXISTS_REFL = Sequent + ([],parse_term "!a:A. ?x. x = a");; + +let eXISTS_UNIQUE_REFL = Sequent + ([],parse_term "!a:A. ?!x. x = a");; + +(* ------------------------------------------------------------------------- *) +(* Unwinding. *) +(* ------------------------------------------------------------------------- *) + +let uNWIND_THM1 = Sequent + ([],parse_term "!P (a:A). (?x. a = x /\\ P x) <=> P a");; + +let uNWIND_THM2 = Sequent + ([],parse_term "!P (a:A). (?x. x = a /\\ P x) <=> P a");; + +let fORALL_UNWIND_THM2 = Sequent + ([],parse_term "!P (a:A). (!x. x = a ==> P x) <=> P a");; + +let fORALL_UNWIND_THM1 = Sequent + ([],parse_term "!P a. (!x. a = x ==> P x) <=> P a");; + +(* ------------------------------------------------------------------------- *) +(* Permuting quantifiers. *) +(* ------------------------------------------------------------------------- *) + +let sWAP_FORALL_THM = Sequent + ([],parse_term "!P:A->B->bool. (!x y. P x y) <=> (!y x. P x y)");; + +let sWAP_EXISTS_THM = Sequent + ([],parse_term "!P:A->B->bool. (?x y. P x y) <=> (?y x. P x y)");; + +(* ------------------------------------------------------------------------- *) +(* Universal quantifier and conjunction. *) +(* ------------------------------------------------------------------------- *) + +let fORALL_AND_THM = Sequent + ([],parse_term "!P Q. (!x:A. P x /\\ Q x) <=> (!x. P x) /\\ (!x. Q x)");; + +let aND_FORALL_THM = Sequent + ([],parse_term "!P Q. (!x. P x) /\\ (!x. Q x) <=> (!x:A. P x /\\ Q x)");; + +let lEFT_AND_FORALL_THM = Sequent + ([],parse_term "!P Q. (!x:A. P x) /\\ Q <=> (!x:A. P x /\\ Q)");; + +let rIGHT_AND_FORALL_THM = Sequent + ([],parse_term "!P Q. P /\\ (!x:A. Q x) <=> (!x. P /\\ Q x)");; + +(* ------------------------------------------------------------------------- *) +(* Existential quantifier and disjunction. *) +(* ------------------------------------------------------------------------- *) + +let eXISTS_OR_THM = Sequent + ([],parse_term "!P Q. (?x:A. P x \\/ Q x) <=> (?x. P x) \\/ (?x. Q x)");; + +let oR_EXISTS_THM = Sequent + ([],parse_term "!P Q. (?x. P x) \\/ (?x. Q x) <=> (?x:A. P x \\/ Q x)");; + +let lEFT_OR_EXISTS_THM = Sequent + ([],parse_term "!P Q. (?x. P x) \\/ Q <=> (?x:A. P x \\/ Q)");; + +let rIGHT_OR_EXISTS_THM = Sequent + ([],parse_term "!P Q. P \\/ (?x. Q x) <=> (?x:A. P \\/ Q x)");; + +(* ------------------------------------------------------------------------- *) +(* Existential quantifier and conjunction. *) +(* ------------------------------------------------------------------------- *) + +let lEFT_EXISTS_AND_THM = Sequent + ([],parse_term "!P Q. (?x:A. P x /\\ Q) <=> (?x:A. P x) /\\ Q");; + +let rIGHT_EXISTS_AND_THM = Sequent + ([],parse_term "!P Q. (?x:A. P /\\ Q x) <=> P /\\ (?x:A. Q x)");; + +let tRIV_EXISTS_AND_THM = Sequent + ([],parse_term "!P Q. (?x:A. P /\\ Q) <=> (?x:A. P) /\\ (?x:A. Q)");; + +let lEFT_AND_EXISTS_THM = Sequent + ([],parse_term "!P Q. (?x:A. P x) /\\ Q <=> (?x:A. P x /\\ Q)");; + +let rIGHT_AND_EXISTS_THM = Sequent + ([],parse_term "!P Q. P /\\ (?x:A. Q x) <=> (?x:A. P /\\ Q x)");; + +let tRIV_AND_EXISTS_THM = Sequent + ([],parse_term "!P Q. (?x:A. P) /\\ (?x:A. Q) <=> (?x:A. P /\\ Q)");; + +(* ------------------------------------------------------------------------- *) +(* Only trivial instances of universal quantifier and disjunction. *) +(* ------------------------------------------------------------------------- *) + +let tRIV_FORALL_OR_THM = Sequent + ([],parse_term "!P Q. (!x:A. P \\/ Q) <=> (!x:A. P) \\/ (!x:A. Q)");; + +let tRIV_OR_FORALL_THM = Sequent + ([],parse_term "!P Q. (!x:A. P) \\/ (!x:A. Q) <=> (!x:A. P \\/ Q)");; + +(* ------------------------------------------------------------------------- *) +(* Implication and quantifiers. *) +(* ------------------------------------------------------------------------- *) + +let rIGHT_IMP_FORALL_THM = Sequent + ([],parse_term "!P Q. (P ==> !x:A. Q x) <=> (!x. P ==> Q x)");; + +let rIGHT_FORALL_IMP_THM = Sequent + ([],parse_term "!P Q. (!x. P ==> Q x) <=> (P ==> !x:A. Q x)");; + +let lEFT_IMP_EXISTS_THM = Sequent + ([],parse_term "!P Q. ((?x:A. P x) ==> Q) <=> (!x. P x ==> Q)");; + +let lEFT_FORALL_IMP_THM = Sequent + ([],parse_term "!P Q. (!x. P x ==> Q) <=> ((?x:A. P x) ==> Q)");; + +let tRIV_FORALL_IMP_THM = Sequent + ([],parse_term "!P Q. (!x:A. P ==> Q) <=> ((?x:A. P) ==> (!x:A. Q))");; + +let tRIV_EXISTS_IMP_THM = Sequent + ([],parse_term "!P Q. (?x:A. P ==> Q) <=> ((!x:A. P) ==> (?x:A. Q))");; + +(* ------------------------------------------------------------------------- *) +(* Alternative versions of unique existence. *) +(* ------------------------------------------------------------------------- *) + +let eXISTS_UNIQUE_ALT = Sequent + ([],parse_term "!P:A->bool. (?!x. P x) <=> (?x. !y. P y <=> (x = y))");; + +let eXISTS_UNIQUE = Sequent + ([],parse_term "!P:A->bool. (?!x. P x) <=> (?x. P x /\\ !y. P y ==> (y = x))");; + +let lEFT_FORALL_OR_THM = Sequent + ([],parse_term "!P Q. (!x:A. P x \\/ Q) <=> (!x. P x) \\/ Q");; + +let rIGHT_FORALL_OR_THM = Sequent + ([],parse_term "!P Q. (!x:A. P \\/ Q x) <=> P \\/ (!x. Q x)");; + +let sKOLEM_THM = Sequent + ([],parse_term "!P. (!x:A. ?y:B. P x y) <=> (?y. !x. P x (y x))");; + +let lEFT_OR_FORALL_THM = Sequent + ([],parse_term "!P Q. (!x:A. P x) \\/ Q <=> (!x. P x \\/ Q)");; + +let rIGHT_OR_FORALL_THM = Sequent + ([],parse_term "!P Q. P \\/ (!x:A. Q x) <=> (!x. P \\/ Q x)");; diff --git a/src/holyhammer/hh/hh_lexer.mll b/src/holyhammer/hh/hh_lexer.mll new file mode 100644 index 0000000000..336aaca83a --- /dev/null +++ b/src/holyhammer/hh/hh_lexer.mll @@ -0,0 +1,51 @@ +{ + open Lexing;; + open Hh_parse;; +} + +let white = [' ' '\t'] +let newline = ['\r' '\n'] +let letter = ['a'-'z' 'A'-'Z' '0'-'9' '_'] + +rule hh2lex = parse +| '%' [^'\n' '\r']* {hh2lex lexbuf} +| white+ {hh2lex lexbuf} +| newline {let pos = lexbuf.Lexing.lex_curr_p in + lexbuf.Lexing.lex_curr_p <- { pos with + Lexing.pos_lnum = pos.Lexing.pos_lnum + 1; + Lexing.pos_bol = pos.Lexing.pos_cnum; + }; + hh2lex lexbuf} (*...*) +| eof {TokEof} +| '(' {TokParO} +| ')' {TokParC} +| '.' {TokDot} +| ',' {TokComma} +| '!' white* '[' {TokQUni} +| '!' '>' white* '[' {TokQUni} +| '?' white* '[' {TokQExi} +| '^' white* '[' {TokLam} +| ']' white* ':' {TokSqrC} +| "!=" {TokNEq} +| '~' {TokTilde} +| "<=>" {TokEqvt} +| "<~>" {TokNEqvt} +| "=>" {TokImpl} +| '=' {TokEq} +| '&' {TokAnd} +| '|' {TokOr} +| ':' {TokColon} +| '>' {TokFun} +| '@' {TokAt} +| '\'' {TokWord ("'" ^ lex_squot lexbuf ^ "'")} +| letter+ {TokWord (Lexing.lexeme lexbuf)} +| '$' letter+ {TokWord (Lexing.lexeme lexbuf)} +(*| [^'\n' '\r']+ {TokUnknown (Lexing.lexeme lexbuf)}*) + +and lex_squot = parse +| '\'' {""} +| '\\' '\'' {"\\'" ^ lex_squot lexbuf} +| [^ '\'' '\\']+ {let s = Lexing.lexeme lexbuf in s ^ lex_squot lexbuf} + +{ +} diff --git a/src/holyhammer/hh/hh_parse.mly b/src/holyhammer/hh/hh_parse.mly new file mode 100644 index 0000000000..1d3fc7e8dd --- /dev/null +++ b/src/holyhammer/hh/hh_parse.mly @@ -0,0 +1,75 @@ +%{ + type hhterm = + Id of string (* may be a constant or variable *) + | Comb of hhterm * hhterm + | Abs of string * hhterm * hhterm;; (* name of introduced id, type and subterm *) + + let mk_uni s t = Comb (Id s, t);; + let mk_neg t = mk_uni "~" t;; + let mk_bin s t1 t2 = Comb (mk_uni s t1, t2);; + let mk_lam l t = List.fold_right (fun (n, t) sf -> Abs (n, t, sf)) l t;; + let mk_qua s l t = List.fold_right (fun (n, t) sf -> mk_uni s (Abs (n, t, sf))) l t;; + let mk_app t1 tl = List.fold_left (fun sf e -> Comb (sf, e)) t1 tl;; + +%} +%token TokEof TokParO TokParC TokDot TokComma TokQUni TokQExi TokLam TokSqrC TokEq TokNEq +%token TokAnd TokOr TokTilde TokEqvt TokNEqvt TokColon TokImpl TokFun TokAt +%token TokWord +%token TokUnknown + + +%right TokFun +%right TokImpl +%nonassoc TokEqvt TokNEqvt +%nonassoc TokEq TokNEq +%right TokOr +%right TokAnd +%nonassoc TokTilde +%left TokApp TokAt TokComma +%nonassoc TokLam TokQUni TokQExi + +%start hhtop +%type <(string * string * string * hhterm)> hhtop +%% + + + +hhtop : + TokWord TokParO TokWord TokComma TokWord TokComma term TokParC TokDot { ($1, $3, $5, $7) } +| TokEof { raise End_of_file }; + +term: +| TokWord TokColon term { mk_bin ":" (Id $1) $3 } +| term TokImpl term { mk_bin "=>" $1 $3 } +| TokImpl TokAt term TokAt term { mk_bin "=>" $3 $5 } +| term TokEq term { mk_bin "=" $1 $3 } +| term TokEqvt term { mk_bin "=" $1 $3 } +| term TokAnd term { mk_bin "&" $1 $3 } +| TokAnd TokAt term TokAt term { mk_bin "&" $3 $5 } +| term TokOr term { mk_bin "|" $1 $3 } +| TokOr TokAt term TokAt term { mk_bin "|" $3 $5 } +| term TokFun term { mk_bin ">" $1 $3 } +| TokTilde term { mk_neg $2 } +| TokTilde TokAt term { mk_neg $3 } +| term TokNEq term { mk_neg (mk_bin "=" $1 $3) } +| term TokNEqvt term { mk_neg (mk_bin "=" $1 $3) } +| TokLam vars term { mk_lam $2 $3 } +| TokQUni vars term { mk_qua "!" $2 $3 } +| TokQExi vars term { mk_qua "?" $2 $3 } +| term TokAt term { mk_app $1 [$3] } +| termapp %prec TokApp { $1 } + +termapp: +| termapp simpleterm %prec TokApp { mk_app $1 [$2] } +| simpleterm { $1 } + +simpleterm: +| TokParO term TokParC {$2} +| TokWord { Id $1 } + +vars : + TokWord TokColon term TokComma vars { ($1, $3) :: $5 } +| TokWord TokColon term TokSqrC { [($1, $3)] }; + + + diff --git a/src/holyhammer/hh/init.ml b/src/holyhammer/hh/init.ml new file mode 100644 index 0000000000..c3b0d0b3f0 --- /dev/null +++ b/src/holyhammer/hh/init.ml @@ -0,0 +1,105 @@ +(*-------------------------------------------------------------------------- *) +(* Organize the libraries by theorems, types and constants. Give also *) +(* additional information about the theorems such as their dependencies and *) +(* originated theories (deph), their role (roleh) and the order (thmlo) in *) +(* which the theorems were proved inside their theory. *) +(*-------------------------------------------------------------------------- *) + +open Hh_parse +open Preprocess + +(* object partition *) +let rec is_type t = match t with + | Id "$t" -> true + | Comb (Comb (Id ">", Id "$t"), x) -> is_type x + | _ -> false + +let is_thm (_,role,_) = role = "ax" || role = "def" +let is_tyc (_,role,_) = role = "ty" +let is_ty (_,_,t) = is_type t + +let get_tyl_cl_thml l = + let (tycl,thml) = List.partition is_tyc l in + let (tyl,cl) = List.partition is_ty tycl in + let f (x,_,y) = (x,y) in + let (tyl,cl,thml) = (List.map f tyl, List.map f cl, List.map f thml) in + (tyl,cl,thml) + +(* Transforming the lists of terms by theory *) +let flatten_tmll l = List.concat (List.map snd l) +let foreach_filter f tmll = List.map (fun (thy,l) -> (thy,List.filter f l)) tmll +let foreach_map f tmll = List.map (fun (thy,l) -> (thy,List.map f l)) tmll +let drop_tt tmll = foreach_map (fun (_,s,r,t) -> (s,r,t)) tmll + +(* Creating a hash from a associative list *) +let hash_of_alist l = + let hash = Hashtbl.create (List.length l) in + List.iter (fun (a,b) -> Hashtbl.add hash a b) l; + hash + +(* Initialization *) +let print_info (dir,tyl,cl,thml,thmlo) = + print_string ("Loading objects from " ^ dir ^ "\n"); + print_string ("- types: " ^ string_of_int (List.length tyl) ^ "\n"); + print_string ("- constants: " ^ string_of_int (List.length cl) ^ "\n"); + print_string ("- theorems: " ^ string_of_int (List.length thml) ^ "\n"); + print_string ("- theories: "^ string_of_int (List.length thmlo) ^ "\n\n") + +(* HOL-Light and HOL4 *) +let init_dir dir = + let (deph,tmll) = Read.read_dir dir in + let tmll = drop_tt tmll in (* remove the TPTP "tt" prefix *) + (* let (deph,tmll) = split_lib (deph,tmll) in *) (* splits under quantifiers removed *) + let (tyl,cl,thml) = get_tyl_cl_thml (flatten_tmll tmll) in + let big_thml = List.map fst (List.filter (fun (_,t) -> size_of t >= 2000) thml) in + let tmll = foreach_filter (fun (s,r,t) -> is_thm (s,r,t) && not (List.mem s big_thml)) tmll in + let short_thml = List.filter (fun (s,_) -> not (List.mem s big_thml)) thml in + let deph = remove_deph big_thml deph in + let thmlo = foreach_map (fun (s,r,t) -> s) tmll in + let roleh = hash_of_alist (List.map (fun (s,r,t) -> (s,r)) (flatten_tmll tmll)) in + print_info (dir,tyl,cl,thml,thmlo); + ((tyl,cl,short_thml),(deph,roleh,thmlo)) + +(* Experiments : matching *) +let init_dir_prefix prefix dir = + let (deph,tmll) = Read.read_dir dir in + let tmll = drop_tt tmll in (* remove the TPTP "tt" prefix *) + (* prefix *) + let tmll = foreach_map (prefix_entry prefix) tmll in + let deph = prefix_deph prefix deph in + (* split *) + let (deph,tmll) = split_lib (deph,tmll) in + (* *) + let (tyl,cl,thml) = get_tyl_cl_thml (flatten_tmll tmll) in + let tmll = foreach_filter (is_thm) tmll in + let thmlo = foreach_map (fun (s,r,t) -> s) tmll in + let roleh = hash_of_alist (List.map (fun (s,r,t) -> (s,r)) (flatten_tmll tmll)) in + print_info (dir,tyl,cl,thml,thmlo); + ((tyl,cl,thml),(deph,roleh,thmlo)) + +(* TO BE UPDATED: +(* Mizar *) +let init_dir_miz dir = + let tmll = Read.read_dir_nodep dir in + let tmll = miz_split_fc (drop_tt tmll) in + let thml = List.map (fun (x,y,z) -> (x,z)) (flatten_tmll tmll) in + let thmlo = foreach_map (fun (x,y,z) -> x) tmll in + print_info_miz (dir,thml,thmlo); + (thml,thmlo) + +(* + let h = Read.read_thy_graph (dir ^ "/thygraph") in + let +*) + +(* Matita and Coq *) +let init_dir_mat dir = + let thylo = Read.read_thy_lo (dir ^ "/thyorder") in + let tmll = Read.read_dir_nodep dir in + let tmll = List.map (fun x -> (x, List.assoc x tmll)) thylo in + let tmll = miz_split_fc (drop_tt tmll) in + let (tyl,cl,thml) = get_tyl_cl_thml (flatten_tmll tmll) in + let thmlo = foreach_map (fun (x,y,z) -> x) tmll in + print_info (dir,tyl,cl,thml,thmlo); + (tyl,cl,thml,thmlo) +*) diff --git a/src/holyhammer/hh/main.ml b/src/holyhammer/hh/main.ml new file mode 100644 index 0000000000..b9c7e423a5 --- /dev/null +++ b/src/holyhammer/hh/main.ml @@ -0,0 +1,75 @@ +(* Example usage: echo "conjecture" | ./hh 128 ../theories *) + +open Hh_parse +open Thf1hh1 +open Dependency +open Prepredict +open Write +open Filename + +type filepath = string + +(* Load theories and conjecture. *) +let init_proving_env thy_dir cj_file cj_name thydep_file thylo_file = + let ((tyl,cl,thml),(thmh,roleh,thmlo)) = Init.init_dir thy_dir in + let cj = Read.read_conjecture cj_file in + let _ = init_dep_env thydep_file thylo_file (thmh,roleh,thmlo) in + Thf1hh1.parse (tyl,cl,(cj_name,cj) :: thml) (* creating the term hash *) + +(* Predict n premises for a conjecture, saving results to directory. *) +let predict (p : predictor) (out_dir : filepath) (n_preds : int) (cj : string) = + predict_wrap p out_dir n_preds cj (gen_all ()) + +(* Parse command-line arguments, exiting with help if not valid. + TODO: Read a conjecture itself, not its name. *) +let parse_commandline () = + (* Saving results into two references and a array. *) + let anon_counter = ref 0 in + let anon_tab = Array.make 6 "" in + let thydep_ref = ref "" in + let thylo_ref = ref "" in + let option_of_string s = if s = "" then None else Some s in + let parse_anon anon = anon_tab.(!anon_counter) <- anon; incr anon_counter in + let speclist = + [("-thydep", Arg.Set_string thydep_ref, "Provides dependencies between theories"); + ("-thylo", Arg.Set_string thylo_ref, "Provides a linear order for the theories.\n" ^ + "Warning: all theories that do not belong to this order are ignored.")] + in + let usage_msg = "HOL(y) Hammer. Usage: " ^ + Sys.argv.(0) ^ " " + in + Arg.parse speclist parse_anon usage_msg; + (* Processing the parsed objects. *) + let predictor = match anon_tab.(0) with + "knn" -> KNN + | "nbayes" -> NaiveBayes + | "mepo" -> Mepo + | "geo" -> Geo + | _ -> failwith "Unknown predictor." in + let n_predictions = try int_of_string (anon_tab.(1)) + with _ -> failwith "Number of predictions have to be an integer." in + let theory_dir = anon_tab.(2) in + let cj_file = anon_tab.(3) in + let cj_name = anon_tab.(4) in + let out_dir = concat anon_tab.(5) "" in (* I don't understand why you need concat here *) + let thydep_file = option_of_string !thydep_ref in + let thylo_file = option_of_string !thylo_ref in + (predictor, n_predictions, theory_dir, cj_file, cj_name, out_dir, thydep_file, thylo_file) + + +(* Main function. *) +(* TO DO: read the conjecture from the file *) +let _ = + let (predictor, n_predictions, theory_dir, cj_file, + cj_name, out_dir, thydep_file, thylo_file) = parse_commandline () in + + print_endline ("Loading theories from " ^ theory_dir); + init_proving_env theory_dir cj_file cj_name thydep_file thylo_file; + + print_endline ("Predicting " ^ (string_of_int n_predictions) ^ " lemmata"); + let axioms = predict predictor out_dir n_predictions cj_name in + + print_endline "Writing ATP file"; + let atp_path = Filename.concat out_dir "atp_in" in + write_fof atp_path (cj_name, axioms); +; diff --git a/src/holyhammer/hh/predict.ml b/src/holyhammer/hh/predict.ml new file mode 100644 index 0000000000..82737b07f7 --- /dev/null +++ b/src/holyhammer/hh/predict.ml @@ -0,0 +1,99 @@ +let mydir = Filename.dirname (Sys.executable_name);; + +let os = output_string;; + +let unlink = ref [];; + +let cpp_advice axsyms csyms cmd = + let fname = Filename.temp_file "predict" "" in + let ocsym = open_out (fname ^ "syms") in + let ocseq = open_out (fname ^ "seq") in + let ocdep = open_out (fname ^ "dep") in + unlink := fname :: (fname ^ "syms") :: (fname ^ "csyms") :: (fname ^ "seq") :: (fname ^ "dep") :: (fname ^ "out") :: !unlink; + List.iter (fun (thn, ths) -> + os ocseq thn; output_char ocseq '\n'; + os ocdep thn; os ocdep ":\n"; + os ocsym thn; output_char ocsym ':'; + match ths with + [] -> output_char ocsym '\n' + | l -> output_char ocsym '\"'; os ocsym (String.concat "\", \"" l); os ocsym "\"\n" + ) axsyms; + close_out ocsym; + close_out ocseq; + close_out ocdep; + let ocsym = open_out (fname ^ "csyms") in + output_char ocsym '\"'; os ocsym (String.concat "\", \"" csyms); os ocsym "\"\n"; + close_out ocsym; + ignore (Sys.command (cmd fname)); + let ic = open_in (fname ^ "out") in + let predict = Str.split (Str.regexp " ") (try input_line ic with End_of_file -> failwith "predictor did not return advice") in + close_in ic; + predict +;; + +let knn_advice divider axsyms csyms limit = + (*let limit = min (List.length axsyms) limit in + let kno = limit / divider in*) + let cmd s = Printf.sprintf "%s/../predict/predict knn %i %ssyms %sdep %sseq < %scsyms > %sout 2>/dev/null" mydir limit s s s s s in + cpp_advice axsyms csyms cmd +;; + +let mepo_advice axsyms csyms limit = + let cmd s = Printf.sprintf "%s/../predict/predict mepo %i %ssyms %sdep %sseq < %scsyms > %sout 2>/dev/null" mydir limit s s s s s in + cpp_advice axsyms csyms cmd +;; + +let nb_advice axsyms csyms limit = + let cmd s = Printf.sprintf "%s/../predict/predict nbayes %i %ssyms %sdep %sseq < %scsyms > %sout 2>/dev/null" mydir limit s s s s s in + cpp_advice axsyms csyms cmd +;; + +(* Thibault's experiments *) +let cpp_advice2 fname cmd = + print_endline ("Running predictor: " ^ cmd fname); + ignore (Sys.command (cmd fname)); + let ic = open_in (fname ^ "out") in + let predict = Str.split (Str.regexp " ") + (try input_line ic with End_of_file -> failwith "predictor did not return advice") in + close_in ic; + predict + +let knn_advice2 fname limit = + let cmd s = Printf.sprintf + "../predict/predict %ssyms %sdep %sseq -n %i -p knn < %scsyms > %sout 2> %serror" + s s s limit s s s in + cpp_advice2 fname cmd + +let nb_advice2 fname limit = + let cmd s = Printf.sprintf + "../predict/predict %ssyms %sdep %sseq -n %i -p nbayes < %scsyms > %sout 2> %serror" + s s s limit s s s in + cpp_advice2 fname cmd + +let mepo_advice2 fname limit = + let cmd s = Printf.sprintf + "../predict/mepo/mepo3 %i %ssyms %sdep %i %sseq < %scsyms > %sout 2> %serror" + 0 s s limit s s s s in + cpp_advice2 fname cmd + +let geo_advice2 fname limit = + let cmd s = Printf.sprintf + "../predict/mepo/geo %i %f %ssyms %sdep %i %sseq < %scsyms > %sout 2> %serror" + 1 0.99 s s limit s s s s in + cpp_advice2 fname cmd + +(* Matching experiments *) + +let nb_advice3 fname limit = + let cmd s = Printf.sprintf "../../predict/predict %ssyms %sdep %sseq -n %i -p nbayes < %scsyms > %sout 2> %serror" s s s limit s s s in + cpp_advice2 fname cmd +;; + +let knn_advice3 fname limit = + let cmd s = Printf.sprintf "../../predict/predict %ssyms %sdep %sseq -n %i -p knn < %scsyms > %sout 2> %serror" s s s limit s s s in + cpp_advice2 fname cmd +;; + + + + diff --git a/src/holyhammer/hh/prepredict.ml b/src/holyhammer/hh/prepredict.ml new file mode 100644 index 0000000000..22d33775e0 --- /dev/null +++ b/src/holyhammer/hh/prepredict.ml @@ -0,0 +1,110 @@ +(*-------------------------------------------------------------------------- *) +(* Printing the necessary files for the predictors, such as dependencies *) +(* and features. *) +(*-------------------------------------------------------------------------- *) + +open Dependency +open Thf1hh1 + +(*-------------------------------------------------------------------------- + Preparing files for the predictor + -------------------------------------------------------------------------- *) +let feature_of thm = Hh_symbols.get_symbols (term_of thm) + +let os = output_string + +let print_dep fname axl = + let ocdep = open_out (fname ^ "dep") in + let f x = os ocdep (x ^ ":" ^ String.concat " " (dep_of x) ^ "\n") in + List.iter f axl; close_out ocdep + +let out_dep ocdep axl = + let f x = os ocdep (x ^ ":" ^ String.concat " " (dep_of x) ^ "\n") in + List.iter f axl + +let print_seq fname axl = + let ocseq = open_out (fname ^ "seq") in + let f x = os ocseq (x ^ "\n") in + List.iter f axl; close_out ocseq + +let print_syms fname axl = + let ocsym = open_out (fname ^ "syms") in + let axsym = List.map (fun a -> (a, feature_of a)) axl in + let f (x,ths) = + let s = match ths with + [] -> "\n" + | _ -> "\"" ^ String.concat "\", \"" ths ^ "\"\n" + in + os ocsym (x ^ ":" ^ s) + in + List.iter f axsym; close_out ocsym + +let print_csyms fname cjname = + let csyms = feature_of cjname in + let ocsym = open_out (fname ^ "csyms") in + if csyms = [] + then os ocsym "\n" + else os ocsym ("\"" ^ (String.concat "\", \"" csyms) ^ "\"\n"); + close_out ocsym + +let predict_print_all fname axl cjname = + print_dep fname axl; + print_seq fname axl; + print_syms fname axl; + print_csyms fname cjname + + +(*-------------------------------------------------------------------------- + Running the predictor + -------------------------------------------------------------------------- *) + +type predictor = KNN | NaiveBayes | Mepo | Geo + +let run_predictor = function + KNN -> Predict.knn_advice2 +| NaiveBayes -> Predict.nb_advice2 +| Mepo -> Predict.mepo_advice2 +| Geo -> Predict.geo_advice2 + + +let predict_wrap predictor file_prefix n cj axl = + predict_print_all file_prefix axl cj; + run_predictor predictor file_prefix n + +(* Matching experiments 1 *) + +let run_predictor_matching = function + KNN -> Predict.knn_advice3 +| NaiveBayes -> Predict.nb_advice3 +| _ -> failwith "not supported" + +let print_all_matching file_prefix dep_env1 dep_env2 axl1 axl2 cjname = + let axl = axl1 @ axl2 in + (* dependencies *) + let ocdep = open_out (file_prefix ^ "dep") in + set_dep_env dep_env1; + out_dep ocdep axl1; + set_dep_env dep_env2; + out_dep ocdep axl2; + close_out ocdep; + (* term *) + print_seq file_prefix axl; + print_syms file_prefix axl; + print_csyms file_prefix cjname + +let predict_matching predictor file_prefix dep_env1 dep_env2 axl1 axl2 n cjname = + print_all_matching file_prefix dep_env1 dep_env2 axl1 axl2 cjname; + run_predictor_matching predictor file_prefix n + + + + + + + + + + + + + diff --git a/src/holyhammer/hh/preprocess.ml b/src/holyhammer/hh/preprocess.ml new file mode 100644 index 0000000000..54f00b76f5 --- /dev/null +++ b/src/holyhammer/hh/preprocess.ml @@ -0,0 +1,181 @@ +(*--------------------------------------------------------------------------- *) +(* This files contains the data-preprocessing done after the reading phase *) +(* namely: splitting conjunctions and more later. *) +(*--------------------------------------------------------------------------- *) + +open Hh_parse + +(*--------------------------------------------------------------------------- + Prefixing tools. + --------------------------------------------------------------------------- *) +let fixed_constants = + ["$o"; "$t"; ">"; "!";"?";"&";"|";"=>";"~";"=";"<=>"; + "$forall";"$exists";"$and";"$or";"$imply";"$not";"$equals"; + "$true";"$false";"$i"] + +let is_lowercase c = + let i = Char.code c in i >= Char.code 'a' && i <= Char.code 'z' +let is_uppercase c = + let i = Char.code c in i >= Char.code 'A' && i <= Char.code 'Z' +let is_alphanumeric c = + (is_lowercase c) or (is_uppercase c) or (Char.code c == Char.code '_') + +let can f s = try (f s; true) with _ -> false + +let is_tptp s = + let f c = if is_alphanumeric c then () else raise Exit in + can (String.iter f) s + +let remove_prime name = + try + if name.[0] = '\'' && name.[String.length name - 1] = '\'' + then + let n = String.length name in + Str.last_chars (Str.first_chars name (n - 1)) (n- 2) + else name + with _ -> name + +let add_prime name = + if List.mem name fixed_constants || is_tptp name + then name + else "\'" ^ name ^ "\'" + +let give_prefix prefix name = + if List.mem name fixed_constants + then name + else add_prime (prefix ^ remove_prime name) + + +(*--------------------------------------------------------------------------- + Removing really big theorems. + --------------------------------------------------------------------------- *) + +let rec size_of t = match t with + | Abs (n,ty,tm) -> size_of ty + size_of tm + | Comb (x,y) -> size_of x + size_of y + | Id x -> 1 + +let remove_deph big_thml deph = + let h = Hashtbl.create 20000 in + let f thm (thy,depl) = + if List.mem thm big_thml then () + else + let new_depl = List.filter (fun x -> not (List.mem x big_thml)) depl in + Hashtbl.add h thm (thy,new_depl) + in + Hashtbl.iter f deph; + h +;; + +(*--------------------------------------------------------------------------- + Prefixing objects by provers + (necessary for matching between different libraries). + --------------------------------------------------------------------------- *) + +let rec bv_of t = match t with + | Abs (n,ty,tm) -> n :: (bv_of ty @ bv_of tm) + | Comb (x,y) -> bv_of x @ bv_of y + | Id x -> [] + +let prefix_entry prefix (s,r,t) = + let bvl = bv_of t in + let is_free fv = not (List.mem fv bvl) in + let rec f tm = match tm with + | Abs (v,ty,tm') -> Abs (v, f ty, f tm') + | Comb (x,y) -> Comb (f x, f y) + | Id x -> if is_free x then Id (give_prefix prefix x) else Id x + in + (give_prefix prefix s,r,f t) + +let prefix_deph prefix h = + let h_res = Hashtbl.create 20000 in + let f thm (thy,depl) = + let new_thm = give_prefix prefix thm in + let new_depl = List.map (give_prefix prefix) depl in + Hashtbl.add h_res new_thm (thy,new_depl) + in + Hashtbl.iter f h; + h_res + +(*--------------------------------------------------------------------------- + Splitting conjunctions under the quantifiers. (used only for matching now) + --------------------------------------------------------------------------- *) + +(* Hashtable used by hollight, hol4 and mizar. + Warning: need to be cleaned before usage *) +let splith = Hashtbl.create 20000 + +let find_split thm = try Hashtbl.find splith thm + with Not_found -> failwith ("find_split: " ^ thm) + +(* name tools *) +let app_info s info = + let add_prime s = "\'" ^ s ^ "\'" in + let remove_prime s = + let n = String.length s in + Str.last_chars (Str.first_chars s (n - 1)) (n- 2) + in + if s.[0] = '\'' && s.[String.length s - 1] = '\'' + then add_prime (remove_prime s ^ info) + else s ^ info + +(* accessors and constructors for the AST *) +let rec all_id t = match t with + | Comb (x,y) -> all_id x @ all_id y + | Abs (n,ty,tm) -> n :: (all_id ty @ all_id tm) + | Id x -> [x] + +let mk_forall ((n,ty),t) = Comb (Id "!",Abs (n, ty, t)) + +let mk_clever_forall ((n,ty),t) = + if List.mem n (all_id t) then mk_forall ((n,ty),t) else t + +let rec list_mk_clever_forall (vl,t) = match vl with + | [] -> t + | a :: m -> mk_clever_forall (a,list_mk_clever_forall (m,t)) + +(* splitting each entry into multiple entries *) +let rec split_term vl t = match t with + | Comb (Id "!", Abs (n, ty, tm)) -> split_term ((n,ty) :: vl) tm + | Comb (Comb (Id "&", x), y) -> split_term vl x @ split_term vl y + | _ -> [list_mk_clever_forall (List.rev vl,t)] + +let split_entry (name,role,term) = + let conjl = split_term [] term in + let i = ref 0 in + let name_conj x = + let entry = (app_info name ("s" ^ string_of_int !i), role, x) in + incr i; entry + in + let entryl = if List.length conjl = 1 + then [(name,role,term)] + else List.map name_conj conjl + in + (* save how the term was splitted to be able to recompute the dependencies *) + Hashtbl.add splith name (List.map (fun (n,r,t) -> n) entryl); + entryl + +let split_thy (thy,entryl) = (thy,List.concat (List.map split_entry entryl)) + +(* splitting dependencies: need to be done after splitting terms *) +let split_deph deph = + let h1 = Hashtbl.create 20000 in + let h2 = Hashtbl.create 20000 in + let split_depl h thm (thy,l) = + Hashtbl.add h thm (thy, List.concat (List.map find_split l)) + in + let split_thm h thm (thy,depl) = + let conjl = find_split thm in + List.iter (fun x -> Hashtbl.add h x (thy,depl)) conjl + in + Hashtbl.iter (split_depl h1) deph; + Hashtbl.iter (split_thm h2) h1; + h2 + +let split_lib (deph,tmll) = + Hashtbl.clear splith; + let new_tmll = List.map split_thy tmll in (* keep it before split_deph *) + (split_deph deph,new_tmll) + + + diff --git a/src/holyhammer/hh/proto.ml b/src/holyhammer/hh/proto.ml new file mode 100644 index 0000000000..9bdc7f0c31 --- /dev/null +++ b/src/holyhammer/hh/proto.ml @@ -0,0 +1,100 @@ +let lookup p = List.assoc p +[("atpstr_my_05c900b7acd7e0314c15fce53bb9e79cf904cd89","--definitional-cnf=24 --destructive-er-aggressive --destructive-er --prefer-initial-clauses -F1 --delete-bad-limit=150000000 --sine='GSinE(CountFormulas,,1.5,,03,40,1.0)' --forward-context-sr -winvfreqrank -c1 -Ginvfreq -WSelectNewComplexAHP --simul-paramod --split-aggressive --split-clauses=4 -tLPO4 -H'(8*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),6*ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),1*ConjectureSymbolWeight(ConstPrio,10,10,5,5,5,1.5,1.5,1.5),1*Clauseweight(ByCreationDate,2,1,0.8),4*Clauseweight(ConstPrio,3,1,1),1*Clauseweight(PreferProcessed,1,1,1),1*FIFOWeight(PreferProcessed),2*Refinedweight(PreferNonGoals,1,1,2,1.5,1.5),4*Refinedweight(SimulateSOS,1,1,2,1.5,2))'"); +("atpstr_my_0b08a1d1a32ffc279e90769114bdfda18e672e1c","--definitional-cnf=24 --destructive-er-aggressive --destructive-er --prefer-initial-clauses -F1 --delete-bad-limit=150000000 --sine='GSinE(CountFormulas,hypos,1.1,,03,40,1.0)' -winvfreqrank -c1 -Ginvfreq -WSelectMaxLComplexAvoidPosPred --simul-paramod --split-aggressive --split-reuse-defs -tAuto -H'(10*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),4*ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),12*ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),7*ConjectureSymbolWeight(ConstPrio,10,10,5,5,5,1.5,1.5,1.5),1*Clauseweight(ByCreationDate,2,1,0.8),1*FIFOWeight(ConstPrio),2*FIFOWeight(PreferProcessed))'"); +("atpstr_my_1518b94b1627f7a5f7ce55e37817c09306fe714c","--definitional-cnf=24 --destructive-er-aggressive --destructive-er --prefer-initial-clauses -F1 --delete-bad-limit=150000000 --sine='GSinE(CountFormulas,hypos,1.2,,02,40,1.0)' -winvfreqrank -c1 -Ginvfreq -WSelectMaxLComplexAvoidPosPred --simul-paramod -tAuto -H'(1*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),8*ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),1*Clauseweight(ByCreationDate,2,1,0.8),2*Clauseweight(PreferProcessed,1,1,1),1*FIFOWeight(ConstPrio),1*FIFOWeight(PreferProcessed),2*Refinedweight(PreferNonGoals,1,1,2,1.5,1.5))'"); +("atpstr_my_2af8b399ea0b8c22c6fc1b13069ad80214f9fa8b","--definitional-cnf=24 --destructive-er-aggressive --destructive-er --prefer-initial-clauses -F1 --delete-bad-limit=150000000 --sine='GSinE(CountFormulas,hypos,5.0,,6,80,1.0)' -Ginvfreqconstmin -WSelectComplexG --simul-paramod --split-reuse-defs -tKBO -H'(8*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),4*ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),2*FIFOWeight(PreferProcessed),10*Refinedweight(SimulateSOS,1,1,2,1.5,2))'"); +("atpstr_my_2d0c1ae7703dba890de879a4f4409a64f9856908","--definitional-cnf=24 --destructive-er-aggressive --destructive-er --prefer-initial-clauses -F1 --delete-bad-limit=150000000 --sine='GSinE(CountFormulas,,1.5,,2,60,1.0)' --forward-context-sr -Garity -WSelectMaxLComplexAvoidPosPred --oriented-simul-paramod --split-aggressive --split-reuse-defs -tLPO4 -H'(1*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),1*ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),4*ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),8*Clauseweight(ConstPrio,3,1,1),2*Clauseweight(PreferProcessed,1,1,1),2*FIFOWeight(PreferProcessed),1*Refinedweight(PreferNonGoals,1,1,2,1.5,1.5),10*Refinedweight(PreferGroundGoals,2,1,2,1.0,1),4*Refinedweight(SimulateSOS,1,1,2,1.5,2))'"); +("atpstr_my_2eeaa79326ed674ea9ebfc3531c32ba1feec013b","--definitional-cnf=24 --destructive-er-aggressive --destructive-er --prefer-initial-clauses -F1 --delete-bad-limit=150000000 --forward-context-sr -Garity -WSelectComplexG --simul-paramod -tAuto -H'(10*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),1*Clauseweight(ByCreationDate,2,1,0.8),1*FIFOWeight(ConstPrio),1*FIFOWeight(PreferProcessed))'"); +("atpstr_my_304d2e324da665c057353a60ddd91c0712280c88","--definitional-cnf=24 --destructive-er-aggressive --destructive-er --prefer-initial-clauses -F1 --delete-bad-limit=150000000 --sine='GSinE(CountFormulas,,1.1,,02,60,1.0)' --forward-context-sr -Garity -WSelectMaxLComplexAvoidPosPred --simul-paramod --split-clauses=4 -tLPO4 -H'(6*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),1*ConjectureSymbolWeight(ConstPrio,10,10,5,5,5,1.5,1.5,1.5),1*Clauseweight(ByCreationDate,2,1,0.8),1*Clauseweight(PreferProcessed,1,1,1),1*FIFOWeight(ConstPrio),2*FIFOWeight(PreferProcessed),4*Refinedweight(PreferNonGoals,1,1,2,1.5,1.5))'"); +("atpstr_my_37be21ea059a2fcb865621e373a97f33a9d07b12","--definitional-cnf=24 --destructive-er-aggressive --destructive-er --prefer-initial-clauses -F1 --delete-bad-limit=150000000 --sine='GSinE(CountFormulas,,2.0,,02,100,1.0)' --forward-context-sr -Ginvfreqconstmin -WSelectComplexG --simul-paramod --split-clauses=7 --split-reuse-defs -tKBO -H'(4*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),1*FIFOWeight(ConstPrio),1*FIFOWeight(PreferProcessed))'"); +("atpstr_my_3e6c84c618b85cc326775b240e7b2b07e3a2dde9","--definitional-cnf=24 --destructive-er-aggressive --destructive-er --prefer-initial-clauses -F1 --delete-bad-limit=150000000 --forward-context-sr -Ginvfreqconstmin -WSelectNewComplexAHP --simul-paramod --split-aggressive --split-clauses=4 -tAuto -H'(10*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),3*ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),1*ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),1*ConjectureSymbolWeight(ConstPrio,10,10,5,5,5,1.5,1.5,1.5),1*Clauseweight(ByCreationDate,2,1,0.8),1*Clauseweight(ConstPrio,3,1,1),1*FIFOWeight(ConstPrio))'"); +("atpstr_my_40306ce1a432dd48c918ac611d77fc5069b2fbc7","--definitional-cnf=24 --destructive-er-aggressive --destructive-er --prefer-initial-clauses -F1 --delete-bad-limit=150000000 --forward-context-sr -Garity -WSelectComplexG --simul-paramod -tKBO -H'(2*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),3*ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),10*ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),4*ConjectureSymbolWeight(ConstPrio,10,10,5,5,5,1.5,1.5,1.5),1*FIFOWeight(ConstPrio),4*Refinedweight(PreferNonGoals,1,1,2,1.5,1.5),2*Refinedweight(SimulateSOS,1,1,2,1.5,2))'"); +("atpstr_my_43029cedefea4858aae9c4ebd6be482056ce22f4","--definitional-cnf=24 --destructive-er-aggressive --destructive-er --prefer-initial-clauses -F1 --delete-bad-limit=150000000 --forward-context-sr -Ginvfreqconstmin -WSelectComplexG --simul-paramod -tKBO -H'(10*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),1*ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),1*FIFOWeight(PreferProcessed),1*Refinedweight(SimulateSOS,1,1,2,1.5,2))'"); +("atpstr_my_4e6e6157a8ac18b9bae11142d40377c9660db06b","--definitional-cnf=24 --destructive-er-aggressive --destructive-er --prefer-initial-clauses -F1 --delete-bad-limit=150000000 --sine='GSinE(CountFormulas,hypos,6.0,,02,100,1.0)' --forward-context-sr -winvfreqrank -c1 -Ginvfreq -WSelectMaxLComplexAvoidPosPred --simul-paramod -tLPO4 -H'(10*ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),1*ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),1*ConjectureSymbolWeight(ConstPrio,10,10,5,5,5,1.5,1.5,1.5),1*Clauseweight(ByCreationDate,2,1,0.8),2*Clauseweight(ConstPrio,3,1,1),2*Clauseweight(PreferProcessed,1,1,1),1*FIFOWeight(ConstPrio),2*FIFOWeight(PreferProcessed),10*Refinedweight(PreferGroundGoals,2,1,2,1.0,1),2*Refinedweight(SimulateSOS,1,1,2,1.5,2))'"); +("atpstr_my_5fce846ef89413a220d0951fb615d42ded72b119","--definitional-cnf=24 --destructive-er-aggressive --destructive-er --prefer-initial-clauses -F1 --delete-bad-limit=150000000 --forward-context-sr -Garity -WSelectMaxLComplexAvoidPosPred --simul-paramod --split-clauses=4 --split-reuse-defs -tLPO4 -H'(8*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),3*ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),1*Clauseweight(ByCreationDate,2,1,0.8),1*Clauseweight(ConstPrio,3,1,1),1*FIFOWeight(PreferProcessed),8*Refinedweight(PreferGroundGoals,2,1,2,1.0,1),1*Refinedweight(SimulateSOS,1,1,2,1.5,2))'"); +("atpstr_my_69856783cec8fab1acccfe08bb382ad42c8475df","--definitional-cnf=24 --destructive-er-aggressive --destructive-er --prefer-initial-clauses -F1 --delete-bad-limit=150000000 --sine='GSinE(CountFormulas,,6.0,,,100,1.0)' -Garity -WSelectComplexG --simul-paramod --split-clauses=7 -tKBO -H'(10*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),2*ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),7*ConjectureSymbolWeight(ConstPrio,10,10,5,5,5,1.5,1.5,1.5),2*Refinedweight(PreferNonGoals,1,1,2,1.5,1.5),2*Refinedweight(PreferGroundGoals,2,1,2,1.0,1))'"); +("atpstr_my_7b674c1081cd73ca6ce34d02596e6f6fd903ac6c","--definitional-cnf=24 --destructive-er-aggressive --destructive-er --prefer-initial-clauses -F1 --delete-bad-limit=150000000 --sine='GSinE(CountFormulas,,5.0,,02,80,1.0)' -Garity -WSelectNewComplexAHP --simul-paramod -tLPO4 -H'(10*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),1*ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),2*ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),7*ConjectureSymbolWeight(ConstPrio,10,10,5,5,5,1.5,1.5,1.5),1*Clauseweight(ConstPrio,3,1,1),2*Clauseweight(PreferProcessed,1,1,1),1*FIFOWeight(PreferProcessed),3*Refinedweight(PreferNonGoals,1,1,2,1.5,1.5),2*Refinedweight(PreferGroundGoals,2,1,2,1.0,1),4*Refinedweight(SimulateSOS,1,1,2,1.5,2))'"); +("atpstr_my_88760aa43d575e84b7030b8a6188f74ba5f80dc7","--definitional-cnf=24 --destructive-er-aggressive --destructive-er --prefer-initial-clauses -F1 --delete-bad-limit=150000000 --sine='GSinE(CountFormulas,,2.0,,02,100,1.0)' --forward-context-sr -Garity -WSelectComplexG --simul-paramod --split-clauses=7 -tKBO -H'(8*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),2*ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),3*ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),1*ConjectureSymbolWeight(ConstPrio,10,10,5,5,5,1.5,1.5,1.5),1*Clauseweight(PreferProcessed,1,1,1),1*FIFOWeight(ConstPrio),2*FIFOWeight(PreferProcessed),3*Refinedweight(PreferNonGoals,1,1,2,1.5,1.5))'"); +("atpstr_my_8fb389ef013a89e03c1aa87be52b2f151b1819cc","--definitional-cnf=24 --destructive-er-aggressive --destructive-er --prefer-initial-clauses -F1 --delete-bad-limit=150000000 --sine='GSinE(CountFormulas,,1.1,,04,80,1.0)' -Garity -WSelectNewComplexAHP --simul-paramod --split-aggressive --split-clauses=4 --split-reuse-defs -tAuto -H'(6*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),2*ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),2*ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),2*ConjectureSymbolWeight(ConstPrio,10,10,5,5,5,1.5,1.5,1.5),2*FIFOWeight(PreferProcessed),1*Refinedweight(PreferGroundGoals,2,1,2,1.0,1))'"); +("atpstr_my_92168ebc2ef464a6f2d6a311a4fa90219fd0aa91","--definitional-cnf=24 --destructive-er-aggressive --destructive-er --prefer-initial-clauses -F1 --delete-bad-limit=150000000 --sine='GSinE(CountFormulas,hypos,6.0,,02,20000,1.0)' --forward-context-sr -Garity -WSelectNewComplexAHP --simul-paramod --split-aggressive --split-reuse-defs -tAuto -H'(6*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),12*ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),6*ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),4*ConjectureSymbolWeight(ConstPrio,10,10,5,5,5,1.5,1.5,1.5),1*Refinedweight(PreferNonGoals,1,1,2,1.5,1.5),8*Refinedweight(PreferGroundGoals,2,1,2,1.0,1),4*Refinedweight(SimulateSOS,1,1,2,1.5,2))'"); +("atpstr_my_9cb7c8ca63fd56afb053ade56353a3b00eee7e6a","--definitional-cnf=24 --destructive-er-aggressive --destructive-er --prefer-initial-clauses -F1 --delete-bad-limit=150000000 --sine='GSinE(CountFormulas,,1.2,,4,100,1.0)' --forward-context-sr -winvfreqrank -c1 -Ginvfreq -WSelectMaxLComplexAvoidPosPred --simul-paramod --split-clauses=4 --split-reuse-defs -tLPO4 -H'(10*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),1*FIFOWeight(ConstPrio),2*FIFOWeight(PreferProcessed))'"); +("atpstr_my_9f72062a403172caf26fbe878a32becf1403c276","--definitional-cnf=24 --destructive-er-aggressive --destructive-er --prefer-initial-clauses -F1 --delete-bad-limit=150000000 --sine='GSinE(CountFormulas,hypos,2.0,,3,20,1.0)' -Garity -WSelectComplexG --simul-paramod --split-clauses=7 --split-reuse-defs -tKBO -H'(4*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),6*ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),3*ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),10*ConjectureSymbolWeight(ConstPrio,10,10,5,5,5,1.5,1.5,1.5),1*FIFOWeight(ConstPrio),1*Refinedweight(PreferNonGoals,1,1,2,1.5,1.5),10*Refinedweight(SimulateSOS,1,1,2,1.5,2))'"); +("atpstr_my_9fde028f05afb32f97bced19843d73b32d923682","--definitional-cnf=24 --destructive-er-aggressive --destructive-er --prefer-initial-clauses -F1 --delete-bad-limit=150000000 --forward-context-sr -Ginvfreqconstmin -WSelectComplexG --oriented-simul-paramod --split-aggressive -tKBO -H'(1*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),2*ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),3*ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),4*ConjectureSymbolWeight(ConstPrio,10,10,5,5,5,1.5,1.5,1.5),1*Clauseweight(ByCreationDate,2,1,0.8),1*Clauseweight(PreferProcessed,1,1,1),1*FIFOWeight(ConstPrio),2*Refinedweight(PreferNonGoals,1,1,2,1.5,1.5),1*Refinedweight(PreferGroundGoals,2,1,2,1.0,1),2*Refinedweight(SimulateSOS,1,1,2,1.5,2))'"); +("atpstr_my_a175515211bb22b22434eae9bbbfab623676a2ba","--definitional-cnf=24 --destructive-er-aggressive --destructive-er --prefer-initial-clauses -F1 --delete-bad-limit=150000000 --forward-context-sr -winvfreqrank -c1 -Ginvfreq -WSelectComplexG --simul-paramod --split-clauses=4 --split-reuse-defs -tLPO4 -H'(10*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),2*FIFOWeight(PreferProcessed),2*Refinedweight(PreferGroundGoals,2,1,2,1.0,1))'"); +("atpstr_my_a3154f3180cc47331f1b05c36960c32e4805a7c5","--definitional-cnf=24 --destructive-er-aggressive --destructive-er --prefer-initial-clauses -F1 --delete-bad-limit=150000000 --sine='GSinE(CountFormulas,,6.0,,01,20000,1.0)' --forward-context-sr -Garity -WSelectComplexG --simul-paramod --split-clauses=4 -tLPO4 -H'(10*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),3*ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),1*ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),1*ConjectureSymbolWeight(ConstPrio,10,10,5,5,5,1.5,1.5,1.5),1*Clauseweight(ByCreationDate,2,1,0.8),1*Clauseweight(PreferProcessed,1,1,1),1*Refinedweight(PreferGroundGoals,2,1,2,1.0,1))'"); +("atpstr_my_a473e2c35f909af4ba00d9f1a7a8a454a851ed9c","--definitional-cnf=24 --destructive-er-aggressive --destructive-er --prefer-initial-clauses -F1 --delete-bad-limit=150000000 --sine='GSinE(CountFormulas,,1.4,,,20,1.0)' -Ginvfreqconstmin -WSelectMaxLComplexAvoidPosPred --simul-paramod --split-aggressive --split-clauses=4 -tLPO4 -H'(10*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),2*ConjectureSymbolWeight(ConstPrio,10,10,5,5,5,1.5,1.5,1.5),1*FIFOWeight(PreferProcessed))'"); +("atpstr_my_a4a4da5778ba9bebf9bc5e616786c7ad501b1af5","--definitional-cnf=24 --destructive-er-aggressive --destructive-er --prefer-initial-clauses -F1 --delete-bad-limit=150000000 --sine='GSinE(CountFormulas,hypos,1.1,,03,20,1.0)' --forward-context-sr -winvfreqrank -c1 -Ginvfreq -WSelectMaxLComplexAvoidPosPred --simul-paramod --split-aggressive --split-clauses=4 --split-reuse-defs -tLPO4 -H'(1*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),1*ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),1*ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),1*Clauseweight(ByCreationDate,2,1,0.8),1*Clauseweight(PreferProcessed,1,1,1),1*FIFOWeight(ConstPrio),2*FIFOWeight(PreferProcessed),3*Refinedweight(PreferNonGoals,1,1,2,1.5,1.5))'"); +("atpstr_my_a74b37f2d8b7e35be554fc999f671188cf40f113","--definitional-cnf=24 --destructive-er-aggressive --destructive-er --prefer-initial-clauses -F1 --delete-bad-limit=150000000 --sine='GSinE(CountFormulas,hypos,6.0,,01,80,1.0)' -Ginvfreqconstmin -WSelectComplexG --simul-paramod --split-clauses=4 --split-reuse-defs -tLPO4 -H'(6*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),3*ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),6*ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),2*ConjectureSymbolWeight(ConstPrio,10,10,5,5,5,1.5,1.5,1.5),1*Clauseweight(ByCreationDate,2,1,0.8),1*Clauseweight(PreferProcessed,1,1,1),1*FIFOWeight(ConstPrio),2*FIFOWeight(PreferProcessed),1*Refinedweight(PreferNonGoals,1,1,2,1.5,1.5))'"); +("atpstr_my_c0d9db6a7b7a90437bd07739f25aa91c0ffc1607","--definitional-cnf=24 --destructive-er-aggressive --destructive-er --prefer-initial-clauses -F1 --delete-bad-limit=150000000 --forward-context-sr -Ginvfreqconstmin -WSelectComplexG --simul-paramod --split-clauses=4 -tKBO -H'(10*ConjectureSymbolWeight(ConstPrio,10,10,5,5,5,1.5,1.5,1.5),1*Clauseweight(ByCreationDate,2,1,0.8),1*FIFOWeight(PreferProcessed),1*Refinedweight(PreferGroundGoals,2,1,2,1.0,1))'"); +("atpstr_my_c13d4886baa4fa2cef7b4f50892895255b04b078","--definitional-cnf=24 --destructive-er-aggressive --destructive-er --prefer-initial-clauses -F1 --delete-bad-limit=150000000 --sine='GSinE(CountFormulas,,2.0,,1,80,1.0)' --forward-context-sr -Garity -WSelectMaxLComplexAvoidPosPred --simul-paramod -tKBO -H'(10*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),2*ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),4*ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),4*ConjectureSymbolWeight(ConstPrio,10,10,5,5,5,1.5,1.5,1.5),1*Clauseweight(ByCreationDate,2,1,0.8),1*Clauseweight(PreferProcessed,1,1,1),1*FIFOWeight(ConstPrio),1*Refinedweight(PreferNonGoals,1,1,2,1.5,1.5),1*Refinedweight(SimulateSOS,1,1,2,1.5,2))'"); +("atpstr_my_c284f1f10aedfccc65cdb7d9b1210ef814cb8f1a","--definitional-cnf=24 --destructive-er-aggressive --destructive-er --prefer-initial-clauses -F1 --delete-bad-limit=150000000 --sine='GSinE(CountFormulas,hypos,5.0,,02,60,1.0)' --forward-context-sr -Garity -WSelectComplexG --simul-paramod --split-clauses=4 --split-reuse-defs -tLPO4 -H'(2*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),1*Clauseweight(ByCreationDate,2,1,0.8),1*FIFOWeight(ConstPrio),1*FIFOWeight(PreferProcessed),1*Refinedweight(PreferGroundGoals,2,1,2,1.0,1))'"); +("atpstr_my_cfee9ff42189552c6557cda7d36f20820c827219","--definitional-cnf=24 --destructive-er-aggressive --destructive-er --prefer-initial-clauses -F1 --delete-bad-limit=150000000 --sine='GSinE(CountFormulas,,1.5,,04,100,1.0)' --forward-context-sr -Garity -WSelectMaxLComplexAvoidPosPred --simul-paramod --split-clauses=4 -tLPO4 -H'(6*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),6*ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),1*ConjectureSymbolWeight(ConstPrio,10,10,5,5,5,1.5,1.5,1.5),4*Clauseweight(ConstPrio,3,1,1),1*Clauseweight(PreferProcessed,1,1,1),2*FIFOWeight(PreferProcessed),2*Refinedweight(PreferGroundGoals,2,1,2,1.0,1),2*Refinedweight(SimulateSOS,1,1,2,1.5,2))'"); +("atpstr_my_d60b37aca40b6e560cee4bde2efc36c05a24873f","--definitional-cnf=24 --destructive-er-aggressive --destructive-er --prefer-initial-clauses -F1 --delete-bad-limit=150000000 -Garity -WSelectComplexG --simul-paramod -tLPO4 -H'(1*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),2*ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),2*ConjectureSymbolWeight(ConstPrio,10,10,5,5,5,1.5,1.5,1.5),1*FIFOWeight(ConstPrio),1*FIFOWeight(PreferProcessed))'"); +("atpstr_my_e3b5200232138aedc93b8882335da60ccd317d87","--definitional-cnf=24 --destructive-er-aggressive --destructive-er --prefer-initial-clauses -F1 --delete-bad-limit=150000000 --sine='GSinE(CountFormulas,hypos,1.2,,01,80,1.0)' --forward-context-sr -Ginvfreqconstmin -WSelectComplexG --simul-paramod --split-clauses=7 --split-reuse-defs -tLPO4 -H'(10*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),1*ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),1*ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),1*Clauseweight(PreferProcessed,1,1,1))'"); +("atpstr_my_e4d2b8713a71da3a6bc64790217310975ccdde24","--definitional-cnf=24 --destructive-er-aggressive --destructive-er --prefer-initial-clauses -F1 --delete-bad-limit=150000000 --sine='GSinE(CountFormulas,hypos,1.1,,01,20000,1.0)' -winvfreqrank -c1 -Ginvfreq -WSelectComplexG --simul-paramod --split-clauses=7 --split-reuse-defs -tLPO4 -H'(1*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),7*ConjectureSymbolWeight(ConstPrio,10,10,5,5,5,1.5,1.5,1.5),1*Clauseweight(ByCreationDate,2,1,0.8),1*FIFOWeight(PreferProcessed),2*Refinedweight(PreferNonGoals,1,1,2,1.5,1.5))'"); +("atpstr_my_e6869afe09f22abfbe1163ee95524cfdbfe77603","--definitional-cnf=24 --destructive-er-aggressive --destructive-er --prefer-initial-clauses -F1 --delete-bad-limit=150000000 --sine='GSinE(CountFormulas,,2.0,,04,40,1.0)' --forward-context-sr -Garity -WSelectMaxLComplexAvoidPosPred --simul-paramod --split-clauses=4 -tLPO4 -H'(2*ConjectureSymbolWeight(ConstPrio,10,10,5,5,5,1.5,1.5,1.5),1*Clauseweight(ByCreationDate,2,1,0.8),1*Clauseweight(ConstPrio,3,1,1),2*FIFOWeight(PreferProcessed),10*Refinedweight(PreferGroundGoals,2,1,2,1.0,1),1*Refinedweight(SimulateSOS,1,1,2,1.5,2))'"); +("atpstr_my_e6ff24ca1a5013a612ccffc94da0b282477718de","--definitional-cnf=24 --destructive-er-aggressive --destructive-er --prefer-initial-clauses -F1 --delete-bad-limit=150000000 --sine='GSinE(CountFormulas,hypos,1.5,,02,100,1.0)' --forward-context-sr -Ginvfreqconstmin -WSelectComplexG --simul-paramod -tKBO -H'(10*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),1*FIFOWeight(ConstPrio))'"); +("atpstr_my_e8ac4ce30401bd9e99200725cfa03816a32e3aa4","--definitional-cnf=24 --destructive-er-aggressive --destructive-er --prefer-initial-clauses -F1 --delete-bad-limit=150000000 --sine='GSinE(CountFormulas,hypos,5.0,,01,20000,1.0)' --forward-context-sr -Ginvfreqconstmin -WSelectComplexG --simul-paramod --split-aggressive -tLPO4 -H'(6*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),12*ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),4*ConjectureSymbolWeight(ConstPrio,10,10,5,5,5,1.5,1.5,1.5),1*Clauseweight(PreferProcessed,1,1,1),1*Refinedweight(PreferNonGoals,1,1,2,1.5,1.5))'"); +("atpstr_my_eba37f91665fc364eeb63558058658ee9a149d9a","--definitional-cnf=24 --destructive-er-aggressive --destructive-er --prefer-initial-clauses -F1 --delete-bad-limit=150000000 --sine='GSinE(CountFormulas,hypos,1.1,,02,60,1.0)' --forward-context-sr -Garity -WSelectNewComplexAHP --simul-paramod --split-clauses=4 --split-reuse-defs -tLPO4 -H'(10*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),6*ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),10*ConjectureSymbolWeight(ConstPrio,10,10,5,5,5,1.5,1.5,1.5),2*Clauseweight(ConstPrio,3,1,1),1*Clauseweight(PreferProcessed,1,1,1),1*FIFOWeight(PreferProcessed),3*Refinedweight(PreferNonGoals,1,1,2,1.5,1.5),8*Refinedweight(PreferGroundGoals,2,1,2,1.0,1))'"); +("atpstr_my_edc94794a7d25c504761344c2a8b4afaac43a2d0","--definitional-cnf=24 --destructive-er-aggressive --destructive-er --prefer-initial-clauses -F1 --delete-bad-limit=150000000 --sine='GSinE(CountFormulas,hypos,5.0,,,100,1.0)' --forward-context-sr -Ginvfreqconstmin -WSelectMaxLComplexAvoidPosPred --simul-paramod --split-clauses=4 --split-reuse-defs -tKBO -H'(6*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),1*ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),2*ConjectureSymbolWeight(ConstPrio,10,10,5,5,5,1.5,1.5,1.5),1*Clauseweight(ByCreationDate,2,1,0.8),1*FIFOWeight(ConstPrio),1*FIFOWeight(PreferProcessed),1*Refinedweight(PreferGroundGoals,2,1,2,1.0,1))'"); +("atpstr_my_f67d73f57ffeda22ddd93400237cd848911520e5","--definitional-cnf=24 --destructive-er-aggressive --destructive-er --prefer-initial-clauses -F1 --delete-bad-limit=150000000 -Garity -WSelectComplexG --simul-paramod --split-aggressive --split-clauses=4 -tLPO4 -H'(10*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),1*FIFOWeight(PreferProcessed))'"); +("atpstr_my_f9ecf400d7420b0148b2ef7cf4b1498512cf83fd","--definitional-cnf=24 --destructive-er-aggressive --destructive-er --prefer-initial-clauses -F1 --delete-bad-limit=150000000 --forward-context-sr -winvfreqrank -c1 -Ginvfreq -WSelectMaxLComplexAvoidPosPred --simul-paramod -tLPO4 -H'(6*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),1*Clauseweight(ByCreationDate,2,1,0.8),1*Clauseweight(PreferProcessed,1,1,1),1*FIFOWeight(ConstPrio),2*FIFOWeight(PreferProcessed),2*Refinedweight(PreferGroundGoals,2,1,2,1.0,1))'"); +("atpstr_my_fc3fb6907f504dffe1a6181663296b37fe358480","--definitional-cnf=24 --destructive-er-aggressive --destructive-er --prefer-initial-clauses -F1 --delete-bad-limit=150000000 -Ginvfreqconstmin -WSelectMaxLComplexAvoidPosPred --simul-paramod --split-clauses=4 --split-reuse-defs -tLPO4 -H'(8*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),2*ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),7*ConjectureSymbolWeight(ConstPrio,10,10,5,5,5,1.5,1.5,1.5),1*Clauseweight(ByCreationDate,2,1,0.8),1*Clauseweight(PreferProcessed,1,1,1),1*Refinedweight(PreferNonGoals,1,1,2,1.5,1.5))'"); +("atpstr_my_fe548d15a6fc730fd350de634ad9d912ae198efd","--definitional-cnf=24 --destructive-er-aggressive --destructive-er --prefer-initial-clauses -F1 --delete-bad-limit=150000000 --simul-paramod --forward-context-sr -winvfreqrank -c1 -Ginvfreq -WSelectMaxLComplexAvoidPosPred -H'(10*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),1*FIFOWeight(ConstPrio))'"); +("G_E___001_B31_F1_AE_S4_CS_OS_S2S","--definitional-cnf=24 --delete-bad-limit=1024000000 --destructive-er --destructive-er-aggressive --forward-context-sr --oriented-simul-paramod --split-aggressive --split-clauses=4 --tstp-in -F1 -Ginvfreqconstmin -H'(10*ConjectureSymbolWeight(ConstPrio,10,10,5,5,5,1.5,1.5,1.5),1*FIFOWeight(ConstPrio))' -WSelectNewComplexAHP -tLPO4"); +("G_E___008_B07_F1_PI_AE_Q4_CS_SP_S2S","--split-reuse-defs --split-clauses=4 --simul-paramod --forward-context-sr --destructive-er-aggressive --destructive-er --prefer-initial-clauses -tLPO4 -Ginvfreq -F1 --delete-bad-limit=150000000 -WSelectNewComplexAHP -H'(10*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),1*FIFOWeight(ConstPrio))'"); +("G_E___008_B31_F1_PI_AE_S4_CS_SP_S2S","--split-aggressive --split-clauses=4 --simul-paramod --forward-context-sr --destructive-er-aggressive --destructive-er --prefer-initial-clauses -tLPO4 -Ginvfreqconstmin -F1 --delete-bad-limit=150000000 -WSelectNewComplexAHP -H'(10*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),1*FIFOWeight(ConstPrio))'"); +("G_E___008_C18_F1_PI_AE_IO_Q7_CS_SP_S4S","--definitional-cnf=24 --delete-bad-limit=512000000 --destructive-er --destructive-er-aggressive --forward-context-sr --prefer-initial-clauses --simul-paramod --sos-uses-input-types --split-clauses=7 --split-reuse-defs --tstp-in -F1 -Ginvfreq -H'(10*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),1*FIFOWeight(ConstPrio))' -WSelectNewComplexAHPNS -c1 -tKBO6 -winvfreqrank"); +("G_E___008_C18_F1_PI_AE_Q4_CS_SP_PS_S0Y","--definitional-cnf=24 --split-reuse-defs --split-clauses=4 --tstp-in --simul-paramod --forward-context-sr --destructive-er-aggressive --destructive-er --presat-simplify --prefer-initial-clauses -tKBO6 -winvfreqrank -c1 -Ginvfreq -F1 --delete-bad-limit=1024000000 -WSelectMaxLComplexAvoidPosPred -H'(10*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),1*FIFOWeight(ConstPrio))'"); +("G_E___008_C45_F1_AE_CS_SP_S0Y","--definitional-cnf=24 --delete-bad-limit=512000000 --destructive-er --destructive-er-aggressive --forward-context-sr --simul-paramod --tstp-in -F1 -Ginvfreqconjmax -H'(10*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),1*FIFOWeight(ConstPrio))' -WSelectMaxLComplexAvoidPosPred -c1 -tKBO6 -winvfreqrank"); +("G_E___008_K18_F1_PI_AE_CS_SP_S0Y","--simul-paramod --forward-context-sr --destructive-er-aggressive --destructive-er --prefer-initial-clauses -winvfreqrank -c1 -Ginvfreq -F1 --delete-bad-limit=150000000 -WSelectMaxLComplexAvoidPosPred -H'(10*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),1*FIFOWeight(ConstPrio))'"); +("G_E___010_B02_F1_PI_AE_S4_CS_SP_S0Y","--split-aggressive --split-clauses=4 --simul-paramod --forward-context-sr --destructive-er-aggressive --destructive-er --prefer-initial-clauses -tLPO4 -Garity -F1 --delete-bad-limit=150000000 -WSelectMaxLComplexAvoidPosPred -H'(4*ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),3*ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),1*Clauseweight(PreferProcessed,1,1,1),1*FIFOWeight(PreferProcessed))'"); +("G_E___024_B07_F1_PI_AE_Q4_CS_SP_S0Y","--split-reuse-defs --split-clauses=4 --simul-paramod --forward-context-sr --destructive-er-aggressive --destructive-er --prefer-initial-clauses -tLPO4 -Ginvfreq -F1 --delete-bad-limit=150000000 -WSelectMaxLComplexAvoidPosPred -H'(4*ConjectureGeneralSymbolWeight(SimulateSOS,100,100,100,50,50,50,50,1.5,1.5,1),3*ConjectureGeneralSymbolWeight(PreferNonGoals,100,100,100,50,50,1000,100,1.5,1.5,1),1*Clauseweight(PreferProcessed,1,1,1),1*FIFOWeight(PreferProcessed))'"); +("G_E___024_B31_F1_AE_Q4_CS_SP_S2S","--definitional-cnf=24 --delete-bad-limit=512000000 --destructive-er --destructive-er-aggressive --forward-context-sr --simul-paramod --split-clauses=4 --split-reuse-defs --tstp-in -F1 -Ginvfreqconstmin -H'(4*ConjectureGeneralSymbolWeight(SimulateSOS,100,100,100,50,50,50,50,1.5,1.5,1),3*ConjectureGeneralSymbolWeight(PreferNonGoals,100,100,100,50,50,1000,100,1.5,1.5,1),1*Clauseweight(PreferProcessed,1,1,1),1*FIFOWeight(PreferProcessed))' -WSelectNewComplexAHP -tLPO4"); +("G_E___042_C45_F1_PI_AE_Q4_CS_SP_PS_S4S","--definitional-cnf=24 --delete-bad-limit=1024000000 --destructive-er --destructive-er-aggressive --forward-context-sr --prefer-initial-clauses --presat-simplify --simul-paramod --split-clauses=4 --split-reuse-defs --tstp-in -F1 -Ginvfreqconjmax -H'(20*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),1*Refinedweight(PreferNonGoals,2,1,2,3,0.8),1*FIFOWeight(ConstPrio))' -WSelectNewComplexAHPNS -c1 -tKBO6 -winvfreqrank"); +("G_E___044_C18_F1_PI_AE_R4_S1S","--definitional-cnf=24 --delete-bad-limit=512000000 --destructive-er --destructive-er-aggressive --prefer-initial-clauses --split-aggressive --split-clauses=4 --split-reuse-defs --tstp-in -F1 -Ginvfreq -H'(4*Refinedweight(SimulateSOS,1,1,2,1.5,2),3*Refinedweight(PreferNonGoals,1,1,2,1.5,1.5),2*Clauseweight(PreferProcessed,1,1,1),1*FIFOWeight(PreferProcessed))' -WSelectComplexAHP -c1 -tKBO6 -winvfreqrank"); +("G_E___045_B31_F1_PI_AE_S4_CS_SP_S0Y","--split-aggressive --split-clauses=4 --simul-paramod --forward-context-sr --destructive-er-aggressive --destructive-er --prefer-initial-clauses -tLPO4 -Ginvfreqconstmin -F1 --delete-bad-limit=150000000 -WSelectMaxLComplexAvoidPosPred -H'(4*Refinedweight(SimulateSOS,1,1,2,1.5,2),3*Refinedweight(PreferNonGoals,1,1,2,1.5,1.5),1*Clauseweight(PreferProcessed,1,1,1),1*FIFOWeight(PreferProcessed))'"); +("G_E___045_K18_F1_PI_AE_CS_OS_S0S","--oriented-simul-paramod --forward-context-sr --destructive-er-aggressive --destructive-er --prefer-initial-clauses -winvfreqrank -c1 -Ginvfreq -F1 --delete-bad-limit=150000000 -WSelectComplexG -H'(4*Refinedweight(SimulateSOS,1,1,2,1.5,2),3*Refinedweight(PreferNonGoals,1,1,2,1.5,1.5),1*Clauseweight(PreferProcessed,1,1,1),1*FIFOWeight(PreferProcessed))'"); +("G_E___045_K18_F1_PI_AE_CS_OS_S0S_sine05","--sine=gf120_gu_RUU_F100_L00100 --oriented-simul-paramod --forward-context-sr --destructive-er-aggressive --destructive-er --prefer-initial-clauses -winvfreqrank -c1 -Ginvfreq -F1 --delete-bad-limit=150000000 -WSelectComplexG -H'(4*Refinedweight(SimulateSOS,1,1,2,1.5,2),3*Refinedweight(PreferNonGoals,1,1,2,1.5,1.5),1*Clauseweight(PreferProcessed,1,1,1),1*FIFOWeight(PreferProcessed))'"); +("G_E___052_K18_F1_PI_AE_Q4_CS_SP_S0Y","--split-reuse-defs --split-clauses=4 --simul-paramod --forward-context-sr --destructive-er-aggressive --destructive-er --prefer-initial-clauses -winvfreqrank -c1 -Ginvfreq -F1 --delete-bad-limit=150000000 -WSelectMaxLComplexAvoidPosPred -H'(10*ConjectureRelativeSymbolWeight(ConstPrio,0.05,100,100,100,100,1.5,1.5,1.5),1*FIFOWeight(SimulateSOS))'"); +("G_E___073_C18_F1_PI_AE_Q4_CS_SP_S0Y","--definitional-cnf=24 --delete-bad-limit=1024000000 --destructive-er --destructive-er-aggressive --forward-context-sr --prefer-initial-clauses --simul-paramod --split-clauses=4 --split-reuse-defs --tstp-in -F1 -Ginvfreq -H'(5*RelevanceLevelWeight2(SimulateSOS,2,2,0,2,100,100,100,100,1.5,1.5,1),1*FIFOWeight(PreferProcessed))' -WSelectMaxLComplexAvoidPosPred -c1 -tKBO6 -winvfreqrank"); +("G_E___092_C01_F1_PI_AE_Q4_CS_SP_PS_S0Y","--definitional-cnf=24 --tstp-in --presat-simplify --split-clauses=4 --split-reuse-defs --simul-paramod --forward-context-sr --destructive-er-aggressive --destructive-er --prefer-initial-clauses -F1 --delete-bad-limit=1024000000 -WSelectMaxLComplexAvoidPosPred -tKBO6 -H'(4*RelevanceLevelWeight2(SimulateSOS,1,2,0,2,100,100,100,400,1.5,1.5,1),3*ConjectureGeneralSymbolWeight(PreferNonGoals,200,100,200,50,50,1,100,1.5,1.5,1),1*Clauseweight(PreferProcessed,1,1,1),1*FIFOWeight(PreferProcessed))'"); +("G_E___107_C33_F1_PI_AE_Q4_CS_SP_PS_S0Y","--definitional-cnf=24 --delete-bad-limit=512000000 --destructive-er --destructive-er-aggressive --forward-context-sr --prefer-initial-clauses --presat-simplify --simul-paramod --split-clauses=4 --split-reuse-defs --tstp-in -F1 -Ginvfreqconstmin -H'(4*RelevanceLevelWeight2(SimulateSOS,0,2,1,2,100,100,100,400,1.5,1.5,1),3*ConjectureGeneralSymbolWeight(PreferNonGoals,200,100,200,50,50,1,100,1.5,1.5,1),1*Clauseweight(PreferProcessed,1,1,1),1*FIFOWeight(PreferProcessed))' -WSelectMaxLComplexAvoidPosPred -c1 -tKBO6 -wprecedence"); +("G_E___107_C37_F1_PI_AE_Q4_CS_SP_PS_S0Y","--definitional-cnf=24 --split-clauses=4 --split-reuse-defs --simul-paramod --forward-context-sr --destructive-er-aggressive --destructive-er --presat-simplify --prefer-initial-clauses -tKBO6 -warity -c1 -Ginvconjfreq -F1 --delete-bad-limit=1024000000 -WSelectMaxLComplexAvoidPosPred -H'(4*RelevanceLevelWeight2(SimulateSOS,0,2,1,2,100,100,100,400,1.5,1.5,1),3*ConjectureGeneralSymbolWeight(PreferNonGoals,200,100,200,50,50,1,100,1.5,1.5,1),1*Clauseweight(PreferProcessed,1,1,1),1*FIFOWeight(PreferProcessed))'"); +("G_E___107_C37_F1_PI_AE_Q4_CS_SP_PS_S0Y_sine13","--sine=gf120_h_gu_R02_F100_L20000 --split-clauses=4 --split-reuse-defs --simul-paramod --forward-context-sr --destructive-er-aggressive --destructive-er --presat-simplify --prefer-initial-clauses -tKBO6 -warity -c1 -Ginvconjfreq -F1 --delete-bad-limit=1024000000 -WSelectMaxLComplexAvoidPosPred -H'(4*RelevanceLevelWeight2(SimulateSOS,0,2,1,2,100,100,100,400,1.5,1.5,1),3*ConjectureGeneralSymbolWeight(PreferNonGoals,200,100,200,50,50,1,100,1.5,1.5,1),1*Clauseweight(PreferProcessed,1,1,1),1*FIFOWeight(PreferProcessed))'"); +("G_E___107_C45_F1_PI_AE_Q7_CS_SP_PS_S0Y","--definitional-cnf=24 --delete-bad-limit=512000000 --destructive-er --destructive-er-aggressive --forward-context-sr --prefer-initial-clauses --presat-simplify --simul-paramod --split-clauses=7 --split-reuse-defs --tstp-in -F1 -Ginvfreqconjmax -H'(4*RelevanceLevelWeight2(SimulateSOS,0,2,1,2,100,100,100,400,1.5,1.5,1),3*ConjectureGeneralSymbolWeight(PreferNonGoals,200,100,200,50,50,1,100,1.5,1.5,1),1*Clauseweight(PreferProcessed,1,1,1),1*FIFOWeight(PreferProcessed))' -WSelectMaxLComplexAvoidPosPred -c1 -tKBO6 -winvfreqrank"); +("H_____047_C18_F1_AE_R8_CS_SP_S2S","--definitional-cnf=24 --delete-bad-limit=512000000 --destructive-er --destructive-er-aggressive --forward-context-sr --simul-paramod --split-aggressive --split-clauses=8 --split-reuse-defs --tstp-in -F1 -Ginvfreq -H'(10*PNRefinedweight(PreferGoals,1,1,1,2,2,2,0.5),10*PNRefinedweight(PreferNonGoals,2,1,1,1,2,2,2),5*OrientLMaxWeight(ConstPrio,2,1,2,1,1),1*FIFOWeight(ConstPrio))' -WSelectNewComplexAHP -c1 -tKBO6 -winvfreqrank"); +("H_____102_C18_F1_PI_AE_Q4_CS_SP_S1S","--definitional-cnf=24 --delete-bad-limit=1024000000 --destructive-er --destructive-er-aggressive --forward-context-sr --prefer-initial-clauses --simul-paramod --split-clauses=4 --split-reuse-defs --tstp-in -F1 -Ginvfreq -H'(10*Refinedweight(PreferGoals,1,2,2,2,0.5),10*Refinedweight(PreferNonGoals,2,1,2,2,2),3*OrientLMaxWeight(ConstPrio,2,1,2,1,1),2*ClauseWeightAge(ConstPrio,1,1,1,3))' -WSelectComplexAHP -c1 -tKBO6 -winvfreqrank"); +("my10simple","--definitional-cnf=24 --split-clauses=7 --simul-paramod --forward-context-sr --destructive-er-aggressive --destructive-er --prefer-initial-clauses -tLPO4 -Ginvfreqconstmin -F1 --delete-bad-limit=150000000 -WSelectMaxLComplexAvoidPosPred -H'(2*ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),1*FIFOWeight(PreferProcessed),1*FIFOWeight(ConstPrio))'"); +("my11simple","--definitional-cnf=24 --simul-paramod --forward-context-sr --destructive-er-aggressive --destructive-er --prefer-initial-clauses -tKBO -winvfreqrank -c1 -Ginvfreq -F1 --delete-bad-limit=150000000 -WSelectMaxLComplexAvoidPosPred -H'(1*FIFOWeight(PreferProcessed),2*ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),1*Refinedweight(SimulateSOS,1,1,2,1.5,2),2*Refinedweight(PreferNonGoals,1,1,2,1.5,1.5))'"); +("my11simple_sine13","--sine=gf120_h_gu_R02_F100_L20000 --definitional-cnf=24 --simul-paramod --forward-context-sr --destructive-er-aggressive --destructive-er --prefer-initial-clauses -tKBO -winvfreqrank -c1 -Ginvfreq -F1 --delete-bad-limit=150000000 -WSelectMaxLComplexAvoidPosPred -H'(1*FIFOWeight(PreferProcessed),2*ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),1*Refinedweight(SimulateSOS,1,1,2,1.5,2),2*Refinedweight(PreferNonGoals,1,1,2,1.5,1.5))'"); +("my12simple","--definitional-cnf=24 --split-aggressive --simul-paramod --forward-context-sr --destructive-er-aggressive --destructive-er --prefer-initial-clauses -tKBO -winvfreqrank -c1 -Ginvfreq -F1 --delete-bad-limit=150000000 -WSelectMaxLComplexAvoidPosPred -H'(1*Refinedweight(PreferNonGoals,1,1,2,1.5,1.5),2*ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),1*FIFOWeight(PreferProcessed))'"); +("my13simple","--definitional-cnf=24 --split-aggressive --simul-paramod --forward-context-sr --destructive-er-aggressive --destructive-er --prefer-initial-clauses -tAuto -Ginvfreqconstmin -F1 --delete-bad-limit=150000000 -WSelectComplexG -H'(6*ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),1*Refinedweight(PreferNonGoals,1,1,2,1.5,1.5),8*ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),1*FIFOWeight(PreferProcessed))'"); +("my14simple","--definitional-cnf=24 --simul-paramod --forward-context-sr --destructive-er-aggressive --destructive-er --prefer-initial-clauses -tLPO4 -Garity -F1 --delete-bad-limit=150000000 -WSelectComplexG -H'(6*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),1*ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),1*FIFOWeight(PreferProcessed),1*ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),1*FIFOWeight(ConstPrio))'"); +("my15simple","--definitional-cnf=24 --simul-paramod --forward-context-sr --destructive-er-aggressive --destructive-er --prefer-initial-clauses -tLPO4 -Ginvfreqconstmin -F1 --delete-bad-limit=150000000 -WSelectNewComplexAHP -H'(1*Refinedweight(SimulateSOS,1,1,2,1.5,2),6*ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),2*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5))'"); +("my16simple","--definitional-cnf=24 --split-clauses=4 --simul-paramod --forward-context-sr --destructive-er-aggressive --destructive-er --prefer-initial-clauses -tLPO4 -winvfreqrank -c1 -Ginvfreq -F1 --delete-bad-limit=150000000 -WSelectComplexG -H'(1*FIFOWeight(ConstPrio),1*FIFOWeight(PreferProcessed),1*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),1*Refinedweight(PreferNonGoals,1,1,2,1.5,1.5))'"); +("my17simple","--definitional-cnf=24 --split-aggressive --simul-paramod --forward-context-sr --destructive-er-aggressive --destructive-er --prefer-initial-clauses -tLPO4 -Garity -F1 --delete-bad-limit=150000000 -WSelectComplexG -H'(1*FIFOWeight(ConstPrio),1*FIFOWeight(PreferProcessed),1*ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),3*ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),10*Refinedweight(SimulateSOS,1,1,2,1.5,2))'"); +("my17simple_sine13","--sine=gf120_h_gu_R02_F100_L20000 --definitional-cnf=24 --split-aggressive --simul-paramod --forward-context-sr --destructive-er-aggressive --destructive-er --prefer-initial-clauses -tLPO4 -Garity -F1 --delete-bad-limit=150000000 -WSelectComplexG -H'(1*FIFOWeight(ConstPrio),1*FIFOWeight(PreferProcessed),1*ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),3*ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),10*Refinedweight(SimulateSOS,1,1,2,1.5,2))'"); +("my18simple","--definitional-cnf=24 --simul-paramod --forward-context-sr --destructive-er-aggressive --destructive-er --prefer-initial-clauses -tLPO4 -Ginvfreqconstmin -F1 --delete-bad-limit=150000000 -WSelectNewComplexAHP -H'(1*FIFOWeight(ConstPrio),2*FIFOWeight(PreferProcessed),8*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5))'"); +("my19simple","--definitional-cnf=24 --split-aggressive --simul-paramod --forward-context-sr --destructive-er-aggressive --destructive-er --prefer-initial-clauses -tLPO4 -Garity -F1 --delete-bad-limit=150000000 -WSelectComplexG -H'(1*Refinedweight(PreferNonGoals,1,1,2,1.5,1.5),10*Refinedweight(SimulateSOS,1,1,2,1.5,2),2*FIFOWeight(PreferProcessed),8*ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),1*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),1*FIFOWeight(ConstPrio))'"); +("my1KBO_SOS","--definitional-cnf=24 --split-aggressive --split-clauses=4 --simul-paramod --forward-context-sr --destructive-er-aggressive --destructive-er --prefer-initial-clauses -tKBO -Ginvfreqconstmin -F1 --delete-bad-limit=150000000 -WSelectComplexG -H'(4*ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),1*ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),10*Refinedweight(SimulateSOS,1,1,2,1.5,2),1*Refinedweight(PreferNonGoals,1,1,2,1.5,1.5),1*Clauseweight(PreferProcessed,1,1,1),2*FIFOWeight(PreferProcessed))'"); +("my1_SOS","--definitional-cnf=24 --split-aggressive --split-clauses=4 --simul-paramod --forward-context-sr --destructive-er-aggressive --destructive-er --prefer-initial-clauses -tLPO4 -Ginvfreqconstmin -F1 --delete-bad-limit=150000000 -WSelectComplexG -H'(4*ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),1*ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),10*Refinedweight(SimulateSOS,1,1,2,1.5,2),1*Refinedweight(PreferNonGoals,1,1,2,1.5,1.5),1*Clauseweight(PreferProcessed,1,1,1),2*FIFOWeight(PreferProcessed))'"); +("my20simple","--definitional-cnf=24 --simul-paramod --forward-context-sr --destructive-er-aggressive --destructive-er --prefer-initial-clauses -tKBO -Garity -F1 --delete-bad-limit=150000000 -WSelectMaxLComplexAvoidPosPred -H'(1*Refinedweight(SimulateSOS,1,1,2,1.5,2),1*FIFOWeight(ConstPrio),10*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5))'"); +("my21simple","--definitional-cnf=24 --simul-paramod --forward-context-sr --destructive-er-aggressive --destructive-er --prefer-initial-clauses -tLPO4 -winvfreqrank -c1 -Ginvfreq -F1 --delete-bad-limit=150000000 -WSelectMaxLComplexAvoidPosPred -H'(1*FIFOWeight(ConstPrio),2*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),2*FIFOWeight(PreferProcessed))'"); +("my22simple","--definitional-cnf=24 --split-clauses=7 --simul-paramod --forward-context-sr --destructive-er-aggressive --destructive-er --prefer-initial-clauses -tAuto -winvfreqrank -c1 -Ginvfreq -F1 --delete-bad-limit=150000000 -WSelectComplexG -H'(1*FIFOWeight(ConstPrio),6*ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),8*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),2*FIFOWeight(PreferProcessed),1*Refinedweight(SimulateSOS,1,1,2,1.5,2))'"); +("my23simple","--definitional-cnf=24 --split-aggressive --split-clauses=4 --simul-paramod --forward-context-sr --destructive-er-aggressive --destructive-er --prefer-initial-clauses -tLPO4 -Garity -F1 --delete-bad-limit=150000000 -WSelectComplexG -H'(1*FIFOWeight(PreferProcessed),10*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),1*ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),1*Refinedweight(PreferNonGoals,1,1,2,1.5,1.5))'"); +("my24simple","--definitional-cnf=24 --split-aggressive --simul-paramod --forward-context-sr --destructive-er-aggressive --destructive-er --prefer-initial-clauses -tLPO4 -Garity -F1 --delete-bad-limit=150000000 -WSelectComplexG -H'(1*ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),6*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),2*FIFOWeight(PreferProcessed),1*ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),8*Refinedweight(SimulateSOS,1,1,2,1.5,2))'"); +("my25simple","--definitional-cnf=24 --split-aggressive --simul-paramod --forward-context-sr --destructive-er-aggressive --destructive-er --prefer-initial-clauses -tKBO -Garity -F1 --delete-bad-limit=150000000 -WSelectMaxLComplexAvoidPosPred -H'(2*ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),2*ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),2*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),2*FIFOWeight(PreferProcessed),1*FIFOWeight(ConstPrio))'"); +("my2simple","--definitional-cnf=24 --split-aggressive --split-clauses=4 --simul-paramod --forward-context-sr --destructive-er-aggressive --destructive-er --prefer-initial-clauses -tLPO4 -Ginvfreqconstmin -F1 --delete-bad-limit=150000000 -WSelectMaxLComplexAvoidPosPred -H'(1*Clauseweight(PreferProcessed,1,1,1),2*FIFOWeight(PreferProcessed))'"); +("my3simple","--definitional-cnf=24 --split-aggressive --split-clauses=4 --simul-paramod --forward-context-sr --destructive-er-aggressive --destructive-er --prefer-initial-clauses -tLPO4 -Garity -F1 --delete-bad-limit=150000000 -WSelectMaxLComplexAvoidPosPred -H'(1*ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),1*Clauseweight(PreferProcessed,1,1,1),2*FIFOWeight(PreferProcessed))'"); +("my4simple","--definitional-cnf=24 --split-aggressive --simul-paramod --forward-context-sr --destructive-er-aggressive --destructive-er --prefer-initial-clauses -tAuto -winvfreqrank -c1 -Ginvfreq -F1 --delete-bad-limit=150000000 -WSelectMaxLComplexAvoidPosPred -H'(6*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),1*FIFOWeight(ConstPrio),1*FIFOWeight(PreferProcessed),1*ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1))'"); +("my5simple","--definitional-cnf=24 --split-aggressive --simul-paramod --forward-context-sr --destructive-er-aggressive --destructive-er --prefer-initial-clauses -tKBO -Garity -F1 --delete-bad-limit=150000000 -WSelectMaxLComplexAvoidPosPred -H'(1*FIFOWeight(ConstPrio),8*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),2*FIFOWeight(PreferProcessed))'"); +("my6simple","--definitional-cnf=24 --split-clauses=7 --simul-paramod --forward-context-sr --destructive-er-aggressive --destructive-er --prefer-initial-clauses -tLPO4 -winvfreqrank -c1 -Ginvfreq -F1 --delete-bad-limit=150000000 -WSelectMaxLComplexAvoidPosPred -H'(1*FIFOWeight(ConstPrio),2*FIFOWeight(PreferProcessed),1*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5))'"); +("my7simple","--definitional-cnf=24 --split-aggressive --simul-paramod --forward-context-sr --destructive-er-aggressive --destructive-er --prefer-initial-clauses -tLPO4 -Ginvfreqconstmin -F1 --delete-bad-limit=150000000 -WSelectMaxLComplexAvoidPosPred -H'(1*FIFOWeight(PreferProcessed),1*FIFOWeight(ConstPrio),2*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5))'"); +("my8simple","--definitional-cnf=24 --split-aggressive --simul-paramod --forward-context-sr --destructive-er-aggressive --destructive-er --prefer-initial-clauses -tKBO -Ginvfreqconstmin -F1 --delete-bad-limit=150000000 -WSelectMaxLComplexAvoidPosPred -H'(1*FIFOWeight(ConstPrio),4*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),1*Refinedweight(PreferNonGoals,1,1,2,1.5,1.5),2*FIFOWeight(PreferProcessed))'"); +("my8simple_sine13","--sine=gf120_h_gu_R02_F100_L20000 --definitional-cnf=24 --split-aggressive --simul-paramod --forward-context-sr --destructive-er-aggressive --destructive-er --prefer-initial-clauses -tKBO -Ginvfreqconstmin -F1 --delete-bad-limit=150000000 -WSelectMaxLComplexAvoidPosPred -H'(1*FIFOWeight(ConstPrio),4*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),1*Refinedweight(PreferNonGoals,1,1,2,1.5,1.5),2*FIFOWeight(PreferProcessed))'"); +("my9simple","--definitional-cnf=24 --split-aggressive --split-clauses=7 --simul-paramod --forward-context-sr --destructive-er-aggressive --destructive-er --prefer-initial-clauses -tAuto -winvfreqrank -c1 -Ginvfreq -F1 --delete-bad-limit=150000000 -WSelectComplexG -H'(6*ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),1*FIFOWeight(ConstPrio),2*Refinedweight(SimulateSOS,1,1,2,1.5,2),2*Refinedweight(PreferNonGoals,1,1,2,1.5,1.5),2*FIFOWeight(PreferProcessed),10*ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),3*ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1))'"); +("X_____auto_sine03","--delete-bad-limit=1024000000 -xAuto -tAuto --sine=gf120_gu_R02_F100_L20000"); +("X_____auto_sine05","--delete-bad-limit=1024000000 -xAuto -tAuto --sine=gf120_gu_RUU_F100_L00100"); +("X_____auto_sine13","--delete-bad-limit=1024000000 -xAuto -tAuto --sine=gf120_h_gu_R02_F100_L20000"); +("X_____sauto_300","--delete-bad-limit=1024000000 --auto")];; diff --git a/src/holyhammer/hh/read.ml b/src/holyhammer/hh/read.ml new file mode 100644 index 0000000000..131a7842e4 --- /dev/null +++ b/src/holyhammer/hh/read.ml @@ -0,0 +1,155 @@ +(*-------------------------------------------------------------------------- *) +(* Read statements .p,dependencies .hd, (.sx not yet supported) from the *) +(* libraries exported from different ITPs. All .p and .hd files below the *) +(* input directory (including files in subdirectories) *) +(*-------------------------------------------------------------------------- *) + +(*-------------------------------------------------------------------------- + Input directories + -------------------------------------------------------------------------- *) + +let lib_dir = "../palibs" +let dir_of_itp p = match p with + "h4" -> lib_dir ^ "/h4-kananaskis9/standard_library" + | "hl" -> lib_dir ^ "/hl-225/complex_multivariate" + | "h4core" -> lib_dir ^ "/h4-kananaskis9/core_library" + | "hlcore" -> lib_dir ^ "/hl-225/core_library" + | _ -> failwith "dir_of_prover" +let thydep_of_itp p = dir_of_itp p ^ "/info/theory_dep" +let thyorder_of_itp p = dir_of_itp p ^ "/info/theory_order" + +(*-------------------------------------------------------------------------- + Reading a file + -------------------------------------------------------------------------- *) + +let file_iter fname fn = + let ic = try open_in fname with Sys_error _ -> failwith ("file_iter: "^fname) in + let next = ref 0 in + let rec suck_lines () = fn !next (input_line ic); incr next; suck_lines () in + try suck_lines () with End_of_file -> close_in ic + +let file_to_stringl file = + let r = ref [] in + let f _ s = r := s :: !r in + file_iter file f; List.rev !r + +(*-------------------------------------------------------------------------- + Recursive search of files with a given extension + -------------------------------------------------------------------------- *) + +let rec rdirents isok prefix acc d = + try + let dirh = Unix.opendir (prefix ^ d) in + let rec fs acc = try fs + ( + let l = Unix.readdir dirh in + if l <> "." && l <> ".." + then rdirents isok (prefix ^ d ^ "/") acc l + else acc + ) + with End_of_file -> acc in + let ret = fs acc in + Unix.closedir dirh; ret + with Unix.Unix_error (Unix.ENOTDIR, _, _) -> if isok d then (prefix ^ d) :: acc else acc + +let find_ext dir ext = + let n_ext = String.length ext in + let isok s = + let l = String.length s in + l > n_ext && String.sub s (l - n_ext) n_ext = ext + in + let l = rdirents isok "" [] dir in + let len = String.length dir in + List.map (fun s -> String.sub s (len + 1) (String.length s - len - 1)) l + +let find_p dir = find_ext dir ".p" +let find_hd dir = find_ext dir ".hd" + +(* To be moved to mizar and coq export +let find_xml2 dir = find_ext dir ".xml2" +let find_con_xml dir = find_ext dir ".con.xml" +let find_ind_xml dir = find_ext dir ".ind.xml" +let find_con_body_xml dir = find_ext dir ".con.body.xml" +*) + +(*-------------------------------------------------------------------------- + Parsing statements (.p) and dependencies (.hd). + -------------------------------------------------------------------------- *) + +(* Parsing statements *) +let rxpspace = Str.regexp " ";; + +let read_statements_aux fname = + let inc = Pervasives.open_in fname in + let lexb = Lexing.from_channel inc in + let rec parse_statements () = + try let v = try Hh_parse.hhtop Hh_lexer.hh2lex lexb + with Parsing.YYexit a -> Obj.magic a in v :: (parse_statements ()) + with End_of_file -> + close_in inc; + [] + | exn -> (* error message *) + begin + let curr = lexb.Lexing.lex_curr_p in + let line = curr.Lexing.pos_lnum in + let cnum = curr.Lexing.pos_cnum - curr.Lexing.pos_bol in + Printf.eprintf "HH Parse error: %s line %i, char %i\n" fname line cnum; + raise exn + end + in parse_statements () + +let read_statements dir filel = + let f x = (Filename.chop_extension x, read_statements_aux (dir ^ "/" ^ x)) in + List.map f filel + +(* Parsing dependencies *) +let read_thy_graph fname = + let hash = Hashtbl.create 1000 in + let add _ line = + match Str.split rxpspace line with + [] -> failwith ("empty line: " ^ fname) + | h :: t -> Hashtbl.add hash h t + in + file_iter fname add; hash + +let read_thy_lo fname = + let ll = ref [] in + let add _ s = ll := (Str.split rxpspace s) :: !ll in + file_iter fname add; List.hd(List.rev !ll) + +let read_deps dir filel = + let hash = Hashtbl.create 20000 in + let add fname _ line = + match Str.split rxpspace line with + [] -> failwith ("empty .hd file line: " ^ fname) + | h :: t -> Hashtbl.add hash h (Filename.chop_extension fname, t) + in + List.iter (fun f -> file_iter (dir ^ "/" ^ f) (add f)) filel; + hash + +(*-------------------------------------------------------------------------- + Main reading functions + -------------------------------------------------------------------------- *) + +(* Statements + Dependencies *) +let read_dir dir = + let hds = find_hd dir in + let ps = find_p dir in + (read_deps dir hds, read_statements dir ps) + +(* Conjecture *) +let read_conjecture fname = + let fourth (_,_,_,t) = t in + fourth (List.hd (read_statements_aux fname)) + +(* Kept for thf0hh1 *) +let read_prf filel = + let hash = Hashtbl.create 1000 in + let read1 fname = + let add (_, name, ty, tm) = Hashtbl.add hash (fname, name) (ty, tm) in + let l = read_statements_aux fname in + List.iter add l + in + List.iter read1 filel; + hash + diff --git a/src/holyhammer/hh/thf0.ml b/src/holyhammer/hh/thf0.ml new file mode 100644 index 0000000000..59d05915e8 --- /dev/null +++ b/src/holyhammer/hh/thf0.ml @@ -0,0 +1,142 @@ +(* This is the main loop of a HOLyHammer based THF0 prover + submitted to CASC 2014 *) +let try_predict pred time axassoc cname conj prover = + let fname = Filename.temp_file "hh" ".p" in + Predict.unlink := fname :: !Predict.unlink; + let pth = List.map (fun x -> Fusion.Sequent ([], List.assoc x axassoc)) pred in + let pth, p = [Bool.tRUTH; Bool.bOOL_CASES_AX] @ pth, ["TRUTH"; "BOOL_CASES"] @ pred in + Hh_write.write_atp_proof fname (pth, p) cname conj; + Thf0hh1.run_prover time fname prover +;; + +let try_predict_seq predl t axassoc cname conj = + let t = string_of_int (int_of_string t / (List.length predl)) in + let fold_fun sf (pred,prover) = + match sf with Some _ -> sf | None -> + (Printf.printf "Trying: pred len %i prover %s\n%!" (List.length pred) (Digest.to_hex (Digest.string prover)); + try_predict pred t axassoc cname conj prover) in + List.fold_left fold_fun None predl +;; + +let make_maybe_seq len axsyms csyms axassoc = + let l2 = int_of_float (1.5 *. ((float_of_int len) ** 0.6)) in + let l3 = int_of_float (3.0 *. ((float_of_int len) ** 0.6)) in + let l4 = int_of_float (5.0 *. ((float_of_int len) ** 0.6)) in + let a1 = Predict.mepo_advice axsyms csyms l4 in + let a2 = Predict.knn_advice 4 axsyms csyms l3 in + let a3 = Predict.nb_advice axsyms csyms l2 in + [(a1,"e"); (a2,"e"); (a3,"e"); (List.map fst axassoc, "e")] +;; + +let fast_seq = [ + "atpstr_my_fe548d15a6fc730fd350de634ad9d912ae198efd"; + "atpstr_my_e6869afe09f22abfbe1163ee95524cfdbfe77603"; + "my7simple"; + "atpstr_my_a473e2c35f909af4ba00d9f1a7a8a454a851ed9c"; + "atpstr_my_edc94794a7d25c504761344c2a8b4afaac43a2d0"; + "my24simple"; + "G_E___008_C45_F1_AE_CS_SP_S0Y"; + "X_____auto_sine03"; + "atpstr_my_69856783cec8fab1acccfe08bb382ad42c8475df"; + "H_____047_C18_F1_AE_R8_CS_SP_S2S"; + "G_E___024_B07_F1_PI_AE_Q4_CS_SP_S0Y"; + "atpstr_my_e8ac4ce30401bd9e99200725cfa03816a32e3aa4"; +];; + +let make_fast_seq axnames = List.map (fun p -> (axnames, Proto.lookup p)) fast_seq;; + +let slow_seq = [ + ("atpstr_my_fe548d15a6fc730fd350de634ad9d912ae198efd","all",0); + ("atpstr_my_a74b37f2d8b7e35be554fc999f671188cf40f113","mepo",1); + ("my24simple","all",0); + ("G_E___008_C18_F1_PI_AE_IO_Q7_CS_SP_S4S","mepo",1); + ("X_____auto_sine05","all",0); + ("atpstr_my_e6869afe09f22abfbe1163ee95524cfdbfe77603","mepo",2); + ("atpstr_my_69856783cec8fab1acccfe08bb382ad42c8475df","knn2",2); + ("atpstr_my_edc94794a7d25c504761344c2a8b4afaac43a2d0","mepo",2); + ("atpstr_my_9f72062a403172caf26fbe878a32becf1403c276","knn8",3); + ("atpstr_my_9f72062a403172caf26fbe878a32becf1403c276","nb",2); + ("atpstr_my_4e6e6157a8ac18b9bae11142d40377c9660db06b","knn8",3); + ("atpstr_my_c284f1f10aedfccc65cdb7d9b1210ef814cb8f1a","mepo",2); + ("atpstr_my_a4a4da5778ba9bebf9bc5e616786c7ad501b1af5","knn2",1); + ("atpstr_my_7b674c1081cd73ca6ce34d02596e6f6fd903ac6c","mepo",2); + ("atpstr_my_edc94794a7d25c504761344c2a8b4afaac43a2d0","mepo",3); + ("G_E___024_B07_F1_PI_AE_Q4_CS_SP_S0Y","all",0); +];; + +let rec cut_list acc n = function + [] -> List.rev acc +| h :: t -> if n = 0 then List.rev acc else cut_list (h :: acc) (n - 1) t;; + +let make_slow_seq len axsyms csyms axassoc = + let len1 = int_of_float (1.5 *. ((float_of_int len) ** 0.6)) + and len2 = int_of_float (3.0 *. ((float_of_int len) ** 0.6)) + and len3 = int_of_float (5.0 *. ((float_of_int len) ** 0.6)) in + let knn8 = Predict.knn_advice 8 axsyms csyms len3 in + let knn2 = Predict.knn_advice 2 axsyms csyms len2 in + let mepo = Predict.mepo_advice axsyms csyms len3 in + let nb = Predict.nb_advice axsyms csyms len2 in + let map_len pl = if pl = 1 then len1 else if pl = 2 then len2 else len3 in + let mapper (p, pm, pl) = + match pm with + "knn8" -> (cut_list [] (map_len pl) knn8,Proto.lookup p) + | "knn2" -> (cut_list [] (map_len pl) knn2,Proto.lookup p) + | "mepo" -> (cut_list [] (map_len pl) mepo,Proto.lookup p) + | "nb" -> (cut_list [] (map_len pl) nb,Proto.lookup p) + | "all" -> (List.map fst axassoc,Proto.lookup p) + | _ -> failwith "unknown prediction strategy" + in + List.map mapper slow_seq +;; + +let make_pred predmethod predlen axassoc conj prover = + let len = List.length axassoc in + if len < 100 && predmethod = "" then make_fast_seq (List.map fst axassoc) else + let axsyms = List.map (fun (a,b) -> (a, Hh_symbols.get_symbols b)) axassoc in + let csyms = Hh_symbols.get_symbols conj in + if predmethod = "" then make_slow_seq len axsyms csyms axassoc else + let l = + if predlen = 1 then int_of_float (1.5 *. ((float_of_int len) ** 0.6)) else + if predlen = 2 then int_of_float (3.0 *. ((float_of_int len) ** 0.6)) + else int_of_float (5.0 *. ((float_of_int len) ** 0.6)) in + let a = match predmethod with + "knn8" -> Predict.knn_advice 8 axsyms csyms l + | "knn4" -> Predict.knn_advice 4 axsyms csyms l + | "knn2" -> Predict.knn_advice 2 axsyms csyms l + | "mepo" -> Predict.mepo_advice axsyms csyms l + | "nb" -> Predict.nb_advice axsyms csyms l + | "all" -> List.map fst axassoc + | _ -> failwith "unknown prediction strategy" + in + [(a, prover)] +;; + +(*let (time, file, predmethod, predlen, prover) = ("300", "/tmp/SEU824^3.p", "", 0, "e");;*) + +try + let (time, file, predmethod, predlen, prover) = match Array.to_list Sys.argv with + [ _; t; f] -> (t, f, "", 0, "e") + | _ :: t :: f :: pm :: len :: pr -> (t, f, pm, int_of_string len, String.concat " " pr) + | _ -> Printf.printf "Hol(y)Hammer version 20140613\nUsage: ./hh time_in_seconds thf_file_name [pred_method predlen prover]\n"; + failwith "Invalid executable arguments" + in + (try ignore (int_of_string time) with _ -> failwith "Time must be integer"); + let (cname, conj, axassoc) = Thf0hh1.read_file file in + let pl = make_pred predmethod predlen axassoc conj prover in + match try_predict_seq pl time axassoc cname conj with + None -> Printf.printf "SZS status Timeout\n" + | Some l -> Printf.printf "SZS status Theorem\nSZS core %s\n" (String.concat " " l) + (*if ret > 0 then Printf.printf "SZS status GaveUp\n" else*) +with + Failure x -> Format.printf "SZS status Error\n%s\n" x +| Sys_error x -> Format.printf "SZS status Error\nSys_error %s\n" x +| x -> Format.printf "SZS status Error\nUnhandled Exception\n"; flush stdout; raise x +;; + +List.iter (fun x -> try Unix.unlink x with _ -> ()) !Predict.unlink; + + +(*Hh_write.write_atp_proof "testo.p" + ([Bool.tRUTH; Bool.bOOL_CASES_AX], ["TRUTH"; "BOOL_CASES"]) + "conj" (Parser.parse_term "x = x") +;;*) diff --git a/src/holyhammer/hh/thf0hh1.ml b/src/holyhammer/hh/thf0hh1.ml new file mode 100644 index 0000000000..f2e4a0b0f5 --- /dev/null +++ b/src/holyhammer/hh/thf0hh1.ml @@ -0,0 +1,139 @@ +open Hh_parse;; + +let rec isNtType sf = function + | Id "$tType" -> Some sf + | Hh_parse.Comb (Hh_parse.Comb (Hh_parse.Id ">", Id "$tType"), x) -> isNtType (sf + 1) x + | Id "$t" -> Some sf + | Hh_parse.Comb (Hh_parse.Comb (Hh_parse.Id ">", Id "$t"), x) -> isNtType (sf + 1) x + | _ -> if sf = 0 then None else failwith "isNtType" +;; + +let process (tys, cs, axs, conj) = function + (_, "type", Comb (Comb (Id ":", Id x), y)) -> + (match isNtType 0 y with + Some n -> ((x, n) :: tys, cs, axs, conj) + | None -> (tys, (x, y) :: cs, axs, conj) + ) + | (x, "ty", y) -> + (match isNtType 0 y with + Some n -> ((x, n) :: tys, cs, axs, conj) + | None -> (tys, (x, y) :: cs, axs, conj) + ) + | (x, "axiom", y) -> (tys, cs, (x, y) :: axs, conj) + | (x, "ax", y) -> (tys, cs, (x, y) :: axs, conj) + | (x, "hypothesis", y) -> (tys, cs, (x, y) :: axs, conj) + | (x, "definition", y) -> (tys, cs, (x, y) :: axs, conj) + | (x, "conjecture", y) -> (tys, cs, axs, (x, y) :: conj) + | (_, x, _) -> failwith ("process: " ^ x) +;; + +let rec strip_comb acc = function + | Comb (x, y) -> strip_comb (y :: acc) x + | t -> (t, acc) +;; + +let rec ptype tvl = function + Comb (Id "!", Abs (n, Id "$tType", tm)) -> ptype (n :: tvl) tm + | Comb (Id "!", Abs (n, Id "$t", tm)) -> ptype (n :: tvl) tm + | Comb (Comb (Id ">", x), y) -> Fusion.mk_type ("fun", [ptype tvl x; ptype tvl y]) + | Id "$o" -> Fusion.mk_type ("bool", []) + | Id x -> (try Fusion.mk_vartype (Printf.sprintf "%03i" (List.length tvl - Lib.index x tvl)) with _ -> Fusion.mk_type (x, [])) + | (Comb _ as ty) -> + (match strip_comb [] ty with + (Id x, tyl) -> Fusion.mk_type (x, List.map (ptype tvl) tyl) + | _ -> failwith "ptype1") + | _ -> failwith "ptype2" +;; + +let pnot = Hl_parser.parse_term "~";; +let pt = Hl_parser.parse_term "T";; +let pf = Hl_parser.parse_term "F";; + +let rec pterm env tvl = function + Abs (n, ty, tm) -> + let ty = ptype tvl ty in Fusion.mk_abs (Fusion.mk_var (n, ty), pterm ((n, ty) :: env) tvl tm) + | Comb (Id "!", Abs (n, Id "$tType", tm)) -> pterm env (n :: tvl) tm + | Comb (Id "!", Abs (n, ty, tm)) -> + let ty = ptype tvl ty in Bool.mk_forall (Fusion.mk_var (n, ty), pterm ((n, ty) :: env) tvl tm) + | Comb (Id "?", Abs (n, ty, tm)) -> + let ty = ptype tvl ty in Bool.mk_exists (Fusion.mk_var (n, ty), pterm ((n, ty) :: env) tvl tm) + | Comb (Id "~", x) -> Fusion.mk_comb (pnot, pterm env tvl x) + | Comb (Comb (Id "=", x), y) -> Fusion.mk_eq (pterm env tvl x, pterm env tvl y) + | Comb (Comb (Id "=>", x), y) -> Bool.mk_imp (pterm env tvl x, pterm env tvl y) + | Comb (Comb (Id "&", x), y) -> Bool.mk_conj (pterm env tvl x, pterm env tvl y) + | Comb (Comb (Id "|", x), y) -> Basics.mk_binary "\\/" (pterm env tvl x, pterm env tvl y) + | (Comb _ as t) -> pterm_comb env tvl t + | Id "$true" -> pt + | Id "$false" -> pf + | Id x -> + try let ty = List.assoc x env in Fusion.mk_var (x, ty) + with Not_found -> try Fusion.mk_const (x, []) with _ -> failwith ("pterm: mk_const: " ^ x) +and pterm_comb env tvl t = + match strip_comb [] t with + (Id s, rl) -> + begin try let ty = List.assoc s env in Basics.list_mk_comb (Fusion.mk_var (s,ty),List.map (pterm env tvl) rl) + with Not_found -> + let tyv = Lib.setify (Fusion.tyvars (Fusion.get_const_type s)) in + let tya, tma = Lib.chop_list (List.length tyv) rl in + let tya = List.map (ptype tvl) tya + and tma = List.map (pterm env tvl) tma in + let c = Fusion.mk_const (s, List.combine tya tyv) in + Basics.list_mk_comb (c, tma) + end + | (l, rl) -> Basics.list_mk_comb (pterm env tvl l,List.map (pterm env tvl) rl) +let rxp = Str.regexp "'";; +let apos = Str.global_replace rxp "\\'";; + +let rxpfile = Str.regexp "axiom.*,file[(][']";; +let rxpu = Str.regexp "u_";; +let rxpo = Str.regexp "o_";; +let rxpi = Str.regexp "i_";; +let unrxp s = Str.global_replace rxpo "." (Str.global_replace rxpi "'" (Str.global_replace rxpu "_" s));; + +let get_deps fname = + let ic = open_in fname in + let sf = ref [] in + (try while true do + let l = input_line ic in + try ignore (Str.search_forward rxpfile l 0); + let q1 = String.index l '\'' in + let q2 = String.index_from l (q1 + 1) '\'' in + sf := unrxp (String.sub l (q2 + 4) (String.length l - q2 - 7)) :: !sf + with Not_found -> () + done with End_of_file -> ()); + !sf +;; + +let run_prover time fname prover = + let cmd = match prover with + "v" -> "vampire --mode casc -t " ^ time ^ " --proof tptp --output_axiom_names on " ^ fname + | "z" -> "z3 -tptp DISPLAY_UNSAT_CORE=true -T:" ^ time ^ " " ^ fname + | "e" -> "eproof -s --tstp-format --cpu-limit=" ^ time ^ " " ^ fname + | "E" -> "runepar.pl " ^ time ^ " 0 " ^ fname ^ " 2 1" + | x -> "eproof -s --tstp-format --cpu-limit=" ^ time ^ " " ^ ((*apos*) x) ^ " " ^ fname + in + let fnameo = fname ^ "o" in + let cmd = cmd ^ " > " ^ fnameo ^ " 2> /dev/null" in +(* print_endline cmd;*) +(* Predict.unlink := fnameo :: !Predict.unlink;*) + ignore (Sys.command cmd); + if Sys.command ("grep -q 'SZS status Theorem' " ^ fnameo) = 0 then Some (get_deps fnameo) else None +(* if Sys.command ("grep -q 'SZS status Timeout' " ^ fnameo) = 0 then -1 else 1*) +;; + +let hh1_type_constants = ("$i", 0) :: !Fusion.the_type_constants;; +let hh1_term_constants = Fusion.constants ();; + +let read_file file = + let h2 = Read.read_prf [file] in + let (tys, cs, axs, conj) = Hashtbl.fold (fun (_, a) (b, c) sf -> process sf (a, b, c)) h2 ([],[],[],[]) in + Fusion.the_type_constants := hh1_type_constants @ tys; + let cs = List.map (fun (a, b) -> (a, ptype [] b)) cs in + Fusion.set_term_constants (hh1_term_constants @ cs); + let axassoc = List.map (fun (a,b) -> (a, pterm [] [] b)) axs in + let (cnames, conjs) = List.split conj in + let cname = String.concat "" cnames in + let conj = if conjs = [] then pt else Bool.list_mk_conj (List.map (pterm [] []) conjs) in + (cname, conj, axassoc) +;; + diff --git a/src/holyhammer/hh/thf1hh1.ml b/src/holyhammer/hh/thf1hh1.ml new file mode 100644 index 0000000000..e201b4fba1 --- /dev/null +++ b/src/holyhammer/hh/thf1hh1.ml @@ -0,0 +1,135 @@ +open Hh_parse +(* Global references *) +let const_tyvarl = ref [];; +let init_type = ("$i", 0) :: !Fusion.the_type_constants;; +Fusion.new_constant ("$equals",List.assoc "=" (Fusion.constants ()));; +let init_const = Fusion.constants();; +let (term_hash : (string,Fusion.term) Hashtbl.t ref) = ref (Hashtbl.create 20000) +let term_of n = Hashtbl.find (!term_hash) n + +(* HH tools *) +let rec hh_to_string hhterm = match hhterm with + Abs (a,x,y) -> "Abs " ^ a ^ ":" ^ hh_to_string x ^ "," ^ hh_to_string y + | Comb (x,y) -> "(" ^ hh_to_string x ^ " " ^ hh_to_string y ^ ")" + | Id a -> a + +let rec strip_comb acc = function + | Comb (x, y) -> strip_comb (y :: acc) x + | t -> (t, acc) + +let rec isNtType sf = function + Id "$t" -> Some sf + | Comb (Comb (Id ">", Id "$t"), x) -> isNtType (sf + 1) x + | _ -> if sf = 0 then None else failwith "isNtType" + +let hash_of_alist l = + let hash = Hashtbl.create 20000 in + List.iter (fun (a,b) -> Hashtbl.add hash a b) l; + hash + +let alist_of_hash hash = + Hashtbl.fold (fun k v l -> (k,v) :: l) hash [] + +(* Parse type *) +let quantl = ref [];; +let rec ptypea tvl hht = match hht with + Comb (Id "!", Abs (n,Id "$t", tm)) -> + quantl := (Fusion.mk_vartype n) :: (!quantl); ptypea (n :: tvl) tm + | Comb (Comb (Id ">", x), y) -> Fusion.mk_type ("fun", [ptypea tvl x; ptypea tvl y]) + | Id "$o" -> Fusion.bool_ty + | Id x -> if List.mem x tvl then Fusion.mk_vartype x else Fusion.mk_type (x, []) + | Comb _ as t -> begin + match strip_comb [] t with + (Id x,tyl) -> Fusion.mk_type (x, List.map (ptypea tvl) tyl) + | _ -> failwith ("ptypea: " ^ hh_to_string hht) + end + | _ -> failwith ("ptypea: " ^ hh_to_string hht) + +let ptypeb tvl t = quantl := []; let res = ptypea tvl t in (List.rev !quantl,res) +let ptype tvl t = snd (ptypeb tvl t) + + +let pnot = Hl_parser.parse_term "~" +let pt = Hl_parser.parse_term "T" +let pf = Hl_parser.parse_term "F" + +let rec pterm tvl vl t = match t with + | Abs (n, ty, tm) -> + let ty = ptype tvl ty in Fusion.mk_abs (Fusion.mk_var (n, ty), pterm tvl ((n, ty) :: vl) tm) + | Comb (Id "!", Abs (n, ty, tm)) -> + if ty = Id "$t" then pterm (n :: tvl) vl tm else + let ty = ptype tvl ty in Bool.mk_forall (Fusion.mk_var (n, ty), pterm tvl ((n, ty) :: vl) tm) + | Comb (Id "?", Abs (n, ty, tm)) -> + let ty = ptype tvl ty in Bool.mk_exists (Fusion.mk_var (n, ty), pterm tvl ((n, ty) :: vl) tm) + | Comb (Id "~", x) -> Fusion.mk_comb (pnot, pterm tvl vl x) + | Comb (Comb (Id "=", x), y) -> Fusion.mk_eq (pterm tvl vl x, pterm tvl vl y) + | Comb (Comb (Id "=>", x), y) -> Bool.mk_imp (pterm tvl vl x, pterm tvl vl y) + | Comb (Comb (Id "&", x), y) -> Bool.mk_conj (pterm tvl vl x, pterm tvl vl y) + | Comb (Comb (Id "|", x), y) -> Basics.mk_binary "\\/" (pterm tvl vl x, pterm tvl vl y) + | (Comb _ as t) -> pterm_comb tvl vl t + | Id "$true" -> pt + | Id "$false" -> pf + | Id x -> try let ty = List.assoc x vl in Fusion.mk_var (x, ty) with Not_found -> Fusion.mk_const (x, []) + | _ -> pterm_comb tvl vl t +and pterm_comb tvl vl t = match strip_comb [] t with + (Id x, rl) -> begin + try let ty = List.assoc x vl in + Basics.list_mk_comb (Fusion.mk_var (x,ty), List.map (pterm tvl vl) rl) + with Not_found -> + let itvl = try List.assoc x !const_tyvarl with _ -> failwith ("undeclared constant: " ^ x) in + let (tyl,tml) = Lib.chop_list (List.length itvl) rl in + let tyl = List.map (ptype tvl) tyl in + let tml = List.map (pterm tvl vl) tml in + let c = Fusion.mk_const (x,List.combine tyl itvl) in + Basics.list_mk_comb (c,tml) + end + | (lt, rl) -> Basics.list_mk_comb (pterm tvl vl lt,List.map (pterm tvl vl) rl) + +let pterm t = try pterm [] [] t + with | Failure s -> failwith ("pterm: " ^ s ^ " in: " ^ hh_to_string t) + | _ -> failwith ("pterm: " ^ hh_to_string t) + + +(* Parse and initialize types and constants *) +let rm_used_id l1 l2 = + List.filter (fun (id,_) -> not (List.mem id (List.map fst l2))) l1 + +let parse_type (ty_name,ty) = match isNtType 0 ty with + | None -> failwith ("parse_type: " ^ ty_name ^ ": " ^ hh_to_string ty) + | Some n -> (ty_name,n) + +let parse_init_tyc (tyl,cl) = + let tys = List.map parse_type tyl in + let lty = init_type @ rm_used_id tys init_type in + Fusion.the_type_constants := lty; + print_string ("- types: " ^ string_of_int (List.length lty) ^ " \n"); + let cs0 = List.map (fun (a, b) -> (a, ptypeb [] b)) cl in + let cs1 = List.map (fun (a,(b,c)) -> (a,c)) cs0 in + let cs2 = List.map (fun (a,(b,c)) -> (a,b)) cs0 in + let lc = init_const @ rm_used_id cs1 init_const in + Fusion.set_term_constants lc; + print_string ("- constants: " ^ string_of_int (List.length lc) ^ " \n"); + const_tyvarl := ("$equals",[Fusion.aty]) :: cs2 +;; + +let parse_axdef thml = + let f (s,t) = (s,pterm t) in List.map f thml + +(* Main function *) +let parse (tyl,cl,thml) = + print_string ("Parsing objects \n"); + parse_init_tyc (tyl,cl); + let thml = parse_axdef thml in + let tmh = hash_of_alist thml in + print_string ("- theorems: "^ string_of_int (List.length thml) ^ "\n\n"); + (term_hash := tmh) +;; + + + + + + + + + diff --git a/src/holyhammer/hh/write.ml b/src/holyhammer/hh/write.ml new file mode 100644 index 0000000000..aaae67b4a0 --- /dev/null +++ b/src/holyhammer/hh/write.ml @@ -0,0 +1,25 @@ +(*--------------------------------------------------------------------------- *) +(* Write problems to fof from the axioms' name and the conjecture name *) +(* The hash term_hash used by term_of needs to be initialized beforehand by *) +(* Thf1hh1.parse or init_dep_env or init_acc_env *) +(*--------------------------------------------------------------------------- *) + +open Hh_parse +open Thf1hh1 +open Dependency + +(* Required theorems for the ATPs. *) +let additional_theorems () = + let falsity = Fusion.Sequent([],Hl_parser.parse_term "~F") in + let ext = Fusion.Sequent([],Hl_parser.parse_term "!f g. (!x. f x = g x) ==> f = g") in + [Bool.tRUTH; falsity; Bool.bOOL_CASES_AX; ext], + ["HL_TRUTH"; "HL_FALSITY"; "HL_BOOL_CASES"; "HL_EXT"] + +(* Make a theorem without premises (?) from a theorem name. *) +let mk_thm (thm_name : string) = Fusion.Sequent ([], term_of thm_name) + +(* Write a FOF file from given conjecture and axioms for use with an ATP. *) +let write_fof file_name (cj_name, axioms) = + let (ath, a) = additional_theorems () in + let (pth, p) = (ath @ List.map mk_thm axioms, a @ axioms) in + Hh_write.write_atp_proof file_name (pth,p) cj_name (term_of cj_name) diff --git a/src/holyhammer/hhReconstruct.sig b/src/holyhammer/hhReconstruct.sig new file mode 100644 index 0000000000..7e70635266 --- /dev/null +++ b/src/holyhammer/hhReconstruct.sig @@ -0,0 +1,8 @@ +signature hhReconstruct = +sig + + val minimize_flag : bool ref + val reconstruct : thm list -> (string * string) -> term -> unit + val reconstructl : thm list -> (string * string) list -> term -> unit + +end diff --git a/src/holyhammer/hhReconstruct.sml b/src/holyhammer/hhReconstruct.sml new file mode 100644 index 0000000000..a5bec7eee9 --- /dev/null +++ b/src/holyhammer/hhReconstruct.sml @@ -0,0 +1,176 @@ +(* ===================================================================== *) +(* FILE : hhReconstruct.sml *) +(* DESCRIPTION : Reconstruct a proof from the lemmas given by an ATP *) +(* and minimize them. Can only be used after a call of *) +(* write_hh_thyl that initializes the dictionary *) +(* of theorems' names. *) +(* AUTHOR : (c) Thibault Gauthier, University of Innsbruck *) +(* DATE : 2015 *) +(* ===================================================================== *) + +structure hhReconstruct :> hhReconstruct = +struct + +open HolKernel boolLib Dep Tag hhWriter + +val ERR = mk_HOL_ERR "hhReconstruct" + +(*--------------------------------------------------------------------------- + Reading the ATP file. + ----------------------------------------------------------------------------*) + +fun readl path = + let + val file = TextIO.openIn path + fun loop file = case TextIO.inputLine file of + SOME line => line :: loop file + | NONE => [] + val l1 = loop file + fun rm_last_char s = String.substring (s,0,String.size s - 1) + fun is_empty s = s = "" + val l2 = map rm_last_char l1 (* removing end line *) + val l3 = filter (not o is_empty) l2 + in + (TextIO.closeIn file; l3) + end + +fun read_status path = hd (readl path) handle _ => "Unknown" + +(*--------------------------------------------------------------------------- + Timed Metis + ----------------------------------------------------------------------------*) + +fun time_metis thml conjecture time = + let + val oldlimit = !mlibMetis.limit + val oldtracelevel = !mlibUseful.trace_level + val thm = + ( + metisTools.limit := {time = SOME time, infs = NONE}; + mlibUseful.trace_level := 0; + metisTools.METIS_PROVE thml conjecture + ) + in + (metisTools.limit := oldlimit; mlibUseful.trace_level := oldtracelevel; thm) + end + +(*--------------------------------------------------------------------------- + Minimization. Can be turned off by minimize_flag if it takes too much time. + ----------------------------------------------------------------------------*) + +val minimize_flag = ref true + +fun minimize_loop l1 l2 cj = + if null l2 then l1 else + if can (time_metis (map snd (l1 @ tl l2)) cj) 2.0 + then minimize_loop l1 (tl l2) cj + else minimize_loop (hd l2 :: l1) (tl l2) cj + +fun minimize l cj = + ( + print "Minimization ...\n"; + if can (time_metis (map snd l) cj) 2.0 + then minimize_loop [] l cj + else l + ) + +(*--------------------------------------------------------------------------- + Reconstruction and printing (depends on DB.fetch) + ----------------------------------------------------------------------------*) + +exception Status of string + +val ppstrm_stdout = + PP.mk_ppstream {consumer = fn s => TextIO.output(TextIO.stdOut, s), + linewidth = 80, + flush = fn () => TextIO.flushOut TextIO.stdOut} + + +fun depid_of_thm thm = depid_of (dep_of (tag thm)) +fun has_depid (name,thm) = can depid_of_thm thm + +fun pp_lemmas ppstrm lemmas = + let + open Portable + val {add_string,add_break,begin_block, + end_block,add_newline,flush_ppstream,...} = + with_ppstream ppstrm + fun pp_l_aux g L = case L of + [] => () + | [a] => g a + | a :: m => (g a; add_string ","; add_break(1,0); pp_l_aux g m) + fun pp_l f l = + (begin_block INCONSISTENT 0; + add_string "["; + begin_block INCONSISTENT 0; + pp_l_aux f l; + end_block(); + add_string "]"; + end_block()) + fun pp_lemma (name,thm) = + let val (thy,_) = depid_of (dep_of (tag thm)) in + add_string (String.concatWith " " ["fetch", quote thy, quote name]) + end + in + begin_block INCONSISTENT 0; + add_string "val lemmas = "; + pp_l pp_lemma lemmas; + add_string ";"; + end_block(); + flush_ppstream() + end + +fun reprove thml axl cj = + let + (* reserved theorems are not required by Metis *) + val axl1 = filter (fn x => not (mem x reserved_names_escaped)) axl + val didl = map (fn x => Redblackmap.find (!readhh_names,x)) axl1 + val l1 = map (fn x => ("",x)) thml @ map thm_of_depid didl + val l2 = if !minimize_flag then minimize l1 cj else l1 + (* hacky way of removing user given theorems *) + val l3 = filter (fn (name,_) => name <> "") l2 + in + pp_lemmas ppstrm_stdout l3; + print "\n"; + ignore (time_metis (map snd l2) cj 30.0) + end + +fun reconstruct thml (atp_status,atp_out) conjecture = + let val s = read_status atp_status in + if s = "Theorem" + then reprove thml (readl atp_out) conjecture + else raise Status s + end + +fun reconstructl thml atpfilel conjecture = + let + fun process (atp_status,atp_out) = + let val s = read_status atp_status in + if s = "Theorem" then (s, readl atp_out) else (s, []) + end + val processedl = map process atpfilel + val proofl = filter (fn (x,_) => x = "Theorem") processedl + in + (* If no proof is found, *) + if null proofl + then + let + val status_list = map fst processedl + val s = if all (fn x => x = "Unknown") status_list + then "Unknown" + else hd (filter (fn x => x <> "Unknown") status_list) + in + raise Status s + end + (* else take the one that use the less lemmas. *) + else + let + fun compare_list l1 l2 = length l1 > length l2 + val axl = hd (sort compare_list (map snd proofl)) + in + reprove thml axl conjecture + end + end + + +end diff --git a/src/holyhammer/hhWriter.sig b/src/holyhammer/hhWriter.sig new file mode 100644 index 0000000000..16999e9b37 --- /dev/null +++ b/src/holyhammer/hhWriter.sig @@ -0,0 +1,14 @@ +signature hhWriter = +sig + + val thm_of_depid : Dep.depid -> (string * Thm.thm) + + val write_hh_thyl : string -> string list -> unit + val write_conjecture : string -> term -> unit + val write_thydep : string -> string list -> unit + + val writehh_names : (Dep.depid, string) Redblackmap.dict ref + val readhh_names : (string, Dep.depid) Redblackmap.dict ref + val reserved_names_escaped : string list + +end diff --git a/src/holyhammer/hhWriter.sml b/src/holyhammer/hhWriter.sml new file mode 100644 index 0000000000..8f69fffa66 --- /dev/null +++ b/src/holyhammer/hhWriter.sml @@ -0,0 +1,495 @@ +(* ===================================================================== *) +(* FILE : hhWriter.sml *) +(* DESCRIPTION : Print objects (constants, types and theorems) and *) +(* dependencies between conjuncts of theorems for *) +(* holyHammer. *) +(* AUTHOR : (c) Thibault Gauthier, University of Innsbruck *) +(* DATE : 2015 *) +(* ===================================================================== *) + + +structure hhWriter :> hhWriter = +struct + + +open HolKernel boolLib TextIO Tag Dep + +val ERR = mk_HOL_ERR "hhWriter" + +(*--------------------------------------------------------------------------- + Dictionaries + ----------------------------------------------------------------------------*) + +(* Shorter accessors and constructors *) +fun dfind k m = Redblackmap.find (m,k) +fun dmem k m = Lib.can (dfind k) m +fun dadd i v m = Redblackmap.insert (m,i,v) +val dempty = Redblackmap.mkDict + +val ty_names = ref (dempty KernelSig.name_compare) +val const_names = ref (dempty KernelSig.name_compare) +val var_names = ref (dempty Term.compare) +val tyvar_names = ref (dempty Type.compare) + +val writehh_names = ref (dempty depid_compare) (* symmetric dictionaries *) +val readhh_names = ref (dempty String.compare) + +(* Keeping track of which names are already used to prevent clashes. *) +val used_names = ref (dempty String.compare) + +(* reserved names *) +val hollight_theorems = ["HL_TRUTH", "HL_FALSITY", "HL_BOOL_CASES", "HL_EXT"]; +val conjecture_name = "conjecture" +val reserved_names = conjecture_name :: hollight_theorems +fun reserve name = used_names := dadd name 0 (!used_names) + +(* Initialisation *) + +fun reset_dicts () = +( + ty_names := dempty KernelSig.name_compare; + const_names := dempty KernelSig.name_compare; + var_names := dempty Term.compare; + tyvar_names := dempty Type.compare; + used_names := dempty String.compare; (* contains non escaped names *) + app reserve reserved_names; + writehh_names := dempty depid_compare; + readhh_names := dempty String.compare +) + +(*--------------------------------------------------------------------------- + Absolute limit on the size of theorems (to be included in the incremental + export) + ----------------------------------------------------------------------------*) +val size_limit = 200 +fun size_of_term t = + if is_abs t + then let val (v,t') = dest_abs t in 1 + size_of_term t' end + else if is_comb t + then let val (t1,t2) = dest_comb t in size_of_term t1 + size_of_term t2 end + else if is_var t orelse is_const t + then 1 + else raise ERR "size_of_term" "" + +fun is_oversized_term t = size_of_term t > size_limit + +fun is_oversized_thm thm = + let + val thml = BODY_CONJUNCTS thm + val terml = map (concl o GEN_ALL o DISCH_ALL) thml + in + exists is_oversized_term terml + end + +(*--------------------------------------------------------------------------- + Save new objects in the dictionnaries. + ----------------------------------------------------------------------------*) +(* escaping *) +fun is_alphanumeric s = + let val l = String.explode s in + all (fn x => Char.isAlphaNum x orelse x = #"_") l + end + +(* now additonnally escape quotes *) +fun escape_slash s = + let + val l1 = String.explode s + fun image x = + case x of + #"#" => String.explode "#hash#" + | #"/" => String.explode "#slash#" + | #"\"" => String.explode "#quote#" + | _ => [x] + val l2 = map image l1 + in + String.implode (List.concat l2) + end + +fun escape_prime s = + let + val l1 = String.explode s + val l2 = map (fn x => if x = #"'" then [#"\\",#"'"] else [x]) l1 + in + String.implode (List.concat l2) + end + +fun tptp_escape name = + if is_alphanumeric name + then name + else "'" ^ escape_prime name ^ "'" + +(* use a similar escaping than the holyhammer fof writer *) +fun fof_escape name = + if is_alphanumeric name andalso Char.isLower (hd (String.explode name)) + then name + else "'" ^ escape_prime name ^ "'" + +val reserved_names_escaped = map fof_escape reserved_names + +(* nice printing *) +fun nice_dest_vartype v = + let + val s = dest_vartype v + val l = String.explode s + in + if hd l = #"'" then String.implode (map Char.toUpper (tl l)) else s + end + +(* renaming *) +(* only used for variables *) +fun variant_name_dict s used = + let + val i = dfind s used + fun new_name s i = + let val si = s ^ Int.toString i in + if dmem si used + then new_name s (i + 1) + else (tptp_escape si, dadd s (i + 1) (dadd si 0 used)) + end + in + new_name s i + end + handle NotFound => (tptp_escape s, dadd s 0 used) + +fun store_name name = + if dmem name (!used_names) + then () + else used_names := dadd name 0 (!used_names) + +fun store_name name = + if dmem name (!used_names) + then () + else used_names := dadd name 0 (!used_names) + +(* types *) +fun declare_perm_type dict {Thy,Name} = + let + val name1 = "type/" ^ Thy ^ "/" ^ (escape_slash Name) + val name2 = tptp_escape name1 + in + store_name name1; + dict := dadd {Thy=Thy,Name=Name} name2 (!dict); + name2 + end + +(* constants *) +fun declare_perm_const dict {Thy,Name} = + let + val name1 = "const/" ^ Thy ^ "/" ^ (escape_slash Name) + val name2 = tptp_escape name1 + in + store_name name1; + dict := dadd {Thy=Thy,Name=Name} name2 (!dict); + name2 + end + +(* theorems *) +fun declare_perm_thm (thy,n) name = + let + val name1 = "thm/" ^ thy ^ "/" ^ (escape_slash name) + val name2 = tptp_escape name1 + in + store_name name1; + writehh_names := dadd (thy,n) name2 (!writehh_names); + readhh_names := dadd name2 (thy,n) (!readhh_names); + name2 + end + +(* special constants *) +fun declare_fixed dict {Thy,Name} name = + ( + store_name name; + dict := dadd {Thy=Thy,Name=Name} name (!dict); + name + ) + +(* temporary variables and type variables *) +fun declare_temp_list get_name dict l = + let + val olddict = !dict + val oldused = !used_names + fun fold_fun (s,sl) = + let val (news, newused) = + variant_name_dict (get_name s) (!used_names) + in + (dict := dadd s news (!dict); + used_names := newused; + news :: sl) + end + val sl = foldl fold_fun [] l + in + (List.rev sl, fn () => (dict := olddict; used_names := oldused)) + end + +(*--------------------------------------------------------------------------- + Streams. Objects and dependencies are written in different files. + ----------------------------------------------------------------------------*) + +val oc = ref stdOut +val oc_deps = ref stdOut +fun os s = output (!oc,s) +fun oiter_aux oc sep f = + fn [] => () + | [e] => f e + | h :: t => (f h; output (oc,sep); oiter_aux oc sep f t) +fun oiter_deps sep f l = oiter_aux (!oc_deps) sep f l +fun oiter sep f l = oiter_aux (!oc) sep f l + +(*--------------------------------------------------------------------------- + Printing objects (types, constants, theorems' conjuncts). + ----------------------------------------------------------------------------*) + +(* type *) +fun oty ty = + if is_vartype ty then os (dfind ty (!tyvar_names) + handle _ => raise ERR "dfind" "type") + else + let val {Args,Thy,Tyop} = dest_thy_type ty in + let val s = dfind {Thy=Thy,Name=Tyop} (!ty_names) in + if null Args then os s else + if (Thy ="min" andalso Tyop = "fun") + then (os "("; oty (hd Args); os " > "; oty (hd (tl Args)); os ")") + else (os ("(" ^ s ^ " "); oiter " " oty Args; os ")") + end end + +val less_ty = fn a => (fn b => Type.compare (a,b) = LESS) +fun less_red a b = less_ty (#redex a) (#redex b) + +fun id_subst a = {redex = a, residue = a} +fun full_match_type t1 t2 = + let + val (subst1,al) = raw_match_type t1 t2 ([],[]) + val subst2 = map id_subst al + in + sort less_red (subst1 @ subst2) + end + +(* term *) +fun otm tm = + if is_var tm then os (dfind tm (!var_names) + handle _ => raise ERR "dfind" "var") + else if is_const tm then + let val {Thy, Name, Ty} = dest_thy_const tm in + let val mgty = type_of (prim_mk_const {Thy = Thy, Name = Name}) in + let val subst = full_match_type mgty Ty in + let val resl = map #residue subst in + if null resl then os (dfind {Thy=Thy,Name=Name} (!const_names)) + else (os "("; os (dfind {Thy=Thy,Name=Name} (!const_names)); os " "; + oiter " " oty resl; os ")") + end end end end + else if is_eq tm then + (os "("; otm (lhs tm); os " = "; otm (rhs tm); os ")") + else if is_conj tm then + (os "("; otm (lhand tm); os " & "; otm (rand tm); os ")") + else if is_disj tm then + (os "("; otm (lhand tm); os " | "; otm (rand tm); os ")") + else if is_imp_only tm then + (os "("; otm (lhand tm); os " => "; otm (rand tm); os ")") + else if is_neg tm then (os "(~ "; otm (rand tm); os ")") + else if is_forall tm then hh_binder "!" (strip_forall tm) + else if is_exists tm then hh_binder "?" (strip_exists tm) + else if is_abs tm then hh_binder "^" (strip_abs tm) + else if is_comb tm then + let val (v,l) = strip_comb tm in + (os "("; otm v; app (fn x => (os " "; otm x)) l; os ")") + end + else raise ERR "otm" "" +and hh_binder s (l,tm) = + let val (vl,undeclare) = declare_temp_list (fst o dest_var) var_names l in + os ("(" ^ s ^ "["); + oiter ", " + (fn x => (os (dfind x (!var_names) handle _ => raise ERR "dfind" "var"); + os " : "; oty (type_of x))) l; + os "]: "; otm tm; os ")"; + undeclare () + end + +(* type definition *) +fun hh_tydef thy (s,arity) = + case (thy,s) of + ("min","bool") => ignore (declare_fixed ty_names {Thy=thy,Name=s} "$o") + | ("min","fun") => ignore (declare_fixed ty_names {Thy=thy,Name=s} "$fun") + | _ => + let val news = declare_perm_type ty_names {Thy=thy,Name=s} in + ( + os "tt("; os news; os ", ty, "; + let fun tyd i = case i of + 0 => os "$t" + | n => (os "$t > "; tyd (n - 1)) + in + (tyd arity; os ").\n") + end + ) + end + +fun quant_tyvarl l = + if null l then () + else (os "!["; oiter ", " (fn x => (os x; os " : $t")) l; os "]: ") + +(* constant definition *) +fun hh_constdef thy (s,ty) = + let + val fix = declare_fixed const_names {Thy=thy,Name=s} + val news = case (thy,s) of + ("min","=") => fix "$equals" + | ("bool","!") => fix "$forall" + | ("bool","?") => fix "$exists" + | ("bool","/\\") => fix "$and" + | ("bool","\\/") => fix "$or" + | ("min","==>") => fix "$imply" + | ("bool","~") => fix "$not" + | ("bool","T") => fix "$true" + | ("bool","F") => fix "$false" + | _ => declare_perm_const const_names {Thy=thy,Name=s} + val tv = sort less_ty (type_vars ty) + val (newtvs, undeclare) = + declare_temp_list nice_dest_vartype tyvar_names tv + in + ( + os "tt("; os news; os ", ty, "; + case newtvs of [] => () | l => quant_tyvarl l; + oty ty; os ").\n"; undeclare () + ) + end + +(* theorems *) +fun othm (name,role,tm) = + let + fun f x = is_var x orelse is_const x + val l1 = type_varsl (map type_of (find_terms f tm)) + val (l2,undeclare) = declare_temp_list nice_dest_vartype tyvar_names l1 + in + ( + os "tt("; os name; + os (", " ^ role ^ ", "); quant_tyvarl l2; otm tm; os ").\n"; + undeclare () + ) + end + +fun othm_theorem (name,role,thm) = + othm (name,role,concl (GEN_ALL (DISCH_ALL thm))) + +(* conjecture *) +fun othm_conjecture conjecture = + othm (conjecture_name, conjecture_name, + list_mk_forall (free_vars_lr conjecture,conjecture)) + + +(*--------------------------------------------------------------------------- + Printing dependencies. + ----------------------------------------------------------------------------*) + +fun thm_of_depid (thy,n) = + let + val thml = DB.thms thy + fun find_number x = + if (depnumber_of o depid_of o dep_of o tag o snd) x = n + then x + else raise ERR "find_number" "" + in + tryfind find_number thml + handle _ => raise ERR "thm_of_depid" "Not found" + end + +fun exists_depid did = can thm_of_depid did + +fun odep (name,dl) = + let + fun os_deps s = output (!oc_deps,s) + fun name_did did = dfind did (!writehh_names) + in + os_deps (name ^ " "); + oiter_deps " " os_deps (mapfilter name_did dl); + os_deps "\n" + end + +(*--------------------------------------------------------------------------- + Exporting a theorem and its dependencies + ----------------------------------------------------------------------------*) + +fun export_thm ((name,thm),role) = + let + val d = (dep_of o tag) thm + val did = depid_of d + val dl = filter exists_depid (depidl_of d) + val name' = declare_perm_thm did name + in + othm_theorem (name',role,thm); + odep (name',dl) + end + +(*--------------------------------------------------------------------------- + Printing theories + ----------------------------------------------------------------------------*) + +fun hh_thy_start folder thy = + ( + oc := openOut (folder ^ "/" ^ thy ^ ".p"); + oc_deps := openOut (folder ^ "/" ^ thy ^ ".hd") + ) + +fun hh_thy_end () = + ( + closeOut (!oc); oc := stdOut; + closeOut (!oc_deps); oc_deps := stdOut + ) + +fun write_hh_thy folder thy = + ( + hh_thy_start folder thy; + let val l = dest_theory thy in + case l of THEORY(_,t) => + ( + app (hh_tydef thy) (#types t); + app (hh_constdef thy) (#consts t); + let + val axl = map (fn x => (x,"ax")) (DB.theorems thy) + val defl = map (fn x => (x,"def")) (DB.axioms thy @ DB.definitions thy) + fun compare ((_,th1),_) ((_,th2),_) = + let val f = depnumber_of o depid_of o dep_of o Thm.tag in + f th1 < f th2 + end + (* val thml = filter (fn ((_,x),_) => not (is_oversized_thm x)) *) + val thml = sort compare (axl @ defl) + in + app export_thm thml + end + ) + end; + hh_thy_end () + ) + +fun sort_thyl thyl = case thyl of + [] => [] + | thy :: m => + let val (l1,l2) = partition (fn a => mem a (ancestry thy)) m in + (sort_thyl l1) @ [thy] @ (sort_thyl l2) + end + +fun write_thydep file thyl = + ( + oc := openOut file; + app (fn x => (os x; os " "; oiter " " os (parents x); os "\n")) thyl; + closeOut (!oc); oc := stdOut + ) + +fun write_hh_thyl folder thyl = + (reset_dicts(); + app (write_hh_thy folder) (sort_thyl thyl)) + + +fun write_conjecture file conjecture = + (* if is_oversized_term conjecture + then raise ERR "write_conjecture" "too large conjecture" + else *) + if type_of conjecture = bool + then + ( + oc := openOut file; + othm_conjecture conjecture; + closeOut (!oc); oc := stdOut + ) + else raise ERR "write_conjecture" "conjecture is not a boolean" + + +end diff --git a/src/holyhammer/holyHammer.sig b/src/holyhammer/holyHammer.sig new file mode 100644 index 0000000000..26acbfd9a1 --- /dev/null +++ b/src/holyhammer/holyHammer.sig @@ -0,0 +1,19 @@ +signature holyHammer = +sig + + datatype PREDICTOR = KNN | Mepo | NBayes | Geo + datatype ATP = Eprover | Vampire | Z3 + + val hh : Thm.thm list -> Term.term -> unit + val hh_atp : ATP -> Thm.thm list -> Term.term -> unit + val hh_goal : Thm.thm list -> Term.term list * Term.term -> unit + + val set_minimization : bool -> unit + val set_timeout : int -> unit + val set_predictors : PREDICTOR -> unit + val reset_hh : unit -> unit + val set_prediction : ATP -> int -> unit + val set_predictor : ATP -> PREDICTOR -> unit + val atp_settings : ATP -> (PREDICTOR * int * int) + +end diff --git a/src/holyhammer/holyHammer.sml b/src/holyhammer/holyHammer.sml new file mode 100644 index 0000000000..62a2974d83 --- /dev/null +++ b/src/holyhammer/holyHammer.sml @@ -0,0 +1,190 @@ +(* ===================================================================== *) +(* FILE : holyHammer.sml *) +(* DESCRIPTION : Export types, constants, theorems and dependencies to *) +(* the holyHammer framework which performs premise *) +(* selection and calls to external provers. The lemmas *) +(* found by the provers help Metis to reconstruct the *) +(* proof. *) +(* AUTHOR : (c) Thibault Gauthier, University of Innsbruck *) +(* DATE : 2015 *) +(* ===================================================================== *) + + +structure holyHammer :> holyHammer = +struct + +open hhWriter hhReconstruct + +val ERR = mk_HOL_ERR "holyHammer" + +(*--------------------------------------------------------------------------- + Settings + ----------------------------------------------------------------------------*) + +datatype PREDICTOR = KNN | Mepo | NBayes | Geo +datatype ATP = Eprover | Vampire | Z3 + +fun name_of_atp atp = case atp of + Eprover => "eprover" + | Vampire => "vampire" + | Z3 => "z3" + +fun name_of_predictor predictor = case predictor of + KNN => "knn" + | Mepo => "mepo" + | NBayes => "nbayes" + | Geo => "geo" + +val eprover_settings = ref (KNN,128,5) +val vampire_settings = ref (KNN,96,5) +val z3_settings = ref (KNN,32,5) + +fun change_time settings t = + let val (p,n,_) = !settings in settings := (p,n,t) end + +fun change_pred settings p = + let val (_,n,t) = !settings in settings := (p,n,t) end + +fun change_nbpred settings n = + let val (p,_,t) = !settings in settings := (p,n,t) end + +fun atp_settings atp = case atp of + Eprover => !eprover_settings + | Vampire => !vampire_settings + | Z3 => !z3_settings + +fun set_minimization b = minimize_flag := b + +fun set_timeout time = + ( + change_time eprover_settings time; + change_time vampire_settings time; + change_time z3_settings time + ) + +fun set_predictors pred = + ( + change_pred eprover_settings pred; + change_pred vampire_settings pred; + change_pred z3_settings pred + ) + +fun reset_hh () = + ( + eprover_settings := (KNN,128,5); + vampire_settings := (KNN,96,5); + z3_settings := (KNN,32,5) + ) + +fun set_prediction atp n = case atp of + Eprover => change_nbpred eprover_settings n + | Vampire => change_nbpred vampire_settings n + | Z3 => change_nbpred z3_settings n + +fun set_predictor atp pred = case atp of + Eprover => change_pred eprover_settings pred + | Vampire => change_pred vampire_settings pred + | Z3 => change_pred z3_settings pred + +(*--------------------------------------------------------------------------- + Directories + ----------------------------------------------------------------------------*) + +val hh_dir = HOLDIR ^ "/src/holyhammer" +val scripts_dir = hh_dir ^ "/scripts" +val thy_dir = hh_dir ^ "/theories" + +fun dir_of_prover atp = + let val atp_name = name_of_atp atp in + hh_dir ^ "/provers/" ^ atp_name ^ "/" ^ atp_name ^ "_files" + end + +fun out_of_prover atp = + let val atp_name = name_of_atp atp in + dir_of_prover atp ^ "/" ^ atp_name ^ "_out" + end + +fun status_of_prover atp = + let val atp_name = name_of_atp atp in + dir_of_prover atp ^ "/" ^ atp_name ^ "_status" + end + +fun hh_of_prover atp = "hh_" ^ name_of_atp atp ^ ".sh" + +(*--------------------------------------------------------------------------- + Export + ----------------------------------------------------------------------------*) + +fun export cj = + let + val ct = current_theory () + val thyl = ct :: Theory.ancestry ct + in + (* write loaded theories *) + write_hh_thyl thy_dir thyl; + (* write the conjecture in thf format *) + write_conjecture (thy_dir ^ "/conjecture") cj; + (* write the dependencies between theories *) + write_thydep (thy_dir ^ "/thydep") thyl + end + +(*--------------------------------------------------------------------------- + Main helpers + ----------------------------------------------------------------------------*) + +fun mk_argl () = + let + val (p1,n1,t1) = !eprover_settings + val (p2,n2,t2) = !vampire_settings + val (p3,n3,t3) = !z3_settings + val predictorl = List.map name_of_predictor [p1,p2,p3] + val nl = List.map int_to_string [n1,n2,n3] + val time = int_to_string t1 + in + String.concatWith " " (time :: (predictorl @ nl)) + end + +fun prepare_cj thml cj = + if null thml + then cj + else mk_imp (list_mk_conj (map (concl o GEN_ALL o DISCH_ALL) thml),cj) + +fun cmd_in_dir dir cmd = + OS.Process.system ("cd " ^ dir ^ "; " ^ cmd); + +(*--------------------------------------------------------------------------- + Main functions + ----------------------------------------------------------------------------*) + +(* Try every provers in parallel: eprover, vampire and z3. *) +fun hh thml cj = + let + val atpfilel = map (fn x => (status_of_prover x, out_of_prover x)) + [Eprover,Vampire,Z3] + val new_cj = prepare_cj thml cj + in + cmd_in_dir scripts_dir "sh hh_clean.sh"; + export new_cj; + cmd_in_dir scripts_dir ("sh hh.sh " ^ mk_argl()); + reconstructl thml atpfilel cj + end + +(* Let you chose the specific prover you want to use either + ("eprover", "vampire" or "z3") *) + +fun hh_atp atp thml cj = + let + val new_cj = prepare_cj thml cj + val (p,n,t) = atp_settings atp + val argl = name_of_predictor p ^ " " ^ int_to_string n ^ " " ^ + int_to_string t + in + cmd_in_dir scripts_dir "sh hh_clean.sh"; + export new_cj; + cmd_in_dir scripts_dir ("sh " ^ hh_of_prover atp ^ " " ^ argl); + reconstruct thml (status_of_prover atp, out_of_prover atp) cj + end + +fun hh_goal thml (goal as (tml,tm)) = hh thml (list_mk_imp (tml,tm)) + +end diff --git a/src/holyhammer/predict/Holmakefile b/src/holyhammer/predict/Holmakefile new file mode 100644 index 0000000000..ecd604e191 --- /dev/null +++ b/src/holyhammer/predict/Holmakefile @@ -0,0 +1,7 @@ +all: predict + +predict: main.cpp predictor.cpp format.cpp knn.cpp nbayes.cpp rforest.cpp tfidf.cpp dtree.cpp + g++-4.8 -std=c++11 -g -Wall $< -o $@ + +clean: + rm -f predict diff --git a/src/holyhammer/predict/README b/src/holyhammer/predict/README new file mode 100644 index 0000000000..f46c718cd8 --- /dev/null +++ b/src/holyhammer/predict/README @@ -0,0 +1,10 @@ +The format of machine learning data is as follows: + +"seq" gives the order of all the named facts, one by line. +"eval" gives the facts to find predictions for (no definitions or basic tautologies), one per line. +"deps" gives the dependencies used in a proof. Only available for some (provable) facts. Each line is: + theorema: lemmab lemmab lemmac +"syms" gives the features present in each fact. If not present assumed empty. Each line is: + lemmad:"featurebla", "feature asd, asd", "a,d,eff " + +However we would like to change the "seq" in the long run to give an accessibility relation. diff --git a/src/holyhammer/predict/dtree.cpp b/src/holyhammer/predict/dtree.cpp new file mode 100644 index 0000000000..406608f68e --- /dev/null +++ b/src/holyhammer/predict/dtree.cpp @@ -0,0 +1,196 @@ +#ifndef DTREE_CPP +#define DTREE_CPP + +#include +#include + +typedef unordered_map LUMap; + +class DecisionTree { + public: + // trees which have (left) and which do not have (right) feature + DecisionTree *left = NULL, *right = NULL; + long feature = -1; + LVec labels; + LUMap features_freq; + long n_samples = 0; + + DecisionTree(LVec labels = LVec()) : labels(labels) {} + DecisionTree(DecisionTree *left, DecisionTree *right, long feature) + : left(left), right(right), feature(feature) {} + DecisionTree(string filename, const SLMap& th_no, const SLMap& sym_no); + + ~DecisionTree() { delete left; delete right; } + + bool is_leaf() const { return (left == NULL) || (right == NULL); } + long height() const { + if (is_leaf()) return 1; + else return 1 + max(left->height(), right->height()); + } + + void add_labels_recursively(LVec& result) const; + + void query(const LVec& features, LDMap& result, double weight) const; + void write_to_file(string filename, + const SVec& no_th, const SVec& no_sym) const; + + private: + string dot(string pos, const SVec& no_th, const SVec& no_sym) const; + + const double punish_weight = 0.05; + const double min_weight = punish_weight*punish_weight; +}; + +void DecisionTree::add_labels_recursively(LVec& result) const { + if (is_leaf()) + result.insert(result.end(), labels.begin(), labels.end()); + else { + left ->add_labels_recursively(result); + right->add_labels_recursively(result); + } +} + +void DecisionTree::query(const LVec& features, LDMap& result, double weight = 1.0) + const { + if (weight < min_weight) + return; + + if (is_leaf()) + for (const auto& l : labels) + result[l] += weight; + else { + double lweight = weight, + rweight = weight; + + LVec::const_iterator fitr = find(features.begin(), features.end(), feature); + if (fitr == features.end()) + lweight *= punish_weight; + else + rweight *= punish_weight; + + left->query(features, result, lweight); + right->query(features, result, rweight); + } +} + +DecisionTree::DecisionTree(string filename, + const SLMap& th_no, const SLMap& sym_no) : DecisionTree() { + + ifstream f(filename); + + if (f.is_open()) { + string line; + + while (getline(f, line)) { + if (line.find("->") != string::npos || + line == "digraph tree {" || + line == " node [shape=box]" || + line == "}") + continue; + else { + DecisionTree *pos = this; + bool is_feature = true; + + auto p = find_if_not(line.begin(), line.end(), + [](char c) { return c == ' '; } ); + if (p == line.end() || *p != 't') + exit_error("Tree position expected!"); + p++; + + while (p != line.end()) { + if (*p == ' ') + break; + + switch (*p) { + case 'l': + if (pos->left == NULL) pos->left = new DecisionTree; + pos = pos->left; + break; + case 'r': + if (pos->right == NULL) pos->right = new DecisionTree; + pos = pos->right; + break; + default: + if (isdigit(*p)) + is_feature = false; + else + exit_error("Unknown character in tree position found."); + } + + p++; + } + if (*p != ' ') + exit_error("Content expected after tree position."); + + auto opening_quote = find(p + 1, line.end(), '"'); + if (opening_quote == line.end()) + exit_error("Opening quote not found."); + auto closing_quote = find(opening_quote + 1, line.end(), '"'); + if (closing_quote == line.end()) + exit_error("Closing quote not found."); + + string name_str(opening_quote + 1, closing_quote); + + if (is_feature) { + auto sym = sym_no.find(name_str); + if (sym == sym_no.end()) + exit_error("Could not find feature `" + name_str + "'"); + else + pos->feature = sym->second; + } + else { + auto th = th_no.find(name_str); + if (th == th_no.end()) + exit_error("Could not find label `" + name_str + "'"); + else + pos->labels.push_back(th->second); + } + } + } + f.close(); + } + else + exit_error("Could not read file `" + filename + "'."); +} + +void DecisionTree::write_to_file(string filename, + const SVec& no_th, const SVec& no_sym) const { + string s = + "digraph tree {\n" + " node [shape=box]\n" + + dot("t", no_th, no_sym) + + "}\n"; + + ofstream f(filename); + if (f.is_open()) { + f << s; + f.close(); + } + else + cerr << "Could not write file `" << filename << "'.\n"; +} + +string DecisionTree::dot(string pos, + const SVec& no_th, const SVec& no_sym) const { + string s; + + if (is_leaf()) { + for (unsigned i = 0; i < labels.size(); i++) { + string new_pos = pos + to_string(i); + s += " " + pos + " -> " + new_pos + "\n"; + s += " " + new_pos + " [label = \"" + no_th[labels[i]] + + "\" shape = ellipse]\n"; + } + } + else { + s += " " + pos + " [label = \"" + no_sym[feature] + "\"]\n"; + s += " " + pos + " -> " + pos + "l\n"; + s += " " + pos + " -> " + pos + "r\n"; + s += left->dot(pos + "l", no_th, no_sym); + s += right->dot(pos + "r", no_th, no_sym); + } + + return s; +} + +#endif diff --git a/src/holyhammer/predict/format.cpp b/src/holyhammer/predict/format.cpp new file mode 100644 index 0000000000..a82dde4e0e --- /dev/null +++ b/src/holyhammer/predict/format.cpp @@ -0,0 +1,166 @@ +#ifndef FORMAT_CPP +#define FORMAT_CPP + +#include +#include +#include +#include +#include +#include + +using namespace std; + +typedef unordered_map SLMap; +typedef vector SVec; +typedef vector LVec; +typedef vector > LVecVec; +typedef vector > LDPairVec; +typedef unordered_map LDMap; + +void exit_error(string message) { + cerr << message << endl; + exit(1); +} + +/* Given a file name, fills the given empty [th_no], [no_th], and sets th_num */ +void read_order(const string &fname, SLMap &th_no, SVec &no_th) { + ifstream ic(fname); + string line; + while (getline (ic, line)) { + if (th_no.find (line) == th_no.end ()) { + th_no[line] = no_th.size(); + no_th.push_back(line); + } + else + exit_error("Duplicate `" + line + + "' detected upon reading file `" + fname + "."); + } +} + +/* Given a file name and trans, fills deps in an allocated vector of empty vectors */ +void read_deps(const string &fname, SLMap &th_no, LVecVec &deps) { + ifstream ic(fname); + string line; + while (getline (ic, line)) { + const long colon_pos = line.find(":", 0); + const string thn = line.substr (0, colon_pos); + if (th_no.find (thn) == th_no.end ()) + cerr << "dep item missing in seq: " << thn << endl; + else { + long th = th_no[thn]; + size_t start = colon_pos + 1, end = 0; + const string delim = " "; + if (line.size() > start) + while (end != string::npos) { + end = line.find(delim, start); + auto t = line.substr(start, (end == string::npos) ? string::npos : end - start); + start = ((end > (string::npos - delim.size())) ? string::npos : end + delim.size()); + if (th_no.find (t) == th_no.end ()) + cerr << "dependency missing in seq: " << t << endl; + else { + long d=th_no[t]; + if (d < th) deps[th].push_back(d); + else cerr << "future dep (ignored): " << thn << "(" << th << ") " << t << "(" << d << ")" << endl; + } + } + } + } +} + +// parses strings of the format: +// "string1", "string2", ..., "stringn" +SVec parse_string_list(string::iterator begin, string::iterator end) { + SVec result; + + while (true) { + if (begin == end || *begin != '"') + exit_error("Feature start with double quote expected!"); + + const auto closing_quote = find(begin + 1, end, '"'); + if (closing_quote == end) + exit_error("Features stop with double quote expected!"); + + result.push_back(string(begin + 1, closing_quote)); + + const auto comma = closing_quote + 1; + if (comma == end) + break; + else { + const auto space = comma + 1; + if (space == end) + exit_error("Space expected after comma!"); + else if (*comma != ',' || *space != ' ') + exit_error("Comma and space expected after feature!"); + + begin = space + 1; + } + } + + return result; +} + +// parses strings of the format: +// thmid:"feature1", "feature2", ..., "featuren" +void read_syms(const string &fname, LVecVec &syms, LVecVec &sym_ths, + long &sym_num, const SLMap &th_no, + SLMap &sym_no, SVec& no_sym) { + ifstream ic(fname); + string line; + while (getline(ic, line)) { + const auto colon = find(line.begin(), line.end(), ':'); + if (colon == line.end()) + exit_error("Expected colon in line `" + line + "'!"); + + string th_str(line.begin(), colon); + auto th_got = th_no.find(th_str); + if (th_got == th_no.end()) + exit_error("Theorem `" + th_str + "' not found!"); + long th = th_got->second; + + SVec features = parse_string_list(colon + 1, line.end()); + for (const auto& f : features) { + auto ftr_got = sym_no.find(f); + if (ftr_got == sym_no.end()) { + syms[th].push_back(sym_num); + sym_ths.push_back(vector(1,th)); + + // register new feature + sym_no[f] = sym_num++; + no_sym.push_back(f); + } + else { + syms[th].push_back(ftr_got->second); + sym_ths[ftr_got->second].push_back(th); + } + } + } +} + +LVec parse_feature_list(string::iterator begin, string::iterator end, + const SLMap& ftr_no) { + LVec result; + for (const auto& f : parse_string_list(begin, end)) { + auto got = ftr_no.find(f); + if (got != ftr_no.end()) + result.push_back(got->second); + } + + return result; +} + +void read_eval(const string &fname, unordered_map &th_no, + unordered_set &eval) { + ifstream ic(fname); + string line; + while (getline(ic, line)) { + auto get = th_no.find (line); + if (get == th_no.end()) + exit_error("Could not find theorem `" + line + + "' in file `" + fname + "'."); + else + eval.insert(get->second); + } +} + +#endif + diff --git a/src/holyhammer/predict/knn.cpp b/src/holyhammer/predict/knn.cpp new file mode 100644 index 0000000000..b8c18a4f3f --- /dev/null +++ b/src/holyhammer/predict/knn.cpp @@ -0,0 +1,93 @@ +#include +#include "predictor.cpp" + +class kNN : public Predictor { + public: + kNN(LVecVec deps, LVecVec syms, LVecVec sym_ths, long sym_num); + + void learn(long from, long to); + + protected: + LDPairVec predict(const LVec& csyms, long maxth, long no_adv) const; + + private: + Tfidf tfidf; +}; + +kNN::kNN(LVecVec deps, LVecVec syms, LVecVec sym_ths, long sym_num) +: Predictor(deps, syms, sym_ths, sym_num), tfidf(sym_num) { +} + +void kNN::learn(long from, long to) { + for (unsigned i = from; i < to; ++i) + tfidf.add(syms[i]); +} + +inline double age(long k) { + return 500000000 - 100 * k; +} + +LDPairVec kNN::predict(const LVec& csyms, long maxth, long no_adv) const { + LDPairVec ans = LDPairVec(maxth, make_pair(0, 0)); + + // initialise theorem importance matrix + for (long i = 0; i < maxth; ++i) { + ans[i].first=i; ans[i].second=0; + } + + // for each symbol, increase the importance of the theorems which contain + // the symbol by a given symbol weight + for (const auto& sym : csyms) { + vector ths = sym_ths[sym]; + double weight = tfidf.get(sym); + for (const auto& th : ths) { + if (th < maxth) ans[th].second += pow(weight, 6); + } + } + + LDPairVec neighbours(maxth); + partial_sort_copy(ans.begin(), ans.begin() + maxth, neighbours.begin(), neighbours.end(), sortfun); + for (long i = 0; i < maxth; ++i) ans[i].second=0; + + + // In typical k-NN implementation the number 'k' is fixed. Unfortunately for + // premise selection, using a wrong number may have quite bad implications, + // namely the neighbours may all be very similar and have very similiar dependencies. + // This may mean that we will not have enough non-zero entries to fill no-adv predictions. + // This is why we use an adaptive 'k'. We count how many premises we recommended, + // and we continue until this number is enough. + // Since we want to sort the list of recommended answers only once, we want to make + // sure that items recommended by a certain 'k' are before those coming for the increased + // k. In order to do this, we use an "age" that is added to non-zero predictions + // and decreases when k increases. + + long no_recommends = 0; + for (long k = 0; k < maxth && no_recommends < no_adv; ++k) { + long nn = neighbours[k].first; + double o = neighbours[k].second; // distance, we do not use sqrt + if (ans[nn].second <= 0) { + no_recommends++; + ans[nn].second = age(k) + o; + } + else + ans[nn].second += o; + + // dependencies of the neighbor also gain some relevance, depending on the + // number of dependencies of the current theorem + LVec ds = deps[nn]; + double ol = 2.7 * o / ds.size(); + for (const auto& d : ds) { + if (d < maxth) { // in case of future dependencies, do not predict them + if (ans[d].second <= 0) { + no_recommends++; + ans[d].second = age(k) + ol; + } + else + ans[d].second += ol; + } + } + } + + sort_prediction(ans, no_adv); + return ans; +} diff --git a/src/holyhammer/predict/main.cpp b/src/holyhammer/predict/main.cpp new file mode 100644 index 0000000000..ded0c79b33 --- /dev/null +++ b/src/holyhammer/predict/main.cpp @@ -0,0 +1,210 @@ +#include +#include + +#include "knn.cpp" +#include "nbayes.cpp" +#include "rforest.cpp" + +const string usage_str = + "Usage: predict [OPTION]...\n" + "\n" + "Mandatory arguments:\n" + " is a file containing the symbols of theorems\n" + " is a file containing the dependencies of theorems\n" + " is a file containing the order of theorems\n" + "\n" + "General options:\n" + " -p method is either knn, nbayes, or rforest\n" + " -n i is the number of predictions to output\n" + " -e eval is an optional file, containing theorems for which we want predictions\n" + " -x eXport learned predictor data to path\n" + " -y Ymport learned predictor data from path\n" + "\n" + "Predictor-specific options:\n" + " Random Forest:\n" + " -t number of trees to build\n" + " -s number of samples to consider per tree\n" + " -f number of features to consider per tree\n" + " -w dependency weight\n"; + + +void print_prediction(LDPairVec prediction, long n_predictions, + vector no_th) { + for (long j = 0; j < n_predictions; ++j) { + // print label + cout << no_th[prediction[j].first] << " "; + // print weight + //cout << "(" << prediction[j].second << ") "; + } + cout << endl; +} + +void interaction(unique_ptr& p, long predno, + const SLMap& sym_no, const vector& no_th) { + p->learn_all(); + cerr << "Learning done; awaiting your features ..." << endl; + + string line; + while (getline(cin, line)) { + const LVec symsi = parse_feature_list(line.begin(), line.end(), sym_no); + long no_adv = min((long)no_th.size(), predno); + const LDPairVec ans = p->predict(symsi, no_th.size(), no_adv); + print_prediction(ans, no_adv, no_th); + } +} + +void evaluation(unique_ptr& p, string evalf, long predno, + SLMap th_no, vector no_th) { + unordered_set eval; + read_eval(evalf, th_no, eval); + + // last theorem up to which we learnt + long prev = 0; + + for (long i = 0; i < (long)no_th.size(); ++i) { + if (eval.find(i) != eval.end()) { + p->learn(prev, i); + prev = i; + + long no_adv = min(i, predno); + LDPairVec ans = p->predict(i, i, no_adv); + + cout << no_th[i] << ":"; + print_prediction(ans, no_adv, no_th); + } + } +} + +int atoi_check(const char *nptr, const char *desc) { + int result = atoi(nptr); + if (result == 0) { + cerr << "Error: You have to specify a valid " << desc << "!\n"; + exit(EXIT_FAILURE); + } + else + return result; +} + +double atof_check(const char *nptr, const char *desc) { + double result = atof(nptr); + if (result == 0.0) { + cerr << "Error: You have to specify a valid " << desc << "!\n"; + exit(EXIT_FAILURE); + } + else + return result; +} + +int main(int argc, char* argv[]) { + const int MIN_ARGS = 3; + if (argc < MIN_ARGS + 1) { + cerr << usage_str; + return EXIT_FAILURE; + } + + // obligatory files + string symsf(argv[1]), depsf(argv[2]), seqf(argv[3]); + + // evaluation file + string evalf = ""; + // number of predictions to output + long predno = 1000; + // prediction method + string method = "knn"; + // path to prelearned predictor data + string import_path, export_path; + + // Random Forest specific options + long n_trees = 512; + long n_samples = 512; + long n_features = 128; + double depweight = 1.7; + + char c; + optind = MIN_ARGS; // start getopt after obligatory arguments + while ((c = getopt (argc, argv, "he:n:p:k:t:s:f:w:x:y:")) != -1) + switch (c) { + case 'h': + cout << usage_str; + return EXIT_SUCCESS; + case 'e': + evalf = optarg; + break; + case 'n': + predno = atoi_check(optarg, "number of predictions"); + break; + case 'p': + method = optarg; + break; + case 'x': + export_path = optarg; + break; + case 'y': + import_path = optarg; + break; + case 't': + n_trees = atoi_check(optarg, "number of trees"); + break; + case 's': + n_samples = atoi_check(optarg, "number of samples per tree"); + break; + case 'f': + n_features = atoi_check(optarg, "number of features per tree"); + break; + case 'w': + depweight = atof_check(optarg, "dependency weight"); + break; + case '?': + // unknown option or option lacking an argument + // getopt prints an error message (unless opterr is set to 0) + cerr << "Try '" << argv[0] << " -h' for more information.\n"; + return EXIT_FAILURE; + } + + long sym_num = 0; + SLMap th_no, // maps a theorem to its numeric identifier + sym_no; // maps a symbol to its numeric identifier + vector no_th, // theorem name table + no_sym; + LVecVec deps, // dependencies of each theorem + syms, // syms[t] holds the symbols of a theorem t + sym_ths; // sym_ths[s] holds the theorems which contain s + + read_order(seqf, th_no, no_th); + + deps = LVecVec(no_th.size(), vector(0)); + syms = LVecVec(no_th.size(), vector(0)); + + read_deps(depsf, th_no, deps); + read_syms(symsf, syms, sym_ths, sym_num, th_no, sym_no, no_sym); + + // getting number of a theorem + //cout << th_no["Set.subsetI"] << endl; + + // initialise predictor + unique_ptr predictor; + if (method == "knn") + predictor.reset(new kNN(deps, syms, sym_ths, sym_num)); + else if (method == "nbayes") + predictor.reset(new NaiveBayes(deps, syms, sym_ths, sym_num)); + else if (method == "rforest") + predictor.reset(new RandomForest(deps, syms, sym_ths, sym_num, + n_trees, n_samples, n_features, depweight)); + else { + cerr << "Error: You have to specify a valid predictor!\n"; + return EXIT_FAILURE; + } + + predictor->set_tables(no_th, no_sym, th_no, sym_no); + if (!import_path.empty()) + predictor->import_data(import_path); + + // if user did not supply evaluation file + if (evalf == "") + interaction(predictor, predno, sym_no, no_th); + else + evaluation(predictor, evalf, predno, th_no, no_th); + + if (!export_path.empty()) + predictor->export_data(export_path); +} diff --git a/src/holyhammer/predict/mepo/Holmakefile b/src/holyhammer/predict/mepo/Holmakefile new file mode 100644 index 0000000000..8e8924a4e3 --- /dev/null +++ b/src/holyhammer/predict/mepo/Holmakefile @@ -0,0 +1,10 @@ +all: geo mepo3 + +mepo3: + g++ -std=c++0x mepo3.cpp -o mepo3 + +geo: + g++ -std=c++0x geo.cpp -o geo + +clean: + rm -f mepo3 geo diff --git a/src/holyhammer/predict/mepo/format.cpp b/src/holyhammer/predict/mepo/format.cpp new file mode 100644 index 0000000000..95230f70c4 --- /dev/null +++ b/src/holyhammer/predict/mepo/format.cpp @@ -0,0 +1,153 @@ +#include +#include +#include +#include +#include +#include +#include + +using namespace std; + +/* Given a file name, fills the given empty [th_no], [no_th], and sets th_num */ +void read_order(const string &fname, unordered_map &th_no, + vector &no_th) { + ifstream ic(fname); + string line; + while (getline (ic, line)) { + if (th_no.find (line) == th_no.end ()) { + th_no[line] = no_th.size(); + no_th.push_back(line); + } else { + cerr << "read_order: dup: " << line; abort (); + } + } +} + +/* Given a file name and trans, fills deps in an allocated vector of empty vectors */ +void read_deps(const string &fname, unordered_map &th_no, vector > &deps) { + ifstream ic(fname); + string line; + while (getline (ic, line)) { + const long colon_pos = line.find(":", 0); + const string thn = line.substr (0, colon_pos); + long th = th_no[thn]; + size_t start = colon_pos + 1, end = 0; + const string delim = " "; + if (line.size() > start) + while (end != string::npos) { + end = line.find(delim, start); + auto t = line.substr(start, (end == string::npos) ? string::npos : end - start); + start = ((end > (string::npos - delim.size())) ? string::npos : end + delim.size()); + long d=th_no[t]; + /*if (d < th)*/ deps[th].push_back(d); + //else cerr << "future dep (ignored): " << thn << " " << t << endl; + } + } +} + +void read_syms(const string &fname, vector > &syms, vector > &sym_ths, + long &sym_num, const unordered_map &th_no, unordered_map &sym_no) { + ifstream ic(fname); + string line; + while (getline (ic, line)) { + const long colon_pos = line.find(":", 0); + string thn = line.substr (0, colon_pos); + auto got = th_no.find(thn); + if (got != th_no.end () && colon_pos + 2 < line.size()) { + if ((line.at(colon_pos+1) != '"') || (line.at(line.size () - 1) != '"')) + {cerr << "Incorrect symbols file: no quote!" << endl; abort ();} + long th = got->second; + size_t start = colon_pos + 2, end = 0; + const string delim = "\", \""; + while (end != string::npos) { + end = line.find(delim, start); + auto t = line.substr(start, (end == string::npos) ? line.size() - start - 1 : end - start); + auto got = sym_no.find (t); + if (got == sym_no.end ()) { + syms[th].push_back(sym_num); + sym_no[t] = sym_num++; + sym_ths.push_back(vector(1,th)); + } else { + syms[th].push_back(got->second); + sym_ths[got->second].push_back(th); + } + start = (( end > (string::npos - delim.size()) ) + ? string::npos : end + delim.size()); + } + } + } +} + +vector input_sym_line(const unordered_map &sym_no){ + string line; + vector ret; + getline (cin, line); + if (line.size () >= 2) { + if ((line.at(0) != '"') || (line.at(line.size () - 1) != '"')) + {cerr << "Incorrect input: no quote!" << endl; abort ();} + size_t start = 1, end = 0; + const string delim = "\", \""; + while (end != string::npos) { + end = line.find(delim, start); + auto t = line.substr(start, (end == string::npos) ? line.size() - start - 1 : end - start); + auto got = sym_no.find (t); + if (got != sym_no.end ()) + ret.push_back(got->second); + start = (( end > (string::npos - delim.size()) ) + ? string::npos : end + delim.size()); + } + } + return ret; +} + +class Tfidf { +public: + Tfidf(const long &sym_num) : thn(0), thv(0), freq(vector(sym_num, 0)), a(vector(sym_num, 0)){}; + double get(long s) const {return thv - a[s];} + double get_sum() const { + double r = a.size() * thv; + for (long i = 0; i < a.size(); ++i) r -= a[i]; + return r; + } + void add(const vector &syms) { + for(long sym = 0; sym != syms.size(); ++sym) { + long symn = syms[sym]; + freq[symn]++; a[symn] = log(freq[symn]); + } + thv = log (++thn); + } + void add_many(const vector > &syms) { + for(long i = 0; i < syms.size(); ++i) + for(long j = 0; j < syms[i].size(); ++j) + freq[syms[i][j]] = freq[syms[i][j]] + 1; + for(long i = 0; i < a.size(); ++i) + a[i] = log(freq[i]); + thn += syms.size(); thv = log (thn); + } +private: + long thn; + double thv; + vector freq; + vector a; +}; + +inline bool sortfun (pair i,pair j) { + return (j.second < i.second); +} + +inline bool sortfunl (pair i,pair j) { + return (i.second < j.second); +} + +void read_eval(const string &fname, unordered_map &th_no, unordered_set &eval) { + ifstream ic(fname); + string line; + while (getline (ic, line)) { + auto get = th_no.find (line); + if (get == th_no.end ()) { + cerr << "read_eval: none: " << line; abort (); + } else { + eval.insert(get->second); + } + } +} diff --git a/src/holyhammer/predict/mepo/formatnow.cpp b/src/holyhammer/predict/mepo/formatnow.cpp new file mode 100644 index 0000000000..cb89a2b41d --- /dev/null +++ b/src/holyhammer/predict/mepo/formatnow.cpp @@ -0,0 +1,147 @@ +#include +#include +#include +#include +#include +#include +#include + +using namespace std; + +/* Given a file name, fills the given empty [th_no], [no_th], and sets th_num */ +void read_order(const string &fname, unordered_map &th_no, + vector &no_th) { + ifstream ic(fname); + string line; + while (getline (ic, line)) { + if (th_no.find (line) == th_no.end ()) { + th_no[line] = no_th.size(); + no_th.push_back(line); + } else { + cerr << "read_order: dup: " << line; abort (); + } + } +} + +/* Given a file name and trans, fills deps in an allocated vector of empty vectors */ +void read_deps(const string &fname, unordered_map &th_no, vector > &deps) { + ifstream ic(fname); + string line; + while (getline (ic, line)) { + const long colon_pos = line.find(":", 0); + const string thn = line.substr (0, colon_pos); + long th = th_no[thn]; + size_t start = colon_pos + 1, end = 0; + if (line.size() > start) + while (end != string::npos) { + end = line.find(" ", start); + auto t = line.substr(start, (end == string::npos) ? string::npos : end - start); + start = end + 1; + long d=th_no[t]; + //if (d < th) + deps[th].push_back(d); + //else cerr << "future dep (ignored): " << thn << " " << t << endl; + } + } +} + +void read_syms(const string &fname, vector > > &syms, vector > > &sym_ths, + long &sym_num, const unordered_map &th_no, unordered_map &sym_no) { + ifstream ic(fname); + string line; + while (getline (ic, line)) { + const long colon_pos = line.find(":", 0); + string thn = line.substr (0, colon_pos); + auto got = th_no.find(thn); + if (got != th_no.end ()) { + long th = got->second; + size_t start = colon_pos + 2, end = 0; + const string delim = "\", \""; + while (end != string::npos) { + end = line.find(delim, start); + auto t = line.substr(start, (end == string::npos) ? line.size() - start - 1 : end - start); + auto got = sym_no.find (t); + if (got == sym_no.end ()) { + syms[th].push_back(make_pair(sym_num,1)); + sym_no[t] = sym_num++; + sym_ths.push_back(vector >(1,make_pair(th,1))); + } else { + syms[th].push_back(make_pair(got->second,1)); + sym_ths[got->second].push_back(make_pair(th,1)); + } + start = (( end > (string::npos - delim.size()) ) + ? string::npos : end + delim.size()); + } + } + } +} + +vector > input_sym_line(const unordered_map &sym_no) { + string line; + vector > ret; + getline (cin, line); + size_t start = 1, end = 0; + const string delim = "\", \""; + while (end != string::npos) { + end = line.find(delim, start); + auto t = line.substr(start, (end == string::npos) ? line.size() - start - 1 : end - start); + auto got = sym_no.find (t); + if (got != sym_no.end ()) + ret.push_back(make_pair(got->second,1)); + start = (( end > (string::npos - delim.size()) ) + ? string::npos : end + delim.size()); + } + return ret; +} + +class Tfidf { +public: + Tfidf(const long &sym_num) : thn(0), thv(0), freq(vector(sym_num, 0)), a(vector(sym_num, 0)){}; + double get(long s) const {return thv - a[s];} + double get_sum() const { + double r = a.size() * thv; + for (long i = 0; i < a.size(); ++i) r -= a[i]; + return r; + } + void add(const vector > &syms) { + for(long sym = 0; sym != syms.size(); ++sym) { + long symn = syms[sym].first; + freq[symn]++; a[symn] = log(freq[symn]); + } + thv = log (++thn); + } + void add_many(const vector > > &syms) { + for(long i = 0; i < syms.size(); ++i) + for(long j = 0; j < syms[i].size(); ++j) + freq[syms[i][j].first] = freq[syms[i][j].first] + 1; + for(long i = 0; i < a.size(); ++i) + a[i] = log(freq[i]); + thn += syms.size(); thv = log (thn); + } +private: + long thn; + double thv; + vector freq; + vector a; +}; + +inline bool sortfun (pair i,pair j) { + return (j.second < i.second); +} + +inline bool sortfunl (pair i,pair j) { + return (i.second < j.second); +} + +void read_eval(const string &fname, unordered_map &th_no, unordered_set &eval) { + ifstream ic(fname); + string line; + while (getline (ic, line)) { + auto get = th_no.find (line); + if (get == th_no.end ()) { + cerr << "read_eval: none: " << line; abort (); + } else { + eval.insert(get->second); + } + } +} diff --git a/src/holyhammer/predict/mepo/geo.cpp b/src/holyhammer/predict/mepo/geo.cpp new file mode 100644 index 0000000000..2998872f38 --- /dev/null +++ b/src/holyhammer/predict/mepo/geo.cpp @@ -0,0 +1,81 @@ +#include +#include "format.cpp" + +void geo(const vector &syms, const vector > &sym_ths, + const vector > &deps, const long &maxth, + const long recurse, const double factor, const Tfidf &tfidf, + const long no_adv, vector > &ans){ + for(long i = 0; i < maxth; ++i) { + ans[i].first=i; ans[i].second=0; + } + for(long sym = 0; sym != syms.size(); ++sym) { + long symn = syms[sym]; + vector ths = sym_ths[symn]; + double wght = tfidf.get(symn); + for(auto th = ths.begin(); th != ths.end(); ++th) { + if (*th < maxth) ans[*th].second += wght * wght; + } + } + if (recurse) { + for(long i = maxth - 1; i >= 0; --i) { + double v = factor * ans[i].second; + if (v > 0) { + vector ds = deps[i]; + for(auto d = ds.begin(); d != ds.end(); ++d) + ans[*d].second = max(ans[*d].second, v); + } + } + } else { + for(int i = 0; i < maxth; ++i) { + double v = factor * ans[i].second; + if (v > 0) { + vector ds = deps[i]; + for(auto d = ds.begin(); d != ds.end(); ++d) + ans[*d].second = max(ans[*d].second, v); + } + } + } + partial_sort(ans.begin(), ans.begin() + no_adv, ans.begin() + maxth, sortfun); +} + +int main(int argc, char* argv[]) { + if (argc < 7 || argc > 8) { + cerr << "geo recurse factor syms deps pred-no seq [eval]"; return 0; + } + char *symsf=argv[3], *depsf=argv[4], *seqf=argv[6]; + long recurse=atoi(argv[1]), sym_num=0, predno=atoi(argv[5]); + double factor=atof(argv[2]); + unordered_map th_no; + vector no_th; + read_order(seqf, th_no, no_th);// cerr << "o"; + vector > deps(no_th.size(), vector(0)); + read_deps(depsf, th_no, deps);// cerr << "d"; + vector > syms(no_th.size(), vector(0)); + vector > sym_ths; + unordered_map sym_no; + read_syms(symsf, syms, sym_ths, sym_num, th_no, sym_no);// cerr << "s"; + Tfidf tfidf(sym_num);// cerr << "t"; + vector > ans(no_th.size(), make_pair(0, 0)); + if (argc == 8) { + unordered_set eval; + read_eval(argv[7], th_no, eval); // cerr << "e"; + for (long i = 0; i < no_th.size(); ++i) { + if (eval.find(i) != eval.end()) { + long no_adv = min(i, predno); + cout << no_th[i] << ":"; + geo(syms[i], sym_ths, deps, i, recurse, factor, tfidf, no_adv, ans); + for (long j = 0; j < no_adv; ++j) + cout << no_th[ans[j].first] /*<< "(" << ans[j].second << ")"*/ << " "; + cout << endl; + } + tfidf.add(syms[i]); + } + } else { + tfidf.add_many(syms); + auto syms = input_sym_line(sym_no); + geo(syms, sym_ths, deps, no_th.size(), recurse, factor, tfidf, predno, ans); + for (long j = 0; j < predno; ++j) + cout << no_th[ans[j].first] /*<< "(" << ans[j].second << ")"*/ << " "; + cout << endl; + } +} diff --git a/src/holyhammer/predict/mepo/mepo3.cpp b/src/holyhammer/predict/mepo/mepo3.cpp new file mode 100644 index 0000000000..be6838ad7a --- /dev/null +++ b/src/holyhammer/predict/mepo/mepo3.cpp @@ -0,0 +1,151 @@ +#include +#include "formatnow.cpp" + +double jaccard(const vector > &syms1, const vector > &syms2, + const Tfidf &tfidf){ + unordered_map sym1h; + double sig = 0, sig1 = 0, sig2 = 0; + for (auto s = syms1.begin(); s != syms1.end(); ++s) { + sym1h[s->first] = s->second; + const double tw = tfidf.get(s->first); + const double fw = s->second; + sig1 += tw * tw * fw * fw; + } + for (auto s = syms2.begin(); s != syms2.end(); ++s) { + const double tw = tfidf.get(s->first); + const double fw = s->second; + sig2 += tw * tw * fw * fw; + auto got = sym1h.find(s->first); + if (got != sym1h.end()) + sig += tw * tw * fw * got->second; + } + return (sig / (sig1 + sig2 + sig)); +} + +double cosine(const vector > &syms1, const vector > &syms2, + const Tfidf &tfidf){ + //cerr << syms1.size() << " " << syms2.size() << "\n"; + unordered_map sym1h; + double sig = 0, sig1 = 0, sig2 = 0; + for (auto s = syms1.begin(); s != syms1.end(); ++s) { + sym1h[s->first] = s->second; + const double tw = tfidf.get(s->first); + const double fw = s->second; + //cerr << "(" << s->first << "," << s->second << "," << fw << "," << tw << ")"; + sig1 += tw * tw * fw * fw; + } + for (auto s = syms2.begin(); s != syms2.end(); ++s) { + const double tw = tfidf.get(s->first); + const double fw = s->second; + //cerr << "[" << s->first << "," << s->second << "," << fw << "," << tw << "]"; + sig2 += tw * tw * fw * fw; + auto got = sym1h.find(s->first); + if (got != sym1h.end()) + sig += tw * tw * fw * got->second; + } + return (sig * sig / (sig1 * sig2)); +} + +double euclid(const vector > &syms1, const vector > &syms2, + const Tfidf &tfidf){ + unordered_map sym1h; + double sig = 0; + for (auto s = syms1.begin(); s != syms1.end(); ++s) + sym1h[s->first] = s->second; + for (auto s = syms2.begin(); s != syms2.end(); ++s) { + const double tw = tfidf.get(s->first); + const double fw = s->second; + auto got = sym1h.find(s->first); + if (got != sym1h.end()) { + const double diff = tw * (got->second - fw); + sig += diff * diff; + sym1h.erase(s->first); + } else + sig += tw * tw * fw * fw; + } + for (const auto s : sym1h) { + const double tw = tfidf.get(s.first); + const double fw = s.second; + sig += tw * tw * fw * fw; + } + return (1 / (1 + sig)); +} + +static int mepo_incr = 100; + +void mepo(const vector > &syms, const vector > > &sym_ths, + const vector > > &allsyms, const long &maxth, double threshold, + const Tfidf &tfidf, long more_adv, long sofar, vector > &ans){ + //cerr << "mepo: " << syms.size() << " " << sofar << "->" << more_adv << "\n"; + if (more_adv <= 0) return; + for(long i = sofar; i < maxth; ++i) + ans[i].second = cosine(syms, allsyms[ans[i].first], tfidf); + partial_sort(ans.begin() + sofar, ans.begin() + sofar + more_adv, ans.begin() + maxth, sortfun); + if (ans[0].second == 0.0) return; + long pos = mepo_incr; + unordered_map nsymsh; + for (auto s : syms) nsymsh[s.first] = s.second; + //cerr << "thr: " << threshold << " pos: " << pos << "\n"; + pos += sofar; + for (; sofar < pos && more_adv >= 0; sofar++) { + more_adv--; + const long aif = ans[sofar].first; + const vector > thesyms = allsyms[aif]; + for (auto sw : thesyms) + nsymsh[sw.first] = max(nsymsh[sw.first], sw.second * ans[sofar].second); + } + vector > nsyms; + for (auto s : nsymsh) + nsyms.push_back(s); + mepo(nsyms, sym_ths, allsyms, maxth, threshold, tfidf, more_adv, sofar, ans); +} + +int main(int argc, char* argv[]) { + if (argc < 6 || argc > 7) { + cerr << "mepo3j nei1 syms deps pred-no seq [eval]"; return 0; + } + char *symsf=argv[2], *depsf=argv[3], *seqf=argv[5]; + long mepo_incr=atoi(argv[1]), sym_num=0, predno=atoi(argv[4]); + unordered_map th_no; + vector no_th; + read_order(seqf, th_no, no_th);// cerr << "o"; + vector > deps(no_th.size(), vector(0)); + read_deps(depsf, th_no, deps);// cerr << "d"; + vector > > syms(no_th.size(), vector >(0)); + vector > > sym_ths; + unordered_map sym_no; + read_syms(symsf, syms, sym_ths, sym_num, th_no, sym_no);// cerr << "s"; + Tfidf tfidf(sym_num);// cerr << "t"; + vector > ans(no_th.size(), make_pair(0, 0)); + if (argc == 7) { + unordered_set eval; + read_eval(argv[6], th_no, eval); + for(long i = 0; i < no_th.size(); ++i) { + ans[i].first=i; ans[i].second=0; + } + for (long i = 0; i < no_th.size(); ++i) { + if (eval.find(i) != eval.end()) { + long no_adv = min(i, predno); + cout << no_th[i] << ":"; + mepo(syms[i], sym_ths, syms, i, 0.6, tfidf, no_adv, 0, ans); + for (long j = 0; j < no_adv; ++j) + cout << no_th[ans[j].first] /*<< "(" << j << "," << ans[j].second << ")"*/ << " "; + cout << endl; + } + tfidf.add(syms[i]); + } + } else { + tfidf.add_many(syms); + auto csyms = input_sym_line(sym_no); + //cerr << syms.size(); + + for(long i = 0; i < no_th.size(); ++i) { + ans[i].first=i; ans[i].second=0; + } + + mepo(csyms, sym_ths, syms, no_th.size(), 0.6, tfidf, predno, 0, ans); + for (long j = 0; j < predno; ++j) + cout << no_th[ans[j].first] /*<< "(" << ans[j].second << ")"*/ << " "; + cout << endl; + } +} diff --git a/src/holyhammer/predict/nbayes.cpp b/src/holyhammer/predict/nbayes.cpp new file mode 100644 index 0000000000..b91293bfb5 --- /dev/null +++ b/src/holyhammer/predict/nbayes.cpp @@ -0,0 +1,103 @@ +#include +#include +#include +#include "predictor.cpp" + +typedef long feature_t; +typedef long sample_t; + +class NaiveBayes : public Predictor { + public: + NaiveBayes(LVecVec deps, LVecVec syms, LVecVec sym_ths, long sym_num); + + void learn(long from, long to); + LDPairVec predict(const LVec& csyms, long maxth, long no_adv) const; + + private: + double score(sample_t i, set symsh) const; + + void learn(const LVec& csyms, sample_t i, const LVec& cdeps); + void add_sample_freqs(const LVec& csyms, sample_t i, long weight); + + // tfreq[t] = number of theorems having t as dependency + vector tfreq; + // sfreq[t][f] = number of theorems having f and having t as dependency + vector > sfreq; + + Tfidf tfidf; +}; + +NaiveBayes::NaiveBayes(LVecVec deps, LVecVec syms, LVecVec sym_ths, long sym_num) +: Predictor(deps, syms, sym_ths, sym_num), tfidf(sym_num) { + tfreq.resize(deps.size()); + sfreq.resize(deps.size(), unordered_map (100)); +} + +void NaiveBayes::learn(sample_t from, sample_t to) { + for (unsigned i = from; i < to; ++i) + tfidf.add(syms[i]); + + for (sample_t i = from; i < to; i++) + learn(syms[i], i, deps[i]); +} + +LDPairVec NaiveBayes::predict(const LVec &csyms, sample_t maxth, long no_adv) const { + LDPairVec ans = LDPairVec(maxth, make_pair(0, 0)); + + // set of query features + set symh(csyms.begin(), csyms.end()); + + for(long i = 0; i < maxth; ++i) { + ans[i].first = i; + ans[i].second = score(i, symh); + } + + sort_prediction(ans, no_adv); + return ans; +} + +double NaiveBayes::score(sample_t i, set symh) const { + // number of times current theorem was used as dependency + const long n = tfreq[i]; + const auto sfreqh = sfreq[i]; + + double s = 30 * log(n); + + /* + for (const auto sv : sfreqh) { + // sv.first ranges over all features of theorems depending on i + // sv.second is the number of times sv.first appears among theorems + // depending on i + double sfreqv = sv.second; + + // if sv.first exists in query features + if (symh.erase(sv.first) == 1) + s += tfidf.get(sv.first) * log (5 * sfreqv / n); + else + s += tfidf.get(sv.first) * 0.2 * log (1 + (1 - sfreqv) / n); + } + + // for all query features that did not appear in features of dependencies + // of current theorem + for (const auto f : symh) s -= tfidf.get(f) * 18; + */ + + return s; +} + +void add_sym(unordered_map &m, feature_t sym, long w) { + auto itr = m.find(sym); + if (itr == m.end()) m[sym] = w; + else (itr->second) += w; +} + +void NaiveBayes::add_sample_freqs(const LVec& csyms, sample_t i, long w) { + tfreq[i] += w; + for (const auto s : csyms) add_sym(sfreq[i], s, w); +} + +void NaiveBayes::learn(const LVec& csyms, sample_t i, const LVec& cdeps) { + add_sample_freqs(csyms, i, 1000); + for (const auto d : cdeps) add_sample_freqs(csyms, d, 1); +} + diff --git a/src/holyhammer/predict/predictor.cpp b/src/holyhammer/predict/predictor.cpp new file mode 100644 index 0000000000..76f6a848e8 --- /dev/null +++ b/src/holyhammer/predict/predictor.cpp @@ -0,0 +1,67 @@ +#ifndef PREDICTOR_CPP +#define PREDICTOR_CPP + +#include +#include "format.cpp" +#include "tfidf.cpp" + +class Predictor { + public: + Predictor(LVecVec deps, LVecVec syms, LVecVec sym_ths, long sym_num); + virtual ~Predictor() {} + + virtual void learn(long from, long to) = 0; // learn [from, ..., to) + void learn_all(); + + LDPairVec predict(long i, long maxth, long no_adv); + virtual LDPairVec predict(const LVec& csyms, long maxth, long no_adv) const = 0; + + void set_tables(SVec no_th, SVec no_sym, SLMap th_no, SLMap sym_no); + + virtual void import_data(string location) {} + virtual void export_data(string location) const {} + + protected: + LVecVec deps, // dependencies of each theorem + syms, // syms[t] holds the symbols of a theorem t + sym_ths; // sym_ths[s] holds the theorems which contain s + + SVec no_th, + no_sym; + SLMap th_no, + sym_no; + + private: + void print_answer(long no_adv); +}; + +Predictor::Predictor(LVecVec deps, LVecVec syms, LVecVec sym_ths, long sym_num) + : deps(deps), syms(syms), sym_ths(sym_ths) {} + +void Predictor::learn_all() { + learn(0, syms.size() - 1); +} + +LDPairVec Predictor::predict(long i, long maxth, long n_predictions) { + return predict(syms[i], maxth, n_predictions); +} + +void Predictor::set_tables(SVec no_th, SVec no_sym, SLMap th_no, SLMap sym_no) { + this->no_th = no_th; + this->no_sym = no_sym; + this->th_no = th_no; + this->sym_no = sym_no; +} + +inline bool sortfun (pair i, pair j) { + return (j.second < i.second); +} + +// sort the theorem-probability table such that the first n_predictions +// elements of it contain the best predictions +void sort_prediction(LDPairVec& prediction, long n_predictions) { + partial_sort(prediction.begin(), prediction.begin() + n_predictions, + prediction.end(), sortfun); +} + +#endif diff --git a/src/holyhammer/predict/rforest.cpp b/src/holyhammer/predict/rforest.cpp new file mode 100644 index 0000000000..87a3b39e5d --- /dev/null +++ b/src/holyhammer/predict/rforest.cpp @@ -0,0 +1,425 @@ +#ifndef RFOREST_CPP +#define RFOREST_CPP + +#include + +#include "dtree.cpp" +#include "predictor.cpp" +#include "tfidf.cpp" + +class RandomForest : public Predictor { + public: + RandomForest(LVecVec deps, LVecVec syms, LVecVec sym_ths, long sym_num, + long n_trees, long n_samples, long n_features, double depweight); + ~RandomForest(); + + void import_data(string dirname); + void export_data(string dirname) const; + + void learn(long from, long to); + LDPairVec predict(const LVec& csyms, long maxth, long no_adv) const; + + private: + long n_of_samples_with_label(const LVec& samples, long label) const; + long n_of_labels_in_samples(const LVec& samples) const; + pair labels_of_samples(const LVec& samples) const; + double gini_part(const LVec& samples) const; + double gini_index(const LVec& samples, long feature) const; + + LUMap features_frequency(const LVec& samples) const; + long feature_minlabels(const LVec& samples, long feature) const; + + long best_feature_gini(const LVec& samples, unsigned min_labels, + const LUMap& features_freq) const; + long best_feature_naive(const LVec& samples) const; + + void update_tree(DecisionTree *tree, const LVec& samples); + + DecisionTree* grow_tree(const LVec& samples); + DecisionTree* grow_tree(const LVec& samples, unsigned min_labels, + const LUMap& features_freq); + + vector forest; + long n_samples; // number of samples to consider per tree + long n_features; // number of features to consider per tree + double depweight; + + bool prelearned; + + Tfidf labels_ti; + + mt19937 rng; // random number generator, in this case Mersenne twister +}; + +// TODO: seed hard-coded ... +RandomForest::RandomForest(LVecVec deps, LVecVec syms, LVecVec sym_ths, + long sym_num, + long n_trees, long n_samples, long n_features, double depweight) +: Predictor(deps, syms, sym_ths, sym_num), forest(n_trees, NULL), + n_samples(n_samples), n_features(n_features), depweight(depweight), + prelearned(false), labels_ti(deps.size()), rng(42) { + + for (auto& tree : forest) + tree = new DecisionTree; +} + +RandomForest::~RandomForest() { + for (auto& tree : forest) + delete tree; +} + +void RandomForest::import_data(string dirname) { + for (unsigned i = 0; i < forest.size(); i++) + forest[i] = new DecisionTree(dirname + "/tree" + to_string(i) + ".dot", + th_no, sym_no); + prelearned = true; +} + +void RandomForest::export_data(string dirname) const { + for (unsigned i = 0; i < forest.size(); i++) + forest[i]->write_to_file(dirname + "/tree" + to_string(i) + ".dot", + no_th, no_sym); +} + +void RandomForest::learn(long from, long to) { + // update TF-IDF information for labels + for (unsigned i = from; i < to; i++) + labels_ti.add(deps[i]); + + if (prelearned) + return; + + // by how many trees will a sample be learnt + const long sampling_frequency = 1; + + // determine which tree should learn which samples + LVecVec tree_samples(forest.size()); + uniform_int_distribution<> tree_distr(0, forest.size() - 1); + for (long s = from; s < to; s++) + for (long n = 0; n < sampling_frequency; n++) + tree_samples[tree_distr(rng)].push_back(s); + + for (unsigned t = 0; t < forest.size(); t++) + update_tree(forest[t], tree_samples[t]); + + /* + // probability of sampling from the range [from, to), when we + // draw from [0, to) + double prob = (to - from) / double(to); + binomial_distribution bin_dist(n_samples, prob); + uniform_int_distribution uni_dist_old(0, from - 1); + uniform_int_distribution uni_dist_new(from, to - 1); + + for (auto& tree : forest) { + long n_new_samples = bin_dist(rng); + + // update tree if we need to consider new samples + if (n_new_samples > 0) { + LVec samples_old(n_samples - n_new_samples); + LVec samples_new(n_new_samples); + + for (auto& sample : samples_old) sample = uni_dist_old(rng); + for (auto& sample : samples_new) sample = uni_dist_new(rng); + + samples_new.insert(samples_new.end(), + samples_old.begin(), samples_old.end()); + + // regrow + delete tree; + tree = grow_tree(samples_new); + } + } + */ +} + +LDPairVec RandomForest::predict(const LVec& csyms, long maxth, long no_adv) + const { + LDPairVec ans = LDPairVec(maxth, make_pair(0, 0)); + for (long i = 0; i < maxth; ++i) { + ans[i].first = i; + ans[i].second = 0; + } + + LDMap labels; + + for (const auto& tree : forest) + tree->query(csyms, labels); + +/* + double tfidf_d = 1; + for (const auto& feature : positives) + // is a low TF-IDF better or worse? + // if low was better, we should probably divide here! + tfidf_d *= tfidf.get(feature); + long tfidf_l = tfidf_d * 1000.0; + //cout << tfidf_l << endl; +*/ + + for (const auto& label : labels) { + // this might be the case if we use a prelearned tree, and to prevent + // suggesting theorems "from the future", we discard them + if (label.first >= maxth) + continue; + + ans[label.first].second += label.second; // / pow(labels_ti.get(label), 1); + + const LVec& ds = deps[label.first]; + for (const auto& dep : ds) { + //cerr << dw / pow(labels_ti.get(dep), 3) << endl; + ans[dep].second += depweight * label.second; // / pow(labels_ti.get(dep), 4); + } + } + + sort_prediction(ans, no_adv); + return ans; +} + + +long RandomForest::n_of_samples_with_label(const LVec& samples, long label) + const { + long sum = 0; + for (const auto& sample : samples) { + const LVec& ds = deps[sample]; + if (sample == label || find(ds.begin(), ds.end(), label) != ds.end()) + sum++; + } + return sum; +} + +pair RandomForest::labels_of_samples(const LVec& samples) const { + LUMap labels; + long n_labels = 0; + for (const auto& sample : samples) { + labels[sample]++; + n_labels++; + for (const auto& dep : deps[sample]) { + labels[dep]++; + n_labels++; + } + } + return make_pair(labels, n_labels); +} + +double RandomForest::gini_part(const LVec& samples) const { + auto l = labels_of_samples(samples); + LUMap labels = l.first; + double n_labels = l.second; + + double sum = 0.0; + for (const auto& label : labels) { + double p = n_of_samples_with_label(samples, label.first) / n_labels; + sum += (p - p*p) * label.second; + } + return samples.size() * sum; +} + +double RandomForest::gini_index(const LVec& samples, long feature) const { + LVec yes, no; + for (const auto& sample : samples) { + const LVec& features = syms[sample]; + if (find(features.begin(), features.end(), feature) != features.end()) + yes.push_back(sample); + else + no.push_back(sample); + } + return gini_part(yes) + gini_part(no); +} + + +LUMap RandomForest::features_frequency(const LVec& samples) const { + LUMap features_freq; + for (const auto& sample : samples) + for (const auto& feature : syms[sample]) + features_freq[feature]++; + + return features_freq; +} + +long RandomForest::feature_minlabels(const LVec& samples, long feature) + const { + LVec left, right; + for (const auto& sample : samples) { + const LVec& csyms = syms[sample]; + if (find(csyms.begin(), csyms.end(), feature) != csyms.end()) + left.push_back(sample); + else + right.push_back(sample); + } + + return min(labels_of_samples(left ).second, + labels_of_samples(right).second); +} + + +template Container + sample_with_replacement(const Container& c, unsigned n, Generator& g) { + + // generate sorted vector of container indices + vector indices(n); + uniform_int_distribution<> distr(0, c.size() - 1); + for (auto& i : indices) i = distr(g); + sort(indices.begin(), indices.end()); + + Container result; + auto citr = c.cbegin(); + unsigned prev_i = 0; + for (const auto& i : indices) { + advance(citr, i - prev_i); + prev_i = i; + + copy_n(citr, 1, inserter(result, result.end())); + } + return result; +} + +long RandomForest::best_feature_gini(const LVec& samples, unsigned min_labels, + const LUMap& features_freq) const { + + long best_f = -1; + double best_gini = 0; + + // iterate through unique list of features + for (const auto& f : features_freq) { + // check if a feature even has a chance to provide a valid split + if (feature_minlabels(samples, f.first) >= min_labels) { + double gini = gini_index(samples, f.first); + if (gini < best_gini || best_f == -1) { + best_f = f.first; + best_gini = gini; + } + } + } + + return best_f; +} + +long RandomForest::best_feature_naive(const LVec& samples) const { + LUMap ff = features_frequency(samples); + long optimal_n_samples = samples.size() / 2; + + long best_f = -1; + long best_diff = 0; + + for (const auto& f : ff) { + long diff = abs(f.second - optimal_n_samples); + if (diff < best_diff || best_f == -1) { + best_f = f.first; + best_diff = diff; + } + } + + return best_f; +} + +void RandomForest::update_tree(DecisionTree *tree, const LVec& new_samples) { + if (new_samples.empty()) + return; + + for (const auto& sample : new_samples) + for (const auto& feature : syms[sample]) + tree->features_freq[feature]++; + + tree->n_samples += new_samples.size(); + + long optimal_n_samples = tree->n_samples / 2; + long best_f = -1; + long best_diff = 0; + + // we have to consider all features present in the tree at this point, + // because it might be that a feature that was previously bad, now has + // become a good splitting feature, even if it did not appear at all + // in the new samples + for (const auto& f : tree->features_freq) { + long diff = abs(f.second - optimal_n_samples); + if (diff < best_diff || best_f == -1) { + best_f = f.first; + best_diff = diff; + } + } + + LVec update_samples = new_samples; + + if (best_f != tree->feature) { + tree->add_labels_recursively(update_samples); + + delete tree->left; + delete tree->right; + + tree->left = new DecisionTree; + tree->right = new DecisionTree; + } + + const LVec& best = sym_ths[best_f]; + + LVec left, right; + + // divide samples into those which have the best feature and those who do not + for (const auto& sample : update_samples) + if (find(best.begin(), best.end(), sample) != best.end()) + left.push_back(sample); + else + right.push_back(sample); + + if (min(left .size() + tree->left ->n_samples, + right.size() + tree->right->n_samples) < 1) { + tree->labels = update_samples; + tree->feature = -1; + + delete tree->left; + delete tree->right; + + tree->left = NULL; + tree->right = NULL; + } + else { + tree->labels = LVec(); + tree->feature = best_f; + + update_tree(tree->left , left); + update_tree(tree->right, right); + } +} + +DecisionTree* RandomForest::grow_tree(const LVec& samples) { + LUMap ff = features_frequency(samples); + // remove too seldomly occuring features + /*for (auto fi = ff.begin(); fi != ff.end(); ) + if (fi->second <= 3) fi = ff.erase(fi); + else fi++;*/ + + LUMap fs = sample_with_replacement(ff, n_features, rng); + + return grow_tree(samples, 1/*2*log(labels_of_samples(samples).second)*/, fs); +} + +DecisionTree* RandomForest::grow_tree(const LVec& samples, + unsigned min_labels, const LUMap& features_freq) { + + long best_f = best_feature_naive(samples); + //long best_f = best_feature_gini(samples, min_labels, features_freq); + if (best_f == -1) + return new DecisionTree(samples); + + const LVec& best = sym_ths[best_f]; + + LVec left, right; + + // divide samples into those which have the best feature and those who do not + for (const auto& sample : samples) + if (find(best.begin(), best.end(), sample) != best.end()) + left.push_back(sample); + else + right.push_back(sample); + + // stop growing tree if one of its children would be too small + if (min(labels_of_samples(left ).second, + labels_of_samples(right).second) < min_labels) + return new DecisionTree(samples); + else { + DecisionTree *t_left = grow_tree(left , min_labels, features_freq); + DecisionTree *t_right = grow_tree(right, min_labels, features_freq); + return new DecisionTree(t_left, t_right, best_f); + } +} + +#endif diff --git a/src/holyhammer/predict/tfidf.cpp b/src/holyhammer/predict/tfidf.cpp new file mode 100644 index 0000000000..b70ec6b313 --- /dev/null +++ b/src/holyhammer/predict/tfidf.cpp @@ -0,0 +1,52 @@ +#ifndef TFIDF_CPP +#define TFIDF_CPP + +template +T sum_of_vector(const std::vector& v) { + return accumulate(v.begin(), v.end(), 0); +} + +// term frequency - inverse document frequency +class Tfidf { + public: + Tfidf(long sym_num) + : thn(0), thv(0), freq(vector (sym_num, 0)), + a(vector(sym_num, 0)) {}; + + double get(long s) const {return thv - a[s];} + + // Alternate version, slightly weaker than the above according to the + // PxTP 2013 paper evaluations. + //double get(long s) const {return (1.0 / (1.0 + a[s]));} + + double get_sum() const { return (a.size() * thv) - sum_of_vector(a); } + + void add(const LVec &syms) { + for (const auto& sym : syms) { + freq[sym]++; + a[sym] = log(freq[sym]); + } + + thv = log(++thn); + } + + void add_many(const LVecVec &syms) { + for (const auto& sx : syms) + for (const auto& sy : sx) + freq[sy]++; + + for (unsigned i = 0; i < a.size(); ++i) + a[i] = log(freq[i]); + + thn += syms.size(); + thv = log(thn); + } + + private: + long thn; // number of theories + double thv; // logarithmic number of theories + vector freq; // feature frequency + vector a; // logarithmic feature frequency +}; + +#endif diff --git a/src/holyhammer/provers/eprover.sh b/src/holyhammer/provers/eprover.sh new file mode 100644 index 0000000000..8b240a8fd2 --- /dev/null +++ b/src/holyhammer/provers/eprover.sh @@ -0,0 +1,24 @@ +# Time limit and I/O files +DIR="eprover_files" +IN="$DIR/atp_in" +OUT1="$DIR/eprover_out1" +OUT2="$DIR/eprover_out2" +OUT="$DIR/eprover_out" +STATUS="$DIR/eprover_status" +ERROR="$DIR/eprover_error" + +# Running eprover (1.8) +cd eprover +timeout $1 ./eprover -s --cpu-limit=$1 --auto-schedule --tptp3-in \ +-R --print-statistics -p --tstp-format $IN | grep "file[(]'\|# SZS" > $OUT1 2> $ERROR +# Extracting status +grep "SZS status" $OUT1 > $STATUS 2> $ERROR +sed -i -e 's/^.*SZS status\(.*\).*/\1/' $STATUS 2> $ERROR +sed -i 's/ //g' $STATUS 2> $ERROR +# Extracting axioms +grep "file[(]" $OUT1 > $OUT2 2> $ERROR +sed -e 's/^fof[(].*file(.*,\(.*\)[)][)]\..*$/\1/' $OUT2 > $OUT1 2> $ERROR +tr -d " " < $OUT1 > $OUT 2> $ERROR +# Cleaning +rm -f $OUT1 +rm -f $OUT2 diff --git a/src/holyhammer/provers/eprover/COPYING_eprover b/src/holyhammer/provers/eprover/COPYING_eprover new file mode 100644 index 0000000000..ed66dd761b --- /dev/null +++ b/src/holyhammer/provers/eprover/COPYING_eprover @@ -0,0 +1,877 @@ +======================================================================== +NOTE: The GPL/LGPL does not necessarily apply to all versions of E. If +you obtained the code under a different license, you are bound by +its conditions. You can get the latest free release of E from +http://www.eprover.org. +======================================================================== + +As of version 1.2, E is licensed under both the GNU General Public +License (2.0 or later), and the GNU Lesser General Public License (2.1 +or later). I will only accept code submissions with the same +licensing for inclusion in my branch. + +Release under the LGPL is due to the request of researchers wanting to +integrate E into free software projects using licenses incompatible +with the GPL. If this does not pan out, I will probably revert to pure +GPL for later versions (but that will not affect this release, of +course). + + + +----------------------------------------------------------------------------- + + + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc. + 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Library General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) 19yy + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) 19yy name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + , 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Library General +Public License instead of this License. + + + + + +----------------------------------------------------------------------------- + + + + + + + GNU LESSER GENERAL PUBLIC LICENSE + Version 2.1, February 1999 + + Copyright (C) 1991, 1999 Free Software Foundation, Inc. + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + +[This is the first released version of the Lesser GPL. It also counts + as the successor of the GNU Library Public License, version 2, hence + the version number 2.1.] + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +Licenses are intended to guarantee your freedom to share and change +free software--to make sure the software is free for all its users. + + This license, the Lesser General Public License, applies to some +specially designated software packages--typically libraries--of the +Free Software Foundation and other authors who decide to use it. You +can use it too, but we suggest you first think carefully about whether +this license or the ordinary General Public License is the better +strategy to use in any particular case, based on the explanations below. + + When we speak of free software, we are referring to freedom of use, +not price. Our General Public Licenses are designed to make sure that +you have the freedom to distribute copies of free software (and charge +for this service if you wish); that you receive source code or can get +it if you want it; that you can change the software and use pieces of +it in new free programs; and that you are informed that you can do +these things. + + To protect your rights, we need to make restrictions that forbid +distributors to deny you these rights or to ask you to surrender these +rights. These restrictions translate to certain responsibilities for +you if you distribute copies of the library or if you modify it. + + For example, if you distribute copies of the library, whether gratis +or for a fee, you must give the recipients all the rights that we gave +you. You must make sure that they, too, receive or can get the source +code. If you link other code with the library, you must provide +complete object files to the recipients, so that they can relink them +with the library after making changes to the library and recompiling +it. And you must show them these terms so they know their rights. + + We protect your rights with a two-step method: (1) we copyright the +library, and (2) we offer you this license, which gives you legal +permission to copy, distribute and/or modify the library. + + To protect each distributor, we want to make it very clear that +there is no warranty for the free library. Also, if the library is +modified by someone else and passed on, the recipients should know +that what they have is not the original version, so that the original +author's reputation will not be affected by problems that might be +introduced by others. + + Finally, software patents pose a constant threat to the existence of +any free program. We wish to make sure that a company cannot +effectively restrict the users of a free program by obtaining a +restrictive license from a patent holder. Therefore, we insist that +any patent license obtained for a version of the library must be +consistent with the full freedom of use specified in this license. + + Most GNU software, including some libraries, is covered by the +ordinary GNU General Public License. This license, the GNU Lesser +General Public License, applies to certain designated libraries, and +is quite different from the ordinary General Public License. We use +this license for certain libraries in order to permit linking those +libraries into non-free programs. + + When a program is linked with a library, whether statically or using +a shared library, the combination of the two is legally speaking a +combined work, a derivative of the original library. The ordinary +General Public License therefore permits such linking only if the +entire combination fits its criteria of freedom. The Lesser General +Public License permits more lax criteria for linking other code with +the library. + + We call this license the "Lesser" General Public License because it +does Less to protect the user's freedom than the ordinary General +Public License. It also provides other free software developers Less +of an advantage over competing non-free programs. These disadvantages +are the reason we use the ordinary General Public License for many +libraries. However, the Lesser license provides advantages in certain +special circumstances. + + For example, on rare occasions, there may be a special need to +encourage the widest possible use of a certain library, so that it becomes +a de-facto standard. To achieve this, non-free programs must be +allowed to use the library. A more frequent case is that a free +library does the same job as widely used non-free libraries. In this +case, there is little to gain by limiting the free library to free +software only, so we use the Lesser General Public License. + + In other cases, permission to use a particular library in non-free +programs enables a greater number of people to use a large body of +free software. For example, permission to use the GNU C Library in +non-free programs enables many more people to use the whole GNU +operating system, as well as its variant, the GNU/Linux operating +system. + + Although the Lesser General Public License is Less protective of the +users' freedom, it does ensure that the user of a program that is +linked with the Library has the freedom and the wherewithal to run +that program using a modified version of the Library. + + The precise terms and conditions for copying, distribution and +modification follow. Pay close attention to the difference between a +"work based on the library" and a "work that uses the library". The +former contains code derived from the library, whereas the latter must +be combined with the library in order to run. + + GNU LESSER GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License Agreement applies to any software library or other +program which contains a notice placed by the copyright holder or +other authorized party saying it may be distributed under the terms of +this Lesser General Public License (also called "this License"). +Each licensee is addressed as "you". + + A "library" means a collection of software functions and/or data +prepared so as to be conveniently linked with application programs +(which use some of those functions and data) to form executables. + + The "Library", below, refers to any such software library or work +which has been distributed under these terms. A "work based on the +Library" means either the Library or any derivative work under +copyright law: that is to say, a work containing the Library or a +portion of it, either verbatim or with modifications and/or translated +straightforwardly into another language. (Hereinafter, translation is +included without limitation in the term "modification".) + + "Source code" for a work means the preferred form of the work for +making modifications to it. For a library, complete source code means +all the source code for all modules it contains, plus any associated +interface definition files, plus the scripts used to control compilation +and installation of the library. + + Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running a program using the Library is not restricted, and output from +such a program is covered only if its contents constitute a work based +on the Library (independent of the use of the Library in a tool for +writing it). Whether that is true depends on what the Library does +and what the program that uses the Library does. + + 1. You may copy and distribute verbatim copies of the Library's +complete source code as you receive it, in any medium, provided that +you conspicuously and appropriately publish on each copy an +appropriate copyright notice and disclaimer of warranty; keep intact +all the notices that refer to this License and to the absence of any +warranty; and distribute a copy of this License along with the +Library. + + You may charge a fee for the physical act of transferring a copy, +and you may at your option offer warranty protection in exchange for a +fee. + + 2. You may modify your copy or copies of the Library or any portion +of it, thus forming a work based on the Library, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) The modified work must itself be a software library. + + b) You must cause the files modified to carry prominent notices + stating that you changed the files and the date of any change. + + c) You must cause the whole of the work to be licensed at no + charge to all third parties under the terms of this License. + + d) If a facility in the modified Library refers to a function or a + table of data to be supplied by an application program that uses + the facility, other than as an argument passed when the facility + is invoked, then you must make a good faith effort to ensure that, + in the event an application does not supply such function or + table, the facility still operates, and performs whatever part of + its purpose remains meaningful. + + (For example, a function in a library to compute square roots has + a purpose that is entirely well-defined independent of the + application. Therefore, Subsection 2d requires that any + application-supplied function or table used by this function must + be optional: if the application does not supply it, the square + root function must still compute square roots.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Library, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Library, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote +it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Library. + +In addition, mere aggregation of another work not based on the Library +with the Library (or with a work based on the Library) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may opt to apply the terms of the ordinary GNU General Public +License instead of this License to a given copy of the Library. To do +this, you must alter all the notices that refer to this License, so +that they refer to the ordinary GNU General Public License, version 2, +instead of to this License. (If a newer version than version 2 of the +ordinary GNU General Public License has appeared, then you can specify +that version instead if you wish.) Do not make any other change in +these notices. + + Once this change is made in a given copy, it is irreversible for +that copy, so the ordinary GNU General Public License applies to all +subsequent copies and derivative works made from that copy. + + This option is useful when you wish to copy part of the code of +the Library into a program that is not a library. + + 4. You may copy and distribute the Library (or a portion or +derivative of it, under Section 2) in object code or executable form +under the terms of Sections 1 and 2 above provided that you accompany +it with the complete corresponding machine-readable source code, which +must be distributed under the terms of Sections 1 and 2 above on a +medium customarily used for software interchange. + + If distribution of object code is made by offering access to copy +from a designated place, then offering equivalent access to copy the +source code from the same place satisfies the requirement to +distribute the source code, even though third parties are not +compelled to copy the source along with the object code. + + 5. A program that contains no derivative of any portion of the +Library, but is designed to work with the Library by being compiled or +linked with it, is called a "work that uses the Library". Such a +work, in isolation, is not a derivative work of the Library, and +therefore falls outside the scope of this License. + + However, linking a "work that uses the Library" with the Library +creates an executable that is a derivative of the Library (because it +contains portions of the Library), rather than a "work that uses the +library". The executable is therefore covered by this License. +Section 6 states terms for distribution of such executables. + + When a "work that uses the Library" uses material from a header file +that is part of the Library, the object code for the work may be a +derivative work of the Library even though the source code is not. +Whether this is true is especially significant if the work can be +linked without the Library, or if the work is itself a library. The +threshold for this to be true is not precisely defined by law. + + If such an object file uses only numerical parameters, data +structure layouts and accessors, and small macros and small inline +functions (ten lines or less in length), then the use of the object +file is unrestricted, regardless of whether it is legally a derivative +work. (Executables containing this object code plus portions of the +Library will still fall under Section 6.) + + Otherwise, if the work is a derivative of the Library, you may +distribute the object code for the work under the terms of Section 6. +Any executables containing that work also fall under Section 6, +whether or not they are linked directly with the Library itself. + + 6. As an exception to the Sections above, you may also combine or +link a "work that uses the Library" with the Library to produce a +work containing portions of the Library, and distribute that work +under terms of your choice, provided that the terms permit +modification of the work for the customer's own use and reverse +engineering for debugging such modifications. + + You must give prominent notice with each copy of the work that the +Library is used in it and that the Library and its use are covered by +this License. You must supply a copy of this License. If the work +during execution displays copyright notices, you must include the +copyright notice for the Library among them, as well as a reference +directing the user to the copy of this License. Also, you must do one +of these things: + + a) Accompany the work with the complete corresponding + machine-readable source code for the Library including whatever + changes were used in the work (which must be distributed under + Sections 1 and 2 above); and, if the work is an executable linked + with the Library, with the complete machine-readable "work that + uses the Library", as object code and/or source code, so that the + user can modify the Library and then relink to produce a modified + executable containing the modified Library. (It is understood + that the user who changes the contents of definitions files in the + Library will not necessarily be able to recompile the application + to use the modified definitions.) + + b) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (1) uses at run time a + copy of the library already present on the user's computer system, + rather than copying library functions into the executable, and (2) + will operate properly with a modified version of the library, if + the user installs one, as long as the modified version is + interface-compatible with the version that the work was made with. + + c) Accompany the work with a written offer, valid for at + least three years, to give the same user the materials + specified in Subsection 6a, above, for a charge no more + than the cost of performing this distribution. + + d) If distribution of the work is made by offering access to copy + from a designated place, offer equivalent access to copy the above + specified materials from the same place. + + e) Verify that the user has already received a copy of these + materials or that you have already sent this user a copy. + + For an executable, the required form of the "work that uses the +Library" must include any data and utility programs needed for +reproducing the executable from it. However, as a special exception, +the materials to be distributed need not include anything that is +normally distributed (in either source or binary form) with the major +components (compiler, kernel, and so on) of the operating system on +which the executable runs, unless that component itself accompanies +the executable. + + It may happen that this requirement contradicts the license +restrictions of other proprietary libraries that do not normally +accompany the operating system. Such a contradiction means you cannot +use both them and the Library together in an executable that you +distribute. + + 7. You may place library facilities that are a work based on the +Library side-by-side in a single library together with other library +facilities not covered by this License, and distribute such a combined +library, provided that the separate distribution of the work based on +the Library and of the other library facilities is otherwise +permitted, and provided that you do these two things: + + a) Accompany the combined library with a copy of the same work + based on the Library, uncombined with any other library + facilities. This must be distributed under the terms of the + Sections above. + + b) Give prominent notice with the combined library of the fact + that part of it is a work based on the Library, and explaining + where to find the accompanying uncombined form of the same work. + + 8. You may not copy, modify, sublicense, link with, or distribute +the Library except as expressly provided under this License. Any +attempt otherwise to copy, modify, sublicense, link with, or +distribute the Library is void, and will automatically terminate your +rights under this License. However, parties who have received copies, +or rights, from you under this License will not have their licenses +terminated so long as such parties remain in full compliance. + + 9. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Library or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Library (or any work based on the +Library), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Library or works based on it. + + 10. Each time you redistribute the Library (or any work based on the +Library), the recipient automatically receives a license from the +original licensor to copy, distribute, link with or modify the Library +subject to these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties with +this License. + + 11. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Library at all. For example, if a patent +license would not permit royalty-free redistribution of the Library by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Library. + +If any portion of this section is held invalid or unenforceable under any +particular circumstance, the balance of the section is intended to apply, +and the section as a whole is intended to apply in other circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 12. If the distribution and/or use of the Library is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Library under this License may add +an explicit geographical distribution limitation excluding those countries, +so that distribution is permitted only in or among countries not thus +excluded. In such case, this License incorporates the limitation as if +written in the body of this License. + + 13. The Free Software Foundation may publish revised and/or new +versions of the Lesser General Public License from time to time. +Such new versions will be similar in spirit to the present version, +but may differ in detail to address new problems or concerns. + +Each version is given a distinguishing version number. If the Library +specifies a version number of this License which applies to it and +"any later version", you have the option of following the terms and +conditions either of that version or of any later version published by +the Free Software Foundation. If the Library does not specify a +license version number, you may choose any version ever published by +the Free Software Foundation. + + 14. If you wish to incorporate parts of the Library into other free +programs whose distribution conditions are incompatible with these, +write to the author to ask for permission. For software which is +copyrighted by the Free Software Foundation, write to the Free +Software Foundation; we sometimes make exceptions for this. Our +decision will be guided by the two goals of preserving the free status +of all derivatives of our free software and of promoting the sharing +and reuse of software generally. + + NO WARRANTY + + 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO +WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. +EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR +OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY +KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE +LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME +THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN +WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY +AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU +FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR +CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE +LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING +RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A +FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF +SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH +DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Libraries + + If you develop a new library, and you want it to be of the greatest +possible use to the public, we recommend making it free software that +everyone can redistribute and change. You can do so by permitting +redistribution under these terms (or, alternatively, under the terms of the +ordinary General Public License). + + To apply these terms, attach the following notices to the library. It is +safest to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least the +"copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + +Also add information on how to contact you by electronic and paper mail. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the library, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the + library `Frob' (a library for tweaking knobs) written by James Random Hacker. + + , 1 April 1990 + Ty Coon, President of Vice + +That's all there is to it! diff --git a/src/holyhammer/provers/vampire.sh b/src/holyhammer/provers/vampire.sh new file mode 100644 index 0000000000..40fda6779e --- /dev/null +++ b/src/holyhammer/provers/vampire.sh @@ -0,0 +1,23 @@ +# I/O files +DIR="vampire_files" +IN="$DIR/atp_in" +OUT="$DIR/vampire_out" +OUT1="$DIR/vampire_out1" +OUT2="$DIR/vampire_out2" +STATUS="$DIR/vampire_status" +ERROR="$DIR/vampire_error" + +# Running Vampire (2.6) +cd vampire +timeout $1 ./vampire --mode casc -t $1 --proof tptp --output_axiom_names on $IN \ + | grep "file[(]'\| SZS" > $OUT1 2> $ERROR +# Extracting status +grep "SZS status" $OUT1 > $STATUS 2> $ERROR +sed -i -e 's/^%[ ]*SZS[ ]*status\(.*\)[ ]*for.*$/\1/' $STATUS 2> $ERROR +sed -i 's/ //g' $STATUS 2> $ERROR +# Extracting axioms +grep "file[(]" $OUT1 > $OUT2 2> $ERROR +sed -e 's/^[ ]*file[(].*,\(.*\)[)])\..*$/\1/' $OUT2 > $OUT 2> $ERROR +# Cleaning +rm -f $OUT1 +rm -f $OUT2 diff --git a/src/holyhammer/provers/vampire/README b/src/holyhammer/provers/vampire/README new file mode 100644 index 0000000000..2a7962267b --- /dev/null +++ b/src/holyhammer/provers/vampire/README @@ -0,0 +1,2 @@ +This directory is initially empty. You may add Vampire(2.6) here. +Please give name vampire to this binary. diff --git a/src/holyhammer/provers/z3.sh b/src/holyhammer/provers/z3.sh new file mode 100644 index 0000000000..289fb7e345 --- /dev/null +++ b/src/holyhammer/provers/z3.sh @@ -0,0 +1,25 @@ +# Time limit and I/O files +DIR="z3_files" +IN="$DIR/atp_in" +OUT1="$DIR/z3_out1" +OUT2="$DIR/z3_out2" +OUT="$DIR/z3_out" +STATUS="$DIR/z3_status" +ERROR="$DIR/z3_error" + +# Running Z3 (4.0) +cd z3 +timeout $1 ./z3 -tptp DISPLAY_UNSAT_CORE=true ELIM_QUANTIFIERS=true PULL_NESTED_QUANTIFIERS=true \ +-T:$1 $IN > $OUT1 2> $ERROR +# Extracting status +grep "SZS status" $OUT1 > $STATUS 2> $ERROR +sed -i -e 's/^[ ]*SZS[ ]*status\(.*\)[ ]*for.*$/\1/' $STATUS 2> $ERROR +sed -i 's/ //g' $STATUS 2> $ERROR +# Extracting axioms +grep "^core" $OUT1 > $OUT2 2> $ERROR +sed -e 's/^core[(].*\[\(.*\)\][)].*/\1/' $OUT2 > $OUT1 2> $ERROR +tr "," "\n" < $OUT1 > $OUT2 2> $ERROR +tr -d " " < $OUT2 > $OUT 2> $ERROR +# Cleaning +rm -f $OUT1 +rm -f $OUT2 diff --git a/src/holyhammer/provers/z3/LICENSE.txt b/src/holyhammer/provers/z3/LICENSE.txt new file mode 100644 index 0000000000..91c8070d0f --- /dev/null +++ b/src/holyhammer/provers/z3/LICENSE.txt @@ -0,0 +1,7 @@ +Z3 +Copyright (c) Microsoft Corporation +All rights reserved. +MIT License +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the ""Software""), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/src/holyhammer/provers/z3/README b/src/holyhammer/provers/z3/README new file mode 100644 index 0000000000..c7eb858a27 --- /dev/null +++ b/src/holyhammer/provers/z3/README @@ -0,0 +1,2 @@ +The current executable works for linux 64bit. +You may replace Z3(4.0) here, if you don't want to use it you can remove it. diff --git a/src/holyhammer/scripts/hh.sh b/src/holyhammer/scripts/hh.sh new file mode 100644 index 0000000000..c60527412b --- /dev/null +++ b/src/holyhammer/scripts/hh.sh @@ -0,0 +1,8 @@ +EPROVER="../provers/eprover/eprover" +VAMPIRE="../provers/vampire/vampire" +Z3="../provers/z3/z3" + +# Run eprover, vampire and z3 +(if [ -f $EPROVER ]; then sh hh_eprover.sh $2 $5 $1; fi) & \ +(if [ -f $VAMPIRE ]; then sh hh_vampire.sh $3 $6 $1; fi) & \ +(if [ -f $Z3 ]; then sh hh_z3.sh $4 $7 $1; fi) diff --git a/src/holyhammer/scripts/hh_clean.sh b/src/holyhammer/scripts/hh_clean.sh new file mode 100644 index 0000000000..2a2a46627b --- /dev/null +++ b/src/holyhammer/scripts/hh_clean.sh @@ -0,0 +1,14 @@ +EPROVER_DIR="../provers/eprover/eprover_files" +VAMPIRE_DIR="../provers/vampire/vampire_files" +Z3_DIR="../provers/z3/z3_files" +THEORY_DIR="../theories" + +clean(){ +if [ -d $1 ]; then rm -r $1; fi +mkdir $1 +} + +clean $EPROVER_DIR +clean $VAMPIRE_DIR +clean $Z3_DIR +clean $THEORY_DIR diff --git a/src/holyhammer/scripts/hh_eprover.sh b/src/holyhammer/scripts/hh_eprover.sh new file mode 100644 index 0000000000..9a99d12eb3 --- /dev/null +++ b/src/holyhammer/scripts/hh_eprover.sh @@ -0,0 +1,16 @@ +EPROVER_DIR="../provers/eprover/eprover_files" + +clean(){ +if [ -d $1 ]; then rm -r $1; fi +mkdir $1 +} + +cd ../hh +clean $EPROVER_DIR +# Premise selection and translation +./hh $1 $2 ../theories ../theories/conjecture conjecture \ +$EPROVER_DIR -thydep ../theories/thydep > /dev/null || \ +(echo "See README in src/holyhammer."; exit) +# Run eprover +cd ../provers +sh eprover.sh $3 diff --git a/src/holyhammer/scripts/hh_vampire.sh b/src/holyhammer/scripts/hh_vampire.sh new file mode 100644 index 0000000000..b0a9b98f96 --- /dev/null +++ b/src/holyhammer/scripts/hh_vampire.sh @@ -0,0 +1,16 @@ +VAMPIRE_DIR="../provers/vampire/vampire_files" + +clean(){ +if [ -d $1 ]; then rm -r $1; fi +mkdir $1 +} + +cd ../hh +clean $VAMPIRE_DIR +# Premise selection and translation +./hh $1 $2 ../theories ../theories/conjecture conjecture \ +$VAMPIRE_DIR -thydep ../theories/thydep > /dev/null || \ +(echo "See README in src/holyhammer."; exit) +# Run vampire +cd ../provers +sh vampire.sh $3 diff --git a/src/holyhammer/scripts/hh_z3.sh b/src/holyhammer/scripts/hh_z3.sh new file mode 100644 index 0000000000..168d656dbb --- /dev/null +++ b/src/holyhammer/scripts/hh_z3.sh @@ -0,0 +1,16 @@ +Z3_DIR="../provers/z3/z3_files" + +clean(){ +if [ -d $1 ]; then rm -r $1; fi +mkdir $1 +} + +cd ../hh +clean $Z3_DIR +# Premise selection and translation +./hh $1 $2 ../theories ../theories/conjecture conjecture \ +$Z3_DIR -thydep ../theories/thydep > /dev/null || \ +(echo "See README in src/holyhammer."; exit) +# Run z3 +cd ../provers +sh z3.sh $3 diff --git a/src/logging-kernel/Thm.sml b/src/logging-kernel/Thm.sml index db819b41ad..5b717038a0 100644 --- a/src/logging-kernel/Thm.sml +++ b/src/logging-kernel/Thm.sml @@ -15,9 +15,10 @@ structure Thm :> Thm = struct -open Feedback Lib Term +open Feedback Lib Term Tag Dep type 'a set = 'a HOLset.set; +type depdisk = (string * int) * ((string * int list) list); type tag = Tag.tag val --> = Type.-->; @@ -1262,17 +1263,39 @@ in end +(* ---------------------------------------------------------------------- + Creating a theorem from disk + ---------------------------------------------------------------------- *) + local val mk_disk_thm = make_thm Count.Disk in -fun disk_thm (s, termlist) = let +fun disk_thm ((d,ocl), termlist) = let val c = hd termlist val asl = tl termlist in - mk_disk_thm(Tag.read_disk_tag s,list_hyp asl,c,Axiom_prf) + mk_disk_thm (Tag.read_disk_tag (d,ocl),list_hyp asl,c) end end; (* local *) +(* ---------------------------------------------------------------------- + Saving dependencies of a theorem + ---------------------------------------------------------------------- *) + +(* This reference is automatically reset to 0 each time you create + a theory. *) +val thm_order = ref 0 + +fun save_dep thy (th as (THM(t,h,c))) = + let + val did = (thy,!thm_order) + val dl = (transfer_thydepl o dep_of o tag) th + val dep = DEP_SAVED(did,dl) + in + thm_order := (!thm_order) + 1; + THM(Tag.set_dep dep t,h,c) + end + (* Some OpenTheory kernel rules *) fun deductAntisym (th1 as THM(o1,a1,c1,p1)) (th2 as THM(o2,a2,c2,p2)) = let val a1' = disch (c2,a1) diff --git a/src/postkernel/Theory.sml b/src/postkernel/Theory.sml index c76af95a42..c04767d687 100644 --- a/src/postkernel/Theory.sml +++ b/src/postkernel/Theory.sml @@ -534,8 +534,9 @@ local val mesg = with_flag(MESG_to_string, Lib.I) HOL_MESG in fun save_thm (name,th) = - (check_name true ("save_thm",name) - ; if uptodate_thm th then add_thmCT(name,th) + let val th' = save_dep (CTname()) th in + check_name true ("save_thm",name) + ; if uptodate_thm th' then add_thmCT(name,th') else raise DATED_ERR "save_thm" name ; if !save_thm_reporting = 0 then () else if !Globals.interactive then @@ -545,25 +546,29 @@ fun save_thm (name,th) = () else mesg ("Saved theorem _____ " ^ Lib.quote name ^ "\n") - ; th) + ; th' + end fun new_axiom (name,tm) = - let val rname = Nonce.mk name - val axiom = Thm.mk_axiom_thm (rname,tm) - val _ = check_name false ("new_axiom",name) - in if uptodate_term tm then add_axiomCT(rname,axiom) - else raise DATED_ERR "new_axiom" name - ; axiom - end + let val rname = Nonce.mk name + val axiom = Thm.mk_axiom_thm (rname,tm) + val axiom' = save_dep (CTname()) axiom + val _ = check_name false ("new_axiom",name) + in if uptodate_term tm then add_axiomCT(rname,axiom') + else raise DATED_ERR "new_axiom" name + ; axiom' + end fun store_definition(name, def) = - let val () = check_name true ("store_definition",name) + let + val def' = save_dep (CTname()) def + val () = check_name true ("store_definition",name) in - if uptodate_thm def then () + if uptodate_thm def' then () else raise DATED_ERR "store_definition" name - ; add_defnCT(name,def) - ; def - end + ; add_defnCT(name,def') + ; def' + end end; diff --git a/src/prekernel/Dep.sig b/src/prekernel/Dep.sig new file mode 100644 index 0000000000..ca53cf0606 --- /dev/null +++ b/src/prekernel/Dep.sig @@ -0,0 +1,29 @@ +signature Dep = +sig + + type depid = string * int + datatype dep = DEP_SAVED of depid * (string * int list) list + | DEP_UNSAVED of (string * int list) list + type depdisk = (string * int) * ((string * int list) list) + + val empty_dep : dep + + (* Dependency accessors *) + val depthy_of : depid -> string + val depnumber_of : depid -> int + val depid_of : dep -> depid + val depidl_of : dep -> depid list + val thydepl_of : dep -> (string * int list) list + + (* Comparison functions *) + val depid_compare : (depid * depid) -> order + + (* Tracking dependencies in inference rules *) + val transfer_thydepl : dep -> (string * int list) list + val merge_dep : dep -> dep -> dep + + (* I/O *) + val pp_dep : Portable.ppstream -> dep -> unit + val read_dep : depdisk -> dep + +end diff --git a/src/prekernel/Dep.sml b/src/prekernel/Dep.sml new file mode 100644 index 0000000000..dfa1278e91 --- /dev/null +++ b/src/prekernel/Dep.sml @@ -0,0 +1,142 @@ +(* ===================================================================== *) +(* FILE : Dep.sml *) +(* DESCRIPTION : Dependency tracking between theorems *) +(* for holyhammer *) +(* *) +(* AUTHOR : Thibault Gauthier, University of Innsbruck *) +(* DATE : 2015 *) +(* ===================================================================== *) + +structure Dep :> Dep = +struct +open Lib Feedback + +val ERR = mk_HOL_ERR "Dep" + +(*---------------------------------------------------------------------------*) +(* We store the dependencies of a theorem as a sorted list of dependencies *) +(* identifiers factorized by theory (thydepl). *) +(*---------------------------------------------------------------------------*) + +type depid = string * int +datatype dep = DEP_SAVED of depid * (string * int list) list + | DEP_UNSAVED of (string * int list) list +type depdisk = (string * int) * ((string * int list) list) + +val empty_dep = DEP_UNSAVED [] + +(*--------------------------------------------------------------------------- + Accessors + ----------------------------------------------------------------------------*) + +fun depthy_of depid = fst depid +fun depnumber_of depid = snd depid + +fun depid_of d = case d of + DEP_SAVED (did,_) => did + | DEP_UNSAVED _ => raise ERR "depid_of_dep" "" + +fun thydepl_of dep = case dep of + DEP_SAVED (did,thydl) => thydl + | DEP_UNSAVED thydl => thydl + +fun flatten_thydepl thydepl = + let fun distrib (s,nl) = map (fn n => (s,n)) nl in + List.concat (map distrib thydepl) + end + +fun depidl_of dep = flatten_thydepl (thydepl_of dep) + +(*--------------------------------------------------------------------------- + Comparison + ----------------------------------------------------------------------------*) + +fun couple_compare compare1 compare2 ((a1,a2),(b1,b2)) = + case compare1 (a1,b1) of + LESS => LESS + | GREATER => GREATER + | EQUAL => compare2 (a2,b2) + + +val depid_compare = couple_compare String.compare Int.compare + +(*--------------------------------------------------------------------------- + Tracking dependencies in inference rules. + ----------------------------------------------------------------------------*) + +fun transfer_thydepl d = case d of + DEP_SAVED ((thy,n),thydl) => [(thy,[n])] + | DEP_UNSAVED thydl => thydl + +fun merge_intl nl1 nl2 = case (nl1, nl2) of + ([], _) => nl2 + | (_, []) => nl1 + | (n1 :: m1, n2 :: m2) => + ( + case Int.compare (n1,n2) of + LESS => n1 :: merge_intl m1 nl2 + | GREATER => n2 :: merge_intl nl1 m2 + | EQUAL => n1 :: merge_intl m1 m2 + ) + +fun merge_thydepl thydl1 thydl2 = case (thydl1, thydl2) of + ([], _) => thydl2 + | (_, []) => thydl1 + | ((thy1,nl1) :: m1, (thy2,nl2) :: m2) => + ( + case String.compare (thy1,thy2) of + LESS => (thy1, nl1) :: merge_thydepl m1 thydl2 + | GREATER => (thy2, nl2) :: merge_thydepl thydl1 m2 + | EQUAL => (thy1, merge_intl nl1 nl2) :: merge_thydepl m1 m2 + ) + +fun merge_dep d1 d2 = + let val (thydl1,thydl2) = (transfer_thydepl d1, transfer_thydepl d2) in + DEP_UNSAVED (merge_thydepl thydl1 thydl2) + end + +(*--------------------------------------------------------------------------- + Printing dependencies to disk. + ----------------------------------------------------------------------------*) + +fun pp_dep_aux ppstrm (did,thydl) = + let + open Portable + val {add_string,add_break,begin_block,end_block,...} = with_ppstream ppstrm + fun pp_l_aux f L = case L of + [] => () + | [a] => f a + | a :: m => (f a; add_string ","; add_break(0,0); pp_l_aux f m) + fun pp_l f L = + (begin_block INCONSISTENT 0; + add_string "["; + begin_block INCONSISTENT 0; + pp_l_aux f L; + end_block(); + add_string "]"; + end_block()) + fun pp_couple (f1,f2) (a1,a2) = + (begin_block INCONSISTENT 0; + add_string "("; f1 a1; add_string ","; add_break(0,0); + f2 a2; add_string ")"; + end_block()) + fun pp_scouple (s1,s2) = pp_couple (add_string,add_string) (s1,s2) + fun pp_did (thy,n) = pp_scouple (Lib.quote thy, int_to_string n) + fun pp_thyentry (thy,l) = + pp_couple (add_string o Lib.quote, pp_l add_string) (thy,map int_to_string l) + fun pp_thydepl l = pp_l pp_thyentry l + in + pp_couple (pp_did, pp_thydepl) (did,thydl) + end + +fun pp_dep ppstrm d = case d of + DEP_SAVED (did,thydl) => pp_dep_aux ppstrm (did,thydl) + | DEP_UNSAVED dl => raise ERR "pp_dep" "" + +(*--------------------------------------------------------------------------- + Reading dependencies from disk. + ----------------------------------------------------------------------------*) + +fun read_dep (did,l) = DEP_SAVED(did,l) + +end diff --git a/src/prekernel/FinalTag-sig.sml b/src/prekernel/FinalTag-sig.sml index 919d0135d9..11101c40f2 100644 --- a/src/prekernel/FinalTag-sig.sml +++ b/src/prekernel/FinalTag-sig.sml @@ -2,13 +2,16 @@ signature FinalTag = sig type tag - val read : string -> tag - val dest_tag : tag -> string list * string list - val axioms_of : tag -> string Nonce.t list - val merge : tag -> tag -> tag - val isEmpty : tag -> bool - val isDisk : tag -> bool - val pp_tag : Portable.ppstream -> tag -> unit - val pp_to_disk : Portable.ppstream -> tag -> unit + val axioms_of : tag -> string Nonce.t list + val dep_of : tag -> Dep.dep + val dest_tag : tag -> string list * string list + val isEmpty : tag -> bool + val isDisk : tag -> bool + val ax_tag : string Nonce.t -> tag + val set_dep : Dep.dep -> tag -> tag + val read : string -> tag + val merge : tag -> tag -> tag + val pp_tag : Portable.ppstream -> tag -> unit + val pp_to_disk : Portable.ppstream -> tag -> unit end diff --git a/src/prekernel/FinalThm-sig.sml b/src/prekernel/FinalThm-sig.sml index 898b4a9633..e5996325ae 100644 --- a/src/prekernel/FinalThm-sig.sml +++ b/src/prekernel/FinalThm-sig.sml @@ -5,6 +5,7 @@ sig type term type hol_type type 'a set = 'a HOLset.set + type depdisk = (string * int) * ((string * int list) list) val kernelid : string @@ -115,5 +116,10 @@ sig (* Fetching theorems from disk *) - val disk_thm : string list * term list -> thm + val disk_thm : (depdisk * string list) * term list -> thm + + (* Saving proof dependencies *) + + val save_dep : string -> thm -> thm + end; diff --git a/src/prekernel/Tag.sig b/src/prekernel/Tag.sig index 672dc93aab..fd7450315e 100644 --- a/src/prekernel/Tag.sig +++ b/src/prekernel/Tag.sig @@ -2,16 +2,18 @@ signature Tag = sig type tag - val read : string -> tag - val read_disk_tag : string list -> tag - val axioms_of : tag -> string Nonce.t list - val dest_tag : tag -> string list * string list - val empty_tag : tag - val isEmpty : tag -> bool - val isDisk : tag -> bool - val merge : tag -> tag -> tag - val ax_tag : string Nonce.t -> tag - val pp_tag : Portable.ppstream -> tag -> unit + val axioms_of : tag -> string Nonce.t list + val dep_of : tag -> Dep.dep + val dest_tag : tag -> string list * string list + val empty_tag : tag + val isEmpty : tag -> bool + val isDisk : tag -> bool + val ax_tag : string Nonce.t -> tag + val set_dep : Dep.dep -> tag -> tag + val read : string -> tag + val merge : tag -> tag -> tag + val read_disk_tag : Dep.depdisk * string list -> tag + val pp_tag : Portable.ppstream -> tag -> unit val pp_to_disk : Portable.ppstream -> tag -> unit end diff --git a/src/prekernel/Tag.sml b/src/prekernel/Tag.sml index 19d6a00ccf..05e9f70c0f 100644 --- a/src/prekernel/Tag.sml +++ b/src/prekernel/Tag.sml @@ -3,89 +3,117 @@ (* DESCRIPTION : Theorem tagging (for oracles and other stuff) *) (* *) (* AUTHOR : (c) Konrad Slind, University of Cambridge *) +(* Modified by Thibault Gauthier 2015 *) (* DATE : 1998 *) (* ===================================================================== *) structure Tag :> Tag = struct -open Lib Feedback +open Lib Feedback Dep val ERR = mk_HOL_ERR "Tag"; (*---------------------------------------------------------------------------*) -(* A tag is represented by a pair (O,A) where O is a list of oracles *) +(* A tag is represented by a pair (D,O,A) where O is a list of oracles *) (* (represented by strings) and A is a list of axioms (a list of references *) (* to strings). The axioms are used to track the use of axioms in proofs in *) -(* the current theory. *) +(* the current theory. D represents a list of proof dependencies of the *) +(* theorem. *) (*---------------------------------------------------------------------------*) -datatype tag = TAG of string list * string Nonce.t list +datatype tag = TAG of dep * string list * string Nonce.t list -fun dest_tag (TAG(O,A)) = (O, map Nonce.dest A) -fun oracles_of (TAG(O,_)) = O; -fun axioms_of (TAG(_,A)) = A; +fun dest_tag (TAG(D,O,A)) = (O, map Nonce.dest A) +fun oracles_of (TAG(_,O,_)) = O +fun axioms_of (TAG(_,_,A)) = A +fun dep_of (TAG(D,_,_)) = D +fun set_dep d (TAG(_,O,A)) = TAG(d,O,A) -val empty_tag = TAG ([],[]) -val disk_only_tag = TAG (["DISK_THM"],[]) -fun ax_tag r = TAG ([],[r]) +val empty_tag = TAG (empty_dep,[],[]) +val disk_only_tag = TAG (empty_dep,["DISK_THM"],[]) +fun ax_tag r = TAG (empty_dep,[],[r]) -val isEmpty = equal empty_tag; -val isDisk = equal disk_only_tag; +fun isEmpty tg = null (oracles_of tg) andalso null (axioms_of tg) +fun isDisk tg = oracles_of tg = ["DISK_THM"] andalso null (axioms_of tg) -(*---------------------------------------------------------------------------*) -(* Create a tag. A tag is a string with only printable characters (as *) -(* defined by Char.isPrint) and without spaces. *) -(*---------------------------------------------------------------------------*) +(*--------------------------------------------------------------------------- + Create a tag. A tag is a string with only printable characters (as + defined by Char.isPrint) and without spaces. + ----------------------------------------------------------------------------*) fun read s = let open Substring in if isEmpty(dropl Char.isPrint (full s)) - then TAG ([s],[]) + then TAG (empty_dep,[s],[]) else raise ERR "read" (Lib.quote s^" has unprintable characters") end; (*--------------------------------------------------------------------------- - Merge two tags; read tags from disk - ---------------------------------------------------------------------------*) + Tracks the extra information passed through the inference rules. + Read tags from disk. + ----------------------------------------------------------------------------*) -local fun smerge t1 [] = t1 - | smerge [] t2 = t2 - | smerge (t as ["DISK_THM"]) ["DISK_THM"] = t - | smerge (l0 as s0::rst0) (l1 as s1::rst1) = - case String.compare (s0,s1) - of LESS => s0::smerge rst0 l1 - | GREATER => s1::smerge l0 rst1 - | EQUAL => s0::smerge rst0 rst1 -in -fun merge (TAG(o1,ax1)) (TAG(o2,ax2)) = TAG(smerge o1 o2, Lib.union ax1 ax2) -fun read_disk_tag [] = disk_only_tag - | read_disk_tag slist = TAG (smerge ["DISK_THM"] slist, []) -end; +local +val merge_axiom = Lib.union -(*---------------------------------------------------------------------------*) -(* In a theory file, the list of oracles gets dumped out as a list of *) -(* strings. The axioms are not currently dumped, since they are being used *) -(* only for ensuring that no out-of-date objects in the current theory *) -(* become persistent. *) -(*---------------------------------------------------------------------------*) +fun merge_oracle t1 [] = t1 + | merge_oracle [] t2 = t2 + | merge_oracle (t as ["DISK_THM"]) ["DISK_THM"] = t + | merge_oracle (l0 as s0::rst0) (l1 as s1::rst1) = + case String.compare (s0,s1) of + LESS => s0::merge_oracle rst0 l1 + | GREATER => s1::merge_oracle l0 rst1 + | EQUAL => s0::merge_oracle rst0 rst1 -fun pp_to_disk ppstrm (TAG (olist,_)) = - let open Portable - val {add_string,add_break,begin_block,end_block,...} = with_ppstream ppstrm - val olist' = map Lib.mlquote olist - in - begin_block CONSISTENT 0; - add_string "["; +in (* in local *) + +fun merge (TAG(d1,o1,ax1)) (TAG(d2,o2,ax2)) = + TAG(merge_dep d1 d2, merge_oracle o1 o2, merge_axiom ax1 ax2) + +fun read_disk_tag (d,[]) = TAG (read_dep d, ["DISK_THM"], []) + | read_disk_tag (d,sl) = TAG (read_dep d, merge_oracle ["DISK_THM"] sl, []) + +end; (* end local *) + + +(*--------------------------------------------------------------------------- + In a theory file, the list of oracles gets dumped out as a list of + strings. The axioms are not currently dumped, since they are being used + only for ensuring that no out-of-date objects in the current theory + become persistent. Concrening dependencies, we only print the dependency + number inside the tag. Other informations are retrieved from the dependency + graph. + ----------------------------------------------------------------------------*) + +fun pp_to_disk ppstrm (TAG (d,olist,_)) = + let + open Portable + val {add_string,add_break,begin_block,end_block,...} = with_ppstream ppstrm + fun pp_sl l = + ( + begin_block CONSISTENT 0; + add_string "["; begin_block INCONSISTENT 1; pr_list add_string (fn () => add_string ",") - (fn () => add_break(1,0)) olist'; + (fn () => add_break(1,0)) l; end_block(); add_string "]"; end_block() - end + ) + in + ( + begin_block CONSISTENT 0; + add_string "("; + pp_dep ppstrm d; + add_string ","; + pp_sl (map Lib.mlquote olist); + add_string ")"; + end_block() + ) + end (*--------------------------------------------------------------------------- Prettyprint a tag (for interactive work). @@ -95,7 +123,7 @@ local open Portable fun repl ch alist = String.implode (itlist (fn _ => fn chs => (ch::chs)) alist []) in -fun pp_tag ppstrm (TAG (olist,axlist)) = +fun pp_tag ppstrm (TAG (_,olist,axlist)) = let val {add_string,add_break,begin_block,end_block,...} = with_ppstream ppstrm in diff --git a/tools/build-sequence b/tools/build-sequence index 96983393c5..30ae16d041 100644 --- a/tools/build-sequence +++ b/tools/build-sequence @@ -52,6 +52,7 @@ # (the directory containing this file). #include sequences/kernel +#include sequences/holyhammer #include sequences/core-theories #include sequences/more-theories #include sequences/large-theories diff --git a/tools/sequences/holyhammer b/tools/sequences/holyhammer new file mode 100644 index 0000000000..e4caca00fb --- /dev/null +++ b/tools/sequences/holyhammer @@ -0,0 +1,5 @@ +src/holyhammer/hh/hh1 +src/holyhammer/hh +src/holyhammer/predict +src/holyhammer/predict/mepo +src/holyhammer From 45c4e543893874806d13aa9c02cb5acd2c272eb0 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 4 Aug 2015 11:32:08 +0200 Subject: [PATCH 390/718] Clean up holyhammer Holmakefiles This assumes new which function therein. --- src/holyhammer/hh/.gitignore | 5 ++++ src/holyhammer/hh/Holmakefile | 19 ++++++++++++-- src/holyhammer/hh/hh1/Holmakefile | 16 +++++++++--- src/holyhammer/predict/.gitignore | 1 + src/holyhammer/predict/Holmakefile | 35 +++++++++++++++++++++++--- src/holyhammer/predict/mepo/.gitignore | 2 ++ 6 files changed, 70 insertions(+), 8 deletions(-) create mode 100644 src/holyhammer/hh/.gitignore create mode 100644 src/holyhammer/predict/.gitignore create mode 100644 src/holyhammer/predict/mepo/.gitignore diff --git a/src/holyhammer/hh/.gitignore b/src/holyhammer/hh/.gitignore new file mode 100644 index 0000000000..964803dda5 --- /dev/null +++ b/src/holyhammer/hh/.gitignore @@ -0,0 +1,5 @@ +*.cmi +*.cmx +hh +hh_lexer.ml +hh_parse.ml diff --git a/src/holyhammer/hh/Holmakefile b/src/holyhammer/hh/Holmakefile index eebab464c9..49d9d05ea0 100644 --- a/src/holyhammer/hh/Holmakefile +++ b/src/holyhammer/hh/Holmakefile @@ -1,3 +1,7 @@ +.PHONY: all + +ifneq ($(which ocamlopt),) + HH2_CMX=hh_parse.cmx hh_lexer.cmx read.cmx predict.cmx preprocess.cmx init.cmx \ dependency.cmx thf1hh1.cmx prepredict.cmx write.cmx @@ -5,10 +9,14 @@ HL_CMX=hh1/lib.cmx hh1/fusion.cmx hh1/basics.cmx hh1/printer.cmx \ hh1/preterm.cmx hh1/hl_parser.cmx hh1/equal.cmx hh1/bool.cmx \ hh1/drule.cmx hh1/tactics.cmx hh1/simp.cmx hh1/theorems.cmx \ hh1/canon.cmx hh1/fol.cmx hh1/follist.cmx hh1/meson.cmx \ -hh1/hh_symbols.cmx hh1/features_dt.cmx hh1/hh_tac.cmx hh1/hh_write.cmx +hh1/hh_symbols.cmx hh1/features_dt.cmx hh1/hh_tac.cmx hh1/hh_write.cmx ALL_CMX=$(HL_CMX) $(HH2_CMX) +EXTRA_CLEANS = $(HH2_CMX) $(patsubst %.cmx,%.cmi,$(HH2_CMX)) $(patsubst %.cmx,%.o,$(HH2_CMX)) hh_parse.ml hh_lexer.ml + + + all: $(HH2_CMX) hh hh: main.ml @@ -20,7 +28,7 @@ hh_parse.ml: hh_parse.mly hh_lexer.ml: hh_lexer.mll hh_parse.ml ocamllex $< - + hh_parse.cmx: hh_parse.ml ocamlopt -c $< hh_lexer.cmx: hh_lexer.ml @@ -44,3 +52,10 @@ write.cmx: write.ml clean: rm -f hh *cmx *cmi *_lexer.ml *_parse.ml *.o *.mli + +else + +all: + @echo "No OCaml installation found -- giving up on hh" + +endif diff --git a/src/holyhammer/hh/hh1/Holmakefile b/src/holyhammer/hh/hh1/Holmakefile index 23e3a4c684..bfceb646ca 100644 --- a/src/holyhammer/hh/hh1/Holmakefile +++ b/src/holyhammer/hh/hh1/Holmakefile @@ -1,5 +1,11 @@ +.PHONY: all + FILES_CMX=lib.cmx fusion.cmx basics.cmx printer.cmx preterm.cmx hl_parser.cmx equal.cmx bool.cmx drule.cmx tactics.cmx simp.cmx theorems.cmx canon.cmx fol.cmx follist.cmx meson.cmx hh_symbols.cmx features_dt.cmx hh_tac.cmx hh_write.cmx - + +EXTRA_CLEANS = $(FILES_CMX) $(patsubst %.cmx,%.cmi,$(FILES_CMX)) $(patsubst %.cmx,%.o,$(FILES_CMX)) + +ifneq($(which ocamlopt),) + all: $(FILES_CMX) lib.cmx: lib.ml @@ -43,5 +49,9 @@ hh_tac.cmx: hh_tac.ml hh_write.cmx: hh_write.ml ocamlopt -c $< -clean: - rm -f *cmx *cmi *.o +else + +all: + @echo "No OCaml detected -- giving up" + +endif diff --git a/src/holyhammer/predict/.gitignore b/src/holyhammer/predict/.gitignore new file mode 100644 index 0000000000..7b4849715e --- /dev/null +++ b/src/holyhammer/predict/.gitignore @@ -0,0 +1 @@ +predict diff --git a/src/holyhammer/predict/Holmakefile b/src/holyhammer/predict/Holmakefile index ecd604e191..f0b371f44f 100644 --- a/src/holyhammer/predict/Holmakefile +++ b/src/holyhammer/predict/Holmakefile @@ -1,7 +1,36 @@ + +GPP48=$(which g++-4.8) +EXTRA_CLEANS = predict + +# prefer g++-4.8 if it's available +ifeq($(GPP48),) + +# otherwise just try g++ +GPP=$(which g++) + +else + +GPP=$(GPP48) + +endif + +.PHONY: all + +ifneq($(GPP),) + all: predict +# allow for compilation to fail even if there is a compiler to hand + predict: main.cpp predictor.cpp format.cpp knn.cpp nbayes.cpp rforest.cpp tfidf.cpp dtree.cpp - g++-4.8 -std=c++11 -g -Wall $< -o $@ + -$(GPP) -std=c++11 -Wall $< -o $@ + +predict.debug: main.cpp predictor.cpp format.cpp knn.cpp nbayes.cpp rforest.cpp tfidf.cpp dtree.cpp + -$(GPP) -std=c++11 -Wall -g $< -o $@ + +else + +all: + @echo "*** Holyhammer does not build -- no C++ compiler" -clean: - rm -f predict +endif diff --git a/src/holyhammer/predict/mepo/.gitignore b/src/holyhammer/predict/mepo/.gitignore new file mode 100644 index 0000000000..52b895f76d --- /dev/null +++ b/src/holyhammer/predict/mepo/.gitignore @@ -0,0 +1,2 @@ +mepo3 +geo From b5c2c1efd42508d01d67b4a3afa14160ba1752cb Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 4 Aug 2015 11:38:58 +0200 Subject: [PATCH 391/718] Get comparelogs developer tool to build with Poly Drop dependency on mlton --- developers/Holmakefile | 14 ++- developers/comparelogs.sml | 164 ++++++++++++++++--------------- developers/mosml-comparelogs.sml | 1 + developers/poly-comparelogs.ML | 6 ++ 4 files changed, 102 insertions(+), 83 deletions(-) create mode 100644 developers/mosml-comparelogs.sml create mode 100644 developers/poly-comparelogs.ML diff --git a/developers/Holmakefile b/developers/Holmakefile index 90233b779a..c8d021133b 100644 --- a/developers/Holmakefile +++ b/developers/Holmakefile @@ -8,8 +8,18 @@ mosml-comparelogs : mosmlTextIO.ui comparelogs.sml mosmlTextIO.ui mosmlTextIO.uo: mosmlTextIO.sml $(MOSMLC) -toplevel $< -comparelogs: comparelogs.sml $(MLTON_SRCS) - mlton comparelogs.mlb +ifdef POLY + +comparelogs: poly-comparelogs.ML comparelogs.sml + poly < $< + gcc -o $@ comparelogs.o $(POLY_LDFLAGS) + +else + +comparelogs: comparelogs.uo + $(MOSML) -o $< $@ + +endif poly_gbsdep = generateBuildSummary.o mosml_gbsdep = mosmlgbs.uo generateBuildSummary.uo diff --git a/developers/comparelogs.sml b/developers/comparelogs.sml index e739ed7029..51096a8c4d 100644 --- a/developers/comparelogs.sml +++ b/developers/comparelogs.sml @@ -3,7 +3,6 @@ val theory_width = 30 structure Process = OS.Process -val args0 = CommandLine.arguments() fun die s = (TextIO.output(TextIO.stdErr, s ^ "\n"); Process.exit Process.failure) @@ -13,39 +12,34 @@ fun mkquiet {bequiet, diffsort, files} = fun mkdiff {bequiet, diffsort, files} = {bequiet = bequiet, diffsort = true, files = files} -val usage_msg = - "Usage:\n " ^ CommandLine.name() ^ " file1 file2 ... filen\n\n" ^ +fun usage_msg appname = + "Usage:\n " ^ appname ^ " file1 file2 ... filen\n\n" ^ "Options:\n\ \ -d Sort results in order of the differences (only with two files)\n\ \ -q Print raw data only, no sums, or fancy lines; (output to other tools)\n\ \ -h Show this help message\n\ \ -? Show this help message\n" -fun show_usage() = (print usage_msg; Process.exit Process.success) +fun show_usage appname = + (print (usage_msg appname); Process.exit Process.success) -fun getargs args = - case args of - [] => {bequiet = false, diffsort = false, files = []} - | "-q" :: rest => mkquiet (getargs rest) - | "-d" :: rest => mkdiff (getargs rest) - | "-h" :: _ => show_usage() - | "-?" :: _ => show_usage() - | _ => {bequiet = false, diffsort = false, files = args} - -val {bequiet,diffsort,files = args} = getargs args0 - -val _ = if null args then die "Must specify at least one file to \"analyse\"" - else () - -val _ = if length args <> 2 andalso diffsort then - die "-d option not appropriate when #files <> 2" - else () - -val base = hd args +fun getargs appname args = + let + fun recurse args = + case args of + [] => {bequiet = false, diffsort = false, files = []} + | "-q" :: rest => mkquiet (recurse rest) + | "-d" :: rest => mkdiff (recurse rest) + | "-h" :: _ => show_usage appname + | "-?" :: _ => show_usage appname + | _ => {bequiet = false, diffsort = false, files = args} + in + recurse args + end -fun print_dashes () = - (print (StringCvt.padLeft #"-" (15 * length args + theory_width) ""); +fun print_dashes n = + (print (StringCvt.padLeft #"-" (15 * n + theory_width) ""); print "\n") fun read_file (fname,m) = let @@ -68,36 +62,11 @@ in recurse m before TextIO.closeIn instr end -val final_map = List.foldl read_file (Binarymap.mkDict String.compare) args - fun lookup m fname thy = case Binarymap.peek(m, fname) of NONE => NONE | SOME m' => Binarymap.peek(m', thy) -val base_theories = - map #1 (Binarymap.listItems (Binarymap.find(final_map, base))) - handle NotFound => die ("No data in base file: "^hd args) - -val base_theories = - if diffsort then let - val [file1, file2] = args - fun nzero NONE = 0.0 - | nzero (SOME r) = r - fun get f thy = nzero (lookup final_map f thy) - fun compare (thy1, thy2) = let - val t11 = get file1 thy1 - val t12 = get file1 thy2 - val t21 = get file2 thy1 - val t22 = get file2 thy2 - in - Real.compare (t21 - t11, t22 - t12) - end - in - Listsort.sort compare base_theories - end - else base_theories - fun fmt_fname s = let val s' = if size s > 14 then String.extract(s, size s - 14, NONE) else s in @@ -111,15 +80,7 @@ in end fun fmt_real r = centered25 (Real.fmt (StringCvt.FIX (SOME 3)) r) - -val _ = if not bequiet then - (print (StringCvt.padLeft #" " theory_width ""); - app (print o fmt_fname) args; - print "\n"; - print_dashes()) - else () - -fun print_line m thyname = let +fun print_line m args thyname = let open StringCvt fun print_entry fname = case lookup m fname thyname of @@ -131,33 +92,74 @@ in print "\n" end -val _ = app (print_line final_map) base_theories +fun print_entry total_map fname = let + open StringCvt +in + print (fmt_real (Binarymap.find(total_map, fname))) +end -fun calc_totals m = let - fun calc_file (fname, m0) = let - fun foldthis (thy, subtot) = let - val r = case lookup m fname thy of NONE => 0.0 | SOME v => v +fun main() = let + val args0 = CommandLine.arguments() + val {bequiet,diffsort,files = args} = getargs (CommandLine.name()) args0 + + val _ = if null args then die "Must specify at least one file to \"analyse\"" + else () + + val _ = if length args <> 2 andalso diffsort then + die "-d option not appropriate when #files <> 2" + else () + val base = hd args + val final_map = List.foldl read_file (Binarymap.mkDict String.compare) args + val base_theories = + map #1 (Binarymap.listItems (Binarymap.find(final_map, base))) + handle NotFound => die ("No data in base file: "^hd args) + val base_theories = + if diffsort then let + val [file1, file2] = args + fun nzero NONE = 0.0 + | nzero (SOME r) = r + fun get f thy = nzero (lookup final_map f thy) + fun compare (thy1, thy2) = let + val t11 = get file1 thy1 + val t12 = get file1 thy2 + val t21 = get file2 thy1 + val t22 = get file2 thy2 + in + Real.compare (t21 - t11, t22 - t12) + end + in + Listsort.sort compare base_theories + end + else base_theories + fun calc_totals m = let + fun calc_file (fname, m0) = let + fun foldthis (thy, subtot) = let + val r = case lookup m fname thy of NONE => 0.0 | SOME v => v + in + subtot + r + end in - subtot + r + Binarymap.insert(m0, fname, List.foldl foldthis 0.0 base_theories) end in - Binarymap.insert(m0, fname, List.foldl foldthis 0.0 base_theories) + List.foldl calc_file (Binarymap.mkDict String.compare) args end -in - List.foldl calc_file (Binarymap.mkDict String.compare) args -end -val total_map = calc_totals final_map -fun print_entry fname = let - open StringCvt -in - print (fmt_real (Binarymap.find(total_map, fname))) -end + val _ = if not bequiet then + (print (StringCvt.padLeft #" " theory_width ""); + app (print o fmt_fname) args; + print "\n"; + print_dashes (length args)) + else () + val _ = app (print_line final_map args) base_theories -val _ = if not bequiet then - (print_dashes(); - print (StringCvt.padRight #" " theory_width "Total"); - app print_entry args; - print "\n") - else () + val total_map = calc_totals final_map +in + if not bequiet then + (print_dashes (length args); + print (StringCvt.padRight #" " theory_width "Total"); + app (print_entry total_map) args; + print "\n") + else () +end diff --git a/developers/mosml-comparelogs.sml b/developers/mosml-comparelogs.sml new file mode 100644 index 0000000000..dcfa4ff7da --- /dev/null +++ b/developers/mosml-comparelogs.sml @@ -0,0 +1 @@ +val _ = comparelogs.main() diff --git a/developers/poly-comparelogs.ML b/developers/poly-comparelogs.ML new file mode 100644 index 0000000000..86420a1515 --- /dev/null +++ b/developers/poly-comparelogs.ML @@ -0,0 +1,6 @@ +use "mlton-srcs/Binarymap.sml"; +use "mlton-srcs/Listsort.sml"; +use "comparelogs.sml"; + +val _ = PolyML.shareCommonData main; +val _ = PolyML.export ("comparelogs", main); From 71f0d722c69879c8e759a79451d934b16eeb8147 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 4 Aug 2015 12:59:43 +0200 Subject: [PATCH 392/718] More minor Holmakefile fixes in HOLyhammer - Can't use clean: target in Holmakefile; must instead use EXTRA_CLEANS variable. - Allow compilation of mepo and geo to fail without causing Holmake to report a failure. In this way build won't give up on building the rest of the system --- src/holyhammer/predict/mepo/Holmakefile | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/src/holyhammer/predict/mepo/Holmakefile b/src/holyhammer/predict/mepo/Holmakefile index 8e8924a4e3..2dcb458296 100644 --- a/src/holyhammer/predict/mepo/Holmakefile +++ b/src/holyhammer/predict/mepo/Holmakefile @@ -1,10 +1,11 @@ +.PHONY: all + all: geo mepo3 -mepo3: - g++ -std=c++0x mepo3.cpp -o mepo3 +mepo3: mepo3.cpp formatnow.cpp + -g++ -std=c++0x mepo3.cpp -o mepo3 -geo: - g++ -std=c++0x geo.cpp -o geo +geo: geo.cpp format.cpp + -g++ -std=c++0x geo.cpp -o geo -clean: - rm -f mepo3 geo +EXTRA_CLEANS = mepo3 geo From 70ae472504caf1d19de46d1c56ddf3fc857dc87c Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Wed, 5 Aug 2015 08:50:14 +0400 Subject: [PATCH 393/718] add some release notes for gen_new_specification --- doc/next-release.md | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/doc/next-release.md b/doc/next-release.md index 0ad0579e6c..0c91809c4c 100644 --- a/doc/next-release.md +++ b/doc/next-release.md @@ -24,6 +24,11 @@ New features: - The tactic `PAT_ABBREV_TAC` (also available in the `Q` module) can now use patterns that are more polymorphic than the sub-term in the goal that is ultimately matched. ([Github issue](http://github.com/HOL-Theorem-Prover/HOL/issues/252)) +- We have implemented the rule for constant specification described by Rob Arthan in [HOL Constant Definition Done Right](http://www.lemma-one.com/papers/hcddr.pdf). + The new primitive `gen_prim_specification` in the kernel is used to implement the new rule, `gen_new_specification`, and is also used to re-implement `new_definition` and `new_specification`. + We removed `prim_constant_definition` from the kernel, but kept `prim_specification` because the new derivation of `new_specification` uses pairs. + ([Github pull-req](https://github.com/HOL-Theorem-Prover/HOL/pull/201)) + Bugs fixed: ----------- From 1ab5ef6508b596eaf5de33b250faab80b694bf6e Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 5 Aug 2015 11:31:32 +0200 Subject: [PATCH 394/718] Get holyhammer to build with Moscow ML. * It needs to come after metis in the build sequence because it refers to metisLib. * Various signatures needed to have 'include Abbrev' added * Record type inference differs slightly under the two systems; now one place where it makes a difference has some typing information added --- src/holyhammer/hhReconstruct.sig | 1 + src/holyhammer/hhWriter.sig | 1 + src/holyhammer/hhWriter.sml | 4 +++- src/holyhammer/holyHammer.sml | 2 +- tools/build-sequence | 1 - tools/sequences/core-theories | 1 + 6 files changed, 7 insertions(+), 3 deletions(-) diff --git a/src/holyhammer/hhReconstruct.sig b/src/holyhammer/hhReconstruct.sig index 7e70635266..6675d46f08 100644 --- a/src/holyhammer/hhReconstruct.sig +++ b/src/holyhammer/hhReconstruct.sig @@ -1,6 +1,7 @@ signature hhReconstruct = sig + include Abbrev val minimize_flag : bool ref val reconstruct : thm list -> (string * string) -> term -> unit val reconstructl : thm list -> (string * string) list -> term -> unit diff --git a/src/holyhammer/hhWriter.sig b/src/holyhammer/hhWriter.sig index 16999e9b37..988c77e256 100644 --- a/src/holyhammer/hhWriter.sig +++ b/src/holyhammer/hhWriter.sig @@ -1,6 +1,7 @@ signature hhWriter = sig + include Abbrev val thm_of_depid : Dep.depid -> (string * Thm.thm) val write_hh_thyl : string -> string list -> unit diff --git a/src/holyhammer/hhWriter.sml b/src/holyhammer/hhWriter.sml index 8f69fffa66..d2c2bb9aa4 100644 --- a/src/holyhammer/hhWriter.sml +++ b/src/holyhammer/hhWriter.sml @@ -252,8 +252,10 @@ fun oty ty = else (os ("(" ^ s ^ " "); oiter " " oty Args; os ")") end end +type ('a,'b)substp = {redex : 'a, residue : 'b} val less_ty = fn a => (fn b => Type.compare (a,b) = LESS) -fun less_red a b = less_ty (#redex a) (#redex b) +fun less_red (a:(hol_type,'a)substp) (b:(hol_type,'b)substp) = + less_ty (#redex a) (#redex b) fun id_subst a = {redex = a, residue = a} fun full_match_type t1 t2 = diff --git a/src/holyhammer/holyHammer.sml b/src/holyhammer/holyHammer.sml index 62a2974d83..50545ecab0 100644 --- a/src/holyhammer/holyHammer.sml +++ b/src/holyhammer/holyHammer.sml @@ -13,7 +13,7 @@ structure holyHammer :> holyHammer = struct -open hhWriter hhReconstruct +open HolKernel boolLib hhWriter hhReconstruct val ERR = mk_HOL_ERR "holyHammer" diff --git a/tools/build-sequence b/tools/build-sequence index 30ae16d041..96983393c5 100644 --- a/tools/build-sequence +++ b/tools/build-sequence @@ -52,7 +52,6 @@ # (the directory containing this file). #include sequences/kernel -#include sequences/holyhammer #include sequences/core-theories #include sequences/more-theories #include sequences/large-theories diff --git a/tools/sequences/core-theories b/tools/sequences/core-theories index b363cf6dde..746dfff5b7 100644 --- a/tools/sequences/core-theories +++ b/tools/sequences/core-theories @@ -10,6 +10,7 @@ src/lite src/refute src/simp/src src/metis +#include sequences/holyhammer src/meson/src src/IndDef src/basicProof From 8dfb03107f21affcf44204faa4975ac83cbdab3c Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Sat, 8 Aug 2015 19:45:20 +1000 Subject: [PATCH 395/718] Make new_definition_hook replace a constant on the LHS by a variable new_definition calls gen_prim_specification which requires an equation whose left-hand side is a variable, but sometimes (maybe only in obscure old example script files) users pass an equation with a constant on the left. The same hook that abstracts arguments now turns a constant on the left into a variable. --- src/1/boolSyntax.sml | 1 + src/pair/src/pairScript.sml | 1 + src/postkernel/Theory.sml | 4 +--- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/1/boolSyntax.sml b/src/1/boolSyntax.sml index 4ae97567be..238e9c1e1f 100644 --- a/src/1/boolSyntax.sml +++ b/src/1/boolSyntax.sml @@ -269,6 +269,7 @@ fun dest t = let val (lhs, rhs) = dest_eq (snd (strip_forall t)) val (f, args) = strip_comb lhs + val f = mk_var(dest_const f) handle HOL_ERR _ => f in if all is_var args then (args, mk_eq (f, list_mk_abs (args, rhs))) diff --git a/src/pair/src/pairScript.sml b/src/pair/src/pairScript.sml index e1adada14a..54dfeaeb3a 100644 --- a/src/pair/src/pairScript.sml +++ b/src/pair/src/pairScript.sml @@ -810,6 +810,7 @@ NL(); S "fun dest t = "; NL(); S " let val (lhs,rhs) = dest_eq (snd(strip_forall t))"; NL(); S " val (f,args) = strip_comb lhs"; NL(); +S " val f = mk_var(dest_const f) handle HOL_ERR _ => f"; NL(); S " in "; NL(); S " case filter (not o is_vstruct) args "; NL(); S " of [] => (case joint_vars (map free_vars args)"; NL(); diff --git a/src/postkernel/Theory.sml b/src/postkernel/Theory.sml index c51c35596d..145dca90ea 100644 --- a/src/postkernel/Theory.sml +++ b/src/postkernel/Theory.sml @@ -1020,8 +1020,6 @@ val DEF_FORM_ERR = DEF_ERR "expected a term of the form \"v = M\""; operations until after boolTheory is built. ---------------------------------------------------------------------------*) -fun dest_atom tm = (dest_var tm handle HOL_ERR _ => dest_const tm) - fun mk_exists (absrec as (Bvar,_)) = mk_comb(mk_thy_const{Name="?",Thy="bool", Ty= (type_of Bvar-->bool)-->bool}, mk_abs absrec) @@ -1114,7 +1112,7 @@ fun gen_new_specification(name, th) = let fun new_definition(name,M) = let val (dest,post) = !new_definition_hook val (V,eq) = dest M - val (nm, _) = eq |> dest_eq |> #1 |> dest_atom + val (nm, _) = eq |> dest_eq |> #1 |> dest_var handle HOL_ERR _ => raise ERR "Definition.new_definition" "Definition not an equality" From 1ab56460a81212804f7567cd318a25e53775af5a Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 11 Aug 2015 21:33:03 +1000 Subject: [PATCH 396/718] Example: define type of hierarchically finite sets --- examples/hfs/hfsScript.sml | 275 ++++++++++++++++++++++++++++++++++ tools/sequences/more-theories | 1 + 2 files changed, 276 insertions(+) create mode 100644 examples/hfs/hfsScript.sml diff --git a/examples/hfs/hfsScript.sml b/examples/hfs/hfsScript.sml new file mode 100644 index 0000000000..58e23a6211 --- /dev/null +++ b/examples/hfs/hfsScript.sml @@ -0,0 +1,275 @@ +(* Define the type of hierarchically finite sets. + + Single (recursive) constructor is + + fromSet : hfs set -> hfs + + where the set must be finite. (Perhaps an argument to have a finite set + type in the core distribution?) + + Because there is just one constructor, there is a total inverse to + fromSet, called toSet + + toSet : hfs -> hfs set + + where we have + + fromSet (toSet h) = h + + Future work: + - define empty hfs value + - define other operations such as insert, intersection, union and + cardinality + - prove induction principle + - prove recursion principle + + The type is defined via a cute bijection (due to Ackermann + according to Wikipedia) with the natural numbers. + + Inspired to do this by Larry Paulson's talk about using h.f. sets + as part of a mechanisation of automata theory at CADE 2015. There (in + Isabelle/HOL), the type definition mechanism can create the type + directly so the Ackermann bijection is not required. +*) + +open HolKernel Parse boolLib bossLib; + +open lcsymtacs +open pred_setTheory + +val _ = new_theory "hfs"; + +val _ = ParseExtras.tight_equality() + +val _ = temp_overload_on ("mk", ``SUM_IMAGE ((EXP) 2)``) + +val numeq_wlog = prove( + ``∀P. (∀n m. P n m ⇔ P m n) ∧ (∀n m. P n m ⇒ n ≤ m) ⇒ + (∀n m. P n m ⇒ (n = m))``, + metis_tac [DECIDE ``∀n m. n ≤ m ∧ m ≤ n ⇒ m = n``]); + +val strictly_increasing_SUC_extends = prove( + ``(∀n. f n < f (n + 1)) ⇒ (∀n m. n < m ⇒ f n < f m)``, + strip_tac >> Induct_on `m` >> simp[] >> rpt strip_tac >> + qcase_tac `n < SUC m` >> + `n = m ∨ n < m` by simp[] >> + simp[arithmeticTheory.ADD1] >> + metis_tac [DECIDE ``∀m n p. m < n ⇒ n < p ⇒ m < p``]); + +val strictly_increasing_injective = prove( + ``(∀n. f n < f (n + 1)) ⇒ ∀n1 n2. f n1 = f n2 ⇔ n1 = n2``, + simp[EQ_IMP_THM] >> rpt strip_tac >> + qspec_then `λn m. f n = f m` (irule o BETA_RULE) numeq_wlog >> + qexists_tac `f` >> simp[] >> spose_not_then strip_assume_tac >> + qcase_tac `¬(n ≤ m)` >> `m < n` by simp[] >> + `f m < f n` by metis_tac [strictly_increasing_SUC_extends] >> + metis_tac[DECIDE ``¬(x < x)``]); + +val strictly_increasing_nobounds = prove( + ``(∀n. f n < f (n + 1)) ⇒ ∀b. ∃n. b < f n``, + rpt strip_tac >> spose_not_then strip_assume_tac >> + qcase_tac `bnd < f _` >> + `∀n. f n ≤ bnd` by metis_tac[DECIDE ``¬(x < y) ⇒ y ≤ x``] >> + `∀n m. f n = f m ⇔ n = m` by metis_tac[strictly_increasing_injective] >> + `INJ f (count (bnd + 2)) (count (bnd + 1))` + by simp[INJ_DEF, DECIDE ``x < y + 1 ⇔ x ≤ y``] >> + `FINITE (count (bnd + 1))` by simp[] >> + `CARD (count (bnd + 1)) < CARD (count (bnd + 2))` by simp[] >> + metis_tac[PHP]); + +val TWO_EXP_BOUNDS = prove( + ``∀n. ∃j. n < 2 ** j``, + match_mp_tac strictly_increasing_nobounds >> simp[arithmeticTheory.EXP_ADD]); + +val bound_exists = prove( + ``∀n. n < 2 ** (LEAST m. n < 2 ** m) ∧ + ∀p. p < (LEAST m. n < 2 ** m) ⇒ 2 ** p ≤ n``, + qx_gen_tac `n` >> + qspec_then `λm. n < 2 ** m` + (match_mp_tac o SIMP_RULE (srw_ss()) [arithmeticTheory.NOT_LESS]) + whileTheory.LEAST_EXISTS_IMP >> + metis_tac[TWO_EXP_BOUNDS]); + +val mk_minimum = prove( + ``∀s. FINITE s ⇒ ∀j. j ∈ s ⇒ 2 ** j ≤ mk s``, + ho_match_mp_tac FINITE_INDUCT >> simp[] >> + dsimp[SUM_IMAGE_THM, DELETE_NON_ELEMENT_RWT] >> + rpt strip_tac >> res_tac >> simp[]); + +val mk_onto = prove( + ``∀n. ∃s. FINITE s ∧ mk s = n``, + completeInduct_on `n` >> + qspec_then `n` strip_assume_tac bound_exists >> + qabbrev_tac `m = LEAST m. n < 2 EXP m` >> + Cases_on `m = 0` + >- (fs[] >> `n = 0` by simp[] >> qexists_tac `∅` >> + simp[SUM_IMAGE_THM]) >> + `m - 1 < m` by simp[] >> + `2 ** (m - 1) ≤ n` by simp[] >> + qabbrev_tac `M = 2 ** (m - 1)` >> + `0 < M` by simp[Abbr`M`] >> + `n - M < n` by simp[] >> + `∃s0. FINITE s0 ∧ mk s0 = n - M` by metis_tac[] >> + qexists_tac `(m - 1) INSERT s0` >> + simp[SUM_IMAGE_THM] >> + Cases_on `m - 1 ∈ s0` + >- (`M ≤ mk s0` by metis_tac[mk_minimum] >> + `2 * M ≤ n` by simp[] >> + `2 * M = 2 ** m` suffices_by simp[] >> + simp[Abbr`M`] >> fs[GSYM arithmeticTheory.EXP] >> + `SUC (m - 1) = m` by simp[] >> lfs[]) >> + simp[DELETE_NON_ELEMENT_RWT]); + +val split_sets = prove( + ``s1 = (s1 ∩ s2) ∪ (s1 DIFF s2)``, + simp[EXTENSION] >> metis_tac[]); + +val DISJOINT_DIFF = prove( + ``DISJOINT (s1 DIFF s2) (s2 DIFF s1)``, + simp[DISJOINT_DEF, EXTENSION] >> metis_tac[]); + +val DIFF_NONEMPTY = prove( + ``s1 ≠ s2 ⇔ s1 DIFF s2 ≠ ∅ ∨ s2 DIFF s1 ≠ ∅``, + simp[EXTENSION] >> metis_tac[]); + +val disjoint_inequal_has_maximum = prove( + ``FINITE s1 ∧ FINITE s2 ∧ DISJOINT s1 s2 ∧ s1 ≠ s2 ⇒ + (∃m. m ∈ s1 ∧ (∀n. n ∈ s2 ⇒ n < m)) ∨ + (∃m. m ∈ s2 ∧ (∀n. n ∈ s1 ⇒ n < m))``, + Cases_on `s1 = ∅` + >- (simp[] >> strip_tac >> + `∃m s0. s2 = m INSERT s0` by metis_tac[SET_CASES] >> dsimp[]) >> + Cases_on `s2 = ∅` >> simp[] + >- (`∃m s0. s1 = m INSERT s0` by metis_tac[SET_CASES] >> dsimp[]) >> + qabbrev_tac `m1 = MAX_SET s1` >> + qabbrev_tac `m2 = MAX_SET s2` >> + strip_tac >> + `m1 ∈ s1 ∧ (∀a. a ∈ s1 ⇒ a ≤ m1) ∧ m2 ∈ s2 ∧ (∀b. b ∈ s2 ⇒ b ≤ m2)` + by metis_tac[MAX_SET_DEF] >> + Cases_on `m1 < m2` + >- (disj2_tac >> qexists_tac `m2` >> simp[] >> rpt strip_tac >> res_tac >> + simp[]) >> + disj1_tac >> qexists_tac `m1` >> simp[] >> rpt strip_tac >> + `m1 ≠ m2` by (strip_tac >> fs[DISJOINT_DEF, EXTENSION] >> metis_tac[]) >> + res_tac >> simp[]); + +val topdown_induct = prove( + ``P ∅ ∧ + (∀e s0. P s0 ∧ e ∉ s0 ∧ (∀n. n ∈ s0 ⇒ n < e) ∧ FINITE s0 ⇒ + P (e INSERT s0)) ⇒ + (∀s. FINITE s ⇒ P s)``, + strip_tac >> gen_tac >> Induct_on `CARD s` + >- (rpt strip_tac >> `s = ∅` by metis_tac[CARD_EQ_0] >> simp[]) >> + rpt strip_tac >> `s ≠ ∅` by (strip_tac >> fs[]) >> + qabbrev_tac `M = MAX_SET s` >> + `M ∈ s ∧ ∀n. n ∈ s ⇒ n ≤ M` by metis_tac[MAX_SET_DEF] >> + `s = M INSERT (s DELETE M)` by metis_tac[INSERT_DELETE] >> + qabbrev_tac `s0 = s DELETE M` >> + `M ∉ s0 ∧ FINITE s0` by simp[Abbr`s0`] >> + qcase_tac `SUC n = CARD s` >> + `CARD s = SUC (CARD s0)` by simp[] >> + `n = CARD s0` by simp[] >> + `P s0` by metis_tac[] >> + `∀n. n ∈ s0 ⇒ n < M` + by (fs[] >> metis_tac[DECIDE ``x ≤ y ∧ x ≠ y ⇒ x < y``]) >> + metis_tac[]); + +val mk_upper_bound = prove( + ``∀s. FINITE s ⇒ ∀b. (∀n. n ∈ s ⇒ n < b) ⇒ mk s < 2 ** b``, + ho_match_mp_tac topdown_induct >> + dsimp[SUM_IMAGE_THM, DELETE_NON_ELEMENT_RWT] >> rpt strip_tac >> + qcase_tac `e ∉ s` >> + `mk s < 2 ** e` by metis_tac[] >> + qcase_tac `e < b` >> + `∃d. b = SUC d + e` by metis_tac[arithmeticTheory.LESS_STRONG_ADD] >> + simp[arithmeticTheory.EXP_ADD, arithmeticTheory.EXP] >> + match_mp_tac arithmeticTheory.LESS_LESS_EQ_TRANS >> + qexists_tac `2 * 2 ** e` >> simp[]); + +val mk_11 = prove( + ``FINITE s1 ∧ FINITE s2 ⇒ (mk s1 = mk s2 ⇔ s1 = s2)``, + simp[EQ_IMP_THM] >> rpt strip_tac >> + spose_not_then strip_assume_tac >> + qabbrev_tac `c = s1 ∩ s2` >> + qabbrev_tac `t1 = s1 DIFF s2` >> + qabbrev_tac `t2 = s2 DIFF s1` >> + `s1 = c ∪ t1 ∧ s2 = c ∪ t2` by metis_tac[split_sets, INTER_COMM] >> + `FINITE c ∧ FINITE t1 ∧ FINITE t2` by simp[Abbr`c`, Abbr`t1`, Abbr`t2`] >> + `c ∩ t1 = ∅ ∧ c ∩ t2 = ∅` + by (simp[Abbr`c`, Abbr`t1`, Abbr`t2`, EXTENSION] >> metis_tac[]) >> + `mk s1 = mk c + mk t1 ∧ mk s2 = mk c + mk t2` + by (rpt BasicProvers.VAR_EQ_TAC >> + Q.UNDISCH_THEN `mk (c ∪ t1) = mk (c ∪ t2)` kall_tac >> + simp[SUM_IMAGE_UNION, SUM_IMAGE_THM]) >> + `mk t1 = mk t2` by simp[] >> + `DISJOINT t1 t2` by metis_tac[DISJOINT_DIFF] >> + `t1 ≠ t2` by metis_tac[] >> + `(∃m1. m1 ∈ t1 ∧ (∀n. n ∈ t2 ⇒ n < m1)) ∨ + (∃m2. m2 ∈ t2 ∧ (∀n. n ∈ t1 ⇒ n < m2))` + by metis_tac[disjoint_inequal_has_maximum] + >- (`mk t2 < 2 ** m1` by metis_tac[mk_upper_bound] >> + `2 ** m1 ≤ mk t1` by metis_tac[mk_minimum] >> lfs[]) >> + `mk t1 < 2 ** m2` by metis_tac[mk_upper_bound] >> + `2 ** m2 ≤ mk t2` by metis_tac[mk_minimum] >> lfs[]) + +val mk_BIJ = prove( + ``BIJ mk {s | FINITE s} univ(:num)``, + simp[BIJ_DEF, INJ_DEF, SURJ_DEF, mk_11, mk_onto]); + +val hfs = new_type_definition( + "hfs", + prove(``?x:num. (\x. T) x``, simp[])) + +val HFS_TYBIJ = + define_new_type_bijections { ABS = "mkHFS", REP = "destHFS", + name = "HFS_TYBIJ", tyax = hfs} + |> SIMP_RULE (srw_ss()) [] + +val mkHFS_11 = store_thm( + "mkHFS_11[simp]", + ``mkHFS n1 = mkHFS n2 ⇔ n1 = n2``, + metis_tac[HFS_TYBIJ]); + +val destHFS_11 = store_thm( + "destHFS_11[simp]", + ``destHFS h1 = destHFS h2 ⇔ h1 = h2``, + metis_tac[HFS_TYBIJ]); + +val toSet_def = Define` + toSet hfs = IMAGE mkHFS (LINV mk { s | FINITE s } (destHFS hfs)) +`; + +val LINV_mk_11 = store_thm( + "LINV_mk_11[simp]", + ``LINV mk {s | FINITE s} x = LINV mk {s | FINITE s} y ⇔ x = y``, + `BIJ (LINV mk {s | FINITE s}) univ(:num) { s | FINITE s}` + by simp[BIJ_LINV_BIJ, mk_BIJ] >> + fs[BIJ_DEF, INJ_DEF, EQ_IMP_THM]); + +val toSet_11 = store_thm( + "toSet_11[simp]", + ``toSet h1 = toSet h2 ⇔ h1 = h2``, + simp[toSet_def, IMAGE_11]); + +val FINITE_toSet = store_thm( + "FINITE_toSet[simp]", + ``FINITE (toSet h)``, + simp[toSet_def] >> + `BIJ (LINV mk {s | FINITE s}) univ(:num) { s | FINITE s}` + by simp[BIJ_LINV_BIJ, mk_BIJ] >> + fs[BIJ_DEF, INJ_DEF]); + +val fromSet_def = Define` + fromSet s = mkHFS (mk (IMAGE destHFS s)) +`; + +val fromSet_toSet = store_thm( + "fromSet_toSet", + ``fromSet (toSet h) = h``, + simp[fromSet_def, toSet_def] >> simp[GSYM IMAGE_COMPOSE] >> + simp[combinTheory.o_DEF, HFS_TYBIJ] >> + strip_assume_tac (MATCH_MP BIJ_LINV_INV mk_BIJ) >> fs[HFS_TYBIJ]); + +val _ = hide "mk" + +val _ = export_theory(); diff --git a/tools/sequences/more-theories b/tools/sequences/more-theories index d6b83c6012..66d261f566 100644 --- a/tools/sequences/more-theories +++ b/tools/sequences/more-theories @@ -42,3 +42,4 @@ src/hol88 !src/quotient/examples/sigma src/rational src/datatype/inftree +!examples/hfs From f0f324ada005d2956e99f578acdd032b151b4401 Mon Sep 17 00:00:00 2001 From: Brian Campbell Date: Wed, 12 Aug 2015 15:57:53 +0100 Subject: [PATCH 397/718] Update handling of case constants for Yices in HolSmt --- src/HolSmt/Yices.sml | 113 ++++++++++++++++++++++--------------------- 1 file changed, 57 insertions(+), 56 deletions(-) diff --git a/src/HolSmt/Yices.sml b/src/HolSmt/Yices.sml index 93c1a40d89..3284f5336b 100644 --- a/src/HolSmt/Yices.sml +++ b/src/HolSmt/Yices.sml @@ -544,64 +544,65 @@ structure Yices = struct is still missing. *) (* case constants for data types (+ arguments) *) - (if List.null rands then - raise Feedback.mk_HOL_ERR "Yices" "translate_term" - "not a case constant (no operands)" - else - let val (cases, elem) = Lib.front_last rands - val data_ty = Term.type_of elem - in - case TypeBase.fetch data_ty of - SOME tyinfo => - if Term.same_const rator (TypeBasePure.case_const_of tyinfo) - then - let (* constructors *) - val cs = TypeBasePure.constructors_of tyinfo - val _ = if List.length cs = List.length cases then () - else - raise Feedback.mk_HOL_ERR "Yices" "translate_term" - "not a case constant (wrong number of cases)" - (* translate argument terms *) - val (acc, yices_cases) = Lib.foldl_map translate_term - (acc, cases) - val (acc, yices_elem) = translate_term (acc, elem) - val (_, _, ty_dict, _, _) = acc - val ty_name = Redblackmap.find (ty_dict, data_ty) - (* recognizers, accessors *) - val cs = List.map (List.length o Lib.fst o - boolSyntax.strip_fun o Term.type_of) cs - val (_, cs) = Lib.foldl_map (fn (i, n) => - let val cname = "c_" ^ ty_name ^ "_" ^ Int.toString i - fun aname j = - "a_" ^ ty_name ^ "_" ^ Int.toString i ^ "_" ^ - Int.toString j - val anames = List.tabulate (n, aname) - in - (i + 1, (cname, anames)) - end) (0, cs) - (* build the cascaded ite expression *) - val mk_case = List.foldl (fn (aname, yices_case) => - "(" ^ yices_case ^ " (" ^ aname ^ " " ^ yices_elem ^ - "))") - fun cascaded_ite [ycase] [(_, anames)] = - mk_case ycase anames - | cascaded_ite (ycase::ys) ((cname, anames)::cs) = - "(ite (" ^ cname ^ "? " ^ yices_elem ^ ") " ^ - mk_case ycase anames ^ " " ^ cascaded_ite ys cs ^ - ")" - | cascaded_ite _ _ = - raise Feedback.mk_HOL_ERR "Yices" "translate_term" - "not a case constant (error in cascaded_ite)" - in - (acc, cascaded_ite yices_cases cs) - end - else + let val (cases, elem) = + case rands of + [] => raise Feedback.mk_HOL_ERR "Yices" "translate_term" - "not a case constant (different constant)" - | NONE => + "not a case constant (no operands)" + | (h::t) => (t,h) + val data_ty = Term.type_of elem + in + case TypeBase.fetch data_ty of + SOME tyinfo => + if Term.same_const rator (TypeBasePure.case_const_of tyinfo) + then + let (* constructors *) + val cs = TypeBasePure.constructors_of tyinfo + val _ = if List.length cs = List.length cases then () + else + raise Feedback.mk_HOL_ERR "Yices" "translate_term" + "not a case constant (wrong number of cases)" + (* translate argument terms *) + val (acc, yices_cases) = Lib.foldl_map translate_term + (acc, cases) + val (acc, yices_elem) = translate_term (acc, elem) + val (_, _, ty_dict, _, _) = acc + val ty_name = Redblackmap.find (ty_dict, data_ty) + (* recognizers, accessors *) + val cs = List.map (List.length o Lib.fst o + boolSyntax.strip_fun o Term.type_of) cs + val (_, cs) = Lib.foldl_map (fn (i, n) => + let val cname = "c_" ^ ty_name ^ "_" ^ Int.toString i + fun aname j = + "a_" ^ ty_name ^ "_" ^ Int.toString i ^ "_" ^ + Int.toString j + val anames = List.tabulate (n, aname) + in + (i + 1, (cname, anames)) + end) (0, cs) + (* build the cascaded ite expression *) + val mk_case = List.foldl (fn (aname, yices_case) => + "(" ^ yices_case ^ " (" ^ aname ^ " " ^ yices_elem ^ + "))") + fun cascaded_ite [ycase] [(_, anames)] = + mk_case ycase anames + | cascaded_ite (ycase::ys) ((cname, anames)::cs) = + "(ite (" ^ cname ^ "? " ^ yices_elem ^ ") " ^ + mk_case ycase anames ^ " " ^ cascaded_ite ys cs ^ + ")" + | cascaded_ite _ _ = + raise Feedback.mk_HOL_ERR "Yices" "translate_term" + "not a case constant (error in cascaded_ite)" + in + (acc, cascaded_ite yices_cases cs) + end + else raise Feedback.mk_HOL_ERR "Yices" "translate_term" - "not a case constant (last argument is not a data type)" - end) + "not a case constant (different constant)" + | NONE => + raise Feedback.mk_HOL_ERR "Yices" "translate_term" + "not a case constant (last argument is not a data type)" + end handle Feedback.HOL_ERR _ => (* not a case constant *) (* record field selectors *) From 5602c99d59b45733dbc36c1f13409b5a2c053d64 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 13 Aug 2015 11:10:57 +1000 Subject: [PATCH 398/718] Make smtlib's prove functions quieter. They will still raise exceptions but they won't also print stuff to the screen. --- src/HolSmt/HolSmtLib.sml | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/HolSmt/HolSmtLib.sml b/src/HolSmt/HolSmtLib.sml index 0e57dfa630..8fe2cf0029 100644 --- a/src/HolSmt/HolSmtLib.sml +++ b/src/HolSmt/HolSmtLib.sml @@ -34,9 +34,10 @@ structure HolSmtLib :> HolSmtLib = struct val Z3_ORACLE_TAC = GENERIC_SMT_TAC Z3.Z3_SMT_Oracle val Z3_TAC = GENERIC_SMT_TAC Z3.Z3_SMT_Prover - fun YICES_PROVE tm = Tactical.prove (tm, YICES_TAC) - fun Z3_ORACLE_PROVE tm = Tactical.prove (tm, Z3_ORACLE_TAC) - fun Z3_PROVE tm = Tactical.prove (tm, Z3_TAC) + fun prove (tm, tac) = Tactical.TAC_PROOF(([], tm), tac) + fun YICES_PROVE tm = prove (tm, YICES_TAC) + fun Z3_ORACLE_PROVE tm = prove (tm, Z3_ORACLE_TAC) + fun Z3_PROVE tm = prove (tm, Z3_TAC) (* report whether solvers are available *) val _ = From b832f3fc7458e67b04e277dea60e93cad4012377 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 13 Aug 2015 11:11:35 +1000 Subject: [PATCH 399/718] Z3 solver won't attempt proof replay if version <> 2 --- src/HolSmt/Z3.sml | 27 ++++++++++++++++++++++++++- 1 file changed, 26 insertions(+), 1 deletion(-) diff --git a/src/HolSmt/Z3.sml b/src/HolSmt/Z3.sml index 75fc77f178..8c247e5020 100644 --- a/src/HolSmt/Z3.sml +++ b/src/HolSmt/Z3.sml @@ -44,8 +44,33 @@ structure Z3 = struct " -smt2 -file:" (Lib.K is_sat_file) + fun parse_Z3_version fname = + let + val instrm = TextIO.openIn fname + val s = TextIO.inputAll instrm before TextIO.closeIn instrm + in + List.last (String.tokens Char.isSpace s) + end + + val Z3version = + case OS.Process.getEnv "HOL4_Z3_EXECUTABLE" of + NONE => "0" + | SOME p => + let + val outfile = OS.FileSys.tmpName() + val _ = OS.Process.system (p ^ " -version > " ^ outfile) + in + parse_Z3_version outfile + end + + val doproofs = + if String.sub(Z3version, 0) = #"2" then true + else if String.sub(Z3version, 0) = #"0" then false + else + (Feedback.HOL_MESG ("Can't replay proofs with Z3 v"^Z3version); false) + (* Z3 (Linux/Unix), SMT-LIB file format, with proofs *) - val Z3_SMT_Prover = + val Z3_SMT_Prover = if not doproofs then Z3_SMT_Oracle else mk_Z3_fun "Z3_SMT_Prover" (fn goal => let From 8e4f09fba5672bffe783b35f530989ea07f933d3 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 13 Aug 2015 11:12:18 +1000 Subject: [PATCH 400/718] Prettify SmtLib's selftest; fix bug The now-deleted word example was perhaps being proved by earlier versions of Z3, but Z3 4.4.0 and HOL both reckon the example is false. (Depends on definition of signed modulus and -INT_MIN.) --- src/HolSmt/selftest.sml | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/src/HolSmt/selftest.sml b/src/HolSmt/selftest.sml index a2724f92af..9e8f95098a 100644 --- a/src/HolSmt/selftest.sml +++ b/src/HolSmt/selftest.sml @@ -2,7 +2,7 @@ (* Unit tests for HolSmtLib *) -val _ = print "Testing HolSmtLib " +val _ = print "Testing HolSmtLib\n" (*****************************************************************************) (* tracing/pretty-printing options useful for debugging *) @@ -25,10 +25,10 @@ val _ = Feedback.set_trace "HolSmtLib" 4 (*****************************************************************************) val _ = if Yices.is_configured () then () else - print "(Yices not configured, some tests will be skipped.) " + print "(Yices not configured, some tests will be skipped.)\n" val _ = if Z3.is_configured () then () else - print "(Z3 not configured, some tests will be skipped.) " + print "(Z3 not configured, some tests will be skipped.)\n" (*****************************************************************************) (* utility functions *) @@ -745,8 +745,10 @@ in [(*thm_AUTO, thm_YO,*)thm_Z3(*, thm_Z3p*)]), (``x:word8 < 0w /\ y >= 0w ==> (word_smod x y = -word_mod (-x) y + y)``, [(*thm_AUTO, thm_YO, thm_Z3, thm_Z3p*)]), +(* this is false: consider x = 99, y = 255 (``x:word8 >= 0w /\ y < 0w ==> (word_smod x y = word_mod x (-y) + y)``, [(*thm_AUTO, thm_YO,*)thm_Z3(*, thm_Z3p*)]), +*) (``x:word8 >= 0w /\ y >= 0w ==> (word_smod x y = word_mod x y)``, [(*thm_AUTO, thm_YO, thm_Z3, thm_Z3p*)]), From ce8624a0289f64a725fb9317d7dc2198800bfc16 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 13 Aug 2015 11:14:42 +1000 Subject: [PATCH 401/718] Omit (deliberately) bogus set-logic command. This causes Z3 4.4.0 to emit annoying warning message, and can't have any useful semantics. Yices v1 doesn't object if this is left out. Perhaps other solvers require a (set-logic) command, even if the specified logic doesn't exist. If so, we will have to pass parameters to selectively turn this text on or off. --- src/HolSmt/SmtLib.sml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/HolSmt/SmtLib.sml b/src/HolSmt/SmtLib.sml index 79464a9832..97d41f4f6c 100644 --- a/src/HolSmt/SmtLib.sml +++ b/src/HolSmt/SmtLib.sml @@ -542,7 +542,7 @@ local (fn ((xs, s), acc) => acc @ xs @ ["(assert " ^ s ^ ")\n"]) [] smtlibs in (acc, [ - "(set-logic AUFBVNIRA)\n", + (* "(set-logic AUFBVNIRA)\n", *) "(set-info :source |Automatically generated from HOL4 by SmtLib.goal_to_SmtLib.\n", "Copyright (c) 2011 Tjark Weber. All rights reserved.|)\n", "(set-info :smt-lib-version 2.0)\n" From 36ac337c8d0675fa52acfd7ca461cca5dd5eb4ce Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Thu, 13 Aug 2015 12:12:34 +1000 Subject: [PATCH 402/718] make new_specification more careful about existentials fixes #277 --- src/pair/src/pairLib.sml | 34 ++++++++++++++++++++++++++-------- 1 file changed, 26 insertions(+), 8 deletions(-) diff --git a/src/pair/src/pairLib.sml b/src/pair/src/pairLib.sml index 7473ec8be1..03c8d6938c 100644 --- a/src/pair/src/pairLib.sml +++ b/src/pair/src/pairLib.sml @@ -39,18 +39,37 @@ local f tm [] end - open Lib PairRules + val strip_n_exists = + let + fun f a n tm = + if n = 0 then (List.rev a,tm) + else let + val (x,tm) = dest_exists tm + in + f (x::a) (n-1) tm + end + in f [] end + + fun nconv 0 c = ALL_CONV + | nconv 1 c = c + | nconv n c = c THENC (nconv (n-1) c) + + open Lib PairRules pairSyntax in fun new_specification (name,cnames,th) = let + val n = List.length cnames in if n = 0 then + Theory.Definition.gen_new_specification (name,th) + else let val th1 = - (* this is not good enough since it doesn't guarantee the cnames will be used + (* CONV_RULE (RENAME_VARS_CONV cnames) th + is not good enough since it doesn't guarantee the cnames will be used - primed variants could be used if they clash with existing constant names - CONV_RULE (RENAME_VARS_CONV cnames) th *) + *) let val tm1 = concl th - val (vs1,body1) = strip_exists tm1 + val (vs1,body1) = strip_n_exists n tm1 val tys = map type_of vs1 val vs2 = map2 (curry mk_var) cnames tys val body2 = Term.subst (map2 (curry op |->) vs1 vs2) body1 @@ -58,9 +77,8 @@ local val th2 = ALPHA tm1 tm2 in EQ_MP th2 th end (* turn it into a single paired existential *) - val th2 = CONV_RULE (REPEATC UNCURRY_EXISTS_CONV) th1 - val (vs,body) = strip_pexists (concl th2) - val vs = case vs of [vs] => vs | _ => raise Match + val th2 = CONV_RULE (nconv (n-1) UNCURRY_EXISTS_CONV) th1 + val (vs,body) = dest_pexists (concl th2) val witness = mk_pselect (vs,body) val eqs = varstruct_to_eqs witness vs val th3 = CONV_RULE PEXISTS_CONV th2 @@ -69,7 +87,7 @@ local val th5 = List.foldl (Lib.uncurry ADD_ASSUM) th4 eqs in Theory.Definition.gen_new_specification (name,th5) - end + end end end From 3732a63e15e0d4fe9092ae81d57aa17891fa4e07 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Thu, 13 Aug 2015 16:40:42 +1000 Subject: [PATCH 403/718] add sefltest for #277 --- src/pair/src/selftest.sml | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/src/pair/src/selftest.sml b/src/pair/src/selftest.sml index 462f7e6f50..8344859e48 100644 --- a/src/pair/src/selftest.sml +++ b/src/pair/src/selftest.sml @@ -106,4 +106,21 @@ val _ = overload_on ("bar", ``\b. if b then T else F``) val _ = tpp "bar T" val _ = trace ("types", 1) tpp "if (b :bool) then (x :'a) else (y :'a)" +local open pairLib in +val _ = print "*** new_specification with existential definition\n" +val th = metisLib.METIS_PROVE[]``?x y z. x ==> z /\ z ==> y``; +val _ = tprint "Testing 0 constants" +val nothing_def = new_specification("nothing_def",[],th); +val _ = print "OK\n" +val _ = tprint "Testing 1 constant" +val a_def = new_specification("a_def",["a"],th); +val _ = print "OK\n" +val _ = tprint "Testing 2 constants" +val pq_def = new_specification("pq_def",["p","q"],th); +val _ = print "OK\n" +val _ = tprint "Testing 3 constants" +val rst_def = new_specification("rst_def",["r","s","t"],th); +val _ = print "OK\n" +end + val _ = Process.exit Process.success From 25e7f5eb963dcb6993157dca63019de55d97035f Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Thu, 13 Aug 2015 16:40:51 +1000 Subject: [PATCH 404/718] add Holmakefile for building selftest.exe in src/pair/src --- src/pair/src/Holmakefile | 7 +++++++ 1 file changed, 7 insertions(+) create mode 100644 src/pair/src/Holmakefile diff --git a/src/pair/src/Holmakefile b/src/pair/src/Holmakefile new file mode 100644 index 0000000000..ed3ee54f8d --- /dev/null +++ b/src/pair/src/Holmakefile @@ -0,0 +1,7 @@ +THYFILES = $(patsubst %Script.sml,%Theory.uo,$(wildcard *.sml)) +TARGETS = $(patsubst %.sml,%.uo,$(THYFILES)) + +all: $(TARGETS) selftest.exe + +selftest.exe: selftest.uo + $(HOLMOSMLC) -o $@ $< From d50646a7423a942cb2c443b158c198703ddf1c1b Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 14 Aug 2015 10:18:17 +1000 Subject: [PATCH 405/718] Trivial: remove redundant open decl in build.sml --- tools/build.sml | 2 -- 1 file changed, 2 deletions(-) diff --git a/tools/build.sml b/tools/build.sml index 5ec64875b4..6fc8fab385 100644 --- a/tools/build.sml +++ b/tools/build.sml @@ -7,8 +7,6 @@ struct structure Process = OS.Process -open buildutils - (* utilities *) (* ---------------------------------------------------------------------- From b3a2235c7cc5334c595c6b628ff5f651947570c4 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 14 Aug 2015 10:23:00 +1000 Subject: [PATCH 406/718] Get build to check for need to rebuild Holmake Previous behaviour was to look for things being fresher than the build executable, but if changes are made to the Holmake sources, then that executable should also be rebuilt. Thanks to Jeremy Dawson for bringing the issue to my attention. --- tools-poly/build.sml | 24 ++++++++++++++++++++---- tools/build.sml | 24 ++++++++++++++++++------ tools/buildutils.sig | 9 +++++++-- tools/buildutils.sml | 26 ++++++++++++++++++++++---- 4 files changed, 67 insertions(+), 16 deletions(-) diff --git a/tools-poly/build.sml b/tools-poly/build.sml index 8cdf08f1bf..404eab2b15 100644 --- a/tools-poly/build.sml +++ b/tools-poly/build.sml @@ -159,10 +159,26 @@ end Get rid of compiled code and dependency information. ---------------------------------------------------------------------------*) -val _ = check_against "tools-poly/smart-configure.sml" -val _ = check_against "tools-poly/configure.sml" -val _ = check_against "tools-poly/build.sml" -val _ = check_against "tools/Holmake/Systeml.sig" +val check_againstB = check_against EXECUTABLE +val _ = check_againstB "tools-poly/smart-configure.sml" +val _ = check_againstB "tools-poly/configure.sml" +val _ = check_againstB "tools-poly/build.sml" +val _ = check_againstB "tools/Holmake/Systeml.sig" + +val _ = let + val fP = fullPath + open OS.FileSys + val hmake = fP [HOLDIR,"bin",xable_string "Holmake"] +in + if access(hmake, [A_READ, A_EXEC]) then + (app_sml_files (check_against hmake) + {dirname = fP [HOLDIR, "tools-poly", "Holmake"]}; + app_sml_files (check_against hmake) + {dirname = fP [HOLDIR, "tools", "Holmake"]}) + else + die ("No Holmake executable in " ^ fP [HOLDIR, "bin"]) +end + diff --git a/tools/build.sml b/tools/build.sml index 6fc8fab385..44a0d66f39 100644 --- a/tools/build.sml +++ b/tools/build.sml @@ -100,12 +100,24 @@ end Get rid of compiled code and dependency information. ---------------------------------------------------------------------------*) - -val _ = check_against "tools/smart-configure.sml" -val _ = check_against "tools/configure.sml" -val _ = check_against "tools/build.sml" -val _ = check_against "tools/Holmake/Systeml.sig" -val _ = check_against "tools/configure-mosml.sml" +val check_againstB = check_against EXECUTABLE +val _ = check_againstB "tools/smart-configure.sml" +val _ = check_againstB "tools/configure.sml" +val _ = check_againstB "tools/build.sml" +val _ = check_againstB "tools/Holmake/Systeml.sig" +val _ = check_againstB "tools/configure-mosml.sml" + +val _ = let + val fP = fullPath + open OS.FileSys + val hmake = fP [HOLDIR,"bin",xable_string "Holmake"] +in + if access(hmake, [A_READ, A_EXEC]) then + app_sml_files (check_against hmake) + {dirname = fP [HOLDIR, "tools", "Holmake"]} + else + die ("No Holmake executable in " ^ fP [HOLDIR, "bin"]) +end val _ = diff --git a/tools/buildutils.sig b/tools/buildutils.sig index 4707e7a35b..22402cee58 100644 --- a/tools/buildutils.sig +++ b/tools/buildutils.sig @@ -37,8 +37,13 @@ sig val clean_sigobj : unit -> unit - val check_against : string -> unit - (* checks to see if string is newer than build executable *) + val check_against : string -> string -> unit + (* [check_against f1 f2] checks to see if file f1 is older than file f2 + and prints big warning if so *) + + val app_sml_files : (string -> unit) -> {dirname : string} -> unit + (* applies function to every .sml and .sig file in given + directory *) val transfer_file : (bool -> string -> string -> unit) -> string -> (string * string) -> unit diff --git a/tools/buildutils.sml b/tools/buildutils.sml index 38cfb330a6..3b199aa226 100644 --- a/tools/buildutils.sml +++ b/tools/buildutils.sml @@ -540,13 +540,31 @@ fun full_clean (SRCDIRS:(string*int) list) f = fullPath [HOLDIR, "src", "logging-kernel"] :: map #1 SRCDIRS) -fun check_against s = let +fun app_sml_files f {dirname} = + let + open OS.FileSys OS.Path + val dstrm = openDir dirname + fun recurse () = + case readDir dstrm of + NONE => closeDir dstrm + | SOME p => ((case ext p of + SOME "sml" => f (concat(dirname,p)) + | SOME "sig" => f (concat(dirname,p)) + | _ => ()); + recurse()) + in + recurse () + end + +fun check_against executable s = let open Time - val cfgtime = FileSys.modTime (fullPath [HOLDIR, s]) + val p = if OS.Path.isRelative s then fullPath [HOLDIR, s] + else s + val cfgtime = FileSys.modTime p in - if FileSys.modTime EXECUTABLE < cfgtime then + if FileSys.modTime executable < cfgtime then (warn ("WARNING! WARNING!"); - warn (" The build file is older than " ^ s ^ ";"); + warn (" The executable "^executable^" is older than " ^ s ^ ";"); warn (" this suggests you should reconfigure the system."); warn (" Press Ctl-C now to abort the build; to continue."); warn ("WARNING! WARNING!"); From d229eea2c216d549f6d8593fd0bf0f3d5f47608a Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Thu, 13 Aug 2015 14:16:59 +1000 Subject: [PATCH 407/718] mark some theorems as automatic rewrites selection taken from CakeML --- src/finite_map/alistScript.sml | 4 ++-- src/finite_map/finite_mapScript.sml | 4 ++-- src/list/src/listScript.sml | 2 +- src/list/src/rich_listScript.sml | 2 +- 4 files changed, 6 insertions(+), 6 deletions(-) diff --git a/src/finite_map/alistScript.sml b/src/finite_map/alistScript.sml index f72159e737..4bd3c1e9a2 100644 --- a/src/finite_map/alistScript.sml +++ b/src/finite_map/alistScript.sml @@ -472,7 +472,7 @@ val INJ_I = prove ( SRW_TAC[][INJ_DEF,SUBSET_DEF]) val MAP_KEYS_I = store_thm( -"MAP_KEYS_I", +"MAP_KEYS_I[simp]", ``!fm. MAP_KEYS I fm = fm``, rw[GSYM fmap_EQ_THM,MAP_KEYS_def,EXTENSION] >> metis_tac[MAP_KEYS_def,INJ_I,SUBSET_UNIV,combinTheory.I_THM]) @@ -485,7 +485,7 @@ Q.ISPECL_THEN [`I:'c->'c`,`f`,`al`] match_mp_tac alist_to_fmap_MAP_matchable >> SRW_TAC[][INJ_DEF,SUBSET_DEF,MAP_KEYS_I]) val set_MAP_FST_fmap_to_alist = store_thm( -"set_MAP_FST_fmap_to_alist", +"set_MAP_FST_fmap_to_alist[simp]", ``set (MAP FST (fmap_to_alist fm)) = FDOM fm``, METIS_TAC[fmap_to_alist_to_fmap,FDOM_alist_to_fmap]) diff --git a/src/finite_map/finite_mapScript.sml b/src/finite_map/finite_mapScript.sml index 4e2979a7cc..bb7fecb41c 100644 --- a/src/finite_map/finite_mapScript.sml +++ b/src/finite_map/finite_mapScript.sml @@ -777,12 +777,12 @@ val FDOM_FUNION = save_thm("FDOM_FUNION", FUNION_DEF |> SPEC_ALL |> CONJUNCT1) val _ = export_rewrites ["FDOM_FUNION"] val FUNION_FEMPTY_1 = Q.store_thm -("FUNION_FEMPTY_1", +("FUNION_FEMPTY_1[simp]", `!g. FUNION FEMPTY g = g`, SRW_TAC [][GSYM fmap_EQ_THM, FUNION_DEF, FDOM_FEMPTY]); val FUNION_FEMPTY_2 = Q.store_thm -("FUNION_FEMPTY_2", +("FUNION_FEMPTY_2[simp]", `!f. FUNION f FEMPTY = f`, SRW_TAC [][GSYM fmap_EQ_THM, FUNION_DEF, FDOM_FEMPTY]); diff --git a/src/list/src/listScript.sml b/src/list/src/listScript.sml index b17c00e496..1f02ea0976 100644 --- a/src/list/src/listScript.sml +++ b/src/list/src/listScript.sml @@ -3175,7 +3175,7 @@ val EVERY2_refl = Q.store_thm("EVERY2_refl", `(!x. MEM x ls ==> R x x) ==> (EVERY2 R ls ls)`, Induct_on`ls` >> rw []) -val EVERY2_THM = Q.store_thm("EVERY2_THM", +val EVERY2_THM = Q.store_thm("EVERY2_THM[simp]", `(!P ys. EVERY2 P [] ys = (ys = [])) /\ (!P yys x xs. EVERY2 P (x::xs) yys = ?y ys. (yys = y::ys) /\ (P x y) /\ (EVERY2 P xs ys)) /\ diff --git a/src/list/src/rich_listScript.sml b/src/list/src/rich_listScript.sml index 2538a4502f..90993cbaf3 100644 --- a/src/list/src/rich_listScript.sml +++ b/src/list/src/rich_listScript.sml @@ -3078,7 +3078,7 @@ val EVERY2_TAKE = store_thm("EVERY2_TAKE", THEN fs [TAKE_LENGTH_TOO_LONG] THEN rfs [TAKE_LENGTH_TOO_LONG]); -val LIST_REL_APPEND_SING = Q.store_thm("LIST_REL_APPEND_SING", +val LIST_REL_APPEND_SING = Q.store_thm("LIST_REL_APPEND_SING[simp]", `LIST_REL R (l1 ++ [x1]) (l2 ++ [x2]) <=> LIST_REL R l1 l2 /\ R x1 x2`, rw[EQ_IMP_THM] >> TRY (MATCH_MP_TAC EVERY2_APPEND_suff >> simp[]) From 18cbeef62c31900da950e2ece44b93f34c17418c Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Thu, 13 Aug 2015 14:22:28 +1000 Subject: [PATCH 408/718] some additions to llistTheory from CakeML --- src/llist/llistScript.sml | 21 ++++++++++++++++++++- 1 file changed, 20 insertions(+), 1 deletion(-) diff --git a/src/llist/llistScript.sml b/src/llist/llistScript.sml index 897f1fca0c..eacf748f7d 100644 --- a/src/llist/llistScript.sml +++ b/src/llist/llistScript.sml @@ -1,7 +1,7 @@ structure llistScript = struct -open HolKernel boolLib Parse bossLib +open HolKernel boolLib Parse bossLib lcsymtacs open BasicProvers boolSimps markerLib; @@ -1050,6 +1050,16 @@ val LTAKE_DROP = store_thm( `z = THE (LTAKE n t)` by ASM_SIMP_TAC (srw_ss()) [] THEN SRW_TAC [][] ]); +val LDROP_ADD = store_thm("LDROP_ADD", + ``!k1 k2 x. + LDROP (k1 + k2) x = case LDROP k1 x of + | NONE => NONE + | SOME ll => LDROP k2 ll``, + Induct \\ fs [arithmeticTheory.ADD_CLAUSES] + \\ fs [LDROP] \\ REPEAT STRIP_TAC + \\ Cases_on `LTL x` \\ fs [] + \\ Cases_on `LDROP k1 x'` \\ fs []); + (* ---------------------------------------------------------------------- exists : ('a -> bool) -> 'a llist -> bool @@ -1850,6 +1860,15 @@ linear_order_to_list_lem2] THENL end +val LPREFIX_def = Define ` + LPREFIX l1 l2 = + case toList l1 of + | NONE => (l1 = l2) + | SOME xs => + case toList l2 of + | NONE => LTAKE (LENGTH xs) l2 = SOME xs + | SOME ys => isPREFIX xs ys` + val _ = export_theory(); end; From 67164f2491c0ed9ed9e943cc6e4a7e08676037a5 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Thu, 13 Aug 2015 14:55:41 +1000 Subject: [PATCH 409/718] some additions to rich_listTheory from CakeML --- src/list/src/rich_listScript.sml | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/src/list/src/rich_listScript.sml b/src/list/src/rich_listScript.sml index 90993cbaf3..770f1b4ad2 100644 --- a/src/list/src/rich_listScript.sml +++ b/src/list/src/rich_listScript.sml @@ -3152,6 +3152,26 @@ val map_replicate = Q.store_thm ("map_replicate", `!f n x. MAP f (REPLICATE n x) = REPLICATE n (f x)`, Induct_on `n` >> rw [REPLICATE]); +val REPLICATE_NIL = Q.store_thm("REPLICATE_NIL", + `(REPLICATE x y = []) ⇔ (x = 0)`, + Cases_on`x`>>rw[REPLICATE]); + +val REPLICATE_APPEND = Q.store_thm("REPLICATE_APPEND", + `REPLICATE n a ++ REPLICATE m a = REPLICATE (n+m) a`, + simp[LIST_EQ_REWRITE,LENGTH_REPLICATE] >> rw[] >> + Cases_on`x < n` >> simp[EL_APPEND1,LENGTH_REPLICATE,EL_REPLICATE,EL_APPEND2]) + +val DROP_REPLICATE = Q.store_thm("DROP_REPLICATE", + `DROP n (REPLICATE m a) = REPLICATE (m-n) a`, + simp[LIST_EQ_REWRITE,LENGTH_REPLICATE,EL_REPLICATE,EL_DROP]) + +val LIST_REL_REPLICATE_same = store_thm("LIST_REL_REPLICATE_same", + ``LIST_REL P (REPLICATE n x) (REPLICATE n y) ⇔ (n > 0 ⇒ P x y)``, + simp[LIST_REL_EL_EQN,REPLICATE_GENLIST] >> + Cases_on`n`>>simp[EQ_IMP_THM] >> rw[] >> + FIRST_X_ASSUM MATCH_MP_TAC >> + Q.EXISTS_TAC`0`>>simp[]) + val take_drop_partition = Q.store_thm ("take_drop_partition", `!n m l. m <= n ==> (TAKE m l ++ TAKE (n - m) (DROP m l) = TAKE n l)`, Induct_on `m` From c9d2272a5416f0fb07c62b714228f9bfb3b4f92c Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Fri, 14 Aug 2015 11:28:32 +1000 Subject: [PATCH 410/718] more list theorems from CakeML --- src/list/src/listScript.sml | 31 +++++++++++++++++++++ src/list/src/rich_listScript.sml | 47 ++++++++++++++++++++++++++++++++ 2 files changed, 78 insertions(+) diff --git a/src/list/src/listScript.sml b/src/list/src/listScript.sml index 1f02ea0976..323effcda2 100644 --- a/src/list/src/listScript.sml +++ b/src/list/src/listScript.sml @@ -3451,6 +3451,37 @@ val EL_LENGTH_dropWhile_REVERSE = Q.store_thm("EL_LENGTH_dropWhile_REVERSE", >> fs [NOT_EVERY, dropWhile_APPEND_EXISTS, arithmeticTheory.ADD1]) end +val LENGTH_TAKE_EQ = store_thm("LENGTH_TAKE_EQ", + ``LENGTH (TAKE n xs) = if n <= LENGTH xs then n else LENGTH xs``, + SRW_TAC [] [] THEN fs [GSYM NOT_LESS] THEN AP_TERM_TAC + THEN MATCH_MP_TAC TAKE_LENGTH_TOO_LONG THEN numLib.DECIDE_TAC); + +val IMP_EVERY_LUPDATE = store_thm("IMP_EVERY_LUPDATE", + ``!xs h i. P h /\ EVERY P xs ==> EVERY P (LUPDATE h i xs)``, + Induct THEN fs [LUPDATE_def] THEN REPEAT STRIP_TAC + THEN Cases_on `i` THEN fs [LUPDATE_def]); + +val MAP_APPEND_MAP_EQ = store_thm("MAP_APPEND_MAP_EQ", + ``!xs ys. + ((MAP f1 xs ++ MAP g1 ys) = (MAP f2 xs ++ MAP g2 ys)) <=> + (MAP f1 xs = MAP f2 xs) /\ (MAP g1 ys = MAP g2 ys)``, + Induct THEN fs [] THEN METIS_TAC []); + +val LUPDATE_SOME_MAP = store_thm("LUPDATE_SOME_MAP", + ``!xs n f h. + LUPDATE (SOME (f h)) n (MAP (OPTION_MAP f) xs) = + MAP (OPTION_MAP f) (LUPDATE (SOME h) n xs)``, + Induct THEN1 (fs [LUPDATE_def]) THEN + Cases_on `n` THEN fs [LUPDATE_def]); + +val ZIP_EQ_NIL = store_thm("ZIP_EQ_NIL", + ``∀l1 l2. (LENGTH l1 = LENGTH l2) ⇒ ((ZIP (l1,l2) = []) ⇔ ((l1 = []) ∧ (l2 = [])))``, + REPEAT GEN_TAC >> Cases_on`l1`>>rw[LENGTH_NIL_SYM,ZIP]>> Cases_on`l2`>>fs[ZIP]) + +val LUPDATE_SAME = store_thm("LUPDATE_SAME", + ``∀n ls. n < LENGTH ls ⇒ (LUPDATE (EL n ls) n ls = ls)``, + rw[LIST_EQ_REWRITE,EL_LUPDATE]>>rw[]) + end; (* end CakeML lemmas *) diff --git a/src/list/src/rich_listScript.sml b/src/list/src/rich_listScript.sml index 770f1b4ad2..5e3f2e7911 100644 --- a/src/list/src/rich_listScript.sml +++ b/src/list/src/rich_listScript.sml @@ -2922,11 +2922,15 @@ val LIST_ELEM_COUNT_MEM = Q.store_thm ("LIST_ELEM_COUNT_MEM", local val op>> = op Tactical.THEN + val op>- = op Tactical.THEN1 val rw = SRW_TAC [] val metis_tac = METIS_TAC val fs = FULL_SIMP_TAC (srw_ss()) val rfs = REV_FULL_SIMP_TAC (srw_ss()) val simp = ASM_SIMP_TAC (srw_ss()++boolSimps.LET_ss++numSimps.ARITH_ss) + val decide_tac = numLib.DECIDE_TAC + val imp_res_tac = IMP_RES_TAC + val res_tac = RES_TAC open pred_setTheory open listTheory pairTheory; in @@ -3049,6 +3053,12 @@ val EVERY2_APPEND = Q.store_thm("EVERY2_APPEND", (LENGTH l1 = LENGTH l2) /\ (LENGTH l3 = LENGTH l4)`, rw[EVERY2_EVERY,EVERY_MEM] >> metis_tac[ZIP_APPEND,MEM_APPEND]) +val LIST_REL_APPEND_IMP = store_thm("LIST_REL_APPEND_IMP", + ``!xs ys xs1 ys1. + LIST_REL P (xs ++ xs1) (ys ++ ys1) /\ (LENGTH xs = LENGTH ys) ==> + LIST_REL P xs ys /\ LIST_REL P xs1 ys1``, + Induct >> Cases_on `ys` >> FULL_SIMP_TAC (srw_ss()) [] >> METIS_TAC []); + val EVERY2_APPEND_suff = Q.store_thm("EVERY2_APPEND_suff", `EVERY2 R l1 l2 /\ EVERY2 R l3 l4 ==> EVERY2 R (l1 ++ l3) (l2 ++ l4)`, metis_tac[EVERY2_APPEND]) @@ -3085,6 +3095,13 @@ val LIST_REL_APPEND_SING = Q.store_thm("LIST_REL_APPEND_SING[simp]", >> IMP_RES_TAC EVERY2_APPEND >> fs[]) +val LIST_REL_GENLIST = store_thm("LIST_REL_GENLIST", + ``EVERY2 P (GENLIST f l) (GENLIST g l) <=> + !i. i < l ==> P (f i) (g i)``, + Induct_on `l` + >> fs [GENLIST,LIST_REL_APPEND_SING,SNOC_APPEND] + >> fs [DECIDE ``i < SUC n <=> i < n \/ (i = n)``] >> METIS_TAC []); + val ALL_DISTINCT_MEM_ZIP_MAP = Q.store_thm("ALL_DISTINCT_MEM_ZIP_MAP", `!f x ls. ALL_DISTINCT ls ==> @@ -3190,6 +3207,36 @@ val all_distinct_count_list = Q.store_thm ("all_distinct_count_list", >> MATCH_MP_TAC ALL_DISTINCT_MAP_INJ >> rw []); +val list_rel_lastn = Q.store_thm("list_rel_lastn", + `!f l1 l2 n. + n ≤ LENGTH l1 ∧ + LIST_REL f l1 l2 ⇒ + LIST_REL f (LASTN n l1) (LASTN n l2)`, + Induct_on `l1` >> + rw [LASTN] >> + imp_res_tac EVERY2_LENGTH >> + Cases_on `n = LENGTH l1 + 1` + >- metis_tac [LASTN_LENGTH_ID, ADD1, LENGTH, LIST_REL_def] >> + `n ≤ LENGTH l1` by decide_tac >> + `n ≤ LENGTH ys` by decide_tac >> + res_tac >> + fs [LASTN_CONS]); + +val list_rel_butlastn = Q.store_thm ("list_rel_butlastn", + `!f l1 l2 n. + n ≤ LENGTH l1 ∧ + LIST_REL f l1 l2 ⇒ + LIST_REL f (BUTLASTN n l1) (BUTLASTN n l2)`, + Induct_on `l1` >> + rw [BUTLASTN] >> + imp_res_tac EVERY2_LENGTH >> + Cases_on `n = LENGTH l1 + 1` + >- metis_tac [BUTLASTN_LENGTH_NIL, ADD1, LENGTH, LIST_REL_def] >> + `n ≤ LENGTH l1` by decide_tac >> + `n ≤ LENGTH ys` by decide_tac >> + res_tac >> + fs [BUTLASTN_CONS]); + end (* end CakeML lemmas *) From c7d6871aa44c8146e70e81b56a8aa56a1aba4bbb Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Fri, 14 Aug 2015 11:32:38 +1000 Subject: [PATCH 411/718] some lemmas about SORTED from CakeML --- src/sort/sortingScript.sml | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/src/sort/sortingScript.sml b/src/sort/sortingScript.sml index 5006a948e7..45830e633d 100644 --- a/src/sort/sortingScript.sml +++ b/src/sort/sortingScript.sml @@ -1370,6 +1370,23 @@ val SORTED_weaken = store_thm("SORTED_weaken", FIRST_X_ASSUM MATCH_MP_TAC THEN METIS_TAC[]) +val less_sorted_eq = MATCH_MP SORTED_EQ arithmeticTheory.transitive_LESS + |> curry save_thm"less_sorted_eq"; + +val SORTED_GENLIST_PLUS = store_thm("SORTED_GENLIST_PLUS", + ``∀n k. SORTED $< (GENLIST ($+ k) n)``, + Induct >> simp[GENLIST_CONS,less_sorted_eq,MEM_GENLIST] >> gen_tac >> + `$+ k o SUC = $+ (k+1)` by ( + simp[FUN_EQ_THM] ) >> + metis_tac[]) + +val SORTED_ALL_DISTINCT = store_thm("SORTED_ALL_DISTINCT", + ``irreflexive R /\ transitive R ==> !ls. SORTED R ls ==> ALL_DISTINCT ls``, + STRIP_TAC THEN Induct THEN SRW_TAC[][] THEN + IMP_RES_TAC SORTED_EQ THEN + FULL_SIMP_TAC (srw_ss()) [SORTED_DEF] THEN + METIS_TAC[relationTheory.irreflexive_def]) + end val _ = export_theory(); From 3b7739085ec6b0f2fe9a607415bd93cf391ee781 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Fri, 14 Aug 2015 17:05:03 +1000 Subject: [PATCH 412/718] some sptree theorems from CakeML --- src/patricia/sptreeScript.sml | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/src/patricia/sptreeScript.sml b/src/patricia/sptreeScript.sml index 52b3dfeb4f..c36fa621c2 100644 --- a/src/patricia/sptreeScript.sml +++ b/src/patricia/sptreeScript.sml @@ -345,6 +345,18 @@ val lookup_inter_eq = store_thm( rw[optcase_lemma] >> REPEAT BasicProvers.CASE_TAC >> fs [lookup_def, lookup_mk_BS, lookup_mk_BN]); +val lookup_inter_EQ = store_thm("lookup_inter_EQ", + ``((lookup x (inter t1 t2) = SOME y) <=> + (lookup x t1 = SOME y) /\ lookup x t2 <> NONE) /\ + ((lookup x (inter t1 t2) = NONE) <=> + (lookup x t1 = NONE) \/ (lookup x t2 = NONE))``, + fs [lookup_inter] \\ BasicProvers.EVERY_CASE_TAC); + +val lookup_inter_assoc = store_thm("lookup_inter_assoc", + ``lookup x (inter t1 (inter t2 t3)) = + lookup x (inter (inter t1 t2) t3)``, + fs [lookup_inter] \\ BasicProvers.EVERY_CASE_TAC) + val lookup_difference = store_thm( "lookup_difference", ``!m1 m2 k. lookup k (difference m1 m2) = @@ -440,6 +452,12 @@ val domain_lookup = store_thm( simp[oddevenlemma, EVEN_ADD, EVEN_MULT, EQ_MULT_LCANCEL, MULT2_DIV']); +val lookup_inter_alt = store_thm("lookup_inter_alt", + ``lookup x (inter t1 t2) = + if x IN domain t2 then lookup x t1 else NONE``, + fs [lookup_inter,domain_lookup] + \\ Cases_on `lookup x t2` \\ fs [] \\ Cases_on `lookup x t1` \\ fs []); + val lookup_NONE_domain = store_thm( "lookup_NONE_domain", ``(lookup k t = NONE) <=> k NOTIN domain t``, @@ -1141,4 +1159,12 @@ val lookup_map = store_thm("lookup_map", ``∀s x. lookup x (map f s) = OPTION_MAP f (lookup x s)``, Induct >> simp[map_def,lookup_def] >> rw[]) +val map_LN = store_thm("map_LN[simp]", + ``!t. (map f t = LN) <=> (t = LN)``, + Cases \\ EVAL_TAC); + +val wf_map = store_thm("wf_map[simp]", + ``!t f. wf (map f t) = wf t``, + Induct \\ fs [wf_def,map_def]); + val _ = export_theory(); From 8f025327eed7bcca98d59ea57a9c0e0c70e1ac78 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Mon, 17 Aug 2015 09:37:19 +1000 Subject: [PATCH 413/718] a few lcsymtacs from BasicProvers --- src/boss/lcsymtacs.sig | 4 ++++ src/boss/lcsymtacs.sml | 4 ++++ 2 files changed, 8 insertions(+) diff --git a/src/boss/lcsymtacs.sig b/src/boss/lcsymtacs.sig index 0ee54e2649..2f4de3bbd0 100644 --- a/src/boss/lcsymtacs.sig +++ b/src/boss/lcsymtacs.sig @@ -12,6 +12,7 @@ sig val disj1_tac : tactic val disj2_tac : tactic val gen_tac : tactic + val var_eq_tac : tactic val rpt : tactic -> tactic val ntac : int -> tactic -> tactic val reverse : tactic -> tactic @@ -26,6 +27,9 @@ sig val mp_tac : thm_tactic val match_mp_tac : thm_tactic + val every_case_tac : tactic + val full_case_tac : tactic + val rule_assum_tac : (thm -> thm) -> tactic val pop_assum : thm_tactic -> tactic val first_assum : thm_tactic -> tactic diff --git a/src/boss/lcsymtacs.sml b/src/boss/lcsymtacs.sml index 13ea1c7599..8e251f19e9 100644 --- a/src/boss/lcsymtacs.sml +++ b/src/boss/lcsymtacs.sml @@ -18,6 +18,7 @@ struct val rpt = Tactical.REPEAT val reverse = Tactical.REVERSE val ntac = Tactic.NTAC + val var_eq_tac = BasicProvers.VAR_EQ_TAC val rewrite_tac : thm list -> tactic = Rewrite.REWRITE_TAC val once_rewrite_tac : thm list -> tactic = Rewrite.ONCE_REWRITE_TAC @@ -57,6 +58,9 @@ struct val qmatch_goalsub_rename_tac = Q.MATCH_GOALSUB_RENAME_TAC val qcase_tac = Q.FIND_CASE_TAC + val every_case_tac = BasicProvers.EVERY_CASE_TAC + val full_case_tac = BasicProvers.FULL_CASE_TAC + val rule_assum_tac : (thm -> thm) -> tactic = Tactic.RULE_ASSUM_TAC val assume_tac : thm_tactic = Tactic.ASSUME_TAC val strip_assume_tac : thm_tactic = Tactic.STRIP_ASSUME_TAC From be67aea5d4877f63d20bfaea9b108d661352c69b Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Mon, 17 Aug 2015 15:58:12 +1000 Subject: [PATCH 414/718] strengthen rich_listTheory.EL_TAKE and delete dup in numposrep remove an unnecessary hypothesis --- src/list/src/numposrepScript.sml | 4 ---- src/list/src/rich_listScript.sml | 2 +- 2 files changed, 1 insertion(+), 5 deletions(-) diff --git a/src/list/src/numposrepScript.sml b/src/list/src/numposrepScript.sml index fe7b775476..dafd7c6d49 100644 --- a/src/list/src/numposrepScript.sml +++ b/src/list/src/numposrepScript.sml @@ -88,10 +88,6 @@ val LENGTH_l2n = Q.store_thm("LENGTH_l2n", `~(l2n b l = 0)` by (STRIP_TAC \\ FULL_SIMP_TAC arith_ss []) \\ SRW_TAC [] []]); -val EL_TAKE = Q.store_thm("EL_TAKE", - `!x n l. x < n /\ n <= LENGTH l ==> (EL x (TAKE n l) = EL x l)`, - Induct_on `l` \\ Cases_on `x` \\ SRW_TAC [ARITH_ss] []); - val l2n_DIGIT = Q.store_thm("l2n_DIGIT", `!b l x. 1 < b /\ EVERY ($> b) l /\ x < LENGTH l ==> ((l2n b l DIV b ** x) MOD b = EL x l)`, diff --git a/src/list/src/rich_listScript.sml b/src/list/src/rich_listScript.sml index 5e3f2e7911..ffe35f0d77 100644 --- a/src/list/src/rich_listScript.sml +++ b/src/list/src/rich_listScript.sml @@ -2816,7 +2816,7 @@ val ZIP_TAKE = Q.store_thm ("ZIP_TAKE", SIMP_TAC arith_ss [ZIP_TAKE_LEQ, listTheory.TAKE_LENGTH_ID]); val EL_TAKE = Q.store_thm ("EL_TAKE", - `!n x l. x < n /\ n <= LENGTH l ==> (EL x (TAKE n l) = EL x l)`, + `!n x l. x < n ==> (EL x (TAKE n l) = EL x l)`, Induct_on `n` THEN ASM_SIMP_TAC list_ss [TAKE] THEN Cases_on `x` From 7b94292bcd6e4d7d3fd779491d04e6838bb15db1 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Tue, 18 Aug 2015 11:31:57 +1000 Subject: [PATCH 415/718] a theorem: sorted_filter - list remains sorted after filtering from CakeML --- src/sort/sortingScript.sml | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/src/sort/sortingScript.sml b/src/sort/sortingScript.sml index 45830e633d..8a4beeb4ca 100644 --- a/src/sort/sortingScript.sml +++ b/src/sort/sortingScript.sml @@ -376,6 +376,8 @@ val SORTED_DEF = (SORTED R (x::y::rst) = R x y /\ SORTED R (y::rst))`; +val SORTED_IND = theorem"SORTED_IND"; + val SORTS_DEF = Define `SORTS f R = !l. PERM l (f R l) /\ SORTED R (f R l)`; @@ -1387,6 +1389,13 @@ val SORTED_ALL_DISTINCT = store_thm("SORTED_ALL_DISTINCT", FULL_SIMP_TAC (srw_ss()) [SORTED_DEF] THEN METIS_TAC[relationTheory.irreflexive_def]) +val sorted_filter = Q.store_thm("sorted_filter", + `∀R ls. transitive R ⇒ SORTED R ls ⇒ SORTED R (FILTER P ls)`, + HO_MATCH_MP_TAC SORTED_IND >> + rw[SORTED_DEF] >> fs[] >> + rfs[SORTED_EQ,MEM_FILTER] >> + rw[] >> metis_tac[transitive_def]) + end val _ = export_theory(); From d94eb76c659b0f92d6caf2ffcd44b695ea9968a5 Mon Sep 17 00:00:00 2001 From: Andrea Condoluci Date: Wed, 19 Aug 2015 12:25:05 +1000 Subject: [PATCH 416/718] Co-induction theorem added, others to co-me --- src/CoIndDef/CoIndDefLib.sig | 15 ++ src/CoIndDef/CoIndDefLib.sml | 259 +++++++++++++++++++++++++++++++++++ 2 files changed, 274 insertions(+) create mode 100644 src/CoIndDef/CoIndDefLib.sig create mode 100644 src/CoIndDef/CoIndDefLib.sml diff --git a/src/CoIndDef/CoIndDefLib.sig b/src/CoIndDef/CoIndDefLib.sig new file mode 100644 index 0000000000..6c2410582e --- /dev/null +++ b/src/CoIndDef/CoIndDefLib.sig @@ -0,0 +1,15 @@ +signature CoIndDefLib = +sig + include Abbrev + type monoset = InductiveDefinition.monoset + + val Hol_coreln : term quotation -> thm * thm * thm + val xHol_coreln : string -> term quotation -> thm * thm * thm + val Hol_mono_coreln : string -> monoset -> + (term * locn.locn list) -> thm * thm * thm +(*) + val derive_mono_strong_coinduction : monoset -> thm * thm -> thm + val derive_strong_coinduction : thm * thm -> thm +*) + val derive_nonschematic_inductive_relations : term -> thm +end diff --git a/src/CoIndDef/CoIndDefLib.sml b/src/CoIndDef/CoIndDefLib.sml new file mode 100644 index 0000000000..c88c28a540 --- /dev/null +++ b/src/CoIndDef/CoIndDefLib.sml @@ -0,0 +1,259 @@ +(* ========================================================================= * + * * + * Coinductive Definitions * + * * + * ========================================================================= *) + +structure CoIndDefLib :> CoIndDefLib = +struct + +open HolKernel boolLib + +(* Prove definitions work for non-schematic relations with canonical rules. *) + +fun derive_canon_coinductive_relations pclauses = + let val closed = list_mk_conj pclauses + val pclauses = strip_conj closed + val (vargs,bodies) = split(map strip_forall pclauses) + val swap = fn (x, y) => (y, x) + val bodies = map mk_imp (map swap (map dest_imp bodies)) + val pclauses = map list_mk_forall (zip vargs bodies) + val closed = list_mk_conj pclauses + val (ants,concs) = split(map dest_imp bodies) + val rels = map (repeat rator) ants + val avoids = all_vars closed + val rels' = variants avoids rels + val prime_fn = subst (map2 (curry op |->) rels rels' ) + val closed' = prime_fn closed + + fun mk_def arg ant = + mk_eq(repeat rator ant, + list_mk_abs(arg,list_mk_exists(rels', + mk_conj(prime_fn ant, closed')))) + val deftms = map2 mk_def vargs ants + val defthms = map2 HALF_BETA_EXPAND vargs (map ASSUME deftms) + + fun rm_exists th rels' = (* fix the dest_exists with rels' *) + let val ant = hd (hyp th) + val (var, conj) = dest_exists ant + val (a, b) = dest_conj conj + val ex = EXISTS(ant, var) (ASSUME conj) + val th1 = PROVE_HYP ex th + val th2 = CONJ (ASSUME a) (ASSUME b) + in PROVE_HYP th2 th1 + end + + fun mk_coind args th = + let val th1 = snd(EQ_IMP_RULE(SPEC_ALL th)) + val th2 = rm_exists (UNDISCH th1) rels' + val ant = hd (hyp th2) + in GENL args (DISCH ant (th2)) + end + val coindthms = map2 mk_coind vargs defthms + val coindthmr = end_itlist CONJ coindthms + val my_closed_why = (hd (hyp coindthmr)) + val coindthm = GENL rels'(DISCH my_closed_why coindthmr) + + val mants = map2 (fn a => fn t => + list_mk_forall(a,mk_imp(prime_fn t, t))) vargs concs + val monotm = mk_imp(concl coindthmr, list_mk_conj mants) + val monothm = ASSUME(list_mk_forall(rels,list_mk_forall(rels',monotm))) + + val closthm = ASSUME my_closed_why + + val monothms = CONJUNCTS + (MP (SPEC_ALL monothm) (MP (SPECL rels' coindthm) closthm)) + val closthms = CONJUNCTS closthm + + fun reverse_mess th rel = + let val a = hd (hyp th) (* FIXME *) + val b = my_closed_why + val conj = mk_conj(a, b) + val A = CONJUNCT1(ASSUME conj); + val B = CONJUNCT2(ASSUME conj); + val step1 = PROVE_HYP A th; + val step2 = PROVE_HYP B step1; + val ex = mk_exists(rel, conj) + in (ex, CHOOSE(rel, ASSUME ex) step2) + end + + fun prove_rule mth (cth,dth) = + let val (avs,bod) = strip_forall(concl mth) + val th1 = IMP_TRANS (SPECL avs cth) (SPECL avs mth) + val (ex, th1') = reverse_mess (UNDISCH th1) (hd rels') + (* FIXME: insted of GENL rels', I should exists all, not hd *) + val th2 = DISCH ex th1' + val th3 = IMP_TRANS (fst(EQ_IMP_RULE(SPECL avs dth))) th2 + in GENL avs th3 + end + val ruvalhms = map2 prove_rule monothms (zip closthms defthms) + val ruvalhm = end_itlist CONJ ruvalhms + (* + val dtms = map2 (curry list_mk_abs) vargs ants + val double_fn = subst (map2 (curry op |->) rels dtms) + fun mk_unbetas tm dtm = + let val (avs,bod) = strip_forall tm + val (il,r) = dest_comb bod + val (i,l) = dest_comb il + val bth = RIGHT_BETAS avs (REFL dtm) + val munb = AP_THM (AP_TERM i bth) r + val iunb = AP_TERM (mk_comb(i,double_fn l)) bth + val junb = AP_TERM (mk_comb(i,r)) bth + val quantify = itlist MK_FORALL avs + in (quantify munb,(quantify iunb,quantify junb)) + end + val unths = map2 mk_unbetas pclauses dtms + val irthm = EQ_MP (SYM(end_itlist MK_CONJ (map fst unths))) ruvalhm + val mrthm = MP (SPECL rels (SPECL dtms monothm)) irthm + val imrth = EQ_MP + (SYM(end_itlist MK_CONJ (map (fst o snd) unths))) mrthm + val ifthm = MP (SPECL dtms indthm) imrth + val fthm = EQ_MP (end_itlist MK_CONJ (map (snd o snd) unths)) ifthm + fun mk_case th1 th2 = + let val avs = fst(strip_forall(concl th1)) + in GENL avs (IMP_ANTISYM_RULE (SPEC_ALL th1) (SPEC_ALL th2)) + end + val casethm = end_itlist CONJ + (map2 mk_case (CONJUNCTS fthm) (CONJUNCTS ruvalhm)) + *) + val todo = hd defthms + in (*CONJ ruvalhm (CONJ indthm casethm)*) + CONJ ruvalhm (CONJ coindthm todo) + end + handle e => raise (wrap_exn "co_InductiveDefinition" + "derive_canon_coinductive_relations"e); + + + +(* General case for nonschematic relations; monotonicity & defn hyps. *) +fun derive_nonschematic_coinductive_relations tm = + let val clauses = strip_conj tm + val canonthm = canonicalize_clauses clauses + val canonthm' = SYM canonthm + val pclosed = rand(concl canonthm) + val pclauses = strip_conj pclosed + val rawthm = derive_canon_coinductive_relations pclauses + val (ruvalhm,otherthms) = CONJ_PAIR rawthm + val (indthm,casethm) = CONJ_PAIR otherthms + (* TODO + val ruvalhm' = EQ_MP canonthm' ruvalhm + and indthm' = CONV_RULE (ONCE_DEPTH_CONV (REWR_CONV canonthm')) indthm *) + in (* TODO CONJ ruvalhm' (CONJ indthm' casethm) *) rawthm + end + handle e => raise (wrap_exn "co_InductiveDefinition" + "derive_nonschematic_coinductive_relations" e); + + +fun new_coinductive_definition monoset stem (tm,clocs) = + let val clauses = strip_conj tm + val (clauses',fvs) = unschematize_clauses clauses + val _ = check_definition fvs clocs (list_mk_conj clauses') + val th0 = derive_nonschematic_coinductive_relations + (check_definition fvs clocs (list_mk_conj clauses')) + val th1 = prove_monotonicity_hyps monoset th0 + val th2 = generalize_schematic_variables fvs th1 + val th3 = make_definitions stem th2 + val avs = fst(strip_forall(concl th3)) + val (r,ic) = CONJ_PAIR(SPECL avs th3) + val (i,c) = CONJ_PAIR ic + in (GENL avs r, GENL avs i, GENL avs c) + end + handle e => raise wrap_exn "co_InductiveDefinition" "new_coinductive_definition" e; + + +(* ------------------------------------------------------------------------- *) + +fun save_theorems name (rules, indn, strong_ind, cases) = let +in + (* save_thm(name^"_rules", rules); + save_thm(name^"_ind", indn); + save_thm(name^"_strongind", strong_ind); + save_thm(name^"_cases", cases); + export_rule_induction (name ^ "_strongind") *) + () +end + +(* ------------------------------------------------------------------------- *) +(* entrypoints: *) + +fun Hol_mono_coreln name monoset tm = let + val _ = Lexis.ok_sml_identifier (name ^ !boolLib.def_suffix) orelse + raise ERR "Hol_mono_coreln" + ("Bad name for definition: "^ Lib.mlquote name^ + " (use xHol_coreln to specify a better)") + val (rules, indn, cases) = new_coinductive_definition monoset name tm + (* not! InductiveDefinition.bool_monoset tm *) + val strong_ind = (*derive_strong_induction (rules, indn)*) () +in + save_theorems name (rules, indn, strong_ind, cases); + (rules, indn, cases) +end +handle e => raise (wrap_exn "CoIndDefLib" "Hol_mono_coreln" e); + +fun xHol_coreln name q = Hol_mono_coreln name (!IndDefLib.the_monoset) (IndDefLib.term_of q) + +fun Hol_coreln q = let + val parse = IndDefLib.term_of |> trace ("syntax_error", 0) + |> trace ("show_typecheck_errors", 0) + (* turn off verbiage because the Raise below will redisplay any + exceptions *) + val def as (def_t,_) = parse q + val name = IndDefLib.name_from_def def_t +in + Hol_mono_coreln name (!IndDefLib.the_monoset) def +end handle e => Raise (wrap_exn "IndDefLib" "Hol_coreln" e); + + + +(* DEBUGGING CODE *) + +fun coreln q = let + (* *) + val parse = IndDefLib.term_of |> trace ("syntax_error", 0) + |> trace ("show_typecheck_errors", 0) + (* turn off verbiage because the Raise below will redisplay any + exceptions *) + val tm as (def_t,_) = parse q + val name = name_from_def def_t + val monoset = (!IndDefLib.the_monoset) + + (* *) + val _ = Lexis.ok_sml_identifier (name ^ !boolLib.def_suffix) orelse + raise ERR "Hol_mono_coreln" + ("Bad name for definition: "^ Lib.mlquote name^ + " (use xHol_reln to specify a better)") + + (* new_coinductive_definition monoset stem (tm,clocs) *) + val stem = name + val (tm, clocs) = tm + val clauses = strip_conj tm + val (clauses',fvs) = unschematize_clauses clauses + val _ = check_definition fvs clocs (list_mk_conj clauses') + val check = check_definition fvs clocs (list_mk_conj clauses') + + (* derive_nonschematic_coinductive_relations *) + val tm = check + val clauses = strip_conj tm + val canonthm = canonicalize_clauses clauses + val canonthm' = SYM canonthm + val pclosed = rand(concl canonthm) + val pclauses = strip_conj pclosed + (* val rawthm = derive_canon_coinductive_relations pclauses *) + + in pclauses +end; + + + +(* simple test cases + +val pclauses = coreln`(N 0) /\ (N n ==> N (f n))`; + +val q = ` + (lrep_ok (\n. NONE)) + /\ lrep_ok (\n. if n = 0 then SOME h else t(n - 1)) +`; +*) + + +end (* CoIndDefLib *) From a71a3086aab8acaa5e1a94eb274852d6aab1b272 Mon Sep 17 00:00:00 2001 From: Andrea Condoluci Date: Wed, 19 Aug 2015 12:27:33 +1000 Subject: [PATCH 417/718] Fix sigs to share co-mmon funs --- src/IndDef/IndDefLib.sig | 2 ++ src/IndDef/InductiveDefinition.sig | 9 +++++++++ 2 files changed, 11 insertions(+) diff --git a/src/IndDef/IndDefLib.sig b/src/IndDef/IndDefLib.sig index 2df7fdfde3..93ab12067e 100644 --- a/src/IndDef/IndDefLib.sig +++ b/src/IndDef/IndDefLib.sig @@ -6,6 +6,8 @@ sig val term_of : term quotation -> term * locn.locn list val term_of_absyn : Absyn.absyn -> term * locn.locn list + val name_from_def : term -> string + val Hol_reln : term quotation -> thm * thm * thm val xHol_reln : string -> term quotation -> thm * thm * thm val Hol_mono_reln : string -> monoset -> diff --git a/src/IndDef/InductiveDefinition.sig b/src/IndDef/InductiveDefinition.sig index 1c6104968c..086e99f409 100644 --- a/src/IndDef/InductiveDefinition.sig +++ b/src/IndDef/InductiveDefinition.sig @@ -23,4 +23,13 @@ sig val derive_nonschematic_inductive_relations : term -> thm val prove_monotonicity_hyps : monoset -> thm -> thm + (* tools *) + val variants : term list -> term list -> term list + val HALF_BETA_EXPAND : term list -> thm -> thm + val canonicalize_clauses : term list -> thm + val unschematize_clauses : term list -> term list * term list + val check_definition : term list -> locn list -> term -> term + val generalize_schematic_variables : term list -> thm -> thm + + end From eda9ab5511db701793e0c69af9d1ddc3440815a8 Mon Sep 17 00:00:00 2001 From: Andrea Condoluci Date: Wed, 19 Aug 2015 17:14:42 +1000 Subject: [PATCH 418/718] towards co-mpletion --- src/CoIndDef/CoIndDefLib.sig | 14 ++-- src/CoIndDef/CoIndDefLib.sml | 125 +++++++++-------------------- src/IndDef/InductiveDefinition.sig | 6 +- src/boss/bossLib.sig | 11 +-- src/boss/bossLib.sml | 20 ++--- 5 files changed, 61 insertions(+), 115 deletions(-) diff --git a/src/CoIndDef/CoIndDefLib.sig b/src/CoIndDef/CoIndDefLib.sig index 6c2410582e..812f6df927 100644 --- a/src/CoIndDef/CoIndDefLib.sig +++ b/src/CoIndDef/CoIndDefLib.sig @@ -7,9 +7,13 @@ sig val xHol_coreln : string -> term quotation -> thm * thm * thm val Hol_mono_coreln : string -> monoset -> (term * locn.locn list) -> thm * thm * thm -(*) - val derive_mono_strong_coinduction : monoset -> thm * thm -> thm - val derive_strong_coinduction : thm * thm -> thm -*) - val derive_nonschematic_inductive_relations : term -> thm + + val new_coinductive_definition : monoset -> string -> + term * locn.locn list-> + thm * thm * thm + + val derive_nonschematic_coinductive_relations : term -> thm + (*val derive_mono_strong_coinduction : monoset -> thm * thm -> thm + val derive_strong_coinduction : thm * thm -> thm *) + end diff --git a/src/CoIndDef/CoIndDefLib.sml b/src/CoIndDef/CoIndDefLib.sml index c88c28a540..bd78e29128 100644 --- a/src/CoIndDef/CoIndDefLib.sml +++ b/src/CoIndDef/CoIndDefLib.sml @@ -7,7 +7,8 @@ structure CoIndDefLib :> CoIndDefLib = struct -open HolKernel boolLib +open HolKernel boolLib liteLib InductiveDefinition IndDefLib + (* Prove definitions work for non-schematic relations with canonical rules. *) @@ -88,44 +89,42 @@ fun derive_canon_coinductive_relations pclauses = end val ruvalhms = map2 prove_rule monothms (zip closthms defthms) val ruvalhm = end_itlist CONJ ruvalhms - (* - val dtms = map2 (curry list_mk_abs) vargs ants + + val dtms = map2 (curry list_mk_abs) vargs concs val double_fn = subst (map2 (curry op |->) rels dtms) fun mk_unbetas tm dtm = let val (avs,bod) = strip_forall tm val (il,r) = dest_comb bod val (i,l) = dest_comb il val bth = RIGHT_BETAS avs (REFL dtm) - val munb = AP_THM (AP_TERM i bth) r - val iunb = AP_TERM (mk_comb(i,double_fn l)) bth - val junb = AP_TERM (mk_comb(i,r)) bth + val munb = AP_THM (AP_TERM i bth) l + val iunb = AP_THM (AP_TERM i bth) (double_fn r) + val junb = AP_TERM (mk_comb(i,l)) bth val quantify = itlist MK_FORALL avs - in (quantify munb,(quantify iunb,quantify junb)) + in (quantify junb,(quantify iunb,quantify munb)) end val unths = map2 mk_unbetas pclauses dtms val irthm = EQ_MP (SYM(end_itlist MK_CONJ (map fst unths))) ruvalhm val mrthm = MP (SPECL rels (SPECL dtms monothm)) irthm val imrth = EQ_MP (SYM(end_itlist MK_CONJ (map (fst o snd) unths))) mrthm - val ifthm = MP (SPECL dtms indthm) imrth + val ifthm = MP (SPECL dtms coindthm) imrth val fthm = EQ_MP (end_itlist MK_CONJ (map (snd o snd) unths)) ifthm fun mk_case th1 th2 = let val avs = fst(strip_forall(concl th1)) - in GENL avs (IMP_ANTISYM_RULE (SPEC_ALL th1) (SPEC_ALL th2)) + in GENL avs (IMP_ANTISYM_RULE (SPEC_ALL th2) (SPEC_ALL th1)) end val casethm = end_itlist CONJ (map2 mk_case (CONJUNCTS fthm) (CONJUNCTS ruvalhm)) - *) - val todo = hd defthms - in (*CONJ ruvalhm (CONJ indthm casethm)*) - CONJ ruvalhm (CONJ coindthm todo) + in CONJ fthm (CONJ coindthm casethm) end - handle e => raise (wrap_exn "co_InductiveDefinition" + handle e => raise (wrap_exn "CoIndDefLib" "derive_canon_coinductive_relations"e); (* General case for nonschematic relations; monotonicity & defn hyps. *) + fun derive_nonschematic_coinductive_relations tm = let val clauses = strip_conj tm val canonthm = canonicalize_clauses clauses @@ -135,12 +134,11 @@ fun derive_nonschematic_coinductive_relations tm = val rawthm = derive_canon_coinductive_relations pclauses val (ruvalhm,otherthms) = CONJ_PAIR rawthm val (indthm,casethm) = CONJ_PAIR otherthms - (* TODO val ruvalhm' = EQ_MP canonthm' ruvalhm - and indthm' = CONV_RULE (ONCE_DEPTH_CONV (REWR_CONV canonthm')) indthm *) - in (* TODO CONJ ruvalhm' (CONJ indthm' casethm) *) rawthm + and indthm' = CONV_RULE (ONCE_DEPTH_CONV (REWR_CONV canonthm')) indthm + in CONJ ruvalhm' (CONJ indthm' casethm) end - handle e => raise (wrap_exn "co_InductiveDefinition" + handle e => raise (wrap_exn "CoIndDefLib" "derive_nonschematic_coinductive_relations" e); @@ -158,102 +156,51 @@ fun new_coinductive_definition monoset stem (tm,clocs) = val (i,c) = CONJ_PAIR ic in (GENL avs r, GENL avs i, GENL avs c) end - handle e => raise wrap_exn "co_InductiveDefinition" "new_coinductive_definition" e; + handle e => raise wrap_exn "CoIndDefLib" "new_coinductive_definition" e; (* ------------------------------------------------------------------------- *) -fun save_theorems name (rules, indn, strong_ind, cases) = let +fun save_theorems name (rules, coind, strong_ind, cases) = let in - (* save_thm(name^"_rules", rules); - save_thm(name^"_ind", indn); - save_thm(name^"_strongind", strong_ind); + save_thm(name^"_rules", rules); + save_thm(name^"_coind", coind); + (*save_thm(name^"_strongind", strong_ind);*) save_thm(name^"_cases", cases); - export_rule_induction (name ^ "_strongind") *) + (*export_rule_induction (name ^ "_strongind") *) () end -(* ------------------------------------------------------------------------- *) -(* entrypoints: *) +fun derive_strong_coinduction (rules, coind) = ((* TODO *)) + +(* ------------------------------------------------------------------------- ) +( Entrypoints: *) fun Hol_mono_coreln name monoset tm = let val _ = Lexis.ok_sml_identifier (name ^ !boolLib.def_suffix) orelse raise ERR "Hol_mono_coreln" ("Bad name for definition: "^ Lib.mlquote name^ " (use xHol_coreln to specify a better)") - val (rules, indn, cases) = new_coinductive_definition monoset name tm - (* not! InductiveDefinition.bool_monoset tm *) - val strong_ind = (*derive_strong_induction (rules, indn)*) () + val (rules, coind, cases) = new_coinductive_definition monoset name tm + val strong_ind = derive_strong_coinduction (rules, coind) in - save_theorems name (rules, indn, strong_ind, cases); - (rules, indn, cases) + save_theorems name (rules, coind, strong_ind, cases); + (rules, coind, cases) end handle e => raise (wrap_exn "CoIndDefLib" "Hol_mono_coreln" e); -fun xHol_coreln name q = Hol_mono_coreln name (!IndDefLib.the_monoset) (IndDefLib.term_of q) +fun xHol_coreln name q = + Hol_mono_coreln name (!IndDefLib.the_monoset) (IndDefLib.term_of q) fun Hol_coreln q = let - val parse = IndDefLib.term_of |> trace ("syntax_error", 0) + val parse = IndDefLib.term_of + |> trace ("syntax_error", 0) |> trace ("show_typecheck_errors", 0) - (* turn off verbiage because the Raise below will redisplay any - exceptions *) - val def as (def_t,_) = parse q + val def as (def_t, _) = parse q val name = IndDefLib.name_from_def def_t in Hol_mono_coreln name (!IndDefLib.the_monoset) def -end handle e => Raise (wrap_exn "IndDefLib" "Hol_coreln" e); - - - -(* DEBUGGING CODE *) - -fun coreln q = let - (* *) - val parse = IndDefLib.term_of |> trace ("syntax_error", 0) - |> trace ("show_typecheck_errors", 0) - (* turn off verbiage because the Raise below will redisplay any - exceptions *) - val tm as (def_t,_) = parse q - val name = name_from_def def_t - val monoset = (!IndDefLib.the_monoset) - - (* *) - val _ = Lexis.ok_sml_identifier (name ^ !boolLib.def_suffix) orelse - raise ERR "Hol_mono_coreln" - ("Bad name for definition: "^ Lib.mlquote name^ - " (use xHol_reln to specify a better)") - - (* new_coinductive_definition monoset stem (tm,clocs) *) - val stem = name - val (tm, clocs) = tm - val clauses = strip_conj tm - val (clauses',fvs) = unschematize_clauses clauses - val _ = check_definition fvs clocs (list_mk_conj clauses') - val check = check_definition fvs clocs (list_mk_conj clauses') - - (* derive_nonschematic_coinductive_relations *) - val tm = check - val clauses = strip_conj tm - val canonthm = canonicalize_clauses clauses - val canonthm' = SYM canonthm - val pclosed = rand(concl canonthm) - val pclauses = strip_conj pclosed - (* val rawthm = derive_canon_coinductive_relations pclauses *) - - in pclauses -end; - - - -(* simple test cases - -val pclauses = coreln`(N 0) /\ (N n ==> N (f n))`; - -val q = ` - (lrep_ok (\n. NONE)) - /\ lrep_ok (\n. if n = 0 then SOME h else t(n - 1)) -`; -*) +end handle e => Raise (wrap_exn "CoIndDefLib" "Hol_coreln" e); end (* CoIndDefLib *) diff --git a/src/IndDef/InductiveDefinition.sig b/src/IndDef/InductiveDefinition.sig index 086e99f409..1846af127a 100644 --- a/src/IndDef/InductiveDefinition.sig +++ b/src/IndDef/InductiveDefinition.sig @@ -24,12 +24,12 @@ sig val prove_monotonicity_hyps : monoset -> thm -> thm (* tools *) - val variants : term list -> term list -> term list + val variants : term list -> term list -> term list val HALF_BETA_EXPAND : term list -> thm -> thm + val make_definitions : string -> thm -> thm val canonicalize_clauses : term list -> thm val unschematize_clauses : term list -> term list * term list - val check_definition : term list -> locn list -> term -> term + val check_definition : term list -> locn.locn list -> term -> term val generalize_schematic_variables : term list -> thm -> thm - end diff --git a/src/boss/bossLib.sig b/src/boss/bossLib.sig index 74f450d6ed..734c22ffb3 100644 --- a/src/boss/bossLib.sig +++ b/src/boss/bossLib.sig @@ -18,15 +18,13 @@ sig val WF_REL_TAC : term quotation -> tactic val Hol_defn : string -> term quotation -> defn - (* new (inductive) relations *) + (* new (co-inductive) relations *) val Hol_reln : term quotation -> thm * thm * thm + val Hol_coreln : term quotation -> thm * thm * thm val xHol_reln : string -> term quotation -> thm * thm * thm + val xHol_coreln : string -> term quotation -> thm * thm * thm val export_mono : string -> unit - (* Derived rule for specifying new constants. - (Should have the same effect as Thm.new_specification.) *) - val new_specification : string * string list * thm -> thm - (* Case-splitting and induction operations *) val Cases : tactic @@ -86,9 +84,6 @@ sig val RW_TAC : simpset -> thm list -> tactic val SRW_TAC : ssfrag list -> thm list -> tactic - val NO_STRIP_FULL_SIMP_TAC : simpset -> thm list -> tactic - val NO_STRIP_REV_FULL_SIMP_TAC : simpset -> thm list -> tactic - (* Call-by-value evaluation *) val EVAL : term -> thm val EVAL_RULE : thm -> thm diff --git a/src/boss/bossLib.sml b/src/boss/bossLib.sml index 3a45a627f7..3db1e7c090 100644 --- a/src/boss/bossLib.sml +++ b/src/boss/bossLib.sml @@ -24,13 +24,11 @@ open HolKernel Parse boolLib pairLib simpLib metisLib pred_setLib local open listTheory optionTheory combinSyntax listSyntax optionSyntax numSyntax oneSyntax sumSyntax - (* EvalRef Lift; *) + EvalRef Lift; in end; val ERR = mk_HOL_ERR "bossLib"; -val new_specification = pairLib.new_specification; - (*---------------------------------------------------------------------------* Datatype definition *---------------------------------------------------------------------------*) @@ -45,15 +43,17 @@ val Datatype = Datatype.Datatype Function definition ---------------------------------------------------------------------------*) -val xDefine = TotalDefn.xDefine -val tDefine = TotalDefn.tDefine -val Define = TotalDefn.Define -val zDefine = Lib.with_flag (computeLib.auto_import_definitions,false) Define -val Hol_defn = Defn.Hol_defn -val Hol_reln = IndDefLib.Hol_reln +val xDefine = TotalDefn.xDefine +val tDefine = TotalDefn.tDefine +val Define = TotalDefn.Define +val zDefine = Lib.with_flag (computeLib.auto_import_definitions,false) Define +val Hol_defn = Defn.Hol_defn +val Hol_reln = IndDefLib.Hol_reln val xHol_reln = IndDefLib.xHol_reln +val Hol_coreln = CoIndDefLib.Hol_coreln +val xHol_coreln = CoIndDefLib.xHol_coreln val export_mono = IndDefLib.export_mono -val WF_REL_TAC = TotalDefn.WF_REL_TAC +val WF_REL_TAC = TotalDefn.WF_REL_TAC (*--------------------------------------------------------------------------- From d60e0ec32c95f8650a4cf54ab5c90623e3ece3b8 Mon Sep 17 00:00:00 2001 From: Andrea Condoluci Date: Thu, 20 Aug 2015 11:36:06 +1000 Subject: [PATCH 419/718] clean up --- src/{CoIndDef => IndDef}/CoIndDefLib.sig | 0 src/{CoIndDef => IndDef}/CoIndDefLib.sml | 0 2 files changed, 0 insertions(+), 0 deletions(-) rename src/{CoIndDef => IndDef}/CoIndDefLib.sig (100%) rename src/{CoIndDef => IndDef}/CoIndDefLib.sml (100%) diff --git a/src/CoIndDef/CoIndDefLib.sig b/src/IndDef/CoIndDefLib.sig similarity index 100% rename from src/CoIndDef/CoIndDefLib.sig rename to src/IndDef/CoIndDefLib.sig diff --git a/src/CoIndDef/CoIndDefLib.sml b/src/IndDef/CoIndDefLib.sml similarity index 100% rename from src/CoIndDef/CoIndDefLib.sml rename to src/IndDef/CoIndDefLib.sml From 7e9d8a2a8d573206643770be0f75e4c16d8799f1 Mon Sep 17 00:00:00 2001 From: Andrea Condoluci Date: Thu, 20 Aug 2015 11:44:05 +1000 Subject: [PATCH 420/718] update --- src/boss/bossLib.sig | 7 +++++++ src/boss/bossLib.sml | 14 ++++++++------ 2 files changed, 15 insertions(+), 6 deletions(-) diff --git a/src/boss/bossLib.sig b/src/boss/bossLib.sig index 734c22ffb3..6bf7d4fbf8 100644 --- a/src/boss/bossLib.sig +++ b/src/boss/bossLib.sig @@ -25,6 +25,10 @@ sig val xHol_coreln : string -> term quotation -> thm * thm * thm val export_mono : string -> unit + (* Derived rule for specifying new constants. + (Should have the same effect as Thm.new_specification.) *) + val new_specification : string * string list * thm -> thm + (* Case-splitting and induction operations *) val Cases : tactic @@ -84,6 +88,9 @@ sig val RW_TAC : simpset -> thm list -> tactic val SRW_TAC : ssfrag list -> thm list -> tactic + val NO_STRIP_FULL_SIMP_TAC : simpset -> thm list -> tactic + val NO_STRIP_REV_FULL_SIMP_TAC : simpset -> thm list -> tactic + (* Call-by-value evaluation *) val EVAL : term -> thm val EVAL_RULE : thm -> thm diff --git a/src/boss/bossLib.sml b/src/boss/bossLib.sml index 3db1e7c090..f2c395801f 100644 --- a/src/boss/bossLib.sml +++ b/src/boss/bossLib.sml @@ -24,11 +24,13 @@ open HolKernel Parse boolLib pairLib simpLib metisLib pred_setLib local open listTheory optionTheory combinSyntax listSyntax optionSyntax numSyntax oneSyntax sumSyntax - EvalRef Lift; + (* EvalRef Lift; *) in end; val ERR = mk_HOL_ERR "bossLib"; +val new_specification = pairLib.new_specification; + (*---------------------------------------------------------------------------* Datatype definition *---------------------------------------------------------------------------*) @@ -43,17 +45,17 @@ val Datatype = Datatype.Datatype Function definition ---------------------------------------------------------------------------*) -val xDefine = TotalDefn.xDefine -val tDefine = TotalDefn.tDefine -val Define = TotalDefn.Define -val zDefine = Lib.with_flag (computeLib.auto_import_definitions,false) Define +val xDefine = TotalDefn.xDefine +val tDefine = TotalDefn.tDefine +val Define = TotalDefn.Define +val zDefine = Lib.with_flag (computeLib.auto_import_definitions,false) Define val Hol_defn = Defn.Hol_defn val Hol_reln = IndDefLib.Hol_reln val xHol_reln = IndDefLib.xHol_reln val Hol_coreln = CoIndDefLib.Hol_coreln val xHol_coreln = CoIndDefLib.xHol_coreln val export_mono = IndDefLib.export_mono -val WF_REL_TAC = TotalDefn.WF_REL_TAC +val WF_REL_TAC = TotalDefn.WF_REL_TAC (*--------------------------------------------------------------------------- From fd1662ccd190cc6bad00ed00b9afe86264fee2e1 Mon Sep 17 00:00:00 2001 From: Andrea Condoluci Date: Thu, 20 Aug 2015 15:43:40 +1000 Subject: [PATCH 421/718] bugfixes --- src/IndDef/CoIndDefLib.sml | 68 ++++++++++++++++++-------------------- src/boss/bossLib.sig | 2 +- 2 files changed, 34 insertions(+), 36 deletions(-) diff --git a/src/IndDef/CoIndDefLib.sml b/src/IndDef/CoIndDefLib.sml index bd78e29128..fbbfa9e0cc 100644 --- a/src/IndDef/CoIndDefLib.sml +++ b/src/IndDef/CoIndDefLib.sml @@ -13,20 +13,19 @@ open HolKernel boolLib liteLib InductiveDefinition IndDefLib (* Prove definitions work for non-schematic relations with canonical rules. *) fun derive_canon_coinductive_relations pclauses = - let val closed = list_mk_conj pclauses - val pclauses = strip_conj closed - val (vargs,bodies) = split(map strip_forall pclauses) - val swap = fn (x, y) => (y, x) - val bodies = map mk_imp (map swap (map dest_imp bodies)) + let val (vargs, bodies) = split(map strip_forall pclauses) + val swap_fn = fn (x, y) => (y, x) + val bodies = map mk_imp (map swap_fn (map dest_imp bodies)) val pclauses = map list_mk_forall (zip vargs bodies) val closed = list_mk_conj pclauses - val (ants,concs) = split(map dest_imp bodies) + val (ants, concs) = split (map dest_imp bodies) val rels = map (repeat rator) ants val avoids = all_vars closed val rels' = variants avoids rels val prime_fn = subst (map2 (curry op |->) rels rels' ) val closed' = prime_fn closed + (* definition theorems *) fun mk_def arg ant = mk_eq(repeat rator ant, list_mk_abs(arg,list_mk_exists(rels', @@ -34,55 +33,53 @@ fun derive_canon_coinductive_relations pclauses = val deftms = map2 mk_def vargs ants val defthms = map2 HALF_BETA_EXPAND vargs (map ASSUME deftms) - fun rm_exists th rels' = (* fix the dest_exists with rels' *) - let val ant = hd (hyp th) - val (var, conj) = dest_exists ant - val (a, b) = dest_conj conj - val ex = EXISTS(ant, var) (ASSUME conj) - val th1 = PROVE_HYP ex th - val th2 = CONJ (ASSUME a) (ASSUME b) - in PROVE_HYP th2 th1 + (* coinductive theorems *) + fun rm_exists_left th = + let val ant = fst (dest_imp (concl th)) + val (vars, conj) = strip_exists ant + val ex_fn = fn (v, t) => EXISTS(mk_exists(v, concl t), v) t + val ex = foldl ex_fn (ASSUME conj) (rev vars) + val th1 = PROVE_HYP ex (UNDISCH th) + val (c1, c2) = dest_conj conj + val th2 = CONJ (ASSUME c1) (ASSUME c2) + in DISCH c1 (PROVE_HYP th2 th1) end fun mk_coind args th = - let val th1 = snd(EQ_IMP_RULE(SPEC_ALL th)) - val th2 = rm_exists (UNDISCH th1) rels' - val ant = hd (hyp th2) - in GENL args (DISCH ant (th2)) + let val th = snd(EQ_IMP_RULE(SPEC_ALL th)) + in GENL args (rm_exists_left th) end val coindthms = map2 mk_coind vargs defthms val coindthmr = end_itlist CONJ coindthms - val my_closed_why = (hd (hyp coindthmr)) - val coindthm = GENL rels'(DISCH my_closed_why coindthmr) + val coindthm = GENL rels'(DISCH closed' coindthmr) + (* mono theorems *) val mants = map2 (fn a => fn t => list_mk_forall(a,mk_imp(prime_fn t, t))) vargs concs val monotm = mk_imp(concl coindthmr, list_mk_conj mants) val monothm = ASSUME(list_mk_forall(rels,list_mk_forall(rels',monotm))) - - val closthm = ASSUME my_closed_why - + val closthm = ASSUME closed' val monothms = CONJUNCTS (MP (SPEC_ALL monothm) (MP (SPECL rels' coindthm) closthm)) val closthms = CONJUNCTS closthm - fun reverse_mess th rel = - let val a = hd (hyp th) (* FIXME *) - val b = my_closed_why - val conj = mk_conj(a, b) + (* rules *) + fun intro_exists_left th = + let val conj1 = fst (dest_imp (concl th)) + val conj = mk_conj(conj1, closed') val A = CONJUNCT1(ASSUME conj); val B = CONJUNCT2(ASSUME conj); - val step1 = PROVE_HYP A th; + val step1 = PROVE_HYP A (UNDISCH th); val step2 = PROVE_HYP B step1; - val ex = mk_exists(rel, conj) - in (ex, CHOOSE(rel, ASSUME ex) step2) + val ex_fn = fn (v, (t1, t2)) => + (mk_exists(v, t1), CHOOSE(v, ASSUME (mk_exists(v, t1))) t2) + in foldl ex_fn (conj, step2) (rev rels') end fun prove_rule mth (cth,dth) = - let val (avs,bod) = strip_forall(concl mth) + let val (avs, bod) = strip_forall(concl mth) val th1 = IMP_TRANS (SPECL avs cth) (SPECL avs mth) - val (ex, th1') = reverse_mess (UNDISCH th1) (hd rels') - (* FIXME: insted of GENL rels', I should exists all, not hd *) + val (ex, th1') = intro_exists_left th1 val th2 = DISCH ex th1' val th3 = IMP_TRANS (fst(EQ_IMP_RULE(SPECL avs dth))) th2 in GENL avs th3 @@ -90,6 +87,7 @@ fun derive_canon_coinductive_relations pclauses = val ruvalhms = map2 prove_rule monothms (zip closthms defthms) val ruvalhm = end_itlist CONJ ruvalhms + (* cases *) val dtms = map2 (curry list_mk_abs) vargs concs val double_fn = subst (map2 (curry op |->) rels dtms) fun mk_unbetas tm dtm = @@ -165,9 +163,9 @@ fun save_theorems name (rules, coind, strong_ind, cases) = let in save_thm(name^"_rules", rules); save_thm(name^"_coind", coind); - (*save_thm(name^"_strongind", strong_ind);*) + (* save_thm(name^"_strongind", strong_ind);*) save_thm(name^"_cases", cases); - (*export_rule_induction (name ^ "_strongind") *) + (* export_rule_induction (name ^ "_strongind") *) () end diff --git a/src/boss/bossLib.sig b/src/boss/bossLib.sig index 6bf7d4fbf8..64e75a1864 100644 --- a/src/boss/bossLib.sig +++ b/src/boss/bossLib.sig @@ -18,7 +18,7 @@ sig val WF_REL_TAC : term quotation -> tactic val Hol_defn : string -> term quotation -> defn - (* new (co-inductive) relations *) + (* new (inductive) relations *) val Hol_reln : term quotation -> thm * thm * thm val Hol_coreln : term quotation -> thm * thm * thm val xHol_reln : string -> term quotation -> thm * thm * thm From 146d6645022684726c1f74229217bcef3ac5ecd8 Mon Sep 17 00:00:00 2001 From: Andrea Condoluci Date: Thu, 20 Aug 2015 16:27:41 +1000 Subject: [PATCH 422/718] Start porting llists to Hol_coreln --- src/boss/bossLib.sml | 4 +-- src/llist/llistScript.sml | 69 +++++++++++++++------------------------ 2 files changed, 28 insertions(+), 45 deletions(-) diff --git a/src/boss/bossLib.sml b/src/boss/bossLib.sml index f2c395801f..0373bea9b3 100644 --- a/src/boss/bossLib.sml +++ b/src/boss/bossLib.sml @@ -49,8 +49,8 @@ val xDefine = TotalDefn.xDefine val tDefine = TotalDefn.tDefine val Define = TotalDefn.Define val zDefine = Lib.with_flag (computeLib.auto_import_definitions,false) Define -val Hol_defn = Defn.Hol_defn -val Hol_reln = IndDefLib.Hol_reln +val Hol_defn = Defn.Hol_defn +val Hol_reln = IndDefLib.Hol_reln val xHol_reln = IndDefLib.xHol_reln val Hol_coreln = CoIndDefLib.Hol_coreln val xHol_coreln = CoIndDefLib.xHol_coreln diff --git a/src/llist/llistScript.sml b/src/llist/llistScript.sml index eacf748f7d..8a85248302 100644 --- a/src/llist/llistScript.sml +++ b/src/llist/llistScript.sml @@ -12,18 +12,15 @@ val _ = new_theory "llist"; The representing type is :num -> 'a option ---------------------------------------------------------------------- *) -val lrep_ok_def = Define` - lrep_ok f = - ?P. (!g. P g ==> - (g = (\n. NONE)) \/ - ?h t. P t /\ (g = (\n. if n = 0 then SOME h else t(n - 1)))) /\ - P f +val (lrep_ok_rules, lrep_ok_coinduction, lrep_ok_cases) = Hol_coreln` + (lrep_ok (\n. NONE)) +/\ (lrep_ok t ==> lrep_ok (\n. if n = 0 then SOME h else t(n - 1))) `; val type_inhabited = prove( ``?f. lrep_ok f``, - Q.EXISTS_TAC `\n. NONE` THEN SRW_TAC [][lrep_ok_def] THEN - Q.EXISTS_TAC `(=) (\n.NONE)` THEN SRW_TAC [][]); + Q.EXISTS_TAC `\n. NONE` THEN ACCEPT_TAC(CONJUNCT1 lrep_ok_rules) +); val llist_tydef = new_type_definition ("llist", type_inhabited); @@ -60,32 +57,6 @@ val LCONS = new_definition( else llist_rep t (n - 1))`` ); -val lrep_ok_rules = prove( - ``lrep_ok (\n. NONE) /\ - (lrep_ok f ==> lrep_ok (\n. if n = 0 then SOME h else f (n - 1)))``, - SRW_TAC [][lrep_ok_def] THENL [ - Q.EXISTS_TAC `(=) (\n. NONE)` THEN SRW_TAC [][], - Q.EXISTS_TAC - `\f'. P f' \/ (f' = (\n. (if n = 0 then SOME h else f (n - 1))))` THEN - SRW_TAC [][] THEN METIS_TAC [] - ]); - -val lrep_ok_coinduction = prove( - ``(!f. P f ==> - (f = (\n. NONE)) \/ - ?h t. P t /\ (f = (\n. if n = 0 then SOME h else t(n - 1)))) ==> - !f. P f ==> lrep_ok f``, - SRW_TAC [][lrep_ok_def] THEN Q.EXISTS_TAC `P` THEN SRW_TAC [][]); - -val lrep_ok_cases = prove( - ``lrep_ok f = - (f = \n. NONE) \/ - (?h t. lrep_ok t /\ (f = \n. if n = 0 then SOME h else t (n - 1)))``, - SIMP_TAC (srw_ss() ++ DNF_ss)[EQ_IMP_THM, lrep_ok_rules] THEN - SRW_TAC [][lrep_ok_def] THEN RES_TAC THEN SRW_TAC [][] THEN - DISJ2_TAC THEN MAP_EVERY Q.EXISTS_TAC [`h`,`t`] THEN SRW_TAC [][] THEN - Q.EXISTS_TAC `P` THEN SRW_TAC [][]); - val llist_rep_LCONS = store_thm( "llist_rep_LCONS", ``llist_rep (LCONS h t) = @@ -134,13 +105,10 @@ val LHDTL_CONS_THM = store_thm( val lrep_inversion = prove( ``lrep_ok f ==> (f = \n. NONE) \/ - (?h t. lrep_ok t /\ (f = \n. if n = 0 then SOME h - else t (n - 1)))``, - SRW_TAC [][lrep_ok_def] THEN RES_TAC THENL [ - SRW_TAC [][], - DISJ2_TAC THEN MAP_EVERY Q.EXISTS_TAC [`h`, `t`] THEN - SRW_TAC [][] THEN Q.EXISTS_TAC `P` THEN SRW_TAC [][] - ]); + (?h t. (f = \n. if n = 0 then SOME h else t (n - 1)) + /\ lrep_ok t)``, + MATCH_ACCEPT_TAC (fst (EQ_IMP_RULE (SPEC_ALL lrep_ok_cases))) +); val forall_llist = prove( ``(!l. P l) = (!r. lrep_ok r ==> P (llist_abs r))``, @@ -267,9 +235,9 @@ val llist_ue_Axiom = store_thm( DISJ2_TAC THEN MAP_EVERY Q.EXISTS_TAC [`SND x'`, `\n. h f n (FST x')`] THEN CONJ_TAC THENL [ - Q.EXISTS_TAC `FST x'` THEN SRW_TAC [][], SRW_TAC [][FUN_EQ_THM] THEN Cases_on `n` THEN - SRW_TAC [][] + SRW_TAC [][], + Q.EXISTS_TAC `FST x'` THEN SRW_TAC [][] ] ]) THEN SRW_TAC [][EXISTS_UNIQUE_THM] THENL [ @@ -384,6 +352,21 @@ val LUNFOLD = new_specification bisimulation ---------------------------------------------------------------------- *) +(* STUB: Hol_coreln version + +val (x, llbis_coind, y) = Hol_coreln`(LLBIS LNIL LNIL) + /\ (LLBIS t1 t2 ==> LLBIS (h:::t1) (h:::t2))`; + +val LLIST_BISIMULATION0 = store_thm( + "LLIST_BISIMULATION0", + ``!ll1 ll2. (ll1 = ll2) = LLBIS ll1 ll2``, + REPEAT GEN_TAC THEN EQ_TAC THENL [ + Induct + ] +); + +*) + val LLIST_BISIMULATION0 = store_thm( "LLIST_BISIMULATION0", ``!ll1 ll2. (ll1 = ll2) = From abf4a044ee85803197398424084a4b7f500cb645 Mon Sep 17 00:00:00 2001 From: Andrea Condoluci Date: Thu, 20 Aug 2015 16:46:26 +1000 Subject: [PATCH 423/718] Removed STUB comment --- src/llist/llistScript.sml | 15 --------------- 1 file changed, 15 deletions(-) diff --git a/src/llist/llistScript.sml b/src/llist/llistScript.sml index 8a85248302..4a394992db 100644 --- a/src/llist/llistScript.sml +++ b/src/llist/llistScript.sml @@ -352,21 +352,6 @@ val LUNFOLD = new_specification bisimulation ---------------------------------------------------------------------- *) -(* STUB: Hol_coreln version - -val (x, llbis_coind, y) = Hol_coreln`(LLBIS LNIL LNIL) - /\ (LLBIS t1 t2 ==> LLBIS (h:::t1) (h:::t2))`; - -val LLIST_BISIMULATION0 = store_thm( - "LLIST_BISIMULATION0", - ``!ll1 ll2. (ll1 = ll2) = LLBIS ll1 ll2``, - REPEAT GEN_TAC THEN EQ_TAC THENL [ - Induct - ] -); - -*) - val LLIST_BISIMULATION0 = store_thm( "LLIST_BISIMULATION0", ``!ll1 ll2. (ll1 = ll2) = From fb4bda193c2a6ec1c20a1d5683c0cd228b7fc48a Mon Sep 17 00:00:00 2001 From: Andrea Condoluci Date: Fri, 21 Aug 2015 08:58:16 +1000 Subject: [PATCH 424/718] Fixed Holmakefile --- src/IndDef/Holmakefile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/IndDef/Holmakefile b/src/IndDef/Holmakefile index 277baf5282..9a1dfb0243 100644 --- a/src/IndDef/Holmakefile +++ b/src/IndDef/Holmakefile @@ -1,2 +1,2 @@ -selftest.exe: selftest.uo IndDefLib.uo IndDefRules.uo InductiveDefinition.uo +selftest.exe: selftest.uo IndDefLib.uo IndDefRules.uo InductiveDefinition.uo CoIndDefLib.uo $(HOLMOSMLC) -o $@ $< From c15f381c8165f8c19a35bce1175f8be266a11aba Mon Sep 17 00:00:00 2001 From: Thibault Gauthier Date: Sat, 22 Aug 2015 05:33:45 +0200 Subject: [PATCH 425/718] Release notes (Holyhammer) --- doc/next-release.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/doc/next-release.md b/doc/next-release.md index 0c91809c4c..6ba6a5ee6c 100644 --- a/doc/next-release.md +++ b/doc/next-release.md @@ -66,6 +66,10 @@ New theories: New tools: ---------- +- Holyhammer: A method for automatically finding relevant theorems for Metis. Given a term, the procedure selects a large number of lemmas through different predictors such as KNN or Mepo. These lemmas are given to the external provers E-prover, Vampire or Z3. The necessary lemmas in the provers' proofs are then returned to the user. + Modifications to the kernels to track dependencies between theorems allow predictors to learn from the induced relation improving future predictions. + The build of the source directory `src/holyhammer` needs ocaml (> 3.12.1) installed as well as a recent version of g++ that supports the c++11 standard. The three ATPs have to be installed independently. At least one of them should be present, preferably E-prover. + New examples: --------- From 9e3aa89529d9dabfc7f244c6c376e61cdad754cf Mon Sep 17 00:00:00 2001 From: Thibault Gauthier Date: Sat, 22 Aug 2015 16:32:42 +0200 Subject: [PATCH 426/718] holyHammer update: provers' binaries now needs to be in PATH + working toward incremental export --- src/holyhammer/README | 44 +- src/holyhammer/examples/presentation.sml | 12 +- src/holyhammer/hh/Holmakefile | 8 +- src/holyhammer/hh/README | 15 - src/holyhammer/hh/features.ml | 54 ++ src/holyhammer/hh/hh1/hh_tac.ml | 27 +- src/holyhammer/hh/hh1/hh_write.ml | 14 +- src/holyhammer/hh/init.ml | 42 +- src/holyhammer/hh/main.ml | 3 +- src/holyhammer/hh/predict.ml | 5 + src/holyhammer/hh/prepredict.ml | 24 +- src/holyhammer/hh/read.ml | 30 +- src/holyhammer/hh/toolbox.ml | 82 ++ src/holyhammer/hhReconstruct.sig | 1 - src/holyhammer/hhReconstruct.sml | 78 +- src/holyhammer/hhWriter.sig | 4 +- src/holyhammer/hhWriter.sml | 96 +- src/holyhammer/holyHammer.sig | 3 +- src/holyhammer/holyHammer.sml | 79 +- src/holyhammer/provers/eprover.sh | 9 +- .../provers/eprover/COPYING_eprover | 877 ------------------ src/holyhammer/provers/vampire.sh | 5 +- src/holyhammer/provers/vampire/README | 2 - src/holyhammer/provers/z3.sh | 7 +- src/holyhammer/provers/z3/LICENSE.txt | 7 - src/holyhammer/provers/z3/README | 2 - src/holyhammer/scripts/hh.sh | 8 +- src/holyhammer/scripts/hh_clean.sh | 6 - src/holyhammer/scripts/hh_eprover.sh | 2 +- src/holyhammer/scripts/hh_vampire.sh | 2 +- src/holyhammer/scripts/hh_z3.sh | 2 +- 31 files changed, 454 insertions(+), 1096 deletions(-) delete mode 100644 src/holyhammer/hh/README create mode 100644 src/holyhammer/hh/features.ml create mode 100644 src/holyhammer/hh/toolbox.ml delete mode 100644 src/holyhammer/provers/eprover/COPYING_eprover delete mode 100644 src/holyhammer/provers/vampire/README delete mode 100644 src/holyhammer/provers/z3/LICENSE.txt delete mode 100644 src/holyhammer/provers/z3/README diff --git a/src/holyhammer/README b/src/holyhammer/README index fae32d165e..fa1a15d434 100644 --- a/src/holyhammer/README +++ b/src/holyhammer/README @@ -5,7 +5,7 @@ Requires: * OCaml >= 3.12 sudo apt-get install ocaml * g++ >= 4.8 (recent version with C++11 support) - Ubuntu 12.04: + Ubuntu 12.04: sudo add-apt-repository ppa:ubuntu-toolchain-r/test -y sudo apt-get update sudo apt-get install g++-4.8 @@ -18,26 +18,30 @@ Install holyhammer: (done during the build) run Holmake in src/holyhammer/predict run Holmake in src/holyhammer/predict/mepo -Adding provers: +Supported provers: Eprover, Vampire and Z3 + + Eprover: + Tested with 1.8 and 1.9. + Vampire: + Tested with version 2.6. Parsing may need changing for higher versions + Z3: + Tested with 4.0. The newest version of z3 does not support + tptp input. Can be fetch from http://isabelle.in.tum.de/components/. + CVC4: + Waiting for a good minimization algorithm to be implemented + as it does not output have unsatisfiable cores. - Eprover and Z3 are given by default are for linux 64 bit. - Please replace the binary in provers/eprover/eprover if necessary. - You may use different versions but parsing may need to be fixed in - provers/"prover".sh . - The name of the binary for Vampire has to be vampire. - -Removing provers: - - Delete the binaries (eprover,z3 or vampire) in - their respective directory provers/"prover". - Predictors: - The two best predictors are KNN and Mepo. - Mepo works best for a definition based proof with small theorems - KNN learns from previous proofs so it is useful on well developed theories. - The default predictor is KNN. - Please switch between them if the proof fails by using - "set_predictors Mepo;" and "set_predictors Knn;" + + The two best predictors are KNN and Mepo. The default predictor is KNN. + - Mepo works best when your conjecture has rare symbols. + - KNN learns from previous proofs. + - Kepo is a combination of the previous two. + They have different strength so please switch between predictors: + - "set_predictors KNN;" + - "set_predictors Mepo;" + - "set_predictors Kepo;" + Alternatively, you can call hh_try which tries all of them sequentially. Example: @@ -45,8 +49,6 @@ Example: open holyHammer; hh [] ``1 + 1 = 2``; METIS_PROVE lemmas ``1 + 1 = 2``; - load "complexTheory"; - hh_atp "eprover" [] ``0 <> 1``; Questions: diff --git a/src/holyhammer/examples/presentation.sml b/src/holyhammer/examples/presentation.sml index 6fa8dc7b56..e9fd4d2cf3 100644 --- a/src/holyhammer/examples/presentation.sml +++ b/src/holyhammer/examples/presentation.sml @@ -4,9 +4,10 @@ open holyHammer; hh [] ``54 + 35 = 89``; load "transcTheory"; -M -val cj = ``1 = cos x * cos x + sin x * sin x``; +val cj = ``1 = cos x * cos x + sin x * sin x``; +val lemmas = [fetch "real" "REAL_ADD_SYM", fetch "real" "POW_2", + fetch "transc" "SIN_CIRCLE"]; val thm = save_thm ("LEM1",METIS_PROVE lemmas cj); val cj = ``cos (2 * x) + 1 = @@ -17,13 +18,13 @@ val thm = save_thm ("LEM2",METIS_PROVE lemmas cj); val cj = ``(a = b - c + (b + c)) ==> (a = b + b)``; val thm = save_thm ("LEM3",METIS_PROVE lemmas cj); +(* set_timeout 30; + Eprover alone doesn't find a proof even with Mepo predictions *) val cj = ``cos (2 * x) = 2 * cos x pow 2 - 1``; -set_predictors Mepo; val thm = save_thm ("LEM4",METIS_PROVE (thm :: lemmas) cj); +(* set_timeout 5; *) val cj = ``2 * cos x pow 2 = 1 + cos (2*x)``; -set_predictors KNN; -set_timeout 15; val thm = save_thm ("LEM5",METIS_PROVE lemmas cj); val cj = ``(2:real * a:real = b) ==> (a:real = b/2:real)``; @@ -32,4 +33,3 @@ val thm = save_thm ("LEM6",METIS_PROVE lemmas cj); val cj = ``cos x pow 2 = (1 + cos (2*x))/2``; val thm = save_thm ("COS_LIN",METIS_PROVE lemmas cj); - diff --git a/src/holyhammer/hh/Holmakefile b/src/holyhammer/hh/Holmakefile index 49d9d05ea0..473e2de26d 100644 --- a/src/holyhammer/hh/Holmakefile +++ b/src/holyhammer/hh/Holmakefile @@ -2,8 +2,8 @@ ifneq ($(which ocamlopt),) -HH2_CMX=hh_parse.cmx hh_lexer.cmx read.cmx predict.cmx preprocess.cmx init.cmx \ -dependency.cmx thf1hh1.cmx prepredict.cmx write.cmx +HH2_CMX=toolbox.cmx hh_parse.cmx hh_lexer.cmx read.cmx predict.cmx preprocess.cmx init.cmx \ +dependency.cmx thf1hh1.cmx features.cmx prepredict.cmx write.cmx HL_CMX=hh1/lib.cmx hh1/fusion.cmx hh1/basics.cmx hh1/printer.cmx \ hh1/preterm.cmx hh1/hl_parser.cmx hh1/equal.cmx hh1/bool.cmx \ @@ -29,6 +29,8 @@ hh_parse.ml: hh_parse.mly hh_lexer.ml: hh_lexer.mll hh_parse.ml ocamllex $< +toolbox.cmx: toolbox.ml + ocamlopt -c -I hh1 $< hh_parse.cmx: hh_parse.ml ocamlopt -c $< hh_lexer.cmx: hh_lexer.ml @@ -45,6 +47,8 @@ dependency.cmx: dependency.ml ocamlopt -c -I hh1 $< thf1hh1.cmx: thf1hh1.ml ocamlopt -c -I hh1 $< +features.cmx: features.ml + ocamlopt -c -I hh1 $< prepredict.cmx: prepredict.ml ocamlopt -c -I hh1 $< write.cmx: write.ml diff --git a/src/holyhammer/hh/README b/src/holyhammer/hh/README deleted file mode 100644 index 580468b690..0000000000 --- a/src/holyhammer/hh/README +++ /dev/null @@ -1,15 +0,0 @@ -This is HH / THF0 batch processor. - -Requires: -* OCaml >= 3.12 (tested also with 4.01.0) -* g++ (recent version with C++11 support) -* eproof (the eprover proof-reconstruction script); needs to be in PATH - -To compile: -* run make in hh1 subdir -* run make in predict subdir -* run make - -To test fun for example: -./hhthf0 30 example/test_theorem.p -./hhthf0 3 example/test_timeout.p diff --git a/src/holyhammer/hh/features.ml b/src/holyhammer/hh/features.ml new file mode 100644 index 0000000000..5a9ad7bb37 --- /dev/null +++ b/src/holyhammer/hh/features.ml @@ -0,0 +1,54 @@ +(*-------------------------------------------------------------------------- + Precomputing the features. + -------------------------------------------------------------------------- *) + +open Thf1hh1 +open Toolbox + +(* Optimization for multiple experiments (memorize previous call of get_symbols) *) +let feature_hash = ref (Hashtbl.create 20000) + +let feature_of thm = + try Hashtbl.find !feature_hash thm + with _ -> + let l = Hh_symbols.get_symbols (term_of thm) in + Hashtbl.add (!feature_hash) thm l; + l + +(* Never store the current theory as it may changed *) +let string_of_feature thm = (thm ^ " " ^ String.concat " " (feature_of thm)) + +let export_features dir thmlo thy = + let fname = dir ^ "/" ^ thy ^ ".fea" in + let thml = List.assoc thy thmlo in + let l = List.map string_of_feature thml in + writel fname l + +let updating_features dir ct_option = + let ((tyl,cl,thml),(deph,roleh,thmlo),(feah,fea_thyl)) = + Init.init_dir_features dir + in + feature_hash := feah; + let thyl = List.map fst thmlo in + let not_ct x = match ct_option with + None -> true + | Some ct -> ct <> x in + let updatable_thy thy = not (List.mem thy fea_thyl) && not_ct thy in + let mthyl = List.filter updatable_thy thyl in + print_string ("- computing features for " ^ + string_of_int (List.length mthyl) ^ " theories\n"); + let mthml = List.concat (List.map (fun x -> List.assoc x thmlo) mthyl) in + let mthml2 = List.filter (fun (x,_) -> List.mem x mthml) thml in + Thf1hh1.parse (tyl,cl,mthml2); + List.iter (export_features dir thmlo) mthyl + +(* Running +terminal command: rlwrap ./top -I hh1 + +open Features;; +open Toolbox;; +let dir = "../palibs/cakeml";; + +updating_features dir None;; +time_here Init.init_dir_features dir;; +*) diff --git a/src/holyhammer/hh/hh1/hh_tac.ml b/src/holyhammer/hh/hh1/hh_tac.ml index b7ef95a2a5..9917fe0ee3 100644 --- a/src/holyhammer/hh/hh1/hh_tac.ml +++ b/src/holyhammer/hh/hh1/hh_tac.ml @@ -127,10 +127,13 @@ let get_minarg tm sofar = (*let happ_def = new_definition (parse_term "(happ : ((A -> B) -> A -> B)) = I");;*) let happ_conv_th = Sequent ([],parse_term "!(f:A->B) x. f x = happ f x");; +(* For ATP learning: Thibault and Josef *) let happ_conv = rEWR_CONV happ_conv_th;; let rec happ_n_conv n tm = if n = 1 then happ_conv tm else (tHENC (rATOR_CONV (happ_n_conv (n - 1))) happ_conv) tm;; + + let fol_conv_assoc op (cmin,vmin) = if is_const op then assoc (fst (dest_const op)) cmin else if is_var op then try assoc (fst (dest_var op)) vmin with _ -> 0 else failwith "fol_conv_assoc";; @@ -185,8 +188,8 @@ let escape_to_hex s = for i = 0 to String.length s - 1 do begin match String.unsafe_get s i with ('a'|'b'|'c'|'d'|'e'|'f'|'g'|'h'|'i'|'j'|'k'|'l'|'m'|'n'|'o'|'p'|'q'|'r'|'s'|'t'|'u'|'v'|'w'|'x'|'y'|'z' - |'A'|'B'|'C'|'D'|'E'|'F'|'G'|'H'|'I'|'J'|'K'|'L'|'M'|'N'|'O'|'P'|'Q'|'R'|'S'|'T'|'U'|'V'|'W'|'X'|'Y'|'Z' - |'0'|'1'|'2'|'3'|'4'|'5'|'6'|'7'|'8'|'9' as c) -> String.unsafe_set s' !n c + |'A'|'B'|'C'|'D'|'E'|'F'|'G'|'H'|'I'|'J'|'K'|'L'|'M'|'N'|'O'|'P'|'Q'|'R'|'S'|'T'|'U'|'V'|'W'|'X'|'Y'|'Z' + |'0'|'1'|'2'|'3'|'4'|'5'|'6'|'7'|'8'|'9' as c) -> String.unsafe_set s' !n c | '_' -> String.unsafe_set s' !n '_'; incr n; String.unsafe_set s' !n '_' | c -> let c = Char.code c in String.unsafe_set s' !n '_'; incr n; @@ -207,17 +210,17 @@ let is_letter c = (is_lowercase c) or (is_uppercase c) (* We don't have complete control over the names of - the type variables so we escape them completely *) + the type variables so we escape them completely + (for example the sytem may name them "'a" which clash with our + escaping method'word') +*) let escape_var s = - let s1 = escape_to_hex s in - if is_letter s1.[0] - then String.capitalize s1 - else "V" ^ s1 - -let escape_obj s = - if (s.[0] = '\'') or (is_lowercase s.[0]) then s else add_prime s + let s1 = escape_to_hex s in "V" ^ s1 +let escape_const s = let s1 = escape_to_hex s in "c" ^ s1 +let escape_thm s = + if (s.[0] = '\'') or (is_lowercase s.[0]) then s else add_prime s (* Less explosive version of pOLY_ASSUME_TAC *) let rec fold_cs fn tm sofar = @@ -293,10 +296,10 @@ let pOLY_ASSUME_TAC names ths (asl,w as gl) = let ths3 = List.map map_fun ths2 in let ths4 = List.concat ths3 in (* let names, ths' = List.split ths4 in*) - mAP_EVERY (fun (n, th) -> lABEL_TAC (escape_obj n) th) ths4 gl;; + mAP_EVERY (fun (n, th) -> lABEL_TAC (escape_thm n) th) ths4 gl;; let lABEL_ASSUME_TAC names ths = - mAP_EVERY (fun (n, th) -> lABEL_TAC (escape_obj n) th) (zip names ths);; + mAP_EVERY (fun (n, th) -> lABEL_TAC (escape_thm n) th) (zip names ths);; (* lAMBDA_ELIM_CONV2 does less explosive lambda-lifting than lAMBDA_ELIM_CONV for universally quantified theorems; all the quantified variables do not diff --git a/src/holyhammer/hh/hh1/hh_write.ml b/src/holyhammer/hh/hh1/hh_write.ml index 74c9581aac..8628fce0bf 100644 --- a/src/holyhammer/hh/hh1/hh_write.ml +++ b/src/holyhammer/hh/hh1/hh_write.ml @@ -78,13 +78,13 @@ let name_tscs_mono_fold ho (tys, cs, used) tm () = if is_type ty then let s, stys = dest_type ty in List.iter name_ty stys; - String.concat "" (escape_obj s :: (map (fun x -> Hashtbl.find tys x) stys)) + String.concat "" (escape_const s :: (map (fun x -> Hashtbl.find tys x) stys)) else print_vartype ty in let n = variant_name_hash n used in Hashtbl.replace tys ty n in List.iter name_ty ctys; if Hashtbl.mem cs tm or is_var tm then () else - let n = escape_obj (fst (dest_const tm)) in + let n = escape_const (fst (dest_const tm)) in let n = variant_name_hash n used in Hashtbl.replace cs tm n ;; @@ -94,7 +94,7 @@ let name_tscs_poly_fold (tys, cs, used) tm () = if is_type ty then let s, stys = dest_type ty in (if Hashtbl.mem tys s then () else - Hashtbl.replace tys s (variant_name_hash (escape_obj s) used)); + Hashtbl.replace tys s (variant_name_hash (escape_const s) used)); List.iter name_ty stys; else let s = dest_vartype ty in @@ -105,12 +105,12 @@ let name_tscs_poly_fold (tys, cs, used) tm () = if is_var tm then let s = fst (dest_var tm) in if Hashtbl.mem cs ("`" ^ s) then () else - let n = variant_name_hash (escape_obj s) used in + let n = variant_name_hash (escape_const s) used in Hashtbl.replace cs ("`" ^ s) n else let s, _ = dest_const tm in if Hashtbl.mem cs s then () else - let n = variant_name_hash (escape_obj s) used in + let n = variant_name_hash (escape_const s) used in Hashtbl.replace cs s n ;; @@ -539,7 +539,7 @@ let tff_gl_hash oc names name asms gl (ts,cs,used) = List.iter output_const (fst (get_mindata (asms, gl))); os oc "% AXIOMS\n"; List.iter2 (fun n t -> ohdr n "axiom"; tff_pred oc cs ts used t; otl ()) names asms; - ohdr (escape_obj name) "conjecture"; tff_pred oc cs ts used gl; otl (); + ohdr (escape_thm name) "conjecture"; tff_pred oc cs ts used gl; otl (); ;; let tff_gl oc names name asms gl = @@ -615,7 +615,7 @@ let fof_gl_hash oc names name asms gl (ts,cs,used) = let ohdr s1 s2 = os oc "fof("; os oc s1; os oc ", "; os oc s2; os oc ", " in let otl () = os oc ").\n" in List.iter2 (fun n t -> ohdr n "axiom"; fof_pred oc cs ts used t; otl ()) names asms; - ohdr (escape_obj name) "conjecture"; fof_pred oc cs ts used gl; otl (); + ohdr (escape_thm name) "conjecture"; fof_pred oc cs ts used gl; otl (); ;; let fof_gl_mk_hash terms = diff --git a/src/holyhammer/hh/init.ml b/src/holyhammer/hh/init.ml index c3b0d0b3f0..8537a147fe 100644 --- a/src/holyhammer/hh/init.ml +++ b/src/holyhammer/hh/init.ml @@ -45,13 +45,16 @@ let print_info (dir,tyl,cl,thml,thmlo) = print_string ("- theorems: " ^ string_of_int (List.length thml) ^ "\n"); print_string ("- theories: "^ string_of_int (List.length thmlo) ^ "\n\n") -(* HOL-Light and HOL4 *) +let really_big_theorems = ref [] (* only used for information *) + let init_dir dir = let (deph,tmll) = Read.read_dir dir in let tmll = drop_tt tmll in (* remove the TPTP "tt" prefix *) (* let (deph,tmll) = split_lib (deph,tmll) in *) (* splits under quantifiers removed *) let (tyl,cl,thml) = get_tyl_cl_thml (flatten_tmll tmll) in - let big_thml = List.map fst (List.filter (fun (_,t) -> size_of t >= 2000) thml) in + really_big_theorems := + List.map fst (List.filter (fun (_,t) -> size_of t >= 2000) thml); + let big_thml = !really_big_theorems in let tmll = foreach_filter (fun (s,r,t) -> is_thm (s,r,t) && not (List.mem s big_thml)) tmll in let short_thml = List.filter (fun (s,_) -> not (List.mem s big_thml)) thml in let deph = remove_deph big_thml deph in @@ -60,7 +63,14 @@ let init_dir dir = print_info (dir,tyl,cl,thml,thmlo); ((tyl,cl,short_thml),(deph,roleh,thmlo)) -(* Experiments : matching *) +let init_dir_features dir = + let ((tyl,cl,thml),(deph,roleh,thmlo)) = init_dir dir in + let (feah,fea_thyl) = Read.read_features_dir dir in + ((tyl,cl,thml),(deph,roleh,thmlo),(feah,fea_thyl)) + +(* Gives an additional prefix to all the objects in the directory + (useful for matching different libraries) +*) let init_dir_prefix prefix dir = let (deph,tmll) = Read.read_dir dir in let tmll = drop_tt tmll in (* remove the TPTP "tt" prefix *) @@ -77,29 +87,3 @@ let init_dir_prefix prefix dir = print_info (dir,tyl,cl,thml,thmlo); ((tyl,cl,thml),(deph,roleh,thmlo)) -(* TO BE UPDATED: -(* Mizar *) -let init_dir_miz dir = - let tmll = Read.read_dir_nodep dir in - let tmll = miz_split_fc (drop_tt tmll) in - let thml = List.map (fun (x,y,z) -> (x,z)) (flatten_tmll tmll) in - let thmlo = foreach_map (fun (x,y,z) -> x) tmll in - print_info_miz (dir,thml,thmlo); - (thml,thmlo) - -(* - let h = Read.read_thy_graph (dir ^ "/thygraph") in - let -*) - -(* Matita and Coq *) -let init_dir_mat dir = - let thylo = Read.read_thy_lo (dir ^ "/thyorder") in - let tmll = Read.read_dir_nodep dir in - let tmll = List.map (fun x -> (x, List.assoc x tmll)) thylo in - let tmll = miz_split_fc (drop_tt tmll) in - let (tyl,cl,thml) = get_tyl_cl_thml (flatten_tmll tmll) in - let thmlo = foreach_map (fun (x,y,z) -> x) tmll in - print_info (dir,tyl,cl,thml,thmlo); - (tyl,cl,thml,thmlo) -*) diff --git a/src/holyhammer/hh/main.ml b/src/holyhammer/hh/main.ml index b9c7e423a5..1c12620245 100644 --- a/src/holyhammer/hh/main.ml +++ b/src/holyhammer/hh/main.ml @@ -36,7 +36,7 @@ let parse_commandline () = "Warning: all theories that do not belong to this order are ignored.")] in let usage_msg = "HOL(y) Hammer. Usage: " ^ - Sys.argv.(0) ^ " " + Sys.argv.(0) ^ " " in Arg.parse speclist parse_anon usage_msg; (* Processing the parsed objects. *) @@ -45,6 +45,7 @@ let parse_commandline () = | "nbayes" -> NaiveBayes | "mepo" -> Mepo | "geo" -> Geo + | "kepo" -> Kepo | _ -> failwith "Unknown predictor." in let n_predictions = try int_of_string (anon_tab.(1)) with _ -> failwith "Number of predictions have to be an integer." in diff --git a/src/holyhammer/hh/predict.ml b/src/holyhammer/hh/predict.ml index 82737b07f7..9b8921618c 100644 --- a/src/holyhammer/hh/predict.ml +++ b/src/holyhammer/hh/predict.ml @@ -82,6 +82,11 @@ let geo_advice2 fname limit = 1 0.99 s s limit s s s s in cpp_advice2 fname cmd +let kepo_advice2 fname limit = + let l1 = mepo_advice2 fname limit in + let l2 = knn_advice2 fname limit in + Toolbox.mk_set (l1 @ l2) + (* Matching experiments *) let nb_advice3 fname limit = diff --git a/src/holyhammer/hh/prepredict.ml b/src/holyhammer/hh/prepredict.ml index 22d33775e0..fe217900cd 100644 --- a/src/holyhammer/hh/prepredict.ml +++ b/src/holyhammer/hh/prepredict.ml @@ -3,13 +3,13 @@ (* and features. *) (*-------------------------------------------------------------------------- *) +open Features open Dependency open Thf1hh1 (*-------------------------------------------------------------------------- Preparing files for the predictor -------------------------------------------------------------------------- *) -let feature_of thm = Hh_symbols.get_symbols (term_of thm) let os = output_string @@ -58,14 +58,20 @@ let predict_print_all fname axl cjname = Running the predictor -------------------------------------------------------------------------- *) -type predictor = KNN | NaiveBayes | Mepo | Geo - -let run_predictor = function - KNN -> Predict.knn_advice2 -| NaiveBayes -> Predict.nb_advice2 -| Mepo -> Predict.mepo_advice2 -| Geo -> Predict.geo_advice2 - +type predictor = KNN | NaiveBayes | Mepo | Geo | Kepo + +let run_predictor p fname limit = + if limit <= 0 + then [] + else + begin + match p with + KNN -> Predict.knn_advice2 fname limit + | NaiveBayes -> Predict.nb_advice2 fname limit + | Mepo -> Predict.mepo_advice2 fname limit + | Geo -> Predict.geo_advice2 fname limit + | Kepo -> Predict.kepo_advice2 fname limit + end let predict_wrap predictor file_prefix n cj axl = predict_print_all file_prefix axl cj; diff --git a/src/holyhammer/hh/read.ml b/src/holyhammer/hh/read.ml index 131a7842e4..93cf68ef3c 100644 --- a/src/holyhammer/hh/read.ml +++ b/src/holyhammer/hh/read.ml @@ -10,10 +10,12 @@ let lib_dir = "../palibs" let dir_of_itp p = match p with - "h4" -> lib_dir ^ "/h4-kananaskis9/standard_library" - | "hl" -> lib_dir ^ "/hl-225/complex_multivariate" - | "h4core" -> lib_dir ^ "/h4-kananaskis9/core_library" + "h4" -> lib_dir ^ "/h4-kananaskis10/standard_library" + | "hl" -> lib_dir ^ "/hl-225/standard_library" + | "h4core" -> lib_dir ^ "/h4-kananaskis10/core_library" | "hlcore" -> lib_dir ^ "/hl-225/core_library" + | "h4exp" -> lib_dir ^ "/h4-kananaskis10/exp_library" + | "hlexp" -> lib_dir ^ "/hl-225/exp_library" | _ -> failwith "dir_of_prover" let thydep_of_itp p = dir_of_itp p ^ "/info/theory_dep" let thyorder_of_itp p = dir_of_itp p ^ "/info/theory_order" @@ -64,16 +66,17 @@ let find_ext dir ext = let find_p dir = find_ext dir ".p" let find_hd dir = find_ext dir ".hd" +let find_fea dir = find_ext dir ".fea" -(* To be moved to mizar and coq export +(* TODO: To be moved to mizar and coq export *) let find_xml2 dir = find_ext dir ".xml2" let find_con_xml dir = find_ext dir ".con.xml" let find_ind_xml dir = find_ext dir ".ind.xml" let find_con_body_xml dir = find_ext dir ".con.body.xml" -*) + (*-------------------------------------------------------------------------- - Parsing statements (.p) and dependencies (.hd). + Parsing statements (.p) and dependencies (.hd) and features (.fea) -------------------------------------------------------------------------- *) (* Parsing statements *) @@ -127,10 +130,25 @@ let read_deps dir filel = List.iter (fun f -> file_iter (dir ^ "/" ^ f) (add f)) filel; hash +(* Parsing features *) +let read_features dir filel = + let hash = Hashtbl.create 20000 in + let add fname _ line = + match Str.split rxpspace line with + [] -> failwith ("empty .fea file line: " ^ fname) + | h :: t -> Hashtbl.add hash h t + in + List.iter (fun f -> file_iter (dir ^ "/" ^ f) (add f)) filel; + (hash, List.map Filename.chop_extension filel) + (*-------------------------------------------------------------------------- Main reading functions -------------------------------------------------------------------------- *) +(* Features *) +let read_features_dir dir = + let fea = find_fea dir in read_features dir fea + (* Statements + Dependencies *) let read_dir dir = let hds = find_hd dir in diff --git a/src/holyhammer/hh/toolbox.ml b/src/holyhammer/hh/toolbox.ml new file mode 100644 index 0000000000..dece8d6bc8 --- /dev/null +++ b/src/holyhammer/hh/toolbox.ml @@ -0,0 +1,82 @@ +(*-------------------------------------------------------------------------- *) +(* Useful functions used troughout the developments *) +(*-------------------------------------------------------------------------- *) + +(*-------------------------------------------------------------------------- + Debugging + -------------------------------------------------------------------------- *) + +let log_file file str = + let oc = open_out_gen [Open_creat; Open_text; Open_append] 0o640 file in + output_string oc str; + close_out oc + +let logfile = "matching_log" +let logs s = log_file logfile s + +let time name f x = + let t = Sys.time() in + let fx = f x in + logs (name ^ ": " ^ string_of_float (Sys.time() -. t) ^ "sec\n"); + fx + +let time_here f x = + let t = Sys.time() in + let fx = f x in + print_string (string_of_float (Sys.time() -. t) ^ "sec\n"); + fx + +(*-------------------------------------------------------------------------- + IO + -------------------------------------------------------------------------- *) +let erase_file file = + let oc = open_out file in + output_string oc ""; + close_out oc + +let readl file = +let lines = ref [] in +let chan = open_in file in +try + while true; do + lines := input_line chan :: !lines + done; !lines +with End_of_file -> + close_in chan; + List.rev !lines ;; + +let writel file strl = + let oc = open_out file in + List.iter (Printf.fprintf oc "%s\n") strl; + close_out oc + +let append file str = + let oc = open_out_gen [Open_creat; Open_text; Open_append] 0o640 file in + output_string oc str; + close_out oc + +(*-------------------------------------------------------------------------- + List + -------------------------------------------------------------------------- *) + +let rec first_n n l = + if n <= 0 || l = [] + then [] + else List.hd l :: first_n (n - 1) (List.tl l) + +let rec mk_set l = match l with + [] -> [] + | a :: m -> if List.mem a m then mk_set m else a :: mk_set m + +let rec sum fl = if fl = [] then 0. else List.hd fl +. (sum (List.tl fl)) + +(*-------------------------------------------------------------------------- + Hash + -------------------------------------------------------------------------- *) + +let values_of_hash hash = Hashtbl.fold (fun k v l -> v :: l) hash [] +let keys_of_hash hash = Hashtbl.fold (fun k v l -> k :: l) hash [] +let alist_of_hash hash = Hashtbl.fold (fun k v l -> (k,v) :: l) hash [] + + + diff --git a/src/holyhammer/hhReconstruct.sig b/src/holyhammer/hhReconstruct.sig index 6675d46f08..7e70635266 100644 --- a/src/holyhammer/hhReconstruct.sig +++ b/src/holyhammer/hhReconstruct.sig @@ -1,7 +1,6 @@ signature hhReconstruct = sig - include Abbrev val minimize_flag : bool ref val reconstruct : thm list -> (string * string) -> term -> unit val reconstructl : thm list -> (string * string) list -> term -> unit diff --git a/src/holyhammer/hhReconstruct.sml b/src/holyhammer/hhReconstruct.sml index a5bec7eee9..fab59b95ea 100644 --- a/src/holyhammer/hhReconstruct.sml +++ b/src/holyhammer/hhReconstruct.sml @@ -1,8 +1,7 @@ (* ===================================================================== *) (* FILE : hhReconstruct.sml *) (* DESCRIPTION : Reconstruct a proof from the lemmas given by an ATP *) -(* and minimize them. Can only be used after a call of *) -(* write_hh_thyl that initializes the dictionary *) +(* and minimize them. *) (* of theorems' names. *) (* AUTHOR : (c) Thibault Gauthier, University of Innsbruck *) (* DATE : 2015 *) @@ -15,6 +14,41 @@ open HolKernel boolLib Dep Tag hhWriter val ERR = mk_HOL_ERR "hhReconstruct" +(*--------------------------------------------------------------------------- + Unescaping and extracting theorem and theory name. + ----------------------------------------------------------------------------*) + +(* Assumes the term was single quoted before *) +fun unsquotify s = + if String.size s >= 2 + then String.substring (s, 1, String.size s - 2) + else raise ERR "unsquotify" "" + +fun map_half b f l = case l of + [] => [] + | a :: m => if b then f a :: map_half false f m + else a :: map_half true f m + +fun hh_unescape s = + let + val sl = String.fields (fn c => c = #"#") s + fun f s = case s of + "hash" => "#" + |"slash" => "/" + |"quote" => "\"" + |"squote" => "'" + | _ => raise ERR "hh_unescape" "" + in + String.concat (map_half false f sl) + end + +fun split_name s = case String.fields (fn c => c = #"/") s of + [_,thy,name] => (thy,name) + | _ => raise ERR "split_name" "" + +fun fetchl l = + List.map (fn (thy,name) => ((thy,name),DB.fetch thy name)) l + (*--------------------------------------------------------------------------- Reading the ATP file. ----------------------------------------------------------------------------*) @@ -58,22 +92,38 @@ fun time_metis thml conjecture time = Minimization. Can be turned off by minimize_flag if it takes too much time. ----------------------------------------------------------------------------*) +(* internal use *) +fun third (a,b,c) = c + val minimize_flag = ref true fun minimize_loop l1 l2 cj = if null l2 then l1 else - if can (time_metis (map snd (l1 @ tl l2)) cj) 2.0 + if can (time_metis (map third (l1 @ tl l2)) cj) 2.0 then minimize_loop l1 (tl l2) cj else minimize_loop (hd l2 :: l1) (tl l2) cj fun minimize l cj = ( print "Minimization ...\n"; - if can (time_metis (map snd l) cj) 2.0 + if can (time_metis (map third l) cj) 2.0 then minimize_loop [] l cj else l ) +(* external use *) +fun hh_minimize_loop l1 l2 cj = + if null l2 then l1 else + if can (time_metis (l1 @ tl l2) cj) 2.0 + then hh_minimize_loop l1 (tl l2) cj + else hh_minimize_loop (hd l2 :: l1) (tl l2) cj + +fun hh_minimize l cj = + if can (time_metis l cj) 2.0 + then hh_minimize_loop [] l cj + else l + + (*--------------------------------------------------------------------------- Reconstruction and printing (depends on DB.fetch) ----------------------------------------------------------------------------*) @@ -107,10 +157,8 @@ fun pp_lemmas ppstrm lemmas = end_block(); add_string "]"; end_block()) - fun pp_lemma (name,thm) = - let val (thy,_) = depid_of (dep_of (tag thm)) in - add_string (String.concatWith " " ["fetch", quote thy, quote name]) - end + fun pp_lemma (_,(thy,name),thm) = + add_string (String.concatWith " " ["fetch", quote thy, quote name]) in begin_block INCONSISTENT 0; add_string "val lemmas = "; @@ -124,15 +172,17 @@ fun reprove thml axl cj = let (* reserved theorems are not required by Metis *) val axl1 = filter (fn x => not (mem x reserved_names_escaped)) axl - val didl = map (fn x => Redblackmap.find (!readhh_names,x)) axl1 - val l1 = map (fn x => ("",x)) thml @ map thm_of_depid didl + val sl = map (hh_unescape o unsquotify) axl1 + val axl2 = fetchl (map split_name sl) + val l1 = map (fn thm => (false,("",""),thm)) thml @ + map (fn (name,thm) => (true,name,thm)) axl2 val l2 = if !minimize_flag then minimize l1 cj else l1 - (* hacky way of removing user given theorems *) - val l3 = filter (fn (name,_) => name <> "") l2 + (* TO DO: external reconstruction *) + val l3 = filter (fn (b,_,_) => b) l2 in pp_lemmas ppstrm_stdout l3; print "\n"; - ignore (time_metis (map snd l2) cj 30.0) + ignore (time_metis (map third l2) cj 30.0) end fun reconstruct thml (atp_status,atp_out) conjecture = @@ -162,7 +212,7 @@ fun reconstructl thml atpfilel conjecture = in raise Status s end - (* else take the one that use the less lemmas. *) + (* else take the one that uses the less lemmas. *) else let fun compare_list l1 l2 = length l1 > length l2 diff --git a/src/holyhammer/hhWriter.sig b/src/holyhammer/hhWriter.sig index 988c77e256..aeead0f4fa 100644 --- a/src/holyhammer/hhWriter.sig +++ b/src/holyhammer/hhWriter.sig @@ -1,15 +1,13 @@ signature hhWriter = sig - include Abbrev val thm_of_depid : Dep.depid -> (string * Thm.thm) val write_hh_thyl : string -> string list -> unit val write_conjecture : string -> term -> unit val write_thydep : string -> string list -> unit + val write_hh_thml : string -> string -> string list -> (string * Thm.thm) list -> unit - val writehh_names : (Dep.depid, string) Redblackmap.dict ref - val readhh_names : (string, Dep.depid) Redblackmap.dict ref val reserved_names_escaped : string list end diff --git a/src/holyhammer/hhWriter.sml b/src/holyhammer/hhWriter.sml index d2c2bb9aa4..41f514cc6e 100644 --- a/src/holyhammer/hhWriter.sml +++ b/src/holyhammer/hhWriter.sml @@ -1,5 +1,5 @@ (* ===================================================================== *) -(* FILE : hhWriter.sml *) +(* FILE : hhWriter.sml *) (* DESCRIPTION : Print objects (constants, types and theorems) and *) (* dependencies between conjuncts of theorems for *) (* holyHammer. *) @@ -31,8 +31,7 @@ val const_names = ref (dempty KernelSig.name_compare) val var_names = ref (dempty Term.compare) val tyvar_names = ref (dempty Type.compare) -val writehh_names = ref (dempty depid_compare) (* symmetric dictionaries *) -val readhh_names = ref (dempty String.compare) +val writehh_names = ref (dempty depid_compare) (* Keeping track of which names are already used to prevent clashes. *) val used_names = ref (dempty String.compare) @@ -53,13 +52,11 @@ fun reset_dicts () = tyvar_names := dempty Type.compare; used_names := dempty String.compare; (* contains non escaped names *) app reserve reserved_names; - writehh_names := dempty depid_compare; - readhh_names := dempty String.compare + writehh_names := dempty depid_compare ) (*--------------------------------------------------------------------------- - Absolute limit on the size of theorems (to be included in the incremental - export) + Absolute limit on the size of theorems (to be removed) ----------------------------------------------------------------------------*) val size_limit = 200 fun size_of_term t = @@ -90,8 +87,8 @@ fun is_alphanumeric s = all (fn x => Char.isAlphaNum x orelse x = #"_") l end -(* now additonnally escape quotes *) -fun escape_slash s = +(* now additonnally escape quotes for the feature generation algorithm *) +fun hh_escape s = let val l1 = String.explode s fun image x = @@ -99,32 +96,26 @@ fun escape_slash s = #"#" => String.explode "#hash#" | #"/" => String.explode "#slash#" | #"\"" => String.explode "#quote#" + | #"'" => String.explode "#squote#" | _ => [x] val l2 = map image l1 in String.implode (List.concat l2) end -fun escape_prime s = - let - val l1 = String.explode s - val l2 = map (fn x => if x = #"'" then [#"\\",#"'"] else [x]) l1 - in - String.implode (List.concat l2) - end +fun squotify name = "'" ^ name ^ "'" +fun full_escape name = "'" ^ hh_escape name ^ "'" -fun tptp_escape name = - if is_alphanumeric name - then name - else "'" ^ escape_prime name ^ "'" +(* TO BE MOVED *) (* use a similar escaping than the holyhammer fof writer *) -fun fof_escape name = +fun reserved_escape name = if is_alphanumeric name andalso Char.isLower (hd (String.explode name)) then name - else "'" ^ escape_prime name ^ "'" + else "'" ^ name ^ "'" + +val reserved_names_escaped = map reserved_escape reserved_names -val reserved_names_escaped = map fof_escape reserved_names (* nice printing *) fun nice_dest_vartype v = @@ -144,12 +135,12 @@ fun variant_name_dict s used = let val si = s ^ Int.toString i in if dmem si used then new_name s (i + 1) - else (tptp_escape si, dadd s (i + 1) (dadd si 0 used)) + else (full_escape si, dadd s (i + 1) (dadd si 0 used)) end in new_name s i end - handle NotFound => (tptp_escape s, dadd s 0 used) + handle NotFound => (full_escape s, dadd s 0 used) fun store_name name = if dmem name (!used_names) @@ -164,8 +155,8 @@ fun store_name name = (* types *) fun declare_perm_type dict {Thy,Name} = let - val name1 = "type/" ^ Thy ^ "/" ^ (escape_slash Name) - val name2 = tptp_escape name1 + val name1 = "type/" ^ Thy ^ "/" ^ (hh_escape Name) + val name2 = squotify name1 in store_name name1; dict := dadd {Thy=Thy,Name=Name} name2 (!dict); @@ -175,8 +166,8 @@ fun declare_perm_type dict {Thy,Name} = (* constants *) fun declare_perm_const dict {Thy,Name} = let - val name1 = "const/" ^ Thy ^ "/" ^ (escape_slash Name) - val name2 = tptp_escape name1 + val name1 = "const/" ^ Thy ^ "/" ^ (hh_escape Name) + val name2 = squotify name1 in store_name name1; dict := dadd {Thy=Thy,Name=Name} name2 (!dict); @@ -186,12 +177,11 @@ fun declare_perm_const dict {Thy,Name} = (* theorems *) fun declare_perm_thm (thy,n) name = let - val name1 = "thm/" ^ thy ^ "/" ^ (escape_slash name) - val name2 = tptp_escape name1 + val name1 = "thm/" ^ thy ^ "/" ^ (hh_escape name) + val name2 = squotify name1 in store_name name1; writehh_names := dadd (thy,n) name2 (!writehh_names); - readhh_names := dadd name2 (thy,n) (!readhh_names); name2 end @@ -252,10 +242,8 @@ fun oty ty = else (os ("(" ^ s ^ " "); oiter " " oty Args; os ")") end end -type ('a,'b)substp = {redex : 'a, residue : 'b} val less_ty = fn a => (fn b => Type.compare (a,b) = LESS) -fun less_red (a:(hol_type,'a)substp) (b:(hol_type,'b)substp) = - less_ty (#redex a) (#redex b) +fun less_red a b = less_ty (#redex a) (#redex b) fun id_subst a = {redex = a, residue = a} fun full_match_type t1 t2 = @@ -480,7 +468,7 @@ fun write_hh_thyl folder thyl = app (write_hh_thy folder) (sort_thyl thyl)) -fun write_conjecture file conjecture = +fun write_conjecture file conjecture = (* TO DO: put it in a subdirectory *) (* if is_oversized_term conjecture then raise ERR "write_conjecture" "too large conjecture" else *) @@ -493,5 +481,41 @@ fun write_conjecture file conjecture = ) else raise ERR "write_conjecture" "conjecture is not a boolean" +(*--------------------------------------------------------------------------- + Print only selected theorems. + ----------------------------------------------------------------------------*) + +fun write_hh_thy_const folder thy = + ( + hh_thy_start folder thy; + let val l = dest_theory thy in + case l of THEORY(_,t) => + ( + app (hh_tydef thy) (#types t); + app (hh_constdef thy) (#consts t) + ) + end; + hh_thy_end () + ) + +fun write_hh_thyl_const folder thyl = + ( + reset_dicts(); + app (write_hh_thy_const folder) (sort_thyl thyl) + ) + +fun write_hh_thml_aux file thmnamel = (* TO DO: put it in a subdirectory *) + let val thml = map (fn x => (x,"ax")) thmnamel in + oc := openOut file; + app export_thm thml; + closeOut (!oc); oc := stdOut + end + +fun write_hh_thml folder file thyl namethml = + ( + write_hh_thyl_const folder thyl; + write_hh_thml_aux file namethml + ) + end diff --git a/src/holyhammer/holyHammer.sig b/src/holyhammer/holyHammer.sig index 26acbfd9a1..f2603a9893 100644 --- a/src/holyhammer/holyHammer.sig +++ b/src/holyhammer/holyHammer.sig @@ -1,10 +1,11 @@ signature holyHammer = sig - datatype PREDICTOR = KNN | Mepo | NBayes | Geo + datatype PREDICTOR = KNN | Mepo | NBayes | Geo | Kepo datatype ATP = Eprover | Vampire | Z3 val hh : Thm.thm list -> Term.term -> unit + val hh_try : Thm.thm list -> Term.term -> unit val hh_atp : ATP -> Thm.thm list -> Term.term -> unit val hh_goal : Thm.thm list -> Term.term list * Term.term -> unit diff --git a/src/holyhammer/holyHammer.sml b/src/holyhammer/holyHammer.sml index 50545ecab0..d9732c6eb2 100644 --- a/src/holyhammer/holyHammer.sml +++ b/src/holyhammer/holyHammer.sml @@ -13,15 +13,17 @@ structure holyHammer :> holyHammer = struct -open HolKernel boolLib hhWriter hhReconstruct +open hhWriter hhReconstruct val ERR = mk_HOL_ERR "holyHammer" +val exported_thyl = ref [] + (*--------------------------------------------------------------------------- Settings ----------------------------------------------------------------------------*) -datatype PREDICTOR = KNN | Mepo | NBayes | Geo +datatype PREDICTOR = KNN | Mepo | NBayes | Geo | Kepo datatype ATP = Eprover | Vampire | Z3 fun name_of_atp atp = case atp of @@ -34,6 +36,7 @@ fun name_of_predictor predictor = case predictor of | Mepo => "mepo" | NBayes => "nbayes" | Geo => "geo" + | Kepo => "kepo" val eprover_settings = ref (KNN,128,5) val vampire_settings = ref (KNN,96,5) @@ -94,20 +97,13 @@ val hh_dir = HOLDIR ^ "/src/holyhammer" val scripts_dir = hh_dir ^ "/scripts" val thy_dir = hh_dir ^ "/theories" -fun dir_of_prover atp = - let val atp_name = name_of_atp atp in - hh_dir ^ "/provers/" ^ atp_name ^ "/" ^ atp_name ^ "_files" - end +fun dir_of_prover atp = hh_dir ^ "/provers/" ^ name_of_atp atp -fun out_of_prover atp = - let val atp_name = name_of_atp atp in - dir_of_prover atp ^ "/" ^ atp_name ^ "_out" - end +fun out_of_prover atp = + dir_of_prover atp ^ "/" ^ name_of_atp atp ^ "_out" -fun status_of_prover atp = - let val atp_name = name_of_atp atp in - dir_of_prover atp ^ "/" ^ atp_name ^ "_status" - end +fun status_of_prover atp = + dir_of_prover atp ^ "/" ^ name_of_atp atp ^ "_status" fun hh_of_prover atp = "hh_" ^ name_of_atp atp ^ ".sh" @@ -128,15 +124,39 @@ fun export cj = write_thydep (thy_dir ^ "/thydep") thyl end +fun export_namethml cj namethml = + let + val ct = current_theory () + val thyl = ct :: Theory.ancestry ct + in + (* write constants of loaded theories and some theorems *) + write_hh_thml thy_dir (thy_dir ^ "/problem") thyl namethml; + (* write the conjecture in thf format *) + write_conjecture (thy_dir ^ "/conjecture") cj; + (* write the dependencies between theories *) + write_thydep (thy_dir ^ "/thydep") thyl + end + + +(* TO DO: Incremental export +fun export_thyl thy_dir thyl = + let val thyl' = List.filter (fn x => not (mem x (!exported_thyl))) thyl in + write_hh_thyl thy_dir thyl; + +fun export_ct ct_dir ct = + clean_dir ct_dir; + write_hh_thy ct +*) + (*--------------------------------------------------------------------------- Main helpers ----------------------------------------------------------------------------*) -fun mk_argl () = +fun mk_argl (e_settings,v_settings,z_settings) = let - val (p1,n1,t1) = !eprover_settings - val (p2,n2,t2) = !vampire_settings - val (p3,n3,t3) = !z3_settings + val (p1,n1,t1) = e_settings + val (p2,n2,t2) = v_settings + val (p3,n3,t3) = z_settings val predictorl = List.map name_of_predictor [p1,p2,p3] val nl = List.map int_to_string [n1,n2,n3] val time = int_to_string t1 @@ -157,7 +177,7 @@ fun cmd_in_dir dir cmd = ----------------------------------------------------------------------------*) (* Try every provers in parallel: eprover, vampire and z3. *) -fun hh thml cj = +fun hh_argl thml cj argl = let val atpfilel = map (fn x => (status_of_prover x, out_of_prover x)) [Eprover,Vampire,Z3] @@ -165,13 +185,28 @@ fun hh thml cj = in cmd_in_dir scripts_dir "sh hh_clean.sh"; export new_cj; - cmd_in_dir scripts_dir ("sh hh.sh " ^ mk_argl()); + cmd_in_dir scripts_dir ("sh hh.sh " ^ argl); reconstructl thml atpfilel cj end +fun hh thml cj = + hh_argl thml cj + (mk_argl (!eprover_settings,!vampire_settings,!z3_settings)) + +(* Try best strategies sequentially *) +fun hh_try thml cj = + let + val strat1 = ((KNN,128,5),(KNN,96,5),(KNN,32,5)) + val strat2 = ((Mepo,128,5),(Mepo,96,5),(Mepo,32,5)) + val strat3 = ((Kepo,128,5),(Kepo,96,5),(Kepo,32,5)) + in + (hh_argl thml cj (mk_argl strat1) handle _ => + hh_argl thml cj (mk_argl strat2)) handle _ => + hh_argl thml cj (mk_argl strat3) + end + (* Let you chose the specific prover you want to use either ("eprover", "vampire" or "z3") *) - fun hh_atp atp thml cj = let val new_cj = prepare_cj thml cj @@ -185,6 +220,8 @@ fun hh_atp atp thml cj = reconstruct thml (status_of_prover atp, out_of_prover atp) cj end +(* Derived function *) fun hh_goal thml (goal as (tml,tm)) = hh thml (list_mk_imp (tml,tm)) + end diff --git a/src/holyhammer/provers/eprover.sh b/src/holyhammer/provers/eprover.sh index 8b240a8fd2..015ebb6d7a 100644 --- a/src/holyhammer/provers/eprover.sh +++ b/src/holyhammer/provers/eprover.sh @@ -1,5 +1,5 @@ -# Time limit and I/O files -DIR="eprover_files" +# I/O files +DIR="eprover" IN="$DIR/atp_in" OUT1="$DIR/eprover_out1" OUT2="$DIR/eprover_out2" @@ -8,9 +8,8 @@ STATUS="$DIR/eprover_status" ERROR="$DIR/eprover_error" # Running eprover (1.8) -cd eprover -timeout $1 ./eprover -s --cpu-limit=$1 --auto-schedule --tptp3-in \ --R --print-statistics -p --tstp-format $IN | grep "file[(]'\|# SZS" > $OUT1 2> $ERROR +timeout $1 eprover -s --cpu-limit=$1 --auto-schedule --tptp3-in \ +-R --print-statistics -p --tstp-format $IN | grep "file[(]'\|# SZS" > $OUT1 2> $ERROR # Extracting status grep "SZS status" $OUT1 > $STATUS 2> $ERROR sed -i -e 's/^.*SZS status\(.*\).*/\1/' $STATUS 2> $ERROR diff --git a/src/holyhammer/provers/eprover/COPYING_eprover b/src/holyhammer/provers/eprover/COPYING_eprover deleted file mode 100644 index ed66dd761b..0000000000 --- a/src/holyhammer/provers/eprover/COPYING_eprover +++ /dev/null @@ -1,877 +0,0 @@ -======================================================================== -NOTE: The GPL/LGPL does not necessarily apply to all versions of E. If -you obtained the code under a different license, you are bound by -its conditions. You can get the latest free release of E from -http://www.eprover.org. -======================================================================== - -As of version 1.2, E is licensed under both the GNU General Public -License (2.0 or later), and the GNU Lesser General Public License (2.1 -or later). I will only accept code submissions with the same -licensing for inclusion in my branch. - -Release under the LGPL is due to the request of researchers wanting to -integrate E into free software projects using licenses incompatible -with the GPL. If this does not pan out, I will probably revert to pure -GPL for later versions (but that will not affect this release, of -course). - - - ------------------------------------------------------------------------------ - - - GNU GENERAL PUBLIC LICENSE - Version 2, June 1991 - - Copyright (C) 1989, 1991 Free Software Foundation, Inc. - 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - Everyone is permitted to copy and distribute verbatim copies - of this license document, but changing it is not allowed. - - Preamble - - The licenses for most software are designed to take away your -freedom to share and change it. By contrast, the GNU General Public -License is intended to guarantee your freedom to share and change free -software--to make sure the software is free for all its users. This -General Public License applies to most of the Free Software -Foundation's software and to any other program whose authors commit to -using it. (Some other Free Software Foundation software is covered by -the GNU Library General Public License instead.) You can apply it to -your programs, too. - - When we speak of free software, we are referring to freedom, not -price. Our General Public Licenses are designed to make sure that you -have the freedom to distribute copies of free software (and charge for -this service if you wish), that you receive source code or can get it -if you want it, that you can change the software or use pieces of it -in new free programs; and that you know you can do these things. - - To protect your rights, we need to make restrictions that forbid -anyone to deny you these rights or to ask you to surrender the rights. -These restrictions translate to certain responsibilities for you if you -distribute copies of the software, or if you modify it. - - For example, if you distribute copies of such a program, whether -gratis or for a fee, you must give the recipients all the rights that -you have. You must make sure that they, too, receive or can get the -source code. And you must show them these terms so they know their -rights. - - We protect your rights with two steps: (1) copyright the software, and -(2) offer you this license which gives you legal permission to copy, -distribute and/or modify the software. - - Also, for each author's protection and ours, we want to make certain -that everyone understands that there is no warranty for this free -software. If the software is modified by someone else and passed on, we -want its recipients to know that what they have is not the original, so -that any problems introduced by others will not reflect on the original -authors' reputations. - - Finally, any free program is threatened constantly by software -patents. We wish to avoid the danger that redistributors of a free -program will individually obtain patent licenses, in effect making the -program proprietary. To prevent this, we have made it clear that any -patent must be licensed for everyone's free use or not licensed at all. - - The precise terms and conditions for copying, distribution and -modification follow. - - GNU GENERAL PUBLIC LICENSE - TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION - - 0. This License applies to any program or other work which contains -a notice placed by the copyright holder saying it may be distributed -under the terms of this General Public License. The "Program", below, -refers to any such program or work, and a "work based on the Program" -means either the Program or any derivative work under copyright law: -that is to say, a work containing the Program or a portion of it, -either verbatim or with modifications and/or translated into another -language. (Hereinafter, translation is included without limitation in -the term "modification".) Each licensee is addressed as "you". - -Activities other than copying, distribution and modification are not -covered by this License; they are outside its scope. The act of -running the Program is not restricted, and the output from the Program -is covered only if its contents constitute a work based on the -Program (independent of having been made by running the Program). -Whether that is true depends on what the Program does. - - 1. You may copy and distribute verbatim copies of the Program's -source code as you receive it, in any medium, provided that you -conspicuously and appropriately publish on each copy an appropriate -copyright notice and disclaimer of warranty; keep intact all the -notices that refer to this License and to the absence of any warranty; -and give any other recipients of the Program a copy of this License -along with the Program. - -You may charge a fee for the physical act of transferring a copy, and -you may at your option offer warranty protection in exchange for a fee. - - 2. You may modify your copy or copies of the Program or any portion -of it, thus forming a work based on the Program, and copy and -distribute such modifications or work under the terms of Section 1 -above, provided that you also meet all of these conditions: - - a) You must cause the modified files to carry prominent notices - stating that you changed the files and the date of any change. - - b) You must cause any work that you distribute or publish, that in - whole or in part contains or is derived from the Program or any - part thereof, to be licensed as a whole at no charge to all third - parties under the terms of this License. - - c) If the modified program normally reads commands interactively - when run, you must cause it, when started running for such - interactive use in the most ordinary way, to print or display an - announcement including an appropriate copyright notice and a - notice that there is no warranty (or else, saying that you provide - a warranty) and that users may redistribute the program under - these conditions, and telling the user how to view a copy of this - License. (Exception: if the Program itself is interactive but - does not normally print such an announcement, your work based on - the Program is not required to print an announcement.) - -These requirements apply to the modified work as a whole. If -identifiable sections of that work are not derived from the Program, -and can be reasonably considered independent and separate works in -themselves, then this License, and its terms, do not apply to those -sections when you distribute them as separate works. But when you -distribute the same sections as part of a whole which is a work based -on the Program, the distribution of the whole must be on the terms of -this License, whose permissions for other licensees extend to the -entire whole, and thus to each and every part regardless of who wrote it. - -Thus, it is not the intent of this section to claim rights or contest -your rights to work written entirely by you; rather, the intent is to -exercise the right to control the distribution of derivative or -collective works based on the Program. - -In addition, mere aggregation of another work not based on the Program -with the Program (or with a work based on the Program) on a volume of -a storage or distribution medium does not bring the other work under -the scope of this License. - - 3. You may copy and distribute the Program (or a work based on it, -under Section 2) in object code or executable form under the terms of -Sections 1 and 2 above provided that you also do one of the following: - - a) Accompany it with the complete corresponding machine-readable - source code, which must be distributed under the terms of Sections - 1 and 2 above on a medium customarily used for software interchange; or, - - b) Accompany it with a written offer, valid for at least three - years, to give any third party, for a charge no more than your - cost of physically performing source distribution, a complete - machine-readable copy of the corresponding source code, to be - distributed under the terms of Sections 1 and 2 above on a medium - customarily used for software interchange; or, - - c) Accompany it with the information you received as to the offer - to distribute corresponding source code. (This alternative is - allowed only for noncommercial distribution and only if you - received the program in object code or executable form with such - an offer, in accord with Subsection b above.) - -The source code for a work means the preferred form of the work for -making modifications to it. For an executable work, complete source -code means all the source code for all modules it contains, plus any -associated interface definition files, plus the scripts used to -control compilation and installation of the executable. However, as a -special exception, the source code distributed need not include -anything that is normally distributed (in either source or binary -form) with the major components (compiler, kernel, and so on) of the -operating system on which the executable runs, unless that component -itself accompanies the executable. - -If distribution of executable or object code is made by offering -access to copy from a designated place, then offering equivalent -access to copy the source code from the same place counts as -distribution of the source code, even though third parties are not -compelled to copy the source along with the object code. - - 4. You may not copy, modify, sublicense, or distribute the Program -except as expressly provided under this License. Any attempt -otherwise to copy, modify, sublicense or distribute the Program is -void, and will automatically terminate your rights under this License. -However, parties who have received copies, or rights, from you under -this License will not have their licenses terminated so long as such -parties remain in full compliance. - - 5. You are not required to accept this License, since you have not -signed it. However, nothing else grants you permission to modify or -distribute the Program or its derivative works. These actions are -prohibited by law if you do not accept this License. Therefore, by -modifying or distributing the Program (or any work based on the -Program), you indicate your acceptance of this License to do so, and -all its terms and conditions for copying, distributing or modifying -the Program or works based on it. - - 6. Each time you redistribute the Program (or any work based on the -Program), the recipient automatically receives a license from the -original licensor to copy, distribute or modify the Program subject to -these terms and conditions. You may not impose any further -restrictions on the recipients' exercise of the rights granted herein. -You are not responsible for enforcing compliance by third parties to -this License. - - 7. If, as a consequence of a court judgment or allegation of patent -infringement or for any other reason (not limited to patent issues), -conditions are imposed on you (whether by court order, agreement or -otherwise) that contradict the conditions of this License, they do not -excuse you from the conditions of this License. If you cannot -distribute so as to satisfy simultaneously your obligations under this -License and any other pertinent obligations, then as a consequence you -may not distribute the Program at all. For example, if a patent -license would not permit royalty-free redistribution of the Program by -all those who receive copies directly or indirectly through you, then -the only way you could satisfy both it and this License would be to -refrain entirely from distribution of the Program. - -If any portion of this section is held invalid or unenforceable under -any particular circumstance, the balance of the section is intended to -apply and the section as a whole is intended to apply in other -circumstances. - -It is not the purpose of this section to induce you to infringe any -patents or other property right claims or to contest validity of any -such claims; this section has the sole purpose of protecting the -integrity of the free software distribution system, which is -implemented by public license practices. Many people have made -generous contributions to the wide range of software distributed -through that system in reliance on consistent application of that -system; it is up to the author/donor to decide if he or she is willing -to distribute software through any other system and a licensee cannot -impose that choice. - -This section is intended to make thoroughly clear what is believed to -be a consequence of the rest of this License. - - 8. If the distribution and/or use of the Program is restricted in -certain countries either by patents or by copyrighted interfaces, the -original copyright holder who places the Program under this License -may add an explicit geographical distribution limitation excluding -those countries, so that distribution is permitted only in or among -countries not thus excluded. In such case, this License incorporates -the limitation as if written in the body of this License. - - 9. The Free Software Foundation may publish revised and/or new versions -of the General Public License from time to time. Such new versions will -be similar in spirit to the present version, but may differ in detail to -address new problems or concerns. - -Each version is given a distinguishing version number. If the Program -specifies a version number of this License which applies to it and "any -later version", you have the option of following the terms and conditions -either of that version or of any later version published by the Free -Software Foundation. If the Program does not specify a version number of -this License, you may choose any version ever published by the Free Software -Foundation. - - 10. If you wish to incorporate parts of the Program into other free -programs whose distribution conditions are different, write to the author -to ask for permission. For software which is copyrighted by the Free -Software Foundation, write to the Free Software Foundation; we sometimes -make exceptions for this. Our decision will be guided by the two goals -of preserving the free status of all derivatives of our free software and -of promoting the sharing and reuse of software generally. - - NO WARRANTY - - 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY -FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN -OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES -PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED -OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF -MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS -TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE -PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, -REPAIR OR CORRECTION. - - 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING -WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR -REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, -INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING -OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED -TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY -YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER -PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE -POSSIBILITY OF SUCH DAMAGES. - - END OF TERMS AND CONDITIONS - - How to Apply These Terms to Your New Programs - - If you develop a new program, and you want it to be of the greatest -possible use to the public, the best way to achieve this is to make it -free software which everyone can redistribute and change under these terms. - - To do so, attach the following notices to the program. It is safest -to attach them to the start of each source file to most effectively -convey the exclusion of warranty; and each file should have at least -the "copyright" line and a pointer to where the full notice is found. - - - Copyright (C) 19yy - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - - -Also add information on how to contact you by electronic and paper mail. - -If the program is interactive, make it output a short notice like this -when it starts in an interactive mode: - - Gnomovision version 69, Copyright (C) 19yy name of author - Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. - This is free software, and you are welcome to redistribute it - under certain conditions; type `show c' for details. - -The hypothetical commands `show w' and `show c' should show the appropriate -parts of the General Public License. Of course, the commands you use may -be called something other than `show w' and `show c'; they could even be -mouse-clicks or menu items--whatever suits your program. - -You should also get your employer (if you work as a programmer) or your -school, if any, to sign a "copyright disclaimer" for the program, if -necessary. Here is a sample; alter the names: - - Yoyodyne, Inc., hereby disclaims all copyright interest in the program - `Gnomovision' (which makes passes at compilers) written by James Hacker. - - , 1 April 1989 - Ty Coon, President of Vice - -This General Public License does not permit incorporating your program into -proprietary programs. If your program is a subroutine library, you may -consider it more useful to permit linking proprietary applications with the -library. If this is what you want to do, use the GNU Library General -Public License instead of this License. - - - - - ------------------------------------------------------------------------------ - - - - - - - GNU LESSER GENERAL PUBLIC LICENSE - Version 2.1, February 1999 - - Copyright (C) 1991, 1999 Free Software Foundation, Inc. - 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA - Everyone is permitted to copy and distribute verbatim copies - of this license document, but changing it is not allowed. - -[This is the first released version of the Lesser GPL. It also counts - as the successor of the GNU Library Public License, version 2, hence - the version number 2.1.] - - Preamble - - The licenses for most software are designed to take away your -freedom to share and change it. By contrast, the GNU General Public -Licenses are intended to guarantee your freedom to share and change -free software--to make sure the software is free for all its users. - - This license, the Lesser General Public License, applies to some -specially designated software packages--typically libraries--of the -Free Software Foundation and other authors who decide to use it. You -can use it too, but we suggest you first think carefully about whether -this license or the ordinary General Public License is the better -strategy to use in any particular case, based on the explanations below. - - When we speak of free software, we are referring to freedom of use, -not price. Our General Public Licenses are designed to make sure that -you have the freedom to distribute copies of free software (and charge -for this service if you wish); that you receive source code or can get -it if you want it; that you can change the software and use pieces of -it in new free programs; and that you are informed that you can do -these things. - - To protect your rights, we need to make restrictions that forbid -distributors to deny you these rights or to ask you to surrender these -rights. These restrictions translate to certain responsibilities for -you if you distribute copies of the library or if you modify it. - - For example, if you distribute copies of the library, whether gratis -or for a fee, you must give the recipients all the rights that we gave -you. You must make sure that they, too, receive or can get the source -code. If you link other code with the library, you must provide -complete object files to the recipients, so that they can relink them -with the library after making changes to the library and recompiling -it. And you must show them these terms so they know their rights. - - We protect your rights with a two-step method: (1) we copyright the -library, and (2) we offer you this license, which gives you legal -permission to copy, distribute and/or modify the library. - - To protect each distributor, we want to make it very clear that -there is no warranty for the free library. Also, if the library is -modified by someone else and passed on, the recipients should know -that what they have is not the original version, so that the original -author's reputation will not be affected by problems that might be -introduced by others. - - Finally, software patents pose a constant threat to the existence of -any free program. We wish to make sure that a company cannot -effectively restrict the users of a free program by obtaining a -restrictive license from a patent holder. Therefore, we insist that -any patent license obtained for a version of the library must be -consistent with the full freedom of use specified in this license. - - Most GNU software, including some libraries, is covered by the -ordinary GNU General Public License. This license, the GNU Lesser -General Public License, applies to certain designated libraries, and -is quite different from the ordinary General Public License. We use -this license for certain libraries in order to permit linking those -libraries into non-free programs. - - When a program is linked with a library, whether statically or using -a shared library, the combination of the two is legally speaking a -combined work, a derivative of the original library. The ordinary -General Public License therefore permits such linking only if the -entire combination fits its criteria of freedom. The Lesser General -Public License permits more lax criteria for linking other code with -the library. - - We call this license the "Lesser" General Public License because it -does Less to protect the user's freedom than the ordinary General -Public License. It also provides other free software developers Less -of an advantage over competing non-free programs. These disadvantages -are the reason we use the ordinary General Public License for many -libraries. However, the Lesser license provides advantages in certain -special circumstances. - - For example, on rare occasions, there may be a special need to -encourage the widest possible use of a certain library, so that it becomes -a de-facto standard. To achieve this, non-free programs must be -allowed to use the library. A more frequent case is that a free -library does the same job as widely used non-free libraries. In this -case, there is little to gain by limiting the free library to free -software only, so we use the Lesser General Public License. - - In other cases, permission to use a particular library in non-free -programs enables a greater number of people to use a large body of -free software. For example, permission to use the GNU C Library in -non-free programs enables many more people to use the whole GNU -operating system, as well as its variant, the GNU/Linux operating -system. - - Although the Lesser General Public License is Less protective of the -users' freedom, it does ensure that the user of a program that is -linked with the Library has the freedom and the wherewithal to run -that program using a modified version of the Library. - - The precise terms and conditions for copying, distribution and -modification follow. Pay close attention to the difference between a -"work based on the library" and a "work that uses the library". The -former contains code derived from the library, whereas the latter must -be combined with the library in order to run. - - GNU LESSER GENERAL PUBLIC LICENSE - TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION - - 0. This License Agreement applies to any software library or other -program which contains a notice placed by the copyright holder or -other authorized party saying it may be distributed under the terms of -this Lesser General Public License (also called "this License"). -Each licensee is addressed as "you". - - A "library" means a collection of software functions and/or data -prepared so as to be conveniently linked with application programs -(which use some of those functions and data) to form executables. - - The "Library", below, refers to any such software library or work -which has been distributed under these terms. A "work based on the -Library" means either the Library or any derivative work under -copyright law: that is to say, a work containing the Library or a -portion of it, either verbatim or with modifications and/or translated -straightforwardly into another language. (Hereinafter, translation is -included without limitation in the term "modification".) - - "Source code" for a work means the preferred form of the work for -making modifications to it. For a library, complete source code means -all the source code for all modules it contains, plus any associated -interface definition files, plus the scripts used to control compilation -and installation of the library. - - Activities other than copying, distribution and modification are not -covered by this License; they are outside its scope. The act of -running a program using the Library is not restricted, and output from -such a program is covered only if its contents constitute a work based -on the Library (independent of the use of the Library in a tool for -writing it). Whether that is true depends on what the Library does -and what the program that uses the Library does. - - 1. You may copy and distribute verbatim copies of the Library's -complete source code as you receive it, in any medium, provided that -you conspicuously and appropriately publish on each copy an -appropriate copyright notice and disclaimer of warranty; keep intact -all the notices that refer to this License and to the absence of any -warranty; and distribute a copy of this License along with the -Library. - - You may charge a fee for the physical act of transferring a copy, -and you may at your option offer warranty protection in exchange for a -fee. - - 2. You may modify your copy or copies of the Library or any portion -of it, thus forming a work based on the Library, and copy and -distribute such modifications or work under the terms of Section 1 -above, provided that you also meet all of these conditions: - - a) The modified work must itself be a software library. - - b) You must cause the files modified to carry prominent notices - stating that you changed the files and the date of any change. - - c) You must cause the whole of the work to be licensed at no - charge to all third parties under the terms of this License. - - d) If a facility in the modified Library refers to a function or a - table of data to be supplied by an application program that uses - the facility, other than as an argument passed when the facility - is invoked, then you must make a good faith effort to ensure that, - in the event an application does not supply such function or - table, the facility still operates, and performs whatever part of - its purpose remains meaningful. - - (For example, a function in a library to compute square roots has - a purpose that is entirely well-defined independent of the - application. Therefore, Subsection 2d requires that any - application-supplied function or table used by this function must - be optional: if the application does not supply it, the square - root function must still compute square roots.) - -These requirements apply to the modified work as a whole. If -identifiable sections of that work are not derived from the Library, -and can be reasonably considered independent and separate works in -themselves, then this License, and its terms, do not apply to those -sections when you distribute them as separate works. But when you -distribute the same sections as part of a whole which is a work based -on the Library, the distribution of the whole must be on the terms of -this License, whose permissions for other licensees extend to the -entire whole, and thus to each and every part regardless of who wrote -it. - -Thus, it is not the intent of this section to claim rights or contest -your rights to work written entirely by you; rather, the intent is to -exercise the right to control the distribution of derivative or -collective works based on the Library. - -In addition, mere aggregation of another work not based on the Library -with the Library (or with a work based on the Library) on a volume of -a storage or distribution medium does not bring the other work under -the scope of this License. - - 3. You may opt to apply the terms of the ordinary GNU General Public -License instead of this License to a given copy of the Library. To do -this, you must alter all the notices that refer to this License, so -that they refer to the ordinary GNU General Public License, version 2, -instead of to this License. (If a newer version than version 2 of the -ordinary GNU General Public License has appeared, then you can specify -that version instead if you wish.) Do not make any other change in -these notices. - - Once this change is made in a given copy, it is irreversible for -that copy, so the ordinary GNU General Public License applies to all -subsequent copies and derivative works made from that copy. - - This option is useful when you wish to copy part of the code of -the Library into a program that is not a library. - - 4. You may copy and distribute the Library (or a portion or -derivative of it, under Section 2) in object code or executable form -under the terms of Sections 1 and 2 above provided that you accompany -it with the complete corresponding machine-readable source code, which -must be distributed under the terms of Sections 1 and 2 above on a -medium customarily used for software interchange. - - If distribution of object code is made by offering access to copy -from a designated place, then offering equivalent access to copy the -source code from the same place satisfies the requirement to -distribute the source code, even though third parties are not -compelled to copy the source along with the object code. - - 5. A program that contains no derivative of any portion of the -Library, but is designed to work with the Library by being compiled or -linked with it, is called a "work that uses the Library". Such a -work, in isolation, is not a derivative work of the Library, and -therefore falls outside the scope of this License. - - However, linking a "work that uses the Library" with the Library -creates an executable that is a derivative of the Library (because it -contains portions of the Library), rather than a "work that uses the -library". The executable is therefore covered by this License. -Section 6 states terms for distribution of such executables. - - When a "work that uses the Library" uses material from a header file -that is part of the Library, the object code for the work may be a -derivative work of the Library even though the source code is not. -Whether this is true is especially significant if the work can be -linked without the Library, or if the work is itself a library. The -threshold for this to be true is not precisely defined by law. - - If such an object file uses only numerical parameters, data -structure layouts and accessors, and small macros and small inline -functions (ten lines or less in length), then the use of the object -file is unrestricted, regardless of whether it is legally a derivative -work. (Executables containing this object code plus portions of the -Library will still fall under Section 6.) - - Otherwise, if the work is a derivative of the Library, you may -distribute the object code for the work under the terms of Section 6. -Any executables containing that work also fall under Section 6, -whether or not they are linked directly with the Library itself. - - 6. As an exception to the Sections above, you may also combine or -link a "work that uses the Library" with the Library to produce a -work containing portions of the Library, and distribute that work -under terms of your choice, provided that the terms permit -modification of the work for the customer's own use and reverse -engineering for debugging such modifications. - - You must give prominent notice with each copy of the work that the -Library is used in it and that the Library and its use are covered by -this License. You must supply a copy of this License. If the work -during execution displays copyright notices, you must include the -copyright notice for the Library among them, as well as a reference -directing the user to the copy of this License. Also, you must do one -of these things: - - a) Accompany the work with the complete corresponding - machine-readable source code for the Library including whatever - changes were used in the work (which must be distributed under - Sections 1 and 2 above); and, if the work is an executable linked - with the Library, with the complete machine-readable "work that - uses the Library", as object code and/or source code, so that the - user can modify the Library and then relink to produce a modified - executable containing the modified Library. (It is understood - that the user who changes the contents of definitions files in the - Library will not necessarily be able to recompile the application - to use the modified definitions.) - - b) Use a suitable shared library mechanism for linking with the - Library. A suitable mechanism is one that (1) uses at run time a - copy of the library already present on the user's computer system, - rather than copying library functions into the executable, and (2) - will operate properly with a modified version of the library, if - the user installs one, as long as the modified version is - interface-compatible with the version that the work was made with. - - c) Accompany the work with a written offer, valid for at - least three years, to give the same user the materials - specified in Subsection 6a, above, for a charge no more - than the cost of performing this distribution. - - d) If distribution of the work is made by offering access to copy - from a designated place, offer equivalent access to copy the above - specified materials from the same place. - - e) Verify that the user has already received a copy of these - materials or that you have already sent this user a copy. - - For an executable, the required form of the "work that uses the -Library" must include any data and utility programs needed for -reproducing the executable from it. However, as a special exception, -the materials to be distributed need not include anything that is -normally distributed (in either source or binary form) with the major -components (compiler, kernel, and so on) of the operating system on -which the executable runs, unless that component itself accompanies -the executable. - - It may happen that this requirement contradicts the license -restrictions of other proprietary libraries that do not normally -accompany the operating system. Such a contradiction means you cannot -use both them and the Library together in an executable that you -distribute. - - 7. You may place library facilities that are a work based on the -Library side-by-side in a single library together with other library -facilities not covered by this License, and distribute such a combined -library, provided that the separate distribution of the work based on -the Library and of the other library facilities is otherwise -permitted, and provided that you do these two things: - - a) Accompany the combined library with a copy of the same work - based on the Library, uncombined with any other library - facilities. This must be distributed under the terms of the - Sections above. - - b) Give prominent notice with the combined library of the fact - that part of it is a work based on the Library, and explaining - where to find the accompanying uncombined form of the same work. - - 8. You may not copy, modify, sublicense, link with, or distribute -the Library except as expressly provided under this License. Any -attempt otherwise to copy, modify, sublicense, link with, or -distribute the Library is void, and will automatically terminate your -rights under this License. However, parties who have received copies, -or rights, from you under this License will not have their licenses -terminated so long as such parties remain in full compliance. - - 9. You are not required to accept this License, since you have not -signed it. However, nothing else grants you permission to modify or -distribute the Library or its derivative works. These actions are -prohibited by law if you do not accept this License. Therefore, by -modifying or distributing the Library (or any work based on the -Library), you indicate your acceptance of this License to do so, and -all its terms and conditions for copying, distributing or modifying -the Library or works based on it. - - 10. Each time you redistribute the Library (or any work based on the -Library), the recipient automatically receives a license from the -original licensor to copy, distribute, link with or modify the Library -subject to these terms and conditions. You may not impose any further -restrictions on the recipients' exercise of the rights granted herein. -You are not responsible for enforcing compliance by third parties with -this License. - - 11. If, as a consequence of a court judgment or allegation of patent -infringement or for any other reason (not limited to patent issues), -conditions are imposed on you (whether by court order, agreement or -otherwise) that contradict the conditions of this License, they do not -excuse you from the conditions of this License. If you cannot -distribute so as to satisfy simultaneously your obligations under this -License and any other pertinent obligations, then as a consequence you -may not distribute the Library at all. For example, if a patent -license would not permit royalty-free redistribution of the Library by -all those who receive copies directly or indirectly through you, then -the only way you could satisfy both it and this License would be to -refrain entirely from distribution of the Library. - -If any portion of this section is held invalid or unenforceable under any -particular circumstance, the balance of the section is intended to apply, -and the section as a whole is intended to apply in other circumstances. - -It is not the purpose of this section to induce you to infringe any -patents or other property right claims or to contest validity of any -such claims; this section has the sole purpose of protecting the -integrity of the free software distribution system which is -implemented by public license practices. Many people have made -generous contributions to the wide range of software distributed -through that system in reliance on consistent application of that -system; it is up to the author/donor to decide if he or she is willing -to distribute software through any other system and a licensee cannot -impose that choice. - -This section is intended to make thoroughly clear what is believed to -be a consequence of the rest of this License. - - 12. If the distribution and/or use of the Library is restricted in -certain countries either by patents or by copyrighted interfaces, the -original copyright holder who places the Library under this License may add -an explicit geographical distribution limitation excluding those countries, -so that distribution is permitted only in or among countries not thus -excluded. In such case, this License incorporates the limitation as if -written in the body of this License. - - 13. The Free Software Foundation may publish revised and/or new -versions of the Lesser General Public License from time to time. -Such new versions will be similar in spirit to the present version, -but may differ in detail to address new problems or concerns. - -Each version is given a distinguishing version number. If the Library -specifies a version number of this License which applies to it and -"any later version", you have the option of following the terms and -conditions either of that version or of any later version published by -the Free Software Foundation. If the Library does not specify a -license version number, you may choose any version ever published by -the Free Software Foundation. - - 14. If you wish to incorporate parts of the Library into other free -programs whose distribution conditions are incompatible with these, -write to the author to ask for permission. For software which is -copyrighted by the Free Software Foundation, write to the Free -Software Foundation; we sometimes make exceptions for this. Our -decision will be guided by the two goals of preserving the free status -of all derivatives of our free software and of promoting the sharing -and reuse of software generally. - - NO WARRANTY - - 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO -WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. -EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR -OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY -KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE -IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR -PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE -LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME -THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. - - 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN -WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY -AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU -FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR -CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE -LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING -RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A -FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF -SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH -DAMAGES. - - END OF TERMS AND CONDITIONS - - How to Apply These Terms to Your New Libraries - - If you develop a new library, and you want it to be of the greatest -possible use to the public, we recommend making it free software that -everyone can redistribute and change. You can do so by permitting -redistribution under these terms (or, alternatively, under the terms of the -ordinary General Public License). - - To apply these terms, attach the following notices to the library. It is -safest to attach them to the start of each source file to most effectively -convey the exclusion of warranty; and each file should have at least the -"copyright" line and a pointer to where the full notice is found. - - - Copyright (C) - - This library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2.1 of the License, or (at your option) any later version. - - This library is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public - License along with this library; if not, write to the Free Software - Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA - -Also add information on how to contact you by electronic and paper mail. - -You should also get your employer (if you work as a programmer) or your -school, if any, to sign a "copyright disclaimer" for the library, if -necessary. Here is a sample; alter the names: - - Yoyodyne, Inc., hereby disclaims all copyright interest in the - library `Frob' (a library for tweaking knobs) written by James Random Hacker. - - , 1 April 1990 - Ty Coon, President of Vice - -That's all there is to it! diff --git a/src/holyhammer/provers/vampire.sh b/src/holyhammer/provers/vampire.sh index 40fda6779e..532b0f8db8 100644 --- a/src/holyhammer/provers/vampire.sh +++ b/src/holyhammer/provers/vampire.sh @@ -1,5 +1,5 @@ # I/O files -DIR="vampire_files" +DIR="vampire" IN="$DIR/atp_in" OUT="$DIR/vampire_out" OUT1="$DIR/vampire_out1" @@ -8,8 +8,7 @@ STATUS="$DIR/vampire_status" ERROR="$DIR/vampire_error" # Running Vampire (2.6) -cd vampire -timeout $1 ./vampire --mode casc -t $1 --proof tptp --output_axiom_names on $IN \ +timeout $1 vampire --mode casc -t $1 --proof tptp --output_axiom_names on $IN \ | grep "file[(]'\| SZS" > $OUT1 2> $ERROR # Extracting status grep "SZS status" $OUT1 > $STATUS 2> $ERROR diff --git a/src/holyhammer/provers/vampire/README b/src/holyhammer/provers/vampire/README deleted file mode 100644 index 2a7962267b..0000000000 --- a/src/holyhammer/provers/vampire/README +++ /dev/null @@ -1,2 +0,0 @@ -This directory is initially empty. You may add Vampire(2.6) here. -Please give name vampire to this binary. diff --git a/src/holyhammer/provers/z3.sh b/src/holyhammer/provers/z3.sh index 289fb7e345..4872ef083a 100644 --- a/src/holyhammer/provers/z3.sh +++ b/src/holyhammer/provers/z3.sh @@ -1,5 +1,5 @@ -# Time limit and I/O files -DIR="z3_files" +# I/O files +DIR="z3" IN="$DIR/atp_in" OUT1="$DIR/z3_out1" OUT2="$DIR/z3_out2" @@ -8,8 +8,7 @@ STATUS="$DIR/z3_status" ERROR="$DIR/z3_error" # Running Z3 (4.0) -cd z3 -timeout $1 ./z3 -tptp DISPLAY_UNSAT_CORE=true ELIM_QUANTIFIERS=true PULL_NESTED_QUANTIFIERS=true \ +timeout $1 z3 -tptp DISPLAY_UNSAT_CORE=true ELIM_QUANTIFIERS=true PULL_NESTED_QUANTIFIERS=true \ -T:$1 $IN > $OUT1 2> $ERROR # Extracting status grep "SZS status" $OUT1 > $STATUS 2> $ERROR diff --git a/src/holyhammer/provers/z3/LICENSE.txt b/src/holyhammer/provers/z3/LICENSE.txt deleted file mode 100644 index 91c8070d0f..0000000000 --- a/src/holyhammer/provers/z3/LICENSE.txt +++ /dev/null @@ -1,7 +0,0 @@ -Z3 -Copyright (c) Microsoft Corporation -All rights reserved. -MIT License -Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the ""Software""), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: -The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. -THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/src/holyhammer/provers/z3/README b/src/holyhammer/provers/z3/README deleted file mode 100644 index c7eb858a27..0000000000 --- a/src/holyhammer/provers/z3/README +++ /dev/null @@ -1,2 +0,0 @@ -The current executable works for linux 64bit. -You may replace Z3(4.0) here, if you don't want to use it you can remove it. diff --git a/src/holyhammer/scripts/hh.sh b/src/holyhammer/scripts/hh.sh index c60527412b..db98cbabb2 100644 --- a/src/holyhammer/scripts/hh.sh +++ b/src/holyhammer/scripts/hh.sh @@ -1,8 +1,10 @@ +#!/bin/sh + EPROVER="../provers/eprover/eprover" VAMPIRE="../provers/vampire/vampire" Z3="../provers/z3/z3" # Run eprover, vampire and z3 -(if [ -f $EPROVER ]; then sh hh_eprover.sh $2 $5 $1; fi) & \ -(if [ -f $VAMPIRE ]; then sh hh_vampire.sh $3 $6 $1; fi) & \ -(if [ -f $Z3 ]; then sh hh_z3.sh $4 $7 $1; fi) +(type eprover >/dev/null 2>&1 && sh hh_eprover.sh $2 $5 $1) & \ +(type vampire >/dev/null 2>&1 && sh hh_vampire.sh $3 $6 $1) & \ +(type z3 >/dev/null 2>&1 && sh hh_z3.sh $4 $7 $1) diff --git a/src/holyhammer/scripts/hh_clean.sh b/src/holyhammer/scripts/hh_clean.sh index 2a2a46627b..00405300bd 100644 --- a/src/holyhammer/scripts/hh_clean.sh +++ b/src/holyhammer/scripts/hh_clean.sh @@ -1,6 +1,3 @@ -EPROVER_DIR="../provers/eprover/eprover_files" -VAMPIRE_DIR="../provers/vampire/vampire_files" -Z3_DIR="../provers/z3/z3_files" THEORY_DIR="../theories" clean(){ @@ -8,7 +5,4 @@ if [ -d $1 ]; then rm -r $1; fi mkdir $1 } -clean $EPROVER_DIR -clean $VAMPIRE_DIR -clean $Z3_DIR clean $THEORY_DIR diff --git a/src/holyhammer/scripts/hh_eprover.sh b/src/holyhammer/scripts/hh_eprover.sh index 9a99d12eb3..387646bcf3 100644 --- a/src/holyhammer/scripts/hh_eprover.sh +++ b/src/holyhammer/scripts/hh_eprover.sh @@ -1,4 +1,4 @@ -EPROVER_DIR="../provers/eprover/eprover_files" +EPROVER_DIR="../provers/eprover" clean(){ if [ -d $1 ]; then rm -r $1; fi diff --git a/src/holyhammer/scripts/hh_vampire.sh b/src/holyhammer/scripts/hh_vampire.sh index b0a9b98f96..868934849b 100644 --- a/src/holyhammer/scripts/hh_vampire.sh +++ b/src/holyhammer/scripts/hh_vampire.sh @@ -1,4 +1,4 @@ -VAMPIRE_DIR="../provers/vampire/vampire_files" +VAMPIRE_DIR="../provers/vampire" clean(){ if [ -d $1 ]; then rm -r $1; fi diff --git a/src/holyhammer/scripts/hh_z3.sh b/src/holyhammer/scripts/hh_z3.sh index 168d656dbb..99658e7442 100644 --- a/src/holyhammer/scripts/hh_z3.sh +++ b/src/holyhammer/scripts/hh_z3.sh @@ -1,4 +1,4 @@ -Z3_DIR="../provers/z3/z3_files" +Z3_DIR="../provers/z3" clean(){ if [ -d $1 ]; then rm -r $1; fi From 71e38bfeaaa60aecff1180af55e9a950e2e48b1f Mon Sep 17 00:00:00 2001 From: Thibault Gauthier Date: Sat, 22 Aug 2015 18:21:41 +0200 Subject: [PATCH 427/718] Adding documentation for holyhammer main function --- help/Docfiles/DB.match.doc | 2 +- help/Docfiles/DB.matcher.doc | 2 +- help/Docfiles/DB.matchp.doc | 2 +- help/Docfiles/holyHammer.hh.doc | 47 +++++++++++++++++++++++++++++++++ src/holyhammer/hhWriter.sml | 1 - 5 files changed, 50 insertions(+), 4 deletions(-) create mode 100644 help/Docfiles/holyHammer.hh.doc diff --git a/help/Docfiles/DB.match.doc b/help/Docfiles/DB.match.doc index f2202dd75b..ef08bae154 100644 --- a/help/Docfiles/DB.match.doc +++ b/help/Docfiles/DB.match.doc @@ -55,5 +55,5 @@ The notion of matching is a restricted version of higher-order matching. For locating theorems when doing interactive proof. \SEEALSO -DB.matcher, DB.matchp, DB.find, DB.theorems, DB.thy, DB.listDB. +DB.matcher, DB.matchp, DB.find, DB.theorems, DB.thy, DB.listDB, holyHammer.hh. \ENDDOC diff --git a/help/Docfiles/DB.matcher.doc b/help/Docfiles/DB.matcher.doc index e7ab90373d..ef16f0255f 100644 --- a/help/Docfiles/DB.matcher.doc +++ b/help/Docfiles/DB.matcher.doc @@ -60,5 +60,5 @@ Never fails, but may return an empty list. Usually, {pm} will be a pattern-matcher, but it need not be. \SEEALSO -DB.match, DB.apropos, DB.matchp, DB.find. +DB.match, DB.apropos, DB.matchp, DB.find, holyHammer.hh. \ENDDOC diff --git a/help/Docfiles/DB.matchp.doc b/help/Docfiles/DB.matchp.doc index a49880609a..5089eaf3cd 100644 --- a/help/Docfiles/DB.matchp.doc +++ b/help/Docfiles/DB.matchp.doc @@ -77,5 +77,5 @@ in the theory {pair}. \SEEALSO -DB.match, DB.matcher, DB.apropos, DB.find. +DB.match, DB.matcher, DB.apropos, DB.find, holyHammer.hh. \ENDDOC diff --git a/help/Docfiles/holyHammer.hh.doc b/help/Docfiles/holyHammer.hh.doc new file mode 100644 index 0000000000..51b77ffe26 --- /dev/null +++ b/help/Docfiles/holyHammer.hh.doc @@ -0,0 +1,47 @@ +\DOC hh + +\TYPE {hh : Thm.thm list -> Term.term -> unit} + +\SYNOPSIS +Select relevant lemmas for proving a term using premise selection +algorithms and external provers (ATP). Additional theorems may +optionnally be provided to help the proof search. + +\DESCRIBE +If an easy goal fails, consider changing predictor using +{set_predictors Mepo} or {set_predictors KNN}. The default predictor +is {KNN}. It is also possible to increase the default timeout of the +provers using {set_timeout 5}. Additional theorems are considered very +important for the proof so they should be chosen carefully and their +number should be limited. + +\FAILURE +Fails if the supplied term is not a boolean. Or if no ATP is installed. +Or if no proof is found by the installed ATPs. Or if METIS cannot replay +the proof from the selected lemmas in less than 30 seconds. + +\EXAMPLE +{ +- load "holyHammer"; open holyHammer; +(* output omitted *) +> val it = () : unit + +- hh [] ``1+1=2``; +> Minimization ... + val lemmas = [fetch "arithmetic" "TWO", fetch "arithmetic" "SUC_ONE_ADD"]; + val it = (): unit + +- val lemmas = [fetch "arithmetic" "TWO", fetch "arithmetic" "SUC_ONE_ADD"]; +> val lemmas = + [|- 2 = SUC 1, |- ∀n. SUC n = 1 + n]: + +- val thm = METIS_PROVE lemmas ``1+1=2``; +> val thm = |- 1 + 1 = 2: thm +} + +\COMMENTS +See more examples in src/holyHammer/examples. + +\SEEALSO +DB.match, DB.matchp, DB.matcher. +\ENDDOC diff --git a/src/holyhammer/hhWriter.sml b/src/holyhammer/hhWriter.sml index 41f514cc6e..44c212676c 100644 --- a/src/holyhammer/hhWriter.sml +++ b/src/holyhammer/hhWriter.sml @@ -11,7 +11,6 @@ structure hhWriter :> hhWriter = struct - open HolKernel boolLib TextIO Tag Dep val ERR = mk_HOL_ERR "hhWriter" From e635d65e7ef6bcc7602239ade8f2c0b671481f07 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Sun, 23 Aug 2015 06:10:53 +0800 Subject: [PATCH 428/718] ignore some generated/non-included files in holyhammer I may be wrong about these, @barakeel could check. --- src/holyhammer/.gitignore | 7 +++++++ 1 file changed, 7 insertions(+) create mode 100644 src/holyhammer/.gitignore diff --git a/src/holyhammer/.gitignore b/src/holyhammer/.gitignore new file mode 100644 index 0000000000..12309cc90a --- /dev/null +++ b/src/holyhammer/.gitignore @@ -0,0 +1,7 @@ +theories/* +provers/eprover/eprover +provers/eprover/eprover_files/* +provers/z3/z3 +provers/z3/z3_files/* +provers/vampire/vampire +provers/vampire/vampire_files/* From db2885e1bed786f29197e475d0d43036def6bf40 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Sun, 23 Aug 2015 17:51:07 +0800 Subject: [PATCH 429/718] balanced parentheses example Inspired by an extra exercise at the Isabelle tutorial (Nanjing, 2015). My version in Isabelle is about 40 lines longer. (This version includes input from Michael Norrish to make it easier to write and more concise.) --- examples/misc/balancedParensScript.sml | 84 ++++++++++++++++++++++++++ 1 file changed, 84 insertions(+) create mode 100644 examples/misc/balancedParensScript.sml diff --git a/examples/misc/balancedParensScript.sml b/examples/misc/balancedParensScript.sml new file mode 100644 index 0000000000..ee7999294a --- /dev/null +++ b/examples/misc/balancedParensScript.sml @@ -0,0 +1,84 @@ +open HolKernel boolLib bossLib lcsymtacs + listTheory rich_listTheory arithmeticTheory + +val _ = new_theory"balancedParens" + +val _ = Datatype`alpha = a | b`; (* a = "(", b = ")" *) + +fun met h = metis_tac([APPEND,APPEND_ASSOC]@h) + +val (S_rules,S_ind,S_cases) = Hol_reln` + S [] ∧ + (S w ⇒ S ([a] ++ w ++ [b])) ∧ + (S w1 ∧ S w2 ⇒ S (w1++w2))` + +val Snil = Q.store_thm("Snil[simp]", + `S []`, rw[Once S_cases]); + +val (T_rules,T_ind,T_cases) = Hol_reln` + T [] ∧ + (T w1 ∧ T w2 ⇒ T (w1 ++ [a] ++ w2 ++ [b]))` + +val TS = Q.store_thm("TS", + `∀w. T w ⇒ S w`, + Induct_on`T` >> met[S_rules]) + +val Tnil = Q.store_thm("Tnil[simp]", + `T []`, rw[Once T_cases]) + +val Tapp = Q.store_thm("Tapp", + `∀w2. T w2 ⇒ ∀w1. T w1 ⇒ T (w1 ++ w2)`, + Induct_on`T` >> simp[T_rules]) + +val ST = Q.store_thm("ST", + `∀w. S w ⇒ T w`, + Induct_on`S` >> met[T_rules,Tapp]) + +val T_iff_S = Q.store_thm("T_iff_S", + `T w ⇔ S w`, metis_tac[TS,ST]); + +val balanced_def = Define` + (balanced [] 0 ⇔ T) ∧ + (balanced (a::xs) n ⇔ balanced xs (SUC n)) ∧ + (balanced (b::xs) (SUC n) ⇔ balanced xs n) ∧ + (balanced _ _ ⇔ F)` +val _ = export_rewrites["balanced_def"] +val balanced_ind = theorem"balanced_ind" + +val balanced_append = Q.store_thm("balanced_append", + `∀w1 n1. balanced w1 n1 ⇒ ∀w2 n2. balanced w2 n2 ⇒ balanced (w1++w2) (n1+n2)`, + ho_match_mp_tac balanced_ind >> + rw[] >> fs[] >- ( + res_tac >> fsrw_tac[ARITH_ss][ADD1] ) >> + REWRITE_TAC[GSYM SUC_ADD_SYM] >> + simp[]) + +val S_balanced = Q.store_thm("S_balanced", + `∀w. S w ⇒ balanced w 0`, + Induct_on`S` >> + simp[] >> conj_tac >- ( + SUBST1_TAC(DECIDE``1 = 0+1``) >> + rpt strip_tac >> irule balanced_append >> + REWRITE_TAC[ONE] >> simp[] ) >> + metis_tac[balanced_append,DECIDE``0+0=0``]) + +val Sins = Q.store_thm("Sins", + `∀w. S w ⇒ ∀w1 w2. (w = w1 ++ w2) ⇒ S(w1++[a;b]++w2)`, + Induct_on`S`>> + rw[APPEND_EQ_APPEND,APPEND_EQ_CONS] >> fs[] >> + met[S_rules]) + +val balanced_S = Q.store_thm("balanced_S", + `∀w n. balanced w n ⇒ S (REPLICATE n a ++ w)`, + ho_match_mp_tac balanced_ind >> + simp[REPLICATE_GENLIST] >> rw[] >> fs[] >- ( + fs[GENLIST,SNOC_APPEND] >> met[] ) >> + imp_res_tac Sins >> + first_x_assum(qspec_then`w`mp_tac) >> simp[] >> + simp[GENLIST,SNOC_APPEND] >> met[]) + +val balanced_iff_S = Q.store_thm("balanced_iff_S", + `balanced w 0 ⇔ S w`, + metis_tac[balanced_S,S_balanced,REPLICATE,APPEND]) + +val _ = export_theory() From 8b04c082838958bd1e3c867619ccef6b9d94259d Mon Sep 17 00:00:00 2001 From: Thibault Gauthier Date: Sun, 23 Aug 2015 15:28:55 +0200 Subject: [PATCH 430/718] adapting holyhammer gitignore --- src/holyhammer/.gitignore | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/src/holyhammer/.gitignore b/src/holyhammer/.gitignore index 12309cc90a..225e512c4b 100644 --- a/src/holyhammer/.gitignore +++ b/src/holyhammer/.gitignore @@ -1,7 +1,4 @@ theories/* -provers/eprover/eprover -provers/eprover/eprover_files/* -provers/z3/z3 -provers/z3/z3_files/* -provers/vampire/vampire -provers/vampire/vampire_files/* +provers/eprover/* +provers/z3/* +provers/vampire/* From 1f221e4c7905af501453188b60c751e130c61df3 Mon Sep 17 00:00:00 2001 From: Thibault Gauthier Date: Sun, 23 Aug 2015 22:42:49 +0200 Subject: [PATCH 431/718] holyhammer: edited Readme + removing dependency to timeout --- src/holyhammer/README | 14 +++++++++++--- src/holyhammer/provers/eprover.sh | 2 +- src/holyhammer/provers/vampire.sh | 2 +- src/holyhammer/provers/z3.sh | 2 +- 4 files changed, 14 insertions(+), 6 deletions(-) diff --git a/src/holyhammer/README b/src/holyhammer/README index fa1a15d434..58029e9a41 100644 --- a/src/holyhammer/README +++ b/src/holyhammer/README @@ -18,12 +18,20 @@ Install holyhammer: (done during the build) run Holmake in src/holyhammer/predict run Holmake in src/holyhammer/predict/mepo -Supported provers: Eprover, Vampire and Z3 +Supported provers: Eprover, Z3 and (Vampire) + They need to be installed manually so that they be called from the command +line using the respective commands eprover, vampire and z3. + At least one of these provers +should be installed for holyHammer to work. + Eprover: - Tested with 1.8 and 1.9. + Tested with 1.8 and 1.9. Can be fetched from + http://wwwlehre.dhbw-stuttgart.de/~sschulz/E/E.html. Vampire: - Tested with version 2.6. Parsing may need changing for higher versions + Tested with version 2.6. Parsing may need changing for higher versions. + Waiting for 3.0 to be released at http://www.vprover.org/download.cgi + before adapting the parsing. Z3: Tested with 4.0. The newest version of z3 does not support tptp input. Can be fetch from http://isabelle.in.tum.de/components/. diff --git a/src/holyhammer/provers/eprover.sh b/src/holyhammer/provers/eprover.sh index 015ebb6d7a..f67b7d7b99 100644 --- a/src/holyhammer/provers/eprover.sh +++ b/src/holyhammer/provers/eprover.sh @@ -8,7 +8,7 @@ STATUS="$DIR/eprover_status" ERROR="$DIR/eprover_error" # Running eprover (1.8) -timeout $1 eprover -s --cpu-limit=$1 --auto-schedule --tptp3-in \ +eprover -s --cpu-limit=$1 --auto-schedule --tptp3-in \ -R --print-statistics -p --tstp-format $IN | grep "file[(]'\|# SZS" > $OUT1 2> $ERROR # Extracting status grep "SZS status" $OUT1 > $STATUS 2> $ERROR diff --git a/src/holyhammer/provers/vampire.sh b/src/holyhammer/provers/vampire.sh index 532b0f8db8..aefb3fd260 100644 --- a/src/holyhammer/provers/vampire.sh +++ b/src/holyhammer/provers/vampire.sh @@ -8,7 +8,7 @@ STATUS="$DIR/vampire_status" ERROR="$DIR/vampire_error" # Running Vampire (2.6) -timeout $1 vampire --mode casc -t $1 --proof tptp --output_axiom_names on $IN \ +vampire --mode casc -t $1 --proof tptp --output_axiom_names on $IN \ | grep "file[(]'\| SZS" > $OUT1 2> $ERROR # Extracting status grep "SZS status" $OUT1 > $STATUS 2> $ERROR diff --git a/src/holyhammer/provers/z3.sh b/src/holyhammer/provers/z3.sh index 4872ef083a..f52068f75b 100644 --- a/src/holyhammer/provers/z3.sh +++ b/src/holyhammer/provers/z3.sh @@ -8,7 +8,7 @@ STATUS="$DIR/z3_status" ERROR="$DIR/z3_error" # Running Z3 (4.0) -timeout $1 z3 -tptp DISPLAY_UNSAT_CORE=true ELIM_QUANTIFIERS=true PULL_NESTED_QUANTIFIERS=true \ +z3 -tptp DISPLAY_UNSAT_CORE=true ELIM_QUANTIFIERS=true PULL_NESTED_QUANTIFIERS=true \ -T:$1 $IN > $OUT1 2> $ERROR # Extracting status grep "SZS status" $OUT1 > $STATUS 2> $ERROR From 388273e275184e8401d4301f94309cb28ccaf1b8 Mon Sep 17 00:00:00 2001 From: Thibault Gauthier Date: Sun, 23 Aug 2015 23:39:21 +0200 Subject: [PATCH 432/718] holyhammer: redirecting error message to error file --- src/holyhammer/provers/eprover.sh | 2 +- src/holyhammer/provers/vampire.sh | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/holyhammer/provers/eprover.sh b/src/holyhammer/provers/eprover.sh index f67b7d7b99..4e7ce08562 100644 --- a/src/holyhammer/provers/eprover.sh +++ b/src/holyhammer/provers/eprover.sh @@ -9,7 +9,7 @@ ERROR="$DIR/eprover_error" # Running eprover (1.8) eprover -s --cpu-limit=$1 --auto-schedule --tptp3-in \ --R --print-statistics -p --tstp-format $IN | grep "file[(]'\|# SZS" > $OUT1 2> $ERROR +-R --print-statistics -p --tstp-format $IN 2> $ERROR | grep "file[(]'\|# SZS" > $OUT1 # Extracting status grep "SZS status" $OUT1 > $STATUS 2> $ERROR sed -i -e 's/^.*SZS status\(.*\).*/\1/' $STATUS 2> $ERROR diff --git a/src/holyhammer/provers/vampire.sh b/src/holyhammer/provers/vampire.sh index aefb3fd260..bf238cbd1c 100644 --- a/src/holyhammer/provers/vampire.sh +++ b/src/holyhammer/provers/vampire.sh @@ -8,8 +8,8 @@ STATUS="$DIR/vampire_status" ERROR="$DIR/vampire_error" # Running Vampire (2.6) -vampire --mode casc -t $1 --proof tptp --output_axiom_names on $IN \ - | grep "file[(]'\| SZS" > $OUT1 2> $ERROR +vampire --mode casc -t $1 --proof tptp --output_axiom_names on $IN 2> $ERROR \ + | grep "file[(]'\| SZS" > $OUT1 # Extracting status grep "SZS status" $OUT1 > $STATUS 2> $ERROR sed -i -e 's/^%[ ]*SZS[ ]*status\(.*\)[ ]*for.*$/\1/' $STATUS 2> $ERROR From cb68734363dd30582d0df677e36a46bcbccee469 Mon Sep 17 00:00:00 2001 From: Thibault Gauthier Date: Mon, 24 Aug 2015 00:20:05 +0200 Subject: [PATCH 433/718] holyhammer: waiting for all provers to finish --- src/holyhammer/scripts/hh.sh | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/holyhammer/scripts/hh.sh b/src/holyhammer/scripts/hh.sh index db98cbabb2..292f1d77fb 100644 --- a/src/holyhammer/scripts/hh.sh +++ b/src/holyhammer/scripts/hh.sh @@ -7,4 +7,5 @@ Z3="../provers/z3/z3" # Run eprover, vampire and z3 (type eprover >/dev/null 2>&1 && sh hh_eprover.sh $2 $5 $1) & \ (type vampire >/dev/null 2>&1 && sh hh_vampire.sh $3 $6 $1) & \ -(type z3 >/dev/null 2>&1 && sh hh_z3.sh $4 $7 $1) +(type z3 >/dev/null 2>&1 && sh hh_z3.sh $4 $7 $1) & \ +wait From 834fa9d863b54cd720c1e485080f1e7559266364 Mon Sep 17 00:00:00 2001 From: Thibault Gauthier Date: Mon, 24 Aug 2015 00:21:34 +0200 Subject: [PATCH 434/718] holyhammer: removing some unnecessary bash variables in hh.sh --- src/holyhammer/scripts/hh.sh | 4 ---- 1 file changed, 4 deletions(-) diff --git a/src/holyhammer/scripts/hh.sh b/src/holyhammer/scripts/hh.sh index 292f1d77fb..c96f6de7d5 100644 --- a/src/holyhammer/scripts/hh.sh +++ b/src/holyhammer/scripts/hh.sh @@ -1,9 +1,5 @@ #!/bin/sh -EPROVER="../provers/eprover/eprover" -VAMPIRE="../provers/vampire/vampire" -Z3="../provers/z3/z3" - # Run eprover, vampire and z3 (type eprover >/dev/null 2>&1 && sh hh_eprover.sh $2 $5 $1) & \ (type vampire >/dev/null 2>&1 && sh hh_vampire.sh $3 $6 $1) & \ From d7d0863fc412aa9048996579212047458f40362f Mon Sep 17 00:00:00 2001 From: Thibault Gauthier Date: Mon, 24 Aug 2015 00:58:40 +0200 Subject: [PATCH 435/718] holyhammer(minor): Doc --- help/Docfiles/holyHammer.hh.doc | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/help/Docfiles/holyHammer.hh.doc b/help/Docfiles/holyHammer.hh.doc index 51b77ffe26..5838c26504 100644 --- a/help/Docfiles/holyHammer.hh.doc +++ b/help/Docfiles/holyHammer.hh.doc @@ -40,7 +40,8 @@ the proof from the selected lemmas in less than 30 seconds. } \COMMENTS -See more examples in src/holyHammer/examples. +See src/holyhammer/README for more information on how to install the provers. +See more examples in src/holyhammer/examples. \SEEALSO DB.match, DB.matchp, DB.matcher. From 8bfc36ff801d1c44617d7f00dd635503a2057676 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 24 Aug 2015 09:47:37 +0800 Subject: [PATCH 436/718] Fix Holmakefile bug apparent on Windows The $(dprot ...) function should be called to protect dependencies, but $(protect ...) should be used when things need protecting on commandlines. Not sure how Windows HOL managed to build given this, but thanks to Andrea Condoluci for helping discover the problem. --- src/parse/Holmakefile | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/parse/Holmakefile b/src/parse/Holmakefile index a349756308..8e02fe3bd1 100644 --- a/src/parse/Holmakefile +++ b/src/parse/Holmakefile @@ -14,13 +14,13 @@ base_lexer.sml: base_lexer $(protect $(HOLDIR)/tools/mllex/mllex.exe) base_lexer LVTermNetFunctor.ui LVTermNetFunctor.uo: LVTermNetFunctor.sml - $(HOLMOSMLC) $(dprot $(SIGOBJ)/Overlay.ui) -toplevel -c $< + $(HOLMOSMLC) $(protect $(SIGOBJ)/Overlay.ui) -toplevel -c $< Overload.ui: Overload.sig LVTermNetFunctor.ui - $(HOLMOSMLC) $(dprot $(SIGOBJ)/Overlay.ui) LVTermNetFunctor.ui -c $< + $(HOLMOSMLC) $(protect $(SIGOBJ)/Overlay.ui) LVTermNetFunctor.ui -c $< Overload.uo: Overload.sml Overload.ui $(dprot $(SIGOBJ)/Lexis.ui) $(dprot $(SIGOBJ)/HOLset.ui) LVTermNetFunctor.ui stmonad.ui GrammarSpecials.ui - $(HOLMOSMLC) $(dprot $(SIGOBJ)/Overlay.ui) LVTermNetFunctor.ui -c $< + $(HOLMOSMLC) $(protect $(SIGOBJ)/Overlay.ui) LVTermNetFunctor.ui -c $< selftest.exe: selftest.uo $(SELFTEST_DEPS) $(HOLMOSMLC) -o $@ $< From 8fce5d4effcba0b628042f0cb00b54d8fd4b026e Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 24 Aug 2015 11:20:42 +0800 Subject: [PATCH 437/718] Reapply 1ab5ef6508 These are necessary for these files to build with Moscow ML. Please be careful merging changes. --- src/holyhammer/hhReconstruct.sig | 1 + src/holyhammer/hhWriter.sig | 1 + src/holyhammer/hhWriter.sml | 4 +++- 3 files changed, 5 insertions(+), 1 deletion(-) diff --git a/src/holyhammer/hhReconstruct.sig b/src/holyhammer/hhReconstruct.sig index 7e70635266..6675d46f08 100644 --- a/src/holyhammer/hhReconstruct.sig +++ b/src/holyhammer/hhReconstruct.sig @@ -1,6 +1,7 @@ signature hhReconstruct = sig + include Abbrev val minimize_flag : bool ref val reconstruct : thm list -> (string * string) -> term -> unit val reconstructl : thm list -> (string * string) list -> term -> unit diff --git a/src/holyhammer/hhWriter.sig b/src/holyhammer/hhWriter.sig index aeead0f4fa..d98f3d67dd 100644 --- a/src/holyhammer/hhWriter.sig +++ b/src/holyhammer/hhWriter.sig @@ -1,6 +1,7 @@ signature hhWriter = sig + include Abbrev val thm_of_depid : Dep.depid -> (string * Thm.thm) val write_hh_thyl : string -> string list -> unit diff --git a/src/holyhammer/hhWriter.sml b/src/holyhammer/hhWriter.sml index 44c212676c..77878c9aab 100644 --- a/src/holyhammer/hhWriter.sml +++ b/src/holyhammer/hhWriter.sml @@ -241,8 +241,10 @@ fun oty ty = else (os ("(" ^ s ^ " "); oiter " " oty Args; os ")") end end +type ('a,'b)substp = {redex : 'a, residue : 'b} val less_ty = fn a => (fn b => Type.compare (a,b) = LESS) -fun less_red a b = less_ty (#redex a) (#redex b) +fun less_red (a:(hol_type,'a)substp) (b:(hol_type,'b)substp) = + less_ty (#redex a) (#redex b) fun id_subst a = {redex = a, residue = a} fun full_match_type t1 t2 = From 620d3d8a9900a3e5e3b3af1d7c9a086132092759 Mon Sep 17 00:00:00 2001 From: Thibault Gauthier Date: Mon, 24 Aug 2015 14:42:04 +0200 Subject: [PATCH 438/718] holyhammer: fixing reading status --- src/holyhammer/README | 9 ++++----- src/holyhammer/hhReconstruct.sml | 11 ++++++++++- src/holyhammer/provers/eprover.sh | 2 +- 3 files changed, 15 insertions(+), 7 deletions(-) diff --git a/src/holyhammer/README b/src/holyhammer/README index 58029e9a41..d8b2bfa3d5 100644 --- a/src/holyhammer/README +++ b/src/holyhammer/README @@ -20,10 +20,9 @@ Install holyhammer: (done during the build) Supported provers: Eprover, Z3 and (Vampire) - They need to be installed manually so that they be called from the command -line using the respective commands eprover, vampire and z3. - At least one of these provers -should be installed for holyHammer to work. + They need to be installed manually, a binary of each prover with the appropriate +version should be copied to src/holyhammer/provers. At least +one of them should be installed for holyHammer to work. Eprover: Tested with 1.8 and 1.9. Can be fetched from @@ -33,7 +32,7 @@ should be installed for holyHammer to work. Waiting for 3.0 to be released at http://www.vprover.org/download.cgi before adapting the parsing. Z3: - Tested with 4.0. The newest version of z3 does not support + Tested with 4.0. Higher versions of z3 does not support tptp input. Can be fetch from http://isabelle.in.tum.de/components/. CVC4: Waiting for a good minimization algorithm to be implemented diff --git a/src/holyhammer/hhReconstruct.sml b/src/holyhammer/hhReconstruct.sml index fab59b95ea..6e6ee3f4e4 100644 --- a/src/holyhammer/hhReconstruct.sml +++ b/src/holyhammer/hhReconstruct.sml @@ -18,6 +18,14 @@ val ERR = mk_HOL_ERR "hhReconstruct" Unescaping and extracting theorem and theory name. ----------------------------------------------------------------------------*) +fun remove_white_spaces s = + let + val cl = String.explode s + val cl' = filter (not o Char.isSpace) cl + in + String.implode cl' + end + (* Assumes the term was single quoted before *) fun unsquotify s = if String.size s >= 2 @@ -68,7 +76,8 @@ fun readl path = (TextIO.closeIn file; l3) end -fun read_status path = hd (readl path) handle _ => "Unknown" +fun read_status path = + remove_white_spaces (hd (readl path)) handle _ => "Unknown" (*--------------------------------------------------------------------------- Timed Metis diff --git a/src/holyhammer/provers/eprover.sh b/src/holyhammer/provers/eprover.sh index 4e7ce08562..fd4ede1e29 100644 --- a/src/holyhammer/provers/eprover.sh +++ b/src/holyhammer/provers/eprover.sh @@ -7,7 +7,7 @@ OUT="$DIR/eprover_out" STATUS="$DIR/eprover_status" ERROR="$DIR/eprover_error" -# Running eprover (1.8) +# Running eprover (1.8 or 1.9) eprover -s --cpu-limit=$1 --auto-schedule --tptp3-in \ -R --print-statistics -p --tstp-format $IN 2> $ERROR | grep "file[(]'\|# SZS" > $OUT1 # Extracting status From faa9c29dfe9cb6d76614cf6570c582b6d8fc84b3 Mon Sep 17 00:00:00 2001 From: Thibault Gauthier Date: Mon, 24 Aug 2015 15:20:08 +0200 Subject: [PATCH 439/718] holyhammer: reverting to the binary (symlink) approach to prevent multiple version problems. Provers(ATP) binaries should now be copied in src/provers --- src/holyhammer/.gitignore | 9 ++++++--- src/holyhammer/README | 9 +++++---- src/holyhammer/holyHammer.sml | 2 +- src/holyhammer/provers/eprover.sh | 4 ++-- src/holyhammer/provers/vampire.sh | 4 ++-- src/holyhammer/provers/z3.sh | 4 ++-- src/holyhammer/scripts/hh.sh | 10 +++++++--- src/holyhammer/scripts/hh_eprover.sh | 2 +- src/holyhammer/scripts/hh_vampire.sh | 2 +- src/holyhammer/scripts/hh_z3.sh | 2 +- 10 files changed, 28 insertions(+), 20 deletions(-) diff --git a/src/holyhammer/.gitignore b/src/holyhammer/.gitignore index 225e512c4b..a469bed848 100644 --- a/src/holyhammer/.gitignore +++ b/src/holyhammer/.gitignore @@ -1,4 +1,7 @@ theories/* -provers/eprover/* -provers/z3/* -provers/vampire/* +provers/eprover_files/* +provers/z3_files/* +provers/vampire_files/* +provers/eprover +provers/z3 +provers/vampire diff --git a/src/holyhammer/README b/src/holyhammer/README index d8b2bfa3d5..4559a67474 100644 --- a/src/holyhammer/README +++ b/src/holyhammer/README @@ -18,11 +18,12 @@ Install holyhammer: (done during the build) run Holmake in src/holyhammer/predict run Holmake in src/holyhammer/predict/mepo -Supported provers: Eprover, Z3 and (Vampire) +Supported provers: Eprover, Z3 (4.0) and (Vampire) - They need to be installed manually, a binary of each prover with the appropriate -version should be copied to src/holyhammer/provers. At least -one of them should be installed for holyHammer to work. + They need to be installed manually. Binaries with the appropriate version + have to be fetched from the location cited below. They should be copied + or linked in the directory src/provers. Their names should be respectively + eprover, z3 and vampire. Eprover: Tested with 1.8 and 1.9. Can be fetched from diff --git a/src/holyhammer/holyHammer.sml b/src/holyhammer/holyHammer.sml index d9732c6eb2..b20e9fa377 100644 --- a/src/holyhammer/holyHammer.sml +++ b/src/holyhammer/holyHammer.sml @@ -97,7 +97,7 @@ val hh_dir = HOLDIR ^ "/src/holyhammer" val scripts_dir = hh_dir ^ "/scripts" val thy_dir = hh_dir ^ "/theories" -fun dir_of_prover atp = hh_dir ^ "/provers/" ^ name_of_atp atp +fun dir_of_prover atp = hh_dir ^ "/provers/" ^ name_of_atp atp ^ "_files" fun out_of_prover atp = dir_of_prover atp ^ "/" ^ name_of_atp atp ^ "_out" diff --git a/src/holyhammer/provers/eprover.sh b/src/holyhammer/provers/eprover.sh index fd4ede1e29..39a1f6b15b 100644 --- a/src/holyhammer/provers/eprover.sh +++ b/src/holyhammer/provers/eprover.sh @@ -1,5 +1,5 @@ # I/O files -DIR="eprover" +DIR="eprover_files" IN="$DIR/atp_in" OUT1="$DIR/eprover_out1" OUT2="$DIR/eprover_out2" @@ -8,7 +8,7 @@ STATUS="$DIR/eprover_status" ERROR="$DIR/eprover_error" # Running eprover (1.8 or 1.9) -eprover -s --cpu-limit=$1 --auto-schedule --tptp3-in \ +./eprover -s --cpu-limit=$1 --auto-schedule --tptp3-in \ -R --print-statistics -p --tstp-format $IN 2> $ERROR | grep "file[(]'\|# SZS" > $OUT1 # Extracting status grep "SZS status" $OUT1 > $STATUS 2> $ERROR diff --git a/src/holyhammer/provers/vampire.sh b/src/holyhammer/provers/vampire.sh index bf238cbd1c..7d5e655091 100644 --- a/src/holyhammer/provers/vampire.sh +++ b/src/holyhammer/provers/vampire.sh @@ -1,5 +1,5 @@ # I/O files -DIR="vampire" +DIR="vampire_files" IN="$DIR/atp_in" OUT="$DIR/vampire_out" OUT1="$DIR/vampire_out1" @@ -8,7 +8,7 @@ STATUS="$DIR/vampire_status" ERROR="$DIR/vampire_error" # Running Vampire (2.6) -vampire --mode casc -t $1 --proof tptp --output_axiom_names on $IN 2> $ERROR \ +./vampire --mode casc -t $1 --proof tptp --output_axiom_names on $IN 2> $ERROR \ | grep "file[(]'\| SZS" > $OUT1 # Extracting status grep "SZS status" $OUT1 > $STATUS 2> $ERROR diff --git a/src/holyhammer/provers/z3.sh b/src/holyhammer/provers/z3.sh index f52068f75b..9c9615d97d 100644 --- a/src/holyhammer/provers/z3.sh +++ b/src/holyhammer/provers/z3.sh @@ -1,5 +1,5 @@ # I/O files -DIR="z3" +DIR="z3_files" IN="$DIR/atp_in" OUT1="$DIR/z3_out1" OUT2="$DIR/z3_out2" @@ -8,7 +8,7 @@ STATUS="$DIR/z3_status" ERROR="$DIR/z3_error" # Running Z3 (4.0) -z3 -tptp DISPLAY_UNSAT_CORE=true ELIM_QUANTIFIERS=true PULL_NESTED_QUANTIFIERS=true \ +./z3 -tptp DISPLAY_UNSAT_CORE=true ELIM_QUANTIFIERS=true PULL_NESTED_QUANTIFIERS=true \ -T:$1 $IN > $OUT1 2> $ERROR # Extracting status grep "SZS status" $OUT1 > $STATUS 2> $ERROR diff --git a/src/holyhammer/scripts/hh.sh b/src/holyhammer/scripts/hh.sh index c96f6de7d5..cf6cf67b57 100644 --- a/src/holyhammer/scripts/hh.sh +++ b/src/holyhammer/scripts/hh.sh @@ -1,7 +1,11 @@ #!/bin/sh +EPROVER="../provers/eprover" +VAMPIRE="../provers/vampire" +Z3="../provers/z3" + # Run eprover, vampire and z3 -(type eprover >/dev/null 2>&1 && sh hh_eprover.sh $2 $5 $1) & \ -(type vampire >/dev/null 2>&1 && sh hh_vampire.sh $3 $6 $1) & \ -(type z3 >/dev/null 2>&1 && sh hh_z3.sh $4 $7 $1) & \ +(if [ -f $EPROVER ]; then sh hh_eprover.sh $2 $5 $1; fi) & \ +(if [ -f $VAMPIRE ]; then sh hh_vampire.sh $3 $6 $1; fi) & \ +(if [ -f $Z3 ]; then sh hh_z3.sh $4 $7 $1; fi) & \ wait diff --git a/src/holyhammer/scripts/hh_eprover.sh b/src/holyhammer/scripts/hh_eprover.sh index 387646bcf3..72082f4bf0 100644 --- a/src/holyhammer/scripts/hh_eprover.sh +++ b/src/holyhammer/scripts/hh_eprover.sh @@ -1,4 +1,4 @@ -EPROVER_DIR="../provers/eprover" +EPROVER_DIR="../provers/eprover_files" clean(){ if [ -d $1 ]; then rm -r $1; fi diff --git a/src/holyhammer/scripts/hh_vampire.sh b/src/holyhammer/scripts/hh_vampire.sh index 868934849b..672a41ebd1 100644 --- a/src/holyhammer/scripts/hh_vampire.sh +++ b/src/holyhammer/scripts/hh_vampire.sh @@ -1,4 +1,4 @@ -VAMPIRE_DIR="../provers/vampire" +VAMPIRE_DIR="../provers/vampire_files" clean(){ if [ -d $1 ]; then rm -r $1; fi diff --git a/src/holyhammer/scripts/hh_z3.sh b/src/holyhammer/scripts/hh_z3.sh index 99658e7442..0130a8e85d 100644 --- a/src/holyhammer/scripts/hh_z3.sh +++ b/src/holyhammer/scripts/hh_z3.sh @@ -1,4 +1,4 @@ -Z3_DIR="../provers/z3" +Z3_DIR="../provers/z3_files" clean(){ if [ -d $1 ]; then rm -r $1; fi From 075593f247ee9a49ad3f7f07c8d37cad26cf46fd Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 24 Aug 2015 22:19:44 +0800 Subject: [PATCH 440/718] Remove trailing whitespace in holyHammer.sml --- src/holyhammer/holyHammer.sml | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/src/holyhammer/holyHammer.sml b/src/holyhammer/holyHammer.sml index b20e9fa377..9a6cfa2f61 100644 --- a/src/holyhammer/holyHammer.sml +++ b/src/holyhammer/holyHammer.sml @@ -99,10 +99,10 @@ val thy_dir = hh_dir ^ "/theories" fun dir_of_prover atp = hh_dir ^ "/provers/" ^ name_of_atp atp ^ "_files" -fun out_of_prover atp = +fun out_of_prover atp = dir_of_prover atp ^ "/" ^ name_of_atp atp ^ "_out" -fun status_of_prover atp = +fun status_of_prover atp = dir_of_prover atp ^ "/" ^ name_of_atp atp ^ "_status" fun hh_of_prover atp = "hh_" ^ name_of_atp atp ^ ".sh" @@ -135,7 +135,7 @@ fun export_namethml cj namethml = write_conjecture (thy_dir ^ "/conjecture") cj; (* write the dependencies between theories *) write_thydep (thy_dir ^ "/thydep") thyl - end + end (* TO DO: Incremental export @@ -189,22 +189,22 @@ fun hh_argl thml cj argl = reconstructl thml atpfilel cj end -fun hh thml cj = - hh_argl thml cj +fun hh thml cj = + hh_argl thml cj (mk_argl (!eprover_settings,!vampire_settings,!z3_settings)) (* Try best strategies sequentially *) fun hh_try thml cj = - let + let val strat1 = ((KNN,128,5),(KNN,96,5),(KNN,32,5)) val strat2 = ((Mepo,128,5),(Mepo,96,5),(Mepo,32,5)) val strat3 = ((Kepo,128,5),(Kepo,96,5),(Kepo,32,5)) in - (hh_argl thml cj (mk_argl strat1) handle _ => - hh_argl thml cj (mk_argl strat2)) handle _ => + (hh_argl thml cj (mk_argl strat1) handle _ => + hh_argl thml cj (mk_argl strat2)) handle _ => hh_argl thml cj (mk_argl strat3) end - + (* Let you chose the specific prover you want to use either ("eprover", "vampire" or "z3") *) fun hh_atp atp thml cj = From 61001e1d3964eb4ec41e9638d22b75f383e3b314 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 24 Aug 2015 22:20:07 +0800 Subject: [PATCH 441/718] Reinstate another part of 1ab5ef6508b I didn't get this in the earlier 8fce5d4eff --- src/holyhammer/holyHammer.sml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/holyhammer/holyHammer.sml b/src/holyhammer/holyHammer.sml index 9a6cfa2f61..845dce2d98 100644 --- a/src/holyhammer/holyHammer.sml +++ b/src/holyhammer/holyHammer.sml @@ -13,7 +13,7 @@ structure holyHammer :> holyHammer = struct -open hhWriter hhReconstruct +open HolKernel boolLib hhWriter hhReconstruct val ERR = mk_HOL_ERR "holyHammer" From 87ec6f379062e366cdac043880b61e2862bbb3f2 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 26 Aug 2015 09:48:42 +0800 Subject: [PATCH 442/718] Not "hierarchically" finite; "hereditarily" finite --- examples/hfs/hfsScript.sml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/hfs/hfsScript.sml b/examples/hfs/hfsScript.sml index 58e23a6211..34a44d1b87 100644 --- a/examples/hfs/hfsScript.sml +++ b/examples/hfs/hfsScript.sml @@ -1,4 +1,4 @@ -(* Define the type of hierarchically finite sets. +(* Define the type of hereditarily finite sets. Single (recursive) constructor is From 7f94c9158bada8afc4dd087bcff66dd95deb0642 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 27 Aug 2015 08:11:11 +0800 Subject: [PATCH 443/718] Add CONTRIBUTORS list; modify COPYRIGHT I've added a CONTRIBUTORS list that I hope is fairly comprehensive. I've derived it from the list of acknowledgements in the Manual, and from an inspection of our git history. I've also modified the COPYRIGHT to simply assert ownership by the CONTRIBUTORS. As I've commented in the past, it may be simpler to try to assert that it is all simply in the public domain. --- CONTRIBUTORS | 41 +++++++++++++++++++++++++++++++++++++++++ COPYRIGHT | 5 +---- 2 files changed, 42 insertions(+), 4 deletions(-) create mode 100644 CONTRIBUTORS diff --git a/CONTRIBUTORS b/CONTRIBUTORS new file mode 100644 index 0000000000..ea459edefa --- /dev/null +++ b/CONTRIBUTORS @@ -0,0 +1,41 @@ +Vincent Aravantinos +Bruno Barras +Richard Boulton +Jens Brandt +Aaron Coble +Hélène Collavizza +Andrea Condoluci +Jeremy Dawson +Anthony Fox +Elsa Gunter +Ken Friis Larsen +Thibault Gauthier +Mike Gordon +Juliano Iyoda +Matt Kaufmann +Narges Khakpour +Ramana Kumar +John Harrison +Peter Homeier +Joe Leslie Hurd +Guodong Li +Tom Melham +Tarek Mhamdi +Robin Milner +Lockwood Morris +Magnus Myreen +Malcolm Newey +Michael Norrish +Scott Owens +Larry Paulson +James Reynolds +Tom Ridge +Peter Sewell +Konrad Slind +Donald Syme +Piotr Trojanek +Thomas Türk +Chris Wadsworth +Keith Wansbrough +Tjark Weber +Chongkai Zhu diff --git a/COPYRIGHT b/COPYRIGHT index b91a4c4073..28b19cddf9 100644 --- a/COPYRIGHT +++ b/COPYRIGHT @@ -1,9 +1,6 @@ HOL COPYRIGHT NOTICE, LICENSE AND DISCLAIMER. -Copyright 1998, 1999 by Konrad Slind. -Copyright 2000--2014 by Michael Norrish and Konrad Slind. - -All rights reserved. +Copyright 2015 by the HOL4 CONTRIBUTORS Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are From ebb276cffb4e4c88da7e0dd82ee4e9d5117dc59d Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 27 Aug 2015 08:17:00 +0800 Subject: [PATCH 444/718] CONTRIBUTORS: Joe has a hyphenated surname --- CONTRIBUTORS | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CONTRIBUTORS b/CONTRIBUTORS index ea459edefa..0a48da919c 100644 --- a/CONTRIBUTORS +++ b/CONTRIBUTORS @@ -17,7 +17,7 @@ Narges Khakpour Ramana Kumar John Harrison Peter Homeier -Joe Leslie Hurd +Joe Leslie-Hurd Guodong Li Tom Melham Tarek Mhamdi From ffda7f68b17bb941603928a2dd376d8c557fe26d Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 27 Aug 2015 08:29:22 +0800 Subject: [PATCH 445/718] Fix sorting error in CONTRIBUTORS file --- CONTRIBUTORS | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CONTRIBUTORS b/CONTRIBUTORS index 0a48da919c..7dbc0db56a 100644 --- a/CONTRIBUTORS +++ b/CONTRIBUTORS @@ -7,10 +7,10 @@ Hélène Collavizza Andrea Condoluci Jeremy Dawson Anthony Fox -Elsa Gunter Ken Friis Larsen Thibault Gauthier Mike Gordon +Elsa Gunter Juliano Iyoda Matt Kaufmann Narges Khakpour From bdee03d19bba90e7416ba5cfc9e062bb13f98fce Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 27 Aug 2015 08:51:34 +0800 Subject: [PATCH 446/718] More sorting errors in CONTRIBUTORS --- CONTRIBUTORS | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/CONTRIBUTORS b/CONTRIBUTORS index 7dbc0db56a..2a72099fdf 100644 --- a/CONTRIBUTORS +++ b/CONTRIBUTORS @@ -11,12 +11,12 @@ Ken Friis Larsen Thibault Gauthier Mike Gordon Elsa Gunter +John Harrison +Peter Homeier Juliano Iyoda Matt Kaufmann Narges Khakpour Ramana Kumar -John Harrison -Peter Homeier Joe Leslie-Hurd Guodong Li Tom Melham From ba61219fc37c2d6b3b82d5e645241ce7d93685e3 Mon Sep 17 00:00:00 2001 From: Thomas Tuerk Date: Thu, 27 Aug 2015 07:59:40 +0200 Subject: [PATCH 447/718] fix spelling of my name in CONTRIBUTORS list --- CONTRIBUTORS | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CONTRIBUTORS b/CONTRIBUTORS index 2a72099fdf..556e58d79c 100644 --- a/CONTRIBUTORS +++ b/CONTRIBUTORS @@ -34,7 +34,7 @@ Peter Sewell Konrad Slind Donald Syme Piotr Trojanek -Thomas Türk +Thomas Tuerk Chris Wadsworth Keith Wansbrough Tjark Weber From 472f178084005ec3e075b3e89dca5b86d0a84836 Mon Sep 17 00:00:00 2001 From: Magnus Myreen Date: Fri, 21 Aug 2015 10:27:45 +0200 Subject: [PATCH 448/718] public release of decompiler tool developed at NICTA An earlier version of this tool was described in the following paper: Thomas Sewell, Magnus O. Myreen and Gerwin Klein. Translation validation for a verified OS kernel. In Programming Language Design and Implementation (PLDI), 2013. --- CONTRIBUTORS | 1 + .../machine-code/graph/GraphLangScript.sml | 1919 +++++++++++++++++ examples/machine-code/graph/Holmakefile | 35 + examples/machine-code/graph/backgroundLib.sml | 153 ++ examples/machine-code/graph/cond_cleanLib.sml | 126 ++ examples/machine-code/graph/decompile.py | 91 + examples/machine-code/graph/decompileLib.sml | 14 + .../machine-code/graph/derive_specsLib.sml | 726 +++++++ examples/machine-code/graph/exportLib.sml | 375 ++++ .../machine-code/graph/file_readerLib.sml | 280 +++ .../machine-code/graph/func_decompileLib.sml | 215 ++ .../machine-code/graph/graph_specsLib.sml | 451 ++++ examples/machine-code/graph/loop-m0/example.c | 22 + .../graph/loop-m0/example.elf.txt | 32 + .../machine-code/graph/loop-m0/example.sigs | 3 + examples/machine-code/graph/loop/example.c | 22 + .../machine-code/graph/loop/example.elf.txt | 55 + examples/machine-code/graph/loop/example.sigs | 3 + .../machine-code/graph/stack_analysisLib.sml | 253 +++ .../machine-code/graph/stack_introLib.sml | 80 + examples/machine-code/graph/syntaxLib.sml | 33 + examples/machine-code/graph/writerLib.sml | 75 + 22 files changed, 4964 insertions(+) create mode 100644 examples/machine-code/graph/GraphLangScript.sml create mode 100644 examples/machine-code/graph/Holmakefile create mode 100644 examples/machine-code/graph/backgroundLib.sml create mode 100644 examples/machine-code/graph/cond_cleanLib.sml create mode 100644 examples/machine-code/graph/decompile.py create mode 100644 examples/machine-code/graph/decompileLib.sml create mode 100644 examples/machine-code/graph/derive_specsLib.sml create mode 100644 examples/machine-code/graph/exportLib.sml create mode 100644 examples/machine-code/graph/file_readerLib.sml create mode 100644 examples/machine-code/graph/func_decompileLib.sml create mode 100644 examples/machine-code/graph/graph_specsLib.sml create mode 100644 examples/machine-code/graph/loop-m0/example.c create mode 100644 examples/machine-code/graph/loop-m0/example.elf.txt create mode 100644 examples/machine-code/graph/loop-m0/example.sigs create mode 100644 examples/machine-code/graph/loop/example.c create mode 100644 examples/machine-code/graph/loop/example.elf.txt create mode 100644 examples/machine-code/graph/loop/example.sigs create mode 100644 examples/machine-code/graph/stack_analysisLib.sml create mode 100644 examples/machine-code/graph/stack_introLib.sml create mode 100644 examples/machine-code/graph/syntaxLib.sml create mode 100644 examples/machine-code/graph/writerLib.sml diff --git a/CONTRIBUTORS b/CONTRIBUTORS index 556e58d79c..ca6f06dd55 100644 --- a/CONTRIBUTORS +++ b/CONTRIBUTORS @@ -31,6 +31,7 @@ Larry Paulson James Reynolds Tom Ridge Peter Sewell +Thomas Sewell Konrad Slind Donald Syme Piotr Trojanek diff --git a/examples/machine-code/graph/GraphLangScript.sml b/examples/machine-code/graph/GraphLangScript.sml new file mode 100644 index 0000000000..b24f6cbf20 --- /dev/null +++ b/examples/machine-code/graph/GraphLangScript.sml @@ -0,0 +1,1919 @@ + +open HolKernel Parse boolLib bossLib; + +val _ = new_theory "GraphLang"; + +open wordsTheory wordsLib pairTheory listTheory relationTheory; +open pred_setTheory arithmeticTheory combinTheory; +open arm_decompTheory set_sepTheory progTheory addressTheory; +open m0_decompTheory lcsymtacs; + +infix \\ val op \\ = op THEN; + +val RW1 = ONCE_REWRITE_RULE; +val RW = REWRITE_RULE; + +val _ = Datatype `variable = + VarNone + | VarNat num + | VarWord8 word8 + | VarWord32 word32 + | VarMem (word32 -> word8) + | VarDom (word32 set) + | VarBool bool`; + +(* States are a mapping from names to the variable type, which is + a union of the available names. *) + +val _ = type_abbrev("state",``:string -> variable``); + +(* Accessors for grabbing variables by name and expected type. *) + +val var_acc_def = zDefine ` + var_acc nm (f:state) = f nm`; + +val var_nat_def = zDefine ` + var_nat nm st = case var_acc nm st of VarNat n => n | _ => 0`; + +val var_word8_def = zDefine ` + var_word8 nm st = case var_acc nm st of VarWord8 w => w | _ => 0w`; + +val var_word32_def = zDefine ` + var_word32 nm st = case var_acc nm st of VarWord32 w => w | _ => 0w`; + +val var_mem_def = zDefine ` + var_mem nm st = case var_acc nm st of VarMem m => m | _ => (\x. 0w)`; + +val var_dom_def = zDefine ` + var_dom nm st = case var_acc nm st of VarDom d => d | _ => {}`; + +val var_bool_def = zDefine ` + var_bool nm st = case var_acc nm st of VarBool b => b | _ => F`; + +(* The variable updator. *) + +val var_upd_def = zDefine ` + var_upd nm v f = ((nm =+ v) f)`; + +val _ = zDefine ` + default_state = (\x. VarNone)`; + +(* The type of nodes. *) + +val _ = Datatype `next_node = NextNode num | Ret | Err`; + +val _ = Datatype `node = + Basic next_node ((string # (state -> variable)) list) + | Cond next_node next_node (state -> bool) + | Call next_node string ((state -> variable) list) (string list)`; + +val _ = zDefine ` + Skip nn = Cond nn nn (\x. T)`; + +(* The type for a total graph function, including list of inputs, list + of outputs, graph, and entry point. *) + +val _ = Datatype `graph_function = + GraphFunction (string list) (string list) (num -> node option) num`; + +(* The definition of execution of a single node. *) + +val fold_def = zDefine ` + (fold f [] s = s) /\ + (fold f (x::xs) s = fold f xs (f x s))`; + +val save_vals_def = zDefine ` + save_vals vars vals st = + fold (\(var, val). var_upd var val) (ZIP (vars,vals)) st`; + +val init_vars_def = zDefine ` + init_vars vars accs st = + save_vals vars (MAP (\i. i st) accs) default_state`; + +val return_vars_def = zDefine ` + return_vars inner outer inner_st = + save_vals outer (MAP (\v. var_acc v inner_st) inner)`; + +val upd_vars_def = zDefine ` + upd_vars upds st = + save_vals (MAP FST upds) (MAP (\(nm, vf). vf st) upds) st`; + +val _ = type_abbrev("stack",``:(next_node # state # string) list``); + +val upd_stack_def = zDefine ` + (upd_stack nn stf (x :: xs) = (nn, stf (FST (SND x)), SND (SND x)) :: xs) /\ + (upd_stack nn stf [] = []:stack)`; + +val exec_node_def = zDefine ` + (exec_node Gamma st (Basic cont upds) stack = + {upd_stack cont (K (upd_vars upds st)) stack}) /\ + (exec_node Gamma st (Cond left right cond) stack = + {upd_stack (if cond st then left else right) I stack}) /\ + (exec_node Gamma st (Call cont fname inputs outputs) stack = + case Gamma fname of NONE => {upd_stack Err I stack} + | SOME (GraphFunction inps outps graph1 ep) => + {(NextNode ep, init_vars inps inputs st, fname) :: stack})`; + +val exec_node_return_def = zDefine ` + (exec_node_return _ _ (Basic _ _) stack = {}) /\ + (exec_node_return _ _ (Cond _ _ _) stack = {}) /\ + (exec_node_return Gamma st (Call cont fname inputs outputs) stack = + case Gamma fname of NONE => {} + | SOME (GraphFunction inps outps graph ep) => + {upd_stack cont (return_vars outps outputs st) stack})`; + +(* The single-step relation on graph states. *) + +val exec_graph_step_def = zDefine ` + exec_graph_step Gamma stack stack' = + case stack of + (NextNode nn, st, fname) :: _ => + (case Gamma fname of | NONE => F + | SOME (GraphFunction _ _ graph _) => + (case graph nn of NONE => (stack' = upd_stack Err I stack) + | SOME node => stack' IN exec_node Gamma st node stack)) + | (Ret, st, _) :: (NextNode nn, _, fname) :: _ => + (case Gamma fname of | NONE => F + | SOME (GraphFunction _ _ graph _) => + (case graph nn of NONE => (stack' = upd_stack Err I stack) + | SOME node => stack' IN exec_node_return Gamma st node (TL stack))) + | [] => F + | [_] => F + | _ => stack' = upd_stack Err I (TL stack)` + +(* Multi-step relations. *) + +val _ = zDefine ` + exec_graph Gamma = RTC (exec_graph_step Gamma)`; + +val exec_graph_n_def = zDefine ` + exec_graph_n Gamma n = NRC (exec_graph_step Gamma) n`; + + +(* more abstract representation of graph *) + +val _ = type_abbrev("update",``:(string # (state -> variable)) list``) +val _ = type_abbrev("assert",``:state->bool``) + +val _ = Datatype ` + jump = Jump word32 | Return` + +val _ = Datatype ` + next = IF assert next next (* if ... then ... else ... *) + | ASM (assert option) update jump + | CALL (assert option) update string jump`; + +val _ = Datatype ` + inst = Inst word32 assert next (* name, inv, what happens *)` + +val _ = Datatype ` + func = Func string word32 (inst list) (* name, entry point, insts *)`; + +(* execution *) + +val get_assert_def = Define ` + (get_assert NONE = \x.T) /\ + (get_assert (SOME a) = a)`; + +val apply_update_def = Define ` + (apply_update [] s = s) /\ + (apply_update ((x,y)::xs) s = (x =+ y s) (apply_update xs s))`; + +val check_jump_def = Define ` + (check_jump (Jump p) s w = (w = p)) /\ + (check_jump Return s w = (var_word32 "ret" s = w))`; + +val check_ret_def = Define ` + (check_ret (Jump p) s t = (var_word32 "ret" t = p)) /\ + (check_ret Return s t = (var_word32 "ret" t = var_word32 "ret" s))`; + +val exec_next_def = Define ` + (exec_next locs (IF guard n1 n2) s t w call = + if guard s then exec_next locs n1 s t w call + else exec_next locs n2 s t w call) /\ + (exec_next locs (ASM assert update jmp) s t w call = + get_assert assert s /\ + (apply_update update s = t) /\ + check_jump jmp t w /\ (call = NONE)) /\ + (exec_next locs (CALL assert update name jmp) s t w call = + get_assert assert s /\ + (apply_update update s = t) /\ + locs name <> NONE /\ + check_jump (Jump (THE (locs name))) t w /\ + check_ret jmp s t /\ (call = SOME name))` + +(* representation in ARM SPEC *) + +val arm_STATE_CPSR_def = Define ` + arm_STATE_CPSR s = + arm_CPSR_N (var_bool "n" s) * + arm_CPSR_Z (var_bool "z" s) * + arm_CPSR_C (var_bool "c" s) * + arm_CPSR_V (var_bool "v" s)`; + +val arm_STATE_REGS_def = Define ` + arm_STATE_REGS s = + arm_REG (R_mode (w2w (var_word8 "mode" s)) 0w) (var_word32 "r0" s) * + arm_REG (R_mode (w2w (var_word8 "mode" s)) 1w) (var_word32 "r1" s) * + arm_REG (R_mode (w2w (var_word8 "mode" s)) 2w) (var_word32 "r2" s) * + arm_REG (R_mode (w2w (var_word8 "mode" s)) 3w) (var_word32 "r3" s) * + arm_REG (R_mode (w2w (var_word8 "mode" s)) 4w) (var_word32 "r4" s) * + arm_REG (R_mode (w2w (var_word8 "mode" s)) 5w) (var_word32 "r5" s) * + arm_REG (R_mode (w2w (var_word8 "mode" s)) 6w) (var_word32 "r6" s) * + arm_REG (R_mode (w2w (var_word8 "mode" s)) 7w) (var_word32 "r7" s) * + arm_REG (R_mode (w2w (var_word8 "mode" s)) 8w) (var_word32 "r8" s) * + arm_REG (R_mode (w2w (var_word8 "mode" s)) 9w) (var_word32 "r9" s) * + arm_REG (R_mode (w2w (var_word8 "mode" s)) 10w) (var_word32 "r10" s) * + arm_REG (R_mode (w2w (var_word8 "mode" s)) 11w) (var_word32 "r11" s) * + arm_REG (R_mode (w2w (var_word8 "mode" s)) 12w) (var_word32 "r12" s) * + arm_REG (R_mode (w2w (var_word8 "mode" s)) 13w) (var_word32 "r13" s) * + arm_REG (R_mode (w2w (var_word8 "mode" s)) 14w) (var_word32 "r14" s)`; + +val arm_STACK_MEMORY_def = Define ` + arm_STACK_MEMORY = arm_MEMORY`; + +val arm_STATE_def = Define ` + arm_STATE s = + arm_STATE_REGS s * arm_STATE_CPSR s * + arm_OK (w2w (var_word8 "mode" s)) * + arm_MEMORY (var_dom "dom" s) (var_mem "mem" s) * + arm_STACK_MEMORY (var_dom "dom_stack" s) (var_mem "stack" s)`; + +val arm_STATE_thm = save_thm("arm_STATE_thm", + arm_STATE_def + |> REWRITE_RULE [arm_STATE_CPSR_def,arm_STATE_REGS_def,STAR_ASSOC] + |> SPEC_ALL); + +(* representation in M0 SPEC *) + +val m0_STATE_PSR_def = Define ` + m0_STATE_PSR s = + m0_PSR_N (var_bool "n" s) * + m0_PSR_Z (var_bool "z" s) * + m0_PSR_C (var_bool "c" s) * + m0_PSR_V (var_bool "v" s)`; + +val m0_STATE_REGS_def = Define ` + m0_STATE_REGS s = + m0_REG RName_0 (var_word32 "r0" s) * + m0_REG RName_1 (var_word32 "r1" s) * + m0_REG RName_2 (var_word32 "r2" s) * + m0_REG RName_3 (var_word32 "r3" s) * + m0_REG RName_4 (var_word32 "r4" s) * + m0_REG RName_5 (var_word32 "r5" s) * + m0_REG RName_6 (var_word32 "r6" s) * + m0_REG RName_7 (var_word32 "r7" s) * + m0_REG RName_8 (var_word32 "r8" s) * + m0_REG RName_9 (var_word32 "r9" s) * + m0_REG RName_10 (var_word32 "r10" s) * + m0_REG RName_11 (var_word32 "r11" s) * + m0_REG RName_12 (var_word32 "r12" s) * + m0_REG RName_SP_main (var_word32 "r13" s) * + m0_REG RName_LR (var_word32 "r14" s)`; + +val m0_STACK_MEMORY_def = Define ` + m0_STACK_MEMORY = m0_MEMORY`; + +val m0_STATE_def = Define ` + m0_STATE s = + m0_STATE_REGS s * m0_STATE_PSR s * + m0_CurrentMode Mode_Thread * + m0_MEMORY (var_dom "dom" s) (var_mem "mem" s) * + m0_STACK_MEMORY (var_dom "dom_stack" s) (var_mem "stack" s) * + m0_COUNT (var_nat "clock" s)`; + +val m0_STATE_thm = save_thm("m0_STATE_thm", + m0_STATE_def + |> REWRITE_RULE [m0_STATE_PSR_def,m0_STATE_REGS_def,STAR_ASSOC] + |> SPEC_ALL); + +(* misc *) + +val var_update_thm = store_thm("var_update_thm", + ``(var_dom n ((n1 =+ x) s) = + if n = n1 then (case x of VarDom y => y | _ => EMPTY) else + var_dom n s) /\ + (var_nat n ((n1 =+ x) s) = + if n = n1 then (case x of VarNat y => y | _ => 0) else + var_nat n s) /\ + (var_word8 n ((n1 =+ x) s) = + if n = n1 then (case x of VarWord8 y => y | _ => 0w) else + var_word8 n s) /\ + (var_word32 n ((n1 =+ x) s) = + if n = n1 then (case x of VarWord32 y => y | _ => 0w) else + var_word32 n s) /\ + (var_mem n ((n1 =+ x) s) = + if n = n1 then (case x of VarMem y => y | _ => \x. 0w) else + var_mem n s) /\ + (var_bool n ((n1 =+ x) s) = + if n = n1 then (case x of VarBool y => y | _ => F) else + var_bool n s)``, + SRW_TAC [] [var_dom_def,var_mem_def,var_bool_def,var_nat_def, + var_word8_def,var_word32_def,var_acc_def, + APPLY_UPDATE_THM]); + +val all_names_def = Define ` + all_names = + ["r0"; "r1"; "r2"; "r3"; "r4"; "r5"; "r6"; "r7"; "r8"; "r9"; + "r10"; "r11"; "r12"; "r13"; "r14"; "mode"; "n"; "z"; "c"; "v"; + "mem"; "dom"; "stack"; "dom_stack"; "clock"]`; + +val ret_and_all_names_def = Define ` + ret_and_all_names = "ret"::all_names ++ ["r0_input"]`; + +val all_names_ignore_def = Define ` + all_names_ignore = all_names ++ ["r0_input_ignore"]`; + +val all_names_with_input_def = Define ` + all_names_with_input = all_names ++ ["r0_input"]`; + +val LIST_SUBSET_def = Define ` + LIST_SUBSET xs ys = EVERY (\x. MEM x ys) xs`; + +val upd_ok_def = Define ` + upd_ok u = ALL_DISTINCT (MAP FST u) /\ + LIST_SUBSET (MAP FST u) all_names`; + +val jump_ok_def = Define ` + (jump_ok (Jump p) = EVEN (w2n p)) /\ + (jump_ok Return = T)`; + +val next_ok_def = Define ` + (next_ok (ASM s u l) = upd_ok u /\ jump_ok l) /\ + (next_ok (IF b n1 n2) = next_ok n1 /\ next_ok n2) /\ + (next_ok (CALL a u n j) = + (MAP FST u = ret_and_all_names) /\ jump_ok j /\ + !st. check_ret j st (apply_update u st))` + +val _ = Datatype `code = ARM ((word32 # word32) set) + | M0 ((word32 # (word16 + word32)) set)`; + +val IMPL_INST_def = Define ` + IMPL_INST code locs (Inst n assert next) = + next_ok next /\ EVEN (w2n n) /\ + !s t call w. + assert s /\ exec_next locs next s t w call ==> + case code of + | ARM arm_c => SPEC ARM_MODEL (arm_STATE s * arm_PC n) arm_c + (arm_STATE t * arm_PC w) + | M0 m0_c => SPEC M0_MODEL (m0_STATE s * m0_PC n) m0_c + (m0_STATE t * m0_PC w)`; + +val IMPL_INST_IF = store_thm("IMPL_INST_IF", + ``IMPL_INST code locs (Inst pc1 assert1 next1) /\ + IMPL_INST code locs (Inst pc1 assert2 next2) ==> + (!s. assert1 s ==> assert2 s) ==> + !guard. IMPL_INST code locs (Inst pc1 assert1 (IF guard next1 next2))``, + SIMP_TAC std_ss [IMPL_INST_def,exec_next_def,next_ok_def] \\ METIS_TAC []); + +val IMPL_INST_IF_ALT = store_thm("IMPL_INST_IF_ALT", + ``IMPL_INST code locs (Inst pc1 assert1 next1) /\ + IMPL_INST code locs (Inst pc1 assert2 next2) ==> + !guard. IMPL_INST code locs + (Inst pc1 (\s. if guard s then assert1 s else assert2 s) + (IF guard next1 next2))``, + SIMP_TAC std_ss [IMPL_INST_def,exec_next_def,next_ok_def] \\ METIS_TAC []); + +val IMPL_INST_SIMP_IF = store_thm("IMPL_INST_SIMP_IF", + ``IMPL_INST code locs + (Inst pc assert (IF guard (ASM (SOME s1) up1 j1) + (ASM (SOME s2) up2 j2))) <=> + IMPL_INST code locs + (Inst pc assert (IF guard (ASM (SOME (\s. guard s ==> s1 s)) up1 j1) + (ASM (SOME (\s. ~guard s ==> s2 s)) up2 j2)))``, + SIMP_TAC std_ss [IMPL_INST_def,exec_next_def,get_assert_def,next_ok_def]); + +val IMPL_INST_IF_RW = store_thm("IMPL_INST_IF_RW", + ``(IMPL_INST code locs + (Inst pc assert (IF guard (ASM (SOME (\s. T)) up1 j1) next)) <=> + IMPL_INST code locs + (Inst pc assert (IF guard (ASM NONE up1 j1) next))) /\ + (IMPL_INST code locs + (Inst pc assert (IF guard next (ASM (SOME (\s. T)) up1 j1))) <=> + IMPL_INST code locs + (Inst pc assert (IF guard next (ASM NONE up1 j1))))``, + SIMP_TAC std_ss [IMPL_INST_def,exec_next_def,get_assert_def,next_ok_def]); + +val IMPL_INST_IF_SPLIT = store_thm("IMPL_INST_IF_SPLIT", + ``IMPL_INST c locs (Inst n b (IF g (ASM x u (Jump j)) next)) <=> + IMPL_INST c locs (Inst n (\s. b s /\ g s) (ASM x u (Jump j))) /\ + IMPL_INST c locs (Inst n (\s. b s /\ ~(g s)) next)``, + SIMP_TAC std_ss [IMPL_INST_def,check_jump_def,exec_next_def,next_ok_def] + \\ METIS_TAC []); + +val IMPL_INST_IF_SIMP1 = store_thm("IMPL_INST_IF_SIMP1", + ``IMPL_INST c locs (Inst n (K T) (IF g next1 next2)) ==> + !a. (!s. a s ==> g s) ==> IMPL_INST c locs (Inst n a next1)``, + SIMP_TAC std_ss [IMPL_INST_def,check_jump_def,exec_next_def,next_ok_def] + \\ METIS_TAC []); + +val IMPL_INST_IF_SIMP2 = store_thm("IMPL_INST_IF_SIMP2", + ``IMPL_INST c locs (Inst n (K T) (IF g next1 next2)) ==> + !a. (!s. a s ==> ($~ o g) s) ==> IMPL_INST c locs (Inst n a next2)``, + SIMP_TAC std_ss [IMPL_INST_def,check_jump_def,exec_next_def,next_ok_def] + \\ METIS_TAC []); + +val IMPL_INST_SET_ASSUM = store_thm("IMPL_INST_SET_ASSUM", + ``IMPL_INST c locs (Inst n (K T) next) ==> + !a. IMPL_INST c locs (Inst n a next)``, + SIMP_TAC std_ss [IMPL_INST_def,check_jump_def,exec_next_def] + \\ METIS_TAC []); + +val IMPL_INST_IF_COMPOSE1 = store_thm("IMPL_INST_IF_COMPOSE1", + ``IMPL_INST c locs (Inst n b (IF g (ASM pre u1 (Jump w)) next)) /\ + IMPL_INST c locs (Inst w g (ASM NONE [] (Jump j))) ==> + (!s. g s ==> g (apply_update u1 s)) ==> + IMPL_INST c locs (Inst n b (IF g (ASM pre u1 (Jump j)) next))``, + Cases_on `c` + \\ SIMP_TAC (srw_ss()) [IMPL_INST_def,check_jump_def,exec_next_def,next_ok_def] + \\ REPEAT STRIP_TAC \\ REVERSE (Cases_on `g s`) + \\ FULL_SIMP_TAC std_ss [] + \\ TRY (Q.PAT_ASSUM `!s t cc. bbb` (MP_TAC o Q.SPECL [`s`,`t`,`call`,`w'`]) + \\ FULL_SIMP_TAC std_ss [] \\ NO_TAC) + \\ MATCH_MP_TAC (progTheory.SPEC_COMPOSE + |> Q.SPECL [`x`,`p`,`c`,`m`,`c`,`q`] + |> SIMP_RULE std_ss [UNION_IDEMPOT] |> GEN_ALL) + THEN1 (Q.EXISTS_TAC `arm_STATE t * arm_PC w` + \\ FULL_SIMP_TAC std_ss [apply_update_def] + \\ REPEAT STRIP_TAC \\ FIRST_X_ASSUM MATCH_MP_TAC + \\ FULL_SIMP_TAC std_ss [get_assert_def] \\ METIS_TAC []) + THEN1 (Q.EXISTS_TAC `m0_STATE t * m0_PC w` + \\ FULL_SIMP_TAC std_ss [apply_update_def] + \\ REPEAT STRIP_TAC \\ FIRST_X_ASSUM MATCH_MP_TAC + \\ FULL_SIMP_TAC std_ss [get_assert_def] \\ METIS_TAC [])); + +val IMPL_INST_IF_COMPOSE2 = store_thm("IMPL_INST_IF_COMPOSE2", + ``IMPL_INST c locs (Inst n b (IF g next (ASM pre u1 (Jump w)))) /\ + IMPL_INST c locs (Inst w ($~ o g) (ASM NONE [] (Jump j))) ==> + (!s. g (apply_update u1 s) <=> g s) ==> + IMPL_INST c locs (Inst n b (IF g next (ASM pre u1 (Jump j))))``, + Cases_on `c` + \\ SIMP_TAC (srw_ss()) [IMPL_INST_def,check_jump_def,exec_next_def,next_ok_def] + \\ REPEAT STRIP_TAC \\ Cases_on `g s` + \\ FULL_SIMP_TAC std_ss [] + \\ TRY (Q.PAT_ASSUM `!s t cc. bbb` (MP_TAC o Q.SPECL [`s`,`t`,`call`,`w'`]) + \\ FULL_SIMP_TAC std_ss [] \\ NO_TAC) + \\ MATCH_MP_TAC (progTheory.SPEC_COMPOSE + |> Q.SPECL [`x`,`p`,`c`,`m`,`c`,`q`] + |> SIMP_RULE std_ss [UNION_IDEMPOT] |> GEN_ALL) + THEN1 (Q.EXISTS_TAC `arm_STATE t * arm_PC w` + \\ FULL_SIMP_TAC std_ss [apply_update_def] + \\ REPEAT STRIP_TAC \\ FIRST_X_ASSUM MATCH_MP_TAC + \\ FULL_SIMP_TAC std_ss [get_assert_def] \\ METIS_TAC []) + THEN1 (Q.EXISTS_TAC `m0_STATE t * m0_PC w` + \\ FULL_SIMP_TAC std_ss [apply_update_def] + \\ REPEAT STRIP_TAC \\ FIRST_X_ASSUM MATCH_MP_TAC + \\ FULL_SIMP_TAC std_ss [get_assert_def] \\ METIS_TAC [])); + +val LESS_EQ_APPEND = store_thm("LESS_EQ_APPEND", + ``!xs n. n <= LENGTH xs ==> ?ys zs. (xs = ys ++ zs) /\ (LENGTH ys = n)``, + Induct \\ Cases_on `n` \\ FULL_SIMP_TAC (srw_ss()) [LENGTH_NIL] + \\ REPEAT STRIP_TAC \\ RES_TAC \\ METIS_TAC [LENGTH,APPEND]); + +val EL_LENGTH_APPEND = store_thm("EL_LENGTH_APPEND", + ``!n xs ys. (EL (LENGTH xs) (xs ++ ys) = EL 0 ys) /\ + (EL (LENGTH xs + n) (xs ++ ys) = EL n ys)``, + REPEAT STRIP_TAC \\ `LENGTH xs <= LENGTH xs + n` by DECIDE_TAC + \\ FULL_SIMP_TAC std_ss [rich_listTheory.EL_APPEND2]); + +val DROP_LENGTH_ADD_APPEND = store_thm("DROP_LENGTH_ADD_APPEND", + ``!xs n ys. DROP (LENGTH xs + n) (xs ++ ys) = DROP n ys``, + Induct \\ ASM_SIMP_TAC (srw_ss()) [LENGTH,ADD_CLAUSES]); + +val LUPDATE_LENGTH_ADD_APPEND = store_thm("LUPDATE_LENGTH_ADD_APPEND", + ``!xs x n ys. (LUPDATE x (LENGTH xs) (xs ++ ys) = xs ++ LUPDATE x 0 ys) /\ + (LUPDATE x (LENGTH xs + n) (xs ++ ys) = xs ++ LUPDATE x n ys)``, + Induct \\ ASM_SIMP_TAC (srw_ss()) [LENGTH,ADD_CLAUSES,LUPDATE_def]); + +val EL_LENGTH_REVERSE_APPEND = store_thm("EL_LENGTH_REVERSE_APPEND", + ``(EL (LENGTH xs + n) (REVERSE xs ++ ys) = EL n ys) /\ + (EL (LENGTH xs) (REVERSE xs ++ ys) = EL 0 ys)``, + ONCE_REWRITE_TAC [GSYM LENGTH_REVERSE] + \\ SIMP_TAC std_ss [EL_LENGTH_APPEND]); + +val arm_STATE_all_names = store_thm("arm_STATE_all_names", + ``EVERY (\n. s1 n = s2 n) all_names ==> + (arm_STATE s1 = arm_STATE s2)``, + SIMP_TAC std_ss [arm_STATE_thm,EVERY_DEF,all_names_def, + var_word8_def,var_dom_def,var_mem_def,var_nat_def, + var_word32_def,STAR_ASSOC,var_acc_def,var_bool_def]); + +val m0_STATE_all_names = store_thm("m0_STATE_all_names", + ``EVERY (\n. s1 n = s2 n) all_names ==> + (m0_STATE s1 = m0_STATE s2)``, + SIMP_TAC std_ss [m0_STATE_thm,EVERY_DEF,all_names_def, + var_word8_def,var_dom_def,var_mem_def,var_nat_def, + var_word32_def,STAR_ASSOC,var_acc_def,var_bool_def]); + +(* translation from my graph lang to Tom's *) + +val get_jump_def = Define ` + (get_jump (Jump j) = NextNode (w2n j)) /\ + (get_jump Return = Ret)`; + +val next_trans_def = Define ` + (next_trans n t (ASM NONE upd jump) = + (t, + [(n,Basic (get_jump jump) upd)])) /\ + (next_trans n t (ASM (SOME a) upd jump) = + (t+2, + [(n,Cond (NextNode t) Err a); + (t,Basic (get_jump jump) upd)])) /\ + (next_trans n t (IF guard n1 n2) = + let (t1,xs) = next_trans t (t+4) n1 in + let (t2,ys) = next_trans (t+2) t1 n2 in + (t2,[(n,Cond (NextNode t) (NextNode (t+2)) guard)] ++ xs ++ ys)) /\ + (next_trans n t (CALL a upd name r) = + (t+2, + [(n,Cond (NextNode t) Err (get_assert a)); + (t,Call (get_jump r) name (MAP SND upd) all_names_ignore)]))` + +val inst_trans_def = Define ` + inst_trans t (Inst l _ next) = next_trans (w2n l) t next`; + +val list_inst_trans_def = Define ` + (list_inst_trans t [] = []) /\ + (list_inst_trans t (x::xs) = + let (t1,ys) = inst_trans t x in + ys ++ list_inst_trans t1 xs)`; + +val graph_def = zDefine ` + (graph [] = K NONE) /\ + (graph ((x,y)::xs) = (x =+ SOME y) (graph xs))`; + +val func_trans_def = zDefine ` + func_trans (Func name entry l) = + (name,GraphFunction ret_and_all_names all_names_with_input + (graph (list_inst_trans 1 l)) (w2n entry))`; + +val list_func_trans_def = zDefine ` + list_func_trans fs = graph (MAP func_trans fs)`; + +(* condition decompiler has to prove *) + +val inst_loc_def = Define ` + inst_loc (Inst loc _ _) = w2n loc`; + +val fs_locs_def = Define ` + (fs_locs [] = K NONE) /\ + (fs_locs ((Func name entry l)::xs) = (name =+ SOME entry) (fs_locs xs))`; + +val func_ok_def = Define ` + func_ok code names (Func name entry l) = + ALL_DISTINCT (MAP inst_loc l) /\ EVEN (w2n entry) /\ + !i assert next. + MEM (Inst i assert next) l ==> + IMPL_INST code names (Inst i assert next) /\ (assert = K T)`; + +val funcs_ok_def = Define ` + funcs_ok code fs = EVERY (func_ok code (fs_locs fs)) fs`; + +(* proving a simulation result *) + +val find_inst_def = Define ` + (find_inst n [] = NONE) /\ + (find_inst n ((Inst l asrt next)::xs) = + if l = n then SOME (Inst l asrt next) else find_inst n xs)`; + +val find_func_def = Define ` + (find_func n [] = NONE) /\ + (find_func n ((Func name entry insts)::xs) = + if n = name then SOME (Func name entry insts) else find_func n xs)`; + +val good_stack_tail_def = Define ` + (good_stack_tail fs ([]:stack) = T) /\ + (good_stack_tail fs [x] = T) /\ + (good_stack_tail fs ((l1,s1,n1)::(l2,s2,n2)::xs) = + good_stack_tail fs ((l2,s2,n2)::xs) /\ + ?n x1 x2 g x3 ret y1 y2 y3. + (l2 = NextNode n) /\ + (list_func_trans fs n2 = SOME (GraphFunction x1 x2 g x3)) /\ + (g n = SOME (Call ret y1 y2 y3)) /\ + (case ret of + | NextNode i => (var_word32 "ret" s1 = n2w i) /\ EVEN i + | Ret => (var_word32 "ret" s1 = var_word32 "ret" s2) + | Err => F))` + +val good_stack_def = Define ` + good_stack fs stack = + good_stack_tail fs stack /\ + (case FST (HD stack) of + | Err => F + | NextNode n => EVEN n + | Ret => T)`; + +val NRC_Err = prove( + ``!n s st name s2. + NRC (exec_graph_step Gamma) n ((Err,st,name)::s) s2 ==> + ~(good_stack fs s2)``, + Induct \\ FULL_SIMP_TAC (srw_ss()) [good_stack_def,NRC,PULL_EXISTS] + \\ REPEAT STRIP_TAC \\ FIRST_X_ASSUM MATCH_MP_TAC + \\ Q.PAT_ASSUM `exec_graph_step Gamma ((Err,st,name)::s) z` MP_TAC + \\ SIMP_TAC (srw_ss()) [exec_graph_step_def,upd_stack_def] + \\ Cases_on `s` \\ FULL_SIMP_TAC (srw_ss()) [] + \\ REPEAT STRIP_TAC \\ FULL_SIMP_TAC std_ss [] + \\ PairCases_on `h` \\ FULL_SIMP_TAC (srw_ss()) [upd_stack_def] + \\ METIS_TAC []); + +val list_func_trans_EQ_SOME_IMP = prove( + ``!fs. + (list_func_trans fs name = SOME (GraphFunction x1 x2 graph1 x3)) ==> + ?entry l. (find_func name fs = SOME (Func name entry l)) /\ + (x1 = ret_and_all_names) /\ (x2 = all_names_with_input) /\ + (x3 = w2n entry) /\ + (graph1 = graph (list_inst_trans 1 l)) /\ + (fs_locs fs name = SOME (n2w x3))``, + Induct \\ FULL_SIMP_TAC std_ss [list_func_trans_def,MAP,graph_def] + \\ Cases_on `h` \\ FULL_SIMP_TAC (srw_ss()) [func_trans_def,graph_def,fs_locs_def] + \\ FULL_SIMP_TAC std_ss [APPLY_UPDATE_THM,find_func_def] + \\ STRIP_TAC \\ Cases_on `s = name` \\ FULL_SIMP_TAC (srw_ss()) [] + \\ SRW_TAC [] [] \\ FULL_SIMP_TAC std_ss [RW1[MULT_COMM]MULT_DIV,n2w_w2n]); + +val odd_nums_def = Define ` + (odd_nums k 0 = []) /\ + (odd_nums k (SUC n) = (k:num) :: odd_nums (k+2) n)`; + +val odd_nums_ADD = prove( + ``!m n k. odd_nums k (m + n) = odd_nums k m ++ odd_nums (k + 2 * m) n``, + Induct \\ FULL_SIMP_TAC std_ss [odd_nums_def,APPEND,ADD_CLAUSES, + MULT_CLAUSES,ADD_ASSOC]); + +val next_trans_IMP = prove( + ``!nn n k k1 xs. + ODD k /\ (next_trans n k nn = (k1,xs)) ==> + ?y ys. (xs = (n,y)::ys) /\ EVERY (ODD o FST) ys /\ ODD k1 /\ + PERM (MAP FST xs) (n :: odd_nums k (LENGTH (TL xs))) /\ + (k1 = k + 2 * (LENGTH (TL xs)))``, + REVERSE Induct + \\ SIMP_TAC (srw_ss()) [next_trans_def,LET_DEF,CONS_11,EVERY_DEF,ODD_ADD] + THEN1 (EVAL_TAC \\ SIMP_TAC std_ss []) + THEN1 (Cases_on `^(mk_var("o",``:assert option``))` + \\ EVAL_TAC \\ SIMP_TAC (srw_ss()) [] \\ EVAL_TAC \\ SRW_TAC [] [] + \\ FULL_SIMP_TAC std_ss [ODD_ADD]) + \\ REPEAT STRIP_TAC + \\ Cases_on `next_trans k (k + 4) nn` \\ FULL_SIMP_TAC std_ss [] + \\ Cases_on `next_trans (k + 2) q nn'` \\ FULL_SIMP_TAC std_ss [] + \\ `ODD (k + 4) /\ ODD (k + 2)` by FULL_SIMP_TAC (srw_ss()) [ODD_ADD] + \\ RES_TAC \\ RES_TAC + \\ REPEAT (Q.PAT_ASSUM `!xx.bb` (K ALL_TAC)) \\ REVERSE (SRW_TAC [] []) + \\ FULL_SIMP_TAC std_ss [odd_nums_def,CONS_11] + \\ FULL_SIMP_TAC std_ss [sortingTheory.PERM_CONS_IFF,MAP,TL] + THEN1 DECIDE_TAC + \\ FULL_SIMP_TAC std_ss [ADD_CLAUSES,odd_nums_def] + \\ MATCH_MP_TAC sortingTheory.APPEND_PERM_SYM + \\ FULL_SIMP_TAC std_ss [sortingTheory.PERM_CONS_IFF,MAP,TL,APPEND] + \\ FULL_SIMP_TAC std_ss [GSYM ADD_ASSOC] + \\ MATCH_MP_TAC sortingTheory.APPEND_PERM_SYM + \\ FULL_SIMP_TAC std_ss [odd_nums_ADD] + \\ MATCH_MP_TAC sortingTheory.PERM_CONG + \\ FULL_SIMP_TAC std_ss [ADD_ASSOC]); + +val next_trans_lemma = prove( + ``!nn n k k1 xs. + ODD k /\ (next_trans n k nn = (k1,xs)) ==> + ?y ys. (xs = (n,y)::ys) /\ EVERY (ODD o FST) ys /\ ODD k1``, + METIS_TAC [next_trans_IMP]); + +val graph_APPEND_ODD = prove( + ``!ys. + EVERY (ODD o FST) ys ==> + (graph (ys ++ xs) (2 * m) = graph xs (2 * m))``, + Induct \\ FULL_SIMP_TAC std_ss [APPEND,FORALL_PROD,EVERY_DEF,graph_def, + APPLY_UPDATE_THM] + \\ SRW_TAC [] [] \\ IMP_RES_TAC EVEN_ODD_EXISTS + \\ Q.MATCH_ASSUM_RENAME_TAC `2 * m = SUC (2 * n)` + \\ `(2 * m) MOD 2 = (SUC (2 * n)) MOD 2` by METIS_TAC [] + \\ POP_ASSUM MP_TAC + \\ ONCE_REWRITE_TAC [MULT_COMM] + \\ FULL_SIMP_TAC (srw_ss()) [MOD_MULT,ADD1] + \\ ONCE_REWRITE_TAC [DECIDE ``m * 2 = m * 2 + 0:num``] + \\ FULL_SIMP_TAC (srw_ss()) [MOD_MULT,ADD1]); + +val graph_list_inst_trans_EQ_SOME_IMP = prove( + ``!l k n x. + ODD k /\ EVEN n /\ n < 2**32 /\ + (graph (list_inst_trans k l) n = SOME x) ==> + ?a t. find_inst (n2w n) l = SOME (Inst (n2w n) a t)``, + Induct \\ FULL_SIMP_TAC std_ss [list_inst_trans_def,graph_def] + \\ Cases_on `h` \\ FULL_SIMP_TAC std_ss [inst_trans_def,find_inst_def] + \\ REPEAT STRIP_TAC + \\ Cases_on `next_trans (w2n c) k n` + \\ FULL_SIMP_TAC std_ss [LET_DEF] + \\ IMP_RES_TAC next_trans_lemma + \\ NTAC 2 (POP_ASSUM (K ALL_TAC)) + \\ SRW_TAC [] [] + \\ FULL_SIMP_TAC std_ss [APPEND,graph_def,APPLY_UPDATE_THM] + \\ Cases_on `c` \\ FULL_SIMP_TAC (srw_ss()) [] + \\ Q.MATCH_ASSUM_RENAME_TAC `n1 ≠ n2 MOD 4294967296` + \\ IMP_RES_TAC (EVEN_ODD_EXISTS |> SPEC_ALL |> CONJUNCT1) + \\ FIRST_X_ASSUM MATCH_MP_TAC + \\ Q.EXISTS_TAC `q` \\ FULL_SIMP_TAC std_ss [] + \\ NTAC 3 (POP_ASSUM MP_TAC) + \\ FULL_SIMP_TAC std_ss [graph_APPEND_ODD] + \\ REPEAT STRIP_TAC \\ FULL_SIMP_TAC std_ss []); + +val MEM_IMP_graph_SOME = prove( + ``!nodes i x. + MEM (i,x) nodes /\ ALL_DISTINCT (MAP FST nodes) ==> + (graph nodes i = SOME x)``, + Induct \\ FULL_SIMP_TAC (srw_ss()) [FORALL_PROD,MEM_MAP,graph_def] + \\ NTAC 3 STRIP_TAC \\ Cases_on `p_1 = i` \\ FULL_SIMP_TAC std_ss [] + \\ REPEAT STRIP_TAC \\ FULL_SIMP_TAC std_ss [APPLY_UPDATE_THM]); + +val exec_graph_step_NOT_ZERO = prove( + ``!s2. NRC (exec_graph_step (list_func_trans fs)) n + ((NextNode k,st,name)::t) s2 /\ ODD k /\ good_stack fs s2 ==> n <> 0``, + Cases_on `n` + \\ FULL_SIMP_TAC (srw_ss()) [ADD1,NRC,good_stack_def,EVERY_DEF] + \\ FULL_SIMP_TAC std_ss [EVEN_ODD] + \\ CCONTR_TAC \\ FULL_SIMP_TAC std_ss [] \\ FULL_SIMP_TAC std_ss []); + +val ZIP_MAP_MAP = prove( + ``!xs f g. ZIP (MAP f xs, MAP g xs) = MAP (\x. (f x, g x)) xs``, + Induct \\ SRW_TAC [] []); + +val NOT_MEM_IMP_fold_var_upd_ALT = prove( + ``!l st x y. + ~(MEM x (MAP FST l)) ==> + (fold (\(var,val). var_upd var val) l ((x =+ y) st) = + (x =+ y) (fold (\(var,val). var_upd var val) l st))``, + Induct \\ SRW_TAC [] [fold_def,var_upd_def] + \\ Cases_on `h` \\ FULL_SIMP_TAC (srw_ss()) [fold_def,var_upd_def] + \\ `((q =+ r) ((x =+ y) st)) = ((x =+ y) ((q =+ r) st))` + by METIS_TAC [UPDATE_COMMUTES] \\ METIS_TAC []); + +val NOT_MEM_IMP_fold_var_upd = prove( + ``!l st x y. + ~(MEM x (MAP FST l)) ==> + (fold (\(var,val). var_upd var val) (MAP (\(p1,p2). (p1,p2 st1)) l) + ((x =+ y st1) st) = + (x =+ y st1) + (fold (\(var,val). var_upd var val) (MAP (\(p1,p2). (p1,p2 st1)) l) st))``, + REPEAT STRIP_TAC \\ MATCH_MP_TAC NOT_MEM_IMP_fold_var_upd_ALT + \\ FULL_SIMP_TAC std_ss [MEM_MAP,FORALL_PROD]); + +val NOT_MEM_IMP_fold_var_upd_HO = prove( + ``!l st x y. + ~(MEM x (MAP FST l)) ==> + (fold (\(var,val). var_upd var (val t)) l ((x =+ y t) st) = + (x =+ y t) (fold (\(var,val). var_upd var (val t)) l st))``, + Induct \\ SRW_TAC [] [fold_def,var_upd_def] + \\ Cases_on `h` \\ FULL_SIMP_TAC (srw_ss()) [fold_def,var_upd_def] + \\ `((q =+ r t) ((x =+ y t) st)) = ((x =+ y t) ((q =+ r t) st))` + by METIS_TAC [UPDATE_COMMUTES] \\ METIS_TAC []); + +val upd_vars_thm = prove( + ``!l st. upd_ok l ==> (upd_vars l st = apply_update l st)``, + SIMP_TAC std_ss [upd_vars_def,save_vals_def,ZIP_MAP_MAP,LAMBDA_PROD] + \\ Induct + \\ FULL_SIMP_TAC std_ss [apply_update_def,FORALL_PROD,MAP,fold_def,var_upd_def] + \\ FULL_SIMP_TAC std_ss [upd_ok_def,ALL_DISTINCT,MAP] + \\ FULL_SIMP_TAC std_ss [NOT_MEM_IMP_fold_var_upd] + \\ REPEAT STRIP_TAC \\ AP_TERM_TAC + \\ FIRST_X_ASSUM MATCH_MP_TAC + \\ FULL_SIMP_TAC std_ss [LIST_SUBSET_def,EVERY_DEF]); + +val fold_MAP = prove( + ``!xs f g s. fold f (MAP g xs) s = fold (f o g) xs s``, + Induct \\ SRW_TAC [] [fold_def,MAP]); + +val fold_EQ_apply_update = prove( + ``!l s1 s2 n. + ALL_DISTINCT (MAP FST l) /\ MEM n (MAP FST l) ==> + (fold (\x. var_upd (FST x) (SND x st)) l s1 n = + apply_update l st n)``, + Induct \\ FULL_SIMP_TAC std_ss [MEM,MAP,ALL_DISTINCT] + \\ Cases \\ FULL_SIMP_TAC std_ss [fold_def,var_upd_def,LAMBDA_PROD] + \\ REPEAT STRIP_TAC + \\ FULL_SIMP_TAC std_ss [NOT_MEM_IMP_fold_var_upd_HO,apply_update_def] + \\ FULL_SIMP_TAC std_ss [APPLY_UPDATE_THM] + \\ METIS_TAC []); + +val upd_ok_IMP_var_word32_ret = prove( + ``!l. upd_ok l ==> + (var_word32 "ret" (apply_update l st) = var_word32 "ret" st)``, + Induct \\ FULL_SIMP_TAC std_ss [FORALL_PROD] + \\ FULL_SIMP_TAC std_ss [apply_update_def,upd_ok_def,MAP,LIST_SUBSET_def, + EVERY_DEF,ALL_DISTINCT,var_word32_def,var_acc_def, + APPLY_UPDATE_THM] + \\ `~MEM "ret" all_names` by ALL_TAC + THEN1 (SIMP_TAC std_ss [all_names_def] \\ EVAL_TAC) + \\ SRW_TAC [] []); + +val good_stack_tail_UPDATE = prove( + ``good_stack_tail fs ((i,st,name)::t) /\ upd_ok l ==> + good_stack_tail fs ((i,apply_update l st,name)::t)``, + Cases_on `t` \\ FULL_SIMP_TAC std_ss [good_stack_tail_def] + \\ PairCases_on `h` \\ FULL_SIMP_TAC std_ss [good_stack_tail_def] + \\ Cases_on `upd_ok l` \\ FULL_SIMP_TAC std_ss [] + \\ IMP_RES_TAC upd_ok_IMP_var_word32_ret \\ FULL_SIMP_TAC std_ss []); + +val good_stack_tail_STEP = prove( + ``good_stack_tail fs ((i,st,name)::t) ==> + !k. good_stack_tail fs ((k,st,name)::t)``, + Cases_on `t` \\ FULL_SIMP_TAC std_ss [good_stack_tail_def] + \\ PairCases_on `h` \\ FULL_SIMP_TAC std_ss [good_stack_tail_def]); + +val var_word32_fold_IGNORE = prove( + ``!t s st. + ~(MEM x (MAP FST t)) ==> + (var_word32 x + (fold (\(var,val). var_upd var val) (MAP (\x. (FST x,SND x st)) t) s) = + var_word32 x s)``, + Induct \\ FULL_SIMP_TAC std_ss [MAP,fold_def,MEM,MAP] + \\ FULL_SIMP_TAC std_ss [var_word32_def,var_upd_def,var_acc_def, + APPLY_UPDATE_THM]); + +val save_vals_lemma = prove( + ``(MAP FST l = ("ret"::all_names ++ ["r0_input"])) ==> + (var_word32 "ret" (save_vals ("ret"::all_names ++ ["r0_input"]) + (MAP (\i. i st) (MAP SND l)) s) = + var_word32 "ret" (apply_update l st))``, + Cases_on `l` \\ FULL_SIMP_TAC (srw_ss()) [MAP,save_vals_def,fold_def] + \\ FULL_SIMP_TAC std_ss [var_upd_def] \\ REPEAT STRIP_TAC + \\ POP_ASSUM (ASSUME_TAC o GSYM) + \\ FULL_SIMP_TAC std_ss [MAP_MAP_o,o_DEF,ZIP_MAP_MAP] + \\ `~(MEM "ret" (MAP FST t))` by ALL_TAC + THEN1 (POP_ASSUM (ASSUME_TAC o GSYM) + \\ FULL_SIMP_TAC std_ss [all_names_def] \\ EVAL_TAC) + \\ FULL_SIMP_TAC std_ss [var_word32_fold_IGNORE] \\ Cases_on `h` + \\ FULL_SIMP_TAC std_ss [apply_update_def,var_word32_def,var_acc_def, + APPLY_UPDATE_THM]); + +val find_func_IMP_EVEN = prove( + ``!fs s s entry l. + EVERY (func_ok code jjj) fs /\ + (find_func s fs = SOME (Func s entry l)) ==> + EVEN (w2n entry)``, + Induct \\ TRY (Cases_on `h`) \\ FULL_SIMP_TAC std_ss [find_func_def] + \\ REPEAT STRIP_TAC \\ Cases_on `s' = s` + \\ FULL_SIMP_TAC (srw_ss()) [funcs_ok_def,func_ok_def,fs_locs_def] + \\ RES_TAC) |> SPEC_ALL |> Q.INST [`jjj`|->`fs_locs fs`] + |> SIMP_RULE std_ss [GSYM funcs_ok_def]; + +val find_inst_IMP_LIST_SUBSET = prove( + ``!l k1. + i < 4294967296 /\ ALL_DISTINCT (MAP inst_loc l) /\ ODD k1 /\ + (find_inst (n2w i) l = SOME (Inst (n2w i) a next)) ==> + ?k2. ODD k2 /\ + (LIST_SUBSET (SND (next_trans i k2 next)) (list_inst_trans k1 l))``, + Induct \\ FULL_SIMP_TAC std_ss [find_inst_def] \\ Cases_on `h` + \\ FULL_SIMP_TAC std_ss [find_inst_def,inst_loc_def,MAP,ALL_DISTINCT] + \\ Cases_on `c = n2w i` \\ FULL_SIMP_TAC (srw_ss()) [] + \\ REPEAT STRIP_TAC THEN1 + (Q.EXISTS_TAC `k1` + \\ FULL_SIMP_TAC (srw_ss()) [LIST_SUBSET_def,EVERY_MEM,list_inst_trans_def, + inst_trans_def,w2n_n2w] \\ Cases_on `next_trans i k1 next` + \\ FULL_SIMP_TAC std_ss [LET_DEF,MEM_APPEND]) + \\ FULL_SIMP_TAC std_ss [] + \\ FULL_SIMP_TAC (srw_ss()) [LIST_SUBSET_def,EVERY_MEM,list_inst_trans_def, + inst_trans_def,w2n_n2w] + \\ Cases_on `next_trans (w2n (c:word32)) k1 n` + \\ FULL_SIMP_TAC std_ss [MEM_APPEND,LET_DEF] + \\ `ODD q` by IMP_RES_TAC next_trans_IMP + \\ METIS_TAC []) |> Q.SPECL [`l`,`1`] |> SIMP_RULE std_ss []; + +val NOT_MEM_odd_nums = prove( + ``!l k n. ODD k /\ EVEN n ==> ~(MEM n (odd_nums k l))``, + Induct \\ FULL_SIMP_TAC std_ss [odd_nums_def,MEM] + \\ REPEAT STRIP_TAC + \\ FULL_SIMP_TAC std_ss [ODD_EVEN] + \\ FULL_SIMP_TAC std_ss [ODD_EVEN] + \\ `~(EVEN (k+2))` by FULL_SIMP_TAC std_ss [EVEN_ADD] + \\ RES_TAC); + +val MEM_odd_nums = prove( + ``!l k i. MEM k (odd_nums i l) ==> i <= k``, + Induct \\ FULL_SIMP_TAC std_ss [odd_nums_def,MEM] + \\ REPEAT STRIP_TAC \\ RES_TAC \\ DECIDE_TAC); + +val ALL_DISTINCT_odd_nums = prove( + ``!l k. ALL_DISTINCT (odd_nums k l)``, + Induct \\ FULL_SIMP_TAC std_ss [odd_nums_def,ALL_DISTINCT] + \\ POP_ASSUM (K ALL_TAC) \\ REPEAT STRIP_TAC + \\ IMP_RES_TAC MEM_odd_nums \\ DECIDE_TAC); + +val EVEN_ODD_MEM_list_inst_trans = prove( + ``!l k. + EVERY (\i. EVEN (inst_loc i)) l /\ + MEM e (MAP FST (list_inst_trans k l)) /\ ODD k ==> + if EVEN e then MEM e (MAP inst_loc l) else k <= e``, + Induct \\ FULL_SIMP_TAC std_ss [list_inst_trans_def,MAP,MEM] + \\ REPEAT STRIP_TAC \\ Cases_on `inst_trans k h` \\ Cases_on `h` + \\ FULL_SIMP_TAC std_ss [LET_DEF,MEM,MAP_APPEND,inst_trans_def] + \\ FULL_SIMP_TAC std_ss [EVERY_DEF,inst_loc_def] + \\ Q.MATCH_ASSUM_RENAME_TAC `next_trans (w2n c) k nn = (k1,xs)` + \\ MP_TAC (next_trans_IMP |> Q.SPECL [`nn`,`w2n (c:word32)`] |> SPEC_ALL) + \\ FULL_SIMP_TAC std_ss [] \\ REPEAT STRIP_TAC + \\ FULL_SIMP_TAC std_ss [MEM_APPEND,MEM,MAP,inst_loc_def,TL] + THEN1 (Q.PAT_ASSUM `xs = yyy` ASSUME_TAC + \\ FULL_SIMP_TAC std_ss [TL,HD,MAP,sortingTheory.PERM_CONS_IFF] + \\ FULL_SIMP_TAC std_ss [EVERY_MEM,MEM_MAP] + \\ Cases_on `y'` \\ FULL_SIMP_TAC std_ss [] + \\ `ODD q` by (RES_TAC \\ FULL_SIMP_TAC std_ss []) + \\ ASM_SIMP_TAC std_ss [EVEN_ODD] + \\ IMP_RES_TAC sortingTheory.PERM_MEM_EQ + \\ FULL_SIMP_TAC std_ss [MEM_MAP,PULL_EXISTS,FORALL_PROD] + \\ RES_TAC \\ IMP_RES_TAC MEM_odd_nums) + \\ RES_TAC \\ FULL_SIMP_TAC std_ss [ODD_ADD,ODD_EVEN,EVEN_DOUBLE] + \\ RES_TAC \\ Cases_on `EVEN e` \\ FULL_SIMP_TAC std_ss [] + \\ DECIDE_TAC) + +val EVEN_MEM_list_inst_trans = prove( + ``EVERY (\i. EVEN (inst_loc i)) l /\ + MEM e (MAP FST (list_inst_trans k l)) /\ EVEN e /\ ODD k ==> + MEM e (MAP inst_loc l)``, + METIS_TAC [EVEN_ODD_MEM_list_inst_trans]) + +val ODD_MEM_list_inst_trans = prove( + ``EVERY (\i. EVEN (inst_loc i)) l /\ + MEM e (MAP FST (list_inst_trans k l)) /\ ODD e /\ ODD k ==> + k <= e``, + METIS_TAC [EVEN_ODD_MEM_list_inst_trans,EVEN_ODD]) + +val ODD_MEM_odd_nums = prove( + ``!l k i. MEM k (odd_nums i l) /\ ODD i ==> ODD k /\ k < i + 2 * l``, + Induct \\ FULL_SIMP_TAC std_ss [odd_nums_def,MEM] + \\ REPEAT STRIP_TAC \\ FULL_SIMP_TAC std_ss [] + \\ RES_TAC \\ FULL_SIMP_TAC std_ss [ODD_ADD] + \\ RES_TAC \\ DECIDE_TAC); + +val ALL_DISTINCT_list_inst_trans = prove( + ``!l k. EVERY (\i. EVEN (inst_loc i)) l /\ + ODD k /\ ALL_DISTINCT (MAP inst_loc l) ==> + ALL_DISTINCT (MAP FST (list_inst_trans k l))``, + Induct THEN1 (EVAL_TAC \\ SIMP_TAC std_ss []) + \\ FULL_SIMP_TAC std_ss [list_inst_trans_def,LET_DEF] + \\ REPEAT STRIP_TAC \\ Cases_on `inst_trans k h` + \\ FULL_SIMP_TAC std_ss [MAP_APPEND,ALL_DISTINCT_APPEND,MAP,ALL_DISTINCT] + \\ Cases_on `h` \\ FULL_SIMP_TAC std_ss [EVERY_DEF,inst_loc_def] + \\ FULL_SIMP_TAC std_ss [inst_trans_def] + \\ `ODD q` by IMP_RES_TAC next_trans_IMP + \\ FULL_SIMP_TAC std_ss [] + \\ MP_TAC (next_trans_IMP |> Q.SPECL [`n`,`w2n (c:word32)`,`k`,`q`,`r`]) + \\ FULL_SIMP_TAC std_ss [] \\ REPEAT STRIP_TAC + THEN1 (IMP_RES_TAC sortingTheory.ALL_DISTINCT_PERM + \\ FULL_SIMP_TAC std_ss [TL,ALL_DISTINCT,ALL_DISTINCT_odd_nums] + \\ MATCH_MP_TAC NOT_MEM_odd_nums + \\ FULL_SIMP_TAC std_ss [EVEN_DOUBLE]) + \\ IMP_RES_TAC sortingTheory.PERM_MEM_EQ + \\ FULL_SIMP_TAC std_ss [inst_loc_def,TL,MEM] + \\ FULL_SIMP_TAC std_ss [] + \\ SRW_TAC [] [] \\ FULL_SIMP_TAC std_ss [HD,TL] + \\ Q.PAT_ASSUM `~bbb` MP_TAC + \\ SIMP_TAC std_ss [] THEN1 + (MATCH_MP_TAC (EVEN_MEM_list_inst_trans |> GEN_ALL) + \\ Q.LIST_EXISTS_TAC [`(k + 2 * LENGTH ys)`] + \\ FULL_SIMP_TAC std_ss [EVEN_DOUBLE]) + \\ IMP_RES_TAC ODD_MEM_odd_nums + \\ IMP_RES_TAC ODD_MEM_list_inst_trans + \\ `F` by DECIDE_TAC); + +val find_func_IMP_MEM = prove( + ``!xs x y. (find_func x xs = SOME y) ==> MEM y xs``, + Induct \\ FULL_SIMP_TAC std_ss [find_func_def] \\ Cases + \\ SRW_TAC [] [find_func_def] \\ RES_TAC \\ FULL_SIMP_TAC std_ss []); + +val find_inst_IMP_MEM = prove( + ``!xs x y. (find_inst x xs = SOME y) ==> MEM y xs``, + Induct \\ FULL_SIMP_TAC std_ss [find_inst_def] \\ Cases + \\ SRW_TAC [] [find_inst_def] \\ RES_TAC \\ FULL_SIMP_TAC std_ss []); + +val graph_SOME_IMP = prove( + ``!xs n y. (graph xs n = SOME y) ==> MEM (n,y) xs``, + Induct \\ FULL_SIMP_TAC std_ss [graph_def,FORALL_PROD, + APPLY_UPDATE_THM,MEM] \\ SRW_TAC [] []); + +val graph_APPEND = prove( + ``!xs ys x. + graph (xs ++ ys) x = + case graph xs x of + | NONE => graph ys x + | y => y``, + Induct \\ FULL_SIMP_TAC std_ss [graph_def,APPEND, + FORALL_PROD,APPLY_UPDATE_THM] \\ SRW_TAC [] []); + +val list_inst_trans_IMP_LESS = prove( + ``!l k n x. + (graph (list_inst_trans k l) n = SOME x) /\ EVEN n /\ ODD k ==> + n < 2**32``, + Induct \\ FULL_SIMP_TAC std_ss [graph_def,FORALL_PROD, + APPLY_UPDATE_THM,MEM,list_inst_trans_def,LET_DEF] + \\ REPEAT STRIP_TAC \\ Cases_on `inst_trans k h` + \\ Cases_on `h` \\ FULL_SIMP_TAC std_ss [inst_trans_def] + \\ `ODD q` by IMP_RES_TAC next_trans_IMP + \\ FULL_SIMP_TAC std_ss [graph_APPEND] + \\ Cases_on `graph r n` \\ FULL_SIMP_TAC std_ss [] + \\ RES_TAC \\ FULL_SIMP_TAC std_ss [] + \\ IMP_RES_TAC graph_SOME_IMP + \\ IMP_RES_TAC next_trans_IMP + \\ FULL_SIMP_TAC std_ss [MEM] + \\ `w2n c < dimword(:32)` by METIS_TAC [w2n_lt] + \\ FULL_SIMP_TAC (srw_ss()) [] + \\ SRW_TAC [] [] \\ FULL_SIMP_TAC std_ss [EVERY_MEM,FORALL_PROD] + \\ RES_TAC \\ FULL_SIMP_TAC std_ss [EVEN_ODD]); + +val good_stack_tail_return_vars = prove( + ``good_stack_tail fs ((ret,st1,name1)::t) ==> + good_stack_tail fs ((ret,return_vars all_names_with_input + all_names_ignore st st1,name1)::t)``, + Cases_on `t` \\ FULL_SIMP_TAC std_ss [good_stack_tail_def] + \\ PairCases_on `h` \\ FULL_SIMP_TAC std_ss [good_stack_tail_def] + \\ `var_word32 "ret" (return_vars all_names_with_input all_names_ignore st st1) = + var_word32 "ret" st1` by ALL_TAC + \\ FULL_SIMP_TAC std_ss [] + \\ FULL_SIMP_TAC std_ss [var_word32_def,var_acc_def,return_vars_def, + save_vals_def,fold_def,var_upd_def,all_names_def] \\ EVAL_TAC + \\ FULL_SIMP_TAC std_ss [var_word32_def,var_acc_def,return_vars_def, + save_vals_def,fold_def,var_upd_def] \\ EVAL_TAC) + +val func_ok_EXPEND_CODE = store_thm("func_ok_EXPEND_CODE", + ``func_ok code locs f ==> + !c. (case (code,c) of + | (ARM c1, ARM c2) => c1 SUBSET c2 + | (M0 c1, M0 c2) => c1 SUBSET c2 + | _ => F) ==> + func_ok c locs f``, + Cases_on `f` \\ SIMP_TAC std_ss [func_ok_def,IMPL_INST_def] + \\ Cases_on `code` \\ FULL_SIMP_TAC (srw_ss()) [] + \\ REPEAT STRIP_TAC \\ Cases_on `c'` \\ FULL_SIMP_TAC (srw_ss()) [] + \\ RES_TAC \\ FULL_SIMP_TAC std_ss [] + \\ IMP_RES_TAC SPEC_SUBSET_CODE); + +val return_vars_SAME = prove( + ``!n. MEM n all_names ==> + (st n = return_vars all_names_with_input all_names_ignore st st1 n)``, + FULL_SIMP_TAC std_ss [GSYM EVERY_MEM] + \\ FULL_SIMP_TAC std_ss [all_names_def,EVERY_DEF,return_vars_def] + \\ FULL_SIMP_TAC std_ss [var_word32_def,var_acc_def,return_vars_def, + save_vals_def,fold_def,var_upd_def] \\ EVAL_TAC + \\ FULL_SIMP_TAC std_ss [var_word32_def,var_acc_def,return_vars_def, + save_vals_def,fold_def,var_upd_def] \\ EVAL_TAC) + +val MEM_CAll_next_trans = prove( + ``!n1 d k q r. MEM (n,Call x1 x2 x3 x4) r /\ (next_trans d k n1 = (q,r)) ==> + (x4 = all_names_ignore)``, + Induct \\ FULL_SIMP_TAC (srw_ss()) [next_trans_def,MEM] + \\ REPEAT STRIP_TAC + \\ TRY (Cases_on `o'` \\ FULL_SIMP_TAC (srw_ss()) [next_trans_def]) + \\ Cases_on `next_trans k (k + 4) n1` \\ FULL_SIMP_TAC std_ss [LET_DEF] + \\ Cases_on `next_trans (k + 2) q' n1'` \\ FULL_SIMP_TAC std_ss [LET_DEF] + \\ SRW_TAC [] [] \\ FULL_SIMP_TAC (srw_ss()) [MEM,MEM_APPEND] \\ RES_TAC); + +val MEM_Call_list_inst_trans = prove( + ``!l k. MEM (n,Call x1 x2 x3 x4) (list_inst_trans k l) ==> + (x4 = all_names_ignore)``, + Induct \\ FULL_SIMP_TAC std_ss [list_inst_trans_def,MEM] + \\ REPEAT STRIP_TAC \\ Cases_on `inst_trans k h` + \\ FULL_SIMP_TAC std_ss [LET_DEF,MEM_APPEND] \\ RES_TAC + \\ Cases_on `h` \\ FULL_SIMP_TAC std_ss [inst_trans_def] + \\ IMP_RES_TAC MEM_CAll_next_trans); + +val arm_assert_for_def = Define ` + (arm_assert_for ([]:stack) = SEP_F) /\ + (arm_assert_for ((loc,state,name)::rest) = + arm_STATE state * arm_PC (case loc of NextNode n => n2w n + | _ => var_word32 "ret" state))`; + +val m0_assert_for_def = Define ` + (m0_assert_for ([]:stack) = SEP_F) /\ + (m0_assert_for ((loc,state,name)::rest) = + m0_STATE state * m0_PC (case loc of NextNode n => n2w n + | _ => var_word32 "ret" state))`; + +fun exec_graph_step_IMP_exec_next arch = let + val (assert_for_def,code,tm) = + if arch = "arm" then + (arm_assert_for_def,``ARM code``, + ``arm_assert_for s4 = arm_STATE s7 * arm_PC w``) else + if arch = "m0" then + (m0_assert_for_def,``M0 code``, + ``m0_assert_for s4 = m0_STATE s7 * m0_PC w``) else fail() + in prove( + ``!next i k n. + NRC (exec_graph_step (list_func_trans fs)) n + ((NextNode i,st,name)::t) s2 /\ n <> 0 /\ funcs_ok ^code fs /\ + (list_func_trans fs name = SOME (GraphFunction x1 x2 (graph nodes) x3)) /\ + ODD k /\ LIST_SUBSET (SND (next_trans i k next)) nodes /\ + ALL_DISTINCT (MAP FST nodes) /\ next_ok next /\ + good_stack_tail fs ((NextNode i,st,name)::t) /\ good_stack fs s2 ==> + ?s4 s7 j j1 call w. + exec_next (fs_locs fs) next st s7 w call /\ + ^tm /\ + good_stack fs s4 /\ + NRC (exec_graph_step (list_func_trans fs)) j + ((NextNode i,st,name)::t) s4 /\ j1 < n /\ + NRC (exec_graph_step (list_func_trans fs)) j1 s4 s2``, + Induct \\ NTAC 4 STRIP_TAC + THEN1 (* IF *) + (Cases_on `n` \\ FULL_SIMP_TAC std_ss [NRC] \\ REPEAT STRIP_TAC + \\ Q.PAT_ASSUM `exec_graph_step (list_func_trans fs) + ((NextNode i,st,name)::t) z` MP_TAC + \\ ASM_SIMP_TAC (srw_ss()) [Once exec_graph_step_def] + \\ FULL_SIMP_TAC std_ss [next_trans_def] + \\ Cases_on `next_trans k (k + 4) next` \\ FULL_SIMP_TAC (srw_ss()) [] + \\ Q.MATCH_ASSUM_RENAME_TAC `next_trans k (k + 4) next1 = (t1,xs)` + \\ Cases_on `next_trans (k+2) t1 next'` \\ FULL_SIMP_TAC (srw_ss()) [] + \\ Q.MATCH_ASSUM_RENAME_TAC `next_trans (k+2) t1 next2 = (t2,ys)` + \\ FULL_SIMP_TAC std_ss [LIST_SUBSET_def,EVERY_DEF,LET_DEF] + \\ IMP_RES_TAC MEM_IMP_graph_SOME + \\ FULL_SIMP_TAC std_ss [] + \\ SIMP_TAC (srw_ss()) [exec_node_def,exec_next_def,upd_stack_def] + \\ Cases_on `f st` \\ FULL_SIMP_TAC std_ss [next_ok_def] + THEN1 (SRW_TAC [] [] \\ Q.PAT_ASSUM `!xx.bbb` (K ALL_TAC) + \\ Q.PAT_ASSUM `!xx.bbb` (MP_TAC o Q.SPECL [`k`,`k+4`,`n'`]) + \\ `n' <> 0` by ALL_TAC THEN1 (IMP_RES_TAC exec_graph_step_NOT_ZERO) + \\ FULL_SIMP_TAC std_ss [ODD_ADD,EVERY_APPEND] + \\ STRIP_TAC \\ FULL_SIMP_TAC std_ss [] + \\ IMP_RES_TAC good_stack_tail_STEP \\ FULL_SIMP_TAC std_ss [] + \\ Q.LIST_EXISTS_TAC [`s4`,`s7`,`SUC j`,`j1`,`call`,`w`] + \\ FULL_SIMP_TAC std_ss [] + \\ REVERSE STRIP_TAC THEN1 DECIDE_TAC + \\ REWRITE_TAC [NRC] + \\ FULL_SIMP_TAC (srw_ss()) [exec_graph_step_def,exec_node_def,upd_stack_def]) + THEN1 (SRW_TAC [] [] + \\ Q.PAT_ASSUM `!xx.bbb` (MP_TAC o Q.SPECL [`k+2`,`t1`,`n'`]) + \\ `ODD (k+2) /\ ODD (k+4)` by FULL_SIMP_TAC std_ss [ODD_ADD] + \\ `n' <> 0` by ALL_TAC THEN1 (IMP_RES_TAC exec_graph_step_NOT_ZERO) + \\ `ODD t1` by METIS_TAC [next_trans_lemma] + \\ FULL_SIMP_TAC std_ss [ODD_ADD,EVERY_APPEND] + \\ STRIP_TAC \\ FULL_SIMP_TAC std_ss [] + \\ IMP_RES_TAC good_stack_tail_STEP \\ FULL_SIMP_TAC std_ss [] + \\ Q.LIST_EXISTS_TAC [`s4`,`s7`,`SUC j`,`j1`,`call`,`w`] + \\ FULL_SIMP_TAC std_ss [] + \\ REVERSE STRIP_TAC THEN1 DECIDE_TAC + \\ REWRITE_TAC [NRC] + \\ FULL_SIMP_TAC (srw_ss()) [exec_graph_step_def,exec_node_def,upd_stack_def])) + THEN1 (* ASM *) + (Cases_on `^(mk_var("o'",``:assert option``))` THEN1 + (Cases_on `n` \\ FULL_SIMP_TAC std_ss [NRC] \\ REPEAT STRIP_TAC + \\ Q.PAT_ASSUM `exec_graph_step (list_func_trans fs) + ((NextNode i,st,name)::t) z` MP_TAC + \\ ASM_SIMP_TAC (srw_ss()) [Once exec_graph_step_def] + \\ FULL_SIMP_TAC std_ss [next_trans_def] + \\ FULL_SIMP_TAC std_ss [LIST_SUBSET_def,EVERY_DEF] + \\ IMP_RES_TAC MEM_IMP_graph_SOME + \\ FULL_SIMP_TAC std_ss [] + \\ SIMP_TAC (srw_ss()) [exec_node_def] + \\ FULL_SIMP_TAC std_ss [upd_stack_def] + \\ REPEAT STRIP_TAC \\ FULL_SIMP_TAC std_ss [] + \\ FULL_SIMP_TAC std_ss [exec_next_def] + \\ Q.LIST_EXISTS_TAC [`z`,`SUC 0`,`n'`] + \\ FULL_SIMP_TAC std_ss [assert_for_def,upd_vars_thm,next_ok_def] + \\ FULL_SIMP_TAC std_ss [get_assert_def] + \\ Q.EXISTS_TAC `(case get_jump j of + NextNode n => n2w n + | Ret => var_word32 "ret" (apply_update l st) + | Err => var_word32 "ret" (apply_update l st))` + \\ FULL_SIMP_TAC std_ss [] + \\ REVERSE (REPEAT STRIP_TAC) + THEN1 (REWRITE_TAC [NRC,DECIDE ``1 = SUC 0``] + \\ FULL_SIMP_TAC (srw_ss()) [exec_graph_step_def,exec_node_def,upd_stack_def] + \\ FULL_SIMP_TAC std_ss [upd_vars_thm]) + THEN1 (Cases_on `j` + \\ FULL_SIMP_TAC (srw_ss()) [get_jump_def,good_stack_def,EVERY_DEF] + \\ FULL_SIMP_TAC std_ss [EVEN_DOUBLE,jump_ok_def] + \\ MATCH_MP_TAC good_stack_tail_UPDATE + \\ IMP_RES_TAC good_stack_tail_STEP + \\ FULL_SIMP_TAC std_ss []) + \\ Cases_on `j` + \\ FULL_SIMP_TAC (srw_ss()) [check_jump_def,get_jump_def]) + \\ Cases_on `n` \\ FULL_SIMP_TAC std_ss [NRC] \\ REPEAT STRIP_TAC + \\ Q.PAT_ASSUM `exec_graph_step (list_func_trans fs) + ((NextNode i,st,name)::t) z` MP_TAC + \\ ASM_SIMP_TAC (srw_ss()) [Once exec_graph_step_def] + \\ FULL_SIMP_TAC std_ss [next_trans_def] + \\ FULL_SIMP_TAC std_ss [LIST_SUBSET_def,EVERY_DEF] + \\ IMP_RES_TAC MEM_IMP_graph_SOME + \\ FULL_SIMP_TAC std_ss [] + \\ SIMP_TAC (srw_ss()) [exec_node_def,get_assert_def] + \\ FULL_SIMP_TAC std_ss [upd_stack_def] + \\ REPEAT STRIP_TAC \\ FULL_SIMP_TAC std_ss [next_ok_def] + \\ Cases_on `x st` \\ FULL_SIMP_TAC std_ss [] + \\ IMP_RES_TAC NRC_Err + \\ Q.MATCH_ASSUM_RENAME_TAC `SUC n1 <> 0` + \\ `n1 <> 0` by ALL_TAC THEN1 (IMP_RES_TAC exec_graph_step_NOT_ZERO) + \\ Cases_on `n1` \\ FULL_SIMP_TAC std_ss [NRC] + \\ Q.PAT_ASSUM `exec_graph_step (list_func_trans fs) + ((NextNode i,st,name)::t) z` MP_TAC + \\ ASM_SIMP_TAC (srw_ss()) [Once exec_graph_step_def] + \\ SIMP_TAC (srw_ss()) [exec_node_def,upd_stack_def] + \\ REPEAT STRIP_TAC \\ FULL_SIMP_TAC std_ss [exec_next_def] + \\ Q.LIST_EXISTS_TAC [`z'`,`SUC (SUC 0)`,`n`] + \\ FULL_SIMP_TAC std_ss [assert_for_def,upd_vars_thm,next_ok_def,get_assert_def] + \\ FULL_SIMP_TAC std_ss [] + \\ Q.EXISTS_TAC `(case get_jump j of + NextNode n => n2w n + | Ret => var_word32 "ret" (apply_update l st) + | Err => var_word32 "ret" (apply_update l st))` + \\ FULL_SIMP_TAC std_ss [] + \\ REVERSE (REPEAT STRIP_TAC) THEN1 DECIDE_TAC + THEN1 (REWRITE_TAC [NRC,DECIDE ``2 = SUC (SUC 0)``] + \\ FULL_SIMP_TAC (srw_ss()) [exec_graph_step_def,exec_node_def,upd_stack_def] + \\ FULL_SIMP_TAC std_ss [upd_vars_thm]) + THEN1 (Cases_on `j` + \\ FULL_SIMP_TAC (srw_ss()) [get_jump_def,good_stack_def,EVERY_DEF] + \\ FULL_SIMP_TAC std_ss [EVEN_DOUBLE,jump_ok_def] + \\ MATCH_MP_TAC good_stack_tail_UPDATE + \\ IMP_RES_TAC good_stack_tail_STEP + \\ FULL_SIMP_TAC std_ss []) + \\ Cases_on `j` + \\ FULL_SIMP_TAC (srw_ss()) [check_jump_def,get_jump_def]) + THEN (* CALL *) Cases_on `n` \\ FULL_SIMP_TAC std_ss [NRC] \\ REPEAT STRIP_TAC + \\ Q.PAT_ASSUM `exec_graph_step (list_func_trans fs) + ((NextNode i,st,name)::t) z` MP_TAC + \\ ASM_SIMP_TAC (srw_ss()) [Once exec_graph_step_def] + \\ FULL_SIMP_TAC std_ss [next_trans_def] + \\ FULL_SIMP_TAC std_ss [LIST_SUBSET_def,EVERY_DEF] + \\ IMP_RES_TAC MEM_IMP_graph_SOME + \\ FULL_SIMP_TAC std_ss [] + \\ SIMP_TAC (srw_ss()) [exec_node_def] + \\ REVERSE (Cases_on `get_assert o' st`) + \\ FULL_SIMP_TAC std_ss [upd_stack_def] + \\ REPEAT STRIP_TAC \\ FULL_SIMP_TAC std_ss [] + \\ IMP_RES_TAC NRC_Err + \\ Q.MATCH_ASSUM_RENAME_TAC `SUC n1 <> 0` + \\ `n1 <> 0` by ALL_TAC THEN1 (IMP_RES_TAC exec_graph_step_NOT_ZERO) + \\ Cases_on `n1` \\ FULL_SIMP_TAC std_ss [NRC] + \\ Q.PAT_ASSUM `exec_graph_step (list_func_trans fs) + ((NextNode i,st,name)::t) z` MP_TAC + \\ ASM_SIMP_TAC (srw_ss()) [Once exec_graph_step_def] + \\ SIMP_TAC (srw_ss()) [exec_node_def,upd_stack_def] + \\ REPEAT STRIP_TAC \\ FULL_SIMP_TAC std_ss [exec_next_def] + \\ Cases_on `list_func_trans fs s` \\ FULL_SIMP_TAC std_ss [] + \\ REPEAT STRIP_TAC \\ FULL_SIMP_TAC (srw_ss()) [] + \\ IMP_RES_TAC NRC_Err + \\ Q.ABBREV_TAC `n' = n` \\ POP_ASSUM (K ALL_TAC) + \\ Cases_on `x` \\ FULL_SIMP_TAC (srw_ss()) [init_vars_def] + \\ Q.MATCH_ASSUM_RENAME_TAC + `list_func_trans fs s = SOME (GraphFunction inp out f n)` + \\ `inp = ret_and_all_names` by ALL_TAC + THEN1 (IMP_RES_TAC list_func_trans_EQ_SOME_IMP) + \\ `fs_locs fs s = SOME (n2w n)` by ALL_TAC + THEN1 (IMP_RES_TAC list_func_trans_EQ_SOME_IMP) + \\ FULL_SIMP_TAC std_ss [check_jump_def] + \\ Q.LIST_EXISTS_TAC [`z'`,`SUC (SUC 0)`,`n'`] + \\ REVERSE (REPEAT STRIP_TAC) \\ FULL_SIMP_TAC std_ss [] + THEN1 DECIDE_TAC + THEN1 (REWRITE_TAC [NRC,DECIDE ``2 = SUC (SUC 0)``] + \\ FULL_SIMP_TAC (srw_ss()) [exec_graph_step_def,exec_node_def, + upd_stack_def] \\ FULL_SIMP_TAC std_ss [init_vars_def,MAP]) + THEN1 + (ASM_SIMP_TAC (srw_ss()) [next_ok_def,good_stack_def,HD,FST] + \\ IMP_RES_TAC good_stack_tail_STEP + \\ ASM_SIMP_TAC (srw_ss()) [good_stack_tail_def] + \\ `EVEN n` by ALL_TAC THEN1 + (IMP_RES_TAC list_func_trans_EQ_SOME_IMP + \\ FULL_SIMP_TAC std_ss [EVEN_DOUBLE,jump_ok_def] + \\ IMP_RES_TAC find_func_IMP_EVEN) + \\ FULL_SIMP_TAC std_ss [next_ok_def] + \\ Cases_on `j` + \\ FULL_SIMP_TAC (srw_ss()) [get_jump_def,check_ret_def,EVEN_DOUBLE] + \\ FULL_SIMP_TAC std_ss [RW1[MULT_COMM]MULT_DIV,n2w_w2n] + \\ FULL_SIMP_TAC std_ss [ret_and_all_names_def] + \\ FULL_SIMP_TAC std_ss [save_vals_lemma,jump_ok_def]) + THEN1 (FULL_SIMP_TAC (srw_ss()) [assert_for_def] + \\ AP_THM_TAC \\ AP_TERM_TAC + \\ TRY (MATCH_MP_TAC arm_STATE_all_names) + \\ TRY (MATCH_MP_TAC m0_STATE_all_names) + \\ FULL_SIMP_TAC std_ss [EVERY_MEM,MAP_MAP_o,o_DEF] + \\ FULL_SIMP_TAC std_ss [next_ok_def] + \\ Q.PAT_ASSUM `MAP FST l = ret_and_all_names` (ASSUME_TAC o GSYM) + \\ FULL_SIMP_TAC std_ss [save_vals_def,ZIP_MAP_MAP,fold_MAP] + \\ FULL_SIMP_TAC std_ss [EVERY_MEM,MAP_MAP_o,o_DEF] + \\ POP_ASSUM (ASSUME_TAC o GSYM) + \\ REPEAT STRIP_TAC + \\ MATCH_MP_TAC fold_EQ_apply_update + \\ FULL_SIMP_TAC std_ss [] + \\ FULL_SIMP_TAC std_ss [ret_and_all_names_def] + \\ FULL_SIMP_TAC std_ss [MEM,all_names_def] \\ EVAL_TAC) + \\ FULL_SIMP_TAC std_ss [next_ok_def]) end; + +fun exec_inst_progress arch = let + val lemma = exec_graph_step_IMP_exec_next arch + val (assert_for_def,code,tm) = + if arch = "arm" then + (arm_assert_for_def,``ARM code``, + ``SPEC ARM_MODEL (arm_assert_for ((NextNode i,st,name)::t)) code + (arm_assert_for s4)``) else + if arch = "m0" then + (m0_assert_for_def,``M0 code``, + ``SPEC M0_MODEL (m0_assert_for ((NextNode i,st,name)::t)) code + (m0_assert_for s4)``) else fail() + in prove( + ``NRC (exec_graph_step (list_func_trans fs)) n + ((NextNode i,st,name)::t) s2 /\ funcs_ok ^code fs /\ + (find_func name fs = SOME (Func name entry l)) /\ + (find_inst (n2w i) l = SOME (Inst (n2w i) a next)) /\ + (list_func_trans fs name = + SOME (GraphFunction x1 x2 (graph nodes) x3)) /\ ODD k /\ + LIST_SUBSET (SND (next_trans i k next)) nodes /\ + ALL_DISTINCT (MAP FST nodes) /\ + IMPL_INST ^code (fs_locs fs) (Inst (n2w i) (K T) next) /\ + n <> 0 /\ good_stack fs ((NextNode i,st,name)::t) /\ good_stack fs s2 ==> + ?s4 j j1. + NRC (exec_graph_step (list_func_trans fs)) j + ((NextNode i,st,name)::t) s4 /\ + NRC (exec_graph_step (list_func_trans fs)) j1 s4 s2 /\ j1 < n /\ + good_stack fs s4 /\ ^tm``, + SIMP_TAC (srw_ss()) [IMPL_INST_def] \\ REPEAT STRIP_TAC + \\ FULL_SIMP_TAC (srw_ss()) [assert_for_def] + \\ FULL_SIMP_TAC std_ss [RW1[MULT_COMM]MULT_DIV] + \\ MP_TAC (lemma |> SPEC_ALL) + \\ FULL_SIMP_TAC std_ss [] + \\ FULL_SIMP_TAC std_ss [good_stack_def] + \\ REPEAT STRIP_TAC \\ RES_TAC + \\ Q.LIST_EXISTS_TAC [`s4`,`j`,`j1`] \\ FULL_SIMP_TAC std_ss []) end; + +fun exec_func_step_IMP arch = let + val lemma = exec_inst_progress arch + val (assert_for_def,code,assert_for_tm,model_tm) = + if arch = "arm" then + (arm_assert_for_def,``ARM code``,``arm_assert_for``,``ARM_MODEL``) else + if arch = "m0" then + (m0_assert_for_def,``M0 code``,``m0_assert_for``,``M0_MODEL``) else + fail() + in prove( + ``funcs_ok ^code fs ==> + !n s1 s2. + good_stack fs s1 /\ good_stack fs s2 /\ + exec_graph_n (list_func_trans fs) n s1 s2 ==> + SPEC ^model_tm (^assert_for_tm s1) code (^assert_for_tm s2)``, + STRIP_TAC + \\ completeInduct_on `n` \\ Cases_on `n = 0` + \\ FULL_SIMP_TAC std_ss [exec_graph_n_def,NRC,SPEC_REFL] + \\ REPEAT STRIP_TAC + \\ `?s3. NRC (exec_graph_step (list_func_trans fs)) (n-1) s3 s2 /\ + exec_graph_step (list_func_trans fs) s1 s3` by + (Cases_on `n` \\ FULL_SIMP_TAC std_ss [exec_graph_n_def,NRC] \\ METIS_TAC []) + \\ POP_ASSUM MP_TAC + \\ SIMP_TAC (srw_ss()) [exec_graph_step_def] + \\ Cases_on `s1` \\ FULL_SIMP_TAC (srw_ss()) [] + \\ `?l st name. h = (l,st,name)` by METIS_TAC [PAIR] + \\ REVERSE (Cases_on `l`) \\ FULL_SIMP_TAC (srw_ss()) [] + THEN1 (FULL_SIMP_TAC (srw_ss()) [good_stack_def,EVERY_DEF]) + THEN1 + (Cases_on `t` \\ FULL_SIMP_TAC (srw_ss()) [] + \\ `?l1 st1 name1. h' = (l1,st1,name1)` by METIS_TAC [PAIR] + \\ FULL_SIMP_TAC (srw_ss()) [upd_stack_def] + \\ REVERSE (Cases_on `l1`) \\ FULL_SIMP_TAC (srw_ss()) [] + \\ REPEAT STRIP_TAC \\ FULL_SIMP_TAC std_ss [] + THEN1 IMP_RES_TAC NRC_Err THEN1 IMP_RES_TAC NRC_Err + \\ Cases_on `list_func_trans fs name1` \\ FULL_SIMP_TAC (srw_ss()) [] + \\ Cases_on `x` \\ FULL_SIMP_TAC (srw_ss()) [] + \\ Q.MATCH_ASSUM_RENAME_TAC `list_func_trans fs name1 = + SOME (GraphFunction x1 x2 graph1 x3)` + \\ Cases_on `graph1 n'` \\ FULL_SIMP_TAC (srw_ss()) [] + THEN1 (REPEAT STRIP_TAC \\ FULL_SIMP_TAC std_ss [upd_stack_def] + \\ IMP_RES_TAC NRC_Err) + \\ Cases_on `x` \\ FULL_SIMP_TAC (srw_ss()) [exec_node_return_def] + \\ Cases_on `list_func_trans fs s` \\ FULL_SIMP_TAC (srw_ss()) [] + \\ Cases_on `x` \\ FULL_SIMP_TAC (srw_ss()) [exec_node_return_def] + \\ FULL_SIMP_TAC std_ss [upd_stack_def] + \\ CONV_TAC ((RATOR_CONV o RAND_CONV) (ONCE_REWRITE_CONV [GSYM UNION_IDEMPOT])) + \\ MATCH_MP_TAC SPEC_COMPOSE + \\ Q.EXISTS_TAC `^assert_for_tm s3` + \\ `(^assert_for_tm ((Ret,st,name)::(NextNode n',st1,name1)::t') = + ^assert_for_tm s3) /\ good_stack fs s3` by ALL_TAC THEN1 + (Q.MATCH_ASSUM_RENAME_TAC `list_func_trans fs name2 = + SOME (GraphFunction y1 y2 graph2 y3)` + \\ FULL_SIMP_TAC std_ss [] + \\ Q.PAT_ASSUM `good_stack fs (xx::yy::tt)` MP_TAC + \\ SIMP_TAC (srw_ss()) [good_stack_def,good_stack_tail_def,HD,FST] + \\ STRIP_TAC \\ FULL_SIMP_TAC (srw_ss()) [] + \\ Q.PAT_ASSUM `g = graph1` ASSUME_TAC \\ FULL_SIMP_TAC (srw_ss()) [] + \\ NTAC 6 (POP_ASSUM MP_TAC) \\ FULL_SIMP_TAC std_ss [] + \\ REPEAT (POP_ASSUM (fn th => if is_eq (concl th) then ALL_TAC else NO_TAC)) + \\ NTAC 6 STRIP_TAC + \\ Q.MATCH_ASSUM_RENAME_TAC `graph1 n1 = SOME (Call ret name2 l l0)` + \\ `(y2 = all_names_with_input) /\ (l0 = all_names_ignore)` by ALL_TAC THEN1 + (IMP_RES_TAC list_func_trans_EQ_SOME_IMP + \\ FULL_SIMP_TAC std_ss [] + \\ IMP_RES_TAC graph_SOME_IMP + \\ IMP_RES_TAC MEM_Call_list_inst_trans) + \\ FULL_SIMP_TAC std_ss [] + \\ REVERSE (REPEAT STRIP_TAC) + THEN1 (Cases_on `ret` \\ FULL_SIMP_TAC (srw_ss()) []) + THEN1 (MATCH_MP_TAC good_stack_tail_return_vars + \\ IMP_RES_TAC good_stack_tail_STEP \\ FULL_SIMP_TAC std_ss []) + \\ FULL_SIMP_TAC std_ss [assert_for_def] + \\ MATCH_MP_TAC (METIS_PROVE [] ``(f1 = f2) /\ (x1 = x2) ==> (f1 x1 = f2 x2)``) + \\ STRIP_TAC THEN1 + (AP_TERM_TAC + \\ TRY (MATCH_MP_TAC arm_STATE_all_names) + \\ TRY (MATCH_MP_TAC m0_STATE_all_names) + \\ FULL_SIMP_TAC std_ss [EVERY_MEM] + \\ METIS_TAC [return_vars_SAME]) + \\ Cases_on `ret` \\ FULL_SIMP_TAC (srw_ss()) [] + \\ AP_TERM_TAC + \\ FULL_SIMP_TAC std_ss [var_word32_def,var_acc_def,return_vars_def, + save_vals_def,fold_def,var_upd_def,all_names_def] \\ EVAL_TAC + \\ FULL_SIMP_TAC std_ss [var_word32_def,var_acc_def,return_vars_def, + save_vals_def,fold_def,var_upd_def] \\ EVAL_TAC) + \\ FULL_SIMP_TAC std_ss [SPEC_REFL,PULL_FORALL,AND_IMP_INTRO] + \\ FIRST_X_ASSUM MATCH_MP_TAC + \\ Q.EXISTS_TAC `n-1` \\ FULL_SIMP_TAC std_ss [] + \\ POP_ASSUM MP_TAC \\ FULL_SIMP_TAC std_ss [] + \\ REPEAT STRIP_TAC \\ DECIDE_TAC) + \\ Cases_on `list_func_trans fs name` \\ FULL_SIMP_TAC (srw_ss()) [] + \\ Cases_on `x` \\ FULL_SIMP_TAC (srw_ss()) [] + \\ Q.MATCH_ASSUM_RENAME_TAC `list_func_trans fs name = + SOME (GraphFunction x1 x2 graph1 x3)` + \\ Cases_on `graph1 n'` \\ FULL_SIMP_TAC (srw_ss()) [] + THEN1 (REPEAT STRIP_TAC \\ FULL_SIMP_TAC std_ss [upd_stack_def] + \\ IMP_RES_TAC NRC_Err) + \\ FULL_SIMP_TAC (srw_ss()) [] + \\ IMP_RES_TAC list_func_trans_EQ_SOME_IMP + \\ FULL_SIMP_TAC std_ss [] \\ SRW_TAC [] [] + \\ `EVEN n'` by ALL_TAC THEN1 (FULL_SIMP_TAC (srw_ss()) [good_stack_def]) + \\ `n' < 2 ** 32` by ALL_TAC THEN1 + (IMP_RES_TAC list_inst_trans_IMP_LESS + \\ FULL_SIMP_TAC std_ss []) + \\ IMP_RES_TAC graph_list_inst_trans_EQ_SOME_IMP + \\ FULL_SIMP_TAC std_ss [] + \\ Q.MATCH_ASSUM_RENAME_TAC `graph (list_inst_trans 1 l) i = SOME x` + \\ Q.MATCH_ASSUM_RENAME_TAC `find_inst (n2w i) l = SOME (Inst (n2w i) a next)` + \\ FULL_SIMP_TAC std_ss [funcs_ok_def,EVERY_MEM] + \\ IMP_RES_TAC find_func_IMP_MEM + \\ RES_TAC \\ FULL_SIMP_TAC std_ss [func_ok_def] + \\ IMP_RES_TAC find_inst_IMP_MEM + \\ RES_TAC \\ FULL_SIMP_TAC std_ss [] + \\ `i < 4294967296` by DECIDE_TAC + \\ IMP_RES_TAC find_inst_IMP_LIST_SUBSET + \\ MP_TAC (lemma + |> Q.INST [`x1`|->`ret_and_all_names`, + `x2`|->`all_names_with_input`, + `k`|->`k2`, + `x3`|->`w2n entry`, + `nodes`|->`list_inst_trans 1 l`]) + \\ FULL_SIMP_TAC (srw_ss()) [funcs_ok_def,EVERY_MEM] + \\ MATCH_MP_TAC IMP_IMP \\ STRIP_TAC THEN1 + (MATCH_MP_TAC ALL_DISTINCT_list_inst_trans + \\ FULL_SIMP_TAC std_ss [EVERY_MEM,IMPL_INST_def,func_ok_def] + \\ Cases \\ REPEAT STRIP_TAC \\ RES_TAC + \\ FULL_SIMP_TAC std_ss [inst_loc_def]) + \\ REPEAT STRIP_TAC + \\ CONV_TAC ((RATOR_CONV o RAND_CONV) (ONCE_REWRITE_CONV [GSYM UNION_IDEMPOT])) + \\ MATCH_MP_TAC SPEC_COMPOSE + \\ Q.EXISTS_TAC `(^assert_for_tm s4)` \\ FULL_SIMP_TAC std_ss [] + \\ FULL_SIMP_TAC std_ss [SPEC_REFL,PULL_FORALL,AND_IMP_INTRO] + \\ FIRST_X_ASSUM MATCH_MP_TAC + \\ Q.EXISTS_TAC `j1` \\ FULL_SIMP_TAC std_ss []) end + +val _ = save_thm("arm_exec_func_step_IMP", exec_func_step_IMP "arm"); +val _ = save_thm("m0_exec_func_step_IMP", exec_func_step_IMP "m0"); + +(* misc lemmas *) + +val LIST_IMPL_INST_def = Define ` + (LIST_IMPL_INST code names [] = T) /\ + (LIST_IMPL_INST code names ((Inst i assert next)::xs) = + IMPL_INST code names (Inst i assert next) /\ (assert = K T) /\ + LIST_IMPL_INST code names xs)`; + +val IMP_LIST_IMPL_INST = store_thm("IMP_LIST_IMPL_INST", + ``IMPL_INST code names (Inst i (K T) next) /\ + LIST_IMPL_INST code names xs ==> + LIST_IMPL_INST code names ((Inst i (K T) next)::xs)``, + SIMP_TAC std_ss [LIST_IMPL_INST_def]); + +val IMP_func_ok = store_thm("IMP_func_ok", + ``!insts. LIST_IMPL_INST code names insts ==> + ALL_DISTINCT (MAP inst_loc insts) /\ EVEN (w2n entry) ==> + func_ok code names (Func name entry insts)``, + SIMP_TAC std_ss [func_ok_def] \\ Induct + \\ FULL_SIMP_TAC std_ss [LIST_IMPL_INST_def,MAP,ALL_DISTINCT,MEM] \\ Cases + \\ FULL_SIMP_TAC std_ss [LIST_IMPL_INST_def,MAP,ALL_DISTINCT,MEM,inst_loc_def] + \\ REPEAT STRIP_TAC + \\ RES_TAC \\ FULL_SIMP_TAC (srw_ss()) []); + +val IMP_EVERY_func_ok = store_thm("IMP_EVERY_func_ok", + ``func_ok code locs f /\ + EVERY (func_ok code locs) fs ==> + EVERY (func_ok code locs) (f::fs)``, + FULL_SIMP_TAC std_ss [EVERY_DEF]); + +val _ = wordsLib.guess_lengths () + +val word32_def = Define ` + (word32 (b1:word8) (b2:word8) (b3:word8) (b4:word8)) :word32 = + b1 @@ b2 @@ b3 @@ b4`; + +val READ32_def = zDefine ` + READ32 a mem = word32 (mem (a + 3w)) (mem (a + 2w)) (mem (a + 1w)) (mem a)`; + +val READ8_def = zDefine ` + READ8 a mem = (mem:word32 -> word8) a`; + +val WRITE32_def = zDefine ` + WRITE32 (a:word32) (w:word32) (mem:word32->word8) = + (a =+ w2w w) + ((a + 1w =+ w2w (w >>> 8)) + ((a + 2w =+ w2w (w >>> 16)) + ((a + 3w =+ w2w (w >>> 24)) mem)))`; + +val WRITE8_def = zDefine ` + WRITE8 (a:word32) (w:word8) (mem:word32->word8) = (a =+ w) mem`; + +val func_name_def = Define ` + func_name (Func name entry l) = name`; + +val func_body_trans_def = zDefine ` + func_body_trans f = SND (func_trans f)`; + +val list_func_trans_thm = store_thm("list_func_trans_thm", + ``list_func_trans fs = + graph (MAP (\f. (func_name f, func_body_trans f)) fs)``, + SIMP_TAC std_ss [list_func_trans_def] \\ AP_TERM_TAC + \\ Induct_on `fs` \\ FULL_SIMP_TAC std_ss [MAP] \\ Cases + \\ FULL_SIMP_TAC std_ss [func_name_def,func_trans_def,func_body_trans_def]); + +val word_extract_thm = store_thm("word_extract_thm", + ``((7 >< 0) (w:word32) = (w2w w):word8) /\ + ((15 >< 8) (w:word32) = (w2w (w >>> 8)):word8) /\ + ((23 >< 16) (w:word32) = (w2w (w >>> 16)):word8) /\ + ((31 >< 24) (w:word32) = (w2w (w >>> 24)):word8) /\ + ((31 >< 0) (v:word64) = ((w2w v):word32)) /\ + ((63 >< 32) (v:word64) = ((w2w (v >>> 32)):word32))``, + blastLib.BBLAST_TAC); + +val n2w_lsr = + ``n2w (w2n ((w:'a word) >>> m)):'a word`` + |> SIMP_CONV std_ss [w2n_lsr] |> RW [n2w_w2n] + +val Align_lemma = prove( + ``!w. (arm$Align (w,2) = w >>> 1 << 1) /\ + (m0$Align (w,2) = w >>> 1 << 1) /\ + (arm$Align (w,4) = w >>> 2 << 2) /\ + (m0$Align (w,4) = w >>> 2 << 2)``, + Cases \\ SIMP_TAC std_ss [n2w_lsr,armTheory.Align_def, + m0Theory.Align_def,w2n_n2w,WORD_MUL_LSL,word_mul_n2w]); + +val REMOVE_Align = store_thm("REMOVE_Align", + ``!w. ALIGNED w ==> + (arm$Align (w,2) = w) /\ (arm$Align (w,4) = w) /\ + (m0$Align (w,2) = w) /\ (m0$Align (w,4) = w)``, + SIMP_TAC std_ss [Align_lemma,ALIGNED_def] \\ blastLib.BBLAST_TAC); + +val byte_lemma = prove( + ``(((b1:word8) @@ (b2:word8)):word16 = w2w b1 << 8 || w2w b2) /\ + (((h1:word16) @@ (b2:word8)):24 word = w2w h1 << 8 || w2w b2) /\ + (((b1:word8) @@ (h2:word16)):24 word = w2w b1 << 16 || w2w h2) /\ + (((h1:word16) @@ (h2:word16)):word32 = w2w h1 << 16 || w2w h2)``, + blastLib.BBLAST_TAC); + +val lemma = blastLib.BBLAST_PROVE + ``(w && 1w = 0w) <=> ~(w:word32) ' 0`` + +val Aligned2_thm = prove( + ``(arm$Aligned (w:word32,2) = (w && 1w = 0w)) /\ + (m0$Aligned (w:word32,2) = (w && 1w = 0w))``, + FULL_SIMP_TAC std_ss [lemma] + \\ SIMP_TAC std_ss [armTheory.Aligned_def,m0Theory.Aligned_def, + armTheory.Align_def,m0Theory.Align_def,ALIGNED_INTRO] + \\ Cases_on `w` \\ FULL_SIMP_TAC (srw_ss()) [ALIGNED_n2w] + \\ FULL_SIMP_TAC (srw_ss()) [wordsTheory.word_index, + bitTheory.BIT_def, bitTheory.BITS_THM] + \\ `(2 * (n DIV 2)) < 4294967296` by ALL_TAC THEN1 + (SIMP_TAC bool_ss [GSYM (EVAL ``2 * 2147483648:num``),LT_MULT_LCANCEL] + \\ FULL_SIMP_TAC std_ss [DIV_LT_X]) + \\ FULL_SIMP_TAC std_ss [] + \\ ASSUME_TAC (DIVISION |> Q.SPEC `2` |> SIMP_RULE std_ss [] + |> GSYM |> Q.SPEC `n`) + \\ Cases_on `n MOD 2 = 0` \\ FULL_SIMP_TAC std_ss [] + \\ FULL_SIMP_TAC std_ss [AC MULT_COMM MULT_ASSOC] + \\ `n MOD 2 < 2` by FULL_SIMP_TAC std_ss [] + \\ DECIDE_TAC); + +val Aligned_thm = prove( + ``(arm$Aligned (w:word32,4) = (w && 3w = 0w)) /\ + (m0$Aligned (w:word32,4) = (w && 3w = 0w))``, + SIMP_TAC std_ss [armTheory.Aligned_def,m0Theory.Aligned_def, + armTheory.Align_def,m0Theory.Align_def,ALIGNED_INTRO] + \\ Cases_on `w` \\ FULL_SIMP_TAC (srw_ss()) [ALIGNED_n2w] + \\ `(4 * (n DIV 4)) < 4294967296` by ALL_TAC THEN1 + (SIMP_TAC bool_ss [GSYM (EVAL ``4 * 1073741824:num``),LT_MULT_LCANCEL] + \\ FULL_SIMP_TAC std_ss [DIV_LT_X]) + \\ FULL_SIMP_TAC std_ss [] + \\ ASSUME_TAC (DIVISION |> Q.SPEC `4` |> SIMP_RULE std_ss [] |> GSYM |> Q.SPEC `n`) + \\ Cases_on `n MOD 4 = 0` \\ FULL_SIMP_TAC std_ss [] + \\ FULL_SIMP_TAC std_ss [AC MULT_COMM MULT_ASSOC] \\ DECIDE_TAC); + +val w2n_eq = prove( + ``!w. (w2n w = 0) <=> (w = 0w)``, + Cases \\ FULL_SIMP_TAC (srw_ss()) []); + +val decomp_simp1 = prove( + ``(K x y = x) /\ (SUC n = n + 1)``, + SIMP_TAC std_ss [FUN_EQ_THM,ADD1]); + +val decomp_simp1 = save_thm("decomp_simp1", + LIST_CONJ [GSYM word32_def,Aligned_thm,Aligned2_thm,ALIGNED, + decomp_simp1,word_extract_thm,ALIGNED_INTRO,w2n_eq,byte_lemma]) + +val decomp_simp2 = store_thm("decomp_simp2", + ``(K x = \y. x) /\ (SUC = \n. n + 1)``, + SIMP_TAC std_ss [FUN_EQ_THM,ADD1]); + +val decomp_simp3 = store_thm("decomp_simp3", + ``(K = \x y. x) /\ (ALIGNED x = (x && 3w = 0w)) /\ + (REV xs [] = REVERSE xs)``, + SIMP_TAC std_ss [FUN_EQ_THM,ALIGNED_def] \\ EVAL_TAC); + +val CALL_TAG_def = Define ` + CALL_TAG (s:string) (is_tail_call:bool) = T`; + +val unspecified_pre_def = zDefine `unspecified_pre = F`; + +val SKIP_TAG_def = zDefine ` + SKIP_TAG (s:string) = unspecified_pre`; + +val SKIP_SPEC = store_thm("SKIP_SPEC", + ``!asm. + SPEC ARM_MODEL (arm_PC p * cond (SKIP_TAG asm)) {} (arm_PC (p + 4w))``, + SIMP_TAC std_ss [SKIP_TAG_def,SPEC_MOVE_COND,unspecified_pre_def]); + +val fake_spec = store_thm("fake_spec", + ``SPEC ARM_MODEL (aPC p * aR 0w r0 * cond (unspecified_pre)) {} + (aR 0w ARB * aPC (p + 4w))``, + SIMP_TAC std_ss [unspecified_pre_def,SPEC_MOVE_COND]); + +val WORD_LEMMA = prove( + ``(a - l = w) = (l = a - w:word32)``, + blastLib.BBLAST_TAC); + +val SP_LEMMA = store_thm("SP_LEMMA", + ``((a - n2w (l + n) * 4w = r13 - 4w * n2w l) ==> b) ==> + ALIGNED a /\ ALIGNED r13 /\ (n = w2n (a - r13:word32) DIV 4) ==> b``, + Cases_on `b` \\ FULL_SIMP_TAC std_ss [] + \\ REPEAT STRIP_TAC \\ CCONTR_TAC \\ FULL_SIMP_TAC std_ss [] + \\ FULL_SIMP_TAC std_ss [Once ADD_COMM] + \\ FULL_SIMP_TAC std_ss [GSYM word_add_n2w,WORD_RIGHT_ADD_DISTRIB] + \\ FULL_SIMP_TAC std_ss [WORD_SUB_PLUS] + \\ FULL_SIMP_TAC std_ss [AC WORD_MULT_ASSOC WORD_MULT_COMM] + \\ FULL_SIMP_TAC std_ss [WORD_LCANCEL_SUB] + \\ FULL_SIMP_TAC std_ss [WORD_LEMMA] + \\ `ALIGNED (a - r13)` by METIS_TAC [ALIGNED_SUB] + \\ Cases_on `a - r13` + \\ FULL_SIMP_TAC std_ss [w2n_n2w,ALIGNED_n2w,word_mul_n2w] + \\ MP_TAC (MATCH_MP DIVISION (DECIDE ``0<4:num``) |> Q.SPEC `n'`) + \\ FULL_SIMP_TAC std_ss [AC MULT_COMM MULT_ASSOC] + \\ ONCE_REWRITE_TAC [EQ_SYM_EQ] \\ REPEAT STRIP_TAC + \\ FULL_SIMP_TAC std_ss []); + +val ALIGNED_IMP_BITS_01 = store_thm("ALIGNED_IMP_BITS_01", + ``ALIGNED w ==> ~(w ' 0) /\ ~(w ' 1)``, + SIMP_TAC std_ss [ALIGNED_def] \\ blastLib.BBLAST_TAC); + +val BITS_01_IMP_ALIGNED = store_thm("BITS_01_IMP_ALIGNED", + ``~(w ' 0) /\ ~(w ' 1) ==> ((b ==> ALIGNED w) <=> ALIGNED w)``, + SIMP_TAC std_ss [ALIGNED_def] \\ blastLib.BBLAST_TAC); + +val ALIGNED_Align = store_thm("ALIGNED_Align", + ``(ALIGNED (arm$Align (w,2)) = ~(w ' 1)) /\ + (ALIGNED (arm$Align (w,4)) = T) /\ + (ALIGNED (m0$Align (w,2)) = ~(w ' 1)) /\ + (ALIGNED (m0$Align (w,4)) = T)``, + SIMP_TAC std_ss [Align_lemma,ALIGNED_def] \\ blastLib.BBLAST_TAC); + +val carry_out_def = zDefine ` + carry_out w1 w2 c = CARRY_OUT w1 w2 c`; + +val OVERFLOW_EQ = store_thm("OVERFLOW_EQ", + ``OVERFLOW x y c = + (word_msb x = word_msb y) /\ + (word_msb x <> word_msb (if c then x - ~y else x + y))``, + SIMP_TAC std_ss [add_with_carry_def,LET_DEF] + \\ Cases_on `x` \\ Cases_on `y` \\ FULL_SIMP_TAC std_ss [] + \\ Cases_on `c` \\ FULL_SIMP_TAC std_ss [w2n_n2w,word_add_n2w] + \\ FULL_SIMP_TAC std_ss [word_sub_def,WORD_NEG,WORD_NOT_NOT] + \\ FULL_SIMP_TAC std_ss [ADD_ASSOC,word_add_n2w]); + +val BIT_31 = prove( + ``BIT 31 m = ((m DIV 2**31) MOD 2 = 1)``, + SIMP_TAC std_ss [bitTheory.BIT_def,bitTheory.BITS_THM]); + +val word32_msb_n2w = store_thm("word32_msb_n2w", + ``word_msb ((n2w n):word32) = ((n DIV 2**31) MOD 2 = 1)``, + SIMP_TAC (srw_ss()) [word_msb_n2w,BIT_31]); + +val count_leading_zero_bits_def = zDefine ` + count_leading_zero_bits (w:'a word) = + (n2w (arm$CountLeadingZeroBits w)):'a word`; + +val count_leading_zero_bits_thm = + store_thm("count_leading_zero_bits_thm", + ``(n2w (arm$CountLeadingZeroBits w) = count_leading_zero_bits w) /\ + (n2w (m0$CountLeadingZeroBits w) = count_leading_zero_bits w)``, + FULL_SIMP_TAC std_ss [m0Theory.CountLeadingZeroBits_def, + armTheory.CountLeadingZeroBits_def,count_leading_zero_bits_def, + armTheory.HighestSetBit_def,m0Theory.HighestSetBit_def]); + +val word_add_with_carry_def = zDefine ` + word_add_with_carry (w1:'a word) w2 c = + FST (add_with_carry (w1,w2,c))`; + +(* graph format helpers *) + +val MemAcc8_def = Define ` + MemAcc8 m a = READ8 a (m:word32->word8)`; + +val MemAcc32_def = Define ` + MemAcc32 m a = READ32 a (m:word32->word8)`; + +val MemUpdate8_def = Define ` + MemUpdate8 m a w = WRITE8 a w (m:word32->word8)`; + +val MemUpdate32_def = Define ` + MemUpdate32 m a w = WRITE32 a w (m:word32->word8)`; + +val ShiftLeft_def = Define ` + ShiftLeft (w:'a word) (y:'a word) = word_lsl w (w2n y)`; + +val ShiftRight_def = Define ` + ShiftRight (w:'a word) (y:'a word) = word_lsr w (w2n y)`; + +val w2w_carry_alt = prove( + ``((w2w:word32 -> 33 word) (w1:word32) << w2n ((w2w (w2:word32)):word8)) ' 32 <=> + (ShiftLeft ((w2w:word32 -> word64) (w1:word32)) + (w2w ((w2w:word32->word8) w2))) ' 32``, + FULL_SIMP_TAC (srw_ss()) [ShiftLeft_def] + \\ `w2n ((w2w:word8->word64) (w2w w2)) = w2n ((w2w w2):word8)` by + (FULL_SIMP_TAC (srw_ss()) [w2w_def] + \\ MATCH_MP_TAC LESS_TRANS \\ Q.EXISTS_TAC `256` + \\ FULL_SIMP_TAC (srw_ss()) []) + \\ FULL_SIMP_TAC (srw_ss()) [word_lsl_def,fcpTheory.FCP_BETA] + \\ Q.ABBREV_TAC `n = w2n ((w2w:word32->word8) w2)` + \\ Cases_on `n <= 32` \\ FULL_SIMP_TAC (srw_ss()) [] + \\ `32 - n < dimindex (:33) /\ 32 - n < dimindex (:64)` by + (FULL_SIMP_TAC (srw_ss()) [] \\ DECIDE_TAC) + \\ FULL_SIMP_TAC std_ss [wordsTheory.w2w]); + +val w2w_carry = prove( + ``EVERY (\i. (((w2w (w:word32) << i):33 word) ' 32) <=> + ((w && n2w (2 ** (32 - i))) <> 0w)) (GENLIST I 32)``, + FULL_SIMP_TAC (srw_ss()) [EVAL ``GENLIST I 32``,EVERY_DEF, + ShiftLeft_def,ShiftRight_def,w2n_n2w] \\ blastLib.BBLAST_TAC) + |> SIMP_RULE std_ss [EVAL ``GENLIST I 32``,EVERY_DEF]; + +val rw64 = prove( + ``EVERY (\i. ((w:word64) ' i = ((w && n2w (2 ** i)) <> 0w)) /\ + (word_bit i w = ((w && n2w (2 ** i)) <> 0w)) /\ + (word_lsr w i = ShiftRight w ((n2w i):word64)) /\ + (word_lsl w i = ShiftLeft w ((n2w i):word64))) (GENLIST I 64) /\ + (word_msb w = (w:word64) ' 63)``, + FULL_SIMP_TAC (srw_ss()) [EVAL ``GENLIST I 64``,EVERY_DEF, + ShiftLeft_def,ShiftRight_def,w2n_n2w] \\ blastLib.BBLAST_TAC) + |> SIMP_RULE std_ss [EVAL ``GENLIST I 64``,EVERY_DEF] + +val rw8 = prove( + ``EVERY (\i. ((w:word8) ' i = ((w && n2w (2 ** i)) <> 0w)) /\ + (word_bit i w = ((w && n2w (2 ** i)) <> 0w)) /\ + (word_lsr w i = ShiftRight w ((n2w i):word8)) /\ + (word_lsl w i = ShiftLeft w ((n2w i):word8))) (GENLIST I 8) /\ + (word_msb w = (w:word8) ' 7)``, + FULL_SIMP_TAC (srw_ss()) [EVAL ``GENLIST I 8``,EVERY_DEF, + ShiftLeft_def,ShiftRight_def,w2n_n2w] \\ blastLib.BBLAST_TAC) + |> SIMP_RULE std_ss [EVAL ``GENLIST I 8``,EVERY_DEF] + +val rw = prove( + ``EVERY (\i. ((w:word32) ' i = ((w && n2w (2 ** i)) <> 0w)) /\ + (word_bit i w = ((w && n2w (2 ** i)) <> 0w)) /\ + (word_lsr w i = ShiftRight w ((n2w i):word32)) /\ + (word_lsl w i = ShiftLeft w ((n2w i):word32))) (GENLIST I 32) /\ + (word_msb w = (w:word32) ' 31)``, + FULL_SIMP_TAC (srw_ss()) [EVAL ``GENLIST I 32``,EVERY_DEF, + ShiftLeft_def,ShiftRight_def,w2n_n2w] \\ blastLib.BBLAST_TAC) + |> SIMP_RULE std_ss [EVAL ``GENLIST I 32``,EVERY_DEF] + +val word_add_with_carry_eq = prove( + ``word_add_with_carry (x:'a word) y z = + x + y + if z then 1w else 0w``, + Cases_on `z` \\ Cases_on `x` \\ Cases_on `y` + \\ FULL_SIMP_TAC std_ss [word_add_with_carry_def] + \\ FULL_SIMP_TAC std_ss [carry_out_def,add_with_carry_def,LET_DEF] + \\ FULL_SIMP_TAC std_ss [w2n_n2w,w2w_def,word_add_n2w]); + +val w2w_blast = prove( + ``!w. w <+ n2w (2 ** 33):word64 ==> + ((w2w ((w2w w):word32) = w) <=> (w && (n2w (2 ** 32)) = 0w))``, + blastLib.BBLAST_TAC); + +val carry_out_eq = prove( + ``carry_out (x:word32) (y:word32) z = + ((w2w x + w2w y + if z then 1w else 0w:word64) && n2w (2 ** 32)) <> 0w``, + Cases_on `z` \\ Cases_on `x` \\ Cases_on `y` + \\ FULL_SIMP_TAC std_ss [carry_out_def,add_with_carry_def,LET_DEF] + \\ FULL_SIMP_TAC std_ss [w2n_n2w,w2w_def,word_add_n2w] + \\ `(n + n') < 18446744073709551616` by (fs [] \\ DECIDE_TAC) + \\ `(n + n' + 1) < 18446744073709551616` by (fs [] \\ DECIDE_TAC) + \\ `n2w (n + n' + 1) <+ n2w (2 ** 33):word64 /\ + n2w (n + n') <+ n2w (2 ** 33):word64` by (fs [WORD_LO] \\ DECIDE_TAC) + \\ IMP_RES_TAC w2w_blast + \\ `(n + n' + 1) < dimword (:64)` by (fs [WORD_LO] \\ DECIDE_TAC) + \\ `(n + n' + 1) MOD dimword (:32) < dimword (:64) /\ + (n + n') MOD dimword (:32) < dimword (:64)` by + (REPEAT STRIP_TAC \\ MATCH_MP_TAC LESS_TRANS + \\ Q.EXISTS_TAC `dimword (:32)` + \\ FULL_SIMP_TAC std_ss [MATCH_MP MOD_LESS ZERO_LT_dimword] + \\ EVAL_TAC) + \\ `(n + n') < dimword (:64)` by DECIDE_TAC + \\ FULL_SIMP_TAC std_ss [w2w_def,w2n_n2w,n2w_11]); + +val rw3 = prove( + ``(w << w2n y = ShiftLeft (w:word64) (w2w (y:word32))) /\ + (w >>> w2n y = ShiftRight (w:word64) (w2w (y:word32))) /\ + (w << w2n x = ShiftLeft (w:word64) (w2w (x:word8))) /\ + (w >>> w2n x = ShiftRight (w:word64) (w2w (x:word8))) /\ + (v << w2n x = ShiftLeft (v:word32) (w2w (x:word8))) /\ + (v >>> w2n x = ShiftRight (v:word32) (w2w (x:word8)))``, + Cases_on `y` \\ Cases_on `x` \\ fs [ShiftLeft_def,ShiftRight_def,w2w_def] + \\ `n < 18446744073709551616` by DECIDE_TAC \\ fs [] + \\ `n' < 18446744073709551616` by DECIDE_TAC \\ fs [] + \\ `n' < 4294967296` by DECIDE_TAC \\ fs []); + +val fix_align = blastLib.BBLAST_PROVE + ``(((31 '' 2) w = w:word32) <=> (w && 1w = 0w) /\ (w && 2w = 0w)) /\ + ((w = (31 '' 2) w:word32) <=> (w && 1w = 0w) /\ (w && 2w = 0w)) /\ + (((31 '' 1) w = w:word32) <=> (w && 1w = 0w)) /\ + ((w = (31 '' 1) w:word32) <=> (w && 1w = 0w)) /\ + ((31 '' 2) w = w >>> 2 << 2) /\ + ((31 '' 1) w = w >>> 1 << 1) /\ + ((31 '' 0) w = w)``; + +val graph_format_preprocessing = save_thm("graph_format_preprocessing", + LIST_CONJ [MemAcc8_def, MemAcc32_def, ShiftLeft_def, ShiftRight_def, + MemUpdate8_def, MemUpdate32_def] |> GSYM + |> CONJ rw |> CONJ rw3 |> CONJ rw64 |> CONJ rw8 + |> CONJ w2w_carry |> CONJ w2w_carry_alt + |> CONJ carry_out_eq + |> CONJ word_add_with_carry_eq + |> CONJ fix_align + |> RW [GSYM CONJ_ASSOC] + |> SIMP_RULE std_ss []) + +(* misc *) + +val STAR_IF = store_thm("STAR_IF", + ``(if b then x else y) * (q:'a set set) = (if b then x * q else STAR y q)``, + Cases_on `b` \\ FULL_SIMP_TAC std_ss []) + +val emp_STAR = store_thm("emp_STAR", + ``(emp * p = p) /\ (p * emp = p:'a set set)``, + SIMP_TAC std_ss [SEP_CLAUSES]) + +val T_IMP = store_thm("T_IMP",``(T ==> b) ==> b``,SIMP_TAC std_ss []) + +val EQ_T = store_thm("EQ_T",``(x = T) ==> x``,SIMP_TAC std_ss []) + +val ret_lemma = store_thm("ret_lemma", + ``(s "ret" = VarWord32 w) ==> (w = var_word32 "ret" s)``, + SRW_TAC [] [var_word32_def,var_acc_def]); + +val apply_update_NIL = store_thm("apply_update_NIL", + ``apply_update [] s = (s:'a->'b)``, + SIMP_TAC std_ss [apply_update_def]); + +val var_word32_apply_update = store_thm("var_word32_apply_update", + ``var_word32 n (apply_update ((x,y)::xs) s) = + if n = x then (case y s of VarWord32 w => w | _ => 0w) else + var_word32 n (apply_update xs s)``, + SRW_TAC [] [var_word32_def,var_acc_def,apply_update_def,APPLY_UPDATE_THM]); + +val I_LEMMA = store_thm("I_LEMMA", + ``(\x.x:'a) = I``, + SIMP_TAC std_ss [FUN_EQ_THM]); + +val Aligned_Align = store_thm("Aligned_Align", + ``arm$Aligned (w,n) ==> (arm$Align (w:'a word,n) = w)``, + SIMP_TAC std_ss [armTheory.Aligned_def,armTheory.Align_def]); + +val SWITCH_LEMMA = store_thm("SWITCH_LEMMA", + ``SPEC m (p * f x) c (q * f x) <=> + !v. (v = x) ==> SPEC m (p * f v) c (q * f v)``, + SIMP_TAC std_ss []); + +val SWITCH_COMBINE = store_thm("SWITCH_COMBINE", + ``(b1 ==> SPEC m p c1 q1) /\ (b2 ==> SPEC m p c2 q2) ==> + (~b1 ==> b2) ==> SPEC m p (c1 UNION c2) (if b1 then q1 else q2)``, + Cases_on `b1` \\ FULL_SIMP_TAC std_ss [] + \\ REPEAT STRIP_TAC + \\ MATCH_MP_TAC (SPEC_SUBSET_CODE |> SIMP_RULE std_ss [PULL_FORALL,AND_IMP_INTRO]) + \\ TRY (Q.EXISTS_TAC `c1` \\ FULL_SIMP_TAC (srw_ss()) [] \\ NO_TAC) + \\ TRY (Q.EXISTS_TAC `c2` \\ FULL_SIMP_TAC (srw_ss()) [] \\ NO_TAC)); + +val SPEC_PC_LEMMA = store_thm("SPEC_PC_LEMMA", + ``SPEC m (p * r x) c q ==> + !pc. (pc = x) ==> SPEC m (p * r pc) c q``, + SIMP_TAC std_ss []); + +val ABBBREV_CODE_LEMMA = store_thm("ABBBREV_CODE_LEMMA", + ``!a (x :('a, 'b, 'c) processor) p c q. + (a ==> SPEC x p c q) ==> !d. c SUBSET d ==> a ==> SPEC x p d q``, + REPEAT STRIP_TAC THEN RES_TAC THEN IMP_RES_TAC SPEC_SUBSET_CODE); + +val NEQ_SYM = store_thm("NEQ_SYM", + ``~(x = y) <=> ~(y = x)``, + METIS_TAC []); + +val _ = export_theory(); diff --git a/examples/machine-code/graph/Holmakefile b/examples/machine-code/graph/Holmakefile new file mode 100644 index 0000000000..f97bb9a0d1 --- /dev/null +++ b/examples/machine-code/graph/Holmakefile @@ -0,0 +1,35 @@ +INCLUDES = $(HOLDIR)/examples/l3-machine-code/common \ + $(HOLDIR)/examples/l3-machine-code/arm/model \ + $(HOLDIR)/examples/l3-machine-code/m0/model \ + $(HOLDIR)/examples/l3-machine-code/arm/step \ + $(HOLDIR)/examples/l3-machine-code/m0/step \ + $(HOLDIR)/examples/l3-machine-code/arm/prog \ + $(HOLDIR)/examples/l3-machine-code/m0/prog \ + $(HOLDIR)/examples/l3-machine-code/arm/decompiler \ + $(HOLDIR)/examples/l3-machine-code/m0/decompiler \ + $(HOLDIR)/examples/machine-code/hoare-triple \ + $(HOLDIR)/examples/machine-code/decompiler +OPTIONS = QUIT_ON_FAILURE + +THYFILES = $(patsubst %Script.sml,%Theory.uo,$(wildcard *.sml)) +TARGETS = $(patsubst %.sml,%.uo,$(THYFILES)) +all: $(TARGETS) +.PHONY: all + +ifdef POLY +HOLHEAP = local-hol-heap +EXTRA_CLEANS = $(HOLHEAP) $(HOLHEAP).o + +BARE_THYS = $(HOLDIR)/examples/l3-machine-code/common/utilsLib \ + $(HOLDIR)/examples/l3-machine-code/common/stateTheory \ + $(HOLDIR)/examples/l3-machine-code/common/temporal_stateTheory \ + $(HOLDIR)/examples/l3-machine-code/common/tripleLib \ + $(HOLDIR)/examples/l3-machine-code/arm/prog/arm_progLib \ + $(HOLDIR)/examples/l3-machine-code/m0/prog/m0_progLib \ + $(HOLDIR)/examples/machine-code/decompiler/decompilerLib +DEPS = $(patsubst %,%.uo,$(BARE_THYS)) + +$(HOLHEAP): $(DEPS) + $(protect $(HOLDIR)/bin/buildheap) -o $(HOLHEAP) $(BARE_THYS) + +endif diff --git a/examples/machine-code/graph/backgroundLib.sml b/examples/machine-code/graph/backgroundLib.sml new file mode 100644 index 0000000000..6f93f5de2c --- /dev/null +++ b/examples/machine-code/graph/backgroundLib.sml @@ -0,0 +1,153 @@ +structure backgroundLib = +struct + +open HolKernel boolLib bossLib Parse; +open helperLib; + +val _ = set_echo 5; + +infix \\ val op \\ = op THEN; + +fun the (SOME x) = x | the NONE = fail() + +fun try_map f [] = [] + | try_map f (x::xs) = let val y = f x in y :: try_map f xs end + handle Interrupt => raise Interrupt + | _ => try_map f xs + +fun max (x,y) = if x < y then y else x; + +fun drop_until p [] = [] + | drop_until p (x::xs) = if p x then x::xs else drop_until p xs + +fun take_until p [] = [] + | take_until p (x::xs) = if p x then [] else x::take_until p xs + +fun every p [] = true + | every p (x::xs) = p x andalso every p xs + +fun subset xs ys = every (fn x => mem x ys) xs + +fun diff xs ys = filter (fn x => not (mem x ys)) xs + +fun append_lists [] = [] + | append_lists (x::xs) = x @ append_lists xs + +fun take n [] = [] + | take n (x::xs) = if n = 0 then [] else x :: take (n-1) xs + +fun drop n [] = [] + | drop n (x::xs) = if n = 0 then x::xs else drop (n-1) xs + +val sum = foldl (op +) 0 + +fun lines_from_file filename = let + val _ = echo 1 (" Reading " ^ filename) + val t = TextIO.openIn(filename) + fun lines aux = case TextIO.inputLine(t) of + NONE => rev aux + | (SOME line) => lines (line::aux) + val xs = lines [] + val _ = TextIO.closeIn(t) + val _ = echo 1 ", done.\n" + in xs end + +fun measure_it name f x = let + (* count inferences and record time *) + val _ = Count.counting_thms true + val _ = Count.reset_thm_count () + val start1 = Time.now() + val y = f x + val end1 = Time.now() + val total1 = Count.thm_count () + val _ = Count.counting_thms false + val time1 = Time.toReal ((op Time.-)(end1,start1)) + val _ = print "\n (profiling) " + val _ = print name + val _ = print " " + val _ = print (Real.toString time1) + val _ = print " sec, " + val _ = print (int_to_string (#total total1)) + val _ = print " prim. inf.\n" + in y end; + +fun dest_tuple tm = + if tm = ``():unit`` then [] else + let val (x,y) = pairSyntax.dest_pair tm in x :: dest_tuple y end + handle HOL_ERR e => [tm]; + +fun REPLACE_CONV th tm = let + val th = SPEC_ALL th + val (i,j) = match_term ((fst o dest_eq o concl) th) tm + in INST i (INST_TYPE j th) end + +(* expands pairs ``(x,y,z) = f`` --> (x = FST f) /\ (y = FST (SND f)) /\ (z = ...) *) +fun expand_conv tm = let + val cc = RAND_CONV (REPLACE_CONV (GSYM pairTheory.PAIR)) + val cc = cc THENC REPLACE_CONV pairTheory.PAIR_EQ + val th = cc tm + in CONV_RULE (RAND_CONV (RAND_CONV expand_conv)) th end + handle HOL_ERR e => REFL tm + +fun list_mk_pair xs = pairSyntax.list_mk_pair xs handle HOL_ERR e => ``()`` +fun list_dest_pair tm = let val (x,y) = pairSyntax.dest_pair tm + in list_dest_pair x @ list_dest_pair y end handle HOL_ERR e => [tm] + +val BINOP1_CONV = RATOR_CONV o RAND_CONV + +fun index_for x xs = let (* idea: el (index_for x xs) x = x *) + fun aux k n [] = fail() + | aux k n (x::xs) = if k = x then n else aux k (n+1) xs + in aux x 1 xs end + +(* implementation of skip_proofs *) + +val skip_proofs = ref false; + +fun print_error goal = let + val _ = print "\n\nAuto proof of following failed.\n\n" + val _ = print_term goal + val _ = print "\n\n" + in () end + +fun auto_prove proof_name (goal,tac) = + if !skip_proofs then prove(goal,cheat) else let + val (rest,validation) = tac ([], goal) + in if length rest = 0 then validation [] + else (print_error goal; + failwith("auto_prove failed for " ^ proof_name)) end + +fun auto_conv_prove proof_name goal conv = + if !skip_proofs then prove(goal,cheat) else let + val th = conv goal + in if rand (concl th) = T then MATCH_MP GraphLangTheory.EQ_T th + else (print_error goal; + failwith("auto_conv_prove failed for " ^ proof_name)) end + +(* debugging *) + +fun modify_message f e = + case e of + HOL_ERR e => HOL_ERR { message = f (#message e) , + origin_function = #origin_function e , + origin_structure = #origin_structure e } + | _ => e + +fun report_error name e = let + val _ = "\n\n" ^ name ^ " failed.\n\n" + in raise (modify_message (fn s => s ^ " << " ^ name) e) end + +(* misc *) + +fun is_inl tm = can (match_term sumSyntax.inl_tm o car) tm +fun is_inr tm = can (match_term sumSyntax.inr_tm o car) tm + +fun dest_sum_type ty = let + val (name,xs) = dest_type ty + val _ = name = "sum" orelse fail() + in (el 1 xs, el 2 xs) end + +fun clean_name s = String.translate + (fn c => if c = #"." then "_" else implode [c]) s + +end diff --git a/examples/machine-code/graph/cond_cleanLib.sml b/examples/machine-code/graph/cond_cleanLib.sml new file mode 100644 index 0000000000..6d61e880da --- /dev/null +++ b/examples/machine-code/graph/cond_cleanLib.sml @@ -0,0 +1,126 @@ +structure cond_cleanLib = +struct + +open HolKernel boolLib bossLib Parse; +open listTheory wordsTheory pred_setTheory arithmeticTheory wordsLib pairTheory; +open set_sepTheory progTheory helperLib addressTheory combinTheory; + +open backgroundLib syntaxLib file_readerLib derive_specsLib graph_specsLib; +open GraphLangTheory writerLib; + +fun find_inst_for loc insts = let + val pat = ``IMPL_INST code locs (Inst ^loc assert next)`` + in first (can (match_term pat) o concl) insts end + +fun dest_IMPL_INST_IF_ASM_ASM th = let + val (_,_,i) = dest_IMPL_INST (concl th) + val (_,_,next) = dest_Inst i + val (guard,next1,next2) = dest_IF next + in (guard,dest_ASM next1, dest_ASM next2) end + +fun negate tm = if is_neg tm then dest_neg tm else mk_neg tm; +fun negate_guard tm = combinSyntax.mk_o(``$~:bool->bool``,tm) + +fun reduce_inst_under_assum assum th = + if can (dest_IMPL_INST_IF_ASM_ASM) th then let + val (guard,asm1,asm2) = dest_IMPL_INST_IF_ASM_ASM th + in let + val th1 = MATCH_MP IMPL_INST_IF_SIMP2 th |> SPEC assum + val h = th1 |> concl |> dest_imp |> fst + val lemma = MATCH_MP EQ_T (QCONV (SIMP_CONV std_ss []) h) + in MP th1 lemma end + handle HOL_ERR _ => + let + val th1 = MATCH_MP IMPL_INST_IF_SIMP1 th |> SPEC assum + val h = th1 |> concl |> dest_imp |> fst + val lemma = MATCH_MP EQ_T (QCONV (SIMP_CONV std_ss []) h) + in MP th1 lemma end + end + else MATCH_MP IMPL_INST_SET_ASSUM th |> SPEC assum + +val pc_string = ``"pc"`` + +fun inst_only_updates_pc th = let + val (_,_,i) = dest_IMPL_INST (concl th) + val (_,_,next) = dest_Inst i + val (_,update,_) = dest_ASM next + in listSyntax.is_nil update end + handle HOL_ERR _ => false; + +val optimisations_count = ref 0; + +fun report_optimisation branch loc old_dest new_dest = let + val _ = write_line (branch ^ "-branch at `" ^ + int_to_hex loc ^ "` can target `" ^ + int_to_hex new_dest ^ "` instead of `" ^ + int_to_hex old_dest ^ "`.") + in optimisations_count := 1 + (!optimisations_count) end + +val solve_conv = + QCONV (EVAL THENC + SIMP_CONV std_ss [apply_update_def,var_bool_def,var_acc_def] THENC + EVAL THENC SIMP_CONV std_ss [apply_update_def]) + +fun append_nop_to_if th thms = let + val th = th |> RW [I_LEMMA] + val (guard,_,(s2,u2,j2)) = dest_IMPL_INST_IF_ASM_ASM th + val th = let (* simplify else-branch *) + val w = dest_Jump j2 + val th1 = find_inst_for w thms |> RW [I_LEMMA] + val assum = negate_guard guard + val th1 = reduce_inst_under_assum assum th1 + val res = MATCH_MP IMPL_INST_IF_COMPOSE2 (CONJ th th1) + val h = res |> concl |> dest_imp |> fst + val lemma = solve_conv h |> MATCH_MP EQ_T + val th = MP res lemma + val _ = let + val (guard,_,(s2,u2,j2)) = dest_IMPL_INST_IF_ASM_ASM th + val new_dest = dest_Jump j2 |> rand |> numSyntax.int_of_term + val old_dest = w |> rand |> numSyntax.int_of_term + val loc = th |> concl |> rand |> dest_Inst |> #1 |> rand + |> numSyntax.int_of_term + val _ = report_optimisation "Else" loc old_dest new_dest + in () end handle HOL_ERR _ => () + in th end handle HOL_ERR _ => th + val (guard,(s1,u1,j1),_) = dest_IMPL_INST_IF_ASM_ASM th + val th = let (* simplify then-branch *) + val w = dest_Jump j1 + val th1 = find_inst_for w thms |> RW [I_LEMMA] + val assum = guard + val th1 = reduce_inst_under_assum assum th1 + val res = MATCH_MP IMPL_INST_IF_COMPOSE1 (CONJ th th1) + val h = res |> concl |> dest_imp |> fst + val lemma = solve_conv h |> MATCH_MP EQ_T + val th = MP res lemma + val _ = let + val (guard,(s1,u1,j1),_) = dest_IMPL_INST_IF_ASM_ASM th + val new_dest = dest_Jump j1 |> rand |> numSyntax.int_of_term + val old_dest = w |> rand |> numSyntax.int_of_term + val loc = th |> concl |> rand |> dest_Inst |> #1 |> rand + |> numSyntax.int_of_term + val _ = report_optimisation "Then" loc old_dest new_dest + in () end handle HOL_ERR _ => () + in th end handle HOL_ERR _ => th + val th = PURE_REWRITE_RULE [combinTheory.UPDATE_EQ] th + in th end handle HOL_ERR _ => th + +fun list_append_nop_to_if thms = let + fun aux [] result = result + | aux (th::rest) result = let + val th = append_nop_to_if th result + in aux rest (th::result) end + in aux (rev thms) [] end + +fun clean_conds thms = let + val _ = write_subsection "Optimising inst theorems" + val _ = (optimisations_count := 0) + val thms = list_append_nop_to_if thms + val _ = (if (!optimisations_count) <> 0 then () else + write_line "Nothing was optimised.") + in thms end + +(* +val th = first (can (find_term (fn tm => tm = ``Inst 0xF0013DECw``)) o concl) thms +*) + +end diff --git a/examples/machine-code/graph/decompile.py b/examples/machine-code/graph/decompile.py new file mode 100644 index 0000000000..6a9d533b06 --- /dev/null +++ b/examples/machine-code/graph/decompile.py @@ -0,0 +1,91 @@ +#!/usr/bin/env python + +import argparse + + +# Read arguments + +parser = argparse.ArgumentParser(description='Decompile an ELF file.') +parser.add_argument('filename', metavar='filename', type=str, + help='base of filename, e.g. loop for loop.elf.txt') +parser.add_argument('--fast', dest='fast', action='store_const', + const=True, default=False, + help='fast mode skips some proofs') +parser.add_argument('--ignore', metavar='names', type=str, nargs='?', + default='', + help='comma separated list of function names that are to be ignored (decompiler output will contain stubs for these)') + +args = parser.parse_args() + +if args.fast: + fast_str = 'true' +else: + fast_str = 'false' + + +# Run HOL + +import subprocess +import io +import sys +import os + +def call_input_output(args,input_str,output_file): + with open('.input.txt',"w") as input: + input.write(input_str) + input.close() + with open('.input.txt',"r") as input, open(output_file,"wb") as out: + try: + ret = subprocess.call(args, stdin=input, stdout=out, stderr=out, universal_newlines=True, shell=True) + except KeyboardInterrupt: + print '\nInterrupted' + exit(1) + return ret + +elf = os.path.abspath(args.filename) +output_file = os.path.abspath(args.filename + '_output.txt') + +ml_input = """ +use "writerLib"; load "decompileLib"; +val _ = decompileLib.decomp "{0}" {1} "{2}"; +""" + +ml_input = ml_input.format(elf, fast_str, args.ignore) + +decompiler_dir = os.path.dirname(sys.argv[0]) +if decompiler_dir: + os.chdir(decompiler_dir) + +print "Building dependancies ...", +sys.stdout.flush() +ret = call_input_output('Holmake','','hol_output.txt') +if ret != 0: + print "failed!" + print "Holmake failed, abandoning." + print "Short failure summary:" + outp = os.path.abspath('hol_output.txt') + last_lines = list (open (outp))[-20:] + for l in ['\n'] + last_lines + ['\n']: + print l, + print "(more error information in %s )." % outp + exit(1) +print "done." +sys.stdout.flush() + +print "Decompiling {0} ... (output in {1})".format(elf,output_file), +sys.stdout.flush() +call_input_output('./local-hol-heap',ml_input,output_file) +last_lines = list (open (output_file))[-20:] +summaries = [i for (i, l) in enumerate (last_lines) if l.strip() == 'Summary'] +if not summaries: + print "failed!" + print + print "Short failure summary:" + for l in ['\n'] + last_lines + ['\n']: + print l, + print "(more information in %s )" % output_file + exit(1) +print "done." +for l in [''] + last_lines[summaries[-1]:]: + print l, +sys.stdout.flush() diff --git a/examples/machine-code/graph/decompileLib.sml b/examples/machine-code/graph/decompileLib.sml new file mode 100644 index 0000000000..94b684c84d --- /dev/null +++ b/examples/machine-code/graph/decompileLib.sml @@ -0,0 +1,14 @@ +structure decompileLib = +struct + +open func_decompileLib; + +fun decomp base_name fast ignore_names = let + val ignore = String.tokens (fn c => mem c [#",",#" "]) ignore_names + val () = read_files base_name ignore + val _ = (skip_proofs := fast) + val names = section_names() + val th = prove_funcs_ok names + in th end; + +end diff --git a/examples/machine-code/graph/derive_specsLib.sml b/examples/machine-code/graph/derive_specsLib.sml new file mode 100644 index 0000000000..50afd5f340 --- /dev/null +++ b/examples/machine-code/graph/derive_specsLib.sml @@ -0,0 +1,726 @@ +structure derive_specsLib = +struct + +open HolKernel boolLib bossLib Parse; +open listTheory wordsTheory pred_setTheory arithmeticTheory wordsLib pairTheory; +open set_sepTheory progTheory helperLib addressTheory; + +open backgroundLib file_readerLib stack_introLib stack_analysisLib writerLib; + +infix \\ val op \\ = op THEN; + +fun spec_rule x = + case !arch_name of + ARM => arm_spec x + | M0 => m0_spec x; + +(* code abbrevs *) + +val code_abbreviations = ref ([]:thm list); +fun add_code_abbrev thms = (code_abbreviations := thms @ !code_abbreviations); + +(* formatting *) + +fun DISCH_ALL_AS_SINGLE_IMP th = let + val th = RW [AND_IMP_INTRO] (DISCH_ALL th) + in if is_imp (concl th) then th else DISCH ``T`` th end + +(* thm traces *) + +fun next_possible_pcs f (th,i,SOME j,p) = + if can (find_term (fn tm => tm = ``GUARD``)) (concl th) + then all_distinct [j,p+i] else [j] + | next_possible_pcs f (th,i,NONE,p) = + ((th |> concl |> cdr |> find_terms (can (match_term ``p+(n2w n):word32``)) + |> filter (fn tm => wordsSyntax.is_word_add tm) + |> filter (fn tm => wordsSyntax.is_n2w (cdr tm)) + |> filter (fn tm => cdr (car tm) = mk_var("p",``:word32``)) + |> map (numSyntax.int_of_term o cdr o cdr) + |> map f + |> sort (fn x => fn y => x <= y)) + handle HOL_ERR _ => fail()) + +datatype 'a thm_trace = + TRACE_CUT of int (* cut because a different branch describes the rest *) + | TRACE_END of 'a (* normal end *) + | TRACE_STEP of int * 'a * thm * ('a thm_trace) + | TRACE_SPLIT of ('a thm_trace) list; + +fun print_cfg t = let + fun cfg2str prefix (TRACE_CUT p) = "repeat from " ^ (int_to_string p) ^ "\n" ^ prefix + | cfg2str prefix (TRACE_END _) = "return\n" ^ prefix + | cfg2str prefix (TRACE_STEP (p,_,th,t)) = int_to_string p ^ " " ^ cfg2str prefix t + | cfg2str prefix (TRACE_SPLIT qs) = let + val s = "\n" ^ prefix ^ ". " ^ concat (map (cfg2str (prefix ^ ". ")) qs) + in String.substring(s,0,size(s)-2) end + in print ("\n\nCFG:\n " ^ cfg2str " " t ^ "\n\n") end; + +(* + +There's a bug in the trace generation to do with guards that are not +just one variable. The following code shows how this happens: + + val code = ["e92d47f0", "e3520003", "959ac000", "97de9002", + "979cc109", "8590c00c", "e8bd87f0"] + +print_cfg (construct_thm_trace thms) + +*) + +fun bool_normal_form tm = let + val vars = free_vars tm + val vsort = sort (fn v1 => fn v2 => fst (dest_var v1) <= fst (dest_var v2)) + val vs = vsort vars + fun aux t [] = t + | aux t (v::vs) = + mk_cond(v,aux (subst [v|->T] t) vs,aux (subst [v|->F] t) vs) + in SIMP_CONV std_ss [] (aux tm vs) |> concl |> dest_comb |> snd end + +fun construct_thm_trace thms = let + fun list_lookup i [] = fail() + | list_lookup i ((j,x,NONE)::xs) = if i = j then [x] else list_lookup i xs + | list_lookup i ((j,x,SOME y)::xs) = if i = j then [x,y] else list_lookup i xs + fun extract_pre (th,i,j) = let + val th = RW [] th + val guard = cdr (find_term (can (match_term ``GUARD n b``)) (concl th)) + in (th,bool_normal_form guard) end handle HOL_ERR _ => (th,T) + fun resets_status_bits th = let + val (_,p,_,q) = dest_spec (concl th) + val pv = free_vars p |> filter (fn tm => type_of tm = ``:bool``) + val qv = free_vars q |> filter (fn tm => type_of tm = ``:bool``) + in not (diff pv qv = []) end + fun guard_conj guard (th,pre) = + (th,if resets_status_bits th then pre else bool_normal_form (mk_conj(pre,guard))) + fun next_directions th = + ((th |> concl |> cdr |> find_terms (can (match_term ``p+(n2w n):word32``)) + |> filter (fn tm => wordsSyntax.is_word_add tm) + |> filter (fn tm => wordsSyntax.is_n2w (cdr tm)) + |> filter (fn tm => cdr (car tm) = mk_var("p",``:word32``)) + |> map (numSyntax.int_of_term o cdr o cdr) + |> sort (fn x => fn y => x <= y))) + fun mk_TRACE_SPLIT [] = TRACE_END T + | mk_TRACE_SPLIT [x] = x + | mk_TRACE_SPLIT xs = TRACE_SPLIT xs + val aux_calls = ref (tl [(0,T)]) + (* warning: the handling of guards is not perfect, but maybe good enough *) + fun aux (p:int) (seen:int list) (guard:term) = + if mem (p,guard) (!aux_calls) then TRACE_CUT p else + (aux_calls := (p,guard)::(!aux_calls); + if mem p seen then TRACE_CUT p else let + (* finds theorems describing program point p *) + val xs = list_lookup p thms + (* extract boolean precondition *) + val xs = map extract_pre xs + (* combine with current guard if theorem does not reset status bits *) + val xs = map (guard_conj guard) xs + (* remove dead paths *) + val xs = filter (fn (_,pre) => not (pre = F)) xs + (* reads the next pcs *) + val ys = map (fn (th,gg) => (th,gg,next_directions th)) xs + in mk_TRACE_SPLIT (map (fn (th,gs,nexts) => + TRACE_STEP (p, gs, th, mk_TRACE_SPLIT (map + (fn n => aux (n:int) (p::seen) (gs:term)) nexts))) ys) end) + fun is_nop th = (hyp th = []) andalso + can (find_term (fn tm => tm = ``GUARD``)) (concl th) + fun filter_nops (TRACE_CUT p) = TRACE_CUT p + | filter_nops (TRACE_END d) = TRACE_END d + | filter_nops (TRACE_SPLIT ts) = TRACE_SPLIT (map filter_nops ts) + | filter_nops (TRACE_STEP (p,x,th,t)) = + if is_nop th then filter_nops t else TRACE_STEP (p,x,th,filter_nops t) + val result = aux 0 [] T + in result end + + +(* derive SPEC theorems *) + +fun pair_apply f ((th1,x1:int,x2:int option),NONE) = ((f th1,x1,x2),NONE) + | pair_apply f ((th1,x1,x2),SOME (th2,y1:int,y2:int option)) = + ((f th1,x1,x2),SOME (f th2,y1,y2)) + +fun jump_apply f NONE = NONE | jump_apply f (SOME x) = SOME (f x); + +fun pair_jump_apply (f:int->int) ((th1,x1:int,x2:int option),NONE) = ((th1,x1,jump_apply f x2),NONE) + | pair_jump_apply f ((th1:thm,x1,x2),SOME (th2:thm,y1:int,y2:int option)) = + ((th1,x1,jump_apply f x2),SOME (th2,y1,jump_apply f y2)); + +val switch_input = ref (0:int ,[]:string list); + +val CARRY_OUT_LEMMA = + ``CARRY_OUT x y T`` + |> ONCE_REWRITE_CONV [GSYM WORD_NOT_NOT] + |> RW [ADD_WITH_CARRY_SUB] + |> RW [WORD_NOT_NOT] + +val OVERFLOW_LEMMA = + ``OVERFLOW x y T`` + |> ONCE_REWRITE_CONV [GSYM WORD_NOT_NOT] + |> RW [ADD_WITH_CARRY_SUB] + |> RW [WORD_NOT_NOT] + +val WORD_NOT_EQ_LESS_EQ = blastLib.BBLAST_PROVE + ``v <> w /\ v <=+ w <=> v <+ w:word32`` + |> (fn th => CONJ th (RW1 [CONJ_COMM] th)) + |> (fn th => CONJ th (RW1 [NEQ_SYM] th)) + |> RW [GSYM CONJ_ASSOC] |> GEN_ALL + +local + val cond_pat = cond_def |> SPEC_ALL |> concl |> dest_eq |> fst +in + fun STAR_cond_CONV c tm = let + val (x,y) = dest_star tm + val _ = match_term cond_pat y + in RAND_CONV (RAND_CONV c) tm end +end + +local + val d32 = CONJ (EVAL ``dimindex (:32)``) (EVAL ``dimword (:32)``) + val word32_mem_pat = ``word32 (READ8 w1 m) (READ8 w2 m) (READ8 w3 m) (READ8 w4 m)`` + val Align_pat1 = ``arm$Align (w:'a word,n)`` + val Align_pat2 = ``m0$Align (w:'a word,n)`` + (* ``b /\ ~(w ' 0) /\ b2 /\ (b3 ==> ALIGNED w) /\ ~(w ' 1)`` *) + val clean_ALIGNED_CONV = + SIMP_CONV (bool_ss++boolSimps.CONJ_ss) [BITS_01_IMP_ALIGNED] THENC + SIMP_CONV (bool_ss++boolSimps.CONJ_ss) [ALIGNED_IMP_BITS_01] + val word_arith_lemma_CONV = + SIMP_CONV std_ss [word_arith_lemma1] THENC + SIMP_CONV std_ss [word_arith_lemma3,word_arith_lemma4] + val flag_conv = + SIMP_CONV std_ss + [OVERFLOW_EQ,WORD_MSB_1COMP,WORD_NOT_NOT, + GSYM carry_out_def,WORD_0_POS,WORD_SUB_RZERO, + GSYM (EVAL ``~(0w:word32)``),d32] THENC + ONCE_REWRITE_CONV [word_1comp_n2w,word32_msb_n2w] THENC + SIMP_CONV std_ss [d32] + val finalise_pre_cond = + PRE_CONV (SIMP_CONV (pure_ss++sep_cond_ss) [] THENC + TRY_CONV (STAR_cond_CONV wordsLib.WORD_SUB_CONV)) + val final_conv = clean_ALIGNED_CONV THENC word_arith_lemma_CONV + THENC flag_conv THENC finalise_pre_cond + fun is_Align tm = can (match_term Align_pat1) tm orelse + can (match_term Align_pat2) tm + fun remove_Align th = + if not (can (find_term is_Align) (concl th)) then th else let + val tms = find_terms is_Align (concl th) + val rws = map (fn tm => SPEC (tm |> rand |> pairSyntax.dest_pair |> fst) + REMOVE_Align |> UNDISCH) tms + in PURE_REWRITE_RULE rws th |> DISCH_ALL + |> PURE_REWRITE_RULE [GSYM SPEC_MOVE_COND] + |> SIMP_RULE (pure_ss++sep_cond_ss) [] end + fun READ8_INTRO_CONV tm = + (if tm |> rator |> is_var then REWR_CONV (GSYM READ8_def) tm + else NO_CONV tm) + handle HOL_ERR _ => NO_CONV tm + val lemma31 = blastLib.BBLAST_PROVE + ``(((((31 >< 1) (w:word32)):31 word) @@ (0w:1 word)) : word32) = + w && 0xFFFFFFFEw`` +in + fun clean_spec_thm th = let + val th = th |> REWRITE_RULE [GSYM word32_def,decomp_simp1,GSYM READ32_def, + GSYM WRITE32_def,word_extract_thm,GSYM word_add_with_carry_def] + |> CONV_RULE (DEPTH_CONV READ8_INTRO_CONV) + |> REWRITE_RULE [GSYM WRITE8_def] + |> SIMP_RULE std_ss [AC CONJ_COMM CONJ_ASSOC,word_bit_def,d32, + GSYM ADD_ASSOC,lemma31,count_leading_zero_bits_thm] + val tms = find_terms (can (match_term word32_mem_pat)) (concl th) + fun READ32_RW tm = let + val (y,x) = tm |> rand |> dest_comb + val goal = mk_eq(tm,``READ32 ^(rand y) ^x``) + val c = + SIMP_CONV std_ss [READ32_def,word_arith_lemma1,READ8_def] THENC + SIMP_CONV std_ss [word_arith_lemma2,word_arith_lemma3,word_arith_lemma4] + in MATCH_MP EQ_T (c goal) end handle HOL_ERR _ => TRUTH; + val th = th |> PURE_REWRITE_RULE (ALIGNED_Align::map READ32_RW tms) + val th = remove_Align th + val th = CONV_RULE final_conv th + in th end +end + +fun remove_arm_CONFIGURE th = + if can (find_term (fn tm => tm = ``arm_CONFIG``)) (concl th) then let + val var = ``var:bool`` + val pat = ``arm_CONFIG (T,ARMv7_A,F,^var,mode)`` + val m = match_term pat + val n = subst (fst (m (find_term (can m) (concl th)))) var + val th = DISCH (mk_neg n) th |> SIMP_RULE bool_ss [] + |> SIMP_RULE (bool_ss++sep_cond_ss) [GSYM SPEC_MOVE_COND, + GSYM arm_decompTheory.arm_OK_def] + val _ = if can m (concl th) + then failwith "unable to remove arm_CONFIGURE" else () + in th end + else th + +(* +val (pos,switch_code) = !switch_input +*) + +fun get_spec_for_switch (pos,switch_code) = let + val _ = (switch_input := (pos,switch_code)) + fun remove_colon_prefix s = last (String.tokens (fn x => x = #":") s) + val raw_code = map remove_colon_prefix switch_code + val ((th1,_,_),_) = spec_rule (el 1 raw_code) + val ((th2,_,_),th2a) = spec_rule (el 2 raw_code) + val ((th3,_,_),_) = spec_rule (el 3 raw_code) + val (th2a,_,_) = the th2a + val (_,_,sts,_) = get_tools() + val (reg,case_count) = let + val thB = SPEC_COMPOSE_RULE [th1,th2a,th3] + val thB = thB |> SIMP_RULE (std_ss++sep_cond_ss) [precond_def, + SPEC_MOVE_COND,CARRY_OUT_LEMMA,WORD_EQ_SUB_ZERO] + |> CONV_RULE (BINOP1_CONV (SIMP_CONV (srw_ss()) [])) + |> RW [WORD_NOT_EQ_LESS_EQ] + |> Q.INST [`pc`|->`n2w ^(numLib.term_of_int pos)`] + |> SIMP_RULE (srw_ss()) [word_add_n2w,OVERFLOW_LEMMA] + |> CONV_RULE (SIMP_CONV (pure_ss++star_ss) [] THENC + REWRITE_CONV [STAR_ASSOC]) + val reg = thB |> concl |> find_term (can (match_term ``arm_REG x y``)) + in (reg,thB |> concl |> dest_imp |> fst |> rator |> rand |> rand + |> numLib.int_of_term |> (curry (op +) 1)) end + fun genlist f 0 k = [] + | genlist f n k = f k :: genlist f (n-1) (k+1) + val targets = zip (genlist I case_count 0) (take case_count (drop 3 raw_code)) + val thA = th2 + val thA = RW [WORD_CMP_NORMALISE,precond_def] thA + val thA = thA |> DISCH ``arm$Aligned (w0:word32,2)`` + |> SIMP_RULE std_ss [Aligned_Align] + val thA = remove_arm_CONFIGURE thA + val thA = thA |> Q.INST [`pc`|->`n2w ^(numLib.term_of_int (pos+4))`] + val thA = thA |> Q.INST [`w0`|->`n2w target`] + val thA = thA |> INST [reg |> rand|->``n2w n:word32``] + fun eval_case (c,p) = let + val n = p |> Arbnum.fromHexString |> Arbnum.toInt |> numLib.term_of_int + val cnv = PRE_CONV (MOVE_OUT_CONV (rator reg)) THENC + POST_CONV (MOVE_OUT_CONV (rator reg)) + val th = thA |> INST [``target:num``|->n,``n:num``|->numSyntax.term_of_int c] + val th = th |> SIMP_RULE (srw_ss()) [armTheory.Aligned_def,armTheory.Align_def, + CARRY_OUT_LEMMA,OVERFLOW_LEMMA] + |> CONV_RULE (PRE_CONV ((RAND_CONV o RAND_CONV) + (REWRITE_CONV [armTheory.Aligned_def,armTheory.Align_def] + THENC EVAL))) |> RW [SEP_CLAUSES] + |> CONV_RULE cnv |> RW1 [SWITCH_LEMMA] |> SPEC (rand reg) + |> CONV_RULE (SIMP_CONV (pure_ss++star_ss) [] THENC + REWRITE_CONV [STAR_ASSOC]) + in th end + val xs = map eval_case targets + fun combine (x,th) = MATCH_MP SWITCH_COMBINE (CONJ x th) + val th = foldr combine (last xs) (butlast xs) + val assum = th |> concl |> dest_imp |> fst + val (w,n) = dest_eq(repeat (snd o dest_imp) assum) + val new_assum = ``^w <+ ^n + 1w`` + val lemma = blastLib.BBLAST_PROVE (mk_imp(new_assum,assum)) + val th = + MP th (UNDISCH lemma) + |> DISCH_ALL + |> CONV_RULE ((RATOR_CONV o RAND_CONV) (SIMP_CONV std_ss [word_add_n2w])) + |> RW [GSYM SPEC_MOVE_COND] + val (_,_,c,_) = dest_spec (concl th) + val code_list = find_terms pairSyntax.is_pair c |> all_distinct + val code_set = code_list |> pred_setSyntax.mk_set + val th = MATCH_MP SPEC_SUBSET_CODE th |> SPEC code_set + |> CONV_RULE (BINOP1_CONV (REWRITE_CONV [UNION_SUBSET, + INSERT_SUBSET,EMPTY_SUBSET,IN_INSERT])) + val th = MP th TRUTH + val th2a = th2a |> Q.INST [`pc`|->`n2w ^(numLib.term_of_int (pos+4))`] + val (_,_,c,_) = dest_spec (concl th) + val th2a = MP (MATCH_MP SPEC_SUBSET_CODE th2a |> SPEC c + |> CONV_RULE (BINOP1_CONV (EVAL))) TRUTH + in (th1,th,th2a,th3, (length code_list)) end + +fun inst_pc_var tools thms = let + fun triple_apply f (y,(th1,x1:int,x2:int option),NONE) = (y,(f y th1,x1,x2),NONE) + | triple_apply f (y,(th1,x1,x2),SOME (th2,y1:int,y2:int option)) = + (y,(f y th1,x1,x2),SOME (f y th2,y1,y2)) + val i = [mk_var("eip",``:word32``) |-> mk_var("p",``:word32``), + mk_var("rip",``:word64``) |-> mk_var("p",``:word64``)] + val (_,_,_,pc) = tools + val ty = (hd o snd o dest_type o type_of) pc + fun f y th = let + val aa = (hd o tl o snd o dest_type) ty + val th = INST i th + val (_,p,_,_) = dest_spec (concl th) + val pattern = inst [``:'a``|->aa] ``(p:'a word) + n2w n`` + val new_p = subst [mk_var("n",``:num``)|-> numSyntax.mk_numeral (Arbnum.fromInt y)] pattern + val th = INST [mk_var("p",type_of new_p)|->new_p] th + val (_,_,_,q) = dest_spec (concl th) + val tm = find_term (fn tm => car tm = pc handle HOL_ERR e => false) q handle HOL_ERR _ => ``T`` + val cc = SIMP_CONV std_ss [word_arith_lemma1,word_arith_lemma3,word_arith_lemma4] + val th = CONV_RULE ((RATOR_CONV o RAND_CONV) cc) th + val thi = QCONV cc tm + in PURE_ONCE_REWRITE_RULE [thi,WORD_ADD_0] th end; + in map (triple_apply f) thms end + +fun pull_let_wider_CONV tm = let + val x = find_term (can (pairSyntax.dest_anylet)) tm + val (y,d) = pairSyntax.dest_anylet x + val tm2 = pairSyntax.mk_anylet(y,subst [x|->d] tm) + val goal = mk_eq(tm,tm2) + val lemma = auto_prove "pull_let_wider_CONV" (goal, + SIMP_TAC std_ss [LET_DEF] + THEN CONV_TAC (DEPTH_CONV PairRules.PBETA_CONV) + THEN REWRITE_TAC []) + in lemma end handle HOL_ERR _ => NO_CONV tm; + +local + val pc_var1 = mk_var("pc",``:word32``) + val pc_var2 = mk_var("p",``:word32``) + val arm_PC_pat = ``arm_PC t`` +in + fun inst_pc pos th = let + val new_pc = ``n2w ^(numSyntax.term_of_int pos):word32`` + val th = INST [pc_var1 |-> new_pc, pc_var2 |-> new_pc] th + val tms = find_terms (can (match_term ``arm_PC t``)) (rand (concl th)) + val rws = map (QCONV (RAND_CONV EVAL)) tms + val th = ONCE_REWRITE_RULE rws th + in th end +end + +fun mk_call_tag fname is_tail_call = let + val b = if is_tail_call then T else F + val fname_tm = stringSyntax.fromMLstring fname + in mk_comb(mk_comb(``CALL_TAG``,fname_tm),b) end + +fun dest_call_tag tm = let + val (xy,z) = dest_comb tm + val (x,y) = dest_comb xy + val _ = (x = ``CALL_TAG``) orelse fail() + in (stringSyntax.fromHOLstring y, + if z = T then true else + if z = F then false else fail()) end + +fun derive_individual_specs code = let + val tools = get_tools() + fun mk_new_var prefix v = let + val (n,ty) = dest_var v + in mk_var (prefix ^ "@" ^ n, ty) end + val (f,_,hide_th,pc) = tools + fun get_model_status_list th = + (map dest_sep_hide o list_dest dest_star o snd o dest_eq o concl) th handle HOL_ERR e => [] + val delete_spaces = (implode o filter (fn x => not(x = #" ")) o explode) + fun list_find name [] = fail () + | list_find name ((x,y)::xs) = if name = x then y else list_find name xs + val prefix_len = size "switch:" + fun remove_switch_prefix s = + if String.isPrefix "switch:" s + then remove_switch_prefix (String.substring(s,prefix_len,size s - prefix_len)) else s + val bad_insts = ["rfeia","mrc","mcr","mcrr","strex","cpsid"] + fun bad_instruction asm_name = + length (filter (fn s => String.isPrefix s asm_name) bad_insts) <> 0 + val white_chars = explode " \t\n" + fun get_asm_name asm = asm |> String.tokens (fn c => mem c white_chars) |> hd + +(* + val ((th,_,_),_) = res + val th = (inst_pc pos o RW [precond_def]) th +*) + + fun get_local_const pos = let + val (_,c,_) = first (fn (p,_,_) => p = pos) code + val _ = String.isPrefix "const:" c orelse failwith "const load from non-const" + val hex = String.tokens (fn c => c = #":") c |> el 2 + val tm = Arbnum.fromHexString hex |> numSyntax.mk_numeral + in ``n2w (^tm):word32`` end + fun has_free_vars tm = length (free_vars tm) <> 0 + fun inst_pc_rel_const th = let + val (_,_,c,_) = dest_spec (concl th) + in if not (has_free_vars c) then th else let + fun do_inst tm = let + val (pos_tm,v) = pairSyntax.dest_pair tm + in v |-> get_local_const (pos_tm |> rand + |> numSyntax.int_of_term) end + val i = find_terms (fn tm => pairSyntax.is_pair tm andalso + is_var (rand tm)) c + |> map (do_inst o rand o concl o QCONV EVAL) + val th = INST i th |> CONV_RULE (RATOR_CONV (RAND_CONV EVAL)) + in th end end + + fun remove_tab s = + s |> explode |> map (fn c => if c = #"\t" then #" " else c) |> implode + fun placeholder_spec asm = let + val t = String.tokens (fn x => x = #":") asm |> last |> remove_tab + in (SPEC (stringSyntax.fromMLstring t) SKIP_SPEC,4,SOME 4) end + +(* + val ((pos,instruction,asm)::code) = drop 1 code + val ((pos,instruction,asm)::code) = drop 17 code +*) + fun get_specs [] = [] + | get_specs ((pos,instruction,asm)::code) = let + val instruction = delete_spaces instruction + in + if String.isPrefix "call:" instruction then let + val ts = String.tokens (fn x => x = #":") instruction + val fname = ts |> el 2 + val instruction = ts |> el 3 + fun add_call_tag th = + th |> DISCH (mk_call_tag fname false) |> UNDISCH + val g = add_call_tag o + clean_spec_thm o + remove_arm_CONFIGURE o + inst_pc_rel_const o + inst_pc pos o RW [precond_def] + val res = f instruction handle HOL_ERR e => + failwith ("Unable to derive spec for " ^ asm) + val (x,y) = pair_apply g res + in (pos,x,y) :: get_specs code end + else if String.isPrefix "const:" instruction then + get_specs code + else if not (code = []) andalso + String.isPrefix "switch:" ((fn (_,x,_) => x) (hd code)) then let + val switch_code = instruction :: map (fn (_,x,_) => x) code + val _ = write_line "Switch found." + val (th1,th2,th2a,th3,l) = get_spec_for_switch (pos,switch_code) + val code = drop (l-1) code + val th2 = th2 |> RW [SPEC_MOVE_COND] + |> SIMP_RULE std_ss [] |> UNDISCH_ALL + fun g pos = clean_spec_thm o + remove_arm_CONFIGURE o + inst_pc_rel_const o + inst_pc pos o RW [precond_def] + in (pos,(g pos th1,4,SOME 4),NONE) :: + (pos+4,(g (pos+4) th2,4,NONE),SOME (g (pos+4) th2a,4,SOME 4)) :: + (pos+8,(g (pos+8) th3,4*l-8,SOME 4),NONE) :: + get_specs code end + else let + val g = clean_spec_thm o + remove_arm_CONFIGURE o + inst_pc_rel_const o + inst_pc pos o RW [precond_def] + val res = f instruction handle HOL_ERR e => + failwith ("Unable to derive spec for " ^ asm) + val (x,y) = pair_apply g res + in (pos,x,y) :: get_specs code end + end handle HOL_ERR _ => let + val (thi,x1,x2) = (placeholder_spec asm) + in (pos,(inst_pc pos thi,x1,x2),NONE) :: get_specs code end + +(* + val (pos,instruction,asm) = hd code + val n = 8 + val instruction = hd (drop 22 code) + val iss = drop 13 code + val ((th,_,_),_) = f instruction + val th = renamer th + val prefix = "foo@" +*) + val res = get_specs code + val has_bad_insts = exists bad_instruction + (map (fn (_,_,asm) => get_asm_name asm) code) + fun calc_addresses i [] = [] + | calc_addresses i ((n:int,(th1:thm,l1,j1),y)::xs) = let + val (x,y) = pair_jump_apply (fn j => i+j) ((th1,l1,j1),y) + in (i,x,y) :: calc_addresses (i+l1) xs end + val res = calc_addresses 0 res + val res = inst_pc_var tools res + (* deal with silly blx instructions that call a constant pointer *) + val pc_rel_var = mk_var("pc_rel",``:word32``) + fun basic_find_pc_rel_load v = + first (fn (n,(th,i,k),y) => let + val vs = free_vars (concl th) + in mem pc_rel_var vs andalso mem (mk_new_var "new" v) vs end) res + fun find_pc_rel_load nn v = let + fun exit_pc_is_var th = let + val v = cdr (find_term (can (match_term ``arm_PC w``)) (cdr (concl th))) + in is_var v end; + val res2 = map (fn (nn,(th,i,x),y) => + if (x = NONE) andalso exit_pc_is_var th + then hd (inst_pc_var tools [(nn,(fake_spec,i,SOME 4),y)]) + else (nn,(th,i,x),y)) (butlast res) @ [last res] + fun is_assign th = let + val vs = free_vars (concl th) + in mem pc_rel_var vs andalso mem (mk_new_var "new" v) vs end + fun assign curr (TRACE_CUT p) = [] + | assign curr (TRACE_END _) = [] + | assign curr (TRACE_SPLIT qs) = append_lists (map (assign curr) qs) + | assign curr (TRACE_STEP (p,_,th,t)) = + if p = nn then [curr] else + assign (if is_assign th then p else curr) t + val xs = (diff (assign ~1 (construct_thm_trace res2)) [~1]) + val _ = length xs > 0 orelse failwith("can't find assignment") + val i = hd xs + fun thms_lookup n [] = fail() + | thms_lookup n ((nn,x,y)::xs) = if n = nn then (nn,x,y) else thms_lookup n xs + in thms_lookup i res end handle HOL_ERR _ => basic_find_pc_rel_load v + fun delete_long_jump (nn,(th,i,SOME k),y) = (nn,(th,i,SOME k),y) + | delete_long_jump (nn,(th,i,NONE),y) = let + val v = cdr (find_term (can (match_term ``arm_PC w``)) (cdr (concl th))) + val (n,(r,_,_),_) = find_pc_rel_load nn v + val (_,_,c,_) = dest_spec (concl r) + val k = el 2 (list_dest pred_setSyntax.dest_insert c) + |> dest_pair |> fst |> cdr |> cdr |> numSyntax.int_of_term + val xs = String.tokens (fn c => c = #":") ((fn (_,x,_) => x) (el (k div 4 + 1) code)) + val a = el 2 xs |> Arbnum.fromHexString |> numSyntax.mk_numeral + |> (fn n => wordsSyntax.mk_n2w(n,``:32``)) + val name = el 3 xs + val rw = GSYM (ASSUME (mk_eq(a,v))) + val th = CONV_RULE (POST_CONV (MOVE_OUT_CONV ``arm_PC``)) th + val th = CONV_RULE ((RATOR_CONV o RAND_CONV) (REWRITE_CONV [rw])) th + val th = CONV_RULE ((POST_CONV o RAND_CONV) (REWRITE_CONV [rw])) th + val th = DISCH_ALL_AS_SINGLE_IMP th + val th = CONV_RULE ((RATOR_CONV o RAND_CONV) (REWRITE_CONV [rw] THENC EVAL)) th + val th = UNDISCH_ALL th + val (th1,_,_) = (print "Not found in memory.\n\n"; fail()) + val th = RW [hide_th] th + val th = CONV_RULE (POST_CONV (MOVE_OUT_CONV ``aR 14w``)) th + val th = CONV_RULE (PRE_CONV (MOVE_OUT_CONV ``arm_PC``)) th + val th = SPEC_COMPOSE_RULE [th,th1] + val th = DISCH_ALL th |> REWRITE_RULE [GSYM SPEC_MOVE_COND] + val th = RW [sidecond_def,hide_th,STAR_ASSOC] th + val th = CONV_RULE (POST_CONV pull_let_wider_CONV) th + in (nn,(th,i,SOME (nn+i)),y) end handle HOL_ERR _ => (nn,(th,i,NONE),y) + val res = map delete_long_jump res + in (has_bad_insts, res) end; + +fun inst_pc_rel_const tools thms code = let + fun triple_apply f (y,(th1,x1:int,x2:int option),NONE) = (y,(f y th1,x1,x2),NONE) + | triple_apply f (y,(th1,x1,x2),SOME (th2,y1:int,y2:int option)) = + (y,(f y th1,x1,x2),SOME (f y th2,y1,y2)) + fun find_instr [] p = hd [] + | find_instr (x::xs) p = if p < 4 then x else find_instr xs (p-4) + val pc_rel = mk_var("pc_rel",``:word32``) + val has_pc_rel = can (find_term (fn x => x = pc_rel)) + fun foo y th = + if not (has_pc_rel (concl th)) then th else let + val (_,_,c,_) = dest_spec (concl th) + val ys = find_terms (can (match_term ``(x1:word32,x2:word32)``)) c + val const = ys |> filter has_pc_rel |> hd |> dest_pair |> fst + |> cdr |> cdr |> numSyntax.int_of_term |> find_instr code + val const = if String.isPrefix "const:" const + then el 2 (String.tokens (fn c => c = #":") const) else const + val n = numSyntax.mk_numeral (Arbnum.fromHexString const) + val th = INST [pc_rel|->wordsSyntax.mk_n2w(n,``:32``)] th + in th end + in map (triple_apply foo) thms end + +fun UNABBREV_CODE_RULE th = let + val rw = (!code_abbreviations) + val c = REWRITE_CONV rw THENC + SIMP_CONV std_ss [word_arith_lemma1] THENC + REWRITE_CONV [INSERT_UNION_EQ,UNION_EMPTY] + val th = CONV_RULE ((RATOR_CONV o RAND_CONV) c) th + in th end; + +fun abbreviate_code name thms = let + fun extract_code (_,(th,_,_),_) = let val (_,_,c,_) = dest_spec (concl th) in c end + val cs = map extract_code thms + val ty = (hd o snd o dest_type o type_of o hd) cs + val tm = foldr pred_setSyntax.mk_union (pred_setSyntax.mk_empty ty) cs + val cth = QCONV (PURE_REWRITE_CONV [INSERT_UNION_EQ,UNION_EMPTY]) tm + val c = (cdr o concl) cth + val (_,(th,_,_),_) = hd thms + val (m,_,_,_) = dest_spec (concl th) + val model_name = (to_lower o implode o take_until (fn x => x = #"_") o explode o fst o dest_const) m + val x = list_mk_pair (free_vars c) + val def_name = name ^ "_" ^ model_name + val v = if x = ``():unit`` then mk_var(def_name,type_of c) + else mk_var(def_name,type_of(mk_pabs(x,c))) + val code_def = new_definition(def_name ^ "_def", + if x = ``():unit`` then mk_eq(v,c) + else mk_eq(mk_comb(v,x),c)) + val _ = add_code_abbrev [code_def] + fun triple_apply f (y,(th1,x1:int,x2:int option),NONE) = (y,(f th1,x1,x2),NONE) + | triple_apply f (y,(th1,x1,x2),SOME (th2,y1:int,y2:int option)) = + (y,(f th1,x1,x2),SOME (f th2,y1,y2)) + val code_thm = CONV_RULE (RAND_CONV (fn _ => GSYM cth)) (SPEC_ALL code_def) + fun foo th = let + val thi = MATCH_MP ABBBREV_CODE_LEMMA (DISCH_ALL_AS_SINGLE_IMP th) + val thi = SPEC ((fst o dest_eq o concl o SPEC_ALL) code_def) thi + val goal = (fst o dest_imp o concl) thi + val lemma = auto_prove "abbreviate_code" (goal, + REPEAT (REWRITE_TAC [code_thm,SUBSET_DEF,IN_UNION] THEN REPEAT STRIP_TAC + THEN ASM_REWRITE_TAC [] THEN (fn _ => fail())) + THEN REWRITE_TAC [EMPTY_SUBSET] + THEN REWRITE_TAC [SUBSET_DEF,IN_INSERT,IN_UNION,NOT_IN_EMPTY,code_def] + THEN REPEAT STRIP_TAC THEN ASM_SIMP_TAC std_ss []) + val thi = UNDISCH_ALL (PURE_REWRITE_RULE [GSYM AND_IMP_INTRO] (MP thi lemma)) + in thi end + val thms = map (triple_apply foo) thms + val _ = (x = ``():unit``) orelse failwith "code contains variables" + in (code_def,thms) end + +fun apply_thms f (i:int,(th,l:int,j:int option),NONE) = (i,(f th,l,j),NONE) + | apply_thms f (i,(th,l,j),SOME (th1,l1,j1)) = (i,(f th,l,j),SOME (f th1,l1,j1)) + +fun try_map g f [] = [] + | try_map g f (x::xs) = let + val y = f x + in y :: try_map g f xs end + handle HOL_ERR _ => + (g x; try_map g f xs) + +val stack_intro_fails = ref ([] : (int * string) list); + +fun print_stack_intro_fail (pos,sec_name) = let + val b = !writer_prints + val _ = (writer_prints := true) + val _ = write_line ("Stack intro failed in " ^ sec_name ^ " for pos " ^ + (int_to_hex pos) ^ ".") + val _ = (writer_prints := b) + in () end + +fun add_stack_intro_fail pos sec_name = + (print_stack_intro_fail (pos,sec_name); + stack_intro_fails := (pos, sec_name) :: (!stack_intro_fails)); + +fun clear_stack_intro_fails () = (stack_intro_fails := []); + +fun print_stack_intro_report () = + (if length (!stack_intro_fails) = 0 then + (write_line "No stack intro failures."; []) + else (map print_stack_intro_fail (!stack_intro_fails))) + +fun dervie_specs_for sec_name = let + val code = section_body sec_name + val _ = write_subsection "Deriving specifications" + val cl = int_to_string (length code) + val str = "Section `"^sec_name^"` consists of "^cl^" instructions." + val _ = write_line str + val thms = snd (derive_individual_specs code) + val stack_accesses = + if length thms = 0 then [] else + find_stack_accesses sec_name thms + handle HOL_ERR _ => (add_stack_intro_fail 0 sec_name; []) + val _ = (writer_prints := false) + val thms = try_map (fn (n,_,_) => add_stack_intro_fail n sec_name) + (apply_thms (STACK_INTRO_RULE stack_accesses)) thms + val _ = (writer_prints := true) + val (code_abbrev_def, thms) = + if length thms = 0 then (TRUTH, thms) else + abbreviate_code sec_name thms + in thms end; + +(* + val base_name = "/Users/mom22/decompiler/graph/new-gcc-O1/kernel" + val _ = read_files base_name + val _ = open_current "test" + val sec_name = "doNormalTransfer" + + val ths = thms |> map (#1 o #2) + + val all_summaries = map approx_summary (thms1 @ thms2) |> flatten + +val all_summaries = + [(``4w:word32``, ``T``, + [(``r3:word32``,``r13 + 64w:word32``)], NONE, + ``8w:word32``), + + (``8w:word32``, ``T``, + [(``READ32 (r13 + 12w:word32) m``,``r3:word32``)], + SOME ``r13 + 8w:word32``, + ``11w:word32``), + + (``11w:word32``, ``T``, + [(``r13:word32``,``r13 + 4w:word32``)], NONE, + ``12w:word32``), + + (``12w:word32``, ``T``, + [(``r12:word32``, ``READ32 (r13 + 8w:word32) m``), + (``READ32 (r13 + 60w:word32) m``,``r3:word32``)], + SOME ``r13 + 8w:word32``, ``16w:word32``), + + (``16w:word32``, ``T``, + [(``r2:word32``, ``READ32 (r12:word32) m``), + (``r3:word32``, ``READ32 (r12 + 4w:word32) m``)], + SOME ``r12:word32``, ``20w:word32``)] + +*) + +end diff --git a/examples/machine-code/graph/exportLib.sml b/examples/machine-code/graph/exportLib.sml new file mode 100644 index 0000000000..eef14d6025 --- /dev/null +++ b/examples/machine-code/graph/exportLib.sml @@ -0,0 +1,375 @@ +structure exportLib = +struct + +open HolKernel boolLib bossLib Parse; +open listTheory wordsTheory pred_setTheory arithmeticTheory wordsLib pairTheory; +open set_sepTheory progTheory helperLib addressTheory combinTheory; + +open graph_specsLib backgroundLib writerLib; + +open GraphLangTheory; + + +(* exporter state *) + +val failed_ty_translations = ref ([]:hol_type list); +val failed_tm_translations = ref ([]:term list); + + +(* recording errors *) + +local + fun print_ty_fail ty = let + val _ = print "FAILED to translate type: " + val _ = print_type ty + val _ = print "\n" + in () end; + fun print_tm_fail tm = let + val _ = print "FAILED to translate term: " + val _ = print_term tm + val _ = (print "\n\nwith type: "; print_type (type_of tm); print "\n\n") + in () end; +in + fun add_ty_fail ty = let + val _ = (failed_ty_translations := ty::(!failed_ty_translations)) + in print_ty_fail ty end + fun add_tm_fail tm = let + val _ = (failed_tm_translations := tm::(!failed_tm_translations)) + in print_tm_fail tm end +end + + +(* syntax functions *) + +fun dest_graph tm = + if can (match_term ``graph (xs:('a # 'b) list)``) tm then let + val (x,y) = dest_comb tm + fun f (x,y) = (numSyntax.int_of_term x, y) + in listSyntax.dest_list y |> fst |> map (f o pairSyntax.dest_pair) end + handle HOL_ERR _ => failwith "dest_graph" + else failwith "dest_graph" + +fun dest_str_graph tm = + if can (match_term ``graph (xs:('a # 'b) list)``) tm then let + val (x,y) = dest_comb tm + fun f (x,y) = (stringSyntax.fromHOLstring x, y) + in listSyntax.dest_list y |> fst |> map (f o pairSyntax.dest_pair) end + handle HOL_ERR _ => failwith "dest_graph" + else failwith "dest_graph" + +fun dest_string_list tm = let + val (xs,ty) = listSyntax.dest_list tm + val _ = (ty = ``:string``) orelse fail() + val ys = map stringSyntax.fromHOLstring xs + in ys end handle HOL_ERR _ => failwith "dest_string_list" + +local + val pat = ``GraphFunction inps outps gg ep`` +in + fun dest_GraphFunction tm = let + val _ = can (match_term pat) tm orelse fail() + val ep = tm |> rand |> numSyntax.int_of_term + val gs = tm |> rator |> rand |> dest_graph + val ys = tm |> rator |> rator |> rand |> dest_string_list + val xs = tm |> rator |> rator |> rator |> rand |> dest_string_list + in (xs,ys,gs,ep) end +end + +local + val pat = ``Basic n xs`` +in + fun dest_Basic tm = let + val _ = can (match_term pat) tm orelse fail() + val next = tm |> rator |> rand + val (xs,ty) = tm |> rand |> listSyntax.dest_list + val _ = (ty = ``:string # (state -> variable)``) orelse fail() + val ys = xs |> map pairSyntax.dest_pair + |> map (fn (x,y) => (stringSyntax.fromHOLstring x,y)) + in (next,ys) end +end + +local + val pat = ``Cond n1 n2 p`` +in + fun dest_Cond tm = let + val _ = can (match_term pat) tm orelse fail() + val next1 = tm |> rator |> rator |> rand + val next2 = tm |> rator |> rand + val tm = tm |> rand + in (next1,next2,tm) end +end + +local + val pat = ``Call next name args strs`` +in + fun dest_Call tm = let + val _ = can (match_term pat) tm orelse fail() + val next = tm |> rator |> rator |> rator |> rand + val (strs,ty) = tm |> rand |> listSyntax.dest_list + val _ = (ty = ``:string``) orelse fail() + val strs = strs |> map stringSyntax.fromHOLstring + val name = tm |> rator |> rator |> rand |> stringSyntax.fromHOLstring + val (args,ty) = tm |> rator |> rand |> listSyntax.dest_list + val _ = (ty = ``:state -> variable``) orelse fail() + in (next,name,args,strs) end +end + +local + val pat = ``NextNode n`` +in + fun dest_NextNode tm = let + val _ = can (match_term pat) tm orelse fail() + val next = tm |> rand |> numSyntax.int_of_term + in next end +end + +local + val pat = ``var_acc str`` +in + fun dest_var_acc tm = let + val _ = can (match_term pat) tm orelse fail() + in tm |> rand |> stringSyntax.fromHOLstring end +end + +local + val pat = ``SKIP_TAG str`` +in + fun dest_SKIP_TAG tm = let + val _ = can (match_term pat) tm orelse fail() + in tm |> rand |> stringSyntax.fromHOLstring end +end + +local + fun any_var_acc pat = fn tm => let + val _ = can (match_term pat) tm orelse fail() + val x1 = tm |> rator |> rand |> stringSyntax.fromHOLstring + val x2 = tm |> rand + in (x1,x2) end +in + val dest_var_word32 = any_var_acc ``var_word32 str s`` + val dest_var_word8 = any_var_acc ``var_word8 str s`` + val dest_var_nat = any_var_acc ``var_nat str s`` + val dest_var_bool = any_var_acc ``var_bool str s`` + val dest_var_mem = any_var_acc ``var_mem str s`` + val dest_var_dom = any_var_acc ``var_dom str s`` +end; + + +(* export to Graph's graph format *) + +val patterns = + [(``MemAcc8 m a``,"MemAcc"), + (``MemAcc32 m a``,"MemAcc"), + (``MemUpdate8 m a w``,"MemUpdate"), + (``MemUpdate32 m a w``,"MemUpdate"), + (``x = (y:'a)``,"Equals"), + (``T``,"True"), + (``F``,"False"), + (``~(b:bool)``,"Not"), + (``word_1comp (x:'a word)``,"BWNot"), + (``word_add (x:'a word) y``,"Plus"), + (``word_sub (x:'a word) y``,"Minus"), + (``word_mul (x:'a word) y``,"Times"), + (``word_and (x:'a word) y``,"BWAnd"), + (``word_or (x:'a word) y``,"BWOr"), + (``word_xor (x:'a word) y``,"BWXOR"), + (``ShiftLeft (x:'a word) y``,"ShiftLeft"), + (``ShiftRight (x:'a word) y``,"ShiftRight"), + (``x ==> y:bool``,"Implies"), + (``x /\ y:bool``,"And"), + (``x \/ y:bool``,"Or"), + (``(x:'a word) < y``,"SignedLess"), + (``(x:'a word) <+ y``,"Less"), + (``(x:'a word) <= y``,"SignedLessEquals"), + (``(x:'a word) <=+ y``,"LessEquals"), + (``(x:'a word) IN y``,"MemDom"), + (``(w2w (x:'a word)):'b word``,"WordCast"), + (``(sw2sw (x:'a word)):'b word``,"WordCastSigned"), + (``(n:num) + m``,"Plus"), + (``if b then x else y``,"IfThenElse"), + (``count_leading_zero_bits (w:'a word)``,"CountLeadingZeroes")]; + +val last_fail_node_tm = ref T; + +fun export_graph name rhs = let + fun int_to_hex i = + "0x" ^ Arbnumcore.toHexString (Arbnum.fromInt i) + fun get_var_type "mem" = "Mem" + | get_var_type "dom" = "Dom" + | get_var_type "stack" = "Mem" + | get_var_type "dom_stack" = "Dom" + | get_var_type "n" = "Bool" + | get_var_type "z" = "Bool" + | get_var_type "c" = "Bool" + | get_var_type "v" = "Bool" + | get_var_type "clock" = "Word 64" + | get_var_type _ = "Word 32" + fun arg s = "" ^ s ^ " " ^ get_var_type s + fun commas [] = "" + | commas [x] = x + | commas (x::xs) = x ^ " " ^ commas xs + fun export_list xs = int_to_string (length xs) ^ " " ^ commas xs + fun export_type ty = + if ty = ``:word64`` then "Word 64" else + if ty = ``:word32`` then "Word 32" else + if ty = ``:word8`` then "Word 8" else + if ty = ``:word32->word8`` then "Mem" else + if ty = ``:word32->bool`` then "Dom" else + if ty = ``:bool`` then "Bool" else + if ty = ``:num`` then "Word 64" else failwith("type") + fun is_var_acc tm = + can dest_var_word32 tm orelse + can dest_var_word8 tm orelse + can dest_var_nat tm orelse + can dest_var_bool tm orelse + can dest_var_mem tm orelse + can dest_var_dom tm + fun match_pattern tm [] = fail() + | match_pattern tm ((pat,name)::xs) = + if not (can (match_term pat) tm) then match_pattern tm xs else let + val (s1,s2) = match_term pat tm + val cs = filter is_var (list_dest dest_comb pat) + in (name,map (subst s1 o inst s2) cs) end + fun term tm = + (* Num *) + if numSyntax.is_numeral tm then + "Num " ^ int_to_string (tm |> numSyntax.int_of_term) ^ " Nat" + else if wordsSyntax.is_n2w tm then + let val i = tm |> rand |> numSyntax.int_of_term + in "Num " ^ int_to_string i ^ " " ^ export_type (type_of tm) end + (* Var *) + else if is_var_acc tm then + let val name = tm |> rator |> rand |> stringSyntax.fromHOLstring + in "Var " ^ name ^ " " ^ export_type (type_of tm) end + (* Op *) + else let + val (n,xs) = match_pattern tm patterns + val ty = export_type (type_of tm) + in "Op " ^ n ^ " " ^ ty ^ " " ^ export_list (map term xs) end + handle HOL_ERR _ => (add_tm_fail tm; fail()) + val types = [``VarNat``,``VarWord8``,``VarWord32``, + ``VarMem``,``VarDom``,``VarBool``] + val s_var = mk_var("s",``:state``) + fun bool_exp tm = + if can dest_var_acc tm then let + val n = dest_var_acc tm + in "Var " ^ n ^ " " ^ get_var_type n end + else let + val (s,e) = dest_abs tm + val _ = type_of s = ``:state`` orelse failwith("bad exp") + val _ = type_of e = ``:bool`` orelse failwith("bad exp") + in term e end + fun exp tm = + if can dest_var_acc tm then let + val n = dest_var_acc tm + in "Var " ^ n ^ " " ^ get_var_type n end + else let + val (s,e) = dest_abs tm + val _ = type_of s = ``:state`` orelse failwith("bad exp") + val (t,tm) = dest_comb e + val _ = mem t types + in term tm end + fun dest_abs_skip_tag test = let + val (v,x) = dest_abs test + val n = dest_SKIP_TAG x + in n end + fun assign_var (n,tm) = + "" ^ n ^ " " ^ get_var_type n ^ " " ^ exp tm + val ret_node = ``Ret`` + val err_node = ``Err`` + fun export_nextnode tm = + if tm = ret_node then "Ret" else + if tm = err_node then "Err" else let + val i = dest_NextNode tm + in int_to_hex i end + fun export_node (n,tm) = let + val (next,assign) = dest_Basic tm + in commas [int_to_hex n,"Basic",export_nextnode next, + export_list (map assign_var assign)] ^ "\n" end + handle HOL_ERR _ => let + val (next1,next2,test) = dest_Cond tm + in if can dest_abs_skip_tag test then + "# " ^ int_to_hex n ^ " node is " ^ + dest_abs_skip_tag test ^ "\n" ^ + commas [int_to_hex n,"Cond", + export_nextnode next1, + export_nextnode next2, + "Op UnspecifiedPrecond Bool 0"] ^ "\n" + else + commas [int_to_hex n,"Cond", + export_nextnode next1, + export_nextnode next2, + bool_exp test] ^ "\n" end + handle HOL_ERR _ => let + val (next,func_name,input,output) = dest_Call tm + in commas [int_to_hex n,"Call", + export_nextnode next, + func_name, + export_list (map exp input), + export_list (map arg output)] ^ "\n" end + val rhs = rhs |> QCONV (REWRITE_CONV [graph_format_preprocessing]) + |> concl |> rand + val (input,output,nodes,entry) = dest_GraphFunction rhs + val decl = "Function " ^ name ^ " " ^ + export_list (map arg input) ^ " " ^ + export_list (map arg output) ^ "\n" + val _ = write_graph decl + fun my_map f [] = [] + | my_map f (x::xs) = + (let val y = f x in y end + handle HOL_ERR e => + let val _ = print "\n\nFailed to translate node: \n\n" + val _ = print_term (snd x) + val _ = print "\n\n" + val _ = (last_fail_node_tm := snd x) + in raise (HOL_ERR e) end) :: my_map f xs + val _ = my_map (write_graph o export_node) nodes + val last_line = "EntryPoint " ^ int_to_hex entry ^ "\n" + val _ = write_graph last_line + in () end + + +(* export constant definition *) + +fun export_func lemma = let + val (lhs,rhs) = lemma |> concl |> dest_eq + val name = lhs |> dest_const |> fst |> clean_name + val _ = export_graph name rhs + in "define_" ^ name end + + +(* print export report *) + +fun print_export_report () = let + val l = length (!failed_ty_translations) + length (!failed_tm_translations) + in if l = 0 then write_line "No export failures." else let + val xs = map (fn ty => "Failed to translate type: " ^ type_to_string ty) + (all_distinct (!failed_ty_translations)) @ + map (fn tm => "Failed to translate term: " ^ term_to_string tm) + (all_distinct (!failed_tm_translations)) + in (map write_line xs; ()) end end + + +(* conv used by func_decompiler *) + +val prepare_for_export_conv = let + fun unbeta_conv pat tm = + if is_comb tm andalso can (match_term pat) (rand tm) then let + val ty = rand tm |> type_of |> dest_type |> snd |> hd + in (RAND_CONV (REWR_CONV (GSYM ETA_AX))) tm end else NO_CONV tm + val foldback = (unbeta_conv ``var_bool str``) ORELSEC + (unbeta_conv ``var_word32 str``) ORELSEC + (unbeta_conv ``var_word8 str``) ORELSEC + (unbeta_conv ``var_nat str``) ORELSEC + (unbeta_conv ``var_mem str``) ORELSEC + (unbeta_conv ``var_dom str``) + val c = PURE_REWRITE_CONV [decomp_simp1,all_names_def, + ret_and_all_names_def, + all_names_ignore_def, all_names_with_input_def] THENC + PURE_REWRITE_CONV [decomp_simp2] THENC + PURE_REWRITE_CONV [decomp_simp3] THENC + PURE_REWRITE_CONV [GSYM wordsTheory.WORD_NOT_LOWER] THENC + DEPTH_CONV foldback + in QCONV c end; + +end diff --git a/examples/machine-code/graph/file_readerLib.sml b/examples/machine-code/graph/file_readerLib.sml new file mode 100644 index 0000000000..74bfbb3ad3 --- /dev/null +++ b/examples/machine-code/graph/file_readerLib.sml @@ -0,0 +1,280 @@ +structure file_readerLib = +struct + +open HolKernel boolLib bossLib Parse; +open backgroundLib writerLib; + +datatype arch = ARM | M0 + +(* refs begin *) + +val arch_name = ref ARM; +val skip_names = ref ["halt"]; +val missing_sigs = ref ([]:string list); +val complete_sections = ref ([]:(string * (* sec_name *) + (int list * int * bool) * (* signature *) + string * (* location as hex string *) + (int * string * string) list * (* body *) + string list) list); (* dependencies *) + +(* refs end *) + +fun arch_str () = + case (!arch_name) of ARM => "ARM" | M0 => "M0" + +fun HOL_commit () = let + val path = Globals.HOLDIR + val exec = OS.Process.system + val filename = "/tmp/hol_commit" + val _ = exec ("cd " ^ path ^ + "; git log --abbrev-commit -n 1 | head -n 1 > " ^ filename) + val t = TextIO.openIn(filename) + val commit = case TextIO.inputLine(t) of SOME s => s | NONE => fail() + val _ = TextIO.closeIn(t) + val _ = exec ("/bin/rm -f " ^ filename) + val remove_newline = + String.translate (fn c => if c = #"\n" then "" else implode [c]) + in remove_newline commit end handle Interrupt => raise Interrupt + | _ => failwith("Cannot read commit number.") + +fun HOL_version () = + Globals.release ^ " " ^ int_to_string Globals.version ^ + " (" ^ Thm.kernelid ^ ") " ^ (HOL_commit () handle HOL_ERR e => #message e) + +fun add_missing_sig x = let + val _ = print ("No signature info for section: " ^ x ^ "\n") + in (missing_sigs := x :: (!missing_sigs)) end; + +fun read_complete_sections filename filename_sigs ignore = let + (* helper functions *) + fun try_map f [] = [] + | try_map f (x::xs) = (f x :: try_map f xs) handle HOL_ERR _ => try_map f xs + (* read basic section info *) + val xs = lines_from_file filename + fun is_hex_char c = mem c (explode "0123456789abcdefABCDEF") + fun is_hex_string str = every is_hex_char (explode str) + fun dest_section_declaration line = let + val hex = String.substring(line,0,8) + val _ = String.substring(line,8,2) = " <" orelse fail() + val rest = String.substring(line,10,size line - 10) + val sec_name = hd (String.tokens (fn x => x = #">") rest) + in (hex,sec_name) end handle Empty => fail() + | Subscript => fail() + val ys = drop_until (can dest_section_declaration) xs + fun split_by_sections [] = [] + | split_by_sections (y::ys) = + if y = "\n" then split_by_sections ys else (let + val (location,sec_name) = dest_section_declaration y + val body = take_until (fn x => x = "\n") ys + val ys = drop_until (fn x => x = "\n") ys + in (sec_name,location,body) :: split_by_sections ys end + handle HOL_ERR _ => split_by_sections ys) + val all_sections = split_by_sections ys + (* read in signature file *) + val ss = lines_from_file filename_sigs + fun process_sig_line line = let + val ts0 = String.tokens (fn x => mem x [#" ",#"\n"]) line + val ts = filter (fn s => s <> "struct") ts0 + val sec_name = el 2 ts + val returns_struct = (hd ts0 = "struct") + val ret_length = if hd ts = "0" then 0 else max(string_to_int (hd ts),4) div 4 + val arg_lengths = map string_to_int (tl (tl ts)) + val arg_lengths = map (fn x => max(x,4) div 4) arg_lengths + in (sec_name,(arg_lengths,ret_length,returns_struct)) end + val ss_alist = map process_sig_line ss + (* combine section info with signatures *) + fun lookup x [] = (add_missing_sig; fail()) + | lookup x ((y,z)::ys) = if x = y then z else lookup x ys + fun combine_ss (sec_name,location,body) = + (sec_name,lookup (hd (String.tokens (fn x => x = #".") sec_name)) ss_alist,location,body) + val all_sections = try_map combine_ss all_sections + (* function that cleans names *) + val remove_dot = + String.translate (fn c => if mem c [#".",#" "] then "_" else implode [c]) + (* process section bodies *) + fun process_body (sec_name,io,location,body) = let + val lines = body + fun find_first i c s = if String.sub(s,i) = c then i else find_first (i+1) c s + fun split_at c s = + (String.substring(s,0,find_first 0 c s), + String.extract(s,find_first 0 c s+1,NONE)) + fun is_subroutine_call s3 = + (String.isPrefix "bl" s3 andalso not (String.isPrefix "bls" s3) + andalso not (String.isPrefix "ble" s3) + andalso not (String.isPrefix "blt" s3)) orelse let + val ts = String.tokens (fn c => mem c [#"<",#">"]) s3 + in 1 < length ts andalso not (el 2 ts = sec_name) andalso + length (String.tokens (fn x => x = #"+") (el 2 ts)) < 2 end + fun format_line line = let + val (s1,s2) = split_at #":" line + val s2 = String.extract(s2,1,NONE) + val (s2,s3) = split_at #"\t" s2 + val s3 = String.extract(s3,0,SOME (size s3 - 1)) + val i = Arbnum.toInt(Arbnum.fromHexString s1) + val s2 = if String.isPrefix ".word" s3 then "const:" ^ s2 else s2 + val s2 = if String.isPrefix "ldrls\tpc," s3 then "switch:" ^ s2 else s2 + val s2 = ((if is_subroutine_call s3 + then "call:" ^ remove_dot + (el 2 (String.tokens (fn x => mem x [#"<",#">"]) s3)) ^ ":" ^ s2 + else s2) + handle HOL_ERR _ => s2) + val f = String.translate (fn c => if c = #" " then "" else + implode [c]) + in (i,f s2,s3) end + in (remove_dot sec_name,io,location, + if mem sec_name ignore then [] else map format_line body) end + val all_sections = map process_body all_sections + (* location function *) + fun update x y f a = if x = a then y else f a + val find_section = foldl (fn ((sec_name,_,location,_),x) => update location sec_name x) (fn x => fail()) all_sections + (* calculate dependencies *) + fun get_deps (sec_name,io,location,body) = let + val calls = body + |> filter (fn (_,s,_) => String.isPrefix "call:" s) + |> map (fn (_,s,_) => el 2 (String.tokens (fn x => x = #":") s) handle Subscript => "") + |> filter (fn s => length (String.tokens (fn x => x = #"+") s) < 2) + val consts = body + |> filter (fn (_,s,_) => String.isPrefix "const:" s) + |> map (fn (_,s,_) => el 2 (String.tokens (fn x => x = #":") s) handle Subscript => "") + |> try_map find_section + val deps = all_distinct (calls @ consts) + in (sec_name,io,location,body,deps) end + val all_sections = map get_deps all_sections + (* annotate constants with function names whenever they match *) + fun annotate_consts (sec_name,io,location,body,deps) = let + fun annotate (x,line,y) = let + val _ = String.isPrefix "const:" line orelse fail() + val c = el 2 (String.tokens (fn x => x = #":") line) + val sec_name = find_section c + in (x,line ^ ":" ^ sec_name,y) end handle HOL_ERR _ => (x,line,y) + in (sec_name,io,location,map annotate body,deps) end + val all_sections = map annotate_consts all_sections + fun compare_secs (_,_,_,body1,deps1) (_,_,_,body2,deps2) = + if length deps1 < length deps2 then true else + if length deps2 < length deps1 then false else + (length body1 <= length deps2) + val arch = let + fun has_short_instr (_,_,_,lines,_) = + exists (fn (_,hex,_) => size hex < 8) lines + in if exists has_short_instr all_sections then M0 else ARM end + val _ = (arch_name := arch) + in complete_sections := sort compare_secs all_sections end + +fun section_info sec_name = let + fun f [] = failwith ("Can't find info for section: " ^ sec_name) + | f ((name,io,location,body,deps)::xs) = + if sec_name = name then (io,(location,(body,deps))) else f xs + in f (!complete_sections) end + +fun section_names () = + map (fn (sec_name,io,location,body,deps) => sec_name) (!complete_sections); + +val section_io = fst o section_info +val section_location = fst o snd o section_info +val section_body = fst o snd o snd o section_info +fun section_deps name = (snd o snd o snd o section_info) name handle HOL_ERR _ => [] +fun section_length name = length (section_body name) handle HOL_ERR _ => 0 + +(* + val base_name = "/Users/mom22/graph-decompiler/loop-m0/example" +*) + +fun read_files base_name ignore = let + val _ = set_base (base_name ^ "_") + fun n_times 0 f x = x | n_times n f x = n_times (n-1) f (f x) + val long_line = n_times 70 (fn x => "=" ^ x) "\n" + val _ = print long_line + val _ = print (" Base name: "^base_name^"\n") + val _ = print (" Poly/ML: "^(int_to_string (PolyML.rtsVersion()))^"\n") + val _ = print (" HOL: "^(HOL_version ())^"\n") + val _ = print long_line + (* file names *) + fun get_filename suffix = base_name ^ suffix; + val filename = get_filename ".elf.txt"; + val filename_sigs = get_filename ".sigs"; + (* read sections *) + val () = read_complete_sections filename filename_sigs ignore +(* + (* read md5sum *) + val (md5sum,date_now) = let + fun drop_newline_char s = let + val xs = s |> explode + in if last xs = #"\n" then xs |> butlast |> implode else s end + val raw = map drop_newline_char (lines_from_file filename_md5) + val m = hd raw + val d = hd (tl raw) + in (m,d) end; + val _ = print long_line + val _ = print (" md5: "^md5sum^"\n") +*) + (* print stats *) + val f = print + val names = section_names () + val lengths = map (fn n => (n, (length o section_body) n)) names + val _ = print long_line + val names_count = (int_to_string (length names)) + val inst_count = (int_to_string (sum (map snd lengths))) + val _ = f (" Total: " ^ names_count ^ " functions, " ^ inst_count ^ + " " ^ arch_str () ^ " instructions\n") + fun list_max [] = fail() + | list_max [x] = x + | list_max ((x,x1)::(y,y1)::xs) = + if x1 < y1 then list_max ((y,y1)::xs) else list_max ((x,x1)::xs) + val (longest_name,l) = list_max lengths + val _ = f (" Longest function: " ^ longest_name ^ " (" ^(int_to_string l) ^ + " instructions)\n") + val dep_counts = map (length o section_deps) names |> all_distinct + fun print_dep_count_line n = let + fun max_string_length n [] s = s + | max_string_length n (x::xs) s = + if size (s ^ ", " ^ x) < n then + max_string_length n xs (s ^ ", " ^ x) else s ^ ", ..." + val deps = filter (fn s => length (section_deps s) = n) names + val s = " " ^ int_to_string n ^ " deps: " ^ int_to_string (length deps) ^ + " functions (" + in max_string_length 65 (tl deps) (s ^ hd deps) ^ ")\n" end + val _ = map (print o print_dep_count_line) dep_counts + val _ = print long_line + in () end; + +val int_to_hex = (fn s => "0x" ^ s) o to_lower o + Arbnum.toHexString o Arbnum.fromInt + +fun show_annotated_code ann sec_name = let + val code = section_body sec_name + val l = hd code |> #1 + val code = map (fn (x,y,z) => (x,x-l,z)) code + val loc_width = last code |> #1 |> int_to_hex |> size + val offset_width = (last code |> #2 |> int_to_hex |> size) + 4 + fun left_pad k s = if size s < k then left_pad k (" " ^ s) else s + fun right_pad k s = if size s < k then right_pad k (s ^ " ") else s + fun line (loc,offset,asm) = let + val s1 = left_pad loc_width (int_to_hex loc) + val s2 = left_pad offset_width (int_to_hex offset) + val asm = String.tokens (fn c => c = #";") asm |> hd + |> String.translate (fn c => if c = #"\t" then " " else implode [c]) + val s3 = right_pad 20 asm ^ " ; " ^ ann loc handle HOL_ERR _ => asm + in s1 ^ s2 ^ " " ^ s3 ^ "\n" end + val _ = write_blank_line () + val _ = write_indented_block (concat (map line code)) + val _ = write_blank_line () + in () end + +val show_code = show_annotated_code (fn x => fail()) + +(* tools *) + +val () = arm_progLib.arm_config "vfp" "mapped" +val arm_tools = arm_decompLib.l3_arm_tools +val (arm_spec,_,_,_) = arm_tools + +val () = m0_progLib.m0_config false (* not bigendian *) "mapped" +val m0_tools = m0_decompLib.l3_m0_tools +val (m0_spec,_,_,_) = m0_tools + +fun get_tools () = + case !arch_name of + ARM => arm_tools + | M0 => m0_tools ; + +end diff --git a/examples/machine-code/graph/func_decompileLib.sml b/examples/machine-code/graph/func_decompileLib.sml new file mode 100644 index 0000000000..bf57469379 --- /dev/null +++ b/examples/machine-code/graph/func_decompileLib.sml @@ -0,0 +1,215 @@ +structure func_decompileLib = +struct + +open HolKernel boolLib bossLib Parse; +open listTheory wordsTheory pred_setTheory arithmeticTheory wordsLib pairTheory; +open set_sepTheory progTheory helperLib addressTheory combinTheory; + +open GraphLangTheory graph_specsLib exportLib writerLib cond_cleanLib; + + +infix \\ val op \\ = op THEN; + +val _ = max_print_depth := ~1; +val _ = set_trace "Unicode" 0; + +local + val export_fails = ref ([]:string list) +in + fun add_export_fail sec_name = (export_fails := sec_name :: (!export_fails)) + fun get_export_fails () = rev (!export_fails) + fun clear_export_fails () = (export_fails := []) +end; + +fun func_export sec_name th funcs_def = let + val f = th |> concl |> rand + val name = sec_name + val rhs = ``func_body_trans ^f`` + val lhs = mk_var(name,type_of rhs) + val trans_def = new_definition(name,mk_eq(lhs,rhs)) + val _ = write_subsection "Evaluating graph" + val c = REWRITE_CONV [func_body_trans_def,func_trans_def,funcs_def] + THENC EVAL THENC PURE_REWRITE_CONV [GSYM word_sub_def] + THENC prepare_for_export_conv + val lemma = trans_def |> CONV_RULE (RAND_CONV c) + val xs = lemma |> concl |> rand |> rator |> rand |> rand + |> listSyntax.dest_list |> fst + val node_count = length xs |> int_to_string + val msg = "The graph for `" ^ sec_name ^ "` has " ^ node_count ^ " nodes." + val _ = write_line msg + val _ = (writer_prints := false) + val _ = map write_term xs + val _ = (writer_prints := true) + val ml_name = export_func lemma + in (trans_def," o " ^ ml_name) end + handle HOL_ERR _ => let + val _ = print ("Export FAILED for " ^ sec_name ^ ".\n") + val _ = add_export_fail sec_name + in (TRUTH,"") end; + +fun print_title (s:string) = () + +fun get_loction_as_word sec_name = let + val tm = section_location sec_name + |> Arbnumcore.fromHexString |> numSyntax.mk_numeral + in ``n2w (^tm):word32`` end + +fun func_decompile print_title sec_name = let + val _ = (writer_prints := true) + val _ = open_current sec_name + val _ = print_title sec_name + val thms = derive_insts_for sec_name +(* val thms = clean_conds thms *) + val code = thms |> hd |> concl |> rator |> rator |> rand + handle Empty => (if !arch_name = ARM + then ``(ARM {}):code`` + else ``(M0 {}):code``) + val lemma = prove(``LIST_IMPL_INST ^code locs []``, + SIMP_TAC std_ss [LIST_IMPL_INST_def]) + fun combine [] = lemma + | combine (th::thms) = + MATCH_MP IMP_LIST_IMPL_INST (CONJ th (combine thms)) + val th = combine thms + val entry = th |> concl |> rand |> rator |> rand + |> rator |> rator |> rand + handle HOL_ERR _ => get_loction_as_word sec_name + val th = MATCH_MP IMP_func_ok th |> Q.INST [`entry`|->`^entry`] + val goal = th |> concl |> dest_imp |> fst + val lemma = auto_prove "inst_locs_distinct" + (goal,REWRITE_TAC [MAP,inst_loc_def] \\ EVAL_TAC) + val th = MP th lemma + val entry = th |> concl |> rand |> rand |> listSyntax.dest_cons |> fst + |> rator |> rator |> rand + handle HOL_ERR _ => get_loction_as_word sec_name + val name = stringSyntax.fromMLstring sec_name + val th = th |> Q.INST [`name`|->`^name`,`entry`|->`^entry`] + val funcs_def_rhs = th |> concl |> rand |> rand + val funcs_name = sec_name ^ "_funcs" + val funcs_def_lhs = mk_var(funcs_name,type_of funcs_def_rhs) + val funcs_def = new_definition(funcs_name,``^funcs_def_lhs = ^funcs_def_rhs``) + val th = CONV_RULE (RAND_CONV (RAND_CONV (REWR_CONV (GSYM funcs_def)))) th + in (th,func_export sec_name th funcs_def) end + +fun list_mk_union [] = ``{}:'a set`` + | list_mk_union [x] = x + | list_mk_union (x::xs) = pred_setSyntax.mk_union(list_mk_union xs,x) + +(* + val sec_name = "bi_finalise" +*) + +fun prove_funcs_ok names = let + val _ = clear_stack_intro_fails () + val _ = clear_graph_spec_fails () + val _ = clear_export_fails () + fun print_title sec_name = let + fun find_index [] = ~2000 + | find_index (x::xs) = if x = sec_name then 1 else find_index xs + 1 + val i = find_index names + val str = "Section " ^ sec_name ^ " (" ^ + int_to_string i ^ " of " ^ int_to_string (length names) ^ ")" + in write_section str end + (* decompile all sections *) + val fs_and_trans_defs = map (func_decompile print_title) names + val fs = map fst fs_and_trans_defs + (* abbreviate all codes *) + val all_code = fs |> map (rand o rator o rator o concl) + val code_name = all_code |> hd |> rator + val all_code = mk_comb(code_name, (all_code |> map rand |> list_mk_union)) + val all_code_def = new_definition("all_code",``all_code = ^all_code``); + val code_case_of = TypeBase.case_def_of ``:code``; + val pair_case_of = TypeBase.case_def_of ``:'a # 'b``; + fun expend_code th = let + val th = MATCH_MP func_ok_EXPEND_CODE th |> Q.SPEC `all_code` + val goal = th |> concl |> dest_imp |> fst + val lemma = auto_prove "expand_code" (goal, + REWRITE_TAC [all_code_def,SUBSET_DEF,IN_UNION,code_case_of,pair_case_of] + \\ CONV_TAC (DEPTH_CONV BETA_CONV) + \\ REWRITE_TAC [all_code_def,SUBSET_DEF,IN_UNION,code_case_of,pair_case_of] + \\ CONV_TAC (DEPTH_CONV BETA_CONV) + \\ REWRITE_TAC [all_code_def,SUBSET_DEF,IN_UNION,code_case_of,pair_case_of] + \\ REPEAT STRIP_TAC \\ ASM_REWRITE_TAC []) + in MP th lemma end + val fs = map expend_code fs + (* package up into funcs_ok *) + val code = fs |> hd |> concl |> rator |> rator |> rand + val funcs = listSyntax.mk_list(fs |> map (rand o concl),``:func``) + val lemma = prove(``EVERY (func_ok ^code locs) []``, + SIMP_TAC std_ss [EVERY_DEF]) + fun combine [] = lemma + | combine (th::thms) = + MATCH_MP IMP_EVERY_func_ok (CONJ th (combine thms)) + val th = combine fs + val funcs = th |> concl |> rand + val th = th |> Q.INST [`locs`|->`fs_locs ^funcs`] + |> CONV_RULE (REWR_CONV (GSYM funcs_ok_def)) + |> DISCH_ALL |> DISCH T + |> PURE_REWRITE_RULE [fs_locs_def,AND_IMP_INTRO] + val goal = th |> concl |> dest_imp |> fst + val _ = write_line "" + val _ = write_section "Proving correctness of call offsets" + fun prove_fs_locs goal = + if goal = T then (TRUTH,true) else + if is_conj goal then let + val (x,y) = dest_conj goal + val (th1,s1) = prove_fs_locs x + val (th2,s2) = prove_fs_locs y + in (CONJ th1 th2, s1 andalso s2) end + else (MATCH_MP EQ_T (EVAL goal), true) + handle HOL_ERR _ => let + val (lhs,rhs) = dest_eq goal + val name = lhs |> rand |> stringSyntax.fromHOLstring + val v = optionSyntax.dest_some rhs |> rand + |> numSyntax.int_of_term |> int_to_hex + val _ = write_line ("Failed to prove that " ^ name ^ " is at " ^ v ^ ".") + in (mk_thm([],goal),false) end + handle HOL_ERR _ => failwith "internal error" + val (lemma,fs_locs_success) = prove_fs_locs goal + val th = MP th lemma + fun print_fs_locs_success () = + write_line (if fs_locs_success + then "No call offset failures." + else "Failed to prove correctness of some call offsets.") + val _ = if fs_locs_success then write_line "Offsets proved correct." else () + (* export top-level graph definition *) + val funcs = th |> concl |> rand + val trans_defs = map (fst o snd) fs_and_trans_defs + val name = "complete_graph" + val _ = open_current name + val rhs = ``list_func_trans ^funcs`` + val lhs = mk_var(name,type_of rhs) + val graph = new_definition(name,mk_eq(lhs,rhs)) + val c = REWRITE_CONV [list_func_trans_thm] THENC EVAL + THENC REWRITE_CONV (map GSYM trans_defs) + THENC prepare_for_export_conv + val lemma = graph |> CONV_RULE (RAND_CONV c) + val _ = write_section "Summary" + val _ = print_stack_intro_report () + val _ = print_graph_spec_report () + val _ = print_export_report () + val _ = print_fs_locs_success () + val _ = close_current () + in th end + +(* + + val base_name = "loop-m0/example" + val base_name = "kernel-gcc-O1/kernel" + val () = read_files base_name ["f"] + val _ = (skip_proofs := true) + val _ = (skip_proofs := false) + val names = section_names() + local val randgen = Random.newgen() + in fun get_rand_name () = + el (Random.range(1,length names) randgen) names end + + val _ = func_decompile print_title (get_rand_name ()); + val _ = func_decompile print_title sec_name; + + val _ = max_print_depth := 5; + + val th = prove_funcs_ok names + +*) + +end diff --git a/examples/machine-code/graph/graph_specsLib.sml b/examples/machine-code/graph/graph_specsLib.sml new file mode 100644 index 0000000000..c910dba98e --- /dev/null +++ b/examples/machine-code/graph/graph_specsLib.sml @@ -0,0 +1,451 @@ +structure graph_specsLib = +struct + +open HolKernel boolLib bossLib Parse; +open listTheory wordsTheory pred_setTheory arithmeticTheory wordsLib pairTheory; +open set_sepTheory progTheory helperLib addressTheory combinTheory; + +open backgroundLib file_readerLib derive_specsLib stack_introLib writerLib; + +open GraphLangTheory + +infix \\ val op \\ = op THEN; + +val code_case_of = TypeBase.case_def_of ``:code``; + +val emp_pat = ``emp:'a set set`` +val s_var = mk_var("s",``:state``) + +fun get_pc_pat () = let + val (_,_,_,pc) = get_tools () + in ``^pc w`` end + +local + val var_bool_pat = ``var_bool n s`` + val var_nat_pat = ``var_nat n s`` + val var_word8_pat = ``var_word8 n s`` + val var_word32_pat = ``var_word32 n s`` + val var_mem_pat = ``var_mem n s`` +in + fun var_lookup tm = + can (match_term var_bool_pat) tm orelse + can (match_term var_nat_pat) tm orelse + can (match_term var_word8_pat) tm orelse + can (match_term var_word32_pat) tm orelse + can (match_term var_mem_pat) tm + fun mk_update (x,y) = + if can (match_term var_bool_pat) x then + pairSyntax.mk_pair(x |> rator |> rand,mk_abs(s_var,mk_comb(``VarBool``,y))) + else if can (match_term var_nat_pat) x then + pairSyntax.mk_pair(x |> rator |> rand,mk_abs(s_var,mk_comb(``VarNat``,y))) + else if can (match_term var_word8_pat) x then + pairSyntax.mk_pair(x |> rator |> rand,mk_abs(s_var,mk_comb(``VarWord8``,y))) + else if can (match_term var_word32_pat) x then + pairSyntax.mk_pair(x |> rator |> rand,mk_abs(s_var,mk_comb(``VarWord32``,y))) + else if can (match_term var_mem_pat) x then + pairSyntax.mk_pair(x |> rator |> rand,mk_abs(s_var,mk_comb(``VarMem``,y))) + else failwith "should not happen (mk_update)" +end + +local + val arm_state_inst = arm_STATE_thm |> concl |> find_terms var_lookup + |> map (fn tm => + let + val str = tm |> rator |> rand |> stringSyntax.fromHOLstring + val ty = type_of tm + in mk_var(str,ty) |-> tm end) + |> (fn x => (``dmem:word32 set`` |-> + ``(var_dom "dom" s):word32 set``):: + (``dom_stack:word32 set`` |-> + ``(var_dom "dom_stack" s):word32 set``):: + (``mode:word5`` |-> + ``w2w (var_word8 "mode" s):word5``)::x) |> INST + val arm_state = arm_STATE_thm |> concl |> rator |> rand + val arm_state_parts = arm_STATE_thm |> concl |> rand |> list_dest dest_star + val arm_state_type = arm_state_parts |> hd |> type_of + val arm_state_combs = map (fn tm => (rator tm,rand tm)) arm_state_parts + val arm_state_thm = arm_STATE_thm + val m0_state_inst = m0_STATE_thm |> concl |> find_terms var_lookup + |> map (fn tm => + let + val str = tm |> rator |> rand |> stringSyntax.fromHOLstring + val ty = type_of tm + in mk_var(str,ty) |-> tm end) + |> (fn x => (``dmem:word32 set`` |-> + ``(var_dom "dom" s):word32 set``):: + (``dom_stack:word32 set`` |-> + ``(var_dom "dom_stack" s):word32 set``):: + (mk_var("count",``:num``) |-> + ``(var_nat "clock" s):num``):: + (``mode:Mode`` |-> + ``Mode_Thread:Mode``)::x) |> INST + val m0_state = m0_STATE_thm |> concl |> rator |> rand + val m0_state_parts = m0_STATE_thm |> concl |> rand |> list_dest dest_star + val m0_state_type = m0_state_parts |> hd |> type_of + val m0_state_combs = map (fn tm => (rator tm,rand tm)) m0_state_parts + val m0_state_thm = m0_STATE_thm +in + fun state_tools () = + case (!arch_name) of + ARM => (arm_state_inst, arm_state, arm_state_parts, + arm_state_type, arm_state_combs, arm_state_thm) + | M0 => (m0_state_inst, m0_state, m0_state_parts, m0_state_type, + m0_state_combs, m0_state_thm) +end + +val STATE_INTRO_RULE_input = ref TRUTH +(* + val th = !STATE_INTRO_RULE_input +*) +fun STATE_INTRO_RULE th = let + val (state_inst, state, state_parts, + state_type, state_combs, state_thm) = state_tools () + val pc_pat = get_pc_pat () + val th = th |> SIMP_RULE (std_ss++sep_cond_ss) [] + |> REWRITE_RULE [SPEC_MOVE_COND] |> UNDISCH_ALL + |> Q.INST [`curr`|->`stack`] + (* make pre into just ``STATE s`` *) + val th = state_inst th + val (_,pre,_,_) = dest_spec (concl th) + val ps = list_dest dest_star pre + val pc = first (can (match_term pc_pat)) ps + val missing_parts = diff state_parts ps + val frame = list_mk_star missing_parts state_type + val th = SPEC_FRAME_RULE th frame + val (_,pre,_,_) = dest_spec (concl th) + val goal = mk_eq(pre,mk_star(state,pc)) + val conv = PURE_REWRITE_CONV [state_thm,emp_STAR] THENC + BINOP_CONV STAR_AC_CONV THENC REWRITE_CONV [] + val lemma = auto_conv_prove "STATE_INTRO_RULE - 1" goal conv + val th = th |> CONV_RULE (PRE_CONV (REWR_CONV lemma)) + (* make post into just state *) + val th = PURE_REWRITE_RULE [STAR_IF] th + val (_,_,_,post) = dest_spec (concl th) + fun fix_post_conv post = let + val ps = list_dest dest_star post + val pc = first (can (match_term pc_pat)) ps + val ps = filter (not o can (match_term pc_pat)) ps + val ps = filter (not o can (match_term emp_pat)) ps + fun find_match x [] = fail () + | find_match x ((n,y)::xs) = + if x = n then y else find_match x xs + fun find_all_matches tm = + [(find_match (rator tm) state_combs,rand tm)] + handle HOL_ERR _ => let + val x = repeat rator tm + val y = first (fn tm => x = repeat rator tm) state_parts + fun dest_app tm = let + val (x,y) = dest_comb tm + val (f,xs) = dest_app x + in (f,xs @ [y]) end handle HOL_ERR _ => (tm,[]) + val xs = zip (dest_app y |> snd) (dest_app tm |> snd) + in xs end + val qs = ps |> map find_all_matches |> flatten + |> filter (fn (x,y) => x <> y) |> all_distinct + val new_s = listSyntax.mk_list( + foldl (fn ((x,y),s) => mk_update(x,y)::s) [] qs, + ``:string # (state -> variable)``) + val new_s = ``apply_update ^new_s ^s_var`` + val goal = mk_eq(post,mk_star(mk_comb(rator state,new_s),pc)) + val conv = (REWRITE_CONV [state_thm,var_update_thm, + apply_update_def, + CONS_11,NOT_CONS_NIL,GSYM NOT_CONS_NIL] + THENC (DEPTH_CONV stringLib.string_EQ_CONV) + THENC REWRITE_CONV [] THENC SIMP_CONV (srw_ss()) [] + THENC PURE_REWRITE_CONV [state_thm,emp_STAR] + THENC BINOP_CONV STAR_AC_CONV THENC REWRITE_CONV []) + val lemma = auto_conv_prove "STATE_INTRO_RULE - 2" goal conv + in lemma end + fun fix_if_post_conv post = + if is_cond post then BINOP_CONV fix_if_post_conv post + else fix_post_conv post + val th = th |> CONV_RULE (POST_CONV fix_if_post_conv) + in th end + handle HOL_ERR e => + (STATE_INTRO_RULE_input := th; + report_error "STATE_INTRO_RULE" (HOL_ERR e)) + +fun write_transform th1 th2_opt th_res = let + val clean_th = REWRITE_RULE [] o DISCH_ALL + val _ = write_line "Proved:" + val _ = write_thm (clean_th th_res) + val _ = write_line "Using:" + val _ = write_thm (clean_th th1) + val _ = (case th2_opt of NONE => () | SOME th => write_thm (clean_th th)) + in th_res end + +fun mk_code_term c = + case (!arch_name) of ARM => ``ARM ^c`` | M0 => ``M0 ^c``; + +val make_ASM_input = ref TRUTH; +val make_CALL_input = ref TRUTH; +val make_SWITCH_input = ref TRUTH; + +local + fun read_pc_assum hs = let + val h = first (can (match_term ``var_word32 "pc" s = w``)) hs + in (h |> rand,filter (fn tm => tm <> h) hs) end + fun read_pc_update th = let + val tm = find_term (can (match_term ``("pc" =+ VarWord32 (n2w n))``)) + (concl th) |> rand |> rand + in (mk_comb(``Jump``,tm),th) end + handle HOL_ERR _ => let + val tm = find_term (can (match_term ``("pc" =+ pat)``)) (concl th) + val x = ``var_word32 "ret" s`` + val assum = mk_eq(tm |> rand,``^s_var "ret"``) + val rw = RAND_CONV (fn tm => ASSUME assum) tm + val th = RW1 [rw] th + in (``Return``,th) end + fun read_state_update th = let + val (_,_,_,q) = dest_spec (concl th) + in q |> rand end + val simp = SIMP_CONV std_ss [IMPL_INST_def,exec_next_def,CONS_11,NOT_CONS_NIL, + check_jump_def,get_assert_def,APPLY_UPDATE_THM, + stringTheory.CHR_11,code_case_of] + fun has_call_tag th = + can (find_term (can dest_call_tag)) (concl (DISCH_ALL th)) + val ret_and_all_names = + ret_and_all_names_def |> concl |> rand + |> REWRITE_CONV [all_names_def,APPEND] |> concl |> rand + |> listSyntax.dest_list |> fst + fun dest_supdate tm = + listSyntax.dest_list tm |> fst |> map pairSyntax.dest_pair + fun prepare_supdate_for_call th = let + val (_,pre,_,post) = dest_spec (concl th) + val pc1 = pre |> rand |> rand + val tm = post |> rator |> rand |> rand |> rator |> rand + val supdate = dest_supdate tm + val r0 = ``"r0"`` + val r14 = ``"r14"`` + val ret_str = ``"ret"`` + val r0_input_str = ``"r0_input"`` + val (is_tail_call,ret) = let + val u = first (fn (t,x) => t = r14) supdate |> snd + val res = EVAL ``(^u s = VarWord32 (^pc1+4w)) \/ (^u s = VarWord32 (^pc1+2w))`` + |> concl |> rand + in if res = T then + (false,mk_comb(``Jump``,u |> dest_abs |> snd |> rand)) + else (true,``Return``) end handle HOL_ERR _ => (true,``Return``) + fun get_assign tm = + if tm = r0_input_str then + pairSyntax.mk_pair(r0_input_str,``var_acc ^r0``) + else let + val tm2 = if is_tail_call then tm else + if tm = ret_str then r14 else tm + val rhs = first (fn (t,x) => (t = tm2)) supdate |> snd + handle HOL_ERR _ => ``var_acc ^tm`` + in pairSyntax.mk_pair(tm,rhs) end + val new_supdate = map get_assign ret_and_all_names + val new_supdate = listSyntax.mk_list(new_supdate,type_of (hd new_supdate)) + val x = post |> rator |> rand |> rator + val goal = ``^x (apply_update ^tm s) = ^x (apply_update ^new_supdate s)`` + val lemma = auto_prove "prepare_supdate_for_call" (goal, + TRY (MATCH_MP_TAC arm_STATE_all_names) + \\ TRY (MATCH_MP_TAC m0_STATE_all_names) + \\ REWRITE_TAC [all_names_def,EVERY_DEF,apply_update_def, + combinTheory.APPLY_UPDATE_THM,var_acc_def] + \\ CONV_TAC (DEPTH_CONV BETA_CONV) + \\ CONV_TAC (DEPTH_CONV stringLib.string_EQ_CONV) + \\ REWRITE_TAC [all_names_def,EVERY_DEF,apply_update_def, + combinTheory.APPLY_UPDATE_THM,var_acc_def]) + val th = CONV_RULE ((RAND_CONV o RATOR_CONV o RAND_CONV) + (REWR_CONV lemma)) th + in (th,ret) end +(* + val th = !make_CALL_input +*) + fun make_CALL th = let + val th = STATE_INTRO_RULE th + val hs = filter (fn tm => tm <> T) (hyp th) + val tag = first (can dest_call_tag) hs + val fname = fst (dest_call_tag tag) + val th = th |> DISCH_ALL |> PURE_REWRITE_RULE [CALL_TAG_def] |> UNDISCH_ALL + val (_,pre,_,post) = dest_spec (concl th) + val pc1 = pre |> rand |> rand + val pc2 = post |> rand |> rand + val supdate = post |> rator |> rand |> rand |> rator |> rand + val hs = filter (fn tm => tm <> T) (hyp th) + val side = if length hs = 0 then ``NONE:(state->bool) option`` + else ``SOME ^(mk_abs(s_var,list_mk_conj hs))`` + val (th,ret) = prepare_supdate_for_call th + val (_,pre,_,post) = dest_spec (concl th) + val supdate = post |> rator |> rand |> rand |> rator |> rand + val name = stringSyntax.fromMLstring fname + val i = ``Inst ^pc1 (K T) (CALL ^side ^supdate ^name ^ret)`` + val (m,_,c,_) = dest_spec (concl th) + val goal = ``(locs ^name = SOME ^pc2) ==> IMPL_INST ^(mk_code_term c) locs ^i`` +(* + set_goal([],goal) +*) + val lemma = auto_prove "make_CALL" (goal, + CONV_TAC simp \\ REPEAT STRIP_TAC \\ IMP_RES_TAC ret_lemma + \\ ASM_SIMP_TAC std_ss [code_case_of] + \\ NTAC 20 (ONCE_REWRITE_TAC [var_word32_apply_update]) + \\ CONV_TAC (DEPTH_CONV stringLib.string_EQ_CONV) + \\ ASM_REWRITE_TAC [apply_update_NIL] + \\ SIMP_TAC std_ss [next_ok_def,check_ret_def] + \\ TRY (REWRITE_TAC [ret_and_all_names_def,all_names_def,MAP,APPEND] + \\ REWRITE_TAC [all_names_def,EVERY_DEF,apply_update_def, + combinTheory.APPLY_UPDATE_THM,var_acc_def,var_word32_def] + \\ EVAL_TAC \\ NO_TAC) + \\ (DISCH_ALL th |> DISCH T + |> PURE_REWRITE_RULE [AND_IMP_INTRO] |> MATCH_MP_TAC) + \\ ASM_REWRITE_TAC [] \\ FULL_SIMP_TAC (srw_ss()) []) + val th = lemma |> UNDISCH_ALL |> SIMP_RULE std_ss [word_add_n2w] + in th end + handle HOL_ERR e => + (make_CALL_input := th; + report_error "make_CALL" (HOL_ERR e)) +(* + val th = !make_ASM_input +*) + fun make_ASM th = + if has_call_tag th then make_CALL th else let + val th = STATE_INTRO_RULE th + val (_,pre,_,post) = dest_spec (concl th) + val pc1 = pre |> rand |> rand + val pc2 = post |> rand |> rand + val supdate = post |> rator |> rand |> rand |> rator |> rand + val (jmp,th) = if wordsSyntax.is_n2w pc2 then (``Jump ^pc2``,th) else + (``Return``,let + val lemma = ASSUME (mk_eq(pc2,``var_word32 "ret" s``)) + in CONV_RULE (RAND_CONV (RAND_CONV (RAND_CONV (fn tm => lemma)))) th end) + val hs = filter (fn tm => tm <> T) (hyp th) + val side = if length hs = 0 then ``NONE:(state->bool) option`` + else ``SOME ^(mk_abs(s_var,list_mk_conj hs))`` + val i = ``Inst ^pc1 (K T) (ASM ^side ^supdate ^jmp)`` + val th = RW [apply_update_NIL] th + val (m,_,c,_) = dest_spec (concl th) + val goal = ``IMPL_INST ^(mk_code_term c) locs ^i`` +(* + set_goal([],goal) +*) + val lemma = auto_prove "make_ASM" (goal, + CONV_TAC simp \\ REPEAT STRIP_TAC \\ IMP_RES_TAC ret_lemma + \\ ASM_SIMP_TAC std_ss [code_case_of] + \\ NTAC 20 (ONCE_REWRITE_TAC [var_word32_apply_update]) + \\ CONV_TAC (DEPTH_CONV stringLib.string_EQ_CONV) + \\ ASM_REWRITE_TAC [apply_update_NIL] THEN1 EVAL_TAC THEN1 EVAL_TAC + \\ (DISCH_ALL th |> DISCH T + |> PURE_REWRITE_RULE [AND_IMP_INTRO] |> MATCH_MP_TAC) + \\ ASM_REWRITE_TAC [] \\ FULL_SIMP_TAC (srw_ss()) []) + in lemma end + handle HOL_ERR e => + (make_ASM_input := th; + report_error "make_ASM" (HOL_ERR e)) +(* + val th = !make_SWITCH_input +*) + fun make_SWITCH th = let + val th = STATE_INTRO_RULE th + (* val th = SIMP_RULE std_ss [Once EQ_SYM_EQ] th *) + val post = th |> concl |> rand + val pre = + th |> DISCH_ALL |> DISCH T |> PURE_REWRITE_RULE [AND_IMP_INTRO] + |> CONV_RULE ((RATOR_CONV o RAND_CONV) (REWRITE_CONV [])) + |> concl |> dest_imp |> fst + val pre = mk_abs(s_var,pre) + fun get_simp_asm x1 = let + val upd = x1 |> rator |> rand |> rand |> rator |> rand + val pc = x1 |> rand |> rand + in ``ASM (SOME ^pre) ^upd (Jump ^pc)`` end + fun dest_ifs post = let + val (g,x1,x2) = dest_cond post + val next1 = get_simp_asm x1 + val next2 = dest_ifs x2 + in ``IF (\s. ^g) ^next1 ^next2`` end + handle HOL_ERR _ => get_simp_asm post + val next = dest_ifs post + val pc1 = th |> concl |> rator |> rator |> rand |> rand |> rand + val i = ``Inst ^pc1 (K T) ^next`` + val (m,_,c,_) = dest_spec (concl th) + val goal = ``IMPL_INST ^(mk_code_term c) locs ^i`` + val lemma = auto_prove "make_SWITCH" (goal, + REWRITE_TAC [IMPL_INST_IF_SPLIT] + \\ CONV_TAC (DEPTH_CONV BETA_CONV) + \\ REPEAT STRIP_TAC + \\ CONV_TAC simp \\ REPEAT STRIP_TAC + \\ TRY (EVAL_TAC \\ NO_TAC) + \\ MP_TAC (DISCH_ALL th) + \\ ASM_REWRITE_TAC [] + \\ STRIP_TAC + \\ TRY (POP_ASSUM MATCH_MP_TAC) + \\ ASM_REWRITE_TAC [var_word32_def,var_acc_def] + \\ EVAL_TAC) + in lemma end + handle HOL_ERR e => + (make_SWITCH_input := th; + report_error "make_SWITCH" (HOL_ERR e)) +in + fun make_INST (i:int,(th,l:int,j:int option),NONE) = + write_transform th NONE + (if not (is_cond (rand (concl th))) + then make_ASM th else make_SWITCH th) + | make_INST (i,(th1',l',j'),SOME (th2',l:int,j:int option)) = let + val th1 = make_INST (i,(th1',l',j'),NONE) + val th2 = th2' |> make_ASM + val not_guard = th2 |> concl |> find_term (can (match_term ``ASM (SOME k)``)) + |> rand |> rand |> dest_abs |> snd + val guard = dest_neg not_guard handle HOL_ERR _ => mk_neg not_guard + val c = (RAND_CONV o RATOR_CONV o RAND_CONV) (SIMP_CONV std_ss []) + val th = MATCH_MP IMPL_INST_IF (CONJ th1 th2) + |> CONV_RULE (BINOP1_CONV (SIMP_CONV std_ss [])) + |> MATCH_MP T_IMP |> SPEC (mk_abs(s_var,guard)) + val th = RW1 [IMPL_INST_SIMP_IF] th + |> SIMP_RULE std_ss [IMPL_INST_IF_RW] + in write_transform th1' (SOME th2') th end +end + +(* +val (i:int,(th,l:int,j:int option),NONE) = + first (fn (i,(th,_,_),_) => i = 52) thms + +val (i:int,(th,l:int,j:int option),NONE) = thms |> el 2 + +val (_,(th1,_,_),SOME (th2,l:int,j:int option)) = first (not o can make_INST) thms + +*) + +fun try_map g f [] = [] + | try_map g f (x::xs) = let + val y = f x + in y :: try_map g f xs end + handle HOL_ERR _ => + (g x; try_map g f xs) + +val graph_spec_fails = ref ([] : (int * string) list); + +fun print_graph_spec_fail (pos,sec_name) = let + val str = ("Graph spec failed in " ^ sec_name ^ " for pos " ^ + (int_to_hex pos) ^ ".") + in (write_line str; print (str ^ "\n")) end + +fun add_graph_spec_fail pos sec_name = + (print_graph_spec_fail (pos,sec_name); + graph_spec_fails := (pos, sec_name) :: (!graph_spec_fails)); + +fun clear_graph_spec_fails () = (graph_spec_fails := []); + +fun print_graph_spec_report () = + (if length (!graph_spec_fails) = 0 then + (write_line "No graph spec failures."; []) + else (map print_graph_spec_fail (!graph_spec_fails))) + +fun get_pc_val th = let + val pc_pat = get_pc_pat () + val (_,p,_,_) = dest_spec (concl th) + in find_term (can (match_term pc_pat)) p + |> rand |> rand |> numSyntax.int_of_term end + +fun derive_insts_for sec_name = let + val thms = dervie_specs_for sec_name + val _ = write_subsection "Proving inst theorems" + val _ = (writer_prints := false) + val insts = try_map (fn (_,(th,_,_),_) => + add_graph_spec_fail (get_pc_val th) sec_name) make_INST thms + val _ = (writer_prints := true) + val inst_count = int_to_string (length insts) + val _ = write_line (inst_count ^ " inst theorems describe instructions.") + in insts end; + +end diff --git a/examples/machine-code/graph/loop-m0/example.c b/examples/machine-code/graph/loop-m0/example.c new file mode 100644 index 0000000000..9581c2f88c --- /dev/null +++ b/examples/machine-code/graph/loop-m0/example.c @@ -0,0 +1,22 @@ + + + +int +g (int i) { + return i * 8 + (i & 15); +} + +void +f (int *p, int x) { + int i; + + for (i = x; i < 100; i ++) { + p[i] = g (i); + } +} + + +int +main (void) { + return 0; +} diff --git a/examples/machine-code/graph/loop-m0/example.elf.txt b/examples/machine-code/graph/loop-m0/example.elf.txt new file mode 100644 index 0000000000..af1842f822 --- /dev/null +++ b/examples/machine-code/graph/loop-m0/example.elf.txt @@ -0,0 +1,32 @@ + +example.o: file format elf32-littlearm + + +Disassembly of section .text: + +00000000 : + 0: 230f movs r3, #15 + 2: 4003 ands r3, r0 + 4: 00c0 lsls r0, r0, #3 + 6: 1818 adds r0, r3, r0 + 8: 4770 bx lr + a: 46c0 nop ; (mov r8, r8) + +0000000c : + c: b538 push {r3, r4, r5, lr} + e: 2963 cmp r1, #99 ; 0x63 + 10: dc09 bgt.n 26 + 12: 008d lsls r5, r1, #2 + 14: 1945 adds r5, r0, r5 + 16: 1c0c adds r4, r1, #0 + 18: 1c20 adds r0, r4, #0 + 1a: f7ff fffe bl 0 + 1e: c501 stmia r5!, {r0} + 20: 3401 adds r4, #1 + 22: 2c64 cmp r4, #100 ; 0x64 + 24: d1f8 bne.n 18 + 26: bd38 pop {r3, r4, r5, pc} + +00000028
: + 28: 2000 movs r0, #0 + 2a: 4770 bx lr diff --git a/examples/machine-code/graph/loop-m0/example.sigs b/examples/machine-code/graph/loop-m0/example.sigs new file mode 100644 index 0000000000..0897d6009b --- /dev/null +++ b/examples/machine-code/graph/loop-m0/example.sigs @@ -0,0 +1,3 @@ +0 f 4 4 +4 g 4 +4 main diff --git a/examples/machine-code/graph/loop/example.c b/examples/machine-code/graph/loop/example.c new file mode 100644 index 0000000000..9581c2f88c --- /dev/null +++ b/examples/machine-code/graph/loop/example.c @@ -0,0 +1,22 @@ + + + +int +g (int i) { + return i * 8 + (i & 15); +} + +void +f (int *p, int x) { + int i; + + for (i = x; i < 100; i ++) { + p[i] = g (i); + } +} + + +int +main (void) { + return 0; +} diff --git a/examples/machine-code/graph/loop/example.elf.txt b/examples/machine-code/graph/loop/example.elf.txt new file mode 100644 index 0000000000..55635be313 --- /dev/null +++ b/examples/machine-code/graph/loop/example.elf.txt @@ -0,0 +1,55 @@ + +example.o: file format elf32-littlearm + + +Disassembly of section .text: + +00000000 : + 0: e200300f and r3, r0, #15 + 4: e0830180 add r0, r3, r0, lsl #3 + 8: e12fff1e bx lr + +0000000c : + c: e3510063 cmp r1, #99 ; 0x63 + 10: e52d4004 push {r4} ; (str r4, [sp, #-4]!) + 14: ca000021 bgt a0 + 18: e1a02181 lsl r2, r1, #3 + 1c: e201c00f and ip, r1, #15 + 20: e2813001 add r3, r1, #1 + 24: e2614063 rsb r4, r1, #99 ; 0x63 + 28: e08cc002 add ip, ip, r2 + 2c: e0801101 add r1, r0, r1, lsl #2 + 30: e3530064 cmp r3, #100 ; 0x64 + 34: e2044001 and r4, r4, #1 + 38: e481c004 str ip, [r1], #4 + 3c: e2820008 add r0, r2, #8 + 40: 0a000016 beq a0 + 44: e3540000 cmp r4, #0 + 48: 0a000006 beq 68 + 4c: e203200f and r2, r3, #15 + 50: e2833001 add r3, r3, #1 + 54: e082c000 add ip, r2, r0 + 58: e3530064 cmp r3, #100 ; 0x64 + 5c: e481c004 str ip, [r1], #4 + 60: e2800008 add r0, r0, #8 + 64: 0a00000d beq a0 + 68: e203200f and r2, r3, #15 + 6c: e082c000 add ip, r2, r0 + 70: e2833001 add r3, r3, #1 + 74: e1a02001 mov r2, r1 + 78: e482c004 str ip, [r2], #4 + 7c: e2800008 add r0, r0, #8 + 80: e203c00f and ip, r3, #15 + 84: e2833001 add r3, r3, #1 + 88: e08cc000 add ip, ip, r0 + 8c: e3530064 cmp r3, #100 ; 0x64 + 90: e581c004 str ip, [r1, #4] + 94: e2800008 add r0, r0, #8 + 98: e2821004 add r1, r2, #4 + 9c: 1afffff1 bne 68 + a0: e49d4004 pop {r4} ; (ldr r4, [sp], #4) + a4: e12fff1e bx lr + +000000a8
: + a8: e3a00000 mov r0, #0 + ac: e12fff1e bx lr diff --git a/examples/machine-code/graph/loop/example.sigs b/examples/machine-code/graph/loop/example.sigs new file mode 100644 index 0000000000..0897d6009b --- /dev/null +++ b/examples/machine-code/graph/loop/example.sigs @@ -0,0 +1,3 @@ +0 f 4 4 +4 g 4 +4 main diff --git a/examples/machine-code/graph/stack_analysisLib.sml b/examples/machine-code/graph/stack_analysisLib.sml new file mode 100644 index 0000000000..4614f6a531 --- /dev/null +++ b/examples/machine-code/graph/stack_analysisLib.sml @@ -0,0 +1,253 @@ +structure stack_analysisLib = +struct + +open HolKernel boolLib bossLib Parse; +open listTheory wordsTheory pred_setTheory arithmeticTheory wordsLib pairTheory; +open set_sepTheory progTheory helperLib addressTheory combinTheory; + +open backgroundLib file_readerLib; + +open GraphLangTheory + +infix \\ val op \\ = op THEN; + +fun stack_offset_in_r0 sec_name = let + val (_,ret_word_count,_) = section_io sec_name + in 1 < ret_word_count end + +local + val bool_arb = mk_arb(``:bool``) + val mem_type = ``:word32->word8`` + val write32_pat = ``WRITE32 a w m`` + fun dest_write32 tm = + if can (match_term write32_pat) tm then + let val (xyz,q) = dest_comb tm + val (xy,z) = dest_comb xyz + val (x,y) = dest_comb xy + in (y,z,q) end + else failwith "dest_write32" + fun list_dest_write32 tm = + let val (a,w,m) = dest_write32 tm + val ls = list_dest_write32 m + in (``READ32 ^a ^m``,w)::ls end handle HOL_ERR _ => [] +in + fun get_updates pre post = let + val ps = list_dest dest_star pre + val qs = list_dest dest_star post + fun find_same q [] = failwith "not found" + | find_same q (y::ys) = + (if rator y = q then rand y else find_same q ys) + handle HOL_ERR _ => find_same q ys + fun dest_write (x,y) = + if type_of x <> mem_type then [(x,y)] else list_dest_write32 y + in map (fn tm => (rand tm,find_same (rator tm) qs)) ps + |> filter (fn (x,y) => is_var x andalso x <> y) + |> map (fn (x,y) => if type_of x = ``:bool`` then (x,bool_arb) else (x,y)) + |> map dest_write |> Lib.flatten + end +end + +fun get_assum_pre_post th = let + val th = th |> SIMP_RULE (std_ss++sep_cond_ss) [word_arith_lemma1] + |> SIMP_RULE std_ss [word_arith_lemma3,word_arith_lemma4] + |> PURE_REWRITE_RULE [SPEC_MOVE_COND] + |> UNDISCH_ALL + val (_,pre,_,post) = dest_spec (concl th) + in (hyp th, pre, post) end + +fun get_pc_pat () = let + val (_,_,_,pc) = get_tools () + in ``^pc w`` end + +local + fun get_pc_val tm = let + val pc_pat = get_pc_pat () + in find_term (can (match_term pc_pat)) tm |> rand end + val dmem_type = ``:word32 set`` + fun dest_dmem_test tm = let + val (x,y) = pred_setSyntax.dest_in tm + val (v,ty) = dest_var y + val _ = (ty = dmem_type) orelse fail() + in x end + fun get_mem_access [] = NONE + | get_mem_access (tm::tms) = + SOME (dest_dmem_test (find_term (can dest_dmem_test) tm)) + handle HOL_ERR _ => get_mem_access tms + fun summary (i:int,(th,l:int,j:int option),NONE) = let + val (assum,pre,post) = get_assum_pre_post th + val pc = get_pc_val pre + fun all_posts post = + if is_cond post then let + val (_,p1,p2) = dest_cond post + in all_posts p1 @ all_posts p2 end + else [post] + in map (fn post => (pc,T,get_updates pre post, + get_mem_access assum,get_pc_val post)) + (all_posts post) end + | summary (i,(th1,l1,j1),SOME (th2,l:int,j:int option)) = let + val (assum1,pre1,post1) = get_assum_pre_post th1 + val (assum2,pre2,post2) = get_assum_pre_post th2 + val assum2 = list_mk_conj assum2 + val u1 = get_updates pre1 post1 + val u2 = get_updates pre2 post2 + val assum1' = mk_neg assum2 |> QCONV (REWRITE_CONV []) |> concl |> rand + val pc = get_pc_val pre1 + val res1 = (pc,assum1',u1,get_mem_access assum1,get_pc_val post1) + val res2 = (pc,assum2,u2,NONE,get_pc_val post2) + in [res1,res2] end handle HOL_ERR _ => + summary (i,(th1,l1,j1),NONE) @ summary (i,(th2,l,j),NONE) + fun dest_call_tag tm = let + val (xy,z) = dest_comb tm + val (x,y) = dest_comb xy + val _ = (x = ``CALL_TAG``) orelse fail() + in (stringSyntax.fromHOLstring y, + if z = T then true else + if z = F then false else fail()) end + fun has_call_tag th = + can (find_term (can dest_call_tag)) (concl (DISCH_ALL th)) + val call_update = let + fun mk_arb_pair tm = (tm,mk_arb(type_of tm)) + in map mk_arb_pair [``r0:word32``, + ``r1:word32``, ``r2:word32``, ``r3:word32``, ``r14:word32``, + ``n:bool``, ``z:bool``, ``c:bool``, ``v:bool``] end +in + fun approx_summary (i,(th1,i1,i2),thi2) = + if not (has_call_tag th1) then summary (i,(th1,i1,i2),thi2) else let + val res = summary (i,(th1,i1,i2),thi2) + val (p1,assum1,u1,addr,q1) = hd res + val r14 = mk_var("r14",``:word32``) + val dest = first (fn (x,_) => x = r14) u1 |> snd handle HOL_ERR _ => T + in (p1,assum1,call_update,addr,dest) :: tl res end +end + +fun find_stack_accesses_for all_summaries sec_name = let + val r13 = ``r13:word32`` + val (init_pc,_,_,_,_) = hd all_summaries + val state = (init_pc,(r13,r13)::(if stack_offset_in_r0 sec_name then + [(``r0:word32``,``^r13 + offset``)] + else []),T) + val (pc,s,t) = state + val us = filter (fn (p,_,_,_,_) => p = pc) all_summaries + val (pc1,assum,u,addr,pc2) = hd us + val stack_accesses = ref ([]:int list); + fun add_stack_access pc = let + val n = pc |> wordsSyntax.dest_n2w |> fst |> numSyntax.int_of_term + val a = !stack_accesses + in if mem n a then () else (stack_accesses := n::a) end + fun can_exec_step t (pc1,assum,u,addr,pc2) = + if assum = T then true else let + val test = mk_imp(t,mk_neg assum) + val vs = free_vars test + val test = list_mk_forall(vs,test) + fun can_prove_by_cases goal = + ([],goal) |> (REPEAT Cases THEN REWRITE_TAC []) + |> (fn (x,_) => length x = 0) + in not (can_prove_by_cases test) end + fun is_sp_add_or_sub a = + if a = r13 then true else let + val (w1,w2) = wordsSyntax.dest_word_add a + in (w1 = r13 andalso wordsSyntax.is_n2w w2) orelse + (w2 = r13 andalso wordsSyntax.is_n2w w1) end + handle HOL_ERR _ => let + val (w1,w2) = wordsSyntax.dest_word_sub a + in (w1 = r13 andalso wordsSyntax.is_n2w w2) orelse + (w2 = r13 andalso wordsSyntax.is_n2w w1) end + handle HOL_ERR _ => false + val stack_read32_pat = ``READ32 (a:word32) m`` + fun is_simple_or_stack_read32 (x,y) = + if is_var x then true else + if can (match_term stack_read32_pat) x then + (x |> rator |> rand |> is_sp_add_or_sub) + else false + val word_simp_tm = rand o concl o QCONV (SIMP_CONV std_ss [word_arith_lemma1] THENC + SIMP_CONV std_ss [word_arith_lemma3,word_arith_lemma4,WORD_ADD_0]) + fun exec_step s t (pc1,assum,u,addr,pc2) = let + val s_simple = filter (fn (x,_) => is_var x) s + val s_read32 = filter (fn (x,_) => not (is_var x)) s + val i_simple = word_simp_tm o subst (map (fn (x,y) => x |-> y) s_simple) + val i = word_simp_tm o subst (map (fn (x,y) => x |-> y) s_read32) o i_simple + fun i_read32_only tm = if is_comb tm then i_simple tm else tm + val new_u_part = map (fn (x,y) => (i_read32_only x,i y)) u + val u_domain = map fst new_u_part + val new_u = new_u_part @ filter (fn (x,y) => not (mem x u_domain)) s + val new_t = if assum = T then t else assum + val new_t = if intersect u_domain (free_vars new_t) <> [] then T else new_t + in (pc2,filter is_simple_or_stack_read32 new_u,new_t) end + fun register_state (pc,s,t) = let + val _ = print ("\nRegister state:\n pc = " ^ term_to_string pc ^ "\n") + val _ = print (" assumes " ^ term_to_string t ^ "\n") + val s = filter (fn (x,y) => not (is_arb y)) s + val _ = map (fn (x,y) => print (" " ^ term_to_string x ^ " is " ^ + term_to_string y ^ "\n")) s + in () end + val read32_pat = ``READ32 a (m:word32->word8)`` + fun remove_read32 tm = let + val xs = find_terms (can (match_term read32_pat)) tm + val ss = map (fn x => x |-> (mk_arb(type_of x))) xs + in subst ss tm end + fun found_stack_access pc s = let + val _ = add_stack_access pc +(* val _ = print ("Stack found access at pc = " ^ term_to_string pc ^ "\n") *) +(* val _ = print "\n" *) + in () end + fun check_for_stack_accesses (pc,s,t) NONE = () + | check_for_stack_accesses (pc,s,t) (SOME a) = let + val i = remove_read32 o word_simp_tm o subst (map (fn (x,y) => x |-> y) s) + fun contains_sp tm = mem r13 (free_vars tm) + in if contains_sp (i a) + then found_stack_access pc (filter (fn (x,y) => contains_sp y) + (map (fn (x,y) => (x,i y)) s)) + else () end + fun get_pc (pc,s,t) = pc + val seen_nodes = ref ([]:(term * term) list) + fun has_visited (pc,s,t) = let + val seen = !seen_nodes + in if can (first (fn x => x = (t,pc))) seen then true else + (seen_nodes := ((t,pc)::seen); false) end + fun print_state (pc,s,t) = let + val _ = print ("Looking at pc = " ^ term_to_string pc ^ "\n") + val _ = map (fn (x,y) => print (" " ^ term_to_string x ^ " is " ^ + term_to_string y ^ "\n")) s + val _ = print (" assuming: " ^ term_to_string t ^ "\n\n") + in () end + fun exec_steps state = + if has_visited state then () else let + (* val _ = register_state state *) + val (pc,s,t) = state +(* val _ = print_state state *) + val us = filter (fn (p,_,_,_,_) => p = pc) all_summaries + val us = filter (can_exec_step t) us + val addresses = map (fn (_,_,_,a,_) => a) us + val _ = map (check_for_stack_accesses state) addresses +(* val (pc1,assum,u,addr,pc2) = hd us *) + val states = map (exec_step s t) us +(* val state = hd states handle Empty => state *) + val _ = map exec_steps states + in () end + val _ = exec_steps state + val xs = !stack_accesses + in xs end; + +fun find_stack_accesses sec_name thms = let + val _ = write_subsection "Stack analysis" + val all_summaries = map approx_summary thms |> flatten + val all_simple_summaries = all_summaries + |> map (fn (x,a,u,z,y) => (x,a,filter (is_var o fst) u,z,y)) + val all_stack_accesses = find_stack_accesses_for all_summaries sec_name + val simple_stack_accesses = find_stack_accesses_for all_simple_summaries sec_name + fun annotation loc = + if mem loc simple_stack_accesses then "stack access" else + if mem loc all_stack_accesses then "indirect stack access" else fail() + val _ = if stack_offset_in_r0 sec_name then + write_line ("Section `" ^ sec_name ^ "` expects pointer to stack in r0.") + else () + val l = all_stack_accesses |> all_distinct |> length |> int_to_string + val _ = (if l = "0" then + write_line ("No stack accesses found. Code for `" ^ sec_name ^ "`:") + else + write_line (l ^ " stack accesses found. " ^ + "Annotated code for `" ^ sec_name ^ "`:")) + val _ = show_annotated_code annotation sec_name + in all_stack_accesses end + +end diff --git a/examples/machine-code/graph/stack_introLib.sml b/examples/machine-code/graph/stack_introLib.sml new file mode 100644 index 0000000000..344023fac2 --- /dev/null +++ b/examples/machine-code/graph/stack_introLib.sml @@ -0,0 +1,80 @@ +structure stack_introLib = +struct + +open HolKernel boolLib bossLib Parse; +open listTheory wordsTheory pred_setTheory arithmeticTheory wordsLib pairTheory; +open set_sepTheory progTheory helperLib addressTheory combinTheory; + +open backgroundLib file_readerLib writerLib; + +open GraphLangTheory + +infix \\ val op \\ = op THEN; + +fun STACK_MEMORY_INTRO_RULE th = let + val (_,p,_,_) = th |> concl |> dest_spec + val ps = list_dest dest_star p + val pat = case !arch_name of ARM => ``arm_MEMORY d m`` + | M0 => ``m0_MEMORY d m`` + val x = first (can (match_term pat)) ps + val d = x |> rator |> rand + val m = x |> rand + val th = th |> RW1 [GSYM arm_STACK_MEMORY_def, + GSYM m0_STACK_MEMORY_def] + val th = th |> INST [m |-> mk_var("stack" ,type_of m), + d |-> mk_var("dom_stack" ,type_of d)] + in th end handle HOL_ERR _ => th; + +(* + val () = arm_progLib.arm_config "vfp" "array" + val (f,_,_,_) = arm_decompLib.l3_arm_tools + val ((th,_,_),_) = f "e59d900c" (* ldr r9, [sp, #12] *) + val ((th,_,_),_) = f "e58d2010" (* str r2, [sp, #16] *) + val ((th,_,_),_) = f "e92d0030" (* push {r4, r5} *) + val ((th,_,_),_) = f "e92d0010" (* push {r4} *) + val ((th,_,_),_) = f "e24dd014" (* sub sp, sp, #20 *) + val ((th,_,_),_) = f "e1370006" (* teq r7, r6 *) +*) + +val STACK_INTRO_RULE_input = ref ([]:int list,TRUTH); + +(* + val (stack_accesses,th) = !STACK_INTRO_RULE_input +*) + +local + fun get_pc_pat () = let + val (_,_,_,pc) = get_tools () + in ``^pc w`` end + val r13 = mk_var("r13",``:word32``) + fun dest_r13 q = let + val r13_pat = case !arch_name of + ARM => ``arm_REG (R_mode mode 13w) r13`` + | M0 => ``m0_REG RName_SP_main r13`` + val tm = find_term (can (match_term r13_pat)) q |> rand + in let val (x,y) = wordsSyntax.dest_word_add tm + val _ = x = r13 orelse fail() + in y |> wordsSyntax.dest_n2w |> fst |> numSyntax.int_of_term end + handle HOL_ERR _ => + let val (x,y) = wordsSyntax.dest_word_sub tm + val _ = x = r13 orelse fail() + in 0-(y |> wordsSyntax.dest_n2w |> fst |> numSyntax.int_of_term) end + handle HOL_ERR _ => + if tm = r13 then 0 else failwith "unexpected value assigned to r13" end + fun get_pc_num th = let + val pc_pat = get_pc_pat () + val (_,p,_,_) = dest_spec (concl th) + in find_term (can (match_term pc_pat)) p + |> rand |> wordsSyntax.dest_n2w |> fst |> numSyntax.int_of_term end +in + fun STACK_INTRO_RULE stack_accesses th = let + val (_,p,_,q) = dest_spec (concl th) + val (n,must_intro) = (dest_r13 q,true) + handle HOL_ERR _ => (0,mem (get_pc_num th) stack_accesses) + in if n <> 0 orelse must_intro then STACK_MEMORY_INTRO_RULE th else th end + handle HOL_ERR e => + (STACK_INTRO_RULE_input := (stack_accesses,th); + report_error "STACK_INTRO_RULE" (HOL_ERR e)) +end + +end diff --git a/examples/machine-code/graph/syntaxLib.sml b/examples/machine-code/graph/syntaxLib.sml new file mode 100644 index 0000000000..e99378cf4b --- /dev/null +++ b/examples/machine-code/graph/syntaxLib.sml @@ -0,0 +1,33 @@ +structure syntaxLib = +struct + +open HolKernel boolLib bossLib Parse; +open listTheory wordsTheory pred_setTheory arithmeticTheory wordsLib pairTheory; +open set_sepTheory progTheory helperLib addressTheory combinTheory; + +(* generic functions *) + +fun dest1 name pat = fn tm => + if can (match_term pat) tm then + rand tm + else failwith (name ^ " expects " ^ term_to_string pat) + +fun dest2 name pat = fn tm => + if can (match_term pat) tm then + (rand (rator tm), rand tm) + else failwith (name ^ " expects " ^ term_to_string pat) + +fun dest3 name pat = fn tm => + if can (match_term pat) tm then + (rand (rator (rator tm)), rand (rator tm), rand tm) + else failwith (name ^ " expects " ^ term_to_string pat) + +(* specific functions *) + +val dest_IMPL_INST = dest3 "dest_IMPL_INST" ``IMPL_INST code locs next`` +val dest_Inst = dest3 "dest_Inst" ``Inst loc assert next`` +val dest_IF = dest3 "dest_IF" ``IF g next1 next2`` +val dest_ASM = dest3 "dest_ASM" ``ASM side update jump`` +val dest_Jump = dest1 "dest_Jump" ``Jump w`` + +end diff --git a/examples/machine-code/graph/writerLib.sml b/examples/machine-code/graph/writerLib.sml new file mode 100644 index 0000000000..ddcc93b6fc --- /dev/null +++ b/examples/machine-code/graph/writerLib.sml @@ -0,0 +1,75 @@ +structure writerLib = +struct + +open HolKernel boolLib bossLib Parse; + +val writer_prints = ref true; + +local + val filename_base = ref "output_"; + val filename_current = ref ""; + val current_graph_file = ref (NONE:TextIO.outstream option) + val last_line_is_blank = ref false; + fun remove_trailing_underscores s = let + fun aux (#"_"::cs) = aux cs | aux xs = String.implode (rev xs) + in aux (rev (String.explode s)) end + fun graph_filename () = remove_trailing_underscores (!filename_base) ^ "_mc_graph.txt" + fun print_fail str = (print (str ^ "\n"); failwith str); +in + fun reset_graph_file () = + TextIO.closeOut (TextIO.openOut (graph_filename ())) + handle Io _ => () + fun close_current () = + ((case !current_graph_file of NONE => () | SOME f => TextIO.closeOut f); + (current_graph_file := NONE)) + fun write_graph str = + case !current_graph_file of + NONE => print_fail "Attempt to write to graph file, but no graph file open." + | SOME f => TextIO.output (f,str) + fun open_current sec_name = + (close_current (); + filename_current := sec_name; last_line_is_blank := false; + current_graph_file := SOME (TextIO.openAppend (graph_filename ())); + write_graph "\n") + fun set_base filename = + (close_current (); + filename_base := filename; + reset_graph_file ()) + fun write_txt_and_print str = + (if !writer_prints then print str else ()) + fun write_blank_line () = + if !last_line_is_blank then () else + (write_txt_and_print "\n"; last_line_is_blank := true) + fun write_line str = + (write_txt_and_print (str ^ "\n"); + last_line_is_blank := (size str = 0)) + fun write_section str = + (write_blank_line (); + write_line str; + write_line (String.translate (fn c => "=") str); + write_blank_line ()) + fun write_subsection str = + (write_blank_line (); + write_line str; + write_line (String.translate (fn c => "-") str); + write_blank_line ()) + fun write_indented_block str = let + val lines = String.tokens (fn c => c = #"\n") str + in (write_blank_line (); + map (fn l => if l = "" then () else write_line (" " ^ l)) lines; + write_blank_line ()) end + fun write_term th = let + val _ = set_trace "PPBackEnd use annotations" 0 + val _ = write_indented_block (term_to_string th) + val _ = set_trace "PPBackEnd use annotations" 1 + in () end + fun write_thm th = let + val _ = set_trace "PPBackEnd use annotations" 0 + val a = !Globals.show_assums + val _ = Globals.show_assums := false + val _ = write_indented_block (thm_to_string th) + val _ = set_trace "PPBackEnd use annotations" 1 + in Globals.show_assums := a end +end + +end From 2b75a10c73287bd045dd256cc7e38b717fa2955d Mon Sep 17 00:00:00 2001 From: Thomas Tuerk Date: Sat, 29 Aug 2015 17:57:50 +0200 Subject: [PATCH 449/718] quantHeuristicsLib: fix handling of pairs the heuristic for instantiating product variables was broken. Nested pairs were broken. Pairs like (a, b, c) worked, while ((a,b), c) did not. --- src/quantHeuristics/quantHeuristicsLibParameters.sml | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/src/quantHeuristics/quantHeuristicsLibParameters.sml b/src/quantHeuristics/quantHeuristicsLibParameters.sml index 9bf11939cb..0f720a86e9 100644 --- a/src/quantHeuristics/quantHeuristicsLibParameters.sml +++ b/src/quantHeuristics/quantHeuristicsLibParameters.sml @@ -67,7 +67,7 @@ in end; val GUESS_PAIR_THM = prove ( -``!P. GUESS_EXISTS_GAP (\x:'a. x) P /\ GUESS_FORALL_GAP (\x. x) P``, +``!P i. (!v. ?x. v = i x) ==> simpLib.SIMP_TAC numLib.std_ss [GUESS_REWRITES]) @@ -81,7 +81,15 @@ let | some => valOf some; val fvL = rev (free_vars vars) - val gthmL = CONJUNCTS (ISPEC (mk_abs (v, t)) GUESS_PAIR_THM) + val ip = pairLib.mk_pabs (pairLib.list_mk_pair fvL, vars); + val ip' = rhs (concl ((pairTools.PABS_ELIM_CONV ip) handle UNCHANGED => REFL ip)); + + val gthm = ISPECL[mk_abs (v, t), ip'] GUESS_PAIR_THM + val pre = rand (rator (concl gthm)) + val pre_thm = prove (pre, + simpLib.SIMP_TAC numLib.std_ss [ + pairTheory.EXISTS_PROD, pairTheory.FORALL_PROD]) + val gthmL = BODY_CONJUNCTS (MP gthm pre_thm) in {rewrites = [], general = [], From 1c2225f4741859bdff8996836d2f6b92525745d3 Mon Sep 17 00:00:00 2001 From: Thomas Tuerk Date: Sat, 29 Aug 2015 18:08:18 +0200 Subject: [PATCH 450/718] quantHeuristicsLib: fix handling of pairs, context cleanup The heuristic for instantiating product variables was broken. Nested pairs were broken. Pairs like (a, b, c) worked, while ((a,b), c) did not. Moreover, context heuristics that recurse are now not any more part of the basic quant parameter. This stops the quant-heuristics looping sometimes, when the user isn't careful. --- src/quantHeuristics/doc/quantHeu.tex | 6 ++-- src/quantHeuristics/quantHeuristicsLib.sig | 4 ++- .../quantHeuristicsLibBase.sig | 5 +++- .../quantHeuristicsLibBase.sml | 30 +++++++++++-------- .../quantHeuristicsLibParameters.sig | 4 ++- .../quantHeuristicsLibParameters.sml | 9 +++++- 6 files changed, 38 insertions(+), 20 deletions(-) diff --git a/src/quantHeuristics/doc/quantHeu.tex b/src/quantHeuristics/doc/quantHeu.tex index 08ccae740f..9be978482c 100644 --- a/src/quantHeuristics/doc/quantHeu.tex +++ b/src/quantHeuristics/doc/quantHeu.tex @@ -857,8 +857,8 @@ \subsection{Conversions} All these functions get a list of \emph{quantifier heuristic parameters} as arguments. These parameters essentially configure, which heuristics are used during the guess-search. If -an empty list is provided, the tools know about the standard Boolean combinators, equations and context. -\texttt{std\_qp} adds support for common datatypes like pairs or lists. +an empty list is provided, the tools know about the standard Boolean combinators and equations. +\texttt{std\_qp} adds support for context and common datatypes like pairs or lists. Quantifier heuristic parameters are explained in more detail in Section~\ref{sec_qps}. @@ -1027,7 +1027,7 @@ \subsection{Interface Details} \item[\texttt{ctx\ :\ thm list}] a list of theorems that come from the context (e.\,g.\ collected by the simplifier). \item[\texttt{base\_arg\ :\ quant\_param}] a parameter that should always be used. This is by default - \texttt{basic\_qp}, which can handle the standard Boolean connectives, equations and context. In special circumstances, + \texttt{basic\_qp}, which can handle the standard Boolean connectives and equations. In special circumstances, it might be beneficial to use \texttt{empty\_qp}, though. \item[\texttt{args\ :\ quant\_param list}] list of quantifier heuristic parameters to use. diff --git a/src/quantHeuristics/quantHeuristicsLib.sig b/src/quantHeuristics/quantHeuristicsLib.sig index 5df7e4cc25..ae3dc3cf42 100644 --- a/src/quantHeuristics/quantHeuristicsLib.sig +++ b/src/quantHeuristics/quantHeuristicsLib.sig @@ -104,7 +104,9 @@ sig val list_ty_filter : term -> term -> bool (* combination of all except the stateful ones *) - val std_qp : quantHeuristicsLibBase.quant_param; + val std_qp : quantHeuristicsLibBase.quant_param; + val no_ctxt_std_qp : quantHeuristicsLibBase.quant_param (* ignore context *); + val direct_ctxt_std_qp : quantHeuristicsLibBase.quant_param (* don't use context for weaken / strengthen *); (* A heuristic that considers just the conclusion of implications. This may lead to wrong guesses, but if used carefully, is a handy heuristic. *) diff --git a/src/quantHeuristics/quantHeuristicsLibBase.sig b/src/quantHeuristics/quantHeuristicsLibBase.sig index 90dc36d64e..c030f623ab 100644 --- a/src/quantHeuristics/quantHeuristicsLibBase.sig +++ b/src/quantHeuristics/quantHeuristicsLibBase.sig @@ -163,6 +163,8 @@ sig val empty_qp : quant_param; val basic_qp : quant_param; (* the basic things that should always be turned on *) + val direct_context_qp : quant_param; (* use the context, but don't recurse *) + val context_qp : quant_param; (* use the context *) val stateful_qp : unit -> quant_param; val pure_stateful_qp : unit -> quant_param; val TypeBase_qp : quant_param; @@ -184,8 +186,9 @@ sig val QUANT_INSTANTIATE_HEURISTIC___EQUATION_two_cases : thm -> quant_heuristic; val QUANT_INSTANTIATE_HEURISTIC___one_case : thm -> quant_heuristic; val QUANT_INSTANTIATE_HEURISTIC___cases : thm -> quant_heuristic; - val QUANT_INSTANTIATE_HEURISTIC___GIVEN_INSTANTIATION : thm list -> quant_heuristic; + val QUANT_INSTANTIATE_HEURISTIC___GIVEN_INSTANTIATION : bool -> thm list -> quant_heuristic; val QUANT_INSTANTIATE_HEURISTIC___STRENGTHEN_WEAKEN : thm list -> quant_heuristic; + val QUANT_INSTANTIATE_HEURISTIC___QUANT : bool -> quant_heuristic; val QUANT_INSTANTIATE_HEURISTIC___max_rec_depth : int ref diff --git a/src/quantHeuristics/quantHeuristicsLibBase.sml b/src/quantHeuristics/quantHeuristicsLibBase.sml index 0109a90c13..f8d724a3bd 100644 --- a/src/quantHeuristics/quantHeuristicsLibBase.sml +++ b/src/quantHeuristics/quantHeuristicsLibBase.sml @@ -1221,7 +1221,7 @@ local val u_icL = col (GUESS_RULES_EXISTS_UNIQUE, TRUTH, TRUTH); in -fun QUANT_INSTANTIATE_HEURISTIC___QUANT sys (v:term) t = +fun QUANT_INSTANTIATE_HEURISTIC___QUANT allow_new_fv sys (v:term) t = let val ((ic, ic_fv, ic_fv_1), (v2, b)) = (f_icL, dest_forall t) handle HOL_ERR _ => @@ -1235,6 +1235,7 @@ let val (_, i, fvL, gthm0, was_thm) = guess_extract_thm guess; val gthm = GEN_ASSUM v2 gthm0; val new_fv = free_in v2 i + val _ = if new_fv andalso not allow_new_fv then Feedback.fail() else (); val use_ic = if new_fv then (if null fvL then ic_fv_1 else ic_fv) else ic; val inf_thm = hd (inf use_ic) handle Empty => Feedback.fail(); val xthm2 = HO_MATCH_MP inf_thm gthm @@ -2006,7 +2007,7 @@ local forall_gap = []}:guess_collection in gc end; - fun try_single_thm sys vset v t v' t' thm = + fun try_single_thm try_imps sys vset v t v' t' thm = let val (vs, _) = strip_forall (concl thm); val vs' = map (fn v => genvar (type_of v)) vs @@ -2020,12 +2021,16 @@ local val i = Unify.deref_tmenv s v'; val P = mk_abs (v, t) val thm'' = INST s thm'; - val gc1 = get_direct_matches_gc neg dneg i P thm''; - val gc2 = get_implication_gc sys v t neg dneg i P thm''; - in SOME (guess_collection_append gc1 gc2) end handle HOL_ERR _ => NONE; + val gc = get_direct_matches_gc neg dneg i P thm''; + val gc' = if try_imps then let + val gc'' = get_implication_gc sys v t neg dneg i P thm''; + in + guess_collection_append gc gc'' + end else gc + in SOME gc' end handle HOL_ERR _ => NONE; in -fun QUANT_INSTANTIATE_HEURISTIC___GIVEN_INSTANTIATION thms sys (v:term) t = +fun QUANT_INSTANTIATE_HEURISTIC___GIVEN_INSTANTIATION try_imps thms sys (v:term) t = let val v' = genvar (type_of v); val t' = subst [v |-> v'] t; @@ -2033,7 +2038,7 @@ let val vset = HOLset.delete (FVL [t] empty_tmset, v) handle HOLset.NotFound => raise QUANT_INSTANTIATE_HEURISTIC___no_guess_exp; - val gc = guess_collection_flatten (map (try_single_thm sys vset v t v' t') thmL) + val gc = guess_collection_flatten (map (try_single_thm try_imps sys vset v t v' t') thmL) in gc end handle HOL_ERR _ => raise QUANT_INSTANTIATE_HEURISTIC___no_guess_exp; @@ -2557,16 +2562,16 @@ local QUANT_INSTANTIATE_HEURISTIC___BOOL, QUANT_INSTANTIATE_HEURISTIC___THM_GENERAL_SIMPLE guesses_net_simple, QUANT_INSTANTIATE_HEURISTIC___THM_GENERAL_COMPLEX guesses_net_complex, - QUANT_INSTANTIATE_HEURISTIC___QUANT, + QUANT_INSTANTIATE_HEURISTIC___QUANT true, QUANT_INSTANTIATE_HEURISTIC___CONV (markerLib.DEST_LABEL_CONV), QUANT_INSTANTIATE_HEURISTIC___CONV (asm_marker_ELIM_CONV) ] in (* The most basic heuristics that should always be turned on *) - val basic_qp = combine_qps [ - heuristics_qp BASIC_QUANT_INSTANTIATE_HEURISTICS, - context_heuristics_qp[QUANT_INSTANTIATE_HEURISTIC___GIVEN_INSTANTIATION, QUANT_INSTANTIATE_HEURISTIC___STRENGTHEN_WEAKEN]] + val basic_qp = heuristics_qp BASIC_QUANT_INSTANTIATE_HEURISTICS + val direct_context_qp = context_heuristics_qp[QUANT_INSTANTIATE_HEURISTIC___GIVEN_INSTANTIATION false] + val context_qp = context_heuristics_qp[QUANT_INSTANTIATE_HEURISTIC___GIVEN_INSTANTIATION true, QUANT_INSTANTIATE_HEURISTIC___STRENGTHEN_WEAKEN] end; fun qp_to_heuristic @@ -2598,7 +2603,7 @@ fun qp_to_heuristic QUANT_INSTANTIATE_HEURISTIC___THM_GENERAL_SIMPLE guesses_net_simple, QUANT_INSTANTIATE_HEURISTIC___THM_GENERAL_COMPLEX guesses_net_complex, QUANT_INSTANTIATE_HEURISTIC___STRENGTHEN_WEAKEN (imp_thmL @ extra_imp_thms), - QUANT_INSTANTIATE_HEURISTIC___GIVEN_INSTANTIATION instantiation_thmL] + QUANT_INSTANTIATE_HEURISTIC___GIVEN_INSTANTIATION true instantiation_thmL] val heuristicL_2 = map QUANT_INSTANTIATE_HEURISTIC___CONV ((map (fn thm => TOP_ONCE_REWRITE_CONV [thm]) rewrite_thmL)@convL) val heuristicL_final = flatten [heuristicL_1, heuristicL_2, hcL2, heuristicL] in @@ -3169,7 +3174,6 @@ fun QUANT_TAC L (asm,t) = (asm,t) end; - fun INST_QUANT_CONV L t = let val ctxt = HOLset.listItems (FVL [t] empty_tmset); diff --git a/src/quantHeuristics/quantHeuristicsLibParameters.sig b/src/quantHeuristics/quantHeuristicsLibParameters.sig index 693a76d0ab..feeb7d308b 100644 --- a/src/quantHeuristics/quantHeuristicsLibParameters.sig +++ b/src/quantHeuristics/quantHeuristicsLibParameters.sig @@ -44,7 +44,9 @@ sig (* combination of all except the stateful ones *) - val std_qp : quantHeuristicsLibBase.quant_param; + val no_ctxt_std_qp : quantHeuristicsLibBase.quant_param; + val direct_ctxt_std_qp : quantHeuristicsLibBase.quant_param; + val std_qp : quantHeuristicsLibBase.quant_param; (* A heuristic that considers just the conclusion of implications. This may lead to wrong guesses, but if used carefully, is a handy heuristic. *) diff --git a/src/quantHeuristics/quantHeuristicsLibParameters.sml b/src/quantHeuristics/quantHeuristicsLibParameters.sml index 0f720a86e9..1d25cb2d97 100644 --- a/src/quantHeuristics/quantHeuristicsLibParameters.sml +++ b/src/quantHeuristics/quantHeuristicsLibParameters.sml @@ -68,6 +68,7 @@ end; val GUESS_PAIR_THM = prove ( ``!P i. (!v. ?x. v = i x) ==> + (GUESS_EXISTS_GAP i P /\ GUESS_FORALL_GAP i P)``, simpLib.SIMP_TAC numLib.std_ss [GUESS_REWRITES]) @@ -224,6 +225,7 @@ val sum_qp = combine_qps [ val sum_ty_filter = type_match_filter [``:('a + 'b)``] + (******************************************************************* * Nums *******************************************************************) @@ -403,7 +405,12 @@ val conj_lift_qp = dest_lift_qp (fn t => (let val (t1,t2) = dest_conj t in [t1, * Combinations *******************************************************************) -val std_qp = combine_qps [num_qp, option_qp, pair_default_qp, list_qp, sum_qp, record_default_qp] +val std_qps = [num_qp, option_qp, pair_default_qp, list_qp, sum_qp, record_default_qp] + +val no_ctxt_std_qp = combine_qps std_qps +val direct_ctxt_std_qp = combine_qps (std_qps @ [direct_context_qp]) +val std_qp = combine_qps (std_qps @ [context_qp]) + end From 9f8b068ca4269ac95854085de34f4fd587b2ca62 Mon Sep 17 00:00:00 2001 From: Thomas Tuerk Date: Sat, 29 Aug 2015 19:04:56 +0200 Subject: [PATCH 451/718] separationLogic example: fix Holmakefiles fix Holmakefiles following the changes discussed in issue #175 --- examples/separationLogic/src/Holmakefile | 6 ++++++ examples/separationLogic/src/holfoot/Holmakefile | 8 +++++++- 2 files changed, 13 insertions(+), 1 deletion(-) diff --git a/examples/separationLogic/src/Holmakefile b/examples/separationLogic/src/Holmakefile index f8bd945e08..f51b9afa8a 100644 --- a/examples/separationLogic/src/Holmakefile +++ b/examples/separationLogic/src/Holmakefile @@ -1,3 +1,9 @@ +THYFILES = $(patsubst %Script.sml,%Theory.uo,$(wildcard *.sml)) +TARGETS = $(patsubst %.sml,%.uo,$(THYFILES)) + +all: $(TARGETS) +.PHONY: all + vars_as_resourceBaseFunctor.uo: vars_as_resourceBaseFunctor.sml vars_as_resourceSyntax.uo $(dprot $(SIGOBJ)/listLib.uo) $(dprot $(SIGOBJ)/bagLib.uo) $(HOLMOSMLC) -c -toplevel Overlay.ui vars_as_resourceBaseFunctor.sml diff --git a/examples/separationLogic/src/holfoot/Holmakefile b/examples/separationLogic/src/holfoot/Holmakefile index 557f5f6caf..678b626bec 100644 --- a/examples/separationLogic/src/holfoot/Holmakefile +++ b/examples/separationLogic/src/holfoot/Holmakefile @@ -5,6 +5,12 @@ MLYACCLIB_UIS = $(patsubst %,MLY_%.ui,base-sig join lrtable parser2 stream) EXTRA_CLEANS = holfoot.grm-sig.sml holfoot.grm.sml holfoot.lex.sig \ holfoot.lex.sml holfoot.grm.sig +THYFILES = $(patsubst %Script.sml,%Theory.uo,$(wildcard *.sml)) +TARGETS = $(patsubst %.sml,%.uo,$(THYFILES)) + +all: $(TARGETS) holfootLib.ui +.PHONY: all + Parsetree.uo : Parsetree.sml HOLMOSMLC -c Parsetree.sml @@ -31,7 +37,7 @@ holfootLib.uo: holfootLib.sml holfootParser.ui holfootParser.uo holfootParserGen $(HOLMOSMLC) -I $(protect $(SIGOBJ)) -I .. -c ListConv1.uo treeTheory.uo HolSmtLib.uo treeSyntax.uo finite_mapLib.uo stringSimps.uo listLib.uo bagLib.uo permLib.uo vars_as_resourceBaseFunctor.ui vars_as_resourceFunctor.uo Overlay.ui holfootLib.sml header.uo: header.sml - + clean-lib: rm -f holfootLib.uo holfootLib.ui From 136e6cb0d723e51c7b1594c709fa1b65fb49140b Mon Sep 17 00:00:00 2001 From: Thomas Tuerk Date: Sat, 29 Aug 2015 19:17:09 +0200 Subject: [PATCH 452/718] fix selftest of quantHeuristicsLib The recent changes to how context is processed were unluckily not propagated to the selftests. This fixes the resulting errors. --- src/quantHeuristics/quantHeuristicsLib.sig | 4 ++++ src/quantHeuristics/selftest.sml | 13 +++++++++---- 2 files changed, 13 insertions(+), 4 deletions(-) diff --git a/src/quantHeuristics/quantHeuristicsLib.sig b/src/quantHeuristics/quantHeuristicsLib.sig index ae3dc3cf42..ace5630f25 100644 --- a/src/quantHeuristics/quantHeuristicsLib.sig +++ b/src/quantHeuristics/quantHeuristicsLib.sig @@ -69,6 +69,10 @@ sig val stateful_qp___add_combine_arguments : quantHeuristicsLibBase.quant_param list -> unit; + (* Context *) + val direct_context_qp : quant_param; (* use the context, but don't recurse *) + val context_qp : quant_param; (* use the context *) + (*pair type*) val split_pair___PABS___pred : Abbrev.term -> Abbrev.term -> Abbrev.term option val split_pair___FST_SND___pred : bool -> Abbrev.term -> Abbrev.term -> Abbrev.term option diff --git a/src/quantHeuristics/selftest.sml b/src/quantHeuristics/selftest.sml index ebc57cf621..d7ebe06093 100644 --- a/src/quantHeuristics/selftest.sml +++ b/src/quantHeuristics/selftest.sml @@ -292,13 +292,18 @@ val _ = map (qh_test_sum hard_fail quiet) qh_testCases_sum; (* Context tests *) (******************************************************************************) -val qh_test_context = test_conv "SIMP_CONV (bool_ss++QUANT_INST_ss[]) []" (SIMP_CONV (bool_ss++QUANT_INST_ss[]) []) +val qh_test_direct_context = test_conv "SIMP_CONV (bool_ss++QUANT_INST_ss[direct_context_qp]) []" (SIMP_CONV (bool_ss++QUANT_INST_ss[direct_context_qp]) []) -val qh_testCases_context = +val qh_testCases_direct_context = [(``(P x) ==> !x. ~(P x) /\ Q x``, SOME ``~(P x)``), (``~(P x) ==> !x. P x /\ Q x``, SOME ``(P (x:'a)):bool``), - (``P x ==> ?x. Q x \/ P x``, SOME ``T``), - (``(!x. P x ==> (x = 2)) ==> (!x. P x ==> Q x)``, SOME ``(!x. P x ==> (x = 2)) ==> P 2 ==> Q 2``), + (``P x ==> ?x. Q x \/ P x``, SOME ``T``) +] + + +val qh_test_context = test_conv "SIMP_CONV (bool_ss++QUANT_INST_ss[context_qp]) []" (SIMP_CONV (bool_ss++QUANT_INST_ss[context_qp]) []) +val qh_testCases_context = + [(``(!x. P x ==> (x = 2)) ==> (!x. P x ==> Q x)``, SOME ``(!x. P x ==> (x = 2)) ==> P 2 ==> Q 2``), (``(!x. Q x ==> P x) /\ Q 2 ==> (?x. P x)``, SOME T) ] From d7a48af92397d2f959ff0a250bcf743c3608852f Mon Sep 17 00:00:00 2001 From: Thomas Tuerk Date: Sat, 29 Aug 2015 18:11:50 +0200 Subject: [PATCH 453/718] add quantHeuristicsLib abbreviations to bossLib --- help/Docfiles/bossLib.ASM_QI_TAC.doc | 14 ++++++++++++++ help/Docfiles/bossLib.GEN_EXISTS_TAC.doc | 16 ++++++++++++++++ help/Docfiles/bossLib.QI_TAC.doc | 14 ++++++++++++++ help/Docfiles/bossLib.QI_ss.doc | 14 ++++++++++++++ src/boss/bossLib.sig | 5 +++++ src/boss/bossLib.sml | 8 +++++++- 6 files changed, 70 insertions(+), 1 deletion(-) create mode 100644 help/Docfiles/bossLib.ASM_QI_TAC.doc create mode 100644 help/Docfiles/bossLib.GEN_EXISTS_TAC.doc create mode 100644 help/Docfiles/bossLib.QI_TAC.doc create mode 100644 help/Docfiles/bossLib.QI_ss.doc diff --git a/help/Docfiles/bossLib.ASM_QI_TAC.doc b/help/Docfiles/bossLib.ASM_QI_TAC.doc new file mode 100644 index 0000000000..df76a40857 --- /dev/null +++ b/help/Docfiles/bossLib.ASM_QI_TAC.doc @@ -0,0 +1,14 @@ +\DOC ASM_QI_TAC + +\TYPE {ASM_QI_TAC : tactic} + +\SYNOPSIS +Try to instantiate quantifiers with some default heuristics using also the assumptions.. + +\DESCRIBE +{ASM_QI_TAC} is short for {ASM_QUANT_INSTANTIATE_TAC [std_qp]}. + +\SEEALSO +bossLib.QI_TAC, quantHeuristicsLib.ASM_QUANT_INSTANTIATE_TAC, quantHeuristicsLib.QUANT_INSTANTIATE_TAC. + +\ENDDOC diff --git a/help/Docfiles/bossLib.GEN_EXISTS_TAC.doc b/help/Docfiles/bossLib.GEN_EXISTS_TAC.doc new file mode 100644 index 0000000000..3ee75b375b --- /dev/null +++ b/help/Docfiles/bossLib.GEN_EXISTS_TAC.doc @@ -0,0 +1,16 @@ +\DOC GEN_EXISTS_TAC + +\TYPE {GEN_EXISTS_TAC : string -> Parse.term Lib.frag list -> tactic} + +\SYNOPSIS +Instantiate a quantifier at subposition. + +\DESCRIBE +{GEN_EXISTS_TAC v_name i} tries to instantiate a quantifier for a variable with +name {v_name} with {i}. It is short for {quantHeuristicsLib.QUANT_TAC [(v, i, [])]}. +It can be seen as a generalisation of {Q.EXISTS_TAC}. + +\SEEALSO +Tactic.EXISTS_TAC, quantHeuristicsLib.QUANT_TAC. + +\ENDDOC diff --git a/help/Docfiles/bossLib.QI_TAC.doc b/help/Docfiles/bossLib.QI_TAC.doc new file mode 100644 index 0000000000..afd595391e --- /dev/null +++ b/help/Docfiles/bossLib.QI_TAC.doc @@ -0,0 +1,14 @@ +\DOC QI_TAC + +\TYPE {QI_TAC : tactic} + +\SYNOPSIS +Try to instantiate quantifiers with some default heuristics. + +\DESCRIBE +{QI_TAC} is short for {QUANT_INSTANTIATE_TAC [std_qp]}. + +\SEEALSO +bossLib.ASM_QI_TAC, quantHeuristicsLib.QUANT_INSTANTIATE_TAC, quantHeuristicsLib.ASM_QUANT_INSTANTIATE_TAC. + +\ENDDOC diff --git a/help/Docfiles/bossLib.QI_ss.doc b/help/Docfiles/bossLib.QI_ss.doc new file mode 100644 index 0000000000..db264d392e --- /dev/null +++ b/help/Docfiles/bossLib.QI_ss.doc @@ -0,0 +1,14 @@ +\DOC QI_ss + +\TYPE {QI_ss : ssfrag} + +\SYNOPSIS +Simpset-fragment for instantiating quantifiers with some default heuristics. + +\DESCRIBE +{QI_ss} is short for {QUANT_INST_ss [std_qp]}. + +\SEEALSO +bossLib.QI_TAC, quantHeuristicsLib.QUANT_INST_ss. + +\ENDDOC diff --git a/src/boss/bossLib.sig b/src/boss/bossLib.sig index 64e75a1864..830aaa0820 100644 --- a/src/boss/bossLib.sig +++ b/src/boss/bossLib.sig @@ -61,6 +61,7 @@ sig val old_arith_ss : simpset val list_ss : simpset val srw_ss : unit -> simpset + val QI_ss : ssfrag val ARITH_ss : ssfrag (* arithmetic d.p. + some rewrites *) val old_ARITH_ss : ssfrag val type_rws : hol_type -> thm list @@ -91,6 +92,10 @@ sig val NO_STRIP_FULL_SIMP_TAC : simpset -> thm list -> tactic val NO_STRIP_REV_FULL_SIMP_TAC : simpset -> thm list -> tactic + val QI_TAC : tactic + val ASM_QI_TAC : tactic + val GEN_EXISTS_TAC : string -> Parse.term Lib.frag list -> tactic + (* Call-by-value evaluation *) val EVAL : term -> thm val EVAL_RULE : thm -> thm diff --git a/src/boss/bossLib.sml b/src/boss/bossLib.sml index 0373bea9b3..945835867e 100644 --- a/src/boss/bossLib.sml +++ b/src/boss/bossLib.sml @@ -15,7 +15,7 @@ structure bossLib :> bossLib = struct open HolKernel Parse boolLib pairLib simpLib metisLib pred_setLib - boolSimps + boolSimps quantHeuristicsLib (* This makes the dependency on listTheory and optionTheory explicit. Without it, the theories can change, and bossLib won't get recompiled. @@ -77,6 +77,10 @@ val EVAL = computeLib.EVAL_CONV; val EVAL_RULE = computeLib.EVAL_RULE val EVAL_TAC = computeLib.EVAL_TAC +val QI_TAC = quantHeuristicsLib.QUANT_INSTANTIATE_TAC [std_qp] +val ASM_QI_TAC = quantHeuristicsLib.ASM_QUANT_INSTANTIATE_TAC [std_qp] +fun GEN_EXISTS_TAC v i = quantHeuristicsLib.QUANT_TAC [(v, i, [])] + val op && = simpLib.&&; (*--------------------------------------------------------------------------- @@ -94,6 +98,8 @@ val op && = simpLib.&&; local open sumTheory pred_setTheory infix ++ in + +val QI_ss = quantHeuristicsLib.QUANT_INST_ss [std_qp] val pure_ss = pureSimps.pure_ss val bool_ss = boolSimps.bool_ss val std_ss = numLib.std_ss From e9bb81e34026f31cc1d07f701208c47bc2a01481 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 1 Sep 2015 12:04:15 +1000 Subject: [PATCH 454/718] Start of a developers' manual. Progress with #290 --- Manual/Developers/.gitignore | 2 + Manual/Developers/Makefile | 12 ++++ Manual/Developers/developers.md | 101 ++++++++++++++++++++++++++++++++ developers/releasing-hol | 2 +- 4 files changed, 116 insertions(+), 1 deletion(-) create mode 100644 Manual/Developers/.gitignore create mode 100644 Manual/Developers/Makefile create mode 100644 Manual/Developers/developers.md diff --git a/Manual/Developers/.gitignore b/Manual/Developers/.gitignore new file mode 100644 index 0000000000..4588044f28 --- /dev/null +++ b/Manual/Developers/.gitignore @@ -0,0 +1,2 @@ +developers.tex +developers.html diff --git a/Manual/Developers/Makefile b/Manual/Developers/Makefile new file mode 100644 index 0000000000..058df7b213 --- /dev/null +++ b/Manual/Developers/Makefile @@ -0,0 +1,12 @@ +.PHONY: all + +all: developers.pdf developers.html + +developers.pdf: developers.tex + latexmk -pdf developers + +developers.tex: developers.md + pandoc -s $< -o $@ + +developers.html: developers.md + pandoc -s $< -o $@ diff --git a/Manual/Developers/developers.md b/Manual/Developers/developers.md new file mode 100644 index 0000000000..07c1dcf7e0 --- /dev/null +++ b/Manual/Developers/developers.md @@ -0,0 +1,101 @@ +--- +title: HOL Developers’ Manual +author: HOL4 Developers +date: +numbersections: yes +--- + +# Introduction + +This manual attempts to provide documentation for people wishing to develop HOL4, a process that will likely involve frequent re-compilations or rebuilds of the core sources. + +As *per* [the standard installation instructions](http://hol-theorem-prover.org/InstallKananaskis.html), once one has an SML installation, there are two stages to the process of building HOL4: + +1. The first step is the *configuration* of the system (see [Configuration](#configuration) below). + This is achieved with the command + + smlsystem < tools/smart-configure.sml + + where `smlsystem` is either `poly` or `mosml`. + This command must be issued from the root of the HOL installation, where the path `tools/smart-configure.sml` makes sense. + This should complete quickly. + +2. Second, one needs to *build* the system (see [Build](#build) below). + This is achieved with the command + + bin/build + + assuming one is still in the root HOL directory. + Note however, that `build` can be executed from anywhere. + In particular, if `/bin` is in one’s path, it is reasonable to run `build` from any directory. + + When first executed, the build process will take a while because it proves all of the theorems in the core system, writing theories to disk as it goes. + Building should terminate with the message + + Hol built successfully. + + Repeated calls to `build` should complete quickly: theorem-proving work will not be redone unnecessarily. + +# Configuration + +The configuration process is responsible for + +* calculating important environmental details, such as the SML implementation, the nature of the operating system, and important paths; +* the creation of core system tools: standard SML tools (`mlyacc`, `mllex`), and HOL-specific tools (most importantly, the quotation filter, `Holmake` and `build`). + +The first thing that configuration does is to figure out which SML implementation is being run. +This is important because the compilation and creation of executables differs so dramatically in Poly/ML and Moscow\ ML. +Once this determination is made, actual configuration work is done in either `tools-poly/configure.sml` or `tools/configure.sml` +(See [Sources](#sources) below for more on how these sources are organised.) + +## Building `Holmake` + +Because `Holmake` is not assumed to exist when `Holmake` is built, the configuration script is responsible for assembling the constituent sources. +In the case of Moscow\ ML, this means that it makes the successive calls to `mosmlc` as necessary. +With Poly/ML, the work is orchestrated by `tools-poly/Holmake/poly-Holmake.ML`. +That script is a sequence of calls to `use`, followed by the boilerplate necessary to create an object-code file. +The configuration script then calls the C compiler to link that object code into the final executable. + +Note that we can’t simplify the Moscow\ ML build in a way analogous to what happens with Poly/ML because the complicated sequence of instructions are command-line invocations of `mosmlc`, rather than calls to `use` within a Poly/ML program. +We might attempt to create a shell-script containing the calls to `mosmlc`, but it seems more OS-independent to invoke `OS.Process.system` from within `configure.sml`. + +# Build + +The standard options to build are described in its help documentation, which is accessible by invoking `build\ –help` (but not `build\ help` because this builds the HOL documentation). +The file containing this information about options is located at `tools/buildhelp.txt`. + +The most frequently used options to build are those to do with “selftest” level, and the selection of kernel. + +## Regression Testing + +The build program’s `-selftest` option can be given as is (in which case the selftest level is 1), or followed by a positive number, which gives the selftest level explicitly. +The higher the number, the more regression tests are executed. +Developers are expected to categorise their tests so that those at level 1 will complete quickly, those at level 2 will execute in moderate time, and those at level 3 can take as long as is necessary.[^selftestnote] +As this document is written (late 2015), there are no regression tests that require a level greater than 3. + +[^selftestnote]: As of 2015, our automatic testing infrastructure runs selftest level 1 tests 6 times each day, and level 3 tests twice daily. + +There are two standard ways to the install a test that can be run by `build`: + +1. Create a `selftest.exe` executable in an existing directory that build works on. + This executable will be run if `build`’s selftest level is non-zero, and will be passed the level as the executable’s one and only command-line argument. + (The `selftest.exe` can thus choose to do nothing if the level is too low, or to do more if the level is higher.) + + There are a number of examples of constructing `selftest.exe` executables in the sources. + See for example `src/boss/selftest.sml` and `src/boss/Holmakefile`. + Though the `Holmakefile` gives build commands in terms of `$(HOLMOSMLC)`, the `selftest.exe` executable will also be built correctly if running Poly/ML. + +2. Extend the build sequence with a new directory for build to operate on. + As explained in the documentation at the head of `tools/build-sequence`, the name of this directory should be preceded by as many exclamation mark characters\ (`!`) as its desired selftest level. + Using this approach is necessary if the tests need to examine behaviours to do with theory export and loading. + + + +# Sources and Their Organisation {#sources} + +# Appropriate Idioms + + + + diff --git a/developers/releasing-hol b/developers/releasing-hol index 6f5cd4007a..352bb6ded1 100755 --- a/developers/releasing-hol +++ b/developers/releasing-hol @@ -136,7 +136,7 @@ else fi echo ; echo Building documentation -for man_name in Reference Description Tutorial Quick Logic +for man_name in Reference Description Tutorial Quick Logic Developers do lcname=$(echo $man_name | tr A-Z a-z) echo -n " $man_name" From 02c184e5aaa28c06d763037a4f31d27982fb5e61 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 1 Sep 2015 12:12:27 +1000 Subject: [PATCH 455/718] Use explicit template for pandoc to tweak output In particular, get it to include date of build by omitting explicit \date command (then \maketitle puts the current date into the title block). --- Manual/Developers/Makefile | 2 +- Manual/Developers/hol4.latex | 195 +++++++++++++++++++++++++++++++++++ 2 files changed, 196 insertions(+), 1 deletion(-) create mode 100644 Manual/Developers/hol4.latex diff --git a/Manual/Developers/Makefile b/Manual/Developers/Makefile index 058df7b213..dc26a57915 100644 --- a/Manual/Developers/Makefile +++ b/Manual/Developers/Makefile @@ -6,7 +6,7 @@ developers.pdf: developers.tex latexmk -pdf developers developers.tex: developers.md - pandoc -s $< -o $@ + pandoc -s --template=hol4 $< -o $@ developers.html: developers.md pandoc -s $< -o $@ diff --git a/Manual/Developers/hol4.latex b/Manual/Developers/hol4.latex new file mode 100644 index 0000000000..0d7e95e4d8 --- /dev/null +++ b/Manual/Developers/hol4.latex @@ -0,0 +1,195 @@ +\documentclass[$if(fontsize)$$fontsize$,$endif$$if(lang)$$lang$,$endif$$if(papersize)$$papersize$,$endif$$for(classoption)$$classoption$$sep$,$endfor$]{$documentclass$} +$if(fontfamily)$ +\usepackage{$fontfamily$} +$else$ +\usepackage{lmodern} +$endif$ +$if(linestretch)$ +\usepackage{setspace} +\setstretch{$linestretch$} +$endif$ +\usepackage{amssymb,amsmath} +\usepackage{ifxetex,ifluatex} +\usepackage{fixltx2e} % provides \textsubscript +\ifnum 0\ifxetex 1\fi\ifluatex 1\fi=0 % if pdftex + \usepackage[T1]{fontenc} + \usepackage[utf8]{inputenc} +$if(euro)$ + \usepackage{eurosym} +$endif$ +\else % if luatex or xelatex + \ifxetex + \usepackage{mathspec} + \usepackage{xltxtra,xunicode} + \else + \usepackage{fontspec} + \fi + \defaultfontfeatures{Mapping=tex-text,Scale=MatchLowercase} + \newcommand{\euro}{€} +$if(mainfont)$ + \setmainfont{$mainfont$} +$endif$ +$if(sansfont)$ + \setsansfont{$sansfont$} +$endif$ +$if(monofont)$ + \setmonofont[Mapping=tex-ansi]{$monofont$} +$endif$ +$if(mathfont)$ + \setmathfont(Digits,Latin,Greek){$mathfont$} +$endif$ +\fi +% use upquote if available, for straight quotes in verbatim environments +\IfFileExists{upquote.sty}{\usepackage{upquote}}{} +% use microtype if available +\IfFileExists{microtype.sty}{% +\usepackage{microtype} +\UseMicrotypeSet[protrusion]{basicmath} % disable protrusion for tt fonts +}{} +$if(geometry)$ +\usepackage[$for(geometry)$$geometry$$sep$,$endfor$]{geometry} +$endif$ +$if(lang)$ +\ifxetex + \usepackage{polyglossia} + \setmainlanguage{$mainlang$} +\else + \usepackage[shorthands=off,$lang$]{babel} +\fi +$endif$ +$if(natbib)$ +\usepackage{natbib} +\bibliographystyle{$if(biblio-style)$$biblio-style$$else$plainnat$endif$} +$endif$ +$if(biblatex)$ +\usepackage{biblatex} +$if(biblio-files)$ +\bibliography{$biblio-files$} +$endif$ +$endif$ +$if(listings)$ +\usepackage{listings} +$endif$ +$if(lhs)$ +\lstnewenvironment{code}{\lstset{language=Haskell,basicstyle=\small\ttfamily}}{} +$endif$ +$if(highlighting-macros)$ +$highlighting-macros$ +$endif$ +$if(verbatim-in-note)$ +\usepackage{fancyvrb} +\VerbatimFootnotes +$endif$ +$if(tables)$ +\usepackage{longtable,booktabs} +$endif$ +$if(graphics)$ +\usepackage{graphicx} +\makeatletter +\def\maxwidth{\ifdim\Gin@nat@width>\linewidth\linewidth\else\Gin@nat@width\fi} +\def\maxheight{\ifdim\Gin@nat@height>\textheight\textheight\else\Gin@nat@height\fi} +\makeatother +% Scale images if necessary, so that they will not overflow the page +% margins by default, and it is still possible to overwrite the defaults +% using explicit options in \includegraphics[width, height, ...]{} +\setkeys{Gin}{width=\maxwidth,height=\maxheight,keepaspectratio} +$endif$ +\ifxetex + \usepackage[setpagesize=false, % page size defined by xetex + unicode=false, % unicode breaks when used with xetex + xetex]{hyperref} +\else + \usepackage[unicode=true]{hyperref} +\fi +\hypersetup{breaklinks=true, + bookmarks=true, + pdfauthor={$author-meta$}, + pdftitle={$title-meta$}, + colorlinks=true, + citecolor=$if(citecolor)$$citecolor$$else$blue$endif$, + urlcolor=$if(urlcolor)$$urlcolor$$else$blue$endif$, + linkcolor=$if(linkcolor)$$linkcolor$$else$magenta$endif$, + pdfborder={0 0 0}} +\urlstyle{same} % don't use monospace font for urls +$if(links-as-notes)$ +% Make links footnotes instead of hotlinks: +\renewcommand{\href}[2]{#2\footnote{\url{#1}}} +$endif$ +$if(strikeout)$ +\usepackage[normalem]{ulem} +% avoid problems with \sout in headers with hyperref: +\pdfstringdefDisableCommands{\renewcommand{\sout}{}} +$endif$ +\setlength{\parindent}{0pt} +\setlength{\parskip}{6pt plus 2pt minus 1pt} +\setlength{\emergencystretch}{3em} % prevent overfull lines +$if(numbersections)$ +\setcounter{secnumdepth}{5} +$else$ +\setcounter{secnumdepth}{0} +$endif$ +$if(verbatim-in-note)$ +\VerbatimFootnotes % allows verbatim text in footnotes +$endif$ + +$if(title)$ +\title{$title$$if(subtitle)$\\\vspace{0.5em}{\large $subtitle$}$endif$} +$endif$ +$if(author)$ +\author{$for(author)$$author$$sep$ \and $endfor$} +$endif$ +$for(header-includes)$ +$header-includes$ +$endfor$ + +\begin{document} +$if(title)$ +\maketitle +$endif$ +$if(abstract)$ +\begin{abstract} +$abstract$ +\end{abstract} +$endif$ + +$for(include-before)$ +$include-before$ + +$endfor$ +$if(toc)$ +{ +\hypersetup{linkcolor=black} +\setcounter{tocdepth}{$toc-depth$} +\tableofcontents +} +$endif$ +$if(lot)$ +\listoftables +$endif$ +$if(lof)$ +\listoffigures +$endif$ +$body$ + +$if(natbib)$ +$if(biblio-files)$ +$if(biblio-title)$ +$if(book-class)$ +\renewcommand\bibname{$biblio-title$} +$else$ +\renewcommand\refname{$biblio-title$} +$endif$ +$endif$ +\bibliography{$biblio-files$} + +$endif$ +$endif$ +$if(biblatex)$ +\printbibliography$if(biblio-title)$[title=$biblio-title$]$endif$ + +$endif$ +$for(include-after)$ +$include-after$ + +$endfor$ +\end{document} From 5b8c615627de94a2cc04e1f9087b0e81ccd97a7d Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 1 Sep 2015 12:13:23 +1000 Subject: [PATCH 456/718] Tweak developers' manual Using '\ ' (backslash space) between backquotes doesn't create a non-breaking space as I thought it might. --- Manual/Developers/developers.md | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/Manual/Developers/developers.md b/Manual/Developers/developers.md index 07c1dcf7e0..2e88cf7389 100644 --- a/Manual/Developers/developers.md +++ b/Manual/Developers/developers.md @@ -1,7 +1,6 @@ --- title: HOL Developers’ Manual author: HOL4 Developers -date: numbersections: yes --- @@ -61,7 +60,7 @@ We might attempt to create a shell-script containing the calls to `mosmlc`, but # Build -The standard options to build are described in its help documentation, which is accessible by invoking `build\ –help` (but not `build\ help` because this builds the HOL documentation). +The standard options to build are described in its help documentation, which is accessible by invoking `build –help` (but not `build help` because this builds the HOL documentation). The file containing this information about options is located at `tools/buildhelp.txt`. The most frequently used options to build are those to do with “selftest” level, and the selection of kernel. From 8cdc28d48f5a67792732e7d406de45666e4d4167 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 3 Sep 2015 09:52:18 +1000 Subject: [PATCH 457/718] Complete a version 0.9 of the Developers Manual Closes #290 --- Manual/Developers/developers.md | 55 ++++++++++++++++++++++++++++++++- 1 file changed, 54 insertions(+), 1 deletion(-) diff --git a/Manual/Developers/developers.md b/Manual/Developers/developers.md index 2e88cf7389..0f4be7fbf9 100644 --- a/Manual/Developers/developers.md +++ b/Manual/Developers/developers.md @@ -92,7 +92,60 @@ There are two standard ways to the install a test that can be run by `build`: # Sources and Their Organisation {#sources} -# Appropriate Idioms +HOL comes with two `tools` directories, `tools` and `tools-poly`, as well as a `developers` directory. +The `tools-poly` directory is for sources that are specific to the Poly/ML implementation. +The `tools` directory is for general sources, and for sources specific to the Moscow\ ML implementation. +Apart from sources for tools that are genuine command-line executables, the `tools` directory also includes some configuration files and editor “modes”. + +## Tool Executables + +The tools distributed with HOL are described below. +Unless otherwise noted, they are built by the configuration process. + +`build` +: Described [above](#build). + The top-level driver code is in files called `build.sml` in `tools` and `tools-poly`. + Shared code is in `tools/buildutils.sml`. + +`cmp` +: A simple-minded tool for comparing two files, returning (*via* exit code) 0 (success) if the two command-line arguments are byte-for-byte identical. + Useful in regression testing of other tools. + Built on demand *via* a Holmakefile. + +`Holmake` +: The user-facing tool for building HOL developments. + Use of this tool is described in the Description manual. + The `tools/Holmake` directory contains most of the sources, but the Poly/ML version has sources in `tools-poly/Holmake` as well. + Sharing between the two code-bases is entirely done at the leaf level; the top-level drivers are different, implemented in files called `Holmake.sml` in the respective directories. + +`mllex` +: The tool from SML/NJ. + +`mllyacc` +: The tool from SML/NJ. + +`quote-filter` +: The quotation filter that runs over sources before they are seen by SML implementations. + This is used interactively (*via* a Unix filter that preprocesses all user-input), and non-interactively (by being applied to source files). + +## Other Tools Directories + +`tools/build-logs` and `tools-poly/build-logs` +: As each build proceeds, log files recording execution times *per* theory are generated and stored in these directories. + +`tools-poly/poly` +: Implementations of `Binarymap`, `Binaryset`, `Listsort` and `Help` (from the Moscow\ ML library) so that these libraries can be used in Poly/ML. + Also a definition of `load` in `poly-init2.ML`, so that “object code” and its dependencies can be automatically loaded into running sessions. + +`tools/sequences` +: Build sequence files. + These are “modularised” so that, in principle, custom build sequences can be constructed more easily. + +`tools/vim` +: Implementation of the vim editor mode. + + + From 63e95c8e95a9b243eacf4b8cff26955a14f005c9 Mon Sep 17 00:00:00 2001 From: Thibault Gauthier Date: Thu, 3 Sep 2015 13:17:10 +0200 Subject: [PATCH 458/718] holyhammer: taking the prover that returns the less lemmas not the most --- src/holyhammer/hhReconstruct.sml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/holyhammer/hhReconstruct.sml b/src/holyhammer/hhReconstruct.sml index 6e6ee3f4e4..973b3ad140 100644 --- a/src/holyhammer/hhReconstruct.sml +++ b/src/holyhammer/hhReconstruct.sml @@ -224,7 +224,7 @@ fun reconstructl thml atpfilel conjecture = (* else take the one that uses the less lemmas. *) else let - fun compare_list l1 l2 = length l1 > length l2 + fun compare_list l1 l2 = length l1 < length l2 val axl = hd (sort compare_list (map snd proofl)) in reprove thml axl conjecture From 08b750fdf2f6012a69a4222a94fd08b8154dbff0 Mon Sep 17 00:00:00 2001 From: Magnus Myreen Date: Tue, 8 Sep 2015 13:02:46 +0200 Subject: [PATCH 459/718] decompile.py made executable --- examples/machine-code/graph/decompile.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) mode change 100644 => 100755 examples/machine-code/graph/decompile.py diff --git a/examples/machine-code/graph/decompile.py b/examples/machine-code/graph/decompile.py old mode 100644 new mode 100755 From 9a51218669f00ca91267f9dd114608718077a8ac Mon Sep 17 00:00:00 2001 From: Thibault Gauthier Date: Wed, 9 Sep 2015 18:39:42 +0200 Subject: [PATCH 460/718] holyhammer: cleaning up experiments --- src/holyhammer/hhWriter.sig | 1 - src/holyhammer/hhWriter.sml | 37 ----------------------------------- src/holyhammer/holyHammer.sml | 24 ----------------------- 3 files changed, 62 deletions(-) diff --git a/src/holyhammer/hhWriter.sig b/src/holyhammer/hhWriter.sig index d98f3d67dd..a68fdceb55 100644 --- a/src/holyhammer/hhWriter.sig +++ b/src/holyhammer/hhWriter.sig @@ -7,7 +7,6 @@ sig val write_hh_thyl : string -> string list -> unit val write_conjecture : string -> term -> unit val write_thydep : string -> string list -> unit - val write_hh_thml : string -> string -> string list -> (string * Thm.thm) list -> unit val reserved_names_escaped : string list diff --git a/src/holyhammer/hhWriter.sml b/src/holyhammer/hhWriter.sml index 77878c9aab..26e5ce985e 100644 --- a/src/holyhammer/hhWriter.sml +++ b/src/holyhammer/hhWriter.sml @@ -482,41 +482,4 @@ fun write_conjecture file conjecture = (* TO DO: put it in a subdirectory *) ) else raise ERR "write_conjecture" "conjecture is not a boolean" -(*--------------------------------------------------------------------------- - Print only selected theorems. - ----------------------------------------------------------------------------*) - -fun write_hh_thy_const folder thy = - ( - hh_thy_start folder thy; - let val l = dest_theory thy in - case l of THEORY(_,t) => - ( - app (hh_tydef thy) (#types t); - app (hh_constdef thy) (#consts t) - ) - end; - hh_thy_end () - ) - -fun write_hh_thyl_const folder thyl = - ( - reset_dicts(); - app (write_hh_thy_const folder) (sort_thyl thyl) - ) - -fun write_hh_thml_aux file thmnamel = (* TO DO: put it in a subdirectory *) - let val thml = map (fn x => (x,"ax")) thmnamel in - oc := openOut file; - app export_thm thml; - closeOut (!oc); oc := stdOut - end - -fun write_hh_thml folder file thyl namethml = - ( - write_hh_thyl_const folder thyl; - write_hh_thml_aux file namethml - ) - - end diff --git a/src/holyhammer/holyHammer.sml b/src/holyhammer/holyHammer.sml index 845dce2d98..c87f630bf2 100644 --- a/src/holyhammer/holyHammer.sml +++ b/src/holyhammer/holyHammer.sml @@ -124,30 +124,6 @@ fun export cj = write_thydep (thy_dir ^ "/thydep") thyl end -fun export_namethml cj namethml = - let - val ct = current_theory () - val thyl = ct :: Theory.ancestry ct - in - (* write constants of loaded theories and some theorems *) - write_hh_thml thy_dir (thy_dir ^ "/problem") thyl namethml; - (* write the conjecture in thf format *) - write_conjecture (thy_dir ^ "/conjecture") cj; - (* write the dependencies between theories *) - write_thydep (thy_dir ^ "/thydep") thyl - end - - -(* TO DO: Incremental export -fun export_thyl thy_dir thyl = - let val thyl' = List.filter (fn x => not (mem x (!exported_thyl))) thyl in - write_hh_thyl thy_dir thyl; - -fun export_ct ct_dir ct = - clean_dir ct_dir; - write_hh_thy ct -*) - (*--------------------------------------------------------------------------- Main helpers ----------------------------------------------------------------------------*) From ccaa1d67ec009d483e43db48c7a9251405fbf505 Mon Sep 17 00:00:00 2001 From: Thibault Gauthier Date: Wed, 9 Sep 2015 22:33:19 +0200 Subject: [PATCH 461/718] holyhammer: refractoring hhReconstruct.sml --- src/holyhammer/hhReconstruct.sig | 4 +- src/holyhammer/hhReconstruct.sml | 190 ++++++++++++++----------------- src/holyhammer/holyHammer.sml | 4 +- 3 files changed, 92 insertions(+), 106 deletions(-) diff --git a/src/holyhammer/hhReconstruct.sig b/src/holyhammer/hhReconstruct.sig index 6675d46f08..4bf18fc412 100644 --- a/src/holyhammer/hhReconstruct.sig +++ b/src/holyhammer/hhReconstruct.sig @@ -3,7 +3,7 @@ sig include Abbrev val minimize_flag : bool ref - val reconstruct : thm list -> (string * string) -> term -> unit - val reconstructl : thm list -> (string * string) list -> term -> unit + val reconstruct : (string * string) -> term -> unit + val reconstructl : (string * string) list -> term -> unit end diff --git a/src/holyhammer/hhReconstruct.sml b/src/holyhammer/hhReconstruct.sml index 973b3ad140..3dc0b0cf53 100644 --- a/src/holyhammer/hhReconstruct.sml +++ b/src/holyhammer/hhReconstruct.sml @@ -54,9 +54,6 @@ fun split_name s = case String.fields (fn c => c = #"/") s of [_,thy,name] => (thy,name) | _ => raise ERR "split_name" "" -fun fetchl l = - List.map (fn (thy,name) => ((thy,name),DB.fetch thy name)) l - (*--------------------------------------------------------------------------- Reading the ATP file. ----------------------------------------------------------------------------*) @@ -76,79 +73,43 @@ fun readl path = (TextIO.closeIn file; l3) end -fun read_status path = - remove_white_spaces (hd (readl path)) handle _ => "Unknown" +fun read_status atp_status = + remove_white_spaces (hd (readl atp_status)) handle _ => "Unknown" -(*--------------------------------------------------------------------------- - Timed Metis - ----------------------------------------------------------------------------*) - -fun time_metis thml conjecture time = - let - val oldlimit = !mlibMetis.limit - val oldtracelevel = !mlibUseful.trace_level - val thm = - ( - metisTools.limit := {time = SOME time, infs = NONE}; - mlibUseful.trace_level := 0; - metisTools.METIS_PROVE thml conjecture - ) - in - (metisTools.limit := oldlimit; mlibUseful.trace_level := oldtracelevel; thm) +fun read_lemmas atp_out = + let + val l = readl atp_out + val l' = filter (fn x => not (mem x reserved_names_escaped)) l + in + map (split_name o hh_unescape o unsquotify) l' end -(*--------------------------------------------------------------------------- - Minimization. Can be turned off by minimize_flag if it takes too much time. - ----------------------------------------------------------------------------*) - -(* internal use *) -fun third (a,b,c) = c - -val minimize_flag = ref true - -fun minimize_loop l1 l2 cj = - if null l2 then l1 else - if can (time_metis (map third (l1 @ tl l2)) cj) 2.0 - then minimize_loop l1 (tl l2) cj - else minimize_loop (hd l2 :: l1) (tl l2) cj - -fun minimize l cj = - ( - print "Minimization ...\n"; - if can (time_metis (map third l) cj) 2.0 - then minimize_loop [] l cj - else l - ) - -(* external use *) -fun hh_minimize_loop l1 l2 cj = - if null l2 then l1 else - if can (time_metis (l1 @ tl l2) cj) 2.0 - then hh_minimize_loop l1 (tl l2) cj - else hh_minimize_loop (hd l2 :: l1) (tl l2) cj +fun atp_lemmas (atp_status,atp_out) = + let val s = read_status atp_status in + if s = "Theorem" + then (s, (read_lemmas atp_out)) + else (s, []) + end -fun hh_minimize l cj = - if can (time_metis l cj) 2.0 - then hh_minimize_loop [] l cj - else l +exception Status of string +fun atp_lemmas_exn (atp_status,atp_out) = + let val s = read_status atp_status in + if s = "Theorem" + then (read_lemmas atp_out) + else raise Status s + end (*--------------------------------------------------------------------------- - Reconstruction and printing (depends on DB.fetch) + Pretty-printing for lemmas. ----------------------------------------------------------------------------*) -exception Status of string - val ppstrm_stdout = PP.mk_ppstream {consumer = fn s => TextIO.output(TextIO.stdOut, s), linewidth = 80, flush = fn () => TextIO.flushOut TextIO.stdOut} - -fun depid_of_thm thm = depid_of (dep_of (tag thm)) -fun has_depid (name,thm) = can depid_of_thm thm - -fun pp_lemmas ppstrm lemmas = +fun pp_lemmas_aux ppstrm lemmas = let open Portable val {add_string,add_break,begin_block, @@ -166,7 +127,7 @@ fun pp_lemmas ppstrm lemmas = end_block(); add_string "]"; end_block()) - fun pp_lemma (_,(thy,name),thm) = + fun pp_lemma (thy,name) = add_string (String.concatWith " " ["fetch", quote thy, quote name]) in begin_block INCONSISTENT 0; @@ -177,57 +138,82 @@ fun pp_lemmas ppstrm lemmas = flush_ppstream() end -fun reprove thml axl cj = +fun pp_lemmas lemmas = (pp_lemmas_aux ppstrm_stdout lemmas; print "\n") + +(*--------------------------------------------------------------------------- + Timed Metis. + ----------------------------------------------------------------------------*) + +fun time_metis thml conjecture time = let - (* reserved theorems are not required by Metis *) - val axl1 = filter (fn x => not (mem x reserved_names_escaped)) axl - val sl = map (hh_unescape o unsquotify) axl1 - val axl2 = fetchl (map split_name sl) - val l1 = map (fn thm => (false,("",""),thm)) thml @ - map (fn (name,thm) => (true,name,thm)) axl2 - val l2 = if !minimize_flag then minimize l1 cj else l1 - (* TO DO: external reconstruction *) - val l3 = filter (fn (b,_,_) => b) l2 + val oldlimit = !mlibMetis.limit + val oldtracelevel = !mlibUseful.trace_level + val thm = + ( + metisTools.limit := {time = SOME time, infs = NONE}; + mlibUseful.trace_level := 0; + metisTools.METIS_PROVE thml conjecture + ) in - pp_lemmas ppstrm_stdout l3; - print "\n"; - ignore (time_metis (map third l2) cj 30.0) + (metisTools.limit := oldlimit; mlibUseful.trace_level := oldtracelevel; thm) end -fun reconstruct thml (atp_status,atp_out) conjecture = - let val s = read_status atp_status in - if s = "Theorem" - then reprove thml (readl atp_out) conjecture - else raise Status s - end +(*--------------------------------------------------------------------------- + Minimization. Can be turned off by minimize_flag if it takes too much time. + ----------------------------------------------------------------------------*) + +val minimize_flag = ref true + +fun minimize_lemmas_loop l1 l2 cj = + if null l2 then l1 else + if can (time_metis (map snd (l1 @ tl l2)) cj) 2.0 + then minimize_lemmas_loop l1 (tl l2) cj + else minimize_lemmas_loop (hd l2 :: l1) (tl l2) cj + +fun minimize_lemmas lemmas cj = + let val l = map (fn (thy,nm) => ((thy,nm), fetch thy nm)) lemmas in + if can (time_metis (map snd l) cj) 2.0 + then ( + print "Minimization ...\n"; + pp_lemmas (map fst (minimize_lemmas_loop [] l cj)) + ) + else + if can (time_metis (map snd l) cj) 30.0 + then pp_lemmas lemmas + else ( + pp_lemmas lemmas; + raise ERR "minimize_lemmas" "Metis timed out after 30 seconds." + ) + end -fun reconstructl thml atpfilel conjecture = +(*--------------------------------------------------------------------------- + Reconstruction. + ----------------------------------------------------------------------------*) + +fun reconstruct (atp_status,atp_out) cj = + minimize_lemmas (atp_lemmas_exn (atp_status,atp_out)) cj + +fun reconstructl atpfilel cj = let - fun process (atp_status,atp_out) = - let val s = read_status atp_status in - if s = "Theorem" then (s, readl atp_out) else (s, []) - end - val processedl = map process atpfilel - val proofl = filter (fn (x,_) => x = "Theorem") processedl + val lemmasl = map atp_lemmas atpfilel + val proofl = filter (fn (x,_) => x = "Theorem") lemmasl in - (* If no proof is found, *) + (* If no proof is found, find a not "Unknown" message *) if null proofl - then - let - val status_list = map fst processedl - val s = if all (fn x => x = "Unknown") status_list - then "Unknown" - else hd (filter (fn x => x <> "Unknown") status_list) - in - raise Status s - end + then + let val s = if all (fn x => x = "Unknown") (map fst lemmasl) + then "Unknown" + else hd (filter (fn x => x <> "Unknown") (map fst lemmasl)) + in + raise Status s + end (* else take the one that uses the less lemmas. *) else let - fun compare_list l1 l2 = length l1 < length l2 - val axl = hd (sort compare_list (map snd proofl)) + fun cmp l1 l2 = length l1 < length l2 + val lemmas = hd (sort cmp (map snd proofl)) in - reprove thml axl conjecture + minimize_lemmas lemmas cj end end diff --git a/src/holyhammer/holyHammer.sml b/src/holyhammer/holyHammer.sml index c87f630bf2..3e87e95a60 100644 --- a/src/holyhammer/holyHammer.sml +++ b/src/holyhammer/holyHammer.sml @@ -162,7 +162,7 @@ fun hh_argl thml cj argl = cmd_in_dir scripts_dir "sh hh_clean.sh"; export new_cj; cmd_in_dir scripts_dir ("sh hh.sh " ^ argl); - reconstructl thml atpfilel cj + reconstructl atpfilel new_cj end fun hh thml cj = @@ -193,7 +193,7 @@ fun hh_atp atp thml cj = cmd_in_dir scripts_dir "sh hh_clean.sh"; export new_cj; cmd_in_dir scripts_dir ("sh " ^ hh_of_prover atp ^ " " ^ argl); - reconstruct thml (status_of_prover atp, out_of_prover atp) cj + reconstruct (status_of_prover atp, out_of_prover atp) new_cj end (* Derived function *) From 2594d90c93a0502df53f8f911c759033036d9c88 Mon Sep 17 00:00:00 2001 From: Thibault Gauthier Date: Wed, 9 Sep 2015 23:23:16 +0200 Subject: [PATCH 462/718] holyhammer: updating hh_try function --- src/holyhammer/holyHammer.sig | 2 +- src/holyhammer/holyHammer.sml | 23 ++++++++++++++--------- 2 files changed, 15 insertions(+), 10 deletions(-) diff --git a/src/holyhammer/holyHammer.sig b/src/holyhammer/holyHammer.sig index f2603a9893..5ab1a66dec 100644 --- a/src/holyhammer/holyHammer.sig +++ b/src/holyhammer/holyHammer.sig @@ -5,7 +5,7 @@ sig datatype ATP = Eprover | Vampire | Z3 val hh : Thm.thm list -> Term.term -> unit - val hh_try : Thm.thm list -> Term.term -> unit + val hh_try : Thm.thm list -> Term.term -> int -> unit val hh_atp : ATP -> Thm.thm list -> Term.term -> unit val hh_goal : Thm.thm list -> Term.term list * Term.term -> unit diff --git a/src/holyhammer/holyHammer.sml b/src/holyhammer/holyHammer.sml index 3e87e95a60..d3879aa9cb 100644 --- a/src/holyhammer/holyHammer.sml +++ b/src/holyhammer/holyHammer.sml @@ -170,19 +170,24 @@ fun hh thml cj = (mk_argl (!eprover_settings,!vampire_settings,!z3_settings)) (* Try best strategies sequentially *) -fun hh_try thml cj = +fun hh_try thml cj time = let - val strat1 = ((KNN,128,5),(KNN,96,5),(KNN,32,5)) - val strat2 = ((Mepo,128,5),(Mepo,96,5),(Mepo,32,5)) - val strat3 = ((Kepo,128,5),(Kepo,96,5),(Kepo,32,5)) + val negcj = mk_neg cj + val strat1 = ((KNN,128,time),(KNN,96,time),(KNN,32,time)) + val strat2 = ((Mepo,128,time),(Mepo,96,time),(Mepo,32,time)) + val strat3 = ((KNN,128*2,time),(KNN,96*2,time),(KNN,32*2,time)) + val strat4 = ((Mepo,128*2,time),(Mepo,96*2,time),(Mepo,32*2,time)) in - (hh_argl thml cj (mk_argl strat1) handle _ => - hh_argl thml cj (mk_argl strat2)) handle _ => - hh_argl thml cj (mk_argl strat3) + (print "Try KNN ...\n"; hh_argl thml cj (mk_argl strat1)) handle _ => + (print "Try Mepo ...\n"; hh_argl thml cj (mk_argl strat2)) handle _ => + (print "Doubling the number of predictions\n"; + print "Try KNN ...\n"; hh_argl thml cj (mk_argl strat3)) handle _ => + (print "Try Mepo ...\n"; hh_argl thml cj (mk_argl strat4)) handle _ => + (print "Proving the negation ...\n"; + hh_argl thml (mk_neg cj) (mk_argl strat1)) end -(* Let you chose the specific prover you want to use either - ("eprover", "vampire" or "z3") *) +(* Let you chose the specific prover you want to use either *) fun hh_atp atp thml cj = let val new_cj = prepare_cj thml cj From f5217420f4617c847369f473bdb8cda436f51cc9 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 10 Sep 2015 09:45:21 +1000 Subject: [PATCH 463/718] type_grammar.sml now uses record type internally This is a prelude to changing behaviours and fixing bugs. I didn't like the look of an anonymous 4-tuple when I came to start working on this file. --- src/parse/type_grammar.sml | 92 ++++++++++++++++++++++---------------- 1 file changed, 53 insertions(+), 39 deletions(-) diff --git a/src/parse/type_grammar.sml b/src/parse/type_grammar.sml index 9846c0d3f5..520efb311e 100644 --- a/src/parse/type_grammar.sml +++ b/src/parse/type_grammar.sml @@ -1,6 +1,7 @@ structure type_grammar :> type_grammar = struct +open Lib datatype grammar_rule = INFIX of {opname : string, parse_string : string} list * HOLgrammars.associativity @@ -17,10 +18,19 @@ fun typstruct_uptodate ts = -datatype grammar = TYG of (int * grammar_rule) list * - string list * - (string, type_structure) Binarymap.dict * - (int * string) TypeNet.typenet +datatype grammar = TYG of { rules : (int * grammar_rule) list, + suffixes : string list, + abbparse : (string, type_structure) Binarymap.dict, + abbprint : (int * string) TypeNet.typenet} + +fun fupdate_rules f (TYG{rules,suffixes,abbprint,abbparse}) = + TYG{rules=f rules,suffixes=suffixes,abbprint=abbprint,abbparse=abbparse} +fun fupdate_suffixes f (TYG{rules,suffixes,abbprint,abbparse}) = + TYG{rules=rules,suffixes=f suffixes,abbprint=abbprint,abbparse=abbparse} +fun fupdate_abbprint f (TYG{rules,suffixes,abbprint,abbparse}) = + TYG{rules=rules,suffixes=suffixes,abbprint=f abbprint,abbparse=abbparse} +fun fupdate_abbparse f (TYG{rules,suffixes,abbprint,abbparse}) = + TYG{rules=rules,suffixes=suffixes,abbprint=abbprint,abbparse=f abbparse} open HOLgrammars @@ -86,8 +96,7 @@ fun insert_sorted (k, v) [] = [(k, v)] kv2 :: insert_sorted kv1 rest end -fun new_binary_tyop (TYG(G,sfxs,abbrevs,pmap)) - {precedence, infix_form, opname, associativity} = +fun new_binary_tyop g {precedence, infix_form, opname, associativity} = let val rule = if isSome infix_form then @@ -97,10 +106,11 @@ fun new_binary_tyop (TYG(G,sfxs,abbrevs,pmap)) else (precedence, INFIX([{parse_string = opname, opname = opname}], associativity)) in - TYG (insert_sorted rule G, Lib.insert opname sfxs, abbrevs, pmap) + g |> fupdate_rules (insert_sorted rule) + |> fupdate_suffixes (Lib.insert opname) end -fun remove_binary_tyop (TYG (G, sfxs, abbrevs, pmap)) s = let +fun remove_binary_tyop g s = let fun bad_irule {parse_string,...} = parse_string = s fun edit_rule (prec, r) = case r of @@ -111,20 +121,18 @@ fun remove_binary_tyop (TYG (G, sfxs, abbrevs, pmap)) s = let else SOME (prec, INFIX (irules', assoc)) end in - TYG(List.mapPartial edit_rule G, sfxs, abbrevs, pmap) + g |> fupdate_rules (List.mapPartial edit_rule) end -fun new_tyop (TYG(G,sfxs,abbrevs,pmap)) name = - TYG (G, name::sfxs, abbrevs, pmap) +fun new_tyop g name = g |> fupdate_suffixes (cons name) -val empty_grammar = TYG ([], - [], - Binarymap.mkDict String.compare, - TypeNet.empty) +val empty_grammar = TYG { rules = [], suffixes = [], + abbparse = Binarymap.mkDict String.compare, + abbprint = TypeNet.empty} -fun rules (TYG (G, sfxs, dict, pmap)) = {infixes = G, suffixes = sfxs} -fun abbreviations (TYG (G, sfxs, dict, pmap)) = dict +fun rules (TYG gr) = {infixes = #rules gr, suffixes = #suffixes gr} +fun abbreviations (TYG gr) = #abbparse gr fun check_structure st = let fun param_numbers (PARAM i, pset) = HOLset.add(pset, i) @@ -143,26 +151,30 @@ in end val abb_tstamp = ref 0 -fun new_abbreviation (TYG(G, sfxs,dict0,pmap)) (s, st) = let +fun new_abbreviation tyg (s, st) = let val _ = check_structure st val _ = case st of PARAM _ => raise GrammarError "Abbreviation can't be to a type variable" | _ => () - val G0 = TYG(G, sfxs,Binarymap.insert(dict0,s,st), - TypeNet.insert(pmap, structure_to_type st, (!abb_tstamp, s))) - val _ = abb_tstamp := !abb_tstamp + 1 + val result = + tyg |> fupdate_abbparse (fn d => Binarymap.insert(d,s,st)) + |> fupdate_abbprint + (fn pmap => TypeNet.insert(pmap, structure_to_type st, + (!abb_tstamp, s))) + |> C new_tyop s in - new_tyop G0 s + abb_tstamp := !abb_tstamp + 1; + result end -fun remove_abbreviation(arg as TYG(G, sfxs,dict0, pmap0)) s = let - val (dict,st) = Binarymap.remove(dict0,s) - val pmap = #1 (TypeNet.delete(pmap0, structure_to_type st)) - handle Binarymap.NotFound => pmap0 +fun remove_abbreviation g s = let + val (dict,st) = Binarymap.remove(abbreviations g,s) + fun doprint pmap0 = #1 (TypeNet.delete(pmap0, structure_to_type st)) + handle Binarymap.NotFound => pmap0 in - TYG(G, sfxs, dict, pmap) -end handle Binarymap.NotFound => arg + g |> fupdate_abbparse (K dict) |> fupdate_abbprint doprint +end handle Binarymap.NotFound => g fun rev_append [] acc = acc | rev_append (x::xs) acc = rev_append xs (x::acc) @@ -191,8 +203,10 @@ fun merge_pmaps (p1, p2) = fun merge_grammars (G1, G2) = let (* both grammars are sorted, with no adjacent suffixes *) - val TYG (grules1, sfxs1, abbrevs1, pmap1) = G1 - val TYG (grules2, sfxs2, abbrevs2, pmap2) = G2 + val TYG { rules = grules1, suffixes = sfxs1, abbparse = abbrevs1, + abbprint = pmap1 } = G1 + val TYG { rules = grules2, suffixes = sfxs2, abbparse = abbrevs2, + abbprint = pmap2 } = G2 fun merge_acc acc (gs as (g1, g2)) = case gs of ([], _) => rev_append acc g2 @@ -205,13 +219,14 @@ fun merge_grammars (G1, G2) = let | EQUAL => merge_acc ((g1k, merge g1v g2v)::acc) (g1rest, g2rest) end in - TYG (merge_acc [] (grules1, grules2), - Lib.union sfxs1 sfxs2, - merge_abbrevs G2 (abbrevs1, abbrevs2), - merge_pmaps (pmap1, pmap2)) + TYG { rules = merge_acc [] (grules1, grules2), + suffixes = Lib.union sfxs1 sfxs2, + abbparse = merge_abbrevs G2 (abbrevs1, abbrevs2), + abbprint = merge_pmaps (pmap1, pmap2) } end -fun prettyprint_grammar pps (G as TYG (g,sfxs,abbrevs,pmap)) = let +fun prettyprint_grammar pps G = let + val TYG { rules=g, suffixes=sfxs, abbparse=abbrevs, abbprint=pmap } = G open Portable Lib val {add_break,add_newline,add_string,begin_block,end_block,...} = with_ppstream pps @@ -348,7 +363,7 @@ fun tysize ty = 1 + List.foldl (fn (ty,acc) => tysize ty + acc) 0 Args end -fun abb_dest_type0 (TYG(_, _, _, pmap)) ty = let +fun abb_dest_type0 (TYG{ abbprint = pmap, ...}) ty = let open HolKernel val net_matches = TypeNet.match(pmap, ty) fun mymatch pat ty = let @@ -382,14 +397,14 @@ end fun abb_dest_type G ty = if !print_abbrevs then abb_dest_type0 G ty else Type.dest_type ty -fun disable_abbrev_printing s (arg as TYG(G,sfxs,abbs,pmap)) = +fun disable_abbrev_printing s (arg as TYG{abbparse=abbs, abbprint=pmap, ...}) = case Binarymap.peek(abbs, s) of NONE => arg | SOME st => let val ty = structure_to_type st val (pmap', (_,s')) = TypeNet.delete(pmap, ty) in - if s = s' then TYG(G, sfxs,abbs, pmap') + if s = s' then fupdate_abbprint (K pmap') arg else arg end handle Binarymap.NotFound => arg (* ---------------------------------------------------------------------- @@ -399,7 +414,6 @@ fun disable_abbrev_printing s (arg as TYG(G,sfxs,abbs,pmap)) = fun, which also has an infix -> presentation ---------------------------------------------------------------------- *) -open Lib val min_grammar = empty_grammar |> C new_tyop "bool" |> C new_tyop "ind" From b6daee1d9bd80ea4323d6eef9f6a8d386e815f9c Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 10 Sep 2015 09:58:42 +1000 Subject: [PATCH 464/718] Make early tests follow building of first heap This makes those tests execute considerably faster. --- tools/sequences/kernel | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tools/sequences/kernel b/tools/sequences/kernel index 4f1087cd4c..2547c8114e 100644 --- a/tools/sequences/kernel +++ b/tools/sequences/kernel @@ -10,11 +10,11 @@ src/postkernel src/parse src/bool src/1 +src/proofman +[poly]bin/hol.bare !tools/Holmake/tests/depchain1/dir3 !tools/Holmake/tests/depchain2/dir1 !tools/Holmake/tests/altquote1 !tools/Holmake/tests/brokenstrings !tools/Holmake/tests/holdep !src/1/theory_tests -src/proofman -[poly]bin/hol.bare From 56476c26397470f1591055fa9b65cf519c0027b2 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 10 Sep 2015 09:59:51 +1000 Subject: [PATCH 465/718] Record dependency of first heap on type_grammar.uo --- src/proofman/Holmakefile | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/proofman/Holmakefile b/src/proofman/Holmakefile index 9aa43b9734..127a0e926d 100644 --- a/src/proofman/Holmakefile +++ b/src/proofman/Holmakefile @@ -22,7 +22,8 @@ DEPS = $(BOOLLIB) $(BOOLTHEORY) $(PRIMREC) $(TERMPP) \ $(dprot $(SIGOBJ)/Drule.uo) \ $(dprot $(SIGOBJ)/TheoryPP.uo) \ $(dprot $(SIGOBJ)/Conv.uo) \ - $(dprot $(SIGOBJ)/ParseDatatype.uo) + $(dprot $(SIGOBJ)/ParseDatatype.uo) \ + $(dprot $(SIGOBJ)/type_grammar.uo) EXTRA_CLEANS = $(TARGET) From 081809bab5a50ed13f692b98dd9d3408447f8d9b Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 10 Sep 2015 10:03:47 +1000 Subject: [PATCH 466/718] Replace old with new type abbreviations properly Closes #294 --- src/1/theory_tests/gh294aScript.sml | 8 ++++++++ src/1/theory_tests/gh294bScript.sml | 8 ++++++++ src/1/theory_tests/gh294cScript.sml | 14 +++++++++++++ src/parse/type_grammar.sml | 32 ++++++++++++++++++++++------- 4 files changed, 55 insertions(+), 7 deletions(-) create mode 100644 src/1/theory_tests/gh294aScript.sml create mode 100644 src/1/theory_tests/gh294bScript.sml create mode 100644 src/1/theory_tests/gh294cScript.sml diff --git a/src/1/theory_tests/gh294aScript.sml b/src/1/theory_tests/gh294aScript.sml new file mode 100644 index 0000000000..0b2ead198f --- /dev/null +++ b/src/1/theory_tests/gh294aScript.sml @@ -0,0 +1,8 @@ +open HolKernel Parse boolLib + +val _ = new_theory "gh294a"; + +val _ = type_abbrev("foo", ``:bool -> bool``) + + +val _ = export_theory(); diff --git a/src/1/theory_tests/gh294bScript.sml b/src/1/theory_tests/gh294bScript.sml new file mode 100644 index 0000000000..209d7f817a --- /dev/null +++ b/src/1/theory_tests/gh294bScript.sml @@ -0,0 +1,8 @@ +open HolKernel Parse boolLib + +val _ = new_theory "gh294b"; + +val _ = type_abbrev("foo", ``:bool -> bool -> bool``) + + +val _ = export_theory(); diff --git a/src/1/theory_tests/gh294cScript.sml b/src/1/theory_tests/gh294cScript.sml new file mode 100644 index 0000000000..a267fc8fe8 --- /dev/null +++ b/src/1/theory_tests/gh294cScript.sml @@ -0,0 +1,14 @@ +open HolKernel Parse boolLib + +open gh294aTheory gh294bTheory + +val _ = new_theory "gh294c"; + +val _ = disable_tyabbrev_printing "foo" + +val s = type_to_string ``:bool -> bool -> bool`` = ":bool -> bool -> bool" + orelse + raise Fail "Test fails" + + +val _ = export_theory(); diff --git a/src/parse/type_grammar.sml b/src/parse/type_grammar.sml index 520efb311e..a4adbda428 100644 --- a/src/parse/type_grammar.sml +++ b/src/parse/type_grammar.sml @@ -151,8 +151,33 @@ in end val abb_tstamp = ref 0 +fun remove_abbreviation g s = let + val (dict,st) = Binarymap.remove(abbreviations g,s) + fun doprint pmap0 = #1 (TypeNet.delete(pmap0, structure_to_type st)) + handle Binarymap.NotFound => pmap0 +in + g |> fupdate_abbparse (K dict) |> fupdate_abbprint doprint +end handle Binarymap.NotFound => g + fun new_abbreviation tyg (s, st) = let val _ = check_structure st + val tyg = case Binarymap.peek(abbreviations tyg, s) of + NONE => tyg + | SOME st' => + if st = st' then tyg + else + let + val tyg' = remove_abbreviation tyg s + in + Feedback.HOL_WARNING + "type_grammar" + "new_abbreviation" + ("Replacing old mapping from " ^ s ^ " to "^ + PP.pp_to_string (!Globals.linewidth) + (pp_type tyg') + (structure_to_type st')); + tyg' + end val _ = case st of PARAM _ => raise GrammarError "Abbreviation can't be to a type variable" @@ -168,13 +193,6 @@ in result end -fun remove_abbreviation g s = let - val (dict,st) = Binarymap.remove(abbreviations g,s) - fun doprint pmap0 = #1 (TypeNet.delete(pmap0, structure_to_type st)) - handle Binarymap.NotFound => pmap0 -in - g |> fupdate_abbparse (K dict) |> fupdate_abbprint doprint -end handle Binarymap.NotFound => g fun rev_append [] acc = acc | rev_append (x::xs) acc = rev_append xs (x::acc) From 111800f70b42ceb98ae14684de56ee428f83510e Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 10 Sep 2015 16:29:57 +1000 Subject: [PATCH 467/718] Implement and document remove_type_abbrev. Closes #148 --- .../Parse.disable_tyabbrev_printing.doc | 2 +- help/Docfiles/Parse.remove_type_abbrev.doc | 42 +++++++++++++++++++ help/Docfiles/Parse.type_abbrev.doc | 2 +- src/1/selftest.sml | 11 +++++ src/parse/Parse.sig | 2 + src/parse/Parse.sml | 14 +++++++ 6 files changed, 71 insertions(+), 2 deletions(-) create mode 100644 help/Docfiles/Parse.remove_type_abbrev.doc diff --git a/help/Docfiles/Parse.disable_tyabbrev_printing.doc b/help/Docfiles/Parse.disable_tyabbrev_printing.doc index aa01ea797b..491114d411 100644 --- a/help/Docfiles/Parse.disable_tyabbrev_printing.doc +++ b/help/Docfiles/Parse.disable_tyabbrev_printing.doc @@ -56,6 +56,6 @@ this function, {temp_disable_tyabbrev_printing} that does not cause its effect to persist with an exported theory. \SEEALSO -Parse.type_abbrev. +Parse.remove_type_abbrev, Parse.type_abbrev. \ENDDOC diff --git a/help/Docfiles/Parse.remove_type_abbrev.doc b/help/Docfiles/Parse.remove_type_abbrev.doc new file mode 100644 index 0000000000..56db98b665 --- /dev/null +++ b/help/Docfiles/Parse.remove_type_abbrev.doc @@ -0,0 +1,42 @@ +\DOC + +\TYPE {remove_type_abbrev : string -> unit} + +\SYNOPSIS +Remove a type abbreviation from the type grammar. + +\KEYWORDS +parsing, pretty-printing. + +\DESCRIBE +A call to {remove_type_abbrev s} removes the type abbreviation keyed +on string {s}. As with other functions affecting the global grammar, +there is a companion function, {temp_remove_type_abbrev}, which +affects the grammar but does not cause the effect to be replayed in +descendant theories. + +\FAILURE +Never fails. If the specified string is not a current abbreviation, +the call has no effect on the grammar. + +\EXAMPLE +The standard theory context (where {pred_set} is loaded), includes an +abbreviation mapping {``:'a set``} to {``:'a -> bool``}. It doesn't +print the abbreviated form back to the user, because its printing has +been disabled with {disable_tyabbrev_printing}. + +{ + > ``:'a set``; + val it = ``:'a -> bool`` : hol_type + + > remove_type_abbrev "set"; + val it = (): unit + + > ``:'a set``; + Exception- HOL_ERR ... +} + +\SEEALSO +Parse.disable_tyabbrev_printing, Parse.type_abbrev. + +\ENDDOC diff --git a/help/Docfiles/Parse.type_abbrev.doc b/help/Docfiles/Parse.type_abbrev.doc index 8bb328b9e8..7a4b963240 100644 --- a/help/Docfiles/Parse.type_abbrev.doc +++ b/help/Docfiles/Parse.type_abbrev.doc @@ -64,5 +64,5 @@ abbreviations (using {Parse.disable_tyabbrev_printing}), or to not print any (by setting the trace variable {"print_tyabbrevs"}). \SEEALSO -Parse.add_infix_type, Parse.disable_tyabbrev_printing. +Parse.add_infix_type, Parse.disable_tyabbrev_printing, Parse.remove_type_abbrev. \ENDDOC diff --git a/src/1/selftest.sml b/src/1/selftest.sml index b3eb78c12e..051e37df06 100644 --- a/src/1/selftest.sml +++ b/src/1/selftest.sml @@ -572,5 +572,16 @@ val _ = let in if hyp th = [] then print "OK\n" else die "FAILED" end handle _ => die "FAILED!" +val _ = let + val _ = tprint "Removing type abbreviation" + val _ = temp_type_abbrev ("foo", ``:'a -> bool``) + val s1 = type_to_string ``:bool -> bool`` + val _ = s1 = ":bool foo" orelse die "FAILED!" + val _ = temp_remove_type_abbrev "foo" + val s2 = type_to_string ``:bool -> bool`` +in + if s2 = ":bool -> bool" then print "OK\n" else die "FAILED!" +end + val _ = Process.exit (if List.all substtest tests then Process.success else Process.failure) diff --git a/src/parse/Parse.sig b/src/parse/Parse.sig index d10ee1dc33..3b969af4b5 100644 --- a/src/parse/Parse.sig +++ b/src/parse/Parse.sig @@ -37,6 +37,8 @@ signature Parse = sig val type_abbrev : string * hol_type -> unit val temp_disable_tyabbrev_printing : string -> unit val disable_tyabbrev_printing : string -> unit + val remove_type_abbrev : string -> unit + val temp_remove_type_abbrev : string -> unit (* Parsing terms *) diff --git a/src/parse/Parse.sml b/src/parse/Parse.sml index 4bbeee91ae..a734e96ba0 100644 --- a/src/parse/Parse.sml +++ b/src/parse/Parse.sml @@ -751,6 +751,20 @@ in ("temp_disable_tyabbrev_printing", mlquote s) end +fun temp_remove_type_abbrev s = let + val tyg = the_type_grammar +in + tyg := type_grammar.remove_abbreviation (!tyg) s; + type_grammar_changed := true; + term_grammar_changed := true +end + +fun remove_type_abbrev s = let +in + temp_remove_type_abbrev s; + update_grms "remove_type_abbrev" ("temp_remove_type_abbrev", mlquote s) +end + (* Not persistent? *) fun temp_set_associativity (i,a) = let in From 67a27218324bcf36db26f6e24b6c8cbf976d1e43 Mon Sep 17 00:00:00 2001 From: Thibault Gauthier Date: Mon, 14 Sep 2015 00:52:20 +0200 Subject: [PATCH 468/718] holyhammer: examples --- src/holyhammer/examples/example.sml | 101 ++++------------------- src/holyhammer/examples/presentation.sml | 35 -------- src/holyhammer/examples/proof.sml | 43 ++++++++++ 3 files changed, 59 insertions(+), 120 deletions(-) delete mode 100644 src/holyhammer/examples/presentation.sml create mode 100644 src/holyhammer/examples/proof.sml diff --git a/src/holyhammer/examples/example.sml b/src/holyhammer/examples/example.sml index 9118f4a4b5..36a2ba904c 100644 --- a/src/holyhammer/examples/example.sml +++ b/src/holyhammer/examples/example.sml @@ -5,8 +5,7 @@ open holyHammer; Example 1 -------------------------------------------------------------------------- *) -val cj = ``a ≤ b ⇒ (g ** (b − a) * g ** a = g ** b)`` - (* hh [] cj; *) +val cj = ``a ≤ b ⇒ (g ** (b − a) * g ** a = g ** b)`` (* hh [] cj; *) val lemmas = [fetch "arithmetic" "SUB_ADD", fetch "arithmetic" "EXP_ADD"]; val th = save_thm ("EXP_NEG",METIS_PROVE (lemmas) cj); @@ -19,102 +18,34 @@ new_theory "zerok"; val BASE_DEF = new_definition ("BASE_DEF",``BASE = @(x:num). x >= 2``); val th0 = INST_TYPE [alpha |-> ``:num``] SELECT_AX; val th1 = save_thm ("hh0",SPECL [``\x.x>=(2:num)``,``2:num``] th0); -val cj = ``BASE>=2``; - (* hh [th0,th1] cj; *) +val cj = ``BASE>=2``; (* hh [th0,th1] cj; *) val lemmas = [fetch "zerok" "BASE_DEF", fetch "numeral" "numeral_lte", fetch "arithmetic" "GREATER_EQ", fetch "arithmetic" "NUMERAL_DEF"]; - val th = save_thm ("BASE_THM",METIS_PROVE ([th0,th1] @ lemmas) cj); (*-------------------------------------------------------------------------- Example 3 -------------------------------------------------------------------------- *) -(* Tools to fetch rewrite theorems (could be programmed using DB.match) *) - -fun is_rwthm_of c (s,thm) = - let - val thml = CONJUNCTS thm - val th1 = SPEC_ALL (hd thml) - val tm1 = concl th1 - val (c1,_) = strip_comb (lhs tm1) - in - same_const c c1 - end - handle _ => false - -fun fetch_rwthm c = - let - val {Name,Thy,Ty} = dest_thy_const c - val thml = DB.thms Thy - val thml1 = filter (is_rwthm_of c) thml - in - (List.hd thml1) - end - -fun all_rwthm term = - let - val cl = filter (not o (same_const equality)) (find_terms is_const term) - val cl = mk_set cl - val thml = map fetch_rwthm cl; - in - thml - end - -(* Starting Proof *) - load "complexTheory"; val cj = ``i * i = -1``; -(* all_rwthm cj; *) -(* hh [complexTheory.complex_mul] cj; *) -val eqthm = REWRITE_CONV [complexTheory.complex_mul] cj; -val new_cj = rhs (concl eqthm); -(* hh [complexTheory.complex_mul] cj; *) -(* hh [] new_cj; *) -val lemmas = [fetch "complex" "complex_neg", fetch "real" "REAL_MUL_RZERO", - fetch "real" "REAL_ADD_LID", fetch "real" "REAL_MUL_RID", - fetch "complex" "RE", fetch "pair" "FST", - fetch "complex" "complex_of_num", - fetch "complex" "complex_of_real", fetch "complex" "IM", - fetch "pair" "SND", fetch "real" "real_sub", - fetch "real" "REAL_ADD_RINV", fetch "complex" "i"]; - -val th = METIS_PROVE lemmas new_cj; -val th1 = EQ_MP (SYM eqthm) th; - +hh [] cj; +val lemmas = [fetch "real" "real_sub", fetch "real" "REAL_ADD_LID", + fetch "real" "REAL_NEG_0", fetch "complex" "COMPLEX_1", + fetch "real" "REAL_MUL_RZERO", fetch "complex" "complex_of_real", + fetch "complex" "complex_neg", fetch "real" "REAL_MUL_RID", + fetch "pair" "SND", fetch "complex" "i", fetch "pair" "FST", + fetch "complex" "IM", fetch "complex" "RE", + fetch "complex" "complex_mul"]; +val th = METIS_PROVE lemmas cj; (*-------------------------------------------------------------------------- - Example 4 (turning off minimization) + Example 4 -------------------------------------------------------------------------- *) load "complexTheory"; -val cj = ``(1:complex) + 1 = 2``; -hh [] cj; -hh [complexTheory.complex_add] cj; - -val lemmas = [fetch "real" "REAL_MUL_RZERO", fetch "real" "REAL_MUL_RID", - fetch "complex" "complex_scalar_lmul", - fetch "complex" "COMPLEX_DOUBLE", - fetch "complex" "complex_of_num", fetch "complex" "IM", - fetch "pair" "SND", fetch "complex" "RE", - fetch "complex" "complex_of_real", fetch "pair" "FST"]; - - -val th = METIS_PROVE (complexTheory.complex_add :: lemmas) cj; - -load "hhReconstruct"; -open hhReconstruct; -minimize_flag:= false; - -hh [complexTheory.complex_add] cj; -val lemmas = [fetch "pair" "FST", fetch "complex" "complex_of_real", - fetch "complex" "RE", fetch "pair" "SND", fetch "complex" "IM", - fetch "complex" "complex_of_num", - fetch "complex" "COMPLEX_DOUBLE", - fetch "complex" "complex_scalar_lmul", - fetch "complex" "complex_pow_def_compute", - fetch "real" "REAL_MUL_RID", fetch "real" "REAL_MUL_RZERO"]; - - - +val cj = ``(1:complex) + 1 = 2``; (* hh [] cj; *) +val lemmas = [fetch "arithmetic" "TWO", fetch "complex" "COMPLEX_OF_REAL_ADD", + fetch "real" "REAL", fetch "complex" "complex_of_num"]; +val th = METIS_PROVE lemmas cj; diff --git a/src/holyhammer/examples/presentation.sml b/src/holyhammer/examples/presentation.sml deleted file mode 100644 index e9fd4d2cf3..0000000000 --- a/src/holyhammer/examples/presentation.sml +++ /dev/null @@ -1,35 +0,0 @@ -load "holyHammer"; -open holyHammer; - -hh [] ``54 + 35 = 89``; - -load "transcTheory"; - -val cj = ``1 = cos x * cos x + sin x * sin x``; -val lemmas = [fetch "real" "REAL_ADD_SYM", fetch "real" "POW_2", - fetch "transc" "SIN_CIRCLE"]; -val thm = save_thm ("LEM1",METIS_PROVE lemmas cj); - -val cj = ``cos (2 * x) + 1 = - cos x * cos x - sin x * sin x + - (cos x * cos x + sin x * sin x)``; -val thm = save_thm ("LEM2",METIS_PROVE lemmas cj); - -val cj = ``(a = b - c + (b + c)) ==> (a = b + b)``; -val thm = save_thm ("LEM3",METIS_PROVE lemmas cj); - -(* set_timeout 30; - Eprover alone doesn't find a proof even with Mepo predictions *) -val cj = ``cos (2 * x) = 2 * cos x pow 2 - 1``; -val thm = save_thm ("LEM4",METIS_PROVE (thm :: lemmas) cj); - -(* set_timeout 5; *) -val cj = ``2 * cos x pow 2 = 1 + cos (2*x)``; -val thm = save_thm ("LEM5",METIS_PROVE lemmas cj); - -val cj = ``(2:real * a:real = b) ==> (a:real = b/2:real)``; -set_predictors Mepo; -val thm = save_thm ("LEM6",METIS_PROVE lemmas cj); - -val cj = ``cos x pow 2 = (1 + cos (2*x))/2``; -val thm = save_thm ("COS_LIN",METIS_PROVE lemmas cj); diff --git a/src/holyhammer/examples/proof.sml b/src/holyhammer/examples/proof.sml new file mode 100644 index 0000000000..88120a4878 --- /dev/null +++ b/src/holyhammer/examples/proof.sml @@ -0,0 +1,43 @@ +load "holyHammer"; +open holyHammer; +load "transcTheory"; + +val cj = ``1 = cos x * cos x + sin x * sin x``; +val lemmas = [fetch "real" "REAL_ADD_SYM", fetch "real" "POW_2", + fetch "transc" "SIN_CIRCLE"]; +val thm = save_thm ("LEM1",METIS_PROVE lemmas cj); + +val cj = ``cos (2 * x) + 1 = + cos x * cos x - sin x * sin x + + (cos x * cos x + sin x * sin x)``; +val lemmas = [fetch "transc" "COS_ADD", fetch "scratch" "LEM1", + fetch "real" "REAL_DOUBLE"]; +val thm = save_thm ("LEM2",METIS_PROVE lemmas cj); + +val cj = ``(a = b - c + (b + c)) ==> (a = b + b)``; +val lemmas = [fetch "real" "REAL_ADD_SYM", fetch "real" "REAL_ADD_ASSOC", + fetch "real" "REAL_EQ_SUB_LADD"]; +val thm = save_thm ("LEM3",METIS_PROVE lemmas cj); + +(* set_timeout 30; hh [thm] cj; (only Vampire finds a proof) *) +val cj = ``cos (2 * x) = 2 * cos x pow 2 - 1``; +val lemmas = [fetch "scratch" "LEM2", fetch "real" "POW_2", + fetch "real" "REAL_EQ_SUB_LADD", fetch "real" "REAL_DOUBLE"]; +val thm = save_thm ("LEM4",METIS_PROVE (thm :: lemmas) cj); + +(* set_timeout 5; *) +val cj = ``2 * cos x pow 2 = 1 + cos (2*x)``; +val lemmas = [fetch "scratch" "LEM4", fetch "real" "REAL_EQ_SUB_LADD", + fetch "real" "REAL_ADD_SYM"]; +val thm = save_thm ("LEM5",METIS_PROVE lemmas cj); + +(* set_predictors Mepo; *) +val cj = ``(2:real * a:real = b) ==> (a:real = b/2:real)``; +val lemmas = [fetch "real" "REAL_DOUBLE", fetch "real" "REAL_HALF_DOUBLE", + fetch "real" "REAL_EQ_RDIV_EQ", fetch "real" "REAL_LT_HALF1", + fetch "real" "REAL_HALF_BETWEEN", fetch "real" "REAL_DIV_REFL2"]; +val thm = save_thm ("LEM6",METIS_PROVE lemmas cj); + +val cj = ``cos x pow 2 = (1 + cos (2*x))/2``; +val lemmas = [fetch "scratch" "LEM6", fetch "scratch" "LEM5"]; +val thm = save_thm ("LEM7",METIS_PROVE lemmas cj); From f944cbde63ba63561725f5817276dc33350990c9 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 14 Sep 2015 16:43:41 +1000 Subject: [PATCH 469/718] Remove state_option theory. Documented in release notes, including pointer to errorStateMonad theory. --- doc/next-release.md | 3 ++ src/option/state_optionScript.sml | 49 ------------------------------- 2 files changed, 3 insertions(+), 49 deletions(-) delete mode 100644 src/option/state_optionScript.sml diff --git a/doc/next-release.md b/doc/next-release.md index 6ba6a5ee6c..b8dd84a55e 100644 --- a/doc/next-release.md +++ b/doc/next-release.md @@ -106,6 +106,9 @@ Incompatibilities: Of course, the `qmatch_rename_tac` and `qmatch_assum_rename_tac` names for these tactics in `lcsymtacs` have changed types as well. The new `Q.MATCH_GOALSUB_RENAME_TAC` and `Q.MATCH_ASMSUB_RENAME_TAC` (and their lower-case versions) have similar types, without explicit lists of variable names to ignore. +- The theory `state_option` was removed. + The better-developed `errorStateMonad` theory should be used instead. + * * * * *
diff --git a/src/option/state_optionScript.sml b/src/option/state_optionScript.sml deleted file mode 100644 index 5f94a21f37..0000000000 --- a/src/option/state_optionScript.sml +++ /dev/null @@ -1,49 +0,0 @@ -open HolKernel boolLib Parse - -open pairTheory optionTheory - -val _ = new_theory "state_option" - -val _ = type_abbrev("state_option", ``:'a -> ('b # 'a) option``); -val _ = temp_type_abbrev("monad", ``:('a,'b) state_option``); - -val STATE_OPTION_FAIL_def = new_definition( - "STATE_OPTION_FAIL_def", - ``STATE_OPTION_FAIL : ('a,'b) monad s = NONE``); - -val STATE_OPTION_UNIT_def = new_definition( - "STATE_OPTION_UNIT_def", - ``STATE_OPTION_UNIT : 'b -> ('a,'b) monad a s = SOME (a,s)``); - -val STATE_OPTION_BIND_def = new_definition( - "STATE_OPTION_BIND_def", - ``STATE_OPTION_BIND - (m : ('a,'b)monad) - (f:'b -> ('a,'c) monad) : ('a,'c) monad - s - = - OPTION_BIND (m s) (UNCURRY f)``); - -val STATE_OPTION_IGNORE_BIND_def = new_definition( - "STATE_OPTION_IGNORE_BIND_def", - ``STATE_OPTION_IGNORE_BIND - (m1 : ('a,'b) monad) - (m2 : ('a,'c) monad) : ('a,'c) monad - s - = - OPTION_BIND (m1 s) (m2 o SND)``); - -val STATE_OPTION_LIFT_def = new_definition( - "STATE_OPTION_LIFT_def", - ``(STATE_OPTION_LIFT : 'b option -> ('a,'b) monad) m s = - OPTION_BIND m (\a. SOME (a,s))``); - -(* Commands to make the above look nice with monadsyntax in place. -val _ = overload_on("monad_bind", ``STATE_OPTION_BIND o STATE_OPTION_LIFT``); -val _ = overload_on("monad_unitbind", ``STATE_OPTION_IGNORE_BIND o STATE_OPTION_LIFT``); -val _ = overload_on("monad_bind", ``STATE_OPTION_BIND``); -val _ = overload_on("monad_unitbind", ``STATE_OPTION_IGNORE_BIND``); -val _ = overload_on("return", ``STATE_OPTION_UNIT``); -*) - -val _ = export_theory () From 90a608c94665c0ccd4b2dfdc6d4033a263833b61 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 15 Sep 2015 21:59:02 +1000 Subject: [PATCH 470/718] Move 2 open declarations to head of listScript.sml --- src/list/src/listScript.sml | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/src/list/src/listScript.sml b/src/list/src/listScript.sml index 323effcda2..04482395e8 100644 --- a/src/list/src/listScript.sml +++ b/src/list/src/listScript.sml @@ -22,7 +22,10 @@ * are "arithmetic" and "pair". * *---------------------------------------------------------------------------*) -local open arithmeticTheory pairTheory pred_setTheory operatorTheory Datatype OpenTheoryMap in end; +local + open arithmeticTheory pairTheory pred_setTheory operatorTheory Datatype + OpenTheoryMap +in end; (*--------------------------------------------------------------------------- @@ -30,7 +33,8 @@ local open arithmeticTheory pairTheory pred_setTheory operatorTheory Datatype Op *---------------------------------------------------------------------------*) open HolKernel Parse boolLib Num_conv Prim_rec BasicProvers mesonLib - simpLib boolSimps pairTheory TotalDefn metisLib;; + simpLib boolSimps pairTheory pred_setTheory TotalDefn metisLib + relationTheory val arith_ss = bool_ss ++ numSimps.ARITH_ss ++ numSimps.REDUCE_ss @@ -459,7 +463,6 @@ val EVERY_CONJ = store_thm("EVERY_CONJ", REPEAT (STRIP_TAC ORELSE EQ_TAC) THEN FIRST_ASSUM ACCEPT_TAC); -open pred_setTheory val EVERY_MEM = store_thm( "EVERY_MEM", ``!P l:'a list. EVERY P l = !e. MEM e l ==> P e``, @@ -2981,7 +2984,6 @@ val LLEX_NIL2 = store_thm( ``~LLEX R l []``, Cases_on `l` THEN SIMP_TAC (srw_ss()) [LLEX_def]); -open relationTheory val LLEX_transitive = store_thm( "LLEX_transitive", ``transitive R ==> transitive (LLEX R)``, From 5e6555a6b4dbef85b7e5b174367f139470d844d4 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 15 Sep 2015 21:59:45 +1000 Subject: [PATCH 471/718] Rewrites about terms of form ``MAP f t1 = t2`` When t2 is involves a standard list function (CONS, APPEND etc), there are useful possible rhses. When t2 = [x], the rewrite seems sufficiently useful to warrant making the rewrite automatic. Moved from grammarTheory in examples/parsing --- examples/parsing/grammarScript.sml | 20 +++---------------- src/list/src/listScript.sml | 31 +++++++++++++++++++++++++----- 2 files changed, 29 insertions(+), 22 deletions(-) diff --git a/examples/parsing/grammarScript.sml b/examples/parsing/grammarScript.sml index f4c8560323..9a56c6b9be 100644 --- a/examples/parsing/grammarScript.sml +++ b/examples/parsing/grammarScript.sml @@ -200,20 +200,6 @@ val FLAT_EQ_SING = store_thm( Induct_on `l` >> simp[] >> simp[APPEND_EQ_CONS] >> simp_tac (srw_ss() ++ DNF_ss) [] >> metis_tac[]); -val MAP_EQ_SING = store_thm( - "MAP_EQ_SING", - ``MAP f l = [x] ⇔ ∃x0. l = [x0] ∧ x = f x0``, - Induct_on `l` >> simp[] >> metis_tac[]); - -val MAP_EQ_APPEND = store_thm( - "MAP_EQ_APPEND", - ``MAP f l = x ++ y ⇔ - ∃x0 y0. l = x0 ++ y0 ∧ x = MAP f x0 ∧ y = MAP f y0``, - reverse eq_tac >- (rw[]>>rw[]) >> - map_every qid_spec_tac [`y`,`x`, `l`] >> Induct >> simp[] >> - map_every qx_gen_tac [`h`, `x`, `y`] >> Cases_on `x` >> simp[] >> - strip_tac >> Q.REFINE_EXISTS_TAC `hh::tt` >> simp[]); - val fringe_element = store_thm( "fringe_element", ``∀pt p x s. @@ -244,7 +230,7 @@ val fringe_element = store_thm( `fsp1 ++ (nilps ++ [[x]] ++ nilss) ++ fss = fp ++ [[x]] ++ fs` by simp[] >> pop_assum SUBST_ALL_TAC >> - simp[MAP_EQ_APPEND, MAP_EQ_SING] >> + simp[MAP_EQ_APPEND] >> disch_then (fn th => `∃ts1 ts2 xpt. ptl = ts1 ++ [xpt] ++ ts2 ∧ fp = MAP ptree_fringe ts1 ∧ @@ -264,7 +250,7 @@ val fringe_element = store_thm( rw[] >> qabbrev_tac `f2 = snils ++ fss` >> `MAP ptree_fringe ptl = f1 ++ [xp ++ [x]] ++ f2` by simp[Abbr`f2`] >> pop_assum mp_tac >> - simp_tac (srw_ss()) [MAP_EQ_APPEND, MAP_EQ_SING] >> + simp_tac (srw_ss()) [MAP_EQ_APPEND] >> disch_then (fn th => `∃pt1 pt2 ptx. ptl = pt1 ++ [ptx] ++ pt2 ∧ f1 = MAP ptree_fringe pt1 ∧ @@ -283,7 +269,7 @@ val fringe_element = store_thm( simp[APPEND_EQ_APPEND, APPEND_EQ_CONS, DISJ_IMP_THM] >> metis_tac[]) >> qpat_assum `MAP ptree_fringe XX = YY` mp_tac >> - simp[MAP_EQ_APPEND, MAP_EQ_SING] >> + simp[MAP_EQ_APPEND] >> disch_then (fn th => `∃pt1 pt2 ptx. ptl = pt1 ++ [ptx] ++ pt2 ∧ f1 = MAP ptree_fringe pt1 ∧ diff --git a/src/list/src/listScript.sml b/src/list/src/listScript.sml index 04482395e8..e7d007dd38 100644 --- a/src/list/src/listScript.sml +++ b/src/list/src/listScript.sml @@ -411,12 +411,24 @@ val LENGTH_MAP = store_thm ("LENGTH_MAP", LIST_INDUCT_TAC THEN ASM_REWRITE_TAC [MAP, LENGTH]); val MAP_EQ_NIL = store_thm( - "MAP_EQ_NIL", + "MAP_EQ_NIL[simp]", --`!(l:'a list) (f:'a->'b). ((MAP f l = []) = (l = [])) /\ (([] = MAP f l) = (l = []))`--, LIST_INDUCT_TAC THEN REWRITE_TAC [MAP, NOT_CONS_NIL, NOT_NIL_CONS]); +val MAP_EQ_CONS = store_thm( + "MAP_EQ_CONS", + ``(MAP (f:'a -> 'b) l = h::t) <=> + ?x0 t0. (l = x0::t0) /\ (h = f x0) /\ (t = MAP f t0)``, + Q.ISPEC_THEN `l` STRUCT_CASES_TAC list_CASES THEN SIMP_TAC (srw_ss()) [] THEN + METIS_TAC[]); + +val MAP_EQ_SING = store_thm( + "MAP_EQ_SING[simp]", + ``(MAP (f:'a -> 'b) l = [x]) <=> ?x0. (l = [x0]) /\ (x = f x0)``, + SIMP_TAC (srw_ss()) [MAP_EQ_CONS]) + val MAP_EQ_f = store_thm ("MAP_EQ_f", ``!f1 f2 l. (MAP f1 l = MAP f2 l) = (!e. MEM e l ==> (f1 e = f2 e))``, Induct_on `l` THEN @@ -674,6 +686,16 @@ CONJ_TAC THEN THEN GEN_TAC THEN MATCH_ACCEPT_TAC EQ_SYM_EQ); val _ = export_rewrites ["APPEND_eq_NIL"] +val MAP_EQ_APPEND = store_thm( + "MAP_EQ_APPEND", + ``(MAP (f:'a -> 'b) l = l1 ++ l2) <=> + ?l10 l20. (l = l10 ++ l20) /\ (l1 = MAP f l10) /\ (l2 = MAP f l20)``, + REVERSE EQ_TAC THEN1 SIMP_TAC (srw_ss() ++ boolSimps.DNF_ss) [MAP_APPEND] THEN + MAP_EVERY Q.ID_SPEC_TAC [`l1`, `l2`, `l`] THEN LIST_INDUCT_TAC THEN + SIMP_TAC (srw_ss()) [] THEN MAP_EVERY Q.X_GEN_TAC [`h`, `l2`, `l1`] THEN + Cases_on `l1` THEN SIMP_TAC (srw_ss() ++ boolSimps.DNF_ss) [MAP_EQ_CONS] THEN + METIS_TAC[]); + val APPEND_EQ_SING = store_thm( "APPEND_EQ_SING", ``(l1 ++ l2 = [e:'a]) <=> @@ -1687,7 +1709,7 @@ val MAP_EQ_EVERY2 = store_thm( (LENGTH l1 = LENGTH l2) /\ (EVERY2 (\x y. f1 x = f2 y) l1 l2)``, NTAC 2 GEN_TAC THEN -Induct THEN SRW_TAC [] [LENGTH_NIL_SYM, MAP, MAP_EQ_NIL] THEN +Induct THEN SRW_TAC [] [LENGTH_NIL_SYM, MAP] THEN Cases_on `l2` THEN SRW_TAC [] [MAP] THEN PROVE_TAC[]) @@ -1904,7 +1926,7 @@ FULL_SIMP_TAC(srw_ss()++numSimps.ARITH_ss)[MEM, MAP, SUM]) val INJ_MAP_EQ = store_thm( "INJ_MAP_EQ", ``!f l1 l2. (INJ f (set l1 UNION set l2) UNIV) /\ (MAP f l1 = MAP f l2) ==> (l1 = l2)``, -GEN_TAC THEN Induct THEN1 SRW_TAC[] [MAP, MAP_EQ_NIL] THEN +GEN_TAC THEN Induct THEN1 SRW_TAC[] [MAP] THEN GEN_TAC THEN Cases THEN SRW_TAC[] [MAP] THEN1 ( IMP_RES_TAC INJ_DEF THEN FIRST_X_ASSUM (MATCH_MP_TAC o MP_CANON) THEN @@ -3093,7 +3115,6 @@ val EXISTS_LIST_EQ_MAP = Q.store_thm("EXISTS_LIST_EQ_MAP", Induct >> ASM_SIMP_TAC (srw_ss()) [] >> rw [] - THEN1 (Q.EXISTS_TAC `[]` >> rw []) >> RES_TAC >> Q.EXISTS_TAC`y::l` >> ASM_SIMP_TAC (srw_ss()) []) @@ -3547,7 +3568,7 @@ val _ = export_rewrites "MAP2", "NULL_DEF", "SUM", "APPEND_ASSOC", "CONS", "CONS_11", "LENGTH_MAP", "MAP_APPEND", - "NOT_CONS_NIL", "NOT_NIL_CONS", "MAP_EQ_NIL", + "NOT_CONS_NIL", "NOT_NIL_CONS", "CONS_ACYCLIC", "list_case_def", "ZIP", "UNZIP", "ZIP_UNZIP", "UNZIP_ZIP", "LENGTH_ZIP", "LENGTH_UNZIP", From 7f88b646ffeb5cf5a3fa9fe80a84179586ca870a Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 17 Sep 2015 18:07:33 +1000 Subject: [PATCH 472/718] Fix (somewhat obscure) looping bug in simplifier. If the terms T = F and F = T both arrive in your assumption list, then you will go into an infinite loop. Neither should fire as a rewrite at all. Indeed, anything of the form T = x, or F = x, is better off flipped, unless it's the bad case above. In the bad case, treat the rewrite as we treat a bare F. --- src/simp/src/Cond_rewr.sml | 49 +++++++++++++++++++++++++------------- src/simp/src/selftest.sml | 22 +++++++++++++++++ 2 files changed, 54 insertions(+), 17 deletions(-) diff --git a/src/simp/src/Cond_rewr.sml b/src/simp/src/Cond_rewr.sml index b915fcf5ae..a7298e753a 100644 --- a/src/simp/src/Cond_rewr.sml +++ b/src/simp/src/Cond_rewr.sml @@ -274,6 +274,10 @@ val truth_tm = boolSyntax.T val false_tm = boolSyntax.F val Abbrev_tm = prim_mk_const {Name = "Abbrev", Thy = "marker"} val x_eq_false = SPEC (mk_eq(genvar bool, false_tm)) FALSITY +val TF_EQ_F = PROVE_HYP (UNDISCH_ALL (NOT_ELIM (CONJUNCT1 BOOL_EQ_DISTINCT))) + (UNDISCH_ALL x_eq_false) +val FT_EQ_F = PROVE_HYP (UNDISCH_ALL (NOT_ELIM (CONJUNCT2 BOOL_EQ_DISTINCT))) + (UNDISCH_ALL x_eq_false) fun IMP_EQ_CANON (thm,bnd) = let val conditions = #1 (strip_imp (concl thm)) @@ -285,24 +289,35 @@ fun IMP_EQ_CANON (thm,bnd) = let if loops undisch_thm andalso bnd = BoundedRewrites.UNBOUNDED then (trace(1,IGNORE("looping rewrite (but adding EQT versions)",thm)); [(EQT_INTRO undisch_thm, bnd), (EQT_INTRO (SYM undisch_thm), bnd)]) - else let - val base = - if null (subtract (free_vars (rhs conc)) - (free_varsl (lhs conc::hyp thm))) - then undisch_thm - else - (trace(1,IGNORE("rewrite with existential vars (adding \ - \EQT version(s))",thm)); - EQT_INTRO undisch_thm) - val flip_eqp = let val (l,r) = dest_eq (concl base) - in - is_eq l andalso not (is_eq r) - end + else + let + val (l,r) = dest_eq conc in - if flip_eqp then - [(base, bnd), - (CONV_RULE (LAND_CONV (REWR_CONV EQ_SYM_EQ)) base, bnd)] - else [(base,bnd)] + if l = truth_tm then + if r = false_tm then [(PROVE_HYP thm TF_EQ_F, bnd)] + else [(CONV_RULE (REWR_CONV EQ_SYM_EQ) thm, bnd)] + else if l = false_tm then + if r = truth_tm then [(PROVE_HYP thm FT_EQ_F,bnd)] + else [(CONV_RULE (REWR_CONV EQ_SYM_EQ) thm, bnd)] + else + let + val base = + if null (subtract (free_vars r) (free_varsl (l::hyp thm))) + then undisch_thm + else + (trace(1,IGNORE("rewrite with existential vars (adding \ + \EQT version(s))",thm)); + EQT_INTRO undisch_thm) + val flip_eqp = let val (l,r) = dest_eq (concl base) + in + is_eq l andalso not (is_eq r) + end + in + if flip_eqp then + [(base, bnd), + (CONV_RULE (LAND_CONV (REWR_CONV EQ_SYM_EQ)) base, bnd)] + else [(base,bnd)] + end end else if is_conj conc then undisch_thm |> CONJ_PAIR diff --git a/src/simp/src/selftest.sml b/src/simp/src/selftest.sml index 3b1a22d5b7..f5d47e393e 100644 --- a/src/simp/src/selftest.sml +++ b/src/simp/src/selftest.sml @@ -190,6 +190,28 @@ in infloop_protect "Abbrev-simplification with abstraction" check doit g end +(* rewrites on F and T *) +val TF = mk_eq(T,F) +val FT = mk_eq(F,T) + +val _ = let + val t = TF + val doit = QCONV (SIMP_CONV bool_ss [ASSUME TF, ASSUME FT]) + fun check th = th |> concl |> rhs |> aconv F +in + infloop_protect "assume T=F and F=T (if hangs, it's failed)" check doit t +end + + +(* conjunction congruence *) +val _ = let + val t = list_mk_conj [TF,FT,TF] + val doit = QCONV (SIMP_CONV (bool_ss ++ CONJ_ss) []) + fun check th = th |> concl |> rhs |> aconv F +in + infloop_protect "CONJ_ss with T=F and F=T assumptions (if hangs, it's failed)" check doit t +end + (* ---------------------------------------------------------------------- *) val _ = Process.exit Process.success From d3fe575aeef7a54d39287be3bc882d6513ce9731 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 17 Sep 2015 19:35:53 +1000 Subject: [PATCH 473/718] A new simpset fragment that reorients equalities If an equality l = r has a ground (no free variables) term on the left and r does have free variables, then flip the equality. One might think about automatically doing this when adding new facts to the simplifier context. --- help/Docfiles/boolSimps.NORMEQ_ss.doc | 35 +++++++++++++++++++++++++++ src/simp/src/boolSimps.sig | 4 +++ src/simp/src/boolSimps.sml | 24 ++++++++++++++++++ 3 files changed, 63 insertions(+) create mode 100644 help/Docfiles/boolSimps.NORMEQ_ss.doc diff --git a/help/Docfiles/boolSimps.NORMEQ_ss.doc b/help/Docfiles/boolSimps.NORMEQ_ss.doc new file mode 100644 index 0000000000..f5d41353cd --- /dev/null +++ b/help/Docfiles/boolSimps.NORMEQ_ss.doc @@ -0,0 +1,35 @@ +\DOC + +\TYPE {NORMEQ_ss : ssfrag} + +\SYNOPSIS +A simpset fragment that reorients equalities. + +\KEYWORDS +simplification + +\DESCRIBE + +The {NORMEQ_ss} simpset fragment embodies a conversion that flips +terms of the form {l = r} when {l} contains no free variables, and {r} +contains at least one variable. To flip an equality is to rewrite it +so that {l = r} becomes {r = l}. + +\FAILURE +As a static value, this cannot fail. + +\EXAMPLE +In this example, the simplifier flips the {3 = x} term, making it +useful as a rewrite when attacking the consequent of the implication. +{ + SIMP_CONV (bool_ss ++ boolSimps.NORMEQ_ss) [] ``(3 = x) ==> x + 1 < y``; + > val it = + |- (3 = x) ==> x + 1 < y <=> (x = 3) ==> 3 + 1 < y : thm +} + + +\SEEALSO +simpLib.SIMP_CONV. + + +\ENDDOC diff --git a/src/simp/src/boolSimps.sig b/src/simp/src/boolSimps.sig index a2e87f1a2e..0f37e89199 100644 --- a/src/simp/src/boolSimps.sig +++ b/src/simp/src/boolSimps.sig @@ -60,6 +60,10 @@ sig |- (A /\ B /\ C <=> C /\ B /\ D) <=> C /\ B ==> (A <=> D) *) + val NORMEQ_ss : simpLib.ssfrag + (* flips equalities that have a ground term on the left and a + non-ground term on the right *) + val SimpLHS : thm val SimpRHS : thm val SimpL : term -> thm diff --git a/src/simp/src/boolSimps.sml b/src/simp/src/boolSimps.sml index 102be39fc3..5256d2803f 100644 --- a/src/simp/src/boolSimps.sml +++ b/src/simp/src/boolSimps.sml @@ -304,6 +304,30 @@ val DNF_ss = rewrites [FORALL_AND_THM, EXISTS_OR_THM, val EQUIV_EXTRACT_ss = simpLib.conv_ss BoolExtractShared.BOOL_EQ_IMP_convdata; +val NORMEQ_CONV = let + fun c (cf : term list -> term -> thm) (tl : term list) t = + let + val (l,r) = dest_eq t + in + if null (free_vars l) andalso not (null (free_vars r)) then + REWR_CONV EQ_SYM_EQ + else NO_CONV + end t +in + { name = "NORMEQ_CONV", + key = SOME ([] : term list, ``x:'a = y``), + trace = 2, + conv = c } +end + +val NORMEQ_ss = simpLib.SSFRAG { + ac = [], + congs = [], + convs = [NORMEQ_CONV], + dprocs = [], + filter = NONE, + name = SOME "NORMEQ_ss", rewrs = []} + (* ---------------------------------------------------------------------- Congruence rules for rewriting on one side or the other of a goal's central binary operator From 3df6c6b3318ff5bb9e097003d332d06c8004ad8d Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 18 Sep 2015 16:28:20 +1000 Subject: [PATCH 474/718] Fix thm_to_string to use raw backend properly. The term_to_string and type_to_string functions do this already. --- doc/next-release.md | 2 ++ src/1/selftest.sml | 8 ++++++++ src/parse/Parse.sml | 2 +- 3 files changed, 11 insertions(+), 1 deletion(-) diff --git a/doc/next-release.md b/doc/next-release.md index b8dd84a55e..f9e014047e 100644 --- a/doc/next-release.md +++ b/doc/next-release.md @@ -60,6 +60,8 @@ Bugs fixed: Working in such directories will likely cause problems when and if an `export_theory` call is made, so there is a warning emitted in this situation, but the `load` now succeeds. Thanks to Narges Khakpour for the bug report. +- The function `thm_to_string` was creating ugly strings full of special codes (encoding type information) rather than using the “raw” backend. + New theories: ------------- diff --git a/src/1/selftest.sml b/src/1/selftest.sml index 051e37df06..418850cb93 100644 --- a/src/1/selftest.sml +++ b/src/1/selftest.sml @@ -411,6 +411,14 @@ val _ = app test [ \else F"} ] +val _ = let + open testutils + val _ = tprint (standard_tpp_message "|- p") + val res = thm_to_string (ASSUME (mk_var("p", Type.bool))) +in + if res = " [.] |- p" then print "OK\n" else die "FAILED!" +end + val _ = temp_add_rule { paren_style = NotEvenIfRand, fixity = Prefix 2200, block_style = (AroundEachPhrase, (PP.CONSISTENT,0)), pp_elements = [TOK "/"], term_name = "div" }; diff --git a/src/parse/Parse.sml b/src/parse/Parse.sml index a734e96ba0..d69c3053fd 100644 --- a/src/parse/Parse.sml +++ b/src/parse/Parse.sml @@ -465,7 +465,7 @@ fun pp_thm ppstrm th = end_block() end; -val thm_to_string = ppstring (rawterm_pp pp_thm) +val thm_to_string = rawterm_pp (ppstring pp_thm) val print_thm = print o thm_to_string (*--------------------------------------------------------------------------- From d2d3a43aa93c0b14b5a4916e6c6e0ea0fabeb89f Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Wed, 16 Sep 2015 18:32:21 +1000 Subject: [PATCH 475/718] more crossreferences in doc pages --- help/Docfiles/Tactic.AP_TERM_TAC.doc | 3 ++- help/Docfiles/Tactic.AP_THM_TAC.doc | 3 ++- help/Docfiles/Tactic.MK_COMB_TAC.doc | 2 +- 3 files changed, 5 insertions(+), 3 deletions(-) diff --git a/help/Docfiles/Tactic.AP_TERM_TAC.doc b/help/Docfiles/Tactic.AP_TERM_TAC.doc index 12245f0d42..1d4342dc43 100644 --- a/help/Docfiles/Tactic.AP_TERM_TAC.doc +++ b/help/Docfiles/Tactic.AP_TERM_TAC.doc @@ -29,5 +29,6 @@ Fails unless the goal is equational, with both sides being applications of the same function. \SEEALSO -Thm.AP_TERM, Thm.AP_THM, Tactic.AP_THM_TAC, Tactic.ABS_TAC. +Thm.AP_TERM, Thm.AP_THM, Tactic.AP_THM_TAC, Tactic.MK_COMB_TAC, Tactic.ABS_TAC. + \ENDDOC diff --git a/help/Docfiles/Tactic.AP_THM_TAC.doc b/help/Docfiles/Tactic.AP_THM_TAC.doc index c567fa3838..2576120bed 100644 --- a/help/Docfiles/Tactic.AP_THM_TAC.doc +++ b/help/Docfiles/Tactic.AP_THM_TAC.doc @@ -29,5 +29,6 @@ Fails unless the goal has the above form, namely an equation both sides of which consist of function applications to the same arguments. \SEEALSO -Thm.AP_TERM, Tactic.AP_TERM_TAC, Thm.AP_THM, Tactic.ABS_TAC, Drule.EXT. +Thm.AP_TERM, Tactic.AP_TERM_TAC, Thm.AP_THM, Tactic.MK_COMB_TAC, +Tactic.ABS_TAC, Drule.EXT. \ENDDOC diff --git a/help/Docfiles/Tactic.MK_COMB_TAC.doc b/help/Docfiles/Tactic.MK_COMB_TAC.doc index 5b36c0e16f..37781df302 100644 --- a/help/Docfiles/Tactic.MK_COMB_TAC.doc +++ b/help/Docfiles/Tactic.MK_COMB_TAC.doc @@ -29,5 +29,5 @@ goals {A ?- f = g} and {A ?- x = y}. Fails unless the goal is equational, with both sides being applications. \SEEALSO -Thm.MK_COMB, Thm.AP_TERM, Thm.AP_THM, Tactic.AP_THM_TAC. +Thm.MK_COMB, Thm.AP_TERM, Thm.AP_THM, Tactic.AP_TERM_TAC, Tactic.AP_THM_TAC. \ENDDOC From 3ce46a7b3ca78f1bfc3243edcd95d05f243da35a Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Wed, 16 Sep 2015 18:57:41 +1000 Subject: [PATCH 476/718] PART_MATCH_A, REWR_CONV_A - allow substutiting in assumptions --- src/1/Conv.sig | 1 + src/1/Conv.sml | 1 + src/1/Drule.sig | 1 + src/1/Drule.sml | 10 ++++++++++ 4 files changed, 13 insertions(+) diff --git a/src/1/Conv.sig b/src/1/Conv.sig index 9a5ebf66b7..89c11d703f 100644 --- a/src/1/Conv.sig +++ b/src/1/Conv.sig @@ -7,6 +7,7 @@ sig val QCONV : conv -> conv val REWR_CONV : thm -> conv val HO_REWR_CONV : thm -> conv + val REWR_CONV_A : thm -> conv val LAND_CONV : conv -> conv val RAND_CONV : conv -> conv val RATOR_CONV : conv -> conv diff --git a/src/1/Conv.sml b/src/1/Conv.sml index 099dafb1fa..8108e68745 100644 --- a/src/1/Conv.sml +++ b/src/1/Conv.sml @@ -61,6 +61,7 @@ fun REWR_CONV0 (part_matcher, fn_name) th = val REWR_CONV = REWR_CONV0 (PART_MATCH, "REWR_CONV") val HO_REWR_CONV = REWR_CONV0 (HO_PART_MATCH, "HO_REWR_CONV") +val REWR_CONV_A = REWR_CONV0 (PART_MATCH_A, "REWR_CONV_A") (*----------------------------------------------------------------------* * RAND_CONV conv "t1 t2" applies conv to t2 * diff --git a/src/1/Drule.sig b/src/1/Drule.sig index 0e113fe99c..0c2d4a5f3d 100644 --- a/src/1/Drule.sig +++ b/src/1/Drule.sig @@ -80,6 +80,7 @@ sig val GSPEC : thm -> thm val PART_MATCH : (term -> term) -> thm -> term -> thm + val PART_MATCH_A : (term -> term) -> thm -> term -> thm val MATCH_MP : thm -> thm -> thm val BETA_VAR : term -> term -> term -> thm val HO_PART_MATCH : (term -> term) -> thm -> term -> thm diff --git a/src/1/Drule.sml b/src/1/Drule.sml index bc5b302e42..e822933410 100644 --- a/src/1/Drule.sml +++ b/src/1/Drule.sml @@ -1256,6 +1256,16 @@ fun PART_MATCH partfn th = fn tm => INST_TY_TERM (matchfn tm) th end +(*---------------------------------------------------------------------------* + * version of PART_MATCH which allows substituting in assumptions * + *---------------------------------------------------------------------------*) +fun PART_MATCH_A partfn th = + let + val pat = partfn (concl (SPEC_ALL th)) + in + fn tm => INST_TY_TERM (match_term pat tm) th + end + (* --------------------------------------------------------------------------* EXISTS_LEFT, EXISTS_LEFT1 existentially quantifying variables which appear only in the hypotheses From e50b803213b0d408a47140156c3f02de45e0f5f0 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Wed, 16 Sep 2015 18:58:34 +1000 Subject: [PATCH 477/718] some shorter proofs for fracTheory --- src/rational/fracScript.sml | 80 +++++++++++-------------------------- 1 file changed, 23 insertions(+), 57 deletions(-) diff --git a/src/rational/fracScript.sml b/src/rational/fracScript.sml index 50edb2f3f5..72fa4af15d 100644 --- a/src/rational/fracScript.sml +++ b/src/rational/fracScript.sml @@ -88,25 +88,17 @@ val FRAC = store_thm("FRAC", ``!f. abs_frac (frac_nmr f,frac_dnm f) = f``, * ((abs_frac(a1,b1)=abs_frac(a2,b2)) = (a1=a2) /\ (b1=b2) ) *--------------------------------------------------------------------------*) -val FRAC_EQ = - let - val subst2a = #1 (EQ_IMP_RULE (REWRITE_RULE [SND] (BETA_RULE (SPEC ``(a1:int,b1:int)`` (CONJUNCT2 frac_bij))))); - val subst2b = #1 (EQ_IMP_RULE (REWRITE_RULE [SND] (BETA_RULE (SPEC ``(a2:int,b2:int)`` (CONJUNCT2 frac_bij))))); - in - store_thm("FRAC_EQ", ``!a1 b1 a2 b2. 0i < b1 ==> 0i < b2 ==> ((abs_frac(a1,b1)=abs_frac(a2,b2)) = (a1=a2) /\ (b1=b2) )``, - REPEAT GEN_TAC THEN - STRIP_TAC THEN - STRIP_TAC THEN - EQ_TAC THENL - [ - STRIP_TAC THEN - REWRITE_TAC[ prove(``((a1:int = a2:int) /\ (b1:int = b2:int)) = ((a1,b1)=(a2,b2))``,RW_TAC int_ss []) ] THEN - SUBST_TAC[GSYM (UNDISCH_ALL subst2a), GSYM (UNDISCH_ALL subst2b)] THEN - PROVE_TAC[frac_bij] - , - PROVE_TAC[] - ] ) - end; +val [abs_rep_frac, rep_abs_frac] = CONJUNCTS frac_bij ; +val (raf_eqI, raf_eqD) = EQ_IMP_RULE (SPEC_ALL rep_abs_frac) ; + +val FRAC_EQ = store_thm("FRAC_EQ", + ``!a1 b1 a2 b2. 0i < b1 ==> 0i < b2 ==> + ((abs_frac(a1,b1)=abs_frac(a2,b2)) = (a1=a2) /\ (b1=b2) )``, + REPEAT STRIP_TAC THEN EQ_TAC THEN DISCH_TAC THENL [ + POP_ASSUM (MP_TAC o AP_TERM ``rep_frac``) THEN + VALIDATE (CONV_TAC (DEPTH_CONV (REWR_CONV_A (UNDISCH raf_eqI)))), + ALL_TAC] THEN + ASM_SIMP_TAC std_ss []) ; (*-------------------------------------------------------------------------- * FRAC_EQ_ALT : thm @@ -141,21 +133,14 @@ val FRAC_NOT_EQ = store_thm("FRAC_NOT_EQ", ``!a1 b1 a2 b2. 0i 0i ( * ~((a1,b1) = (a2,b2)) ==> ~(abs_frac (a1,b1) = abs_frac (a2,b2)) *--------------------------------------------------------------------------*) -val FRAC_NOT_EQ_IMP = - let - val lemma01a = fst(EQ_IMP_RULE (ONCE_REWRITE_RULE[EQ_SYM_EQ] (SPEC ``(a1:int,b1:int)`` (ONCE_REWRITE_RULE [EQ_SYM_EQ] (CONJUNCT2 frac_bij))))); - val lemma01b = fst(EQ_IMP_RULE (ONCE_REWRITE_RULE[EQ_SYM_EQ] (SPEC ``(a2:int,b2:int)`` (ONCE_REWRITE_RULE [EQ_SYM_EQ] (CONJUNCT2 frac_bij))))); - val lemma02a = UNDISCH_ALL (GSYM (REWRITE_RULE[SND] (BETA_RULE (SPEC_ALL lemma01a)))); - val lemma02b = UNDISCH_ALL (GSYM (REWRITE_RULE[SND] (BETA_RULE (SPEC_ALL lemma01b)))); - in - store_thm("FRAC_NOT_EQ", ``!a1 b1 a2 b2. 0i < b1 ==> 0i < b2 ==> ~((a1,b1) = (a2,b2)) ==> ~(abs_frac (a1,b1) = abs_frac (a2,b2))``, - REPEAT GEN_TAC THEN - STRIP_TAC THEN STRIP_TAC THEN - REWRITE_TAC[CONTRAPOS_CONV ``~((a1,b1) = (a2,b2)) ==> ~(abs_frac (a1,b1) = abs_frac (a2,b2))``] THEN - ONCE_REWRITE_TAC[lemma02a,lemma02b] THEN - REWRITE_TAC[CONJUNCT1 frac_bij] THEN - RW_TAC int_ss [] ) - end; +(* following theorem (with longer proof) + was previously stored as "FRAC_NOT_EQ", must be an error JED 16.9.15 *) +val FRAC_NOT_EQ_IMP = store_thm("FRAC_NOT_EQ_IMP", + ``!a1 b1 a2 b2. 0i < b1 ==> 0i < b2 ==> + ~((a1,b1) = (a2,b2)) ==> ~(abs_frac (a1,b1) = abs_frac (a2,b2))``, + REPEAT GEN_TAC THEN STRIP_TAC THEN STRIP_TAC THEN + ASM_SIMP_TAC std_ss [FRAC_EQ]) ; + (*-------------------------------------------------------------------------- * FRAC_EQ_TAC : tactic @@ -163,32 +148,13 @@ val FRAC_NOT_EQ_IMP = * A ?- abs_frac(a1,b1) = abs_frac(a2,b2) * ========================================= FRAC_EQ_TAC * A ?- a1=a2 | A ?- b1=b2 + * + * simplified version - note, doesn't check that goal is of given form *--------------------------------------------------------------------------*) val FRAC_EQ_TAC:tactic = fn (asm_list,goal) => -let - val (lhs,rhs) = dest_eq goal; - val (lhc, lha) = dest_comb lhs; - val (rhc, rha ) = dest_comb rhs; - val (a1,b1) = dest_pair lha; - val (a2,b2) = dest_pair rha; -in - let - val subgoal1 = mk_eq(a1,a2); - val subgoal2 = mk_eq(b1,b2); - in - ( - [(asm_list,subgoal1), (asm_list,subgoal2)], - fn thms => MP - (SPEC b2 (SPEC a2 (SPEC b1 (SPEC a1 ( - prove(``!a1 b1 a2 b2. (a1=a2) /\ (b1=b2) ==> (abs_frac(a1,b1)=abs_frac(a2,b2))``, RW_TAC int_ss []) - ))))) - (LIST_CONJ thms) - ) - end -end -handle HOL_ERR _ => raise ERR "FRAC_EQ_TAC" ""; - + (AP_TERM_TAC THEN MK_COMB_TAC THENL [AP_TERM_TAC, ALL_TAC]) (asm_list,goal) + handle HOL_ERR _ => raise ERR "FRAC_EQ_TAC" ""; (*========================================================================== * some useful things about positive and non-zero From d6c2da5f7ab71599ece8c19c475736ea8cb715da Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Thu, 17 Sep 2015 20:55:37 +1000 Subject: [PATCH 478/718] some shorter proofs for ratTheory --- src/rational/ratScript.sml | 198 +++++++++++++++++-------------------- 1 file changed, 90 insertions(+), 108 deletions(-) diff --git a/src/rational/ratScript.sml b/src/rational/ratScript.sml index d442912144..b0e6f253ac 100644 --- a/src/rational/ratScript.sml +++ b/src/rational/ratScript.sml @@ -36,128 +36,110 @@ val _ = new_theory "rat"; (* definition of equivalence relation *) val rat_equiv_def = Define `rat_equiv f1 f2 = (frac_nmr f1 * frac_dnm f2 = frac_nmr f2 * frac_dnm f1)`; -val RAT_EQUIV = store_thm("RAT_EQUIV", ``!f1 f2. rat_equiv f1 f2 = (rat_equiv f1 = rat_equiv f2)``, - REPEAT GEN_TAC THEN - SUBST_TAC[FUN_EQ_CONV ``rat_equiv f1 = rat_equiv f2``] THEN - REWRITE_TAC[rat_equiv_def] THEN - EQ_TAC THEN - REPEAT STRIP_TAC THENL - [ - FRAC_POS_TAC ``frac_dnm f1`` THEN - FRAC_POS_TAC ``frac_dnm f2`` THEN - SUBST_TAC[UNDISCH (SPECL[``frac_nmr f1 * frac_dnm f``,``frac_nmr f * frac_dnm f1``,``frac_dnm f2``] INT_EQ_RMUL_EXP)] THEN - SUBST_TAC[UNDISCH (SPECL[``frac_nmr f2 * frac_dnm f``,``frac_nmr f * frac_dnm f2``,``frac_dnm f1``] INT_EQ_RMUL_EXP)] THEN - ASSUME_TAC (EQT_ELIM (AC_CONV (INT_MUL_ASSOC, INT_MUL_COMM) ``frac_nmr f1 * frac_dnm f * frac_dnm f2 = frac_nmr f1 * frac_dnm f2 * frac_dnm f``)) THEN - ASSUME_TAC (EQT_ELIM (AC_CONV (INT_MUL_ASSOC, INT_MUL_COMM) ``frac_nmr f * frac_dnm f1 * frac_dnm f2 = frac_nmr f * frac_dnm f2 * frac_dnm f1``)) THEN - ASSUME_TAC (EQT_ELIM (AC_CONV (INT_MUL_ASSOC, INT_MUL_COMM) ``frac_nmr f2 * frac_dnm f1 * frac_dnm f = frac_nmr f2 * frac_dnm f * frac_dnm f1``)) - , - LEFT_FORALL_TAC ``f2:frac`` - ] THEN - PROVE_TAC[] ); - (* RAT_EQUIV_REF: |- !a:frac. rat_equiv a a *) val RAT_EQUIV_REF = store_thm("RAT_EQUIV_REF", ``!a:frac. rat_equiv a a``, - STRIP_TAC THEN - REWRITE_TAC[rat_equiv_def] ); + STRIP_TAC THEN + REWRITE_TAC[rat_equiv_def] ); (* RAT_EQUIV_SYM: |- !a b. rat_equiv a b = rat_equiv b a *) -val RAT_EQUIV_SYM = store_thm("RAT_EQUIV_SYM",``!a b. rat_equiv a b = rat_equiv b a``, - REPEAT STRIP_TAC THEN - REWRITE_TAC[rat_equiv_def] THEN - RW_TAC int_ss[EQ_SYM_EQ] ); - -(* RAT_EQUIV_TRANS: |- !a b c. rat_equiv a b /\ rat_equiv b c ==> rat_equiv a c *) -val RAT_EQUIV_TRANS = - let - val subst01 = prove(``(frac_nmr a * frac_dnm b = frac_nmr b * frac_dnm a) = (frac_nmr a * frac_dnm b * frac_dnm c * frac_dnm c = frac_nmr b * frac_dnm a * frac_dnm c * frac_dnm c)``, - FRAC_POS_TAC ``frac_dnm c * frac_dnm c`` THEN - ASSUME_TAC (SPEC ``frac_dnm c * frac_dnm c`` (SPEC ``frac_nmr b * frac_dnm a`` (SPEC ``frac_nmr a * frac_dnm b`` INT_EQ_RMUL_EXP))) THEN - RW_TAC int_ss[INT_MUL_ASSOC]); - - val subst02 = prove(``(frac_nmr b * frac_dnm c = frac_nmr c * frac_dnm b) = (frac_nmr b * frac_dnm c * frac_dnm a * frac_dnm c = frac_nmr c * frac_dnm b * frac_dnm a * frac_dnm c)``, - FRAC_POS_TAC ``frac_dnm a * frac_dnm c`` THEN - ASSUME_TAC (SPEC ``frac_dnm a * frac_dnm c`` (SPEC ``frac_nmr c * frac_dnm b`` (SPEC ``frac_nmr b * frac_dnm c`` INT_EQ_RMUL_EXP))) THEN - RW_TAC int_ss[INT_MUL_ASSOC]); - - val subst03 = prove(``(frac_nmr a * frac_dnm c = frac_nmr c * frac_dnm a) = (frac_nmr a * frac_dnm c * frac_dnm b * frac_dnm c = frac_nmr c * frac_dnm a * frac_dnm b * frac_dnm c)``, - FRAC_POS_TAC ``frac_dnm b * frac_dnm c`` THEN - ASSUME_TAC (SPEC ``frac_dnm b * frac_dnm c`` (SPEC ``frac_nmr c * frac_dnm a`` (SPEC ``frac_nmr a * frac_dnm c`` INT_EQ_RMUL_EXP))) THEN - RW_TAC int_ss[INT_MUL_ASSOC]); - - val subst11 = - EQT_ELIM (AC_CONV (INT_MUL_ASSOC,INT_MUL_SYM) ``frac_nmr a * frac_dnm b * frac_dnm c * frac_dnm c = frac_nmr a * frac_dnm c * frac_dnm b * frac_dnm c``); - val subst12 = - EQT_ELIM (AC_CONV (INT_MUL_ASSOC,INT_MUL_SYM) ``frac_nmr b * frac_dnm a * frac_dnm c * frac_dnm c = frac_nmr b * frac_dnm c * frac_dnm a * frac_dnm c``); - val subst13 = - EQT_ELIM (AC_CONV (INT_MUL_ASSOC,INT_MUL_SYM) ``frac_nmr c * frac_dnm b * frac_dnm a * frac_dnm c = frac_nmr c * frac_dnm a * frac_dnm b * frac_dnm c``); - - in - store_thm("RAT_EQUIV_TRANS",``!a b c. rat_equiv a b /\ rat_equiv b c ==> rat_equiv a c``, - REPEAT GEN_TAC THEN - REWRITE_TAC[rat_equiv_def] THEN - SUBST_TAC[subst01, subst02, subst03] THEN - SUBST_TAC[subst11, subst12, subst13] THEN - REPEAT STRIP_TAC THEN - ASM_REWRITE_TAC[] ) - end; - +val RAT_EQUIV_SYM = store_thm("RAT_EQUIV_SYM", + ``!a b. rat_equiv a b = rat_equiv b a``, + REPEAT STRIP_TAC THEN + REWRITE_TAC[rat_equiv_def] THEN + RW_TAC int_ss[EQ_SYM_EQ] ); + +val INT_ENTIRE' = CONV_RULE (ONCE_DEPTH_CONV (LHS_CONV SYM_CONV)) INT_ENTIRE ; +val FRAC_DNMNZ = GSYM (MATCH_MP INT_LT_IMP_NE (SPEC_ALL FRAC_DNMPOS)) ; + +val RAT_EQUIV_NMR_Z_IFF = store_thm ("RAT_EQUIV_NMR_Z_IFF", + ``!a b. rat_equiv a b ==> ((frac_nmr a = 0) = (frac_nmr b = 0))``, + REWRITE_TAC[rat_equiv_def] THEN + REPEAT STRIP_TAC THEN EQ_TAC THEN DISCH_TAC THEN + FULL_SIMP_TAC std_ss [INT_MUL_LZERO, INT_MUL_RZERO, + INT_ENTIRE, INT_ENTIRE', FRAC_DNMNZ]) ; + +val RAT_NMR_Z_IFF_EQUIV = store_thm ("RAT_NMR_Z_IFF_EQUIV", + ``!a b. (frac_nmr a = 0) ==> (rat_equiv a b = (frac_nmr b = 0))``, + REWRITE_TAC[rat_equiv_def] THEN + REPEAT STRIP_TAC THEN EQ_TAC THEN DISCH_TAC THEN + REV_FULL_SIMP_TAC std_ss [INT_MUL_LZERO, INT_MUL_RZERO, + INT_ENTIRE, INT_ENTIRE', FRAC_DNMNZ]) ; + +val times_dnmb = MATCH_MP INT_EQ_RMUL_EXP (Q.SPEC `b` FRAC_DNMPOS) ; +fun ifcan f x = f x handle _ => x ; + +val box_equals = prove (``(a = b) ==> (c = a) /\ (d = b) ==> (c = d)``, + REPEAT STRIP_TAC THEN BasicProvers.VAR_EQ_TAC THEN ASM_SIMP_TAC bool_ss []) ; + +val RAT_EQUIV_TRANS = store_thm("RAT_EQUIV_TRANS", + ``!a b c. rat_equiv a b /\ rat_equiv b c ==> rat_equiv a c``, + REPEAT GEN_TAC THEN Cases_on `frac_nmr b = 0` + THENL [ STRIP_TAC THEN + RULE_ASSUM_TAC (ifcan (MATCH_MP RAT_EQUIV_NMR_Z_IFF)) THEN + FULL_SIMP_TAC std_ss [RAT_NMR_Z_IFF_EQUIV], + REWRITE_TAC[rat_equiv_def] THEN STRIP_TAC THEN + ONCE_REWRITE_TAC [times_dnmb] THEN + FIRST_X_ASSUM (fn th => ONCE_REWRITE_TAC [MATCH_MP INT_EQ_LMUL2 th]) THEN + POP_ASSUM_LIST (fn [thbc, thab] => ASSUME_TAC + (MK_COMB (AP_TERM ``int_mul`` thab, thbc))) THEN + POP_ASSUM (fn th => MATCH_MP_TAC (MATCH_MP box_equals th)) THEN + CONJ_TAC THEN CONV_TAC (AC_CONV (INT_MUL_ASSOC,INT_MUL_SYM)) ] ) ; + +val RAT_EQUIV_TRANS' = REWRITE_RULE [GSYM AND_IMP_INTRO] RAT_EQUIV_TRANS ; + +fun e2tac tthm = FIRST_X_ASSUM (fn th1 => + let val tha1 = MATCH_MP tthm th1 ; + in FIRST_X_ASSUM (fn th2 => ACCEPT_TAC (MATCH_MP tha1 th2)) end) ; + +val RAT_EQUIV = store_thm("RAT_EQUIV", + ``!f1 f2. rat_equiv f1 f2 = (rat_equiv f1 = rat_equiv f2)``, + REPEAT GEN_TAC THEN EQ_TAC + THENL [ + REWRITE_TAC[FUN_EQ_THM] THEN + REPEAT STRIP_TAC THEN EQ_TAC THEN_LT + NTH_GOAL (ONCE_REWRITE_TAC [RAT_EQUIV_SYM]) 1 THEN + DISCH_TAC THEN e2tac RAT_EQUIV_TRANS', + DISCH_TAC THEN ASM_SIMP_TAC bool_ss [RAT_EQUIV_REF]]) ; (*--------------------------------------------------------------------------* * RAT_EQUIV_ALT * * |- !a. rat_equiv a = * \x. (?b c. 0 0 < frac_dnm x * y``, REPEAT GEN_TAC THEN FRAC_POS_TAC ``frac_dnm x`` THEN RW_TAC int_ss[INT_MUL_POS_SIGN]); - val lemma2 = prove(``(abs_frac (frac_nmr a * b,frac_dnm a * b) = abs_frac (frac_nmr f * c,frac_dnm f * c)) ==> (rep_frac (abs_frac (frac_nmr a * b,frac_dnm a * b)) = rep_frac (abs_frac (frac_nmr f * c,frac_dnm f * c)))``, RW_TAC int_ss[]); - (* lemma3: 0 < frac_dnm a * b |= rep_frac (abs_frac (frac_nmr a * b,frac_dnm a * b)) = (frac_nmr a * b,frac_dnm a * b) *) - val lemma3 = UNDISCH_ALL (REWRITE_RULE[pairTheory.SND] (#1 (EQ_IMP_RULE (SPEC ``(frac_nmr a * b,frac_dnm a * b)`` (BETA_RULE (CONJUNCT2 frac_bij)))))); - (* lemma4: 0 < frac_dnm f * c |= rep_frac (abs_frac (frac_nmr f * c,frac_dnm f * c)) = (frac_nmr f * c,frac_dnm f * c) *) - val lemma4 = UNDISCH_ALL (REWRITE_RULE[pairTheory.SND] (#1 (EQ_IMP_RULE (SPEC ``(frac_nmr f * c,frac_dnm f * c)`` (BETA_RULE (CONJUNCT2 frac_bij)))))); - - val subst1 = UNDISCH_ALL (SPEC ``b:int`` (SPEC ``frac_nmr f * frac_dnm a`` (SPEC ``frac_nmr a * frac_dnm f`` INT_EQ_RMUL_EXP))); - val subst2 = UNDISCH_ALL (SPEC ``c:int`` (SPEC ``frac_nmr f * frac_dnm a * b`` (SPEC ``frac_nmr a * frac_dnm f * b`` INT_EQ_RMUL_EXP))); -in - store_thm("RAT_EQUIV_ALT", ``!a. rat_equiv a = \x. (?b c. 0 + ONCE_REWRITE_TAC [MATCH_MP INT_EQ_RMUL_EXP th]) THEN + FIRST_X_ASSUM (fn th => + ONCE_REWRITE_TAC [MATCH_MP INT_EQ_RMUL_EXP th]) THEN + POP_ASSUM (fn th => MATCH_MP_TAC (MATCH_MP box_equals th)) THEN + CONJ_TAC THEN CONV_TAC (AC_CONV (INT_MUL_ASSOC,INT_MUL_SYM)) ] ) ; (*--------------------------------------------------------------------------* * type definition From 4dd0d9ed7fe06fd233d66f9735a9ab0a2e3d714c Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Thu, 17 Sep 2015 23:30:19 +1000 Subject: [PATCH 479/718] shorter proofs of RAT_NMRxx0_CONG in ratTheory also useful lemmas RAT_EQUIV_NMR_xxZ_IFF --- src/rational/ratScript.sml | 79 +++++++++++++++----------------------- 1 file changed, 32 insertions(+), 47 deletions(-) diff --git a/src/rational/ratScript.sml b/src/rational/ratScript.sml index b0e6f253ac..3e7c786cad 100644 --- a/src/rational/ratScript.sml +++ b/src/rational/ratScript.sml @@ -50,6 +50,9 @@ val RAT_EQUIV_SYM = store_thm("RAT_EQUIV_SYM", val INT_ENTIRE' = CONV_RULE (ONCE_DEPTH_CONV (LHS_CONV SYM_CONV)) INT_ENTIRE ; val FRAC_DNMNZ = GSYM (MATCH_MP INT_LT_IMP_NE (SPEC_ALL FRAC_DNMPOS)) ; +val FRAC_DNMNN = let val th = MATCH_MP INT_LT_IMP_LE (SPEC_ALL FRAC_DNMPOS) + in MATCH_MP (snd (EQ_IMP_RULE (SPEC_ALL INT_NOT_LT))) th end ; +fun ifcan f x = f x handle _ => x ; val RAT_EQUIV_NMR_Z_IFF = store_thm ("RAT_EQUIV_NMR_Z_IFF", ``!a b. rat_equiv a b ==> ((frac_nmr a = 0) = (frac_nmr b = 0))``, @@ -58,6 +61,20 @@ val RAT_EQUIV_NMR_Z_IFF = store_thm ("RAT_EQUIV_NMR_Z_IFF", FULL_SIMP_TAC std_ss [INT_MUL_LZERO, INT_MUL_RZERO, INT_ENTIRE, INT_ENTIRE', FRAC_DNMNZ]) ; +val RAT_EQUIV_NMR_GTZ_IFF = store_thm ("RAT_EQUIV_NMR_GTZ_IFF", + ``!a b. rat_equiv a b ==> ((frac_nmr a > 0) = (frac_nmr b > 0))``, + REWRITE_TAC[rat_equiv_def] THEN + REPEAT STRIP_TAC THEN EQ_TAC THEN DISCH_TAC THEN + RULE_ASSUM_TAC (ifcan (AP_TERM ``int_lt 0i``)) THEN + FULL_SIMP_TAC std_ss [int_gt, INT_MUL_SIGN_CASES, FRAC_DNMPOS, FRAC_DNMNN ]) ; + +val RAT_EQUIV_NMR_LTZ_IFF = store_thm ("RAT_EQUIV_NMR_LTZ_IFF", + ``!a b. rat_equiv a b ==> ((frac_nmr a < 0) = (frac_nmr b < 0))``, + REWRITE_TAC[rat_equiv_def] THEN + REPEAT STRIP_TAC THEN EQ_TAC THEN DISCH_TAC THEN + RULE_ASSUM_TAC (ifcan (AP_TERM ``int_gt 0i``)) THEN + FULL_SIMP_TAC std_ss [int_gt, INT_MUL_SIGN_CASES, FRAC_DNMPOS, FRAC_DNMNN ]) ; + val RAT_NMR_Z_IFF_EQUIV = store_thm ("RAT_NMR_Z_IFF_EQUIV", ``!a b. (frac_nmr a = 0) ==> (rat_equiv a b = (frac_nmr b = 0))``, REWRITE_TAC[rat_equiv_def] THEN @@ -66,7 +83,6 @@ val RAT_NMR_Z_IFF_EQUIV = store_thm ("RAT_NMR_Z_IFF_EQUIV", INT_ENTIRE, INT_ENTIRE', FRAC_DNMNZ]) ; val times_dnmb = MATCH_MP INT_EQ_RMUL_EXP (Q.SPEC `b` FRAC_DNMPOS) ; -fun ifcan f x = f x handle _ => x ; val box_equals = prove (``(a = b) ==> (c = a) /\ (d = b) ==> (c = d)``, REPEAT STRIP_TAC THEN BasicProvers.VAR_EQ_TAC THEN ASM_SIMP_TAC bool_ss []) ; @@ -239,6 +255,9 @@ val RAT_ABS_EQUIV = store_thm("RAT_ABS_EQUIV", ``!f1 f2. (abs_rat f1 = abs_rat f val REP_ABS_EQUIV = prove(``!a. rat_equiv a (rep_rat (abs_rat a))``, PROVE_TAC[rat_equiv_def, rat_def]); +val RAT_ABS_EQUIV' = GSYM RAT_ABS_EQUIV ; +val REP_ABS_EQUIV' = ONCE_REWRITE_RULE [RAT_EQUIV_SYM] REP_ABS_EQUIV ; + val REP_ABS_DFN_EQUIV = prove(``!x. frac_nmr x * frac_dnm (rep_rat(abs_rat x)) = frac_nmr (rep_rat(abs_rat x)) * frac_dnm x``, GEN_TAC THEN REWRITE_TAC[GSYM rat_equiv_def] THEN @@ -292,54 +311,20 @@ val RAT_EQ_ALT = store_thm("RAT_EQ_ALT", ``! r1 r2. (r1=r2) = (rat_nmr r1 * rat_ * *--------------------------------------------------------------------------*) -val RAT_NMREQ0_CONG = -let - val subst1 = UNDISCH_ALL (SPEC ``frac_dnm f1`` (SPEC ``0i`` (SPEC ``frac_nmr (rep_rat (abs_rat f1))`` INT_EQ_RMUL_EXP))); - val subst2 = UNDISCH_ALL (SPEC ``frac_dnm (rep_rat (abs_rat f1))`` (SPEC ``0i`` (SPEC ``frac_nmr f1`` INT_EQ_RMUL_EXP))); -in - store_thm("RAT_NMREQ0_CONG", ``!f1. (frac_nmr (rep_rat (abs_rat f1)) = 0) = (frac_nmr f1 = 0)``, - GEN_TAC THEN - FRAC_POS_TAC ``frac_dnm f1`` THEN - FRAC_POS_TAC ``frac_dnm (rep_rat (abs_rat f1))`` THEN - SUBST_TAC[subst1,subst2] THEN - REWRITE_TAC[INT_MUL_LZERO] THEN - PROVE_TAC[REP_ABS_DFN_EQUIV] ) -end; - +val RAT_NMREQ0_CONG = store_thm("RAT_NMREQ0_CONG", + ``!f1. (frac_nmr (rep_rat (abs_rat f1)) = 0) = (frac_nmr f1 = 0)``, + GEN_TAC THEN MATCH_ACCEPT_TAC + (MATCH_MP RAT_EQUIV_NMR_Z_IFF (SPEC_ALL REP_ABS_EQUIV'))) ; -val RAT_NMRLT0_CONG = -let - val subst1 = UNDISCH_ALL (SPEC ``frac_dnm f1`` (SPEC ``0i`` (SPEC ``frac_nmr (rep_rat (abs_rat f1))`` INT_LT_RMUL_EXP))); - val subst2 = UNDISCH_ALL (SPEC ``frac_dnm (rep_rat (abs_rat f1))`` (SPEC ``0i`` (SPEC ``frac_nmr f1`` INT_LT_RMUL_EXP))); -in - store_thm("RAT_NMRLT0_CONG", ``!f1. (frac_nmr (rep_rat (abs_rat f1)) < 0) = (frac_nmr f1 < 0)``, - GEN_TAC THEN - FRAC_POS_TAC ``frac_dnm f1`` THEN - FRAC_POS_TAC ``frac_dnm (rep_rat (abs_rat f1))`` THEN - SUBST_TAC[subst1,subst2] THEN - REWRITE_TAC[INT_MUL_LZERO] THEN - PROVE_TAC[REP_ABS_DFN_EQUIV] ) -end; - -val RAT_NMRGT0_CONG = -let - val subst1 = UNDISCH_ALL (SPEC ``frac_dnm f1`` - (SPEC ``0i`` - (SPEC ``frac_nmr (rep_rat (abs_rat f1))`` INT_GT_RMUL_EXP))) - val subst2 = UNDISCH_ALL (SPEC ``frac_dnm (rep_rat (abs_rat f1))`` - (SPEC ``0i`` - (SPEC ``frac_nmr f1`` INT_GT_RMUL_EXP))) -in - store_thm("RAT_NMRGT0_CONG", - ``!f1. (frac_nmr (rep_rat (abs_rat f1)) > 0) = (frac_nmr f1 > 0)``, - GEN_TAC THEN - FRAC_POS_TAC ``frac_dnm f1`` THEN - FRAC_POS_TAC ``frac_dnm (rep_rat (abs_rat f1))`` THEN - SUBST_TAC[subst1,subst2] THEN - REWRITE_TAC[INT_MUL_LZERO] THEN - PROVE_TAC[REP_ABS_DFN_EQUIV] ) -end; +val RAT_NMRLT0_CONG = store_thm("RAT_NMRLT0_CONG", + ``!f1. (frac_nmr (rep_rat (abs_rat f1)) < 0) = (frac_nmr f1 < 0)``, + GEN_TAC THEN MATCH_ACCEPT_TAC + (MATCH_MP RAT_EQUIV_NMR_LTZ_IFF (SPEC_ALL REP_ABS_EQUIV'))) ; +val RAT_NMRGT0_CONG = store_thm("RAT_NMRGT0_CONG", + ``!f1. (frac_nmr (rep_rat (abs_rat f1)) > 0) = (frac_nmr f1 > 0)``, + GEN_TAC THEN MATCH_ACCEPT_TAC + (MATCH_MP RAT_EQUIV_NMR_GTZ_IFF (SPEC_ALL REP_ABS_EQUIV'))) ; (*-------------------------------------------------------------------------- * RAT_SGN_CONG: thm From 819bfd2cbce7360170fea44af93d0a5158c13290 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Fri, 18 Sep 2015 18:54:57 +1000 Subject: [PATCH 480/718] shorter proof of ratTheory.RAT_MINV_CONG uses new theorem ratTheory.FRAC_MINV_EQUIV also name clash in ratScript.sml between theorem stored as rat_def and ML identifier rat_def, changed latter to rat_thm --- src/rational/ratScript.sml | 101 +++++++++++++++---------------------- 1 file changed, 41 insertions(+), 60 deletions(-) diff --git a/src/rational/ratScript.sml b/src/rational/ratScript.sml index 3e7c786cad..10df5ffacd 100644 --- a/src/rational/ratScript.sml +++ b/src/rational/ratScript.sml @@ -127,9 +127,10 @@ val RAT_EQUIV = store_thm("RAT_EQUIV", * alternative representation of equivalence relation *--------------------------------------------------------------------------*) -val FRAC_EQ' = UNDISCH_ALL (SPEC_ALL FRAC_EQ) ; -val feqconv = DEPTH_CONV (REWR_CONV_A FRAC_EQ') ; -val feqtac = VALIDATE (POP_ASSUM (ASSUME_TAC o CONV_RULE feqconv)) ; +fun feqconv thm = let val thm' = UNDISCH_ALL (SPEC_ALL thm) ; + in DEPTH_CONV (REWR_CONV_A thm') end ; +fun feqtac thm = VALIDATE (POP_ASSUM (ASSUME_TAC o CONV_RULE (feqconv thm))) ; + fun msprod th = let val [thbc, thab] = CONJUNCTS th in MK_COMB (AP_TERM ``int_mul`` (MATCH_MP EQ_SYM thab), thbc) end ; @@ -141,12 +142,12 @@ val RAT_EQUIV_ALT = store_thm("RAT_EQUIV_ALT", THENL [ DISCH_TAC THEN EXISTS_TAC ``frac_dnm x`` THEN EXISTS_TAC ``frac_dnm a`` THEN ASM_SIMP_TAC bool_ss [FRAC_DNMPOS, NMR, DNM] THEN - VALIDATE (CONV_TAC feqconv) THEN + VALIDATE (CONV_TAC (feqconv FRAC_EQ)) THEN TRY (irule INT_MUL_POS_SIGN THEN irule FRAC_DNMPOS) THEN CONJ_TAC (* ASM_SIMP_TAC bool_ss [] does nothing - why ??? *) THENL [ POP_ASSUM ACCEPT_TAC, ASM_SIMP_TAC bool_ss [INT_MUL_COMM] ], REPEAT STRIP_TAC THEN - REV_FULL_SIMP_TAC bool_ss [NMR, DNM] THEN feqtac THEN + REV_FULL_SIMP_TAC bool_ss [NMR, DNM] THEN feqtac FRAC_EQ THEN TRY (irule INT_MUL_POS_SIGN THEN ASM_SIMP_TAC bool_ss [FRAC_DNMPOS]) THEN POP_ASSUM (ASSUME_TAC o msprod) THEN @@ -161,10 +162,12 @@ val RAT_EQUIV_ALT = store_thm("RAT_EQUIV_ALT", * type definition *--------------------------------------------------------------------------*) -val _ = save_thm("rat_def", define_quotient_type "rat" "abs_rat" "rep_rat" RAT_EQUIV); +(* following also stored as rat_QUOTIENT *) +val rat_def = save_thm("rat_def", + define_quotient_type "rat" "abs_rat" "rep_rat" RAT_EQUIV); val QUOTIENT_def = DB.fetch "quotient" "QUOTIENT_def"; -val rat_def = REWRITE_RULE[QUOTIENT_def] (DB.fetch "-" "rat_QUOTIENT"); +val rat_thm = REWRITE_RULE[QUOTIENT_def] rat_def ; (* was rat_def *) (*--------------------------------------------------------------------------* * operations @@ -243,17 +246,17 @@ val _ = add_user_printer val RAT = store_thm("RAT", ``!r. abs_rat ( rep_rat r ) = r``, GEN_TAC THEN - PROVE_TAC[rat_def]); + PROVE_TAC[rat_thm]); (*-------------------------------------------------------------------------- * some lemmas *--------------------------------------------------------------------------*) val RAT_ABS_EQUIV = store_thm("RAT_ABS_EQUIV", ``!f1 f2. (abs_rat f1 = abs_rat f2) = rat_equiv f1 f2``, - PROVE_TAC[rat_def, rat_equiv_def] ); + PROVE_TAC[rat_thm, rat_equiv_def] ); val REP_ABS_EQUIV = prove(``!a. rat_equiv a (rep_rat (abs_rat a))``, - PROVE_TAC[rat_equiv_def, rat_def]); + PROVE_TAC[rat_equiv_def, rat_thm]); val RAT_ABS_EQUIV' = GSYM RAT_ABS_EQUIV ; val REP_ABS_EQUIV' = ONCE_REWRITE_RULE [RAT_EQUIV_SYM] REP_ABS_EQUIV ; @@ -293,7 +296,7 @@ val RAT_EQ_ALT = store_thm("RAT_EQ_ALT", ``! r1 r2. (r1=r2) = (rat_nmr r1 * rat_ REPEAT GEN_TAC THEN REWRITE_TAC[rat_nmr_def, rat_dnm_def] THEN REWRITE_TAC[GSYM rat_equiv_def] THEN - PROVE_TAC[rat_def] ); + PROVE_TAC[rat_thm] ); (*========================================================================== * congruence theorems @@ -359,48 +362,26 @@ val RAT_AINV_CONG = store_thm("RAT_AINV_CONG", ``!x. abs_rat (frac_ainv (rep_rat * (abs_rat (frac_minv (rep_rat (abs_rat x))) = abs_rat (frac_minv x)) *--------------------------------------------------------------------------*) -val RAT_MINV_CONG = -let - val lemmaX = prove(``0 < ABS (frac_nmr x) ==> 0 < ABS (frac_nmr (rep_rat (abs_rat x)))``, - REWRITE_TAC[INT_ABS] THEN - REWRITE_TAC[RAT_NMRLT0_CONG] THEN - RW_TAC int_ss[] THENL - [ - PROVE_TAC[RAT_NMRLT0_CONG] - , - UNDISCH_TAC ``0 < frac_nmr x`` THEN - REWRITE_TAC[GSYM int_gt] THEN - PROVE_TAC[RAT_NMRGT0_CONG] - ] ); - val lemmaY = prove(``!x:int. 0 (ABS x = x)``, - GEN_TAC THEN - REWRITE_TAC[INT_ABS] THEN - RW_TAC int_ss[] THEN - PROVE_TAC[INT_LT_ANTISYM] ); -in - - - store_thm("RAT_MINV_CONG",``!x. ~(frac_nmr x=0) ==> (abs_rat (frac_minv (rep_rat (abs_rat x))) = abs_rat (frac_minv x))``, - - REPEAT STRIP_TAC THEN - REWRITE_TAC[frac_minv_def] THEN - ASSUME_TAC (UNDISCH_ALL (SPEC ``frac_nmr x`` INT_ABS_NOT0POS)) THEN - ASSUME_TAC (UNDISCH_ALL lemmaX) THEN - REWRITE_TAC[RAT_ABS_EQUIV] THEN - REWRITE_TAC[rat_equiv_def] THEN - RW_TAC int_ss[NMR,DNM] THEN - FRAC_POS_TAC ``frac_dnm x`` THEN - FRAC_POS_TAC ``frac_dnm (rep_rat (abs_rat x))`` THEN - ONCE_REWRITE_TAC[UNDISCH_ALL (GSYM (SPEC ``frac_dnm x`` lemmaY)),UNDISCH_ALL (GSYM (SPEC ``frac_dnm (rep_rat (abs_rat x))`` lemmaY))] THEN - REWRITE_TAC[RAT_SGN_CONG] THEN - REWRITE_TAC[EQT_ELIM (AC_CONV (INT_MUL_ASSOC,INT_MUL_SYM) ``frac_sgn x * ABS (frac_dnm (rep_rat (abs_rat x))) * ABS (frac_nmr x) = frac_sgn x * (ABS (frac_dnm (rep_rat (abs_rat x))) * ABS (frac_nmr x))``)] THEN - REWRITE_TAC[EQT_ELIM (AC_CONV (INT_MUL_ASSOC,INT_MUL_SYM) ``frac_sgn x * ABS (frac_dnm x) * ABS (frac_nmr (rep_rat (abs_rat x))) = frac_sgn x * (ABS (frac_dnm x) * ABS (frac_nmr (rep_rat (abs_rat x))))``)] THEN - REWRITE_TAC[INT_ABS_MUL] THEN - REWRITE_TAC[INT_EQ_LMUL] THEN - DISJ2_TAC THEN - ONCE_REWRITE_TAC[INT_MUL_SYM] THEN - REWRITE_TAC[REP_ABS_DFN_EQUIV] ) -end; +val FRAC_MINV_EQUIV = store_thm ("FRAC_MINV_EQUIV", + ``~(frac_nmr y=0) ==> rat_equiv x y ==> + rat_equiv (frac_minv x) (frac_minv y)``, + DISCH_TAC THEN DISCH_THEN (fn th => MP_TAC th THEN ASSUME_TAC th) THEN + POP_ASSUM (ASSUME_TAC o MATCH_MP RAT_EQUIV_NMR_Z_IFF) THEN + REWRITE_TAC[frac_minv_def, rat_equiv_def, frac_sgn_def] THEN + VALIDATE (CONV_TAC (feqconv NMR THENC feqconv DNM)) THEN + (TRY (irule INT_ABS_NOT0POS THEN ASM_SIMP_TAC bool_ss [])) THEN + REWRITE_TAC[SGN_def] THEN REPEAT IF_CASES_TAC THEN + ASM_SIMP_TAC int_ss [INT_ABS, + GSYM INT_NEG_MINUS1, GSYM INT_NEG_LMUL, GSYM INT_NEG_RMUL] THEN + SIMP_TAC bool_ss [INT_MUL_COMM]) ; + +val RAT_MINV_CONG = store_thm("RAT_MINV_CONG", + ``!x. ~(frac_nmr x=0) ==> + (abs_rat (frac_minv (rep_rat (abs_rat x))) = abs_rat (frac_minv x))``, + REPEAT STRIP_TAC THEN + IMP_RES_TAC FRAC_MINV_EQUIV THEN + ASSUME_TAC (Q.SPEC `x` REP_ABS_EQUIV') THEN + RES_TAC THEN ASM_SIMP_TAC bool_ss [RAT_ABS_EQUIV]) ; (*-------------------------------------------------------------------------- * RAT_ADD_CONG1: thm @@ -964,7 +945,7 @@ val RAT_ADD_RID = store_thm("RAT_ADD_RID", ``!a. rat_add a 0q = a``, REWRITE_TAC[rat_add_def,rat_0] THEN REWRITE_TAC[RAT_ADD_CONG] THEN REWRITE_TAC[FRAC_ADD_RID] THEN - RW_TAC int_ss[CONJUNCT1 rat_def]); + RW_TAC int_ss[CONJUNCT1 rat_thm]); val RAT_ADD_LID = store_thm("RAT_ADD_LID", ``!a. rat_add 0q a = a``, ONCE_REWRITE_TAC[RAT_ADD_COMM] THEN @@ -974,7 +955,7 @@ val RAT_MUL_RID = store_thm("RAT_MUL_RID", ``!a. rat_mul a 1q = a``, REWRITE_TAC[rat_mul_def,rat_1] THEN REWRITE_TAC[RAT_MUL_CONG] THEN REWRITE_TAC[FRAC_MUL_RID] THEN - RW_TAC int_ss[CONJUNCT1 rat_def]); + RW_TAC int_ss[CONJUNCT1 rat_thm]); val RAT_MUL_LID = store_thm("RAT_MUL_LID", ``!a. rat_mul 1q a = a``, ONCE_REWRITE_TAC[RAT_MUL_COMM] THEN @@ -1026,9 +1007,9 @@ let REWRITE_TAC[rat_0, frac_0_def] THEN ONCE_REWRITE_TAC[EQ_SYM_EQ] THEN ASM_REWRITE_TAC[] THEN - SUBST_TAC[GSYM (SPEC ``a:rat`` (CONJUNCT1 rat_def))] THEN + SUBST_TAC[GSYM (SPEC ``a:rat`` (CONJUNCT1 rat_thm))] THEN REWRITE_TAC[rat_equiv_def, RAT_ABS_EQUIV] THEN - RW_TAC int_ss[rat_def] THEN + RW_TAC int_ss[rat_thm] THEN FRAC_POS_TAC ``1i`` THEN RW_TAC int_ss[NMR,DNM] THEN UNDISCH_TAC ``0 = frac_nmr (rep_rat a)`` THEN @@ -1170,7 +1151,7 @@ val RAT_AINV_0 = store_thm("RAT_AINV_0", ``rat_ainv 0q = 0q``, val RAT_AINV_AINV = store_thm("RAT_AINV_AINV", ``!r1. rat_ainv (rat_ainv r1) = r1``, GEN_TAC THEN REWRITE_TAC[rat_ainv_def] THEN - RW_TAC int_ss[RAT_AINV_CONG, FRAC_AINV_AINV, rat_def] ); + RW_TAC int_ss[RAT_AINV_CONG, FRAC_AINV_AINV, rat_thm] ); val RAT_AINV_ADD = store_thm("RAT_AINV_ADD", ``! r1 r2. rat_ainv (rat_add r1 r2) = rat_add (rat_ainv r1) (rat_ainv r2)``, REPEAT GEN_TAC THEN @@ -1210,7 +1191,7 @@ val lemma01 = prove(``!r1 r2. (rat_ainv r1 = rat_ainv r2) = (r1=r2)``, REWRITE_TAC[INT_EQ_NEG] THEN REWRITE_TAC[GSYM rat_equiv_def] THEN REWRITE_TAC[GSYM RAT_ABS_EQUIV] THEN - RW_TAC int_ss[rat_def] ); + RW_TAC int_ss[rat_thm] ); val lemma02 = prove(``!r1 r2. (rat_ainv r1 = r2) = (r1 = rat_ainv r2)``, REPEAT GEN_TAC THEN EQ_TAC THEN @@ -1768,7 +1749,7 @@ val RAT_EQ_AINV = store_thm("RAT_EQ_AINV", ``!r1 r2. (rat_ainv r1 = rat_ainv r2) REWRITE_TAC[INT_EQ_NEG] THEN REWRITE_TAC[GSYM rat_equiv_def] THEN REWRITE_TAC[GSYM RAT_ABS_EQUIV] THEN - RW_TAC int_ss[rat_def] ); + RW_TAC int_ss[rat_thm] ); (*-------------------------------------------------------------------------- RAT_EQ_LADD, RAT_EQ_RADD From 1e2425b0379dabbe02e4cf42202378d256c7cf1d Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Sat, 19 Sep 2015 00:42:14 +1000 Subject: [PATCH 481/718] shorter proof of ratTheory.RAT_ADD_CONG1 also useful lemma FRAC_ADD_EQUIV1 --- src/rational/ratScript.sml | 70 ++++++++++++-------------------------- 1 file changed, 22 insertions(+), 48 deletions(-) diff --git a/src/rational/ratScript.sml b/src/rational/ratScript.sml index 10df5ffacd..e346a1c964 100644 --- a/src/rational/ratScript.sml +++ b/src/rational/ratScript.sml @@ -378,10 +378,10 @@ val FRAC_MINV_EQUIV = store_thm ("FRAC_MINV_EQUIV", val RAT_MINV_CONG = store_thm("RAT_MINV_CONG", ``!x. ~(frac_nmr x=0) ==> (abs_rat (frac_minv (rep_rat (abs_rat x))) = abs_rat (frac_minv x))``, - REPEAT STRIP_TAC THEN - IMP_RES_TAC FRAC_MINV_EQUIV THEN - ASSUME_TAC (Q.SPEC `x` REP_ABS_EQUIV') THEN - RES_TAC THEN ASM_SIMP_TAC bool_ss [RAT_ABS_EQUIV]) ; + REPEAT STRIP_TAC THEN + IMP_RES_TAC FRAC_MINV_EQUIV THEN + ASSUME_TAC (Q.SPEC `x` REP_ABS_EQUIV') THEN + RES_TAC THEN ASM_SIMP_TAC bool_ss [RAT_ABS_EQUIV]) ; (*-------------------------------------------------------------------------- * RAT_ADD_CONG1: thm @@ -395,50 +395,24 @@ val RAT_MINV_CONG = store_thm("RAT_MINV_CONG", * !x y. abs_rat (frac_add x (rep_rat (abs_rat y))) = abs_rat (frac_add x y) *--------------------------------------------------------------------------*) -val RAT_ADD_CONG1 = -let - val lemmaX = prove(``!a:int b:int c:int d:int. (a + b = c + d) = (a - c = d - b)``, - REWRITE_TAC[SPEC ``b:int`` (SPEC ``d:int`` (SPEC ``a:int - c:int`` INT_EQ_SUB_LADD))] THEN - ONCE_REWRITE_TAC[EQT_ELIM (intLib.ARITH_CONV ``(a:int) - (c:int) + (b:int) = a + b - c``)] THEN - REWRITE_TAC[SPEC ``d:int`` (SPEC ``c:int`` (SPEC ``(a:int) + (b:int)`` INT_EQ_SUB_RADD)) ] THEN - RW_TAC int_ss[EQT_ELIM (intLib.ARITH_CONV ``(d:int) + (c:int) = c + d``)] ); - val lemmaY = prove(``!a:int b:int. 0 ( (a*b=0)=(a=0) )``, - REPEAT STRIP_TAC THEN - EQ_TAC THENL - [ - SUBST_TAC[UNDISCH_ALL (SPEC ``b:int`` (SPEC ``0i`` (SPEC ``a:int`` INT_EQ_RMUL_EXP)))] THEN - ASM_REWRITE_TAC[] THEN - RW_TAC int_ss[INT_MUL_LZERO] - , - RW_TAC int_ss[INT_MUL_LZERO] - ]); - val subst1 = UNDISCH_ALL (SPEC ``frac_dnm y`` (SPEC ``(frac_nmr x * (frac_dnm (rep_rat (abs_rat x)) * frac_dnm y) + frac_nmr y * frac_dnm x * frac_dnm (rep_rat (abs_rat x)))`` (SPEC ``(frac_nmr (rep_rat (abs_rat x)) * frac_dnm x * frac_dnm y + frac_nmr y * frac_dnm (rep_rat (abs_rat x)) * frac_dnm x)`` (GSYM INT_EQ_RMUL_EXP)))); -in - store_thm("RAT_ADD_CONG1", ``!x y. abs_rat (frac_add (rep_rat (abs_rat x)) y) = abs_rat (frac_add x y)``, - REPEAT GEN_TAC THEN - REWRITE_TAC[RAT_ABS_EQUIV] THEN - REWRITE_TAC[rat_equiv_def,frac_add_def] THEN - FRAC_POS_TAC ``frac_dnm x * frac_dnm y`` THEN - FRAC_POS_TAC ``frac_dnm (rep_rat (abs_rat x)) * frac_dnm y`` THEN - RW_TAC int_ss[NMR,DNM] THEN - REWRITE_TAC[INT_RDISTRIB] THEN - REWRITE_TAC[EQT_ELIM (RING_CONV `` frac_nmr (rep_rat (abs_rat x)) * frac_dnm y * (frac_dnm x * frac_dnm y) + frac_nmr y * frac_dnm (rep_rat (abs_rat x)) * (frac_dnm x * frac_dnm y) = (frac_nmr (rep_rat (abs_rat x)) * frac_dnm x * frac_dnm y + frac_nmr y * frac_dnm (rep_rat (abs_rat x)) * frac_dnm x) * frac_dnm y``)] THEN - REWRITE_TAC[EQT_ELIM (RING_CONV `` frac_nmr x * frac_dnm y * (frac_dnm (rep_rat (abs_rat x)) * frac_dnm y) + frac_nmr y * frac_dnm x * (frac_dnm (rep_rat (abs_rat x)) * frac_dnm y)=(frac_nmr x * (frac_dnm (rep_rat (abs_rat x)) * frac_dnm y) + frac_nmr y * frac_dnm x * (frac_dnm (rep_rat (abs_rat x)))) * frac_dnm y``)] THEN - FRAC_POS_TAC ``frac_dnm y`` THEN - SUBST_TAC[subst1] THEN - REWRITE_TAC[EQT_ELIM (RING_CONV ``frac_nmr x * (frac_dnm (rep_rat (abs_rat x)) * frac_dnm y) = frac_nmr x * frac_dnm (rep_rat (abs_rat x)) * frac_dnm y``)] THEN - REWRITE_TAC[EQT_ELIM (RING_CONV ``frac_nmr y * frac_dnm x * frac_dnm (rep_rat (abs_rat x)) = frac_nmr y * (frac_dnm x * frac_dnm (rep_rat (abs_rat x)))``)] THEN - REWRITE_TAC[EQT_ELIM (RING_CONV ``frac_nmr y * frac_dnm (rep_rat (abs_rat x)) * frac_dnm x = frac_nmr y * (frac_dnm (rep_rat (abs_rat x)) * frac_dnm x)``)] THEN - RW_TAC int_ss[lemmaX] THEN - REWRITE_TAC[GSYM INT_SUB_LDISTRIB, GSYM INT_SUB_RDISTRIB] THEN - REWRITE_TAC[EQT_ELIM (RING_CONV ``frac_dnm x * frac_dnm (rep_rat (abs_rat x)) = frac_dnm (rep_rat (abs_rat x)) * frac_dnm x``)] THEN - RW_TAC int_ss[INT_MUL_RZERO,INT_SUB_REFL] THEN - RW_TAC int_ss[lemmaY] THEN - ONCE_REWRITE_TAC[EQ_SYM_EQ] THEN - RW_TAC int_ss[INT_EQ_SUB_LADD, INT_ADD_LID] THEN - REWRITE_TAC[GSYM rat_equiv_def] THEN - RW_TAC int_ss[GSYM REP_ABS_EQUIV] ) -end; +val FRAC_ADD_EQUIV1 = store_thm ("FRAC_ADD_EQUIV1", + ``rat_equiv x x' ==> rat_equiv (frac_add x y) (frac_add x' y)``, + REWRITE_TAC[frac_add_def, rat_equiv_def] THEN + VALIDATE (CONV_TAC (feqconv NMR THENC feqconv DNM)) THEN + TRY (irule INT_MUL_POS_SIGN THEN irule FRAC_DNMPOS) THEN + REWRITE_TAC[INT_RDISTRIB] THEN DISCH_TAC THEN + MK_COMB_TAC THENL [AP_TERM_TAC, ALL_TAC] + THENL [ + RULE_ASSUM_TAC (AP_TERM ``int_mul (frac_dnm y * frac_dnm y)``) THEN + POP_ASSUM (fn th => MATCH_MP_TAC (MATCH_MP box_equals th)) THEN CONJ_TAC, + ALL_TAC ] THEN + CONV_TAC (AC_CONV (INT_MUL_ASSOC,INT_MUL_SYM)) ) ; + +val RAT_ADD_CONG1 = store_thm("RAT_ADD_CONG1", + ``!x y. abs_rat (frac_add (rep_rat (abs_rat x)) y) = abs_rat (frac_add x y)``, + REPEAT STRIP_TAC THEN + SIMP_TAC bool_ss [RAT_ABS_EQUIV] THEN + irule FRAC_ADD_EQUIV1 THEN irule REP_ABS_EQUIV') ; val RAT_ADD_CONG2 = store_thm("RAT_ADD_CONG2", ``!x y. abs_rat (frac_add x (rep_rat (abs_rat y))) = abs_rat (frac_add x y)``, ONCE_REWRITE_TAC[FRAC_ADD_COMM] THEN From d8e4c1a89a58565ba0f8213dd06f7834c96881b0 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Sat, 19 Sep 2015 00:59:50 +1000 Subject: [PATCH 482/718] shorter proof of ratTheory.RAT_MUL_CONG1 also useful lemma FRAC_MUL_EQUIV1 --- src/rational/ratScript.sml | 34 +++++++++++++--------------------- 1 file changed, 13 insertions(+), 21 deletions(-) diff --git a/src/rational/ratScript.sml b/src/rational/ratScript.sml index e346a1c964..4a98533ec9 100644 --- a/src/rational/ratScript.sml +++ b/src/rational/ratScript.sml @@ -432,28 +432,20 @@ val RAT_ADD_CONG = save_thm("RAT_ADD_CONG", CONJ RAT_ADD_CONG1 RAT_ADD_CONG2); * !x y. abs_rat (frac_mul x (rep_rat (abs_rat y))) = abs_rat (frac_mul x y) *--------------------------------------------------------------------------*) -val RAT_MUL_CONG1 = store_thm("RAT_MUL_CONG1", ``!x y. abs_rat (frac_mul (rep_rat (abs_rat x)) y) = abs_rat (frac_mul x y)``, +val FRAC_MUL_EQUIV1 = store_thm ("FRAC_MUL_EQUIV1", + ``rat_equiv x x' ==> rat_equiv (frac_mul x y) (frac_mul x' y)``, + REWRITE_TAC[frac_mul_def, rat_equiv_def] THEN + VALIDATE (CONV_TAC (feqconv NMR THENC feqconv DNM)) THEN + TRY (irule INT_MUL_POS_SIGN THEN irule FRAC_DNMPOS) THEN DISCH_TAC THEN + RULE_ASSUM_TAC (AP_TERM ``int_mul (frac_nmr y * frac_dnm y)``) THEN + POP_ASSUM (fn th => MATCH_MP_TAC (MATCH_MP box_equals th)) THEN + CONJ_TAC THEN CONV_TAC (AC_CONV (INT_MUL_ASSOC,INT_MUL_SYM)) ) ; - REPEAT GEN_TAC THEN - REWRITE_TAC[RAT_ABS_EQUIV] THEN - REWRITE_TAC[rat_equiv_def,frac_mul_def] THEN - FRAC_POS_TAC ``frac_dnm x * frac_dnm y`` THEN - FRAC_POS_TAC ``frac_dnm (rep_rat (abs_rat x)) * frac_dnm y`` THEN - RW_TAC int_ss[NMR,DNM] THEN - REWRITE_TAC[EQT_ELIM (RING_CONV ``frac_nmr (rep_rat (abs_rat x)) * frac_nmr y * (frac_dnm x * frac_dnm y) = frac_nmr (rep_rat (abs_rat x)) *frac_dnm x * frac_nmr y * frac_dnm y``)] THEN - REWRITE_TAC[EQT_ELIM (RING_CONV ``frac_nmr x * frac_nmr y * (frac_dnm (rep_rat (abs_rat x)) * frac_dnm y) = frac_nmr x * frac_dnm (rep_rat (abs_rat x)) * frac_nmr y * frac_dnm y``)] THEN - FRAC_POS_TAC ``frac_dnm y`` THEN - REWRITE_TAC[INT_EQ_RMUL] THEN - RW_TAC int_ss[LESS_IMP_NOT_0] THEN - ASM_CASES_TAC ``frac_nmr y=0`` THENL - [ - RW_TAC int_ss[] - , - RW_TAC int_ss[] THEN - REWRITE_TAC[GSYM rat_equiv_def] THEN - ONCE_REWRITE_TAC[RAT_EQUIV_SYM] THEN - RW_TAC int_ss[REP_ABS_EQUIV] - ] ); +val RAT_MUL_CONG1 = store_thm("RAT_MUL_CONG1", + ``!x y. abs_rat (frac_mul (rep_rat (abs_rat x)) y) = abs_rat (frac_mul x y)``, + REPEAT STRIP_TAC THEN + SIMP_TAC bool_ss [RAT_ABS_EQUIV] THEN + irule FRAC_MUL_EQUIV1 THEN irule REP_ABS_EQUIV') ; val RAT_MUL_CONG2 = store_thm("RAT_MUL_CONG2", ``!x y. abs_rat (frac_mul x (rep_rat (abs_rat y))) = abs_rat (frac_mul x y)``, ONCE_REWRITE_TAC[FRAC_MUL_COMM] THEN From 3ddd9eed6f765dbddbb2cac82d5d43ed071ef027 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Sat, 19 Sep 2015 17:44:53 +1000 Subject: [PATCH 483/718] finish ptree_sexp Of course (as I realised later) the PEG does not produce a parse tree anyway, but if one were to write a PEG that produces a parse tree, these conversions functions should be useful. --- examples/parsing/simpleSexpScript.sml | 191 ++++++++++++++++++++++++++ 1 file changed, 191 insertions(+) diff --git a/examples/parsing/simpleSexpScript.sml b/examples/parsing/simpleSexpScript.sml index 39afc46409..8fc4f8b355 100644 --- a/examples/parsing/simpleSexpScript.sml +++ b/examples/parsing/simpleSexpScript.sml @@ -152,5 +152,196 @@ val ptree_sexpnum_def = Define` `; +val ptree_WS_def = Define` + (ptree_WS (Lf _) = NONE) ∧ + (ptree_WS (Nd ntm args) = + if ntm ≠ mkNT sxnt_WS then NONE + else + case args of + [c] => return () + | _ => NONE)`; + +val ptree_grabWS_def = Define` + (ptree_grabWS (Lf _) = NONE) ∧ + (ptree_grabWS (Nd ntm args) = + if ntm ≠ mkNT sxnt_grabWS then NONE + else + case args of + [w; g] => + do + ptree_WS w; + ptree_grabWS g; + return () + od + | _ => NONE)`; + +val ptree_normstrchar_def = Define` + (ptree_normstrchar (Lf _) = NONE) ∧ + (ptree_normstrchar (Nd ntm args) = + if ntm ≠ mkNT sxnt_normstrchar then NONE + else + case args of + [Lf(TK c)] => return c + | _ => NONE)`; + +val ptree_escapablechar_def = Define` + (ptree_escapablechar (Lf _) = NONE) ∧ + (ptree_escapablechar (Nd ntm args) = + if ntm ≠ mkNT sxnt_escapablechar then NONE + else + case args of + [Lf(TK c)] => return c + | _ => NONE)`; + +val ptree_escapedstrchar_def = Define` + (ptree_escapedstrchar (Lf _) = NONE) ∧ + (ptree_escapedstrchar (Nd ntm args) = + if ntm ≠ mkNT sxnt_escapedstrchar then NONE + else + case args of + [b; c] => + if b = Lf(TK#"\\") then + ptree_escapablechar c + else NONE + | _ => NONE)`; + +val ptree_strchar_def = Define` + (ptree_strchar (Lf _) = NONE) ∧ + (ptree_strchar (Nd ntm args) = + if ntm ≠ mkNT sxnt_strchar then NONE + else + case args of + [c] => ptree_normstrchar c ++ ptree_escapedstrchar c + | _ => NONE)`; + +val ptree_strcontents_def = Define` + (ptree_strcontents (Lf _) = NONE) ∧ + (ptree_strcontents (Nd ntm args) = + if ntm ≠ mkNT sxnt_strcontents then NONE + else + case args of + [] => return "" + | [sc; ss] => + do + c <- ptree_strchar sc; + s <- ptree_strcontents ss; + return (c::s) + od + | _ => NONE)`; + +val ptree_sexpstr_def = Define` + (ptree_sexpstr (Lf _) = NONE) ∧ + (ptree_sexpstr (Nd ntm args) = + if ntm ≠ mkNT sxnt_sexpstr then NONE + else + case args of + [lq; s; rq] => + if (lq = Lf(TK#"\"") ∧ rq = Lf(TK#"\"")) then + ptree_strcontents s + else NONE + | _ => NONE)`; + +val ptree_first_symchar_def = Define` + (ptree_first_symchar (Lf _) = NONE) ∧ + (ptree_first_symchar (Nd ntm args) = + if ntm ≠ mkNT sxnt_first_symchar then NONE + else + case args of + [Lf(TK c)] => return c + | _ => NONE)`; + +val ptree_symchar_def = Define` + (ptree_symchar (Lf _) = NONE) ∧ + (ptree_symchar (Nd ntm args) = + if ntm ≠ mkNT sxnt_symchar then NONE + else + case args of + [Lf(TK c)] => return c + | _ => NONE)`; + +val ptree_symchars_def = Define` + (ptree_symchars (Lf _) = NONE) ∧ + (ptree_symchars (Nd ntm args) = + if ntm ≠ mkNT sxnt_symchars then NONE + else + case args of + [f;s] => + do + c <- ptree_symchar f; + cs <- ptree_symchars s; + return (c::cs) + od + | _ => NONE)`; + +val ptree_sexpsym_def = Define` + (ptree_sexpsym (Lf _) = NONE) ∧ + (ptree_sexpsym (Nd ntm args) = + if ntm ≠ mkNT sxnt_sexpsym then NONE + else + case args of + [f;s] => + do + c <- ptree_first_symchar f; + cs <- ptree_symchars s; + return (c::cs) + od + | _ => NONE)`; + +val ptree_sexp_def = Define` + (ptree_sexp (Lf _) = NONE) ∧ + (ptree_sexp (Nd ntm args) = + if ntm ≠ mkNT sxnt_sexp then NONE + else + case args of + [w; g] => do ptree_grabWS g; ptree_WSsexp w od + | _ => NONE) ∧ + (ptree_WSsexp (Lf _) = NONE) ∧ + (ptree_WSsexp (Nd ntm args) = + if ntm ≠ mkNT sxnt_WSsexp then NONE + else + case args of + [g; s] => do ptree_grabWS g; ptree_sexp0 s od + | _ => NONE) ∧ + (ptree_sexp0 (Lf _) = NONE) ∧ + (ptree_sexp0 (Nd ntm args) = + if ntm ≠ mkNT sxnt_sexp0 then NONE + else + case args of + [s] => + do x <- ptree_sexpsym s; return (SX_SYM x) od ++ + do x <- ptree_sexpnum s; return (SX_NUM x) od ++ + do x <- ptree_sexpstr s; return (SX_STR x) od + | [q;w] => + if q = Lf (TK#"'") then ptree_WSsexp w else NONE + | [lp; s; g; rp] => + if lp = Lf (TK#"(") ∧ rp = Lf (TK#")") then + do + ptree_grabWS g; + ptree_sexpseq s + od + else NONE + | [lp; sa; dot; sd; rp] => + if lp = Lf (TK#"(") ∧ dot = Lf (TK#".") ∧ rp = Lf (TK#")") then + do + a <- ptree_sexp sa; + d <- ptree_sexp sd; + return (SX_CONS a d) + od + else NONE + | _ => NONE) ∧ + (ptree_sexpseq (Lf _) = NONE) ∧ + (ptree_sexpseq (Nd ntm args) = + if ntm ≠ mkNT sxnt_sexpseq then NONE + else + case args of + [] => return nil + | [w; s] => + do + x <- ptree_WSsexp w; + r <- ptree_sexpseq s; + return (SX_CONS x r) + od + | _ => NONE)`; + val _ = export_theory() From d93c332bbefabe6fa948103b71c247c13c321d01 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Mon, 21 Sep 2015 10:38:25 +1000 Subject: [PATCH 484/718] improve interactive use comment for pairScript.sml --- src/pair/src/pairScript.sml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/pair/src/pairScript.sml b/src/pair/src/pairScript.sml index 54dfeaeb3a..fcc09deba1 100644 --- a/src/pair/src/pairScript.sml +++ b/src/pair/src/pairScript.sml @@ -16,7 +16,7 @@ structure pairScript = struct (* interactive use: - app load ["Q", "relationTheory", "mesonLib"]; + app load ["Q", "relationTheory", "mesonLib", "OpenTheoryMap", "BasicProvers"]; open Parse relationTheory mesonLib; *) From 191963df14c6526fdc2c2bc59005fff4c8d9a7a3 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Mon, 21 Sep 2015 10:39:27 +1000 Subject: [PATCH 485/718] add LEX_MONO to pairTheory --- src/pair/src/pairScript.sml | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/src/pair/src/pairScript.sml b/src/pair/src/pairScript.sml index fcc09deba1..5b7d43990d 100644 --- a/src/pair/src/pairScript.sml +++ b/src/pair/src/pairScript.sml @@ -596,6 +596,18 @@ val LEX_DEF_THM = Q.store_thm REWRITE_TAC [LEX_DEF,UNCURRY_DEF] THEN BETA_TAC THEN REWRITE_TAC [UNCURRY_DEF] THEN BETA_TAC THEN REFL_TAC); +val LEX_MONO = store_thm("LEX_MONO", + ``(!x y. R1 x y ==> R2 x y) /\ + (!x y. R3 x y ==> R4 x y) + ==> + (R1 LEX R3) x y ==> (R2 LEX R4) x y``, + STRIP_TAC THEN + Q.SPEC_THEN`x`FULL_STRUCT_CASES_TAC pair_CASES THEN + Q.SPEC_THEN`y`FULL_STRUCT_CASES_TAC pair_CASES THEN + SRW_TAC[][LEX_DEF_THM] THEN + PROVE_TAC[]) +val () = IndDefLib.export_mono"LEX_MONO"; + val WF_LEX = Q.store_thm("WF_LEX", `!(R:'a->'a->bool) (Q:'b->'b->bool). WF R /\ WF Q ==> WF (R LEX Q)`, REWRITE_TAC [LEX_DEF, relationTheory.WF_DEF] From 03f5ea143243907fb64e2ad25c9dcc20c7557c58 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Mon, 21 Sep 2015 10:43:57 +1000 Subject: [PATCH 486/718] add LLEX_MONO (this and 191963d related to #219) --- src/list/src/listScript.sml | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/src/list/src/listScript.sml b/src/list/src/listScript.sml index e7d007dd38..a00c08fd0b 100644 --- a/src/list/src/listScript.sml +++ b/src/list/src/listScript.sml @@ -3001,6 +3001,18 @@ val LLEX_THM = save_thm( (def' |> Q.INST [`l2` |-> `h2::t2`] |> SIMP_RULE (srw_ss()) [])) +val LLEX_MONO = store_thm("LLEX_MONO", + ``(!x y. R1 x y ==> R2 x y) + ==> + LLEX R1 x y ==> LLEX R2 x y``, + STRIP_TAC THEN + Q.ID_SPEC_TAC`y` THEN + Induct_on`x` THEN + Cases_on`y` THEN + SRW_TAC[][LLEX_THM] THEN + PROVE_TAC[]) +val () = IndDefLib.export_mono"LLEX_MONO"; + val LLEX_NIL2 = store_thm( "LLEX_NIL2[simp]", ``~LLEX R l []``, From b644139bad86025d6b99ff1614b6da31b44bcd68 Mon Sep 17 00:00:00 2001 From: Konrad Slind Date: Sun, 20 Sep 2015 19:54:19 -0500 Subject: [PATCH 487/718] cong for lex --- src/pair/src/pairScript.sml | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/src/pair/src/pairScript.sml b/src/pair/src/pairScript.sml index 5b7d43990d..ea31b0067d 100644 --- a/src/pair/src/pairScript.sml +++ b/src/pair/src/pairScript.sml @@ -692,6 +692,20 @@ val symmetric_LEX = store_thm( METIS_TAC[]); val _ = export_rewrites ["symmetric_LEX"] +val LEX_CONG = Q.store_thm +("LEX_CONG", + `!R1 R2 v1 v2 R1' R2' v1' v2'. + (v1 = v1') /\ (v2 = v2') /\ + (!a b c d. (v1' = (a,b)) /\ (v2' = (c,d)) ==> (R1 a c = R1' a c)) /\ + (!a b c d. (v1' = (a,b)) /\ (v2' = (c,d)) /\ (a=c) ==> (R2 b d = R2' b d)) + ==> + ($LEX R1 R2 v1 v2 = $LEX R1' R2' v1' v2')`, + Ho_Rewrite.REWRITE_TAC [LEX_DEF,FORALL_PROD,PAIR_EQ] + THEN NTAC 2 (REWRITE_TAC [UNCURRY_VAR,FST,SND] THEN BETA_TAC) + THEN METIS_TAC[]); + +val _ = DefnBase.export_cong "LEX_CONG"; + (*--------------------------------------------------------------------------- Generate some ML that gets evaluated at theory load time. It adds relevant rewrites into the global compset. From 55f466ed130bf57f6beaea1213a778f04fdf2fe2 Mon Sep 17 00:00:00 2001 From: Konrad Slind Date: Sun, 20 Sep 2015 20:15:35 -0500 Subject: [PATCH 488/718] cong for llex (closes #219) --- src/list/src/listScript.sml | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/src/list/src/listScript.sml b/src/list/src/listScript.sml index a00c08fd0b..1770267d71 100644 --- a/src/list/src/listScript.sml +++ b/src/list/src/listScript.sml @@ -3013,6 +3013,22 @@ val LLEX_MONO = store_thm("LLEX_MONO", PROVE_TAC[]) val () = IndDefLib.export_mono"LLEX_MONO"; +val LLEX_CONG = store_thm +("LLEX_CONG", + ``!R l1 l2 R' l1' l2'. + (l1 = l1') /\ (l2 = l2') /\ + (!a b. MEM a l1' /\ MEM b l2' ==> (R a b = R' a b)) + ==> + (LLEX R l1 l2 = LLEX R' l1' l2')``, + GEN_TAC THEN Induct + THENL [ALL_TAC, GEN_TAC] + THEN Induct + THEN SRW_TAC [] [] + THEN SRW_TAC [] [LLEX_THM] + THEN METIS_TAC[MEM]); + +val _ = DefnBase.export_cong "LEX_CONG"; + val LLEX_NIL2 = store_thm( "LLEX_NIL2[simp]", ``~LLEX R l []``, From 75775e50411132378518948569f28ead71ca17cb Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Mon, 21 Sep 2015 11:19:05 +1000 Subject: [PATCH 489/718] LLEX_CONG not LEX_CONG, also delete some trailing whitespace --- src/list/src/listScript.sml | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/list/src/listScript.sml b/src/list/src/listScript.sml index 1770267d71..c0eb649fe2 100644 --- a/src/list/src/listScript.sml +++ b/src/list/src/listScript.sml @@ -3020,14 +3020,14 @@ val LLEX_CONG = store_thm (!a b. MEM a l1' /\ MEM b l2' ==> (R a b = R' a b)) ==> (LLEX R l1 l2 = LLEX R' l1' l2')``, - GEN_TAC THEN Induct - THENL [ALL_TAC, GEN_TAC] - THEN Induct + GEN_TAC THEN Induct + THENL [ALL_TAC, GEN_TAC] + THEN Induct THEN SRW_TAC [] [] THEN SRW_TAC [] [LLEX_THM] THEN METIS_TAC[MEM]); -val _ = DefnBase.export_cong "LEX_CONG"; +val _ = DefnBase.export_cong "LLEX_CONG"; val LLEX_NIL2 = store_thm( "LLEX_NIL2[simp]", From e8d6a4c98b22497d892d0ef0e56651ba0b1c1a2a Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Mon, 21 Sep 2015 11:21:09 +1000 Subject: [PATCH 490/718] delete redundant theorem thanks to Jeremy Dawson and Konrad Slind for pointing this out --- src/sort/sortingScript.sml | 10 ---------- 1 file changed, 10 deletions(-) diff --git a/src/sort/sortingScript.sml b/src/sort/sortingScript.sml index 8a4beeb4ca..8b7884502b 100644 --- a/src/sort/sortingScript.sml +++ b/src/sort/sortingScript.sml @@ -923,16 +923,6 @@ val SORTED_APPEND_IFF = Q.store_thm ("SORTED_APPEND_IFF", SIMP_TAC bool_ss [CONJ_COMM], SIMP_TAC bool_ss [CONJ_ASSOC] ] ) ; -(* note, assumption transitive R not needed, see SORTED_APPEND_IFF *) -val SORTED_transitive_APPEND_IFF = store_thm( -"SORTED_transitive_APPEND_IFF", -``!R. transitive R ==> - !L1 L2. SORTED R (L1 ++ L2) = - SORTED R L1 /\ SORTED R L2 /\ - ((L1 = []) \/ (L2 = []) \/ (R (LAST L1) (HD L2)))``, - GEN_TAC >> DISCH_TAC >> MATCH_ACCEPT_TAC SORTED_APPEND_IFF ) ; - - val MEM_PERM = store_thm( "MEM_PERM", From c4138809c11f503d6ddae36546648346a59f9922 Mon Sep 17 00:00:00 2001 From: Konrad Slind Date: Sun, 20 Sep 2015 20:32:06 -0500 Subject: [PATCH 491/718] multiset order specialized to worklist algorithms --- src/bag/containerScript.sml | 53 +++++++++++++++++++++++++++---- src/num/termination/TotalDefn.sml | 1 + 2 files changed, 48 insertions(+), 6 deletions(-) diff --git a/src/bag/containerScript.sml b/src/bag/containerScript.sml index fb7c596ae1..ada1bb698c 100644 --- a/src/bag/containerScript.sml +++ b/src/bag/containerScript.sml @@ -112,8 +112,6 @@ val MEM_BAG_TO_LIST = Q.store_thm val _ = export_rewrites ["MEM_BAG_TO_LIST"]; - - val FINITE_LIST_TO_BAG = Q.store_thm( "FINITE_LIST_TO_BAG", `FINITE_BAG (LIST_TO_BAG ls)`, @@ -217,6 +215,53 @@ local open rich_listTheory arithmeticTheory in Cases_on `h = e` THEN SRW_TAC [][LIST_ELEM_COUNT_THM,BAG_INSERT,ADD1]); end +(*---------------------------------------------------------------------------*) +(* Following packaging of multiset order applied to lists is easier to use *) +(* in some termination proofs, typically those of worklist algorithms, where *) +(* the head of the list is replaced by a list of smaller elements. *) +(*---------------------------------------------------------------------------*) + +val mlt_list_def = + Define + `mlt_list R = + \l1 l2. + ?h t list. + (l1 = list ++ t) /\ + (l2 = h::t) /\ + (!e. MEM e list ==> R e h)`; + +val WF_mlt_list = Q.store_thm +("WF_mlt_list", + `!R. WF(R) ==> WF (mlt_list R)`, + REPEAT STRIP_TAC THEN MATCH_MP_TAC relationTheory.WF_SUBSET THEN + Q.EXISTS_TAC `inv_image (mlt1 R) LIST_TO_BAG` THEN + CONJ_TAC THENL + [METIS_TAC [relationTheory.WF_inv_image,bagTheory.WF_mlt1], + RW_TAC list_ss [mlt_list_def, relationTheory.inv_image_thm,bagTheory.mlt1_def] + THENL + [METIS_TAC [FINITE_LIST_TO_BAG], + METIS_TAC [FINITE_LIST_TO_BAG], + MAP_EVERY Q.EXISTS_TAC [`h`, `LIST_TO_BAG list`, `LIST_TO_BAG t`] + THEN RW_TAC std_ss [BAG_INSERT_UNION,LIST_TO_BAG_APPEND,LIST_TO_BAG_def] + THENL [METIS_TAC [COMM_BAG_UNION,ASSOC_BAG_UNION,BAG_UNION_EMPTY], + METIS_TAC [IN_LIST_TO_BAG]]]]); + + +(*---------------------------------------------------------------------------*) +(* Tell the termination proof infrastructure about mlt_list *) +(*---------------------------------------------------------------------------*) + +val _ = adjoin_to_theory +{sig_ps = NONE, + struct_ps = SOME + (fn ppstrm => let + val S = (fn s => (PP.add_string ppstrm s; PP.add_newline ppstrm)) + in + S "val _ = TotalDefn.WF_thms := (!TotalDefn.WF_thms @ [WF_mlt_list]);"; + S "val _ = TotalDefn.termination_simps := (!TotalDefn.termination_simps @ [mlt_list_def]);" + end)}; + + (*--------------------------------------------------------------------------- finite maps and bags. ---------------------------------------------------------------------------*) @@ -275,8 +320,6 @@ Cases_on `x = f k v` THENL [ ) ]); - - val BAG_IN_BAG_OF_FMAP = store_thm ("BAG_IN_BAG_OF_FMAP", ``!x f b. BAG_IN x (BAG_OF_FMAP f b) = ?k. k IN FDOM b /\ (x = f k (b ' k))``, @@ -297,8 +340,6 @@ REPEAT GEN_TAC THEN ASM_SIMP_TAC std_ss [CARD_EQ_0] THEN SIMP_TAC std_ss [EXTENSION, NOT_IN_EMPTY, IN_ABS]); - - val FINITE_BAG_OF_FMAP = store_thm ("FINITE_BAG_OF_FMAP", ``!f b. FINITE_BAG (BAG_OF_FMAP f b)``, GEN_TAC THEN HO_MATCH_MP_TAC fmap_INDUCT THEN diff --git a/src/num/termination/TotalDefn.sml b/src/num/termination/TotalDefn.sml index b2c410fa67..38f0292bdd 100644 --- a/src/num/termination/TotalDefn.sml +++ b/src/num/termination/TotalDefn.sml @@ -152,6 +152,7 @@ val termination_simps = prim_recTheory.measure_def, relationTheory.inv_image_def, pairTheory.LEX_DEF, + pairTheory.RPROD_DEF, SUB_LESS_I,DIV_LESS_I,MOD_LESS_I]; (*---------------------------------------------------------------------------*) From 98c7fd9eee14b207d32dcae29812f7fb714afeaa Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Mon, 21 Sep 2015 11:39:15 +1000 Subject: [PATCH 492/718] update mergesortTheory after redundant theorem removed --- src/sort/mergesortScript.sml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/sort/mergesortScript.sml b/src/sort/mergesortScript.sml index 1ae7a4d504..8eb7cc78d0 100644 --- a/src/sort/mergesortScript.sml +++ b/src/sort/mergesortScript.sml @@ -440,7 +440,7 @@ val merge_tail_correct2 = Q.store_thm ("merge_tail_correct2", rw [merge_tail_def, merge_def, REV_REVERSE_LEM, merge_empty] >> fs [] >> `SORTED R (REVERSE l1) /\ SORTED R (REVERSE l2)` - by metis_tac [SORTED_transitive_APPEND_IFF] >> + by metis_tac [SORTED_APPEND_IFF] >> fs [] >- (match_mp_tac (GSYM merge_last_lem1) >> rw [] >> From 051995440c2b44b8c5604c3b1a4d2ab7b93bea8d Mon Sep 17 00:00:00 2001 From: Konrad Slind Date: Sun, 20 Sep 2015 20:58:46 -0500 Subject: [PATCH 493/718] playground for formal language theory developments. --- .../formal-languages/FormalLangScript.sml | 415 ++++++++++++++++++ .../context-free}/Holmakefile | 0 .../context-free}/NTpropertiesScript.sml | 0 .../context-free}/grammarLib.sig | 0 .../context-free}/grammarLib.sml | 0 .../context-free}/grammarScript.sml | 0 .../context-free}/pegLib.sig | 0 .../context-free}/pegLib.sml | 0 .../context-free}/pegML.sml | 0 .../context-free}/pegSampleScript.sml | 0 .../context-free}/pegScript.sml | 0 .../context-free}/pegexecScript.sml | 0 .../context-free}/precparserScript.sml | 0 .../context-free}/selftest.sml | 0 .../context-free}/simpleSexpPEGScript.sml | 0 .../context-free}/simpleSexpScript.sml | 0 16 files changed, 415 insertions(+) create mode 100644 examples/formal-languages/FormalLangScript.sml rename examples/{parsing => formal-languages/context-free}/Holmakefile (100%) rename examples/{parsing => formal-languages/context-free}/NTpropertiesScript.sml (100%) rename examples/{parsing => formal-languages/context-free}/grammarLib.sig (100%) rename examples/{parsing => formal-languages/context-free}/grammarLib.sml (100%) rename examples/{parsing => formal-languages/context-free}/grammarScript.sml (100%) rename examples/{parsing => formal-languages/context-free}/pegLib.sig (100%) rename examples/{parsing => formal-languages/context-free}/pegLib.sml (100%) rename examples/{parsing => formal-languages/context-free}/pegML.sml (100%) rename examples/{parsing => formal-languages/context-free}/pegSampleScript.sml (100%) rename examples/{parsing => formal-languages/context-free}/pegScript.sml (100%) rename examples/{parsing => formal-languages/context-free}/pegexecScript.sml (100%) rename examples/{parsing => formal-languages/context-free}/precparserScript.sml (100%) rename examples/{parsing => formal-languages/context-free}/selftest.sml (100%) rename examples/{parsing => formal-languages/context-free}/simpleSexpPEGScript.sml (100%) rename examples/{parsing => formal-languages/context-free}/simpleSexpScript.sml (100%) diff --git a/examples/formal-languages/FormalLangScript.sml b/examples/formal-languages/FormalLangScript.sml new file mode 100644 index 0000000000..abbb88e046 --- /dev/null +++ b/examples/formal-languages/FormalLangScript.sml @@ -0,0 +1,415 @@ +(*****************************************************************************) +(* Formal Language Theory *) +(* *) +(* A formal language is a set of strings over an alphabet. The notion of *) +(* 'a list exactly captures such strings. We define the following language *) +(* operations: concatenation, iterated concatenation, and Kleene Star. We *) +(* prove a collection of lemmas about these operations, including Arden's *) +(* lemma. *) +(*****************************************************************************) + + +(*===========================================================================*) +(* Load and open context theories and proof support (lists and sets). *) +(*===========================================================================*) + +open HolKernel boolLib bossLib Parse; +open pred_setLib pred_setTheory arithmeticTheory listTheory; + +val _ = new_theory "FormalLang"; + +(*---------------------------------------------------------------------------*) +(* Basic simplification support *) +(*---------------------------------------------------------------------------*) + +val APPEND_EQNS = LIST_CONJ [APPEND,APPEND_NIL,APPEND_eq_NIL]; + +val basic_ss = list_ss ++ PRED_SET_ss ++ rewrites [APPEND_EQNS]; + + +(*---------------------------------------------------------------------------*) +(* A language is a set of strings over an alphabet. A string is represented *) +(* by an 'a list. *) +(*---------------------------------------------------------------------------*) + +val _ = type_abbrev ("lang", ``:'a list set``); + +(*---------------------------------------------------------------------------*) +(* Binary language concatenation. Right infix *) +(*---------------------------------------------------------------------------*) + +val dot_def = + Define + `$dot A B = {x ++ y | x IN A /\ y IN B}`; + +val _ = set_fixity "dot" (Infixr 675); + +(*---------------------------------------------------------------------------*) +(* Some lemmas about language concatenation. *) +(*---------------------------------------------------------------------------*) + +val IN_dot = Q.store_thm +("IN_dot", +`!w A B. w IN (A dot B) = ?u v. (w = u ++ v) /\ u IN A /\ v IN B`, + RW_TAC basic_ss [dot_def]); + +val DOT_EMPTYSET = Q.store_thm +("DOT_EMPTYSET", +`!A. (A dot {} = {}) /\ ({} dot A = {})`, + RW_TAC basic_ss [dot_def,EXTENSION]); + +val DOT_EMPTYSTRING = Q.store_thm +("DOT_EMPTYSTRING", +`!A. (A dot {[]} = A) /\ ({[]} dot A = A)`, + RW_TAC basic_ss [dot_def,EXTENSION]); + +val STRCAT_IN_dot = Q.store_thm +("STRCAT_IN_dot", +`!a b A B. a IN A /\ b IN B ==> (a ++ b) IN (A dot B)`, + METIS_TAC[IN_dot]); + +val EMPTY_IN_DOT = Q.store_thm +("EMPTY_IN_DOT", +`!A B. [] IN (A dot B) = [] IN A /\ [] IN B`, + METIS_TAC [IN_dot,APPEND_EQNS]); + +val DOT_ASSOC = Q.store_thm +("DOT_ASSOC", +`!A B C. A dot (B dot C) = (A dot B) dot C`, + RW_TAC basic_ss [EXTENSION,IN_dot] THEN METIS_TAC [APPEND_ASSOC]); + +val DOT_UNION_LDISTRIB = Q.store_thm +("DOT_UNION_LDISTRIB", +`!A B C. A dot (B UNION C) = (A dot B) UNION (A dot C)`, + RW_TAC basic_ss [EXTENSION,IN_dot] THEN METIS_TAC []); + +val DOT_UNION_RDISTRIB = Q.store_thm +("DOT_UNION_RDISTRIB", +`!A B C. (A UNION B) dot C = (A dot C) UNION (B dot C)`, + RW_TAC basic_ss [EXTENSION,IN_dot] THEN METIS_TAC []); + +val DOT_MONO = Q.store_thm +("DOT_MONO", +`!A B C D. A SUBSET C /\ B SUBSET D ==> (A dot B) SUBSET (C dot D)`, + RW_TAC basic_ss [SUBSET_DEF,IN_dot] THEN METIS_TAC []); + +(*---------------------------------------------------------------------------*) +(* Iterated language concatenation. *) +(*---------------------------------------------------------------------------*) + +val DOTn_def = + Define + `(DOTn A 0 = {[]}) /\ + (DOTn A (SUC n) = A dot (DOTn A n))`; + +val DOTn_RIGHT = Q.store_thm +("DOTn_RIGHT", +`!n A. A dot DOTn A n = DOTn A n dot A`, + Induct THEN RW_TAC basic_ss [DOTn_def] THENL + [RW_TAC basic_ss [EXTENSION,IN_dot], + METIS_TAC [DOT_ASSOC]]); + +val SUBSET_DOTn = Q.store_thm +("SUBSET_DOTn", +`!A. A SUBSET DOTn A (SUC 0)`, + RW_TAC basic_ss [SUBSET_DEF,DOTn_def,IN_dot]); + +val EMPTY_IN_DOTn_ZERO = Q.store_thm +("EMPTY_IN_DOTn_ZERO", +`!x A. x IN DOTn A 0 = (x = [])`, + RW_TAC basic_ss [DOTn_def]); + +val STRCAT_IN_DOTn_SUC = Q.store_thm +("STRCAT_IN_DOTn_SUC", + `!a b A n. (a IN A /\ b IN DOTn A n) \/ (a IN DOTn A n /\ b IN A) + ==> (a ++ b) IN DOTn A (SUC n)`, + RW_TAC basic_ss [DOTn_def] THEN METIS_TAC [STRCAT_IN_dot,DOTn_RIGHT]); + +val STRCAT_IN_DOTn_ADD = Q.store_thm +("STRCAT_IN_DOTn_ADD", +`!m n a b A. + a IN DOTn A m /\ b IN DOTn A n ==> (a ++ b) IN DOTn A (m + n)`, + Induct THEN RW_TAC basic_ss [DOTn_def] THEN + FULL_SIMP_TAC basic_ss [IN_dot] THEN + `(v ++ b) IN DOTn A (m + n)` by METIS_TAC [] THEN + METIS_TAC [STRCAT_IN_DOTn_SUC,APPEND_ASSOC,DECIDE``SUC(m+n) = n + SUC m``]); + +val DOTn_EMPTYSET = Q.store_thm +("DOTn_EMPTYSET", +`!n. DOTn {} n = if n=0 then {[]} else {}`, + Induct THEN RW_TAC basic_ss [DOTn_def,DOT_EMPTYSET]); + +val DOTn_EMPTYSTRING = Q.store_thm +("DOTn_EMPTYSTRING", +`!n. DOTn {[]} n = {[]}`, + Induct THEN RW_TAC basic_ss [DOTn_def,dot_def,EXTENSION] THEN + METIS_TAC[APPEND_EQNS]); + +val EMPTY_IN_DOTn = Q.store_thm +("EMPTY_IN_DOTn", +`!n. ([] IN DOTn A n) <=> (n=0) \/ ([] IN A)`, + Induct THEN RW_TAC basic_ss [DOTn_def,EMPTY_IN_DOT] THEN METIS_TAC[]); + +val DOTn_UNION = Q.store_thm +("DOTn_UNION", +`!n x A B. x IN DOTn A n ==> x IN DOTn (A UNION B) n`, + Induct THEN RW_TAC basic_ss [DOTn_def,IN_dot] THEN METIS_TAC[]); + +val DOTn_DIFF = Q.store_thm +("DOTn_DIFF", +`!n x A B. x IN DOTn (A DIFF B) n ==> x IN DOTn A n`, + Induct THEN RW_TAC basic_ss [DOTn_def,IN_dot] THEN METIS_TAC[]); + +(*---------------------------------------------------------------------------*) +(* This lemma can be extended so that k is as large or small as possible. It *) +(* says that a word in A^n is either empty or can be split into k non-empty *) +(* pieces. *) +(*---------------------------------------------------------------------------*) + +val DOTn_EMPTYSTRING_FREE = Q.store_thm +("DOTn_EMPTYSTRING_FREE", +`!n A w. w IN DOTn A n ==> + (w = []) \/ + ?k. w IN DOTn (A DELETE []) k`, + Induct THEN RW_TAC basic_ss [DOTn_def,IN_dot] THEN + RES_TAC THEN Cases_on `u` THEN RW_TAC basic_ss [] THEN + `h::t IN (A DELETE [])` by RW_TAC basic_ss [] THENL + [METIS_TAC [SUBSET_DOTn,SUBSET_DEF], + METIS_TAC [STRCAT_IN_DOTn_SUC,APPEND_EQNS]]); + +(*---------------------------------------------------------------------------*) +(* Kleene star *) +(*---------------------------------------------------------------------------*) + +val KSTAR_def = + Define + `KSTAR(L:'a lang) = BIGUNION {DOTn L n | n IN UNIV}`; + +val IN_KSTAR = Q.store_thm +("IN_KSTAR", + `x IN KSTAR(L) = ?n. x IN DOTn L n`, + RW_TAC basic_ss [KSTAR_def,BIGUNION] THEN + RW_TAC basic_ss [SPECIFICATION] THEN + METIS_TAC[]); + +val KSTAR_EMPTYSET = Q.store_thm +("KSTAR_EMPTYSET", +`KSTAR {} = {[]}`, + RW_TAC basic_ss [EXTENSION,IN_KSTAR,DOTn_EMPTYSET] THEN + EQ_TAC THEN RW_TAC basic_ss [] THENL + [Cases_on `n` THEN FULL_SIMP_TAC basic_ss [], + METIS_TAC [IN_INSERT]]); + +val EMPTY_IN_KSTAR = Q.store_thm +("EMPTY_IN_KSTAR", +`!A. [] IN (KSTAR A)`, + RW_TAC basic_ss [IN_KSTAR] THEN METIS_TAC [DOTn_def,IN_INSERT]); + +val KSTAR_SING = Q.store_thm +("KSTAR_SING", +`!x. x IN (KSTAR {x})`, + RW_TAC basic_ss [IN_KSTAR] THEN + Q.EXISTS_TAC `SUC 0` THEN + RW_TAC basic_ss [DOTn_def,IN_dot]); + +val SUBSET_KSTAR = Q.store_thm +("SUBSET_KSTAR", +`!A. A SUBSET KSTAR(A)`, + RW_TAC basic_ss [SUBSET_DEF,IN_KSTAR] THEN + Q.EXISTS_TAC `SUC 0` THEN + RW_TAC basic_ss [DOTn_def,IN_dot]); + +val SUBSET_KSTAR_DOT = Q.store_thm +("SUBSET_KSTAR_DOT", +`!A B. B SUBSET (KSTAR A) dot B`, + RW_TAC basic_ss [SUBSET_DEF,IN_KSTAR,IN_dot] THEN + MAP_EVERY Q.EXISTS_TAC [`[]`,`x`] THEN + RW_TAC basic_ss [] THEN METIS_TAC [DOTn_def,IN_INSERT]); + +val STRCAT_IN_KSTAR = Q.store_thm +("STRCAT_IN_KSTAR", +`!u v A B. + u IN A /\ v IN KSTAR(A) dot B ==> (u ++ v) IN KSTAR(A) dot B`, + RW_TAC list_ss [IN_KSTAR,IN_dot] THEN + MAP_EVERY Q.EXISTS_TAC [`u++u'`,`v'`] THEN + RW_TAC list_ss [APPEND_ASSOC] THEN + Q.EXISTS_TAC `SUC n` THEN RW_TAC std_ss [DOTn_def] THEN + METIS_TAC [STRCAT_IN_dot]); + +val KSTAR_EQ_INTRO = Q.store_thm +("KSTAR_EQ_INTRO", +`!A B. (!n. DOTn A n = DOTn B n) ==> (KSTAR A = KSTAR B)`, + RW_TAC basic_ss [EXTENSION,IN_KSTAR]); + +val IN_KSTAR_LIST = Q.store_thm +("IN_KSTAR_LIST", + `!s A. s IN KSTAR A <=> ?wlist. EVERY (\w. w IN A) wlist /\ (s = FLAT wlist)`, + RW_TAC list_ss [IN_KSTAR,EQ_IMP_THM] THENL + [POP_ASSUM MP_TAC THEN Q.ID_SPEC_TAC `s` + THEN Induct_on `n` THEN RW_TAC list_ss [] + THENL + [FULL_SIMP_TAC list_ss [EMPTY_IN_DOTn_ZERO] THEN RW_TAC list_ss [] + THEN Q.EXISTS_TAC `[]` THEN RW_TAC list_ss [], + FULL_SIMP_TAC list_ss [DOTn_def,IN_dot] + THEN RW_TAC list_ss [] THEN RES_TAC + THEN Q.EXISTS_TAC `u::wlist` THEN RW_TAC list_ss []], + Induct_on `wlist` THEN FULL_SIMP_TAC list_ss [] + THENL [METIS_TAC [EMPTY_IN_DOTn], + RW_TAC list_ss [] THEN RES_TAC + THEN Q.EXISTS_TAC `SUC n` + THEN RW_TAC list_ss [DOTn_def] THEN METIS_TAC[IN_dot]]]); + +(*---------------------------------------------------------------------------*) +(* Some more complex equalities *) +(*---------------------------------------------------------------------------*) + +val lang_ss = basic_ss ++ + rewrites [IN_KSTAR, IN_dot, DOTn_def, + DOT_EMPTYSET,DOT_EMPTYSTRING, DOTn_EMPTYSTRING, + KSTAR_SING,KSTAR_EMPTYSET,EMPTY_IN_KSTAR]; + +val KSTAR_EQ_EPSILON_UNION_DOT = Q.store_thm +("KSTAR_EQ_EPSILON_UNION_DOT", +`!A. KSTAR A = {[]} UNION (A dot KSTAR A)`, + RW_TAC lang_ss [EXTENSION,EQ_IMP_THM] THENL + [Cases_on `n` + THENL [METIS_TAC[EMPTY_IN_DOTn_ZERO], + FULL_SIMP_TAC lang_ss [] THEN METIS_TAC[]], + METIS_TAC [EMPTY_IN_DOTn_ZERO], + METIS_TAC [STRCAT_IN_DOTn_SUC]]); + +val IN_KSTAR_THM = Q.store_thm("IN_KSTAR_THM", +`!w L. w IN KSTAR L = (w = []) \/ ?w1 w2. (w = w1++w2) /\ w1 IN L /\ w2 IN KSTAR L`, + RW_TAC list_ss [Once KSTAR_EQ_EPSILON_UNION_DOT,IN_UNION, IN_SING,IN_dot]); + +val KSTAR_EQ_KSTAR_UNION = Q.store_thm +("KSTAR_EQ_KSTAR_UNION", +`!A. KSTAR A = KSTAR ({[]} UNION A)`, + RW_TAC lang_ss [EXTENSION,EQ_IMP_THM] THENL + [METIS_TAC [DOTn_UNION,UNION_COMM], + POP_ASSUM MP_TAC THEN Q.ID_SPEC_TAC `x` THEN + Induct_on `n` THEN RW_TAC lang_ss [] THENL + [METIS_TAC [EMPTY_IN_DOTn_ZERO], + METIS_TAC [APPEND_EQNS], + METIS_TAC [STRCAT_IN_DOTn_SUC,APPEND_EQNS]]]); + +val KSTAR_DOT_KSTAR = Q.store_thm +("KSTAR_DOT_KSTAR", +`!A. (KSTAR A dot KSTAR A) = KSTAR A`, + RW_TAC lang_ss [EXTENSION,EQ_IMP_THM] THENL + [METIS_TAC [STRCAT_IN_DOTn_ADD], + Cases_on `n` THEN FULL_SIMP_TAC lang_ss[] THENL + [METIS_TAC [APPEND_eq_NIL,EMPTY_IN_DOTn_ZERO], + METIS_TAC [SUBSET_DOTn,SUBSET_DEF]]]); + +val KSTAR_KSTAR_EQ_KSTAR = Q.store_thm +("KSTAR_KSTAR_EQ_KSTAR", +`!A. KSTAR(KSTAR A) = KSTAR A`, + RW_TAC lang_ss [EXTENSION,EQ_IMP_THM] THENL + [POP_ASSUM MP_TAC THEN Q.ID_SPEC_TAC `x` THEN + Induct_on `n` THEN RW_TAC lang_ss [] THEN + METIS_TAC [EMPTY_IN_DOTn_ZERO,STRCAT_IN_DOTn_ADD], + METIS_TAC [SUBSET_KSTAR,IN_KSTAR,SUBSET_DEF]]); + +val DOT_KSTAR_EQ_KSTAR_DOT = Q.store_thm +("DOT_KSTAR_EQ_KSTAR_DOT", +`!A. (A dot KSTAR A) = (KSTAR A dot A)`, + RW_TAC lang_ss [EXTENSION,EQ_IMP_THM] THENL + [`(u++v) IN (DOTn A n dot A)` by METIS_TAC [DOTn_RIGHT,EXTENSION,IN_dot], + `(u++v) IN (A dot DOTn A n)` by METIS_TAC [DOTn_RIGHT,EXTENSION,IN_dot]] + THEN METIS_TAC [IN_dot]); + +val lemma = Q.prove +(`(!n. DOTn (A dot B) n dot A = A dot DOTn (B dot A) n) + ==> (KSTAR (A dot B) dot A = A dot KSTAR(B dot A))`, + RW_TAC lang_ss [EXTENSION] THEN METIS_TAC[]); + +val KSTAR_DOT_SHIFT = Q.store_thm +("KSTAR_DOT_SHIFT", +`!A. KSTAR (A dot B) dot A = A dot KSTAR(B dot A)`, + GEN_TAC THEN MATCH_MP_TAC lemma THEN + Induct THEN RW_TAC lang_ss [] THEN METIS_TAC [DOT_ASSOC]); + +val DOT_SQUARED_SUBSET = Q.store_thm +("DOT_SQUARED_SUBSET", +`!L. (L dot L) SUBSET L ==> (L dot KSTAR L) SUBSET L`, + RW_TAC lang_ss [SUBSET_DEF,GSYM LEFT_FORALL_IMP_THM] THEN + NTAC 2 (POP_ASSUM MP_TAC) THEN MAP_EVERY Q.ID_SPEC_TAC [`v`, `u`] THEN + Induct_on `n` THEN RW_TAC lang_ss [] THEN + METIS_TAC [DOT_ASSOC]); + +val KSTAR_UNION = Q.store_thm +("KSTAR_UNION", +`!A B. KSTAR (A UNION B) = KSTAR(KSTAR A dot B) dot KSTAR A`, + RW_TAC lang_ss [EXTENSION,EQ_IMP_THM] THENL + [POP_ASSUM MP_TAC THEN Q.ID_SPEC_TAC `x` THEN Induct_on `n` THENL + [METIS_TAC [EMPTY_IN_DOTn_ZERO,APPEND_EQNS], + SIMP_TAC basic_ss [DOTn_def,DOTn_RIGHT] THEN RW_TAC lang_ss [] THENL + [`?u1 u2. (u = u1 ++ u2) /\ (?m. u1 IN DOTn (KSTAR A dot B) m) /\ + ?k. u2 IN DOTn A k` by METIS_TAC[] THEN + METIS_TAC [APPEND_ASSOC,STRCAT_IN_DOTn_SUC], + `?u1 u2. (u = u1 ++ u2) /\ (?m. u1 IN DOTn (KSTAR A dot B) m) /\ + ?k. u2 IN DOTn A k` by METIS_TAC[] THEN + Q.EXISTS_TAC `u1 ++ (u2 ++ v)` THEN Q.EXISTS_TAC `[]` THEN + RW_TAC lang_ss [APPEND_ASSOC] THENL + [`u2 ++ v IN (KSTAR A dot B)` by (RW_TAC lang_ss [] THEN METIS_TAC[]) + THEN METIS_TAC [APPEND_ASSOC,STRCAT_IN_DOTn_SUC], + METIS_TAC [EMPTY_IN_DOTn_ZERO]]]] + , + REPEAT (POP_ASSUM MP_TAC) THEN MAP_EVERY Q.ID_SPEC_TAC [`v`, `u`, `n`] + THEN Induct_on `n'` THEN RW_TAC lang_ss [] THENL + [POP_ASSUM MP_TAC THEN Q.ID_SPEC_TAC `u` THEN + Induct_on`n` THEN RW_TAC lang_ss [] THENL + [METIS_TAC [EMPTY_IN_DOTn_ZERO], + METIS_TAC [IN_UNION,APPEND_ASSOC,STRCAT_IN_DOTn_ADD, + STRCAT_IN_DOTn_SUC,DOTn_UNION]], + `u' ++ v' IN DOTn A n' dot A` by METIS_TAC [IN_dot,DOTn_RIGHT] THEN + FULL_SIMP_TAC lang_ss [] THEN + METIS_TAC [IN_UNION,APPEND_ASSOC,STRCAT_IN_DOTn_ADD, + STRCAT_IN_DOTn_SUC,DOTn_UNION]]]); + +(*===========================================================================*) +(* Arden's Lemma. *) +(*===========================================================================*) + +val LENGTH_LESS = Q.store_thm +("LENGTH_LESS", +`!u x v. (x = u++v) /\ ~(u = []) ==> LENGTH v < LENGTH x`, + Cases_on `u` THEN RW_TAC list_ss []); + +val lemma = Q.prove +(`!A B X. (!n. (DOTn A n dot B) SUBSET X) ==> KSTAR(A) dot B SUBSET X`, + RW_TAC basic_ss [SUBSET_DEF,IN_KSTAR,IN_dot] THEN METIS_TAC []); + +(*---------------------------------------------------------------------------*) +(* Although Arden's Lemma doesn't directly mention machines, it can be used *) +(* to map DFAs to equivalent regular languages. *) +(*---------------------------------------------------------------------------*) + +val ARDENS_LEMMA = Q.store_thm +("ARDENS_LEMMA", + `!A B X:'a lang. + ~([] IN A) /\ (X = (A dot X) UNION B) ==> (X = KSTAR(A) dot B)`, + REPEAT STRIP_TAC THEN RW_TAC basic_ss [SET_EQ_SUBSET] THENL + [REWRITE_TAC [SUBSET_DEF] THEN GEN_TAC THEN + measureInduct_on `LENGTH x` THEN + Cases_on `LENGTH x` THENL + [FULL_SIMP_TAC basic_ss [LENGTH_NIL,EMPTY_IN_DOT] THEN RW_TAC std_ss [] + THENL [METIS_TAC [EMPTY_IN_KSTAR],METIS_TAC [EMPTY_IN_DOT,IN_UNION]], + STRIP_TAC THEN + `x IN A dot X \/ x IN B` by METIS_TAC [IN_UNION] THENL + [`?u v. (x = u ++ v) /\ u IN A /\ v IN X` by METIS_TAC [IN_dot] THEN + `~(u = [])` by METIS_TAC [] THEN + `LENGTH v < LENGTH x` by METIS_TAC [LENGTH_LESS] THEN + `v IN KSTAR A dot B` by METIS_TAC [] THEN METIS_TAC [STRCAT_IN_KSTAR] + , + METIS_TAC [SUBSET_DEF,SUBSET_KSTAR_DOT]]] + , + MATCH_MP_TAC lemma THEN Induct THENL + [RW_TAC basic_ss [DOTn_def,SUBSET_DEF,dot_def] THEN METIS_TAC [IN_UNION], + `A dot (DOTn A n dot B) SUBSET (A dot X)` + by METIS_TAC [DOT_MONO,SUBSET_REFL] THEN + SIMP_TAC std_ss [DOTn_def,GSYM DOT_ASSOC] THEN + METIS_TAC [IN_UNION,SUBSET_DEF]]]); + +val _ = export_theory(); diff --git a/examples/parsing/Holmakefile b/examples/formal-languages/context-free/Holmakefile similarity index 100% rename from examples/parsing/Holmakefile rename to examples/formal-languages/context-free/Holmakefile diff --git a/examples/parsing/NTpropertiesScript.sml b/examples/formal-languages/context-free/NTpropertiesScript.sml similarity index 100% rename from examples/parsing/NTpropertiesScript.sml rename to examples/formal-languages/context-free/NTpropertiesScript.sml diff --git a/examples/parsing/grammarLib.sig b/examples/formal-languages/context-free/grammarLib.sig similarity index 100% rename from examples/parsing/grammarLib.sig rename to examples/formal-languages/context-free/grammarLib.sig diff --git a/examples/parsing/grammarLib.sml b/examples/formal-languages/context-free/grammarLib.sml similarity index 100% rename from examples/parsing/grammarLib.sml rename to examples/formal-languages/context-free/grammarLib.sml diff --git a/examples/parsing/grammarScript.sml b/examples/formal-languages/context-free/grammarScript.sml similarity index 100% rename from examples/parsing/grammarScript.sml rename to examples/formal-languages/context-free/grammarScript.sml diff --git a/examples/parsing/pegLib.sig b/examples/formal-languages/context-free/pegLib.sig similarity index 100% rename from examples/parsing/pegLib.sig rename to examples/formal-languages/context-free/pegLib.sig diff --git a/examples/parsing/pegLib.sml b/examples/formal-languages/context-free/pegLib.sml similarity index 100% rename from examples/parsing/pegLib.sml rename to examples/formal-languages/context-free/pegLib.sml diff --git a/examples/parsing/pegML.sml b/examples/formal-languages/context-free/pegML.sml similarity index 100% rename from examples/parsing/pegML.sml rename to examples/formal-languages/context-free/pegML.sml diff --git a/examples/parsing/pegSampleScript.sml b/examples/formal-languages/context-free/pegSampleScript.sml similarity index 100% rename from examples/parsing/pegSampleScript.sml rename to examples/formal-languages/context-free/pegSampleScript.sml diff --git a/examples/parsing/pegScript.sml b/examples/formal-languages/context-free/pegScript.sml similarity index 100% rename from examples/parsing/pegScript.sml rename to examples/formal-languages/context-free/pegScript.sml diff --git a/examples/parsing/pegexecScript.sml b/examples/formal-languages/context-free/pegexecScript.sml similarity index 100% rename from examples/parsing/pegexecScript.sml rename to examples/formal-languages/context-free/pegexecScript.sml diff --git a/examples/parsing/precparserScript.sml b/examples/formal-languages/context-free/precparserScript.sml similarity index 100% rename from examples/parsing/precparserScript.sml rename to examples/formal-languages/context-free/precparserScript.sml diff --git a/examples/parsing/selftest.sml b/examples/formal-languages/context-free/selftest.sml similarity index 100% rename from examples/parsing/selftest.sml rename to examples/formal-languages/context-free/selftest.sml diff --git a/examples/parsing/simpleSexpPEGScript.sml b/examples/formal-languages/context-free/simpleSexpPEGScript.sml similarity index 100% rename from examples/parsing/simpleSexpPEGScript.sml rename to examples/formal-languages/context-free/simpleSexpPEGScript.sml diff --git a/examples/parsing/simpleSexpScript.sml b/examples/formal-languages/context-free/simpleSexpScript.sml similarity index 100% rename from examples/parsing/simpleSexpScript.sml rename to examples/formal-languages/context-free/simpleSexpScript.sml From 52c80ef69f69e96f5dfd7aa82d35ff4849f3013d Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 21 Sep 2015 14:23:04 +1000 Subject: [PATCH 494/718] Minor cleanup in oneScript. Make dependency on BasicProvers more explicit (listed at top-level). --- src/one/oneScript.sml | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/one/oneScript.sml b/src/one/oneScript.sml index eb6b2b9160..12c86e6773 100644 --- a/src/one/oneScript.sml +++ b/src/one/oneScript.sml @@ -24,7 +24,7 @@ structure oneScript = struct -open Lib HolKernel Parse boolLib; +open Lib HolKernel Parse boolLib BasicProvers val _ = new_theory "one"; @@ -139,10 +139,9 @@ val one_induction = Q.store_thm REPEAT STRIP_TAC THEN ONCE_REWRITE_TAC [one] THEN ASM_REWRITE_TAC[]); val FORALL_ONE = store_thm( - "FORALL_ONE", + "FORALL_ONE[simp]", ``(!x:unit. P x) <=> P ()``, simpLib.SIMP_TAC boolSimps.bool_ss [EQ_IMP_THM, one_induction]); -val _ = BasicProvers.export_rewrites ["FORALL_ONE"] (*--------------------------------------------------------------------------- Define the case constant From 8b046b8b9a372ed8e1bf2636f1f00cf0621a31a0 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 21 Sep 2015 14:24:10 +1000 Subject: [PATCH 495/718] Implement theory namespaces for type abbreviations Closes #168 --- src/parse/Parse.sig | 1 + src/parse/Parse.sml | 15 ++- src/parse/parse_type.sml | 12 ++- src/parse/type_grammar.sig | 11 +- src/parse/type_grammar.sml | 203 ++++++++++++++++++++++++++---------- src/parse/type_pp.sml | 41 ++++++-- src/prekernel/KernelSig.sig | 1 + src/prekernel/KernelSig.sml | 2 + 8 files changed, 212 insertions(+), 74 deletions(-) diff --git a/src/parse/Parse.sig b/src/parse/Parse.sig index 3b969af4b5..d5ce175828 100644 --- a/src/parse/Parse.sig +++ b/src/parse/Parse.sig @@ -33,6 +33,7 @@ signature Parse = sig Name : string, Assoc : associativity} -> unit + val temp_thytype_abbrev : KernelSig.kernelname * hol_type -> unit val temp_type_abbrev : string * hol_type -> unit val type_abbrev : string * hol_type -> unit val temp_disable_tyabbrev_printing : string -> unit diff --git a/src/parse/Parse.sml b/src/parse/Parse.sml index d69c3053fd..f77c505bfe 100644 --- a/src/parse/Parse.sml +++ b/src/parse/Parse.sml @@ -703,7 +703,7 @@ fun add_infix_type (x as {Name, ParseName, Assoc, Prec}) = let in ", Prec = ", Int.toString Prec, "}"]) end -fun temp_type_abbrev (s, ty) = let +fun temp_thytype_abbrev(knm, ty) = let val params = Listsort.sort Type.compare (type_vars ty) val (num_vars, pset) = List.foldl (fn (ty,(i,pset)) => (i + 1, Binarymap.insert(pset,ty,i))) @@ -718,16 +718,23 @@ fun temp_type_abbrev (s, ty) = let end in the_type_grammar := type_grammar.new_abbreviation (!the_type_grammar) - (s, mk_structure pset ty); + (knm, mk_structure pset ty); type_grammar_changed := true; term_grammar_changed := true end handle GrammarError s => raise ERROR "type_abbrev" s +fun temp_type_abbrev (s, ty) = let + val thy = Theory.current_theory() +in + temp_thytype_abbrev({Thy = thy, Name = s}, ty) +end + fun type_abbrev (s, ty) = let + val knm = {Thy=Theory.current_theory(),Name=s} in temp_type_abbrev (s, ty); - full_update_grms ("temp_type_abbrev", - String.concat ["(", mlquote s, ", ", + full_update_grms ("temp_thytype_abbrev", + String.concat ["(", KernelSig.name_toMLString knm, ", ", PP.pp_to_string (!Globals.linewidth) (TheoryPP.pp_type "U" "T") ty, diff --git a/src/parse/parse_type.sml b/src/parse/parse_type.sml index 6c99a68682..5818e456fb 100644 --- a/src/parse/parse_type.sml +++ b/src/parse/parse_type.sml @@ -33,6 +33,7 @@ fun totalify f x = SOME (f x) handle InternalFailure _ => NONE fun parse_type tyfns allow_unknown_suffixes G = let val G = rules G and abbrevs = abbreviations G + and privabbs = privileged_abbrevs G val {vartype = pVartype, tyop = pType, antiq = pAQ, qtyop} = tyfns fun structure_to_value0 (s,locn) args st = case st of @@ -121,9 +122,14 @@ fun parse_type tyfns allow_unknown_suffixes G = let in if is_numeric s then generate_fcpbit((s,locn), args) else - case Binarymap.peek(abbrevs, s) of - NONE => pType((s,locn),args) - | SOME st => structure_to_value (s,locn) args st + case Binarymap.peek(privabbs, s) of + NONE => pType((s,locn), args) + | SOME thy => let + in + case Binarymap.peek(abbrevs, {Name = s, Thy = thy}) of + NONE => pType((s,locn),args) + | SOME st => structure_to_value (s,locn) args st + end end | QTypeIdent(thy,ty) => qtyop{Thy=thy,Tyop=ty,Locn=locn,Args=args} | _ => raise Fail "parse_type.apply_tyop: can't happen" diff --git a/src/parse/type_grammar.sig b/src/parse/type_grammar.sig index ae78e4fea5..65d2157a76 100644 --- a/src/parse/type_grammar.sig +++ b/src/parse/type_grammar.sig @@ -1,6 +1,8 @@ signature type_grammar = sig + type kernelname = KernelSig.kernelname + datatype grammar_rule = INFIX of {opname : string, parse_string : string} list * HOLgrammars.associativity @@ -17,9 +19,12 @@ sig val min_grammar : grammar val rules : grammar -> {infixes: (int * grammar_rule) list, suffixes : string list} - val abbreviations : grammar -> (string,type_structure) Binarymap.dict + val abbreviations : grammar -> (kernelname,type_structure) Binarymap.dict + val privileged_abbrevs : grammar -> (string,string) Binarymap.dict - val abb_dest_type : grammar -> Type.hol_type -> string * Type.hol_type list + val abb_dest_type : grammar -> Type.hol_type -> + {Thy : string option, Tyop : string, + Args : Type.hol_type list} val disable_abbrev_printing : string -> grammar -> grammar val new_binary_tyop : grammar @@ -33,7 +38,7 @@ sig (* removes by infix symbol, i.e. "+", not "sum" *) val new_tyop : grammar -> string -> grammar - val new_abbreviation : grammar -> string * type_structure -> grammar + val new_abbreviation : grammar -> kernelname * type_structure -> grammar val remove_abbreviation : grammar -> string -> grammar val num_params : type_structure -> int diff --git a/src/parse/type_grammar.sml b/src/parse/type_grammar.sml index a4adbda428..b560d41dd2 100644 --- a/src/parse/type_grammar.sml +++ b/src/parse/type_grammar.sml @@ -16,21 +16,50 @@ fun typstruct_uptodate ts = | TYOP {Thy, Tyop, Args} => isSome (Type.op_arity {Thy = Thy, Tyop = Tyop}) andalso List.all typstruct_uptodate Args - - -datatype grammar = TYG of { rules : (int * grammar_rule) list, - suffixes : string list, - abbparse : (string, type_structure) Binarymap.dict, - abbprint : (int * string) TypeNet.typenet} - -fun fupdate_rules f (TYG{rules,suffixes,abbprint,abbparse}) = - TYG{rules=f rules,suffixes=suffixes,abbprint=abbprint,abbparse=abbparse} -fun fupdate_suffixes f (TYG{rules,suffixes,abbprint,abbparse}) = - TYG{rules=rules,suffixes=f suffixes,abbprint=abbprint,abbparse=abbparse} -fun fupdate_abbprint f (TYG{rules,suffixes,abbprint,abbparse}) = - TYG{rules=rules,suffixes=suffixes,abbprint=f abbprint,abbparse=abbparse} -fun fupdate_abbparse f (TYG{rules,suffixes,abbprint,abbparse}) = - TYG{rules=rules,suffixes=suffixes,abbprint=abbprint,abbparse=f abbparse} +type kernelname = KernelSig.kernelname + +datatype grammar = TYG of { + rules : (int * grammar_rule) list, + suffixes : string list, + abbparse : (kernelname, type_structure) Binarymap.dict, + abbprint : (int * kernelname) TypeNet.typenet, + privabbs : (string, string) Binarymap.dict, + tstamp : int +} +(* Abbreviations are handled by four fields of the grammar record : + + abbparse: maps (Thy,Name) pairs to type structures, encoding the abbreviation + abbprint: maps type-patterns (i.e., structures in effect) to kernel names, + as well as a "time stamp". In this way, more recent patterns + take precedence over older ones (the "specific-ness" of the + match is more important than this though). + privabbs: records which bare strings/Names are "privileged", and get to + be printed without being qualified by their theory. The map is + from Name to Theory, so that when parsing, if the algorithm sees + bare Name nm, it then looks up in privabbs to see which theory + this name is associated with, and then looks up the given + (theory,name) pair to see what structure this abbreviation has. + tstamp: provides the timestamps for abbprint above +*) + +fun fupdate_rules f (TYG{rules,suffixes,abbprint,abbparse,privabbs,tstamp}) = + TYG{rules=f rules,suffixes=suffixes,abbprint=abbprint,abbparse=abbparse, + privabbs = privabbs, tstamp = tstamp} +fun fupdate_suffixes f (TYG{rules,suffixes,abbprint,abbparse,privabbs,tstamp}) = + TYG{rules=rules,suffixes=f suffixes,abbprint=abbprint,abbparse=abbparse, + privabbs = privabbs, tstamp = tstamp} +fun fupdate_abbprint f (TYG{rules,suffixes,abbprint,abbparse,privabbs,tstamp}) = + TYG{rules=rules,suffixes=suffixes,abbprint=f abbprint,abbparse=abbparse, + privabbs = privabbs, tstamp = tstamp} +fun fupdate_abbparse f (TYG{rules,suffixes,abbprint,abbparse,privabbs,tstamp}) = + TYG{rules=rules,suffixes=suffixes,abbprint=abbprint,abbparse=f abbparse, + privabbs = privabbs, tstamp = tstamp} +fun fupdate_privabbs f (TYG{rules,suffixes,abbprint,abbparse,privabbs,tstamp}) = + TYG{rules=rules,suffixes=suffixes,abbprint=abbprint,abbparse=abbparse, + privabbs = f privabbs, tstamp = tstamp} +fun fupdate_tstamp f (TYG{rules,suffixes,abbprint,abbparse,privabbs,tstamp}) = + TYG{rules=rules,suffixes=suffixes,abbprint=abbprint,abbparse=abbparse, + privabbs = privabbs, tstamp = f tstamp} open HOLgrammars @@ -63,16 +92,23 @@ val params = params0 (HOLset.empty Int.compare) val num_params = HOLset.numItems o params -fun suffix_arity abbrevs s = - case Binarymap.peek (abbrevs, s) of - NONE => let +fun suffix_arity (abbrevs, privs) s = + case Binarymap.peek (privs, s) of + NONE => + let in case Type.decls s of [] => NONE | ty :: _ => Option.map (fn n => (s,n)) (Type.op_arity ty) end - | SOME st => if typstruct_uptodate st then SOME (s, num_params st) - else NONE + | SOME thy => + let + in + case Binarymap.peek(abbrevs, {Thy = thy, Name = s}) of + NONE => NONE (* shouldn't happen *) + | SOME st => if typstruct_uptodate st then SOME (s, num_params st) + else NONE + end fun merge r1 r2 = case (r1, r2) of @@ -128,11 +164,17 @@ end fun new_tyop g name = g |> fupdate_suffixes (cons name) val empty_grammar = TYG { rules = [], suffixes = [], - abbparse = Binarymap.mkDict String.compare, - abbprint = TypeNet.empty} + abbparse = Binarymap.mkDict KernelSig.name_compare, + privabbs = Binarymap.mkDict String.compare, + abbprint = TypeNet.empty, + tstamp = 0 } fun rules (TYG gr) = {infixes = #rules gr, suffixes = #suffixes gr} fun abbreviations (TYG gr) = #abbparse gr +fun privabbs (TYG gr) = #privabbs gr +val privileged_abbrevs = privabbs +fun tstamp (TYG gr) = #tstamp gr +fun bump_tstamp g = (tstamp g, fupdate_tstamp (fn n => n + 1) g) fun check_structure st = let fun param_numbers (PARAM i, pset) = HOLset.add(pset, i) @@ -150,24 +192,35 @@ in check_for_gaps 0 plist end -val abb_tstamp = ref 0 -fun remove_abbreviation g s = let - val (dict,st) = Binarymap.remove(abbreviations g,s) +fun remove_knm_abbreviation g knm = let + val (dict, st) = Binarymap.remove(abbreviations g, knm) fun doprint pmap0 = #1 (TypeNet.delete(pmap0, structure_to_type st)) handle Binarymap.NotFound => pmap0 + fun maybe_rmpriv d = + case Binarymap.peek (d, #Name knm) of + NONE => d + | SOME thy' => if thy' = #Thy knm then #1 (Binarymap.remove(d, #Name knm)) + else d in g |> fupdate_abbparse (K dict) |> fupdate_abbprint doprint -end handle Binarymap.NotFound => g + |> fupdate_privabbs maybe_rmpriv +end + +fun remove_abbreviation g s = + case Binarymap.peek (privabbs g, s) of + NONE => raise GrammarError ("Name \""^s^ + "\" doesn't map to a known type abbreviation") + | SOME thy => remove_knm_abbreviation g {Name = s, Thy = thy} -fun new_abbreviation tyg (s, st) = let +fun new_abbreviation tyg (knm as {Name=s,Thy=thy}, st) = let val _ = check_structure st - val tyg = case Binarymap.peek(abbreviations tyg, s) of + val tyg = case Binarymap.peek(abbreviations tyg, knm) of NONE => tyg | SOME st' => if st = st' then tyg else let - val tyg' = remove_abbreviation tyg s + val tyg' = remove_knm_abbreviation tyg knm in Feedback.HOL_WARNING "type_grammar" @@ -182,14 +235,15 @@ fun new_abbreviation tyg (s, st) = let raise GrammarError "Abbreviation can't be to a type variable" | _ => () + val (tstamp, tyg) = bump_tstamp tyg val result = - tyg |> fupdate_abbparse (fn d => Binarymap.insert(d,s,st)) + tyg |> fupdate_abbparse (fn d => Binarymap.insert(d,knm,st)) |> fupdate_abbprint (fn pmap => TypeNet.insert(pmap, structure_to_type st, - (!abb_tstamp, s))) + (tstamp, knm))) + |> fupdate_privabbs (fn d => Binarymap.insert(d,s,thy)) |> C new_tyop s in - abb_tstamp := !abb_tstamp + 1; result end @@ -204,7 +258,8 @@ fun merge_abbrevs G (d1, d2) = let | SOME v0 => if v0 <> v then (Feedback.HOL_WARNING "parse_type" "merge_grammars" - ("Conflicting entries for abbreviation "^k^ + ("Conflicting entries for abbreviation "^ + KernelSig.name_toString k ^ "; arbitrarily keeping map to "^ PP.pp_to_string (!Globals.linewidth) (pp_type G) @@ -219,12 +274,15 @@ end fun merge_pmaps (p1, p2) = TypeNet.fold (fn (ty,v,acc) => TypeNet.insert(acc,ty,v)) p1 p2 +fun merge_privs (p1, p2) = + Binarymap.foldl (fn (nm,thy,acc) => Binarymap.insert(acc,nm,thy)) p1 p2 + fun merge_grammars (G1, G2) = let (* both grammars are sorted, with no adjacent suffixes *) val TYG { rules = grules1, suffixes = sfxs1, abbparse = abbrevs1, - abbprint = pmap1 } = G1 + abbprint = pmap1, tstamp = t1, privabbs = priv1 } = G1 val TYG { rules = grules2, suffixes = sfxs2, abbparse = abbrevs2, - abbprint = pmap2 } = G2 + abbprint = pmap2, tstamp = t2, privabbs = priv2 } = G2 fun merge_acc acc (gs as (g1, g2)) = case gs of ([], _) => rev_append acc g2 @@ -240,11 +298,15 @@ in TYG { rules = merge_acc [] (grules1, grules2), suffixes = Lib.union sfxs1 sfxs2, abbparse = merge_abbrevs G2 (abbrevs1, abbrevs2), - abbprint = merge_pmaps (pmap1, pmap2) } + abbprint = merge_pmaps (pmap1, pmap2), + privabbs = merge_privs (priv1, priv2), + tstamp = Int.max(t1,t2) + 1 } end fun prettyprint_grammar pps G = let - val TYG { rules=g, suffixes=sfxs, abbparse=abbrevs, abbprint=pmap } = G + val TYG grm = G + val {rules=g, suffixes=sfxs, abbparse=abbrevs, abbprint=pmap, ... } = grm + val privabbs = #privabbs grm open Portable Lib val {add_break,add_newline,add_string,begin_block,end_block,...} = with_ppstream pps @@ -263,18 +325,23 @@ fun prettyprint_grammar pps G = let end fun print_abbrev (s, st) = let + val kns = KernelSig.name_toString s + val ispriv = case Binarymap.peek (privabbs, #Name s) of + SOME thy => thy = #Thy s + | NONE => false fun print_lhs () = case num_params st of - 0 => add_string s - | 1 => (add_string "'a "; add_string s) + 0 => add_string kns + | 1 => (add_string "'a "; add_string kns) | n => (begin_block INCONSISTENT 0; add_string "("; pr_list (pp_type G pps o structure_to_type o PARAM) (fn () => add_string ",") (fn () => add_break(1,0)) (List.tabulate(n, I)); - add_string ") "; - add_string s) + add_string ") "; + add_string kns) + fun print_priv () = if ispriv then add_string " (*)" else () val ty = structure_to_type st val printed = case TypeNet.peek (pmap, ty) of NONE => false @@ -285,7 +352,13 @@ fun prettyprint_grammar pps G = let add_string " ="; add_break(1,2); Feedback.trace ("print_tyabbrevs", 0) (pp_type G pps) ty; - if not printed then (add_break(5,2); add_string "(not printed)") else (); + if not printed orelse ispriv then + (add_break(5,2); add_string "("; + (if ispriv then add_string "preferred" else ()); + if printed then add_string ")" + else if ispriv then add_string ", not printed)" + else add_string "not printed)") + else (); end_block() end @@ -318,7 +391,7 @@ fun prettyprint_grammar pps G = let end fun print_suffixes slist = let - val oksl = List.mapPartial (suffix_arity abbrevs) slist + val oksl = List.mapPartial (suffix_arity (abbrevs, privabbs)) slist in if null oksl then () else let @@ -381,7 +454,13 @@ fun tysize ty = 1 + List.foldl (fn (ty,acc) => tysize ty + acc) 0 Args end -fun abb_dest_type0 (TYG{ abbprint = pmap, ...}) ty = let +fun dest_type' ty = let + val (nm, args) = Type.dest_type ty +in + {Thy = NONE, Tyop = nm, Args = args} +end + +fun abb_dest_type0 (TYG{abbprint = pmap, privabbs, ...}) ty = let open HolKernel val net_matches = TypeNet.match(pmap, ty) fun mymatch pat ty = let @@ -395,7 +474,7 @@ fun abb_dest_type0 (TYG{ abbprint = pmap, ...}) ty = let fun instcmp ({redex = r1, ...}, {redex = r2, ...}) = Type.compare(r1, r2) in case checked_matches of - [] => Type.dest_type ty + [] => dest_type' ty | _ => let fun instsize i = List.foldl (fn ({redex,residue},acc) => tysize residue + acc) 0 i @@ -404,27 +483,39 @@ in (pair_compare(Int.compare, Lib.flip_order o Int.compare)) val allinsts = Listsort.sort matchcmp checked_matches - val (inst,nm,_) = hd allinsts + val (inst,{Thy,Name},_) = hd allinsts val inst' = Listsort.sort instcmp inst val args = map #residue inst' in - (nm, args) + case Binarymap.peek (privabbs, Name) of + NONE => {Thy = SOME Thy, Tyop = Name, Args = args} + | SOME thy' => if Thy = thy' then {Thy = NONE, Tyop = Name, Args = args} + else {Thy = SOME Thy, Tyop = Name, Args = args} end end fun abb_dest_type G ty = if !print_abbrevs then abb_dest_type0 G ty - else Type.dest_type ty + else dest_type' ty -fun disable_abbrev_printing s (arg as TYG{abbparse=abbs, abbprint=pmap, ...}) = - case Binarymap.peek(abbs, s) of +fun disable_abbrev_printing s (arg as TYG grm) = let + val {abbparse=abbs, abbprint=pmap, privabbs,...} = grm +in + case Binarymap.peek (privabbs, s) of NONE => arg - | SOME st => let - val ty = structure_to_type st - val (pmap', (_,s')) = TypeNet.delete(pmap, ty) + | SOME thy => let + val knm = {Name = s, Thy = thy} in - if s = s' then fupdate_abbprint (K pmap') arg - else arg - end handle Binarymap.NotFound => arg + case Binarymap.peek(abbs, knm) of + NONE => arg + | SOME st => let + val ty = structure_to_type st + val (pmap', (_,knm')) = TypeNet.delete(pmap, ty) + in + if knm = knm' then fupdate_abbprint (K pmap') arg + else arg + end handle Binarymap.NotFound => arg + end +end (* ---------------------------------------------------------------------- min grammar diff --git a/src/parse/type_pp.sml b/src/parse/type_pp.sml index a18214ef49..934293132c 100644 --- a/src/parse/type_pp.sml +++ b/src/parse/type_pp.sml @@ -129,15 +129,14 @@ fun pp_type0 (G:grammar) backend = let add_string s end handle HOL_ERR _ => let - val (Tyop, Args) = type_grammar.abb_dest_type G ty + fun realtype ty = let val {Thy,Tyop,...} = dest_thy_type ty + in Thy ^ "$" ^ Tyop end + val {Tyop, Args, Thy = thyopt} = type_grammar.abb_dest_type G ty fun tooltip () = - case Binarymap.peek (type_grammar.abbreviations G, Tyop) of - NONE => let - val {Thy,Tyop,...} = dest_thy_type ty - in - Thy ^ "$" ^ Tyop - end - | SOME st => let + let + val abbs = type_grammar.abbreviations G + fun doabbrev st = + let val numps = num_params st in if 0 < numps then let @@ -155,6 +154,32 @@ fun pp_type0 (G:grammar) backend = let end else structure_to_string st end + in + case thyopt of + SOME thy => + let + val knm = {Thy = thy, Name = Tyop} + in + case Binarymap.peek (abbs, knm) of + NONE => realtype ty + | SOME st => doabbrev st + end + | NONE => + let + val privabbs = type_grammar.privileged_abbrevs G + in + case Binarymap.peek (privabbs, Tyop) of + NONE => realtype ty + | SOME thy => + let + val knm = {Thy = thy, Name = Tyop} + in + case Binarymap.peek (abbs, knm) of + NONE => raise Fail "Very confused tyabbrev" + | SOME st => doabbrev st + end + end + end fun print_args grav0 args = let val parens_needed = case Args of [_] => false | _ => true val grav = if parens_needed then Top else grav0 diff --git a/src/prekernel/KernelSig.sig b/src/prekernel/KernelSig.sig index f044730bd9..612f9d78fd 100644 --- a/src/prekernel/KernelSig.sig +++ b/src/prekernel/KernelSig.sig @@ -4,6 +4,7 @@ sig type kernelname = {Thy : string, Name : string} val name_compare : kernelname * kernelname -> order val name_toString : kernelname -> string + val name_toMLString : kernelname -> string eqtype kernelid diff --git a/src/prekernel/KernelSig.sml b/src/prekernel/KernelSig.sml index 5448ff6683..db3d3070d6 100644 --- a/src/prekernel/KernelSig.sml +++ b/src/prekernel/KernelSig.sml @@ -8,6 +8,8 @@ struct | x => x fun name_toString {Thy,Name} = Thy ^ "$" ^ Name + fun name_toMLString {Thy,Name} = + "{Thy=\"" ^ String.toString Thy ^ "\",Name=\"" ^ String.toString Name ^ "\"}" type kernelid = (kernelname * bool) ref (* bool is uptodate flag *) From 6bac5bc4998b8fe875a3dc2a9db0a94561718078 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 21 Sep 2015 15:12:52 +1000 Subject: [PATCH 496/718] Build sequence needs adjusting in light of 051995440c --- tools/sequences/final-examples | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tools/sequences/final-examples b/tools/sequences/final-examples index 7d8b38dabd..499c025f74 100644 --- a/tools/sequences/final-examples +++ b/tools/sequences/final-examples @@ -1,5 +1,6 @@ !examples/parity -!examples/parsing +!examples/formal-languages +!examples/formal-languages/context-free !examples/MLsyntax !examples/set-theory/zfset !examples/set-theory/vbg From f84e658dfbe118a60ad4980141538c7b92e30e57 Mon Sep 17 00:00:00 2001 From: Konrad Slind Date: Mon, 21 Sep 2015 00:35:03 -0500 Subject: [PATCH 497/718] added depth-first search. BFS to come --- src/search/dftScript.sml | 312 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 312 insertions(+) create mode 100644 src/search/dftScript.sml diff --git a/src/search/dftScript.sml b/src/search/dftScript.sml new file mode 100644 index 0000000000..baff9a3fad --- /dev/null +++ b/src/search/dftScript.sml @@ -0,0 +1,312 @@ +(*---------------------------------------------------------------------------*) +(* Depth first traversal of directed graphs that can contain cycles. *) +(*---------------------------------------------------------------------------*) + +open HolKernel boolLib bossLib + pred_setTheory pred_setLib relationTheory listTheory; + +val set_ss = list_ss ++ PRED_SET_ss; +val dnf_ss = bool_ss ++ boolSimps.DNF_ss ++ rewrites [AND_IMP_INTRO]; + +val _ = numLib.prefer_num(); + +val _ = new_theory "dft"; + +(*---------------------------------------------------------------------------*) +(* A graph G is a function of type 'a -> 'a list. *) +(* A node of G is a parent iff it has children. *) +(*---------------------------------------------------------------------------*) + +val Parents_def = Define `Parents G = {x | ~(G x = [])}`; + +(*---------------------------------------------------------------------------*) +(* DFT :('a -> 'a list) -> (* graph *) *) +(* ('a -> 'b -> 'b) -> (* folding function *) *) +(* 'a list -> (* nodes seen *) *) +(* 'a list -> (* fringe to visit *) *) +(* 'b -> (* accumulator *) *) +(* 'b (* final result *) *) +(* *) +(* DFT checks that the given graph has finite Parents. If the Parents set *) +(* is finite then the graph has only finitely many edges (because G produces *) +(* a list of children, a node has only finitely many children) and DFT must *) +(* terminate. *) +(* *) +(* Termination proof. In the first recursive call, the to_visit list is *) +(* shorter. In the second recursive call, the seen and to_visit argument can *) +(* both increase, but in different circumstances. In this call, visit_now *) +(* has not been seen. If it is a parent in the graph, then adding it to *) +(* seen decreases the number of unseen parents in the graph. If it is not a *) +(* parent, then it has no children, and so the to_visit list shrinks. *) +(*---------------------------------------------------------------------------*) + +val Rel_def = (* map arg. tuples into a pair of numbers for termination *) + Define + `Rel(G,f,seen,to_visit,acc) = + (CARD(Parents G DIFF (LIST_TO_SET seen)), LENGTH to_visit)`; + +val def = (* Define function and prove termination *) + tDefine + "DFT" + `DFT G f seen to_visit acc = + if FINITE (Parents G) + then case to_visit + of [] => acc + | visit_now :: visit_later => + if MEM visit_now seen + then DFT G f seen visit_later acc + else DFT G f (visit_now :: seen) + (G visit_now ++ visit_later) + (f visit_now acc) + else ARB` + (WF_REL_TAC `inv_image ($< LEX $<) Rel` + THEN RW_TAC set_ss [Rel_def, DECIDE ``(0 < p - q) = q < p ``] + THEN Cases_on `visit_now IN Parents G` THENL + [DISJ1_TAC, DISJ2_TAC] THEN RW_TAC set_ss [] THENL + [MATCH_MP_TAC (DECIDE ``y <= x /\ y < z ==> x < z + (x - y)``) THEN + CONJ_TAC THENL + [METIS_TAC [CARD_INTER_LESS_EQ], + MATCH_MP_TAC (SIMP_RULE dnf_ss [] CARD_PSUBSET) + THEN RW_TAC set_ss [INTER_DEF,PSUBSET_DEF,SUBSET_DEF,EXTENSION] + THEN METIS_TAC[]], + MATCH_MP_TAC (SIMP_RULE dnf_ss [] CARD_PSUBSET) + THEN RW_TAC set_ss [INTER_DEF,PSUBSET_DEF,SUBSET_DEF,EXTENSION] + THEN METIS_TAC[], + MATCH_MP_TAC (DECIDE ``(p=q) ==> (x-p = x-q)``) + THEN MATCH_MP_TAC (METIS_PROVE [] ``(s1=s2) ==> (CARD s1 = CARD s2)``) + THEN RW_TAC set_ss [INTER_DEF,EXTENSION] THEN METIS_TAC [], + FULL_SIMP_TAC set_ss [Parents_def]]); + + +(*---------------------------------------------------------------------------*) +(* Desired recursion equations, constrained by finiteness of graph. *) +(*---------------------------------------------------------------------------*) + +val DFT_def = Q.store_thm +("DFT_def", + `FINITE (Parents G) ==> + (DFT G f seen [] acc = acc) /\ + (DFT G f seen (visit_now :: visit_later) acc = + if MEM visit_now seen + then DFT G f seen visit_later acc + else DFT G f (visit_now :: seen) + (G visit_now ++ visit_later) + (f visit_now acc))`, + RW_TAC std_ss [] THENL + [RW_TAC list_ss [def], + GEN_REWRITE_TAC LHS_CONV empty_rewrites [def] THEN RW_TAC list_ss [], + RW_TAC list_ss [def], + GEN_REWRITE_TAC LHS_CONV empty_rewrites [def] THEN RW_TAC list_ss []]); + + +(*---------------------------------------------------------------------------*) +(* Desired induction theorem for DFT. *) +(*---------------------------------------------------------------------------*) + +val DFT_ind = Q.store_thm +("DFT_ind", + `!P. + (!G f seen visit_now visit_later acc. + P G f seen [] acc /\ + ((FINITE (Parents G) /\ ~MEM visit_now seen ==> + P G f (visit_now :: seen) + (G visit_now ++ visit_later) + (f visit_now acc)) /\ + (FINITE (Parents G) /\ MEM visit_now seen ==> + P G f seen visit_later acc) + ==> P G f seen (visit_now :: visit_later) acc)) + ==> + !v v1 v2 v3 v4. P v v1 v2 v3 v4`, + NTAC 2 STRIP_TAC + THEN HO_MATCH_MP_TAC (fetch "-" "DFT_ind") + THEN REPEAT GEN_TAC THEN Cases_on `to_visit` + THEN RW_TAC list_ss []); + +(*---------------------------------------------------------------------------*) +(* Basic lemmas about DFT *) +(*---------------------------------------------------------------------------*) + +val DFT_CONS = Q.store_thm +("DFT_CONS", + `!G f seen to_visit acc a b. + FINITE (Parents G) /\ (f = CONS) /\ (acc = APPEND a b) + ==> + (DFT G f seen to_visit acc = DFT G f seen to_visit a ++ b)`, + recInduct DFT_ind + THEN RW_TAC list_ss [DFT_def] THEN METIS_TAC [APPEND]); + +val FOLDR_UNROLL = Q.prove +(`!f x b l. FOLDR f (f x b) l = FOLDR f b (l ++ [x])`, + Induct_on `l` THEN RW_TAC list_ss []); + +val DFT_FOLD = Q.store_thm +("DFT_FOLD", + `!G f seen to_visit acc. + FINITE (Parents G) + ==> + (DFT G f seen to_visit acc = FOLDR f acc (DFT G CONS seen to_visit []))`, + recInduct DFT_ind THEN + RW_TAC list_ss [DFT_def] THEN METIS_TAC [FOLDR_UNROLL,DFT_CONS,APPEND]); + +val DFT_ALL_DISTINCT_LEM = Q.prove +(`!G f seen to_visit acc. + FINITE (Parents G) /\ (f = CONS) /\ + ALL_DISTINCT acc /\ (!x. MEM x acc ==> MEM x seen) + ==> + ALL_DISTINCT (DFT G f seen to_visit acc)`, + recInduct DFT_ind THEN RW_TAC list_ss [DFT_def] THEN METIS_TAC []); + +val DFT_ALL_DISTINCT = Q.store_thm +("DFT_ALL_DISTINCT", + `!G seen to_visit. + FINITE (Parents G) ==> ALL_DISTINCT (DFT G CONS seen to_visit [])`, + RW_TAC list_ss [DFT_ALL_DISTINCT_LEM]); + +(*---------------------------------------------------------------------------*) +(* Definition of reachability in a graph of the kind we are using here. *) +(*---------------------------------------------------------------------------*) + +val REACH_DEF = + Define + `REACH G = RTC (\x y. MEM y (G x))`; + +val REACH_LIST_DEF = + Define + `REACH_LIST G nodes y = ?x. MEM x nodes /\ y IN REACH G x`; + +(*---------------------------------------------------------------------------*) +(* Removing a set of nodes ex from G. *) +(*---------------------------------------------------------------------------*) + +val EXCLUDE_DEF = + Define + `EXCLUDE G ex node = if node IN ex then [] else G node`; + +(*---------------------------------------------------------------------------*) +(* Lemmas about reachability and restricted graphs. *) +(*---------------------------------------------------------------------------*) + +val EXCLUDE_LEM = Q.store_thm +("EXCLUDE_LEM", + `!G x l. EXCLUDE G (x INSERT l) = EXCLUDE (EXCLUDE G l) {x}`, + RW_TAC set_ss [FUN_EQ_THM,EXTENSION, EXCLUDE_DEF, IN_INSERT, NOT_IN_EMPTY] + THEN METIS_TAC[]); + +val REACH_EXCLUDE = Q.store_thm +("REACH_EXCLUDE", +`!G x. REACH (EXCLUDE G x) = RTC (\x' y. ~(x' IN x) /\ MEM y (G x'))`, + RW_TAC set_ss [REACH_DEF, EXCLUDE_DEF] THEN AP_TERM_TAC + THEN RW_TAC set_ss [FUN_EQ_THM] + THEN RW_TAC set_ss []); + +(*---------------------------------------------------------------------------*) +(* A node is reachable from p iff it is reachable from a child of p on a *) +(* path not containing p. *) +(*---------------------------------------------------------------------------*) + +val REACH_LEM1 = Q.store_thm +("REACH_LEM1", +`!p G seen. + ~(p IN seen) ==> + (REACH (EXCLUDE G seen) p = + p INSERT (REACH_LIST (EXCLUDE G (p INSERT seen)) (G p)))`, + RW_TAC set_ss [EXTENSION,SPECIFICATION,REACH_EXCLUDE,REACH_LIST_DEF] + THEN Cases_on `p = x` + THEN RW_TAC list_ss [RTC_RULES] THEN EQ_TAC THEN RW_TAC bool_ss [] THENL + [Q.PAT_ASSUM `$~a` MP_TAC THEN POP_ASSUM MP_TAC + THEN Q.SPEC_TAC (`x`,`q`) THEN Q.ID_SPEC_TAC `p` + THEN HO_MATCH_MP_TAC RTC_INDUCT_RIGHT1 THEN RW_TAC bool_ss [] + THEN Cases_on `p' = x'` THEN FULL_SIMP_TAC bool_ss [] THENL + [METIS_TAC [RTC_RULES], + Q.EXISTS_TAC `x''` THEN RW_TAC bool_ss [Once RTC_CASES2] THEN METIS_TAC[]], + `RTC (\x' y. ~seen x' /\ set (G x') y) x' x` + by (POP_ASSUM MP_TAC THEN MATCH_MP_TAC RTC_MONOTONE THEN METIS_TAC[]) + THEN RW_TAC bool_ss [Once RTC_CASES1] THEN METIS_TAC []]); + +(*---------------------------------------------------------------------------*) +(* If y is reachable from x, but not z, then y is reachable from x on a path *) +(* that does not include z. *) +(*---------------------------------------------------------------------------*) + +val REACH_LEM2 = Q.store_thm +("REACH_LEM2", + `!G x y. REACH G x y ==> !z. ~REACH G z y ==> REACH (EXCLUDE G {z}) x y`, + STRIP_TAC THEN REWRITE_TAC [REACH_EXCLUDE, REACH_DEF, IN_SING] THEN + HO_MATCH_MP_TAC RTC_INDUCT_RIGHT1 THEN RW_TAC set_ss [RTC_RULES] THEN + POP_ASSUM MP_TAC THEN RW_TAC set_ss [Once RTC_CASES2] THEN + POP_ASSUM (MP_TAC o Q.SPEC `x'`) THEN RW_TAC set_ss [] THEN + RW_TAC set_ss [Once RTC_CASES2] THEN METIS_TAC [RTC_RULES]); + +(*---------------------------------------------------------------------------*) +(* If DFT visits x, then x is reachable or is in the starting accumulator *) +(*---------------------------------------------------------------------------*) + +val DFT_REACH_1 = Q.store_thm +("DFT_REACH_1", + `!G f seen to_visit acc. + FINITE (Parents G) /\ (f = CONS) ==> + !x. MEM x (DFT G f seen to_visit acc) ==> + x IN (REACH_LIST G to_visit) \/ MEM x acc`, + recInduct DFT_ind + THEN RW_TAC set_ss [DFT_def, REACH_LIST_DEF, REACH_DEF, IN_DEF] + THENL[METIS_TAC [], ALL_TAC] + THEN POP_ASSUM MP_TAC THEN RW_TAC set_ss [] + THEN POP_ASSUM (MP_TAC o Q.SPEC `x`) THEN RW_TAC set_ss [] THENL + [IMP_RES_TAC RTC_RULES THEN METIS_TAC[], + METIS_TAC[], METIS_TAC[RTC_RULES], METIS_TAC[]]); + +(*---------------------------------------------------------------------------*) +(* If x is reachable from to_visit on a path that does not include the nodes *) +(* in seen, then DFT visits x. *) +(*---------------------------------------------------------------------------*) + +val DFT_REACH_2 = Q.store_thm +("DFT_REACH_2", + `!G f seen to_visit acc x. + FINITE (Parents G) /\ (f = CONS) /\ + x IN (REACH_LIST (EXCLUDE G (LIST_TO_SET seen)) to_visit) /\ + ~MEM x seen + ==> + MEM x (DFT G f seen to_visit acc)`, + recInduct DFT_ind THEN RW_TAC set_ss [DFT_def] THENL + [(* Base Case *) + FULL_SIMP_TAC list_ss [IN_DEF, EXCLUDE_DEF, REACH_LIST_DEF], + (* The head of to_visit is in seen *) + FULL_SIMP_TAC dnf_ss [SPECIFICATION, REACH_LIST_DEF] + THEN RW_TAC list_ss [] THEN + POP_ASSUM MP_TAC THEN RW_TAC list_ss [] THEN POP_ASSUM MATCH_MP_TAC THEN + FULL_SIMP_TAC set_ss [SPECIFICATION, REACH_LIST_DEF] THENL + [FULL_SIMP_TAC set_ss [REACH_EXCLUDE,Once RTC_CASES1,SPECIFICATION],ALL_TAC] + THEN METIS_TAC [], + (* The head of to_visit is not in seen *) + POP_ASSUM MP_TAC THEN RW_TAC set_ss [] THEN + POP_ASSUM (MP_TAC o Q.SPEC `x`) THEN RW_TAC list_ss [] THEN + Cases_on `x = visit_now` THEN FULL_SIMP_TAC set_ss [] THEN + RW_TAC set_ss [] THENL + [RW_TAC list_ss [Q.SPECL [`G`, `CONS`, `h::seen`, + `G visit_now ++ visit_later`, `visit_now::acc`, + `[]`, `visit_now::acc`] DFT_CONS], + FIRST_ASSUM MATCH_MP_TAC THEN RW_TAC set_ss [] THEN + Cases_on `x IN REACH (EXCLUDE G (LIST_TO_SET seen)) visit_now` THENL + [POP_ASSUM MP_TAC THEN RW_TAC set_ss [REACH_LEM1] THEN + FULL_SIMP_TAC set_ss [SPECIFICATION,REACH_LIST_DEF,LIST_TO_SET_THM] + THEN METIS_TAC [], + FULL_SIMP_TAC set_ss [SPECIFICATION, REACH_LIST_DEF,LIST_TO_SET_THM] + THENL [METIS_TAC [], METIS_TAC [REACH_LEM2, EXCLUDE_LEM]]]]]); + +(*---------------------------------------------------------------------------*) +(* x is reachable iff DFT finds it. *) +(*---------------------------------------------------------------------------*) + +val DFT_REACH_THM = Q.store_thm +("DFT_REACH_THM", + `!G to_visit. + FINITE (Parents G) + ==> + !x. x IN REACH_LIST G to_visit = MEM x (DFT G CONS [] to_visit [])`, + RW_TAC bool_ss [EQ_IMP_THM] THENL + [MATCH_MP_TAC DFT_REACH_2,IMP_RES_TAC DFT_REACH_1] THEN + FULL_SIMP_TAC set_ss [REACH_DEF,REACH_EXCLUDE,SPECIFICATION,REACH_LIST_DEF] THEN + METIS_TAC[LIST_TO_SET_DEF]); + +val _ = export_theory(); From e93d1e097afe09da349044c4c0c27da71e6b7ec2 Mon Sep 17 00:00:00 2001 From: Konrad Slind Date: Mon, 21 Sep 2015 00:38:27 -0500 Subject: [PATCH 498/718] miscellaneous fixes --- src/list/src/listScript.sml | 2 +- src/num/termination/TotalDefn.sml | 2 +- src/tfl/examples/test.Define | 27 +++++++++++++++++++++++++++ src/tfl/examples/variant | 2 -- 4 files changed, 29 insertions(+), 4 deletions(-) diff --git a/src/list/src/listScript.sml b/src/list/src/listScript.sml index c0eb649fe2..02e6521174 100644 --- a/src/list/src/listScript.sml +++ b/src/list/src/listScript.sml @@ -755,7 +755,7 @@ val APPEND_11_LENGTH = save_thm ("APPEND_11_LENGTH", ) THEN PROVE_TAC[APPEND_LENGTH_EQ]))) -val APPEND_eq_ID = store_thm( +val APPEND_EQ_SELF = store_thm( "APPEND_EQ_SELF", ``(!l1 l2:'a list. ((l1 ++ l2 = l1) = (l2 = []))) /\ (!l1 l2:'a list. ((l1 ++ l2 = l2) = (l1 = []))) /\ diff --git a/src/num/termination/TotalDefn.sml b/src/num/termination/TotalDefn.sml index 38f0292bdd..e3d79094cd 100644 --- a/src/num/termination/TotalDefn.sml +++ b/src/num/termination/TotalDefn.sml @@ -109,7 +109,7 @@ fun mk_lex_reln argvars sizedlist arrangement = (*---------------------------------------------------------------------------*) -(* proper_subterm t1 t2 iff t1 is a proper subterm of t2. A recod projection *) +(* proper_subterm t1 t2 iff t1 is a proper subterm of t2. A record projn *) (* x.fld is a proper subterm of x. *) (*---------------------------------------------------------------------------*) diff --git a/src/tfl/examples/test.Define b/src/tfl/examples/test.Define index 7a32c482bc..63d7772ab3 100644 --- a/src/tfl/examples/test.Define +++ b/src/tfl/examples/test.Define @@ -994,3 +994,30 @@ Define `t4 (a,17w,18w,b,19w,c) = a /\ b /\ c`; Define `t5 (a,17w,18w,b,c,19w) = a /\ b /\ c`; Define `t6 (a,17w,18w,19w,b,c) = a /\ b /\ c`; + +(*---------------------------------------------------------------------------*) +(* Comparison function on first order terms. *) +(*---------------------------------------------------------------------------*) + +load "stringLib"; +open comparisonTheory; (* source in HOLDIR/src/enumfset *) + +val _ = Hol_datatype + `term + = Var of string + | App of string => term list`; + +val term_size_def = fetch "-" "term_size_def"; + +val term_cmp_def = + tDefine + "term_cmp" + `(term_cmp (Var x1) (Var x2) = string_cmp x1 x2) ∧ + (term_cmp (Var _) (App _ _) = Less) ∧ + (term_cmp (App _ _) (Var _) = Greater) ∧ + (term_cmp (App x1 ts1) (App x2 ts2) = + pair_cmp string_cmp (list_cmp term_cmp) (x1,ts1) (x2,ts2))` + (RW_TAC list_ss [] THEN + WF_REL_TAC `measure (term_size o FST)` THEN + Induct_on `ts1` THEN RW_TAC list_ss [term_size_def] THENL + [ALL_TAC, RES_TAC THEN POP_ASSUM (MP_TAC o SPEC_ALL)] THEN DECIDE_TAC); diff --git a/src/tfl/examples/variant b/src/tfl/examples/variant index a8ca2e1838..cfde9be61a 100644 --- a/src/tfl/examples/variant +++ b/src/tfl/examples/variant @@ -1,5 +1,3 @@ -app load ["bossLib"]; open bossLib; - (*--------------------------------------------------------------------------- Find an element not in a given list. ---------------------------------------------------------------------------*) From 248ee68a34542c2c13731da87d29ab6ae58c6ce9 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 21 Sep 2015 16:02:50 +1000 Subject: [PATCH 499/718] Build sequence for Travis also needs adjusting. Again, in light of 051995440c --- developers/travis/selftestseq | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/developers/travis/selftestseq b/developers/travis/selftestseq index 1c86d19cfd..bd6dabb5ae 100644 --- a/developers/travis/selftestseq +++ b/developers/travis/selftestseq @@ -10,6 +10,7 @@ src/n-bit src/bag !examples/ind_def !examples/lambda/basics -!examples/parsing +!examples/formal-languages +!examples/formal-languages/context-free !examples/unification/triangular/first-order !examples/zipper From df50c8822f9b02f21a1cae4dc0ef2e390c2cbdc2 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 22 Sep 2015 10:39:39 +1000 Subject: [PATCH 500/718] Fix a type-error in EmitTeX Related to github issue #168 and commit 8b046b8b9a --- src/TeX/EmitTeX.sml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/TeX/EmitTeX.sml b/src/TeX/EmitTeX.sml index d913928740..4e12e31933 100644 --- a/src/TeX/EmitTeX.sml +++ b/src/TeX/EmitTeX.sml @@ -416,7 +416,7 @@ let val {add_string,add_break,begin_block,add_newline,end_block,add_xstring,...} val TP0 = type_pp.pp_type (Parse.type_grammar()) backend ostrm val adest_type = type_grammar.abb_dest_type (Parse.type_grammar()) fun TP ty = - if is_vartype ty orelse null (#2 (adest_type ty)) then TP0 ty + if is_vartype ty orelse null (#Args (adest_type ty)) then TP0 ty else (S "("; BB PP.INCONSISTENT 0; TP0 ty; EB(); S")") From 893a6d7a6cada81987be5616236f3b5846ab3a8d Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 22 Sep 2015 11:19:36 +1000 Subject: [PATCH 501/718] Add an OK() function to testutils. Just prints "OK\n" --- src/1/testutils.sig | 1 + src/1/testutils.sml | 1 + 2 files changed, 2 insertions(+) diff --git a/src/1/testutils.sig b/src/1/testutils.sig index dc604dde94..c16b2fef8b 100644 --- a/src/1/testutils.sig +++ b/src/1/testutils.sig @@ -2,6 +2,7 @@ signature testutils = sig val linewidth : int ref +val OK : unit -> unit val die : string -> 'a val tprint : string -> unit val tpp : string -> unit diff --git a/src/1/testutils.sml b/src/1/testutils.sml index 955be79109..1d0cfb16df 100644 --- a/src/1/testutils.sml +++ b/src/1/testutils.sml @@ -6,6 +6,7 @@ open Lib val linewidth = ref 80 fun die s = (print (s ^ "\n"); OS.Process.exit OS.Process.failure) +fun OK () = print "OK\n" fun tprint s = print (UTF8.padRight #" " 65 (s ^ " ... ")) From 08272beb015eae7fecea56be76c110dd2f23b333 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 22 Sep 2015 11:20:24 +1000 Subject: [PATCH 502/718] Fixes and tests arising from namespacing tyabbrevs Document how to remove/disable-printing-for all type abbreviations of a given name, or a specific abbreviation from a given theory. Tests for this. Final cleanup for #168 I hope. --- .../Parse.disable_tyabbrev_printing.doc | 11 ++- help/Docfiles/Parse.remove_type_abbrev.doc | 13 +++- src/1/theory_tests/gh168aScript.sml | 17 ++++ src/1/theory_tests/gh168bScript.sml | 28 +++++++ src/1/theory_tests/gh168cScript.sml | 32 ++++++++ src/parse/type_grammar.sml | 78 +++++++++++++------ src/parse/type_pp.sml | 45 ++++++----- 7 files changed, 174 insertions(+), 50 deletions(-) create mode 100644 src/1/theory_tests/gh168aScript.sml create mode 100644 src/1/theory_tests/gh168bScript.sml create mode 100644 src/1/theory_tests/gh168cScript.sml diff --git a/help/Docfiles/Parse.disable_tyabbrev_printing.doc b/help/Docfiles/Parse.disable_tyabbrev_printing.doc index 491114d411..03f701a1e3 100644 --- a/help/Docfiles/Parse.disable_tyabbrev_printing.doc +++ b/help/Docfiles/Parse.disable_tyabbrev_printing.doc @@ -9,12 +9,19 @@ Disables the printing of a type abbreviation. Pretty-printing \DESCRIBE -A call to {disable_tyabbrev_printing s} causes the type abbreviation +A call to {disable_tyabbrev_printing s} causes type abbreviations mapping the string {s} to some type expansion not to be printed when an instance of the type expansion is seen. +If the string {s} is not a qualified name (of the form {"thy$name"}), +then all type abbreviations with base name {s} are disabled. If {s} +does have a qualified name, then only a type abbreviation of that name +and theory will be disabled (if such exists). + \FAILURE -Never fails. If there is no abbreviation of the given name, a call to +Fails if the given string is a malformed qualified identifier (e.g., +{foo$$}). If the given name is syntactically valid, but there are no +abbreviations keyed to the given name, a call to {disable_tyabbrev_printing} will silently do nothing. \EXAMPLE diff --git a/help/Docfiles/Parse.remove_type_abbrev.doc b/help/Docfiles/Parse.remove_type_abbrev.doc index 56db98b665..ac613f02e6 100644 --- a/help/Docfiles/Parse.remove_type_abbrev.doc +++ b/help/Docfiles/Parse.remove_type_abbrev.doc @@ -9,15 +9,22 @@ Remove a type abbreviation from the type grammar. parsing, pretty-printing. \DESCRIBE -A call to {remove_type_abbrev s} removes the type abbreviation keyed +A call to {remove_type_abbrev s} removes any type abbreviations keyed on string {s}. As with other functions affecting the global grammar, there is a companion function, {temp_remove_type_abbrev}, which affects the grammar but does not cause the effect to be replayed in descendant theories. +If the string {s} is not a qualified name (of the form {"thy$name"}), +then all type abbreviations with base name {s} are removed. If {s} +does have a qualified name, then only a type abbreviation of that name +and theory will be removed (if such exists). + \FAILURE -Never fails. If the specified string is not a current abbreviation, -the call has no effect on the grammar. +Fails if the given string is a malformed qualified identifier (e.g., +{foo$$}). If the given name is syntactically valid, but there are no +abbreviations keyed to the given name, a call to {remove_type_abbrev} +will silently do nothing. \EXAMPLE The standard theory context (where {pred_set} is loaded), includes an diff --git a/src/1/theory_tests/gh168aScript.sml b/src/1/theory_tests/gh168aScript.sml new file mode 100644 index 0000000000..d3dfd59d5d --- /dev/null +++ b/src/1/theory_tests/gh168aScript.sml @@ -0,0 +1,17 @@ +open HolKernel Parse boolLib + +open gh294aTheory gh294bTheory + +val _ = new_theory "gh168a"; + +val thy = + Binarymap.find(type_grammar.privileged_abbrevs (type_grammar()), "foo") + +val _ = disable_tyabbrev_printing (thy^"$foo") + +val s = type_to_string ``:bool -> bool -> bool`` + +val _ = if thy = "gh294a" then assert (equal ":gh294b$foo") s + else assert (equal ":bool -> gh294a$foo") s + +val _ = export_theory(); diff --git a/src/1/theory_tests/gh168bScript.sml b/src/1/theory_tests/gh168bScript.sml new file mode 100644 index 0000000000..e3dae6dc5c --- /dev/null +++ b/src/1/theory_tests/gh168bScript.sml @@ -0,0 +1,28 @@ +open HolKernel Parse boolLib + +open gh294aTheory gh294bTheory testutils + +val _ = new_theory "gh168b"; + +val _ = remove_type_abbrev "foo" + +val tyg = type_grammar() + +val _ = tprint "foo abbrev no longer parses" +val _ = (``:foo``; die "FAILED!") handle HOL_ERR _ => OK() + +fun typrinttest s = + let + val ty = Parse.Type [QUOTE s] + in + tprint (standard_tpp_message s); + if s = type_to_string ty then OK() else die "FAILED!" + end + +val _ = typrinttest ":bool -> bool" +val _ = typrinttest ":bool -> bool -> bool" +val _ = tprint "type_grammar abbrevs map is empty" +val _ = if Binarymap.numItems (type_grammar.abbreviations tyg) = 0 then OK() + else die "FAILED!" + +val _ = export_theory(); diff --git a/src/1/theory_tests/gh168cScript.sml b/src/1/theory_tests/gh168cScript.sml new file mode 100644 index 0000000000..9229ee66d3 --- /dev/null +++ b/src/1/theory_tests/gh168cScript.sml @@ -0,0 +1,32 @@ +open HolKernel Parse boolLib + +open gh294aTheory gh294bTheory testutils + +val _ = new_theory "gh168c"; + +val tyg0 = type_grammar() +val privthy = Binarymap.find(type_grammar.privileged_abbrevs tyg0, "foo") +val unprivthy = if privthy = "gh294a" then "gh294b" else "gh294a" + +val _ = remove_type_abbrev (privthy ^ "$foo") + +val _ = tprint "foo abbrev no longer parses" +val _ = (``:foo``; die "FAILED!") handle HOL_ERR _ => OK() + +fun typrinttest s expected = + let + val ty = Parse.Type [QUOTE s] + in + tprint (standard_tpp_message s); + if type_to_string ty = expected then OK() else die "FAILED!" + end + +val _ = typrinttest ":bool -> bool" + (if unprivthy = "gh294a" then ":gh294a$foo" + else ":bool -> bool -> bool") +val _ = typrinttest ":bool -> bool -> bool" + (if unprivthy = "gh294a" then ":bool -> gh294a$foo" + else ":gh294b$foo") + + +val _ = export_theory(); diff --git a/src/parse/type_grammar.sml b/src/parse/type_grammar.sml index b560d41dd2..2cad79fbc7 100644 --- a/src/parse/type_grammar.sml +++ b/src/parse/type_grammar.sml @@ -1,10 +1,11 @@ structure type_grammar :> type_grammar = struct +open HOLgrammars open Lib + datatype grammar_rule = - INFIX of {opname : string, parse_string : string} list * - HOLgrammars.associativity + INFIX of {opname : string, parse_string : string} list * associativity datatype type_structure = TYOP of {Thy : string, Tyop : string, Args : type_structure list} @@ -18,6 +19,14 @@ fun typstruct_uptodate ts = type kernelname = KernelSig.kernelname +fun break_qident s = + case String.fields (equal #"$") s of + [ _ ] => (NONE, s) + | [thy, nm] => (SOME thy, nm) + | _ => raise GrammarError ("String \""^s^ + "\" is not a valid type identifier") + + datatype grammar = TYG of { rules : (int * grammar_rule) list, suffixes : string list, @@ -61,8 +70,6 @@ fun fupdate_tstamp f (TYG{rules,suffixes,abbprint,abbparse,privabbs,tstamp}) = TYG{rules=rules,suffixes=suffixes,abbprint=abbprint,abbparse=abbparse, privabbs = privabbs, tstamp = f tstamp} -open HOLgrammars - fun default_typrinter (G:grammar) (pps:Portable.ppstream) (ty:Type.hol_type) = PP.add_string pps "" @@ -171,6 +178,7 @@ val empty_grammar = TYG { rules = [], suffixes = [], fun rules (TYG gr) = {infixes = #rules gr, suffixes = #suffixes gr} fun abbreviations (TYG gr) = #abbparse gr +fun abbprintmap (TYG gr) = #abbprint gr fun privabbs (TYG gr) = #privabbs gr val privileged_abbrevs = privabbs fun tstamp (TYG gr) = #tstamp gr @@ -207,10 +215,30 @@ in end fun remove_abbreviation g s = - case Binarymap.peek (privabbs g, s) of - NONE => raise GrammarError ("Name \""^s^ - "\" doesn't map to a known type abbreviation") - | SOME thy => remove_knm_abbreviation g {Name = s, Thy = thy} + let + val (thyopt, nm) = break_qident s + fun parsemap nmcheck (knm,st,acc) = + if nmcheck knm then acc else Binarymap.insert(acc,knm,st) + fun printmap nmcheck (ty,v as (tstamp,knm),acc) = + if nmcheck knm then acc else TypeNet.insert(acc,ty,v) + fun thyprivrm thy m = + case Binarymap.peek (m, nm) of + NONE => m + | SOME thy' => if thy' = thy then #1 (Binarymap.remove(m,nm)) + else m + val (check,privrm) = + case thyopt of + NONE => ((fn knm => #Name knm = nm), + (fn m => #1 (Binarymap.remove (m, nm)) + handle Binarymap.NotFound => m)) + | SOME thy => (equal {Name = nm, Thy = thy}, thyprivrm thy) + in + g |> fupdate_privabbs privrm + |> fupdate_abbprint (TypeNet.fold (printmap check) TypeNet.empty) + |> fupdate_abbparse + (Binarymap.foldl (parsemap check) + (Binarymap.mkDict KernelSig.name_compare)) + end fun new_abbreviation tyg (knm as {Name=s,Thy=thy}, st) = let val _ = check_structure st @@ -497,25 +525,25 @@ end fun abb_dest_type G ty = if !print_abbrevs then abb_dest_type0 G ty else dest_type' ty -fun disable_abbrev_printing s (arg as TYG grm) = let - val {abbparse=abbs, abbprint=pmap, privabbs,...} = grm +fun disable_abbrev_printing s (g as TYG grm) = let + val (thyopt, nm) = break_qident s + fun rmprints namecheck g = + let + val pmap' = + TypeNet.fold (fn (ty, (tstamp, knm), acc) => + if namecheck knm then acc + else TypeNet.insert(acc,ty, (tstamp, knm))) + TypeNet.empty + (abbprintmap g) + in + fupdate_abbprint (K pmap') g + end in - case Binarymap.peek (privabbs, s) of - NONE => arg - | SOME thy => let - val knm = {Name = s, Thy = thy} - in - case Binarymap.peek(abbs, knm) of - NONE => arg - | SOME st => let - val ty = structure_to_type st - val (pmap', (_,knm')) = TypeNet.delete(pmap, ty) - in - if knm = knm' then fupdate_abbprint (K pmap') arg - else arg - end handle Binarymap.NotFound => arg - end + case thyopt of + NONE => rmprints (fn knm => #Name knm = nm) g + | SOME thy => rmprints (fn knm => knm = {Name = nm, Thy = thy}) g end + (* ---------------------------------------------------------------------- min grammar diff --git a/src/parse/type_pp.sml b/src/parse/type_pp.sml index 934293132c..7b7daae1ae 100644 --- a/src/parse/type_pp.sml +++ b/src/parse/type_pp.sml @@ -131,7 +131,12 @@ fun pp_type0 (G:grammar) backend = let let fun realtype ty = let val {Thy,Tyop,...} = dest_thy_type ty in Thy ^ "$" ^ Tyop end - val {Tyop, Args, Thy = thyopt} = type_grammar.abb_dest_type G ty + val {Tyop = abop, Args = abargs, Thy = thyopt} = + type_grammar.abb_dest_type G ty + val abop_s = + case thyopt of + NONE => abop + | SOME thy => KernelSig.name_toString {Thy = thy, Name = abop} fun tooltip () = let val abbs = type_grammar.abbreviations G @@ -156,23 +161,23 @@ fun pp_type0 (G:grammar) backend = let end in case thyopt of - SOME thy => + SOME thy => (* unprivileged abbrev *) let - val knm = {Thy = thy, Name = Tyop} + val knm = {Thy = thy, Name = abop} in case Binarymap.peek (abbs, knm) of - NONE => realtype ty + NONE => realtype ty (* probably shouldn't happen *) | SOME st => doabbrev st end | NONE => let val privabbs = type_grammar.privileged_abbrevs G in - case Binarymap.peek (privabbs, Tyop) of + case Binarymap.peek (privabbs, abop) of NONE => realtype ty | SOME thy => let - val knm = {Thy = thy, Name = Tyop} + val knm = {Thy = thy, Name = abop} in case Binarymap.peek (abbs, knm) of NONE => raise Fail "Very confused tyabbrev" @@ -181,7 +186,7 @@ fun pp_type0 (G:grammar) backend = let end end fun print_args grav0 args = let - val parens_needed = case Args of [_] => false | _ => true + val parens_needed = case args of [_] => false | _ => true val grav = if parens_needed then Top else grav0 in pbegin parens_needed; @@ -192,7 +197,7 @@ fun pp_type0 (G:grammar) backend = let pend parens_needed end fun print_ghastly () = let - val {Thy,Tyop,...} = dest_thy_type ty + val {Thy,Tyop,Args} = dest_thy_type ty in add_string "("; begin_block INCONSISTENT 0; @@ -204,24 +209,24 @@ fun pp_type0 (G:grammar) backend = let end val {Thy, Tyop = realTyop, Args = realArgs} = dest_thy_type ty in - if Tyop = "cart" andalso length Args = 2 andalso + if abop = "cart" andalso length abargs = 2 andalso Thy = "fcp" andalso realTyop = "cart" andalso !pp_array_types then - (pr_ty pps (hd Args) Sfx (depth - 1); + (pr_ty pps (hd realArgs) Sfx (depth - 1); add_string "["; - pr_ty pps (hd (tl Args)) Top (depth - 1); + pr_ty pps (hd (tl realArgs)) Top (depth - 1); add_string "]") else - case Args of + case abargs of [] => let in - case lookup_tyop Tyop of + case lookup_tyop abop of NONE => print_ghastly () - | _ => add_ann_string (Tyop, TyOp tooltip) + | _ => add_ann_string (abop_s, TyOp tooltip) end | [arg1, arg2] => (let - val rule = valOf (lookup_tyop Tyop) + val rule = valOf (lookup_tyop abop) in case rule of SR => let @@ -230,9 +235,9 @@ fun pp_type0 (G:grammar) backend = let (* knowing that there are two args, we know that they will be printed with parentheses, so the gravity we pass in here makes no difference. *) - print_args Top Args; + print_args Top abargs; add_break(1,0); - add_ann_string (Tyop, TyOp tooltip); + add_ann_string (abop_s, TyOp tooltip); end_block() end | IR(prec, assoc, printthis) => let @@ -258,14 +263,14 @@ fun pp_type0 (G:grammar) backend = let end handle Option => print_ghastly()) | _ => let in - case lookup_tyop Tyop of + case lookup_tyop abop of NONE => print_ghastly() | SOME _ => let in begin_block INCONSISTENT 0; - print_args Sfx Args; + print_args Sfx abargs; add_break(1,0); - add_ann_string (Tyop, TyOp tooltip); + add_ann_string (abop_s, TyOp tooltip); end_block() end end From 507ec74ff0240d51f5dbd5aa5cf3a2d64cbd0524 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 22 Sep 2015 12:12:23 +1000 Subject: [PATCH 503/718] Document build's kernel and sequence selection options [ci skip] --- Manual/Developers/developers.md | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/Manual/Developers/developers.md b/Manual/Developers/developers.md index 0f4be7fbf9..fc5086cef7 100644 --- a/Manual/Developers/developers.md +++ b/Manual/Developers/developers.md @@ -88,7 +88,29 @@ There are two standard ways to the install a test that can be run by `build`: As explained in the documentation at the head of `tools/build-sequence`, the name of this directory should be preceded by as many exclamation mark characters\ (`!`) as its desired selftest level. Using this approach is necessary if the tests need to examine behaviours to do with theory export and loading. +## Kernel Selection +There are currently three kernels that can be built to underlie a HOL installation. +The *standard kernel* uses a de\ Bruijn representation for terms, with bound variables represented as numbers. +Free variables are represented as a pair of name and type. +This kernel also implements explicit substitutions internally, allowing for efficient call-by-value execution with tools such as `EVAL`. +This kernel is the default choice, and can be explicitly selected by passing the `-stdknl` option to `build`. + +The *experimental kernel* uses name-type pairs for all sorts of variables. +This means that the functions `mk_abs` and `dest_abs` operate in constant time. +(In the standard kernel, these functions must switch between de\ Bruijn indices and free variables in the body when called, making them run in time linear in the size of the body.) +The experimental kernel can be selected by passing the `-expk` option to `build`. + +The *OpenTheory kernel* is based on the experimental kernel, but adds proof-logging to the primitive inference rules so that OpenTheory theory packages can be exported from HOL. +This kernel can be selected by passing the `-otknl` option to `build`. + +## Build Sequences + +When `build` runs, it choreographs its calls to `Holmake` by referring to a specified sequence of directories. +By default this sequence is that specified in the file `tools/build-sequence`, which in turn refers to other files *via* `#include` directives. +It is possible to provide a different sequence by using the `-seq` commandline option to `build`. +Such sequences can be constructed more easily be referring to sequence fragments in the `tools/sequences` directory, and including these with `#include` commands. +The details of the required format for sequence files is spelled out in a comment at the head of the `tools/build-sequence` file. # Sources and Their Organisation {#sources} From 0c595d323d050e397ce256b876e9758e3c01b619 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 22 Sep 2015 17:34:32 +1000 Subject: [PATCH 504/718] Detect availability of polyc at config time Work towards issue #292 --- tools-poly/Holmake/unix-systeml.sml | 1 + tools-poly/configure.sml | 4 ++++ tools-poly/smart-configure.sml | 16 +++++++++++++--- tools/Holmake/Systeml.sig | 1 + tools/Holmake/unix-systeml.sml | 1 + tools/Holmake/winNT-systeml.sml | 1 + 6 files changed, 21 insertions(+), 3 deletions(-) diff --git a/tools-poly/Holmake/unix-systeml.sml b/tools-poly/Holmake/unix-systeml.sml index 02a78010a6..93cdc0941c 100644 --- a/tools-poly/Holmake/unix-systeml.sml +++ b/tools-poly/Holmake/unix-systeml.sml @@ -88,6 +88,7 @@ val MOSMLDIR = "" val HAVE_BASIS2002 = false val POLYMLLIBDIR = "" val POLY = "" +val POLYC = NONE val POLY_LDFLAGS = [] val POLY_LDFLAGS_STATIC = [] val CC = "" diff --git a/tools-poly/configure.sml b/tools-poly/configure.sml index cf3c6fe455..6efd1083bd 100644 --- a/tools-poly/configure.sml +++ b/tools-poly/configure.sml @@ -200,6 +200,9 @@ fun systeml x = (print "Systeml not correctly loaded.\n"; val mk_xable = systeml; val xable_string = systeml; +fun optquote NONE = "NONE" + | optquote (SOME p) = "SOME " ^ quote p + val OSkind = if OS="linux" orelse OS="solaris" orelse OS="macosx" then "unix" else OS val _ = let @@ -214,6 +217,7 @@ in ["val HOLDIR =" --> ("val HOLDIR = "^quote holdir^"\n"), "val POLYMLLIBDIR =" --> ("val POLYMLLIBDIR = "^quote polymllibdir^"\n"), "val POLY =" --> ("val POLY = "^quote poly^"\n"), + "val POLYC =" --> ("val POLYC = "^optquote polyc^"\n"), "val POLY_LDFLAGS =" --> ("val POLY_LDFLAGS = ["^ (String.concatWith ", " diff --git a/tools-poly/smart-configure.sml b/tools-poly/smart-configure.sml index d226da9755..fb8fd0081c 100644 --- a/tools-poly/smart-configure.sml +++ b/tools-poly/smart-configure.sml @@ -37,6 +37,9 @@ in end val check_poly = check_dir "poly" [OS.FileSys.A_EXEC] val check_libpoly = check_dir "libpolymain.a" [OS.FileSys.A_READ] +fun check_polyc c = + Option.map (fn p => OS.Path.concat(p,"polyc")) + (check_dir "polyc" [OS.FileSys.A_EXEC] c) fun findpartial f [] = NONE | findpartial f (h::t) = @@ -60,6 +63,7 @@ fun determining s = print "\nHOL smart configuration.\n\n"; val poly = "" +val polyc = NONE : string option val polymllibdir = ""; val DOT_PATH = ""; @@ -126,7 +130,7 @@ val polyinstruction = \properly.\n\ \This file should include a line of the form\n\n\ \ val poly = \"path-to-poly\";" -val poly = +val (poly,polyc) = if poly = "" then let val _ = determining "poly" val nm = CommandLine.name() @@ -155,7 +159,7 @@ val poly = | SOME c => let in case check_poly c of - SOME p => OS.Path.concat(p,"poly") + SOME p => (OS.Path.concat(p,"poly"), check_polyc p) | NONE => die ("\n\nI tried to figure out where your poly executable is\ \n\by examining your command-line.\n\ @@ -171,7 +175,7 @@ val poly = ^poly^ "'\nas the location of the poly executable.\n"^ polyinstruction) - | SOME p => OS.Path.concat(p, "poly") + | SOME p => (OS.Path.concat(p, "poly"), check_polyc p) val polylibsister = let val p as {arcs,isAbs,vol} = OS.Path.fromString poly @@ -225,8 +229,14 @@ fun verdict (prompt, value) = print value; print "\n"); +fun optverdict (prompt, optvalue) = + (print (StringCvt.padRight #" " 20 (prompt ^ ":")); + print (case optvalue of NONE => "NONE" | SOME p => "SOME "^p); + print "\n"); + verdict ("OS", OS); verdict ("poly", poly); +optverdict ("polyc", polyc); verdict ("polymllibdir", polymllibdir); verdict ("holdir", holdir); verdict ("DOT_PATH", DOT_PATH); diff --git a/tools/Holmake/Systeml.sig b/tools/Holmake/Systeml.sig index 87ccfb31ec..786a5a848f 100644 --- a/tools/Holmake/Systeml.sig +++ b/tools/Holmake/Systeml.sig @@ -19,6 +19,7 @@ sig val HOLDIR : string val POLYMLLIBDIR : string val POLY : string + val POLYC : string option val POLY_LDFLAGS : string list val POLY_LDFLAGS_STATIC : string list val CC : string diff --git a/tools/Holmake/unix-systeml.sml b/tools/Holmake/unix-systeml.sml index e688666cd4..494a67cf2d 100644 --- a/tools/Holmake/unix-systeml.sml +++ b/tools/Holmake/unix-systeml.sml @@ -91,6 +91,7 @@ val MOSMLDIR = "" val HAVE_BASIS2002 = false val OS = "" val POLY = "" +val POLYC = NONE val POLYMLLIBDIR = "" val POLY_LDFLAGS = [] val POLY_LDFLAGS_STATIC = [] diff --git a/tools/Holmake/winNT-systeml.sml b/tools/Holmake/winNT-systeml.sml index c282995bca..c5af11ed14 100644 --- a/tools/Holmake/winNT-systeml.sml +++ b/tools/Holmake/winNT-systeml.sml @@ -84,6 +84,7 @@ val MOSMLDIR = "" val HAVE_BASIS2002 = "" val OS = "" val POLY = "" +val POLYC = NONE val POLYMLLIBDIR = "" val POLY_LDFLAGS = [] val POLY_LDFLAGS_STATIC = [] From d3ecf896b55afba105af8474dc899863c2c2c477 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 22 Sep 2015 17:36:29 +1000 Subject: [PATCH 505/718] Refactor Holmake sources to allow polyc compile Next step is to actually use polyc from configure script when it's available. Work towards issue #292 --- tools-poly/Holmake/poly-Holmake-core.ML | 32 ++++++++++++++++++++++ tools-poly/Holmake/poly-Holmake.ML | 35 +++---------------------- 2 files changed, 35 insertions(+), 32 deletions(-) create mode 100644 tools-poly/Holmake/poly-Holmake-core.ML diff --git a/tools-poly/Holmake/poly-Holmake-core.ML b/tools-poly/Holmake/poly-Holmake-core.ML new file mode 100644 index 0000000000..9879900910 --- /dev/null +++ b/tools-poly/Holmake/poly-Holmake-core.ML @@ -0,0 +1,32 @@ +val _ = PolyML.Compiler.prompt1:=""; +val _ = PolyML.Compiler.prompt2:=""; +val _ = PolyML.print_depth 0; +val _ = use "poly/poly-init.ML"; + +structure BasicIO = SML90; +exception Interrupt = SML90.Interrupt + +fun useH f = + (use ("Holmake/" ^ f ^ ".sig"); + use ("Holmake/" ^ f ^ ".sml")); + +fun useC f = + (use ("../tools/Holmake/" ^ f ^ ".sig"); + use ("../tools/Holmake/" ^ f ^ ".sml")) + +val _ = use "../tools/Holmake/Systeml.sig" +val _ = use "Holmake/Systeml.sml"; + +val _ = useC "Holdep_tokens"; +val _ = useC "Holdep"; + +val _ = useC "regexpMatch"; +val _ = useC "parse_glob"; +val _ = useC "internal_functions"; +val _ = useC "Holmake_types"; +val _ = useC "Holmake_tools"; +val _ = useC "ReadHMF"; + +val _ = use "Holmake/Holmake.sml"; + +fun main() = Holmake.main() diff --git a/tools-poly/Holmake/poly-Holmake.ML b/tools-poly/Holmake/poly-Holmake.ML index 8273cea522..95877013ab 100644 --- a/tools-poly/Holmake/poly-Holmake.ML +++ b/tools-poly/Holmake/poly-Holmake.ML @@ -1,33 +1,4 @@ -val _ = PolyML.Compiler.prompt1:=""; -val _ = PolyML.Compiler.prompt2:=""; -val _ = PolyML.print_depth 0; -val _ = use "poly/poly-init.ML"; +val _ = use "Holmake/poly-Holmake-core.ML"; -structure BasicIO = SML90; -exception Interrupt = SML90.Interrupt - -fun useH f = - (use ("Holmake/" ^ f ^ ".sig"); - use ("Holmake/" ^ f ^ ".sml")); - -fun useC f = - (use ("../tools/Holmake/" ^ f ^ ".sig"); - use ("../tools/Holmake/" ^ f ^ ".sml")) - -val _ = use "../tools/Holmake/Systeml.sig" -val _ = use "Holmake/Systeml.sml"; - -val _ = useC "Holdep_tokens"; -val _ = useC "Holdep"; - -val _ = useC "regexpMatch"; -val _ = useC "parse_glob"; -val _ = useC "internal_functions"; -val _ = useC "Holmake_types"; -val _ = useC "Holmake_tools"; -val _ = useC "ReadHMF"; - -val _ = use "Holmake/Holmake.sml"; - -val _ = PolyML.shareCommonData Holmake.main; -val _ = PolyML.export ("Holmake/Holmake", Holmake.main); +val _ = PolyML.shareCommonData main; +val _ = PolyML.export ("Holmake/Holmake", main); From 6117e390b578e62528e1e5a9534aaa98e3f3291b Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 23 Sep 2015 10:59:05 +1000 Subject: [PATCH 506/718] Systeml's mk_xable returns status, not string It previously used to return the string of the executable version of the file. On Windows, this makes sense because making things executable consists of adding the string ".exe", changing the filename. But we already have the xable_string function for doing this calculation. --- tools-poly/Holmake/unix-systeml.sml | 10 +++++++--- tools/Holmake/Holmake.sml | 5 ++++- tools/Holmake/Systeml.sig | 7 ++++--- tools/Holmake/unix-systeml.sml | 10 +++++++--- tools/Holmake/winNT-systeml.sml | 4 ++-- 5 files changed, 24 insertions(+), 12 deletions(-) diff --git a/tools-poly/Holmake/unix-systeml.sml b/tools-poly/Holmake/unix-systeml.sml index 93cdc0941c..69a13c15a0 100644 --- a/tools-poly/Holmake/unix-systeml.sml +++ b/tools-poly/Holmake/unix-systeml.sml @@ -64,15 +64,19 @@ in fun xable_string s = s fun mk_xable file = - if Process.isSuccess (systeml ["chmod", "a+x", file]) then file + let + val r = systeml ["chmod", "a+x", file] + in + if Process.isSuccess r then r else if FileSys.access (file,[FileSys.A_EXEC]) then (* if we can execute it, then continue with a warning *) (* NB: MoSML docs say FileSys.access uses real uid/gid, not effective uid/gid, so this test may be bogus if we are setuid. This is unlikely(!). *) (print ("Non-fatal warning: couldn't set world execute permission on "^file^",\n but continuing anyway since at least the current user has execute permission.\n"); - file) + OS.Process.success) else (print ("unable to set execute permission on "^file^".\n"); - raise Fail "mk_xable") + OS.Process.failure) + end fun normPath s = Path.toString(Path.fromString s) diff --git a/tools/Holmake/Holmake.sml b/tools/Holmake/Holmake.sml index 4ba6f32955..43cee63b06 100644 --- a/tools/Holmake/Holmake.sml +++ b/tools/Holmake/Holmake.sml @@ -719,7 +719,10 @@ in if isSuccess (compile debug (include_flags @ ["-o", script] @ objectfiles)) then let - val script' = Systeml.mk_xable script + val status = Systeml.mk_xable script + val _ = OS.Process.isSuccess status orelse + die_with ("Couldn't make script "^script^" executable") + val script' = xable_string script val thysmlfile = s^"Theory.sml" val thysigfile = s^"Theory.sig" fun safedelete s = FileSys.remove s handle OS.SysErr _ => () diff --git a/tools/Holmake/Systeml.sig b/tools/Holmake/Systeml.sig index 786a5a848f..3a173527a2 100644 --- a/tools/Holmake/Systeml.sig +++ b/tools/Holmake/Systeml.sig @@ -6,12 +6,13 @@ sig val exec : string * string list -> 'a val protect : string -> string val xable_string : string -> string - val mk_xable : string -> string + val mk_xable : string -> OS.Process.status (* first argument to these are the name of the desired executable, the second is the name of the post-initialisation script to run. *) - val emit_hol_script : string -> string -> string list -> string - val emit_hol_unquote_script : string -> string -> string list -> string + val emit_hol_script : string -> string -> string list -> OS.Process.status + val emit_hol_unquote_script : string -> string -> string list -> + OS.Process.status val find_my_path : unit -> string diff --git a/tools/Holmake/unix-systeml.sml b/tools/Holmake/unix-systeml.sml index 494a67cf2d..ac2504dcb0 100644 --- a/tools/Holmake/unix-systeml.sml +++ b/tools/Holmake/unix-systeml.sml @@ -67,15 +67,19 @@ in fun xable_string s = s fun mk_xable file = - if Process.isSuccess (systeml ["chmod", "a+x", file]) then file + let + val r = systeml ["chmod", "a+x", file] + in + if Process.isSuccess r then r else if FileSys.access (file,[FileSys.A_EXEC]) then (* if we can execute it, then continue with a warning *) (* NB: MoSML docs say FileSys.access uses real uid/gid, not effective uid/gid, so this test may be bogus if we are setuid. This is unlikely(!). *) (print ("Non-fatal warning: couldn't set world execute permission on "^file^",\n but continuing anyway since at least the current user has execute permission.\n"); - file) + OS.Process.success) else (print ("unable to set execute permission on "^file^".\n"); - raise Fail "mk_xable") + OS.Process.failure) + end fun normPath s = Path.toString(Path.fromString s) diff --git a/tools/Holmake/winNT-systeml.sml b/tools/Holmake/winNT-systeml.sml index c5af11ed14..42fe9a2c3b 100644 --- a/tools/Holmake/winNT-systeml.sml +++ b/tools/Holmake/winNT-systeml.sml @@ -38,12 +38,12 @@ val protect = dquote fun system_ps s = Process.system ("call " ^ s) fun xable_string s = s^".exe" -fun mk_xable file = (* returns the name of the executable *) +fun mk_xable file = let val exe = file^".exe" val _ = FileSys.remove exe handle _ => () in FileSys.rename{old=file, new=exe}; - exe + OS.Process.success end fun normPath s = Path.toString(Path.fromString s) From d95e7fd1a9997f4d81ed6b259bfd594584f5435b Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 23 Sep 2015 12:18:42 +1000 Subject: [PATCH 507/718] Use polyc for all compilation in configure.sml I don't think I can use polyc in the creation of a new heap that is done within buildheap though, which means that I believe we still have to tell users to build poly with --enable-shared. Progress with #292 --- tools-poly/Holmake/poly-Holmake-core.ML | 32 ---- tools-poly/Holmake/poly-Holmake.ML | 34 +++- tools-poly/buildheap.ML | 6 +- tools-poly/configure.sml | 198 +++++++++++------------- tools-poly/heapname.ML | 5 - tools-poly/poly-build.ML | 3 +- tools/Holmake/poly-holdeptool.ML | 3 +- tools/mllex/poly-mllex.ML | 5 - tools/mlyacc/{ => src}/poly-mlyacc.ML | 11 +- tools/quote-filter/poly-unquote.ML | 4 - 10 files changed, 128 insertions(+), 173 deletions(-) delete mode 100644 tools-poly/Holmake/poly-Holmake-core.ML rename tools/mlyacc/{ => src}/poly-mlyacc.ML (79%) diff --git a/tools-poly/Holmake/poly-Holmake-core.ML b/tools-poly/Holmake/poly-Holmake-core.ML deleted file mode 100644 index 9879900910..0000000000 --- a/tools-poly/Holmake/poly-Holmake-core.ML +++ /dev/null @@ -1,32 +0,0 @@ -val _ = PolyML.Compiler.prompt1:=""; -val _ = PolyML.Compiler.prompt2:=""; -val _ = PolyML.print_depth 0; -val _ = use "poly/poly-init.ML"; - -structure BasicIO = SML90; -exception Interrupt = SML90.Interrupt - -fun useH f = - (use ("Holmake/" ^ f ^ ".sig"); - use ("Holmake/" ^ f ^ ".sml")); - -fun useC f = - (use ("../tools/Holmake/" ^ f ^ ".sig"); - use ("../tools/Holmake/" ^ f ^ ".sml")) - -val _ = use "../tools/Holmake/Systeml.sig" -val _ = use "Holmake/Systeml.sml"; - -val _ = useC "Holdep_tokens"; -val _ = useC "Holdep"; - -val _ = useC "regexpMatch"; -val _ = useC "parse_glob"; -val _ = useC "internal_functions"; -val _ = useC "Holmake_types"; -val _ = useC "Holmake_tools"; -val _ = useC "ReadHMF"; - -val _ = use "Holmake/Holmake.sml"; - -fun main() = Holmake.main() diff --git a/tools-poly/Holmake/poly-Holmake.ML b/tools-poly/Holmake/poly-Holmake.ML index 95877013ab..d6ae412da3 100644 --- a/tools-poly/Holmake/poly-Holmake.ML +++ b/tools-poly/Holmake/poly-Holmake.ML @@ -1,4 +1,32 @@ -val _ = use "Holmake/poly-Holmake-core.ML"; +val _ = PolyML.Compiler.prompt1:=""; +val _ = PolyML.Compiler.prompt2:=""; +val _ = PolyML.print_depth 0; +OS.FileSys.chDir ".."; +val _ = use "poly/poly-init.ML"; +OS.FileSys.chDir "Holmake"; -val _ = PolyML.shareCommonData main; -val _ = PolyML.export ("Holmake/Holmake", main); +structure BasicIO = SML90; +exception Interrupt = SML90.Interrupt + +fun useH f = (use (f ^ ".sig"); use (f ^ ".sml")); + +fun useC f = + (use ("../../tools/Holmake/" ^ f ^ ".sig"); + use ("../../tools/Holmake/" ^ f ^ ".sml")) + +val _ = use "../../tools/Holmake/Systeml.sig" +val _ = use "Systeml.sml"; + +val _ = useC "Holdep_tokens"; +val _ = useC "Holdep"; + +val _ = useC "regexpMatch"; +val _ = useC "parse_glob"; +val _ = useC "internal_functions"; +val _ = useC "Holmake_types"; +val _ = useC "Holmake_tools"; +val _ = useC "ReadHMF"; + +val _ = use "Holmake.sml"; + +fun main() = Holmake.main(); diff --git a/tools-poly/buildheap.ML b/tools-poly/buildheap.ML index f17e2a9dc5..1f5232d08c 100644 --- a/tools-poly/buildheap.ML +++ b/tools-poly/buildheap.ML @@ -69,8 +69,8 @@ in system_ps ("cc -o " ^ outputheap ^ " " ^ outputheap^".o" ^ " " ^ String.concatWith " " POLY_LDFLAGS); OS.FileSys.remove (outputheap^".o") - handle OS.SysErr(msg, _) => - warn ("Couldn't remove "^outputheap^".o: "^msg) + handle OS.SysErr(msg, _) => + warn ("Couldn't remove "^outputheap^".o: "^msg) end @@ -87,5 +87,3 @@ fun main() = let in create_heap (objs, output, base) end -val _ = PolyML.shareCommonData main; -val _ = PolyML.export ("buildheap", ignore o main); diff --git a/tools-poly/configure.sml b/tools-poly/configure.sml index 6efd1083bd..04210c6d7d 100644 --- a/tools-poly/configure.sml +++ b/tools-poly/configure.sml @@ -83,10 +83,25 @@ in else [] end; +fun echo s = (TextIO.output(TextIO.stdOut, s^"\n"); + TextIO.flushOut TextIO.stdOut); + +val verbose = false + +val echov = if verbose then echo else (fn _ => ()) + fun compile systeml exe obj = - (systeml ([CC, "-o", exe, obj, "-L" ^ polymllibdir, - "-lpolymain", "-lpolyml"] @ machine_flags); - OS.FileSys.remove obj); + let + val args = [CC, "-o", exe, obj, "-L" ^ polymllibdir, + "-lpolymain", "-lpolyml"] @ machine_flags + in + echov (String.concatWith " " args ^ "\n"); + systeml args before OS.FileSys.remove obj + end + +fun liftstatus f x = + if OS.Process.isSuccess (f x) then () + else raise Fail "Command failed" (*--------------------------------------------------------------------------- END user-settable parameters @@ -294,15 +309,6 @@ in print "sml)\n" end; - - -(*--------------------------------------------------------------------------- - String and path operations. - ---------------------------------------------------------------------------*) - -fun echo s = (TextIO.output(TextIO.stdOut, s^"\n"); - TextIO.flushOut TextIO.stdOut); - val _ = echo "Beginning configuration."; (* ---------------------------------------------------------------------- @@ -327,19 +333,18 @@ fun die s = (print s; print "\n"; Process.exit Process.failure) local val cdir = FileSys.getDir() - val systeml = fn clist => if not (Process.isSuccess (systeml clist)) then - raise (Fail "") - else () + val systeml = liftstatus systeml + val system_ps = liftstatus system_ps val toolsdir = fullPath [holdir, "tools-poly"] val lexdir = fullPath [holdir, "tools", "mllex"] - val yaccdir = fullPath [holdir, "tools", "mlyacc"] + val yaccdir = fullPath [holdir, "tools", "mlyacc", "src"] val qfdir = fullPath [holdir, "tools", "quote-filter"] val hmakedir = fullPath [toolsdir, "Holmake"] val hmakebin = fullPath [holdir, "bin", "Holmake"] val buildbin = fullPath [holdir, "bin", "build"] val qfbin = fullPath [holdir, "bin", "unquote"] val lexer = fullPath [lexdir, "mllex.exe"] - val yaccer = fullPath [yaccdir, "src", "mlyacc.exe"] + val yaccer = fullPath [yaccdir, "mlyacc.exe"] fun copyfile from to = let val instrm = BinIO.openIn from val ostrm = BinIO.openOut to @@ -364,98 +369,75 @@ val _ = remove (fullPath [hmakedir, "Parser.grm.sig"]); val _ = remove (fullPath [hmakedir, "Parser.grm.sml"]); -(* ---------------------------------------------------------------------- - Compile our local copy of mllex - ---------------------------------------------------------------------- *) -val _ = - (echo "Making tools/mllex/mllex.exe."; - FileSys.chDir lexdir; - system_ps (POLY ^ " < poly-mllex.ML"); - compile systeml "mllex.exe" "mllex.o"; - mk_xable "../../tools/mllex/mllex.exe"; - FileSys.chDir cdir) - handle _ => die "Failed to build mllex."; - -(* ---------------------------------------------------------------------- - Compile our local copy of mlyacc - ---------------------------------------------------------------------- *) -val _ = - (echo "Making tools/mlyacc/mlyacc.exe."; - FileSys.chDir yaccdir; - FileSys.chDir "src"; - systeml [lexer, "yacc.lex"]; - FileSys.chDir yaccdir; - system_ps (POLY ^ " < poly-mlyacc.ML"); - compile systeml yaccer "mlyacc.o"; - mk_xable "../../tools/mlyacc/src/mlyacc.exe"; - FileSys.chDir cdir) - handle _ => die "Failed to build mlyacc."; - -(* ---------------------------------------------------------------------- - Compile quote-filter - ---------------------------------------------------------------------- *) -val _ = - (echo "Making bin/unquote."; - FileSys.chDir qfdir; - systeml [lexer, "filter"]; - system_ps (POLY ^ " < poly-unquote.ML"); - compile systeml qfbin "unquote.o"; - FileSys.chDir cdir) - handle _ => die "Failed to build unquote."; - -(*--------------------------------------------------------------------------- - Compile Holmake (bypassing the makefile in directory Holmake), then - put the executable bin/Holmake. - ---------------------------------------------------------------------------*) -val _ = - (echo "Making bin/Holmake"; - FileSys.chDir toolsdir; - system_ps (POLY ^ " < " ^ fullPath ["Holmake", "poly-Holmake.ML"]); - compile systeml hmakebin (fullPath ["Holmake", "Holmake.o"]); - FileSys.chDir (fullPath [HOLDIR, "tools", "Holmake"]); - system_ps (POLY ^ " < poly-holdeptool.ML"); - compile systeml - (fullPath [HOLDIR, "bin", "holdeptool.exe"]) - (fullPath [HOLDIR, "tools", "Holmake", "holdeptool.o"]); - FileSys.chDir cdir) - handle _ => die "Failed to build Holmake."; - -(*--------------------------------------------------------------------------- - Compile build.sml, and put it in bin/build. - ---------------------------------------------------------------------------*) -val _ = - (echo "Making bin/build."; - FileSys.chDir toolsdir; - system_ps (POLY ^ " < poly-build.ML"); - compile systeml buildbin "build.o"; - FileSys.chDir cdir) - handle _ => die "Failed to build build."; - -(* ---------------------------------------------------------------------- - Generate heapname executable - ---------------------------------------------------------------------- *) - -val _ = let -in - echo "Making bin/heapname utility"; - FileSys.chDir toolsdir; - system_ps (POLY ^ " < heapname.ML"); - compile systeml (fullPath [HOLDIR,"bin","heapname"]) "heapname.o"; - FileSys.chDir cdir -end handle _ => die "Failed to build heapname." - -(* ---------------------------------------------------------------------- - Generate buildheap executable - ---------------------------------------------------------------------- *) -val _ = let -in - echo "Making bin/buildheap utility"; - FileSys.chDir toolsdir; - system_ps (POLY ^ " < buildheap.ML"); - compile systeml (fullPath [HOLDIR, "bin", "buildheap"]) "buildheap.o"; - FileSys.chDir cdir -end handle _ => die "Failed to build buildheap." +fun fakepolyc src tgt = + let + val cline = + "echo 'use \"" ^ src ^ "\"; PolyML.export(\"" ^ tgt ^ "\", main);' | " ^ + POLY ^ " -q --error-exit" + in + echov cline; + system_ps cline; + compile systeml tgt (tgt ^ ".o") + end +val maybe_polyc_compile = + case POLYC of + NONE => fakepolyc + | SOME pc => (fn s => fn tgt => + let + val cline = pc ^ " -o " ^ tgt ^ " " ^ s + in + echov cline; + system_ps cline + end) + + +fun work_in_dir tgtname d f = + (echo ("Making " ^ tgtname); FileSys.chDir d; f(); FileSys.chDir cdir) + handle _ => die ("Failed to make "^tgtname) + +(* mllex *) +val _ = work_in_dir "mllex" + lexdir + (fn () => maybe_polyc_compile "poly-mllex.ML" "mllex.exe") + +(* mlyacc *) +val _ = work_in_dir + "mlyacc" yaccdir + (fn () => (systeml [lexer, "yacc.lex"]; + maybe_polyc_compile "poly-mlyacc.ML" "mlyacc.exe")) + +(* unquote - the quotation filter *) +val _ = work_in_dir "unquote." qfdir + (fn () => (systeml [lexer, "filter"]; + maybe_polyc_compile "poly-unquote.ML" qfbin)) + +(* Holmake *) +val _ = work_in_dir "Holmake" hmakedir + (fn () => maybe_polyc_compile "poly-Holmake.ML" hmakebin) + +(* holdeptool *) +val _ = work_in_dir "holdeptool" (fullPath [HOLDIR, "tools", "Holmake"]) + (fn () => + maybe_polyc_compile + "poly-holdeptool.ML" + (fullPath [HOLDIR, "bin", "holdeptool.exe"])) + +(* build *) +val _ = work_in_dir "build" toolsdir + (fn () => maybe_polyc_compile "poly-build.ML" buildbin) + +(* heapname *) +val _ = work_in_dir + "heapname" toolsdir + (fn () => maybe_polyc_compile "heapname.ML" + (fullPath [HOLDIR,"bin","heapname"])) + +(* buildheap *) +val _ = work_in_dir + "buildheap" toolsdir + (fn () => maybe_polyc_compile "buildheap.ML" + (fullPath [HOLDIR, "bin", "buildheap"])) end (* local *) diff --git a/tools-poly/heapname.ML b/tools-poly/heapname.ML index 8ee088b129..a40685876f 100644 --- a/tools-poly/heapname.ML +++ b/tools-poly/heapname.ML @@ -1,4 +1,3 @@ -(* this is an -*- sml -*- file *) val _ = PolyML.Compiler.prompt1:=""; val _ = PolyML.Compiler.prompt2:=""; val _ = PolyML.print_depth 0; @@ -55,7 +54,3 @@ fun main() = let in TextIO.output(TextIO.stdOut, heap ^ "\n") end - - -val _ = PolyML.shareCommonData main -val _ = PolyML.export ("heapname", main); diff --git a/tools-poly/poly-build.ML b/tools-poly/poly-build.ML index 45a8f1acb4..d5eeb40075 100644 --- a/tools-poly/poly-build.ML +++ b/tools-poly/poly-build.ML @@ -20,5 +20,4 @@ val _ = useC "ReadHMF" val _ = use "../tools/buildutils.sig"; val _ = use "../tools/buildutils.sml"; val _ = use "build.sml"; -val _ = PolyML.shareCommonData build.main; -val _ = PolyML.export ("build", build.main); +val main = build.main diff --git a/tools/Holmake/poly-holdeptool.ML b/tools/Holmake/poly-holdeptool.ML index 735ab523e4..fb0ac98096 100644 --- a/tools/Holmake/poly-holdeptool.ML +++ b/tools/Holmake/poly-holdeptool.ML @@ -7,5 +7,4 @@ use "Holdep_tokens.sig"; use "Holdep_tokens.sml"; use "holdeptool.sml"; -val _ = PolyML.shareCommonData holdeptool.main -val _ = PolyML.export("holdeptool", holdeptool.main) +val main = holdeptool.main diff --git a/tools/mllex/poly-mllex.ML b/tools/mllex/poly-mllex.ML index 726a8560f9..3964bed797 100644 --- a/tools/mllex/poly-mllex.ML +++ b/tools/mllex/poly-mllex.ML @@ -1,4 +1,3 @@ -(* this is an -*- sml -*- file *) val _ = PolyML.Compiler.prompt1:=""; val _ = PolyML.Compiler.prompt2:=""; val _ = PolyML.print_depth 0; @@ -12,7 +11,3 @@ in OS.Process.exit OS.Process.failure) | args => List.app LexGen.lexGen args end; - -val _ = PolyML.shareCommonData main; -val _ = PolyML.export("mllex", main); - diff --git a/tools/mlyacc/poly-mlyacc.ML b/tools/mlyacc/src/poly-mlyacc.ML similarity index 79% rename from tools/mlyacc/poly-mlyacc.ML rename to tools/mlyacc/src/poly-mlyacc.ML index afacc90274..ae132f0840 100644 --- a/tools/mlyacc/poly-mlyacc.ML +++ b/tools/mlyacc/src/poly-mlyacc.ML @@ -1,7 +1,7 @@ val _ = PolyML.Compiler.prompt1:=""; val _ = PolyML.Compiler.prompt2:=""; val _ = PolyML.print_depth 0; -fun u f = use ("mlyacclib/" ^ f ^ ".sml"); +fun u f = use ("../mlyacclib/" ^ f ^ ".sml"); val _ = u "MLY_base-sig"; val _ = u "MLY_join"; @@ -9,7 +9,7 @@ val _ = u "MLY_lrtable"; val _ = u "MLY_stream"; val _ = u "MLY_parser2"; -fun u f = use ("src/" ^ f ^ ".sml"); +fun u f = use (f ^ ".sml"); val _ = u "utils-sig"; val _ = u "utils"; @@ -33,11 +33,6 @@ val _ = u "absyn-sig"; val _ = u "yacc"; val _ = u "absyn"; val _ = u "link"; -val _ = use "src/poly-main.ML"; +val _ = use "poly-main.ML"; fun main () = main.main (CommandLine.arguments ()); - -val _ = PolyML.shareCommonData main; -val _ = PolyML.export ("mlyacc", main); - - diff --git a/tools/quote-filter/poly-unquote.ML b/tools/quote-filter/poly-unquote.ML index 6c7710aa9f..8285ac4b13 100644 --- a/tools/quote-filter/poly-unquote.ML +++ b/tools/quote-filter/poly-unquote.ML @@ -1,4 +1,3 @@ -(* this is an -*- sml -*- file *) val _ = PolyML.Compiler.prompt1:=""; val _ = PolyML.Compiler.prompt2:=""; val _ = PolyML.print_depth 0; @@ -52,6 +51,3 @@ in TextIO.closeOut outstream; exit success end; - -val _ = PolyML.shareCommonData main; -val _ = PolyML.export("unquote", main) From 016407b9c1e34b6a4726241e1c6c4f26e77323bb Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Wed, 23 Sep 2015 16:21:37 +1000 Subject: [PATCH 508/718] sxMEM_sizelt (moved from CakeML) --- .../formal-languages/context-free/simpleSexpScript.sml | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/examples/formal-languages/context-free/simpleSexpScript.sml b/examples/formal-languages/context-free/simpleSexpScript.sml index 8fc4f8b355..7235ed010a 100644 --- a/examples/formal-languages/context-free/simpleSexpScript.sml +++ b/examples/formal-languages/context-free/simpleSexpScript.sml @@ -67,6 +67,15 @@ val sxMEM_def = Define` sxMEM e s ⇔ ∃l. strip_sxcons s = SOME l ∧ MEM e l `; +val sexp_size_def = definition"sexp_size_def"; + +val sxMEM_sizelt = store_thm( + "sxMEM_sizelt", + ``∀s1 s2. sxMEM s1 s2 ⇒ sexp_size s1 < sexp_size s2``, + dsimp[sxMEM_def] >> Induct_on `s2` >> + dsimp[Once strip_sxcons_def, sexp_size_def] >> rpt strip_tac >> + res_tac >> simp[]); + val dstrip_sexp_def = Define` (dstrip_sexp (SX_CONS sym args) = case sym of From ecb64c3bb27b939b9afc6be9422d51970440b911 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Wed, 23 Sep 2015 16:22:21 +1000 Subject: [PATCH 509/718] define a printer for sexps, and EVAL stuff for sexpPEG the latter is mostly copied from CakeML: it would be nicer to have a generic library for generating this stuff. the printer is totally unverified at the moment. --- .../context-free/simpleSexpParseScript.sml | 111 ++++++++++++++++++ 1 file changed, 111 insertions(+) create mode 100644 examples/formal-languages/context-free/simpleSexpParseScript.sml diff --git a/examples/formal-languages/context-free/simpleSexpParseScript.sml b/examples/formal-languages/context-free/simpleSexpParseScript.sml new file mode 100644 index 0000000000..c84ea86260 --- /dev/null +++ b/examples/formal-languages/context-free/simpleSexpParseScript.sml @@ -0,0 +1,111 @@ +open HolKernel boolLib bossLib lcsymtacs finite_mapSyntax +open ASCIInumbersTheory simpleSexpTheory simpleSexpPEGTheory pegexecTheory + +val _ = new_theory"simpleSexpParse" + +val parse_sexp_def = Define` + parse_sexp s = + OPTION_BIND (destResult (peg_exec sexpPEG (pnt sxnt_sexp) s [] done failed)) + (λ(rest,sx). OPTION_IGNORE_BIND (OPTION_GUARD (rest="")) (SOME sx))`; + +(* TODO: all this is taken from cakeml/parsing, and should be made more generic *) + +val FDOM_sexpPEG_rules = save_thm("FDOM_sexpPEG_rules", + ``FDOM sexpPEG.rules`` + |> SIMP_CONV(srw_ss())[sexpPEG_def,finite_mapTheory.FUPDATE_LIST_THM]) + +val spec0 = + peg_nt_thm |> Q.GEN`G` |> Q.ISPEC`sexpPEG` + |> SIMP_RULE (srw_ss()) [FDOM_sexpPEG_rules] + |> Q.GEN`n` + +val mkNT = ``mkNT`` + +val distinct_ths = let + val ntlist = TypeBase.constructors_of ``:sexpNT`` + fun recurse [] = [] + | recurse (t::ts) = let + val eqns = map (fn t' => mk_eq(t,t')) ts + val ths0 = map (SIMP_CONV (srw_ss()) []) eqns + val ths1 = map (CONV_RULE (LAND_CONV (REWR_CONV EQ_SYM_EQ))) ths0 + in + ths0 @ ths1 @ recurse ts + end +in + recurse ntlist +end + +val rules_t = ``sexpPEG.rules`` +fun ty2frag ty = let + open simpLib + val {convs,rewrs} = TypeBase.simpls_of ty +in + merge_ss (rewrites rewrs :: map conv_ss convs) +end +(* can't use srw_ss() as it will attack the bodies of the rules, + and in particular, will destroy predicates from tok + constructors of the form + do ... od = SOME () + which matches optionTheory.OPTION_BIND_EQUALS_OPTION, putting + an existential into our rewrite thereby *) +val rules = SIMP_CONV (bool_ss ++ ty2frag ``:(α,β,γ)peg``) + [sexpPEG_def, combinTheory.K_DEF, + finite_mapTheory.FUPDATE_LIST_THM] rules_t + +val _ = print "Calculating application of sexpPEG rules\n" +val sexppeg_rules_applied = let + val app0 = finite_mapSyntax.fapply_t + val theta = + Type.match_type (type_of app0 |> dom_rng |> #1) (type_of rules_t) + val app = inst theta app0 + val app_rules = AP_TERM app rules + val sset = bool_ss ++ ty2frag ``:'a + 'b`` ++ ty2frag ``:sexpNT`` + fun mkrule t = + AP_THM app_rules ``mkNT ^t`` + |> SIMP_RULE sset + [finite_mapTheory.FAPPLY_FUPDATE_THM] + val ths = TypeBase.constructors_of ``:sexpNT`` |> map mkrule +in + save_thm("sexppeg_rules_applied", LIST_CONJ ths); + ths +end + +val sexpPEG_exec_thm = save_thm( + "sexpPEG_exec_thm", + TypeBase.constructors_of ``:sexpNT`` + |> map (fn t => ISPEC (mk_comb(mkNT, t)) spec0) + |> map (SIMP_RULE bool_ss (sexppeg_rules_applied @ distinct_ths @ + [sumTheory.INL_11])) + |> LIST_CONJ) +val _ = computeLib.add_persistent_funs ["sexpPEG_exec_thm"] +(* -- *) + +val escape_string_def = Define` + escape_string s = + case s of + | "" => "" + | #"\\"::s => "\\\\"++(escape_string s) + | #"\""::s => "\\\""++(escape_string s) + | c::s => c::(escape_string s)`; + +val print_space_separated_def = Define` + (print_space_separated [] = "") ∧ + (print_space_separated [x] = x) ∧ + (print_space_separated (x::xs) = x ++ " " ++ print_space_separated xs)`; + +val print_sexp_def = tDefine"print_sexp"` + (print_sexp (SX_SYM s) = s) ∧ + (print_sexp (SX_NUM n) = toString n) ∧ + (print_sexp (SX_STR s) = "\"" ++ escape_string s ++ "\"") ∧ + (print_sexp s = + case strip_sxcons s of + | NONE => (case s of SX_CONS a d => "(" ++ print_sexp a ++ "." ++ print_sexp d ++")" | _ => "") + | SOME [q; s] => if q = SX_SYM "quote" then "'" ++ print_sexp s + else "(" ++ print_sexp q ++ " " ++ print_sexp s ++ ")" + | SOME ls => "(" ++ print_space_separated (MAP print_sexp ls) ++ ")")` + (WF_REL_TAC`measure sexp_size` >> rw[] >> simp[sexp_size_def] >> + fs[Once strip_sxcons_def] >> rw[] >> simp[sexp_size_def] >> + PROVE_TAC[sxMEM_def,sxMEM_sizelt,arithmeticTheory.LESS_IMP_LESS_ADD,listTheory.MEM, + DECIDE``(a:num) + (b + c) = b + (a + c)``]); + +val _ = export_theory() From 0dbc7c015d9f3c5dc1643c9b5c650e49a3b0eaa9 Mon Sep 17 00:00:00 2001 From: Thibault Gauthier Date: Wed, 23 Sep 2015 11:07:16 +0200 Subject: [PATCH 510/718] holyhammer: Fixing minimize_flag --- src/holyhammer/hhReconstruct.sml | 16 ++++++---------- 1 file changed, 6 insertions(+), 10 deletions(-) diff --git a/src/holyhammer/hhReconstruct.sml b/src/holyhammer/hhReconstruct.sml index 3dc0b0cf53..84bf0242a8 100644 --- a/src/holyhammer/hhReconstruct.sml +++ b/src/holyhammer/hhReconstruct.sml @@ -177,21 +177,17 @@ fun minimize_lemmas lemmas cj = print "Minimization ...\n"; pp_lemmas (map fst (minimize_lemmas_loop [] l cj)) ) - else - if can (time_metis (map snd l) cj) 30.0 - then pp_lemmas lemmas - else ( - pp_lemmas lemmas; - raise ERR "minimize_lemmas" "Metis timed out after 30 seconds." - ) - end + else pp_lemmas lemmas + end (*--------------------------------------------------------------------------- Reconstruction. ----------------------------------------------------------------------------*) fun reconstruct (atp_status,atp_out) cj = - minimize_lemmas (atp_lemmas_exn (atp_status,atp_out)) cj + let val lemmas = atp_lemmas_exn (atp_status,atp_out) in + if !minimize_flag then minimize_lemmas lemmas cj else pp_lemmas lemmas + end fun reconstructl atpfilel cj = let @@ -213,7 +209,7 @@ fun reconstructl atpfilel cj = fun cmp l1 l2 = length l1 < length l2 val lemmas = hd (sort cmp (map snd proofl)) in - minimize_lemmas lemmas cj + if !minimize_flag then minimize_lemmas lemmas cj else pp_lemmas lemmas end end From 177f825739ea1603af5b0d72f33cbaf832c7fc3d Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Wed, 23 Sep 2015 22:27:56 +1000 Subject: [PATCH 511/718] use pegparse constant rather than spelling out what, it turns out, is its definition --- .../formal-languages/context-free/simpleSexpParseScript.sml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/formal-languages/context-free/simpleSexpParseScript.sml b/examples/formal-languages/context-free/simpleSexpParseScript.sml index c84ea86260..4fe456c1f4 100644 --- a/examples/formal-languages/context-free/simpleSexpParseScript.sml +++ b/examples/formal-languages/context-free/simpleSexpParseScript.sml @@ -5,7 +5,7 @@ val _ = new_theory"simpleSexpParse" val parse_sexp_def = Define` parse_sexp s = - OPTION_BIND (destResult (peg_exec sexpPEG (pnt sxnt_sexp) s [] done failed)) + OPTION_BIND (pegparse sexpPEG s) (λ(rest,sx). OPTION_IGNORE_BIND (OPTION_GUARD (rest="")) (SOME sx))`; (* TODO: all this is taken from cakeml/parsing, and should be made more generic *) From 7a77114e0723a446228505dd2fd2e9aee38c8693 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Thu, 24 Sep 2015 14:17:41 +1000 Subject: [PATCH 512/718] make pegLib.derive_lookup_ths return more --- examples/formal-languages/context-free/pegLib.sig | 3 ++- examples/formal-languages/context-free/pegLib.sml | 2 +- examples/formal-languages/context-free/selftest.sml | 2 +- 3 files changed, 4 insertions(+), 3 deletions(-) diff --git a/examples/formal-languages/context-free/pegLib.sig b/examples/formal-languages/context-free/pegLib.sig index 5178ddc02b..d2b0fbc39f 100644 --- a/examples/formal-languages/context-free/pegLib.sig +++ b/examples/formal-languages/context-free/pegLib.sig @@ -6,6 +6,7 @@ include Abbrev val add_peg_compset : computeLib.compset -> unit val derive_compset_distincts : hol_type -> thm val derive_lookup_ths : - {pegth : thm, ntty : hol_type, simp : thm list -> conv} -> thm list + {pegth : thm, ntty : hol_type, simp : thm list -> conv} -> + {lookups : thm list, fdom_thm : thm, applieds : thm list} end diff --git a/examples/formal-languages/context-free/pegLib.sml b/examples/formal-languages/context-free/pegLib.sml index 8fd97cc5e3..cc37c4d2a3 100644 --- a/examples/formal-languages/context-free/pegLib.sml +++ b/examples/formal-languages/context-free/pegLib.sml @@ -79,7 +79,7 @@ fun derive_lookup_ths {pegth, ntty, simp} = (PURE_REWRITE_CONV (COND_CLAUSES :: fdoms @ fapps))) (SPEC c nt_thm) in - map final cs + {lookups = map final cs, fdom_thm = fdom_thm, applieds = fapps} end diff --git a/examples/formal-languages/context-free/selftest.sml b/examples/formal-languages/context-free/selftest.sml index 8e1c438438..91fa6ea7bf 100644 --- a/examples/formal-languages/context-free/selftest.sml +++ b/examples/formal-languages/context-free/selftest.sml @@ -4,7 +4,7 @@ open testutils local open pegLib simpleSexpPEGTheory pegexecTheory val ds = derive_compset_distincts ``:sexpNT`` - val lookups = derive_lookup_ths {pegth = sexpPEG_def, ntty = ``:sexpNT``, + val {lookups,...} = derive_lookup_ths {pegth = sexpPEG_def, ntty = ``:sexpNT``, simp = SIMP_CONV (srw_ss())} val _ = computeLib.add_funs (ds::lookups) val _ = let From 0a26ee7228916e6b6bf5ce08786b58c7bb4059e3 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Thu, 24 Sep 2015 14:19:16 +1000 Subject: [PATCH 513/718] remove some stuff from simpleSexpParse can be done much neater using pegLib --- .../context-free/simpleSexpParseScript.sml | 75 +------------------ 1 file changed, 2 insertions(+), 73 deletions(-) diff --git a/examples/formal-languages/context-free/simpleSexpParseScript.sml b/examples/formal-languages/context-free/simpleSexpParseScript.sml index 4fe456c1f4..b8ce76d553 100644 --- a/examples/formal-languages/context-free/simpleSexpParseScript.sml +++ b/examples/formal-languages/context-free/simpleSexpParseScript.sml @@ -1,5 +1,6 @@ open HolKernel boolLib bossLib lcsymtacs finite_mapSyntax -open ASCIInumbersTheory simpleSexpTheory simpleSexpPEGTheory pegexecTheory +open ASCIInumbersTheory simpleSexpTheory +open simpleSexpPEGTheory pegexecTheory val _ = new_theory"simpleSexpParse" @@ -8,78 +9,6 @@ val parse_sexp_def = Define` OPTION_BIND (pegparse sexpPEG s) (λ(rest,sx). OPTION_IGNORE_BIND (OPTION_GUARD (rest="")) (SOME sx))`; -(* TODO: all this is taken from cakeml/parsing, and should be made more generic *) - -val FDOM_sexpPEG_rules = save_thm("FDOM_sexpPEG_rules", - ``FDOM sexpPEG.rules`` - |> SIMP_CONV(srw_ss())[sexpPEG_def,finite_mapTheory.FUPDATE_LIST_THM]) - -val spec0 = - peg_nt_thm |> Q.GEN`G` |> Q.ISPEC`sexpPEG` - |> SIMP_RULE (srw_ss()) [FDOM_sexpPEG_rules] - |> Q.GEN`n` - -val mkNT = ``mkNT`` - -val distinct_ths = let - val ntlist = TypeBase.constructors_of ``:sexpNT`` - fun recurse [] = [] - | recurse (t::ts) = let - val eqns = map (fn t' => mk_eq(t,t')) ts - val ths0 = map (SIMP_CONV (srw_ss()) []) eqns - val ths1 = map (CONV_RULE (LAND_CONV (REWR_CONV EQ_SYM_EQ))) ths0 - in - ths0 @ ths1 @ recurse ts - end -in - recurse ntlist -end - -val rules_t = ``sexpPEG.rules`` -fun ty2frag ty = let - open simpLib - val {convs,rewrs} = TypeBase.simpls_of ty -in - merge_ss (rewrites rewrs :: map conv_ss convs) -end -(* can't use srw_ss() as it will attack the bodies of the rules, - and in particular, will destroy predicates from tok - constructors of the form - do ... od = SOME () - which matches optionTheory.OPTION_BIND_EQUALS_OPTION, putting - an existential into our rewrite thereby *) -val rules = SIMP_CONV (bool_ss ++ ty2frag ``:(α,β,γ)peg``) - [sexpPEG_def, combinTheory.K_DEF, - finite_mapTheory.FUPDATE_LIST_THM] rules_t - -val _ = print "Calculating application of sexpPEG rules\n" -val sexppeg_rules_applied = let - val app0 = finite_mapSyntax.fapply_t - val theta = - Type.match_type (type_of app0 |> dom_rng |> #1) (type_of rules_t) - val app = inst theta app0 - val app_rules = AP_TERM app rules - val sset = bool_ss ++ ty2frag ``:'a + 'b`` ++ ty2frag ``:sexpNT`` - fun mkrule t = - AP_THM app_rules ``mkNT ^t`` - |> SIMP_RULE sset - [finite_mapTheory.FAPPLY_FUPDATE_THM] - val ths = TypeBase.constructors_of ``:sexpNT`` |> map mkrule -in - save_thm("sexppeg_rules_applied", LIST_CONJ ths); - ths -end - -val sexpPEG_exec_thm = save_thm( - "sexpPEG_exec_thm", - TypeBase.constructors_of ``:sexpNT`` - |> map (fn t => ISPEC (mk_comb(mkNT, t)) spec0) - |> map (SIMP_RULE bool_ss (sexppeg_rules_applied @ distinct_ths @ - [sumTheory.INL_11])) - |> LIST_CONJ) -val _ = computeLib.add_persistent_funs ["sexpPEG_exec_thm"] -(* -- *) - val escape_string_def = Define` escape_string s = case s of From d017fb2f0e8d6ad17b36f493d75ebb9fd96d7776 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Thu, 24 Sep 2015 14:19:48 +1000 Subject: [PATCH 514/718] prove sexpPEG is NOT well-formed --- .../context-free/simpleSexpPEGScript.sml | 224 +++++++++++++++++- 1 file changed, 222 insertions(+), 2 deletions(-) diff --git a/examples/formal-languages/context-free/simpleSexpPEGScript.sml b/examples/formal-languages/context-free/simpleSexpPEGScript.sml index c7b133fdf1..873e51a995 100644 --- a/examples/formal-languages/context-free/simpleSexpPEGScript.sml +++ b/examples/formal-languages/context-free/simpleSexpPEGScript.sml @@ -1,14 +1,62 @@ -open HolKernel Parse boolLib bossLib; +open HolKernel Parse boolLib bossLib lcsymtacs; -open simpleSexpTheory +open simpleSexpTheory pegTheory pegLib val _ = new_theory "simpleSexpPEG"; +(* TODO: move? *) +val pegfail_empty = store_thm( + "pegfail_empty[simp]", + ``pegfail G (empty r) = F``, + simp[Once peg0_cases]); + +val peg0_empty = store_thm( + "peg0_empty[simp]", + ``peg0 G (empty r) = T``, + simp[Once peg0_cases]); + +val peg0_not = store_thm( + "peg0_not[simp]", + ``peg0 G (not s r) ⇔ pegfail G s``, + simp[Once peg0_cases, SimpLHS]); + +val peg0_choice = store_thm( + "peg0_choice[simp]", + ``peg0 G (choice s1 s2 f) ⇔ peg0 G s1 ∨ pegfail G s1 ∧ peg0 G s2``, + simp[Once peg0_cases, SimpLHS]); + +val peg0_choicel = store_thm( + "peg0_choicel[simp]", + ``(peg0 G (choicel []) = F) ∧ + (peg0 G (choicel (h::t)) ⇔ peg0 G h ∨ pegfail G h ∧ peg0 G (choicel t))``, + simp[choicel_def]) + +val peg0_seq = store_thm( + "peg0_seq[simp]", + ``peg0 G (seq s1 s2 f) ⇔ peg0 G s1 ∧ peg0 G s2``, + simp[Once peg0_cases, SimpLHS]) + +val peg0_pegf = store_thm( + "peg0_pegf[simp]", + ``peg0 G (pegf s f) = peg0 G s``, + simp[pegf_def]) + +val peg0_tok = store_thm( + "peg0_tok[simp]", + ``peg0 G (tok P f) = F``, + simp[Once peg0_cases]) +(*--*) + val tokeq_def = Define`tokeq t = tok ((=) t) (K (SX_SYM [t]))` val grabWS_def = Define` grabWS s = rpt (tok isSpace ARB) (K ARB) ~> s `; +val peg0_tokeq = store_thm( + "peg0_tokeq[simp]", + ``peg0 G (tokeq t) = F``, + simp[tokeq_def]) + val pnt_def = Define`pnt ntsym = nt (mkNT ntsym) I` val isFirstSymChar_def = Define` @@ -61,5 +109,177 @@ val sexpPEG_def = zDefine` |> `; +val sexpPEG_start = SIMP_CONV(srw_ss())[sexpPEG_def]``sexpPEG.start`` +val ds = derive_compset_distincts ``:sexpNT`` +val {lookups,fdom_thm,applieds} = derive_lookup_ths {pegth = sexpPEG_def, ntty = ``:sexpNT``, simp = SIMP_CONV (srw_ss())} +val sexpPEG_exec_thm = save_thm("sexpPEG_exec_thm",LIST_CONJ(sexpPEG_start::ds::lookups)) +val _ = computeLib.add_persistent_funs["sexpPEG_exec_thm"]; + +val frange_image = prove( + ``FRANGE fm = IMAGE (FAPPLY fm) (FDOM fm)``, + simp[finite_mapTheory.FRANGE_DEF, pred_setTheory.EXTENSION] >> metis_tac[]); + +val sexpPEG_range = + SIMP_CONV (srw_ss()) + (fdom_thm :: frange_image :: applieds) + ``FRANGE sexpPEG.rules`` + +val wfpeg_rwts = wfpeg_cases + |> ISPEC ``sexpPEG`` + |> (fn th => map (fn t => Q.SPEC t th) + [`seq e1 e2 f`, `choice e1 e2 f`, `tok P f`, + `any f`, `empty v`, `not e v`, `rpt e f`, + `choicel []`, `choicel (h::t)`, `tokeq t`, + `pegf e f` + ]) + |> map (CONV_RULE + (RAND_CONV (SIMP_CONV (srw_ss()) + [choicel_def, tokeq_def, + pegf_def]))) + +val wfpeg_pnt = wfpeg_cases + |> ISPEC ``sexpPEG`` + |> Q.SPEC `pnt n` + |> CONV_RULE (RAND_CONV (SIMP_CONV (srw_ss()) [pnt_def])) + +val peg0_rwts = peg0_cases + |> ISPEC ``sexpPEG`` |> CONJUNCTS + |> map (fn th => map (fn t => Q.SPEC t th) + [`tok P f`, `choice e1 e2 f`, `seq e1 e2 f`, + `tokeq t`, `empty l`, `not e v`, `rpt e f`]) + |> List.concat + |> map (CONV_RULE + (RAND_CONV (SIMP_CONV (srw_ss()) + [tokeq_def]))) + +val pegfail_t = ``pegfail`` +val peg0_rwts = let + fun filterthis th = let + val c = concl th + val (l,r) = dest_eq c + val (f,_) = strip_comb l + in + not (same_const pegfail_t f) orelse is_const r + end +in + List.filter filterthis peg0_rwts +end + +val pegnt_case_ths = peg0_cases + |> ISPEC ``sexpPEG`` |> CONJUNCTS + |> map (Q.SPEC `pnt n`) + |> map (CONV_RULE (RAND_CONV (SIMP_CONV (srw_ss()) [pnt_def]))) + +fun pegnt(t,acc) = let + val th = + prove(``¬peg0 sexpPEG (pnt ^t)``, + simp (fdom_thm::choicel_def::ignoreL_def::pegnt_case_ths @ applieds @ peg0_rwts) >> + simp(peg0_rwts @ acc)) + val nm = "peg0_" ^ term_to_string t + val th' = save_thm(nm, SIMP_RULE bool_ss [pnt_def] th) + val _ = export_rewrites [nm] +in + th::acc +end + +val peg0_sexpnum = prove( + ``peg0 sexpPEG (pnt sxnt_sexpnum)``, + rw[Once peg0_cases,pnt_def,fdom_thm] >> + rw applieds >> + rw[checkAhead_def] >> + rw[ignoreL_def] >> + rw[Once peg0_cases] >> + rw[Once peg0_cases] >> + rw[Once peg0_cases] >> + rw[Once peg0_cases,pnt_def] >> + rw[fdom_thm] >> + rw applieds >> + rw[Once peg0_cases]) + +val peg0_sexp0 = prove( + ``peg0 sexpPEG (pnt sxnt_sexp0)``, + rw[Once peg0_cases,pnt_def,fdom_thm] >> + rw applieds >> + rw[peg0_sexpnum]) + +val peg0_WSsexp = prove( + ``peg0 sexpPEG (pnt sxnt_WSsexp)``, + rw[Once peg0_cases,pnt_def,fdom_thm] >> + rw applieds >> + rw[ignoreL_def] >- ( + rw[Once peg0_cases] >> + rw[Once peg0_cases] ) >> + rw[peg0_sexp0]) + +val nwfpeg_sexpstr = Q.prove( + `¬wfpeg sexpPEG (pnt sxnt_sexpstr)`, + rw(applieds@[wfpeg_pnt,fdom_thm])) + +val npeg0_rwts = + List.foldl pegnt [] + [``sxnt_symchars``, ``sxnt_symchar``, + ``sxnt_strchar``, ``sxnt_sexpsym``, ``sxnt_sexpstr``, + (*``sxnt_sexpnum``, ``sxnt_sexp0``, ``sxnt_sexp``, *) ``sxnt_normstrchar``, + ``sxnt_grabWS``, ``sxnt_first_symchar``, ``sxnt_escapedstrchar``, + ``sxnt_escapablechar``, ``sxnt_digit``(*, ``sxnt_WSsexp``*), ``sxnt_WS``] + +fun wfnt(t,acc) = let + val th = + prove(``wfpeg sexpPEG (pnt ^t)``, + SIMP_TAC (srw_ss()) + (applieds @ + [wfpeg_pnt, fdom_thm, ignoreL_def, ignoreR_def, checkAhead_def]) THEN + fs(wfpeg_rwts @ npeg0_rwts @ peg0_rwts @ acc)) +in + th::acc +end; + +val topo_nts = + [(*``sxnt_symchar``, + ``sxnt_symchars``, + ``sxnt_first_symchar``,*) + ``sxnt_sexpsym``, + (*``sxnt_escapablechar``,*) + ``sxnt_escapedstrchar``, + ``sxnt_normstrchar``, + ``sxnt_strchar``, + ``sxnt_strcontents``, + (*``sxnt_sexpstr``,*) + ``sxnt_digit``, + ``sxnt_sexpnum``, + ``sxnt_sexp0``, + (*``sxnt_WS``, + ``sxnt_grabWS``,*) + ``sxnt_WSsexp``, + (*``sxnt_sexpseq``,*) + ``sxnt_sexp``] + +val wfpeg_thm = save_thm( + "wfpeg_thm", + LIST_CONJ (List.foldl wfnt [] topo_nts)) + +val subexprs_pnt = prove( + ``subexprs (pnt n) = {pnt n}``, + simp[subexprs_def, pnt_def]); + +val PEG_exprs = save_thm( + "PEG_exprs", + ``Gexprs sexpPEG`` + |> SIMP_CONV (srw_ss()) + [Gexprs_def, subexprs_def, + subexprs_pnt, sexpPEG_start, sexpPEG_range, + ignoreR_def, ignoreL_def, + choicel_def, tokeq_def, pegf_def, grabWS_def, + checkAhead_def, + pred_setTheory.INSERT_UNION_EQ + ]) + +val PEG_wellformed = store_thm( + "PEG_wellformed", + ``¬wfG sexpPEG``, + rw[wfG_def,PEG_exprs] >> + srw_tac[boolSimps.DNF_ss][] >> + simp(wfpeg_thm :: wfpeg_rwts @ npeg0_rwts) >> + rw[peg0_WSsexp]) val _ = export_theory(); From e8b1de2062cddd7f6777dbebd3d8fe82038a290e Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Thu, 24 Sep 2015 18:39:06 +1000 Subject: [PATCH 515/718] fix sexpPEG so it is wfG (and still passes tests) rather ugly peg expression for sexpnum, but seems hard to avoid --- .../context-free/simpleSexpPEGScript.sml | 78 +++++++------------ .../context-free/simpleSexpScript.sml | 4 + 2 files changed, 31 insertions(+), 51 deletions(-) diff --git a/examples/formal-languages/context-free/simpleSexpPEGScript.sml b/examples/formal-languages/context-free/simpleSexpPEGScript.sml index 873e51a995..9219234b9e 100644 --- a/examples/formal-languages/context-free/simpleSexpPEGScript.sml +++ b/examples/formal-languages/context-free/simpleSexpPEGScript.sml @@ -86,9 +86,12 @@ val sexpPEG_def = zDefine` (mkNT sxnt_WSsexp, rpt (tok isSpace ARB) (K ARB) ~> pnt sxnt_sexp0); (mkNT sxnt_sexpnum, - checkAhead isDigit - (rpt (pnt sxnt_digit) - (SX_NUM o FOLDL (λa d. 10 * a + destSXNUM d) 0))) ; + seq (pnt sxnt_digit) + (rpt (pnt sxnt_digit) + (UNCURRY SX_CONS o (SX_NUM ## SX_NUM) o + FOLDL (λ(l,n) d. (10*l, 10*n + destSXNUM d)) (1,0))) + (λs1. (λ(l,n). SX_NUM (destSXNUM s1 * l + n)) + o (destSXNUM ## destSXNUM) o destSXCONS)) ; (mkNT sxnt_digit, tok isDigit (λc. SX_NUM (ORD c - ORD #"0"))) ; (mkNT sxnt_sexpsym, seq (tok isFirstSymChar (λc. SX_SYM [c])) @@ -173,7 +176,7 @@ val pegnt_case_ths = peg0_cases fun pegnt(t,acc) = let val th = prove(``¬peg0 sexpPEG (pnt ^t)``, - simp (fdom_thm::choicel_def::ignoreL_def::pegnt_case_ths @ applieds @ peg0_rwts) >> + simp (fdom_thm::choicel_def::ignoreL_def::ignoreR_def::applieds @ pegnt_case_ths) >> simp(peg0_rwts @ acc)) val nm = "peg0_" ^ term_to_string t val th' = save_thm(nm, SIMP_RULE bool_ss [pnt_def] th) @@ -182,46 +185,27 @@ in th::acc end -val peg0_sexpnum = prove( - ``peg0 sexpPEG (pnt sxnt_sexpnum)``, - rw[Once peg0_cases,pnt_def,fdom_thm] >> - rw applieds >> - rw[checkAhead_def] >> - rw[ignoreL_def] >> - rw[Once peg0_cases] >> - rw[Once peg0_cases] >> - rw[Once peg0_cases] >> - rw[Once peg0_cases,pnt_def] >> - rw[fdom_thm] >> - rw applieds >> - rw[Once peg0_cases]) - -val peg0_sexp0 = prove( - ``peg0 sexpPEG (pnt sxnt_sexp0)``, - rw[Once peg0_cases,pnt_def,fdom_thm] >> - rw applieds >> - rw[peg0_sexpnum]) - -val peg0_WSsexp = prove( - ``peg0 sexpPEG (pnt sxnt_WSsexp)``, - rw[Once peg0_cases,pnt_def,fdom_thm] >> - rw applieds >> - rw[ignoreL_def] >- ( - rw[Once peg0_cases] >> - rw[Once peg0_cases] ) >> - rw[peg0_sexp0]) - -val nwfpeg_sexpstr = Q.prove( - `¬wfpeg sexpPEG (pnt sxnt_sexpstr)`, - rw(applieds@[wfpeg_pnt,fdom_thm])) - val npeg0_rwts = List.foldl pegnt [] [``sxnt_symchars``, ``sxnt_symchar``, ``sxnt_strchar``, ``sxnt_sexpsym``, ``sxnt_sexpstr``, - (*``sxnt_sexpnum``, ``sxnt_sexp0``, ``sxnt_sexp``, *) ``sxnt_normstrchar``, + ``sxnt_sexpnum``, ``sxnt_normstrchar``, ``sxnt_grabWS``, ``sxnt_first_symchar``, ``sxnt_escapedstrchar``, - ``sxnt_escapablechar``, ``sxnt_digit``(*, ``sxnt_WSsexp``*), ``sxnt_WS``] + ``sxnt_escapablechar``, ``sxnt_digit``,``sxnt_WS``] + +val npeg0_sexp0 = Q.prove( + `¬peg0 sexpPEG (pnt sxnt_sexp0)`, + simp pegnt_case_ths >> simp[fdom_thm] >> + simp applieds >> simp[ignoreL_def,ignoreR_def] >> + simp npeg0_rwts) + +val npeg0_WSsexp = Q.prove( + `¬peg0 sexpPEG (pnt sxnt_WSsexp)`, + simp pegnt_case_ths >> simp[fdom_thm] >> + simp applieds >> simp[ignoreL_def] >> + simp (npeg0_sexp0::peg0_rwts)) + +val npeg0_rwts = npeg0_WSsexp::npeg0_sexp0::npeg0_rwts fun wfnt(t,acc) = let val th = @@ -235,23 +219,16 @@ in end; val topo_nts = - [(*``sxnt_symchar``, - ``sxnt_symchars``, - ``sxnt_first_symchar``,*) - ``sxnt_sexpsym``, - (*``sxnt_escapablechar``,*) + [``sxnt_sexpsym``, ``sxnt_escapedstrchar``, ``sxnt_normstrchar``, ``sxnt_strchar``, ``sxnt_strcontents``, - (*``sxnt_sexpstr``,*) ``sxnt_digit``, ``sxnt_sexpnum``, ``sxnt_sexp0``, - (*``sxnt_WS``, - ``sxnt_grabWS``,*) ``sxnt_WSsexp``, - (*``sxnt_sexpseq``,*) + ``sxnt_sexpseq``, ``sxnt_sexp``] val wfpeg_thm = save_thm( @@ -276,10 +253,9 @@ val PEG_exprs = save_thm( val PEG_wellformed = store_thm( "PEG_wellformed", - ``¬wfG sexpPEG``, + ``wfG sexpPEG``, rw[wfG_def,PEG_exprs] >> srw_tac[boolSimps.DNF_ss][] >> - simp(wfpeg_thm :: wfpeg_rwts @ npeg0_rwts) >> - rw[peg0_WSsexp]) + simp(wfpeg_thm :: wfpeg_rwts @ npeg0_rwts)); val _ = export_theory(); diff --git a/examples/formal-languages/context-free/simpleSexpScript.sml b/examples/formal-languages/context-free/simpleSexpScript.sml index 7235ed010a..c69697e540 100644 --- a/examples/formal-languages/context-free/simpleSexpScript.sml +++ b/examples/formal-languages/context-free/simpleSexpScript.sml @@ -54,6 +54,10 @@ val destSXSYM_def = Define` destSXSYM (SX_SYM s) = s `; +val destSXCONS_def = Define` + destSXCONS (SX_CONS a d) = (a,d) +`; + val strip_sxcons_def = Define` strip_sxcons s = case s of From d126ddb93bace0f28857ff734d0bab3fa199c672 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Fri, 25 Sep 2015 07:26:54 +1000 Subject: [PATCH 516/718] save fdom and applieds, and clean saved theorem names in simpleSexpPEG --- .../context-free/simpleSexpPEGScript.sml | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/examples/formal-languages/context-free/simpleSexpPEGScript.sml b/examples/formal-languages/context-free/simpleSexpPEGScript.sml index 9219234b9e..221db08f3b 100644 --- a/examples/formal-languages/context-free/simpleSexpPEGScript.sml +++ b/examples/formal-languages/context-free/simpleSexpPEGScript.sml @@ -117,6 +117,8 @@ val ds = derive_compset_distincts ``:sexpNT`` val {lookups,fdom_thm,applieds} = derive_lookup_ths {pegth = sexpPEG_def, ntty = ``:sexpNT``, simp = SIMP_CONV (srw_ss())} val sexpPEG_exec_thm = save_thm("sexpPEG_exec_thm",LIST_CONJ(sexpPEG_start::ds::lookups)) val _ = computeLib.add_persistent_funs["sexpPEG_exec_thm"]; +val _ = save_thm("FDOM_sexpPEG", fdom_thm); +val _ = save_thm("sexpPEG_applied", LIST_CONJ applieds); val frange_image = prove( ``FRANGE fm = IMAGE (FAPPLY fm) (FDOM fm)``, @@ -231,16 +233,14 @@ val topo_nts = ``sxnt_sexpseq``, ``sxnt_sexp``] -val wfpeg_thm = save_thm( - "wfpeg_thm", - LIST_CONJ (List.foldl wfnt [] topo_nts)) +val wfpeg_thm = LIST_CONJ (List.foldl wfnt [] topo_nts) val subexprs_pnt = prove( ``subexprs (pnt n) = {pnt n}``, simp[subexprs_def, pnt_def]); -val PEG_exprs = save_thm( - "PEG_exprs", +val Gexprs_sexpPEG = save_thm( + "Gexprs_sexpPEG", ``Gexprs sexpPEG`` |> SIMP_CONV (srw_ss()) [Gexprs_def, subexprs_def, @@ -251,10 +251,10 @@ val PEG_exprs = save_thm( pred_setTheory.INSERT_UNION_EQ ]) -val PEG_wellformed = store_thm( - "PEG_wellformed", +val wfG_sexpPEG = store_thm( + "wfG_sexpPEG", ``wfG sexpPEG``, - rw[wfG_def,PEG_exprs] >> + rw[wfG_def,Gexprs_sexpPEG] >> srw_tac[boolSimps.DNF_ss][] >> simp(wfpeg_thm :: wfpeg_rwts @ npeg0_rwts)); From fa5686212587bd43736b4c7fd9abdf242ccb53ce Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Fri, 25 Sep 2015 07:28:40 +1000 Subject: [PATCH 517/718] define valid_sexp the only restriction is on symbols (hopefully that's enough for parsing back what's printed) --- .../context-free/simpleSexpPEGScript.sml | 8 ++----- .../context-free/simpleSexpScript.sml | 22 ++++++++++++++++--- 2 files changed, 21 insertions(+), 9 deletions(-) diff --git a/examples/formal-languages/context-free/simpleSexpPEGScript.sml b/examples/formal-languages/context-free/simpleSexpPEGScript.sml index 221db08f3b..39d26ff331 100644 --- a/examples/formal-languages/context-free/simpleSexpPEGScript.sml +++ b/examples/formal-languages/context-free/simpleSexpPEGScript.sml @@ -59,10 +59,6 @@ val peg0_tokeq = store_thm( val pnt_def = Define`pnt ntsym = nt (mkNT ntsym) I` -val isFirstSymChar_def = Define` - isFirstSymChar c ⇔ isGraph c ∧ ¬isDigit c ∧ c ∉ {#"("; #"'"; #")"; #"."} -`; - val sexpPEG_def = zDefine` sexpPEG : (char, sexpNT, sexp) peg = <| start := pnt sxnt_sexp ; @@ -94,8 +90,8 @@ val sexpPEG_def = zDefine` o (destSXNUM ## destSXNUM) o destSXCONS)) ; (mkNT sxnt_digit, tok isDigit (λc. SX_NUM (ORD c - ORD #"0"))) ; (mkNT sxnt_sexpsym, - seq (tok isFirstSymChar (λc. SX_SYM [c])) - (rpt (tok (λc. isGraph c ∧ c ∉ {#"("; #")"; #"'"}) (λc. SX_SYM [c])) + seq (tok valid_first_symchar (λc. SX_SYM [c])) + (rpt (tok valid_symchar (λc. SX_SYM [c])) (SX_SYM o FOLDR (λs a. destSXSYM s ++ a) [])) (λs1 s2. SX_SYM (destSXSYM s1 ++ destSXSYM s2))); (mkNT sxnt_strcontents, diff --git a/examples/formal-languages/context-free/simpleSexpScript.sml b/examples/formal-languages/context-free/simpleSexpScript.sml index c69697e540..985d8ca4e9 100644 --- a/examples/formal-languages/context-free/simpleSexpScript.sml +++ b/examples/formal-languages/context-free/simpleSexpScript.sml @@ -46,6 +46,22 @@ val _ = add_rule { block_style = (AroundEachPhrase, (PP.INCONSISTENT, 0)), val _ = overload_on ("’", ``λs. ⦇ SX_SYM "quote" ; s ⦈``) +val valid_first_symchar_def = Define` + valid_first_symchar c ⇔ isGraph c ∧ c ∉ {#"'"; #"("; #")"} ∧ ¬isDigit c`; + +val valid_symchar_def = Define` + valid_symchar c ⇔ isGraph c ∧ c ∉ {#"'"; #"("; #")"}`; + +val valid_symbol_def = Define` + (valid_symbol "" ⇔ F) ∧ + (valid_symbol (c::cs) ⇔ valid_first_symchar c ∧ EVERY valid_symchar cs)`; + +val valid_sexp_def = Define` + (valid_sexp (SX_SYM s) ⇔ valid_symbol s) ∧ + (valid_sexp (SX_CONS s1 s2) ⇔ valid_sexp s1 ∧ valid_sexp s2) ∧ + (valid_sexp s ⇔ T)`; +val _ = export_rewrites["valid_first_symchar_def","valid_symchar_def","valid_symbol_def","valid_sexp_def"]; + val destSXNUM_def = Define` destSXNUM (SX_NUM n) = n `; @@ -123,10 +139,10 @@ val sexpG_def = mk_grammar_def ginfo ` escapablechar ::= "\\" | "\"" ; sexpsym ::= first_symchar symchars ; - first_symchar ::= - ^(``{ c | isGraph c ∧ c ∉ {#"'"; #"("; #")"} ∧ ¬isDigit c}``) ; + first_symchar ::= ^(``{ c | valid_first_symchar c }``) + ; symchars ::= symchar symchars | ; - symchar ::= ^(``{ c | isGraph c ∧ c ∉ {#"'"; #"("; #")"}}``); + symchar ::= ^(``{ c | valid_symchar c }``); `; val _ = type_abbrev("NT", ``:sexpNT inf``) From a5acf22edfa170473b15359828a60a00559e3b73 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Fri, 25 Sep 2015 08:41:04 +1000 Subject: [PATCH 518/718] I think a symbol should not start with a . or a " It would probably be possible to allow symbols starting with ".", but is it worth the effort? Also, I noticed a discrepancy with my understanding of sexps: (this is a dotted . list) is not allowed, but I think it should be (representing (this . (is . (a . (dotted . list))))) --- examples/formal-languages/context-free/selftest.sml | 5 ++++- examples/formal-languages/context-free/simpleSexpScript.sml | 2 +- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/examples/formal-languages/context-free/selftest.sml b/examples/formal-languages/context-free/selftest.sml index 91fa6ea7bf..dcf87712c7 100644 --- a/examples/formal-languages/context-free/selftest.sml +++ b/examples/formal-languages/context-free/selftest.sml @@ -51,5 +51,8 @@ val _ = print "\n" before app test [ ("\"foo bar\"", ``SX_STR "foo bar"``), ("( \" foo \" \"bar\" )", ``⦇ SX_STR " foo "; SX_STR "bar" ⦈``), ("\"foo\\\"\"", ``SX_STR "foo\""``), - ("\"foo\\\\\"", ``SX_STR "foo\\"``) + ("\"foo\\\\\"", ``SX_STR "foo\\"``), + ("(1sym)", ``⦇1; SX_SYM "sym"⦈``), + ("symq\"9", ``SX_SYM "symq\"9"``), + ("symd.9", ``SX_SYM "symd.9"``) ] diff --git a/examples/formal-languages/context-free/simpleSexpScript.sml b/examples/formal-languages/context-free/simpleSexpScript.sml index 985d8ca4e9..17998821db 100644 --- a/examples/formal-languages/context-free/simpleSexpScript.sml +++ b/examples/formal-languages/context-free/simpleSexpScript.sml @@ -47,7 +47,7 @@ val _ = add_rule { block_style = (AroundEachPhrase, (PP.INCONSISTENT, 0)), val _ = overload_on ("’", ``λs. ⦇ SX_SYM "quote" ; s ⦈``) val valid_first_symchar_def = Define` - valid_first_symchar c ⇔ isGraph c ∧ c ∉ {#"'"; #"("; #")"} ∧ ¬isDigit c`; + valid_first_symchar c ⇔ isGraph c ∧ c ∉ {#"'"; #"("; #")"; #"."; #"\""} ∧ ¬isDigit c`; val valid_symchar_def = Define` valid_symchar c ⇔ isGraph c ∧ c ∉ {#"'"; #"("; #")"}`; From 0106cc667945b1fb57cb0d1281c19c9d5b784d22 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Fri, 25 Sep 2015 09:02:25 +1000 Subject: [PATCH 519/718] prove a valid_symbol will peg_eval correctly unfortunately could not use EVAL, but only the simplifier, because I can't see how to back from an intermediate peg_exec state to peg_eval --- .../context-free/simpleSexpParseScript.sml | 115 +++++++++++++++++- 1 file changed, 114 insertions(+), 1 deletion(-) diff --git a/examples/formal-languages/context-free/simpleSexpParseScript.sml b/examples/formal-languages/context-free/simpleSexpParseScript.sml index b8ce76d553..5481801b89 100644 --- a/examples/formal-languages/context-free/simpleSexpParseScript.sml +++ b/examples/formal-languages/context-free/simpleSexpParseScript.sml @@ -1,6 +1,6 @@ open HolKernel boolLib bossLib lcsymtacs finite_mapSyntax open ASCIInumbersTheory simpleSexpTheory -open simpleSexpPEGTheory pegexecTheory +open simpleSexpPEGTheory pegTheory pegexecTheory val _ = new_theory"simpleSexpParse" @@ -37,4 +37,117 @@ val print_sexp_def = tDefine"print_sexp"` PROVE_TAC[sxMEM_def,sxMEM_sizelt,arithmeticTheory.LESS_IMP_LESS_ADD,listTheory.MEM, DECIDE``(a:num) + (b + c) = b + (a + c)``]); +val FOLDR_STRCAT_destSXSYM = Q.prove( + `∀ls. FOLDR (λs a. STRCAT (destSXSYM s) a) "" (MAP (λc. SX_SYM (STRING c "")) ls) = ls`, + Induct >> simp[destSXSYM_def]); + +val peg_eval_list_valid_symchars = Q.prove( + `∀cs. EVERY valid_symchar cs ⇒ + peg_eval_list sexpPEG (cs,tok valid_symchar (λc. SX_SYM [c])) ("",MAP (λc. SX_SYM [c]) cs)`, + Induct >> simp[Once peg_eval_cases] >> simp[Once peg_eval_cases]) + +val peg_eval_valid_symchars = Q.prove( + `∀cs. EVERY valid_symchar cs ⇒ + peg_eval sexpPEG (cs,rpt (tok valid_symchar (λc. SX_SYM (STRING c ""))) (SX_SYM o FOLDR (λs a. STRCAT (destSXSYM s) a) "")) + (SOME ("",SX_SYM cs))`, + rw[Once peg_eval_cases] >> + imp_res_tac peg_eval_list_valid_symchars >> + metis_tac[FOLDR_STRCAT_destSXSYM]); + +val peg_eval_valid_symbol = Q.prove( + `∀s. valid_symbol s ⇒ + peg_eval sexpPEG (s,sexpPEG.start) (SOME ("",SX_SYM s))`, + Cases_on`s`>>simp[]>>rw[]>> + rw[Once peg_eval_cases,sexpPEG_exec_thm,pnt_def,FDOM_sexpPEG,sexpPEG_applied,ignoreR_def] >> + rw[Once peg_eval_cases] >> + rw[Once peg_eval_cases,FDOM_sexpPEG,sexpPEG_applied,ignoreL_def] >> + rw[Once peg_eval_cases,PULL_EXISTS] >> + rw[Once peg_eval_cases,PULL_EXISTS] >> + rw[Once peg_eval_cases,PULL_EXISTS] >> + srw_tac[boolSimps.DNF_ss][] >> disj1_tac >> + rw[Once peg_eval_cases,PULL_EXISTS] >> + simp[GSYM PULL_EXISTS] >> + conj_tac >- fs[stringTheory.isGraph_def] >> + rw[Once peg_eval_cases,PULL_EXISTS,pnt_def,FDOM_sexpPEG,sexpPEG_applied,choicel_def] >> + rw[Once peg_eval_cases,PULL_EXISTS] >> + srw_tac[boolSimps.DNF_ss][] >> disj2_tac >> + rw[Once peg_eval_cases,PULL_EXISTS,pnt_def,FDOM_sexpPEG,sexpPEG_applied] >> + rw[Once peg_eval_cases,PULL_EXISTS] >> + srw_tac[boolSimps.DNF_ss][] >> disj1_tac >> + rw[Once peg_eval_cases,PULL_EXISTS,pnt_def,FDOM_sexpPEG,sexpPEG_applied] >> + rw[Once peg_eval_cases,PULL_EXISTS] >> + rw[Once peg_eval_cases,PULL_EXISTS,ignoreR_def,ignoreL_def] >> + rw[Once peg_eval_cases,PULL_EXISTS] >> + srw_tac[boolSimps.DNF_ss][] >> disj2_tac >> + rw[Once peg_eval_cases,PULL_EXISTS] >> + srw_tac[boolSimps.DNF_ss][] >> disj1_tac >> + rw[Once peg_eval_cases,PULL_EXISTS,tokeq_def] >> + srw_tac[boolSimps.DNF_ss][] >> disj1_tac >> + rw[Once peg_eval_cases,PULL_EXISTS] >> + rw[Once peg_eval_cases,PULL_EXISTS] >> + srw_tac[boolSimps.DNF_ss][] >> disj2_tac >> + rw[Once peg_eval_cases,PULL_EXISTS] >> + srw_tac[boolSimps.DNF_ss][] >> disj1_tac >> + rw[Once peg_eval_cases,PULL_EXISTS] >> + srw_tac[boolSimps.DNF_ss][] >> disj1_tac >> + rw[Once peg_eval_cases,PULL_EXISTS] >> + rw[Once peg_eval_cases,PULL_EXISTS] >> + srw_tac[boolSimps.DNF_ss][] >> disj2_tac >> + rw[Once peg_eval_cases,PULL_EXISTS] >> + srw_tac[boolSimps.DNF_ss][] >> disj1_tac >> + rw[Once peg_eval_cases,PULL_EXISTS] >> + srw_tac[boolSimps.DNF_ss][] >> disj1_tac >> + rw[Once peg_eval_cases,PULL_EXISTS] >> + rw[Once peg_eval_cases,PULL_EXISTS] >> + srw_tac[boolSimps.DNF_ss][] >> disj2_tac >> + rw[Once peg_eval_cases,PULL_EXISTS,pegf_def] >> + srw_tac[boolSimps.DNF_ss][] >> disj1_tac >> + rw[Once peg_eval_cases,PULL_EXISTS] >> + srw_tac[boolSimps.DNF_ss][] >> disj1_tac >> + rw[Once peg_eval_cases,PULL_EXISTS] >> + rw[Once peg_eval_cases,PULL_EXISTS] >> + srw_tac[boolSimps.DNF_ss][] >> disj1_tac >> + rw[Once peg_eval_cases,PULL_EXISTS,FDOM_sexpPEG,sexpPEG_applied] >> + rw[Once peg_eval_cases,PULL_EXISTS] >> + rw[Once peg_eval_cases,PULL_EXISTS,destSXSYM_def] >> + imp_res_tac peg_eval_valid_symchars >> + map_every qexists_tac[`""`,`ARB`,`SX_SYM t`] >> + simp[destSXSYM_def] >> + rw[Once peg_eval_cases] >> + rw[Once peg_eval_cases] >> + srw_tac[boolSimps.DNF_ss][] >> disj1_tac >> + rw[Once peg_eval_cases]); +(* +val cs = listLib.list_compset() +val () = pegLib.add_peg_compset cs +val () = computeLib.add_thms[sexpPEG_exec_thm,pnt_def,ignoreR_def,ignoreL_def,tokeq_def,pegf_def]cs + simp[MATCH_MP peg_eval_executed + (CONJ wfG_sexpPEG (EQT_ELIM(SIMP_CONV(srw_ss())[sexpPEG_def,Gexprs_sexpPEG]``sexpPEG.start ∈ Gexprs sexpPEG``)))] >> + CONV_TAC(computeLib.CBV_CONV cs) >> + IF_CASES_TAC >- fs[stringTheory.isGraph_def] >> + simp[choicel_def] >> + CONV_TAC(computeLib.CBV_CONV cs) >> simp[] >> +*) + +(* +val peg_eval_print_sexp = Q.prove( + `∀s. valid_sexp s ⇒ + peg_eval sexpPEG (print_sexp s,sexpPEG.start) (SOME ("",s))`, + ho_match_mp_tac(theorem"print_sexp_ind") >> + strip_tac >- ( + rw[print_sexp_def] + +val parse_print = Q.store_thm("parse_print", + `parse_sexp (print_sexp s) = SOME s`, + rw[parse_sexp_def] >> + Cases_on`pegparse sexpPEG (print_sexp s)` >> simp[] >- ( + imp_res_tac pegparse_eq_NONE >> fs[PEG_wellformed] >> + f"peg_eval" + reverse(Induct_on`s`) + >- ( + rw[print_sexp_def] >> + rw[parse_sexp_def] >> + pegparse_eq_SOME +*) + val _ = export_theory() From a211643561628c65ee67dd606c7b8bb96aa6ffc7 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 25 Sep 2015 16:48:42 +1000 Subject: [PATCH 520/718] Improve sexp parsing to handle dotted lists better Also move some peg_eval theorems from CakeML to pegTheory and use these to simplify proof about valid symbols. --- .../context-free/pegScript.sml | 76 +++++++++++++++++ .../context-free/selftest.sml | 1 + .../context-free/simpleSexpPEGScript.sml | 51 +++++++++--- .../context-free/simpleSexpParseScript.sml | 81 +++++-------------- 4 files changed, 139 insertions(+), 70 deletions(-) diff --git a/examples/formal-languages/context-free/pegScript.sml b/examples/formal-languages/context-free/pegScript.sml index 8ab2806f6e..4b13f09a9f 100644 --- a/examples/formal-languages/context-free/pegScript.sml +++ b/examples/formal-languages/context-free/pegScript.sml @@ -353,4 +353,80 @@ val checkAhead_def = Define` checkAhead P s = not (not (tok P ARB) ARB) ARB ~> s `; +val peg_eval_seq_SOME = store_thm( + "peg_eval_seq_SOME", + ``peg_eval G (i0, seq s1 s2 f) (SOME (i,r)) ⇔ + ∃i1 r1 r2. peg_eval G (i0, s1) (SOME (i1,r1)) ∧ + peg_eval G (i1, s2) (SOME (i,r2)) ∧ (r = f r1 r2)``, + simp[Once peg_eval_cases] >> metis_tac[]); + +val peg_eval_seq_NONE = store_thm( + "peg_eval_seq_NONE", + ``peg_eval G (i0, seq s1 s2 f) NONE ⇔ + peg_eval G (i0, s1) NONE ∨ + ∃i r. peg_eval G (i0,s1) (SOME(i,r)) ∧ + peg_eval G (i,s2) NONE``, + simp[Once peg_eval_cases] >> metis_tac[]); + +val peg_eval_tok_NONE = save_thm( + "peg_eval_tok_NONE", + ``peg_eval G (i, tok P f) NONE`` + |> SIMP_CONV (srw_ss()) [Once peg_eval_cases]) + +val peg_eval_tok_SOME = store_thm( + "peg_eval_tok_SOME", + ``peg_eval G (i0, tok P f) (SOME (i,r)) ⇔ ∃h. P h ∧ i0 = h::i ∧ r = f h``, + simp[Once peg_eval_cases] >> metis_tac[]); + +val peg_eval_empty = store_thm( + "peg_eval_empty[simp]", + ``peg_eval G (i, empty r) x ⇔ (x = SOME(i,r))``, + simp[Once peg_eval_cases]) + +val peg_eval_NT_SOME = store_thm( + "peg_eval_NT_SOME", + ``peg_eval G (i0,nt N f) (SOME(i,r)) ⇔ + ∃r0. r = f r0 ∧ N ∈ FDOM G.rules ∧ + peg_eval G (i0,G.rules ' N) (SOME(i,r0))``, + simp[Once peg_eval_cases]); + +val peg_eval_choice = store_thm( + "peg_eval_choice", + ``∀x. + peg_eval G (i0, choice s1 s2 f) x ⇔ + (∃i r. peg_eval G (i0, s1) (SOME(i, r)) ∧ x = SOME(i, f (INL r))) ∨ + (∃i r. peg_eval G (i0, s1) NONE ∧ + peg_eval G (i0, s2) (SOME(i, r)) ∧ x = SOME(i, f (INR r))) ∨ + peg_eval G (i0, s1) NONE ∧ peg_eval G (i0,s2) NONE ∧ (x = NONE)``, + simp[Once peg_eval_cases, SimpLHS] >> + simp[optionTheory.FORALL_OPTION, pairTheory.FORALL_PROD] >> metis_tac[]); + +val peg_eval_choicel_NIL = store_thm( + "peg_eval_choicel_NIL[simp]", + ``peg_eval G (i0, choicel []) x = (x = NONE)``, + simp[choicel_def, Once peg_eval_cases]); + +val peg_eval_choicel_CONS = store_thm( + "peg_eval_choicel_CONS", + ``∀x. peg_eval G (i0, choicel (h::t)) x ⇔ + peg_eval G (i0, h) x ∧ x <> NONE ∨ + peg_eval G (i0,h) NONE ∧ peg_eval G (i0, choicel t) x``, + simp[choicel_def, SimpLHS, Once peg_eval_cases] >> + simp[pairTheory.FORALL_PROD, optionTheory.FORALL_OPTION]); + +val peg_eval_rpt = store_thm( + "peg_eval_rpt", + ``peg_eval G (i0, rpt s f) x ⇔ + ∃i l. peg_eval_list G (i0,s) (i,l) ∧ x = SOME(i,f l)``, + simp[Once peg_eval_cases, SimpLHS] >> metis_tac[]); + +val peg_eval_list = Q.store_thm( + "peg_eval_list", + `peg_eval_list G (i0, e) (i, r) ⇔ + peg_eval G (i0, e) NONE ∧ i = i0 ∧ r = [] ∨ + (∃i1 rh rt. + peg_eval G (i0, e) (SOME (i1, rh)) ∧ + peg_eval_list G (i1, e) (i, rt) ∧ r = rh::rt)`, + simp[Once peg_eval_cases, SimpLHS] >> metis_tac[]); + val _ = export_theory() diff --git a/examples/formal-languages/context-free/selftest.sml b/examples/formal-languages/context-free/selftest.sml index dcf87712c7..e8074af4c3 100644 --- a/examples/formal-languages/context-free/selftest.sml +++ b/examples/formal-languages/context-free/selftest.sml @@ -47,6 +47,7 @@ val _ = print "\n" before app test [ ("(foo )", ``⦇SX_SYM "foo"⦈``), ("foo2", ``SX_SYM "foo2"``), ("(foo bar 3 4)", ``⦇ SX_SYM "foo"; SX_SYM "bar"; 3; 4 ⦈``), + ("(1 2 3 . 4)", ``SX_CONS 1 (SX_CONS 2 (SX_CONS 3 4))``), ("(3 . 4)", ``SX_CONS 3 4``), ("\"foo bar\"", ``SX_STR "foo bar"``), ("( \" foo \" \"bar\" )", ``⦇ SX_STR " foo "; SX_STR "bar" ⦈``), diff --git a/examples/formal-languages/context-free/simpleSexpPEGScript.sml b/examples/formal-languages/context-free/simpleSexpPEGScript.sml index 39d26ff331..89613d060d 100644 --- a/examples/formal-languages/context-free/simpleSexpPEGScript.sml +++ b/examples/formal-languages/context-free/simpleSexpPEGScript.sml @@ -59,6 +59,13 @@ val peg0_tokeq = store_thm( val pnt_def = Define`pnt ntsym = nt (mkNT ntsym) I` +val replace_nil_def= Define` + (replace_nil (SX_SYM s) z = if s = "nil" then z else SX_SYM s) ∧ + (replace_nil (SX_CONS x y) z = SX_CONS x (replace_nil y z)) ∧ + (replace_nil x y = x) +`; + + val sexpPEG_def = zDefine` sexpPEG : (char, sexpNT, sexp) peg = <| start := pnt sxnt_sexp ; @@ -68,17 +75,27 @@ val sexpPEG_def = zDefine` (mkNT sxnt_sexp0, choicel [ pnt sxnt_sexpnum ; - tokeq #"(" ~> pnt sxnt_sexpseq <~ grabWS (tokeq #")") ; - seq (tokeq #"(" ~> pnt sxnt_WSsexp) - (grabWS (tokeq #".") ~> pnt sxnt_WSsexp <~ grabWS (tokeq #")")) - SX_CONS ; + tokeq #"(" ~> pnt sxnt_sexpseq ; tokeq #"\"" ~> pnt sxnt_strcontents <~ tokeq #"\"" ; pegf (tokeq #"'" ~> grabWS (pnt sxnt_sexp0)) (λs. ⦇ SX_SYM "quote"; s⦈) ; pnt sxnt_sexpsym ]); (mkNT sxnt_sexpseq, - rpt (pnt sxnt_WSsexp) (FOLDR SX_CONS (SX_SYM "nil"))); + choicel [ + pegf (grabWS (tokeq #")")) (K (SX_SYM "nil")); + seq (grabWS (pnt sxnt_sexp0)) + (seq (rpt (grabWS (pnt sxnt_sexp0)) + (FOLDR SX_CONS (SX_SYM "nil"))) + (choicel [ + pegf (grabWS (tokeq #")")) (K (SX_SYM "nil")); + grabWS (tokeq #".") ~> + grabWS (pnt sxnt_sexp0) + <~ grabWS (tokeq #")") + ]) + replace_nil) + SX_CONS + ]); (mkNT sxnt_WSsexp, rpt (tok isSpace ARB) (K ARB) ~> pnt sxnt_sexp0); (mkNT sxnt_sexpnum, @@ -108,7 +125,9 @@ val sexpPEG_def = zDefine` |> `; -val sexpPEG_start = SIMP_CONV(srw_ss())[sexpPEG_def]``sexpPEG.start`` +val sexpPEG_start = save_thm( + "sexpPEG_start[simp]", + SIMP_CONV(srw_ss())[sexpPEG_def]``sexpPEG.start``) val ds = derive_compset_distincts ``:sexpNT`` val {lookups,fdom_thm,applieds} = derive_lookup_ths {pegth = sexpPEG_def, ntty = ``:sexpNT``, simp = SIMP_CONV (srw_ss())} val sexpPEG_exec_thm = save_thm("sexpPEG_exec_thm",LIST_CONJ(sexpPEG_start::ds::lookups)) @@ -135,8 +154,9 @@ val wfpeg_rwts = wfpeg_cases ]) |> map (CONV_RULE (RAND_CONV (SIMP_CONV (srw_ss()) - [choicel_def, tokeq_def, - pegf_def]))) + [choicel_def, tokeq_def, ignoreL_def, + ignoreR_def, pegf_def, grabWS_def]))) + val wfpeg_pnt = wfpeg_cases |> ISPEC ``sexpPEG`` @@ -153,6 +173,11 @@ val peg0_rwts = peg0_cases (RAND_CONV (SIMP_CONV (srw_ss()) [tokeq_def]))) +val wfpeg_grabWS = + SIMP_CONV (srw_ss()) (grabWS_def::ignoreL_def::wfpeg_rwts @ peg0_rwts) + ``wfpeg sexpPEG (grabWS e)`` + + val pegfail_t = ``pegfail`` val peg0_rwts = let fun filterthis th = let @@ -205,13 +230,19 @@ val npeg0_WSsexp = Q.prove( val npeg0_rwts = npeg0_WSsexp::npeg0_sexp0::npeg0_rwts +val peg0_grabWS = Q.prove( + `peg0 sexpPEG (grabWS e) = peg0 sexpPEG e`, + simp(ignoreL_def::grabWS_def::peg0_rwts)); + fun wfnt(t,acc) = let val th = prove(``wfpeg sexpPEG (pnt ^t)``, SIMP_TAC (srw_ss()) (applieds @ - [wfpeg_pnt, fdom_thm, ignoreL_def, ignoreR_def, checkAhead_def]) THEN - fs(wfpeg_rwts @ npeg0_rwts @ peg0_rwts @ acc)) + [wfpeg_pnt, fdom_thm, ignoreL_def, ignoreR_def, + checkAhead_def]) THEN + fs(peg0_grabWS :: wfpeg_grabWS :: wfpeg_rwts @ npeg0_rwts @ + peg0_rwts @ acc)) in th::acc end; diff --git a/examples/formal-languages/context-free/simpleSexpParseScript.sml b/examples/formal-languages/context-free/simpleSexpParseScript.sml index 5481801b89..e54a4728fa 100644 --- a/examples/formal-languages/context-free/simpleSexpParseScript.sml +++ b/examples/formal-languages/context-free/simpleSexpParseScript.sml @@ -57,66 +57,27 @@ val peg_eval_valid_symchars = Q.prove( val peg_eval_valid_symbol = Q.prove( `∀s. valid_symbol s ⇒ peg_eval sexpPEG (s,sexpPEG.start) (SOME ("",SX_SYM s))`, - Cases_on`s`>>simp[]>>rw[]>> - rw[Once peg_eval_cases,sexpPEG_exec_thm,pnt_def,FDOM_sexpPEG,sexpPEG_applied,ignoreR_def] >> - rw[Once peg_eval_cases] >> - rw[Once peg_eval_cases,FDOM_sexpPEG,sexpPEG_applied,ignoreL_def] >> - rw[Once peg_eval_cases,PULL_EXISTS] >> - rw[Once peg_eval_cases,PULL_EXISTS] >> - rw[Once peg_eval_cases,PULL_EXISTS] >> - srw_tac[boolSimps.DNF_ss][] >> disj1_tac >> - rw[Once peg_eval_cases,PULL_EXISTS] >> - simp[GSYM PULL_EXISTS] >> - conj_tac >- fs[stringTheory.isGraph_def] >> - rw[Once peg_eval_cases,PULL_EXISTS,pnt_def,FDOM_sexpPEG,sexpPEG_applied,choicel_def] >> - rw[Once peg_eval_cases,PULL_EXISTS] >> - srw_tac[boolSimps.DNF_ss][] >> disj2_tac >> - rw[Once peg_eval_cases,PULL_EXISTS,pnt_def,FDOM_sexpPEG,sexpPEG_applied] >> - rw[Once peg_eval_cases,PULL_EXISTS] >> - srw_tac[boolSimps.DNF_ss][] >> disj1_tac >> - rw[Once peg_eval_cases,PULL_EXISTS,pnt_def,FDOM_sexpPEG,sexpPEG_applied] >> - rw[Once peg_eval_cases,PULL_EXISTS] >> - rw[Once peg_eval_cases,PULL_EXISTS,ignoreR_def,ignoreL_def] >> - rw[Once peg_eval_cases,PULL_EXISTS] >> - srw_tac[boolSimps.DNF_ss][] >> disj2_tac >> - rw[Once peg_eval_cases,PULL_EXISTS] >> - srw_tac[boolSimps.DNF_ss][] >> disj1_tac >> - rw[Once peg_eval_cases,PULL_EXISTS,tokeq_def] >> - srw_tac[boolSimps.DNF_ss][] >> disj1_tac >> - rw[Once peg_eval_cases,PULL_EXISTS] >> - rw[Once peg_eval_cases,PULL_EXISTS] >> - srw_tac[boolSimps.DNF_ss][] >> disj2_tac >> - rw[Once peg_eval_cases,PULL_EXISTS] >> - srw_tac[boolSimps.DNF_ss][] >> disj1_tac >> - rw[Once peg_eval_cases,PULL_EXISTS] >> - srw_tac[boolSimps.DNF_ss][] >> disj1_tac >> - rw[Once peg_eval_cases,PULL_EXISTS] >> - rw[Once peg_eval_cases,PULL_EXISTS] >> - srw_tac[boolSimps.DNF_ss][] >> disj2_tac >> - rw[Once peg_eval_cases,PULL_EXISTS] >> - srw_tac[boolSimps.DNF_ss][] >> disj1_tac >> - rw[Once peg_eval_cases,PULL_EXISTS] >> - srw_tac[boolSimps.DNF_ss][] >> disj1_tac >> - rw[Once peg_eval_cases,PULL_EXISTS] >> - rw[Once peg_eval_cases,PULL_EXISTS] >> - srw_tac[boolSimps.DNF_ss][] >> disj2_tac >> - rw[Once peg_eval_cases,PULL_EXISTS,pegf_def] >> - srw_tac[boolSimps.DNF_ss][] >> disj1_tac >> - rw[Once peg_eval_cases,PULL_EXISTS] >> - srw_tac[boolSimps.DNF_ss][] >> disj1_tac >> - rw[Once peg_eval_cases,PULL_EXISTS] >> - rw[Once peg_eval_cases,PULL_EXISTS] >> - srw_tac[boolSimps.DNF_ss][] >> disj1_tac >> - rw[Once peg_eval_cases,PULL_EXISTS,FDOM_sexpPEG,sexpPEG_applied] >> - rw[Once peg_eval_cases,PULL_EXISTS] >> - rw[Once peg_eval_cases,PULL_EXISTS,destSXSYM_def] >> - imp_res_tac peg_eval_valid_symchars >> - map_every qexists_tac[`""`,`ARB`,`SX_SYM t`] >> - simp[destSXSYM_def] >> - rw[Once peg_eval_cases] >> - rw[Once peg_eval_cases] >> - srw_tac[boolSimps.DNF_ss][] >> disj1_tac >> - rw[Once peg_eval_cases]); + Cases_on`s`>> + simp[pnt_def, peg_eval_NT_SOME, FDOM_sexpPEG, sexpPEG_applied, + ignoreL_def, ignoreR_def, peg_eval_seq_SOME, peg_eval_rpt] >> + dsimp[] >> strip_tac >> + `¬isSpace h` by (strip_tac >> Cases_on `h` >> fs[stringTheory.isGraph_def]) >> + simp[Once peg_eval_list, SimpL ``$/\``] >> + simp[peg_eval_tok_SOME, peg_eval_tok_NONE] >> + simp[peg_eval_choicel_CONS, peg_eval_NT_SOME, FDOM_sexpPEG, sexpPEG_applied, + peg_eval_seq_SOME, peg_eval_tok_SOME, peg_eval_tok_NONE, tokeq_def, + peg_eval_seq_NONE, pegf_def, pnt_def, destSXSYM_def] >> dsimp[] >> + simp[Once peg_eval_cases, SimpL ``$/\``] >> + dsimp[FDOM_sexpPEG, sexpPEG_applied, peg_eval_seq_NONE, pnt_def, + peg_eval_rpt] >> + simp[Once peg_eval_cases, SimpL ``$/\``] >> + dsimp[FDOM_sexpPEG, sexpPEG_applied, peg_eval_seq_NONE, pnt_def, + peg_eval_rpt, peg_eval_tok_NONE] >> + IMP_RES_THEN mp_tac peg_eval_valid_symchars >> + dsimp[peg_eval_rpt] >> qx_gen_tac `l` >> strip_tac >> + map_every qexists_tac[`""`,`[]`,`l`] >> + simp[destSXSYM_def] >> rw[] >> + rw[Once peg_eval_cases] >> simp[peg_eval_tok_NONE]); (* val cs = listLib.list_compset() val () = pegLib.add_peg_compset cs From 3c51e8d41a9c2a9e3c4b99b6464053495e018cce Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 25 Sep 2015 16:53:08 +1000 Subject: [PATCH 521/718] One more parsing test for repeated "dot-conses" --- examples/formal-languages/context-free/selftest.sml | 1 + 1 file changed, 1 insertion(+) diff --git a/examples/formal-languages/context-free/selftest.sml b/examples/formal-languages/context-free/selftest.sml index e8074af4c3..383a4297f3 100644 --- a/examples/formal-languages/context-free/selftest.sml +++ b/examples/formal-languages/context-free/selftest.sml @@ -48,6 +48,7 @@ val _ = print "\n" before app test [ ("foo2", ``SX_SYM "foo2"``), ("(foo bar 3 4)", ``⦇ SX_SYM "foo"; SX_SYM "bar"; 3; 4 ⦈``), ("(1 2 3 . 4)", ``SX_CONS 1 (SX_CONS 2 (SX_CONS 3 4))``), + ("(1 . (2 . (3 . 4)))", ``SX_CONS 1 (SX_CONS 2 (SX_CONS 3 4))``), ("(3 . 4)", ``SX_CONS 3 4``), ("\"foo bar\"", ``SX_STR "foo bar"``), ("( \" foo \" \"bar\" )", ``⦇ SX_STR " foo "; SX_STR "bar" ⦈``), From 9d4c7968226373cafe63502ca7c5971a1eb7969b Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Sun, 27 Sep 2015 21:17:50 +1000 Subject: [PATCH 522/718] docs for PART_MATCH_A and REWR_CONV_A --- help/Docfiles/Conv.REWR_CONV.doc | 6 +++- help/Docfiles/Conv.REWR_CONV_A.doc | 41 ++++++++++++++++++++++++++++ help/Docfiles/Drule.PART_MATCH.doc | 7 ++++- help/Docfiles/Drule.PART_MATCH_A.doc | 15 ++++++++++ 4 files changed, 67 insertions(+), 2 deletions(-) create mode 100644 help/Docfiles/Conv.REWR_CONV_A.doc create mode 100644 help/Docfiles/Drule.PART_MATCH_A.doc diff --git a/help/Docfiles/Conv.REWR_CONV.doc b/help/Docfiles/Conv.REWR_CONV.doc index e65a82493e..cd5ac002d7 100644 --- a/help/Docfiles/Conv.REWR_CONV.doc +++ b/help/Docfiles/Conv.REWR_CONV.doc @@ -100,6 +100,10 @@ can be obtained by instantiation of free type variables (i.e. type variables not occurring in the assumptions {A}) and substitution for the free variables {x1}, ..., {xn}. +As noted, {REWR_CONV th} will fail rather than substitute for variables or type +variables which appear in the hypotheses {A}. To allow substitution in the +hypotheses, use {REWR_CONV_A th}. + \EXAMPLE The following example illustrates a straightforward use of {REWR_CONV}. The supplied rewrite rule is polymorphic, and both substitution for free @@ -141,5 +145,5 @@ variable (in this case {n}) which is also free in the assumptions, but which must be instantiated in order to match the input term. \SEEALSO -Rewrite.REWRITE_CONV. +Conv.REWR_CONV_A, Rewrite.REWRITE_CONV. \ENDDOC diff --git a/help/Docfiles/Conv.REWR_CONV_A.doc b/help/Docfiles/Conv.REWR_CONV_A.doc new file mode 100644 index 0000000000..ccc00b2bf2 --- /dev/null +++ b/help/Docfiles/Conv.REWR_CONV_A.doc @@ -0,0 +1,41 @@ +\DOC REWR_CONV_A + +\TYPE {REWR_CONV_A : (thm -> conv)} + +\SYNOPSIS +Uses an instance of a given equation to rewrite a term. + +\KEYWORDS +conversion. + +\DESCRIBE +{REWR_CONV_A th} behaves as +{REWR_CONV th} except that it allows substitution of variables or type +variables which appear in the hypotheses of {th}. + +\EXAMPLE +Consider the theorem {th} +{ + [0 < n] |- (a * n = b * (n : int)) <=> (a = b) +} +and the term {tm} +{ + f (a * m = b * (m : int)) x +} +Then {DEPTH_CONV (REWR_CONV_A th) tm} returns +{ + [0 < m] |- f (a * m = b * m) x <=> f (a = b) x +} +Likewise, when the goal is {tm} above, +{e (VALIDATE (CONV_TAC (DEPTH_CONV (REWR_CONV_A th))))} +gives the two subgoals: +{ + f (a = b) x + + 0 < m +} + +\SEEALSO +Conv.REWR_CONV, Rewrite.REWRITE_CONV, +Conv.DEPTH_CONV, Tactic.CONV_TAC, Tactical.VALIDATE. +\ENDDOC diff --git a/help/Docfiles/Drule.PART_MATCH.doc b/help/Docfiles/Drule.PART_MATCH.doc index 0465160946..fd71f474b3 100644 --- a/help/Docfiles/Drule.PART_MATCH.doc +++ b/help/Docfiles/Drule.PART_MATCH.doc @@ -24,6 +24,11 @@ returned. Fails if the selector function {fn} fails when applied to the instantiated theorem, or if the match fails with the term it has provided. +Since {PART_MATCH} will not instantiate variables which appear in the +hypotheses of the given theorem, it fails if the attempted match would require +instantiating these variables. +To allow instantiation of these variables, use {PART_MATCH_A}. + \EXAMPLE Suppose that we have the following theorem: { @@ -42,6 +47,6 @@ because the selector function picks the antecedent of the implication it to {T}. \SEEALSO -Thm.INST_TYPE, Drule.INST_TY_TERM, Term.match_term. +Drule.PART_MATCH_A, Thm.INST_TYPE, Drule.INST_TY_TERM, Term.match_term. \ENDDOC diff --git a/help/Docfiles/Drule.PART_MATCH_A.doc b/help/Docfiles/Drule.PART_MATCH_A.doc new file mode 100644 index 0000000000..ecbab8d993 --- /dev/null +++ b/help/Docfiles/Drule.PART_MATCH_A.doc @@ -0,0 +1,15 @@ +\DOC PART_MATCH_A + +\TYPE {PART_MATCH_A : (term -> term) -> thm -> term -> thm} + +\SYNOPSIS +Instantiates a theorem by matching part of its conclusion to a term. + +\DESCRIBE +{PART_MATCH_A} behaves as {PART_MATCH} except that it permits instantiating +variables which appear in the assumptions of the given theorem. + +\SEEALSO +Drule.PART_MATCH, Conv.REWR_CONV_A + +\ENDDOC From 10c492ffa3461bb91cbf723e4ce390e639124211 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Mon, 28 Sep 2015 22:13:21 +1000 Subject: [PATCH 523/718] make type parser honour qualified abbreviations arguably should have been done for #168 --- src/parse/parse_type.sml | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/parse/parse_type.sml b/src/parse/parse_type.sml index 5818e456fb..da50319d22 100644 --- a/src/parse/parse_type.sml +++ b/src/parse/parse_type.sml @@ -131,7 +131,10 @@ fun parse_type tyfns allow_unknown_suffixes G = let | SOME st => structure_to_value (s,locn) args st end end - | QTypeIdent(thy,ty) => qtyop{Thy=thy,Tyop=ty,Locn=locn,Args=args} + | QTypeIdent(thy,ty) => + (case Binarymap.peek(abbrevs, {Name = ty, Thy = thy}) of + NONE => qtyop{Thy=thy,Tyop=ty,Locn=locn,Args=args} + | SOME st => structure_to_value (ty,locn) args st) | _ => raise Fail "parse_type.apply_tyop: can't happen" fun apply_asfx locn (base,index) = From edbcd360c0d0669c3e612a497c767c7ef4b2369d Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 29 Sep 2015 09:28:26 +1000 Subject: [PATCH 524/718] Test for the behaviour implemented in 10c492ffa3 Fallout from imperfectly handled issue #168 --- src/1/theory_tests/gh168dScript.sml | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 src/1/theory_tests/gh168dScript.sml diff --git a/src/1/theory_tests/gh168dScript.sml b/src/1/theory_tests/gh168dScript.sml new file mode 100644 index 0000000000..0c34482cfe --- /dev/null +++ b/src/1/theory_tests/gh168dScript.sml @@ -0,0 +1,15 @@ +open HolKernel Parse boolLib + +open gh294aTheory gh294bTheory testutils + +val _ = new_theory "gh168d"; + +val b2b = bool --> bool +val b2b2b = bool --> b2b +val ty1 = ``:gh294a$foo`` +val ty2 = ``:gh294b$foo`` + +val _ = assert (equal b2b) ty1 +val _ = assert (equal b2b2b) ty2 + +val _ = export_theory(); From e9827f1462d62fd3ded4803300bdd9345adfd809 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 29 Sep 2015 10:05:05 +1000 Subject: [PATCH 525/718] Implement/document/test thytype_abbrev This function allows better control of type abbreviations in their theory namespaces. --- help/Docfiles/Parse.thytype_abbrev.doc | 46 ++++++++++++++++++++++++++ help/Docfiles/Parse.type_abbrev.doc | 2 +- src/1/theory_tests/gh168eScript.sml | 25 ++++++++++++++ src/parse/Parse.sig | 1 + src/parse/Parse.sml | 30 ++++++++++------- 5 files changed, 91 insertions(+), 13 deletions(-) create mode 100644 help/Docfiles/Parse.thytype_abbrev.doc create mode 100644 src/1/theory_tests/gh168eScript.sml diff --git a/help/Docfiles/Parse.thytype_abbrev.doc b/help/Docfiles/Parse.thytype_abbrev.doc new file mode 100644 index 0000000000..f3a89bcc81 --- /dev/null +++ b/help/Docfiles/Parse.thytype_abbrev.doc @@ -0,0 +1,46 @@ +\DOC + +\TYPE {thytype_abbrev : {Name:string,Thy:string} * hol_type -> unit} + +\SYNOPSIS +Abbreviates a type to a specific theory-qualified name. + +\KEYWORDS +Parsing, pretty-printing. + +\DESCRIBE +A call to {thytype_abbrev({Name=n,Thy=t}, ty)} establishes the +``kernel'' name {t$n} as an abbreviation for the type {ty}, as happens +with {type_abbrev}. In other words, after the call it becomes possible +to write ``:args t$n`` to stand for type {ty}. If there are type +variables in {ty} they become the parameters to the new abbreviated +type operator. These parameters need to be filled in in the {args} +position above. If there are no type variables in {ty} then +abbreviation is of a whole type, and {args} must be blank. + +If there was an existing abbreviation for {t$n}, then this will be +replaced by the call. + +In addition, after the given call, this abbreviation will become the +preferred binding for the bare name {n}. Other abbreviations in +different theories will need to use the form with fully-qualified +names ({thy1$n}, {thy2$n} etc). + +\FAILURE +Fails if {ty} is a variable type. + +\COMMENTS +As with other parsing and pretty-printing functions, there is a +companion function, {temp_thytype_abbrev}, which has the same effect +on the global grammar but does not cause the change to persist when +the theory is exported. + +It is legitimate to use a string for the theory component of the +record that does not correspond to the current theory. Indeed, it is +perfectly reasonable to do this, if one wants to give priority to a +particular ancestral abbreviation. + +\SEEALSO +Parse.type_abbrev. + +\ENDDOC diff --git a/help/Docfiles/Parse.type_abbrev.doc b/help/Docfiles/Parse.type_abbrev.doc index 7a4b963240..9e3b246ce0 100644 --- a/help/Docfiles/Parse.type_abbrev.doc +++ b/help/Docfiles/Parse.type_abbrev.doc @@ -64,5 +64,5 @@ abbreviations (using {Parse.disable_tyabbrev_printing}), or to not print any (by setting the trace variable {"print_tyabbrevs"}). \SEEALSO -Parse.add_infix_type, Parse.disable_tyabbrev_printing, Parse.remove_type_abbrev. +Parse.add_infix_type, Parse.disable_tyabbrev_printing, Parse.remove_type_abbrev, Parse.thytype_abbrev. \ENDDOC diff --git a/src/1/theory_tests/gh168eScript.sml b/src/1/theory_tests/gh168eScript.sml new file mode 100644 index 0000000000..f221707aeb --- /dev/null +++ b/src/1/theory_tests/gh168eScript.sml @@ -0,0 +1,25 @@ +open HolKernel Parse boolLib + +open gh294aTheory gh294bTheory testutils + +val _ = new_theory "gh168e"; + +val b2b = bool --> bool +val b2b2b = bool --> b2b + +val tyg0 = type_grammar() +val privthy = Binarymap.find(type_grammar.privileged_abbrevs tyg0, "foo") +val unprivthy = if privthy = "gh294a" then "gh294b" else "gh294a" + +val (privty, unprivty) = if privthy = "gh294a" then (b2b, b2b2b) + else (b2b2b, b2b) + +val ty = ``:foo`` +val _ = assert (equal privty) ty + +val _ = temp_thytype_abbrev ({Name = "foo", Thy = unprivthy}, unprivty) + +val ty = ``:foo`` +val _ = assert (equal unprivty) ty + +val _ = export_theory(); diff --git a/src/parse/Parse.sig b/src/parse/Parse.sig index d5ce175828..0de9d29228 100644 --- a/src/parse/Parse.sig +++ b/src/parse/Parse.sig @@ -34,6 +34,7 @@ signature Parse = sig Assoc : associativity} -> unit val temp_thytype_abbrev : KernelSig.kernelname * hol_type -> unit + val thytype_abbrev : KernelSig.kernelname * hol_type -> unit val temp_type_abbrev : string * hol_type -> unit val type_abbrev : string * hol_type -> unit val temp_disable_tyabbrev_printing : string -> unit diff --git a/src/parse/Parse.sml b/src/parse/Parse.sml index f77c505bfe..73b2d8f250 100644 --- a/src/parse/Parse.sml +++ b/src/parse/Parse.sml @@ -703,7 +703,12 @@ fun add_infix_type (x as {Name, ParseName, Assoc, Prec}) = let in ", Prec = ", Int.toString Prec, "}"]) end -fun temp_thytype_abbrev(knm, ty) = let +fun replace_exnfn fnm f x = + f x handle HOL_ERR {message = m, origin_structure = s, ...} => + raise HOL_ERR {message = m, origin_function = fnm, + origin_structure = s} + +fun temp_thytype_abbrev (knm, ty) = let val params = Listsort.sort Type.compare (type_vars ty) val (num_vars, pset) = List.foldl (fn (ty,(i,pset)) => (i + 1, Binarymap.insert(pset,ty,i))) @@ -721,18 +726,11 @@ in (knm, mk_structure pset ty); type_grammar_changed := true; term_grammar_changed := true -end handle GrammarError s => raise ERROR "type_abbrev" s - -fun temp_type_abbrev (s, ty) = let - val thy = Theory.current_theory() -in - temp_thytype_abbrev({Thy = thy, Name = s}, ty) -end +end handle GrammarError s => raise ERR "temp_thytype_abbrev" s -fun type_abbrev (s, ty) = let - val knm = {Thy=Theory.current_theory(),Name=s} +fun thytype_abbrev(knm, ty) = let in - temp_type_abbrev (s, ty); + replace_exnfn "thytype_abbrev" temp_thytype_abbrev (knm, ty); full_update_grms ("temp_thytype_abbrev", String.concat ["(", KernelSig.name_toMLString knm, ", ", PP.pp_to_string (!Globals.linewidth) @@ -741,7 +739,15 @@ in ")"], SOME (mk_thy_const{Name = "ARB", Thy = "bool", Ty = ty}) ) -end; +end + +fun temp_type_abbrev (s, ty) = + replace_exnfn "temp_type_abbrev" temp_thytype_abbrev + ({Thy = Theory.current_theory(), Name = s}, ty) + +fun type_abbrev (s, ty) = + replace_exnfn "type_abbrev" thytype_abbrev + ({Thy = Theory.current_theory(), Name = s}, ty) fun temp_disable_tyabbrev_printing s = let val tyg = the_type_grammar From 4b082abcea847ee93bed98576aea3c34e08298aa Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 1 Oct 2015 11:34:35 +1000 Subject: [PATCH 526/718] Tests for prettyprinting polymorphic record ops Github issue #150 --- src/datatype/selftest.sml | 26 +++++++++++++++++++++++++- 1 file changed, 25 insertions(+), 1 deletion(-) diff --git a/src/datatype/selftest.sml b/src/datatype/selftest.sml index 2380168139..61f7245be6 100644 --- a/src/datatype/selftest.sml +++ b/src/datatype/selftest.sml @@ -217,6 +217,11 @@ val _ = Hol_datatype`ovlrcd = <| id : num ; opn : num -> num |>` val _ = overload_on ("ID", ``f.id``) val _ = overload_on ("inv", ``f.opn``) +val _ = type_abbrev ("ms", ``:'a -> num``) +val _ = Hol_datatype` + polyrcd = <| pfld1 : 'a ms ; pfld2 : 'b -> bool ; pfld3 : num|> +`; + val _ = List.app pptest [("field selection", ``r.fld2``, "r.fld2"), ("field sel. for fn type", ``r.fld1 x``, "r.fld1 x"), @@ -237,7 +242,26 @@ val _ = List.app pptest s ``r with <| fld3 := 6; fld9 := (T,6)|>``, "r with <|fld3 := 6; fld9 := (T,6)|>"), ("overloaded bare var.fld", ``ID``, "ID"), - ("overloaded var.fld with args", ``inv x``, "inv x") + ("overloaded var.fld with args", ``inv x``, "inv x"), + ("poly simple upd", ``r : ('c,num) polyrcd with pfld1 := K 1``, + "r with pfld1 := K 1"), + ("poly simple seln", ``(r : ('c,'d)polyrcd).pfld1``, "r.pfld1"), + ("bare ('a,'b) polyrcd_pfld1", + ``polyrcd_pfld1 : ('a,'b) polyrcd -> 'a ms``, "polyrcd_pfld1"), + ("bare ('a,'b) polyrcd_pfld1_fupd", + ``polyrcd_pfld1_fupd : + ('a ms -> 'a ms) -> ('a,'b) polyrcd -> ('a,'b) polyrcd``, + "polyrcd_pfld1_fupd"), + ("bare (num,num) polyrcd_pfld1", + ``polyrcd_pfld1 : (num,num) polyrcd -> num ms``, "polyrcd_pfld1"), + ("bare ('c,'d) polyrcd_pfld1", + ``polyrcd_pfld1 : ('c,'d) polyrcd -> 'c ms``, "polyrcd_pfld1"), + ("bare ('c,'d) polyrcd_pfld3", + ``polyrcd_pfld3 : ('c,'d) polyrcd -> num``, "polyrcd_pfld3"), + ("bare ('c,'d) polyrcd_pfld1_fupd", + ``polyrcd_pfld1_fupd : + ('c ms -> 'c ms) -> ('c,'d) polyrcd -> ('c,'d) polyrcd``, + "polyrcd_pfld1_fupd") ] val _ = Feedback.emit_MESG := false From fbeddafb1073f829ae9ab2d8b75360c8dfefa346 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 1 Oct 2015 11:54:19 +1000 Subject: [PATCH 527/718] Print bare polymorphic record operations better. Closes #150 --- src/parse/term_pp.sml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/parse/term_pp.sml b/src/parse/term_pp.sml index 18bc12b008..31c180c32a 100644 --- a/src/parse/term_pp.sml +++ b/src/parse/term_pp.sml @@ -1659,7 +1659,7 @@ fun pp_term (G : grammar) TyG backend = let case Overload.info_for_name overload_info Name of NONE => add_prim_name() | SOME {actual_ops,...} => - if List.exists (aconv tm) actual_ops then + if List.exists (same_const tm) actual_ops then cope_with_rules Name else add_prim_name() From 95616e2a9a59c5dc60a38dac67305b720b42e4a6 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 1 Oct 2015 11:59:25 +1000 Subject: [PATCH 528/718] Another record pretty-printing bug. It should be reasonable to write rcdname_fldname_fupd f which is a function that takes a record, applies f to the given field, and returns the updated record. Unfortunately, it gets printed in hideous fashion. --- src/datatype/selftest.sml | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/datatype/selftest.sml b/src/datatype/selftest.sml index 61f7245be6..c91a0fb774 100644 --- a/src/datatype/selftest.sml +++ b/src/datatype/selftest.sml @@ -261,7 +261,10 @@ val _ = List.app pptest ("bare ('c,'d) polyrcd_pfld1_fupd", ``polyrcd_pfld1_fupd : ('c ms -> 'c ms) -> ('c,'d) polyrcd -> ('c,'d) polyrcd``, - "polyrcd_pfld1_fupd") + "polyrcd_pfld1_fupd"), + ("one-arg polyrcd_pfld1_fupd", + ``polyrcd_pfld1_fupd f : ('a,'b) polyrcd -> ('a,'b) polyrcd``, + "polyrcd_pfld1_fupd f") ] val _ = Feedback.emit_MESG := false From 2d9842258d7664683e657354dab71f68e8b17e79 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 1 Oct 2015 15:42:48 +1000 Subject: [PATCH 529/718] Fix another record pretty-printing problem --- doc/next-release.md | 2 ++ src/datatype/selftest.sml | 6 +++--- src/parse/Parse.sml | 34 ++++++++++++++++------------- src/parse/term_pp.sml | 45 ++++++++++++--------------------------- 4 files changed, 38 insertions(+), 49 deletions(-) diff --git a/doc/next-release.md b/doc/next-release.md index f9e014047e..f6ecb8f24b 100644 --- a/doc/next-release.md +++ b/doc/next-release.md @@ -62,6 +62,8 @@ Bugs fixed: - The function `thm_to_string` was creating ugly strings full of special codes (encoding type information) rather than using the “raw” backend. +- Bare record operations (*e.g.*, `rcdtype_field`, the function that accesses `field` of type `rcdtype`) would occasionally pretty-print badly. ([Github issue](http://github.com/HOL-Theorem-Prover/HOL/issues/150)) + New theories: ------------- diff --git a/src/datatype/selftest.sml b/src/datatype/selftest.sml index c91a0fb774..f20ecea576 100644 --- a/src/datatype/selftest.sml +++ b/src/datatype/selftest.sml @@ -251,7 +251,7 @@ val _ = List.app pptest ("bare ('a,'b) polyrcd_pfld1_fupd", ``polyrcd_pfld1_fupd : ('a ms -> 'a ms) -> ('a,'b) polyrcd -> ('a,'b) polyrcd``, - "polyrcd_pfld1_fupd"), + "pfld1_fupd"), ("bare (num,num) polyrcd_pfld1", ``polyrcd_pfld1 : (num,num) polyrcd -> num ms``, "polyrcd_pfld1"), ("bare ('c,'d) polyrcd_pfld1", @@ -261,10 +261,10 @@ val _ = List.app pptest ("bare ('c,'d) polyrcd_pfld1_fupd", ``polyrcd_pfld1_fupd : ('c ms -> 'c ms) -> ('c,'d) polyrcd -> ('c,'d) polyrcd``, - "polyrcd_pfld1_fupd"), + "pfld1_fupd"), ("one-arg polyrcd_pfld1_fupd", ``polyrcd_pfld1_fupd f : ('a,'b) polyrcd -> ('a,'b) polyrcd``, - "polyrcd_pfld1_fupd f") + "pfld1_fupd f") ] val _ = Feedback.emit_MESG := false diff --git a/src/parse/Parse.sml b/src/parse/Parse.sml index 73b2d8f250..50bcb0b657 100644 --- a/src/parse/Parse.sml +++ b/src/parse/Parse.sml @@ -1213,29 +1213,33 @@ in end -fun temp_add_record_field (fldname, term) = let +fun primadd_rcdfld f ovopn (fldname, t) = let + val (d,r) = dom_rng (type_of t) + handle HOL_ERR _ => + raise ERROR f "field selection term must be of type t -> a" + val r = mk_var("rcd", d) val recfldname = recsel_special^fldname in - temp_overload_on(recfldname, term) + ovopn(recfldname, mk_abs(r, mk_comb(t, r))) end -fun add_record_field (fldname, term) = let - val recfldname = recsel_special^fldname -in - overload_on(recfldname, term) -end +val temp_add_record_field = + primadd_rcdfld "temp_add_record_field" temp_overload_on +val add_record_field = primadd_rcdfld "add_record_field" overload_on -fun temp_add_record_fupdate (fldname, term) = let - val recfldname = recfupd_special ^ fldname +fun buildfupdt f ovopn (fnm, t) = let + val (argtys, rty) = strip_fun (type_of t) + val err = ERROR f "fupdate term must be of type (a -> a) -> t -> t" + val f = mk_var("f", hd argtys) handle Empty => raise err + val x = mk_var("x", hd (tl argtys)) handle Empty => raise err + val recfldname = recfupd_special ^ fnm in - temp_overload_on(recfldname, term) + ovopn(recfldname, list_mk_abs([f,x], list_mk_comb(t, [f,x]))) end -fun add_record_fupdate (fldname, term) = let - val recfldname = recfupd_special ^ fldname -in - overload_on(recfldname, term) -end +val temp_add_record_fupdate = + buildfupdt "temp_add_record_fupdate" temp_overload_on +val add_record_fupdate = buildfupdt "add_record_fupdate" overload_on fun temp_add_numeral_form (c, stropt) = let val _ = diff --git a/src/parse/term_pp.sml b/src/parse/term_pp.sml index 31c180c32a..18f3899de8 100644 --- a/src/parse/term_pp.sml +++ b/src/parse/term_pp.sml @@ -1004,18 +1004,23 @@ fun pp_term (G : grammar) TyG backend = let isSome recfupd_info andalso isSome recupd_info then let open Overload + fun ap1 t = let val (d,_) = dom_rng (type_of t) + in mk_comb(t,genvar d) end + fun ap2 t = t |> ap1 |> ap1 + fun fupdstr0 t = + t |> ap2 |> Overload.oi_strip_comb overload_info + |> Option.map (atom_name o #1) + val fupdstr = Option.join o Lib.total fupdstr0 (* function to determine if t is a record update *) fun is_record_update t = - if is_comb t andalso is_const (rator t) then let - val rname = overloading_of_term overload_info (rator t) - in - case rname of + if is_comb t andalso is_const (rator t) then + case fupdstr (rator t) of SOME s => (!prettyprint_bigrecs andalso isSuffix "_fupd" s andalso is_substring (bigrec_subdivider_string ^ "sf") s) orelse isPrefix recfupd_special s | NONE => false - end else false + else false (* descend the rands of a term until one that is not a record update is found. Return this and the list of rators up to this point. *) @@ -1027,7 +1032,7 @@ fun pp_term (G : grammar) TyG backend = let fun categorise_bigrec_updates v = let fun bigrec_update t = if is_comb t then - case overloading_of_term overload_info (rator t) of + case fupdstr (rator t) of SOME s => if is_substring bigrec_subdivider_string s then SOME (s, rand t) else NONE @@ -1086,7 +1091,7 @@ fun pp_term (G : grammar) TyG backend = let string, and a boolean, which is true iff the update is a value update (not a "fupd") *) val (fld, value) = dest_comb t - val rname = valOf (overloading_of_term' overload_info fld) + val rname = valOf (fupdstr fld) in if isPrefix recfupd_special rname then let val (f, x) = dest_comb value @@ -1643,30 +1648,8 @@ fun pp_term (G : grammar) TyG backend = let NONE => add_prim_name() | SOME s => (* term is overloaded *) - if isPrefix recsel_special s orelse - isPrefix recupd_special s orelse - isPrefix recfupd_special s - then - (* if overloaded to a record special, check to see if it *) - (* has a normal name in the map that we could use instead. *) - (* This way we will print out something that can still be *) - (* parsed back to the original term, without having to go *) - (* for full uglification with dollared syntax. *) - - (* Note that if we've got this far, we can't print out *) - (* the special record syntax for some other reason, so *) - (* is our "fall-back" action *) - case Overload.info_for_name overload_info Name of - NONE => add_prim_name() - | SOME {actual_ops,...} => - if List.exists (same_const tm) actual_ops then - cope_with_rules Name - else - add_prim_name() - else if s = "case" then - cope_with_rules Name - else - cope_with_rules s + if s = "case" then cope_with_rules Name + else cope_with_rules s end in case (showtypes_v, const_is_polymorphic tm, const_has_multi_ovl tm) of From c14b5cc393e3a1c9ef84b44df43dce42981518d1 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Sun, 4 Oct 2015 22:41:01 +1100 Subject: [PATCH 530/718] new proof of LESS_0 uses existing proof of LESS_0_0, doesn't require LESS_THM --- src/num/theories/prim_recScript.sml | 21 +++++++++------------ 1 file changed, 9 insertions(+), 12 deletions(-) diff --git a/src/num/theories/prim_recScript.sml b/src/num/theories/prim_recScript.sml index 3ec61be0eb..10aeb85bad 100644 --- a/src/num/theories/prim_recScript.sml +++ b/src/num/theories/prim_recScript.sml @@ -114,15 +114,19 @@ val NOT_LESS_0 = (SPECL[--`n:num`--, --`0`--] SUC_LESS)) THEN ASM_REWRITE_TAC[]); -val LESS_0_0 = - store_thm - ("LESS_0_0", - --`0 < SUC 0`--, - REWRITE_TAC[LESS_DEF] +val LESS_0 = store_thm("LESS_0", + --`!n. 0 < (SUC n)`--, + GEN_TAC + THEN REWRITE_TAC[LESS_DEF] THEN EXISTS_TAC (--`\x.x = 0`--) THEN CONV_TAC(DEPTH_CONV BETA_CONV) THEN REWRITE_TAC[NOT_SUC]); +val LESS_0_0 = + store_thm + ("LESS_0_0", + --`0 < SUC 0`--, + REWRITE_TAC[LESS_0]) ; val LESS_MONO = store_thm @@ -210,13 +214,6 @@ val LESS_SUC_IMP = THEN RES_TAC THEN ASM_REWRITE_TAC[]); -(* Move to conversion nets forces different tactic in this proof. kls. *) -val LESS_0 = store_thm("LESS_0", - --`!n. 0 < (SUC n)`--, - INDUCT_TAC THEN - ONCE_REWRITE_TAC[LESS_THM] THEN - ASM_REWRITE_TAC[]); - val EQ_LESS = store_thm ("EQ_LESS", From 6dacfbcf511def715295185d91bbc1a09b671a4c Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Sun, 4 Oct 2015 22:57:25 +1100 Subject: [PATCH 531/718] shorter proof of LESS_MONO requires moving definition of PRE forward --- src/num/theories/prim_recScript.sml | 51 +++++++++++------------------ 1 file changed, 20 insertions(+), 31 deletions(-) diff --git a/src/num/theories/prim_recScript.sml b/src/num/theories/prim_recScript.sml index 10aeb85bad..d958f08b46 100644 --- a/src/num/theories/prim_recScript.sml +++ b/src/num/theories/prim_recScript.sml @@ -89,6 +89,22 @@ val INV_SUC_EQ = save_thm("INV_SUC_EQ", (AP_TERM (--`SUC`--) (ASSUME (--`m:num = n`--)))))); +(*--------------------------------------------------------------------------- + * First we define a partial inverse to SUC called PRE such that: + * + * (PRE 0 = 0) /\ (!m. PRE(SUC m) = m) + *---------------------------------------------------------------------------*) +val PRE_DEF = new_definition("PRE_DEF", + --`PRE m = (if (m=0) then 0 else @n. m = SUC n)`--); +val _ = OpenTheoryMap.OpenTheory_const_name{const={Thy="prim_rec",Name="PRE"},name=(["Number","Natural"],"pre")} + +val PRE = + store_thm + ("PRE", + --`(PRE 0 = 0) /\ (!m. PRE(SUC m) = m)`--, + REPEAT STRIP_TAC + THEN REWRITE_TAC[PRE_DEF, INV_SUC_EQ, NOT_SUC, SELECT_REFL_2]); + val LESS_REFL = store_thm( "LESS_REFL", --`!n. ~(n < n)`--, GEN_TAC THEN REWRITE_TAC[LESS_DEF, NOT_AND]); @@ -134,22 +150,11 @@ val LESS_MONO = --`!m n. (m < n) ==> (SUC m < SUC n)`--, REWRITE_TAC[LESS_DEF] THEN REPEAT STRIP_TAC - THEN EXISTS_TAC (--`\x.(x = SUC m) \/ (P x)`--) + THEN EXISTS_TAC ``\n : num. P (PRE n) : bool`` THEN CONV_TAC(DEPTH_CONV BETA_CONV) - THEN ASM_REWRITE_TAC[] - THEN IMP_RES_TAC - (DISCH_ALL - (CONTRAPOS(SPEC (--`(n:num)`--) - (ASSUME (--`!n'. P(SUC n') ==> P n'`--))))) - THEN ASM_REWRITE_TAC[] - THEN REPEAT STRIP_TAC - THEN RES_TAC - THEN IMP_RES_TAC INV_SUC - THEN ASM_REWRITE_TAC[] - THEN IMP_RES_TAC - (DISCH_ALL(SUBS [ASSUME (--`n:num = m`--)] - (ASSUME (--`~(P (n:num))`--)))) - THEN RES_TAC); + THEN ASM_REWRITE_TAC [PRE] + THEN INDUCT_TAC (* don't have num_CASES yet *) + THEN ASM_REWRITE_TAC [PRE]) ; val LESS_SUC_REFL = store_thm @@ -388,22 +393,6 @@ val SIMP_REC_THM = store_thm ( *---------------------------------------------------------------------------*) -(*--------------------------------------------------------------------------- - * First we define a partial inverse to SUC called PRE such that: - * - * (PRE 0 = 0) /\ (!m. PRE(SUC m) = m) - *---------------------------------------------------------------------------*) -val PRE_DEF = new_definition("PRE_DEF", - --`PRE m = (if (m=0) then 0 else @n. m = SUC n)`--); -val _ = OpenTheoryMap.OpenTheory_const_name{const={Thy="prim_rec",Name="PRE"},name=(["Number","Natural"],"pre")} - -val PRE = - store_thm - ("PRE", - --`(PRE 0 = 0) /\ (!m. PRE(SUC m) = m)`--, - REPEAT STRIP_TAC - THEN REWRITE_TAC[PRE_DEF, INV_SUC_EQ, NOT_SUC, SELECT_REFL_2]); - val PRIM_REC_FUN = new_definition ("PRIM_REC_FUN", From 764cbf5984b38a9f95f2151c2369ac58c1563420 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Mon, 5 Oct 2015 01:47:45 +1100 Subject: [PATCH 532/718] inverse of LESS_MONO --- src/num/theories/prim_recScript.sml | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/src/num/theories/prim_recScript.sml b/src/num/theories/prim_recScript.sml index d958f08b46..14dfacd903 100644 --- a/src/num/theories/prim_recScript.sml +++ b/src/num/theories/prim_recScript.sml @@ -156,6 +156,23 @@ val LESS_MONO = THEN INDUCT_TAC (* don't have num_CASES yet *) THEN ASM_REWRITE_TAC [PRE]) ; +val LESS_MONO_INV = + store_thm + ("LESS_MONO_INV", + --`!m n. (SUC m < SUC n) ==> (m < n)`--, + REWRITE_TAC[LESS_DEF] + THEN REPEAT STRIP_TAC + THEN EXISTS_TAC ``\n : num. P (SUC n) : bool`` + THEN CONV_TAC(DEPTH_CONV BETA_CONV) + THEN ASM_REWRITE_TAC []) ; + +val LESS_MONO_IFF = + store_thm + ("LESS_MONO_IFF", + --`!m n. (SUC m < SUC n) = (m < n)`--, + REPEAT GEN_TAC THEN EQ_TAC + THEN REWRITE_TAC [LESS_MONO, LESS_MONO_INV]) ; + val LESS_SUC_REFL = store_thm ("LESS_SUC_REFL", From f570e462786993bcc8fbd7f75676ccc754e8cd96 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Mon, 5 Oct 2015 02:37:12 +1100 Subject: [PATCH 533/718] LESS_ALT, alternative definition of < --- src/num/theories/prim_recScript.sml | 40 +++++++++++++++++++++++++++++ 1 file changed, 40 insertions(+) diff --git a/src/num/theories/prim_recScript.sml b/src/num/theories/prim_recScript.sml index 14dfacd903..ff99c42d44 100644 --- a/src/num/theories/prim_recScript.sml +++ b/src/num/theories/prim_recScript.sml @@ -173,6 +173,46 @@ val LESS_MONO_IFF = REPEAT GEN_TAC THEN EQ_TAC THEN REWRITE_TAC [LESS_MONO, LESS_MONO_INV]) ; +(* now show that < is the transitive closure of the successor relation *) + +val TC_LESS_0 = prove ( --`!n. TC (\x y. y = SUC x) 0 (SUC n)`--, + INDUCT_TAC + THENL [ irule relationTheory.TC_SUBSET THEN BETA_TAC THEN REFL_TAC, + ONCE_REWRITE_TAC [relationTheory.TC_CASES2] THEN DISJ2_TAC + THEN EXISTS_TAC ``SUC n`` THEN BETA_TAC THEN ASM_REWRITE_TAC [] ]) ; + +val TC_NOT_LESS_0 = prove ( --`!n. ~(TC (\x y. y = SUC x) n 0)`--, + ONCE_REWRITE_TAC [relationTheory.TC_CASES2] + THEN BETA_TAC THEN REWRITE_TAC [GSYM NOT_SUC] ) ; + +val TC_IM_RTC_SUC = prove ( + ``!m n. TC (\x y. y = SUC x) m (SUC n) = RTC (\x y. y = SUC x) m n``, + ONCE_REWRITE_TAC [relationTheory.TC_CASES2] THEN BETA_TAC + THEN REWRITE_TAC [relationTheory.RTC_CASES_TC, INV_SUC_EQ] + THEN REPEAT (STRIP_TAC ORELSE EQ_TAC) + THEN ASM_REWRITE_TAC [] + THEN DISJ2_TAC THEN EXISTS_TAC ``n : num`` + THEN ASM_REWRITE_TAC []) ; + +val RTC_IM_TC = prove ( + ``!m n. RTC (\x y. y = f x) (f m) n = TC (\x y. y = f x) m n``, + REWRITE_TAC [relationTheory.EXTEND_RTC_TC_EQN] + THEN BETA_TAC THEN REPEAT (STRIP_TAC ORELSE EQ_TAC) + THENL [Q.EXISTS_TAC `f m`, + FIRST_X_ASSUM (ASSUME_TAC o SYM)] + THEN ASM_REWRITE_TAC []) ; + +val TC_LESS_MONO_IFF = prove ( + ``!m n. TC (\x y. y = SUC x) (SUC m) (SUC n) = TC (\x y. y = SUC x) m n``, + REWRITE_TAC [TC_IM_RTC_SUC, RTC_IM_TC] ) ; + +val LESS_ALT = store_thm ("LESS_ALT", + ``!m n. (m < n) = TC (\x y. y = SUC x) m n``, + INDUCT_TAC THEN INDUCT_TAC THEN + REWRITE_TAC [NOT_LESS_0, TC_NOT_LESS_0, LESS_0, TC_LESS_0, + TC_LESS_MONO_IFF, LESS_MONO_IFF] + THEN FIRST_ASSUM MATCH_ACCEPT_TAC) ; + val LESS_SUC_REFL = store_thm ("LESS_SUC_REFL", From a8a882f52600a5e487f20f89d4907279ad575dd8 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Mon, 5 Oct 2015 02:53:19 +1100 Subject: [PATCH 534/718] use of LESS_ALT to give shorter proofs --- src/num/theories/prim_recScript.sml | 15 +-------------- 1 file changed, 1 insertion(+), 14 deletions(-) diff --git a/src/num/theories/prim_recScript.sml b/src/num/theories/prim_recScript.sml index ff99c42d44..203486a4a9 100644 --- a/src/num/theories/prim_recScript.sml +++ b/src/num/theories/prim_recScript.sml @@ -238,20 +238,7 @@ val LESS_LEMMA1 = store_thm ("LESS_LEMMA1", --`!m n. (m < SUC n) ==> (m = n) \/ (m < n)`--, - REWRITE_TAC[LESS_DEF] - THEN REPEAT STRIP_TAC - THEN ASM_CASES_TAC (--`(m:num) = n`--) - THEN ASM_REWRITE_TAC[] - THEN EXISTS_TAC (--`\(x:num). ~(x = n) /\ (P x)`--) - THEN CONV_TAC(DEPTH_CONV BETA_CONV) - THEN REPEAT STRIP_TAC - THEN IMP_RES_TAC - (DISCH_ALL(SUBS[ASSUME (--`(n':num) = n`--)] - (ASSUME(--`P(SUC n'):bool`--)))) - THEN ASSUME_TAC(REFL(--`n:num`--)) - THEN RES_TAC - THEN ASM_REWRITE_TAC[]); - + REWRITE_TAC [LESS_ALT, TC_IM_RTC_SUC, relationTheory.RTC_CASES_TC]) ; val LESS_LEMMA2 = store_thm From 1cadbb4ebcefc696657e00b06ae1834589b0f1d7 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Mon, 5 Oct 2015 10:34:58 +1100 Subject: [PATCH 535/718] using LESS_ALT to prove WF_LESS more easily --- src/num/theories/prim_recScript.sml | 20 +++++--------------- 1 file changed, 5 insertions(+), 15 deletions(-) diff --git a/src/num/theories/prim_recScript.sml b/src/num/theories/prim_recScript.sml index 203486a4a9..9c4634d3a6 100644 --- a/src/num/theories/prim_recScript.sml +++ b/src/num/theories/prim_recScript.sml @@ -207,7 +207,8 @@ val TC_LESS_MONO_IFF = prove ( REWRITE_TAC [TC_IM_RTC_SUC, RTC_IM_TC] ) ; val LESS_ALT = store_thm ("LESS_ALT", - ``!m n. (m < n) = TC (\x y. y = SUC x) m n``, + ``$< = TC (\x y. y = SUC x)``, + REWRITE_TAC [FUN_EQ_THM] THEN INDUCT_TAC THEN INDUCT_TAC THEN REWRITE_TAC [NOT_LESS_0, TC_NOT_LESS_0, LESS_0, TC_LESS_0, TC_LESS_MONO_IFF, LESS_MONO_IFF] @@ -613,24 +614,13 @@ Q.store_thm (*---------------------------------------------------------------------------- - * This theorem would be a lot nicer if < was defined as the transitive + * This theorem is now a lot nicer as < can be defined as the transitive * closure of predecessor. *---------------------------------------------------------------------------*) val WF_LESS = Q.store_thm("WF_LESS", `WF $<`, -REWRITE_TAC[relationTheory.WF_DEF] - THEN GEN_TAC THEN CONV_TAC CONTRAPOS_CONV - THEN DISCH_THEN (fn th1 => - SUBGOAL_THEN (--`^(concl th1) ==> !i j. j ~B j`--) - (fn th => MP_TAC (MP th th1))) - THEN CONV_TAC (DEPTH_CONV NOT_EXISTS_CONV) THEN DISCH_TAC THENL - [INDUCT_TAC THEN GEN_TAC THEN - REWRITE_TAC[NOT_LESS_0,LESS_THM] - THEN DISCH_THEN (DISJ_CASES_THENL[SUBST1_TAC, ASSUME_TAC]) - THEN STRIP_TAC THEN RES_TAC, - GEN_TAC THEN FIRST_ASSUM MATCH_MP_TAC - THEN Q.EXISTS_TAC`SUC w` - THEN MATCH_ACCEPT_TAC LESS_SUC_REFL]); + REWRITE_TAC[LESS_ALT, relationTheory.WF_TC_EQN, WF_PRED]) ; + val _ = BasicProvers.export_rewrites ["WF_LESS"] From 1ec6ecffa96ff31f3928ffa3dfd312fbdbc88e74 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Mon, 5 Oct 2015 10:44:09 +1100 Subject: [PATCH 536/718] LESS_TRANS follows directly from LESS_ALT --- src/num/theories/arithmeticScript.sml | 24 ++++++++---------------- 1 file changed, 8 insertions(+), 16 deletions(-) diff --git a/src/num/theories/arithmeticScript.sml b/src/num/theories/arithmeticScript.sml index f9136ca5e0..fabfc0a2dd 100644 --- a/src/num/theories/arithmeticScript.sml +++ b/src/num/theories/arithmeticScript.sml @@ -58,7 +58,8 @@ and SUC_ID = prim_recTheory.SUC_ID and NOT_LESS_EQ = prim_recTheory.NOT_LESS_EQ and LESS_NOT_EQ = prim_recTheory.LESS_NOT_EQ and LESS_SUC_SUC = prim_recTheory.LESS_SUC_SUC -and PRE = prim_recTheory.PRE; +and PRE = prim_recTheory.PRE +and LESS_ALT = prim_recTheory.LESS_ALT; (*---------------------------------------------------------------------------* * The basic arithmetic operations. * @@ -320,24 +321,15 @@ val LESS_ADD = store_thm ("LESS_ADD", RES_THEN (STRIP_THM_THEN (SUBST1_TAC o SYM)) THEN EXISTS_TAC (``SUC p``) THEN REWRITE_TAC [ADD]]); -val LESS_TRANS = store_thm ("LESS_TRANS", - ``!m n p. (m < n) /\ (n < p) ==> (m < p)``, - REPEAT GEN_TAC - THEN SPEC_TAC(``(n:num)``,``(n:num)``) - THEN SPEC_TAC(``(m:num)``,``(m:num)``) - THEN SPEC_TAC(``(p:num)``,``(p:num)``) - THEN INDUCT_TAC - THEN REWRITE_TAC[NOT_LESS_0, LESS_THM] - THEN REPEAT STRIP_TAC - THEN RES_TAC - THENL [SUBST_TAC[SYM(ASSUME (``n:num = p``))], ALL_TAC] - THEN ASM_REWRITE_TAC[]); - val transitive_LESS = store_thm( "transitive_LESS[simp]", ``transitive $<``, - REWRITE_TAC [relationTheory.transitive_def] THEN - MATCH_ACCEPT_TAC LESS_TRANS); + REWRITE_TAC [relationTheory.TC_TRANSITIVE, LESS_ALT]); + +val LESS_TRANS = store_thm ("LESS_TRANS", + ``!m n p. (m < n) /\ (n < p) ==> (m < p)``, + MATCH_ACCEPT_TAC + (REWRITE_RULE [relationTheory.transitive_def] transitive_LESS)) ; val LESS_ANTISYM = store_thm ("LESS_ANTISYM", ``!m n. ~((m < n) /\ (n < m))``, From c4c35324b0e867e15d222b14e88d436a8d603217 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Mon, 5 Oct 2015 11:39:52 +1100 Subject: [PATCH 537/718] alt definition of <= as RTC of successor --- src/num/theories/arithmeticScript.sml | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-) diff --git a/src/num/theories/arithmeticScript.sml b/src/num/theories/arithmeticScript.sml index fabfc0a2dd..f083fee5ff 100644 --- a/src/num/theories/arithmeticScript.sml +++ b/src/num/theories/arithmeticScript.sml @@ -308,6 +308,13 @@ val NOT_LT_ZERO_EQ_ZERO = store_thm( ``!n. ~(0 < n) <=> (n = 0)``, REWRITE_TAC [GSYM NOT_ZERO_LT_ZERO]); +val LESS_OR_EQ_ALT = store_thm ("LESS_OR_EQ_ALT", + ``$<= = RTC (λx y. y = SUC x)``, + REWRITE_TAC [FUN_EQ_THM, LESS_OR_EQ, + relationTheory.RTC_CASES_TC, prim_recTheory.LESS_ALT] + THEN REPEAT (STRIP_TAC ORELSE EQ_TAC) + THEN ASM_REWRITE_TAC []) ; + (* --------------------------------------------------------------------- *) (* LESS_ADD proof rewritten: TFM 90.O9.21 *) (* --------------------------------------------------------------------- *) @@ -775,12 +782,8 @@ val LESS_EQ_MONO_ADD_EQ = store_thm ("LESS_EQ_MONO_ADD_EQ", val LESS_EQ_TRANS = store_thm ("LESS_EQ_TRANS", ``!m n p. (m <= n) /\ (n <= p) ==> (m <= p)``, - REWRITE_TAC[LESS_OR_EQ] - THEN REPEAT STRIP_TAC - THEN IMP_RES_TAC LESS_TRANS - THEN ASM_REWRITE_TAC[] - THEN SUBST_TAC[SYM(ASSUME (``(n:num) = p``))] - THEN ASM_REWRITE_TAC[]); + REWRITE_TAC[LESS_OR_EQ_ALT, REWRITE_RULE + [relationTheory.transitive_def] relationTheory.transitive_RTC]) ; (* % Proof modified for new IMP_RES_TAC [TFM 90.04.25] *) From 58cc1c2939082ff3acc451fdeb9be0221eb8bf22 Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Mon, 5 Oct 2015 12:16:22 +1100 Subject: [PATCH 538/718] using new lemmas to prove existing theorems easier --- src/num/theories/arithmeticScript.sml | 45 +++++++++------------------ src/num/theories/prim_recScript.sml | 18 +++++------ 2 files changed, 23 insertions(+), 40 deletions(-) diff --git a/src/num/theories/arithmeticScript.sml b/src/num/theories/arithmeticScript.sml index f083fee5ff..90edc48613 100644 --- a/src/num/theories/arithmeticScript.sml +++ b/src/num/theories/arithmeticScript.sml @@ -364,43 +364,23 @@ val transitive_measure = Q.store_thm ("transitive_measure", * |- !m n. SUC m < SUC n = m < n *---------------------------------------------------------------------------*) -val LESS_MONO_REV = store_thm ("LESS_MONO_REV", - ``!m n. SUC m < SUC n ==> m < n``, - REPEAT GEN_TAC - THEN REWRITE_TAC[LESS_THM] - THEN STRIP_TAC - THEN IMP_RES_TAC SUC_LESS - THEN IMP_RES_TAC EQ_LESS - THEN ASM_REWRITE_TAC[]); +val LESS_MONO_REV = save_thm ("LESS_MONO_REV", prim_recTheory.LESS_MONO_REV) ; +val LESS_MONO_EQ = save_thm ("LESS_MONO_EQ", prim_recTheory.LESS_MONO_EQ) ; -val LESS_MONO_EQ = save_thm ("LESS_MONO_EQ", - GENL [``m:num``, ``n:num``] - (IMP_ANTISYM_RULE (SPEC_ALL LESS_MONO_REV) - (SPEC_ALL LESS_MONO))); +val LESS_EQ = store_thm ("LESS_EQ", + ``!m n. (m < n) = (SUC m <= n)``, + REWRITE_TAC[LESS_OR_EQ_ALT, + prim_recTheory.LESS_ALT, prim_recTheory.RTC_IM_TC]) ; val LESS_OR = store_thm ("LESS_OR", ``!m n. m < n ==> SUC m <= n``, - REWRITE_TAC[LESS_OR_EQ] - THEN GEN_TAC THEN INDUCT_TAC - THEN REWRITE_TAC[NOT_LESS_0,LESS_MONO_EQ,INV_SUC_EQ, LESS_THM] - THEN STRIP_TAC THENL [ALL_TAC, RES_TAC] THEN ASM_REWRITE_TAC[]); + REWRITE_TAC[LESS_EQ]) ; val LESS_SUC_EQ = LESS_OR; val OR_LESS = store_thm ("OR_LESS", ``!m n. (SUC m <= n) ==> (m < n)``, - REPEAT GEN_TAC - THEN REWRITE_TAC[LESS_OR_EQ] - THEN STRIP_TAC - THEN IMP_RES_TAC SUC_LESS - THEN IMP_RES_TAC EQ_LESS - THEN ASM_REWRITE_TAC[]); - -(* |- !m n. (m < n) = (SUC m <= n) *) -val LESS_EQ = save_thm ("LESS_EQ", - GENL [``m:num``, ``n:num``] - (IMP_ANTISYM_RULE (SPEC_ALL LESS_OR) - (SPEC_ALL OR_LESS))); + REWRITE_TAC[LESS_EQ]) ; val LESS_SUC_EQ_COR = store_thm ("LESS_SUC_EQ_COR", ``!m n. ((m < n) /\ (~(SUC m = n))) ==> (SUC m < n)``, @@ -1245,11 +1225,14 @@ val LESS_IMP_LESS_ADD = store_thm ("LESS_IMP_LESS_ADD", PURE_ONCE_REWRITE_TAC [ADD_CLAUSES] THEN GEN_TAC THEN MATCH_ACCEPT_TAC LESS_ADD_SUC); +val LESS_EQ_IFF_LESS_SUC = store_thm ("LESS_EQ_IFF_LESS_SUC", + ``!n m. (n <= m) = (n < (SUC m))``, + REWRITE_TAC[LESS_OR_EQ_ALT, + prim_recTheory.LESS_ALT, prim_recTheory.TC_IM_RTC_SUC]) ; + val LESS_EQ_IMP_LESS_SUC = store_thm ("LESS_EQ_IMP_LESS_SUC", ``!n m. (n <= m) ==> (n < (SUC m))``, - REWRITE_TAC [LESS_OR_EQ] THEN - REPEAT STRIP_TAC THENL - [IMP_RES_TAC LESS_SUC, ASM_REWRITE_TAC [LESS_SUC_REFL]]); + REWRITE_TAC [LESS_EQ_IFF_LESS_SUC]) ; val SUB_LESS_EQ_ADD = store_thm ("SUB_LESS_EQ_ADD", ``!m p. (m <= p) ==> !n. (((p - m) <= n) = (p <= (m + n)))``, diff --git a/src/num/theories/prim_recScript.sml b/src/num/theories/prim_recScript.sml index 9c4634d3a6..71604e74d7 100644 --- a/src/num/theories/prim_recScript.sml +++ b/src/num/theories/prim_recScript.sml @@ -156,9 +156,9 @@ val LESS_MONO = THEN INDUCT_TAC (* don't have num_CASES yet *) THEN ASM_REWRITE_TAC [PRE]) ; -val LESS_MONO_INV = +val LESS_MONO_REV = store_thm - ("LESS_MONO_INV", + ("LESS_MONO_REV", --`!m n. (SUC m < SUC n) ==> (m < n)`--, REWRITE_TAC[LESS_DEF] THEN REPEAT STRIP_TAC @@ -166,12 +166,12 @@ val LESS_MONO_INV = THEN CONV_TAC(DEPTH_CONV BETA_CONV) THEN ASM_REWRITE_TAC []) ; -val LESS_MONO_IFF = +val LESS_MONO_EQ = store_thm - ("LESS_MONO_IFF", + ("LESS_MONO_EQ", --`!m n. (SUC m < SUC n) = (m < n)`--, REPEAT GEN_TAC THEN EQ_TAC - THEN REWRITE_TAC [LESS_MONO, LESS_MONO_INV]) ; + THEN REWRITE_TAC [LESS_MONO, LESS_MONO_REV]) ; (* now show that < is the transitive closure of the successor relation *) @@ -185,7 +185,7 @@ val TC_NOT_LESS_0 = prove ( --`!n. ~(TC (\x y. y = SUC x) n 0)`--, ONCE_REWRITE_TAC [relationTheory.TC_CASES2] THEN BETA_TAC THEN REWRITE_TAC [GSYM NOT_SUC] ) ; -val TC_IM_RTC_SUC = prove ( +val TC_IM_RTC_SUC = store_thm ("TC_IM_RTC_SUC", ``!m n. TC (\x y. y = SUC x) m (SUC n) = RTC (\x y. y = SUC x) m n``, ONCE_REWRITE_TAC [relationTheory.TC_CASES2] THEN BETA_TAC THEN REWRITE_TAC [relationTheory.RTC_CASES_TC, INV_SUC_EQ] @@ -194,7 +194,7 @@ val TC_IM_RTC_SUC = prove ( THEN DISJ2_TAC THEN EXISTS_TAC ``n : num`` THEN ASM_REWRITE_TAC []) ; -val RTC_IM_TC = prove ( +val RTC_IM_TC = store_thm ("RTC_IM_TC", ``!m n. RTC (\x y. y = f x) (f m) n = TC (\x y. y = f x) m n``, REWRITE_TAC [relationTheory.EXTEND_RTC_TC_EQN] THEN BETA_TAC THEN REPEAT (STRIP_TAC ORELSE EQ_TAC) @@ -202,7 +202,7 @@ val RTC_IM_TC = prove ( FIRST_X_ASSUM (ASSUME_TAC o SYM)] THEN ASM_REWRITE_TAC []) ; -val TC_LESS_MONO_IFF = prove ( +val TC_LESS_MONO_EQ = prove ( ``!m n. TC (\x y. y = SUC x) (SUC m) (SUC n) = TC (\x y. y = SUC x) m n``, REWRITE_TAC [TC_IM_RTC_SUC, RTC_IM_TC] ) ; @@ -211,7 +211,7 @@ val LESS_ALT = store_thm ("LESS_ALT", REWRITE_TAC [FUN_EQ_THM] THEN INDUCT_TAC THEN INDUCT_TAC THEN REWRITE_TAC [NOT_LESS_0, TC_NOT_LESS_0, LESS_0, TC_LESS_0, - TC_LESS_MONO_IFF, LESS_MONO_IFF] + TC_LESS_MONO_EQ, LESS_MONO_EQ] THEN FIRST_ASSUM MATCH_ACCEPT_TAC) ; val LESS_SUC_REFL = From f874d2f922632e11e2e856d08e2803356da8586f Mon Sep 17 00:00:00 2001 From: Jeremy Dawson Date: Mon, 5 Oct 2015 13:47:42 +1100 Subject: [PATCH 539/718] some instances of easier proofs involving < and <= --- src/num/theories/arithmeticScript.sml | 158 ++++++++++---------------- 1 file changed, 57 insertions(+), 101 deletions(-) diff --git a/src/num/theories/arithmeticScript.sml b/src/num/theories/arithmeticScript.sml index 90edc48613..f63e2e8d0f 100644 --- a/src/num/theories/arithmeticScript.sml +++ b/src/num/theories/arithmeticScript.sml @@ -59,6 +59,8 @@ and NOT_LESS_EQ = prim_recTheory.NOT_LESS_EQ and LESS_NOT_EQ = prim_recTheory.LESS_NOT_EQ and LESS_SUC_SUC = prim_recTheory.LESS_SUC_SUC and PRE = prim_recTheory.PRE +and RTC_IM_TC = prim_recTheory.RTC_IM_TC +and TC_IM_RTC_SUC = prim_recTheory.TC_IM_RTC_SUC and LESS_ALT = prim_recTheory.LESS_ALT; (*---------------------------------------------------------------------------* @@ -310,8 +312,7 @@ val NOT_LT_ZERO_EQ_ZERO = store_thm( val LESS_OR_EQ_ALT = store_thm ("LESS_OR_EQ_ALT", ``$<= = RTC (λx y. y = SUC x)``, - REWRITE_TAC [FUN_EQ_THM, LESS_OR_EQ, - relationTheory.RTC_CASES_TC, prim_recTheory.LESS_ALT] + REWRITE_TAC [FUN_EQ_THM, LESS_OR_EQ, relationTheory.RTC_CASES_TC, LESS_ALT] THEN REPEAT (STRIP_TAC ORELSE EQ_TAC) THEN ASM_REWRITE_TAC []) ; @@ -344,15 +345,21 @@ val LESS_ANTISYM = store_thm ("LESS_ANTISYM", THEN IMP_RES_TAC LESS_TRANS THEN IMP_RES_TAC LESS_REFL); +(*--------------------------------------------------------------------------- + * |- !m n. SUC m < SUC n = m < n + *---------------------------------------------------------------------------*) + +val LESS_MONO_REV = save_thm ("LESS_MONO_REV", prim_recTheory.LESS_MONO_REV) ; +val LESS_MONO_EQ = save_thm ("LESS_MONO_EQ", prim_recTheory.LESS_MONO_EQ) ; + +val LESS_EQ_MONO = store_thm ("LESS_EQ_MONO", + ``!n m. (SUC n <= SUC m) = (n <= m)``, + REWRITE_TAC [LESS_OR_EQ,LESS_MONO_EQ,INV_SUC_EQ]); + val LESS_LESS_SUC = store_thm ("LESS_LESS_SUC", ``!m n. ~((m < n) /\ (n < SUC m))``, - REWRITE_TAC[LESS_THM] - THEN REPEAT STRIP_TAC - THEN IMP_RES_TAC LESS_TRANS - THEN IMP_RES_TAC(DISCH_ALL(SUBS[ASSUME(``(n:num)=m``)] - (ASSUME(``m SUC m <= n``, @@ -382,28 +381,30 @@ val OR_LESS = store_thm ("OR_LESS", ``!m n. (SUC m <= n) ==> (m < n)``, REWRITE_TAC[LESS_EQ]) ; +val LESS_EQ_IFF_LESS_SUC = store_thm ("LESS_EQ_IFF_LESS_SUC", + ``!n m. (n <= m) = (n < (SUC m))``, + REWRITE_TAC[LESS_OR_EQ_ALT, LESS_ALT, TC_IM_RTC_SUC]) ; + +val LESS_EQ_IMP_LESS_SUC = store_thm ("LESS_EQ_IMP_LESS_SUC", + ``!n m. (n <= m) ==> (n < (SUC m))``, + REWRITE_TAC [LESS_EQ_IFF_LESS_SUC]) ; + +val ZERO_LESS_EQ = store_thm ("ZERO_LESS_EQ", + ``!n. 0 <= n``, + REWRITE_TAC [LESS_0,LESS_EQ_IFF_LESS_SUC]); + val LESS_SUC_EQ_COR = store_thm ("LESS_SUC_EQ_COR", ``!m n. ((m < n) /\ (~(SUC m = n))) ==> (SUC m < n)``, - REPEAT STRIP_TAC - THEN IMP_RES_TAC LESS_SUC_EQ - THEN MP_TAC(ASSUME (``(SUC m) <= n``)) - THEN REWRITE_TAC[LESS_OR_EQ] - THEN REPEAT STRIP_TAC - THEN RES_TAC); (* RES_TAC doesn't solve the goal when ``F`` is - in the assumptions *) + CONV_TAC (ONCE_DEPTH_CONV SYM_CONV) THEN + INDUCT_TAC THEN INDUCT_TAC THEN + ASM_REWRITE_TAC [LESS_MONO_EQ, INV_SUC_EQ, LESS_0, NOT_LESS_0, + NOT_ZERO_LT_ZERO]) ; val LESS_NOT_SUC = store_thm ("LESS_NOT_SUC", ``!m n. (m < n) /\ ~(n = SUC m) ==> SUC m < n``, - REPEAT GEN_TAC - THEN ASM_CASES_TAC (``n = SUC m``) - THEN ASM_REWRITE_TAC[] - THEN STRIP_TAC - THEN MP_TAC(REWRITE_RULE[LESS_OR_EQ] - (EQ_MP(SPEC_ALL LESS_EQ) - (ASSUME (``m < n``)))) - THEN STRIP_TAC - THEN ASSUME_TAC(SYM(ASSUME (``SUC m = n``))) - THEN RES_TAC); (* RES_TAC doesn't solve ``F`` in assumptions *) + INDUCT_TAC THEN INDUCT_TAC THEN + ASM_REWRITE_TAC [LESS_MONO_EQ, INV_SUC_EQ, LESS_0, NOT_LESS_0, + NOT_ZERO_LT_ZERO]) ; val LESS_0_CASES = store_thm ("LESS_0_CASES", ``!m. (0 = m) \/ 0 (n < m)``, - GEN_TAC - THEN INDUCT_TAC - THEN STRIP_TAC - THENL - [MP_TAC(ASSUME (``~(m = 0)``)) - THEN ACCEPT_TAC - (DISJ_IMP - (SUBS - [SPECL[``0``, ``m:num``]EQ_SYM_EQ'] - (SPEC_ALL LESS_0_CASES))), - MP_TAC(ASSUME (``~(m < (SUC n))``)) - THEN REWRITE_TAC[LESS_THM, DE_MORGAN_THM] - THEN STRIP_TAC - THEN RES_TAC - THEN IMP_RES_TAC LESS_NOT_SUC - THEN ASM_REWRITE_TAC[]]); + INDUCT_TAC THEN INDUCT_TAC THEN + ASM_REWRITE_TAC [LESS_MONO_EQ, INV_SUC_EQ, LESS_0, NOT_LESS_0]) ; val LESS_CASES = store_thm ("LESS_CASES", ``!m n. (m < n) \/ (n <= m)``, - REPEAT GEN_TAC - THEN ASM_REWRITE_TAC[LESS_OR_EQ, DE_MORGAN_THM] - THEN ASM_CASES_TAC (``(m:num) = n``) - THEN ASM_CASES_TAC (``m < n``) - THEN IMP_RES_TAC LESS_CASES_IMP - THEN ASM_REWRITE_TAC[]); + INDUCT_TAC THEN INDUCT_TAC THEN + ASM_REWRITE_TAC + [LESS_MONO_EQ, LESS_EQ_MONO, ZERO_LESS_EQ, LESS_0, NOT_LESS_0]) ; val ADD_INV_0 = store_thm ("ADD_INV_0", ``!m n. (m + n = m) ==> (n = 0)``, @@ -486,26 +470,25 @@ val LESS_ADD_NONZERO = store_thm ("LESS_ADD_NONZERO", THEN IMP_RES_TAC LESS_TRANS THEN ASM_REWRITE_TAC[ADD_CLAUSES,LESS_SUC_REFL]); -val LESS_EQ_ANTISYM = store_thm ("LESS_EQ_ANTISYM", - ``!m n. ~(m < n /\ n <= m)``, - REWRITE_TAC[LESS_OR_EQ] - THEN REPEAT STRIP_TAC - THEN IMP_RES_TAC LESS_ANTISYM - THEN ASM_REWRITE_TAC[] - THEN ASSUME_TAC(SYM(ASSUME (``(n:num) = m``))) - THEN IMP_RES_TAC NOT_LESS_EQ - THEN ASM_REWRITE_TAC[]); +val NOT_SUC_LESS_EQ_0 = store_thm ("NOT_SUC_LESS_EQ_0", + ``!n. ~(SUC n <= 0)``, + REWRITE_TAC [NOT_LESS_0, GSYM LESS_EQ]); val NOT_LESS = store_thm ("NOT_LESS", ``!m n. ~(m < n) = (n <= m)``, - REPEAT GEN_TAC - THEN ASM_CASES_TAC (``m < n``) - THEN ASM_CASES_TAC (``n <= m``) - THEN IMP_RES_TAC(DISJ_IMP(SPEC_ALL LESS_CASES)) - THEN IMP_RES_TAC(CONTRAPOS(DISJ_IMP(SPEC_ALL LESS_CASES))) - THEN RES_TAC - THEN IMP_RES_TAC LESS_EQ_ANTISYM - THEN ASM_REWRITE_TAC[]); + INDUCT_TAC THEN INDUCT_TAC THEN + ASM_REWRITE_TAC [LESS_MONO_EQ, LESS_EQ_MONO, + ZERO_LESS_EQ, LESS_0, NOT_LESS_0, NOT_SUC_LESS_EQ_0]) ; + +val NOT_LESS_EQUAL = store_thm ("NOT_LESS_EQUAL", + ``!m n. ~(m <= n) = n < m``, + REWRITE_TAC[GSYM NOT_LESS]); + +val LESS_EQ_ANTISYM = store_thm ("LESS_EQ_ANTISYM", + ``!m n. ~(m < n /\ n <= m)``, + INDUCT_TAC THEN INDUCT_TAC THEN + ASM_REWRITE_TAC [LESS_MONO_EQ, LESS_EQ_MONO, + ZERO_LESS_EQ, LESS_0, NOT_LESS_0, NOT_SUC_LESS_EQ_0]) ; val _ = print "Now proving properties of subtraction\n" @@ -909,16 +892,6 @@ val LESS_ADD_SUC = store_thm ("LESS_ADD_SUC", POP_ASSUM (ASSUME_TAC o REWRITE_RULE [ADD_CLAUSES]) THEN ASM_REWRITE_TAC [LESS_MONO_EQ,ADD_CLAUSES]]); -val ZERO_LESS_EQ = store_thm ("ZERO_LESS_EQ", - ``!n. 0 <= n``, - GEN_TAC THEN - REPEAT_TCL STRIP_THM_THEN SUBST1_TAC (SPEC (``n:num``) num_CASES) THEN - REWRITE_TAC [LESS_0,LESS_OR_EQ]); - -val LESS_EQ_MONO = store_thm ("LESS_EQ_MONO", - ``!n m. (SUC n <= SUC m) = (n <= m)``, - REWRITE_TAC [LESS_OR_EQ,LESS_MONO_EQ,INV_SUC_EQ]); - (* Following proof revised for version 1.12 resolution. [TFM 91.01.18] *) val LESS_OR_EQ_ADD = store_thm ("LESS_OR_EQ_ADD", ``!n m. n < m \/ ?p. n = p+m``, @@ -1225,15 +1198,6 @@ val LESS_IMP_LESS_ADD = store_thm ("LESS_IMP_LESS_ADD", PURE_ONCE_REWRITE_TAC [ADD_CLAUSES] THEN GEN_TAC THEN MATCH_ACCEPT_TAC LESS_ADD_SUC); -val LESS_EQ_IFF_LESS_SUC = store_thm ("LESS_EQ_IFF_LESS_SUC", - ``!n m. (n <= m) = (n < (SUC m))``, - REWRITE_TAC[LESS_OR_EQ_ALT, - prim_recTheory.LESS_ALT, prim_recTheory.TC_IM_RTC_SUC]) ; - -val LESS_EQ_IMP_LESS_SUC = store_thm ("LESS_EQ_IMP_LESS_SUC", - ``!n m. (n <= m) ==> (n < (SUC m))``, - REWRITE_TAC [LESS_EQ_IFF_LESS_SUC]) ; - val SUB_LESS_EQ_ADD = store_thm ("SUB_LESS_EQ_ADD", ``!m p. (m <= p) ==> !n. (((p - m) <= n) = (p <= (m + n)))``, REPEAT STRIP_TAC THEN @@ -1377,10 +1341,6 @@ val LESS_EQ_EXISTS = store_thm ("LESS_EQ_EXISTS", [MATCH_ACCEPT_TAC LESS_EQUAL_ADD, DISCH_THEN(CHOOSE_THEN SUBST1_TAC) THEN MATCH_ACCEPT_TAC LESS_EQ_ADD]); -val NOT_LESS_EQUAL = store_thm ("NOT_LESS_EQUAL", - ``!m n. ~(m <= n) = n < m``, - REWRITE_TAC[GSYM NOT_LESS]); - val LESS_EQ_0 = store_thm ("LESS_EQ_0", ``!n. (n <= 0) = (n = 0)``, GEN_TAC THEN EQ_TAC THENL @@ -1556,10 +1516,6 @@ val LE_ADD_LCANCEL = save_thm ("LE_ADD_LCANCEL", ADD_MONO_LESS_EQ) val LE_ADD_RCANCEL = save_thm ("LE_ADD_RCANCEL", ONCE_REWRITE_RULE [ADD_COMM] LE_ADD_LCANCEL) -val NOT_SUC_LESS_EQ_0 = store_thm ("NOT_SUC_LESS_EQ_0", - ``!n. ~(SUC n <= 0)``, - REWRITE_TAC [NOT_LESS_EQUAL,LESS_0]); - (* ---------------------------------------------------------------------*) (* Theorems to support the arithmetic proof procedure [RJB 92.09.29]*) (* ---------------------------------------------------------------------*) From abc1e3ffbf693bc4cbf6a20274539d9668429f0d Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Tue, 6 Oct 2015 11:27:30 +0100 Subject: [PATCH 540/718] Minor changes to L3 importer. --- examples/l3-machine-code/common/Import.sig | 1 - examples/l3-machine-code/common/Import.sml | 55 +++++++--------------- 2 files changed, 17 insertions(+), 39 deletions(-) diff --git a/examples/l3-machine-code/common/Import.sig b/examples/l3-machine-code/common/Import.sig index 8260fa1044..4c37a2b0fa 100644 --- a/examples/l3-machine-code/common/Import.sig +++ b/examples/l3-machine-code/common/Import.sig @@ -43,7 +43,6 @@ sig | Msb | Neg | Not - | Nub | PadLeft | PadRight | QuotRem diff --git a/examples/l3-machine-code/common/Import.sml b/examples/l3-machine-code/common/Import.sml index d8d775fbd8..cb29574b28 100644 --- a/examples/l3-machine-code/common/Import.sml +++ b/examples/l3-machine-code/common/Import.sml @@ -492,7 +492,6 @@ datatype monop = | Msb | Neg | Not - | Nub | PadLeft | PadRight | QuotRem @@ -665,11 +664,6 @@ local val mk_quot_rem = mk_uncurry ``\(m, n). (integer$int_quot m n, integer$int_rem m n)`` - fun mk_rev tm = - (if Lib.can wordsSyntax.dim_of tm - then wordsSyntax.mk_word_reverse - else listSyntax.mk_reverse) tm - fun enum2num ty = Lib.with_exn mk_local_const (typeName ty ^ "2num", Type.--> (ty, numLib.num)) @@ -892,37 +886,24 @@ local ("bad domain: " ^ typeName ty1 ^ " -> " ^ typeName ty2) end - fun pick (a, b, c) tm = - let - val ty = Term.type_of tm - in - Option.valOf - (if Option.isSome a andalso wordsSyntax.is_word_type ty - then a - else if Option.isSome b andalso ty = bitstringSyntax.bitstring_ty - then b - else if Option.isSome c andalso ty = intSyntax.int_ty - then c - else raise ERR "Mop" "pick") tm - end + fun pick (a, b) tm = (if Lib.can wordsSyntax.dim_of tm then a else b) tm - fun pickMinMax (a, b, c) tm = - let - val ty = (fst o pairSyntax.dest_prod o Term.type_of) tm - in - (if wordsSyntax.is_word_type ty - then a - else if ty = numSyntax.num - then b - else if ty = intSyntax.int_ty - then c - else raise ERR "Mop" "pickMinMax") tm - end + fun pickMinMax (a, b, c) tm = + let + val ty = (fst o pairSyntax.dest_prod o Term.type_of) tm + in + (if wordsSyntax.is_word_type ty + then a + else if ty = numSyntax.num + then b + else if ty = intSyntax.int_ty + then c + else raise ERR "Mop" "pickMinMax") tm + end in fun Mop (m : monop, x) = (case m of - Abs => - pick (SOME wordsSyntax.mk_word_abs, NONE, SOME intSyntax.mk_absval) + Abs => pick (wordsSyntax.mk_word_abs, intSyntax.mk_absval) | BNot => wordsSyntax.mk_word_1comp | Bin => ASCIInumbersSyntax.mk_fromBinString | Cardinality => pred_setSyntax.mk_card @@ -960,13 +941,11 @@ in | IsUpper => stringSyntax.mk_isupper | K1 ty => (fn tm => combinSyntax.mk_K_1 (tm, Ty ty)) | Length => listSyntax.mk_length - | Log => - pick (SOME wordsSyntax.mk_word_log2, SOME bitSyntax.mk_log2, NONE) + | Log => pick (wordsSyntax.mk_word_log2, bitSyntax.mk_log2) | Max => pickMinMax (mk_word_max, mk_num_max, mk_int_max) | Min => pickMinMax (mk_word_min, mk_num_min, mk_int_min) | Msb => wordsSyntax.mk_word_msb - | Neg => - pick (SOME wordsSyntax.mk_word_2comp, NONE, SOME intSyntax.mk_negated) + | Neg => pick (wordsSyntax.mk_word_2comp, intSyntax.mk_negated) | Not => boolSyntax.mk_neg | PadLeft => mk_pad_left | PadRight => mk_pad_right @@ -974,7 +953,7 @@ in | Remove => mk_remove | RemoveExcept => mk_remove_e | RemoveDuplicates => listSyntax.mk_nub - | Rev => mk_rev + | Rev => pick (wordsSyntax.mk_word_reverse, listSyntax.mk_reverse) | SE ty => mk_sign_extend ty | Size => wordsSyntax.mk_word_len | Smax => mk_word_smax From 9ace4ee8af953fd13b31a57738bb09231e12ce99 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 7 Oct 2015 19:45:30 +1100 Subject: [PATCH 541/718] ALL/EVERY h.o. predicates for sums, pairs, options Named {SUM,PROD,OPTION}_ALL, taking as many predicate arguments as their are arguments to the type operator. Also provide monotonicity and congruence theorems --- src/option/optionScript.sml | 22 ++++++++++++++++++++++ src/pair/src/pairScript.sml | 33 ++++++++++++++++++++++++++++++++- src/sum/sumScript.sml | 28 ++++++++++++++++++++++++++++ 3 files changed, 82 insertions(+), 1 deletion(-) diff --git a/src/option/optionScript.sml b/src/option/optionScript.sml index 0880a4882f..7f1b469dd8 100644 --- a/src/option/optionScript.sml +++ b/src/option/optionScript.sml @@ -610,6 +610,28 @@ val option_case_cong = save_thm("option_case_cong", Prim_rec.case_cong_thm option_nchotomy option_case_def); +val OPTION_ALL_def = Prim_rec.new_recursive_definition { + def = ``(OPTION_ALL P NONE <=> T) /\ (OPTION_ALL P (SOME (x:'a)) <=> P x)``, + name = "OPTION_ALL_def", + rec_axiom = option_Axiom }; +val _ = export_rewrites ["OPTION_ALL_def"] +val _ = computeLib.add_persistent_funs ["OPTION_ALL_def"] + +val OPTION_ALL_MONO = store_thm( + "OPTION_ALL_MONO", + ``(!x:'a. P x ==> P' x) ==> OPTION_ALL P opt ==> OPTION_ALL P' opt``, + Q.SPEC_THEN `opt` STRUCT_CASES_TAC option_nchotomy THEN + REWRITE_TAC [OPTION_ALL_def] THEN REPEAT STRIP_TAC THEN RES_TAC); +val _ = IndDefLib.export_mono "OPTION_ALL_MONO" + +val OPTION_ALL_CONG = store_thm( + "OPTION_ALL_CONG[defncong]", + ``!opt opt' P P'. + (opt = opt') /\ (!x. (opt' = SOME x) ==> (P x <=> P' x)) ==> + (OPTION_ALL P opt <=> OPTION_ALL P' opt')``, + simpLib.SIMP_TAC (srw_ss()) [FORALL_OPTION]); + + val _ = adjoin_to_theory {sig_ps = SOME (fn ppstrm => let val S = PP.add_string ppstrm diff --git a/src/pair/src/pairScript.sml b/src/pair/src/pairScript.sml index ea31b0067d..ac3af98e04 100644 --- a/src/pair/src/pairScript.sml +++ b/src/pair/src/pairScript.sml @@ -331,6 +331,37 @@ val FORALL_PROD = Q.store_thm("FORALL_PROD", val pair_induction = save_thm("pair_induction", #2(EQ_IMP_RULE FORALL_PROD)); +(* ---------------------------------------------------------------------- + PROD_ALL + ---------------------------------------------------------------------- *) + +val PROD_ALL_def = new_definition( + "PROD_ALL_def", + ``PROD_ALL (P:'a -> bool) (Q : 'b -> bool) p <=> P (FST p) /\ Q (SND p)``); + +val PROD_ALL_THM = store_thm( + "PROD_ALL_THM", + ``PROD_ALL P Q (x:'a,y:'b) <=> P x /\ Q y``, + REWRITE_TAC [PROD_ALL_def, FST, SND]); +val _ = BasicProvers.export_rewrites ["PROD_ALL_THM"] +val _ = computeLib.add_persistent_funs ["PROD_ALL_THM"] + +val PROD_ALL_MONO = store_thm( + "PROD_ALL_MONO", + ``(!x:'a. P x ==> P' x) /\ (!y:'b. Q y ==> Q' y) ==> + PROD_ALL P Q p ==> PROD_ALL P' Q' p``, + Q.SPEC_THEN `p` STRUCT_CASES_TAC ABS_PAIR_THM THEN + REWRITE_TAC [PROD_ALL_THM] THEN REPEAT STRIP_TAC THEN RES_TAC); +val _ = IndDefLib.export_mono "PROD_ALL_MONO" + +val PROD_ALL_CONG = store_thm( + "PROD_ALL_CONG[defncong]", + ``!p p' P P' Q Q'. + (p = p') /\ (!x:'a y:'b. (p' = (x,y)) ==> (P x <=> P' x)) /\ + (!x:'a y:'b. (p' = (x,y)) ==> (Q y <=> Q' y)) ==> + (PROD_ALL P Q p <=> PROD_ALL P' Q' p')``, + SIMP_TAC (BasicProvers.srw_ss()) [FORALL_PROD, PAIR_EQ]); + (* ------------------------------------------------------------------------- *) (* ELIM_PEXISTS = |- !P. (?p. P (FST p) (SND p)) = ?p1 p2. P p1 p2 *) (* ------------------------------------------------------------------------- *) @@ -700,7 +731,7 @@ val LEX_CONG = Q.store_thm (!a b c d. (v1' = (a,b)) /\ (v2' = (c,d)) /\ (a=c) ==> (R2 b d = R2' b d)) ==> ($LEX R1 R2 v1 v2 = $LEX R1' R2' v1' v2')`, - Ho_Rewrite.REWRITE_TAC [LEX_DEF,FORALL_PROD,PAIR_EQ] + Ho_Rewrite.REWRITE_TAC [LEX_DEF,FORALL_PROD,PAIR_EQ] THEN NTAC 2 (REWRITE_TAC [UNCURRY_VAR,FST,SND] THEN BETA_TAC) THEN METIS_TAC[]); diff --git a/src/sum/sumScript.sml b/src/sum/sumScript.sml index b9aa77b7f4..0aebadd65b 100644 --- a/src/sum/sumScript.sml +++ b/src/sum/sumScript.sml @@ -433,8 +433,36 @@ val NOT_ISR_ISL = store_thm("NOT_ISR_ISL", GEN_TAC THEN Q.SPEC_THEN `x` STRUCT_CASES_TAC sum_CASES THEN SRW_TAC[][]) val _ = export_rewrites["NOT_ISR_ISL"] +(* ---------------------------------------------------------------------- + SUM_ALL + ---------------------------------------------------------------------- *) + +val SUM_ALL_def = Prim_rec.new_recursive_definition { + def = ``(SUM_ALL (P:'a -> bool) (Q:'b -> bool) (INL x) <=> P x) /\ + (SUM_ALL (P:'a -> bool) (Q:'b -> bool) (INR y) <=> Q y)``, + name = "SUM_ALL_def", + rec_axiom = sum_Axiom} +val _ = export_rewrites ["SUM_ALL_def"] + +val SUM_ALL_MONO = store_thm( + "SUM_ALL_MONO", + ``(!x:'a. P x ==> P' x) /\ (!y:'b. Q y ==> Q' y) ==> + SUM_ALL P Q s ==> SUM_ALL P' Q' s``, + Q.SPEC_THEN `s` STRUCT_CASES_TAC sum_CASES THEN + REWRITE_TAC [SUM_ALL_def] THEN REPEAT STRIP_TAC THEN RES_TAC); +val _ = IndDefLib.export_mono "SUM_ALL_MONO" + +val SUM_ALL_CONG = store_thm( + "SUM_ALL_CONG[defncong]", + ``!(s:'a + 'b) s' P P' Q Q'. + (s = s') /\ (!a. (s' = INL a) ==> (P a <=> P' a)) /\ + (!b. (s' = INR b) ==> (Q b <=> Q' b)) ==> + (SUM_ALL P Q s <=> SUM_ALL P' Q' s')``, + SIMP_TAC (srw_ss()) [FORALL_SUM]); + val _ = computeLib.add_persistent_funs ["sum_case_def", "INL_11", "INR_11", "sum_distinct", "sum_distinct1", + "SUM_ALL_def", "OUTL", "OUTR", "ISL", "ISR"] local open OpenTheoryMap From 1c94f5f9e430d5ee3dfc88325b653ff8885bcce2 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 7 Oct 2015 19:48:22 +1100 Subject: [PATCH 542/718] Remove some structure foo = struct .. end bracketing This is unnecessary in script files. --- src/pair/src/pairScript.sml | 5 ----- src/sum/sumScript.sml | 5 ----- 2 files changed, 10 deletions(-) diff --git a/src/pair/src/pairScript.sml b/src/pair/src/pairScript.sml index ac3af98e04..9d72e1ebc8 100644 --- a/src/pair/src/pairScript.sml +++ b/src/pair/src/pairScript.sml @@ -12,9 +12,6 @@ (* DATE : August 7, 1997 *) (* ===================================================================== *) -structure pairScript = -struct - (* interactive use: app load ["Q", "relationTheory", "mesonLib", "OpenTheoryMap", "BasicProvers"]; open Parse relationTheory mesonLib; @@ -917,5 +914,3 @@ val _ = adjoin_to_theory val _ = export_theory(); val _ = export_theory_as_docfiles (Path.concat (Path.parentArc, "help/thms")) - -end; diff --git a/src/sum/sumScript.sml b/src/sum/sumScript.sml index 0aebadd65b..cdc2aea38a 100644 --- a/src/sum/sumScript.sml +++ b/src/sum/sumScript.sml @@ -29,9 +29,6 @@ (* ===================================================================== *) -structure sumScript = -struct - open HolKernel Parse boolLib BasicProvers; (* done to keep Holmake happy - satTheory is an ancestor of BasicProvers *) @@ -524,5 +521,3 @@ val datatype_sum = store_thm( REWRITE_TAC[DATATYPE_TAG_THM]); val _ = export_theory(); - -end From 1227e5ac16d397d8fb84c9fa82a415f57721b668 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Thu, 8 Oct 2015 11:55:00 +1100 Subject: [PATCH 543/718] various llist theorems LTAKE_EQ_NONE_LNTH was exported with the wrong name; corrected. LPREFIX: reflexivity, antisymmetry, transitivity, cons and nil theorems, fromList and LUNFOLD theorems. a couple more misc. theorems about LTAKE, LFINITE, LLENGTH, LAPPEND and their interactions. --- src/llist/llistScript.sml | 121 +++++++++++++++++++++++++++++++++++++- 1 file changed, 120 insertions(+), 1 deletion(-) diff --git a/src/llist/llistScript.sml b/src/llist/llistScript.sml index 4a394992db..1fa8932fc7 100644 --- a/src/llist/llistScript.sml +++ b/src/llist/llistScript.sml @@ -510,7 +510,7 @@ val LTAKE_SNOC_LNTH = store_thm( ]); val LTAKE_EQ_NONE_LNTH = store_thm( - "LTAKE_LNTH", + "LTAKE_EQ_NONE_LNTH", ``!n ll. (LTAKE n ll = NONE) ==> (LNTH n ll = NONE)``, Induct THEN ASM_SIMP_TAC (srw_ss()) [LTAKE,LNTH] THEN Q.X_GEN_TAC `ll` THEN @@ -695,6 +695,16 @@ val LAPPEND_NIL_2ND = store_thm( STRUCT_CASES_TAC (Q.SPEC `ll4` llist_CASES) THEN SIMP_TAC (srw_ss()) []); +val LHD_LAPPEND = Q.store_thm("LHD_LAPPEND", + `LHD (LAPPEND l1 l2) = if l1 = LNIL then LHD l2 else LHD l1`, + qspec_then`l1`FULL_STRUCT_CASES_TAC llist_CASES >> rw[]) + +val LTAKE_LAPPEND1 = Q.store_thm("LTAKE_LAPPEND1", + `∀n l1 l2. IS_SOME (LTAKE n l1) ⇒ (LTAKE n (LAPPEND l1 l2) = LTAKE n l1)`, + Induct >> rw[LTAKE_THM] >> + qspec_then`l1`FULL_STRUCT_CASES_TAC llist_CASES >> fs[] >> + Cases_on`LTAKE n t`>>fs[]) + (* ---------------------------------------------------------------------- finiteness and list length ---------------------------------------------------------------------- *) @@ -777,6 +787,13 @@ val NOT_LFINITE_NO_LENGTH = store_thm( ``!ll. ~LFINITE ll ==> (LLENGTH ll = NONE)``, SIMP_TAC (srw_ss()) [LLENGTH]); +val LFINITE_LLENGTH = Q.store_thm("LFINITE_LLENGTH", + `LFINITE ll ⇔ ∃n. LLENGTH ll = SOME n`, + rw[EQ_IMP_THM,LFINITE_HAS_LENGTH] >> + spose_not_then strip_assume_tac >> + imp_res_tac NOT_LFINITE_NO_LENGTH >> + fs[]) + val LFINITE_INDUCTION = save_thm( "LFINITE_INDUCTION", CONV_RULE (RENAME_VARS_CONV ["P"]) LFINITE_ind); @@ -1580,6 +1597,43 @@ SRW_TAC [] [] THEN FULL_SIMP_TAC (srw_ss()) [] THEN METIS_TAC []); +val LTAKE_LNTH_EL = Q.store_thm ("LTAKE_LNTH_EL", + `!n ll m l. + (LTAKE n ll = SOME l) ∧ + m < n + ⇒ + (LNTH m ll = SOME (EL m l))`, + Induct>>simp[]>> + (* "Cases" *) + (fn (g as(_,w)) => (gen_tac >> + FULL_STRUCT_CASES_TAC(ISPEC(#1(dest_forall w))llist_CASES))g) >> + simp[PULL_EXISTS] >> Cases>>simp[]); + +val LTAKE_TAKE_LESS = Q.store_thm("LTAKE_TAKE_LESS", + `(LTAKE n ll = SOME l) ∧ m ≤ n ⇒ + (LTAKE m ll = SOME (TAKE m l))`, + rw[] >> Cases_on`n=m`>>fs[] >> + imp_res_tac LTAKE_LENGTH >> rw[] >> + Cases_on`LTAKE m ll` >- ( + imp_res_tac LTAKE_EQ_NONE_LNTH >> + `m < LENGTH l` by fsrw_tac[ARITH_ss][] >> + imp_res_tac LTAKE_LNTH_EL >> fs[] ) >> + imp_res_tac LTAKE_LENGTH >> simp[] >> + simp[listTheory.LIST_EQ_REWRITE,rich_listTheory.EL_TAKE] >> rw[] >> + qmatch_assum_rename_tac`n < LENGTH x` >> + `n < LENGTH l` by decide_tac >> + imp_res_tac LTAKE_LNTH_EL >> fs[]); + +val LTAKE_LLENGTH_NONE = Q.store_thm("LTAKE_LLENGTH_NONE", + `(LLENGTH ll = SOME n) ∧ n < m ⇒ (LTAKE m ll = NONE)`, + rw[] >> `LFINITE ll` by metis_tac[LFINITE_LLENGTH] >> + `∀ll. LFINITE ll ⇒ ∀m n. (LLENGTH ll = SOME n) ∧ n < m + ⇒ (LTAKE m ll = NONE)` suffices_by metis_tac[] >> + rpt (pop_assum kall_tac) >> + ho_match_mp_tac LFINITE_INDUCTION >> rw[] >> + simp[LTAKE_CONS_EQ_NONE] >> + Cases_on`m`>>fs[]) + (* ------------------------------------------------------------------------ *) (* Turning a stream-like linear order into a lazy list *) @@ -1837,6 +1891,71 @@ val LPREFIX_def = Define ` | NONE => LTAKE (LENGTH xs) l2 = SOME xs | SOME ys => isPREFIX xs ys` +val LPREFIX_LNIL = Q.store_thm("LPREFIX_LNIL[simp]", + `LPREFIX [||] ll ∧ + (LPREFIX ll [||] ⇔ (ll = [||]))`, + rw[LPREFIX_def,toList_THM] >> + BasicProvers.CASE_TAC >> + simp[rich_listTheory.IS_PREFIX_NIL] >> + rw[EQ_IMP_THM] >> fs[toList_THM] >> + (* "Cases_on `ll`" *) + Q.ISPEC_THEN`ll`FULL_STRUCT_CASES_TAC llist_CASES >> + fs[toList_THM]); + +val LPREFIX_LCONS = Q.store_thm("LPREFIX_LCONS", + `(∀ll h t. + LPREFIX ll (h:::t) ⇔ + ((ll = [||]) ∨ ∃l. (ll = h:::l) ∧ LPREFIX l t)) ∧ + (∀h t ll. + LPREFIX (h:::t) ll ⇔ + ∃l. (ll = h:::l) ∧ LPREFIX t l)`, + rw[] >> + Q.ISPEC_THEN`ll`FULL_STRUCT_CASES_TAC llist_CASES >> + simp[LPREFIX_def,toList_THM] >> + every_case_tac >> fs[] >> rw[EQ_IMP_THM]); + +val LPREFIX_LUNFOLD = Q.store_thm("LPREFIX_LUNFOLD", + `LPREFIX ll (LUNFOLD f n) ⇔ + case f n of NONE => (ll = LNIL) + | SOME (n,x) => ∀h t. (ll = h:::t) ⇒ (h = x) ∧ LPREFIX t (LUNFOLD f n)`, + BasicProvers.CASE_TAC >- ( + simp[LUNFOLD_THM,LPREFIX_LNIL] ) >> + BasicProvers.CASE_TAC >> + imp_res_tac LUNFOLD_THM >> + simp[LPREFIX_LCONS] >> + (* "Cases_on `ll`" *) + Q.ISPEC_THEN`ll`FULL_STRUCT_CASES_TAC llist_CASES >> + simp[]); + +val LPREFIX_REFL = Q.store_thm("LPREFIX_REFL[simp]", + `LPREFIX ll ll`, + rw[LPREFIX_def] >> BasicProvers.CASE_TAC >> simp[]); + +val LPREFIX_ANTISYM = Q.store_thm("LPREFIX_ANTISYM", + `LPREFIX l1 l2 ∧ LPREFIX l2 l1 ⇒ (l1 = l2)`, + rw[LPREFIX_def] >> + every_case_tac >> fs[] >> + imp_res_tac rich_listTheory.IS_PREFIX_ANTISYM >> rw[] >> + metis_tac[to_fromList,optionTheory.THE_DEF,toList,optionTheory.NOT_SOME_NONE]); + +val LPREFIX_TRANS = Q.store_thm("LPREFIX_TRANS", + `LPREFIX l1 l2 ∧ LPREFIX l2 l3 ⇒ LPREFIX l1 l3`, + rw[LPREFIX_def] >> + every_case_tac >> fs[] >> + TRY(imp_res_tac rich_listTheory.IS_PREFIX_TRANS >> NO_TAC) >> + imp_res_tac rich_listTheory.IS_PREFIX_LENGTH >> + imp_res_tac LTAKE_TAKE_LESS >> simp[] >> + fs[rich_listTheory.IS_PREFIX_APPEND] >> + simp[listTheory.TAKE_APPEND1]); + +val LPREFIX_fromList = Q.store_thm ("LPREFIX_fromList", + `!l ll. + LPREFIX (fromList l) ll ⇔ + case toList ll of + | NONE => LTAKE (LENGTH l) ll = SOME l + | SOME ys => isPREFIX l ys`, + rw [LPREFIX_def, from_toList]); + val _ = export_theory(); end; From 25468b36b6a97607e3f8a8fc134e37dfb4a3a9c6 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Thu, 8 Oct 2015 16:23:38 +1100 Subject: [PATCH 544/718] more llist theorems highlights: - LPREFIX is total if restricted to prefixes of a fixed llist - LPREFIX is equivalent to the existence of an LAPPEND --- src/list/src/rich_listScript.sml | 5 + src/llist/llistScript.sml | 165 ++++++++++++++++++++++++++++--- src/option/optionScript.sml | 5 + 3 files changed, 162 insertions(+), 13 deletions(-) diff --git a/src/list/src/rich_listScript.sml b/src/list/src/rich_listScript.sml index ffe35f0d77..e352e82888 100644 --- a/src/list/src/rich_listScript.sml +++ b/src/list/src/rich_listScript.sml @@ -2725,6 +2725,11 @@ val IS_PREFIX_APPEND3 = save_thm("IS_PREFIX_APPEND3", |> Q.GENL [`c`, `a`]) val _ = export_rewrites ["IS_PREFIX_APPEND3"] +val prefixes_is_prefix_total = Q.store_thm("prefixes_is_prefix_total", + `∀l. ∀l1 l2. IS_PREFIX l l1 ∧ IS_PREFIX l l2 ⇒ IS_PREFIX l2 l1 ∨ IS_PREFIX l1 l2`, + Induct THEN SIMP_TAC(srw_ss())[IS_PREFIX_NIL] THEN + GEN_TAC THEN Cases THEN SIMP_TAC(srw_ss())[] THEN + Cases THEN SRW_TAC[][]) (*--------------------------------------------------------------------------- A list of numbers diff --git a/src/llist/llistScript.sml b/src/llist/llistScript.sml index 1fa8932fc7..7a8e4b2519 100644 --- a/src/llist/llistScript.sml +++ b/src/llist/llistScript.sml @@ -835,6 +835,18 @@ val LFINITE_APPEND = store_thm( SIMP_TAC (srw_ss()) [LFINITE_THM, LAPPEND] ]); +val LTAKE_LNTH_EL = Q.store_thm ("LTAKE_LNTH_EL", + `!n ll m l. + (LTAKE n ll = SOME l) ∧ + m < n + ⇒ + (LNTH m ll = SOME (EL m l))`, + Induct>>simp[]>> + (* "Cases" *) + (fn (g as(_,w)) => (gen_tac >> + FULL_STRUCT_CASES_TAC(ISPEC(#1(dest_forall w))llist_CASES))g) >> + simp[PULL_EXISTS] >> Cases>>simp[]); + val NOT_LFINITE_APPEND = store_thm( "NOT_LFINITE_APPEND", ``!ll1 ll2. ~LFINITE ll1 ==> (LAPPEND ll1 ll2 = ll1)``, @@ -930,6 +942,11 @@ val LFINITE_toList = store_thm( HO_MATCH_MP_TAC LFINITE_STRONG_INDUCTION THEN REPEAT STRIP_TAC THEN ASM_SIMP_TAC (srw_ss()) [toList_THM]); +val LFINITE_toList_SOME = Q.store_thm("LFINITE_toList_SOME", + `LFINITE ll ⇔ IS_SOME (toList ll)`, + EQ_TAC >> simp[optionTheory.IS_SOME_EXISTS,LFINITE_toList] >> + rw[] >> fs[toList]) + val to_fromList = store_thm( "to_fromList", ``!ll. LFINITE ll ==> (fromList (THE (toList ll)) = ll)``, @@ -937,6 +954,26 @@ val to_fromList = store_thm( SIMP_TAC (srw_ss()) [toList_THM] THEN REPEAT STRIP_TAC THEN IMP_RES_TAC LFINITE_toList THEN FULL_SIMP_TAC (srw_ss()) []); +val LTAKE_LAPPEND2 = Q.store_thm("LTAKE_LAPPEND2", + `∀n l1 l2. (LTAKE n l1 = NONE) ⇒ + (LTAKE n (LAPPEND l1 l2) = + OPTION_MAP (APPEND (THE(toList l1))) (LTAKE (n - THE(LLENGTH l1)) l2))`, + rpt gen_tac >> strip_tac >> + `LFINITE l1` by metis_tac[LFINITE] >> + qpat_assum`_ = _`mp_tac >> + map_every qid_spec_tac[`l2`,`n`] >> + pop_assum mp_tac >> + qid_spec_tac`l1` >> + ho_match_mp_tac LFINITE_INDUCTION >> + rw[toList_THM] >- ( + Cases_on`LTAKE n l2`>>simp[] ) >> + Cases_on`n`>>fs[] >> + simp[optionTheory.OPTION_MAP_COMPOSE] >> + `LFINITE l1` by metis_tac[LFINITE] >> + imp_res_tac LFINITE_toList >> simp[] >> + imp_res_tac LFINITE_HAS_LENGTH >> simp[] >> + rpt (AP_THM_TAC ORELSE AP_TERM_TAC) >> simp[FUN_EQ_THM] ) + (* ---------------------------------------------------------------------- LDROP : num -> 'a llist -> 'a llist option @@ -966,7 +1003,6 @@ val LDROP1_THM = store_thm( GEN_TAC THEN Cases_on `LTL ll` THEN SIMP_TAC (srw_ss()) [LDROP]); - val NOT_LFINITE_TAKE = store_thm( "NOT_LFINITE_TAKE", ``!ll. ~LFINITE ll ==> !n. ?y. LTAKE n ll = SOME y``, @@ -1045,6 +1081,38 @@ val LDROP_ADD = store_thm("LDROP_ADD", \\ Cases_on `LTL x` \\ fs [] \\ Cases_on `LDROP k1 x'` \\ fs []); +val LFINITE_LNTH_NONE = Q.store_thm("LFINITE_LNTH_NONE", + `LFINITE ll ⇔ ∃n. LNTH n ll = NONE`, + EQ_TAC >- ( + qid_spec_tac`ll` >> + ho_match_mp_tac LFINITE_INDUCTION >> + rw[] >> qexists_tac`SUC n` >> simp[] ) >> + metis_tac[NOT_LFINITE_TAKE,LTAKE_LNTH_EL, + optionTheory.NOT_SOME_NONE, + prim_recTheory.LESS_SUC_REFL]); + +val LNTH_LAPPEND = Q.store_thm("LNTH_LAPPEND", + `LNTH n (LAPPEND l1 l2) = + case LLENGTH l1 of NONE => LNTH n l1 + | SOME m => if n < m then LNTH n l1 else LNTH (n-m) l2`, + Cases_on`LFINITE l1` >- ( + map_every qid_spec_tac[`l2`,`n`] >> + pop_assum mp_tac >> qid_spec_tac`l1` >> + ho_match_mp_tac LFINITE_STRONG_INDUCTION >> rw[] >> + imp_res_tac LFINITE_HAS_LENGTH >> fs[] >> + Cases_on`n`>>fs[] ) >> + BasicProvers.CASE_TAC >> + fs[LFINITE_LLENGTH] >> + `∀n. ∃x. LNTH n l1 = SOME x` by ( + metis_tac[LFINITE_LNTH_NONE,LFINITE_LLENGTH, + optionTheory.option_CASES,optionTheory.NOT_SOME_NONE] ) >> + Cases_on`LTAKE (SUC n) l1` >- ( + metis_tac[optionTheory.NOT_SOME_NONE,LTAKE_EQ_NONE_LNTH] ) >> + qspecl_then[`SUC n`,`l1`,`l2`]mp_tac LTAKE_LAPPEND1 >> + simp[] >> strip_tac >> + imp_res_tac LTAKE_LNTH_EL >> + rpt(pop_assum(qspec_then`n`mp_tac)) >> simp[]) + (* ---------------------------------------------------------------------- exists : ('a -> bool) -> 'a llist -> bool @@ -1597,18 +1665,6 @@ SRW_TAC [] [] THEN FULL_SIMP_TAC (srw_ss()) [] THEN METIS_TAC []); -val LTAKE_LNTH_EL = Q.store_thm ("LTAKE_LNTH_EL", - `!n ll m l. - (LTAKE n ll = SOME l) ∧ - m < n - ⇒ - (LNTH m ll = SOME (EL m l))`, - Induct>>simp[]>> - (* "Cases" *) - (fn (g as(_,w)) => (gen_tac >> - FULL_STRUCT_CASES_TAC(ISPEC(#1(dest_forall w))llist_CASES))g) >> - simp[PULL_EXISTS] >> Cases>>simp[]); - val LTAKE_TAKE_LESS = Q.store_thm("LTAKE_TAKE_LESS", `(LTAKE n ll = SOME l) ∧ m ≤ n ⇒ (LTAKE m ll = SOME (TAKE m l))`, @@ -1634,6 +1690,23 @@ val LTAKE_LLENGTH_NONE = Q.store_thm("LTAKE_LLENGTH_NONE", simp[LTAKE_CONS_EQ_NONE] >> Cases_on`m`>>fs[]) +val toList_LAPPEND_APPEND = Q.store_thm("toList_LAPPEND_APPEND", + `(toList (LAPPEND l1 l2) = SOME x) ⇒ + (x = (THE(toList l1)++THE(toList l2)))`, + Cases_on`l2=[||]`>>simp[toList_THM,LAPPEND_NIL_2ND] >> + strip_tac >> fs[toList,LFINITE_APPEND] >> + rfs[LLENGTH_APPEND] >> + qmatch_assum_abbrev_tac`LTAKE n (LAPPEND l1 l2) = SOME x` >> + `LTAKE n l1 = NONE` by ( + match_mp_tac (GEN_ALL LTAKE_LLENGTH_NONE) >> + imp_res_tac LTAKE_LENGTH >> + imp_res_tac LFINITE_HAS_LENGTH >> + fs[Abbr`n`] >> + qspec_then`l2`FULL_STRUCT_CASES_TAC llist_CASES >> fs[] >> + decide_tac ) >> + fs[LTAKE_LAPPEND2,Abbr`n`] >> + simp[toList]); + (* ------------------------------------------------------------------------ *) (* Turning a stream-like linear order into a lazy list *) @@ -1956,6 +2029,72 @@ val LPREFIX_fromList = Q.store_thm ("LPREFIX_fromList", | SOME ys => isPREFIX l ys`, rw [LPREFIX_def, from_toList]); +val prefixes_lprefix_total = Q.store_thm("prefixes_lprefix_total", + `∀ll. ∀l1 l2. LPREFIX l1 ll ∧ LPREFIX l2 ll ⇒ + LPREFIX l1 l2 ∨ LPREFIX l2 l1`, + rw[LPREFIX_def] >> reverse every_case_tac >> fs[] + >- metis_tac[rich_listTheory.prefixes_is_prefix_total] >> + rpt(pop_assum mp_tac) >> + qho_match_abbrev_tac`P l1 l2 x x'` >> + `P l1 l2 x x' ⇔ P l2 l1 x' x` by ( + simp[Abbr`P`] >> metis_tac[] ) >> + `∀ll1 ll2 l1 l2. LENGTH l1 ≤ LENGTH l2 ⇒ P ll1 ll2 l1 l2` suffices_by ( + rw[] >> metis_tac[arithmeticTheory.LESS_EQ_CASES] ) >> + pop_assum kall_tac >> unabbrev_all_tac >> rw[] >> + `l1 = (TAKE (LENGTH l1) l2)` by ( + metis_tac[LTAKE_TAKE_LESS,optionTheory.SOME_11] ) >> + simp[rich_listTheory.IS_PREFIX_APPEND] >> + metis_tac[listTheory.TAKE_DROP]) + +val LPREFIX_LAPPEND1 = Q.prove( + `LPREFIX ll (LAPPEND ll l2)`, + rw[LPREFIX_def] >> every_case_tac >> + metis_tac[LFINITE_toList,NOT_LFINITE_APPEND,optionTheory.NOT_SOME_NONE, + optionTheory.IS_SOME_EXISTS,to_fromList,optionTheory.THE_DEF,LTAKE_LAPPEND1, + LTAKE_fromList,toList_LAPPEND_APPEND,rich_listTheory.IS_PREFIX_APPEND]); + +val LTAKE_IMP_LDROP = Q.store_thm("LTAKE_IMP_LDROP", + `∀n ll l1. + (LTAKE n ll = SOME l1) ⇒ + ∃l2. (LDROP n ll = SOME l2) ∧ + (LAPPEND (fromList l1) l2 = ll)`, + Induct >> simp[] >> + gen_tac >> qspec_then`ll`FULL_STRUCT_CASES_TAC llist_CASES >> rw[] >> + first_x_assum(fn th => first_x_assum (strip_assume_tac o MATCH_MP th)) >> + rw[]) + +val LPREFIX_APPEND = Q.store_thm("LPREFIX_APPEND", + `LPREFIX l1 l2 ⇔ ∃ll. l2 = LAPPEND l1 ll`, + reverse EQ_TAC >- metis_tac[LPREFIX_LAPPEND1] >> + simp[LPREFIX_def] >> + Cases_on`toList l1`>>fs[] + >- metis_tac[LAPPEND_NIL_2ND] >> + `LFINITE l1` by fs[toList] >> + imp_res_tac LFINITE_HAS_LENGTH >> + `LTAKE n l1 = SOME x` by fs[toList] >> + imp_res_tac LTAKE_LENGTH >> rw[] >> + qexists_tac`THE(LDROP (LENGTH x) l2)` >> + rw[LNTH_EQ] >> + simp[LNTH_LAPPEND] >> + rw[] >> + every_case_tac >> fs[toList] >> + imp_res_tac LTAKE_LNTH_EL >> simp[] >> + fs[rich_listTheory.IS_PREFIX_APPEND] >> rw[] >> + imp_res_tac LTAKE_LENGTH >> fs[] >> + TRY ( + first_x_assum(qspec_then`n`mp_tac) >> + simp[rich_listTheory.EL_APPEND1] >> NO_TAC) >> + TRY ( + imp_res_tac LTAKE_IMP_LDROP >> rw[] >> + simp[LNTH_LAPPEND,LLENGTH_fromList] >> + NO_TAC) >> + `LTAKE (LENGTH x) l2 = SOME x` by ( + imp_res_tac LTAKE_TAKE_LESS >> + rpt(first_x_assum(qspec_then`LENGTH x`mp_tac)) >> + simp[rich_listTheory.TAKE_APPEND1] ) >> + pop_assum(strip_assume_tac o MATCH_MP LTAKE_IMP_LDROP) >> + rw[LNTH_LAPPEND,LLENGTH_fromList]); + val _ = export_theory(); end; diff --git a/src/option/optionScript.sml b/src/option/optionScript.sml index 7f1b469dd8..78e061b9b9 100644 --- a/src/option/optionScript.sml +++ b/src/option/optionScript.sml @@ -201,6 +201,11 @@ val ex1_rw = prove(Term`!x. (?y. x = y) /\ (?y. y = x)`, fun OPTION_CASES_TAC t = STRUCT_CASES_TAC (ISPEC t option_nchotomy); +val IS_SOME_EXISTS = store_thm("IS_SOME_EXISTS", + ``∀opt. IS_SOME opt ⇔ ∃x. opt = SOME x``, + GEN_TAC THEN (Q_TAC OPTION_CASES_TAC`opt`) THEN + SRW_TAC[][IS_SOME_DEF]) + val IS_NONE_EQ_NONE = Q.store_thm( "IS_NONE_EQ_NONE", `!x. IS_NONE x = (x = NONE)`, From 4ba8d33c429fbe933b042a4613f415d2b14dc54c Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 9 Oct 2015 09:38:46 +1100 Subject: [PATCH 545/718] Remove trailing w/space in rational/ratScript.sml --- src/rational/ratScript.sml | 60 +++++++++++++++++++------------------- 1 file changed, 30 insertions(+), 30 deletions(-) diff --git a/src/rational/ratScript.sml b/src/rational/ratScript.sml index 4a98533ec9..1898f673a2 100644 --- a/src/rational/ratScript.sml +++ b/src/rational/ratScript.sml @@ -55,31 +55,31 @@ val FRAC_DNMNN = let val th = MATCH_MP INT_LT_IMP_LE (SPEC_ALL FRAC_DNMPOS) fun ifcan f x = f x handle _ => x ; val RAT_EQUIV_NMR_Z_IFF = store_thm ("RAT_EQUIV_NMR_Z_IFF", - ``!a b. rat_equiv a b ==> ((frac_nmr a = 0) = (frac_nmr b = 0))``, + ``!a b. rat_equiv a b ==> ((frac_nmr a = 0) = (frac_nmr b = 0))``, REWRITE_TAC[rat_equiv_def] THEN REPEAT STRIP_TAC THEN EQ_TAC THEN DISCH_TAC THEN - FULL_SIMP_TAC std_ss [INT_MUL_LZERO, INT_MUL_RZERO, + FULL_SIMP_TAC std_ss [INT_MUL_LZERO, INT_MUL_RZERO, INT_ENTIRE, INT_ENTIRE', FRAC_DNMNZ]) ; val RAT_EQUIV_NMR_GTZ_IFF = store_thm ("RAT_EQUIV_NMR_GTZ_IFF", - ``!a b. rat_equiv a b ==> ((frac_nmr a > 0) = (frac_nmr b > 0))``, + ``!a b. rat_equiv a b ==> ((frac_nmr a > 0) = (frac_nmr b > 0))``, REWRITE_TAC[rat_equiv_def] THEN REPEAT STRIP_TAC THEN EQ_TAC THEN DISCH_TAC THEN RULE_ASSUM_TAC (ifcan (AP_TERM ``int_lt 0i``)) THEN FULL_SIMP_TAC std_ss [int_gt, INT_MUL_SIGN_CASES, FRAC_DNMPOS, FRAC_DNMNN ]) ; val RAT_EQUIV_NMR_LTZ_IFF = store_thm ("RAT_EQUIV_NMR_LTZ_IFF", - ``!a b. rat_equiv a b ==> ((frac_nmr a < 0) = (frac_nmr b < 0))``, + ``!a b. rat_equiv a b ==> ((frac_nmr a < 0) = (frac_nmr b < 0))``, REWRITE_TAC[rat_equiv_def] THEN REPEAT STRIP_TAC THEN EQ_TAC THEN DISCH_TAC THEN RULE_ASSUM_TAC (ifcan (AP_TERM ``int_gt 0i``)) THEN FULL_SIMP_TAC std_ss [int_gt, INT_MUL_SIGN_CASES, FRAC_DNMPOS, FRAC_DNMNN ]) ; val RAT_NMR_Z_IFF_EQUIV = store_thm ("RAT_NMR_Z_IFF_EQUIV", - ``!a b. (frac_nmr a = 0) ==> (rat_equiv a b = (frac_nmr b = 0))``, + ``!a b. (frac_nmr a = 0) ==> (rat_equiv a b = (frac_nmr b = 0))``, REWRITE_TAC[rat_equiv_def] THEN REPEAT STRIP_TAC THEN EQ_TAC THEN DISCH_TAC THEN - REV_FULL_SIMP_TAC std_ss [INT_MUL_LZERO, INT_MUL_RZERO, + REV_FULL_SIMP_TAC std_ss [INT_MUL_LZERO, INT_MUL_RZERO, INT_ENTIRE, INT_ENTIRE', FRAC_DNMNZ]) ; val times_dnmb = MATCH_MP INT_EQ_RMUL_EXP (Q.SPEC `b` FRAC_DNMPOS) ; @@ -89,27 +89,27 @@ val box_equals = prove (``(a = b) ==> (c = a) /\ (d = b) ==> (c = d)``, val RAT_EQUIV_TRANS = store_thm("RAT_EQUIV_TRANS", ``!a b c. rat_equiv a b /\ rat_equiv b c ==> rat_equiv a c``, - REPEAT GEN_TAC THEN Cases_on `frac_nmr b = 0` + REPEAT GEN_TAC THEN Cases_on `frac_nmr b = 0` THENL [ STRIP_TAC THEN RULE_ASSUM_TAC (ifcan (MATCH_MP RAT_EQUIV_NMR_Z_IFF)) THEN FULL_SIMP_TAC std_ss [RAT_NMR_Z_IFF_EQUIV], REWRITE_TAC[rat_equiv_def] THEN STRIP_TAC THEN ONCE_REWRITE_TAC [times_dnmb] THEN FIRST_X_ASSUM (fn th => ONCE_REWRITE_TAC [MATCH_MP INT_EQ_LMUL2 th]) THEN - POP_ASSUM_LIST (fn [thbc, thab] => ASSUME_TAC + POP_ASSUM_LIST (fn [thbc, thab] => ASSUME_TAC (MK_COMB (AP_TERM ``int_mul`` thab, thbc))) THEN POP_ASSUM (fn th => MATCH_MP_TAC (MATCH_MP box_equals th)) THEN CONJ_TAC THEN CONV_TAC (AC_CONV (INT_MUL_ASSOC,INT_MUL_SYM)) ] ) ; -val RAT_EQUIV_TRANS' = REWRITE_RULE [GSYM AND_IMP_INTRO] RAT_EQUIV_TRANS ; +val RAT_EQUIV_TRANS' = REWRITE_RULE [GSYM AND_IMP_INTRO] RAT_EQUIV_TRANS ; fun e2tac tthm = FIRST_X_ASSUM (fn th1 => let val tha1 = MATCH_MP tthm th1 ; in FIRST_X_ASSUM (fn th2 => ACCEPT_TAC (MATCH_MP tha1 th2)) end) ; - + val RAT_EQUIV = store_thm("RAT_EQUIV", ``!f1 f2. rat_equiv f1 f2 = (rat_equiv f1 = rat_equiv f2)``, - REPEAT GEN_TAC THEN EQ_TAC + REPEAT GEN_TAC THEN EQ_TAC THENL [ REWRITE_TAC[FUN_EQ_THM] THEN REPEAT STRIP_TAC THEN EQ_TAC THEN_LT @@ -131,27 +131,27 @@ fun feqconv thm = let val thm' = UNDISCH_ALL (SPEC_ALL thm) ; in DEPTH_CONV (REWR_CONV_A thm') end ; fun feqtac thm = VALIDATE (POP_ASSUM (ASSUME_TAC o CONV_RULE (feqconv thm))) ; -fun msprod th = let val [thbc, thab] = CONJUNCTS th +fun msprod th = let val [thbc, thab] = CONJUNCTS th in MK_COMB (AP_TERM ``int_mul`` (MATCH_MP EQ_SYM thab), thbc) end ; val RAT_EQUIV_ALT = store_thm("RAT_EQUIV_ALT", ``!a. rat_equiv a = \x. (?b c. 0 + FIRST_X_ASSUM (fn th => ONCE_REWRITE_TAC [MATCH_MP INT_EQ_RMUL_EXP th]) THEN FIRST_X_ASSUM (fn th => ONCE_REWRITE_TAC [MATCH_MP INT_EQ_RMUL_EXP th]) THEN @@ -316,17 +316,17 @@ val RAT_EQ_ALT = store_thm("RAT_EQ_ALT", ``! r1 r2. (r1=r2) = (rat_nmr r1 * rat_ val RAT_NMREQ0_CONG = store_thm("RAT_NMREQ0_CONG", ``!f1. (frac_nmr (rep_rat (abs_rat f1)) = 0) = (frac_nmr f1 = 0)``, - GEN_TAC THEN MATCH_ACCEPT_TAC + GEN_TAC THEN MATCH_ACCEPT_TAC (MATCH_MP RAT_EQUIV_NMR_Z_IFF (SPEC_ALL REP_ABS_EQUIV'))) ; val RAT_NMRLT0_CONG = store_thm("RAT_NMRLT0_CONG", ``!f1. (frac_nmr (rep_rat (abs_rat f1)) < 0) = (frac_nmr f1 < 0)``, - GEN_TAC THEN MATCH_ACCEPT_TAC + GEN_TAC THEN MATCH_ACCEPT_TAC (MATCH_MP RAT_EQUIV_NMR_LTZ_IFF (SPEC_ALL REP_ABS_EQUIV'))) ; val RAT_NMRGT0_CONG = store_thm("RAT_NMRGT0_CONG", ``!f1. (frac_nmr (rep_rat (abs_rat f1)) > 0) = (frac_nmr f1 > 0)``, - GEN_TAC THEN MATCH_ACCEPT_TAC + GEN_TAC THEN MATCH_ACCEPT_TAC (MATCH_MP RAT_EQUIV_NMR_GTZ_IFF (SPEC_ALL REP_ABS_EQUIV'))) ; (*-------------------------------------------------------------------------- @@ -363,15 +363,15 @@ val RAT_AINV_CONG = store_thm("RAT_AINV_CONG", ``!x. abs_rat (frac_ainv (rep_rat *--------------------------------------------------------------------------*) val FRAC_MINV_EQUIV = store_thm ("FRAC_MINV_EQUIV", - ``~(frac_nmr y=0) ==> rat_equiv x y ==> + ``~(frac_nmr y=0) ==> rat_equiv x y ==> rat_equiv (frac_minv x) (frac_minv y)``, - DISCH_TAC THEN DISCH_THEN (fn th => MP_TAC th THEN ASSUME_TAC th) THEN - POP_ASSUM (ASSUME_TAC o MATCH_MP RAT_EQUIV_NMR_Z_IFF) THEN + DISCH_TAC THEN DISCH_THEN (fn th => MP_TAC th THEN ASSUME_TAC th) THEN + POP_ASSUM (ASSUME_TAC o MATCH_MP RAT_EQUIV_NMR_Z_IFF) THEN REWRITE_TAC[frac_minv_def, rat_equiv_def, frac_sgn_def] THEN VALIDATE (CONV_TAC (feqconv NMR THENC feqconv DNM)) THEN (TRY (irule INT_ABS_NOT0POS THEN ASM_SIMP_TAC bool_ss [])) THEN REWRITE_TAC[SGN_def] THEN REPEAT IF_CASES_TAC THEN - ASM_SIMP_TAC int_ss [INT_ABS, + ASM_SIMP_TAC int_ss [INT_ABS, GSYM INT_NEG_MINUS1, GSYM INT_NEG_LMUL, GSYM INT_NEG_RMUL] THEN SIMP_TAC bool_ss [INT_MUL_COMM]) ; @@ -399,18 +399,18 @@ val FRAC_ADD_EQUIV1 = store_thm ("FRAC_ADD_EQUIV1", ``rat_equiv x x' ==> rat_equiv (frac_add x y) (frac_add x' y)``, REWRITE_TAC[frac_add_def, rat_equiv_def] THEN VALIDATE (CONV_TAC (feqconv NMR THENC feqconv DNM)) THEN - TRY (irule INT_MUL_POS_SIGN THEN irule FRAC_DNMPOS) THEN + TRY (irule INT_MUL_POS_SIGN THEN irule FRAC_DNMPOS) THEN REWRITE_TAC[INT_RDISTRIB] THEN DISCH_TAC THEN MK_COMB_TAC THENL [AP_TERM_TAC, ALL_TAC] THENL [ RULE_ASSUM_TAC (AP_TERM ``int_mul (frac_dnm y * frac_dnm y)``) THEN POP_ASSUM (fn th => MATCH_MP_TAC (MATCH_MP box_equals th)) THEN CONJ_TAC, - ALL_TAC ] THEN + ALL_TAC ] THEN CONV_TAC (AC_CONV (INT_MUL_ASSOC,INT_MUL_SYM)) ) ; val RAT_ADD_CONG1 = store_thm("RAT_ADD_CONG1", ``!x y. abs_rat (frac_add (rep_rat (abs_rat x)) y) = abs_rat (frac_add x y)``, - REPEAT STRIP_TAC THEN + REPEAT STRIP_TAC THEN SIMP_TAC bool_ss [RAT_ABS_EQUIV] THEN irule FRAC_ADD_EQUIV1 THEN irule REP_ABS_EQUIV') ; @@ -436,14 +436,14 @@ val FRAC_MUL_EQUIV1 = store_thm ("FRAC_MUL_EQUIV1", ``rat_equiv x x' ==> rat_equiv (frac_mul x y) (frac_mul x' y)``, REWRITE_TAC[frac_mul_def, rat_equiv_def] THEN VALIDATE (CONV_TAC (feqconv NMR THENC feqconv DNM)) THEN - TRY (irule INT_MUL_POS_SIGN THEN irule FRAC_DNMPOS) THEN DISCH_TAC THEN + TRY (irule INT_MUL_POS_SIGN THEN irule FRAC_DNMPOS) THEN DISCH_TAC THEN RULE_ASSUM_TAC (AP_TERM ``int_mul (frac_nmr y * frac_dnm y)``) THEN - POP_ASSUM (fn th => MATCH_MP_TAC (MATCH_MP box_equals th)) THEN + POP_ASSUM (fn th => MATCH_MP_TAC (MATCH_MP box_equals th)) THEN CONJ_TAC THEN CONV_TAC (AC_CONV (INT_MUL_ASSOC,INT_MUL_SYM)) ) ; val RAT_MUL_CONG1 = store_thm("RAT_MUL_CONG1", ``!x y. abs_rat (frac_mul (rep_rat (abs_rat x)) y) = abs_rat (frac_mul x y)``, - REPEAT STRIP_TAC THEN + REPEAT STRIP_TAC THEN SIMP_TAC bool_ss [RAT_ABS_EQUIV] THEN irule FRAC_MUL_EQUIV1 THEN irule REP_ABS_EQUIV') ; From 2b69b9c67ed6e160ad2d24666da032cf36e0e97c Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 9 Oct 2015 09:39:32 +1100 Subject: [PATCH 546/718] Stop EVAL making a mess of rational arithmetic Use zDefine to avoid having definitions of fundamental arithmetic operations expanded. --- src/rational/ratScript.sml | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/rational/ratScript.sml b/src/rational/ratScript.sml index 1898f673a2..96d8bad884 100644 --- a/src/rational/ratScript.sml +++ b/src/rational/ratScript.sml @@ -187,10 +187,10 @@ val rat_ainv_def = Define `rat_ainv r1 = abs_rat( frac_ainv (rep_rat r1))`; val rat_minv_def = Define `rat_minv r1 = abs_rat( frac_minv (rep_rat r1))`; (* basic arithmetics *) -val rat_add_def = Define `rat_add r1 r2 = abs_rat( frac_add (rep_rat r1) (rep_rat r2) )`; -val rat_sub_def = Define `rat_sub r1 r2 = abs_rat( frac_sub (rep_rat r1) (rep_rat r2) )`; -val rat_mul_def = Define `rat_mul r1 r2 = abs_rat( frac_mul (rep_rat r1) (rep_rat r2) )`; -val rat_div_def = Define `rat_div r1 r2 = abs_rat( frac_div (rep_rat r1) (rep_rat r2) )`; +val rat_add_def = zDefine `rat_add r1 r2 = abs_rat( frac_add (rep_rat r1) (rep_rat r2) )`; +val rat_sub_def = zDefine `rat_sub r1 r2 = abs_rat( frac_sub (rep_rat r1) (rep_rat r2) )`; +val rat_mul_def = zDefine `rat_mul r1 r2 = abs_rat( frac_mul (rep_rat r1) (rep_rat r2) )`; +val rat_div_def = zDefine `rat_div r1 r2 = abs_rat( frac_div (rep_rat r1) (rep_rat r2) )`; (* order relations *) val rat_les_def = Define `rat_les r1 r2 = (rat_sgn (rat_sub r2 r1) = 1)`; From f94c47aae7261bd23116ec339c9f0791aff91cfb Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 9 Oct 2015 09:41:17 +1100 Subject: [PATCH 547/718] Add {is,mk,dest}_{literal,rat_of_num} to ratSyntax Literals are - injections from :num; or - negated injections from :num; or - one of the above divided by an injection from :num The rat_of_num constant is the injection from :num, and hides behind the q suffix on numerals. --- src/rational/ratSyntax.sig | 5 +++++ src/rational/ratSyntax.sml | 20 ++++++++++++++++++++ 2 files changed, 25 insertions(+) diff --git a/src/rational/ratSyntax.sig b/src/rational/ratSyntax.sig index 0d4c477e23..a7ecccbd54 100644 --- a/src/rational/ratSyntax.sig +++ b/src/rational/ratSyntax.sig @@ -7,10 +7,12 @@ sig val rat_0_tm : term val rat_1_tm : term + val is_literal : term -> bool val rat_nmr_tm : term val rat_dnm_tm : term val rat_sgn_tm : term + val rat_of_num_tm : term val rat_ainv_tm : term val rat_minv_tm : term @@ -28,6 +30,7 @@ sig val mk_rat_nmr : term -> term val mk_rat_dnm : term -> term val mk_rat_sgn : term -> term + val mk_rat_of_num : term -> term val mk_rat_ainv : term -> term val mk_rat_minv : term -> term @@ -40,6 +43,7 @@ sig val dest_rat_nmr : term -> term val dest_rat_dnm : term -> term val dest_rat_sgn : term -> term + val dest_rat_of_num : term -> term val dest_rat_ainv : term -> term val dest_rat_minv : term -> term @@ -57,6 +61,7 @@ sig val is_rat_nmr : term -> bool val is_rat_dnm : term -> bool val is_rat_sgn : term -> bool + val is_rat_of_num : term -> bool val is_rat_ainv : term -> bool val is_rat_minv : term -> bool diff --git a/src/rational/ratSyntax.sml b/src/rational/ratSyntax.sml index 6a1377b2ea..d59279caab 100644 --- a/src/rational/ratSyntax.sml +++ b/src/rational/ratSyntax.sml @@ -38,6 +38,7 @@ val rat_les_tm = prim_mk_const {Name="rat_les",Thy="rat"}; val rat_gre_tm = prim_mk_const {Name="rat_gre",Thy="rat"}; val rat_leq_tm = prim_mk_const {Name="rat_leq",Thy="rat"}; val rat_geq_tm = prim_mk_const {Name="rat_geq",Thy="rat"}; +val rat_of_num_tm = prim_mk_const {Name = "rat_of_num", Thy = "rat"} (*--------------------------------------------------------------------------* * constructors @@ -52,6 +53,7 @@ val mk_rat_sgn = mk_monop rat_sgn_tm; val mk_rat_ainv = mk_monop rat_ainv_tm; val mk_rat_minv = mk_monop rat_minv_tm; +val mk_rat_of_num = mk_monop rat_of_num_tm; val mk_rat_add = mk_binop rat_add_tm; val mk_rat_sub = mk_binop rat_sub_tm; @@ -70,6 +72,7 @@ val mk_rat_geq = mk_binop rat_geq_tm; val dest_rat_nmr = dest_monop rat_nmr_tm (ERR "dest_rat_nmr" ""); val dest_rat_dnm = dest_monop rat_dnm_tm (ERR "dest_rat_dnm" ""); val dest_rat_sgn = dest_monop rat_sgn_tm (ERR "dest_rat_sgn" ""); +val dest_rat_of_num = dest_monop rat_of_num_tm (ERR "dest_rat_of_num" "") val dest_rat_ainv = dest_monop rat_ainv_tm (ERR "dest_rat_ainv" ""); val dest_rat_minv = dest_monop rat_minv_tm (ERR "dest_rat_minv" ""); @@ -91,6 +94,7 @@ val dest_rat_geq = dest_binop rat_geq_tm (ERR "dest_rat_geq" ""); val is_rat_nmr = can dest_rat_nmr; val is_rat_dnm = can dest_rat_dnm; val is_rat_sgn = can dest_rat_sgn; +val is_rat_of_num = can dest_rat_of_num val is_rat_ainv = can dest_rat_ainv; val is_rat_minv = can dest_rat_minv; @@ -105,6 +109,22 @@ val is_rat_gre = can dest_rat_gre; val is_rat_leq = can dest_rat_leq; val is_rat_geq = can dest_rat_geq; +(* ---------------------------------------------------------------------- + literals + ---------------------------------------------------------------------- *) + +fun is_int_injection t = + is_rat_of_num t orelse + is_rat_of_num (dest_rat_ainv t) handle HOL_ERR _ => false + +fun is_literal t = + is_int_injection t orelse + (let val (n,d) = dest_rat_div t + in + is_int_injection n andalso is_rat_of_num d + end handle HOL_ERR _ => false) + + (*--------------------------------------------------------------------------* * list constructors *--------------------------------------------------------------------------*) From dcbc968a5bb128bde20cfe1cfc7538eb67d092b1 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 9 Oct 2015 15:32:09 +1100 Subject: [PATCH 548/718] Fix recently broken proofs in sep logic example I don't know why some automatically generated variables should have suddenly started changing their names, but the change has certainly occurred. By using lcsymtacs.qcase_tac, it is possible to make sure that certain names really do occur in the expected positions. --- .../src/separationLogicScript.sml | 55 +++++++++++-------- .../src/vars_as_resourceScript.sml | 24 ++++---- 2 files changed, 45 insertions(+), 34 deletions(-) diff --git a/examples/separationLogic/src/separationLogicScript.sml b/examples/separationLogic/src/separationLogicScript.sml index 1a610ff73c..03f76f1be2 100644 --- a/examples/separationLogic/src/separationLogicScript.sml +++ b/examples/separationLogic/src/separationLogicScript.sml @@ -2269,11 +2269,12 @@ REPEAT STRIP_TAC THEN EQ_TAC THENL [ REPEAT STRIP_TAC THEN - Cases_on `R (SOME s1) NONE` THEN ( - ASM_SIMP_TAC std_ss [fasl_star_REWRITE, fasl_order_THM] - ) THEN + lcsymtacs.qcase_tac `f (SOME s1) (SOME s2) = SOME y` THEN + Cases_on `R (SOME s1) NONE` THEN + ASM_SIMP_TAC std_ss [fasl_star_REWRITE, fasl_order_THM] THEN `~(R (SOME y) NONE)` by METIS_TAC[] THEN - ASM_SIMP_TAC std_ss [asl_star_def, IN_ABS, IN_SING, fasl_order_THM, SUBSET_DEF] + ASM_SIMP_TAC std_ss [asl_star_def, IN_ABS, IN_SING, fasl_order_THM, + SUBSET_DEF] ]); @@ -2429,7 +2430,8 @@ val fasl_action_order_TRANSITIVE = store_thm ("fasl_action_order_TRANSITIVE", PROVE_TAC [fasl_action_order_IS_WEAK_ORDER, WeakOrder, transitive_def]); -val ASL_IS_LOCAL_ACTION___HOARE_TRIPLE = store_thm ("ASL_IS_LOCAL_ACTION___HOARE_TRIPLE", +val ASL_IS_LOCAL_ACTION___HOARE_TRIPLE = store_thm ( + "ASL_IS_LOCAL_ACTION___HOARE_TRIPLE", ``!f a. ( ASL_IS_LOCAL_ACTION f a = (!P Q. (HOARE_TRIPLE P a Q ==> @@ -2439,16 +2441,18 @@ SIMP_TAC std_ss [HOARE_TRIPLE_def, fasl_order_THM, ASL_IS_LOCAL_ACTION_def, ASL_IS_SEPARATE_def, IS_SOME_EXISTS, GSYM LEFT_FORALL_IMP_THM] THEN REPEAT STRIP_TAC THEN EQ_TAC THEN REPEAT STRIP_TAC THENL [ FULL_SIMP_TAC std_ss [asl_star_def, IN_ABS, SUBSET_DEF] THEN + lcsymtacs.qcase_tac `SOME s = f (SOME p) (SOME q)` THEN `fasl_order (a s) (fasl_star f (a p) (SOME {q}))` by METIS_TAC[] THEN `?p'. (a p = SOME p') /\ !x. x IN p' ==> x IN Q` by METIS_TAC[] THEN FULL_SIMP_TAC std_ss [fasl_star_REWRITE, fasl_order_THM, asl_star_def, IN_SING, IN_ABS, SUBSET_DEF] THEN METIS_TAC[], - Cases_on `a s1` THEN ( - ASM_SIMP_TAC std_ss [fasl_star_REWRITE, fasl_order_THM] - ) THEN - Q.PAT_ASSUM `!P Q. X P Q` (MP_TAC o Q.SPECL [`{s1}`, `x`]) THEN + lcsymtacs.qcase_tac `f (SOME s1) (SOME s2) = SOME y` THEN + Cases_on `a s1` THEN + ASM_SIMP_TAC std_ss [fasl_star_REWRITE, fasl_order_THM] THEN + lcsymtacs.qcase_tac `a s1 = SOME xx` THEN + Q.PAT_ASSUM `!P Q. X P Q` (MP_TAC o Q.SPECL [`{s1}`, `xx`]) THEN ASM_SIMP_TAC std_ss [IN_SING, SUBSET_REFL, asl_star_def, IN_ABS, SUBSET_DEF] THEN SIMP_TAC std_ss [GSYM LEFT_EXISTS_IMP_THM] THEN @@ -2865,12 +2869,13 @@ SIMP_TAC std_ss [IS_NON_EMPTY_COMPLETE_LATTICE_def, val best_local_action_def = Define ` best_local_action f P1 P2 s = let set = \p. ?s0 s1. ((SOME s) = f (SOME s0) (SOME s1)) /\ (s1 IN P1) /\ (p = fasl_star f (SOME P2) (SOME {s0})) in - INF_fasl_order set` + INF_fasl_order set`; -val best_local_action_IS_LOCAL = store_thm ("best_local_action_IS_LOCAL", -``!f P1 P2. -IS_SEPARATION_COMBINATOR f ==> -ASL_IS_LOCAL_ACTION f (best_local_action f P1 P2)``, +val best_local_action_IS_LOCAL = store_thm ( + "best_local_action_IS_LOCAL", + ``!f P1 P2. + IS_SEPARATION_COMBINATOR f ==> + ASL_IS_LOCAL_ACTION f (best_local_action f P1 P2)``, ONCE_REWRITE_TAC [IS_SEPARATION_COMBINATOR_EXPAND_THM] THEN SIMP_TAC std_ss [ASL_IS_LOCAL_ACTION_def, ASL_IS_SEPARATE_def, @@ -2879,6 +2884,7 @@ SIMP_TAC std_ss [ASL_IS_LOCAL_ACTION_def, ASL_IS_SEPARATE_def, fasl_star_def, BIN_OPTION_MAP_ALL_DEF_THM, INF_fasl_order_def] THEN REPEAT STRIP_TAC THEN +lcsymtacs.qcase_tac `f (SOME s1) (SOME s2) = SOME y` THEN Cases_on `!s0 s1'. ~(SOME y = f (SOME s0) (SOME s1')) \/ ~(s1' IN P1)` THENL [ ASM_SIMP_TAC std_ss [COND_RAND, COND_RATOR, fasl_order_THM, BIN_OPTION_MAP_ALL_DEF_THM] THEN @@ -2948,8 +2954,6 @@ Cases_on `!s0 s1'. ~(SOME y = f (SOME s0) (SOME s1')) \/ ~(s1' IN P1)` THENL [ ] ]); - - val best_local_action_SPEC = store_thm ("best_local_action_SPEC", ``!f P1 P2. IS_SEPARATION_COMBINATOR f ==> @@ -5043,15 +5047,16 @@ METIS_TAC[COMM_DEF]); -val ASL_TRACE_SEM___PARALLEL_DECOMPOSITION = store_thm ("ASL_TRACE_SEM___PARALLEL_DECOMPOSITION", -``!f lock_env q1 q2 s s1 s2 t1 t2 t . -(IS_SEPARATION_COMBINATOR f /\ -fasl_order (ASL_TRACE_SEM (f, lock_env) t1 s1) q1 /\ -fasl_order (ASL_TRACE_SEM (f, lock_env) t2 s2) q2 /\ -(t IN (ASL_TRACE_ZIP t1 t2)) /\ -(SOME s = f (SOME s1) (SOME s2))) ==> +val ASL_TRACE_SEM___PARALLEL_DECOMPOSITION = store_thm ( + "ASL_TRACE_SEM___PARALLEL_DECOMPOSITION", + ``!f lock_env q1 q2 s s1 s2 t1 t2 t . + (IS_SEPARATION_COMBINATOR f /\ + fasl_order (ASL_TRACE_SEM (f, lock_env) t1 s1) q1 /\ + fasl_order (ASL_TRACE_SEM (f, lock_env) t2 s2) q2 /\ + (t IN (ASL_TRACE_ZIP t1 t2)) /\ + (SOME s = f (SOME s1) (SOME s2))) ==> -fasl_order (ASL_TRACE_SEM (f, lock_env) t s) (fasl_star f q1 q2)``, + fasl_order (ASL_TRACE_SEM (f, lock_env) t s) (fasl_star f q1 q2)``, NTAC 2 GEN_TAC THEN @@ -5265,6 +5270,8 @@ SIMP_TAC std_ss [fasl_star_REWRITE, fasl_order_THM, asl_star_def, `f (SOME s2) (SOME s1) = f (SOME s1) (SOME s2)` by METIS_TAC[IS_SEPARATION_COMBINATOR_def, COMM_DEF] THEN ASM_SIMP_TAC std_ss [GSYM LEFT_FORALL_IMP_THM] THEN REPEAT STRIP_TAC THEN + lcsymtacs.qcase_tac `la1 s = SOME y` THEN + lcsymtacs.qcase_tac `x IN y` THEN Q.PAT_ASSUM `!s1 s2 s3 y. P s1 s2 s3 y` ( MP_TAC o Q.SPECL [`s2`, `s1`, `s`, `vq3`, `y`, `x`]) THEN ASM_SIMP_TAC std_ss [GSYM LEFT_FORALL_IMP_THM] THEN diff --git a/examples/separationLogic/src/vars_as_resourceScript.sml b/examples/separationLogic/src/vars_as_resourceScript.sml index fa1d983fc2..1806a15b1e 100644 --- a/examples/separationLogic/src/vars_as_resourceScript.sml +++ b/examples/separationLogic/src/vars_as_resourceScript.sml @@ -12615,13 +12615,15 @@ FULL_SIMP_TAC std_ss [ASL_PROGRAM_SEM___prog_repeat___asla_repeat, IS_SOME_EXIST SIMP_TAC std_ss [SOME___asla_seq, GSYM LEFT_FORALL_IMP_THM, IN_BIGUNION, IN_IMAGE, GSYM RIGHT_EXISTS_AND_THM] THEN CONJ_TAC THEN1 ( - Q.EXISTS_TAC `y` THEN METIS_TAC[option_CLAUSES] ) THEN REPEAT GEN_TAC THEN STRIP_TAC THEN GEN_TAC THEN STRIP_TAC THEN -`x'' IN P /\ VAR_RES_STACK___IS_EQUAL_UPTO_VALUES (FST x) (FST x'')` by METIS_TAC[] THEN -Q.PAT_ASSUM `!x. x IN P ==> X x` (MP_TAC o Q.SPEC `x''`) THEN +lcsymtacs.qcase_tac `asla_report _ n x = SOME s1` THEN +lcsymtacs.qcase_tac `yy IN s1` THEN +`yy IN P /\ VAR_RES_STACK___IS_EQUAL_UPTO_VALUES (FST x) (FST yy)` + by METIS_TAC[] THEN +Q.PAT_ASSUM `!x. x IN P ==> X x` (MP_TAC o Q.SPEC `yy`) THEN ASM_REWRITE_TAC[] THEN STRIP_TAC THEN FULL_SIMP_TAC std_ss [] THEN METIS_TAC[VAR_RES_STACK___IS_EQUAL_UPTO_VALUES___TRANS]); @@ -13177,12 +13179,12 @@ ASM_SIMP_TAC list_ss []); val ASL_INTUITIONISTIC_NEGATION___weak_prop_expression = store_thm ("ASL_INTUITIONISTIC_NEGATION___weak_prop_expression", ``!el f s p. -(IS_SEPARATION_COMBINATOR f /\ - EVERY (VAR_RES_IS_STACK_IMPRECISE_EXPRESSION___USED_VARS_SUBSET (FDOM (FST s))) el) ==> + (IS_SEPARATION_COMBINATOR f /\ + EVERY (VAR_RES_IS_STACK_IMPRECISE_EXPRESSION___USED_VARS_SUBSET (FDOM (FST s))) el) ==> -(ASL_INTUITIONISTIC_NEGATION (VAR_RES_COMBINATOR f) - (var_res_prop_weak_expression p el) s = -(var_res_prop_weak_expression (\l. ~(p l)) el) s)``, + (ASL_INTUITIONISTIC_NEGATION (VAR_RES_COMBINATOR f) + (var_res_prop_weak_expression p el) s = + (var_res_prop_weak_expression (\l. ~(p l)) el) s)``, SIMP_TAC std_ss [ASL_INTUITIONISTIC_NEGATION_def, EXTENSION, @@ -13209,8 +13211,10 @@ EQ_TAC THENL [ REPEAT (GEN_TAC ORELSE DISCH_TAC) THEN - Tactical.REVERSE (`MAP (\e. e (FST y)) el = - MAP (\e. e (FST s)) el` by ALL_TAC) THEN1 ( + lcsymtacs.qcase_tac + `VAR_RES_COMBINATOR f (SOME ss1) (SOME ss2) = SOME xx` THEN + Tactical.REVERSE (`MAP (\e. e (FST xx)) el = + MAP (\e. e (FST ss1)) el` by ALL_TAC) THEN1 ( ASM_REWRITE_TAC[] ) THEN FULL_SIMP_TAC std_ss [VAR_RES_IS_STACK_IMPRECISE_EXPRESSION___USED_VARS_SUBSET_def, From f9053c22028649f29395bc31d0a7afae982fac75 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 9 Oct 2015 16:03:21 +1100 Subject: [PATCH 549/718] Next release will be Kananaskis-11 This commit starts release preparation branch. --- Manual/LaTeX/commands.tex | 4 ++-- doc/{next-release.md => kananaskis-11.release.md} | 6 +++--- tools-poly/configure.sml | 2 +- tools/configure.sml | 2 +- 4 files changed, 7 insertions(+), 7 deletions(-) rename doc/{next-release.md => kananaskis-11.release.md} (98%) diff --git a/Manual/LaTeX/commands.tex b/Manual/LaTeX/commands.tex index f43cc2de61..ed2a9f0b5f 100644 --- a/Manual/LaTeX/commands.tex +++ b/Manual/LaTeX/commands.tex @@ -34,8 +34,8 @@ % macro names is a bit of a pain; deciding to do away % with hol98 nomenclature means that we just want to % write HOL for hol98. -\def\holnversion{Kananaskis-10} -\def\holnsversion{Kananaskis~10} % version with space rather than hyphen +\def\holnversion{Kananaskis-11} +\def\holnsversion{Kananaskis~11} % version with space rather than hyphen \def\LCF{{\small LCF}} \def\LCFLSM{{\small LCF{\kern-.2em}{\normalsize\_}{\kern0.1em}LSM}} \def\PPL{{\small PP}{\kern-.095em}$\lambda$} diff --git a/doc/next-release.md b/doc/kananaskis-11.release.md similarity index 98% rename from doc/next-release.md rename to doc/kananaskis-11.release.md index f6ecb8f24b..1ccc9bae07 100644 --- a/doc/next-release.md +++ b/doc/kananaskis-11.release.md @@ -1,11 +1,11 @@ -% Release notes for HOL4, ?????? +% Release notes for HOL4, Kananaskis-11 (Released: ??????) -We are pleased to announce the ?????? release of HOL 4. +We are pleased to announce the Kananaskis-11 release of HOL 4. Contents -------- @@ -116,7 +116,7 @@ Incompatibilities: * * * * *
-*[HOL4, ??????](http://hol.sourceforge.net)* +*[HOL4, Kananaskis-11](http://hol-theorem-prover.org)* [Release notes for the previous version](kananaskis-10.release.html) diff --git a/tools-poly/configure.sml b/tools-poly/configure.sml index 04210c6d7d..7f7ce49e8c 100644 --- a/tools-poly/configure.sml +++ b/tools-poly/configure.sml @@ -107,7 +107,7 @@ fun liftstatus f x = END user-settable parameters ---------------------------------------------------------------------------*) -val version_number = 10 +val version_number = 11 val release_string = "Kananaskis" (* diff --git a/tools/configure.sml b/tools/configure.sml index 18752f4b77..25080ae4d0 100644 --- a/tools/configure.sml +++ b/tools/configure.sml @@ -49,7 +49,7 @@ val DEPDIR:string = ".HOLMK"; (* where Holmake dependencies kept *) END user-settable parameters ---------------------------------------------------------------------------*) -val version_number = 10 +val version_number = 11 val release_string = "Kananaskis" From c1b43bda91b3c147d0f6528f5cf0ff80dec81903 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 21 Oct 2015 10:24:08 +1100 Subject: [PATCH 550/718] Tweak unicode-grep - more portable through use of character classes rather than Perl regexps (backslashed characters inside [..]) - allow presence of UOK on line with Unicode to suppress warning --- developers/unicode-grep | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/developers/unicode-grep b/developers/unicode-grep index b68cc25420..63f4b0dc15 100755 --- a/developers/unicode-grep +++ b/developers/unicode-grep @@ -4,4 +4,4 @@ # As of 18 Feb 2014, sources include some Unicode in comments. -grep -R --color=auto -P -n "[\x80-\xFF]" --include=*.sml --exclude=*Theory.sml --exclude=*Theory.sig --exclude selftest.sml --exclude EmitTeX.sml "$(dirname $0)/../src/" +LC_ALL=C grep -R -n -v -E '^[[:print:][:space:]]*$|UOK' --include=*.sml --exclude=*Theory.sml --exclude=*Theory.sig --exclude selftest.sml --exclude EmitTeX.sml "$(dirname $0)/../src/" From fda6dec35881742a7e750de74dc1c842d2ca4e14 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 21 Oct 2015 11:01:30 +1100 Subject: [PATCH 551/718] Clean src/ to remove Unicode (or to mark it as OK) Marking Unicode as OK is done by putting the UOK tag on the same line of the relevant file. --- src/1/Drule.sml | 6 +- src/HolQbf/QbfCertificate.sml | 2 +- src/TeX/theory_tests/bag248Script.sml | 2 +- src/TeX/theory_tests/foo248Script.sml | 2 +- src/TeX/theory_tests/pp248Script.sml | 2 +- src/bag/bagScript.sml | 2 +- src/bag/containerScript.sml | 16 +- src/enumfset/comparisonScript.sml | 154 +++++++++--------- src/holyhammer/examples/example.sml | 10 +- src/list/src/listScript.sml | 8 +- src/list/src/rich_listScript.sml | 23 +-- src/llist/llistScript.sml | 68 ++++---- src/n-bit/alignmentScript.sml | 2 +- src/num/theories/arithmeticScript.sml | 8 +- src/option/optionScript.sml | 2 +- src/patricia/sptreeScript.sml | 42 ++--- .../examples/ext_finite_setScript.sml | 2 +- src/rational/fracLib.sml | 4 +- src/sort/sortingScript.sml | 18 +- src/temporal/src/temporalLib.sml | 103 ++++++------ src/tfl/src/RW.sml | 6 +- 21 files changed, 246 insertions(+), 236 deletions(-) diff --git a/src/1/Drule.sml b/src/1/Drule.sml index e822933410..b97c0eecee 100644 --- a/src/1/Drule.sml +++ b/src/1/Drule.sml @@ -1220,11 +1220,11 @@ fun INST_TT_HYPS subs th = val thd = DISCH_ALL th ; val thdsub = INST_TY_TERM subs thd ; (* UNDISCH_TM nhyps times only *) - fun UNDISCH_TM_L (th, tms) = + fun UNDISCH_TM_L (th, tms) = let val (tm, th') = UNDISCH_TM th ; in (th', tm :: tms) end ; in Lib.funpow nhyps UNDISCH_TM_L (thdsub, []) end ; - + (*---------------------------------------------------------------------------* * |- !x y z. w ---> |- w[g1/x][g2/y][g3/z] * *---------------------------------------------------------------------------*) @@ -1272,7 +1272,7 @@ fun PART_MATCH_A partfn th = [x = y, y = z] |- x = z (eg) -------------------------------- EXISTS_LEFT1 ``y`` - [∃y. (x = y) ∧ (y = z)] |- x = z + [∃y. (x = y) ∧ (y = z)] |- x = z (UOK) * --------------------------------------------------------------------------*) diff --git a/src/HolQbf/QbfCertificate.sml b/src/HolQbf/QbfCertificate.sml index a74157ade2..afa468a40b 100644 --- a/src/HolQbf/QbfCertificate.sml +++ b/src/HolQbf/QbfCertificate.sml @@ -7,7 +7,7 @@ http://www.cprover.org/qbv/download/qbcformat.pdf). Also see "A First Step Towards a Unified Proof Checker for QBF" by Toni - Jussila, Armin Biere, Carsten Sinz, Daniel Kröning and Christoph + Jussila, Armin Biere, Carsten Sinz, Daniel Kröning and Christoph (UOK) Wintersteiger, published at SAT 2007 (vol. 4501 of LNCS). We additionally require that certificates of validity contain "extensions" diff --git a/src/TeX/theory_tests/bag248Script.sml b/src/TeX/theory_tests/bag248Script.sml index 3b2972fd68..d4ab077d70 100644 --- a/src/TeX/theory_tests/bag248Script.sml +++ b/src/TeX/theory_tests/bag248Script.sml @@ -9,7 +9,7 @@ val BAG_IN = new_definition ( val _ = set_fixity "<:" (Infix(NONASSOC, 425)) val _ = overload_on ("<:", ``BAG_IN``) val _ = Unicode.unicode_version {tmnm = "<:", u = UTF8.chr 0x22F2} - (* U+22F2 looks like ⋲ in your current font; unfortunately this + (* U+22F2 looks like ⋲ in your current font; unfortunately this (* UOK *) symbol doesn't seem to correspond to anything in LaTeX... *) val _ = TeX_notation {hol = "<:", TeX = ("\\HOLTokenIn{}:",2)} val _ = TeX_notation {hol = UTF8.chr 0x22F2, TeX = ("\\HOLTokenIn{}:",2)} diff --git a/src/TeX/theory_tests/foo248Script.sml b/src/TeX/theory_tests/foo248Script.sml index 391e61ca34..74f9fb50ce 100644 --- a/src/TeX/theory_tests/foo248Script.sml +++ b/src/TeX/theory_tests/foo248Script.sml @@ -1,5 +1,5 @@ open HolKernel boolLib bossLib Parse val _ = new_theory"foo248" val _ = Define`foo a b = a < b` -val _ = overload_on("<:",``λa b. foo b a``) +val _ = overload_on("<:",``\a b. foo b a``) val _ = export_theory() diff --git a/src/TeX/theory_tests/pp248Script.sml b/src/TeX/theory_tests/pp248Script.sml index d421047f7e..f0ad016710 100644 --- a/src/TeX/theory_tests/pp248Script.sml +++ b/src/TeX/theory_tests/pp248Script.sml @@ -1,5 +1,5 @@ open HolKernel boolLib foo248Theory bag248Theory val _ = new_theory"pp248" val _ = TeX_notation{hol="<:", TeX=("\\ensuremath{\\le}",1)} -val _ = TeX_notation{hol="⋲", TeX=("\\ensuremath{\\lessdot}",1)} +val _ = TeX_notation{hol="⋲", TeX=("\\ensuremath{\\lessdot}",1)} (* UOK *) val _ = export_theory() diff --git a/src/bag/bagScript.sml b/src/bag/bagScript.sml index 8928085a30..6cd39193b9 100644 --- a/src/bag/bagScript.sml +++ b/src/bag/bagScript.sml @@ -44,7 +44,7 @@ val BAG_IN = new_definition ( val _ = set_fixity "<:" (Infix(NONASSOC, 425)) val _ = overload_on ("<:", ``BAG_IN``) val _ = Unicode.unicode_version {tmnm = "<:", u = UTF8.chr 0x22F2} - (* U+22F2 looks like ⋲ in your current font; unfortunately this + (* U+22F2 looks like ⋲ in your current font; unfortunately this (UOK) symbol doesn't seem to correspond to anything in LaTeX... *) val _ = TeX_notation {hol = "<:", TeX = ("\\HOLTokenIn{}:",2)} val _ = TeX_notation {hol = UTF8.chr 0x22F2, TeX = ("\\HOLTokenIn{}:",2)} diff --git a/src/bag/containerScript.sml b/src/bag/containerScript.sml index ada1bb698c..c6f7f0b1b3 100644 --- a/src/bag/containerScript.sml +++ b/src/bag/containerScript.sml @@ -166,7 +166,7 @@ Induct_on `l` THENL [ val LIST_TO_BAG_DISTINCT = store_thm ("LIST_TO_BAG_DISTINCT", ``BAG_ALL_DISTINCT (LIST_TO_BAG b) = ALL_DISTINCT b``, - Induct_on `b` THEN + Induct_on `b` THEN ASM_SIMP_TAC (srw_ss ()) [LIST_TO_BAG_def, IN_LIST_TO_BAG]) ; val LIST_TO_BAG_EQ_EMPTY = store_thm ("LIST_TO_BAG_EQ_EMPTY", @@ -194,7 +194,7 @@ val EQ_TRANS' = REWRITE_RULE [GSYM AND_IMP_INTRO] EQ_TRANS ; val th = MATCH_MP EQ_TRANS' (SYM CARD_LIST_TO_BAG) ; val BAG_TO_LIST_CARD = store_thm ("BAG_TO_LIST_CARD", - ``!b. FINITE_BAG b ⇒ (LENGTH (BAG_TO_LIST b) = BAG_CARD b)``, + ``!b. FINITE_BAG b ==> (LENGTH (BAG_TO_LIST b) = BAG_CARD b)``, EVERY [REPEAT STRIP_TAC, irule th, ASM_SIMP_TAC bool_ss [BAG_TO_LIST_INV] ]) ; @@ -221,11 +221,11 @@ end (* the head of the list is replaced by a list of smaller elements. *) (*---------------------------------------------------------------------------*) -val mlt_list_def = +val mlt_list_def = Define - `mlt_list R = + `mlt_list R = \l1 l2. - ?h t list. + ?h t list. (l1 = list ++ t) /\ (l2 = h::t) /\ (!e. MEM e list ==> R e h)`; @@ -237,12 +237,12 @@ val WF_mlt_list = Q.store_thm Q.EXISTS_TAC `inv_image (mlt1 R) LIST_TO_BAG` THEN CONJ_TAC THENL [METIS_TAC [relationTheory.WF_inv_image,bagTheory.WF_mlt1], - RW_TAC list_ss [mlt_list_def, relationTheory.inv_image_thm,bagTheory.mlt1_def] + RW_TAC list_ss [mlt_list_def, relationTheory.inv_image_thm,bagTheory.mlt1_def] THENL [METIS_TAC [FINITE_LIST_TO_BAG], METIS_TAC [FINITE_LIST_TO_BAG], - MAP_EVERY Q.EXISTS_TAC [`h`, `LIST_TO_BAG list`, `LIST_TO_BAG t`] - THEN RW_TAC std_ss [BAG_INSERT_UNION,LIST_TO_BAG_APPEND,LIST_TO_BAG_def] + MAP_EVERY Q.EXISTS_TAC [`h`, `LIST_TO_BAG list`, `LIST_TO_BAG t`] + THEN RW_TAC std_ss [BAG_INSERT_UNION,LIST_TO_BAG_APPEND,LIST_TO_BAG_def] THENL [METIS_TAC [COMM_BAG_UNION,ASSOC_BAG_UNION,BAG_UNION_EMPTY], METIS_TAC [IN_LIST_TO_BAG]]]]); diff --git a/src/enumfset/comparisonScript.sml b/src/enumfset/comparisonScript.sml index ddce77dc66..607086490b 100644 --- a/src/enumfset/comparisonScript.sml +++ b/src/enumfset/comparisonScript.sml @@ -15,44 +15,44 @@ val _ = Parse.overload_on("Equal",``EQUAL``) val _ = Parse.overload_on("Greater",``GREATER``) val good_cmp_def = Define ` -good_cmp cmp ⇔ - (!x. cmp x x = Equal) ∧ - (!x y. cmp x y = Equal ⇒ cmp y x = Equal) ∧ - (!x y. cmp x y = Greater ⇔ cmp y x = Less) ∧ - (!x y z. cmp x y = Equal ∧ cmp y z = Less ⇒ cmp x z = Less) ∧ - (!x y z. cmp x y = Less ∧ cmp y z = Equal ⇒ cmp x z = Less) ∧ - (!x y z. cmp x y = Equal ∧ cmp y z = Equal ⇒ cmp x z = Equal) ∧ - (!x y z. cmp x y = Less ∧ cmp y z = Less ⇒ cmp x z = Less)`; +good_cmp cmp <=> + (!x. cmp x x = Equal) /\ + (!x y. cmp x y = Equal ==> cmp y x = Equal) /\ + (!x y. cmp x y = Greater <=> cmp y x = Less) /\ + (!x y z. cmp x y = Equal /\ cmp y z = Less ==> cmp x z = Less) /\ + (!x y z. cmp x y = Less /\ cmp y z = Equal ==> cmp x z = Less) /\ + (!x y z. cmp x y = Equal /\ cmp y z = Equal ==> cmp x z = Equal) /\ + (!x y z. cmp x y = Less /\ cmp y z = Less ==> cmp x z = Less)`; val good_cmp_thm = Q.store_thm ("good_cmp_thm", `!cmp. - good_cmp cmp ⇔ - (!x. cmp x x = Equal) ∧ + good_cmp cmp <=> + (!x. cmp x x = Equal) /\ (!x y z. - (cmp x y = Greater ⇔ cmp y x = Less) ∧ - (cmp x y = Less ∧ cmp y z = Equal ⇒ cmp x z = Less) ∧ - (cmp x y = Less ∧ cmp y z = Less ⇒ cmp x z = Less))`, + (cmp x y = Greater <=> cmp y x = Less) /\ + (cmp x y = Less /\ cmp y z = Equal ==> cmp x z = Less) /\ + (cmp x y = Less /\ cmp y z = Less ==> cmp x z = Less))`, rw [good_cmp_def] >> metis_tac [comparison_distinct, comparison_nchotomy]); val cmp_thms = save_thm ("cmp_thms", LIST_CONJ [comparison_distinct, comparison_case_def, comparison_nchotomy, good_cmp_def]) val option_cmp_def = Define ` -(option_cmp cmp NONE NONE = Equal) ∧ -(option_cmp cmp NONE (SOME x) = Less) ∧ -(option_cmp cmp (SOME x) NONE = Greater) ∧ +(option_cmp cmp NONE NONE = Equal) /\ +(option_cmp cmp NONE (SOME x) = Less) /\ +(option_cmp cmp (SOME x) NONE = Greater) /\ (option_cmp cmp (SOME x) (SOME y) = cmp x y)`; val option_cmp2_def = Define` - (option_cmp2 cmp NONE NONE = Equal) ∧ - (option_cmp2 cmp NONE (SOME x) = Greater) ∧ - (option_cmp2 cmp (SOME x) NONE = Less) ∧ + (option_cmp2 cmp NONE NONE = Equal) /\ + (option_cmp2 cmp NONE (SOME x) = Greater) /\ + (option_cmp2 cmp (SOME x) NONE = Less) /\ (option_cmp2 cmp (SOME x) (SOME y) = cmp x y)` val list_cmp_def = Define` -(list_cmp cmp [] [] = Equal) ∧ -(list_cmp cmp [] (x::y) = Less) ∧ -(list_cmp cmp (x::y) [] = Greater) ∧ +(list_cmp cmp [] [] = Equal) /\ +(list_cmp cmp [] (x::y) = Less) /\ +(list_cmp cmp (x::y) [] = Greater) /\ (list_cmp cmp (x1::y1) (x2::y2) = case cmp x1 x2 of | Equal => list_cmp cmp y1 y2 @@ -69,9 +69,9 @@ pair_cmp cmp1 cmp2 x y = | Greater => Greater`; val bool_cmp_def = Define ` -(bool_cmp T T = Equal) ∧ -(bool_cmp F F = Equal) ∧ -(bool_cmp T F = Greater) ∧ +(bool_cmp T T = Equal) /\ +(bool_cmp F F = Equal) /\ +(bool_cmp T F = Greater) /\ (bool_cmp F T = Less)`; val num_cmp_def = Define ` @@ -92,34 +92,34 @@ string_cmp = list_cmp char_cmp`; (* relationship to toto *) val TotOrd_imp_good_cmp = store_thm("TotOrder_imp_good_cmp", - ``∀cmp. TotOrd cmp ⇒ good_cmp cmp``, + ``!cmp. TotOrd cmp ==> good_cmp cmp``, rw[TotOrd,good_cmp_thm] >> metis_tac[]) val invert_def = Define` - invert GREATER = LESS ∧ - invert LESS = GREATER ∧ + invert GREATER = LESS /\ + invert LESS = GREATER /\ invert EQUAL = EQUAL` val _ = export_rewrites["invert_def"] val invert_eq_EQUAL = store_thm("invert_eq_EQUAL[simp]", - ``∀x. invert x = EQUAL ⇔ x = EQUAL``, + ``!x. invert x = EQUAL <=> x = EQUAL``, Cases >> simp[]) val TO_inv_invert = store_thm("TO_inv_invert", - ``∀c. TotOrd c ⇒ TO_inv c = CURRY (invert o UNCURRY c)``, + ``!c. TotOrd c ==> TO_inv c = CURRY (invert o UNCURRY c)``, simp[FUN_EQ_THM,TO_inv] >> gen_tac >> strip_tac >> map_every qx_gen_tac[`x`,`y`] >> Cases_on`c x y`>>simp[]>> fs[TotOrd] >> metis_tac[]) val option_cmp2_TO_inv = store_thm("option_cmp2_TO_inv", - ``∀c. option_cmp2 c = TO_inv (option_cmp (TO_inv c))``, + ``!c. option_cmp2 c = TO_inv (option_cmp (TO_inv c))``, simp[FUN_EQ_THM,TO_inv] >> gen_tac >> Cases >> Cases >> simp[option_cmp2_def,option_cmp_def,TO_inv]); val list_cmp_ListOrd = store_thm("list_cmp_ListOrd", - ``∀c. TotOrd c ⇒ list_cmp c = ListOrd (TO c)``, + ``!c. TotOrd c ==> list_cmp c = ListOrd (TO c)``, simp[FUN_EQ_THM,PULL_FORALL] >> ho_match_mp_tac list_cmp_ind >> simp[list_cmp_def,ListOrd,TO_of_LinearOrder, @@ -130,7 +130,7 @@ val list_cmp_ListOrd = store_thm("list_cmp_ListOrd", metis_tac[cmp_thms]) val pair_cmp_lexTO = store_thm("pair_cmp_lexTO", - ``∀R V. TotOrd R ∧ TotOrd V ⇒ pair_cmp R V = R lexTO V``, + ``!R V. TotOrd R /\ TotOrd V ==> pair_cmp R V = R lexTO V``, simp[FUN_EQ_THM,lexTO_thm,pair_cmp_def]) val num_cmp_numOrd = store_thm("num_cmp_numOrd", @@ -156,7 +156,7 @@ val string_cmp_stringto = store_thm("string_cmp_stringto", (* cmps are good *) val option_cmp_good = Q.store_thm ("option_cmp_good", -`!cmp. good_cmp cmp ⇒ good_cmp (option_cmp cmp)`, +`!cmp. good_cmp cmp ==> good_cmp (option_cmp cmp)`, rw [good_cmp_def] >> Cases_on `x` >> TRY (Cases_on `y`) >> @@ -164,7 +164,7 @@ val option_cmp_good = Q.store_thm ("option_cmp_good", metis_tac [option_cmp_def, comparison_distinct]); val option_cmp2_good = Q.store_thm ("option_cmp2_good", -`!cmp. good_cmp cmp ⇒ good_cmp (option_cmp2 cmp)`, +`!cmp. good_cmp cmp ==> good_cmp (option_cmp2 cmp)`, rw [good_cmp_def] >> Cases_on `x` >> TRY (Cases_on `y`) >> @@ -172,7 +172,7 @@ val option_cmp2_good = Q.store_thm ("option_cmp2_good", metis_tac [option_cmp2_def, comparison_distinct]); val list_cmp_good = Q.store_thm ("list_cmp_good", -`!cmp. good_cmp cmp ⇒ good_cmp (list_cmp cmp)`, +`!cmp. good_cmp cmp ==> good_cmp (list_cmp cmp)`, simp [good_cmp_def] >> rpt gen_tac >> strip_tac >> @@ -186,7 +186,7 @@ val list_cmp_good = Q.store_thm ("list_cmp_good", metis_tac [list_cmp_def, comparison_distinct, comparison_case_def, comparison_nchotomy]); val pair_cmp_good = Q.store_thm ("pair_cmp_good", -`!cmp1 cmp2. good_cmp cmp1 ∧ good_cmp cmp2 ⇒ good_cmp (pair_cmp cmp1 cmp2)`, +`!cmp1 cmp2. good_cmp cmp1 /\ good_cmp cmp2 ==> good_cmp (pair_cmp cmp1 cmp2)`, simp [good_cmp_def] >> rpt gen_tac >> strip_tac >> @@ -238,10 +238,10 @@ val string_cmp_good = Q.store_thm ("string_cmp_good[simp]", val list_cmp_cong = Q.store_thm ("list_cmp_cong", `!cmp l1 l2 cmp' l1' l2'. - (l1 = l1') ∧ - (l2 = l2') ∧ - (!x x'. MEM x l1' ∧ MEM x' l2' ⇒ cmp x x' = cmp' x x') - ⇒ + (l1 = l1') /\ + (l2 = l2') /\ + (!x x'. MEM x l1' /\ MEM x' l2' ==> cmp x x' = cmp' x x') + ==> list_cmp cmp l1 l2 = list_cmp cmp' l1' l2'`, ho_match_mp_tac list_cmp_ind >> rw [list_cmp_def] >> @@ -251,10 +251,10 @@ val list_cmp_cong = Q.store_thm ("list_cmp_cong", val option_cmp_cong = Q.store_thm ("option_cmp_cong", `!cmp v1 v2 cmp' v1' v2'. - (v1 = v1') ∧ - (v2 = v2') ∧ - (!x x'. v1' = SOME x ∧ v2' = SOME x' ⇒ cmp x x' = cmp' x x') - ⇒ + (v1 = v1') /\ + (v2 = v2') /\ + (!x x'. v1' = SOME x /\ v2' = SOME x' ==> cmp x x' = cmp' x x') + ==> option_cmp cmp v1 v2 = option_cmp cmp' v1' v2'`, ho_match_mp_tac (fetch "-" "option_cmp_ind") >> rw [option_cmp_def] >> @@ -262,10 +262,10 @@ val option_cmp_cong = Q.store_thm ("option_cmp_cong", val option_cmp2_cong = Q.store_thm ("option_cmp2_cong", `!cmp v1 v2 cmp' v1' v2'. - (v1 = v1') ∧ - (v2 = v2') ∧ - (!x x'. v1' = SOME x ∧ v2' = SOME x' ⇒ cmp x x' = cmp' x x') - ⇒ + (v1 = v1') /\ + (v2 = v2') /\ + (!x x'. v1' = SOME x /\ v2' = SOME x' ==> cmp x x' = cmp' x x') + ==> option_cmp2 cmp v1 v2 = option_cmp2 cmp' v1' v2'`, ho_match_mp_tac (fetch "-" "option_cmp2_ind") >> rw [option_cmp2_def] >> @@ -273,11 +273,11 @@ val option_cmp2_cong = Q.store_thm ("option_cmp2_cong", val pair_cmp_cong = Q.store_thm ("pair_cmp_cong", `!cmp1 cmp2 v1 v2 cmp1' cmp2' v1' v2'. - (v1 = v1') ∧ - (v2 = v2') ∧ - (!a b c d. v1' = (a,b) ∧ v2' = (c,d) ⇒ cmp1 a c = cmp1' a c) ∧ - (!a b c d. v1' = (a,b) ∧ v2' = (c,d) ⇒ cmp2 b d = cmp2' b d) - ⇒ + (v1 = v1') /\ + (v2 = v2') /\ + (!a b c d. v1' = (a,b) /\ v2' = (c,d) ==> cmp1 a c = cmp1' a c) /\ + (!a b c d. v1' = (a,b) /\ v2' = (c,d) ==> cmp2 b d = cmp2' b d) + ==> pair_cmp cmp1 cmp2 v1 v2 = pair_cmp cmp1' cmp2' v1' v2'`, rw [pair_cmp_def] >> every_case_tac >> @@ -291,7 +291,7 @@ val _ = DefnBase.export_cong "option_cmp2_cong"; val _ = DefnBase.export_cong "pair_cmp_cong"; val good_cmp_trans = Q.store_thm ("good_cmp_trans", -`!cmp. good_cmp cmp ⇒ transitive (λ(k,v) (k',v'). cmp k k' = Less)`, +`!cmp. good_cmp cmp ==> transitive (\ (k,v) (k',v'). cmp k k' = Less)`, rw [relationTheory.transitive_def] >> Cases_on `x` >> Cases_on `y` >> @@ -300,23 +300,23 @@ val good_cmp_trans = Q.store_thm ("good_cmp_trans", metis_tac [cmp_thms]); val bool_cmp_antisym = Q.store_thm ("bool_cmp_antisym[simp]", -`!x y. bool_cmp x y = Equal ⇔ x = y`, +`!x y. bool_cmp x y = Equal <=> x = y`, rw [] >> Cases_on `x` >> Cases_on `y` >> rw [bool_cmp_def]); val num_cmp_antisym = Q.store_thm ("num_cmp_antisym[simp]", -`!x y. num_cmp x y = Equal ⇔ x = y`, +`!x y. num_cmp x y = Equal <=> x = y`, rw [num_cmp_def]); val char_cmp_antisym = Q.store_thm ("char_cmp_antisym[simp]", -`!x y. char_cmp x y = Equal ⇔ x = y`, +`!x y. char_cmp x y = Equal <=> x = y`, rw [char_cmp_def, num_cmp_antisym] >> rw [ORD_11]); val list_cmp_antisym = Q.store_thm ("list_cmp_antisym", -`!cmp x y. (!x y. cmp x y = Equal ⇔ x = y) ⇒ (list_cmp cmp x y = Equal ⇔ x = y)`, +`!cmp x y. (!x y. cmp x y = Equal <=> x = y) ==> (list_cmp cmp x y = Equal <=> x = y)`, ho_match_mp_tac list_cmp_ind >> rw [list_cmp_def] >> every_case_tac >> @@ -324,15 +324,15 @@ val list_cmp_antisym = Q.store_thm ("list_cmp_antisym", metis_tac [comparison_distinct]); val string_cmp_antisym = Q.store_thm ("string_cmp_antisym[simp]", -`!x y. string_cmp x y = Equal ⇔ x = y`, +`!x y. string_cmp x y = Equal <=> x = y`, metis_tac [string_cmp_def, char_cmp_antisym, list_cmp_antisym]); val pair_cmp_antisym = Q.store_thm ("pair_cmp_antisym", `!cmp1 cmp2 x y. - (!x y. cmp1 x y = Equal ⇔ x = y) ∧ - (!x y. cmp2 x y = Equal ⇔ x = y) - ⇒ - (pair_cmp cmp1 cmp2 x y = Equal ⇔ x = y)`, + (!x y. cmp1 x y = Equal <=> x = y) /\ + (!x y. cmp2 x y = Equal <=> x = y) + ==> + (pair_cmp cmp1 cmp2 x y = Equal <=> x = y)`, Cases_on `x` >> Cases_on `y` >> rw [pair_cmp_def] >> @@ -342,9 +342,9 @@ val pair_cmp_antisym = Q.store_thm ("pair_cmp_antisym", val option_cmp_antisym = Q.store_thm ("option_cmp_antisym", `!cmp x y. - (!x y. cmp x y = Equal ⇔ x = y) - ⇒ - (option_cmp cmp x y = Equal ⇔ x = y)`, + (!x y. cmp x y = Equal <=> x = y) + ==> + (option_cmp cmp x y = Equal <=> x = y)`, Cases_on `x` >> Cases_on `y` >> rw [option_cmp_def] >> @@ -354,9 +354,9 @@ val option_cmp_antisym = Q.store_thm ("option_cmp_antisym", val option_cmp2_antisym = Q.store_thm ("option_cmp2_antisym", `!cmp x y. - (!x y. cmp x y = Equal ⇔ x = y) - ⇒ - (option_cmp2 cmp x y = Equal ⇔ x = y)`, + (!x y. cmp x y = Equal <=> x = y) + ==> + (option_cmp2 cmp x y = Equal <=> x = y)`, Cases_on `x` >> Cases_on `y` >> rw [option_cmp2_def] >> @@ -365,25 +365,25 @@ val option_cmp2_antisym = Q.store_thm ("option_cmp2_antisym", metis_tac [comparison_distinct]); val resp_equiv_def = Define ` -resp_equiv cmp f ⇔ !k1 k2 v. cmp k1 k2 = Equal ⇒ f k1 v = f k2 v`; +resp_equiv cmp f <=> !k1 k2 v. cmp k1 k2 = Equal ==> f k1 v = f k2 v`; val resp_equiv2_def = Define ` -resp_equiv2 cmp cmp2 f ⇔ (!k1 k2. cmp k1 k2 = Equal ⇒ cmp2 (f k1) (f k2) = Equal)`; +resp_equiv2 cmp cmp2 f <=> (!k1 k2. cmp k1 k2 = Equal ==> cmp2 (f k1) (f k2) = Equal)`; val equiv_inj_def = Define ` -equiv_inj cmp cmp2 f ⇔ (!k1 k2. cmp2 (f k1) (f k2) = Equal ⇒ cmp k1 k2 = Equal)`; +equiv_inj cmp cmp2 f <=> (!k1 k2. cmp2 (f k1) (f k2) = Equal ==> cmp k1 k2 = Equal)`; val antisym_resp_equiv = Q.store_thm ("antisym_resp_equiv", `!cmp f. - (!x y. cmp x y = Equal ⇒ x = y) - ⇒ - resp_equiv cmp f ∧ !cmp2. good_cmp cmp2 ⇒ resp_equiv2 cmp cmp2 f`, + (!x y. cmp x y = Equal ==> x = y) + ==> + resp_equiv cmp f /\ !cmp2. good_cmp cmp2 ==> resp_equiv2 cmp cmp2 f`, rw [resp_equiv_def, resp_equiv2_def] >> metis_tac [cmp_thms]); val list_cmp_equal_list_rel = Q.store_thm ("list_cmp_equal_list_rel", `!cmp l1 l2. - list_cmp cmp l1 l2 = Equal ⇔ LIST_REL (\x y. cmp x y = Equal) l1 l2`, + list_cmp cmp l1 l2 = Equal <=> LIST_REL (\x y. cmp x y = Equal) l1 l2`, Induct_on `l1` >> rw [] >> Cases_on `l2` >> diff --git a/src/holyhammer/examples/example.sml b/src/holyhammer/examples/example.sml index 36a2ba904c..5eecdd5b8e 100644 --- a/src/holyhammer/examples/example.sml +++ b/src/holyhammer/examples/example.sml @@ -1,15 +1,15 @@ load "holyHammer"; open holyHammer; -(*-------------------------------------------------------------------------- +(*-------------------------------------------------------------------------- Example 1 -------------------------------------------------------------------------- *) -val cj = ``a ≤ b ⇒ (g ** (b − a) * g ** a = g ** b)`` (* hh [] cj; *) +val cj = ``a <= b ==> (g ** (b - a) * g ** a = g ** b)`` (* hh [] cj; *) val lemmas = [fetch "arithmetic" "SUB_ADD", fetch "arithmetic" "EXP_ADD"]; val th = save_thm ("EXP_NEG",METIS_PROVE (lemmas) cj); -(*-------------------------------------------------------------------------- +(*-------------------------------------------------------------------------- Example 2 -------------------------------------------------------------------------- *) @@ -24,7 +24,7 @@ val lemmas = [fetch "zerok" "BASE_DEF", fetch "numeral" "numeral_lte", fetch "arithmetic" "NUMERAL_DEF"]; val th = save_thm ("BASE_THM",METIS_PROVE ([th0,th1] @ lemmas) cj); -(*-------------------------------------------------------------------------- +(*-------------------------------------------------------------------------- Example 3 -------------------------------------------------------------------------- *) @@ -40,7 +40,7 @@ val lemmas = [fetch "real" "real_sub", fetch "real" "REAL_ADD_LID", fetch "complex" "complex_mul"]; val th = METIS_PROVE lemmas cj; -(*-------------------------------------------------------------------------- +(*-------------------------------------------------------------------------- Example 4 -------------------------------------------------------------------------- *) diff --git a/src/list/src/listScript.sml b/src/list/src/listScript.sml index 02e6521174..801d708a09 100644 --- a/src/list/src/listScript.sml +++ b/src/list/src/listScript.sml @@ -3526,11 +3526,13 @@ val LUPDATE_SOME_MAP = store_thm("LUPDATE_SOME_MAP", Cases_on `n` THEN fs [LUPDATE_def]); val ZIP_EQ_NIL = store_thm("ZIP_EQ_NIL", - ``∀l1 l2. (LENGTH l1 = LENGTH l2) ⇒ ((ZIP (l1,l2) = []) ⇔ ((l1 = []) ∧ (l2 = [])))``, - REPEAT GEN_TAC >> Cases_on`l1`>>rw[LENGTH_NIL_SYM,ZIP]>> Cases_on`l2`>>fs[ZIP]) + ``!l1 l2. (LENGTH l1 = LENGTH l2) ==> + ((ZIP (l1,l2) = []) <=> ((l1 = []) /\ (l2 = [])))``, + REPEAT GEN_TAC >> Cases_on`l1` >> rw[LENGTH_NIL_SYM,ZIP] >> Cases_on`l2` >> + fs[ZIP]) val LUPDATE_SAME = store_thm("LUPDATE_SAME", - ``∀n ls. n < LENGTH ls ⇒ (LUPDATE (EL n ls) n ls = ls)``, + ``!n ls. n < LENGTH ls ==> (LUPDATE (EL n ls) n ls = ls)``, rw[LIST_EQ_REWRITE,EL_LUPDATE]>>rw[]) end; diff --git a/src/list/src/rich_listScript.sml b/src/list/src/rich_listScript.sml index e352e82888..b2944195b9 100644 --- a/src/list/src/rich_listScript.sml +++ b/src/list/src/rich_listScript.sml @@ -2726,7 +2726,8 @@ val IS_PREFIX_APPEND3 = save_thm("IS_PREFIX_APPEND3", val _ = export_rewrites ["IS_PREFIX_APPEND3"] val prefixes_is_prefix_total = Q.store_thm("prefixes_is_prefix_total", - `∀l. ∀l1 l2. IS_PREFIX l l1 ∧ IS_PREFIX l l2 ⇒ IS_PREFIX l2 l1 ∨ IS_PREFIX l1 l2`, + `!l l1 l2. + IS_PREFIX l l1 /\ IS_PREFIX l l2 ==> IS_PREFIX l2 l1 \/ IS_PREFIX l1 l2`, Induct THEN SIMP_TAC(srw_ss())[IS_PREFIX_NIL] THEN GEN_TAC THEN Cases THEN SIMP_TAC(srw_ss())[] THEN Cases THEN SRW_TAC[][]) @@ -3175,7 +3176,7 @@ val map_replicate = Q.store_thm ("map_replicate", Induct_on `n` >> rw [REPLICATE]); val REPLICATE_NIL = Q.store_thm("REPLICATE_NIL", - `(REPLICATE x y = []) ⇔ (x = 0)`, + `(REPLICATE x y = []) <=> (x = 0)`, Cases_on`x`>>rw[REPLICATE]); val REPLICATE_APPEND = Q.store_thm("REPLICATE_APPEND", @@ -3188,7 +3189,7 @@ val DROP_REPLICATE = Q.store_thm("DROP_REPLICATE", simp[LIST_EQ_REWRITE,LENGTH_REPLICATE,EL_REPLICATE,EL_DROP]) val LIST_REL_REPLICATE_same = store_thm("LIST_REL_REPLICATE_same", - ``LIST_REL P (REPLICATE n x) (REPLICATE n y) ⇔ (n > 0 ⇒ P x y)``, + ``LIST_REL P (REPLICATE n x) (REPLICATE n y) <=> (n > 0 ==> P x y)``, simp[LIST_REL_EL_EQN,REPLICATE_GENLIST] >> Cases_on`n`>>simp[EQ_IMP_THM] >> rw[] >> FIRST_X_ASSUM MATCH_MP_TAC >> @@ -3214,31 +3215,31 @@ val all_distinct_count_list = Q.store_thm ("all_distinct_count_list", val list_rel_lastn = Q.store_thm("list_rel_lastn", `!f l1 l2 n. - n ≤ LENGTH l1 ∧ - LIST_REL f l1 l2 ⇒ + n <= LENGTH l1 /\ + LIST_REL f l1 l2 ==> LIST_REL f (LASTN n l1) (LASTN n l2)`, Induct_on `l1` >> rw [LASTN] >> imp_res_tac EVERY2_LENGTH >> Cases_on `n = LENGTH l1 + 1` >- metis_tac [LASTN_LENGTH_ID, ADD1, LENGTH, LIST_REL_def] >> - `n ≤ LENGTH l1` by decide_tac >> - `n ≤ LENGTH ys` by decide_tac >> + `n <= LENGTH l1` by decide_tac >> + `n <= LENGTH ys` by decide_tac >> res_tac >> fs [LASTN_CONS]); val list_rel_butlastn = Q.store_thm ("list_rel_butlastn", `!f l1 l2 n. - n ≤ LENGTH l1 ∧ - LIST_REL f l1 l2 ⇒ + n <= LENGTH l1 /\ + LIST_REL f l1 l2 ==> LIST_REL f (BUTLASTN n l1) (BUTLASTN n l2)`, Induct_on `l1` >> rw [BUTLASTN] >> imp_res_tac EVERY2_LENGTH >> Cases_on `n = LENGTH l1 + 1` >- metis_tac [BUTLASTN_LENGTH_NIL, ADD1, LENGTH, LIST_REL_def] >> - `n ≤ LENGTH l1` by decide_tac >> - `n ≤ LENGTH ys` by decide_tac >> + `n <= LENGTH l1` by decide_tac >> + `n <= LENGTH ys` by decide_tac >> res_tac >> fs [BUTLASTN_CONS]); diff --git a/src/llist/llistScript.sml b/src/llist/llistScript.sml index 7a8e4b2519..7e0f39d21d 100644 --- a/src/llist/llistScript.sml +++ b/src/llist/llistScript.sml @@ -700,7 +700,7 @@ val LHD_LAPPEND = Q.store_thm("LHD_LAPPEND", qspec_then`l1`FULL_STRUCT_CASES_TAC llist_CASES >> rw[]) val LTAKE_LAPPEND1 = Q.store_thm("LTAKE_LAPPEND1", - `∀n l1 l2. IS_SOME (LTAKE n l1) ⇒ (LTAKE n (LAPPEND l1 l2) = LTAKE n l1)`, + `!n l1 l2. IS_SOME (LTAKE n l1) ==> (LTAKE n (LAPPEND l1 l2) = LTAKE n l1)`, Induct >> rw[LTAKE_THM] >> qspec_then`l1`FULL_STRUCT_CASES_TAC llist_CASES >> fs[] >> Cases_on`LTAKE n t`>>fs[]) @@ -788,7 +788,7 @@ val NOT_LFINITE_NO_LENGTH = store_thm( SIMP_TAC (srw_ss()) [LLENGTH]); val LFINITE_LLENGTH = Q.store_thm("LFINITE_LLENGTH", - `LFINITE ll ⇔ ∃n. LLENGTH ll = SOME n`, + `LFINITE ll <=> ?n. LLENGTH ll = SOME n`, rw[EQ_IMP_THM,LFINITE_HAS_LENGTH] >> spose_not_then strip_assume_tac >> imp_res_tac NOT_LFINITE_NO_LENGTH >> @@ -837,9 +837,9 @@ val LFINITE_APPEND = store_thm( val LTAKE_LNTH_EL = Q.store_thm ("LTAKE_LNTH_EL", `!n ll m l. - (LTAKE n ll = SOME l) ∧ + (LTAKE n ll = SOME l) /\ m < n - ⇒ + ==> (LNTH m ll = SOME (EL m l))`, Induct>>simp[]>> (* "Cases" *) @@ -943,7 +943,7 @@ val LFINITE_toList = store_thm( REPEAT STRIP_TAC THEN ASM_SIMP_TAC (srw_ss()) [toList_THM]); val LFINITE_toList_SOME = Q.store_thm("LFINITE_toList_SOME", - `LFINITE ll ⇔ IS_SOME (toList ll)`, + `LFINITE ll <=> IS_SOME (toList ll)`, EQ_TAC >> simp[optionTheory.IS_SOME_EXISTS,LFINITE_toList] >> rw[] >> fs[toList]) @@ -955,7 +955,7 @@ val to_fromList = store_thm( IMP_RES_TAC LFINITE_toList THEN FULL_SIMP_TAC (srw_ss()) []); val LTAKE_LAPPEND2 = Q.store_thm("LTAKE_LAPPEND2", - `∀n l1 l2. (LTAKE n l1 = NONE) ⇒ + `!n l1 l2. (LTAKE n l1 = NONE) ==> (LTAKE n (LAPPEND l1 l2) = OPTION_MAP (APPEND (THE(toList l1))) (LTAKE (n - THE(LLENGTH l1)) l2))`, rpt gen_tac >> strip_tac >> @@ -1082,7 +1082,7 @@ val LDROP_ADD = store_thm("LDROP_ADD", \\ Cases_on `LDROP k1 x'` \\ fs []); val LFINITE_LNTH_NONE = Q.store_thm("LFINITE_LNTH_NONE", - `LFINITE ll ⇔ ∃n. LNTH n ll = NONE`, + `LFINITE ll <=> ?n. LNTH n ll = NONE`, EQ_TAC >- ( qid_spec_tac`ll` >> ho_match_mp_tac LFINITE_INDUCTION >> @@ -1103,7 +1103,7 @@ val LNTH_LAPPEND = Q.store_thm("LNTH_LAPPEND", Cases_on`n`>>fs[] ) >> BasicProvers.CASE_TAC >> fs[LFINITE_LLENGTH] >> - `∀n. ∃x. LNTH n l1 = SOME x` by ( + `!n. ?x. LNTH n l1 = SOME x` by ( metis_tac[LFINITE_LNTH_NONE,LFINITE_LLENGTH, optionTheory.option_CASES,optionTheory.NOT_SOME_NONE] ) >> Cases_on`LTAKE (SUC n) l1` >- ( @@ -1666,7 +1666,7 @@ FULL_SIMP_TAC (srw_ss()) [] THEN METIS_TAC []); val LTAKE_TAKE_LESS = Q.store_thm("LTAKE_TAKE_LESS", - `(LTAKE n ll = SOME l) ∧ m ≤ n ⇒ + `(LTAKE n ll = SOME l) /\ m <= n ==> (LTAKE m ll = SOME (TAKE m l))`, rw[] >> Cases_on`n=m`>>fs[] >> imp_res_tac LTAKE_LENGTH >> rw[] >> @@ -1681,17 +1681,17 @@ val LTAKE_TAKE_LESS = Q.store_thm("LTAKE_TAKE_LESS", imp_res_tac LTAKE_LNTH_EL >> fs[]); val LTAKE_LLENGTH_NONE = Q.store_thm("LTAKE_LLENGTH_NONE", - `(LLENGTH ll = SOME n) ∧ n < m ⇒ (LTAKE m ll = NONE)`, + `(LLENGTH ll = SOME n) /\ n < m ==> (LTAKE m ll = NONE)`, rw[] >> `LFINITE ll` by metis_tac[LFINITE_LLENGTH] >> - `∀ll. LFINITE ll ⇒ ∀m n. (LLENGTH ll = SOME n) ∧ n < m - ⇒ (LTAKE m ll = NONE)` suffices_by metis_tac[] >> + `!ll. LFINITE ll ==> !m n. (LLENGTH ll = SOME n) /\ n < m + ==> (LTAKE m ll = NONE)` suffices_by metis_tac[] >> rpt (pop_assum kall_tac) >> ho_match_mp_tac LFINITE_INDUCTION >> rw[] >> simp[LTAKE_CONS_EQ_NONE] >> Cases_on`m`>>fs[]) val toList_LAPPEND_APPEND = Q.store_thm("toList_LAPPEND_APPEND", - `(toList (LAPPEND l1 l2) = SOME x) ⇒ + `(toList (LAPPEND l1 l2) = SOME x) ==> (x = (THE(toList l1)++THE(toList l2)))`, Cases_on`l2=[||]`>>simp[toList_THM,LAPPEND_NIL_2ND] >> strip_tac >> fs[toList,LFINITE_APPEND] >> @@ -1965,8 +1965,8 @@ val LPREFIX_def = Define ` | SOME ys => isPREFIX xs ys` val LPREFIX_LNIL = Q.store_thm("LPREFIX_LNIL[simp]", - `LPREFIX [||] ll ∧ - (LPREFIX ll [||] ⇔ (ll = [||]))`, + `LPREFIX [||] ll /\ + (LPREFIX ll [||] <=> (ll = [||]))`, rw[LPREFIX_def,toList_THM] >> BasicProvers.CASE_TAC >> simp[rich_listTheory.IS_PREFIX_NIL] >> @@ -1976,21 +1976,21 @@ val LPREFIX_LNIL = Q.store_thm("LPREFIX_LNIL[simp]", fs[toList_THM]); val LPREFIX_LCONS = Q.store_thm("LPREFIX_LCONS", - `(∀ll h t. - LPREFIX ll (h:::t) ⇔ - ((ll = [||]) ∨ ∃l. (ll = h:::l) ∧ LPREFIX l t)) ∧ - (∀h t ll. - LPREFIX (h:::t) ll ⇔ - ∃l. (ll = h:::l) ∧ LPREFIX t l)`, + `(!ll h t. + LPREFIX ll (h:::t) <=> + ((ll = [||]) \/ ?l. (ll = h:::l) /\ LPREFIX l t)) /\ + (!h t ll. + LPREFIX (h:::t) ll <=> + ?l. (ll = h:::l) /\ LPREFIX t l)`, rw[] >> Q.ISPEC_THEN`ll`FULL_STRUCT_CASES_TAC llist_CASES >> simp[LPREFIX_def,toList_THM] >> every_case_tac >> fs[] >> rw[EQ_IMP_THM]); val LPREFIX_LUNFOLD = Q.store_thm("LPREFIX_LUNFOLD", - `LPREFIX ll (LUNFOLD f n) ⇔ + `LPREFIX ll (LUNFOLD f n) <=> case f n of NONE => (ll = LNIL) - | SOME (n,x) => ∀h t. (ll = h:::t) ⇒ (h = x) ∧ LPREFIX t (LUNFOLD f n)`, + | SOME (n,x) => !h t. (ll = h:::t) ==> (h = x) /\ LPREFIX t (LUNFOLD f n)`, BasicProvers.CASE_TAC >- ( simp[LUNFOLD_THM,LPREFIX_LNIL] ) >> BasicProvers.CASE_TAC >> @@ -2005,14 +2005,14 @@ val LPREFIX_REFL = Q.store_thm("LPREFIX_REFL[simp]", rw[LPREFIX_def] >> BasicProvers.CASE_TAC >> simp[]); val LPREFIX_ANTISYM = Q.store_thm("LPREFIX_ANTISYM", - `LPREFIX l1 l2 ∧ LPREFIX l2 l1 ⇒ (l1 = l2)`, + `LPREFIX l1 l2 /\ LPREFIX l2 l1 ==> (l1 = l2)`, rw[LPREFIX_def] >> every_case_tac >> fs[] >> imp_res_tac rich_listTheory.IS_PREFIX_ANTISYM >> rw[] >> metis_tac[to_fromList,optionTheory.THE_DEF,toList,optionTheory.NOT_SOME_NONE]); val LPREFIX_TRANS = Q.store_thm("LPREFIX_TRANS", - `LPREFIX l1 l2 ∧ LPREFIX l2 l3 ⇒ LPREFIX l1 l3`, + `LPREFIX l1 l2 /\ LPREFIX l2 l3 ==> LPREFIX l1 l3`, rw[LPREFIX_def] >> every_case_tac >> fs[] >> TRY(imp_res_tac rich_listTheory.IS_PREFIX_TRANS >> NO_TAC) >> @@ -2023,22 +2023,22 @@ val LPREFIX_TRANS = Q.store_thm("LPREFIX_TRANS", val LPREFIX_fromList = Q.store_thm ("LPREFIX_fromList", `!l ll. - LPREFIX (fromList l) ll ⇔ + LPREFIX (fromList l) ll <=> case toList ll of | NONE => LTAKE (LENGTH l) ll = SOME l | SOME ys => isPREFIX l ys`, rw [LPREFIX_def, from_toList]); val prefixes_lprefix_total = Q.store_thm("prefixes_lprefix_total", - `∀ll. ∀l1 l2. LPREFIX l1 ll ∧ LPREFIX l2 ll ⇒ - LPREFIX l1 l2 ∨ LPREFIX l2 l1`, + `!ll. !l1 l2. LPREFIX l1 ll /\ LPREFIX l2 ll ==> + LPREFIX l1 l2 \/ LPREFIX l2 l1`, rw[LPREFIX_def] >> reverse every_case_tac >> fs[] >- metis_tac[rich_listTheory.prefixes_is_prefix_total] >> rpt(pop_assum mp_tac) >> qho_match_abbrev_tac`P l1 l2 x x'` >> - `P l1 l2 x x' ⇔ P l2 l1 x' x` by ( + `P l1 l2 x x' <=> P l2 l1 x' x` by ( simp[Abbr`P`] >> metis_tac[] ) >> - `∀ll1 ll2 l1 l2. LENGTH l1 ≤ LENGTH l2 ⇒ P ll1 ll2 l1 l2` suffices_by ( + `!ll1 ll2 l1 l2. LENGTH l1 <= LENGTH l2 ==> P ll1 ll2 l1 l2` suffices_by ( rw[] >> metis_tac[arithmeticTheory.LESS_EQ_CASES] ) >> pop_assum kall_tac >> unabbrev_all_tac >> rw[] >> `l1 = (TAKE (LENGTH l1) l2)` by ( @@ -2054,9 +2054,9 @@ val LPREFIX_LAPPEND1 = Q.prove( LTAKE_fromList,toList_LAPPEND_APPEND,rich_listTheory.IS_PREFIX_APPEND]); val LTAKE_IMP_LDROP = Q.store_thm("LTAKE_IMP_LDROP", - `∀n ll l1. - (LTAKE n ll = SOME l1) ⇒ - ∃l2. (LDROP n ll = SOME l2) ∧ + `!n ll l1. + (LTAKE n ll = SOME l1) ==> + ?l2. (LDROP n ll = SOME l2) /\ (LAPPEND (fromList l1) l2 = ll)`, Induct >> simp[] >> gen_tac >> qspec_then`ll`FULL_STRUCT_CASES_TAC llist_CASES >> rw[] >> @@ -2064,7 +2064,7 @@ val LTAKE_IMP_LDROP = Q.store_thm("LTAKE_IMP_LDROP", rw[]) val LPREFIX_APPEND = Q.store_thm("LPREFIX_APPEND", - `LPREFIX l1 l2 ⇔ ∃ll. l2 = LAPPEND l1 ll`, + `LPREFIX l1 l2 <=> ?ll. l2 = LAPPEND l1 ll`, reverse EQ_TAC >- metis_tac[LPREFIX_LAPPEND1] >> simp[LPREFIX_def] >> Cases_on`toList l1`>>fs[] diff --git a/src/n-bit/alignmentScript.sml b/src/n-bit/alignmentScript.sml index c5251f9579..38f5ac74f7 100644 --- a/src/n-bit/alignmentScript.sml +++ b/src/n-bit/alignmentScript.sml @@ -85,7 +85,7 @@ val align_sub = Q.store_thm("align_sub", rw_tac bool_ss [align_0] \\ Cases_on `dimindex(:'a) <= p - 1` >- ( - `(p − 1 >< 0) w : 'a word = (dimindex (:'a) - 1 >< 0) w` + `(p - 1 >< 0) w : 'a word = (dimindex (:'a) - 1 >< 0) w` by simp [wordsTheory.WORD_EXTRACT_MIN_HIGH] \\ rule_assum_tac (SIMP_RULE (srw_ss()) ths) \\ asm_rewrite_tac [] diff --git a/src/num/theories/arithmeticScript.sml b/src/num/theories/arithmeticScript.sml index f63e2e8d0f..cbc5c440e2 100644 --- a/src/num/theories/arithmeticScript.sml +++ b/src/num/theories/arithmeticScript.sml @@ -311,9 +311,9 @@ val NOT_LT_ZERO_EQ_ZERO = store_thm( REWRITE_TAC [GSYM NOT_ZERO_LT_ZERO]); val LESS_OR_EQ_ALT = store_thm ("LESS_OR_EQ_ALT", - ``$<= = RTC (λx y. y = SUC x)``, + ``$<= = RTC (\x y. y = SUC x)``, REWRITE_TAC [FUN_EQ_THM, LESS_OR_EQ, relationTheory.RTC_CASES_TC, LESS_ALT] - THEN REPEAT (STRIP_TAC ORELSE EQ_TAC) + THEN REPEAT (STRIP_TAC ORELSE EQ_TAC) THEN ASM_REWRITE_TAC []) ; (* --------------------------------------------------------------------- *) @@ -336,7 +336,7 @@ val transitive_LESS = store_thm( val LESS_TRANS = store_thm ("LESS_TRANS", ``!m n p. (m < n) /\ (n < p) ==> (m < p)``, - MATCH_ACCEPT_TAC + MATCH_ACCEPT_TAC (REWRITE_RULE [relationTheory.transitive_def] transitive_LESS)) ; val LESS_ANTISYM = store_thm ("LESS_ANTISYM", @@ -368,7 +368,7 @@ val transitive_measure = Q.store_thm ("transitive_measure", THEN SRW_TAC [SatisfySimps.SATISFY_ss][]); val LESS_EQ = store_thm ("LESS_EQ", - ``!m n. (m < n) = (SUC m <= n)``, + ``!m n. (m < n) = (SUC m <= n)``, REWRITE_TAC[LESS_OR_EQ_ALT, LESS_ALT, RTC_IM_TC]) ; val LESS_OR = store_thm ("LESS_OR", diff --git a/src/option/optionScript.sml b/src/option/optionScript.sml index 78e061b9b9..3bf6e9f1b9 100644 --- a/src/option/optionScript.sml +++ b/src/option/optionScript.sml @@ -202,7 +202,7 @@ val ex1_rw = prove(Term`!x. (?y. x = y) /\ (?y. y = x)`, fun OPTION_CASES_TAC t = STRUCT_CASES_TAC (ISPEC t option_nchotomy); val IS_SOME_EXISTS = store_thm("IS_SOME_EXISTS", - ``∀opt. IS_SOME opt ⇔ ∃x. opt = SOME x``, + ``!opt. IS_SOME opt <=> ?x. opt = SOME x``, GEN_TAC THEN (Q_TAC OPTION_CASES_TAC`opt`) THEN SRW_TAC[][IS_SOME_DEF]) diff --git a/src/patricia/sptreeScript.sml b/src/patricia/sptreeScript.sml index c36fa621c2..3abc89bbf2 100644 --- a/src/patricia/sptreeScript.sml +++ b/src/patricia/sptreeScript.sml @@ -642,9 +642,9 @@ val domain_empty = store_thm("domain_empty", simp[] >> Induct >> simp[wf_def] >> metis_tac[]) val toAList_append = prove( - ``∀t n ls. - foldi (λk v a. (k,v)::a) n ls t = - foldi (λk v a. (k,v)::a) n [] t ++ ls``, + ``!t n ls. + foldi (\k v a. (k,v)::a) n ls t = + foldi (\k v a. (k,v)::a) n [] t ++ ls``, Induct >- simp[foldi_def] >- simp[foldi_def] @@ -667,9 +667,9 @@ val toAList_append = prove( metis_tac[APPEND_ASSOC,APPEND] ) val toAList_inc = prove( - ``∀t n. - foldi (λk v a. (k,v)::a) n [] t = - MAP (λ(k,v). (n + lrnext n * k,v)) (foldi (λk v a. (k,v)::a) 0 [] t)``, + ``!t n. + foldi (\k v a. (k,v)::a) n [] t = + MAP (\(k,v). (n + lrnext n * k,v)) (foldi (\k v a. (k,v)::a) 0 [] t)``, Induct >- simp[foldi_def] >- simp[foldi_def] @@ -709,8 +709,8 @@ val toAList_inc = prove( simp[lrlemma1,lrlemma2] )) val lemmas = prove( - ``(∀x. EVEN (2 * x + 2)) ∧ - (∀x. ODD (2 * x + 1))``, + ``(!x. EVEN (2 * x + 2)) /\ + (!x. ODD (2 * x + 1))``, conj_tac >- ( simp[EVEN_EXISTS] >> rw[] >> qexists_tac`SUC x` >> simp[] ) >> @@ -718,7 +718,7 @@ val lemmas = prove( metis_tac[] ) val ALL_DISTINCT_MAP_FST_toAList = store_thm("ALL_DISTINCT_MAP_FST_toAList", - ``∀t. ALL_DISTINCT (MAP FST (toAList t))``, + ``!t. ALL_DISTINCT (MAP FST (toAList t))``, simp[toAList_def] >> Induct >> simp[foldi_def] >- ( CONV_TAC(RAND_CONV(RAND_CONV(RATOR_CONV(RAND_CONV(REWR_CONV toAList_inc))))) >> @@ -728,14 +728,14 @@ val ALL_DISTINCT_MAP_FST_toAList = store_thm("ALL_DISTINCT_MAP_FST_toAList", simp[ALL_DISTINCT_APPEND] >> rpt conj_tac >- ( qmatch_abbrev_tac`ALL_DISTINCT (MAP f ls)` >> - `MAP f ls = MAP (λx. 2 * x + 1) (MAP FST ls)` by ( + `MAP f ls = MAP (\x. 2 * x + 1) (MAP FST ls)` by ( simp[MAP_MAP_o,combinTheory.o_DEF,Abbr`f`] ) >> pop_assum SUBST1_TAC >> qunabbrev_tac`f` >> match_mp_tac ALL_DISTINCT_MAP_INJ >> simp[] ) >- ( qmatch_abbrev_tac`ALL_DISTINCT (MAP f ls)` >> - `MAP f ls = MAP (λx. 2 * x + 2) (MAP FST ls)` by ( + `MAP f ls = MAP (\x. 2 * x + 2) (MAP FST ls)` by ( simp[MAP_MAP_o,combinTheory.o_DEF,Abbr`f`] ) >> pop_assum SUBST1_TAC >> qunabbrev_tac`f` >> match_mp_tac ALL_DISTINCT_MAP_INJ >> @@ -750,7 +750,7 @@ val ALL_DISTINCT_MAP_FST_toAList = store_thm("ALL_DISTINCT_MAP_FST_toAList", simp[ALL_DISTINCT_APPEND] >> rpt conj_tac >- ( qmatch_abbrev_tac`ALL_DISTINCT (MAP f ls)` >> - `MAP f ls = MAP (λx. 2 * x + 1) (MAP FST ls)` by ( + `MAP f ls = MAP (\x. 2 * x + 1) (MAP FST ls)` by ( simp[MAP_MAP_o,combinTheory.o_DEF,Abbr`f`] ) >> pop_assum SUBST1_TAC >> qunabbrev_tac`f` >> match_mp_tac ALL_DISTINCT_MAP_INJ >> @@ -758,7 +758,7 @@ val ALL_DISTINCT_MAP_FST_toAList = store_thm("ALL_DISTINCT_MAP_FST_toAList", >- ( simp[MEM_MAP] ) >- ( qmatch_abbrev_tac`ALL_DISTINCT (MAP f ls)` >> - `MAP f ls = MAP (λx. 2 * x + 2) (MAP FST ls)` by ( + `MAP f ls = MAP (\x. 2 * x + 2) (MAP FST ls)` by ( simp[MAP_MAP_o,combinTheory.o_DEF,Abbr`f`] ) >> pop_assum SUBST1_TAC >> qunabbrev_tac`f` >> match_mp_tac ALL_DISTINCT_MAP_INJ >> @@ -769,13 +769,13 @@ val ALL_DISTINCT_MAP_FST_toAList = store_thm("ALL_DISTINCT_MAP_FST_toAList", val _ = remove_ovl_mapping "lrnext" {Name = "lrnext", Thy = "sptree"} val foldi_FOLDR_toAList_lemma = prove( - ``∀t n a ls. foldi f n (FOLDR (UNCURRY f) a ls) t = - FOLDR (UNCURRY f) a (foldi (λk v a. (k,v)::a) n ls t)``, + ``!t n a ls. foldi f n (FOLDR (UNCURRY f) a ls) t = + FOLDR (UNCURRY f) a (foldi (\k v a. (k,v)::a) n ls t)``, Induct >> simp[foldi_def] >> rw[] >> pop_assum(assume_tac o GSYM) >> simp[]) val foldi_FOLDR_toAList = store_thm("foldi_FOLDR_toAList", - ``∀f a t. foldi f 0 a t = FOLDR (UNCURRY f) a (toAList t)``, + ``!f a t. foldi f 0 a t = FOLDR (UNCURRY f) a (toAList t)``, simp[toAList_def,GSYM foldi_FOLDR_toAList_lemma]) val toListA_def = Define` @@ -823,7 +823,7 @@ fun tac () = ( (metis_tac[])) val MEM_toListA = prove( - ``∀t acc x. MEM x (toListA acc t) ⇔ (MEM x acc ∨ ∃k. lookup k t = SOME x)``, + ``!t acc x. MEM x (toListA acc t) <=> (MEM x acc \/ ?k. lookup k t = SOME x)``, Induct >> simp[toListA_def,lookup_def] >- metis_tac[] >> rw[EQ_IMP_THM] >> rw[] >> pop_assum mp_tac >> rw[] >- (tac()) @@ -837,7 +837,7 @@ val MEM_toListA = prove( >- (tac())) val MEM_toList = store_thm("MEM_toList", - ``∀x t. MEM x (toList t) ⇔ ∃k. lookup k t = SOME x``, + ``!x t. MEM x (toList t) <=> ?k. lookup k t = SOME x``, rw[toList_def,MEM_toListA]) val div2_even_lemma = prove( @@ -1145,18 +1145,18 @@ val map_def = Define` (map f (BS t1 a t2) = BS (map f t1) (f a) (map f t2))` val toList_map = store_thm("toList_map", - ``∀s. toList (map f s) = MAP f (toList s)``, + ``!s. toList (map f s) = MAP f (toList s)``, Induct >> fs[toList_def,map_def,toListA_def] >> simp[Once toListA_append] >> simp[Once toListA_append,SimpRHS]) val domain_map = store_thm("domain_map", - ``∀s. domain (map f s) = domain s``, + ``!s. domain (map f s) = domain s``, Induct >> simp[map_def]) val lookup_map = store_thm("lookup_map", - ``∀s x. lookup x (map f s) = OPTION_MAP f (lookup x s)``, + ``!s x. lookup x (map f s) = OPTION_MAP f (lookup x s)``, Induct >> simp[map_def,lookup_def] >> rw[]) val map_LN = store_thm("map_LN[simp]", diff --git a/src/quotient/examples/ext_finite_setScript.sml b/src/quotient/examples/ext_finite_setScript.sml index 1c2b75ac5b..e2d2dde435 100644 --- a/src/quotient/examples/ext_finite_setScript.sml +++ b/src/quotient/examples/ext_finite_setScript.sml @@ -287,7 +287,7 @@ val fnlist = (* if desired, a membership constant for finite sets can be defined in terms of fset2set: - fmem x s = x ∈ fset2set s + fmem x s = x ∈ fset2set s (UOK) Alternatively, fmem could just be overloaded to a term of this form, as is done in the finite_set version of this example. diff --git a/src/rational/fracLib.sml b/src/rational/fracLib.sml index fbd6412a6b..546a7bba4d 100644 --- a/src/rational/fracLib.sml +++ b/src/rational/fracLib.sml @@ -427,7 +427,7 @@ fun frac_calc_tac (frac_terms:term list) (asm_list:term list,goal:term) = (* generate subgoals: prove the hypothesis of the hypothesis of the calculation theorems *) val hyps_sgs = map (fn x => (asm_list,x)) asms_hyp; - (* TODO: statt oben hier noch ein paar Theoreme ergänzen, die dann mit thms konkateniert werden *) + (* TODO: statt oben hier noch ein paar Theoreme ergänzen, die dann mit thms konkateniert werden (UOK) *) (*val thms = map mk_thm ([subs_sg] @ hyps_sgs);*) @@ -439,7 +439,7 @@ fun frac_calc_tac (frac_terms:term list) (asm_list:term list,goal:term) = (* all other theorems: hyptothesis subgoals *) val asm_thms = tl thms; - (* erster Schritt: baue Voraussetzungen für die calc_thms zusammen *) + (* erster Schritt: baue Voraussetzungen für die calc_thms zusammen (UOK) *) (* extract proof from asm_thms list (TODO: other list) *) diff --git a/src/sort/sortingScript.sml b/src/sort/sortingScript.sml index 8b7884502b..3159bab574 100644 --- a/src/sort/sortingScript.sml +++ b/src/sort/sortingScript.sml @@ -169,21 +169,21 @@ RW_TAC bool_ss [o_DEF] Alternative definition of PERM ---------------------------------------------------------------------- *) -val FILTER_EQ_REP = store_thm ("FILTER_EQ_REP", +val FILTER_EQ_REP = store_thm ("FILTER_EQ_REP", ``FILTER ($= x) l = REPLICATE (LENGTH (FILTER ($= x) l)) x``, EVERY [Induct_on `l`, SIMP_TAC list_ss [rich_listTheory.REPLICATE], GEN_TAC, COND_CASES_TAC THENL [ BasicProvers.VAR_EQ_TAC, ALL_TAC], ASM_SIMP_TAC list_ss [rich_listTheory.REPLICATE] ]) ; -val FILTER_EQ_LENGTHS_EQ = store_thm ("FILTER_EQ_LENGTHS_EQ", - ``(LENGTH (FILTER ($= x) l1) = LENGTH (FILTER ($= x) l2)) ==> +val FILTER_EQ_LENGTHS_EQ = store_thm ("FILTER_EQ_LENGTHS_EQ", + ``(LENGTH (FILTER ($= x) l1) = LENGTH (FILTER ($= x) l2)) ==> (FILTER ($= x) l1 = FILTER ($= x) l2)``, EVERY [ DISCH_TAC, ONCE_REWRITE_TAC [FILTER_EQ_REP], ASM_SIMP_TAC bool_ss [] ]) ; val PERM_alt = store_thm ("PERM_alt", - ``!L1 L2. PERM L1 L2 = + ``!L1 L2. PERM L1 L2 = !x. LENGTH (FILTER ($= x) L1) = LENGTH (FILTER ($= x) L2)``, EVERY [REWRITE_TAC [PERM_DEF], REPEAT GEN_TAC, EQ_TAC, REPEAT STRIP_TAC ] THENL [ @@ -282,7 +282,7 @@ val perm_cons_append = prove( ``^perm_t ==> !l1 l2. perm l1 l2 ==> !M N. (l2 = M ++ N) ==> !h. perm (h::l1) (M ++ [h] ++ N)``, - REPEAT STRIP_TAC >> MATCH_MP_TAC perm_trans >> + REPEAT STRIP_TAC >> MATCH_MP_TAC perm_trans >> Q.EXISTS_TAC `h :: l2` >> CONJ_TAC THENL [ ASSUME_TAC perm_rules >> ASM_SIMP_TAC list_ss [], BasicProvers.VAR_EQ_TAC >> @@ -627,7 +627,7 @@ val PERM_SINGLE_SWAP_I = Q.store_thm ("PERM_SINGLE_SWAP_I", val PERM_SINGLE_SWAP_APPEND = save_thm ("PERM_SINGLE_SWAP_APPEND", REWRITE_RULE [APPEND] (Q.INST [`x1` |-> `NIL`] PERM_SINGLE_SWAP_I)) ; -val PERM_SINGLE_SWAP_REFL = save_thm ("PERM_SINGLE_SWAP_REFL", +val PERM_SINGLE_SWAP_REFL = save_thm ("PERM_SINGLE_SWAP_REFL", GEN_ALL (REWRITE_RULE [APPEND, APPEND_NIL] (Q.INST [`x2` |-> `NIL`, `x3` |-> `l`] PERM_SINGLE_SWAP_APPEND))) ; @@ -932,7 +932,7 @@ val MEM_PERM = val SORTED_PERM_EQ = Q.store_thm ("SORTED_PERM_EQ", `!R. transitive R /\ antisymmetric R ==> - !l1 l2. SORTED R l1 /\ SORTED R l2 /\ PERM l1 l2 ==> (l1 = l2)`, + !l1 l2. SORTED R l1 /\ SORTED R l2 /\ PERM l1 l2 ==> (l1 = l2)`, GEN_TAC >> STRIP_TAC >> Induct THEN1 SIMP_TAC list_ss [PERM_NIL] >> REPEAT STRIP_TAC >> @@ -1366,7 +1366,7 @@ val less_sorted_eq = MATCH_MP SORTED_EQ arithmeticTheory.transitive_LESS |> curry save_thm"less_sorted_eq"; val SORTED_GENLIST_PLUS = store_thm("SORTED_GENLIST_PLUS", - ``∀n k. SORTED $< (GENLIST ($+ k) n)``, + ``!n k. SORTED $< (GENLIST ($+ k) n)``, Induct >> simp[GENLIST_CONS,less_sorted_eq,MEM_GENLIST] >> gen_tac >> `$+ k o SUC = $+ (k+1)` by ( simp[FUN_EQ_THM] ) >> @@ -1380,7 +1380,7 @@ val SORTED_ALL_DISTINCT = store_thm("SORTED_ALL_DISTINCT", METIS_TAC[relationTheory.irreflexive_def]) val sorted_filter = Q.store_thm("sorted_filter", - `∀R ls. transitive R ⇒ SORTED R ls ⇒ SORTED R (FILTER P ls)`, + `!R ls. transitive R ==> SORTED R ls ==> SORTED R (FILTER P ls)`, HO_MATCH_MP_TAC SORTED_IND >> rw[SORTED_DEF] >> fs[] >> rfs[SORTED_EQ,MEM_FILTER] >> diff --git a/src/temporal/src/temporalLib.sml b/src/temporal/src/temporalLib.sml index dc323d6f63..61c50f1d8d 100644 --- a/src/temporal/src/temporalLib.sml +++ b/src/temporal/src/temporalLib.sml @@ -831,45 +831,49 @@ fun UNSAFE_TEMP_DEFS_CONV t = -(* ************************************************************************************ *) -(* The conversion LTL2OMEGA_CONV finally does what its name indicates. Given an LTL *) -(* formula in the form as mentioned in the comment on the conversion TEMP_DEFS_CONV, *) -(* LTL2OMEGA_CONV computes an equivalent generalized Büchi automaton and proves the *) -(* equivalence with the given LTL formula. *) -(* ------------------------------------------------------------------------------------ *) -(* LTL2OMEGA_CONV (--`ALWAYS (\t. (EVENTUAL a) t = a t \/ NEXT (EVENTUAL a) t) 0`--); *) -(* val it = *) -(* |- ALWAYS (\t. EVENTUAL a t = a t \/ NEXT (EVENTUAL a) t) 0 = *) -(* (?ell0 ell1 ell2 ell3 ell4. *) -(* ell4 0 /\ *) -(* (!t. *) -(* (ell0 t = a t \/ ell0 (SUC t)) /\ *) -(* (ell1 t = a t \/ ell1 (SUC t)) /\ *) -(* (ell2 t = ell1 t) /\ *) -(* (ell3 t = ell2 (SUC t)) /\ *) -(* (ell4 t = (ell0 t = a t \/ ell3 t) /\ ell4 (SUC t))) /\ *) -(* (!t1. ?t2. ell0 (t1 + t2) ==> a (t1 + t2)) /\ *) -(* (!t1. ?t2. ell1 (t1 + t2) ==> a (t1 + t2)) /\ *) -(* (!t1. *) -(* ?t2. *) -(* (ell0 (t1 + t2) = a (t1 + t2) \/ ell3 (t1 + t2)) ==> *) -(* ell4 (t1 + t2))) : thm *) -(* *) -(* LTL2OMEGA_CONV (--`ALWAYS (EVENTUAL (\t. a t /\ PALWAYS b t)) 0`--); *) -(* val it = *) -(* |- ALWAYS (EVENTUAL (\t. a t /\ PALWAYS b t)) 0 = *) -(* (?ell0 ell1 ell2. *) -(* (ell2 0 /\ ell0 0) /\ *) -(* (!t. *) -(* (ell0 (SUC t) = b t /\ ell0 t) /\ *) -(* (ell1 t = a t /\ b t /\ ell0 t \/ ell1 (SUC t)) /\ *) -(* (ell2 t = ell1 t /\ ell2 (SUC t))) /\ *) -(* (!t1. *) -(* ?t2. *) -(* ell1 (t1 + t2) ==> a (t1 + t2) /\ b (t1 + t2) /\ ell0 (t1 + t2)) /\ *) -(* (!t1. ?t2. ell1 (t1 + t2) ==> ell2 (t1 + t2))) : thm *) -(* *) -(* ************************************************************************************ *) +(* **************************************************************************** + + The conversion LTL2OMEGA_CONV finally does what its name indicates. + Given an LTL formula in the form as mentioned in the comment on the + conversion TEMP_DEFS_CONV, LTL2OMEGA_CONV computes an equivalent + generalized Büchi automaton and proves the equivalence with the (* UOK *) + given LTL formula. + + ---------------------------------------------------------------------------- + LTL2OMEGA_CONV + ``ALWAYS (\t. (EVENTUAL a) t = a t \/ NEXT (EVENTUAL a) t) 0``; + val it = + |- ALWAYS (\t. EVENTUAL a t = a t \/ NEXT (EVENTUAL a) t) 0 = + (?ell0 ell1 ell2 ell3 ell4. + ell4 0 /\ + (!t. + (ell0 t = a t \/ ell0 (SUC t)) /\ + (ell1 t = a t \/ ell1 (SUC t)) /\ + (ell2 t = ell1 t) /\ + (ell3 t = ell2 (SUC t)) /\ + (ell4 t = (ell0 t = a t \/ ell3 t) /\ ell4 (SUC t))) /\ + (!t1. ?t2. ell0 (t1 + t2) ==> a (t1 + t2)) /\ + (!t1. ?t2. ell1 (t1 + t2) ==> a (t1 + t2)) /\ + (!t1. + ?t2. + (ell0 (t1 + t2) = a (t1 + t2) \/ ell3 (t1 + t2)) ==> + ell4 (t1 + t2))) : thm + + LTL2OMEGA_CONV ``ALWAYS (EVENTUAL (\t. a t /\ PALWAYS b t)) 0``; + val it = + |- ALWAYS (EVENTUAL (\t. a t /\ PALWAYS b t)) 0 = + (?ell0 ell1 ell2. + (ell2 0 /\ ell0 0) /\ + (!t. + (ell0 (SUC t) = b t /\ ell0 t) /\ + (ell1 t = a t /\ b t /\ ell0 t \/ ell1 (SUC t)) /\ + (ell2 t = ell1 t /\ ell2 (SUC t))) /\ + (!t1. + ?t2. + ell1 (t1 + t2) ==> a (t1 + t2) /\ b (t1 + t2) /\ ell0 (t1 + t2)) /\ + (!t1. ?t2. ell1 (t1 + t2) ==> ell2 (t1 + t2))) : thm + + ************************************************************************* *) @@ -1370,15 +1374,18 @@ fun print_smv_info smv_info = -(* ************************************************************************************ *) -(* Given a generalized co-Büchi automaton, the conversion SMV_AUTOMATON_CONV checks for *) -(* nonemptiness of the automaton. If the language accepted by the automaton is empty, *) -(* the conversion generates the following theorem: |- (?a_1...a_n. automaton) = F, where*) -(* a_1,...,a_n are the free variables of the given automaton formula. *) -(* In case the language is not empty, the conversion will print out the countermodel *) -(* that has been generated by SMV which shows a word that belongs to the language of the*) -(* automaton. *) -(* ************************************************************************************ *) +(* *************************************************************************** + + Given a generalized co-Büchi automaton, the conversion (* UOK *) + SMV_AUTOMATON_CONV checks for nonemptiness of the automaton. If the + language accepted by the automaton is empty, the conversion + generates the following theorem: |- (?a_1...a_n. automaton) = F, + where a_1,...,a_n are the free variables of the given automaton + formula. In case the language is not empty, the conversion will + print out the countermodel that has been generated by SMV which + shows a word that belongs to the language of the automaton. + + ************************************************************************* *) fun SMV_RUN_FILE smv_file = diff --git a/src/tfl/src/RW.sml b/src/tfl/src/RW.sml index 69275dd336..26b2936a3e 100644 --- a/src/tfl/src/RW.sml +++ b/src/tfl/src/RW.sml @@ -493,9 +493,9 @@ fun add_cntxt ADD = add_rws | add_cntxt DONT_ADD = Lib.K; (* The following congruence rule has only bare antecedents: *) (* *) (* |- !P Q x x' y y'. *) -(* (P ⇔ Q) /\ *) -(* (Q ⇒ (x = x')) /\ *) -(* (¬Q ⇒ (y = y')) *) +(* (P ⇔ Q) /\ UOK *) +(* (Q ⇒ (x = x')) /\ UOK *) +(* (¬Q ⇒ (y = y')) UOK *) (* ==> *) (* ((if P then x else y) = if Q then x' else y') *) (* *) From f03b6d2c2fe2fff0852a159a9bfe1b8cad0606aa Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 21 Oct 2015 11:40:02 +1100 Subject: [PATCH 552/718] Improve Makefile for Developers' Manual --- Manual/Developers/Makefile | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/Manual/Developers/Makefile b/Manual/Developers/Makefile index dc26a57915..d777aa710b 100644 --- a/Manual/Developers/Makefile +++ b/Manual/Developers/Makefile @@ -1,6 +1,8 @@ -.PHONY: all +.PHONY: all clean -all: developers.pdf developers.html +TARGETS = developers.pdf developers.html + +all: $(TARGETS) developers.pdf: developers.tex latexmk -pdf developers @@ -10,3 +12,6 @@ developers.tex: developers.md developers.html: developers.md pandoc -s $< -o $@ + +clean: + -/bin/rm -f $(TARGETS) developers.tex From bd77b8fb0bb84711ac3cffc05b1ccdb77e4dc334 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 21 Oct 2015 16:11:37 +1100 Subject: [PATCH 553/718] Delete trailing whitespace --- .../IT/Description/QuantHeuristics.tex | 118 +- .../IT/Description/definitions.tex | 1074 +++---- .../IT/Description/description.tex | 4 +- Manual/Translations/IT/Description/drules.tex | 388 +-- .../Translations/IT/Description/libraries.tex | 2556 ++++++++--------- .../Translations/IT/Description/preface.tex | 108 +- Manual/Translations/IT/Description/system.tex | 968 +++---- .../Translations/IT/Description/theories.tex | 1820 ++++++------ Manual/Translations/IT/LaTeX/ack.tex | 62 +- Manual/Translations/IT/Logic/logic.tex | 2 +- Manual/Translations/IT/Logic/preface.tex | 108 +- Manual/Translations/IT/Logic/semantics.tex | 1054 +++---- Manual/Translations/IT/Logic/syntax.tex | 780 ++--- Manual/Translations/IT/Tutorial/combin.tex | 584 ++-- Manual/Translations/IT/Tutorial/euclid.tex | 872 +++--- Manual/Translations/IT/Tutorial/intro.tex | 158 +- Manual/Translations/IT/Tutorial/logic.tex | 450 +-- Manual/Translations/IT/Tutorial/ml.tex | 174 +- .../IT/Tutorial/more-examples.tex | 56 +- Manual/Translations/IT/Tutorial/parity.tex | 372 +-- Manual/Translations/IT/Tutorial/preface.tex | 56 +- .../Translations/IT/Tutorial/proof-tools.tex | 488 ++-- Manual/Translations/IT/Tutorial/tutorial.tex | 4 +- .../ARM_security_properties/ARM_proverLib.sig | 10 +- .../ARM_prover_extLib.sig | 12 +- .../ARM_security_properties/MMUScript.sml | 128 +- .../MMU_SetupScript.sml | 78 +- .../inference_rulesScript.sml | 220 +- .../model/arm_seq_monadScript.sml | 2 +- .../switching_lemma_helperScript.sml | 554 ++-- .../ARM_security_properties/tacticsLib.sig | 6 +- .../ARM_security_properties/tacticsLib.sml | 24 +- .../user_lemma_basicsScript.sml | 142 +- .../examples/M1/complex_rationalScript.sml | 2 +- .../acl2_packageScript.sml | 2 +- .../complex_rationalScript.sml | 2 +- .../formal-languages/FormalLangScript.sml | 116 +- examples/pattern_match_demoScript.sml | 10 +- .../pattern_matches/constrFamiliesLib.sig | 26 +- .../pattern_matches/constrFamiliesLib.sml | 106 +- .../patternMatchesExamples.sml | 52 +- .../pattern_matches/patternMatchesLib.sig | 24 +- .../pattern_matches/patternMatchesLib.sml | 334 +-- .../pattern_matches/patternMatchesScript.sml | 88 +- .../pattern_matches/patternMatchesSyntax.sig | 50 +- .../pattern_matches/patternMatchesSyntax.sml | 80 +- .../src/holfoot/holfootLib.sml | 4 +- .../src/holfoot/holfootParser.sml | 2 +- .../src/holfoot/holfoot_pp_print.sml | 4 +- .../src/vars_as_resourceBaseFunctor.sml | 4 +- examples/set-theory/zfset/zfsetScript.sml | 6 +- src/1/Tactical.sig | 2 +- src/1/Tactical.sml | 6 +- src/HolSmt/Yices.sml | 2 +- src/IndDef/CoIndDefLib.sml | 2 +- src/holyhammer/hhReconstruct.sml | 16 +- src/holyhammer/holyHammer.sml | 4 +- src/num/theories/prim_recScript.sml | 12 +- src/prekernel/Dep.sml | 6 +- .../quantHeuristicsLibBase.sml | 2 +- src/rational/fracScript.sml | 4 +- src/search/dftScript.sml | 106 +- 62 files changed, 7253 insertions(+), 7253 deletions(-) diff --git a/Manual/Translations/IT/Description/QuantHeuristics.tex b/Manual/Translations/IT/Description/QuantHeuristics.tex index cd70f7e016..acb16e83ff 100644 --- a/Manual/Translations/IT/Description/QuantHeuristics.tex +++ b/Manual/Translations/IT/Description/QuantHeuristics.tex @@ -13,7 +13,7 @@ \subsection{Motivation} and \[ \exists x_1\ \ldots x_i \ldots x_n.\ P_1 \wedge \ldots \wedge x_i = c \wedge \ldots \wedge P_n \] can be simplified by -instantiating $x_i$ with $c$. Because unwind-conversions are +instantiating $x_i$ with $c$. Because unwind-conversions are part of \holtxt{bool\_ss}, they are used with nearly every call of the simplifier and often simplify proofs considerably. However, the \ml{Unwind} library can only handle these common cases. If the term structure is only slightly more complicated, it fails. For example, $\exists x.\ P(x) \Longrightarrow (x = 2) \wedge Q(x)$ @@ -50,10 +50,10 @@ \subsection{Motivation} $\forall x.\ x = 2$ & $\textit{false}$ \\ \mytablehead{complicated nestings of standard operators} -$\exists x_1. \forall x_2.\ (x_1 = 2) \wedge P(x_1, x_2)$ & +$\exists x_1. \forall x_2.\ (x_1 = 2) \wedge P(x_1, x_2)$ & $\forall x_2.\ P(2, x_2)$ \\ -$\exists x_1, x_2.\ P_1(x_2) \Longrightarrow (x_1 = 2) \wedge P(x_1, x_2)$ & +$\exists x_1, x_2.\ P_1(x_2) \Longrightarrow (x_1 = 2) \wedge P(x_1, x_2)$ & $\exists x_2.\ P_1(x_2) \Longrightarrow P(2, x_2)$ \\ $\exists x.\ ((x = 2) \vee (2 = x)) \wedge P(x)$ & $P(2)$ \\ @@ -89,7 +89,7 @@ \subsection{User Interface}\label{sec_interface} The quantifier heuristics library can be found in the sub-directory \holtxt{src/quantHeuristics}. The entry point to the framework is the -library \holtxt{quantHeuristicsLib}. +library \holtxt{quantHeuristicsLib}. \subsubsection{Conversions} Usually the library is used for @@ -102,15 +102,15 @@ \subsubsection{Conversions} \texttt{QUANT\_INSTANTIATE\_CONV} & \texttt{: quant\_param list -> conv} \\ \texttt{QUANT\_INST\_ss} & \texttt{: quant\_param list -> ssfrag} \\ \texttt{QUANT\_INSTANTIATE\_TAC} & \texttt{: quant\_param list -> tactic} \\ -\texttt{ASM\_QUANT\_INSTANTIATE\_TAC} & \texttt{: quant\_param list -> tactic} +\texttt{ASM\_QUANT\_INSTANTIATE\_TAC} & \texttt{: quant\_param list -> tactic} \end{tabular} \bigskip All these functions get a list of \emph{quantifier heuristic parameters} as arguments. These parameters essentially configure, which heuristics are used during the guess-search. If an empty list is provided, the tools know about the standard Boolean combinators, equations and context. -\texttt{std\_qp} adds support for common datatypes like pairs or lists. -Quantifier heuristic parameters are explained in more detail in +\texttt{std\_qp} adds support for common datatypes like pairs or lists. +Quantifier heuristic parameters are explained in more detail in Section~\ref{quantHeu_subsec_qps}. So, some simple usage of the quantifier heuristic library looks like: @@ -127,7 +127,7 @@ \subsubsection{Conversions} Usually, the quantifier heuristics library is used together with the simplifier using \holtxt{QUANT\_INST\_ss}. Besides interleaving -simplification and quantifier instantiation, this has the benefit of +simplification and quantifier instantiation, this has the benefit of being able to use context information collected by the simplifier: \begin{session} @@ -172,32 +172,32 @@ \subsubsection{Unjustified Guesses} However, $2$ looks tempting and is probably sensible in many situations. (Counterexample: $P(2)$, $\neg Q(2)$ and $\neg P(3)$ hold) -\texttt{implication\_concl\_qp} is a quantifier parameter that looks for valid guesses in the conclusion of an implication. -Then, it assumes without justification that these guesses are probably sensible for the whole implication as well. +\texttt{implication\_concl\_qp} is a quantifier parameter that looks for valid guesses in the conclusion of an implication. +Then, it assumes without justification that these guesses are probably sensible for the whole implication as well. Because these guesses might be wrong, one can either use implications or expansion theorems like $\exists x.\ P(x)\ \Longleftrightarrow (\forall x.\ x \neg c \Rightarrow \neg P(x)) \Rightarrow P(c)$. \begin{session} \begin{verbatim} -- QUANT_INSTANTIATE_CONV [implication_concl_qp] +- QUANT_INSTANTIATE_CONV [implication_concl_qp] ``?x. P x ==> (x = 2) /\ Q x`` Exception- UNCHANGED raised -- QUANT_INSTANTIATE_CONSEQ_CONV [implication_concl_qp] - CONSEQ_CONV_STRENGTHEN_direction +- QUANT_INSTANTIATE_CONSEQ_CONV [implication_concl_qp] + CONSEQ_CONV_STRENGTHEN_direction ``?x. P x ==> (x = 2) /\ Q x`` > val it = |- (P 2 ==> Q 2) ==> ?x. P x ==> (x = 2) /\ Q x: thm -- EXPAND_QUANT_INSTANTIATE_CONV [implication_concl_qp] +- EXPAND_QUANT_INSTANTIATE_CONV [implication_concl_qp] ``?x. P x ==> (x = 2) /\ Q x`` > val it = |- (?x. P x ==> (x = 2) /\ Q x) <=> (!x. x <> 2 ==> ~(P x ==> (x = 2) /\ Q 2)) ==> P 2 ==> Q 2 -- SIMP_CONV (std_ss++EXPAND_QUANT_INST_ss [implication_concl_qp]) [] +- SIMP_CONV (std_ss++EXPAND_QUANT_INST_ss [implication_concl_qp]) [] ``?x. P x ==> (x = 2) /\ Q x`` > val it = - |- (?x. P x ==> (x = 2) /\ Q x) <=> + |- (?x. P x ==> (x = 2) /\ Q x) <=> (!x. x <> 2 ==> P x) ==> P 2 ==> Q 2: thm \end{verbatim} \end{session} @@ -210,7 +210,7 @@ \subsubsection{Unjustified Guesses} \texttt{QUANT\_INSTANTIATE\_CONSEQ\_CONV} & \texttt{: quant\_param list -> directed\_conseq\_conv} \\ \texttt{EXPAND\_QUANT\_INSTANTIATE\_CONV} & \texttt{: quant\_param list -> conv} \\ \texttt{EXPAND\_QUANT\_INST\_ss} & \texttt{: quant\_param list -> ssfrag} \\ -\texttt{QUANT\_INSTANTIATE\_CONSEQ\_TAC} & \texttt{: quant\_param list -> tactic} +\texttt{QUANT\_INSTANTIATE\_CONSEQ\_TAC} & \texttt{: quant\_param list -> tactic} \end{tabular} @@ -219,8 +219,8 @@ \subsubsection{Explicit Instantiations} A special (degenerated) use of the framework, is turning guess search off completely and providing instantiations explicitly. The tactic \holtxt{QUANT\_TAC} allows this. This means that it allows to partially instantiate quantifiers at subpositions -with explicitly given terms. As such, it can be seen as -a generalisation of \holtxt{EXISTS\_TAC}\index{EXISTS\_TAC}. +with explicitly given terms. As such, it can be seen as +a generalisation of \holtxt{EXISTS\_TAC}\index{EXISTS\_TAC}. % \begin{session} \begin{verbatim} @@ -230,7 +230,7 @@ \subsubsection{Explicit Instantiations} - val it = !x. ( P x 0) ==> ? b a'. Q (SUC a') b z : proof \end{verbatim} \end{session} -% +% This tactic is implemented using unjustified guesses. It normally produces implications, which is fine when used as a tactic. There is also a conversion called \holtxt{INST\_QUANT\_CONV} with the same @@ -250,8 +250,8 @@ \subsection{Quantifier Heuristic Parameters}\label{quantHeu_subsec_qps} \subsubsection{Quantifier Heuristic Parameters for Common Datatypes} -There are \holtxt{option\_qp}, \holtxt{list\_qp}, \holtxt{num\_qp} and \holtxt{sum\_qp} for option types, lists, -natural numbers and sum types respectively. +There are \holtxt{option\_qp}, \holtxt{list\_qp}, \holtxt{num\_qp} and \holtxt{sum\_qp} for option types, lists, +natural numbers and sum types respectively. Some examples are displayed in the following table: % \[\begin{array}{r@{\quad \Longleftrightarrow \quad}l} @@ -259,13 +259,13 @@ \subsubsection{Quantifier Heuristic Parameters for Common Datatypes} \forall x.\ \holtxt{IS\_NONE}(x)& \textit{false} \\ \forall l.\ l \neq [\,] \Rightarrow P(l)& \forall h, l'.\ P(h::l') \\ \forall x.\ x = c + 3& \textit{false} \\ -\forall x.\ x \neq 0 \Rightarrow P(x)& \forall x'.\ P(\holtxt{SUC}(x')) +\forall x.\ x \neq 0 \Rightarrow P(x)& \forall x'.\ P(\holtxt{SUC}(x')) \end{array}\] \subsubsection{Quantifier Heuristic Parameters for Tuples} For tuples the situation is peculiar, because each quantifier over a variable of a product type -can be instantiated. The challenge is to decide which quantifiers should be instantiated and +can be instantiated. The challenge is to decide which quantifiers should be instantiated and which new variable names to use for the components of the pair. There is a quantifier heuristic parameter called \holtxt{pair\_default\_qp}. It first looks for subterms of the form $(\lambda (x_1, \ldots, x_n).\ \ldots)\ x$. If such a term is found $x$ is instantiated with @@ -274,7 +274,7 @@ \subsubsection{Quantifier Heuristic Parameters for Tuples} % \[\begin{array}{r@{\quad \Longleftrightarrow \quad}l} \forall p.\ (x = \holtxt{SND}(p)) \Rightarrow P(p)& \forall p_1.\ P(p_1, x) \\ -\exists p.\ (\lambda (p_a, p_b, p_c). P(p_a, p_b, p_c))\ p & \exists p_a, p_b, p_c.\ P(p_a, p_b, p_c) +\exists p.\ (\lambda (p_a, p_b, p_c). P(p_a, p_b, p_c))\ p & \exists p_a, p_b, p_c.\ P(p_a, p_b, p_c) \end{array}\] \holtxt{pair\_default\_qp} is implemented in terms of the more general @@ -322,7 +322,7 @@ \subsection{User defined Quantifier Heuristic Parameters}\label{sec_qps_user} The user is also able to define own parameters. There is \holtxt{empty\_qp}, which does not contain any information. Several -parameters can be combined using +parameters can be combined using \holtxt{combine\_qps}. Together with the basic types of user defined parameters that are explained below, these functions provide an interface for user defined quantifier heuristic parameters. @@ -336,7 +336,7 @@ \subsubsection{Rewrites / Conversions} rewriting \holtxt{IS\_SOME(x)} to \holtxt{?x'. x = SOME(x')}, however, these rules fire. -\holtxt{option\_qp} uses this rewrite to implement support for +\holtxt{option\_qp} uses this rewrite to implement support for \holtxt{IS\_SOME}. Similarly support for predicates like \holtxt{NULL} is implemented using rewrites. Even adding rewrites like $\textsf{append}(l_1, l_2) = [\,] \Longleftrightarrow (l_1 = @@ -349,16 +349,16 @@ \subsubsection{Rewrites / Conversions} \begin{session} \begin{verbatim} -> val thm = QUANT_INSTANTIATE_CONV [] ``!x. IS_SOME x ==> P x`` +> val thm = QUANT_INSTANTIATE_CONV [] ``!x. IS_SOME x ==> P x`` Exception- UNCHANGED raised -> val IS_SOME_EXISTS = prove (``IS_SOME x = (?x'. x = SOME x')``, +> val IS_SOME_EXISTS = prove (``IS_SOME x = (?x'. x = SOME x')``, Cases_on `x` THEN SIMP_TAC std_ss []); val IS_SOME_EXISTS = |- IS_SOME x <=> ?x'. x = SOME x': thm -> val thm = QUANT_INSTANTIATE_CONV [rewrite_qp[IS_SOME_EXISTS]] - ``!x. IS_SOME x ==> P x`` -val thm = |- (!x. IS_SOME x ==> P x) <=> +> val thm = QUANT_INSTANTIATE_CONV [rewrite_qp[IS_SOME_EXISTS]] + ``!x. IS_SOME x ==> P x`` +val thm = |- (!x. IS_SOME x ==> P x) <=> !x'. IS_SOME (SOME x') ==> P (SOME x'): thm \end{verbatim} \end{session} @@ -367,8 +367,8 @@ \subsubsection{Rewrites / Conversions} \holtxt{final\_rewrite\_qp}. \begin{session} \begin{verbatim} -> val thm = QUANT_INSTANTIATE_CONV [rewrite_qp[IS_SOME_EXISTS], - final_rewrite_qp[option_CLAUSES]] +> val thm = QUANT_INSTANTIATE_CONV [rewrite_qp[IS_SOME_EXISTS], + final_rewrite_qp[option_CLAUSES]] ``!x. IS_SOME x ==> P x`` val thm = |- (!x. IS_SOME x ==> P x) <=> !x'. P (SOME x'): thm \end{verbatim} @@ -377,7 +377,7 @@ \subsubsection{Rewrites / Conversions} If rewrites are not enough, \holtxt{conv\_qp} can be used to add conversions: \begin{session} \begin{verbatim} -- val thm = QUANT_INSTANTIATE_CONV [] ``?x. (\y. y = 2) x`` +- val thm = QUANT_INSTANTIATE_CONV [] ``?x. (\y. y = 2) x`` Exception- UNCHANGED raised - val thm = QUANT_INSTANTIATE_CONV [convs_qp[BETA_CONV]] ``?x. (\y. y = 2) x`` @@ -393,46 +393,46 @@ \subsubsection{Strengthening / Weakening} \begin{session} \begin{verbatim} -- val thm = QUANT_INSTANTIATE_CONV [list_qp] ``!l. 0 < LENGTH l ==> P l`` +- val thm = QUANT_INSTANTIATE_CONV [list_qp] ``!l. 0 < LENGTH l ==> P l`` Exception- UNCHANGED raised -- val LENGTH_LESS_IMP = prove (``!l n. n < LENGTH l ==> l <> []``, +- val LENGTH_LESS_IMP = prove (``!l n. n < LENGTH l ==> l <> []``, Cases_on `l` THEN SIMP_TAC list_ss []); > val LENGTH_LESS_IMP = |- !l n. n < LENGTH l ==> l <> []: thm -- val thm = QUANT_INSTANTIATE_CONV [imp_qp[LENGTH_LESS_IMP], list_qp] +- val thm = QUANT_INSTANTIATE_CONV [imp_qp[LENGTH_LESS_IMP], list_qp] ``!l. 0 < LENGTH l ==> P l`` > val thm = |- (!l. 0 < LENGTH l ==> P l) <=> !l_t l_h. 0 < LENGTH (l_h::l_t) ==> P (l_h::l_t): thm -- val thm = SIMP_CONV (list_ss ++ - QUANT_INST_ss [imp_qp[LENGTH_LESS_IMP], list_qp]) [] +- val thm = SIMP_CONV (list_ss ++ + QUANT_INST_ss [imp_qp[LENGTH_LESS_IMP], list_qp]) [] ``!l. SUC (SUC n) < LENGTH l ==> P l`` > val thm = |- (!l. SUC (SUC n) < LENGTH l ==> P l) <=> - !l_h l_t_h l_t_t_t l_t_t_h. n < SUC (LENGTH l_t_t_t) ==> + !l_h l_t_h l_t_t_t l_t_t_h. n < SUC (LENGTH l_t_t_t) ==> P (l_h::l_t_h::l_t_t_h::l_t_t_t): thm \end{verbatim} \end{session} - + \subsubsection{Filtering} -Sometimes, one might want to avoid to instantiate certain quantifiers. +Sometimes, one might want to avoid to instantiate certain quantifiers. The function \holtxt{filter\_qp} allows to add ML-functions that filter the handled -quantifiers. These functions are given a variable $x$ and a term $P(x)$. +quantifiers. These functions are given a variable $x$ and a term $P(x)$. The tool only tries to instantiate $x$ in $P(x)$, if all filter functions -return \textit{true}. +return \textit{true}. \begin{session} \begin{verbatim} -- val thm = QUANT_INSTANTIATE_CONV [] +- val thm = QUANT_INSTANTIATE_CONV [] ``?x y z. (x = 1) /\ (y = 2) /\ (z = 3) /\ P (x, y, z)`` -> val thm = |- (?x y z. (x = 1) /\ (y = 2) /\ (z = 3) /\ P (x,y,z)) <=> +> val thm = |- (?x y z. (x = 1) /\ (y = 2) /\ (z = 3) /\ P (x,y,z)) <=> P (1,2,3): thm -- val thm = QUANT_INSTANTIATE_CONV - [filter_qp [fn v => fn t => (v = ``y:num``)]] +- val thm = QUANT_INSTANTIATE_CONV + [filter_qp [fn v => fn t => (v = ``y:num``)]] ``?x y z. (x = 1) /\ (y = 2) /\ (z = 3) /\ P (x, y, z)`` > val thm = |- (?x y z. (x = 1) /\ (y = 2) /\ (z = 3) /\ P (x,y,z)) <=> ?x z. (x = 1) /\ (z = 3) /\ P (x,2,z): thm @@ -441,20 +441,20 @@ \subsubsection{Filtering} \subsubsection{Satisfying and Contradicting Instantiations} -As the satisfy library demonstrates, it is often -useful to use unification and explicitly given theorems to +As the satisfy library demonstrates, it is often +useful to use unification and explicitly given theorems to find instantiations. In addition to satisfying instantiations, the quantifier heuristics framework is also able to use contradicting ones. The theorems used for finding instantiations usually come from the context. However, \holtxt{instantiation\_qp} allows to add additional ones: \begin{session} \begin{verbatim} -> val thm = SIMP_CONV (std_ss++QUANT_INST_ss[]) [] +> val thm = SIMP_CONV (std_ss++QUANT_INST_ss[]) [] ``P n ==> ?m:num. n <= m /\ P m`` Exception- UNCHANGED raised > val thm = SIMP_CONV (std_ss++ - QUANT_INST_ss[instantiation_qp[LESS_EQ_REFL]]) [] + QUANT_INST_ss[instantiation_qp[LESS_EQ_REFL]]) [] ``P n ==> ?m:num. n <= m /\ P m`` > val thm = |- P n ==> ?m:num. n <= m /\ P m = T : thm \end{verbatim} @@ -464,15 +464,15 @@ \subsubsection{Di- and Monochotomies} Dichotomies can be exploited for guess search. \holtxt{distinct\_qp} provides an interface to add theorems -of the form $\forall x.\ c_1(x) \neq c_2(x)$. +of the form $\forall x.\ c_1(x) \neq c_2(x)$. \holtxt{cases\_qp} expects theorems of the form -$\forall x. \ (x = \exists \textit{fv}. c_1(\textit{fv}))\ \vee \ldots \vee (x = \exists \textit{fv}. c_n(\textit{fv}))$. +$\forall x. \ (x = \exists \textit{fv}. c_1(\textit{fv}))\ \vee \ldots \vee (x = \exists \textit{fv}. c_n(\textit{fv}))$. However, only theorems for $n = 2$ and $n = 1$ are used. All other cases are currently ignored. \subsubsection{Oracle Guesses} Sometimes, the user does not want to justify guesses. The tactic -\holtxt{QUANT\_TAC} is implemented using oracle guesses for example. +\holtxt{QUANT\_TAC} is implemented using oracle guesses for example. A simple interface to oracle guesses is provided by \holtxt{oracle\_qp}. It expects a ML function that given a variable and a term returns a pair of an instantiation and the free variables in this instantiation. @@ -494,15 +494,15 @@ \subsubsection{Oracle Guesses} \noindent Notice, that an option type is returned and that the function is -allowed to throw \holtxt{HOL\_ERR} exceptions. +allowed to throw \holtxt{HOL\_ERR} exceptions. With this definition, we get \begin{session} \begin{verbatim} -- NORE_QUANT_INSTANTIATE_CONSEQ_CONV [dummy_list_qp] +- NORE_QUANT_INSTANTIATE_CONSEQ_CONV [dummy_list_qp] CONSEQ_CONV_STRENGTHEN_direction ``?x:'a list y:'b. P (x, y)`` > val it = ?y x_hd x_tl. P (x_hd::x_tl,y)) ==> ?x y. P (x,y) : thm -\end{verbatim} +\end{verbatim} \end{session} \subsubsection{Lifting Theorems} diff --git a/Manual/Translations/IT/Description/definitions.tex b/Manual/Translations/IT/Description/definitions.tex index e648c4fed8..c717515941 100644 --- a/Manual/Translations/IT/Description/definitions.tex +++ b/Manual/Translations/IT/Description/definitions.tex @@ -7,15 +7,15 @@ \section{I Datatype}\label{sec:datatype} \index{tipi di dato!definizione in HOL@definizione in \HOL{}} \index{tipi di dato!definizione in HOL@definizione in \HOL{}|seealso{\ml{Hol\_datatype}}} -Nonostante la logica \HOL{} fornisca principi primitivi di definizione -che permettono di introdurre nuovi tipi, il livello di dettaglio -a grana molto fine. Lo stile delle definizioni di datatype nei linguaggi -di programmazione funzionale fornisce una motivazione per un interfaccia di +Nonostante la logica \HOL{} fornisca principi primitivi di definizione +che permettono di introdurre nuovi tipi, il livello di dettaglio +a grana molto fine. Lo stile delle definizioni di datatype nei linguaggi +di programmazione funzionale fornisce una motivazione per un interfaccia di alto livello per definire datatype algebrici. -La funzione \verb+Hol_datatype+ supporta la definizione di tali -tipi di dato; le specifiche dei tipi possono essere ricorsive, mutuamente -ricorsive, ricorsive annidate, e coinvolgere record. La sintassi delle +La funzione \verb+Hol_datatype+ supporta la definizione di tali +tipi di dato; le specifiche dei tipi possono essere ricorsive, mutuamente +ricorsive, ricorsive annidate, e coinvolgere record. La sintassi delle dichiarazioni che \verb+Hol_datatype+ accetta si trova nella Tabella \ref{datatype}. @@ -59,26 +59,26 @@ \section{I Datatype}\label{sec:datatype} \index{definizioni di tipo, nella logica HOL@definizioni di tipo, nella logica \HOL{}!mantenimento della TypeBase@mantenimento della \ml{TypeBase}} \index{TypeBase@\ml{TypeBase}} % -\HOL{} mantiene un database sottostante di fatti datatype chiamata la -\ml{TypeBase}. Questo database usato per supportare vari strumenti -di dimostrazione di alto livello (si veda la Sezione~\ref{sec:bossLib}), ed aumentato ogni volta -che si fa una dichiarazione \verb+Hol_datatype+. Quando un datatype -definito per mezzo di \verb+Hol_datatype+, la seguente informazione derivata +\HOL{} mantiene un database sottostante di fatti datatype chiamata la +\ml{TypeBase}. Questo database usato per supportare vari strumenti +di dimostrazione di alto livello (si veda la Sezione~\ref{sec:bossLib}), ed aumentato ogni volta +che si fa una dichiarazione \verb+Hol_datatype+. Quando un datatype +definito per mezzo di \verb+Hol_datatype+, la seguente informazione derivata e archiviata nel database. \begin{itemize} -\item teorema d'inizializzazione per il tipo -\item iniettivit dei costruttori +\item teorema d'inizializzazione per il tipo +\item iniettivit dei costruttori \item distinzione dei costruttori \item teorema d'induzione strutturale \item teorema di analisi dei casi -\item definizione della costante `case' per il tipo +\item definizione della costante `case' per il tipo \item teorema di congruenza per la costante case \item definizione della `dimensione' del tipo \end{itemize} -Quando il sistema \HOL{} -si avvia, la \ml{TypeBase} contiene gi le voci rilevanti per +Quando il sistema \HOL{} +si avvia, la \ml{TypeBase} contiene gi le voci rilevanti per i tipi \holtxt{bool}, \holtxt{prod}, \holtxt{num}, \holtxt{option}, e \holtxt{list}. @@ -90,24 +90,24 @@ \section{I Datatype}\label{sec:datatype} | Node of ('a,'b) btree * 'b * ('a,'b) btree \end{verbatim} \end{hol} -\noindent sarebbe dichiarata in \HOL{} come +\noindent sarebbe dichiarata in \HOL{} come \begin{hol} \begin{verbatim} Hol_datatype `btree = Leaf of 'a | Node of btree => 'b => btree` \end{verbatim} \end{hol} -\noindent La notazione \holtxt{=>} in una descrizione di datatype HOL - intesa sostituire \holtxt{*} in una descrizione di datatype ML, -e evidenzia il fatto che, in HOL, i costruttori sono di default -curried. Si noti anche che non menzionato alcun parametro di tipo +\noindent La notazione \holtxt{=>} in una descrizione di datatype HOL + intesa sostituire \holtxt{*} in una descrizione di datatype ML, +e evidenzia il fatto che, in HOL, i costruttori sono di default +curried. Si noti anche che non menzionato alcun parametro di tipo per il nuovo tipo: le variabili di tipo sono sempre in ordine alfabetivo. -Vale la pena ripetere questo punto delicato: il formato delle definizioni di datatype -non ha abbastanza informazione per determinare sempre l'ordine degli -argomenti per gli operatori di tipo introdotti. Cos, quando si definisce un tipo -che polimorfico in pi di un argomento, c' la questione di -quale sar l'ordine degli argomenti del nuovo operatore. Per un altro +Vale la pena ripetere questo punto delicato: il formato delle definizioni di datatype +non ha abbastanza informazione per determinare sempre l'ordine degli +argomenti per gli operatori di tipo introdotti. Cos, quando si definisce un tipo +che polimorfico in pi di un argomento, c' la questione di +quale sar l'ordine degli argomenti del nuovo operatore. Per un altro esempio, se si definisce % \begin{hol} @@ -116,17 +116,17 @@ \section{I Datatype}\label{sec:datatype} \end{verbatim} \end{hol} % -e poi si scrive \ml{('a,'b)sum}, il valore \ml{'a} sar sotto il -costruttore \ml{Left} o \ml{Right}? Il sistema sceglie di far apparire -gli argomenti corrispondenti alla variabili nell'ordine dato dall'ordine -alfabetico dei nomi delle variabili. Cos, nell'esempio -dato, l'\ml{'a} di \ml{('a,'b)sum} sar l'argomento \ml{Left} -perch \ml{left} viene prima di \ml{right} nell'ordine alfabetico +e poi si scrive \ml{('a,'b)sum}, il valore \ml{'a} sar sotto il +costruttore \ml{Left} o \ml{Right}? Il sistema sceglie di far apparire +gli argomenti corrispondenti alla variabili nell'ordine dato dall'ordine +alfabetico dei nomi delle variabili. Cos, nell'esempio +dato, l'\ml{'a} di \ml{('a,'b)sum} sar l'argomento \ml{Left} +perch \ml{left} viene prima di \ml{right} nell'ordine alfabetico standard (ASCII). \subsection{Ulteriori esempi} -Nel seguito, daremo una panoramica del genere di tipi che +Nel seguito, daremo una panoramica del genere di tipi che possono essere definiti per mezzo di \ml{Hol\_datatype}. Per iniziare, i tipi enumerati possono essere definiti come nel seguente esempio: @@ -153,8 +153,8 @@ \subsection{Ulteriori esempi} \end{verbatim} \end{hol} % -Spostandoci ai tipi ricorsivi, abbiamo gi visto un tipo di alberi -binari che hanno valori polimorfici presso i nodi interni. Questa volta, +Spostandoci ai tipi ricorsivi, abbiamo gi visto un tipo di alberi +binari che hanno valori polimorfici presso i nodi interni. Questa volta, li dichiareremo in formato ``accoppiato''. \begin{hol} \begin{verbatim} @@ -164,8 +164,8 @@ \subsection{Ulteriori esempi} \end{verbatim} \end{hol} % -Questa specifica sembra pi vicina alla dichiarazione che si potrebbe fare -in ML, ma pu essere pi difficile da gestire nella dimostrazione rispetto al +Questa specifica sembra pi vicina alla dichiarazione che si potrebbe fare +in ML, ma pu essere pi difficile da gestire nella dimostrazione rispetto al formato curried usato di sopra. La sintassi di base del lambda calcolo denominato facile da descrivere: @@ -193,8 +193,8 @@ \subsection{Ulteriori esempi} \end{verbatim} \end{hol} % -Gli alberi arbitrariamente ramificanti possono essere definiti permettendo a un nodo di mantenere -la lista dei suoi sotto-alberi. In un tale caso, i nodi foglia non hanno bisogno di essere +Gli alberi arbitrariamente ramificanti possono essere definiti permettendo a un nodo di mantenere +la lista dei suoi sotto-alberi. In un tale caso, i nodi foglia non hanno bisogno di essere dichiarati esplicitamente. % \begin{hol} @@ -214,8 +214,8 @@ \subsection{Ulteriori esempi} \end{verbatim} \end{hol} % -Possono anche essere definiti tipi mutuamente ricorsivi. Il seguente, estratto -da Elsa Gunter da Definition of Standard ML, cattura un sottoinsieme di +Possono anche essere definiti tipi mutuamente ricorsivi. Il seguente, estratto +da Elsa Gunter da Definition of Standard ML, cattura un sottoinsieme di Core ML. % \begin{hol} @@ -255,7 +255,7 @@ \subsection{Ulteriori esempi} \end{verbatim} \end{hol} % -L'uso di tipi record pu essere ricorsivo. Per esempio, la seguente +L'uso di tipi record pu essere ricorsivo. Per esempio, la seguente dichiarazione potrebbe essere usata per formalizzare un semplice file system. % \begin{hol} @@ -270,12 +270,12 @@ \subsection{Ulteriori esempi} \subsection{Definizioni di tipo che falliscono} -Ora ci rivolgiamo ad alcuni tipi che non possono essere dichiarati con \ml{Hol\_datatype}. -In alcuni casi essi non possono esistere del tutto in HOL; in altri, il tipo -pu essere incorporato nella logica HOL, ma \ml{Hol\_datatype} non in grado di rendere +Ora ci rivolgiamo ad alcuni tipi che non possono essere dichiarati con \ml{Hol\_datatype}. +In alcuni casi essi non possono esistere del tutto in HOL; in altri, il tipo +pu essere incorporato nella logica HOL, ma \ml{Hol\_datatype} non in grado di rendere la definizione. -Per prima cosa, un tipo vuoto non permesso in HOL, cos il seguente tentativo +Per prima cosa, un tipo vuoto non permesso in HOL, cos il seguente tentativo destinato a fallire. % \begin{hol} @@ -285,7 +285,7 @@ \subsection{Definizioni di tipo che falliscono} \end{verbatim} \end{hol} % -I cosiddetti `tipi annidati', che occasionalmente sono piuttosto utili, non possono +I cosiddetti `tipi annidati', che occasionalmente sono piuttosto utili, non possono al momento essere costruiti con \ml{Hol\_datatype}: % \begin{hol} @@ -296,9 +296,9 @@ \subsection{Definizioni di tipo che falliscono} \end{verbatim} \end{hol} % -I tipi non possono eseguire la ricorsione su entrambi i lati delle frecce funzione. La ricorsione -sulla destra coerente (si veda la teoria \theoryimp{inftree}), ma -\ml{Hol\_datatype} non in grado di definire tipi algebrici che +I tipi non possono eseguire la ricorsione su entrambi i lati delle frecce funzione. La ricorsione +sulla destra coerente (si veda la teoria \theoryimp{inftree}), ma +\ml{Hol\_datatype} non in grado di definire tipi algebrici che la richiedono. Cos, esempi come il seguente falliranno: % \begin{hol} @@ -309,9 +309,9 @@ \subsection{Definizioni di tipo che falliscono} \end{verbatim} \end{hol} % -La ricorsione sulla sinistra deve fallire per ragioni di cardinalit. Per -esempio, HOL non permette il seguente tentativo di modellare il lambda -calcolo non tipizzato come un insieme (si noti la \holtxt{->} nella clausola per il +La ricorsione sulla sinistra deve fallire per ragioni di cardinalit. Per +esempio, HOL non permette il seguente tentativo di modellare il lambda +calcolo non tipizzato come un insieme (si noti la \holtxt{->} nella clausola per il costruttore \holtxt{Abs}): % \begin{hol} @@ -326,18 +326,18 @@ \subsection{Definizioni di tipo che falliscono} \subsection{Teoremi che sorgono da una definizione di datatype} -Le conseguenze di un'invocazione di \ml{Hol\_datatype} sono archiviate nell'attuale segmento di teoria e nella \ml{TypeBase}. -Le principali conseguenze di una definizione di datatype sono i teoremi di ricorsione primitiva e d'induzione. +Le conseguenze di un'invocazione di \ml{Hol\_datatype} sono archiviate nell'attuale segmento di teoria e nella \ml{TypeBase}. +Le principali conseguenze di una definizione di datatype sono i teoremi di ricorsione primitiva e d'induzione. Questi forniscono la capacit di definire semplici funzioni sul tipo, e un principio d'induzione per il tipo. \index{teoremi d'induzione, nella logica HOL@teoremi d'induzione, nella logica \HOL{}!per tipi di dato algenrico} Cos, per un tipo denominato \holtxt{ty}, il teorema di ricorsione primitiva archiviato sono \ml{ty\_Axiom} e il teorema d'induzione messo sotto \ml{ty\_induction}. -Altre conseguenze includono la distinzione dei costruttori (\ml{ty\_distinct}), e l'iniettivit dei costruttori (\verb+ty_11+). +Altre conseguenze includono la distinzione dei costruttori (\ml{ty\_distinct}), e l'iniettivit dei costruttori (\verb+ty_11+). Una versione `degenerata' di \ml{ty\_induction} anche archiviata sotto \ml{ty\_nchotomy}: essa prevede ragionamenti per casi sulla costruzione degli elementi di \ml{ty}. -Infine, sono archiviati alcuni teoremi per scopi speciali: per esempio, \ml{ty\_case\_cong} mantiene un teorema di congruenza per enunciati ``case'' su elementi di \ml{ty}. +Infine, sono archiviati alcuni teoremi per scopi speciali: per esempio, \ml{ty\_case\_cong} mantiene un teorema di congruenza per enunciati ``case'' su elementi di \ml{ty}. Questi enunciati case sono definiti da \ml{ty\_case\_def}. Inoltre, aggiunta alla teoria attuale una definizione della ``dimensione'' del tipo, sotto il nome \ml{ty\_size\_def}. -Per esempio, l'invocazione +Per esempio, l'invocazione % \begin{hol} \begin{verbatim} @@ -361,7 +361,7 @@ \subsection{Teoremi che sorgono da una definizione di datatype} \end{verbatim} \end{hol} % -sono aggiunte alla teoria attuale. I seguenti teoremi circa i datatype +sono aggiunte alla teoria attuale. I seguenti teoremi circa i datatype sono inoltre dimostrati e archiviati nella teoria attuale. % \begin{hol} @@ -390,30 +390,30 @@ \subsection{Teoremi che sorgono da una definizione di datatype} \end{verbatim} \end{hol} % -Quando definito un tipo che coinvolge record, molte pi definizioni sono +Quando definito un tipo che coinvolge record, molte pi definizioni sono fatte e aggiunte alla teoria attuale. -Una definizione di tipo mutuamente ricorsiva ha come risultato che i +Una definizione di tipo mutuamente ricorsiva ha come risultato che i teoremi e le definizioni di sopra sono aggiunte per ognuno dei tipi definiti. \section{Tipi Record}\label{sec:records} \index{definizioni di tipo, nella logica HOL@definizioni di tipo, nella logica \HOL{}!tipi record} \index{tipi record} -I tipi record sono dei modi convenienti d'impacchettare insieme un numero di -tipi componenti, e di dare a questi componenti dei nomi cos da facilitare -l'accesso ad essi. I tipi record sono semanticamente equivalenti a grandi -tipi coppia (prodotto), ma la possibilit di etichettare i campi con nomi di -propria scelta una grande comodit. I tipi record come -implementati in \HOL{} sono analoghi ai tipi \texttt{struct} del C e ai +I tipi record sono dei modi convenienti d'impacchettare insieme un numero di +tipi componenti, e di dare a questi componenti dei nomi cos da facilitare +l'accesso ad essi. I tipi record sono semanticamente equivalenti a grandi +tipi coppia (prodotto), ma la possibilit di etichettare i campi con nomi di +propria scelta una grande comodit. I tipi record come +implementati in \HOL{} sono analoghi ai tipi \texttt{struct} del C e ai record del Pascal. -Costruiti correttamente, i tipi record forniscono utili funzionalit di manutenibilit. -Se si pu sempre accedere al campo {\tt fieldn} di un tipo record -semplicemente scrivendo {\tt record.fieldn}, allora dei cambiamenti al tipo che -risultano nell'aggiunta o cancellazione di altri campi non invalideranno -questo riferimento. Una mancanza nei tipi record dell'SML che non -permettono la stessa manutenibilit quando sono interessati degli aggiornamenti +Costruiti correttamente, i tipi record forniscono utili funzionalit di manutenibilit. +Se si pu sempre accedere al campo {\tt fieldn} di un tipo record +semplicemente scrivendo {\tt record.fieldn}, allora dei cambiamenti al tipo che +risultano nell'aggiunta o cancellazione di altri campi non invalideranno +questo riferimento. Una mancanza nei tipi record dell'SML che non +permettono la stessa manutenibilit quando sono interessati degli aggiornamenti (funzionali) dei record. L'implementazione HOL permette di scrivere \begin{hol} \begin{verbatim} @@ -421,13 +421,13 @@ \section{Tipi Record}\label{sec:records} \end{verbatim} \end{hol} che sostituisce il vecchio valore di {\tt fieldn} nel record {\tt rec} -con {\tt new\_value}. Non sar necessario cambiare questa espressione se -un altro campo aggiunto, modificato o cancellato dalla definizione originale +con {\tt new\_value}. Non sar necessario cambiare questa espressione se +un altro campo aggiunto, modificato o cancellato dalla definizione originale del record. \paragraph{Definire un tipo record} -I tipi record sono definiti con la funzione \texttt{Hol\_datatype}, come -discusso in precedenza. Per esempio, per creare un tipo record chiamato +I tipi record sono definiti con la funzione \texttt{Hol\_datatype}, come +discusso in precedenza. Per esempio, per creare un tipo record chiamato {\tt person} con campi booleani, stringa e numero chiamati {\tt employed}, {\tt name} e {\tt age}, si inserirebbe: \begin{hol} @@ -438,28 +438,28 @@ \section{Tipi Record}\label{sec:records} name : string |>` \end{verbatim} \end{hol} -L'ordine in cui i campi sono inseriti non significativo. Oltre -a definire il tipo (chiamato {\tt person}), la funzione di definizione -di datatype definisce anche due altre insiemi di costanti. Queste sono le -funzioni di accesso al campo e le funzioni di aggiornamento funzionale. Le funzioni -di accesso al campo hanno nomi della forma +L'ordine in cui i campi sono inseriti non significativo. Oltre +a definire il tipo (chiamato {\tt person}), la funzione di definizione +di datatype definisce anche due altre insiemi di costanti. Queste sono le +funzioni di accesso al campo e le funzioni di aggiornamento funzionale. Le funzioni +di accesso al campo hanno nomi della forma $\langle$\textsl{record-type\/}$\rangle$\verb|_|$\langle$\textsl{field\/}$\rangle$. -Queste funzioni possono essere usate direttamente, o si pu usare la notazione standard -di accesso ai campi per accedere ai valori del campo di un record. Cos, -si scriverebbe l'espressione: \holtxt{bob.employed} allo scopo -di restituire il valore del campo {\tt employed} di {\tt bob}. -L'alternativa, \holtxt{person\_employed bob}, funziona, ma sarebbe +Queste funzioni possono essere usate direttamente, o si pu usare la notazione standard +di accesso ai campi per accedere ai valori del campo di un record. Cos, +si scriverebbe l'espressione: \holtxt{bob.employed} allo scopo +di restituire il valore del campo {\tt employed} di {\tt bob}. +L'alternativa, \holtxt{person\_employed bob}, funziona, ma sarebbe stampata usando la prima sintassi, con il punto.\index{tipi record!notazione di selezione dei campi} -Alle funzioni di aggiornamento funzionale sono dati i nomi -\mbox{``$\langle$\textsl{record-type}$\rangle$\texttt{\_}$\langle$\textsl{field}$\rangle$\texttt{\_fupd}''} -per ciascun campo nel -tipo. Esse prendono due argomenti, una funzione e un record da -aggiornare. Il parametro funzione un endomorfismo sul tipo del campo, -cos che il record risultante lo stesso dell'originale, eccetto per il fatto che -il campo specificato ha avuto la funzione applicata ad esso per -generare il nuovo valore per quel campo. Esse possono essere scritte con la -parola chiave \texttt{with} e l'operatore \texttt{updated\_by}. Cos che +Alle funzioni di aggiornamento funzionale sono dati i nomi +\mbox{``$\langle$\textsl{record-type}$\rangle$\texttt{\_}$\langle$\textsl{field}$\rangle$\texttt{\_fupd}''} +per ciascun campo nel +tipo. Esse prendono due argomenti, una funzione e un record da +aggiornare. Il parametro funzione un endomorfismo sul tipo del campo, +cos che il record risultante lo stesso dell'originale, eccetto per il fatto che +il campo specificato ha avuto la funzione applicata ad esso per +generare il nuovo valore per quel campo. Esse possono essere scritte con la +parola chiave \texttt{with} e l'operatore \texttt{updated\_by}. Cos che % \begin{hol} \begin{verbatim} @@ -468,11 +468,11 @@ \section{Tipi Record}\label{sec:records} \end{verbatim} \end{hol}\noindent % - un valore record identico a \texttt{bob} eccetto per il fatto che il + un valore record identico a \texttt{bob} eccetto per il fatto che il valore booleano nel campo \texttt{employed} stato invertito. -Inoltre, c' un addolcimento sintattico disponibile per permettere di scrivere un -record con uno dei suoi campi sostituito da un valore specifico. Questo +Inoltre, c' un addolcimento sintattico disponibile per permettere di scrivere un +record con uno dei suoi campi sostituito da un valore specifico. Questo fatto usando l'operatore \holtxt{:=} al posto di \holtxt{updated\_by}: % @@ -482,8 +482,8 @@ \section{Tipi Record}\label{sec:records} \end{verbatim} \end{hol} % -Questo forma tradotta al momento del parsing per essere un uso del corrispondente -aggiornamento funzionale, insieme con un udo del combinatorio-\textsf{K} dalla +Questo forma tradotta al momento del parsing per essere un uso del corrispondente +aggiornamento funzionale, insieme con un udo del combinatorio-\textsf{K} dalla teoria \texttt{combin}. Perci, l'esempio di sopra in realt % \begin{hol} @@ -500,8 +500,8 @@ \section{Tipi Record}\label{sec:records} \end{verbatim} \end{hol} % -Se si desidera una catena di aggiornamenti, allora gli aggiornamenti multipli possono essere -specificati all'interno di coppie \holtxt{<|}-\holtxt{|>}, separati da +Se si desidera una catena di aggiornamenti, allora gli aggiornamenti multipli possono essere +specificati all'interno di coppie \holtxt{<|}-\holtxt{|>}, separati da punti-e-virgola, cos: % \begin{hol} @@ -510,14 +510,14 @@ \section{Tipi Record}\label{sec:records} \end{verbatim} \end{hol} % -Entrambe le forme di aggiornamento (usando \texttt{updated\_by} e \texttt{:=}) possono essere +Entrambe le forme di aggiornamento (usando \texttt{updated\_by} e \texttt{:=}) possono essere usati in una catena di aggiornamenti. \paragraph{Specificare letterali record} -Il parser accetta liste di specifiche di campo tra coppie +Il parser accetta liste di specifiche di campo tra coppie \holtxt{<|}-\holtxt{|>} senza la parola chiave \holtxt{with}. -Queste sono tradotte in sequenze di aggiornamenti di un valore arbitrario +Queste sono tradotte in sequenze di aggiornamenti di un valore arbitrario (letteralmente, il valore HOL \holtxt{ARB}), e sono trattate come letterali. Cos, % @@ -529,20 +529,20 @@ \section{Tipi Record}\label{sec:records} \paragraph{Usare i teoremi prodotti da definizioni di record} -Oltre a definire il tipo e le funzioni descritti di sopra, una definizione -di tipo record dimostra anche una suite di utili teoremi. Questi sono tutti +Oltre a definire il tipo e le funzioni descritti di sopra, una definizione +di tipo record dimostra anche una suite di utili teoremi. Questi sono tutti salvati (usando {\tt save\_thm}) nel segmento attuale. % % \index{TypeBase@\ml{TypeBase}} % -Alcuni sono anche aggiunti alle semplificazioni della \ml{TypeBase} per il -tipo, cos saranno automaticamente applicati quando si semplifica con il +Alcuni sono anche aggiunti alle semplificazioni della \ml{TypeBase} per il +tipo, cos saranno automaticamente applicati quando si semplifica con il simpset \ml{srw\_ss()}, o con le tattiche \ml{RW\_TAC} e \ml{SRW\_TAC} (si veda la Sezione~\ref{sec:simpLib}). -Tutti i teoremi sono salvati sotto i nomi che cominciano con il nome del -tipo. La lista di sotto un esempio dei teoremi dimostrati. Le -stringhe d'identificazione sono suffissi appesi al nome del tipo al +Tutti i teoremi sono salvati sotto i nomi che cominciano con il nome del +tipo. La lista di sotto un esempio dei teoremi dimostrati. Le +stringhe d'identificazione sono suffissi appesi al nome del tipo al fine di generare il nome finale del teorema. \newcommand{\rewruse}{Questo teorema installato nella \texttt{TypeBase}.} @@ -552,10 +552,10 @@ \section{Tipi Record}\label{sec:records} \begin{description} \item[\texttt{\_accessors}] Le definizioni delle funzioni di accesso. \rewruse -\item[\texttt{\_fn\_updates}] Le definizioni delle funzioni di aggiornamento +\item[\texttt{\_fn\_updates}] Le definizioni delle funzioni di aggiornamento funzionale. -\item[\texttt{\_accfupds}] Un teorema che stabilisce forme pi semplici per - espressioni che sono della forma $\field{i}\, (\field{j}\update\;f\; r)$. Se +\item[\texttt{\_accfupds}] Un teorema che stabilisce forme pi semplici per + espressioni che sono della forma $\field{i}\, (\field{j}\update\;f\; r)$. Se $i = j$, allora il lato destro $f (\field{i}(r))$, se no, $(\field{i}\;r)$. \rewruse \item[\texttt{\_component\_equality}] Un teorema che stabilisce che $(r_1 = @@ -563,9 +563,9 @@ \section{Tipi Record}\label{sec:records} \item[\texttt{\_fupdfupds}] Un teorema che stabilisce che $\field{i}\update \;f \,(\field{i}\update \;g\;r) = \field{i}\update\;(f \circ g)\;r$. \rewruse -\item[\texttt{\_fupdcanon}] Un teorema che stabilisce i risultati di commutativit - per tutte le possibili coppie di aggiornamenti di campo. Essi sono costruiti in - un modo tale che se usati come riscritture, renderanno canoniche +\item[\texttt{\_fupdcanon}] Un teorema che stabilisce i risultati di commutativit + per tutte le possibili coppie di aggiornamenti di campo. Essi sono costruiti in + un modo tale che se usati come riscritture, renderanno canoniche le sequenze di aggiornamenti. Cos, per tutti gli $i < j$, generato \[ \field{j}\update\;f\;(\field{i}\update\;g\;r) = \field{i}\update\;g\;(\field{j}\update\;f\;r) @@ -573,28 +573,28 @@ \section{Tipi Record}\label{sec:records} \rewruse \end{description} -\paragraph{Record grandi} La dimensione di certi teoremi dimostrati nel -pacchetto tipi record cresce come il quadrato del numero di campi nel -record. (In particolare, i teoremi di canonicalizzazione dell'aggiornamento e -e i teoremi \texttt{acc\_fupd} hanno questa propriet.) Per evitare inefficienza -con record grandi, l'implementazione dei tipi record usa una -rappresentazione sottostante pi efficiente quando il numero dei campi cresce -troppo. Il punto esatto in cui applicata questa ottimizzazione applicata -controllato dalla variabile reference -\texttt{Datatype.big\_record\_size}. Questo valore inizializzato a 20, +\paragraph{Record grandi} La dimensione di certi teoremi dimostrati nel +pacchetto tipi record cresce come il quadrato del numero di campi nel +record. (In particolare, i teoremi di canonicalizzazione dell'aggiornamento e +e i teoremi \texttt{acc\_fupd} hanno questa propriet.) Per evitare inefficienza +con record grandi, l'implementazione dei tipi record usa una +rappresentazione sottostante pi efficiente quando il numero dei campi cresce +troppo. Il punto esatto in cui applicata questa ottimizzazione applicata +controllato dalla variabile reference +\texttt{Datatype.big\_record\_size}. Questo valore inizializzato a 20, ma gli utenti possono cambiarlo a scelta. -Sfortunatamente, la rappresentazione di record grandi ha lo svantaggio che -ogni funzione di aggiornamento e di accesso ha due forme: termini differenti che -sono stampati allo stesso modo. Una forma una semplice costante, ed la forma -prodotta quando un termine sottoposto al parsing. L'altra un p pi complicata, ma -ammette l'uso di teoremi pi piccoli quando dei valori record sono -semplificati. Di conseguenza, si raccomanda che i nuovi teoremi, dimostrati -dall'utente che menzionano campi di record grandi o aggiornamenti di campi passino -attraverso una fase di semplificazione (\texttt{SIMP\_RULE}), applicando le +Sfortunatamente, la rappresentazione di record grandi ha lo svantaggio che +ogni funzione di aggiornamento e di accesso ha due forme: termini differenti che +sono stampati allo stesso modo. Una forma una semplice costante, ed la forma +prodotta quando un termine sottoposto al parsing. L'altra un p pi complicata, ma +ammette l'uso di teoremi pi piccoli quando dei valori record sono +semplificati. Di conseguenza, si raccomanda che i nuovi teoremi, dimostrati +dall'utente che menzionano campi di record grandi o aggiornamenti di campi passino +attraverso una fase di semplificazione (\texttt{SIMP\_RULE}), applicando le riscritture della \texttt{TypeBase}, prima di essere salvati. -Il pretty-printing di record grandi pu essere controllato con il +Il pretty-printing di record grandi pu essere controllato con il flag di trace \texttt{pp\_bigrecs}. \index{Hol_datatype@\ml{Hol\_datatype}|)} @@ -603,34 +603,34 @@ \section{Tipi Quoziente}\label{quotients} \index{definizioni di tipo, nella logica HOL@definizioni di tipo, nella logica \HOL{}!quozienti|(} \index{tipi quoziente, definizione di} -\HOL{} fornisce una libreria per definire nuovi tipi che sono quozienti -di tipi esistenti, rispetto alle relazioni di equivalenza parziale. +\HOL{} fornisce una libreria per definire nuovi tipi che sono quozienti +di tipi esistenti, rispetto alle relazioni di equivalenza parziale. Questa libreria descritta in {\it ``Higher Order Quotients in Higher Order Logic''} [HOQ], da cui presa la seguente descrizione. -Si accede alla libreria quotient aprendo {\tt quotientLib}, +Si accede alla libreria quotient aprendo {\tt quotientLib}, il che rende accessibili tutti i suoi strumenti e teoremi. -La definizione di nuovi tipi corrispondenti ai quozienti di -tipi esistenti per relazioni di equivalenza chiamata ``sollevare'' -i tipi da un livello inferiore, pi rappresentativo a uno superiore -pi alto. Entrambi i livelli descrivono oggetti simili, ma -alcuni dettagli che sono evidenti al livello inferiore non sono pi +La definizione di nuovi tipi corrispondenti ai quozienti di +tipi esistenti per relazioni di equivalenza chiamata ``sollevare'' +i tipi da un livello inferiore, pi rappresentativo a uno superiore +pi alto. Entrambi i livelli descrivono oggetti simili, ma +alcuni dettagli che sono evidenti al livello inferiore non sono pi visibili al livello superiore. La logica semplificata. Formare semplicemente un nuovo tipo non completa l'operazione quoziente. -Piuttosto, si desidera ricreare +Piuttosto, si desidera ricreare %significant parts of the -l'ambiente logico pre-esistente al nuovo livello, -pi alto, e pi astratto. Questo include non solo i nuovi -tipi, ma anche le nuove versioni delle costanti che formano e -manipolano i valori di questi tipi, e anche le nuove versioni dei -teoremi che descrivono le propriet di queste costanti. Ognuna di queste +l'ambiente logico pre-esistente al nuovo livello, +pi alto, e pi astratto. Questo include non solo i nuovi +tipi, ma anche le nuove versioni delle costanti che formano e +manipolano i valori di questi tipi, e anche le nuove versioni dei +teoremi che descrivono le propriet di queste costanti. Ognuna di queste %must be recreated at the higher level, in order to -formano uno strato logico, sopra il quale tutti i dettagli rappresentazionali pi bassi +formano uno strato logico, sopra il quale tutti i dettagli rappresentazionali pi bassi si possono dimenticare con sicurezza e per sempre. -Questo si pu fare in una singola chiamata dello +Questo si pu fare in una singola chiamata dello strumento principale di questo pacchetto. \begin{hol} @@ -652,15 +652,15 @@ \section{Tipi Quoziente}\label{quotients} thm list \end{verbatim} \end{hol} -{\tt define\_quotient\_types} prende un singolo argomento che un +{\tt define\_quotient\_types} prende un singolo argomento che un record con i seguenti campi. {\it types\/} una lista di record, ognuno dei quali contiene due campi: -{\it name}, che il nome di un nuovo tipo quoziente da creare, e +{\it name}, che il nome di un nuovo tipo quoziente da creare, e {\it equiv}, che o 1) un teorema che una relazione binaria {\it R\/} - una relazione di equivalenza + una relazione di equivalenza (si veda [HOQ] \S 4) della forma $$ @@ -671,91 +671,91 @@ \section{Tipi Quoziente}\label{quotients} o 2) un teorema che {\it R\/} una relazione di equivalenza parziale non vuota, (si veda [HOQ] \S 5) -della forma +della forma $$ \mbox{\tt |-}\ (\exists x.\ R\ x\ x) \ \wedge \ (\forall x\ y.\ R\ x\ y \ \Leftrightarrow \ R\ x\ x \wedge R\ y\ y \wedge (R\ x = R\ y)). $$ -Il processo di formare i nuovi tipi quoziente descritto +Il processo di formare i nuovi tipi quoziente descritto in [HOQ] \S 8. {\it defs\/} una lista di record che specifica le costanti da sollevare. Ciascun record contiene i seguenti quattro campi: -{\it func\/} un termine HOL, che deve essere una singola costante, che la +{\it func\/} un termine HOL, che deve essere una singola costante, che la costante da sollevare. {\it fname\/} il nome della nuova costante da definire come la versione sollevata di {\it func}. -{\it fixity\/} la fixity HOL della nuova costante da creare, +{\it fixity\/} la fixity HOL della nuova costante da creare, come specificato nella struttura HOL {\tt Parse}. -{\it def\_name} il nome sotto il quale deve essere archiviata la definizione nella nuova costante +{\it def\_name} il nome sotto il quale deve essere archiviata la definizione nella nuova costante nella teoria attuale. -Il -processo di definire le costanti sollevate +Il +processo di definire le costanti sollevate descritto in [HOQ] \S 9. -{\it tyop\_equivs\/} una lista di teoremi di equivalenza condizionali +{\it tyop\_equivs\/} una lista di teoremi di equivalenza condizionali per operatori di tipo (si veda [HOQ] \S 4.1). -Questi sono usati per portare in forma regolare +Questi sono usati per portare in forma regolare i teoremi sui nuovi operatori di tipo, cos che essi possono essere sollevati (si veda [HOQ] \S 11 and \S 12). -{\it tyop\_quotients\/} una lista di teoremi quoziente condizionali +{\it tyop\_quotients\/} una lista di teoremi quoziente condizionali per operatori di tipo (si veda [HOQ] \S 5.2). Questi sono usati per sollevare sia le costanti sia i teoremi. -{\it tyop\_simps\/} una lista di teoremi per semplificare relazioni operatori di tipo +{\it tyop\_simps\/} una lista di teoremi per semplificare relazioni operatori di tipo e mappare funzioni, ad esempio, {\tt |- (\$= \#\#\# \$=) = \$=} e {\tt |- (I \#\# I) = I}. -Il resto degli argomenti si riferisce al processo generale di sollevare i teoremi +Il resto degli argomenti si riferisce al processo generale di sollevare i teoremi sui quozienti che vengono definiti, come descritto in [HOQ] \S 10. -{\it respects\/} una lista di teoremi circa il rispetto delle +{\it respects\/} una lista di teoremi circa il rispetto delle costanti che sono sollevate. -Questi teoremi sono descritti in +Questi teoremi sono descritti in [HOQ] \S 10.1. -{\it poly\_preserves\/} una lista di teoremi circa la preservazione di -costanti polimorfiche nella logica HOL +{\it poly\_preserves\/} una lista di teoremi circa la preservazione di +costanti polimorfiche nella logica HOL attraverso un'operazione quoziente. %as if they were definitions across the quotient operation. -In altre parole, essi affermano che qualsiasi operazione quozionte preserva queste +In altre parole, essi affermano che qualsiasi operazione quozionte preserva queste costanti come un omomorfismo. Questo teoremi sono descritti in [HOQ] \S 10.2. -{\it poly\_respects\/} una lista di teoremi che mostra il rispetto +{\it poly\_respects\/} una lista di teoremi che mostra il rispetto delle costanti polimorfiche menzionate in {\it poly\_preserves}. -Queste sono -descritte in +Queste sono +descritte in [HOQ] \S 10.3. -{\it old\_thms\/} una lista di teoremi che concernono i tipi e le costanti pi basse, -rappresentative, che devono essere sollevate e dimostrate automaticamente al +{\it old\_thms\/} una lista di teoremi che concernono i tipi e le costanti pi basse, +rappresentative, che devono essere sollevate e dimostrate automaticamente al pi alto, e pi astratto livello quoziente. Questo teoremi sono descritti in [HOQ] \S 10.4. -{\tt define\_quotient\_types} restituisce una lista di teoremi, che sono le +{\tt define\_quotient\_types} restituisce una lista di teoremi, che sono le versioni sollevate degli {\it old\_thms}. -Una funzione analoga, -{\tt define\_quotient\_types\_rule}, prende un singolo argomento che un -record con gli stessi campi di sopra eccetto per {\it old\_thms}, -e restituisce una funzione SML di tipo {\tt thm -> thm}. -Questo risultato tipicamente chiamato {\tt LIFT\_RULE}, +Una funzione analoga, +{\tt define\_quotient\_types\_rule}, prende un singolo argomento che un +record con gli stessi campi di sopra eccetto per {\it old\_thms}, +e restituisce una funzione SML di tipo {\tt thm -> thm}. +Questo risultato tipicamente chiamato {\tt LIFT\_RULE}, poi usato per sollevare i vecchi teoremi individualmente, uno alla volta. -Per retro-compatibilit con -l'eccellente pacchetto quozienti +Per retro-compatibilit con +l'eccellente pacchetto quozienti {\tt EquivType} -creato da +creato da John Harrison %to whom much credit is due, and -(che ha fornito molta ispirazione), +(che ha fornito molta ispirazione), anche fornita la seguente funzione: \begin{hol} @@ -773,7 +773,7 @@ \section{Tipi Quoziente}\label{quotients} \end{verbatim} \end{hol} \noindent -Questa funzione limitata ad un singolo tipo quoziente, ma pu essere +Questa funzione limitata ad un singolo tipo quoziente, ma pu essere pi conveniente quando la generalit di {\tt define\_quotient\_types} non necessaria. Questa funzione definita in termini di {\tt define\_quotient\_types} come @@ -810,10 +810,10 @@ \section{Espressioni Case}\label{CaseExp} La scelta nella regola per il primo caso ($\mathit{case}_1$) permette l'uso di una sintassi pi uniforme, dove ciascun caso preceduto da una barra verticale. Omettendo la barra, che ci che fa il pretty-printer quando la sintassi stampata, si conforma con la sintassi usata dall'SML. -Sulla base del valore di una espressione di test, sono considerate in sequenza una lista di +Sulla base del valore di una espressione di test, sono considerate in sequenza una lista di espressioni pattern per vedere se si accordano con l'espressione di test. -Il primo pattern che matcha con successo fa s che l'espressione risultato ad esso -associata sia valutata e il suo valore restituito come il valore dell'intera +Il primo pattern che matcha con successo fa s che l'espressione risultato ad esso +associata sia valutata e il suo valore restituito come il valore dell'intera espressione case. Per esempio, % \begin{hol} @@ -827,12 +827,12 @@ \section{Espressioni Case}\label{CaseExp} \end{hol} % -Questo avrebbe potuto essere espresso usando diversi costrutti ``if--then--else'', -ma l'espressione case molto pi compatta e pulita, con la +Questo avrebbe potuto essere espresso usando diversi costrutti ``if--then--else'', +ma l'espressione case molto pi compatta e pulita, con la selezione tra varie scelte rese chiaramente evidenti. -Oltre ai letterali come pattern, come di sopra, i pattern possono essere -espressioni costruttore. Molti tipi standard \HOL{} hanno dei costruttori, +Oltre ai letterali come pattern, come di sopra, i pattern possono essere +espressioni costruttore. Molti tipi standard \HOL{} hanno dei costruttori, compresi \ml{num}, \ml{list}, e \ml{option}. % \begin{hol} @@ -844,35 +844,35 @@ \section{Espressioni Case}\label{CaseExp} \end{hol} (Questo esempio usa la barra opzionale all'inizio del primo caso.) -\HOL{} supporta una ricca struttura di espressioni case che usano una singola -notazione. Il formato legato a quello delle definizioni di funzioni -ricorsive, come descritto nella Sezione~\ref{TFL}. Inoltre, le espressioni -case possono contenere letterali come pattern, o singolarmente come +\HOL{} supporta una ricca struttura di espressioni case che usano una singola +notazione. Il formato legato a quello delle definizioni di funzioni +ricorsive, come descritto nella Sezione~\ref{TFL}. Inoltre, le espressioni +case possono contenere letterali come pattern, o singolarmente come elementi di pattern pi profondamente annidati. -Le espressioni case possono testare valori di qualsiasi tipo. Se l'espressione test - un tipo con costruttori, allora i pattenr possono essere espressi -usando i costruttori applicati agli argomenti, come per esempio \ml{SOME s} -nell'esempio di sopra. Una variabile libeera all'interno del pattern costruttore, -per esempio \ml{s} nel pattern \ml{SOME s}, diventa legata al -corrispondente valore all'interno del valore dell'espressione di test, e +Le espressioni case possono testare valori di qualsiasi tipo. Se l'espressione test + un tipo con costruttori, allora i pattenr possono essere espressi +usando i costruttori applicati agli argomenti, come per esempio \ml{SOME s} +nell'esempio di sopra. Una variabile libeera all'interno del pattern costruttore, +per esempio \ml{s} nel pattern \ml{SOME s}, diventa legata al +corrispondente valore all'interno del valore dell'espressione di test, e pu essere usata all'interno dell'espressione risultato associata per quel pattern. -Oltre ai costruttori per i tipi standard in \HOL{}, -i pattern costruttore possono essere usati anche per i tipi creati per mezzo della -definizione di datatype descritta nella Sezione~\ref{sec:datatype}, +Oltre ai costruttori per i tipi standard in \HOL{}, +i pattern costruttore possono essere usati anche per i tipi creati per mezzo della +definizione di datatype descritta nella Sezione~\ref{sec:datatype}, compresi i tipi definiti dall'utente. -Sia che l'espressione di testi sia un tipo con costruttori o meno, -i pattern possono essere espressi usando i letterali appropriati di quel tipo, -se esistono tali letterali. -Un pattern complesso pu contenere o letterali o pattern costruttore +Sia che l'espressione di testi sia un tipo con costruttori o meno, +i pattern possono essere espressi usando i letterali appropriati di quel tipo, +se esistono tali letterali. +Un pattern complesso pu contenere o letterali o pattern costruttore o entrambi annidati l'uno con l'altro. -Tuttavia, i letterali e i costruttori non possono essere mischiati come alternative -gli uni degli altri all'interno della stessa espressione case, -a meno che un particolare pattern possa essere sia un letterale -e anche un costruttore (0-ario) del suo tipo, come per esempio \ml{0} (zero) - sia un letterale sia un costruttore del tipo \ml{num}. +Tuttavia, i letterali e i costruttori non possono essere mischiati come alternative +gli uni degli altri all'interno della stessa espressione case, +a meno che un particolare pattern possa essere sia un letterale +e anche un costruttore (0-ario) del suo tipo, come per esempio \ml{0} (zero) + sia un letterale sia un costruttore del tipo \ml{num}. Qui c' un esempio di questo genere di miscuglio improprio. % \begin{hol} @@ -885,15 +885,15 @@ \section{Espressioni Case}\label{CaseExp} \end{verbatim} \end{hol} % -In questo pattern, il pattern costruttore \ml{SUC m} dato come -un'alternativa ai pattern letterali \ml{1} and \ml{2}. -Ci rende questo espressione case invalida. -Cancellare uno dei due gruppi di righe risolverebbe il conflitto, -e renderebbe valida l'espressione. +In questo pattern, il pattern costruttore \ml{SUC m} dato come +un'alternativa ai pattern letterali \ml{1} and \ml{2}. +Ci rende questo espressione case invalida. +Cancellare uno dei due gruppi di righe risolverebbe il conflitto, +e renderebbe valida l'espressione. Si noti che il pattern \ml{0} accettabile per entrambi i gruppi. -Anche i pattern possono essere nidificati, come mostrato nel prossimo esempio, dove -la funzione \ml{parents} restituisce una coppia contenente il padre della persona +Anche i pattern possono essere nidificati, come mostrato nel prossimo esempio, dove +la funzione \ml{parents} restituisce una coppia contenente il padre della persona e/o la madre, dove ciascuno rappresentato da \ml{NONE} se deceduto. % \begin{hol} @@ -904,11 +904,11 @@ \section{Espressioni Case}\label{CaseExp} \end{verbatim} \end{hol} % -Questo mostra l'annidamento di pattern option all'interno di un pattern coppia, +Questo mostra l'annidamento di pattern option all'interno di un pattern coppia, e anche l'uso di una wildcard \ml{\_} per matchare i casi non forniti. -Se l'insieme di pattern rado [sparse nel testo originale (ndt)], ci possono essere alcune nuove righe generate -automaticamente per compilarlo, e possibilmente alcune nuove variabili o la +Se l'insieme di pattern rado [sparse nel testo originale (ndt)], ci possono essere alcune nuove righe generate +automaticamente per compilarlo, e possibilmente alcune nuove variabili o la costante \ml{ARB} per rappresentare propriamente l'espressione case. % \begin{hol} @@ -930,9 +930,9 @@ \section{Espressioni Case}\label{CaseExp} \end{verbatim} \end{hol} -Questo soltanto una breve descrizione di alcune delle -capacit espressive dell'espressione case con pattern. -Molti altri esempi di pattern sono forniti nella Sezione~\ref{TFL} +Questo soltanto una breve descrizione di alcune delle +capacit espressive dell'espressione case con pattern. +Molti altri esempi di pattern sono forniti nella Sezione~\ref{TFL} sulla definizione delle funzioni ricorsive. \index{espressioni case|)} @@ -940,28 +940,28 @@ \section{Espressioni Case}\label{CaseExp} \section{Funzioni Ricorsive}\label{TFL} -\HOL{} fornisce una meccanismo di definizione di funzione basato sul -teorema di ricorsione benfondata fornito in \theoryimp{relationTheory}, -discusso nella Sezione~\ref{relation}. \ml{Define} prende una specifica di alto livello, -possibilmente ricorsiva, di una funzione e tenta di -definire la funzione nella logica. \ml{Define} pu essere usato per definire -abbreviazioni, funzioni ricorsive, e funzioni mutuamente -ricorsive. Un teorema d'induzione pu essere generato come un sotto-prodotto -dell'attivit di \ml{Define}. Questo teorema d'induzione segue la struttura -ricorsiva della funzione, e pu essere utile quando di dimostrano propriet -della funzione. \ml{Define} non ha sempre successo nel tentare di -eseguire la definizione specificata, di solito perch una dimostrazione -automatica di terminazione fallisce: in quel caso, si pu usare un altro punto d'entrata, -\ml{Hol\_defn}, rinvia la dimostrazione di terminazione all'utente. -La tecnologia che sottosta a \ml{Define} e \ml{Hol\_defn} spiegata +\HOL{} fornisce una meccanismo di definizione di funzione basato sul +teorema di ricorsione benfondata fornito in \theoryimp{relationTheory}, +discusso nella Sezione~\ref{relation}. \ml{Define} prende una specifica di alto livello, +possibilmente ricorsiva, di una funzione e tenta di +definire la funzione nella logica. \ml{Define} pu essere usato per definire +abbreviazioni, funzioni ricorsive, e funzioni mutuamente +ricorsive. Un teorema d'induzione pu essere generato come un sotto-prodotto +dell'attivit di \ml{Define}. Questo teorema d'induzione segue la struttura +ricorsiva della funzione, e pu essere utile quando di dimostrano propriet +della funzione. \ml{Define} non ha sempre successo nel tentare di +eseguire la definizione specificata, di solito perch una dimostrazione +automatica di terminazione fallisce: in quel caso, si pu usare un altro punto d'entrata, +\ml{Hol\_defn}, rinvia la dimostrazione di terminazione all'utente. +La tecnologia che sottosta a \ml{Define} e \ml{Hol\_defn} spiegata in dettaglio in Slind~\cite{slind-thesis}. \index{Define@\ml{Define}} -In particolare, \ml{Define} prende come input una quotation che rappresenta una -congiunzione di equazioni. La (o le) funzione (funzioni) specificate possono essere formulate -usando un pattern-matching in stile ML. Una chiamata +In particolare, \ml{Define} prende come input una quotation che rappresenta una +congiunzione di equazioni. La (o le) funzione (funzioni) specificate possono essere formulate +usando un pattern-matching in stile ML. Una chiamata \ml{Define `}\textit{spec}\ml{`} dovrebbe conformarsi con la grammatica nella Tabella \ref{define:syntax}. \begin{table}[htbp] @@ -993,8 +993,8 @@ \section{Funzioni Ricorsive}\label{TFL} \end{table} \paragraph{Espansione di Pattern} -In generale, \ml{Define} tenta di derivare esattamente la congiunzione -di equazioni specificata. Tuttavia, la ricca sintassi dei pattern ammette +In generale, \ml{Define} tenta di derivare esattamente la congiunzione +di equazioni specificata. Tuttavia, la ricca sintassi dei pattern ammette qualche ambiguit. Per esempio, l'input % \begin{hol} @@ -1005,26 +1005,26 @@ \section{Funzioni Ricorsive}\label{TFL} \end{hol} % ambiguo per \holtxt{f 0 0}: il risultato dovrebbe essere \holtxt{1} o -\holtxt{2}? Questa ambiguit gestita ne modo usuale per i compilatori e -gli interpreti per i linguaggi funzionali: cio, la congiunzione delle -equazioni trattata come fosse applicata prima la congiunzione sinistra, seguita -dall'elaborazione del congiunto destro. Quindi, nell'esempio di sopra, il -valore di \holtxt{f 0 0} \holtxt{1}. Nell'implementazione, -le ambiguit che sorgono da tali pattern sovrapposti sono tradotti +\holtxt{2}? Questa ambiguit gestita ne modo usuale per i compilatori e +gli interpreti per i linguaggi funzionali: cio, la congiunzione delle +equazioni trattata come fosse applicata prima la congiunzione sinistra, seguita +dall'elaborazione del congiunto destro. Quindi, nell'esempio di sopra, il +valore di \holtxt{f 0 0} \holtxt{1}. Nell'implementazione, +le ambiguit che sorgono da tali pattern sovrapposti sono tradotti sistematicamente in un passo di pre-elaborazione. -Un altro caso di ambiguit nei pattern mostrato di sotto: la specifica - incompleta dal momento che non dice come \holtxt{f} dovrebbe comportarsi quando -applicata a due argomenti diversi da zero: ad esempio, \holtxt{f (SUC m) (SUC n)}. Nella -implementazione, tali clausole mancanti sono riempite, e hanno il valore -\holtxt{ARB}. Questo passo di `completamento del pattern' un modo di trasformare le descrizioni -di funzioni parziali in funzioni totali adatte per HOL. Tuttavia, -dal momento che l'utente non specificato in modo completo la funzione, il sistema -lo prende come un suggerimento che l'utente non interessato nell'usare la -funzione per le clausole mancanti ma riempite, e cos tali clausole sono +Un altro caso di ambiguit nei pattern mostrato di sotto: la specifica + incompleta dal momento che non dice come \holtxt{f} dovrebbe comportarsi quando +applicata a due argomenti diversi da zero: ad esempio, \holtxt{f (SUC m) (SUC n)}. Nella +implementazione, tali clausole mancanti sono riempite, e hanno il valore +\holtxt{ARB}. Questo passo di `completamento del pattern' un modo di trasformare le descrizioni +di funzioni parziali in funzioni totali adatte per HOL. Tuttavia, +dal momento che l'utente non specificato in modo completo la funzione, il sistema +lo prende come un suggerimento che l'utente non interessato nell'usare la +funzione per le clausole mancanti ma riempite, e cos tali clausole sono eliminate dal teorema finale. -In sintesi, \ml{Define} deriver le equazioni non ambigue e +In sintesi, \ml{Define} deriver le equazioni non ambigue e complete % \begin{hol} @@ -1036,10 +1036,10 @@ \section{Funzioni Ricorsive}\label{TFL} \end{verbatim} \end{hol} % -dall'equazioni ambigue e incomplete di sopra. Gli strani -nomi delle variabili sono dovuti ai passi di pre-elaborazione descritti di sopra. Il -risultato di sopra solo un valore intermedio: nel risultato finale restituito -da \ml{Define}, l'ultima equazione rimossa dal momento che non stata +dall'equazioni ambigue e incomplete di sopra. Gli strani +nomi delle variabili sono dovuti ai passi di pre-elaborazione descritti di sopra. Il +risultato di sopra solo un valore intermedio: nel risultato finale restituito +da \ml{Define}, l'ultima equazione rimossa dal momento che non stata specificata dall'input originale. \begin{hol} @@ -1052,42 +1052,42 @@ \section{Funzioni Ricorsive}\label{TFL} \paragraph{Terminazione} -Durante l'elaborazione della specifica di una funzione ricorsiva, \ml{Define} -deve eseguire una dimostrazione di terminazione. Essa costruisce automaticamente -delle condizioni di terminazione per la funzione, e invoca un dimostratore -di terminazione nel tentativo di dimostrare le condizioni di terminazione. Se la -funzione ricorsiva primitiva, nel senso che segue esattamente -il pattern ricorsione di un datatype HOL dichiarato in precedenza, allora questa -dimostrazione avr sempre successo, e \ml{Define} archivia l'equazioni derivate nel +Durante l'elaborazione della specifica di una funzione ricorsiva, \ml{Define} +deve eseguire una dimostrazione di terminazione. Essa costruisce automaticamente +delle condizioni di terminazione per la funzione, e invoca un dimostratore +di terminazione nel tentativo di dimostrare le condizioni di terminazione. Se la +funzione ricorsiva primitiva, nel senso che segue esattamente +il pattern ricorsione di un datatype HOL dichiarato in precedenza, allora questa +dimostrazione avr sempre successo, e \ml{Define} archivia l'equazioni derivate nel segmento attuale di teoria. -Altrimenti, la funzione non -un'istanza di ricorsione primitiva, e il dimostratore di terminazione pu -avere successo o fallire. Se la dimostrazione di terminazione fallisce, allora \ml{Define} fallisce. -Se ha successo, allora \ml{Define} archivia l'equazioni specificate nell'attuale -segmento di teoria. E' anche archiviato nell'attuale segmento di teoria un teorema d'induzione -customizzato per la funzione specificata. Si noti, tuttavia, che -non archiviato un teorema d'induzione per le funzioni ricorsive primitive, dal -momento che quel teorema sarebbe identico al teorema d'induzione che risulta +Altrimenti, la funzione non +un'istanza di ricorsione primitiva, e il dimostratore di terminazione pu +avere successo o fallire. Se la dimostrazione di terminazione fallisce, allora \ml{Define} fallisce. +Se ha successo, allora \ml{Define} archivia l'equazioni specificate nell'attuale +segmento di teoria. E' anche archiviato nell'attuale segmento di teoria un teorema d'induzione +customizzato per la funzione specificata. Si noti, tuttavia, che +non archiviato un teorema d'induzione per le funzioni ricorsive primitive, dal +momento che quel teorema sarebbe identico al teorema d'induzione che risulta dalla dichiarazione del datatype. \paragraph{Archiviare le definizioni nel segmento di teoria} -\ml{Define} genera automaticamente nomi con i quali archiviare la -definizione e, (se esiste) il teorema d'induzione associato, nella teoria -attuale. Il nome per archiviare la definizione costruito -concatenando il nome della funzione con il valore della variabile -reference \ml{Defn.def\_suffix}. Il nome per archiviare il teorema d'induzione - costruito concatenando il nome della funzione con il valore -della variabile reference \ml{Defn.ind\_suffix}. Per funzioni -mutuamente ricorsive, dove c' una scelta di nomi, preso il nome della funzione +\ml{Define} genera automaticamente nomi con i quali archiviare la +definizione e, (se esiste) il teorema d'induzione associato, nella teoria +attuale. Il nome per archiviare la definizione costruito +concatenando il nome della funzione con il valore della variabile +reference \ml{Defn.def\_suffix}. Il nome per archiviare il teorema d'induzione + costruito concatenando il nome della funzione con il valore +della variabile reference \ml{Defn.ind\_suffix}. Per funzioni +mutuamente ricorsive, dove c' una scelta di nomi, preso il nome della funzione nella prima clausola. -Dal momento che i nomi usati per archiviare elementi nel segmento attuale di teoria -sono trasformati in binding ML dopo che la teoria esportata, -richiesto che ogni invocazione di \ml{Define} generi nomi che sono -identificatori ML validi. Per questa ragione, \ml{Define} richiede -nomi alfanumerici di funzione. Se si desidera definire identificatori +Dal momento che i nomi usati per archiviare elementi nel segmento attuale di teoria +sono trasformati in binding ML dopo che la teoria esportata, +richiesto che ogni invocazione di \ml{Define} generi nomi che sono +identificatori ML validi. Per questa ragione, \ml{Define} richiede +nomi alfanumerici di funzione. Se si desidera definire identificatori simbolici, si dovrebbe usare la funzione ML \ml{xDefine}. \index{xDefine@\ml{xDefine}} @@ -1096,13 +1096,13 @@ \section{Funzioni Ricorsive}\label{TFL} xDefine : string -> term quotation -> thm \end{verbatim} \end{hol} -La funzione \ml{xDefine} identica a -\ml{Define} eccetto per il fatto che prende un nome esplicito da usare quando +La funzione \ml{xDefine} identica a +\ml{Define} eccetto per il fatto che prende un nome esplicito da usare quando si archivia la definizione nella teoria attuale. \subsection{Esempi di definizione di funzione} -Daremo un numero di esempi che mostrano la gamma di funzioni -che possono essere definite con \ml{Define}. Innanzi tutto, abbiamo una funzione ricorsiva +Daremo un numero di esempi che mostrano la gamma di funzioni +che possono essere definite con \ml{Define}. Innanzi tutto, abbiamo una funzione ricorsiva che usa ``de-costruttori'' nella chiamata ricorsiva. \begin{hol} @@ -1116,8 +1116,8 @@ \subsection{Esempi di definizione di funzione} \end{verbatim} \end{hol} % -Dal momento che \holtxt{fact} non -ricorsiva primitiva, generato un teorema d'induzione per \holtxt{fact} e +Dal momento che \holtxt{fact} non +ricorsiva primitiva, generato un teorema d'induzione per \holtxt{fact} e archiviato nella teoria attuale. % \begin{hol} @@ -1129,8 +1129,8 @@ \subsection{Esempi di definizione di funzione} \end{verbatim} \end{hol} -Poi abbiamo una funzione ricorsiva con un pattern-matching -relativamente complesso. Tralasciamo di esaminare il teorema +Poi abbiamo una funzione ricorsiva con un pattern-matching +relativamente complesso. Tralasciamo di esaminare il teorema d'induzione generato. % \begin{hol} @@ -1149,7 +1149,7 @@ \subsection{Esempi di definizione di funzione} \end{verbatim} \end{hol} -Poi definiamo una funzione ricorsiva curried, che usa +Poi definiamo una funzione ricorsiva curried, che usa espansione di caratteri jolly e pre-elaborazione di pattern-matching. % \begin{hol} @@ -1167,7 +1167,7 @@ \subsection{Esempi di definizione di funzione} \end{verbatim} \end{hol} -Poi facciamo una definizione ricorsiva primitiva. Si noti che, in questo caso, non +Poi facciamo una definizione ricorsiva primitiva. Si noti che, in questo caso, non generato alcun teorema d'induzione. % \begin{hol} @@ -1184,9 +1184,9 @@ \subsection{Esempi di definizione di funzione} \end{verbatim} \end{hol} -\ml{Define} pu essere usata anche per definire funzioni mutuamente ricorsive. -Per esempio, possiamo definire un datatype di proposizioni e una funzione per -mettere una proposizione in forma normale negata come segue. +\ml{Define} pu essere usata anche per definire funzioni mutuamente ricorsive. +Per esempio, possiamo definire un datatype di proposizioni e una funzione per +mettere una proposizione in forma normale negata come segue. Prima definiamo un datatype, chiamato \ml{prop}, di formule booleane: % \begin{hol} @@ -1199,7 +1199,7 @@ \subsection{Esempi di definizione di funzione} \end{verbatim} \end{hol} % -Poi sono definite due funzioni mutuamente ricorsive +Poi sono definite due funzioni mutuamente ricorsive \holtxt{nnfpos} e \holtxt{nnfneg}: % \begin{hol} @@ -1241,9 +1241,9 @@ \subsection{Esempi di definizione di funzione} \end{verbatim} \end{hol} -\ml{Define} pu essere usata anche per definire funzioni non-ricorsive -con un pattern-matching complesso. La pre-elaborazione del pattern-matching di -\ml{Define} pu essere conveniente per questo scopo, ma pu anche generare un +\ml{Define} pu essere usata anche per definire funzioni non-ricorsive +con un pattern-matching complesso. La pre-elaborazione del pattern-matching di +\ml{Define} pu essere conveniente per questo scopo, ma pu anche generare un grande numero di equazioni. Per esempio: % \begin{hol} @@ -1262,8 +1262,8 @@ \subsection{Esempi di definizione di funzione} \subsection{Quando la terminazione non dimostrata automaticamente} -Se la dimostrazione di terminazione per una definizione potenziale -fallisce, l'invocazione di \ml{Define} (o \ml{xDefine}) fallisce. In tali +Se la dimostrazione di terminazione per una definizione potenziale +fallisce, l'invocazione di \ml{Define} (o \ml{xDefine}) fallisce. In tali situazioni, si dovrebbe usare la funzione \ML{} \ml{Hol\_defn}. % \index{Hol_defn@\ml{Hol\_defn}} @@ -1274,8 +1274,8 @@ \subsection{Esempi di definizione di funzione} \end{verbatim} \end{hol} -\ml{Hol\_defn} esegue la definizione richiesta, ma rinvia la dimostrazione di -terminazione all'utente. Per la creazione di dimostrazioni di terminazione, esistono +\ml{Hol\_defn} esegue la definizione richiesta, ma rinvia la dimostrazione di +terminazione all'utente. Per la creazione di dimostrazioni di terminazione, esistono alcuni utili entrypoint, cio \begin{hol} \begin{verbatim} @@ -1283,14 +1283,14 @@ \subsection{Esempi di definizione di funzione} Defn.tprove : Defn.defn * tactic -> thm * thm \end{verbatim} \end{hol} -\ml{Defn.tgoal} analogo a \ml{set\_goal} e \ml{Defn.tprove} -analogo a \ml{prove}, Cos, \ml{Defn.tgoal} usato per prendere il -risultato di \ml{Hol\_defn} e creare un goal per dimostrare la terminazione +\ml{Defn.tgoal} analogo a \ml{set\_goal} e \ml{Defn.tprove} +analogo a \ml{prove}, Cos, \ml{Defn.tgoal} usato per prendere il +risultato di \ml{Hol\_defn} e creare un goal per dimostrare la terminazione della definizione. -\paragraph{Esempio.} Un'invocazione di {\small\verb+Define+} sulle -seguenti equazioni per Quicksort attualmente fallir, dal momento che la -dimostrazione di terminazione attualmente oltre le capacit del dimostratore elementare +\paragraph{Esempio.} Un'invocazione di {\small\verb+Define+} sulle +seguenti equazioni per Quicksort attualmente fallir, dal momento che la +dimostrazione di terminazione attualmente oltre le capacit del dimostratore elementare di terminazione. Piuttosto, eseguiamo un'applicazione di {\small\verb+Hol_defn+}: \setcounter{sessioncount}{0} @@ -1305,7 +1305,7 @@ \subsection{Esempi di definizione di funzione} qsort ord (FILTER (\x. ~(ord x h)) t))` \end{verbatim} \end{session} -che restituisce il seguente valore di tipo \ml{defn}, ma non tenta di +che restituisce il seguente valore di tipo \ml{defn}, ma non tenta di dimostrare la terminazione. \begin{session} \begin{verbatim} @@ -1335,10 +1335,10 @@ \subsection{Esempi di definizione di funzione} \end{verbatim} \end{session} -Il tipo \ml{defn} ha un prettyprinter installato per esso: l'output -di sopra tipico, mostrando i componenti di una \ml{defn} in un formato -comprensibile. Bench sia possibile lavorare direttamente con elementi di -tipo \ml{defn}, pi conveniente invocare +Il tipo \ml{defn} ha un prettyprinter installato per esso: l'output +di sopra tipico, mostrando i componenti di una \ml{defn} in un formato +comprensibile. Bench sia possibile lavorare direttamente con elementi di +tipo \ml{defn}, pi conveniente invocare \ml{Defn.tgoal}, che imposta una dimostrazione di terminazione in un goalstack. % \begin{session} @@ -1355,12 +1355,12 @@ \subsection{Esempi di definizione di funzione} \end{verbatim} \end{session} % -Il goal trovare una relazione benfondata sugli argomenti per \holtxt{qsort} -e mostrare che gli argomenti per \holtxt{qsort} sono nella relazione. -La funzione \ml{WF\_REL\_TAC} quasi sempre utilizzata a questo punto per -iniziare la dimostrazione di terminazione. Chiaramente, \ml{qsort} termina perch la lista -argomento diventa pi piccola. L'invocazione di \ml{WF\_REL\_TAC} con la funzione di misura -appropriata risulta in due subgoal, ognuno dei quali facile da +Il goal trovare una relazione benfondata sugli argomenti per \holtxt{qsort} +e mostrare che gli argomenti per \holtxt{qsort} sono nella relazione. +La funzione \ml{WF\_REL\_TAC} quasi sempre utilizzata a questo punto per +iniziare la dimostrazione di terminazione. Chiaramente, \ml{qsort} termina perch la lista +argomento diventa pi piccola. L'invocazione di \ml{WF\_REL\_TAC} con la funzione di misura +appropriata risulta in due subgoal, ognuno dei quali facile da dimostrare. \begin{session} @@ -1375,16 +1375,16 @@ \subsection{Esempi di definizione di funzione} \end{verbatim} \end{session} % -L'esecuzione di \ml{WF\_REL\_TAC} ha dimostrato automaticamente la -benfondatezza della relazione di terminazione -\holtxt{measure (LENGTH o SND)} -e il resto del goal stato semplificato in una -coppia di goal semplici. Una volta che entrambi i goal sono dimostrati, possiamo incapsulare -la relazione di terminazione con \ml{tDefine}, che prende una quotation -(che rappresenta l'equazioni di ricorsione desiderate) e una tattica $t$, -definisce la funzione specificata, calcola le condizioni di terminazione, -e applica $t$ ad esse. Se le condizioni di terminazione sono dimostrate da -$t$ allora l'equazioni di ricorsione e il teorema d'induzione sono archiviati +L'esecuzione di \ml{WF\_REL\_TAC} ha dimostrato automaticamente la +benfondatezza della relazione di terminazione +\holtxt{measure (LENGTH o SND)} +e il resto del goal stato semplificato in una +coppia di goal semplici. Una volta che entrambi i goal sono dimostrati, possiamo incapsulare +la relazione di terminazione con \ml{tDefine}, che prende una quotation +(che rappresenta l'equazioni di ricorsione desiderate) e una tattica $t$, +definisce la funzione specificata, calcola le condizioni di terminazione, +e applica $t$ ad esse. Se le condizioni di terminazione sono dimostrate da +$t$ allora l'equazioni di ricorsione e il teorema d'induzione sono archiviati nel segmento di teoria attuale prima che le equazioni di ricorsione siano restituite: \begin{session} @@ -1404,8 +1404,8 @@ \subsection{Esempi di definizione di funzione} \end{verbatim} \end{session} -Il teorema d'induzione custom per una funzione si pu ottenere usando \holtxt{fetch}, -che restituisce elementi nominati nella teoria specifica\footnote{In una chiamata a \texttt{fetch}, il +Il teorema d'induzione custom per una funzione si pu ottenere usando \holtxt{fetch}, +che restituisce elementi nominati nella teoria specifica\footnote{In una chiamata a \texttt{fetch}, il primo argomento denota una teoria; la teoria attuale pu essere specificata da \texttt{"-"}.}. \begin{session} \begin{verbatim} @@ -1421,26 +1421,26 @@ \subsection{Esempi di definizione di funzione} \end{verbatim} \end{session} -\noindent Il teorema d'induzione prodotto da \holtxt{Define} e \holtxt{tDefine} pu +\noindent Il teorema d'induzione prodotto da \holtxt{Define} e \holtxt{tDefine} pu essere applicato da \ml{recInduct}. Si veda la Sezione \ref{sec:bossLib} per i dettagli. \subsubsection{Tecniche per dimostrare la terminazione} -Ci sono due problemi da affrontare quando di tenta di dimostrare la terminazione. -Primo, bisogna comprendere, intuitivamente e poi matematicamente, -perch la funzione in considerazione termina. Secondo, si deve -essere in grado di formulare questo in \HOL. In ci che segue, daremo alcuni +Ci sono due problemi da affrontare quando di tenta di dimostrare la terminazione. +Primo, bisogna comprendere, intuitivamente e poi matematicamente, +perch la funzione in considerazione termina. Secondo, si deve +essere in grado di formulare questo in \HOL. In ci che segue, daremo alcuni esempi di come questo fatto. -C' un certo numero di strumenti base e avanzati per specificare relazioni -benfondate. Il punto di partenza pi comune per trattare i problemi -di terminazione per funzioni ricorsive trovare qualche funzione, conosciuta come una -\emph{misura} sotto la quale gli argomenti di una chiamata di funzione sono pi grandi +C' un certo numero di strumenti base e avanzati per specificare relazioni +benfondate. Il punto di partenza pi comune per trattare i problemi +di terminazione per funzioni ricorsive trovare qualche funzione, conosciuta come una +\emph{misura} sotto la quale gli argomenti di una chiamata di funzione sono pi grandi degli argomenti a qualsiasi chiamata ricorsiva che ne risulta. -Per un esempio di partenza molto semplice, si consideri la seguente definizione -di una funzione che calcola il massimo comun divisore di due +Per un esempio di partenza molto semplice, si consideri la seguente definizione +di una funzione che calcola il massimo comun divisore di due numeri: % \setcounter{sessioncount}{0} @@ -1461,11 +1461,11 @@ \subsubsection{Tecniche per dimostrare la terminazione} \end{verbatim} \end{session} % -L'invocazione \holtxt{gcd(m,n)} esegue una ricorsione nel suo primo argomento, e -dal momento che sappiamo che \holtxt{m} non 0, si da il caso che -\holtxt{n MOD m} sia pi piccolo di \holtxt{m}. Il modo di formulare la -terminazione di \holtxt{gcd} in HOL di usare una funzione `misura' -per mappare dal dominio di \holtxt{gcd}---una coppia di numeri---a un numero. +L'invocazione \holtxt{gcd(m,n)} esegue una ricorsione nel suo primo argomento, e +dal momento che sappiamo che \holtxt{m} non 0, si da il caso che +\holtxt{n MOD m} sia pi piccolo di \holtxt{m}. Il modo di formulare la +terminazione di \holtxt{gcd} in HOL di usare una funzione `misura' +per mappare dal dominio di \holtxt{gcd}---una coppia di numeri---a un numero. La definizione di {misura} in \HOL{} equivalente a % \begin{hol} @@ -1474,7 +1474,7 @@ \subsubsection{Tecniche per dimostrare la terminazione} \end{verbatim} \end{hol} % -Ora dobbiamo scegliere la posizione di argomento da misurare e +Ora dobbiamo scegliere la posizione di argomento da misurare e invocare \ml{WF\_REL\_TAC}: \begin{session} \begin{verbatim} @@ -1490,10 +1490,10 @@ \subsubsection{Tecniche per dimostrare la terminazione} \paragraph{Funzioni di Ponderazione} -A volte, si ha bisogno di una funzione di misura che sia essa stessa ricorsiva. Per -esempio, si consideri un tipo di alberi binari e una funzione che -linearizza gli alberi. L'algoritmo funziona ruotando l'albero fino a quando -ottiene un \holtxt{Leaf} nel ramo sinistro, poi esegue una ricorsione nel ramo +A volte, si ha bisogno di una funzione di misura che sia essa stessa ricorsiva. Per +esempio, si consideri un tipo di alberi binari e una funzione che +linearizza gli alberi. L'algoritmo funziona ruotando l'albero fino a quando +ottiene un \holtxt{Leaf} nel ramo sinistro, poi esegue una ricorsione nel ramo destro. Alla fine dell'esecuzione l'albero stato linearizzato. \setcounter{sessioncount}{0} \begin{session} @@ -1520,10 +1520,10 @@ \subsubsection{Tecniche per dimostrare la terminazione} \end{verbatim} \end{session} % -Dal momento che la dimensione dell'albero non modificata nell'ultima clausola nella -definizione di \holtxt{Unbal}, una semplice misura di dimensione non funziona. Piuttosto, -possiamo assegnare dei pesi ai nodi nell'albero tali che le chiamate ricorsive di -\holtxt{Unbal} diminuiscono il peso totale in ogni case. Una tale assegnazione +Dal momento che la dimensione dell'albero non modificata nell'ultima clausola nella +definizione di \holtxt{Unbal}, una semplice misura di dimensione non funziona. Piuttosto, +possiamo assegnare dei pesi ai nodi nell'albero tali che le chiamate ricorsive di +\holtxt{Unbal} diminuiscono il peso totale in ogni case. Una tale assegnazione % \begin{session} \begin{verbatim} @@ -1551,21 +1551,21 @@ \subsubsection{Tecniche per dimostrare la terminazione} % Entrambi questi goal sono piuttosto facili da dimostrare. % -Le tecniche di `ponderazione' di nodi in un datatype al fine di dimostrare -la terminazione vanno anche sotto il nome di \emph{interpretazione polinomiale}. Bisogna -ammettere che trovare la ponderazione corretta per una dimostrazione -di terminazione pi un'arte che una scienza. Tipicamente, si fa una congettura e +Le tecniche di `ponderazione' di nodi in un datatype al fine di dimostrare +la terminazione vanno anche sotto il nome di \emph{interpretazione polinomiale}. Bisogna +ammettere che trovare la ponderazione corretta per una dimostrazione +di terminazione pi un'arte che una scienza. Tipicamente, si fa una congettura e si prova la dimostrazione di terminazione per vedere se funziona. \paragraph{Combinazioni Lessicografiche} -Saltuariamente, c' una combinazione di fattori che complica -l'argomento di terminazione. Per esempio, la seguente specifica -descrive un ingenuo algoritmo di pattern matching su stringhe (qui -rappresentate come liste). La funzione prende quattro argomenti: il primo, $p$, - il rimanente del pattern da matchare. Il secondo, -$\mathit{rst}$, il rimanente della stringa che viene cercata. Il terzo -argomento, $p_0$, mantiene il pattern originale da matchare. +Saltuariamente, c' una combinazione di fattori che complica +l'argomento di terminazione. Per esempio, la seguente specifica +descrive un ingenuo algoritmo di pattern matching su stringhe (qui +rappresentate come liste). La funzione prende quattro argomenti: il primo, $p$, + il rimanente del pattern da matchare. Il secondo, +$\mathit{rst}$, il rimanente della stringa che viene cercata. Il terzo +argomento, $p_0$, mantiene il pattern originale da matchare. Il quarto argomento, $s$, la stringa che viene cercata. % \setcounter{sessioncount}{0} @@ -1586,28 +1586,28 @@ \subsubsection{Tecniche per dimostrare la terminazione} \end{verbatim} \end{session} % -La prima clausola della definizione afferma che se $p$ si esaurisce, allora stato -trovato un match; la funzione restituisce \holtxt{T}. La seconda clausola rappresenta il caso -dove $s$ esaurito ma $p$ no, in questo caso la funzione restituisce -\holtxt{F}. Il caso rimanente quando c' pi ricerca da fare; la funzione -controlla se la testa del pattern $p$ la stessa della testa di -$\mathit{rst}$. Se s, allora la ricerca procede ricorsivamente, usando la -coda di $p$ e la coda di $\mathit{rst}$. Se no, questo significa che $p$ ha -fallito il match, cos l'algoritmo avanza di un carattere in avanti in -$\mathit{s}$ e inizia il matching dall'inizio di $p_0$. Se -$\mathit{s}$ vuoto allora, comunque, restituisce \holtxt{F}. Si noti che -$\mathit{rst}$ e $s$ rappresentano entrambi la stringa da -cercare: $\mathit{rst}$ una versione `locale` di $s$: eseguiamo una ricorsione in -$\mathit{rst}$ fino a quando ci sono dei match con il pattern $p$. Tuttavia, -se la ricerca alla fine fallisce, allora $s$, che `ricorda` dove la ricerca +La prima clausola della definizione afferma che se $p$ si esaurisce, allora stato +trovato un match; la funzione restituisce \holtxt{T}. La seconda clausola rappresenta il caso +dove $s$ esaurito ma $p$ no, in questo caso la funzione restituisce +\holtxt{F}. Il caso rimanente quando c' pi ricerca da fare; la funzione +controlla se la testa del pattern $p$ la stessa della testa di +$\mathit{rst}$. Se s, allora la ricerca procede ricorsivamente, usando la +coda di $p$ e la coda di $\mathit{rst}$. Se no, questo significa che $p$ ha +fallito il match, cos l'algoritmo avanza di un carattere in avanti in +$\mathit{s}$ e inizia il matching dall'inizio di $p_0$. Se +$\mathit{s}$ vuoto allora, comunque, restituisce \holtxt{F}. Si noti che +$\mathit{rst}$ e $s$ rappresentano entrambi la stringa da +cercare: $\mathit{rst}$ una versione `locale` di $s$: eseguiamo una ricorsione in +$\mathit{rst}$ fino a quando ci sono dei match con il pattern $p$. Tuttavia, +se la ricerca alla fine fallisce, allora $s$, che `ricorda` dove la ricerca iniziata, usata per riavviare la ricerca. -Questo per quanto riguarda il comportamento della funzione. Perch termina? Ci -sono due chiamate ricorsive. La prima chiamata riduce la dimensione di $p$ e $\mathit{rst}$, e -lascia l'altro argomento invariato. La seconda chiamata pu accrescere la -dimensione di $p$ e $\mathit{rst}$, ma riduce la dimensione di $s$. Questa una classica situazione -in cui usare un ordine lessicografico: alcuni argomenti alla funzione sono ridotti in -alcune chiamate ricorsive, e altri sono ridotti in altre chiamate ricorsive. +Questo per quanto riguarda il comportamento della funzione. Perch termina? Ci +sono due chiamate ricorsive. La prima chiamata riduce la dimensione di $p$ e $\mathit{rst}$, e +lascia l'altro argomento invariato. La seconda chiamata pu accrescere la +dimensione di $p$ e $\mathit{rst}$, ma riduce la dimensione di $s$. Questa una classica situazione +in cui usare un ordine lessicografico: alcuni argomenti alla funzione sono ridotti in +alcune chiamate ricorsive, e altri sono ridotti in altre chiamate ricorsive. Si ricordi che \holtxt{LEX} un operatore infisso, definito in \ml{pairTheory} come segue: % \begin{hol} @@ -1616,12 +1616,12 @@ \subsubsection{Tecniche per dimostrare la terminazione} \end{verbatim} \end{hol} % -Nella seconda chiamata ricorsiva, la lunghezza di \holtxt{s} ridotta, e nella -prima rimane uguale. Questo spinge ad avere la lunghezza della -$s$ come il primo componente della combinazione -lessicografica, e la lunghezza di $\mathit{rst}$ come il secondo -componente. Formalmente, vogliamo mappare dalla quadrupla degli -argomenti in una combinazione lessicografica di relazioni. +Nella seconda chiamata ricorsiva, la lunghezza di \holtxt{s} ridotta, e nella +prima rimane uguale. Questo spinge ad avere la lunghezza della +$s$ come il primo componente della combinazione +lessicografica, e la lunghezza di $\mathit{rst}$ come il secondo +componente. Formalmente, vogliamo mappare dalla quadrupla degli +argomenti in una combinazione lessicografica di relazioni. Questo permesso da \holtxt{inv\_image} di \ml{relationTheory}: % \begin{hol} @@ -1630,9 +1630,9 @@ \subsubsection{Tecniche per dimostrare la terminazione} \end{verbatim} \end{hol} % -La relazione desiderata mappa dalla quadrupla degli argomenti in una coppia -di numeri $(m,n)$, dove $m$ la lunghezza del quarto argomento, e -$n$ la lunghezza del secondo argomento. Queste lunghezze sono poi +La relazione desiderata mappa dalla quadrupla degli argomenti in una coppia +di numeri $(m,n)$, dove $m$ la lunghezza del quarto argomento, e +$n$ la lunghezza del secondo argomento. Queste lunghezze sono poi confrontate dal punto di vista lessicografico rispetto a minore-di ($<$). \begin{session} \begin{verbatim} @@ -1652,17 +1652,17 @@ \subsubsection{Tecniche per dimostrare la terminazione} \end{verbatim} \end{session} % -Il primo subgoal ha bisogno di un case-split su \holtxt{s} prima di essere dimostrato per +Il primo subgoal ha bisogno di un case-split su \holtxt{s} prima di essere dimostrato per riscritture, e il secondo anch'esso facile da dimostrare per riscrittura. \subsubsection{Come sono sintetizzate le condizioni di terminazione} \index{regole di congruenza!nelle analisi di terminazione|(} -A volte importante comprendere, almeno in parte, come -\ml{Hol\_defn} costruisce i vincoli di terminazione. In alcuni casi, -persino necessario che gli utenti influenzino questo processo al fine di avere estratti -dei vincoli di terminazione corretti. Il processo guidato dai cosiddetti -\emph{teoremi di congruenza} per particolari vincoli \HOL{}. +A volte importante comprendere, almeno in parte, come +\ml{Hol\_defn} costruisce i vincoli di terminazione. In alcuni casi, +persino necessario che gli utenti influenzino questo processo al fine di avere estratti +dei vincoli di terminazione corretti. Il processo guidato dai cosiddetti +\emph{teoremi di congruenza} per particolari vincoli \HOL{}. Per esempio, si consideri la seguente definizione ricorsiva di fattoriale: % \begin{hol} @@ -1671,8 +1671,8 @@ \subsubsection{Come sono sintetizzate le condizioni di terminazione} \end{verbatim} \end{hol} % -In assenza di una conoscenza di come il costrutto `if-then-else` -influisce il \emph{contesto} delle chiamate ricorsive, \ml{Hol\_defn} +In assenza di una conoscenza di come il costrutto `if-then-else` +influisce il \emph{contesto} delle chiamate ricorsive, \ml{Hol\_defn} estrarrebbe i vincoli di terminazione: % \begin{hol} @@ -1682,8 +1682,8 @@ \subsubsection{Come sono sintetizzate le condizioni di terminazione} \end{verbatim} \end{hol} % -che non sono dimostrabili, perch il \emph{contesto} delle chiamate ricorsive non -stato preso in considerazione. Questo esempio di fatto non un problema per HOL, +che non sono dimostrabili, perch il \emph{contesto} delle chiamate ricorsive non +stato preso in considerazione. Questo esempio di fatto non un problema per HOL, dal momento che il seguente teorema di congruenza conosciuto da \ml{Hol\_defn}: % \begin{hol} @@ -1696,24 +1696,24 @@ \subsubsection{Come sono sintetizzate le condizioni di terminazione} \end{verbatim} \end{hol} % -Questo teorema compreso da \ml{Hol\_defn} come una sequenza ordinata -di istruzioni da seguire quando l'estrattore di condizioni di terminazione -incontra un `if-then-else`. Il teorema letto come segue: quando -un'istanza `\texttt{if} $B$ \texttt{then} $X$ \texttt{else} $Y$` -incontrata mentre l'estrattore passa attraverso la definizione di funzione, +Questo teorema compreso da \ml{Hol\_defn} come una sequenza ordinata +di istruzioni da seguire quando l'estrattore di condizioni di terminazione +incontra un `if-then-else`. Il teorema letto come segue: quando +un'istanza `\texttt{if} $B$ \texttt{then} $X$ \texttt{else} $Y$` +incontrata mentre l'estrattore passa attraverso la definizione di funzione, fa ci che segue. \begin{enumerate} -\item Traversa $B$ ed estrae le condizioni di terminazione +\item Traversa $B$ ed estrae le condizioni di terminazione $\mathit{TCs}(B)$ da ogni chiamata ricorsiva al suo interno. Questo restituisce un teorema $\mathit{TCs}(B) \vdash B = B'$. -\item Assume $B'$ ed estrae le condizioni di terminazione da ogni - chiamata ricorsiva in $X$. Questo restituisce un teorema +\item Assume $B'$ ed estrae le condizioni di terminazione da ogni + chiamata ricorsiva in $X$. Questo restituisce un teorema $\mathit{TCs}(X) \vdash X = X'$. -\item Assume $\neg B'$ ed estrae le condizioni di terminazione da ogni - chiamata ricorsiva in $Y$. Questo restituisce un teorema +\item Assume $\neg B'$ ed estrae le condizioni di terminazione da ogni + chiamata ricorsiva in $Y$. Questo restituisce un teorema $\mathit{TCs}(Y) \vdash Y = Y'$. \item Ragionando in modo equazionale con (1), (2), e (3), deriva il teorema @@ -1728,8 +1728,8 @@ \subsubsection{Come sono sintetizzate le condizioni di terminazione} \end{enumerate} -Le condizioni di terminazione sono accumulate fino a quando -il processo di terminazione non finisce, ed appaiono come ipotesi nel risultato +Le condizioni di terminazione sono accumulate fino a quando +il processo di terminazione non finisce, ed appaiono come ipotesi nel risultato finale. Cos le condizioni di terminazione estratte per \holtxt{fact} sono % \begin{hol} @@ -1739,9 +1739,9 @@ \subsubsection{Come sono sintetizzate le condizioni di terminazione} \end{verbatim} \end{hol} % -e sono facili da dimostrare. La nozione di \emph{contesto} di una chiamata ricorsiva - definita dall'insieme di regole di congruenza usate nell'estrazione delle condizioni -di terminazione. Questo insieme si pu ottenere invocando \holtxt{DefnBase.read\_congs}, +e sono facili da dimostrare. La nozione di \emph{contesto} di una chiamata ricorsiva + definita dall'insieme di regole di congruenza usate nell'estrazione delle condizioni +di terminazione. Questo insieme si pu ottenere invocando \holtxt{DefnBase.read\_congs}, e manipolare con \holtxt{DefnBase.add\_cong}, \holtxt{DefnBase.drop\_cong} e \holtxt{DefnBase.export\_cong}. Le funzioni `add' e `drop' influenzano solo lo stato attuale del database di congruenza; per contro, la funzione `export' fornisce un modo per le teorie di specificare che un particolare teorema dovrebbe essere aggiunto al database di congruenza in tutte le teorie discendenti. @@ -1752,17 +1752,17 @@ \subsubsection{Come sono sintetizzate le condizioni di terminazione} \paragraph{Ricorsione di Ordine Superiore e Regole di Congruenza} -Una ricorsione di `ordine superiore' una in cui una funzione di ordine superiore -usata per applicare la funzione ricorsiva agli argomenti. Al fine di -dimostrare le condizioni di terminazione corrette per una tale ricorsione, -le regole di congruenza per la funzione di ordine superiore devono essere conosciute -dal meccanismo di estrazione delle condizioni di terminazione. Le regole di congrueza per +Una ricorsione di `ordine superiore' una in cui una funzione di ordine superiore +usata per applicare la funzione ricorsiva agli argomenti. Al fine di +dimostrare le condizioni di terminazione corrette per una tale ricorsione, +le regole di congruenza per la funzione di ordine superiore devono essere conosciute +dal meccanismo di estrazione delle condizioni di terminazione. Le regole di congrueza per funzioni di ordine superiore comuni, ad esempio \holtxt{MAP}, \holtxt{EVERY}, and -\holtxt{EXISTS} per le liste, sono gi conosciute dal -meccanismo. Tuttavia, a volte, di deve dimostrare ed installare manualmente un +\holtxt{EXISTS} per le liste, sono gi conosciute dal +meccanismo. Tuttavia, a volte, di deve dimostrare ed installare manualmente un teorema di congruenza per una nuova funzione di ordine superiore definita dall'utente. -Per esempio, supponiamo di definire una funzione di ordine superiore \holtxt{SIGMA} per +Per esempio, supponiamo di definire una funzione di ordine superiore \holtxt{SIGMA} per sommare i risultati di una funzione in una lista. % \setcounter{sessioncount}{0} @@ -1773,8 +1773,8 @@ \subsubsection{Come sono sintetizzate le condizioni di terminazione} \end{verbatim} \end{session} % -Usiamo poi \holtxt{SIGMA} nella definizione di una funzione per -sommare i risultati di una funzione in un albero +Usiamo poi \holtxt{SIGMA} nella definizione di una funzione per +sommare i risultati di una funzione in un albero arbitrariamente (finitamente) ramificato. % \begin{session} @@ -1787,11 +1787,11 @@ \subsubsection{Come sono sintetizzate le condizioni di terminazione} \end{verbatim} \end{session} % -In questa definizione, \holtxt{SIGMA} applicato a un'applicazione parziale -\holtxt{(ltree\_sigma f)} della funzione da definire. Una tale situazione - chiamata una \emph{ricorsione di ordine superiore}. Dal momento che la chiamata ricorsiva di -\holtxt{ltree\_sigma} non applicata in modo completo, bisogna fare degli sforzi -speciali per estrarre le condizioni di terminazione corrette. Altrimenti, +In questa definizione, \holtxt{SIGMA} applicato a un'applicazione parziale +\holtxt{(ltree\_sigma f)} della funzione da definire. Una tale situazione + chiamata una \emph{ricorsione di ordine superiore}. Dal momento che la chiamata ricorsiva di +\holtxt{ltree\_sigma} non applicata in modo completo, bisogna fare degli sforzi +speciali per estrarre le condizioni di terminazione corrette. Altrimenti, risulta la seguente infelice situazione: % \begin{session} @@ -1812,13 +1812,13 @@ \subsubsection{Come sono sintetizzate le condizioni di terminazione} \end{session} % \index{regole di congruenza!nelle analisi di terminazione|(} -Le condizioni di terminazione per \holtxt{ltree\_sigma} sembrano -richiedere di trovare una relazione benfondata \holtxt{R} tale che la coppia -\holtxt{(f,a)} \holtxt{R}-minore di -\holtxt{(f, Node v tl)}. Tuttavia, questo un compito senza speranza, dal momento che non c' alcuna -relazione tra \holtxt{a} e \holtxt{Node v tl}, oltre al fatto -che entrambi sono \holtxt{ltree}. L'estrattore di condizioni di terminazione -non ha funzionato in modo appropriato, perch non conosceva una regola di congruenza +Le condizioni di terminazione per \holtxt{ltree\_sigma} sembrano +richiedere di trovare una relazione benfondata \holtxt{R} tale che la coppia +\holtxt{(f,a)} \holtxt{R}-minore di +\holtxt{(f, Node v tl)}. Tuttavia, questo un compito senza speranza, dal momento che non c' alcuna +relazione tra \holtxt{a} e \holtxt{Node v tl}, oltre al fatto +che entrambi sono \holtxt{ltree}. L'estrattore di condizioni di terminazione +non ha funzionato in modo appropriato, perch non conosceva una regola di congruenza per \holtxt{SIGMA}. Una tale teorema di congruenza il seguente: % \begin{hol} @@ -1854,8 +1854,8 @@ \subsubsection{Come sono sintetizzate le condizioni di terminazione} \subsection{Schemi di Ricorsione} -Nella logica di ordine superiore, possono essere definiti pattern molto generali di ricorsione, conosciuti come -\emph{schemi di ricorsione} o a volte \emph{schemi di programma}. +Nella logica di ordine superiore, possono essere definiti pattern molto generali di ricorsione, conosciuti come +\emph{schemi di ricorsione} o a volte \emph{schemi di programma}. Un esempio il seguente: % \[ @@ -1863,26 +1863,26 @@ \subsection{Schemi di Ricorsione} \itelse{d(x)}{e(x)}{f(\konst{linRec}(g\; x))} \] % -In questa specifica, le variabili $d$, $e$, $f$, e $g$ sono -funzioni, che, quando istanziate in modi differenti, permettono a -\konst{linRec} di implementare funzioni ricorsive differenti. In questo, -\konst{linRec} come molte altre funzioni di ordine superiore. Tuttavia, +In questa specifica, le variabili $d$, $e$, $f$, e $g$ sono +funzioni, che, quando istanziate in modi differenti, permettono a +\konst{linRec} di implementare funzioni ricorsive differenti. In questo, +\konst{linRec} come molte altre funzioni di ordine superiore. Tuttavia, si noti che se $d(x) = \konst{F}$, $f(x) = x+1$, e -$g(x) = x$, allora l'istanziazione risultante di +$g(x) = x$, allora l'istanziazione risultante di \konst{linRec} potrebbe essere usata per ottenere una contraddizione: % \[ \konst{linRec} (x) = \konst{linRec}(x) + 1 \] % -Questo, comunque, non derivabile in \HOL{}, perch gli schemi di ricorsione -sono definiti istanziando il teorema di ricorsione benfondata, e -pertanto sorgono certi vincoli astratti di terminazione che -devono essere soddisfatti prima che le equazioni di ricorsione possano essere usati senza -restrizioni. L'entrypoint per definire uno schema -\ml{TotalDefn.DefineSchema}. Nell'esempio \konst{linRec} -si comporta nel modo seguente (si noti che le variabili schematiche dovrebbero -occorrere solo sul lato destro della definizione quando si fa +Questo, comunque, non derivabile in \HOL{}, perch gli schemi di ricorsione +sono definiti istanziando il teorema di ricorsione benfondata, e +pertanto sorgono certi vincoli astratti di terminazione che +devono essere soddisfatti prima che le equazioni di ricorsione possano essere usati senza +restrizioni. L'entrypoint per definire uno schema +\ml{TotalDefn.DefineSchema}. Nell'esempio \konst{linRec} +si comporta nel modo seguente (si noti che le variabili schematiche dovrebbero +occorrere solo sul lato destro della definizione quando si fa la definizione di uno schema): % \setcounter{sessioncount}{0} @@ -1902,8 +1902,8 @@ \subsection{Schemi di Ricorsione} \end{verbatim} \end{session} % -Le ipotesi del teorema restituito soddisfano i vincoli astratti -di terminazione. Un teorema d'induzione vincolato in modo simile +Le ipotesi del teorema restituito soddisfano i vincoli astratti +di terminazione. Un teorema d'induzione vincolato in modo simile anche archiviato nel segmento attuale di teoria. % \begin{session} @@ -1913,10 +1913,10 @@ \subsection{Schemi di Ricorsione} \end{verbatim} \end{session} % -Questi vincoli sono astratti, dal momento che pongono dei requisiti di terminazione -su variabili che non sono state ancora istanziate. Una volta che sono trovate -istanziazioni per le variabili, i vincoli possono poi essere eliminati -trovando un'adeguata relazione benfondata per \holtxt{R} e poi +Questi vincoli sono astratti, dal momento che pongono dei requisiti di terminazione +su variabili che non sono state ancora istanziate. Una volta che sono trovate +istanziazioni per le variabili, i vincoli possono poi essere eliminati +trovando un'adeguata relazione benfondata per \holtxt{R} e poi dimostrando gli altri vincoli. \section{Relazioni Induttive} @@ -1924,12 +1924,12 @@ \section{Relazioni Induttive} \index{Hol_reln, definire relazioni induttive@\ml{Hol\_reln}, definire relazioni induttive} \index{relazioni induttive!Hol_reln (funzione ML)@\ml{Hol\_reln} (funzione ML)} -Le definizioni induttive sono fatte con la funzione \ml{Hol\_reln}, che si trova -nella struttura \ml{bossLib}, e le definizioni e i teoremi -risultanti sono gestiti con funzioni definite nella libreria -\ml{IndDefLib}. La funzione \ml{Hol\_reln} prende una -term quotation come input e tenta di definire le relazioni li -specificate. La term quotation di input deve essere parsata a un termine che +Le definizioni induttive sono fatte con la funzione \ml{Hol\_reln}, che si trova +nella struttura \ml{bossLib}, e le definizioni e i teoremi +risultanti sono gestiti con funzioni definite nella libreria +\ml{IndDefLib}. La funzione \ml{Hol\_reln} prende una +term quotation come input e tenta di definire le relazioni li +specificate. La term quotation di input deve essere parsata a un termine che si conforma alla seguente grammatica: \newcommand{\nonterm}[1]{\ensuremath{\langle\mathit{#1}\rangle}} \begin{eqnarray*} @@ -1942,30 +1942,30 @@ \section{Relazioni Induttive} \nonterm{ipotesi} &::=& \mbox{qualsiasi termine}\\ \nonterm{con} &::=& \mbox{una nuova costante di relazione} \end{eqnarray*} -I termini (opzionali) $\mathit{sv}_i$ che appaiono dopo il nome di una costante -sono le cosiddette ``variabili schematiche''. Le stesse variabili devono sempre -seguire tutte le costanti nuove in tutta la definizione. Queste variabili -e i nomi delle costanti-to-be non devono essere quantificate in -ciascuna {\nonterm{clausola}}. Una {\nonterm{clausola}} non dovrebbe avere -altre variabili libere. Qualunque variabile che occorra sar quantificata universalmente come parte -del processo di definizione, e sar emesso un messaggio di warning. -(I quantificatori universali alla testa della clausola possono essere usati per legare -le variabili libere, ma anche ammissibile usare la quantificazione -esistenziale nelle ipotesi. Se una clausola non ha variabili libere, +I termini (opzionali) $\mathit{sv}_i$ che appaiono dopo il nome di una costante +sono le cosiddette ``variabili schematiche''. Le stesse variabili devono sempre +seguire tutte le costanti nuove in tutta la definizione. Queste variabili +e i nomi delle costanti-to-be non devono essere quantificate in +ciascuna {\nonterm{clausola}}. Una {\nonterm{clausola}} non dovrebbe avere +altre variabili libere. Qualunque variabile che occorra sar quantificata universalmente come parte +del processo di definizione, e sar emesso un messaggio di warning. +(I quantificatori universali alla testa della clausola possono essere usati per legare +le variabili libere, ma anche ammissibile usare la quantificazione +esistenziale nelle ipotesi. Se una clausola non ha variabili libere, ammissibili non avere alcuna quantificazione universale.) -Un'invocazione di successo di \ml{Hol\_reln} restituisce tre teoremi -$(\mathit{rules},\mathit{ind},\mathit{cases})$. Ognuno anche archiviato nel +Un'invocazione di successo di \ml{Hol\_reln} restituisce tre teoremi +$(\mathit{rules},\mathit{ind},\mathit{cases})$. Ognuno anche archiviato nel segmento di teoria attuale. \begin{itemize} -\item $\mathit{rules}$ una congiunzione di implicazioni - che sar la stessa della term quotation di input; il teorema - salvato sotto il nome \ml{\_rules}, dove \ml{} il nome della +\item $\mathit{rules}$ una congiunzione di implicazioni + che sar la stessa della term quotation di input; il teorema + salvato sotto il nome \ml{\_rules}, dove \ml{} il nome della prima relazione definita dalla funzione. -\item $\mathit{ind}$ il principio d'induzione per le relazioni, +\item $\mathit{ind}$ il principio d'induzione per le relazioni, salvato sotto il nome \ml{\_ind}. -\item $\mathit{cases}$ il cosiddetto teorema dei `casi' o di `inversione' - per le relazioni, salvato sotto il nome \ml{\_cases}. Un teorema +\item $\mathit{cases}$ il cosiddetto teorema dei `casi' o di `inversione' + per le relazioni, salvato sotto il nome \ml{\_cases}. Un teorema dei casi della forma % \begin{verbatim} @@ -1978,7 +1978,7 @@ \section{Relazioni Induttive} ... \end{verbatim} % -ed usato per decomporre un elemento nella relazione nei +ed usato per decomporre un elemento nella relazione nei possibili modi di ottenerlo dalle regole. \end{itemize} @@ -1992,24 +1992,24 @@ \section{Relazioni Induttive} \paragraph{Aggiungere Operatori Monotoni} \index{relazioni induttive!operatori monotoni per} -Nuove costanti possono occorrere ricorsivamente all'interno delle ipotesi delle regole, purch -si possa dimostrare che le regole rimangono monotone rispetto alle -nuove costanti. \ml{Hol\_reln} tenter di dimostrare automaticamente tali -risultati di monotonicit, usando un insieme di teoremi mantenuti in una reference +Nuove costanti possono occorrere ricorsivamente all'interno delle ipotesi delle regole, purch +si possa dimostrare che le regole rimangono monotone rispetto alle +nuove costanti. \ml{Hol\_reln} tenter di dimostrare automaticamente tali +risultati di monotonicit, usando un insieme di teoremi mantenuti in una reference \ml{IndDefLib.the\_monoset}. I teoremi di monotonicit devono essere della forma \[ \mathit{cond}_1 \land \cdots \land \mathit{cond}_m \Rightarrow (\mathit{Op}\;\mathit{arg}_1 \dots \mathit{arg}_n \Rightarrow \mathit{Op}\;\mathit{arg}'_1 \dots \mathit{arg}'_n) \] -dove ciascun termine $\mathit{arg}$ e $\mathit{arg}'$ deve avere una variabile, -e dove ci devono essere tanti termini $\mathit{cond}_i$ quanti sono gli -argomenti a $\mathit{Op}$ che variano. Ciascun $\mathit{cond}_i$ deve essere +dove ciascun termine $\mathit{arg}$ e $\mathit{arg}'$ deve avere una variabile, +e dove ci devono essere tanti termini $\mathit{cond}_i$ quanti sono gli +argomenti a $\mathit{Op}$ che variano. Ciascun $\mathit{cond}_i$ deve essere della forma \[ \forall \vec{v}. \;\mathit{arg}\;\vec{v} \Rightarrow \mathit{arg}'\;\vec{v} \] -dove il vettore di variabili $\vec{v}$ pu essere vuoto, e dove i -$\mathit{arg}$ e $\mathit{arg}'$ possono essere di fatto invertiti (come nella +dove il vettore di variabili $\vec{v}$ pu essere vuoto, e dove i +$\mathit{arg}$ e $\mathit{arg}'$ possono essere di fatto invertiti (come nella regola per la negazione). Per esempio, la regola di monotonicit per la congiunzione @@ -2017,28 +2017,28 @@ \section{Relazioni Induttive} (P \Rightarrow P') \land (Q \Rightarrow Q') \Rightarrow (P \land Q \Rightarrow P' \land Q') \] -La regola di monotonicit per l'operatore \holtxt{EVERY} nella teoria delle -liste (si veda la Sezione~\ref{avra_list}), +La regola di monotonicit per l'operatore \holtxt{EVERY} nella teoria delle +liste (si veda la Sezione~\ref{avra_list}), \[ (\forall x. \;P(x) \Rightarrow Q(x)) \Rightarrow (\holtxt{EVERY}\;P\;\ell \Rightarrow \holtxt{EVERY}\;Q\;\ell) \] -Con un risultato di monotonicit disponibile per un operatore come -\holtxt{EVERY}, poi possibile scrivere definizioni induttive -dove le ipotesi includono una menzione della nuova relazione come argomenti agli +Con un risultato di monotonicit disponibile per un operatore come +\holtxt{EVERY}, poi possibile scrivere definizioni induttive +dove le ipotesi includono una menzione della nuova relazione come argomenti agli operatori dati. \index{export_mono (funzione ML)@\ml{export\_mono} (funzione \ML{})} -I risultati di monotonicit che l'utente deriva possono essere archiviati nella variabile -globale \ml{the\_monoset} usando la funzione \ml{export\_mono}. -Questa funzione prende una stringa che nomina un teorema nel segmento di teoria -attuale, e aggiunge quel teorema ai teoremi di monotonicit -immediatamente, e in un tal modo che questa situazione si otterr anche quando +I risultati di monotonicit che l'utente deriva possono essere archiviati nella variabile +globale \ml{the\_monoset} usando la funzione \ml{export\_mono}. +Questa funzione prende una stringa che nomina un teorema nel segmento di teoria +attuale, e aggiunge quel teorema ai teoremi di monotonicit +immediatamente, e in un tal modo che questa situazione si otterr anche quando la teoria attuale successivamente ricaricata. \paragraph{Esempi} -Un semplice esempio di definizione di due relazioni mutuamente ricorsive +Un semplice esempio di definizione di due relazioni mutuamente ricorsive il seguente: % \setcounter{sessioncount}{0} @@ -2075,10 +2075,10 @@ \section{Relazioni Induttive} \end{verbatim} \end{session} % -Il prossimo esempio mostra come definire induttivamente la chiusura riflessiva e -transitiva di una relazione $R$. Si noti che \holtxt{R}, come una -variabile schematica, non quantificata nelle regole. Questo -appropriato perch \holtxt{RTC R} che ha la caratterizzazione +Il prossimo esempio mostra come definire induttivamente la chiusura riflessiva e +transitiva di una relazione $R$. Si noti che \holtxt{R}, come una +variabile schematica, non quantificata nelle regole. Questo +appropriato perch \holtxt{RTC R} che ha la caratterizzazione induttiva, \holtxt{RTC} di per s. % \begin{session} @@ -2101,9 +2101,9 @@ \section{Relazioni Induttive} \end{verbatim} \end{session} % -La funzione \ml{Hol\_reln} pu essere usata per definire relazioni multiple, -come nella definizione di \holtxt{EVEN} e \holtxt{ODD}. Le relazioni -possono essere mutuamente ricorsive o meno. Le clausole per ciascuna relazione +La funzione \ml{Hol\_reln} pu essere usata per definire relazioni multiple, +come nella definizione di \holtxt{EVEN} e \holtxt{ODD}. Le relazioni +possono essere mutuamente ricorsive o meno. Le clausole per ciascuna relazione non hanno bisogno di essere contigue. \subsection{Dimostrazioni con Relazioni Induttive} @@ -2132,10 +2132,10 @@ \subsection{Dimostrazioni con Relazioni Induttive} HO_MATCH_MP_TAC R_ind \end{verbatim} \index{Induct_on (tattica d'induzione ML)@\ml{Induct\_on} (tattica d'induzione \ML{})} -Un approccio leggermente di pi alto livello di usare la tattica \ml{Induct\_on}. -(Questa tattica anche usata per eseguire induzioni strutturali su tipi di dato algebrici; si veda la Sezione~\ref{sec:bossLib}.) +Un approccio leggermente di pi alto livello di usare la tattica \ml{Induct\_on}. +(Questa tattica anche usata per eseguire induzioni strutturali su tipi di dato algebrici; si veda la Sezione~\ref{sec:bossLib}.) Quando si esegue una regola d'induzione, la quotation passata a \ml{Induct\_on} dovrebbe essere della costante usata. -Per questioni estetiche, la costante pu anche essere applicata a degli argomenti. +Per questioni estetiche, la costante pu anche essere applicata a degli argomenti. Cos, si pu scrivere \begin{verbatim} Induct_on `R` diff --git a/Manual/Translations/IT/Description/description.tex b/Manual/Translations/IT/Description/description.tex index 471d096294..0e1cf789cd 100644 --- a/Manual/Translations/IT/Description/description.tex +++ b/Manual/Translations/IT/Description/description.tex @@ -6,8 +6,8 @@ % Lingua italiana.Start \usepackage[latin1]{inputenc} -\usepackage[T1]{fontenc} -\usepackage[italian]{babel} +\usepackage[T1]{fontenc} +\usepackage[italian]{babel} % lingua italiana.End \usepackage[notindex]{tocbibind} diff --git a/Manual/Translations/IT/Description/drules.tex b/Manual/Translations/IT/Description/drules.tex index b6c860875f..76f3658c55 100644 --- a/Manual/Translations/IT/Description/drules.tex +++ b/Manual/Translations/IT/Description/drules.tex @@ -1,47 +1,47 @@ \chapter{Regole d'inferenza derivate} \label{derived-rules} -La nozione di {\it dimostrazione\/} stata definita in modo astratto nel manuale -\LOGIC:\linebreak una dimostrazione di un sequente $(\Gamma,t)$ da un insieme di sequenti -$\Delta$ (rispetto a un sistema deduttivo ${\cal D}$) -una catena di sequenti culminanti in $(\Gamma,t)$, tale che ogni -elemento della catena o appartiene a $\Delta$ o altrimenti segue da -$\Delta$ e dagli elementi precedenti della catena per deduzione. Anche la nozione -di {\it teorema\/} stata definita in \LOGIC: un teorema di un -sistema deduttivo un sequente che segue dall'insieme vuoto di -sequenti per deduzione; cio, l'ultimo elemento di una dimostrazione -dall'insieme vuoto di sequenti, nel sistema deduttivo. In questa sezione, +La nozione di {\it dimostrazione\/} stata definita in modo astratto nel manuale +\LOGIC:\linebreak una dimostrazione di un sequente $(\Gamma,t)$ da un insieme di sequenti +$\Delta$ (rispetto a un sistema deduttivo ${\cal D}$) +una catena di sequenti culminanti in $(\Gamma,t)$, tale che ogni +elemento della catena o appartiene a $\Delta$ o altrimenti segue da +$\Delta$ e dagli elementi precedenti della catena per deduzione. Anche la nozione +di {\it teorema\/} stata definita in \LOGIC: un teorema di un +sistema deduttivo un sequente che segue dall'insieme vuoto di +sequenti per deduzione; cio, l'ultimo elemento di una dimostrazione +dall'insieme vuoto di sequenti, nel sistema deduttivo. In questa sezione, le dimostrazioni e i teoremi sono resi concreti in \HOL. -Il sistema deduttivo di \HOL\ - stato abbozzato nella Sezione~\ref{rules}, dove -le otto famiglie d'inferenze primitive che compongono il -sistema deduttivo sono state specificate da diagrammi. E' stato spiegato che -queste famiglie d'inferenze sono rappresentate in \HOL\ attraverso -funzioni \ML, e che i teoremi -sono rappresentati da un tipo \ML\ astratto chiamato \ml{thm}\index{thm@\ml{thm}}. -Le otto funzioni \ML\ corrispondenti alle inferenze -sono operazioni sul tipo \ml{thm}, ed ognuna delle otto -restituisce un valore di tipo \ml{thm}. E' stato spiegato che il -tipo \ml{thm} ha dei de-costruttori primitivi, ma nessun costruttore -primitivo; e che in questo modo, la logica protetta contro -la possibilit di computare teoremi se non per mezzo di funzioni che rappresentano +Il sistema deduttivo di \HOL\ + stato abbozzato nella Sezione~\ref{rules}, dove +le otto famiglie d'inferenze primitive che compongono il +sistema deduttivo sono state specificate da diagrammi. E' stato spiegato che +queste famiglie d'inferenze sono rappresentate in \HOL\ attraverso +funzioni \ML, e che i teoremi +sono rappresentati da un tipo \ML\ astratto chiamato \ml{thm}\index{thm@\ml{thm}}. +Le otto funzioni \ML\ corrispondenti alle inferenze +sono operazioni sul tipo \ml{thm}, ed ognuna delle otto +restituisce un valore di tipo \ml{thm}. E' stato spiegato che il +tipo \ml{thm} ha dei de-costruttori primitivi, ma nessun costruttore +primitivo; e che in questo modo, la logica protetta contro +la possibilit di computare teoremi se non per mezzo di funzioni che rappresentano inferenze primitive, o loro composizioni. -Infine, la logica \HOL\ primitiva stata integrata di tre costanti -primitive e quattro assiomi, per formare la logica base. Le inferenze -primitive, insieme con le costanti primitive, i quattro assiomi, -e una collezione di definizioni, forniscono un punto iniziale per -costruire dimostrazioni, e di conseguenza computare teoremi. Tuttavia, dimostrare -persino i teoremi pi semplici a partire da questa base minimale costa uno sforzo -considerevole. La base non fornisce immediatamente la transitivit -dell'eguaglianza, per esempio, o un mezzo per la quantificazione universale; entrambe +Infine, la logica \HOL\ primitiva stata integrata di tre costanti +primitive e quattro assiomi, per formare la logica base. Le inferenze +primitive, insieme con le costanti primitive, i quattro assiomi, +e una collezione di definizioni, forniscono un punto iniziale per +costruire dimostrazioni, e di conseguenza computare teoremi. Tuttavia, dimostrare +persino i teoremi pi semplici a partire da questa base minimale costa uno sforzo +considerevole. La base non fornisce immediatamente la transitivit +dell'eguaglianza, per esempio, o un mezzo per la quantificazione universale; entrambe devono a loro volta essere derivate. \section{Derivazioni Semplici} -Come illustrazione di una dimostrazione in \HOL{}, la seguente catena di -teoremi forma una dimostrazione (dall'insieme vuoto, nel sistema deduttivo +Come illustrazione di una dimostrazione in \HOL{}, la seguente catena di +teoremi forma una dimostrazione (dall'insieme vuoto, nel sistema deduttivo \HOL{}), per i particolari termini \ml{``}$t_1$\ml{``}%'' e \ml{``}$t_2$\ml{``}, %'' entrambi del tipo \HOL\ \ml{``:bool``}:%'' @@ -56,7 +56,7 @@ \section{Derivazioni Semplici} \noindent Cio, il terzo teorema segue dal primo e dal secondo. -Nella sessione di sotto, la dimostrazione eseguita nel sistema \HOL, +Nella sessione di sotto, la dimostrazione eseguita nel sistema \HOL, usando le funzioni \ML\ \ml{ASSUME}\index{ASSUME@\ml{ASSUME}} e \ml{MP}. @@ -77,7 +77,7 @@ \section{Derivazioni Semplici} \end{verbatim} \end{session} -\noindent Pi in breve, si potrebbe valutare la seguente, e `contare'\index{contare le inferenze, nelle dimostrazioni HOL@contare le inferenze, nelle dimostrazioni \HOL{}} le +\noindent Pi in breve, si potrebbe valutare la seguente, e `contare'\index{contare le inferenze, nelle dimostrazioni HOL@contare le inferenze, nelle dimostrazioni \HOL{}} le invocazioni delle funzioni che rappresentano inferenze primitive. \begin{session} @@ -93,51 +93,51 @@ \section{Derivazioni Semplici} \end{verbatim} \end{session} -\noindent Ciascuno dei tre passi d'inferenza della dimostrazione astratta +\noindent Ciascuno dei tre passi d'inferenza della dimostrazione astratta corrisponde all'applicazione % % \index{inferenze, nella logica HOL@inferenze, nella logica \HOL{}!come applicazioni di funzioni ML@come applicazioni di funzioni \ML}% \index{passi di dimostrazione, come applicazioni di funzioni ML@passi di dimostrazione, come applicazioni di funzioni \ML}% -\index{dimostrazione!la nozione di, nel sistema HOL@la nozione +\index{dimostrazione!la nozione di, nel sistema HOL@la nozione di, nel sistema \HOL}% % -di una funzione \ML\ nell'esecuzione della dimostrazione in \HOL; e ciascuna -delle funzioni \ML\ corrisponde a un'inferenza primitiva del +di una funzione \ML\ nell'esecuzione della dimostrazione in \HOL; e ciascuna +delle funzioni \ML\ corrisponde a un'inferenza primitiva del sistema deduttivo. -E' bene sottolineare che, in entrambi i casi, fatta ogni -inferenza primitiva nella catena di dimostrazione, nel senso -che per ogni inferenza, valutata la corrispondente funzione \ML. Cio, -\HOL\ non permette alcuna scorciatoia circa la necessit di eseguire -dimostrazioni complete. La scorciatoia fornita dalle regole -d'inferenza derivate\index{inferenze, nella logica HOL@inferenze, nella logica \HOL{}!nelle regole derivate} -(come implementate in \ML) riguarda la necessit di -\emph{specificare} ogni passo; un qualcosa che sarebbe impossibile per -una dimostrazione di qualsiasi lunghezza. Si pu vedere da questo che la regola +E' bene sottolineare che, in entrambi i casi, fatta ogni +inferenza primitiva nella catena di dimostrazione, nel senso +che per ogni inferenza, valutata la corrispondente funzione \ML. Cio, +\HOL\ non permette alcuna scorciatoia circa la necessit di eseguire +dimostrazioni complete. La scorciatoia fornita dalle regole +d'inferenza derivate\index{inferenze, nella logica HOL@inferenze, nella logica \HOL{}!nelle regole derivate} +(come implementate in \ML) riguarda la necessit di +\emph{specificare} ogni passo; un qualcosa che sarebbe impossibile per +una dimostrazione di qualsiasi lunghezza. Si pu vedere da questo che la regola derivata,% % \index{dimostrazioni, nella logica HOL@dimostrazioni, nella logica \HOL{}!come applicazioni di funzioni ML@come applicazioni di funzioni \ML} \index{dimostrazioni, nella logica HOL@dimostrazioni, nella logica \HOL{}!cos come generate da regole derivate} \index{regole derivate, nella logica HOL@regole derivate, nella logica \HOL{}!importanza delle} % -e la sua rappresentazione come una funzione \ML{}, essenziale alla +e la sua rappresentazione come una funzione \ML{}, essenziale alla metodologia \HOL{}; la dimostrazione di teoremi altrimenti sarebbe impossibile. -Ci sono, naturalmente, un numero infinito di dimostrazioni, della `forma' -mostrata nell'esempio, che possono essere condotte in \HOL: una per ogni +Ci sono, naturalmente, un numero infinito di dimostrazioni, della `forma' +mostrata nell'esempio, che possono essere condotte in \HOL: una per ogni coppia di termini tipizzati \ml{``:bool``}. %'' Inoltre, ogni volta che richiesto un teorema della forma $$t_1 \ \imp \ t_2, \ t_1 \ \vdash \ t_2,$$ -\noindent la sua dimostrazione deve essere costruita da capo. Per catturare il -pattern generale dell'inferenza, si pu scrivere una funzione \ML\ per +\noindent la sua dimostrazione deve essere costruita da capo. Per catturare il +pattern generale dell'inferenza, si pu scrivere una funzione \ML\ per implementare una regola d'inferenza come una derivazione dalle inferenze primitive. Astrattamente, una \emph{regola d'inferenza derivata} \index{regole derivate, nella logica HOL@regole derivate, nella logica \HOL{}!giustificazione delle} % - una regola che pu essere giustificata sulla base delle regole -primitive\linebreak d'inferenza (e/o degli assiomi). Nel caso attuale, la regola + una regola che pu essere giustificata sulla base delle regole +primitive\linebreak d'inferenza (e/o degli assiomi). Nel caso attuale, la regola ha richiesto lo `scaricamento' delle assunzioni. Essa specificata per \HOL{} da \bigskip @@ -151,13 +151,13 @@ \section{Derivazioni Semplici} \bigskip -\noindent Questa regola generale valida perch da un teorema \HOL\ della +\noindent Questa regola generale valida perch da un teorema \HOL\ della forma $\Gamma${\small\verb% |- %}$t_1${\small\verb%==>%}$t_2$, si pu derivare il teorema -$\Gamma\cup\{t_1\}${\small\verb% |- %}$t_2$ +$\Gamma\cup\{t_1\}${\small\verb% |- %}$t_2$ come nell'esempio specifico di sopra. -La regola pu essere implementata in \ML\ come una funzione (diciamo -\ml{UNDISCH})\index{UNDISCH@\ml{UNDISCH}} che richiama la -sequenza appropriata d'inferenze +La regola pu essere implementata in \ML\ come una funzione (diciamo +\ml{UNDISCH})\index{UNDISCH@\ml{UNDISCH}} che richiama la +sequenza appropriata d'inferenze primitive. La definizione \ML\ di \ml{UNDISCH} semplicemente \begin{session} @@ -167,14 +167,14 @@ \section{Derivazioni Semplici} \end{verbatim} \end{session} -\noindent Questo fornisce una funzione che mappa un teorema a un teorema; +\noindent Questo fornisce una funzione che mappa un teorema a un teorema; cio, esegue dimostrazioni in \HOL. -La seguente sessione illustra l'uso della regola derivata, su -una conseguenza dell'assioma \ml{IMP\_ANTISYM\_AX}. (Le inferenze sono +La seguente sessione illustra l'uso della regola derivata, su +una conseguenza dell'assioma \ml{IMP\_ANTISYM\_AX}. (Le inferenze sono contate.% \index{contare le inferenze, nelle dimostrazioni HOL@contare le inferenze, nelle dimostrazioni \HOL{}}% % -) Assumiamo che la stampa dei teoremi sia stata aggiustata come di sopra e che +) Assumiamo che la stampa dei teoremi sia stata aggiustata come di sopra e che \ml{th} sia legato come mostrato di sotto: \setcounter{sessioncount}{1} @@ -200,34 +200,34 @@ \section{Derivazioni Semplici} \end{verbatim} \end{session} -\noindent Ogni applicazione di successo di {\small\verb%UNDISCH%} -a un teorema invoca un'applicazione -di {\small\verb%ASSUME%}, seguita da un'applicazione di {\small\verb%MP%}; -\ml{UNDISCH} costruisce la +\noindent Ogni applicazione di successo di {\small\verb%UNDISCH%} +a un teorema invoca un'applicazione +di {\small\verb%ASSUME%}, seguita da un'applicazione di {\small\verb%MP%}; +\ml{UNDISCH} costruisce la dimostrazione di due passi per qualsiasi teorema dato (della forma appropriata). -Come si pu -vedere, essa fa affidamento sulla classe delle funzioni \ML\ che accedono alla sintassi \HOL: -in particolare, \ml{concl} per produrre la conclusione -del teorema, \ml{dest\_imp} per separare l'implicazione, e il +Come si pu +vedere, essa fa affidamento sulla classe delle funzioni \ML\ che accedono alla sintassi \HOL: +in particolare, \ml{concl} per produrre la conclusione +del teorema, \ml{dest\_imp} per separare l'implicazione, e il selettore \ml{fst} per scegliere l'antecedente. -Questo esempio particolare molto semplice, ma una regola d'inferenza derivata -pu eseguire dimostrazioni di lunghezza arbitraria. Essa pu fare anche uso di -regole definite in precedenza. In questo modo, i normali pattern d'inferenza -possono essere sviluppati molto pi velocemente e facilmente; la transitivit, +Questo esempio particolare molto semplice, ma una regola d'inferenza derivata +pu eseguire dimostrazioni di lunghezza arbitraria. Essa pu fare anche uso di +regole definite in precedenza. In questo modo, i normali pattern d'inferenza +possono essere sviluppati molto pi velocemente e facilmente; la transitivit, la generalizzazione, e cos via, supportano i pattern d'inferenza familiari. -Quando si entra nel sistema \HOL\ sono pre-definite un numero di regole -d'inferenza derivate (di cui \ml{UNDISCH} una delle prime). Nella -Sezione~\ref{avra_standard}, sono date le derivazioni astratte per -le regole pre-definite che riflettono i pattern d'inferenza pi usuali -del calcolo predicativo (e del lambda calcolo). Come quelle mostrate, alcune delle -regole derivate pre-definite in \HOL\ generano dimostrazioni relativamente corte. -Altre invocano migliaia d'inferenze primitive, e chiaramente risparmiano una -grande quantit di sforzo. Inoltre, possono essere definite dall'utente regole per +Quando si entra nel sistema \HOL\ sono pre-definite un numero di regole +d'inferenza derivate (di cui \ml{UNDISCH} una delle prime). Nella +Sezione~\ref{avra_standard}, sono date le derivazioni astratte per +le regole pre-definite che riflettono i pattern d'inferenza pi usuali +del calcolo predicativo (e del lambda calcolo). Come quelle mostrate, alcune delle +regole derivate pre-definite in \HOL\ generano dimostrazioni relativamente corte. +Altre invocano migliaia d'inferenze primitive, e chiaramente risparmiano una +grande quantit di sforzo. Inoltre, possono essere definite dall'utente regole per fare passi ancora pi ampi, o per implementare pattern pi specializzati. -Tutte le regole derivate pre-definite in \HOL\ sono descritte +Tutte le regole derivate pre-definite in \HOL\ sono descritte in \REFERENCE. \section{Riscrittura} @@ -235,65 +235,65 @@ \section{Riscrittura} \index{riscrittura!regole per|(} \index{REWRITE_RULE@\ml{REWRITE\_RULE}|(} -Nell'insieme d'inferenze derivate che sono pre-definite in -\HOL\ incluso un gruppo di regole con delle definizioni complesse che eseguono una limitata -quantit di dimostrazione `automatica' di teoremi in forma di riscrittura. L'idea -e l'implementazione furono sviluppate originariamente da -Milner\index{Milner, R.} e Wadsworth\index{Wadsworth, C.} per -l'\LCF\ di Edimburgo\index{LCF@\LCF!Edinburgh}, e furono successivamente implementate +Nell'insieme d'inferenze derivate che sono pre-definite in +\HOL\ incluso un gruppo di regole con delle definizioni complesse che eseguono una limitata +quantit di dimostrazione `automatica' di teoremi in forma di riscrittura. L'idea +e l'implementazione furono sviluppate originariamente da +Milner\index{Milner, R.} e Wadsworth\index{Wadsworth, C.} per +l'\LCF\ di Edimburgo\index{LCF@\LCF!Edinburgh}, e furono successivamente implementate in modo pi flessibile ed efficiente da Paulson\index{Paulson, L.} e Huet\index{Huet, G.} per l'\LCF\ di Cambridge\index{LCF@\LCF!Cambridge}. -Esse appaiono in \HOL{} nella forma di Cambridge. La regola base di riscrittura - \ml{REWRITE\_RULE}. Tutte le regole di riscrittura sono descritte in +Esse appaiono in \HOL{} nella forma di Cambridge. La regola base di riscrittura + \ml{REWRITE\_RULE}. Tutte le regole di riscrittura sono descritte in dettaglio in \REFERENCE. -\ml{REWRITE\_RULE} usa una lista di teoremi equazionali +\ml{REWRITE\_RULE} usa una lista di teoremi equazionali \index{teoremi equazionali, nella logica HOL@teoremi equazionali, nella logica \HOL{}!uso dei \ldots nella riscrittura} \index{teoremi, nella logica HOL@teoremi, nella logica \HOL{}!equazionali} -(teoremi le cui conclusioni possono essere considerate avere la forma -$t_1${\small\verb% = %}$t_2$) per sostituire -qualsiasi sottotermine di un teorema oggetto che `matcha' $t_1$ con -l'istanza corrispondente di $t_2$. La regola esegue un matching ricorsivo e a tutte le profondit, -fino a quando non possono essere fatte ulteriori sostituzioni, -usando algoritmi di ricerca, matching e -istanziazione\index{istanziazione di tipo, nella logica HOL@istanziazione di tipo, nella logica \HOL{}!nella regola di riscrittura} definiti internamente. La validit - di \ml{REWRITE\_RULE} si appoggia -in definitiva sulle regole primitive \ml{SUBST} (per eseguire le sostituzioni); -\ml{INST\_TYPE}\index{INST_TYPE@\ml{INST\_TYPE}} (per istanziare i tipi); e le regole derivate per -la generalizzazione e la specializzazione (si vedano le Sezioni~\ref{avra_gen} -e \ref{avra_spec}) per istanziare i termini. La definizione -di \ml{REWRITE\_RULE} in \ML\ -si basa anche su un grande numero di funzioni \ML\ generali +(teoremi le cui conclusioni possono essere considerate avere la forma +$t_1${\small\verb% = %}$t_2$) per sostituire +qualsiasi sottotermine di un teorema oggetto che `matcha' $t_1$ con +l'istanza corrispondente di $t_2$. La regola esegue un matching ricorsivo e a tutte le profondit, +fino a quando non possono essere fatte ulteriori sostituzioni, +usando algoritmi di ricerca, matching e +istanziazione\index{istanziazione di tipo, nella logica HOL@istanziazione di tipo, nella logica \HOL{}!nella regola di riscrittura} definiti internamente. La validit + di \ml{REWRITE\_RULE} si appoggia +in definitiva sulle regole primitive \ml{SUBST} (per eseguire le sostituzioni); +\ml{INST\_TYPE}\index{INST_TYPE@\ml{INST\_TYPE}} (per istanziare i tipi); e le regole derivate per +la generalizzazione e la specializzazione (si vedano le Sezioni~\ref{avra_gen} +e \ref{avra_spec}) per istanziare i termini. La definizione +di \ml{REWRITE\_RULE} in \ML\ +si basa anche su un grande numero di funzioni \ML\ generali e \HOL-oriented. %The implementation is partly described in Chapter~\ref{avra_conv}. -In pratica, la regola derivata \ml{REWRITE\_RULE} gioca un ruolo centrale -nelle dimostrazioni, perch prende il posto di un grande numero d'inferenze -che potrebbero accadere in un ordine complesso e non prevedibile. E' diversa -da qualsiasi altra regola primitiva o pre-definita, primo per il numero -di inferenze che genera\footnote{Il numero di inferenze eseguite - da questa regola in generale `inflazionato'; cio, in genere pi grande della - lunghezza della dimostrazione stessa, se la dimostrazione si potesse `vedere'. Questo - accade perch, nell'attuale implementazione, alcune inferenze sono fatte - durante la fase di ricerca che non necessariamente sostiene delle - sostituzioni di successo.}; e secondo perch il suo risultato spesso -inaspettato. Il suo potere accresciuto dal fatto che qualsiasi teorema -equazionale esistente pu essere fornito come una `regola di riscrittura', incluso un -insieme \HOL\ standard di tautologie pre-dimostrate; e queste regole di riscrittura -possono interagire l'una con l'altra nel processo di riscrittura per trasformare il +In pratica, la regola derivata \ml{REWRITE\_RULE} gioca un ruolo centrale +nelle dimostrazioni, perch prende il posto di un grande numero d'inferenze +che potrebbero accadere in un ordine complesso e non prevedibile. E' diversa +da qualsiasi altra regola primitiva o pre-definita, primo per il numero +di inferenze che genera\footnote{Il numero di inferenze eseguite + da questa regola in generale `inflazionato'; cio, in genere pi grande della + lunghezza della dimostrazione stessa, se la dimostrazione si potesse `vedere'. Questo + accade perch, nell'attuale implementazione, alcune inferenze sono fatte + durante la fase di ricerca che non necessariamente sostiene delle + sostituzioni di successo.}; e secondo perch il suo risultato spesso +inaspettato. Il suo potere accresciuto dal fatto che qualsiasi teorema +equazionale esistente pu essere fornito come una `regola di riscrittura', incluso un +insieme \HOL\ standard di tautologie pre-dimostrate; e queste regole di riscrittura +possono interagire l'una con l'altra nel processo di riscrittura per trasformare il teorema originale. -L'applicazione di \ml{REWRITE\_RULE}, nella sessione di sotto, -illustra che le sostituzioni sono eseguite a tutti i livelli della +L'applicazione di \ml{REWRITE\_RULE}, nella sessione di sotto, +illustra che le sostituzioni sono eseguite a tutti i livelli della struttura di un termine. L'esempio numerico; -gli infissi {\small\verb%"$>"%} e {\small\verb%"$<"%} sono -le usuali relazioni `maggiore di' e `minore di', rispettivamente, -e \ml{"SUC"}, +gli infissi {\small\verb%"$>"%} e {\small\verb%"$<"%} sono +le usuali relazioni `maggiore di' e `minore di', rispettivamente, +e \ml{"SUC"}, l'usuale funzione successore. Si usa la definizione pre-esistente di {\small\verb%"$>"%}: \ml{GREATER} (si veda \REFERENCE). -Si usa di nuovo la funzionalit di timinig\index{contare le inferenze, nelle dimostrazioni HOL@contare le inferenze, nelle dimostrazioni \HOL{}}, a titolo informativo, e la stampa +Si usa di nuovo la funzionalit di timinig\index{contare le inferenze, nelle dimostrazioni HOL@contare le inferenze, nelle dimostrazioni \HOL{}}, a titolo informativo, e la stampa di teoremi aggiustata come sopra. @@ -324,13 +324,13 @@ \section{Riscrittura} \end{verbatim} \end{session} -\noindent Si noti che le equazioni -di riscrittura possono essere estratte da -teoremi quantificati universalmente. -Costruire la -dimostrazione passo passo, con tutte le istanziazioni, -sostituzioni, ed usi della transitivit, ecc, -sarebbe un processo lungo. Le regole di riscrittura lo rendono facile, +\noindent Si noti che le equazioni +di riscrittura possono essere estratte da +teoremi quantificati universalmente. +Costruire la +dimostrazione passo passo, con tutte le istanziazioni, +sostituzioni, ed usi della transitivit, ecc, +sarebbe un processo lungo. Le regole di riscrittura lo rendono facile, e lo fanno pur continuando a generare l'intera catena d'inferenze. \index{REWRITE_RULE@\ml{REWRITE\_RULE}|)} \index{riscrittura!regole per|)} @@ -340,72 +340,72 @@ \section{Derivazione delle Regole Standard} \index{regole derivate, nella logica HOL@regole derivate, nella logica \HOL{}!pre-definite|(} % -Il sistema \HOL{} fornisce tutte le regole standard d'introduzione ed -eliminazione del calcolo dei predicato pre-definite come inferenze -derivate. Sono queste regole, piuttosto che le regole -primitive, che normalmente si usano in pratica. In questa sezione, sono date -le derivazioni di alcune delle regole standard, in sequenza. -Queste derivazioni usano solo gli assiomi e le definizioni nella teoria -\theoryimp{bool} (si veda la Sezione~\ref{boolfull}), le otto regole -d'inferenza primitive della logica \HOL, e le inferenze definite in precedenza nella +Il sistema \HOL{} fornisce tutte le regole standard d'introduzione ed +eliminazione del calcolo dei predicato pre-definite come inferenze +derivate. Sono queste regole, piuttosto che le regole +primitive, che normalmente si usano in pratica. In questa sezione, sono date +le derivazioni di alcune delle regole standard, in sequenza. +Queste derivazioni usano solo gli assiomi e le definizioni nella teoria +\theoryimp{bool} (si veda la Sezione~\ref{boolfull}), le otto regole +d'inferenza primitive della logica \HOL, e le inferenze definite in precedenza nella sequenza. I teoremi,% % \index{teoremi, nella logica HOL@teoremi, nella logica \HOL{}!come regole d'inferenza}% % -in accordo con la definizione data all'inizio di questo -capitolo, sono trattati come regole senza ipotesi; cos la derivazione -di un teorema assomiglia alla derivazione di una regola eccetto per il fatto che non -ha ipotesi. (La derivazione di \ml{TRUTH}, Sezione~\ref{avra_T}, -l'unico esempio dato di questo, ma ce ne sono molti altri in \HOL.) -Ci sono anche alcune regole che sono intrinsecamente pi generali dei -teoremi. Per esempio, per ogni due termini $t_1$ e $t_2$, il teorema -$\vdash(\lquant{x}t_1)t_2 = t_1[t_2/x]$ segue dala regola primitiva -\rul{BETA\_CONV}. La regola \ml{BETA\_CONV} restituisce un teorema per ogni -coppia di termini $t_1$ e $t_2$, ed quindi equivalente a una +in accordo con la definizione data all'inizio di questo +capitolo, sono trattati come regole senza ipotesi; cos la derivazione +di un teorema assomiglia alla derivazione di una regola eccetto per il fatto che non +ha ipotesi. (La derivazione di \ml{TRUTH}, Sezione~\ref{avra_T}, +l'unico esempio dato di questo, ma ce ne sono molti altri in \HOL.) +Ci sono anche alcune regole che sono intrinsecamente pi generali dei +teoremi. Per esempio, per ogni due termini $t_1$ e $t_2$, il teorema +$\vdash(\lquant{x}t_1)t_2 = t_1[t_2/x]$ segue dala regola primitiva +\rul{BETA\_CONV}. La regola \ml{BETA\_CONV} restituisce un teorema per ogni +coppia di termini $t_1$ e $t_2$, ed quindi equivalente a una famiglia infinita % % \index{famiglie d'inferenze, nella logica HOL@famiglie d'inferenze, nella logica \HOL{}}% -% -di teoremi. Nella logica \HOL{} non possibile esprimere alcun teorema singolo +% +di teoremi. Nella logica \HOL{} non possibile esprimere alcun teorema singolo che sia equivalente a \rul{BETA\_CONV}.% \index{teoremi, nella logica HOL@teoremi, nella logica \HOL{}!regole non esprimibili come} \index{beta-conversione, nella logica HOL@beta-conversione, nella logica \HOL{}!non esprimibile come un teorema}% % %(See Chapter~\ref{avra_conv} for further discussion of this point.) -(\ml{UNDISCH} non una regola di questo tipo, dal momento che pu, di fatto, essere +(\ml{UNDISCH} non una regola di questo tipo, dal momento che pu, di fatto, essere espressa come un teorema.) -Per ogni derivazione data di sotto, c' la definizione di una funzione \ML\ -nel sistema \HOL\ che implementa la regola derivata come una procedura in -\ML. L'attuale implementazione nel sistema \HOL\ differisce in qualche -caso dalle derivazioni date qui, dal momento che il codice del sistema stato +Per ogni derivazione data di sotto, c' la definizione di una funzione \ML\ +nel sistema \HOL\ che implementa la regola derivata come una procedura in +\ML. L'attuale implementazione nel sistema \HOL\ differisce in qualche +caso dalle derivazioni date qui, dal momento che il codice del sistema stato ottimizzato per performance migliori. -Inoltre per ragioni che sono pi che altro storiche, non tutte le -inferenze che sono derivate in termini della logica astratta sono -di fatto derivate nella versione attuale del sistema \HOL. Pi precisamente, -ci sono attualmente circa quaranta regole che sono installate nel sistema -su una base `assiomatica', ognuna delle quali dovrebbe essere derivata attraverso un'inferenza -esplicita. Bench lo stato attuale di queste regole non sia -soddisfacente, ed pianificato, con priorit alta, di derivarle -in modo appropriato in una versione futura, il loro stato attuale di fatto -non compromette la coerenza della logica. In effetti, il sistema -\HOL\ esistente ha un sistema deduttivo pi comprensivo di quello -presentato astrattamente, ma il modello delineato in \LOGIC{} si estenderebbe +Inoltre per ragioni che sono pi che altro storiche, non tutte le +inferenze che sono derivate in termini della logica astratta sono +di fatto derivate nella versione attuale del sistema \HOL. Pi precisamente, +ci sono attualmente circa quaranta regole che sono installate nel sistema +su una base `assiomatica', ognuna delle quali dovrebbe essere derivata attraverso un'inferenza +esplicita. Bench lo stato attuale di queste regole non sia +soddisfacente, ed pianificato, con priorit alta, di derivarle +in modo appropriato in una versione futura, il loro stato attuale di fatto +non compromette la coerenza della logica. In effetti, il sistema +\HOL\ esistente ha un sistema deduttivo pi comprensivo di quello +presentato astrattamente, ma il modello delineato in \LOGIC{} si estenderebbe facilmente per coprirlo.% % \index{regole derivate, nella logica HOL@regole derivate, nella logica \HOL{}!pre-definite|)} -A titolo informativo, nella Versione 2.0 di \HOL\ le seguenti regole che dovrebbero essere +A titolo informativo, nella Versione 2.0 di \HOL\ le seguenti regole che dovrebbero essere derivate % \index{regole d'inferenza, della logica HOL@regole d'inferenza, della logica \HOL{}!alcune \ldots non derivate in modo appropriato|(} \index{regole nella logica HOL, alcune \ldots non derivate in modo appropriato@regole nella logica \HOL{}, alcune \ldots non derivate in modo appropriato|(} % -non sono derivate, ma (per questioni di efficienza) sono implementate come -primitive. La lista include alcune conversioni e funzioni con valore +non sono derivate, ma (per questioni di efficienza) sono implementate come +primitive. La lista include alcune conversioni e funzioni con valore di conversioni. % (conversions are discussed in Chapter~\ref{avra_conv}). \vfill \newpage @@ -455,16 +455,16 @@ \section{Derivazione delle Regole Standard} \index{regole nella logica HOL, alcune \ldots non derivate in modo appropriato@regole nella logica \HOL{}, alcune \ldots non derivate in modo appropriato|(} \index{regole d'inferenza, della logica HOL@regole d'inferenza, della logica \HOL{}!derivate|(} -Le derivazioni che seguono consistono di sequenze di passi numerati ciascuno dei -quali +Le derivazioni che seguono consistono di sequenze di passi numerati ciascuno dei +quali \begin{enumerate} \item un assioma, oppure \item un'ipotesi della regola che si sta derivando, oppure -\item segue da passi precedenti per una regola d'inferenza (o primitiva +\item segue da passi precedenti per una regola d'inferenza (o primitiva o precedentemente derivata). \end{enumerate} -\noindent Si noti che l'abbreviazione \ml{conv} (che sta per +\noindent Si noti che l'abbreviazione \ml{conv} (che sta per `conversione') usata per il tipo \ML\ \ml{term -> thm}.% % \footnote{This stands for `conversion', as explained in @@ -740,8 +740,8 @@ \subsection{\texorpdfstring{Specializzazione ($\forall$-eliminazione)}{Specializ $$\Gamma\turn \uquant{x}t\over \Gamma\turn t[t'/x]$$ \begin{itemize} -\item $t[t'/x]$ denota il risultato della sostituzione di $t'$ per le occorrenze libere\index{variabili libere, nella logica HOL@variabili libere, nella logica \HOL{}} -di $x$ in $t$, con la restrizione che nessuna variabile libera in $t'$ +\item $t[t'/x]$ denota il risultato della sostituzione di $t'$ per le occorrenze libere\index{variabili libere, nella logica HOL@variabili libere, nella logica \HOL{}} +di $x$ in $t$, con la restrizione che nessuna variabile libera in $t'$ diventi legata dopo la sostituzione. \end{itemize} @@ -857,9 +857,9 @@ \subsection{\texorpdfstring{$\alpha$-conversione semplice}{alfa-conversione semp $$\turn(\lquant{x_1}t\ x_1) = (\lquant{x_2}t\ x_2)$$ \begin{itemize} -\item Dove n $x_1$ n $x_2$ occorre libera in $t$\footnote{\ml{SIMPLE\_ALPHA} -inclusa qui perch -usata in una derivazione successiva, ma di fatto non nel +\item Dove n $x_1$ n $x_2$ occorre libera in $t$\footnote{\ml{SIMPLE\_ALPHA} +inclusa qui perch +usata in una derivazione successiva, ma di fatto non nel sistema \HOL\ dal momento che sussunta da altre funzioni.}. \end{itemize} @@ -902,7 +902,7 @@ \subsection{\texorpdfstring{$\eta$-conversione}{Eta-conversione}} $$\turn(\lquant{x'}t\ x') = t$$ \begin{itemize} -\item Dove $x'$ non occorre libera\index{variabili libere, nella logica HOL@variabili libere, nella logica \HOL{}} in $t$ (usiamo $x'$ piuttosto che semplicemente $x$ +\item Dove $x'$ non occorre libera\index{variabili libere, nella logica HOL@variabili libere, nella logica \HOL{}} in $t$ (usiamo $x'$ piuttosto che semplicemente $x$ per motivare l'uso di \rul{SIMPLE\_ALPHA} nella derivazione di sotto). \end{itemize} @@ -969,7 +969,7 @@ \subsection{\texorpdfstring{$\hilbert$-introduzione}{Hilbert-introduzione}} \vspace{12pt plus2pt minus1pt} \begin{proof} -\item $\turn\uquant{P\ x}P\ x\imp P(\hilbert\ P)$\hfill [Assioma con un'adatta +\item $\turn\uquant{P\ x}P\ x\imp P(\hilbert\ P)$\hfill [Assioma con un'adatta istanziazione dei tipi] \item $\turn t_1\ t_2 \imp t_1(\hilbert\ t_1)$\hfill [\rul{SPEC} 1 (due volte)] \item $\Gamma\turn t_1\ t_2$\hfill [Ipotesi] @@ -993,7 +993,7 @@ \subsection{\texorpdfstring{$\hilbert$-eliminazione}{Hilbert-eliminazione}} $$\Gamma_1\turn t_1(\hilbert\ t_1)\qquad\qquad\qquad\Gamma_2,\ t_1\ v\turn t \over \Gamma_1\cup\Gamma_2\turn t$$ \begin{itemize} -\item Dove $v$ non occorre da nessuna parte eccetto nell'assunzione $t_1\ v$ della seconda +\item Dove $v$ non occorre da nessuna parte eccetto nell'assunzione $t_1\ v$ della seconda ipotesi. \end{itemize} @@ -1024,10 +1024,10 @@ \subsection{\texorpdfstring{$\exists$-introduzione}{Esiste-introduzione}} $$\Gamma\turn t_1[t_2]\over \Gamma\turn \equant{x}t_1[x]$$ \begin{itemize} -\item Dove $t_1[t_2]$ denota un termine $t_1$ con qualche occorrenza libera\index{variabili libere, nella logica HOL@variabili libere, nella logica \HOL{}} -di $t_2$ -scelta, e $t_1[x]$ denota il risultato di sostituire queste -occorrenze di $t_1$ con $x$, con la restrizione che $x$ +\item Dove $t_1[t_2]$ denota un termine $t_1$ con qualche occorrenza libera\index{variabili libere, nella logica HOL@variabili libere, nella logica \HOL{}} +di $t_2$ +scelta, e $t_1[x]$ denota il risultato di sostituire queste +occorrenze di $t_1$ con $x$, con la restrizione che $x$ non divenga legata dopo la sostituzione. \end{itemize} @@ -1068,10 +1068,10 @@ \subsection{\texorpdfstring{$\exists$-eliminazione}{Esiste-eliminazione}} $$\Gamma_1\turn\equant{x}t[x]\qquad\qquad\qquad \Gamma_2,\ t[v]\turn t' \over \Gamma_1\cup\Gamma_2\turn t'$$ \begin{itemize} -\item Dove $t[v]$ denota un termine $t$ con qualche occorrenza libera\index{variabili libere, nella logica HOL@variabili libere, nella logica \HOL{}} -della variabile $v$ -selezionata, e $t[x]$ denota il risultato di sostituire queste -occorrenze di $v$ con $x$, con la restrizione che $x$ non divenga +\item Dove $t[v]$ denota un termine $t$ con qualche occorrenza libera\index{variabili libere, nella logica HOL@variabili libere, nella logica \HOL{}} +della variabile $v$ +selezionata, e $t[x]$ denota il risultato di sostituire queste +occorrenze di $v$ con $x$, con la restrizione che $x$ non divenga legata dopo la sostituzione. \end{itemize} diff --git a/Manual/Translations/IT/Description/libraries.tex b/Manual/Translations/IT/Description/libraries.tex index 2a39d0f04b..1cfa97f54f 100644 --- a/Manual/Translations/IT/Description/libraries.tex +++ b/Manual/Translations/IT/Description/libraries.tex @@ -19,83 +19,83 @@ \chapter{Librerie}\label{HOLlibraries} \newcommand{\term} {\mbox{\it term}} \newcommand{\vstr} {\mbox{\it vstr}} -Una \emph{libreria} un'astrazione intesa fornire un livello pi alto -di organizzazione per applicazioni \HOL{}. In generale, una libreria pu -contenere una collezione di teorie, procedure di dimostrazione, e materiale -di supporto, come la documentazione. Alcune librerie forniscono semplicemente -procedure di dimostrazione, come \ml{simpLib}, mentre altre forniscono teorie e -procedure di dimostrazioni, tale che \ml{intLib}. Le librerie possono includere altre +Una \emph{libreria} un'astrazione intesa fornire un livello pi alto +di organizzazione per applicazioni \HOL{}. In generale, una libreria pu +contenere una collezione di teorie, procedure di dimostrazione, e materiale +di supporto, come la documentazione. Alcune librerie forniscono semplicemente +procedure di dimostrazione, come \ml{simpLib}, mentre altre forniscono teorie e +procedure di dimostrazioni, tale che \ml{intLib}. Le librerie possono includere altre librerie. -Nel sistema \HOL{}, le librerie sono tipicamente rappresentate da strutture -\ML{} nominate seguendo la convenzione che la libreria \emph{x} -si trover nella struttura \ML{} \ml{xLib}. Caricare questa struttura -dovrebbe caricare tutte le sotto-componenti rilevanti della libreria e settare +Nel sistema \HOL{}, le librerie sono tipicamente rappresentate da strutture +\ML{} nominate seguendo la convenzione che la libreria \emph{x} +si trover nella struttura \ML{} \ml{xLib}. Caricare questa struttura +dovrebbe caricare tutte le sotto-componenti rilevanti della libreria e settare qualunque parametro di sistema che sia appropriato per l'uso della libreria. -Quando il sistema \HOL{} invocato nella sua configurazione normale, alcune -utili librerie sono caricate automaticamente. La libreria \HOL{} -pi di base \ml{boolLib}, che supporta le definizioni della logica -\HOL{}, che si trova nella teoria \theoryimp{bool}, e fornisce un'utile +Quando il sistema \HOL{} invocato nella sua configurazione normale, alcune +utili librerie sono caricate automaticamente. La libreria \HOL{} +pi di base \ml{boolLib}, che supporta le definizioni della logica +\HOL{}, che si trova nella teoria \theoryimp{bool}, e fornisce un'utile suite di strumenti di definizione e ragionamento. -Un'altra libreria usata in modo pervasivo si trova nella struttura \ml{Parse} -(il lettore pu vedere che non siamo strettamente fedeli alla nostra -convenzione circa le denominazioni delle librerie). La libreria parser fornisce supporto -per il parsing e il `pretty-printing' dei tipi, i termini, e +Un'altra libreria usata in modo pervasivo si trova nella struttura \ml{Parse} +(il lettore pu vedere che non siamo strettamente fedeli alla nostra +convenzione circa le denominazioni delle librerie). La libreria parser fornisce supporto +per il parsing e il `pretty-printing' dei tipi, i termini, e i teoremi \HOL{}. -La libreria \ml{boss} fornisce una collezione base di teorie -standard e di procedure di dimostrazione di alto livello, e serve come una piattaforma -standard su cui lavorare. Essa pre-caricata e aperta quando il sistema +La libreria \ml{boss} fornisce una collezione base di teorie +standard e di procedure di dimostrazione di alto livello, e serve come una piattaforma +standard su cui lavorare. Essa pre-caricata e aperta quando il sistema \HOL{} si avvia. Essa include \ml{boolLib} e \ml{Parse}. Le teorie fornite includono \theoryimp{pair}, -\theoryimp{sum}, \theoryimp{option}; le teorie aritmetiche +\theoryimp{sum}, \theoryimp{option}; le teorie aritmetiche \theoryimp{num}, \theoryimp{prim\_rec}, \theoryimp{arithmetic}, -e \theoryimp{numeral}; e \theoryimp{list}. Altre librerie -incluse in \ml{bossLib} sono \ml{goalstackLib}, che fornisce -un gestore di dimostrazione per dimostrazioni basate su tattiche; \ml{simpLib}, che fornisce -una variet di semplificatori; \ml{numLib}, che fornisce una procedura -di decisione per l'aritmetica; \ml{Datatype}, che fornisce -supporto di alto-livello per definire tipi di dato algebrici; e \ml{tflLib}, +e \theoryimp{numeral}; e \theoryimp{list}. Altre librerie +incluse in \ml{bossLib} sono \ml{goalstackLib}, che fornisce +un gestore di dimostrazione per dimostrazioni basate su tattiche; \ml{simpLib}, che fornisce +una variet di semplificatori; \ml{numLib}, che fornisce una procedura +di decisione per l'aritmetica; \ml{Datatype}, che fornisce +supporto di alto-livello per definire tipi di dato algebrici; e \ml{tflLib}, che fornisce supporto per definire funzioni ricorsive. \section{Parsing e Prettyprinting} \label{sec:parsing-printing} -Ogni tipo e termine in \HOL{} in definitiva costruito per applicazione dei -costruttori (astratti) primitivi per i tipi e i termini. Tuttavia, al -fine di ospitare un'ampia variet di espressioni matematiche, \HOL{} -fornisce un'infrastruttura flessibile per il parsing e il prettyprinting dei tipi +Ogni tipo e termine in \HOL{} in definitiva costruito per applicazione dei +costruttori (astratti) primitivi per i tipi e i termini. Tuttavia, al +fine di ospitare un'ampia variet di espressioni matematiche, \HOL{} +fornisce un'infrastruttura flessibile per il parsing e il prettyprinting dei tipi e dei termini attraverso la struttura \ml{Parse}. -Il parser dei termini supporta l'inferenza di tipo, l'overloading, i binders, e +Il parser dei termini supporta l'inferenza di tipo, l'overloading, i binders, e varie dichiarazioni di fixity (infisso, prefisso, suffisso, e -combinazioni). Ci sono anche dei flag per controllare il comportamento -del parser. Inoltre, la struttura del parser esposta cos che +combinazioni). Ci sono anche dei flag per controllare il comportamento +del parser. Inoltre, la struttura del parser esposta cos che possano essere costruiti rapidamente nuovi parser per supportare applicazioni utente. -Il parser parametrizzato da grammatiche per tipi e termini. Il -comportamento del parser e del prettyprinter di conseguenza di solito alterato +Il parser parametrizzato da grammatiche per tipi e termini. Il +comportamento del parser e del prettyprinter di conseguenza di solito alterato da manipolazioni di grammatica. % \index{parsing, della logica HOL@parsing, della logica \HOL{}!grammatiche per} % Queste possono essere di due generi: \emph{temporanee} o \emph{permanenti}. -I cambiamenti temporanei dovrebbero essere usati nelle implementazioni di librerie, o nei -file di script per quei cambiamenti che l'utente non vuole far -persistere nelle teorie discendenti da quella attuale. I cambiamenti permanenti -sono appropriati per l'uso in file di script, e saranno forzati in tutte -le teorie discendenti. Le funzioni che fanno cambiamenti temporanei sono denotate +I cambiamenti temporanei dovrebbero essere usati nelle implementazioni di librerie, o nei +file di script per quei cambiamenti che l'utente non vuole far +persistere nelle teorie discendenti da quella attuale. I cambiamenti permanenti +sono appropriati per l'uso in file di script, e saranno forzati in tutte +le teorie discendenti. Le funzioni che fanno cambiamenti temporanei sono denotate da un prefisso \ml{temp\_} nei loro nomi. \subsection{Parsing dei tipi} \index{types, nella logica HOL@types, nella logica \HOL{}!parsing of|(} -Il linguaggio dei tipi semplice. Una grammatica astratta per il -linguaggio presentata nella Figura~\ref{fig:abstract-type-grammar}. La -grammatica attuale (con i valori concreti per i simboli infissi e gli operatori +Il linguaggio dei tipi semplice. Una grammatica astratta per il +linguaggio presentata nella Figura~\ref{fig:abstract-type-grammar}. La +grammatica attuale (con i valori concreti per i simboli infissi e gli operatori di tipo) pu essere ispezionata usando la funzione \ml{type\_grammar}. \begin{figure}[tbhp] \newcommand{\nt}[1]{\mathit{#1}} @@ -114,100 +114,100 @@ \subsection{Parsing dei tipi} \end{array} \] \caption{Una grammatica astratta per i tipi \HOL{} ($\tau$). Gli infissi ($\odot$) - legano sempre pi debolmente dei gli operatori di tipo~($\nt{tyop}$) (e - e dei sottoscritti di tipo~($\tau\tok{[}\tau\tok{]}$)), cos che + legano sempre pi debolmente dei gli operatori di tipo~($\nt{tyop}$) (e + e dei sottoscritti di tipo~($\tau\tok{[}\tau\tok{]}$)), cos che $\tau_1 \,\odot\, \tau_2 \,\nt{tyop}$ sempre parsato come $\tau_1\, \odot\, - (\tau_2 \,\nt{tyop})$. Infissi differenti possono avere priorit - differenti, e gli infissi a diversi livelli di priorit possono associare - in modo differente (alla sinistra, alla destra, o non associare del tutto). Gli utenti possono - estendere le categorie $\odot$ e $\nt{tyop}$ facendo nuove definizioni + (\tau_2 \,\nt{tyop})$. Infissi differenti possono avere priorit + differenti, e gli infissi a diversi livelli di priorit possono associare + in modo differente (alla sinistra, alla destra, o non associare del tutto). Gli utenti possono + estendere le categorie $\odot$ e $\nt{tyop}$ facendo nuove definizioni di tipo, e manipolando la grammatica direttamente.} \label{fig:abstract-type-grammar} \end{figure} \paragraph{Infissi di tipo} -Gli infissi possono essere introdotti con la funzione \ml{add\_infix\_type}. -Questa imposta un mapping da un simbolo infisso (come \texttt{->}) al -nome di un operatore di tipo esistente (come \texttt{fun}). E' necessario -dare al simbolo binario un livello di precedenza e +Gli infissi possono essere introdotti con la funzione \ml{add\_infix\_type}. +Questa imposta un mapping da un simbolo infisso (come \texttt{->}) al +nome di un operatore di tipo esistente (come \texttt{fun}). E' necessario +dare al simbolo binario un livello di precedenza e un'associativit. Si veda \REFERENCE{} per maggiori dettagli. \paragraph{Abbreviazioni di tipo} \index{abbreviazioni di tipo} -Gli utenti possono abbreviare pattern di tipo comuni con delle \emph{abbreviazioni}. +Gli utenti possono abbreviare pattern di tipo comuni con delle \emph{abbreviazioni}. Questo fatto con la funzione \ML{} \ml{type\_abbrev}: \begin{hol} \begin{verbatim} type_abbrev : string * hol_type -> unit \end{verbatim} \end{hol} -Un'abbreviazione un nuovo operatore di tipo, di qualsiasi numero di argomenti, -che espande in un tipo esistente. Per esempio, si potrebbe sviluppare una -teoria leggera di numeri estesi con un infinito, in cui -tipo rappresentante fosse \holtxt{num option} (\holtxt{NONE} -rappresenterebbe il valore infinito). Si potrebbe impostare un'abbreviazione -\holtxt{infnum} che si espanderebbe a questo tipo sottostante. -Sono supportati anche i pattern polimorfici. Per esempio, come descritto -nella Sezione~\ref{sec:theory-of-sets}, l'abbreviazione \holtxt{set}, di -un unico argomento, tale che \holtxt{:'a set} espande nel tipo +Un'abbreviazione un nuovo operatore di tipo, di qualsiasi numero di argomenti, +che espande in un tipo esistente. Per esempio, si potrebbe sviluppare una +teoria leggera di numeri estesi con un infinito, in cui +tipo rappresentante fosse \holtxt{num option} (\holtxt{NONE} +rappresenterebbe il valore infinito). Si potrebbe impostare un'abbreviazione +\holtxt{infnum} che si espanderebbe a questo tipo sottostante. +Sono supportati anche i pattern polimorfici. Per esempio, come descritto +nella Sezione~\ref{sec:theory-of-sets}, l'abbreviazione \holtxt{set}, di +un unico argomento, tale che \holtxt{:'a set} espande nel tipo \holtxt{:'a -> bool}, per qualsiasi tipo \holtxt{:'a}. -Quando i tipi devono essere stampati, l'espansione delle abbreviazioni fatta dal parser invertita. +Quando i tipi devono essere stampati, l'espansione delle abbreviazioni fatta dal parser invertita. Per maggiori informazioni, si veda la voce \ml{type\_abbrev} in \REFERENCE. \index{tipi, nella logica HOL@tipi, nella logica \HOL{}!parsing dei|)} \subsection{Parsing dei termini} -Il parser dei termini fornisce un'infrastruttura basata sulla grammatica per supportare -la sintassi concreta per le formalizzazioni. Di solito, la grammatica \HOL{} viene -estesa quando viene fatta una nuova definizione o una specifica di costante. (L'introduzione -di una nuova costante discussa -nelle Sezioni~\ref{sec:constant-definitions} e \ref{conspec}.) Tuttavia, -qualsiasi identificatore pu avere assegnato ad esso in ogni momento uno stato di parsing. -In quello che segue, esploriamo alcune delle capacit del +Il parser dei termini fornisce un'infrastruttura basata sulla grammatica per supportare +la sintassi concreta per le formalizzazioni. Di solito, la grammatica \HOL{} viene +estesa quando viene fatta una nuova definizione o una specifica di costante. (L'introduzione +di una nuova costante discussa +nelle Sezioni~\ref{sec:constant-definitions} e \ref{conspec}.) Tuttavia, +qualsiasi identificatore pu avere assegnato ad esso in ogni momento uno stato di parsing. +In quello che segue, esploriamo alcune delle capacit del parser dei termini \HOL{}. \subsubsection{Architettura del parser} \label{sec:parser:architecture} -Il parser trasforma le stringhe in termini. Fa questo nella seguente -serie di fasi, ciascuna delle quali influenzata dalla grammatica fornita. -Di solito questa grammatica la grammatica globale di default, ma gli utenti possono +Il parser trasforma le stringhe in termini. Fa questo nella seguente +serie di fasi, ciascuna delle quali influenzata dalla grammatica fornita. +Di solito questa grammatica la grammatica globale di default, ma gli utenti possono organizzarsi per usare grammatiche differenti se lo desiderano. % \index{parsing, della logica HOL@parsing, della logica \HOL{}!grammatiche per} % -Correttamente, il parsing avviene dopo che il lexing ha diviso l'input in una +Correttamente, il parsing avviene dopo che il lexing ha diviso l'input in una serie di token. Per maggiori informazioni sul lexing, si veda la Sezione~\ref{HOL-lex}. \begin{description} -\item[Sintassi Concreta:] Caratteristiche come gli infissi, i binder e le forme - mix-fix sono tradotte, creando una forma di ``sintassi - astratta'' intermedia (tipo ML \ml{Absyn}). Le fixity possibili sono - discusse nella Sezione~\ref{sec:parseprint:fixities} di sotto. Le forme - di sintassi concreta sono aggiunte alla grammatica con funzioni come - \ml{add\_rule} e \ml{set\_fixity} (per le quali, si veda \REFERENCE). - L'azione di questa fase di parsing incarnata nella funzione +\item[Sintassi Concreta:] Caratteristiche come gli infissi, i binder e le forme + mix-fix sono tradotte, creando una forma di ``sintassi + astratta'' intermedia (tipo ML \ml{Absyn}). Le fixity possibili sono + discusse nella Sezione~\ref{sec:parseprint:fixities} di sotto. Le forme + di sintassi concreta sono aggiunte alla grammatica con funzioni come + \ml{add\_rule} e \ml{set\_fixity} (per le quali, si veda \REFERENCE). + L'azione di questa fase di parsing incarnata nella funzione \ml{Absyn}. - Il data type \ml{Absyn} costruito usando i costruttori \ml{AQ} + Il data type \ml{Absyn} costruito usando i costruttori \ml{AQ} (un antiquote, si veda la Sezione~\ref{sec:quotation-antiquotation}); % % \index{antiquotation, nei termini della logica HOL@antiquotation, nei termini della logica \HOL{}}% % - \ml{IDENT} (un identificatore); \ml{QIDENT} (un identificatore qualificato, - dato come \holtxt{thy\$ident}); \ml{APP} (un'applicazione di una forma - a un'altra); \ml{LA} (un'astrazione di una variabile su un corpo), - e \ml{TYPED} (una forma accompagnata da un vincolo di tipo\footnote{I - tipi nei vincoli \ml{Absyn} non sono tipi HOL completi, ma valori - da un'altro tipo intermedio \ml{Pretype}.}, si veda - la Sezione~\ref{sec:parseprint-type-constraints}). A questo stadio della - traduzione, non viene fatta alcuna distinzione tra costanti e - variabili: bench le forme \ml{QIDENT} debbano essere delle costanti, gli utente sono + \ml{IDENT} (un identificatore); \ml{QIDENT} (un identificatore qualificato, + dato come \holtxt{thy\$ident}); \ml{APP} (un'applicazione di una forma + a un'altra); \ml{LA} (un'astrazione di una variabile su un corpo), + e \ml{TYPED} (una forma accompagnata da un vincolo di tipo\footnote{I + tipi nei vincoli \ml{Absyn} non sono tipi HOL completi, ma valori + da un'altro tipo intermedio \ml{Pretype}.}, si veda + la Sezione~\ref{sec:parseprint-type-constraints}). A questo stadio della + traduzione, non viene fatta alcuna distinzione tra costanti e + variabili: bench le forme \ml{QIDENT} debbano essere delle costanti, gli utente sono anche in grado di riferirsi alle costanti dando loro dei nomi nudi. - E' possibile che i nomi che occorrono nel valore \ml{Absyn} siano - differenti da qualsiasi token che appariva nell'input + E' possibile che i nomi che occorrono nel valore \ml{Absyn} siano + differenti da qualsiasi token che appariva nell'input originale. Per esempio, l'input \begin{verbatim} ``if P then Q else R`` @@ -215,12 +215,12 @@ \subsubsection{Architettura del parser} \begin{verbatim} APP (APP (APP (IDENT "COND", IDENT "P"), IDENT "Q"), IDENT "R") \end{verbatim} - (Questo un output leggermente semplificato: i vari costruttori per + (Questo un output leggermente semplificato: i vari costruttori per \ml{Absyn}, incluso \ml{APP}, prendono anche parametri di localizzazione.) - La grammatica standard include una regola che associa la speciale - forma miz-fix per l'espressioni if-then-else con il sottostante - ``nome'' \holtxt{COND}. E' \holtxt{COND}. che sar alla fine + La grammatica standard include una regola che associa la speciale + forma miz-fix per l'espressioni if-then-else con il sottostante + ``nome'' \holtxt{COND}. E' \holtxt{COND}. che sar alla fine risolto come la costante \holtxt{bool\dol{}COND}. Se si usa la sintassi di ``quotation'' con un dollaro nudo,% @@ -228,122 +228,122 @@ \subsubsection{Architettura del parser} \index{ escape, nel parser della logica HOL@\ml{\$} (escape, nel parser della logica \HOL{})}% \index{token!sopprimere il comportamento di parsing dei|(} % -allora questa fase del parser non tratter le stringhe come parte di una -forma speciale. Per esempio, \holtxt{\holquote{\dol{}if~P}} si trasforma +allora questa fase del parser non tratter le stringhe come parte di una +forma speciale. Per esempio, \holtxt{\holquote{\dol{}if~P}} si trasforma nella forma \ml{Absyn} \begin{verbatim} APP(IDENT "if", IDENT "P") \end{verbatim} \emph{non} in una forma che coinvolge \holtxt{COND}. - Pi tipicamente, spesso si scrive qualcosa come + Pi tipicamente, spesso si scrive qualcosa come \holtxt{\holquote{\$+~x}}, che genera la sintassi astratta \begin{verbatim} APP(IDENT "+", IDENT "x") \end{verbatim} - Senza il segno di dollaro, il parser della sintassi concreta si lamenterebbe - del fatto che l'infisso pi non ha un argomento - sinistro. Quando il risultato di successo del parsing passato alla - fase successiva, il fatto che ci sia una costante chiamata \holtxt{+} + Senza il segno di dollaro, il parser della sintassi concreta si lamenterebbe + del fatto che l'infisso pi non ha un argomento + sinistro. Quando il risultato di successo del parsing passato alla + fase successiva, il fatto che ci sia una costante chiamata \holtxt{+} dar all'input il suo significato desiderato. - Si pu eseguire l'``escape'' dei simboli racchiudendoli in parentesi. - Cos, quello di sopra si potrebbe scrivere \holtxt{\holquote{(+)~x}} per avere + Si pu eseguire l'``escape'' dei simboli racchiudendoli in parentesi. + Cos, quello di sopra si potrebbe scrivere \holtxt{\holquote{(+)~x}} per avere lo stesso effetto. \index{token!sopprimere il comportamento di parsing dei|)} - L'utente pu inserire a questo punto nel processo di parsing delle funzioni - di trasformazione intermedia sviluppate per proprio conto . Questo fatto + L'utente pu inserire a questo punto nel processo di parsing delle funzioni + di trasformazione intermedia sviluppate per proprio conto . Questo fatto con la funzione \begin{verbatim} add_absyn_postprocessor \end{verbatim} - La funzione dell'utente sar di tipo \ml{Absyn~->~Absyn} e potr - eseguire qualunque cambiamento sia appropriato. Come tutti gli altri aspetti del + La funzione dell'utente sar di tipo \ml{Absyn~->~Absyn} e potr + eseguire qualunque cambiamento sia appropriato. Come tutti gli altri aspetti del parsing, queste funzioni sono parte di una grammatica: se l'utente non vuole - vedere usata una particolare funzione, pu organizzarsi in modo che il parsing + vedere usata una particolare funzione, pu organizzarsi in modo che il parsing sia fatto rispetto a una grammatica differente. -\item[Risoluzione dei Nomi:] Le forme nude \ml{IDENT} nel valore \ml{Absyn} - sono risolte come variabili libere, nomi legati o costanti. - Questo processo risulta in un valore del tipo di dati \ml{Preterm}, che - ha costruttori simili a quelli in \ml{Absyn} eccetto che con le forme +\item[Risoluzione dei Nomi:] Le forme nude \ml{IDENT} nel valore \ml{Absyn} + sono risolte come variabili libere, nomi legati o costanti. + Questo processo risulta in un valore del tipo di dati \ml{Preterm}, che + ha costruttori simili a quelli in \ml{Absyn} eccetto che con le forme per le costanti. % \index{parsing, della logica HOL@parsing, della logica \HOL{}!preterms}% - Una stringa pu essere convertita direttamente in un \ml{Preterm} per mezzo della + Una stringa pu essere convertita direttamente in un \ml{Preterm} per mezzo della funzione \ml{Preterm}. - Un nome legato il primo argomento a un costruttore \ml{LAM}, un - identificatore che occorro sul lato sinistro di una freccia di - una espressione case, o un identificatore che occorre all'interno di un pattern - di comprensione d'insieme. Una costante una stringa che presente nel dominio - dell'``overload map'' della grammatica. Le variabili libere sono tutti gli altri identificatori. - Variabili libere dello stesso nome in un termine avranno lo stesso - tipo. Gli identificatori sono testati per vedere se sono legati, e poi per + Un nome legato il primo argomento a un costruttore \ml{LAM}, un + identificatore che occorro sul lato sinistro di una freccia di + una espressione case, o un identificatore che occorre all'interno di un pattern + di comprensione d'insieme. Una costante una stringa che presente nel dominio + dell'``overload map'' della grammatica. Le variabili libere sono tutti gli altri identificatori. + Variabili libere dello stesso nome in un termine avranno lo stesso + tipo. Gli identificatori sono testati per vedere se sono legati, e poi per vedere se sono costanti. Cos possibile scrivere \begin{verbatim} \SUC. SUC + 3 \end{verbatim} - ed avere la stringa \holtxt{SUC} trattata come un numero nel - contesto dell'astrazione data, piuttosto che come la costante + ed avere la stringa \holtxt{SUC} trattata come un numero nel + contesto dell'astrazione data, piuttosto che come la costante successore. \index{parsing, della logica HOL@parsing, della logica \HOL{}!overloading} \index{overloading|see{parsing, of \HOL{} logic, overloading}} - L'``overloap map'' una mappa da stringhe a liste di termini. I - termini di solito sono solo costanti, ma possono essere termini arbitrari (dando + L'``overloap map'' una mappa da stringhe a liste di termini. I + termini di solito sono solo costanti, ma possono essere termini arbitrari (dando origine a ``macro sintattiche'' o ``pattern'').\index{macro sintattiche} - Questa infrastruttura usata per permettere ad un nome come \holtxt{+} di mappare a - costanti di addizione differenti in teorie come + Questa infrastruttura usata per permettere ad un nome come \holtxt{+} di mappare a + costanti di addizione differenti in teorie come \theoryimp{arithmetic}, \theoryimp{integer}, e - \theoryimp{words}. In questo modo i nomi ``reali'' delle costanti si possono - slegare da ci che l'utente digita. Nel caso dell'addizione, il - pi sui numeri naturali di fatto chiamato \holtxt{+} (strettamente, - \holtxt{arithmetic\$+}); ma sugli interi, - \holtxt{int\_add}, e su word \holtxt{word\_add}. (Si noti - che poich ciascuna costante arriva da una teoria differente e cos da un + \theoryimp{words}. In questo modo i nomi ``reali'' delle costanti si possono + slegare da ci che l'utente digita. Nel caso dell'addizione, il + pi sui numeri naturali di fatto chiamato \holtxt{+} (strettamente, + \holtxt{arithmetic\$+}); ma sugli interi, + \holtxt{int\_add}, e su word \holtxt{word\_add}. (Si noti + che poich ciascuna costante arriva da una teoria differente e cos da un namespace differenti, esse potrebbero avere tutte il nome \holtxt{+}.) \index{inferenza di tipo!nel parser HOL@nel parser \HOL{}} - Quando la risoluzione dei nomi determina che un identificatore dovrebbe essere trattato - come una costante, esso mappato a una forma pretermine che elenca tutte le - possibilit per quella stringa. Successivamente, poich i termini nel - range della mappa di overload tipicamente avranno tipi differenti, - l'inferenza di tipo spesso eliminer le possibilit dalla lista. Se - rimangono pi possibilit dopo che l'inferenza di tipo stata - eseguita, allora sar stampato un warning, e sar scelta una - delle possibilit. (Gli utenti possono controllare quali termini sono + Quando la risoluzione dei nomi determina che un identificatore dovrebbe essere trattato + come una costante, esso mappato a una forma pretermine che elenca tutte le + possibilit per quella stringa. Successivamente, poich i termini nel + range della mappa di overload tipicamente avranno tipi differenti, + l'inferenza di tipo spesso eliminer le possibilit dalla lista. Se + rimangono pi possibilit dopo che l'inferenza di tipo stata + eseguita, allora sar stampato un warning, e sar scelta una + delle possibilit. (Gli utenti possono controllare quali termini sono selezionati quando si presenta questa situazione.) - Quando un termine nella mappa di overload scelto come l'opzione migliore, - sostituito nel termini alla posizione appropriata. Se il termine una - lambda astrazione, allora sono fatte tante $\beta$-riduzioni quante - possibili, usando qualsiasi argomento a cui il termine sia stato applicato. E' - in questo modo che un pattern sintattico pu elaborare gli argomenti. (Si veda - anche la Sezione~\ref{sec:parser:syntactic-patterns} per maggiori informazioni sui + Quando un termine nella mappa di overload scelto come l'opzione migliore, + sostituito nel termini alla posizione appropriata. Se il termine una + lambda astrazione, allora sono fatte tante $\beta$-riduzioni quante + possibili, usando qualsiasi argomento a cui il termine sia stato applicato. E' + in questo modo che un pattern sintattico pu elaborare gli argomenti. (Si veda + anche la Sezione~\ref{sec:parser:syntactic-patterns} per maggiori informazioni sui pattern sintattici.) \item[Inferenza di Tipo:] % \index{inferenza di tipo!nel parser HOL@nel parser \HOL{}}% - Tutti i termini nella logica \HOL{} sono ben tipizzati. Il kernel rafforza - questo attraverso le API per il tipo di dato \ml{term}. (In particolare, + Tutti i termini nella logica \HOL{} sono ben tipizzati. Il kernel rafforza + questo attraverso le API per il tipo di dato \ml{term}. (In particolare, la funzione \ml{mk\_comb} % \index{mk_comb@\ml{mk\_comb}}% - controlla che il tipo del primo argomento sia una funzione il cui - dominio uguale al tipo del secondo argomento.) Il lavoro del - parser di trasformare le stringhe fornite dall'utente in termini. Per convenienza, - vitale che l'utente non debba fornire tipi per tutti gli - identificatori che digita. (Si veda la Sezione~\ref{sec:parser:type-inference} + controlla che il tipo del primo argomento sia una funzione il cui + dominio uguale al tipo del secondo argomento.) Il lavoro del + parser di trasformare le stringhe fornite dall'utente in termini. Per convenienza, + vitale che l'utente non debba fornire tipi per tutti gli + identificatori che digita. (Si veda la Sezione~\ref{sec:parser:type-inference} di sotto.) - In presenza di identificatori sottoposti a overload, l'inferenza di tipo pu non essere - in grado di assegnare un tipo unico a tutte le costanti. Se esistono - pi possibilit, ne sar scelto uno quando il \ml{Preterm} infine + In presenza di identificatori sottoposti a overload, l'inferenza di tipo pu non essere + in grado di assegnare un tipo unico a tutte le costanti. Se esistono + pi possibilit, ne sar scelto uno quando il \ml{Preterm} infine convertito in un termine genuino. \item[Conversione a un Termine:]% - Quando stato completato il controllo di tipo di un \ml{Preterm}, la conversione finale da - quel tipo al tipo del \ml{term} per lo pi semplice. L'utente - pu pure inserire ulteriore elaborazione a questo punto, cos che una - funzione fornita dall'utente modifichi il risultato prima che il parser + Quando stato completato il controllo di tipo di un \ml{Preterm}, la conversione finale da + quel tipo al tipo del \ml{term} per lo pi semplice. L'utente + pu pure inserire ulteriore elaborazione a questo punto, cos che una + funzione fornita dall'utente modifichi il risultato prima che il parser lo restituisca. \end{description} @@ -352,8 +352,8 @@ \subsubsection{Caratteri unicode} \index{Unicode}\index{UTF-8} \index{parsing, della logica HOL@parsing, della logica \HOL{}!Caratteri unicode|(} -E' possibile fare in modo che l'infrastruttura \HOL{} di parsing e stampa -utilizzi caratteri Unicode (scritti nella codifica UTF-8). Questo rende +E' possibile fare in modo che l'infrastruttura \HOL{} di parsing e stampa +utilizzi caratteri Unicode (scritti nella codifica UTF-8). Questo rende possibile scrivere e leggere termini come \begin{alltt} \(\forall\)x. P x \(\land\) Q x @@ -362,48 +362,48 @@ \subsubsection{Caratteri unicode} \begin{alltt} !x. P x /\bs{} Q x \end{alltt} -Se lo desiderano, gli utenti possono semplicemente definire costanti che hanno caratteri -Unicode nei loro nomi, e lasciare le cose come stanno. Il problema con -questo approccio che gli strumenti standard probabilmente creeranno file +Se lo desiderano, gli utenti possono semplicemente definire costanti che hanno caratteri +Unicode nei loro nomi, e lasciare le cose come stanno. Il problema con +questo approccio che gli strumenti standard probabilmente creeranno file di teoria che includono binding \ML{} (illegali) come \ml{val $\rightarrow$\_def = \dots}. Il risultato saranno file \ml{...Theory.sig} e -\ml{...Theory.sml} che falliranno di compilare, anche se la chiamata a -\ml{export\_theory} pu avere successo. Questo problema pu essere manovrato attraverso -l'uso di funzioni come \ml{set\_MLname}, probabilmente una pratica -migliore usare solamente caratteri alfanumerici nei nomi delle costanti, e -usare poi funzioni come \ml{overload\_on} e \ml{add\_rule} per creare +\ml{...Theory.sml} che falliranno di compilare, anche se la chiamata a +\ml{export\_theory} pu avere successo. Questo problema pu essere manovrato attraverso +l'uso di funzioni come \ml{set\_MLname}, probabilmente una pratica +migliore usare solamente caratteri alfanumerici nei nomi delle costanti, e +usare poi funzioni come \ml{overload\_on} e \ml{add\_rule} per creare la sintassi unicode per la costante sottostante. -Se gli utenti hanno a disposizione dei font con il repertorio di caratteri appropriati per -mostrare la loro sintassi, e confidano nel fatto che anche ognuno degli utenti delle loro -teorie li hanno, allora questo perfettamente ragionevole. Tuttavia, se -gli utenti vogliono mantenere la retro-compatibilit con la pura sintassi -ASCII, possono farlo definendo prima una sintassi ASCII pura. Dopo aver fatto -questo, possono creare una versione Unicode della sintassi con la -funzione \ml{Unicode.unicode\_version}. Quindi, quando la variabile -di traccia \ml{"Unicode"} $0$, la sintassi ASCII sar usata per -il parsing e la stampa. Se la traccia impostata a $1$, allora funzioner -anche la sintassi unicode nel parse, e il pretty-priunter +Se gli utenti hanno a disposizione dei font con il repertorio di caratteri appropriati per +mostrare la loro sintassi, e confidano nel fatto che anche ognuno degli utenti delle loro +teorie li hanno, allora questo perfettamente ragionevole. Tuttavia, se +gli utenti vogliono mantenere la retro-compatibilit con la pura sintassi +ASCII, possono farlo definendo prima una sintassi ASCII pura. Dopo aver fatto +questo, possono creare una versione Unicode della sintassi con la +funzione \ml{Unicode.unicode\_version}. Quindi, quando la variabile +di traccia \ml{"Unicode"} $0$, la sintassi ASCII sar usata per +il parsing e la stampa. Se la traccia impostata a $1$, allora funzioner +anche la sintassi unicode nel parse, e il pretty-priunter la preferir quando i termini sono stampati. -Per esempio, in \ml{boolScript.sml}, il carattere Unicode per l'and -logico (\texttt{$\land$}), impostato come un'alternativa unicode per +Per esempio, in \ml{boolScript.sml}, il carattere Unicode per l'and +logico (\texttt{$\land$}), impostato come un'alternativa unicode per \texttt{/\bs} con la chiamata \begin{verbatim} val _ = unicode_version {u = UChar.conj, tmnm = "/\\"}; \end{verbatim} -(In questo contesto, stata aperta la struttura \ml{Unicode}, -dando accesso anche alla struttura \ml{UChar} che contiene i binding +(In questo contesto, stata aperta la struttura \ml{Unicode}, +dando accesso anche alla struttura \ml{UChar} che contiene i binding per l'alfabeto Greco, e alcuni altri simboli matematici.) L'argomento a \ml{unicode\_version} un record con campi \ml{u} -e \ml{tmnm}. Entrambe sono stringhe. Il campo \ml{tmnm} pu essere o -il nome di una costante, o un token che appare in una regola di sintassi concreta -(che possibilmente mappa a qualche altro nome). Se il \ml{tmnm} solo il -nome di una costante, allora, con la variabili di traccia abilitata, la stringa -\ml{u} sar sottoposta a overloading con lo stesso nome. Se il \ml{tmnm} lo -stesso di un token di una regola di sintassi concreta, allora il comportamento di -creare una nuova regola che mappa allo stesso nome, ma con la stringa \ml{u} +e \ml{tmnm}. Entrambe sono stringhe. Il campo \ml{tmnm} pu essere o +il nome di una costante, o un token che appare in una regola di sintassi concreta +(che possibilmente mappa a qualche altro nome). Se il \ml{tmnm} solo il +nome di una costante, allora, con la variabili di traccia abilitata, la stringa +\ml{u} sar sottoposta a overloading con lo stesso nome. Se il \ml{tmnm} lo +stesso di un token di una regola di sintassi concreta, allora il comportamento di +creare una nuova regola che mappa allo stesso nome, ma con la stringa \ml{u} usata come il token. \paragraph{Regole di lexing con caratteri Unicode} @@ -411,21 +411,21 @@ \subsubsection{Caratteri unicode} \index{token!Caratteri unicode} \index{identificatori, nella logica HOL@identificatori, nella logica \HOL{}!caratteri che non associano} % -In parole povere, \HOL{} considera i caratteri divisi in tre -classi: alfanumerici, simboli che non associano e simboli. Questo -influenza il comportamento del lexer quando incontra delle stringhe di -caratteri. A meno che ci sia gi nella grammatica uno specifico token ``misto'', -i token si dividono quando la classe di caratteri cambia. Cos, nella +In parole povere, \HOL{} considera i caratteri divisi in tre +classi: alfanumerici, simboli che non associano e simboli. Questo +influenza il comportamento del lexer quando incontra delle stringhe di +caratteri. A meno che ci sia gi nella grammatica uno specifico token ``misto'', +i token si dividono quando la classe di caratteri cambia. Cos, nella stringa \begin{verbatim} ++a \end{verbatim} -il lexer vedr due token, \holtxt{++} e \holtxt{a}, perch -\holtxt{+} un simbolo e \holtxt{a} un alfanumerico. La -classificazione dei caratteri Unicode extra molto -semplicistica: tutt le lettere greche eccetto \holtxt{$\lambda$} sono alfanumerici; -il simbolo di negazione logica \holtxt{$\neg$} non associa; e -ogni altra cosa simbolica. (L'eccezzione per \holtxt{$\lambda$} per +il lexer vedr due token, \holtxt{++} e \holtxt{a}, perch +\holtxt{+} un simbolo e \holtxt{a} un alfanumerico. La +classificazione dei caratteri Unicode extra molto +semplicistica: tutt le lettere greche eccetto \holtxt{$\lambda$} sono alfanumerici; +il simbolo di negazione logica \holtxt{$\neg$} non associa; e +ogni altra cosa simbolica. (L'eccezzione per \holtxt{$\lambda$} per permettere a stringhe come \holtxt{$\lambda$x.x} di essere divise dal lexer in \emph{quattro} token.) \index{parsing, della logica HOL@parsing, della logica \HOL{}!Caratteri unicode|)} @@ -435,35 +435,35 @@ \subsubsection{Pattern sintattici (``macro'')} \index{parsing, della logica HOL@parsing, della logica \HOL{}!overloading} \index{parsing, della logica HOL@parsing, della logica \HOL{}!pattern sintattici|(} -La ``mappa di overload'' menzionata in precedenza di fatto una combinazione di -mappe, una per il parsing, e una per la stampa. La mappa di parsing da -nomi a liste di termini, e determina come i nomi che appaiono in un -\ml{Preterm} saranno tradotti in termini. In sostanza, i nomi legati sono tradotti -in variabili legate, nomi non legati che non sono nel dominio della mappa sono tradotti -in variabili libere, e nomi non legati nel dominio della mappa sono tradotti -in uno degli elementi dell'insieme associato con il nome dato. -Ogni termine nell'insieme delle possibilit pu avere un tipo differente, cos -l'inferenza di tipo sceglier da quelli che hanno tipi coerenti con -il resto del termine dato. Se la lista risultante contiene pi di -un elemento, allora il termine che appare prima nella lista sar +La ``mappa di overload'' menzionata in precedenza di fatto una combinazione di +mappe, una per il parsing, e una per la stampa. La mappa di parsing da +nomi a liste di termini, e determina come i nomi che appaiono in un +\ml{Preterm} saranno tradotti in termini. In sostanza, i nomi legati sono tradotti +in variabili legate, nomi non legati che non sono nel dominio della mappa sono tradotti +in variabili libere, e nomi non legati nel dominio della mappa sono tradotti +in uno degli elementi dell'insieme associato con il nome dato. +Ogni termine nell'insieme delle possibilit pu avere un tipo differente, cos +l'inferenza di tipo sceglier da quelli che hanno tipi coerenti con +il resto del termine dato. Se la lista risultante contiene pi di +un elemento, allora il termine che appare prima nella lista sar scelto. -Il caso d'uso pi comune per la mappa di overload di avere nomi mappati a -costanti. In questo modo, per esempio, le varie teorie aritmetiche possono -mappare la stringa \ml{"+"} alla nozione rilevante di addizione, ognuna delle -quali una costante differente. Tuttavia, il sistema ha una flessibilit -extra perch i nomi possono mappare termini arbitrari. Per esempio, -possibile mappare a istanze di costanti con specifici tipi. Cos, la -stringa \ml{"<=>"} mappa l'eguaglianza, ma dove gli argomenti sono forzati +Il caso d'uso pi comune per la mappa di overload di avere nomi mappati a +costanti. In questo modo, per esempio, le varie teorie aritmetiche possono +mappare la stringa \ml{"+"} alla nozione rilevante di addizione, ognuna delle +quali una costante differente. Tuttavia, il sistema ha una flessibilit +extra perch i nomi possono mappare termini arbitrari. Per esempio, +possibile mappare a istanze di costanti con specifici tipi. Cos, la +stringa \ml{"<=>"} mappa l'eguaglianza, ma dove gli argomenti sono forzati essere di tipo \holquote{:bool}. -Inoltre, se il termine mappato una lambda-astrazione (cio, della -forma $\lambda x.\;M$), allora il parser eseguir tutte le $\beta$-riduzioni -possibili per quel termine e gli argomenti che lo accompagnano. per -esempio, in \theoryimp{boolTheory} e nei suoi discendenti, la stringa -\ml{"<>"} sottoposta a overload rispetto al termine \holquote{\bs{}x~y.~\td{}(x~=~y)}. -Inoltre, \ml{"<>"} impostato come un infisso al livello della sintassi -concreta. Quando l'utente inserisce \holquote{x~\lt\gt~y}, il valore +Inoltre, se il termine mappato una lambda-astrazione (cio, della +forma $\lambda x.\;M$), allora il parser eseguir tutte le $\beta$-riduzioni +possibili per quel termine e gli argomenti che lo accompagnano. per +esempio, in \theoryimp{boolTheory} e nei suoi discendenti, la stringa +\ml{"<>"} sottoposta a overload rispetto al termine \holquote{\bs{}x~y.~\td{}(x~=~y)}. +Inoltre, \ml{"<>"} impostato come un infisso al livello della sintassi +concreta. Quando l'utente inserisce \holquote{x~\lt\gt~y}, il valore \ml{Absyn} risultante \begin{verbatim} APP(APP(IDENT "<>", IDENT "x"), IDENT "x") @@ -474,68 +474,68 @@ \subsubsection{Pattern sintattici (``macro'')} \begin{verbatim} :'a -> 'a -> bool \end{verbatim} -e le variabili polimorfiche sono generalizzabili, permettendo all'inferenza -di tipo di dare i tipi (identici) appropriati a \ml{x} e \ml{y}. -Assumendo che questa opzione sia l'unico oveloading per il \ml{"<>"} lasciato -dopo l'inferenza di tipo, allora il termine risultante sar -\holtxt{\td(x~=~y)}. Meglio, bench questa sar la struttura -sottostante del termine in memoria, esso sar di fatto stampato come +e le variabili polimorfiche sono generalizzabili, permettendo all'inferenza +di tipo di dare i tipi (identici) appropriati a \ml{x} e \ml{y}. +Assumendo che questa opzione sia l'unico oveloading per il \ml{"<>"} lasciato +dopo l'inferenza di tipo, allora il termine risultante sar +\holtxt{\td(x~=~y)}. Meglio, bench questa sar la struttura +sottostante del termine in memoria, esso sar di fatto stampato come \holquote{x~\lt\gt~y}. -Se il termine mappato nella mappa di overload contiene qualsiasi variabili libere, -queste variabili non saranno istanziate in alcun modo. In particolare, -se queste variabili hanno tipi polimorfici, allora le variabili di tipo in -questi tipi saranno costanti: non soggette a istanziazione dall'inferenza +Se il termine mappato nella mappa di overload contiene qualsiasi variabili libere, +queste variabili non saranno istanziate in alcun modo. In particolare, +se queste variabili hanno tipi polimorfici, allora le variabili di tipo in +questi tipi saranno costanti: non soggette a istanziazione dall'inferenza di tipo. -\paragraph{Il pretty-printing e i pattern sintattici} La seconda parte della ``mappa di overload'' una mappa da termini a stringhe, che specifica come -i termini dovrebbero essere trasformati indietro in identificatori. (Bench di fatto -non costruisca un valore \ml{Absyn}, questo processo inverte la fase del parsing -di risoluzione dei nomi, producendo qualcosa che poi stampato +\paragraph{Il pretty-printing e i pattern sintattici} La seconda parte della ``mappa di overload'' una mappa da termini a stringhe, che specifica come +i termini dovrebbero essere trasformati indietro in identificatori. (Bench di fatto +non costruisca un valore \ml{Absyn}, questo processo inverte la fase del parsing +di risoluzione dei nomi, producendo qualcosa che poi stampato secondo la parte di sintassi concreta della grammatica data.) -Poich il parsing pu mappare nomi singoli in complicate strutture di termine, -la stampa deve essere in grado di ricondurre una complicata struttura di termine a -un nome singolo. Esso fa questo eseguendo +Poich il parsing pu mappare nomi singoli in complicate strutture di termine, +la stampa deve essere in grado di ricondurre una complicata struttura di termine a +un nome singolo. Esso fa questo eseguendo un term matching.% \index{matching!nel pretty-printing dei termini}% % -\footnote{Il matching eseguito del primo ordine; per contro il matching di ordine superiore +\footnote{Il matching eseguito del primo ordine; per contro il matching di ordine superiore fatto nel semplificatore.} -Se pi pattern matchano con lo stesso termine, allora il printer sceglie il -match pi specifico (quello che richiede l'istanziazione minima delle -variabili del pattern.) Se questo risulta ancora in pi possibilit, ugualmente -specifiche, ha la precedenza il pattern aggiunto -pi recentemente. (Gli utenti possono cos manipolare le preferenze del printer +Se pi pattern matchano con lo stesso termine, allora il printer sceglie il +match pi specifico (quello che richiede l'istanziazione minima delle +variabili del pattern.) Se questo risulta ancora in pi possibilit, ugualmente +specifiche, ha la precedenza il pattern aggiunto +pi recentemente. (Gli utenti possono cos manipolare le preferenze del printer eseguendo delle chiamate altrimenti ridondanti alla funzione \ml{overload\_on}.) -Nell'esempio di sopra dell'operatore non-uguale-a, il pattern sar -\holtxt{\~{}(?x = ?y)}, dove i punti interrogativi, indicano variabili del pattern -istanziabili. Se un pattern include delle variabili libere (si ricordi che -la \ml{x} e la \ml{y} in questo esempio erano legate da un'astrazione), +Nell'esempio di sopra dell'operatore non-uguale-a, il pattern sar +\holtxt{\~{}(?x = ?y)}, dove i punti interrogativi, indicano variabili del pattern +istanziabili. Se un pattern include delle variabili libere (si ricordi che +la \ml{x} e la \ml{y} in questo esempio erano legate da un'astrazione), allora queste non saranno istanziabili. -Non c' alcun'altra finezza nell'uso di questa infrastruttura: matching -``pi grandi'', che coprono pi di un termine hanno la precedenza. La difficolt -che questo pu causare illustrata nel pattern \holtxt{IS\_PREFIX} dalla teoria -\theoryimp{rich\_listTheory}. Per questioni di retro-compatibilit +Non c' alcun'altra finezza nell'uso di questa infrastruttura: matching +``pi grandi'', che coprono pi di un termine hanno la precedenza. La difficolt +che questo pu causare illustrata nel pattern \holtxt{IS\_PREFIX} dalla teoria +\theoryimp{rich\_listTheory}. Per questioni di retro-compatibilit questo identificatore mappa a \begin{verbatim} \x y. isPREFIX y x \end{verbatim} -dove \holtxt{isPREFIX} una costante da \theoryimp{listTheory}. -(La questione che \holtxt{IS\_PREFIX} si aspetta i suoi argomenti in -ordine inverso a quello che si aspetta \holtxt{isPREFIX}.) Ora, quando questa -macro impostata la mappa di overload contiene gi un mapping dalla -stringa \holtxt{"isPREFIX"} alla costante \holtxt{isPREFIX} (questo -accade con ogni definizione di costante). Ma dopo la chiamata -che stabilisce il nuovo pattern per \holtxt{IS\_PREFIX}, la -forma \holtxt{isPREFIX} non sar pi stampata. N sufficiente, +dove \holtxt{isPREFIX} una costante da \theoryimp{listTheory}. +(La questione che \holtxt{IS\_PREFIX} si aspetta i suoi argomenti in +ordine inverso a quello che si aspetta \holtxt{isPREFIX}.) Ora, quando questa +macro impostata la mappa di overload contiene gi un mapping dalla +stringa \holtxt{"isPREFIX"} alla costante \holtxt{isPREFIX} (questo +accade con ogni definizione di costante). Ma dopo la chiamata +che stabilisce il nuovo pattern per \holtxt{IS\_PREFIX}, la +forma \holtxt{isPREFIX} non sar pi stampata. N sufficiente, ripetere la chiamata \begin{verbatim} overload_on("isPREFIX", ``isPREFIX``) \end{verbatim} -Piuttosto (supponendo che \holtxt{isPREFIX} sia di fatto la forma +Piuttosto (supponendo che \holtxt{isPREFIX} sia di fatto la forma di stampa preferita), la chiamata deve essere \begin{verbatim} overload_on("isPREFIX", ``\x y. isPREFIX x y``) @@ -548,24 +548,24 @@ \subsubsection{Vincoli di tipo} \label{sec:parseprint-type-constraints} \index{vincoli di tipo!nel parser HOL@nel parser \HOL{}} -Un termine pu essere vincolato ad essere un certo tipo. Per esempio, -\holtxt{X:bool} vincola la variabile \holtxt{X} ad avere il tipo -\holtxt{bool}. Un tentativo di vincolare un +Un termine pu essere vincolato ad essere un certo tipo. Per esempio, +\holtxt{X:bool} vincola la variabile \holtxt{X} ad avere il tipo +\holtxt{bool}. Un tentativo di vincolare un termine in modo inappropriato sollever un'eccezione: per esempio, \begin{hol} \begin{verbatim} if T then (X:ind) else (Y:bool) \end{verbatim} \end{hol} -fallir perch entrambi i rami di un condizionale dovono essere dello stesso -tipo. I vincoli di tipo possono essere visti come un suffisso che lega pi +fallir perch entrambi i rami di un condizionale dovono essere dello stesso +tipo. I vincoli di tipo possono essere visti come un suffisso che lega pi strettamente di qualunque altra cosa eccetto l'applicazione di funzione. Cos $\term\ \ldots\ \term \ : \type$ uguale a $(\term\ \ldots\ \term)\ : -\type$, ma $x < y:\holtxt{num}$ un vincolo legittimo sulla sola +\type$, ma $x < y:\holtxt{num}$ un vincolo legittimo sulla sola variabile $y$. -L'inclusione di \holtxt{:} negli identificatori simbolici significa che pu +L'inclusione di \holtxt{:} negli identificatori simbolici significa che pu essere necessario separare qualche vincolo con degli spazi vuoti. Per esempio, \begin{hol} \begin{verbatim} @@ -578,7 +578,7 @@ \subsubsection{Vincoli di tipo} $=: bool -> bool -> bool \end{verbatim} \end{hol} -ed elaborato dal parser come un'applicazione del'identificatore simbolico \holtxt{\$=:} alla +ed elaborato dal parser come un'applicazione del'identificatore simbolico \holtxt{\$=:} alla lista di termini argomento [\holtxt{bool}, \holtxt{->}, \holtxt{bool}, \holtxt{->}, \holtxt{bool}]. Uno spazio messo al punto giusto eviter questo problema: \begin{hol} @@ -586,8 +586,8 @@ \subsubsection{Vincoli di tipo} $= :bool->bool->bool \end{verbatim} \end{hol} - elaborato da parser come l'identificatore simbolico ``='' vincolato a un tipo. -Al posto del \holtxt{\$}, si possono anche usare le parentesi per rimuovere dai lessemi + elaborato da parser come l'identificatore simbolico ``='' vincolato a un tipo. +Al posto del \holtxt{\$}, si possono anche usare le parentesi per rimuovere dai lessemi un comportamento di parsing speciale: \begin{hol} \begin{verbatim} @@ -599,30 +599,30 @@ \subsubsection{Inferenza di tipo} \label{sec:parser:type-inference} \index{inferenza di tipo!nel parser HOL@nel parser \HOL{}|(} -Si consideri il termine \holtxt{x = T}: esso (e tutti i suoi sottotermini) -ha un tipo nella logica \HOL{}. Ora, \holtxt{T} ha il tipo \holtxt{bool}. Questo +Si consideri il termine \holtxt{x = T}: esso (e tutti i suoi sottotermini) +ha un tipo nella logica \HOL{}. Ora, \holtxt{T} ha il tipo \holtxt{bool}. Questo significa che la costante \holtxt{=} ha tipo \holtxt{xty -> bool -> bool}, -per qualche tipo \holtxt{xty}. Dal momento che lo schema di tipo per \holtxt{=} -\holtxt{'a -> 'a -> bool}, sappiamo che \holtxt{xty} di fatto deve essere -\holtxt{bool} perch l'istanza di tipo sia ben formata. Sapendo +per qualche tipo \holtxt{xty}. Dal momento che lo schema di tipo per \holtxt{=} +\holtxt{'a -> 'a -> bool}, sappiamo che \holtxt{xty} di fatto deve essere +\holtxt{bool} perch l'istanza di tipo sia ben formata. Sapendo questo, possiamo dedurre che il tipo di \holtxt{x} deve essere \holtxt{bool}. -Trascurando il gergo (``schema'' e ``istanza'') nel precedente -paragrafo, abbiamo condotto un assegnamento di tipo alla struttura di termine, -finendo con un termine ben formato. Sarebbe molto noioso per gli utenti -condurre un tale assegnamento a mano per ciascun termine immesso ad \HOL{}. -Cos, \HOL{} usa un adattamento dell'algoritmo d'inferenza di tipo di Milner -per l'\ML{} quando si costruiscono dei termini attraverso il parsing. Alla fine dell'inferenza -di tipo, alle variabili di tipo non vincolate sono assegnati dei nomi da parte del sistema. -Di solito, questa assegnazione fa la cosa giusta. Tuttavia, a volte, il -tipo pi generale non ci che si desidera e l'utente deve aggiungere dei vincoli -di tipo ai sotto termini rilevanti. Per situazioni complicate, si pu assegnare la -variabili globale \ml{show\_types}. Quando impostato questo flag, -i prettyprinter per i termini e i teoremi mostreranno come i tipi -sono stati assegnati ai sottotermini. Se non si vuole che il sistema assegni -delle variabili di tipo per proprio conto, si pu impostare la variabile globale -\ml{guessing\_tyvars} a \ml{false}, nel qual caso -l'esistenza delle variabili di tipo non assegnate alla fine dell'inferenza di tipo +Trascurando il gergo (``schema'' e ``istanza'') nel precedente +paragrafo, abbiamo condotto un assegnamento di tipo alla struttura di termine, +finendo con un termine ben formato. Sarebbe molto noioso per gli utenti +condurre un tale assegnamento a mano per ciascun termine immesso ad \HOL{}. +Cos, \HOL{} usa un adattamento dell'algoritmo d'inferenza di tipo di Milner +per l'\ML{} quando si costruiscono dei termini attraverso il parsing. Alla fine dell'inferenza +di tipo, alle variabili di tipo non vincolate sono assegnati dei nomi da parte del sistema. +Di solito, questa assegnazione fa la cosa giusta. Tuttavia, a volte, il +tipo pi generale non ci che si desidera e l'utente deve aggiungere dei vincoli +di tipo ai sotto termini rilevanti. Per situazioni complicate, si pu assegnare la +variabili globale \ml{show\_types}. Quando impostato questo flag, +i prettyprinter per i termini e i teoremi mostreranno come i tipi +sono stati assegnati ai sottotermini. Se non si vuole che il sistema assegni +delle variabili di tipo per proprio conto, si pu impostare la variabile globale +\ml{guessing\_tyvars} a \ml{false}, nel qual caso +l'esistenza delle variabili di tipo non assegnate alla fine dell'inferenza di tipo solleveranno un'eccezzione. \index{type inference!nel parser HOL@nel parser \HOL{}|)} @@ -631,12 +631,12 @@ \subsubsection{Overloading} \label{sec:parsing:overloading} \index{parsing, della logica HOL@parsing, della logica \HOL{}!overloading|(} -Una misura limitata di risoluzione di overloading eseguita dal parser -del termine. Per esempio, il simbolo `tilde' (\holtxt{\~{}}) -denota la negazione booleana nella teoria iniziale di \HOL, e denota anche +Una misura limitata di risoluzione di overloading eseguita dal parser +del termine. Per esempio, il simbolo `tilde' (\holtxt{\~{}}) +denota la negazione booleana nella teoria iniziale di \HOL, e denota anche l'invero additivo nelle teorie \ml{integer} e -\ml{real}. Se carichiamo la teoria \ml{integer} -e immettiamo un termine ambiguo con \holtxt{\~{}}, il +\ml{real}. Se carichiamo la teoria \ml{integer} +e immettiamo un termine ambiguo con \holtxt{\~{}}, il sistema ci informer che stata eseguita la risoluzione dell'overloading. \setcounter{sessioncount}{0} @@ -654,13 +654,13 @@ \subsubsection{Overloading} \end{verbatim} \end{session} -Per risolvere pi scelte possibili usato un meccanismo di priorit. -Nell'esempio, \holtxt{\~{}} potrebbe essere coerentemente scelto avere il tipo -\holtxt{:bool -> bool} o \holtxt{:int -> int}, e il -meccanismo ha scelto il primo. Per un controllo pi fine, si possono usare dei -vincoli di tipo espliciti. Nella seguente sessione, il +Per risolvere pi scelte possibili usato un meccanismo di priorit. +Nell'esempio, \holtxt{\~{}} potrebbe essere coerentemente scelto avere il tipo +\holtxt{:bool -> bool} o \holtxt{:int -> int}, e il +meccanismo ha scelto il primo. Per un controllo pi fine, si possono usare dei +vincoli di tipo espliciti. Nella seguente sessione, il \holtxt{\~{}\~{}x} nella prima quotation ha il tipo \holtxt{:bool}, -mentre nella seconda, un vincolo di tipo assicura che \holtxt{\~{}\~{}x} ha +mentre nella seconda, un vincolo di tipo assicura che \holtxt{\~{}\~{}x} ha il tipo \holtxt{:int}. \begin{session} @@ -677,9 +677,9 @@ \subsubsection{Overloading} \end{verbatim} \end{session} -Si noti che il simbolo \holtxt{\~{}} sta per due costanti differenti nella -seconda quotation; la sua prima occorrenza la negazione booleana, mentre -le altre due occorrenze sono l'operazione d'inverso additivo per +Si noti che il simbolo \holtxt{\~{}} sta per due costanti differenti nella +seconda quotation; la sua prima occorrenza la negazione booleana, mentre +le altre due occorrenze sono l'operazione d'inverso additivo per gli interi. \index{parsing, della logica HOL@parsing, della logica \HOL{}!overloading|)} @@ -687,23 +687,23 @@ \subsubsection{Le fixity} \label{sec:parseprint:fixities} Al fine di fornire qualche flessibilit notazionale, le costanti sono disponibili in varie forme o {\it fixity}: oltre a essere costanti ordinarie (senza alcuna fixity), le costanti possono essere anche dei {\it binder}, {\it prefissi}, {\it suffissi}, {\it infissi}, o {\it closefix}. -Pi in generale, i termini possono anche essere rappresentati usando specifiche {\it mixfix} ragionevolmente arbitrarie. -Il grado in cui i termini legano i loro argomenti associati conosciuto come precedenza. +Pi in generale, i termini possono anche essere rappresentati usando specifiche {\it mixfix} ragionevolmente arbitrarie. +Il grado in cui i termini legano i loro argomenti associati conosciuto come precedenza. Pi grande questo numero, pi stretto il binding. Per esempio, nel momento in cui introdotto, \verb-+- ha una precedenza di 500, mentre il pi stretto binder moltiplicazione (\verb+*+) ha una precedenza di 600. \paragraph{I binder} -Un binder un costrutto che lega una variabile; per esempio, il -quantificatore universale. In \HOL, questo rappresentato usando un trucco che -risale ad Alnozo Church: un binder una costante che prende una lambda -astrazione come suo argomento. Il binding lambda usato per implementare -il binding del costrutto. Questa una soluzione elegante ed uniforme. -Cos la sintassi concreta \verb+!v. M+ rappresentata +Un binder un costrutto che lega una variabile; per esempio, il +quantificatore universale. In \HOL, questo rappresentato usando un trucco che +risale ad Alnozo Church: un binder una costante che prende una lambda +astrazione come suo argomento. Il binding lambda usato per implementare +il binding del costrutto. Questa una soluzione elegante ed uniforme. +Cos la sintassi concreta \verb+!v. M+ rappresentata dall'applicazione della costante \verb+!+ all'astrazione \verb+(\v. M)+. I binder pi comuni sono \verb+!+, \verb+?+, \verb+?!+, e -\verb+@+. A volte si vogliono iterare applicazione dello stesso +\verb+@+. A volte si vogliono iterare applicazione dello stesso binder, ad esempio, \begin{alltt} !x. !y. ?p. ?q. ?r. \term. @@ -715,14 +715,14 @@ \subsubsection{Le fixity} \paragraph{Infissi} -Le costanti infisse possono associare in tre modi differenti: a destra, -a sinistra o non associare del tutto. (Se \holtxt{+} fosse non-associativo, allora -il parser non riuscirebbe ad elaborare \holtxt{3 + 4 + 5}; si dovrebbe scrivere -\holtxt{(3 + 4) + 5} o \holtxt{3 + (4 + 5)} a seconda del significato -desiderato.) L'ordine di precedenza per l'insieme iniziale di infissi +Le costanti infisse possono associare in tre modi differenti: a destra, +a sinistra o non associare del tutto. (Se \holtxt{+} fosse non-associativo, allora +il parser non riuscirebbe ad elaborare \holtxt{3 + 4 + 5}; si dovrebbe scrivere +\holtxt{(3 + 4) + 5} o \holtxt{3 + (4 + 5)} a seconda del significato +desiderato.) L'ordine di precedenza per l'insieme iniziale di infissi \holtxt{/\bs}, \holtxt{\bs/}, \holtxt{==>}, \holtxt{=}, \begin{Large}\holtxt{,}\end{Large} (la virgola\footnote{Quando - stata caricata \theoryimp{pairTheory}.}). Inoltre, tutte queste + stata caricata \theoryimp{pairTheory}.}). Inoltre, tutte queste costanti sono associative a destra. Cos \begin{hol} \begin{verbatim} @@ -774,14 +774,14 @@ \subsubsection{Le fixity} \paragraph{Suffissi} -I suffissi appaiono dopo il loro argomenti. Non ci sono suffissi -introdotti nelle teorie standard disponibili in \HOL{}, ma gli utenti -sono sempre in grado di introdurli per loro conto se lo scelgono. I suffissi sono -associati con una precedenza esattamente come lo sono gli infissi e i prefissi. -Se \holtxt{p} un prefisso, \holtxt{i} un infisso, e \holtxt{s} un -suffisso, allora ci sono sei ordinamenti possibili per i tre differenti -operatori, sulla base delle loro precedenze, dando cinque risultati per il parsing di -$\holtxt{p}\; t_1\; \holtxt{i}\; t_2\; \holtxt{s}$ a seconda delle +I suffissi appaiono dopo il loro argomenti. Non ci sono suffissi +introdotti nelle teorie standard disponibili in \HOL{}, ma gli utenti +sono sempre in grado di introdurli per loro conto se lo scelgono. I suffissi sono +associati con una precedenza esattamente come lo sono gli infissi e i prefissi. +Se \holtxt{p} un prefisso, \holtxt{i} un infisso, e \holtxt{s} un +suffisso, allora ci sono sei ordinamenti possibili per i tre differenti +operatori, sulla base delle loro precedenze, dando cinque risultati per il parsing di +$\holtxt{p}\; t_1\; \holtxt{i}\; t_2\; \holtxt{s}$ a seconda delle relative precedenze: \[ \begin{array}{cl} @@ -799,61 +799,61 @@ \subsubsection{Le fixity} \paragraph{I closefix} -I termini closefix sono operatori che racchiudono completamente gli argomenti. -Un esempio che si potrebbe usare nello sviluppo di una teoria della -semantica denotazionale sono le parentesi semantiche. Cos, le infrastrutture di parsing -di \HOL{} possono essere configurate in modo da permettere di scrivere \holtxt{denotation x} -come \holtxt{[| x |]}. I closefix non sono associati con delle precedenze +I termini closefix sono operatori che racchiudono completamente gli argomenti. +Un esempio che si potrebbe usare nello sviluppo di una teoria della +semantica denotazionale sono le parentesi semantiche. Cos, le infrastrutture di parsing +di \HOL{} possono essere configurate in modo da permettere di scrivere \holtxt{denotation x} +come \holtxt{[| x |]}. I closefix non sono associati con delle precedenze perch non possono competere per gli argomenti con altri operatori. \subsubsection{Trucchi e magia del parser} -Qui descriviamo come ottenere alcuni effetti utili con il +Qui descriviamo come ottenere alcuni effetti utili con il parser in \HOL{}. \begin{description} -\item[Aliasing] Se si vuole che una sintassi speciale sia un ``alias'' per una - forma \HOL{} normale, questo facile da ottenere; entrambi gli esempi fatti finora - di fatto hanno fatto proprio questo. Tuttavia, se si vuole avere soltanto una - normale sostituzione uno-a-uno di una stringa per un'altra, non si pu - usare la fase grammatica/sintassi per parsing per fare questo. Piuttosto, si - pu usare il meccanismo di overloading. Per esempio, sia - \texttt{MEM} un alias per \texttt{IS\_EL}. Abbiamo bisogno della funzione - \texttt{overload\_on} per impostare l'overload della constante originale sul nuovo +\item[Aliasing] Se si vuole che una sintassi speciale sia un ``alias'' per una + forma \HOL{} normale, questo facile da ottenere; entrambi gli esempi fatti finora + di fatto hanno fatto proprio questo. Tuttavia, se si vuole avere soltanto una + normale sostituzione uno-a-uno di una stringa per un'altra, non si pu + usare la fase grammatica/sintassi per parsing per fare questo. Piuttosto, si + pu usare il meccanismo di overloading. Per esempio, sia + \texttt{MEM} un alias per \texttt{IS\_EL}. Abbiamo bisogno della funzione + \texttt{overload\_on} per impostare l'overload della constante originale sul nuovo nome: \begin{verbatim} val _ = overload_on ("MEM", Term`IS_EL`); \end{verbatim} -\item[Rendere l'addizione associativa a destra] Se si ha un numero di vecchi - script che assumono che l'addizione sia associativa a destra perch questo - come era una volta \HOL{}, potrebbe essere troppo penoso convertire tutto. Il trucco - di rimuovere tutte le regole al livello dato della grammatica, e - rimetterle come infissi che associano sulla destra. il modo pi semplice per riconoscere - quali regole sono nella grammatica per ispezione (usando - \ml{term\_grammar()}). Con la sola \ml{arithmeticTheory} +\item[Rendere l'addizione associativa a destra] Se si ha un numero di vecchi + script che assumono che l'addizione sia associativa a destra perch questo + come era una volta \HOL{}, potrebbe essere troppo penoso convertire tutto. Il trucco + di rimuovere tutte le regole al livello dato della grammatica, e + rimetterle come infissi che associano sulla destra. il modo pi semplice per riconoscere + quali regole sono nella grammatica per ispezione (usando + \ml{term\_grammar()}). Con la sola \ml{arithmeticTheory} caricata, gli unici infissi al livello 500 sono \holtxt{+} and \holtxt{-}. Cos, rimuoviamo le loro regole: \begin{verbatim} val _ = app temp_remove_rules_for_term ["+", "-"]; \end{verbatim} - \noindent E poi le rimettiamo con l'associativit + \noindent E poi le rimettiamo con l'associativit appropriata: \begin{verbatim} val _ = app (fn s => temp_add_infix(s, 500, RIGHT)) ["+", "-"]; \end{verbatim} -\noindent Si noti che usiamo le versioni \ml{temp\_} di queste due -funzioni cos che altre teorie che dipendono da questa non saranno -influenzate. Si noti inoltre che non possiamo avere due infissi allo stesso -livello di precedenza con differenti associativit, cos dobbiamo +\noindent Si noti che usiamo le versioni \ml{temp\_} di queste due +funzioni cos che altre teorie che dipendono da questa non saranno +influenzate. Si noti inoltre che non possiamo avere due infissi allo stesso +livello di precedenza con differenti associativit, cos dobbiamo rimuovere entrambi gli operatori, non solo l'addizione. \item[Sintassi mix-fix per {\it if-then-else}:] \index{condizionali, nella logica HOL@condizionali, nella logica \HOL{}!stampa dei} % -Il primo passo per andare in questa direzione di guardare all'aspetto generale +Il primo passo per andare in questa direzione di guardare all'aspetto generale delle espressioni di questa forma. In questo caso, sar: % \[ @@ -861,9 +861,9 @@ \subsubsection{Trucchi e magia del parser} \holtxt{else}\;\;\dots \] % - Dal momento che ci deve essere un termine ``a penzoloni'' sulla destra, la - fixity appropriata \ml{Prefix}. Sapendo che il termine costante - sottostante chiamato \holtxt{COND}, il modo pi semplice per ottenere + Dal momento che ci deve essere un termine ``a penzoloni'' sulla destra, la + fixity appropriata \ml{Prefix}. Sapendo che il termine costante + sottostante chiamato \holtxt{COND}, il modo pi semplice per ottenere la sintassi desiderata : \begin{verbatim} val _ = add_rule @@ -874,7 +874,7 @@ \subsubsection{Trucchi e magia del parser} paren_style = Always, block_style = (AroundEachPhrase, (PP.CONSISTENT, 0))}; \end{verbatim} -\noindent La regola effettiva leggermente un p pi complicata, e +\noindent La regola effettiva leggermente un p pi complicata, e si pu trovare nei sorgenti della teoria \theoryimp{bool}. \item[Sintassi mix-fix sintassi per la sostituzione di termini:] @@ -883,23 +883,23 @@ \subsubsection{Trucchi e magia del parser} \[ \mbox{\texttt{[}}\,t_1\,\mbox{\texttt{/}}\,t_2\,\mbox{\texttt{]}}\,t_3 \] -denotando la sostituzione di $t_1$ per $t_2$ in $t_3$, magari -traducendolo in \holtxt{SUB $t_1$ $t_2$ $t_3$}. Questo sembra -come ci dovesse essere un altro \ml{Prefix}, ma la scelta delle -parentesi quadre (\holtxt{[} e \holtxt{]}) come delimitatori sarebbe +denotando la sostituzione di $t_1$ per $t_2$ in $t_3$, magari +traducendolo in \holtxt{SUB $t_1$ $t_2$ $t_3$}. Questo sembra +come ci dovesse essere un altro \ml{Prefix}, ma la scelta delle +parentesi quadre (\holtxt{[} e \holtxt{]}) come delimitatori sarebbe in conflitto con la sintassi concreta per i letterali lista se si facesse questo. -Dato che i letterali lista sono di fatto della classe -\ml{CloseFix}, la nuova sintassi deve essere della stessa classe. Questo abbastanza semplice -da fare: impostiamo la sintassi +Dato che i letterali lista sono di fatto della classe +\ml{CloseFix}, la nuova sintassi deve essere della stessa classe. Questo abbastanza semplice +da fare: impostiamo la sintassi \[ \holtxt{[}\,t_1\,\holtxt{/}\,t_2\,\holtxt{]} \] -in modo che mappi a \holtxt{SUB $t_1$ $t_2$}, un valore di un tipo -funzionale, che quando applicato a un terzo argomento apparir -corretto\footnote{Si noti che facendo la stessa cosa per - l'esempio \textit{if-then-else} di sopra sarebbe - inappropriato, dal momento che permetterebbe di scrivere -\[ \holtxt{if}\;P\;\holtxt{then}\;Q\;\holtxt{else} \] +in modo che mappi a \holtxt{SUB $t_1$ $t_2$}, un valore di un tipo +funzionale, che quando applicato a un terzo argomento apparir +corretto\footnote{Si noti che facendo la stessa cosa per + l'esempio \textit{if-then-else} di sopra sarebbe + inappropriato, dal momento che permetterebbe di scrivere +\[ \holtxt{if}\;P\;\holtxt{then}\;Q\;\holtxt{else} \] senza l'argomento finale}. La regola per questo cos: \begin{verbatim} @@ -920,7 +920,7 @@ \subsubsection{Nascondere le costanti} \index{costanti, nella logica HOL@costanti, nella logica \HOL{}!nascondere lo status delle} \index{parsing, della logica HOL@parsing, della logica \HOL{}!overloading} % -La seguente funzione pu essere usata per nascondere lo status di costante di un +La seguente funzione pu essere usata per nascondere lo status di costante di un nome dal parser delle quotation. \begin{holboxed} @@ -931,22 +931,22 @@ \subsubsection{Nascondere le costanti} \end{verbatim} \end{holboxed} -\noindent La valutazione di \ml{hide "$x$"} -fa s che il parser delle quotation tratti $x$ come una variabile (purch le regole -lessicali lo permettano), anche se $x$ il nome di una costante nella teoria attuale +\noindent La valutazione di \ml{hide "$x$"} +fa s che il parser delle quotation tratti $x$ come una variabile (purch le regole +lessicali lo permettano), anche se $x$ il nome di una costante nella teoria attuale (le costanti e le variabili possono avere lo stesso nome). -Questo utile se si vogliono usare delle variabili +Questo utile se si vogliono usare delle variabili % \index{variabili, nella logica HOL@variabili, nella logica \HOL{}!con nomi di costante} % -con lo stesso nome di costanti dichiarate in precedenza (o incorporate) -(ad esempio \ml{o}, \ml{I}, \ml{S} \etc). Il nome $x$ ancora una costante -per i costruttori, le teorie, ecc; \ml{hide} influisce solo sul parsing e -la stampa rimuovendo il nome dato dalla ``mappa di overload'' descritta -di sopra nella Sezione~\ref{sec:parser:architecture}. Si noti che l'effetto -di \ml{hide} \emph{temporaneo}; i suoi effetti non persistono nelle -teorie discendenti da quella attuale. Si veda la voce \ml{hide} in -\REFERENCE{} per maggiori dettagli, inclusa una spiegazione del tipo +con lo stesso nome di costanti dichiarate in precedenza (o incorporate) +(ad esempio \ml{o}, \ml{I}, \ml{S} \etc). Il nome $x$ ancora una costante +per i costruttori, le teorie, ecc; \ml{hide} influisce solo sul parsing e +la stampa rimuovendo il nome dato dalla ``mappa di overload'' descritta +di sopra nella Sezione~\ref{sec:parser:architecture}. Si noti che l'effetto +di \ml{hide} \emph{temporaneo}; i suoi effetti non persistono nelle +teorie discendenti da quella attuale. Si veda la voce \ml{hide} in +\REFERENCE{} per maggiori dettagli, inclusa una spiegazione del tipo restituito. La funzione @@ -977,7 +977,7 @@ \subsubsection{Nascondere le costanti} \subsubsection{Adattare la profondit del pretty-print} \index{stampa, nella logica HOL@stampa, nella logica \HOL{}!adattamento della profondit strutturale nella} -La seguente reference \ML{} pu essere usata per impostare la profondit massima +La seguente reference \ML{} pu essere usata per impostare la profondit massima della stampa \begin{holboxed} @@ -989,8 +989,8 @@ \subsubsection{Nascondere le costanti} \index{profondit di stampa di default, per la logica HOL@profondit di stampa di default, per la logica \HOL{}|(} -\noindent La profondit di default della stampa $-1$ che intesa significare -nessun massimo. I sotto termini annidati pi profondamente della profondit +\noindent La profondit di default della stampa $-1$ che intesa significare +nessun massimo. I sotto termini annidati pi profondamente della profondit massima di stampa sono stampati come \holtxt{...}. Per esempio: \setcounter{sessioncount}{0} @@ -1014,11 +1014,11 @@ \subsection{Quotation e antiquotation} \index{quotation, nella logica HOL@quotation, nella logica \HOL{}!parser per} \index{parsing, della logica HOL@parsing, della logica \HOL{}!della sintassi di quotation|(} -La sintassi correlata alla logica nel sistema HOL tipicamente passato al -parser in forme speciali conosciute come \emph{quotation}. Una quotation di base - delimitata da singoli accenti grave (cio, \ml{`}, carattere ASCII~96). Quando -i valori quotation sono stampati dal loop interattivo ML, appaiono -piuttosto brutti a causa dello speciale filtro che fatto di questi +La sintassi correlata alla logica nel sistema HOL tipicamente passato al +parser in forme speciali conosciute come \emph{quotation}. Una quotation di base + delimitata da singoli accenti grave (cio, \ml{`}, carattere ASCII~96). Quando +i valori quotation sono stampati dal loop interattivo ML, appaiono +piuttosto brutti a causa dello speciale filtro che fatto di questi valori ancor prima che l'interprete li veda: \setcounter{sessioncount}{0} \begin{session} @@ -1034,8 +1034,8 @@ \subsection{Quotation e antiquotation} and is thus of type \[ \ml{term quotation -> term} \] -I parser dei termini e dei tipi possono essere chiamati anche implicitamente usando -i doppi accenti acuti come delimitatori. Per il parser dei tipi, il primo +I parser dei termini e dei tipi possono essere chiamati anche implicitamente usando +i doppi accenti acuti come delimitatori. Per il parser dei tipi, il primo carattere non spazio dopo il delimitatore principale deve essere un segno di deu punti. Cos: \begin{session} @@ -1048,25 +1048,25 @@ \subsection{Quotation e antiquotation} \end{verbatim} \end{session} -L'espressione legata alla variabile ML \ml{t} di sopra di fatto espansa -a un'applicazione della funzione \ml{Parse.Term} alla quotation -argomento \ml{`p /\bs{} q`}. Analogamente, la seconda espressione si espande +L'espressione legata alla variabile ML \ml{t} di sopra di fatto espansa +a un'applicazione della funzione \ml{Parse.Term} alla quotation +argomento \ml{`p /\bs{} q`}. Analogamente, la seconda espressione si espande in un'applicazione di \ml{Parse.Type} alla quotation \ml{`:'a -> bool`}. -Il vantaggio importante delle quotation rispetto a normali stringhe \ML{} -che esse possono includere caratteri di nuova riga e backslash senza -richiedere caratteri speciali di escape. Le nuove righe occorrono ogni volta che i termini vanno oltre -una dimensione banale, mentre i backslash occorrono non solo nella -rappresentazione di $\lambda$, ma anche nella sintassi per la congiunzione e +Il vantaggio importante delle quotation rispetto a normali stringhe \ML{} +che esse possono includere caratteri di nuova riga e backslash senza +richiedere caratteri speciali di escape. Le nuove righe occorrono ogni volta che i termini vanno oltre +una dimensione banale, mentre i backslash occorrono non solo nella +rappresentazione di $\lambda$, ma anche nella sintassi per la congiunzione e la disgiunzione. -Se una quotation deve includere un carattere di accento grave, allora questo dovrebbe -essere fatto usando il carattere di escape proprio della sintassi della quotation, il -caret (\ml{\^}, carattere ASCII~94). Per avere un semplice caret, le cose diventano -leggermente pi complicate. Se una sequenza di caret seguita dallo -spazio vuoto (incluso un carattere di nuova riga), allora quella sequenza di caret -passata al parser di HOL senza modifiche. Altrimenti, un singolo caret si pu -ottenere scrivendone due in una riga. (L'ultima regola analoga al +Se una quotation deve includere un carattere di accento grave, allora questo dovrebbe +essere fatto usando il carattere di escape proprio della sintassi della quotation, il +caret (\ml{\^}, carattere ASCII~94). Per avere un semplice caret, le cose diventano +leggermente pi complicate. Se una sequenza di caret seguita dallo +spazio vuoto (incluso un carattere di nuova riga), allora quella sequenza di caret +passata al parser di HOL senza modifiche. Altrimenti, un singolo caret si pu +ottenere scrivendone due in una riga. (L'ultima regola analoga al modo in cui in \ML{} la sintassi delle stringhe tratta il backslash.) Cos: \begin{session} \begin{verbatim} @@ -1080,8 +1080,8 @@ \subsection{Quotation e antiquotation} \end{verbatim} \end{session} -La regola per i caret non seguiti da uno spazio vuoto illustrata qui, -includendo un esempio che accade quando non si segue la regola +La regola per i caret non seguiti da uno spazio vuoto illustrata qui, +includendo un esempio che accade quando non si segue la regola per il quoting: \begin{session} \begin{verbatim} @@ -1098,8 +1098,8 @@ \subsection{Quotation e antiquotation} \end{verbatim} \end{session} -L'uso principale del caret d'introdurre le \emph{quntiquotation} (come -suggerito nell'ultimo esempio di sopra). All'interno di una quotation, l'espressioni +L'uso principale del caret d'introdurre le \emph{quntiquotation} (come +suggerito nell'ultimo esempio di sopra). All'interno di una quotation, l'espressioni della forma {\small\verb+^(+}$t${\small\verb+)+} % \index{ antiquotation, nella logica HOL@{\small\verb+^+} (antiquotation, nella logica \HOL{})} @@ -1113,11 +1113,11 @@ \subsection{Quotation e antiquotation} \index{termini, nella logica HOL@termini, nella logica \HOL{}!antiquotation} \index{antiquotation, nei termini della logica HOL@antiquotation, nei termini della logica \HOL{}} % -Una quotation \holtxt{\^{}($t$)} valutata al -valore \ML{} di $t$. Per esempio, {\small\verb+``x \/ ^(mk_conj(``y:bool``, ``z:bool``))``+} - valutata allo stesso termine di {\small\verb+``x \/ (y /\ z)``+}. L'uso -pi comune dell'antiquotation quando il termine $t$ legato a una variabile -\ML\ $x$. In questo caso {\small\verb+^(+}$x${\small\verb+)+} pu essere +Una quotation \holtxt{\^{}($t$)} valutata al +valore \ML{} di $t$. Per esempio, {\small\verb+``x \/ ^(mk_conj(``y:bool``, ``z:bool``))``+} + valutata allo stesso termine di {\small\verb+``x \/ (y /\ z)``+}. L'uso +pi comune dell'antiquotation quando il termine $t$ legato a una variabile +\ML\ $x$. In questo caso {\small\verb+^(+}$x${\small\verb+)+} pu essere abbreviato da {\small\verb+^+}$x$. La seguente sessione illustra l'antiquotation. @@ -1148,9 +1148,9 @@ \subsection{Quotation e antiquotation} \end{verbatim} \end{session} -\noindent Le quotation sono polimorfiche, e la variabile di tipo di una -quotation corrisponde al tipo dell'entit che pu essere sottoposta all'antiquotation -in quella quotation. Dal moemnto che il parser dei termini si aspetta solo termini +\noindent Le quotation sono polimorfiche, e la variabile di tipo di una +quotation corrisponde al tipo dell'entit che pu essere sottoposta all'antiquotation +in quella quotation. Dal moemnto che il parser dei termini si aspetta solo termini sottoposti ad antiquotation, l'antiquotation di un tipo all'interno di una quotation di termine richiede l'uso di \holtxt{ty\_antiq}. Per esempio,% % @@ -1179,63 +1179,63 @@ \subsection{Quotation e antiquotation} \subsection{Retro-compatibilit della sintassi} -Questa sezione del manuale documenta il cambiamento (esteso) fatto al -parsing di \HOL{} dei termini e dei tipi nella release Taupo (una delle -release HOL3) e al di l del punto di vista di un utente che non -vuole sapere come usare le nuove strutture, ma vuole essere sicuro +Questa sezione del manuale documenta il cambiamento (esteso) fatto al +parsing di \HOL{} dei termini e dei tipi nella release Taupo (una delle +release HOL3) e al di l del punto di vista di un utente che non +vuole sapere come usare le nuove strutture, ma vuole essere sicuro che il proprio vecchio codice continui a funzionare in modo pulito. I cambiamenti che possono far s che i vecchi termini falliscano il parsing sono: \begin{itemize} \newcommand\condexp{\holtxt{$p$ => $q$ | $r$}} -\item La precedenza delle annotazioni di tipo completamente cambiata. Ora - un suffisso molto stretto (bench con una precedenza pi debole di quella +\item La precedenza delle annotazioni di tipo completamente cambiata. Ora + un suffisso molto stretto (bench con una precedenza pi debole di quella associata con l'applicazione di funzione), invece di uno debole. - Questo significa che \mbox{\tt (x,y:bool \# bool)} ora dovrebbe essere scritto - come \mbox{\tt (x,y):bool \# bool}. La forma precedente sar ora - parsata come un'annotazione di tipo che si applica solo a \verb+y+. Questo - cambiamento porta la sintassi delle logica pi vicina a quella dell'SML e - dovrebbe rendere in genere pi facile annotare le tuple, dal momento che ora + Questo significa che \mbox{\tt (x,y:bool \# bool)} ora dovrebbe essere scritto + come \mbox{\tt (x,y):bool \# bool}. La forma precedente sar ora + parsata come un'annotazione di tipo che si applica solo a \verb+y+. Questo + cambiamento porta la sintassi delle logica pi vicina a quella dell'SML e + dovrebbe rendere in genere pi facile annotare le tuple, dal momento che ora si pu scrivere \[ (x\,:\,\tau_1,\;y\,:\,\tau_2,\dots z\,:\,\tau_n) \] al posto di \[ (x\,:\,\tau_1, \;(y\,:\,\tau_2, \dots (z\,:\,\tau_n))) - \] dove le parentesi extra si sono dovute aggiungere solo per permettere di + \] dove le parentesi extra si sono dovute aggiungere solo per permettere di scrivere una forma di vincolo che occorre frequentemente. -\item La maggior parte degli operatori aritmetici ora sono associativi a sinistra piuttosto che - a destra. In particolare, $+$, $-$, $*$ e {\tt DIV} sono - associativi a sinistra. In modo simile, gli analoghi operatori nelle altre - teoria aritmetiche come {\tt integer} e {\tt real} sono anche associativi - a sinistra. Questo porta il parser di \HOL{} in linea con la pratica +\item La maggior parte degli operatori aritmetici ora sono associativi a sinistra piuttosto che + a destra. In particolare, $+$, $-$, $*$ e {\tt DIV} sono + associativi a sinistra. In modo simile, gli analoghi operatori nelle altre + teoria aritmetiche come {\tt integer} e {\tt real} sono anche associativi + a sinistra. Questo porta il parser di \HOL{} in linea con la pratica matematica standard. -\item Il binding dell'eguaglianza nell'espressioni {\tt let} trattata esattamente - nello stesso modo dell'eguaglianze negli altri contesti. Nelle versioni precedenti - di \HOL, l'eguaglianze in questo contesto hanno una precedenza di bindig differente +\item Il binding dell'eguaglianza nell'espressioni {\tt let} trattata esattamente + nello stesso modo dell'eguaglianze negli altri contesti. Nelle versioni precedenti + di \HOL, l'eguaglianze in questo contesto hanno una precedenza di bindig differente pi debole. -\item La vecchia sintassi per l'espressioni condizionali stata - rimossa. Cos la stringa \holquote{\condexp} ora deve essere - scritta +\item La vecchia sintassi per l'espressioni condizionali stata + rimossa. Cos la stringa \holquote{\condexp} ora deve essere + scritta $\holquote{\texttt{if}\;p\;\texttt{then}\;q\;\texttt{else}\;r}$. -\item Alcune categorie lessicali sono sorvegliate pi strettamente. I letterali - stringa (le stringhe all'interno dei doppi apici) e quelli numerici non possono essere usati - a meno che le teorie rilevanti non siano state caricate. Inoltre questi +\item Alcune categorie lessicali sono sorvegliate pi strettamente. I letterali + stringa (le stringhe all'interno dei doppi apici) e quelli numerici non possono essere usati + a meno che le teorie rilevanti non siano state caricate. Inoltre questi letterali non possono essere usati come variabili all'interno di scopi di binding. \end{itemize} \section{Un Semplice Gestore di Dimostrazione Interattivo}\label{sec:goalstack} -Il \emph{goal stack} fornisce una semplice interfaccia di dimostrazione interattiva -basata sulle tattiche. Quando si vogliono usare le tattiche per decomporre una dimostrazione, sorgono -molti stati intermedi; il goalstack si prende cura del necessario mantenimento -di queste informazioni. L'implementazione dei goalstack qui riportati un +Il \emph{goal stack} fornisce una semplice interfaccia di dimostrazione interattiva +basata sulle tattiche. Quando si vogliono usare le tattiche per decomporre una dimostrazione, sorgono +molti stati intermedi; il goalstack si prende cura del necessario mantenimento +di queste informazioni. L'implementazione dei goalstack qui riportati un ridisegno della concezione originale di Larry Paulson. La libreria goalstack caricata automaticamente quando \HOL{} si avvia. -I tipi astratti \ml{goalstack} e \ml{proofs} sono il -punto focale delle operazioni di dimostrazione all'indietro. il tipo \ml{proofs} pu essere -considerato come una lista di goalstack indipendenti. La maggior parte delle operazioni agiscono sulla -testa della lista dei goalstack; ci sono anche operazioni cos che il +I tipi astratti \ml{goalstack} e \ml{proofs} sono il +punto focale delle operazioni di dimostrazione all'indietro. il tipo \ml{proofs} pu essere +considerato come una lista di goalstack indipendenti. La maggior parte delle operazioni agiscono sulla +testa della lista dei goalstack; ci sono anche operazioni cos che il punto focale pu essere cambiato. \subsection{Avviare un goalstack di dimostrazione} @@ -1247,17 +1247,17 @@ \subsection{Avviare un goalstack di dimostrazione} \end{verbatim} \end{hol} -Si ricordi che il tipo \ml{goal} un'abbreviazione per -\ml{term list * term}. Per partire su un nuovo goal, si da a -\ml{set\_goal} un goal. Questa crea un nuovo goalstack e lo rende il +Si ricordi che il tipo \ml{goal} un'abbreviazione per +\ml{term list * term}. Per partire su un nuovo goal, si da a +\ml{set\_goal} un goal. Questa crea un nuovo goalstack e lo rende il punto focale di ulteriori operazioni. -Un'abbreviazione per \ml{set\_goal} la funzione \ml{g}: essa -invoca il parser automaticamente, e non permette al goal di +Un'abbreviazione per \ml{set\_goal} la funzione \ml{g}: essa +invoca il parser automaticamente, e non permette al goal di avere alcuna assunzione. -La chiamata a \ml{set\_goal}, o \ml{g}, aggiunge un nuovo tentativo di dimostrazione a -quelli esistenti, \textit{cio}, al posto di sovrascrivere il tentativo +La chiamata a \ml{set\_goal}, o \ml{g}, aggiunge un nuovo tentativo di dimostrazione a +quelli esistenti, \textit{cio}, al posto di sovrascrivere il tentativo di dimostrazione attuale, il nuovo tentativo impilato in cima. \subsection{Applicare una tattica a un goal} @@ -1270,11 +1270,11 @@ \subsection{Applicare una tattica a un goal} \end{verbatim} \end{hol} -Come si fa dunque di fatto a fare una dimostrazione goalstack? Nella maggior parte dei casi, -l'applicazione delle tattiche al goal attuale fatto con la funzione -\verb+expand+. Nel raro caso in cui si voglia applicare una -tattica {\it invalida\/}, allora usata \verb+expandf+. (Per una -spiegazione delle tattiche invalide, si veda il Capitolo 24 di \& Melham.) +Come si fa dunque di fatto a fare una dimostrazione goalstack? Nella maggior parte dei casi, +l'applicazione delle tattiche al goal attuale fatto con la funzione +\verb+expand+. Nel raro caso in cui si voglia applicare una +tattica {\it invalida\/}, allora usata \verb+expandf+. (Per una +spiegazione delle tattiche invalide, si veda il Capitolo 24 di \& Melham.) Per espandere una tattica si pu anche usare l'abbreviazione \verb+e+. @@ -1291,26 +1291,26 @@ \subsection{Undo} \end{verbatim} \end{hol} -Spesso (siamo tentati di dire {\it di solito}!) si prende una strada sbagliata -nel fare una dimostrazione, o si fa un errore nell'impostare un goal. Per annullare un passo -nel goalstack, sono usate la funzione \ml{backup} e la sua abbreviazione -\ml{b}. Questo ripristiner il goalstack al suo stato +Spesso (siamo tentati di dire {\it di solito}!) si prende una strada sbagliata +nel fare una dimostrazione, o si fa un errore nell'impostare un goal. Per annullare un passo +nel goalstack, sono usate la funzione \ml{backup} e la sua abbreviazione +\ml{b}. Questo ripristiner il goalstack al suo stato precedente. -Per eseguire il backup completo al goal originale, pu essere usata -la funzione \ml{restart}. Ovviamente, anche importante liberarsi -dei tentativi di dimostrazione che sono sbagliati; per questo c' \ml{drop}, -che si sbarazza del tentativo di dimostrazione corrente, e \ml{dropn}, che +Per eseguire il backup completo al goal originale, pu essere usata +la funzione \ml{restart}. Ovviamente, anche importante liberarsi +dei tentativi di dimostrazione che sono sbagliati; per questo c' \ml{drop}, +che si sbarazza del tentativo di dimostrazione corrente, e \ml{dropn}, che elimina i primi $n$ tentativi di dimostrazione. -Ogni tentativo di dimostrazione ha la sua \emph{lista-di-annullamento} degli stati -precedenti. La lista di annullamento per ciascun tentativo di dimensione fissata (inzialmente -12). Se si vuole impostare questo valore per il tentativo corrente di dimostrazione, si pu -usare la funzione \ml{set\_backup}. Se la dimensione della lista di -backup impostata essere pi piccola di quanto sia attualmente, la lista di annullamente sar -immediatamente troncata. Non si pu annullare un'operazione ``proofs-level'', come +Ogni tentativo di dimostrazione ha la sua \emph{lista-di-annullamento} degli stati +precedenti. La lista di annullamento per ciascun tentativo di dimensione fissata (inzialmente +12). Se si vuole impostare questo valore per il tentativo corrente di dimostrazione, si pu +usare la funzione \ml{set\_backup}. Se la dimensione della lista di +backup impostata essere pi piccola di quanto sia attualmente, la lista di annullamente sar +immediatamente troncata. Non si pu annullare un'operazione ``proofs-level'', come \ml{set\_goal} o \ml{drop}. \subsection{Visualizzare lo stato del proof manager} @@ -1326,9 +1326,9 @@ \subsection{Visualizzare lo stato del proof manager} \end{verbatim} \end{hol} -Per visualizzare lo stato del proof manager in qualsiasi momento, si possono -usare le funzioni \ml{p} e \ml{status}. La prima mostra solo -i subgoal in cima al goalstack corrente, mentre la seconda da una +Per visualizzare lo stato del proof manager in qualsiasi momento, si possono +usare le funzioni \ml{p} e \ml{status}. La prima mostra solo +i subgoal in cima al goalstack corrente, mentre la seconda da una sintesi di ogni tentativo di dimostrazione. To get the top goal or goals of a proof attempt, use \ml{top\_goal} @@ -1336,12 +1336,12 @@ \subsection{Visualizzare lo stato del proof manager} use \ml{initial\_goal}. Per ottenere il o i top goal di un tentativo di dimostrazione, si usi \ml{top\_goal} -e \ml{top\_goals}. Per ottenere il goal originale di un tentativo di dimostrazione, +e \ml{top\_goals}. Per ottenere il goal originale di un tentativo di dimostrazione, si usi \ml{initial\_goal}. -Una volta che un teorema stato dimostrato il goalstack che stato usato per derivarlo -continua ad esistere (e anche la sua lista-di-annullamento): il suo compito principale ora quello di -mantenere il teorema. Questo teorema pu essere estratto con +Una volta che un teorema stato dimostrato il goalstack che stato usato per derivarlo +continua ad esistere (e anche la sua lista-di-annullamento): il suo compito principale ora quello di +mantenere il teorema. Questo teorema pu essere estratto con \ml{top\_thm}. \subsection{Spostare il fuoco su un differente subgoal o tentativo di dimostrazione} @@ -1355,9 +1355,9 @@ \subsection{Spostare il fuoco su un differente subgoal o tentativo di dimostrazi \end{verbatim} \end{hol} -Spesso vogliamo spostare la nostra attenzione a un differente goal nella dimostrazione -attuale, o a una dimostrazione differente. Le funzioni che fanno questo sono -\ml{rotate} e \ml{rotate\_proofs}, rispettivamente. Le abbreviazioni +Spesso vogliamo spostare la nostra attenzione a un differente goal nella dimostrazione +attuale, o a una dimostrazione differente. Le funzioni che fanno questo sono +\ml{rotate} e \ml{rotate\_proofs}, rispettivamente. Le abbreviazioni \ml{r} e \ml{R} sono pi semplici da digitare. \section{Dimostrazione di Alto Livello---\texttt{bossLib}} @@ -1366,19 +1366,19 @@ \section{Dimostrazione di Alto Livello---\texttt{bossLib}} \newcommand\bossLib{\ml{bossLib}} \index{bossLib@\ml{bossLib}} -La libreria \bossLib\ introduce alcuni degli strumenti di dimostrazione di teoremi -pi ampiamente utilizzati in \HOL{} e li fornisce di un'interfaccia conveniente -per l'interazione. La libreria attualmente si concentra su tre cose: -definizione di datatype e funzioni; operazioni interattive di dimostrazione -di alto livello, e composizione di ragionatori automatici. Il caricamento di \bossLib\ -impegna a lavorare in un contesto che fornisce gi le teorie +La libreria \bossLib\ introduce alcuni degli strumenti di dimostrazione di teoremi +pi ampiamente utilizzati in \HOL{} e li fornisce di un'interfaccia conveniente +per l'interazione. La libreria attualmente si concentra su tre cose: +definizione di datatype e funzioni; operazioni interattive di dimostrazione +di alto livello, e composizione di ragionatori automatici. Il caricamento di \bossLib\ +impegna a lavorare in un contesto che fornisce gi le teorie dei booleani, le coppie, le somme, il tipo option, l'aritmetica, e le liste. \subsection{Supporto per passi di dimostrazione di alto livello} \label{sec:high-level-proof-steps} -Le seguenti funzioni usano informazione nel database per facilitare +Le seguenti funzioni usano informazione nel database per facilitare l'applicazione delle funzionalit di \HOL{} sottostanti. \index{Induct_on (tattica ML d'induzione)@\ml{Induct\_on} (tattica \ML{} d'induzione)} @@ -1394,20 +1394,20 @@ \subsection{Supporto per passi di dimostrazione di alto livello} \index{type_rws@\ml{type\_rws}} \index{TypeBase@\ml{TypeBase}} % -La funzione \ml{type\_rws} cercher per il tipo dato nel -database sottostante \ml{TypeBase} e restituir utili regole di riscrittura per -quel tipo. Le regole di riscrittura del datatype sono costruite a partire dai -teoremi di iniettivit e distinzione, insieme con la definizione di costante +La funzione \ml{type\_rws} cercher per il tipo dato nel +database sottostante \ml{TypeBase} e restituir utili regole di riscrittura per +quel tipo. Le regole di riscrittura del datatype sono costruite a partire dai +teoremi di iniettivit e distinzione, insieme con la definizione di costante case. Le tattiche di semplificazione \ml{RW\_TAC}, \ml{SRW\_TAC}, -e il \simpset{} \ml{(srw\_ss())} includono automaticamente questi -teoremi. Altre tattiche usate con altri \simpset{} avranno bisogno di questi +e il \simpset{} \ml{(srw\_ss())} includono automaticamente questi +teoremi. Altre tattiche usate con altri \simpset{} avranno bisogno di questi teoremi per essere aggiunte manualmente. \index{teoremi d'induzione, nella logica HOL@teoremi d'induzione, nella logica \HOL{}!per tipi di dato algebrici} % -La tattica \ml{Induct} rende conveniente invocare l'induzione. Quando - applicata a un goal, esaminato il quantificatore universale principale; -se il suo tipo quello di un datatype conosciuto, estratta e applicata +La tattica \ml{Induct} rende conveniente invocare l'induzione. Quando + applicata a un goal, esaminato il quantificatore universale principale; +se il suo tipo quello di un datatype conosciuto, estratta e applicata l'appropriata tattica d'induzione strutturale. The \ml{Cases} tactic makes it convenient to invoke case @@ -1415,55 +1415,55 @@ \subsection{Supporto per passi di dimostrazione di alto livello} its type is that of a known datatype, the appropriate structural case analysis theorem is extracted and applied. -La tattica \ml{Cases\_on} prende una quotation, che -parsata a un termine $M$, e poi in $M$ viene effettuata una ricerca per il goal. Se $M$ - una variabile, allora si cerca per una variabile con lo stesso nome. Una volta -che si conosce il termine su cui effettuare lo split, il suo tipo e i fatti associati sono -ottenuti dal database sottostante e usati per eseguire il case -split. Se alcune delle variabili libere di $M$ sono legate nel goal, fatto un tentativo -per rimuovere i quantificatori (universali) cos che il case split abbia -vigore. Infine, $M$ non ha bisogno di apparire nel goal, bench dovrebbe almeno -contenere alcune delle variabili libere che compaiono gi nel goal. Si noti -che la tattica \ml{Cases\_on} pi generale di \ml{Cases}, ma +La tattica \ml{Cases\_on} prende una quotation, che +parsata a un termine $M$, e poi in $M$ viene effettuata una ricerca per il goal. Se $M$ + una variabile, allora si cerca per una variabile con lo stesso nome. Una volta +che si conosce il termine su cui effettuare lo split, il suo tipo e i fatti associati sono +ottenuti dal database sottostante e usati per eseguire il case +split. Se alcune delle variabili libere di $M$ sono legate nel goal, fatto un tentativo +per rimuovere i quantificatori (universali) cos che il case split abbia +vigore. Infine, $M$ non ha bisogno di apparire nel goal, bench dovrebbe almeno +contenere alcune delle variabili libere che compaiono gi nel goal. Si noti +che la tattica \ml{Cases\_on} pi generale di \ml{Cases}, ma richiede che gli sia dato un termine esplicito. \index{Induct_on (tattica ML d'induzione)@\ml{Induct\_on} (tattica \ML{} d'induzione)} -La tattica \ml{Induct\_on} prende una quotation, che parsata in un -termine $M$, e poi si cerca in $M$ il goal. Se $M$ una -variabile, allora si cerca per una variabile con lo stesso nome. Una volta che il -termine su cui effettuare l'induzione conosciuto, il suo tipo e i fatti associati sono -ottenuti dal database sottostante e usati per eseguire -l'induzione. Se $M$ non una variabile, creato una nuova variabile $v$ -che non occorre gi nel goal, ed usata per costruire un termine $v = M$ -a cui viene subordinato il goal prima che sia eseguita -l'induzione. Prima tuttavia, tutti i termini che contengono variabili libere da $M$ -sono spostate dalle assunzioni alla conclusione del goal, e tutte -le variabili libere dei $M$ sono quantificate universalmente. \ml{Induct\_on} -pi generale di \ml{Induct}, ma richiede che le venga dato un termine +La tattica \ml{Induct\_on} prende una quotation, che parsata in un +termine $M$, e poi si cerca in $M$ il goal. Se $M$ una +variabile, allora si cerca per una variabile con lo stesso nome. Una volta che il +termine su cui effettuare l'induzione conosciuto, il suo tipo e i fatti associati sono +ottenuti dal database sottostante e usati per eseguire +l'induzione. Se $M$ non una variabile, creato una nuova variabile $v$ +che non occorre gi nel goal, ed usata per costruire un termine $v = M$ +a cui viene subordinato il goal prima che sia eseguita +l'induzione. Prima tuttavia, tutti i termini che contengono variabili libere da $M$ +sono spostate dalle assunzioni alla conclusione del goal, e tutte +le variabili libere dei $M$ sono quantificate universalmente. \ml{Induct\_on} +pi generale di \ml{Induct}, ma richiede che le venga dato un termine esplicito. -Sono stati forniti tre entry-point supplementari per induzioni pi +Sono stati forniti tre entry-point supplementari per induzioni pi esotiche: \begin{description} -\item [\ml{completeInduct\_on}] esegue un'induzione completa sul - termine denotato dalla quotazione data. L'induzione completa permette - un'ipotesi d'induzione apparentemente\footnote{L'induzione completa e l'induzione - matematica ordinaria sono entrambe derivabili l'una dall'altra.} pi forte - rispetto all'induzione matematica ordinaria: vale a dire, quando - si esegue l'induzione su $n$, permesso assumere che la propriet valga per +\item [\ml{completeInduct\_on}] esegue un'induzione completa sul + termine denotato dalla quotazione data. L'induzione completa permette + un'ipotesi d'induzione apparentemente\footnote{L'induzione completa e l'induzione + matematica ordinaria sono entrambe derivabili l'una dall'altra.} pi forte + rispetto all'induzione matematica ordinaria: vale a dire, quando + si esegue l'induzione su $n$, permesso assumere che la propriet valga per \emph{tutti} gli $m$ pi piccoli di $n$. Formalmente: $\forall P.\ (\forall x.\ (\forall y.\ y < x \supset P\, y) \supset P\,x) \supset \forall x.\ - P\,x$. Questo permette di usare l'ipotesi d'induzione pi di - una volta, e permette anche d'istanziare l'ipotesi d'induzione + P\,x$. Questo permette di usare l'ipotesi d'induzione pi di + una volta, e permette anche d'istanziare l'ipotesi d'induzione in modo diverso dal predecessore. -\item [\ml{measureInduct\_on}] prende una quotation, e la suddivide +\item [\ml{measureInduct\_on}] prende una quotation, e la suddivide per trovare un termine e una funzione misura con cui indurre. - Per esempio, se si volesse fare un'induzione sulla lunghezza di una lista - \holtxt{L}, l'invocazione \ml{measureInduct\_on~`LENGTH L`} + Per esempio, se si volesse fare un'induzione sulla lunghezza di una lista + \holtxt{L}, l'invocazione \ml{measureInduct\_on~`LENGTH L`} sarebbe appropriata. -\item [\ml{recInduct}] prende un teorema d'induzione generato da +\item [\ml{recInduct}] prende un teorema d'induzione generato da \ml{Define} o \ml{Hol\_defn} e lo applica al goal attuale. \end{description} @@ -1472,13 +1472,13 @@ \subsection{Supporto per passi di dimostrazione di alto livello} \subsection{Ragionatori Automatici} \label{sec:automated-reasoners} -\ml{bossLib} riunisce i pi potenti ragionatori in \HOL{} e -prova a rendere facile comporli in un modo semplice. Prendiamo i nostri ragionatori -base da \ml{mesonLib}, \ml{simpLib}, e \ml{numLib}, -ma il punto di \ml{bossLib} di fornire un livello di astrazione cos -che l'utente debba sapere solo pochi entry-point\footnote{Nella met degli anni 1980 - Graham Birtwistle ha sostenuto un tale approccio, chiamandolo `HOL in Dieci - Tattiche}. (Quest librerie sottostanti, e altre che forniscono strumenti analogamente +\ml{bossLib} riunisce i pi potenti ragionatori in \HOL{} e +prova a rendere facile comporli in un modo semplice. Prendiamo i nostri ragionatori +base da \ml{mesonLib}, \ml{simpLib}, e \ml{numLib}, +ma il punto di \ml{bossLib} di fornire un livello di astrazione cos +che l'utente debba sapere solo pochi entry-point\footnote{Nella met degli anni 1980 + Graham Birtwistle ha sostenuto un tale approccio, chiamandolo `HOL in Dieci + Tattiche}. (Quest librerie sottostanti, e altre che forniscono strumenti analogamente potenti sono descritte nel dettaglio nelle sezioni di sotto.) \begin{hol} \begin{verbatim} @@ -1492,15 +1492,15 @@ \subsection{Ragionatori Automatici} DECIDE_TAC : tactic \end{verbatim} \end{hol} -La regola d'inferenza \texttt{PROVE} (e la tattica corrispondente -\texttt{PROVE\_TAC}) prende una lista di teoremi e un termine, e tenta -di dimostrare il termine usando un ragionatore al primo ordine. Le due funzioni -\ml{METIS} eseguono la stessa funzionalit ma usano un metodo di dimostrazione -sottostante differente. Gli entry-point \texttt{PROVE} si riferiscono alla -libreria \texttt{meson}, che ulteriormente descritta nella -Sezione~\ref{sec:mesonLib} di sotto. Il sistema \ml{METIS} descritto -nella Sezione~\ref{sec:metisLib}. La regola d'inferenza \texttt{DECIDE} -(e la tattica corrispondente \texttt{DECIDE\_TAC}) applica una procedura +La regola d'inferenza \texttt{PROVE} (e la tattica corrispondente +\texttt{PROVE\_TAC}) prende una lista di teoremi e un termine, e tenta +di dimostrare il termine usando un ragionatore al primo ordine. Le due funzioni +\ml{METIS} eseguono la stessa funzionalit ma usano un metodo di dimostrazione +sottostante differente. Gli entry-point \texttt{PROVE} si riferiscono alla +libreria \texttt{meson}, che ulteriormente descritta nella +Sezione~\ref{sec:mesonLib} di sotto. Il sistema \ml{METIS} descritto +nella Sezione~\ref{sec:metisLib}. La regola d'inferenza \texttt{DECIDE} +(e la tattica corrispondente \texttt{DECIDE\_TAC}) applica una procedura di decisione che (al meno) gestisce enunciati dell'aritmetica lineare. \begin{hol} @@ -1515,40 +1515,40 @@ \subsection{Ragionatori Automatici} \end{verbatim} \end{hol} % -\index{RW_TAC@\ml{RW\_TAC}} La tattica di riscrittura \ml{RW\_TAC} lavora -prima aggiungendo i teoremi dati nel \simpset dato; poi -semplifica il goal quanto pi possibile; quindi esegue dei case split -sull'espressioni condizionali nel goal; poi ripetutamente (1) -elimina tutte le ipotesi della forma $v = M$ o $M = v$ dove $v$ -una variabile che non occorre in $M$, (2) rompe qualsiasi equazione tra -termini costruttore ovunque nel goal. Infine, -\ml{RW\_TAC} solleva le espressioni-\holtxt{let} all'interno del goal cos che -l'equazioni binding appaiono come -abbreviazioni\index{abbreviazioni!dimostrazione basata-su-tattche} nelle +\index{RW_TAC@\ml{RW\_TAC}} La tattica di riscrittura \ml{RW\_TAC} lavora +prima aggiungendo i teoremi dati nel \simpset dato; poi +semplifica il goal quanto pi possibile; quindi esegue dei case split +sull'espressioni condizionali nel goal; poi ripetutamente (1) +elimina tutte le ipotesi della forma $v = M$ o $M = v$ dove $v$ +una variabile che non occorre in $M$, (2) rompe qualsiasi equazione tra +termini costruttore ovunque nel goal. Infine, +\ml{RW\_TAC} solleva le espressioni-\holtxt{let} all'interno del goal cos che +l'equazioni binding appaiono come +abbreviazioni\index{abbreviazioni!dimostrazione basata-su-tattche} nelle assunzioni. -\index{SRW_TAC@\ml{SRW\_TAC}} La tattica \ml{SRW\_TAC} analoga a -\ml{RW\_TAC}, ma lavora rispetto a un \simpset{} sottostante -(accessibile attraverso la funzione \ml{srw\_ss}) che viene aggiornato ogni volta che viene caricato -un nuovo contesto. Questo \simpset{} pu essere aumentato attraverso -l'aggiornamento di ``frammenti \simpset{} '' (valori \ml{ssfrag}) e -teoremi. Nelle situazioni in cui ci sono grandi tipi archiviati nel -sistema, le performance di \ml{RW\_TAC} ne possono risentire perch -aggiunge ripetutamente tutti i teoremi di riscrittura per i tipi conosciuti in un -\simpset{} prima di attaccare il goal. Dall'altro lato, -\ml{SRW\_TAC} carica le riscritture nel \simpset{} al di sotto di -\ml{srw\_ss()} una volta sola, rendendo l'operazione pi veloce in questa +\index{SRW_TAC@\ml{SRW\_TAC}} La tattica \ml{SRW\_TAC} analoga a +\ml{RW\_TAC}, ma lavora rispetto a un \simpset{} sottostante +(accessibile attraverso la funzione \ml{srw\_ss}) che viene aggiornato ogni volta che viene caricato +un nuovo contesto. Questo \simpset{} pu essere aumentato attraverso +l'aggiornamento di ``frammenti \simpset{} '' (valori \ml{ssfrag}) e +teoremi. Nelle situazioni in cui ci sono grandi tipi archiviati nel +sistema, le performance di \ml{RW\_TAC} ne possono risentire perch +aggiunge ripetutamente tutti i teoremi di riscrittura per i tipi conosciuti in un +\simpset{} prima di attaccare il goal. Dall'altro lato, +\ml{SRW\_TAC} carica le riscritture nel \simpset{} al di sotto di +\ml{srw\_ss()} una volta sola, rendendo l'operazione pi veloce in questa situazione. -\ml{bossLib} fornisce un numero d'insiemi di semplificazione. Il -simpset per la logica pura, le somme, le coppie e il tipo \ml{option} -chiamato \ml{std\_ss}. Il simpset per l'aritmetica chiamato -\ml{arith\_ss}, e il simpset per le liste chiamato \ml{list\_ss}. -I simpset forniti da \bossLib{} aumentano strettamente di forza: -\ml{std\_ss} contenuto in \ml{arith\_ss}, e \ml{arith\_ss} -contenuto in \ml{list\_ss}. Il combinatore infisso \ml{\&\&} usato -per costruire un nuovo \simpset{} da un \simpset{} e una lista di -teoremi dati. La tecnologia di semplificazione di \HOL{} ulteriormente descritta nella +\ml{bossLib} fornisce un numero d'insiemi di semplificazione. Il +simpset per la logica pura, le somme, le coppie e il tipo \ml{option} +chiamato \ml{std\_ss}. Il simpset per l'aritmetica chiamato +\ml{arith\_ss}, e il simpset per le liste chiamato \ml{list\_ss}. +I simpset forniti da \bossLib{} aumentano strettamente di forza: +\ml{std\_ss} contenuto in \ml{arith\_ss}, e \ml{arith\_ss} +contenuto in \ml{list\_ss}. Il combinatore infisso \ml{\&\&} usato +per costruire un nuovo \simpset{} da un \simpset{} e una lista di +teoremi dati. La tecnologia di semplificazione di \HOL{} ulteriormente descritta nella Sezione~\ref{sec:simpLib} di sotto e nelle \REFERENCE. \begin{hol} @@ -1557,32 +1557,32 @@ \subsection{Ragionatori Automatici} SPOSE_NOT_THEN : (thm -> tactic) -> tactic \end{verbatim} \end{hol} -La funzione \ml{by} un operatore infisso che prende una quotation -e una tattica $tac$. La quotation parsata in un termine $M$. Quando -l'invocazione ``\ml{$M$ by $\mathit{tac}$}'' applicata a un goal -$(A,g)$, creato un nuovo subgoal $(A,M)$ e ad esso applicata la tattica $tac$. -Se il goal dimostrato, il teorema risultante de-costruito e aggiunto -alle assunzioni del goal originale; cos la dimostrazione procede con -il goal $((M::A), g)$. (Si noti tuttavia, che avverr uno split dei casi -se la de-costruzione di $\ \vdash M$ espone delle disgiunzioni.) Cos -\ml{by} permette di mischiare un utile stile di ragionamento `asserzionale' o `Mizar-like' -all'ordinaria dimostrazione basata sulle tattiche\footnote{Le dimostrazioni nel - sistema Mizar sono documenti leggibili, diversamente dalla maggior parte +La funzione \ml{by} un operatore infisso che prende una quotation +e una tattica $tac$. La quotation parsata in un termine $M$. Quando +l'invocazione ``\ml{$M$ by $\mathit{tac}$}'' applicata a un goal +$(A,g)$, creato un nuovo subgoal $(A,M)$ e ad esso applicata la tattica $tac$. +Se il goal dimostrato, il teorema risultante de-costruito e aggiunto +alle assunzioni del goal originale; cos la dimostrazione procede con +il goal $((M::A), g)$. (Si noti tuttavia, che avverr uno split dei casi +se la de-costruzione di $\ \vdash M$ espone delle disgiunzioni.) Cos +\ml{by} permette di mischiare un utile stile di ragionamento `asserzionale' o `Mizar-like' +all'ordinaria dimostrazione basata sulle tattiche\footnote{Le dimostrazioni nel + sistema Mizar sono documenti leggibili, diversamente dalla maggior parte delle dimostrazioni basate su tattiche.} -L'entry-point \ml{SPOSE\_NOT\_THEN} inizia una dimostrazione per -contraddizione assumendo la negazione del goal e spostando la -negazione all'interno dei quantificatori. Essa fornisce il teorema -risultante come un argomento della funzione fornite, che user il +L'entry-point \ml{SPOSE\_NOT\_THEN} inizia una dimostrazione per +contraddizione assumendo la negazione del goal e spostando la +negazione all'interno dei quantificatori. Essa fornisce il teorema +risultante come un argomento della funzione fornite, che user il teorema per costruire e applicare una tattica. \section{Dimostrazione al Primo Ordine---\texttt{mesonLib} e \texttt{metisLib}} \label{sec:first-order-proof} \index{procedure di decisione!logica del primo ordine} -La dimostrazione del primo ordine una potente tecnica di dimostrazione di teoremi che pu -sbrigare goal complicati. Diversamente da strumenti come il semplificatore, o -dimostra un goal completamente, o fallisce. Non pu trasformare un goal +La dimostrazione del primo ordine una potente tecnica di dimostrazione di teoremi che pu +sbrigare goal complicati. Diversamente da strumenti come il semplificatore, o +dimostra un goal completamente, o fallisce. Non pu trasformare un goal in una forma differente (e pi utile). \subsection{Model elimination---\texttt{mesonLib}} @@ -1591,8 +1591,8 @@ \subsection{Model elimination---\texttt{mesonLib}} \index{meson (model elimination) procedura@\ml{meson} (model elimination) procedura} \index{metodo model elimination per la logica del primo ordine} -La libreria \ml{meson} un'implementazione del -metodo model-elimination per trovare dimostrazioni di goal nella logica +La libreria \ml{meson} un'implementazione del +metodo model-elimination per trovare dimostrazioni di goal nella logica del primo ordine. Ci sono tre entry-point principali: \begin{hol} \begin{verbatim} @@ -1602,32 +1602,32 @@ \subsection{Model elimination---\texttt{mesonLib}} \end{verbatim} \end{hol} -Ciascuna di quest tattiche tenta di dimostrare il goal. Esse o avranno -successo nel fare questo, o falliranno con un eccezione ``depth exceeded''. Se -il fattore di ramificazione nello spazio di ricerca alto, le tattiche +Ciascuna di quest tattiche tenta di dimostrare il goal. Esse o avranno +successo nel fare questo, o falliranno con un eccezione ``depth exceeded''. Se +il fattore di ramificazione nello spazio di ricerca alto, le tattiche \texttt{meson} possono richiedere anche molto tempo per raggiungere la profondit massima. -Tutte le tattiche \texttt{meson} prendono una lista di teoremi. Questi +Tutte le tattiche \texttt{meson} prendono una lista di teoremi. Questi fatti extra sono usati dalla procedura di decisione per aiutare a dimostrare il goal. -\texttt{MESON\_TAC} ignora le assunzioni del goal; gli altri due -entry-point includono le assunzioni come pare del sequente da +\texttt{MESON\_TAC} ignora le assunzioni del goal; gli altri due +entry-point includono le assunzioni come pare del sequente da dimostrare. -I parametri extra a \ml{GEN\_MESON\_TAC} forniscono un controllo extra del -comportamento dell'aumentare iterativo della profondit che al centro della -ricerca per una dimostrazione. In ogni iterazione data, l'algoritmo ricerca -per una dimostrazione di profondit non pi alta di un parametro $d$. Il -comportamento di default per \ml{MESON\_TAC} e \ml{ASM\_MESON\_TAC} di iniziare $d$ -a 0, incrementarlo di uno ogni volta che una ricerca fallisce, e di fallire se -$d$ eccede il valore archiviato nel valore della reference -\ml{mesonLib.max\_depth}. Per contro, -\ml{GEN\_MESON\_TAC~min~max~step} inizia $d$ a \ml{min}, lo incrementa +I parametri extra a \ml{GEN\_MESON\_TAC} forniscono un controllo extra del +comportamento dell'aumentare iterativo della profondit che al centro della +ricerca per una dimostrazione. In ogni iterazione data, l'algoritmo ricerca +per una dimostrazione di profondit non pi alta di un parametro $d$. Il +comportamento di default per \ml{MESON\_TAC} e \ml{ASM\_MESON\_TAC} di iniziare $d$ +a 0, incrementarlo di uno ogni volta che una ricerca fallisce, e di fallire se +$d$ eccede il valore archiviato nel valore della reference +\ml{mesonLib.max\_depth}. Per contro, +\ml{GEN\_MESON\_TAC~min~max~step} inizia $d$ a \ml{min}, lo incrementa di \ml{step}, e rinuncia quando $d$ eccede \ml{max}. -La funzione \ml{PROVE\_TAC} da \ml{bossLib} esegue qualche -normalizzazione, prima di passare un goal e le sue assunzioni a -\ml{ASM\_MESON\_TAC}. A causa di questa normalizzazione, nella maggior parte -delle circostanze, si dovrebbe preferire \ml{PROVE\_TAC} +La funzione \ml{PROVE\_TAC} da \ml{bossLib} esegue qualche +normalizzazione, prima di passare un goal e le sue assunzioni a +\ml{ASM\_MESON\_TAC}. A causa di questa normalizzazione, nella maggior parte +delle circostanze, si dovrebbe preferire \ml{PROVE\_TAC} a \ml{ASM\_MESON\_TAC}. \subsection{Risoluzione---\texttt{metisLib}} @@ -1636,8 +1636,8 @@ \subsection{Risoluzione---\texttt{metisLib}} \index{procedura metis (risoluzione)@procedura \ml{metis} (risoluzione)} \index{metodo di risoluzione per la logica del primo ordine} -La libreria \ml{metis} un'implementazione del metodo di risoluzione -per trovare dimostrazioni di goal nella logica del primo ordine. Ci sono due +La libreria \ml{metis} un'implementazione del metodo di risoluzione +per trovare dimostrazioni di goal nella logica del primo ordine. Ci sono due entry-point principali: \begin{hol} @@ -1647,17 +1647,17 @@ \subsection{Risoluzione---\texttt{metisLib}} \end{verbatim} \end{hol} -Entrambe le funzioni prendono una lista di teoremi, e questi sono usati come lemmi -nella dimostrazione. \texttt{METIS\_TAC} una tattica, e o avr successo -nel dimostrare il goal, o se non ha successo o fallir o continuer a ciclare -all'infinito. \texttt{METIS\_PROVE} prende un termine $t$ e prova a dimostrare un -teorema con conclusione $t$: se ha successo, restituito il teorema -$\vdash t$. Come per \texttt{METIS\_TAC}, potrebbe fallire o ciclare all'infinito se +Entrambe le funzioni prendono una lista di teoremi, e questi sono usati come lemmi +nella dimostrazione. \texttt{METIS\_TAC} una tattica, e o avr successo +nel dimostrare il goal, o se non ha successo o fallir o continuer a ciclare +all'infinito. \texttt{METIS\_PROVE} prende un termine $t$ e prova a dimostrare un +teorema con conclusione $t$: se ha successo, restituito il teorema +$\vdash t$. Come per \texttt{METIS\_TAC}, potrebbe fallire o ciclare all'infinito se la ricerca della dimostrazione non ha successo. -La famiglia \texttt{metisLib} di strumenti di dimostrazione implementano la risoluzione -ordinata e il calcolo di paramodulazione ordinata per la logica del primo ordine, -che di solito li rende pi adatti a goal che richiedono ragionamenti di eguaglianza +La famiglia \texttt{metisLib} di strumenti di dimostrazione implementano la risoluzione +ordinata e il calcolo di paramodulazione ordinata per la logica del primo ordine, +che di solito li rende pi adatti a goal che richiedono ragionamenti di eguaglianza non banali rispetto alle tattiche in \texttt{mesonLib}. @@ -1665,29 +1665,29 @@ \section{Semplificazione---\texttt{simpLib}} \label{sec:simpLib} \index{semplificazione|(} -Il semplificatore il motore di riscrittura pi sofisticato in \HOL{}. E' -raccomandato come un cavallo di battaglia di scopo generale durante la dimostrazione di teoremi -interattiva. Come strumenti di riscrittura, il ruolo generale del semplificatore +Il semplificatore il motore di riscrittura pi sofisticato in \HOL{}. E' +raccomandato come un cavallo di battaglia di scopo generale durante la dimostrazione di teoremi +interattiva. Come strumenti di riscrittura, il ruolo generale del semplificatore di applicare teoremi della forma generale \[ \vdash l = r \] -a termini, rimpiazzando le istanze di $l$ nel termine con $r$. Cos, la -ruotine base di semplificazione una \emph{conversione}, che prende un termine -$t$, e restituisce un teorema $\vdash t = t'$, o l'eccezione +a termini, rimpiazzando le istanze di $l$ nel termine con $r$. Cos, la +ruotine base di semplificazione una \emph{conversione}, che prende un termine +$t$, e restituisce un teorema $\vdash t = t'$, o l'eccezione \ml{UNCHANGED}. -La conversione di base +La conversione di base \begin{hol} \begin{verbatim} simpLib.SIMP_CONV : simpLib.simpset -> thm list -> term -> thm \end{verbatim} \end{hol} -Il primo argomento, un \simpset, il modo standard di fornire una -collezione di regole di (e altri dati, che saranno spiegati di sotto) al -semplificatore. Ci sono dei \simpset{} che accompagnano le teorie principali +Il primo argomento, un \simpset, il modo standard di fornire una +collezione di regole di (e altri dati, che saranno spiegati di sotto) al +semplificatore. Ci sono dei \simpset{} che accompagnano le teorie principali di \HOL{}. Per esempio, il \simpset{} \ml{bool\_ss} -in \ml{boolSimps} incorpora tutti i teoremi di riscrittura usuali desiderabili su formule +in \ml{boolSimps} incorpora tutti i teoremi di riscrittura usuali desiderabili su formule booleane: \setcounter{sessioncount}{0} \begin{session} @@ -1696,8 +1696,8 @@ \section{Semplificazione---\texttt{simpLib}} > val it = |- p /\ T \/ ~(q /\ r) = p \/ ~q \/ ~r : thm \end{verbatim} \end{session} -Oltre alla riscrittura con i teoremi ovvi, \ml{bool\_ss} -anche capace di eseguire semplificazioni che non sono esprimibili come +Oltre alla riscrittura con i teoremi ovvi, \ml{bool\_ss} +anche capace di eseguire semplificazioni che non sono esprimibili come teoremi semplici: \begin{session} \begin{verbatim} @@ -1705,24 +1705,24 @@ \section{Semplificazione---\texttt{simpLib}} > val it = |- (?x. (\y. P (f y)) x /\ (x = z)) = P (f z) : thm \end{verbatim} \end{session} -In questo esempio, il semplificatore ha eseguito una $\beta$-riduzione nel -primo congiunto sotto il quantificatore esistenziale, e poi ha fatto una -riduzione ``unwinding'' o ``one-point'', riconoscendo che l'unico -valore possibile per la variabile quantificata \holtxt{x} era il valore +In questo esempio, il semplificatore ha eseguito una $\beta$-riduzione nel +primo congiunto sotto il quantificatore esistenziale, e poi ha fatto una +riduzione ``unwinding'' o ``one-point'', riconoscendo che l'unico +valore possibile per la variabile quantificata \holtxt{x} era il valore \holtxt{z}. -Il secondo argomento a \ml{SIMP\_CONV} una lista di teoremi da +Il secondo argomento a \ml{SIMP\_CONV} una lista di teoremi da aggiungere al \simpset fornito, e da aggiungere come regole di riscrittura addizionali. -In questo modo, gli utenti possono aumentare temporaneamente i \simpset{} con -le loro proprie riscritture. Se un particolare insieme di teoremi usato spesso come -un tale argomento, allora possibile costruire un valore \simpset{} per +In questo modo, gli utenti possono aumentare temporaneamente i \simpset{} con +le loro proprie riscritture. Se un particolare insieme di teoremi usato spesso come +un tale argomento, allora possibile costruire un valore \simpset{} per incorporare queste nuove riscritture. -Per esempio, la riscrittura \ml{arithmeticTheory.LEFT\_ADD\_DISTRIB}, che -afferma che $p(m + n) = pm + pn$, non fa parte di alcun \simpset{} standard -di \HOL{}. Questo perch pu causare un aumento poco attraente nella -dimensione del termine (ci sono due occorrenze di $p$ al lato destro -del teorema). Ci nonostante, chiaro che questo teorema pu pu +Per esempio, la riscrittura \ml{arithmeticTheory.LEFT\_ADD\_DISTRIB}, che +afferma che $p(m + n) = pm + pn$, non fa parte di alcun \simpset{} standard +di \HOL{}. Questo perch pu causare un aumento poco attraente nella +dimensione del termine (ci sono due occorrenze di $p$ al lato destro +del teorema). Ci nonostante, chiaro che questo teorema pu pu essere appropriato occasionalmente: \begin{session} \begin{verbatim} @@ -1730,9 +1730,9 @@ \section{Semplificazione---\texttt{simpLib}} > val it = |- p * (n + 1) = p + n * p : thm \end{verbatim} \end{session} -Si noti come il \simpset{} \ml{arith\_ss} non ha solamente semplificato il -termine intermedio \ml{(p * 1)}, ma ha anche riordinato l'addizione per -mettere il termine pi semplice sulla sinistra, e ordinato gli argomenti +Si noti come il \simpset{} \ml{arith\_ss} non ha solamente semplificato il +termine intermedio \ml{(p * 1)}, ma ha anche riordinato l'addizione per +mettere il termine pi semplice sulla sinistra, e ordinato gli argomenti della moltiplicazione. @@ -1740,26 +1740,26 @@ \subsection{Tattiche di semplificazione} \label{sec:simplification-tactics} \index{semplificazione!tattiche} -Il semplificatore implementato intorno alla conversione \ml{SIMP\_CONV}, -che una funzione per `convertire' i termini in teoremi. Per applicare -il semplificatore ai goal (alternativamente, per eseguire dimostrazioni basate su tattiche -con il semplificatore), \HOL{} fornisce cinque tattiche, ognuna delle quali +Il semplificatore implementato intorno alla conversione \ml{SIMP\_CONV}, +che una funzione per `convertire' i termini in teoremi. Per applicare +il semplificatore ai goal (alternativamente, per eseguire dimostrazioni basate su tattiche +con il semplificatore), \HOL{} fornisce cinque tattiche, ognuna delle quali disponibile in \ml{bossLib}. \subsubsection{\ml{SIMP\_TAC : simpset -> thm list -> tactic}} \index{SIMP_TAC@\ml{SIMP\_TAC}} -\ml{SIMP\_TAC} la tattica di semplificazione pi semplice: essa tenta di -semplificare il goal attuale (ignorando le assunzioni) usando il \simpset{} -dato e i teoremi aggiuntivi. Non niente di pi che il -sollevamento della sottostante conversione \ml{SIMP\_CONV} al livello +\ml{SIMP\_TAC} la tattica di semplificazione pi semplice: essa tenta di +semplificare il goal attuale (ignorando le assunzioni) usando il \simpset{} +dato e i teoremi aggiuntivi. Non niente di pi che il +sollevamento della sottostante conversione \ml{SIMP\_CONV} al livello di tattica attraverso l'uso della funzione standard \ml{CONV\_TAC}. \subsubsection{\ml{ASM\_SIMP\_TAC : simpset -> thm list -> tactic}} \index{ASM_SIMP_TAC@\ml{ASM\_SIMP\_TAC}} -Come \ml{SIMP\_TAC}, \ml{ASM\_SIMP\_TAC} semplifica il goal attuale -(lasciando le assunzioni intatte), ma include le assunzioni +Come \ml{SIMP\_TAC}, \ml{ASM\_SIMP\_TAC} semplifica il goal attuale +(lasciando le assunzioni intatte), ma include le assunzioni del goal come regole di riscrittura extra. Cos: \begin{session} \begin{verbatim} @@ -1781,33 +1781,33 @@ \subsubsection{\ml{ASM\_SIMP\_TAC : simpset -> thm list -> tactic}} \end{verbatim} \end{session} \noindent -In questo esempio, \ml{ASM\_SIMP\_TAC} ha usato \holtxt{x = 3} come una +In questo esempio, \ml{ASM\_SIMP\_TAC} ha usato \holtxt{x = 3} come una regola di riscrittura addizionale, e ha sostituito la \holtxt{x} di \holtxt{P x} -con \holtxt{3}. Quando un'assunzione usata da \ml{ASM\_SIMP\_TAC} essa - convertita in regole di riscrittura nello stesso modo dei teoremi passati nella -lista data come secondo argomento della tattica. Per esempio, +con \holtxt{3}. Quando un'assunzione usata da \ml{ASM\_SIMP\_TAC} essa + convertita in regole di riscrittura nello stesso modo dei teoremi passati nella +lista data come secondo argomento della tattica. Per esempio, un'assunzione \holtxt{\~{}P} sar trattata come la riscrittura \holtxt{|- P = F}. \subsubsection{\ml{FULL\_SIMP\_TAC : simpset -> thm list -> tactic}} \index{FULL_SIMP_TAC@\ml{FULL\_SIMP\_TAC}} \noindent -La tattica \ml{FULL\_SIMP\_TAC} semplifica non solo la conclusione di -un goal ma anche le sue assunzioni. Essa procede semplificando -ciascuna assunzione una alla volta, usando inoltre le assunzioni precedenti nella -semplificazione delle assunzioni successive. Dopo essere stata semplificata, ciascuna -assunzione ri-aggiunta alla lista di assunzioni del goal con la -tattica \ml{STRIP\_ASSUME\_TAC}. Questo significa che le assunzioni che -diventano congiunzioni avranno ciascuno dei congiunti assunti separatamente. -Le assunzioni che diventano disgiunzioni faranno s che un nuovo sotto goal sia -creato per ciascun disgiunto. Se un'assunzione semplificata a falso, +La tattica \ml{FULL\_SIMP\_TAC} semplifica non solo la conclusione di +un goal ma anche le sue assunzioni. Essa procede semplificando +ciascuna assunzione una alla volta, usando inoltre le assunzioni precedenti nella +semplificazione delle assunzioni successive. Dopo essere stata semplificata, ciascuna +assunzione ri-aggiunta alla lista di assunzioni del goal con la +tattica \ml{STRIP\_ASSUME\_TAC}. Questo significa che le assunzioni che +diventano congiunzioni avranno ciascuno dei congiunti assunti separatamente. +Le assunzioni che diventano disgiunzioni faranno s che un nuovo sotto goal sia +creato per ciascun disgiunto. Se un'assunzione semplificata a falso, questo risolver il goal. -\ml{FULL\_SIMP\_TAC} attacca le assunzioni nell'ordine in cui -appaiono nella lista dei termini che rappresentano le assunzioni -del goal. Tipicamente quindi, la prima assunzione da semplificare -sar l'assunzione aggiunta pi di recente. Vista alla luce della -stampa dei goal di \ml{goalstackLib}, \ml{FULL\_SIMP\_TAC} si fa +\ml{FULL\_SIMP\_TAC} attacca le assunzioni nell'ordine in cui +appaiono nella lista dei termini che rappresentano le assunzioni +del goal. Tipicamente quindi, la prima assunzione da semplificare +sar l'assunzione aggiunta pi di recente. Vista alla luce della +stampa dei goal di \ml{goalstackLib}, \ml{FULL\_SIMP\_TAC} si fa strada lungo l'elenco delle assunzioni, dal basso verso l'alto. La seguente sessione dimostra un uso semplice di \ml{FULL\_SIMP\_TAC}: @@ -1831,9 +1831,9 @@ \subsubsection{\ml{FULL\_SIMP\_TAC : simpset -> thm list -> tactic}} \end{verbatim} \end{session} In questo esempio, l'assunzione \holtxt{x = 4} ha fatto s che la \holtxt{x} -nell'assunzione \holtxt{f x < 10} sia stata rimpiazzata da \holtxt{4}. La -\holtxt{x} nel goal stata sostituita in modo analogo. Se le assunzioni fossero -apparse nell'ordine opposto, solo la \holtxt{x} del goal sarebbe +nell'assunzione \holtxt{f x < 10} sia stata rimpiazzata da \holtxt{4}. La +\holtxt{x} nel goal stata sostituita in modo analogo. Se le assunzioni fossero +apparse nell'ordine opposto, solo la \holtxt{x} del goal sarebbe cambiata. La prossima sessione dimostra un comportamento ancora pi interessante. @@ -1863,20 +1863,20 @@ \subsubsection{\ml{FULL\_SIMP\_TAC : simpset -> thm list -> tactic}} \[ \vdash x \leq y \equiv x < y \lor x = y \] -Sostituendo l'assunzione con una disgiunzione che risulta in due sotto goal. -Nel secondo di questi, l'assunzione \holtxt{x = 4} ha ulteriormente +Sostituendo l'assunzione con una disgiunzione che risulta in due sotto goal. +Nel secondo di questi, l'assunzione \holtxt{x = 4} ha ulteriormente semplificato il resto del goal. \subsubsection{\ml{RW\_TAC : simpset -> thm list -> tactic}} \index{RW_TAC@\ml{RW\_TAC}} -Nonostante il suo tipo sia lo stesso delle tattiche di semplificazioni gi -descritte, \ml{RW\_TAC} una tattica ``aumentata''. Essa aumentata in +Nonostante il suo tipo sia lo stesso delle tattiche di semplificazioni gi +descritte, \ml{RW\_TAC} una tattica ``aumentata''. Essa aumentata in due modi: \begin{itemize} -\item Quando si semplifica il goal, il \simpset{} fornito aumentato - non solo con i teoremi passati esplicitamente nel secondo argomento, - ma anche con tutte le regole di riscrittura dalla \ml{TypeBase}, e +\item Quando si semplifica il goal, il \simpset{} fornito aumentato + non solo con i teoremi passati esplicitamente nel secondo argomento, + ma anche con tutte le regole di riscrittura dalla \ml{TypeBase}, e anche con le assunzioni del goal. % \index{TypeBase@\ml{TypeBase}} @@ -1894,42 +1894,42 @@ \subsubsection{\ml{RW\_TAC : simpset -> thm list -> tactic}} \subsubsection{\ml{SRW\_TAC : ssfrag list -> thm list -> tactic}} \index{SRW_TAC@\ml{SRW\_TAC}} -La tattica \ml{SRW\_TAC} ha un tipo differente dalle altre -tattiche di semplificazione. Non prende un \simpset{} come un argomento. -Piuttosto la sua operazione si fonda sempre sul \simpset{} incorporato -\ml{srw\_ss()} (ulteriormente descritto nella Sezione~\ref{sec:srw_ss}). I -teoremi forniti come il secondo argomento di \ml{SRW\_TAC} sono trattati nello -stesso modo delle altre tattiche di semplificazione. Infine, la -lista dei frammenti \simpset{} sono incorporati nel \simpset{} -sottostante, permettendo all'utente di fondere capacit di semplificazione +La tattica \ml{SRW\_TAC} ha un tipo differente dalle altre +tattiche di semplificazione. Non prende un \simpset{} come un argomento. +Piuttosto la sua operazione si fonda sempre sul \simpset{} incorporato +\ml{srw\_ss()} (ulteriormente descritto nella Sezione~\ref{sec:srw_ss}). I +teoremi forniti come il secondo argomento di \ml{SRW\_TAC} sono trattati nello +stesso modo delle altre tattiche di semplificazione. Infine, la +lista dei frammenti \simpset{} sono incorporati nel \simpset{} +sottostante, permettendo all'utente di fondere capacit di semplificazione aggiuntive se lo desidera. -Per esempio, per includere la procedura di decisione Presburger, si potrebbe +Per esempio, per includere la procedura di decisione Presburger, si potrebbe scrivere \begin{hol} \begin{verbatim} SRW_TAC [ARITH_ss][] \end{verbatim} \end{hol} -I frammenti \Simpset{} sono descritti di sotto nella +I frammenti \Simpset{} sono descritti di sotto nella Sezione~\ref{sec:simpset-fragments}. -La tattica \ml{SRW\_TAC} esegue la stessa combinazione di semplificazione e -goal-splitting che fa \ml{RW\_TAC}. Le principali differenze tra le -due tattiche risiedono nel fatto che la seconda pu essere inefficiente quando -si lavora con una grande \ml{TypeBase}, e nel fatto che lavorare con -\ml{SRW\_TAC} risparmia dal dover costruire esplicitamente -dei \simpset{} che includano tutte le riscritture ``appropriate'' del contesto -attuale. Il secondo ``vantaggio'' basato sull'assunzione che -\ml{(srw\_ss())} non include mai riscritture inappropriate. La presenza -di riscritture non utilizzate non mai un problema: la presenza di riscritture che +La tattica \ml{SRW\_TAC} esegue la stessa combinazione di semplificazione e +goal-splitting che fa \ml{RW\_TAC}. Le principali differenze tra le +due tattiche risiedono nel fatto che la seconda pu essere inefficiente quando +si lavora con una grande \ml{TypeBase}, e nel fatto che lavorare con +\ml{SRW\_TAC} risparmia dal dover costruire esplicitamente +dei \simpset{} che includano tutte le riscritture ``appropriate'' del contesto +attuale. Il secondo ``vantaggio'' basato sull'assunzione che +\ml{(srw\_ss())} non include mai riscritture inappropriate. La presenza +di riscritture non utilizzate non mai un problema: la presenza di riscritture che fanno la cosa sbagliata pu essere causa di maggiore irritazione. \subsection{I \simpset{} standard} \label{sec:standard-simpsets} -\HOL{} fornito con un numero di \simpset{} standard. Ognuno di questi -accessibile dall'interno di \ml{bossLib}, bench alcuni si originano in altre +\HOL{} fornito con un numero di \simpset{} standard. Ognuno di questi +accessibile dall'interno di \ml{bossLib}, bench alcuni si originano in altre strutture. \subsubsection{\ml{pure\_ss} and \ml{bool\_ss}} @@ -1937,32 +1937,32 @@ \subsubsection{\ml{pure\_ss} and \ml{bool\_ss}} % \index{pure_ss@\ml{pure\_ss}} % -Il \simpset{} \ml{pure\_ss} (definito nella struttura \ml{pureSimps}) -non contiene del tutto teoremi di riscrittura, e gioca il ruolo di una tabula -rasa all'interno dello spazio dei \simpset{} possibili. Quando si costruisce un -\simpset{} completamente nuovo, \ml{pure\_ss} un punto di partenza possibile. -Il \simpset{} \ml{pure\_ss} ha solo due componenti: regole di congruenza -per specificare come traversare i termini. e una funzione che trasforma -i teoremi in regole di riscrittura. Le regole di congruenza sono ulteriormente descritte -nella Sezione~\ref{sec:advanced-simplifier}; la generazione di regole -di riscrittura da teoremi descritta nella +Il \simpset{} \ml{pure\_ss} (definito nella struttura \ml{pureSimps}) +non contiene del tutto teoremi di riscrittura, e gioca il ruolo di una tabula +rasa all'interno dello spazio dei \simpset{} possibili. Quando si costruisce un +\simpset{} completamente nuovo, \ml{pure\_ss} un punto di partenza possibile. +Il \simpset{} \ml{pure\_ss} ha solo due componenti: regole di congruenza +per specificare come traversare i termini. e una funzione che trasforma +i teoremi in regole di riscrittura. Le regole di congruenza sono ulteriormente descritte +nella Sezione~\ref{sec:advanced-simplifier}; la generazione di regole +di riscrittura da teoremi descritta nella Sezione~\ref{sec:simplifier-rewriting}. \index{bool_ss (insieme di semplificazione)@\ml{bool\_ss} (insieme di semplificazione)} % -Il \simpset{} \ml{bool\_ss} (definito nella struttura \ml{boolSimps}) -spesso usato quando altri \simpset{} potrebbero essere troppo. Esso contiene -regole di riscritture per i connettivi booleani, e poco altro. Esso -contiene tutti i teoremi di de~Morgan per spostare le negazioni tra i -connettivi (congiunzione, disgiunzione, implicazione e espressioni +Il \simpset{} \ml{bool\_ss} (definito nella struttura \ml{boolSimps}) +spesso usato quando altri \simpset{} potrebbero essere troppo. Esso contiene +regole di riscritture per i connettivi booleani, e poco altro. Esso +contiene tutti i teoremi di de~Morgan per spostare le negazioni tra i +connettivi (congiunzione, disgiunzione, implicazione e espressioni condizionali), incluse le regole dei quantificatori che hanno $\neg(\forall -x.\,P(x))$ e $\neg(\exists x.\,P (x))$ sui loro lati sinistri. Esso -contiene anche le regole che specificano il comportamento dei connettivi -quando le costanti \holtxt{T} e \holtxt{F} appaiono come loro +x.\,P(x))$ e $\neg(\exists x.\,P (x))$ sui loro lati sinistri. Esso +contiene anche le regole che specificano il comportamento dei connettivi +quando le costanti \holtxt{T} e \holtxt{F} appaiono come loro argomenti. (Una di queste regole \holtxt{|- T /\bs{} p = p}.) -Come nell'esempio di sopra, \ml{bool\_ss} esegue anche -delle $\beta$-riduzioni e svolgimenti di un solo punto. Questi ultimi trasformano termini +Come nell'esempio di sopra, \ml{bool\_ss} esegue anche +delle $\beta$-riduzioni e svolgimenti di un solo punto. Questi ultimi trasformano termini della forma \[ \exists x.\;P(x)\land\dots (x = e) \dots\land Q(x) \] @@ -1973,11 +1973,11 @@ \subsubsection{\ml{pure\_ss} and \ml{bool\_ss}} Analogamente, lo svolgimento trasformer $\forall x.\;(x = e) \Rightarrow P(x)$ in $P(e)$. -Infine, \ml{bool\_ss} include anche regole di congruenza che permettono -al semplificatore di fare delle assunzioni aggiuntive quando sono semplificate -implicazioni ed espressioni condizionali. Questa caratteristica spiegata -ulteriormente nella Sezione~\ref{sec:simplifier-rewriting} di sotto, ma pu essere -illustrata da qualche esempio (il primo dimostra anche lo svolgimento +Infine, \ml{bool\_ss} include anche regole di congruenza che permettono +al semplificatore di fare delle assunzioni aggiuntive quando sono semplificate +implicazioni ed espressioni condizionali. Questa caratteristica spiegata +ulteriormente nella Sezione~\ref{sec:simplifier-rewriting} di sotto, ma pu essere +illustrata da qualche esempio (il primo dimostra anche lo svolgimento sotto un quantificatore universale): \begin{session} \begin{verbatim} @@ -1994,8 +1994,8 @@ \subsubsection{\ml{std\_ss}} % \index{std_ss (insieme di semplificazione)@\ml{std\_ss} (insieme di semplificazione)} % -Il \simpset{} \ml{std\_ss} definito in \ml{bossLib}, e aggiunge -regole di riscrittura pertinenti ai tipi di somme, coppie, option e +Il \simpset{} \ml{std\_ss} definito in \ml{bossLib}, e aggiunge +regole di riscrittura pertinenti ai tipi di somme, coppie, option e numeri naturali a \ml{bool\_ss}. \begin{session} \begin{verbatim} @@ -2008,8 +2008,8 @@ \subsubsection{\ml{std\_ss}} \end{verbatim} \end{session} -Con i numeri naturali, il \simpset{} \ml{std\_ss} pu calcolare -con valori ground, e anche includere una suite di ``riscritture ovvie'' +Con i numeri naturali, il \simpset{} \ml{std\_ss} pu calcolare +con valori ground, e anche includere una suite di ``riscritture ovvie'' per formule che includono variabili. \begin{session} \begin{verbatim} @@ -2025,14 +2025,14 @@ \subsubsection{\ml{arith\_ss}} % \index{arith_ss (insieme di semplificazione)@\ml{arith\_ss} (insieme di semplificazione)} % -Il \simpset{} \ml{arith\_ss} (definito in \ml{bossLib}) estende -\ml{std\_ss} aggiungendo la capacit di decidere formule dell'aritmetica -Presburger, e per normalizzare espressioni aritmetiche (raccogliendo -coefficienti , e ri-ordinazione di addendi). La sottostante procedura di decisione -per i numeri naturali quella descritta nella +Il \simpset{} \ml{arith\_ss} (definito in \ml{bossLib}) estende +\ml{std\_ss} aggiungendo la capacit di decidere formule dell'aritmetica +Presburger, e per normalizzare espressioni aritmetiche (raccogliendo +coefficienti , e ri-ordinazione di addendi). La sottostante procedura di decisione +per i numeri naturali quella descritta nella Sezione~\ref{sec:numLib} di sotto. -Questi due aspetti del \simpset{} \ml{arith\_ss} sono dimostrati +Questi due aspetti del \simpset{} \ml{arith\_ss} sono dimostrati qui: \begin{session} \begin{verbatim} @@ -2043,8 +2043,8 @@ \subsubsection{\ml{arith\_ss}} > val it = |- 2 * x + y - x + y = x + 2 * y : thm \end{verbatim} \end{session} -Si noti che la sottrazione su numeri naturali funziona in modi che possono -sembrare non intuitivi. In particolare, la normalizzazione del coefficiente non pu +Si noti che la sottrazione su numeri naturali funziona in modi che possono +sembrare non intuitivi. In particolare, la normalizzazione del coefficiente non pu occorrere quando atteso prima: \begin{session} \begin{verbatim} @@ -2053,26 +2053,26 @@ \subsubsection{\ml{arith\_ss}} ! UNCHANGED \end{verbatim} \end{session} -Sui numeri naturali, l'espressione $2 x + y - z + y$ non -uguale a $2 x + 2 y - z$. In particolare, queste espressioni non sono +Sui numeri naturali, l'espressione $2 x + y - z + y$ non +uguale a $2 x + 2 y - z$. In particolare, queste espressioni non sono uguali quando $2x + y < z$. \subsubsection{\ml{list\_ss}} % \index{list_ss (insieme di semplificazione)@\ml{list\_ss} (insieme di semplificazione)} % -L'ultimo valore \simpset{} puro in \ml{bossLib}, \ml{list\_ss} aggiunge -teoremi di riscrittura circa il tipo delle liste a \ml{arith\_ss}. Queste -riscritture includono i fatti ovvi circa i costruttori del tipo lista -\holtxt{NIL} e \holtxt{CONS}, come il fatto che \holtxt{CONS} +L'ultimo valore \simpset{} puro in \ml{bossLib}, \ml{list\_ss} aggiunge +teoremi di riscrittura circa il tipo delle liste a \ml{arith\_ss}. Queste +riscritture includono i fatti ovvi circa i costruttori del tipo lista +\holtxt{NIL} e \holtxt{CONS}, come il fatto che \holtxt{CONS} iniettivo: \begin{hol} \begin{verbatim} (h1 :: t1 = h2 :: t2) = (h1 = h2) /\ (t1 = t2) \end{verbatim} \end{hol} -Opportunamente, \ml{list\_ss} include anche delle riscritture per le funzioni -definite per ricorsione primitiva sulle liste. Esempi includono +Opportunamente, \ml{list\_ss} include anche delle riscritture per le funzioni +definite per ricorsione primitiva sulle liste. Esempi includono \holtxt{MAP}, \holtxt{FILTER} e \holtxt{LENGTH}. Cos: \begin{session} \begin{verbatim} @@ -2086,11 +2086,11 @@ \subsubsection{\ml{list\_ss}} > val it = |- LENGTH (FILTER ODD [1; 2; 3; 4; 5]) = 3 : thm \end{verbatim} \end{session} -Questi esempi dimostrano come il semplificatore pu essere usato come un valutatore -simbolico di scopo generale per termini che assomigliano in grande misura a quelli -che appaiono in un linguaggio di programmazione funzionale. Si noti che -questa funzionalit fornita anche da \ml{computeLib} (si veda -la Sezione~\ref{sec:computeLib} di sotto); \ml{computeLib} pi +Questi esempi dimostrano come il semplificatore pu essere usato come un valutatore +simbolico di scopo generale per termini che assomigliano in grande misura a quelli +che appaiono in un linguaggio di programmazione funzionale. Si noti che +questa funzionalit fornita anche da \ml{computeLib} (si veda +la Sezione~\ref{sec:computeLib} di sotto); \ml{computeLib} pi efficiente, ma meno generale del semplificatore. Per esempio: \begin{session} \begin{verbatim} @@ -2105,21 +2105,21 @@ \subsubsection{Il \simpset{} ``stateful''---\ml{srw\_ss()}} \label{sec:srw_ss} \index{srw_ss (insieme di semplificazione)@\ml{srw\_ss} (insieme di semplificazione)} -L'ultimo \simpset{} esportato da \ml{bossLib} nascosto dietro una -funzione. Il valore \ml{srw\_ss} ha il tipo \ml{unit -> simpset}, cos -che si deve digitare \ml{srw\_ss()} per ottenere un valore \simpset{}. -Questo uso di un tipo funzione permette al \simpset{} sottostante di essere -archiviato in una reference \ML{}, e permette ad esso di essere aggiornato -dinamicamente. In questo modo, la trasparenza referenziale deliberatamente -spezzata. Tutti gli altri \simpset{} si comporteranno sempre in modo identico: -\ml{SIMP\_CONV~bool\_ss} la stessa routine di semplificazione ovunque +L'ultimo \simpset{} esportato da \ml{bossLib} nascosto dietro una +funzione. Il valore \ml{srw\_ss} ha il tipo \ml{unit -> simpset}, cos +che si deve digitare \ml{srw\_ss()} per ottenere un valore \simpset{}. +Questo uso di un tipo funzione permette al \simpset{} sottostante di essere +archiviato in una reference \ML{}, e permette ad esso di essere aggiornato +dinamicamente. In questo modo, la trasparenza referenziale deliberatamente +spezzata. Tutti gli altri \simpset{} si comporteranno sempre in modo identico: +\ml{SIMP\_CONV~bool\_ss} la stessa routine di semplificazione ovunque e ogni volta che chiamata. -Per contro, \ml{srw\_ss} progettata per essere aggiornata. Quando una teoria -caricata, quando un nuovo tipo definito. il valore dietro \ml{srw\_ss()} -cambia, e il comportamento di \ml{SIMP\_CONV} applicato a -\ml{(srw\_ss())} cambia con esso. La filosofia di sviluppo dietro -\ml{srw\_ss} che essa dovrebbe essere sempre una ragionevole prima scelta in +Per contro, \ml{srw\_ss} progettata per essere aggiornata. Quando una teoria +caricata, quando un nuovo tipo definito. il valore dietro \ml{srw\_ss()} +cambia, e il comportamento di \ml{SIMP\_CONV} applicato a +\ml{(srw\_ss())} cambia con esso. La filosofia di sviluppo dietro +\ml{srw\_ss} che essa dovrebbe essere sempre una ragionevole prima scelta in tutte le situazioni dove il semplificatore utilizzato. Questa versatilit illustrata nel seguente esempio: @@ -2151,10 +2151,10 @@ \subsubsection{Il \simpset{} ``stateful''---\ml{srw\_ss()}} BasicProvers.export_rewrites : string list -> unit \end{verbatim} \end{holboxed} -Le stringhe passate a \ml{export\_rewrites} sono i nomi di teoremi -nell'attuale segmento di teoria (quelli che saranno esportati quando -\ml{export\_theory} chiamata). Non solo questi teoremi sono aggiunti -al \simpset{} sottostante nella sessione attuale, ma essi saranno +Le stringhe passate a \ml{export\_rewrites} sono i nomi di teoremi +nell'attuale segmento di teoria (quelli che saranno esportati quando +\ml{export\_theory} chiamata). Non solo questi teoremi sono aggiunti +al \simpset{} sottostante nella sessione attuale, ma essi saranno aggiunti nelle sessioni future quando la teoria ricaricata. \begin{session} \begin{verbatim} @@ -2174,40 +2174,40 @@ \subsubsection{Il \simpset{} ``stateful''---\ml{srw\_ss()}} \end{verbatim} \end{session} -Come regola generale, \ml{(srw\_ss())} include tutte le ``riscritture ovvie'' -del suo contesto, cos come codice per fare calcoli standard -(come l'aritmetica esegita nell'esempio di sopra). Non -include procedure di decisione che possono esibire performance occasionalmente -povere, cos i frammenti \simpset{} che contengono queste procedure -dovrebbero essere aggiunte manualmente a quelle invocazioni di semplificazione che ne +Come regola generale, \ml{(srw\_ss())} include tutte le ``riscritture ovvie'' +del suo contesto, cos come codice per fare calcoli standard +(come l'aritmetica esegita nell'esempio di sopra). Non +include procedure di decisione che possono esibire performance occasionalmente +povere, cos i frammenti \simpset{} che contengono queste procedure +dovrebbero essere aggiunte manualmente a quelle invocazioni di semplificazione che ne hanno bisogno. \subsection{Frammenti \simpset{}} \label{sec:simpset-fragments} \index{semplificazione!frammenti simpset} -Il frammento \simpset{} il blocco base di costruzione usato per -costruire valori \simpset{}. C' una funzione base che +Il frammento \simpset{} il blocco base di costruzione usato per +costruire valori \simpset{}. C' una funzione base che esegue questa costruzione: \begin{hol} \begin{verbatim} op ++ : simpset * ssfrag -> simpset \end{verbatim} \end{hol} -dove \ml{++} un infisso. In generale, meglio costruire sopra -il \simpset{} \ml{pure\_ss} o uno dei sui discendenti al fine di -selezionare la funzione ``filtro'' di default per convertire teoremi in -regole di riscrittura. (Questo processo di filtro descritto di sotto nella +dove \ml{++} un infisso. In generale, meglio costruire sopra +il \simpset{} \ml{pure\_ss} o uno dei sui discendenti al fine di +selezionare la funzione ``filtro'' di default per convertire teoremi in +regole di riscrittura. (Questo processo di filtro descritto di sotto nella Sezione~\ref{sec:generating-rewrite-rules}.) -Per le teorie principali (o gruppi di esse), una collezione di -frammenti \simpset{} rilevanti si trova di solito nel modulo \ml{Simps}, -dove \ml{} il nome della teoria. Per esempio, i frammenti -\simpset{} per la teoria dei numeri naturali si trovano in +Per le teorie principali (o gruppi di esse), una collezione di +frammenti \simpset{} rilevanti si trova di solito nel modulo \ml{Simps}, +dove \ml{} il nome della teoria. Per esempio, i frammenti +\simpset{} per la teoria dei numeri naturali si trovano in \ml{numSimps}, e i frammenti per le liste si trovano in \ml{listSimps}. -Alcuni frammenti \simpset{} standard della distribuzione sono descritti -nella Tabella~\ref{table:ssfrags}. Questi ed altri frammenti \simpset{} +Alcuni frammenti \simpset{} standard della distribuzione sono descritti +nella Tabella~\ref{table:ssfrags}. Questi ed altri frammenti \simpset{} sono descritti in maggior dettaglio nelle \REFERENCE. \begin{table}[htbp] @@ -2216,17 +2216,17 @@ \subsection{Frammenti \simpset{}} \begin{tabular}{lp{0.65\textwidth}} \ml{BOOL\_ss} & Riscritture standard per gli operatori booleani -(congiunzione, negazione \&c), cos come una conversione per eseguire +(congiunzione, negazione \&c), cos come una conversione per eseguire $\beta$-riduzioni. (In \ml{boolSimps}.) \\ \ml{CONG\_ss} & Regole di congruenza per l'implicazione e le espressioni condizionali. (In \ml{boolSimps}.) \\ \ml{ARITH\_ss} & -La procedura di decisione sui numeri naturali +La procedura di decisione sui numeri naturali per l'aritmetica universale Presburger. (In \ml{numSimps}.) \\ -\ml{PRED\_SET\_AC\_ss} & Normalizzazione-AC per unioni e intersezioni +\ml{PRED\_SET\_AC\_ss} & Normalizzazione-AC per unioni e intersezioni su insiemi. (In \ml{pred\_setSimps}.) \end{tabular} \end{center} @@ -2234,7 +2234,7 @@ \subsection{Frammenti \simpset{}} \label{table:ssfrags} \end{table} -I frammenti \simpset{} in definitiva sono costruiti con il costruttore +I frammenti \simpset{} in definitiva sono costruiti con il costruttore \ml{SSFRAG}: \begin{hol} \begin{verbatim} @@ -2249,9 +2249,9 @@ \subsection{Frammenti \simpset{}} } -> ssfrag \end{verbatim} \end{hol} -Una descrizione completa per i vari campi del record passato a -\ml{SSFRAG}, e il loro significato dato in \REFERENCE. La -funzione \ml{rewrites} fornisce una strada semplice per costruire un +Una descrizione completa per i vari campi del record passato a +\ml{SSFRAG}, e il loro significato dato in \REFERENCE. La +funzione \ml{rewrites} fornisce una strada semplice per costruire un frammento che include solo una lista di riscritture: \begin{hol} \begin{verbatim} @@ -2262,7 +2262,7 @@ \subsection{Frammenti \simpset{}} \subsection{Riscrittura con il semplificatore} \label{sec:simplifier-rewriting} -La riscrittura l'``operazione core'' del semplificatore. Questa sezione +La riscrittura l'``operazione core'' del semplificatore. Questa sezione descrive l'azione di riscrittura in maggior dettaglio. @@ -2272,136 +2272,136 @@ \subsubsection{Riscrittura di base} Data una regola di riscrittura della forma \[ \vdash \ell = r \] -il semplificatore eseguir una scansione dall'alto verso il basso del termine di input $t$, -cercando per dei \emph{match}~(si veda la Sezione~\ref{sec:simp-homatch} di sotto) -di $\ell$ all'interno di $t$. Questo match occorrer in un sotto termine di $t$ -(chiamiamolo $t_0$) e restituir un'istanziazione. Quando questa -istanziazione applicata alla regola di riscrittura, il risultato sar una nuova +il semplificatore eseguir una scansione dall'alto verso il basso del termine di input $t$, +cercando per dei \emph{match}~(si veda la Sezione~\ref{sec:simp-homatch} di sotto) +di $\ell$ all'interno di $t$. Questo match occorrer in un sotto termine di $t$ +(chiamiamolo $t_0$) e restituir un'istanziazione. Quando questa +istanziazione applicata alla regola di riscrittura, il risultato sar una nuova equazione della forma \[ \vdash t_0 = r' \] -Poich il sistema a quel punto ha un teorema che esprime un'equivalenza per +Poich il sistema a quel punto ha un teorema che esprime un'equivalenza per $t_0$ pu creare la nuova equazione \[ \vdash \underbrace{(\dots t_0\dots)}_t = (\dots r' \dots) \] -L'attraversamento del termine da semplificare ripetuto fino a quando non si trova -alcun match ulteriore per le regole di riscrittura del semplificatore. La +L'attraversamento del termine da semplificare ripetuto fino a quando non si trova +alcun match ulteriore per le regole di riscrittura del semplificatore. La strategia di attraversamento \begin{enumerate} \item \label{enum:simp-traverse-toplevel}% - Mentre c' un qualsiasi match per le regole di riscrittura archiviate a questo livello, - si continui ad applicarle. \emph{Non} si pu fare affidamento sull'ordine in cui le regole - di riscrittura sono applicate, eccetto quando un \simpset{} - include due riscritture con esattamente gli stessi lati sinistri. la - riscrittura aggiunta per ultima sar quella preferita per match. (Questo permette una - certa misura di overloading della riscrittura nella costruzione dei + Mentre c' un qualsiasi match per le regole di riscrittura archiviate a questo livello, + si continui ad applicarle. \emph{Non} si pu fare affidamento sull'ordine in cui le regole + di riscrittura sono applicate, eccetto quando un \simpset{} + include due riscritture con esattamente gli stessi lati sinistri. la + riscrittura aggiunta per ultima sar quella preferita per match. (Questo permette una + certa misura di overloading della riscrittura nella costruzione dei \simpset{}.) %% may not wish to own up to above detail \item \label{enum:simp-traverse-recurse}% - Eseguire una ricorsione sui sotto termini del termine. Il modo in cui i termini sono - attraversati a questo passo pu essere controllato da \emph{regole di - congruenza}~(una caratteristica avanzata, si veda la Sezione~\ref{sec:simp-congruences} + Eseguire una ricorsione sui sotto termini del termine. Il modo in cui i termini sono + attraversati a questo passo pu essere controllato da \emph{regole di + congruenza}~(una caratteristica avanzata, si veda la Sezione~\ref{sec:simp-congruences} di sotto) -\item Se il passo~\ref{enum:simp-traverse-recurse} ha cambiato il termine - completamente, si provi un'altra fase di riscrittura a questo livello. Se questo fallisce, - o se non c' stato alcun cambiamento dall'attraversamento dei sotto-termin, si provi - qualsiasi procedura di decisione incorporata (si veda - la Sezione~\ref{sec:simp-embedding-code}). Se la fase di riscrittura o - qualsiasi delle procedure di decisione ha alterato il termine, ri ritorni al +\item Se il passo~\ref{enum:simp-traverse-recurse} ha cambiato il termine + completamente, si provi un'altra fase di riscrittura a questo livello. Se questo fallisce, + o se non c' stato alcun cambiamento dall'attraversamento dei sotto-termin, si provi + qualsiasi procedura di decisione incorporata (si veda + la Sezione~\ref{sec:simp-embedding-code}). Se la fase di riscrittura o + qualsiasi delle procedure di decisione ha alterato il termine, ri ritorni al passo~\ref{enum:simp-traverse-toplevel}. Altrimenti di termini. \end{enumerate} \subsubsection{Riscrittura condizionale} \index{semplificazione!riscrittura condizionale} -La descrizione di sopra una leggera semplificazione dello stato reale delle -cose. Una caratteristica particolarmente potente del semplificatore che -essa realmente usa regole di riscrittura \emph{condizionali}. Questi sono teoremi +La descrizione di sopra una leggera semplificazione dello stato reale delle +cose. Una caratteristica particolarmente potente del semplificatore che +essa realmente usa regole di riscrittura \emph{condizionali}. Questi sono teoremi della forma \[ \vdash P \Rightarrow (\ell = r) \] -Quando il semplificatore trova un match per il termine $\ell$ durante il suo attraversamento -del termine, tenta di scaricare la condizione $P$. Se il -semplificatore pu semplificare il termine $P$ a vero, allora l'istanza di -$\ell$ nel termine attraversato pu essereo sostituito dall'appropriata +Quando il semplificatore trova un match per il termine $\ell$ durante il suo attraversamento +del termine, tenta di scaricare la condizione $P$. Se il +semplificatore pu semplificare il termine $P$ a vero, allora l'istanza di +$\ell$ nel termine attraversato pu essereo sostituito dall'appropriata istanziazione di $r$. -Quando si semplifica $P$ (un termine che non necessariamente nemmeno occorre -nell'originale), il semplificatore si pu trovare ad applicare un'altra -regola di riscrittura condizionale. Per fermare eccessive applicazioni -ricorsive, il semplificatore tiene traccia di uno stack di tutte le -condizioni collaterali su cui sta lavorando. Il semplificatore smette la dimostrazione -su una condizione collaterale se nota una ripetizione in questo stack. -C' anche una variabile accessibile dall'utente, \ml{Cond\_rewr.stack\_limit} -che specifica la dimensione massima dello stack che il semplificatore pu +Quando si semplifica $P$ (un termine che non necessariamente nemmeno occorre +nell'originale), il semplificatore si pu trovare ad applicare un'altra +regola di riscrittura condizionale. Per fermare eccessive applicazioni +ricorsive, il semplificatore tiene traccia di uno stack di tutte le +condizioni collaterali su cui sta lavorando. Il semplificatore smette la dimostrazione +su una condizione collaterale se nota una ripetizione in questo stack. +C' anche una variabile accessibile dall'utente, \ml{Cond\_rewr.stack\_limit} +che specifica la dimensione massima dello stack che il semplificatore pu di usare. -Le riscritture condizionali possono essere estremamente utili. Per esempio, i teoremi -circa la divisione e il modulo sono spesso accompagnate da condizioni -che richiedono che il divisore non sia zero. Il semplificatore pu spesso -scaricare queste, in particolare se include una procedura di decisione -aritmetica. Per esempio, il teorema \ml{MOD\_MOD} dalla teoria +Le riscritture condizionali possono essere estremamente utili. Per esempio, i teoremi +circa la divisione e il modulo sono spesso accompagnate da condizioni +che richiedono che il divisore non sia zero. Il semplificatore pu spesso +scaricare queste, in particolare se include una procedura di decisione +aritmetica. Per esempio, il teorema \ml{MOD\_MOD} dalla teoria \ml{arithmetic} afferma \[ \vdash 0 < n \;\Rightarrow \; (k\,\textsf{MOD}\,n)\,\textsf{MOD}\,n = k \,\textsf{MOD}\,n \] -Il semplificatore (in modo specifico, \ml{SIMP\_CONV~arith\_ss~[MOD\_MOD]}) -pu usare questo teorema per semplificare il termine -\holtxt{(k~MOD~(x~+~1))~MOD~(x~+~1)}: la procedura di decisione +Il semplificatore (in modo specifico, \ml{SIMP\_CONV~arith\_ss~[MOD\_MOD]}) +pu usare questo teorema per semplificare il termine +\holtxt{(k~MOD~(x~+~1))~MOD~(x~+~1)}: la procedura di decisione aritmetica pu dimostrare che \holtxt{0 < x + 1}, giustificando la riscrittura. -Bench le regole riscrittura condizionali siano potenti, non ogni teorema della -forma descritta di sopra una scelta appropriata. Una riscrittura scelta male -pu causare un considerevole degrado delle performance del semplificatore, dal momento -che perde tempo nel tentare di dimostrare condizioni collaterali impossibili. Per -esempio, il semplificatore non molto bravo a trovare testimoni +Bench le regole riscrittura condizionali siano potenti, non ogni teorema della +forma descritta di sopra una scelta appropriata. Una riscrittura scelta male +pu causare un considerevole degrado delle performance del semplificatore, dal momento +che perde tempo nel tentare di dimostrare condizioni collaterali impossibili. Per +esempio, il semplificatore non molto bravo a trovare testimoni esistenziali. Questo significa che la riscrittura condizionale \[ \vdash x < y \land y < z \Rightarrow (x < z = \top) \] -non funzioner come si potrebbe sperare. In generale, il semplificatore non un -buon strumento per eseguire ragionamenti di transitivit. (Si provi invece uno strumento +non funzioner come si potrebbe sperare. In generale, il semplificatore non un +buon strumento per eseguire ragionamenti di transitivit. (Si provi invece uno strumento al primo ordine come \ml{PROVE\_TAC}) \subsubsection{Generare regole di riscrittura per i teoremi} \label{sec:generating-rewrite-rules} \index{teoremi equazionali, nella logica HOL@teoremi equazionali, nella logica \HOL{}!uso dei ... nel semplificatore} -Ci sono due strade per cui un teorema per la riscrittura pu essere passato al -semplificatore: o come un argomento esplicito a una delle funzioni -\ML{} (\ml{SIMP\_CONV}, \ml{ASM\_SIMP\_TAC} ecc) che prendono liste di -teoremi come argomenti, o includendoli in un frammento \simpset{} -che incorporato in un \simpset. In entrambi i casi, questi teoremi sono -trasformati prima di essere usati. Le trasformazioni applicate sono +Ci sono due strade per cui un teorema per la riscrittura pu essere passato al +semplificatore: o come un argomento esplicito a una delle funzioni +\ML{} (\ml{SIMP\_CONV}, \ml{ASM\_SIMP\_TAC} ecc) che prendono liste di +teoremi come argomenti, o includendoli in un frammento \simpset{} +che incorporato in un \simpset. In entrambi i casi, questi teoremi sono +trasformati prima di essere usati. Le trasformazioni applicate sono progettate per rendere l'uso interattivo quanto pi conveniente possibile. -In particolare, non necessario passare al semplificatore teoremi +In particolare, non necessario passare al semplificatore teoremi che sono esattamente della forma \[ \vdash P \Rightarrow (\ell = r) \] -Piuttosto, il semplificatore trasformer i suoi teoremi di input per estrarre -le riscritture di questa stessa forma. L'esatta trasformazione eseguita -dipendente dal \simpset{} utilizzato: ciascun \simpset{} contiene la sua -propriat funzione ``filtro'' che applicata ai teoremi che sono aggiunti ad -esso. La maggior parte dei \simpset{} usano la funzione filtro dal \simpset{} -\ml{pure\_ss} (si veda la Sezione~\ref{sec:purebool-ss}). Tuttavia, quando un -frammento \simpset{} aggiunto a un simpset completo, il frammento pu -specificare un componente filtro addizionale. Se specificata, questa funzione - di tipo \ml{controlled\_thm~->~controlled\_thm~list}, ed applicata +Piuttosto, il semplificatore trasformer i suoi teoremi di input per estrarre +le riscritture di questa stessa forma. L'esatta trasformazione eseguita +dipendente dal \simpset{} utilizzato: ciascun \simpset{} contiene la sua +propriat funzione ``filtro'' che applicata ai teoremi che sono aggiunti ad +esso. La maggior parte dei \simpset{} usano la funzione filtro dal \simpset{} +\ml{pure\_ss} (si veda la Sezione~\ref{sec:purebool-ss}). Tuttavia, quando un +frammento \simpset{} aggiunto a un simpset completo, il frammento pu +specificare un componente filtro addizionale. Se specificata, questa funzione + di tipo \ml{controlled\_thm~->~controlled\_thm~list}, ed applicata ad ognuno dei teoremi prodotti dal filtro del \simpset{} esistente. % \index{semplificazione!garantire la terminazione} -(Un teorema ``controllato'' uno che accompagnato da un pezzo di -dati di ``controllo'' che esprimono il limite (se ne esiste uno) sul numero di volte -che pu essere applicato. Si veda la Sezione~\ref{sec:simp-special-rewrite-forms} -per come gli utenti possono introdurre questi limiti. Il tipo di ``controllo'' +(Un teorema ``controllato'' uno che accompagnato da un pezzo di +dati di ``controllo'' che esprimono il limite (se ne esiste uno) sul numero di volte +che pu essere applicato. Si veda la Sezione~\ref{sec:simp-special-rewrite-forms} +per come gli utenti possono introdurre questi limiti. Il tipo di ``controllo'' appare nel modulo \ML{} \ml{BoundedRewrites}.) -Il filtro che produce riscritture in \ml{pure\_ss} elimina -le congiunzioni, le implicazioni e le quantificazioni universali fino a quando o ha -un teorema di eguaglianza, o qualche altra forma booleana. Per esempio, +Il filtro che produce riscritture in \ml{pure\_ss} elimina +le congiunzioni, le implicazioni e le quantificazioni universali fino a quando o ha +un teorema di eguaglianza, o qualche altra forma booleana. Per esempio, il teorema \ml{ADD\_MODULUS} afferma \[ \vdash @@ -2419,8 +2419,8 @@ \subsubsection{Generare regole di riscrittura per i teoremi} \end{array} \] -Se guardando a un'eguaglianza dove ci sono delle variabili sul -lato destro che non occorrono sul lato sinistro, il +Se guardando a un'eguaglianza dove ci sono delle variabili sul +lato destro che non occorrono sul lato sinistro, il semplificatore trasforma questo nella regola \[ \vdash (\ell = r) = \top \] @@ -2431,8 +2431,8 @@ \subsubsection{Generare regole di riscrittura per i teoremi} \vdash P = \top \] -Infine, se guardando a un'eguaglianza il cui lato sinistro esso stesso -un'eguaglianza, e dove il lato destro non a sua volta un'eguaglianza, +Infine, se guardando a un'eguaglianza il cui lato sinistro esso stesso +un'eguaglianza, e dove il lato destro non a sua volta un'eguaglianza, il semplificatore trasforma $(x = y) = P$ nelle due regole \[ \begin{array}{l} @@ -2440,54 +2440,54 @@ \subsubsection{Generare regole di riscrittura per i teoremi} \vdash (y = x) = P \end{array} \] -Questo generalmente utile. Per esempio, un teorema come +Questo generalmente utile. Per esempio, un teorema come \[ \vdash \neg(\textsf{SUC}\,n = 0) \] -far s che il semplificatore riscriva entrambi $(\textsf{SUC}\,n = 0)$ e +far s che il semplificatore riscriva entrambi $(\textsf{SUC}\,n = 0)$ e $(0 = \textsf{SUC}\,n)$ a falso. -La restrizione che il lato destro di una tale regola non sia esso stesso +La restrizione che il lato destro di una tale regola non sia esso stesso un'eguaglianza una semplifice euristica che previene alcune forme di looping. \subsubsection{Regole di riscrittura di matching} \label{sec:simp-homatch} -Dato un teorema di riscrittura $\vdash \ell = r$, il primo passo di -esecuzione di una riscrittura determinare se $\ell$ pu o meno essere -istanziata cos da renderla uguale al termine che -riscritto. Questo processo conosciuto come matching. Per esempio, se $\ell$ - il termine $\textsf{SUC}(n)$, allora farne il matching verso il termine +Dato un teorema di riscrittura $\vdash \ell = r$, il primo passo di +esecuzione di una riscrittura determinare se $\ell$ pu o meno essere +istanziata cos da renderla uguale al termine che +riscritto. Questo processo conosciuto come matching. Per esempio, se $\ell$ + il termine $\textsf{SUC}(n)$, allora farne il matching verso il termine $\textsf{SUC}(3)$ avr successo, e trover l'istanziazione $n\mapsto -3$. Contrariamente all'unificazione, il matching non simmetrico: un +3$. Contrariamente all'unificazione, il matching non simmetrico: un pattern $\textsf{SUC}(3)$ non matcher il termine $\textsf{SUC}(n)$. -\index{matching di ordine superiore} \index{matching!di ordine superiore} Il semplificatore -usa una speciale forma di matching di ordine superiore. Se un pattern -include una variabile di qualche tipo funzione (diciamo $f$), e quella variabile - applicata a un argomento $a$ che non include alcuna variabile eccetto quelle -che sono legate da un'atrazione ad uno spopo pi alto. allora il termine -combinato $f(a)$ matcher qualsiasi termine del tipo appropriato fino a quando le -sole occorrenze delle variabili legate in $a$ sono in sotto-termini +\index{matching di ordine superiore} \index{matching!di ordine superiore} Il semplificatore +usa una speciale forma di matching di ordine superiore. Se un pattern +include una variabile di qualche tipo funzione (diciamo $f$), e quella variabile + applicata a un argomento $a$ che non include alcuna variabile eccetto quelle +che sono legate da un'atrazione ad uno spopo pi alto. allora il termine +combinato $f(a)$ matcher qualsiasi termine del tipo appropriato fino a quando le +sole occorrenze delle variabili legate in $a$ sono in sotto-termini che matchano $a$. -Assumiamo per i seguenti esempi che la variabile $x$ sia legata a uno -scopo pi alto. Allora, se $f(x)$ deve matchare $x + 4$, la variabile $f$ -sar istanziata a $(\lambda x.\; x + 4)$. Se $f(x)$ deve matchare -$3 + z$, allora $f$ sar istanziata a $(\lambda x.\;3 + z)$. +Assumiamo per i seguenti esempi che la variabile $x$ sia legata a uno +scopo pi alto. Allora, se $f(x)$ deve matchare $x + 4$, la variabile $f$ +sar istanziata a $(\lambda x.\; x + 4)$. Se $f(x)$ deve matchare +$3 + z$, allora $f$ sar istanziata a $(\lambda x.\;3 + z)$. Inoltre $f(x + 1)$ matcha $x + 1 < 7$, ma non matcha $x + 2 < 7$. -Un matching di ordine superiore di questo genere rende pi facile esprimere i risultati -dei movimenti dei quantificatori come regole di riscrittura, e avere queste regole applicate dal +Un matching di ordine superiore di questo genere rende pi facile esprimere i risultati +dei movimenti dei quantificatori come regole di riscrittura, e avere queste regole applicate dal semplificatore. Per esempio, il teorema \[ \vdash (\exists x. \;P(x)\lor Q(x)) = (\exists x.\;P(x)) \lor (\exists x.\;Q(x)) \] -ha due variabili di un tipo funzione ($P$ e $Q$), ed entrambe sono -applicate alla variabile legata $x$. Questo significa che quando applicato +ha due variabili di un tipo funzione ($P$ e $Q$), ed entrambe sono +applicate alla variabile legata $x$. Questo significa che quando applicato all'input \[ \exists z. \;z < 4 \lor z + x = 5 * z \] @@ -2498,7 +2498,7 @@ \subsubsection{Regole di riscrittura di matching} \end{array} \] -Eseguendo questa istanziazione, e poi facendo qualche $\beta$-riduzione +Eseguendo questa istanziazione, e poi facendo qualche $\beta$-riduzione sulla regola di riscrittura, si produce il teorema \[ \vdash (\exists z. \;z < 4 \lor z + x = 5 * z) = (\exists z. \;z < 4) \lor (\exists z.\;z + x = 5 * z) @@ -2509,14 +2509,14 @@ \subsubsection{Regole di riscrittura di matching} \[ \vdash f \circ (\lambda x.\; g(x)) = (\lambda x.\;f(g(x))) \] -La presenza dell'astrazione sul lato sinistro della regola -richiede che un'astrazione appaia nel termine da matchare, cos questa -regola pu essere vista come un'implementazione di un metodo per muovere le astrazioni +La presenza dell'astrazione sul lato sinistro della regola +richiede che un'astrazione appaia nel termine da matchare, cos questa +regola pu essere vista come un'implementazione di un metodo per muovere le astrazioni al di sopra delle composizioni di funzione. -Un esempio di un possibile lato sinistro che \emph{non} matchare come -in generale si potrebbe desiderare $(\exists x.\;P(x + y))$. Questo -perch il predicato $P$ applicato a un argomento che include la +Un esempio di un possibile lato sinistro che \emph{non} matchare come +in generale si potrebbe desiderare $(\exists x.\;P(x + y))$. Questo +perch il predicato $P$ applicato a un argomento che include la variabile libera $y$. \subsection{Caratteristiche avanzate} @@ -2529,11 +2529,11 @@ \subsubsection{Regole di congruenza} \index{semplificazione!regole di congruenza} \index{regole di congruenza!nella semplificazione} Le regole di congruenza controllano il modo in cui il semplificatore traversa un termine. -Esse forniscono anche un meccanismo per mezzo del quale possono essere -aggiunte al contesto del semplificatore assunzioni aggiuntive, che rappresentano informazione circa il -contesto contenitore. Le regole di congruenza pi semplici sono incorporate nel -simpset \ml{pure\_ss}. Esse specificano come traversare termini applicazione e -astrazione. A questo livello fondamentale, queste regole di congruenza +Esse forniscono anche un meccanismo per mezzo del quale possono essere +aggiunte al contesto del semplificatore assunzioni aggiuntive, che rappresentano informazione circa il +contesto contenitore. Le regole di congruenza pi semplici sono incorporate nel +simpset \ml{pure\_ss}. Esse specificano come traversare termini applicazione e +astrazione. A questo livello fondamentale, queste regole di congruenza sono poco di pi che le regole d'inferenza \ml{ABS} \[ \frac{\Gamma \turn t_1 = t_2} @@ -2544,21 +2544,21 @@ \subsubsection{Regole di congruenza} \frac{\Gamma \turn f = g \qquad \qquad \Delta \turn x = y} {\Gamma \cup \Delta \turn f(x) = g(y)} \] -Quando si specifica l'azione del semplificatore, queste regole dovrebbero essere -lette verso l'alto. Con \ml{ABS}, per esempio, la regola dice ``quando -si semplifica un'astrazione, si semplifichi il corpo $t_1$ a qualche nuovo $t_2$, -e poi il risultato formato ri-astraendo con la variabile +Quando si specifica l'azione del semplificatore, queste regole dovrebbero essere +lette verso l'alto. Con \ml{ABS}, per esempio, la regola dice ``quando +si semplifica un'astrazione, si semplifichi il corpo $t_1$ a qualche nuovo $t_2$, +e poi il risultato formato ri-astraendo con la variabile legata~$x$.'' -Ulteriori regole di congruenza dovrebbero essere aggiunte al semplificatore nella forma -di teoremi, attraverso il campo \ml{congs} dei record passati al +Ulteriori regole di congruenza dovrebbero essere aggiunte al semplificatore nella forma +di teoremi, attraverso il campo \ml{congs} dei record passati al costruttore \ml{SSFRAG}. Tali regole di congruenza dovrebbero essere della forma \[ \mathit{cond_1} \Rightarrow \mathit{cond_2} \Rightarrow \dots (E_1 = E_2) \] -dove $E_1$ la forma da riscrivere. Ciascun $\mathit{cond}_i$ pu -essere o una formula booleana arbitraria (nel qual caso trattata come +dove $E_1$ la forma da riscrivere. Ciascun $\mathit{cond}_i$ pu +essere o una formula booleana arbitraria (nel qual caso trattata come una condizione collaterale da scaricare) o un'equazione della forma generale \[ \forall \vec{v}. \;\mathit{ctxt}_1 \Rightarrow \mathit{ctxt}_2 @@ -2575,21 +2575,21 @@ \subsubsection{Regole di congruenza} \vdash (\forall x. \;f (x) = g (x)) \Rightarrow (\lambda x. \;f(x)) = (\lambda x.\;g(x)) \] -La forma per \ml{ABS} dimostra come possibile per le regole -di congruenza gestire variabili legate. Dal momento che le regole di congruenza sono -matchate con il match di ordine superiore della Sezione~\ref{sec:simp-homatch}, +La forma per \ml{ABS} dimostra come possibile per le regole +di congruenza gestire variabili legate. Dal momento che le regole di congruenza sono +matchate con il match di ordine superiore della Sezione~\ref{sec:simp-homatch}, questa regola matcher tutti i possibili termini astrazione. -Questi semplici esempi non hanno ancora dimostrato l'uso delle -condizioni $\mathit{ctxt}$ su sotto-equazioni. Un esempio di questo -la regola di congruenza (che si trova in \ml{CONG\_ss}) per le implicazioni. Questa +Questi semplici esempi non hanno ancora dimostrato l'uso delle +condizioni $\mathit{ctxt}$ su sotto-equazioni. Un esempio di questo +la regola di congruenza (che si trova in \ml{CONG\_ss}) per le implicazioni. Questa afferma \[ \vdash (P = P') \Rightarrow (P' \Rightarrow (Q = Q')) \Rightarrow (P \Rightarrow Q = P' \Rightarrow Q') \] -Questa regola dovrebbe essere letta: ``Quando si semplifica $P\Rightarrow Q$, prima -si semplifichi $P$ a $P'$. Poi si assuma $P'$, e si semplifichi $Q$ a $Q'$. +Questa regola dovrebbe essere letta: ``Quando si semplifica $P\Rightarrow Q$, prima +si semplifichi $P$ a $P'$. Poi si assuma $P'$, e si semplifichi $Q$ a $Q'$. Poi il risultato $P' \Rightarrow Q'$.'' La regola per espressioni condizionali @@ -2601,25 +2601,25 @@ \subsubsection{Regole di congruenza} \textsf{if}\;P'\;\textsf{then}\;x'\;\textsf{else}\;y') \end{array} \] -Questa regola permette di assumere la guardia quando si semplifica il -ramo-vero del condizionale, e di assumere la sua negazione quando si +Questa regola permette di assumere la guardia quando si semplifica il +ramo-vero del condizionale, e di assumere la sua negazione quando si semplifica il ramo-falso. -Le assunzioni contestuali da regole di congruenza sono trasformate in -riscritture usando il meccanismo descritto nella +Le assunzioni contestuali da regole di congruenza sono trasformate in +riscritture usando il meccanismo descritto nella Sezione~\ref{sec:generating-rewrite-rules}. -Le regole di congruenza possono essere usate per ottenere un numero di interessanti -effetti. Per esempio, una congruenza pu specificare che i sotto-termini -\emph{non} siano semplificati se lo si desidera. Questo potrebbe essere usato per impedire +Le regole di congruenza possono essere usate per ottenere un numero di interessanti +effetti. Per esempio, una congruenza pu specificare che i sotto-termini +\emph{non} siano semplificati se lo si desidera. Questo potrebbe essere usato per impedire la semplificazione dei rami delle espressioni condizionali: \[ \vdash (P = P') \Rightarrow (\textsf{if}\;P\;\textsf{then}\;x\;\textsf{else}\;y = \textsf{if}\;P'\;\textsf{then}\;x\;\textsf{else}\;y) \] -Se aggiunta al semplificatore, questa regola prender la precedenza su qualsiasi -altra regola per le espressioni condizionali (mascherando quella sopra +Se aggiunta al semplificatore, questa regola prender la precedenza su qualsiasi +altra regola per le espressioni condizionali (mascherando quella sopra \ml{CONG\_ss}, diciamo) e far s che il semplificatore di scendere solo nella guardia. Con le riscritture standard (da \ml{BOOL\_ss}): \[ @@ -2628,8 +2628,8 @@ \subsubsection{Regole di congruenza} \vdash \;\textsf{if}\;\bot\;\textsf{then}\;x\;\textsf{else}\;y \,\;=\,\; y \end{array} \] -gli utenti possono scegliere che il semplificatore ignori -i rami di un condizionali fino a quando la guarda di quel condizionale semplificata +gli utenti possono scegliere che il semplificatore ignori +i rami di un condizionali fino a quando la guarda di quel condizionale semplificata o a vero o a falso. @@ -2672,16 +2672,16 @@ \subsubsection{Normalizzazione-AC} \end{session} \index{arith_ss (insieme di semplificazione)@\ml{arith\_ss} (insieme di semplificazione)} -L'ordine degli operandi nella forma normale-AC in cui lavora la normalizzazione-AC -del semplificatore non specificato. Tuttavia, la forma -normale sempre associata a destra. Si noti inoltre che il \simpset{} -\ml{arith\_ss}, e il frammento \ml{ARITH\_ss} che ne la base, ha -le sue procedure di normalizzazione su misura per l'addizione sui -numeri naturali. Combinare la normalizzazione-AC, come descritta qui, con +L'ordine degli operandi nella forma normale-AC in cui lavora la normalizzazione-AC +del semplificatore non specificato. Tuttavia, la forma +normale sempre associata a destra. Si noti inoltre che il \simpset{} +\ml{arith\_ss}, e il frammento \ml{ARITH\_ss} che ne la base, ha +le sue procedure di normalizzazione su misura per l'addizione sui +numeri naturali. Combinare la normalizzazione-AC, come descritta qui, con \ml{arith\_ss} pu far s che il semplificatore entri in un loop infinito. -I teoremi AC possono essere aggiunti ai \simpset{} anche attraverso la lista di teoremi parte -dell'interfaccia della tattica e della conversione, usando la forma speciale di riscrittura +I teoremi AC possono essere aggiunti ai \simpset{} anche attraverso la lista di teoremi parte +dell'interfaccia della tattica e della conversione, usando la forma speciale di riscrittura \ml{AC}: \begin{session} \begin{verbatim} @@ -2690,21 +2690,21 @@ \subsubsection{Normalizzazione-AC} > val it = |- p /\ q \/ r \/ P z = r \/ P z \/ p /\ q : thm \end{verbatim} \end{session} -Si veda la Sezione~\ref{sec:simp-special-rewrite-forms} per maggiori informazioni su speciali +Si veda la Sezione~\ref{sec:simp-special-rewrite-forms} per maggiori informazioni su speciali forme di riscrittura. \subsubsection{Incorporate codice} \label{sec:simp-embedding-code} -Il semplificatore dispone di due modi diversi in cui il codice dell'utente pu essere -incorporato nel suo attraversamento e semplificazione dei termini di input. Incorporando -il loro proprio codice gli utenti possono personalizzare il comportamento del +Il semplificatore dispone di due modi diversi in cui il codice dell'utente pu essere +incorporato nel suo attraversamento e semplificazione dei termini di input. Incorporando +il loro proprio codice gli utenti possono personalizzare il comportamento del semplificatore in una misura significativa. \paragraph{Conversioni utente} -Il pi semplice dei due metodi permente al semplificatore di includere -conversioni fornite dall'utente. Queste sono aggiunte ai \simpset{} nel -campo {convs} dei frammenti \simpset{}. Questo campo prende liste di +Il pi semplice dei due metodi permente al semplificatore di includere +conversioni fornite dall'utente. Queste sono aggiunte ai \simpset{} nel +campo {convs} dei frammenti \simpset{}. Questo campo prende liste di valori di tipo \begin{hol} \begin{verbatim} @@ -2715,58 +2715,58 @@ \subsubsection{Incorporate codice} \end{verbatim} \end{hol} -I campo \ml{name} e \ml{trace} sono usati quando il tracing del semplificatore - acceso. Se la conversione applicata, e se il livello di traccia del -semplificatore maggiore di o uguale al campo \ml{trace}, allora sar -emesso un messagio circa l'applicazione della conversione +I campo \ml{name} e \ml{trace} sono usati quando il tracing del semplificatore + acceso. Se la conversione applicata, e se il livello di traccia del +semplificatore maggiore di o uguale al campo \ml{trace}, allora sar +emesso un messagio circa l'applicazione della conversione (che include il suo \ml{name}). -Il campo \ml{key} del record di sopra usato per specificare i -sotto-termini a cui la conversione dovrebbe essere applicata. Se il valore +Il campo \ml{key} del record di sopra usato per specificare i +sotto-termini a cui la conversione dovrebbe essere applicata. Se il valore \ml{NONE}, allora la conversione sar provata ad ogni posizione. -Altrimenti, la conversione applicata a posizioni di termine che matchano il -pattern fornito. Il primo componente del pattern una lista di -variabili che dovrebbero essere trattate come costanti quando si cercano match -del pattern. Il secondo componente il pattern di termine stesso. Il matching -verso questa componente \emph{non} fatto dal match di ordine superiore della -Sezione~\ref{sec:simp-homatch}, ma da una ``term-net'' di ordine superiore. -Questa forma di matching non cerca di essere precisa; essa usata per -eliminare in modo efficiente match chiaramente impossibili. Non controlla -i tipi, e non controlla binding multipli. Questo significa che la -conversione non sar applicata a termini che sono match esatti +Altrimenti, la conversione applicata a posizioni di termine che matchano il +pattern fornito. Il primo componente del pattern una lista di +variabili che dovrebbero essere trattate come costanti quando si cercano match +del pattern. Il secondo componente il pattern di termine stesso. Il matching +verso questa componente \emph{non} fatto dal match di ordine superiore della +Sezione~\ref{sec:simp-homatch}, ma da una ``term-net'' di ordine superiore. +Questa forma di matching non cerca di essere precisa; essa usata per +eliminare in modo efficiente match chiaramente impossibili. Non controlla +i tipi, e non controlla binding multipli. Questo significa che la +conversione non sar applicata a termini che sono match esatti per il pattern fornito. -Infine, la conversione stessa. Molti usi di questa infrastruttura sono per aggiungere -normali conversioni \HOL{} (di tipo \ml{term->thm}), e questo pu essere -fatto ignorando i primi due parametri del campo \ml{conv} Per una -conversione \ml{myconv}, l'idioma standard di scrivere -\ml{K~(K~myconv)}. Se l'utente lo desidera, tuttavia, il suo codice -\emph{pu} riferirsi ai primi due parametri. Il secondo parametro -lo stack delle condizioni collaterali che sono state tentate fino ad ora. Il -primo permette al codice dell'utente di richiamare il semplificatore, passando -lo stack delle condizioni collaterali, e una nuova condizione per risolvere. -L'argomento \ml{term} deve essere di tipo \holtxt{:bool}, e la chiamata -ricorsiva lo semplificher a vero (e richiamer \ml{EQT\_ELIM} per trasformare un termine -$t$ nel teorema $\vdash t$). Questa restrizione pu essere sollevata in una -futura versione di \HOL{} ma per come stanno le cose ora, la chiamata ricorsiva pu -essere usata \emph{solo} per scaricare la condizione collaterale. Si noti anche che - responsabilit dell'utente passare uno stack appropriatamente aggiornato di +Infine, la conversione stessa. Molti usi di questa infrastruttura sono per aggiungere +normali conversioni \HOL{} (di tipo \ml{term->thm}), e questo pu essere +fatto ignorando i primi due parametri del campo \ml{conv} Per una +conversione \ml{myconv}, l'idioma standard di scrivere +\ml{K~(K~myconv)}. Se l'utente lo desidera, tuttavia, il suo codice +\emph{pu} riferirsi ai primi due parametri. Il secondo parametro +lo stack delle condizioni collaterali che sono state tentate fino ad ora. Il +primo permette al codice dell'utente di richiamare il semplificatore, passando +lo stack delle condizioni collaterali, e una nuova condizione per risolvere. +L'argomento \ml{term} deve essere di tipo \holtxt{:bool}, e la chiamata +ricorsiva lo semplificher a vero (e richiamer \ml{EQT\_ELIM} per trasformare un termine +$t$ nel teorema $\vdash t$). Questa restrizione pu essere sollevata in una +futura versione di \HOL{} ma per come stanno le cose ora, la chiamata ricorsiva pu +essere usata \emph{solo} per scaricare la condizione collaterale. Si noti anche che + responsabilit dell'utente passare uno stack appropriatamente aggiornato di condizioni collaterali all'invocazione ricorsiva del semplificatore. -Una conversione fornita dall'utente non dovrebbe mai restituire l'identit riflessiva -(un'istanza di $\vdash t = t$). Questo far andare in loop il -semplificatore. Piuttosto che restituire un tale risultato, si sollevi un \ml{HOL\_ERR} o +Una conversione fornita dall'utente non dovrebbe mai restituire l'identit riflessiva +(un'istanza di $\vdash t = t$). Questo far andare in loop il +semplificatore. Piuttosto che restituire un tale risultato, si sollevi un \ml{HOL\_ERR} o un'eccezione \ml{Conv.UNCHANGED}. (Entrambe sono trattate allo stesso modo dal semplificatore.) \paragraph{Procedure di decisione consapevoli del contesto} -Un altro metodo, pi complicato, per incorporare codice utente nel -semplificatore \emph{attraverso} il campo \ml{dprocs} della struttura -frammento \simpset{}. Questo metodo pi generale rispetto ad aggiungere -conversioni, e permette anche al codice utente di costruire e mantenere i suoi +Un altro metodo, pi complicato, per incorporare codice utente nel +semplificatore \emph{attraverso} il campo \ml{dprocs} della struttura +frammento \simpset{}. Questo metodo pi generale rispetto ad aggiungere +conversioni, e permette anche al codice utente di costruire e mantenere i suoi propri contesti logici costruiti su misura. -Il campo \ml{dprocs} richiede liste di valori di tipo -\ml{Traverse.reducer}. Questi valori sono costruiti con il +Il campo \ml{dprocs} richiede liste di valori di tipo +\ml{Traverse.reducer}. Questi valori sono costruiti con il costruttore \ml{REDUCER}: \begin{hol} \begin{verbatim} @@ -2778,18 +2778,18 @@ \subsubsection{Incorporate codice} -> reducer \end{verbatim} \end{hol} -Il tipo \ml{context} un alias per il tipo \ML{} incorporato -\ml{exn}, quello delle eccezioni. Le eccezioni sono qui usate come un -``tipo universale'', capace di archiviare dati di qualsiasi tipo. Per esempio, -se il dato desiderato una coppia di un intero e un booleano, allora si +Il tipo \ml{context} un alias per il tipo \ML{} incorporato +\ml{exn}, quello delle eccezioni. Le eccezioni sono qui usate come un +``tipo universale'', capace di archiviare dati di qualsiasi tipo. Per esempio, +se il dato desiderato una coppia di un intero e un booleano, allora si pu fare la seguente dichiarazione: \begin{hol} \begin{verbatim} exception my_data of int * bool \end{verbatim} \end{hol} -Non necessario rendere questa dichiarazione visibile con uno scopo -ampio. Infatti, solo le funzioni che accedono e creano contesti di questa +Non necessario rendere questa dichiarazione visibile con uno scopo +ampio. Infatti, solo le funzioni che accedono e creano contesti di questa forma hanno bisogno di vederla. Per esempio: \begin{hol} \begin{verbatim} @@ -2798,49 +2798,49 @@ \subsubsection{Incorporate codice} \end{verbatim} \end{hol} -Quando crea un valore di tipo \ml{reducer}, l'utente deve fornire un -contesto iniziale, e due funzioni. La prima, \ml{addcontext}, -chiamata dal meccanismo di attraversamento del semplificatore per dare ad ogni -procedura di decisione incorporata accesso ai teoremi che rappresentano la nuova informazione -di contesto. Per esempio, questa funzione chiamata con i teoremi dalle -assunzioni attuali in \ml{ASM\_SIMP\_TAC}, e con i teoremi -dagli argomenti lista di teoremi a tutt le varie funzioni di -semplificazione. Mentre un termine attraversato, le regole di congruenza che governano -questo attraversamento possono fornire teoremi addizionali; questi saranno passati -anche alla funzione \ml{addcontext}. (Naturalmente, del tutto a carico -della funzione \ml{addcontext} come questi teoremi saranno +Quando crea un valore di tipo \ml{reducer}, l'utente deve fornire un +contesto iniziale, e due funzioni. La prima, \ml{addcontext}, +chiamata dal meccanismo di attraversamento del semplificatore per dare ad ogni +procedura di decisione incorporata accesso ai teoremi che rappresentano la nuova informazione +di contesto. Per esempio, questa funzione chiamata con i teoremi dalle +assunzioni attuali in \ml{ASM\_SIMP\_TAC}, e con i teoremi +dagli argomenti lista di teoremi a tutt le varie funzioni di +semplificazione. Mentre un termine attraversato, le regole di congruenza che governano +questo attraversamento possono fornire teoremi addizionali; questi saranno passati +anche alla funzione \ml{addcontext}. (Naturalmente, del tutto a carico +della funzione \ml{addcontext} come questi teoremi saranno gestiti; essi possono persino essere ignorati completamente.) -Quando un riduttore applicato a un termine, richiamata la funzione -\ml{apply} fornita. Oltre che al termine da trasformare, la -funzione \ml{apply} passata anche a un record che contiene un -risolutore di condizione collaterale, l'attuale contesto della procedura di decisione. e -allo stack delle condizioni collaterali tentate fino ad ora. Lo stack e il risolutore -sono gli stessi degli argomenti addizionali dati alle conversioni fornite -dall'utente. La potenza dell'astrazione del riduttore di avere accesso a +Quando un riduttore applicato a un termine, richiamata la funzione +\ml{apply} fornita. Oltre che al termine da trasformare, la +funzione \ml{apply} passata anche a un record che contiene un +risolutore di condizione collaterale, l'attuale contesto della procedura di decisione. e +allo stack delle condizioni collaterali tentate fino ad ora. Lo stack e il risolutore +sono gli stessi degli argomenti addizionali dati alle conversioni fornite +dall'utente. La potenza dell'astrazione del riduttore di avere accesso a un contesto che pu essere costruito in modo appropriato per ogni procedura di decisione. -Le procedure di decisione sono applicate per l'ultima volta quando un termine incontrato dal -semplificatore. Inoltre, esse sono applicate \emph{dopo} che il semplificatore ha -gia eseguito un ricorsione in ogni sotto-termine e ha tentato di fare quante pi riscritture -possibili. Questo significa che bench la riscrittura del semplificatore avvenda in un maniera che va -dall'alto verso il basso, le procedure di decisione saranno applicate dal basso verso l'alto e +Le procedure di decisione sono applicate per l'ultima volta quando un termine incontrato dal +semplificatore. Inoltre, esse sono applicate \emph{dopo} che il semplificatore ha +gia eseguito un ricorsione in ogni sotto-termine e ha tentato di fare quante pi riscritture +possibili. Questo significa che bench la riscrittura del semplificatore avvenda in un maniera che va +dall'alto verso il basso, le procedure di decisione saranno applicate dal basso verso l'alto e solo come ultima risorsa. -Come per le conversioni-utente, le procedure di decisione devono sollevare un'eccezione +Come per le conversioni-utente, le procedure di decisione devono sollevare un'eccezione piuttosto che restituire istanze di riflessivit. \subsubsection{Forme speciali di riscrittura} \label{sec:simp-special-rewrite-forms} -Si pu accedere ad alcune delle caratteristiche del semplificatore in un modo -relativamente semplice usando funzioni \ML{} per costruire speciali forme -di teorema. Questi teoremi speciali possono poi essere passati negli +Si pu accedere ad alcune delle caratteristiche del semplificatore in un modo +relativamente semplice usando funzioni \ML{} per costruire speciali forme +di teorema. Questi teoremi speciali possono poi essere passati negli argomenti lista-di-teoremi delle tattiche di semplificazione. -A due delle caratteristiche avanzate del semplificatore, la normalizzazione-AC e -le regole di congruenza si pu accedere in questo modo. Piuttosto che costruire un -frammento \simpset{} custom che include le regole AC o di congruenza +A due delle caratteristiche avanzate del semplificatore, la normalizzazione-AC e +le regole di congruenza si pu accedere in questo modo. Piuttosto che costruire un +frammento \simpset{} custom che include le regole AC o di congruenza richieste, l'utente pu usare piuttosto le funzioni \ml{AC} o \ml{Cong}: \begin{hol} \begin{verbatim} @@ -2854,15 +2854,15 @@ \subsubsection{Forme speciali di riscrittura} AC DISJ_ASSOC DISJ_COMM \end{verbatim} \end{hol} -appare tra i teoremi passati a una tattica di semplificazionie, allora -il semplificatore eseguir una normalizzazione-AC di disgiunzioni. La -funzione \ml{Cong} fornisce un'interfaccia analoga per l'aggiunta di +appare tra i teoremi passati a una tattica di semplificazionie, allora +il semplificatore eseguir una normalizzazione-AC di disgiunzioni. La +funzione \ml{Cong} fornisce un'interfaccia analoga per l'aggiunta di nuove regole di congruenza. \index{semplificazione!garantire la terminazione} \index{Once (controllo delle applicazioni di riscrittura)@\ml{Once} (controllo delle applicazioni di riscrittura)|pin} \index{Ntimes (controllo delle applicazioni di riscrittura)@\ml{Ntimes} (controllo delle applicazioni di riscrittura)|pin} -Altre due funzioni forniscono un meccanismo crudo per controllare il +Altre due funzioni forniscono un meccanismo crudo per controllare il numero di volte che una riscrittura individuale sar applicata. \begin{hol} \begin{verbatim} @@ -2870,50 +2870,50 @@ \subsubsection{Forme speciali di riscrittura} Ntimes : thm -> int -> thm \end{verbatim} \end{hol} -Un teorema ``avvolto'' nella funzione \ml{Once} sar applicato -una sola volta quando il semplificatore applicato a un termine dato. Un teorema -avvolto in \ml{Ntimes} sar applicato tante volte quante sono date nel +Un teorema ``avvolto'' nella funzione \ml{Once} sar applicato +una sola volta quando il semplificatore applicato a un termine dato. Un teorema +avvolto in \ml{Ntimes} sar applicato tante volte quante sono date nel parametro intero. \paragraph{Semplificare a particolari sotto-termini} \index{semplificazione!a particolari sotto-termini} -Abbiamo gi visto (Sezione~\ref{sec:simp-congruences} di sopra) che -la tecnologia di congruenza del semplificatore pu essere usata per forzare il -semplificatore ad ignorare termini particolari. L'esempio nella sezione -di sopra ha discusso come un regola di congruenza potrebbe essere usata per assicurare che +Abbiamo gi visto (Sezione~\ref{sec:simp-congruences} di sopra) che +la tecnologia di congruenza del semplificatore pu essere usata per forzare il +semplificatore ad ignorare termini particolari. L'esempio nella sezione +di sopra ha discusso come un regola di congruenza potrebbe essere usata per assicurare che solo le guardie delle espressioni condizionali dovrebbero essere semplificate. -In molte dimostrazioni, comune voler riscrivere solo un lato o -l'altro di un connettivo binario (spesso, questo connettivo -un'eguaglianza). Per esempio, questo capita quando si riscrive con equazioni -da complicate definizioni ricorsive che non sono soltanto ricorsioni -strutturali. In tali definizioni, il lato sinistro dell'equazioni +In molte dimostrazioni, comune voler riscrivere solo un lato o +l'altro di un connettivo binario (spesso, questo connettivo +un'eguaglianza). Per esempio, questo capita quando si riscrive con equazioni +da complicate definizioni ricorsive che non sono soltanto ricorsioni +strutturali. In tali definizioni, il lato sinistro dell'equazioni avr un simbolo funzione attaccato a una sequenza di variabili, ad esempio: \begin{hol} \begin{verbatim} |- f x y = ... f (g x y) z ... \end{verbatim} \end{hol} -Teoremi di una forma analoga sono anche restituiti come i teoremi +Teoremi di una forma analoga sono anche restituiti come i teoremi ``casi'' dalle definizioni induttive. -Qualunque sia la loro origine, tali teoremi sono il classico esempio di -qualcosa a cui si vorrebbe attaccare il qualificatore \ml{Once}. -Tuttavia, questo pu non essere sufficiente: si pu desiderare di dimostrare un risultato -come +Qualunque sia la loro origine, tali teoremi sono il classico esempio di +qualcosa a cui si vorrebbe attaccare il qualificatore \ml{Once}. +Tuttavia, questo pu non essere sufficiente: si pu desiderare di dimostrare un risultato +come \begin{hol} \begin{verbatim} f (constructor x) y = ... f (h x y) z ... \end{verbatim} \end{hol} -(Con le relazioni, il goal pu spesso rappresentare un'implicazione al posto di -un'eguaglianza.) In questa situazioni, spesso si vuole semplicemente espandere -l'istanza di \holtxt{f} sulla sinistra, lasciando l'altra occorrenza -da sola. Usare \ml{Once} espander solo una di esse, ma senza +(Con le relazioni, il goal pu spesso rappresentare un'implicazione al posto di +un'eguaglianza.) In questa situazioni, spesso si vuole semplicemente espandere +l'istanza di \holtxt{f} sulla sinistra, lasciando l'altra occorrenza +da sola. Usare \ml{Once} espander solo una di esse, ma senza specificare quale deve essere espansa. -La soluzione a questo problema di usare speciali regole di congruenza, -costruite come forme speciali che possono essere passate come teoremi come +La soluzione a questo problema di usare speciali regole di congruenza, +costruite come forme speciali che possono essere passate come teoremi come \ml{Once}. Le funzioni \begin{hol} \begin{verbatim} @@ -2921,8 +2921,8 @@ \subsubsection{Forme speciali di riscrittura} SimpR : term -> thm \end{verbatim} \end{hol} -costruiscono regole di congruenza per forzare la riscritture alla sinistra o alla destra di -termini particolari. Per esempio, se \holtxt{opn} un operatore binario, +costruiscono regole di congruenza per forzare la riscritture alla sinistra o alla destra di +termini particolari. Per esempio, se \holtxt{opn} un operatore binario, \ml{SimpL~\holquote{(opn)}} restituisce \ml{Cong} applicato al teorema \begin{hol} \begin{verbatim} @@ -2930,25 +2930,25 @@ \subsubsection{Forme speciali di riscrittura} \end{verbatim} \end{hol} \index{SimpLHS@\ml{SimpLHS}|pin}\index{SimpRHS@\ml{SimpRHS}|pin} -Dal momento che il caso eguaglianza cos comune, gli speciali valori -\ml{SimpLHS} e \ml{SimpRHS} sono forniti per forzare -la semplificazione sulla sinistra o sulla destra di un'eguaglianza rispettivamente. -Queste sono definite essere solo applicazioni di \ml{SimpL} e \ml{SimpR} +Dal momento che il caso eguaglianza cos comune, gli speciali valori +\ml{SimpLHS} e \ml{SimpRHS} sono forniti per forzare +la semplificazione sulla sinistra o sulla destra di un'eguaglianza rispettivamente. +Queste sono definite essere solo applicazioni di \ml{SimpL} e \ml{SimpR} all'eguaglianza. -Si noti che queste regole si applicano per tutto un termine, non soltanto -all'occorrenza pi alta di un operatore. Inoltre, l'operatore pi alto nel -termine non ha bisogno di essere quello della regola di congruenza. Questo comportamento -una conseguenza automatica dell'implementazione in termini di regole +Si noti che queste regole si applicano per tutto un termine, non soltanto +all'occorrenza pi alta di un operatore. Inoltre, l'operatore pi alto nel +termine non ha bisogno di essere quello della regola di congruenza. Questo comportamento +una conseguenza automatica dell'implementazione in termini di regole di congruenza. \subsubsection{Limitare la semplificazione} \label{sec:limit-simpl} \index{semplificazione!garantire la terminazione} -Oltre alle forme-di-teoremi \ml{Once} and \ml{Ntimes} appena -discusse, che limitano il numero di volte che una particolare riscrittura -applicata, il semplificatore pu anche essere limitato nel numero totale di +Oltre alle forme-di-teoremi \ml{Once} and \ml{Ntimes} appena +discusse, che limitano il numero di volte che una particolare riscrittura +applicata, il semplificatore pu anche essere limitato nel numero totale di riscritture che esso esegue. La funzione \ml{limit} (in \ml{simpLib} e \ml{bossLib}) \begin{hol} @@ -2956,38 +2956,38 @@ \subsubsection{Limitare la semplificazione} limit : int -> simpset -> simpset \end{verbatim} \end{hol} -registra un limite numerico in un \simpset{}. Quando un \simpset{} limitato -poi lavora su un termine, non applicher mai pi del numero dato -di riscritture a quel termine. Quando sono usate riscritture condizionali, la -riscrittura fatta nello scaricamento delle condizioni collaterali pesano negativamente sul -limite, finch la riscrittura infine applicata. Anche l'applicazione -delle regole di congruenza, delle conversioni e delle procedure +registra un limite numerico in un \simpset{}. Quando un \simpset{} limitato +poi lavora su un termine, non applicher mai pi del numero dato +di riscritture a quel termine. Quando sono usate riscritture condizionali, la +riscrittura fatta nello scaricamento delle condizioni collaterali pesano negativamente sul +limite, finch la riscrittura infine applicata. Anche l'applicazione +delle regole di congruenza, delle conversioni e delle procedure di decisione fornite dall'utente pesano tutte negativamente sul limite. -Quando il semplificatore cede il controllo a una conversione o a una procedura di -decisione fornita dall'utente non pu garantire che queste funzioni restituiranno -alla fine un risultato (e inoltre esse possono prendere un tempo arbitrariamente lungo per terminare, spesso una preoccupazione -con le procedure di decisione aritmetica), ma l'uso di \ml{limit} +Quando il semplificatore cede il controllo a una conversione o a una procedura di +decisione fornita dall'utente non pu garantire che queste funzioni restituiranno +alla fine un risultato (e inoltre esse possono prendere un tempo arbitrariamente lungo per terminare, spesso una preoccupazione +con le procedure di decisione aritmetica), ma l'uso di \ml{limit} altrimenti un buon metodo per assicurare che la semplificazione termina. \subsubsection{Riscrittura con pre-ordini arbitrari} \label{sec:preorder-rewriting} \index{semplificazione!con i pre-ordini} -Oltre a semplificare rispetto all'eguaglianza, anche -possibile usare il semplificatore per ``riscrivere'' rispetto a una relazione -che riflessiva e transitiva (un \emph{preordine}). Questo pu essere un -modo molto potente di lavorare con relazioni di transizione nella semantica +Oltre a semplificare rispetto all'eguaglianza, anche +possibile usare il semplificatore per ``riscrivere'' rispetto a una relazione +che riflessiva e transitiva (un \emph{preordine}). Questo pu essere un +modo molto potente di lavorare con relazioni di transizione nella semantica operazionale. {\newcommand{\bred}{\ensuremath{\rightarrow^*_\beta}} - Si immagini, per esempio, che si debba impostare un ``profondo incorporamento'' del - $\lambda$-calcolo. Questo implicher la definizione di un nuovo tipo - (diciamo, \texttt{lamterm}) all'interno della logica, cos come le definizioni delle - funzioni appropriate (ad esempio, la sostituzione) e le relazioni su - \texttt{lamterm}. E' probabile che si lavori con la chiusura riflessiva - e transitiva della $\beta$-riduzione (\bred). Questa relazione ha + Si immagini, per esempio, che si debba impostare un ``profondo incorporamento'' del + $\lambda$-calcolo. Questo implicher la definizione di un nuovo tipo + (diciamo, \texttt{lamterm}) all'interno della logica, cos come le definizioni delle + funzioni appropriate (ad esempio, la sostituzione) e le relazioni su + \texttt{lamterm}. E' probabile che si lavori con la chiusura riflessiva + e transitiva della $\beta$-riduzione (\bred). Questa relazione ha regole di congruenza come \[ \begin{array}{c@{\qquad\qquad}c} @@ -2995,17 +2995,17 @@ \subsubsection{Riscrittura con pre-ordini arbitrari} \infer{M \,N_1\;\bred\;M\,N_2}{N_1 \;\bred\;N_2}\\[3mm] \multicolumn{2}{c}{\infer{(\lambda v.M_1)\;\bred\;(\lambda v.M_2)}{M_1\;\bred M_2}} \end{array} -\] e un'importante riscrittura +\] e un'importante riscrittura \[ \infer{(\lambda v. M)\,N \;\bred\; M[v := N]}{} \] -Dovendo applicare queste regole manualmente mostrare che un -dato termine iniziale si pu ridurre a una particolare destinazione di solito -molto doloroso, coinvolgendo molte applicazioni, non solo quelle dei teoremi -di sopra, ma anche quelle dei teoremi che descrivono la chiusura riflessiva e +Dovendo applicare queste regole manualmente mostrare che un +dato termine iniziale si pu ridurre a una particolare destinazione di solito +molto doloroso, coinvolgendo molte applicazioni, non solo quelle dei teoremi +di sopra, ma anche quelle dei teoremi che descrivono la chiusura riflessiva e transitiva (si veda la Sezione~\ref{relation}). -Bench il $\lambda$-calcolo sia non-deterministico, esso anche confluente, cos +Bench il $\lambda$-calcolo sia non-deterministico, esso anche confluente, cos vale il seguente teorema: \[ \infer{ @@ -3014,25 +3014,25 @@ \subsubsection{Riscrittura con pre-ordini arbitrari} \beta\textrm{-nf}\;N & M_1 \;\bred\;M_2 } \] -Questo il teorema critico che giustifica il cambio dalla riscrittura -con l'eguaglianza alla riscrittura con \bred. Esso dice che se si ha un termine -$M_1\bred N$, dove $N$ una forma $\beta$-normale, e se $M_1$ riscrive a -$M_2$ sotto \bred, allora il termine originale uguale a $M_2\bred N$. -Avendo fortuna, $M_2$ sar sintatticamente identico a $N$, e -la riflessivit di \bred{} dimostrer il risultato desiderato. I teoremi -come questi, che giustificano il cambio da una relazione di riscrittura a +Questo il teorema critico che giustifica il cambio dalla riscrittura +con l'eguaglianza alla riscrittura con \bred. Esso dice che se si ha un termine +$M_1\bred N$, dove $N$ una forma $\beta$-normale, e se $M_1$ riscrive a +$M_2$ sotto \bred, allora il termine originale uguale a $M_2\bred N$. +Avendo fortuna, $M_2$ sar sintatticamente identico a $N$, e +la riflessivit di \bred{} dimostrer il risultato desiderato. I teoremi +come questi, che giustificano il cambio da una relazione di riscrittura a un'altra sono conosciuti come \emph{congruenze d'indebolimento}. -Quando aggiustato in modo appropriato, il semplificatore pu essere modificato per sfruttare -i cinque teoremi di sopra, e dimostrare automaticamente risultati come +Quando aggiustato in modo appropriato, il semplificatore pu essere modificato per sfruttare +i cinque teoremi di sopra, e dimostrare automaticamente risultati come \[ u ((\lambda f\,x. f (f\,x)) v) \bred u (\lambda x. v(v\,x)) \] -(sotto le assunzioni che i termini $u$ e $v$ siano variabili del +(sotto le assunzioni che i termini $u$ e $v$ siano variabili del $\lambda$-calcolo, rendendo il risultato come una forma $\beta$-normale). -Inoltre, si avranno probabilmente vari teoremi di riscrittura -che si vorranno usare oltre a quelli specificati di sopra. Per +Inoltre, si avranno probabilmente vari teoremi di riscrittura +che si vorranno usare oltre a quelli specificati di sopra. Per esempio, se in precedenza si dimostrato un teorema come \[ K\,x\,y \bred x @@ -3048,36 +3048,36 @@ \subsubsection{Riscrittura con pre-ordini arbitrari} \end{verbatim} I campo del record che il primo argomento sono: \begin{description} -\item[\texttt{trans}] Il teorema che afferma che la relazione +\item[\texttt{trans}] Il teorema che afferma che la relazione transitiva, nella forma $\forall x y z. R\,x\,y \land R\,y\,z \Rightarrow R x z$. -\item[\texttt{refl}] Il teorema che afferma che la relazione +\item[\texttt{refl}] Il teorema che afferma che la relazione riflessiva, nella forma $\forall x. R\,x\,x$. -\item[\texttt{weakenings}] Una lista di congruenze d'indebolimento, della - forma generale $P_1 \Rightarrow P_2 \Rightarrow \cdots (t_1 = t_2)$, dove almeno una delle - $P_i$ menzioner presumibilmente la nuova relazione $R$ applicata a una - variabile che appare in $t_1$. Altri - antecedenti possono essere condizioni collaterali come il requisito +\item[\texttt{weakenings}] Una lista di congruenze d'indebolimento, della + forma generale $P_1 \Rightarrow P_2 \Rightarrow \cdots (t_1 = t_2)$, dove almeno una delle + $P_i$ menzioner presumibilmente la nuova relazione $R$ applicata a una + variabile che appare in $t_1$. Altri + antecedenti possono essere condizioni collaterali come il requisito nell'esempio di sopra che il termine $N$ sia in forma $\beta$-normale. \item[\texttt{subsets}] Teoremi della forma $R'\,x\,y \Rightarrow R\,x\,y$. - Questi sono usati per aumentare il risultante ``filtro'' del \simpset{} cos che - i teoremi nel contesto che menziona $R'$ deriveranno utili riscritture - che coinvolgono $R$. Nell'esempio della $\beta$-riduzione, si potrebbe avere anche - una relazione $\rightarrow_{wh}^*$ per la riduzione weak-head. Qualsiasi riduzione - weak-head anche una $\beta$-riduzione, cos pu essere utile anche avere che - il semplificatore ``promuova'' automaticamente i fatti circa la riduzione weak-head + Questi sono usati per aumentare il risultante ``filtro'' del \simpset{} cos che + i teoremi nel contesto che menziona $R'$ deriveranno utili riscritture + che coinvolgono $R$. Nell'esempio della $\beta$-riduzione, si potrebbe avere anche + una relazione $\rightarrow_{wh}^*$ per la riduzione weak-head. Qualsiasi riduzione + weak-head anche una $\beta$-riduzione, cos pu essere utile anche avere che + il semplificatore ``promuova'' automaticamente i fatti circa la riduzione weak-head a fatti circa la $\beta$-riduzione, e poi li usi come riscritture. -\item[\texttt{rewrs}] Possibilmente riscritture condizionali, presumibilmente la maggior parte - della forma $P \Rightarrow R\,t_1\,t_2$. Qui possono anche essere - incluse riscritture sull'eguaglianza, che permettono di includere utili fatti aggiuntivi. Per - esempio, quando si lavora con il $\lambda$-calcolo, si potrebbe includere sia - la riscrittura per $K$ di sopra, cos come la definizione della +\item[\texttt{rewrs}] Possibilmente riscritture condizionali, presumibilmente la maggior parte + della forma $P \Rightarrow R\,t_1\,t_2$. Qui possono anche essere + incluse riscritture sull'eguaglianza, che permettono di includere utili fatti aggiuntivi. Per + esempio, quando si lavora con il $\lambda$-calcolo, si potrebbe includere sia + la riscrittura per $K$ di sopra, cos come la definizione della sostituzione. \end{description} } % end of block defining \bred -L'applicazione di questa funzione a un \simpset{} \texttt{ss} -produrr un \texttt{ss} aumentato che ha tutti i comportamenti del -\texttt{ss} esistente, cos come la capacit di riscrivere con la relazione +L'applicazione di questa funzione a un \simpset{} \texttt{ss} +produrr un \texttt{ss} aumentato che ha tutti i comportamenti del +\texttt{ss} esistente, cos come la capacit di riscrivere con la relazione data. @@ -3086,31 +3086,31 @@ \subsubsection{Riscrittura con pre-ordini arbitrari} \section{Efficient Applicative Order Reduction---\texttt{computeLib}} \label{sec:computeLib} -La Sezione~\ref{sec:datatype} e la Sezione~\ref{TFL} mostrano la capacit di -\HOL{} di rappresentare molti dei costrutti standard della programmazione -funzionale. Se si vuole quindi `eseguire' programmi funzionali su -argomenti, ci sono molte scelte. Primo, si pu applicare il -semplificatore, come mostrato nella Sezione~\ref{sec:simpLib}. Questo permette -di esercitare tutto il potere del processo di riscrittura, -inclusa, per esempio, l'applicazione delle procedure di decisione per -dimostrare vincoli sulle regole di riscrittura condizionale. Secondo, si potrebbe -scrivere il programma, e tutti i programmi da cui dipende in modo transitivo, -in un file in una sintassi concreta adatta, e invocare un compilatore o -un interprete. Questa funzionalit disponibile in \HOL{} attraverso l'uso di +La Sezione~\ref{sec:datatype} e la Sezione~\ref{TFL} mostrano la capacit di +\HOL{} di rappresentare molti dei costrutti standard della programmazione +funzionale. Se si vuole quindi `eseguire' programmi funzionali su +argomenti, ci sono molte scelte. Primo, si pu applicare il +semplificatore, come mostrato nella Sezione~\ref{sec:simpLib}. Questo permette +di esercitare tutto il potere del processo di riscrittura, +inclusa, per esempio, l'applicazione delle procedure di decisione per +dimostrare vincoli sulle regole di riscrittura condizionale. Secondo, si potrebbe +scrivere il programma, e tutti i programmi da cui dipende in modo transitivo, +in un file in una sintassi concreta adatta, e invocare un compilatore o +un interprete. Questa funzionalit disponibile in \HOL{} attraverso l'uso di \ml{EmitML.exportML}. -Terzo, si pu usare \ml{computeLib}. Questa libreria supporta una valutazione -call-by-value delle funzioni \HOL{} per passi deduttivi. In altre parole, -molto simile ad avere un interprete \ML{} all'interno della logica \HOL{}, -lavorando per inferenza in avanti. Quando usati in questo modo, i programmi +Terzo, si pu usare \ml{computeLib}. Questa libreria supporta una valutazione +call-by-value delle funzioni \HOL{} per passi deduttivi. In altre parole, +molto simile ad avere un interprete \ML{} all'interno della logica \HOL{}, +lavorando per inferenza in avanti. Quando usati in questo modo, i programmi funzionali possono essere eseguiti pi velocemente che usando il semplificatore. -Gli entry-point pi accessibili per usare la libreria \ml{computeLib} -sono la conversione \ml{EVAL} e la sua tattica corrispondente -\ml{EVAL\_TAC}. Queste dipendono su un database interno che archivia -definizioni di funzione. Nel seguente esempio, caricare \ml{sortingTheory} -aumenta questo database con le definizioni rilevanti, in particolare quella -di Quicksort (\holtxt{QSORT}), e poi possiamo valutare +Gli entry-point pi accessibili per usare la libreria \ml{computeLib} +sono la conversione \ml{EVAL} e la sua tattica corrispondente +\ml{EVAL\_TAC}. Queste dipendono su un database interno che archivia +definizioni di funzione. Nel seguente esempio, caricare \ml{sortingTheory} +aumenta questo database con le definizioni rilevanti, in particolare quella +di Quicksort (\holtxt{QSORT}), e poi possiamo valutare \holtxt{QSORT} su una lista concreta. % \setcounter{sessioncount}{0} @@ -3122,15 +3122,15 @@ \section{Efficient Applicative Order Reduction---\texttt{computeLib}} > val it = |- QSORT $<= [76; 34; 102; 3; 4] = [3; 4; 34; 76; 102] : thm \end{verbatim} \end{session} -Spesso, l'argomento a una funzione non ha variabili: in quel caso -l'applicazione di \ml{EVAL} dovrebbe restituire un risultato ground, -come nell'esempio di sopra. Tuttavia, \ml{EVAL} pu anche valutare funzioni su -argomenti con variabili---la cosiddetta valutazione \emph{simbolica}---e -in quel caso, il comportamento di \ml{EVAL} dipende dalla struttura -dell'equazioni di ricorsione. Per esempio, nella seguente sessione, se c' -sufficiente informazione nell'input, la valutazione simbolica pu restituire -un risultato interessante. Tuttavia, se nell'input non c' informazione -sufficiente a permettere all'algoritmo alcuna presa, non avr luogo +Spesso, l'argomento a una funzione non ha variabili: in quel caso +l'applicazione di \ml{EVAL} dovrebbe restituire un risultato ground, +come nell'esempio di sopra. Tuttavia, \ml{EVAL} pu anche valutare funzioni su +argomenti con variabili---la cosiddetta valutazione \emph{simbolica}---e +in quel caso, il comportamento di \ml{EVAL} dipende dalla struttura +dell'equazioni di ricorsione. Per esempio, nella seguente sessione, se c' +sufficiente informazione nell'input, la valutazione simbolica pu restituire +un risultato interessante. Tuttavia, se nell'input non c' informazione +sufficiente a permettere all'algoritmo alcuna presa, non avr luogo alcuna espansione % \begin{session} @@ -3146,9 +3146,9 @@ \section{Efficient Applicative Order Reduction---\texttt{computeLib}} \subsection{Trattare con la divergenza} -La difficolt maggiore con l'uso di \ml{EVAL} la terminazione. Troppo -spesso, la valutazione simbolica con \ml{EVAL} diverger, o generer -termini enormi. Il caso usuale sono i condizionali con le variabili nel +La difficolt maggiore con l'uso di \ml{EVAL} la terminazione. Troppo +spesso, la valutazione simbolica con \ml{EVAL} diverger, o generer +termini enormi. Il caso usuale sono i condizionali con le variabili nel test. Per esempio, la seguente definizione probabilmente uguale a \holtxt{FACT}, % \begin{session} @@ -3171,9 +3171,9 @@ \subsection{Trattare con la divergenza} \end{verbatim} \end{session} % -La definizione ricorsiva primitiva di \holtxt{FACT} non si espande -per nulla, mentre la ricorsione stile-decostruttore di \holtxt{fact} non smette mai -di espandere. Un rudimentale strumento di monitoraggio mostra il comportamento, prima +La definizione ricorsiva primitiva di \holtxt{FACT} non si espande +per nulla, mentre la ricorsione stile-decostruttore di \holtxt{fact} non smette mai +di espandere. Un rudimentale strumento di monitoraggio mostra il comportamento, prima su un argomento ground, poi su un argomento simbolico. % \begin{session} @@ -3205,64 +3205,64 @@ \subsection{Trattare con la divergenza} \end{verbatim} \end{session} % -In ogni espansione ricorsiva, il testo coinvolge una variabile, e di conseguenza -non pu essere ridotta a \holtxt{T} o a \holtxt{F}. Cos, l'espansione +In ogni espansione ricorsiva, il testo coinvolge una variabile, e di conseguenza +non pu essere ridotta a \holtxt{T} o a \holtxt{F}. Cos, l'espansione non si ferma mai. Some simple remedies can be adopted in trying to deal with non-terminating symbolic evaluation. -Si possono adottare alcuni semplici rimedi nel provare a trattare con +Si possono adottare alcuni semplici rimedi nel provare a trattare con una valutazione simbolica che non termina. \begin{itemize} -\item \ml{RESTR\_EVAL\_CONV} si comporta come \ml{EVAL} eccetto - che prende una lista extra di costanti. Durante - la valutazione, se si incontra una delle costanti fornite, essa - non sar espansa. Questo permette di valutare gi fino a un livello specificato. +\item \ml{RESTR\_EVAL\_CONV} si comporta come \ml{EVAL} eccetto + che prende una lista extra di costanti. Durante + la valutazione, se si incontra una delle costanti fornite, essa + non sar espansa. Questo permette di valutare gi fino a un livello specificato. e pu essere usato per tagliare alcune valutazioni circolari. -\item anche \ml{set\_skip} pu essere usata per controllare - la valutazione. Si veda la voce per \ml{CBV\_CONV} in \REFERENCE{} per +\item anche \ml{set\_skip} pu essere usata per controllare + la valutazione. Si veda la voce per \ml{CBV\_CONV} in \REFERENCE{} per una discussione di \ml{set\_skip} \end{itemize} \paragraph{Valutatori custom} -Per alcuni problemi, desiderabile costruire un valutatore -personalizzato, specializzato su un insieme fissato di definizioni. Il tipo -\ml{compset} che si trova in \ml{computeLib} il tipo dei database di definizione. Le +Per alcuni problemi, desiderabile costruire un valutatore +personalizzato, specializzato su un insieme fissato di definizioni. Il tipo +\ml{compset} che si trova in \ml{computeLib} il tipo dei database di definizione. Le funzioni \ml{new\_compset}, \ml{bool\_compset}, \ml{add\_funs}, e -\ml{add\_convs} forniscono il modo standard per costruire tali -database. Un altro \holtxt{compset} piuttosto utile -\ml{reduceLib.num\_compset}, che pu essere usato per valutare -termini con numeri e booleani. Dato un \ml{compset}, la funzione -\ml{CBV\_CONV} genera un valutatore: usata per implementare \ml{EVAL}. +\ml{add\_convs} forniscono il modo standard per costruire tali +database. Un altro \holtxt{compset} piuttosto utile +\ml{reduceLib.num\_compset}, che pu essere usato per valutare +termini con numeri e booleani. Dato un \ml{compset}, la funzione +\ml{CBV\_CONV} genera un valutatore: usata per implementare \ml{EVAL}. Si veda \REFERENCE{} per maggiori dettagli. \paragraph{Trattare con Funzioni sui Numeri di Peano} -Le funzioni definite per pattern-matching su numeri nello stile di Peano non sono -nel formato giusto per \ml{EVAL}, dal momento che i calcoli saranno -asintoticamente inefficienti. Piuttosto, la stessa definizione dovrebbe essere -usata su numerali, che una notazione posizionale descritta nella -Sezione~\ref{sec:numerals}. Tuttavia, preferibile per le dimostrazioni -lavorare su numeri di Peano. Per colmare questa lacuna, la funzione -\ml{numLib.SUC\_TO\_NUMERAL\_DEFN\_CONV} usata per convertire una funzione -su numeri di Peano in una su numerali, che il formato che -\ml{Eval} preferisce. \ml{Define} chiamer automaticamente +Le funzioni definite per pattern-matching su numeri nello stile di Peano non sono +nel formato giusto per \ml{EVAL}, dal momento che i calcoli saranno +asintoticamente inefficienti. Piuttosto, la stessa definizione dovrebbe essere +usata su numerali, che una notazione posizionale descritta nella +Sezione~\ref{sec:numerals}. Tuttavia, preferibile per le dimostrazioni +lavorare su numeri di Peano. Per colmare questa lacuna, la funzione +\ml{numLib.SUC\_TO\_NUMERAL\_DEFN\_CONV} usata per convertire una funzione +su numeri di Peano in una su numerali, che il formato che +\ml{Eval} preferisce. \ml{Define} chiamer automaticamente \ml{SUC\_TO\_NUMERAL\_DEFN\_CONV} sul suo risultato. \paragraph{Archiviare le definizioni} -\ml{Define} aggiunge automaticamente la sua definizione al compset globale -usato da \ml{EVAL} e \ml{EVAL\_TAC}. Tuttavia, quando \ml{Hol\_defn} -usata per definire una funzione, le sue equazioni di definizione non sono aggiunte al -compset globale fino a quando \ml{tprove} usata per dimostrare i vincoli -di terminazione. Inoltre, \ml{tprove} non aggiunge la definizione -in modo persistente nel compset globale. Di conseguenza, si deve usare -\ml{add\_persistent\_funs} in una teoria per essere sicuri che le definizioni -fatte da \ml{Hol\_defn} siano disponibili a \ml{Eval} nelle teorie -discendenti. Un altro punto: si deve chiamare \ml{add\_persistent\_funs} +\ml{Define} aggiunge automaticamente la sua definizione al compset globale +usato da \ml{EVAL} e \ml{EVAL\_TAC}. Tuttavia, quando \ml{Hol\_defn} +usata per definire una funzione, le sue equazioni di definizione non sono aggiunte al +compset globale fino a quando \ml{tprove} usata per dimostrare i vincoli +di terminazione. Inoltre, \ml{tprove} non aggiunge la definizione +in modo persistente nel compset globale. Di conseguenza, si deve usare +\ml{add\_persistent\_funs} in una teoria per essere sicuri che le definizioni +fatte da \ml{Hol\_defn} siano disponibili a \ml{Eval} nelle teorie +discendenti. Un altro punto: si deve chiamare \ml{add\_persistent\_funs} prima di chiamare \ml{export\_theory}. @@ -3270,45 +3270,45 @@ \section{Le Librerie Aritmetiche---\texttt{numLib}, \texttt{intLib} and \texttt{ \label{sec:numLib} \index{procedure di decisione!Aritemtica Presburger su numeri naturali} -Ognuna delle librerie aritmetiche di \HOL{} fornisce una +Ognuna delle librerie aritmetiche di \HOL{} fornisce una suite di definizioni e teoremi cos come il supporto per l'inferenza automatica. \paragraph{numLib} -I numeri pi di base in \HOL{} sono i numeri naturali. La +I numeri pi di base in \HOL{} sono i numeri naturali. La libreria \ml{numLib} comprende le teorie \ml{numTheory}, -\ml{prim\_recTheory}, \ml{arithmeticTheory}, e \ml{numeralTheory}. -Questa libreria incorpora anche un valutatore per espressioni numeriche -da \ml{reduceLib} e una procedura di decisione per l'aritmetica lineare -\ml{ARITH\_CONV}. Il valutatore e la procedura di decisione sono -integrati nel simpset \ml{arith\_ss} usato dal semplificatore. -Allo stesso modo, la procedura di decisione dell'aritmetica lineare pu essere invocata -direttamente attraverso \ml{DECIDE} e \ml{DECIDE\_TAC}, che si trovano entrambe in +\ml{prim\_recTheory}, \ml{arithmeticTheory}, e \ml{numeralTheory}. +Questa libreria incorpora anche un valutatore per espressioni numeriche +da \ml{reduceLib} e una procedura di decisione per l'aritmetica lineare +\ml{ARITH\_CONV}. Il valutatore e la procedura di decisione sono +integrati nel simpset \ml{arith\_ss} usato dal semplificatore. +Allo stesso modo, la procedura di decisione dell'aritmetica lineare pu essere invocata +direttamente attraverso \ml{DECIDE} e \ml{DECIDE\_TAC}, che si trovano entrambe in \ml{bossLib}. \index{procedure di decisione!Aritemtica Presburger su interi} -\paragraph{intLib} - -La libreria \ml{intLib} comprende \ml{integerTheory}, un'estesa -teoria degli interi, pi due procedure di decisione -per la completa aritmetica Presburger. Queste sono disponibili come -\ml{intLib.COOPER\_CONV} e \ml{intLib.ARITH\_CONV}. Queste -procedure di decisione sono in grado di trattare con l'aritmetica lineare -sugli interi e i numeri naturali, cos come di trattare -con un'alternanza arbitraria di quantificatori. La procedura -\ml{ARITH\_CONV} un'implementazione dell'Omega Test, e sembra -in generale avere migliori performance rispetto all'algoritmo di Cooper. Ci sono -comunque problemi per cui questo non vero, cos utile avere disponibili +\paragraph{intLib} + +La libreria \ml{intLib} comprende \ml{integerTheory}, un'estesa +teoria degli interi, pi due procedure di decisione +per la completa aritmetica Presburger. Queste sono disponibili come +\ml{intLib.COOPER\_CONV} e \ml{intLib.ARITH\_CONV}. Queste +procedure di decisione sono in grado di trattare con l'aritmetica lineare +sugli interi e i numeri naturali, cos come di trattare +con un'alternanza arbitraria di quantificatori. La procedura +\ml{ARITH\_CONV} un'implementazione dell'Omega Test, e sembra +in generale avere migliori performance rispetto all'algoritmo di Cooper. Ci sono +comunque problemi per cui questo non vero, cos utile avere disponibili entrambe le procedure. \paragraph{realLib} -La libreria \ml{realLib} fornisce uno sviluppo fondazionale -dei numeri reali e dell'analisi. Si veda la Sezione~\ref{reals} -per una rapida descrizione delle teorie. -E' anche fornita una teoria dei polinomi, in \theoryimp{polyTheory}. -Una procedura di decisione per l'aritmetica lineare sui numeri reali +La libreria \ml{realLib} fornisce uno sviluppo fondazionale +dei numeri reali e dell'analisi. Si veda la Sezione~\ref{reals} +per una rapida descrizione delle teorie. +E' anche fornita una teoria dei polinomi, in \theoryimp{polyTheory}. +Una procedura di decisione per l'aritmetica lineare sui numeri reali anche fornita da \ml{realLib}, sotto il nome \ml{REAL\_ARITH\_CONV} e \ml{REAL\_ARITH\_TAC}. @@ -3318,7 +3318,7 @@ \section{Libreria Bit Vector---\texttt{wordsLib}} \subsection{Valutazione} -La libreria \theoryimp{wordsLib} dovrebbe essere caricata quando si valutano termini bit-vector ground. Questa libreria fornisce un \emph{compset} \ml{words\_compset}, che +La libreria \theoryimp{wordsLib} dovrebbe essere caricata quando si valutano termini bit-vector ground. Questa libreria fornisce un \emph{compset} \ml{words\_compset}, che pu essere usato nella costruzione di \emph{compese} e conversioni personalizzati. \setcounter{sessioncount}{0} \begin{session} @@ -3330,7 +3330,7 @@ \subsection{Valutazione} > val it = |- 8w + 9w = 1w : thm \end{verbatim} \end{session} -Si noti che qui usata un'annotazione di tipo per designare la dimensione word. Quando la dimensione word rappresentata da una variabile di tipo (cio per word i lunghezza arbitraria), la valutazione +Si noti che qui usata un'annotazione di tipo per designare la dimensione word. Quando la dimensione word rappresentata da una variabile di tipo (cio per word i lunghezza arbitraria), la valutazione pu dare risultati parziali o insoddisfacenti. \subsection{Parsing e pretty-printing} @@ -3359,7 +3359,7 @@ \subsection{Parsing e pretty-printing} \end{verbatim} \end{session} -I word possono essere stampati usando le basi numeriche standard. Per esempio, la funzione +I word possono essere stampati usando le basi numeriche standard. Per esempio, la funzione \ml{wordsLib.output\_words\_as\_bin} selezioner il formato binario: \begin{session} \begin{verbatim} @@ -3370,7 +3370,7 @@ \subsection{Parsing e pretty-printing} > val it = |- $FCP ODD = 0b1010101010101010w : thm \end{verbatim} \end{session} -La funzione \ml{output\_words\_as} pi flessibile e permette alla base numerica di variare a seconda della +La funzione \ml{output\_words\_as} pi flessibile e permette alla base numerica di variare a seconda della lunghezza del word e del valore numerico. Il pretty-printer di default (installato quando si carica \theoryimp{wordsLib}) stampa valori piccoli in decimale e valori grandi in esadecimale. La funzione \ml{output\_words\_as\_oct} abiliter automaticamente il parsing per i numeri ottali. @@ -3562,16 +3562,16 @@ \subsection{Semplificazione e conversioni} \subsubsection{Procedure di decisione} -Una procedura di decisione per i word fornita nella forma di -\ml{blastLib.BBLAST\_PROVE}. Questa procedura usa il \emph{bit-blasting} --- -convertire espressioni word in proposizioni e poi usare il risolutore SAT per -decidere il goal\footnote{Questo approccio permette di dare contro-esempi -quando la negazione di un goal insoddisfacibile.}. Questo approccio ragionevolmente generale e -pu affrontare un ampia gamma di problemi bit-vector. Tuttavia, ci sono alcune -limitazioni: l'approccio funziona solo per lunghezze word costanti, artimetica -lineare (moltiplicazione per letterali) e per shift e estrazioni -bit-field rispetto a valori letterali. Si noti inoltre che alcuni problemi saranno -potenzialmente lenti da dimostrare, ad esempio quando le dimensioni dei word sono grandi e/o quando +Una procedura di decisione per i word fornita nella forma di +\ml{blastLib.BBLAST\_PROVE}. Questa procedura usa il \emph{bit-blasting} --- +convertire espressioni word in proposizioni e poi usare il risolutore SAT per +decidere il goal\footnote{Questo approccio permette di dare contro-esempi +quando la negazione di un goal insoddisfacibile.}. Questo approccio ragionevolmente generale e +pu affrontare un ampia gamma di problemi bit-vector. Tuttavia, ci sono alcune +limitazioni: l'approccio funziona solo per lunghezze word costanti, artimetica +lineare (moltiplicazione per letterali) e per shift e estrazioni +bit-field rispetto a valori letterali. Si noti inoltre che alcuni problemi saranno +potenzialmente lenti da dimostrare, ad esempio quando le dimensioni dei word sono grandi e/o quando ci sono molte addizioni annidate (magari attraverso la moltiplicazione). @@ -3587,8 +3587,8 @@ \subsubsection{Procedure di decisione} > val it = |- w2w a <+ 256w : thm \end{verbatim} \end{session} -La procedura di decisione \ml{BBLAST\_PROVE} basata sulla conversione -\ml{BBLAST\_CONV}. Questa conversione pu essere usata per convertire problemi bit-vector +La procedura di decisione \ml{BBLAST\_PROVE} basata sulla conversione +\ml{BBLAST\_CONV}. Questa conversione pu essere usata per convertire problemi bit-vector in una forma proposizionale; per esempio: \begin{session} \begin{verbatim} diff --git a/Manual/Translations/IT/Description/preface.tex b/Manual/Translations/IT/Description/preface.tex index 02703c8979..ba11b139ea 100644 --- a/Manual/Translations/IT/Description/preface.tex +++ b/Manual/Translations/IT/Description/preface.tex @@ -15,82 +15,82 @@ \chapter*{Prefazione}\markboth{Prefazione}{Prefazione} \noindent Si far riferimento a questi quattro documenti con i nomi abbreviati (in maiuscoletto inclinato) dati di sopra. -Questo documento, \DESCRIPTION, una guida avanzata per utenti con qualche -esperienza precedente del sistema. I principianti dovrebbero iniziare con il +Questo documento, \DESCRIPTION, una guida avanzata per utenti con qualche +esperienza precedente del sistema. I principianti dovrebbero iniziare con il documento di accompagnamento \TUTORIAL. -Il sistema \HOL\ sviluppato per supportare la dimostrazione interattiva di teoremi nella -logica di ordine superiore (da qui l'acronimo `\HOL' [Higher Order Logic (ndt)]). A questo scopo, la logica -formale interfacciata a un linguaggio di programmazione di scopo generale (\ML, per -meta-linguaggio) in cui possono essere denotati i termini e i teoremi della logica, -possono essere espresse ed applicate le strategie di dimostrazione, e sviluppate le teorie logiche. -La versione della logica di ordine superiore usata in \HOL\ il calcolo dei predicati -con termini dal lambda calcolo tipizzato (cio la teoria dei -tipi semplici). Questo fu inizialmente sviluppato come una fondazione per la matematica -\cite{Church}. La principale area di applicazione di \HOL\ fu inizialmente -intesa essere la specifica e la verifica dei modelli hardware. -(L'uso della logica di ordine superiore a questo scopo fu inizialmente difesa da -Keith Hanna \cite{Hanna-Daeche}.) Tuttavia, la logica non limita +Il sistema \HOL\ sviluppato per supportare la dimostrazione interattiva di teoremi nella +logica di ordine superiore (da qui l'acronimo `\HOL' [Higher Order Logic (ndt)]). A questo scopo, la logica +formale interfacciata a un linguaggio di programmazione di scopo generale (\ML, per +meta-linguaggio) in cui possono essere denotati i termini e i teoremi della logica, +possono essere espresse ed applicate le strategie di dimostrazione, e sviluppate le teorie logiche. +La versione della logica di ordine superiore usata in \HOL\ il calcolo dei predicati +con termini dal lambda calcolo tipizzato (cio la teoria dei +tipi semplici). Questo fu inizialmente sviluppato come una fondazione per la matematica +\cite{Church}. La principale area di applicazione di \HOL\ fu inizialmente +intesa essere la specifica e la verifica dei modelli hardware. +(L'uso della logica di ordine superiore a questo scopo fu inizialmente difesa da +Keith Hanna \cite{Hanna-Daeche}.) Tuttavia, la logica non limita le applicazione all'hardware; \HOL\ stato applicato a molte altre aree. -Questo documento presenta la logica \HOL\ nella sua forma \ML{}, e -spiega i mezzi con cui le funzioni del meta-linguaggio possono essere usate per -generare dimostrazioni nella logica. Cos. descrive come il sistema -astratto di \LOGIC{} di fatto implementato nel linguaggio di programmazione -\ML{}, fornendo una descrizione complessiva delle principali caratteristiche +Questo documento presenta la logica \HOL\ nella sua forma \ML{}, e +spiega i mezzi con cui le funzioni del meta-linguaggio possono essere usate per +generare dimostrazioni nella logica. Cos. descrive come il sistema +astratto di \LOGIC{} di fatto implementato nel linguaggio di programmazione +\ML{}, fornendo una descrizione complessiva delle principali caratteristiche del sistema. L'approccio di meccanizzare le dimostrazioni formali usato in \HOL\ dovuto a Robin -Milner \cite{Edinburgh-LCF}, che ha anche diretto il team che ha progettato -e implementato il linguaggio \ML. Quel lavoro era centrato su un sistema -chiamato \LCF\ (logica per le funzioni computabili), che era inteso per -il ragionamento interattivo automatizzato circa funzioni di ordine superiore definite -ricorsivamente. L'interfaccia della logica al meta-linguaggio era reso -esplicito, usando la struttura di tipi dell'\ML, con l'intenzione che alla fine -altre logiche sarebbe state provate al posto della logica originaria. Il -sistema \HOL\ un discendente diretto di \LCF; questo riflesso in -ogni cosa dalla sua struttura e aspetto alla sua incorporazione dell'\ML, -e persino a parti della sua implementazione. Cos \HOL\ soddisfa il +Milner \cite{Edinburgh-LCF}, che ha anche diretto il team che ha progettato +e implementato il linguaggio \ML. Quel lavoro era centrato su un sistema +chiamato \LCF\ (logica per le funzioni computabili), che era inteso per +il ragionamento interattivo automatizzato circa funzioni di ordine superiore definite +ricorsivamente. L'interfaccia della logica al meta-linguaggio era reso +esplicito, usando la struttura di tipi dell'\ML, con l'intenzione che alla fine +altre logiche sarebbe state provate al posto della logica originaria. Il +sistema \HOL\ un discendente diretto di \LCF; questo riflesso in +ogni cosa dalla sua struttura e aspetto alla sua incorporazione dell'\ML, +e persino a parti della sua implementazione. Cos \HOL\ soddisfa il piano iniziale di applicare la metodologia \LCF\ ad altre logiche. -L'\LCF\ originario fu implementato ad Edimburgo nei primi anni 1970, ed ora ci si -riferisce ad esso come all'`\LCF di Edimburgo'. Il suo codice fu portato dallo Stanford Lisp -al Franz Lisp da G\'erard Huet presso l'{\small INRIA}, e fu usato in un progetto di ricerca -francese chiamato `Formel'. La versione Franz Lisp dell'\LCF\ di Huet fu -ulteriormente sviluppata a Cambridge da Larry Paulson, e divenne conosciuta come il -`Cambridge \LCF'. Il sistema \HOL\ implementato sulla base di una prima versione del Cambridge -\LCF\ e di conseguenza molte delle caratteristiche sia dell'Edinburgh che del Cambridge \LCF\ furono -ereditate da \HOL. Per esempio, l'assiomatizzazione della logica di ordine superiore utilizzata -non quella classica dovuta a Church, ma una formulazione equivalente +L'\LCF\ originario fu implementato ad Edimburgo nei primi anni 1970, ed ora ci si +riferisce ad esso come all'`\LCF di Edimburgo'. Il suo codice fu portato dallo Stanford Lisp +al Franz Lisp da G\'erard Huet presso l'{\small INRIA}, e fu usato in un progetto di ricerca +francese chiamato `Formel'. La versione Franz Lisp dell'\LCF\ di Huet fu +ulteriormente sviluppata a Cambridge da Larry Paulson, e divenne conosciuta come il +`Cambridge \LCF'. Il sistema \HOL\ implementato sulla base di una prima versione del Cambridge +\LCF\ e di conseguenza molte delle caratteristiche sia dell'Edinburgh che del Cambridge \LCF\ furono +ereditate da \HOL. Per esempio, l'assiomatizzazione della logica di ordine superiore utilizzata +non quella classica dovuta a Church, ma una formulazione equivalente influenzata da \LCF. -Una versione avanzata e razionalizzata di \HOL, chiamata \HOL 88, fu -rilasciata (nel 1988), dopo che il sistema \HOL\ originario era stato in uso -per molti anni. \HOL 90 (rilasciato nel 1990) fu un porting di \HOL 88 -in SML \cite{sml} da parte di Konrad Slind presso l'Universit di Calgary. Esso stato -ulteriormente sviluppato nel corso degli anni 1990. \HOL{} 4 l'ultima -versione di \HOL, e anch'esso implementato in SML; dotato di un numero -di novit rispetto ai suoi predecessori. \HOL{} 4 anche la +Una versione avanzata e razionalizzata di \HOL, chiamata \HOL 88, fu +rilasciata (nel 1988), dopo che il sistema \HOL\ originario era stato in uso +per molti anni. \HOL 90 (rilasciato nel 1990) fu un porting di \HOL 88 +in SML \cite{sml} da parte di Konrad Slind presso l'Universit di Calgary. Esso stato +ulteriormente sviluppato nel corso degli anni 1990. \HOL{} 4 l'ultima +versione di \HOL, e anch'esso implementato in SML; dotato di un numero +di novit rispetto ai suoi predecessori. \HOL{} 4 anche la versione del sistema supportata per la comunit internazionale \HOL. -Abbiamo deciso di numerare le implementazioni di \HOL{} retroattivamente nel +Abbiamo deciso di numerare le implementazioni di \HOL{} retroattivamente nel modo seguente \begin{enumerate} -\item \HOL88 e precedenti: implementazioni basate su un substrato Lisp, +\item \HOL88 e precedenti: implementazioni basate su un substrato Lisp, con l'ML Classico. -\item \HOL90: implementazioni in Standard ML, che usano principalmente +\item \HOL90: implementazioni in Standard ML, che usano principalmente l'implementazione SML/NJ. -\item \HOL98 (distribuzioni Athabasca e Taupo): implementazioni che usano +\item \HOL98 (distribuzioni Athabasca e Taupo): implementazioni che usano il Moscow ML, e con una nuova libreria e un nuovo meccanismo di teoria. \item \HOL{} (distribuzioni Kananaskis) \end{enumerate} -Di conseguenza, con \HOL{}~4, facciamo a meno dell'abitudine di associare -le implementazioni con i numeri degli anni. Le distribuzioni individuali all'interno +Di conseguenza, con \HOL{}~4, facciamo a meno dell'abitudine di associare +le implementazioni con i numeri degli anni. Le distribuzioni individuali all'interno di \HOL{}~4 conservano lo schema di nome \textit{lake-number}. -In questo documento, l'acronimo `\HOL' si riferisce sia al sistema di dimostrazione -interattiva di teoremi sia alla versione di logica di ordine superiore che il sistema -supporta; dove c' una seria ambiguit, il primo chiamato `il sistema +In questo documento, l'acronimo `\HOL' si riferisce sia al sistema di dimostrazione +interattiva di teoremi sia alla versione di logica di ordine superiore che il sistema +supporta; dove c' una seria ambiguit, il primo chiamato `il sistema \HOL' e la seconda `la logica \HOL'. diff --git a/Manual/Translations/IT/Description/system.tex b/Manual/Translations/IT/Description/system.tex index 71284ff12f..9197699594 100644 --- a/Manual/Translations/IT/Description/system.tex +++ b/Manual/Translations/IT/Description/system.tex @@ -1,122 +1,122 @@ \chapter{La Logica \HOL{} in ML}\label{HOLsyschapter} -In questo capitolo, descritta la concreta rappresentazione della logica -\HOL{}. Questo implica descrivere le funzioni \ML\ che contengono -l'interfaccia alla logica (fino alla -Sezione~\ref{sec:system-terms} inclusa); le quotation, il parsing, e la stampa dei -tipi e dei termini logici (Sezione~\ref{quotation}); la rappresentazione dei -teoremi (Sezione~\ref{sec:theorems-in-ml}); la rappresentazione delle teorie -(Sezione~\ref{theoryfns}); la fondamentale teoria \HOL{} \texttt{bool} -(Sezione~\ref{boolfull}); le regole primitive d'inferenza -(Sezione~\ref{rules}); e i metodi per estendere le teorie -(nella Sezione~\ref{theoryfns} e anche pi avanti nella -Sezione~\ref{sec:bossLib}). Si assume che il lettore sia familiare +In questo capitolo, descritta la concreta rappresentazione della logica +\HOL{}. Questo implica descrivere le funzioni \ML\ che contengono +l'interfaccia alla logica (fino alla +Sezione~\ref{sec:system-terms} inclusa); le quotation, il parsing, e la stampa dei +tipi e dei termini logici (Sezione~\ref{quotation}); la rappresentazione dei +teoremi (Sezione~\ref{sec:theorems-in-ml}); la rappresentazione delle teorie +(Sezione~\ref{theoryfns}); la fondamentale teoria \HOL{} \texttt{bool} +(Sezione~\ref{boolfull}); le regole primitive d'inferenza +(Sezione~\ref{rules}); e i metodi per estendere le teorie +(nella Sezione~\ref{theoryfns} e anche pi avanti nella +Sezione~\ref{sec:bossLib}). Si assume che il lettore sia familiare con l'\ML. Se non lo , dovrebbe leggere prima l'introduzione all'\ML\ in {\sl Getting Started with HOL\/} nel \TUTORIAL. -Il sistema \HOL{} fornisce i tipi \ML\ \ml{hol\_type} e \ml{term} -che implementano i tipi e i termini della logica \HOL{}, come definito in -\LOGIC. Esso fornisce anche delle funzioni \ML\ primitive per creare e -manipolare valori di questi tipi. Su questa base implementata la logica +Il sistema \HOL{} fornisce i tipi \ML\ \ml{hol\_type} e \ml{term} +che implementano i tipi e i termini della logica \HOL{}, come definito in +\LOGIC. Esso fornisce anche delle funzioni \ML\ primitive per creare e +manipolare valori di questi tipi. Su questa base implementata la logica \HOL{}. L'idea chiave del sistema \HOL{} dovuta a Robin -Milner\index{Milner, R.}, e discussa in questo capitolo, che -i teoremi sono rappresentati da un tipo astratto \ML\ i cui unici -valori predefiniti sono gli assiomi, e le cui sole operazioni sono regole -d'inferenza. Questo significa che l'unico modo per costruire teoremi in -\HOL{} quello di applicare le regole d'inferenza ad assiomi o a teoremi esistenti; +Milner\index{Milner, R.}, e discussa in questo capitolo, che +i teoremi sono rappresentati da un tipo astratto \ML\ i cui unici +valori predefiniti sono gli assiomi, e le cui sole operazioni sono regole +d'inferenza. Questo significa che l'unico modo per costruire teoremi in +\HOL{} quello di applicare le regole d'inferenza ad assiomi o a teoremi esistenti; di conseguenza la coerenza della logica preservata. -Il proposito del meta-linguaggio \ML\ di fornire un ambiente -di programmazione in cui costruire strumenti di dimostrazione per assistere nella -costruzione di dimostrazioni. Quando il build del sistema \HOL{} eseguito, una variet di -utili teoremi pre-dimostrato e un insieme di strumenti pre-definito. Il sistema -di base cos offre un ricco ambiente iniziale; gli utenti lo possono arricchire ulteriormente -implementando i loro propri strumenti per applicazioni specifiche e costruire +Il proposito del meta-linguaggio \ML\ di fornire un ambiente +di programmazione in cui costruire strumenti di dimostrazione per assistere nella +costruzione di dimostrazioni. Quando il build del sistema \HOL{} eseguito, una variet di +utili teoremi pre-dimostrato e un insieme di strumenti pre-definito. Il sistema +di base cos offre un ricco ambiente iniziale; gli utenti lo possono arricchire ulteriormente +implementando i loro propri strumenti per applicazioni specifiche e costruire le loro teorie per applicazioni specifiche. \section{Questioni lessicali}\label{HOL-lex} -\index{identificatori, nella logica HOL@identificatori, nella logica \HOL{}|(} Il nome -di una variabile \HOL{} +\index{identificatori, nella logica HOL@identificatori, nella logica \HOL{}|(} Il nome +di una variabile \HOL{} % \index{tokens|(} \index{variabili, nella logica HOL@variabili, nella logica \HOL{}!nomi di|(} % -pu essere qualsiasi stringa \ML{}, ma il meccanismo di quotation eseguir il parsing solo -di nomi che sono identificatori (si veda la Sezione~\ref{ident} di sotto). Usare dei non-identificatori come nomi di variabili sconsigliato eccetto in circostanze -speciali (per esempio, quando si scrivono delle regole derivate che generano -variabili con nomi che sono garantiti essere differenti da nomi -esistenti). Il nome di una variabile di tipo +pu essere qualsiasi stringa \ML{}, ma il meccanismo di quotation eseguir il parsing solo +di nomi che sono identificatori (si veda la Sezione~\ref{ident} di sotto). Usare dei non-identificatori come nomi di variabili sconsigliato eccetto in circostanze +speciali (per esempio, quando si scrivono delle regole derivate che generano +variabili con nomi che sono garantiti essere differenti da nomi +esistenti). Il nome di una variabile di tipo % \index{variabili di tipo, nella logica HOL@variabili di tipo, nella logica \HOL{}!nomi di} % -nella logica \HOL{} formato da un apice (\ml{'}) seguito da un -alfanumerico che a sua volta non contiene apici (si veda la Sezione~\ref{tyvars} -per degli esempi). Il nome di una costante di tipo o di un termine costante nella -logica \HOL{} pu essere qualsiasi identificatore, bench alcuni nomi sono trattati -in modo speciale dal parser e dal printer di HOL e dovrebbero quindi essere +nella logica \HOL{} formato da un apice (\ml{'}) seguito da un +alfanumerico che a sua volta non contiene apici (si veda la Sezione~\ref{tyvars} +per degli esempi). Il nome di una costante di tipo o di un termine costante nella +logica \HOL{} pu essere qualsiasi identificatore, bench alcuni nomi sono trattati +in modo speciale dal parser e dal printer di HOL e dovrebbero quindi essere evitati. % \index{identificatori, nella logica HOL@identificatori, nella logica \HOL{}|)} \subsection{identificatori}\label{ident} -In aggiunta a forme speciali gi presenti nella grammatica rilevante, +In aggiunta a forme speciali gi presenti nella grammatica rilevante, un identificatore \HOL{} pu essere di due forme: \begin{myenumerate} -\item Una sequenza finita di \emph{alfanumerici} che cominciano con una lettera. Il - carattere di underscore considerato un carattere numerico, e cos pu - occorrere dopo la prima lettera di un identificatore. I caratteri greci (approssimativamente - caratteri Unicode che variano da \ml{U+0370} a \ml{U+03FF}) sono anch'essi lettere, eccetto per - $\lambda$~(\ml{U+03BB}), che trattata come un simbolo. \HOL{} - case-sensitive: le lettere maiuscole e minuscole sono considerate essere +\item Una sequenza finita di \emph{alfanumerici} che cominciano con una lettera. Il + carattere di underscore considerato un carattere numerico, e cos pu + occorrere dopo la prima lettera di un identificatore. I caratteri greci (approssimativamente + caratteri Unicode che variano da \ml{U+0370} a \ml{U+03FF}) sono anch'essi lettere, eccetto per + $\lambda$~(\ml{U+03BB}), che trattata come un simbolo. \HOL{} + case-sensitive: le lettere maiuscole e minuscole sono considerate essere differenti. - Le cifre sono i caratteri ASCII 0--9, il carattere di underscore, e i - sottoscritti e i soprascritti Unicode. Il carattere di apostrofo + Le cifre sono i caratteri ASCII 0--9, il carattere di underscore, e i + sottoscritti e i soprascritti Unicode. Il carattere di apostrofo speciale.% \index{apostrofo, gestione lessicale del} % - Non una lettera, ma pu comparire come parte di un identificatore di termine - alfanumerico dopo la prima lettera. Esso deve apparire all'inizio del - nome di una variabile di tipo, e pu anche apparire nel contesto di un termine come + Non una lettera, ma pu comparire come parte di un identificatore di termine + alfanumerico dopo la prima lettera. Esso deve apparire all'inizio del + nome di una variabile di tipo, e pu anche apparire nel contesto di un termine come una sequenza di apostrofi per conto proprio. -\item Un identificatore \emph{simbolico}, cio, una sequenza finita formata da - qualsiasi combinazione dei simboli ASCII e dei simboli Unicode. I +\item Un identificatore \emph{simbolico}, cio, una sequenza finita formata da + qualsiasi combinazione dei simboli ASCII e dei simboli Unicode. I simboli ASCII di base sono \begin{verbatim} # ? + * / \ = < > & % @ ! : | - ^ ` \end{verbatim} - L'uso del segno di omissione e del carattere di accento circonflesso complicato dal fatto - che questi caratteri hanno un significato speciale nel meccanismo - di quotation; si veda la Sezione~\ref{sec:quotation-antiquotation}. I simboli - ASCII di raggruppamento (graffe, quadre, e parentesi tonde), e i caratteri + L'uso del segno di omissione e del carattere di accento circonflesso complicato dal fatto + che questi caratteri hanno un significato speciale nel meccanismo + di quotation; si veda la Sezione~\ref{sec:quotation-antiquotation}. I simboli + ASCII di raggruppamento (graffe, quadre, e parentesi tonde), e i caratteri tilde~(\holtxt{\symbol{126}}), il punto~(\holtxt{.}), - la virgola~(\holtxt{,}), il punto-e-virgola~(\holtxt{;}) e il trattino~(\holtxt{-}) + la virgola~(\holtxt{,}), il punto-e-virgola~(\holtxt{;}) e il trattino~(\holtxt{-}) sono chiamati caratteri \emph{non-aggreganti}. % % \index{identificatori, nella logica HOL@identificatori, nella logica \HOL{}!caratteri non-aggreganti}% % - A meno che il token desiderato non sia gi presente nella grammatica, questi - caratteri non si combinano tra di loro o con altri caratteri - simbolici. Cos, la stringa \holtxt{"(("} vista come \emph{due} + A meno che il token desiderato non sia gi presente nella grammatica, questi + caratteri non si combinano tra di loro o con altri caratteri + simbolici. Cos, la stringa \holtxt{"(("} vista come \emph{due} token, cos come lo sono \holtxt{"+;"} e \holtxt{"-+"}. \index{token!Caratteri unicode} \index{Unicode} - I caratteri unicode che non sono n lettere n cifre sono considerati + I caratteri unicode che non sono n lettere n cifre sono considerati come simboli. Nessuno di questi non-aggregante. -\item Un \emph{numero} una stringa di una o pi cifre. Se non la - cifra iniziale, un underscore pu essere usato all'interno della sequenza per - fornire una spaziatura. Al fine di distinguere differenti generi di numeri - si pu usare un singolo carattere suffisso: per esempio \holtxt{3n} un - numero naturale mentre \holtxt{3i} un intero. I prefissi \holtxt{0x} e - \holtxt{0b} possono anche essere usati per cambiare la base del - numero. Se usato il prefisso \holtxt{0x}, possono anche essere usate - le `cifre' esadecimali \holtxt{a}--\holtxt{f} e \holtxt{A}--\holtxt{F}. +\item Un \emph{numero} una stringa di una o pi cifre. Se non la + cifra iniziale, un underscore pu essere usato all'interno della sequenza per + fornire una spaziatura. Al fine di distinguere differenti generi di numeri + si pu usare un singolo carattere suffisso: per esempio \holtxt{3n} un + numero naturale mentre \holtxt{3i} un intero. I prefissi \holtxt{0x} e + \holtxt{0b} possono anche essere usati per cambiare la base del + numero. Se usato il prefisso \holtxt{0x}, possono anche essere usate + le `cifre' esadecimali \holtxt{a}--\holtxt{f} e \holtxt{A}--\holtxt{F}. Si veda anche la Sezione~\ref{sec:numerals}.% \end{myenumerate} \index{variabili, nella logica HOL@variabili, nella logica \HOL{}!names of|)} @@ -124,7 +124,7 @@ \subsection{identificatori}\label{ident} \paragraph{Separatori} -I separatori usati dall'analizzatore lessicale \HOL{} sono (con i codici ASCII tra +I separatori usati dall'analizzatore lessicale \HOL{} sono (con i codici ASCII tra parentesi): \bigskip @@ -135,9 +135,9 @@ \subsection{identificatori}\label{ident} \paragraph{Identificatori speciali} -I seguenti identificatori validi sono usati dalla grammatica nella teoria -dei booleani, e di conseguenza anche in tutte le teorie discendenti. Essi non -dovrebbero essere usati come il nome di una variabile o di una costante a meno che l'utente sia +I seguenti identificatori validi sono usati dalla grammatica nella teoria +dei booleani, e di conseguenza anche in tutte le teorie discendenti. Essi non +dovrebbero essere usati come il nome di una variabile o di una costante a meno che l'utente sia molto confidente della propria abilit di perdere tempo con le grammatiche % \begin{verbatim} @@ -146,9 +146,9 @@ \subsection{identificatori}\label{ident} \paragraph {Nomi di variabili di tipo}\label{tyvars} -Il nome di una variabile di tipo nella logica \HOL{} una stringa -che comincia con un apice (\ml{'}) seguito da un alfanumerico che a sua volta -non contiene primi; per esempio tutti quelli che seguono sono nomi validi +Il nome di una variabile di tipo nella logica \HOL{} una stringa +che comincia con un apice (\ml{'}) seguito da un alfanumerico che a sua volta +non contiene primi; per esempio tutti quelli che seguono sono nomi validi di variabili di tipo eccetto l'ultimo: % \begin{hol} @@ -158,10 +158,10 @@ \subsection{identificatori}\label{ident} \end{hol} \paragraph{Token utente} -In generale, un utente \HOL{} ha una grande quantit di libert di creare la sua propria sintassi, richiedendo token speciali a prescindere dalle variabili e dai nomi per le costanti. +In generale, un utente \HOL{} ha una grande quantit di libert di creare la sua propria sintassi, richiedendo token speciali a prescindere dalle variabili e dai nomi per le costanti. Per esempio, la sintassi if-then-else per l'operatore condizionale % \index{condizionali, nella logica HOL@condizionali, nella logica \HOL{}!stampa dei}% -ha token speciali (l'``if'', il ``then'' e l'``else'') che non sono nomi per le variabili, n per le costanti (la costante sottostante di fatto chiamata \holtxt{COND}). +ha token speciali (l'``if'', il ``then'' e l'``else'') che non sono nomi per le variabili, n per le costanti (la costante sottostante di fatto chiamata \holtxt{COND}). Per essere sicuro che le operazioni di stampa e parsing dei token siano appropriatamente l'una l'inverso dell'altra, gli utenti non dovrebbero creare token che includono spazi vuoti o le stringhe di commento (\ml{(*} and \ml{*)}). \index{token|)} @@ -171,9 +171,9 @@ \section{Tipi}\index{tipi, nella logica HOL@tipi, nella logica \HOL{}} % \index{costanti di tipo, nella logica HOL@costanti di tipo, nella logica \HOL{}} % -sono state dichiarate nella teoria corrente. Si veda la Sezione~\ref{theoryfns} -per i dettagli di come tali dichiarazioni sono fatte. Ci sono due funzioni -primitive +sono state dichiarate nella teoria corrente. Si veda la Sezione~\ref{theoryfns} +per i dettagli di come tali dichiarazioni sono fatte. Ci sono due funzioni +primitive % \index{tipi, nella logica HOL@tipi, nella logica \HOL{}!costruttori per} \index{costruttori di tipo!nella logica HOL@nella logica \HOL{}} @@ -190,26 +190,26 @@ \section{Tipi}\index{tipi, nella logica HOL@tipi, nella logica \HOL{}} \end{verbatim} \end{holboxed} % -La funzione \ml{mk\_vartype} costruisce una variabile di tipo +La funzione \ml{mk\_vartype} costruisce una variabile di tipo % \index{variabili di tipo, nella logica HOL@variabili di tipo, nella logica \HOL{}!costruttori per} % -con un nome dato; essa da un warning se il nome non un nome ammissibile -per una variabile di tipo (cio non un \ml{'} seguito da un alfanumerico). -La funzione \ml{mk\_thy\_type} costruisce un tipo composto +con un nome dato; essa da un warning se il nome non un nome ammissibile +per una variabile di tipo (cio non un \ml{'} seguito da un alfanumerico). +La funzione \ml{mk\_thy\_type} costruisce un tipo composto % \index{tipi composti, nella logica HOL@tipi composti, nella logica \HOL{}!costruttori per} % -da un record \ml{\lb Tyop,Thy,Args\rb{}} dove \ml{Tyop} una stringa -che rappresenta il nome di un operatore di tipo, \ml{Thy} una stringa -che rappresenta la teoria in cui \ml{Tyop} stato dichiarato, e \ml{Args} - una lista di tipi che rappresentano gli argomenti dell'operatore. -I tipi funzione $\sigma_1\fun\sigma_2$ della logica sono rappresentati in -\ML{} come se fossero tipi composti $(\sigma_1,\sigma_2)$\ml{fun} -(in \LOGIC, tuttavia, i tipi funzioni non erano considerati come tipi +da un record \ml{\lb Tyop,Thy,Args\rb{}} dove \ml{Tyop} una stringa +che rappresenta il nome di un operatore di tipo, \ml{Thy} una stringa +che rappresenta la teoria in cui \ml{Tyop} stato dichiarato, e \ml{Args} + una lista di tipi che rappresentano gli argomenti dell'operatore. +I tipi funzione $\sigma_1\fun\sigma_2$ della logica sono rappresentati in +\ML{} come se fossero tipi composti $(\sigma_1,\sigma_2)$\ml{fun} +(in \LOGIC, tuttavia, i tipi funzioni non erano considerati come tipi composti). -La valutazione di +La valutazione di $\ml{mk\_thy\_type}\{\ml{Tyop} = \mathit{name},\ \ml{Thy} = \mathit{thyname},\ \ml{Args} = [\sigma_1, \cdots ,\sigma_n]\}$ @@ -229,14 +229,14 @@ \section{Tipi}\index{tipi, nella logica HOL@tipi, nella logica \HOL{}} % %\paragraph{Support for constructing types} -Le costanti di tipo possono essere -legate a valori \ML\ e non hanno bisogno di essere costruiti ripetutamente, ad esempio il tipo costruito da\linebreak -\ml{mk\_thy\_type\lb{}Tyop="bool", Thy="bool", Args=[]\rb{}} abbreviato -dal valore \ML\ \ml{bool}. Analogamente, i tipi funzione possono essere costruiti -con la funzione infissa \ML\ \ml{-->}. Alcune variabili di tipo comuni -sono state costruite e legate a identificatori \ML{}, ad esempio, \ml{alpha} - la variabile di tipo \ml{'a} e \ml{beta} la variabile di tipo -\ml{'b}. Cos il codice \ML\ \ml{alpha --> bool} uguale a, ma molto pi conciso di +Le costanti di tipo possono essere +legate a valori \ML\ e non hanno bisogno di essere costruiti ripetutamente, ad esempio il tipo costruito da\linebreak +\ml{mk\_thy\_type\lb{}Tyop="bool", Thy="bool", Args=[]\rb{}} abbreviato +dal valore \ML\ \ml{bool}. Analogamente, i tipi funzione possono essere costruiti +con la funzione infissa \ML\ \ml{-->}. Alcune variabili di tipo comuni +sono state costruite e legate a identificatori \ML{}, ad esempio, \ml{alpha} + la variabile di tipo \ml{'a} e \ml{beta} la variabile di tipo +\ml{'b}. Cos il codice \ML\ \ml{alpha --> bool} uguale a, ma molto pi conciso di % \begin{hol} \begin{verbatim} @@ -270,22 +270,22 @@ \section{Tipi}\index{tipi, nella logica HOL@tipi, nella logica \HOL{}} \index{variabili di tipo, nella logica HOL@variabili di tipo, nella logica \HOL{}!de-costruttori per} \index{tipi composti, nella logica HOL@tipi composti, nella logica \HOL{}!de-costruttori per} % -estrae il nome di una variabile di tipo. Un tipo composto de-costruito -dalla funzione \ml{dest\_thy\_type} nel nome dell'operatore -di tipo, il nome della teoria in cui esso fu dichiarato, e una lista dei -tipi argomento; \ml{dest\_vartype} e \ml{dest\_thy\_type} sono cos +estrae il nome di una variabile di tipo. Un tipo composto de-costruito +dalla funzione \ml{dest\_thy\_type} nel nome dell'operatore +di tipo, il nome della teoria in cui esso fu dichiarato, e una lista dei +tipi argomento; \ml{dest\_vartype} e \ml{dest\_thy\_type} sono cos le inverse di \ml{mk\_vartype} e \ml{mk\_thy\_type}, rispettivamente. I de-costruttori falliscono su argomenti della forma sbagliata. \section{Termini}\label{sec:system-terms} -Le quattro specie primitive di termini della logica sono descritte in -\LOGIC. Le funzioni \ML\ per manipolarle sono descritte in -questa sezione. Ci sono anche termini \emph{derivati} che sono descritti +Le quattro specie primitive di termini della logica sono descritte in +\LOGIC. Le funzioni \ML\ per manipolarle sono descritte in +questa sezione. Ci sono anche termini \emph{derivati} che sono descritti nella Sezione~\ref{derived-terms}. -In qualunque momento, i termini che possono essere costruiti dipendono da quali -costanti sono state dichiarate nella teoria corrente. Si veda +In qualunque momento, i termini che possono essere costruiti dipendono da quali +costanti sono state dichiarate nella teoria corrente. Si veda la Sezione~\ref{theoryfns} per i dettagli su come sono fatte queste dichiarazioni. Ci sono quattro funzioni primitive @@ -301,7 +301,7 @@ \section{Termini}\label{sec:system-terms} \end{verbatim} \end{holboxed} -\noindent\ml{mk\_var($x$,$\sigma$)} valutata a una variabile +\noindent\ml{mk\_var($x$,$\sigma$)} valutata a una variabile con nome $x$ e tipo $\sigma$; essa ha sempre successo. \begin{holboxed} @@ -341,7 +341,7 @@ \section{Termini}\label{sec:system-terms} $t_1\ t_2$. Essa fallisce se: \begin{myenumerate} \item il tipo di $t_1$ non ha la forma \ml{$\sigma'$->$\sigma$}; -\item il tipo di $t_1$ ha la forma \ml{$\sigma'$->$\sigma$}, ma il +\item il tipo di $t_1$ ha la forma \ml{$\sigma'$->$\sigma$}, ma il tipo di $t_2$ non uguale a $\sigma'$. \end{myenumerate} @@ -352,8 +352,8 @@ \section{Termini}\label{sec:system-terms} \end{verbatim} \end{holboxed} -\noindent\ml{mk\_abs($x$,$t$)} valutato a un termine che rappresenta -l'astrazione +\noindent\ml{mk\_abs($x$,$t$)} valutato a un termine che rappresenta +l'astrazione % \index{astrazione di funzione, nella logica HOL@astrazione di funzione, nella logica \HOL{}!costruttore per} % @@ -385,7 +385,7 @@ \section{Termini}\label{sec:system-terms} \end{holboxed} Queste sono le inverse di \ml{mk\_var}, \ml{mk\_thy\_const}, -\ml{mk\_comb} e \ml{mk\_abs}, rispettivamente. Esse falliscono quando applicate +\ml{mk\_comb} e \ml{mk\_abs}, rispettivamente. Esse falliscono quando applicate a termini della forma sbagliata. Altre utili funzioni di de-costruzione sono \ml{rator}\index{rator@\ml{rator}}, \ml{rand}\index{rand@\ml{rand}}, @@ -405,7 +405,7 @@ \section{Termini}\label{sec:system-terms} \noindent restituisce il tipo \index{tipi, nella logica HOL@tipi, nella logica \HOL{}!determinazione di} -di un termine. La funzione +di un termine. La funzione \begin{holboxed}\index{aconv@\ml{aconv}|pin} \begin{verbatim} @@ -418,10 +418,10 @@ \section{Termini}\label{sec:system-terms} % \index{$\alpha$-convertibil, nella logica HOL@$\alpha$-convertibil, nella logica \HOL{}!determinazione di} % -Dal punto di vista della logica \HOL{}, i termini $\alpha$-convertibili -sono identici. Una variet di altre funzioni sono disponibili per +Dal punto di vista della logica \HOL{}, i termini $\alpha$-convertibili +sono identici. Una variet di altre funzioni sono disponibili per eseguire la $\beta$-riduzione (\ml{beta\_conv}), l'$\eta$-riduzione -(\ml{eta\_conv}), la sostituzione (\ml{subst}), l'istanziazione di tipo (\ml{inst}), la computazione delle variabili libere (\ml{free\_vars}) e +(\ml{eta\_conv}), la sostituzione (\ml{subst}), l'istanziazione di tipo (\ml{inst}), la computazione delle variabili libere (\ml{free\_vars}) e altre operazioni comuni sui termini. Si veda \REFERENCE{} per maggiori dettagli. @@ -432,16 +432,16 @@ \section{Quotation} \index{ type quotes, in ML@\ml{\dq:$\cdots$\dq} (type quotes, in \ML)|(} \index{ term quotes, in ML@\ml{\dq$\cdots$\dq} (term quotes, in \ML)|(} -Sarebbe noioso dover sempre immettere tipi e termini -usando le funzioni costruttore. Il sistema \HOL{}, adattando -l'approccio preso in \LCF\index{LCF@\LCF}, ha dei parser -speciali per le quotation +Sarebbe noioso dover sempre immettere tipi e termini +usando le funzioni costruttore. Il sistema \HOL{}, adattando +l'approccio preso in \LCF\index{LCF@\LCF}, ha dei parser +speciali per le quotation \index{quotation, nella logica HOL@quotation, nella logica \HOL{}!parser per} \index{parsing, della logica HOL@parsing, della logica \HOL{}!delle quotation di sintassi} -per tipi e termini \HOL{} che permettono di immettere -tipi e termini usando una sintassi abbastanza standard. Per esempio, -l'espressione \ML{} $\holquote{\ml{:bool -> bool}}$ denota esattamente lo stesso -valore (con tipo \ML\ \ml{hol\_type}) di +per tipi e termini \HOL{} che permettono di immettere +tipi e termini usando una sintassi abbastanza standard. Per esempio, +l'espressione \ML{} $\holquote{\ml{:bool -> bool}}$ denota esattamente lo stesso +valore (con tipo \ML\ \ml{hol\_type}) di \begin{hol} \index{bool, the type nella logica HOL@\ml{bool}, the type nella logica \HOL{}} @@ -456,9 +456,9 @@ \section{Quotation} % \index{astrazione di funzione, nella logica HOL@astrazione di funzione, nella logica \HOL{}} % -pu essere usata al posto di\footnote{Per poter essere elaborata con successo - questa quotation richiede che la teoria dell'aritmetica sia gi - stata caricata, il che si pu ottenere nel sistema interattivo attraverso +pu essere usata al posto di\footnote{Per poter essere elaborata con successo + questa quotation richiede che la teoria dell'aritmetica sia gi + stata caricata, il che si pu ottenere nel sistema interattivo attraverso \ml{load "arithmeticTheory"}.} \begin{hol} @@ -478,8 +478,8 @@ \section{Quotation} \end{verbatim} \end{hol} -Il printer \HOL{}, che integrato nel loop toplevel \ML{}, -mostra in output anche i tipi e i termini usando questa sintassi. +Il printer \HOL{}, che integrato nel loop toplevel \ML{}, +mostra in output anche i tipi e i termini usando questa sintassi. % \index{stampa, nella logica HOL@stampa, nella logica \HOL{}!della sintassi delle quotation} % @@ -487,43 +487,43 @@ \section{Quotation} % \index{stampa, nella logica HOL@stampa, nella logica \HOL{}!dei tipi} % -nella forma \holquote{\ml{:}\textit{type}}. Per esempio, il valore \ML\ -di tipo \ml{hol\_type} che rappresenta -$\alpha\fun(\ty{ind}\fun\ty{bool})$ sarebbe stampato +nella forma \holquote{\ml{:}\textit{type}}. Per esempio, il valore \ML\ +di tipo \ml{hol\_type} che rappresenta +$\alpha\fun(\ty{ind}\fun\ty{bool})$ sarebbe stampato come \ml{\holquote{:'a -> ind -> bool}}. -Analogamente, i termini sono stampati nella forma \holquote{\textit{term}}. -Cos, il termine che rappresenta $\uquant{x\ y}x ?z. x + z = y}} \] % -Un segno iniziale di due punti usato per distinguere una quotation di tipo da una quotation di termine: -la prima ha la forma \holquote{\ml{:}~$\cdots$~} e il secondo ha +Un segno iniziale di due punti usato per distinguere una quotation di tipo da una quotation di termine: +la prima ha la forma \holquote{\ml{:}~$\cdots$~} e il secondo ha la forma \holquote{~$\cdots$~}. \index{quotation, nella logica HOL@quotation, nella logica \HOL{}|)} -La Sessione~\ref{sec:parsing-printing} ha informazioni pi dettagliate circa -le capacit delle funzioni di parsing e stampa di termini e tipi -nel sistema. Il resto di questa sezione fornisce una breve +La Sessione~\ref{sec:parsing-printing} ha informazioni pi dettagliate circa +le capacit delle funzioni di parsing e stampa di termini e tipi +nel sistema. Il resto di questa sezione fornisce una breve panoramica di ci che possibile. \subsection{Inferenza di tipo} \index{inferenza di tipo!nel parser HOL@nel parser \HOL{}|(} % -Si noti che non c' alcuna informazione esplicita di tipo in -\holtxt{\bs{}x.x+1}. Il type checker \HOL{} sa che \ml{1} ha -il tipo \holtxt{num} e \holtxt{+} ha il tipo \holtxt{num->(num->num)}. -Da questa informazione esso pu inferire che entrambe le occorrenze di \ml{x} in -\holtxt{\bs{}x.x+1} potrebbero avere il tipo \holtxt{num}. Questa non -l'unica assegnazione di tipo possibile; per esempio, la prima occorrenza di -\holtxt{x} potrebbe avere il tipo \holtxt{bool} e la seconda avere il tipo -\holtxt{num}. In quel caso ci sarebbero due variabili -\emph{differenti} con nome \holtxt{x}, cio \holtxt{x}$_{\holtxt{bool}}$ e -\holtxt{x}$_{\holtxt{num}}$, la seconda delle quali libera. Tuttavia, -l'unico modo di costruire in termine con questa seconda assegnazione di tipo -usando dei costruttori, dal momento che il type checker usa l'euristica che tutte -le variabili in un termine con lo stesso nome hanno lo stesso tipo. Questo +Si noti che non c' alcuna informazione esplicita di tipo in +\holtxt{\bs{}x.x+1}. Il type checker \HOL{} sa che \ml{1} ha +il tipo \holtxt{num} e \holtxt{+} ha il tipo \holtxt{num->(num->num)}. +Da questa informazione esso pu inferire che entrambe le occorrenze di \ml{x} in +\holtxt{\bs{}x.x+1} potrebbero avere il tipo \holtxt{num}. Questa non +l'unica assegnazione di tipo possibile; per esempio, la prima occorrenza di +\holtxt{x} potrebbe avere il tipo \holtxt{bool} e la seconda avere il tipo +\holtxt{num}. In quel caso ci sarebbero due variabili +\emph{differenti} con nome \holtxt{x}, cio \holtxt{x}$_{\holtxt{bool}}$ e +\holtxt{x}$_{\holtxt{num}}$, la seconda delle quali libera. Tuttavia, +l'unico modo di costruire in termine con questa seconda assegnazione di tipo +usando dei costruttori, dal momento che il type checker usa l'euristica che tutte +le variabili in un termine con lo stesso nome hanno lo stesso tipo. Questo illustrato nella sessione seguente. % \setcounter{sessioncount}{0} @@ -550,7 +550,7 @@ \subsection{Inferenza di tipo} \end{verbatim} \end{session} -Il valore desiderato pu essere costruito direttamente per mezzo delle funzioni costruttore +Il valore desiderato pu essere costruito direttamente per mezzo delle funzioni costruttore primitive: \begin{session} @@ -563,17 +563,17 @@ \subsection{Inferenza di tipo} \end{verbatim} \end{session} -Il type checker delle quotation originario fu progettato e implementato da -Robin milner\index{Milner, R.}. Esso sfrutta delle euristiche come quella +Il type checker delle quotation originario fu progettato e implementato da +Robin milner\index{Milner, R.}. Esso sfrutta delle euristiche come quella di sopra per inferire un tipo sensato per tutte le variabili che occorrono in un termine. -\index{vincoli di tipo!nella logica HOL@nella logica \HOL{}} A volte, -l'utente pu voler controllare il tipo esatto di un sottotermine. Per supportare tale -funzionalit, i tipo possono essere indicati esplicitamente facendo seguire a qualsiasi -termine un simbolo di due punti e poi un tipo. Per esempio, dato -\holtxt{\dq{}f(x:num):bool\dq} il type checker assegner a \holtxt{f} il tipo -\holtxt{num->bool} e a \holtxt{x} il tipo -\holtxt{num}. Questo trattamento dei tipi all'interno delle quotation ereditato +\index{vincoli di tipo!nella logica HOL@nella logica \HOL{}} A volte, +l'utente pu voler controllare il tipo esatto di un sottotermine. Per supportare tale +funzionalit, i tipo possono essere indicati esplicitamente facendo seguire a qualsiasi +termine un simbolo di due punti e poi un tipo. Per esempio, dato +\holtxt{\dq{}f(x:num):bool\dq} il type checker assegner a \holtxt{f} il tipo +\holtxt{num->bool} e a \holtxt{x} il tipo +\holtxt{num}. Questo trattamento dei tipi all'interno delle quotation ereditato da \LCF. % \index{LCF@\LCF} @@ -585,15 +585,15 @@ \subsection{Visualizzare la grammatica} \index{parsing, della logica HOL@parsing, della logica \HOL{}!grammatiche per il} \index{stampa, nella logica HOL@stampa, nella logica \HOL{}!grammatiche per la} -Il comportamento del parser e del printer di \HOL{} determinato -dalla grammatica corrente. Cos, importante una familiarit con il vocabolario -della collezione standard di teorie di \HOL{} se si vuole usare -\HOL{} in modo efficace. Si pu esaminare la grammatica attuale usata +Il comportamento del parser e del printer di \HOL{} determinato +dalla grammatica corrente. Cos, importante una familiarit con il vocabolario +della collezione standard di teorie di \HOL{} se si vuole usare +\HOL{} in modo efficace. Si pu esaminare la grammatica attuale usata dal parser con le funzioni \verb+type_grammar+ e \verb+term_grammar+. -Per esempio, nella seguente sessione, vediamo che la grammatica dei tipi -usata nel contesto di avvio di \HOL{} ha gli operatori di tipo +Per esempio, nella seguente sessione, vediamo che la grammatica dei tipi +usata nel contesto di avvio di \HOL{} ha gli operatori di tipo \verb+fun+, \verb+sum+, \verb+prod+, \verb+list+, \verb+recspace+, \verb+num+, \verb+option+, \verb+one+, \verb+label+, \verb+ind+, and \verb+bool+. @@ -613,19 +613,19 @@ \subsection{Visualizzare la grammatica} \end{verbatim} \end{session} -Inoltre, \verb+fun+, \verb+sum+, e \verb+prod+ hanno le notazioni -infisse (\verb+->+), (\verb|+|), e (\verb+#+), rispettivamente, con -differenti precedenze: \verb+#+ (con 70) lega in modo pi forte di -\verb|+| (60), che lega pi forte di \verb+->+ (50). Tutti gli +Inoltre, \verb+fun+, \verb+sum+, e \verb+prod+ hanno le notazioni +infisse (\verb+->+), (\verb|+|), e (\verb+#+), rispettivamente, con +differenti precedenze: \verb+#+ (con 70) lega in modo pi forte di +\verb|+| (60), che lega pi forte di \verb+->+ (50). Tutti gli operatori di tipo suffissi (con 100) legano pi fortemente di quelli infissi. -La prossima sessione, nella Figura~\ref{fig:term-grammar}, mostra -l'output (abbreviato) dell'invocazione della funzione \ml{term\_grammar} -nell'ambiente di avvio di \HOL{}. L'output omesso include un elenco -di tutte le costanti conosciute dal sistema, inclusi gli operatori prefissi, -insieme con tutti gli overload attualmente attivi. La grammatica ritratta -varia da operatori di binding con forza di binding molto bassa (0), -fino all'applicazione di funzione (2000) e alla selezione di record (2500), +La prossima sessione, nella Figura~\ref{fig:term-grammar}, mostra +l'output (abbreviato) dell'invocazione della funzione \ml{term\_grammar} +nell'ambiente di avvio di \HOL{}. L'output omesso include un elenco +di tutte le costanti conosciute dal sistema, inclusi gli operatori prefissi, +insieme con tutti gli overload attualmente attivi. La grammatica ritratta +varia da operatori di binding con forza di binding molto bassa (0), +fino all'applicazione di funzione (2000) e alla selezione di record (2500), che legano molto strettamente. \setcounter{sessioncount}{0} @@ -685,15 +685,15 @@ \subsection{Visualizzare la grammatica} \subsection{Controllo di namespace} -Per convenienza, il parser tratta con l'overload e -l'ambiguit. L'overload di letterali numerici discusso nella -Sessione~\ref{arith-overloading}, bench a qualunque simbolo si possa applicare -l'overload, non solo i numerali. A volte una tale flessibilit piuttosto -utile; comunque, pu accadere che si voglia designare in modo esplicito -una costante particolare. In quel caso, la notazione -$\mathit{thy}\holtxt{\$}\mathit{const}$ pu essere usata nel parser per -designare la costante $\mathit{const}$ dichiarata nella teoria -$\mathit{thy}$. Nell'esempio seguente, esplicitamente specificato +Per convenienza, il parser tratta con l'overload e +l'ambiguit. L'overload di letterali numerici discusso nella +Sessione~\ref{arith-overloading}, bench a qualunque simbolo si possa applicare +l'overload, non solo i numerali. A volte una tale flessibilit piuttosto +utile; comunque, pu accadere che si voglia designare in modo esplicito +una costante particolare. In quel caso, la notazione +$\mathit{thy}\holtxt{\$}\mathit{const}$ pu essere usata nel parser per +designare la costante $\mathit{const}$ dichiarata nella teoria +$\mathit{thy}$. Nell'esempio seguente, esplicitamente specificato l'operatore minore-di. \setcounter{sessioncount}{0} @@ -703,9 +703,9 @@ \subsection{Controllo di namespace} > val it = ``x < y`` : term \end{verbatim} \end{session} -Si noti come il simbolo \holtxt{<} non sia trattato come un infisso dal -parser quando fornito nella sua forma ``fully-qualified''. Dal punto di vista sintattico, a tali -token non mai dato un trattamento speciale dal parser della sintassi +Si noti come il simbolo \holtxt{<} non sia trattato come un infisso dal +parser quando fornito nella sua forma ``fully-qualified''. Dal punto di vista sintattico, a tali +token non mai dato un trattamento speciale dal parser della sintassi concreta di \HOL. % \index{costanti, nella logica HOL@costanti, nella logica \HOL{}!nomi di ... fully-qualified} @@ -716,7 +716,7 @@ \section{Modi di Costruire Tipi e Termini} \index{costruttori di tipo!nella logica HOL@nella logica \HOL{}} \index{costruttori di termine, nella logica HOL@costruttori di termine, nella logica \HOL{}|(} \index{termini, nella logica HOL@termini, nella logica \HOL{}!costruttori per|(} -La tabella di sotto mostra l'espressioni \ML\ per varie specie di quotazioni +La tabella di sotto mostra l'espressioni \ML\ per varie specie di quotazioni di tipo\index{quotation, nella logica HOL@quotation, nella logica \HOL{}!di tipi}. L'espressioni nella stessa riga sono equivalenti. @@ -761,7 +761,7 @@ \section{Modi di Costruire Tipi e Termini} \end{center} -Modi equivalenti di immettere le quattro specie di termini primitivi sono mostrati nella +Modi equivalenti di immettere le quattro specie di termini primitivi sono mostrati nella prossima tabella. \bigskip @@ -806,7 +806,7 @@ \section{Modi di Costruire Tipi e Termini} % \index{type checking, nella logica HOL@type checking, nella logica \HOL{}!delle quotation di sintassi|)} -In aggiunta alle specie di termini nella tabella di sopra, il parser supporta +In aggiunta alle specie di termini nella tabella di sopra, il parser supporta anche le seguenti abbreviazioni sintattiche. @@ -846,12 +846,12 @@ \section{Teoremi} % \index{sequenti!nella deduzione naturale} % -dove un sequente una coppia il cui secondo componente una formula che viene +dove un sequente una coppia il cui secondo componente una formula che viene asserita (una conclusione), % \index{conclusioni!di sequenti} % -e il cui primo componente un insieme di formule +e il cui primo componente un insieme di formule (ipotesi). % \index{ipotesi!di sequenti} @@ -861,29 +861,29 @@ \section{Teoremi} \index{deduzione naturale} \index{sistemi deduttivi} % -un insieme di coppie, il cui secondo componente un sequente, e il cui primo -componente un insieme di sequenti\footnote{Si noti che questi sequenti formano - una lista, non un insieme; cio, sono ordinati.}. Fu quindi definito il concetto di un sequente -\textit{che segue da} +un insieme di coppie, il cui secondo componente un sequente, e il cui primo +componente un insieme di sequenti\footnote{Si noti che questi sequenti formano + una lista, non un insieme; cio, sono ordinati.}. Fu quindi definito il concetto di un sequente +\textit{che segue da} % \index{segue da, nella deduzione naturale} % -un insieme di sequenti attraverso un sistema deduttivo: un sequente -segue da un insieme di sequenti se il sequente l'ultimo elemento di -qualche catena di sequenti, ognuno dei cui elementi o nell'insieme, -o esso stesso segue dall'insieme attraverso elementi precedenti della +un insieme di sequenti attraverso un sistema deduttivo: un sequente +segue da un insieme di sequenti se il sequente l'ultimo elemento di +qualche catena di sequenti, ognuno dei cui elementi o nell'insieme, +o esso stesso segue dall'insieme attraverso elementi precedenti della catena, attraverso il sistema deduttivo. -\index{notazione turnstile|(} E' stata poi introdotta una notazione per `segue -da'. Il fatto che un sequente\linebreak $(\{t_1,\ldots,t_n\},\ t)$ segua da un -insieme di sequenti $\Delta$, attraverso un sistema deduttivo ${\cal D}$, -denotato da: $t_1,\ldots,t_n\vdash_{{\cal D},\Delta} t$. (E' stato notato -che dove sia ${\cal D}$ sia $\Delta$ sono fossero chiari dal contesto, la loro -menzione potrebbe essere omessa; e dove l'insieme delle ipotesi fosse vuoto, +\index{notazione turnstile|(} E' stata poi introdotta una notazione per `segue +da'. Il fatto che un sequente\linebreak $(\{t_1,\ldots,t_n\},\ t)$ segua da un +insieme di sequenti $\Delta$, attraverso un sistema deduttivo ${\cal D}$, +denotato da: $t_1,\ldots,t_n\vdash_{{\cal D},\Delta} t$. (E' stato notato +che dove sia ${\cal D}$ sia $\Delta$ sono fossero chiari dal contesto, la loro +menzione potrebbe essere omessa; e dove l'insieme delle ipotesi fosse vuoto, la sua menzione potrebbe essere omessa.) -Un sequente che segue dall'insieme vuoto di sequenti attraverso un sistema -deduttivo chiamato un \textit{teorema} di quel sistema deduttivo. In altre +Un sequente che segue dall'insieme vuoto di sequenti attraverso un sistema +deduttivo chiamato un \textit{teorema} di quel sistema deduttivo. In altre parole, un teorema % \index{teoremi, nella deduzione naturale} @@ -892,35 +892,35 @@ \section{Teoremi} % \index{dimostrazione!nella deduzione naturale} % -(nel senso di \LOGIC) dall'insieme vuoto di sequenti. Quando una coppia -$(L,(\Gamma,t))$ appartiene a un sistema deduttivo, e la lista $L$ -vuota, allora il sequente $(\Gamma,t)$ chiamato un -\textit{assioma}\index{assiomi!nella deduzione naturale}. Qualsiasi coppia -$(L,(\Gamma,t))$ appartenente a un sistema deduttivo chiamata una +(nel senso di \LOGIC) dall'insieme vuoto di sequenti. Quando una coppia +$(L,(\Gamma,t))$ appartiene a un sistema deduttivo, e la lista $L$ +vuota, allora il sequente $(\Gamma,t)$ chiamato un +\textit{assioma}\index{assiomi!nella deduzione naturale}. Qualsiasi coppia +$(L,(\Gamma,t))$ appartenente a un sistema deduttivo chiamata una \textit{inferenza primitiva}\index{inferenza, nella deduzione - naturale}\index{inferenza primitiva, nella deduzione naturale} del -sistema, con ipotesi\footnote{Si noti che `ipotesi' e - `conclusione' sono usate anche per le componenti dei sequenti.} $L$ e + naturale}\index{inferenza primitiva, nella deduzione naturale} del +sistema, con ipotesi\footnote{Si noti che `ipotesi' e + `conclusione' sono usate anche per le componenti dei sequenti.} $L$ e conclusione $(\Gamma,t)$. Una formula % \index{formule come termini, nella logica HOL@formule come termini, nella logica \HOL{}} % -in astratto rappresentata concretamente in \HOL{} da un termine il cui +in astratto rappresentata concretamente in \HOL{} da un termine il cui tipo \HOL{} \holtxt{:bool}. Perci, un termine % \index{termini, nella logica HOL@termini, nella logica \HOL{}!come formule logiche} % -di tipo \holtxt{:bool} usato per rappresentare un membro dell'insieme di -ipotesi di un sequente; e allo stesso modo per rappresentare la conclusione di un -sequente. Gli insiemi in questo contesto sono rappresentati da un'implementazione della -firma \ML{} \ml{HOLset} che supporta operazioni come +di tipo \holtxt{:bool} usato per rappresentare un membro dell'insieme di +ipotesi di un sequente; e allo stesso modo per rappresentare la conclusione di un +sequente. Gli insiemi in questo contesto sono rappresentati da un'implementazione della +firma \ML{} \ml{HOLset} che supporta operazioni come \ml{member} e \ml{union}. % \index{sequenti!rappresentazione dei, nella logica HOL@rappresentazione dei, nella logica \HOL{}} -Un teorema in astratto rappresentato concretamente nel sistema +Un teorema in astratto rappresentato concretamente nel sistema \HOL{} da un valore con il tipo \ML{} astratto \ml{thm}. % \index{thm (tipo ML)@\ml{thm} (tipo \ML{})} @@ -934,14 +934,14 @@ \section{Teoremi} \end{verbatim} \end{holboxed} -\noindent che restituisce una coppia che consiste, rispettivamente, di una lista delle -ipotesi -\index{ipotesi!di teoremi} +\noindent che restituisce una coppia che consiste, rispettivamente, di una lista delle +ipotesi +\index{ipotesi!di teoremi} e della conclusione, \index{conclusioni!di teoremi} % -di un teorema. Non si dovrebbe fare affidamento sull'ordine delle assunzioni -nella lista. Le ipotesi di un teorema sono disponibili anche nella forma +di un teorema. Non si dovrebbe fare affidamento sull'ordine delle assunzioni +nella lista. Le ipotesi di un teorema sono disponibili anche nella forma di insieme con la funzione \begin{holboxed} @@ -951,9 +951,9 @@ \section{Teoremi} \end{verbatim} \end{holboxed} -Usando \ml{dest\_thm}, sono derivate ulteriori funzioni di +Usando \ml{dest\_thm}, sono derivate ulteriori funzioni di \index{teoremi, nella logica HOL@teoremi, nella logica \HOL{}!de-costruttori per} -de-costruzione +de-costruzione \begin{holboxed} \index{hyp@\ml{hyp}|pin} @@ -964,28 +964,28 @@ \section{Teoremi} \end{verbatim} \end{holboxed} -\noindent per estrarre, rispettivamente, la lista delle ipotesi e la conclusione -di un teorema. Il tipo \ML\ non ha -una funzione costruttore primitiva. In questo modo, il sistema di tipi \ML{} protegge -la logica \HOL{} -dalla costruzione arbitraria e non tracciata -di teoremi, che comprometterebbero -la coerenza\index{coerenza, della logica HOL@coerenza, della logica \HOL{}} della logica. -(Le funzioni che restituiscono teoremi come valori, ad esempio le funzioni che rappresentano inferenze primitive, +\noindent per estrarre, rispettivamente, la lista delle ipotesi e la conclusione +di un teorema. Il tipo \ML\ non ha +una funzione costruttore primitiva. In questo modo, il sistema di tipi \ML{} protegge +la logica \HOL{} +dalla costruzione arbitraria e non tracciata +di teoremi, che comprometterebbero +la coerenza\index{coerenza, della logica HOL@coerenza, della logica \HOL{}} della logica. +(Le funzioni che restituiscono teoremi come valori, ad esempio le funzioni che rappresentano inferenze primitive, sono discusse nella Sezione~\ref{rules}.) %% derived-rules reference is dead for the moment (until we %% resuscitate drules.tex) %, and further in Chapter\ref{derived-rules}.) -In \LOGIC stato menzionato che il sistema deduttivo di \HOL{} -include quattro assiomi\footnote{Questa una semplificazione: di fatto i - vari assiomi sono un'estensione della logica di base.}. In quel -manuale, gli assiomi sono stati presentati in forma astratta. Concretamente, -gli assiomi sono semplicemente valori teorema che sono introdotti attraverso l'uso della -funzione \ML{} \ml{new\_axiom} (si veda la Sessione~\ref{theoryprims} -di sotto). Per esempio, l'assioma \ml{BOOL\_CASES\_AX} menzionato in +In \LOGIC stato menzionato che il sistema deduttivo di \HOL{} +include quattro assiomi\footnote{Questa una semplificazione: di fatto i + vari assiomi sono un'estensione della logica di base.}. In quel +manuale, gli assiomi sono stati presentati in forma astratta. Concretamente, +gli assiomi sono semplicemente valori teorema che sono introdotti attraverso l'uso della +funzione \ML{} \ml{new\_axiom} (si veda la Sessione~\ref{theoryprims} +di sotto). Per esempio, l'assioma \ml{BOOL\_CASES\_AX} menzionato in \LOGIC{} stampato in \HOL{} come segue (dove \ml{T} e -\ml{F} sono le costanti della logica \HOL{} che rappresentano la verit e +\ml{F} sono le costanti della logica \HOL{} che rappresentano la verit e la falsit, rispettivamente): \begin{hol} @@ -999,17 +999,17 @@ \section{Teoremi} Si noti lo speciale formato di stampa, \index{stampa, nella logica HOL@stampa, nella logica \HOL{}!dei teoremi} % -con l'approssimazione +con l'approssimazione alla notazione astratta $\vdash$, % \index{notazione dei teoremi, nella logica HOL@notazione dei teoremi, nella logica \HOL{}|(} % -\ml{|-}, usata per indicare lo status di tipo \ML{} \ml{thm}; insieme con -l'assenza dei segni di quotation \HOL{} +\ml{|-}, usata per indicare lo status di tipo \ML{} \ml{thm}; insieme con +l'assenza dei segni di quotation \HOL{} % \index{ segno di teorema, nella logica HOL@\ml{"|-} (segno di teorema, nella logica \HOL{})} % -nel contesto \ml{|-}. La sessione di sotto illustra l'uso delle +nel contesto \ml{|-}. La sessione di sotto illustra l'uso delle funzioni di de-costruzione: \setcounter{sessioncount}{0} @@ -1030,13 +1030,13 @@ \section{Teoremi} \end{session} \index{notazione turnstile|)} -\noindent In aggiunta alle convenzioni di stampa menzionate di sopra, la -stampa di teoremi stampa le ipotesi -\index{stampa, nella logica HOL@stampa, nella logica \HOL{}!delle ipotesi dei teoremi} +\noindent In aggiunta alle convenzioni di stampa menzionate di sopra, la +stampa di teoremi stampa le ipotesi +\index{stampa, nella logica HOL@stampa, nella logica \HOL{}!delle ipotesi dei teoremi} come dei punti (cio un singolo punto di conclusione o dei puntini). Il flag \ml{show\_assums} -\index{show_assums@\ml{show\_assums}} permette di stampare i teoremi -con le ipotesi mostrate in modo completo. Questi punti sono illustrati con un -teorema inferito, a scopo di esempio, da un altro assioma menzionato +\index{show_assums@\ml{show\_assums}} permette di stampare i teoremi +con le ipotesi mostrate in modo completo. Questi punti sono illustrati con un +teorema inferito, a scopo di esempio, da un altro assioma menzionato in \LOGIC, \ml{SELECT\_AX}. \begin{session} @@ -1058,43 +1058,43 @@ \section{Regole Primitive d'Inferenza della Logica \HOL{}} \index{regole d'inferenza, della logica HOL@regole d'inferenza, della logica \HOL{}!primitive|(} % -Le regole primitive d'inferenza della logica sono state descritte +Le regole primitive d'inferenza della logica sono state descritte in astratto in \LOGIC. Le descrizioni si basavano su meta-variabili $t$, -$t_1$, $t_2$, e cos via. Nella logica \HOL{}, infinite famiglie di -inferenze primitive sono raggruppate insieme e pensate come singoli +$t_1$, $t_2$, e cos via. Nella logica \HOL{}, infinite famiglie di +inferenze primitive sono raggruppate insieme e pensate come singoli schemi primitivi di inferenza. % % \index{famiglie d'inferenze, nella logica HOL@famiglie d'inferenze, nella logica \HOL{}} % -Ciascuna famiglia contiene tutte le istanze concrete di un particolare -`pattern' d'inferenza. Queste possono essere prodotte, in astratto, -istanziando le meta-variabili delle regole in \LOGIC\ su termini +Ciascuna famiglia contiene tutte le istanze concrete di un particolare +`pattern' d'inferenza. Queste possono essere prodotte, in astratto, +istanziando le meta-variabili delle regole in \LOGIC\ su termini concreti. -In \HOL, gli schemi primitivi d'inferenza sono rappresentati da funzioni \ML{} -che restituiscono teoremi come valori. Cio, per particolari termini \HOL{}, -le funzioni \ML{} restituiscono l'istanza del teorema per quei termini. -Le funzioni \ML{} sono parte del tipo \ML{} astratto +In \HOL, gli schemi primitivi d'inferenza sono rappresentati da funzioni \ML{} +che restituiscono teoremi come valori. Cio, per particolari termini \HOL{}, +le funzioni \ML{} restituiscono l'istanza del teorema per quei termini. +Le funzioni \ML{} sono parte del tipo \ML{} astratto \ml{thm}: % \index{thm (tipo ML)@\ml{thm} (tipo \ML{})} % -bench \ml{thm} non abbia dei costruttori primitivi, esso ha (otto) +bench \ml{thm} non abbia dei costruttori primitivi, esso ha (otto) operazioni che restituiscono teoremi come valori: \ml{ASSUME}, \ml{REFL}, \ml{BETA\_CONV}, \ml{SUBST}, \ml{ABS}, \ml{INST\_TYPE}, \ml{DISCH} e \ml{MP}. % \index{schemi d'inferenza, nella logica HOL@schemi d'inferenza, nella logica \HOL{}} -Le funzioni \ML{} che implementano gli schemi primitivi d'inferenza nel +Le funzioni \ML{} che implementano gli schemi primitivi d'inferenza nel sistema \HOL{} sono descritte di sotto. E' usata qui la stessa notazione % \index{inferenze, nella logica HOL@inferenze, nella logica \HOL{}!notazione per le} % -usata in \LOGIC: le ipotesi sono sopra una linea orizzontale e la +usata in \LOGIC: le ipotesi sono sopra una linea orizzontale e la conclusione % -\index{conclusioni!delle regole d'inferenza} di sotto. Per le costanti logiche usata +\index{conclusioni!delle regole d'inferenza} di sotto. Per le costanti logiche usata la notazione {\small ASCII} leggibile dalla macchina. \subsection{Introduzione di assunzione} @@ -1135,7 +1135,7 @@ \subsection{Introduzione di assunzione} \end{tabular} \end{center} -\noindent {\small\verb+REFL +}$t${\small\verb++} valutata a +\noindent {\small\verb+REFL +}$t${\small\verb++} valutata a {\small\verb+|- +}$t${\small\verb+ = +}$t$. Una chiamata a \ml{REFL} non fallisce mai. \bigskip @@ -1158,8 +1158,8 @@ \subsection{Beta-conversione} \begin{itemize} \item dove $t_1[t_2/x]$ denota il risultato di sostituire $t_2$ per $x$ -in $t_1$, con una rinomina appropriata delle variabili per evitare che variabili libere -in $t_2$ diventino legate dopo la sostituzione. La sostituzione +in $t_1$, con una rinomina appropriata delle variabili per evitare che variabili libere +in $t_2$ diventino legate dopo la sostituzione. La sostituzione $t_1[t_2/x]$ sempre definita. \end{itemize} @@ -1192,21 +1192,21 @@ \subsection{Sostituzione}\index{regola di sostituzione, nella logica HOL@regola \bigskip \begin{itemize} -\item dove $t[t_1,\ldots,t_n]$ denota un termine $t$ con qualche occorrenza -libera dei termini $t_1$, $\dots$, $t_n$ scelti e -$t[t'_1,\ldots,t'_n]$ denota il risultato di sostituire simultaneamente ciascuna -di tali occorrenze di $t_i$ con $t'_i$ (per $1{\leq}i {\leq} n$), -con un'appropriata rinomina delle variabili per evitare che variabili libere +\item dove $t[t_1,\ldots,t_n]$ denota un termine $t$ con qualche occorrenza +libera dei termini $t_1$, $\dots$, $t_n$ scelti e +$t[t'_1,\ldots,t'_n]$ denota il risultato di sostituire simultaneamente ciascuna +di tali occorrenze di $t_i$ con $t'_i$ (per $1{\leq}i {\leq} n$), +con un'appropriata rinomina delle variabili per evitare che variabili libere in $t_i'$ diventino legate dopo la sostituzione. \end{itemize} \noindent -Il primo argomento a {\small\verb+SUBST+} una lista +Il primo argomento a {\small\verb+SUBST+} una lista {\small\verb+[(|-+}$t_1${\small\verb+=+}$t'_1${\small\verb+, +}$x_1${\small\verb+);+}$\:\ldots\:${\small\verb+;(|-+}$t_n${\small\verb+=+} -$t'_n${\small\verb+, +}$x_n${\small\verb+)]+}. Il secondo argomento -un template di termine $t[x_1,\ldots,x_n]$ in cui le occorrenze della variabile -$x_i$ (dove $1 \leq i\leq n$) sono usate per segnare gli spazi in cui -le sostituzioni con {\small\verb+|- +}$t_i${\small\verb+=+}$t'_i$ devono essere +$t'_n${\small\verb+, +}$x_n${\small\verb+)]+}. Il secondo argomento +un template di termine $t[x_1,\ldots,x_n]$ in cui le occorrenze della variabile +$x_i$ (dove $1 \leq i\leq n$) sono usate per segnare gli spazi in cui +le sostituzioni con {\small\verb+|- +}$t_i${\small\verb+=+}$t'_i$ devono essere fatte. Cos \bigskip @@ -1247,7 +1247,7 @@ \subsection{Astrazione}\index{regola di astrazione, nella logica HOL@regola di a \end{itemize} \noindent -{\small\verb+ABS +}$x${\small\verb+ +}$\Gamma${\small\verb+ |- +}$t_1${\small\verb+=+}$t_2$ restituisce il teorema +{\small\verb+ABS +}$x${\small\verb+ +}$\Gamma${\small\verb+ |- +}$t_1${\small\verb+=+}$t_2$ restituisce il teorema $\Gamma${\small\verb+ |- (\+}$x${\small\verb+.+}$t_1${\small\verb+) = (\+}$x${\small\verb+.+}$t_2${\small\verb+)+}. Fallisce se $x$ non una variabile, o $x$ occorre libera in qualcuna delle assunzioni in $\Gamma$. @@ -1279,20 +1279,20 @@ \subsection{Istanziazione di tipo} denota il risultato di sostituire (in parallelo) i tipi $\sigma_1$, $\ldots$\ , $\sigma_n$ per le variabili di tipo $\alpha_1$, $\ldots$\ , $\alpha_n$ nel termine $t$. Analogamente, $\Gamma[\sigma_1,\ \ldots\ -,\sigma_n/\alpha_1,\ \ldots\ ,\alpha_n]$ denota il risultato di -eseguire la stessa sostituzione per tutte le ipotesi nell'insieme +,\sigma_n/\alpha_1,\ \ldots\ ,\alpha_n]$ denota il risultato di +eseguire la stessa sostituzione per tutte le ipotesi nell'insieme $\Gamma$. \end{itemize} \noindent \ml{INST\_TYPE[$\alpha_1$~|->~$\sigma_1$% - ,$\ldots$,$\alpha_n$~|->~$\sigma_n$]~$th$} restituisce il risultato di -sostituire ciascuna occorrenza di $\alpha_i$ nel teorema $th$ con -$\sigma_i$ (per $1 \leq i \leq n$). Si verifica un fallimento se un $\alpha_i$ non + ,$\ldots$,$\alpha_n$~|->~$\sigma_n$]~$th$} restituisce il risultato di +sostituire ciascuna occorrenza di $\alpha_i$ nel teorema $th$ con +$\sigma_i$ (per $1 \leq i \leq n$). Si verifica un fallimento se un $\alpha_i$ non una variabile di tipo. -La funzione \ML{} polimorfica infissa {\small\verb+|->+} usata per -costruire valori del tipo record \ml{redex-residue}. Essa definita +La funzione \ML{} polimorfica infissa {\small\verb+|->+} usata per +costruire valori del tipo record \ml{redex-residue}. Essa definita \begin{verbatim} fun ((x:'a) |-> (y:'b)) = {redex = x, residue = y} \end{verbatim} @@ -1315,16 +1315,16 @@ \subsection{Scaricamento di un'assunzione}\index{scaricamento di assunzioni, nel \end{center} \begin{itemize} -\item $\Gamma{-}\{t_1\}$ denota l'insieme ottenuto rimuovendo $t_1$ -da $\Gamma$ (si noti che non necessario che $t_1$ occorra in $\Gamma$; in questo caso +\item $\Gamma{-}\{t_1\}$ denota l'insieme ottenuto rimuovendo $t_1$ +da $\Gamma$ (si noti che non necessario che $t_1$ occorra in $\Gamma$; in questo caso $\Gamma{-}\{t_1\} = \Gamma$). \end{itemize} \noindent {\small\verb+DISCH +}$t_1${\small\verb+ +}$\Gamma${\small\verb+ |- +}$t_2$ - valutata al teorema + valutata al teorema $\Gamma{-}\{t_1\}${\small\verb+ |- +}$t_1${\small\verb+ ==> +}$t_2$. -\ml{DISCH} fallisce se il termine dato come suo primo argomento non di +\ml{DISCH} fallisce se il termine dato come suo primo argomento non di tipo \ml{bool}. @@ -1348,27 +1348,27 @@ \subsection{Modus Ponens}\index{Modus Ponens, nella logica HOL@Modus Ponens, nel \end{center} \noindent -{\small\verb+MP+} prende due teoremi (nell'ordine mostrato di sopra) e restituisce -il risultato dell'applicazione del Modus Ponens; fallisce se gli argomenti non sono della +{\small\verb+MP+} prende due teoremi (nell'ordine mostrato di sopra) e restituisce +il risultato dell'applicazione del Modus Ponens; fallisce se gli argomenti non sono della forma corretta. \index{regole d'inferenza, della logica HOL@regole d'inferenza, della logica \HOL{}!primitive|)} \section{Oracoli} -\HOL{} estende la tradizione \LCF\ permettendo l'uso di un -meccanismo di \emph{oracolo}, consentendo che formule arbitrarie diventino -elementi del tipo \ml{thm}. Per mezzo dell'uso di questo meccanismo, \HOL{} pu -utilizzare i risultati di procedure di dimostrazione arbitrarie. Nonostante questa -liberalit, si possono fare ancora forti asserzioni circa la sicurezza +\HOL{} estende la tradizione \LCF\ permettendo l'uso di un +meccanismo di \emph{oracolo}, consentendo che formule arbitrarie diventino +elementi del tipo \ml{thm}. Per mezzo dell'uso di questo meccanismo, \HOL{} pu +utilizzare i risultati di procedure di dimostrazione arbitrarie. Nonostante questa +liberalit, si possono fare ancora forti asserzioni circa la sicurezza degli oggetti ML di tipo \ml{thm}. -Per evitare la non validit, attaccato un \emph{tag} a ogni teorema che deriva -da un oracolo. Questo tag propagato attraverso ogni inferenza cui quel -teorema partecipa (un p come le assunzioni ordinarie sono -propagate nella regola d'inferenza \ml{MP}). Se accade che la falsit -sia derivata, l'oracolo incriminato pu essere trovato esaminando i -tag componenti del teorema. Un teorema dimostrato senza l'uso di -oracoli avr un tag vuoto, e pu essere cos considerato essere stato dimostrato +Per evitare la non validit, attaccato un \emph{tag} a ogni teorema che deriva +da un oracolo. Questo tag propagato attraverso ogni inferenza cui quel +teorema partecipa (un p come le assunzioni ordinarie sono +propagate nella regola d'inferenza \ml{MP}). Se accade che la falsit +sia derivata, l'oracolo incriminato pu essere trovato esaminando i +tag componenti del teorema. Un teorema dimostrato senza l'uso di +oracoli avr un tag vuoto, e pu essere cos considerato essere stato dimostrato soltanto attraverso passi deduttivi nella logica HOL. Un teorema taggato pu essere creato attraverso @@ -1380,7 +1380,7 @@ \section{Oracoli} \end{verbatim} \end{holboxed} -che crea direttamente il teorema richiesto e attacca ad esso il tag +che crea direttamente il teorema richiesto e attacca ad esso il tag dato. Il tag creato attraverso una chiamata a \begin{holboxed} @@ -1390,16 +1390,16 @@ \section{Oracoli} \end{verbatim} \end{holboxed} -Oltre a fornire un accesso di principio ai risultati di ragionatori -esterni, i tag sono usati per implementare alcune utili operazioni di `sistema' -sui teoremi. Per esempio, si pu creare direttamente un teorema attraverso la -funzione \ml{mk\_thm}. Il tag \verb+MK_THM+ viene attaccato ad ogni -teorema creato con questa chiamata. Questo permette agli utenti di creare direttamente -utili teoremi, ad esempio, da usare come dati di test per regole d'inferenza -derivate. Un altro tag usato per implementare il cosiddetto `check +Oltre a fornire un accesso di principio ai risultati di ragionatori +esterni, i tag sono usati per implementare alcune utili operazioni di `sistema' +sui teoremi. Per esempio, si pu creare direttamente un teorema attraverso la +funzione \ml{mk\_thm}. Il tag \verb+MK_THM+ viene attaccato ad ogni +teorema creato con questa chiamata. Questo permette agli utenti di creare direttamente +utili teoremi, ad esempio, da usare come dati di test per regole d'inferenza +derivate. Un altro tag usato per implementare il cosiddetto `check di validit' per le tattiche. -I tag in un teorema possono essere visualizzati impostando \verb+Globals.show_tags+ a +I tag in un teorema possono essere visualizzati impostando \verb+Globals.show_tags+ a vero. \setcounter{sessioncount}{0} @@ -1413,10 +1413,10 @@ \section{Oracoli} \end{verbatim} \end{session}\index{mk_thm@\ml{mk\_thm}} -Ci sono tre elementi alla sinistra del turnstile nella rappresentazioni completamente -stampata di un teorema: i primi due\footnote{I tag sono usati anche per -tenere traccia dell'uso di assiomi nelle dimostrazioni.} comprendono i tag componenti e il -terzo la lista standard di assunzioni. Il tag componente di un teorema +Ci sono tre elementi alla sinistra del turnstile nella rappresentazioni completamente +stampata di un teorema: i primi due\footnote{I tag sono usati anche per +tenere traccia dell'uso di assiomi nelle dimostrazioni.} comprendono i tag componenti e il +terzo la lista standard di assunzioni. Il tag componente di un teorema pu essere estratto da \begin{holboxed} @@ -1454,28 +1454,28 @@ \section{Teorie} la firma di ${\cal T}$; \item ${\sf Axioms}_{\cal T}$ l'insieme di assiomi di ${\cal T}$; -\item ${\sf Theorems}_{\cal T}$ l'insieme di +\item ${\sf Theorems}_{\cal T}$ l'insieme di teoremi di ${\cal T}$. \end{myenumerate} -Nell'implementazione di \HOL, le teorie sono strutturate in modo gerarchico -per rappresentare sequenze di estensioni chiamate +Nell'implementazione di \HOL, le teorie sono strutturate in modo gerarchico +per rappresentare sequenze di estensioni chiamate \emph{segmenti} % \index{segmenti di teoria} % -di una teoria iniziale chiamata \ml{min}\index{min@\ml{min}}. Un segmento di -teoria non realmente un concetto logico, ma piuttosto un mezzo per -rappresentare teorie nel sistema \HOL{}. Ciascun segmento registra -alcuni tipi, costanti, assiomi e teoremi, insieme con dei puntatori ad +di una teoria iniziale chiamata \ml{min}\index{min@\ml{min}}. Un segmento di +teoria non realmente un concetto logico, ma piuttosto un mezzo per +rappresentare teorie nel sistema \HOL{}. Ciascun segmento registra +alcuni tipi, costanti, assiomi e teoremi, insieme con dei puntatori ad altri segmenti chiamati i suoi \emph{genitori} % \index{genitori, di teorie HOL@genitori, di teorie \HOL{}} % -La teoria rappresentata da un segmento ottenuta prendendo l'unione di -tutti i tipi, le costanti, gli assiomi e i teoremi nel segmento, insieme -con i tipi, le costanti, gli assiomi e i teoremi in tutti i segmenti -raggiungibili seguendo i puntatori ai genitori. Questa collezione di +La teoria rappresentata da un segmento ottenuta prendendo l'unione di +tutti i tipi, le costanti, gli assiomi e i teoremi nel segmento, insieme +con i tipi, le costanti, gli assiomi e i teoremi in tutti i segmenti +raggiungibili seguendo i puntatori ai genitori. Questa collezione di segmenti raggiungibili chiamata la \emph{stirpe} % \index{stirpe, delle teorie del sistema HOL@stirpe, delle teorie del sistema \HOL{}} @@ -1488,40 +1488,40 @@ \section{Teorie} \subsection{Funzioni ML per le operazioni sulle teorie} \label{theoryprims} -Un tipico\index{sistema HOL@sistema \HOL{}!lavoro tipico in} pezzo di lavoro +Un tipico\index{sistema HOL@sistema \HOL{}!lavoro tipico in} pezzo di lavoro con il sistema \HOL{} consiste in un numero di sessioni\index{sessioni -con il sistema HOL@sessioni, con il sistema \HOL{}}. Nella prima di queste, creata -una nuova teoria, diciamo ${\cal T}$, importando qualche segmento di teoria -esistente, facendo una serie di definizioni, e magari dimostrando e -archiviando alcuni teoremi nell'attuale segmento. Poi il segmento corrente -(nominato $name$ diciamo) esportato. Il risultato concreto sar un modulo \ML\ -$name$\ml{Theory} il cui contenuto il segmento di teoria attuale -creato durante la sessione e la cui stirpe rappresenta la teoria logica -desiderata ${\cal T}$. Le sessioni di lavoro successive possono accedere alle +con il sistema HOL@sessioni, con il sistema \HOL{}}. Nella prima di queste, creata +una nuova teoria, diciamo ${\cal T}$, importando qualche segmento di teoria +esistente, facendo una serie di definizioni, e magari dimostrando e +archiviando alcuni teoremi nell'attuale segmento. Poi il segmento corrente +(nominato $name$ diciamo) esportato. Il risultato concreto sar un modulo \ML\ +$name$\ml{Theory} il cui contenuto il segmento di teoria attuale +creato durante la sessione e la cui stirpe rappresenta la teoria logica +desiderata ${\cal T}$. Le sessioni di lavoro successive possono accedere alle definizioni e ai teoremi di ${\cal T}$ importando $name$\ml{Theory}; -questo evita di dover caricare gli strumenti e rieseguire +questo evita di dover caricare gli strumenti e rieseguire le dimostrazioni che $name$\ml{Theory} ha creato in precedenza. -Il nome dato ai dati nelle teorie basato sul nome dato ai segmenti. -In modo specifico si accede\index{teorie, nella logica HOL@teorie, nella logica \HOL{}!nomina delle} a un assioma, -una definizione, una specifica o a un teorema -attraverso un identificatore lungo \ML\ $thy${\small\verb+Theory.+}$name$, dove -$thy$ il nome dell'attuale segmento di teoria quando l'elemento fu -dichiarato e $name$ un nome specifico fornito dall'utente (si vedano le -funzioni \ml{new\_axiom}, \ml{new\_definition}, di sotto). Elementi differenti +Il nome dato ai dati nelle teorie basato sul nome dato ai segmenti. +In modo specifico si accede\index{teorie, nella logica HOL@teorie, nella logica \HOL{}!nomina delle} a un assioma, +una definizione, una specifica o a un teorema +attraverso un identificatore lungo \ML\ $thy${\small\verb+Theory.+}$name$, dove +$thy$ il nome dell'attuale segmento di teoria quando l'elemento fu +dichiarato e $name$ un nome specifico fornito dall'utente (si vedano le +funzioni \ml{new\_axiom}, \ml{new\_definition}, di sotto). Elementi differenti possono avere lo stesso nome specifico se il segmento associato differente. -Cos ciascun segmento di teoria fornisce un namespace separato di binding ML di +Cos ciascun segmento di teoria fornisce un namespace separato di binding ML di elementi \HOL{}. -Vari pezzi aggiuntivi d'informazione sono archiviati in un segmento -di teoria, incluso lo status di parsing delle costanti (ad esempio se +Vari pezzi aggiuntivi d'informazione sono archiviati in un segmento +di teoria, incluso lo status di parsing delle costanti (ad esempio se esse sono degli infissi o dei binder). \paragraph {Determinare il contesto} -C' sempre una \emph{teoria attuale} che la teoria -rappresentata dal segmento di teoria attuale insieme con la sua -stirpe. Il nome del segmento di teoria attuale restituito dalla funzione +C' sempre una \emph{teoria attuale} che la teoria +rappresentata dal segmento di teoria attuale insieme con la sua +stirpe. Il nome del segmento di teoria attuale restituito dalla funzione \ML: \begin{holboxed}\index{current_theory@\ml{current\_theory}|pin} @@ -1530,13 +1530,13 @@ \subsection{Funzioni ML per le operazioni sulle teorie} \end{verbatim} \end{holboxed} - Quando una sessione interattiva \HOL{} inizia, alcune teorie saranno - gi nel contesto logico. L'insieme esatto di teorie nel + Quando una sessione interattiva \HOL{} inizia, alcune teorie saranno + gi nel contesto logico. L'insieme esatto di teorie nel contesto varier. Se l'eseguibile usato \texttt{hol.bare}, - allora saranno caricate solo \theoryimp{min} e \theoryimp{bool}. Quando + allora saranno caricate solo \theoryimp{min} e \theoryimp{bool}. Quando usato l'eseguibile \texttt{hol}, caricato un conteso logico pi ricco. -L'esatto insieme di teorie caricate pu essere determinato con il +L'esatto insieme di teorie caricate pu essere determinato con il comando \ml{ancestry}. % \begin{holboxed} @@ -1546,10 +1546,10 @@ \subsection{Funzioni ML per le operazioni sulle teorie} \end{verbatim} \end{holboxed} -Questa funzione fornisce un meccanismo generale per esaminare la struttura -della gerarchia delle teorie. L'argomento il nome di una teoria (o -\texttt{"-"} come abbreviazione per la teoria attuale), al quale -\texttt{ancestry} risponder con una lista degli antenati dell'argomento +Questa funzione fornisce un meccanismo generale per esaminare la struttura +della gerarchia delle teorie. L'argomento il nome di una teoria (o +\texttt{"-"} come abbreviazione per la teoria attuale), al quale +\texttt{ancestry} risponder con una lista degli antenati dell'argomento nella gerarchia delle teorie. \begin{holboxed} @@ -1578,41 +1578,41 @@ \subsection{Funzioni ML per le operazioni sulle teorie} \end{verbatim} \end{holboxed} % -Questo alloca una nuova `area' dove le successive operazioni -di teoria hanno effetto. Se la teoria attuale (diciamo $thy_1$) al momento -di una chiamata a {\small\verb+new_theory +}$thy_2$ non vuota, cio, stato -archiviato in essa un assioma, una definizione, o un teorema, allora $thy_1$ -esportata prima che $thy_2$ sia allocata. Inoltre, $thy_2$ otterr -$thy_1$ come genitore. Se {\small\verb+new_theory +}$thy$ chiamato quando -il segmento attuale di teoria gi chiamato $thy$, allora questo -interpretato semplicemente come una richiesta di ripulire l'attuale segmento di teoria +Questo alloca una nuova `area' dove le successive operazioni +di teoria hanno effetto. Se la teoria attuale (diciamo $thy_1$) al momento +di una chiamata a {\small\verb+new_theory +}$thy_2$ non vuota, cio, stato +archiviato in essa un assioma, una definizione, o un teorema, allora $thy_1$ +esportata prima che $thy_2$ sia allocata. Inoltre, $thy_2$ otterr +$thy_1$ come genitore. Se {\small\verb+new_theory +}$thy$ chiamato quando +il segmento attuale di teoria gi chiamato $thy$, allora questo +interpretato semplicemente come una richiesta di ripulire l'attuale segmento di teoria (nulla sar esportato). Una chiamata a \ml{new\_theory "$\mathit{name}$"} fallisce se: \begin{itemize} \item $name$ non un alfanumerico che inizia con una lettera. -\item c' gi una teoria chiamata $name$ nella stirpe del +\item c' gi una teoria chiamata $name$ nella stirpe del segmento attuale. -\item se necessario esportare il segmento attuale prima di creare +\item se necessario esportare il segmento attuale prima di creare il nuovo e il tentativo di export fallisce. \end{itemize} -All'avvio, il segmento di teoria attuale di \HOL{} chiamato \ml{scratch}, -che una teoria vuota, che ha un'utile collezione di teorie nella -sua stirpe. Tipicamente, un utente inizierebbe caricando qualunque contesto +All'avvio, il segmento di teoria attuale di \HOL{} chiamato \ml{scratch}, +che una teoria vuota, che ha un'utile collezione di teorie nella +sua stirpe. Tipicamente, un utente inizierebbe caricando qualunque contesto logico extra sia richiesto per il lavoro da fare. -Il segmento attuale di teoria agisce come una sorta di blocco di appunti. Gli elementi archiviati -nel segmento attuale possono essere sovrascritti da aggiunte successive, o -cancellati completamente. Ogni elemento di teoria che fosse stato sovrascritto -o cancellato sarebbe quindi considerato {\it scaduto}, e non sarebbe +Il segmento attuale di teoria agisce come una sorta di blocco di appunti. Gli elementi archiviati +nel segmento attuale possono essere sovrascritti da aggiunte successive, o +cancellati completamente. Ogni elemento di teoria che fosse stato sovrascritto +o cancellato sarebbe quindi considerato {\it scaduto}, e non sarebbe incluso nella teoria nel momento cui essa fosse in fine esportata. Le costanti -e i tipi scaduti sono individuati dal printer \HOL{}, che li stamper +e i tipi scaduti sono individuati dal printer \HOL{}, che li stamper inclusi in una sintassi strana-alla-vista per avvertire l'utente. -Contrariamente al segmento attuale, i segmenti antenati (propri) non possono +Contrariamente al segmento attuale, i segmenti antenati (propri) non possono essere alterati. % \index{teorie, nella logica HOL@teorie, nella logica \HOL{}!creazione di|)} @@ -1620,7 +1620,7 @@ \subsection{Funzioni ML per le operazioni sulle teorie} \paragraph{Caricare teorie pre-costruite} -Dal momento che le teorie \HOL{} sono rappresentate da moduli \ML, si importa +Dal momento che le teorie \HOL{} sono rappresentate da moduli \ML, si importa un segmento di teoria esistente semplicemente importando il modulo corrispondente. \begin{holboxed} @@ -1630,20 +1630,20 @@ \subsection{Funzioni ML per le operazioni sulle teorie} \end{verbatim}\end{holboxed} \noindent -Eseguire {\small\verb+load +}$name${\small\verb+Theory+} importa nella sessione il -primo file chiamato $name${\small\verb+Theory.uo+} trovato lungo il -{\small\verb+loadPath+}. Qualunque antenato di -$name$ sar caricato prima che il caricamento di $name${\small\verb+Theory+} -continui. Si noti che {\small\verb+load+} non pu essere usato in file ML -che non sono stati compilati; pu essere usato solo nel sistema +Eseguire {\small\verb+load +}$name${\small\verb+Theory+} importa nella sessione il +primo file chiamato $name${\small\verb+Theory.uo+} trovato lungo il +{\small\verb+loadPath+}. Qualunque antenato di +$name$ sar caricato prima che il caricamento di $name${\small\verb+Theory+} +continui. Si noti che {\small\verb+load+} non pu essere usato in file ML +che non sono stati compilati; pu essere usato solo nel sistema interattivo. \paragraph{Aggiungere alla teoria attuale} -Le seguenti funzioni \ML{} aggiungono tipi e termini al segmento di teoria -attuale. Nell'uso tipico, queste funzioni non saranno -necessarie dal momento che funzionalit di definizione di pi alto livello invocheranno queste -in caso di necessit. Tuttavia, queste funzioni possono essere utili per coloro che scrivono +Le seguenti funzioni \ML{} aggiungono tipi e termini al segmento di teoria +attuale. Nell'uso tipico, queste funzioni non saranno +necessarie dal momento che funzionalit di definizione di pi alto livello invocheranno queste +in caso di necessit. Tuttavia, queste funzioni possono essere utili per coloro che scrivono strumenti di dimostrazione e principi derivati di definizione. \begin{holboxed} @@ -1654,9 +1654,9 @@ \subsection{Funzioni ML per le operazioni sulle teorie} \end{holboxed} -\noindent Eseguire \ml{new\_type}$\ n\ \ml{"\ty{op}"}$ rende \ty{op} -un nuovo operatore di tipo\index{operatori di tipo, nella logica HOL@operatori di -tipo, nella logica \HOL{}!dichiarazione di} $n$-ario nella teoria attuale. Se +\noindent Eseguire \ml{new\_type}$\ n\ \ml{"\ty{op}"}$ rende \ty{op} +un nuovo operatore di tipo\index{operatori di tipo, nella logica HOL@operatori di +tipo, nella logica \HOL{}!dichiarazione di} $n$-ario nella teoria attuale. Se \ty{op} non un nome permesso per un tipo, sar emesso un warning. @@ -1668,9 +1668,9 @@ \subsection{Funzioni ML per le operazioni sulle teorie} \end{holboxed} \noindent Eseguire {\small\verb+new_constant("+}$c${\small\verb+",+}$\sigma${\small\verb+)+} rende -$c_{\sigma'}$ una nuova costante\index{costanti, nella logica HOL@costanti, nella logica \HOL{}!dichiarazione di} della teoria attuale, +$c_{\sigma'}$ una nuova costante\index{costanti, nella logica HOL@costanti, nella logica \HOL{}!dichiarazione di} della teoria attuale, per ogni $c_{\sigma'}$ dove $\sigma'$ un'istanza di $\sigma$. -Il tipo $\sigma$ +Il tipo $\sigma$ chiamato il {\it tipo generico\/}\index{tipi generici, nella logica HOL@tipi generici, nella logica \HOL{}} di $c$. Se $c$ non un nome permesso per una costante, sar emesso un warning. @@ -1682,14 +1682,14 @@ \subsection{Funzioni ML per le operazioni sulle teorie} \end{verbatim} \end{holboxed} -\noindent Eseguire \ml{new\_axiom("}$name$\ml{",}$t$\ml{)} dichiara il -sequente +\noindent Eseguire \ml{new\_axiom("}$name$\ml{",}$t$\ml{)} dichiara il +sequente \ml{(\lb\rb{},$t$)} essere un assioma\index{assiomi!dichiarazione di, nella logica HOL@dichiarazione di, nella logica \HOL{}} della teoria attuale con nome $name$. Fallisce se: \begin{myenumerate} \item il tipo di $t$ non \verb+bool+. -\item $t$ contiene costanti o tipi scaduti, cio, costanti o +\item $t$ contiene costanti o tipi scaduti, cio, costanti o tipi che sono stati ri-dichiarati dopo che stato eseguito il build di $t$. \end{myenumerate} @@ -1709,12 +1709,12 @@ \subsection{Funzioni ML per le operazioni sulle teorie} \index{teoremi, nella logica HOL@teoremi, nella logica \HOL{}!salvataggio di} \index{salvare teoremi} % -$\mathit{th}$ con nome $\mathit{name}$ nel segmento di teoria +$\mathit{th}$ con nome $\mathit{name}$ nel segmento di teoria attuale. \paragraph{Esportare una teoria} -Una volta che un segmento di teoria stato costruito, pu essere scritto su un +Una volta che un segmento di teoria stato costruito, pu essere scritto su un file, che, dopo la compilazione, pu essere importato in sessioni future. \begin{holboxed} @@ -1724,14 +1724,14 @@ \subsection{Funzioni ML per le operazioni sulle teorie} \end{verbatim} \end{holboxed} -Quando chiamato {\small\verb+export_theory+}, tutte le entit scadute -sono rimosse dal segmento attuale. Inoltre, calcolata la paternit della -teoria. Il segmento di teoria attuale scritto sul file -$name${\small{\tt Theory.sml}} nell'attuale directory di lavoro. Anche il -file $name${\small{\tt Theory.sig}}, che documenta il contenuto di -$name$, scritto nell'attuale directory di lavoro. Si noti che -la teoria esportata non compilata da \HOL. Questo lasciato a uno -strumento esterno, \holmake{} (si veda la sezione~\ref{Holmake}), che mantiene +Quando chiamato {\small\verb+export_theory+}, tutte le entit scadute +sono rimosse dal segmento attuale. Inoltre, calcolata la paternit della +teoria. Il segmento di teoria attuale scritto sul file +$name${\small{\tt Theory.sml}} nell'attuale directory di lavoro. Anche il +file $name${\small{\tt Theory.sig}}, che documenta il contenuto di +$name$, scritto nell'attuale directory di lavoro. Si noti che +la teoria esportata non compilata da \HOL. Questo lasciato a uno +strumento esterno, \holmake{} (si veda la sezione~\ref{Holmake}), che mantiene le dipendenze tra collezioni di segmenti di teoria \HOL{}. @@ -1740,18 +1740,18 @@ \subsection{Funzioni ML per accedere alle teorie} \index{teorie, nella logica HOL@teorie, nella logica \HOL{}!funzioni per accedere alle|(} \index{assiomi!recupero degli, nel sistema HOL@recupero degli, nel sistema \HOL{}|(} % -Gli argomenti di tipo \ML{} \ml{string} a \ml{new\_axiom}, -\ml{new\_definition}, ecc., sono i nomi degli assiomi e delle -definizioni corrispondenti. Questi nomi sono usati quando si accede alle teorie con le +Gli argomenti di tipo \ML{} \ml{string} a \ml{new\_axiom}, +\ml{new\_definition}, ecc., sono i nomi degli assiomi e delle +definizioni corrispondenti. Questi nomi sono usati quando si accede alle teorie con le funzioni \ml{axiom}, \ml{definition}, ecc., descritte di sotto. La teoria attuale % \index{teorie, nella logica HOL@teorie, nella logica \HOL{}!gerarchia delle} % -pu essere estesa aggiungendo nuovi genitori, tipi, costanti, assiomi e -definizioni. Le teorie che sono nella stirpe della teoria attuale -non possono essere estese in questo modo; esse possono essere pensate come +pu essere estesa aggiungendo nuovi genitori, tipi, costanti, assiomi e +definizioni. Le teorie che sono nella stirpe della teoria attuale +non possono essere estese in questo modo; esse possono essere pensate come \emph{congelate}. Ci sono varie funzioni per caricare il contenuto dei file di teoria: @@ -1767,18 +1767,18 @@ \subsection{Funzioni ML per accedere alle teorie} \end{verbatim} \end{holboxed} -\noindent Il primo argomento il nome di una teoria (che deve essere nella -stirpe dell'attuale segmento di teoria); il risultato una lista delle -componenti della teoria. Il nome della teoria attuale pu essere +\noindent Il primo argomento il nome di una teoria (che deve essere nella +stirpe dell'attuale segmento di teoria); il risultato una lista delle +componenti della teoria. Il nome della teoria attuale pu essere abbreviato da \ml{"-"}. % \index{ abbreviazione, di parte dei nomi di teoria HOL@\ml{-} (abbreviazione, di parte dei nomi di teoria \HOL{})} % -Per esempio, \ml{parents "-"} restituisce i genitori della teoria +Per esempio, \ml{parents "-"} restituisce i genitori della teoria attuale. -Nel caso di \ml{types} restituita una lista di coppie ariet-nome. -Gli assiomi, le definizioni e i teoremi individuali possono essere letti dalla +Nel caso di \ml{types} restituita una lista di coppie ariet-nome. +Gli assiomi, le definizioni e i teoremi individuali possono essere letti dalla teoria attuale usando le seguenti funzioni \ML: \begin{holboxed} @@ -1792,9 +1792,9 @@ \subsection{Funzioni ML per accedere alle teorie} \end{verbatim} \end{holboxed} -\noindent Il primo argomento il nome dell'assioma, definizione o teorema -fornito dall'utente nella teoria attuale. Inoltre, pu essere estratta -una lista di tutti gli assiomi, definizioni e teoremi della teoria con +\noindent Il primo argomento il nome dell'assioma, definizione o teorema +fornito dall'utente nella teoria attuale. Inoltre, pu essere estratta +una lista di tutti gli assiomi, definizioni e teoremi della teoria con le funzioni \ML{}: \begin{holboxed} @@ -1808,7 +1808,7 @@ \subsection{Funzioni ML per accedere alle teorie} \end{verbatim} \end{holboxed} -Il contenuto della teoria attuale pu essere stampato in un formato leggibile +Il contenuto della teoria attuale pu essere stampato in un formato leggibile usando la funzione \ml{print\_theory}. % \index{stampa, nella logica HOL@stampa, nella logica \HOL{}!di teorie} @@ -1828,12 +1828,12 @@ \subsection{Funzioni per creare estensioni definizionali} \subsubsection{Definizioni di costante} \label{sec:constant-definitions} -In \LOGIC{} una definizione di costante +In \LOGIC{} una definizione di costante % \index{estensione, della logica HOL@estensione, della logica \HOL{}!per definizione di costante} \index{estensione per definizione di costante, della logica HOL@estensione per definizione di costante, della logica \HOL{}!funzione ML per@funzione \ML\ per} % -su una firma $\Sigma_{\Omega}$ definita essere un'equazione, cio +su una firma $\Sigma_{\Omega}$ definita essere un'equazione, cio una formula della forma $c_{\sigma}=t_{\sigma}$, tale che: \begin{myenumerate} \item $c$ non il nome di alcuna costante in $\Sigma_{\Omega}$; @@ -1841,13 +1841,13 @@ \subsubsection{Definizioni di costante} \item tutte le variabili di tipo che occorrono in $t_{\sigma}$ occorrono in $\sigma$. \end{myenumerate} -In \HOL, le definizioni possono essere leggermente pi generali di questo, nel senso che +In \HOL, le definizioni possono essere leggermente pi generali di questo, nel senso che permesso che un'equazione: \[ c\ v_1\ \cdots\ v_n\ =\ t \] \noindent sia una definizione dove $v_1$, $\dots$, $v_n$ sono -strutture variabili (cio tuple di variabili distinte). Una tale equazione +strutture variabili (cio tuple di variabili distinte). Una tale equazione logicamente equivalente a: \[ c\ =\ \lambda v_1\ \cdots\ v_n.\ t \] @@ -1855,7 +1855,7 @@ \subsubsection{Definizioni di costante} \noindent che una definizione nel senso di \LOGIC{} se valgono (i), (ii) e (iii). -La seguente funzione \ML\ crea\index{meccanismi di definizione, per la logica HOL@meccanismi di definizione, per la logica \HOL{}} una nuova definizione nella +La seguente funzione \ML\ crea\index{meccanismi di definizione, per la logica HOL@meccanismi di definizione, per la logica \HOL{}} una nuova definizione nella teoria attuale. \begin{holboxed} @@ -1869,16 +1869,16 @@ \subsubsection{Definizioni di costante} \noindent Valutare \ml{new\_definition("$name$", \holquote{$c\ v_1\ \cdots\ v_n\ =\ t$})}, dichiara il sequente\linebreak -\ml{(\lb\rb{},$c = \lambda v_1\ \cdots\ v_n.\ t$)} essere una definizione di costante +\ml{(\lb\rb{},$c = \lambda v_1\ \cdots\ v_n.\ t$)} essere una definizione di costante \index{definizioni, aggiungere ... alla logica HOLc@definizioni, aggiungere ... alla logica \HOL{}} -della teoria attuale. Il nome associato con la definizione in +della teoria attuale. Il nome associato con la definizione in questa teoria $name$. Si verifica un fallimento se: \begin{myenumerate} -\item $t$ contiene delle variabili libere che non sono in nessuna delle -strutture variabili $v_1$, $\dots$, $v_n$ (questo equivale +\item $t$ contiene delle variabili libere che non sono in nessuna delle +strutture variabili $v_1$, $\dots$, $v_n$ (questo equivale a richiedere che $\lambda v_1\ \cdots\ v_n.\ t$ sia un termine chiuso); -\item c' una variabile di tipo in $v_1$, $\dots$, $v_n$ o $t$ +\item c' una variabile di tipo in $v_1$, $\dots$, $v_n$ o $t$ che non occorre nel tipo di $c$. \end{myenumerate} @@ -1889,7 +1889,7 @@ \subsubsection{Specifiche di costante} % \index{estensione, della logica HOL@estensione, della logica \HOL{}!per specifica di costante} % -In \LOGIC{} una specifica di costante\index{estensione per specifica di costante, della logica HOL@estensione per specifica di costante, della logica \HOL{}!funzione ML per@funzione \ML\ per} per una teoria ${\cal T}$ +In \LOGIC{} una specifica di costante\index{estensione per specifica di costante, della logica HOL@estensione per specifica di costante, della logica \HOL{}!funzione ML per@funzione \ML\ per} per una teoria ${\cal T}$ definita essere una coppia: \[ @@ -1908,7 +1908,7 @@ \subsubsection{Specifiche di costante} \item $\equant{{x_1}_{\sigma_1}\ \cdots\ {x_n}_{\sigma_n}}t \ \in\ {\sf Theorems}_{\cal T}$. \end{myenumerate} -La seguente funzione \ML\ usata per fare specifiche di costante nel +La seguente funzione \ML\ usata per fare specifiche di costante nel sistema \HOL{}. \begin{holboxed} @@ -1934,15 +1934,15 @@ \subsubsection{Specifiche di costante} \[ \ml{|- }t\ml{[}c_1\ml{,}\ \ldots\ \ml{,}c_n\ml{]} \] -\noindent Questo teorema archiviato, -con nome $name$, come una definizione nell'attuale segmento di teoria. Una chiamata a +\noindent Questo teorema archiviato, +con nome $name$, come una definizione nell'attuale segmento di teoria. Una chiamata a \ml{new\_specification} fallisce se: \begin{myenumerate} \item il teorema argomento non ha una lista vuota di assunzioni; \item ci sono variabili libere nel teorema argomento; \item $c_1$, $\dots$, $c_n$ non sono variabili distinte; -\item il tipo di qualche $c_i$ non contiene tutte le variabili +\item il tipo di qualche $c_i$ non contiene tutte le variabili di tipo che occorrono nel termine \holtxt{\bs$x_1\ \cdots\ x_n$. $t$[$x_1$, $\ldots$, $x_n$]}. \end{myenumerate} @@ -1956,20 +1956,20 @@ \subsubsection{Definizioni di tipo} % \index{definizioni di tipo, nella logica HOL@definizioni di tipo, nella logica \HOL{}|(} % -In \LOGIC{} spiegato che -definire +In \LOGIC{} spiegato che +definire % \index{definizioni di tipo, nella logica HOL@definizioni di tipo, nella logica \HOL{}!introduzione di} \index{estensione per definizione di tipo, nella logica HOL@estensione per definizione di tipo, nella logica \HOL{}!funzione ML per@funzione \ML\ per|(} % un nuovo tipo $(\alpha_1,\ldots,\alpha_n)\ty{op}$ in una teoria ${\cal T}$ -consiste nell'introdurre $\ty{op}$ come un nuovo operatore di tipo $n$-ario e +consiste nell'introdurre $\ty{op}$ come un nuovo operatore di tipo $n$-ario e \[\turn \equant{f_{(\alpha_1,\ldots,\alpha_n)\ty{op}\fun\sigma}}\TyDef\ p\ f\] -\noindent come un nuovo assioma, dove $p$ un predicato -che caratterizza\index{predicato caratteristico, di definizioni di tipo} un -sottoinsieme non vuoto di un tipo esistente $\sigma$. Formalmente, una definizione di tipo +\noindent come un nuovo assioma, dove $p$ un predicato +che caratterizza\index{predicato caratteristico, di definizioni di tipo} un +sottoinsieme non vuoto di un tipo esistente $\sigma$. Formalmente, una definizione di tipo per una teoria ${\cal T}$ una tripla \[ \langle \sigma,\ (\alpha_1,\ldots,\alpha_n)\ty{op}, @@ -1981,7 +1981,7 @@ \subsubsection{Definizioni di tipo} \item $\sigma\in{\sf Types}_{\cal T}$ e $tyvars(\sigma)\in\{\alpha_1, \ldots , \alpha_n\}$. \item \ty{op} il nome di una costante di tipo in ${\sf Struc}_{\cal T}$. -\item $p\in{\sf Terms}_{\cal T}$ un termine chiuso di +\item $p\in{\sf Terms}_{\cal T}$ un termine chiuso di tipo $\sigma\fun\ty{bool}$ e $tyvars(p)\subseteq\{\alpha_1, \ldots , \alpha_n\}$. \item $\equant{x_{\sigma}}p\ x \ \subseteq\ {\sf Theorems}_{\cal T}$. @@ -2006,8 +2006,8 @@ \subsubsection{Definizioni di tipo} \end{alltt} \end{hol}} -\noindent risulta nella dichiarazione di \ty{op} come un nuovo operatore di tipo $n$-ario -caratterizzato dall'assioma +\noindent risulta nella dichiarazione di \ty{op} come un nuovo operatore di tipo $n$-ario +caratterizzato dall'assioma definizionale\index{operatori di tipo, nella logica HOL@operatori di tipo, nella logica \HOL{}!assiomi definizionali per}: \begin{hol} \begin{alltt} @@ -2015,8 +2015,8 @@ \subsubsection{Definizioni di tipo} \end{alltt} \end{hol} -\noindent che archiviato come una definizione con il nome generato -automaticamente +\noindent che archiviato come una definizione con il nome generato +automaticamente \ty{op}\ml{\_TY\_DEF}.\index{TY_DEF@$\ldots$\ml{\_TY\_DEF}}. La costante \ml{TYPE\_DEFINITION}\index{TYPE_DEFINITION@\ml{TYPE\_DEFINITION}} definita nella teoria \ml{bool} da: @@ -2041,11 +2041,11 @@ \subsubsection{Definizioni di tipo} \paragraph{Definire le biezioni} \index{definizioni di tipo, nella logica HOL@definizioni di tipo, nella logica \HOL{}!definire le biezioni per|(} -Il risultato di una definizione di tipo usando \ml{new\_type\_definition} un teorema -che asserisce solo l'{\it esistenza\/} di una -biezione\index{biezione di tipi, nella logica HOL@biezione di tipi, nella logica \HOL{}} -dal tipo che esso definisce al corrispondente sottoinsieme di un tipo esistente. Per -introdurre costanti che di fatto denotano una tale biezione e la sua inversa, +Il risultato di una definizione di tipo usando \ml{new\_type\_definition} un teorema +che asserisce solo l'{\it esistenza\/} di una +biezione\index{biezione di tipi, nella logica HOL@biezione di tipi, nella logica \HOL{}} +dal tipo che esso definisce al corrispondente sottoinsieme di un tipo esistente. Per +introdurre costanti che di fatto denotano una tale biezione e la sua inversa, fornita la seguente funzione \ML: \begin{holboxed} @@ -2055,16 +2055,16 @@ \subsubsection{Definizioni di tipo} : {name:string, ABS:string, REP:string, tyax:thm} -> thm \end{verbatim}\end{holboxed} -\noindent Questa funzione prende un record {\small\verb+{ABS, REP, name, tyax}+}. -L'argomento {\verb+tyax+} deve essere un assioma definizionale della forma restituita da -\ml{new\_type\_definition}.\linebreak L'argomento {\verb+name+} il nome sotto cui -la definizione di costante (di fatto, una specifica di costante) fatta da -{\small\verb!define_new_type_bijections!} sar archiviata nel segmento di teoria -attuale, e gli argomenti {\small\verb+ABS+} e {\small\verb+REP+} -sono nomi specificati dall'utente per le due costanti che devono essere -definite. Queste costanti sono definite in modo da denotare biezioni mutuamente -inverse tra il tipo definito, la cui definizione data dal -teorema fornito, e il tipo rappresentante di questo tipo +\noindent Questa funzione prende un record {\small\verb+{ABS, REP, name, tyax}+}. +L'argomento {\verb+tyax+} deve essere un assioma definizionale della forma restituita da +\ml{new\_type\_definition}.\linebreak L'argomento {\verb+name+} il nome sotto cui +la definizione di costante (di fatto, una specifica di costante) fatta da +{\small\verb!define_new_type_bijections!} sar archiviata nel segmento di teoria +attuale, e gli argomenti {\small\verb+ABS+} e {\small\verb+REP+} +sono nomi specificati dall'utente per le due costanti che devono essere +definite. Queste costanti sono definite in modo da denotare biezioni mutuamente +inverse tra il tipo definito, la cui definizione data dal +teorema fornito, e il tipo rappresentante di questo tipo definito. Valutare: @@ -2088,10 +2088,10 @@ \subsubsection{Definizioni di tipo} |- (!a. \m{abs}(\m{rep} a) = a) /\bk (!r. \m{P} r = (\m{rep}(\m{abs} r) = r)) \end{alltt}\end{hol}} -\noindent Questo teorema, che la propriet di definizione per le costanti -\m{abs} e \m{rep}, archiviato sotto il nome "\m{name}" nell'attuale segmento +\noindent Questo teorema, che la propriet di definizione per le costanti +\m{abs} e \m{rep}, archiviato sotto il nome "\m{name}" nell'attuale segmento di teoria. Esso anche il valore restituito da \ml{define\_new\_type\_bijections}. -Il teorema dichiara che \m{abs} l'inversa sinistra di \m{rep} e---per +Il teorema dichiara che \m{abs} l'inversa sinistra di \m{rep} e---per valori che soddisfano \ml{P}---che \ml{rep} l'inversa sinistra di \m{abs}. Una chiamata a @@ -2108,8 +2108,8 @@ \subsubsection{Definizioni di tipo} \index{definizioni di tipo, nella logica HOL@definizioni di tipo, nella logica \HOL{}!propriet delle biezioni per|(} -Le seguenti funzioni \ML\ sono fornite per dimostrare che le biezioni -introdotte da \ml{define\_new\_type\_bijections} sono iniettive\linebreak \ml{define\_new\_type\_bijections} +Le seguenti funzioni \ML\ sono fornite per dimostrare che le biezioni +introdotte da \ml{define\_new\_type\_bijections} sono iniettive\linebreak \ml{define\_new\_type\_bijections} e suriettive (onto): \begin{holboxed} @@ -2124,7 +2124,7 @@ \subsubsection{Definizioni di tipo} prove_abs_fn_onto : thm -> thm \end{verbatim}\end{holboxed} -\noindent Il teorema argomento a ciascuna di queste funzioni deve essere un teorema +\noindent Il teorema argomento a ciascuna di queste funzioni deve essere un teorema della forma restituita da \ml{define\_new\_type\_bijections}: {\def\bk{\char'134} @@ -2132,8 +2132,8 @@ \subsubsection{Definizioni di tipo} |- (!a. \m{abs}(\m{rep} a) = a) /\bk (!r. \m{P} r = (\m{rep}(\m{abs} r) = r)) \end{alltt}\end{hol}} -\noindent Se \m{th} un teorema di questa forma, allora valutare -\ml{prove\_rep\_fn\_one\_one \m{th}} dimostra che la funzione \m{rep} +\noindent Se \m{th} un teorema di questa forma, allora valutare +\ml{prove\_rep\_fn\_one\_one \m{th}} dimostra che la funzione \m{rep} uno-a-uno, e restituisce il teorema: \begin{hol}\begin{alltt} @@ -2166,7 +2166,7 @@ \subsubsection{Definizioni di tipo} \end{alltt} \end{hol}} -\noindent Tutte e quattro le funzioni falliranno se applicate a qualunque teorema che non +\noindent Tutte e quattro le funzioni falliranno se applicate a qualunque teorema che non abbia la forma di un teorema restituito da \ml{define\_new\_type\_bijections}. Nessuna di queste funzioni salva alcunch nella teoria attuale. diff --git a/Manual/Translations/IT/Description/theories.tex b/Manual/Translations/IT/Description/theories.tex index 6e187546a5..de73f42f2c 100644 --- a/Manual/Translations/IT/Description/theories.tex +++ b/Manual/Translations/IT/Description/theories.tex @@ -23,22 +23,22 @@ \chapter{Teorie Fondamentali}\label{HOLtheories} \newcommand{\nil}{\mathbf{[} \;\mathbf{]}} \newcommand{\cons}[2]{{#1}\mathbf{:}\mathbf{:}{#2}} -\index{teorie, nella logica HOL@theories, nella logica \HOL{}!gerarchie +\index{teorie, nella logica HOL@theories, nella logica \HOL{}!gerarchie delle}% -Il sistema \HOL{} fornisce una collezione di teorie sulla quali basare strumenti di verifica o un ulteriore sviluppo di teorie. +Il sistema \HOL{} fornisce una collezione di teorie sulla quali basare strumenti di verifica o un ulteriore sviluppo di teorie. Nel resto di questa sezione, queste teorie sono descritte brevemente. Le sessioni che seguono forniscono una panoramica del contenuto di ciascuna teoria. Per un elenco completo degli assiomi, definizioni e teoremi in \HOL, si vedano le risorse online distribuite con il sistema. -In particolare, il file HTML \url{help/HOLindex.html} un buon punto di partenza per esplorare le teorie disponibili. +In particolare, il file HTML \url{help/HOLindex.html} un buon punto di partenza per esplorare le teorie disponibili. Per un'immagine grafica della gerarchia delle teorie, si veda \url{help/theorygraph/theories.html}. \section{La Teoria {\tt min}}\label{minTheory} La teoria di partenza di \HOL{} la teoria \ml{min}. \index{min, la teoria HOL@\ml{min}, la teoria \HOL{}|(} -In questa teoria sono dichiarate la costante di tipo {\small\verb+bool+} dei booleani, -l'operatore di tipo binario $(\alpha,\beta)${\small\verb+fun+} delle funzioni, e la costante -di tipo {\small\verb+ind+} degli individui. Sulla base di +In questa teoria sono dichiarate la costante di tipo {\small\verb+bool+} dei booleani, +l'operatore di tipo binario $(\alpha,\beta)${\small\verb+fun+} delle funzioni, e la costante +di tipo {\small\verb+ind+} degli individui. Sulla base di questi tipi, sono dichiarate tre costanti primitive: % \index{costanti, nella logica HOL@costanti, nella logica \HOL{}!logiche primitive} @@ -52,29 +52,29 @@ \section{La Teoria {\tt min}}\label{minTheory} \index{eguaglianza, nella logica HOL@eguaglianza, nella logica \HOL{}} \item [Implicazione] Implicazione ({\small\verb+==> : bool -> bool -> bool+}) l' - \emph{implicazione materiale} ed un operatore infisso che - associativo a destra, cio, \verb+x ==> y ==> z+ parsato allo stesso termine + \emph{implicazione materiale} ed un operatore infisso che + associativo a destra, cio, \verb+x ==> y ==> z+ parsato allo stesso termine di \verb+x ==> (y ==> z)+. \index{implicazione, nella logica HOL@implicazione, nella logica \HOL{}} -\item [Scelta] L'eguaglianza -e l'implicazione sono nozioni standard del calcolo dei predicati, ma la scelta -pi esotica: se $t$ un termine che ha il tipo $\sigma${\small\verb+->bool+}, -allora {\small\verb+@x.+}$t${\small\verb+ x+} (o, equivalentemente, -{\small\verb+$@+}$t$) denota \emph{qualche} membro dell'insieme la cui -funzione caratteristica\index{predicato caratteristico, delle definizioni di tipo} - $t$. Se l'insieme vuoto, allora -{\small\verb+@x.+}$t${\small\verb+ x+} denota un membro arbitrario -dell'insieme denotato da $\sigma$. La costante {\small\verb+@+} una versione -di ordine superiore dell'$\hilbert$-operatore +\item [Scelta] L'eguaglianza +e l'implicazione sono nozioni standard del calcolo dei predicati, ma la scelta +pi esotica: se $t$ un termine che ha il tipo $\sigma${\small\verb+->bool+}, +allora {\small\verb+@x.+}$t${\small\verb+ x+} (o, equivalentemente, +{\small\verb+$@+}$t$) denota \emph{qualche} membro dell'insieme la cui +funzione caratteristica\index{predicato caratteristico, delle definizioni di tipo} + $t$. Se l'insieme vuoto, allora +{\small\verb+@x.+}$t${\small\verb+ x+} denota un membro arbitrario +dell'insieme denotato da $\sigma$. La costante {\small\verb+@+} una versione +di ordine superiore dell'$\hilbert$-operatore \index{Hilbert, D.} \index{operatore epsilon} -di Hilbert; collegato alla costante -$\iota$ nella formulazione di Church della logica di ordine superiore. Per maggiori dettagli, -si veda lo scritto -originale -di Church\index{Church, A.} \cite{Church}, il libro di -Leinsenring\index{Leisenring, A.} -del simbolo-$\hilbert$ di Hilbert \cite{Leisenring}, oppure il libro di testo +di Hilbert; collegato alla costante +$\iota$ nella formulazione di Church della logica di ordine superiore. Per maggiori dettagli, +si veda lo scritto +originale +di Church\index{Church, A.} \cite{Church}, il libro di +Leinsenring\index{Leisenring, A.} +del simbolo-$\hilbert$ di Hilbert \cite{Leisenring}, oppure il libro di testo di Andrews sulla teoria dei tipi \cite{Andrews}. \end{description} @@ -89,13 +89,13 @@ \section{La Teoria {\tt min}}\label{minTheory} \section{Teorie di Base} -Le teorie pi di base in HOL forniscono il supporto per una collezione standard -di tipi. La teoria \theoryimp{bool} definisce la base della -logica \HOL{}, includendo le operazioni booleane e -i quantificatori. Su questa piattaforma si pu gi costruire un bel p -d'infrastruttura di dimostrazione di teoremi. Ulteriori tipi base sono sviluppati -nella teoria delle coppie (\theoryimp{prod}), delle somme disgiunte -(\theoryimp{sum}), del tipo di un solo elemento (\theoryimp{one}), e del +Le teorie pi di base in HOL forniscono il supporto per una collezione standard +di tipi. La teoria \theoryimp{bool} definisce la base della +logica \HOL{}, includendo le operazioni booleane e +i quantificatori. Su questa piattaforma si pu gi costruire un bel p +d'infrastruttura di dimostrazione di teoremi. Ulteriori tipi base sono sviluppati +nella teoria delle coppie (\theoryimp{prod}), delle somme disgiunte +(\theoryimp{sum}), del tipo di un solo elemento (\theoryimp{one}), e del tipo (\theoryimp{option}). @@ -103,30 +103,30 @@ \subsection{La teoria \theoryimp{bool}}\label{boolfull} \index{assiomi!primitivi, della logica HOL@primitivi, della logica \HOL{}|(} % -All'avvio, la teoria iniziale per gli utenti del sistema \HOL{} -chiamata \ml{bool}\index{HOL@\HOL{}}, che costruita quando viene eseguito -il build del sistema \HOL{}. La teoria \theoryimp{bool} un'estensione -della combinazione delle teorie ``concettuali'' \theory{LOG} e +All'avvio, la teoria iniziale per gli utenti del sistema \HOL{} +chiamata \ml{bool}\index{HOL@\HOL{}}, che costruita quando viene eseguito +il build del sistema \HOL{}. La teoria \theoryimp{bool} un'estensione +della combinazione delle teorie ``concettuali'' \theory{LOG} e \theory{INIT}, descritte in \LOGIC. Cos essa contiene i quattro assiomi % \index{assiomi!nella teoria bool@nella teoria \ml{bool}} % -per la logica di ordine superiore. Questi assiomi, insieme con le regole -d'inferenza descritte nella Sezione~\ref{rules}, costituiscono il nucleo della +per la logica di ordine superiore. Questi assiomi, insieme con le regole +d'inferenza descritte nella Sezione~\ref{rules}, costituiscono il nucleo della logica \HOL{}. A causa del modo in cui il sistema \HOL{} si evoluto dall'\LCF% % \index{LCF@\LCF}% % -\footnote{Per semplificare il porting degli strumenti di dimostrazione di teoremi LCF al - sistema HOL, la logica HOL stata resa quanto pi simile possibile a - PP$\lambda$ (la logica incorporata in LCF).}, la particolare assiomatizzazione -della logica di ordine superiore che esso usa differisce dall'assiomatizzazione -classica dovuta a Church\index{Church, A.} \cite{Church}. La +\footnote{Per semplificare il porting degli strumenti di dimostrazione di teoremi LCF al + sistema HOL, la logica HOL stata resa quanto pi simile possibile a + PP$\lambda$ (la logica incorporata in LCF).}, la particolare assiomatizzazione +della logica di ordine superiore che esso usa differisce dall'assiomatizzazione +classica dovuta a Church\index{Church, A.} \cite{Church}. La differenza pi grande che nella formulazione di Church le variabili di tipo % \index{variabili di tipo, nella logica HOL@variabili di tipo, nella logica \HOL{}!differenza da quelle classiche} % -sono nel meta-linguaggio, mentre nella logica \HOL{} esse sono parte del +sono nel meta-linguaggio, mentre nella logica \HOL{} esse sono parte del linguaggio oggetto. Le costanti logiche @@ -166,8 +166,8 @@ \subsection{La teoria \theoryimp{bool}}\label{boolfull} % \index{eguaglianza, nella logica HOL@eguaglianza, nella logica \HOL{}} % -implicazione e scelta. Le definizioni elencate di sotto sono abbastanza -standard; ognuna preceduta dal suo nome \ML{}. Le definizioni posteriori +implicazione e scelta. Le definizioni elencate di sotto sono abbastanza +standard; ognuna preceduta dal suo nome \ML{}. Le definizioni posteriori a volte sono costruite sulla base di quelle precedenti. \begin{hol} @@ -230,14 +230,14 @@ \subsection{La teoria \theoryimp{bool}}\label{boolfull} ETA_AX |- !t. (\x. t x) = t - SELECT_AX |- !P:'a->bool x. P x ==> P($@ P) + SELECT_AX |- !P:'a->bool x. P x ==> P($@ P) \end{verbatim} \end{hol} \noindent -Il quarto ed ultimo assioma della logica \HOL{} l'Assioma -dell'Infinito\index{assioma dell'infinito}. Il suo enunciato formulato in termini delle -propriet di funzione {\small\verb+ONE_ONE+} e {\small\verb+ONTO+}. Le +Il quarto ed ultimo assioma della logica \HOL{} l'Assioma +dell'Infinito\index{assioma dell'infinito}. Il suo enunciato formulato in termini delle +propriet di funzione {\small\verb+ONE_ONE+} e {\small\verb+ONTO+}. Le definizioni sono: \begin{hol} @@ -264,29 +264,29 @@ \subsection{La teoria \theoryimp{bool}}\label{boolfull} \end{hol} % \noindent -Questo asserisce che esiste una mappa uno-a-uno da \holtxt{ind} a -s stesso che non suriettiva. Questo implica che il tipo \holtxt{ind} +Questo asserisce che esiste una mappa uno-a-uno da \holtxt{ind} a +s stesso che non suriettiva. Questo implica che il tipo \holtxt{ind} denota un insieme infinito. % \index{assiomi!primitive, della logica HOL@primitive, della logica \HOL{}|)} -Gli altri tre assiomi della teoria \theoryimp{bool}, le regole -d'inferenza nella Sezione~\ref{rules} e l'Assioma dell'Infinito sono, -insieme, sufficienti per sviluppare tutta la matematica standard. Cos, -in linea di principio, l'utente del sistema \HOL{} non dovrebbe avere mai bisogno -di fare una teoria +Gli altri tre assiomi della teoria \theoryimp{bool}, le regole +d'inferenza nella Sezione~\ref{rules} e l'Assioma dell'Infinito sono, +insieme, sufficienti per sviluppare tutta la matematica standard. Cos, +in linea di principio, l'utente del sistema \HOL{} non dovrebbe avere mai bisogno +di fare una teoria % \index{assiomi!dispensabilit di aggiungere} \index{teorie definizionali} % -non-definizionale. In pratica, spesso molto allettante correre il rischio di -introdurre nuovi assiomi perch derivarli dalle definizioni pu essere -noioso---dimostrare che gli `assiomi' seguono da definizioni equivale a +non-definizionale. In pratica, spesso molto allettante correre il rischio di +introdurre nuovi assiomi perch derivarli dalle definizioni pu essere +noioso---dimostrare che gli `assiomi' seguono da definizioni equivale a dimostrare la loro coerenza. \paragraph {Ulteriori definizioni} -La teoria \theoryimp{bool} fornisce anche le definizioni di un numero di +La teoria \theoryimp{bool} fornisce anche le definizioni di un numero di utili costanti. \begin{hol} \index{COND, la costante HOL@\holtxt{COND}, la costante \HOL{}} @@ -303,42 +303,42 @@ \subsection{La teoria \theoryimp{bool}}\label{boolfull} % \index{termini-let, nella logica HOL@termini-\holtxt{let}, nella logica \HOL{}!costante per} % - usata nella rappresentazione di termini che contengono binding per variabili locali (cio + usata nella rappresentazione di termini che contengono binding per variabili locali (cio termini-\holtxt{let}). % \index{termini-let, nella logica HOL@termini-\holtxt{let}, nella logica \HOL{}!assioma definizionale per} % -Per esempio, la sintassi concreta \holtxt{let v = M in N} tradotta -dal parser al termine \holtxt{LET (\bs{}v.N) M}. Per la descrizione -completa di come le espressioni \holtxt{let} sono tradotte, si veda +Per esempio, la sintassi concreta \holtxt{let v = M in N} tradotta +dal parser al termine \holtxt{LET (\bs{}v.N) M}. Per la descrizione +completa di come le espressioni \holtxt{let} sono tradotte, si veda la Sezione \ref{prod}. -La costante \holtxt{COND} usata per rappresentare espressioni +La costante \holtxt{COND} usata per rappresentare espressioni condizionali. La sintassi concreta % \index{termini, nella logica HOL@termini, nella logica \HOL{}!condizionali}% \index{condizionali, nella logica HOL@v, nella logica \HOL{}}% % -$\holtxt{if}\;t_1\;\holtxt{then}\;t_2\;\holtxt{else}\;t_3$ abbrevia +$\holtxt{if}\;t_1\;\holtxt{then}\;t_2\;\holtxt{else}\;t_3$ abbrevia l'applicazione \holtxt{COND $t_1$ $t_2$ $t_3$}. -La costante \holtxt{IN} (scritta come un infisso) la base -della modellazione degli insiemi attraverso funzioni caratteristiche. Il termine -$x\holtxt{ IN }P$ pu essere letto come ``$x$ un elemento dell'insieme -$P$'', o (pi in linea con la sua definizione) come ``il predicato $P$ +La costante \holtxt{IN} (scritta come un infisso) la base +della modellazione degli insiemi attraverso funzioni caratteristiche. Il termine +$x\holtxt{ IN }P$ pu essere letto come ``$x$ un elemento dell'insieme +$P$'', o (pi in linea con la sua definizione) come ``il predicato $P$ vero di $x$''. -Infine, la costante polimorfica $\holtxt{ARB}:\alpha$ denota un -elemento arbitrario fissato. \holtxt{ARB} occasionalmente utile quando +Infine, la costante polimorfica $\holtxt{ARB}:\alpha$ denota un +elemento arbitrario fissato. \holtxt{ARB} occasionalmente utile quando si tenta di trattare con il problema della parzialit. \subsubsection{Quantificatori ristretti}\label{res-quant} \index{quantificazione ristretta} % -La teoria \theoryimp{bool} definisce anche costanti che implementano -la \emph{quantificazione ristretta}. Questa fornisce un mezzo per simulare -sotto-tipi e tipi dipendenti con dei predicati. Quelle usate pi pesantemente +La teoria \theoryimp{bool} definisce anche costanti che implementano +la \emph{quantificazione ristretta}. Questa fornisce un mezzo per simulare +sotto-tipi e tipi dipendenti con dei predicati. Quelle usate pi pesantemente sono le restrizioni dei quantificatori esistenziale e universale: % \begin{verbatim} @@ -352,16 +352,16 @@ \subsubsection{Quantificatori ristretti}\label{res-quant} (RES_ABSTRACT P m1 = RES_ABSTRACT P m2) \end{verbatim} % -La definizione di \ml{RES\_ABSTRACT} una formula caratterizzante, piuttosto +La definizione di \ml{RES\_ABSTRACT} una formula caratterizzante, piuttosto che un'equazione diretta. Ci sono due propriet importanti \begin{itemize} \item se $y$ un elemento di $P$ allora $(\bs{}x :: P.\; M) y = M[y/x]$ -\item se due astrazioni ristrette concordano per tutti i valori sul loro +\item se due astrazioni ristrette concordano per tutti i valori sul loro insieme (comune) di restrizione, allora sono uguali. \end{itemize} -Per completezza, sono fornite le versioni ristrette dell'esistenza unica e +Per completezza, sono fornite le versioni ristrette dell'esistenza unica e della descrizione indefinita, bench difficilmente usate. \begin{verbatim} RES_EXISTS_UNIQUE_DEF @@ -372,13 +372,13 @@ \subsubsection{Quantificatori ristretti}\label{res-quant} |- RES_SELECT = \P m. @x. x IN P /\ m x \end{verbatim} -La definizione di \ml{RES\_EXISTS\_UNIQUE} usa la sintassi della -quantificazione ristretta con il simbolo {\small\verb+::+}, che si riferisce +La definizione di \ml{RES\_EXISTS\_UNIQUE} usa la sintassi della +quantificazione ristretta con il simbolo {\small\verb+::+}, che si riferisce alle precedenti definizioni \ml{RES\_EXISTS} e \ml{RES\_FORALL}. -La sintassi \texttt{::} usata con i quantificatori ristretti per permettere -predicati arbitrari per restringere le variabili di binding. Il parser \HOL{} -permette la quantificazione ristretta su tutte le variabili di una sequenza di variabili -di binding mettendo la restrizione alla fine della sequenza, cos +La sintassi \texttt{::} usata con i quantificatori ristretti per permettere +predicati arbitrari per restringere le variabili di binding. Il parser \HOL{} +permette la quantificazione ristretta su tutte le variabili di una sequenza di variabili +di binding mettendo la restrizione alla fine della sequenza, cos con una quantificazione universale: % \[ @@ -392,41 +392,41 @@ \subsubsection{Forme sintattiche derivate}\label{derived-terms} \index{quotation, nella logica HOL@quotation, nella logica \HOL{}!of non-primitive terms|(} % don't refill the \index entries above, it's important to keep each % entry on one line -Il parser delle quotation di \HOL{} +Il parser delle quotation di \HOL{} % \index{quotation, nella logica HOL@quotation, nella logica \HOL{}!parser per} % -pu tradurre varie notazioni logiche +pu tradurre varie notazioni logiche standard % \index{parsing, della logica HOL@parsing, della logica \HOL{}!delle notazioni standard} % -in termini primitivi. Per esempio, se \ml{+} stato dichiarato un +in termini primitivi. Per esempio, se \ml{+} stato dichiarato un infisso % \index{infissi, nella logica HOL@infissi, nella logica \HOL{}} % -(come spiegato nella Sezione~\ref{theoryfns}), come avviene quando - stata caricata \ml{arithmeticTheory}, allora \ml{``x+1``} +(come spiegato nella Sezione~\ref{theoryfns}), come avviene quando + stata caricata \ml{arithmeticTheory}, allora \ml{``x+1``} tradotto in \ml{``\$+~x~1``}. Il carattere di escape \ml{\$} % \index{ escape, nel parser della logica HOL@\ml{\$} (escape, nel parser della logica \HOL{})} \index{costanti dichiarate, nella logica HOL@costanti dichiarate, nella logica \HOL{}} \index{infissi, nella logica HOL@infissi, nella logica \HOL{}} % -sopprime il comportamento infisso di \ml{+} e impedisce al parser delle -quotation di rimanere confuso. In generale, \ml{\$} pu essere usato per sopprimere +sopprime il comportamento infisso di \ml{+} e impedisce al parser delle +quotation di rimanere confuso. In generale, \ml{\$} pu essere usato per sopprimere qualsiasi comportamento sintattico speciale che un token (come \texttt{if}, \texttt{+} o \texttt{let}) % \index{token!sopprimere il comportamento di parsing di} % -potrebbe avere. Questo illustrato nella tabella di sotto, in cui i termini -nella colonna intestata \textit{`Quotation \ML{}'} sono tradotti dal -parser di quotation nei corrispondenti termini nella colonna intestata -\textit{`Termine primitivo'}. Invece, i termini nell'ultima colonna -sono sempre stampati nella forma mostrata nella prima. Le espressioni -costruttore \ML{} nella colonna pi a destra sono valutate agli stessi +potrebbe avere. Questo illustrato nella tabella di sotto, in cui i termini +nella colonna intestata \textit{`Quotation \ML{}'} sono tradotti dal +parser di quotation nei corrispondenti termini nella colonna intestata +\textit{`Termine primitivo'}. Invece, i termini nell'ultima colonna +sono sempre stampati nella forma mostrata nella prima. Le espressioni +costruttore \ML{} nella colonna pi a destra sono valutate agli stessi valori (di tipo \ml{term}) come le altre quotation nella stessa riga. \bigskip @@ -506,11 +506,11 @@ \subsubsection{Forme sintattiche derivate}\label{derived-terms} \bigskip -Ci sono costruttori, de-costruttori, e indicatori per tutti i costrutti -ovvi. (Gli indicatori, ad esempio \ml{is\_neg}, restituiscono valori di verit -che indicano se un termine appartiene o meno alla classe di sintassi in -questione.) In aggiunta ai costruttori elencati nella tabella ci sono -costruttori, de-costruttori, e indicatori per coppie e liste, +Ci sono costruttori, de-costruttori, e indicatori per tutti i costrutti +ovvi. (Gli indicatori, ad esempio \ml{is\_neg}, restituiscono valori di verit +che indicano se un termine appartiene o meno alla classe di sintassi in +questione.) In aggiunta ai costruttori elencati nella tabella ci sono +costruttori, de-costruttori, e indicatori per coppie e liste, cio \ml{mk\_pair}, % \index{mk_pair@\ml{mk\_pair}} @@ -523,25 +523,25 @@ \subsubsection{Forme sintattiche derivate}\label{derived-terms} % \index{mk_list@\ml{mk\_list}} % -(si veda \REFERENCE). Le costanti \holtxt{COND} e \holtxt{LET} sono +(si veda \REFERENCE). Le costanti \holtxt{COND} e \holtxt{LET} sono spiegate nella Sezione~\ref{boolfull}. Le costanti \holtxt{\bs/}, % \index{disgiunzione, nella logica HOL@disgiunzione, nella logica \HOL{}!sintassi di} % -\holtxt{/\bs}, \holtxt{==>} e \holtxt{=} sono esempi di +\holtxt{/\bs}, \holtxt{==>} e \holtxt{=} sono esempi di \textit{infissi} e rappresentano $\vee$, $\wedge$, $\imp$ e l'eguaglianza, -rispettivamente. Se $c$ dichiarato essere un infisso, allora il parser +rispettivamente. Se $c$ dichiarato essere un infisso, allora il parser \HOL{} tradurr $t_1\ c\ t_2$ in {\small\verb+$+}$c\ t_1\ t_2$. -Le costanti {\small\verb+!+}, {\small\verb+?+} e {\small\verb+@+} +Le costanti {\small\verb+!+}, {\small\verb+?+} e {\small\verb+@+} sono esempi di \label{binder} \textit{binder} % \index{binder, nella logica HOL@binder, nella logica \HOL{}} % -e rappresentano $\forall$, $\exists$ e $\hilbert$, rispettivamente. Se -$c$ dichiarata essere un binder, allora il parser \HOL{} tradurr -\holtxt{$c$ $x$.$t$} nella combinazione \holtxt{\$$c$(\bs$x$.$t$)} -(cio l'applicazione della costante $c$ alla rappresentazione +e rappresentano $\forall$, $\exists$ e $\hilbert$, rispettivamente. Se +$c$ dichiarata essere un binder, allora il parser \HOL{} tradurr +\holtxt{$c$ $x$.$t$} nella combinazione \holtxt{\$$c$(\bs$x$.$t$)} +(cio l'applicazione della costante $c$ alla rappresentazione dell'astrazione $\lquant{x}t$). \index{ binder astrazione di funzione, nella logica HOL@\holtxt{\bs} (binder astrazione di funzione, nella logica \HOL{})} @@ -580,10 +580,10 @@ \subsubsection{Forme sintattiche derivate}\label{derived-terms} \end{tabular} \end{center} -\noindent Ci sono anche costruttori +\noindent Ci sono anche costruttori \ml{list\_mk\_conj}\index{list_mk_conj@\ml{list\_mk\_conj}}, \ml{list\_mk\_disj}\index{list_mk_disj@\ml{list\_mk\_disj}} e -\ml{list\_mk\_imp}\index{list_mk_imp@\ml{list\_mk\_imp}} +\ml{list\_mk\_imp}\index{list_mk_imp@\ml{list\_mk\_imp}} per le congiunzioni, le disgiunzioni, e le implicazioni rispettivamente. Le corrispondenti funzioni de-costruttore sono chiamate \ml{strip\_comb}, ecc., % @@ -595,9 +595,9 @@ \subsubsection{Forme sintattiche derivate}\label{derived-terms} \subsubsection{Teoremi} -Nella teoria \theoryimp{bool} sono pre-dimostrati molti teoremi che coinvolgono -costanti logiche. I seguenti teoremi -illustrano come la logica di ordine superiore permette l'espressione concisa di +Nella teoria \theoryimp{bool} sono pre-dimostrati molti teoremi che coinvolgono +costanti logiche. I seguenti teoremi +illustrano come la logica di ordine superiore permette l'espressione concisa di teoremi che supportano lo spostamento del quantificatore. \begin{holboxed} @@ -630,7 +630,7 @@ \subsubsection{Teoremi} \end{verbatim} \end{holboxed} -Inoltre, dimostrato un teorema che giustifica la Skolemizzazione +Inoltre, dimostrato un teorema che giustifica la Skolemizzazione ({\small\verb+SKOLEM_THM+}). Nella teoria \theoryimp{bool} si possono trovare molti altri teoremi. @@ -673,7 +673,7 @@ \subsection{Combinatori} \end{verbatim} \end{hol} -\noindent Le seguenti propriet elementari sono dimostrate nella teoria +\noindent Le seguenti propriet elementari sono dimostrate nella teoria \ml{combin}: \begin{hol} @@ -710,14 +710,14 @@ \subsection{Combinatori} % \index{variabili, nella logica HOL@variabili, nella logica \HOL{}!con nomi di costanti} % -talvolta non conveniente perch spesso essi sono desiderati come nomi -mnemonici per variabili (ad esempio \ml{S} varia su insiemi e \ml{o} -varia su output)\footnote{Le costanti dichiarate nelle nuove teorie possono - riutilizzare liberamente questi nomi, con input ambigui risolti dall'inferenza - di tipo.}. Si possono usare variabili con questi nomi nel sistema -attuale se \ml{o}, \ml{S}, \ml{K}, \ml{I}, \ml{W}, e \ml{C} sono prima -nascosti (si veda la Sezione~\ref{hidden}). Di fatto, questo accade cos spesso -con la costante \holtxt{C} che essa `nascosta' di default. Quando +talvolta non conveniente perch spesso essi sono desiderati come nomi +mnemonici per variabili (ad esempio \ml{S} varia su insiemi e \ml{o} +varia su output)\footnote{Le costanti dichiarate nelle nuove teorie possono + riutilizzare liberamente questi nomi, con input ambigui risolti dall'inferenza + di tipo.}. Si possono usare variabili con questi nomi nel sistema +attuale se \ml{o}, \ml{S}, \ml{K}, \ml{I}, \ml{W}, e \ml{C} sono prima +nascosti (si veda la Sezione~\ref{hidden}). Di fatto, questo accade cos spesso +con la costante \holtxt{C} che essa `nascosta' di default. Quando nascosta, deve essere scritta nella sua forma completamente-qualificata, come \holtxt{combin\$C}. % @@ -732,7 +732,7 @@ \subsection{Coppie}\label{prod} \index{coppie, nella logica HOL@coppie, nella logica \HOL{}|(} \index{tipi prodotto!nella logica HOL@in \HOL{} logic|(} % -L'operatore di prodotto Cartesiano +L'operatore di prodotto Cartesiano % \index{operatori di tipo, nella logica HOL@operatori di tipo, nella logica \HOL{}!per coppie} % @@ -740,14 +740,14 @@ \subsection{Coppie}\label{prod} % \index{prod, l'operatore di tipo HOL@\holtxt{prod}, l'operatore di tipo \HOL{}} % - definito nella teoria \theoryimp{pair}. I valori di tipo -\holtxt{($\sigma_1$,$\sigma_2$)prod} sono coppie ordinate il cui primo -componente ha il tipo $\sigma_1$ e il cui secondo componente ha il tipo -$\sigma_2$. Il parser di tipo \HOL{} + definito nella teoria \theoryimp{pair}. I valori di tipo +\holtxt{($\sigma_1$,$\sigma_2$)prod} sono coppie ordinate il cui primo +componente ha il tipo $\sigma_1$ e il cui secondo componente ha il tipo +$\sigma_2$. Il parser di tipo \HOL{} % \index{parsing, della logica HOL@parsing, della logica \HOL{}!of pairs} % -converte le espressioni di tipo della forma \holtxt{:$\sigma_1$\#$\sigma_2$} +converte le espressioni di tipo della forma \holtxt{:$\sigma_1$\#$\sigma_2$} % \index{ operatore di tipo prodotto, nella logica HOL@\holtxt{\#} (operatore di tipo prodotto, nella logica \HOL{})} % @@ -768,20 +768,20 @@ \subsection{Coppie}\label{prod} \end{hol} \noindent -cos, per esempio, se $t_1$ e $t_2$ hanno i tipi $\sigma_1$ e -$\sigma_2$ rispettivamente, allora $t_1$\ml{,}$t_2$ un termine con tipo -$\sigma_1$\holtxt{\#}$\sigma_2$. Di solito, le coppie sono scritte all'interno -di parentesi: \holtxt{($t_1$,$t_2$)}. Il simbolo virgola associa +cos, per esempio, se $t_1$ e $t_2$ hanno i tipi $\sigma_1$ e +$\sigma_2$ rispettivamente, allora $t_1$\ml{,}$t_2$ un termine con tipo +$\sigma_1$\holtxt{\#}$\sigma_2$. Di solito, le coppie sono scritte all'interno +di parentesi: \holtxt{($t_1$,$t_2$)}. Il simbolo virgola associa % \index{costruttore di accoppiamento, nella logica HOL@costruttore di accoppiamento, nella logica \HOL{}!associativit di} % -a destra, cos che \holtxt{($t_1$,$t_2$,$\ldots$,$t_n$)} significa +a destra, cos che \holtxt{($t_1$,$t_2$,$\ldots$,$t_n$)} significa \holtxt{($t_1$,($t_2$,$\ldots$,$t_n$))}. \paragraph {Definire il tipo prodotto} -Il tipo dei prodotti Cartesiani definito rappresentando una coppia -{\small\verb%(%}$t_1${\small\verb%,%}$t_2${\small\verb%)%} +Il tipo dei prodotti Cartesiani definito rappresentando una coppia +{\small\verb%(%}$t_1${\small\verb%,%}$t_2${\small\verb%)%} per mezzo della funzione % \begin{hol} @@ -790,11 +790,11 @@ \subsection{Coppie}\label{prod} \end{alltt} \end{hol} % -\noindent Il tipo rappresentante di -$\sigma_1${\small\verb%#%}$\sigma_2$ cos +\noindent Il tipo rappresentante di +$\sigma_1${\small\verb%#%}$\sigma_2$ cos $\sigma_1${\small\verb%->%}$\sigma_2${\small\verb%->bool%}. -E' facile dimostrare il seguente teorema\footnote{Questo teorema ha -un $\beta$-redex non ridotto al fine di soddisfare l'interfaccia +E' facile dimostrare il seguente teorema\footnote{Questo teorema ha +un $\beta$-redex non ridotto al fine di soddisfare l'interfaccia richiesta dal principio di definizione di tipo}. % \begin{hol} @@ -813,8 +813,8 @@ \subsection{Coppie}\label{prod} \end{hol} % Poi, sono introdotte le funzioni di rappresentazione e astrazione \holtxt{REP\_prod} -e \holtxt{ABS\_prod} per il nuovo tipo, insieme con il -seguente teorema caratterizzante, per mezzo dell'uso della funzione +e \holtxt{ABS\_prod} per il nuovo tipo, insieme con il +seguente teorema caratterizzante, per mezzo dell'uso della funzione \ml{define\_new\_type\_bijections}. % \begin{hol} @@ -826,10 +826,10 @@ \subsection{Coppie}\label{prod} \paragraph {Coppie e proiezioni} -Il costruttore infisso `{\small\verb%,%}' poi definito -essere un'applicazione della funzione di astrazione. Successivamente, sono -dimostrati due teoremi cruciali: {\small\verb+PAIR_EQ+} afferma che coppie -uguali hanno componenti uguali e {\small\verb+ABS_PAIR_THM+} mostra che +Il costruttore infisso `{\small\verb%,%}' poi definito +essere un'applicazione della funzione di astrazione. Successivamente, sono +dimostrati due teoremi cruciali: {\small\verb+PAIR_EQ+} afferma che coppie +uguali hanno componenti uguali e {\small\verb+ABS_PAIR_THM+} mostra che ogni termine che ha un tipo prodotto pu essere decomposto in una coppia di termini. \begin{hol} \index{costruttore di accoppiamento, nella logica HOL@costruttore di accoppiamento, nella logica \HOL{}!definizione di} @@ -845,8 +845,8 @@ \subsection{Coppie}\label{prod} \end{verbatim} \end{hol} % -Skolemizzando {\small\verb+ABS_PAIR_THM+} e facendo le specifiche di costante -per {\small\verb+FST+} e {\small\verb+SND+}, sono dimostrati i +Skolemizzando {\small\verb+ABS_PAIR_THM+} e facendo le specifiche di costante +per {\small\verb+FST+} e {\small\verb+SND+}, sono dimostrati i seguenti teoremi. % \begin{hol} @@ -866,7 +866,7 @@ \subsection{Coppie}\label{prod} \paragraph{Coppie e funzioni} -In \HOL{}, una funzione di tipo $\alpha \# \beta\to\gamma$ ha sempre una +In \HOL{}, una funzione di tipo $\alpha \# \beta\to\gamma$ ha sempre una controparte di tipo $\alpha\to\beta\to\gamma$, e \emph{vice versa}. Questa conversione compiuta attraverso le funzioni \holtxt{CURRY} e \holtxt{UNCURRY}. Queste funzioni sono inverse. @@ -886,8 +886,8 @@ \subsection{Coppie}\label{prod} \paragraph {Mappare funzioni su una coppia} -Le funzioni $f : \alpha \to \gamma_1$ e $g : \beta\to\gamma_2$ possono essere -applicate in modo componente ({\small\verb+##+}, infisso) su una coppia di tipo +Le funzioni $f : \alpha \to \gamma_1$ e $g : \beta\to\gamma_2$ possono essere +applicate in modo componente ({\small\verb+##+}, infisso) su una coppia di tipo $\alpha \# \beta$ per ottenere una coppia di tipo $\gamma_1 \# \gamma_2$. % \begin{hol} @@ -900,10 +900,10 @@ \subsection{Coppie}\label{prod} \paragraph {Binder e coppie} -Quando si fanno dimostrazioni, gli enunciati che coinvolgono tuple possono prendere la forma di un -binding (quantificazione o $\lambda$-astrazione) di una variabile con un -tipo prodotto. Pu essere conveniente nei successivi passi di ragionamento -rimpiazzare le variabili con tuple di variabili. I seguenti teoremi +Quando si fanno dimostrazioni, gli enunciati che coinvolgono tuple possono prendere la forma di un +binding (quantificazione o $\lambda$-astrazione) di una variabile con un +tipo prodotto. Pu essere conveniente nei successivi passi di ragionamento +rimpiazzare le variabili con tuple di variabili. I seguenti teoremi supportano questo. % \begin{hol} @@ -921,11 +921,11 @@ \subsection{Coppie}\label{prod} \paragraph {Relazioni benfondate su coppie} La benfondatezza, definita nella Sezione \ref{prim-rec-conseq}, - una nozione utile, specialmente per dimostrare la terminazione delle -funzioni ricorsive. Per le coppie, la combinazione lessicografica -delle relazioni ({\small\verb+LEX+}, infisso) pu essere definita usando -astrazioni accoppiate. Poi il teorema che la combinazione lessicografica -delle relazioni benfondate produce [delivers n.d.t.] una relazione benfondata facile da + una nozione utile, specialmente per dimostrare la terminazione delle +funzioni ricorsive. Per le coppie, la combinazione lessicografica +delle relazioni ({\small\verb+LEX+}, infisso) pu essere definita usando +astrazioni accoppiate. Poi il teorema che la combinazione lessicografica +delle relazioni benfondate produce [delivers n.d.t.] una relazione benfondata facile da dimostrare. % \begin{hol} @@ -946,13 +946,13 @@ \subsubsection{Astrazioni accoppiate} \index{astrazione di funzione, nella logica HOL@astrazione di funzione, nella logica \HOL{}!accoppiate|(} \index{astrazione di funzione, nella logica HOL@astrazione di funzione, nella logica \HOL{}!uncurrying, nella ... accoppiata|(} -E' conveniente dal punto di vista della notazione includere l'accoppiamento nella lambda -astrazione, come un semplice meccanismo di pattern-matching. Il parser delle quotation +E' conveniente dal punto di vista della notazione includere l'accoppiamento nella lambda +astrazione, come un semplice meccanismo di pattern-matching. Il parser delle quotation \index{parsing, della logica HOL@parsing, della logica \HOL{}!di astrazioni di funzione} \index{astrazione di funzione nella logica HOL@astrazione di funzione, nella logica \HOL{}!abbreviazione per ... multipla} -\index{termini, nella logica HOL@termini, nella logica \HOL{}!astrazione di funzione} -convertir il termine -{\small\bs\texttt{(}}$x_1${\small\verb%,%}$x_2${\small\verb%).%}$t$ +\index{termini, nella logica HOL@termini, nella logica \HOL{}!astrazione di funzione} +convertir il termine +{\small\bs\texttt{(}}$x_1${\small\verb%,%}$x_2${\small\verb%).%}$t$ in {\small\verb%UNCURRY(%\bs}$x_1\ x_2${\small\verb%.%}$t${\small\verb%)%}. La trasformazione fatta ricorsivamente cos che, per esempio, % @@ -970,7 +970,7 @@ \subsubsection{Astrazioni accoppiate} \end{alltt} \end{hol} % -\noindent Pi in generale, il parser delle quotation applica ripetutamente la +\noindent Pi in generale, il parser delle quotation applica ripetutamente la trasformazione: % \begin{hol} @@ -997,13 +997,13 @@ \subsubsection{Astrazioni accoppiate} \vspace{1ex} \noindent Come risultato di questa traduzione del parser, una struttura variabile, come \ml{(x,y)} in -\ml{\bs(x,y).x+y}, non un sottotermine della astrazione -\index{astrazione di funzione, nella logica HOL@astrazione di funzione, nella logica \HOL{}!sottotermini di} +\ml{\bs(x,y).x+y}, non un sottotermine della astrazione +\index{astrazione di funzione, nella logica HOL@astrazione di funzione, nella logica \HOL{}!sottotermini di} in cui occorre; essa scompare nel parsing. \index{binder, nella logica HOL@binder, nella logica \HOL{}!parsing di} \index{parsing, della logica HOL@parsing, della logica \HOL{}!di binders} -Questo pu portare ad errori inaspettati (accompagnati da oscuri messaggi -di errore). Per esempio, l'antiquoting di una coppia nella posizione della variabile +Questo pu portare ad errori inaspettati (accompagnati da oscuri messaggi +di errore). Per esempio, l'antiquoting di una coppia nella posizione della variabile legata di una lambda astrazione fallisce: \begin{session} @@ -1021,11 +1021,11 @@ \subsubsection{Astrazioni accoppiate} ! Uncaught exception: \end{verbatim} \end{session} -Se $b$ un binder, allora \ml{$b$($x_1$,$x_2$).$t$} parsato come -\ml{$b$(\bs($x_1$,$x_2$).$t$)}, e di conseguenza trasformato come di sopra. Per -esempio, +Se $b$ un binder, allora \ml{$b$($x_1$,$x_2$).$t$} parsato come +\ml{$b$(\bs($x_1$,$x_2$).$t$)}, e di conseguenza trasformato come di sopra. Per +esempio, \ml{!(x,y).\ x > y} - parsato a\linebreak + parsato a\linebreak \ml{\$!(UNCURRY(\bs{}x.\bs{}y.\ x > y))}. \index{astrazione di funzione, nella logica HOL@astrazione di funzione, nella logica \HOL{}!accoppiata|)} \index{astrazione di funzione, nella logica HOL@astrazione di funzione, nella logica \HOL{}!uncurrying, nella ... accoppiata|)} @@ -1040,7 +1040,7 @@ \subsubsection{Termini-\texttt{let}} % \index{parsing, della logica HOL@parsing, della logica \HOL{}!di termini-let@di termini-\holtxt{let}} % -accetta termini-\ml{let} +accetta termini-\ml{let} \index{termini, nella logica HOL@termini, nella logica \HOL{}!let-@\holtxt{let}-} \index{termini-let, nella logica HOL@termini-\holtxt{let}, nella logica \HOL{}!come abbreviazioni} analoghi a quelli \ML. Per esempio, sono permessi i seguenti termini: @@ -1053,7 +1053,7 @@ \subsubsection{Termini-\texttt{let}} \end{verbatim} \end{hol} -i termini-\ml{let} sono di fatto abbreviazioni per termini ordinari che sono +i termini-\ml{let} sono di fatto abbreviazioni per termini ordinari che sono supportati in modo speciale dal parser e dal pretty printer. La costante \ml{LET} % @@ -1067,7 +1067,7 @@ \subsubsection{Termini-\texttt{let}} \end{verbatim} \end{hol} -\noindent ed usata per codificare i termini-\ml{let} nella logica. Il parser +\noindent ed usata per codificare i termini-\ml{let} nella logica. Il parser applica ripetutamente le trasformazioni: \bigskip @@ -1086,7 +1086,7 @@ \subsubsection{Termini-\texttt{let}} \bigskip -\noindent La struttura sottostante del termine si pu vedere applicando +\noindent La struttura sottostante del termine si pu vedere applicando le operazioni di de-costruzione. Per esempio: \begin{session} @@ -1105,8 +1105,8 @@ \subsubsection{Termini-\texttt{let}} \end{verbatim} \end{session} -I lettori sono incoraggiati a convincersi che le traduzioni dei -termini-\ml{let} rappresentano il significato intuitivo suggerito dalla +I lettori sono incoraggiati a convincersi che le traduzioni dei +termini-\ml{let} rappresentano il significato intuitivo suggerito dalla sintassi di superficie.% % @@ -1116,13 +1116,13 @@ \subsection{Somme disgiunte} \index{somme (unioni disgiunte), la teoria HOL delle@somme (unioni disgiunte), la teoria \HOL{} delle|(} -La teoria \theoryimp{sum} definisce l'operatore di tipo binario unione -disgiunta \holtxt{sum}. Un tipo \holtxt{($\sigma_1$,$\sigma_2$)sum} -denota l'unione disgiunta dei tipi $\sigma_1$ and $\sigma_2$. L'operatore -di tipo \holtxt{sum} pu essere definito, esattamente come stato per \holtxt{prod}, -ma i dettagli sono qui omessi\footnote{La definizione delle unioni - disgiunte nel sistema HOL dovuta a Tom Melham. I dettagli tecnici - di questa definizione si possono trovare in~\cite{Melham-banff}.} Il parser +La teoria \theoryimp{sum} definisce l'operatore di tipo binario unione +disgiunta \holtxt{sum}. Un tipo \holtxt{($\sigma_1$,$\sigma_2$)sum} +denota l'unione disgiunta dei tipi $\sigma_1$ and $\sigma_2$. L'operatore +di tipo \holtxt{sum} pu essere definito, esattamente come stato per \holtxt{prod}, +ma i dettagli sono qui omessi\footnote{La definizione delle unioni + disgiunte nel sistema HOL dovuta a Tom Melham. I dettagli tecnici + di questa definizione si possono trovare in~\cite{Melham-banff}.} Il parser di \HOL{} % \index{parsing, della logica HOL@parsing, della logica \HOL{}!dei tipi sum} @@ -1153,14 +1153,14 @@ \subsection{Somme disgiunte} \end{verbatim} \end{hol} -\noindent Queste sono tutte definite come costanti nella teoria \ml{sum}. Le -costanti \ml{INL} e \ml{INR} iniettano nei sommandi sinistro e destro, -rispettivamente. Le costanti \ml{ISL} e \ml{ISR} testano l'appartenenza ai -sommandi sinistro e destro, rispettivamente. Le costanti \ml{OUTL} e \ml{OUTR} +\noindent Queste sono tutte definite come costanti nella teoria \ml{sum}. Le +costanti \ml{INL} e \ml{INR} iniettano nei sommandi sinistro e destro, +rispettivamente. Le costanti \ml{ISL} e \ml{ISR} testano l'appartenenza ai +sommandi sinistro e destro, rispettivamente. Le costanti \ml{OUTL} e \ml{OUTR} proiettano da una somma ai sommandi sinistro e destro, rispettivamente. -Il seguente teorema dimostrato nella teoria \ml{sum}. Esso fornisce una -caratterizzazione completa e astratta del tipo somma disgiunta, ed +Il seguente teorema dimostrato nella teoria \ml{sum}. Esso fornisce una +caratterizzazione completa e astratta del tipo somma disgiunta, ed usato per giustificare la definizione delle funzioni sulle somme. \begin{hol} @@ -1169,7 +1169,7 @@ \subsection{Somme disgiunte} \end{verbatim} \end{hol} -\noindent Inoltre sono forniti i seguenti teoremi che hanno a che fare +\noindent Inoltre sono forniti i seguenti teoremi che hanno a che fare con le funzioni discriminatore \ml{ISL} e \ml{ISR}: \begin{hol} @@ -1181,7 +1181,7 @@ \subsection{Somme disgiunte} \end{verbatim} \end{hol} -\noindent La teoria \ml{sum} fornisce anche i seguenti teoremi +\noindent La teoria \ml{sum} fornisce anche i seguenti teoremi relativi alle funzioni di proiezione e ai discriminatori. \begin{hol} @@ -1202,7 +1202,7 @@ \subsection{Il tipo di un-unico-elemento}% \index{one, la teoria e il tipo HOL@\ml{one}, la teoria e il tipo \HOL{}}% La teoria \ml{one} definisce il tipo \ml{one} che contiene un solo elemento. -La costante \ml{one} specificata denotare questo elemento. I teoremi +La costante \ml{one} specificata denotare questo elemento. I teoremi pre-dimostrati nella teoria \ml{one} sono: \begin{hol} @@ -1214,18 +1214,18 @@ \subsection{Il tipo di un-unico-elemento}% \end{verbatim} \end{hol} -\noindent Questi tre teoremi sono caratterizzazioni equivalenti del tipo -con un solo valore. La teoria \ml{one} usata tipicamente nella -costruzione di tipi pi elaborati. L'unico valore del tipo -\ml{one}, pu anche essere scritto \ml{()} per analogia con il valore -unit nell'\ML. Questo anche il modo di default in cui questo valore +\noindent Questi tre teoremi sono caratterizzazioni equivalenti del tipo +con un solo valore. La teoria \ml{one} usata tipicamente nella +costruzione di tipi pi elaborati. L'unico valore del tipo +\ml{one}, pu anche essere scritto \ml{()} per analogia con il valore +unit nell'\ML. Questo anche il modo di default in cui questo valore stampato dal pretty-printer del sistema. \subsubsection{Il tipo itself} \index{itself, l'operatore di tipo HOL@\holtxt{itself}, l'operatore di tipo \HOL{}}% -L'operatore di tipo \holtxt{itself} fornisce una famiglia di tipi singleton simili a \holtxt{one}. -Cos, per ogni tipo $\alpha$, \holtxt{$\alpha$~itself} un tipo che contiene solo un unico valore. -Il nome di questo valore \holtxt{the\_value}, ma il parser e il pretty-printere sono impostati cos che per il tipo \holtxt{$\alpha$~itself}, \holtxt{the\_value} pu essere scritto come \holtxt{(:$\alpha$)} (la sintassi include le parentesi). +L'operatore di tipo \holtxt{itself} fornisce una famiglia di tipi singleton simili a \holtxt{one}. +Cos, per ogni tipo $\alpha$, \holtxt{$\alpha$~itself} un tipo che contiene solo un unico valore. +Il nome di questo valore \holtxt{the\_value}, ma il parser e il pretty-printere sono impostati cos che per il tipo \holtxt{$\alpha$~itself}, \holtxt{the\_value} pu essere scritto come \holtxt{(:$\alpha$)} (la sintassi include le parentesi). Per esempio, \holtxt{(:num)} il singolo valore che abita il tipo \holtxt{num~itself}. Il punto del tipo itself che se si definisce una funzione con \holtxt{$\alpha$~itself} come dominio, la funzione sceglie un solo valore nel suo rango, e cos si pu pensare alla funzione come se fosse una dal tipo a un valore per l'intero tipo. @@ -1250,9 +1250,9 @@ \subsubsection{Il tipo itself} \subsection{Il tipo option} \index{option, la teoria HOL delle@option, la teoria \HOL{} delle} -La teoria \theoryimp{option} definisce un operatore di tipo \verb+option+ -che `solleva' il suo tipo argomento, creando un tipo con tutti i valori -dell'argomento e un altro valore distinto in modo speciale. +La teoria \theoryimp{option} definisce un operatore di tipo \verb+option+ +che `solleva' il suo tipo argomento, creando un tipo con tutti i valori +dell'argomento e un altro valore distinto in modo speciale. I costruttori di questo tipo sono \begin{hol} \begin{verbatim} @@ -1260,13 +1260,13 @@ \subsection{Il tipo option} SOME : 'a -> 'a option \end{verbatim} \end{hol} -Le option possono essere usate per modellizzare le funzioni parziali. Se una funzione di tipo -$\alpha\rightarrow\beta$ non valori $\beta$ utili per tutti -gli input $\alpha$, allora questa distinzione pu essere contrassegnata rendendo il -rango della funzione $\beta\,\konst{option}$, e mappando i +Le option possono essere usate per modellizzare le funzioni parziali. Se una funzione di tipo +$\alpha\rightarrow\beta$ non valori $\beta$ utili per tutti +gli input $\alpha$, allora questa distinzione pu essere contrassegnata rendendo il +rango della funzione $\beta\,\konst{option}$, e mappando i valori $\alpha$ indefiniti su \holtxt{NONE}. -Come tipo induttivo, le option hanno un teorema di ricorsione che supporta la +Come tipo induttivo, le option hanno un teorema di ricorsione che supporta la definizione di funzioni ricorsive primitive su valori option. % \begin{hol} @@ -1278,7 +1278,7 @@ \subsection{Il tipo option} (h NONE = e) \end{verbatim} \end{hol} -La teoria \theoryimp{option} definisce anche una costante case che permette +La teoria \theoryimp{option} definisce anche una costante case che permette di ispezionare i valori option in un stile ``pattern-matching''. \begin{hol} \begin{verbatim} @@ -1288,8 +1288,8 @@ \subsection{Il tipo option} \end{verbatim} \end{hol} % -La costante sottostante a questo addolcimento sintattico \verb+option_case+ -con la definizione +La costante sottostante a questo addolcimento sintattico \verb+option_case+ +con la definizione \begin{hol} \begin{verbatim} option_case_def |- (option_case u f NONE = u) /\ @@ -1306,8 +1306,8 @@ \subsection{Il tipo option} (OPTION_MAP f (SOME x) = SOME (f x)) \end{verbatim} \end{hol} -Infine, la funzione \holtxt{THE} prende un valore -\holtxt{SOME} per quell'argomento del costruttore, ed indefinita su +Infine, la funzione \holtxt{THE} prende un valore +\holtxt{SOME} per quell'argomento del costruttore, ed indefinita su \holtxt{NONE}: \begin{hol} \begin{verbatim} @@ -1317,31 +1317,31 @@ \subsection{Il tipo option} \section{Numeri} -I numeri naturali, gli interi, e i numeri reali sono forniti in una -serie di teorie. Sono anche disponibili teorie di parole di $n$-bit +I numeri naturali, gli interi, e i numeri reali sono forniti in una +serie di teorie. Sono anche disponibili teorie di parole di $n$-bit (numeri modulo $2^n$), numeri a virgola mobile e numeri a virgola fissa. \subsection{Numeri naturali} -I numeri naturali sono sviluppati in una serie di teorie: +I numeri naturali sono sviluppati in una serie di teorie: \theoryimp{num}, \theoryimp{prim\_rec}, \theoryimp{arithmetic}, e -\theoryimp{numeral}. In \theoryimp{num}, il tipo dei numeri -definito dall'Assioma dell'Infinito, e sono derivati gli assiomi di Peano. In -\theoryimp{prim\_rec} dimostrato il teorema di Ricorsione Primitiva. Sulla base -di questo, in \theoryimp{arithmetic} sviluppata un'ampia teoria che tratta le operazioni aritmetiche -standard. Da ultimo, sviluppata una teoria dei +\theoryimp{numeral}. In \theoryimp{num}, il tipo dei numeri +definito dall'Assioma dell'Infinito, e sono derivati gli assiomi di Peano. In +\theoryimp{prim\_rec} dimostrato il teorema di Ricorsione Primitiva. Sulla base +di questo, in \theoryimp{arithmetic} sviluppata un'ampia teoria che tratta le operazioni aritmetiche +standard. Da ultimo, sviluppata una teoria dei numerali. \subsubsection{La teoria \theoryimp{num}} La teoria \theoryimp{num} \index{num, la teoria nella logica HOL@\ml{num}, la teoria nella logica \HOL{}} -definisce che il tipo \ml{num} dei numeri naturali -isomorfo a un sottoinsieme numerabile del tipo primitivo \ml{ind}. In questa +definisce che il tipo \ml{num} dei numeri naturali +isomorfo a un sottoinsieme numerabile del tipo primitivo \ml{ind}. In questa teoria, sono definite le costanti \ml{0} \index{ zero, nella logica HOL@\ml{0} (zero, nella logica \HOL{})} -e \ml{SUC} (la funzione successore) -e gli assiomi di Peano +e \ml{SUC} (la funzione successore) +e gli assiomi di Peano \index{assiomi!nella teoria num@nella teoria \ml{num}} \index{gli assiomi di Peano} \index{assiomi!non-primitivi, della logica HOL@non-primitive, della logica \HOL{}!per i numeri naturali} @@ -1358,10 +1358,10 @@ \subsubsection{La teoria \theoryimp{num}} \end{verbatim} \end{hol} -Nella logica di ordine superiore, gli assiomi di Peano sono sufficienti per sviluppare -la teoria dei numeri perch possono essere definite l'addizione e la moltiplicazione. Nella -logica del primo ordine queste devono essere prese come primitive. Si noti anche che -\ml{INDUCTION} non potrebbe essere enunciato come un singolo assioma nella logica del +Nella logica di ordine superiore, gli assiomi di Peano sono sufficienti per sviluppare +la teoria dei numeri perch possono essere definite l'addizione e la moltiplicazione. Nella +logica del primo ordine queste devono essere prese come primitive. Si noti anche che +\ml{INDUCTION} non potrebbe essere enunciato come un singolo assioma nella logica del primo ordine perch i predicati (ad esempio \holtxt{P}) non possono essere quantificati. \subsubsection{La teoria \theoryimp{prim\_rec}} @@ -1377,30 +1377,30 @@ \subsubsection{La teoria \theoryimp{prim\_rec}} % \index{definizioni ricorsive, nelle logiche classiche} % -non sono permesse. Per esempio, non c' alcuna funzione $f$ (di tipo +non sono permesse. Per esempio, non c' alcuna funzione $f$ (di tipo \ml{num->num}) tale che \begin{alltt} !\(x\). \(f\) \(x\) = (\(f\) \(x\)) + 1 \end{alltt} -Certe ristrette forme di definizione +Certe ristrette forme di definizione % \index{funzioni ricorsive primitive} % -ricorsiva, comunque, definiscono funzioni in modo univoco. Un esempio -importante sono le funzioni \emph{ricorsive primitive}\footnote{Nella - logica di ordine superiore, la ricorsione primitiva molto pi potente che - nella logica del primo ordine; per esempio la funzione di Ackermann pu essere - definita per ricorsione primitiva nella logica di ordine superiore.}. Per qualsiasi $x$ -e $f$ il \emph{teorema di ricorsione primitiva} ci dice che c' +ricorsiva, comunque, definiscono funzioni in modo univoco. Un esempio +importante sono le funzioni \emph{ricorsive primitive}\footnote{Nella + logica di ordine superiore, la ricorsione primitiva molto pi potente che + nella logica del primo ordine; per esempio la funzione di Ackermann pu essere + definita per ricorsione primitiva nella logica di ordine superiore.}. Per qualsiasi $x$ +e $f$ il \emph{teorema di ricorsione primitiva} ci dice che c' un'unica funzione \holtxt{fn} tale che: \begin{alltt} (fn 0 = \(x\)) /\bs (!\(n\). fn(SUC \(n\)) = f (fn \(n\)) \(n\)) \end{alltt} -Il teorema di ricorsione primitiva, chiamato \ml{num\_Axiom} in \HOL, -segue dagli assiomi +Il teorema di ricorsione primitiva, chiamato \ml{num\_Axiom} in \HOL, +segue dagli assiomi % \index{assiomi di Peano} % @@ -1413,10 +1413,10 @@ \subsubsection{La teoria \theoryimp{prim\_rec}} \end{verbatim} \end{hol} -\noindent Il teorema stabilisce la validit delle definizioni ricorsive -primitive sui numeri naturali: per qualsiasi \ml{x} e \ml{f} esiste una -corrispondente funzione totale \ml{fn} che soddisfa -la definizione ricorsiva primitiva la cui forma determinata da \ml{x} e +\noindent Il teorema stabilisce la validit delle definizioni ricorsive +primitive sui numeri naturali: per qualsiasi \ml{x} e \ml{f} esiste una +corrispondente funzione totale \ml{fn} che soddisfa +la definizione ricorsiva primitiva la cui forma determinata da \ml{x} e \ml{f}. \paragraph{La relazione minore-di} @@ -1424,10 +1424,10 @@ \subsubsection{La teoria \theoryimp{prim\_rec}} La relazione minore-di `\holtxt{<}' \index{ minore di, nella logica HOL@\ml{<} (minore di, nella logica \HOL{})} \index{minore di, nella logica HOL@minore di, nella logica \HOL{}} - definita in modo pi naturale per ricorsione primitiva. Tuttavia, nel nostro -sviluppo richiesta per la dimostrazione del - teorema di ricorsione primitiva, cos deve essere definita prima che la definizione - per ricorsione primitiva sia disponibile. La teoria \theoryimp{prim\_rec} + definita in modo pi naturale per ricorsione primitiva. Tuttavia, nel nostro +sviluppo richiesta per la dimostrazione del + teorema di ricorsione primitiva, cos deve essere definita prima che la definizione + per ricorsione primitiva sia disponibile. La teoria \theoryimp{prim\_rec} di conseguenza contiene la seguente definizione non ricorsiva di \ml{<}: \begin{hol} @@ -1438,10 +1438,10 @@ \subsubsection{La teoria \theoryimp{prim\_rec}} \end{hol} \noindent -Questa definizione dice che {\small\verb%m < n%} se esiste un insieme (con -funzione caratteristica {\small\verb%P%}) che chiuso -verso il basso\footnote{Un insieme di numeri \textit{chiuso verso il basso} se ogni volta che -contiene il successore di un numero, contiene anche il numero.} e +Questa definizione dice che {\small\verb%m < n%} se esiste un insieme (con +funzione caratteristica {\small\verb%P%}) che chiuso +verso il basso\footnote{Un insieme di numeri \textit{chiuso verso il basso} se ogni volta che +contiene il successore di un numero, contiene anche il numero.} e contiene {\small\verb%m%} ma non {\small\verb%n%}. \index{prim_rec, la teoria HOL@\ml{prim\_rec}, la teoria \HOL{}|)} @@ -1451,10 +1451,10 @@ \subsubsection{Meccanizzazione delle definizioni ricorsive primitive} \index{definizioni ricorsive, nella logica HOL@definizioni ricorsive, nella logica \HOL{}!automatiche, per i numeri} \index{teorema di ricorsione primitiva!uso automatico del, nel sistema HOL@uso automatico del, nel sistema \HOL{}|(} -Il teorema +Il teorema \index{definizioni ricorsive primitive, nella logica HOL@definizioni ricorsive primitive, nella logica \HOL{}!giustificazione delle} -di ricorsione primitiva pu essere usato per giustificare qualsiasi definizione di una funzione -sui numeri naturali per ricorsione primitiva. Per esempio, una +di ricorsione primitiva pu essere usato per giustificare qualsiasi definizione di una funzione +sui numeri naturali per ricorsione primitiva. Per esempio, una definizione ricorsiva primitiva nella logica di ordine superiore della forma \begin{hol} @@ -1476,10 +1476,10 @@ \subsubsection{Meccanizzazione delle definizioni ricorsive primitive} \end{alltt} \end{hol} -L'esistenza di una funzione ricorsiva \ml{fun} che soddisfa queste due -equazioni segue direttamente dal teorema di ricorsione primitiva +L'esistenza di una funzione ricorsiva \ml{fun} che soddisfa queste due +equazioni segue direttamente dal teorema di ricorsione primitiva \ml{num\_Axiom} mostrato di sopra. La specializzazione delle variabili quantificate \verb!x! -e \verb!f! con un'adeguata istanziazione dei tipi di \ml{num\_Axiom} cos +e \verb!f! con un'adeguata istanziazione dei tipi di \ml{num\_Axiom} cos che \begin{hol} @@ -1497,11 +1497,11 @@ \subsubsection{Meccanizzazione delle definizioni ricorsive primitive} \end{alltt} \end{hol} -\noindent Questo teorema permette d'introdurre una costante \ml{fun} (attraverso il -meccanismo\linebreak definizionale delle specifiche di costante---si veda la Sezione~\ref{conspec}) -per denotare la funzione ricorsiva che soddisfa le due equazioni nel corpo -del teorema. L'introduzione di una costante \ml{fun} per nominare la funzione che affermata -esistere dal teorema mostrato di sopra, e la semplificazione per mezzo di una $\beta$-riduzione, +\noindent Questo teorema permette d'introdurre una costante \ml{fun} (attraverso il +meccanismo\linebreak definizionale delle specifiche di costante---si veda la Sezione~\ref{conspec}) +per denotare la funzione ricorsiva che soddisfa le due equazioni nel corpo +del teorema. L'introduzione di una costante \ml{fun} per nominare la funzione che affermata +esistere dal teorema mostrato di sopra, e la semplificazione per mezzo di una $\beta$-riduzione, porta al seguente teorema: \begin{hol} @@ -1511,8 +1511,8 @@ \subsubsection{Meccanizzazione delle definizioni ricorsive primitive} \end{alltt} \end{hol} -\noindent Segue immediatamente da questo teorema che la costante \ml{fun} -soddisfa le equazioni di definizione ricorsiva primitiva date dal teorema mostrato +\noindent Segue immediatamente da questo teorema che la costante \ml{fun} +soddisfa le equazioni di definizione ricorsiva primitiva date dal teorema mostrato di sotto: \begin{hol} @@ -1522,10 +1522,10 @@ \subsubsection{Meccanizzazione delle definizioni ricorsive primitive} \end{alltt} \end{hol} -Per automatizzare l'uso del teorema di ricorsione primitiva nel derivare -definizioni ricorsive di questo genere, il sistema \HOL{} fornisce una funzione -che automaticamente dimostra l'esistenza di funzioni ricorsive -primitive e poi fa una specifica di costante per introdurre la costante +Per automatizzare l'uso del teorema di ricorsione primitiva nel derivare +definizioni ricorsive di questo genere, il sistema \HOL{} fornisce una funzione +che automaticamente dimostra l'esistenza di funzioni ricorsive +primitive e poi fa una specifica di costante per introdurre la costante che denota una tale funzione: \begin{holboxed} @@ -1536,22 +1536,22 @@ \subsubsection{Meccanizzazione delle definizioni ricorsive primitive} \end{verbatim} \end{holboxed} -\noindent Di fatto, \ml{new\_recursive\_definition} gestisce -definizioni ricorsive primitive su un range di tipi, non solo sui +\noindent Di fatto, \ml{new\_recursive\_definition} gestisce +definizioni ricorsive primitive su un range di tipi, non solo sui numeri naturali. Per i dettagli, si veda la documentazione \REFERENCE. -In modo ancora pi conveniente, la funzione \ml{Define} (si veda -la Sezione~\ref{sec:high-level-proof-steps}) supporta la ricorsione -primitiva, insieme con altri stili di ricorsione, e non richiede -all'utente di citare l'assioma di ricorsione primitiva. Pu, tuttavia, -richiedere di eseguire dimostrazioni di terminazione; fortunatamente, non necessario +In modo ancora pi conveniente, la funzione \ml{Define} (si veda +la Sezione~\ref{sec:high-level-proof-steps}) supporta la ricorsione +primitiva, insieme con altri stili di ricorsione, e non richiede +all'utente di citare l'assioma di ricorsione primitiva. Pu, tuttavia, +richiedere di eseguire dimostrazioni di terminazione; fortunatamente, non necessario fare queste dimostrazioni per le ricorsioni primitive. \subsubsection{Scelta dipendente e benfondatezza} \label{prim-rec-conseq} -Il teorema di ricorsione primitiva utile oltre il suo scopo principale di -giustificare le definizioni ricorsive. Per esempio, la teoria +Il teorema di ricorsione primitiva utile oltre il suo scopo principale di +giustificare le definizioni ricorsive. Per esempio, la teoria \theoryimp{prim\_rec} dimostra l'Assioma di Scelta Dipendente ({\small\verb+DC+}). \begin{hol} @@ -1565,10 +1565,10 @@ \subsubsection{Scelta dipendente e benfondatezza} \end{verbatim} \end{hol} -La dimostrazione usa {\small\verb+SELECT_AX+}. Il teorema {\small\verb+DC+} - utile quando si desidera costruire una funzione che ha una certa -propriet da una relazione. Per esempio, un modo di definire la -benfondatezza di una relazione $R$ quello di dire che non ha infinite +La dimostrazione usa {\small\verb+SELECT_AX+}. Il teorema {\small\verb+DC+} + utile quando si desidera costruire una funzione che ha una certa +propriet da una relazione. Per esempio, un modo di definire la +benfondatezza di una relazione $R$ quello di dire che non ha infinite $R$ catene discendenti. % \begin{hol} @@ -1581,13 +1581,13 @@ \subsubsection{Scelta dipendente e benfondatezza} |- !R. WF R = wellfounded R \end{verbatim} \end{hol} -Per mezzo dell'uso di {\small\verb+DC+}, questo enunciato pu essere dimostrato -essere uguale alla nozione di benfondatezza {\small\verb+WF+} -(cio, che ogni insieme ha un elemento $R$-minimale) definita nella teoria +Per mezzo dell'uso di {\small\verb+DC+}, questo enunciato pu essere dimostrato +essere uguale alla nozione di benfondatezza {\small\verb+WF+} +(cio, che ogni insieme ha un elemento $R$-minimale) definita nella teoria \theoryimp{relation}. -Nella teoria \theoryimp{prim\_rec} sono anche dimostrati teoremi che affermano la benfondatezza della relazione di predecessore e -della relazione minore-di, esattamente come la benfondatezza delle funzioni +Nella teoria \theoryimp{prim\_rec} sono anche dimostrati teoremi che affermano la benfondatezza della relazione di predecessore e +della relazione minore-di, esattamente come la benfondatezza delle funzioni di misura. \begin{hol} @@ -1609,7 +1609,7 @@ \subsubsection{Scelta dipendente e benfondatezza} \subsection{Aritmetica} \index{aritmetica, la teoria HOL della@aritmetica, la teoria \HOL{} della} -La teoria \HOL{} \theoryimp{arithmetic} contiene le definizioni ricorsive +La teoria \HOL{} \theoryimp{arithmetic} contiene le definizioni ricorsive primitive, dei seguenti operatori aritmetici standard. \begin{hol} @@ -1635,8 +1635,8 @@ \subsection{Aritmetica} \end{verbatim} \end{hol} % -Si noti che \holtxt{EXP} un infisso. La notazione infissa -\holtxt{**} pu essere usata al posto di \holtxt{EXP}. Cos +Si noti che \holtxt{EXP} un infisso. La notazione infissa +\holtxt{**} pu essere usata al posto di \holtxt{EXP}. Cos (\holtxt{x EXP y}) significa $x^y$, e lo stesso vale per (\holtxt{x ** y}). \paragraph{Operatori di confronto} @@ -1657,7 +1657,7 @@ \subsection{Aritmetica} \paragraph{Divisione e modulo} Per introdurre gli operatori divisione ({\small\verb+DIV+}, infisso) e -modulo ({\small\verb+MOD+}, infisso) usata una specifica di costante, insieme con le loro +modulo ({\small\verb+MOD+}, infisso) usata una specifica di costante, insieme con le loro propriet caratterizzanti. \begin{hol} \index{MOD, la costante HOL@\ml{MOD}, la costante \HOL{}} @@ -1710,9 +1710,9 @@ \subsection{Aritmetica} \index{FUNPOW, la costante HOL@\ml{FUNPOW}, la costante \HOL{}} L'applicazione iterata $f^n x$ di una funzione $f : \alpha \to -\alpha$ definita per ricorsione primitiva. La definizione -(\ml{FUNPOW}) tail-recursive, il che pu essere scomodo per ragionarci -sopra. Una caratterizzazione alternativa (\ml{FUNPOW\_SUC}) pu essere pi facile +\alpha$ definita per ricorsione primitiva. La definizione +(\ml{FUNPOW}) tail-recursive, il che pu essere scomodo per ragionarci +sopra. Una caratterizzazione alternativa (\ml{FUNPOW\_SUC}) pu essere pi facile da applicare quando si fanno delle dimostrazioni. % \begin{hol} @@ -1727,16 +1727,16 @@ \subsection{Aritmetica} \medskip -Su questa base, quando eseguito il build di \HOL{} una serie \adhoc\ ma utile di pi duecentocinquanta -teoremi elementari sono dimostrati -e archiviati nella teoria \theoryimp{arithmetic}. Per una lista -completa dei teoremi disponibili, si veda \REFERENCE. Si veda inoltre -la Sezione~\ref{sec:while-loops} per la discussione dell'operatore +Su questa base, quando eseguito il build di \HOL{} una serie \adhoc\ ma utile di pi duecentocinquanta +teoremi elementari sono dimostrati +e archiviati nella teoria \theoryimp{arithmetic}. Per una lista +completa dei teoremi disponibili, si veda \REFERENCE. Si veda inoltre +la Sezione~\ref{sec:while-loops} per la discussione dell'operatore \holtxt{LEAST}, che restituisce il pi piccolo numero che soddisfa un predicato. \subsubsection{Informazioni sulla grammatica} -La seguente tabella da lo status di parsing delle costanti +La seguente tabella da lo status di parsing delle costanti aritmetiche. \begin{center} @@ -1759,11 +1759,11 @@ \subsubsection{Informazioni sulla grammatica} \subsection{Numerali}\label{sec:numerals} Il tipo \ml{num} -\index{num, il tipo ... nella logica \HOL{}@\ml{num}, il tipo ... nella logica \HOL{}} -di solito pensato essere fornito di una collezione infinita di -numerali: \ml{1}, \ml{2}, \ml{3}, \etc. Tuttavia, la logica \HOL{} non ha -alcun modo di definire tali famiglie infinite di costanti; piuttosto, tutti -i numerali diversi da $0$ sono di fatto costruiti dalle costanti +\index{num, il tipo ... nella logica \HOL{}@\ml{num}, il tipo ... nella logica \HOL{}} +di solito pensato essere fornito di una collezione infinita di +numerali: \ml{1}, \ml{2}, \ml{3}, \etc. Tuttavia, la logica \HOL{} non ha +alcun modo di definire tali famiglie infinite di costanti; piuttosto, tutti +i numerali diversi da $0$ sono di fatto costruiti dalle costanti introdotte dalle seguenti definizioni: \begin{verbatim} @@ -1779,14 +1779,14 @@ \subsection{Numerali}\label{sec:numerals} \[ \ml{NUMERAL}(\ml{BIT1}(\ml{BIT2}\;\ml{ZERO})) \] -e il parser e il pretty-printer di \HOL{} fanno apparire tali termini come -numerali. Questa rappresentazione binaria per i numerali permette un -calcolo asintoticamente efficiente. I teoremi che supportano i calcoli -aritmetici sui numerali si possono trovare nella teoria -\theoryimp{numeral}; questi sono meccanizzati dalla libreria \verb+reduce+. Cos, -i calcoli aritmetici sono eseguiti per passi deduttivi in \HOL. Per -esempio il seguente calcolo di $2 ^{(1023 + 14)/9}$ richiede -approssimativamente 4,200 passi d'inferenza primitiva e si completa in 30 +e il parser e il pretty-printer di \HOL{} fanno apparire tali termini come +numerali. Questa rappresentazione binaria per i numerali permette un +calcolo asintoticamente efficiente. I teoremi che supportano i calcoli +aritmetici sui numerali si possono trovare nella teoria +\theoryimp{numeral}; questi sono meccanizzati dalla libreria \verb+reduce+. Cos, +i calcoli aritmetici sono eseguiti per passi deduttivi in \HOL. Per +esempio il seguente calcolo di $2 ^{(1023 + 14)/9}$ richiede +approssimativamente 4,200 passi d'inferenza primitiva e si completa in 30 milli-secondi. % \setcounter{sessioncount}{0} @@ -1801,15 +1801,15 @@ \subsection{Numerali}\label{sec:numerals} \paragraph {Costruzione dei numerali} \index{numerali, nella logica HOL@numerali, nella logica \HOL{}!costruzione dei} -I numerali si possono naturalmente costruire usando\linebreak \ml{mk\_comb}, e si possono scomporre con -\ml{dest\_comb}; comunque, un'interfaccia pi conveniente per questa +I numerali si possono naturalmente costruire usando\linebreak \ml{mk\_comb}, e si possono scomporre con +\ml{dest\_comb}; comunque, un'interfaccia pi conveniente per questa funzionalit fornita dalle funzioni \ml{mk\_numeral}, -\ml{dest\_numeral}, e \ml{is\_numeral} (che si trovano nella structure -\ml{numSyntax}). Questi entry-point fanno uso di una structure \ML -\ml{Arbnum} che implementa numeri di precisione arbitraria {\verb+num+}. La -seguente sessione mostra come i numerali \HOL{} sono costruiti da elementi del -tipo \verb+num+ e come i numerali sono de-costruiti. La structure -{\small\verb+Arbnum+} fornisce una collezione completa di operazioni +\ml{dest\_numeral}, e \ml{is\_numeral} (che si trovano nella structure +\ml{numSyntax}). Questi entry-point fanno uso di una structure \ML +\ml{Arbnum} che implementa numeri di precisione arbitraria {\verb+num+}. La +seguente sessione mostra come i numerali \HOL{} sono costruiti da elementi del +tipo \verb+num+ e come i numerali sono de-costruiti. La structure +{\small\verb+Arbnum+} fornisce una collezione completa di operazioni aritmetiche, che usano i nomi usuali per le operazioni, ad esempio \verb|+|, \verb|*|, \verb|-|, ecc. @@ -1833,19 +1833,19 @@ \subsection{Numerali}\label{sec:numerals} \index{token!parsing dei numerali} \index{numerali, nella logica HOL@numerali, nella logica \HOL{}!parsing dei} % -Le sequenze semplici di cifre sono rese dal parser come numeri decimali, ma il parser -supporta anche l'input di numeri in notazione binaria, ottale ed -esadecimale. I numeri possono essere scritti in forma binaria ed esadecimale aggiungendo ad essi -come prefisso le stringhe \holtxt{0b} e \holtxt{0x} rispettivamente. Le -`cifre' A--F nei numeri esadecimali possono essere scritte con le lettere maiuscole o -minuscole. I numeri binari hanno le loro cifre pi significative pi a sinistra. Ai -fini della retro-compatibilit i numeri ottali non sono -abilitati di default, ma se la reference -\ml{base\_tokens.allow\_octal\_input} impostata a \ml{true}, i numeri +Le sequenze semplici di cifre sono rese dal parser come numeri decimali, ma il parser +supporta anche l'input di numeri in notazione binaria, ottale ed +esadecimale. I numeri possono essere scritti in forma binaria ed esadecimale aggiungendo ad essi +come prefisso le stringhe \holtxt{0b} e \holtxt{0x} rispettivamente. Le +`cifre' A--F nei numeri esadecimali possono essere scritte con le lettere maiuscole o +minuscole. I numeri binari hanno le loro cifre pi significative pi a sinistra. Ai +fini della retro-compatibilit i numeri ottali non sono +abilitati di default, ma se la reference +\ml{base\_tokens.allow\_octal\_input} impostata a \ml{true}, i numeri ottali sono quelli che appaiono con gli zero in testa. -Infine, tutti i numeri possono essere intervallati da caratteri di underscore -(\ml{\_}). Questi possono essere usati per raggruppare le cifre per aggiungere leggibilit +Infine, tutti i numeri possono essere intervallati da caratteri di underscore +(\ml{\_}). Questi possono essere usati per raggruppare le cifre per aggiungere leggibilit e non hanno alcun effetto semantico. Cos @@ -1867,8 +1867,8 @@ \subsection{Numerali}\label{sec:numerals} \paragraph{Numerali e numeri di Peano} -I numerali sono collegati ai numeri costruiti da \holtxt{0} e \holtxt{SUC} -attraverso la regola d'inferenza derivata \ml{num\_CONV}, che si trova +I numerali sono collegati ai numeri costruiti da \holtxt{0} e \holtxt{SUC} +attraverso la regola d'inferenza derivata \ml{num\_CONV}, che si trova nella libreria \ml{numLib}. \begin{holboxed} @@ -1878,7 +1878,7 @@ \subsection{Numerali}\label{sec:numerals} \end{verbatim} \end{holboxed} -\noindent \ml{num\_CONV} pu essere usata per generare l'equazione +\noindent \ml{num\_CONV} pu essere usata per generare l'equazione `\ml{SUC}' per qualsiasi numerale diverso da zero. Per esempio: \begin{session} @@ -1898,12 +1898,12 @@ \subsection{Numerali}\label{sec:numerals} \subsubsection{Overloading degli operatori aritmetici} \label{arith-overloading} -Quando sono caricate altre teorie numeriche (come quelle per i reali o -gli interi), i numerali sono sottoposti all'overloading cos che il numerale {\small\verb+1+} pu -stare di fatto per un numero naturale, un intero o un valore reale. Il -parser ha un passo di risoluzione dell'overloading in cui tenta di -determinare il tipo corrente da dare a un numero. Per esempio, nella -seguente sessione, la teoria degli interi caricata, dopo di che il +Quando sono caricate altre teorie numeriche (come quelle per i reali o +gli interi), i numerali sono sottoposti all'overloading cos che il numerale {\small\verb+1+} pu +stare di fatto per un numero naturale, un intero o un valore reale. Il +parser ha un passo di risoluzione dell'overloading in cui tenta di +determinare il tipo corrente da dare a un numero. Per esempio, nella +seguente sessione, la teoria degli interi caricata, dopo di che il numerale \verb+2+ considerato essere un intero. % \begin{session} @@ -1920,8 +1920,8 @@ \subsubsection{Overloading degli operatori aritmetici} \end{verbatim} \end{session} -Al fine di specificare in modo preciso il tipo desiderato, l'utente pu usare dei suffissi -di un singolo carattere (`\ml{n}' per i numeri naturali, e `\ml{i}' per +Al fine di specificare in modo preciso il tipo desiderato, l'utente pu usare dei suffissi +di un singolo carattere (`\ml{n}' per i numeri naturali, e `\ml{i}' per gli interi): \begin{session} \begin{verbatim} @@ -1933,27 +1933,27 @@ \subsubsection{Overloading degli operatori aritmetici} \end{verbatim} \end{session} -Un letterale numerico per un tipo \HOL{} diverso da \verb+num+, come -\verb+42i+, rappresentato dall'applicazione di una funzione -d'\emph{iniezione} di tipo {\small\verb+num -> ty+} per un -numerale. La funzione di iniezione differente per ogni tipo +Un letterale numerico per un tipo \HOL{} diverso da \verb+num+, come +\verb+42i+, rappresentato dall'applicazione di una funzione +d'\emph{iniezione} di tipo {\small\verb+num -> ty+} per un +numerale. La funzione di iniezione differente per ogni tipo {\small\verb+ty+}. Si veda la Sezione \ref{integers} per un'ulteriore discussione. -Le funzioni {\verb+mk_numeral+}, {\verb+dest_numeral+}, e -{\verb+is_numeral+} funzionano solo per numerali, e per letterali -numerici con suffissi di un carattere diverso da {\small\verb+n+}. Per -informazioni su come installare nuovi suffissi di un carattere, si consulti la +Le funzioni {\verb+mk_numeral+}, {\verb+dest_numeral+}, e +{\verb+is_numeral+} funzionano solo per numerali, e per letterali +numerici con suffissi di un carattere diverso da {\small\verb+n+}. Per +informazioni su come installare nuovi suffissi di un carattere, si consulti la voce \ml{add\_numeral\_form} in \REFERENCE. \subsection{Interi} \label{integers} \index{interi, la teoria HOL degli@interi, la teoria \HOL{} degli} -In \HOL{} c' un'estesa teoria degli interi. Il tipo degli interi - costruito come un quoziente su coppie di numeri naturali. E' definita -una collezione standard di operatori. Questi sono degli overload con +In \HOL{} c' un'estesa teoria degli interi. Il tipo degli interi + costruito come un quoziente su coppie di numeri naturali. E' definita +una collezione standard di operatori. Questi sono degli overload con operazioni analoghe sui numeri naturali, e sui numeri reali. -Le costanti definite nella teoria degli interi includono quelle che si trovano nella +Le costanti definite nella teoria degli interi includono quelle che si trovano nella seguente tabella. \begin{center} @@ -1975,8 +1975,8 @@ \subsection{Interi} \end{tabular}} \end{center} -Il simbolo sottoposto a overload {\small\verb+& : num -> int+} denota la -funzione d'iniezione dai numeri naturali agli interi. La seguente +Il simbolo sottoposto a overload {\small\verb+& : num -> int+} denota la +funzione d'iniezione dai numeri naturali agli interi. La seguente sessione illustra come sono trattati l'overloading e i letterali interi. \setcounter{sessioncount}{0} @@ -1998,16 +1998,16 @@ \subsection{Interi} \subsection{Numeri razionali}\label{rationals} \index{numeri razionali, la teoria HOL dei@razionali, la teoria \HOL{} dei|(} -Il tipo dei razionali costruito come un quoziente di coppie ordinate di -interi (il numeratore e il denominatore di una frazione) il cui secondo -componente non deve essere zero. Per rendere le cose pi semplici nella teoria \HOL\, -il segno di un numero razionale sempre spostato al numeratore. +Il tipo dei razionali costruito come un quoziente di coppie ordinate di +interi (il numeratore e il denominatore di una frazione) il cui secondo +componente non deve essere zero. Per rendere le cose pi semplici nella teoria \HOL\, +il segno di un numero razionale sempre spostato al numeratore. Cos, il denominatore sempre positivo. -E' definita una collezione di operatori, che sono sottoposti a overload con -operazioni analoghe sugli interi. Questi includono quelli che si trovano nella -seguente tabella. L'iniezione dai numeri naturali supportata -dal simbolo sottoposto a overload {\small\verb+& : num -> rat+} e dal +E' definita una collezione di operatori, che sono sottoposti a overload con +operazioni analoghe sugli interi. Questi includono quelli che si trovano nella +seguente tabella. L'iniezione dai numeri naturali supportata +dal simbolo sottoposto a overload {\small\verb+& : num -> rat+} e dal suffisso {\small\verb+q+}. @@ -2029,10 +2029,10 @@ \subsection{Numeri razionali}\label{rationals} \end{tabular}} \end{center} -I teoremi nella teoria dei numeri razionali includono le propriet del campo, -le regole aritmetiche la manipolazione delle (in)equazioni e la loro riduzione a -(in)equazioni tra interi, le propriet delle relazioni minore-di e la -densit dei numeri razionali. Per i dettagli, si consulti \REFERENCE\ e i +I teoremi nella teoria dei numeri razionali includono le propriet del campo, +le regole aritmetiche la manipolazione delle (in)equazioni e la loro riduzione a +(in)equazioni tra interi, le propriet delle relazioni minore-di e la +densit dei numeri razionali. Per i dettagli, si consulti \REFERENCE\ e i file sorgenti. \index{numeri razionali, la teoria HOL dei@razionali, la teoria \HOL{} dei|)} @@ -2040,20 +2040,20 @@ \subsection{Numeri razionali}\label{rationals} \subsection{Numeri reali}\label{reals} \index{numeri reali, la teoria HOL dei@numeri reali, la teoria \HOL{} dei|(} -C' un'estesa collezione di teorie che costituisce lo -sviluppo dei numeri reali e dell'analisi in HOL, dovuta a John Harrison -\cite{jrh:thesis}. Daremo solo una panoramica approssimativa dello -sviluppo; il lettore interessato dovrebbe consultare \REFERENCE\ e +C' un'estesa collezione di teorie che costituisce lo +sviluppo dei numeri reali e dell'analisi in HOL, dovuta a John Harrison +\cite{jrh:thesis}. Daremo solo una panoramica approssimativa dello +sviluppo; il lettore interessato dovrebbe consultare \REFERENCE\ e la tesi di Harrison. -Gli assiomi per i numeri reali sono derivati dai `mezzi reali' che -sono costruiti dai `mezzi razionali'. Questa parte dello sviluppo +Gli assiomi per i numeri reali sono derivati dai `mezzi reali' che +sono costruiti dai `mezzi razionali'. Questa parte dello sviluppo registrata in {\small\verb+hratTheory+} e -{\small\verb+hrealTheory+}, ma non usata una volta che i reali sono stati -costruiti. Gli assiomi reali sono derivati nella teoria -{\small\verb+realaxTheory+}. Una collezione standard di operatori sui +{\small\verb+hrealTheory+}, ma non usata una volta che i reali sono stati +costruiti. Gli assiomi reali sono derivati nella teoria +{\small\verb+realaxTheory+}. Una collezione standard di operatori sui reali, e di teoremi che li riguardano, si trova in {\small\verb+realaxTheory+} -and {\small\verb+realTheory+}. Gli operatori e il loro status di parsing sono +and {\small\verb+realTheory+}. Gli operatori e il loro status di parsing sono elencati nella seguente tabella. \begin{center} @@ -2074,20 +2074,20 @@ \subsection{Numeri reali}\label{reals} \end{tabular}} \end{center} -Sulla base di {\small\verb+realTheory+}, costruita la seguente sequenza di +Sulla base di {\small\verb+realTheory+}, costruita la seguente sequenza di teorie: \begin{description} -\item [topology] Topologie e spazi metrici, inclusa la metrica sulla +\item [topology] Topologie e spazi metrici, inclusa la metrica sulla linea reale. -\item [nets] Reti di convergenza Moore-Smith, e casi speciali come +\item [nets] Reti di convergenza Moore-Smith, e casi speciali come le sequenze. \item [seq] Sequenze e serie di numeri reali. \item [lim] Limiti, continuit e differenziazione. \item [powser] Serie potenza. \item [transc] Funzioni trascendenti, \emph{ad esempio}, exp, sin, -cos, ln, root, sqrt, pi, tan, asn, acs, atn. Inoltre la misura integrale -Kurzweil-Henstock il teorema fondamentale del calcolo, e il teorema di +cos, ln, root, sqrt, pi, tan, asn, acs, atn. Inoltre la misura integrale +Kurzweil-Henstock il teorema fondamentale del calcolo, e il teorema di McLaurin \end{description} @@ -2095,7 +2095,7 @@ \subsection{Numeri reali}\label{reals} \index{numeri complessi, la teoria HOL dei@numeri complessi, la teoria \HOL{} dei} \noindent -\HOL{} include anche una teoria di base dei numeri complessi (\ml{complexTheory}), dove il tipo \holtxt{complex} un'abbreviazione di tipo per una coppia di numeri reali. +\HOL{} include anche una teoria di base dei numeri complessi (\ml{complexTheory}), dove il tipo \holtxt{complex} un'abbreviazione di tipo per una coppia di numeri reali. Il valore $\sqrt{-1}$ la costante \HOL{} \holtxt{i}. I numerali sono supportati (con il suffisso \holtxt{c} disponibile per forzare il parsing dei numerali come numeri complessi). Sono definite le operazioni aritmetiche standard, con dimostrati gli appropriati teoremi che le riguardano. @@ -2103,21 +2103,21 @@ \subsection{Numeri reali}\label{reals} \subsection{Teoria della probabilit}\label{prob} \index{probabilit, la teoria HOL della@probabilit, la teoria \HOL{} della} -Una costruzione fondazionale della teoria della probabilit sviluppata da Joe -Hurd~\cite{hurd-thesis}. Per prima cosa definito un tipo di sequenze booleane -per modellare una sequenza infinita di lanci di monete. Poi formalizzata -una funzione di probabilit che prende come input un insieme di sequenze -booleane, e restituisce un numero reale tra 0 e 1. Sfortunatamente -non a tutti gli insiemi pu essere assegnata una probabilit (il paradosso di -Banach-Tarski), piuttosto gli insiemi a cui pu essere assegnata una probabilit sono -chiamati \emph{insiemi misurabili}, e anche questi sono formalizzati nella +Una costruzione fondazionale della teoria della probabilit sviluppata da Joe +Hurd~\cite{hurd-thesis}. Per prima cosa definito un tipo di sequenze booleane +per modellare una sequenza infinita di lanci di monete. Poi formalizzata +una funzione di probabilit che prende come input un insieme di sequenze +booleane, e restituisce un numero reale tra 0 e 1. Sfortunatamente +non a tutti gli insiemi pu essere assegnata una probabilit (il paradosso di +Banach-Tarski), piuttosto gli insiemi a cui pu essere assegnata una probabilit sono +chiamati \emph{insiemi misurabili}, e anche questi sono formalizzati nella teoria HOL. -Su questa base, la teoria della probabilit usata per definire -una funzione di esempio che prende una sequenza infinita di lanci di monete e +Su questa base, la teoria della probabilit usata per definire +una funzione di esempio che prende una sequenza infinita di lanci di monete e un intero positivo $N$, e restituisce un intero $n$ nel range $0\le -n < N$, selezionato uniformemente a caso tra le scelte possibili. Questa -funzione di esempio per la distribuzione uniforme usata pi avanti per verificare +n < N$, selezionato uniformemente a caso tra le scelte possibili. Questa +funzione di esempio per la distribuzione uniforme usata pi avanti per verificare il test di primalit di Miller-Rabin. \subsection{Vettori di bit} @@ -2133,38 +2133,38 @@ \subsection{Vettori di bit} \newcommand{\hash}{\,\holtxt{\#}\,} \newcommand{\oo}[2]{\mbox{\holtxt{#1\,'\,#2}}} -\HOL{} fornisce una teoria di vettori du bit, o parole di $n$-bit. Per esempio, nelle architetture +\HOL{} fornisce una teoria di vettori du bit, o parole di $n$-bit. Per esempio, nelle architetture informatiche si trovano: byte/octet ($n = 8$), mezze-parole ($n = 16$), parole ($n = 32$) e parole-lunghe -($n = 64$). Nella teoria \theoryimp{words}, i vettori di bit sono rappresentati come -\emph{prodotti cartesiani finiti}: a una parola di $n$-bit dato il tipo $\worda$ -dove la \emph{dimensione} del tipo $\alpha$ determina la lunghezza $n$ della parola. Questo -approccio viene da un'idea di John Harrison, che fu presentata al TPHOLs del +($n = 64$). Nella teoria \theoryimp{words}, i vettori di bit sono rappresentati come +\emph{prodotti cartesiani finiti}: a una parola di $n$-bit dato il tipo $\worda$ +dove la \emph{dimensione} del tipo $\alpha$ determina la lunghezza $n$ della parola. Questo +approccio viene da un'idea di John Harrison, che fu presentata al TPHOLs del 2005\footnote{La teoria attuale sussume teorie di parola precedenti -- si evoluta da uno sviluppo basato su una costruzione di classi di equivalenza. La teoria di parola di Wai Wong, che era basata sulla teoria \ml{rich\_list} di Paul Curzon, non pi distribuita con HOL. I principali vantaggi della teoria attuale sono che c' un'unica teoria per tutte le dimensioni di parole e che non sono richiesti effetti secondari della lunghezza delle parole.} \subsubsection{Prodotti cartesiani finiti} -La teoria \HOL{} \theoryimp{fcp} introduce un operatore di tipo infisso -\holtxt{**}, che usato per rappresentare prodotti cartesiani finiti\footnote{La teoria dei +La teoria \HOL{} \theoryimp{fcp} introduce un operatore di tipo infisso +\holtxt{**}, che usato per rappresentare prodotti cartesiani finiti\footnote{La teoria dei prodotti cartesiani finiti stata portata da HOL Light.}. Il tipo \holtxt{'a ** 'b}, o equivalentemente \fcp{'a}{'b}, concettualmente equivalente a: \begin{hol} $\underbrace{\ty{'a}\;\hash\;\ty{'a}\;\hash\;\cdots\;\hash\;\ty{'a}}_{\holtxt{dimindex('b)}}$ \end{hol} dove \holtxt{dimindex('b)} la cardinalit di \holtxt{univ(:'b)} quando \ty{'b} finito e uno quando infinito. Cos, \fcp{'a}{\num} analogo a \ty{'a}, e \fcp{'a}{\bool} analogo a \ty{'a}\hash\ty{'a}. Sono supportati nomi di tipo numerici, cos si pu lavorare liberamente con insiemi indicizzati di qualsiasi dimensione, ad esempio il tipo \ty{32} ha trentadue elementi e \fcp{\bool}{32} rappresenta parole di 32-bit. -Si accede alle \emph{componenti} di un prodotto cartesiano finito con una -funzione di indicizzazione +Si accede alle \emph{componenti} di un prodotto cartesiano finito con una +funzione di indicizzazione \begin{hol} \begin{alltt} fcp_index : \fcp{'a}{'b}\rarr\num\rarr\ty{'a} \end{alltt} \end{hol} -che tipicamente scritta con un apostrofo infisso: -\oo{x}{i} denota il valore del vettore \holtxt{x} alla posizione \holtxt{i}. +che tipicamente scritta con un apostrofo infisso: +\oo{x}{i} denota il valore del vettore \holtxt{x} alla posizione \holtxt{i}. Tipicamente, gli indici sono vincolati ad essere minori della dimensione di \ty{'b}. -Il seguente teorema mostra che due prodotti cartesiani \holtxt{x} e -\holtxt{y} sono uguali se, e solo se, tutte le loro componenti \oo{x}{i} e +Il seguente teorema mostra che due prodotti cartesiani \holtxt{x} e +\holtxt{y} sono uguali se, e solo se, tutte le loro componenti \oo{x}{i} e \oo{y}{i} sono uguali: \begin{hol} \begin{verbatim} @@ -2172,7 +2172,7 @@ \subsubsection{Prodotti cartesiani finiti} \end{verbatim} \end{hol} -Al fine di costruire prodotti cartesiani, la teoria \theoryimp{fcp} introduce un +Al fine di costruire prodotti cartesiani, la teoria \theoryimp{fcp} introduce un binder \holtxt{FCP}, che caratterizzato dai seguenti teoremi: \begin{hol} \begin{verbatim} @@ -2181,24 +2181,24 @@ \subsubsection{Prodotti cartesiani finiti} $ \end{verbatim} \end{hol} -Il teorema \ml{FCP\_BETA} mostra che i componenti di \holtxt{\$FCP g} sono -determinati dalla funzione \holtxt{g:\num\rarr\ty{'a}}. Il teorema -\ml{FCP\_ETA} mostra che si pu eliminare un binding quando tutte le componenti +Il teorema \ml{FCP\_BETA} mostra che i componenti di \holtxt{\$FCP g} sono +determinati dalla funzione \holtxt{g:\num\rarr\ty{'a}}. Il teorema +\ml{FCP\_ETA} mostra che si pu eliminare un binding quando tutte le componenti sono identiche a quelle di \holtxt{x}. -Questi due teoremi, insieme con \ml{CART\_EQ}, si possono trovare nel +Questi due teoremi, insieme con \ml{CART\_EQ}, si possono trovare nel frammento \ml{fcpLib.FCP\_ss} di \emph{simpset}. -I prodotti cartesiani finiti forniscono un buon mezzo per modellare parole di $n$-bit. Vale a -dire, il tipo \fcp{bool}{'a} pu rappresentare una parola binaria la cui lunghezza $n$ -corrisponde alla dimensione del tipo \ty{'a}. Il binder \holtxt{FCP} -fornisce un mezzo flessibile per definire parole -- si pu fornire una funzione +I prodotti cartesiani finiti forniscono un buon mezzo per modellare parole di $n$-bit. Vale a +dire, il tipo \fcp{bool}{'a} pu rappresentare una parola binaria la cui lunghezza $n$ +corrisponde alla dimensione del tipo \ty{'a}. Il binder \holtxt{FCP} +fornisce un mezzo flessibile per definire parole -- si pu fornire una funzione \holtxt{f:\num\rarr\bool} che da i valori bit della parola, a ciascuno dei quali si pu accedere usando la mappa d'indicizzazione \holtxt{fcp\_index}. \subsubsection{Teoria bit} -La teoria \theoryimp{bit} definisce alcune operazioni bit sui numeri naturali, +La teoria \theoryimp{bit} definisce alcune operazioni bit sui numeri naturali, ad esempio \holtxt{BITS}, \holtxt{SLICE}, \holtxt{BIT}, \holtxt{BITWISE} e -\holtxt{BIT\_MODIFY}. In questo contesto, i numeri naturali sono trattati come parole binarie di +\holtxt{BIT\_MODIFY}. In questo contesto, i numeri naturali sono trattati come parole binarie di lunghezza slegata. Le operazioni in \theoryimp{bit} principalmente sono definite usando \holtxt{DIV}, \holtxt{MOD} e \holtxt{EXP}. Pe esempio, dalla definizione di \holtxt{BIT}, vale il seguente teorema: \begin{hol} \begin{verbatim} @@ -2206,40 +2206,40 @@ \subsubsection{Teoria bit} \end{verbatim} \end{hol} -Questa teoria usata nello sviluppo della teoria word e fornisce anche -un meccanismo per la valutazione efficiente di alcune operazioni su parole attraverso la teoria +Questa teoria usata nello sviluppo della teoria word e fornisce anche +un meccanismo per la valutazione efficiente di alcune operazioni su parole attraverso la teoria \theoryimp{numeral\_bit}. \subsubsection{La teoria words} -La teoria \theoryimp{words} introduce una selezione di costanti ed operazioni polimorfiche, i cui tipi possono essere istanziati a parole di qualsiasi dimensione. Per esempio, l'addizione word +La teoria \theoryimp{words} introduce una selezione di costanti ed operazioni polimorfiche, i cui tipi possono essere istanziati a parole di qualsiasi dimensione. Per esempio, l'addizione word ha il tipo: \begin{hol} +:\worda\rarr\worda\rarr\worda \end{hol} -Se \ty{'a} istanziato a \ty{32} allora questa operazione corrisponde all'addizione 32-bit. -Tutti i teoremi circa operazioni word si applicano a word di qualsiasi lunghezza\footnote{Si noti -che impossibile introdurre word di lunghezza zero perch tutti i tipi -devono essere abitati, e di conseguenza la loro dimensione sar sempre maggiore o uguale a +Se \ty{'a} istanziato a \ty{32} allora questa operazione corrisponde all'addizione 32-bit. +Tutti i teoremi circa operazioni word si applicano a word di qualsiasi lunghezza\footnote{Si noti +che impossibile introdurre word di lunghezza zero perch tutti i tipi +devono essere abitati, e di conseguenza la loro dimensione sar sempre maggiore o uguale a uno.} \paragraph{Alcune operazioni di base} -La funzione \holtxt{w2n:\worda\rarr\num} da il valore del numero naturale di una -parola. Se $x\in\bools^{\{0, 1, \ldots, n - 1\}}$ un prodotto cartesiano finito +La funzione \holtxt{w2n:\worda\rarr\num} da il valore del numero naturale di una +parola. Se $x\in\bools^{\{0, 1, \ldots, n - 1\}}$ un prodotto cartesiano finito che rappresenta una parola di $n$-bit allora il valore del suo numero naturale : \[ \mathrm{w2n}(x) = \sum_{i = 0}^{n - 1} \textbf{if } x_i \textbf{ then } 2^i \textbf{ else } 0\ .\] -La lunghezza di una parola (il numero $n$) dato dalla funzione +La lunghezza di una parola (il numero $n$) dato dalla funzione \holtxt{word\_len:\worda\rarr\num}. -La funzione \holtxt{n2w:\num\rarr\worda} mappa un numero a una parola ed +La funzione \holtxt{n2w:\num\rarr\worda} mappa un numero a una parola ed definita in \HOL{} da: \begin{hol} \begin{verbatim} |- !n. n2w n = FCP i. BIT i n \end{verbatim} \end{hol} -Il suffisso \holtxt{w} usato per denotare parole letterali, ad esempio +Il suffisso \holtxt{w} usato per denotare parole letterali, ad esempio \holtxt{255w} lo stesso di \holtxt{n2w 255}. La funzione \holtxt{w2w:\worda\rarr\wordb} fornisce conversioni da-parola-a-parola (casting): @@ -2248,9 +2248,9 @@ \subsubsection{La teoria words} |- !w. w2w w = n2w (w2n w) \end{verbatim} \end{hol} -Se $\beta$ pi piccolo di $\alpha$ allora i bit pi alti di \holtxt{w} saranno -persi (esegue un'estrazione di bit), altrimenti la parola pi lunga avr lo stesso valore dell'originale (fornendo in effetti zero padding). -Tuttavia, se si stesse trattando \holtxt{w} come un numero complemento di due allora la +Se $\beta$ pi piccolo di $\alpha$ allora i bit pi alti di \holtxt{w} saranno +persi (esegue un'estrazione di bit), altrimenti la parola pi lunga avr lo stesso valore dell'originale (fornendo in effetti zero padding). +Tuttavia, se si stesse trattando \holtxt{w} come un numero complemento di due allora la parola dovrebbe essere sign extended, cio \begin{eqnarray*} \mbox{\small ($-$ve)}\quad 1b_{n-2} \cdots b_0\ \mapsto \ 1 \cdots 1 1 b_{n-2} @@ -2258,10 +2258,10 @@ \subsubsection{La teoria words} \mbox{\small ($+$ve)}\quad 0b_{n-2} \cdots b_0\ \mapsto \ 0 \cdots 0 0 b_{n-2} \cdots b_0 \end{eqnarray*} -La funzione \holtxt{sw2sw:\worda\rarr\wordb} fornisce questa versione sign extending di +La funzione \holtxt{sw2sw:\worda\rarr\wordb} fornisce questa versione sign extending di \holtxt{w2w}. -E' fornita una collezione di operazioni per mappare da stringhe a liste di numeri (cifre) e vice versa, ad esempio +E' fornita una collezione di operazioni per mappare da stringhe a liste di numeri (cifre) e vice versa, ad esempio \begin{hol} \begin{verbatim} |- word_to_dec_string 876w = "876" @@ -2281,42 +2281,42 @@ \subsubsection{La teoria words} \paragraph{Parole con e senza segno} -Le parole possono essere \emph{viste} sia come aventi segno (usando la rappresentazione -in complemento a due) o come non aventi segno. Tuttavia, questo non -reso esplicito all'interno della teoria\footnote{Le parole non sono etichettate come +Le parole possono essere \emph{viste} sia come aventi segno (usando la rappresentazione +in complemento a due) o come non aventi segno. Tuttavia, questo non +reso esplicito all'interno della teoria\footnote{Le parole non sono etichettate come aventi/non aventi segno. Sono forniti mapping a/da interi (\holtxt{w2i} e \holtxt{i2w}) nella teoria \theoryimp{integer\_word}.} -e tutte le operazioni aritmetiche sono definite usando i numeri -naturali, cio attraverso \holtxt{w2n} e \holtxt{n2w}. In particolare, -l'addizione e la moltiplicazione funzionano in modo naturale (hanno la stessa definizione) -sotto la rappresentazione in complemento a due. Questo tuttavia non avviene -nella conversione da-parola-a-parola, negli ordinamenti, nella divisione e nello shifting -a destra, dove sono necessarie le varianti con segno e senza segno. Quando -si opera su numeri naturali, alcune delle versioni complemento -a due hanno delle presentazioni leggermente innaturali da vedere. Per esempio, -con la versione (complemento a due) con segno di ``minore di'' abbiamo -\holtxt{255w < (0w:word8)} perch la parola \holtxt{255w} di fatto -considerata rappresentare l'intero $-1$, mentre la versione +e tutte le operazioni aritmetiche sono definite usando i numeri +naturali, cio attraverso \holtxt{w2n} e \holtxt{n2w}. In particolare, +l'addizione e la moltiplicazione funzionano in modo naturale (hanno la stessa definizione) +sotto la rappresentazione in complemento a due. Questo tuttavia non avviene +nella conversione da-parola-a-parola, negli ordinamenti, nella divisione e nello shifting +a destra, dove sono necessarie le varianti con segno e senza segno. Quando +si opera su numeri naturali, alcune delle versioni complemento +a due hanno delle presentazioni leggermente innaturali da vedere. Per esempio, +con la versione (complemento a due) con segno di ``minore di'' abbiamo +\holtxt{255w < (0w:word8)} perch la parola \holtxt{255w} di fatto +considerata rappresentare l'intero $-1$, mentre la versione senza segno pi naturale: \holtxt{0w <+ (255w:word8)}. \paragraph{Operazioni bit field} -Sono fornite le operazioni booleane bit field standard, cio la negazione bitwise -(complemento a uno), la congiunzione bitwise, la disgiunzione bitwise e l'or-esclusivo bitwise. Queste funzioni -sono definite in modo piuttosto naturale usando il binder prodotto cartesiano; per esempio, +Sono fornite le operazioni booleane bit field standard, cio la negazione bitwise +(complemento a uno), la congiunzione bitwise, la disgiunzione bitwise e l'or-esclusivo bitwise. Queste funzioni +sono definite in modo piuttosto naturale usando il binder prodotto cartesiano; per esempio, la congiunzione bitwise definita da: \begin{hol} \begin{verbatim} |- !v w. v && w = FCP i. v ' i /\ w ' i . \end{verbatim} \end{hol} -C' anche una collezione di operazioni di \emph{riduzione} parola, che riducono vettori di bit a parole di 1 bit, ad esempio +C' anche una collezione di operazioni di \emph{riduzione} parola, che riducono vettori di bit a parole di 1 bit, ad esempio \[ \mathrm{reduce\_and}(x)\;'\; 0= \bigwedge_{i = 0}^{n - 1} x_i\ .\] -Le funzioni \holtxt{word\_lsb}, \holtxt{word\_msb} e \holtxt{word\_bit(i)} -danno il valore bit di una parola alle posizioni $0$, $n - 1$ e $i$ -rispettivamente. Sono fornite quattro operazioni per selezionare bit -field, o sotto-parole: \holtxt{word\_bits} (\holtxt{--}), \holtxt{word\_signed\_bits} (\holtxt{---}), \holtxt{word\_slice} (\holtxt{''}) e +Le funzioni \holtxt{word\_lsb}, \holtxt{word\_msb} e \holtxt{word\_bit(i)} +danno il valore bit di una parola alle posizioni $0$, $n - 1$ e $i$ +rispettivamente. Sono fornite quattro operazioni per selezionare bit +field, o sotto-parole: \holtxt{word\_bits} (\holtxt{--}), \holtxt{word\_signed\_bits} (\holtxt{---}), \holtxt{word\_slice} (\holtxt{''}) e \holtxt{word\_extract} (\holtxt{><}). Per esempio, \holtxt{word\_bits 4 1} selezioner quattro bit iniziando dalla posizione bit 1. La funzione slice una variante in-place 8azzeira i bit fuori dal bit range) e la funzione extract combina \holtxt{word\_bits} con un cast di parola (\holtxt{w2w}). L'operazione \holtxt{word\_signed\_bits} analoga a \holtxt{word\_bits}, eccetto che segna-estende il bit field. @@ -2330,25 +2330,25 @@ \subsubsection{La teoria words} L'ordinamento di un bit di parola pu essere capovolto con \holtxt{word\_reverse}, cio il bit zero scambiato con il bit $n - 1$ e cos via. -La funzione -\holtxt{word\_modify:(\num\,\rarr\,\bool\,\rarr\,\bool)\,\rarr\,\worda\,\rarr\,\worda} cambia +La funzione +\holtxt{word\_modify:(\num\,\rarr\,\bool\,\rarr\,\bool)\,\rarr\,\worda\,\rarr\,\worda} cambia una parola applicando una mappa ad ogni posizione bit. -Questa operazione fornisce un meccanismo molto flessibile e conveniente per +Questa operazione fornisce un meccanismo molto flessibile e conveniente per manipolare parole, as esempio \begin{hol} \holtxt{word\_modify ($\lambda$i b.\,if EVEN i then $\sim$b else b) w} \end{hol} -nega i bit di \holtxt{w} che sono nelle posizioni pari. Naturalmente, il -binder \holtxt{FCP} fornisce anche un mezzo molto generale per rappresentare parole usando -un predicato ad esempio \holtxt{\$FCP ODD} rappresenta una parola dove tutti i bit dispari +nega i bit di \holtxt{w} che sono nelle posizioni pari. Naturalmente, il +binder \holtxt{FCP} fornisce anche un mezzo molto generale per rappresentare parole usando +un predicato ad esempio \holtxt{\$FCP ODD} rappresenta una parola dove tutti i bit dispari sono insiemi. \paragraph{Shift} Sono fornite sei tipi di shift: shift logico sinistra/destra (\holtxt{<<} e -\holtxt{>>>}), shift aritmetico destro (\holtxt{>>}), ruotare a sinistra/destra -(\holtxt{\#<<} e \holtxt{\#>>}) e ruotare a destra propagato di 1 posto -(\holtxt{word\_rrx}). Questi shisft sono illustrati nella Figura~\ref{fig:shifts} e sono definiti in un maniera analoga alle operazioni bit field. Per +\holtxt{>>>}), shift aritmetico destro (\holtxt{>>}), ruotare a sinistra/destra +(\holtxt{\#<<} e \holtxt{\#>>}) e ruotare a destra propagato di 1 posto +(\holtxt{word\_rrx}). Questi shisft sono illustrati nella Figura~\ref{fig:shifts} e sono definiti in un maniera analoga alle operazioni bit field. Per esempio, la rotazione a destra definita da: \begin{hol} @@ -2356,7 +2356,7 @@ \subsubsection{La teoria words} |- !w n. w #>> x = FCP i. w ' (i + x) MOD dimindex (:'a) . \end{verbatim} \end{hol} -La rotazione a sinistra di $x$ posti definita come rotazione a destra di $n - x \bmod n$ +La rotazione a sinistra di $x$ posti definita come rotazione a destra di $n - x \bmod n$ posti. \begin{figure} @@ -2382,21 +2382,21 @@ \subsubsection{La teoria words} \paragraph{Aritmetica e ordinamenti} -Le operazioni aritmetiche sono: addizione, sottrazione, meno unario (coplemento a -due), logaritmo (base-2), moltiplicazione, modulo e divisione (con e senza +Le operazioni aritmetiche sono: addizione, sottrazione, meno unario (coplemento a +due), logaritmo (base-2), moltiplicazione, modulo e divisione (con e senza segno). -Queste operazioni sono definite rispetto ai numeri naturali. Per esempio, +Queste operazioni sono definite rispetto ai numeri naturali. Per esempio, l'addizione parola definita da: \begin{hol} \begin{verbatim} |- !v w. v + w = n2w (w2n v + w2n w) \end{verbatim} \end{hol} -Il \holtxt{+} sul lato sinistro un'addizione parola e quello sul lato destro +Il \holtxt{+} sul lato sinistro un'addizione parola e quello sul lato destro l'addizione sui numeri naturali. -Sono forniti tutti gli ordinamenti parola standard, con le versioni con e senza -segno di $<$, $\leq$, $>$ e $\geq$. Le versioni senza segno hanno un suffisso +Sono forniti tutti gli ordinamenti parola standard, con le versioni con e senza +segno di $<$, $\leq$, $>$ e $\geq$. Le versioni senza segno hanno un suffisso con un pi; per esempio, \holtxt{<+} il ``minore di'' senza segno. \paragraph{Costanti} @@ -2512,7 +2512,7 @@ \subsubsection{La teoria words} \section{Sequenze} -\HOL{} fornisce teorie per vari generi di sequenze: liste finite, liste lazy, +\HOL{} fornisce teorie per vari generi di sequenze: liste finite, liste lazy, percorsi, e stringhe finite. \subsection{Liste}\label{avra_list} @@ -2521,10 +2521,10 @@ \subsection{Liste}\label{avra_list} \index{liste, la teoria HOL dei@liste, la teoria \HOL{} dei|(} \index{ liste, la teoria HOL dei@\ml{[} $\cdots$ \ml{;} $\cdots$ \ml{]} (liste, la teoria \HOL{} dei)|(} -Le liste \HOL{} sono sequenze finite definite induttivamente dove ogni -elemento in una lista ha lo stesso tipo. La teoria \ml{list} introduce -l'operatore di tipo unario $\alpha \; \konst{list}$ per mezzo di una definizione di tipo -ed definita una collezione standard di funzioni di elaborazioni di +Le liste \HOL{} sono sequenze finite definite induttivamente dove ogni +elemento in una lista ha lo stesso tipo. La teoria \ml{list} introduce +l'operatore di tipo unario $\alpha \; \konst{list}$ per mezzo di una definizione di tipo +ed definita una collezione standard di funzioni di elaborazioni di liste. I costruttori primitivi {\small\verb+NIL+} e {\small\verb+CONS+} % \begin{hol} @@ -2536,12 +2536,12 @@ \subsection{Liste}\label{avra_list} \end{verbatim} \end{hol} % -sono usati per costruire liste e sono state definite dal tipo rappresentante per +sono usati per costruire liste e sono state definite dal tipo rappresentante per le liste. Il parser \HOL{} % \index{parsing, della logica HOL@parsing, della logica \HOL{}!delle espressioni lista} % - stato modificato in modo speciale per eseguire il parsing dell'espressione \holtxt{[]} in + stato modificato in modo speciale per eseguire il parsing dell'espressione \holtxt{[]} in \holtxt{NIL}, per eseguire il parsing dell'espressione \holtxt{h::t} in \holtxt{CONS h t}, e il parsing dell'espressione \holtxt{[$t_1$;$t_2$;\dots;$t_n$]} in \holtxt{CONS $t_1$ (CONS $t_2$ $\cdots$ (CONS $t_n$ NIL) @@ -2552,8 +2552,8 @@ \subsection{Liste}\label{avra_list} inverte queste trasformazioni. \index{teoremi sulle liste, nella logica HOL@teoremi sulle liste, nella logica \HOL{}} -Sulla base della caratterizzazione induttiva del tipo, i seguenti -teoremi fondamentali sulle liste sono dimostrati e archiviati nella teoria +Sulla base della caratterizzazione induttiva del tipo, i seguenti +teoremi fondamentali sulle liste sono dimostrati e archiviati nella teoria \ml{list}. \begin{hol} @@ -2577,34 +2577,34 @@ \subsection{Liste}\label{avra_list} \end{verbatim} \end{hol} -Il teorema \ml{list\_Axiom} mostrato di sopra analogo al teorema di -ricorsione primitiva +Il teorema \ml{list\_Axiom} mostrato di sopra analogo al teorema di +ricorsione primitiva % \index{teorema di ricorsione primitiva!per le liste} % -sui numeri naturali discusso di sopra nella Sezione~\ref{num-prim-rec}. -Esso afferma la validit delle definizioni ricorsive primitive sulle liste, -e pu essere usato per giustificare qualsiasi di tali definizioni. La funzione \ML{} -\ml{new\_recursive\_definition} usa questo teorema per fare +sui numeri naturali discusso di sopra nella Sezione~\ref{num-prim-rec}. +Esso afferma la validit delle definizioni ricorsive primitive sulle liste, +e pu essere usato per giustificare qualsiasi di tali definizioni. La funzione \ML{} +\ml{new\_recursive\_definition} usa questo teorema per fare % \index{teorema di ricorsione primitiva!uso automatizzato del, nel sistema HOL@uso automatizzato del, nel sistema \HOL{}|)} % -dimostrazioni di esistenza delle funzioni ricorsive primitive sulle liste e -quindi fare specifiche di costanti per introdurre costanti che denotano +dimostrazioni di esistenza delle funzioni ricorsive primitive sulle liste e +quindi fare specifiche di costanti per introdurre costanti che denotano tali funzioni. -Il teorema d'induzione per le liste, \ml{list\_INDUCT}, fornisce lo strumento -di dimostrazione principale usato per ragionare su operazioni che manipolano liste. Il -teorema \ml{list\_CASES} usato per eseguire l'analisi dei casi riguardo al fatto che una +Il teorema d'induzione per le liste, \ml{list\_INDUCT}, fornisce lo strumento +di dimostrazione principale usato per ragionare su operazioni che manipolano liste. Il +teorema \ml{list\_CASES} usato per eseguire l'analisi dei casi riguardo al fatto che una lista sia vuota o meno. -Il teorema {\small\verb+CONS_11+} mostra che {\small\verb+CONS+} iniettiva; -i teoremi {\small\verb+NOT_NIL_CONS+} e {\small\verb+NOT_CONS_NIL+} mostrano che -{\small\verb+NIL+} e {\small\verb+CONS+} sono distinte, cio, -non possono dare origine alla stessa struttura. Insieme, questi tre teoremi +Il teorema {\small\verb+CONS_11+} mostra che {\small\verb+CONS+} iniettiva; +i teoremi {\small\verb+NOT_NIL_CONS+} e {\small\verb+NOT_CONS_NIL+} mostrano che +{\small\verb+NIL+} e {\small\verb+CONS+} sono distinte, cio, +non possono dare origine alla stessa struttura. Insieme, questi tre teoremi sono usati per il ragionamento equazionale circa le liste. -Il predicato \ml{NULL} e i selettori +Il predicato \ml{NULL} e i selettori % \index{selettori, nella logica HOL@selettori, nella logica \HOL{}!per le liste} % @@ -2627,8 +2627,8 @@ \subsection{Liste}\label{avra_list} \paragraph{Espressioni case} \index{espressioni case!sulle liste} -Le espressioni composte \HOL{} che ramificano sulla base del fatto che un termine sia -un lista vuota o non vuota hanno la sintassi di superficie (grossomodo presa in prestito +Le espressioni composte \HOL{} che ramificano sulla base del fatto che un termine sia +un lista vuota o non vuota hanno la sintassi di superficie (grossomodo presa in prestito dall'ML) \begin{hol} \begin{verbatim} @@ -2639,7 +2639,7 @@ \subsection{Liste}\label{avra_list} \end{hol} % Una tale espressione tradotta in -$\holtxt{list\_CASE}\ e_1\ e_2\ (\lambda h\; t.\ e_3)$ dove la costante +$\holtxt{list\_CASE}\ e_1\ e_2\ (\lambda h\; t.\ e_3)$ dove la costante \holtxt{list\_CASE} definita come segue: \begin{hol} \begin{verbatim} @@ -2666,10 +2666,10 @@ \subsection{Liste}\label{avra_list} \index{concatenazione di liste!nella logica HOL@nella logica \HOL{}} \index{FLAT, la costante HOL@\ml{FLAT}, la costante \HOL{}} -La concatenazione binaria di liste ({\small\verb+APPEND+}) pu anche essere denotata -dall'operatore infisso {\small\verb|++|}; cos l'espressione -{\small\verb|L1 ++ L2|} tradotta in {\small\verb+APPEND L1 L2+}. -La concatenazione di una lista di liste in una lista ottenuta da +La concatenazione binaria di liste ({\small\verb+APPEND+}) pu anche essere denotata +dall'operatore infisso {\small\verb|++|}; cos l'espressione +{\small\verb|L1 ++ L2|} tradotta in {\small\verb+APPEND L1 L2+}. +La concatenazione di una lista di liste in una lista ottenuta da {\small\verb+FLAT+}. % \begin{hol} @@ -2687,12 +2687,12 @@ \subsection{Liste}\label{avra_list} \index{EL, la costante HOL@\ml{EL}, la costante \HOL{}} \index{list_size, la costante HOL@\ml{list\_size}, la costante \HOL{}} -La lunghezza (\holtxt{LENGTH}) e la dimensione (\holtxt{list\_size}) di una lista -sono nozioni correlate. La dimensione di una lista tiene conto della dimensione di -ciascun elemento della lista (data dal parametro -$f:\alpha\to\konst{num}$), mentre la lunghezza della lista ignora la -dimensione di ciascun elemento della lista. La definizione alternativa della lunghezza -(\holtxt{LEN}) tail-recursive. Si possono inoltre usare numeri come indici +La lunghezza (\holtxt{LENGTH}) e la dimensione (\holtxt{list\_size}) di una lista +sono nozioni correlate. La dimensione di una lista tiene conto della dimensione di +ciascun elemento della lista (data dal parametro +$f:\alpha\to\konst{num}$), mentre la lunghezza della lista ignora la +dimensione di ciascun elemento della lista. La definizione alternativa della lunghezza +(\holtxt{LEN}) tail-recursive. Si possono inoltre usare numeri come indici nelle liste, estraendo l'elemento alla posizione specificata. % \begin{hol} @@ -2710,9 +2710,9 @@ \subsection{Liste}\label{avra_list} \end{hol} \noindent -Si noti che l'estrazione dell'elemento $n$-esimo (\holtxt{EL}) di una lista -inizia la sua indicizzazione da 0. Se la lunghezza della lista $\ell$ minore -o uguale a $n$, il risultato di \holtxt{EL~$n$~$\ell$~} non +Si noti che l'estrazione dell'elemento $n$-esimo (\holtxt{EL}) di una lista +inizia la sua indicizzazione da 0. Se la lunghezza della lista $\ell$ minore +o uguale a $n$, il risultato di \holtxt{EL~$n$~$\ell$~} non specificato. \paragraph {Funzioni di mapping sulle liste} @@ -2720,7 +2720,7 @@ \subsection{Liste}\label{avra_list} \index{MAP2, la costante HOL@\ml{MAP2}, la costante \HOL{}} \index{funzioni di mapping, nella logica HOL@funzioni di mapping, nella logica \HOL{}!per liste} -Ci sono delle funzioni per mappare una funzione $f : \alpha \to \beta$ su +Ci sono delle funzioni per mappare una funzione $f : \alpha \to \beta$ su una singola lista (\holtxt{MAP}) o una funzione $f : \alpha \to \beta \to \gamma$ sopra due liste (\holtxt{MAP2}). \begin{hol} @@ -2733,7 +2733,7 @@ \subsection{Liste}\label{avra_list} !f h1 t1 h2 t2. MAP2 f (h1::t1) (h2::t2) = f h1 h2::MAP2 f t1 t2 \end{verbatim} \end{hol} -Il comportamento di \holtxt{MAP2} nel caso in cui le siano date liste di +Il comportamento di \holtxt{MAP2} nel caso in cui le siano date liste di lunghezza diversa indeterminato. \paragraph {Predicati su liste} @@ -2743,11 +2743,11 @@ \subsection{Liste}\label{avra_list} \index{EXISTS, la costante HOL (sulle liste)@\ml{EXISTS}, la costante \HOL{} (sulle liste)} -I predicati possono essere applicati a liste in un senso universale (il predicato -deve valere per ogni elemento nella lista) o in un senso esistenziale (il -predicato deve valere per qualche elemento nella lista). Questa funzionalit - supportata da \holtxt{EVERY} e \holtxt{EXISTS}, rispettivamente. L'eliminazione -di tutti gli elementi in una lista che non soddisfano il predicato dato +I predicati possono essere applicati a liste in un senso universale (il predicato +deve valere per ogni elemento nella lista) o in un senso esistenziale (il +predicato deve valere per qualche elemento nella lista). Questa funzionalit + supportata da \holtxt{EVERY} e \holtxt{EXISTS}, rispettivamente. L'eliminazione +di tutti gli elementi in una lista che non soddisfano il predicato dato eseguita da \holtxt{FILTER}. \begin{hol} \begin{verbatim} @@ -2765,17 +2765,17 @@ \subsection{Liste}\label{avra_list} (!h t. ALL_DISTINCT (h::t) = ~MEM h t /\ ALL_DISTINCT t) \end{verbatim} \end{hol} -Il predicato \holtxt{ALL\_DISTINCT} vale su una lista solo nel caso in cui +Il predicato \holtxt{ALL\_DISTINCT} vale su una lista solo nel caso in cui nessun elemento nella lista uguale ad uno qualsiasi degli altri. \paragraph {Folding} \index{FOLDL, la costante HOL@\ml{FOLDL}, la costante \HOL{}} \index{FOLDR, la costante HOL@\ml{FOLDR}, la costante \HOL{}} -L'applicare una funzione binaria $f : \alpha\to\beta\to\beta$ in modo accoppiato -attraverso una lista e accumulando il risultato conosciuto come -\emph{folding}. A volte, necessario eseguire questa operazione -da sinistra a destra (\holtxt{FOLDL}), e altre volte richieste la +L'applicare una funzione binaria $f : \alpha\to\beta\to\beta$ in modo accoppiato +attraverso una lista e accumulando il risultato conosciuto come +\emph{folding}. A volte, necessario eseguire questa operazione +da sinistra a destra (\holtxt{FOLDL}), e altre volte richieste la direzione da destra a sinistra (\holtxt{FOLDR}). \begin{hol} \begin{verbatim} @@ -2790,7 +2790,7 @@ \subsection{Liste}\label{avra_list} \paragraph {Capovolgimento di liste} -Il capovolgimento di una lista (\holtxt{REVERSE}) e la sua controparte +Il capovolgimento di una lista (\holtxt{REVERSE}) e la sua controparte tail recursive \holtxt{REV} sono definite in \theoryimp{list}. \begin{hol} \begin{verbatim} @@ -2805,8 +2805,8 @@ \subsection{Liste}\label{avra_list} \paragraph {Conversione a insiemi} -Le liste possono essere convertite in insiemi (\ml{LIST\_TO\_SET}) attraverso l'applicazione -parziale di of \holtxt{MEM}. La definizione in qualche modo concisa usata per +Le liste possono essere convertite in insiemi (\ml{LIST\_TO\_SET}) attraverso l'applicazione +parziale di of \holtxt{MEM}. La definizione in qualche modo concisa usata per derivare il teorema \ml{IN\_LIST\_TO\_SET}. % \begin{hol} @@ -2819,15 +2819,15 @@ \subsection{Liste}\label{avra_list} \end{verbatim} \end{hol} % -Ulteriore supporto per tradurre tra differenti generi di +Ulteriore supporto per tradurre tra differenti generi di collezioni si pu trovare nella teoria \theoryimp{container}. \paragraph {Coppie e liste} -Due liste di uguale lunghezza possono essere accoppiate componente per componente attraverso -l'operazione {\small\verb+ZIP+}. Il risultato non specificato -quando le liste non sono della stessa lunghezza. L'operazione inversa, -{\small\verb+UNZIP+}, traduce una lista di coppie in una coppia di +Due liste di uguale lunghezza possono essere accoppiate componente per componente attraverso +l'operazione {\small\verb+ZIP+}. Il risultato non specificato +quando le liste non sono della stessa lunghezza. L'operazione inversa, +{\small\verb+UNZIP+}, traduce una lista di coppie in una coppia di liste. \begin{hol} \begin{verbatim} @@ -2844,9 +2844,9 @@ \subsection{Liste}\label{avra_list} \index{LAST, la costante HOL@\ml{LAST}, la costante \HOL{}} \index{FRONT, la costante HOL@\ml{FRONT}, la costante \HOL{}} % -Le liste sono trattate essenzialmente in modo simile a uno stack. Tuttavia, a -volte conveniente accedere all'ultimo elemento -(\holtxt{LAST}) di una lista non vuota in modo diretto. L'ultimo elemento +Le liste sono trattate essenzialmente in modo simile a uno stack. Tuttavia, a +volte conveniente accedere all'ultimo elemento +(\holtxt{LAST}) di una lista non vuota in modo diretto. L'ultimo elemento di una lista non vuota eliminato attraverso \holtxt{FRONT}. \begin{hol} \begin{verbatim} @@ -2859,16 +2859,16 @@ \subsection{Liste}\label{avra_list} \end{verbatim} \end{hol} % -Concatenare la parte frontale e l'ultimo elemento di una lista non vuota porta -alla lista originale. Entrambi \holtxt{LAST} e \holtxt{FRONT} +Concatenare la parte frontale e l'ultimo elemento di una lista non vuota porta +alla lista originale. Entrambi \holtxt{LAST} e \holtxt{FRONT} sono non specificate su liste vuote. \paragraph {Controllo prefisso} \index{isPREFIX, la costante HOL@\ml{isPREFIX}, la costante \HOL{}} -La relazione che cattura se una lista $\ell_1$ un prefisso di $\ell_2$ -({\holtxt{isPREFIX}) pu essere definita per ricorsione. L'infisso +La relazione che cattura se una lista $\ell_1$ un prefisso di $\ell_2$ +({\holtxt{isPREFIX}) pu essere definita per ricorsione. L'infisso \holtxt{<{}<=} pu anche essere usato come una notazione per questo ordine parziale. % use of {} above is just a trick to stop Emacs font-lock colouring % this file disgustingly @@ -2881,15 +2881,15 @@ \subsection{Liste}\label{avra_list} (h1::t1 <<= h2::t2 <=> (h1 = h2) /\ t1 <<= t2) \end{verbatim} \end{hol} -Il teorema di sopra afferma che: la lista vuota un prefisso di ogni altra -lista (clausola 1); che nessuna lista non vuota un prefisso della lista vuota -(clausola 2); e che una lista non vuota un prefisso di un'altra lista -non vuota se i primi elementi delle liste sono gli stessi, e se la coda +Il teorema di sopra afferma che: la lista vuota un prefisso di ogni altra +lista (clausola 1); che nessuna lista non vuota un prefisso della lista vuota +(clausola 2); e che una lista non vuota un prefisso di un'altra lista +non vuota se i primi elementi delle liste sono gli stessi, e se la coda della prima un prefisso della coda della seconda. \vspace{1ex} -\noindent Per una lista completa dei teoremi disponibili in -\theoryimp{list}, si veda \REFERENCE. Un ulteriore sviluppo della teoria +\noindent Per una lista completa dei teoremi disponibili in +\theoryimp{list}, si veda \REFERENCE. Un ulteriore sviluppo della teoria delle liste si pu trovare in \theoryimp{rich\_list}. @@ -2897,15 +2897,15 @@ \subsubsection{Permutazioni e ordinamento di liste} \index{permutazioni (di liste), la teoria HOL delle@permutazioni (di liste), la teoria \HOL{} delle} \index{ordinamento, la teoria HOL del@ordinamento, la teoria \HOL{} del} -La teoria \theoryimp{sorting} definisce la nozione per cui due liste sono -permutazioni l'una dell'altra, poi definisce una nozione generale di ordinamento, +La teoria \theoryimp{sorting} definisce la nozione per cui due liste sono +permutazioni l'una dell'altra, poi definisce una nozione generale di ordinamento, quindi mostra che Quicksort una funzione di ordinamento. \paragraph{Permutazione di liste} -Due liste sono in permutazione se hanno esattamente gli stessi membri, -e ogni membro ha lo stesso numero di occorrenze in entrambe le liste. Una -definizione (\holtxt{PERM}) che cattura questa relazione la +Due liste sono in permutazione se hanno esattamente gli stessi membri, +e ogni membro ha lo stesso numero di occorrenze in entrambe le liste. Una +definizione (\holtxt{PERM}) che cattura questa relazione la seguente: % \begin{hol} @@ -2923,13 +2923,13 @@ \subsubsection{Permutazioni e ordinamento di liste} \end{verbatim} \end{hol} % -Un teorema di induzione derivato (\holtxt{PERM\_IND}) molto +Un teorema di induzione derivato (\holtxt{PERM\_IND}) molto utile nelle dimostrazioni circa le permutazioni. \paragraph{Ordinamento} -Una lista $R$-ordinata se $R$ vale a coppie attraverso la lista. Questa -nozione (\holtxt{SORTED}) catturata da una definizione ricorsiva. Quindi +Una lista $R$-ordinata se $R$ vale a coppie attraverso la lista. Questa +nozione (\holtxt{SORTED}) catturata da una definizione ricorsiva. Quindi una funzione di tipo % \begin{hol} @@ -2938,7 +2938,7 @@ \subsubsection{Permutazioni e ordinamento di liste} \end{verbatim} \end{hol} % - una funzione di ordinamento (\holtxt{SORTS}) rispetto a $R$ se + una funzione di ordinamento (\holtxt{SORTS}) rispetto a $R$ se emette una permutazione del suo input, e il risultato $R$-ordinato. % \begin{hol} @@ -2952,8 +2952,8 @@ \subsubsection{Permutazioni e ordinamento di liste} \end{verbatim} \end{hol} % -Quicksort definito nell'usuale stile di programmazione funzionale, ed - di fatto una funzione di ordinamento, purch $R$ sia una relazione +Quicksort definito nell'usuale stile di programmazione funzionale, ed + di fatto una funzione di ordinamento, purch $R$ sia una relazione transitiva e totale. % \begin{hol} @@ -2978,13 +2978,13 @@ \subsection{Sequenze potenzialmente infinite (\theoryimp{llist})} \index{liste lazy, la teoria HOL delle@liste ``lazy'', la teoria \HOL{} delle|(} -La teoria \theoryimp{llist} contiene la definizione di un tipo di -sequenze potenzialmente infinite. Questo tipo analogo alle ``liste -lazy'' di linguaggi di programmazione come l'Haskell, da qui il nome -della teoria. La teoria \theoryimp{llist} ha un numero di costanti che -sono analoghe alle costanti nella teoria delle liste -finite. Le versioni \theoryimp{llist} di queste costanti hanno gli -stessi nomi, ma con una `L\/' maiuscola anteposta. Cos, alcune delle costanti +La teoria \theoryimp{llist} contiene la definizione di un tipo di +sequenze potenzialmente infinite. Questo tipo analogo alle ``liste +lazy'' di linguaggi di programmazione come l'Haskell, da qui il nome +della teoria. La teoria \theoryimp{llist} ha un numero di costanti che +sono analoghe alle costanti nella teoria delle liste +finite. Le versioni \theoryimp{llist} di queste costanti hanno gli +stessi nomi, ma con una `L\/' maiuscola anteposta. Cos, alcune delle costanti core in questa teoria sono: \begin{hol} \begin{verbatim} @@ -2995,16 +2995,16 @@ \subsection{Sequenze potenzialmente infinite (\theoryimp{llist})} \end{verbatim} \end{hol} -Le costanti \ml{LHD} e \ml{LTL} restituiscono \ml{NONE} quando applicate alla -sequenza vuota, \ml{LNIL}. Questo uso di un tipo opzione un altro -modo di modellare la parzialit essenziale di queste costanti. (Nella -teoria delle liste, le analoghe funzioni \ml{HD} e \ml{TL} hanno +Le costanti \ml{LHD} e \ml{LTL} restituiscono \ml{NONE} quando applicate alla +sequenza vuota, \ml{LNIL}. Questo uso di un tipo opzione un altro +modo di modellare la parzialit essenziale di queste costanti. (Nella +teoria delle liste, le analoghe funzioni \ml{HD} e \ml{TL} hanno semplicemente dei valori non specificati quando applicate alle liste vuote.) -Il tipo \ml{llist} non induttivo, e non c' alcun teorema di -ricorsione primitiva che supporti la definizione di funzioni che hanno -domini di tipo \ml{llist}. Piuttosto, \ml{llist} un tipo coinduttivo, -e ha un assioma che giustifica la definizione di funzioni +Il tipo \ml{llist} non induttivo, e non c' alcun teorema di +ricorsione primitiva che supporti la definizione di funzioni che hanno +domini di tipo \ml{llist}. Piuttosto, \ml{llist} un tipo coinduttivo, +e ha un assioma che giustifica la definizione di funzioni (co-)ricorsive che mappano \emph{al} tipo \ml{llist}: \begin{hol} \begin{verbatim} @@ -3071,9 +3071,9 @@ \subsection{Sequenze potenzialmente infinite (\theoryimp{llist})} \paragraph{Concatenazione} -Due liste lazy possono essere concatenate per mezzo di \ml{LAPPEND}. Se la prima lista -lazy infinita, gli elementi della seconda sono inaccessibili nel -risultato. Una lista lazy di liste lazy pu essere appiattita per mezzo +Due liste lazy possono essere concatenate per mezzo di \ml{LAPPEND}. Se la prima lista +lazy infinita, gli elementi della seconda sono inaccessibili nel +risultato. Una lista lazy di liste lazy pu essere appiattita per mezzo di \ml{LFLATTEN}. \begin{hol}\begin{verbatim} LAPPEND @@ -3088,7 +3088,7 @@ \subsection{Sequenze potenzialmente infinite (\theoryimp{llist})} \paragraph{Liste e liste lazy} -Il mapping da liste a liste lazy e vice versa si ottiene +Il mapping da liste a liste lazy e vice versa si ottiene per mezzo di \ml{fromList} and \ml{toList}: \begin{hol}\begin{verbatim} fromList @@ -3101,16 +3101,16 @@ \subsection{Sequenze potenzialmente infinite (\theoryimp{llist})} \paragraph{Principi di dimostrazione} -In fine, ci sono due principi di dimostrazione molto importanti per dimostrare -che due valori \ml{llist} sono uguali. Il primo afferma che due -sequenze sono uguali se restituiscono gli stessi prefissi di lunghezza $n$ per +In fine, ci sono due principi di dimostrazione molto importanti per dimostrare +che due valori \ml{llist} sono uguali. Il primo afferma che due +sequenze sono uguali se restituiscono gli stessi prefissi di lunghezza $n$ per tutti i valori possibili di $n$: \begin{hol} \begin{verbatim} LTAKE_EQ |- (ll1 = ll2) = (!n. LTAKE n ll1 = LTAKE n ll2) \end{verbatim} \end{hol} -Questo teorema usato successivamente per derivare il principio +Questo teorema usato successivamente per derivare il principio di bi-simulazione: \begin{hol} \begin{verbatim} @@ -3123,20 +3123,20 @@ \subsection{Sequenze potenzialmente infinite (\theoryimp{llist})} R (THE (LTL ll3)) (THE (LTL ll4)) \end{verbatim} \end{hol} -Il principio di bi-simulazione afferma che due valori \ml{llist} $l_1$ -e $l_2$ sono uguali se (e solo se) possibile trovare una +Il principio di bi-simulazione afferma che due valori \ml{llist} $l_1$ +e $l_2$ sono uguali se (e solo se) possibile trovare una relazione $R$ tale che \begin{itemize} \item $R$ collega i due valori, cio, $R\;l_1\;l_2$; and -\item se $R$ vale di due valori qualsiasi $l_3$ e $l_4$, allora o +\item se $R$ vale di due valori qualsiasi $l_3$ e $l_4$, allora o \begin{itemize} \item entrambi $l_3$ e $l_4$ sono vuoti; o - \item gli elementi testa di $l_3$ e $l_4$ sono gli stessi, e le + \item gli elementi testa di $l_3$ e $l_4$ sono gli stessi, e le code di quei due valori sono di nuovo collegati da $R$ \end{itemize} \end{itemize} -Naturalmente, un $R$ possibile l'eguaglianza stessa, ma la forza -di questo teorema che possono essere usate anche altre relazioni +Naturalmente, un $R$ possibile l'eguaglianza stessa, ma la forza +di questo teorema che possono essere usate anche altre relazioni pi convenienti. \index{liste lazy, la teoria HOL delle@liste ``lazy'', la teoria \HOL{} delle|)} @@ -3148,7 +3148,7 @@ \subsection{Percorsi etichettati (\theoryimp{path})} \index{sequenze di riduzione, la teoria HOL delle@sequenze di riduzione, la teoria \HOL{} delle|(} \index{percorsi (sequenze di riduzione), la teoria HOL delle@percorsi (sequenze di riduzione), la teoria \HOL{} delle|(} % -definisce un operatore di tipo binario $(\alpha,\beta)\ml{path}$, che +definisce un operatore di tipo binario $(\alpha,\beta)\ml{path}$, che sta per percorsi potenzialmente infiniti della seguente forma \[ \alpha_1 \stackrel{\beta_1}{\longrightarrow} @@ -3157,12 +3157,12 @@ \subsection{Percorsi etichettati (\theoryimp{path})} \alpha_n \stackrel{\beta_n}{\longrightarrow} \alpha_{n+1} \stackrel{\beta_{n+1}}{\longrightarrow} \cdots \] -Il tipo \ml{path} cos un modello appropriato per sequenze -di riduzione, dove il parametro $\alpha$ corrisponde a ``stati'', e +Il tipo \ml{path} cos un modello appropriato per sequenze +di riduzione, dove il parametro $\alpha$ corrisponde a ``stati'', e il parametro $\beta$ corrisponde alle etichette sulle frecce. Il modello di $(\alpha,\beta)\ml{path}$ $\alpha \times -((\alpha\times\beta)\ml{llist})$. Il tipo dei percorsi ha due +((\alpha\times\beta)\ml{llist})$. Il tipo dei percorsi ha due costruttori: \begin{hol} \begin{verbatim} @@ -3170,11 +3170,11 @@ \subsection{Percorsi etichettati (\theoryimp{path})} pcons : 'a -> 'b -> ('a,'b) path -> ('a,'b) path \end{verbatim} \end{hol} -Il costruttore \holtxt{stopped\_at} restituisce un percorso che contiene solo uno -stato, e nessuna transizione. (Cos, la sequenza di riduzione ha -questo stato ``fermato'' [``stopped at'' ndt].) Il costruttore \ml{pcons} prende uno stato, -un'etichetta, e un percorso, e restituisce un percorso che ora intestato -dall'argomento stato, e che si sposta da quello stato attraverso l'argomento etichetta +Il costruttore \holtxt{stopped\_at} restituisce un percorso che contiene solo uno +stato, e nessuna transizione. (Cos, la sequenza di riduzione ha +questo stato ``fermato'' [``stopped at'' ndt].) Il costruttore \ml{pcons} prende uno stato, +un'etichetta, e un percorso, e restituisce un percorso che ora intestato +dall'argomento stato, e che si sposta da quello stato attraverso l'argomento etichetta al percorso. Graficamente, $\ml{pcons}\;x\;l\;p$ uguale a \[ x \stackrel{l}{\longrightarrow} @@ -3207,8 +3207,8 @@ \subsection{Percorsi etichettati (\theoryimp{path})} \end{verbatim} \end{hol} -Dall'altro lato, la funzione \ml{last} non ha sempre un -valore ben-specificato, bench abbia ancora delle eleganti equazioni +Dall'altro lato, la funzione \ml{last} non ha sempre un +valore ben-specificato, bench abbia ancora delle eleganti equazioni di caratterizzazione. \begin{hol} \begin{verbatim} @@ -3217,8 +3217,8 @@ \subsection{Percorsi etichettati (\theoryimp{path})} \end{verbatim} \end{hol} -Il teorema per \ml{finite} ha un aspetto simile, ma ha un valore -definito (\ml{F}, o \emph{false}) su percorsi infiniti, mentre il +Il teorema per \ml{finite} ha un aspetto simile, ma ha un valore +definito (\ml{F}, o \emph{false}) su percorsi infiniti, mentre il valore di \ml{last} su tali percorsi non specificato: \begin{hol} \begin{verbatim} @@ -3227,9 +3227,9 @@ \subsection{Percorsi etichettati (\theoryimp{path})} \end{verbatim} \end{hol} -La funzione \ml{pconcat} concatena due percorsi, collegandoli -con un'etichetta fornita. Se il primo percorso infinito, allora il risultato - uguale a quello del primo percorso. Le equazioni di definizioni +La funzione \ml{pconcat} concatena due percorsi, collegandoli +con un'etichetta fornita. Se il primo percorso infinito, allora il risultato + uguale a quello del primo percorso. Le equazioni di definizioni \begin{hol} \begin{verbatim} pconcat_thm |- (pconcat (stopped_at x) lab p2 = pcons x lab p2) /\ @@ -3238,11 +3238,11 @@ \subsection{Percorsi etichettati (\theoryimp{path})} \end{verbatim} \end{hol} % -Queste equazioni sono vere persino quando il primo argomento a +Queste equazioni sono vere persino quando il primo argomento a \ml{pconcat} un percorso infinito. -Il predicato \ml{okpath} testa se un percorso o meno una transizione -valida data una relazione di transizione ternaria. Il suo teorema +Il predicato \ml{okpath} testa se un percorso o meno una transizione +valida data una relazione di transizione ternaria. Il suo teorema di caratterizzazione \begin{hol} \begin{verbatim} @@ -3252,7 +3252,7 @@ \subsection{Percorsi etichettati (\theoryimp{path})} \end{verbatim} \end{hol} % -C' anche un principio d'induzione che semplifica il ragionamento circa +C' anche un principio d'induzione che semplifica il ragionamento circa $R$-percorsi finiti: % \begin{hol} @@ -3265,7 +3265,7 @@ \subsection{Percorsi etichettati (\theoryimp{path})} \end{verbatim} \end{hol} -Si pu mostrare che un insieme \holtxt{P} di percorsi sono tutti $R$-percorsi con il +Si pu mostrare che un insieme \holtxt{P} di percorsi sono tutti $R$-percorsi con il principio di co-induzione: \begin{hol} \begin{verbatim} @@ -3283,16 +3283,16 @@ \subsection{Percorsi etichettati (\theoryimp{path})} \subsection{Le stringhe di caratteri (\theoryimp{string})} \index{stringhe, la teoria HOL delle@stringhe, la teoria \HOL{} delle|(} -La teoria \theoryimp{string} definisce un tipo di caratteri e un tipo -di stringhe finite costruite da quei caratteri, insieme con un'utile suite di +La teoria \theoryimp{string} definisce un tipo di caratteri e un tipo +di stringhe finite costruite da quei caratteri, insieme con un'utile suite di definizioni per operare su stringhe. \paragraph {Caratteri} \index{caratteri, la teoria HOL dei@caratteri, la teoria \HOL{} dei} -Il tipo \holtxt{char} rappresentato dai numeri minori di 256. Sono +Il tipo \holtxt{char} rappresentato dai numeri minori di 256. Sono definite due costanti: {\small\verb+CHR +}$: \konst{num}\to\konst{char}$ e -{\small\verb+ORD +}$: \konst{char}\to\konst{num}$. Valgono i seguenti +{\small\verb+ORD +}$: \konst{char}\to\konst{num}$. Valgono i seguenti teoremi: \begin{hol} \begin{verbatim} @@ -3302,7 +3302,7 @@ \subsection{Le stringhe di caratteri (\theoryimp{string})} \end{hol} \index{letterali carattere} -I letterali carattere possono essere inseriti usando la sintassi \ML{}, con un carattere +I letterali carattere possono essere inseriti usando la sintassi \ML{}, con un carattere hash immediatamente seguito da un letterale stringa di lunghezza uno. Cos: \setcounter{sessioncount}{0} @@ -3321,14 +3321,14 @@ \subsection{Le stringhe di caratteri (\theoryimp{string})} \paragraph {Stringhe} -Il tipo \holtxt{string} un alias per il tipo \holtxt{char list}. -Tutte le funzioni e i predicati sulle liste sono cos disponibili per l'uso -sulle stringhe. Alcune di queste costanti sono sottoposte a overload cos che sono -stampate (e possono essere elaborate dal parsing) con nomi che sono pi appropriate per +Il tipo \holtxt{string} un alias per il tipo \holtxt{char list}. +Tutte le funzioni e i predicati sulle liste sono cos disponibili per l'uso +sulle stringhe. Alcune di queste costanti sono sottoposte a overload cos che sono +stampate (e possono essere elaborate dal parsing) con nomi che sono pi appropriate per il particolare caso delle liste di caratteri. -Per esempio, \holtxt{NIL} e \holtxt{CONS} su liste hanno -i nomi alternativi \holtxt{EMPTYSTRING} e \holtxt{STRING} +Per esempio, \holtxt{NIL} e \holtxt{CONS} su liste hanno +i nomi alternativi \holtxt{EMPTYSTRING} e \holtxt{STRING} rispettivamente: % \begin{hol} @@ -3340,9 +3340,9 @@ \subsection{Le stringhe di caratteri (\theoryimp{string})} \end{verbatim} \end{hol} \index{letterali stringa} -Il parser \HOL{} mappa la sintassi \holtxt{""} a \holtxt{EMPTYSTRING}, -e il printer \HOL{} inverte questo. Il parser espande i letterali -stringa della forma \holtxt{"$c_1 c_2 \ldots c_n$"} al termine +Il parser \HOL{} mappa la sintassi \holtxt{""} a \holtxt{EMPTYSTRING}, +e il printer \HOL{} inverte questo. Il parser espande i letterali +stringa della forma \holtxt{"$c_1 c_2 \ldots c_n$"} al termine composto \[ \holtxt{STRING} \;c_1\; (\holtxt{STRING}\;c_2\,\ldots\, @@ -3357,9 +3357,9 @@ \subsection{Le stringhe di caratteri (\theoryimp{string})} \end{verbatim} \end{session} -I letterali stringa possono essere costruiti usando le varie speciali sequenze -di escape che sono usate in \ML{}. Per esempio, \ml{\bs{}n} per il -carattere di nuova linea, e un backslash seguite da tre cifre decimali +I letterali stringa possono essere costruiti usando le varie speciali sequenze +di escape che sono usate in \ML{}. Per esempio, \ml{\bs{}n} per il +carattere di nuova linea, e un backslash seguite da tre cifre decimali per caratteri del numero dato. \begin{session} \begin{verbatim} @@ -3367,12 +3367,12 @@ \subsection{Le stringhe di caratteri (\theoryimp{string})} > val t = ``"foo bar\n\^A"`` : term \end{verbatim} \end{session} -Si noti che se si vuole usare la sintassi di controllo caratteri con il -caret che il pretty-printer ha scelto di usare per stampare la stringa -data, e questo accade all'interno di una quotation, allora il caret dovr +Si noti che se si vuole usare la sintassi di controllo caratteri con il +caret che il pretty-printer ha scelto di usare per stampare la stringa +data, e questo accade all'interno di una quotation, allora il caret dovr essere duplicato. (Si veda la Sezione~\ref{sec:quotation-antiquotation}.) -C' anche una funzione de-costruttore {\small\verb+DEST_STRING+} per +C' anche una funzione de-costruttore {\small\verb+DEST_STRING+} per le stringhe che restituisce un tipo opzione. \begin{hol} \begin{verbatim} @@ -3386,8 +3386,8 @@ \subsection{Le stringhe di caratteri (\theoryimp{string})} \paragraph{Espressioni case} \index{espressioni case!su stringhe} -Le espressioni \HOL{} composte che ramificano sulla base del fatto che -un termine sia una stringa vuota o non vuota possono essere scritte con la +Le espressioni \HOL{} composte che ramificano sulla base del fatto che +un termine sia una stringa vuota o non vuota possono essere scritte con la sintassi di superficie \begin{hol} \begin{verbatim} @@ -3401,10 +3401,10 @@ \subsection{Le stringhe di caratteri (\theoryimp{string})} \paragraph {Lunghezza e concatenazione} -Una funzione standard \holtxt{LENGTH} pu essere scritta \holtxt{STRLEN} -quando applicata a una stringa, e \holtxt{APPEND} pu essere scritta come -\holtxt{STRCAT}. Ci sono anche teoremi che caratterizzano queste -costanti in \ml{stringTheory}, bench esse siano semplicemente istanziazioni +Una funzione standard \holtxt{LENGTH} pu essere scritta \holtxt{STRLEN} +quando applicata a una stringa, e \holtxt{APPEND} pu essere scritta come +\holtxt{STRCAT}. Ci sono anche teoremi che caratterizzano queste +costanti in \ml{stringTheory}, bench esse siano semplicemente istanziazioni dei risultati da \ml{listTheory}: \begin{hol} \begin{verbatim} @@ -3424,35 +3424,35 @@ \subsection{Le stringhe di caratteri (\theoryimp{string})} \section{Collezioni} -In \HOL{} sono disponibili alcune nozioni differenti di collezione di elementi: +In \HOL{} sono disponibili alcune nozioni differenti di collezione di elementi: insiemi, multi-insiemi, relazioni, e mappe finite. \subsection{Insiemi (\theoryimp{pred\_set})} \label{sec:theory-of-sets} \index{insiemi, la teoria HOL dei@insiemi, la teoria \HOL{} dei} -Un esteso sviluppo della teoria degli insiemi disponibile nella teoria -\theoryimp{pred\_set}. Gli insiemi sono rappresentati da funzione del tipo -$\alpha \to \konst{bool}$, cio, essi sono le cosiddette funzioni +Un esteso sviluppo della teoria degli insiemi disponibile nella teoria +\theoryimp{pred\_set}. Gli insiemi sono rappresentati da funzione del tipo +$\alpha \to \konst{bool}$, cio, essi sono le cosiddette funzioni caratteristiche. % \index{funzioni caratteristiche!come base della teoria \HOL{} degli insiemi} % -Si pu usare l'abbreviazione di tipo $\alpha\; \konst{set}$ -al posto di $\alpha \to \konst{bool}$. Gli insiemi possono essere finiti o +Si pu usare l'abbreviazione di tipo $\alpha\; \konst{set}$ +al posto di $\alpha \to \konst{bool}$. Gli insiemi possono essere finiti o infiniti. Tutti gli elementi in un insieme devono avere lo stesso tipo. -L'\emph{appartenenza a un insieme} la nozione base sui cui basata la teoria degli insiemi -formalizzata. In \HOL, l'appartenenza rappresentata da una costante -infissa \holtxt{IN}, definita per convenienza nella teoria +L'\emph{appartenenza a un insieme} la nozione base sui cui basata la teoria degli insiemi +formalizzata. In \HOL, l'appartenenza rappresentata da una costante +infissa \holtxt{IN}, definita per convenienza nella teoria \theoryimp{bool}. \begin{hol} \begin{verbatim} IN_DEF |- IN = \x f. f x \end{verbatim} \end{hol} -L'operatore \holtxt{IN} semplicemente un modo di applicare la -funzione caratteristica a un elemento, come mostra la seguente conseguenza +L'operatore \holtxt{IN} semplicemente un modo di applicare la +funzione caratteristica a un elemento, come mostra la seguente conseguenza banale della definizione: \begin{hol} \begin{verbatim} @@ -3477,11 +3477,11 @@ \subsection{Insiemi (\theoryimp{pred\_set})} \end{verbatim} \end{hol} In aggiunta a \holtxt{UNIV} (magari con un'annotazione di tipo \holtxt{:'a~set}), si pu anche scrivere \holtxt{univ(:'a)} per rappresentare l'insieme universale sul tipo \holtxt{:'a}. -La sintassi Unicode \holtxt{$\mathbb{U}$(:'a)} significa la stessa cosa. +La sintassi Unicode \holtxt{$\mathbb{U}$(:'a)} significa la stessa cosa. Il simbolo Unicode per $\mathbb{U}$ U+1D54C, e potrebbe non esistere in molti set di font. -Una di queste forme sar usata per stampare \holtxt{UNIV} di default. -La traccia utente (si veda la Sezione~\ref{sec:traces}) \ml{"Univ~pretty-printing"} pu essere impostata a zero per cancellare questo comportamento. +Una di queste forme sar usata per stampare \holtxt{UNIV} di default. +La traccia utente (si veda la Sezione~\ref{sec:traces}) \ml{"Univ~pretty-printing"} pu essere impostata a zero per cancellare questo comportamento. Inoltre, la traccia \ml{"Unicode Univ printing"} pu essere usata per smettere di usare la sintassi U+1D54C, persino se attiva la traccia Unicode. I simboli \holtxt{univ} e \holtxt{$\mathbb{U}$} sono prefissi di priorit alta (si veda la Sezione~\ref{sec:parseprint:fixities}), e pattern sottoposti a overload (si veda la Sezione~\ref{sec:parser:syntactic-patterns}) che mappano un valore dello tipo stesso alla costante corrispondente \holtxt{UNIV}. @@ -3495,10 +3495,10 @@ \subsection{Insiemi (\theoryimp{pred\_set})} \paragraph{Inserimento, unione, e intersezione} -L'inserimento ({\small\verb+INSERT+}, scritto infisso) di un elemento -in un insieme definito con una comprensione d'insieme. La comprensione d'insieme +L'inserimento ({\small\verb+INSERT+}, scritto infisso) di un elemento +in un insieme definito con una comprensione d'insieme. La comprensione d'insieme discussa nella sottosezione successiva. Le definizioni usuali per l'unione insiemistica ({\small\verb+UNION+}, -scritto infisso) e l'intersezione ({\small\verb+INTER+}, anch'esso infisso) +scritto infisso) e l'intersezione ({\small\verb+INTER+}, anch'esso infisso) sono date attraverso la comprensione d'insieme. \begin{hol} \begin{verbatim} @@ -3507,9 +3507,9 @@ \subsection{Insiemi (\theoryimp{pred\_set})} INTER_DEF |- !s t. s INTER t = {x | x IN s /\ x IN t} \end{verbatim} \end{hol} -\holtxt{UNION} e \holtxt{INTER} sono operazioni -binarie. Le operazioni di unione e intersezione indicizzata, cio, -$\bigcup_{i \in P}$ e $\bigcap_{i \in P}$ sono fornite dalle +\holtxt{UNION} e \holtxt{INTER} sono operazioni +binarie. Le operazioni di unione e intersezione indicizzata, cio, +$\bigcup_{i \in P}$ e $\bigcap_{i \in P}$ sono fornite dalle definizioni di \holtxt{BIGUNION} e \holtxt{BIGINTER}. \begin{hol} \begin{verbatim} @@ -3517,14 +3517,14 @@ \subsection{Insiemi (\theoryimp{pred\_set})} BIGINTER |- !P. BIGINTER P = {x | !s. s IN P ==> x IN s} \end{verbatim} \end{hol} -Sia \holtxt{BIGUNION} che \holtxt{BIGINTER} riducono un insieme di insiemi a un -insieme e cos hanno il tipo +Sia \holtxt{BIGUNION} che \holtxt{BIGINTER} riducono un insieme di insiemi a un +insieme e cos hanno il tipo $((\alpha\to\konst{bool})\to\konst{bool})\to (\alpha\to\konst{bool})$. \paragraph{Sottoinsiemi} -L'inclusione di insiemi (\holtxt{SUBSET}, infisso), l'inclusione propria -(\holtxt{PSUBSET}, infisso), e l'insieme potenza (\holtxt{POW}) sono definite come +L'inclusione di insiemi (\holtxt{SUBSET}, infisso), l'inclusione propria +(\holtxt{PSUBSET}, infisso), e l'insieme potenza (\holtxt{POW}) sono definite come segue: % \begin{hol} @@ -3537,10 +3537,10 @@ \subsection{Insiemi (\theoryimp{pred\_set})} \paragraph{Differenza di insiemi e complemento} -La differenza tra due insiemi (\holtxt{DIFF}, infisso) definita da una -comprensione di insieme. Sulla base di quella, la cancellazione di un singolo elemento -(\holtxt{DELETE}, infisso) da un insieme diretta. Dal momento che -l'universo di un tipo sempre disponibile attraverso \holtxt{UNIV}, si pu prendere il +La differenza tra due insiemi (\holtxt{DIFF}, infisso) definita da una +comprensione di insieme. Sulla base di quella, la cancellazione di un singolo elemento +(\holtxt{DELETE}, infisso) da un insieme diretta. Dal momento che +l'universo di un tipo sempre disponibile attraverso \holtxt{UNIV}, si pu prendere il complemento (\holtxt{COMPL}) di un insieme. \begin{hol} \begin{verbatim} @@ -3551,7 +3551,7 @@ \subsection{Insiemi (\theoryimp{pred\_set})} \end{hol} \paragraph{Funzioni su insiemi} -L'immagine di una funzione $f :\alpha \to \beta$ su +L'immagine di una funzione $f :\alpha \to \beta$ su un insieme (\holtxt{IMAGE}) definito con una comprensione d'insieme. \begin{hol} \begin{verbatim} @@ -3559,7 +3559,7 @@ \subsection{Insiemi (\theoryimp{pred\_set})} \end{verbatim} \end{hol} % -Iniezioni, suriezioni, e biezioni tra insiemi sono definite +Iniezioni, suriezioni, e biezioni tra insiemi sono definite come segue: % \begin{hol} @@ -3581,7 +3581,7 @@ \subsection{Insiemi (\theoryimp{pred\_set})} \paragraph{Insiemi finiti} \index{finitezza!di insiemi} -Gli insiemi finiti (\holtxt{FINITE}) sono definiti induttivamente come quelli +Gli insiemi finiti (\holtxt{FINITE}) sono definiti induttivamente come quelli costruiti dall'insieme vuoto per mezzo di un numero finito di inserimenti. % \begin{hol} @@ -3609,9 +3609,9 @@ \subsection{Insiemi (\theoryimp{pred\_set})} \end{verbatim} \end{hol} % -Come menzionato, le operazioni su insiemi si applicano sia a insiemi finiti che -infiniti. Tuttavia, alcune operazioni, come la cardinalit -(\holtxt{CARD}), sono definite soltanto per insiemi finiti. La +Come menzionato, le operazioni su insiemi si applicano sia a insiemi finiti che +infiniti. Tuttavia, alcune operazioni, come la cardinalit +(\holtxt{CARD}), sono definite soltanto per insiemi finiti. La cardinalit di un insieme infinito non specificata. \index{cardinalit d'insiemi (finiti)} % @@ -3624,10 +3624,10 @@ \subsection{Insiemi (\theoryimp{pred\_set})} \end{verbatim} \end{hol} % -Dal momento che gli insiemi finiti e infiniti sono gestiti in modo uniforme in -\theoryimp{pred\_set}, le propriet delle operazioni su insiemi finiti devono -includere esplicitamente dei vincoli circa la finitezza. Per esempio il -seguente teorema che collega la cardinalit e i sottoinsiemi vero solo per +Dal momento che gli insiemi finiti e infiniti sono gestiti in modo uniforme in +\theoryimp{pred\_set}, le propriet delle operazioni su insiemi finiti devono +includere esplicitamente dei vincoli circa la finitezza. Per esempio il +seguente teorema che collega la cardinalit e i sottoinsiemi vero solo per insiemi finiti. % \begin{hol} @@ -3637,11 +3637,11 @@ \subsection{Insiemi (\theoryimp{pred\_set})} \end{verbatim} \end{hol} % -In \theoryimp{pred\_set} disponibile un'estesa suite di teoremi che trattano +In \theoryimp{pred\_set} disponibile un'estesa suite di teoremi che trattano con la finitezza e la cardinalit. \paragraph{Prodotto incrociato} -Il prodotto di due insiemi ({\small\verb+CROSS+}, infisso) definito +Il prodotto di due insiemi ({\small\verb+CROSS+}, infisso) definito con una comprensione d'insieme. % \begin{hol} @@ -3660,13 +3660,13 @@ \subsection{Insiemi (\theoryimp{pred\_set})} \paragraph{Funzioni ricorsive su insiemi} -Le funzioni ricorsive su insiemi possono essere definite dalla ricorsione -benfondata. Di solito, la totalit di una tale funzione stabilita -misurando la cardinalit dell'insieme (finito). Tuttavia, si pu usare +Le funzioni ricorsive su insiemi possono essere definite dalla ricorsione +benfondata. Di solito, la totalit di una tale funzione stabilita +misurando la cardinalit dell'insieme (finito). Tuttavia, si pu usare un altro teorema per giustificare un fold ({\small\verb+ITSET+}) per insiemi finiti. -Purch una funzione $f:\alpha\to\beta\to\beta$ obbedisca a una condizione +Purch una funzione $f:\alpha\to\beta\to\beta$ obbedisca a una condizione conosciuta come \emph{commutativa-a-sinistra}, cio, $f\;x\;(f\;y\;z) = -f\;y\;(f\;x\;z)$, allora $f$ pu essere applicata eseguendo il suo folding sull'insieme +f\;y\;(f\;x\;z)$, allora $f$ pu essere applicata eseguendo il suo folding sull'insieme in un modo tail-ricorsivo. \begin{hol} \begin{verbatim} @@ -3686,10 +3686,10 @@ \subsection{Insiemi (\theoryimp{pred\_set})} (ITSET f (e INSERT s) b = f e (ITSET f (s DELETE e) b)) \end{verbatim} \end{hol} -Per la completa derivazione, si vedano i sorgenti di {\small\verb+pred_set+}. -La definizione di {\small\verb+ITSET+} permette, per esempio, la -definizione della sommatoria dei risultati di una funzione su un insieme finito di -elementi, da cui sono derivati una caratterizzazione ricorsiva e altri utili +Per la completa derivazione, si vedano i sorgenti di {\small\verb+pred_set+}. +La definizione di {\small\verb+ITSET+} permette, per esempio, la +definizione della sommatoria dei risultati di una funzione su un insieme finito di +elementi, da cui sono derivati una caratterizzazione ricorsiva e altri utili teoremi. % \begin{hol} @@ -3705,15 +3705,15 @@ \subsection{Insiemi (\theoryimp{pred\_set})} \paragraph{Altre definizioni e teoremi} -TCi sono molte altre definizioni in \theoryimp{pred\_set}, ma non sono -usate cos pesantemente come quelle presentate qui. Analogamente, la maggior parte dei teoremi -in \theoryimp{pred\_set} collegano varie operazioni comuni sugli insiemi l'una +TCi sono molte altre definizioni in \theoryimp{pred\_set}, ma non sono +usate cos pesantemente come quelle presentate qui. Analogamente, la maggior parte dei teoremi +in \theoryimp{pred\_set} collegano varie operazioni comuni sugli insiemi l'una con le altre, ma non esprimono al cun teorema profondo della teoria degli insiemi. -Comunque, un teorema degno di nota il Lemma di Koenig, che afferma che -ogni albero infinito finitamente ramificato ha un percorso infinito. Ci sono -molti modi di formulare questo teorema, a seconda di come la nozione di -albero formalizzata. In \theoryimp{pred\_set}, la ramificazione finita +Comunque, un teorema degno di nota il Lemma di Koenig, che afferma che +ogni albero infinito finitamente ramificato ha un percorso infinito. Ci sono +molti modi di formulare questo teorema, a seconda di come la nozione di +albero formalizzata. In \theoryimp{pred\_set}, la ramificazione finita definita come un predicato su una relazione. % \begin{hol} @@ -3723,7 +3723,7 @@ \subsection{Insiemi (\theoryimp{pred\_set})} \end{verbatim} \end{hol} % -Da questo, la seguente versione del Lemma di Koenig enunciata e +Da questo, la seguente versione del Lemma di Koenig enunciata e dimostrata: \begin{hol} \begin{verbatim} @@ -3737,16 +3737,16 @@ \subsection{Insiemi (\theoryimp{pred\_set})} \subsubsection{Sintassi per gli insiemi}\index{notazione insiemistica} -Le notazioni insiemistiche special purpose +Le notazioni insiemistiche special purpose {\small\verb%{%}$t_1 ;t_2 ; \ldots ; t_n${\small\verb%}%} e -{\small\verb%{%}$t${\small\verb% | %}$p${\small\verb%}%} sono riconosciute -dal parser e dal printer di \HOL{} quando la teoria \theoryimp{pred\_set} +{\small\verb%{%}$t${\small\verb% | %}$p${\small\verb%}%} sono riconosciute +dal parser e dal printer di \HOL{} quando la teoria \theoryimp{pred\_set} caricata. -L'interpretazione normale di \lb$t_1 ;t_2 ; \ldots ; t_n$\rb{} l'insieme finito +L'interpretazione normale di \lb$t_1 ;t_2 ; \ldots ; t_n$\rb{} l'insieme finito che contiene solo $t_1,t_2,\ldots, -t_n$. Questo pu essere modellato iniziando con l'insieme vuoto e -eseguendo una sequenza di inserimenti. Per esempio, \holtxt{\lb{}1;2;3;4\rb{}} +t_n$. Questo pu essere modellato iniziando con l'insieme vuoto e +eseguendo una sequenza di inserimenti. Per esempio, \holtxt{\lb{}1;2;3;4\rb{}} parsato a \begin{hol} @@ -3763,13 +3763,13 @@ \subsubsection{Sintassi per gli insiemi}\index{notazione insiemistica} % \ml{GSPEC(\bs($x_1$,$\ldots$,$x_n$).($t$,$p$))} % -\noindent dove $x_1, \ldots, x_n$ sono quelle variabili libere che -occorrono sia in $t$ sia in $p$ se entrambi hanno almeno una variabile libera. Se -$t$ o $p$ non hanno variabili libere, allora $x_1, \ldots, x_n$ sono considerate -essere le variabili libere dell'altro termine. Se entrambi hanno variabili -libere, ma non c' sovrapposizione, allora risulta un errore. L'ordine -in cui le variabili sono elencate nella struttura di variabili -dell'astrazione accoppiata una funzione nn specificata della struttura di $t$ +\noindent dove $x_1, \ldots, x_n$ sono quelle variabili libere che +occorrono sia in $t$ sia in $p$ se entrambi hanno almeno una variabile libera. Se +$t$ o $p$ non hanno variabili libere, allora $x_1, \ldots, x_n$ sono considerate +essere le variabili libere dell'altro termine. Se entrambi hanno variabili +libere, ma non c' sovrapposizione, allora risulta un errore. L'ordine +in cui le variabili sono elencate nella struttura di variabili +dell'astrazione accoppiata una funzione nn specificata della struttura di $t$ ( approssimativamente da sinistra a destra). Per esempio, % \begin{hol} @@ -3794,8 +3794,8 @@ \subsubsection{Sintassi per gli insiemi}\index{notazione insiemistica} \end{verbatim} \end{hol} -Questa specifica in qualche modo criptica si pu comprendere attraverso -un esempio. La sintassi +Questa specifica in qualche modo criptica si pu comprendere attraverso +un esempio. La sintassi % \begin{hol} \begin{verbatim} @@ -3817,9 +3817,9 @@ \subsubsection{Sintassi per gli insiemi}\index{notazione insiemistica} \end{verbatim} \end{hol} % -La variabile quantificata esistenzialmente \verb+x+ ha un tipo coppia, -cos che pu essere sostituita da una coppia \verb+(p,q)+ e -si pu eseguire una $\beta$-riduzione-accoppiata, portando a +La variabile quantificata esistenzialmente \verb+x+ ha un tipo coppia, +cos che pu essere sostituita da una coppia \verb+(p,q)+ e +si pu eseguire una $\beta$-riduzione-accoppiata, portando a % \begin{hol} \begin{verbatim} @@ -3827,7 +3827,7 @@ \subsubsection{Sintassi per gli insiemi}\index{notazione insiemistica} \end{verbatim} \end{hol} % -che uguale al significato inteso della sintassi +che uguale al significato inteso della sintassi originale: % \begin{hol} @@ -3836,26 +3836,26 @@ \subsubsection{Sintassi per gli insiemi}\index{notazione insiemistica} \end{verbatim} \end{hol} -\paragraph{Comprensioni d'insieme non ambigue} C' anche una sintassi -della comprensione d'insieme non ambigua, che permetter all'utente di -specificare quali variabili devono essere quantificate nell'astrazione -cio l'argomento di \holtxt{GSPEC}. Termini della forma +\paragraph{Comprensioni d'insieme non ambigue} C' anche una sintassi +della comprensione d'insieme non ambigua, che permetter all'utente di +specificare quali variabili devono essere quantificate nell'astrazione +cio l'argomento di \holtxt{GSPEC}. Termini della forma \begin{hol} \begin{verbatim} { t | vs | P } \end{verbatim} \end{hol} -generano insiemi che contengono valori della forma data da \holtxt{t}, dove -le variabili menzionate in \holtxt{vs} devono soddisfare il vincolo -\holtxt{P}. Per esempio, l'insieme +generano insiemi che contengono valori della forma data da \holtxt{t}, dove +le variabili menzionate in \holtxt{vs} devono soddisfare il vincolo +\holtxt{P}. Per esempio, l'insieme \begin{hol} \begin{verbatim} { x + y | x | x < y } \end{verbatim} \end{hol} - l'insieme dei numeri da \holtxt{y} fino a ma non incluso -\holtxt{2~*~y}. L'insieme pu essere ``letto'' in modo computazionale: escludere tutte -quelle \holtxt{x} che sono minori di \holtxt{y}, e ad ognuna di tali + l'insieme dei numeri da \holtxt{y} fino a ma non incluso +\holtxt{2~*~y}. L'insieme pu essere ``letto'' in modo computazionale: escludere tutte +quelle \holtxt{x} che sono minori di \holtxt{y}, e ad ognuna di tali \holtxt{x} aggiungere \holtxt{y}, generando con ci un insieme di numeri. Nell'esempio di sopra, il termine \holtxt{GSPEC} sottostante sar @@ -3865,37 +3865,37 @@ \subsubsection{Sintassi per gli insiemi}\index{notazione insiemistica} \end{verbatim} \end{hol} -Il componente \holtxt{vs} della notazione non ambigua deve essere una singola -``struttura variabile'' che potrebbe apparire sotto un'astrazione possibilmente +Il componente \holtxt{vs} della notazione non ambigua deve essere una singola +``struttura variabile'' che potrebbe apparire sotto un'astrazione possibilmente accoppiata come nella Sezione~\ref{HOL-varstruct}. In altre parole, questo \begin{hol} \begin{verbatim} { x + y | (x,y) | x < y } \end{verbatim} \end{hol} -va bene, ma questo +va bene, ma questo \begin{hol} \begin{verbatim} { x + y | x y | x < y } \end{verbatim} \end{hol} -sollever un errore. (Inoltre, le parentesi pi esterne intorno +sollever un errore. (Inoltre, le parentesi pi esterne intorno alle coppie nella posizione \holtxt{vs} si possono omettere.) -La notazione non ambigua stampata dal pretty-printere ogni volta che -l'insieme da stampare non pu essere espressa con la notazione di default, o -se la variabile di traccia con nome \ml{pp\_unambiguous\_comprehensions} +La notazione non ambigua stampata dal pretty-printere ogni volta che +l'insieme da stampare non pu essere espressa con la notazione di default, o +se la variabile di traccia con nome \ml{pp\_unambiguous\_comprehensions} impostata a \ml{true}. \subsection{Multi-insiemi (\theoryimp{bag})}\label{multiset} -I multinsiemi, anche conosciuti come \emph{bag}, sono simili agli insiemi, eccetto per il fatto che -essi permettono occorrenze ripetute di un elemento. Mentre gli insiemi sono -rappresentati da funzioni di tipo $\alpha\to\konst{bool}$, che segnalano -la presenza, o l'assenza, di un elemento, i multinsiemi sono rappresentati -da funzioni di tipo $\alpha\to\konst{num}$, che danno la -molteplicit di ciascun elemento nel multinsieme. I multinsiemi possono essere finiti +I multinsiemi, anche conosciuti come \emph{bag}, sono simili agli insiemi, eccetto per il fatto che +essi permettono occorrenze ripetute di un elemento. Mentre gli insiemi sono +rappresentati da funzioni di tipo $\alpha\to\konst{bool}$, che segnalano +la presenza, o l'assenza, di un elemento, i multinsiemi sono rappresentati +da funzioni di tipo $\alpha\to\konst{num}$, che danno la +molteplicit di ciascun elemento nel multinsieme. I multinsiemi possono essere finiti o infiniti. Le abbreviazioni di tipo $\alpha\;\konst{multiset}$ e @@ -3903,7 +3903,7 @@ \subsection{Multi-insiemi (\theoryimp{bag})}\label{multiset} \paragraph {Multinsieme vuoto} -Il multinsieme vuoto non ha elementi. Cos, la funzione che lo implementa +Il multinsieme vuoto non ha elementi. Cos, la funzione che lo implementa restituisce $0$ per ogni input. % \begin{hol} @@ -3912,7 +3912,7 @@ \subsection{Multi-insiemi (\theoryimp{bag})}\label{multiset} \end{verbatim} \end{hol} -\noindent La sintassi speciale {\verb+{||}+} pu essere usata per rappresentare il multinsieme +\noindent La sintassi speciale {\verb+{||}+} pu essere usata per rappresentare il multinsieme vuoto. \paragraph {Appartenenza} @@ -3922,8 +3922,8 @@ \subsection{Multi-insiemi (\theoryimp{bag})}\label{multiset} in a bag ({\small\verb+BAG_INN+}); and does an element occur in a bag at all ({\small\verb+BAG_IN+}). -La maggior parte della teoria si pu basare sulla nozione di appartenenza a un -multinsieme. Ci sono due nozioni: un elemento occorre al meno $n$ volte +La maggior parte della teoria si pu basare sulla nozione di appartenenza a un +multinsieme. Ci sono due nozioni: un elemento occorre al meno $n$ volte in una bag % \begin{hol} @@ -3945,8 +3945,8 @@ \subsection{Multi-insiemi (\theoryimp{bag})}\label{multiset} \paragraph{Sotto-multinsieme} Una relazione sotto-bag (\holtxt{SUB\_BAG}) vale tra $b_1$ e -$b_2$ a condizione che ogni elemento in $b_1$ occorra almeno le stesse volte in -$b_2$. La nozione di una sotto-bag propria (\holtxt{PSUB\_BAG}) facilmente +$b_2$ a condizione che ogni elemento in $b_1$ occorra almeno le stesse volte in +$b_2$. La nozione di una sotto-bag propria (\holtxt{PSUB\_BAG}) facilmente definita. % \begin{hol} @@ -3960,7 +3960,7 @@ \subsection{Multi-insiemi (\theoryimp{bag})}\label{multiset} \paragraph{Inserimento} -L'inserimento di un elemento in una bag (\holtxt{BAG\_INSERT}) aggiorna il +L'inserimento di un elemento in una bag (\holtxt{BAG\_INSERT}) aggiorna il conteggio di quell'elemento e lascia gli altri inalterati. % \begin{hol} @@ -3970,10 +3970,10 @@ \subsection{Multi-insiemi (\theoryimp{bag})}\label{multiset} \end{verbatim} \end{hol} -Multinsiemi esplicitamente-dati sono supportati dalla sintassi -{\small\verb%{|%}$t_1 ;t_2 ; \ldots ; t_n${\small\verb%|}%}, dove -ci possono essere, naturalmente, ripetizioni. Questo modellando iniziando con il multinsieme -vuoto ed eseguendo una sequenza di inserimenti. Per esempio, +Multinsiemi esplicitamente-dati sono supportati dalla sintassi +{\small\verb%{|%}$t_1 ;t_2 ; \ldots ; t_n${\small\verb%|}%}, dove +ci possono essere, naturalmente, ripetizioni. Questo modellando iniziando con il multinsieme +vuoto ed eseguendo una sequenza di inserimenti. Per esempio, \verb+{|1; 2; 3; 2; 1|}+ analizzato dal parser a \begin{hol} @@ -3986,15 +3986,15 @@ \subsection{Multi-insiemi (\theoryimp{bag})}\label{multiset} \paragraph{Unione and differenza} -Le operazioni di unione (\holtxt{BAG\_UNION}) e differenza (\holtxt{BAG\_DIFF}) -su bag si riducono entrambe a un calcolo aritmetico sui loro -elementi. L'eliminazione di un singolo elemento da un bag pu essere espresso come il -prendere la differenza tra il multinsieme con un multinsieme di un singolo elemento; -tuttavia, c' anche una presentazione relazionale -(\holtxt{BAG\_DELETE}) che collega i suoi primi e ultimi argomenti solo -se il primo contiene esattamente una occorrenza in pi dell'argomento -di mezzo rispetto all'ultimo. Questa non la stessa cosa di usare -\holtxt{BAG\_DIFF} per rimuovere una bag di un elemento perch insiste sul fatto che +Le operazioni di unione (\holtxt{BAG\_UNION}) e differenza (\holtxt{BAG\_DIFF}) +su bag si riducono entrambe a un calcolo aritmetico sui loro +elementi. L'eliminazione di un singolo elemento da un bag pu essere espresso come il +prendere la differenza tra il multinsieme con un multinsieme di un singolo elemento; +tuttavia, c' anche una presentazione relazionale +(\holtxt{BAG\_DELETE}) che collega i suoi primi e ultimi argomenti solo +se il primo contiene esattamente una occorrenza in pi dell'argomento +di mezzo rispetto all'ultimo. Questa non la stessa cosa di usare +\holtxt{BAG\_DIFF} per rimuovere una bag di un elemento perch insiste sul fatto che l'elemento che viene rimosso appare effettivamente nella bag pi grande. % \begin{hol} @@ -4010,9 +4010,9 @@ \subsection{Multi-insiemi (\theoryimp{bag})}\label{multiset} \paragraph {Intersezione, merge, e filtro} -L'intersezione di due bag (\holtxt{BAG\_INTER}) prende il minimo -puntuale. L'operazione duale, il merging (\holtxt{BAG\_MERGE}), prende il -massimo puntuale. Una bag pu essere `filtrata' da un insieme per restituire la bag +L'intersezione di due bag (\holtxt{BAG\_INTER}) prende il minimo +puntuale. L'operazione duale, il merging (\holtxt{BAG\_MERGE}), prende il +massimo puntuale. Una bag pu essere `filtrata' da un insieme per restituire la bag dove tutti gli elementi che non sono nell'insieme sono stati rimossi. % \begin{hol} @@ -4028,7 +4028,7 @@ \subsection{Multi-insiemi (\theoryimp{bag})}\label{multiset} \paragraph {Insiemi e Multinsiemi} -Lo spostamento tra bag e insiemi si ottiene con le seguenti due +Lo spostamento tra bag e insiemi si ottiene con le seguenti due definizioni % \begin{hol} @@ -4042,16 +4042,16 @@ \subsection{Multi-insiemi (\theoryimp{bag})}\label{multiset} \paragraph {Immagine} -Prendere l'immagina di una funzione su un multinsieme per ottenere un nuovo multinsieme -sembrerebbe essere semplicemente una questione di applicare la funzione a ciascun elemento -del multinsieme. Tuttavia, c' un problema se $f$ non iniettiva -e il multinsieme infinito. Per esempio, si prenda il multinsieme -che consiste di tutti i numeri naturali e si applichi $\lambda x.\; 1$ a -ciascun elemento. Il multinsieme risultante conterrebbe un numero infinito di -$1$. Per evitare questo sono richiesti alcuni vincoli: per esempio, -stipulare che la funzione sia solo finitamente non-iniettiva, o che -il multinsieme di input sia finito. Tali condizioni sarebbero onerose alla prova -dei fatti; il compromesso mappare la molteplicit degli elementi +Prendere l'immagina di una funzione su un multinsieme per ottenere un nuovo multinsieme +sembrerebbe essere semplicemente una questione di applicare la funzione a ciascun elemento +del multinsieme. Tuttavia, c' un problema se $f$ non iniettiva +e il multinsieme infinito. Per esempio, si prenda il multinsieme +che consiste di tutti i numeri naturali e si applichi $\lambda x.\; 1$ a +ciascun elemento. Il multinsieme risultante conterrebbe un numero infinito di +$1$. Per evitare questo sono richiesti alcuni vincoli: per esempio, +stipulare che la funzione sia solo finitamente non-iniettiva, o che +il multinsieme di input sia finito. Tali condizioni sarebbero onerose alla prova +dei fatti; il compromesso mappare la molteplicit degli elementi problematici a $0$. % \begin{hol} @@ -4067,7 +4067,7 @@ \subsection{Multi-insiemi (\theoryimp{bag})}\label{multiset} \paragraph {Multinsiemi finiti} \index{finitezza!dei multinsiemi} -I multinsiemi finiti (\holtxt{FINITE\_BAG}) sono definiti in modo induttivo come +I multinsiemi finiti (\holtxt{FINITE\_BAG}) sono definiti in modo induttivo come quelli costruiti dalla bag vuota attraverso un numero finito di inserimenti. % \begin{hol} @@ -4079,7 +4079,7 @@ \subsection{Multi-insiemi (\theoryimp{bag})}\label{multiset} \end{verbatim} \end{hol} % -I multinsiemi finiti hanno un teorema d'induzione, e anche un teorema +I multinsiemi finiti hanno un teorema d'induzione, e anche un teorema d'induzione completa. % \index{teoremi d'induzione, nella logica HOL@teoremi d'induzione, nella logica \HOL{}!per bag finite} @@ -4098,7 +4098,7 @@ \subsection{Multi-insiemi (\theoryimp{bag})}\label{multiset} \end{verbatim} \end{hol} % -La cardinalit (\holtxt{BAG\_CARD}) di un multinsieme conta il +La cardinalit (\holtxt{BAG\_CARD}) di un multinsieme conta il numero totale di occorrenze. Essa specificata solo per multinsiemi finiti. % \begin{hol} @@ -4112,13 +4112,13 @@ \subsection{Multi-insiemi (\theoryimp{bag})}\label{multiset} \paragraph{Funzioni ricorsive su multinsiemi} -Le funzioni ricorsive su multinsiemi possono essere definite per ricorsione -benfondata. Di solito, la totalit di una tale funzione stabilita -misurando la cardinalit del multinsieme (finito). Tuttavia, fornito -un fold (\holtxt{ITBAG}) per insiemi [multinsiemi? ndt] finiti. A condizione che una funzione -$f:\alpha\to\beta\to\beta$ obbedisca a una condizione conosciuta come +Le funzioni ricorsive su multinsiemi possono essere definite per ricorsione +benfondata. Di solito, la totalit di una tale funzione stabilita +misurando la cardinalit del multinsieme (finito). Tuttavia, fornito +un fold (\holtxt{ITBAG}) per insiemi [multinsiemi? ndt] finiti. A condizione che una funzione +$f:\alpha\to\beta\to\beta$ obbedisca a una condizione conosciuta come \emph{commutativit-a-sinistra}, cio, $f\;x\;(f\;y\;z) = -f\;y\;(f\;x\;z)$, allora $f$ pu essere applicata eseguendone il folding sul +f\;y\;(f\;x\;z)$, allora $f$ pu essere applicata eseguendone il folding sul multinsieme in una maniera tail-ricorsiva. % \begin{hol} @@ -4142,13 +4142,13 @@ \subsection{Multi-insiemi (\theoryimp{bag})}\label{multiset} \subsection{Relazioni (\theoryimp{relation})}\label{relation} -Le relazioni matematiche possono essere rappresentate in \HOL{} dal tipo -$\alpha \to\beta\to\konst{bool}$. (Nella maggior parte delle applicazioni, il tipo di una -relazione un'istanza di $\alpha \to\alpha\to\konst{bool}$, ma la -generalit extra non fa male.) La teoria \theoryimp{relation} -fornisce definizioni delle propriet e delle operazioni di base sulle relazioni, -definisce vari generi di ordini e chiusure, definisce la benfondatezza -e dimostra il teorema di ricorsione benfondata, e sviluppa alcuni +Le relazioni matematiche possono essere rappresentate in \HOL{} dal tipo +$\alpha \to\beta\to\konst{bool}$. (Nella maggior parte delle applicazioni, il tipo di una +relazione un'istanza di $\alpha \to\alpha\to\konst{bool}$, ma la +generalit extra non fa male.) La teoria \theoryimp{relation} +fornisce definizioni delle propriet e delle operazioni di base sulle relazioni, +definisce vari generi di ordini e chiusure, definisce la benfondatezza +e dimostra il teorema di ricorsione benfondata, e sviluppa alcuni risultati base usati nella Riscrittura dei Termini. \paragraph {Propriet base} @@ -4178,9 +4178,9 @@ \subsection{Relazioni (\theoryimp{relation})}\label{relation} \paragraph{Operazioni base} -Le seguenti operazioni base sulle relazioni sono definite: la relazione +Le seguenti operazioni base sulle relazioni sono definite: la relazione vuota (\holtxt{EMPTY\_REL}), la composizione di relazione (\holtxt{O}, -infisso), l'inversione (\holtxt{inv}), il dominio (\holtxt{RDOM}), e il rango +infisso), l'inversione (\holtxt{inv}), il dominio (\holtxt{RDOM}), e il rango (\holtxt{RRANGE}). % \begin{hol} @@ -4198,7 +4198,7 @@ \subsection{Relazioni (\theoryimp{relation})}\label{relation} \end{verbatim} \end{hol} -\noindent Le operazioni sugli insiemi riutilizzate per lavorare sulle relazioni includono il sottoinsieme +\noindent Le operazioni sugli insiemi riutilizzate per lavorare sulle relazioni includono il sottoinsieme (\holtxt{RSUBSET}, infisso), l'unione (\holtxt{RUNION}, infisso), l'intersezione (\holtxt{RINTER}, infisso), il complemento (\holtxt{RCOMPL}), e l'universo (\holtxt{RUNIV}). @@ -4220,7 +4220,7 @@ \subsection{Relazioni (\theoryimp{relation})}\label{relation} \paragraph {Ordini} -In \theoryimp{relation} fatta una serie di definizioni che catturano varie +In \theoryimp{relation} fatta una serie di definizioni che catturano varie nozioni. % \begin{hol} @@ -4245,9 +4245,9 @@ \subsection{Relazioni (\theoryimp{relation})}\label{relation} \paragraph {Chiusure} La chiusura transitiva (\holtxt{TC}) di una relazione $R : \alpha -\to\alpha\to\konst{bool}$ definita in modo induttivo, come la pi piccola -relazione che include $R$ ed chiusa sotto la transitivit. Analogamente, la -chiusura riflessiva-transitiva (\holtxt{RTC}) definita essere la pi piccola +\to\alpha\to\konst{bool}$ definita in modo induttivo, come la pi piccola +relazione che include $R$ ed chiusa sotto la transitivit. Analogamente, la +chiusura riflessiva-transitiva (\holtxt{RTC}) definita essere la pi piccola relazione chiusa sotto la transitivit e la riflessivit. % \begin{hol} @@ -4280,19 +4280,19 @@ \subsection{Relazioni (\theoryimp{relation})}\label{relation} \end{verbatim} \end{hol} % -Si noti che {\small\verb+RTC_RULES+}, in linea con la definizione -di {\small\verb+RTC+}, estende un \verb+R+-passo da \verb+x+ a -\verb+y+ con una sequenza di \verb+R+-passi da \verb+y+ a \verb+z+ -per costruire \verb+RTC x z+. Il teorema +Si noti che {\small\verb+RTC_RULES+}, in linea con la definizione +di {\small\verb+RTC+}, estende un \verb+R+-passo da \verb+x+ a +\verb+y+ con una sequenza di \verb+R+-passi da \verb+y+ a \verb+z+ +per costruire \verb+RTC x z+. Il teorema {\small\verb+RTC_RULES_RIGHT1+} prima fa una serie di \verb+R+ -passi e poi un singolo \verb+R+ passo per formare \verb+RTC x z+. Analoghi +passi e poi un singolo \verb+R+ passo per formare \verb+RTC x z+. Analoghi teoremi alternatici sono dimostrati per l'analisi dei casi e l'induzione. -Per esempio, {\small\verb+TC_CASES1+} e {\small\verb+TC_CASES2+} in ci che -segue de-compongono {\small\verb+RTC R x z+} o a +Per esempio, {\small\verb+TC_CASES1+} e {\small\verb+TC_CASES2+} in ci che +segue de-compongono {\small\verb+RTC R x z+} o a {\small\verb+R x y+} seguito da {\small\verb+RTC R y z+} ({\small\verb+TC_CASES1+}) -o a +o a {\small\verb+RTC R x y+} seguito da {\small\verb+R y z+} ({\small\verb+TC_CASES2+}). @@ -4314,7 +4314,7 @@ \subsection{Relazioni (\theoryimp{relation})}\label{relation} \end{hol} Esattamente come i teoremi d'induzione di base per {\small\verb+TC+} e -{\small\verb+RTC+}, ci sono i cosiddetti teoremi d'induzione +{\small\verb+RTC+}, ci sono i cosiddetti teoremi d'induzione \emph{completa}, che hanno ipotesi d'induzione pi forti. % \begin{hol} @@ -4337,14 +4337,14 @@ \subsection{Relazioni (\theoryimp{relation})}\label{relation} (!x y. RTC R x y ==> P x y) \end{verbatim} \end{hol} -Sono anche disponibili varianti di questi teoremi d'induzione che dividono +Sono anche disponibili varianti di questi teoremi d'induzione che dividono la chiusura dalla sinistra o dalla destra, come per i teoremi di analisi dei casi. \medskip -Le chiusure riflessiva~(\holtxt{RC}) e simmetrica~(\holtxt{SC}) sono -facili da definire. La chiusura di equivalenza -({\small\verb+EQC+}) la chiusura simmetrica poi transitiva poi riflessiva +Le chiusure riflessiva~(\holtxt{RC}) e simmetrica~(\holtxt{SC}) sono +facili da definire. La chiusura di equivalenza +({\small\verb+EQC+}) la chiusura simmetrica poi transitiva poi riflessiva di $R$. % \begin{hol} @@ -4357,8 +4357,8 @@ \subsection{Relazioni (\theoryimp{relation})}\label{relation} \paragraph {Relazioni benfondate} -Una relazione $R$ benfondata ({\small\verb+WF+}) se ogni insieme non-vuoto -ha un elemento $R$-minimo. La benfondatezza usata per giustificare il +Una relazione $R$ benfondata ({\small\verb+WF+}) se ogni insieme non-vuoto +ha un elemento $R$-minimo. La benfondatezza usata per giustificare il principio d'induzione benfondata ({\small\verb+WF_INDUCTION_THM+}). % \begin{hol} @@ -4370,8 +4370,8 @@ \subsection{Relazioni (\theoryimp{relation})}\label{relation} \end{verbatim} \end{hol} -La \emph{parte benfondata} ({\small\verb+WFP+}) di una relazione pu essere -definita induttivamente, da essa possono essere derivate le sue regole, il teorema di analisi dei casi e +La \emph{parte benfondata} ({\small\verb+WFP+}) di una relazione pu essere +definita induttivamente, da essa possono essere derivate le sue regole, il teorema di analisi dei casi e i teoremi d'induzione. % \begin{hol} @@ -4391,19 +4391,19 @@ \subsection{Relazioni (\theoryimp{relation})}\label{relation} \end{verbatim} \end{hol} -La benfondatezza pu essere usata anche per giustificare un teorema di ricorsione -generale. Intuitivamente, una collezione di equazioni di ricorsione possono essere -ammesse nella logica \HOL{} senza perdita di coerenza purch -ogni sequenza possibile di chiamate ricorsive sia finita. Le relazioni -benfondate sono usate per catturare questa nozione: se c' una relazione -benfondata $R$ sul dominio della funzione desiderata tale che ogni -sequenza di chiamate ricorsive $R$-decrescente, allora le equazioni -di ricorsione specificano un'unica funzione totale e le equazioni possono essere +La benfondatezza pu essere usata anche per giustificare un teorema di ricorsione +generale. Intuitivamente, una collezione di equazioni di ricorsione possono essere +ammesse nella logica \HOL{} senza perdita di coerenza purch +ogni sequenza possibile di chiamate ricorsive sia finita. Le relazioni +benfondate sono usate per catturare questa nozione: se c' una relazione +benfondata $R$ sul dominio della funzione desiderata tale che ogni +sequenza di chiamate ricorsive $R$-decrescente, allora le equazioni +di ricorsione specificano un'unica funzione totale e le equazioni possono essere ammesse nella logica. -I teoremi di ricorsione {\small\verb+WFREC_COROLLARY+} e -{\small\verb+WF_RECURSION_THM+} usano la nozione di una restrizione -di funzione ({\small\verb+RESTRICT+}) al fine di forzare l'applicazione della funzione +I teoremi di ricorsione {\small\verb+WFREC_COROLLARY+} e +{\small\verb+WF_RECURSION_THM+} usano la nozione di una restrizione +di funzione ({\small\verb+RESTRICT+}) al fine di forzare l'applicazione della funzione ricorsiva ad argomenti $R$-pi-piccoli nelle chiamate ricorsive. % \begin{hol} @@ -4420,9 +4420,9 @@ \subsection{Relazioni (\theoryimp{relation})}\label{relation} \end{hol} \noindent I teoremi {\small\verb+WF_INDUCTION_THM+} e -{\small\verb+WFREC_COROLLARY+} sono usati per automatizzare le definizioni -ricorsive; si veda la Sezione \ref{TFL}. Sono anche definiti alcuni operatori -di base per le relazioni benfondate, insieme con i teoremi che affermano +{\small\verb+WFREC_COROLLARY+} sono usati per automatizzare le definizioni +ricorsive; si veda la Sezione \ref{TFL}. Sono anche definiti alcuni operatori +di base per le relazioni benfondate, insieme con i teoremi che affermano che essi propagano la benfondatezza. \begin{hol} @@ -4438,10 +4438,10 @@ \subsection{Relazioni (\theoryimp{relation})}\label{relation} \paragraph {Riscrittura di termini} -Alcune definizioni di base prese dalla teoria della Riscrittura di Termini -(la propriet diamante (\verb+diamond+), la propriet -Church-Rosser ({\small\verb+CR+} e {\small\verb+WCR+}), e la Normalizzazione -Forte ({\small\verb+SN+})) appaiono +Alcune definizioni di base prese dalla teoria della Riscrittura di Termini +(la propriet diamante (\verb+diamond+), la propriet +Church-Rosser ({\small\verb+CR+} e {\small\verb+WCR+}), e la Normalizzazione +Forte ({\small\verb+SN+})) appaiono in \theoryimp{relation}. % \begin{hol} @@ -4467,21 +4467,21 @@ \subsection{Relazioni (\theoryimp{relation})}\label{relation} \subsection{Mappe finite (\theoryimp{finite\_map})}\label{finite_map} -La teoria \theoryimp{finite\_map} formalizza un tipo -$(\alpha,\beta)\,\holtxt{fmap}$ di funzioni finite. Queste teoricamente -hanno il tipo $\alpha\to\beta$, ma in pi hanno solo un numero finito di -elementi nel loro dominio. Le mappe finite sono utili per formalizzare +La teoria \theoryimp{finite\_map} formalizza un tipo +$(\alpha,\beta)\,\holtxt{fmap}$ di funzioni finite. Queste teoricamente +hanno il tipo $\alpha\to\beta$, ma in pi hanno solo un numero finito di +elementi nel loro dominio. Le mappe finite sono utili per formalizzare le sostituzioni e gli array. Il tipo rappresentate $\alpha\to\beta + -\konst{one}$, dove solo un numero finito degli $\alpha$ mappano a un -$\beta$ e il resto mappano a \verb+one+. la sintassi -$\alpha\,\holtxt{|->}\,\beta$ riconosciuta dal parser come +\konst{one}$, dove solo un numero finito degli $\alpha$ mappano a un +$\beta$ e il resto mappano a \verb+one+. la sintassi +$\alpha\,\holtxt{|->}\,\beta$ riconosciuta dal parser come un'alternativa a $(\alpha,\beta)\,\holtxt{fmap}$. \paragraph {Nozioni base} -La mappa vuota (\holtxt{FEMPTY}), l'aggiornamento di una mappa -(\holtxt{FUPDATE}), l'applicazione di una mappa a un argomento -(\holtxt{FAPPLY}), e il dominio di una mappa (\holtxt{FDOM}) sono le +La mappa vuota (\holtxt{FEMPTY}), l'aggiornamento di una mappa +(\holtxt{FUPDATE}), l'applicazione di una mappa a un argomento +(\holtxt{FAPPLY}), e il dominio di una mappa (\holtxt{FDOM}) sono le nozioni principali nella teoria. \begin{hol} \begin{verbatim} @@ -4492,21 +4492,21 @@ \subsection{Mappe finite (\theoryimp{finite\_map})}\label{finite_map} \end{verbatim} \end{hol} -Il parser e il printer \HOL{} tratteranno la sintassi \holtxt{f\,'\,x} come -l'applicazione della mappa finita \verb+f+ to argument \verb+x+, cio, come -\holtxt{FAPPLY\,f\,x}. La notazione \holtxt{f\,|+\,(x,y)} rappresenta -\holtxt{FUPDATE\,f\,(x,y)}, cio, l'aggiornamento della mappa finita +Il parser e il printer \HOL{} tratteranno la sintassi \holtxt{f\,'\,x} come +l'applicazione della mappa finita \verb+f+ to argument \verb+x+, cio, come +\holtxt{FAPPLY\,f\,x}. La notazione \holtxt{f\,|+\,(x,y)} rappresenta +\holtxt{FUPDATE\,f\,(x,y)}, cio, l'aggiornamento della mappa finita \verb+f+ per mezzo della coppia \verb+(x,y)+. -Le costanti base hanno delle definizioni oscure, dalle quali sono poi derivate -propriet pi utili. {\small\verb+FAPPLY_FUPDATE_THM+} collega -l'aggiornamento di una mappa con l'applicazione di una mappa. {\small\verb+fmap_EXT+} un -risultato di estensionalit: due mappe sono uguali se hanno lo stesso dominio -e si accordano quando applicate ad argomenti in quel dominio. Si possono dimostrare -propriet delle mappe finite per induzione sulla costruzione della mappa -({\small\verb+fmap_INDUCT+}). La cardinalit di una mappa finita -semplicemente la cardinalit del suo dominio ({\small\verb+FCARD_DEF+}); da -questo derivata una caratterizzazione ricorsiva +Le costanti base hanno delle definizioni oscure, dalle quali sono poi derivate +propriet pi utili. {\small\verb+FAPPLY_FUPDATE_THM+} collega +l'aggiornamento di una mappa con l'applicazione di una mappa. {\small\verb+fmap_EXT+} un +risultato di estensionalit: due mappe sono uguali se hanno lo stesso dominio +e si accordano quando applicate ad argomenti in quel dominio. Si possono dimostrare +propriet delle mappe finite per induzione sulla costruzione della mappa +({\small\verb+fmap_INDUCT+}). La cardinalit di una mappa finita +semplicemente la cardinalit del suo dominio ({\small\verb+FCARD_DEF+}); da +questo derivata una caratterizzazione ricorsiva ({\small\verb+FCARD_FUPDATE+}). \begin{hol} \begin{verbatim} @@ -4524,7 +4524,7 @@ \subsection{Mappe finite (\theoryimp{finite\_map})}\label{finite_map} if a IN FDOM fm then FCARD fm else 1 + FCARD fm \end{verbatim} \end{hol} -Aggiornamenti iterati (\holtxt{FUPDATE\_LIST}) a una mappa sono utili. Si pu anche usare +Aggiornamenti iterati (\holtxt{FUPDATE\_LIST}) a una mappa sono utili. Si pu anche usare la notazione infissa \holtxt{|++}. Per esempio, \holtxt{fm\,|++\,[(k1,v1);\,(k2,v2)]} uguale a \holtxt{(fm\,|+\,(k1,v1))\,|+\,(k2,v2)}. \begin{hol} \begin{verbatim} @@ -4539,8 +4539,8 @@ \subsection{Mappe finite (\theoryimp{finite\_map})}\label{finite_map} \paragraph {Dominio e rango} Il dominio di una mappa finita l'insieme di elementi a cui essa si applica; -questo pu essere caratterizzato ricorsivamente -({\small\verb+FDOM_FUPDATE+}). Il rango di una mappa definito nel +questo pu essere caratterizzato ricorsivamente +({\small\verb+FDOM_FUPDATE+}). Il rango di una mappa definito nel modo usuale. \begin{hol} \begin{verbatim} @@ -4551,9 +4551,9 @@ \subsection{Mappe finite (\theoryimp{finite\_map})}\label{finite_map} \end{verbatim} \end{hol} % -Una mappa finita pu avere il suo dominio ({\small\verb+DRESTRICT+}) -o rango ({\small\verb+RRESTRICT+}) ristretti per intersezione con un -insieme. Queste nozioni hanno anche delle versioni ricorsive +Una mappa finita pu avere il suo dominio ({\small\verb+DRESTRICT+}) +o rango ({\small\verb+RRESTRICT+}) ristretti per intersezione con un +insieme. Queste nozioni hanno anche delle versioni ricorsive ({\small\verb+DRESTRICT_FUPDATE+} e {\small\verb+RRESTRICT_FUPDATE+}). % \begin{hol} @@ -4578,10 +4578,10 @@ \subsection{Mappe finite (\theoryimp{finite\_map})}\label{finite_map} else RRESTRICT (DRESTRICT f (COMPL {x})) r) \end{verbatim} \end{hol} -La rimozione di un singolo elemento dal dominio di una mappa -(\holtxt{\bs\bs}, infisso) una semplice applicazione di -(\holtxt{DRESTRICT}), ma sufficientemente utile per essere degno di una sua propria -definizione. Di nuovo, questo concetto ha una presentazione ricorsiva alternativa +La rimozione di un singolo elemento dal dominio di una mappa +(\holtxt{\bs\bs}, infisso) una semplice applicazione di +(\holtxt{DRESTRICT}), ma sufficientemente utile per essere degno di una sua propria +definizione. Di nuovo, questo concetto ha una presentazione ricorsiva alternativa (\holtxt{DOMSUB\_FUPDATE\_THM}). % \begin{hol} @@ -4596,10 +4596,10 @@ \subsection{Mappe finite (\theoryimp{finite\_map})}\label{finite_map} \paragraph {Unione e sotto-mappe} -Diversamente dall'unione d'insiemi, l'unione di due mappe finite -(\holtxt{FUNION\_DEF}) non simmetrica: il dominio della prima mappa -prende la precedenza. La nozione dell'essere una mappa finita una sotto-mappa di un'altra -(\holtxt{SUBMAP}, infisso) un'estensione di come sono formalizzati i +Diversamente dall'unione d'insiemi, l'unione di due mappe finite +(\holtxt{FUNION\_DEF}) non simmetrica: il dominio della prima mappa +prende la precedenza. La nozione dell'essere una mappa finita una sotto-mappa di un'altra +(\holtxt{SUBMAP}, infisso) un'estensione di come sono formalizzati i sottoinsiemi. \begin{hol} \begin{verbatim} @@ -4615,13 +4615,13 @@ \subsection{Mappe finite (\theoryimp{finite\_map})}\label{finite_map} \paragraph {Mappe finite e funzioni} -Per quanto possibile, le mappe finite dovrebbero essere come funzioni ordinarie. -Cos, se \holtxt{f} una mappa finita, allora \holtxt{FAPPLY f} una -funzione ordinaria. Analogamente, c' un'operazione per -\emph{totalizzare} una mappa finita (\holtxt{lookup}) cos che -un'applicazione di essa restituisca una funzione ordinaria, il rango della quale -il tipo option. Una funzione ordinaria pu essere trasformata in una mappa finita -restringendo la funzione a un insieme finito di argomenti +Per quanto possibile, le mappe finite dovrebbero essere come funzioni ordinarie. +Cos, se \holtxt{f} una mappa finita, allora \holtxt{FAPPLY f} una +funzione ordinaria. Analogamente, c' un'operazione per +\emph{totalizzare} una mappa finita (\holtxt{lookup}) cos che +un'applicazione di essa restituisca una funzione ordinaria, il rango della quale +il tipo option. Una funzione ordinaria pu essere trasformata in una mappa finita +restringendo la funzione a un insieme finito di argomenti (\ml{FUN\_FMAP\_DEF}). % \begin{hol} @@ -4638,14 +4638,14 @@ \subsection{Mappe finite (\theoryimp{finite\_map})}\label{finite_map} \paragraph {Composizione di mappe} \index{composizione di funzione, nella logica HOL@composizione di funzione, nella logica \HOL{}!di mappe finite} -Ci sono tre nuove definizioni di composizione, determinate dal fatto se -le funzioni composte sono mappe finite o no. La composizione di due -mappe finite (\verb+f_o_f+, infisso) ha attaccati dei vincoli -di dominio. La composizione di una mappa finita con una funzione ordinaria -(\verb+o_f+, infisso) applica prima la mappa finita, poi la funzione -ordinaria. La composizione di una funzione ordinaria con una mappa finita -(\verb+f_o+, infisso) applica la funzione ordinaria e poi la mappa -finita; l'applicazione della funzione ordinaria ottenuta trasformandola +Ci sono tre nuove definizioni di composizione, determinate dal fatto se +le funzioni composte sono mappe finite o no. La composizione di due +mappe finite (\verb+f_o_f+, infisso) ha attaccati dei vincoli +di dominio. La composizione di una mappa finita con una funzione ordinaria +(\verb+o_f+, infisso) applica prima la mappa finita, poi la funzione +ordinaria. La composizione di una funzione ordinaria con una mappa finita +(\verb+f_o+, infisso) applica la funzione ordinaria e poi la mappa +finita; l'applicazione della funzione ordinaria ottenuta trasformandola in una mappa finita. % \begin{hol} @@ -4666,10 +4666,10 @@ \subsection{Mappe finite (\theoryimp{finite\_map})}\label{finite_map} \section{Cicli While} \label{sec:while-loops} -E' un fatto curioso che la logica di ordine superiore, bench sia una logica di -funzioni totali, permetta la definizione di funzioni che non sembrano -totali, almeno da un punto di vista computazionale. Un esempio -sono i cicli-\holtxt{WHILE}. La seguente equazione derivata nella teoria +E' un fatto curioso che la logica di ordine superiore, bench sia una logica di +funzioni totali, permetta la definizione di funzioni che non sembrano +totali, almeno da un punto di vista computazionale. Un esempio +sono i cicli-\holtxt{WHILE}. La seguente equazione derivata nella teoria \theoryimp{while}: % \begin{hol} @@ -4679,14 +4679,14 @@ \section{Cicli While} \end{hol} % Chiaramente, se \holtxt{P} in questo teorema fosse istanziato a $\lambda -x.\;\konst{T}$, l'istanza risultante di \holtxt{WHILE} sarebbe `va avanti -per sempre' se eseguita. Perch una tale funzione ``ovviamente'' parziale +x.\;\konst{T}$, l'istanza risultante di \holtxt{WHILE} sarebbe `va avanti +per sempre' se eseguita. Perch una tale funzione ``ovviamente'' parziale definibile in HOL? % La risposta si trova in una sottile definizione di \holtxt{WHILE}, \footnote{L'idea originale dovuta a J. Moore, che la sugger per l'uso in ACL2.} -che usa il potere espressivo di HOL per un effetto sorprendente. Si consideri +che usa il potere espressivo di HOL per un effetto sorprendente. Si consideri la seguente funzione totale e non-ricorsiva: % \begin{hol} @@ -4698,10 +4698,10 @@ \section{Cicli While} \end{verbatim} \end{hol} % -Questa funzione fa un'analisi dei casi sulle iterazioni della funzione -\holtxt{g}: quelle finite restituiscono il primo valore nell'iterazione per -cui \holtxt{P} vale (cio, quando l'iterazione si ferma); quelle -infinite sono mappate a \holtxt{ARB}. Questa funzione usata come il testimone +Questa funzione fa un'analisi dei casi sulle iterazioni della funzione +\holtxt{g}: quelle finite restituiscono il primo valore nell'iterazione per +cui \holtxt{P} vale (cio, quando l'iterazione si ferma); quelle +infinite sono mappate a \holtxt{ARB}. Questa funzione usata come il testimone per \verb+f+ nella dimostrazione del seguente teorema: % \begin{hol} @@ -4711,16 +4711,16 @@ \section{Cicli While} \end{verbatim} \end{hol} % -Da questo, semplicemente questione di applicare la Skolemizzazione e +Da questo, semplicemente questione di applicare la Skolemizzazione e di \holtxt{new\_specification} per ottenere l'equazione per \holtxt{WHILE}. \paragraph{Ragionare circa i cicli \holtxt{WHILE}} -Il teorema d'induzione per i cicli \holtxt{WHILE} dimostrato per -induzione benfondata, e porta con s dei vincoli di benfondatezza -che ne limitano la sua applicazione. Al fine di applicare \verb+WHILE_INDUCTION+, -le istanziazione per \verb+B+ e \verb+C+ devono essere conosciute prima -che una relazione benfondata per \verb+R+ sia trovata e usata per eliminare i +Il teorema d'induzione per i cicli \holtxt{WHILE} dimostrato per +induzione benfondata, e porta con s dei vincoli di benfondatezza +che ne limitano la sua applicazione. Al fine di applicare \verb+WHILE_INDUCTION+, +le istanziazione per \verb+B+ e \verb+C+ devono essere conosciute prima +che una relazione benfondata per \verb+R+ sia trovata e usata per eliminare i vincoli. % \begin{hol} @@ -4732,7 +4732,7 @@ \section{Cicli While} \end{verbatim} \end{hol} % -Un livello di supporto pi raffinato fornito dalla regola \holtxt{WHILE} +Un livello di supporto pi raffinato fornito dalla regola \holtxt{WHILE} standard della Logica di Hoare, espressa in termini di triple Hoare (\holtxt{HOARE\_SPEC}). % @@ -4748,7 +4748,7 @@ \section{Cicli While} \end{verbatim} \end{hol} % -Come seguito, definito un operatore per trovare l'ultimo numero con la propriet +Come seguito, definito un operatore per trovare l'ultimo numero con la propriet \verb+P+. % \begin{hol} @@ -4757,14 +4757,14 @@ \section{Cicli While} \end{verbatim} \end{hol} % -Alcuni teoremi per ragionare su \holtxt{LEAST} si possono trovare nella +Alcuni teoremi per ragionare su \holtxt{LEAST} si possono trovare nella teoria \theoryimp{while}. %\section{Partial orders} \section{Altre Teorie} -Altre teorie di interesse in \HOL{} sono elencate e brevemente descritte +Altre teorie di interesse in \HOL{} sono elencate e brevemente descritte nella Figura~\ref{fig:further-hol-theories}. \begin{figure}[hbtp] @@ -4777,7 +4777,7 @@ \section{Altre Teorie} Divisibilit e il massimo comun divisore. \\ \theoryimp{poly} & - Una teoria di polinomi su $\mathbb{R}$, che fornisce + Una teoria di polinomi su $\mathbb{R}$, che fornisce una collezione di operazioni su polinomi, e teoremi che li riguardano. \\ \theoryimp{Temporal\_Logic},\newline \theoryimp{Omega\_Automata} @@ -4786,7 +4786,7 @@ \section{Altre Teorie} \\ \theoryimp{ctl}, \theoryimp{mu} & - La logica Computation Tree Logic e l'$\mu$-calculo. Si veda la tesi di + La logica Computation Tree Logic e l'$\mu$-calculo. Si veda la tesi di Hasan Amjad. \\ \theoryimp{lbtree} & Alberi binari possibilmente infinitamente profondi (cio, co-algebrici).\\ \theoryimp{inftree} & Alberi algebrici possibilmente infinitamente ramificanti\\ diff --git a/Manual/Translations/IT/LaTeX/ack.tex b/Manual/Translations/IT/LaTeX/ack.tex index 6b0e238b2b..dffb606d42 100644 --- a/Manual/Translations/IT/LaTeX/ack.tex +++ b/Manual/Translations/IT/LaTeX/ack.tex @@ -1,6 +1,6 @@ \chapter*{Riconoscimenti}\markboth{Riconoscimenti}{Riconoscimenti} -La maggior parte di \HOL\ basato su codice scritto da---in ordine +La maggior parte di \HOL\ basato su codice scritto da---in ordine alfabetico---% Hasan Amjad, Richard Boulton, @@ -31,42 +31,42 @@ \chapter*{Riconoscimenti}\markboth{Riconoscimenti}{Riconoscimenti} \subsection*{Edizione attuale} L'edizione attuale di tutti e quattro i volumi (\LOGIC, \TUTORIAL, -\DESCRIPTION\ e \REFERENCE) stata preparata da Michael Norrish e +\DESCRIPTION\ e \REFERENCE) stata preparata da Michael Norrish e Konrad Slind. Altri contributi a questi volumi sono venuti da Hasan -Amjad, che ha sviluppato una libreria di controllo del modello, e ha scritto le sezioni -che ne descrivono l'uso; Jens Brandt, che ha sviluppato e documentato una -libreria per i numeri razionali; Anthony Fox, che ha formalizzato e -documentato nuove teorie dei gruppi riguardanti i word e le librerie associate; Mike -Gordon, che ha documentato le librerie per i BDD e SAT; Peter Homeier, -che ha implementato e documentato la libreria quoziente; Joe Hurd, che -ha aggiunto materiale sulla ricerca della dimostrazione nel primo ordine; e Tjark Weber, che ha scritto -le librerie per le Teorie Modulo Soddisfacibilit~(SMT) e le Formule Booleane +Amjad, che ha sviluppato una libreria di controllo del modello, e ha scritto le sezioni +che ne descrivono l'uso; Jens Brandt, che ha sviluppato e documentato una +libreria per i numeri razionali; Anthony Fox, che ha formalizzato e +documentato nuove teorie dei gruppi riguardanti i word e le librerie associate; Mike +Gordon, che ha documentato le librerie per i BDD e SAT; Peter Homeier, +che ha implementato e documentato la libreria quoziente; Joe Hurd, che +ha aggiunto materiale sulla ricerca della dimostrazione nel primo ordine; e Tjark Weber, che ha scritto +le librerie per le Teorie Modulo Soddisfacibilit~(SMT) e le Formule Booleane Quantificate~(QBF). \medskip -Il materiale nella terza edizione costituisce un'approfondita rielaborazione -ed estensione delle edizioni precedenti, l'unico pezzo essenzialmente non -alterato la semantica di Andy Pitts (in \LOGIC), il che riflette il fatto -che, nonostante il sistema \HOL\ abbia subito uno sviluppo e un miglioramento -continuo, la logica di \HOL\ rimasta inalterata dalla sua prima edizione +Il materiale nella terza edizione costituisce un'approfondita rielaborazione +ed estensione delle edizioni precedenti, l'unico pezzo essenzialmente non +alterato la semantica di Andy Pitts (in \LOGIC), il che riflette il fatto +che, nonostante il sistema \HOL\ abbia subito uno sviluppo e un miglioramento +continuo, la logica di \HOL\ rimasta inalterata dalla sua prima edizione (1988). \newpage \subsection*{Seconda edizione} -La seconda edizione di \REFERENCE\ stato uno sforzo congiunto da parte del gruppo +La seconda edizione di \REFERENCE\ stato uno sforzo congiunto da parte del gruppo \HOL\ di Cambridge. \subsection*{Prima edizione} -I tre volumi \TUTORIAL, \DESCRIPTION\ e \REFERENCE\ sono stati -prodotti presso il Cambridge Research Center della SRI International con il +I tre volumi \TUTORIAL, \DESCRIPTION\ e \REFERENCE\ sono stati +prodotti presso il Cambridge Research Center della SRI International con il supporto del DSTO Australia. -Il progetto di documentazione di \HOL\ fu gestito da Mike Gordon, che -scrisse anche parti di \DESCRIPTION\ e \TUTORIAL\ usando del materiale basato su +Il progetto di documentazione di \HOL\ fu gestito da Mike Gordon, che +scrisse anche parti di \DESCRIPTION\ e \TUTORIAL\ usando del materiale basato su uno scritto originario che descriveva il sistema \HOL\footnote{M.J.C.\ Gordon, `HOL: a Proof Generating System for Higher Order Logic', in: {\it VLSI Specification, Verification and Synthesis\/}, edito da G.\ @@ -74,24 +74,24 @@ \subsection*{Prima edizione} 1988), pp.\ 73--128.} e {\sl The ML Handbook\/}\footnote{{\sl The ML Handbook}, scritto inedito presso l'Inria da parte di Guy Cousineau, Mike Gordon, G\'erard Huet, Robin Milner, Larry Paulson and Chris - Wadsworth.}. Altri che hanno contribuito a \DESCRIPTION\ includono Avra Cohn, -che ha scritto del materiale su teoremi, regole, conversioni e tattiche, -e ha anche composto l'indice (che fu battuto a macchina da Juanito Camilleri); -Tom Melham, che ha scritto le sezioni che descrivono le definizioni di tipo, -il concreto pacchetto dei tipi, e le tattiche di `risoluzione'; e Andy Pitts, -che ha ideato la semantica a modelli insiemistici della logica di \HOL\ e ha scritto + Wadsworth.}. Altri che hanno contribuito a \DESCRIPTION\ includono Avra Cohn, +che ha scritto del materiale su teoremi, regole, conversioni e tattiche, +e ha anche composto l'indice (che fu battuto a macchina da Juanito Camilleri); +Tom Melham, che ha scritto le sezioni che descrivono le definizioni di tipo, +il concreto pacchetto dei tipi, e le tattiche di `risoluzione'; e Andy Pitts, +che ha ideato la semantica a modelli insiemistici della logica di \HOL\ e ha scritto il materiale che la descrive. Il documento originario usava macro \LaTeX\ fornite da Elsa -Gunter, Tom Melham e Larry Paulson. La battitura di tutti e tre +Gunter, Tom Melham e Larry Paulson. La battitura di tutti e tre i volumi fu gestita da Tom Melham. La copertina fu disegnata da Arnold -Smith, che us una fotografia di una `lanterna da neve' presa da +Smith, che us una fotografia di una `lanterna da neve' presa da Avra Cohn (nel cui giardino risiede l'oggetto originale). John Van Tassel ha composto l'immagine \LaTeX\ della lanterna. -Molte altre persone oltre a quelle elencate di sopra hanno contribuito nello sforzo della -documentazione di \HOL\, sia fornendo materiale, sia inviando elenchi di errori nella prima -edizione. Grazie a tutti coloro che hanno aiutato, e grazie al DSTO e all'SRI per il loro +Molte altre persone oltre a quelle elencate di sopra hanno contribuito nello sforzo della +documentazione di \HOL\, sia fornendo materiale, sia inviando elenchi di errori nella prima +edizione. Grazie a tutti coloro che hanno aiutato, e grazie al DSTO e all'SRI per il loro generoso supporto. diff --git a/Manual/Translations/IT/Logic/logic.tex b/Manual/Translations/IT/Logic/logic.tex index 3a85ca30ae..d0432d2e8b 100644 --- a/Manual/Translations/IT/Logic/logic.tex +++ b/Manual/Translations/IT/Logic/logic.tex @@ -51,7 +51,7 @@ \bibliographystyle{plain} \bibliography{../../../Description/description} - + \printindex \newcommand{\glossario}{Indice analitico} \addcontentsline{toc}{chapter}{\glossario} diff --git a/Manual/Translations/IT/Logic/preface.tex b/Manual/Translations/IT/Logic/preface.tex index e7e4a3c0d5..05219f88f0 100644 --- a/Manual/Translations/IT/Logic/preface.tex +++ b/Manual/Translations/IT/Logic/preface.tex @@ -1,7 +1,7 @@ \chapter*{Prefazione}\markboth{Prefazione}{Prefazione} \label{intro} -Questo volume contiene la descrizione della logica del sistema \HOL. E' +Questo volume contiene la descrizione della logica del sistema \HOL. E' uno di quattro volumi che compongono la documentazione per \HOL: \begin{myenumerate} @@ -15,82 +15,82 @@ \chapter*{Prefazione}\markboth{Prefazione}{Prefazione} \noindent Si far riferimento a questi quattro documenti con i nomi abbreviati (in maiuscoletto inclinato) dati di sopra. -Questo documento, \LOGIC, serve come una definizione formale della logica -di ordine superiore in termini di una semantica a modelli. Questo materiale fu -scritto da Andrew Pitts nel 1991, ed era originariamente parte di -\DESCRIPTION. Poich questa logica condivisa con altri sistemi di dimostrazione -di teoremi (HOL~Light, ProofPower), ed simile a quella implementata in -Isabelle, in cui chiamata Isabelle/HOL, ora presentata nel suo +Questo documento, \LOGIC, serve come una definizione formale della logica +di ordine superiore in termini di una semantica a modelli. Questo materiale fu +scritto da Andrew Pitts nel 1991, ed era originariamente parte di +\DESCRIPTION. Poich questa logica condivisa con altri sistemi di dimostrazione +di teoremi (HOL~Light, ProofPower), ed simile a quella implementata in +Isabelle, in cui chiamata Isabelle/HOL, ora presentata nel suo proprio manuale. -Il sistema \HOL\ sviluppato per supportare la dimostrazione interattiva di teoremi nella -logica di ordine superiore(da qui l'acronimo `\HOL'). A questo scopo, la logica -formale interfacciata da un linguaggio di programmazione di uso generale (\ML, per +Il sistema \HOL\ sviluppato per supportare la dimostrazione interattiva di teoremi nella +logica di ordine superiore(da qui l'acronimo `\HOL'). A questo scopo, la logica +formale interfacciata da un linguaggio di programmazione di uso generale (\ML, per meta-linguaggio) in cui si possono denotare i termini e i teoremi della logica, -esprimere ed applicare le strategie di dimostrazione, e sviluppare teorie logiche. -La versione della logica di ordine superiore usata in \HOL\ un calcolo dei predicati -con i termini del lambda calcolo tipizzato (cio la teoria semplice dei -tipi). Questa fu originariamente sviluppata come una fondazione per la matematica -da \cite{Church}. La principale area di applicazione di \HOL\ fu inizialmente -intesa essere la specifica e la verifica dei dispositivi di hardware. -(L'uso della logica di ordine superiore a questo scopo fu inizialmente sostenuto da -Keith Hanna \cite{Hanna-Daeche}.) Comunque, le applicazioni della logica non +esprimere ed applicare le strategie di dimostrazione, e sviluppare teorie logiche. +La versione della logica di ordine superiore usata in \HOL\ un calcolo dei predicati +con i termini del lambda calcolo tipizzato (cio la teoria semplice dei +tipi). Questa fu originariamente sviluppata come una fondazione per la matematica +da \cite{Church}. La principale area di applicazione di \HOL\ fu inizialmente +intesa essere la specifica e la verifica dei dispositivi di hardware. +(L'uso della logica di ordine superiore a questo scopo fu inizialmente sostenuto da +Keith Hanna \cite{Hanna-Daeche}.) Comunque, le applicazioni della logica non si riducono all'hardware; \HOL\ stato applicato in molte altre aree. -Cos, questo documento descrive le basi teoriche del +Cos, questo documento descrive le basi teoriche del sistema \HOL{}, e lo presenta astrattamente. L'approccio di meccanizzare le dimostrazioni formali usato in \HOL\ dovuto a Robin -Milner \cite{Edinburgh-LCF}, che ha anche diretto il team che ha progettato -e implementato il linguaggio \ML. Quel lavoro era centrato su un sistema -chiamato \LCF\ (logica per le funzioni computabili), che era inteso per -il ragionamento interattivo automatizzato circa funzioni di ordine superiore definite -ricorsivamente. L'interfaccia della logica al meta-linguaggio era reso -esplicito, usando la struttura di tipi dell'\ML, con l'intenzione che alla fine -altre logiche sarebbe state provate al posto della logica originaria. Il -sistema \HOL\ un discendente diretto di \LCF; questo riflesso in -ogni cosa dalla sua struttura e aspetto alla sua incorporazione dell'\ML, -e persino a parti della sua implementazione. Cos \HOL\ soddisfa il +Milner \cite{Edinburgh-LCF}, che ha anche diretto il team che ha progettato +e implementato il linguaggio \ML. Quel lavoro era centrato su un sistema +chiamato \LCF\ (logica per le funzioni computabili), che era inteso per +il ragionamento interattivo automatizzato circa funzioni di ordine superiore definite +ricorsivamente. L'interfaccia della logica al meta-linguaggio era reso +esplicito, usando la struttura di tipi dell'\ML, con l'intenzione che alla fine +altre logiche sarebbe state provate al posto della logica originaria. Il +sistema \HOL\ un discendente diretto di \LCF; questo riflesso in +ogni cosa dalla sua struttura e aspetto alla sua incorporazione dell'\ML, +e persino a parti della sua implementazione. Cos \HOL\ soddisfa il piano iniziale di applicare la metodologia \LCF\ ad altre logiche. -L'\LCF\ originario fu implementato ad Edimburgo nei primi anni 1970, ed ora ci si -riferisce ad esso come all'`\LCF di Edimburgo'. Il suo codice fu portato dallo Stanford Lisp -al Franz Lisp da G\'erard Huet presso l'{\small INRIA}, e fu usato in un progetto di ricerca -francese chiamato `Formel'. La versione Franz Lisp dell'\LCF\ di Huet fu -ulteriormente sviluppata a Cambridge da Larry Paulson, e divenne conosciuta come il -`Cambridge \LCF'. Il sistema \HOL\ implementato sulla base di una prima versione del Cambridge -\LCF\ e di conseguenza molte delle caratteristiche sia dell'Edinburgh che del Cambridge \LCF\ furono -ereditate da \HOL. Per esempio, l'assiomatizzazione della logica di ordine superiore utilizzata -non quella classica dovuta a Church, ma una formulazione equivalente +L'\LCF\ originario fu implementato ad Edimburgo nei primi anni 1970, ed ora ci si +riferisce ad esso come all'`\LCF di Edimburgo'. Il suo codice fu portato dallo Stanford Lisp +al Franz Lisp da G\'erard Huet presso l'{\small INRIA}, e fu usato in un progetto di ricerca +francese chiamato `Formel'. La versione Franz Lisp dell'\LCF\ di Huet fu +ulteriormente sviluppata a Cambridge da Larry Paulson, e divenne conosciuta come il +`Cambridge \LCF'. Il sistema \HOL\ implementato sulla base di una prima versione del Cambridge +\LCF\ e di conseguenza molte delle caratteristiche sia dell'Edinburgh che del Cambridge \LCF\ furono +ereditate da \HOL. Per esempio, l'assiomatizzazione della logica di ordine superiore utilizzata +non quella classica dovuta a Church, ma una formulazione equivalente influenzata da \LCF. -Una versione avanzata e razionalizzata di \HOL, chiamata \HOL 88, fu -rilasciata (nel 1988), dopo che il sistema \HOL\ originario era stato in uso -per molti anni. \HOL 90 (rilasciato nel 1990) fu un porting di \HOL 88 -in SML \cite{sml} da parte di Konrad Slind presso l'Universit di Calgary. Esso stato -ulteriormente sviluppato nel corso degli anni 1990. \HOL{} 4 l'ultima -versione di \HOL, e anch'esso implementato in SML; dotato di un numero -di novit rispetto ai suoi predecessori. \HOL{} 4 anche la +Una versione avanzata e razionalizzata di \HOL, chiamata \HOL 88, fu +rilasciata (nel 1988), dopo che il sistema \HOL\ originario era stato in uso +per molti anni. \HOL 90 (rilasciato nel 1990) fu un porting di \HOL 88 +in SML \cite{sml} da parte di Konrad Slind presso l'Universit di Calgary. Esso stato +ulteriormente sviluppato nel corso degli anni 1990. \HOL{} 4 l'ultima +versione di \HOL, e anch'esso implementato in SML; dotato di un numero +di novit rispetto ai suoi predecessori. \HOL{} 4 anche la versione del sistema supportata per la comunit internazionale \HOL. -Abbiamo deciso di numerare le implementazioni di \HOL{} retroattivamente nel +Abbiamo deciso di numerare le implementazioni di \HOL{} retroattivamente nel modo seguente \begin{enumerate} -\item \HOL88 e precedenti: implementazioni basate su un substrato Lisp, +\item \HOL88 e precedenti: implementazioni basate su un substrato Lisp, con l'ML Classico. -\item \HOL90: implementazioni in Standard ML, che usano principalmente +\item \HOL90: implementazioni in Standard ML, che usano principalmente l'implementazione SML/NJ. -\item \HOL98 (distribuzioni Athabasca e Taupo): implementazioni che usano +\item \HOL98 (distribuzioni Athabasca e Taupo): implementazioni che usano il Moscow ML, e con una nuova libreria e un nuovo meccanismo di teoria. \item \HOL{} (distribuzioni Kananaskis) \end{enumerate} -Di conseguenza, con \HOL{}~4, facciamo a meno dell'abitudine di associare -le implementazioni con i numeri degli anni. Le distribuzioni individuali all'interno +Di conseguenza, con \HOL{}~4, facciamo a meno dell'abitudine di associare +le implementazioni con i numeri degli anni. Le distribuzioni individuali all'interno di \HOL{}~4 conservano lo schema di nome \textit{lake-number}. -In questo documento, l'acronimo `\HOL' si riferisce sia al sistema di dimostrazione -interattiva di teoremi sia alla versione di logica di ordine superiore che il sistema -supporta; dove c' una seria ambiguit, il primo chiamato `il sistema +In questo documento, l'acronimo `\HOL' si riferisce sia al sistema di dimostrazione +interattiva di teoremi sia alla versione di logica di ordine superiore che il sistema +supporta; dove c' una seria ambiguit, il primo chiamato `il sistema \HOL' e la seconda `la logica \HOL'. %%% Local Variables: diff --git a/Manual/Translations/IT/Logic/semantics.tex b/Manual/Translations/IT/Logic/semantics.tex index 990c9738a1..09f8f7c4b7 100644 --- a/Manual/Translations/IT/Logic/semantics.tex +++ b/Manual/Translations/IT/Logic/semantics.tex @@ -8,78 +8,78 @@ \chapter{Teorie}\label{semantics} \section{Introduzione} -Il risultato, se ce n' uno, di una sessione con il sistema \HOL{} un oggetto -chiamato una {\it teoria\/}. Questo oggetto strettamente collegato con ci che un -logico chiamerebbe una teoria\index{theories, nella logica HOL@teorie, nella logica \HOL{}!forma astratta di}, ma ci sono alcune differenze che sorgono -dalle necessit della dimostrazione meccanica. Una teoria \HOL{}, come la teoria di -un logico, contiene insiemi di tipi, costanti, definizioni e assiomi. In -aggiunta, tuttavia, una teoria \HOL{}, in qualsiasi punto del tempo, contiene una -esplicita lista di teoremi che sono gi stati dimostrati dagli -assiomi e dalle definizioni. I logici non hanno alcuna necessit di distinguere i teoremi -attualmente dimostrati da quelli meramente dimostrabili; di conseguenza essi normalmente non -considerano insiemi di teoremi dimostrati come parte di una teoria; piuttosto, essi -considerano i teoremi di una teoria essere l'insieme (spesso infinito) di tutte -le conseguenze degli assiomi e le definizioni. Una differenza collegata -tra le teorie dei logici e le teorie \HOL{} che per i logici, -le teorie sono oggetti statici, ma in \HOL{} esse possono essere pensate come -potenzialmente estensibili. Per esempio, il sistema \HOL{} fornisce strumenti -per aggiungere alle teorie e combinare teorie. Un'interazione tipica -con \HOL{} consiste nel combinare qualche teoria esistente, facendo qualche +Il risultato, se ce n' uno, di una sessione con il sistema \HOL{} un oggetto +chiamato una {\it teoria\/}. Questo oggetto strettamente collegato con ci che un +logico chiamerebbe una teoria\index{theories, nella logica HOL@teorie, nella logica \HOL{}!forma astratta di}, ma ci sono alcune differenze che sorgono +dalle necessit della dimostrazione meccanica. Una teoria \HOL{}, come la teoria di +un logico, contiene insiemi di tipi, costanti, definizioni e assiomi. In +aggiunta, tuttavia, una teoria \HOL{}, in qualsiasi punto del tempo, contiene una +esplicita lista di teoremi che sono gi stati dimostrati dagli +assiomi e dalle definizioni. I logici non hanno alcuna necessit di distinguere i teoremi +attualmente dimostrati da quelli meramente dimostrabili; di conseguenza essi normalmente non +considerano insiemi di teoremi dimostrati come parte di una teoria; piuttosto, essi +considerano i teoremi di una teoria essere l'insieme (spesso infinito) di tutte +le conseguenze degli assiomi e le definizioni. Una differenza collegata +tra le teorie dei logici e le teorie \HOL{} che per i logici, +le teorie sono oggetti statici, ma in \HOL{} esse possono essere pensate come +potenzialmente estensibili. Per esempio, il sistema \HOL{} fornisce strumenti +per aggiungere alle teorie e combinare teorie. Un'interazione tipica +con \HOL{} consiste nel combinare qualche teoria esistente, facendo qualche definizione, dimostrando alcuni teoremi e poi salvare i nuovi risultati. -Lo scopo del sistema \HOL{} di fornire strumenti per permettere -di costruire teorie ben-formate. La logica \HOL{} tipizzata: -ogni teoria specifica una firma di constanti di tipo e individuali; -queste poi determinano gli insiemi dei tipi e dei termini come nel capitolo -precedente. Tutti i teoremi di tali teorie sono conseguenze logiche -delle definizioni e degli assiomi della teoria. Il sistema \HOL{} assicura -che solo teorie ben-formate possono essere costruite permettendo di creare -teoremi solo per {\it dimostrazione formale\/}. Esplicitare questo comporta -definire cosa significa essere un teorema, il che porta alla descrizione -del sistema di dimostrazione di \HOL{}, che sar dato di seguito. Esso dimostrato essere {\em -valido\/} per la semantica insiemistica di \HOL{} descritta nel -capitolo precedente. Questo significa che un teorema soddisfatto da un modello -se ha una dimostrazione formale da assiomi che sono a loro volta soddisfatti dal -modello. Dal momento che una contraddizione logica non soddisfatta da alcun -modello, questo garantisce in particolare che una teoria che possiede un modello - necessariamente coerente, cio non pu essere dimostrata una contraddizione +Lo scopo del sistema \HOL{} di fornire strumenti per permettere +di costruire teorie ben-formate. La logica \HOL{} tipizzata: +ogni teoria specifica una firma di constanti di tipo e individuali; +queste poi determinano gli insiemi dei tipi e dei termini come nel capitolo +precedente. Tutti i teoremi di tali teorie sono conseguenze logiche +delle definizioni e degli assiomi della teoria. Il sistema \HOL{} assicura +che solo teorie ben-formate possono essere costruite permettendo di creare +teoremi solo per {\it dimostrazione formale\/}. Esplicitare questo comporta +definire cosa significa essere un teorema, il che porta alla descrizione +del sistema di dimostrazione di \HOL{}, che sar dato di seguito. Esso dimostrato essere {\em +valido\/} per la semantica insiemistica di \HOL{} descritta nel +capitolo precedente. Questo significa che un teorema soddisfatto da un modello +se ha una dimostrazione formale da assiomi che sono a loro volta soddisfatti dal +modello. Dal momento che una contraddizione logica non soddisfatta da alcun +modello, questo garantisce in particolare che una teoria che possiede un modello + necessariamente coerente, cio non pu essere dimostrata una contraddizione logica dai suoi assiomi. -Questo capitolo descrive anche i vari meccanismi per i quali le teorie -\HOL\ possono essere estese a nuove teorie. Ogni meccanismo mostrato -preservare la propriet di possedere un modello. Cos le teorie costruite -dalla teoria \HOL{} iniziale (che possiede un modello) usando +Questo capitolo descrive anche i vari meccanismi per i quali le teorie +\HOL\ possono essere estese a nuove teorie. Ogni meccanismo mostrato +preservare la propriet di possedere un modello. Cos le teorie costruite +dalla teoria \HOL{} iniziale (che possiede un modello) usando questi meccanismi sono garantite essere coerenti. \section{Sequenti} \label{sequents} -La logica \HOL{} formulata in termini di asserzioni ipotetiche chiamate -{\em sequenti}\index{sequenti!nella deduzione naturale}. Fissando una +La logica \HOL{} formulata in termini di asserzioni ipotetiche chiamate +{\em sequenti}\index{sequenti!nella deduzione naturale}. Fissando una firma (standard) $\Sigma_\Omega$, un sequente una coppia $(\Gamma, -t)$ dove $\Gamma$ un insieme finito di formule su $\Sigma_\Omega$ -e $t$ una singola formula su $\Sigma_\Omega$\footnote{Si noti che -il sottoscritto di tipo omesso dai termini quando chiaro dal -contesto che essi sono formule, cio hanno tipo \ty{bool}.}. L'insieme di -formule $\Gamma$ che formano il primo componente di un sequente chiamato -il suo insieme di {\it assunzioni\/}\index{assunzioni!di sequenti} e il +t)$ dove $\Gamma$ un insieme finito di formule su $\Sigma_\Omega$ +e $t$ una singola formula su $\Sigma_\Omega$\footnote{Si noti che +il sottoscritto di tipo omesso dai termini quando chiaro dal +contesto che essi sono formule, cio hanno tipo \ty{bool}.}. L'insieme di +formule $\Gamma$ che formano il primo componente di un sequente chiamato +il suo insieme di {\it assunzioni\/}\index{assunzioni!di sequenti} e il termine $t$ che forma il secondo componente chiamato la sua {\it -conclusione\/}\index{conclusioni!di sequenti}. Quando non d origine ad +conclusione\/}\index{conclusioni!di sequenti}. Quando non d origine ad ambiguit, un sequente $(\{\},t)$ scritto semplicemente $t$. Intuitivamente un modello $M$ di $\Sigma_\Omega$ {\em -soddisfa}\index{soddisfazione di sequenti, da parte di un modello} un sequente -$(\Gamma, t)$ se qualsiasi interpretazione delle variabili libere rilevanti come -elementi di $M$ che rendono le formule in $\Gamma$ vere, rendono vera -anche la formula $t$. Per rendere questo pi preciso, supponiamo che -$\Gamma=\{t_1,\ldots,t_p\}$ e sia $\alpha\!s,\!x\!s$ un -contesto contenente tutte le variabili di tipo e tutte le variabili libere -che occorrono nelle formule $t,t_{1},\ldots,t_{p}$. Supponiamo che -$\alpha\!s$ abbia lunghezza $n$, che $x\!s=x_{1},\ldots,x_{m}$ e che il -tipo di $x_{j}$ sia $\sigma_{j}$. Dal momento che le formule sono termini di tipo -$\bool$, la semantica dei termini definita nel capitolo precedente da +soddisfa}\index{soddisfazione di sequenti, da parte di un modello} un sequente +$(\Gamma, t)$ se qualsiasi interpretazione delle variabili libere rilevanti come +elementi di $M$ che rendono le formule in $\Gamma$ vere, rendono vera +anche la formula $t$. Per rendere questo pi preciso, supponiamo che +$\Gamma=\{t_1,\ldots,t_p\}$ e sia $\alpha\!s,\!x\!s$ un +contesto contenente tutte le variabili di tipo e tutte le variabili libere +che occorrono nelle formule $t,t_{1},\ldots,t_{p}$. Supponiamo che +$\alpha\!s$ abbia lunghezza $n$, che $x\!s=x_{1},\ldots,x_{m}$ e che il +tipo di $x_{j}$ sia $\sigma_{j}$. Dal momento che le formule sono termini di tipo +$\bool$, la semantica dei termini definita nel capitolo precedente da origine a elementi $\den{\alpha\!s,\!x\!s.t}_M$ e $\den{\alpha\!s,\!x\!s.t_{k}}_M$ ($k=1,\ldots,p$) in \[ @@ -102,8 +102,8 @@ \section{Sequenti} \] (Si ricordi che $\two$ l'insieme $\{0,1\}$.) -Nel caso $p=0$, la soddisfazione di $(\{\},t)$ da parte di $M$ sar scritta -$\models_{M} t$. Cos $\models_{M} t$ significa che la funzione dipendentemente tipizzata +Nel caso $p=0$, la soddisfazione di $(\{\},t)$ da parte di $M$ sar scritta +$\models_{M} t$. Cos $\models_{M} t$ significa che la funzione dipendentemente tipizzata \[ \den{t}_M \in \prod_{X\!s\in{\cal U}^{n}} \left(\prod_{j=1}^{m}\den{\alpha\!s.\sigma_{j}}_M(X\!s)\right) \fun \:\two @@ -112,15 +112,15 @@ \section{Sequenti} \section{Logica} -Un sistema deduttivo\index{sistemi deduttivi} -${\cal D}$ un insieme di coppie $(L,(\Gamma,t))$ dove $L$ una +Un sistema deduttivo\index{sistemi deduttivi} +${\cal D}$ un insieme di coppie $(L,(\Gamma,t))$ dove $L$ una lista (possibilmente vuota) di sequenti e $(\Gamma,t)$ un sequente. Un sequente $(\Gamma,t)$ segue da\index{segue da, nella deduzione naturale} -un insieme di sequenti -$\Delta$ per un sistema deduttivo +un insieme di sequenti +$\Delta$ per un sistema deduttivo ${\cal D}$ se -e solo se esistono sequenti +e solo se esistono sequenti $(\Gamma_1,t_1)$, $\ldots$ , $(\Gamma_n,t_n)$ tali che: \begin{enumerate} \item $(\Gamma,t) = (\Gamma_n,t_n)$, e @@ -143,40 +143,40 @@ \section{Logica} La notazione\index{turnstile} $t_1,\ldots,t_n\vdash_{{\cal D},\Delta} t$ significa che il sequente $(\{t_1,\ldots,t_n\},\ t)$ segue da $\Delta$ per ${\cal D}$. Se o ${\cal D}$ o $\Delta$ - chiaro dal contesto allora pu essere omesso. Nel caso in cui + chiaro dal contesto allora pu essere omesso. Nel caso in cui non ci siano ipotesi\index{ipotesi!di sequenti} (cio $n=0$), si scrive semplicemente $\vdash t$. -In pratica, un particolare sistema deduttivo di solito specificato da un +In pratica, un particolare sistema deduttivo di solito specificato da un numero di \emph{regole d'inferenza} (schematiche), -\index{regole d'inferenza, della logica HOL@regole d'inferenza, della logica \HOL{}!forma astratta di primitive} +\index{regole d'inferenza, della logica HOL@regole d'inferenza, della logica \HOL{}!forma astratta di primitive} che prendono la forma \[ \frac{\Gamma_1\turn t_1 \qquad\cdots\qquad\Gamma_n\turn t_n} {\Gamma \turn t} \] I sequenti sopra la linea sono chiamate le {\it -ipotesi\/}\index{ipotesi!di regole d'inferenza} della regola e il +ipotesi\/}\index{ipotesi!di regole d'inferenza} della regola e il sequente sotto la linea chiamato la sua {\it -conclusione}\index{conclusioni!di regole d'inferenza}. Una tale regola -schematica perch pu contenere meta-variabili -che stanno per termini arbitrari dei tipi appropriati. Istanziando -queste meta-variabili con termini reali, si ottiene una lista di sequenti -sopra la linea e un singolo sequente sotto la linea che insieme -costituiscono un elemento particolare del sistema deduttivo. Le -istanziazioni permesse per una particolare regola possono essere ristrette +conclusione}\index{conclusioni!di regole d'inferenza}. Una tale regola +schematica perch pu contenere meta-variabili +che stanno per termini arbitrari dei tipi appropriati. Istanziando +queste meta-variabili con termini reali, si ottiene una lista di sequenti +sopra la linea e un singolo sequente sotto la linea che insieme +costituiscono un elemento particolare del sistema deduttivo. Le +istanziazioni permesse per una particolare regola possono essere ristrette imponendo una {\em condizione a lato\/} della regola. \subsection{Il sistema deduttivo \HOL{}} \label{HOLrules} -Il sistema deduttivo della logica \HOL{} specificato da otto regole -d'inferenza, date di seguito. Le prime tre regole non hanno ipotesi; -le loro conclusioni possono essere dedotte sempre. Gli identificatori nelle parentesi -quadre sono i nomi delle funzioni \ML\ nel sistema \HOL{} che -implementano le corrispondenti regole d'inferenza (si veda \DESCRIPTION). Qualsiasi -condizioni a lato che restringano lo scopo di una regola sono date immediatamente +Il sistema deduttivo della logica \HOL{} specificato da otto regole +d'inferenza, date di seguito. Le prime tre regole non hanno ipotesi; +le loro conclusioni possono essere dedotte sempre. Gli identificatori nelle parentesi +quadre sono i nomi delle funzioni \ML\ nel sistema \HOL{} che +implementano le corrispondenti regole d'inferenza (si veda \DESCRIPTION). Qualsiasi +condizioni a lato che restringano lo scopo di una regola sono date immediatamente al di sotto di essa. \bigskip @@ -199,7 +199,7 @@ \subsubsection*{Beta-conversione [{\small\tt BETA\_CONV}]} \overline{\turn (\lquant{x}t_1)t_2 = t_1[t_2/x]} \] \begin{itemize} -\item Dove $t_1[t_2/x]$ +\item Dove $t_1[t_2/x]$ il risultato di sostituire $t_2$ per $x$ in $t_1$, con un'adatta rinomina delle variabili per impedire che le variabili libere in $t_2$ diventino legate dopo la sostituzione. @@ -213,11 +213,11 @@ \subsubsection*{Sostituzione [{\small\tt {\Gamma_1\cup\cdots\cup\Gamma_n\cup\Gamma\turn t[t_1',\ldots,t_n']} \] \begin{itemize} -\item Dove $t[t_1,\ldots,t_n]$ denota un termine $t$ con alcune occorrenze -libere di sottotermini $t_1$, $\ldots$ , $t_n$ isolati e -$t[t_1',\ldots,t_n']$ denota il risultato di sostituire ciascuna occorrenza -selezionata di $t_i$ per $t_i'$ (per $1{\leq}i{\leq}n$), con una rinomina -adatta delle variabili per impedire che variabili libere in $t_1'$ diventino +\item Dove $t[t_1,\ldots,t_n]$ denota un termine $t$ con alcune occorrenze +libere di sottotermini $t_1$, $\ldots$ , $t_n$ isolati e +$t[t_1',\ldots,t_n']$ denota il risultato di sostituire ciascuna occorrenza +selezionata di $t_i$ per $t_i'$ (per $1{\leq}i{\leq}n$), con una rinomina +adatta delle variabili per impedire che variabili libere in $t_1'$ diventino legate dopo la sostituzione. \end{itemize} @@ -239,13 +239,13 @@ \subsubsection*{Istanziazione di tipo [{\small\tt INST\_TYPE}]} {\Gamma\insttysub\turn t\insttysub} \] \begin{itemize} -\item Dove $t\insttysub$ il risultato di sostituire, in parallelo, - i tipi $\sigma_1$, $\dots$, $\sigma_n$ per le variabili di tipo +\item Dove $t\insttysub$ il risultato di sostituire, in parallelo, + i tipi $\sigma_1$, $\dots$, $\sigma_n$ per le variabili di tipo $\alpha_1$, $\dots$, $\alpha_n$ in $t$, e dove $\Gamma\insttysub$ - il risultato di eseguire la stessa sostituzione in tutte le + il risultato di eseguire la stessa sostituzione in tutte le ipotesi del teorema. -\item Dopo l'istanziazione, le variabili libere nell'input non possono - diventare legate, ma variabili libere distinte nell'input possono diventare +\item Dopo l'istanziazione, le variabili libere nell'input non possono + diventare legate, ma variabili libere distinte nell'input possono diventare identiche. \end{itemize} @@ -268,26 +268,26 @@ \subsubsection*{Modus Ponens [{\small\tt \] In aggiunta a queste otto regole, ci sono anche quattro {\it -assiomi\/}\index{assiomi!come regole d'inferenza} che avrebbero potuto essere -considerate come regole d'inferenza senza le ipotesi. Questo non fatto, -tuttavia, dal momento che pi naturale formulare gli assiomi usando qualche -costante logica definita e il principio di definizione di costante non -stato ancora descritto. Gli assiomi sono dati nella Sezione~\ref{INIT} e -le definizioni delle costanti logiche extra che essi coinvolgono sono date nella +assiomi\/}\index{assiomi!come regole d'inferenza} che avrebbero potuto essere +considerate come regole d'inferenza senza le ipotesi. Questo non fatto, +tuttavia, dal momento che pi naturale formulare gli assiomi usando qualche +costante logica definita e il principio di definizione di costante non +stato ancora descritto. Gli assiomi sono dati nella Sezione~\ref{INIT} e +le definizioni delle costanti logiche extra che essi coinvolgono sono date nella Sezione~\ref{LOG}. -Il particolare insieme di regole e assiomi scelti per assiomatizzare la logica -\HOL\ piuttosto arbitrario. In parte basato sulle regole che erano state -utilizzate nella logica -\LCF\index{LCF@\LCF}\ -\PPL\index{PPlambda (same as PPLAMBDA), of LCF system@\ml{PP}$\lambda$ (same as \ml{PPLAMBDA}), of \ml{LCF} system}, dal momento che \HOL{} stato -implementato modificando il sistema \LCF. In particolare, la -regola di sostituzione\index{substitution rule, nella logica HOL@substitution rule, nella logica \HOL{}!implementation of} {\small\tt SUBST} esattamente -la stessa della corrispondente regola in \LCF; il codice che implementa questa regola -fu scritto da Robin Milner ed altamente ottimizzato. Poich -la sostituzione un'attivit cos pervasiva nella dimostrazione, si ritenuto -importante che la primitiva di sistema fosse il pi veloce possibile. Da un -punto di vista logico sarebbe stato meglio avere una primitiva +Il particolare insieme di regole e assiomi scelti per assiomatizzare la logica +\HOL\ piuttosto arbitrario. In parte basato sulle regole che erano state +utilizzate nella logica +\LCF\index{LCF@\LCF}\ +\PPL\index{PPlambda (same as PPLAMBDA), of LCF system@\ml{PP}$\lambda$ (same as \ml{PPLAMBDA}), of \ml{LCF} system}, dal momento che \HOL{} stato +implementato modificando il sistema \LCF. In particolare, la +regola di sostituzione\index{substitution rule, nella logica HOL@substitution rule, nella logica \HOL{}!implementation of} {\small\tt SUBST} esattamente +la stessa della corrispondente regola in \LCF; il codice che implementa questa regola +fu scritto da Robin Milner ed altamente ottimizzato. Poich +la sostituzione un'attivit cos pervasiva nella dimostrazione, si ritenuto +importante che la primitiva di sistema fosse il pi veloce possibile. Da un +punto di vista logico sarebbe stato meglio avere una primitiva di sostituzione pi semplice, come la `Regola R' della logica di Andrews ${\cal Q}_0$, e poi derivare regole pi complicate da essa. @@ -296,24 +296,24 @@ \subsubsection*{Modus Ponens [{\small\tt \label{soundness} \index{inference rules, della logica HOL@inference rules, della logica \HOL{}!formal semantics of} -\emph{Le regole del sistema deduttivo \HOL{} sono {\em valide} per - la nozione di soddisfacimento definita nella Sezione~\ref{sequents}: per - qualsiasi istanza di regole d'inferenza, se un modello (standard) - soddisfa le ipotesi della regola soddisfa anche la +\emph{Le regole del sistema deduttivo \HOL{} sono {\em valide} per + la nozione di soddisfacimento definita nella Sezione~\ref{sequents}: per + qualsiasi istanza di regole d'inferenza, se un modello (standard) + soddisfa le ipotesi della regola soddisfa anche la conclusione.} \medskip \noindent{\bf Dimostrazione\ } -La verifica della validit delle regole semplice. -Le propriet della semantica rispetto alla sostituzione date dai -Lemmi 3 e 4 nella Sezione~\ref{term-substitution} sono necessari per le regole +La verifica della validit delle regole semplice. +Le propriet della semantica rispetto alla sostituzione date dai +Lemmi 3 e 4 nella Sezione~\ref{term-substitution} sono necessari per le regole \ml{BETA\_CONV}, \ml{SUBST} and -\ml{INST\_TYPE}\index{INST_TYPE@\ml{INST\_TYPE}}\footnote{Si noti in - particolare che la seconda restrizione su \ml{INST\_TYPE} permette - il risultato sulla semantica della sostituzione di tipi per variabili di tipo - nei termini da applicare}. Il fatto che $=$ e $\imp$ siano -interpretate in modo standard (come nella Sezione~\ref{standard-signatures}) +\ml{INST\_TYPE}\index{INST_TYPE@\ml{INST\_TYPE}}\footnote{Si noti in + particolare che la seconda restrizione su \ml{INST\_TYPE} permette + il risultato sulla semantica della sostituzione di tipi per variabili di tipo + nei termini da applicare}. Il fatto che $=$ e $\imp$ siano +interpretate in modo standard (come nella Sezione~\ref{standard-signatures}) necessario per le regole \ml{REFL}\index{REFL@\ml{REFL}}, \ml{BETA\_CONV}\index{BETA_CONV@\ml{BETA\_CONV}}, \ml{SUBST}\index{SUBST@\ml{SUBST}}, \ml{ABS}\index{ABS@\ml{ABS}}, @@ -330,7 +330,7 @@ \section{Teorie \HOL{}} dove \begin{myenumerate} -\item ${\sf Struc}_{\cal T}$ una struttura di tipo\index{type structures, of HOL theories@type structures, of \HOL{} theories} chiamata la +\item ${\sf Struc}_{\cal T}$ una struttura di tipo\index{type structures, of HOL theories@type structures, of \HOL{} theories} chiamata la struttura di tipo di ${\cal T}$; \item ${\sf Sig}_{\cal T}$ una firma\index{signatures, della logica HOL@signatures, della logica \HOL{}!of HOL theories@of \HOL{} theories} @@ -340,29 +340,29 @@ \section{Teorie \HOL{}} chiamati gli assiomi\index{assiomi, in una teoria HOL@assiomi, in una teoria \HOL{}} di ${\cal T}$; -\item ${\sf Theorems}_{\cal T}$ un insieme di sequenti su -${\sf Sig}_{\cal T}$ chiamati i teoremi +\item ${\sf Theorems}_{\cal T}$ un insieme di sequenti su +${\sf Sig}_{\cal T}$ chiamati i teoremi % \index{theorems, nella logica HOL@theorems, nella logica \HOL{}!forma astratta di} % -di ${\cal T}$, con -la propriet che ogni membro segue da ${\sf Axioms}_{\cal T}$ per +di ${\cal T}$, con +la propriet che ogni membro segue da ${\sf Axioms}_{\cal T}$ per il sistema deduttivo \HOL{}. \end{myenumerate} -Gli insiemi ${\sf Types}_{\cal T}$ e ${\sf Terms}_{\cal T}$ dei tipi e -dei termini di una teoria ${\cal T}$ sono, rispettivamente, gli insiemi dei tipi e +Gli insiemi ${\sf Types}_{\cal T}$ e ${\sf Terms}_{\cal T}$ dei tipi e +dei termini di una teoria ${\cal T}$ sono, rispettivamente, gli insiemi dei tipi e dei termini costruibili dalla struttura di tipo e dalla firma di ${\cal T}$, cio: \begin{eqnarray*} {\sf Types}_{\cal T} & = & {\sf Types}_{{\sf Struc}_{\cal T}}\\ {\sf Terms}_{\cal T} & = & {\sf Terms}_{{\sf Sig}_{\cal T}} \end{eqnarray*} -Un modello di una teoria $\cal T$ specificato dando un modello (standard) -$M$ della sottostante firma della teoria con la propriet che -$M$ soddisfa tutti i sequenti che sono assiomi di $\cal T$. A causa -del Teorema di Validit~\ref{soundness}, segue che $M$ soddisfa +Un modello di una teoria $\cal T$ specificato dando un modello (standard) +$M$ della sottostante firma della teoria con la propriet che +$M$ soddisfa tutti i sequenti che sono assiomi di $\cal T$. A causa +del Teorema di Validit~\ref{soundness}, segue che $M$ soddisfa anche qualunque sequente nell'insieme dei teoremi dati, ${\sf Theorems}_{\cal T}$. @@ -378,26 +378,26 @@ \subsection{La teoria {\tt MIN}} \hilbert_{(\alpha\fun\bool)\fun\alpha}\},\ \{\},\ \{\}\rangle \] -Dal momento che la teoria \theory{MIN} ha una firma che consiste solo di -elementi standard e non ha assiomi, essa possiede un unico modello standard, +Dal momento che la teoria \theory{MIN} ha una firma che consiste solo di +elementi standard e non ha assiomi, essa possiede un unico modello standard, che sar indicato con {\em Min}. -Bench la teoria \theory{MIN} contiene solo la sintassi standard -minimale, sfruttando i costrutti di ordine superiore di \HOL{} si pu -costruire su di essa una collezione di termini piuttosto ricca. La seguente -teoria introduce nomi per alcuni di questi termini che denotano utili +Bench la teoria \theory{MIN} contiene solo la sintassi standard +minimale, sfruttando i costrutti di ordine superiore di \HOL{} si pu +costruire su di essa una collezione di termini piuttosto ricca. La seguente +teoria introduce nomi per alcuni di questi termini che denotano utili operazioni logiche nel modello {\em Min}. -Nell'implementazione, alla teoria \theory{MIN} dato il nome -\theoryimp{min}, e contiene anche il distinto operatore di tipo +Nell'implementazione, alla teoria \theory{MIN} dato il nome +\theoryimp{min}, e contiene anche il distinto operatore di tipo binario $\fun$, per costruire spazi di funzione. \subsection{La teoria {\tt LOG}} \index{LOG@\ml{LOG}} \label{LOG} -La teoria \theory{LOG} ha la stessa struttura -di tipo di \theory{MIN}. La sua firma contiene le costanti in +La teoria \theory{LOG} ha la stessa struttura +di tipo di \theory{MIN}. La sua firma contiene le costanti in \theory{MIN}. e le seguenti costanti: \[ \T_\ty{bool} @@ -457,7 +457,7 @@ \subsection{La teoria {\tt LOG}} $t_1\ \vee\ t_2$ & $\vee\ t_1\ t_2$\\ \hline \end{tabular}\end{center} -Gli assiomi della teoria \theory{LOG} consistono dei seguenti +Gli assiomi della teoria \theory{LOG} consistono dei seguenti sequenti: \[ \begin{array}{l} @@ -490,25 +490,25 @@ \subsection{La teoria {\tt LOG}} Theorems}_{\theory{LOG}}$ considerato essere vuoto. Si noti che gli assiomi della teoria \theory{LOG} sono essenzialmente {\em -definizioni\/} delle nuove costanti di \theory{LOG} come termini nella -teoria originaria \theory{MIN}. (Il meccanismo per fare tali -estensioni alle teorie attraverso definizioni di nuove costanti sar riportato -in generale nella Sezione~\ref{defs}.) I primi sette assiomi definiscono le -costanti logiche per la verit, la quantificazione universale, la quantificazione -esistenziale, la falsit, la negazione, la congiunzione e la disgiunzione. -Bench queste definizioni possano essere oscure a qualche lettore, esse sono di -fatto definizioni standard di queste costanti logiche in termini di -implicazione, uguaglianza e scelta all'interno della logica di ordine superiore. I -due assiomi successivi definiscono le propriet di una funzione di essere iniettiva e suriettiva; -esse saranno usate per esprimere l'assioma dell'infinito (si veda -la Sezione~\ref{INIT}), tra le altre cose. L'ultimo assioma definisce una +definizioni\/} delle nuove costanti di \theory{LOG} come termini nella +teoria originaria \theory{MIN}. (Il meccanismo per fare tali +estensioni alle teorie attraverso definizioni di nuove costanti sar riportato +in generale nella Sezione~\ref{defs}.) I primi sette assiomi definiscono le +costanti logiche per la verit, la quantificazione universale, la quantificazione +esistenziale, la falsit, la negazione, la congiunzione e la disgiunzione. +Bench queste definizioni possano essere oscure a qualche lettore, esse sono di +fatto definizioni standard di queste costanti logiche in termini di +implicazione, uguaglianza e scelta all'interno della logica di ordine superiore. I +due assiomi successivi definiscono le propriet di una funzione di essere iniettiva e suriettiva; +esse saranno usate per esprimere l'assioma dell'infinito (si veda +la Sezione~\ref{INIT}), tra le altre cose. L'ultimo assioma definisce una costante usata per le definizioni di tipo (si veda la Sezione~\ref{tydefs}). -L'unico modello standard {\em Min\/} di \theory{MIN} d origine a un -unico modello standard di -\theory{LOG}\index{LOG@\ml{LOG}!formal semantics of}. Questo -perch, data la semantica dei termini formulata nella -Sezione~\ref{semantics of terms}, per soddisfare le equazioni di sopra si +L'unico modello standard {\em Min\/} di \theory{MIN} d origine a un +unico modello standard di +\theory{LOG}\index{LOG@\ml{LOG}!formal semantics of}. Questo +perch, data la semantica dei termini formulata nella +Sezione~\ref{semantics of terms}, per soddisfare le equazioni di sopra si costretti ad interpretare le nuove costanti nel modo seguente: \index{assiomi!semantica formale degli assiomi della logic HOL@semantica formale degli assiomi della logic \HOL{}|(} \begin{itemize} @@ -592,9 +592,9 @@ \subsection{La teoria {\tt LOG}} \] \end{itemize} \index{assiomi!semantica formale degli assiomi della logic HOL@semantica formale degli assiomi della logic \HOL{}|)} -Dal momento che queste definizioni sono state ottenute applicando la semantica dei -termini ai lati sinistri dell'equazioni che formano gli assiomi di -\theory{LOG}, questi assiomi sono soddisfatti e si ottiene un modello della +Dal momento che queste definizioni sono state ottenute applicando la semantica dei +termini ai lati sinistri dell'equazioni che formano gli assiomi di +\theory{LOG}, questi assiomi sono soddisfatti e si ottiene un modello della teoria \theory{LOG}. @@ -602,7 +602,7 @@ \subsection{La teoria {\tt INIT}} \label{INIT} La teoria \theory{INIT}\index{INIT@\ml{INIT}!forma astratta di} si -ottiene aggiungendo i seguenti quattro assiomi\index{assiomi!della logica HOL@della logica \HOL{}} alla teoria +ottiene aggiungendo i seguenti quattro assiomi\index{assiomi!della logica HOL@della logica \HOL{}} alla teoria \theory{LOG}. \[ \index{BOOL_CASES_AX@\ml{BOOL\_CASES\_AX}!forma astratta di} @@ -626,49 +626,49 @@ \subsection{La teoria {\tt INIT}} \end{array} \] -L'unico modello standard di \theory{LOG} soddisfa questi quattro assiomi -e di conseguenza l'unico modello standard della teoria -\theory{INIT}.\index{INIT@\ml{INIT}!formal semantics of} (Per l'assioma -{\small\tt SELECT\_AX} necessario usare la definizione di -$\den{\hilbert}$ data nella Sezione~\ref{standard-signatures}; per l'assioma -{\small\tt INFINITY\_AX} ncessario il fatto che $\den{\ind}=\inds$ +L'unico modello standard di \theory{LOG} soddisfa questi quattro assiomi +e di conseguenza l'unico modello standard della teoria +\theory{INIT}.\index{INIT@\ml{INIT}!formal semantics of} (Per l'assioma +{\small\tt SELECT\_AX} necessario usare la definizione di +$\den{\hilbert}$ data nella Sezione~\ref{standard-signatures}; per l'assioma +{\small\tt INFINITY\_AX} ncessario il fatto che $\den{\ind}=\inds$ un insieme infinito.) La teoria \theory{INIT} la teoria iniziale\index{initial theory, - della logica HOL@initial theory, della logica \HOL{}!forma astratta di} della -logica \HOL{}. Una teoria che estende \theory{INIT} sar chiamata una + della logica HOL@initial theory, della logica \HOL{}!forma astratta di} della +logica \HOL{}. Una teoria che estende \theory{INIT} sar chiamata una {\em teoria standard}\index{teoria standard}. \subsection{Implementare le teorie \texttt{LOG} e \texttt{INIT}} \label{sec:implementing-log-init} L'implementazione combina le teorie \theory{LOG} e -\theory{INIT} in una teoria \theoryimp{bool}. Essa include tutte le -costanti e gli assiomi da queste teorie, e include un numero di -risultati derivati circa queste costanti. Per maggiori informazioni sulla +\theory{INIT} in una teoria \theoryimp{bool}. Essa include tutte le +costanti e gli assiomi da queste teorie, e include un numero di +risultati derivati circa queste costanti. Per maggiori informazioni sulla teoria \theoryimp{bool} d'implementazione, si veda \DESCRIPTION. \subsection{Coerenza} \label{consistency} -Una teoria (standard) {\em coerente\/}\index{teoria coerente} se -non il caso che ogni sequente nella sua firma possa essere -derivato dagli assiomi della teoria usando la logica \HOL{}, o +Una teoria (standard) {\em coerente\/}\index{teoria coerente} se +non il caso che ogni sequente nella sua firma possa essere +derivato dagli assiomi della teoria usando la logica \HOL{}, o in modo equivalente, se non pu essere derivato in questo modo il particolare sequente $\turn\F$. -L'esistenza di un modello (standard) di una teoria sufficiente per -stabilire la sua coerenza. Perch per il Teorema -di Validit~\ref{soundness}, qualsiasi sequente che possa essere derivato dagli -assiomi della teoria sar soddisfatto dal modello, mentre il sequente -$\turn\F$ non mai soddisfatto in alcun modello. Cos in particolare, +L'esistenza di un modello (standard) di una teoria sufficiente per +stabilire la sua coerenza. Perch per il Teorema +di Validit~\ref{soundness}, qualsiasi sequente che possa essere derivato dagli +assiomi della teoria sar soddisfatto dal modello, mentre il sequente +$\turn\F$ non mai soddisfatto in alcun modello. Cos in particolare, la teoria iniziale \theory{INIT} coerente. -Tuttavia, possibile che una teoria sia coerente ma non -possieda un modello standard. Questo avviene perch la nozione di un -modello {\em standard\/} piuttosto restrittiva---in particolare non c' alcuna -scelta su come interpretare gli interi e la loro aritmetica in un tale -modello. Il famoso teorema di incompletezza di G\"odel assicura che ci -sono sequenti che sono soddisfatti in tutti i modelli standard (cio che sono +Tuttavia, possibile che una teoria sia coerente ma non +possieda un modello standard. Questo avviene perch la nozione di un +modello {\em standard\/} piuttosto restrittiva---in particolare non c' alcuna +scelta su come interpretare gli interi e la loro aritmetica in un tale +modello. Il famoso teorema di incompletezza di G\"odel assicura che ci +sono sequenti che sono soddisfatti in tutti i modelli standard (cio che sono `veri'), ma che non sono dimostrabili nella logica \HOL{}. @@ -687,22 +687,22 @@ \section{Estensioni di teorie} \item ${\sf Axioms}_{{\cal T}}\subseteq{\sf Axioms}_{{\cal T}'}$. \item ${\sf Theorems}_{{\cal T}}\subseteq{\sf Theorems}_{{\cal T}'}$. \end{myenumerate} -In questo caso, qualsiasi modello $M'$ della teoria pi grande ${\cal T}'$ pu essere -ristretto a un modello della teoria pi piccola $\cal T$ nel modo -seguente. Primo, $M'$ d origine a un modello della struttura e della firma -di $\cal T$ semplicemente dimenticando i valori di $M'$ alle costanti che non sono -in ${\sf Struc}_{\cal T}$ or ${\sf Sig}_{\cal T}$. Indicando questo modello +In questo caso, qualsiasi modello $M'$ della teoria pi grande ${\cal T}'$ pu essere +ristretto a un modello della teoria pi piccola $\cal T$ nel modo +seguente. Primo, $M'$ d origine a un modello della struttura e della firma +di $\cal T$ semplicemente dimenticando i valori di $M'$ alle costanti che non sono +in ${\sf Struc}_{\cal T}$ or ${\sf Sig}_{\cal T}$. Indicando questo modello con $M$, si ha che per ogni $\sigma\in{\sf Types}_{\cal T}$, $t\in{\sf Terms}_{\cal T}$ e per tutti i contesti adatti che \begin{eqnarray*} \den{\alpha\!s.\sigma}_{M} & = & \den{\alpha\!s.\sigma}_{M'} \\ \den{\alpha\!s,\!x\!s.t}_{M} & = & \den{\alpha\!s,\!x\!s.t}_{M'}. \end{eqnarray*} -Di conseguenza se $(\Gamma,t)$ un sequente su ${\sf Sig}_{\cal T}$ +Di conseguenza se $(\Gamma,t)$ un sequente su ${\sf Sig}_{\cal T}$ (e di conseguenza anche su ${\sf Sig}_{{\cal T}'}$), allora $\Gamma \models_{M} t$ se e solo se $\Gamma \models_{M'} t$. Dal momento che ${\sf -Axioms}_{\cal T}\subseteq{\sf Axioms}_{{\cal T}'}$ e $M'$ un modello -di ${\cal T}'$, segue che $M$ un modello di $\cal T$. $M$ sar +Axioms}_{\cal T}\subseteq{\sf Axioms}_{{\cal T}'}$ e $M'$ un modello +di ${\cal T}'$, segue che $M$ un modello di $\cal T$. $M$ sar chiamata la {\em restrizione}\index{restrictions, of models} del modello $M'$ della teoria ${\cal T}'$ alla sotto-teoria $\cal T$. @@ -713,14 +713,14 @@ \section{Estensioni di teorie} \item Estensione attraverso la specifica di una costante (si veda la Sezione~\ref{specs}). -\item Estensione attraverso la specifica di un tipo (si veda la -Sezione~\ref{tyspecs}).\footnote{Questo meccanismo di estensione di teorie non +\item Estensione attraverso la specifica di un tipo (si veda la +Sezione~\ref{tyspecs}).\footnote{Questo meccanismo di estensione di teorie non implementato nel sistema \HOL{}4.} \end{itemize} -Il primo meccanismo permette la `specifica libera' di costanti (come nella -notazione {\bf Z}~\cite{Z}, per esempio); la seconda permette di -introdurre nuovi tipi e operatori di tipo. Come casi speciali (quando la +Il primo meccanismo permette la `specifica libera' di costanti (come nella +notazione {\bf Z}~\cite{Z}, per esempio); la seconda permette di +introdurre nuovi tipi e operatori di tipo. Come casi speciali (quando la cosa che si sta definendo univocamente determinata) si hanno anche: \begin{itemize} @@ -729,24 +729,24 @@ \section{Estensioni di teorie} \item Estensione attraverso la definizione di un tipo (si veda la Sezione~\ref{tydefs}). \end{itemize} -Questi meccanismi sono descritti nelle seguenti sezioni. Essi producono -tutti delle {\it estensioni definizionali\/} nel senso che essi estendono -una teoria aggiungendo delle nuove costanti e dei nuovi tipi che sono definiti in termini -di propriet di quelli esistenti. La loro propriet chiave che la -teoria estesa possiede un modello (standard) se la teoria originale -lo ha. Cos garantito che una serie di queste estensioni che iniziano dalla teoria -\theory{INIT} risulter in una teoria con un modello -standard, e di conseguenza in una teoria coerente. E' anche possibile estendere -teorie semplicemente aggiungendo nuove costanti e tipi non interpretati. Questo -preserva la coerenza, ma difficilmente sar utile senza assiomi -addizionali. Tuttavia, quando si aggiungono arbitrariamente nuovi -assiomi\index{assiomi!non necessit di aggiungere}, non c' alcuna garanzia -che la coerenza sia preservata. I vantaggi della postulazione rispetto -alla definizione sono stati paragonati da Bertrand Russell ai vantaggi del +Questi meccanismi sono descritti nelle seguenti sezioni. Essi producono +tutti delle {\it estensioni definizionali\/} nel senso che essi estendono +una teoria aggiungendo delle nuove costanti e dei nuovi tipi che sono definiti in termini +di propriet di quelli esistenti. La loro propriet chiave che la +teoria estesa possiede un modello (standard) se la teoria originale +lo ha. Cos garantito che una serie di queste estensioni che iniziano dalla teoria +\theory{INIT} risulter in una teoria con un modello +standard, e di conseguenza in una teoria coerente. E' anche possibile estendere +teorie semplicemente aggiungendo nuove costanti e tipi non interpretati. Questo +preserva la coerenza, ma difficilmente sar utile senza assiomi +addizionali. Tuttavia, quando si aggiungono arbitrariamente nuovi +assiomi\index{assiomi!non necessit di aggiungere}, non c' alcuna garanzia +che la coerenza sia preservata. I vantaggi della postulazione rispetto +alla definizione sono stati paragonati da Bertrand Russell ai vantaggi del furto rispetto al lavoro onesto\footnote{Si veda la pagina 71 del libro di Russel {\sl -Introduction to Mathematical Philosophy\/}}. Dal momento che sin troppo facile -introdurre assiomatizzazioni incoerenti, gli utenti del sistema \HOL{} sono -caldamente invitati a resistere alla tentazione di aggiungere assiomi, ma di lavorare +Introduction to Mathematical Philosophy\/}}. Dal momento che sin troppo facile +introdurre assiomatizzazioni incoerenti, gli utenti del sistema \HOL{} sono +caldamente invitati a resistere alla tentazione di aggiungere assiomi, ma di lavorare onestamente attraverso teorie definizionali. @@ -756,8 +756,8 @@ \subsection{Estensione per definizione di costanti} \index{extension, della logica HOL@extension, della logica \HOL{}!by constant definition|(} \label{defs} -Una {\it definizione di costante\/}\index{definizione di costante} su una -firma $\Sigma_{\Omega}$ una formula della forma +Una {\it definizione di costante\/}\index{definizione di costante} su una +firma $\Sigma_{\Omega}$ una formula della forma $\con{c}_{\sigma} = t_{\sigma}$, tale che: \begin{myenumerate} @@ -789,9 +789,9 @@ \subsection{Estensione per definizione di costanti} \end{array} \] -Si noti che il meccanismo di estensione per definizione di costante gi -stato usato implicitamente nel formare la teoria \theory{LOG} dalla -teoria \theory{MIN} nella Sezione~\ref{LOG}. Cos con la notazione +Si noti che il meccanismo di estensione per definizione di costante gi +stato usato implicitamente nel formare la teoria \theory{LOG} dalla +teoria \theory{MIN} nella Sezione~\ref{LOG}. Cos con la notazione di questa sezione si ha \[ \theory{LOG}\; =\; \theory{MIN}\;\begin{array}[t]{@{}l} @@ -820,42 +820,42 @@ \subsection{Estensione per definizione di costanti} \end{array}\end{array} \] -Se $\cal T$ possiede un modello standard allora lo ha anche l'estensione -${\cal T}{+_{\it def}}\langle\con{c}_{\sigma}=t_{\sigma}\rangle$. Questo -sar dimostrato come un corollario del corrispondente risultato nella\linebreak -Sezione~\ref{specs} mostrando che l'estensione per definizione di costante - di fatto un caso speciale di estensione per specifica di costante. -(Questa riduzione richiede che si stia trattando con teorie -{\em standard\/} nel senso della sezione~\ref{INIT}, dal momento che bench -la quantificazione esistenziale non sia necessaria per le definizioni di costanti, +Se $\cal T$ possiede un modello standard allora lo ha anche l'estensione +${\cal T}{+_{\it def}}\langle\con{c}_{\sigma}=t_{\sigma}\rangle$. Questo +sar dimostrato come un corollario del corrispondente risultato nella\linebreak +Sezione~\ref{specs} mostrando che l'estensione per definizione di costante + di fatto un caso speciale di estensione per specifica di costante. +(Questa riduzione richiede che si stia trattando con teorie +{\em standard\/} nel senso della sezione~\ref{INIT}, dal momento che bench +la quantificazione esistenziale non sia necessaria per le definizioni di costanti, necessaria per formulare il meccanismo di specifica di costante.) \medskip -\noindent{\bf Nota\ } La condizione (iii) nella definizione di -ci che costituisce una definizione di costante corretta una restrizione -importante senza la quale la coerenza non potrebbe essere garantita. Per vedere +\noindent{\bf Nota\ } La condizione (iii) nella definizione di +ci che costituisce una definizione di costante corretta una restrizione +importante senza la quale la coerenza non potrebbe essere garantita. Per vedere questo, consideriamo il termine $\equant{f_{\alpha\fun\alpha}} \OneOne \ f -\conj \neg(\Onto \ f)$, che esprime la proposizione che il (l'insieme -di elementi denotati dal) tipo $\alpha$ infinito. Il termine contiene +\conj \neg(\Onto \ f)$, che esprime la proposizione che il (l'insieme +di elementi denotati dal) tipo $\alpha$ infinito. Il termine contiene la variabile di tipo $\alpha$, mentre il tipo del termine, $\ty{bool}$, no. Cos per (iii) \[ \con{c}_\ty{bool} = \equant{f_{\alpha\fun\alpha}} \OneOne \ f \conj \neg(\Onto \ f) \] -non permessa come definizione di una costante. Il problema che il -significato del lato destro della definizione varia con $\alpha$, -mentre il significato della costante sul lato sinistro fissato, -dal momento che non contiene $\alpha$. Di fatto, se ci fosse permesso di -estendere la teoria coerente $\theory{INIT}$ con questa definizione, il -risultato darebbe una teoria incoerente. Perch istanziare $\alpha$ a -$\ty{ind}$ nel lato destro risulta in un termine che dimostrabile -dagli assiomi di $\theory{INIT}$, e di conseguenza $\con{c}_\ty{bool}=\T$ +non permessa come definizione di una costante. Il problema che il +significato del lato destro della definizione varia con $\alpha$, +mentre il significato della costante sul lato sinistro fissato, +dal momento che non contiene $\alpha$. Di fatto, se ci fosse permesso di +estendere la teoria coerente $\theory{INIT}$ con questa definizione, il +risultato darebbe una teoria incoerente. Perch istanziare $\alpha$ a +$\ty{ind}$ nel lato destro risulta in un termine che dimostrabile +dagli assiomi di $\theory{INIT}$, e di conseguenza $\con{c}_\ty{bool}=\T$ dimostrabile nella teoria estesa. Ma ugualmente, istanziare $\alpha$ -a $\ty{bool}$ rende la negazione del lato destro dimostrabile -dagli assiomi di $\theory{INIT}$, e di conseguenza anche $\con{c}_\ty{bool}=\F$ -dimostrabile nella teoria estesa. Combinando questi teoremi, si +a $\ty{bool}$ rende la negazione del lato destro dimostrabile +dagli assiomi di $\theory{INIT}$, e di conseguenza anche $\con{c}_\ty{bool}=\F$ +dimostrabile nella teoria estesa. Combinando questi teoremi, si ha che $\T=\F$, cio $\F$ dimostrabile nella teoria estesa. \index{extension, della logica HOL@extension, della logica \HOL{}!by constant definition|)} @@ -864,39 +864,39 @@ \subsection{Estensione per specifica di costante} \label{specs} Le specifiche di costanti\index{constant specification extension, della logica HOL@constant specification extension, della logica \HOL{}!abstract form -of} introducono costanti (o insiemi di costanti) -che soddisfano propriet (coerenti) arbitrariamente date. Per esempio, una -teoria potrebbe essere estesa da una specifica di costante in modo da avere due nuove -costanti $\con{b}_1$ e $\con{b}_2$ di tipo \ty{bool} tali che -$\neg(\con{b}_1=\con{b}_2)$. Questa specifica non definisce -in modo univoco $\con{b}_1$ e $\con{b}_2$, dal momento che soddisfatta sia da -$\con{b}_1=\T$ e $\con{b}_2=\F$, sia da $\con{b}_1=\F$ e -$\con{b}_2=\T$. Per assicurare che tali specifiche sono -coerenti\index{consistency, della logica HOL@consistency, della logica \HOL{}!under constant specification}, esse possono essere fatte solo se -gi stato dimostrato che le propriet che le nuove costanti devono -avere sono coerenti. Questo impedisce, per esempio, di introdurre tre -costanti booleane $\con{b}_1$, $\con{b}_2$ e $\con{b}_3$ tali che +of} introducono costanti (o insiemi di costanti) +che soddisfano propriet (coerenti) arbitrariamente date. Per esempio, una +teoria potrebbe essere estesa da una specifica di costante in modo da avere due nuove +costanti $\con{b}_1$ e $\con{b}_2$ di tipo \ty{bool} tali che +$\neg(\con{b}_1=\con{b}_2)$. Questa specifica non definisce +in modo univoco $\con{b}_1$ e $\con{b}_2$, dal momento che soddisfatta sia da +$\con{b}_1=\T$ e $\con{b}_2=\F$, sia da $\con{b}_1=\F$ e +$\con{b}_2=\T$. Per assicurare che tali specifiche sono +coerenti\index{consistency, della logica HOL@consistency, della logica \HOL{}!under constant specification}, esse possono essere fatte solo se +gi stato dimostrato che le propriet che le nuove costanti devono +avere sono coerenti. Questo impedisce, per esempio, di introdurre tre +costanti booleane $\con{b}_1$, $\con{b}_2$ e $\con{b}_3$ tali che $\con{b}_1\neq \con{b}_2$, $\con{b}_1\neq \con{b}_3$ e $\con{b}_2\neq \con{b}_3$. -Supponiamo che $\equant{x_1\cdots x_n}t$ sia una formula, con $x_1,\ldots, x_n$ -variabili distinte. Se $\turn \equant{x_1 \cdots x_n}t$, allora una +Supponiamo che $\equant{x_1\cdots x_n}t$ sia una formula, con $x_1,\ldots, x_n$ +variabili distinte. Se $\turn \equant{x_1 \cdots x_n}t$, allora una specifica di costante permette di introdurre le nuove costanti $\con{c}_1$, $\ldots$ , $\con{c}_n$ che soddisfano: \[ \turn t[\con{c}_1,\cdots,\con{c}_n/x_1,\cdots,x_n] \] -dove $t[\con{c}_1,\cdots,\con{c}_n/x_1,\cdots,x_n]$ denota il -risultato di sostituire simultaneamente $\con{c}_1, \ldots, \con{c}_n$ -per $x_1, \ldots, x_n$ rispettivamente. Naturalmente il tipo di ciascuna -costante $\con{c}_i$ deve essere lo stesso del tipo della corrispondente -variabile $x_i$. Per assicurare che questo meccanismo di estensione preserva la -propriet di possedere un modello, imposto su questi tipi un ulteriore -requisito pi tecnico: essi devono contenere ciascuno tutte le variabili -di tipo che occorrono in $t$. Questa condizione discussa ulteriormente nella +dove $t[\con{c}_1,\cdots,\con{c}_n/x_1,\cdots,x_n]$ denota il +risultato di sostituire simultaneamente $\con{c}_1, \ldots, \con{c}_n$ +per $x_1, \ldots, x_n$ rispettivamente. Naturalmente il tipo di ciascuna +costante $\con{c}_i$ deve essere lo stesso del tipo della corrispondente +variabile $x_i$. Per assicurare che questo meccanismo di estensione preserva la +propriet di possedere un modello, imposto su questi tipi un ulteriore +requisito pi tecnico: essi devono contenere ciascuno tutte le variabili +di tipo che occorrono in $t$. Questa condizione discussa ulteriormente nella Sezione~\ref{constants} di sotto. -Formalmente, una {\em specifica di costante\/}\index{constant specification} +Formalmente, una {\em specifica di costante\/}\index{constant specification} per una teoria ${\cal T}$ data da \medskip @@ -910,7 +910,7 @@ \subsection{Estensione per specifica di costante} \begin{myenumerate} \item -$\con{c}_1,\ldots,\con{c}_n$ sono nomi distinti che +$\con{c}_1,\ldots,\con{c}_n$ sono nomi distinti che non sono i nomi di alcuna costante in ${\sf Sig}_{\cal T}$. \item @@ -925,7 +925,7 @@ \subsection{Estensione per specifica di costante} \ \in\ {\sf Theorems}_{\cal T}$. \end{myenumerate} -L'estensione di una teoria standard ${\cal T}$ per mezzo di una tale specifica +L'estensione di una teoria standard ${\cal T}$ per mezzo di una tale specifica di costante denotata da \[ {\cal T}{+_{\it spec}}\langle(\con{c}_1,\ldots,\con{c}_n), @@ -955,20 +955,20 @@ \subsection{Estensione per specifica di costante} \medskip \noindent{\bf Dimostrazione\ } -Supponiamo che $M$ sia un modello standard di ${\cal T}$. Sia -$\alpha\!s=\alpha_{1},\ldots,\alpha_{m}$ la lista di variabili di tipo -distinte che occorrono nella formula $t$. Allora $\alpha\!s,\!x\!s.t$ un -termine-in-contesto, dove $x\!s=x_{1},\ldots,x_{n}$. (Cambiando ogni variabile -legata in $t$ in modo da renderle distinte da $x\!s$ se necessario.) -Interpretando questo termine-in-contesto nel modello $M$ si ottiene +Supponiamo che $M$ sia un modello standard di ${\cal T}$. Sia +$\alpha\!s=\alpha_{1},\ldots,\alpha_{m}$ la lista di variabili di tipo +distinte che occorrono nella formula $t$. Allora $\alpha\!s,\!x\!s.t$ un +termine-in-contesto, dove $x\!s=x_{1},\ldots,x_{n}$. (Cambiando ogni variabile +legata in $t$ in modo da renderle distinte da $x\!s$ se necessario.) +Interpretando questo termine-in-contesto nel modello $M$ si ottiene \[ \den{\alpha\!s,\!x\!s.t}_{M} \in \prod_{X\!s\in{\cal U}^{m}} \left(\prod_{i=1}^{n}\den{\alpha\!s.\sigma_{i}}_{M}(X\!s)\right) \fun \two \] -Ora $\equant{x\!s}t$ in ${\sf Theorems}_{\cal T}$ e di conseguenza per il -Teorema di Validit \ref{soundness}\index{consistency, della logica HOL@consistency, della logica \HOL{}!under constant specification} questo -sequente soddisfatto da $M$. Usando la semantica di $\exists$ data nella +Ora $\equant{x\!s}t$ in ${\sf Theorems}_{\cal T}$ e di conseguenza per il +Teorema di Validit \ref{soundness}\index{consistency, della logica HOL@consistency, della logica \HOL{}!under constant specification} questo +sequente soddisfatto da $M$. Usando la semantica di $\exists$ data nella Sezione~\ref{LOG}, questo significa che per ogni $X\!s\in{\cal U}^{m}$ l'insieme \[ @@ -976,48 +976,48 @@ \subsection{Estensione per specifica di costante} \den{\alpha\!s.\sigma_{n}}_{M}(X\!s)\; : \; \den{\alpha\!s,\!x\!s.t}_{M}(X\!s)(y\!s)=1 \} \] -non vuoto. Dal momento che anche un sottoinsieme di un prodotto finito di insiemi in -$\cal U$, ne segue che un elemento di $\cal U$ (usando le propriet -{\bf Sub} e {\bf Prod} dell'universo). Cos si pu applicare la funzione +non vuoto. Dal momento che anche un sottoinsieme di un prodotto finito di insiemi in +$\cal U$, ne segue che un elemento di $\cal U$ (usando le propriet +{\bf Sub} e {\bf Prod} dell'universo). Cos si pu applicare la funzione di scelta globale $\ch\in\prod_{X\in{\cal U}}X$ per selezionare un elemento specifico. \[ (s_{1}(X\!s),\ldots,s_{n}(X\!s)) = \ch(S(X\!s)) \in \prod_{i=1}^{n}\den{\alpha\!s.\sigma_{i}}_{M}(X\!s) \] -per il quale $\den{\alpha\!s,\!x\!s.t}_{M}(X\!s)$ prende il valore $1$. Estendiamo +per il quale $\den{\alpha\!s,\!x\!s.t}_{M}(X\!s)$ prende il valore $1$. Estendiamo $M$ a un modello $M'$ della firma di ${\cal T}{+_{\it spec}}\langle(\con{c}_1,\ldots,\con{c}_n), \lquant{{x_1}_{\sigma_1},\ldots,{x_n}_{\sigma_n}}t_{\ty{bool}} -\rangle$ definendo che il suo valore per -ogni nuova costante $(\con{c}_{i},\sigma_{i})$ sia +\rangle$ definendo che il suo valore per +ogni nuova costante $(\con{c}_{i},\sigma_{i})$ sia \[ M'(\con{c}_{i},\sigma_{i}) = s_{i} \in \prod_{X\!s\in{\cal U}^{m}}\den{\sigma_{i}}_{M}(X\!s) . \] -Si noti che la Condizione (iii) nella definizione di una specifica -di costante assicura che $\alpha\!s$ il contesto canonico di ogni -tipo $\sigma_{i}$, cos che -$\den{\sigma_{i}}=\den{\alpha\!s.\sigma_{i}}$ e quindi $s_{i}$ +Si noti che la Condizione (iii) nella definizione di una specifica +di costante assicura che $\alpha\!s$ il contesto canonico di ogni +tipo $\sigma_{i}$, cos che +$\den{\sigma_{i}}=\den{\alpha\!s.\sigma_{i}}$ e quindi $s_{i}$ di fatto un elemento del prodotto di sopra. Dal momento che $t$ un termine della sotto-teoria $\cal T$ di \linebreak${\cal T}{+_{\it spec}}\langle(\con{c}_1,\ldots,\con{c}_n), \lquant{{x_1}_{\sigma_1},\ldots,{x_n}_{\sigma_n}}t_{\ty{bool}} -\rangle$, -come notato all'inizio della Sezione~\ref{extensions}, si ha che -$\den{\alpha\!s,\!x\!s.t}_{M'} = \den{\alpha\!s,\!x\!s.t}_{M}$. Di conseguenza per +\rangle$, +come notato all'inizio della Sezione~\ref{extensions}, si ha che +$\den{\alpha\!s,\!x\!s.t}_{M'} = \den{\alpha\!s,\!x\!s.t}_{M}$. Di conseguenza per la definizione degli $s_{i}$, per tutti gli $X\!s\in{\cal U}^{m}$ \[ \den{\alpha\!s,\!x\!s.t}_{M'}(X\!s)(s_{1}(X\!s),\ldots,s_{n}(X\!s)) = 1 \] -Quindi usando il Lemma~4 nella -Sezione~\ref{term-substitution} sulla semantica della sostituzione insieme con -la definizione di $\den{\con{c}_{i}}_{M'}$, si ottiene infine che +Quindi usando il Lemma~4 nella +Sezione~\ref{term-substitution} sulla semantica della sostituzione insieme con +la definizione di $\den{\con{c}_{i}}_{M'}$, si ottiene infine che per tutti gli $X\!s\in{\cal U}^{m}$ \[ \den{t[\con{c}_{1},\ldots,\con{c}_{n}/x_{1},\ldots,x_{n}]}_{M'}(X\!s)=1 \] -o in altre parole che $M'$ soddisfa +o in altre parole che $M'$ soddisfa $t[\con{c}_{1},\ldots,\con{c}_{n}/x_{1},\ldots,x_{n}]$. Quindi $M'$ un modello di ${\cal T}{+_{\it spec}}\langle(\con{c}_1,\ldots,\con{c}_n), @@ -1026,95 +1026,95 @@ \subsection{Estensione per specifica di costante} \medskip -Le costanti che sono affermate esistere in una specifica di costante -non sono necessariamente determinate in modo univoco. In modo corrispondente, ci possono +Le costanti che sono affermate esistere in una specifica di costante +non sono necessariamente determinate in modo univoco. In modo corrispondente, ci possono essere pi modelli differenti di ${\cal T}{+_{\it spec}}\langle(\con{c}_1,\ldots,\con{c}_n), \lquant{{x_1}_{\sigma_1},\ldots,{x_n}_{\sigma_n}}t_{\ty{bool}} -\rangle$ la cui restrizione a $\cal T$ $M$; la costruzione di sopra -produce un tale modello in una maniera uniforme facendo uso della funzione +\rangle$ la cui restrizione a $\cal T$ $M$; la costruzione di sopra +produce un tale modello in una maniera uniforme facendo uso della funzione di scelta globale sull'universo. -L'estensione per mezzo di una definizione di costante, $\con{c}_\sigma=t_\sigma$, un -caso speciale di estensione per specifica di costante. Perch sia $t'$ -la formula $x_\sigma=t_\sigma$, dove $x_\sigma$ una variabile che non +L'estensione per mezzo di una definizione di costante, $\con{c}_\sigma=t_\sigma$, un +caso speciale di estensione per specifica di costante. Perch sia $t'$ +la formula $x_\sigma=t_\sigma$, dove $x_\sigma$ una variabile che non occorre in $t_\sigma$. Allora chiaramente $\turn -\equant{x_\sigma}t'$ e si pu applicare il metodo della specifica +\equant{x_\sigma}t'$ e si pu applicare il metodo della specifica di costante per ottenere la teoria \[ {\cal T}{+_{\it spec}}\langle \con{c},\lquant{x_\sigma}t'\rangle \] -Ma dal momento che $t'[\con{c}_\sigma/x_\sigma]$ semplicemente +Ma dal momento che $t'[\con{c}_\sigma/x_\sigma]$ semplicemente $\con{c}_\sigma=t_\sigma$, questa estensione porta esattamente a ${\cal T}{+_{\it def}}\langle \con{c}_{\sigma}=t_{\sigma}\rangle$. -Cos come corollario della Proposizione, si ha che per ogni modello +Cos come corollario della Proposizione, si ha che per ogni modello standard $M$ di $\cal T$, c' un modello standard $M'$ di ${\cal -T}{+_{\it def}}\langle\con{c}_{\sigma}=t_{\sigma}\rangle$ la cui -restrizione a $\cal T$ $M$. In contrasto con il caso delle specifiche -di costante, $M'$ determinato in modo univoco da $M$ e dalla definizione di +T}{+_{\it def}}\langle\con{c}_{\sigma}=t_{\sigma}\rangle$ la cui +restrizione a $\cal T$ $M$. In contrasto con il caso delle specifiche +di costante, $M'$ determinato in modo univoco da $M$ e dalla definizione di costante \index{extension, della logica HOL@extension, della logica \HOL{}!by constant specification|)} \subsection{Note circa le costanti in \HOL{}} \label{constants} -Si noti come la Condizione (iii) nella definizione di una specifica di costante -sia stata necessaria nella dimostrazione che il meccanismo di estensione preserva la -propriet di possedere un modello standard. Il suo ruolo di assicurare che -le costanti introdotte abbiano, attraverso i loro tipi, la stessa dipendenza dalle -variabili di tipo che ha la formula che le specifica. La -situazione la stessa di quella discussa nella Nota nella -Sezione~\ref{defs}. In un senso, ci che causava il problema -nell'esempio dato in quella Nota non tanto il metodo di estensione per mezzo -dell'introduzione di costanti, ma piuttosto la sintassi di \HOL{} che non -permette alle costanti di dipendere esplicitamente dalle variabili di tipo (nel modo -in cui lo fanno gli operatori di tipo). Cos nell'esempio si vorrebbe -introdurre una costante `polimorfica' $\con{c}_\ty{bool}(\alpha)$ -che dipende esplicitamente da $\alpha$, e definirla essere +Si noti come la Condizione (iii) nella definizione di una specifica di costante +sia stata necessaria nella dimostrazione che il meccanismo di estensione preserva la +propriet di possedere un modello standard. Il suo ruolo di assicurare che +le costanti introdotte abbiano, attraverso i loro tipi, la stessa dipendenza dalle +variabili di tipo che ha la formula che le specifica. La +situazione la stessa di quella discussa nella Nota nella +Sezione~\ref{defs}. In un senso, ci che causava il problema +nell'esempio dato in quella Nota non tanto il metodo di estensione per mezzo +dell'introduzione di costanti, ma piuttosto la sintassi di \HOL{} che non +permette alle costanti di dipendere esplicitamente dalle variabili di tipo (nel modo +in cui lo fanno gli operatori di tipo). Cos nell'esempio si vorrebbe +introdurre una costante `polimorfica' $\con{c}_\ty{bool}(\alpha)$ +che dipende esplicitamente da $\alpha$, e definirla essere $\equant{f_{\alpha\fun\alpha}} \OneOne \ f \conj -\neg(\Onto \ f)$. Allora nella teoria estesa si potrebbe derivare -$\con{c}_\ty{bool}(\ty{ind})=\T$ e -$\con{c}_\ty{bool}(\ty{bool})=\F$, ma ora non risulta alcuna contraddizione dal momento che -$\con{c}_\ty{bool}(\ty{ind})$ e $\con{c}_\ty{bool}(\ty{bool})$ +\neg(\Onto \ f)$. Allora nella teoria estesa si potrebbe derivare +$\con{c}_\ty{bool}(\ty{ind})=\T$ e +$\con{c}_\ty{bool}(\ty{bool})=\F$, ma ora non risulta alcuna contraddizione dal momento che +$\con{c}_\ty{bool}(\ty{ind})$ e $\con{c}_\ty{bool}(\ty{bool})$ sono differenti. Nella versione attuale di \HOL, le costanti sono coppie-(nome,tipo). -Si potrebbe immaginare una leggera estensione della sintassi di \HOL{} con -costanti `polimorfiche', specificate da coppie -$(\con{c},\alpha\!s.\sigma)$ dove ora $\alpha\!s.\sigma$ un -tipo-in-contesto e la lista $\alpha\!s$ pu ben contenere variabili di tipo -extra che non occorrono in $\sigma$. Una tale coppia darebbe origine -al particolare termine costante -$\con{c}_\sigma(\alpha\!s)$, e pi in generale ai -termini costanti $\con{c}_{\sigma'}(\tau\!s)$ ottenuti da -questo istanziando le variabili di tipo $\alpha_i$ con i tipi -$\tau_i$ (cos $\sigma'$ l'istanza di $\sigma$ ottenuta -sostituendo $\tau\!s$ per $\alpha\!s$). Questa nuova sintassi di costanti -polimorfiche paragonabile alla sintassi esistente dei tipi composti (si veda -la sezione~\ref{types}): un operatore di tipo $n$-ario $\textsl{op}$ da origine a un -tipo composto $(\alpha_1,\ldots,\alpha_n){\textsl{op}}$ che dipende da $n$ -variabili di tipo. Analogamente, la sintassi di sopra delle costanti polimorfiche +Si potrebbe immaginare una leggera estensione della sintassi di \HOL{} con +costanti `polimorfiche', specificate da coppie +$(\con{c},\alpha\!s.\sigma)$ dove ora $\alpha\!s.\sigma$ un +tipo-in-contesto e la lista $\alpha\!s$ pu ben contenere variabili di tipo +extra che non occorrono in $\sigma$. Una tale coppia darebbe origine +al particolare termine costante +$\con{c}_\sigma(\alpha\!s)$, e pi in generale ai +termini costanti $\con{c}_{\sigma'}(\tau\!s)$ ottenuti da +questo istanziando le variabili di tipo $\alpha_i$ con i tipi +$\tau_i$ (cos $\sigma'$ l'istanza di $\sigma$ ottenuta +sostituendo $\tau\!s$ per $\alpha\!s$). Questa nuova sintassi di costanti +polimorfiche paragonabile alla sintassi esistente dei tipi composti (si veda +la sezione~\ref{types}): un operatore di tipo $n$-ario $\textsl{op}$ da origine a un +tipo composto $(\alpha_1,\ldots,\alpha_n){\textsl{op}}$ che dipende da $n$ +variabili di tipo. Analogamente, la sintassi di sopra delle costanti polimorfiche registra come esse dipendono dalle variabili di tipo (as well as which generic type the constant has). -Tuttavia, registrare esplicitamente la dipendenza delle costanti dalle variabili di tipo -da origine a una sintassi ingombrante che in pratica si preferirebbe -evitare laddove possibile. E' possibile evitarlo se il contesto -di tipo $\alpha\!s$ in $(\con{c},\alpha\!s.\sigma)$ di fatto il -contesto {\em canonico\/} di $\sigma$, cio contiene esattamente le variabili -di tipo di $\sigma$. Perch allora si pu applicare il Lemma~1 della -Sezione~\ref{instances-and-substitution} per dedurre che la -costante polimorfica $\con{c}_{\sigma'}(\tau\!s)$ pu essere abbreviata -alla costante ordinaria $\con{c}_{\sigma'}$ senza ambiguit---l'informazione -mancante $\tau\!s$ pu essere ricostruita da $\sigma'$ e -dall'informazione circa la costante $\con{c}$ data nella firma. -Da questo prospettiva, il lato piuttosto tecnico delle Condizioni (iii) nelle -Sezioni~\ref{defs} e \ref{specs} diventano molto meno misteriose: -esse precisamente assicurano che nell'introdurre nuove costanti si stia sempre -trattando solo con i contesti canonici, e cos si possano usare costanti ordinarie -piuttosto che quelle polimorfiche senza ambiguit. In questo modo si evita -di complicare la sintassi esistente al costo di restringere +Tuttavia, registrare esplicitamente la dipendenza delle costanti dalle variabili di tipo +da origine a una sintassi ingombrante che in pratica si preferirebbe +evitare laddove possibile. E' possibile evitarlo se il contesto +di tipo $\alpha\!s$ in $(\con{c},\alpha\!s.\sigma)$ di fatto il +contesto {\em canonico\/} di $\sigma$, cio contiene esattamente le variabili +di tipo di $\sigma$. Perch allora si pu applicare il Lemma~1 della +Sezione~\ref{instances-and-substitution} per dedurre che la +costante polimorfica $\con{c}_{\sigma'}(\tau\!s)$ pu essere abbreviata +alla costante ordinaria $\con{c}_{\sigma'}$ senza ambiguit---l'informazione +mancante $\tau\!s$ pu essere ricostruita da $\sigma'$ e +dall'informazione circa la costante $\con{c}$ data nella firma. +Da questo prospettiva, il lato piuttosto tecnico delle Condizioni (iii) nelle +Sezioni~\ref{defs} e \ref{specs} diventano molto meno misteriose: +esse precisamente assicurano che nell'introdurre nuove costanti si stia sempre +trattando solo con i contesti canonici, e cos si possano usare costanti ordinarie +piuttosto che quelle polimorfiche senza ambiguit. In questo modo si evita +di complicare la sintassi esistente al costo di restringere in qualche modo l'applicabilit di questi meccanismi di estensioni delle teorie. @@ -1123,48 +1123,48 @@ \subsection{Estensione per definizione di tipo} \index{representing types, nella logica HOL@representing types, nella logica \HOL{}!forma astratta di|(} \label{tydefs} -Ogni tipo (monomorfico) $\sigma$ nella teoria iniziale \theory{INIT} -determina un insieme\linebreak $\den{\sigma}$ nell'universo $\cal U$. Tuttavia, -ci sono molti pi insiemi in $\cal U$ dei tipi che sono in -\theory{INIT}. In particolare, mentre $\cal U$ chiuso rispetto -all'operazione di prendere un sottoinsieme non-vuoto di $\den{\sigma}$, non c' -alcun meccanismo corrispondente per formare un `sottotipo' di $\sigma$. Piuttosto, -i sottoinsiemi sono denotati indirettamente attraverso funzioni caratteristiche, per mezzo delle quali un -termine chiuso $p$ di tipo $\sigma\fun\ty{bool}$ determina il sottoinsieme -$\{x\in\den{\sigma} : \den{p}(x)=1\}$ (che un insieme nell'universo -purch non sia vuoto). Tuttavia, utile avere un -meccanismo per introdurre nuovi tipi che sono sottotipi di quelli -esistenti. Tali tipi sono definiti\index{extension, della logica HOL@extension, della logica \HOL{}!by type definition} in \HOL{} introducendo una nuova costante -di tipo e asserendo un assioma che la caratterizza denotare un -insieme in biezione (cio in corrispondenza uno-a-uno) con un sottoinsieme -non-vuoto di un tipo esistente (chiamato il {\em tipo rappresentante\/}). -Per esempio, il tipo \ml{num} definito essere uguale a un sottoinsieme -numerabile del tipo \ml{ind}, che garantito esistere dall'assioma +Ogni tipo (monomorfico) $\sigma$ nella teoria iniziale \theory{INIT} +determina un insieme\linebreak $\den{\sigma}$ nell'universo $\cal U$. Tuttavia, +ci sono molti pi insiemi in $\cal U$ dei tipi che sono in +\theory{INIT}. In particolare, mentre $\cal U$ chiuso rispetto +all'operazione di prendere un sottoinsieme non-vuoto di $\den{\sigma}$, non c' +alcun meccanismo corrispondente per formare un `sottotipo' di $\sigma$. Piuttosto, +i sottoinsiemi sono denotati indirettamente attraverso funzioni caratteristiche, per mezzo delle quali un +termine chiuso $p$ di tipo $\sigma\fun\ty{bool}$ determina il sottoinsieme +$\{x\in\den{\sigma} : \den{p}(x)=1\}$ (che un insieme nell'universo +purch non sia vuoto). Tuttavia, utile avere un +meccanismo per introdurre nuovi tipi che sono sottotipi di quelli +esistenti. Tali tipi sono definiti\index{extension, della logica HOL@extension, della logica \HOL{}!by type definition} in \HOL{} introducendo una nuova costante +di tipo e asserendo un assioma che la caratterizza denotare un +insieme in biezione (cio in corrispondenza uno-a-uno) con un sottoinsieme +non-vuoto di un tipo esistente (chiamato il {\em tipo rappresentante\/}). +Per esempio, il tipo \ml{num} definito essere uguale a un sottoinsieme +numerabile del tipo \ml{ind}, che garantito esistere dall'assioma {\small\tt INFINITY\_AX} (si veda la Sezione~\ref{INIT}). -Cos come definire tipi, anche conveniente essere in grado di definire -operatori di tipo. Un esempio sarebbe un operatore di tipo \ty{inj} che -mappasse un insieme all'insieme di funzioni uno-a-uno (cio iniettive) su -di esso. Il sottoinsieme di $\sigma\fun\sigma$ che rappresenta $(\sigma)\ty{inj}$ -sarebbe definito dal predicato \OneOne. Un altro esempio sarebbe un -operatore di tipo per il prodotto cartesiano binario \ty{prod}. Questo definito -scegliendo un tipo rappresentante che contiene due variabili di tipo, diciamo -$\sigma[\alpha_1;\alpha_2]$, tale che per ogni tipo $\sigma_1$ e -$\sigma_2$, un sottoinsieme di $\sigma[\sigma_1;\sigma_2]$ rappresenta il -prodotto cartesiano di $\sigma_1$ e $\sigma_2$. I dettagli di una tale -definizione sono dati nella sezione di \DESCRIPTION\/ sulla teoria dei +Cos come definire tipi, anche conveniente essere in grado di definire +operatori di tipo. Un esempio sarebbe un operatore di tipo \ty{inj} che +mappasse un insieme all'insieme di funzioni uno-a-uno (cio iniettive) su +di esso. Il sottoinsieme di $\sigma\fun\sigma$ che rappresenta $(\sigma)\ty{inj}$ +sarebbe definito dal predicato \OneOne. Un altro esempio sarebbe un +operatore di tipo per il prodotto cartesiano binario \ty{prod}. Questo definito +scegliendo un tipo rappresentante che contiene due variabili di tipo, diciamo +$\sigma[\alpha_1;\alpha_2]$, tale che per ogni tipo $\sigma_1$ e +$\sigma_2$, un sottoinsieme di $\sigma[\sigma_1;\sigma_2]$ rappresenta il +prodotto cartesiano di $\sigma_1$ e $\sigma_2$. I dettagli di una tale +definizione sono dati nella sezione di \DESCRIPTION\/ sulla teoria dei prodotti cartesiani. -I tipi in \HOL{} devono denotare insiemi non-vuoti. Cos -coerente\index{consistency, della logica HOL@consistency, della logica \HOL{}!under type definition} definire un nuovo tipo isomorfo a un -sottoinsieme specificato da un predicato $p$, solo se c' almeno una cosa -per cui $p$ vale, cio $\turn\equant{x}p\ x$. Per esempio, -sarebbe incoerente definire un operatore di tipo binario \ty{iso} tale -che $(\sigma_1,\sigma_2)\ty{iso}$ denotasse l'insieme di funzioni -uno-a-uno da $\sigma_1$ {\em onto\/} $\sigma_2$ perch per qualche -valore di $\sigma_1$ e $\sigma_2$ l'insieme sarebbe vuoto; per -esempio $(\ty{ind},\ty{bool})\ty{iso}$ denoterebbe l'insieme vuoto. Per -evitare questo, una precondizione di definire un nuovo tipo che il +I tipi in \HOL{} devono denotare insiemi non-vuoti. Cos +coerente\index{consistency, della logica HOL@consistency, della logica \HOL{}!under type definition} definire un nuovo tipo isomorfo a un +sottoinsieme specificato da un predicato $p$, solo se c' almeno una cosa +per cui $p$ vale, cio $\turn\equant{x}p\ x$. Per esempio, +sarebbe incoerente definire un operatore di tipo binario \ty{iso} tale +che $(\sigma_1,\sigma_2)\ty{iso}$ denotasse l'insieme di funzioni +uno-a-uno da $\sigma_1$ {\em onto\/} $\sigma_2$ perch per qualche +valore di $\sigma_1$ e $\sigma_2$ l'insieme sarebbe vuoto; per +esempio $(\ty{ind},\ty{bool})\ty{iso}$ denoterebbe l'insieme vuoto. Per +evitare questo, una precondizione di definire un nuovo tipo che il sottoinsieme rappresentante non sia vuoto. Riassumendo, un nuovo tipo definito: @@ -1180,36 +1180,36 @@ \subsection{Estensione per definizione di tipo} \begin{enumerate} \item Specificare un tipo-in-contesto, $\alpha_1,\ldots,\alpha_n.\sigma$ diciamo. -Il tipo -$\sigma$ chiamato il {\it tipo rappresentante\/}, e il tipo -$(\alpha_1,\ldots,\alpha_n)\ty{op}$ inteso essere isomorfo a un +Il tipo +$\sigma$ chiamato il {\it tipo rappresentante\/}, e il tipo +$(\alpha_1,\ldots,\alpha_n)\ty{op}$ inteso essere isomorfo a un sottoinsieme di $\sigma$. \item -Specificare un termine-in-contesto chiuso, $\alpha_1,\ldots,\alpha_n,.p$ -diciamo, di tipo $\sigma\fun\bool$. Il termine $p$ chiamato la {\it -funzione caratteristica\/}\index{characteristic function, of type definitions}. Questo definisce il sottoinsieme di $\sigma$ al quale -$(\alpha_1,\ldots,\alpha_n)\ty{op}$ deve essere isomorfo\footnote{La -ragione per richiedere che $p$ sia chiuso, cio non abbia variabili -libere, che altrimenti per coerenza l'operatore di tipo definito -dovrebbe {\em dipendere\/} da (cio essere una funzione di) queste +Specificare un termine-in-contesto chiuso, $\alpha_1,\ldots,\alpha_n,.p$ +diciamo, di tipo $\sigma\fun\bool$. Il termine $p$ chiamato la {\it +funzione caratteristica\/}\index{characteristic function, of type definitions}. Questo definisce il sottoinsieme di $\sigma$ al quale +$(\alpha_1,\ldots,\alpha_n)\ty{op}$ deve essere isomorfo\footnote{La +ragione per richiedere che $p$ sia chiuso, cio non abbia variabili +libere, che altrimenti per coerenza l'operatore di tipo definito +dovrebbe {\em dipendere\/} da (cio essere una funzione di) queste variabili. Tali tipi dipendenti non fanno (ancora!) parte del sistema \HOL{}}. \item Dimostrare $\turn \equant{x_{\sigma}} p\ x$. \item -Asserire un assioma che dice che $(\alpha_1,\ldots,\alpha_n)\ty{op}$ +Asserire un assioma che dice che $(\alpha_1,\ldots,\alpha_n)\ty{op}$ isomorfo al sottoinsieme di $\sigma$ selezionato da $p$. \end{enumerate} -Per rendere questo formale, la teoria \theory{LOG} fornisce +Per rendere questo formale, la teoria \theory{LOG} fornisce la costante polimorfica \TyDef\ definita nella Sezione~\ref{LOG}. -La formula +La formula $\equant{f_{(\alpha_1,\ldots,\alpha_n)\ty{op}\fun\sigma}}\TyDef\ p\ f$ -asserisce che -esiste una funzione uno-a uno $f$ da $(\alpha_1,\ldots,\alpha_n)\ty{op}$ +asserisce che +esiste una funzione uno-a uno $f$ da $(\alpha_1,\ldots,\alpha_n)\ty{op}$ al sottoinsieme di elementi di $\sigma$ per cui $p$ vero. Di conseguenza, l'assioma che caratterizza $(\alpha_1,\ldots,\alpha_n)\ty{op}$ : \[ @@ -1217,9 +1217,9 @@ \subsection{Estensione per definizione di tipo} p\ f \] -Definire un nuovo tipo $(\alpha_1,\ldots,\alpha_n)\ty{op}$ in una teoria -${\cal T}$ cos consiste nell'introdurre $\ty{op}$ come un nuovo -operatore di tipo $n$-ario e l'assioma di sopra come un nuovo assioma. Formalmente, una {\em +Definire un nuovo tipo $(\alpha_1,\ldots,\alpha_n)\ty{op}$ in una teoria +${\cal T}$ cos consiste nell'introdurre $\ty{op}$ come un nuovo +operatore di tipo $n$-ario e l'assioma di sopra come un nuovo assioma. Formalmente, una {\em definizione di tipo\/}\index{type definitions, nella logica HOL@type definitions, nella logica \HOL{}!abstract structure of} per una teoria ${\cal T}$ data da @@ -1248,7 +1248,7 @@ \subsection{Estensione per definizione di tipo} $\equant{x_{\sigma}}p\ x \ \in\ {\sf Theorems}_{\cal T}$. \end{myenumerate} -L'estensione di una teoria standard ${\cal T}$ per mezzo di una tale definizione di tipo +L'estensione di una teoria standard ${\cal T}$ per mezzo di una tale definizione di tipo denotata da \[ {\cal @@ -1271,12 +1271,12 @@ \subsection{Estensione per definizione di tipo} \noindent{\bf Proposizione\ }{\em La teoria ${\cal T}{+_{\it -tydef}}\langle(\alpha_1,\ldots,\alpha_n)\ty{op},\sigma,p\rangle$ ha un +tydef}}\langle(\alpha_1,\ldots,\alpha_n)\ty{op},\sigma,p\rangle$ ha un modello standard se la teoria ${\cal T}$ lo ha.} \medskip -Al posto di dare una dimostrazione diretta di questo risultato, esso sar dedotto come +Al posto di dare una dimostrazione diretta di questo risultato, esso sar dedotto come corollario della proposizione corrispondente nella prossima sezione. \index{extension, della logica HOL@extension, della logica \HOL{}!by type definition|)} \index{representing types, nella logica HOL@representing types, nella logica \HOL{}!forma astratta di|)} @@ -1286,68 +1286,68 @@ \subsection{Estensione per specifica di tipo} \index{extension, della logica HOL@extension, della logica \HOL{}!by type specification|(} \label{tyspecs} \noindent -(\textbf{Nota:} Questo meccanismo di estensione \emph{non} -implementato nel sistema HOL4. Fu proposto da T.~Melham e +(\textbf{Nota:} Questo meccanismo di estensione \emph{non} +implementato nel sistema HOL4. Fu proposto da T.~Melham e raffina una proposta di R.~Jones e R.~Arthan.) \smallskip -\noindent Il meccanismo di definizione di -tipo permette d'introdurre nuovi tipi dando una concreta -rappresentazione del tipo come un `sottotipo' di un tipo esistente. Si -potrebbe invece desiderare d'introdurre un nuovo tipo che soddisfa qualche propriet -senza dare un'esplicita rappresentazione per il tipo. Per -esempio, si potrebbe volere estendere \theory{INIT} con un tipo atomico +\noindent Il meccanismo di definizione di +tipo permette d'introdurre nuovi tipi dando una concreta +rappresentazione del tipo come un `sottotipo' di un tipo esistente. Si +potrebbe invece desiderare d'introdurre un nuovo tipo che soddisfa qualche propriet +senza dare un'esplicita rappresentazione per il tipo. Per +esempio, si potrebbe volere estendere \theory{INIT} con un tipo atomico $\ty{one}$ che soddisfa $\turn\uquant{f_{\alpha\fun\ty{one}}\ - g_{\alpha\fun\ty{one}}}f=g$ senza scegliere un tipo specifico in -$\theory{INIT}$ e dicendo che $\ty{one}$ in biezione con un -suo sottoinsieme di un elemento. (L'idea quella che la scelta del -tipo rappresentante irrilevante per le propriet di $\ty{one}$ che -possono essere espresse in \HOL.) Il meccanismo descritto in questa sezione -fornisce un modo di ottenere questo preservando allo stesso tempo -la propriet fondamentale di possedere un modello standard e quindi + g_{\alpha\fun\ty{one}}}f=g$ senza scegliere un tipo specifico in +$\theory{INIT}$ e dicendo che $\ty{one}$ in biezione con un +suo sottoinsieme di un elemento. (L'idea quella che la scelta del +tipo rappresentante irrilevante per le propriet di $\ty{one}$ che +possono essere espresse in \HOL.) Il meccanismo descritto in questa sezione +fornisce un modo di ottenere questo preservando allo stesso tempo +la propriet fondamentale di possedere un modello standard e quindi di mantenere la coerenza. -Ogni formula chiusa $q$ che coinvolge una singola variabile di tipo $\alpha$ pu -essere pensata come se specificasse una propriet $q[\tau/\alpha]$ dei tipi +Ogni formula chiusa $q$ che coinvolge una singola variabile di tipo $\alpha$ pu +essere pensata come se specificasse una propriet $q[\tau/\alpha]$ dei tipi $\tau$. La sua interpretazione in un modello della forma \[ \den{\alpha,.q}\in \prod_{X\in{\cal U}}\den{\alpha.\bool}(X) \;= \prod_{X\in{\cal U}}\two \;=\; {\cal U}\fun\two \] -che una funzione caratteristica sull'universo, che determina un -sottoinsieme $\{X\in{\cal U}:\den{\alpha,.q}(X)=1\}$ che consiste di quegli -insiemi nell'universo per cui vale la propriet $q$. Il modo -pi generale per assicurare la coerenza nell'introduzione di un nuovo tipo -atomico $\nu$ che soddisfa $q[\nu/\alpha]$ sarebbe dimostrare -`$\equant{\alpha}q$'. Tuttavia, una tale -formula con la quantificazione sui tipi non \footnote{ancora!} parte della -logica \HOL{} e si potrebbe procedere in modo indiretto---sostituendo la -formula con una (logicamente pi debole) che pu essere espressa formalmente con +che una funzione caratteristica sull'universo, che determina un +sottoinsieme $\{X\in{\cal U}:\den{\alpha,.q}(X)=1\}$ che consiste di quegli +insiemi nell'universo per cui vale la propriet $q$. Il modo +pi generale per assicurare la coerenza nell'introduzione di un nuovo tipo +atomico $\nu$ che soddisfa $q[\nu/\alpha]$ sarebbe dimostrare +`$\equant{\alpha}q$'. Tuttavia, una tale +formula con la quantificazione sui tipi non \footnote{ancora!} parte della +logica \HOL{} e si potrebbe procedere in modo indiretto---sostituendo la +formula con una (logicamente pi debole) che pu essere espressa formalmente con la sintassi \HOL{}. La formula usata \[ (\equant{f_{\alpha\fun\sigma}}{\sf Type\_Definition}\ p\ f)\ \imp\ q \] -dove $\sigma$ un tipo, $p_{\sigma\fun\ty{bool}}$ un termine chiuso -e non coinvolge la variabile di tipo $\alpha$. Questa formula dice `$q$ -vale di qualsiasi tipo che in biezione con il sottotipo di $\sigma$ -determinato da $p$'. Se questa formula dimostrabile e il sottotipo non +dove $\sigma$ un tipo, $p_{\sigma\fun\ty{bool}}$ un termine chiuso +e non coinvolge la variabile di tipo $\alpha$. Questa formula dice `$q$ +vale di qualsiasi tipo che in biezione con il sottotipo di $\sigma$ +determinato da $p$'. Se questa formula dimostrabile e il sottotipo non vuoto, cio se \[ \equant{x_\sigma}p\ x \] - dimostrabile, allora coerente introdurre un'estensione con un nuovo + dimostrabile, allora coerente introdurre un'estensione con un nuovo tipo atomico $\nu$ che soddisfa $q[\nu/\alpha]$. -Nel dare la definizione formale di questo meccanismo di estensione, saranno -fatti due raffinamenti. Per prima cosa, a $\sigma$ permesso essere -polimorfico e di conseguenza introdotta una nuova costante di ripo di ariet -appropriata, piuttosto che semplicemente un tipo atomico. In secondo luogo, alle formule -esistenziali di sopra permesso di essere dimostrate (nella teoria che deve essere -estesa) da qualche ipotesi\footnote{Questo raffinamento accresce -l'applicabilit del meccanismo di estensione senza accrescere il suo -potere espressivo. Avremmo potuto fare un raffinamento simile per l'altro -meccanismo di estensione di teoria.}. Cos una {\em specifica -di tipo\/}\index{specifica di tipo} per una teoria $\cal T$ +Nel dare la definizione formale di questo meccanismo di estensione, saranno +fatti due raffinamenti. Per prima cosa, a $\sigma$ permesso essere +polimorfico e di conseguenza introdotta una nuova costante di ripo di ariet +appropriata, piuttosto che semplicemente un tipo atomico. In secondo luogo, alle formule +esistenziali di sopra permesso di essere dimostrate (nella teoria che deve essere +estesa) da qualche ipotesi\footnote{Questo raffinamento accresce +l'applicabilit del meccanismo di estensione senza accrescere il suo +potere espressivo. Avremmo potuto fare un raffinamento simile per l'altro +meccanismo di estensione di teoria.}. Cos una {\em specifica +di tipo\/}\index{specifica di tipo} per una teoria $\cal T$ data da \medskip @@ -1365,13 +1365,13 @@ \subsection{Estensione per specifica di tipo} ${\sf Struc}_{\cal T}$. \item -$\alpha_1,\ldots,\alpha_n.\sigma$ un tipo-in-contesto con +$\alpha_1,\ldots,\alpha_n.\sigma$ un tipo-in-contesto con $\sigma\in{\sf Types}_{\cal T}$. \item $p_{\sigma\fun\bool}$ un termine chiuso in ${\sf Terms}_{\cal T}$ le cui variabili di tipo occorrono in $\alpha\!s=\alpha_1,\ldots,\alpha_n$. -\item $\alpha$ una variabile di tipo distinta da quelle in +\item $\alpha$ una variabile di tipo distinta da quelle in $\alpha\!s$. \item $\Gamma$ una lista di formule chiuse in ${\sf Terms}_{\cal T}$ @@ -1388,7 +1388,7 @@ \subsection{Estensione per specifica di tipo} sono in ${\sf Theorems}_{\cal T}$. \end{myenumerate} -L'estensione di una teoria standard $\cal T$ per mezzo di una tale specifica +L'estensione di una teoria standard $\cal T$ per mezzo di una tale specifica di tipo denotata \[ {\cal T}{+_{\it tyspec}} \langle @@ -1406,27 +1406,27 @@ \subsection{Estensione per specifica di tipo} \end{array} \] -\noindent{\bf Esempio\ } Per eseguire l'estensione di \theory{INIT} +\noindent{\bf Esempio\ } Per eseguire l'estensione di \theory{INIT} mensionata all'inizio di questa sezione, si forma \[ \theory{INIT}{+_{\it tyspec}} \langle ()\ty{one},\ty{bool},p,\alpha,\emptyset,q\rangle \] -dove $p$ il termine $\lquant{b_\bool}b$ e $q$ la formula -$\uquant{f_{\beta\fun\alpha}\ g_{\beta\fun\alpha}}f=g$. Cos il -risultato una teoria che estende \theory{INIT} con una -nuova costante di tipo $\ty{one}$ che soddisfa l'assioma +dove $p$ il termine $\lquant{b_\bool}b$ e $q$ la formula +$\uquant{f_{\beta\fun\alpha}\ g_{\beta\fun\alpha}}f=g$. Cos il +risultato una teoria che estende \theory{INIT} con una +nuova costante di tipo $\ty{one}$ che soddisfa l'assioma $\uquant{f_{\beta\fun\ty{one}}\ g_{\beta\fun\ty{one}}}f=g$. -Per verificare che questa un'applicazione corretta del meccanismo -di estensione, si devono controllare le Condizioni da (i) a (vii) di sopra. Solo l'ultima -non banale: essa impone l'obbligo di dimostrare -due sequenti dagli assiomi di \theory{INIT}. Il primo sequente dice -che $p$ definisce un sottoinsieme abitato di $\bool$, il che certamente -vero dal momento che $\T$ testimonia questo fatto. Il secondo sequente dice -in effetti che qualsiasi tipo $\alpha$ che sia in biezione con il sottoinsieme di -$\bool$ definito da $p$ ha la propriet che c' al massimo una -funzione ad esso da qualsiasi tipo dato $\beta$; la dimostrazione di questo dagli +Per verificare che questa un'applicazione corretta del meccanismo +di estensione, si devono controllare le Condizioni da (i) a (vii) di sopra. Solo l'ultima +non banale: essa impone l'obbligo di dimostrare +due sequenti dagli assiomi di \theory{INIT}. Il primo sequente dice +che $p$ definisce un sottoinsieme abitato di $\bool$, il che certamente +vero dal momento che $\T$ testimonia questo fatto. Il secondo sequente dice +in effetti che qualsiasi tipo $\alpha$ che sia in biezione con il sottoinsieme di +$\bool$ definito da $p$ ha la propriet che c' al massimo una +funzione ad esso da qualsiasi tipo dato $\beta$; la dimostrazione di questo dagli assiomi di \theory{INIT} lasciata come esercizio. \medskip @@ -1439,13 +1439,13 @@ \subsection{Estensione per specifica di tipo} \medskip \noindent{\bf Dimostrazione\ } -Scriviamo $\alpha\!s$ per $\alpha_1,\ldots,\alpha_n$, e supponiamo che -$\alpha\!s'={\alpha'}_1,\ldots,{\alpha'}_m$ sia la lista delle variabili -di tipo che occorrono in $\Gamma$ e $q$, ma che non sono ancora nella lista +Scriviamo $\alpha\!s$ per $\alpha_1,\ldots,\alpha_n$, e supponiamo che +$\alpha\!s'={\alpha'}_1,\ldots,{\alpha'}_m$ sia la lista delle variabili +di tipo che occorrono in $\Gamma$ e $q$, ma che non sono ancora nella lista $\alpha\!s,\alpha$. -Supponiamo che $M$ sia un modello standard di ${\cal T}$. Dal momento che $\alpha\!s,.p$ -un termine-in-contesto di tipo $\sigma\fun\ty{bool}$, interpretarlo in +Supponiamo che $M$ sia un modello standard di ${\cal T}$. Dal momento che $\alpha\!s,.p$ +un termine-in-contesto di tipo $\sigma\fun\ty{bool}$, interpretarlo in $M$ porta a \[ \den{\alpha\!s,.p}_{M} @@ -1454,10 +1454,10 @@ \subsection{Estensione per specifica di tipo} \den{\alpha\!s.\sigma}_M(X\!s)\fun\two . \] -Non c' alcuna perdita di generalit nell'assumere che $\Gamma$ consista di -una singola formula $\gamma$. (Semplicemente rimpiazziamo $\Gamma$ con la congiunzione delle -formula che esso contiene, con la convenzione che questa congiunzione sia -$\T$ se $\Gamma$ vuoto.) Per l'assunzione su $\alpha\!s'$ e per la +Non c' alcuna perdita di generalit nell'assumere che $\Gamma$ consista di +una singola formula $\gamma$. (Semplicemente rimpiazziamo $\Gamma$ con la congiunzione delle +formula che esso contiene, con la convenzione che questa congiunzione sia +$\T$ se $\Gamma$ vuoto.) Per l'assunzione su $\alpha\!s'$ e per la Condizione~(iv), $\alpha\!s,\alpha\!s',.\gamma$ un termine-in-contesto. Interpretarlo in $M$ porta a \[ @@ -1467,22 +1467,22 @@ \subsection{Estensione per specifica di tipo} ={\cal U}^{n+m}\fun\two \] -Ora $(\gamma,\equant{x_{\sigma}}p\ x)$ in ${\sf Theorems}_{\cal T}$ -e di conseguenza per il Teorema di Validit~\ref{soundness} questo sequente -soddisfatto da $M$. Usando la semantica di $\exists$ data nella -Sezione~\ref{LOG} e la definizione di soddisfacimento di un sequente dalla -Sezione~\ref{sequents}, questo significa che per tutti gli $(X\!s,X\!s')\in{\cal U}^{n+m}$ -se $\den{\alpha\!s,\alpha\!s'.\gamma}_M(X\!s,X\!s')=1$, allora +Ora $(\gamma,\equant{x_{\sigma}}p\ x)$ in ${\sf Theorems}_{\cal T}$ +e di conseguenza per il Teorema di Validit~\ref{soundness} questo sequente +soddisfatto da $M$. Usando la semantica di $\exists$ data nella +Sezione~\ref{LOG} e la definizione di soddisfacimento di un sequente dalla +Sezione~\ref{sequents}, questo significa che per tutti gli $(X\!s,X\!s')\in{\cal U}^{n+m}$ +se $\den{\alpha\!s,\alpha\!s'.\gamma}_M(X\!s,X\!s')=1$, allora l'insieme \[ \{y\in\den{\alpha\!s.\sigma}_{M}\: :\: \den{\alpha\!s,.p}(X\!s)(y)=1\} \] -non vuoto. (Questo usa il fatto che $p$ non coinvolge -le variabili di tipo $\alpha\!s'$, cos per il Lemma~4 nella -Sezione~\ref{term-substitution} -$\den{\alpha\!s,\alpha\!s'.p}_M(X\!s,X\!s')=\den{\alpha\!s,.p}_M(X\!s)$.) -Dal momento che anche un sottoinsieme di un insieme in $\cal U$, esso -segue per la propriet {\bf Sub} dell'universo che questo insieme un elemento di +non vuoto. (Questo usa il fatto che $p$ non coinvolge +le variabili di tipo $\alpha\!s'$, cos per il Lemma~4 nella +Sezione~\ref{term-substitution} +$\den{\alpha\!s,\alpha\!s'.p}_M(X\!s,X\!s')=\den{\alpha\!s,.p}_M(X\!s)$.) +Dal momento che anche un sottoinsieme di un insieme in $\cal U$, esso +segue per la propriet {\bf Sub} dell'universo che questo insieme un elemento di $\cal U$. Cos definendo \[ S(X\!s) = \left\{\hspace{-1mm} @@ -1493,22 +1493,22 @@ \subsection{Estensione per specifica di tipo} \end{array} \right.%\} \] -si ha che $S$ una funzione ${\cal U}^n\fun{\cal U}$. Estendiamo $M$ -a un modello della firma di ${\cal T}'$ definendo che il suo valore alla -nuova costante di tipo $n$-aria $\ty{op}$ sia questa funzione $S$. Si noti -che i valori di $\sigma$, $p$, $\gamma$ e -$q$ in $M'$ sono gli stessi di quelli in $M$, dal momento che queste espressioni non +si ha che $S$ una funzione ${\cal U}^n\fun{\cal U}$. Estendiamo $M$ +a un modello della firma di ${\cal T}'$ definendo che il suo valore alla +nuova costante di tipo $n$-aria $\ty{op}$ sia questa funzione $S$. Si noti +che i valori di $\sigma$, $p$, $\gamma$ e +$q$ in $M'$ sono gli stessi di quelli in $M$, dal momento che queste espressioni non coinvolgono la nuova costante di tipo $\ty{op}$. -Per ogni $X\!s\in{\cal U}^{n}$ definiamo $i_{X\!s}$ essere la funzione +Per ogni $X\!s\in{\cal U}^{n}$ definiamo $i_{X\!s}$ essere la funzione d'inclusione per il sottoinsiem $S(X\!s)\subseteq\den{\alpha\!s.\sigma}_{M}$ -se $\den{\alpha\!s,\alpha\!s'.\gamma}_M(X\!s,X\!s')=1$ per qualche -$X\!s'$, e altrimenti essere la funzione +se $\den{\alpha\!s,\alpha\!s'.\gamma}_M(X\!s,X\!s')=1$ per qualche +$X\!s'$, e altrimenti essere la funzione $1\fun\den{\alpha\!s.\sigma}_{M}$ che manda $0\in 1$ in $\ch(\den{\alpha\!s.\sigma}_{M})$. Allora $i_{X\!s}\in(S(X\!s)\fun\den{\alpha\!s.\sigma}_{M'}(X\!s))$ poich -$\den{\alpha\!s.\sigma}_{M'}=\den{\alpha\!s.\sigma}_M$. Usando la -semantica di $\TyDef$ data nella Sezione~\ref{LOG}, si ha che per qualsiasi +$\den{\alpha\!s.\sigma}_{M'}=\den{\alpha\!s.\sigma}_M$. Usando la +semantica di $\TyDef$ data nella Sezione~\ref{LOG}, si ha che per qualsiasi $(X\!s,X\!s')\in{\cal U}^{n+m}$, se $\den{\alpha\!s,\alpha\!s'.\gamma}_{M'}(X\!s,X\!s')=1$ allora \[ @@ -1521,27 +1521,27 @@ \subsection{Estensione per specifica di tipo} \] Ma dal momento che il sequente $(\gamma,(\equant{f_{\alpha\fun\sigma}}{\sf Type\_Definition}\ p\ f)\ \imp\ q )$ in ${\sf Theorems}_{\cal T}$, - soddisfatto dal modello $M$ e di conseguenza anche dal modello $M'$ -(dal momento che il sequente non coinvolge la nuova costante di tipo $\ty{op}$). -Istanziando $\alpha$ a $(\alpha\!s)\ty{op}$ in questo sequente (cosa che - ammissibile dal momento che per la Condizione~(iv) $\alpha$ non occorre in + soddisfatto dal modello $M$ e di conseguenza anche dal modello $M'$ +(dal momento che il sequente non coinvolge la nuova costante di tipo $\ty{op}$). +Istanziando $\alpha$ a $(\alpha\!s)\ty{op}$ in questo sequente (cosa che + ammissibile dal momento che per la Condizione~(iv) $\alpha$ non occorre in $\gamma$), si ha che $M'$ soddisfa il sequente \[ (\gamma\ ,\ (\equant{f_{(\alpha\!s)\ty{op}\fun\sigma}}\TyDef\ p\ f)\imp q[(\alpha\!s)\ty{op}/\alpha]). \] -Applicando il Modus Ponens, si conclude che $M'$ soddisfa +Applicando il Modus Ponens, si conclude che $M'$ soddisfa $(\gamma\ ,\ q[(\alpha\!s)\ty{op}/\alpha])$ e quindi $M'$ un modello di ${\cal T}'$, come richiesto. \medskip -Un'estensione per definizione di tipo di fatto un caso speciale di estensione -per specifica di tipo. Per vedere questo, supponiamo che +Un'estensione per definizione di tipo di fatto un caso speciale di estensione +per specifica di tipo. Per vedere questo, supponiamo che $\langle (\alpha_1,\ldots,\alpha_n)\ty{op},\ \sigma,\ -p_{\sigma\fun\ty{bool}}\rangle$ sia una definizione di tipo per una teoria -$\cal T$. Scegliendo una variabile di tipo $\alpha$ differente da +p_{\sigma\fun\ty{bool}}\rangle$ sia una definizione di tipo per una teoria +$\cal T$. Scegliendo una variabile di tipo $\alpha$ differente da $\alpha_1,\ldots,\alpha_n$, $q$ denoti la formula \[ \equant{f_{\alpha\fun\sigma}}{\sf Type\_Definition}\ p\ f @@ -1549,7 +1549,7 @@ \subsection{Estensione per specifica di tipo} Allora $\langle (\alpha_1,\ldots,\alpha_n)\ty{op},\sigma,p,\alpha,\emptyset,q\rangle$ soddisfa tutte le condizioni necessarie per essere una specifica di tipo per -$\cal T$. Dal momento che $q[(\alpha_1,\ldots,\alpha_n)\ty{op}/\alpha]$ solo +$\cal T$. Dal momento che $q[(\alpha_1,\ldots,\alpha_n)\ty{op}/\alpha]$ solo $\equant{f_{(\alpha_1,\ldots,\alpha_n)\ty{op}\fun\sigma}}{\sf Type\_Definition}\ p\ f$, si ha che \[ @@ -1558,16 +1558,16 @@ \subsection{Estensione per specifica di tipo} ={\cal T}{+_{\it tyspec}} \langle(\alpha_1,\ldots,\alpha_n)\ty{op},\sigma,p,\alpha,\emptyset,q\rangle \] -Cos la Proposizione nella Sezione~\ref{tydefs} un caso speciale della +Cos la Proposizione nella Sezione~\ref{tydefs} un caso speciale della Proposizione di sopra. -In un'estensione per specifica di tipo, la propriet $q$ che -affermata della nuova costante di tipo introdotta non ha bisogno di determinare la -costante di tipo in modo univoco (persino fino alla biezione). In modo corrispondente ci -possono essere molti modelli standard differenti della nuova teoria estesa la -cui restrizione a $\cal T$ un dato modello $M$. Per contro, una definizione -di tipo determina la nuova costante di tipo in modo univoco fino alla biezione, -e due modelli qualsiasi della teoria estesa che si restringono allo stesso +In un'estensione per specifica di tipo, la propriet $q$ che +affermata della nuova costante di tipo introdotta non ha bisogno di determinare la +costante di tipo in modo univoco (persino fino alla biezione). In modo corrispondente ci +possono essere molti modelli standard differenti della nuova teoria estesa la +cui restrizione a $\cal T$ un dato modello $M$. Per contro, una definizione +di tipo determina la nuova costante di tipo in modo univoco fino alla biezione, +e due modelli qualsiasi della teoria estesa che si restringono allo stesso modello della teoria originaria saranno isomorfi. \index{extension, della logica HOL@extension, della logica \HOL{}!by type specification|)} diff --git a/Manual/Translations/IT/Logic/syntax.tex b/Manual/Translations/IT/Logic/syntax.tex index 25137df91b..f47f68d880 100644 --- a/Manual/Translations/IT/Logic/syntax.tex +++ b/Manual/Translations/IT/Logic/syntax.tex @@ -9,31 +9,31 @@ \chapter{Sintassi e Semantica}\label{logic} \section{Introduzione} \label{introduction} -Questo capitolo descrive la sintassi e la semantica a modelli della -logica supportata dal sistema \HOL{}, che una variante della -teoria dei tipi semplici di Church\index{Church, A.} \cite{Church} e -che sar d'ora in poi chiamata la logica \HOL{}, o semplicemente \HOL. Il -meta-linguaggio per questa descrizione sar l'Italiano, arricchito con -varie notazioni e convenzioni matematiche. Il liguaggio oggetto -di questa descrizione la logica \HOL{}. Si noti che c' un -`meta-linguaggio', in un senso differente, associato con la logica -\HOL\, cio il linguaggio di programmazione \ML. Questo il linguaggio usato -per manipolare la logica \HOL{} da parte degli utenti del sistema. Si spera -che in base al contesto, non risulti alcuna confusione da questi due usi della -parola `meta-linguaggio'. Quando l'oggetto dello studio l'\ML\ (come in -\cite{sml}), l'\ML\ il linguaggio oggetto considerato---e +Questo capitolo descrive la sintassi e la semantica a modelli della +logica supportata dal sistema \HOL{}, che una variante della +teoria dei tipi semplici di Church\index{Church, A.} \cite{Church} e +che sar d'ora in poi chiamata la logica \HOL{}, o semplicemente \HOL. Il +meta-linguaggio per questa descrizione sar l'Italiano, arricchito con +varie notazioni e convenzioni matematiche. Il liguaggio oggetto +di questa descrizione la logica \HOL{}. Si noti che c' un +`meta-linguaggio', in un senso differente, associato con la logica +\HOL\, cio il linguaggio di programmazione \ML. Questo il linguaggio usato +per manipolare la logica \HOL{} da parte degli utenti del sistema. Si spera +che in base al contesto, non risulti alcuna confusione da questi due usi della +parola `meta-linguaggio'. Quando l'oggetto dello studio l'\ML\ (come in +\cite{sml}), l'\ML\ il linguaggio oggetto considerato---e l'Italiano di nuovo il meta-linguaggio! -La sintassi di \HOL{} contiene categorie sintattiche di tipi e termini i cui -elementi sono intesi denotare rispettivamente certi insiemi e elementi -di insiemi. Questa interpretazione insiemistica sar sviluppata accanto alla -descrizione della sintassi di \HOL{}, e nel prossimo capitolo il sistema di dimostrazione -di \HOL\ sar mostrato essere valido per il ragionamento circa propriet -del modello insiemistico\footnote{Ci sono altri, modelli -`non standard' di \HOL, che non ci riguarderanno qui.}. Questo modello dato in -termini di un insieme di insiemi fisso $\cal U$, che sar chiamato l'{\em -universo\/}\index{universo, nella semantica della logica HOL@universo, nella -semantica della logica \HOL{}\/} e che si assume avere le seguenti +La sintassi di \HOL{} contiene categorie sintattiche di tipi e termini i cui +elementi sono intesi denotare rispettivamente certi insiemi e elementi +di insiemi. Questa interpretazione insiemistica sar sviluppata accanto alla +descrizione della sintassi di \HOL{}, e nel prossimo capitolo il sistema di dimostrazione +di \HOL\ sar mostrato essere valido per il ragionamento circa propriet +del modello insiemistico\footnote{Ci sono altri, modelli +`non standard' di \HOL, che non ci riguarderanno qui.}. Questo modello dato in +termini di un insieme di insiemi fisso $\cal U$, che sar chiamato l'{\em +universo\/}\index{universo, nella semantica della logica HOL@universo, nella +semantica della logica \HOL{}\/} e che si assume avere le seguenti propriet. \begin{description} @@ -43,9 +43,9 @@ \section{Introduzione} $Y\in{\cal U}$. \item[Prod] Se $X\in{\cal U}$ e $Y\in{\cal U}$, allora $X\times -Y\in{\cal U}$. L'insieme $X\times Y$ il prodotto cartesiano, -consistente di coppie ordinate $(x,y)$ con $x\in X$ e $y\in Y$, con -l'usuale notazione insiemistica delle coppie ordinate, cio +Y\in{\cal U}$. L'insieme $X\times Y$ il prodotto cartesiano, +consistente di coppie ordinate $(x,y)$ con $x\in X$ e $y\in Y$, con +l'usuale notazione insiemistica delle coppie ordinate, cio $(x,y)=\{\{x\},\{x,y\}\}$. \item[Pow] Se $X\in{\cal U}$, allora anche l'insieme potenza @@ -54,19 +54,19 @@ \section{Introduzione} \item[Infty] $\cal U$ contiene un distinto insieme infinito $\inds$. \item[Choice] C' un elemento distinto $\ch\in\prod_{X\in{\cal -U}}X$. Gli elementi del prodotto $\prod_{X\in{\cal U}}X$ sono -funzioni (dipendentemente tipizzate): cos per tutti gli $X\in{\cal U}$, $X$ +U}}X$. Gli elementi del prodotto $\prod_{X\in{\cal U}}X$ sono +funzioni (dipendentemente tipizzate): cos per tutti gli $X\in{\cal U}$, $X$ non vuoto per {\bf Inhab} e $\ch(X)\in X$ testimonia questo\footnote{[ndt] Il prodotto cartesiano generalizzato $\prod_{X\in{\cal -U}}X$ definito come l'insieme di tutte le funzioni che mandano ciascun elemento $X\in{\cal U}$ in -un qualche elemento di $X$. Queste funzioni si possono, dunque, considerare come se scegliessero per ogni elemento -$X\in{\cal U}$ un elemento di $X$ rappresentativo di tutto l'insieme $X$ e per +U}}X$ definito come l'insieme di tutte le funzioni che mandano ciascun elemento $X\in{\cal U}$ in +un qualche elemento di $X$. Queste funzioni si possono, dunque, considerare come se scegliessero per ogni elemento +$X\in{\cal U}$ un elemento di $X$ rappresentativo di tutto l'insieme $X$ e per questo si parla di funzioni di scelta. {\bf Choice} isola una di queste funzioni: $\ch$.}. \end{description} Ci sono alcune conseguenze di queste assunzioni che saranno necessarie. -Nella teoria degli insiemi le funzioni sono identificate dai loro grafi, che sono -certi insiemi di coppie ordinate. Cos l'insieme $X\fun Y$ di tutte le funzioni -da un insieme $X$ a un insieme $Y$ un sottoinsieme di $P(X\times Y)$; ed un +Nella teoria degli insiemi le funzioni sono identificate dai loro grafi, che sono +certi insiemi di coppie ordinate. Cos l'insieme $X\fun Y$ di tutte le funzioni +da un insieme $X$ a un insieme $Y$ un sottoinsieme di $P(X\times Y)$; ed un insieme non vuoto quando $Y$ non vuoto. Cos {\bf Sub}, {\bf Prod} e {\bf Pow} insieme implicano che $\cal U$ soddisfa anche \begin{description} @@ -74,55 +74,55 @@ \section{Introduzione} \item[Fun] Se $X\in{\cal U}$ e $Y\in{\cal U}$, allora $X\fun Y\in{\cal U}$. \end{description} -Iterando {\bf Prod}, si ottiene che il prodotto cartesiano di qualsiasi +Iterando {\bf Prod}, si ottiene che il prodotto cartesiano di qualsiasi numero finito, diverso da zero, di insiemi in $\cal U$ ancora in $\cal U$. -$\cal U$ contiene anche il prodotto cartesiano di nessun insieme, il che equivale a -dire che contiene un insieme di un unico elemento (in virt di {\bf Sub} applicato -a qualsiasi insieme in ${\cal U}$---{\bf Infty} garantisce che ce n' uno); per +$\cal U$ contiene anche il prodotto cartesiano di nessun insieme, il che equivale a +dire che contiene un insieme di un unico elemento (in virt di {\bf Sub} applicato +a qualsiasi insieme in ${\cal U}$---{\bf Infty} garantisce che ce n' uno); per precisione, sar isolato un particolare insieme di un solo elemento. \begin{description} \item[Unit] $\cal U$ contiene un distinto insieme di un solo elemento $1=\{0\}$. \end{description} -Analogamente, a causa di {\bf Sub} e {\bf Infty}, $\cal U$ contiene +Analogamente, a causa di {\bf Sub} e {\bf Infty}, $\cal U$ contiene insiemi di due elementi, uno dei quali sar isolato. \begin{description} -\item[Bool] $\cal U$ contiene un distinto insieme di due elementi +\item[Bool] $\cal U$ contiene un distinto insieme di due elementi $\two=\{0,1\}$. \end{description} -Le assunzioni di sopra circa $\cal U$ sono pi deboli di quelle imposte su un -universo di insiemi dagli assiomi della -teoria degli insiemi di Zermelo-Fraenkel\index{teoria degli insiemi Zermelo-Fraenkel} con -l'Assioma di Scelta (\theory{ZFC})\index{assioma di scelta}\index{ZFC@\ml{ZFC}}, -principalmente perch a $\cal U$ non -richiesto di soddisfare alcuna forma dell'Assioma di +Le assunzioni di sopra circa $\cal U$ sono pi deboli di quelle imposte su un +universo di insiemi dagli assiomi della +teoria degli insiemi di Zermelo-Fraenkel\index{teoria degli insiemi Zermelo-Fraenkel} con +l'Assioma di Scelta (\theory{ZFC})\index{assioma di scelta}\index{ZFC@\ml{ZFC}}, +principalmente perch a $\cal U$ non +richiesto di soddisfare alcuna forma dell'Assioma di Rimpiazzamento\index{assioma di rimpiazzamento}. -Di fatto, possibile dimostrare l'esistenza di un insieme -$\cal U$ con le propriet di sopra dagli assiomi di \theory{ZFC}. -(Per esempio si potrebbe considerare $\cal U$ consistere di tutti gli insiemi non vuoti -nella gerarchia cumulativa di von~Neumann formata prima della fase -$\omega+\omega$.) Cos, come per altri pezzi della matematica, -possibile in linea di principio dare una versione completamente formale all'interno -della teoria degli insiemi \theory{ZFC} della semantica della logica \HOL{} che sar fornita +Di fatto, possibile dimostrare l'esistenza di un insieme +$\cal U$ con le propriet di sopra dagli assiomi di \theory{ZFC}. +(Per esempio si potrebbe considerare $\cal U$ consistere di tutti gli insiemi non vuoti +nella gerarchia cumulativa di von~Neumann formata prima della fase +$\omega+\omega$.) Cos, come per altri pezzi della matematica, +possibile in linea di principio dare una versione completamente formale all'interno +della teoria degli insiemi \theory{ZFC} della semantica della logica \HOL{} che sar fornita di sotto. \section{Tipi} \label{types} -I tipi\index{vincolo di tipo!nella logica HOL@nella logica \HOL{}} della +I tipi\index{vincolo di tipo!nella logica HOL@nella logica \HOL{}} della logica \HOL{} sono espressioni che denotano insiemi (nell'universo $\cal U$). -Seguendo la tradizione, -$\sigma$, possibilmente decorato con sottoscritti o primi, usato per +Seguendo la tradizione, +$\sigma$, possibilmente decorato con sottoscritti o primi, usato per variare su tipi arbitrari. -Ci sono quattro specie di tipi nella logica \HOL{}. Questi possono essere descritti +Ci sono quattro specie di tipi nella logica \HOL{}. Questi possono essere descritti informalmente dalla seguente grammatica {\small BNF}, -in cui $\alpha$ varia -su variabili di tipo, \textsl{c} varia su tipi atomici e \textsl{op} varia su +in cui $\alpha$ varia +su variabili di tipo, \textsl{c} varia su tipi atomici e \textsl{op} varia su operatori di tipo. \newlength{\ttX} @@ -154,56 +154,56 @@ \section{Tipi} \begin{enumerate} -\item {\bf Variabili di tipo:}\index{variabili di tipo, nella logica HOL@variabili di tipo, nella logica \HOL{} logic!forma astratta di} queste stanno per insiemi -arbitrari nell'universo. Nella formulazione originale di Church della teoria dei tipi -semplici, le variabili di tipo sono parte del meta-linguaggio e sono usate per -variare su tipi del linguaggio oggetto. Le dimostrazioni contenenti variabili di tipo -erano concepite come schemi di dimostrazione (cio famiglie di dimostrazioni). Per supportare -tali schemi di dimostrazione {\it all'interno} della logica \HOL{}, le variabili di tipo sono -state aggiunte al sistema di tipi del linguaggio oggetto\footnote{Questa tecnica -fu inventata da Robin Milner per la logica oggetto \PPL\ del suo sistema +\item {\bf Variabili di tipo:}\index{variabili di tipo, nella logica HOL@variabili di tipo, nella logica \HOL{} logic!forma astratta di} queste stanno per insiemi +arbitrari nell'universo. Nella formulazione originale di Church della teoria dei tipi +semplici, le variabili di tipo sono parte del meta-linguaggio e sono usate per +variare su tipi del linguaggio oggetto. Le dimostrazioni contenenti variabili di tipo +erano concepite come schemi di dimostrazione (cio famiglie di dimostrazioni). Per supportare +tali schemi di dimostrazione {\it all'interno} della logica \HOL{}, le variabili di tipo sono +state aggiunte al sistema di tipi del linguaggio oggetto\footnote{Questa tecnica +fu inventata da Robin Milner per la logica oggetto \PPL\ del suo sistema \LCF.}. -\item {\bf Tipi atomici:}\index{tipi atomici} questi denotano insiemi fissati nell'universo. Ogni -teoria determina una particolare collezione di tipi atomici. Per -esempio, i tipi atomici standard \ty{bool} e \ty{ind} denotano, -rispettivamente, l'insieme distinto di due elementi $\two$ e +\item {\bf Tipi atomici:}\index{tipi atomici} questi denotano insiemi fissati nell'universo. Ogni +teoria determina una particolare collezione di tipi atomici. Per +esempio, i tipi atomici standard \ty{bool} e \ty{ind} denotano, +rispettivamente, l'insieme distinto di due elementi $\two$ e l'insieme distinto infinito $\inds$. -\item {\bf Tipi composti:}\index{tipi composti, nella logica HOL@tipi composti, nella logica \HOL{}!forma astratta di} questi hanno la +\item {\bf Tipi composti:}\index{tipi composti, nella logica HOL@tipi composti, nella logica \HOL{}!forma astratta di} questi hanno la forma $(\sigma_1,\ldots,\sigma_n)\ty{op}$, dove $\sigma_1$, $\dots$, -$\sigma_n$ sono i tipi argomento e $op$ un {\it operatore di tipo\/} -di ariet $n$. Gli operatori di tipo denotano operazioni per costruire insiemi. -Il tipo $(\sigma_1,\ldots,\sigma_n)\ty{op}$ denota l'insieme che risulta -dall'applicare l'operazione denotata da $op$ agli insiemi denotati da -$\sigma_1$, $\dots$, $\sigma_n$. Per esempio, -\ty{list} un operatore di tipo con ariet 1. Esso denota l'operazione -di formare tutte le liste finite di elementi da un dato insieme. Un altro -esempio l'operatore \ty{prod} di ariet 2 che denota -l'operazione di prodotto cartesiano. Il tipo $(\sigma_1,\sigma_2)\ty{prod}$ +$\sigma_n$ sono i tipi argomento e $op$ un {\it operatore di tipo\/} +di ariet $n$. Gli operatori di tipo denotano operazioni per costruire insiemi. +Il tipo $(\sigma_1,\ldots,\sigma_n)\ty{op}$ denota l'insieme che risulta +dall'applicare l'operazione denotata da $op$ agli insiemi denotati da +$\sigma_1$, $\dots$, $\sigma_n$. Per esempio, +\ty{list} un operatore di tipo con ariet 1. Esso denota l'operazione +di formare tutte le liste finite di elementi da un dato insieme. Un altro +esempio l'operatore \ty{prod} di ariet 2 che denota +l'operazione di prodotto cartesiano. Il tipo $(\sigma_1,\sigma_2)\ty{prod}$ scritto come $\sigma_1\times\sigma_2$. -\item {\bf Tipi funzione:}\index{tipi funzione, nella logica HOL@tipi funzione, nella logica \HOL{}!forma astratta di} Se $\sigma_1$ -e $\sigma_2$ sono tipi, allora $\sigma_1\fun\sigma_2$ il tipo -funzione con {\it dominio\/} $\sigma_1$ e {\it rango} $\sigma_2$. Esso -denota l'insieme di tutte le funzioni (totali) dall'insieme denotato dal suo -dominio all'insieme denotato dal suo rango. (Nella letteratura -$\sigma_1\fun\sigma_2$ scritto senza la freccia e -alla rovescia--cio come $\sigma_2\sigma_1$.) Si noti che sintatticamente -$\fun$ semplicemente un distinto operatore di tipo di ariet 2 scritto con -notazione infissa. E' isolato nella definizione dei tipi \HOL{} -perch denoter sempre la stessa operazione in qualsiasi -modello di una teoria \HOL{}---contrariamente agli altri operatori di tipo che -possono essere interpretati in modo differente in modelli differenti. (Si veda +\item {\bf Tipi funzione:}\index{tipi funzione, nella logica HOL@tipi funzione, nella logica \HOL{}!forma astratta di} Se $\sigma_1$ +e $\sigma_2$ sono tipi, allora $\sigma_1\fun\sigma_2$ il tipo +funzione con {\it dominio\/} $\sigma_1$ e {\it rango} $\sigma_2$. Esso +denota l'insieme di tutte le funzioni (totali) dall'insieme denotato dal suo +dominio all'insieme denotato dal suo rango. (Nella letteratura +$\sigma_1\fun\sigma_2$ scritto senza la freccia e +alla rovescia--cio come $\sigma_2\sigma_1$.) Si noti che sintatticamente +$\fun$ semplicemente un distinto operatore di tipo di ariet 2 scritto con +notazione infissa. E' isolato nella definizione dei tipi \HOL{} +perch denoter sempre la stessa operazione in qualsiasi +modello di una teoria \HOL{}---contrariamente agli altri operatori di tipo che +possono essere interpretati in modo differente in modelli differenti. (Si veda la Sezione~\ref{semantics of types}.) \end{enumerate} -Risulta conveniente identificare i tipi atomici con -tipi composto costruiti con operatori di tipo $0$-ari. Per esempio, -il tipo atomico \ty{bool} dei valori di verit pu essere considerato come -un'abbreviazione per $()\ty{bool}$. Questa identificazione sar fatta nei -dettagli tecnici che seguono, ma nella presentazione informale +Risulta conveniente identificare i tipi atomici con +tipi composto costruiti con operatori di tipo $0$-ari. Per esempio, +il tipo atomico \ty{bool} dei valori di verit pu essere considerato come +un'abbreviazione per $()\ty{bool}$. Questa identificazione sar fatta nei +dettagli tecnici che seguono, ma nella presentazione informale i tipi atomici continueranno ad essere distinti dai tipi composti, e $()c$ sar scritto come $c$. @@ -211,31 +211,31 @@ \subsection{Strutture di tipo} \label{type structures} \index{struttura di tipo, nella logica HOL@struttura di tipo, nella logica \HOL{}} -Il termine `costante di tipo' usato per comprendere sia i tipi atomici sia gli operatori +Il termine `costante di tipo' usato per comprendere sia i tipi atomici sia gli operatori di tipo. Si assume che sia dato un insieme infinito {\sf -TyNames} dei {\em nomi delle costanti di tipo\/}. La lettera +TyNames} dei {\em nomi delle costanti di tipo\/}. La lettera greca $\nu$ usata per variare su membri arbitrari di {\sf TyNames}, -si continuer ad usare \textsl{c} per variare sui nomi dei tipi -atomici (cio costanti di tipo $0$-ari), e \textsl{op} usato per variare -sui nomi degli operatori di tipo (cio costanti di tipo $n$-arie, dove +si continuer ad usare \textsl{c} per variare sui nomi dei tipi +atomici (cio costanti di tipo $0$-ari), e \textsl{op} usato per variare +sui nomi degli operatori di tipo (cio costanti di tipo $n$-arie, dove $n>0$). -Si assume che sia dato un insieme infinito {\sf TyVars} di {\em variabili -di tipo\/}\index{variabili di tipo, nella logica HOL@variabili di tipo, nella logica \HOL{}}. -Le lettere greche $\alpha,\beta,\ldots$, possibilmente con indici -sottoscritti o apici, sono usate per variare su {\sf Tyvars}. Gli insiemi +Si assume che sia dato un insieme infinito {\sf TyVars} di {\em variabili +di tipo\/}\index{variabili di tipo, nella logica HOL@variabili di tipo, nella logica \HOL{}}. +Le lettere greche $\alpha,\beta,\ldots$, possibilmente con indici +sottoscritti o apici, sono usate per variare su {\sf Tyvars}. Gli insiemi {\sf TyNames} e {\sf TyVars} sono assunti disgiunti. -Una {\it struttura di tipo\/} un insieme $\Omega$ di costanti di tipo. Una {\it costante -di tipo\/}\index{costanti di tipo, nella logica HOL@costanti di tipo, nella logica \HOL{}} una coppia $(\nu,n)$ dove $\nu\in{\sf TyNames}$ il +Una {\it struttura di tipo\/} un insieme $\Omega$ di costanti di tipo. Una {\it costante +di tipo\/}\index{costanti di tipo, nella logica HOL@costanti di tipo, nella logica \HOL{}} una coppia $(\nu,n)$ dove $\nu\in{\sf TyNames}$ il nome della costante e $n$ la sua ariet. Cos $\Omega\subseteq{\sf -TyNames}\times\natnums$ (dove $\natnums$ l'insieme dei numeri -naturali). Si assume che non esistano due distinte costanti di tipo che hanno lo -stesso nome -cio ogni volta che $(\nu, n_1)\in\Omega$ e +TyNames}\times\natnums$ (dove $\natnums$ l'insieme dei numeri +naturali). Si assume che non esistano due distinte costanti di tipo che hanno lo +stesso nome +cio ogni volta che $(\nu, n_1)\in\Omega$ e $(\nu, n_2)\in\Omega$, allora $n_1 = n_2$. -L'insieme {\sf Types}$_{\Omega}$ dei tipi su una struttura ${\Omega}$ +L'insieme {\sf Types}$_{\Omega}$ dei tipi su una struttura ${\Omega}$ pu ora essere definito come il pi piccolo insieme tale che: \begin{itemize} @@ -253,7 +253,7 @@ \subsection{Strutture di tipo} \end{itemize} -Si assume che l'operatore di tipo $\fun$ associ\index{operatori di tipo, nella logica HOL@operatori di tipo, nella logica \HOL{}!associativit degli} a +Si assume che l'operatore di tipo $\fun$ associ\index{operatori di tipo, nella logica HOL@operatori di tipo, nella logica \HOL{}!associativit degli} a destra, cos che \[ \sigma_1\fun\sigma_2\fun\ldots\fun \sigma_n\fun\sigma @@ -262,89 +262,89 @@ \subsection{Strutture di tipo} \[ \sigma_1\fun(\sigma_2\fun\ldots\fun (\sigma_n\fun\sigma)\ldots) \] -La notazione $tyvars(\sigma)$ usata per denotare l'insieme delle variabili +La notazione $tyvars(\sigma)$ usata per denotare l'insieme delle variabili di tipo che occorrono in $\sigma$. \subsection{Semantica dei tipi} \label{semantics of types} -Un {\em modello} $M$ di una struttura di tipo $\Omega$ specificato dando +Un {\em modello} $M$ di una struttura di tipo $\Omega$ specificato dando per ogni costante di tipo $(\nu,n)$ una funzione $n$-aria \[ M(\nu):{\cal U}^{n}\longrightarrow{\cal U} \] Cos dati gli insiemi $X_1,\ldots,X_n$ nell'universo $\cal U$, $M(\nu)(X_1,\ldots,X_n)$ anche un insieme nell'universo. Nel caso $n=0$, -questo equivale a specificare un elemento $M(\nu)\in{\cal U}$ per il +questo equivale a specificare un elemento $M(\nu)\in{\cal U}$ per il tipo atomico $\nu$. I tipi che non contengono alcuna variabile di tipo sono chiamati {\it monomorfici}, mentre quelli che contengono variabili di tipo sono chiamati {\it -polimorfici}\index{tipi polimorfici, nella logica HOL@tipi polimorfici, nella logica \HOL{}}\index{tipo, nella logica HOL@tipo, nella logica \HOL{}!polimorfico}. Qual il -significato di un tipo polimorfico? Si pu -dire quale insieme denota un tipo polimorfico solo una volta che si sono istanziate -le sue variabili di tipo su insiemi particolari. Cos il suo significato complessivo non un +polimorfici}\index{tipi polimorfici, nella logica HOL@tipi polimorfici, nella logica \HOL{}}\index{tipo, nella logica HOL@tipo, nella logica \HOL{}!polimorfico}. Qual il +significato di un tipo polimorfico? Si pu +dire quale insieme denota un tipo polimorfico solo una volta che si sono istanziate +le sue variabili di tipo su insiemi particolari. Cos il suo significato complessivo non un singolo insieme, ma piuttosto una funzione con valori su insiemi ${\cal -U}^{n}\longrightarrow{\cal U}$, che assegna un insieme per ogni particolare -assegnazione di insiemi alle variabili di tipo rilevanti. L'ariet $n$ -corrisponde al numero di variabili di tipo coinvolte. E' conveniente -in tale contesto essere in grado di considerare che una variabile di tipo sia -coinvolta nella semantica di un tipo $\sigma$ sia che occorra effettivamente -in $\sigma$ sia che non occorra in esso, portando alla nozione di un +U}^{n}\longrightarrow{\cal U}$, che assegna un insieme per ogni particolare +assegnazione di insiemi alle variabili di tipo rilevanti. L'ariet $n$ +corrisponde al numero di variabili di tipo coinvolte. E' conveniente +in tale contesto essere in grado di considerare che una variabile di tipo sia +coinvolta nella semantica di un tipo $\sigma$ sia che occorra effettivamente +in $\sigma$ sia che non occorra in esso, portando alla nozione di un tipo-in-contesto. -Un {\em contesto di tipo}\index{contesto di tipo}, $\alpha\!s$, semplicemente una -lista finita (possibilmente vuota) di variabili di tipo {\em distinte\/} +Un {\em contesto di tipo}\index{contesto di tipo}, $\alpha\!s$, semplicemente una +lista finita (possibilmente vuota) di variabili di tipo {\em distinte\/} $\alpha_{1},\ldots,\alpha_{n}$. Un {\em -tipo-in-contesto\/}\index{tipo-in-contesto} una coppia, scritta -$\alpha\!s.\sigma$, dove $\alpha\!s$ un contesto di tipo, $\sigma$ un -tipo (su una data struttura di tipo) e tutte le variabili di tipo -che occorrono in $\sigma$ appaiono da qualche parte nella lista $\alpha\!s$. La -lista $\alpha\!s$ pu anche contenere variabili di tipo che non occorrono in +tipo-in-contesto\/}\index{tipo-in-contesto} una coppia, scritta +$\alpha\!s.\sigma$, dove $\alpha\!s$ un contesto di tipo, $\sigma$ un +tipo (su una data struttura di tipo) e tutte le variabili di tipo +che occorrono in $\sigma$ appaiono da qualche parte nella lista $\alpha\!s$. La +lista $\alpha\!s$ pu anche contenere variabili di tipo che non occorrono in $\sigma$. -Per ogni $\sigma$ ci sono dei contesti minimi $\alpha\!s$ per cui -$\alpha\!s.\sigma$ un tipo-in-contesto, che differiscono solo per l'ordine -in cui le variabili di tipo di $\sigma$ sono elencate in $\alpha\!s$. Al -fine di selezionare uno di tali contesti, assumiamo che {\sf TyVars} +Per ogni $\sigma$ ci sono dei contesti minimi $\alpha\!s$ per cui +$\alpha\!s.\sigma$ un tipo-in-contesto, che differiscono solo per l'ordine +in cui le variabili di tipo di $\sigma$ sono elencate in $\alpha\!s$. Al +fine di selezionare uno di tali contesti, assumiamo che {\sf TyVars} venga con un fissato ordine totale e definiamo il contesto {\em -canonico}\index{contesti canonici, nella logica HOL@contesti canonici, nella logica \HOL{}!dei tipi} del tipo $\sigma$ in modo che esso consista esattamente -delle variabili di tipo che esso contiene, elencate in ordine\footnote{E' -possibile lavorare con contesti non ordinati, specificati da insiemi finiti -piuttosto che liste, ma scegliamo di non fare questo dal momento che complica -moderatamente la definizione della semantica che sar data di +canonico}\index{contesti canonici, nella logica HOL@contesti canonici, nella logica \HOL{}!dei tipi} del tipo $\sigma$ in modo che esso consista esattamente +delle variabili di tipo che esso contiene, elencate in ordine\footnote{E' +possibile lavorare con contesti non ordinati, specificati da insiemi finiti +piuttosto che liste, ma scegliamo di non fare questo dal momento che complica +moderatamente la definizione della semantica che sar data di sotto}. -Sia $M$ un modello di una struttura di tipo $\Omega$. Per ogni +Sia $M$ un modello di una struttura di tipo $\Omega$. Per ogni tipo-in-contesto -$\alpha\!s.\sigma$ su $\Omega$, definiamo una funzione +$\alpha\!s.\sigma$ su $\Omega$, definiamo una funzione \[ \den{\alpha\!s.\sigma}_{M}:{\cal U}^{n}\longrightarrow{\cal U} \] -(dove $n$ la lunghezza del contesto) per induzione sulla struttura +(dove $n$ la lunghezza del contesto) per induzione sulla struttura di $\sigma$ come segue. \begin{itemize} -\item Se $\sigma$ una variabile di tipo, essa deve essere $\alpha_{i}$ per qualche unico +\item Se $\sigma$ una variabile di tipo, essa deve essere $\alpha_{i}$ per qualche unico $i=1,\ldots,n$ e allora $\den{\alpha\!s.\sigma}_{M}$ la $i$\/esima funzione di proiezione, che manda $(X_{1},\ldots,X_{n})\in{\cal U}^{n}$ a $X_{i}\in{\cal U}$. \item Se $\sigma$ un tipo funzione\index{tipi funzione, nella logica HOL@tipi funzione, nella logica \HOL{}!semantica formale dei} $\sigma_{1}\fun\sigma_{2}$, allora $\den{\alpha\!s.\sigma}_M$ manda -$X\!s\in{\cal U}^n$ all'insieme di tutte le funzioni +$X\!s\in{\cal U}^n$ all'insieme di tutte le funzioni da $\den{\alpha\!s.\sigma_1}_M(X\!s)$ a $\den{\alpha\!s.\sigma_2}_M(X\!s)$. (Questo fa uso della propriet {\bf Fun} di $\cal U$.) -\item Se $\sigma$ un +\item Se $\sigma$ un tipo composto $(\sigma_{1},\ldots,\sigma_{m})\nu$, allora -$\den{\alpha\!s.\sigma}_{M}$ manda $X\!s$ a +$\den{\alpha\!s.\sigma}_{M}$ manda $X\!s$ a $M(\nu)(S_{1},\ldots,S_{m})$ dove ogni $S_{j}$ $\den{\alpha\!s.\sigma_{j}}_{M}(X\!s)$. \end{itemize} -Si pu ora definire che il significato di un tipo $\sigma$ in un modello $M$ +Si pu ora definire che il significato di un tipo $\sigma$ in un modello $M$ la funzione \[ \den{\sigma}_{M}:{\cal U}^{n}\longrightarrow{\cal U} @@ -352,19 +352,19 @@ \subsection{Semantica dei tipi} data da $\den{\alpha\!s.\sigma}_{M}$, dove $\alpha\!s$ il contesto canonico di $\sigma$. Se $\sigma$ monomorfico, allora $n=0$ e $\den{\sigma}_{M}$ pu essere identificato con l'elemento -$\den{\sigma}_{M}()$ di $\cal U$. Quando il particolare modello $M$ +$\den{\sigma}_{M}()$ di $\cal U$. Quando il particolare modello $M$ chiaro dal contesto, $\den{\_}_{M}$ sar scritto $\den{\_}$. -Per riassumere, dato un modello in $\cal U$ di una struttura di tipo $\Omega$, -la semantica interpreta i tipi monomorfici su $\Omega$ come gli insiemi in +Per riassumere, dato un modello in $\cal U$ di una struttura di tipo $\Omega$, +la semantica interpreta i tipi monomorfici su $\Omega$ come gli insiemi in $\cal U$ e pi in generale, interpreta i tipi polimorfici\index{tipi, nella logica HOL@tipi, nella logica \HOL{}!polimorfici}\index{tipi polimorfici, nella logica HOL@tipi polimorfici, nella logica \HOL{}!semantica formale dei} che coinvolgono $n$ variabili di tipo come funzioni $n$-arie ${\cal -U}^{n}\longrightarrow{\cal U}$ sull'universo. I tipi funzione sono +U}^{n}\longrightarrow{\cal U}$ sull'universo. I tipi funzione sono interpretati da insiemi di funzioni complete. \medskip \noindent{\bf Esempi\ } -Supponiamo che $\Omega$ contenga una costante di tipo $(\textsl{b},0)$ e che +Supponiamo che $\Omega$ contenga una costante di tipo $(\textsl{b},0)$ e che il modello $M$ assegni l'insieme $\two$ a $\textsl{b}$. Allora: \begin{enumerate} @@ -382,55 +382,55 @@ \subsection{Semantica dei tipi} \medskip \noindent{\bf Nota\ } -Un approccio pi tradizionale alla semantica implicherebbe dare -dei significati ai tipi in presenza di `ambienti' che assegnano insiemi in -$\cal U$ a tutte le variabili di tipo. L'uso di tipi-in-contesti quasi -la stessa cosa di usare ambienti parziali con domini finiti--- -solo che il contesto vincola il dominio ammissibile a un particolare -insieme finito (ordinato) di variabili di tipo. Al livello dei tipi non c' -molto da scegliere tra i due approcci. Tuttavia per la sintassi -e la semantica dei termini che sar data di sotto, dove c' una dipendenza -sia dalle variabili di tipo sia dalle variabili individuali, l'approccio usato +Un approccio pi tradizionale alla semantica implicherebbe dare +dei significati ai tipi in presenza di `ambienti' che assegnano insiemi in +$\cal U$ a tutte le variabili di tipo. L'uso di tipi-in-contesti quasi +la stessa cosa di usare ambienti parziali con domini finiti--- +solo che il contesto vincola il dominio ammissibile a un particolare +insieme finito (ordinato) di variabili di tipo. Al livello dei tipi non c' +molto da scegliere tra i due approcci. Tuttavia per la sintassi +e la semantica dei termini che sar data di sotto, dove c' una dipendenza +sia dalle variabili di tipo sia dalle variabili individuali, l'approccio usato qui sembra migliore. \subsection{Istanze e sostituzione} \label{instances-and-substitution} -Se $\sigma$ e $\tau_1,\ldots,\tau_n$ sono tipi su una struttura di tipo +Se $\sigma$ e $\tau_1,\ldots,\tau_n$ sono tipi su una struttura di tipo $\Omega$, \[ \sigma[\tau_{1},\ldots,\tau_{p}/\beta_{1},\ldots,\beta_{p}] \] -denoter il tipo risultante dalle sostituzioni simultanee per -ogni $i=1,\ldots,p$ di +denoter il tipo risultante dalle sostituzioni simultanee per +ogni $i=1,\ldots,p$ di $\tau_i$ per la variabile di tipo $\beta_i$ in $\sigma$. -Il tipo risultante chiamato una {\it istanza\/}\index{tipi, nella logica HOL@tipi, nella logica \HOL{}!istanziazione di} di $\sigma$. Il -seguente lemma circa le istanze sar utile pi avanti; esso dimostrato per +Il tipo risultante chiamato una {\it istanza\/}\index{tipi, nella logica HOL@tipi, nella logica \HOL{}!istanziazione di} di $\sigma$. Il +seguente lemma circa le istanze sar utile pi avanti; esso dimostrato per induzione sulla struttura di $\sigma$. \medskip \noindent{\bf Lemma 1\ }{\it -Supponiamo che $\sigma$ sia un tipo che contiene le variabili di tipo distinte -$\beta_1,\ldots,\beta_p$ e che -$\sigma'=\sigma[\tau_{1},\ldots,\tau_{n}/\beta_1,\ldots,\beta_p]$ sia -un'istanza di $\sigma$. Allora i tipi $\tau_1,\ldots,\tau_p$ sono +Supponiamo che $\sigma$ sia un tipo che contiene le variabili di tipo distinte +$\beta_1,\ldots,\beta_p$ e che +$\sigma'=\sigma[\tau_{1},\ldots,\tau_{n}/\beta_1,\ldots,\beta_p]$ sia +un'istanza di $\sigma$. Allora i tipi $\tau_1,\ldots,\tau_p$ sono determinati univocamente da $\sigma$ e $\sigma'$. } \medskip -Abbiamo anche bisogno di sapere come la semantica dei tipi si comporta rispetto +Abbiamo anche bisogno di sapere come la semantica dei tipi si comporta rispetto alla sostituzione: \medskip \noindent{\bf Lemma 2\ }{\it Dati i tipi-in-contesto $\beta\!s.\sigma$ e -$\alpha\!s.\tau_i$ ($i=1,\ldots,p$, dove $p$ la -lunghezza di $\beta\!s$), sia $\sigma'$ l'istanza -$\sigma[\tau\!s/\beta\!s]$. Allora anche $\alpha\!s.\sigma'$ un -tipo-in-contesto e il suo significato in qualsiasi modello $M$ collegato a quello di -$\beta\!s.\sigma$ come segue. Per tutti gli $X\!s\in{\cal U}^n$ (dove $n$ +$\alpha\!s.\tau_i$ ($i=1,\ldots,p$, dove $p$ la +lunghezza di $\beta\!s$), sia $\sigma'$ l'istanza +$\sigma[\tau\!s/\beta\!s]$. Allora anche $\alpha\!s.\sigma'$ un +tipo-in-contesto e il suo significato in qualsiasi modello $M$ collegato a quello di +$\beta\!s.\sigma$ come segue. Per tutti gli $X\!s\in{\cal U}^n$ (dove $n$ la lunghezza di $\alpha\!s$) \[ \den{\alpha\!s.\sigma'}(X\!s) = @@ -438,19 +438,19 @@ \subsection{Istanze e sostituzione} \ldots ,\den{\alpha\!s.\tau_{p}}(X\!s)) \] } -Ancora una volta, il lemma pu essere dimostrato per induzione sulla struttura di +Ancora una volta, il lemma pu essere dimostrato per induzione sulla struttura di $\sigma$. \section{Termini} \label{terms} -I termini della logica \HOL{} sono espressioni che denotano elementi degli insiemi -denotati dai tipi. La meta-variabile $t$ - usata per variare su termini arbitrari, possibilmente decorata +I termini della logica \HOL{} sono espressioni che denotano elementi degli insiemi +denotati dai tipi. La meta-variabile $t$ + usata per variare su termini arbitrari, possibilmente decorata con indici sottoscritti o apici. -Ci sono quattro specie di termini nella logica \HOL{}. Queste possono essere -descritte approssimativamente nella seguente grammatica {\small BNF}, in +Ci sono quattro specie di termini nella logica \HOL{}. Queste possono essere +descritte approssimativamente nella seguente grammatica {\small BNF}, in cui $x$ varia su variabili e $c$ varia su costanti. \index{combinazioni, nella logica HOL@combinazioni, nella logica \HOL{}!forma astratta di} @@ -478,19 +478,19 @@ \section{Termini} \quad\mid\quad\underbrace{t\ t'}_{\app} \quad\mid\quad\underbrace{\lambda x .\ t}_{\abs}$$ -Informalmente, un $\lambda$-termine\index{lambda termini, nella logica HOL@lambda termini, nella logica \HOL{}}\index{astrazione di funzione, nella logica HOL@astrazione di funzione, nella logica \HOL{}!forma astratta di} $\lambda x.\ t$ denota -una funzione $v\mapsto t[v/x]$, dove $t[v/x]$ denota il risultato di -sostituire $v$ per $x$ in $t$. Un'applicazione\index{applicazione di funzione, nella logica HOL@applicazione di funzione, nella logica \HOL{}!forma astratta di} $t\ t'$ denota il -risultato di applicare la -funzione denotata da $t$ al valore denotato da $t'$. Questo sar +Informalmente, un $\lambda$-termine\index{lambda termini, nella logica HOL@lambda termini, nella logica \HOL{}}\index{astrazione di funzione, nella logica HOL@astrazione di funzione, nella logica \HOL{}!forma astratta di} $\lambda x.\ t$ denota +una funzione $v\mapsto t[v/x]$, dove $t[v/x]$ denota il risultato di +sostituire $v$ per $x$ in $t$. Un'applicazione\index{applicazione di funzione, nella logica HOL@applicazione di funzione, nella logica \HOL{}!forma astratta di} $t\ t'$ denota il +risultato di applicare la +funzione denotata da $t$ al valore denotato da $t'$. Questo sar reso pi preciso di sotto. -La grammatica {\small BNF} appena data omette di menzionare i tipi. Di fatto, ogni -termine nella +La grammatica {\small BNF} appena data omette di menzionare i tipi. Di fatto, ogni +termine nella logica \HOL{} associato con un unico tipo. -La notazione $t_{\sigma}$ -tradizionalmente usata per variare su termini di tipo $\sigma$. Una -grammatica pi accurata dei +La notazione $t_{\sigma}$ +tradizionalmente usata per variare su termini di tipo $\sigma$. Una +grammatica pi accurata dei termini : $$ t_{\sigma} \quad ::=\quad {\mathord{\mathop{x_{\sigma}}\limits_{}}} @@ -500,16 +500,16 @@ \section{Termini} \quad\mid\quad(\lambda x_{\sigma_1} .\ t_{\sigma_2}) _{\sigma_1\fun\sigma_2}$$\index{costanti, nella logica HOL@costanti, nella logica \HOL{}!forma astratta di} -Di fatto, esattamente come la definizione dei tipi era relativa a una particolare -struttura di tipo $\Omega$, la definizione formale dei termini relativa a -una data collezione di costanti tipizzate su $\Omega$. Assumiamo che sia dato -un insieme infinito {\sf Names} di nomi. Una {\em costante\/} su +Di fatto, esattamente come la definizione dei tipi era relativa a una particolare +struttura di tipo $\Omega$, la definizione formale dei termini relativa a +una data collezione di costanti tipizzate su $\Omega$. Assumiamo che sia dato +un insieme infinito {\sf Names} di nomi. Una {\em costante\/} su $\Omega$ una coppia $(\con{c}, \sigma)$, dove $\con{c}\in{\sf Names}$ -e $\sigma\in{\sf Types}_{\Omega}$. Una {\em firma} su $\Omega$ +e $\sigma\in{\sf Types}_{\Omega}$. Una {\em firma} su $\Omega$ semplicemente un insieme $\Sigma_\Omega$ di tali costanti. -L'insieme {\sf Terms}$_{\Sigma_{\Omega}}$ di termini su -$\Sigma_{\Omega}$ definito essere il pi piccolo insieme chiuso sotto le +L'insieme {\sf Terms}$_{\Sigma_{\Omega}}$ di termini su +$\Sigma_{\Omega}$ definito essere il pi piccolo insieme chiuso sotto le seguenti regole di formazione: \begin{enumerate} @@ -522,10 +522,10 @@ \section{Termini} \item {\bf Variabili:} Se $x\in{\sf Names}$ e $\sigma\in{\sf Types}_{\Omega}$, allora ${\tt var}\ x_{\sigma}\in{\sf Terms}_{\Sigma_{\Omega}}$. I termini formati in questo modo sono chiamati {\it -variabili}\index{variabili, nella logica HOL@variabili, nella logica \HOL{}!forma astratta di}. Il marcatore {\tt var}\ semplicemente un accorgimento per -distinguere le variabili da costanti con lo stesso nome. Una variabile -${\tt var}\ x_{\sigma}$ sar di solito scritta come $x_{\sigma}$, se - chiaro dal contesto che $x$ una variabile piuttosto che una +variabili}\index{variabili, nella logica HOL@variabili, nella logica \HOL{}!forma astratta di}. Il marcatore {\tt var}\ semplicemente un accorgimento per +distinguere le variabili da costanti con lo stesso nome. Una variabile +${\tt var}\ x_{\sigma}$ sar di solito scritta come $x_{\sigma}$, se + chiaro dal contesto che $x$ una variabile piuttosto che una costante \item {\bf Applicazioni di funzione:} Se $t_{\sigma'{\fun}\sigma}\in{\sf @@ -542,57 +542,57 @@ \section{Termini} \end{enumerate} -Si noti che possibile avere costanti e variabili\index{variabili, nella logica HOL@variabili, nella logica \HOL{}!con gli stessi nomi} -con lo stesso nome. E' anche possibile avere variabili differenti con +Si noti che possibile avere costanti e variabili\index{variabili, nella logica HOL@variabili, nella logica \HOL{}!con gli stessi nomi} +con lo stesso nome. E' anche possibile avere variabili differenti con lo stesso nome, se esse hanno tipi differenti. -Il tipo sottoscritto a un termine pu essere omesso se chiaro dalla -struttura del termine o dal contesto in cui occorre quale deve essere il +Il tipo sottoscritto a un termine pu essere omesso se chiaro dalla +struttura del termine o dal contesto in cui occorre quale deve essere il suo tipo. -L'applicazione di funzione\index{applicazione di funzione, nella logica HOL@applicazione di funzione, nella logica \HOL{}!associativit della} assunta associare +L'applicazione di funzione\index{applicazione di funzione, nella logica HOL@applicazione di funzione, nella logica \HOL{}!associativit della} assunta associare a sinistra, cos che $t\ t_1\ t_2\ \ldots\ t_n$ abbrevia $(\ \ldots\ ((t\ t_1)\ t_2)\ \ldots\ t_n)$. La notazione $\lambda x_1\ x_2\ \cdots\ x_n.\ t$ abbrevia $\lambda x_1.\ (\lambda x_2.\ \cdots\ (\lambda x_n.\ t)\ \cdots\ )$. -Un termine chiamato polimorfico\index{termini polimorfici, nella logica HOL@termini polimorfici, nella logica \HOL{}} se contiene una variabile -di tipo. Altrimenti chiamato monomorfico. Si noti che un termine -$t_{\sigma}$ pu essere polimorfico anche se $\sigma$ -monomorfico -- per esempio, -$(f_{\alpha\fun\textsl{b}}\ x_{\alpha})_{\textsl{b}}$, dove $\textsl{b}$ un tipo atomico. L'espressione -$tyvars(t_{\sigma})$ denota l'insieme di variabili di tipo che occorrono in +Un termine chiamato polimorfico\index{termini polimorfici, nella logica HOL@termini polimorfici, nella logica \HOL{}} se contiene una variabile +di tipo. Altrimenti chiamato monomorfico. Si noti che un termine +$t_{\sigma}$ pu essere polimorfico anche se $\sigma$ +monomorfico -- per esempio, +$(f_{\alpha\fun\textsl{b}}\ x_{\alpha})_{\textsl{b}}$, dove $\textsl{b}$ un tipo atomico. L'espressione +$tyvars(t_{\sigma})$ denota l'insieme di variabili di tipo che occorrono in $t_{\sigma}$. L'occorrenza di una variabile $x_{\sigma}$ chiamata {\it legata\/}\index{variabili legate, nella logica HOL@variabili legate, nella logica \HOL{}}\index{variabili, nella logica HOL@variabili, nella logica \HOL{}!forma astratta di} - se essa occorre all'interno dello scopo di una $\lambda x_{\sigma}$ + se essa occorre all'interno dello scopo di una $\lambda x_{\sigma}$ che chiude dal punto di vista testuale, altrimenti l'occorrenza chiamata {\it -libera\/}\index{variabili libere, nella logica HOL@variabili libere, nella logica \HOL{}!forma astratta di}. Si noti che $\lambda x_{\sigma}$ non lega -$x_{\sigma'}$ se $\sigma\neq \sigma'$. Un termine in cui tutte le occorrenze +libera\/}\index{variabili libere, nella logica HOL@variabili libere, nella logica \HOL{}!forma astratta di}. Si noti che $\lambda x_{\sigma}$ non lega +$x_{\sigma'}$ se $\sigma\neq \sigma'$. Un termine in cui tutte le occorrenze delle variabili sono legate chiamato {\it chiuso\/}. \subsection{Termini-in-contesto} \label{terms-in-context} -Un {\em contesto\/}\index{contesti, nella semantica della logica HOL@contesti, nella semantica della logica \HOL{}} $\alpha\!s,\!x\!s$ consiste di un contesto -di tipo $\alpha\!s$ insieme con una lista $x\!s=x_{1},\ldots,x_{m}$ di -variabili distinte i cui tipi contengono solo variabili di tipo dalla +Un {\em contesto\/}\index{contesti, nella semantica della logica HOL@contesti, nella semantica della logica \HOL{}} $\alpha\!s,\!x\!s$ consiste di un contesto +di tipo $\alpha\!s$ insieme con una lista $x\!s=x_{1},\ldots,x_{m}$ di +variabili distinte i cui tipi contengono solo variabili di tipo dalla lista $\alpha\!s$. -La condizione che $x\!s$ contenga variabili {\em distinte\/} necessita -di qualche commento. Dal momento che una variabile specificata sia da un nome sia da un -tipo, permesso che $x\!s$ contenga -nomi\index{variabili, nella logica HOL@variabili, nella logica \HOL{}!con gli stessi nomi} ripetuti, - purch ai nomi siano attaccati tipi -differenti. Questo aspetto della sintassi significa che si deve procedere con -cautela quando si definisce il significato dell'istanziazione delle variabili di tipo, -dal momento che l'istanziazione pu far s che delle variabili diventino uguali +La condizione che $x\!s$ contenga variabili {\em distinte\/} necessita +di qualche commento. Dal momento che una variabile specificata sia da un nome sia da un +tipo, permesso che $x\!s$ contenga +nomi\index{variabili, nella logica HOL@variabili, nella logica \HOL{}!con gli stessi nomi} ripetuti, + purch ai nomi siano attaccati tipi +differenti. Questo aspetto della sintassi significa che si deve procedere con +cautela quando si definisce il significato dell'istanziazione delle variabili di tipo, +dal momento che l'istanziazione pu far s che delle variabili diventino uguali `accidentalmente'. Si veda la Sezione~\ref{term-substitution}. Un {\em termine-in-contesto\/}\index{term-in-context} -$\:\;\alpha\!s,\!x\!s.t\;\:$ consiste di un contesto insieme con un termine +$\:\;\alpha\!s,\!x\!s.t\;\:$ consiste di un contesto insieme con un termine $t$ che soddisfa le seguenti condizioni: \begin{itemize} @@ -600,82 +600,82 @@ \subsection{Termini-in-contesto} \item $x\!s$ contiene qualsiasi variabile che occorre libera in $t$. -\item $x\!s$ non contiene alcuna variabile che occorre +\item $x\!s$ non contiene alcuna variabile che occorre legata in $t$. \end{itemize} -Il contesto $\alpha\!s,\!x\!s$ pu contenere variabili (di tipo) che -non appaiono in $t$. Si noti che la combinazione della seconda e della terza -condizione implica che una variabile non pu avere occorrenze sia libere sia -legate in $t$. Per un termine arbitrario, c' sempre un -termine $\alpha$-equivalente che soddisfa questa condizione, ottenuto -rinominando le variabili legate in caso di necessit\footnote{Si ricordi che due -termini sono detti essere $\alpha$-equivalenti se differiscono soltanto nei -nomi delle loro variabili legate.}. Nella semantica dei termini che sar -data di seguito restringeremo l'attenzione a tali termini. Quindi il significato di un -termine arbitrario considerato essere il significato di qualche $\alpha$-variante di -esso non avente variabili sia libere sia legate. (La semantica uguaglier -le $\alpha$-varianti, cos che non importa quale scelta.) Evidentemente -per un tale termine c' un contesto minimale $\alpha\!s,\!x\!s$, unico -a meno dell'ordine in cui le variabili sono elencate, per il quale -$\alpha\!s,\!x\!s.t$ un termine-in-contesto. Come per le variabili di tipo, -assumeremo dato un fissato ordine totale sulle variabili. Quindi l'unico +Il contesto $\alpha\!s,\!x\!s$ pu contenere variabili (di tipo) che +non appaiono in $t$. Si noti che la combinazione della seconda e della terza +condizione implica che una variabile non pu avere occorrenze sia libere sia +legate in $t$. Per un termine arbitrario, c' sempre un +termine $\alpha$-equivalente che soddisfa questa condizione, ottenuto +rinominando le variabili legate in caso di necessit\footnote{Si ricordi che due +termini sono detti essere $\alpha$-equivalenti se differiscono soltanto nei +nomi delle loro variabili legate.}. Nella semantica dei termini che sar +data di seguito restringeremo l'attenzione a tali termini. Quindi il significato di un +termine arbitrario considerato essere il significato di qualche $\alpha$-variante di +esso non avente variabili sia libere sia legate. (La semantica uguaglier +le $\alpha$-varianti, cos che non importa quale scelta.) Evidentemente +per un tale termine c' un contesto minimale $\alpha\!s,\!x\!s$, unico +a meno dell'ordine in cui le variabili sono elencate, per il quale +$\alpha\!s,\!x\!s.t$ un termine-in-contesto. Come per le variabili di tipo, +assumeremo dato un fissato ordine totale sulle variabili. Quindi l'unico contesto minimo con le variabili elencate in ordine sar chiamato il contesto {\em canonico}\index{contesti canonici, nella logica HOL@contesti canonici, nella logica \HOL{}!di termini} del termine $t$. \subsection{Semantica dei termini} \label{semantics of terms} -Sia $\Sigma_{\Omega}$ una firma\index{firme, della logica HOL@firme, della logica \HOL{}!semantica formale delle} su una struttura -di tipo $\Omega$ (si veda la Sezione~\ref{terms}). Un {\em modello\/} $M$ di -$\Sigma_{\Omega}$ specificato da un modello della struttura di tipo pi -per ogni costante\index{costanti primitive, della logica HOL@costanti primitive, della logica \HOL{}} $(\con{c},\sigma)\in\Sigma_{\Omega}$ un +Sia $\Sigma_{\Omega}$ una firma\index{firme, della logica HOL@firme, della logica \HOL{}!semantica formale delle} su una struttura +di tipo $\Omega$ (si veda la Sezione~\ref{terms}). Un {\em modello\/} $M$ di +$\Sigma_{\Omega}$ specificato da un modello della struttura di tipo pi +per ogni costante\index{costanti primitive, della logica HOL@costanti primitive, della logica \HOL{}} $(\con{c},\sigma)\in\Sigma_{\Omega}$ un elemento \[ M(\con{c},\sigma) \in \prod_{X\!s\in{\cal U}^{n}}\den{\sigma}_{M}(X\!s) \] -del prodotto cartesiano indicato, dove $n$ il numero delle variabili -di tipo che occorrono in $\sigma$. In altre parole -$M(\con{c},\sigma)$ una funzione (dipendentemente tipizzata) -che assegna ad ogni $X\!s\in{\cal U}^{n}$ un elemento di -$\den{\sigma}_{M}(X\!s)$. Nel caso che $n=0$ (cos che -$\sigma$ monomorfico), $\den{\sigma}_{M}$ era identificato -con un insieme in $\cal U$ e quindi $M(c,\sigma)$ pu essere +del prodotto cartesiano indicato, dove $n$ il numero delle variabili +di tipo che occorrono in $\sigma$. In altre parole +$M(\con{c},\sigma)$ una funzione (dipendentemente tipizzata) +che assegna ad ogni $X\!s\in{\cal U}^{n}$ un elemento di +$\den{\sigma}_{M}(X\!s)$. Nel caso che $n=0$ (cos che +$\sigma$ monomorfico), $\den{\sigma}_{M}$ era identificato +con un insieme in $\cal U$ e quindi $M(c,\sigma)$ pu essere identificato con un elemento di quell'insieme. -Il significato dei termini \HOL{} in un tale modello sar ora descritto. La -semantica interpreta termini chiusi che non coinvolgono variabili di tipo come -elementi di insiemi in $\cal U$ (il particolare insieme coinvolto essendo derivato -dal tipo del termine come nella Sezione~\ref{semantics of types}). Pi -in generale, se il termine chiuso coinvolge $n$ variabili di tipo allora +Il significato dei termini \HOL{} in un tale modello sar ora descritto. La +semantica interpreta termini chiusi che non coinvolgono variabili di tipo come +elementi di insiemi in $\cal U$ (il particolare insieme coinvolto essendo derivato +dal tipo del termine come nella Sezione~\ref{semantics of types}). Pi +in generale, se il termine chiuso coinvolge $n$ variabili di tipo allora interpretato come un elemento di un prodotto $\prod_{X\!s\in{\cal U}^{n}}Y(X\!s)$, dove la funzione $Y:{\cal U}^{n}\longrightarrow{\cal -U}$ derivata dal tipo del termine (in un contesto di tipo derivato -dal termine). Cos il significato del termine una funzione (dipendentemente tipizzata) -che, quando applicata a qualsiasi significato scelto per le variabili -di tipo nel termine, d un significato per il termine come un elemento di un -insieme in $\cal U$. Dall'altro lato, se il termine coinvolge $m$ variabili -libere ma nessuna variabile di tipo, allora interpretato come una funzione -$Y_1\times\cdots\times Y_m\fun Y$ dove gli insiemi $Y_1,\ldots,Y_m$ in -$\cal U$ sono interpretazioni dei tipi delle variabili libere nel -termine e l'insieme $Y\in{\cal U}$ l'interpretazione del tipo del -termine; cos il significato del termine una funzione che, quando -applicata a qualsiasi significato scelto per le variabili libere nel termine, -d un significato per il termine. Infine, il caso pi generale quello di un -termine che coinvolge $n$ variabili di tipo e $m$ variabili libere: esso +U}$ derivata dal tipo del termine (in un contesto di tipo derivato +dal termine). Cos il significato del termine una funzione (dipendentemente tipizzata) +che, quando applicata a qualsiasi significato scelto per le variabili +di tipo nel termine, d un significato per il termine come un elemento di un +insieme in $\cal U$. Dall'altro lato, se il termine coinvolge $m$ variabili +libere ma nessuna variabile di tipo, allora interpretato come una funzione +$Y_1\times\cdots\times Y_m\fun Y$ dove gli insiemi $Y_1,\ldots,Y_m$ in +$\cal U$ sono interpretazioni dei tipi delle variabili libere nel +termine e l'insieme $Y\in{\cal U}$ l'interpretazione del tipo del +termine; cos il significato del termine una funzione che, quando +applicata a qualsiasi significato scelto per le variabili libere nel termine, +d un significato per il termine. Infine, il caso pi generale quello di un +termine che coinvolge $n$ variabili di tipo e $m$ variabili libere: esso interpretato come un elemento di un prodotto \[ \prod_{X\!s\in{\cal U}^{n}}Y_{1}(X\!s)\times\cdots\times Y_{m}(X\!s) \;\fun\; Y(X\!s) \] dove le funzioni $Y_{1},\ldots,Y_{m},Y:{\cal -U}^{n}\longrightarrow{\cal U}$ sono determinati dai tipi delle variabili -libere e dal tipo del termine (in un conteso di tipo derivato dal +U}^{n}\longrightarrow{\cal U}$ sono determinati dai tipi delle variabili +libere e dal tipo del termine (in un conteso di tipo derivato dal termine). Pi precisamente, dato un termine-in-contesto $\alpha\!s,\!x\!s.t$ -su $\Sigma_{\Omega}$ supponiamo che +su $\Sigma_{\Omega}$ supponiamo che \begin{itemize} \item $t$ abbia il tipo $\tau$ @@ -685,11 +685,11 @@ \subsection{Semantica dei termini} \item $\alpha\!s=\alpha_{1},\ldots,\alpha_{n}$. \end{itemize} -Allora dal momento che $\alpha\!s,\!x\!s.t$ un termine-in-contesto, $\alpha\!s.\tau$ -e $\alpha\!s.\sigma_{j}$ sono tipi-in-contesto, e quindi danno origine -a funzioni $\den{\alpha\!s.\tau}_{M}$ e -$\den{\alpha\!s.\sigma_{j}}_{M}$ da ${\cal U}^{n}$ a $\cal U$ come nella -sezione~\ref{semantics of types}. Il significato di $\alpha\!s,\!x\!s.t$ +Allora dal momento che $\alpha\!s,\!x\!s.t$ un termine-in-contesto, $\alpha\!s.\tau$ +e $\alpha\!s.\sigma_{j}$ sono tipi-in-contesto, e quindi danno origine +a funzioni $\den{\alpha\!s.\tau}_{M}$ e +$\den{\alpha\!s.\sigma_{j}}_{M}$ da ${\cal U}^{n}$ a $\cal U$ come nella +sezione~\ref{semantics of types}. Il significato di $\alpha\!s,\!x\!s.t$ nel modello $M$ sar dato da un elemento \[ \den{\alpha\!s,\!x\!s.t}_{M} \in \prod_{X\!s\in{\cal U}^{n}} @@ -703,20 +703,20 @@ \subsection{Semantica dei termini} \times\cdots\times \den{\alpha\!s.\sigma_{m}}_{M}(X\!s) \end{eqnarray*} si ottiene un elemento $\den{\alpha\!s,\!x\!s.t}_{M}(X\!s)(y\!s)$ di -$\den{\alpha\!s.\tau}_{M}(X\!s)$. La definizione di -$\den{\alpha\!s,\!x\!s.t}_{M}$ procede per induzione sulla struttura del -termine $t$ come segue. (Come prima, il sottoscritto $M$ sar omesso dalle -parentesi semantiche $\den{ \_ }$ quando il particolare modello coinvolto +$\den{\alpha\!s.\tau}_{M}(X\!s)$. La definizione di +$\den{\alpha\!s,\!x\!s.t}_{M}$ procede per induzione sulla struttura del +termine $t$ come segue. (Come prima, il sottoscritto $M$ sar omesso dalle +parentesi semantiche $\den{ \_ }$ quando il particolare modello coinvolto chiaro dal contesto.) \begin{itemize} \item -Se $t$ una variabile\index{variabili, nella logica HOL@variabili, nella logica \HOL{}!semantica formale delle}, deve essere $x_{j}$ per qualche unico -$j=1,\ldots,m$, so $\tau=\sigma_{j}$ e allora +Se $t$ una variabile\index{variabili, nella logica HOL@variabili, nella logica \HOL{}!semantica formale delle}, deve essere $x_{j}$ per qualche unico +$j=1,\ldots,m$, so $\tau=\sigma_{j}$ e allora $\den{\alpha\!s,\!x\!s.t}(X\!s)(y\!s)$ definito essere $y_{j}$. \item -Supponiamo che $t$ sia una costante\index{costanti, nella logica HOL@costanti, nella logica \HOL{}!semantica formale delle} $\con{c}_{\sigma'}$, dove +Supponiamo che $t$ sia una costante\index{costanti, nella logica HOL@costanti, nella logica \HOL{}!semantica formale delle} $\con{c}_{\sigma'}$, dove $(\con{c},\sigma)\in\Sigma_{\Omega}$ e $\sigma'$ un'istanza di $\sigma$. Allora per il Lemma~1 di \ref{instances-and-substitution}, $\sigma'=\sigma[\tau_{1},\ldots,\tau_{p}/\beta_{1},\ldots,\beta_{p}]$ @@ -730,7 +730,7 @@ \subsection{Semantica dei termini} \item Supponiamo che $t$ sia un termine applicazione di funzione\index{combinazioni, nella logica HOL@combinazioni, nella logica \HOL{}!semantica formale delle} $(t_{1}\ -t_{2})$\index{applicazione di funzione, nella logica HOL@applicazione di funzione, nella logica \HOL{}!semantica formale delle} dove $t_{1}$ di tipo +t_{2})$\index{applicazione di funzione, nella logica HOL@applicazione di funzione, nella logica \HOL{}!semantica formale delle} dove $t_{1}$ di tipo $\tau'\fun\tau$ e $t_{2}$ di tipo $\tau'$. Allora $f=\den{\alpha\!s,\!x\!s.t_{1}}(X\!s)(y\!s)$, essendo un elemento di $\den{\alpha\!s.\tau'\fun\tau}(X\!s)$, una funzione dall'insieme @@ -744,81 +744,81 @@ \subsection{Semantica dei termini} tipo $\tau_{2}$. Cos $\tau=\tau_{1}\fun\tau_{2}$ e $\den{\alpha\!s.\tau}(X\!s)$ l'insieme di funzioni $\den{\alpha\!s.\tau_{1}}(X\!s)\fun\den{\alpha\!s.\tau_{2}}(X\!s)$. -Definiamo $\den{\alpha\!s,\!x\!s.t}(X\!s)(y\!s)$ essere l'elemento di +Definiamo $\den{\alpha\!s,\!x\!s.t}(X\!s)(y\!s)$ essere l'elemento di questo insieme che la funzione che manda $y\in\den{\alpha\!s.\tau_{1}}(X\!s)$ a $\den{\alpha\!s,\!x\!s,\!x.t_{2}}(X\!s)(y\!s,y)$. (Si noti che dal momento che -$\alpha\!s,\!x\!s.t$ un termine in contesto, per convenzione la variabile +$\alpha\!s,\!x\!s.t$ un termine in contesto, per convenzione la variabile legata $x$ non occorre in $x\!s$ e cos anche $\alpha\!s,\!x\!s,\!x.t_{2}$ un termine in contesto.) \end{itemize} -Ora definiamo il significato di un termine $t_{\tau}$ in un modello $M$ essere la -funzione dipendentemente tipizzata +Ora definiamo il significato di un termine $t_{\tau}$ in un modello $M$ essere la +funzione dipendentemente tipizzata \[ \den{t_{\tau}} \in \prod_{X\!s\in{\cal U}^{n}} \left(\prod_{j=1}^{m}\den{\alpha\!s.\sigma_{j}}(X\!s)\right) \fun \den{\alpha\!s.\tau}(X\!s) \] -data da $\den{\alpha\!s,\!x\!s.t_{\tau}}$, dove $\alpha\!s,\!x\!s$ il -contesto canonico di $t_{\tau}$. Cos $n$ il numero di variabili di tipi in -$t_{\tau}$, $\alpha\!s$ una lista di quelle variabili di tipo, $m$ il -numero di variabili ordinarie che occorrono libere in $t_{\tau}$ (assunte essere -distinte dalle variabili legate di $t_{\tau}$) e i $\sigma_{j}$ sono -i tipi di quelle variabili. (E' importante notare che la lista -$\alpha\!s$, che parte del contesto canonico di $t$, pu essere strettamente -pi grande dei contesti di tipo canonici di $\sigma_{j}$ o $\tau$. Cos -non avrebbe senso scrivere semplicemente $\den{\sigma_{j}}$ o $\den{\tau}$ nella +data da $\den{\alpha\!s,\!x\!s.t_{\tau}}$, dove $\alpha\!s,\!x\!s$ il +contesto canonico di $t_{\tau}$. Cos $n$ il numero di variabili di tipi in +$t_{\tau}$, $\alpha\!s$ una lista di quelle variabili di tipo, $m$ il +numero di variabili ordinarie che occorrono libere in $t_{\tau}$ (assunte essere +distinte dalle variabili legate di $t_{\tau}$) e i $\sigma_{j}$ sono +i tipi di quelle variabili. (E' importante notare che la lista +$\alpha\!s$, che parte del contesto canonico di $t$, pu essere strettamente +pi grande dei contesti di tipo canonici di $\sigma_{j}$ o $\tau$. Cos +non avrebbe senso scrivere semplicemente $\den{\sigma_{j}}$ o $\den{\tau}$ nella definizione di sopra.) Se $t_{\tau}$ un termine chiuso, allora $m=0$ e per ogni $X\!s\in{\cal -U}^{n}$ si pu identificare $\den{t_{\tau}}$ con l'elemento -$\den{t_{\tau}}(X\!s)()\in\den{\alpha\!s.\tau}(X\!s)$. Cos per termini chiusi +U}^{n}$ si pu identificare $\den{t_{\tau}}$ con l'elemento +$\den{t_{\tau}}(X\!s)()\in\den{\alpha\!s.\tau}(X\!s)$. Cos per termini chiusi si ottiene \[ \den{t_{\tau}} \in \prod_{X\!s\in{\cal U}^{n}} \den{\alpha\!s.\tau}(X\!s) \] -dove $\alpha\!s$ la lista delle variabili di tipo che occorrono in $t_{\tau}$ e -$n$ la lunghezza di quella lista. Se inoltre, nessuna variabile di tipo occorre in -$t_{\tau}$, allora $n=0$ e $\den{t_{\tau}}$ pu essere identificato con +dove $\alpha\!s$ la lista delle variabili di tipo che occorrono in $t_{\tau}$ e +$n$ la lunghezza di quella lista. Se inoltre, nessuna variabile di tipo occorre in +$t_{\tau}$, allora $n=0$ e $\den{t_{\tau}}$ pu essere identificato con l'elemento $\den{t_{\tau}}()$ dell'insieme $\den{\tau}\in{\cal U}$. -La semantica dei termini appare qualcosa di complicato a casua della -possibile dipendenza di un termine sia dalle variabili di tipo sia dalle variabili -ordinarie. Esempi di come la definizione della semantica -funziona in pratica si pu trovare nella Sezione~\ref{LOG}, dove dato il significato +La semantica dei termini appare qualcosa di complicato a casua della +possibile dipendenza di un termine sia dalle variabili di tipo sia dalle variabili +ordinarie. Esempi di come la definizione della semantica +funziona in pratica si pu trovare nella Sezione~\ref{LOG}, dove dato il significato di alcuni termini che denotano costanti logiche. \subsection{Sostituzione} \label{term-substitution} -Dal momento che i termini possono coinvolgere sia variabili di tipo sia -variabili ordinarie, ci sono due differenti operazioni di sostituzione -sui termini che bisogna considerare---sostituzione di tipi per variabili +Dal momento che i termini possono coinvolgere sia variabili di tipo sia +variabili ordinarie, ci sono due differenti operazioni di sostituzione +sui termini che bisogna considerare---sostituzione di tipi per variabili di tipo e sostituzione di termini per variabili. \subsubsection*{Sostituire tipi per variabili di tipo nei termini} \index{regola di sostituzione, nella logica HOL@regola di sostituzione, nella logica \HOL{}!semantica formale della} -Supponiamo che $t$ sia un termine, con contesto canonico $\alpha\!s,\!x\!s$ diciamo, +Supponiamo che $t$ sia un termine, con contesto canonico $\alpha\!s,\!x\!s$ diciamo, dove $\alpha\!s = \alpha_1,\ldots,\alpha_n$, $x\!s = x_1,\ldots,x_m$ -e dove per $j=1,\ldots,m$ il tipo della variabile $x_j$ -$\sigma_j$. Se $\alpha\!s'.\tau_{i}$ ($i=1,\ldots,n$) sono -tipi-in-contesto, allora sostituendo\index{sostituzione di tipo, nella logica HOL@sostituzione di tipo, nella logica \HOL{}!semantica formale della} i tipi -$\tau_{i}$ per le variabili di tipo $\alpha_{i}$ nella lista $x\!s$, si -ottiene una nuova lista di variabili $x\!s'$. Cos il $j$\/esimo elemento di -$x\!s'$ ha il tipo $\sigma'_{j} = \sigma_{j}[\tau\!s/\alpha\!s]$. Saranno considerate solo +e dove per $j=1,\ldots,m$ il tipo della variabile $x_j$ +$\sigma_j$. Se $\alpha\!s'.\tau_{i}$ ($i=1,\ldots,n$) sono +tipi-in-contesto, allora sostituendo\index{sostituzione di tipo, nella logica HOL@sostituzione di tipo, nella logica \HOL{}!semantica formale della} i tipi +$\tau_{i}$ per le variabili di tipo $\alpha_{i}$ nella lista $x\!s$, si +ottiene una nuova lista di variabili $x\!s'$. Cos il $j$\/esimo elemento di +$x\!s'$ ha il tipo $\sigma'_{j} = \sigma_{j}[\tau\!s/\alpha\!s]$. Saranno considerate solo sostituzioni con la seguente propriet. \begin{quote} -Nell'istanziare\index{tipi, nella logica HOL@tipi, nella logica \HOL{}!istanziazione di} le variabili di tipo $\alpha\!s$ con i tipi -$\tau\!s$, nessuna coppia di due variabili distinte nella lista $x\!s$ diventano uguali -nella lista $x\!s'$\footnote{Una tale identificazione di variabili potrebbe -accadere se le variabili avessero lo stesso nome componente e i loro tipi +Nell'istanziare\index{tipi, nella logica HOL@tipi, nella logica \HOL{}!istanziazione di} le variabili di tipo $\alpha\!s$ con i tipi +$\tau\!s$, nessuna coppia di due variabili distinte nella lista $x\!s$ diventano uguali +nella lista $x\!s'$\footnote{Una tale identificazione di variabili potrebbe +accadere se le variabili avessero lo stesso nome componente e i loro tipi diventassero uguali in seguito all'istanziazione.}. \end{quote} -Questa condizione assicura che $\alpha\!s',x\!s'$ sia davvero un contesto. Allora -si ottiene un nuovo termine-in-contesto $\alpha\!s',\!x\!s'.t'$ -sostituendo i tipi $\tau\!s=\tau_{1},\ldots,\tau_{n}$ per le variabili -di tipo $\alpha\!s$ in $t$ (con un'adatta rinomina delle occorrenze -legate delle variabili per renderle distinte dalle variabili in +Questa condizione assicura che $\alpha\!s',x\!s'$ sia davvero un contesto. Allora +si ottiene un nuovo termine-in-contesto $\alpha\!s',\!x\!s'.t'$ +sostituendo i tipi $\tau\!s=\tau_{1},\ldots,\tau_{n}$ per le variabili +di tipo $\alpha\!s$ in $t$ (con un'adatta rinomina delle occorrenze +legate delle variabili per renderle distinte dalle variabili in $x\!s'$). La notazione \[ t[\tau\!s/\alpha\!s] @@ -828,8 +828,8 @@ \subsubsection*{Sostituire tipi per variabili di tipo nei termini} \medskip \noindent{\bf Lemma 3\ }{\it -Il significato di $\alpha\!s',\!x\!s'.t'$ in un modello collegato a quello -di $t$ come segue. Per tutti $X\!s'\in{\cal U}^{n'}$ (dove $n'$ la +Il significato di $\alpha\!s',\!x\!s'.t'$ in un modello collegato a quello +di $t$ come segue. Per tutti $X\!s'\in{\cal U}^{n'}$ (dove $n'$ la lunghezza di $\alpha\!s'$) } \[ @@ -840,24 +840,24 @@ \subsubsection*{Sostituire tipi per variabili di tipo nei termini} \medskip -Il lemma~2 in \ref{instances-and-substitution} necessario per vedere che entrambi +Il lemma~2 in \ref{instances-and-substitution} necessario per vedere che entrambi i lati dell'equazione di sopra sono elementi dello stesso insieme di funzioni. -La validit dell'equazione dimostrata per induzione sulla struttura +La validit dell'equazione dimostrata per induzione sulla struttura del termine $t$. \subsubsection*{Sostituire termini per variabili nei termini} \index{regola di sostituzione, nella logica HOL@regola di sostituzione, nella logica \HOL{}!semantica formale della} -Supponiamo che $t$ sia un termine, con contesto canonico $\alpha\!s,\!x\!s$ diciamo, -dove $\alpha\!s = \alpha_1,\ldots,\alpha_n$, $x\!s = x_1,\ldots,x_m$ +Supponiamo che $t$ sia un termine, con contesto canonico $\alpha\!s,\!x\!s$ diciamo, +dove $\alpha\!s = \alpha_1,\ldots,\alpha_n$, $x\!s = x_1,\ldots,x_m$ e dove per $j=1,\ldots,m$ il tipo della variabile $x_j$ -$\sigma_j$. Se si hanno termini-in-contesto $\alpha\!s,\!x\!s'.t_{j}$ per -$j=1,\ldots,m$ con $t_{j}$ dello stesso tipo di $x_{j}$, diciamo -$\sigma_{j}$, allora si ottiene un nuovo termine-in-contesto -$\alpha\!s,\!x\!s'.t''$ sostituendo i termini -$t\!s=t_1,\ldots,t_m$ per le variabili $x\!s$ in $t$ (con la rinomina +$\sigma_j$. Se si hanno termini-in-contesto $\alpha\!s,\!x\!s'.t_{j}$ per +$j=1,\ldots,m$ con $t_{j}$ dello stesso tipo di $x_{j}$, diciamo +$\sigma_{j}$, allora si ottiene un nuovo termine-in-contesto +$\alpha\!s,\!x\!s'.t''$ sostituendo i termini +$t\!s=t_1,\ldots,t_m$ per le variabili $x\!s$ in $t$ (con la rinomina adatta delle occorrenze legate delle variabili per prevenire che le variabili -libere delle $t_{j}$ diventino legate dopo la sostituzione). La +libere delle $t_{j}$ diventino legate dopo la sostituzione). La notazione \[ t[t\!s/x\!s] @@ -867,8 +867,8 @@ \subsubsection*{Sostituire termini per variabili nei termini} \medskip \noindent{\bf Lemma 4\ }{\it -Il significato di $\alpha\!s,\!x\!s'.t''$ in un modello collegato con quello di -$t$ come segue. Per tutti $X\!s\in{\cal U}^{n}$ e tutti +Il significato di $\alpha\!s,\!x\!s'.t''$ in un modello collegato con quello di +$t$ come segue. Per tutti $X\!s\in{\cal U}^{n}$ e tutti $y\!s'\in\den{\alpha\!s.\sigma'_{1}} \times\cdots\times \den{\alpha\!s.\sigma'_{m'}}$ (dove $\sigma'_{j}$ il tipo di $x'_{j}$)} @@ -880,44 +880,44 @@ \subsubsection*{Sostituire termini per variabili nei termini} \medskip -Di nuovo, questo risultato dimostrato per induzione sulla struttura del +Di nuovo, questo risultato dimostrato per induzione sulla struttura del termine $t$. \section{Nozioni standard} -Fino ad ora la sintassi dei tipi e dei termini stata molto generale. Per -rappresentare le formule standard della logica necessario -imporre qualche struttura specifica. In particolare, ogni struttura di tipo -deve contenere un tipo atomico \ty{bool} che inteso denotare -l'insieme distinto di due elementi $\two\in{\cal U}$, considerato come un insieme -di valori di verit. Le formule logiche sono allora identificate con -i termini\index{variabili di tipo, nella logica HOL@variabili di tipo, nella logica \HOL{}!forma astratta di}\index{termini, nella logica HOL@termini, nella logica \HOL{}!as logical formulas} di -tipo \ty{bool}. In aggiunta, varie -costanti logiche sono assunte essere in tutte le firme. Questi -requisiti sono formalizzati definendo la nozione di una +Fino ad ora la sintassi dei tipi e dei termini stata molto generale. Per +rappresentare le formule standard della logica necessario +imporre qualche struttura specifica. In particolare, ogni struttura di tipo +deve contenere un tipo atomico \ty{bool} che inteso denotare +l'insieme distinto di due elementi $\two\in{\cal U}$, considerato come un insieme +di valori di verit. Le formule logiche sono allora identificate con +i termini\index{variabili di tipo, nella logica HOL@variabili di tipo, nella logica \HOL{}!forma astratta di}\index{termini, nella logica HOL@termini, nella logica \HOL{}!as logical formulas} di +tipo \ty{bool}. In aggiunta, varie +costanti logiche sono assunte essere in tutte le firme. Questi +requisiti sono formalizzati definendo la nozione di una firma standard. \subsection{Strutture di tipo standard} \label{standard-type-structures} -Una struttura di tipo $\Omega$ {\em standard\/} se contiene i -tipi atomici \ty{bool} (dei booleani o valori di verit) e \ty{ind} (degli -individui). (Nella letteratura, spesso utilizzato il simbolo $o$ +Una struttura di tipo $\Omega$ {\em standard\/} se contiene i +tipi atomici \ty{bool} (dei booleani o valori di verit) e \ty{ind} (degli +individui). (Nella letteratura, spesso utilizzato il simbolo $o$ al posto di \ty{bool} e $\iota$ al posto di \ty{ind}.) -Un modello $M$ di $\Omega$ {\em standard\/} se $M(\bool)$ e $M(\ind)$ sono -rispettivamente gli insiemi distinti $\two$ e $\ind$ nell'universo +Un modello $M$ di $\Omega$ {\em standard\/} se $M(\bool)$ e $M(\ind)$ sono +rispettivamente gli insiemi distinti $\two$ e $\ind$ nell'universo $\cal U$. -Si assumer d'ora in avanti che le strutture di tipo e i loro modelli +Si assumer d'ora in avanti che le strutture di tipo e i loro modelli sono standard. \subsection{Firme standard} \label{standard-signatures} \index{firme, della logica HOL@firme, della logica \HOL{}!standard}\index{firme standard, della logica HOL@firme standard, della logica \HOL{}} -Una firma $\Sigma_{\Omega}$ {\em standard\/} se contiene le +Una firma $\Sigma_{\Omega}$ {\em standard\/} se contiene le seguenti tre costanti primitive\index{costanti primitive, della logica HOL@costanti primitive, della logica \HOL{}}\index{costanti, nella logica HOL@costanti, nella logica \HOL{}!primitive, forma astratta di}: \[ {\imp}_{\ty{bool}\fun\ty{bool}\fun\ty{bool}} @@ -928,16 +928,16 @@ \subsection{Firme standard} \[ \hilbert_{(\alpha\fun\ty{bool})\fun\alpha} \] -L'interpretazione intesa di queste costanti che $\imp$ denota -l'implicazione, $=_{\sigma\fun\sigma\fun\ty{bool}}$ denota l'uguaglianza -sull'insieme denotato da $\sigma$, e -$\hilbert_{(\sigma\fun\ty{bool})\fun\sigma}$ denota una funzione di scelta -sull'insieme denotato da $\sigma$. Pi precisamente, un modello $M$ di +L'interpretazione intesa di queste costanti che $\imp$ denota +l'implicazione, $=_{\sigma\fun\sigma\fun\ty{bool}}$ denota l'uguaglianza +sull'insieme denotato da $\sigma$, e +$\hilbert_{(\sigma\fun\ty{bool})\fun\sigma}$ denota una funzione di scelta +sull'insieme denotato da $\sigma$. Pi precisamente, un modello $M$ di $\Sigma_{\Omega}$ sar chiamato {\em standard\/}\index{modelli standard, della logica HOL@modelli standard, della logica \HOL{}} se \begin{itemize} \item -$M({\imp},\bool\fun\bool\fun\bool)\in(\two\fun\two\fun\two)$ +$M({\imp},\bool\fun\bool\fun\bool)\in(\two\fun\two\fun\two)$ la funzione d'implicazione standard\index{implicazione, nella logica HOL@implicazione, nella logica \HOL{}!semantica formale della}, che manda $b,b'\in\two$ su \[ (b\imp b') = \left\{ \begin{array}{ll} @@ -949,7 +949,7 @@ \subsection{Firme standard} \item $M({=},\alpha\fun\alpha\fun\bool)\in\prod_{X\in{\cal U}}.X\fun -X\fun\two$ la funzione che assegna ad ogni $X\in{\cal U}$ +X\fun\two$ la funzione che assegna ad ogni $X\in{\cal U}$ la funzione di test dell'uguaglianza\index{uguaglianza, nella logica HOL@uguaglianza, nella logica \HOL{}!semantica formale della}, che manda $x,x'\in X$ a \[ (x=_{X}x') = \left\{ \begin{array}{ll} @@ -972,28 +972,28 @@ \subsection{Firme standard} \right.%} \] dove $f^{-1}\{1\}=\{x\in X : f(x)=1\}$. (Si noti che $f^{-1}\{1\}$ in -$\cal U$ quando non vuota, per la propriet {\bf Sub} -dell'universo $\cal U$ data nella Sezione~\ref{introduction}. La funzione +$\cal U$ quando non vuota, per la propriet {\bf Sub} +dell'universo $\cal U$ data nella Sezione~\ref{introduction}. La funzione $\ch$ data dalla propriet {\bf Choice}.) \end{itemize} -Si assumer da qui in avanti che le firme e i loro modelli sono +Si assumer da qui in avanti che le firme e i loro modelli sono standard. \medskip \noindent{\bf Nota\ } -Questa particolare scelta delle costanti primitive arbitraria. La +Questa particolare scelta delle costanti primitive arbitraria. La collezione standard delle costanti logiche include $\T$ (`vero'), $\F$ (`falso')\index{valori di verit, nella logica HOL@valori di verit, nella logica \HOL{}!forma astratta di}, $\imp$ (`implica'), $\wedge$ (`e'), $\vee$ -(`o'), $\neg$ (`non'), $\forall$ (`per tutti'), $\exists$ (`esiste'), -$=$ (` uguale'), $\iota$ (`il'), e $\hilbert$ (`un'). Questo -insieme ridondante, dal momento che pu essere definito (in un senso spiegato nella -Sezione~\ref{defs}) da vari sottoinsiemi. In pratica, -necessario lavorare con l'insieme completo delle costanti logiche, e il -particolare sottoinsieme preso come primitivo non importante. il lettore -interessato pu esplorare ulteriormente questo argomento leggendo il libro +(`o'), $\neg$ (`non'), $\forall$ (`per tutti'), $\exists$ (`esiste'), +$=$ (` uguale'), $\iota$ (`il'), e $\hilbert$ (`un'). Questo +insieme ridondante, dal momento che pu essere definito (in un senso spiegato nella +Sezione~\ref{defs}) da vari sottoinsiemi. In pratica, +necessario lavorare con l'insieme completo delle costanti logiche, e il +particolare sottoinsieme preso come primitivo non importante. il lettore +interessato pu esplorare ulteriormente questo argomento leggendo il libro di Andrews~\cite{Andrews} e i riferimenti che esso contiene. \medskip @@ -1021,9 +1021,9 @@ \subsection{Firme standard} (\lambda x_{\sigma}.\ t)$\\ \hline \end{tabular} \end{center} -Queste notazioni sono casi speciali di convenzioni generali di abbreviazione -supportate dal sistema \HOL{}. Le prime due sono infissi e la -terza un binder (si vedano le sezioni di \DESCRIPTION\/ sul parsing e +Queste notazioni sono casi speciali di convenzioni generali di abbreviazione +supportate dal sistema \HOL{}. Le prime due sono infissi e la +terza un binder (si vedano le sezioni di \DESCRIPTION\/ sul parsing e il pretty-printing). diff --git a/Manual/Translations/IT/Tutorial/combin.tex b/Manual/Translations/IT/Tutorial/combin.tex index 4fa381c46a..2da9d85301 100644 --- a/Manual/Translations/IT/Tutorial/combin.tex +++ b/Manual/Translations/IT/Tutorial/combin.tex @@ -13,29 +13,29 @@ \chapter{Esempio: Logica Combinatoria} \section{Introduzione} \label{sec:Introduction} -Questo piccolo caso di studio una formalizzazione di una logica -combinatoria (priva di variabili). Questa logica d'importanza fondamentale -nell'informatica teorica, ed ha una ricca teoria. L'esempio -si basa principalmente su uno sviluppo fatto da Tom Melham. Lo script -completo per lo sviluppo disponibile come \texttt{clScript.sml} nella -directory \texttt{examples/ind\_def} della distribuzione. E' -autosufficiente e cos include le risposte agli esercizi fissati al +Questo piccolo caso di studio una formalizzazione di una logica +combinatoria (priva di variabili). Questa logica d'importanza fondamentale +nell'informatica teorica, ed ha una ricca teoria. L'esempio +si basa principalmente su uno sviluppo fatto da Tom Melham. Lo script +completo per lo sviluppo disponibile come \texttt{clScript.sml} nella +directory \texttt{examples/ind\_def} della distribuzione. E' +autosufficiente e cos include le risposte agli esercizi fissati al termine di questo documento. -Le sessioni HOL assumono che la traccia Unicode sia \emph{accesa} (cos -come di default), il che significa che bench gli input possono essere scritti in -puro ASCII, l'output usa tuttavia degli eleganti caratteri Unicode (simboli come -$\forall$ e $\Rightarrow$). I simboli Unicode potrebbero essere usati anche +Le sessioni HOL assumono che la traccia Unicode sia \emph{accesa} (cos +come di default), il che significa che bench gli input possono essere scritti in +puro ASCII, l'output usa tuttavia degli eleganti caratteri Unicode (simboli come +$\forall$ e $\Rightarrow$). I simboli Unicode potrebbero essere usati anche nell'input. \section{Il tipo dei combinatori} \label{sec:Type-Combinators} -La prima cosa che dobbiamo fare definire il tipo dei -\emph{combinatori}. Di questi ce ne sono soltanto due, \KC{} e \SC, ma -dobbiamo anche essere in grado di \emph{combinarli}, e per questo abbiamo bisogno -di introdurre la nozione di applicazione. In mancanza di un simbolo ASCII +La prima cosa che dobbiamo fare definire il tipo dei +\emph{combinatori}. Di questi ce ne sono soltanto due, \KC{} e \SC, ma +dobbiamo anche essere in grado di \emph{combinarli}, e per questo abbiamo bisogno +di introdurre la nozione di applicazione. In mancanza di un simbolo ASCII migliore, useremo il cancelletto (\#) per rappresentare questo nella logica: \setcounter{sessioncount}{0} \begin{session} @@ -44,7 +44,7 @@ \section{Il tipo dei combinatori} > val it = () : unit \end{verbatim} \end{session} -Vogliamo anche che \# sia un infisso, cos lo impostiamo come uno stretto infisso +Vogliamo anche che \# sia un infisso, cos lo impostiamo come uno stretto infisso associativo a sinistra: \begin{session} \begin{verbatim} @@ -60,28 +60,28 @@ \section{Il tipo dei combinatori} \section{Regole di riduzione dei combinatori} \label{sec:Comb-Reduct} -La logica combinatoria lo studio di come valori di questo tipo possono evolversi -date varie regole che descrivono come cambiano. Di conseguenza, il nostro prossimo -passo di definire le riduzioni che i combinatori possono subire. Ci +La logica combinatoria lo studio di come valori di questo tipo possono evolversi +date varie regole che descrivono come cambiano. Di conseguenza, il nostro prossimo +passo di definire le riduzioni che i combinatori possono subire. Ci sono due regole base: \[\begin{array}{l@{\;\;\rightarrow\;\;}l} \KC\;x\;y & x\\ \SC\;f\;g\;x & (f x)(g x) \end{array}\] -Qui, nella nostra descrizione al di fuori di HOL, usiamo la giustapposizione al posto -del \#. Inoltre, la giustapposizione anche associativa a sinistra, cos che -$\con{K}\;x\;y$ dovrebbe essere letto come $\con{K}\;\#\;x\;\#\;y$ che a sua +Qui, nella nostra descrizione al di fuori di HOL, usiamo la giustapposizione al posto +del \#. Inoltre, la giustapposizione anche associativa a sinistra, cos che +$\con{K}\;x\;y$ dovrebbe essere letto come $\con{K}\;\#\;x\;\#\;y$ che a sua volta $(\con{K}\;\#\;x)\;\#\;y$. -Dato un termine nella logica, vogliamo che queste riduzioni siano in grado di essere eseguite -in qualsiasi punto, non solo al top level, cos abbiamo bisogno di due ulteriori +Dato un termine nella logica, vogliamo che queste riduzioni siano in grado di essere eseguite +in qualsiasi punto, non solo al top level, cos abbiamo bisogno di due ulteriori regole di congruenza:\[ \begin{array}{l} \infer{x\;y\;\;\rightarrow\;\;x'\;y}{x\;\;\rightarrow\;\;x'}\\[5mm] \infer{x\;y\;\;\rightarrow\;\;x\;y'}{y\;\;\rightarrow\;\;y'} \end{array}\] -In HOL, possiamo catturare questa relazione con una definizione induttiva. -Per prima cosa abbiamo bisogno di impostare il nostro simbolo freccia come un infisso per rendere ogni cosa +In HOL, possiamo catturare questa relazione con una definizione induttiva. +Per prima cosa abbiamo bisogno di impostare il nostro simbolo freccia come un infisso per rendere ogni cosa un p pi elegante \begin{session} \begin{verbatim} @@ -89,22 +89,22 @@ \section{Regole di riduzione dei combinatori} > val it = () : unit \end{verbatim} \end{session} -Rendiamo il nostro simbolo freccia non-associativo, rendendo di conseguenza un -errore di parsing scrivere \verb!x --> y --> z!. Sarebbe carino essere in grado -di scrivere questo e averlo con il significato di \verb!x --> y /\ y --> z!, ma questo al +Rendiamo il nostro simbolo freccia non-associativo, rendendo di conseguenza un +errore di parsing scrivere \verb!x --> y --> z!. Sarebbe carino essere in grado +di scrivere questo e averlo con il significato di \verb!x --> y /\ y --> z!, ma questo al momento non possibile con il parser di HOL. -Il nostro prossimo passo di definire di fatto la relazione con la -funzione \ml{xHol\_reln}. In aggiunta a una quotation che specifica le -regole per la nuova relazione, essa richiede un nome da usare come la radice per -i teoremi che essa dimostra. Utilizziamo la stringa \ml{"redn"}\footnote{La - funzione correlata \ml{Hol\_reln} pu essere usata se la scelta della radice da parte del - sistema accettabile. In questo caso, \ml{Hol\_reln} non pu gestire i - caratteri non-alfanumerici in \holtxt{-->} e sollever un +Il nostro prossimo passo di definire di fatto la relazione con la +funzione \ml{xHol\_reln}. In aggiunta a una quotation che specifica le +regole per la nuova relazione, essa richiede un nome da usare come la radice per +i teoremi che essa dimostra. Utilizziamo la stringa \ml{"redn"}\footnote{La + funzione correlata \ml{Hol\_reln} pu essere usata se la scelta della radice da parte del + sistema accettabile. In questo caso, \ml{Hol\_reln} non pu gestire i + caratteri non-alfanumerici in \holtxt{-->} e sollever un errore.}. -La funzione \ml{xHol\_reln} per -fare questo restituisce tre teoremi separati, e leghiamo il primo (il -teorema ``rules'') e il +La funzione \ml{xHol\_reln} per +fare questo restituisce tre teoremi separati, e leghiamo il primo (il +teorema ``rules'') e il terzo (il teorema ``cases'') \begin{session} \begin{alltt} @@ -129,10 +129,10 @@ \section{Regole di riduzione dei combinatori} \end{alltt} \end{session} -Oltre a dimostrare questi tre teoremi per noi, il pacchetto di +Oltre a dimostrare questi tre teoremi per noi, il pacchetto di definizioni induttiva li ha anche salvati sul disco. -Ora, usando il nostro teorema \texttt{redn\_rules} possiamo dimostrare singoli +Ora, usando il nostro teorema \texttt{redn\_rules} possiamo dimostrare singoli passi della nostra relazione di riduzione: \begin{session} \begin{verbatim} @@ -141,55 +141,55 @@ \section{Regole di riduzione dei combinatori} > val it = |- S # (K # x # x) --> S # x : thm \end{verbatim} \end{session} -Il sistema che abbiamo appena definito potente quanto il -$\lambda$-calcolo, le macchine di Turing, e tutti gli altri modelli standard +Il sistema che abbiamo appena definito potente quanto il +$\lambda$-calcolo, le macchine di Turing, e tutti gli altri modelli standard di computazione. -Un utile risultato circa la logica combinatoria che +Un utile risultato circa la logica combinatoria che \emph{confluente}. Si consideri il termine $\SC\;z\;(\KC\;\KC)\;(\KC\; y\; -x)$. Esso pu subire due riduzioni, a $\SC\;z\;(\KC\;\KC)\;y$ e anche -a $(z\;(\KC\;y\;x))\,(\KC\;\KC\;(\KC\;y\;x))$. Fare queste due scelte -di riduzione significa che da questo punto in poi i termini hanno due -storie completamente separate? In parole povere, essere confluente +x)$. Esso pu subire due riduzioni, a $\SC\;z\;(\KC\;\KC)\;y$ e anche +a $(z\;(\KC\;y\;x))\,(\KC\;\KC\;(\KC\;y\;x))$. Fare queste due scelte +di riduzione significa che da questo punto in poi i termini hanno due +storie completamente separate? In parole povere, essere confluente significa che la risposta a questa domanda \emph{no}. \section{Chiusura transitiva e confluenza} \label{sec:Transitive-Clos-Conf} -Una nozione cruciale a quella di confluenza quella di \emph{chiusura - transitiva}. Abbiamo definito un sistema che si evolve specificando come -un valore algebrico si pu evolvere in possibili valori successivi in un singolo -passo. La prossima domanda naturale di chiedere per una caratterizzazione +Una nozione cruciale a quella di confluenza quella di \emph{chiusura + transitiva}. Abbiamo definito un sistema che si evolve specificando come +un valore algebrico si pu evolvere in possibili valori successivi in un singolo +passo. La prossima domanda naturale di chiedere per una caratterizzazione dell'evoluzione in uno o pi passi della relazione $\rightarrow$. -Di fatto, definiremo una relazione che vale tra due valori se -il secondo pu essere raggiunto dal primo in zero o pi passi. Questa - la \emph{chiusura riflessiva, transitiva} della nostra relazione originaria. -Comunque, piuttosto che legare la nostra definizione alla nostra relazione originaria, -svilupperemo questa nozione in modo indipendente e dimostreremo una variet di -risultati che sono veri di ogni sistema, non soltanto del nostro sistema di +Di fatto, definiremo una relazione che vale tra due valori se +il secondo pu essere raggiunto dal primo in zero o pi passi. Questa + la \emph{chiusura riflessiva, transitiva} della nostra relazione originaria. +Comunque, piuttosto che legare la nostra definizione alla nostra relazione originaria, +svilupperemo questa nozione in modo indipendente e dimostreremo una variet di +risultati che sono veri di ogni sistema, non soltanto del nostro sistema di logica combinatoria. -Cos, iniziamo la nostra digressione astratta con un'altra definizione -induttiva. La nostra nuova costante \con{RTC}, tale che -$\con{RTC}\;R\;x\;y$ vera se possibile andare da $x$ a $y$ -con zero o pi ``passi'' della relazione $R$. (La notazione -standard per $\con{RTC}\;R$ $R^*$.) Possiamo esprimere quest'idea con -solo due regole. La prima \[ \infer{\con{RTC}\;R\;x\;x}{} \] dice -che sempre possibile andare da $x$ a $x$ in zero o pi +Cos, iniziamo la nostra digressione astratta con un'altra definizione +induttiva. La nostra nuova costante \con{RTC}, tale che +$\con{RTC}\;R\;x\;y$ vera se possibile andare da $x$ a $y$ +con zero o pi ``passi'' della relazione $R$. (La notazione +standard per $\con{RTC}\;R$ $R^*$.) Possiamo esprimere quest'idea con +solo due regole. La prima \[ \infer{\con{RTC}\;R\;x\;x}{} \] dice +che sempre possibile andare da $x$ a $x$ in zero o pi passi. La seconda \[ \infer{\con{RTC}\;R\;x\;z}{R\;x\;y\qquad\con{RTC}\;R\;y\;z} -\] dice che se si pu fare un singolo passo da $x$ a $y$, e poi -zero o pi passi per andare da $y$ a $z$, allora possibile fare -zero o pi passi per andare da $x$ a $z$. La realizzazione di +\] dice che se si pu fare un singolo passo da $x$ a $y$, e poi +zero o pi passi per andare da $y$ a $z$, allora possibile fare +zero o pi passi per andare da $x$ a $z$. La realizzazione di queste regole in HOL di nuovo diretta. -(Come accade, \con{RTC} una costante gi definita nel conteso -in cui stiamo lavorando (si trova in \texttt{relationTheory}), cos la -nasconderemo dalla vista prima di iniziare. Evitiamo cos messaggi che ci dicono -che stiamo immettendo termini ambigui. Le ambiguit verrebbero sempre -risolte in favore della definizione pi recente, ma i warning +(Come accade, \con{RTC} una costante gi definita nel conteso +in cui stiamo lavorando (si trova in \texttt{relationTheory}), cos la +nasconderemo dalla vista prima di iniziare. Evitiamo cos messaggi che ci dicono +che stiamo immettendo termini ambigui. Le ambiguit verrebbero sempre +risolte in favore della definizione pi recente, ma i warning sono fastidiosi.) \begin{session} \begin{alltt} @@ -207,9 +207,9 @@ \section{Chiusura transitiva e confluenza} \(\exists\)y. R a0 y \(\land\) RTC R y a1 : thm \end{alltt} \end{session} -Ora torniamo indietro alla nozione di confluenza. Vogliamo che questo significhi -qualcosa del tipo: ``bench un sistema possa prendere differenti percorsi a breve -scadenza, questi due percorsi possono sempre finire nello stesso posto''. +Ora torniamo indietro alla nozione di confluenza. Vogliamo che questo significhi +qualcosa del tipo: ``bench un sistema possa prendere differenti percorsi a breve +scadenza, questi due percorsi possono sempre finire nello stesso posto''. Questo suggerisce che definiamo confluente nel modo seguente: \begin{session} \begin{verbatim} @@ -219,7 +219,7 @@ \section{Chiusura transitiva e confluenza} ?u. RTC R y u /\ RTC R z u`; \end{verbatim} \end{session} -Questa propriet afferma di $R$ che possiamo ``completare il diamante''; +Questa propriet afferma di $R$ che possiamo ``completare il diamante''; se abbiamo \begin{center} \begin{tikzpicture}[scale=.8,transform shape] @@ -246,8 +246,8 @@ \section{Chiusura transitiva e confluenza} \end{tikzpicture} \end{center} -Un'interessante propriet delle relazioni confluenti che da qualsiasi punto -iniziale esse producono non pi di una \emph{forma normale}, dove una forma +Un'interessante propriet delle relazioni confluenti che da qualsiasi punto +iniziale esse producono non pi di una \emph{forma normale}, dove una forma normale un valore da cui non si possono pi fare ulteriori passi. \begin{session} \begin{alltt} @@ -257,8 +257,8 @@ \section{Chiusura transitiva e confluenza} > val normform_def = |- \(\forall\)R x. normform R x \(\Leftrightarrow\) \(\forall\)y. \(\neg\)R x y : thm \end{alltt} \end{session} -In altre parole, un sistema ha un $R$-forma normale in $x$ se non ci sono -connessioni attraverso $R$ ad altri valori. (Avremmo potuto scrivere +In altre parole, un sistema ha un $R$-forma normale in $x$ se non ci sono +connessioni attraverso $R$ ad altri valori. (Avremmo potuto scrivere \verb!~?y. R x y! come nostro lato destro per la definizione di sopra.) Possiamo ora dimostrare il seguente: @@ -295,7 +295,7 @@ \section{Chiusura transitiva e confluenza} 4. normform R z \end{alltt} \end{session} - La nostra propriet confluenza ora l'assunzione 0, e possiamo usarla per + La nostra propriet confluenza ora l'assunzione 0, e possiamo usarla per dedurre che c' un $u$ alla base del diamante: \begin{session} \begin{alltt} @@ -315,11 +315,11 @@ \section{Chiusura transitiva e confluenza} 6. RTC R z u \end{alltt} \end{session} - Cos, da $y$ possiamo fare zero o pi passi per arrivare a $u$ e - analogamente da $z$. Ma, sappiamo anche che siamo in una $R$-forma - normale sia in $y$ sia in $z$. Non possiamo fare alcun passo da - questi valori. Possiamo concludere sia che $u = y$ sia che $u = z$, e - questo a sua volta significa che $y = z$, che il nostro goal. Cos possiamo + Cos, da $y$ possiamo fare zero o pi passi per arrivare a $u$ e + analogamente da $z$. Ma, sappiamo anche che siamo in una $R$-forma + normale sia in $y$ sia in $z$. Non possiamo fare alcun passo da + questi valori. Possiamo concludere sia che $u = y$ sia che $u = z$, e + questo a sua volta significa che $y = z$, che il nostro goal. Cos possiamo concludere con \begin{session} \begin{alltt} @@ -337,7 +337,7 @@ \section{Chiusura transitiva e confluenza} (y = z) \end{alltt} \end{session} -Impacchettando cos da rimuovere i comandi del pacchetto sub-goal, possiamo +Impacchettando cos da rimuovere i comandi del pacchetto sub-goal, possiamo dimostrare e salvare il teorema per l'uso futuro con: \begin{session} \begin{verbatim} @@ -353,8 +353,8 @@ \section{Chiusura transitiva e confluenza} \end{session} \eos{} -Chiaramente la confluenza una propriet interessante per un sistema. La -domanda come potremmo riuscire a dimostrarla. Iniziamo definendo +Chiaramente la confluenza una propriet interessante per un sistema. La +domanda come potremmo riuscire a dimostrarla. Iniziamo definendo la propriet diamante che abbiamo usato nella definizione di confluenza. \begin{session} \begin{alltt} @@ -367,8 +367,8 @@ \section{Chiusura transitiva e confluenza} : thm \end{alltt} \end{session} - Ora chiaramente abbiamo che la confluenza di una relazione equivalente alla - chiusura riflessiva, transitiva di quella relazione che ha la + Ora chiaramente abbiamo che la confluenza di una relazione equivalente alla + chiusura riflessiva, transitiva di quella relazione che ha la propriet diamante. \begin{session} \begin{verbatim} @@ -378,11 +378,11 @@ \section{Chiusura transitiva e confluenza} RW_TAC std_ss [confluent_def, diamond_def]); \end{verbatim} \end{session} - Fin qui tutto bene. Come possiamo poi mostrare la propriet diamante per - $\con{RTC}\;R$? La risposta che salta alla mente di sperare che se - la relazione originale ha la propriet diamante, allora magari anche la - chiusura riflessiva, transitiva l'avr. Il teorema che vogliamo - \[ \con{diamond}\;R \supset \con{diamond}\,(\con{RTC}\;R)\] Graficmente, + Fin qui tutto bene. Come possiamo poi mostrare la propriet diamante per + $\con{RTC}\;R$? La risposta che salta alla mente di sperare che se + la relazione originale ha la propriet diamante, allora magari anche la + chiusura riflessiva, transitiva l'avr. Il teorema che vogliamo + \[ \con{diamond}\;R \supset \con{diamond}\,(\con{RTC}\;R)\] Graficmente, questo sperare che da \[\xymatrix @R=5mm @C=2.5mm { & x \ar[dl] \ar[dr] & \\ @@ -393,9 +393,9 @@ \section{Chiusura transitiva e confluenza} & & y \ar@{.>}[dr] \ar@{-->}[ddll] & & z \ar@{.>}[dl] \ar@{-->}[ddrr] \\ & & & u \\ p \ar@{.>}[dddrrr] & & & & & & q \ar@{.>}[dddlll] \\ \\ \\ -& & & r}\] dove le linee tratteggiate indicano che questi passi (da $x$ a $p$, -per esempio) stanno usando $\con{RTC}\;R$. La presenza di due istanze -di $\con{RTC}\;R$ un'indicazione che questa dimostrazione richieder due +& & & r}\] dove le linee tratteggiate indicano che questi passi (da $x$ a $p$, +per esempio) stanno usando $\con{RTC}\;R$. La presenza di due istanze +di $\con{RTC}\;R$ un'indicazione che questa dimostrazione richieder due induzioni. Con la prima dimostreremo \[\xymatrix @R=4mm @C=2mm { & & & x \ar[dl] \ar[dr] & \\ @@ -403,18 +403,18 @@ \section{Chiusura transitiva e confluenza} & & & u \ar@{.>}[ddll] \\ p \ar@{.>}[dr] \\ & r}\] -In altre parole, vogliamo mostrare che se facciamo un passo in una -direzione (verso $z$) e molti altri passi in un'altra (verso $p$), allora la -propriet diamante per $R$ ci garantir l'esistenza di $r$, +In altre parole, vogliamo mostrare che se facciamo un passo in una +direzione (verso $z$) e molti altri passi in un'altra (verso $p$), allora la +propriet diamante per $R$ ci garantir l'esistenza di $r$, verso cui saremo in grado di fare molti passi sia da $p$ sia da $z$. -Facciamo un p d'attenzione ad esprimere il goal cos che dopo aver eliminato -l'assunzione pi esterna (che $R$ ha la propriet diamante), esso si accorder con il -principio di induzione per \con{RTC}\footnote{In questa e nelle seguenti - dimostrazioni usando il pacchetto sub-goal, presenteremo il gestore di dimostrazione - come se il goal da dimostrare fosse il primo in questo stack. In - altre parole, abbiamo fatto una \texttt{dropn 1;} dopo ogni dimostrazione - di successo per rimuovere l'evidenza del goal vecchio. In pratica, non c' +Facciamo un p d'attenzione ad esprimere il goal cos che dopo aver eliminato +l'assunzione pi esterna (che $R$ ha la propriet diamante), esso si accorder con il +principio di induzione per \con{RTC}\footnote{In questa e nelle seguenti + dimostrazioni usando il pacchetto sub-goal, presenteremo il gestore di dimostrazione + come se il goal da dimostrare fosse il primo in questo stack. In + altre parole, abbiamo fatto una \texttt{dropn 1;} dopo ogni dimostrazione + di successo per rimuovere l'evidenza del goal vecchio. In pratica, non c' nulla di male nel lasciare questi goal nello stack del gestore di dimostrazione.}. \begin{session} \begin{alltt} @@ -432,8 +432,8 @@ \section{Chiusura transitiva e confluenza} \(\forall\)x p. RTC R x p \(\Rightarrow\) \(\forall\)z. R x z \(\Rightarrow\) \(\exists\)u. RTC R p u \(\land\) RTC R z u \end{alltt} \end{session} -Per prima cosa, eliminiamo l'assunzione della propriet diamante (due cose devono essere -eliminate: il quantificatore universale pi esterno e l'antecedente +Per prima cosa, eliminiamo l'assunzione della propriet diamante (due cose devono essere +eliminate: il quantificatore universale pi esterno e l'antecedente dell'implicazione): \begin{session} \begin{alltt} @@ -446,11 +446,11 @@ \section{Chiusura transitiva e confluenza} diamond R \end{alltt} \end{session} -Ora possiamo usare il principio d'induzione per la chiusura riflessiva e transitiva (in alternativa, eseguiamo una ``regola d'induzione''). -Per far questo, usiamo il comando \ml{Induct\_on} che usato anche per fare -un'induzione strutturale su tipi di dati algebrici (come numeri e -liste). -Forniamo il nome della costante il cui principio d'induzione vogliamo +Ora possiamo usare il principio d'induzione per la chiusura riflessiva e transitiva (in alternativa, eseguiamo una ``regola d'induzione''). +Per far questo, usiamo il comando \ml{Induct\_on} che usato anche per fare +un'induzione strutturale su tipi di dati algebrici (come numeri e +liste). +Forniamo il nome della costante il cui principio d'induzione vogliamo usare, e la tattica fa il resto: \begin{session} \begin{alltt} @@ -466,7 +466,7 @@ \section{Chiusura transitiva e confluenza} diamond R \end{alltt} \end{session} -Eseguiamo uno strip del goal il pi possibile con l'obiettivo di rendere ci che +Eseguiamo uno strip del goal il pi possibile con l'obiettivo di rendere ci che rimane da dimostrare pi facile da vedere: \begin{session} \begin{alltt} @@ -488,13 +488,13 @@ \section{Chiusura transitiva e confluenza} 1. R x z \end{alltt} \end{session} -Questo primo goal semplice. Esso corrisponde al caso dove i passi -principali da $x$ a $p$ sono di fatto nessun passo del tutto, e $p$ e $x$ -sono di fatto lo stesso posto. Nell'altra direzione, $x$ ha fatto -un passo verso $z$, e abbiamo bisogno di trovare un qualche posto raggiungibile in zero o -pi passi sia da $x$ sia da $z$. Dato quello che conosciamo fino ad ora, l'unico -candidato lo stesso $z$. Di fatto, non abbiamo nemmeno bisogno di fornire questo -testimone in modo esplicito. \texttt{PROVE\_TAC} lo trover per noi, purch +Questo primo goal semplice. Esso corrisponde al caso dove i passi +principali da $x$ a $p$ sono di fatto nessun passo del tutto, e $p$ e $x$ +sono di fatto lo stesso posto. Nell'altra direzione, $x$ ha fatto +un passo verso $z$, e abbiamo bisogno di trovare un qualche posto raggiungibile in zero o +pi passi sia da $x$ sia da $z$. Dato quello che conosciamo fino ad ora, l'unico +candidato lo stesso $z$. Di fatto, non abbiamo nemmeno bisogno di fornire questo +testimone in modo esplicito. \texttt{PROVE\_TAC} lo trover per noi, purch noi gli diciamo quali sono le regole che governano \con{RTC}: \begin{session} \begin{alltt} @@ -514,9 +514,9 @@ \section{Chiusura transitiva e confluenza} 4. R x z \end{alltt} \end{session} - E cosa facciamo di questo goal restante? Le assunzioni uno e quattro - tra di loro sono la cima di un $R$-diamante. Usiamo il fatto - che abbiamo la propriet diamante per $R$ e deduciamo che + E cosa facciamo di questo goal restante? Le assunzioni uno e quattro + tra di loro sono la cima di un $R$-diamante. Usiamo il fatto + che abbiamo la propriet diamante per $R$ e deduciamo che esiste un $v$ verso cui $x'$ e $z$ possono fare entrambi singoli passi: \begin{session} \begin{alltt} @@ -536,11 +536,11 @@ \section{Chiusura transitiva e confluenza} 6. R z v \end{alltt} \end{session} -Ora possiamo applicare le nostre ipotesi d'induzione (assunzione 3) per completare -la lunga, striscia asimmetrica del diamante. Concluderemo che -c' un $u$ tale che $\con{RTC}\;R\;p\;u$ e $\con{RTC}\;R\;v\;u$. Di -fatto abbiamo bisogno un $u$ tale che $\con{RTC}\;R\;z\;u$, ma poich c' -un singolo passo-$R$ tra $z$ e $v$ abbiamo anche quello allo stesso modo. Tutto ci +Ora possiamo applicare le nostre ipotesi d'induzione (assunzione 3) per completare +la lunga, striscia asimmetrica del diamante. Concluderemo che +c' un $u$ tale che $\con{RTC}\;R\;p\;u$ e $\con{RTC}\;R\;v\;u$. Di +fatto abbiamo bisogno un $u$ tale che $\con{RTC}\;R\;z\;u$, ma poich c' +un singolo passo-$R$ tra $z$ e $v$ abbiamo anche quello allo stesso modo. Tutto ci di cui abbiamo bisogno di fornire a \texttt{PROVE\_TAC} sono le regole per \con{RTC}: \begin{session} \begin{alltt} @@ -556,7 +556,7 @@ \section{Chiusura transitiva e confluenza} \(\forall\)x p. RTC R x p \(\Rightarrow\) \(\forall\)z. R x z \(\Rightarrow\) \(\exists\)u. RTC R p u \(\land\) RTC R z u \end{alltt} \end{session} - Di nuovo possiamo (e dovremmo) impacchettare il lemma, evitando i + Di nuovo possiamo (e dovremmo) impacchettare il lemma, evitando i comandi del pacchetto sub-goal: \begin{session} \begin{verbatim} @@ -576,14 +576,14 @@ \section{Chiusura transitiva e confluenza} \end{session} \eos{} -Ora possiamo spostarci a dimostrare che se $R$ ha la propriet diamante, allora +Ora possiamo spostarci a dimostrare che se $R$ ha la propriet diamante, allora anche $\con{RTC}\;R$. Vogliamo dimostrare questo di nuovo per induzione. E' molto forte la tentazione di affermare il goal come l'ovvio \[ \con{diamond}\;R\supset\con{diamond}\,(\con{RTC}\;R) -\] ma cos facendo render di fatto pi difficile applicare il principio -d'induzione quando il momento giusto. E' meglio partire con una -dichiarazione del goal che molto vicina nella forma al principio -d'induzione. Cos, espandiamo manualmente il significato di \con{diamond} e dichiariamo +\] ma cos facendo render di fatto pi difficile applicare il principio +d'induzione quando il momento giusto. E' meglio partire con una +dichiarazione del goal che molto vicina nella forma al principio +d'induzione. Cos, espandiamo manualmente il significato di \con{diamond} e dichiariamo il nostro prossimo goal cos: \begin{session} \begin{alltt} @@ -600,7 +600,7 @@ \section{Chiusura transitiva e confluenza} \(\forall\)x y. RTC R x y \(\Rightarrow\) \(\forall\)z. RTC R x z \(\Rightarrow\) \(\exists\)u. RTC R y u \(\land\) RTC R z u \end{alltt} \end{session} - Di nuovo, eliminiamo l'assunzione della propriet diamante, applichiamo il + Di nuovo, eliminiamo l'assunzione della propriet diamante, applichiamo il principio d'induzione, ed eseguiamo \ml{STRIP_TAC} ripetutamente: \begin{session} \begin{alltt} @@ -622,7 +622,7 @@ \section{Chiusura transitiva e confluenza} 1. RTC R x z \end{alltt} \end{session} -Il primo goal di nuovo uno facile, corrispondendo al caso in cui +Il primo goal di nuovo uno facile, corrispondendo al caso in cui il percorso da $x$ a $y$ stato uno senza alcun passo. \begin{session} \begin{alltt} @@ -643,8 +643,8 @@ \section{Chiusura transitiva e confluenza} 4. RTC R x z \end{alltt} \end{session} -Il goal molto simile a quello che abbiamo visto in precedenza. Abbiamo la punta di -un diamante (``asimmetrico'') nelle assunzioni 1 e 4, cos possiamo dedurre +Il goal molto simile a quello che abbiamo visto in precedenza. Abbiamo la punta di +un diamante (``asimmetrico'') nelle assunzioni 1 e 4, cos possiamo dedurre l'esistenza di una destinazione comune per $x'$ e $z$: \begin{session} \begin{alltt} @@ -664,17 +664,17 @@ \section{Chiusura transitiva e confluenza} 6. RTC R z v \end{alltt} \end{session} - A questo punto nell'ultima dimostrazione eravamo stati in grado di concludere il tutto - appellandoci soltanto alle regole per \con{RTC}. Questa volta non - cos semplice. Quando usiamo l'ipotesi d'induzione - (assunzione 3), possiamo concludere che c' un $u$ per cui sia - $y$ sia $v$ si possono connettere in zero o pi passi, ma al fine di - mostrare che questo $u$ raggiungibile da $z$, abbiamo bisogno di essere in grado di - concludere $\con{RTC}\;R\;z\;u$ quando conosciamo che - $\con{RTC}\;R\;z\;v$ (assunzione 6 di sopra) e - $\con{RTC}\;R\;v\;u$ (la nostra conseguenza dell'ipotesi - d'induzione). Lasciamo la dimostrazione di questo risultato generale come un - esercizio, e qui assumiamo che essa gi stata dimostrato come il teorema + A questo punto nell'ultima dimostrazione eravamo stati in grado di concludere il tutto + appellandoci soltanto alle regole per \con{RTC}. Questa volta non + cos semplice. Quando usiamo l'ipotesi d'induzione + (assunzione 3), possiamo concludere che c' un $u$ per cui sia + $y$ sia $v$ si possono connettere in zero o pi passi, ma al fine di + mostrare che questo $u$ raggiungibile da $z$, abbiamo bisogno di essere in grado di + concludere $\con{RTC}\;R\;z\;u$ quando conosciamo che + $\con{RTC}\;R\;z\;v$ (assunzione 6 di sopra) e + $\con{RTC}\;R\;v\;u$ (la nostra conseguenza dell'ipotesi + d'induzione). Lasciamo la dimostrazione di questo risultato generale come un + esercizio, e qui assumiamo che essa gi stata dimostrato come il teorema \texttt{RTC\_RTC}. \begin{session} \begin{alltt} @@ -689,7 +689,7 @@ \section{Chiusura transitiva e confluenza} \(\forall\)x y. RTC R x y \(\Rightarrow\) \(\forall\)z. RTC R x z \(\Rightarrow\) \(\exists\)u. RTC R y u \(\land\) RTC R z u \end{alltt} \end{session} -Possiamo impacchettare questo risultato come un lemma e poi dimostrare la versione +Possiamo impacchettare questo risultato come un lemma e poi dimostrare la versione pi elegante direttamente: \begin{session} \begin{verbatim} @@ -713,47 +713,47 @@ \section{Chiusura transitiva e confluenza} \section{Di nuovo sui combinatori} \label{sec:Return-to-Land} -Ora, siamo nella posizione di ritornare all'oggetto reale dello studio e -dimostrare la confluenza per la logica combinatoria. Abbiamo fatto uno sviluppo +Ora, siamo nella posizione di ritornare all'oggetto reale dello studio e +dimostrare la confluenza per la logica combinatoria. Abbiamo fatto uno sviluppo astratto e stabilito che\[ \begin{array}{ccccc} \con{diamond}\;R & \supset & \con{diamond}\,(\con{RTC}\;R)\\ & & \land\\ & & \con{diamond}\,(\con{RTC}\;R) & \equiv & \con{confluent}\;R\\ \end{array} -\] (Abbiamo anche stabilito un paio di utili risultati lungo +\] (Abbiamo anche stabilito un paio di utili risultati lungo la strada.) -\newcommand{\topk}{\KC\;\SC\;(\KC\;\KC\;\KC)} Purtroppo, non si da il -caso che $\rightarrow$, la nostra relazione di un passo per i combinatori, abbia -la propriet diamante. Un controesempio $\topk$. La sua evoluzione possibile +\newcommand{\topk}{\KC\;\SC\;(\KC\;\KC\;\KC)} Purtroppo, non si da il +caso che $\rightarrow$, la nostra relazione di un passo per i combinatori, abbia +la propriet diamante. Un controesempio $\topk$. La sua evoluzione possibile pu essere descritta graficamente: \[\xymatrix @R=5mm @C=2.5mm { & \topk \ar[dl] \ar[dr] & \\ \SC & & \KC\;\SC\;\KC \ar[dl] \\ & \SC}\] -Se avessimo la propriet diamante, sarebbe possibile trovare una destinazione -comune per $\KC\;\SC\;\KC$ e $\SC$. Tuttavia, \SC{} non ammette -alcuna riduzione di sorta, cos non c' una destinazione -comune\footnote{Di fatto il nostro contro esempio pi complicato - del necessario. Il fatto che $\KC\;\SC\;\KC$ abbia una +Se avessimo la propriet diamante, sarebbe possibile trovare una destinazione +comune per $\KC\;\SC\;\KC$ e $\SC$. Tuttavia, \SC{} non ammette +alcuna riduzione di sorta, cos non c' una destinazione +comune\footnote{Di fatto il nostro contro esempio pi complicato + del necessario. Il fatto che $\KC\;\SC\;\KC$ abbia una riduzione alla forma normale $\SC$ agisce anche come un contro esempio. Puoi vedere perch?}. Questo un problema. Dovremo prendere un altro approccio. -Definiremo un'altra strategia di riduzione (\emph{riduzione parallela}), -e dimostreremo che la sua chiusura riflessiva, transitiva di fatto la stessa -relazione della nostra chiusura riflessiva, transitiva originaria. Poi -mostreremo anche che la riduzione parallela ha la propriet diamante. Questo -stabilir che anche la sua chiusura riflessiva transitiva ce l'ha. -Poi, dal momento che sono la stessa relazione, avremo che la -chiusura riflessiva, transitiva della nostra relazione originaria ha la propriet +Definiremo un'altra strategia di riduzione (\emph{riduzione parallela}), +e dimostreremo che la sua chiusura riflessiva, transitiva di fatto la stessa +relazione della nostra chiusura riflessiva, transitiva originaria. Poi +mostreremo anche che la riduzione parallela ha la propriet diamante. Questo +stabilir che anche la sua chiusura riflessiva transitiva ce l'ha. +Poi, dal momento che sono la stessa relazione, avremo che la +chiusura riflessiva, transitiva della nostra relazione originaria ha la propriet diamante, e di conseguenza, la nostra relazione originaria sar confluente. \subsection{Riduzione parallela} \label{sec:Parallel-Reduction} -La nostra nuova relazione permette l'occorrenza di un qualsiasi numero di riduzioni -in parallelo. Usiamo il simbolo \texttt{-||->} per indicare la riduzione parallela +La nostra nuova relazione permette l'occorrenza di un qualsiasi numero di riduzioni +in parallelo. Usiamo il simbolo \texttt{-||->} per indicare la riduzione parallela a causa delle sue linee parallele: \begin{session} \begin{verbatim} @@ -761,13 +761,13 @@ \subsection{Riduzione parallela} > val it = () : unit \end{verbatim} \end{session} - Poi possiamo definire la riduzione parallela stessa. Le regole appaiono molto - simili a quelle per $\rightarrow$. La differenza che - permettiamo la transizione riflessiva, e diciamo che un'applicazione di - $x\;u$ pu essere trasformata in $y\;v$ se ci sono trasformazioni - che portano $x$ in $y$ e $u$ in $v$. Questo il motivo per cui dobbiamo avere - incidentalmente la riflessivit. Senza di essa, un termine come - $(\KC\;x\;y)\,\KC$ non si potrebbe ridurre perch mentre il lato sinistro + Poi possiamo definire la riduzione parallela stessa. Le regole appaiono molto + simili a quelle per $\rightarrow$. La differenza che + permettiamo la transizione riflessiva, e diciamo che un'applicazione di + $x\;u$ pu essere trasformata in $y\;v$ se ci sono trasformazioni + che portano $x$ in $y$ e $u$ in $v$. Questo il motivo per cui dobbiamo avere + incidentalmente la riflessivit. Senza di essa, un termine come + $(\KC\;x\;y)\,\KC$ non si potrebbe ridurre perch mentre il lato sinistro dell'applicazione ($\KC\;x\;y$) si pu ridurre, il suo lato destro non pu. \begin{session} \begin{alltt} @@ -798,14 +798,14 @@ \subsection{Riduzione parallela} \subsection{Usare \con{RTC}} \label{sec:Using-RTC} -Ora possiamo impostare un'elegante sintassi per le chiusure riflessiva e -transitiva delle nostre due relazioni. Useremo per entrambe dei simbolo ASCII -che consistono del simbolo originario seguito da un asterisco. Si noti -anche come, definendo le due relazioni, dobbiamo usare il -carattere \texttt{\$} per effettuare l'``escape'' delle normali fixity dei simboli. Questo - esattamente analogo al modo in cui usata la parola chiave \texttt{op} -dell'ML. Per prima cosa creiamo il simbolo desiderato per la sintassi concreta, -e quindi ne effettuiamo l'``overload'' cos che il parser lo espander alla forma +Ora possiamo impostare un'elegante sintassi per le chiusure riflessiva e +transitiva delle nostre due relazioni. Useremo per entrambe dei simbolo ASCII +che consistono del simbolo originario seguito da un asterisco. Si noti +anche come, definendo le due relazioni, dobbiamo usare il +carattere \texttt{\$} per effettuare l'``escape'' delle normali fixity dei simboli. Questo + esattamente analogo al modo in cui usata la parola chiave \texttt{op} +dell'ML. Per prima cosa creiamo il simbolo desiderato per la sintassi concreta, +e quindi ne effettuiamo l'``overload'' cos che il parser lo espander alla forma desiderata. \begin{session} \begin{verbatim} @@ -827,7 +827,7 @@ \subsection{Usare \con{RTC}} > val it = () : unit \end{verbatim} \end{session} -Incidentalmente, in congiunzione con \texttt{PROVE} possiamo ora +Incidentalmente, in congiunzione con \texttt{PROVE} possiamo ora dimostrare automaticamente catene di riduzioni relativamente lunghe. \begin{session} \begin{verbatim} @@ -849,8 +849,8 @@ \subsection{Usare \con{RTC}} \subsection{Dimostrare che le \con{RTC} sono le stesse} \label{sec:Proving-RTCs-same} -Iniziamo con la direzione pi facile, e mostriamo che ogni cosa che in -$\rightarrow^*$ in $\mathpredn^*$. Poich +Iniziamo con la direzione pi facile, e mostriamo che ogni cosa che in +$\rightarrow^*$ in $\mathpredn^*$. Poich \con{RTC} monotona (fatto che lasciato da dimostrare al lettore), possiamo ridurre questo per mostrare che $x\rightarrow y\supset x\mathpredn y$. @@ -888,8 +888,8 @@ \subsection{Dimostrare che le \con{RTC} sono le stesse} \(\forall\)f g x. S # f # g # x -||-> f # x # (g # x) \end{alltt} \end{session} -Avremmo potuto dividere la congiunzione di 4 congiunti in quattro goal, ma non -c' una vera necessit. E' abbastanza chiaro che ciascuno segue immediatamente dalle +Avremmo potuto dividere la congiunzione di 4 congiunti in quattro goal, ma non +c' una vera necessit. E' abbastanza chiaro che ciascuno segue immediatamente dalle regole per la riduzione parallela. \begin{session} \begin{alltt} @@ -915,11 +915,11 @@ \subsection{Dimostrare che le \con{RTC} sono le stesse} \end{session} \eos{} -La nostra prossima dimostrazione nell'altra direzione. Dovrebbe essere chiaro che -questa volta non saremo in grado di ricorrere semplicemente alla monotonicit di -\con{RTC}; un passo della relazione di riduzione parallela non pu essere riflesso -da un passo della relazione di riduzione originale. E' chiaro che -rispecchiare un singolo passo della relazione di riduzione parallela potrebbe richiedere molti +La nostra prossima dimostrazione nell'altra direzione. Dovrebbe essere chiaro che +questa volta non saremo in grado di ricorrere semplicemente alla monotonicit di +\con{RTC}; un passo della relazione di riduzione parallela non pu essere riflesso +da un passo della relazione di riduzione originale. E' chiaro che +rispecchiare un singolo passo della relazione di riduzione parallela potrebbe richiedere molti passi della relazione originale. Dimostriamo dunque questo: \begin{session} \begin{alltt} @@ -931,7 +931,7 @@ \subsection{Dimostrare che le \con{RTC} sono le stesse} \(\forall\)x y. x -||-> y \(\Rightarrow\) x -->* y \end{alltt} \end{session} -Questa volta la nostra induzione sar sulle regole che definiscono la relazione +Questa volta la nostra induzione sar sulle regole che definiscono la relazione di riduzione parallela. \begin{session} \begin{alltt} @@ -946,15 +946,15 @@ \subsection{Dimostrare che le \con{RTC} sono le stesse} \(\forall\)f g x. S # f # g # x -->* f # x # (g # x) \end{alltt} \end{session} - Qui ci sono quattro congiunti, e dovrebbe essere chiaro che nessuno tranne - il secondo pu essere dimostrato immediatamente ricorrendo alle regole per - la chiusura transitiva e per la stessa $\rightarrow$. Potremmo + Qui ci sono quattro congiunti, e dovrebbe essere chiaro che nessuno tranne + il secondo pu essere dimostrato immediatamente ricorrendo alle regole per + la chiusura transitiva e per la stessa $\rightarrow$. Potremmo dividere le congiunzioni ed inserire un ramo \texttt{THENL}. - Tuttavia, avremmo bisogno di ripetere la stessa tattica tre volte per - chiudere velocemente tre dei quattro rami. Piuttosto, usiamo il - tatticale \texttt{TRY} per provare ad applicare la stessa tattica a tutti e quattro - i rami. Se la nostra tattica fallisce sul ramo \#2, come ci aspettiamo, - \texttt{TRY} ci protegger da questo fallimento e ci permetter di + Tuttavia, avremmo bisogno di ripetere la stessa tattica tre volte per + chiudere velocemente tre dei quattro rami. Piuttosto, usiamo il + tatticale \texttt{TRY} per provare ad applicare la stessa tattica a tutti e quattro + i rami. Se la nostra tattica fallisce sul ramo \#2, come ci aspettiamo, + \texttt{TRY} ci protegger da questo fallimento e ci permetter di procedere. \begin{session} \begin{alltt} @@ -971,16 +971,16 @@ \subsection{Dimostrare che le \con{RTC} sono le stesse} x # x' -->* y # y' \end{alltt} \end{session} - Si noti che avvolgere \texttt{TRY} intorno a \texttt{PROVE\_TAC} non - sempre saggio. Spesso la tattica \texttt{PROVE\_TAC} richiede un tempo - estremamente lungo per esaurire il suo spazio di ricerca, e poi arrendersi con un + Si noti che avvolgere \texttt{TRY} intorno a \texttt{PROVE\_TAC} non + sempre saggio. Spesso la tattica \texttt{PROVE\_TAC} richiede un tempo + estremamente lungo per esaurire il suo spazio di ricerca, e poi arrendersi con un fallimento. Qui, ``siamo stati fortunati''. - In ogni caso, che cosa ne facciamo di quest'ultimo subgoal? Se lo osserviamo per un tempo - sufficiente, dovremmo vedere che un altro fatto di monotonicit. Pi - precisamente, abbiamo bisogno di ci che chiamato un risultato di \emph{congruenza} per - \holtxt{-->*}. In questa forma, non molto adatto per una dimostrazione semplice. - Andiamo via e dimostriamo \texttt{RTCredn\_ap\_monotonic} + In ogni caso, che cosa ne facciamo di quest'ultimo subgoal? Se lo osserviamo per un tempo + sufficiente, dovremmo vedere che un altro fatto di monotonicit. Pi + precisamente, abbiamo bisogno di ci che chiamato un risultato di \emph{congruenza} per + \holtxt{-->*}. In questa forma, non molto adatto per una dimostrazione semplice. + Andiamo via e dimostriamo \texttt{RTCredn\_ap\_monotonic} separatamente. (Un altro esercizio!) Il nostro nuovo teorema dovrebbe stabilire \begin{session} \begin{verbatim} @@ -990,13 +990,13 @@ \subsection{Dimostrare che le \con{RTC} sono le stesse} ...); \end{verbatim} \end{session} - Ora che abbiamo questo, il nostro sub-goal quasi immediatamente + Ora che abbiamo questo, il nostro sub-goal quasi immediatamente dimostrabile. Usandolo, sappiamo che \[\begin{array}{c} x\;x' \rightarrow^* y\;x' \\ y\;x' \rightarrow^* y\;y' \end{array}\] - Tutto ci che dobbiamo fare ``cucire insieme'' le due transizioni di sopra - e andiamo da $x\;x'$ a $y\;y'$. Possiamo fare questo ricorrendo al nostro + Tutto ci che dobbiamo fare ``cucire insieme'' le due transizioni di sopra + e andiamo da $x\;x'$ a $y\;y'$. Possiamo fare questo ricorrendo al nostro precedente risultato \texttt{RTC\_RTC}. \begin{session} \begin{alltt} @@ -1010,11 +1010,11 @@ \subsection{Dimostrare che le \con{RTC} sono le stesse} |- \(\forall\)x y. x -||-> y \(\Rightarrow\) x -->* y : goalstack \end{alltt} \end{session} -Ma dato che possiamo rifinire ci che pensavamo essere un ramo scomodo -con solo un'altra applicazione di \texttt{PROVE\_TAC}, non abbiamo bisogno di -usare il nostro footwork con \texttt{TRY} al passo precedente. Piuttosto, -possiamo semplicemente fondere le liste di teoremi passate ad entrambe le invocazioni, distribuire -con \texttt{REPEAT CONJ\_TAC} e avere di fatto una dimostrazione con una tattica +Ma dato che possiamo rifinire ci che pensavamo essere un ramo scomodo +con solo un'altra applicazione di \texttt{PROVE\_TAC}, non abbiamo bisogno di +usare il nostro footwork con \texttt{TRY} al passo precedente. Piuttosto, +possiamo semplicemente fondere le liste di teoremi passate ad entrambe le invocazioni, distribuire +con \texttt{REPEAT CONJ\_TAC} e avere di fatto una dimostrazione con una tattica molto corta: \begin{session} \begin{verbatim} @@ -1027,8 +1027,8 @@ \subsection{Dimostrare che le \con{RTC} sono le stesse} \end{session} \eos{} -Ora il momento di dimostrare che se un numero di passi di riduzione parallela -sono concatenati insieme, allora possiamo riflettere questo con qualche numero di +Ora il momento di dimostrare che se un numero di passi di riduzione parallela +sono concatenati insieme, allora possiamo riflettere questo con qualche numero di passi usando la relazione di riduzione originale. Il nostro goal: \begin{session} \begin{alltt} @@ -1052,8 +1052,8 @@ \subsection{Dimostrare che le \con{RTC} sono le stesse} \end{alltt} \end{session} Possiamo concludere questo in un singolo passo. La prima congiunzione ovvia, -e nella seconda \verb!x -||-> y! e il nostro ultimo risultato si combinano per -dirci che \verb!x -->* y!. Poi questo pu essere concatenato insieme con +e nella seconda \verb!x -||-> y! e il nostro ultimo risultato si combinano per +dirci che \verb!x -->* y!. Poi questo pu essere concatenato insieme con l'altra assunzione nel secondo congiunto e abbiamo finito. \begin{session} \begin{alltt} @@ -1078,7 +1078,7 @@ \subsection{Dimostrare che le \con{RTC} sono le stesse} \end{session} \eos{} -La nostra ultima azione di usare ci che abbiamo finora per concludere che +La nostra ultima azione di usare ci che abbiamo finora per concludere che $\rightarrow^*$ e $\mathpredn^*$ sono uguali. Dichiariamo il nostro goal: \begin{session} \begin{verbatim} @@ -1090,7 +1090,7 @@ \subsection{Dimostrare che le \con{RTC} sono le stesse} $-||->* = $-->* \end{verbatim} \end{session} -Vogliamo ora ricorrere all'estensionalit. Il modo pi semplice per far questo +Vogliamo ora ricorrere all'estensionalit. Il modo pi semplice per far questo di riscrivere con il teorema \texttt{FUN\_EQ\_THM}: \begin{session} \begin{alltt} @@ -1137,15 +1137,15 @@ \subsection{Dimostrare che le \con{RTC} sono le stesse} \subsection{Dimostrare una propriet diamante per la riduzione parallela} \label{sec:predn-diamond} -Ora non ci resta che una dimostrazione sostanziale da fare. Prima ancora di poter -cominciare, c' un numero di lemmi minori che abbiamo bisogno di dimostrare prima. -Questi sono essenzialmente delle specializzazioni del teorema -\texttt{predn\_cases}. Vogliamo delle caratterizzazioni esaustive delle +Ora non ci resta che una dimostrazione sostanziale da fare. Prima ancora di poter +cominciare, c' un numero di lemmi minori che abbiamo bisogno di dimostrare prima. +Questi sono essenzialmente delle specializzazioni del teorema +\texttt{predn\_cases}. Vogliamo delle caratterizzazioni esaustive delle possibilit che si possono presentare quando i seguenti termini subiscono una riduzione parallela: $x\;y$, \KC, \SC, $\KC\;x$, $\SC\;x$, $\KC\;x\;y$, $\SC\;x\;y$ e $\SC\;x\;y\;z$. -Per far questo, scriveremo una piccola funzione che deriva +Per far questo, scriveremo una piccola funzione che deriva le caratterizzazioni automaticamente: \begin{session} \begin{verbatim} @@ -1153,9 +1153,9 @@ \subsection{Dimostrare che le \con{RTC} sono le stesse} > val characterise = fn : term -> thm \end{verbatim} \end{session} -La funzione \ml{characterise} specializza il teorema -\ml{predn\_cases} con il termine di input, e quindi semplifica. Il -simpset \ml{srw\_ss()} include informazioni circa l'iniettivit e +La funzione \ml{characterise} specializza il teorema +\ml{predn\_cases} con il termine di input, e quindi semplifica. Il +simpset \ml{srw\_ss()} include informazioni circa l'iniettivit e la disgiunzione [disjointness ndt] dei costruttori ed elimina le ovvie impossibilit. Per esempio, \begin{session} @@ -1189,7 +1189,7 @@ \subsection{Dimostrare che le \con{RTC} sono le stesse} RW_TAC std_ss [Sx_predn0, predn_rules, S_predn]); \end{verbatim} \end{session} -La nostra funzione \texttt{characterise} dovr solo aiutarci nelle +La nostra funzione \texttt{characterise} dovr solo aiutarci nelle dimostrazioni che seguono. \begin{session} \begin{verbatim} @@ -1199,7 +1199,7 @@ \subsection{Dimostrare che le \con{RTC} sono le stesse} RW_TAC std_ss [characterise ``K # x``, predn_rules, K_predn]); \end{verbatim} \end{session} -Cosa facciamo di $\KC\;x\;y$? Un poco di ragionamento dimostra che ci sono +Cosa facciamo di $\KC\;x\;y$? Un poco di ragionamento dimostra che ci sono in realt due casi questa volta. \begin{session} \begin{verbatim} @@ -1213,7 +1213,7 @@ \subsection{Dimostrare che le \con{RTC} sono le stesse} Kx_predn]); \end{verbatim} \end{session} -Per contro, c' solo un caso per $\SC\;x\;y$ perch esso +Per contro, c' solo un caso per $\SC\;x\;y$ perch esso non ancora un ``redex'' al livello alto. \begin{session} \begin{verbatim} @@ -1238,8 +1238,8 @@ \subsection{Dimostrare che le \con{RTC} sono le stesse} Sxy_predn]); \end{verbatim} \end{session} -Infine, vogliamo una caratterizzazione per $x\;y$. Ci che -\texttt{characterise} ci da questa volta non pu essere migliorato, +Infine, vogliamo una caratterizzazione per $x\;y$. Ci che +\texttt{characterise} ci da questa volta non pu essere migliorato, per quello che potremmo considerare a partire dai quattro disgiunti. \begin{session} \begin{alltt} @@ -1292,8 +1292,8 @@ \subsection{Dimostrare che le \con{RTC} sono le stesse} \(\forall\)x z. x -||-> z \(\Rightarrow\) \(\exists\)u. x -||-> u \(\land\) z -||-> u \end{alltt} \end{session} -Il primo goal facilmente smaltito. Il testimone che forniremmo -per questo caso semplicemente \texttt{z}, ma \texttt{PROVE\_TAC} far +Il primo goal facilmente smaltito. Il testimone che forniremmo +per questo caso semplicemente \texttt{z}, ma \texttt{PROVE\_TAC} far il lavoro per noi: \begin{session} \begin{verbatim} @@ -1304,12 +1304,12 @@ \subsection{Dimostrare che le \con{RTC} sono le stesse} Goal proved. [...] \end{verbatim} \end{session} - Il goal successivo include due istanze di termine della forma - \verb!x # y -||-> z!. Possiamo ora usare il nostro teorema \verb!x_ap_y_predn! - qui. Tuttavia, se riscriviamo in modo indiscriminato con esso, - confonderemo in realt il goal. Vogliamo riscrivere soltanto - l'assunzione, non l'istanza al di sotto del quantificatore - esistenziale. Iniziare il tutto applicando ripetutamente \ml{STRIP\_TAC} non ci + Il goal successivo include due istanze di termine della forma + \verb!x # y -||-> z!. Possiamo ora usare il nostro teorema \verb!x_ap_y_predn! + qui. Tuttavia, se riscriviamo in modo indiscriminato con esso, + confonderemo in realt il goal. Vogliamo riscrivere soltanto + l'assunzione, non l'istanza al di sotto del quantificatore + esistenziale. Iniziare il tutto applicando ripetutamente \ml{STRIP\_TAC} non ci pu portare troppo fuori strada. \begin{session} \begin{alltt} @@ -1326,29 +1326,29 @@ \subsection{Dimostrare che le \con{RTC} sono le stesse} 4. x # u -||-> z \end{alltt} \end{session} -Abbiamo bisogno di suddividere l'assunzione 4. Siamo in grado di estrarla dalla +Abbiamo bisogno di suddividere l'assunzione 4. Siamo in grado di estrarla dalla lista delle assunzioni usando il theorem-tactical \texttt{Q.PAT\_ASSUM}. Scriveremo. \begin{verbatim} Q.PAT_ASSUM `x # y -||-> z` (STRIP_ASSUME_TAC o SIMP_RULE std_ss [x_ap_y_predn]) \end{verbatim} -La quotation specifica il pattern su cui vogliamo effettuare il matching. Il secondo -argomento specifica come trasformeremo il teorema. Leggendo -le composizioni da destra a sinistra, prima semplificheremo con il -teorema \verb!x_ap_y_predn! e poi assumeremo il risultato indietro -nelle assunzioni, eliminando le disgiunzioni e gli esistenziali mentre andiamo -avanti\footnote{Un'alternativa alo posto di usare \texttt{PAT\_ASSUM} di usare - \texttt{by}: ci sarebbe da dichiarare per proprio conto la disgiunzione - di quattro disgiunti, ma la dimostrazione sarebbe pi ``dichiarativa'' nello +La quotation specifica il pattern su cui vogliamo effettuare il matching. Il secondo +argomento specifica come trasformeremo il teorema. Leggendo +le composizioni da destra a sinistra, prima semplificheremo con il +teorema \verb!x_ap_y_predn! e poi assumeremo il risultato indietro +nelle assunzioni, eliminando le disgiunzioni e gli esistenziali mentre andiamo +avanti\footnote{Un'alternativa alo posto di usare \texttt{PAT\_ASSUM} di usare + \texttt{by}: ci sarebbe da dichiarare per proprio conto la disgiunzione + di quattro disgiunti, ma la dimostrazione sarebbe pi ``dichiarativa'' nello stile, e bench pi verbosa, sarebbe pi manutenibile.}. -Sappiamo gi che fare questo produrr quattro nuovi sub-goal -(c'erano quattro disgiunti nel teorema \verb!x_ap_y_predn!). Al meno -uno di questi dovrebbe essere banale perch corrisponder al caso -in cui la riduzione parallela semplicemente un passo ``non fare nulla''. Proviamo -ad eliminare i casi semplici con una chiamata ``speculativa'' a -\texttt{PROVE\_TAC} avvolta all'interno di un \texttt{TRY}. E prima di far -questo, dovremmo fare alcune riscritture per essere sicuri che le uguaglianze nelle +Sappiamo gi che fare questo produrr quattro nuovi sub-goal +(c'erano quattro disgiunti nel teorema \verb!x_ap_y_predn!). Al meno +uno di questi dovrebbe essere banale perch corrisponder al caso +in cui la riduzione parallela semplicemente un passo ``non fare nulla''. Proviamo +ad eliminare i casi semplici con una chiamata ``speculativa'' a +\texttt{PROVE\_TAC} avvolta all'interno di un \texttt{TRY}. E prima di far +questo, dovremmo fare alcune riscritture per essere sicuri che le uguaglianze nelle assunzioni sono eliminate. So: @@ -1380,10 +1380,10 @@ \subsection{Dimostrare che le \con{RTC} sono le stesse} 3. \(\forall\)z. u -||-> z \(\Rightarrow\) \(\exists\)u. v -||-> u \(\land\) z -||-> u \end{alltt} \end{session} -Splendido! Abbiamo gi eliminato due dei quattro disgiunti. Ora -il nostro prossimo goal rappresenta un termine \verb!K # z -||-> y! nelle assunzioni. -Abbiamo un teorema che riguarda proprio questa situazione. Ma prima -di applicarlo volenti o nolenti, proviamo ad immaginare esattamente qual la +Splendido! Abbiamo gi eliminato due dei quattro disgiunti. Ora +il nostro prossimo goal rappresenta un termine \verb!K # z -||-> y! nelle assunzioni. +Abbiamo un teorema che riguarda proprio questa situazione. Ma prima +di applicarlo volenti o nolenti, proviamo ad immaginare esattamente qual la situazione. Un diagramma della situazione corrente potrebbe apparire come \shorthandoff{"} \[\xymatrix @C=2cm { @@ -1393,8 +1393,8 @@ \subsection{Dimostrare che le \con{RTC} sono le stesse} \ar "1,1"!<28pt,0pt>;"2,1"!<11pt,0pt> } \] \shorthandon{"} -Il nostro teorema ci dice che \texttt{y} deve di fatto essere della forma -\verb!K # w! per qualche \texttt{w}, e che ci deve essere una freccia +Il nostro teorema ci dice che \texttt{y} deve di fatto essere della forma +\verb!K # w! per qualche \texttt{w}, e che ci deve essere una freccia tra \texttt{z} e \texttt{w}. Cos: \begin{session} \begin{alltt} @@ -1413,12 +1413,12 @@ \subsection{Dimostrare che le \con{RTC} sono le stesse} 5. z -||-> w \end{alltt} \end{session} - Ispezionando, appare chiaro che \texttt{u} deve essere + Ispezionando, appare chiaro che \texttt{u} deve essere \texttt{w}. Il primo congiunto richiede \verb!K # w # v -||-> w!, - che abbiamo perch questo ci che fa \KC{}, e il secondo - congiunto gi nella lista delle assunzioni. Riscrivendo - (eliminando prima quell'uguaglianza nella lista delle assunzioni - render il lavoro di \texttt{PROVE\_TAC} molto pi facile), e poi il ragionamento al + che abbiamo perch questo ci che fa \KC{}, e il secondo + congiunto gi nella lista delle assunzioni. Riscrivendo + (eliminando prima quell'uguaglianza nella lista delle assunzioni + render il lavoro di \texttt{PROVE\_TAC} molto pi facile), e poi il ragionamento al primo ordine risolver questo goal: \begin{session} \begin{alltt} @@ -1457,10 +1457,10 @@ \subsection{Dimostrare che le \con{RTC} sono le stesse} \(\forall\)x y z. K # x # y -||-> z \(\Rightarrow\) \(\exists\)u. x -||-> u \(\land\) z -||-> u \end{alltt} \end{session} -Questo prossimo goal rappresenta un termine \verb!K # x # y -||-> z! per cui -abbiamo gi un teorema. E di nuovo, usiamo in modo speculativo una chiamata a -\texttt{PROVE\_TAC} per eliminare i casi semplici immediatamente -(\verb!Kxy_predn! un disgiunto cos otteniamo due sub goal se non +Questo prossimo goal rappresenta un termine \verb!K # x # y -||-> z! per cui +abbiamo gi un teorema. E di nuovo, usiamo in modo speculativo una chiamata a +\texttt{PROVE\_TAC} per eliminare i casi semplici immediatamente +(\verb!Kxy_predn! un disgiunto cos otteniamo due sub goal se non eliminiamo nulla). \begin{session} \begin{alltt} @@ -1477,7 +1477,7 @@ \subsection{Dimostrare che le \con{RTC} sono le stesse} \(\exists\)u. f # x # (g # x) -||-> u \(\land\) z -||-> u \end{alltt} \end{session} -Ancora meglio! Abbiamo ottenuto entrambi i casi immediatamente, e ci siamo spostati sull'ultimo +Ancora meglio! Abbiamo ottenuto entrambi i casi immediatamente, e ci siamo spostati sull'ultimo caso. Possiamo provare la stessa strategia. \begin{session} \begin{alltt} @@ -1519,7 +1519,7 @@ \subsection{Dimostrare che le \con{RTC} sono le stesse} \end{session} \eos{} -Siamo in dirittura di arrivo. Il lemma pu essere trasformato in una dichiarazione +Siamo in dirittura di arrivo. Il lemma pu essere trasformato in una dichiarazione che coinvolge direttamente la costante \con{diamond}: \begin{session} \begin{verbatim} @@ -1530,7 +1530,7 @@ \subsection{Dimostrare che le \con{RTC} sono le stesse} \end{verbatim} \end{session} -Ed ora possiamo dimostrare che la nostra relazione originale confluente in +Ed ora possiamo dimostrare che la nostra relazione originale confluente in un modo analogo: \begin{session} @@ -1547,22 +1547,22 @@ \subsection{Dimostrare che le \con{RTC} sono le stesse} \section{Esercizi} -Se necessario, le risposte ai primi tre esercizi si possono trovare +Se necessario, le risposte ai primi tre esercizi si possono trovare esaminando il file sorgente in \texttt{examples/ind\_def/clScript.sml}. \begin{enumerate} \item Dimostrare che \[\con{RTC}\;R \;x\; y \;\;\land \;\; \con{RTC}\;R\;y\;z\;\;\;\supset\;\;\; \con{RTC}\;R\;x\;z -\] Si avr bisogno di dimostrare il goal per induzione, e si avr probabilmente - bisogno di massaggiarlo prima leggermente per ottenere che si accordi all'appropriato - principio d'induzione. Archiviare il teorema sotto il nome +\] Si avr bisogno di dimostrare il goal per induzione, e si avr probabilmente + bisogno di massaggiarlo prima leggermente per ottenere che si accordi all'appropriato + principio d'induzione. Archiviare il teorema sotto il nome \texttt{RTC\_RTC}. \item Un'altra induzione. Mostrare che \[ (\forall x\,y.\; R_1\;x\;y\supset R_2\;x\;y) \supset (\forall x\,y.\; \con{RTC}\;R_1\;x\;y \supset \con{RTC}\;R_2\;x\;y) \] Chiamare il teorema risultante \texttt{RTC\_monotone}. -\item Ancora un'altra induzione \con{RTC}, ma dove $R$ non pi - astratta, ed piuttosto la relazione di riduzione originale. Dimostrare +\item Ancora un'altra induzione \con{RTC}, ma dove $R$ non pi + astratta, ed piuttosto la relazione di riduzione originale. Dimostrare \[ x \rightarrow^* y \;\;\;\supset\;\;\; \forall z.\;\; x\;z \rightarrow^* y \;z \land diff --git a/Manual/Translations/IT/Tutorial/euclid.tex b/Manual/Translations/IT/Tutorial/euclid.tex index 6a4ef45a7d..7a18fca3b0 100644 --- a/Manual/Translations/IT/Tutorial/euclid.tex +++ b/Manual/Translations/IT/Tutorial/euclid.tex @@ -3,36 +3,36 @@ \chapter{Esempio: il Teorema di Euclide} \setcounter{sessioncount}{0} -In questo capitolo, dimostriamo in \holn{} che per ogni numero, c' un -numero primo che pi grande, cio, che i numeri primi formano una -sequenza infinita. Questa dimostrazione stata estratta e adattata da un -pi ampio esempio, dovuto a John Harrison, in cui egli dimostrava il caso -$n = 4$ dell'ultimo teorema di Fermat. Lo sviluppo della dimostrazione ha lo scopo -di servire come un'introduzione all'esecuzione di dimostrazioni interattive di alto livello -in \holn\footnote{Le dimostrazioni discusse di sotto si possono trovare in +In questo capitolo, dimostriamo in \holn{} che per ogni numero, c' un +numero primo che pi grande, cio, che i numeri primi formano una +sequenza infinita. Questa dimostrazione stata estratta e adattata da un +pi ampio esempio, dovuto a John Harrison, in cui egli dimostrava il caso +$n = 4$ dell'ultimo teorema di Fermat. Lo sviluppo della dimostrazione ha lo scopo +di servire come un'introduzione all'esecuzione di dimostrazioni interattive di alto livello +in \holn\footnote{Le dimostrazioni discusse di sotto si possono trovare in \texttt{examples/euclid.sml} della distribuzione \HOL{}.}. Molti dei dettagli possono essere difficili da cogliere per il lettore alle prime armi; -ciononostante, si raccomanda di seguire l'esempio in modo completo +ciononostante, si raccomanda di seguire l'esempio in modo completo al fine di ottenere una vera sensazione dell'uso di \HOL{} per dimostrare teoremi non-banali. -Alcuni tutorial sulla descrizione di sistemi di dimostrazione, mostrano il sistema mentre esegue -incredibili gesta di dimostrazione automatica di teoremi. In questo esempio, \textit{non} -abbiamo seguito questo approccio; piuttosto, cerchiamo di mostrare come si affronta -nella realt il problema di dimostrare teoremi in \holn{}: quando - possibile pi di un modo per dimostrare qualcosa, considereremo -le scelte; quando sorge una difficolt, tenteremo di spiegare come affrontare +Alcuni tutorial sulla descrizione di sistemi di dimostrazione, mostrano il sistema mentre esegue +incredibili gesta di dimostrazione automatica di teoremi. In questo esempio, \textit{non} +abbiamo seguito questo approccio; piuttosto, cerchiamo di mostrare come si affronta +nella realt il problema di dimostrare teoremi in \holn{}: quando + possibile pi di un modo per dimostrare qualcosa, considereremo +le scelte; quando sorge una difficolt, tenteremo di spiegare come affrontare il problema in modo chiaro. -Si `guida' \holn{} interagendo con il loop interattivo ML. In questo -stile interattivo, si eseguono chiamate a funzioni ML per richiamare -un contesto logico gi stabilito, ad esempio, attraverso \ml{load}; per definire +Si `guida' \holn{} interagendo con il loop interattivo ML. In questo +stile interattivo, si eseguono chiamate a funzioni ML per richiamare +un contesto logico gi stabilito, ad esempio, attraverso \ml{load}; per definire nuovi concetti, ad esempio, attraverso \ml{Hol\_datatype}, \ml{Define}, e \ml{Hol\_reln}; -e per eseguire dimostrazioni usando l'interfaccia goalstack, e -gli strumenti di dimostrazione da \ml{bossLib} (o se essi falliscono, dalle +e per eseguire dimostrazioni usando l'interfaccia goalstack, e +gli strumenti di dimostrazione da \ml{bossLib} (o se essi falliscono, dalle librerie di basso livello). Cominciamo. Per prima cosa, avviamo il sistema, con il comando \ml{/bin/hol}. -Quindi con ``\ml{open}'' apriamo la teoria aritmetica; questo significa che tutti i binding \ML{} +Quindi con ``\ml{open}'' apriamo la teoria aritmetica; questo significa che tutti i binding \ML{} dalla teoria \HOL{} sono resi disponibili al loop interattivo. \begin{session} \begin{verbatim} @@ -40,7 +40,7 @@ \chapter{Esempio: il Teorema di Euclide} ... \end{verbatim} \end{session} -Ora iniziamo la formalizzazione. Al fine di definire il concetto di +Ora iniziamo la formalizzazione. Al fine di definire il concetto di numero primo, abbiamo prima bisogno di definire la relazione di \emph{divisibilit}: \begin{session} @@ -52,13 +52,13 @@ \chapter{Esempio: il Teorema di Euclide} \end{verbatim} \end{session} -La definizione aggiunta alla teoria corrente con il nome -\ml{divides\_def}, ed anche restituita dall'invocazione di -\ml{Define}. Approfittiamo di questo ed effettuiamo un binding del nome -\ML{} \ml{divides\_def} alla definizione. Nel modo usuale di -interagire con \HOL, un tale binding \ML{} fatto per ogni -definizione e teorema (utile) dimostrato: l'ambiente \ML{} viene -cos usato come un luogo conveniente per mantenere definizioni e teoremi per +La definizione aggiunta alla teoria corrente con il nome +\ml{divides\_def}, ed anche restituita dall'invocazione di +\ml{Define}. Approfittiamo di questo ed effettuiamo un binding del nome +\ML{} \ml{divides\_def} alla definizione. Nel modo usuale di +interagire con \HOL, un tale binding \ML{} fatto per ogni +definizione e teorema (utile) dimostrato: l'ambiente \ML{} viene +cos usato come un luogo conveniente per mantenere definizioni e teoremi per un futuro riferimento nella sessione. Vogliamo trattare \ml{divides} come un infisso (non-associativo): @@ -67,8 +67,8 @@ \chapter{Esempio: il Teorema di Euclide} - set_fixity "divides" (Infix(NONASSOC, 450)); \end{verbatim} \end{session} -Poi definiamo la propriet di essere un numero \emph{primo}: un numero $p$ -primo se e solo se non uguale a $1$ e non ha altri divisori oltre +Poi definiamo la propriet di essere un numero \emph{primo}: un numero $p$ +primo se e solo se non uguale a $1$ e non ha altri divisori oltre $1$ e s stesso: \begin{session} @@ -83,20 +83,20 @@ \chapter{Esempio: il Teorema di Euclide} \end{verbatim} \end{session} -Questo conclude le definizioni da fare. Ora dobbiamo ``solo'' dimostrare -che ci sono infiniti numeri primi. Se fossimo arrivati ad affrontare questo -problema senza un background, allora saremmo costretti a passare per un processo -non completamente chiaro e spesso tremendamente difficile di ricerca dei giusti lemmi -richiesti per dimostrare il nostro teorema desiderato\footnote{Questo naturalmente un -problema generale quando si affronta qualsiasi tipo di dimostrazione.}. Fortunatamente, stiamo -lavorando a partire da un dimostrazione gi completata e possiamo dedicarci al problema +Questo conclude le definizioni da fare. Ora dobbiamo ``solo'' dimostrare +che ci sono infiniti numeri primi. Se fossimo arrivati ad affrontare questo +problema senza un background, allora saremmo costretti a passare per un processo +non completamente chiaro e spesso tremendamente difficile di ricerca dei giusti lemmi +richiesti per dimostrare il nostro teorema desiderato\footnote{Questo naturalmente un +problema generale quando si affronta qualsiasi tipo di dimostrazione.}. Fortunatamente, stiamo +lavorando a partire da un dimostrazione gi completata e possiamo dedicarci al problema decisamente pi semplice di spiegare come dimostrare i teoremi richiesti. \paragraph{Strumenti di dimostrazione} -Lo sviluppo illustrer che c' spesso pi di un modo di -affrontare una dimostrazione HOL, persino quando si ha in mente un'unica dimostrazione -(informale). In questo esempio, spesso \emph{troviamo} dimostrazioni usando -la tattica di riscrittura \ml{RW\_TAC} per espandere le definizioni ed eseguire semplificazioni +Lo sviluppo illustrer che c' spesso pi di un modo di +affrontare una dimostrazione HOL, persino quando si ha in mente un'unica dimostrazione +(informale). In questo esempio, spesso \emph{troviamo} dimostrazioni usando +la tattica di riscrittura \ml{RW\_TAC} per espandere le definizioni ed eseguire semplificazioni di base, riducendo spesso un goal alla sua essenza. \begin{session} \begin{verbatim} @@ -105,74 +105,74 @@ \chapter{Esempio: il Teorema di Euclide} (term list * term) list * (thm list -> thm) \end{verbatim} \end{session} -Il tipo ML di \ml{RW\_TAC} -\ml{:simpset -> thm list -> tactic}\footnote{Sfortunatamente, il sistema MoscowML non stampa +Il tipo ML di \ml{RW\_TAC} +\ml{:simpset -> thm list -> tactic}\footnote{Sfortunatamente, il sistema MoscowML non stampa il tipo delle tattiche nella sua forma abbreviata.}. -Quando \ml{RW\_TAC} applicata a un \textit{simpset}---per questo esempio sar -sempre \ml{arith\_ss}---e a una lista di teoremi, i +Quando \ml{RW\_TAC} applicata a un \textit{simpset}---per questo esempio sar +sempre \ml{arith\_ss}---e a una lista di teoremi, i teoremi saranno aggiunti al simpset come regole di riscrittura aggiuntive. -Vedremo che \ml{arith\_ss} anche informato in qualche modo circa -l'aritmetica\footnote{Specialmente l'aritmetica lineare: formule puramente -universali, che coinvolgono gli operatori {\tt SUC}, $+$, $-$, letterali -numerici, $<$, $\leq$, $>$, $\geq$, $=$, e la moltiplicazione per letterali +Vedremo che \ml{arith\_ss} anche informato in qualche modo circa +l'aritmetica\footnote{Specialmente l'aritmetica lineare: formule puramente +universali, che coinvolgono gli operatori {\tt SUC}, $+$, $-$, letterali +numerici, $<$, $\leq$, $>$, $\geq$, $=$, e la moltiplicazione per letterali numerici}. A volte la semplificazione con \ml{RW\_TAC} dimostra il goal immediatamente. -Spesso comunque, ci rimane un goal che richiede un p di studio prima di -realizzare quali lemmi sono necessari per concludere la dimostrazione. Una volta che questi lemmi -sono stati dimostrati, o individuati nelle teorie progenitrici, -\ml{METIS\_TAC}\footnote{\ml{METIS\_TAC} -esegue una ricerca della dimostrazione al primo ordine nello stile della risoluzione.} pu -essere invocata con essi, con la speranza che essa individuer le istanziazioni -corrette necessarie per concludere la dimostrazione. Si noti che queste due operazioni, -la semplificazione e la ricerca automatica di una dimostrazione nello stile della risoluzione, non saranno sufficienti per -eseguire tutte le dimostrazioni in questo esempio: in particolare, il nostro sviluppo, avr +Spesso comunque, ci rimane un goal che richiede un p di studio prima di +realizzare quali lemmi sono necessari per concludere la dimostrazione. Una volta che questi lemmi +sono stati dimostrati, o individuati nelle teorie progenitrici, +\ml{METIS\_TAC}\footnote{\ml{METIS\_TAC} +esegue una ricerca della dimostrazione al primo ordine nello stile della risoluzione.} pu +essere invocata con essi, con la speranza che essa individuer le istanziazioni +corrette necessarie per concludere la dimostrazione. Si noti che queste due operazioni, +la semplificazione e la ricerca automatica di una dimostrazione nello stile della risoluzione, non saranno sufficienti per +eseguire tutte le dimostrazioni in questo esempio: in particolare, il nostro sviluppo, avr anche bisogno dell'analisi dei casi e dell'induzione. \paragraph{Trovare i teoremi} -Questo fa sorgere la seguente domanda: come si trovano i giusti lemmi e -le regole di riscrittura da usare? Questo piuttosto problematico, specialmente dal momento che il numero di -teorie progenitrici, e di teoremi al loro interno, grande. Ci sono molte +Questo fa sorgere la seguente domanda: come si trovano i giusti lemmi e +le regole di riscrittura da usare? Questo piuttosto problematico, specialmente dal momento che il numero di +teorie progenitrici, e di teoremi al loro interno, grande. Ci sono molte possibilit. \begin{itemize} -\item Si pu usare il sistema di help per cercare definizioni e +\item Si pu usare il sistema di help per cercare definizioni e teoremi, cos come procedure di dimostrazione; per esempio, un'invocazione di {\small \begin{verbatim} help "arithmeticTheory" \end{verbatim}} -mostrer tutte le definizioni e i teoremi che sono stati archiviati nella -teoria dell'aritmetica. Comunque, bisogna conoscere il nome completo dell'elemento -che si sta cercando prima che il sistema di help sia utile, cos i due +mostrer tutte le definizioni e i teoremi che sono stati archiviati nella +teoria dell'aritmetica. Comunque, bisogna conoscere il nome completo dell'elemento +che si sta cercando prima che il sistema di help sia utile, cos i due seguenti strumenti di ricerca sono spesso pi utili. -\item \verb+DB.match+ permette l'uso di pattern per individuare il -teorema cercato. Sar restituito qualunque teorema archiviato che ha un'istanza del pattern +\item \verb+DB.match+ permette l'uso di pattern per individuare il +teorema cercato. Sar restituito qualunque teorema archiviato che ha un'istanza del pattern come un sotto termine. -\item \verb+DB.find+ user frammenti dei nomi come chiavi con cui +\item \verb+DB.find+ user frammenti dei nomi come chiavi con cui cercare l'informazione \end{itemize} \paragraph{Composizione di tattiche} -Una volta che stata trovata una dimostrazione di una proposizione, d'abitudine, bench -non necessario, avviare un processo di \emph{revisione}, in cui la -sequenza di tattiche originaria composta in un'unica tattica. A volte, -la tattica risultante molto pi breve, e in un certo senso pi gradevole -da un punto di vista estetico. Alcuni utenti spendono un bel p di tempo per raffinare queste tattiche, -nonostante non sembri esserci un reale maggior beneficio nel fare questo, dal momento che esse -sono ricette di dimostrazione \emph{ad hoc}, una per ciascun teorema. Nel +Una volta che stata trovata una dimostrazione di una proposizione, d'abitudine, bench +non necessario, avviare un processo di \emph{revisione}, in cui la +sequenza di tattiche originaria composta in un'unica tattica. A volte, +la tattica risultante molto pi breve, e in un certo senso pi gradevole +da un punto di vista estetico. Alcuni utenti spendono un bel p di tempo per raffinare queste tattiche, +nonostante non sembri esserci un reale maggior beneficio nel fare questo, dal momento che esse +sono ricette di dimostrazione \emph{ad hoc}, una per ciascun teorema. Nel seguito, mostreremo in pochi casi come questo viene fatto. \section{Divisibilit} -Iniziamo dimostrando un numero di teoremi circa la relazione -\verb+divides+. Vedremo che ciascuno di questi teoremi iniziali pu essere -dimostrato con una singola invocazione di \ml{METIS\_TAC}. Sia \ml{RW\_TAC} -sia \ml{METIS\_TAC} sono ragionatori piuttosto potenti, e la scelta di un -ragionatore in una situazione particolare una questione di esperienza. La -ragione principale per cui \ml{METIS\_TAC} funziona cos bene che \verb+divides+ - definita per mezzo di un quantificatore esistenziale, e \ml{METIS\_TAC} - piuttosto buono per istanziare in modo automatico gli esistenziali nel +Iniziamo dimostrando un numero di teoremi circa la relazione +\verb+divides+. Vedremo che ciascuno di questi teoremi iniziali pu essere +dimostrato con una singola invocazione di \ml{METIS\_TAC}. Sia \ml{RW\_TAC} +sia \ml{METIS\_TAC} sono ragionatori piuttosto potenti, e la scelta di un +ragionatore in una situazione particolare una questione di esperienza. La +ragione principale per cui \ml{METIS\_TAC} funziona cos bene che \verb+divides+ + definita per mezzo di un quantificatore esistenziale, e \ml{METIS\_TAC} + piuttosto buono per istanziare in modo automatico gli esistenziali nel corso di una dimostrazione. Per un semplice esempio, si consideri la dimostrazione di $\forall x.\ -x\; \mathtt{divides}\; 0$. Si inserisce una nuova proposizione da dimostrare +x\; \mathtt{divides}\; 0$. Si inserisce una nuova proposizione da dimostrare attraverso ``\ml{g}'', che avvia un nuovo goalstack. \begin{session} @@ -188,9 +188,9 @@ \chapter{Esempio: il Teorema di Euclide} : proofs \end{verbatim} \end{session} -Il manager di dimostrazione ci dice che c' soltanto una dimostrazione da gestire, e -ripete il goal dato. Ora espandiamo la definizione di -\verb+divides+. Si noti che ha luogo un'$\alpha$-conversione al fine di +Il manager di dimostrazione ci dice che c' soltanto una dimostrazione da gestire, e +ripete il goal dato. Ora espandiamo la definizione di +\verb+divides+. Si noti che ha luogo un'$\alpha$-conversione al fine di mantenere distinta la $x$ del goal e la $x$ nella definizione di \ml{divides}: \begin{session} @@ -203,7 +203,7 @@ \chapter{Esempio: il Teorema di Euclide} ?x'. (x = 0) \/ (x' = 0) \end{verbatim} \end{session} -E' naturalmente piuttosto facile istanziare il quantificatore esistenziale a +E' naturalmente piuttosto facile istanziare il quantificatore esistenziale a mano. \begin{session} \begin{verbatim} @@ -232,22 +232,22 @@ \chapter{Esempio: il Teorema di Euclide} \end{verbatim} \end{session} -Cosa appena successo qui? L'applicazione di \ml{RW\_TAC} al goal -lo ha decomposto in una lista vuota di subgoal; in altre parole, il goal stato -dimostrato da \ml{RW\_TAC}. Una volta che il goal stato dimostrato, tirato fuori -dal goalstack, stampato a video, e il teorema diventa -disponibile per l'uso al livello dello stack. Quando tutti i subgoal -richiesti da \textit{quel} livello sono stati dimostrati, anche il goal corrispondente a -quel livello pu essere dimostrato. Questo processo di `svolgimento' continua fino a quando -lo stack vuoto, o fino a quando raggiunge un goal con pi di un subgoal -non dimostrato rimanente. Questo processo pu essere difficile da -visualizzare,\footnote{Forse per il fatto che abbiamo usato uno stack per implementare quello -che teoricamente un albero!} ma ci non importa, dal momento che il goalstack stato +Cosa appena successo qui? L'applicazione di \ml{RW\_TAC} al goal +lo ha decomposto in una lista vuota di subgoal; in altre parole, il goal stato +dimostrato da \ml{RW\_TAC}. Una volta che il goal stato dimostrato, tirato fuori +dal goalstack, stampato a video, e il teorema diventa +disponibile per l'uso al livello dello stack. Quando tutti i subgoal +richiesti da \textit{quel} livello sono stati dimostrati, anche il goal corrispondente a +quel livello pu essere dimostrato. Questo processo di `svolgimento' continua fino a quando +lo stack vuoto, o fino a quando raggiunge un goal con pi di un subgoal +non dimostrato rimanente. Questo processo pu essere difficile da +visualizzare,\footnote{Forse per il fatto che abbiamo usato uno stack per implementare quello +che teoricamente un albero!} ma ci non importa, dal momento che il goalstack stato scritto espressamente per permettere all'utente d'ignorare tali dettagli. -Se le tre interazioni sono combinate insieme con \ml{THEN} per -formare una singola tattica, possiamo provare la dimostrazione -dall'inizio (usando la funzione \ml{restart}) e questa volta richieder +Se le tre interazioni sono combinate insieme con \ml{THEN} per +formare una singola tattica, possiamo provare la dimostrazione +dall'inizio (usando la funzione \ml{restart}) e questa volta richieder soltanto un unico passo: \begin{session} \begin{verbatim} @@ -263,11 +263,11 @@ \chapter{Esempio: il Teorema di Euclide} |- !x. x divides 0 \end{verbatim} \end{session} -Abbiamo visto un modo di dimostrare il teorema. Comunque, come menzionato -in precedenza, c' un altro modo: si potrebbe lasciare che \ml{METIS\_TAC} espanda la -definizione di \ml{divides} e trovi l'istanziazione richiesta per -\verb+x'+ dal teorema \ml{MULT\_CLAUSES}\footnote{Potreste - voler provare a digitare \ml{MULT\_CLAUSES} nel loop interativo +Abbiamo visto un modo di dimostrare il teorema. Comunque, come menzionato +in precedenza, c' un altro modo: si potrebbe lasciare che \ml{METIS\_TAC} espanda la +definizione di \ml{divides} e trovi l'istanziazione richiesta per +\verb+x'+ dal teorema \ml{MULT\_CLAUSES}\footnote{Potreste + voler provare a digitare \ml{MULT\_CLAUSES} nel loop interativo per vedere esattamente cosa esso afferma.}. \begin{session} \begin{verbatim} @@ -282,10 +282,10 @@ \chapter{Esempio: il Teorema di Euclide} |- !x. x divides 0 \end{verbatim} \end{session} -Mentre lavora, \ml{METIS\_TAC} stampa a video alcune diagnostiche +Mentre lavora, \ml{METIS\_TAC} stampa a video alcune diagnostiche possibilmente interessanti. In ogni caso, avendo eseguito la nostra dimostrazione all'interno del pacchetto goalstack, - ora vogliamo avere accesso al valore del teorema che abbiamo - dimostrato. Per far questo usiamo la funzione \ml{top\_thm}, e quindi + ora vogliamo avere accesso al valore del teorema che abbiamo + dimostrato. Per far questo usiamo la funzione \ml{top\_thm}, e quindi usiamo \ml{drop} per svuotare lo stack: \begin{session} \begin{verbatim} @@ -299,11 +299,11 @@ \chapter{Esempio: il Teorema di Euclide} \end{verbatim} \end{session} -Abbiamo usato \ml{METIS\_TAC} in questo modo per dimostrare la seguente -collezione di teoremi circa \ml{divides}. Come menzionato in precedenza, i -teoremi forniti a \ml{METIS\_TAC} nelle seguenti dimostrazioni (di solito) non -provengono dal nulla: in molti casi stato fatto un qualche lavoro esplorativo -con \ml{RW\_TAC} per espandere le definizioni e vedere quali lemmi sarebbero +Abbiamo usato \ml{METIS\_TAC} in questo modo per dimostrare la seguente +collezione di teoremi circa \ml{divides}. Come menzionato in precedenza, i +teoremi forniti a \ml{METIS\_TAC} nelle seguenti dimostrazioni (di solito) non +provengono dal nulla: in molti casi stato fatto un qualche lavoro esplorativo +con \ml{RW\_TAC} per espandere le definizioni e vedere quali lemmi sarebbero stati richiesti da \ml{METIS\_TAC}. \begin{description} @@ -369,9 +369,9 @@ \chapter{Esempio: il Teorema di Euclide} \end{description} -\noindent Assumeremo che le dimostrazioni di sopra siano state eseguite, e -che gli appropriati nomi ML siano stati dati a tutti i teoremi. -Ora affrontiamo un lemma circa la divisibilit che non soccombe a una +\noindent Assumeremo che le dimostrazioni di sopra siano state eseguite, e +che gli appropriati nomi ML siano stati dati a tutti i teoremi. +Ora affrontiamo un lemma circa la divisibilit che non soccombe a una singola invocazione di \ml{METIS\_TAC}: \begin{description} \item [\small{({\it DIVIDES\_LE\/})}] @@ -382,7 +382,7 @@ \chapter{Esempio: il Teorema di Euclide} \verb+ THEN RW_TAC arith_ss [MULT_CLAUSES]+ \\ \end{tabular} \end{description} -Vediamo come questo dimostrato. Il modo pi semplice di iniziare a semplificare +Vediamo come questo dimostrato. Il modo pi semplice di iniziare a semplificare con la definizione di \ml{divides}: \begin{session} \begin{verbatim} @@ -397,16 +397,16 @@ \chapter{Esempio: il Teorema di Euclide} \end{verbatim} \end{session} -Considerando il goal, di base abbiamo tre possibilit: (1) trovare una -collezione di lemmi che insieme implicano il goal e usare -\ml{METIS\_TAC}; (2) fare un case split su $m$; oppure (3) fare un case split su -$x$. La prima non sembra semplice, dal momento che il goal in realt -non calza nella `forma' di un qualsiasi teorema pre-dimostrato di cui l'autore sia a -conoscenza. Bench l'opzione (2) sar rigettata alla fine, proviamola -comunque. Per eseguire il case split, usiamo \verb+Cases_on+, che sta -per ``trova il termine dato nel goal ed esegui un'analisi dei casi sulle -possibilit di costruzione previste dal costruttore del suo datatype'' [corrisponde al pattern matching di ML (ndt)]. Dal momento che -l'occorrenza di $m$ nel goal ha il tipo $num$, i casi considerati saranno +Considerando il goal, di base abbiamo tre possibilit: (1) trovare una +collezione di lemmi che insieme implicano il goal e usare +\ml{METIS\_TAC}; (2) fare un case split su $m$; oppure (3) fare un case split su +$x$. La prima non sembra semplice, dal momento che il goal in realt +non calza nella `forma' di un qualsiasi teorema pre-dimostrato di cui l'autore sia a +conoscenza. Bench l'opzione (2) sar rigettata alla fine, proviamola +comunque. Per eseguire il case split, usiamo \verb+Cases_on+, che sta +per ``trova il termine dato nel goal ed esegui un'analisi dei casi sulle +possibilit di costruzione previste dal costruttore del suo datatype'' [corrisponde al pattern matching di ML (ndt)]. Dal momento che +l'occorrenza di $m$ nel goal ha il tipo $num$, i casi considerati saranno se $m$ $0$ o un successore. \begin{session} \begin{verbatim} @@ -444,20 +444,20 @@ \chapter{Esempio: il Teorema di Euclide} SUC n <= x * SUC n \/ (x = 0) \end{verbatim} \end{session} -Il disgiunto a destra stato semplificato; comunque, il disgiunto a sinistra ha -fallito di espandere la definizione della moltiplicazione nell'espressione -$\mathtt{SUC}\ n * x$, cosa che sarebbe stata conveniente. Di fatto l'ha cambiata +Il disgiunto a destra stato semplificato; comunque, il disgiunto a sinistra ha +fallito di espandere la definizione della moltiplicazione nell'espressione +$\mathtt{SUC}\ n * x$, cosa che sarebbe stata conveniente. Di fatto l'ha cambiata in $x * \mathtt{SUC}\ n$, che non conveniente. -Perch, visto che si suppone che \verb+arith_ss+ e di conseguenza \ml{RW\_TAC} siano esperte -nell'aritmetica? La risposta duplice: primo, le clausole ricorsive per l'addizione e la -moltiplicazione non sono in \verb+arith_ss+ perch una loro applicazione senza controllo -da parte del sistema di riscrittura sembra che, in generale, renda alcune -dimostrazioni \emph{pi} complicate, piuttosto che pi semplici; in secondo luogo, il semplificatore -riorganizzer i termini aritmetici per rendere pi semplici alcune dimostrazioni automatiche. Cos -l'assenza delle clausole ricorsive per la moltiplicazione +Perch, visto che si suppone che \verb+arith_ss+ e di conseguenza \ml{RW\_TAC} siano esperte +nell'aritmetica? La risposta duplice: primo, le clausole ricorsive per l'addizione e la +moltiplicazione non sono in \verb+arith_ss+ perch una loro applicazione senza controllo +da parte del sistema di riscrittura sembra che, in generale, renda alcune +dimostrazioni \emph{pi} complicate, piuttosto che pi semplici; in secondo luogo, il semplificatore +riorganizzer i termini aritmetici per rendere pi semplici alcune dimostrazioni automatiche. Cos +l'assenza delle clausole ricorsive per la moltiplicazione significa che $\mathtt{SUC}\ n * x$ non si espande a $(n * x) + x$; -piuttosto, la riorganizzazione porta a $x * \mathtt{SUC}\; n$. OK, aggiungiamo -la definizione della moltiplicazione. Questo rivela un nuovo problema: come +piuttosto, la riorganizzazione porta a $x * \mathtt{SUC}\; n$. OK, aggiungiamo +la definizione della moltiplicazione. Questo rivela un nuovo problema: come individuare questa definizione. La funzione \begin{holboxed} \begin{verbatim} @@ -467,11 +467,11 @@ \chapter{Esempio: il Teorema di Euclide} \end{holboxed} \noindent - spesso utile a questo scopo. Essa prende una lista di nomi di teorie, e -un pattern, e cerca nella lista delle teorie un teorema, -una definizione, o un assioma che ha un'istanza del pattern come sotto termine. -Se la lista dei nomi di teorie vuota, allora sono incluse nella ricerca -tutte le teorie caricate. Cerchiamo nella teoria dell'aritmetica il + spesso utile a questo scopo. Essa prende una lista di nomi di teorie, e +un pattern, e cerca nella lista delle teorie un teorema, +una definizione, o un assioma che ha un'istanza del pattern come sotto termine. +Se la lista dei nomi di teorie vuota, allora sono incluse nella ricerca +tutte le teorie caricate. Cerchiamo nella teoria dell'aritmetica il sotto termine che deve essere riscritto. \begin{session} @@ -499,8 +499,8 @@ \chapter{Esempio: il Teorema di Euclide} \end{verbatim} \end{session} -Per alcuni, questo restituisce un p troppa informazione; comunque, possiamo -focalizzare la ricerca stabilendo che il pattern appaia come una regola +Per alcuni, questo restituisce un p troppa informazione; comunque, possiamo +focalizzare la ricerca stabilendo che il pattern appaia come una regola di riscrittura: \begin{session} @@ -520,7 +520,7 @@ \chapter{Esempio: il Teorema di Euclide} \end{session} Sia {\small\verb+arithmeticTheory.MULT+} sia -{\small\verb+arithmeticTheory.MULT_CLAUSES+} sarebbero accettabili; +{\small\verb+arithmeticTheory.MULT_CLAUSES+} sarebbero accettabili; scegliamo l'ultima. \begin{session} @@ -536,8 +536,8 @@ \chapter{Esempio: il Teorema di Euclide} SUC n <= x + n * x \/ (x = 0) \end{verbatim} \end{session} -Ora vediamo che, al fine di fare progressi nella dimostrazione, dovremo fare -un case split su $x$ comunque, e che avremmo dovuto fare lo split su di esso +Ora vediamo che, al fine di fare progressi nella dimostrazione, dovremo fare +un case split su $x$ comunque, e che avremmo dovuto fare lo split su di esso fin dall'inizio. Di conseguenza facciamo un backup. Dovremo fare un backup (undo) tre volte. \begin{session} \begin{verbatim} @@ -558,13 +558,13 @@ \chapter{Esempio: il Teorema di Euclide} \end{verbatim} \end{session} -Ora possiamo andare avanti e fare un'analisi dei casi su $x$. Eseguiremo anche\linebreak -l'invocazione a una tattica composta, dal momento che sappiamo gi che dovremo -invocare \ml{RW\_TAC} in entrambi i rami dell'analisi dei casi. Questo pu essere -fatto usando \ml{THEN}. Quando $t_1 \ \mbox{\ml{THEN}}\ t_2$ applicato -a un goal $g$, prima $t_1$ applicato a $g$, dando una lista di nuovi -subgoal, poi $t_2$ applicato ad ogni membro della lista. Tutti i goal -risultanti da queste applicazioni di $t_2$ sono raccolti insieme e +Ora possiamo andare avanti e fare un'analisi dei casi su $x$. Eseguiremo anche\linebreak +l'invocazione a una tattica composta, dal momento che sappiamo gi che dovremo +invocare \ml{RW\_TAC} in entrambi i rami dell'analisi dei casi. Questo pu essere +fatto usando \ml{THEN}. Quando $t_1 \ \mbox{\ml{THEN}}\ t_2$ applicato +a un goal $g$, prima $t_1$ applicato a $g$, dando una lista di nuovi +subgoal, poi $t_2$ applicato ad ogni membro della lista. Tutti i goal +risultanti da queste applicazioni di $t_2$ sono raccolti insieme e restituiti. \begin{session} \begin{verbatim} @@ -578,13 +578,13 @@ \chapter{Esempio: il Teorema di Euclide} |- !m n. m divides n ==> m <= n \/ (n = 0) \end{verbatim} \end{session} -Questo stato facile! Ovviamente fare un case split su $x$ era la scelta -giusta. Il processo di {\it trovare\/} la dimostrazione ora terminato, e -tutto ci che rimane da fare impacchettare la dimostrazione in una singola -tattica come abbiamo visto di sopra. Al posto di usare \ml{top\_thm} e il goalstack, -possiamo bypassarlo e usare la funzione \ml{store\_thm}. Questa funzione -prende una stringa, un termine e una tattica e applica la tattica al termine -per ottenere un teorema, e quindi archivia il teorema nella teoria corrente +Questo stato facile! Ovviamente fare un case split su $x$ era la scelta +giusta. Il processo di {\it trovare\/} la dimostrazione ora terminato, e +tutto ci che rimane da fare impacchettare la dimostrazione in una singola +tattica come abbiamo visto di sopra. Al posto di usare \ml{top\_thm} e il goalstack, +possiamo bypassarlo e usare la funzione \ml{store\_thm}. Questa funzione +prende una stringa, un termine e una tattica e applica la tattica al termine +per ottenere un teorema, e quindi archivia il teorema nella teoria corrente sotto il nome dato. \begin{session} \begin{verbatim} @@ -598,16 +598,16 @@ \chapter{Esempio: il Teorema di Euclide} > val DIVIDES_LE = |- !m n. m divides n ==> m <= n \/ (n = 0) : thm \end{verbatim} \end{session} -Archiviare i teoremi nel nostro script di salvataggio della sessione in questo stile -(piuttosto che con il goalstack) risulta in uno script pi conciso, e -rende anche pi facile trasformare il nostro script in un file di teoria, come facciamo +Archiviare i teoremi nel nostro script di salvataggio della sessione in questo stile +(piuttosto che con il goalstack) risulta in uno script pi conciso, e +rende anche pi facile trasformare il nostro script in un file di teoria, come facciamo nella sessione~\ref{sec:script-to-theory}. \subsection{Divisibilit e fattoriale} -Il prossimo lemma, {\small{\it DIVIDES\_FACT\/}}, dice che ogni numero -maggiore di $0$ e $\leq n$ divide il fattoriale di -$n$. Il fattoriale si trova in \verb+arithmeticTheory.FACT+ ed stato +Il prossimo lemma, {\small{\it DIVIDES\_FACT\/}}, dice che ogni numero +maggiore di $0$ e $\leq n$ divide il fattoriale di +$n$. Il fattoriale si trova in \verb+arithmeticTheory.FACT+ ed stato definito per ricorsione primitiva: \begin{description} \item [\small{({\it FACT\/})}] @@ -618,9 +618,9 @@ \chapter{Esempio: il Teorema di Euclide} \end{verbatim} \end{minipage} \end{description} -Una dimostrazione lucidata di {\small{\it DIVIDES\_FACT\/}} la -seguente\footnote{Questa e le successive dimostrazioni usano i teoremi dimostrati - alla pagina~\pageref{euclid:extra-proofs}, che sono state aggiunte all'ambiente \ML{} +Una dimostrazione lucidata di {\small{\it DIVIDES\_FACT\/}} la +seguente\footnote{Questa e le successive dimostrazioni usano i teoremi dimostrati + alla pagina~\pageref{euclid:extra-proofs}, che sono state aggiunte all'ambiente \ML{} dopo essere state dimostrate.}: \begin{description} \item [\small{({\it DIVIDES\_FACT\/})}] @@ -634,22 +634,22 @@ \chapter{Esempio: il Teorema di Euclide} \verb+ DIVIDES_RMUL, DIVIDES_LMUL, DIVIDES_REFL]+ \\ \end{tabular} \end{description} -Esamineremo questa dimostrazione nel dettaglio, cos dovremmo prima tentare di +Esamineremo questa dimostrazione nel dettaglio, cos dovremmo prima tentare di comprendere perch il teorema vero. Qual l'intuizione sottostante? Supponiamo che $0 < m \leq n$, e cos $\mbox{\tt FACT}\ n = 1 * \cdots * m * -\cdots * n$. Mostrare che $m\ \mbox{\tt divides}\ (\mbox{\tt FACT}\ n)$ +\cdots * n$. Mostrare che $m\ \mbox{\tt divides}\ (\mbox{\tt FACT}\ n)$ significa esibire un $q$ tale che $q * m = \mbox{\tt FACT}\ n$. Cos $q -= \mbox{\tt FACT}\ n \div m$. Se dovessimo intraprendere questo approccio alla -dimostrazione, finiremmo per dover trovare e applicare dei lemmi circa $\div$. -Questo sembra portarci un p fuori strada; non c' una dimostrazione -che non usa la divisione? Ebbene s, possiamo dimostrare il teorema per += \mbox{\tt FACT}\ n \div m$. Se dovessimo intraprendere questo approccio alla +dimostrazione, finiremmo per dover trovare e applicare dei lemmi circa $\div$. +Questo sembra portarci un p fuori strada; non c' una dimostrazione +che non usa la divisione? Ebbene s, possiamo dimostrare il teorema per induzione su $n - m$: nel caso migliore, dovremo dimostrare $n\; -\mbox{\tt divides}\ (\mbox{\tt FACT}\; n)$, che dovrebbe essere facile; nel -caso induttivo, l'ipotesi d'induzione sembrerebbe doverci dare -ci di cui abbiamo bisogno. Questa strategia per il caso induttivo un p vaga, -perch stiamo provando a figurarci mentalmente una formula piuttosto -complicata, ma possiamo contare sul fatto che il sistema calcoli in modo accurato il -i casi d'induzione per noi. Se il caso induttivo si riveler non essere +\mbox{\tt divides}\ (\mbox{\tt FACT}\; n)$, che dovrebbe essere facile; nel +caso induttivo, l'ipotesi d'induzione sembrerebbe doverci dare +ci di cui abbiamo bisogno. Questa strategia per il caso induttivo un p vaga, +perch stiamo provando a figurarci mentalmente una formula piuttosto +complicata, ma possiamo contare sul fatto che il sistema calcoli in modo accurato il +i casi d'induzione per noi. Se il caso induttivo si riveler non essere ci che ci aspettavamo, dovremo ripensare il nostro approccio. \begin{session} \begin{verbatim} @@ -662,7 +662,7 @@ \chapter{Esempio: il Teorema di Euclide} !m n. 0 < m /\ m <= n ==> m divides FACT n \end{verbatim} \end{session} -Al posto di eseguire un'induzione direttamente su $n-m$, faremo un'induzione su una variabile +Al posto di eseguire un'induzione direttamente su $n-m$, faremo un'induzione su una variabile testimone, ottenuta usando il teorema \verb+LESS_EQ_EXISTS+. \begin{session} \begin{verbatim} @@ -707,9 +707,9 @@ \chapter{Esempio: il Teorema di Euclide} 0 < m \end{verbatim} \end{session} -\noindent Ora possiamo fare un'analisi dei casi su $m$: se $0$, abbiamo un -goal banale; se un successore, allora possiamo usare la definizione di -\ml{FACT} e i teoremi \ml{DIVIDES\_RMUL} e +\noindent Ora possiamo fare un'analisi dei casi su $m$: se $0$, abbiamo un +goal banale; se un successore, allora possiamo usare la definizione di +\ml{FACT} e i teoremi \ml{DIVIDES\_RMUL} e \ml{DIVIDES\_REFL}. \begin{session} \begin{verbatim} @@ -727,14 +727,14 @@ \chapter{Esempio: il Teorema di Euclide} \end{verbatim} \end{session} - Qui il primo subgoal ha un'assunzione che falsa, Possiamo - dimostrare questo al sistema usando la funzione -\ml{DECIDE} per dimostrare un semplice fatto dell'aritmetica (cio, che nessun -numero $x$ minore di s stesso), e quindi passare il teorema -risultante a \ml{METIS\_TAC}, che pu combinare questo con l'assunzione -contraddittoria\footnote{Si noti come il sistema interattivo - stampi il teorema dimostrato con \ml{[.]} prima del - turnstile. Questa notazione indica che un teorema ha un'assunzione + Qui il primo subgoal ha un'assunzione che falsa, Possiamo + dimostrare questo al sistema usando la funzione +\ml{DECIDE} per dimostrare un semplice fatto dell'aritmetica (cio, che nessun +numero $x$ minore di s stesso), e quindi passare il teorema +risultante a \ml{METIS\_TAC}, che pu combinare questo con l'assunzione +contraddittoria\footnote{Si noti come il sistema interattivo + stampi il teorema dimostrato con \ml{[.]} prima del + turnstile. Questa notazione indica che un teorema ha un'assunzione (in questo caso l'asserzione falsa $0<0$).}. \begin{session} @@ -753,7 +753,7 @@ \chapter{Esempio: il Teorema di Euclide} 0 < SUC n \end{verbatim} \end{session} -Usando i teoremi identificati di sopra, il subgoal rimanente pu +Usando i teoremi identificati di sopra, il subgoal rimanente pu essere dimostrato con \ml{RW\_TAC}. \begin{session} @@ -771,10 +771,10 @@ \chapter{Esempio: il Teorema di Euclide} 1. m divides FACT (m + p) \end{verbatim} \end{session} -Quest'ultimo passo, cio l'invocazione di \ml{RW\_TAC}, -potrebbe essere ottenuta anche con \ml{METIS\_TAC}. Si noti che -l'unica differenza l'uso di \ml{DIVIDES\_LMUL} nel semplificatore -\emph{al posto di} \ml{DIVIDES\_RMUL} in \ml{METIS\_TAC}. Questo dovuto al +Quest'ultimo passo, cio l'invocazione di \ml{RW\_TAC}, +potrebbe essere ottenuta anche con \ml{METIS\_TAC}. Si noti che +l'unica differenza l'uso di \ml{DIVIDES\_LMUL} nel semplificatore +\emph{al posto di} \ml{DIVIDES\_RMUL} in \ml{METIS\_TAC}. Questo dovuto al gi menzionato riarrangiamento algebrico dei termini aritmetici nel semplificatore. \begin{session} \begin{verbatim} @@ -787,8 +787,8 @@ \chapter{Esempio: il Teorema di Euclide} Goal proved. ... \end{verbatim} \end{session} -Ora abbiamo completato il caso base dell'induzione e possiamo spostarci al -caso di passo. Una cosa ovvia da provare la semplificazione con le +Ora abbiamo completato il caso base dell'induzione e possiamo spostarci al +caso di passo. Una cosa ovvia da provare la semplificazione con le definizioni dell'addizione e del fattoriale: \begin{session} \begin{verbatim} @@ -803,7 +803,7 @@ \chapter{Esempio: il Teorema di Euclide} 1. m divides FACT (m + p) \end{verbatim} \end{session} -\noindent E ora, per mezzo di \ml{DIVIDES\_RMUL} e l'ipotesi d'induzione, abbiamo +\noindent E ora, per mezzo di \ml{DIVIDES\_RMUL} e l'ipotesi d'induzione, abbiamo finito: \begin{session} \begin{verbatim} @@ -818,10 +818,10 @@ \chapter{Esempio: il Teorema di Euclide} |- !m n. 0 < m /\ m <= n ==> m divides FACT n \end{verbatim} \end{session} -Abbiamo concluso la ricerca della dimostrazione, e possiamo spostarci al compito di -creare una singola tattica a partire dalla sequenza delle invocazioni delle tattiche che abbiamo -appena fatto. Assumiamo che sia stata tenuta traccia della sequenza delle invocazioni -in un file o nel buffer di un editor di testo. Avremmo dunque qualcosa +Abbiamo concluso la ricerca della dimostrazione, e possiamo spostarci al compito di +creare una singola tattica a partire dalla sequenza delle invocazioni delle tattiche che abbiamo +appena fatto. Assumiamo che sia stata tenuta traccia della sequenza delle invocazioni +in un file o nel buffer di un editor di testo. Avremmo dunque qualcosa di simile a ci che segue: \begin{hol} \begin{verbatim} @@ -841,8 +841,8 @@ \chapter{Esempio: il Teorema di Euclide} \end{hol} \noindent -Abbiamo aggiunto uno schema di numerazione per tenere traccia dei rami nella -dimostrazione. Possiamo cucire insieme l'espressioni di sopra nella seguente tattica +Abbiamo aggiunto uno schema di numerazione per tenere traccia dei rami nella +dimostrazione. Possiamo cucire insieme l'espressioni di sopra nella seguente tattica composta: \begin{hol} @@ -878,18 +878,18 @@ \chapter{Esempio: il Teorema di Euclide} \end{verbatim} \end{session} -Per molti utenti, questa sarebbe la conclusione di questa dimostrazione: la -tattica ora pu essere impacchettata in un'invocazione di -\ml{prove}\footnote{La funzione \ml{prove} prende un termine e una tattica -e tenta di dimostrare il termine usando la tattica fornita. Essa -restituisce il teorema dimostrato se la tattica ha successo. Essa non salva -il teorema alla teoria sviluppata.} o di \ml{store\_thm} e quella -sarebbe la conclusione. Comunque, un altro utente potrebbe notare +Per molti utenti, questa sarebbe la conclusione di questa dimostrazione: la +tattica ora pu essere impacchettata in un'invocazione di +\ml{prove}\footnote{La funzione \ml{prove} prende un termine e una tattica +e tenta di dimostrare il termine usando la tattica fornita. Essa +restituisce il teorema dimostrato se la tattica ha successo. Essa non salva +il teorema alla teoria sviluppata.} o di \ml{store\_thm} e quella +sarebbe la conclusione. Comunque, un altro utente potrebbe notare che questa tattica potrebbe essere abbreviata. -Per iniziare, entrambi i rami dell'induzione iniziano con un'invocazione di -\ml{RW\_TAC}, e la semantica di \ml{THEN} ci permette di fondere le -occorrenze di \ml{RW\_TAC} prima di \ml{THENL}. La tattica rimaneggiata +Per iniziare, entrambi i rami dell'induzione iniziano con un'invocazione di +\ml{RW\_TAC}, e la semantica di \ml{THEN} ci permette di fondere le +occorrenze di \ml{RW\_TAC} prima di \ml{THENL}. La tattica rimaneggiata \begin{hol} \begin{verbatim} @@ -902,10 +902,10 @@ \chapter{Esempio: il Teorema di Euclide} METIS_TAC [DIVIDES_RMUL]] \end{verbatim} \end{hol} -(Naturalmente, quando una tattica stata rivisitata, dovrebbe essere testata per vedere -se continua a dimostrare il goal!) Ora si ricordi che l'uso di \ml{RW\_TAC} -nel caso base potrebbe essere sostituito da una chiamata a \ml{METIS\_TAC}. Cos -sembra possibile fondere i due sotto casi del caso base in un'unica +(Naturalmente, quando una tattica stata rivisitata, dovrebbe essere testata per vedere +se continua a dimostrare il goal!) Ora si ricordi che l'uso di \ml{RW\_TAC} +nel caso base potrebbe essere sostituito da una chiamata a \ml{METIS\_TAC}. Cos +sembra possibile fondere i due sotto casi del caso base in un'unica invocazione di \ml{METIS\_TAC}: \begin{hol} @@ -920,13 +920,13 @@ \chapter{Esempio: il Teorema di Euclide} \end{hol} \noindent -In fine, spingendo questo revisionismo quasi al suo limite, ci -piacerebbe che ci fosse un'unica invocazione di \ml{METIS\_TAC} per concludere -la dimostrazione. La semantica di \ml{THEN} e di \ml{ALL\_TAC} vengono -in nostro aiuto: divideremo la costruzione di $m$ nel caso base, -come nell'incarnazione attuale della tattica, ma lasceremo il -caso induttivo di passo inalterato attraverso \ml{THENL}. Questo si ottiene -usando \verb+ALL_TAC+, questa una tattica che agisce come una funzione +In fine, spingendo questo revisionismo quasi al suo limite, ci +piacerebbe che ci fosse un'unica invocazione di \ml{METIS\_TAC} per concludere +la dimostrazione. La semantica di \ml{THEN} e di \ml{ALL\_TAC} vengono +in nostro aiuto: divideremo la costruzione di $m$ nel caso base, +come nell'incarnazione attuale della tattica, ma lasceremo il +caso induttivo di passo inalterato attraverso \ml{THENL}. Questo si ottiene +usando \verb+ALL_TAC+, questa una tattica che agisce come una funzione d'identit sul goal. \begin{hol} \begin{verbatim} @@ -940,13 +940,13 @@ \chapter{Esempio: il Teorema di Euclide} \end{hol} \noindent -Il risultato che ci saranno tre subgoal risultanti da -\ml{THENL}: i due sotto casi nel caso base e il caso di passo +Il risultato che ci saranno tre subgoal risultanti da +\ml{THENL}: i due sotto casi nel caso base e il caso di passo inalterato. Ciascuno dimostrato con una chiamata a \ml{METIS\_TAC}. Abbiamo finito ora? Non necessariamente. Per esempio, il case split esplicito, cio \ml{Cases\_on `m`}, -pu essere sostituito fornendo il teorema dei \emph{casi} per i numeri naturali -(\ml{num\_CASES}) a \ml{METIS\_TAC}. Con questo, il case split su $m$, sar -generato automaticamente da \ml{METIS\_TAC} durante la ricerca della dimostrazione. Di conseguenza +pu essere sostituito fornendo il teorema dei \emph{casi} per i numeri naturali +(\ml{num\_CASES}) a \ml{METIS\_TAC}. Con questo, il case split su $m$, sar +generato automaticamente da \ml{METIS\_TAC} durante la ricerca della dimostrazione. Di conseguenza possiamo abbreviare la tattica di nuovo. \begin{session} \begin{verbatim} @@ -960,17 +960,17 @@ \chapter{Esempio: il Teorema di Euclide} DIVIDES_RMUL, DIVIDES_LMUL, DIVIDES_REFL, ADD_CLAUSES]); \end{verbatim} \end{session} -Ora abbiamo concluso il nostro esercizio di revisione delle tattiche. Certamente, -sarebbe difficile indovinare che questa tattica finale dimostrerebbe il -goal; i lemmi richiesti per l'invocazione finale di \ml{METIS\_TAC} +Ora abbiamo concluso il nostro esercizio di revisione delle tattiche. Certamente, +sarebbe difficile indovinare che questa tattica finale dimostrerebbe il +goal; i lemmi richiesti per l'invocazione finale di \ml{METIS\_TAC} sono stati trovati attraverso un processo incrementale di revisione. \subsection{Divisibilit e fattoriale (di nuovo!)} -Nella precedente dimostrazione, abbiamo fatto un passo di semplificazione iniziale al fine -di esporre una variabile su cui indurre. Comunque, la dimostrazione in realt - su $n - m$. Possiamo esprimere questo in modo diretto? La -risposta un s con riserva: l'induzione pu essere dichiarata in modo naturale, ma +Nella precedente dimostrazione, abbiamo fatto un passo di semplificazione iniziale al fine +di esporre una variabile su cui indurre. Comunque, la dimostrazione in realt + su $n - m$. Possiamo esprimere questo in modo diretto? La +risposta un s con riserva: l'induzione pu essere dichiarata in modo naturale, ma porta a dei goal in qualche modo meno naturali. \begin{session} \begin{verbatim} @@ -988,9 +988,9 @@ \chapter{Esempio: il Teorema di Euclide} !n m. (0 = n - m) ==> 0 < m /\ m <= n ==> m divides FACT n \end{verbatim} \end{session} - Questo leggermente complicato da leggere, cos usiamo \ml{STRIP\_TAC} e - \ml{REPEAT} per spostare gli antecedenti dei goal nelle - assunzioni. L'uso di \ml{THEN} assicura che la tatticca venga applicata + Questo leggermente complicato da leggere, cos usiamo \ml{STRIP\_TAC} e + \ml{REPEAT} per spostare gli antecedenti dei goal nelle + assunzioni. L'uso di \ml{THEN} assicura che la tatticca venga applicata in entrambi i rami dell'induzione. \begin{session} \begin{verbatim} @@ -1035,7 +1035,7 @@ \chapter{Esempio: il Teorema di Euclide} \end{verbatim} \end{session} -\noindent Ora possiamo usare \ml{RW\_TAC} per propagare l'uguaglianza appena derivata +\noindent Ora possiamo usare \ml{RW\_TAC} per propagare l'uguaglianza appena derivata attraverso il goal. \begin{session} \begin{verbatim} @@ -1051,24 +1051,24 @@ \chapter{Esempio: il Teorema di Euclide} 2. m <= m \end{verbatim} \end{session} - A questo punto nella dimostrazione precedente abbiamo fatto un'analisi dei casi su $m$. - Comunque, abbiamo gi l'ipotesi che $m$ positivo - (insieme alle altre due ipotesi al momento inutili). Cos sappiamo che - $m$ il successore di qualche numero $k$. Potremmo desiderare di affermare + A questo punto nella dimostrazione precedente abbiamo fatto un'analisi dei casi su $m$. + Comunque, abbiamo gi l'ipotesi che $m$ positivo + (insieme alle altre due ipotesi al momento inutili). Cos sappiamo che + $m$ il successore di qualche numero $k$. Potremmo desiderare di affermare questo fatto con un'invocazione di ``\ml{by}'' nel modo seguente: \[ \mbox{\ml{`?k. m = SUC k` by }} \] -Ma qual la tattica? Se proviamo \ml{DECIDE\_TAC}, essa fallir dal momento che -non gestisce enunciati esistenziali. Anche un'applicazione di +Ma qual la tattica? Se proviamo \ml{DECIDE\_TAC}, essa fallir dal momento che +non gestisce enunciati esistenziali. Anche un'applicazione di \ml{RW\_TAC} si dimostrer insoddisfacente. Cosa fare? -Quando capita una situazione di questo tipo, spesso meglio iniziare una nuova dimostrazione per il -lemma richiesto. Questo si pu fare semplicemente invocando ``\ml{g}'' -di nuovo. Un nuovo goalstack sar creato e aggiunto a quello -corrente\footnote{Questa aggiunta di tentativi di dimostrazione (goalstack) differente - dall'aggiunta di goal e giustificazioni all'interno di un particolare - goalstack.} e sar stampata una panoramica dei tentativi di dimostrazione +Quando capita una situazione di questo tipo, spesso meglio iniziare una nuova dimostrazione per il +lemma richiesto. Questo si pu fare semplicemente invocando ``\ml{g}'' +di nuovo. Un nuovo goalstack sar creato e aggiunto a quello +corrente\footnote{Questa aggiunta di tentativi di dimostrazione (goalstack) differente + dall'aggiunta di goal e giustificazioni all'interno di un particolare + goalstack.} e sar stampata una panoramica dei tentativi di dimostrazione esistenti: \begin{session} \begin{verbatim} @@ -1093,9 +1093,9 @@ \chapter{Esempio: il Teorema di Euclide} !m. 0 < m ==> ?k. m = SUC k \end{verbatim} \end{session} - Il nostro nuovo goal pu essere dimostrato abbastanza velocemente. Una volta che lo abbiamo dimostrato, - possiamo legarlo a un nome ML e usarlo nella dimostrazione precedente, per - mezzo di una specie di gioco di prestigio con la funzione ``\ml{before}''\footnote{Una + Il nostro nuovo goal pu essere dimostrato abbastanza velocemente. Una volta che lo abbiamo dimostrato, + possiamo legarlo a un nome ML e usarlo nella dimostrazione precedente, per + mezzo di una specie di gioco di prestigio con la funzione ``\ml{before}''\footnote{Una versione infissa del combinatore {\tt K}, definito da {\tt fun (x before y) = x}.} \begin{session} @@ -1114,8 +1114,8 @@ \chapter{Esempio: il Teorema di Euclide} \end{verbatim} \end{session} -Ora possiamo ritornare al filo principale della dimostrazione. Lo stato del -subgoal corrente della dimostrazione pu essere mostrato usando la funzione +Ora possiamo ritornare al filo principale della dimostrazione. Lo stato del +subgoal corrente della dimostrazione pu essere mostrato usando la funzione ``\ml{p}''. \begin{session} @@ -1130,8 +1130,8 @@ \chapter{Esempio: il Teorema di Euclide} 2. m <= m \end{verbatim} \end{session} - Ora possiamo usare \ml{lem} nella dimostrazione. Un p opportunisticamente, - vireremo sull'invocazione usata nella precedente dimostrazione (pi o meno) + Ora possiamo usare \ml{lem} nella dimostrazione. Un p opportunisticamente, + vireremo sull'invocazione usata nella precedente dimostrazione (pi o meno) allo stesso punto, sperando che questo risolva il goal: \begin{session} \begin{verbatim} @@ -1152,11 +1152,11 @@ \chapter{Esempio: il Teorema di Euclide} 3. m <= n \end{verbatim} \end{session} - Funziona! Questo si occupa del caso base, Per il passo d'induzione, + Funziona! Questo si occupa del caso base, Per il passo d'induzione, le cose sembrano un p pi complicate che nella dimostrazione precedente. - Comunque, possiamo fare progressi realizzando che l'ipotesi - implica che $0 < n$ e cos, di nuovo per mezzo di \ml{lem}, possiamo trasformare $n$ - in un successore, abilitando di conseguenza l'espansione di \ml{FACT}, come nella + Comunque, possiamo fare progressi realizzando che l'ipotesi + implica che $0 < n$ e cos, di nuovo per mezzo di \ml{lem}, possiamo trasformare $n$ + in un successore, abilitando di conseguenza l'espansione di \ml{FACT}, come nella dimostrazione precedente: \begin{session} \begin{verbatim} @@ -1187,13 +1187,13 @@ \chapter{Esempio: il Teorema di Euclide} |- !m n. 0 < m /\ m <= n ==> m divides FACT n \end{verbatim} \end{session} -\noindent Lasciamo i dettagli del cucire insieme la dimostrazione al lettore +\noindent Lasciamo i dettagli del cucire insieme la dimostrazione al lettore interessato. \section{Primariet} -Ora ci spostiamo a stabilire alcuni fatti circa la primariet dei -primi numeri: $0$ e $1$ non sono primi, ma $2$ lo . Inoltre, tutti +Ora ci spostiamo a stabilire alcuni fatti circa la primariet dei +primi numeri: $0$ e $1$ non sono primi, ma $2$ lo . Inoltre, tutti i primi sono positivi. Queste sono piuttosto semplici da dimostrare. \begin{description} @@ -1228,18 +1228,18 @@ \chapter{Esempio: il Teorema di Euclide} \section{Esistenza dei fattori primi} -Ora siamo nella posizione di dimostrare un lemma pi sostanziale: ogni numero -diverso da $1$ ha un fattore primo. La dimostrazione procede attraverso -un'\emph{induzione completa} su $n$. L'induzione completa -necessaria dal momento che un fattore primo non sar un predecessore. Dopo -l'induzione, la dimostrazione si divide nei casi se $n$ primo o -no. Il primo caso ($n$ primo) -banale. Nel secondo caso, ci deve essere un $x$ che divide $n$, e -$x$ non $1$ o $n$. Per {\small\it DIVIDES\_LE}, $n=0$ o $x \leq n$. Se +Ora siamo nella posizione di dimostrare un lemma pi sostanziale: ogni numero +diverso da $1$ ha un fattore primo. La dimostrazione procede attraverso +un'\emph{induzione completa} su $n$. L'induzione completa +necessaria dal momento che un fattore primo non sar un predecessore. Dopo +l'induzione, la dimostrazione si divide nei casi se $n$ primo o +no. Il primo caso ($n$ primo) +banale. Nel secondo caso, ci deve essere un $x$ che divide $n$, e +$x$ non $1$ o $n$. Per {\small\it DIVIDES\_LE}, $n=0$ o $x \leq n$. Se $n=0$, allora $2$ un primo che divide $0$. Dall'altro lato, se $x \leq -n$, ci sono due casi: se $x < n$ allora possiamo usare l'ipotesi -d'induzione e per la transitivit di \ml{divides} abbiamo finito; altrimenti, -$x=n$ e quindi abbiamo una contraddizione con il fatto che $x$ non $1$ +n$, ci sono due casi: se $x < n$ allora possiamo usare l'ipotesi +d'induzione e per la transitivit di \ml{divides} abbiamo finito; altrimenti, +$x=n$ e quindi abbiamo una contraddizione con il fatto che $x$ non $1$ n $n$. La tattica ripulita la seguente: \begin{description} \item [\small{({\it PRIME\_FACTOR\/})}] @@ -1255,7 +1255,7 @@ \section{Esistenza dei fattori primi} \verb+ DIVIDES_LE,DIVIDES_TRANS,DIVIDES_0]]+ \\ \end{tabular} \end{description} -Iniziamo invocando l'induzione completa. Questo ci d un'ipotesi +Iniziamo invocando l'induzione completa. Questo ci d un'ipotesi d'induzione che vale per ogni numero $m$ strettamente minore di $n$: \begin{session} \begin{verbatim} @@ -1270,8 +1270,8 @@ \section{Esistenza dei fattori primi} !m. m < n ==> ~(m = 1) ==> ?p. prime p /\ p divides m \end{verbatim} \end{session} -Possiamo spostare l'antecedente nelle ipotesi e fare il nostro case -split. Si noti che il termine dato a \ml{Cases\_on} non deve per forza essere nel +Possiamo spostare l'antecedente nelle ipotesi e fare il nostro case +split. Si noti che il termine dato a \ml{Cases\_on} non deve per forza essere nel goal: \begin{session} \begin{verbatim} @@ -1292,7 +1292,7 @@ \section{Esistenza dei fattori primi} 2. prime n \end{verbatim} \end{session} -\noindent Come menzionato, il primo caso dimostrato con la riflessivit della +\noindent Come menzionato, il primo caso dimostrato con la riflessivit della divisibilit: \begin{session} \begin{verbatim} @@ -1304,7 +1304,7 @@ \section{Esistenza dei fattori primi} \end{verbatim} \end{session} \noindent -Nel secondo caso, otteniamo un divisore di $n$ che non $1$ n $n$ +Nel secondo caso, otteniamo un divisore di $n$ che non $1$ n $n$ (dal momento che $n$ non primo): \begin{session} \begin{verbatim} @@ -1323,9 +1323,9 @@ \section{Esistenza dei fattori primi} 5. ~(x = n) \end{verbatim} \end{session} -A questo punto, la tattica ripulita invoca semplicemente \ml{METIS\_TAC} con -una collezione di teoremi. Tenteremo un'esposizione pi -dettagliata. Data l'ipotesi, e {\small\it DIVIDES\_LE}, possiamo +A questo punto, la tattica ripulita invoca semplicemente \ml{METIS\_TAC} con +una collezione di teoremi. Tenteremo un'esposizione pi +dettagliata. Data l'ipotesi, e {\small\it DIVIDES\_LE}, possiamo affermare $x < n \lor n = 0$ e cos dividere la dimostrazione in due casi: \begin{session} \begin{verbatim} @@ -1355,9 +1355,9 @@ \section{Esistenza dei fattori primi} 6. x < n \end{verbatim} \end{session} -Nel primo subgoal, possiamo vedere che gli antecedenti dell'ipotesi -d'induzione sono soddisfatti e cos $x$ ha un divisore primo. Possiamo quindi usare -la transitivit della divisibilit per ottenere il fatto che questo divisore di $x$ +Nel primo subgoal, possiamo vedere che gli antecedenti dell'ipotesi +d'induzione sono soddisfatti e cos $x$ ha un divisore primo. Possiamo quindi usare +la transitivit della divisibilit per ottenere il fatto che questo divisore di $x$ anche un divisore di $n$, concludendo quindi questo ramo della dimostrazione: \begin{session} \begin{verbatim} @@ -1401,7 +1401,7 @@ \section{Esistenza dei fattori primi} 5. ~(x = 0) \end{verbatim} \end{session} -I due passi della semplificazione esplorativa ci hanno portato a uno stato dove +I due passi della semplificazione esplorativa ci hanno portato a uno stato dove tutto ci che dobbiamo fare esibire un primo. E ne abbiamo gi uno a portata di mano: \begin{session} \begin{verbatim} @@ -1415,9 +1415,9 @@ \section{Esistenza dei fattori primi} |- !n. ~(n = 1) ==> ?p. prime p /\ p divides n \end{verbatim} \end{session} -Di nuovo, necessario fare del lavoro per comporre e magari ripulire una singola +Di nuovo, necessario fare del lavoro per comporre e magari ripulire una singola tattica, dai passi individuali di dimostrazione, ma non lo descriveremo\footnote{ -Di fatto, la tattica pu essere semplificata in un'induzione completa +Di fatto, la tattica pu essere semplificata in un'induzione completa seguita da un'invocazione di \ml{METIS\_TAC} con lemmi adeguati.}. Piuttosto andiamo avanti, perch il nostro obiettivo finale a portata di mano. @@ -1425,10 +1425,10 @@ \section{Il teorema di Euclide} \noindent{\bf Teorema.} Ogni numero ha un primo pi grande di lui.\\ \noindent {\it Dimostrazione Informale.} \\ -\noindent Assumiamo l'opposto; allora c' un $n$ +\noindent Assumiamo l'opposto; allora c' un $n$ tale che tutti i $p$ pi grandi di $n$ non sono primi. Si consideri $\mbox{\tt -FACT}(n) + 1$: esso non uguale a 1 cos, per {\small{\it PRIME\_FACTOR}}, -c' un primo $p$ che lo divide. Si noti che $p$ divide anche +FACT}(n) + 1$: esso non uguale a 1 cos, per {\small{\it PRIME\_FACTOR}}, +c' un primo $p$ che lo divide. Si noti che $p$ divide anche $\mbox{\tt FACT}(n)$ perch $p \leq n$\footnote{Per {\small{\it DIVIDES\_FACT}} [ndt].}. Per {\small{\it DIVIDES\_ADDL}}, abbiamo $p=1$. Ma allora $p$ non primo, il che una contraddizione. \\ \noindent {\it Fine della dimostrazione}. @@ -1445,15 +1445,15 @@ \section{Il teorema di Euclide} \verb+ DIVIDES_FACT, DIVIDES_ADDL, DIVIDES_ONE]+ \\ \end{tabular} \end{description} -Consideriamo questo a parte e osserviamolo nel dettaglio. Una dimostrazione per -contraddizione pu essere avviata usando la funzione di \ml{bossLib} -\ml{SPOSE\_NOT\_THEN}. Con essa, si assume la negazione del -goal attuale e quindi la si usa nel tentativo di dimostrare la falsit +Consideriamo questo a parte e osserviamolo nel dettaglio. Una dimostrazione per +contraddizione pu essere avviata usando la funzione di \ml{bossLib} +\ml{SPOSE\_NOT\_THEN}. Con essa, si assume la negazione del +goal attuale e quindi la si usa nel tentativo di dimostrare la falsit (\verb+F+). La negazione assunta $\neg(\forall n.\ \exists p.\ n < p \land \mbox{\tt prime}\ p)$ semplificata un p in $\exists n.\ -\forall p.\ n < p \supset \, \neg \,\mbox{\tt prime}\ p$ e poi -passata alla tattica \ml{STRIP\_ASSUME\_TAC}. Questo sposta il suo argomento -alla lista delle assunzioni del goal dopo aver eliminato la quantificazione +\forall p.\ n < p \supset \, \neg \,\mbox{\tt prime}\ p$ e poi +passata alla tattica \ml{STRIP\_ASSUME\_TAC}. Questo sposta il suo argomento +alla lista delle assunzioni del goal dopo aver eliminato la quantificazione esistenziale su $n$. \begin{session} \begin{verbatim} @@ -1468,16 +1468,16 @@ \section{Il teorema di Euclide} !p. n < p ==> ~prime p \end{verbatim} \end{session} -Cos abbiamo l'ipotesi che tutti i $p$ al di sopra di un certo $n$ non -specificato non sono primi, e il nostro compito di mostrare che ci non pu essere. A questo -punto approfittiamo della grande ispirazione di Euclide e costruiamo un -termine esplicito da $n$. Nella dimostrazione informale ci viene chiesto di `considerare' -il termine $\mbox{\tt FACT}\ n + 1$\footnote{Il parser di HOL pensa che +Cos abbiamo l'ipotesi che tutti i $p$ al di sopra di un certo $n$ non +specificato non sono primi, e il nostro compito di mostrare che ci non pu essere. A questo +punto approfittiamo della grande ispirazione di Euclide e costruiamo un +termine esplicito da $n$. Nella dimostrazione informale ci viene chiesto di `considerare' +il termine $\mbox{\tt FACT}\ n + 1$\footnote{Il parser di HOL pensa che $\mbox{\tt FACT}\ n + 1$ sia equivalente a $(\mbox{\tt FACT}\ n) + 1$.} -Questo termine avr certe propriet (cio, ha un fattore primo) che -porta a una contraddizione. Domanda: come `consideriamo' questo termine nella -dimostrazione formale HOL? Risposta: istanziando un lemma con esso e portando il -lemma nella dimostrazione. Il lemma e la sua istanziazione sono \footnote{La +Questo termine avr certe propriet (cio, ha un fattore primo) che +porta a una contraddizione. Domanda: come `consideriamo' questo termine nella +dimostrazione formale HOL? Risposta: istanziando un lemma con esso e portando il +lemma nella dimostrazione. Il lemma e la sua istanziazione sono \footnote{La funzione {\tt SPEC} implementa la regola della specializzazione universale.}: \begin{session} \begin{verbatim} @@ -1489,10 +1489,10 @@ \section{Il teorema di Euclide} |- ~(FACT n + 1 = 1) ==> (?p. prime p /\ p divides FACT n + 1) \end{verbatim} \end{session} -E' evidente che l'antecedente di \ml{th} pu essere eliminato. In -\holn{}, si potrebbe fare questo in un cosiddetto stile di dimostrazione {\it in avanti\/} (dimostrando +E' evidente che l'antecedente di \ml{th} pu essere eliminato. In +\holn{}, si potrebbe fare questo in un cosiddetto stile di dimostrazione {\it in avanti\/} (dimostrando $\vdash \neg(\mbox{\tt FACT}\ n + 1 = 1)$ e poi applicando {\it -modus ponens}, il cui risultato pu poi essere usato nella dimostrazione), oppure +modus ponens}, il cui risultato pu poi essere usato nella dimostrazione), oppure si potrebbe portare \ml{th} nella dimostrazione e semplificarlo {\it in situ}. Scegliamo il secondo approccio. \begin{session} @@ -1506,8 +1506,8 @@ \section{Il teorema di Euclide} !p. n < p ==> ~prime p \end{verbatim} \end{session} - L'invocazione di \ml{MP\_TAC} ($\vdash M$) applicata a un goal - $(\Delta, g)$ restituisce il goal $(\Delta, M \supset g)$. Ora + L'invocazione di \ml{MP\_TAC} ($\vdash M$) applicata a un goal + $(\Delta, g)$ restituisce il goal $(\Delta, M \supset g)$. Ora semplifichiamo: \begin{session} \begin{verbatim} @@ -1525,8 +1525,8 @@ \section{Il teorema di Euclide} !p. n < p ==> ~prime p \end{verbatim} \end{session} - Si ricordi che zero minore di qualsiasi fattoriale, un fatto che si trova in - \ml{arithmeticTheory} sotto il nome \ml{FACT\_LESS}. Cos possiamo + Si ricordi che zero minore di qualsiasi fattoriale, un fatto che si trova in + \ml{arithmeticTheory} sotto il nome \ml{FACT\_LESS}. Cos possiamo risolvere il goal principale per semplificazione: \begin{session} \begin{verbatim} @@ -1535,13 +1535,13 @@ \section{Il teorema di Euclide} Goal proved. ... \end{verbatim} \end{session} -Si noti l'uso `on-the-fly' di \verb+DECIDE+ per fornire una riscrittura -\textit{ad hoc}. Osservando il goal rimanente, si potrebbe pensare che il nostro obiettivo, di -dimostrare la falsit, andato perso. Ma questo non vero: un goal +Si noti l'uso `on-the-fly' di \verb+DECIDE+ per fornire una riscrittura +\textit{ad hoc}. Osservando il goal rimanente, si potrebbe pensare che il nostro obiettivo, di +dimostrare la falsit, andato perso. Ma questo non vero: un goal $\neg P \lor \neg Q$ logicamente equivalente a $P \imp Q \imp \mathtt{F}$. -Nell'invocazione seguente, usiamo l'uguaglianza -$\vdash A \imp B = \neg A \lor B$ come una regola di riscrittura orientata da destra a sinistra per mezzo -dell'uso di \ml{GSYM}\footnote{In parole povere, \ml{GSYM} scambia i lati sinistro e +Nell'invocazione seguente, usiamo l'uguaglianza +$\vdash A \imp B = \neg A \lor B$ come una regola di riscrittura orientata da destra a sinistra per mezzo +dell'uso di \ml{GSYM}\footnote{In parole povere, \ml{GSYM} scambia i lati sinistro e destro di qualsiasi equazione che trova.}. \begin{session} \begin{verbatim} @@ -1560,7 +1560,7 @@ \section{Il teorema di Euclide} \end{verbatim} \end{session} -Possiamo procedere velocemente per mostrare che $p \ \mathtt{divides}\ (\mathtt{FACT}\; n)$, +Possiamo procedere velocemente per mostrare che $p \ \mathtt{divides}\ (\mathtt{FACT}\; n)$, e di conseguenza che $p = 1$, quindi che $p$ non primo, a quel punto abbiamo finito. Questo pu essere impacchettato tutto in una singola invocazione di \ml{METIS\_TAC}: \begin{session} @@ -1586,17 +1586,17 @@ \section{Il teorema di Euclide} |- !n. ?p. n < p /\ prime p : goalstack \end{verbatim} \end{session} - Il teorema di Euclide ora dimostrato, e possiamo riposare. Comunque, questa - presentazione della dimostrazione finale sar insoddisfacente per alcuni, - dal momento che la dimostrazione completamente nascosta nell'invocazione del - ragionatore automatico. Bene allora, proviamo un'altra dimostrazione, questa volta - impiegando il cosiddetto stile `asserzionale'. Quando usato in modo uniforme, - questo permette una presentazione leggibile e lineare che rispecchia la - dimostrazione informale. Il seguente dimostra il teorema di Euclide nello - stile asserzionale. Pensiamo che sia abbastanza leggibile, certamente molto - di pi della dimostrazione standard basata su tattiche appena data\footnote{Si noti - che {\tt CCONTR\_TAC}, che utilizzata per avviare la dimostrazione, - istanzia una dimostrazione per contraddizione negando il goal e + Il teorema di Euclide ora dimostrato, e possiamo riposare. Comunque, questa + presentazione della dimostrazione finale sar insoddisfacente per alcuni, + dal momento che la dimostrazione completamente nascosta nell'invocazione del + ragionatore automatico. Bene allora, proviamo un'altra dimostrazione, questa volta + impiegando il cosiddetto stile `asserzionale'. Quando usato in modo uniforme, + questo permette una presentazione leggibile e lineare che rispecchia la + dimostrazione informale. Il seguente dimostra il teorema di Euclide nello + stile asserzionale. Pensiamo che sia abbastanza leggibile, certamente molto + di pi della dimostrazione standard basata su tattiche appena data\footnote{Si noti + che {\tt CCONTR\_TAC}, che utilizzata per avviare la dimostrazione, + istanzia una dimostrazione per contraddizione negando il goal e spostandolo nelle ipotesi, lasciando {\tt F} come il nuovo goal.}. \begin{description} @@ -1622,29 +1622,29 @@ \section{Il teorema di Euclide} \section{Trasformare lo script in una teoria} \label{sec:script-to-theory} -Avendo dimostrato il nostro risultato, probabilmente vogliamo impacchettarlo in un modo -che lo renda disponibile per le sessioni future, ma che non ci richieda di -di passare di nuovo attraverso lo sforzo di dimostrare il teorema. Persino avere -uno script completo da cui sia possibile fare un copia e incolla una +Avendo dimostrato il nostro risultato, probabilmente vogliamo impacchettarlo in un modo +che lo renda disponibile per le sessioni future, ma che non ci richieda di +di passare di nuovo attraverso lo sforzo di dimostrare il teorema. Persino avere +uno script completo da cui sia possibile fare un copia e incolla una soluzione soggetta ad errori. -Al fine di fare questo abbiamo bisogno un file con il nome -$x$\ml{Script.sml}, dove $x$ il nome della teoria che desideriamo -esportare. Questo file ha quindi bisogno di essere compilato. Di fatto, usiamo realmente -il compilatore di Moscow ML, accuratamente aumentato con il contesto logico -appropriato. Comunque, il linguaggio accettato dal compilatore non -esattamente lo stesso di quello accettato dal sistema interattivo, cos abbiamo -bisogno di fare un poco di lavoro per smussare lo script originario nella +Al fine di fare questo abbiamo bisogno un file con il nome +$x$\ml{Script.sml}, dove $x$ il nome della teoria che desideriamo +esportare. Questo file ha quindi bisogno di essere compilato. Di fatto, usiamo realmente +il compilatore di Moscow ML, accuratamente aumentato con il contesto logico +appropriato. Comunque, il linguaggio accettato dal compilatore non +esattamente lo stesso di quello accettato dal sistema interattivo, cos abbiamo +bisogno di fare un poco di lavoro per smussare lo script originario nella forma corretta. -Daremo un'illustrazione di conversione a una forma che possa essere +Daremo un'illustrazione di conversione a una forma che possa essere compilata usando lo script \[ \mbox{\ml{/examples/euclid.sml}} -\] come nostra linea di base. Questo -file gi vicino ad essere nella forma corretta. Ha tutte le -dimostrazioni dei teoremi in una forma ``cucita'' cos che quando eseguito, non -coinvolge per nulla il goal-stack. Nella sua forma data, pu essere eseguito +\] come nostra linea di base. Questo +file gi vicino ad essere nella forma corretta. Ha tutte le +dimostrazioni dei teoremi in una forma ``cucita'' cos che quando eseguito, non +coinvolge per nulla il goal-stack. Nella sua forma data, pu essere eseguito come input per \textsf{hol} cos: \setcounter{sessioncount}{0} @@ -1662,30 +1662,30 @@ \section{Trasformare lo script in una teoria} \end{verbatim} \end{session} -Comunque, vogliamo creare una \ml{euclidTheory} che possiamo caricare in -altre sessioni interattive. Cos, il nostro primo passo creare un file -\ml{euclidScript.sml}, e copiare in esso il corpo di +Comunque, vogliamo creare una \ml{euclidTheory} che possiamo caricare in +altre sessioni interattive. Cos, il nostro primo passo creare un file +\ml{euclidScript.sml}, e copiare in esso il corpo di \ml{euclid.sml} -La prima linea non-commentata apre \ml{arithmeticTheory}. Comunque, quando -si scrive per il compilatore, necessario menzionare esplicitamente gli altri +La prima linea non-commentata apre \ml{arithmeticTheory}. Comunque, quando +si scrive per il compilatore, necessario menzionare esplicitamente gli altri moduli \HOL{} da cui dipende. Dobbiamo aggiungere \[ \mbox{\ml{open HolKernel boolLib Parse bossLib}} \] -La linea successiva che presenta una difficolt +La linea successiva che presenta una difficolt \[ \mbox{\ml{set\_fixity "divides" (Infixr 450);}} \] -Mentre legittimo digitare espressioni direttamente nel -sistema interattivo, il compilatore richiede che ogni espressione di primo livello -sia una dichiarazione. Soddisfiamo questo requisito alterando questa linea -in una dichiarazione ``non fare nulla'' che non registra il risultato +Mentre legittimo digitare espressioni direttamente nel +sistema interattivo, il compilatore richiede che ogni espressione di primo livello +sia una dichiarazione. Soddisfiamo questo requisito alterando questa linea +in una dichiarazione ``non fare nulla'' che non registra il risultato dell'espressione: \[ \mbox{\ml{val \_{} = set\_fixity "divides" (Infixr 450)}} \] -Gli unici altri cambiamenti extra sono inserire tra parentesi il resto del testo dello script +Gli unici altri cambiamenti extra sono inserire tra parentesi il resto del testo dello script con le chiamate a \ml{new\_theory} e \ml{export\_theory}. Cos, prima della definizione di \ml{divides}, aggiungiamo: \[ @@ -1696,8 +1696,8 @@ \section{Trasformare lo script in una teoria} \mbox{\ml{val \_{} = export\_theory();}} \] -Ora, possiamo compilare lo script che abbiamo creato usando lo -strumento \textsf{Holmake}. Per mantenere le cose un p pi ordinate, per prima cosa spostiamo +Ora, possiamo compilare lo script che abbiamo creato usando lo +strumento \textsf{Holmake}. Per mantenere le cose un p pi ordinate, per prima cosa spostiamo il nostro script in una nuova directory. \begin{session} @@ -1724,9 +1724,9 @@ \section{Trasformare lo script in una teoria} \end{verbatim} \end{session} -Ora abbiamo creato quattro nuovi file, varie forme di \ml{euclidTheory} -con quattro differenti suffissi. Solo \ml{euclidTheory.sig} realmente -adatta per un consumo da parte dell'uomo. Mentre siamo ancora nella directory +Ora abbiamo creato quattro nuovi file, varie forme di \ml{euclidTheory} +con quattro differenti suffissi. Solo \ml{euclidTheory.sig} realmente +adatta per un consumo da parte dell'uomo. Mentre siamo ancora nella directory \ml{euclid} che abbiamo creato, possiamo provare: \begin{session} @@ -1750,97 +1750,97 @@ \section{Trasformare lo script in una teoria} \section{Sommario} -Il lettore ora ha visto un teorema interessante dimostrato, in grande dettaglio, -in \holn{}. La discussione ha illustrato gli strumenti di alto livello forniti in -\ml{bossLib} e ha toccato questioni che includono la selezione degli strumenti, l'undo, -la `levigatura delle tattiche', la semplificazione esplorativa, e la `biforcazione' di -nuovi tentativi di dimostrazione. Abbiamo anche tentato di dare un'idea dei processi di -pensiero che un utente potrebbe impiegare. Ci che segue una raccolta pi o meno +Il lettore ora ha visto un teorema interessante dimostrato, in grande dettaglio, +in \holn{}. La discussione ha illustrato gli strumenti di alto livello forniti in +\ml{bossLib} e ha toccato questioni che includono la selezione degli strumenti, l'undo, +la `levigatura delle tattiche', la semplificazione esplorativa, e la `biforcazione' di +nuovi tentativi di dimostrazione. Abbiamo anche tentato di dare un'idea dei processi di +pensiero che un utente potrebbe impiegare. Ci che segue una raccolta pi o meno casuale di altre osservazioni. \begin{itemize} -\item Nonostante la dimostrazione del teorema di Euclide sia breve e semplice da -comprendere quando presentata in modo informale, stata richiesta una quantit -forse sorprendente di sviluppo a supporto dell'impostazione dell'argomento +\item Nonostante la dimostrazione del teorema di Euclide sia breve e semplice da +comprendere quando presentata in modo informale, stata richiesta una quantit +forse sorprendente di sviluppo a supporto dell'impostazione dell'argomento classico di Euclide. \item Il supporto alla dimostrazione fornito da \ml{bossLib} (\verb+RW_TAC+, \ml{METIS\_TAC}, \ml{DECIDE\_TAC}, \ml{DECIDE}, -\ml{Cases\_on}, \ml{Induct\_on}, e dal costrutto ``\ml{by}'') stato -quasi completo per questo esempio: raramente stato necessario ricorrere a +\ml{Cases\_on}, \ml{Induct\_on}, e dal costrutto ``\ml{by}'') stato +quasi completo per questo esempio: raramente stato necessario ricorrere a tattiche di basso livello. -\item La semplificazione un cavallo di battaglia delle tattiche; persino quando stato usato -un ragionatore automatico come \ml{METIS\_TAC}, la sua applicazione stata spesso -preparata da qualche semplificazione esplorativa. Vale la pena quindi prendere +\item La semplificazione un cavallo di battaglia delle tattiche; persino quando stato usato +un ragionatore automatico come \ml{METIS\_TAC}, la sua applicazione stata spesso +preparata da qualche semplificazione esplorativa. Vale la pena quindi prendere confidenza con i punti di forza e di debolezza del semplificatore. -\item Un problema comune con i sistemi interattivi di dimostrazione trattare con -le ipotesi. Spesso \ml{METIS\_TAC} e il costrutto ``\ml{by}'' permettono -di usare le ipotesi senza ricorrere direttamente alla loro indicizzazione -(o al dar loro un nome, che equivale alla stessa cosa). Questo desiderabile, -dal momento che le ipotesi sono concettualmente un {\it insieme}, e inoltre, -l'esperienza ha mostrato che il proliferare dell'indicizzazione nelle ipotesi risulta in -script di dimostrazione difficili da manutenere. Comunque, pu confondere lavorare con -un grande insieme di ipotesi, nel qual caso i seguenti approcci possono essere +\item Un problema comune con i sistemi interattivi di dimostrazione trattare con +le ipotesi. Spesso \ml{METIS\_TAC} e il costrutto ``\ml{by}'' permettono +di usare le ipotesi senza ricorrere direttamente alla loro indicizzazione +(o al dar loro un nome, che equivale alla stessa cosa). Questo desiderabile, +dal momento che le ipotesi sono concettualmente un {\it insieme}, e inoltre, +l'esperienza ha mostrato che il proliferare dell'indicizzazione nelle ipotesi risulta in +script di dimostrazione difficili da manutenere. Comunque, pu confondere lavorare con +un grande insieme di ipotesi, nel qual caso i seguenti approcci possono essere utili. -Ci si pu riferire direttamente alle ipotesi usando \ml{UNDISCH\_TAC} (rende -l'ipotesi designata l'antecedente del goal), -\ml{ASSUM\_LIST} (fornisce l'intera lista delle ipotesi a una tattica), -\ml{POP\_ASSUM} (da la prima ipotesi a una tattica), e -\ml{PAT\_ASSUM} (da a una tattica la prima ipotesi +Ci si pu riferire direttamente alle ipotesi usando \ml{UNDISCH\_TAC} (rende +l'ipotesi designata l'antecedente del goal), +\ml{ASSUM\_LIST} (fornisce l'intera lista delle ipotesi a una tattica), +\ml{POP\_ASSUM} (da la prima ipotesi a una tattica), e +\ml{PAT\_ASSUM} (da a una tattica la prima ipotesi {\it che soddisfa il matching\/}). (Si veda \REFERENCE{} per maggiori dettagli su tutte queste cose.) -I numeri associati alle ipotesi dal gestore di dimostrazione verosimilmente potrebbero -essere usati per accedere alle ipotesi (sarebbe piuttosto semplice scrivere una -tattica simile). Comunque, iniziare una nuova dimostrazione a volte la +I numeri associati alle ipotesi dal gestore di dimostrazione verosimilmente potrebbero +essere usati per accedere alle ipotesi (sarebbe piuttosto semplice scrivere una +tattica simile). Comunque, iniziare una nuova dimostrazione a volte la cosa pi illuminante da fare. -In alcuni casi, utile essere in grado di cancellare un'ipotesi. Questo si pu +In alcuni casi, utile essere in grado di cancellare un'ipotesi. Questo si pu ottenere passando l'ipotesi a una tattica che la ignora. -Per esempio, per scartare la prima ipotesi, si pu invocare +Per esempio, per scartare la prima ipotesi, si pu invocare \ml{POP\_ASSUM (K ALL\_TAC)}. -\item Nell'esempio, non abbiamo usato le caratteristiche pi avanzate di -\ml{bossLib}, in gran parte perch non forniscono, finora, molte pi -funzionalit rispetto alla semplice sequenza di semplificazione, procedure -di decisione, e ragionamento automatico al primo ordine. Il tatticale -\ml{THEN} dunque servito come una sostituzione adeguata. Nel futuro, +\item Nell'esempio, non abbiamo usato le caratteristiche pi avanzate di +\ml{bossLib}, in gran parte perch non forniscono, finora, molte pi +funzionalit rispetto alla semplice sequenza di semplificazione, procedure +di decisione, e ragionamento automatico al primo ordine. Il tatticale +\ml{THEN} dunque servito come una sostituzione adeguata. Nel futuro, questi punti d'ingresso dovrebbero diventare pi potenti. \item E' quasi sempre necessario avere un'idea della dimostrazione {\it - informale\/} al fine di avere successo quando di fa una dimostrazione - formale. Tuttavia, troppo spesso i novizi adottano la seguente - strategia: (1) riscrivere il goal con alcune definizioni rilevanti, e - quindi (2) fare affidamento sulla sintassi del goal risultante per guidare - la selezione delle tattiche successive. Un tale approccio costituisce un chiaro - caso di cane che si morde la coda, ed una strategia povera da adottare. - La comprensione della struttura di alto livello della dimostrazione uno dei + informale\/} al fine di avere successo quando di fa una dimostrazione + formale. Tuttavia, troppo spesso i novizi adottano la seguente + strategia: (1) riscrivere il goal con alcune definizioni rilevanti, e + quindi (2) fare affidamento sulla sintassi del goal risultante per guidare + la selezione delle tattiche successive. Un tale approccio costituisce un chiaro + caso di cane che si morde la coda, ed una strategia povera da adottare. + La comprensione della struttura di alto livello della dimostrazione uno dei fattori pi importanti negli esercizi di verifica di successo. -L'autore ha notato che molti degli esperti di verifica pi di successo -lavorano usando un foglio di carta per tenere traccia dei passi principali che -devono essere fatti. Forse distogliere lo sguardo sulla carte aiuta a rompere +L'autore ha notato che molti degli esperti di verifica pi di successo +lavorano usando un foglio di carta per tenere traccia dei passi principali che +devono essere fatti. Forse distogliere lo sguardo sulla carte aiuta a rompere l'effetto ipnotizzante dello schermo del computer. -Dall'altra parte, uno dei vantaggi di avere una logica meccanizzata - che la macchina pu essere usata come un calcolatore di espressioni formali, -e cos l'utente lo pu usare per esplorare velocemente e accuratamente varie +Dall'altra parte, uno dei vantaggi di avere una logica meccanizzata + che la macchina pu essere usata come un calcolatore di espressioni formali, +e cos l'utente lo pu usare per esplorare velocemente e accuratamente varie possibilit di dimostrazione. \item Gli strumenti molto potenti come \ml{METIS\_TAC}, \ml{DECIDE\_TAC}, e -\ml{RW\_TAC} sono il modo principale per fare progressi in una dimostrazione in -\ml{bossLib}. In molti casi, essi fanno ci che si desidera, o addirittura -riescono a stupire l'utente con la loro potenza. Nella formalizzazione del -teorema di Euclide, gli strumenti hanno funzionato piuttosto bene. Tuttavia, a volte -sono eccessivamente aggressivi, o semplicemente fanno errori. In questi casi, si devono -usare, o persino scrivere, degli strumenti di dimostrazione pi specializzati, e di conseguenza +\ml{RW\_TAC} sono il modo principale per fare progressi in una dimostrazione in +\ml{bossLib}. In molti casi, essi fanno ci che si desidera, o addirittura +riescono a stupire l'utente con la loro potenza. Nella formalizzazione del +teorema di Euclide, gli strumenti hanno funzionato piuttosto bene. Tuttavia, a volte +sono eccessivamente aggressivi, o semplicemente fanno errori. In questi casi, si devono +usare, o persino scrivere, degli strumenti di dimostrazione pi specializzati, e di conseguenza alla fine bisogna imparare il supporto sottostante a \ml{bossLib}. -\item Avere una buona conoscenza dei lemmi disponibile, e di dove essi -si trovano, una parte essenziale per avere successo. Spesso gli strumenti -potenti possono sostituire i lemmi in un dominio ristretto, ma in generale, si -deve sapere cosa stato gi dimostrato. Abbiamo visto che i punti di ingresso +\item Avere una buona conoscenza dei lemmi disponibile, e di dove essi +si trovano, una parte essenziale per avere successo. Spesso gli strumenti +potenti possono sostituire i lemmi in un dominio ristretto, ma in generale, si +deve sapere cosa stato gi dimostrato. Abbiamo visto che i punti di ingresso in \verb+DB+ aiutano a trovare velocemente i lemmi. \end{itemize} diff --git a/Manual/Translations/IT/Tutorial/intro.tex b/Manual/Translations/IT/Tutorial/intro.tex index d6c0b73aae..9b65051d6a 100644 --- a/Manual/Translations/IT/Tutorial/intro.tex +++ b/Manual/Translations/IT/Tutorial/intro.tex @@ -1,35 +1,35 @@ \chapter{Ottenere e Installare \HOL{}} \label{install} -Questo capitolo descrive come ottenere il sistema \HOL{} e come installarlo. -Si assume in generale che si stia usando un qualche sistema Unix, +Questo capitolo descrive come ottenere il sistema \HOL{} e come installarlo. +Si assume in generale che si stia usando un qualche sistema Unix, ma le istruzioni che seguono dovrebbero applicarsi {\it mutatis - mutandis\/} ad altre piattaforme. Unix non un prerequisito per -usare il sistema. \HOL{} pu essere lanciato su PC che utilizzano sistemi -operativi Windows da Windows~NT in avanti (cio anche Windows~2000, XP e Vista + mutandis\/} ad altre piattaforme. Unix non un prerequisito per +usare il sistema. \HOL{} pu essere lanciato su PC che utilizzano sistemi +operativi Windows da Windows~NT in avanti (cio anche Windows~2000, XP e Vista sono supportati), esattamente come Macintosh che utilizzano MacOS~X. \section{Ottenere \HOL{}} -Il sistema \HOL{} pu essere scaricato da -\url{http://hol.sourceforge.net}. Lo schema di denominazione per le release di +Il sistema \HOL{} pu essere scaricato da +\url{http://hol.sourceforge.net}. Lo schema di denominazione per le release di \holn{} $\langle${\it nome}$\rangle$-$\langle${\it numero}$\rangle$; la release descritta qui \holnversion. \section{La mailing list {\tt hol-info}} -La mailing list \texttt{hol-info} serve come un forum per discutere su -\HOL{} e diffondere notizie che lo riguardano. Se si desidera essere in questa -lista (cosa che si raccomanda a tutti gli utenti di \HOL), si visiti -\url{http://lists.sourceforge.net/lists/listinfo/hol-info}. Questa +La mailing list \texttt{hol-info} serve come un forum per discutere su +\HOL{} e diffondere notizie che lo riguardano. Se si desidera essere in questa +lista (cosa che si raccomanda a tutti gli utenti di \HOL), si visiti +\url{http://lists.sourceforge.net/lists/listinfo/hol-info}. Questa pagina web pu anche essere usata per annullare l'iscrizione alla mailing list. \section{Installare \HOL{}} -Si assume che si siano ottenuti i sorgenti di \HOL{} e che il -file \texttt{tar} sia stato estratto in una directory \ml{hol}\footnote{Si pu -scegliere un altro nome se lo si desidera; non importante.}. E' probabile che -il contenuto di questa directory cambi nel tempo, ma dovrebbe +Si assume che si siano ottenuti i sorgenti di \HOL{} e che il +file \texttt{tar} sia stato estratto in una directory \ml{hol}\footnote{Si pu +scegliere un altro nome se lo si desidera; non importante.}. E' probabile che +il contenuto di questa directory cambi nel tempo, ma dovrebbe contenere i seguenti: \begin{center} @@ -51,24 +51,24 @@ \section{Installare \HOL{}} \end{tabular} \end{center} -La sessione nel box di sotto mostra una directory di distribuzione tipica. -La distribuzione \HOL{} stata messa su un PC che esegue Linux nella +La sessione nel box di sotto mostra una directory di distribuzione tipica. +La distribuzione \HOL{} stata messa su un PC che esegue Linux nella directory {\small\tt /home/mn200/hol/}. -Tutte le sessioni in questa documentazione saranno mostrate in box con un -numero nell'angolo destro in alto. Questo numero indica se -la sessione una nuova (quando il numero sar {\small\sl 1}) o +Tutte le sessioni in questa documentazione saranno mostrate in box con un +numero nell'angolo destro in alto. Questo numero indica se +la sessione una nuova (quando il numero sar {\small\sl 1}) o la continuazione di una sessione iniziata in un box precedente. -Si assume che box numerati consecutivamente siano parte di una singola -sessione continua. Il prompt Unix per la sessione -\texttt{\small \dol}, cos le linee che iniziano con questo prompt sono state digitate -dall'utente. Dopo essere entrato nel sistema \HOL{} (si veda di sotto), all'utente presentato -il prompt {\small\verb|-|} per inserire un'espressione o un comando del -meta-linguaggio \ML\ di \HOL{}; le linee che cominciano con questo prompt sono dunque espressioni o +Si assume che box numerati consecutivamente siano parte di una singola +sessione continua. Il prompt Unix per la sessione +\texttt{\small \dol}, cos le linee che iniziano con questo prompt sono state digitate +dall'utente. Dopo essere entrato nel sistema \HOL{} (si veda di sotto), all'utente presentato +il prompt {\small\verb|-|} per inserire un'espressione o un comando del +meta-linguaggio \ML\ di \HOL{}; le linee che cominciano con questo prompt sono dunque espressioni o dichiarazioni \ML. Le linee che non cominciano con \texttt{\small - \$} o {\small\verb|-|} sono output del sistema. Saltuariamente, l'output -di sistema sar rimpiazzato con una linea contenente {\small\verb|...|} quando - di interesse minimo. Il meta-linguaggio \ML{} introdotto nel + \$} o {\small\verb|-|} sono output del sistema. Saltuariamente, l'output +di sistema sar rimpiazzato con una linea contenente {\small\verb|...|} quando + di interesse minimo. Il meta-linguaggio \ML{} introdotto nel Capitolo~\ref{ML}. \setcounter{sessioncount}{0} @@ -82,13 +82,13 @@ \section{Installare \HOL{}} \end{verbatim} \end{session} -Ora sar necessario ricostruire \HOL{} dai sorgenti\footnote{ E' - possibile che sistemi pre-costruiti siano disponibili a breve dalla +Ora sar necessario ricostruire \HOL{} dai sorgenti\footnote{ E' + possibile che sistemi pre-costruiti siano disponibili a breve dalla pagina web menzionata di sopra.}. -Prima di iniziare necessario avere una versione attuale di Moscow~ML o -Poly/ML\footnote{Poly/ML non pu essere usato con HOL su Windows.}. Nel -caso di Moscow~ML, bisogna avere la versione 2.01. Moscow~ML disponibile +Prima di iniziare necessario avere una versione attuale di Moscow~ML o +Poly/ML\footnote{Poly/ML non pu essere usato con HOL su Windows.}. Nel +caso di Moscow~ML, bisogna avere la versione 2.01. Moscow~ML disponibile sul web all'indirizzo \url{http://www.itu.dk/~sestoft/mosml.html}. Poly/ML disponibile all'indirizzo \url{http://polyml.org}. @@ -99,7 +99,7 @@ \section{Installare \HOL{}} declare -x LD_LIBRARY_PATH=/usr/local/lib:$HOME/lib $ \end{verbatim} -Quando il proprio sistema ML installato, e ci si trova nella directory radice della distribuzione, il passo successivo eseguire \texttt{smart-configure}. +Quando il proprio sistema ML installato, e ci si trova nella directory radice della distribuzione, il passo successivo eseguire \texttt{smart-configure}. Con Moscow~ML, questo equivale a: \begin{session} @@ -128,17 +128,17 @@ \section{Installare \HOL{}} \end{verbatim} al suo posto. -Assumendo che il processo di configurazione non venga interrotto, questo -costruir i programmi \texttt{Holmake} e \texttt{build}, e li sposter -nella directory \texttt{hol/bin}. Se qualcosa va storto in questo +Assumendo che il processo di configurazione non venga interrotto, questo +costruir i programmi \texttt{Holmake} e \texttt{build}, e li sposter +nella directory \texttt{hol/bin}. Se qualcosa va storto in questo passo, si consulti la Sezione~\ref{sec:editting-configure} di sotto. -Il passo successivo eseguire il programma \texttt{build}. Questo dovrebbe -risultare in una grande quantit di output mentre il codice del sistema viene compilato -e le teorie costruite. Alla fine prodotto un sistema \HOL{}\footnote{Sono +Il passo successivo eseguire il programma \texttt{build}. Questo dovrebbe +risultare in una grande quantit di output mentre il codice del sistema viene compilato +e le teorie costruite. Alla fine prodotto un sistema \HOL{}\footnote{Sono prodotti quattro eseguibili \HOL{}: \textsf{hol}, \textsf{hol.noquote}, - \textsf{hol.bare} e \textsf{hol.bare.noquote}. Il primo di questi - sar usato per la maggior parte degli esempi nel \TUTORIAL{}.} nella + \textsf{hol.bare} e \textsf{hol.bare.noquote}. Il primo di questi + sar usato per la maggior parte degli esempi nel \TUTORIAL{}.} nella directory \texttt{bin/}. \begin{session} @@ -157,15 +157,15 @@ \section{Installare \HOL{}} \subsection{Sovrascrivere \texttt{smart-configure}} \label{sec:editting-configure} -Se \texttt{smart-configure} non in rado di indovinare i valori corretti per i -vari parametri (\texttt{holdir}, \texttt{OS} \etc) allora si pu -creare un file richiamato per fornire i valori corretti. Con Moscow~ML, questo -dovrebbe essere \texttt{config-override} nella directory radice della distribuzione -HOL. Con Poly/ML, questo dovrebbe essere \texttt{poly-includes.ML} -nella directory \texttt{tools-poly}. In questo file, si specifichi il -valore corretto per il parametro appropriato fornendo un binding ML -per esso. A tutte le variabili eccetto \texttt{dynlib\_available} deve essere data -una stringa come valore possibile, mentre \texttt{dynlib\_available} deve essere +Se \texttt{smart-configure} non in rado di indovinare i valori corretti per i +vari parametri (\texttt{holdir}, \texttt{OS} \etc) allora si pu +creare un file richiamato per fornire i valori corretti. Con Moscow~ML, questo +dovrebbe essere \texttt{config-override} nella directory radice della distribuzione +HOL. Con Poly/ML, questo dovrebbe essere \texttt{poly-includes.ML} +nella directory \texttt{tools-poly}. In questo file, si specifichi il +valore corretto per il parametro appropriato fornendo un binding ML +per esso. A tutte le variabili eccetto \texttt{dynlib\_available} deve essere data +una stringa come valore possibile, mentre \texttt{dynlib\_available} deve essere \texttt{true} o \texttt{false}, Cos, si potrebbe scrivere \begin{session} @@ -176,45 +176,45 @@ \subsection{Sovrascrivere \texttt{smart-configure}} \end{verbatim} \end{session} -Il file \texttt{config-override} ha bisogno di fornire soli i valori per quelle +Il file \texttt{config-override} ha bisogno di fornire soli i valori per quelle variabili che devono essere sovra scritte. -Con questo file nel posto corretto, il programma \texttt{smart-configure} user -i valori li specificati piuttosto che quelli che tenta di calcolare -da solo. Il valore dato per la variabile \texttt{OS} deve essere uno tra +Con questo file nel posto corretto, il programma \texttt{smart-configure} user +i valori li specificati piuttosto che quelli che tenta di calcolare +da solo. Il valore dato per la variabile \texttt{OS} deve essere uno tra \texttt{"unix"}, \texttt{"linux"}, \texttt{"solaris"}, -\texttt{"macosx"} or \texttt{"winNT"}\footnote{La stringa +\texttt{"macosx"} or \texttt{"winNT"}\footnote{La stringa \texttt{"winNT"} usata per sistemi operativi Microsoft Windows - recenti almeno quanto Windows~NT. Questi includono + recenti almeno quanto Windows~NT. Questi includono Windows~2000, XP and Vista.}. -In circostanze estreme possibile modificare il file -\texttt{tools/configure.sml} da soli per impostare le variabili di configurazione -direttamente. (Se si sta usando Poly/ML, bisogna invece -modificare \texttt{tools-poly/configure.sml}.) All'inizio di questo file -sono presenti varie dichiarazioni SML incomplete, ma commentate. -Sar necessario decommentare questa sezione (rimuovendo i segni \texttt{(*} e -\texttt{*)}), e fornire valori appropriati. Tutte le stringhe devono +In circostanze estreme possibile modificare il file +\texttt{tools/configure.sml} da soli per impostare le variabili di configurazione +direttamente. (Se si sta usando Poly/ML, bisogna invece +modificare \texttt{tools-poly/configure.sml}.) All'inizio di questo file +sono presenti varie dichiarazioni SML incomplete, ma commentate. +Sar necessario decommentare questa sezione (rimuovendo i segni \texttt{(*} e +\texttt{*)}), e fornire valori appropriati. Tutte le stringhe devono essere incluse tra doppie virgolette. -Il valore \texttt{holdir} deve essere il nome della directory principale -elencata nella prima sessione di sopra. Il valore \texttt{OS} dovrebbe essere +Il valore \texttt{holdir} deve essere il nome della directory principale +elencata nella prima sessione di sopra. Il valore \texttt{OS} dovrebbe essere una delle stringhe specificate nel commento che accompagna quella sezione. -Quando si lavora con Moscow~ML, il valore \texttt{mosmldir} deve essere il -nome della directory che contiene i binari di Moscow~ML -(\texttt{mosmlc}, \texttt{mosml}, \texttt{mosmllex} ecc.). Quando -si lavora con Poly/ML, la stringa \texttt{poly} deve essere il percorso -all'eseguibile \texttt{poly} che inizia una sessione \ML{} interattiva. -Il valore \texttt{polymllibdir} deve essere un percorso a una directory che contiene +Quando si lavora con Moscow~ML, il valore \texttt{mosmldir} deve essere il +nome della directory che contiene i binari di Moscow~ML +(\texttt{mosmlc}, \texttt{mosml}, \texttt{mosmllex} ecc.). Quando +si lavora con Poly/ML, la stringa \texttt{poly} deve essere il percorso +all'eseguibile \texttt{poly} che inizia una sessione \ML{} interattiva. +Il valore \texttt{polymllibdir} deve essere un percorso a una directory che contiene il file \texttt{libpolymain.a}. -I valori successivi (\texttt{CC} e \texttt{GNUMAKE}) sono necessari per -componenti del sistema ``opzionali''. La prima da una stringa -appropriata per invocare il compilatore C di sistema, e la seconda +I valori successivi (\texttt{CC} e \texttt{GNUMAKE}) sono necessari per +componenti del sistema ``opzionali''. La prima da una stringa +appropriata per invocare il compilatore C di sistema, e la seconda specifica un programma \textsf{make}. -Dopo la modifica, le righe di \texttt{tools/configure.sml} di sopra saranno +Dopo la modifica, le righe di \texttt{tools/configure.sml} di sopra saranno qualcosa di simile a : \begin{session} @@ -233,8 +233,8 @@ \subsection{Sovrascrivere \texttt{smart-configure}} \end{alltt} \end{session} -\noindent Ora, a questo livello (nella directory \texttt{tools} o -\texttt{tools-poly}) o al livello di sopra, bisogna passare lo script +\noindent Ora, a questo livello (nella directory \texttt{tools} o +\texttt{tools-poly}) o al livello di sopra, bisogna passare lo script \texttt{configure.sml} all'interprete \ML{} (\ie, \texttt{mosml} o \texttt{poly}). Per esempio, diff --git a/Manual/Translations/IT/Tutorial/logic.tex b/Manual/Translations/IT/Tutorial/logic.tex index 3d09d82471..b6ae9649b6 100644 --- a/Manual/Translations/IT/Tutorial/logic.tex +++ b/Manual/Translations/IT/Tutorial/logic.tex @@ -1,6 +1,6 @@ \chapter{La logica di \HOL{}}\label{HOLlogic} -Il sistema \HOL{} supporta \emph{la logica di ordine superiore}. +Il sistema \HOL{} supporta \emph{la logica di ordine superiore}. Questa una versione del calcolo dei predicati con tre estensioni principali: \begin{itemize} @@ -55,7 +55,7 @@ \chapter{La logica di \HOL{}}\label{HOLlogic} I termini possono essere manipolati da varie funzioni incorporate in \ML{}. Per esempio, la funzione \ML{} \ml{dest\_imp} con il tipo \ML{} \ml{term -> term * term} divide un'implicazione in una coppia di termini che consiste nel suo antecedente e nel suo conseguente, e la funzione \ML\ \ml{dest\_conj} di tipo \ml{term -> term * term} divide una congiunzione nei suoi due congiunti% \footnote{Tutti gli esempi di sotto assumono che l'utente stia eseguendo \texttt{hol}, il cui eseguibile nella directory \texttt{bin/}. -A seconda della configurazione del sistema, anche possibile che la notazione ASCII utilizzata nelle sessioni di esempio che seguono sia sostituita da una notazione +A seconda della configurazione del sistema, anche possibile che la notazione ASCII utilizzata nelle sessioni di esempio che seguono sia sostituita da una notazione Unicode pi gradevole: in cui per esempio \holtxt{/\bs} sostituito da $\land$.}. \setcounter{sessioncount}{0} @@ -72,7 +72,7 @@ \chapter{La logica di \HOL{}}\label{HOLlogic} \end{verbatim} \end{session} -I termini della logica di \HOL{} sono piuttosto simili a espressioni \ML{}, e questo all'inizio pu confondere. +I termini della logica di \HOL{} sono piuttosto simili a espressioni \ML{}, e questo all'inizio pu confondere. Di fatto, i termini della logica hanno tipi analoghi a quelli dell'espressioni \ML{}. Per esempio, \holtxt{``(1,2)``} un'espressione \ML{} con tipo \ML{} \ml{term}. Il tipo \HOL{} di questo termine \holtxt{num \# num}. @@ -100,7 +100,7 @@ \chapter{La logica di \HOL{}}\label{HOLlogic} \end{verbatim} \end{session} -Per tentare di minimizzare la confusione tra i tipi logici dei termini \HOL{} e i tipi \ML{} di espressioni \ML{}, ci si riferir ai primi come a \emph{tipi del linguaggio oggetto} e ai secondi come a \emph{tipi del meta-linguaggio}. +Per tentare di minimizzare la confusione tra i tipi logici dei termini \HOL{} e i tipi \ML{} di espressioni \ML{}, ci si riferir ai primi come a \emph{tipi del linguaggio oggetto} e ai secondi come a \emph{tipi del meta-linguaggio}. Per esempio, \ml{``(1,T)``} un'espressione \ML{} che ha il tipo \ml{term} del meta-linguaggio ed valutato a un termine con il tipo \ml{``:num\#bool``} del linguaggio oggetto. % \begin{session} @@ -143,7 +143,7 @@ \chapter{La logica di \HOL{}}\label{HOLlogic} \paragraph{Controllo di tipo} Di fatto ci sono quattro generi differenti di termini in \HOL: variabili, costanti, applicazioni di funzione (\ml{``$t_1$ $t_2$``}), e lambda astrazioni (\ml{``\bs$x$.$t$``}). -Termini pi complicati, come quelli che abbiamo gi visto di sopra, sono soltanto composizioni di termini da questo semplice insieme. +Termini pi complicati, come quelli che abbiamo gi visto di sopra, sono soltanto composizioni di termini da questo semplice insieme. Al fine di comprendere il comportamento del parser delle quotation, necessario capire come il controllore dei tipi deduca i tipi per le quattro categorie base di termini. Sia le variabili sia le costanti hanno un nome e un tipo; la differenza che le costanti non possono essere legate da quantificatori, e il loro tipo fissato quando sono dichiarate (si veda di sotto). @@ -157,10 +157,10 @@ \chapter{La logica di \HOL{}}\label{HOLlogic} \end{verbatim} \end{session} -Nei prossimi due casi, il tipo di \ml{x} e \ml{y} non pu essere +Nei prossimi due casi, il tipo di \ml{x} e \ml{y} non pu essere dedotto. -(Di default lo `scopo' dell'informazione di tipo per il controllore di tipo una singola quotation, cos un tipo in una quotation non pu influenzare il controllo di tipo di un'altra. -Cos \ml{x} non costretta ad avere il tipo \ml{bool} nella seconda quotation.) +(Di default lo `scopo' dell'informazione di tipo per il controllore di tipo una singola quotation, cos un tipo in una quotation non pu influenzare il controllo di tipo di un'altra. +Cos \ml{x} non costretta ad avere il tipo \ml{bool} nella seconda quotation.) \begin{session} \begin{verbatim} @@ -242,7 +242,7 @@ \chapter{La logica di \HOL{}}\label{HOLlogic} \end{session} Il simbolo di dollaro all'inizio di \holtxt{\td} indica che la costante di negazione booleana ha uno stato sintattico speciale (in questo caso una precedenza non standard). -Mettere \holtxt{\$} davanti a un simbolo qualsiasi fa s che il parser ignori qualsiasi status sintattico speciale esso possa avere (come l'essere un infisso). +Mettere \holtxt{\$} davanti a un simbolo qualsiasi fa s che il parser ignori qualsiasi status sintattico speciale esso possa avere (come l'essere un infisso). Lo stesso effetto si pu ottenere racchiudendo il simbolo fra parentesi. Questo analogo al modo in cui \texttt{op} usato in \ML. @@ -270,7 +270,7 @@ \chapter{La logica di \HOL{}}\label{HOLlogic} \end{verbatim} \end{session} -\noindent Di nuovo, sia \holtxt{+} che \holtxt{==>} sono infissi, cos il loro uso in contesti dove non sono usati come tali richiede un'escaping della sintassi. +\noindent Di nuovo, sia \holtxt{+} che \holtxt{==>} sono infissi, cos il loro uso in contesti dove non sono usati come tali richiede un'escaping della sintassi. La sessione di sotto illustra l'uso di queste costanti come infissi, illustra anche i tipi del linguaggio oggetto di contro a quelli del meta-linguaggio. \begin{session} @@ -363,15 +363,15 @@ \section{Dimostrazioni di base in \HOL{}} \end{session} -I teoremi sono stampati con un turnstile anteposto {\small\verb+|-+} come illustrato di sotto; il simbolo `{\small\verb|!|}' il quantificatore universale `$\forall$'. -Le regole d'inferenza sono funzioni \ML{} che restituiscono valori di tipo \ml{thm}. +I teoremi sono stampati con un turnstile anteposto {\small\verb+|-+} come illustrato di sotto; il simbolo `{\small\verb|!|}' il quantificatore universale `$\forall$'. +Le regole d'inferenza sono funzioni \ML{} che restituiscono valori di tipo \ml{thm}. Un esempio di una regola d'inferenza la {\it specializzazione\/} (o $\forall$-eliminazione). Nella notazione standard della `deduzione naturale' questo : \[ \frac{\Gamma\turn \uquant{x}t}{\Gamma\turn t[t'/x]}\] \begin{itemize} -\item $t[t'/x]$ denota il risultato della sostituzione di $t'$ per tutte le occorrenze libere di $x$ in $t$, con la restrizione che nessuna variabile libera in $t'$ venga legata dopo la sostituzione. +\item $t[t'/x]$ denota il risultato della sostituzione di $t'$ per tutte le occorrenze libere di $x$ in $t$, con la restrizione che nessuna variabile libera in $t'$ venga legata dopo la sostituzione. \end{itemize} \noindent Questa regola rappresentata in \ML{} da una funzione \ml{SPEC},% @@ -398,10 +398,10 @@ \section{Dimostrazioni di base in \HOL{}} \end{proofenumerate} \end{samepage} -Se l'argomento a una funzione \ML{} che rappresenta una regola d'inferenza del genere sbagliato, o viola una condizione della regola, allora l'applicazione fallisce. -Per esempio, $\ml{SPEC}\ t\ th$ fallir se $th$ non della forma $\ml{|-\ !}x\ml{.}\cdots$ o se di questa forma ma il tipo di $t$ non lo stesso del tipo di $x$, o se non soddisfatta la restrizione della variabile libera. +Se l'argomento a una funzione \ML{} che rappresenta una regola d'inferenza del genere sbagliato, o viola una condizione della regola, allora l'applicazione fallisce. +Per esempio, $\ml{SPEC}\ t\ th$ fallir se $th$ non della forma $\ml{|-\ !}x\ml{.}\cdots$ o se di questa forma ma il tipo di $t$ non lo stesso del tipo di $x$, o se non soddisfatta la restrizione della variabile libera. Quando sollevata una delle eccezioni \ml{HOL\_ERR} standard, si pu spesso ottenere pi informazione circa il fallimento usando la funzione \ml{Raise}.% -\footnote{La funzione \ml{Raise} passa su tutte le eccezioni che vede; essa non incide per nulla sulla semantica della computazione. +\footnote{La funzione \ml{Raise} passa su tutte le eccezioni che vede; essa non incide per nulla sulla semantica della computazione. Comunque, quando le viene passata un'eccezione \ml{HOL\_ERR}, stampa alcune utili informazioni prima di passare l'eccezione al livello successivo.}. \begin{session} @@ -427,13 +427,13 @@ \section{Dimostrazioni di base in \HOL{}} La forma generale di un teorema $t_1,\ldots,t_n\;\ml{|-}\;t$, dove $t_1$, $\ldots$ , $t_n$ sono termini booleani chiamati le {\it assunzioni} e $t$ un termine booleano chiamato la {\it conclusione\/}. Un tale teorema afferma che se le sue assunzioni sono vere allora lo anche la sua conclusione. -Le sue condizioni di verit sono cos le stesse di quelle per il +Le sue condizioni di verit sono cos le stesse di quelle per il singolo termine $(t_1\,\ml{/\bs}\ldots\ml{/\bs}\,t_n)\,\ml{==>}\,t$. I teoremi senza assunzioni sono stampati nella forma \ml{|-}$\ t$. I cinque assiomi e le otto regole primitive d'inferenza della logica di \HOL{} sono descritte nel dettaglio nel documento \DESCRIPTION. Ogni valore di tipo \ml{thm} nel sistema \HOL{} si pu ottenere applicando ripetutamente regole primitive d'inferenza agli assiomi. -Quando il sistema \HOL{} costruito, le otto regole primitive d'inferenza sono definite e i cinque assiomi sono legati ai loro nomi \ML{}. +Quando il sistema \HOL{} costruito, le otto regole primitive d'inferenza sono definite e i cinque assiomi sono legati ai loro nomi \ML{}. Tutti gli altri teoremi predefiniti sono dimostrati usando le regole d'inferenza mentre il sistema si costruisce\footnote{Questa una semplificazione leggeremnte eccessiva}. Questa una delle ragioni per cui la costruzione di \ml{hol} richiede cos tanto tempo. @@ -443,15 +443,15 @@ \section{Dimostrazioni di base in \HOL{}} \section{Dimostrazione in avanti} \label{forward} -Tre delle regole primitive d'inferenza della logica \HOL{} sono -\ml{ASSUME} (introduzione di un'assunzione), \ml{DISCH} (scaricamento o -eliminazione di un'assunzione) e \ml{MP} (Modus Ponens). Queste regole saranno +Tre delle regole primitive d'inferenza della logica \HOL{} sono +\ml{ASSUME} (introduzione di un'assunzione), \ml{DISCH} (scaricamento o +eliminazione di un'assunzione) e \ml{MP} (Modus Ponens). Queste regole saranno usate per illustrare la dimostrazione in avanti e la scrittura di regole derivate. La regola d'inferenza \ml{ASSUME} genera teoremi della forma \ml{$t$ - |- $t$}. Si noti, comunque, che il printer \ML{} stampa ogni -assunzione come un punto (ma questo default pu essere cambiato; si veda di sotto). La -funzione \ml{dest\_thm} decompone un teorema in una coppia che consiste nella + |- $t$}. Si noti, comunque, che il printer \ML{} stampa ogni +assunzione come un punto (ma questo default pu essere cambiato; si veda di sotto). La +funzione \ml{dest\_thm} decompone un teorema in una coppia che consiste nella lista delle assunzioni e nella conclusione \begin{session} @@ -464,11 +464,11 @@ \section{Dimostrazione in avanti} \end{verbatim} \end{session} -Una sorta di duale di \ml{ASSUME} la regola primitiva d'inferenza -\ml{DISCH} (scaricamento, eliminazione di un'assunzione) che deduce da -un teorema della forma $\cdots t_1\cdots\ml{\ |-\ }t_2$ il nuovo teorema -$\cdots\ \cdots\ \ml{|-}\ t_1\ml{==>}t_2$. \ml{DISCH} prende come argomenti -il termine che deve essere scaricato (\ie\ $t_1$) e il teorema da cui +Una sorta di duale di \ml{ASSUME} la regola primitiva d'inferenza +\ml{DISCH} (scaricamento, eliminazione di un'assunzione) che deduce da +un teorema della forma $\cdots t_1\cdots\ml{\ |-\ }t_2$ il nuovo teorema +$\cdots\ \cdots\ \ml{|-}\ t_1\ml{==>}t_2$. \ml{DISCH} prende come argomenti +il termine che deve essere scaricato (\ie\ $t_1$) e il teorema da cui le assunzioni devono essere scaricate e restituisce il risultato dello scaricamento. La seguente sessione illustra questo: @@ -478,7 +478,7 @@ \section{Dimostrazione in avanti} > val Th4 = |- (t1 ==> t2) ==> t1 ==> t2 : thm \end{verbatim} \end{session} -Si noti che non necessario che il termine che deve essere scaricato sia nelle assunzioni; in +Si noti che non necessario che il termine che deve essere scaricato sia nelle assunzioni; in questo caso esse rimarranno invariate. \begin{session} @@ -496,11 +496,11 @@ \section{Dimostrazione in avanti} \frac{\Gamma_1 \turn t_1 \imp t_2 \qquad\qquad \Gamma_2\turn t_1} {\Gamma_1 \cup \Gamma_2 \turn t_2} \] -La funzione \ML{} \ml{MP} prende come argomenti teoremi della forma -\ml{$\cdots\ $|-$\ t_1$\ ==>\ $t_2$} e \ml{$\cdots\ $|-$\ t_1$} e -restituisce \ml{$\cdots\ $|-$\ t_2$}. La prossima sessione illustrer l'uso -di \ml{MP} e anche un errore comune, cio il non fornire informazione sufficiente -al controllore di tipo logico di \HOL\ . +La funzione \ML{} \ml{MP} prende come argomenti teoremi della forma +\ml{$\cdots\ $|-$\ t_1$\ ==>\ $t_2$} e \ml{$\cdots\ $|-$\ t_1$} e +restituisce \ml{$\cdots\ $|-$\ t_2$}. La prossima sessione illustrer l'uso +di \ml{MP} e anche un errore comune, cio il non fornire informazione sufficiente +al controllore di tipo logico di \HOL\ . \begin{session} \begin{verbatim} @@ -524,8 +524,8 @@ \section{Dimostrazione in avanti} \end{verbatim} \end{session} -Le ipotesi di \ml{Th6} possono essere ispezionate con la funzione \ML{} -\ml{hyp}, che restituisce la lista delle assunzioni di un teorema (la +Le ipotesi di \ml{Th6} possono essere ispezionate con la funzione \ML{} +\ml{hyp}, che restituisce la lista delle assunzioni di un teorema (la conclusione restituita da \ml{concl}). \begin{session} @@ -551,7 +551,7 @@ \section{Dimostrazione in avanti} \end{session} -\noindent Scaricando \ml{Th6} due volte si stabilisce il teorema +\noindent Scaricando \ml{Th6} due volte si stabilisce il teorema \ml{|-\ t1 ==> (t1==>t2) ==> t2}. \begin{session} @@ -564,7 +564,7 @@ \section{Dimostrazione in avanti} \end{verbatim} \end{session} -La sequenza di teoremi: \ml{Th3}, \ml{Th5}, \ml{Th6}, \ml{Th7}, \ml{Th8} costituisce una dimostrazione in \HOL{} del teorema \ml{|-\ t1 ==> (t1 ==> t2) ==> t2}. +La sequenza di teoremi: \ml{Th3}, \ml{Th5}, \ml{Th6}, \ml{Th7}, \ml{Th8} costituisce una dimostrazione in \HOL{} del teorema \ml{|-\ t1 ==> (t1 ==> t2) ==> t2}. In notazione logica standard questa dimostrazione potrebbe essere scritta: \begin{proofenumerate} @@ -594,12 +594,12 @@ \subsection{Regole derivate} \item $ \Gamma,\ t'\turn t$ \hfill [Modus Ponens applicato alle linee 3 e 1] \end{proofenumerate} -\noindent Questa dimostrazione funziona per qualunque ipotesi della forma $\Gamma\turn t$ -e qualsiasi termine booleano $t'$ e mostra che il risultato di aggiungere un'ipotesi -arbitraria a un teorema un altro teorema (perch le quattro -linee di sopra possono essere aggiunte a qualsiasi dimostrazione di $\Gamma\turn t$ per ottenere una -dimostrazione di $\Gamma,\ t'\turn t$)\footnote{Questa propriet della logica - chiamata {\it monotonicit}.}. Per esempio, la prossima sessione usa questa +\noindent Questa dimostrazione funziona per qualunque ipotesi della forma $\Gamma\turn t$ +e qualsiasi termine booleano $t'$ e mostra che il risultato di aggiungere un'ipotesi +arbitraria a un teorema un altro teorema (perch le quattro +linee di sopra possono essere aggiunte a qualsiasi dimostrazione di $\Gamma\turn t$ per ottenere una +dimostrazione di $\Gamma,\ t'\turn t$)\footnote{Questa propriet della logica + chiamata {\it monotonicit}.}. Per esempio, la prossima sessione usa questa dimostrazione per aggiungere l'ipotesi \ml{``t3``} a \ml{Th6}. \begin{session} @@ -616,11 +616,11 @@ \subsection{Regole derivate} \end{session} - Una {\it regola derivata\/} una procedura \ML{} che genera una dimostrazione - dalle ipotesi date ogni volta che invocata. Le ipotesi sono - gli argomenti della regola. Per illustrare questo, una regola, chiamata - \ml{ADD\_ASSUM}, sar ora definita come una procedura \ML{} che - svolge la dimostrazione di sopra. In notazione standard questo sarebbe + Una {\it regola derivata\/} una procedura \ML{} che genera una dimostrazione + dalle ipotesi date ogni volta che invocata. Le ipotesi sono + gli argomenti della regola. Per illustrare questo, una regola, chiamata + \ml{ADD\_ASSUM}, sar ora definita come una procedura \ML{} che + svolge la dimostrazione di sopra. In notazione standard questo sarebbe descritto da: \[ \frac{\Gamma\turn t}{\Gamma,\ t'\turn t} \] @@ -642,9 +642,9 @@ \subsection{Regole derivate} \end{verbatim} \end{session} -\noindent Il corpo di \ml{ADD\_ASSUM} stato codificato per riflettere la dimostrazione fatta -nella sessione~10 di sopra, cos da mostrare come una dimostrazione interattiva pu essere -generalizzata in una procedura. Ma \ml{ADD\_ASSUM} pu essere scritta in modo +\noindent Il corpo di \ml{ADD\_ASSUM} stato codificato per riflettere la dimostrazione fatta +nella sessione~10 di sopra, cos da mostrare come una dimostrazione interattiva pu essere +generalizzata in una procedura. Ma \ml{ADD\_ASSUM} pu essere scritta in modo molto pi conciso come. \begin{session} @@ -677,7 +677,7 @@ \subsection{Regole derivate} \end{verbatim} \end{session} -\noindent Ogni volta che eseguita \ml{UNDISCH\ $\Gamma\turn t_1\imp t_2$}, +\noindent Ogni volta che eseguita \ml{UNDISCH\ $\Gamma\turn t_1\imp t_2$}, svolta la seguente dimostrazione: \begin{proofenumerate} @@ -686,23 +686,23 @@ \subsection{Regole derivate} \item $ \Gamma,\ t_1\turn t_2$ \hfill [Modus Ponens applicata alle linee 2 and 1] \end{proofenumerate} -Le regole \ml{ADD\_ASSUM} e \ml{UNDISCH} sono le prime regole derivate -definite quando il sistema \HOL{} costruito. Per una descrizione delle regole +Le regole \ml{ADD\_ASSUM} e \ml{UNDISCH} sono le prime regole derivate +definite quando il sistema \HOL{} costruito. Per una descrizione delle regole principali si veda la sezione sulle regole derivate in \DESCRIPTION. \subsubsection{Riscrittura} -Un'interessante regola derivata \ml{REWRITE\_RULE}. Questa prende una lista di +Un'interessante regola derivata \ml{REWRITE\_RULE}. Questa prende una lista di teoremi equazionali della forma: \[ \Gamma\turn (u_1 = v_1) \conj (u_2 = v_2) \conj \ldots\ \conj (u_n = v_n) \] -e un teorema $\Delta\turn t$ e sostituisce ripetutamente istanze di $u_i$ in $t$ con l'istanza corrispondente di $v_i$ fino a quando non occorrono altri cambiamenti. -Il risultato un teorema $\Gamma\cup\Delta\turn t'$ dove $t'$ il risultato di riscrivere $t$ in questo modo. -La sessione di sotto illustra l'uso di \ml{REWRITE\_RULE}. -In essa la lista di equazioni il valore \ml{rewrite\_list} che contiene i teoremi pre-dimostrati \ml{ADD\_CLAUSES} and \ml{MULT\_CLAUSES}. -Questi teoremi appartengono alla teoria \ml{arithmetic}, cos per riferirsi ad essi dobbiamo usare un nome completo con il nome della teoria come primo componente. +e un teorema $\Delta\turn t$ e sostituisce ripetutamente istanze di $u_i$ in $t$ con l'istanza corrispondente di $v_i$ fino a quando non occorrono altri cambiamenti. +Il risultato un teorema $\Gamma\cup\Delta\turn t'$ dove $t'$ il risultato di riscrivere $t$ in questo modo. +La sessione di sotto illustra l'uso di \ml{REWRITE\_RULE}. +In essa la lista di equazioni il valore \ml{rewrite\_list} che contiene i teoremi pre-dimostrati \ml{ADD\_CLAUSES} and \ml{MULT\_CLAUSES}. +Questi teoremi appartengono alla teoria \ml{arithmetic}, cos per riferirsi ad essi dobbiamo usare un nome completo con il nome della teoria come primo componente. (In alternativa, potremmo, come nell'esempio Euclide della sezione~\ref{chap:euclid}, usare \ml{open} per dichiarare tutti i valori nella teoria al top level.) \begin{session} @@ -729,7 +729,7 @@ \subsubsection{Riscrittura} \end{session} \noindent -Questo pu essere riscritto usando un altro teorema pre-dimostrato +Questo pu essere riscritto usando un altro teorema pre-dimostrato \ml{LESS\_THM}, che appartiene alla teoria \ml{prim\_rec}: \begin{session} @@ -739,7 +739,7 @@ \subsubsection{Riscrittura} \end{verbatim} \end{session} -\ml{REWRITE\_RULE} non una regola primitiva in \HOL, ma una regola derivata. +\ml{REWRITE\_RULE} non una regola primitiva in \HOL, ma una regola derivata. E' ereditata dal Cambridge \LCF\ e fu implementata da Larry Paulson (per i dettagli si veda il suo scritto \cite{lcp-rewrite}). In aggiunta alle equazioni fornite, \ml{REWRITE\_RULE} ha incorporate alcune semplificazioni standard: @@ -755,19 +755,19 @@ \subsubsection{Riscrittura} \section{Dimostrazioni Dirette dal Goal: Tattiche e Tatticali} \label{backward}\label{tactics} -Lo stile della dimostrazione in avanti descritto nella sessione precedente -innaturale e troppo di `basso livello' per molte applicazioni. Un importante -passo in avanti nella metodologia di generazione delle dimostrazioni fu fatto da Robin Milner nei primi -anno 1970 quando invent la nozione delle {\it tattiche\/}. Una +Lo stile della dimostrazione in avanti descritto nella sessione precedente +innaturale e troppo di `basso livello' per molte applicazioni. Un importante +passo in avanti nella metodologia di generazione delle dimostrazioni fu fatto da Robin Milner nei primi +anno 1970 quando invent la nozione delle {\it tattiche\/}. Una tattica una funzione che fa le seguenti cose. \begin{myenumerate} \item Divide un `goal' in `subgoals'. \item Tiene traccia del motivo per cui risolvere i subgoals risolve il goal. \end{myenumerate} -\noindent Si consideri, per esempio, la regola di $\wedge$-introduzione\footnote{Nella - logica di ordine superiore questa una regola derivata; nella logica del primo ordine essa - di solito primitiva. In HOL la regola chiamata {\tt CONJ} e la sua +\noindent Si consideri, per esempio, la regola di $\wedge$-introduzione\footnote{Nella + logica di ordine superiore questa una regola derivata; nella logica del primo ordine essa + di solito primitiva. In HOL la regola chiamata {\tt CONJ} e la sua derivazione data in \DESCRIPTION.} mostrata di sotto: \[ \frac{\Gamma_1\turn @@ -775,14 +775,14 @@ \section{Dimostrazioni Dirette dal Goal: Tattiche e Tatticali} t_2} \] -\noindent In \HOL, la $\wedge$-introduzione rappresentata dalla funzione \ML{} +\noindent In \HOL, la $\wedge$-introduzione rappresentata dalla funzione \ML{} \ml{CONJ}: \[\ml{CONJ}\ (\Gamma_1\turn t_1)\ (\Gamma_2\turn t_2) \ \ \leadsto\ \ (\Gamma_1\cup\Gamma_2\turn t_1\conj t_2)\] -\noindent Questo illustrato nella -seguente nuova sessione (si noti che il numero di sessione stata reimpostato a +\noindent Questo illustrato nella +seguente nuova sessione (si noti che il numero di sessione stata reimpostato a {\small\sl 1}: \setcounter{sessioncount}{0} @@ -800,27 +800,27 @@ \section{Dimostrazioni Dirette dal Goal: Tattiche e Tatticali} \end{verbatim} \end{session} - Si supponga che il goal sia dimostrare $A\conj B$, quindi questa regola dice che - sufficiente dimostrare i due subgoal $A$ e $B$, perch - da $\turn A$ e $\turn B$ pu essere dedotto il teorema + Si supponga che il goal sia dimostrare $A\conj B$, quindi questa regola dice che + sufficiente dimostrare i due subgoal $A$ e $B$, perch + da $\turn A$ e $\turn B$ pu essere dedotto il teorema $\turn A\conj B$. Cos: \begin{myenumerate} -\item Per dimostrare $\turn A \conj B$ sufficiente +\item Per dimostrare $\turn A \conj B$ sufficiente dimostrare $\turn A$ e $\turn B$. -\item La giustificazione per la riduzione del +\item La giustificazione per la riduzione del goal $\turn A \conj B$ ai due subgoals $\turn A$ e $\turn B$ la regola di $\wedge$-introduzione. \end{myenumerate} Un \emph{goal} in \HOL{} una coppia \ml{([$t_1$,\ldots,$t_n$],$t$)} di tipo \ML{} \ml{term list~*~term}. -Una \emph{realizzazione} di un tale goal un teorema \ml{$t_1$,$\ldots$,$t_n$\ |-\ $t$}. +Una \emph{realizzazione} di un tale goal un teorema \ml{$t_1$,$\ldots$,$t_n$\ |-\ $t$}. Una tattica una funzione \ML{} che quando applicata a un goal genera i subgoal insieme con una \emph{funzione di giustificazione} o di {\it validazione\/}, che sar una regola d'inferenza derivata \ML{}, che pu essere usata per inferire una realizzazione del goal originale dalla realizzazione dei subgoal. -Se $T$ una tattica (cio una funzione \ML{} di tipo\linebreak \ml{goal\,->\,(goal\,list\,*\,(thm\,list\,->\,thm))}) e $g$ un goal, allora applicare $T$ a -$g$ (cio valutare l'espressione \ML{} $T\ g$) risulter in un -oggetto che una coppia il cui primo componente una lista di goal e -il cui secondo componente una funzione di giustificazione, cio un valore con +Se $T$ una tattica (cio una funzione \ML{} di tipo\linebreak \ml{goal\,->\,(goal\,list\,*\,(thm\,list\,->\,thm))}) e $g$ un goal, allora applicare $T$ a +$g$ (cio valutare l'espressione \ML{} $T\ g$) risulter in un +oggetto che una coppia il cui primo componente una lista di goal e +il cui secondo componente una funzione di giustificazione, cio un valore con tipo \ML{} {\small\verb|thm list -> thm|}. Un esempio di tattica \ml{CONJ\_TAC} che implementa (i) e (ii) di sopra. @@ -844,8 +844,8 @@ \section{Dimostrazioni Dirette dal Goal: Tattiche e Tatticali} \end{verbatim} \end{session} -\noindent \ml{CONJ\_TAC} ha prodotto una lista di goal che consiste di due subgoal -identici di dimostrare soltanto \ml{([],"T")}. Ora, c' un teorema +\noindent \ml{CONJ\_TAC} ha prodotto una lista di goal che consiste di due subgoal +identici di dimostrare soltanto \ml{([],"T")}. Ora, c' un teorema pre-dimostrato in \HOL, chiamato \ml{TRUTH}, che ottiene questo goal. \begin{session} @@ -855,8 +855,8 @@ \section{Dimostrazioni Dirette dal Goal: Tattiche e Tatticali} \end{verbatim} \end{session} -\noindent Applicare la funzione di giustificazione \ml{just\_fn} a una lista -di teoremi che ottengono i goal nella \ml{goal\_list} risulta +\noindent Applicare la funzione di giustificazione \ml{just\_fn} a una lista +di teoremi che ottengono i goal nella \ml{goal\_list} risulta in un teorema che ottiene il goal originario: \begin{session} @@ -866,9 +866,9 @@ \section{Dimostrazioni Dirette dal Goal: Tattiche e Tatticali} \end{verbatim} \end{session} - Nonostante questo esempio sia banale, esso illustra l'idea - essenziale delle tattiche. Si noti che le tattiche non sono delle primitive - speciali di dimostrazione di teoremi; esse sono solo funzioni \ML{}. Per + Nonostante questo esempio sia banale, esso illustra l'idea + essenziale delle tattiche. Si noti che le tattiche non sono delle primitive + speciali di dimostrazione di teoremi; esse sono solo funzioni \ML{}. Per esempio, la definizione di \ml{CONJ\_TAC} semplicemente: \begin{hol} @@ -881,47 +881,47 @@ \section{Dimostrazioni Dirette dal Goal: Tattiche e Tatticali} \end{verbatim} \end{hol} -\noindent La funzione \ml{dest\_conj} divide una congiunzione nei suoi -due congiunti: se\linebreak \ml{(asl,``$t_1$}{\small\verb|/\|}\ml{$t_2$``)} un -goal, allora \ml{CONJ\_TAC} lo divide nella lista dei due subgoal -\ml{(asl,$t_1$)} e \ml{(asl,$t_2$)}. La funzione di giustificazione, -{\small\verb|fn [th1,th2] => CONJ th1 th2|} prende una lista -di teoremi \ml{[$th_1$,$th_2$]} e applica la regola \ml{CONJ} a +\noindent La funzione \ml{dest\_conj} divide una congiunzione nei suoi +due congiunti: se\linebreak \ml{(asl,``$t_1$}{\small\verb|/\|}\ml{$t_2$``)} un +goal, allora \ml{CONJ\_TAC} lo divide nella lista dei due subgoal +\ml{(asl,$t_1$)} e \ml{(asl,$t_2$)}. La funzione di giustificazione, +{\small\verb|fn [th1,th2] => CONJ th1 th2|} prende una lista +di teoremi \ml{[$th_1$,$th_2$]} e applica la regola \ml{CONJ} a $th_1$ e $th_2$. -Riassumendo: se $T$ una tattica e $g$ un goal, allora l'applicazione di $T$ -a $g$ risulter in una coppia il cui primo componente una lista di goal -e il cui secondo componente una funzione di giustificazione, con tipo \ML{} +Riassumendo: se $T$ una tattica e $g$ un goal, allora l'applicazione di $T$ +a $g$ risulter in una coppia il cui primo componente una lista di goal +e il cui secondo componente una funzione di giustificazione, con tipo \ML{} {\small\verb|thm list -> thm|}. -Supponiamo +Supponiamo $T\ g${\small\verb| = ([|}$g_1${\small\verb|,|}$\ldots${\small\verb|,|}$g_n${\small\verb|],|}$p${\small\verb|)|}. -L'idea che $g_1$ , $\ldots$ , $g_n$ siano subgoal e $p$ sia una +L'idea che $g_1$ , $\ldots$ , $g_n$ siano subgoal e $p$ sia una `giustificazione' della riduzione del goal $g$ ai subgoal $g_1$ , $\ldots$ , $g_n$. Supponiamo inoltre che i subgoal $g_1$ , $\ldots$ , $g_n$ siano stati risolti. Questo significherebbe che i teoremi $th_1$ , $\ldots$ , $th_n$ sono stati dimostrati in modo tale che $th_i$ ($1\leq i\leq -n$) `ottiene' il goal $g_i$. La giustificazione $p$ (prodotta -dall'applicazione di $T$ a $g$) una funzione \ML{} che quando applicata alla -lista -{\small\verb|[|}$th_1${\small\verb|,|}$\ldots${\small\verb|,|}$th_n${\small\verb|]|} -restituisce un teorema $th$, che `ottiene' il goal originario $g$. Cos -$p$ una funzione per convertire una soluzione dei subgoal in una -soluzione del goal originario. Se $p$ fa questo con successo, allora la -tattica $T$ chiamata {\it valida\/}. Tattiche non valide non possono risultare nella -dimostrazione di teoremi non validi; il peggio che possono fare risultare in -goal irrisolvibili o nella dimostrazione di teoremi diversi da quelli che si aveva l'intenzione di dimostrare. Se $T$ fosse +n$) `ottiene' il goal $g_i$. La giustificazione $p$ (prodotta +dall'applicazione di $T$ a $g$) una funzione \ML{} che quando applicata alla +lista +{\small\verb|[|}$th_1${\small\verb|,|}$\ldots${\small\verb|,|}$th_n${\small\verb|]|} +restituisce un teorema $th$, che `ottiene' il goal originario $g$. Cos +$p$ una funzione per convertire una soluzione dei subgoal in una +soluzione del goal originario. Se $p$ fa questo con successo, allora la +tattica $T$ chiamata {\it valida\/}. Tattiche non valide non possono risultare nella +dimostrazione di teoremi non validi; il peggio che possono fare risultare in +goal irrisolvibili o nella dimostrazione di teoremi diversi da quelli che si aveva l'intenzione di dimostrare. Se $T$ fosse non valida e fosse usata per ridurre il goal $g$ ai subgoal $g_1$ , $\ldots$ , $g_n$, potrebbero essere spese energie per dimostrare i teoremi $th_1$ , $\ldots$ -, $th_n$ per ottenere i subgoal $g_1$ , $\ldots$ , $g_n$, solo per -poi scoprire che il lavoro fatto un vicolo cieco perch +, $th_n$ per ottenere i subgoal $g_1$ , $\ldots$ , $g_n$, solo per +poi scoprire che il lavoro fatto un vicolo cieco perch $p${\small\verb|[|}$th_1${\small\verb|,|}$\ldots${\small\verb|,|}$th_n${\small\verb|]|} -non ottiene $g$ (cio fallisce, oppure ottiene un altro +non ottiene $g$ (cio fallisce, oppure ottiene un altro goal). -Un teorema {\it ottiene\/} un goal se le assunzioni del teorema sono -incluse nelle assunzioni del goal {\it e\/} se la conclusione del -teorema uguale (a meno della rinomina delle variabili legate) alla conclusione del +Un teorema {\it ottiene\/} un goal se le assunzioni del teorema sono +incluse nelle assunzioni del goal {\it e\/} se la conclusione del +teorema uguale (a meno della rinomina delle variabili legate) alla conclusione del goal. Pi precisamente, un teorema \begin{center} $t_1$, $\dots$, $t_m${\small\verb% |- %}$t$ @@ -932,21 +932,21 @@ \section{Dimostrazioni Dirette dal Goal: Tattiche e Tatticali} {\small\verb|([|}$u_1${\small\verb|,|}$\ldots${\small\verb|,|}$u_n${\small\verb|],|}$u${\small\verb|)|} \end{center} -\noindent se e solo se $\{t_1,\ldots,t_m\}$ - un sottoinsieme di $\{u_1,\ldots,u_n\}$ e $t$ uguale a $u$ (a meno -della rinomina delle variabili legate). Per esempio, il goal\linebreak -{\small\verb|([``x=y``, ``y=z``, ``z=w``], ``x=z``)|} ottenuto dal -teorema {\small\verb+[x=y, y=z] |- x=z+}\linebreak (l'assunzione +\noindent se e solo se $\{t_1,\ldots,t_m\}$ + un sottoinsieme di $\{u_1,\ldots,u_n\}$ e $t$ uguale a $u$ (a meno +della rinomina delle variabili legate). Per esempio, il goal\linebreak +{\small\verb|([``x=y``, ``y=z``, ``z=w``], ``x=z``)|} ottenuto dal +teorema {\small\verb+[x=y, y=z] |- x=z+}\linebreak (l'assunzione {\small\verb|``z=w``|} non necessaria). -Una tattica {\it risolve\/} un goal se esso riduce il goal -alla lista vuota -di subgoal. Cos $T$ risolve $g$ se +Una tattica {\it risolve\/} un goal se esso riduce il goal +alla lista vuota +di subgoal. Cos $T$ risolve $g$ se $T\ g${\small\verb| = ([],|}$p${\small\verb|)|}. -Se questo vero e se $T$ valida, allora $p${\small\verb|[]|} +Se questo vero e se $T$ valida, allora $p${\small\verb|[]|} sar valutata a un teorema che ottiene $g$. -Cos se $T$ risolve $g$ allora l'espressione \ML{} -{\small\verb|snd(|}$T\ g${\small\verb|)[]|} valutata +Cos se $T$ risolve $g$ allora l'espressione \ML{} +{\small\verb|snd(|}$T\ g${\small\verb|)[]|} valutata un teorema che ottiene $g$ Le tattiche sono specificate usando la seguente notazione: @@ -972,15 +972,15 @@ \section{Dimostrazioni Dirette dal Goal: Tattiche e Tatticali} -\noindent Cos {\small\verb|CONJ_TAC|} riduce un goal della forma +\noindent Cos {\small\verb|CONJ_TAC|} riduce un goal della forma {\small\verb|(|}$\Gamma${\small\verb|,``|}$t_1${\small\verb|/\|}$t_2${\small\verb|``)|} -ai subgoal +ai subgoal {\small\verb|(|}$\Gamma${\small\verb|,``|}$t_1${\small\verb|``)|} e {\small\verb|(|}$\Gamma${\small\verb|,``|}$t_2${\small\verb|``)|}. -Il fatto che le assunzioni del goal principale -sono propagate senza modifica ai due subgoal indicato dall'assenza +Il fatto che le assunzioni del goal principale +sono propagate senza modifica ai due subgoal indicato dall'assenza delle assunzioni nella notazione. -Un altro esempio \ml{numLib.INDUCT_TAC},\footnote{Pi avanti, scriveremo \ml{INDUCT_TAC} da solo, senza anteporre ad esso il prefisso \ml{numLib}. Per permettere questo dobbiamo immettere il comando \ml{open~numLib}.} la tattica per +Un altro esempio \ml{numLib.INDUCT_TAC},\footnote{Pi avanti, scriveremo \ml{INDUCT_TAC} da solo, senza anteporre ad esso il prefisso \ml{numLib}. Per permettere questo dobbiamo immettere il comando \ml{open~numLib}.} la tattica per eseguire l'induzione matematica sui numeri naturali. \begin{center} @@ -991,11 +991,11 @@ \section{Dimostrazioni Dirette dal Goal: Tattiche e Tatticali} \end{center} {\small\verb|INDUCT_TAC|} riduce un goal -{\small\verb|(|}$\Gamma${\small\verb|,``!|}$n${\small\verb|.|}$t[n]${\small\verb|``)|} a un subgoal base +{\small\verb|(|}$\Gamma${\small\verb|,``!|}$n${\small\verb|.|}$t[n]${\small\verb|``)|} a un subgoal base {\small\verb|(|}$\Gamma${\small\verb|,``|}$t[${\small\verb|0|}$]${\small\verb|``)|} e a un subgoal passo d'induzione {\small\verb|(|}$\Gamma\cup\{${\small\verb|``|}$t[n]${\small\verb|``|}$\}${\small\verb|,``|}$t[${\small\verb|SUC |}$n]${\small\verb|``)|}. -L'assunzione extra {\small\verb|``|}$t[n]${\small\verb|``|} +L'assunzione extra {\small\verb|``|}$t[n]${\small\verb|``|} indicata nella notazione delle tattiche con le parentesi di insieme. \begin{session} @@ -1008,13 +1008,13 @@ \section{Dimostrazioni Dirette dal Goal: Tattiche e Tatticali} \end{verbatim} \end{session} -\noindent Il primo subgoal il caso base e il secondo subgoal +\noindent Il primo subgoal il caso base e il secondo subgoal il caso passo d'induzione. -Le tattiche in genere falliscono (nel senso \ML{}, cio sollevano un'eccezione) se -sono applicate a goal inappropriati. Per esempio, -{\small\verb|CONJ_TAC|} fallir se applicata a un goal la cui -conclusione non una congiunzione. Alcune tattiche non falliscono mail, per esempio +Le tattiche in genere falliscono (nel senso \ML{}, cio sollevano un'eccezione) se +sono applicate a goal inappropriati. Per esempio, +{\small\verb|CONJ_TAC|} fallir se applicata a un goal la cui +conclusione non una congiunzione. Alcune tattiche non falliscono mail, per esempio {\small\verb|ALL_TAC|} @@ -1025,32 +1025,32 @@ \section{Dimostrazioni Dirette dal Goal: Tattiche e Tatticali} \end{tabular} \end{center} -\noindent la `tattica identit'; essa riduce un goal -{\small\verb|(|}$\Gamma${\small\verb|,|}$t${\small\verb|)|} all'unico -subgoal -{\small\verb|(|}$\Gamma${\small\verb|,|}$t${\small\verb|)|}---\ie\ non -ha alcun effetto. {\small\verb|ALL_TAC|} utile per scrivere tattiche +\noindent la `tattica identit'; essa riduce un goal +{\small\verb|(|}$\Gamma${\small\verb|,|}$t${\small\verb|)|} all'unico +subgoal +{\small\verb|(|}$\Gamma${\small\verb|,|}$t${\small\verb|)|}---\ie\ non +ha alcun effetto. {\small\verb|ALL_TAC|} utile per scrivere tattiche complesse usando i tatticali. \subsection{Usare le tattiche per dimostrare teoremi} \label{using-tactics} -Supponiamo di dover risolvere il goal $g$. Se $g$ semplice potrebbe essere -possibile pensare immediatamente a una tattica, diciamo $T$, che lo riduce +Supponiamo di dover risolvere il goal $g$. Se $g$ semplice potrebbe essere +possibile pensare immediatamente a una tattica, diciamo $T$, che lo riduce alla lista vuota di subgoal. Se questo il caso allora eseguire: $\ ${\small\verb| val (|}$gl${\small\verb|,|}$p${\small\verb|) = |}$T\ g$ -\noindent legher $p$ a una funzione che quando applicata alla lista vuota -di teoremi restituisce un teorema $th$ che ottiene $g$. (La dichiarazione -di sopra legher anche $gl$ alla lista vuota di goal.) Cos un teorema +\noindent legher $p$ a una funzione che quando applicata alla lista vuota +di teoremi restituisce un teorema $th$ che ottiene $g$. (La dichiarazione +di sopra legher anche $gl$ alla lista vuota di goal.) Cos un teorema che ottiene $g$ pu essere computato eseguendo: $\ ${\small\verb| val |}$th${\small\verb| = |}$p${\small\verb|[]|} -\noindent Questo sar illustrato usando \ml{REWRITE\_TAC} che prende una lista -di equazioni (vuota nell'esempio che segue) e prover a dimostrare un goal -riscrivendo con queste equazioni insieme con +\noindent Questo sar illustrato usando \ml{REWRITE\_TAC} che prende una lista +di equazioni (vuota nell'esempio che segue) e prover a dimostrare un goal +riscrivendo con queste equazioni insieme con \ml{basic\_rewrites}: \begin{session} @@ -1066,23 +1066,23 @@ \subsection{Usare le tattiche per dimostrare teoremi} \end{verbatim} \end{session} -\noindent I teoremi dimostrati sono di solito archiviati nella teoria attuale +\noindent I teoremi dimostrati sono di solito archiviati nella teoria attuale cos che possano essere usati nelle sessioni successive. -La funzione incorporata - \ml{store\_thm} di -tipo \ML{} {\small\verb|(string * term * tactic) -> thm|} facilita l'uso +La funzione incorporata + \ml{store\_thm} di +tipo \ML{} {\small\verb|(string * term * tactic) -> thm|} facilita l'uso delle tattiche: -{\small\verb|store_thm("foo",|}$t${\small\verb|,|}$T${\small\verb|)|} dimostra -il goal {\small\verb|([],|}$t${\small\verb|)|} (cio il goal senza -assunzioni e con la conclusione $t$) usando la tattica $T$ e salva il teorema +{\small\verb|store_thm("foo",|}$t${\small\verb|,|}$T${\small\verb|)|} dimostra +il goal {\small\verb|([],|}$t${\small\verb|)|} (cio il goal senza +assunzioni e con la conclusione $t$) usando la tattica $T$ e salva il teorema risultante con il nome {\small\verb|foo|} nella teoria corrente. -Se non si deve salvare il teorema, si pu usare la funzione \ml{prove} di tipo\linebreak -{\small\verb|(term * tactic) -> thm|}. Valutare -{\small\verb|prove(|}$t${\small\verb|,|}$T${\small\verb|)|} dimostra il goal -{\small\verb|([],|}$t${\small\verb|)|} usando $T$ e restituisce il risultato senza -salvarlo. In entrambi i case, la valutazione fallisce se $T$ non risolve il +Se non si deve salvare il teorema, si pu usare la funzione \ml{prove} di tipo\linebreak +{\small\verb|(term * tactic) -> thm|}. Valutare +{\small\verb|prove(|}$t${\small\verb|,|}$T${\small\verb|)|} dimostra il goal +{\small\verb|([],|}$t${\small\verb|)|} usando $T$ e restituisce il risultato senza +salvarlo. In entrambi i case, la valutazione fallisce se $T$ non risolve il goal {\small\verb|([],|}$t${\small\verb|)|}. Quando si conduce una dimostrazione che coinvolge molti subgoal e tattiche, necessario tenere traccia di tutte le funzioni di giustificazione e comporle nell'ordine corretto. @@ -1095,10 +1095,10 @@ \subsection{Usare le tattiche per dimostrare teoremi} \subsection{Tatticali} \label{tacticals} -Un {\it tatticale\/} una funzione \ML{} che prende una o pi tattiche -come argomenti, possibilmente con anche altri argomenti, e restituisce una -tattica come suo risultato. I diversi parametri passati ai tatticali sono -riflessi nei vari tipi \ML{} che hanno i tatticali incorporati nel sistema. +Un {\it tatticale\/} una funzione \ML{} che prende una o pi tattiche +come argomenti, possibilmente con anche altri argomenti, e restituisce una +tattica come suo risultato. I diversi parametri passati ai tatticali sono +riflessi nei vari tipi \ML{} che hanno i tatticali incorporati nel sistema. Alcuni tatticali importanti nel sistema \HOL{} sono elencati di sotto. \subsubsection{\tt THENL : tactic -> tactic list -> tactic} @@ -1106,7 +1106,7 @@ \subsubsection{\tt THENL : tactic -> tactic list -> tactic} Se una tattica $T$ produce $n$ subgoal e $T_1$, $\ldots$ , $T_n$ sono tattiche allora \ml{$T$~THENL~[$T_1$,$\ldots$,$T_n$]} una tattica che prima applica $T$ e poi applica $T_i$ all'$i$-esimo subgoal prodotto da $T$. Il tatticale \ml{THENL} utile se si vogliono fare cose differenti per subgoal differenti. -\ml{THENL} pu essere illustrata eseguendo la dimostrazione di $\vdash \uquant{m}m+0=m$ in +\ml{THENL} pu essere illustrata eseguendo la dimostrazione di $\vdash \uquant{m}m+0=m$ in un solo passo. \setcounter{sessioncount}{0} @@ -1132,19 +1132,19 @@ \subsubsection{\tt THENL : tactic -> tactic list -> tactic} \] prima applica \ml{INDUCT_TAC} e quindi applica \ml{REWRITE\_TAC[ADD]} al primo subgoal (la base) e \ml{ASM\_REWRITE\_TAC[ADD]} al secondo subgoal (il passo). -Il tatticale {\small\verb|THENL|} utile per fare cose differenti -per subgoal differenti. il tatticale \ml{THEN} pu essere usato per applicare +Il tatticale {\small\verb|THENL|} utile per fare cose differenti +per subgoal differenti. il tatticale \ml{THEN} pu essere usato per applicare la stessa tattica a tutti i subgoal. \subsubsection{\tt THEN : tactic -> tactic -> tactic}\label{THEN} -Il tatticale {\small\verb|THEN|} un \ML{} infisso. Se $T_1$ e $T_2$ -sono tattiche, allora l'espressione \ML{} $T_1${\small\verb| THEN |}$T_2$ - valutata a una tattica che prima applica $T_1$ e poi applica $T_2$ +Il tatticale {\small\verb|THEN|} un \ML{} infisso. Se $T_1$ e $T_2$ +sono tattiche, allora l'espressione \ML{} $T_1${\small\verb| THEN |}$T_2$ + valutata a una tattica che prima applica $T_1$ e poi applica $T_2$ a tutti i subgoal prodotti da $T_1$. -Di fatto, \ml{ASM\_REWRITE\_TAC[ADD]} risolver tanto la base che -il passo dell'induzione per $\uquant{m}m+0=m$, cos esiste una +Di fatto, \ml{ASM\_REWRITE\_TAC[ADD]} risolver tanto la base che +il passo dell'induzione per $\uquant{m}m+0=m$, cos esiste una dimostrazione di un solo passo persino pi semplice di quella di sopra: \setcounter{sessioncount}{0} \begin{session} @@ -1164,9 +1164,9 @@ \subsubsection{\tt THEN : tactic -> tactic -> tactic}\label{THEN} \end{verbatim} \end{session} -\noindent Questo tipico: comune usare un'unica tattica per molti -goal. Qui, per esempio, ci sono le prime quattro conseguenze della -definizione \ml{ADD} dell'addizione che sono pre-dimostrate quando la +\noindent Questo tipico: comune usare un'unica tattica per molti +goal. Qui, per esempio, ci sono le prime quattro conseguenze della +definizione \ml{ADD} dell'addizione che sono pre-dimostrate quando la teoria \ml{arithmetic} incorporata in \HOL{} costruita. \begin{hol} @@ -1205,20 +1205,20 @@ \subsubsection{\tt THEN : tactic -> tactic -> tactic}\label{THEN} \end{hol} -\noindent Queste dimostrazioni sono eseguite quando il sistema \HOL{} costruito e i -teoremi sono salvati nella teoria \ml{arithmetic}. La lista completa delle -dimostrazioni per questa teoria incorporata si possono trovare nel file +\noindent Queste dimostrazioni sono eseguite quando il sistema \HOL{} costruito e i +teoremi sono salvati nella teoria \ml{arithmetic}. La lista completa delle +dimostrazioni per questa teoria incorporata si possono trovare nel file \ml{src/num/theories/arithmeticScript.sml}. \subsubsection{\tt ORELSE : tactic -> tactic -> tactic}\label{ORELSE} -Il tatticale {\small\verb|ORELSE|} un \ML{} infisso. Se $T_1$ e -$T_2$ sono tattiche, +Il tatticale {\small\verb|ORELSE|} un \ML{} infisso. Se $T_1$ e +$T_2$ sono tattiche, %\index{tacticals!for alternation} -allora $T_1${\small\verb| ORELSE |}$T_2$ valutata a una tattica che +allora $T_1${\small\verb| ORELSE |}$T_2$ valutata a una tattica che applica $T_1$ a meno che fallisce; se fallisce, applica $T_2$. -\ml{ORELSE} definita in \ML{} come un infisso curried\footnote{Questa +\ml{ORELSE} definita in \ML{} come un infisso curried\footnote{Questa una semplificazione minore.} \begin{hol} @@ -1229,8 +1229,8 @@ \subsubsection{\tt ORELSE : tactic -> tactic -> tactic}\label{ORELSE} \subsubsection{\tt REPEAT : tactic -> tactic} -Se $T$ una tattica allora {\small\verb|REPEAT |}$T$ una tattiche che -applica ripetutamente $T$ fino a quando fallisce. Questo pu essere illustrato in +Se $T$ una tattica allora {\small\verb|REPEAT |}$T$ una tattiche che +applica ripetutamente $T$ fino a quando fallisce. Questo pu essere illustrato in congiunzione con \ml{GEN\_TAC}, che specificato da: \begin{center} @@ -1243,7 +1243,7 @@ \subsubsection{\tt REPEAT : tactic -> tactic} \end{center} \begin{itemize} -\item Dove $x'$ una variante di $x$ +\item Dove $x'$ una variante di $x$ non libera nel goal o nelle assunzioni. \end{itemize} @@ -1275,8 +1275,8 @@ \subsubsection{\tt REPEAT : tactic -> tactic} \subsection{Alcune tattiche incorporate in \HOL{}} -Questa sezione contiene un sommario di alcune tattiche incorporate nel -sistema \HOL{} (incluse quelle gi discusse). Le tattiche date +Questa sezione contiene un sommario di alcune tattiche incorporate nel +sistema \HOL{} (incluse quelle gi discusse). Le tattiche date qui sono quelle che sono usate nell'esempio del bit di parit. \subsubsection{\tt REWRITE\_TAC : thm list -> tactic} @@ -1284,8 +1284,8 @@ \subsubsection{\tt REWRITE\_TAC : thm list -> tactic} \begin{itemize} \item{\bf Sommario:} {\small\verb|REWRITE_TAC[|}$th_1${\small\verb|,|}$\ldots${\small\verb|,|}$th_n${\small\verb|]|} -semplifica il goal riscrivendolo -con i teoremi dati esplicitamente $th_1$, $\ldots$ , $th_n$, +semplifica il goal riscrivendolo +con i teoremi dati esplicitamente $th_1$, $\ldots$ , $th_n$, e varie regole di riscrittura incorporate. @@ -1298,7 +1298,7 @@ \subsubsection{\tt REWRITE\_TAC : thm list -> tactic} \end{tabular} \end{center} -\noindent dove $t'$ ottenuto da $t$ attraverso la riscrittura con +\noindent dove $t'$ ottenuto da $t$ attraverso la riscrittura con \begin{enumerate} \item $th_1$, $\ldots$ , $th_n$ e \item le scritture standard contenute nella variabile \ML{} {\small\verb|basic_rewrites|}. @@ -1308,18 +1308,18 @@ \subsubsection{\tt REWRITE\_TAC : thm list -> tactic} \item{\bf Altre tattiche di riscrittura}: \begin{enumerate} -\item {\small\verb|ASM_REWRITE_TAC|} aggiunge le assunzioni del goal +\item {\small\verb|ASM_REWRITE_TAC|} aggiunge le assunzioni del goal alla lista dei teoremi usati per la riscrittura. -\item {\small\verb|PURE_REWRITE_TAC|} non usa n le assunzioni +\item {\small\verb|PURE_REWRITE_TAC|} non usa n le assunzioni n le riscritture incorporate. \item {\small\verb|RW_TAC|} di tipo \ml{simpLib.simpset -> thm - list -> tactic}. Un \ml{simpset} una speciale collezione - di teoremi di riscrittura e altre funzionalit di dimostrazione di teoremi. I valori - definiti da \HOL{} includono \ml{bossLib.std\_ss}, che ha la conoscenza + list -> tactic}. Un \ml{simpset} una speciale collezione + di teoremi di riscrittura e altre funzionalit di dimostrazione di teoremi. I valori + definiti da \HOL{} includono \ml{bossLib.std\_ss}, che ha la conoscenza di base dei connettivi booleani, \ml{bossLib.arith\_ss} che ``conosce'' tutto riguardo all'aritmetica, e \ml{HOLSimps.list\_ss}, che include teoremi appropriati per le liste, le coppie, e l'aritmetica. - Teoremi aggiuntivi per la riscrittura possono essere aggiunti usando il secondo + Teoremi aggiuntivi per la riscrittura possono essere aggiunti usando il secondo argomento di \ml{RW\_TAC}. \end{enumerate} \end{itemize} @@ -1329,7 +1329,7 @@ \subsubsection{\tt CONJ\_TAC : tactic}\label{CONJTAC} \begin{itemize} -\item{\bf Sommario:} Divide un +\item{\bf Sommario:} Divide un goal {\small\verb|``|}$t_1${\small\verb|/\|}$t_2${\small\verb|``|} in due subgoals {\small\verb|``|}$t_1${\small\verb|``|} e {\small\verb|``|}$t_2${\small\verb|``|}. @@ -1362,7 +1362,7 @@ \subsubsection{\tt EQ\_TAC : tactic}\label{EQTAC} \end{tabular} \end{center} -\item{\bf Uso:} Dimostrare equivalenze logiche, \ie\ goal della forma +\item{\bf Uso:} Dimostrare equivalenze logiche, \ie\ goal della forma ``$u$\ml{=}$v$'' dove $u$ e $v$ sono termini booleani. \end{itemize} @@ -1374,7 +1374,7 @@ \subsubsection{\tt DISCH\_TAC : tactic}\label{DISCHTAC} \begin{itemize} -\item{\bf Sommario:} Sposta l'antecedente +\item{\bf Sommario:} Sposta l'antecedente di un goal implicazione nelle assunzioni \begin{center} @@ -1407,11 +1407,11 @@ \subsubsection{\tt GEN\_TAC : tactic} \end{tabular} \end{center} -\noindent Dove $x'$ una variante di $x$ +\noindent Dove $x'$ una variante di $x$ non libera nel goal o nelle assunzioni. \item{\bf Usi:} Risolvere goal quantificati universalmente. -{\small\verb|REPEAT GEN_TAC|} elimina tutti +{\small\verb|REPEAT GEN_TAC|} elimina tutti i quantificatori universali ed spesso la prima cosa che si fa in una dimostrazione. {\small\verb|STRIP_TAC|} (si veda di sotto) applica {\small\verb|GEN_TAC|} ai goal quantificati universalmente. \end{itemize} @@ -1420,13 +1420,13 @@ \subsubsection{\tt GEN\_TAC : tactic} \subsubsection{\tt PROVE\_TAC : thm list -> tactic} \begin{itemize} -\item {\bf Sommario:} Usato per eseguire un ragionamento al primo ordine; risolvendo il - goal completamente se ha successo, e fallendo altrimenti. Usando - i teoremi forniti e le assunzioni del goal, - {\small\verb|PROVE_TAC|} esegue una ricerca delle dimostrazioni possibili del - goal. Alla fine fallisce se la ricerca fallisce di trovare una dimostrazione pi corta +\item {\bf Sommario:} Usato per eseguire un ragionamento al primo ordine; risolvendo il + goal completamente se ha successo, e fallendo altrimenti. Usando + i teoremi forniti e le assunzioni del goal, + {\small\verb|PROVE_TAC|} esegue una ricerca delle dimostrazioni possibili del + goal. Alla fine fallisce se la ricerca fallisce di trovare una dimostrazione pi corta di una profondit ragionevole. -\item {\bf Usi:} Per concludere un goal quando chiaro che una +\item {\bf Usi:} Per concludere un goal quando chiaro che una conseguenza delle assunzioni e dei teoremi forniti. \end{itemize} @@ -1438,11 +1438,11 @@ \subsubsection{\tt STRIP\_TAC : tactic} \item{\bf Sommario:} Spezza un goal. {\small\verb|STRIP_TAC|} rimuove un connettivo esterno dal goal, usando {\small\verb|CONJ_TAC|}, {\small\verb|DISCH_TAC|}, - {\small\verb|GEN_TAC|}, \etc\ Se il goal -$t_1${\small\verb|/\|}$\cdots${\small\verb|/\|}$t_n${\small\verb| ==> |}$t$ + {\small\verb|GEN_TAC|}, \etc\ Se il goal +$t_1${\small\verb|/\|}$\cdots${\small\verb|/\|}$t_n${\small\verb| ==> |}$t$ allora {\small\verb|STRIP_TAC|} rende ogni $t_i$ in una assunzione separata. -\item{\bf Usi:} utile per dividere un goal in pezzi maneggevoli. +\item{\bf Usi:} utile per dividere un goal in pezzi maneggevoli. Spesso la cosa migliore da fare per prima {\small\verb|REPEAT STRIP_TAC|}. \end{itemize} @@ -1453,13 +1453,13 @@ \subsubsection{\tt ACCEPT\_TAC : thm -> tactic}\label{ACCEPTTAC} \begin{itemize} \item{\bf Sommario:} {\small\verb|ACCEPT_TAC |}$th$ - una tattica che risolve qualsiasi goal che sia + una tattica che risolve qualsiasi goal che sia ottenuto da $th$. -\item{\bf Uso:} Incorporare dimostrazioni in avanti, o teoremi gi - dimostrati, in dimostrazioni dirette dal goal. Per esempio, si potrebbe ridurre un - goal $g$ ai subgoal $g_1$, $\dots$, $g_n$ usando una tattica $T$ e - poi dimostrare i teoremi $th_1$ , $\dots$, $th_n$ ottenendo rispettivamente +\item{\bf Uso:} Incorporare dimostrazioni in avanti, o teoremi gi + dimostrati, in dimostrazioni dirette dal goal. Per esempio, si potrebbe ridurre un + goal $g$ ai subgoal $g_1$, $\dots$, $g_n$ usando una tattica $T$ e + poi dimostrare i teoremi $th_1$ , $\dots$, $th_n$ ottenendo rispettivamente questi goal attraverso dimostrazioni in avanti. La tattica \[\ml{ T THENL[ACCEPT\_TAC }th_1\ml{,}\ldots\ml{,ACCEPT\_TAC }th_n\ml{]} @@ -1467,7 +1467,7 @@ \subsubsection{\tt ACCEPT\_TAC : thm -> tactic}\label{ACCEPTTAC} risolverebbe poi $g$, dove \ml{THENL} %\index{THENL@\ml{THENL}} - il tatticale che applica gli elementi rispettivi della lista di + il tatticale che applica gli elementi rispettivi della lista di tattiche ai subgoal prodotti da \ml{T}. \end{itemize} @@ -1484,9 +1484,9 @@ \subsubsection{\tt ALL\_TAC : tactic} \begin{enumerate} \item Scrivere tatticali (si veda la descrizione di {\small\verb|REPEAT|} in \DESCRIPTION). -\item Con {\small\verb|THENL|}; per esempio, se la tattica $T$ produce due subgoal -e vogliamo applicare $T_1$ -al primo ma non fare nulla al secondo, quindi +\item Con {\small\verb|THENL|}; per esempio, se la tattica $T$ produce due subgoal +e vogliamo applicare $T_1$ +al primo ma non fare nulla al secondo, quindi la tattica da usare \ml{$T$~THENL[$T_1$,ALL_TAC]}. \end{enumerate} \end{itemize} diff --git a/Manual/Translations/IT/Tutorial/ml.tex b/Manual/Translations/IT/Tutorial/ml.tex index 0936b285b2..591c3901cd 100644 --- a/Manual/Translations/IT/Tutorial/ml.tex +++ b/Manual/Translations/IT/Tutorial/ml.tex @@ -1,59 +1,59 @@ \chapter{Introduzione a ML} \label{ML} -Questo capitolo una breve introduzione al meta-linguaggio \ML. -L'obiettivo solo quello di dare una sensazione di come sia interagire con -il linguaggio. Si pu trovare un'introduzione pi dettagliata -in numerosi libri di testo e pagine web; si veda per esempio l'elenco delle risorse -sulla home page +Questo capitolo una breve introduzione al meta-linguaggio \ML. +L'obiettivo solo quello di dare una sensazione di come sia interagire con +il linguaggio. Si pu trovare un'introduzione pi dettagliata +in numerosi libri di testo e pagine web; si veda per esempio l'elenco delle risorse +sulla home page di MoscowML\footnote{\url{http://www.dina.kvl.dk/~sestoft/mosml.html}}, -o le FAQ +o le FAQ \texttt{comp.lang.ml}\footnote{\url{http://www.faqs.org/faqs/meta-lang-faq/}}. \section{Come interagire con ML} -\ML{} un linguaggio di programmazione interattivo come il Lisp. Al livello -dell'interprete si possono valutare espressioni ed eseguire dichiarazioni. Le prime -risultano nella stampa a schermo del valore dell'espressione e del suo tipo, le seconde +\ML{} un linguaggio di programmazione interattivo come il Lisp. Al livello +dell'interprete si possono valutare espressioni ed eseguire dichiarazioni. Le prime +risultano nella stampa a schermo del valore dell'espressione e del suo tipo, le seconde nel binding di un valore a un nome. -Un modo standard di interagire con \ML{} quello di configurare lo schermo +Un modo standard di interagire con \ML{} quello di configurare lo schermo della workstation in modo tale che ci siano due finestre: \begin{myenumerate} -\item Una finestra di modifica in cui i comandi \ML{} sono inizialmente battuti +\item Una finestra di modifica in cui i comandi \ML{} sono inizialmente battuti e registrati. -\item Una finestra shell (o l'equivalente non-Unix) che usata per +\item Una finestra shell (o l'equivalente non-Unix) che usata per valutare i comandi. \end{myenumerate} \noindent -Un modo comune per ottenere questo lavorare all'interno di \ml{Emacs} con una +Un modo comune per ottenere questo lavorare all'interno di \ml{Emacs} con una finestra di testo e una finestra shell. -Dopo ave battuto un comando sulla finestra di modifica (testo) esso pu essere -trasferito alla shell e valutato in \HOL{} con un `copia e incolla'. In -\ml{Emacs} questo si ottiene copiando il testo in un buffer e poi facendo il -suo `yanking' nella shell. Il vantaggio di lavorare con un editor -che se il comando ha un errore, allora il testo pu essere modificato semplicemente -e usato di nuovo; inoltre esso salva i comandi in un file che pu poi -essere usato di nuovo pi avanti (attraverso un caricamento batch). In \ml{Emacs}, la finestra -di shell registra anche la sessione, inclusi sia l'input dell'utente -sia la risposta del sistema. Le sessioni in questo tutorial sono state prodotte -in questo modo. Queste sessioni sono divise in segmenti mostrati in riquadri -con un numero sul loro angolo superiore destro (per indicare la loro +Dopo ave battuto un comando sulla finestra di modifica (testo) esso pu essere +trasferito alla shell e valutato in \HOL{} con un `copia e incolla'. In +\ml{Emacs} questo si ottiene copiando il testo in un buffer e poi facendo il +suo `yanking' nella shell. Il vantaggio di lavorare con un editor +che se il comando ha un errore, allora il testo pu essere modificato semplicemente +e usato di nuovo; inoltre esso salva i comandi in un file che pu poi +essere usato di nuovo pi avanti (attraverso un caricamento batch). In \ml{Emacs}, la finestra +di shell registra anche la sessione, inclusi sia l'input dell'utente +sia la risposta del sistema. Le sessioni in questo tutorial sono state prodotte +in questo modo. Queste sessioni sono divise in segmenti mostrati in riquadri +con un numero sul loro angolo superiore destro (per indicare la loro posizione nella sessione completa). -Le interazioni in questi riquadri dovrebbero essere intese operare in -sequenza. Per esempio, si assume che i binding delle variabili fatte in box precedenti -persistano nei successivi. Per entrare nel sistema \HOL{} si -digita {\small\verb|hol|} o {\small\verb|hol.noquote|} in Unix, -eventualmente preceduti dall'informazione del percorso se la directory bin del sistema -\HOL{} non nel proprio percorso. Il sistema \HOL{} quindi -stampa un messaggio di sign-on e ci colloca all'interno di \ML. Il prompt \ML{} -{\small\verb|-|}, perci le righe cominciano con {\small\verb|-|} sono quelle digitate +Le interazioni in questi riquadri dovrebbero essere intese operare in +sequenza. Per esempio, si assume che i binding delle variabili fatte in box precedenti +persistano nei successivi. Per entrare nel sistema \HOL{} si +digita {\small\verb|hol|} o {\small\verb|hol.noquote|} in Unix, +eventualmente preceduti dall'informazione del percorso se la directory bin del sistema +\HOL{} non nel proprio percorso. Il sistema \HOL{} quindi +stampa un messaggio di sign-on e ci colloca all'interno di \ML. Il prompt \ML{} +{\small\verb|-|}, perci le righe cominciano con {\small\verb|-|} sono quelle digitate dall'utente e le altre righe sono le risposte del sistema. - Qui, come nelle altre parti del \TUTORIAL{}, assumeremo che si stia usando + Qui, come nelle altre parti del \TUTORIAL{}, assumeremo che si stia usando {\small\verb|hol|}. \setcounter{sessioncount}{0} @@ -74,23 +74,23 @@ \section{Come interagire con ML} \end{session} L'espressione \ML{} {\small\verb|1 :: [2,3,4,5]|} ha la forma $e_1\ -op\ e_2$ dove $e_1$ l'espressione {\small\verb|1|} (il cui valore +op\ e_2$ dove $e_1$ l'espressione {\small\verb|1|} (il cui valore l'intero $1$), $e_2$ l'espressione {\small\verb|[2,3,4,5]|} -(il cui valore una lista di quattro interi) e $op$ l'operatore +(il cui valore una lista di quattro interi) e $op$ l'operatore infisso `{\small\verb|::|}' che come la funzione del Lisp {\it cons}. Altre funzioni di elaborazione di liste includono {\small\verb|hd|} ($car$ in Lisp), {\small\verb|tl|} ($cdr$ in Lisp) e {\small\verb|null|} -($null$ in Lisp). Il punto e virgola `{\small\verb|;|}' termina una -frase complessiva. La risposta del sistema mostrata sulla linea che comincia -con il prompt {\small\verb|>|}. Essa consiste del valore -dell'espressione seguito, dopo un segno di due punti, dal suo tipo. Il type checker di \ML{} -deduce il tipo delle espressioni usando metodi inventati da Robin Milner -\cite{Milner-types}. Il tipo {\small\verb|int list|} il tipo delle -`liste di interi'; {\small\verb|list|} un operatore di tipo unario. -Il sistema di tipi di \ML{} molto simile al sistema di tipi della +($null$ in Lisp). Il punto e virgola `{\small\verb|;|}' termina una +frase complessiva. La risposta del sistema mostrata sulla linea che comincia +con il prompt {\small\verb|>|}. Essa consiste del valore +dell'espressione seguito, dopo un segno di due punti, dal suo tipo. Il type checker di \ML{} +deduce il tipo delle espressioni usando metodi inventati da Robin Milner +\cite{Milner-types}. Il tipo {\small\verb|int list|} il tipo delle +`liste di interi'; {\small\verb|list|} un operatore di tipo unario. +Il sistema di tipi di \ML{} molto simile al sistema di tipi della logica \HOL{} che spiegata nel Capitolo~\ref{HOLlogic}. -Il valore dell'ultima espressione valutata dal top level \ML{} sempre +Il valore dell'ultima espressione valutata dal top level \ML{} sempre memorizzata in una variabile chiamata {\small\verb|it|}. \begin{session} @@ -109,17 +109,17 @@ \section{Come interagire con ML} \end{verbatim} \end{session} -Seguendo gli standard del $\lambda$-calcolo, l'applicazione di una +Seguendo gli standard del $\lambda$-calcolo, l'applicazione di una funzione $f$ a un argomento $x$ pu essere scritta senza parentesi come $f\ -x$ (bench permesso anche -il pi convenzionale $f${\small\verb|(|}$x${\small\verb|)|}). L'espressione -$f\ x_1\ x_2\ \cdots\ x_n$ abbrevia l'espressione +x$ (bench permesso anche +il pi convenzionale $f${\small\verb|(|}$x${\small\verb|)|}). L'espressione +$f\ x_1\ x_2\ \cdots\ x_n$ abbrevia l'espressione meno intelligibile {\small\verb|(|}$\cdots${\small\verb|((|}$f\ x_1$% -{\small\verb|)|}$x_2${\small\verb|)|}$\cdots${\small\verb|)|}$x_n$ +{\small\verb|)|}$x_2${\small\verb|)|}$\cdots${\small\verb|)|}$x_n$ (l'applicazione di funzione associativa a sinistra). Le dichiarazioni hanno la forma {\small\verb|val |}$x_1${\small\verb|=|}$e_1${\small\verb| and |}$\cdots -${\small\verb| and |}$x_n${\small\verb|=|}$e_n$ e hanno l'effetto che il valore di +${\small\verb| and |}$x_n${\small\verb|=|}$e_n$ e hanno l'effetto che il valore di ogni espressione $e_i$ venga legato al nome $x_i$. \begin{session} @@ -131,12 +131,12 @@ \section{Come interagire con ML} \end{session} Espressioni \ML{} come {\small\verb|"a"|}, {\small\verb|"b"|}, -{\small\verb|"foo"|} \etc\ sono {\it stringhe\/} e hanno il tipo -{\small\verb|string|}. Qualsiasi sequenza di caratteri {\small ASCII} pu -essere scritta tra virgolette\footnote{I caratteri di nuova riga devono essere scritti come - \ml{$\backslash$n}, e le virgolette come \ml{$\backslash$"}.}. La funzione -{\small\verb|explode|} divide una stringa in una lista di caratteri -singoli, che sono scritti come stringhe di un singolo carattere, con +{\small\verb|"foo"|} \etc\ sono {\it stringhe\/} e hanno il tipo +{\small\verb|string|}. Qualsiasi sequenza di caratteri {\small ASCII} pu +essere scritta tra virgolette\footnote{I caratteri di nuova riga devono essere scritti come + \ml{$\backslash$n}, e le virgolette come \ml{$\backslash$"}.}. La funzione +{\small\verb|explode|} divide una stringa in una lista di caratteri +singoli, che sono scritti come stringhe di un singolo carattere, con anteposto un carattere {\small\verb|#|}. \begin{session} @@ -146,19 +146,19 @@ \section{Come interagire con ML} \end{verbatim} \end{session} -Un'espressione della forma -{\small\verb|(|}$e_1${\small\verb|,|}$e_2${\small\verb|)|} viene valutata -a una coppia dei valori di $e_1$ e $e_2$. Se $e_1$ ha il tipo -$\sigma_1$ e $e_2$ ha il tipo $\sigma_2$ allora -{\small\verb|(|}$e_1${\small\verb|,|}$e_2${\small\verb|)|} ha il tipo -$\sigma_1${\small\verb|*|}$\sigma_2$. Il primo e il secondo componente -di una coppia possono essere estratti con le funzioni \ML{} {\small\verb|#1|} -e {\small\verb|#2|} rispettivamente. Se una tupla ha pi di due componenti, -il suo $n$-esimo componente pu essere estratto con una funzione +Un'espressione della forma +{\small\verb|(|}$e_1${\small\verb|,|}$e_2${\small\verb|)|} viene valutata +a una coppia dei valori di $e_1$ e $e_2$. Se $e_1$ ha il tipo +$\sigma_1$ e $e_2$ ha il tipo $\sigma_2$ allora +{\small\verb|(|}$e_1${\small\verb|,|}$e_2${\small\verb|)|} ha il tipo +$\sigma_1${\small\verb|*|}$\sigma_2$. Il primo e il secondo componente +di una coppia possono essere estratti con le funzioni \ML{} {\small\verb|#1|} +e {\small\verb|#2|} rispettivamente. Se una tupla ha pi di due componenti, +il suo $n$-esimo componente pu essere estratto con una funzione {\small\verb|#|$n$}. I valori {\small\verb|(1,2,3)|}, {\small\verb|(1,(2,3))|} e -{\small\verb|((1,2), 3)|} sono tutti distinti e hanno i tipi +{\small\verb|((1,2), 3)|} sono tutti distinti e hanno i tipi \linebreak{} {\small\verb|int * int * int|}, {\small\verb|int * (int * int)|} and {\small\verb|(int * int) * int|} rispettivamente. @@ -176,23 +176,23 @@ \section{Come interagire con ML} \end{verbatim} \end{session} -\noindent L'espressioni \ML{} {\small\verb|true|} e {\small\verb|false|} +\noindent L'espressioni \ML{} {\small\verb|true|} e {\small\verb|false|} denotano i due valori di verit di tipo {\small\verb|bool|}. I tipi \ML{} possono contenere {\it variabili di tipo\/} {\small\verb|'a|}, {\small\verb|'b|}, {\small\verb|'c|}, \etc\ Tali tipi sono chiamati {\it -polimorfici\/}. Una funzione con un tipo polimorfico dovrebbe essere pensata come +polimorfici\/}. Una funzione con un tipo polimorfico dovrebbe essere pensata come se possedesse tutti i tipi che si possono ottenere sostituendo le variabili di tipo con dei tipi. Questo illustrato di sotto con la funzione {\small\verb|zip|}. Le funzioni sono definite con dichiarazioni della forma {\small\verb|fun|}$\ f\ -v_1\ \ldots\ v_n$ \ml{=} $e$ dove ciascuna $v_i$ o una variabile o un pattern +v_1\ \ldots\ v_n$ \ml{=} $e$ dove ciascuna $v_i$ o una variabile o un pattern composto di variabili. La funzione {\small\verb|zip|}, di sotto, converte una coppia di liste {\small\verb|([|}$x_1${\small\verb|,|}$\ldots${\small\verb|,|}$x_n$% {\small\verb|], [|}$y_1${\small\verb|,|}$\ldots${\small\verb|,|}$y_n$% -{\small\verb|])|} in una lista di coppie +{\small\verb|])|} in una lista di coppie {\small\verb|[(|}$x_1${\small\verb|,|}$y_1${\small\verb|),|}$\ldots$% {\small\verb|,(|}$x_n${\small\verb|,|}$y_n${\small\verb|)]|}. @@ -208,8 +208,8 @@ \section{Come interagire con ML} \end{verbatim} \end{session} -Le funzioni possono essere {\it curried\/}, \ie\ prendono i lori argomenti `uno alla volta' -al posto che come una tupla. Questo illustrato con la funzione +Le funzioni possono essere {\it curried\/}, \ie\ prendono i lori argomenti `uno alla volta' +al posto che come una tupla. Questo illustrato con la funzione {\small\verb|curried_zip|} di sotto: \begin{session} @@ -226,19 +226,19 @@ \section{Come interagire con ML} \end{session} La valutazione di un'espressione o {\it ha successo\/} o {\it - fallisce\/}. Nel primo caso, la valutazione restituisce un valore; nel -secondo caso la valutazione interrotta ed sollevata -un'\emph{eccezione}. Questa eccezione passata a qualunque cosa abbia invocato la valutazione. -Questo contesto pu o propagare il fallimento (questo il default) o -pu {\it gestirlo\/}. Queste due possibilit sono illustrate di sotto. -La gestione di un'eccezione un'espressione della forma -$e_1${\small\verb| handle _ => |}$e_2$. Un'espressione di questa forma + fallisce\/}. Nel primo caso, la valutazione restituisce un valore; nel +secondo caso la valutazione interrotta ed sollevata +un'\emph{eccezione}. Questa eccezione passata a qualunque cosa abbia invocato la valutazione. +Questo contesto pu o propagare il fallimento (questo il default) o +pu {\it gestirlo\/}. Queste due possibilit sono illustrate di sotto. +La gestione di un'eccezione un'espressione della forma +$e_1${\small\verb| handle _ => |}$e_2$. Un'espressione di questa forma valutata valutando per prima cosa $e_1$. Se la valutazione ha successo (\ie\ -non fallisce) allora il valore dell'intera espressione il valore di -$e_1$. Se la valutazione di $e_1$ ha sollevato un'eccezione, allora il valore -dell'intera espressione ottenuto valutando $e_2$.\footnote{Questa - descrizione della gestione dell'eccezioni di fatto una semplificazione grossolana - del modo in cui le eccezioni possono essere gestite in \ML{}; si consulti un testo appropriato +non fallisce) allora il valore dell'intera espressione il valore di +$e_1$. Se la valutazione di $e_1$ ha sollevato un'eccezione, allora il valore +dell'intera espressione ottenuto valutando $e_2$.\footnote{Questa + descrizione della gestione dell'eccezioni di fatto una semplificazione grossolana + del modo in cui le eccezioni possono essere gestite in \ML{}; si consulti un testo appropriato per una spiegazione migliore.}. \begin{session} @@ -252,9 +252,9 @@ \section{Come interagire con ML} \end{verbatim} \end{session} -Le sessioni di sopra sono sufficienti per dare un idea dell'\ML. Nel prossimo -capitolo, sar introdotta la logica supportata dal sistema \HOL{} (la logica di -ordine superiore), insieme con gli strumenti all'interno di \ML{} per +Le sessioni di sopra sono sufficienti per dare un idea dell'\ML. Nel prossimo +capitolo, sar introdotta la logica supportata dal sistema \HOL{} (la logica di +ordine superiore), insieme con gli strumenti all'interno di \ML{} per manipolarla. %%% Local Variables: diff --git a/Manual/Translations/IT/Tutorial/more-examples.tex b/Manual/Translations/IT/Tutorial/more-examples.tex index aa0742d636..b642a9632a 100644 --- a/Manual/Translations/IT/Tutorial/more-examples.tex +++ b/Manual/Translations/IT/Tutorial/more-examples.tex @@ -2,56 +2,56 @@ \chapter{Altri Esempi} \label{chap:more-examples} -In aggiunta agli esempi gi trattati in questo testo, la distribuzione -\holn{} fornisce una variet di esempi istruttivi nella -directory \verb|examples| Li si possono trovare (tra gli +In aggiunta agli esempi gi trattati in questo testo, la distribuzione +\holn{} fornisce una variet di esempi istruttivi nella +directory \verb|examples| Li si possono trovare (tra gli altri) i seguenti esempi: \begin{description} \item [\tt autopilot.sml] - Questo esempio un'interpretazione \holn{} (di Mark Staples) di un - esempio PVS dovuto a Ricky Butler della NASA. L'esempio mostra l'uso del - pacchetto di definizione record, cos come illustra alcuni aspetti + Questo esempio un'interpretazione \holn{} (di Mark Staples) di un + esempio PVS dovuto a Ricky Butler della NASA. L'esempio mostra l'uso del + pacchetto di definizione record, cos come illustra alcuni aspetti dell'automazione disponibile in \holn{}. \item [\tt bmark] - In questa directory, c' un benchmarck standard di HOL: la dimostrazione della + In questa directory, c' un benchmarck standard di HOL: la dimostrazione della correttezza di un circuito moltiplicatore, dovuto a Mike Gordon. \item [\tt euclid.sml] - Questo esempio lo stesso di quello trattato nel - Capitolo~\ref{chap:euclid}: una dimostrazione del teorema di Euclide - sull'infintit dei numeri primi, estratto e modificato da uno sviluppo - molto pi ampio dovuto a John Harrison. Esso illustra + Questo esempio lo stesso di quello trattato nel + Capitolo~\ref{chap:euclid}: una dimostrazione del teorema di Euclide + sull'infintit dei numeri primi, estratto e modificato da uno sviluppo + molto pi ampio dovuto a John Harrison. Esso illustra l'automazione di \HOL{} su una dimostrazione classica. \item[\tt ind\_def] -Questa directory contiene alcuni esempi di un pacchetto di definizione induttiva -in azione. In primo piano ci sono una semantica operazionale per un piccolo linguaggio -di programmazione imperativa, un piccolo sistema di algebra, una logica combinatoria +Questa directory contiene alcuni esempi di un pacchetto di definizione induttiva +in azione. In primo piano ci sono una semantica operazionale per un piccolo linguaggio +di programmazione imperativa, un piccolo sistema di algebra, una logica combinatoria con il suo sistema di tipi. I file furono sviluppati originariamente da Tom Melham -e Juanito Camilleri e sono estesamente commentati. L'ultimo la +e Juanito Camilleri e sono estesamente commentati. L'ultimo la base per il Capitolo~\ref{chap:combin}. -La maggior parte delle dimostrazioni in queste teorie ora possono essere fatte pi facilmente -usando alcuni degli strumenti di dimostrazione sviluppati recentemente, cio il semplificatore +La maggior parte delle dimostrazioni in queste teorie ora possono essere fatte pi facilmente +usando alcuni degli strumenti di dimostrazione sviluppati recentemente, cio il semplificatore e il dimostratore al primo ordine. \item [\tt fol.sml] - Questo file illustra l'implementazione di John Harrison di + Questo file illustra l'implementazione di John Harrison di un dimostratore al primo ordine nello stile del model-elimination. \item[\tt lambda] -Questa directory sviluppa le teorie di un lambda calcolo nello stile ``de Bruijn'', -e anche una versione name-carrying. (Entrambe sono non tipizzate.) Lo sviluppo - una revisione delle dimostrazioni che sottostanno al documento +Questa directory sviluppa le teorie di un lambda calcolo nello stile ``de Bruijn'', +e anche una versione name-carrying. (Entrambe sono non tipizzate.) Lo sviluppo + una revisione delle dimostrazioni che sottostanno al documento {\it ``5 Axioms of Alpha Conversion'', Andy Gordon and Tom Melham, Proceedings of TPHOLs'96, Springer LNCS 1125}. @@ -59,26 +59,26 @@ \chapter{Altri Esempi} \item[\tt parity] - Questa sotto directory contiene i file usati nell'esempio di parit del + Questa sotto directory contiene i file usati nell'esempio di parit del Capitolo~\ref{parity}. \item [\tt MLsyntax] - Questa sotto directory contiene un ampio esempio di un'infrastruttura per + Questa sotto directory contiene un ampio esempio di un'infrastruttura per definire tipi reciprocamente ricorsivi, dovuto a Elsa Gunter del Bell Labs. - Nell'esempio, definito il tipo di sintassi astratta per un sottoinsieme piccolo - ma non totalmente irrealistico di ML, insieme con una semplice funzione + Nell'esempio, definito il tipo di sintassi astratta per un sottoinsieme piccolo + ma non totalmente irrealistico di ML, insieme con una semplice funzione reciprocamente ricorsiva sulla sintassi. \item[\tt Thery.sml] - Un esempio molto breve dovuto a Laurent Thery, che mostra un'acuta + Un esempio molto breve dovuto a Laurent Thery, che mostra un'acuta dimostrazione induttiva. \item[\tt RSA] - Questa directory sviluppa parte della matematica sottostante - lo schema RSA di crittografia. Le teorie sono state + Questa directory sviluppa parte della matematica sottostante + lo schema RSA di crittografia. Le teorie sono state prodotte da Laurent Thery dell'INRIA Sophia-Antipolis. \end{description} diff --git a/Manual/Translations/IT/Tutorial/parity.tex b/Manual/Translations/IT/Tutorial/parity.tex index ec9c5a0851..eaa22a2435 100644 --- a/Manual/Translations/IT/Tutorial/parity.tex +++ b/Manual/Translations/IT/Tutorial/parity.tex @@ -1,56 +1,56 @@ \chapter{Esempio: un Semplice Validatore di Parit}\label{parity} -Questo capitolo consiste di un esempio pratico: la specifica e -la verifica di un semplice validatore di parit sequenziale. L'intenzione +Questo capitolo consiste di un esempio pratico: la specifica e +la verifica di un semplice validatore di parit sequenziale. L'intenzione di ottenere due cose: \begin{myenumerate} \item Presentare un pezzo completo di lavoro con \HOL. -\item Dare una sensazione di cosa vuol dire usare il sistema \HOL\ per +\item Dare una sensazione di cosa vuol dire usare il sistema \HOL\ per una\linebreak dimostrazione complicata. \end{myenumerate} -Per quanto riguarda (ii), si noti che bench i teoremi dimostrati siano, di fatto, -piuttosto semplici, il modo in cui essi sono dimostrati illustra il genere intricato di -`ingegnerizzazione della dimostrazione' che tipico. Le dimostrazioni potrebbero essere -fatte in modo pi elegante, ma presentarle in quel modo farebbe fallire il -proposito di illustrare varie caratteristiche di \HOL. Si spera che il -semplice esempio qui illustrato dar al lettore la sensazione di cosa significhi fare +Per quanto riguarda (ii), si noti che bench i teoremi dimostrati siano, di fatto, +piuttosto semplici, il modo in cui essi sono dimostrati illustra il genere intricato di +`ingegnerizzazione della dimostrazione' che tipico. Le dimostrazioni potrebbero essere +fatte in modo pi elegante, ma presentarle in quel modo farebbe fallire il +proposito di illustrare varie caratteristiche di \HOL. Si spera che il +semplice esempio qui illustrato dar al lettore la sensazione di cosa significhi fare una dimostrazione di grandi dimensioni. -I lettori che non sono interessati nella verifica dell'hardware dovrebbero essere in grado -di imparare qualcosa circa il sistema \HOL{} anche se non desiderano -penetrare i dettagli dell'esempio sul validatore di parit qui usato. La -specifica e la verifica di un validatore di parit pi complesso +I lettori che non sono interessati nella verifica dell'hardware dovrebbero essere in grado +di imparare qualcosa circa il sistema \HOL{} anche se non desiderano +penetrare i dettagli dell'esempio sul validatore di parit qui usato. La +specifica e la verifica di un validatore di parit pi complesso lasciato come esercizio (una soluzione fornita nella directory {\small\verb|examples/parity|}). \section{Introduzione} -Le sessioni di questo esempio comprendono la specifica e -la verifica di un dispositivo che calcolata la parit di una sequenza di -bit. Pi precisamente, data una verifica dettagliata di un dispositivo -con un input {\small\verb|in|}, un output {\small\verb|out|} e la -specifica che l'$n$-esimo output su {\small\verb|out|} -{\small\verb|T|} se e solo se c' stato un numero pari di -input di {\small\verb|T|} su {\small\verb|in|}. E' costruita una teoria chiamata -{\small\verb|PARITY|}; questa contiene la specifica e -la verifica del dispositivo. Tutti gli input \ML{} nei riquadri di sotto -possono essere trovati nel file {\small\verb|examples/parity/PARITYScript.sml|}. Si -suggerisce al lettore di inserire interattivamente questo per avere una -sensazione `pratica' dell'esempio. L'obiettivo del caso di studio di illustrare +Le sessioni di questo esempio comprendono la specifica e +la verifica di un dispositivo che calcolata la parit di una sequenza di +bit. Pi precisamente, data una verifica dettagliata di un dispositivo +con un input {\small\verb|in|}, un output {\small\verb|out|} e la +specifica che l'$n$-esimo output su {\small\verb|out|} +{\small\verb|T|} se e solo se c' stato un numero pari di +input di {\small\verb|T|} su {\small\verb|in|}. E' costruita una teoria chiamata +{\small\verb|PARITY|}; questa contiene la specifica e +la verifica del dispositivo. Tutti gli input \ML{} nei riquadri di sotto +possono essere trovati nel file {\small\verb|examples/parity/PARITYScript.sml|}. Si +suggerisce al lettore di inserire interattivamente questo per avere una +sensazione `pratica' dell'esempio. L'obiettivo del caso di studio di illustrare un dettagliato `proof hacking' su un esempio piccolo e abbastanza semplice. \section{Specifica} \label{example} -Il primo passo avviare il sistema \HOL{}. Usiamo di nuovo -\texttt{/bin/hol}. Il prompt \ML{} {\small\verb|-|}, cos -le righe che cominciano con {\small\verb|-|} sono digitate dall'utente e le altre +Il primo passo avviare il sistema \HOL{}. Usiamo di nuovo +\texttt{/bin/hol}. Il prompt \ML{} {\small\verb|-|}, cos +le righe che cominciano con {\small\verb|-|} sono digitate dall'utente e le altre linee sono le risposte del sistema. -Per specificare il dispositivo, definita una funzione primitiva ricorsiva -{\small\verb|PARITY|} cos che per $n>0$, {\small\tt PARITY} -$n f$ vero se il numero di {\small\verb|T|} nella sequenza +Per specificare il dispositivo, definita una funzione primitiva ricorsiva +{\small\verb|PARITY|} cos che per $n>0$, {\small\tt PARITY} +$n f$ vero se il numero di {\small\verb|T|} nella sequenza $f${\small\tt (}$1${\small\tt)}, $\ldots$ , $f${\small\tt (}$n${\small\tt)} pari. @@ -71,22 +71,22 @@ \section{Specifica} \noindent -L'effetto della nostra chiamata a {\small\verb|Define|} di archiviare la -definizione di {\small\verb|PARITY|} nella teoria corrente con il nome +L'effetto della nostra chiamata a {\small\verb|Define|} di archiviare la +definizione di {\small\verb|PARITY|} nella teoria corrente con il nome {\small\verb|PARITY_def|} e di legare il teorema di definizione alla variabile \ML\ -con lo stesso nome. Si noti che vengono scritti due tipi di -nome: i nomi delle costanti nelle teorie e i nomi -delle variabili in \ML. L'utente in genere libero di gestire questi nomi -come desidera (a seconda delle varie esigenze -lessicali), ma una convenzione comune (come in questo caso) di dare alla -definizione di una costante {\small\tt CON} il nome -{\small\verb|CON_def|} nella teoria e anche in \ML. Un'altra -convenzione usata comunemente di usare solo {\small\verb|CON|} per la -teoria e il nome \ML{} della definizione di una costante -{\small\verb|CON|}. Sfortunatamente, il sistema \HOL{} non usa una -convenzione uniforme, ma agli utenti si raccomanda di adottarne una. In questo -caso \ml{Define} ha fatto una delle scelte per noi, ma ci sono -altri scenari in cui dobbiamo scegliere il nome usato nel file +con lo stesso nome. Si noti che vengono scritti due tipi di +nome: i nomi delle costanti nelle teorie e i nomi +delle variabili in \ML. L'utente in genere libero di gestire questi nomi +come desidera (a seconda delle varie esigenze +lessicali), ma una convenzione comune (come in questo caso) di dare alla +definizione di una costante {\small\tt CON} il nome +{\small\verb|CON_def|} nella teoria e anche in \ML. Un'altra +convenzione usata comunemente di usare solo {\small\verb|CON|} per la +teoria e il nome \ML{} della definizione di una costante +{\small\verb|CON|}. Sfortunatamente, il sistema \HOL{} non usa una +convenzione uniforme, ma agli utenti si raccomanda di adottarne una. In questo +caso \ml{Define} ha fatto una delle scelte per noi, ma ci sono +altri scenari in cui dobbiamo scegliere il nome usato nel file della teoria. La specifica del dispositivo di controllo di parit pu ora essere data come: @@ -98,11 +98,11 @@ \section{Specifica} \end{hol} \noindent -E' {\it intuitivamente\/} chiaro che questa specifica sar -soddisfatta se le funzioni di segnale\footnote{I segnali sono modellati come funzioni - da numeri, che rappresentano tempi, a booleani.} -{\small\verb|inp|} e {\small\verb|out|} soddisfano\footnote{Preferiremmo - usare \ml{in} come uno dei nomi delle nostre variabili, ma questa una parola +E' {\it intuitivamente\/} chiaro che questa specifica sar +soddisfatta se le funzioni di segnale\footnote{I segnali sono modellati come funzioni + da numeri, che rappresentano tempi, a booleani.} +{\small\verb|inp|} e {\small\verb|out|} soddisfano\footnote{Preferiremmo + usare \ml{in} come uno dei nomi delle nostre variabili, ma questa una parola riservata per le espressioni-\ml{let}.}: \begin{hol} @@ -119,7 +119,7 @@ \section{Specifica} \end{verbatim} \end{hol} -\noindent Questo pu essere verificato in modo formale in \HOL{} fornendo il +\noindent Questo pu essere verificato in modo formale in \HOL{} fornendo il seguente lemma: \begin{hol} @@ -132,10 +132,10 @@ \section{Specifica} \end{verbatim} \end{hol} -\noindent La dimostrazione di questo pu essere fatta per Induzione Matematica e, bench -banale, una buona illustrazione di come tali dimostrazioni sono fatte. Il -lemma dimostrato interattivamente usando il pacchetto subgoal di \HOL. La dimostrazione - avviata mettendo il goal da dimostrare in un goal stack usando la +\noindent La dimostrazione di questo pu essere fatta per Induzione Matematica e, bench +banale, una buona illustrazione di come tali dimostrazioni sono fatte. Il +lemma dimostrato interattivamente usando il pacchetto subgoal di \HOL. La dimostrazione + avviata mettendo il goal da dimostrare in un goal stack usando la funzione {\small\verb|g|} che prende un goal come argomento. \begin{session} @@ -156,13 +156,13 @@ \section{Specifica} \end{session} \noindent Il pacchetto subgoal stampa il goal all'inizio del goal stack. -Il goal principale espanso eliminando il quantificatore universale -(con {\small\verb|GEN_TAC|}) e quindi mettendo i due congiunti -dell'antecedente dell'implicazione nelle assunzioni del goal (con -{\small\verb|STRIP_TAC|}). La funzione \ML{} {\small\verb|expand|} -prende una tattica e la applica al goal principale; i subgoal risultanti -sono immessi nel goal stack. Il messaggio `{\small\verb|OK..|}' -stampato appena prima dell'applicazione della tattica. Quindi stampato +Il goal principale espanso eliminando il quantificatore universale +(con {\small\verb|GEN_TAC|}) e quindi mettendo i due congiunti +dell'antecedente dell'implicazione nelle assunzioni del goal (con +{\small\verb|STRIP_TAC|}). La funzione \ML{} {\small\verb|expand|} +prende una tattica e la applica al goal principale; i subgoal risultanti +sono immessi nel goal stack. Il messaggio `{\small\verb|OK..|}' +stampato appena prima dell'applicazione della tattica. Quindi stampato il subgoal risultante. @@ -179,8 +179,8 @@ \section{Specifica} \end{verbatim} \end{session} -\noindent Poi fatta l'induzione su {\small\verb|t|} -usando {\small\verb|Induct|}, che fa +\noindent Poi fatta l'induzione su {\small\verb|t|} +usando {\small\verb|Induct|}, che fa l'induzione sulla variabile quantificata universalmente pi esterna. \begin{session} @@ -202,10 +202,10 @@ \section{Specifica} \end{verbatim} \end{session} -\noindent Le assunzioni dei due subgoal -sono riportate numerate sotto le linee di trattini orizzontali. -L'ultimo goal stampato quello in cima allo stack, che il -caso base. Questo risolto riscrivendolo con le sue assunzioni e la +\noindent Le assunzioni dei due subgoal +sono riportate numerate sotto le linee di trattini orizzontali. +L'ultimo goal stampato quello in cima allo stack, che il +caso base. Questo risolto riscrivendolo con le sue assunzioni e la definizione di {\small\verb|PARITY|}. @@ -227,8 +227,8 @@ \section{Specifica} \end{verbatim} \end{session} -Il goal principale dimostrato, cos il sistema lo estrae dal goal stack (e -mette il teorema dimostrato in uno stack di teoremi). Il nuovo goal principale +Il goal principale dimostrato, cos il sistema lo estrae dal goal stack (e +mette il teorema dimostrato in uno stack di teoremi). Il nuovo goal principale il caso di passo dell'induzione. Questo goal anch'esso risolto per riscrittura. \begin{session} @@ -250,11 +250,11 @@ \section{Specifica} \end{verbatim} \end{session} -\noindent Il goal dimostrato, \ie\ prodotta la lista vuota di subgoal. -Il sistema ora applica le funzioni di giustificazione prodotte dalle -tattiche alla lista di teoremi ottenendo i subgoal (iniziando con -la lista vuota). Questi teoremi sono stampati nell'ordine in cui -sono generati (si noti che le assunzioni dei teoremi sono stampate come +\noindent Il goal dimostrato, \ie\ prodotta la lista vuota di subgoal. +Il sistema ora applica le funzioni di giustificazione prodotte dalle +tattiche alla lista di teoremi ottenendo i subgoal (iniziando con +la lista vuota). Questi teoremi sono stampati nell'ordine in cui +sono generati (si noti che le assunzioni dei teoremi sono stampate come punti). La funzione \ML{} @@ -265,7 +265,7 @@ \section{Specifica} \end{hol} \noindent -restituisce il teorema appena dimostrato (\ie\ quello in cima allo stack dei teoremi) +restituisce il teorema appena dimostrato (\ie\ quello in cima allo stack dei teoremi) nella teoria corrente, e noi lo leghiamo al nome \ML{} \ml{UNIQUENESS\_LEMMA}. @@ -285,34 +285,34 @@ \section{Specifica} \section{Implementazione} \label{implementation} -Il lemma appena dimostrato suggerisce che il checker di parit pu essere -implementato mantenendo il valore di parit in un registro e poi -integrando il contenuto del registro ogni volta che {\small\verb|T|} - inserito. Per rendere l'implementazione pi interessante, si -assumer che i registri `si accendano' archiviando {\small\verb|F|}. Cos -l'output al tempo {\small\verb|0|} non pu essere preso direttamente da un -registro, perch l'output del validatore di parit al tempo -{\small\verb|0|} specificato essere {\small\verb|T|}. Un'altra cosa -complicata da notare che se {\small\verb|t>0|} allora l'output del -validatore di parit al tempo {\small\verb|t|} una funzione dell'input al -tempo {\small\verb|t|}. Cos ci deve essere un percorso combinatorio +Il lemma appena dimostrato suggerisce che il checker di parit pu essere +implementato mantenendo il valore di parit in un registro e poi +integrando il contenuto del registro ogni volta che {\small\verb|T|} + inserito. Per rendere l'implementazione pi interessante, si +assumer che i registri `si accendano' archiviando {\small\verb|F|}. Cos +l'output al tempo {\small\verb|0|} non pu essere preso direttamente da un +registro, perch l'output del validatore di parit al tempo +{\small\verb|0|} specificato essere {\small\verb|T|}. Un'altra cosa +complicata da notare che se {\small\verb|t>0|} allora l'output del +validatore di parit al tempo {\small\verb|t|} una funzione dell'input al +tempo {\small\verb|t|}. Cos ci deve essere un percorso combinatorio dall'input all'output. -Il diagramma schematico di sotto mostra il disegno di +Il diagramma schematico di sotto mostra il disegno di un dispositivo che inteso implementare questa specifica. (L'input pi a sinistra di \ml{MUX} il selettore.) -Questo funziona archiviando la parit della sequenza immessa finora -nella parte bassa dei due registri. Ogni volta che {\small\verb|T|} immesso in -{\small\verb|in|}, questo valore archiviato integrato. Si assume che i registri -`si accendano' in uno stato in cui stanno archiviando {\small\verb|F|}. Il secondo -registro (connesso a {\small\verb|ONE|}) inizialmente restituisce l'output - {\small\verb|F|} e -dopo restituisce sempre {\small\verb|T|}. Il suo ruolo solo quello di assicurare che il -dispositivo -funzioni durante il primo ciclo collegando l'output {\small\verb|out|} al -dispositivo {\small\verb|ONE|} attraverso il multiplexer pi basso. Per tutti i cicli successivi -{\small\verb|out|} collegato a {\small\verb|l3|} e quindi o porta il -valore di parit archiviato (se l'input corrente {\small\verb|F|}) oppure il +Questo funziona archiviando la parit della sequenza immessa finora +nella parte bassa dei due registri. Ogni volta che {\small\verb|T|} immesso in +{\small\verb|in|}, questo valore archiviato integrato. Si assume che i registri +`si accendano' in uno stato in cui stanno archiviando {\small\verb|F|}. Il secondo +registro (connesso a {\small\verb|ONE|}) inizialmente restituisce l'output + {\small\verb|F|} e +dopo restituisce sempre {\small\verb|T|}. Il suo ruolo solo quello di assicurare che il +dispositivo +funzioni durante il primo ciclo collegando l'output {\small\verb|out|} al +dispositivo {\small\verb|ONE|} attraverso il multiplexer pi basso. Per tutti i cicli successivi +{\small\verb|out|} collegato a {\small\verb|l3|} e quindi o porta il +valore di parit archiviato (se l'input corrente {\small\verb|F|}) oppure il complemento di questo valore (se l'input corrente {\small\verb|T|}). \begin{center} @@ -364,9 +364,9 @@ \section{Implementazione} %HEVEA \imageflush \end{center} -I dispositivi che compongono questo schema saranno modellati con predicati -\cite{Why-HOL-paper}. Per esempio, il predicato {\small\verb|ONE|} vero -di un segnale {\small\verb|out|} se per tutti gli istanti {\small\verb|t|} il valore di +I dispositivi che compongono questo schema saranno modellati con predicati +\cite{Why-HOL-paper}. Per esempio, il predicato {\small\verb|ONE|} vero +di un segnale {\small\verb|out|} se per tutti gli istanti {\small\verb|t|} il valore di {\small\verb|out|} {\small\verb|T|}. \begin{session} @@ -377,17 +377,17 @@ \section{Implementazione} \end{verbatim} \end{session} -\noindent Si noti che, come discusso di sopra, `{\small\verb|ONE_def|}' usato sia +\noindent Si noti che, come discusso di sopra, `{\small\verb|ONE_def|}' usato sia come una variabile \ML{} e come il nome della definizione nella teoria. -Si noti anche come `{\small\verb|:num->bool|}' stato aggiunto per risolvere -le ambiguit di tipo; senza questa (o qualche altra informazione) il -controllore di tipo non sarebbe in grado di dedurre che {\small\tt t} deve avere +Si noti anche come `{\small\verb|:num->bool|}' stato aggiunto per risolvere +le ambiguit di tipo; senza questa (o qualche altra informazione) il +controllore di tipo non sarebbe in grado di dedurre che {\small\tt t} deve avere il tipo {\small\tt num}. -Il predicato binario {\small\verb|NOT|} vero di una coppia di segnali -{\small\verb|(inp,out)|} se il valore di {\small\verb|out|} sempre -la negazione del valore di {\small\verb|inp|}. Gli invertitori sono cos -modellati come non aventi alcun ritardo. Questo appropriato per un +Il predicato binario {\small\verb|NOT|} vero di una coppia di segnali +{\small\verb|(inp,out)|} se il valore di {\small\verb|out|} sempre +la negazione del valore di {\small\verb|inp|}. Gli invertitori sono cos +modellati come non aventi alcun ritardo. Questo appropriato per un modello di livello registro-trasferimento, ma non per un livello inferiore. \begin{session} @@ -399,8 +399,8 @@ \section{Implementazione} \end{session} \noindent Il dispositivo combinatorio finale necessario un multiplexer. -Questo un `hardware condizionale'; l'input -{\small\verb|sw|} seleziona quale degli altri +Questo un `hardware condizionale'; l'input +{\small\verb|sw|} seleziona quale degli altri due input devono essere collegati all'output {\small\verb|out|}. \begin{session} @@ -416,11 +416,11 @@ \section{Implementazione} \end{verbatim} \end{session} -I dispositivi rimanenti nello schema sono i registri. Questi sono -elementi unit di ritardo; i valori restituiti come output al tempo {\small\verb|t+1|} sono -i valori immessi come input al tempo precedente {\small\verb|t|}, escluso il -tempo {\small\verb|0|} in cui il registro restituisce l'output -{\small\verb|F|}\footnote{Il tempo {\tt {\small 0}} rappresenta quando il +I dispositivi rimanenti nello schema sono i registri. Questi sono +elementi unit di ritardo; i valori restituiti come output al tempo {\small\verb|t+1|} sono +i valori immessi come input al tempo precedente {\small\verb|t|}, escluso il +tempo {\small\verb|0|} in cui il registro restituisce l'output +{\small\verb|F|}\footnote{Il tempo {\tt {\small 0}} rappresenta quando il dispositivo acceso.}. \begin{session} @@ -436,10 +436,10 @@ \section{Implementazione} \end{verbatim} \end{session} -Il diagramma schematico di sopra pu essere rappresentato come un predicato -congiungendo le relazioni che valgono tra i vari -segnali e quindi quantificando esistenzialmente le linee interne. -Questa tecnica spiegata altrove +Il diagramma schematico di sopra pu essere rappresentato come un predicato +congiungendo le relazioni che valgono tra i vari +segnali e quindi quantificando esistenzialmente le linee interne. +Questa tecnica spiegata altrove (\eg\ si veda \cite{Camilleri-et-al,Why-HOL-paper}). \begin{session} @@ -468,14 +468,14 @@ \section{Verification} |- !inp out. PARITY_IMP(inp,out) ==> (!t. out t = PARITY t inp) \end{verbatim} \end{hol} -Questo afferma che {\it se\/} {\small\verb|inp|} e {\small\verb|out|} -sono correlati come nel diagramma +Questo afferma che {\it se\/} {\small\verb|inp|} e {\small\verb|out|} +sono correlati come nel diagramma schematico (\ie\ come nella definizione di {\small\verb|PARITY_IMP|}), -{\it allora\/} la +{\it allora\/} la coppia di segnali {\small\verb|(inp,out)|} soddisfa la specifica. -Per prima cosa, dimostrato il seguente lemma; la correttezza del validatore -di parit segue da questo e da {\small\verb|UNIQUENESS_LEMMA|} per la +Per prima cosa, dimostrato il seguente lemma; la correttezza del validatore +di parit segue da questo e da {\small\verb|UNIQUENESS_LEMMA|} per la transitivit di {\small{\tt\verb+==>+}}. \begin{session} @@ -496,14 +496,14 @@ \section{Verification} \end{verbatim} \end{session} -Il primo passo, per dimostrare questo goal la riscrittura con le definizioni -seguita da una decomposizione del goal risultante per mezzo di -{\small\verb|STRIP_TAC|}. E' usata la tattica di riscrittura -{\small\verb|PURE_REWRITE_TAC|}; questa non fa alcuna semplificazione -incorporata, ma solo quelle date esplicitamente nella lista di -teoremi fornita come argomento. Una delle semplificazioni incorporate +Il primo passo, per dimostrare questo goal la riscrittura con le definizioni +seguita da una decomposizione del goal risultante per mezzo di +{\small\verb|STRIP_TAC|}. E' usata la tattica di riscrittura +{\small\verb|PURE_REWRITE_TAC|}; questa non fa alcuna semplificazione +incorporata, ma solo quelle date esplicitamente nella lista di +teoremi fornita come argomento. Una delle semplificazioni incorporate usate da {\small\verb|REWRITE_TAC|} {\small\tt |-~(x~=~T)~=~x}. -{\small\verb|PURE_REWRITE_TAC|} usata per evitare che venga effettuata una riscrittura +{\small\verb|PURE_REWRITE_TAC|} usata per evitare che venga effettuata una riscrittura con questa semplificazione. \begin{session} \begin{verbatim} @@ -533,13 +533,13 @@ \section{Verification} \end{verbatim} \end{session} -Il goal principale quello stampato per ultimo; la sua conclusione -{\small\verb|out 0 = T|} e le sue assunzioni sono equazioni che collegano -i valori sulle linee nel circuito. Il prossimo passo naturale -sarebbe espandere il goal principale per mezzo della riscrittura con le assunzioni. Tuttavia, -se si facesse questo il sistema entrerebbe in un loop infinito perch +Il goal principale quello stampato per ultimo; la sua conclusione +{\small\verb|out 0 = T|} e le sue assunzioni sono equazioni che collegano +i valori sulle linee nel circuito. Il prossimo passo naturale +sarebbe espandere il goal principale per mezzo della riscrittura con le assunzioni. Tuttavia, +se si facesse questo il sistema entrerebbe in un loop infinito perch le equazioni per {\small\verb|out|}, {\small\verb|l2|} e -{\small\verb|l3|} sono mutuamente ricorsive. Al suo posto usiamo il +{\small\verb|l3|} sono mutuamente ricorsive. Al suo posto usiamo il ragionatore al primo ordine {\small\verb|PROVE_TAC|} per fare il lavoro: \begin{session} @@ -563,8 +563,8 @@ \section{Verification} 5. !t. out t = (if l5 t then l3 t else l4 t) \end{verbatim} \end{session} -Il primo dei due subgoal dimostrato. Ispezionando il goal -rimanente si pu vedere che sar risolto se il suo lato sinistro, +Il primo dei due subgoal dimostrato. Ispezionando il goal +rimanente si pu vedere che sar risolto se il suo lato sinistro, {\small\verb|out(SUC t)|}, espanso usando l'assunzione: \begin{hol} @@ -574,16 +574,16 @@ \section{Verification} \end{hol} - Tuttavia, se questa assunzione usata per riscrivere, allora anche + Tuttavia, se questa assunzione usata per riscrivere, allora anche tutti i sottotermini della forma {\small\verb|out t|} saranno espansi. - Per evitare questo, in realt vogliamo riscrivere con una formula che - riguarda specificatamente {\small\verb|out (SUC t)|}. Vogliamo estrarre - in qualche modo l'assunzione che desideriamo dalla lista e riscrivere con - una sua versione specializzata. Possiamo fare questo usando + Per evitare questo, in realt vogliamo riscrivere con una formula che + riguarda specificatamente {\small\verb|out (SUC t)|}. Vogliamo estrarre + in qualche modo l'assunzione che desideriamo dalla lista e riscrivere con + una sua versione specializzata. Possiamo fare questo usando {\small\verb|PAT_ASSUM|}. Questa tattica di tipo \ml{term -> thm - -> tactic}. Essa seleziona un'assunzione che della forma data - dal suo termine argomento, e la passa al secondo argomento, una - funzione che si aspetta un teorema e restituisce una tattica. Qui + -> tactic}. Essa seleziona un'assunzione che della forma data + dal suo termine argomento, e la passa al secondo argomento, una + funzione che si aspetta un teorema e restituisce una tattica. Qui mostrata in azione: \begin{session} @@ -605,17 +605,17 @@ \section{Verification} \end{verbatim} \end{session} Il pattern qui usato ha sfruttato qualcosa chiamato \emph{higher order - matching}. L'assunzione attuale che stato tolta dallo stack delle -assunzioni non ha un lato destro che appare come l'applicazione di una -funzione (\ml{X} nel pattern) al parametro \ml{t}, ma il lato destro -potrebbe comunque essere visto uguale all'applicazione di \emph{qualche} -funzione al parametro \ml{t}. Di fatto, il valore che si accordava con + matching}. L'assunzione attuale che stato tolta dallo stack delle +assunzioni non ha un lato destro che appare come l'applicazione di una +funzione (\ml{X} nel pattern) al parametro \ml{t}, ma il lato destro +potrebbe comunque essere visto uguale all'applicazione di \emph{qualche} +funzione al parametro \ml{t}. Di fatto, il valore che si accordava con \ml{X} era {\small\verb|``\x. if l5 x then l3 x else l4 x``|}. -Ispezionando il goal di sopra si pu vedere che il prossimo passo di -svolgere le equazioni per le linee rimanenti del circuito. Facciamo -questo usando il simpset \ml{arith\_ss} fornito da \ml{bossLib} che -aiuta con l'aritmetica incarnata dalle sottrazioni e dai termini +Ispezionando il goal di sopra si pu vedere che il prossimo passo di +svolgere le equazioni per le linee rimanenti del circuito. Facciamo +questo usando il simpset \ml{arith\_ss} fornito da \ml{bossLib} che +aiuta con l'aritmetica incarnata dalle sottrazioni e dai termini \ml{SUC}. @@ -654,9 +654,9 @@ \section{Verification} \end{verbatim} \end{session} -{\small\verb|PARITY_LEMMA|} avrebbe potuto essere dimostrato in un unico passo con una -singola tattica composta. Il nostro goal iniziale poteva essere espanso con una -singola tattica corrispondente alla sequenza delle tattiche che sono state usate +{\small\verb|PARITY_LEMMA|} avrebbe potuto essere dimostrato in un unico passo con una +singola tattica composta. Il nostro goal iniziale poteva essere espanso con una +singola tattica corrispondente alla sequenza delle tattiche che sono state usate interattivamente: \begin{session} @@ -683,8 +683,8 @@ \section{Verification} \end{verbatim} \end{session} -Una volta in possesso di {\small\verb|PARITY_LEMMA|}, il teorema finale facilmente -dimostrato. Questo sar fatto in un unico passo usando la funzione \ML{} +Una volta in possesso di {\small\verb|PARITY_LEMMA|}, il teorema finale facilmente +dimostrato. Questo sar fatto in un unico passo usando la funzione \ML{} {\small\verb|prove|}. \begin{session} @@ -698,30 +698,30 @@ \section{Verification} \end{verbatim} \end{session} -\noindent Questo completa la dimostrazione del +\noindent Questo completa la dimostrazione del dispositivo di controllo di parit. \section{Esercizi} \label{exercises} -In questa sezione sono dati due esercizi: l'Esercizio~1 -chiaro, ma l'Esercizio~2 piuttosto complicato e a un principiante +In questa sezione sono dati due esercizi: l'Esercizio~1 +chiaro, ma l'Esercizio~2 piuttosto complicato e a un principiante potrebbe richiedere molti giorni per risolverlo. \subsection{Esercizio 1} Usando {\it solo\/} i dispositivi {\small\verb|ONE|}, {\small\verb|NOT|}, -{\small\verb|MUX|} e {\small\verb|REG|} definiti nella -Sezione~\ref{implementation}, progettare e verificare un registro -{\small\verb|RESET_REG|} con un input {\small\verb|inp|}, linea di ripristino -{\small\verb|reset|}, output {\small\verb|out|} e comportamento +{\small\verb|MUX|} e {\small\verb|REG|} definiti nella +Sezione~\ref{implementation}, progettare e verificare un registro +{\small\verb|RESET_REG|} con un input {\small\verb|inp|}, linea di ripristino +{\small\verb|reset|}, output {\small\verb|out|} e comportamento specificato come segue. \begin{itemize} -\item Se {\small\verb|reset|} {\small\verb|T|} al tempo - {\small\verb|t|}, allora anche il valore in {\small\verb|out|} al tempo +\item Se {\small\verb|reset|} {\small\verb|T|} al tempo + {\small\verb|t|}, allora anche il valore in {\small\verb|out|} al tempo {\small\verb|t|} {\small\verb|T|}. -\item Se {\small\verb|reset|} {\small\verb|T|} al tempo - {\small\verb|t|} o {\small\verb|t+1|}, allora il valore di output in +\item Se {\small\verb|reset|} {\small\verb|T|} al tempo + {\small\verb|t|} o {\small\verb|t+1|}, allora il valore di output in {\small\verb|out|} al tempo {\small\verb|t+1|} {\small\verb|T|}, altrimenti uguale al valore di input al tempo {\small\verb|t|} su {\small\verb|inp|}. @@ -738,14 +738,14 @@ \subsection{Esercizio 1} \end{verbatim} \end{hol} -\noindent Si noti che questa specifica solo parziale; non specifica +\noindent Si noti che questa specifica solo parziale; non specifica l'output al tempo {\small\verb|0|} nel caso non ci sia alcun azzeramento. -La soluzione all'esercizio dovrebbe essere la definizione di un predicato -{\small\verb|RESET_REG_IMP|} come una quantificazione esistenziale di una +La soluzione all'esercizio dovrebbe essere la definizione di un predicato +{\small\verb|RESET_REG_IMP|} come una quantificazione esistenziale di una congiunzione di applicazioni di {\small\verb|ONE|}, {\small\verb|NOT|}, {\small\verb|MUX|} e {\small\verb|REG|} a nomi di linea -adatti\footnote{Cio una definizione della stessa forma di +adatti\footnote{Cio una definizione della stessa forma di {\small\tt PARITY\_IMP} %BEGIN LATEX a paginae~\pageref{parity-imp}. @@ -763,20 +763,20 @@ \subsection{Esercizio 1} \subsection{Esercizio 2} \begin{enumerate} -\item Specificare formalmente un validatore di parit azzerabile che ha due input - booleani {\small\tt reset} e {\small\tt inp}, e un output booleano +\item Specificare formalmente un validatore di parit azzerabile che ha due input + booleani {\small\tt reset} e {\small\tt inp}, e un output booleano {\small\tt out} con il seguente comportamento: \begin{quote} - Il valore in {\small\tt out} {\small\tt T} se e solo se c' stato - un numero pari di input {\small\tt T} in {\small\tt inp} + Il valore in {\small\tt out} {\small\tt T} se e solo se c' stato + un numero pari di input {\small\tt T} in {\small\tt inp} dall'ultima volta che {\small\tt T} stato immesso in {\small\tt reset}. \end{quote} \item Sviluppare un'implementazione di questa specifica costruita usando {\it solo\/} i dispositivi {\small\verb|ONE|}, {\small\verb|NOT|}, - {\small\verb|MUX|} e {\small\verb|REG|} definiti nella + {\small\verb|MUX|} e {\small\verb|REG|} definiti nella Sezione~\ref{implementation}. - + \item Verificare la correttezza della tua implementazione in \HOL. \end{enumerate} diff --git a/Manual/Translations/IT/Tutorial/preface.tex b/Manual/Translations/IT/Tutorial/preface.tex index 585d96f1d6..62d58d2de0 100644 --- a/Manual/Translations/IT/Tutorial/preface.tex +++ b/Manual/Translations/IT/Tutorial/preface.tex @@ -1,7 +1,7 @@ \chapter*{Prefazione}\markboth{Prefazione}{Prefazione} \label{intro} -Questo volume contiene un tutorial sul sistema \HOL{}. E' uno di quattro +Questo volume contiene un tutorial sul sistema \HOL{}. E' uno di quattro documenti che costituiscono la documentazione per \HOL{}: \begin{myenumerate} @@ -15,19 +15,19 @@ \chapter*{Prefazione}\markboth{Prefazione}{Prefazione} \noindent Si far riferimento a questi quattro documenti con i nomi abbreviati (in maiuscoletto inclinato) dati di sopra. -Questo documento, \TUTORIAL, pensato per essere il primo letto dai nuovi -utenti di \HOL. Esso fornisce un'introduzione da auto-didatta alla struttura -e all'uso del sistema. Il tutorial pensato per dare una sensazione del -modo in cui \HOL{} utilizzato `mettendo gi le mani sul sistema', -ma non spiega in modo sistematico -tutti i principi sottostanti (questi sono spiegati da \DESCRIPTION{} -e \LOGIC{}). Dopo aver lavorato con il \TUTORIAL\ il lettore dovrebbe essere +Questo documento, \TUTORIAL, pensato per essere il primo letto dai nuovi +utenti di \HOL. Esso fornisce un'introduzione da auto-didatta alla struttura +e all'uso del sistema. Il tutorial pensato per dare una sensazione del +modo in cui \HOL{} utilizzato `mettendo gi le mani sul sistema', +ma non spiega in modo sistematico +tutti i principi sottostanti (questi sono spiegati da \DESCRIPTION{} +e \LOGIC{}). Dopo aver lavorato con il \TUTORIAL\ il lettore dovrebbe essere in una posizione tale da poter consultare gli altri documenti. \section*{Per iniziare} -Il Capitolo~\ref{install} spiega come ottenere e installare \HOL. Una volta che questo - stato fatto, il potenziale utente \HOL{} dovrebbe iniziare a familiarizzare con i +Il Capitolo~\ref{install} spiega come ottenere e installare \HOL. Una volta che questo + stato fatto, il potenziale utente \HOL{} dovrebbe iniziare a familiarizzare con i seguenti argomenti: % \begin{enumerate} @@ -39,29 +39,29 @@ \section*{Per iniziare} \end{enumerate} % I Capitoli 2 e 3 introducono questi argomenti. -Il Capitolo~\ref{chap:euclid} sviluppa poi un ampio esempio --- la dimostrazione -di Euclide dell'infinit dei numeri primi --- per illustrare come \HOL{} usato +Il Capitolo~\ref{chap:euclid} sviluppa poi un ampio esempio --- la dimostrazione +di Euclide dell'infinit dei numeri primi --- per illustrare come \HOL{} usato per dimostrare teoremi. %Chapter~\ref{proof} then describes forward and goal %directed proof in much greater detail. -Il Capitolo~\ref{parity} presenta un altro esempio pratico: la specifica -e la verifica di un semplice bit di parit sequenziale. L'intenzione -quella di ottenere due cose: (i) presentare un'altra parte completa -di lavoro con \HOL; e (ii) dare un'idea di cosa significhi usare -il sistema \HOL{} per una dimostrazione complicata. Il Capitolo~\ref{chap:combin} un -esempio pi esteso: la dimostrazione della confluenza per la logica -combinatoria. Di nuovo, l'obiettivo quello di presentare un pezzo completo di +Il Capitolo~\ref{parity} presenta un altro esempio pratico: la specifica +e la verifica di un semplice bit di parit sequenziale. L'intenzione +quella di ottenere due cose: (i) presentare un'altra parte completa +di lavoro con \HOL; e (ii) dare un'idea di cosa significhi usare +il sistema \HOL{} per una dimostrazione complicata. Il Capitolo~\ref{chap:combin} un +esempio pi esteso: la dimostrazione della confluenza per la logica +combinatoria. Di nuovo, l'obiettivo quello di presentare un pezzo completo di lavoro non banale. -Il Capitolo~\ref{chap:proof-tools} da un esempio di implementazione di -uno strumento di dimostrazione custom. Questo dimostra la programmabilit di -\HOL: il modo in cui pu essere implementata una tecnologia per risolvere -problemi specifici sulla base del kernel sottostante. Avendo a disposizione +Il Capitolo~\ref{chap:proof-tools} da un esempio di implementazione di +uno strumento di dimostrazione custom. Questo dimostra la programmabilit di +\HOL: il modo in cui pu essere implementata una tecnologia per risolvere +problemi specifici sulla base del kernel sottostante. Avendo a disposizione strumenti molto potenti, possibile creare prototipi molto rapidamente. -Il Capitolo~\ref{chap:more-examples} discute brevemente alcuni +Il Capitolo~\ref{chap:more-examples} discute brevemente alcuni degli esempi distribuiti con \holn{} nella directory \ml{examples}. %\item Chapter~\ref{tool} shows how a special purpose proof tool (a @@ -81,10 +81,10 @@ \section*{Per iniziare} \vspace{1cm} -\noindent il \TUTORIAL{} stato mantenuto breve in modo tale che i nuovi utenti di \HOL{} possano -riuscire ad andare il pi velocemente possibile. A volte alcuni dettagli sono stati semplificati. -Si raccomanda non appena un argomento nel \TUTORIAL\ stato -digerito, di studiare le parti rilevanti di +\noindent il \TUTORIAL{} stato mantenuto breve in modo tale che i nuovi utenti di \HOL{} possano +riuscire ad andare il pi velocemente possibile. A volte alcuni dettagli sono stati semplificati. +Si raccomanda non appena un argomento nel \TUTORIAL\ stato +digerito, di studiare le parti rilevanti di \DESCRIPTION\ e \REFERENCE. %%% Local Variables: diff --git a/Manual/Translations/IT/Tutorial/proof-tools.tex b/Manual/Translations/IT/Tutorial/proof-tools.tex index 40a99c0b00..1b2d35ea28 100644 --- a/Manual/Translations/IT/Tutorial/proof-tools.tex +++ b/Manual/Translations/IT/Tutorial/proof-tools.tex @@ -3,20 +3,20 @@ \chapter{Strumenti di dimostrazione: Logica Proposizionale} \newcommand{\naive}{na\"\i{}ve} -Gli utenti di \HOL{} possono creare i loro propri strumenti di dimostrazione -combinando le regole e le tattiche predefinite. La disciplina dei tipi \ML{} -assicura che solo metodi logicamente validi possono essere usati per creare valori +Gli utenti di \HOL{} possono creare i loro propri strumenti di dimostrazione +combinando le regole e le tattiche predefinite. La disciplina dei tipi \ML{} +assicura che solo metodi logicamente validi possono essere usati per creare valori di tipo \ml{thm}. In questo capitolo, descritto un esempio reale. -Sono date due implementazioni dello strumento per illustrare vari stili -di programmazione della dimostrazione. La prima implementazione quella ovvia, ma - inefficiente a causa del metodo di `forza bruta' utilizzato. La seconda -implementazione tenta di essere molto pi intelligente. -Sono anche discusse estensioni agli strumenti per permettere un'applicabilit +Sono date due implementazioni dello strumento per illustrare vari stili +di programmazione della dimostrazione. La prima implementazione quella ovvia, ma + inefficiente a causa del metodo di `forza bruta' utilizzato. La seconda +implementazione tenta di essere molto pi intelligente. +Sono anche discusse estensioni agli strumenti per permettere un'applicabilit pi generale. -Il problema da risolvere quello di decidere la verit di una formula -chiusa della logica proposizionale. Una tale formula ha la forma generale +Il problema da risolvere quello di decidere la verit di una formula +chiusa della logica proposizionale. Una tale formula ha la forma generale \[ \begin{array}{ccl} \varphi & ::= & v \;|\;\neg\varphi\;|\;\varphi @@ -26,17 +26,17 @@ \chapter{Strumenti di dimostrazione: Logica Proposizionale} \mathit{formula} &::= & \forall \vec{v}. \;\varphi \end{array} \] -dove le variabili $v$ sono tutte di tipo booleano, e dove il -quantificatore universale al livello pi esterno cattura tutte le +dove le variabili $v$ sono tutte di tipo booleano, e dove il +quantificatore universale al livello pi esterno cattura tutte le variabili libere. \section{Metodo 1: Tabelle di verit} \setcounter{sessioncount}{0} -Il primo metodo che deve essere implementato il metodo di forza bruta di tentare -tutte le combinazioni booleane possibili. L'unico vero vantaggio di questo approccio - che eccezionalmente semplice da implementare. Prima dimostreremo +Il primo metodo che deve essere implementato il metodo di forza bruta di tentare +tutte le combinazioni booleane possibili. L'unico vero vantaggio di questo approccio + che eccezionalmente semplice da implementare. Prima dimostreremo il teorema motivante: \begin{hol} \begin{verbatim} @@ -53,8 +53,8 @@ \chapter{Strumenti di dimostrazione: Logica Proposizionale} \[ P(\top) \land P(\bot) \Rightarrow P(v) \] -per una variabile booleana arbitraria $v$. Dopo lo splitting dei casi su $v$, -le assunzioni sono poi sufficienti a mostrare il goal. (Questo teorema +per una variabile booleana arbitraria $v$. Dopo lo splitting dei casi su $v$, +le assunzioni sono poi sufficienti a mostrare il goal. (Questo teorema di fatto gi dimostrato nella teoria \theoryimp{bool}.) Il prossimo, e ultimo passo, di riscrivere con questo teorema: @@ -92,26 +92,26 @@ \chapter{Strumenti di dimostrazione: Logica Proposizionale} \end{verbatim} \end{session} -Questo un algoritmo terribile per risolvere questo problema. La funzione\linebreak -\ml{tautLib.TAUT\_CONV} incorporata nel sistema risolve il problema di sopra -molto pi velocemente. L'unico merito -reale in questa soluzione che richiede di scrivere una sola riga. Questa -un'illustrazione generale del fatto che gli strumenti di alto livello di \HOL{}, -in particolare il semplificatore, possono fornire prototipi veloci per una variet +Questo un algoritmo terribile per risolvere questo problema. La funzione\linebreak +\ml{tautLib.TAUT\_CONV} incorporata nel sistema risolve il problema di sopra +molto pi velocemente. L'unico merito +reale in questa soluzione che richiede di scrivere una sola riga. Questa +un'illustrazione generale del fatto che gli strumenti di alto livello di \HOL{}, +in particolare il semplificatore, possono fornire prototipi veloci per una variet di compiti di dimostrazione. \section{Metodo 2: l'Algoritmo DPLL} -Il metodo Davis-Putnam-Loveland-Logemann~\cite{DPLL-paper} per +Il metodo Davis-Putnam-Loveland-Logemann~\cite{DPLL-paper} per decidere la soddisfacibilit di formule proposizionali in CNF -(Conjunctive Normal form) una tecnica potente, ancora oggi usata nei -risolutori dell'ultima generazione. Se eliminiamo i quantificatori universali -dalle nostre formule di input, il nostro compito pu essere visto come determinare -la validit di una formula proposizionale. Testare la negazione di una tale -formula per la soddisfacibilit un test per la validit: se la negazione -della formula soddisfacibile, allora non valida (l'assegnazione -che soddisfa render l'originale falsa): se la negazione della formula -insoddisfacibile, allora la formula valida (nessuna assegnazione la pu rendere +(Conjunctive Normal form) una tecnica potente, ancora oggi usata nei +risolutori dell'ultima generazione. Se eliminiamo i quantificatori universali +dalle nostre formule di input, il nostro compito pu essere visto come determinare +la validit di una formula proposizionale. Testare la negazione di una tale +formula per la soddisfacibilit un test per la validit: se la negazione +della formula soddisfacibile, allora non valida (l'assegnazione +che soddisfa render l'originale falsa): se la negazione della formula +insoddisfacibile, allora la formula valida (nessuna assegnazione la pu rendere falsa). \smallskip @@ -120,14 +120,14 @@ \section{Metodo 2: l'Algoritmo DPLL} \subsection*{Preliminari} -Per iniziare, assumiamo che abbiamo gi del codice per convertire formule -arbitrarie in CNF{}, e per poi decidere la soddisfacibilit di queste -formule. Assumiamo inoltre che se l'input all'ultima procedura +Per iniziare, assumiamo che abbiamo gi del codice per convertire formule +arbitrarie in CNF{}, e per poi decidere la soddisfacibilit di queste +formule. Assumiamo inoltre che se l'input all'ultima procedura insoddisfacibile, allora restituir un teorema della forma \[ \vdash \varphi = \holtxt{F} \] -o se soddisfacibile, allora restituir un'assegnazione che soddisfa, -un mapping da variabili a booleani. Questo mapping sar una funzione da +o se soddisfacibile, allora restituir un'assegnazione che soddisfa, +un mapping da variabili a booleani. Questo mapping sar una funzione da variabili \HOL{} a uno dei termini \HOL{} \holtxt{T} o \holtxt{F}. Cos, assumeremo \begin{hol} @@ -137,26 +137,26 @@ \subsection*{Preliminari} val DPLL : term -> result \end{verbatim} \end{hol} -(Il teorema restituito da \ml{toCNF} uguaglier il termine di input a +(Il teorema restituito da \ml{toCNF} uguaglier il termine di input a un altro in CNF{}.) \smallskip \noindent -Prima di guardare all'implementazione di queste funzioni, dovremo +Prima di guardare all'implementazione di queste funzioni, dovremo considerare \begin{itemize} \item come trasformare i nostri input per adattarsi alla funzione; e -\item come usare gli output dalle funzioni per produrre i nostri risultati +\item come usare gli output dalle funzioni per produrre i nostri risultati desiderati \end{itemize} -Stiamo assumendo che il nostro input sia una formula quantificata universalmente. -Entrambe le procedure CNF e DPLL si aspettano formule senza quantificatori. -Vogliamo anche passare a queste procedure la negazione della formula -originaria. Entrambe la manipolazioni di termini richieste si possono fare -con le funzioni che si trovano nella struttura \ml{boolSyntax}. (in generale, -le teorie importanti (come \theoryimp{bool}) sono accompangnate da -moduli \ml{Syntax} che contengono funzioni per manipolare le +Stiamo assumendo che il nostro input sia una formula quantificata universalmente. +Entrambe le procedure CNF e DPLL si aspettano formule senza quantificatori. +Vogliamo anche passare a queste procedure la negazione della formula +originaria. Entrambe la manipolazioni di termini richieste si possono fare +con le funzioni che si trovano nella struttura \ml{boolSyntax}. (in generale, +le teorie importanti (come \theoryimp{bool}) sono accompangnate da +moduli \ml{Syntax} che contengono funzioni per manipolare le forme di termini associate con quella teoria.) In questo caso abbiamo bisogno delle funzioni @@ -166,27 +166,27 @@ \subsection*{Preliminari} mk_neg : term -> term \end{verbatim} \end{hol} -La funzione \ml{strip\_forall} spoglia un termine di tutte le sue quantificazioni -universali pi esterne, restituendo la lista delle variabili spogliate -e il corpo della quantificazione. La funzione \ml{mk\_neg} prende un -termine di tipo \holtxt{bool} e restituisce il termine corrispondente alla sua +La funzione \ml{strip\_forall} spoglia un termine di tutte le sue quantificazioni +universali pi esterne, restituendo la lista delle variabili spogliate +e il corpo della quantificazione. La funzione \ml{mk\_neg} prende un +termine di tipo \holtxt{bool} e restituisce il termine corrispondente alla sua negazione. -Usando queste funzioni, facile vedere come saremo in grado di prendere -$\forall\vec{v}.\;\varphi$ come input, e passare il termine $\neg\varphi$ -alla funzione \ml{toCNF}. Una domanda pi significativa come -usare i risultati di queste chiamate. La chiamata a \ml{toCNF} restituir un +Usando queste funzioni, facile vedere come saremo in grado di prendere +$\forall\vec{v}.\;\varphi$ come input, e passare il termine $\neg\varphi$ +alla funzione \ml{toCNF}. Una domanda pi significativa come +usare i risultati di queste chiamate. La chiamata a \ml{toCNF} restituir un teorema \[ \vdash \neg\varphi = \varphi' \] -La formula $\varphi'$ ci che passeremo poi a \ml{DPLL}. (Possiamo -estrarla usando le funzioni \ml{concl} e \ml{rhs}.) Se -\ml{DPLL} restituisce il teorema $\vdash \varphi' = \holtxt{F}$, -un'applicazione di \ml{TRANS} a questo e al teorema mostrato di sopra -deriver la formula $\vdash \neg\varphi = F$. Al fine di derivare il -risultato finale, avremo bisogno di trasformare questo in $\vdash\varphi$. Questo -si ottiene meglio fornendo un teorema fatto su misura che incorpora l'uguaglianza (non +La formula $\varphi'$ ci che passeremo poi a \ml{DPLL}. (Possiamo +estrarla usando le funzioni \ml{concl} e \ml{rhs}.) Se +\ml{DPLL} restituisce il teorema $\vdash \varphi' = \holtxt{F}$, +un'applicazione di \ml{TRANS} a questo e al teorema mostrato di sopra +deriver la formula $\vdash \neg\varphi = F$. Al fine di derivare il +risultato finale, avremo bisogno di trasformare questo in $\vdash\varphi$. Questo +si ottiene meglio fornendo un teorema fatto su misura che incorpora l'uguaglianza (non ce n' gi uno simile nel sistema): \begin{hol} \begin{verbatim} @@ -203,28 +203,28 @@ \subsection*{Preliminari} } } \] -L'altra possibilit che \ml{DPLL} restituir un'assegnazione che soddisfa -dimostrando che $\varphi'$. Se questo +L'altra possibilit che \ml{DPLL} restituir un'assegnazione che soddisfa +dimostrando che $\varphi'$. Se questo il caso, vogliamo mostrare che $\forall\vec{v}.\;\varphi$ falsa. -Possiamo fare questo assumendo questa formula, e specializzando le -variabili quantificate universalmente in linea con il mapping fornito. In +Possiamo fare questo assumendo questa formula, e specializzando le +variabili quantificate universalmente in linea con il mapping fornito. In questo modo, sar possibile produrre il teorema \[ \forall \vec{v}.\;\varphi \vdash \varphi[\vec{v} := \mbox{\emph{satisfying assignment}}] \] -Poich non ci sono variabili libere in $\forall\vec{v}.\;\varphi$, la -sostituzione produrr una formula booleana completamente ground. Questa -si riscriver direttamente a \holtxt{F} (se l'assegnazione -rende $\neg\varphi$ vero, deve rendere $\varphi$ falso). Trasformare -$\phi\vdash \holtxt{F}$ in $\vdash \phi = \holtxt{F}$ questione di -richiamare \ml{DISCH} e poi di riscrivere con il teorema incorporato +Poich non ci sono variabili libere in $\forall\vec{v}.\;\varphi$, la +sostituzione produrr una formula booleana completamente ground. Questa +si riscriver direttamente a \holtxt{F} (se l'assegnazione +rende $\neg\varphi$ vero, deve rendere $\varphi$ falso). Trasformare +$\phi\vdash \holtxt{F}$ in $\vdash \phi = \holtxt{F}$ questione di +richiamare \ml{DISCH} e poi di riscrivere con il teorema incorporato \ml{IMP\_F\_EQ\_F}: \[ \vdash \forall t.\;t \Rightarrow \holtxt{F} = (t = \holtxt{F}) \] -Mettendo tutto ci che sta di sopra insieme, possiamo scrivere la nostra funzione wrapper, -che chiameremo \ml{DPLL\_UNIV}, con il suffisso \ml{UNIV} +Mettendo tutto ci che sta di sopra insieme, possiamo scrivere la nostra funzione wrapper, +che chiameremo \ml{DPLL\_UNIV}, con il suffisso \ml{UNIV} che ci ricorda che l'input deve essere quantificato universalmente. \begin{hol} \begin{verbatim} @@ -252,29 +252,29 @@ \subsection*{Preliminari} \end{verbatim} \end{hol} -La funzione ausiliaria \ml{spec} che usata nel secondo caso -si basa sul fatto che \ml{dest\_forall} sollever un'eccezione -\ml{HOL\_ERR} se il termine a cui applicata non quantificato universalmente. -Quando l'argomento di \ml{spec} non quantificato universalmente, questo significa -che la ricorsione conclusa, e tutte le variabili universali della -formula originaria sono state specializzate. Quindi la formula risultante -pu essere riscritta a falso (le riscritture incorporate in \ml{REWRITE\_RULE} +La funzione ausiliaria \ml{spec} che usata nel secondo caso +si basa sul fatto che \ml{dest\_forall} sollever un'eccezione +\ml{HOL\_ERR} se il termine a cui applicata non quantificato universalmente. +Quando l'argomento di \ml{spec} non quantificato universalmente, questo significa +che la ricorsione conclusa, e tutte le variabili universali della +formula originaria sono state specializzate. Quindi la formula risultante +pu essere riscritta a falso (le riscritture incorporate in \ml{REWRITE\_RULE} gestiscono tutti i casi necessari). -Anche la funzione \ml{DPLL\_UNIV} usa \ml{REWR\_CONV} in due posti. -La funzione \ml{REWR\_CONV} applica una singola riscrittura (al primo ordine) al -livello principale di un termine. Questi usi di \ml{REWR\_CONV} sono fatti con -chiamate alla funzione \ml{CONV\_RULE}. Questa esegue [lifts ndt] un conversione $c$ (una -funzione che prende un termine $t$ e che produce un teorema $\vdash t = t'$), +Anche la funzione \ml{DPLL\_UNIV} usa \ml{REWR\_CONV} in due posti. +La funzione \ml{REWR\_CONV} applica una singola riscrittura (al primo ordine) al +livello principale di un termine. Questi usi di \ml{REWR\_CONV} sono fatti con +chiamate alla funzione \ml{CONV\_RULE}. Questa esegue [lifts ndt] un conversione $c$ (una +funzione che prende un termine $t$ e che produce un teorema $\vdash t = t'$), cos che $\ml{CONV\_RULE}\;c$ porta il teorema $\vdash t$ a $\vdash t'$. \subsection{Conversione in Forma Normale Congiuntiva} \label{sec:conv-conj-norm} -Una formula in Forma Normale Congiuntiva una congiunzione di disgiunzioni -di letterali (cio o variabili, o variabili negate). E' possibile -convertire formule della forma che ci attendiamo in CNF semplicemente +Una formula in Forma Normale Congiuntiva una congiunzione di disgiunzioni +di letterali (cio o variabili, o variabili negate). E' possibile +convertire formule della forma che ci attendiamo in CNF semplicemente riscrivendo con il seguenti teoremi \begin{eqnarray*} \neg (\phi \land \psi) &=& \neg\phi \lor \neg\psi\\ @@ -286,14 +286,14 @@ \subsection{Conversione in Forma Normale Congiuntiva} (\phi = \psi) &=& (\phi \Rightarrow \psi) \land (\psi \Rightarrow \phi) \end{eqnarray*} -Sfortunatamente, usare questi teoremi come riscritture pu risultare in un -incremento esponenziale nella dimensione di una formula. (Si consideri di usarli -per convertire un input in Forma Normale Disgiuntiva, una disgiunzione +Sfortunatamente, usare questi teoremi come riscritture pu risultare in un +incremento esponenziale nella dimensione di una formula. (Si consideri di usarli +per convertire un input in Forma Normale Disgiuntiva, una disgiunzione di congiunzioni di letterali, in CNF{}.) -Un approccio migliore di convertire in ci che conosciuta come una ``CNF -definizionale''. \HOL{} include funzioni per fare questo nella structure -\ml{defCNF}. Sfortunatamente, questo approccio aggiunge quantificatori, esistenziali, +Un approccio migliore di convertire in ci che conosciuta come una ``CNF +definizionale''. \HOL{} include funzioni per fare questo nella structure +\ml{defCNF}. Sfortunatamente, questo approccio aggiunge quantificatori, esistenziali, extra alla formula. Per esempio \begin{session} \begin{verbatim} @@ -303,20 +303,20 @@ \subsection{Conversione in Forma Normale Congiuntiva} ?x. (x \/ ~q \/ ~r) /\ (r \/ ~x) /\ (q \/ ~x) /\ (p \/ x) : thm \end{verbatim} \end{session} -Sotto la \holtxt{x} legata esistenzialmente, il codice ha prodotto una -formula in CNF{}. Con esempio piccolo come questo, la formula di fatto -pi grande di quella prodotto dalla traduzione ingenua, ma con esempi -pi realistici, la differenza diventa velocemente significativa. L'ultimo -esempio usato con \ml{tautDP} 20 volte pi grande quando tradotto -ingenuamente di quando usando \ml{defCNF}, e la traduzione richiede 150 +Sotto la \holtxt{x} legata esistenzialmente, il codice ha prodotto una +formula in CNF{}. Con esempio piccolo come questo, la formula di fatto +pi grande di quella prodotto dalla traduzione ingenua, ma con esempi +pi realistici, la differenza diventa velocemente significativa. L'ultimo +esempio usato con \ml{tautDP} 20 volte pi grande quando tradotto +ingenuamente di quando usando \ml{defCNF}, e la traduzione richiede 150 volte pi tempo per essere eseguita. -Ma cosa facciamo di queste variabili quantificate esistenzialmente extra? Di fatto, -possiamo ignorare la quantificazione quando chiamiamo la procedura core DPLL. -Se passiamo il corpo non quantificato a DPLL, otteniamo indietro o un -verdetto di insoddisfacibilit della forma $\vdash \varphi' = \holtxt{F}$, o una -assegnazione per tutte le variabili libere che soddisfa. Se capita la -seconda, la stessa assegnazione soddisfer anche +Ma cosa facciamo di queste variabili quantificate esistenzialmente extra? Di fatto, +possiamo ignorare la quantificazione quando chiamiamo la procedura core DPLL. +Se passiamo il corpo non quantificato a DPLL, otteniamo indietro o un +verdetto di insoddisfacibilit della forma $\vdash \varphi' = \holtxt{F}$, o una +assegnazione per tutte le variabili libere che soddisfa. Se capita la +seconda, la stessa assegnazione soddisfer anche l'originale. Se capita la prima, eseguiremo la seguente dimostrazione \[ \infer{\vdash (\exists \vec{x}.\;\varphi') = \holtxt{F}}{ @@ -329,14 +329,14 @@ \subsection{Conversione in Forma Normale Congiuntiva} } } \] -producendo un teorema della forma attesa dalla nostra funzione +producendo un teorema della forma attesa dalla nostra funzione \ml{wrapper}. -Di fatto, c' una funzione alternativa nell'API \ml{defCNF} che -useremo preferendola a \ml{DEF\_CNF\_CONV}. Il problema con -\ml{DEF\_CNF\_CONV} che pu produrre una grande quantificazione, -che coinvolge molte variabili. Useremo piuttosto -\ml{DEF\_CNF\_VECTOR\_CONV}. Al posto di un output della forma +Di fatto, c' una funzione alternativa nell'API \ml{defCNF} che +useremo preferendola a \ml{DEF\_CNF\_CONV}. Il problema con +\ml{DEF\_CNF\_CONV} che pu produrre una grande quantificazione, +che coinvolge molte variabili. Useremo piuttosto +\ml{DEF\_CNF\_VECTOR\_CONV}. Al posto di un output della forma \[ \vdash \varphi = (\exists \vec{x}.\; \varphi') \] @@ -345,22 +345,22 @@ \subsection{Conversione in Forma Normale Congiuntiva} \vdash \varphi = (\exists (v : \textsf{num} \rightarrow \textsf{bool}).\; \varphi') \] -dove le variabili individuali $x_i$ della prima formula sono sostituite -da chiamate alla funzione $v$ $v(i)$, e c' una sola variabile -quantificata, $v$. Questa variabile non influenzer l'operazione della -dimostrazione abbozzata di sopra. E fino a quando non richiediamo che i letterali siano -variabili o le loro negazioni, ma permettiamo anche che siano termini della -forma $v(i)$ e $\neg v(i)$, allora anche l'azione della procedura +dove le variabili individuali $x_i$ della prima formula sono sostituite +da chiamate alla funzione $v$ $v(i)$, e c' una sola variabile +quantificata, $v$. Questa variabile non influenzer l'operazione della +dimostrazione abbozzata di sopra. E fino a quando non richiediamo che i letterali siano +variabili o le loro negazioni, ma permettiamo anche che siano termini della +forma $v(i)$ e $\neg v(i)$, allora anche l'azione della procedura DPLL sulla formula $\varphi'$ non sar influenzata. -Sfortunatamente per uniformit, in casi semplici, le funzioni di conversione -a una CNF definizionale possono risultate in nessuna quantificazione -esistenziale del tutto. Questo rende la nostra implementazione di \ml{DPLL} -in qualche modo pi complicata. Calcoliamo una variabile \ml{body} che -sar passata in cima alla funzione \ml{CoreDPLL}, esattamente come una -funzione \ml{transform} che trasformer un risultato di insoddisfacibilit -in qualcosa della forma desiderata. Se il risultato della conversione a -CNF produce una quantificazione esistenziale, usiamo la dimostrazione abbozzata +Sfortunatamente per uniformit, in casi semplici, le funzioni di conversione +a una CNF definizionale possono risultate in nessuna quantificazione +esistenziale del tutto. Questo rende la nostra implementazione di \ml{DPLL} +in qualche modo pi complicata. Calcoliamo una variabile \ml{body} che +sar passata in cima alla funzione \ml{CoreDPLL}, esattamente come una +funzione \ml{transform} che trasformer un risultato di insoddisfacibilit +in qualcosa della forma desiderata. Se il risultato della conversione a +CNF produce una quantificazione esistenziale, usiamo la dimostrazione abbozzata di sopra. Altrimenti, la trasformazione pu essere la funzione identit, \ml{I}: \begin{hol} @@ -385,12 +385,12 @@ \subsection{Conversione in Forma Normale Congiuntiva} end \end{verbatim} \end{hol} -dove dobbiamo ancora implementare la procedura DPLL core (chiamata -\ml{CoreDPLL} di sopra). Il codice di sopra usa \ml{REWR\_CONV} con il -teorema \ml{IMP\_F\_EQ\_F} per influenzare due delle trasformazioni -della dimostrazione. La funzione \ml{GSYM} usata per invertire -le uguaglianza di primo livello di un teorema. Infine, -la conversione \ml{FORALL\_IMP\_CONV} prende un termine della forma +dove dobbiamo ancora implementare la procedura DPLL core (chiamata +\ml{CoreDPLL} di sopra). Il codice di sopra usa \ml{REWR\_CONV} con il +teorema \ml{IMP\_F\_EQ\_F} per influenzare due delle trasformazioni +della dimostrazione. La funzione \ml{GSYM} usata per invertire +le uguaglianza di primo livello di un teorema. Infine, +la conversione \ml{FORALL\_IMP\_CONV} prende un termine della forma \[ \forall x.\;P(x) \Rightarrow Q \] @@ -406,47 +406,47 @@ \subsection{Conversione in Forma Normale Congiuntiva} \subsection{La Procedura DPLL Core} \label{sec:dpll-procedure} -La procedura pu essere vista come una piccola variazione sulla tecnica -di base ``tabelle di verit'' che abbiamo gi visto. Come con quella +La procedura pu essere vista come una piccola variazione sulla tecnica +di base ``tabelle di verit'' che abbiamo gi visto. Come con quella procedura, l'operazione core un case-split su una variabile booleana. -Ci sono tuttavia due differenze significative: DPLL pu essere vista come -una ricerca per un'assegnazione soddisfacente, cos che se selezionando una variabile -in modo da avere un particolare valore risulta in un'assegnazione soddisfacente, non abbiamo -bisogno di controllare anche cosa accade se alla stessa variabile dato il -valore di verit opposto. In secondo luogo, DPLL fa una certa attenzione a selezionare delle variabili -opportune su cui fare lo split. In particolare usata la \emph{unit propagation} -per eliminare variabili che non causeranno ramificazioni nello +Ci sono tuttavia due differenze significative: DPLL pu essere vista come +una ricerca per un'assegnazione soddisfacente, cos che se selezionando una variabile +in modo da avere un particolare valore risulta in un'assegnazione soddisfacente, non abbiamo +bisogno di controllare anche cosa accade se alla stessa variabile dato il +valore di verit opposto. In secondo luogo, DPLL fa una certa attenzione a selezionare delle variabili +opportune su cui fare lo split. In particolare usata la \emph{unit propagation} +per eliminare variabili che non causeranno ramificazioni nello spazio di ricerca. -La nostra implementazione della procedura DPLL core una funzione che prende -un termine e restituisce un valore del tipo \ml{result}: o un teorema -che uguaglia il termine originario a falso, o un'assegnazione soddisfacente (nella -forma di una funzione da termini a termini). Mentre la ricerca DPLL per -un'assegnazione soddisfacente procede, costruita in modo incrementale -un'assegnazione. Questo suggerisce che il nucleo ricorsivo della nostra funzione -avr bisogno di prendere un termine (la formula corrente) e un contesto (l'assegnazione -corrente) come parametri. L'assegnazione pu essere rappresentata in modo +La nostra implementazione della procedura DPLL core una funzione che prende +un termine e restituisce un valore del tipo \ml{result}: o un teorema +che uguaglia il termine originario a falso, o un'assegnazione soddisfacente (nella +forma di una funzione da termini a termini). Mentre la ricerca DPLL per +un'assegnazione soddisfacente procede, costruita in modo incrementale +un'assegnazione. Questo suggerisce che il nucleo ricorsivo della nostra funzione +avr bisogno di prendere un termine (la formula corrente) e un contesto (l'assegnazione +corrente) come parametri. L'assegnazione pu essere rappresentata in modo naturale come un insieme di equazioni, dove ciascuna equazione o either $v = \holtxt{T}$ o $v = \holtxt{F}$. -Questo suggerisce che una rappresentazione per la dichiarazione del nostro programma -un teorema: le ipotesi rappresenteranno l'assegnazione, e la conclusione -pu essere la formula corrente. Naturalmente, i teoremi \HOL{} -non possono semplicemente essere desiderati esistere. In questo caso, possiamo rendere -ogni cosa valida assumendo anche la formula iniziale. Cos, quando -iniziamo la nostra dichiarazione iniziale sar $\phi\vdash\phi$. Dopo aver effettuato lo splitting sulla -$v$, genereremo due nuove dichiarazioni +Questo suggerisce che una rappresentazione per la dichiarazione del nostro programma +un teorema: le ipotesi rappresenteranno l'assegnazione, e la conclusione +pu essere la formula corrente. Naturalmente, i teoremi \HOL{} +non possono semplicemente essere desiderati esistere. In questo caso, possiamo rendere +ogni cosa valida assumendo anche la formula iniziale. Cos, quando +iniziamo la nostra dichiarazione iniziale sar $\phi\vdash\phi$. Dopo aver effettuato lo splitting sulla +$v$, genereremo due nuove dichiarazioni $\phi,(v\!=\!\holtxt{T})\vdash \phi_1$, e -$\phi,(v\!=\!\holtxt{F})\vdash \phi_2$, dove i $\phi_i$ sono il -risultato di semplificare $\phi$ sotto l'assunzione aggiuntiva +$\phi,(v\!=\!\holtxt{F})\vdash \phi_2$, dove i $\phi_i$ sono il +risultato di semplificare $\phi$ sotto l'assunzione aggiuntiva che vincola $v$. -Il modo pi semplice per aggiungere un'assunzione a un teorema usare la -regola \ml{ADD\_ASSUM}. Ma in questa situazione, vogliamo anche -semplificare la conclusione del teorema con la stessa assunzione. Questo -significa che sar sufficiente riscrivere con il teorema -$\psi\vdash\psi$, dove $\psi$ la nuova assunzione. L'azione di -riscrivere con un tale teorema far apparire la nuova assunzione +Il modo pi semplice per aggiungere un'assunzione a un teorema usare la +regola \ml{ADD\_ASSUM}. Ma in questa situazione, vogliamo anche +semplificare la conclusione del teorema con la stessa assunzione. Questo +significa che sar sufficiente riscrivere con il teorema +$\psi\vdash\psi$, dove $\psi$ la nuova assunzione. L'azione di +riscrivere con un tale teorema far apparire la nuova assunzione tra le assunzioni del risultato. La funzione \ml{casesplit} cos: @@ -461,12 +461,12 @@ \subsection{La Procedura DPLL Core} \end{verbatim} \end{hol} -Un case split pu risultare in una formula che stata riscritta fino al -vero o al falso. Questi sono i casi base della ricorsione. Se la -formula stata riscritta a vero, allora abbiamo trovato un'assegnazione -soddisfacente, una che ora archiviata per noi nelle ipotesi del -teorema stesso. La seguente funzione \ml{mk\_satmap}, estrae -quelle ipotesi in una map finita, e poi restituisce la funzione +Un case split pu risultare in una formula che stata riscritta fino al +vero o al falso. Questi sono i casi base della ricorsione. Se la +formula stata riscritta a vero, allora abbiamo trovato un'assegnazione +soddisfacente, una che ora archiviata per noi nelle ipotesi del +teorema stesso. La seguente funzione \ml{mk\_satmap}, estrae +quelle ipotesi in una map finita, e poi restituisce la funzione di lookup per quella map finita. \begin{hol} \begin{verbatim} @@ -484,31 +484,31 @@ \subsection{La Procedura DPLL Core} end \end{verbatim} \end{hol} -La funzione \ml{foldthis} di sopra aggiunge le equazioni che sono archiviate come -ipotesi nella map finita. La gestione delle eccezione in -\ml{foldthis} necessario perch una delle ipotesi sar la -formula originaria. La gestione delle eccezioni nella funzione che cerca -i binding delle variabili necessaria perch una formula pu essere ridotta a -vero senza che tutte le variabili siano state assegnate a un valore qualsiasi, cos +La funzione \ml{foldthis} di sopra aggiunge le equazioni che sono archiviate come +ipotesi nella map finita. La gestione delle eccezione in +\ml{foldthis} necessario perch una delle ipotesi sar la +formula originaria. La gestione delle eccezioni nella funzione che cerca +i binding delle variabili necessaria perch una formula pu essere ridotta a +vero senza che tutte le variabili siano state assegnate a un valore qualsiasi, cos mappiamo in modo arbitrario tali variabili a \holtxt{T}. -Se la formula stata riscritta a falso, allora possiamo semplicemente restituire -questo teorema direttamente. Un tale teorema non del tutto nella forma giusta -per il chiamante esterno, che si aspetta un'equazione, cos se il -risultato finale della forma $\phi\vdash \holtxt{F}$, dovremo +Se la formula stata riscritta a falso, allora possiamo semplicemente restituire +questo teorema direttamente. Un tale teorema non del tutto nella forma giusta +per il chiamante esterno, che si aspetta un'equazione, cos se il +risultato finale della forma $\phi\vdash \holtxt{F}$, dovremo trasformare questo in $\vdash \phi = \holtxt{F}$. -La domanda successiva da affrontare cosa fare con i risultati delle -chiamate ricorsive. Se un case split restituisce un'assegnazione soddisfacente questa -pu essere restituita senza modifiche. Ma se una chiamata ricorsiva restituisce un teorema -che uguaglia l'input a falso, c' bisogno di fare di pi. Se questa la -prima chiamata, allora necessario controllare l'altro ramo. Se anche questo +La domanda successiva da affrontare cosa fare con i risultati delle +chiamate ricorsive. Se un case split restituisce un'assegnazione soddisfacente questa +pu essere restituita senza modifiche. Ma se una chiamata ricorsiva restituisce un teorema +che uguaglia l'input a falso, c' bisogno di fare di pi. Se questa la +prima chiamata, allora necessario controllare l'altro ramo. Se anche questo restituisce che il teorema insoddisfacibile, allora abbiamo due teoremi. \[ \phi_0,\Delta,(v\!=\!\holtxt{T})\vdash \holtxt{F} \qquad \phi_0,\Delta,(v\!=\!\holtxt{F})\vdash \holtxt{F} -\] dove $\phi_0$ la formula originaria, $\Delta$ il resto -dell'assegnazione corrente, e $v$ la variabile su cui stato appena eseguito +\] dove $\phi_0$ la formula originaria, $\Delta$ il resto +dell'assegnazione corrente, e $v$ la variabile su cui stato appena eseguito uno split. Per trasformare questi due teoremi nel desiderato \[ \phi_0,\Delta\vdash \holtxt{F} @@ -526,7 +526,7 @@ \subsection{La Procedura DPLL Core} \vdash \forall t.\;(t = \holtxt{T}) \lor (t = \holtxt{F}) \] -Possiamo mettere insieme questi frammenti e scrivere la funzione \ml{CoreDPLL} +Possiamo mettere insieme questi frammenti e scrivere la funzione \ml{CoreDPLL} di alto livello, nella Figura~\ref{fig:coredpll}. \begin{figure}[htbp] \begin{holboxed} @@ -567,10 +567,10 @@ \subsection{La Procedura DPLL Core} \end{figure} -Tutto ci che rimane da fare capire su quale variabile effettuare -il case split. Le variabili pi importanti su cui effettuare lo split sono quelle -che appaiono in quelle che sono chiamate ``unit clauses'', clausole che contengono -solo un letterale. Se c' una unit clause in una formula allora +Tutto ci che rimane da fare capire su quale variabile effettuare +il case split. Le variabili pi importanti su cui effettuare lo split sono quelle +che appaiono in quelle che sono chiamate ``unit clauses'', clausole che contengono +solo un letterale. Se c' una unit clause in una formula allora della forma \[ \phi \land v \land \phi' @@ -579,17 +579,17 @@ \subsection{La Procedura DPLL Core} \[ \phi \land \neg v \land \phi' \] -In entrambe le situazioni, effettuare lo split su $v$ risulter sempre in un ramo -che valuta direttamente a falso. Cos eliminiamo una variabile -senza accrescere la dimensione del problema. Il processo di -eliminare clausole unitarie di solito chiamato ``unit propagation''. -La unit propagation di solito non pensata come un'operazione +In entrambe le situazioni, effettuare lo split su $v$ risulter sempre in un ramo +che valuta direttamente a falso. Cos eliminiamo una variabile +senza accrescere la dimensione del problema. Il processo di +eliminare clausole unitarie di solito chiamato ``unit propagation''. +La unit propagation di solito non pensata come un'operazione di case splitting, ma eseguirla in questo modo render il nostro codice pi semplice. -Se una formula non include una clausola unitaria, allora la scelta della prossima -variabile su cui eseguire lo split molto pi di una magia nera. Qui -implementeremo una scelta molto semplice: per eseguire lo split sulla variabile che occorre -pi di frequente. La nostra funzione \ml{find\_splitting\_var} prende una formula +Se una formula non include una clausola unitaria, allora la scelta della prossima +variabile su cui eseguire lo split molto pi di una magia nera. Qui +implementeremo una scelta molto semplice: per eseguire lo split sulla variabile che occorre +pi di frequente. La nostra funzione \ml{find\_splitting\_var} prende una formula e restituisce la variabile su cui eseguire lo split. \begin{hol} \begin{verbatim} @@ -607,11 +607,11 @@ \subsection{La Procedura DPLL Core} end \end{verbatim} \end{hol} -Questa funzione lavora passando una lista di clausole alla funzione -pi interna \ml{recurse}. Questa spoglia ciascuna clausola una alla volta. Se una -clausola ha un solo disgiunto una clausola unitaria e la variabile pu -essere restituita direttamente. Altrimenti, le variabili nelle clausole sono -contate e aggiunte da \ml{count\_vars} alla map che si accumula, e la +Questa funzione lavora passando una lista di clausole alla funzione +pi interna \ml{recurse}. Questa spoglia ciascuna clausola una alla volta. Se una +clausola ha un solo disgiunto una clausola unitaria e la variabile pu +essere restituita direttamente. Altrimenti, le variabili nelle clausole sono +contate e aggiunte da \ml{count\_vars} alla map che si accumula, e la ricorsione pu continuare. La funzione \ml{count\_vars} ha la seguente implementazione: @@ -630,9 +630,9 @@ \subsection{La Procedura DPLL Core} \end{verbatim} \end{hol} -L'uso di un albero binario per archiviare dati variabili rende efficiente -aggiornare i dati mentre sono raccolti. Estrarre la variabile -con il conteggio pi grande poi una scansione lineare dell'albero, che possiamo +L'uso di un albero binario per archiviare dati variabili rende efficiente +aggiornare i dati mentre sono raccolti. Estrarre la variabile +con il conteggio pi grande poi una scansione lineare dell'albero, che possiamo fare con la funzione \ml{foldl}: \begin{hol} \begin{verbatim} @@ -647,10 +647,10 @@ \subsection{La Procedura DPLL Core} \subsection{Performance} \label{sec:dpll-performance} -Quando vengono dati input un p oltre quelli chiaramente banali, la funzione -che abbiamo scritto (al livello alto, \ml{DPLL\_UNIV}) ha delle performance considerevolmente -migliori rispetto all'implementazione con le tavole di verit. Per esempio, la -generalizzazione del seguente termine, con 29 variabili, richiede a +Quando vengono dati input un p oltre quelli chiaramente banali, la funzione +che abbiamo scritto (al livello alto, \ml{DPLL\_UNIV}) ha delle performance considerevolmente +migliori rispetto all'implementazione con le tavole di verit. Per esempio, la +generalizzazione del seguente termine, con 29 variabili, richiede a \ml{wrapper} tre secondi e mezzo per essere dimostrata come tautologia: \begin{hol} \begin{verbatim} @@ -681,21 +681,21 @@ \subsection{Performance} \section{Estendere l'Applicabilit della nostra Procedura} \label{sec:dpll-applicability-extension} -La funzione \ml{DPLL\_UNIV} richiede che il suo input sia quantificato -universalmente, con tutte le variabili libere legate, e che ciascun letterale sia -una variabile o la negazione di una variabile. Questo rende \ml{DPLL\_UNIV} -poco facile da usare quando viene ad essere usata come parte della dimostrazione di -un goal. In questa sezione, scriveremo un ulteriore livello -``wrapper'' per avvolgere \ml{DPLL\_UNIV}, producendo uno strumento che pu +La funzione \ml{DPLL\_UNIV} richiede che il suo input sia quantificato +universalmente, con tutte le variabili libere legate, e che ciascun letterale sia +una variabile o la negazione di una variabile. Questo rende \ml{DPLL\_UNIV} +poco facile da usare quando viene ad essere usata come parte della dimostrazione di +un goal. In questa sezione, scriveremo un ulteriore livello +``wrapper'' per avvolgere \ml{DPLL\_UNIV}, producendo uno strumento che pu essere applicato a molti pi goal. -\paragraph{Mitigare il Requisito di Quantificazione} Il primo passo -permettere formule che non sono chiuse. Al fine di trasmettere una formula -che \emph{} chiusa a \ml{DPLL\_UNIV}, possiamo semplicemente generalizzare -sulle variabili libere della formula. Se \ml{DPLL\_UNIV} dice poi che -la nuova, formula ground vera, allora lo sar anche l'originale. Dall'altro -lato, se \ml{DPLL\_UNIV} dice che la formula ground -falsa, allora non possiamo concludere niente di pi e dovremo sollevare +\paragraph{Mitigare il Requisito di Quantificazione} Il primo passo +permettere formule che non sono chiuse. Al fine di trasmettere una formula +che \emph{} chiusa a \ml{DPLL\_UNIV}, possiamo semplicemente generalizzare +sulle variabili libere della formula. Se \ml{DPLL\_UNIV} dice poi che +la nuova, formula ground vera, allora lo sar anche l'originale. Dall'altro +lato, se \ml{DPLL\_UNIV} dice che la formula ground +falsa, allora non possiamo concludere niente di pi e dovremo sollevare un'eccezione. Il codice che implementa questo mostrato di sotto: @@ -718,11 +718,11 @@ \subsection{Performance} \end{hol} \paragraph{Permettere Foglie Non Letterali} -Possiamo fare meglio di \ml{nonuniv\_wrap}: piuttosto che quantificare solamente -solo sulle variabili libere (che abbiamo convenientemente assunto che saranno solo -booleane), possiamo trasformare ogni parte foglia del termine che non una -variabile o la negazione di una variabile in una nuova variabile. Prima -estraiamo quelle foglie con valore booleano che non sono le costanti vero o +Possiamo fare meglio di \ml{nonuniv\_wrap}: piuttosto che quantificare solamente +solo sulle variabili libere (che abbiamo convenientemente assunto che saranno solo +booleane), possiamo trasformare ogni parte foglia del termine che non una +variabile o la negazione di una variabile in una nuova variabile. Prima +estraiamo quelle foglie con valore booleano che non sono le costanti vero o falso. \begin{hol} \begin{verbatim} @@ -741,11 +741,11 @@ \subsection{Performance} else HOLset.add(acc, t) \end{verbatim} \end{hol} -Si noti che non abbiamo tentato esplicitamente di separare le negazioni -booleane (il che si potrebbe fare con \ml{dest\_neg}). Questo perch -anche \ml{dest\_imp} distrugge termini \holtxt{\~{}p}, restituendo -\holtxt{p} e \holtxt{F} come l'antecedente e la conclusione. Abbiamo -anche usato una funzione \ml{dest\_bool\_eq} progettata per dividere solo +Si noti che non abbiamo tentato esplicitamente di separare le negazioni +booleane (il che si potrebbe fare con \ml{dest\_neg}). Questo perch +anche \ml{dest\_imp} distrugge termini \holtxt{\~{}p}, restituendo +\holtxt{p} e \holtxt{F} come l'antecedente e la conclusione. Abbiamo +anche usato una funzione \ml{dest\_bool\_eq} progettata per dividere solo quelle uguaglianze che sono su valori booleani. La sua definizione \begin{hol} \begin{verbatim} @@ -774,18 +774,18 @@ \subsection{Performance} end \end{verbatim} \end{hol} -Si noti come questo codice prima tira fuori tutte le quantificazioni universali -esterne (con \ml{strip\_forall}), e poi ri-generalizza -(con \ml{list\_mk\_forall}). Le chiamate a \ml{GENL} e \ml{SPECL} -annullano queste manipolazioni, ma al livello dei teoremi. Questo produce -un teorema che uguaglia l'input originale a vero. (Se il termine di input non - un'istanza di una formula proposizionale valida, la chiamata a +Si noti come questo codice prima tira fuori tutte le quantificazioni universali +esterne (con \ml{strip\_forall}), e poi ri-generalizza +(con \ml{list\_mk\_forall}). Le chiamate a \ml{GENL} e \ml{SPECL} +annullano queste manipolazioni, ma al livello dei teoremi. Questo produce +un teorema che uguaglia l'input originale a vero. (Se il termine di input non + un'istanza di una formula proposizionale valida, la chiamata a \ml{EQT\_ELIM} sollever un'eccezione.) \section*{Esercizi} \begin{enumerate} -\item Estendere la procedura cos che gestisca le espressioni condizionali +\item Estendere la procedura cos che gestisca le espressioni condizionali (entrambi i rami dei termini devono essere di tipo booleano). \end{enumerate} diff --git a/Manual/Translations/IT/Tutorial/tutorial.tex b/Manual/Translations/IT/Tutorial/tutorial.tex index a3527bf16e..e6edfea361 100644 --- a/Manual/Translations/IT/Tutorial/tutorial.tex +++ b/Manual/Translations/IT/Tutorial/tutorial.tex @@ -6,8 +6,8 @@ % Lingua italiana.Start \usepackage[latin1]{inputenc} -\usepackage[T1]{fontenc} -\usepackage[italian]{babel} +\usepackage[T1]{fontenc} +\usepackage[italian]{babel} % lingua italiana.End % to use with Italian babel this command must be put here: see ligic.tex at line 963 diff --git a/examples/ARM_security_properties/ARM_proverLib.sig b/examples/ARM_security_properties/ARM_proverLib.sig index a2d1aea9a0..d9ec9abc90 100644 --- a/examples/ARM_security_properties/ARM_proverLib.sig +++ b/examples/ARM_security_properties/ARM_proverLib.sig @@ -4,20 +4,20 @@ sig val global_mode : Parse.term ref val simp_thms_list : Theory.thm list ref val mode_changing_comp_list : Parse.term list ref - val mode_changing_comp_list_rec + val mode_changing_comp_list_rec : Term.term list -> Term.term -> bool - val generate_uncurry_abs + val generate_uncurry_abs : Theory.term -> Theory.term list * Theory.term - val decompose_term + val decompose_term : boolSyntax.term -> boolSyntax.term * boolSyntax.term * boolSyntax.term val get_monad_type : Type.hol_type -> Type.hol_type - val generate_uncurry_abs_from_abs + val generate_uncurry_abs_from_abs : Theory.term -> Theory.term list * Theory.term val get_type_inst : Type.hol_type * bool -> Type.hol_type val get_uncurried_theorem : Thm.thm -> int -> Thm.thm val generalize_theorem : Abbrev.thm -> Abbrev.term -> Thm.thm - val prove + val prove : Hol_pp.term -> Parse.term -> diff --git a/examples/ARM_security_properties/ARM_prover_extLib.sig b/examples/ARM_security_properties/ARM_prover_extLib.sig index 7867d2e697..fd2dea5f4d 100644 --- a/examples/ARM_security_properties/ARM_prover_extLib.sig +++ b/examples/ARM_security_properties/ARM_prover_extLib.sig @@ -1,17 +1,17 @@ signature ARM_prover_extLib = sig (* include arm_encoderLib arm_disassemblerLib*) - - val decompose_term + + val decompose_term : boolSyntax.term -> boolSyntax.term * boolSyntax.term * boolSyntax.term val mk_spec_list : Parse.term -> Parse.term list val mk_spec_list2 : Parse.term -> Parse.term list val mk_spec_list3 : Parse.term -> Parse.term list val mk_spec_list4 : Parse.term -> Parse.term list - val generate_uncurry_abs + val generate_uncurry_abs : Theory.term -> Theory.term list * Theory.term val get_monad_type : Type.hol_type -> Type.hol_type - val generate_uncurry_abs_from_abs + val generate_uncurry_abs_from_abs : Theory.term -> Theory.term list * Theory.term val get_action_from_goal : 'a * boolSyntax.term -> boolSyntax.term val find_theorem : string -> Thm.thm @@ -23,9 +23,9 @@ sig (Abbrev.term -> Term.term list -> 'a) list -> Term.term list -> 'b -> string -> Abbrev.thm list -> Abbrev.thm * Abbrev.tactic - val get_second_lemmma + val get_second_lemmma : Abbrev.thm -> Parse.term -> Parse.term -> Abbrev.thm -> Abbrev.thm - val prove_abs_action + val prove_abs_action : Abbrev.term * (Abbrev.term -> Abbrev.term list -> 'a) list * Abbrev.term list * 'b * Thm.thm list * diff --git a/examples/ARM_security_properties/MMUScript.sml b/examples/ARM_security_properties/MMUScript.sml index c7b64884d6..bef0e9a347 100644 --- a/examples/ARM_security_properties/MMUScript.sml +++ b/examples/ARM_security_properties/MMUScript.sml @@ -1,4 +1,4 @@ -(* +(* Updates since version 4: ------------------------ @@ -40,9 +40,9 @@ Updates since version 1: *) - -(* Loading: I assume that armLib is already loaded + +(* Loading: I assume that armLib is already loaded loadPath := "/NOBACKUP/workspaces/nargeskh/hol4.k.7/examples/ARM/v7/" :: !loadPath; loadPath := "/NOBACKUP/workspaces/nargeskh/hol4.k.7/examples/ARM/v7/eval" :: !loadPath; @@ -65,7 +65,7 @@ val read_mem32_def = Define ` read_mem32 add mem = word32 ([mem (add);mem (add+1w);mem (add+2w);mem (add+3w)])`; -val enabled_MMU_def = Define `enabled_MMU (c1:word32) = +val enabled_MMU_def = Define `enabled_MMU (c1:word32) = let bit0 = BIT 0 (w2n(c1)) in bit0`; @@ -74,40 +74,40 @@ val enabled_MMU_def = Define `enabled_MMU (c1:word32) = (* further changes in version 2: expr3 = 0 and expr7 may be 01 as well *) val sd_supports_MMU_def = Define `sd_supports_MMU content_of_sd si = let expr1 = (content_of_sd && 0x00000003w) in - let expr2 = (content_of_sd && 0x0000000Cw) >>> 2 in - let expr3 = (content_of_sd && 0x00000010w) >>> 4 in - let expr4 = (content_of_sd && 0x00000200w) >>> 9 in - let expr7 = (content_of_sd && 0x00000C00w) >>> 10 in - let expr5 = (content_of_sd && 0x000FF000w) >>> 12 in - let expr6 = (content_of_sd && 0xFFF00000w) >>> 20 in + let expr2 = (content_of_sd && 0x0000000Cw) >>> 2 in + let expr3 = (content_of_sd && 0x00000010w) >>> 4 in + let expr4 = (content_of_sd && 0x00000200w) >>> 9 in + let expr7 = (content_of_sd && 0x00000C00w) >>> 10 in + let expr5 = (content_of_sd && 0x000FF000w) >>> 12 in + let expr6 = (content_of_sd && 0xFFF00000w) >>> 20 in (expr1 = 0b10w:bool[32]) /\ - (expr2 = 0b00w:word32) /\ - (expr3 = 0b0w:word32) /\ - (expr4 = 0b0w:word32) /\ - ((expr7 = 0b11w:word32) \/ (expr7 = 0b01w:word32)) /\ - (expr5 = 0b0w:word32) /\ + (expr2 = 0b00w:word32) /\ + (expr3 = 0b0w:word32) /\ + (expr4 = 0b0w:word32) /\ + ((expr7 = 0b11w:word32) \/ (expr7 = 0b01w:word32)) /\ + (expr5 = 0b0w:word32) /\ (expr6 = si)`; (* permitted_byte *) (* returns (understood, permitted, message) *) -val permitted_byte_def = Define `permitted_byte adr is_write (c1:word32) c2 (c3:bool[32]) priv mem = +val permitted_byte_def = Define `permitted_byte adr is_write (c1:word32) c2 (c3:bool[32]) priv mem = if (~(enabled_MMU c1)) then (T, T, "MMU is disabled") else let si = (adr >>> 20) in - let first_sd = c2 && (0xFFFFC000w:bool[32]) in + let first_sd = c2 && (0xFFFFC000w:bool[32]) in let adr_sd = first_sd + 4w * si in let content_of_sd = read_mem32 adr_sd mem in - let domain:bool[32] = + let domain:bool[32] = (content_of_sd && 0x000001E0w:bool[32]) >>> 5 in (* make sure that it starts with one *) let bit1_c3 = BIT (2*w2n(domain)) (w2n(c3)) in let bit2_c3 = BIT (2*w2n(domain)+1) (w2n(c3)) in let AP = (content_of_sd && 0x00000C00w) >>> 10 in if (sd_supports_MMU content_of_sd si) - then + then (case (bit2_c3, bit1_c3) of (T,T) => (T, T, "uncontrolled manager domain") | (F,F) => (T, F, "no access domain") @@ -124,9 +124,9 @@ val permitted_byte_def = Define `permitted_byte adr is_write (c1:word32) c2 (c3: ) |0b11w => (T, T , "permitted by PTE") | _ => (F, UNKNOWN, "AP wrongly determined") - ) + ) ) - else + else (F, UNKNOWN, "no support") `; @@ -136,15 +136,15 @@ val permitted_byte_def = Define `permitted_byte adr is_write (c1:word32) c2 (c3: (* similar to permitted_byte when assuming *) (* that we always understand the MMU setup *) -val permitted_byte_pure_def = Define `permitted_byte_pure adr is_write (c1:word32) c2 (c3:bool[32]) priv mem = +val permitted_byte_pure_def = Define `permitted_byte_pure adr is_write (c1:word32) c2 (c3:bool[32]) priv mem = if (~(enabled_MMU c1)) then T else let si = (adr >>> 20) in - let first_sd = c2 && (0xFFFFC000w:bool[32]) in + let first_sd = c2 && (0xFFFFC000w:bool[32]) in let adr_sd = first_sd + 4w * si in let content_of_sd = read_mem32 adr_sd mem in - let domain:bool[32] = + let domain:bool[32] = (content_of_sd && 0x000001E0w:bool[32]) >>> 5 in (* make sure that it starts with one *) let bit1_c3 = BIT (2*w2n(domain)) (w2n(c3)) in @@ -164,7 +164,7 @@ val permitted_byte_pure_def = Define `permitted_byte_pure adr is_write (c1:word3 else (~is_write) ) |0b11w => T - ) + ) `; @@ -187,15 +187,15 @@ val permitted_byte_simp = store_thm ( (* returns (understood, abort, address) *); -val check_accesses_def = Define `check_accesses accesses c1 c2 c3 priv memory = +val check_accesses_def = Define `check_accesses accesses c1 c2 c3 priv memory = case accesses of - x::tl => - ( let (adr, is_write) = - ( case x of + x::tl => + ( let (adr, is_write) = + ( case x of MEM_READ address => (address, F) | MEM_WRITE address _ => (address, T) ) in - + let (und, per, msg) = (permitted_byte adr is_write c1 c2 c3 priv memory) in ( if (und /\ (~per)) then @@ -215,7 +215,7 @@ val check_accesses_def = Define `check_accesses accesses c1 c2 c3 priv memory = ) ) ) - | _ => (T, F, UNKNOWN)`; + | _ => (T, F, UNKNOWN)`; @@ -224,17 +224,17 @@ val check_accesses_def = Define `check_accesses accesses c1 c2 c3 priv memory = (* returns boolean "abort" *) (* similar to check_accesses when assuming that we *) (* always understand the MMU setup *) -val check_accesses_pure_def = Define `check_accesses_pure accesses c1 c2 c3 priv memory = +val check_accesses_pure_def = Define `check_accesses_pure accesses c1 c2 c3 priv memory = case accesses of - x::tl => - ( let (adr, is_write) = - ( case x of + x::tl => + ( let (adr, is_write) = + ( case x of MEM_READ address => (address, F) | MEM_WRITE address _ => (address, T) ) in - (~permitted_byte_pure adr is_write c1 c2 c3 priv memory) \/ (check_accesses_pure tl c1 c2 c3 priv memory) + (~permitted_byte_pure adr is_write c1 c2 c3 priv memory) \/ (check_accesses_pure tl c1 c2 c3 priv memory) ) - | _ => F`; + | _ => F`; @@ -246,26 +246,26 @@ val check_accesses_pure_def = Define `check_accesses_pure accesses c1 c2 c3 priv val check_accesses_TAC = (fn IS_WRITE => FULL_SIMP_TAC (srw_ss()) [LET_DEF] THEN Cases_on [QUOTE ("permitted_byte c "^IS_WRITE^" c1 c2 c3 priv mem")] - THEN Cases_on `r` - THEN Cases_on `q` + THEN Cases_on `r` + THEN Cases_on `q` THEN FULL_SIMP_TAC (srw_ss()) [permitted_byte_simp] - THEN MP_TAC ( SPECL [``T``, - ``q':bool``, + THEN MP_TAC ( SPECL [``T``, + ``q':bool``, ``r':string``, ``c:word32``, Term [QUOTE IS_WRITE], ``c1:word32``, - ``c2:word32``, + ``c2:word32``, ``c3:word32``, ``priv:bool``, ``mem:bool[32] -> bool[8]``] permitted_byte_simp) THEN RW_TAC (srw_ss()) [] - THEN Cases_on `check_accesses acc c1 c2 c3 priv mem` - THEN Cases_on `r` + THEN Cases_on `check_accesses acc c1 c2 c3 priv mem` + THEN Cases_on `r` THEN FULL_SIMP_TAC (srw_ss())[permitted_byte_simp] - THEN Cases_on `q` - THEN Cases_on `q'` - THEN (TRY (Cases_on `q''`)) + THEN Cases_on `q` + THEN Cases_on `q'` + THEN (TRY (Cases_on `q''`)) THEN FULL_SIMP_TAC (srw_ss()) [] THEN (NO_TAC ORELSE METIS_TAC [])); @@ -273,9 +273,9 @@ val check_accesses_TAC = (fn IS_WRITE => val check_accesses_simp = store_thm ( "check_accesses_simp", ``!u a add acc c1 c2 c3 priv mem. - ((u,a,add) = check_accesses acc c1 c2 c3 priv mem) /\ u + ((u,a,add) = check_accesses acc c1 c2 c3 priv mem) /\ u ==> (check_accesses_pure acc c1 c2 c3 priv mem = a)``, - Induct_on `acc` + Induct_on `acc` THENL [RW_TAC (srw_ss()) [check_accesses_def, check_accesses_pure_def], ONCE_REWRITE_TAC [check_accesses_def, check_accesses_pure_def] THEN FULL_SIMP_TAC (srw_ss()) [LET_DEF] @@ -292,16 +292,16 @@ val check_accesses_simp = store_thm ( val check_accesses_understand = store_thm ( "check_accesses_understand", ``!acc c1 c2 c3 priv mem. - (!add is_write. FST (permitted_byte add is_write c1 c2 c3 priv mem)) + (!add is_write. FST (permitted_byte add is_write c1 c2 c3 priv mem)) ==> (FST (check_accesses acc c1 c2 c3 priv mem))``, - Induct_on `acc` + Induct_on `acc` THENL [RW_TAC (srw_ss()) [check_accesses_def], ONCE_REWRITE_TAC [check_accesses_def] THEN FULL_SIMP_TAC (srw_ss()) [LET_DEF] THEN STRIP_TAC THEN CASE_TAC THEN PairRules.PBETA_TAC - THEN RW_TAC (srw_ss()) [] + THEN RW_TAC (srw_ss()) [] ]); @@ -309,7 +309,7 @@ val check_accesses_understand = store_thm ( (* access_violation_full *) -val access_violation_full_def = Define `access_violation_full s = check_accesses s.accesses +val access_violation_full_def = Define `access_violation_full s = check_accesses s.accesses s.coprocessors.state.cp15.C1 s.coprocessors.state.cp15.C2 s.coprocessors.state.cp15.C3 @@ -329,12 +329,12 @@ val empty_accesses_full_lem = store_thm( (* access_violation_pure *) -val access_violation_pure_def = Define `access_violation_pure s = check_accesses_pure s.accesses +val access_violation_pure_def = Define `access_violation_pure s = check_accesses_pure s.accesses s.coprocessors.state.cp15.C1 s.coprocessors.state.cp15.C2 s.coprocessors.state.cp15.C3 F - + s.memory`; (* relate access_violation_pure and access_violation_full *) @@ -342,7 +342,7 @@ val access_violation_pure_def = Define `access_violation_pure s = check_accesses val access_violation_simp_pure= store_thm( "access_violation_simp_pure", ``!u a add s. - ((u,a,add) = access_violation_full s) /\ u + ((u,a,add) = access_violation_full s) /\ u ==> (access_violation_pure s = a)``, FULL_SIMP_TAC (srw_ss()) [access_violation_full_def, access_violation_pure_def] THEN METIS_TAC [check_accesses_simp]); @@ -352,7 +352,7 @@ val access_violation_simp_pure= store_thm( (*new_constant("access_violation", ``:arm_state -> bool``);*) -val access_violation_def = new_axiom("access_violation_axiom", ``!state u x add. +val access_violation_def = new_axiom("access_violation_axiom", ``!state u x add. ((u,x,add) = access_violation_full state) /\ u ==> (access_violation state = x) ``); @@ -362,7 +362,7 @@ val access_violation_def = new_axiom("access_violation_axiom", ``!state u x add. val access_violation_simp = store_thm ( "access_violation_simp", ``!s x add. - ((T,x,add) = access_violation_full s) + ((T,x,add) = access_violation_full s) ==> (access_violation s = access_violation_pure s)``, METIS_TAC [access_violation_simp_pure, access_violation_def]); @@ -371,7 +371,7 @@ val access_violation_simp_FST = store_thm ( ``!s. (FST (access_violation_full s)) ==> (access_violation s = access_violation_pure s)``, REPEAT STRIP_TAC - THEN Cases_on `access_violation_full s` + THEN Cases_on `access_violation_full s` THEN Cases_on `r` THEN FULL_SIMP_TAC (srw_ss()) [access_violation_simp]); @@ -401,7 +401,7 @@ val _ = temp_overload_on ("return", ``constT``); val _ = temp_overload_on ("PAD0", ``list$PAD_LEFT #"0"``); -val mmu_arm_next_def = Define `mmu_arm_next irpt state = +val mmu_arm_next_def = Define `mmu_arm_next irpt state = if irpt = NoInterrupt then ( case (waiting_for_interrupt <|proc:=0|> (state with accesses := [])) of @@ -411,20 +411,20 @@ val mmu_arm_next_def = Define `mmu_arm_next irpt state = if (wfi) then ValueState () wfi_state else ( - case (fetch_instruction <|proc:=0|> (\a. read_memA <|proc:=0|> (a, 4) >>= (\d. return (word32 d))) + case (fetch_instruction <|proc:=0|> (\a. read_memA <|proc:=0|> (a, 4) >>= (\d. return (word32 d))) (\a. read_memA <|proc:=0|> (a, 2) >>= (\d. return (word16 d))) (wfi_state with accesses := [])) of Error e => Error e | ValueState (opc,instr) fetched_state => ( - if access_violation fetched_state then + if access_violation fetched_state then take_prefetch_abort_exception <| proc := 0 |> (fetched_state with accesses := []) else case arm_instr <|proc:=0|> instr (fetched_state with accesses := []) of Error e => Error e | ValueState x end_state => ( - if access_violation end_state then + if access_violation end_state then take_data_abort_exception <| proc := 0 |> (end_state with accesses := []) else ValueState () end_state @@ -436,7 +436,7 @@ val mmu_arm_next_def = Define `mmu_arm_next irpt state = ) else (((if irpt = HW_Reset then - take_reset <|proc:=0|> + take_reset <|proc:=0|> else if irpt = HW_Fiq then take_fiq_exception <|proc:=0|> else (* irpt = HW_Irq *) diff --git a/examples/ARM_security_properties/MMU_SetupScript.sml b/examples/ARM_security_properties/MMU_SetupScript.sml index e5de6c120b..2ad5dd897c 100644 --- a/examples/ARM_security_properties/MMU_SetupScript.sml +++ b/examples/ARM_security_properties/MMU_SetupScript.sml @@ -2,7 +2,7 @@ open HolKernel boolLib bossLib Parse; open MMUTheory; -open Cond_rewrite blastLib; +open Cond_rewrite blastLib; val _ = new_theory "MMU_Setup"; @@ -34,17 +34,17 @@ val inequal_by_inequalities = save_thm( (CONJ (SPEC ``guest1_max_adr:word32`` inequal_by_inequalities_gtu_lem) (CONJ (SPEC ``guest1_min_adr:word32`` inequal_by_inequalities_ltu_lem) (CONJ (SPEC ``guest1_max_adr:word32`` inequal_by_inequalities_ltu_lem) -(CONJ (SPEC ``guest2_min_adr:word32`` inequal_by_inequalities_gtu_lem) +(CONJ (SPEC ``guest2_min_adr:word32`` inequal_by_inequalities_gtu_lem) (CONJ (SPEC ``guest2_max_adr:word32`` inequal_by_inequalities_gtu_lem) -(CONJ (SPEC ``guest2_min_adr:word32`` inequal_by_inequalities_ltu_lem) +(CONJ (SPEC ``guest2_min_adr:word32`` inequal_by_inequalities_ltu_lem) (CONJ (SPEC ``guest2_max_adr:word32`` inequal_by_inequalities_ltu_lem) (CONJ (SPEC ``guest1_min_adr:word32`` inequal_by_inequalities_gt_lem) (CONJ (SPEC ``guest1_max_adr:word32`` inequal_by_inequalities_gt_lem) (CONJ (SPEC ``guest1_min_adr:word32`` inequal_by_inequalities_lt_lem) (CONJ (SPEC ``guest1_max_adr:word32`` inequal_by_inequalities_lt_lem) -(CONJ (SPEC ``guest2_min_adr:word32`` inequal_by_inequalities_gt_lem) +(CONJ (SPEC ``guest2_min_adr:word32`` inequal_by_inequalities_gt_lem) (CONJ (SPEC ``guest2_max_adr:word32`` inequal_by_inequalities_gt_lem) -(CONJ (SPEC ``guest2_min_adr:word32`` inequal_by_inequalities_lt_lem) +(CONJ (SPEC ``guest2_min_adr:word32`` inequal_by_inequalities_lt_lem) (SPEC ``guest2_max_adr:word32`` inequal_by_inequalities_lt_lem))))))))))))))))); @@ -82,7 +82,7 @@ val address_cases = save_thm( val negated_and_or = save_thm( - "negated_and_or", + "negated_and_or", blastLib.BBLAST_PROVE ``!(a:word32). ((~(a > guest2_max_adr ∨ a < guest2_min_adr)) = (a <= guest2_max_adr /\ a >= guest2_min_adr)) /\ @@ -180,19 +180,19 @@ FULL_SIMP_TAC (srw_ss()) [guest1_min_adr_def, guest1_max_adr_def, guest2_min_adr val address_complete = store_thm( "address_complete", - ``!(add1:word32). (add1 <=+ guest1_max_adr ∧ add1 >=+ guest1_min_adr) \/ + ``!(add1:word32). (add1 <=+ guest1_max_adr ∧ add1 >=+ guest1_min_adr) \/ (add1 <=+ guest2_max_adr ∧ add1 >=+ guest2_min_adr) \/ (add1 >+ guest2_max_adr ∨ add1 <+ guest1_min_adr)``, FULL_SIMP_TAC (srw_ss()) [guest1_min_adr_def, guest1_max_adr_def, guest2_min_adr_def, guest2_max_adr_def] THEN blastLib.BBLAST_TAC); (* what we assume when guests are running *) -val mmu_requirements_def = Define `mmu_requirements state id = +val mmu_requirements_def = Define `mmu_requirements state id = !add1 is_write u p m. - ((u,p,m) = permitted_byte add1 + ((u,p,m) = permitted_byte add1 is_write - state.coprocessors.state.cp15.C1 - state.coprocessors.state.cp15.C2 + state.coprocessors.state.cp15.C1 + state.coprocessors.state.cp15.C2 state.coprocessors.state.cp15.C3 F state.memory) @@ -210,26 +210,26 @@ val mmu_requirements_def = Define `mmu_requirements state id = val mmu_requirements_pure_def = Define `mmu_requirements_pure state id = !add1 is_write. ( ((add1 <=+ guest1_max_adr) /\ (add1 >=+ guest1_min_adr)) ==> - ((id=guest1) = permitted_byte_pure add1 + ((id=guest1) = permitted_byte_pure add1 is_write - state.coprocessors.state.cp15.C1 - state.coprocessors.state.cp15.C2 + state.coprocessors.state.cp15.C1 + state.coprocessors.state.cp15.C2 state.coprocessors.state.cp15.C3 F state.memory)) /\ ( ((add1 <=+ guest2_max_adr ) /\ (add1 >=+ guest2_min_adr)) ==> - ((id=guest2) = permitted_byte_pure add1 + ((id=guest2) = permitted_byte_pure add1 is_write - state.coprocessors.state.cp15.C1 - state.coprocessors.state.cp15.C2 + state.coprocessors.state.cp15.C1 + state.coprocessors.state.cp15.C2 state.coprocessors.state.cp15.C3 F state.memory)) /\ ( ((add1 >+ guest2_max_adr ) \/ (add1 <+ guest1_min_adr)) ==> - (~ permitted_byte_pure add1 + (~ permitted_byte_pure add1 is_write - state.coprocessors.state.cp15.C1 - state.coprocessors.state.cp15.C2 + state.coprocessors.state.cp15.C1 + state.coprocessors.state.cp15.C2 state.coprocessors.state.cp15.C3 F state.memory))`; @@ -241,7 +241,7 @@ val mmu_requirements_simp = store_thm( ``!s g. mmu_requirements s g ==> mmu_requirements_pure s g``, PURE_ONCE_REWRITE_TAC [mmu_requirements_pure_def] THEN NTAC 5 STRIP_TAC - THEN Cases_on `permitted_byte add1 is_write s.coprocessors.state.cp15.C1 s.coprocessors.state.cp15.C2 s.coprocessors.state.cp15.C3 F s.memory` + THEN Cases_on `permitted_byte add1 is_write s.coprocessors.state.cp15.C1 s.coprocessors.state.cp15.C2 s.coprocessors.state.cp15.C3 F s.memory` THEN pairLib.PairCases_on `r` THEN NTAC 2 STRIP_TAC THEN TRY DISCH_TAC @@ -259,14 +259,14 @@ val mmu_requirements_simp = store_thm( val mmu_requirement_accesses_update_lem = store_thm( "mmu_requirement_accesses_update_lem", - ``!add1 x s g. + ``!add1 x s g. ((mmu_requirements s g) = (mmu_requirements (s with accesses updated_by CONS (MEM_READ add1)) g)) /\ ((mmu_requirements s g) = (mmu_requirements (s with accesses updated_by CONS (MEM_WRITE add1 x)) g))``, FULL_SIMP_TAC (srw_ss()) [mmu_requirements_def]); val mmu_requirement_accesses_update_lem2 = store_thm( "mmu_requirement_accesses_update_lem2", - ``!add1 x s g. + ``!add1 x s g. ((mmu_requirements s g) = (mmu_requirements (s with accesses updated_by CONS (MEM_READ add1) o other) g)) /\ ((mmu_requirements s g) = (mmu_requirements (s with accesses updated_by CONS (MEM_WRITE add1 x) o other) g))``, FULL_SIMP_TAC (srw_ss()) [mmu_requirements_def]); @@ -276,7 +276,7 @@ val mmu_requirement_accesses_update_lem2 = store_thm( (* lemma: same setup --> same access rights *) val same_setup_same_rights_lem = store_thm( - "same_setup_same_rights_lem", + "same_setup_same_rights_lem", ``! s1 s2 g add1 is_write. mmu_requirements_pure s1 g ==> mmu_requirements_pure s2 g @@ -297,7 +297,7 @@ val same_setup_same_rights_lem = store_thm( val same_setup_same_check_accesses_lem = store_thm( - "same_setup_same_check_accesses_lem", + "same_setup_same_check_accesses_lem", ``! s1 s2 g accesses. mmu_requirements_pure s1 g ==> mmu_requirements_pure s2 g @@ -309,7 +309,7 @@ val same_setup_same_check_accesses_lem = store_thm( s2.coprocessors.state.cp15.C2 s2.coprocessors.state.cp15.C3 F s2.memory)``, REPEAT STRIP_TAC - THEN Induct_on `accesses` + THEN Induct_on `accesses` THEN PURE_ONCE_REWRITE_TAC [check_accesses_pure_def] THEN FULL_SIMP_TAC (srw_ss()) [LET_DEF] THEN STRIP_TAC @@ -336,16 +336,16 @@ val same_setup_same_av_pure_lem = store_thm( val access_violation_req = store_thm ( "access_violation_req", - ``!s id. (mmu_requirements s id) + ``!s id. (mmu_requirements s id) ==> (access_violation s = access_violation_pure s)``, REPEAT STRIP_TAC - THEN Cond_rewrite.COND_REWRITE1_TAC (SPEC ``s:arm_state`` access_violation_simp_FST) + THEN Cond_rewrite.COND_REWRITE1_TAC (SPEC ``s:arm_state`` access_violation_simp_FST) THEN FULL_SIMP_TAC (srw_ss()) [access_violation_full_def] - THEN `!add1 is_write. + THEN `!add1 is_write. ((u,p,m) = (permitted_byte add1 is_write s.coprocessors.state.cp15.C1 s.coprocessors.state.cp15.C2 s.coprocessors.state.cp15.C3 F s.memory)) ==> u` by METIS_TAC [mmu_requirements_def] - THEN `!add1 is_write. - FST (permitted_byte add1 is_write s.coprocessors.state.cp15.C1 s.coprocessors.state.cp15.C2 s.coprocessors.state.cp15.C3 F s.memory)` + THEN `!add1 is_write. + FST (permitted_byte add1 is_write s.coprocessors.state.cp15.C1 s.coprocessors.state.cp15.C2 s.coprocessors.state.cp15.C3 F s.memory)` by (RW_TAC (srw_ss()) [] THEN Cases_on `permitted_byte add1 is_write s.coprocessors.state.cp15.C1 s.coprocessors.state.cp15.C2 s.coprocessors.state.cp15.C3 F s.memory` THEN pairLib.PairCases_on `r` @@ -425,25 +425,25 @@ val malicious_write = store_thm ( val aligned_word_readable_def = Define `aligned_word_readable s is_thumb add1 = - ( permitted_byte_pure (add1) F s.coprocessors.state.cp15.C1 s.coprocessors.state.cp15.C2 s.coprocessors.state.cp15.C3 F s.memory + ( permitted_byte_pure (add1) F s.coprocessors.state.cp15.C1 s.coprocessors.state.cp15.C2 s.coprocessors.state.cp15.C3 F s.memory /\ (is_thumb ==> ( permitted_byte_pure (align(add1,2)) F s.coprocessors.state.cp15.C1 - s.coprocessors.state.cp15.C2 + s.coprocessors.state.cp15.C2 s.coprocessors.state.cp15.C3 F s.memory /\ permitted_byte_pure (align (add1,2) + 1w) F s.coprocessors.state.cp15.C1 - s.coprocessors.state.cp15.C2 + s.coprocessors.state.cp15.C2 s.coprocessors.state.cp15.C3 F s.memory)) - + /\ (~is_thumb ==> ( permitted_byte_pure (align(add1,4)) F s.coprocessors.state.cp15.C1 - s.coprocessors.state.cp15.C2 + s.coprocessors.state.cp15.C2 s.coprocessors.state.cp15.C3 F s.memory /\ permitted_byte_pure (align (add1,4) + 1w) F s.coprocessors.state.cp15.C1 - s.coprocessors.state.cp15.C2 + s.coprocessors.state.cp15.C2 s.coprocessors.state.cp15.C3 F s.memory /\ permitted_byte_pure (align (add1,4) + 2w) F s.coprocessors.state.cp15.C1 - s.coprocessors.state.cp15.C2 + s.coprocessors.state.cp15.C2 s.coprocessors.state.cp15.C3 F s.memory /\ permitted_byte_pure (align (add1,4) + 3w) F s.coprocessors.state.cp15.C1 - s.coprocessors.state.cp15.C2 + s.coprocessors.state.cp15.C2 s.coprocessors.state.cp15.C3 F s.memory)))`; diff --git a/examples/ARM_security_properties/inference_rulesScript.sml b/examples/ARM_security_properties/inference_rulesScript.sml index b38e98f858..d2d82639bc 100644 --- a/examples/ARM_security_properties/inference_rulesScript.sml +++ b/examples/ARM_security_properties/inference_rulesScript.sml @@ -9,7 +9,7 @@ val let_ss = simpLib.mk_simpset [boolSimps.LET_ss] ; val comb_def = Define `comb invr1 invr2 invr3 = (!s. invr3 s = (invr1 s \/ invr2 s))`; val assert_mode_def = Define `assert_mode k s = (ARM_MODE s = k)`; - + (* ============= Untouched ==========================*) (* smc mode is not involved yet, also RName_LRmon,RName_SPmon*) @@ -18,14 +18,14 @@ val untouched_def = Define `untouched id state1 state2 = /\ (state1.information = - state2.information) + state2.information) /\ (! a. (((id <> guest1) /\ (id<>guest2)) ==> ((state1.memory a) = (state2.memory a))) - /\ + /\ (((id = guest1) /\ ((a >+ (* UNSIGNED *) guest1_max_adr) \/ (a <+ (* UNSIGNED *) guest1_min_adr))) ==> ((state1.memory a) = (state2.memory a))) /\ @@ -46,7 +46,7 @@ let irq_regs = {RName_0usr; RName_1usr; RName_2usr; RName_3usr; RName_4usr; RNam let fiq_regs = {RName_0usr; RName_1usr; RName_2usr; RName_3usr; RName_4usr; RName_5usr; RName_6usr; RName_7usr; RName_8usr; RName_9usr; RName_10usr; RName_11usr; RName_12usr; RName_SPusr; RName_LRusr; RName_PC; RName_8fiq; RName_9fiq; - RName_10fiq; RName_11fiq; RName_12fiq; RName_SPfiq; RName_LRfiq} in + RName_10fiq; RName_11fiq; RName_12fiq; RName_SPfiq; RName_LRfiq} in let abort_regs = {RName_0usr; RName_1usr; RName_2usr; RName_3usr; RName_4usr; RName_5usr; RName_6usr; RName_7usr; RName_8usr; RName_9usr; RName_10usr; RName_11usr; RName_12usr; RName_SPusr; RName_LRusr; RName_PC; RName_SPabt; RName_LRabt} in @@ -61,7 +61,7 @@ let und_regs = {RName_0usr; RName_1usr; RName_2usr; RName_3usr; RName_4usr; RNam (((ARM_MODE state1 = 16w) /\ (ARM_MODE state2 = 16w)) ==> ((!reg . (reg NOTIN user_regs) - ==> (state1.registers (0, reg) = state2.registers (0, reg))) + ==> (state1.registers (0, reg) = state2.registers (0, reg))) /\ (!psr . ((psr <> CPSR) ==> (state1.psrs (0, psr) = state2.psrs (0, psr)))) /\ @@ -71,63 +71,63 @@ let und_regs = {RName_0usr; RName_1usr; RName_2usr; RName_3usr; RName_4usr; RNam /\ ((((ARM_MODE state1 = 16w) /\ (ARM_MODE state2 = 17w)) -\/ +\/ ((ARM_MODE state1 = 17w) /\ (ARM_MODE state2 = 17w))) ==> - ((!reg . ((reg NOTIN user_regs) /\ (reg NOTIN fiq_regs)) - ==> (state1.registers (0, reg) = state2.registers (0, reg))) + ((!reg . ((reg NOTIN user_regs) /\ (reg NOTIN fiq_regs)) + ==> (state1.registers (0, reg) = state2.registers (0, reg))) /\ (!psr . ((psr <> CPSR) /\ (psr <> SPSR_fiq)) ==> (state1.psrs (0, psr) = state2.psrs (0, psr)))) ) /\ ((((ARM_MODE state1 = 16w) /\ - (ARM_MODE state2 = 18w)) + (ARM_MODE state2 = 18w)) \/ ((ARM_MODE state1 = 18w) /\ (ARM_MODE state2 = 18w))) ==> - ((!reg . ((reg NOTIN user_regs) /\ (reg NOTIN irq_regs)) - ==> (state1.registers (0, reg) = state2.registers (0, reg))) + ((!reg . ((reg NOTIN user_regs) /\ (reg NOTIN irq_regs)) + ==> (state1.registers (0, reg) = state2.registers (0, reg))) /\ (!psr . ((psr <> CPSR) /\ (psr <> SPSR_irq)) ==> (state1.psrs (0, psr) = state2.psrs (0, psr))))) /\ (*this is also the mode of reset, check again*) ((((ARM_MODE state1 = 16w) /\ - (ARM_MODE state2 = 19w)) + (ARM_MODE state2 = 19w)) \/ ((ARM_MODE state1 = 19w) /\ (ARM_MODE state2 = 19w))) ==> - ((!reg . ((reg NOTIN user_regs) /\ (reg NOTIN svc_regs)) - ==> (state1.registers (0, reg) = state2.registers (0, reg))) + ((!reg . ((reg NOTIN user_regs) /\ (reg NOTIN svc_regs)) + ==> (state1.registers (0, reg) = state2.registers (0, reg))) /\ (!psr . ((psr <> CPSR) /\ (psr <> SPSR_svc)) ==> (state1.psrs (0, psr) = state2.psrs (0, psr))))) /\ ((((ARM_MODE state1 = 16w) /\ - (ARM_MODE state2 = 23w)) + (ARM_MODE state2 = 23w)) \/ ((ARM_MODE state1 = 23w) /\ (ARM_MODE state2 = 23w))) ==> - ((!reg . ((reg NOTIN user_regs) /\ (reg NOTIN abort_regs)) - ==> (state1.registers (0, reg) = state2.registers (0, reg))) + ((!reg . ((reg NOTIN user_regs) /\ (reg NOTIN abort_regs)) + ==> (state1.registers (0, reg) = state2.registers (0, reg))) /\ (!psr . ((psr <> CPSR) /\ (psr <> SPSR_abt)) ==> (state1.psrs (0, psr) = state2.psrs (0, psr))))) /\ ((((ARM_MODE state1 = 16w) /\ - (ARM_MODE state2 = 27w)) + (ARM_MODE state2 = 27w)) \/ ((ARM_MODE state1 = 27w) /\ (ARM_MODE state2 = 27w))) ==> - ((!reg . ((reg NOTIN user_regs) /\ (reg NOTIN und_regs)) - ==> (state1.registers (0, reg) = state2.registers (0, reg))) + ((!reg . ((reg NOTIN user_regs) /\ (reg NOTIN und_regs)) + ==> (state1.registers (0, reg) = state2.registers (0, reg))) /\ (!psr . ((psr <> CPSR) /\ (psr <> SPSR_und)) ==> (state1.psrs (0, psr) = state2.psrs (0, psr))))) `; - -(* only for arm_next -val priv_mode_similar_def = + +(* only for arm_next +val priv_mode_similar_def = Define `priv_mode_similar (g:bool[32]) state1 state2 = (ARM_MODE state2 <> 16w) ==> (let (lr_reg,spsr) = case (ARM_MODE state2) of @@ -139,15 +139,15 @@ val priv_mode_similar_def = || 27w -> (RName_LRund,SPSR_und) || _ -> (RName_LRusr,CPSR) in - (state1.registers(0,lr_reg) = state2.registers(0,lr_reg)) - /\ + (state1.registers(0,lr_reg) = state2.registers(0,lr_reg)) + /\ (state1.psrs(0,spsr) = state2.psrs(0,spsr))) - + `;*) -val get_spsr_by_mode_def = - Define `get_spsr_by_mode (mode:bool[5]) = +val get_spsr_by_mode_def = + Define `get_spsr_by_mode (mode:bool[5]) = case (mode) of 17w => SPSR_fiq | 18w => SPSR_irq @@ -157,8 +157,8 @@ val get_spsr_by_mode_def = | 27w => SPSR_und | _ => CPSR`; -val get_lr_by_mode_def = - Define `get_lr_by_mode (mode:bool[5]) = +val get_lr_by_mode_def = + Define `get_lr_by_mode (mode:bool[5]) = case (mode) of 17w => RName_LRfiq | 18w => RName_LRirq @@ -168,16 +168,16 @@ val get_lr_by_mode_def = | 27w => RName_LRund | _ => RName_LRusr `; -val priv_mode_similar_def = +val priv_mode_similar_def = Define `priv_mode_similar (g:bool[32]) state1 state2 = (ARM_MODE state2 <> 16w) ==> (let (lr_reg,spsr) = (get_lr_by_mode(ARM_MODE state2) , get_spsr_by_mode(ARM_MODE state2)) in - (state1.registers(0,lr_reg) = state2.registers(0,lr_reg)) - /\ + (state1.registers(0,lr_reg) = state2.registers(0,lr_reg)) + /\ (state1.psrs(0,spsr) = state2.psrs(0,spsr))) - + `; @@ -185,10 +185,10 @@ val untouched_trans = store_thm ( "untouched_trans", ``!g st1 st2 st3 . (untouched g st1 st2 ) ==> (untouched g st2 st3 ) - ==> ((ARM_MODE st3 = ARM_MODE st2) \/ - (ARM_MODE st1 = ARM_MODE st2)) ==> + ==> ((ARM_MODE st3 = ARM_MODE st2) \/ + (ARM_MODE st1 = ARM_MODE st2)) ==> (untouched g st1 st3 )``, - RW_TAC (srw_ss()) [untouched_def] + RW_TAC (srw_ss()) [untouched_def] THEN FULL_SIMP_TAC (let_ss) [] THEN RW_TAC (srw_ss()) [] ); @@ -267,7 +267,7 @@ val untouched_mmu_setup_lem = store_thm( val trivially_untouched_mmu_setup_lem = store_thm( "trivially_untouched_mmu_setup_lem", ``!s t gst. (s.coprocessors = t.coprocessors) ==> - (s.memory = t.memory) + (s.memory = t.memory) ==> (mmu_requirements s gst = mmu_requirements t gst)``, RW_TAC (srw_ss()) [mmu_requirements_def]); @@ -290,9 +290,9 @@ val trivially_untouched_mmu_setup_lem2 = store_thm( "trivially_untouched_mmu_setup_lem2", ``!s t gst. (s.coprocessors.state.cp15.C1 = t.coprocessors.state.cp15.C1) ==> (s.coprocessors.state.cp15.C2 = t.coprocessors.state.cp15.C2) ==> - (s.coprocessors.state.cp15.C3 = t.coprocessors.state.cp15.C3) ==> - (s.memory = t.memory) - ==> + (s.coprocessors.state.cp15.C3 = t.coprocessors.state.cp15.C3) ==> + (s.memory = t.memory) + ==> (mmu_requirements s gst = mmu_requirements t gst)``, RW_TAC (srw_ss()) [mmu_requirements_def]); @@ -302,12 +302,12 @@ val trivially_untouched_mmu_setup_lem2 = store_thm( val trivially_untouched_av_lem2 = store_thm( "trivially_untouched_av_lem2", - ``!s t gst. (mmu_requirements s gst) ==> + ``!s t gst. (mmu_requirements s gst) ==> (s.coprocessors.state.cp15.C1 = t.coprocessors.state.cp15.C1) ==> (s.coprocessors.state.cp15.C2 = t.coprocessors.state.cp15.C2) ==> - (s.coprocessors.state.cp15.C3 = t.coprocessors.state.cp15.C3) ==> + (s.coprocessors.state.cp15.C3 = t.coprocessors.state.cp15.C3) ==> (s.memory = t.memory) ==> - (s.accesses = t.accesses) + (s.accesses = t.accesses) ==> (access_violation s = access_violation t)``, REPEAT STRIP_TAC THEN `mmu_requirements t gst` by IMP_RES_TAC trivially_untouched_mmu_setup_lem2 @@ -343,9 +343,9 @@ val similar_def = Define `similar gst s1 s2 = (s1.information = s2.information) /\ (* to be checked*) -(s1.monitors = s2.monitors) +(s1.monitors = s2.monitors) /\ -(s1.event_register = s2.event_register) +(s1.event_register = s2.event_register) `; @@ -358,14 +358,14 @@ val similar_refl = store_thm( (*********************** preserve ****************************) -val trans_fun_def = Define `trans_fun uf = +val trans_fun_def = Define `trans_fun uf = !g st1 st2 st3 . (uf g st1 st2) ==> - (uf g st2 st3) + (uf g st2 st3) ==> (uf g st1 st3)`; -val preserve_relation_mmu_def = +val preserve_relation_mmu_def = Define `preserve_relation_mmu comp invr1 invr2 f y = !g s1 s2 . mmu_requirements s1 g ==> @@ -376,12 +376,12 @@ Define `preserve_relation_mmu comp invr1 invr2 f y = invr1 s2 ==> ((?a s1' s2'.((comp s1 = ValueState a s1') /\ (comp s2 = ValueState a s2') /\ (untouched g s1 s1' ) /\ - (untouched g s2 s2' ) /\ + (untouched g s2 s2' ) /\ (f g s1 s1') /\ (f g s2 s2') /\ (y g s1' s2') /\ (invr2 s1') /\ - (invr2 s2') /\ + (invr2 s2') /\ (similar g s1' s2'))) \/ (? e. (comp s1 = Error e) /\ (comp s2 = Error e)))`; @@ -395,7 +395,7 @@ val preserve_relation_mmu_abs_def = Define `preserve_relation_mmu_abs comp invr (y g s1 s2) ==> invr1 s1 ==> invr1 s2 ==> - ((?a s1' s2'.((comp c s1 = ValueState a s1') /\ (comp c s2 = ValueState a s2') /\ + ((?a s1' s2'.((comp c s1 = ValueState a s1') /\ (comp c s2 = ValueState a s2') /\ (untouched g s1 s1' ) /\ (untouched g s2 s2' ) /\ (f g s1 s1') /\ @@ -408,12 +408,12 @@ val preserve_relation_mmu_abs_def = Define `preserve_relation_mmu_abs comp invr val comb_rel_lem = store_thm ( "comb_rel_lem", - ``!i1 i2 i3 s. (comb i1 i2 i3) + ``!i1 i2 i3 s. (comb i1 i2 i3) ==> ((i1 s) ==> (i3 s)) /\ ((i2 s) ==> (i3 s))``, RW_TAC (srw_ss()) [comb_def]); -val seqT_preserves_relation_up_proof = - (RW_TAC (srw_ss()) [arm_seq_monadTheory.seqT_def,arm_seq_monadTheory.constT_def,preserve_relation_mmu_def,preserve_relation_mmu_abs_def,trans_fun_def]) +val seqT_preserves_relation_up_proof = + (RW_TAC (srw_ss()) [arm_seq_monadTheory.seqT_def,arm_seq_monadTheory.constT_def,preserve_relation_mmu_def,preserve_relation_mmu_abs_def,trans_fun_def]) THEN (UNDISCH_ALL_TAC THEN REPEAT (CASE_TAC THEN FULL_SIMP_TAC (srw_ss()) [])) THENL [UNDISCH_ALL_TAC @@ -481,7 +481,7 @@ val seqT_preserves_relation_up1_thm = store_thm ("seqT_preserves_relation_up1_thm", ``! f1 f2 k k' invr23 uf uy. (comb (assert_mode k) (assert_mode k') invr23) ==> - (trans_fun uf) ==> + (trans_fun uf) ==> (preserve_relation_mmu f1 (assert_mode k) (assert_mode k) uf uy) ==> (preserve_relation_mmu_abs f2 (assert_mode k) (assert_mode k') uf uy) ==> (preserve_relation_mmu (f1 >>= (f2)) (assert_mode k) invr23 uf uy) @@ -510,7 +510,7 @@ val seqT_preserves_relation_uc_thm = (preserve_relation_mmu_abs f2 (assert_mode k) (comb_inv) uf uy) ==> (preserve_relation_mmu (f1 >>= (f2)) (assert_mode k) comb_inv uf uy) ``, - (RW_TAC (srw_ss()) [arm_seq_monadTheory.seqT_def,arm_seq_monadTheory.constT_def,preserve_relation_mmu_def,preserve_relation_mmu_abs_def,trans_fun_def]) + (RW_TAC (srw_ss()) [arm_seq_monadTheory.seqT_def,arm_seq_monadTheory.constT_def,preserve_relation_mmu_def,preserve_relation_mmu_abs_def,trans_fun_def]) THEN (UNDISCH_ALL_TAC THEN REPEAT (CASE_TAC THEN FULL_SIMP_TAC (srw_ss()) [])) THENL [UNDISCH_ALL_TAC @@ -580,7 +580,7 @@ val seqT_preserves_relation_uu_thm = (preserve_relation_mmu_abs f2 (assert_mode k) (assert_mode k) uf uy) ==> (preserve_relation_mmu (f1 >>= (f2)) (assert_mode k) (assert_mode k) uf uy) ``, - (RW_TAC (srw_ss()) [arm_seq_monadTheory.seqT_def,arm_seq_monadTheory.constT_def,preserve_relation_mmu_def,preserve_relation_mmu_abs_def,trans_fun_def]) + (RW_TAC (srw_ss()) [arm_seq_monadTheory.seqT_def,arm_seq_monadTheory.constT_def,preserve_relation_mmu_def,preserve_relation_mmu_abs_def,trans_fun_def]) THEN (UNDISCH_ALL_TAC THEN REPEAT (CASE_TAC THEN FULL_SIMP_TAC (srw_ss()) [])) THENL [UNDISCH_ALL_TAC @@ -643,34 +643,34 @@ THEN FULL_SIMP_TAC (srw_ss()) []]); val reflexive_comp_def = Define `reflexive_comp f invr = - ! s g. (invr s) ==> f g s s`; + ! s g. (invr s) ==> f g s s`; val condT_preserves_relation_thm = store_thm("condT_preserves_relation_thm", -``! b f invr1:(arm_state -> bool) uf uy. +``! b f invr1:(arm_state -> bool) uf uy. (reflexive_comp uf invr1) ==> - (preserve_relation_mmu f invr1 invr1 uf uy) ==> + (preserve_relation_mmu f invr1 invr1 uf uy) ==> (preserve_relation_mmu (condT b f ) invr1 invr1 uf uy)``, -(RW_TAC (srw_ss()) [preserve_relation_mmu_def,condT_def,similar_def,constT_def,untouched_def,reflexive_comp_def] ) +(RW_TAC (srw_ss()) [preserve_relation_mmu_def,condT_def,similar_def,constT_def,untouched_def,reflexive_comp_def] ) THEN (RW_TAC (srw_ss()) [] )); val first_abs_lemma = store_thm ("first_abs_lemma", -``(!f g i1 i2 uf uy. (f=g) ==> ((preserve_relation_mmu f i1 i2 uf uy) = +``(!f g i1 i2 uf uy. (f=g) ==> ((preserve_relation_mmu f i1 i2 uf uy) = (preserve_relation_mmu g i1 i2 uf uy)))``, RW_TAC (srw_ss()) []); val second_abs_lemma = store_thm ("second_abs_lemma", -``! f i1 i2 uf uy. (! y. preserve_relation_mmu (f y) i1 i2 uf uy) = +``! f i1 i2 uf uy. (! y. preserve_relation_mmu (f y) i1 i2 uf uy) = preserve_relation_mmu_abs f i1 i2 uf uy``, RW_TAC (srw_ss()) [preserve_relation_mmu_def,preserve_relation_mmu_abs_def]); val constT_preserves_relation_thm = store_thm( "constT_preserves_relation_thm", - ``!invr:(arm_state->bool) x uf uy. (reflexive_comp uf invr) ==> + ``!invr:(arm_state->bool) x uf uy. (reflexive_comp uf invr) ==> preserve_relation_mmu (constT x) invr invr uf uy``, - RW_TAC (srw_ss()) [constT_def, preserve_relation_mmu_def, untouched_def, similar_def,reflexive_comp_def] THEN + RW_TAC (srw_ss()) [constT_def, preserve_relation_mmu_def, untouched_def, similar_def,reflexive_comp_def] THEN RW_TAC (srw_ss()) [] ); @@ -682,12 +682,12 @@ val parT_alternative_thm = store_thm( val parT_latter_part_hlem = store_thm ( "parT_latter_part_hlem", - ``!f2 i2 i3 (x:'a) uf uy. (preserve_relation_mmu f2 i2 i3 uf uy) ==> + ``!f2 i2 i3 (x:'a) uf uy. (preserve_relation_mmu f2 i2 i3 uf uy) ==> preserve_relation_mmu (f2 >>= (λy. constT (x,y))) i2 i3 uf uy``, REPEAT STRIP_TAC THEN ASSUME_TAC (SPEC ``i3:arm_state->bool`` constT_preserves_relation_thm) THEN UNDISCH_ALL_TAC - THEN RW_TAC (srw_ss()) [seqT_def,constT_def,preserve_relation_mmu_def,preserve_relation_mmu_abs_def] + THEN RW_TAC (srw_ss()) [seqT_def,constT_def,preserve_relation_mmu_def,preserve_relation_mmu_abs_def] THEN (UNDISCH_ALL_TAC THEN REPEAT (CASE_TAC THEN FULL_SIMP_TAC (srw_ss()) [])) THEN FIRST_PROVE [ RW_TAC (srw_ss()) [] @@ -700,7 +700,7 @@ val parT_latter_part_hlem = store_thm ( THEN FULL_SIMP_TAC (srw_ss()) [] THEN (`access_violation b = access_violation b'` by METIS_TAC [similar_def]) THEN FULL_SIMP_TAC (srw_ss()) [], - RW_TAC (srw_ss()) [] + RW_TAC (srw_ss()) [] THEN FULL_SIMP_TAC (srw_ss()) [] THEN Cases_on `f2 s1` THEN Cases_on `f2 s2` @@ -765,7 +765,7 @@ val parT_preserves_relation_uu_thm = store_thm("parT_preserves_relation_uu_thm", `` ! f1 f2 k uf uy. (trans_fun uf) ==> (preserve_relation_mmu f1 (assert_mode k) (assert_mode k) uf uy) ==> - (preserve_relation_mmu f2 (assert_mode k) (assert_mode k) uf uy) ==> + (preserve_relation_mmu f2 (assert_mode k) (assert_mode k) uf uy) ==> (preserve_relation_mmu (parT f1 f2) (assert_mode k) (assert_mode k) uf uy) ``, REPEAT STRIP_TAC THEN IMP_RES_TAC parT_latter_part_hlem @@ -816,50 +816,50 @@ val comb_monot_thm = store_thm("comb_monot_thm", val preserve_relation_comb_thm1 = store_thm ("preserve_relation_comb_thm1", - ``! a b c d f uf uy. + ``! a b c d f uf uy. preserve_relation_mmu f d a uf uy ==> comb a b c ==> preserve_relation_mmu f d c uf uy``, - RW_TAC (srw_ss()) [preserve_relation_mmu_def,comb_def] - THEN PAT_ASSUM ``∀g s1 s2. X`` + RW_TAC (srw_ss()) [preserve_relation_mmu_def,comb_def] + THEN PAT_ASSUM ``∀g s1 s2. X`` (fn thm => ASSUME_TAC (SPECL [``g:bool[32]``, ``s1:arm_state``, ``s2:arm_state``] thm)) THEN RES_TAC - THEN RW_TAC (srw_ss()) []); + THEN RW_TAC (srw_ss()) []); val preserve_relation_comb_v2_thm = store_thm ("preserve_relation_comb_v2_thm", - ``! a b c d f uf uy. + ``! a b c d f uf uy. preserve_relation_mmu f d a uf uy ==> comb a b c ==> preserve_relation_mmu f d c uf uy``, - RW_TAC (srw_ss()) [preserve_relation_mmu_def,comb_def] - THEN PAT_ASSUM ``∀g s1 s2. X`` + RW_TAC (srw_ss()) [preserve_relation_mmu_def,comb_def] + THEN PAT_ASSUM ``∀g s1 s2. X`` (fn thm => ASSUME_TAC (SPECL [``g:bool[32]``, ``s1:arm_state``, ``s2:arm_state``] thm)) THEN RES_TAC - THEN RW_TAC (srw_ss()) []); + THEN RW_TAC (srw_ss()) []); val preserve_relation_comb_abs_thm = store_thm ("preserve_relation_comb_abs_thm", ``! a b c d f uf uy. preserve_relation_mmu_abs f d b uf uy ==> comb a b c ==> preserve_relation_mmu_abs f d c uf uy``, - RW_TAC (srw_ss()) [preserve_relation_mmu_abs_def,comb_def] - THEN PAT_ASSUM ``∀ c g s1 s2. X`` + RW_TAC (srw_ss()) [preserve_relation_mmu_abs_def,comb_def] + THEN PAT_ASSUM ``∀ c g s1 s2. X`` (fn thm => ASSUME_TAC (SPECL [``c':'a``,``g:bool[32]``, ``s1:arm_state``, ``s2:arm_state``] thm)) THEN RES_TAC - THEN RW_TAC (srw_ss()) []); + THEN RW_TAC (srw_ss()) []); val comb_mode_def = Define `comb_mode m n k s = (assert_mode m s \/ assert_mode n s \/ assert_mode k s)`; val comb_mode_def = Define `comb_mode m n s = (assert_mode m s \/ assert_mode n s)`; -val comb_mode_thm = +val comb_mode_thm = store_thm ("comb_mode_thm", ``! m n. comb (assert_mode m) (assert_mode n) (comb_mode m n)``, RW_TAC (srw_ss()) [ assert_mode_def,comb_mode_def,comb_def]); @@ -868,10 +868,10 @@ RW_TAC (srw_ss()) [ assert_mode_def,comb_mode_def,comb_def]); (********* 3-parts-lem *********) -val keep_mode_relation_def = Define `keep_mode_relation comp i1 i2 = +val keep_mode_relation_def = Define `keep_mode_relation comp i1 i2 = (!g s s' x. (mmu_requirements s g) ==> (i1 s) ==> (comp s = ValueState x s') ==> (i2 s'))`; -val keep_similar_relation_def = Define `keep_similar_relation comp invr1 y = +val keep_similar_relation_def = Define `keep_similar_relation comp invr1 y = !g s1 s2. mmu_requirements s1 g ==> mmu_requirements s2 g ==> @@ -929,9 +929,9 @@ val comb_gen_lem = store_thm( val constT_unit_preserving_lem = store_thm( "constT_unit_preserving_lem", - ``!invr:(arm_state->bool) uf uy. (reflexive_comp uf invr) ==> + ``!invr:(arm_state->bool) uf uy. (reflexive_comp uf invr) ==> preserve_relation_mmu (constT ()) invr invr uf uy``, - RW_TAC (srw_ss()) [constT_def, preserve_relation_mmu_def, untouched_def, similar_def,reflexive_comp_def] THEN + RW_TAC (srw_ss()) [constT_def, preserve_relation_mmu_def, untouched_def, similar_def,reflexive_comp_def] THEN (RW_TAC (srw_ss()) [] )); @@ -939,10 +939,10 @@ val constT_unit_preserving_lem = store_thm( val SEQT_UNTOUCHED_TAC = UNDISCH_ALL_TAC THEN RW_TAC (srw_ss()) [seqT_def, keep_untouched_relation_def, trans_fun_def] - THEN UNDISCH_ALL_TAC + THEN UNDISCH_ALL_TAC THEN REPEAT (CASE_TAC THEN FULL_SIMP_TAC (srw_ss()) []) - THEN UNDISCH_ALL_TAC - THEN RW_TAC (srw_ss()) [] + THEN UNDISCH_ALL_TAC + THEN RW_TAC (srw_ss()) [] THEN FULL_SIMP_TAC (srw_ss()) [] THEN IMP_RES_TAC untouched_mmu_setup_lem THEN RES_TAC @@ -954,14 +954,14 @@ val SEQT_UNTOUCHED_TAC = val forT_untouching_thm = store_thm( "forT_untouching_thm", - ``!f k uf uy. + ``!f k uf uy. (trans_fun uf) ==> (reflexive_comp uf (assert_mode k)) ==> (!a. keep_untouched_relation (f a) (assert_mode k) uf) ==> (!a. keep_mode_relation (f a) (assert_mode k) (assert_mode k)) ==> (!l h. keep_untouched_relation (forT l h f) (assert_mode k) uf)``, REPEAT STRIP_TAC - THEN Induct_on `h - l` + THEN Induct_on `h - l` THENL [FULL_SIMP_TAC (srw_ss()) [] THEN REPEAT STRIP_TAC THEN NTAC 2 (PURE_ONCE_REWRITE_TAC [forT_def, LET_DEF]) @@ -991,8 +991,8 @@ val SEQT_PRESERVE_TAC = fn F1 => THEN Cases_on [QUOTE (F1^" s2")] THEN RES_TAC THEN RW_TAC (srw_ss()) [] - THEN FULL_SIMP_TAC (srw_ss()) [] - THEN (`access_violation b = access_violation b'` by METIS_TAC [similar_def]) + THEN FULL_SIMP_TAC (srw_ss()) [] + THEN (`access_violation b = access_violation b'` by METIS_TAC [similar_def]) THEN FULL_SIMP_TAC (srw_ss()) [] THEN RW_TAC (srw_ss()) [] THEN `mmu_requirements b g` by METIS_TAC [untouched_mmu_setup_lem] @@ -1006,8 +1006,8 @@ val SEQT_PRESERVE_BEGIN_TAC = fn F1 => THEN Cases_on [QUOTE (F1^" s2")] THEN RES_TAC THEN RW_TAC (srw_ss()) [] - THEN FULL_SIMP_TAC (srw_ss()) [] - THEN (`access_violation b = access_violation b'` by METIS_TAC [similar_def]) + THEN FULL_SIMP_TAC (srw_ss()) [] + THEN (`access_violation b = access_violation b'` by METIS_TAC [similar_def]) THEN FULL_SIMP_TAC (srw_ss()) [] THEN RW_TAC (srw_ss()) [] THEN `mmu_requirements b g` by METIS_TAC [untouched_mmu_setup_lem] @@ -1015,14 +1015,14 @@ val SEQT_PRESERVE_BEGIN_TAC = fn F1 => val forT_similar_thm = store_thm( "forT_similar_thm", - ``!f k uf uy. + ``!f k uf uy. (!a. keep_untouched_relation (f a) (assert_mode k) uf) ==> (!a. keep_mode_relation (f a) (assert_mode k) (assert_mode k)) ==> (!a. keep_similar_relation (f a) (assert_mode k) uy) ==> (!l h. keep_similar_relation (forT l h f) (assert_mode k) uy)``, REPEAT STRIP_TAC THEN IMP_RES_TAC forT_untouching_thm - THEN Induct_on `h - l` + THEN Induct_on `h - l` THENL [FULL_SIMP_TAC (srw_ss()) [] THEN (REPEAT STRIP_TAC) THEN (NTAC 2 (PURE_ONCE_REWRITE_TAC [forT_def, LET_DEF])) @@ -1046,7 +1046,7 @@ val forT_similar_thm = store_thm( THEN SEQT_PRESERVE_BEGIN_TAC "f l" THEN Cases_on `forT (l + 1) h f b` THEN Cases_on `forT (l + 1) h f b'` - THEN FULL_SIMP_TAC (srw_ss()) [] + THEN FULL_SIMP_TAC (srw_ss()) [] THEN PAT_ASSUM ``∀g s1 s2. mmu_requirements s1 g ⇒ mmu_requirements s2 g ⇒ similar g s1 s2 ⇒ @@ -1069,12 +1069,12 @@ val forT_similar_thm = store_thm( val forT_mode_thm = store_thm( "forT_mode_thm", - ``!f k uf. + ``!f k uf. (!a. keep_untouched_relation (f a) (assert_mode k) uf) ==> (!a. keep_mode_relation (f a) (assert_mode k) (assert_mode k)) ==> (!l h. keep_mode_relation (forT l h f) (assert_mode k) (assert_mode k))``, REPEAT STRIP_TAC - THEN Induct_on `h - l` + THEN Induct_on `h - l` THENL [FULL_SIMP_TAC (srw_ss()) [] THEN REPEAT STRIP_TAC THEN NTAC 2 (PURE_ONCE_REWRITE_TAC [forT_def, LET_DEF]) @@ -1083,10 +1083,10 @@ val forT_mode_thm = store_thm( THEN REPEAT STRIP_TAC THEN UNDISCH_ALL_TAC THEN RW_TAC (srw_ss()) [seqT_def, keep_mode_relation_def] - THEN UNDISCH_ALL_TAC + THEN UNDISCH_ALL_TAC THEN REPEAT (CASE_TAC THEN FULL_SIMP_TAC (srw_ss()) []) - THEN UNDISCH_ALL_TAC - THEN RW_TAC (srw_ss()) [] + THEN UNDISCH_ALL_TAC + THEN RW_TAC (srw_ss()) [] THEN FULL_SIMP_TAC (srw_ss()) [] THEN RES_TAC THEN FULL_SIMP_TAC (srw_ss()) [], @@ -1100,10 +1100,10 @@ val forT_mode_thm = store_thm( THEN REPEAT (PAT_ASSUM (``!(l:num). X``) (fn th => (ASSUME_TAC (SPEC ``l:num`` th)))) THEN UNDISCH_ALL_TAC THEN RW_TAC (srw_ss()) [seqT_def, keep_mode_relation_def] - THEN UNDISCH_ALL_TAC + THEN UNDISCH_ALL_TAC THEN REPEAT (CASE_TAC THEN FULL_SIMP_TAC (srw_ss()) []) - THEN UNDISCH_ALL_TAC - THEN RW_TAC (srw_ss()) [] + THEN UNDISCH_ALL_TAC + THEN RW_TAC (srw_ss()) [] THEN RES_TAC THEN FULL_SIMP_TAC (srw_ss()) [keep_untouched_relation_def] THEN RES_TAC @@ -1114,7 +1114,7 @@ val forT_mode_thm = store_thm( val forT_preserves_user_relation_thm = store_thm( "forT_preserves_user_relation_thm", - ``!f k uf uy. + ``!f k uf uy. (trans_fun uf) ==> (refl_rel uy) ==> (reflexive_comp uf (assert_mode k)) @@ -1125,7 +1125,7 @@ val forT_preserves_user_relation_thm = store_thm( val forT_preserving_thm = store_thm( "forT_preserving_thm", - ``!f k uf uy. + ``!f k uf uy. (trans_fun uf) ==> (refl_rel uy) ==> (reflexive_comp uf (assert_mode k)) @@ -1137,13 +1137,13 @@ val forT_preserving_thm = store_thm( (********* errorT *********) -val errorT_thm = +val errorT_thm = store_thm("errorT_thm", ``! inv s uf1 uy1. preserve_relation_mmu (errorT s) inv inv uf1 uy1 ``, (RW_TAC (srw_ss()) [preserve_relation_mmu_def,similar_def, assert_mode_def,errorT_def,untouched_def])); -val errorT_comb_thm = +val errorT_comb_thm = store_thm("errorT_comb_thm", ``! inv1 inv2 s uf1 uy1. preserve_relation_mmu (errorT s) inv1 inv2 uf1 uy1 ``, (RW_TAC (srw_ss()) [preserve_relation_mmu_def,similar_def, diff --git a/examples/ARM_security_properties/model/arm_seq_monadScript.sml b/examples/ARM_security_properties/model/arm_seq_monadScript.sml index 4c26d90423..abd955861f 100644 --- a/examples/ARM_security_properties/model/arm_seq_monadScript.sml +++ b/examples/ARM_security_properties/model/arm_seq_monadScript.sml @@ -108,7 +108,7 @@ new_constant("access_violation", ``:arm_state -> bool``); val seqT_def = Define` (* new seqT *) (seqT: 'a M -> ('a -> 'b M) -> 'b M) s f = \y. case s y of Error e => Error e - | ValueState z t => + | ValueState z t => ( if (access_violation t) then (ValueState ARB t) diff --git a/examples/ARM_security_properties/switching_lemma_helperScript.sml b/examples/ARM_security_properties/switching_lemma_helperScript.sml index 2ee5fbadb0..670ce07d71 100644 --- a/examples/ARM_security_properties/switching_lemma_helperScript.sml +++ b/examples/ARM_security_properties/switching_lemma_helperScript.sml @@ -10,32 +10,32 @@ val _ = new_theory("switching_lemma_helper"); (* Narges *) (****************************************************************) -val get_security_ext_def = - Define `get_security_ext s = +val get_security_ext_def = + Define `get_security_ext s = (((ARMarch2num s.information.arch = 5) ∨ (ARMarch2num s.information.arch = 7)) ∧ Extension_Security ∈ s.information.extensions)`; -val vector_table_address_def = - Define ` vector_table_address (ExcVectorBase:bool[32]) (mode:bool[5]) = +val vector_table_address_def = + Define ` vector_table_address (ExcVectorBase:bool[32]) (mode:bool[5]) = if (mode = 17w:bool[5]) then [ExcVectorBase + 28w] -else if (mode = 18w:bool[5]) -then +else if (mode = 18w:bool[5]) +then [ExcVectorBase + 24w] -else if (mode = 19w:bool[5]) +else if (mode = 19w:bool[5]) then [ExcVectorBase + 8w] -else if (mode = 23w:bool[5]) +else if (mode = 23w:bool[5]) then [ExcVectorBase + 16w; ExcVectorBase + 12w] -else (*if (mode = 27w)*) +else (*if (mode = 27w)*) [ExcVectorBase + 4w] `; -val get_pc_value_def = -Define `get_pc_value s1 = +val get_pc_value_def = +Define `get_pc_value s1 = let is = (if (s1.psrs (0,CPSR)).J then 2 + if (s1.psrs (0,CPSR)).T then 1 else 0 else if (s1.psrs (0,CPSR)).T then @@ -69,19 +69,19 @@ let is = (if (s1.psrs (0,CPSR)).J then (* val get_base_vector_table_def = Define `get_base_vector_table y = - if (y.coprocessors.state.cp15.SCTLR.V) + if (y.coprocessors.state.cp15.SCTLR.V) then 0xFFFF0000w else if - (((ARMarch2num y.information.arch = 5) + (((ARMarch2num y.information.arch = 5) ∨ - (ARMarch2num y.information.arch = 7)) + (ARMarch2num y.information.arch = 7)) ∧ Extension_Security ∈ y.information.extensions) then (if - (¬y.coprocessors.state.cp15.SCR.NS + (¬y.coprocessors.state.cp15.SCR.NS ∨ ((y.psrs (0,CPSR)).M = 22w)) then @@ -93,19 +93,19 @@ val get_base_vector_table_def = *) val get_base_vector_table_def = Define `get_base_vector_table y = - if (y.coprocessors.state.cp15.SCTLR.V) + if (y.coprocessors.state.cp15.SCTLR.V) then 0xFFFF0000w else if - (((ARMarch2num y.information.arch = 5) + (((ARMarch2num y.information.arch = 5) ∨ - (ARMarch2num y.information.arch = 7)) + (ARMarch2num y.information.arch = 7)) ∧ Extension_Security ∈ y.information.extensions) then (if - (¬y.coprocessors.state.cp15.SCR.NS + (¬y.coprocessors.state.cp15.SCR.NS ∨ ((y.psrs (0,CPSR)).M = 22w)) then @@ -116,18 +116,18 @@ val get_base_vector_table_def = 0w:word32`; -fun define_pfc_goal a expr = +fun define_pfc_goal a expr = set_goal([], `` (priv_flags_constraints ^a ^expr) ``); - -fun define_pfc_goal_abs a expr = + +fun define_pfc_goal_abs a expr = set_goal([], `` (priv_flags_constraints_abs ^a ^expr) ``); - + val const_comp_def = Define `const_comp G = (!s s' x. ((G s = ValueState x s') ==> (s=s')))`; -val read_reg_constlem = +val read_reg_constlem = store_thm( "read_reg_constlem", ``!n. const_comp (read_reg <|proc:=0|> n)``, @@ -135,39 +135,39 @@ val read_reg_constlem = THEN EVAL_TAC THEN (REPEAT (RW_TAC (srw_ss()) [] THEN FULL_SIMP_TAC (srw_ss()) [] THEN UNDISCH_ALL_TAC - + THEN RW_TAC (srw_ss()) []))); -val read_sctlr_constlem = +val read_sctlr_constlem = store_thm( "read_sctlr_constlem", ``const_comp (read_sctlr <|proc:=0|> )``, FULL_SIMP_TAC (srw_ss()) [const_comp_def] - THEN EVAL_TAC + THEN EVAL_TAC THEN (REPEAT (RW_TAC (srw_ss()) [] THEN FULL_SIMP_TAC (srw_ss()) [] THEN UNDISCH_ALL_TAC THEN RW_TAC (srw_ss()) []))); -val read_scr_constlem = +val read_scr_constlem = store_thm( "read_scr_constlem", ``const_comp (read_scr <|proc:=0|> )``, FULL_SIMP_TAC (srw_ss()) [const_comp_def] - THEN EVAL_TAC - THEN (REPEAT + THEN EVAL_TAC + THEN (REPEAT (RW_TAC (srw_ss()) [] THEN FULL_SIMP_TAC (srw_ss()) [] THEN UNDISCH_ALL_TAC THEN RW_TAC (srw_ss()) []))); - -val exc_vector_base_constlem = + +val exc_vector_base_constlem = store_thm( "exc_vector_base_constlem", ``const_comp (exc_vector_base <|proc:=0|> )``, FULL_SIMP_TAC (srw_ss()) [const_comp_def] - THEN EVAL_TAC + THEN EVAL_TAC THEN RW_TAC (srw_ss()) [] THEN NTAC 2 (UNDISCH_ALL_TAC THEN RW_TAC (srw_ss()) [])); @@ -176,10 +176,10 @@ val exc_vector_base_constlem = val read_cpsr_quintuple_par_effect_lem = store_thm( "read_cpsr_quintule_par_effect_lem", ``!s A B C D H . (const_comp A) ==> (const_comp B) ==> (const_comp C) ==> - ((((A ||| B ||| C ||| read_cpsr <|proc:=0|> ||| D) >>= (\ (a, b, c, cpsr, d). H (a, b, c, cpsr, d))) s) + ((((A ||| B ||| C ||| read_cpsr <|proc:=0|> ||| D) >>= (\ (a, b, c, cpsr, d). H (a, b, c, cpsr, d))) s) = (((A ||| B ||| C ||| read_cpsr <|proc:=0|> ||| D) >>= (\ (a, b, c, cpsr, d). H (a, b, c, (s.psrs (0, CPSR)), d))) s))``, RW_TAC (srw_ss()) [parT_def, seqT_def, constT_def] - THEN Cases_on `A s` + THEN Cases_on `A s` THEN FULL_SIMP_TAC (srw_ss()) [const_comp_def] THEN Cases_on `B b` THEN FULL_SIMP_TAC (srw_ss()) [const_comp_def] @@ -192,7 +192,7 @@ val read_cpsr_quintuple_par_effect_lem = store_thm( val cpsr_quintuple_simp_lem = store_thm( "cpsr_quintuple_simp_lem", - ``!s a n m H . (assert_mode 16w s) ==> + ``!s a n m H . (assert_mode 16w s) ==> ((((read_reg <|proc:=0|> a ||| read_reg <|proc:=0|> n ||| read_reg <|proc:=0|> m ||| read_cpsr <|proc:=0|> ||| read_teehbr <|proc:=0|>) >>= (\ (a, b, c, cpsr, d). H (a, b, c, cpsr, d))) s) = (((read_reg <|proc:=0|> a ||| read_reg <|proc:=0|> n ||| read_reg <|proc:=0|> m ||| read_cpsr <|proc:=0|> ||| read_teehbr <|proc:=0|>) >>= (\ (a, b, c, cpsr, d). H (a, b, c, ((s.psrs (0, CPSR)) with M := 16w), d))) s))``, RW_TAC (srw_ss()) [assert_mode_def, ARM_MODE_def, read_reg_constlem, read_cpsr_quintuple_par_effect_lem, ARM_READ_CPSR_def] @@ -203,10 +203,10 @@ val cpsr_quintuple_simp_lem = store_thm( val read_cpsr_quintuple_par_effect_with_16_lem = store_thm( "read_cpsr_quintule_par_effect_with_16_lem", ``!s A B C D H . (const_comp A) ==> (const_comp B) ==> (const_comp C) ==> - ((((A ||| B ||| C ||| read_cpsr <|proc:=0|> ||| D) >>= (\ (a, b, c, cpsr, d). H (a, b, c, (cpsr with M := 16w), d))) s) + ((((A ||| B ||| C ||| read_cpsr <|proc:=0|> ||| D) >>= (\ (a, b, c, cpsr, d). H (a, b, c, (cpsr with M := 16w), d))) s) = (((A ||| B ||| C ||| read_cpsr <|proc:=0|> ||| D) >>= (\ (a, b, c, cpsr, d). H (a, b, c, ((s.psrs (0, CPSR)) with M := 16w), d))) s))``, RW_TAC (srw_ss()) [parT_def, seqT_def, constT_def] - THEN Cases_on `A s` + THEN Cases_on `A s` THEN FULL_SIMP_TAC (srw_ss()) [const_comp_def] THEN Cases_on `B b` THEN FULL_SIMP_TAC (srw_ss()) [const_comp_def] @@ -220,7 +220,7 @@ val read_cpsr_quintuple_par_effect_with_16_lem = store_thm( val cpsr_quintuple_simp_rel_lem = store_thm( "cpsr_quintuple_simp_rel_lem", - ``!a n m H inv2 uf uy. + ``!a n m H inv2 uf uy. (preserve_relation_mmu ((read_reg <|proc:=0|> a ||| read_reg <|proc:=0|> n ||| read_reg <|proc:=0|> m ||| read_cpsr <|proc:=0|> ||| read_teehbr <|proc:=0|>) >>= (\ (pc, b, c, cpsr, d). H (pc, b, c, cpsr, d))) (assert_mode 16w) (inv2) uf uy) = (preserve_relation_mmu ((read_reg <|proc:=0|> a ||| read_reg <|proc:=0|> n ||| read_reg <|proc:=0|> m ||| read_cpsr <|proc:=0|> ||| read_teehbr <|proc:=0|>) >>= (\ (pc, b, c, cpsr, d). H (pc, b, c, (cpsr with M := 16w), d))) (assert_mode 16w) (inv2) uf uy)``, RW_TAC (srw_ss()) [cpsr_quintuple_simp_lem, preserve_relation_mmu_def, read_reg_constlem, read_cpsr_quintuple_par_effect_with_16_lem]); @@ -228,16 +228,16 @@ val cpsr_quintuple_simp_rel_lem = store_thm( val read_cpsr_quintuple_par_effect_lem2 = store_thm( "read_cpsr_quintule_par_effect_lem2", - ``!s A B D E H . (const_comp A) ==> (const_comp B) ==> - ((((A ||| B ||| read_cpsr <|proc:=0|> ||| D ||| E) >>= (\ (a, b, cpsr, d, e). H (a, b, cpsr, d, e))) s) + ``!s A B D E H . (const_comp A) ==> (const_comp B) ==> + ((((A ||| B ||| read_cpsr <|proc:=0|> ||| D ||| E) >>= (\ (a, b, cpsr, d, e). H (a, b, cpsr, d, e))) s) = (((A ||| B ||| read_cpsr <|proc:=0|> ||| D ||| E) >>= (\ (a, b, cpsr, d, e). H (a, b, (s.psrs (0, CPSR)), d, e))) s))``, RW_TAC (srw_ss()) [parT_def, seqT_def, constT_def] - THEN Cases_on `A s` + THEN Cases_on `A s` THEN FULL_SIMP_TAC (srw_ss()) [const_comp_def] THEN Cases_on `B b` THEN FULL_SIMP_TAC (srw_ss()) [const_comp_def] THEN RES_TAC - THEN RW_TAC (srw_ss()) [read_cpsr_def, read__psr_def, constT_def, arm_seq_monadTheory.readT_def] + THEN RW_TAC (srw_ss()) [read_cpsr_def, read__psr_def, constT_def, arm_seq_monadTheory.readT_def] THEN Cases_on `D b` THEN FULL_SIMP_TAC (srw_ss()) [const_comp_def] THEN Cases_on `E b'` @@ -245,16 +245,16 @@ val read_cpsr_quintuple_par_effect_lem2 = store_thm( val read_cpsr_quintuple_par_effect_with_16_lem2 = store_thm( "read_cpsr_quintule_par_effect_with_16_lem2", - ``!s A B D E H . (const_comp A) ==> (const_comp B) ==> - ((((A ||| B ||| read_cpsr <|proc:=0|> ||| D ||| E) >>= (\ (a, b, cpsr, d, e). H (a, b, (cpsr with M := 16w), d, e))) s) + ``!s A B D E H . (const_comp A) ==> (const_comp B) ==> + ((((A ||| B ||| read_cpsr <|proc:=0|> ||| D ||| E) >>= (\ (a, b, cpsr, d, e). H (a, b, (cpsr with M := 16w), d, e))) s) = (((A ||| B ||| read_cpsr <|proc:=0|> ||| D ||| E) >>= (\ (a, b, cpsr, d, e). H (a, b, ((s.psrs (0, CPSR)) with M := 16w), d, e))) s))``, RW_TAC (srw_ss()) [parT_def, seqT_def, constT_def] - THEN Cases_on `A s` + THEN Cases_on `A s` THEN FULL_SIMP_TAC (srw_ss()) [const_comp_def] THEN Cases_on `B b` THEN FULL_SIMP_TAC (srw_ss()) [const_comp_def] THEN RES_TAC - THEN RW_TAC (srw_ss()) [read_cpsr_def, read__psr_def, constT_def, arm_seq_monadTheory.readT_def] + THEN RW_TAC (srw_ss()) [read_cpsr_def, read__psr_def, constT_def, arm_seq_monadTheory.readT_def] THEN Cases_on `D b` THEN FULL_SIMP_TAC (srw_ss()) [const_comp_def] THEN Cases_on `E b'` @@ -263,7 +263,7 @@ val read_cpsr_quintuple_par_effect_with_16_lem2 = store_thm( val cpsr_quintuple_simp_lem2 = store_thm( "cpsr_quintuple_simp_lem2", - ``!s x H . (assert_mode 16w s) ==> + ``!s x H . (assert_mode 16w s) ==> ((((read_reg <|proc:=0|> x ||| exc_vector_base <|proc:=0|> ||| read_cpsr <|proc:=0|> ||| read_scr <|proc:=0|> ||| read_sctlr <|proc:=0|>) >>= (\ (a, b, cpsr, d, e). H (a, b, cpsr, d, e))) s) = (((read_reg <|proc:=0|> x ||| exc_vector_base <|proc:=0|> ||| read_cpsr <|proc:=0|> ||| read_scr <|proc:=0|> ||| read_sctlr <|proc:=0|>) >>= (\ (a, b, cpsr, d, e). H (a, b, ((s.psrs (0, CPSR)) with M := 16w), d, e))) s))``, RW_TAC (srw_ss()) [assert_mode_def, ARM_MODE_def, read_reg_constlem, exc_vector_base_constlem, read_cpsr_quintuple_par_effect_lem2, ARM_READ_CPSR_def] @@ -282,7 +282,7 @@ val cpsr_quintuple_simp_rel_lem2 = store_thm( val read_cpsr_effect_lem = store_thm( "read_cpsr_effect_lem", ``!s H . ((read_cpsr <|proc:=0|> >>= (\ (cpsr). H (cpsr))) s = (read_cpsr <|proc:=0|> >>= (\ (cpsr). H (s.psrs (0, CPSR)))) s)``, - RW_TAC (srw_ss()) [parT_def, seqT_def, constT_def] + RW_TAC (srw_ss()) [parT_def, seqT_def, constT_def] THEN FULL_SIMP_TAC (srw_ss()) [] THEN RES_TAC THEN RW_TAC (srw_ss()) [read_cpsr_def, read__psr_def, constT_def, arm_seq_monadTheory.readT_def]); @@ -290,7 +290,7 @@ val read_cpsr_effect_lem = store_thm( val cpsr_simp_lem = store_thm( "cpsr_simp_lem", - ``!s H u. (assert_mode u s) ==> + ``!s H u. (assert_mode u s) ==> (((read_cpsr <|proc:=0|> >>= (\ (cpsr). H (cpsr))) s) = ((read_cpsr <|proc:=0|> >>= (\ (cpsr). H (cpsr with M := u))) s))``, RW_TAC (srw_ss()) [assert_mode_def, ARM_MODE_def, read_cpsr_effect_lem, ARM_READ_CPSR_def] @@ -299,7 +299,7 @@ val cpsr_simp_lem = store_thm( val cpsr_simp_rel_lem = store_thm( "cpsr_simp_rel_lem", - ``!H inv2 uf uy u. + ``!H inv2 uf uy u. (preserve_relation_mmu (read_cpsr <|proc:=0|> >>= (\ (cpsr). H (cpsr))) (assert_mode u) (inv2) uf uy) = (preserve_relation_mmu (read_cpsr <|proc:=0|> >>= (\ (cpsr). H (cpsr with M := u)))(assert_mode u) (inv2) uf uy)``, RW_TAC (srw_ss()) [preserve_relation_mmu_def] @@ -307,127 +307,127 @@ val cpsr_simp_rel_lem = store_thm( (* End of borrowed theorems *) -val read_cpsr_constlem = +val read_cpsr_constlem = store_thm( "read_cpsr_constlem", ``const_comp (read_cpsr <|proc:=0|> )``, FULL_SIMP_TAC (srw_ss()) [const_comp_def] - THEN EVAL_TAC + THEN EVAL_TAC THEN (REPEAT (RW_TAC (srw_ss()) [] THEN FULL_SIMP_TAC (srw_ss()) [] THEN UNDISCH_ALL_TAC THEN RW_TAC (srw_ss()) []))); -val parT_const_comp_thm = +val parT_const_comp_thm = store_thm( - "parT_const_comp_thm", + "parT_const_comp_thm", ``! f h. const_comp f ==> const_comp h ==> const_comp (f ||| h)`` , RW_TAC (srw_ss()) [parT_def,seqT_def,const_comp_def,constT_def] THEN - Cases_on ` f s ` THEN - RES_TAC THEN - FULL_SIMP_TAC (srw_ss()) [] THEN - Cases_on ` h b ` THEN - RES_TAC THEN - FULL_SIMP_TAC (srw_ss()) [] THEN - RW_TAC (srw_ss()) [] THEN - Cases_on ` access_violation b` THEN + Cases_on ` f s ` THEN + RES_TAC THEN + FULL_SIMP_TAC (srw_ss()) [] THEN + Cases_on ` h b ` THEN + RES_TAC THEN + FULL_SIMP_TAC (srw_ss()) [] THEN + RW_TAC (srw_ss()) [] THEN + Cases_on ` access_violation b` THEN FULL_SIMP_TAC (srw_ss()) []); -val fixed_sctrl_undef_svc_thm1 = +val fixed_sctrl_undef_svc_thm1 = store_thm( "fixed_sctrl_undef_svc_thm1", - ``!s A B C D H . - (const_comp A) ==> + ``!s A B C D H . + (const_comp A) ==> (const_comp B) ==> (const_comp C) ==> (const_comp D) ==> - ((((A ||| B ||| C ||| D + ((((A ||| B ||| C ||| D ||| read_sctlr <|proc:=0|>) >>= (\ (a, b, c, d, e). H (a, b, c, d, e))) s) - = (((A ||| B ||| C ||| D ||| - read_sctlr <|proc:=0|>) >>= + = (((A ||| B ||| C ||| D ||| + read_sctlr <|proc:=0|>) >>= (\ (a, b, c, d, e). H (a, b, c, d, s.coprocessors.state.cp15.SCTLR))) s)) ``, RW_TAC (srw_ss()) [parT_def, seqT_def, constT_def] - THEN Cases_on `A s` + THEN Cases_on `A s` THEN FULL_SIMP_TAC (srw_ss()) [const_comp_def] THEN RES_TAC - THEN Cases_on `B s` + THEN Cases_on `B s` THEN FULL_SIMP_TAC (srw_ss()) [const_comp_def] THEN RES_TAC - THEN Cases_on `C s` + THEN Cases_on `C s` THEN FULL_SIMP_TAC (srw_ss()) [const_comp_def] THEN RES_TAC - THEN Cases_on `D s` + THEN Cases_on `D s` THEN FULL_SIMP_TAC (srw_ss()) [const_comp_def] THEN RES_TAC THEN FULL_SIMP_TAC (srw_ss()) [read_sctlr_def,arm_seq_monadTheory.readT_def] THEN RW_TAC (srw_ss()) [] ); -val fixed_cpsr_undef_svc_thm1 = +val fixed_cpsr_undef_svc_thm1 = store_thm( "fixed_cpsr_undef_svc_thm1", - ``!s A B C D H . - (const_comp A) ==> + ``!s A B C D H . + (const_comp A) ==> (const_comp B) ==> ((((A ||| B ||| read_cpsr <|proc := 0|> ||| C ||| D) >>= (\ (a, b, c, d, e). H (a, b, c, d, e))) s) - = (((A ||| B ||| read_cpsr <|proc := 0|> ||| C ||| D) >>= + = (((A ||| B ||| read_cpsr <|proc := 0|> ||| C ||| D) >>= (\ (a, b, c, d, e). H (a, b, s.psrs (0,CPSR), d, e))) s)) ``, RW_TAC (srw_ss()) [parT_def, seqT_def, constT_def] - THEN Cases_on `A s` + THEN Cases_on `A s` THEN FULL_SIMP_TAC (srw_ss()) [const_comp_def] THEN RES_TAC - THEN Cases_on `B s` + THEN Cases_on `B s` THEN FULL_SIMP_TAC (srw_ss()) [const_comp_def] THEN RES_TAC THEN FULL_SIMP_TAC (srw_ss()) [read_cpsr_def,read__psr_def,arm_seq_monadTheory.readT_def] THEN RW_TAC (srw_ss()) [] - THEN Cases_on `C b` + THEN Cases_on `C b` THEN Cases_on ` access_violation b'` THEN FULL_SIMP_TAC (srw_ss()) [] - THEN Cases_on `D b'` + THEN Cases_on `D b'` THEN Cases_on ` access_violation b''` THEN FULL_SIMP_TAC (srw_ss()) [] - + ); -val fixed_sctrl_abt_irq_thm1 = +val fixed_sctrl_abt_irq_thm1 = store_thm( "fixed_sctrl_abt_irq_thm1", - ``!s A B C D E H . - (const_comp A) ==> + ``!s A B C D E H . + (const_comp A) ==> (const_comp B) ==> (const_comp C) ==> (const_comp D) ==> (const_comp E) ==> - ((((A ||| B ||| C ||| D ||| E + ((((A ||| B ||| C ||| D ||| E ||| read_sctlr <|proc:=0|>) >>= (\ (a, b, c, d, e,f). H (a, b, c, d, e,f))) s) - = (((A ||| B ||| C ||| D ||| E ||| - read_sctlr <|proc:=0|>) >>= + = (((A ||| B ||| C ||| D ||| E ||| + read_sctlr <|proc:=0|>) >>= (\ (a, b, c, d, e,f). H (a, b, c, d, e, s.coprocessors.state.cp15.SCTLR))) s)) ``, RW_TAC (srw_ss()) [parT_def, seqT_def, constT_def] - THEN Cases_on `A s` + THEN Cases_on `A s` THEN FULL_SIMP_TAC (srw_ss()) [const_comp_def] THEN RES_TAC - THEN Cases_on `B s` + THEN Cases_on `B s` THEN FULL_SIMP_TAC (srw_ss()) [const_comp_def] THEN RES_TAC - THEN Cases_on `C s` + THEN Cases_on `C s` THEN FULL_SIMP_TAC (srw_ss()) [const_comp_def] THEN RES_TAC - THEN Cases_on `D s` + THEN Cases_on `D s` THEN FULL_SIMP_TAC (srw_ss()) [const_comp_def] THEN RES_TAC - THEN Cases_on `E s` + THEN Cases_on `E s` THEN FULL_SIMP_TAC (srw_ss()) [const_comp_def] THEN RES_TAC THEN FULL_SIMP_TAC (srw_ss()) [read_sctlr_def,arm_seq_monadTheory.readT_def] @@ -456,7 +456,7 @@ val fixed_undef_svc_exception_rp_thm2 = store_thm( THEN RW_TAC (srw_ss()) [] ); - + val fixed_abort_irq_exception_rp_thm2 = store_thm( "fixed_abort_irq_exception_rp_thm2", ``!s f e d c b a . @@ -481,7 +481,7 @@ val fixed_abort_irq_exception_rp_thm2 = store_thm( EVAL_TAC THEN RW_TAC (srw_ss()) []); -val have_security_ext_constlem = +val have_security_ext_constlem = store_thm( "have_security_ext_constlem", ``const_comp (have_security_ext <|proc := 0|>)``, @@ -489,30 +489,30 @@ val have_security_ext_constlem = THEN EVAL_TAC THEN (REPEAT (RW_TAC (srw_ss()) [] THEN FULL_SIMP_TAC (srw_ss()) [] THEN UNDISCH_ALL_TAC - + THEN RW_TAC (srw_ss()) []))); -val const_comp_take_undef_svc_exception_rp_thm = +val const_comp_take_undef_svc_exception_rp_thm = store_thm( - "const_comp_take_undef_svc_exception_rp_thm", + "const_comp_take_undef_svc_exception_rp_thm", ``const_comp (read_reg <|proc := 0|> 15w ||| exc_vector_base <|proc := 0|> ||| read_cpsr <|proc := 0|> ||| read_scr <|proc := 0|> ||| read_sctlr <|proc := 0|>)``, - ASSUME_TAC (SPEC ``15w:bool[4]`` read_reg_constlem) + ASSUME_TAC (SPEC ``15w:bool[4]`` read_reg_constlem) THEN ASSUME_TAC read_cpsr_constlem THEN ASSUME_TAC exc_vector_base_constlem THEN ASSUME_TAC read_scr_constlem THEN ASSUME_TAC read_sctlr_constlem - THEN + THEN `const_comp (read_scr <|proc := 0|> - ||| read_sctlr <|proc := 0|>)` by + ||| read_sctlr <|proc := 0|>)` by IMP_RES_TAC parT_const_comp_thm THEN `const_comp ( read_cpsr <|proc := 0|> ||| read_scr <|proc := 0|> ||| read_sctlr <|proc := 0|>)` by IMP_RES_TAC parT_const_comp_thm - THEN + THEN `const_comp (exc_vector_base <|proc := 0|> ||| read_cpsr <|proc := 0|> ||| read_scr <|proc := 0|> ||| read_sctlr <|proc := 0|>)` by @@ -525,39 +525,39 @@ val const_comp_take_undef_svc_exception_rp_thm = by IMP_RES_TAC parT_const_comp_thm); - -val const_comp_take_abort_irq_exception_rp_thm = + +val const_comp_take_abort_irq_exception_rp_thm = store_thm( - "const_comp_take_abort_irq_exception_rp_thm", + "const_comp_take_abort_irq_exception_rp_thm", ``const_comp (read_reg <|proc := 0|> 15w ||| exc_vector_base <|proc := 0|> ||| have_security_ext <|proc := 0|> ||| read_cpsr <|proc := 0|> ||| read_scr <|proc := 0|> ||| read_sctlr <|proc := 0|>)``, - ASSUME_TAC (SPEC ``15w:bool[4]`` read_reg_constlem) + ASSUME_TAC (SPEC ``15w:bool[4]`` read_reg_constlem) THEN ASSUME_TAC read_cpsr_constlem THEN ASSUME_TAC exc_vector_base_constlem THEN ASSUME_TAC read_scr_constlem THEN ASSUME_TAC have_security_ext_constlem THEN ASSUME_TAC read_sctlr_constlem - THEN + THEN `const_comp (read_scr <|proc := 0|> - ||| read_sctlr <|proc := 0|>)` by + ||| read_sctlr <|proc := 0|>)` by IMP_RES_TAC parT_const_comp_thm THEN `const_comp ( read_cpsr <|proc := 0|> ||| read_scr <|proc := 0|> ||| read_sctlr <|proc := 0|>)` by IMP_RES_TAC parT_const_comp_thm - THEN + THEN `const_comp (have_security_ext <|proc := 0|> ||| read_cpsr <|proc := 0|> ||| read_scr <|proc := 0|> ||| read_sctlr <|proc := 0|>)` by IMP_RES_TAC parT_const_comp_thm THEN `const_comp (exc_vector_base <|proc := 0|> - ||| have_security_ext <|proc := 0|> ||| + ||| have_security_ext <|proc := 0|> ||| read_cpsr <|proc := 0|> ||| read_scr <|proc := 0|> ||| read_sctlr <|proc := 0|>)` - by IMP_RES_TAC parT_const_comp_thm + by IMP_RES_TAC parT_const_comp_thm THEN METIS_TAC [parT_const_comp_thm]); @@ -578,7 +578,7 @@ val fixed_undef_svc_exception_rp_thm3 = store_thm( read_sctlr <|proc:=0|>) >>= (\ (a, b, c, d, e). H ( get_pc_value s, - get_base_vector_table s, + get_base_vector_table s, s.psrs (0,CPSR ) with M := 16w , s.coprocessors.state.cp15.SCR, s.coprocessors.state.cp15.SCTLR))) s))``, @@ -599,12 +599,12 @@ val fixed_abt_irq_exception_rp_thm3 = store_thm( read_sctlr <|proc:=0|>) >>= (\ (a, b, c, d, e,f). (H: (bool[32]#bool[32]#bool#ARMpsr#CP15scr#CP15sctlr -> unit M)) (a, b, c, d, e,f))) s) - = (((read_reg <|proc:=0|> 15w ||| exc_vector_base <|proc:=0|> ||| have_security_ext <|proc := 0|> ||| + = (((read_reg <|proc:=0|> 15w ||| exc_vector_base <|proc:=0|> ||| have_security_ext <|proc := 0|> ||| read_cpsr <|proc:=0|> ||| read_scr <|proc:=0|> ||| read_sctlr <|proc:=0|>) >>= (\ (a, b, c, d, e,f). H ( get_pc_value s, - get_base_vector_table s, + get_base_vector_table s, get_security_ext s, s.psrs (0,CPSR ) with M := 16w , s.coprocessors.state.cp15.SCR, @@ -622,86 +622,86 @@ val fixed_VectorBase_undef_instr_exception_thm1 = store_thm( ``! e d c b a s. (~access_violation s) ==> (* (Extension_Security ∉ s.information.extensions) ==> *) - (((read_reg <|proc:=0|> 15w ||| exc_vector_base <|proc:=0|> ||| - read_cpsr <|proc:=0|> ||| read_scr <|proc:=0|> ||| + (((read_reg <|proc:=0|> 15w ||| exc_vector_base <|proc:=0|> ||| + read_cpsr <|proc:=0|> ||| read_scr <|proc:=0|> ||| read_sctlr <|proc:=0|>) s) = ValueState (a, b, c, d, e) s) ==> (b=get_base_vector_table s)``, EVAL_TAC - THEN RW_TAC (srw_ss()) [] + THEN RW_TAC (srw_ss()) [] ); val fixed_VectorBase_undef_instr_exception_thm2 = store_thm( "fixed_VectorBase_undef_instr_exception_thm2", ``!s H. (~access_violation s) ==> - ((((read_reg <|proc:=0|> 15w ||| exc_vector_base <|proc:=0|> ||| - read_cpsr <|proc:=0|> ||| read_scr <|proc:=0|> ||| + ((((read_reg <|proc:=0|> 15w ||| exc_vector_base <|proc:=0|> ||| + read_cpsr <|proc:=0|> ||| read_scr <|proc:=0|> ||| read_sctlr <|proc:=0|>) >>= (\ (a, b, c, d, e). (H: (bool[32]#bool[32]#ARMpsr#CP15scr#CP15sctlr -> unit M)) (a, b, c, d, e))) s) - = (((read_reg <|proc:=0|> 15w ||| exc_vector_base <|proc:=0|> ||| - read_cpsr <|proc:=0|> ||| read_scr <|proc:=0|> ||| + = (((read_reg <|proc:=0|> 15w ||| exc_vector_base <|proc:=0|> ||| + read_cpsr <|proc:=0|> ||| read_scr <|proc:=0|> ||| read_sctlr <|proc:=0|>) >>= (\ (a, b, c, d, e). H ( - a , (get_base_vector_table s) + a , (get_base_vector_table s) , - c, + c, d, e))) s))``, EVAL_TAC - THEN RW_TAC (srw_ss()) [] - + THEN RW_TAC (srw_ss()) [] + ); val fixed_VectorBase_abort_irq_exception_thm1 = store_thm( "fixed_VectorBase_abort_irq_exception_thm1", ``! f e d c b a s. (~access_violation s) ==> - (((read_reg <|proc:=0|> 15w ||| exc_vector_base <|proc:=0|> ||| - have_security_ext <|proc:=0|> ||| - read_cpsr <|proc:=0|> ||| read_scr <|proc:=0|> ||| + (((read_reg <|proc:=0|> 15w ||| exc_vector_base <|proc:=0|> ||| + have_security_ext <|proc:=0|> ||| + read_cpsr <|proc:=0|> ||| read_scr <|proc:=0|> ||| read_sctlr <|proc:=0|>) s) = ValueState (a, b, c, d, e,f) s) ==> (b=get_base_vector_table s )``, EVAL_TAC - THEN RW_TAC (srw_ss()) [] + THEN RW_TAC (srw_ss()) [] ); val fixed_VectorBase_abort_irq_exception_thm2 = store_thm( "fixed_VectorBase_abort_irq_exception_thm2", ``!s H. (~access_violation s) ==> - ((((read_reg <|proc:=0|> 15w ||| exc_vector_base <|proc:=0|> ||| - have_security_ext <|proc:=0|> ||| - read_cpsr <|proc:=0|> ||| read_scr <|proc:=0|> ||| + ((((read_reg <|proc:=0|> 15w ||| exc_vector_base <|proc:=0|> ||| + have_security_ext <|proc:=0|> ||| + read_cpsr <|proc:=0|> ||| read_scr <|proc:=0|> ||| read_sctlr <|proc:=0|>) >>= (\ (a, b, c, d, e,f). (H: (bool[32]#bool[32]#bool#ARMpsr#CP15scr#CP15sctlr -> unit M)) (a, b, c, d, e,f))) s) - = (((read_reg <|proc:=0|> 15w ||| exc_vector_base <|proc:=0|> ||| - have_security_ext <|proc:=0|> ||| - read_cpsr <|proc:=0|> ||| read_scr <|proc:=0|> ||| + = (((read_reg <|proc:=0|> 15w ||| exc_vector_base <|proc:=0|> ||| + have_security_ext <|proc:=0|> ||| + read_cpsr <|proc:=0|> ||| read_scr <|proc:=0|> ||| read_sctlr <|proc:=0|>) >>= (\ (a, b, c, d, e,f). H ( - a ,(get_base_vector_table s) + a ,(get_base_vector_table s) , - c, + c, d, e, f))) s))``, EVAL_TAC - THEN RW_TAC (srw_ss()) [] - + THEN RW_TAC (srw_ss()) [] + ); - -val fixed_sctrl_undef_svc_thm2 = + +val fixed_sctrl_undef_svc_thm2 = store_thm( "fixed_sctrl_undef_svc_thm2", - ``!s e d c b a. + ``!s e d c b a. (~access_violation s) ==> (((read_reg <|proc:=0|> 15w ||| - exc_vector_base <|proc:=0|> ||| + exc_vector_base <|proc:=0|> ||| read_cpsr <|proc:=0|> ||| read_scr <|proc:=0|> ||| read_sctlr <|proc:=0|>) s) = ValueState (a, b, c, d, e) s) ==> (e = s.coprocessors.state.cp15.SCTLR) ``, @@ -709,19 +709,19 @@ val fixed_sctrl_undef_svc_thm2 = ASSUME_TAC (SPEC ``15w:bool[4]`` read_reg_constlem) THEN ASSUME_TAC exc_vector_base_constlem THEN ASSUME_TAC read_cpsr_constlem THEN - ASSUME_TAC read_scr_constlem + ASSUME_TAC read_scr_constlem THEN FULL_SIMP_TAC (srw_ss()) [const_comp_def] - THEN Cases_on `read_reg <|proc:=0|> 15w s` + THEN Cases_on `read_reg <|proc:=0|> 15w s` THEN FULL_SIMP_TAC (srw_ss()) [] THEN RES_TAC THEN RW_TAC (srw_ss()) [] - THEN Cases_on `exc_vector_base <|proc:=0|> b'` + THEN Cases_on `exc_vector_base <|proc:=0|> b'` THEN RW_TAC (srw_ss()) [const_comp_def] THEN RES_TAC - THEN Cases_on `read_cpsr <|proc:=0|> b'` + THEN Cases_on `read_cpsr <|proc:=0|> b'` THEN RW_TAC (srw_ss()) [const_comp_def] THEN RES_TAC - THEN Cases_on `read_scr <|proc:=0|> b'` + THEN Cases_on `read_scr <|proc:=0|> b'` THEN RW_TAC (srw_ss()) [const_comp_def] THEN RES_TAC THEN FULL_SIMP_TAC (srw_ss()) [read_sctlr_def,readT_def] @@ -730,16 +730,16 @@ val fixed_sctrl_undef_svc_thm2 = THEN FULL_SIMP_TAC (srw_ss()) [read_sctlr_def,readT_def] THEN RW_TAC (srw_ss()) []); - -val fixed_sctrl_abt_irq_thm2 = + +val fixed_sctrl_abt_irq_thm2 = store_thm( "fixed_sctrl_abt_irq_thm2", - ``!s f e d c b a. + ``!s f e d c b a. (~access_violation s) ==> (((read_reg <|proc:=0|> 15w ||| - exc_vector_base <|proc:=0|> - ||| have_security_ext <|proc:=0|> ||| + exc_vector_base <|proc:=0|> + ||| have_security_ext <|proc:=0|> ||| read_cpsr <|proc:=0|> ||| read_scr <|proc:=0|> ||| read_sctlr <|proc:=0|>) s) = ValueState (a, b, c, d, e,f) s) ==> (f = s.coprocessors.state.cp15.SCTLR) ``, @@ -748,22 +748,22 @@ val fixed_sctrl_abt_irq_thm2 = ASSUME_TAC exc_vector_base_constlem THEN ASSUME_TAC read_cpsr_constlem THEN ASSUME_TAC read_scr_constlem THEN - ASSUME_TAC have_security_ext_constlem + ASSUME_TAC have_security_ext_constlem THEN FULL_SIMP_TAC (srw_ss()) [const_comp_def] - THEN Cases_on `read_reg <|proc:=0|> 15w s` + THEN Cases_on `read_reg <|proc:=0|> 15w s` THEN FULL_SIMP_TAC (srw_ss()) [] THEN RES_TAC THEN RW_TAC (srw_ss()) [] - THEN Cases_on `exc_vector_base <|proc:=0|> b'` + THEN Cases_on `exc_vector_base <|proc:=0|> b'` THEN RW_TAC (srw_ss()) [const_comp_def] THEN RES_TAC - THEN Cases_on `read_cpsr <|proc:=0|> b'` + THEN Cases_on `read_cpsr <|proc:=0|> b'` THEN RW_TAC (srw_ss()) [const_comp_def] THEN RES_TAC - THEN Cases_on `read_scr <|proc:=0|> b'` + THEN Cases_on `read_scr <|proc:=0|> b'` THEN RW_TAC (srw_ss()) [const_comp_def] THEN RES_TAC - THEN Cases_on `have_security_ext <|proc:=0|> b'` + THEN Cases_on `have_security_ext <|proc:=0|> b'` THEN RW_TAC (srw_ss()) [const_comp_def] THEN RES_TAC THEN FULL_SIMP_TAC (srw_ss()) [read_sctlr_def,readT_def] @@ -776,35 +776,35 @@ val fixed_sctrl_abt_irq_thm2 = val fixed_sctrl_undef_svc_thm = store_thm( "fixed_sctrl_undef_svc_thm", - ``!s H . + ``!s H . ((((read_reg <|proc:=0|> 15w ||| exc_vector_base <|proc:=0|> ||| - read_cpsr <|proc:=0|> ||| read_scr <|proc:=0|> ||| + read_cpsr <|proc:=0|> ||| read_scr <|proc:=0|> ||| read_sctlr <|proc:=0|>) >>= (\ (pc,ExcVectorBase,cpsr,scr,sctlr). H (pc,ExcVectorBase,cpsr,scr,sctlr))) s) - = + = (((read_reg <|proc:=0|> 15w ||| exc_vector_base <|proc:=0|> ||| - read_cpsr <|proc:=0|> ||| read_scr <|proc:=0|> ||| read_sctlr <|proc:=0|>) >>= + read_cpsr <|proc:=0|> ||| read_scr <|proc:=0|> ||| read_sctlr <|proc:=0|>) >>= (\(pc,ExcVectorBase,cpsr,scr,sctlr). H (pc,ExcVectorBase,cpsr,scr, s.coprocessors.state.cp15.SCTLR))) s))``, - MP_TAC (SPEC ``15w:bool[4]`` read_reg_constlem) + MP_TAC (SPEC ``15w:bool[4]`` read_reg_constlem) THEN MP_TAC read_cpsr_constlem THEN MP_TAC exc_vector_base_constlem THEN MP_TAC read_scr_constlem THEN RW_TAC (srw_ss()) [fixed_sctrl_undef_svc_thm1] ); -val fixed_cpsr_undef_svc_thm = +val fixed_cpsr_undef_svc_thm = store_thm ("fixed_cpsr_undef_svc_thm", - ``!s H . + ``!s H . ((((read_reg <|proc:=0|> 15w ||| exc_vector_base <|proc:=0|> ||| - read_cpsr <|proc:=0|> ||| read_scr <|proc:=0|> ||| - read_sctlr <|proc:=0|>) >>= + read_cpsr <|proc:=0|> ||| read_scr <|proc:=0|> ||| + read_sctlr <|proc:=0|>) >>= (\ (pc,ExcVectorBase,cpsr,scr,sctlr). H (pc,ExcVectorBase,cpsr,scr,sctlr))) s) - = (((read_reg <|proc:=0|> 15w ||| + = (((read_reg <|proc:=0|> 15w ||| exc_vector_base <|proc:=0|> ||| - read_cpsr <|proc:=0|> ||| - read_scr <|proc:=0|> ||| - read_sctlr <|proc:=0|>) >>= + read_cpsr <|proc:=0|> ||| + read_scr <|proc:=0|> ||| + read_sctlr <|proc:=0|>) >>= (\ (pc,ExcVectorBase,cpsr,scr,sctlr). H (pc,ExcVectorBase,s.psrs (0,CPSR),scr,sctlr))) s))``, MP_TAC (SPEC ``15w:bool[4]`` read_reg_constlem) THEN MP_TAC read_cpsr_constlem @@ -816,18 +816,18 @@ val fixed_cpsr_undef_svc_thm = val fixed_sctrl_abt_irq_thm = store_thm( "fixed_sctrl_abt_irq_thm", - ``!s H . + ``!s H . ((((read_reg <|proc:=0|> 15w ||| exc_vector_base <|proc:=0|> ||| have_security_ext <|proc := 0|> ||| - read_cpsr <|proc:=0|> ||| read_scr <|proc:=0|> ||| + read_cpsr <|proc:=0|> ||| read_scr <|proc:=0|> ||| read_sctlr <|proc:=0|>) >>= (\ (pc,ExcVectorBase,have_security_ext1,cpsr,scr,sctlr). H (pc,ExcVectorBase,have_security_ext1,cpsr,scr,sctlr))) s) - = + = (((read_reg <|proc:=0|> 15w ||| exc_vector_base <|proc:=0|> ||| have_security_ext <|proc := 0|> ||| - read_cpsr <|proc:=0|> ||| read_scr <|proc:=0|> ||| read_sctlr <|proc:=0|>) >>= + read_cpsr <|proc:=0|> ||| read_scr <|proc:=0|> ||| read_sctlr <|proc:=0|>) >>= (\(pc,ExcVectorBase,have_security_ext1,cpsr,scr,sctlr). H (pc,ExcVectorBase,have_security_ext1,cpsr,scr, s.coprocessors.state.cp15.SCTLR))) s))``, - MP_TAC (SPEC ``15w:bool[4]`` read_reg_constlem) + MP_TAC (SPEC ``15w:bool[4]`` read_reg_constlem) THEN MP_TAC read_cpsr_constlem THEN MP_TAC exc_vector_base_constlem THEN MP_TAC read_scr_constlem @@ -838,10 +838,10 @@ val fixed_sctrl_abt_irq_thm = store_thm( val read_cpsr_quintuple_par_effect_lem1 = store_thm( "read_cpsr_quintule_par_effect_lem1", ``!s A B C D H . (const_comp A) ==> (const_comp B) ==> (const_comp C) ==> - ((((A ||| B ||| C ||| read_cpsr <|proc:=0|> ||| D ||| E) >>= (\ (a, b, c, cpsr, d,e). H (a, b, c, cpsr, d,e))) s) + ((((A ||| B ||| C ||| read_cpsr <|proc:=0|> ||| D ||| E) >>= (\ (a, b, c, cpsr, d,e). H (a, b, c, cpsr, d,e))) s) = (((A ||| B ||| C ||| read_cpsr <|proc:=0|> ||| D ||| E) >>= (\ (a, b, c, cpsr, d,e). H (a, b, c, (s.psrs (0, CPSR)), d,e))) s))``, RW_TAC (srw_ss()) [parT_def, seqT_def, constT_def] - THEN Cases_on `A s` + THEN Cases_on `A s` THEN FULL_SIMP_TAC (srw_ss()) [const_comp_def] THEN Cases_on `B b` THEN FULL_SIMP_TAC (srw_ss()) [const_comp_def] @@ -858,41 +858,41 @@ val read_cpsr_quintuple_par_effect_lem1 = store_thm( val fixed_cpsr_abt_irq_thm = store_thm( "fixed_cpsr_abt_irq_thm", - ``!s H . + ``!s H . ((((read_reg <|proc:=0|> 15w ||| - exc_vector_base <|proc:=0|> ||| + exc_vector_base <|proc:=0|> ||| have_security_ext <|proc := 0|> ||| - read_cpsr <|proc:=0|> ||| read_scr <|proc:=0|> ||| - read_sctlr <|proc:=0|>) >>= - (\ (pc,ExcVectorBase,have_security_ext1,cpsr,scr,sctlr). + read_cpsr <|proc:=0|> ||| read_scr <|proc:=0|> ||| + read_sctlr <|proc:=0|>) >>= + (\ (pc,ExcVectorBase,have_security_ext1,cpsr,scr,sctlr). H (pc,ExcVectorBase,have_security_ext1,cpsr,scr,sctlr))) s) - = (((read_reg <|proc:=0|> 15w ||| - exc_vector_base <|proc:=0|> ||| + = (((read_reg <|proc:=0|> 15w ||| + exc_vector_base <|proc:=0|> ||| have_security_ext <|proc := 0|> ||| - read_cpsr <|proc:=0|> ||| - read_scr <|proc:=0|> ||| - read_sctlr <|proc:=0|>) >>= - (\ (pc,ExcVectorBase,have_security_ext1,cpsr,scr,sctlr). + read_cpsr <|proc:=0|> ||| + read_scr <|proc:=0|> ||| + read_sctlr <|proc:=0|>) >>= + (\ (pc,ExcVectorBase,have_security_ext1,cpsr,scr,sctlr). H (pc,ExcVectorBase,have_security_ext1,s.psrs (0,CPSR),scr,sctlr))) s))``, RW_TAC (srw_ss()) [read_reg_constlem, exc_vector_base_constlem, have_security_ext_constlem, read_cpsr_quintuple_par_effect_lem1, ARM_READ_CPSR_def] ); -val fixed_cpsr_undef_svc_thm2 = +val fixed_cpsr_undef_svc_thm2 = store_thm("fixed_cpsr_undef_svc_thm2", - ``!s a b c d e. + ``!s a b c d e. (~access_violation s) ==> (((read_reg <|proc:=0|> 15w ||| - exc_vector_base <|proc:=0|> ||| + exc_vector_base <|proc:=0|> ||| read_cpsr <|proc:=0|> ||| read_scr <|proc:=0|> ||| read_sctlr <|proc:=0|>) s) = ValueState (a, b, c, d, e) s) ==> (c = s.psrs (0,CPSR)) ``, RW_TAC (srw_ss()) [fixed_undef_svc_exception_rp_thm2]); -val fixed_cpsr_abt_irq_thm2 = +val fixed_cpsr_abt_irq_thm2 = store_thm("fixed_cpsr_abt_irq_thm2", - ``!s a b c d e f. + ``!s a b c d e f. (~access_violation s) ==> (((read_reg <|proc := 0|> 15w ||| exc_vector_base <|proc := 0|> ||| have_security_ext <|proc := 0|> ||| read_cpsr <|proc := 0|> @@ -903,24 +903,24 @@ val fixed_cpsr_abt_irq_thm2 = RW_TAC (srw_ss()) [fixed_abort_irq_exception_rp_thm2]); -val fixed_pc_undef_svc_thm2 = +val fixed_pc_undef_svc_thm2 = store_thm("fixed_pc_undef_svc_thm2", - ``!s a b c d e. + ``!s a b c d e. (~access_violation s) ==> (((read_reg <|proc:=0|> 15w ||| - exc_vector_base <|proc:=0|> ||| + exc_vector_base <|proc:=0|> ||| read_cpsr <|proc:=0|> ||| read_scr <|proc:=0|> ||| read_sctlr <|proc:=0|>) s) = ValueState (a, b, c, d, e) s) ==> (a = get_pc_value s)``, RW_TAC (srw_ss()) [fixed_undef_svc_exception_rp_thm2]); -val fixed_pc_abt_irq_thm2 = +val fixed_pc_abt_irq_thm2 = store_thm("fixed_pc_abt_irq_thm2", - ``!s a b c d e f. + ``!s a b c d e f. (~access_violation s) ==> (((read_reg <|proc:=0|> 15w ||| exc_vector_base <|proc:=0|> -||| have_security_ext <|proc := 0|> ||| +||| have_security_ext <|proc := 0|> ||| read_cpsr <|proc:=0|> ||| read_scr <|proc:=0|> ||| read_sctlr <|proc:=0|>) s) = ValueState (a, b, c, d, e,f) s) ==> (a = get_pc_value s)`` @@ -951,24 +951,24 @@ store_thm ("hlp_errorT_thm", THEN FULL_SIMP_TAC (srw_ss()) [] ); -val seqT_access_violation_thm = -store_thm ("seqT_access_violation_thm", - ``! g f s a s' s'' a'. +val seqT_access_violation_thm = +store_thm ("seqT_access_violation_thm", + ``! g f s a s' s'' a'. ((g >>= f) s = ValueState a s') ⇒ (g s = ValueState a' s'') ==> ¬access_violation s' ⇒ (¬access_violation s'')``, RW_TAC (srw_ss()) [seqT_def] THEN FULL_SIMP_TAC (srw_ss()) [] - THEN Cases_on `access_violation s''` + THEN Cases_on `access_violation s''` THEN UNDISCH_ALL_TAC THEN RW_TAC (srw_ss()) [seqT_def] THEN FULL_SIMP_TAC (srw_ss()) [] ); -val parT_access_violation_thm = -store_thm ("parT_access_violation_thm", - ``! g f s a s' s'' a'. +val parT_access_violation_thm = +store_thm ("parT_access_violation_thm", + ``! g f s a s' s'' a'. ((g ||| f) s = ValueState a s') ⇒ (g s = ValueState a' s'') ==> ¬access_violation s' ⇒ @@ -976,7 +976,7 @@ store_thm ("parT_access_violation_thm", ``, RW_TAC (srw_ss()) [seqT_def,parT_def,constT_def] THEN FULL_SIMP_TAC (srw_ss()) [] - THEN Cases_on `access_violation s''` + THEN Cases_on `access_violation s''` THEN UNDISCH_ALL_TAC THEN RW_TAC (srw_ss()) [seqT_def] THEN FULL_SIMP_TAC (srw_ss()) [] @@ -985,18 +985,18 @@ store_thm ("parT_access_violation_thm", val const_comp_hlp_thm = store_thm("const_comp_hlp_thm", -``! f s s' a g. +``! f s s' a g. (const_comp f) ==> (f s = ValueState a s') ==> (~access_violation s) ==> ((f >>= g) s = g a s)`` , RW_TAC (srw_ss()) [const_comp_def,seqT_def] -THEN RES_TAC +THEN RES_TAC THEN FULL_SIMP_TAC (srw_ss()) [const_comp_def,seqT_def] ); -val hlp_seqT2_thm = +val hlp_seqT2_thm = store_thm ("hlp_seqT2_thm", ``!f g s a s' b s1 e. ((f >>= g) s = ValueState a s') ==> ((f s = ValueState b s1) ==> @@ -1009,9 +1009,9 @@ THEN Cases_on `f s` THEN FULL_SIMP_TAC (srw_ss()) [seqT_def] ); -val hlp_seqT3_thm = +val hlp_seqT3_thm = store_thm ("hlp_seqT3_thm", - ``!g f s e. + ``!g f s e. (f s = Error e) ==> ((f >>= g) s = Error e) ``, @@ -1019,9 +1019,9 @@ RW_TAC (srw_ss()) [seqT_def] ); -val hlp_seqT4_thm = +val hlp_seqT4_thm = store_thm ("hlp_seqT4_thm", - ``!f H s1 s2 s1' s2' a1 g invr1 invr2 uf uy. + ``!f H s1 s2 s1' s2' a1 g invr1 invr2 uf uy. (~access_violation s1') ==> (~access_violation s2') ==> (f s1 = ValueState a1 s1') ==> @@ -1033,14 +1033,14 @@ val hlp_seqT4_thm = (uy g s1' s2' )⇒ (invr1 s1' )⇒ (invr1 s2' )⇒ - ((?a s1'' s2''. ((f >>= H) s1 = ValueState a s1'') + ((?a s1'' s2''. ((f >>= H) s1 = ValueState a s1'') /\ ((f >>= H) s2 = ValueState a s2'')) \/ - (?e .((f >>= H) s1 = Error e) + (?e .((f >>= H) s1 = Error e) /\ ((f >>= H) s2 = Error e))) - + ``, RW_TAC (srw_ss()) [preserve_relation_mmu_abs_def,seqT_def] THEN RES_TAC @@ -1048,35 +1048,35 @@ val hlp_seqT4_thm = THEN FULL_SIMP_TAC (srw_ss()) [seqT_def] ); -val similar_states_have_same_pc_thm = +val similar_states_have_same_pc_thm = store_thm ("similar_states_have_same_pc_thm", - ``! s1 s2 g. + ``! s1 s2 g. similar g s1 s2 ==> (s2.registers (0,RName_PC)= s1.registers (0,RName_PC))``, RW_TAC (srw_ss()) [similar_def,equal_user_register_def] ); -val similar_states_have_same_cpsr_thm = +val similar_states_have_same_cpsr_thm = store_thm ("similar_states_have_same_cpsr_thm", - ``! s1 s2 g. + ``! s1 s2 g. similar g s1 s2 ==> (s2.psrs (0,CPSR)= s1.psrs (0,CPSR))``, RW_TAC (srw_ss()) [similar_def,equal_user_register_def] ); -val similar_states_have_same_mode_thm = +val similar_states_have_same_mode_thm = store_thm ("similar_states_have_same_mode_thm", - ``! u s1 s2 g. + ``! u s1 s2 g. similar g s1 s2 ==> ((s2.psrs (0,CPSR)).M = u) ⇒ ((s1.psrs (0,CPSR)).M = u)``, RW_TAC (srw_ss()) [similar_def] ); -val similar_states_have_same_av_thm1 = +val similar_states_have_same_av_thm1 = store_thm ("similar_states_have_same_av_thm1", - ``! s1 s2 g. + ``! s1 s2 g. similar g s1 s2 ==> ( ((~access_violation s2) ==> @@ -1088,36 +1088,36 @@ val similar_states_have_same_av_thm1 = RW_TAC (srw_ss()) [similar_def] ); -val similar_states_have_same_vec_tab_thm = +val similar_states_have_same_vec_tab_thm = store_thm ("similar_states_have_same_vec_tab_thm", - ``! s1 s2 g. + ``! s1 s2 g. similar g s1 s2 ==> ( get_base_vector_table s1 = - get_base_vector_table s2) + get_base_vector_table s2) ``, RW_TAC (srw_ss()) [similar_def, get_base_vector_table_def] ); -val similar_states_have_same_security_ext_thm = +val similar_states_have_same_security_ext_thm = store_thm ("similar_states_have_same_security_ext_thm", - ``! s1 s2 g. + ``! s1 s2 g. similar g s1 s2 ==> ( get_security_ext s1 = - get_security_ext s2) + get_security_ext s2) ``, RW_TAC (srw_ss()) [similar_def, get_security_ext_def] ); -val similar_states_have_same_read_pc_thm = +val similar_states_have_same_read_pc_thm = store_thm ("similar_states_have_same_read_pc_thm", - ``! s1 s2 g. + ``! s1 s2 g. similar g s1 s2 ==> ( get_pc_value s1 = - get_pc_value s2) + get_pc_value s2) ``, RW_TAC (srw_ss()) [similar_def, get_pc_value_def,equal_user_register_def] THEN UNABBREV_ALL_TAC @@ -1125,9 +1125,9 @@ val similar_states_have_same_read_pc_thm = THEN RW_TAC (srw_ss()) [] ); -val similar_states_have_same_av_thm2 = +val similar_states_have_same_av_thm2 = store_thm ("similar_states_have_same_av_thm2", - ``! s1 s2 g. + ``! s1 s2 g. similar g s1 s2 ==> ( ((access_violation s2) ==> @@ -1138,9 +1138,9 @@ val similar_states_have_same_av_thm2 = RW_TAC (srw_ss()) [similar_def] ); -val untouched_states_implies_mmu_setup_thm = +val untouched_states_implies_mmu_setup_thm = store_thm ("untouched_states_implies_mmu_setup_thm", - ``! s1 t g. + ``! s1 t g. untouched g s1 t ==> ((s1.coprocessors.state.cp15.C1 = t.coprocessors.state.cp15.C1) /\ @@ -1153,14 +1153,14 @@ val untouched_states_implies_mmu_setup_thm = (* only for arm_next: no svc constraints *) -val priv_mode_constraints_v1_def = +val priv_mode_constraints_v1_def = Define `priv_mode_constraints_v1 (g:bool[32]) (state0:arm_state) state1 = (state1.coprocessors.state.cp15 = - state0.coprocessors.state.cp15) + state0.coprocessors.state.cp15) /\ (state1.information = - state0.information) + state0.information) /\ ((state1.psrs (0, CPSR)).F = @@ -1176,10 +1176,10 @@ val priv_mode_constraints_v1_def = /\ ((ARM_MODE state1 = 16w) ==> -((state1.psrs (0, CPSR)).I = +((state1.psrs (0, CPSR)).I = (state0.psrs (0, CPSR)).I)) -/\ +/\ ((ARM_MODE state1 <> 16w) ==> (let spsr = get_spsr_by_mode (ARM_MODE state1) in @@ -1192,7 +1192,7 @@ val priv_mode_constraints_v1_def = ((state1.psrs (0, CPSR)).IT = 0w) /\ - ((state1.psrs (0, CPSR)).E = + ((state1.psrs (0, CPSR)).E = (state0.coprocessors.state.cp15.SCTLR.EE)) /\ @@ -1206,11 +1206,11 @@ val priv_mode_constraints_v1_def = /\ (* program point to the handler of exception/interrupt in the vector table*) -((state1.registers (0, RName_PC) = +((state1.registers (0, RName_PC) = (HD (vector_table_address (get_base_vector_table state0) ((state1.psrs (0, CPSR)).M)))) \/ -(state1.registers (0, RName_PC) = +(state1.registers (0, RName_PC) = (HD (TL (vector_table_address (get_base_vector_table state0) ((state1.psrs (0, CPSR)).M)))))) @@ -1225,37 +1225,37 @@ val priv_mode_constraints_v1_def = `; (* only for arm_next : svc based on pc of previous state *) -val priv_mode_constraints_v2_def = +val priv_mode_constraints_v2_def = Define `priv_mode_constraints_v2 (g:bool[32]) (state0:arm_state) state1 = priv_mode_constraints_v1 g state0 state1 /\ (* in svc mode, the link register is equal to old PC minus offset *) ((ARM_MODE state1 = 19w) ==> ((state1.registers (0, RName_LRsvc) = - (if (state0.psrs (0,CPSR)).T + (if (state0.psrs (0,CPSR)).T then get_pc_value(state0) -2w else - get_pc_value(state0) -4w + get_pc_value(state0) -4w )) /\ ((state1.psrs(0,SPSR_svc)) = (state0.psrs(0,CPSR))))) `; (* only for arm_next : svc based on pc of previous state *) -val priv_mode_constraints_v2a_def = +val priv_mode_constraints_v2a_def = Define `priv_mode_constraints_v2a (g:bool[32]) (state0:arm_state) state1 = priv_mode_constraints_v1 g state0 state1 /\ (* in svc mode, the link register is equal to old PC minus offset *) ((ARM_MODE state1 = 19w) ==> ((state1.registers (0, RName_LRsvc) = - (if (state0.psrs (0,CPSR)).T + (if (state0.psrs (0,CPSR)).T then get_pc_value(state0) -2w else - get_pc_value(state0) -4w + get_pc_value(state0) -4w )) - /\ ((state1.psrs(0,SPSR_svc)) = + /\ ((state1.psrs(0,SPSR_svc)) = if (((ARMarch2num state0.information.arch = 6) ∨ version_number state0.information.arch ≥ 7) /\ (((state0.psrs (0,CPSR)).IT = 0w) ∨ (state0.psrs (0,CPSR)).T)) @@ -1267,35 +1267,35 @@ priv_mode_constraints_v1 g state0 state1 (* svc based on the borders *) -val priv_mode_constraints_v3_def = +val priv_mode_constraints_v3_def = Define `priv_mode_constraints_v3 (g:bool[32]) (state0:arm_state) state1 = priv_mode_constraints_v2a g state0 state1 /\ ((ARM_MODE state1 = 19w) ==> ( ((g = guest1) ==> - ((((state1.psrs (0,SPSR_svc)).T) ==> (((state1.registers (0, RName_LRsvc) -2w) >=+ guest1_min_adr) /\ ((state1.registers (0, RName_LRsvc) -2w) <=+ guest1_max_adr))) - /\ ((((state1.psrs (0,SPSR_svc)).T = F) /\ ((state1.psrs (0,SPSR_svc)).J = F)) ==> (((state1.registers (0, RName_LRsvc) -4w) >=+ guest1_min_adr) /\ ((state1.registers (0, RName_LRsvc) -4w) <=+ guest1_max_adr))))) + ((((state1.psrs (0,SPSR_svc)).T) ==> (((state1.registers (0, RName_LRsvc) -2w) >=+ guest1_min_adr) /\ ((state1.registers (0, RName_LRsvc) -2w) <=+ guest1_max_adr))) + /\ ((((state1.psrs (0,SPSR_svc)).T = F) /\ ((state1.psrs (0,SPSR_svc)).J = F)) ==> (((state1.registers (0, RName_LRsvc) -4w) >=+ guest1_min_adr) /\ ((state1.registers (0, RName_LRsvc) -4w) <=+ guest1_max_adr))))) /\ ((g = guest2) ==> - ((((state1.psrs (0,SPSR_svc)).T) ==> (((state1.registers (0, RName_LRsvc) -2w) >=+ guest2_min_adr) /\ ((state1.registers (0, RName_LRsvc) -2w) <=+ guest2_max_adr))) - /\ ((((state1.psrs (0,SPSR_svc)).T = F) /\ ((state1.psrs (0,SPSR_svc)).J = F)) ==> (((state1.registers (0, RName_LRsvc) -4w) >=+ guest2_min_adr) /\ ((state1.registers (0, RName_LRsvc) -4w) <=+ guest2_max_adr))))) + ((((state1.psrs (0,SPSR_svc)).T) ==> (((state1.registers (0, RName_LRsvc) -2w) >=+ guest2_min_adr) /\ ((state1.registers (0, RName_LRsvc) -2w) <=+ guest2_max_adr))) + /\ ((((state1.psrs (0,SPSR_svc)).T = F) /\ ((state1.psrs (0,SPSR_svc)).J = F)) ==> (((state1.registers (0, RName_LRsvc) -4w) >=+ guest2_min_adr) /\ ((state1.registers (0, RName_LRsvc) -4w) <=+ guest2_max_adr))))) ))`; (* svc based on accessible bytes *) -val priv_mode_constraints_v4_def = - Define `priv_mode_constraints_v4 (g:bool[32]) (state0:arm_state) state1 = +val priv_mode_constraints_v4_def = + Define `priv_mode_constraints_v4 (g:bool[32]) (state0:arm_state) state1 = priv_mode_constraints_v2a g state0 state1 /\ ((ARM_MODE state1 = 19w) ==> ( - (((state1.psrs (0,SPSR_svc)).T) ==> aligned_word_readable state1 T (state1.registers (0, RName_LRsvc) -2w)) - /\ ((((state1.psrs (0,SPSR_svc)).T = F) /\ ((state1.psrs (0,SPSR_svc)).J = F)) ==> aligned_word_readable state1 F (state1.registers (0, RName_LRsvc) -4w)) + (((state1.psrs (0,SPSR_svc)).T) ==> aligned_word_readable state1 T (state1.registers (0, RName_LRsvc) -2w)) + /\ ((((state1.psrs (0,SPSR_svc)).T = F) /\ ((state1.psrs (0,SPSR_svc)).J = F)) ==> aligned_word_readable state1 F (state1.registers (0, RName_LRsvc) -4w)) ))`; -val satisfy_priv_constraints_v3_def = +val satisfy_priv_constraints_v3_def = Define `satisfy_priv_constraints_v3 f m n = - !g s1 s1' a . + !g s1 s1' a . mmu_requirements s1 g ⇒ (ARM_MODE s1 = m) ==> (ARM_MODE s1' = n) ==> @@ -1304,9 +1304,9 @@ Define `satisfy_priv_constraints_v3 f m n = (¬access_violation s1') ==> priv_mode_constraints_v3 g s1 s1'`; -val satisfy_priv_constraints_v2_def = +val satisfy_priv_constraints_v2_def = Define `satisfy_priv_constraints_v2 f m n = - !g s1 s1' a . + !g s1 s1' a . mmu_requirements s1 g ⇒ (ARM_MODE s1 = m) ==> (ARM_MODE s1' = n) ==> @@ -1315,9 +1315,9 @@ Define `satisfy_priv_constraints_v2 f m n = (¬access_violation s1') ==> priv_mode_constraints_v2 g s1 s1'`; -val satisfy_priv_constraints_v2a_def = +val satisfy_priv_constraints_v2a_def = Define `satisfy_priv_constraints_v2a f m n = - !g s1 s1' a . + !g s1 s1' a . mmu_requirements s1 g ⇒ (ARM_MODE s1 = m) ==> (ARM_MODE s1' = n) ==> @@ -1327,7 +1327,7 @@ Define `satisfy_priv_constraints_v2a f m n = priv_mode_constraints_v2a g s1 s1'`; -val IT_advance_untouch_mmu_setup_thm = +val IT_advance_untouch_mmu_setup_thm = store_thm ("IT_advance_untouch_mmu_setup_thm", ``!s a s'. (IT_advance <|proc := 0|> s = ValueState a s') ==> @@ -1345,7 +1345,7 @@ val IT_advance_untouch_mmu_setup_thm = ); -val IT_advance_keep_access_violation_thm = +val IT_advance_keep_access_violation_thm = store_thm ("IT_advance_keep_access_violation_thm", ``!s a s' g. mmu_requirements s g ==> ¬access_violation s ==> @@ -1354,20 +1354,20 @@ val IT_advance_keep_access_violation_thm = , RW_TAC (srw_ss()) [seqT_def] THEN IMP_RES_TAC IT_advance_untouch_mmu_setup_thm - THEN IMP_RES_TAC (SPECL [``s:arm_state``, - ``s':arm_state``, - ``g:bool[32]``] + THEN IMP_RES_TAC (SPECL [``s:arm_state``, + ``s':arm_state``, + ``g:bool[32]``] trivially_untouched_av_lem2) THEN UNDISCH_ALL_TAC THEN RW_TAC (srw_ss()) [] ); -val IT_advance_untouch_security_ex_thm = +val IT_advance_untouch_security_ex_thm = store_thm ("IT_advance_untouch_security_ex_thm", ``!y s. Extension_Security ∉ s.information.extensions ==> (IT_advance <|proc := 0|> s = ValueState a s') ==> - Extension_Security ∉ s'.information.extensions + Extension_Security ∉ s'.information.extensions `` , diff --git a/examples/ARM_security_properties/tacticsLib.sig b/examples/ARM_security_properties/tacticsLib.sig index f8daaf4e11..4e6c32a85e 100644 --- a/examples/ARM_security_properties/tacticsLib.sig +++ b/examples/ARM_security_properties/tacticsLib.sig @@ -18,15 +18,15 @@ sig val ASSUME_SIMP_TAC : Abbrev.thm list -> Abbrev.thm -> Abbrev.tactic val IMP_RES_SIMP_TAC : Abbrev.thm list -> Abbrev.thm -> Abbrev.tactic val ASSUME_SPEC_TAC : Thm.term -> Thm.thm -> Abbrev.tactic - val ASSUME_SPECL_SIMP_TAC + val ASSUME_SPECL_SIMP_TAC : Abbrev.term list -> Abbrev.thm list -> Abbrev.thm -> Abbrev.tactic val IMP_RES_SPEC_TAC : Thm.term -> Thm.thm -> Abbrev.tactic val IMP_RES_SPECL_TAC : Abbrev.term list -> Abbrev.thm -> Abbrev.tactic val MP_SPEC_TAC : Thm.term -> Thm.thm -> Abbrev.tactic val MP_SPECL_TAC : Abbrev.term list -> Abbrev.thm -> Abbrev.tactic - val ASSUME_SPECL_GEN_REWRITE_TAC + val ASSUME_SPECL_GEN_REWRITE_TAC : Abbrev.term list * Abbrev.thm * Abbrev.thm list -> Abbrev.tactic - val ASSUME_SPECL_INST_TAC + val ASSUME_SPECL_INST_TAC : Abbrev.term list -> (Thm.hol_type, Thm.hol_type) Lib.subst -> Thm.thm -> Abbrev.tactic diff --git a/examples/ARM_security_properties/tacticsLib.sml b/examples/ARM_security_properties/tacticsLib.sml index e23d5fa684..646480558d 100644 --- a/examples/ARM_security_properties/tacticsLib.sml +++ b/examples/ARM_security_properties/tacticsLib.sml @@ -29,42 +29,42 @@ val FORCE_REV_REWRITE_TAC = (fn thm => end); -val ASSUME_SPECL_TAC = +val ASSUME_SPECL_TAC = fn l => fn thm => ASSUME_TAC (SPECL l thm); -val ASSUME_SIMP_TAC = +val ASSUME_SIMP_TAC = fn l => fn thm => ASSUME_TAC (SIMP_RULE (srw_ss()) l thm); -val IMP_RES_SIMP_TAC = +val IMP_RES_SIMP_TAC = fn l => fn thm => IMP_RES_TAC (SIMP_RULE (srw_ss()) l thm); -val ASSUME_SPEC_TAC = +val ASSUME_SPEC_TAC = fn l => fn thm => ASSUME_TAC (SPEC l thm); -val ASSUME_SPECL_SIMP_TAC = +val ASSUME_SPECL_SIMP_TAC = fn l => fn sthms => fn thm => ASSUME_TAC (SPECL l (SIMP_RULE (srw_ss()) sthms thm)); -val IMP_RES_SPEC_TAC = +val IMP_RES_SPEC_TAC = fn l => fn thm => IMP_RES_TAC (SPEC l thm); -val IMP_RES_SPECL_TAC = +val IMP_RES_SPECL_TAC = fn l => fn thm => IMP_RES_TAC (SPECL l thm); -val MP_SPEC_TAC = +val MP_SPEC_TAC = fn l => fn thm => MP_TAC (SPEC l thm); -val MP_SPECL_TAC = +val MP_SPECL_TAC = fn l => fn thm => MP_TAC (SPECL l thm); -val ASSUME_SPECL_INST_TAC = +val ASSUME_SPECL_INST_TAC = fn sl => fn tl => fn thm => - ASSUME_TAC (SPECL sl (INST_TYPE tl thm)) + ASSUME_TAC (SPECL sl (INST_TYPE tl thm)) val ASSUME_SPECL_GEN_REWRITE_TAC = - fn (l , thm, simps) => ASSUME_TAC (SPECL + fn (l , thm, simps) => ASSUME_TAC (SPECL l (GEN_ALL (REWRITE_RULE simps thm))); end diff --git a/examples/ARM_security_properties/user_lemma_basicsScript.sml b/examples/ARM_security_properties/user_lemma_basicsScript.sml index e4594f80b4..4e570acd97 100644 --- a/examples/ARM_security_properties/user_lemma_basicsScript.sml +++ b/examples/ARM_security_properties/user_lemma_basicsScript.sml @@ -30,7 +30,7 @@ val untouched_refl = store_thm( val similarity_implies_equal_mode_thm = store_thm( - "similarity_implies_equal_mode_thm", + "similarity_implies_equal_mode_thm", ``! g s1 s2. (similar g s1 s2) ==> (ARM_MODE s1 = ARM_MODE s2)``, EVAL_TAC THEN RW_TAC (srw_ss()) [] @@ -39,7 +39,7 @@ val similarity_implies_equal_mode_thm = store_thm( val similarity_implies_equal_av_thm = store_thm( - "similarity_implies_equal_av_thm", + "similarity_implies_equal_av_thm", ``! g s1 s2. (similar g s1 s2) ==> (access_violation s1 = access_violation s2)``, EVAL_TAC THEN RW_TAC (srw_ss()) []); @@ -47,11 +47,11 @@ val similarity_implies_equal_av_thm = store_thm( val keep_mode_lem = store_thm( "keep_mode_lem", - ``!m f s s' x. + ``!m f s s' x. (ARM_MODE s = m) ==> (f s = ValueState x s') ==> (s.psrs = s'.psrs) - ==> + ==> (ARM_MODE s' = m)``, NTAC 5 STRIP_TAC THEN EVAL_TAC THEN METIS_TAC []); @@ -61,13 +61,13 @@ val untouched_av_on_coprocessor_update_lem = store_thm( "untouched_av_on_coprocessor_update_lem", ``!s gst. (mmu_requirements s gst) ==> (access_violation s = - access_violation ((arm_state_coprocessors_fupd -(Coprocessors_state_fupd (coproc_state_cp15_fupd (\cp15. cp15 with <| + access_violation ((arm_state_coprocessors_fupd +(Coprocessors_state_fupd (coproc_state_cp15_fupd (\cp15. cp15 with <| SCR := scr |>)))) s))``, (NTAC 2 STRIP_TAC) - THEN (`mmu_requirements ( (arm_state_coprocessors_fupd -(Coprocessors_state_fupd (coproc_state_cp15_fupd (\cp15. cp15 with <| -SCR := scr |>)))) s) gst = mmu_requirements s gst` by RW_TAC + THEN (`mmu_requirements ( (arm_state_coprocessors_fupd +(Coprocessors_state_fupd (coproc_state_cp15_fupd (\cp15. cp15 with <| +SCR := scr |>)))) s) gst = mmu_requirements s gst` by RW_TAC (srw_ss()) [mmu_requirements_def]) THEN REPEAT STRIP_TAC THEN RES_TAC @@ -103,26 +103,26 @@ val reflex_priv_mode_similar_thm = store_thm( val reflex_priv_mode_constraints_thm = store_thm("reflex_priv_mode_constraints_thm", - `` reflexive_comp priv_mode_constraints (assert_mode 16w)``, + `` reflexive_comp priv_mode_constraints (assert_mode 16w)``, RW_TAC (srw_ss()) [reflexive_comp_def,priv_mode_constraints_v1_def,assert_mode_def]); val reflex_priv_mode_constraints_v2_thm = store_thm("reflex_priv_mode_constraints_v2_thm", - `` reflexive_comp priv_mode_constraints_v2 (assert_mode 16w)``, + `` reflexive_comp priv_mode_constraints_v2 (assert_mode 16w)``, RW_TAC (srw_ss()) [reflexive_comp_def,priv_mode_constraints_v1_def, reflex_priv_mode_constraints_thm,priv_mode_constraints_v2_def,assert_mode_def] THEN FULL_SIMP_TAC (srw_ss()) []); val reflex_priv_mode_constraints_v2a_thm = store_thm("reflex_priv_mode_constraints_v2a_thm", - `` reflexive_comp priv_mode_constraints_v2a (assert_mode 16w)``, + `` reflexive_comp priv_mode_constraints_v2a (assert_mode 16w)``, RW_TAC (srw_ss()) [reflexive_comp_def,priv_mode_constraints_v1_def, reflex_priv_mode_constraints_thm,priv_mode_constraints_v2a_def,assert_mode_def] THEN FULL_SIMP_TAC (srw_ss()) []); -val trans_priv_mode_constraints_thm = +val trans_priv_mode_constraints_thm = store_thm("trans_priv_mode_constraints_thm", ``trans_fun priv_mode_constraints``, RW_TAC (srw_ss()) [LET_DEF, trans_fun_def,priv_mode_constraints_def] - THEN RW_TAC (srw_ss()) [] THEN + THEN RW_TAC (srw_ss()) [] THEN FULL_SIMP_TAC (srw_ss()) [get_base_vector_table_def,ARM_MODE_def,ARM_READ_CPSR_def]); - + val reflex_priv_mode_similar_thm = store_thm( "reflex_priv_mode_similar_thm", ``refl_rel priv_mode_similar``, @@ -143,7 +143,7 @@ val reflex_empty_sim_thm = store_thm( val reflex_strict_unt_thm = store_thm( "reflex_strict_unt_thm", - ``!u. reflexive_comp strict_unt (assert_mode u)``, + ``!u. reflexive_comp strict_unt (assert_mode u)``, RW_TAC (srw_ss()) [reflexive_comp_def, strict_unt_def,assert_mode_def]); val strict_unt_and_priv_mode_constraints_v2_lem = store_thm( @@ -156,7 +156,7 @@ val strict_unt_and_priv_mode_constraints_v2a_lem = store_thm( ``strict_unt g a b ==> priv_mode_constraints_v2a g b c ==> priv_mode_constraints_v2a g a c``, RW_TAC (srw_ss()) [strict_unt_def, priv_mode_constraints_v2a_def, priv_mode_constraints_v1_def, ARM_MODE_def, ARM_READ_CPSR_def, LET_DEF, vector_table_address_def, get_base_vector_table_def, get_pc_value_def] THEN FULL_SIMP_TAC (srw_ss()) []); -val trans_strict_unt_thm = +val trans_strict_unt_thm = store_thm("trans_strict_unt_thm", ``trans_fun strict_unt``, RW_TAC (srw_ss()) [LET_DEF, trans_fun_def, strict_unt_def] @@ -165,11 +165,11 @@ val trans_strict_unt_thm = val reflex_empty_unt_thm = store_thm( "reflex_empty_unt_thm", - ``!u. reflexive_comp empty_unt (assert_mode u)``, + ``!u. reflexive_comp empty_unt (assert_mode u)``, RW_TAC (srw_ss()) [reflexive_comp_def, empty_unt_def,assert_mode_def]); -val trans_empty_unt_thm = +val trans_empty_unt_thm = store_thm("trans_empty_unt_thm", ``trans_fun empty_unt``, RW_TAC (srw_ss()) [LET_DEF, trans_fun_def, empty_unt_def] @@ -180,7 +180,7 @@ val strict_unt_lem = store_thm( ``! COMP. preserve_relation_mmu COMP (assert_mode u) (assert_mode u) strict_unt empty_sim ==> preserve_relation_mmu COMP (assert_mode u) (assert_mode u) empty_unt empty_sim``, - RW_TAC (srw_ss()) [empty_unt_def, strict_unt_def, preserve_relation_mmu_def] + RW_TAC (srw_ss()) [empty_unt_def, strict_unt_def, preserve_relation_mmu_def] THEN SPEC_ASSUM_TAC (``!g s1 s2. X``, [``g:word32``, ``s1:arm_state``, ``s2:arm_state``]) THEN METIS_TAC []); @@ -189,7 +189,7 @@ val gen_strict_unt_lem = store_thm( ``! COMP. (!u. preserve_relation_mmu COMP (assert_mode u) (assert_mode u) strict_unt empty_sim) ==> (!u. preserve_relation_mmu COMP (assert_mode u) (assert_mode u) empty_unt empty_sim)``, - RW_TAC (srw_ss()) [empty_unt_def, strict_unt_def, preserve_relation_mmu_def] + RW_TAC (srw_ss()) [empty_unt_def, strict_unt_def, preserve_relation_mmu_def] THEN SPEC_ASSUM_TAC (``!g s1 s2. X``, [``g:word32``, ``s1:arm_state``, ``s2:arm_state``]) THEN METIS_TAC []); @@ -197,7 +197,7 @@ val gen_strict_unt_lem = store_thm( val empty_extras_lem = store_thm( "empty_extras_lem", ``! COMP. - preserve_relation_mmu COMP (assert_mode 16w) (assert_mode 16w) priv_mode_constraints priv_mode_similar + preserve_relation_mmu COMP (assert_mode 16w) (assert_mode 16w) priv_mode_constraints priv_mode_similar = preserve_relation_mmu COMP (assert_mode 16w) (assert_mode 16w) empty_unt empty_sim``, STRIP_TAC THEN EQ_TAC THENL[ RW_TAC (srw_ss()) [LET_DEF, preserve_relation_mmu_def, assert_mode_def, empty_unt_def, empty_sim_def] @@ -227,7 +227,7 @@ val fixed_flags_empty_lem = store_thm( THEN ` ((s2.psrs (0,CPSR)).I ⇔ (s1.psrs (0,CPSR)).I) ∧ ((s2.psrs (0,CPSR)).F ⇔ (s1.psrs (0,CPSR)).F)` by FULL_SIMP_TAC (srw_ss()) [similar_def] THEN UNDISCH_ALL_TAC THEN RW_TAC (srw_ss()) [] - THEN Cases_on `ARM_MODE s2 = 16w` + THEN Cases_on `ARM_MODE s2 = 16w` THEN FULL_SIMP_TAC (srw_ss()) [], RW_TAC (srw_ss()) [preserve_relation_mmu_def, fixed_flags_def, empty_sim_def] THEN SPEC_ASSUM_TAC (``!g s1 s2. X``, [``g:word32``, ``s1:arm_state``, ``s2:arm_state``]) @@ -236,7 +236,7 @@ val fixed_flags_empty_lem = store_thm( RW_TAC (srw_ss()) [preserve_relation_mmu_def, fixed_flags_def, empty_sim_def] THEN SPEC_ASSUM_TAC (``!xI g s1 s2. X``, [``(((s1:arm_state).psrs(0,CPSR)):ARMpsr).I``, ``g:word32``, ``s1:arm_state``, ``s2:arm_state``]) THEN ` ((s2.psrs (0,CPSR)).I ⇔ (s1.psrs (0,CPSR)).I) ∧ ((s2.psrs (0,CPSR)).F ⇔ (s1.psrs (0,CPSR)).F)` by FULL_SIMP_TAC (srw_ss()) [similar_def] - THEN UNDISCH_ALL_TAC + THEN UNDISCH_ALL_TAC THEN RW_TAC (srw_ss()) [] THEN Cases_on `ARM_MODE s2 = 16w` THEN FULL_SIMP_TAC (srw_ss()) []]); @@ -260,7 +260,7 @@ val fix_flags_lem = store_thm( THEN ` ((s2.psrs (0,CPSR)).I ⇔ (s1.psrs (0,CPSR)).I) ∧ ((s2.psrs (0,CPSR)).F ⇔ (s1.psrs (0,CPSR)).F)` by FULL_SIMP_TAC (srw_ss()) [similar_def] THEN UNDISCH_ALL_TAC THEN RW_TAC (srw_ss()) [] - THEN Cases_on `ARM_MODE s2 = 16w` + THEN Cases_on `ARM_MODE s2 = 16w` THEN FULL_SIMP_TAC (srw_ss()) [], RW_TAC (srw_ss()) [preserve_relation_mmu_def, fixed_flags_def, fix_flags_def] THEN SPEC_ASSUM_TAC (``!g s1 s2. X``, [``g:word32``, ``s1:arm_state``, ``s2:arm_state``]) @@ -269,7 +269,7 @@ val fix_flags_lem = store_thm( RW_TAC (srw_ss()) [preserve_relation_mmu_def, fixed_flags_def, fix_flags_def] THEN SPEC_ASSUM_TAC (``!xI g s1 s2. X``, [``(((s1:arm_state).psrs(0,CPSR)):ARMpsr).I``, ``g:word32``, ``s1:arm_state``, ``s2:arm_state``]) THEN ` ((s2.psrs (0,CPSR)).I ⇔ (s1.psrs (0,CPSR)).I) ∧ ((s2.psrs (0,CPSR)).F ⇔ (s1.psrs (0,CPSR)).F)` by FULL_SIMP_TAC (srw_ss()) [similar_def] - THEN UNDISCH_ALL_TAC + THEN UNDISCH_ALL_TAC THEN RW_TAC (srw_ss()) [] THEN Cases_on `ARM_MODE s2 = 16w` THEN FULL_SIMP_TAC (srw_ss()) []]); @@ -303,7 +303,7 @@ val extras_lem3 = store_thm( /\ (preserve_relation_mmu (A) (assert_mode u) (assert_mode u) strict_unt empty_sim) /\ (preserve_relation_mmu (A) (assert_mode 16w) (assert_mode 16w) priv_mode_constraints priv_mode_similar) /\ (preserve_relation_mmu (A) (assert_mode 16w) (assert_mode 16w) priv_mode_constraints (fix_flags xI xF priv_mode_similar)) - /\ (preserve_relation_mmu (A) (assert_mode 16w) (assert_mode 16w) empty_unt (fix_flags xI xF empty_sim)))``, + /\ (preserve_relation_mmu (A) (assert_mode 16w) (assert_mode 16w) empty_unt (fix_flags xI xF empty_sim)))``, RW_TAC (srw_ss()) [gen_strict_unt_lem, empty_extras_lem, fix_flags_lem] THEN METIS_TAC [gen_strict_unt_lem, empty_extras_lem, fix_flags_lem]); @@ -318,23 +318,23 @@ val extras_lem4 = store_thm( RW_TAC (srw_ss()) [strict_unt_lem, empty_extras_lem, fix_flags_lem] THEN METIS_TAC [strict_unt_lem, empty_extras_lem, fix_flags_lem]); - val comb_monot_thm = store_thm("comb_monot_thm", - ``!a:(arm_state -> bool). comb a a a``, - RW_TAC (srw_ss()) [comb_def]); + val comb_monot_thm = store_thm("comb_monot_thm", + ``!a:(arm_state -> bool). comb a a a``, + RW_TAC (srw_ss()) [comb_def]); -val preserve_relation_comb_thm = - store_thm ("preserve_relation_comb_thm", - ``! a b c d f uf uy. - preserve_relation_mmu f d b uf uy - ==> - comb a b c ==> - preserve_relation_mmu f d c uf uy``, - RW_TAC (srw_ss()) [preserve_relation_mmu_def,comb_def] - THEN PAT_ASSUM ``∀g s1 s2. X`` - (fn thm => ASSUME_TAC (SPECL [``g:bool[32]``, - ``s1:arm_state``, ``s2:arm_state``] thm)) - THEN RES_TAC - THEN RW_TAC (srw_ss()) []); +val preserve_relation_comb_thm = + store_thm ("preserve_relation_comb_thm", + ``! a b c d f uf uy. + preserve_relation_mmu f d b uf uy + ==> + comb a b c ==> + preserve_relation_mmu f d c uf uy``, + RW_TAC (srw_ss()) [preserve_relation_mmu_def,comb_def] + THEN PAT_ASSUM ``∀g s1 s2. X`` + (fn thm => ASSUME_TAC (SPECL [``g:bool[32]``, + ``s1:arm_state``, ``s2:arm_state``] thm)) + THEN RES_TAC + THEN RW_TAC (srw_ss()) []); val global_aligned_word_readable_lem = store_thm( @@ -359,7 +359,7 @@ val seqT_preserves_relation_comb_thm = (preserve_relation_mmu_abs f2 (assert_mode k) (comb_inv) uf uy) ==> (preserve_relation_mmu (f1 >>= (f2)) (assert_mode k) comb_inv uf uy) ``, - (RW_TAC (srw_ss()) [seqT_def,constT_def,preserve_relation_mmu_def,preserve_relation_mmu_abs_def,trans_fun_def]) + (RW_TAC (srw_ss()) [seqT_def,constT_def,preserve_relation_mmu_def,preserve_relation_mmu_abs_def,trans_fun_def]) THEN (UNDISCH_ALL_TAC THEN REPEAT (CASE_TAC THEN FULL_SIMP_TAC (srw_ss()) [])) THENL [UNDISCH_ALL_TAC @@ -433,7 +433,7 @@ val equal_mem_lem = store_thm( `` !s1 s2 g (addr:bool[32]) is_write. (similar g s1 s2) ==> (mmu_requirements s1 g) ==> - (mmu_requirements s2 g) + (mmu_requirements s2 g) ==> ((s1.memory addr) = (s2.memory addr)) \/ @@ -460,10 +460,10 @@ val equal_mem_lem = store_thm( val stay_similar_lem = store_thm( "stay_similar_lem", - ``!s1 s2 g addr x. + ``!s1 s2 g addr x. (mmu_requirements s1 g) ==> - (mmu_requirements s2 g) ==> - (similar g s1 s2) + (mmu_requirements s2 g) ==> + (similar g s1 s2) ==> ((similar g (s1 with accesses updated_by CONS (MEM_READ addr)) (s2 with accesses updated_by CONS (MEM_READ addr))) /\ (similar g (s1 with accesses updated_by CONS (MEM_WRITE addr x)) (s2 with accesses updated_by CONS (MEM_WRITE addr x))))``, NTAC 8 STRIP_TAC @@ -479,17 +479,17 @@ val stay_similar_lem = store_thm( THEN FULL_SIMP_TAC (srw_ss()) [LET_DEF] THEN `mmu_requirements_pure s1 g` by FULL_SIMP_TAC (srw_ss()) [mmu_requirements_simp] THEN `mmu_requirements_pure s2 g` by FULL_SIMP_TAC (srw_ss()) [mmu_requirements_simp] - THEN MP_TAC same_setup_same_rights_lem - THEN STRIP_TAC + THEN MP_TAC same_setup_same_rights_lem + THEN STRIP_TAC THEN RES_TAC THEN FULL_SIMP_TAC (srw_ss()) [equal_user_register_def] THEN METIS_TAC []); val keep_mode_on_accesses_update_lem = store_thm( "keep_mode_on_accesses_update_lem", - ``!m s addr x. - (ARM_MODE s = m) - ==> + ``!m s addr x. + (ARM_MODE s = m) + ==> (ARM_MODE (s with accesses updated_by CONS (MEM_READ addr)) = m) /\ (ARM_MODE (s with accesses updated_by CONS (MEM_WRITE addr x)) = m)``, NTAC 4 STRIP_TAC THEN EVAL_TAC); @@ -510,25 +510,25 @@ val read_mem1_mode_thm = store_thm( val read_mem1_similar_thm = store_thm ( "read_mem1_similar_thm", ``!addr. keep_similar_relation (read_mem1 <|proc:=0|> addr) (assert_mode 16w) empty_sim``, - PURE_ONCE_REWRITE_TAC [keep_similar_relation_def] + PURE_ONCE_REWRITE_TAC [keep_similar_relation_def] THEN NTAC 8 STRIP_TAC THEN Cases_on `read_mem1 <|proc:=0|> addr s1` THEN Cases_on `read_mem1 <|proc:=0|> addr s2` THEN FULL_SIMP_TAC (srw_ss()) [empty_sim_def] THENL [FULL_SIMP_TAC (srw_ss()) [read_mem1_def, writeT_def, readT_def, seqT_def] - THEN (`b = (s1 with accesses updated_by CONS (MEM_READ addr))` by + THEN (`b = (s1 with accesses updated_by CONS (MEM_READ addr))` by (Cases_on `access_violation (s1 with accesses updated_by CONS (MEM_READ addr))` THEN FULL_SIMP_TAC (srw_ss()) [])) - THEN (`b' = (s2 with accesses updated_by CONS (MEM_READ addr))` by + THEN (`b' = (s2 with accesses updated_by CONS (MEM_READ addr))` by (Cases_on `access_violation (s2 with accesses updated_by CONS (MEM_READ addr))` THEN FULL_SIMP_TAC (srw_ss()) [])) THEN ASSUME_TAC (SPECL [``s1:arm_state``, ``s2:arm_state``, ``g:word32``, ``addr:word32``, ``F``] equal_mem_lem) THEN RES_TAC THENL [`similar g b b' = similar g s1 s2` by METIS_TAC [stay_similar_lem] - THEN Cases_on `access_violation (s2 with accesses updated_by CONS (MEM_READ addr))` - THEN Cases_on `access_violation (s1 with accesses updated_by CONS (MEM_READ addr))` + THEN Cases_on `access_violation (s2 with accesses updated_by CONS (MEM_READ addr))` + THEN Cases_on `access_violation (s1 with accesses updated_by CONS (MEM_READ addr))` THEN FULL_SIMP_TAC (srw_ss()) [] - THEN RES_TAC + THEN RES_TAC THEN FULL_SIMP_TAC (srw_ss()) [similar_def,arm_stepTheory.ARM_MODE_def, arm_stepTheory.ARM_READ_CPSR_def] THEN METIS_TAC [], ASSUME_TAC (SPECL [``addr:word32``, ``x:word8``, ``s1:arm_state``, ``g:word32``] mmu_requirement_accesses_update_lem) @@ -542,13 +542,13 @@ val read_mem1_similar_thm = store_thm ( THEN FULL_SIMP_TAC (srw_ss()) [] THEN METIS_TAC [stay_similar_lem, keep_mode_on_accesses_update_lem]], FULL_SIMP_TAC (srw_ss()) [read_mem1_def, similar_def, seqT_def, writeT_def, readT_def] - THEN Cases_on `access_violation (s2 with accesses updated_by CONS (MEM_READ addr))` + THEN Cases_on `access_violation (s2 with accesses updated_by CONS (MEM_READ addr))` THEN FULL_SIMP_TAC (srw_ss()) [], FULL_SIMP_TAC (srw_ss()) [read_mem1_def, similar_def, seqT_def, writeT_def, readT_def] - THEN Cases_on `access_violation (s1 with accesses updated_by CONS (MEM_READ addr))` + THEN Cases_on `access_violation (s1 with accesses updated_by CONS (MEM_READ addr))` THEN FULL_SIMP_TAC (srw_ss()) [], FULL_SIMP_TAC (srw_ss()) [read_mem1_def, similar_def, seqT_def, writeT_def, readT_def] - THEN Cases_on `access_violation (s1 with accesses updated_by CONS (MEM_READ addr))` + THEN Cases_on `access_violation (s1 with accesses updated_by CONS (MEM_READ addr))` THEN FULL_SIMP_TAC (srw_ss()) []]); @@ -592,7 +592,7 @@ val write_mem1_ut_thm = store_thm ( THEN Cases_on `g=guest1` THEN Cases_on `g=guest2` THEN ASSUME_TAC you_and_me_thm - THEN FULL_SIMP_TAC (srw_ss()) [] + THEN FULL_SIMP_TAC (srw_ss()) [] THEN FIRST_PROVE [ASSUME_TAC (SPECL [``s:arm_state``, ``s with accesses updated_by CONS (MEM_WRITE addr data)``] trivially_untouched_mmu_setup_lem) THEN FULL_SIMP_TAC (srw_ss()) [] @@ -606,7 +606,7 @@ val write_mem1_ut_thm = store_thm ( THEN CASE_TAC THEN RW_TAC (srw_ss()) [untouched_def, LET_DEF] THEN (RW_TAC (srw_ss()) [] - THEN EVAL_TAC + THEN EVAL_TAC THEN RW_TAC (srw_ss()) [inequal_by_inequalities])]); @@ -699,7 +699,7 @@ val write_mem_pmc_thm = store_thm( THEN IMP_RES_TAC forT_preserves_user_relation_thm THEN (REPEAT (PAT_ASSUM ``!l h. X`` (fn th => ASSUME_TAC (SPECL [``0:num``, ``(LENGTH (value:word8 list) - 1):num``] th)))) THEN (REPEAT (PAT_ASSUM ``!x. X`` (fn th => IMP_RES_TAC th))) - THEN (REPEAT (PAT_ASSUM ``~X`` (fn th => IMP_RES_TAC th))) + THEN (REPEAT (PAT_ASSUM ``~X`` (fn th => IMP_RES_TAC th))) THEN IMP_RES_TAC seqT_preserves_relation_uu_thm]); @@ -733,7 +733,7 @@ val branch_to_thm = save_thm("branch_to_thm", MATCH_MP extras_lem branch_to_empt val write_monitor_empty_thm = store_thm( "write_monitor_empty_thm", ``!u. preserve_relation_mmu (write_monitor <|proc:=0|> vl) (assert_mode u) (assert_mode u) empty_unt empty_sim``, - RW_TAC (srw_ss()) [write_monitor_def, writeT_def, preserve_relation_mmu_def, untouched_def, assert_mode_def, ARM_MODE_def, ARM_READ_CPSR_def, similar_def, equal_user_register_def, empty_unt_def, empty_sim_def] + RW_TAC (srw_ss()) [write_monitor_def, writeT_def, preserve_relation_mmu_def, untouched_def, assert_mode_def, ARM_MODE_def, ARM_READ_CPSR_def, similar_def, equal_user_register_def, empty_unt_def, empty_sim_def] THEN FULL_SIMP_TAC (srw_ss()) [] THEN ASSUME_TAC (SPECL [``s1:arm_state``, ``s1 with monitors := (vl:ExclusiveMonitors)``, ``g:word32``] trivially_untouched_av_lem) THEN ASSUME_TAC (SPECL [``s2:arm_state``, ``s2 with monitors := (vl:ExclusiveMonitors)``, ``g:word32``] trivially_untouched_av_lem) @@ -746,7 +746,7 @@ val write_monitor_thm = save_thm("write_monitor_thm", MATCH_MP extras_lem write_ val clear_event_register_empty_thm = store_thm( "clear_event_register_empty_thm", ``!u. preserve_relation_mmu (clear_event_register <|proc:=0|>) (assert_mode u) (assert_mode u) empty_unt empty_sim``, - RW_TAC (srw_ss()) [clear_event_register_def, writeT_def, preserve_relation_mmu_def, untouched_def, assert_mode_def, ARM_MODE_def, ARM_READ_CPSR_def, similar_def, equal_user_register_def, empty_unt_def, empty_sim_def] + RW_TAC (srw_ss()) [clear_event_register_def, writeT_def, preserve_relation_mmu_def, untouched_def, assert_mode_def, ARM_MODE_def, ARM_READ_CPSR_def, similar_def, equal_user_register_def, empty_unt_def, empty_sim_def] THEN FULL_SIMP_TAC (srw_ss()) [] THEN ASSUME_TAC (SPECL [``s1:arm_state``, ``s1 with event_register updated_by (0=+ F)``, ``g:word32``] trivially_untouched_av_lem) THEN ASSUME_TAC (SPECL [``s2:arm_state``, ``s2 with event_register updated_by (0=+ F)``, ``g:word32``] trivially_untouched_av_lem) @@ -760,7 +760,7 @@ val clear_event_register_thm = save_thm("clear_event_register_thm", MATCH_MP ext val wait_for_interrupt_empty_thm = store_thm( "wait_for_interrupt_empty_thm", ``!u. preserve_relation_mmu (wait_for_interrupt <|proc:=0|>) (assert_mode u) (assert_mode u) empty_unt empty_sim``, - RW_TAC (srw_ss()) [wait_for_interrupt_def, writeT_def, preserve_relation_mmu_def, untouched_def, assert_mode_def, ARM_MODE_def, ARM_READ_CPSR_def, similar_def, equal_user_register_def, empty_unt_def, empty_sim_def] + RW_TAC (srw_ss()) [wait_for_interrupt_def, writeT_def, preserve_relation_mmu_def, untouched_def, assert_mode_def, ARM_MODE_def, ARM_READ_CPSR_def, similar_def, equal_user_register_def, empty_unt_def, empty_sim_def] THEN FULL_SIMP_TAC (srw_ss()) [] THEN ASSUME_TAC (SPECL [``s1:arm_state``, ``s1 with interrupt_wait updated_by (0=+ T)``, ``g:word32``] trivially_untouched_av_lem) THEN ASSUME_TAC (SPECL [``s2:arm_state``, ``s2 with interrupt_wait updated_by (0=+ T)``, ``g:word32``] trivially_untouched_av_lem) @@ -775,7 +775,7 @@ val wait_for_interrupt_thm = save_thm("wait_for_interrupt_thm", MATCH_MP extras_ val send_event_empty_thm = store_thm( "send_event_empty_thm", ``!u. preserve_relation_mmu (send_event <|proc:=0|>) (assert_mode u) (assert_mode u) empty_unt empty_sim``, - RW_TAC (srw_ss()) [send_event_def, writeT_def, preserve_relation_mmu_def, untouched_def, assert_mode_def, ARM_MODE_def, ARM_READ_CPSR_def, similar_def, equal_user_register_def, empty_unt_def, empty_sim_def] + RW_TAC (srw_ss()) [send_event_def, writeT_def, preserve_relation_mmu_def, untouched_def, assert_mode_def, ARM_MODE_def, ARM_READ_CPSR_def, similar_def, equal_user_register_def, empty_unt_def, empty_sim_def] THEN FULL_SIMP_TAC (srw_ss()) [] THEN ASSUME_TAC (SPECL [``s1:arm_state``, ``s1 with event_register := K T``, ``g:word32``] trivially_untouched_av_lem) THEN ASSUME_TAC (SPECL [``s2:arm_state``, ``s2 with event_register := K T``, ``g:word32``] trivially_untouched_av_lem) @@ -859,10 +859,10 @@ val little_mode_mix_upgrade = store_thm( "little_mode_mix_upgrade", ``!A inv1 uf uy. ( preserve_relation_mmu (A) inv1 (assert_mode 16w) uf uy - \/ preserve_relation_mmu (A) inv1 (comb_mode 16w 27w) uf uy + \/ preserve_relation_mmu (A) inv1 (comb_mode 16w 27w) uf uy \/ preserve_relation_mmu (A) inv1 (comb_mode 16w 23w) uf uy \/ preserve_relation_mmu (A) inv1 (comb_mode 16w 17w) uf uy - \/ preserve_relation_mmu (A) inv1 (comb_mode 16w 18w) uf uy) + \/ preserve_relation_mmu (A) inv1 (comb_mode 16w 18w) uf uy) ==> preserve_relation_mmu (A) inv1 little_mode_mix uf uy``, RW_TAC (srw_ss()) [preserve_relation_mmu_def, assert_mode_def, comb_mode_def, little_mode_mix_def] diff --git a/examples/acl2/examples/M1/complex_rationalScript.sml b/examples/acl2/examples/M1/complex_rationalScript.sml index 32189a6900..a948072c61 100644 --- a/examples/acl2/examples/M1/complex_rationalScript.sml +++ b/examples/acl2/examples/M1/complex_rationalScript.sml @@ -232,7 +232,7 @@ val COMPLEX_MULT_COMM = val COMPLEX_MULT_ASSOC = store_thm ("COMPLEX_MULT_ASSOC", - ``a * (b * c) = a * b * c:complex_rational``, + ``a * (b * c) = a * b * c:complex_rational``, Cases_on `a` THEN Cases_on `b` THEN Cases_on `c` THEN RW_TAC std_ss [COMPLEX_MULT_def,RAT_LDISTRIB,RAT_RDISTRIB, diff --git a/examples/acl2/examples/acl2-hol-ltl-paper-example/acl2_packageScript.sml b/examples/acl2/examples/acl2-hol-ltl-paper-example/acl2_packageScript.sml index 5d31156795..01e11d4469 100644 --- a/examples/acl2/examples/acl2-hol-ltl-paper-example/acl2_packageScript.sml +++ b/examples/acl2/examples/acl2-hol-ltl-paper-example/acl2_packageScript.sml @@ -3142,7 +3142,7 @@ val LOOKUP_AUX_RWR = prove(`` (LOOKUP_AUX ((name1,ACL2_USER)::a) (name2,ACL2_USER_CL) = LOOKUP_AUX a (name2,ACL2_USER_CL)) /\ (LOOKUP_AUX ((name1,ACL2_USER)::a) (name2,ACL2_USER) = LOOKUP_AUX a (name2,ACL2_USER))``, RW_TAC arith_ss [LOOKUP_AUX_def,ACL2_CL_def,ACL2_USER_def,ACL_USER_CL_def] THEN - METIS_TAC []); + METIS_TAC []); val CHECK_def = Define `CHECK (x,y,z) = ~(z = "") /\ ~(x = "ACL2-PKG-WITNESS")`; diff --git a/examples/acl2/examples/acl2-hol-ltl-paper-example/complex_rationalScript.sml b/examples/acl2/examples/acl2-hol-ltl-paper-example/complex_rationalScript.sml index 32189a6900..a948072c61 100644 --- a/examples/acl2/examples/acl2-hol-ltl-paper-example/complex_rationalScript.sml +++ b/examples/acl2/examples/acl2-hol-ltl-paper-example/complex_rationalScript.sml @@ -232,7 +232,7 @@ val COMPLEX_MULT_COMM = val COMPLEX_MULT_ASSOC = store_thm ("COMPLEX_MULT_ASSOC", - ``a * (b * c) = a * b * c:complex_rational``, + ``a * (b * c) = a * b * c:complex_rational``, Cases_on `a` THEN Cases_on `b` THEN Cases_on `c` THEN RW_TAC std_ss [COMPLEX_MULT_def,RAT_LDISTRIB,RAT_RDISTRIB, diff --git a/examples/formal-languages/FormalLangScript.sml b/examples/formal-languages/FormalLangScript.sml index abbb88e046..97a64710b3 100644 --- a/examples/formal-languages/FormalLangScript.sml +++ b/examples/formal-languages/FormalLangScript.sml @@ -38,8 +38,8 @@ val _ = type_abbrev ("lang", ``:'a list set``); (* Binary language concatenation. Right infix *) (*---------------------------------------------------------------------------*) -val dot_def = - Define +val dot_def = + Define `$dot A B = {x ++ y | x IN A /\ y IN B}`; val _ = set_fixity "dot" (Infixr 675); @@ -97,7 +97,7 @@ val DOT_MONO = Q.store_thm (* Iterated language concatenation. *) (*---------------------------------------------------------------------------*) -val DOTn_def = +val DOTn_def = Define `(DOTn A 0 = {[]}) /\ (DOTn A (SUC n) = A dot (DOTn A n))`; @@ -121,33 +121,33 @@ val EMPTY_IN_DOTn_ZERO = Q.store_thm val STRCAT_IN_DOTn_SUC = Q.store_thm ("STRCAT_IN_DOTn_SUC", - `!a b A n. (a IN A /\ b IN DOTn A n) \/ (a IN DOTn A n /\ b IN A) + `!a b A n. (a IN A /\ b IN DOTn A n) \/ (a IN DOTn A n /\ b IN A) ==> (a ++ b) IN DOTn A (SUC n)`, RW_TAC basic_ss [DOTn_def] THEN METIS_TAC [STRCAT_IN_dot,DOTn_RIGHT]); val STRCAT_IN_DOTn_ADD = Q.store_thm ("STRCAT_IN_DOTn_ADD", -`!m n a b A. +`!m n a b A. a IN DOTn A m /\ b IN DOTn A n ==> (a ++ b) IN DOTn A (m + n)`, Induct THEN RW_TAC basic_ss [DOTn_def] THEN - FULL_SIMP_TAC basic_ss [IN_dot] THEN + FULL_SIMP_TAC basic_ss [IN_dot] THEN `(v ++ b) IN DOTn A (m + n)` by METIS_TAC [] THEN METIS_TAC [STRCAT_IN_DOTn_SUC,APPEND_ASSOC,DECIDE``SUC(m+n) = n + SUC m``]); val DOTn_EMPTYSET = Q.store_thm ("DOTn_EMPTYSET", -`!n. DOTn {} n = if n=0 then {[]} else {}`, +`!n. DOTn {} n = if n=0 then {[]} else {}`, Induct THEN RW_TAC basic_ss [DOTn_def,DOT_EMPTYSET]); val DOTn_EMPTYSTRING = Q.store_thm ("DOTn_EMPTYSTRING", -`!n. DOTn {[]} n = {[]}`, +`!n. DOTn {[]} n = {[]}`, Induct THEN RW_TAC basic_ss [DOTn_def,dot_def,EXTENSION] THEN METIS_TAC[APPEND_EQNS]); val EMPTY_IN_DOTn = Q.store_thm ("EMPTY_IN_DOTn", -`!n. ([] IN DOTn A n) <=> (n=0) \/ ([] IN A)`, +`!n. ([] IN DOTn A n) <=> (n=0) \/ ([] IN A)`, Induct THEN RW_TAC basic_ss [DOTn_def,EMPTY_IN_DOT] THEN METIS_TAC[]); val DOTn_UNION = Q.store_thm @@ -169,9 +169,9 @@ val DOTn_DIFF = Q.store_thm val DOTn_EMPTYSTRING_FREE = Q.store_thm ("DOTn_EMPTYSTRING_FREE", `!n A w. w IN DOTn A n ==> - (w = []) \/ + (w = []) \/ ?k. w IN DOTn (A DELETE []) k`, - Induct THEN RW_TAC basic_ss [DOTn_def,IN_dot] THEN + Induct THEN RW_TAC basic_ss [DOTn_def,IN_dot] THEN RES_TAC THEN Cases_on `u` THEN RW_TAC basic_ss [] THEN `h::t IN (A DELETE [])` by RW_TAC basic_ss [] THENL [METIS_TAC [SUBSET_DOTn,SUBSET_DEF], @@ -181,15 +181,15 @@ val DOTn_EMPTYSTRING_FREE = Q.store_thm (* Kleene star *) (*---------------------------------------------------------------------------*) -val KSTAR_def = - Define +val KSTAR_def = + Define `KSTAR(L:'a lang) = BIGUNION {DOTn L n | n IN UNIV}`; val IN_KSTAR = Q.store_thm ("IN_KSTAR", `x IN KSTAR(L) = ?n. x IN DOTn L n`, RW_TAC basic_ss [KSTAR_def,BIGUNION] THEN - RW_TAC basic_ss [SPECIFICATION] THEN + RW_TAC basic_ss [SPECIFICATION] THEN METIS_TAC[]); val KSTAR_EMPTYSET = Q.store_thm @@ -208,32 +208,32 @@ val EMPTY_IN_KSTAR = Q.store_thm val KSTAR_SING = Q.store_thm ("KSTAR_SING", `!x. x IN (KSTAR {x})`, - RW_TAC basic_ss [IN_KSTAR] THEN - Q.EXISTS_TAC `SUC 0` THEN + RW_TAC basic_ss [IN_KSTAR] THEN + Q.EXISTS_TAC `SUC 0` THEN RW_TAC basic_ss [DOTn_def,IN_dot]); val SUBSET_KSTAR = Q.store_thm ("SUBSET_KSTAR", `!A. A SUBSET KSTAR(A)`, - RW_TAC basic_ss [SUBSET_DEF,IN_KSTAR] THEN - Q.EXISTS_TAC `SUC 0` THEN + RW_TAC basic_ss [SUBSET_DEF,IN_KSTAR] THEN + Q.EXISTS_TAC `SUC 0` THEN RW_TAC basic_ss [DOTn_def,IN_dot]); val SUBSET_KSTAR_DOT = Q.store_thm ("SUBSET_KSTAR_DOT", `!A B. B SUBSET (KSTAR A) dot B`, - RW_TAC basic_ss [SUBSET_DEF,IN_KSTAR,IN_dot] THEN + RW_TAC basic_ss [SUBSET_DEF,IN_KSTAR,IN_dot] THEN MAP_EVERY Q.EXISTS_TAC [`[]`,`x`] THEN RW_TAC basic_ss [] THEN METIS_TAC [DOTn_def,IN_INSERT]); val STRCAT_IN_KSTAR = Q.store_thm ("STRCAT_IN_KSTAR", -`!u v A B. +`!u v A B. u IN A /\ v IN KSTAR(A) dot B ==> (u ++ v) IN KSTAR(A) dot B`, - RW_TAC list_ss [IN_KSTAR,IN_dot] THEN + RW_TAC list_ss [IN_KSTAR,IN_dot] THEN MAP_EVERY Q.EXISTS_TAC [`u++u'`,`v'`] THEN - RW_TAC list_ss [APPEND_ASSOC] THEN - Q.EXISTS_TAC `SUC n` THEN RW_TAC std_ss [DOTn_def] THEN + RW_TAC list_ss [APPEND_ASSOC] THEN + Q.EXISTS_TAC `SUC n` THEN RW_TAC std_ss [DOTn_def] THEN METIS_TAC [STRCAT_IN_dot]); val KSTAR_EQ_INTRO = Q.store_thm @@ -245,26 +245,26 @@ val IN_KSTAR_LIST = Q.store_thm ("IN_KSTAR_LIST", `!s A. s IN KSTAR A <=> ?wlist. EVERY (\w. w IN A) wlist /\ (s = FLAT wlist)`, RW_TAC list_ss [IN_KSTAR,EQ_IMP_THM] THENL - [POP_ASSUM MP_TAC THEN Q.ID_SPEC_TAC `s` + [POP_ASSUM MP_TAC THEN Q.ID_SPEC_TAC `s` THEN Induct_on `n` THEN RW_TAC list_ss [] - THENL - [FULL_SIMP_TAC list_ss [EMPTY_IN_DOTn_ZERO] THEN RW_TAC list_ss [] + THENL + [FULL_SIMP_TAC list_ss [EMPTY_IN_DOTn_ZERO] THEN RW_TAC list_ss [] THEN Q.EXISTS_TAC `[]` THEN RW_TAC list_ss [], - FULL_SIMP_TAC list_ss [DOTn_def,IN_dot] - THEN RW_TAC list_ss [] THEN RES_TAC + FULL_SIMP_TAC list_ss [DOTn_def,IN_dot] + THEN RW_TAC list_ss [] THEN RES_TAC THEN Q.EXISTS_TAC `u::wlist` THEN RW_TAC list_ss []], Induct_on `wlist` THEN FULL_SIMP_TAC list_ss [] THENL [METIS_TAC [EMPTY_IN_DOTn], - RW_TAC list_ss [] THEN RES_TAC - THEN Q.EXISTS_TAC `SUC n` + RW_TAC list_ss [] THEN RES_TAC + THEN Q.EXISTS_TAC `SUC n` THEN RW_TAC list_ss [DOTn_def] THEN METIS_TAC[IN_dot]]]); (*---------------------------------------------------------------------------*) (* Some more complex equalities *) (*---------------------------------------------------------------------------*) -val lang_ss = basic_ss ++ - rewrites [IN_KSTAR, IN_dot, DOTn_def, +val lang_ss = basic_ss ++ + rewrites [IN_KSTAR, IN_dot, DOTn_def, DOT_EMPTYSET,DOT_EMPTYSTRING, DOTn_EMPTYSTRING, KSTAR_SING,KSTAR_EMPTYSET,EMPTY_IN_KSTAR]; @@ -272,7 +272,7 @@ val KSTAR_EQ_EPSILON_UNION_DOT = Q.store_thm ("KSTAR_EQ_EPSILON_UNION_DOT", `!A. KSTAR A = {[]} UNION (A dot KSTAR A)`, RW_TAC lang_ss [EXTENSION,EQ_IMP_THM] THENL - [Cases_on `n` + [Cases_on `n` THENL [METIS_TAC[EMPTY_IN_DOTn_ZERO], FULL_SIMP_TAC lang_ss [] THEN METIS_TAC[]], METIS_TAC [EMPTY_IN_DOTn_ZERO], @@ -287,7 +287,7 @@ val KSTAR_EQ_KSTAR_UNION = Q.store_thm `!A. KSTAR A = KSTAR ({[]} UNION A)`, RW_TAC lang_ss [EXTENSION,EQ_IMP_THM] THENL [METIS_TAC [DOTn_UNION,UNION_COMM], - POP_ASSUM MP_TAC THEN Q.ID_SPEC_TAC `x` THEN + POP_ASSUM MP_TAC THEN Q.ID_SPEC_TAC `x` THEN Induct_on `n` THEN RW_TAC lang_ss [] THENL [METIS_TAC [EMPTY_IN_DOTn_ZERO], METIS_TAC [APPEND_EQNS], @@ -320,22 +320,22 @@ val DOT_KSTAR_EQ_KSTAR_DOT = Q.store_thm THEN METIS_TAC [IN_dot]); val lemma = Q.prove -(`(!n. DOTn (A dot B) n dot A = A dot DOTn (B dot A) n) +(`(!n. DOTn (A dot B) n dot A = A dot DOTn (B dot A) n) ==> (KSTAR (A dot B) dot A = A dot KSTAR(B dot A))`, RW_TAC lang_ss [EXTENSION] THEN METIS_TAC[]); val KSTAR_DOT_SHIFT = Q.store_thm ("KSTAR_DOT_SHIFT", `!A. KSTAR (A dot B) dot A = A dot KSTAR(B dot A)`, - GEN_TAC THEN MATCH_MP_TAC lemma THEN + GEN_TAC THEN MATCH_MP_TAC lemma THEN Induct THEN RW_TAC lang_ss [] THEN METIS_TAC [DOT_ASSOC]); val DOT_SQUARED_SUBSET = Q.store_thm ("DOT_SQUARED_SUBSET", `!L. (L dot L) SUBSET L ==> (L dot KSTAR L) SUBSET L`, - RW_TAC lang_ss [SUBSET_DEF,GSYM LEFT_FORALL_IMP_THM] THEN - NTAC 2 (POP_ASSUM MP_TAC) THEN MAP_EVERY Q.ID_SPEC_TAC [`v`, `u`] THEN - Induct_on `n` THEN RW_TAC lang_ss [] THEN + RW_TAC lang_ss [SUBSET_DEF,GSYM LEFT_FORALL_IMP_THM] THEN + NTAC 2 (POP_ASSUM MP_TAC) THEN MAP_EVERY Q.ID_SPEC_TAC [`v`, `u`] THEN + Induct_on `n` THEN RW_TAC lang_ss [] THEN METIS_TAC [DOT_ASSOC]); val KSTAR_UNION = Q.store_thm @@ -345,27 +345,27 @@ val KSTAR_UNION = Q.store_thm [POP_ASSUM MP_TAC THEN Q.ID_SPEC_TAC `x` THEN Induct_on `n` THENL [METIS_TAC [EMPTY_IN_DOTn_ZERO,APPEND_EQNS], SIMP_TAC basic_ss [DOTn_def,DOTn_RIGHT] THEN RW_TAC lang_ss [] THENL - [`?u1 u2. (u = u1 ++ u2) /\ (?m. u1 IN DOTn (KSTAR A dot B) m) /\ - ?k. u2 IN DOTn A k` by METIS_TAC[] THEN + [`?u1 u2. (u = u1 ++ u2) /\ (?m. u1 IN DOTn (KSTAR A dot B) m) /\ + ?k. u2 IN DOTn A k` by METIS_TAC[] THEN METIS_TAC [APPEND_ASSOC,STRCAT_IN_DOTn_SUC], - `?u1 u2. (u = u1 ++ u2) /\ (?m. u1 IN DOTn (KSTAR A dot B) m) /\ - ?k. u2 IN DOTn A k` by METIS_TAC[] THEN - Q.EXISTS_TAC `u1 ++ (u2 ++ v)` THEN Q.EXISTS_TAC `[]` THEN + `?u1 u2. (u = u1 ++ u2) /\ (?m. u1 IN DOTn (KSTAR A dot B) m) /\ + ?k. u2 IN DOTn A k` by METIS_TAC[] THEN + Q.EXISTS_TAC `u1 ++ (u2 ++ v)` THEN Q.EXISTS_TAC `[]` THEN RW_TAC lang_ss [APPEND_ASSOC] THENL [`u2 ++ v IN (KSTAR A dot B)` by (RW_TAC lang_ss [] THEN METIS_TAC[]) THEN METIS_TAC [APPEND_ASSOC,STRCAT_IN_DOTn_SUC], METIS_TAC [EMPTY_IN_DOTn_ZERO]]]] , - REPEAT (POP_ASSUM MP_TAC) THEN MAP_EVERY Q.ID_SPEC_TAC [`v`, `u`, `n`] + REPEAT (POP_ASSUM MP_TAC) THEN MAP_EVERY Q.ID_SPEC_TAC [`v`, `u`, `n`] THEN Induct_on `n'` THEN RW_TAC lang_ss [] THENL - [POP_ASSUM MP_TAC THEN Q.ID_SPEC_TAC `u` THEN + [POP_ASSUM MP_TAC THEN Q.ID_SPEC_TAC `u` THEN Induct_on`n` THEN RW_TAC lang_ss [] THENL [METIS_TAC [EMPTY_IN_DOTn_ZERO], - METIS_TAC [IN_UNION,APPEND_ASSOC,STRCAT_IN_DOTn_ADD, + METIS_TAC [IN_UNION,APPEND_ASSOC,STRCAT_IN_DOTn_ADD, STRCAT_IN_DOTn_SUC,DOTn_UNION]], `u' ++ v' IN DOTn A n' dot A` by METIS_TAC [IN_dot,DOTn_RIGHT] THEN FULL_SIMP_TAC lang_ss [] THEN - METIS_TAC [IN_UNION,APPEND_ASSOC,STRCAT_IN_DOTn_ADD, + METIS_TAC [IN_UNION,APPEND_ASSOC,STRCAT_IN_DOTn_ADD, STRCAT_IN_DOTn_SUC,DOTn_UNION]]]); (*===========================================================================*) @@ -388,28 +388,28 @@ val lemma = Q.prove val ARDENS_LEMMA = Q.store_thm ("ARDENS_LEMMA", - `!A B X:'a lang. + `!A B X:'a lang. ~([] IN A) /\ (X = (A dot X) UNION B) ==> (X = KSTAR(A) dot B)`, REPEAT STRIP_TAC THEN RW_TAC basic_ss [SET_EQ_SUBSET] THENL - [REWRITE_TAC [SUBSET_DEF] THEN GEN_TAC THEN - measureInduct_on `LENGTH x` THEN + [REWRITE_TAC [SUBSET_DEF] THEN GEN_TAC THEN + measureInduct_on `LENGTH x` THEN Cases_on `LENGTH x` THENL - [FULL_SIMP_TAC basic_ss [LENGTH_NIL,EMPTY_IN_DOT] THEN RW_TAC std_ss [] + [FULL_SIMP_TAC basic_ss [LENGTH_NIL,EMPTY_IN_DOT] THEN RW_TAC std_ss [] THENL [METIS_TAC [EMPTY_IN_KSTAR],METIS_TAC [EMPTY_IN_DOT,IN_UNION]], - STRIP_TAC THEN + STRIP_TAC THEN `x IN A dot X \/ x IN B` by METIS_TAC [IN_UNION] THENL - [`?u v. (x = u ++ v) /\ u IN A /\ v IN X` by METIS_TAC [IN_dot] THEN - `~(u = [])` by METIS_TAC [] THEN - `LENGTH v < LENGTH x` by METIS_TAC [LENGTH_LESS] THEN + [`?u v. (x = u ++ v) /\ u IN A /\ v IN X` by METIS_TAC [IN_dot] THEN + `~(u = [])` by METIS_TAC [] THEN + `LENGTH v < LENGTH x` by METIS_TAC [LENGTH_LESS] THEN `v IN KSTAR A dot B` by METIS_TAC [] THEN METIS_TAC [STRCAT_IN_KSTAR] , METIS_TAC [SUBSET_DEF,SUBSET_KSTAR_DOT]]] , MATCH_MP_TAC lemma THEN Induct THENL [RW_TAC basic_ss [DOTn_def,SUBSET_DEF,dot_def] THEN METIS_TAC [IN_UNION], - `A dot (DOTn A n dot B) SUBSET (A dot X)` + `A dot (DOTn A n dot B) SUBSET (A dot X)` by METIS_TAC [DOT_MONO,SUBSET_REFL] THEN - SIMP_TAC std_ss [DOTn_def,GSYM DOT_ASSOC] THEN + SIMP_TAC std_ss [DOTn_def,GSYM DOT_ASSOC] THEN METIS_TAC [IN_UNION,SUBSET_DEF]]]); val _ = export_theory(); diff --git a/examples/pattern_match_demoScript.sml b/examples/pattern_match_demoScript.sml index 1b9ef20fbb..7273f7800d 100644 --- a/examples/pattern_match_demoScript.sml +++ b/examples/pattern_match_demoScript.sml @@ -1,5 +1,5 @@ (* This is demo / test file for new features of the pattern matcher. - It's just a collection of tests and demos, nothing substantial. + It's just a collection of tests and demos, nothing substantial. It is not even decently documented and not intended to make it back into the main branch. *) @@ -67,7 +67,7 @@ term_size (concl SWAP_ELEMENTS_def) (!v38 v37 n m e. SWAP_ELEMENTS (SUC m) (SUC n) (e::v37::v38) = e::SWAP_ELEMENTS m n (v37::v38): thm -with Define_f +with Define_f |- (!l. SWAP_ELEMENTS 0 0 l = l) /\ (!n l. SWAP_ELEMENTS (SUC n) 0 l = l) /\ @@ -146,11 +146,11 @@ val x = def_size test_pair_org_def (* 89 *) (* Test runtime performance *) (* generate input *) -local +local fun all_bool_lists 0 = [``[]:bool list``] | all_bool_lists n = - let + let val l = all_bool_lists (n - 1) fun my_cons n L = map (fn l => listSyntax.mk_cons (n,l)) L in @@ -159,7 +159,7 @@ fun all_bool_lists 0 = [``[]:bool list``] fun all_bool_pairs 1 = [T, F] | all_bool_pairs n = - let + let val l = all_bool_pairs (n - 1) fun my_cons n L = map (fn l => pairSyntax.mk_pair (n,l)) L in diff --git a/examples/pattern_matches/constrFamiliesLib.sig b/examples/pattern_matches/constrFamiliesLib.sig index c741406216..752885d422 100644 --- a/examples/pattern_matches/constrFamiliesLib.sig +++ b/examples/pattern_matches/constrFamiliesLib.sig @@ -9,7 +9,7 @@ sig (* A constructor is a combination of a term with a list of names for all it's arguments *) - type constructor + type constructor (* [mk_constructor c arg_names] generate a constructor [c] with argument names [arg_names] *) @@ -18,7 +18,7 @@ sig (* check whether a constructor has no arguments *) val constructor_is_const : constructor -> bool - (* [mk_constructor_term vs constr] construct a term + (* [mk_constructor_term vs constr] construct a term corresponding to [constr]. For the arguments variables are generated. These variables are distinct from the ones provided in the argument [vs]. @@ -41,7 +41,7 @@ sig (* [make_constructorList exh constrs] is a convenience functions that maps [mk_constructor] over constrs before calling - [mk_constructorList]. *) + [mk_constructorList]. *) val make_constructorList : bool -> (term * string list) list -> constructorList (************************) @@ -60,7 +60,7 @@ sig (* Get the case-cong stored in a constructor family. *) val constructorFamily_get_case_cong : constructorFamily -> thm - (* Get the ssfrag resulting form all the stuff + (* Get the ssfrag resulting form all the stuff in a constructor family. *) val constructorFamily_get_ssfrag : constructorFamily -> simpLib.ssfrag @@ -81,8 +81,8 @@ sig val mk_constructorFamily : constructorList * term * tactic -> constructorFamily (* [get_constructorFamily_proofObligations] returns the - proof obligations that occur when creating a new constructor family - via [mk_constructorFamily]. *) + proof obligations that occur when creating a new constructor family + via [mk_constructorFamily]. *) val get_constructorFamily_proofObligations : constructorList * term -> term (* [set_constructorFamily] sets the proof obligations that occur when @@ -92,15 +92,15 @@ sig (* [constructorFamily_of_typebase ty] extracts the constructor family for the given type [ty] from typebase. *) val constructorFamily_of_typebase : hol_type -> constructorFamily - + (************************) (* Compile DBs *) (************************) (* A compile database combines constructor families, - an ssfrag and arbitrary compilation funs. *) - + an ssfrag and arbitrary compilation funs. *) + (* A compilation fun gets a column, i.e. a list of terms together with a list of free variables in this term. @@ -124,16 +124,16 @@ sig } (* empty db *) - val empty : pmatch_compile_db + val empty : pmatch_compile_db (* a default db implemented as a reference *) val thePmatchCompileDB : pmatch_compile_db ref - (* A database represents essentially a compile fun. + (* A database represents essentially a compile fun. This functions combines all the contents of a db to turn it into a compile fun. *) val pmatch_compile_db_compile : pmatch_compile_db -> pmatch_compile_fun - (* This tries to find the family used by a call to + (* This tries to find the family used by a call to [pmatch_compile_db_compile]. If this call picks a use a hand-written compile-fun, [NONE] is returned. Similarly, if no constructor family is found for this column. *) @@ -194,7 +194,7 @@ sig (************************) (* Compile Funs *) (************************) - + (* Compilation fun that turns a column of literals into a large if-then-else case distinction. It is present automatically in the default db. *) diff --git a/examples/pattern_matches/constrFamiliesLib.sml b/examples/pattern_matches/constrFamiliesLib.sml index 259331940f..12b4b2373b 100644 --- a/examples/pattern_matches/constrFamiliesLib.sml +++ b/examples/pattern_matches/constrFamiliesLib.sml @@ -16,7 +16,7 @@ fun cong_ss thms = simpLib.SSFRAG { dprocs = [], congs = thms} -fun failwith f x = +fun failwith f x = raise (mk_HOL_ERR "constrFamiliesLib" f x) fun variants used_vs vs = let @@ -31,7 +31,7 @@ end fun list_mk_comb_subst (c, args) = (case args of [] => c | (a::args') => let - val (v, c') = dest_abs c + val (v, c') = dest_abs c in list_mk_comb_subst (subst [v |-> a] c', args') end handle HOL_ERR _ => @@ -74,7 +74,7 @@ end fun base_ty ty = let val (tn, targs) = dest_type ty - val targs' = List.rev (snd (List.foldl (fn (_, (v, l)) => (next_ty v, v::l)) (Type.alpha, []) targs)) + val targs' = List.rev (snd (List.foldl (fn (_, (v, l)) => (next_ty v, v::l)) (Type.alpha, []) targs)) in mk_type (tn, targs') end @@ -106,7 +106,7 @@ in end fun set_goal_list tl = let - val thm = encode_term_opt_list tl + val thm = encode_term_opt_list tl in proofManagerLib.set_goal ([], rhs (concl thm)) end @@ -150,7 +150,7 @@ end fun match_constructor (CONSTR (cr, args)) t = let val (t', args') = strip_comb_bounded (List.length args) t in - if (same_const t' cr) then + if (same_const t' cr) then SOME (t', zip args args') else NONE end @@ -176,8 +176,8 @@ in cl_is_exhaustive = is_exhaustive }:constructorList end -fun make_constructorList is_exhaustive constrs = - mk_constructorList is_exhaustive (List.map +fun make_constructorList is_exhaustive constrs = + mk_constructorList is_exhaustive (List.map (uncurry mk_constructor) constrs) (***************************************************) @@ -185,7 +185,7 @@ fun make_constructorList is_exhaustive constrs = (***************************************************) (* Contructor families are lists of constructors with - a cass-split constant + extra theorems. + a cass-split constant + extra theorems. *) type constructorFamily = { @@ -198,14 +198,14 @@ type constructorFamily = { nchotomy_thm : thm option } -fun constructorFamily_get_rewrites (cf : constructorFamily) = +fun constructorFamily_get_rewrites (cf : constructorFamily) = case (#one_one_thm cf, #distinct_thm cf) of (NONE, NONE) => TRUTH | (SOME thm1, NONE) => thm1 | (NONE, SOME thm2) => thm2 | (SOME thm1, SOME thm2) => CONJ thm1 thm2 -fun constructorFamily_get_ssfrag (cf : constructorFamily) = +fun constructorFamily_get_ssfrag (cf : constructorFamily) = simpLib.merge_ss [simpLib.rewrites [constructorFamily_get_rewrites cf], cong_ss [#case_cong_thm cf]] @@ -226,15 +226,15 @@ fun constructorFamily_get_case_cong (cf: constructorFamily) = fun constructorFamily_get_nchotomy_thm_opt (cf: constructorFamily) = (#nchotomy_thm cf) -(* Test datatype +(* Test datatype val _ = Datatype `test_ty = - A + A | B 'b | C bool 'a bool | D num bool` -val SOME constrL = constructorList_of_typebase ``:('a, 'b) test_ty`` -val case_const = TypeBase.case_const_of ``:('a, 'b) test_ty`` +val SOME constrL = constructorList_of_typebase ``:('a, 'b) test_ty`` +val case_const = TypeBase.case_const_of ``:('a, 'b) test_ty`` val constrL = make_constructorList false [(``{}:'a set``, []), (``\x:'a. {x}``, ["x"])] @@ -317,7 +317,7 @@ fun mk_case_const_cong_thm_term case_const (constrL : constructorList) = let val (args_l, args_r) = let fun mk_args avoid = let fun mk_arg (a_ty, (i, avoid, vs)) = - let + let val v = variant avoid (mk_var ("f"^(int_to_string i), a_ty)) in (i+1, v::avoid, v::vs) @@ -325,7 +325,7 @@ fun mk_case_const_cong_thm_term case_const (constrL : constructorList) = let val (_, _, vs_rev) = foldl mk_arg (1, avoid, []) (tl arg_tys) in List.rev vs_rev - end + end val r0 = mk_var ("x", hd arg_tys) val l0 = variant [r0] r0 @@ -347,7 +347,7 @@ fun mk_case_const_cong_thm_term case_const (constrL : constructorList) = let el (n+1) args_r) val (CONSTR (c, vns), al, ar) = extract 2 - + *) val congs_main = let fun mk_arg_vars acc avoid (a_ty, vns) = case vns of @@ -359,7 +359,7 @@ fun mk_case_const_cong_thm_term case_const (constrL : constructorList) = let mk_arg_vars (v::acc) (v::avoid) (el 2 atys, vns') end - fun process_all acc neg_pres crs als ars = + fun process_all acc neg_pres crs als ars = case (crs, als, ars) of ([], [], []) => List.rev acc | ([], [al], [ar]) => let @@ -367,8 +367,8 @@ fun mk_case_const_cong_thm_term case_const (constrL : constructorList) = let val eq_t = mk_eq (list_mk_comb (al, arg_ts), list_mk_comb (ar, arg_ts)) - - val pre_t = list_mk_conj neg_pres + + val pre_t = list_mk_conj neg_pres val t_full = list_mk_forall (arg_ts, mk_imp (pre_t, eq_t)) in List.rev (t_full :: acc) @@ -386,16 +386,16 @@ fun mk_case_const_cong_thm_term case_const (constrL : constructorList) = let end | _ => failwith "" "Something is wrong with the constructors/case constant. Wrong arity somewhere?" in - process_all [] [] (#cl_constructors constrL) (tl args_l) (tl args_r) + process_all [] [] (#cl_constructors constrL) (tl args_l) (tl args_r) end in - list_mk_forall (args_l @ args_r, + list_mk_forall (args_l @ args_r, list_mk_imp (cong_0 :: congs_main, base)) end -fun mk_nchotomy_thm_term_opt (constrL : constructorList) = +fun mk_nchotomy_thm_term_opt (constrL : constructorList) = if not (#cl_is_exhaustive constrL) then NONE else let val v = mk_var ("x", #cl_type constrL) @@ -405,7 +405,7 @@ fun mk_nchotomy_thm_term_opt (constrL : constructorList) = in list_mk_exists (vs, eq) end - + val eqs = List.map mk_disj (#cl_constructors constrL) val eqs_t = list_mk_disj eqs in @@ -414,7 +414,7 @@ fun mk_nchotomy_thm_term_opt (constrL : constructorList) = fun mk_constructorFamily_terms case_const constrL = let - val t1 = mk_one_one_thm_term_opt constrL + val t1 = mk_one_one_thm_term_opt constrL val t2 = mk_distinct_thm_term_opt constrL val t3 = SOME (mk_case_expand_thm_term case_const constrL) val t4 = SOME (mk_case_const_cong_thm_term case_const constrL) @@ -424,7 +424,7 @@ in end fun get_constructorFamily_proofObligations (constrL, case_const) = let - val ts = mk_constructorFamily_terms case_const constrL + val ts = mk_constructorFamily_terms case_const constrL val thm = encode_term_opt_list ts in rhs (concl thm) @@ -457,7 +457,7 @@ end from typebase. Do not use the default type-base functions for this but destruct the nchotomy_thm in order to get the default argument names as well. *) -fun constructorList_of_typebase ty = +fun constructorList_of_typebase ty = if null (TypeBase.constructors_of ty) then NONE else let val nchotomy_thm = TypeBase.nchotomy_of ty val eqs = strip_disj (snd (dest_forall (concl nchotomy_thm))) @@ -487,7 +487,7 @@ fun constructorFamily_of_typebase ty = let val thm_case_cong = TypeBase.case_cong_of ty (* set_constructorFamily (crL, case_split_tm) *) - val cf = mk_constructorFamily (crL, case_split_tm, + val cf = mk_constructorFamily (crL, case_split_tm, SIMP_TAC std_ss [thm_distinct, thm_one_one, thm_case_cong] THEN REPEAT STRIP_TAC THEN ( Cases_on `x` THEN @@ -514,12 +514,12 @@ type matchcol_stats = { colstat_cases : int, (* how many cases are covered ? *) - colstat_missed_constr : int + colstat_missed_constr : int (* how many constructors of the family do not appear in the column *) } -fun matchcol_stats_compare - (st1 : matchcol_stats) +fun matchcol_stats_compare + (st1 : matchcol_stats) (st2 : matchcol_stats) = let fun lex_ord (i1, i2) b = (i1 < i2) orelse ((i1 = i2) andalso b) @@ -555,9 +555,9 @@ val empty : pmatch_compile_db = { val thePmatchCompileDB = ref empty fun lookup_typeBase_constructorFamily ty = let - val b_ty = base_ty ty + val b_ty = base_ty ty in - SOME (b_ty, TypeNet.find (!typeConstrFamsDB, b_ty)) handle + SOME (b_ty, TypeNet.find (!typeConstrFamsDB, b_ty)) handle NotFound => let val cf = constructorFamily_of_typebase b_ty val net = !typeConstrFamsDB @@ -565,19 +565,19 @@ in val _ = typeConstrFamsDB := net' in SOME (b_ty, cf) - end + end end handle HOL_ERR _ => NONE -fun measure_constructorFamily (cf : constructorFamily) col = let - fun list_count p col = +fun measure_constructorFamily (cf : constructorFamily) col = let + fun list_count p col = foldl (fn (r, c) => if (p r) then c+1 else c) 0 col (* extract the constructors of the family *) val crs = List.map (fn (CONSTR (c, _)) => c) ( #cl_constructors (#constructors cf)) - fun row_is_missed (vs, p) = + fun row_is_missed (vs, p) = if (is_var p andalso mem p vs) then (* bound variables are fine *) false @@ -603,13 +603,13 @@ in colstat_cases = cases_no' } end - + fun lookup_constructorFamilies_for_type (db : pmatch_compile_db) ty = let val cts_fams = let val cts_fams = TypeNet.match (#pcdb_constrFams db, ty) val cts_fams' = Lib.flatten (List.map (fn (ty, l) => List.map (fn cf => (ty, cf)) l) cts_fams) - val cty_opt = lookup_typeBase_constructorFamily ty + val cty_opt = lookup_typeBase_constructorFamily ty val cty_l = case cty_opt of NONE => [] | SOME (ty, cf) => [(ty, cf)] @@ -636,10 +636,10 @@ fun lookup_constructorFamily force_exh (db : pmatch_compile_db) col = let val _ = if (List.null col) then (failwith "constructorFamiliesLib" "lookup_constructorFamilies: null col") else () val ty = type_of (snd (hd col)) - val cts_fams = lookup_constructorFamilies_for_type db ty - val cts_fams' = if not force_exh then + val cts_fams = lookup_constructorFamilies_for_type db ty + val cts_fams' = if not force_exh then cts_fams - else + else List.filter (fn (_, cf) => isSome (#nchotomy_thm cf)) cts_fams val weighted_fams = List.map (fn (ty, cf) => @@ -654,7 +654,7 @@ end; fun pmatch_compile_db_compile_aux db col = ( - if (List.null col) then failwith "pmatch_compile_db_compile" "col 0" else let + if (List.null col) then failwith "pmatch_compile_db_compile" "col 0" else let val fun_res = get_first (fn f => f col handle HOL_ERR _ => NONE) (#pcdb_compile_funs db) val cf_res = lookup_constructorFamily false db col @@ -670,7 +670,7 @@ fun pmatch_compile_db_compile_aux db col = ( (NONE, NONE) => (NONE, NONE) | (NONE, SOME (tycf, w)) => (SOME (process_cf_res tycf w), SOME tycf) | (SOME (thm, c_no, ss), NONE) => (SOME (thm, c_no, ss), NONE) - | (SOME (thm, c_no, ss), SOME (tycf, w)) => if (c_no < #colstat_cases w) then + | (SOME (thm, c_no, ss), SOME (tycf, w)) => if (c_no < #colstat_cases w) then (SOME (thm, c_no, ss), NONE) else (SOME (process_cf_res tycf w), SOME tycf) end ); @@ -695,7 +695,7 @@ fun pmatch_compile_db_compile_nchotomy db col = ( *) fun pmatch_compile_db_compile_nchotomy db col = ( - if (List.null col) then failwith "pmatch_compile_db_compile_nchotomy" "col 0" else let + if (List.null col) then failwith "pmatch_compile_db_compile_nchotomy" "col 0" else let val fun_res = get_first (fn f => f col handle HOL_ERR _ => NONE) (#pcdb_nchotomy_funs db) val cf_res = lookup_constructorFamily true db col @@ -705,7 +705,7 @@ fun pmatch_compile_db_compile_nchotomy db col = ( (NONE, NONE) => NONE | (NONE, SOME (tycf, _)) => process_cf_res tycf | (SOME (thm, _), NONE) => SOME thm - | (SOME (thm, _), SOME (tycf, w)) => if (0 < #colstat_missed_rows w) then + | (SOME (thm, _), SOME (tycf, w)) => if (0 < #colstat_missed_rows w) then (SOME thm) else (process_cf_res tycf) end ); @@ -808,8 +808,8 @@ fun literals_compile_fun (col:(term list * term) list) = let fun extract_literal ((vs, c), ts) = let val vars = FVL [c] empty_tmset val is_lit = not (List.exists (fn v => HOLset.member (vars, v)) vs) - in - if is_lit then HOLset.add(ts,c) else + in + if is_lit then HOLset.add(ts,c) else (if is_var c then ts else failwith "" "extract_literal") end @@ -836,7 +836,7 @@ fun literals_compile_fun (col:(term list * term) list) = let in thm2 end - + val thm0 = mk_expand_thm lits val thm1 = GEN split_fun (GEN split_arg thm0) in @@ -854,8 +854,8 @@ fun literals_nchotomy_fun (col:(term list * term) list) = let fun extract_literal ((vs, c), ts) = let val vars = FVL [c] empty_tmset val is_lit = not (List.exists (fn v => HOLset.member (vars, v)) vs) - in - if is_lit then HOLset.add(ts,c) else + in + if is_lit then HOLset.add(ts,c) else (if is_var c then ts else failwith "" "extract_literal") end @@ -880,8 +880,8 @@ fun literals_nchotomy_fun (col:(term list * term) list) = let val nchot_tm = list_mk_disj (lit_tms @ [wc_tm]) val nchot_thm = prove(nchot_tm, - SIMP_TAC std_ss [] THEN - EVERY (List.map (fn t => + SIMP_TAC std_ss [] THEN + EVERY (List.map (fn t => (BOOL_CASES_TAC t THEN REWRITE_TAC[])) lit_tms)) val nchot_thm' = GEN split_arg nchot_thm in diff --git a/examples/pattern_matches/patternMatchesExamples.sml b/examples/pattern_matches/patternMatchesExamples.sml index c555c60ea5..fb72d89ac4 100644 --- a/examples/pattern_matches/patternMatchesExamples.sml +++ b/examples/pattern_matches/patternMatchesExamples.sml @@ -3,13 +3,13 @@ (* around with the pattern match lib *) (**************************************) -open bossLib +open bossLib open patternMatchesLib open patternMatchesTheory open patternMatchesSyntax open pred_setTheory open constrFamiliesLib -open stringTheory +open stringTheory open pred_setLib val _ = Globals.priming := SOME "_" @@ -22,8 +22,8 @@ val _ = Globals.priming := SOME "_" val t = ``case x of (NONE, []) => 0`` val t' = ``CASE x OF [ ||. (NONE, []) ~> 0 ]`` -val t'' = case2pmatch true t -val t''' = case2pmatch false t +val t'' = case2pmatch true t +val t''' = case2pmatch false t val thm_t = PMATCH_INTRO_CONV t (* check that SIMP works *) @@ -35,14 +35,14 @@ val t'''' = pmatch2case t''' val thm_t'' = PMATCH_ELIM_CONV t''' val thm_t2'' = PMATCH_ELIM_CONV t2' - + (* more fancy *) -val t = ``case x of +val t = ``case x of (NONE, []) => 0 | (SOME 2, []) => 2 | (SOME 3, (x :: xs)) => 3 + x | (SOME _, (x :: xs)) => x`` -val t' = case2pmatch true t +val t' = case2pmatch true t val thm_t = PMATCH_INTRO_CONV t; (* Playing around with some examples *) @@ -66,7 +66,7 @@ val _ = pmatch2case example1; val example2 = ``PMATCH (h::t) [PMATCH_ROW (\_ . []) (\_. T) (\_. x); - PMATCH_ROW (\_. [2]) (\_. T) (\_. x); + PMATCH_ROW (\_. [2]) (\_. T) (\_. x); PMATCH_ROW (\v18. [v18]) (\v19. T) (\v18. 3); PMATCH_ROW (\ (v12,v16,v17). (v12::v16::v17)) (K T) @@ -94,7 +94,7 @@ set_trace "use pmatch_pp" 1; example1; -val thm1 = PMATCH_SIMP_CONV example1 +val thm1 = PMATCH_SIMP_CONV example1 val thm2 = PMATCH_SIMP_CONV example2 val thm3 = PMATCH_SIMP_CONV example3 @@ -130,7 +130,7 @@ proofManagerLib.drop () (* set parsing of case expression to deep ones *) set_trace "parse deep cases" 1; -val ex1 = ``case (x, y, z) of +val ex1 = ``case (x, y, z) of (x, [], NONE) => x | (x, [], SOME y) => x+y | (_, z::zs, _) => z`` @@ -151,7 +151,7 @@ set_trace "use pmatch_pp" 1 (* there are new features as well. Multiple occurences of the same variable in a pattern are fine *) -val ex2 = ``case (x, y) of +val ex2 = ``case (x, y) of (x, x) => T | _ => F`` @@ -185,8 +185,8 @@ val my_d_def = Define || (x,y,ys). (x,y::ys) ~> (my_d (x + y,ys))]` val my_d_thms = store_thm ("my_d_thms", -``(!x. x > 3 ==> (my_d (x, []) = x)) /\ - (!x. x <= 3 ==> (my_d (x, []) = 0)) /\ +``(!x. x > 3 ==> (my_d (x, []) = x)) /\ + (!x. x <= 3 ==> (my_d (x, []) = 0)) /\ (!x y ys. my_d (x, y::ys) = my_d (x + y, ys))``, REPEAT STRIP_TAC THEN ( @@ -195,8 +195,8 @@ REPEAT STRIP_TAC THEN ( (* Let's prove it via lifting *) val my_d_thms2 = store_thm ("my_d_thms2", -``(!x. x > 3 ==> (my_d (x, []) = x)) /\ - (!x. x <= 3 ==> (my_d (x, []) = 0)) /\ +``(!x. x > 3 ==> (my_d (x, []) = x)) /\ + (!x. x <= 3 ==> (my_d (x, []) = 0)) /\ (!x y ys. my_d (x, y::ys) = my_d (x + y, ys))``, REPEAT STRIP_TAC THEN ( @@ -279,7 +279,7 @@ val balance_black_dectree_def = CONV_RULE (TOP_SWEEP_CONV PMATCH_CASE_SPLIT_CONV) balance_black_def -val balance_black_dectree_def' = +val balance_black_dectree_def' = SIMP_RULE (std_ss++PMATCH_CASE_SPLIT_ss ()) [] balance_black_def @@ -300,7 +300,7 @@ val string_match_def = Define `string_match s x = ]` val string_match_dectree_def = CONV_RULE - (TOP_SWEEP_CONV PMATCH_CASE_SPLIT_CONV) + (TOP_SWEEP_CONV PMATCH_CASE_SPLIT_CONV) string_match_def @@ -318,13 +318,13 @@ val dummy_bool_def = Define `dummy_bool a b c = val dummy_bool_tm = rhs (concl (SPEC_ALL dummy_bool_def)) (* try to compile to a tree inside the logic *) -val dummy_bool_eq1 = +val dummy_bool_eq1 = PMATCH_CASE_SPLIT_CONV_HEU colHeu_first_col dummy_bool_tm -val dummy_bool_eq2 = +val dummy_bool_eq2 = PMATCH_CASE_SPLIT_CONV_HEU colHeu_last_col dummy_bool_tm -val dummy_bool_eq3 = +val dummy_bool_eq3 = PMATCH_CASE_SPLIT_CONV_HEU colHeu_default dummy_bool_tm @@ -342,9 +342,9 @@ val list_REVCASE_THM = prove (`` ((list_REVCASE [] c_nil c_snoc) = c_nil) /\ ((list_REVCASE (SNOC x xs) c_nil c_snoc) = c_snoc x xs)``, SIMP_TAC list_ss [list_REVCASE_def, rich_listTheory.NOT_SNOC_NIL]) - + val cl = make_constructorList true [ - (``[]:'a list``, []), + (``[]:'a list``, []), (``SNOC: 'a -> 'a list -> 'a list``, ["x", "xs"]) ] @@ -400,7 +400,7 @@ val tree_red_CASE_THM = prove (`` (tree_red_CASE (Red t1 n t2) f_red f_else = f_red t1 n t2) /\ (tree_red_CASE (Black t1 n t2) f_red f_else = f_else (Black t1 n t2))``, SIMP_TAC list_ss [tree_red_CASE_def, tree_case_def]) - + val cl = make_constructorList false [ (``Red``, ["t1", "n", "t2"]) ] @@ -428,7 +428,7 @@ val size_old = term_size (rhs (snd (strip_forall (concl balance_black_dectree_de val size_classic = term_size (rhs (snd (strip_forall (concl balance_black_dectree_def3)))) -(* even with the family for red, the full cases are +(* even with the family for red, the full cases are still available when needed (notice the added row above the last one) *) val t = `` @@ -460,7 +460,7 @@ val my_divmod_def = Define `my_divmod (n:num) c = val my_divmod_THM_AUX = PMATCH_TO_TOP_RULE my_divmod_def -val my_divmod_THM = store_thm ("my_divmod_THM", +val my_divmod_THM = store_thm ("my_divmod_THM", ``0 < c ==> (my_divmod n c = (n DIV c, n MOD c))``, REPEAT STRIP_TAC THEN @@ -615,7 +615,7 @@ val t = ``CASE (x, z) OF [ ||. (_, NONE) ~> 2 ]`` -(* The last row is redundant, but it needs both first +(* The last row is redundant, but it needs both first rows to show this. Therefore, the fast test, which only considers single rows, fails. *) diff --git a/examples/pattern_matches/patternMatchesLib.sig b/examples/pattern_matches/patternMatchesLib.sig index e689bff04b..c942a5ce9a 100644 --- a/examples/pattern_matches/patternMatchesLib.sig +++ b/examples/pattern_matches/patternMatchesLib.sig @@ -38,9 +38,9 @@ sig non-constructor patterns. *) val pmatch2case : term -> term - (* The following conversions call + (* The following conversions call case2pmatch and pmatch2case and - afterwards prove the equivalence of + afterwards prove the equivalence of the result. *) val PMATCH_INTRO_CONV : conv val PMATCH_INTRO_CONV_NO_OPTIMISE : conv @@ -121,7 +121,7 @@ sig cases explicitly. This is often handy to prove properties about functions defined via pattern matches without the need to - do the case-splits manually. + do the case-splits manually. This tactic looks for the smallest wrapper around a PMATCH such that the term is of type @@ -160,7 +160,7 @@ sig (* A column heuristic is used to figure out, in which order to process columns. It gets a list of columns - and returns, which one to pick. *) + and returns, which one to pick. *) type column_heuristic = (term * (term list * term) list) list -> int (* Many heuristics are build on ranking funs. @@ -233,7 +233,7 @@ sig original ones and are exhaustive. Moreover these patterns usually have some nice properties like e.g. not overlapping with each other. Such a nchotomy theorem is often handy. We use it to check for - exhaustiveness for example. The interface + exhaustiveness for example. The interface to compute such an nchotomy is exponsed here as well. *) (* [nchotomy_of_pats_GEN db colHeu pats] computes an nchotomy-theorem @@ -260,14 +260,14 @@ sig (* The redundancy removal conversion works by first creating a is-redundant-rows-info theorem and - then turning it into a PMATCH equation. One can + then turning it into a PMATCH equation. One can separate these steps, this allows using interactive proofs for showing that a row is redundant. *) val COMPUTE_REDUNDANT_ROWS_INFO_OF_PMATCH_GEN : ssfrag list -> constrFamiliesLib.pmatch_compile_db -> column_heuristic -> term -> thm val COMPUTE_REDUNDANT_ROWS_INFO_OF_PMATCH : term -> thm - (* Apply the resulting redundant rows-info *) + (* Apply the resulting redundant rows-info *) val IS_REDUNDANT_ROWS_INFO_TO_PMATCH_EQ_THM : thm -> thm @@ -291,7 +291,7 @@ sig val PMATCH_IS_EXHAUSTIVE_CONSEQ_CONV : ConseqConv.conseq_conv; - val PMATCH_IS_EXHAUSTIVE_CONSEQ_CONV_GEN : + val PMATCH_IS_EXHAUSTIVE_CONSEQ_CONV_GEN : constrFamiliesLib.pmatch_compile_db -> column_heuristic -> ssfrag list -> ConseqConv.conseq_conv; @@ -300,7 +300,7 @@ sig expression is exhaustive might be adding at the end additional rows that explicitly list the missing pats and return ARB for them. This is achieved by the following - functions. + functions. The additional patterns can use guards or not. If not guards are used, the added patterns are more coarse, but @@ -312,7 +312,7 @@ sig (* and as usual more general versions that allows using own pattern compilation settings *) val PMATCH_COMPLETE_CONV_GEN : ssfrag list -> - constrFamiliesLib.pmatch_compile_db -> column_heuristic -> + constrFamiliesLib.pmatch_compile_db -> column_heuristic -> bool -> conv val PMATCH_COMPLETE_GEN_ss : ssfrag list -> @@ -326,8 +326,8 @@ sig (* [show_nchotomy t] tries to prove an nchotomy-theorem. Given an nchotomy theorem of the form - ``!x. (?xs1. v = p1 xs1 /\ g1 xs1) \/ ... \/ - (?xsn. v = pn xsn /\ gn xsn)``. + ``!x. (?xs1. v = p1 xs1 /\ g1 xs1) \/ ... \/ + (?xsn. v = pn xsn /\ gn xsn)``. It returns a theorem that is an implication with the input as conclusion. *) val SHOW_NCHOTOMY_CONSEQ_CONV : ConseqConv.conseq_conv diff --git a/examples/pattern_matches/patternMatchesLib.sml b/examples/pattern_matches/patternMatchesLib.sml index 117b274930..15e930e174 100644 --- a/examples/pattern_matches/patternMatchesLib.sml +++ b/examples/pattern_matches/patternMatchesLib.sml @@ -34,7 +34,7 @@ fun does_conv_loop thm = let fun my_mk_abs t = list_mk_abs (free_vars_lr t, t) val l' = my_mk_abs l val const_check = let - val (l_c, _) = strip_comb l + val (l_c, _) = strip_comb l in fn t => (same_const (fst (strip_comb t)) l_c) end handle HOL_ERR _ => (fn t => true) @@ -134,7 +134,7 @@ val static_ss = simpLib.merge_ss PAIR_EQ_COLLAPSE, oneTheory.one]]; -(* We add the stateful rewrite set (to simplify +(* We add the stateful rewrite set (to simplify e.g. case-constants or constructors) and a custum component as well. *) fun rc_ss gl = srw_ss() ++ simpLib.merge_ss (static_ss :: gl) @@ -170,7 +170,7 @@ end (* fix_appends expects a theorem of the form PMATCH v rows = PMATCH v' rows' - + and a term l of form PMATCH v rows0. @@ -205,7 +205,7 @@ in thm3 end -(* Apply a conversion to all args of a PMATCH_ROW, i.e. given +(* Apply a conversion to all args of a PMATCH_ROW, i.e. given a term of the form ``PMATCH_ROW pat guard rhs i`` it applies a conversion to ``pat`` ``guard`` and ``rhs``. *) fun PMATCH_ROW_ARGS_CONV c = @@ -291,7 +291,7 @@ fun dest_case_fun t = dest_case_fun_aux1 t handle HOL_ERR _ => dest_case_fun_aux (* try to collapse rows by introducing a catchall at end*) fun dest_case_fun_collapse (a, ps) = let - + (* find all possible catch-all clauses *) fun check_collapsable (p, rh) = let val p_vs = FVL [p] empty_tmset @@ -301,14 +301,14 @@ fun dest_case_fun_collapse (a, ps) = let in if ok then SOME rh' else NONE end - + val catch_all_cands = List.foldl (fn (prh, cs) => case check_collapsable prh of NONE => cs | SOME rh => rh::cs) [] ps (* really collapse *) - fun is_not_cought ca (p, rh) = + fun is_not_cought ca (p, rh) = not (aconv rh (Term.subst [a |-> p] ca)) val all_collapse_opts = List.map (fn ca => (ca, filter (is_not_cought ca) ps)) catch_all_cands @@ -319,9 +319,9 @@ fun dest_case_fun_collapse (a, ps) = let in if (List.null all_collapse_opts) then (a, ps) else let - val (ca', ps') = hd all_collapse_opts_sorted + val (ca', ps') = hd all_collapse_opts_sorted in if (List.length ps' + 1 < List.length ps) then - (a, (ps' @ [(a, ca')])) + (a, (ps' @ [(a, ca')])) else (a, ps) end end @@ -370,7 +370,7 @@ fun case2pmatch_remove_unnessary_rows ps = let | r2::rs' => let val r2' = mk_distinct_rows r1 r2 in - if pats_unify r1 r2' then ( + if pats_unify r1 r2' then ( not (row_subsumed r1 r2') ) else row_is_needed r1 rs' end @@ -384,8 +384,8 @@ fun case2pmatch_remove_unnessary_rows ps = let val ps' = case ps of [] => [] | (p, rh)::_ => (ps @ [(genvar (type_of p), mk_arb (type_of rh))]) - -in + +in check_rows [] ps' end @@ -436,7 +436,7 @@ end (* So far, we converted a classical case-expression to a PMATCH without any proof. The following is used to prove the equivalence of the result via repeated - case-splits and evaluation. This allows to + case-splits and evaluation. This allows to define some conversions then. *) val COND_CONG_STOP = prove (`` @@ -460,10 +460,10 @@ in end handle HOL_ERR _ => raise UNCHANGED -fun PMATCH_INTRO_CONV t = +fun PMATCH_INTRO_CONV t = case_pmatch_eq_prove t (case2pmatch true t) -fun PMATCH_INTRO_CONV_NO_OPTIMISE t = +fun PMATCH_INTRO_CONV_NO_OPTIMISE t = case_pmatch_eq_prove t (case2pmatch false t) @@ -473,7 +473,7 @@ fun PMATCH_INTRO_CONV_NO_OPTIMISE t = (* convert a case-term into a PMATCH-term, without any proofs *) fun pmatch2case t = let - val (v, rows) = dest_PMATCH t + val (v, rows) = dest_PMATCH t val fv = genvar (type_of v --> type_of t) fun process_row r = let @@ -508,7 +508,7 @@ in case_tm end -fun PMATCH_ELIM_CONV t = +fun PMATCH_ELIM_CONV t = case_pmatch_eq_prove t (pmatch2case t) @@ -538,8 +538,8 @@ val (rows, _) = listSyntax.dest_list (rand t) *) (* For removing redundant rows we want to check whether - the pattern of a row is overlapped by the pattern of a - previous row. In preparation for this, we extract all + the pattern of a row is overlapped by the pattern of a + previous row. In preparation for this, we extract all patterns and generate fresh variables for it. The we build for all rows the pair of the pattern + the patterns of all following rows. This allows for simple checks @@ -547,7 +547,7 @@ val (rows, _) = listSyntax.dest_list (rand t) fun compute_row_pat_pairs rows = let (* get pats with fresh vars to do a quick prefiltering *) val pats_unique = Lib.enumerate 0 (Lib.mapfilter (fn r => let - val (p, _, _) = dest_PMATCH_ROW r + val (p, _, _) = dest_PMATCH_ROW r val (vars_tm, pb) = pairSyntax.dest_pabs p val vars = pairSyntax.strip_pair vars_tm val s = List.map (fn v => (v |-> genvar (type_of v))) vars @@ -595,10 +595,10 @@ fun PMATCH_REMOVE_FAST_REDUNDANT_CONV_GENCALL_SINGLE rc_arg t = let val rows1_tm = listSyntax.mk_list (rows1, type_of r1) val rows2_tm = listSyntax.mk_list (rows2, type_of r1) - val r1rows2_tm = listSyntax.mk_cons (r1, rows2_tm) + val r1rows2_tm = listSyntax.mk_cons (r1, rows2_tm) val rows3_tm = listSyntax.mk_list (rows3, type_of r1) - val r2rows3_tm = listSyntax.mk_cons (r2, rows3_tm) - + val r2rows3_tm = listSyntax.mk_cons (r2, rows3_tm) + val arg = listSyntax.list_mk_append [rows1_tm, r1rows2_tm, r2rows3_tm] in mk_PMATCH v arg @@ -611,7 +611,7 @@ fun PMATCH_REMOVE_FAST_REDUNDANT_CONV_GENCALL_SINGLE rc_arg t = let val thm3 = fix_appends rc_arg t thm2 in thm3 - end + end in Lib.tryfind try_pair cands end handle HOL_ERR _ => raise UNCHANGED @@ -655,7 +655,7 @@ val t = case expression might e.g. not be exhaustive any more. This can also cause trouble for code generation. Therefore the parameter [exploit_match_exp] determines, whether this optimisation is performed. *) -fun PMATCH_REMOVE_SUBSUMED_CONV_GENCALL_SINGLE +fun PMATCH_REMOVE_SUBSUMED_CONV_GENCALL_SINGLE exploit_match_exp rc_arg t = let val (v, rows) = dest_PMATCH t val candidates = compute_row_pat_pairs rows @@ -676,7 +676,7 @@ fun PMATCH_REMOVE_SUBSUMED_CONV_GENCALL_SINGLE (dest_arb r; (i, (NONE : int option))) end) (Lib.enumerate 0 rows) val cands = if exploit_match_exp then (cands_sub @ cands_arb) else - cands_sub + cands_sub (* val (r_no1, r_no2_opt) = el 2 cands_arb *) fun try_pair (r_no1, r_no2_opt) = let @@ -688,7 +688,7 @@ fun PMATCH_REMOVE_SUBSUMED_CONV_GENCALL_SINGLE val rows_rest = List.drop (rs, r_no1+1) val rows1_tm = mk_row_list rows1 - fun build_tm rest_tm = + fun build_tm rest_tm = listSyntax.mk_append (rows1_tm, (listSyntax.mk_cons (r1, rest_tm))) in @@ -720,7 +720,7 @@ fun PMATCH_REMOVE_SUBSUMED_CONV_GENCALL_SINGLE val thm3 = fix_appends rc_arg t thm2 in thm3 - end + end in Lib.tryfind try_pair cands end handle HOL_ERR _ => raise UNCHANGED @@ -1462,7 +1462,7 @@ PMATCH (SOME y,x,l) ]`` *) -fun PMATCH_SIMP_CONV_GENCALL_AUX rc_arg = +fun PMATCH_SIMP_CONV_GENCALL_AUX rc_arg = REPEATC (FIRST_CONV [ CHANGED_CONV (PMATCH_CLEANUP_PVARS_CONV), CHANGED_CONV (PMATCH_CLEANUP_CONV_GENCALL rc_arg), @@ -1476,15 +1476,15 @@ REPEATC (FIRST_CONV [ ]); -fun PMATCH_SIMP_CONV_GENCALL rc_arg t = - if (is_PMATCH t) then PMATCH_SIMP_CONV_GENCALL_AUX rc_arg t else +fun PMATCH_SIMP_CONV_GENCALL rc_arg t = + if (is_PMATCH t) then PMATCH_SIMP_CONV_GENCALL_AUX rc_arg t else raise UNCHANGED fun PMATCH_SIMP_CONV_GEN ssl = PMATCH_SIMP_CONV_GENCALL (ssl, NONE) val PMATCH_SIMP_CONV = PMATCH_SIMP_CONV_GEN []; -fun PMATCH_SIMP_GEN_ss ssl = +fun PMATCH_SIMP_GEN_ss ssl = make_gen_conv_ss PMATCH_SIMP_CONV_GENCALL "PMATCH_SIMP_REDUCER" ssl val PMATCH_SIMP_ss = PMATCH_SIMP_GEN_ss [] @@ -1494,13 +1494,13 @@ val PMATCH_SIMP_ss = PMATCH_SIMP_GEN_ss [] (* Remove double var bindings *) (***********************************************) -fun force_unique_vars s no_change avoid t = +fun force_unique_vars s no_change avoid t = case Psyntax.dest_term t of - Psyntax.VAR (_, _) => + Psyntax.VAR (_, _) => if (mem t no_change) then (s, avoid, t) else let val v' = variant avoid t - val avoid' = v'::avoid + val avoid' = v'::avoid val s' = if (v' = t) then s else ((v', t)::s) in (s', avoid', v') end | Psyntax.CONST _ => (s, avoid, t) @@ -1530,25 +1530,25 @@ fun PMATCH_ROW_REMOVE_DOUBLE_BIND_CONV_GENCALL rc_arg row = let val (p_t, g_t, r_t) = dest_PMATCH_ROW row val (vars_tm, p_tb) = pairSyntax.dest_pabs p_t val vars = pairSyntax.strip_pair vars_tm - + val (new_binds, _, p_tb') = force_unique_vars [] (free_vars p_t) [] p_tb val _ = if List.null new_binds then raise UNCHANGED else () val vars' = vars @ (List.map fst new_binds) val g_v = genvar (type_of g_t) val r_v = genvar (type_of r_t) - + val g_t' = list_mk_conj ((List.map mk_eq new_binds)@[mk_comb (g_v, vars_tm)]) val r_t' = mk_comb (r_v, vars_tm) - + val row' = mk_PMATCH_ROW_PABS vars' (p_tb', g_t', r_t') val row0 = mk_PMATCH_ROW (p_t, g_v, r_v) val thm0_tm = mk_eq (row0, row') val thm0 = let val thm0 = FRESH_TY_VARS_RULE PMATCH_ROW_REMOVE_DOUBLE_BINDS_THM - val g_tm = pairSyntax.mk_pabs (vars_tm, + val g_tm = pairSyntax.mk_pabs (vars_tm, subst (List.map (fn (v, v') => (v |-> v')) new_binds) (pairSyntax.list_mk_pair vars')) val thm1 = ISPEC g_tm thm0 @@ -1557,7 +1557,7 @@ fun PMATCH_ROW_REMOVE_DOUBLE_BIND_CONV_GENCALL rc_arg row = let in thm3 end - + val thm1 = INST [(g_v |-> g_t), (r_v |-> r_t)] thm0 val thm1a_tm = mk_eq (row, lhs (concl thm1)) @@ -1571,16 +1571,16 @@ in thm3 end handle HOL_ERR _ => raise UNCHANGED -fun PMATCH_REMOVE_DOUBLE_BIND_CONV_GENCALL rc_arg t = +fun PMATCH_REMOVE_DOUBLE_BIND_CONV_GENCALL rc_arg t = PMATCH_ROWS_CONV (PMATCH_ROW_REMOVE_DOUBLE_BIND_CONV_GENCALL rc_arg) t -fun PMATCH_REMOVE_DOUBLE_BIND_CONV_GEN ssl = +fun PMATCH_REMOVE_DOUBLE_BIND_CONV_GEN ssl = PMATCH_REMOVE_DOUBLE_BIND_CONV_GENCALL (ssl, NONE) val PMATCH_REMOVE_DOUBLE_BIND_CONV = PMATCH_REMOVE_DOUBLE_BIND_CONV_GEN []; -fun PMATCH_REMOVE_DOUBLE_BIND_GEN_ss ssl = +fun PMATCH_REMOVE_DOUBLE_BIND_GEN_ss ssl = make_gen_conv_ss PMATCH_ROW_REMOVE_DOUBLE_BIND_CONV_GENCALL "PMATCH_REMOVE_DOUBLE_BIND_REDUCER" ssl val PMATCH_REMOVE_DOUBLE_BIND_ss = PMATCH_REMOVE_DOUBLE_BIND_GEN_ss [] @@ -1641,7 +1641,7 @@ fun PMATCH_REMOVE_GUARD_AUX rc_arg t = let val thm2 = CONV_RULE (RHS_CONV (RAND_CONV (RAND_CONV (RATOR_CONV (RAND_CONV PMATCH_ROW_FORCE_SAME_VARS_CONV))))) thm -in +in thm2 end handle HOL_ERR _ => raise UNCHANGED @@ -1662,7 +1662,7 @@ fun PMATCH_REMOVE_GUARDS_CONV_GEN ssl = PMATCH_REMOVE_GUARDS_CONV_GENCALL (ssl, val PMATCH_REMOVE_GUARDS_CONV = PMATCH_REMOVE_GUARDS_CONV_GEN []; -fun PMATCH_REMOVE_GUARDS_GEN_ss ssl = +fun PMATCH_REMOVE_GUARDS_GEN_ss ssl = make_gen_conv_ss PMATCH_REMOVE_GUARDS_CONV_GENCALL "PMATCH_REMOVE_GUARDS_REDUCER" ssl val PMATCH_REMOVE_GUARDS_ss = PMATCH_REMOVE_GUARDS_GEN_ss [] @@ -1674,15 +1674,15 @@ val PMATCH_REMOVE_GUARDS_ss = PMATCH_REMOVE_GUARDS_GEN_ss [] (* One can replace pattern matches with a big-conjunction. Each row becomes one conjunct. Since the conjunction is - of type bool, this needs to be done at a boolean level. - So we can replace an arbitry term + of type bool, this needs to be done at a boolean level. + So we can replace an arbitry term P (PMATCH i rows) with (row_cond 1 i -> P (row_rhs 1)) /\ ... (row_cond n i -> P (row_rhs n)) /\ - + The row-cond contains that the pattern does not overlap with any previous pattern, that the guard holds. @@ -1695,7 +1695,7 @@ val PMATCH_REMOVE_GUARDS_ss = PMATCH_REMOVE_GUARDS_GEN_ss [] rewrite rules for the function f. *) -(* +(* @@ -1748,9 +1748,9 @@ in val c = (RAND_CONV (pairTools.PABS_INTRO_CONV vars_tm)) THENC TRY_CONV (pairTools.ELIM_TUPLED_QUANT_CONV) THENC SIMP_CONV std_ss [] - val c2a_inj = RHS_CONV (RATOR_CONV (RAND_CONV c)) - val c2a_no_inj = RHS_CONV (RATOR_CONV (RAND_CONV - (BINOP_CONV c))) + val c2a_inj = RHS_CONV (RATOR_CONV (RAND_CONV c)) + val c2a_no_inj = RHS_CONV (RATOR_CONV (RAND_CONV + (BINOP_CONV c))) val c2a = if is_inj then c2a_inj else c2a_no_inj val thm2a = CONV_RULE c2a thm1 val thm2b = CONV_RULE (RHS_CONV (RAND_CONV (RATOR_CONV (RAND_CONV c)))) thm2a @@ -1762,8 +1762,8 @@ in val thm3 = let val c = PMATCH_LIFT_BOOL_CONV_AUX rc_arg val thm3 = CONV_RULE (RHS_CONV (RAND_CONV (RAND_CONV c))) thm2 - in - thm3 + in + thm3 end in thm3 @@ -1827,7 +1827,7 @@ fun PMATCH_LIFT_BOOL_CONV_GENCALL rc_arg tm = let in thm1c end - + (* restore original predicate *) val thm2 = let val thm2a = INST [P_v |-> P_tm] thm1 @@ -1836,7 +1836,7 @@ fun PMATCH_LIFT_BOOL_CONV_GENCALL rc_arg tm = let val _ = assert (fn thm => aconv (lhs (concl thm)) tm) thm2c in thm2c - end + end in thm2 end @@ -1845,7 +1845,7 @@ fun PMATCH_LIFT_BOOL_CONV_GEN ssl = PMATCH_LIFT_BOOL_CONV_GENCALL (ssl, NONE) val PMATCH_LIFT_BOOL_CONV = PMATCH_LIFT_BOOL_CONV_GEN []; -fun PMATCH_LIFT_BOOL_GEN_ss ssl = +fun PMATCH_LIFT_BOOL_GEN_ss ssl = make_gen_conv_ss PMATCH_LIFT_BOOL_CONV_GENCALL "PMATCH_LIFT_BOOL_REDUCER" ssl val PMATCH_LIFT_BOOL_ss = PMATCH_LIFT_BOOL_GEN_ss [] @@ -1856,10 +1856,10 @@ fun PMATCH_TO_TOP_RULE_SINGLE ssl thm = let val thm1 = CONV_RULE (DEPTH_CONV (PMATCH_LIFT_BOOL_CONV_GEN ssl)) thm0 val thm2 = CONV_RULE (STRIP_QUANT_CONV ( EVERY_CONJ_CONV (STRIP_QUANT_CONV (TRY_CONV (RAND_CONV markerLib.stmark_term))))) thm1 - val thm3 = SIMP_RULE std_ss [FORALL_AND_THM, + val thm3 = SIMP_RULE std_ss [FORALL_AND_THM, Cong (REFL ``stmarker (t:'a)``)] thm2 val thm4 = PURE_REWRITE_RULE [markerTheory.stmarker_def] thm3 -in +in thm4 end @@ -1880,10 +1880,10 @@ fun PMATCH_TO_TOP_RULE thm = PMATCH_TO_TOP_RULE_GEN [] thm; (***********************************************) (* A column heuristic is a function that chooses the - next column to perform a case split on. + next column to perform a case split on. It gets a list of columns of the pattern match, i.e. the input value + a list of the patterns in each row. - The patterns are represented as a pair of + The patterns are represented as a pair of a list of free variables and the real pattern. *) type column = (term * (term list * term) list) type column_heuristic = column list -> int @@ -1918,18 +1918,18 @@ in | ((i, _) :: _) => i end) : column_heuristic - + (* ranking functions *) fun colRank_first_row (_:term, rows) = ( case rows of [] => 0 - | (vs, p) :: _ => + | (vs, p) :: _ => if (is_var p andalso mem p vs) then 0 else 1); fun colRank_first_row_constr db (_, rows) = case rows of [] => 0 | ((vs, p) :: _) => if (is_var p andalso mem p vs) then 0 else - case pmatch_compile_db_compile_cf db rows of + case pmatch_compile_db_compile_cf db rows of NONE => 0 | SOME cf => let val (exh, constrL) = constructorFamily_get_constructors cf; @@ -1937,18 +1937,18 @@ fun colRank_first_row_constr db (_, rows) = case rows of val cL_cf = List.map fst constrL; val p_c_ok = op_mem same_const p_c cL_cf in - (if p_c_ok then 1 else 0) + (if p_c_ok then 1 else 0) end handle HOL_ERR _ => 0; val colRank_constr_prefix : column_ranking_fun = (fn (_, rows) => let fun aux n [] = n - | aux n ((vs, p) :: pL) = if (is_var p andalso mem p vs) + | aux n ((vs, p) :: pL) = if (is_var p andalso mem p vs) then n else aux (n+1) pL in aux 0 rows end) fun col_get_constr_set db (_, rows) = - case pmatch_compile_db_compile_cf db rows of + case pmatch_compile_db_compile_cf db rows of NONE => NONE | SOME cf => let val (exh, constrL) = constructorFamily_get_constructors cf; @@ -1963,7 +1963,7 @@ fun col_get_constr_set db (_, rows) = fun col_get_nonvar_set (_, rows) = let - val cL' = List.filter (fn (vs, p) => + val cL' = List.filter (fn (vs, p) => not (is_var p andalso mem p vs)) rows; val cL'' = Lib.mk_set cL'; in @@ -1987,7 +1987,7 @@ fun colRank_arity db : column_ranking_fun = (fn col => val colHeu_first_row = colHeu_rank [colRank_first_row] val colHeu_constr_prefix = colHeu_rank [colRank_constr_prefix] fun colHeu_qba db = colHeu_rank [colRank_constr_prefix, colRank_small_branching_factor db, colRank_arity db] -fun colHeu_cqba db = colHeu_rank [colRank_first_row_constr db, +fun colHeu_cqba db = colHeu_rank [colRank_first_row_constr db, colRank_constr_prefix, colRank_small_branching_factor db, colRank_arity db] (* A list of all the standard heuristics *) @@ -2052,7 +2052,7 @@ fun PMATCH_CASE_SPLIT_CONV_GENCALL_STEP (gl, callback_opt) db col_heu t = let fun find_col cols = if (List.null cols) then raise UNCHANGED else let val col_no = col_heu cols val (v, col) = el (col_no+1) cols - val res = pmatch_compile_db_compile db col + val res = pmatch_compile_db_compile db col in case res of SOME (expand_thm, _, expand_ss) => (col_no, expand_thm, expand_ss) @@ -2066,7 +2066,7 @@ fun PMATCH_CASE_SPLIT_CONV_GENCALL_STEP (gl, callback_opt) db col_heu t = let end val (col_no, expand_thm, expand_ss) = find_col (dest_PMATCH_COLS t) - val thm1 = QCHANGED_CONV (PMATCH_CASE_SPLIT_AUX + val thm1 = QCHANGED_CONV (PMATCH_CASE_SPLIT_AUX (expand_ss::gl, callback_opt) col_no expand_thm) t (* check whether it got simpler *) @@ -2079,7 +2079,7 @@ end val pair_CASE_tm = mk_const ("pair_CASE", ``:'a # 'b -> ('a -> 'b -> 'c) -> 'c``) fun PMATCH_CASE_SPLIT_CONV_GENCALL rc_arg db col_heu t = let - val thm0 = PMATCH_SIMP_CONV_GENCALL rc_arg t handle + val thm0 = PMATCH_SIMP_CONV_GENCALL rc_arg t handle HOL_ERR _ => REFL t | UNCHANGED => REFL t val t' = rhs (concl thm0) @@ -2091,7 +2091,7 @@ fun PMATCH_CASE_SPLIT_CONV_GENCALL rc_arg db col_heu t = let fun mk_pair avoid acc col_no v = if (col_no <= 1) then ( let val vs = List.rev (v::acc) - val p = pairSyntax.list_mk_pair vs + val p = pairSyntax.list_mk_pair vs val rows_tm = listSyntax.mk_list (rows, type_of (hd rows)) in mk_PMATCH p rows_tm @@ -2106,7 +2106,7 @@ fun PMATCH_CASE_SPLIT_CONV_GENCALL rc_arg db col_heu t = let val t1 = mk_comb (t0, v) val t2a = mk_pair (v1::v2::avoid) (v1::acc) (col_no-1) v2 val t2b = list_mk_abs ([v1, v2], t2a) - val t2c = mk_comb (t1, t2b) + val t2c = mk_comb (t1, t2b) in t2c end @@ -2128,24 +2128,24 @@ fun PMATCH_CASE_SPLIT_CONV_GENCALL rc_arg db col_heu t = let val _ = if (does_conv_loop thm3) then raise UNCHANGED else () val thm4 = if (has_subterm is_PMATCH (rhs (concl thm3))) then - thm3 + thm3 else CONV_RULE (RHS_CONV REMOVE_REBIND_CONV) thm3 in thm4 end -fun PMATCH_CASE_SPLIT_CONV_GEN ssl = PMATCH_CASE_SPLIT_CONV_GENCALL (ssl, NONE) +fun PMATCH_CASE_SPLIT_CONV_GEN ssl = PMATCH_CASE_SPLIT_CONV_GENCALL (ssl, NONE) -fun PMATCH_CASE_SPLIT_CONV_HEU col_heu t = +fun PMATCH_CASE_SPLIT_CONV_HEU col_heu t = PMATCH_CASE_SPLIT_CONV_GEN [] (!thePmatchCompileDB) col_heu t -fun PMATCH_CASE_SPLIT_CONV t = +fun PMATCH_CASE_SPLIT_CONV t = PMATCH_CASE_SPLIT_CONV_HEU colHeu_default t -fun PMATCH_CASE_SPLIT_GEN_ss ssl db col_heu = +fun PMATCH_CASE_SPLIT_GEN_ss ssl db col_heu = make_gen_conv_ss (fn rc_arg => - PMATCH_CASE_SPLIT_CONV_GENCALL rc_arg db col_heu) + PMATCH_CASE_SPLIT_CONV_GENCALL rc_arg db col_heu) "PMATCH_CASE_SPLIT_REDUCER" ssl fun PMATCH_CASE_SPLIT_HEU_ss col_heu = @@ -2186,22 +2186,22 @@ val t = `` *) local - + val case_dist_exists_thm = prove (``!Q. ( (!(x:'a). Q x) ==> !P. (?x. P x) = (?x. Q x /\ P x))``, SIMP_TAC std_ss []); - + val label_over_or_thm = prove ( - ``(lbl :- (t1 \/ t2)) <=> (lbl :- t1) \/ (lbl :- t2)``, + ``(lbl :- (t1 \/ t2)) <=> (lbl :- t1) \/ (lbl :- t2)``, REWRITE_TAC[markerTheory.label_def]); - + fun find_nchotomy_for_cols db col_heu cols = let - val _ = if (List.null cols) then + val _ = if (List.null cols) then raise failwith "compile failed" else () val col_no = col_heu cols val (v, col) = el (col_no+1) cols - val nchot_thm_opt = pmatch_compile_db_compile_nchotomy db col + val nchot_thm_opt = pmatch_compile_db_compile_nchotomy db col in case nchot_thm_opt of SOME nchot_thm => (v, ISPEC v nchot_thm) @@ -2211,20 +2211,20 @@ local find_nchotomy_for_cols db col_heu cols' end end - + fun mk_initial_state var_gen lbl_gen pats = let val (_, p) = pairSyntax.dest_pabs (hd pats) val cs = pairLib.strip_pair p - val vs = List.map (fn p => var_gen (type_of p)) cs + val vs = List.map (fn p => var_gen (type_of p)) cs val initial_value = pairLib.list_mk_pair vs val cols = dest_PATLIST_COLS initial_value pats - + val lbl = lbl_gen () val initial_thm = let val x_tm = mk_var ("x", type_of initial_value) val tm = mk_forall (x_tm, markerSyntax.mk_label (lbl, list_mk_exists (vs, mk_eq (x_tm, initial_value)))) - val thm = prove (tm, + val thm = prove (tm, SIMP_TAC std_ss [pairTheory.FORALL_PROD, markerTheory.label_def]) in thm end in @@ -2234,19 +2234,19 @@ local fun compute_cases_info var_gen lbl_gen v nthm = let val disjuncts = ref ([] : (string * term * term list) list) - + (* val d = el 2 ds *) fun process_disj d = let val lbl = lbl_gen () - (* intro fresh vars *) - val d_thm = let + (* intro fresh vars *) + val d_thm = let val (evs, d_b) = strip_exists d val s = List.map (fn v => (v |-> var_gen (type_of v))) evs val evs = List.map (Term.subst s) evs val d_b = Term.subst s d_b val d' = list_mk_exists (evs, d_b) - val d_thm = ALPHA d d' + val d_thm = ALPHA d d' in d_thm end @@ -2268,66 +2268,66 @@ local val _ = disjuncts := (lbl, c, evs) :: !disjuncts in () end handle HOL_ERR _ => () in - ld_thm + ld_thm end handle HOL_ERR _ => raise UNCHANGED (* val ds = strip_disj (concl nthm) *) val nthm' = CONV_RULE (ALL_DISJ_CONV process_disj) nthm in (nthm', List.rev (!disjuncts)) - end - + end + fun exists_left_and_label_CONV t = let val (lbls_left, _) = (strip_labels o fst o dest_conj o snd o dest_exists) t val (lbls_right, _) = (strip_labels o snd o dest_conj o snd o dest_exists) t - + val c_remove = QUANT_CONV (BINOP_CONV (REPEATC markerLib.DEST_LABEL_CONV)) - + val thm0 = (c_remove THENC (add_labels_CONV (lbls_left @ lbls_right))) t in thm0 end - + fun expand_disjunction_CONV v nthm_expand d_tm = let val thm00 = RESORT_EXISTS_CONV (fn vs => let val (v', vs') = pick_element (aconv v) vs in (v'::vs') end) d_tm - + val thm01a = HO_PART_MATCH (lhs o snd o strip_forall) nthm_expand (rhs (concl thm00)) val thm01 = TRANS thm00 thm01a - + val thm02 = RIGHT_CONV_RULE (PURE_REWRITE_CONV [RIGHT_AND_OVER_OR]) thm01 val thm03 = RIGHT_CONV_RULE (DECEND_CONV BINOP_CONV (TRY_CONV EXISTS_OR_CONV)) thm02 - + val thm04 = RIGHT_CONV_RULE (ALL_DISJ_CONV exists_left_and_label_CONV) thm03 - - val LEFT_RIGHT_AND_LIST_EXISTS_CONV = (DECEND_CONV QUANT_CONV ((RIGHT_AND_EXISTS_CONV ORELSEC LEFT_AND_EXISTS_CONV))) + + val LEFT_RIGHT_AND_LIST_EXISTS_CONV = (DECEND_CONV QUANT_CONV ((RIGHT_AND_EXISTS_CONV ORELSEC LEFT_AND_EXISTS_CONV))) val thm05 = RIGHT_CONV_RULE (ALL_DISJ_CONV (strip_labels_CONV (STRIP_QUANT_CONV LEFT_RIGHT_AND_LIST_EXISTS_CONV))) thm04 - val thm06 = RIGHT_CONV_RULE (ALL_DISJ_CONV (strip_labels_CONV (Unwind.UNWIND_EXISTS_CONV))) thm05 + val thm06 = RIGHT_CONV_RULE (ALL_DISJ_CONV (strip_labels_CONV (Unwind.UNWIND_EXISTS_CONV))) thm05 in - thm06 + thm06 end fun expand_cases_in_thm lbl (v, nthm') thm = let val nthm_expand = HO_MATCH_MP case_dist_exists_thm (GEN v nthm') - + val thm01 = CONV_RULE (QUANT_CONV (ALL_DISJ_CONV ( guarded_strip_labels_CONV [lbl] ( (expand_disjunction_CONV v nthm_expand))))) thm - + val thm02 = CONV_RULE (PURE_REWRITE_CONV [label_over_or_thm, GSYM DISJ_ASSOC]) thm01 - + in thm02 end handle HOL_ERR _ => thm - + fun get_columns_for_constructor current_col (c, evs) cols' = let - fun process_current_col (cs : (term list * term) list list, kl : bool list) ps = case ps of - [] => (List.map List.rev cs, List.rev kl) + fun process_current_col (cs : (term list * term) list list, kl : bool list) ps = case ps of + [] => (List.map List.rev cs, List.rev kl) | (vs, p)::ps' => let val (cs', kl') = - if (Term.is_var p) andalso List.exists (aconv p) vs then + if (Term.is_var p) andalso List.exists (aconv p) vs then (Lib.map2 (fn v => fn l => ([v], v)::l) evs cs, true::kl) else let @@ -2338,16 +2338,16 @@ local true::kl) end in process_current_col (cs', kl') ps' end - + val ps = (snd current_col) val (cs, kl) = process_current_col (List.map (K []) evs, []) ps val cols1 = zip evs cs - + val cols2 = List.map (fn (v, rs) => (v, List.map snd (Lib.filter fst (zip kl rs)))) cols' - + val cols'' = cols1 @ cols2 - + (* remove cols consisting of only vars *) val cols''' = filter (fn (_, ps) => not (List.all (fn (vs, p) => is_var p andalso List.exists (aconv p) vs) ps)) cols'' in @@ -2356,29 +2356,29 @@ local (* extract the column for variable v from the list of columns *) - fun pick_current_column v cols = + fun pick_current_column v cols = pick_element (fn (v', _) => aconv v v') cols in (* in of local *) - + fun nchotomy_of_pats_GEN db col_heu pats = let val var_gen = mk_var_gen "v" [] val lbl_gen = mk_new_label_gen "case_" - + (* val (thm, cols, lbl) = mk_initial_state var_gen lbl_gen pats - val (thm, cols, lbl) = (thm1, cols'', lbl) + val (thm, cols, lbl) = (thm1, cols'', lbl) val xxx = !args val (thm, cols, lbl) = el 3 xxx *) val args = ref [] - fun compile (thm, cols, lbl) = let + fun compile (thm, cols, lbl) = let val _ = args := (thm, cols, lbl) :: (!args) val (v, nthm) = find_nchotomy_for_cols db col_heu cols val (current_col, cols_rest) = pick_current_column v cols - val (nthm', cases_info) = compute_cases_info var_gen lbl_gen v nthm - + val (nthm', cases_info) = compute_cases_info var_gen lbl_gen v nthm + (* Expand all labeled with [lbl] cases *) val thm1 = expand_cases_in_thm lbl (v, nthm') thm @@ -2396,7 +2396,7 @@ in (* in of local *) in thm2 end handle HOL_ERR _ => thm - + (* compile it *) val thm3 = compile (mk_initial_state var_gen lbl_gen pats) @@ -2405,13 +2405,13 @@ in (* in of local *) in thm4 end - - fun nchotomy_of_pats pats = + + fun nchotomy_of_pats pats = nchotomy_of_pats_GEN (!thePmatchCompileDB) colHeu_default pats - + end - + (********************************************) (* Prune disjunctions of PMATCH_ROW_COND_EX *) (********************************************) @@ -2420,7 +2420,7 @@ end a theorem stating that a certain PMATCH_ROW_COND_EX does not hold, prune the disjunction by removing all patterns covered by the one we know does not hold. *) - + fun PMATCH_ROW_COND_EX_ELIM_FALSE_GUARD_CONV tt = let val (_, _, g) = dest_PMATCH_ROW_COND_EX tt @@ -2481,11 +2481,11 @@ fun PMATCH_ROW_COND_EX_WEAKEN_CONV_GENCALL rc_arg (weaken_thm, v_w, p_w', vars_w (* try to match *) val s = let - val (s_tm, s_ty) = Term.match_term p_w' p + val (s_tm, s_ty) = Term.match_term p_w' p val _ = if List.null s_ty then () else failwith "bound too much" val vars_w'_l = pairSyntax.strip_pair vars_w' - val _ = if List.exists (fn s => not (List.exists - (aconv (#redex s)) vars_w'_l)) s_tm then + val _ = if List.exists (fn s => not (List.exists + (aconv (#redex s)) vars_w'_l)) s_tm then failwith "bound too much" else () in s_tm end @@ -2513,7 +2513,7 @@ fun PMATCH_ROW_COND_EX_WEAKEN_CONV_GENCALL rc_arg (weaken_thm, v_w, p_w', vars_w (* elim false *) val thm2 = RIGHT_CONV_RULE - PMATCH_ROW_COND_EX_ELIM_FALSE_GUARD_CONV thm1 + PMATCH_ROW_COND_EX_ELIM_FALSE_GUARD_CONV thm1 handle HOL_ERR _ => thm1 in thm2 @@ -2521,13 +2521,13 @@ end handle HOL_ERR _ => raise UNCHANGED fun PMATCH_ROW_COND_EX_DISJ_WEAKEN_CONV_GENCALL rc_arg weaken_thm t = let - val (v_w, p_tw, _) = + val (v_w, p_tw, _) = dest_PMATCH_ROW_COND_EX (dest_neg (concl weaken_thm)) val (vars_w, p_w) = pairLib.dest_pabs p_tw (* get fresh vars in p_w before matching *) val (p_w', vars_w') = let - val vars'_l = pairSyntax.strip_pair vars_w + val vars'_l = pairSyntax.strip_pair vars_w val s = List.map (fn v => (v |-> genvar (type_of v))) vars'_l val p_w' = subst s p_w val vars_w' = subst s vars_w @@ -2538,7 +2538,7 @@ fun PMATCH_ROW_COND_EX_DISJ_WEAKEN_CONV_GENCALL rc_arg weaken_thm t = let val thm0 = ALL_DISJ_CONV (PMATCH_ROW_COND_EX_WEAKEN_CONV_GENCALL rc_arg (weaken_thm, v_w, p_w', vars_w')) t - val thm1 = RIGHT_CONV_RULE (PURE_REWRITE_CONV [boolTheory.OR_CLAUSES]) thm0 + val thm1 = RIGHT_CONV_RULE (PURE_REWRITE_CONV [boolTheory.OR_CLAUSES]) thm0 in thm1 end @@ -2561,7 +2561,7 @@ fun SIMPLIFY_PMATCH_ROW_COND_EX_IMP_CONV rc_arg tt = let val (v, p, g) = dest_PMATCH_ROW_COND_EX cl val _ = if (aconv v v') then () else raise UNCHANGED val (vars, _) = pairSyntax.dest_pabs p - in + in (v, vars', p', g', vars, p, g) end @@ -2570,13 +2570,13 @@ fun SIMPLIFY_PMATCH_ROW_COND_EX_IMP_CONV rc_arg tt = let val thm02 = RIGHT_CONV_RULE ( (QUANT_CONV (RAND_CONV (pairTools.PABS_INTRO_CONV vars))) THENC - (RAND_CONV (pairTools.PABS_INTRO_CONV vars'))) thm01 + (RAND_CONV (pairTools.PABS_INTRO_CONV vars'))) thm01 val thm03 = RIGHT_CONV_RULE (DEPTH_CONV pairLib.GEN_BETA_CONV) thm02 val thm04 = RIGHT_CONV_RULE (TRY_CONV (pairTools.ELIM_TUPLED_QUANT_CONV) THENC TRY_CONV (STRIP_QUANT_CONV (pairTools.ELIM_TUPLED_QUANT_CONV))) thm03 fun imp_or_no_imp_CONV c t = - if (is_imp t) then + if (is_imp t) then (RAND_CONV c) t else c t @@ -2586,7 +2586,7 @@ fun SIMPLIFY_PMATCH_ROW_COND_EX_IMP_CONV rc_arg tt = let val rr = rhs (concl thm05) val thm06 = if aconv rr T then thm05 else let - val thm_rr = prove_attempt (rr, rc_tac rc_arg) + val thm_rr = prove_attempt (rr, rc_tac rc_arg) in TRANS thm05 (EQT_INTRO thm_rr) end handle HOL_ERR _ => thm05 @@ -2595,7 +2595,7 @@ in end (* val ttts = strip_disj pre - val ttt = el 1 ttts + val ttt = el 1 ttts val rc_arg = ([], NONE) *) fun SIMPLIFY_PMATCH_ROW_COND_EX_IMP_CONV rc_arg cc_thm v ttt = let @@ -2642,12 +2642,12 @@ fun SIMPLIFY_REDUNDANT_ROWS_INFO_AUX rc_arg tt = let val (v, _, _) = dest_PMATCH_ROW_COND_EX cc val cc_thm = ASSUME cc - val pre_thm0 = + val pre_thm0 = (ALL_DISJ_TF_ELIM_CONV (SIMPLIFY_PMATCH_ROW_COND_EX_IMP_CONV rc_arg cc_thm v)) pre handle UNCHANGED => REFL pre val pre_thm = DISCH cc pre_thm0 val thm0 = SPECL [pre, cc] simple_imp_thm - val thm1 = MATCH_MP thm0 pre_thm + val thm1 = MATCH_MP thm0 pre_thm val thm2 = RIGHT_CONV_RULE (REWRITE_CONV [] THENC DEPTH_CONV PMATCH_ROW_COND_EX_ELIM_CONV) thm1 @@ -2682,20 +2682,20 @@ let (* compute initial enchotomy *) val nchot_thm = let - val pats = List.map (#1 o dest_PMATCH_ROW) rows + val pats = List.map (#1 o dest_PMATCH_ROW) rows val thm01 = nchotomy_of_pats_GEN db col_heu pats val thm02 = CONV_RULE (nchotomy2PMATCH_ROW_COND_EX_CONV_GEN (find_non_constructor_pattern db) ) thm01 val thm03 = ISPEC v thm02 in - thm03 + thm03 end (* get initial info *) val init_info = let val row_ty = listSyntax.dest_list_type (type_of (rand t)) - val s_ty = match_type (``:'a -> 'b option``) row_ty + val s_ty = match_type (``:'a -> 'b option``) row_ty val thm00 = INST_TYPE s_ty IS_REDUNDANT_ROWS_INFO_NIL val thm01 = SPEC v thm00 @@ -2740,7 +2740,7 @@ fun COMPUTE_REDUNDANT_ROWS_INFO_OF_PMATCH_GEN ss db col_heu = COMPUTE_REDUNDANT_ROWS_INFO_OF_PMATCH_GENCALL (ss, NONE) db col_heu fun COMPUTE_REDUNDANT_ROWS_INFO_OF_PMATCH t = - COMPUTE_REDUNDANT_ROWS_INFO_OF_PMATCH_GENCALL ([], NONE) + COMPUTE_REDUNDANT_ROWS_INFO_OF_PMATCH_GENCALL ([], NONE) (!thePmatchCompileDB) colHeu_default t @@ -2769,7 +2769,7 @@ fun IS_REDUNDANT_ROWS_INFO_WEAKEN_RULE info_thm = let val conds' = List.map (fn c => if (aconv c T) then T else F) conds val conds'_tm = listSyntax.mk_list (conds', bool) - val thm00 = REDUNDANT_ROWS_INFOS_CONJ_THM + val thm00 = REDUNDANT_ROWS_INFOS_CONJ_THM val thm01 = MATCH_MP thm00 info_thm val thm02 = SPECL [F, conds'_tm] thm01 @@ -2799,21 +2799,21 @@ end fun PMATCH_REMOVE_REDUNDANT_CONV_GENCALL db col_heu rc_arg t = let - val info_thm = COMPUTE_REDUNDANT_ROWS_INFO_OF_PMATCH_GENCALL rc_arg db col_heu t + val info_thm = COMPUTE_REDUNDANT_ROWS_INFO_OF_PMATCH_GENCALL rc_arg db col_heu t in IS_REDUNDANT_ROWS_INFO_TO_PMATCH_EQ_THM info_thm end -fun PMATCH_REMOVE_REDUNDANT_CONV_GEN db col_heu ssl = +fun PMATCH_REMOVE_REDUNDANT_CONV_GEN db col_heu ssl = PMATCH_REMOVE_REDUNDANT_CONV_GENCALL db col_heu (ssl, NONE) -fun PMATCH_REMOVE_REDUNDANT_CONV t = PMATCH_REMOVE_REDUNDANT_CONV_GEN +fun PMATCH_REMOVE_REDUNDANT_CONV t = PMATCH_REMOVE_REDUNDANT_CONV_GEN (!thePmatchCompileDB) colHeu_default [] t; -fun PMATCH_REMOVE_REDUNDANT_GEN_ss db col_heu ssl = +fun PMATCH_REMOVE_REDUNDANT_GEN_ss db col_heu ssl = make_gen_conv_ss (PMATCH_REMOVE_REDUNDANT_CONV_GENCALL db col_heu) "PMATCH_REMOVE_REDUNDANT_REDUCER" ssl -fun PMATCH_REMOVE_REDUNDANT_ss () = +fun PMATCH_REMOVE_REDUNDANT_ss () = PMATCH_REMOVE_REDUNDANT_GEN_ss (!thePmatchCompileDB) colHeu_default [] @@ -2851,7 +2851,7 @@ val t = ``CASE (x, z) OF [ ||. (SOME _, _) ~> 1; ||. (_, NONE) ~> 2 ]`` - + val t = ``CASE (x, z) OF [ ||. (NONE, 1) ~> 0; ||. (SOME _, 2) ~> 1; @@ -2864,7 +2864,7 @@ val info_thm = COMPUTE_REDUNDANT_ROWS_INFO_OF_PMATCH t fun IS_REDUNDANT_ROWS_INFO_TO_PMATCH_IS_EXHAUSTIVE info_thm = let - val thm0 = MATCH_MP IS_REDUNDANT_ROWS_INFO_EXTRACT_IS_EXHAUSTIVE + val thm0 = MATCH_MP IS_REDUNDANT_ROWS_INFO_EXTRACT_IS_EXHAUSTIVE info_thm in thm0 @@ -2872,13 +2872,13 @@ end fun PMATCH_IS_EXHAUSTIVE_CONSEQ_CONV_GEN db col_heu ssl t = let - val info_thm = COMPUTE_REDUNDANT_ROWS_INFO_OF_PMATCH_GENCALL (ssl, NONE) db col_heu t + val info_thm = COMPUTE_REDUNDANT_ROWS_INFO_OF_PMATCH_GENCALL (ssl, NONE) db col_heu t in IS_REDUNDANT_ROWS_INFO_TO_PMATCH_IS_EXHAUSTIVE info_thm end -fun PMATCH_IS_EXHAUSTIVE_CONSEQ_CONV t = - PMATCH_IS_EXHAUSTIVE_CONSEQ_CONV_GEN +fun PMATCH_IS_EXHAUSTIVE_CONSEQ_CONV t = + PMATCH_IS_EXHAUSTIVE_CONSEQ_CONV_GEN (!thePmatchCompileDB) colHeu_default [] t; @@ -2912,7 +2912,7 @@ fun nchotomy_PMATCH_ROW_COND_EX_CONSEQ_CONV_GEN rc_arg db col_heu tt = let val (v', _, _) = dest_PMATCH_ROW_COND_EX r val _ = if (aconv v v') then () else failwith "illformed input" in () end) disjs - + (* derive nchot thm *) val nchot_thm = let val pats = List.map (#2 o dest_PMATCH_ROW_COND_EX) disjs @@ -2921,7 +2921,7 @@ fun nchotomy_PMATCH_ROW_COND_EX_CONSEQ_CONV_GEN rc_arg db col_heu tt = let (find_non_constructor_pattern db)) thm01 val thm03 = ISPEC v thm02 in - thm03 + thm03 end (* prepare assumptions *) @@ -2938,10 +2938,10 @@ fun nchotomy_PMATCH_ROW_COND_EX_CONSEQ_CONV_GEN rc_arg db col_heu tt = let CONV_RULE (PMATCH_ROW_COND_EX_DISJ_WEAKEN_CONV_GENCALL rc_arg pre_thm) thm val thm00 = foldl step nchot_thm pre_thms val thm01 = DISCH neg_tt thm00 - in + in thm01 end - + val nchot_thm'' = let val thm00 = CONV_RULE (REWR_CONV neg_imp_rewr) nchot_thm' val thm01 = CONV_RULE (RATOR_CONV (RAND_CONV (REWRITE_CONV []))) thm00 @@ -2984,7 +2984,7 @@ val db = !thePmatchCompileDB val col_heu = colHeu_default *) -fun PMATCH_COMPLETE_CONV_GENCALL rc_arg db col_heu use_guards t = let +fun PMATCH_COMPLETE_CONV_GENCALL rc_arg db col_heu use_guards t = let val (v, rows) = dest_PMATCH t fun row_to_cond_ex r = let val (vs_t, p, g, _) = dest_PMATCH_ROW_ABS r @@ -3031,9 +3031,9 @@ fun PMATCH_COMPLETE_CONV_GEN ssl = val PMATCH_COMPLETE_CONV = PMATCH_COMPLETE_CONV_GEN [] (!thePmatchCompileDB) colHeu_default; -fun PMATCH_COMPLETE_GEN_ss ssl db colHeu use_guards = +fun PMATCH_COMPLETE_GEN_ss ssl db colHeu use_guards = make_gen_conv_ss (fn rc_arg => - PMATCH_COMPLETE_CONV_GENCALL rc_arg db colHeu use_guards) + PMATCH_COMPLETE_CONV_GENCALL rc_arg db colHeu use_guards) "PMATCH_COMPLETE_REDUCER" ssl; val PMATCH_COMPLETE_ss = PMATCH_COMPLETE_GEN_ss [] (!thePmatchCompileDB) colHeu_default; diff --git a/examples/pattern_matches/patternMatchesScript.sml b/examples/pattern_matches/patternMatchesScript.sml index a38465f499..84d380f6fd 100644 --- a/examples/pattern_matches/patternMatchesScript.sml +++ b/examples/pattern_matches/patternMatchesScript.sml @@ -22,7 +22,7 @@ REPEAT STRIP_TAC THEN SELECT_ELIM_TAC THEN PROVE_TAC[]) -val some_var_bool_T = store_thm ("some_var_bool_T", +val some_var_bool_T = store_thm ("some_var_bool_T", ``(some x. x) = SOME T``, `(some x. x) = (some x. (x = T))` by REWRITE_TAC[] THEN ONCE_ASM_REWRITE_TAC[] THEN @@ -30,7 +30,7 @@ val some_var_bool_T = store_thm ("some_var_bool_T", REWRITE_TAC[] ) -val some_var_bool_F = store_thm ("some_var_bool_F", +val some_var_bool_F = store_thm ("some_var_bool_F", ``(some x. ~x) = SOME F``, `(some x. ~x) = (some x. (x = F))` by REWRITE_TAC[] THEN ONCE_ASM_REWRITE_TAC[] THEN @@ -69,7 +69,7 @@ Cases_on `x` THEN Cases_on `x'` THEN ( (* Main Definitions *) (***************************************************) -(* rows of a case-expression consist of a +(* rows of a case-expression consist of a - pattern p - guard g - rhs r @@ -103,19 +103,19 @@ val PMATCH_def = Define ` val _ = new_constant ("PMATCH_magic_1", type_of ``PMATCH``) -val _ = new_constant ("PMATCH_ROW_magic_1", type_of +val _ = new_constant ("PMATCH_ROW_magic_1", type_of ``\abc. PMATCH_ROW (\x. FST (abc x)) (\x. FST (SND (abc x))) (\x. SND (SND ((abc x))))``) -val _ = new_constant ("PMATCH_ROW_magic_0", type_of +val _ = new_constant ("PMATCH_ROW_magic_0", type_of ``\abc. PMATCH_ROW (\x:unit. FST abc) (\x. FST (SND abc)) (\x. SND (SND (abc)))``) -val _ = new_constant ("PMATCH_ROW_magic_4", type_of +val _ = new_constant ("PMATCH_ROW_magic_4", type_of ``\abc. PMATCH_ROW (\x:unit. FST abc) (\x. FST (SND abc)) (\x. SND (SND (abc)))``) -val _ = new_constant ("PMATCH_ROW_magic_2", type_of +val _ = new_constant ("PMATCH_ROW_magic_2", type_of ``\(pat:'a) (g:bool) (res:'b). (pat,g,res)``) -val _ = new_constant ("PMATCH_ROW_magic_3", type_of +val _ = new_constant ("PMATCH_ROW_magic_3", type_of ``\(pat:'a) (res:'b). (pat,T,res)``) @@ -235,8 +235,8 @@ SIMP_TAC std_ss [PMATCH_EVAL, each other by modifying or dropping rows are equivalent. We want to perform these proofs in an a way that can be automated nicely. In the following, we provide lemmata that - given an established equivalence, allow adding - a row to both or a single side. + given an established equivalence, allow adding + a row to both or a single side. By starting with an empty list and iterating, one can use this method to construct the desired correspondance. *) val PMATCH_EXTEND_BASE = store_thm ("PMATCH_EXTEND_BASE", @@ -464,9 +464,9 @@ ASM_REWRITE_TAC[]) -(* A row is redundant, if (but not(!) only if) it is made +(* A row is redundant, if (but not(!) only if) it is made redundant by exactly one - row above. This is simple to test and often already very + row above. This is simple to test and often already very helful. More fancy tests involving multiple rows follow below. *) val PMATCH_ROWS_DROP_REDUNDANT = store_thm ( "PMATCH_ROWS_DROP_REDUNDANT", @@ -538,7 +538,7 @@ Cases_on `?r. MEM r rows2 ∧ IS_SOME (r v)` THEN ( Cases_on `r1 v` THEN ( FULL_SIMP_TAC std_ss [EVERY_MEM] ) THEN - RES_TAC THEN + RES_TAC THEN FULL_SIMP_TAC std_ss [], Cases_on `r1 v` THEN ( @@ -578,7 +578,7 @@ REPEAT STRIP_TAC THENL [ ]); -(* A common case for removing subsumed rows +(* A common case for removing subsumed rows is removing ARB rows that are introduced by translating a classical case-expression naively. *) val PMATCH_REMOVE_ARB = store_thm ("PMATCH_REMOVE_ARB", @@ -631,11 +631,11 @@ val PMATCH_ROW_REDUNDANT_def = Define ` This is done via IS_REDUNDANT_ROWS_INFO v rows c infos. If the n-th entry of list infos is true, then the n-th row of rows is redundant for input v. If it is not true, - it may or may not be redundant. + it may or may not be redundant. The parameter c is used for accumulating information of all rows already in the info. If none of the rows - in rows matches, c holds. *) + in rows matches, c holds. *) val IS_REDUNDANT_ROWS_INFO_def = Define ` IS_REDUNDANT_ROWS_INFO v rows c infos <=> ( (LENGTH rows = LENGTH infos) /\ @@ -881,18 +881,18 @@ METIS_TAC[]) val STRONGEST_REDUNDANT_ROWS_INFO_AUX_def = Define ` (STRONGEST_REDUNDANT_ROWS_INFO_AUX v [] p infos = (p, infos)) /\ - (STRONGEST_REDUNDANT_ROWS_INFO_AUX v (r::rows) p infos = + (STRONGEST_REDUNDANT_ROWS_INFO_AUX v (r::rows) p infos = STRONGEST_REDUNDANT_ROWS_INFO_AUX v rows (p /\ (r v = NONE)) (SNOC (p ==> (r v = NONE)) infos))` - + val STRONGEST_REDUNDANT_ROWS_INFO_def = Define ` STRONGEST_REDUNDANT_ROWS_INFO v rows = SND (STRONGEST_REDUNDANT_ROWS_INFO_AUX v rows T [])` val LENGTH_STRONGEST_REDUNDANT_ROWS_INFO_AUX = store_thm ( "LENGTH_STRONGEST_REDUNDANT_ROWS_INFO_AUX", - ``!v rows p infos. - LENGTH (SND (STRONGEST_REDUNDANT_ROWS_INFO_AUX v rows p infos)) = + ``!v rows p infos. + LENGTH (SND (STRONGEST_REDUNDANT_ROWS_INFO_AUX v rows p infos)) = (LENGTH rows + LENGTH infos)``, Induct_on `rows` THEN ( @@ -901,8 +901,8 @@ Induct_on `rows` THEN ( val FST_STRONGEST_REDUNDANT_ROWS_INFO_AUX = store_thm ( "FST_STRONGEST_REDUNDANT_ROWS_INFO_AUX", - ``!v rows p infos. - FST (STRONGEST_REDUNDANT_ROWS_INFO_AUX v rows p infos) = + ``!v rows p infos. + FST (STRONGEST_REDUNDANT_ROWS_INFO_AUX v rows p infos) = (p /\ EVERY (\r. r v = NONE) rows)``, Induct_on `rows` THEN ( @@ -913,9 +913,9 @@ Induct_on `rows` THEN ( val EL1_STRONGEST_REDUNDANT_ROWS_INFO_AUX = store_thm ( "EL1_STRONGEST_REDUNDANT_ROWS_INFO_AUX", - ``!v rows p infos i. + ``!v rows p infos i. (i < LENGTH infos) ==> - (EL i (SND (STRONGEST_REDUNDANT_ROWS_INFO_AUX v rows p infos)) = + (EL i (SND (STRONGEST_REDUNDANT_ROWS_INFO_AUX v rows p infos)) = EL i infos)``, Induct_on `rows` THEN ( @@ -925,9 +925,9 @@ Induct_on `rows` THEN ( val EL2_STRONGEST_REDUNDANT_ROWS_INFO_AUX = store_thm ( "EL2_STRONGEST_REDUNDANT_ROWS_INFO_AUX", - ``!v rows p infos i. + ``!v rows p infos i. (i >= LENGTH infos /\ i < LENGTH rows + LENGTH infos) ==> - (EL i (SND (STRONGEST_REDUNDANT_ROWS_INFO_AUX v rows p infos)) = + (EL i (SND (STRONGEST_REDUNDANT_ROWS_INFO_AUX v rows p infos)) = ((p /\ EVERY (\r. r v = NONE) (TAKE (i - LENGTH infos) rows)) ==> ((EL (i - LENGTH infos) rows) v = NONE)))``, GEN_TAC THEN @@ -958,8 +958,8 @@ SIMP_TAC list_ss [STRONGEST_REDUNDANT_ROWS_INFO_def, val FST_STRONGEST_REDUNDANT_ROWS_INFO_AUX = store_thm ( "FST_STRONGEST_REDUNDANT_ROWS_INFO_AUX", - ``!v rows p infos. - FST (STRONGEST_REDUNDANT_ROWS_INFO_AUX v rows p infos) = + ``!v rows p infos. + FST (STRONGEST_REDUNDANT_ROWS_INFO_AUX v rows p infos) = (p /\ EVERY (\r. r v = NONE) rows)``, Induct_on `rows` THEN ( @@ -968,10 +968,10 @@ Induct_on `rows` THEN ( val EL_STRONGEST_REDUNDANT_ROWS_INFO = store_thm ( "EL_STRONGEST_REDUNDANT_ROWS_INFO", - ``!v rows p infos i. + ``!v rows p infos i. (i < LENGTH rows) ==> - (EL i (STRONGEST_REDUNDANT_ROWS_INFO v rows) = - ((EVERY (\r. r v = NONE) (TAKE i rows)) ==> + (EL i (STRONGEST_REDUNDANT_ROWS_INFO v rows) = + ((EVERY (\r. r v = NONE) (TAKE i rows)) ==> ((EL i rows) v = NONE)))``, SIMP_TAC list_ss [STRONGEST_REDUNDANT_ROWS_INFO_def, @@ -985,7 +985,7 @@ val STRONGEST_REDUNDANT_ROWS_INFO_OK = store_thm ("STRONGEST_REDUNDANT_ROWS_INFO SIMP_TAC std_ss [IS_REDUNDANT_ROWS_INFO_def, EL_STRONGEST_REDUNDANT_ROWS_INFO, - LENGTH_STRONGEST_REDUNDANT_ROWS_INFO, + LENGTH_STRONGEST_REDUNDANT_ROWS_INFO, PMATCH_ROW_REDUNDANT_def] THEN REPEAT STRIP_TAC THEN Cases_on `EL i rows v` THEN1 ( @@ -1005,7 +1005,7 @@ PROVE_TAC[]) (* IN order to automate this procedure, we need a few simple, additional lemmata *) -val PMATCH_ROW_COND_EX_FULL_DEF = store_thm ("PMATCH_ROW_COND_EX_FULL_DEF", +val PMATCH_ROW_COND_EX_FULL_DEF = store_thm ("PMATCH_ROW_COND_EX_FULL_DEF", ``PMATCH_ROW_COND_EX i p g = ?x. (i = p x) /\ g x``, SIMP_TAC std_ss [PMATCH_ROW_COND_EX_def, PMATCH_ROW_COND_def] THEN @@ -1041,16 +1041,16 @@ val PMATCH_ROW_COND_EX_IMP_REWRITE = store_thm ("PMATCH_ROW_COND_EX_IMP_REWRITE" SIMP_TAC std_ss [PMATCH_ROW_COND_EX_def, PMATCH_ROW_COND_def, GSYM LEFT_FORALL_IMP_THM]); -(* Use this simple contradiction to bring - PMATCH_IS_EXHAUSTIVE in the form we need for - automation *) +(* Use this simple contradiction to bring + PMATCH_IS_EXHAUSTIVE in the form we need for + automation *) val PMATCH_IS_EXHAUSTIVE_CONTRADICT = store_thm ( "PMATCH_IS_EXHAUSTIVE_CONTRADICT", -``!v rs. +``!v rs. (EVERY (\r. r v = NONE) rs ==> F) ==> (PMATCH_IS_EXHAUSTIVE v rs)``, -REPEAT STRIP_TAC THEN +REPEAT STRIP_TAC THEN FULL_SIMP_TAC list_ss [PMATCH_IS_EXHAUSTIVE_def, combinTheory.o_DEF, quantHeuristicsTheory.IS_SOME_EQ_NOT_NONE]) @@ -1063,12 +1063,12 @@ FULL_SIMP_TAC list_ss [PMATCH_IS_EXHAUSTIVE_def, we can via the following theorem introduce a fresh variable and add the connection between the old and the newly created var to the guard. *) -val PMATCH_ROW_REMOVE_DOUBLE_BINDS_THM = +val PMATCH_ROW_REMOVE_DOUBLE_BINDS_THM = store_thm ("PMATCH_ROW_REMOVE_DOUBLE_BINDS_THM", ``!g p1 g1 r1 p2 g2 r2. ((!x y. (p1 x = p1 y) ==> (x = y)) /\ (!x. (p2 (g x) = p1 x)) /\ - (!x'. g2 x' = (?x. (x' = g x) /\ g1 x)) /\ + (!x'. g2 x' = (?x. (x' = g x) /\ g1 x)) /\ (!x. r2 (g x) = r1 x)) ==> (PMATCH_ROW p1 g1 r1 = PMATCH_ROW p2 g2 r2)``, @@ -1081,7 +1081,7 @@ Cases_on `?x'. (p1 x' = x) ∧ g1 x'` THEN ( ASM_REWRITE_TAC[optionTheory.OPTION_MAP_DEF] ) THEN SELECT_ELIM_TAC THEN ASM_REWRITE_TAC[] THEN -SELECT_ELIM_TAC THEN +SELECT_ELIM_TAC THEN REPEAT STRIP_TAC THEN ( METIS_TAC[] )) @@ -1093,7 +1093,7 @@ REPEAT STRIP_TAC THEN ( (***************************************************) (* We can eliminate guards by replacing them with true - and add the guard in form of a conditional. + and add the guard in form of a conditional. Notice that all the rows after the guard are duplicated. We heavily rely on simplification of PMATCH to avoid a huge blowup of term-size, @@ -1211,7 +1211,7 @@ val PMATCH_PRED_UNROLL_NIL = store_thm ("PMATCH_PRED_UNROLL_NIL", SIMP_TAC std_ss [PMATCH_def, PMATCH_INCOMPLETE_def]); val PMATCH_PRED_UNROLL_CONS = store_thm ("PMATCH_PRED_UNROLL_CONS", -``!P v p g r rows. +``!P v p g r rows. (!x1 x2. (g x1 /\ g x2 /\ (p x1 = p x2)) ==> (x1 = x2)) ==> (P (PMATCH v ((PMATCH_ROW p g r)::rows)) <=> @@ -1232,7 +1232,7 @@ Cases_on `?x. PMATCH_ROW_COND p g v x` THENL [ ]) val PMATCH_PRED_UNROLL_CONS_NO_INJ = store_thm ("PMATCH_PRED_UNROLL_CONS_NO_INJ", -``!P v p g r rows. +``!P v p g r rows. (P (PMATCH v ((PMATCH_ROW p g r)::rows)) <=> ((?x. (p x = v) /\ g x) ==> ?x. ( (v = p x) /\ g x /\ ((@x. PMATCH_ROW_COND p g v x) = x) /\ diff --git a/examples/pattern_matches/patternMatchesSyntax.sig b/examples/pattern_matches/patternMatchesSyntax.sig index 271c19a92a..4dfcb85e78 100644 --- a/examples/pattern_matches/patternMatchesSyntax.sig +++ b/examples/pattern_matches/patternMatchesSyntax.sig @@ -8,7 +8,7 @@ sig (******************) val PMATCH_ROW_tm : term - + (* dest_PMATCH_ROW ``PMATCH_ROW p g r`` returns (``p``, ``g``, ``r``). *) val dest_PMATCH_ROW : term -> (term * term * term) @@ -16,42 +16,42 @@ sig val is_PMATCH_ROW : term -> bool (* [mk_PMATCH_ROW (p, g, rh)] constructs the term - ``PMATCH_ROW p g rh``. *) + ``PMATCH_ROW p g rh``. *) val mk_PMATCH_ROW : term * term * term -> term (* [mk_PMATCH_ROW_PABS vars (p, g, rh)] constructs the term - ``PMATCH_ROW (\vars. p) (\vars. g) (\vars. rh)``. *) + ``PMATCH_ROW (\vars. p) (\vars. g) (\vars. rh)``. *) val mk_PMATCH_ROW_PABS : term list -> term * term * term -> term (* a wrapper for [mk_PMATCH_ROW_PABS] automatically renames the used variables to mark them as wildcards. Moreover it removes unused vars. - It returns the constructed term with a flag of whether + It returns the constructed term with a flag of whether the result differs from a naive call of [mk_PMATCH_ROW_PABS]. *) val mk_PMATCH_ROW_PABS_WILDCARDS : term list -> term * term * term -> (bool * term) - (* dest_PMATCH_ROW_ABS ``PMATCH_ROW (\(x,y). p x y) + (* dest_PMATCH_ROW_ABS ``PMATCH_ROW (\(x,y). p x y) (\(x,y). g x y) (\(x,y). r x y)`` - returns (``(x,y)``, ``p x y``, ``g x y``, ``r x y``). + returns (``(x,y)``, ``p x y``, ``g x y``, ``r x y``). It fails, if not all paired abstractions use the same variable names. *) val dest_PMATCH_ROW_ABS : term -> (term * term * term * term) - (* calls dest_PMATCH_ROW_ABS and renames the abstracted vars + (* calls dest_PMATCH_ROW_ABS and renames the abstracted vars consistently to be different from the list of given vars. *) val dest_PMATCH_ROW_ABS_VARIANT : term list -> term -> (term * term * term * term) - (* [PMATCH_ROW_PABS_ELIM_CONV t] + (* [PMATCH_ROW_PABS_ELIM_CONV t] replaces paired lambda abstraction in t with a normal lambda abstraction. It returns a theorem stating the equivalence as well as the original varstruct of p removed. *) val PMATCH_ROW_PABS_ELIM_CONV : term -> (term * thm) - (* [PMATCH_ROW_PABS_INTRO_CONV vars t] reintroduces + (* [PMATCH_ROW_PABS_INTRO_CONV vars t] reintroduces paired abstraction again after being removed by e.g. [PMATCH_ROW_PABS_ELIM_CONV]. It uses [vars] for the newly - introduced varstruct. *) + introduced varstruct. *) val PMATCH_ROW_PABS_INTRO_CONV : term -> conv (* [PMATCH_ROW_FORCE_SAME_VARS_CONV] renames the @@ -75,7 +75,7 @@ sig val PMATCH_tm : term - (* [dest_PMATCH ``PMATCH v rows``] returns (``v``, ``rows``). *) + (* [dest_PMATCH ``PMATCH v rows``] returns (``v``, ``rows``). *) val dest_PMATCH : term -> (term * term list) val is_PMATCH : term -> bool @@ -84,10 +84,10 @@ sig (* [dest_PMATCH_COLS ``PMATCH v rows``] tries to extract the columns of the pattern match. Each column consists of the value of v, - the free variables in the pattern and the column of the pattern + the free variables in the pattern and the column of the pattern for each row. *) val dest_PMATCH_COLS : term -> (term * (term list * term) list) list - + (* internally, the columns come from a list of atterns. Sometimes this interface is useful as well. *) val dest_PATLIST_COLS : term -> term list -> (term * (term list * term) list) list @@ -116,13 +116,13 @@ sig val mk_PMATCH_ROW_COND_EX_pat : term -> term -> term val mk_PMATCH_ROW_COND_EX_ROW : term -> term -> term - val PMATCH_ROW_COND_EX_ELIM_CONV : conv + val PMATCH_ROW_COND_EX_ELIM_CONV : conv (* [PMATCH_ROW_COND_EX_INTRO_CONV_GEN find_guard_term v t] tries - to introduce [PMATCH_ROW_COND_EX] terms. For + to introduce [PMATCH_ROW_COND_EX] terms. For t of the form ``?x1 ... xn. v = f x1 ... xn /\ g1 x1 ... xn /\ ...`` - it extracts the pattern [f x1 ... xn] and guard [g1 x1 ... xn /\ ...]. - + it extracts the pattern [f x1 ... xn] and guard [g1 x1 ... xn /\ ...]. + The function [find_guard_term] is used to find subterms of [f x1 ... xn] that should be abbreviated by a new variable and moved to the guard. It gets the list of free variables and the pattern. @@ -135,7 +135,7 @@ sig val nchotomy2PMATCH_ROW_COND_EX_CONV : conv (* A version of making PMATCH_ROW_COND_EX that does the move to guards. *) - val mk_PMATCH_ROW_COND_EX_PABS_MOVE_TO_GUARDS : + val mk_PMATCH_ROW_COND_EX_PABS_MOVE_TO_GUARDS : (term list -> term -> term option) -> term list -> term * term * term -> term @@ -170,7 +170,7 @@ sig (* add a list of labels to a term *) val add_labels_CONV : string list -> conv - (* apply a conversion under a sequence + (* apply a conversion under a sequence of labels *) val strip_labels_CONV : conv -> conv @@ -185,13 +185,13 @@ sig (*******************) (* [pick_element p l] gets the first element of l that satisfies p - and removes this occurence from the list. + and removes this occurence from the list. If no such element exists, the function fails. *) val pick_element : ('a -> bool) -> ('a list) -> 'a * 'a list (* [has_subterm p t] checks whether [t] has a subterm satisfying predicate [p]. *) - val has_subterm : (term -> bool) -> term -> bool + val has_subterm : (term -> bool) -> term -> bool (* Like [prove], but quiet in case it fails. This is useful, when trying to prove things and are not sure, whether they @@ -201,8 +201,8 @@ sig (* List strip_comb, but with a maximum bound. *) val strip_comb_bounded : int -> term -> term * term list - (* auxiliary function that introduces fresh - typevars for all type-vars used by + (* auxiliary function that introduces fresh + typevars for all type-vars used by free vars of a thm *) val FRESH_TY_VARS_RULE : rule @@ -220,7 +220,7 @@ sig (* strip a large disjunction and apply a conversion to all leafs. Eliminate T and F from the resulting term by - applying rewrites. This might be more efficient than + applying rewrites. This might be more efficient than ALL_DISJ_CONV, since it stops, once a T-disjunct is found. *) val ALL_DISJ_TF_ELIM_CONV : conv -> conv @@ -230,7 +230,7 @@ sig (* [DECEND_CONV c_desc c] applies [c] and then uses [c_desc] to descend into the result via [c_desc] and - repeat. *) + repeat. *) val DECEND_CONV : (conv -> conv) -> conv -> conv (* Apply a conversion to all elements of a list (build diff --git a/examples/pattern_matches/patternMatchesSyntax.sml b/examples/pattern_matches/patternMatchesSyntax.sml index 9e06d533a8..0ec5ec3621 100644 --- a/examples/pattern_matches/patternMatchesSyntax.sml +++ b/examples/pattern_matches/patternMatchesSyntax.sml @@ -81,7 +81,7 @@ fun ALL_DISJ_CONV c t = if (is_disj t) then ( (BINOP_CONV (ALL_DISJ_CONV c)) t ) else (TRY_CONV c) t -(* apply a conversion to all leafs of a disjunct +(* apply a conversion to all leafs of a disjunct and simplify the result by removing T and F. *) fun ALL_DISJ_TF_ELIM_CONV c t = let val (t1, t2) = dest_disj t @@ -150,10 +150,10 @@ val prove_attempt = Lib.with_flag (Feedback.emit_MESG, false) prove (* Labels from markerLib *) (***********************************************) -(* generating fresh labels and vars using +(* generating fresh labels and vars using a counter *) fun mk_new_label_gen prefix = let - val c = ref 0 + val c = ref 0 in fn () => let val l = prefix ^ int_to_string (!c) @@ -178,7 +178,7 @@ end fun strip_labels t = let fun aux acc t = let val (l, t') = markerSyntax.dest_label t - in + in aux (l::acc) t' end handle HOL_ERR _ => (List.rev acc, t) in @@ -252,7 +252,7 @@ end handle HOL_ERR _ => (t, avoid) fun REMOVE_REBIND_CONV t = let val (t', _) = REMOVE_REBIND_CONV_AUX [] t in - ALPHA t t' + ALPHA t t' end @@ -292,14 +292,14 @@ fun mk_PMATCH_ROW_PABS_WILDCARDS vars (p_t, g_t, r_t) = let val gr_s = FVL [g_t, r_t] empty_tmset val p_s = FVL [p_t] empty_tmset - val mk_wc = mk_wildcard_gen (HOLset.listItems + val mk_wc = mk_wildcard_gen (HOLset.listItems (HOLset.union (gr_s, p_s))) - + fun apply (v, (vars', subst)) = ( if (not (HOLset.member (gr_s, v)) andalso not (varname_starts_with_uscore v)) then let - val v' = mk_wc (type_of v) - in + val v' = mk_wc (type_of v) + in (v'::vars', (v |-> v')::subst) end else (v::vars', subst) @@ -379,7 +379,7 @@ fun PMATCH_ROW_INTRO_WILDCARDS_CONV row = let val (vars_tm, p_t, g_t, r_t) = dest_PMATCH_ROW_ABS row val vars = pairSyntax.strip_pair vars_tm val (ch, row') = mk_PMATCH_ROW_PABS_WILDCARDS vars (p_t, g_t, r_t) - val _ = if ch then () else raise UNCHANGED + val _ = if ch then () else raise UNCHANGED in ALPHA row row' end handle HOL_ERR _ => raise UNCHANGED @@ -435,7 +435,7 @@ fun dest_PATLIST_COLS v ps = let val col_no = length (hd rows') fun aux acc v col_no = if (col_no <= 1) then List.rev (v::acc) else ( - let + let val (v1, v2) = pairSyntax.dest_pair v handle HOL_ERR _ => (pairSyntax.mk_fst v, pairSyntax.mk_snd v) in @@ -444,7 +444,7 @@ fun dest_PATLIST_COLS v ps = let ) val vs = aux [] v col_no - + fun get_cols acc vs rows = case vs of [] => List.rev acc | (v::vs') => let @@ -464,15 +464,15 @@ fun dest_PMATCH_COLS t = let val ps = List.map (#1 o dest_PMATCH_ROW) rows in dest_PATLIST_COLS v ps -end +end -fun list_CONV c t = +fun list_CONV c t = if not (listSyntax.is_cons t) then raise UNCHANGED else ( (RATOR_CONV (RAND_CONV c) THENC RAND_CONV (list_CONV c)) t) -fun list_nth_CONV n c t = - if not (listSyntax.is_cons t) then raise UNCHANGED else +fun list_nth_CONV n c t = + if not (listSyntax.is_cons t) then raise UNCHANGED else if (n < 0) then raise UNCHANGED else if (n = 0) then RATOR_CONV (RAND_CONV c) t else (RAND_CONV (list_nth_CONV (n-1) c)) t @@ -483,7 +483,7 @@ in RAND_CONV (list_CONV c) t end -val PMATCH_FORCE_SAME_VARS_CONV = +val PMATCH_FORCE_SAME_VARS_CONV = PMATCH_ROWS_CONV PMATCH_ROW_FORCE_SAME_VARS_CONV val PMATCH_INTRO_WILDCARDS_CONV = @@ -548,14 +548,14 @@ fun mk_PMATCH_ROW_COND_EX_PABS vars (i, p_t, g_t) = let end fun mk_PMATCH_ROW_COND_EX_PABS_MOVE_TO_GUARDS find vars (i, p_t, g_t) = let - val fr_vs = free_vars i @ free_vars p_t @ free_vars g_t + val fr_vs = free_vars i @ free_vars p_t @ free_vars g_t fun move_to_guard (vars, p_t, g_t) = let val (p: term) = case find vars p_t of NONE => failwith "not found" | SOME p => p val _ = if (mem p vars) then failwith "loop" else () val x = mk_var ("x", type_of p) - val x = variant (fr_vs @ vars) x + val x = variant (fr_vs @ vars) x val p_t' = Term.subst [p |-> x] p_t val g_t' = mk_conj (mk_eq (x, p), g_t) val vars' = x :: vars @@ -624,7 +624,7 @@ in rc_eq_thm end -fun PMATCH_ROW_COND_EX_INTRO_CONV v t = +fun PMATCH_ROW_COND_EX_INTRO_CONV v t = PMATCH_ROW_COND_EX_INTRO_CONV_GEN (fn _ => fn _ => NONE) v t; fun nchotomy2PMATCH_ROW_COND_EX_CONV_GEN P t = let @@ -633,7 +633,7 @@ in (QUANT_CONV (ALL_DISJ_CONV (PMATCH_ROW_COND_EX_INTRO_CONV_GEN P v))) t end; -fun nchotomy2PMATCH_ROW_COND_EX_CONV t = +fun nchotomy2PMATCH_ROW_COND_EX_CONV t = nchotomy2PMATCH_ROW_COND_EX_CONV_GEN (fn _ => fn _ => NONE) t; fun PMATCH_ROW_COND_EX_ELIM_CONV t = let @@ -662,11 +662,11 @@ fun pmatch_printer_fix_wildcards (vars, pat, guard, rh) = let val var_l = pairSyntax.strip_pair vars val (wc_l, var_l') = partition varname_starts_with_uscore var_l - fun mk_fake wc = mk_var (GrammarSpecials.mk_fakeconst_name {fake = "_", original = NONE}, type_of wc) + fun mk_fake wc = mk_var (GrammarSpecials.mk_fakeconst_name {fake = "_", original = NONE}, type_of wc) val fake_subst = map (fn wc => (wc |-> mk_fake wc)) wc_l - val vars' = + val vars' = if (List.null var_l') then variant (free_varsl [pat, guard, rh]) ``uv:unit`` else @@ -676,7 +676,7 @@ fun pmatch_printer_fix_wildcards (vars, pat, guard, rh) = let val guard' = Term.subst fake_subst guard val rh' = Term.subst fake_subst rh in - (vars', pat', guard', rh') + (vars', pat', guard', rh') end handle HOL_ERR _ => (vars, pat, guard, rh) @@ -698,20 +698,20 @@ fun pmatch_printer GS backend sys (ppfns:term_pp_types.ppstream_funs) gravs d t not (free_in vars guard) andalso not (free_in vars rh)) then ( add_string "||." >> add_break (1, 0) - ) else ( + ) else ( add_string "||" >> add_break (1, 0) >> sys (Top, Top, Top) (d - 1) vars >> add_string "." >> add_break (1, 0) - )) >> + )) >> sys (Top, Top, Top) (d - 1) pat >> (if (aconv guard T) then nothing else ( add_string " when" >> add_break (1, 0) >> sys (Top, Prec (2000, ""), Top) (d - 1) guard )) >> add_string " ~>" >> add_break (1, 0) >> - sys (Top, Prec (2000, ""), Top) (d - 1) rh + sys (Top, Prec (2000, ""), Top) (d - 1) rh )) ) in ublock PP.CONSISTENT 0 ( @@ -837,7 +837,7 @@ val _ = temp_add_rule{term_name = "PMATCH_magic_1", -fun traverse f tm = +fun traverse f tm = f tm handle HOL_ERR _ => let val (tm1, tm2) = dest_comb tm @@ -852,38 +852,38 @@ fun traverse f tm = fun fix_CASE tm = let - val (c, args) = strip_comb tm + val (c, args) = strip_comb tm in if (same_const c PMATCH_magic_1_tm) then let val tys = match_type (type_of PMATCH_magic_1_tm) (type_of c) val c' = inst tys PMATCH_tm; - val args' = map (traverse fix_CASE) args + val args' = map (traverse fix_CASE) args in list_mk_comb (c', args') end else if (same_const c PMATCH_ROW_magic_1_tm) orelse (same_const c PMATCH_ROW_magic_0_tm) orelse (same_const c PMATCH_ROW_magic_4_tm) then let - val args' = map (traverse fix_CASE) args - val (vars, b) = + val args' = map (traverse fix_CASE) args + val (vars, b) = if (same_const c PMATCH_ROW_magic_1_tm) then let - val (p_var, b) = dest_pabs (hd args') + val (p_var, b) = dest_pabs (hd args') val vars = pairSyntax.strip_pair p_var - in - (vars, b) + in + (vars, b) end else if (same_const c PMATCH_ROW_magic_4_tm) then let val b = hd args' val (_, b_args) = strip_comb b; val vars = List.filter (not o varname_starts_with_uscore) (free_vars_lr (el 1 b_args)) - in - (vars, b) + in + (vars, b) end else (* magic 0 *) ([], hd args'); val (b_c, b_args) = strip_comb b; val (p, g, r) = if (same_const b_c PMATCH_ROW_magic_2_tm) then - (el 1 b_args, el 2 b_args, el 3 b_args) + (el 1 b_args, el 2 b_args, el 3 b_args) else if (same_const b_c PMATCH_ROW_magic_3_tm) then - (el 1 b_args, T, el 2 b_args) + (el 1 b_args, T, el 2 b_args) else failwith "unexpected constant"; val wildcards = List.filter varname_starts_with_uscore ( free_vars p @@ -894,7 +894,7 @@ fun fix_CASE tm = let end else failwith "no CASE" end; - + (* Preterm.post_process_term := I *) val old_f = !Preterm.post_process_term; diff --git a/examples/separationLogic/src/holfoot/holfootLib.sml b/examples/separationLogic/src/holfoot/holfootLib.sml index e13eea4209..dca8498a92 100644 --- a/examples/separationLogic/src/holfoot/holfootLib.sml +++ b/examples/separationLogic/src/holfoot/holfootLib.sml @@ -2183,7 +2183,7 @@ let val inf_thm = if af then VAR_RES_FRAME_SPLIT___data_array___data_array___SAME_EXP_LENGTH else - VAR_RES_FRAME_SPLIT___data_interval___data_interval___SAME_EXP_LENGTH + VAR_RES_FRAME_SPLIT___data_interval___data_interval___SAME_EXP_LENGTH val thm1 = PART_MATCH (lhs o snd o dest_imp) inf_thm (rhs (concl thm0)) val thm2 = var_res_precondition_prove thm1 @@ -2955,7 +2955,7 @@ fun holfoot_tac_verify_spec file optL_opt tacL = fun holfoot_auto_verify_spec file = holfoot_interactive_verify_spec true true file (SOME [generate_vcs]) [] - + (* val examplesDir = concat [Globals.HOLDIR, "/examples/separationLogic/src/holfoot/EXAMPLES"] (* 27.5 s *) val file = concat [examplesDir, "/automatic/append.dsf"]; diff --git a/examples/separationLogic/src/holfoot/holfootParser.sml b/examples/separationLogic/src/holfoot/holfootParser.sml index 06827cb624..10c666a288 100644 --- a/examples/separationLogic/src/holfoot/holfootParser.sml +++ b/examples/separationLogic/src/holfoot/holfootParser.sml @@ -1172,7 +1172,7 @@ let fun initPfundecl (Pfundecl(assume_opt, funname, (ref_args, val_args), rwOpt, preCondOpt, localV, fun_body, postCondOpt)) = (funname, ((map (K false) ref_args), []:string list, []:string list)) - val init_funL = map initPfundecl fun_decl_list; + val init_funL = map initPfundecl fun_decl_list; val emp_s = Redblackset.empty String.compare val init = map (fn p => (init_funL, (emp_s,emp_s), p)) fun_decl_list diff --git a/examples/separationLogic/src/holfoot/holfoot_pp_print.sml b/examples/separationLogic/src/holfoot/holfoot_pp_print.sml index 0e8be8080f..a56de13aa2 100644 --- a/examples/separationLogic/src/holfoot/holfoot_pp_print.sml +++ b/examples/separationLogic/src/holfoot/holfoot_pp_print.sml @@ -244,7 +244,7 @@ fun holfoot_prog_printer GS backend sys (ppfns:term_pp_types.ppstream_funs) grav ) else if (same_const op_term asl_prog_diverge_term) then ( ublock CONSISTENT 0 ( add_string "diverge" - ) + ) ) else if (same_const op_term asl_prog_fail_term) then ( ublock CONSISTENT 0 ( add_string "fail" @@ -1057,7 +1057,7 @@ fun holfoot_specification_printer GS backend sys (ppfns:term_pp_types.ppstream_f val argL1_const = map (fn n => mk_comb (holfoot_var_term, stringLib.fromMLstring n)) argL1_string; val argL2_const = map (fn n => mk_var (n, numSyntax.num)) argL2_string - + val argL_term = pairLib.mk_pair (listSyntax.mk_list (argL1_const, ``:holfoot_var``), listSyntax.mk_list (argL2_const, numSyntax.num)); diff --git a/examples/separationLogic/src/vars_as_resourceBaseFunctor.sml b/examples/separationLogic/src/vars_as_resourceBaseFunctor.sml index f4842a1ea0..94e0e606cc 100644 --- a/examples/separationLogic/src/vars_as_resourceBaseFunctor.sml +++ b/examples/separationLogic/src/vars_as_resourceBaseFunctor.sml @@ -150,7 +150,7 @@ fun GABS_CONV conv tm = LAMB(Bvar,Body) => ((ABS_CONV conv tm) handle HOL_ERR _ => let fun conv2 tm = - SPEC Bvar (GEN_ASSUM Bvar (conv tm)); + SPEC Bvar (GEN_ASSUM Bvar (conv tm)); in ABS_CONV conv2 tm end) @@ -972,7 +972,7 @@ fun simpset_strengthen_conseq_conv conv = fun expands_strengthen_conseq_conv conv = (fn p => (fn context => (STRENGTHEN_CONSEQ_CONV (conv (#expands_level p) (#do_prop_simps p, #prop_simp_ss p) context)))):var_res_inference - + fun update_var_res_param () = (update_varlist_rwts();update_prover_extra();prover_cache_clear ();()); diff --git a/examples/set-theory/zfset/zfsetScript.sml b/examples/set-theory/zfset/zfsetScript.sml index fdab3e51a9..f1e8795281 100644 --- a/examples/set-theory/zfset/zfsetScript.sml +++ b/examples/set-theory/zfset/zfsetScript.sml @@ -89,13 +89,13 @@ val InSetCons = val InSing = store_thm - ("InSing", + ("InSing", ``!x y. x In {y} = (x = y)``, METIS_TAC[Extension_ax,U_def,Singleton_def,InSetCons,Empty_def]); val SingNotEmpty = store_thm - ("SingNotEmpty", + ("SingNotEmpty", ``!x. ~({x} = {}) /\ ~({} = {x})``, METIS_TAC[Extension_ax,InSing,Empty_def]); @@ -107,7 +107,7 @@ val InDouble = val DoubleNotEmpty = store_thm - ("DoubleNotEmpty", + ("DoubleNotEmpty", ``!x y. ~({x;y} = {}) /\ ~({} = {x;y})``, METIS_TAC[Extension_ax,InDouble,Empty_def]); diff --git a/src/1/Tactical.sig b/src/1/Tactical.sig index 165c081f00..f6674f02ea 100644 --- a/src/1/Tactical.sig +++ b/src/1/Tactical.sig @@ -53,7 +53,7 @@ sig val VALIDATE_LT : list_tactic -> list_tactic val GEN_VALIDATE : bool -> tactic -> tactic val GEN_VALIDATE_LT : bool -> list_tactic -> list_tactic - val ADD_SGS_TAC : term list -> tactic -> tactic + val ADD_SGS_TAC : term list -> tactic -> tactic val EVERY : tactic list -> tactic val EVERY_LT : list_tactic list -> list_tactic val FIRST : tactic list -> tactic diff --git a/src/1/Tactical.sml b/src/1/Tactical.sml index 173fff327d..cac095df8f 100644 --- a/src/1/Tactical.sml +++ b/src/1/Tactical.sml @@ -340,7 +340,7 @@ fun REPEAT_LT ltac gl = ((ltac THEN_LT REPEAT_LT ltac) ORELSE_LT ALL_LT) gl * Add extra subgoals, which may be needed to make a tactic valid; * similar to VALIDATE, but you can control the order of the extra goals *---------------------------------------------------------------------------*) -fun ADD_SGS_TAC (tms : term list) (tac : tactic) (g as (asl, w) : goal) = +fun ADD_SGS_TAC (tms : term list) (tac : tactic) (g as (asl, w) : goal) = let val (glist, prf) = tac g ; val extra_goals = map (fn tm => (asl, tm)) tms ; val nextra = length extra_goals ; @@ -350,7 +350,7 @@ fun ADD_SGS_TAC (tms : term list) (tac : tactic) (g as (asl, w) : goal) = let val (extra_thms, thlist) = split_after nextra ethlist ; in itlist PROVE_HYP extra_thms (prf thlist) end ; in (extra_goals @ glist, eprf) end ; - + (*--------------------------------------------------------------------------- * Tacticals to make any tactic or list_tactic valid. * @@ -401,7 +401,7 @@ end * GEN_VALIDATE true tac * * is the same as "tac", except that where "tac" returns a proof which is - * invalid because it proves a theorem with extra hypotheses, + * invalid because it proves a theorem with extra hypotheses, * it returns those hypotheses as extra goals * * VALIDATE_LT ltac diff --git a/src/HolSmt/Yices.sml b/src/HolSmt/Yices.sml index 3284f5336b..def6cc5722 100644 --- a/src/HolSmt/Yices.sml +++ b/src/HolSmt/Yices.sml @@ -546,7 +546,7 @@ structure Yices = struct (* case constants for data types (+ arguments) *) let val (cases, elem) = case rands of - [] => + [] => raise Feedback.mk_HOL_ERR "Yices" "translate_term" "not a case constant (no operands)" | (h::t) => (t,h) diff --git a/src/IndDef/CoIndDefLib.sml b/src/IndDef/CoIndDefLib.sml index fbbfa9e0cc..27cd382220 100644 --- a/src/IndDef/CoIndDefLib.sml +++ b/src/IndDef/CoIndDefLib.sml @@ -71,7 +71,7 @@ fun derive_canon_coinductive_relations pclauses = val B = CONJUNCT2(ASSUME conj); val step1 = PROVE_HYP A (UNDISCH th); val step2 = PROVE_HYP B step1; - val ex_fn = fn (v, (t1, t2)) => + val ex_fn = fn (v, (t1, t2)) => (mk_exists(v, t1), CHOOSE(v, ASSUME (mk_exists(v, t1))) t2) in foldl ex_fn (conj, step2) (rev rels') end diff --git a/src/holyhammer/hhReconstruct.sml b/src/holyhammer/hhReconstruct.sml index 84bf0242a8..fd8c761ce7 100644 --- a/src/holyhammer/hhReconstruct.sml +++ b/src/holyhammer/hhReconstruct.sml @@ -27,7 +27,7 @@ fun remove_white_spaces s = end (* Assumes the term was single quoted before *) -fun unsquotify s = +fun unsquotify s = if String.size s >= 2 then String.substring (s, 1, String.size s - 2) else raise ERR "unsquotify" "" @@ -36,9 +36,9 @@ fun map_half b f l = case l of [] => [] | a :: m => if b then f a :: map_half false f m else a :: map_half true f m - + fun hh_unescape s = - let + let val sl = String.fields (fn c => c = #"#") s fun f s = case s of "hash" => "#" @@ -46,12 +46,12 @@ fun hh_unescape s = |"quote" => "\"" |"squote" => "'" | _ => raise ERR "hh_unescape" "" - in + in String.concat (map_half false f sl) end fun split_name s = case String.fields (fn c => c = #"/") s of - [_,thy,name] => (thy,name) + [_,thy,name] => (thy,name) | _ => raise ERR "split_name" "" (*--------------------------------------------------------------------------- @@ -73,14 +73,14 @@ fun readl path = (TextIO.closeIn file; l3) end -fun read_status atp_status = +fun read_status atp_status = remove_white_spaces (hd (readl atp_status)) handle _ => "Unknown" fun read_lemmas atp_out = - let + let val l = readl atp_out val l' = filter (fn x => not (mem x reserved_names_escaped)) l - in + in map (split_name o hh_unescape o unsquotify) l' end diff --git a/src/holyhammer/holyHammer.sml b/src/holyhammer/holyHammer.sml index d3879aa9cb..f5465cb648 100644 --- a/src/holyhammer/holyHammer.sml +++ b/src/holyhammer/holyHammer.sml @@ -183,8 +183,8 @@ fun hh_try thml cj time = (print "Doubling the number of predictions\n"; print "Try KNN ...\n"; hh_argl thml cj (mk_argl strat3)) handle _ => (print "Try Mepo ...\n"; hh_argl thml cj (mk_argl strat4)) handle _ => - (print "Proving the negation ...\n"; - hh_argl thml (mk_neg cj) (mk_argl strat1)) + (print "Proving the negation ...\n"; + hh_argl thml (mk_neg cj) (mk_argl strat1)) end (* Let you chose the specific prover you want to use either *) diff --git a/src/num/theories/prim_recScript.sml b/src/num/theories/prim_recScript.sml index 71604e74d7..8043f05128 100644 --- a/src/num/theories/prim_recScript.sml +++ b/src/num/theories/prim_recScript.sml @@ -132,7 +132,7 @@ val NOT_LESS_0 = val LESS_0 = store_thm("LESS_0", --`!n. 0 < (SUC n)`--, - GEN_TAC + GEN_TAC THEN REWRITE_TAC[LESS_DEF] THEN EXISTS_TAC (--`\x.x = 0`--) THEN CONV_TAC(DEPTH_CONV BETA_CONV) @@ -176,20 +176,20 @@ val LESS_MONO_EQ = (* now show that < is the transitive closure of the successor relation *) val TC_LESS_0 = prove ( --`!n. TC (\x y. y = SUC x) 0 (SUC n)`--, - INDUCT_TAC + INDUCT_TAC THENL [ irule relationTheory.TC_SUBSET THEN BETA_TAC THEN REFL_TAC, ONCE_REWRITE_TAC [relationTheory.TC_CASES2] THEN DISJ2_TAC THEN EXISTS_TAC ``SUC n`` THEN BETA_TAC THEN ASM_REWRITE_TAC [] ]) ; val TC_NOT_LESS_0 = prove ( --`!n. ~(TC (\x y. y = SUC x) n 0)`--, - ONCE_REWRITE_TAC [relationTheory.TC_CASES2] + ONCE_REWRITE_TAC [relationTheory.TC_CASES2] THEN BETA_TAC THEN REWRITE_TAC [GSYM NOT_SUC] ) ; val TC_IM_RTC_SUC = store_thm ("TC_IM_RTC_SUC", ``!m n. TC (\x y. y = SUC x) m (SUC n) = RTC (\x y. y = SUC x) m n``, - ONCE_REWRITE_TAC [relationTheory.TC_CASES2] THEN BETA_TAC + ONCE_REWRITE_TAC [relationTheory.TC_CASES2] THEN BETA_TAC THEN REWRITE_TAC [relationTheory.RTC_CASES_TC, INV_SUC_EQ] - THEN REPEAT (STRIP_TAC ORELSE EQ_TAC) + THEN REPEAT (STRIP_TAC ORELSE EQ_TAC) THEN ASM_REWRITE_TAC [] THEN DISJ2_TAC THEN EXISTS_TAC ``n : num`` THEN ASM_REWRITE_TAC []) ; @@ -198,7 +198,7 @@ val RTC_IM_TC = store_thm ("RTC_IM_TC", ``!m n. RTC (\x y. y = f x) (f m) n = TC (\x y. y = f x) m n``, REWRITE_TAC [relationTheory.EXTEND_RTC_TC_EQN] THEN BETA_TAC THEN REPEAT (STRIP_TAC ORELSE EQ_TAC) - THENL [Q.EXISTS_TAC `f m`, + THENL [Q.EXISTS_TAC `f m`, FIRST_X_ASSUM (ASSUME_TAC o SYM)] THEN ASM_REWRITE_TAC []) ; diff --git a/src/prekernel/Dep.sml b/src/prekernel/Dep.sml index dfa1278e91..543bca5faa 100644 --- a/src/prekernel/Dep.sml +++ b/src/prekernel/Dep.sml @@ -41,12 +41,12 @@ fun thydepl_of dep = case dep of | DEP_UNSAVED thydl => thydl fun flatten_thydepl thydepl = - let fun distrib (s,nl) = map (fn n => (s,n)) nl in + let fun distrib (s,nl) = map (fn n => (s,n)) nl in List.concat (map distrib thydepl) end fun depidl_of dep = flatten_thydepl (thydepl_of dep) - + (*--------------------------------------------------------------------------- Comparison ----------------------------------------------------------------------------*) @@ -71,7 +71,7 @@ fun transfer_thydepl d = case d of fun merge_intl nl1 nl2 = case (nl1, nl2) of ([], _) => nl2 | (_, []) => nl1 - | (n1 :: m1, n2 :: m2) => + | (n1 :: m1, n2 :: m2) => ( case Int.compare (n1,n2) of LESS => n1 :: merge_intl m1 nl2 diff --git a/src/quantHeuristics/quantHeuristicsLibBase.sml b/src/quantHeuristics/quantHeuristicsLibBase.sml index f8d724a3bd..c3a386e24f 100644 --- a/src/quantHeuristics/quantHeuristicsLibBase.sml +++ b/src/quantHeuristics/quantHeuristicsLibBase.sml @@ -2026,7 +2026,7 @@ local val gc'' = get_implication_gc sys v t neg dneg i P thm''; in guess_collection_append gc gc'' - end else gc + end else gc in SOME gc' end handle HOL_ERR _ => NONE; in diff --git a/src/rational/fracScript.sml b/src/rational/fracScript.sml index 72fa4af15d..4bb0cf8b6c 100644 --- a/src/rational/fracScript.sml +++ b/src/rational/fracScript.sml @@ -98,7 +98,7 @@ val FRAC_EQ = store_thm("FRAC_EQ", POP_ASSUM (MP_TAC o AP_TERM ``rep_frac``) THEN VALIDATE (CONV_TAC (DEPTH_CONV (REWR_CONV_A (UNDISCH raf_eqI)))), ALL_TAC] THEN - ASM_SIMP_TAC std_ss []) ; + ASM_SIMP_TAC std_ss []) ; (*-------------------------------------------------------------------------- * FRAC_EQ_ALT : thm @@ -149,7 +149,7 @@ val FRAC_NOT_EQ_IMP = store_thm("FRAC_NOT_EQ_IMP", * ========================================= FRAC_EQ_TAC * A ?- a1=a2 | A ?- b1=b2 * - * simplified version - note, doesn't check that goal is of given form + * simplified version - note, doesn't check that goal is of given form *--------------------------------------------------------------------------*) val FRAC_EQ_TAC:tactic = fn (asm_list,goal) => diff --git a/src/search/dftScript.sml b/src/search/dftScript.sml index baff9a3fad..1834dfc5c9 100644 --- a/src/search/dftScript.sml +++ b/src/search/dftScript.sml @@ -1,7 +1,7 @@ (*---------------------------------------------------------------------------*) (* Depth first traversal of directed graphs that can contain cycles. *) (*---------------------------------------------------------------------------*) - + open HolKernel boolLib bossLib pred_setTheory pred_setLib relationTheory listTheory; @@ -41,20 +41,20 @@ val Parents_def = Define `Parents G = {x | ~(G x = [])}`; (*---------------------------------------------------------------------------*) val Rel_def = (* map arg. tuples into a pair of numbers for termination *) - Define - `Rel(G,f,seen,to_visit,acc) = + Define + `Rel(G,f,seen,to_visit,acc) = (CARD(Parents G DIFF (LIST_TO_SET seen)), LENGTH to_visit)`; val def = (* Define function and prove termination *) tDefine - "DFT" - `DFT G f seen to_visit acc = + "DFT" + `DFT G f seen to_visit acc = if FINITE (Parents G) then case to_visit - of [] => acc + of [] => acc | visit_now :: visit_later => - if MEM visit_now seen - then DFT G f seen visit_later acc + if MEM visit_now seen + then DFT G f seen visit_later acc else DFT G f (visit_now :: seen) (G visit_now ++ visit_later) (f visit_now acc) @@ -66,14 +66,14 @@ val def = (* Define function and prove termination *) [MATCH_MP_TAC (DECIDE ``y <= x /\ y < z ==> x < z + (x - y)``) THEN CONJ_TAC THENL [METIS_TAC [CARD_INTER_LESS_EQ], - MATCH_MP_TAC (SIMP_RULE dnf_ss [] CARD_PSUBSET) + MATCH_MP_TAC (SIMP_RULE dnf_ss [] CARD_PSUBSET) THEN RW_TAC set_ss [INTER_DEF,PSUBSET_DEF,SUBSET_DEF,EXTENSION] THEN METIS_TAC[]], - MATCH_MP_TAC (SIMP_RULE dnf_ss [] CARD_PSUBSET) - THEN RW_TAC set_ss [INTER_DEF,PSUBSET_DEF,SUBSET_DEF,EXTENSION] + MATCH_MP_TAC (SIMP_RULE dnf_ss [] CARD_PSUBSET) + THEN RW_TAC set_ss [INTER_DEF,PSUBSET_DEF,SUBSET_DEF,EXTENSION] THEN METIS_TAC[], - MATCH_MP_TAC (DECIDE ``(p=q) ==> (x-p = x-q)``) - THEN MATCH_MP_TAC (METIS_PROVE [] ``(s1=s2) ==> (CARD s1 = CARD s2)``) + MATCH_MP_TAC (DECIDE ``(p=q) ==> (x-p = x-q)``) + THEN MATCH_MP_TAC (METIS_PROVE [] ``(s1=s2) ==> (CARD s1 = CARD s2)``) THEN RW_TAC set_ss [INTER_DEF,EXTENSION] THEN METIS_TAC [], FULL_SIMP_TAC set_ss [Parents_def]]); @@ -84,10 +84,10 @@ val def = (* Define function and prove termination *) val DFT_def = Q.store_thm ("DFT_def", - `FINITE (Parents G) ==> + `FINITE (Parents G) ==> (DFT G f seen [] acc = acc) /\ (DFT G f seen (visit_now :: visit_later) acc = - if MEM visit_now seen + if MEM visit_now seen then DFT G f seen visit_later acc else DFT G f (visit_now :: seen) (G visit_now ++ visit_later) @@ -106,7 +106,7 @@ val DFT_def = Q.store_thm val DFT_ind = Q.store_thm ("DFT_ind", `!P. - (!G f seen visit_now visit_later acc. + (!G f seen visit_now visit_later acc. P G f seen [] acc /\ ((FINITE (Parents G) /\ ~MEM visit_now seen ==> P G f (visit_now :: seen) @@ -117,7 +117,7 @@ val DFT_ind = Q.store_thm ==> P G f seen (visit_now :: visit_later) acc)) ==> !v v1 v2 v3 v4. P v v1 v2 v3 v4`, - NTAC 2 STRIP_TAC + NTAC 2 STRIP_TAC THEN HO_MATCH_MP_TAC (fetch "-" "DFT_ind") THEN REPEAT GEN_TAC THEN Cases_on `to_visit` THEN RW_TAC list_ss []); @@ -129,10 +129,10 @@ val DFT_ind = Q.store_thm val DFT_CONS = Q.store_thm ("DFT_CONS", `!G f seen to_visit acc a b. - FINITE (Parents G) /\ (f = CONS) /\ (acc = APPEND a b) + FINITE (Parents G) /\ (f = CONS) /\ (acc = APPEND a b) ==> (DFT G f seen to_visit acc = DFT G f seen to_visit a ++ b)`, - recInduct DFT_ind + recInduct DFT_ind THEN RW_TAC list_ss [DFT_def] THEN METIS_TAC [APPEND]); val FOLDR_UNROLL = Q.prove @@ -141,15 +141,15 @@ val FOLDR_UNROLL = Q.prove val DFT_FOLD = Q.store_thm ("DFT_FOLD", - `!G f seen to_visit acc. - FINITE (Parents G) + `!G f seen to_visit acc. + FINITE (Parents G) ==> (DFT G f seen to_visit acc = FOLDR f acc (DFT G CONS seen to_visit []))`, - recInduct DFT_ind THEN + recInduct DFT_ind THEN RW_TAC list_ss [DFT_def] THEN METIS_TAC [FOLDR_UNROLL,DFT_CONS,APPEND]); val DFT_ALL_DISTINCT_LEM = Q.prove -(`!G f seen to_visit acc. +(`!G f seen to_visit acc. FINITE (Parents G) /\ (f = CONS) /\ ALL_DISTINCT acc /\ (!x. MEM x acc ==> MEM x seen) ==> @@ -158,7 +158,7 @@ val DFT_ALL_DISTINCT_LEM = Q.prove val DFT_ALL_DISTINCT = Q.store_thm ("DFT_ALL_DISTINCT", - `!G seen to_visit. + `!G seen to_visit. FINITE (Parents G) ==> ALL_DISTINCT (DFT G CONS seen to_visit [])`, RW_TAC list_ss [DFT_ALL_DISTINCT_LEM]); @@ -166,11 +166,11 @@ val DFT_ALL_DISTINCT = Q.store_thm (* Definition of reachability in a graph of the kind we are using here. *) (*---------------------------------------------------------------------------*) -val REACH_DEF = - Define +val REACH_DEF = + Define `REACH G = RTC (\x y. MEM y (G x))`; -val REACH_LIST_DEF = +val REACH_LIST_DEF = Define `REACH_LIST G nodes y = ?x. MEM x nodes /\ y IN REACH G x`; @@ -178,7 +178,7 @@ val REACH_LIST_DEF = (* Removing a set of nodes ex from G. *) (*---------------------------------------------------------------------------*) -val EXCLUDE_DEF = +val EXCLUDE_DEF = Define `EXCLUDE G ex node = if node IN ex then [] else G node`; @@ -186,7 +186,7 @@ val EXCLUDE_DEF = (* Lemmas about reachability and restricted graphs. *) (*---------------------------------------------------------------------------*) -val EXCLUDE_LEM = Q.store_thm +val EXCLUDE_LEM = Q.store_thm ("EXCLUDE_LEM", `!G x l. EXCLUDE G (x INSERT l) = EXCLUDE (EXCLUDE G l) {x}`, RW_TAC set_ss [FUN_EQ_THM,EXTENSION, EXCLUDE_DEF, IN_INSERT, NOT_IN_EMPTY] @@ -195,8 +195,8 @@ val EXCLUDE_LEM = Q.store_thm val REACH_EXCLUDE = Q.store_thm ("REACH_EXCLUDE", `!G x. REACH (EXCLUDE G x) = RTC (\x' y. ~(x' IN x) /\ MEM y (G x'))`, - RW_TAC set_ss [REACH_DEF, EXCLUDE_DEF] THEN AP_TERM_TAC - THEN RW_TAC set_ss [FUN_EQ_THM] + RW_TAC set_ss [REACH_DEF, EXCLUDE_DEF] THEN AP_TERM_TAC + THEN RW_TAC set_ss [FUN_EQ_THM] THEN RW_TAC set_ss []); (*---------------------------------------------------------------------------*) @@ -206,16 +206,16 @@ val REACH_EXCLUDE = Q.store_thm val REACH_LEM1 = Q.store_thm ("REACH_LEM1", -`!p G seen. +`!p G seen. ~(p IN seen) ==> (REACH (EXCLUDE G seen) p = p INSERT (REACH_LIST (EXCLUDE G (p INSERT seen)) (G p)))`, - RW_TAC set_ss [EXTENSION,SPECIFICATION,REACH_EXCLUDE,REACH_LIST_DEF] - THEN Cases_on `p = x` + RW_TAC set_ss [EXTENSION,SPECIFICATION,REACH_EXCLUDE,REACH_LIST_DEF] + THEN Cases_on `p = x` THEN RW_TAC list_ss [RTC_RULES] THEN EQ_TAC THEN RW_TAC bool_ss [] THENL - [Q.PAT_ASSUM `$~a` MP_TAC THEN POP_ASSUM MP_TAC - THEN Q.SPEC_TAC (`x`,`q`) THEN Q.ID_SPEC_TAC `p` - THEN HO_MATCH_MP_TAC RTC_INDUCT_RIGHT1 THEN RW_TAC bool_ss [] + [Q.PAT_ASSUM `$~a` MP_TAC THEN POP_ASSUM MP_TAC + THEN Q.SPEC_TAC (`x`,`q`) THEN Q.ID_SPEC_TAC `p` + THEN HO_MATCH_MP_TAC RTC_INDUCT_RIGHT1 THEN RW_TAC bool_ss [] THEN Cases_on `p' = x'` THEN FULL_SIMP_TAC bool_ss [] THENL [METIS_TAC [RTC_RULES], Q.EXISTS_TAC `x''` THEN RW_TAC bool_ss [Once RTC_CASES2] THEN METIS_TAC[]], @@ -225,7 +225,7 @@ val REACH_LEM1 = Q.store_thm (*---------------------------------------------------------------------------*) (* If y is reachable from x, but not z, then y is reachable from x on a path *) -(* that does not include z. *) +(* that does not include z. *) (*---------------------------------------------------------------------------*) val REACH_LEM2 = Q.store_thm @@ -243,29 +243,29 @@ val REACH_LEM2 = Q.store_thm val DFT_REACH_1 = Q.store_thm ("DFT_REACH_1", - `!G f seen to_visit acc. + `!G f seen to_visit acc. FINITE (Parents G) /\ (f = CONS) ==> !x. MEM x (DFT G f seen to_visit acc) ==> x IN (REACH_LIST G to_visit) \/ MEM x acc`, - recInduct DFT_ind - THEN RW_TAC set_ss [DFT_def, REACH_LIST_DEF, REACH_DEF, IN_DEF] - THENL[METIS_TAC [], ALL_TAC] - THEN POP_ASSUM MP_TAC THEN RW_TAC set_ss [] + recInduct DFT_ind + THEN RW_TAC set_ss [DFT_def, REACH_LIST_DEF, REACH_DEF, IN_DEF] + THENL[METIS_TAC [], ALL_TAC] + THEN POP_ASSUM MP_TAC THEN RW_TAC set_ss [] THEN POP_ASSUM (MP_TAC o Q.SPEC `x`) THEN RW_TAC set_ss [] THENL - [IMP_RES_TAC RTC_RULES THEN METIS_TAC[], + [IMP_RES_TAC RTC_RULES THEN METIS_TAC[], METIS_TAC[], METIS_TAC[RTC_RULES], METIS_TAC[]]); (*---------------------------------------------------------------------------*) (* If x is reachable from to_visit on a path that does not include the nodes *) -(* in seen, then DFT visits x. *) +(* in seen, then DFT visits x. *) (*---------------------------------------------------------------------------*) val DFT_REACH_2 = Q.store_thm ("DFT_REACH_2", - `!G f seen to_visit acc x. + `!G f seen to_visit acc x. FINITE (Parents G) /\ (f = CONS) /\ - x IN (REACH_LIST (EXCLUDE G (LIST_TO_SET seen)) to_visit) /\ - ~MEM x seen + x IN (REACH_LIST (EXCLUDE G (LIST_TO_SET seen)) to_visit) /\ + ~MEM x seen ==> MEM x (DFT G f seen to_visit acc)`, recInduct DFT_ind THEN RW_TAC set_ss [DFT_def] THENL @@ -288,10 +288,10 @@ val DFT_REACH_2 = Q.store_thm `[]`, `visit_now::acc`] DFT_CONS], FIRST_ASSUM MATCH_MP_TAC THEN RW_TAC set_ss [] THEN Cases_on `x IN REACH (EXCLUDE G (LIST_TO_SET seen)) visit_now` THENL - [POP_ASSUM MP_TAC THEN RW_TAC set_ss [REACH_LEM1] THEN + [POP_ASSUM MP_TAC THEN RW_TAC set_ss [REACH_LEM1] THEN FULL_SIMP_TAC set_ss [SPECIFICATION,REACH_LIST_DEF,LIST_TO_SET_THM] THEN METIS_TAC [], - FULL_SIMP_TAC set_ss [SPECIFICATION, REACH_LIST_DEF,LIST_TO_SET_THM] + FULL_SIMP_TAC set_ss [SPECIFICATION, REACH_LIST_DEF,LIST_TO_SET_THM] THENL [METIS_TAC [], METIS_TAC [REACH_LEM2, EXCLUDE_LEM]]]]]); (*---------------------------------------------------------------------------*) @@ -300,9 +300,9 @@ val DFT_REACH_2 = Q.store_thm val DFT_REACH_THM = Q.store_thm ("DFT_REACH_THM", - `!G to_visit. - FINITE (Parents G) - ==> + `!G to_visit. + FINITE (Parents G) + ==> !x. x IN REACH_LIST G to_visit = MEM x (DFT G CONS [] to_visit [])`, RW_TAC bool_ss [EQ_IMP_THM] THENL [MATCH_MP_TAC DFT_REACH_2,IMP_RES_TAC DFT_REACH_1] THEN From 3a35ef493d1bca8fb0e28722e0da5da3968bf398 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 21 Oct 2015 16:22:52 +1100 Subject: [PATCH 554/718] Tidy unicode-grep; delete redundant find-nonascii --- developers/find-nonascii | 10 ---------- developers/unicode-grep | 22 +++++++++++++++++++--- 2 files changed, 19 insertions(+), 13 deletions(-) delete mode 100755 developers/find-nonascii diff --git a/developers/find-nonascii b/developers/find-nonascii deleted file mode 100755 index 2d7125a691..0000000000 --- a/developers/find-nonascii +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh - -if [ $# -eq 0 ] -then - echo "Usage: $0 dir1 dir2 .. dirn" >&2 - exit 1 -fi - -# assumes recent GNU grep -grep -n -R -P "[\x80-\xFF]" --include=*.sml --include=*.sig --exclude=*Theory.sig "$@" diff --git a/developers/unicode-grep b/developers/unicode-grep index 63f4b0dc15..b8cd36eabc 100755 --- a/developers/unicode-grep +++ b/developers/unicode-grep @@ -1,7 +1,23 @@ #!/bin/bash -# assumes a particular flavour of grep, as per http://stackoverflow.com/questions/3001177/how-do-i-grep-for-all-non-ascii-characters-in-unix +if [ $# -eq 1 ] +then + if [ $1 = "-h" -o $1 = "-?" ] + then + echo "Usage:" + echo " $0 dir1 dir2 .. dirn" + echo + echo "Recursively grep over dirs looking for non-ASCII characters" + echo "If no directories given, run in HOL's src directory" + exit 0 + fi +fi -# As of 18 Feb 2014, sources include some Unicode in comments. +cmd="grep -R -n -v -E '^[[:print:][:space:]]*$|UOK' --include='*.sml' --exclude='*Theory.sml' --exclude='*Theory.sig' --exclude selftest.sml --exclude EmitTeX.sml" -LC_ALL=C grep -R -n -v -E '^[[:print:][:space:]]*$|UOK' --include=*.sml --exclude=*Theory.sml --exclude=*Theory.sig --exclude selftest.sml --exclude EmitTeX.sml "$(dirname $0)/../src/" +if [ $# -eq 0 ] +then + LC_ALL=C eval $cmd $(dirname $0)/../src/ +else + LC_ALL=C eval $cmd "$@" +fi From 594f9a631b5e4bad652c6272867bc3d9f6e19a06 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 21 Oct 2015 16:38:59 +1100 Subject: [PATCH 555/718] Use regression tests to check for Unicode in src --- src/portableML/testsrc/Holmakefile | 8 ++++++++ src/portableML/testsrc/README | 2 ++ tools/sequences/kernel | 1 + 3 files changed, 11 insertions(+) create mode 100644 src/portableML/testsrc/Holmakefile create mode 100644 src/portableML/testsrc/README diff --git a/src/portableML/testsrc/Holmakefile b/src/portableML/testsrc/Holmakefile new file mode 100644 index 0000000000..b64c1736e1 --- /dev/null +++ b/src/portableML/testsrc/Holmakefile @@ -0,0 +1,8 @@ +ifneq($(OS),winNT) + +.PHONY: all + +all: + if $(HOLDIR)/developers/unicode-grep ; then false ; else true ; fi + +endif diff --git a/src/portableML/testsrc/README b/src/portableML/testsrc/README new file mode 100644 index 0000000000..ecb6dd9e3b --- /dev/null +++ b/src/portableML/testsrc/README @@ -0,0 +1,2 @@ +This directory is only present to able regression testing of the +source tree with automated well-formedness checks. diff --git a/tools/sequences/kernel b/tools/sequences/kernel index 2547c8114e..d3e3666dbe 100644 --- a/tools/sequences/kernel +++ b/tools/sequences/kernel @@ -3,6 +3,7 @@ tools/mlyacc/mlyacclib [mosml]src/portableML/mosml [poly]src/portableML/poly src/portableML +!src/portableML/testsrc src/prekernel **KERNEL** src/postkernel From c59b8cb17d30d3f911d7e8f8938b995f1527bd2e Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 22 Oct 2015 14:17:10 +1100 Subject: [PATCH 556/718] Tweak description of option theory's case constant In particular, it's now called option_CASE and takes its arguments in a different order. Also fix a typographic fix (using \tt in paragraph to refer to option type rather than \sf) --- Manual/Description/theories.tex | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/Manual/Description/theories.tex b/Manual/Description/theories.tex index 4eeb035a66..28b4d8142d 100644 --- a/Manual/Description/theories.tex +++ b/Manual/Description/theories.tex @@ -1263,7 +1263,7 @@ \subsection{The option type} Options can be used to model partial functions. If a function of type $\alpha\rightarrow\beta$ does not have useful $\beta$ values for all $\alpha$ inputs, then this distinction can be marked by making the -range of the function $\beta\,\konst{option}$, and mapping the +range of the function $\beta\,\holtxt{option}$, and mapping the undefined $\alpha$ values to \holtxt{NONE}. An inductive type, options have a recursion theorem supporting the @@ -1288,12 +1288,12 @@ \subsection{The option type} \end{verbatim} \end{hol} % -The constant underlying this syntactic sugar is \verb+option_case+ +The constant underlying this syntactic sugar is \verb+option_CASE+ with definition \begin{hol} \begin{verbatim} - option_case_def |- (option_case u f NONE = u) /\ - (option_case u f (SOME x) = f x) + option_case_def |- (option_CASE NONE u f = u) /\ + (option_CASE (SOME x) u f = f x) \end{verbatim} \end{hol} % From 036c9844e404068ab9d4701b76df1743d4411c66 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 26 Oct 2015 12:24:56 +1100 Subject: [PATCH 557/718] Improve tactic selection/movement in emacs mode Also add new "execute the next tactic" binding on M-h M-e, which "automagically" selects the next tactic from the source buffer, and applies it. If the next tactic is, say, a parenthesised argument to >-/THEN1, it will select all of it. To step into such a tactic, the user has to manually move the cursor into the sexp. --- doc/kananaskis-11.release.md | 5 + tools/hol-mode.src | 230 ++++++++++++++++++++++++++++------- 2 files changed, 192 insertions(+), 43 deletions(-) diff --git a/doc/kananaskis-11.release.md b/doc/kananaskis-11.release.md index 1ccc9bae07..bd3b942985 100644 --- a/doc/kananaskis-11.release.md +++ b/doc/kananaskis-11.release.md @@ -29,6 +29,11 @@ New features: We removed `prim_constant_definition` from the kernel, but kept `prim_specification` because the new derivation of `new_specification` uses pairs. ([Github pull-req](https://github.com/HOL-Theorem-Prover/HOL/pull/201)) +- Various commands for moving over and selecting HOL tactics in the emacs mode have been improved. + We have also added a new command `hol-find-eval-next-tactic` (bound to `M-h M-e` by default), which selects and highlights the next tactic in the source text, and then applies it to the current goal in the `*HOL*` buffer. + This shortcuts the current idiom, which requires the tactic to be highlighted manually, and then applied *via* `M-h e`. + (The advantage of the latter is that one can select specific tactic sequences to be applied all at once.) + Bugs fixed: ----------- diff --git a/tools/hol-mode.src b/tools/hol-mode.src index ed01981c18..14bb2d2cf0 100644 --- a/tools/hol-mode.src +++ b/tools/hol-mode.src @@ -138,16 +138,39 @@ process in it." hol-buffer-name)) +(defun forward-smlsymbol (n) + (interactive "p") + (cond ((> n 0) + (while (> n 0) + (skip-syntax-forward "^.") + (skip-syntax-forward ".") + (setq n (- n 1)))) + ((< n 0) + (setq n (- n)) + (setq n (- n (if (equal (skip-syntax-backward ".") 0) 0 1)))) + (while (> n 0) + (skip-syntax-backward "^.") + (skip-syntax-backward ".") + (setq n (- n 1))))) + (defun is-a-then (s) - (and s (or (string-equal s "THEN") (string-equal s "THENL")))) + (and s (or (string-equal s "THEN") + (string-equal s "THENL") + (string-equal s "val") + (string-equal s ">-") + (string-equal s ">>") + (string-equal s ">|") + (string-equal s "\\\\")))) (defun next-hol-lexeme-terminates-tactic () (skip-syntax-forward " ") (or (eobp) (char-equal (following-char) ?,) + (char-equal (following-char) ?\)) ;; (char-equal (following-char) ?=) (char-equal (following-char) ?\;) (is-a-then (word-at-point)) + (is-a-then (thing-at-point 'smlsymbol t)) (string= (word-at-point) "val"))) (defun previous-hol-lexeme-terminates-tactic () @@ -157,12 +180,155 @@ process in it." (char-equal (preceding-char) ?,) (char-equal (preceding-char) ?=) (char-equal (preceding-char) ?\;) + (char-equal (preceding-char) ?\)) (and (condition-case nil (progn (backward-char 1) t) (error nil)) (or (is-a-then (word-at-point)) + (is-a-then (thing-at-point 'smlsymbol t)) (string= (word-at-point) "val")))))) +(defun looking-at-tactic-terminator () + "Returns a cons-pair (x . y), with x the distance to end, and y the + size of the terminator, or nil if there isn't one there. The x value may + be zero, if point is immediately after the terminator." + (interactive) + (let ((c (following-char)) + (pc (preceding-char))) + (cond ((char-equal c ?,) '(1 . 1)) + ((char-equal pc ?,) '(0 . 1)) + ((char-equal c ?\)) '(1 . 1)) + ((char-equal pc ?\)) '(0 . 1)) + ((char-equal c ?\]) '(1 . 1)) + ((char-equal pc ?\]) '(0 . 1)) + ((char-equal c ?\;) '(1 . 1)) + ((char-equal pc ?\;) '(0 . 1)) + ((let ((w (word-at-point))) + (if (is-a-then w) + (cons + (- (cdr (bounds-of-thing-at-point 'word)) (point)) + (length w)) + (let ((w (thing-at-point 'smlsymbol t))) + (if (is-a-then w) + (cons + (- (cdr (bounds-of-thing-at-point 'smlsymbol)) (point)) + (length w)) + nil)))))))) + +(defun looking-at-tactic-starter () + "Returns a cons-pair (x . y), with x the distance to end, and y the + size of the terminator, or nil if there isn't one there. The x value may + be zero, if point is immediately after the terminator." + (interactive) + (let ((c (following-char)) + (pc (preceding-char))) + (cond ((char-equal c ?,) '(1 . 1)) + ((char-equal pc ?,) '(0 . 1)) + ((char-equal c ?\() '(1 . 1)) + ((char-equal pc ?\() '(0 . 1)) + ((char-equal c ?\[) '(1 . 1)) + ((char-equal pc ?\[) '(0 . 1)) + ((char-equal c ?\;) '(1 . 1)) + ((char-equal pc ?\;) '(0 . 1)) + ((let ((w (word-at-point))) + (if (is-a-then w) + (cons + (- (cdr (bounds-of-thing-at-point 'word)) (point)) + (length w)) + (let ((w (thing-at-point 'smlsymbol t))) + (if (is-a-then w) + (cons + (- (cdr (bounds-of-thing-at-point 'smlsymbol)) (point)) + (length w)) + nil)))))))) + + +(defun forward-tactic-terminator (n) + (interactive "^p") + (cond ((> n 0) + (let (c) + (while (> n 0) + (skip-syntax-forward " ") + (setq c (looking-at-tactic-terminator)) + (while (or (not c) (equal (car c) 0)) + (forward-sexp) + (skip-syntax-forward " ") + (setq c (looking-at-tactic-terminator))) + (forward-char (car c)) + (setq n (- n 1))))) + ((< n 0) + (setq n (- n)) + (let (c) + (while (> n 0) + (skip-syntax-backward " ") + (setq c (looking-at-tactic-terminator)) + (while (or (not c) (equal (car c) (cdr c))) + (condition-case nil + (backward-sexp) + (error (backward-char))) + (skip-syntax-backward " ") + (setq c (looking-at-tactic-terminator))) + (backward-char (- (cdr c) (car c))) + (setq n (- n 1))))))) + +(defun forward-tactic-starter (n) + (interactive "^p") + (cond ((> n 0) + (let (c) + (while (> n 0) + (skip-syntax-forward " ") + (setq c (looking-at-tactic-starter)) + (while (or (not c) (equal (car c) 0)) + (forward-sexp) + (skip-syntax-forward " ") + (setq c (looking-at-tactic-starter))) + (forward-char (car c)) + (setq n (- n 1))))) + ((< n 0) + (setq n (- n)) + (let (c) + (while (> n 0) + (skip-syntax-backward " ") + (setq c (looking-at-tactic-starter)) + (while (or (not c) (equal (car c) (cdr c))) + (condition-case nil + (backward-sexp) + (error (backward-char))) + (skip-syntax-backward " ") + (setq c (looking-at-tactic-starter))) + (backward-char (- (cdr c) (car c))) + (setq n (- n 1))))))) + +(defun preceded-by-starter () + (save-excursion + (backward-char) + (thing-at-point 'tactic-starter))) +(defun forward-hol-tactic (n) + (interactive "^p") + (cond ((> n 0) + (while (> n 0) + (skip-syntax-forward " ") + (while (thing-at-point 'tactic-terminator) + (forward-tactic-terminator 1) + (skip-syntax-forward " ")) + (while (not (thing-at-point 'tactic-terminator)) + (forward-sexp 1) + (skip-syntax-forward " ")) + (skip-syntax-backward " ") + (setq n (- n 1)))) + ((< n 0) + (setq n (- n)) + (while (> n 0) + (skip-syntax-backward " ") + (while (preceded-by-starter) + (forward-tactic-starter -1) + (skip-syntax-backward " ")) + (while (not (preceded-by-starter)) + (forward-sexp -1) + (skip-syntax-backward " ")) + (skip-syntax-forward " ") + (setq n (- n 1)))))) + ;;; returns true and moves forward a sexp if this is possible, returns nil ;;; and stays where it is otherwise (defun my-forward-sexp () @@ -174,54 +340,12 @@ process in it." (progn (backward-sexp 1) t) (error nil))) -(defun skip-hol-tactic-punctuation-forward () - (let ((last-point (point))) - (while (progn (if (is-a-then (word-at-point)) (forward-word 1)) - (skip-chars-forward ", \n\t\r") - (not (= last-point (point)))) - (setq last-point (point))))) - (defun word-before-point () (save-excursion (condition-case nil (progn (backward-char 1) (word-at-point)) (error nil)))) -(defun skip-hol-tactic-punctuation-backward () - (let ((last-point (point))) - (while (progn (if (is-a-then (word-before-point)) (forward-word -1)) - (skip-chars-backward ", \n\t") - (not (= last-point (point)))) - (setq last-point (point))))) - -(defun forward-hol-tactic (n) - (interactive "p") - ;; to start you have to get off "tactic" punctuation, i.e. whitespace, - ;; commas and the words THEN and THENL. - (let ((count (or n 1))) - (cond ((> count 0) - (while (> count 0) - (let (moved) - (skip-hol-tactic-punctuation-forward) - (while (and (not (next-hol-lexeme-terminates-tactic)) - (my-forward-sexp)) - (setq moved t)) - (skip-chars-backward " \n\t\r") - (setq count (- count 1)) - (if (not moved) - (error "No more HOL tactics at this level"))))) - ((< count 0) - (while (< count 0) - (let (moved) - (skip-hol-tactic-punctuation-backward) - (while (and (not (previous-hol-lexeme-terminates-tactic)) - (my-backward-sexp)) - (setq moved t)) - (skip-chars-forward " \n\t\r") - (setq count (+ count 1)) - (if (not moved) - (error "No more HOL tactics at this level")))))))) - (defun backward-hol-tactic (n) (interactive "p") (forward-hol-tactic (if n (- n) -1))) @@ -306,6 +430,25 @@ or \">-\"." string))) (replace-regexp-in-string (concat tactic-connective-regexp "\\'") "" s0))) +(defun hol-find-eval-next-tactic (arg) + "Highlights the next tactic in the source and evaluates in the HOL buffer. +With a prefix ARG, uses `expandf' rather than `e'." + (interactive "P") + (deactivate-mark) + (skip-syntax-forward " ") + (let + ((term (thing-at-point 'tactic-terminator)) + (sqb (char-equal (following-char) ?\[))) + (while (or term sqb) + (cond (term (forward-tactic-terminator 1)) + (sqb (forward-char))) + (skip-syntax-forward " ") + (setq term (thing-at-point 'tactic-terminator)) + (setq sqb (char-equal (following-char) ?\[)))) + (mark-hol-tactic) + (copy-region-as-hol-tactic (region-beginning) (region-end) arg) + (goto-char (region-end))) + (defun copy-region-as-hol-tactic (start end arg) "Send selected region to HOL process as tactic." (interactive "r\nP") @@ -1608,6 +1751,7 @@ second is to show the new term. (define-key hol-map "d" 'hol-drop-goal) (define-key hol-map "D" 'hol-drop-all-goals) (define-key hol-map "e" 'copy-region-as-hol-tactic) +(define-key hol-map "\M-e" 'hol-find-eval-next-tactic) (define-key hol-map "E" 'copy-region-as-goaltree-tactic) (define-key hol-map "g" 'hol-do-goal) (define-key hol-map "G" 'hol-do-goaltree) From 11ce3a0b21fa430211a8eed20d9d7fac5e9a90c0 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 27 Oct 2015 10:29:20 +1100 Subject: [PATCH 558/718] Add "termination goal" to g/stack menu in hol-mode --- tools/hol-mode.src | 3 +++ 1 file changed, 3 insertions(+) diff --git a/tools/hol-mode.src b/tools/hol-mode.src index 14bb2d2cf0..355a9c49fb 100644 --- a/tools/hol-mode.src +++ b/tools/hol-mode.src @@ -2064,6 +2064,9 @@ second is to show the new term. (define-key global-map [menu-bar hol-menu hol-goalstack apply-tactic] '("Apply tactic" . copy-region-as-hol-tactic)) +(define-key global-map [menu-bar hol-menu hol-goalstack new-termination-goal] + '("New termination goal" . hol-start-termination-proof)) + (define-key global-map [menu-bar hol-menu hol-goalstack new-goal] '("New goal" . hol-do-goal)) From 66b7f841006a034761545daa9e365d493e6b6dab Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 4 Nov 2015 11:47:09 +1100 Subject: [PATCH 559/718] Fix unescaped $ syntax error in doc-file. Dollar signs have to occur between braces ({ .. }) so that LaTeX only sees them inside verbatim chunks. --- help/Docfiles/Parse.thytype_abbrev.doc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/help/Docfiles/Parse.thytype_abbrev.doc b/help/Docfiles/Parse.thytype_abbrev.doc index f3a89bcc81..2cdde4efe0 100644 --- a/help/Docfiles/Parse.thytype_abbrev.doc +++ b/help/Docfiles/Parse.thytype_abbrev.doc @@ -12,7 +12,7 @@ Parsing, pretty-printing. A call to {thytype_abbrev({Name=n,Thy=t}, ty)} establishes the ``kernel'' name {t$n} as an abbreviation for the type {ty}, as happens with {type_abbrev}. In other words, after the call it becomes possible -to write ``:args t$n`` to stand for type {ty}. If there are type +to write {``:args t$n``} to stand for type {ty}. If there are type variables in {ty} they become the parameters to the new abbreviated type operator. These parameters need to be filled in in the {args} position above. If there are no type variables in {ty} then From 1af1c8d3f48639a9ac19a1af922e6bbfab604c1b Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 16 Nov 2015 17:00:53 +1100 Subject: [PATCH 560/718] Work on making record fupd fns more polymorphic This is github issue #173. Selftest checks for right behaviour. But an earlier test is failing because the handling of "big records" hasn't been completely updated. --- src/datatype/Datatype.sml | 10 +- src/datatype/record/RecordType.sml | 193 +++++++++++++++++++++-------- src/datatype/selftest.sml | 6 + 3 files changed, 152 insertions(+), 57 deletions(-) diff --git a/src/datatype/Datatype.sml b/src/datatype/Datatype.sml index d98b9121d9..8d23e6f556 100644 --- a/src/datatype/Datatype.sml +++ b/src/datatype/Datatype.sml @@ -656,12 +656,14 @@ fun define_bigrec_functions (tyname, fldlist) = let val leaf_fupdname = leaf_accname ^ "_fupd" val leaf_fupd = prim_mk_const{Name = leaf_fupdname, Thy = current_theory()} val fupd_const_name = acc_const_name ^ "_fupd" - val fupd_const = mk_var(fupd_const_name, (field_ty --> field_ty) --> - (toprec_ty --> toprec_ty)) - val field_fvar = mk_var("f", field_ty --> field_ty) + val (leafd, leafr) = dom_rng (type_of leaf_fupd) + val (topd, topr) = dom_rng (type_of subrec_fupd) + val tysig = match_type topd leafr + val fupd_const = mk_var(fupd_const_name, leafd --> type_subst tysig topr) + val field_fvar = mk_var("f", leafd) val fupd_defn = mk_eq(list_mk_comb(fupd_const, [field_fvar, rvar]), - list_mk_comb(subrec_fupd, + list_mk_comb(inst tysig subrec_fupd, [mk_comb(leaf_fupd, field_fvar), rvar])) val fupd_defn_th = new_definition(fupd_const_name, fupd_defn) val fupd_defn_const = defn_hd fupd_defn_th diff --git a/src/datatype/record/RecordType.sml b/src/datatype/record/RecordType.sml index 983021f8ed..c4ca90a6b5 100644 --- a/src/datatype/record/RecordType.sml +++ b/src/datatype/record/RecordType.sml @@ -107,6 +107,48 @@ fun update_tyinfo opt new_simpls tyinfo = (put_fields flds base)) end +fun digit_suffix s = + let + val ss = Substring.full s + val (l,r) = Substring.splitr Char.isDigit ss + in + (Substring.string l, Int.fromString (Substring.string r)) + end + +fun nexttyvar ty = + let + val qnm = dest_vartype ty + val nm = String.extract(qnm, 1, NONE) + in + if size nm = 1 andalso Char.isLower (String.sub(nm, 0)) then + if nm <> "z" then + mk_vartype("'" ^ String.str (Char.chr(Char.ord (String.sub(nm,0)) + 1))) + else + mk_vartype "'a0" + else + case digit_suffix qnm of + (pfx, NONE) => mk_vartype (pfx ^ "0") + | (pfx, SOME i) => mk_vartype (pfx ^ Int.toString (i + 1)) + end + +fun tyvariant avoids ty = + if mem ty avoids then tyvariant avoids (nexttyvar ty) + else ty + +(* assumes that avoids is a superset of tyvs *) +fun freshsubst avoids tyvs = + let + fun foldthis (tyv, (avoids, s)) = + let + val v' = tyvariant avoids tyv + in + (v'::avoids, (tyv |-> v') :: s) + end + in + #2 (List.foldl foldthis (avoids, []) tyvs) + end + + (* ---------------------------------------------------------------------- prove_recordtype_thms @@ -135,6 +177,33 @@ fun prove_recordtype_thms (tyinfo, fields) = let in domtys [] (type_of constructor) end + val varying_tyvs = let + val tymap = Binarymap.mkDict Type.compare : (hol_type,int) Binarymap.dict + fun recurse m tys = + case tys of + [] => m + | ty::tyrest => + let + val tyvs = HOLset.fromList Type.compare (Type.type_vars ty) + fun foldthis (tyv,m) = + case Binarymap.peek(m, tyv) of + NONE => Binarymap.insert(m,tyv,1) + | SOME i => Binarymap.insert(m,tyv,i+1) + in + recurse (HOLset.foldl foldthis m tyvs) tyrest + end + in + Binarymap.foldl (fn (tyv,c,acc) => if c = 1 then tyv::acc else acc) + [] + (recurse tymap types) + end + + val tysigma = let + val avoids = Type.type_varsl types + in + freshsubst avoids varying_tyvs + end + val sigsubst = type_subst tysigma val var = Psyntax.mk_var(app_letter typ, typ) val size = length fields @@ -186,17 +255,25 @@ fun prove_recordtype_thms (tyinfo, fields) = let field_fupd f o = field_update (f (field o)) o *) val fupd_names = map (fn s => s ^ "_fupd") access_fn_names - val fupd_fun_types = map (fn t => t --> t) types - val fupd_types = map (fn t => t --> (typ --> typ)) fupd_fun_types - val fupd_terms = ListPair.map mk_var (fupd_names, fupd_types) - fun mk_fupd_defn (fldfupd, result, (pos, acc)) = let + fun getredex t = let + val tyvs = type_vars t + in + List.filter (fn {redex,residue} => mem redex tyvs) + end + val fupd_fun_types = + map (fn t => (getredex t tysigma, t --> sigsubst t)) types + val fupd_types = + map (fn (s,t) => (s, t --> typ --> type_subst s typ)) fupd_fun_types + val fupd_terms = + ListPair.map (fn (n,(s,ty)) => (s, mk_var(n,ty))) (fupd_names, fupd_types) + fun mk_fupd_defn ((s, fldfupd), result, (pos, acc)) = let val (f_ty, _) = dom_rng (type_of fldfupd) val f0 = mk_var("f", f_ty) val f = variant typeletters f0 in (pos + 1, mk_eq(list_mk_comb(fldfupd, [f, cons_comb]), - list_mk_comb(constructor, + list_mk_comb(Term.inst s constructor, update pos (mk_comb(f, result)) typeletters)) :: acc) end val (_, fupd_def_terms0) = ListPair.foldl mk_fupd_defn (1, []) @@ -207,7 +284,8 @@ fun prove_recordtype_thms (tyinfo, fields) = let val fupdfn_thms = ListPair.map mk_defn_th (fupd_names, fupd_def_terms) val fupdfn_thm = save_thm(typename^"_fn_updates", LIST_CONJ fupdfn_thms) - val fupdfn_terms = map (mk_const o dest_var) fupd_terms + val fupdfn_terms = + map (fn (s, v) => (s, mk_const (dest_var v))) fupd_terms (* do cases and induction theorem *) @@ -227,17 +305,17 @@ fun prove_recordtype_thms (tyinfo, fields) = let fld1 (fld2_fupd val r) = fld1 r ) *) - fun create_goal (acc, fupd) = let + fun create_goal (acc, (s, fupd)) = let val f = gen_var_domty("f", fupd, [var]) in - Term`^acc (^fupd ^f ^var) = ^acc ^var` + Term`^(Term.inst s acc) (^fupd ^f ^var) = ^acc ^var` end val combinations = crosslessdiag accfn_terms fupdfn_terms val goals = map create_goal combinations - fun create_goal (acc, fupd) = let + fun create_goal (acc, (s, fupd)) = let val f = gen_var_domty("f", fupd, [var]) in - Term`^acc (^fupd ^f ^var) = ^f (^acc ^var)` + Term`^(Term.inst s acc) (^fupd ^f ^var) = ^f (^acc ^var)` end val diag_goals = ListPair.map create_goal (accfn_terms, fupdfn_terms) val tactic = STRUCT_CASES_TAC (SPEC var cases_thm) THEN @@ -286,14 +364,18 @@ fun prove_recordtype_thms (tyinfo, fields) = let (* do fupdates of (same) fupdates *) (* i.e., fupd_fld1 f (fupd_fld1 g r) = fupd_fld1 (f o g) r *) - fun create_goal fupd = let - val fty = #1 (dom_rng (type_of fupd)) + fun create_goal (s, fupd) = let + val fupdty = type_of fupd + val (gty,r) = dom_rng fupdty + val (gd, gr) = dom_rng gty + val ftys = freshsubst (type_vars fupdty) (map #residue s) + val fty = gr --> type_subst ftys gr val f = variant [var] (mk_var("f", fty)) - val g = variant [var, f] (mk_var("g", fty)) - val x = variant [var, f, g] (mk_var("x", #1 (dom_rng fty))) + val g = variant [var, f] (mk_var("g", gty)) in - mk_eq(list_mk_comb(fupd, [f, list_mk_comb(fupd, [g, var])]), - list_mk_comb(fupd, [combinSyntax.mk_o(f, g), var])) + mk_eq(list_mk_comb(inst s (inst ftys fupd), + [f, list_mk_comb(fupd, [g, var])]), + list_mk_comb(inst ftys fupd, [combinSyntax.mk_o(f, g), var])) end val goals = map create_goal fupdfn_terms val thms = map (C (curry prove) tactic) goals @@ -306,18 +388,18 @@ fun prove_recordtype_thms (tyinfo, fields) = let (* do fupdates of (different) fupdates *) val combinations = crossprod fupdfn_terms fupdfn_terms val filterfn = (fn (n,_) => let val m = n - 1 - val d = m div size + val d = m div size val m = m - (d * size) in d > m end) val lower_triangle = nfilter filterfn combinations - fun create_goal(f1,f2) = let + fun create_goal((s1, f1),(s2, f2)) = let val (f_t, _) = dom_rng (type_of f1) val (g_t, _) = dom_rng (type_of f2) val f = variant [var] (mk_var("f", f_t)) val g = variant [var, f] (mk_var("g", g_t)) in - mk_eq(list_mk_comb(f1, [f, list_mk_comb(f2, [g, var])]), - list_mk_comb(f2, [g, list_mk_comb(f1, [f, var])])) + mk_eq(list_mk_comb(inst s2 f1, [f, list_mk_comb(f2, [g, var])]), + list_mk_comb(inst s1 f2, [g, list_mk_comb(f1, [f, var])])) end val goals = map create_goal lower_triangle val fupdcanon_thms = map (C (curry prove) tactic) goals @@ -391,12 +473,16 @@ fun prove_recordtype_thms (tyinfo, fields) = let variant avoids v0 end + fun rng_of_dom ty = ty |> dom_rng |> #1 |> dom_rng |> #2 + fun dom_of_dom ty = ty |> dom_rng |> #1 |> dom_rng |> #1 val value_vars = - List.take(List.foldr - (fn (ty, sofar) => - mk_var_avds(app_letter ty, ty, var::sofar)::sofar) - [var] types, - length fields) + List.foldr + (fn ((_,updt), sofar) => + let val ty = rng_of_dom (type_of updt) + in + mk_var_avds(app_letter ty, ty, var::sofar)::sofar + end) + [var] fupdfn_terms |> (fn l => List.take(l, length fields)) fun augvar n v = let val (nm, ty) = dest_var v in @@ -405,20 +491,17 @@ fun prove_recordtype_thms (tyinfo, fields) = let val vvars1 = map (augvar 1) value_vars val vvars2 = map (augvar 2) value_vars val arb = mk_arb typ - fun mapthis (upd,v) = let + fun foldthis ((s,upd),v,(s0,acc)) = let val ty = type_of v - val K = Term.inst [alpha |-> ty, beta |-> ty] K_tm + val K = Term.inst [alpha |-> ty, beta |-> dom_of_dom (type_of upd)] K_tm in - mk_comb(upd, mk_comb(K, v)) + (s @ s0,mk_comb(mk_comb(inst s0 upd, mk_comb(K, v)), acc)) end - val updfns = ListPair.map mapthis (fupdfn_terms, value_vars) - val lhs = List.foldr mk_comb var updfns - val rhs = List.foldr mk_comb arb updfns + val (_, lhs) = ListPair.foldr foldthis ([], var) (fupdfn_terms, value_vars) + val (_, rhs) = ListPair.foldr foldthis ([], arb) (fupdfn_terms, value_vars) - val lit1 = - List.foldr mk_comb arb (ListPair.map mapthis (fupdfn_terms, vvars1)) - val lit2 = - List.foldr mk_comb arb (ListPair.map mapthis (fupdfn_terms, vvars2)) + val (_, lit1) = ListPair.foldr foldthis ([], arb) (fupdfn_terms, vvars1) + val (_, lit2) = ListPair.foldr foldthis ([], arb) (fupdfn_terms, vvars2) val literal_equality = GENL (var::value_vars) @@ -427,36 +510,38 @@ fun prove_recordtype_thms (tyinfo, fields) = let C SPEC cases_thm) [arb, var] THEN REWRITE_TAC [fupdfn_thm, combinTheory.K_THM])) + val var' = inst tysigma var + val typ' = type_of var' val literal_nchotomy = - GEN var - (prove(list_mk_exists(value_vars, mk_eq(var, rhs)), - MAP_EVERY (STRUCT_CASES_TAC o C SPEC cases_thm) - [arb, var] THEN + GEN var' + (prove(list_mk_exists(value_vars, mk_eq(var', rhs)), + MAP_EVERY (STRUCT_CASES_TAC o C ISPEC cases_thm) + [arb, var'] THEN REWRITE_TAC [fupdfn_thm, accessor_thm, oneone_thm, combinTheory.K_THM] THEN REPEAT Unwind.UNWIND_EXISTS_TAC)) - val pred_r = mk_var_avds("P", typ --> bool, var::value_vars) - val P_r = mk_comb(pred_r, var) + val pred_r = mk_var_avds("P", typ' --> bool, var::value_vars) + val P_r = mk_comb(pred_r, var') val P_literal = mk_comb(pred_r, rhs) - val forall_goal = mk_eq(mk_forall(var, P_r), + val forall_goal = mk_eq(mk_forall(var', P_r), list_mk_forall(value_vars, P_literal)) - val exists_goal = mk_eq(mk_exists(var, P_r), + val exists_goal = mk_eq(mk_exists(var', P_r), list_mk_exists(value_vars, P_literal)) val forall_thm = GEN_ALL (prove(forall_goal, EQ_TAC THEN STRIP_TAC THEN ASM_REWRITE_TAC [] THEN - X_GEN_TAC var THEN - STRUCT_CASES_TAC (SPEC var literal_nchotomy) THEN + X_GEN_TAC var' THEN + STRUCT_CASES_TAC (ISPEC var' literal_nchotomy) THEN ASM_REWRITE_TAC [])) val exists_thm = GEN_ALL (prove(exists_goal, EQ_TAC THENL [ - DISCH_THEN (X_CHOOSE_THEN var ASSUME_TAC) THEN + DISCH_THEN (X_CHOOSE_THEN var' ASSUME_TAC) THEN EVERY_TCL (map X_CHOOSE_THEN value_vars) - SUBST_ALL_TAC (SPEC var literal_nchotomy) THEN + SUBST_ALL_TAC (ISPEC var' literal_nchotomy) THEN MAP_EVERY EXISTS_TAC value_vars THEN ASM_REWRITE_TAC [], DISCH_THEN (EVERY_TCL (map X_CHOOSE_THEN value_vars) ASSUME_TAC) THEN @@ -466,7 +551,7 @@ fun prove_recordtype_thms (tyinfo, fields) = let val literal_11 = GENL (vvars1 @ vvars2) (REWRITE_RULE [accfupd_thm, combinTheory.K_THM] - (SPECL [lit1, lit2] component_wise_equality)) + (ISPECL [lit1, lit2] component_wise_equality)) in val literal_equality = @@ -498,10 +583,11 @@ fun prove_recordtype_thms (tyinfo, fields) = let if List.exists (is_substring brss) (typename :: fields) then () else let - fun do_fupdfn (name0, tm) = let val name = name0 ^ "_fupd" - in - Parse.overload_on(name, tm) - end + fun do_fupdfn (name0, (_, tm)) = + let val name = name0 ^ "_fupd" + in + Parse.overload_on(name, tm) + end in ListPair.app add_record_field (fields, accfn_terms); (* overload strings of the form fld_fupd to refer to the @@ -513,7 +599,8 @@ fun prove_recordtype_thms (tyinfo, fields) = let syntax, and we want this to be preferred where possible. *) ListPair.app do_fupdfn (fields, fupdfn_terms); - ListPair.app add_record_fupdate (fields, fupdfn_terms); + ListPair.app (fn (n,(_,t)) => add_record_fupdate(n,t)) + (fields, fupdfn_terms); Parse.overload_on(typename, constructor) end diff --git a/src/datatype/selftest.sml b/src/datatype/selftest.sml index f20ecea576..74a1991815 100644 --- a/src/datatype/selftest.sml +++ b/src/datatype/selftest.sml @@ -295,4 +295,10 @@ val num = numSyntax.num val _ = Datatype.Datatype `dtypeAQ = C13 ^num bool | C14 (^num -> bool)` val _ = print "OK\n" +val _ = tprint "Records with polymorphic fields 1" +val _ = (``polyrcd_pfld1_fupd : + ('c ms -> 'e ms) -> ('c,'d) polyrcd -> ('e,d)polyrcd``; + print "OK\n"; true) + orelse die "FAILED!" + val _ = Process.exit Process.success; From c3cde98f9f9b1f156d0181752acae96189ce5c71 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 17 Nov 2015 10:01:52 +1100 Subject: [PATCH 561/718] Polish preterm API to remove unused parameter. make_qconst didn't read/use its overload_info parameter, so there seems no point having that parameter in the API. --- src/parse/Parse_support.sig | 3 +-- src/parse/Parse_support.sml | 2 +- src/parse/TermParse.sml | 2 +- 3 files changed, 3 insertions(+), 4 deletions(-) diff --git a/src/parse/Parse_support.sig b/src/parse/Parse_support.sig index 9642347dad..0b4ce9f12e 100644 --- a/src/parse/Parse_support.sig +++ b/src/parse/Parse_support.sig @@ -16,8 +16,7 @@ sig val make_aq_binding_occ : locn.locn -> term -> bvar_in_env val make_atom : overload_info -> locn.locn -> string -> preterm_in_env - val make_qconst : overload_info -> locn.locn -> string * string -> - preterm_in_env + val make_qconst : locn.locn -> string * string -> preterm_in_env val list_make_comb : locn.locn -> preterm_in_env list -> preterm_in_env val bind_term : locn.locn -> bvar_in_env list -> preterm_in_env -> preterm_in_env diff --git a/src/parse/Parse_support.sml b/src/parse/Parse_support.sml index 770241afc6..c0e770e72b 100644 --- a/src/parse/Parse_support.sml +++ b/src/parse/Parse_support.sml @@ -290,7 +290,7 @@ end (* local *) treated as visible. ---------------------------------------------------------------------------*) -fun make_qconst _ l (p as (thy,s)) E = (gen_thy_const l p, E); +fun make_qconst l (p as (thy,s)) E = (gen_thy_const l p, E); fun make_atom oinfo l s E = make_bvar l (s,E) handle HOL_ERR _ diff --git a/src/parse/TermParse.sml b/src/parse/TermParse.sml index d338e047a9..9c67a64dcc 100644 --- a/src/parse/TermParse.sml +++ b/src/parse/TermParse.sml @@ -252,7 +252,7 @@ in end | APP(l, t1, t2) => list_make_comb l (map to_ptmInEnv [t1, t2]) | IDENT (l, s) => make_atom oinfo l s - | QIDENT (l, s1, s2) => make_qconst oinfo l (s1,s2) + | QIDENT (l, s1, s2) => make_qconst l (s1,s2) | LAM(l, vs, t) => bind_term l [binder vs] (to_ptmInEnv t) | TYPED(l, t, pty) => make_constrained l (to_ptmInEnv t) pty | AQ (l, t) => make_aq l t From a16605e396892e4cb6a2af509d95e78d5c6ab118 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 17 Nov 2015 11:52:24 +1100 Subject: [PATCH 562/718] Fixes with polymorphic record literals MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 1. When you write <| fld1 := foo ; fld2 := bar |> there is secretly an ARB term hiding in the result. You don't want that ARB term to be unnecessarily polymorphic. 2. TypeBase.mk_record has to adjust for the possibility that fupds can have types of the form fupd : (α fldty -> β fldty) -> (α,γ) rcd -> (β, γ) rcd Continuing work on github issue #173 --- src/1/TypeBasePure.sml | 4 ++-- src/datatype/selftest.sml | 23 +++++++++++++++++++++-- src/parse/TermParse.sml | 29 ++++++++++++++++++++++++++++- src/parse/parse_term.sml | 2 +- 4 files changed, 52 insertions(+), 6 deletions(-) diff --git a/src/1/TypeBasePure.sml b/src/1/TypeBasePure.sml index b82f964807..c0fc647678 100644 --- a/src/1/TypeBasePure.sml +++ b/src/1/TypeBasePure.sml @@ -992,8 +992,8 @@ fun mk_record tybase (ty,fields) = then let val (Thy,Tyop) = type_names ty val fupds = map (fn p => String.concat[Tyop,"_",fst p,"_fupd"]) fields val updfns = map (fn n => prim_mk_const{Name=n,Thy=Thy}) fupds - fun ifn c = let val (_,ty') = strip_fun (type_of c) - val theta = match_type ty' ty + fun ifn c = let val (_,ty') = dom_rng (type_of c) + val theta = match_type ty' (ty --> ty) in inst theta c end val updfns' = map ifn updfns diff --git a/src/datatype/selftest.sml b/src/datatype/selftest.sml index 74a1991815..02b4885fce 100644 --- a/src/datatype/selftest.sml +++ b/src/datatype/selftest.sml @@ -1,6 +1,7 @@ (* tests for Hol_datatype *) open HolKernel Parse +open testutils val _ = Feedback.set_trace "Theory.save_thm_reporting" 0; @@ -101,6 +102,26 @@ val _ = Hol_datatype` val _ = Hol_datatype`squish_record = <|fld1:bool|>` val _ = Hol_datatype`poly_squish_record = <|fld1:'a->'b|>` + +val _ = tprint "Parse polymorphic record literal" +val r = with_flag (Globals.guessing_tyvars, false) Parse.Term + `<| fld1 := SUC |>` +val rnd = repeat rand r +val fupd_t = repeat rator r +val (args, _) = strip_fun (type_of fupd_t) +val fty = hd args +val (d,r) = dom_rng fty +val _ = if type_of rnd = ``:(num, num)poly_squish_record`` andalso + Type.compare(d,r) = EQUAL + then print "OK\n" + else die "FAILED!" +val _ = tprint "TypeBase.mk_record on polymorphic record" +val _ = + case Lib.total TypeBase.mk_record + (``:(num,num)poly_squish_record``, [("fld1", ``SUC``)]) of + NONE => die "FAILED!" + | SOME _ => print "OK\n" + val _ = Hol_datatype`K = <| F : 'a -> bool; S : num |>` val _ = Datatype.big_record_size := 10; @@ -188,8 +209,6 @@ val _ = Hol_datatype `u3 = d3 of u4 u2 u1 ; val _ = Hol_datatype `foo = fooC of 'a` val _ = Hol_datatype `foo = fooC' of num` -open testutils - val _ = tprint "Testing independence of case variables" val t = Lib.total Parse.Term `case (x:valbind) of bind p e => 3 diff --git a/src/parse/TermParse.sml b/src/parse/TermParse.sml index 9c67a64dcc..d550bfab34 100644 --- a/src/parse/TermParse.sml +++ b/src/parse/TermParse.sml @@ -248,6 +248,33 @@ in list_make_comb l [to_ptmInEnv t0, to_ptmInEnv t1, every_case do_arrow t2] end + else if String.isPrefix GrammarSpecials.recfupd_special caseform then + let + fun isARB_updchain a = + case a of + QIDENT (locn.Loc_None, "bool", "ARB") => true + | APP (l1, APP (l2, IDENT (l3, fupd), t1), r) => + String.isPrefix GrammarSpecials.recfupd_special fupd andalso + isARB_updchain r + | _ => false + open Preterm + fun getARBTy pt = + case pt of + Comb{Rand,...} => getARBTy Rand + | Const{Ty,...} => Ty + | Constrained{Ptm,Ty,...} => Ty + | _ => raise Fail "TermParse.getARBTy invariant failure" + val ptE = list_make_comb l (map to_ptmInEnv [t0, t1, t2]) + in + if isARB_updchain t2 then + (fn e => let + val (pt,e') = ptE e + val ty = getARBTy pt + in + (Constrained{Ptm = pt,Ty = ty,Locn = locn.Loc_None}, e') + end) + else ptE + end else list_make_comb l (map to_ptmInEnv [t0, t1, t2]) end | APP(l, t1, t2) => list_make_comb l (map to_ptmInEnv [t1, t2]) @@ -357,4 +384,4 @@ in end -end (* struct *) \ No newline at end of file +end (* struct *) diff --git a/src/parse/parse_term.sml b/src/parse/parse_term.sml index 9d8e300927..57e0927ac5 100644 --- a/src/parse/parse_term.sml +++ b/src/parse/parse_term.sml @@ -1527,7 +1527,7 @@ fun remove_specials t = ("Record selection must have single id to right \ \(possibly non-integer numeric literal)",#2 t2) else if s = reccons_special then - remove_recupdate (#2 t) f t2 (IDENT (locn.Loc_None,"ARB")) + remove_recupdate (#2 t) f t2 (QIDENT (locn.Loc_None,"bool", "ARB")) else if s = recwith_special then remove_recupdate' (#2 t) t2 (remove_specials f) else From dcde507a6da7b76c05cdbc5e67a9c1f2881ed144 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 17 Nov 2015 15:16:54 +1100 Subject: [PATCH 563/718] Fix proof of "bigrec" thms for polymorphic records These are the theorems that are proved to knit together the view of the record that the user expects and the underlying reality, which is a record of records. These are stated and proved after the various underlying record types are defined. Tests in src/datatype/selftest.sml This is work on github issue #173 --- src/datatype/Datatype.sml | 4 +++- src/datatype/selftest.sml | 28 +++++++++++++++++++++++++++- 2 files changed, 30 insertions(+), 2 deletions(-) diff --git a/src/datatype/Datatype.sml b/src/datatype/Datatype.sml index 8d23e6f556..3071776e3b 100644 --- a/src/datatype/Datatype.sml +++ b/src/datatype/Datatype.sml @@ -716,9 +716,11 @@ fun prove_bigrec_theorems tyinfos ss (tyname, fldlist) = let fun mk_literal base values = let fun foldthis (upd, value, acc) = let val ty = type_of value + val theta = match_type (#1 (dom_rng (type_of upd))) (ty --> ty) + val upd' = inst theta upd val K = Term.inst [alpha |-> ty, beta |-> ty] combinSyntax.K_tm in - list_mk_comb(upd, [mk_comb(K, value), acc]) + list_mk_comb(upd', [mk_comb(K, value), acc]) end in ListPair.foldr foldthis base (fupdates, values) diff --git a/src/datatype/selftest.sml b/src/datatype/selftest.sml index 02b4885fce..30c43423f2 100644 --- a/src/datatype/selftest.sml +++ b/src/datatype/selftest.sml @@ -241,6 +241,10 @@ val _ = Hol_datatype` polyrcd = <| pfld1 : 'a ms ; pfld2 : 'b -> bool ; pfld3 : num|> `; +val _ = Datatype.Datatype` + polyrcd2 = <| p2fld1 : 'a ms ; p2fld2 : 'a # 'b -> bool ; p2fld3 : num |> +` + val _ = List.app pptest [("field selection", ``r.fld2``, "r.fld2"), ("field sel. for fn type", ``r.fld1 x``, "r.fld1 x"), @@ -316,8 +320,30 @@ val _ = print "OK\n" val _ = tprint "Records with polymorphic fields 1" val _ = (``polyrcd_pfld1_fupd : - ('c ms -> 'e ms) -> ('c,'d) polyrcd -> ('e,d)polyrcd``; + ('c ms -> 'e ms) -> ('c,'d) polyrcd -> ('e,'d)polyrcd``; print "OK\n"; true) orelse die "FAILED!" +val _ = tprint "Records with polymorphic fields 2" +val _ = (``polyrcd2_p2fld1_fupd : + ('a ms -> 'a ms) -> ('a,'b) polyrcd2 -> ('a,'b)polyrcd2``; + print "OK\n"; true) + orelse die "FAILED!" + +val _ = tprint "Records with polymorphic fields 3" +val _ = (``polyrcd2_p2fld2_fupd : + (('a # 'b -> bool) -> ('a # 'c -> bool)) -> + ('a,'b) polyrcd2 -> ('a,'c)polyrcd2``; + print "OK\n"; true) + orelse die "FAILED!" + +val _ = tprint "Records with polymorphic fields 4" +val _ = + case Lib.total (trace("show_typecheck_errors", 0) Parse.Term) + `polyrcd2_p2fld1_fupd : + ('a ms -> 'b ms) -> ('a,'c) polyrcd2 -> ('b,'c)polyrcd2` + of + NONE => print "OK\n" + | _ => die "FAILED!"; + val _ = Process.exit Process.success; From 9ca8abc51f0b35924382686397c211c80efe70a7 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 17 Nov 2015 15:18:01 +1100 Subject: [PATCH 564/718] Get EmitML to handle polymorphic records correctly Tests in src/emit/theory_tests. Closes github issue #173 --- src/emit/EmitML.sml | 29 +++++++++++++++++----- src/emit/theory_tests/emitrecordScript.sml | 9 +++++++ 2 files changed, 32 insertions(+), 6 deletions(-) diff --git a/src/emit/EmitML.sml b/src/emit/EmitML.sml index 649c139f36..4747e20726 100644 --- a/src/emit/EmitML.sml +++ b/src/emit/EmitML.sml @@ -894,11 +894,23 @@ fun diag vlist flist = tl fun gen_updates ty fields = let open pairSyntax val {Tyop,Thy,Args} = dest_thy_type ty - fun mk_upd_const (fname,fty) = - mk_thy_const{Name=Tyop^"_"^fname^"_fupd",Thy=Thy, - Ty = (fty --> fty) --> ty --> ty} + fun mk_upd_const (fname,_) = + let + val rpty = Pretype.fromType ty + fun gv() = Pretype.UVar (ref NONE) + val op -=> = Pretype.mk_fun_ty infix -=> + val upd_pty = gv() -=> (rpty -=> gv()) + val ln = locn.Loc_None + val qid = Absyn.QIDENT(ln, Thy, Tyop^"_"^fname^"_fupd") + val ptm0 = Parse.absyn_to_preterm qid + val ptm = Preterm.Constrained{Locn = ln, Ptm = ptm0, Ty = upd_pty} + val _ = with_flag (Globals.guessing_tyvars, true) + (Preterm.typecheck_phase1 NONE) ptm + in + Preterm.to_term ptm + end val upds = map mk_upd_const fields - val fns = map (fn (_,ty) => mk_var ("f", ty--> ty)) fields + val fns = map (fn upd_t => mk_var ("f", #1(dom_rng (type_of upd_t)))) upds val fake_tyc = mk_record_vconstr(Tyop,list_mk_fun(map snd fields, ty)) val vars = itlist (fn (n,(_,ty)) => fn acc => @@ -907,8 +919,13 @@ fun gen_updates ty fields = val pat = list_mk_comb(fake_tyc,vars) val lefts = map2 (fn upd => fn f => list_mk_comb(upd,[f,pat])) upds fns val diags = diag vars (map (curry mk_comb) fns) - val rights = map (curry list_mk_comb fake_tyc) diags - val eqns = rev(map2 (curry mk_eq) lefts rights) + fun mapthis (l, d) = let + val rtys = map type_of d + val rtyc = mk_record_vconstr(Tyop, list_mk_fun(rtys, type_of l)) + in + mk_eq(l, list_mk_comb(rtyc, d)) + end + val eqns = ListPair.map mapthis (lefts, diags) val mk_thm = mk_oracle_thm "EmitML fake thm" in map (curry mk_thm []) eqns diff --git a/src/emit/theory_tests/emitrecordScript.sml b/src/emit/theory_tests/emitrecordScript.sml index 530c201758..6df21ba8e4 100644 --- a/src/emit/theory_tests/emitrecordScript.sml +++ b/src/emit/theory_tests/emitrecordScript.sml @@ -10,12 +10,21 @@ val _ = Datatype fooq val literal_def = Define`literal m = <| n := m ; b := T |>`; +val polyrcdq = `prcd = <| m : num ; s : 'a # bool |>` +val _ = Datatype polyrcdq + +val prcdf_def = Define` + prcdf (g : 'a -> 'b) r = r with s updated_by (\ (a,b). (g a, ~b)) +`; + val accessor_def = Define`accessor x = x.n + 1`; val _ = eSML "emitRecordTest" [OPEN ["num"], MLSIG "type num = numML.num", DATATYPE fooq, + DATATYPE polyrcdq, + DEFN prcdf_def, DEFN literal_def, DEFN accessor_def] From ea8d1b7b76e9e27dae16055b45adf19e137eff8b Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 17 Nov 2015 15:29:36 +1100 Subject: [PATCH 565/718] Record polyrcd update work in release notes Related to issue #173 --- doc/kananaskis-11.release.md | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/doc/kananaskis-11.release.md b/doc/kananaskis-11.release.md index bd3b942985..1ee361c924 100644 --- a/doc/kananaskis-11.release.md +++ b/doc/kananaskis-11.release.md @@ -34,6 +34,25 @@ New features: This shortcuts the current idiom, which requires the tactic to be highlighted manually, and then applied *via* `M-h e`. (The advantage of the latter is that one can select specific tactic sequences to be applied all at once.) +- Record updates can now be more polymorphic. For example, if one defined + + Datatype`rcd = <| myset : α -> bool ; size : num |>` + + one used to get back an update constant for the `myset` field: + + rcd_myset_fupd : ((α -> bool) -> (α -> bool)) -> α rcd -> α rcd + + Now, the same constant is + + rcd_myset_fupd : ((α -> bool) -> (β -> bool)) -> α rcd -> β rcd + + One might use this to define + + Define`img (f:α->β) r = r with myset updated_by IMAGE f` + + This definition would have previously been rejected. ([Github issue](https://github.com/HOL-Theorem-Prover/HOL/issues/173)) + + Bugs fixed: ----------- From 2e0240f45db8c72446647cafd8270dd9d36ac869 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 17 Nov 2015 16:09:57 +1100 Subject: [PATCH 566/718] Restore old chapter about tactics in DESCRIPTION I want to tidy this up and have it help address github issue #273, which is to document and encourage use of modern tactics. --- Manual/Description/description.bib | 2 +- Manual/Description/description.tex | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Manual/Description/description.bib b/Manual/Description/description.bib index df383b0b85..671eedbf54 100644 --- a/Manual/Description/description.bib +++ b/Manual/Description/description.bib @@ -325,7 +325,7 @@ @Book{new-LCF-man @TechReport{Stefan, author = {S. Soko\l owski}, - title = {A note on tactics in \LCF}, + title = {A Note on Tactics in {\LCF}}, institution = {University of {E}dinburgh Department of Computer Science}, year = {1983}, OPTkey = {}, diff --git a/Manual/Description/description.tex b/Manual/Description/description.tex index f324fe6a82..62249e05ab 100644 --- a/Manual/Description/description.tex +++ b/Manual/Description/description.tex @@ -82,6 +82,7 @@ \include{system} % embedding HOL logic in ML \include{drules} % derived rules + \include{tactics} % tactics \include{theories} \include{definitions} \include{libraries} @@ -96,7 +97,6 @@ % \include{syntax} % \include{conv} % conversions -% \include{tactics} % tactics % \include{see} % --------------------------------------------------------------------- From a5579a1ac7eaf95b133fbb5b0f57f47137f92881 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 17 Nov 2015 16:13:31 +1100 Subject: [PATCH 567/718] Get trailing-wspace deletion to look at more files Now it also looks in .bib and .doc files --- developers/delete-trailing-ws | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/developers/delete-trailing-ws b/developers/delete-trailing-ws index cebd5b9d3c..7b93e13dfd 100755 --- a/developers/delete-trailing-ws +++ b/developers/delete-trailing-ws @@ -21,7 +21,7 @@ then exit 1 fi -find "$1" \( -name '*.sml' -o -name '*.sig' -o -name '*.tex' -o -name '*.ML' -o -name '*.lem' \) \ +find "$1" \( -name '*.sml' -o -name '*.sig' -o -name '*.tex' -o -name '*.ML' -o -name '*.lem' -o -name '*.bib' -o -name '*.doc' \) \ \! -name '*ML.sml' \! -name '*Theory.sml' \! -name '*Theory.sig' \ -exec perl -e "while (<>) { if (/$wspace_re/) { exit 0; }}; exit 1" \{\} \; \ "${trailingcommand[@]}" From 5cef4bb81049cfa952a39f3ee3c5cbc7e232ad85 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 17 Nov 2015 16:13:58 +1100 Subject: [PATCH 568/718] Delete trailing whitespace in description.bib --- Manual/Description/description.bib | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/Manual/Description/description.bib b/Manual/Description/description.bib index 671eedbf54..101e770651 100644 --- a/Manual/Description/description.bib +++ b/Manual/Description/description.bib @@ -386,11 +386,11 @@ @incollection{Amarel editor = "Donald Michie", publisher = "Edinburgh University Press", year = "1971"} - + @inproceedings{CoudertBerthetMadre, editor = "J. Sifakis", author = "Olivier Coudert and Christian Berthet and Jean Christophe Madre", - title = "Verification of synchronous sequential machines + title = "Verification of synchronous sequential machines based on symbolic execution", booktitle = "Automatic Verification Methods for Finite State Systems", year = 1989, @@ -561,7 +561,7 @@ @incollection{JoyceSeger volume = "780", series = {Lecture Notes in Computer Science} } - + @misc{HenrikNotes, author = "Henrik Reif Andersen", title = "{An Introduction to Binary Decision Diagrams}", @@ -573,7 +573,7 @@ @misc{HenrikNotes Available from: {\url{http://www.it.dtu.dk/~hra}}" } - + @misc{PaulsonMiniscoping, key = "Paulson", note = {Larry Paulson, private communication.} @@ -680,7 +680,7 @@ @article{Milner-types @incollection{BoyerMooreLinearArith, author = "R. S. Boyer and J Moore", - title = "Integrating Decision Procedures into Heuristic Theorem Provers: + title = "Integrating Decision Procedures into Heuristic Theorem Provers: A Case Study of Linear Arithmetic", pages = "83-124", booktitle = "Machine Intelligence 11", @@ -720,7 +720,7 @@ @techreport{boulton92b @techreport{mjcg99a, author = {Mike Gordon}, - title = {Programming combinations of deduction and {BDD}-based + title = {Programming combinations of deduction and {BDD}-based symbolic calculation }, institution = {University of Cambridge Computer Laboratory}, year = {1999}, @@ -730,7 +730,7 @@ @techreport{mjcg99a @techreport{GordonLarsen, author = {Mike Gordon and Ken Friis Larsen}, - title = {Combining the {Hol98} Proof Assistant with + title = {Combining the {Hol98} Proof Assistant with the {BuDDy} {BDD} package}, institution = {University of Cambridge Computer Laboratory}, year = {1999}, @@ -804,8 +804,8 @@ @InProceedings{Gordon:TPHOLs2000 @misc{Amjad:TPHOLs2001, Author = "Hasan Amjad", title = "{BDD} Representation Judgements in {HOL}: A Performance Evaluation", - note = "Category B paper presented at the - {\it 14th International Conference on Theorem Proving and Higher Order Logics\/}. + note = "Category B paper presented at the + {\it 14th International Conference on Theorem Proving and Higher Order Logics\/}. Edinburgh, Scotland, UK, August 2001. Available from \url{http://www.cl.cam.ac.uk/~ha227/}", } From e7f4d74ae2a60ed3d9c0afcff0d5497299786056 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 17 Nov 2015 16:18:39 +1100 Subject: [PATCH 569/718] Move lcsymtacs functions to natural homes For example, we do not need to have >> in lcsymtacs; it might as be in Tactical. The ultimate aim is to do away with lcsymtacs entirely. This is work towards github issue #274 --- src/1/Abbrev.sig | 5 ++++- src/1/Tactical.sig | 17 +++++++++-------- src/1/Tactical.sml | 8 ++++++-- src/boss/lcsymtacs.sml | 10 +++++----- 4 files changed, 24 insertions(+), 16 deletions(-) diff --git a/src/1/Abbrev.sig b/src/1/Abbrev.sig index 4fce1dae32..7c902f31df 100644 --- a/src/1/Abbrev.sig +++ b/src/1/Abbrev.sig @@ -8,8 +8,11 @@ sig type goal = term list * term type validation = thm list -> thm type tactic = goal -> goal list * validation - type list_validation = thm list -> thm list + type list_validation = thm list -> thm list type list_tactic = goal list -> goal list * list_validation + type ('a,'b) gentactic = 'a -> goal list * (thm list -> 'b) + (* ['a |-> goal, 'b -> thm] gives tactic; + ['a |-> goal list, 'b -> thm list] gives list_tactic *) type thm_tactic = thm -> tactic type thm_tactical = thm_tactic -> thm_tactic type ppstream = Portable.ppstream diff --git a/src/1/Tactical.sig b/src/1/Tactical.sig index f6674f02ea..aca43023ee 100644 --- a/src/1/Tactical.sig +++ b/src/1/Tactical.sig @@ -5,14 +5,14 @@ sig val TAC_PROOF : goal * tactic -> thm val prove : term * tactic -> thm val store_thm : string * term * tactic -> thm - val THEN : ('a -> goal list * (thm list -> 'b)) * tactic -> - 'a -> goal list * (thm list -> 'b) + val THEN : ('a,'b) gentactic * tactic -> ('a,'b) gentactic + val >> : ('a,'b) gentactic * tactic -> ('a,'b) gentactic (* could be used as val THEN : tactic * tactic -> tactic val THEN : list_tactic * tactic -> list_tactic *) - val THENL : ('a -> goal list * (thm list -> 'b)) * tactic list -> - 'a -> goal list * (thm list -> 'b) + val THENL : ('a,'b) gentactic * tactic list -> ('a,'b) gentactic + val >| : ('a,'b) gentactic * tactic list -> ('a,'b) gentactic (* could be used as val THENL : tactic * tactic list -> tactic val THENL : list_tactic * tactic list -> list_tactic @@ -20,8 +20,9 @@ sig val ORELSE : tactic * tactic -> tactic val ORELSE_LT : list_tactic * list_tactic -> list_tactic val THEN1 : tactic * tactic -> tactic - val THEN_LT : ('a -> goal list * (thm list -> 'b)) * list_tactic -> - 'a -> goal list * (thm list -> 'b) + val >- : tactic * tactic -> tactic + val THEN_LT : ('a,'b) gentactic * list_tactic -> ('a,'b) gentactic + val >>> : ('a,'b) gentactic * list_tactic -> ('a,'b) gentactic (* could be used as val THEN_LT : tactic * list_tactic -> tactic val THEN_LT : list_tactic * list_tactic -> list_tactic @@ -51,8 +52,8 @@ sig val VALID_LT : list_tactic -> list_tactic val VALIDATE : tactic -> tactic val VALIDATE_LT : list_tactic -> list_tactic - val GEN_VALIDATE : bool -> tactic -> tactic - val GEN_VALIDATE_LT : bool -> list_tactic -> list_tactic + val GEN_VALIDATE : bool -> tactic -> tactic + val GEN_VALIDATE_LT: bool -> list_tactic -> list_tactic val ADD_SGS_TAC : term list -> tactic -> tactic val EVERY : tactic list -> tactic val EVERY_LT : list_tactic list -> list_tactic diff --git a/src/1/Tactical.sml b/src/1/Tactical.sml index cac095df8f..d9f59179a1 100644 --- a/src/1/Tactical.sml +++ b/src/1/Tactical.sml @@ -75,8 +75,6 @@ fun store_thm (name, tm, tac) = (print ("Failed to prove theorem " ^ name ^ ".\n"); Raise e) -infix THEN THENL THEN1 ORELSE ORELSE_LT THEN_LT - (*--------------------------------------------------------------------------- * tac1 THEN_LT ltac2: * A tactical that applies ltac2 to the list of subgoals resulting from tac1 @@ -91,6 +89,8 @@ fun op THEN_LT (tac1, ltac2 : list_tactic) = (gl2, vf1 o vf2) end +val op >>> = op THEN_LT + (* first argument can be a tactic or a list-tactic *) val _ = op THEN_LT : tactic * list_tactic -> tactic ; val _ = op THEN_LT : list_tactic * list_tactic -> list_tactic ; @@ -131,6 +131,7 @@ fun ALLGOALS tac2 gl = *---------------------------------------------------------------------------*) fun tac1 THEN tac2 = tac1 THEN_LT ALLGOALS tac2 ; +val op >> = op THEN (* first argument can be a tactic or a list-tactic *) val _ = op THEN : tactic * tactic -> tactic ; @@ -188,6 +189,7 @@ fun NULL_OK_LT ltac [] = ([], Lib.I) *---------------------------------------------------------------------------*) fun tac1 THENL tacs2 = tac1 THEN_LT NULL_OK_LT (TACS_TO_LT tacs2) ; +val op >| = op THENL (* first argument can be a tactic or a list-tactic *) val _ = op THENL : tactic * tactic list -> tactic ; @@ -217,6 +219,8 @@ fun op THEN1 (tac1: tactic, tac2: tactic) : tactic = (t_gl, fn thl => jf (h_jf [] :: thl)) end +val op >- = op THEN1 + (*--------------------------------------------------------------------------- * NTH_GOAL tac n: A list_tactic that applies tac to the nth goal (counting goals from 1) diff --git a/src/boss/lcsymtacs.sml b/src/boss/lcsymtacs.sml index 8e251f19e9..3112b3f5bf 100644 --- a/src/boss/lcsymtacs.sml +++ b/src/boss/lcsymtacs.sml @@ -111,10 +111,10 @@ struct val fs = fsrw_tac [] val rfs = rfsrw_tac [] - val op>> = op Tactical.THEN - val op\\ = op Tactical.THEN - val op>- = op Tactical.THEN1 - val op>| = op Tactical.THENL - val op>>> = op Tactical.THEN_LT + val op>> = op Tactical.>> + val op\\ = op Tactical.>> + val op>- = op Tactical.>- + val op>| = op Tactical.>| + val op>>> = op Tactical.>>> end From 8f6d778428321e0acded942474409ab84427f732 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 17 Nov 2015 16:22:26 +1100 Subject: [PATCH 570/718] Delete trailing whitespace in help/Docfiles --- help/Docfiles/BasicProvers.RW_TAC.doc | 2 +- .../Docfiles/Cond_rewrite.COND_REWR_CANON.doc | 2 +- help/Docfiles/Cond_rewrite.COND_REWR_CONV.doc | 4 +- .../ConseqConv.CHANGED_CONSEQ_CONV.doc | 4 +- help/Docfiles/ConseqConv.CONSEQ_CONV_TAC.doc | 2 +- .../ConseqConv.CONSEQ_CONV_direction.doc | 2 +- .../ConseqConv.CONSEQ_REWRITE_CONV.doc | 10 +-- .../ConseqConv.CONSEQ_TOP_REWRITE_CONV.doc | 14 ++-- .../Docfiles/ConseqConv.DEPTH_CONSEQ_CONV.doc | 8 +-- ...onseqConv.DEPTH_STRENGTHEN_CONSEQ_CONV.doc | 2 +- .../ConseqConv.EXISTS_EQ___CONSEQ_CONV.doc | 2 +- .../ConseqConv.FORALL_EQ___CONSEQ_CONV.doc | 2 +- .../ConseqConv.NUM_DEPTH_CONSEQ_CONV.doc | 2 +- .../ConseqConv.ONCE_DEPTH_CONSEQ_CONV.doc | 2 +- help/Docfiles/ConseqConv.THEN_CONSEQ_CONV.doc | 4 +- help/Docfiles/Conv.ABS_CONV.doc | 2 +- help/Docfiles/Conv.AC_CONV.doc | 4 +- help/Docfiles/Conv.AND_EXISTS_CONV.doc | 2 +- help/Docfiles/Conv.BINDER_CONV.doc | 4 +- help/Docfiles/Conv.BINOP_CONV.doc | 2 +- help/Docfiles/Conv.DEPTH_CONV.doc | 4 +- help/Docfiles/Conv.QUANT_CONV.doc | 2 +- help/Docfiles/Conv.REWR_CONV.doc | 8 +-- help/Docfiles/Conv.REWR_CONV_A.doc | 8 +-- help/Docfiles/Conv.STRIP_BINDER_CONV.doc | 12 ++-- help/Docfiles/Conv.STRIP_QUANT_CONV.doc | 10 +-- help/Docfiles/DB.apropos.doc | 2 +- help/Docfiles/DB.apropos_in.doc | 4 +- help/Docfiles/DB.axioms.doc | 4 +- help/Docfiles/DB.class.doc | 4 +- help/Docfiles/DB.data.doc | 6 +- help/Docfiles/DB.definitions.doc | 2 +- help/Docfiles/DB.fetch.doc | 2 +- help/Docfiles/DB.find_in.doc | 4 +- help/Docfiles/DB.match.doc | 6 +- help/Docfiles/DB.matcher.doc | 6 +- help/Docfiles/DB.matches.doc | 2 +- help/Docfiles/DB.matchp.doc | 4 +- help/Docfiles/DB.theorems.doc | 4 +- help/Docfiles/DB.thy.doc | 6 +- help/Docfiles/Definition.new_definition.doc | 4 +- .../Docfiles/Definition.new_specification.doc | 12 ++-- help/Docfiles/Defn.tgoal.doc | 8 +-- help/Docfiles/Drule.ASSUME_CONJS.doc | 2 +- help/Docfiles/Drule.BODY_CONJUNCTS.doc | 2 +- help/Docfiles/Drule.CONJ_LIST.doc | 4 +- help/Docfiles/Drule.EXISTS_LEFT.doc | 8 +-- help/Docfiles/Drule.EXISTS_LEFT1.doc | 6 +- help/Docfiles/Drule.GEN_ALPHA_CONV.doc | 8 +-- help/Docfiles/Drule.IMP_ANTISYM_RULE.doc | 2 +- help/Docfiles/Drule.INST_TT_HYPS.doc | 2 +- help/Docfiles/Drule.INST_TY_TERM.doc | 2 +- help/Docfiles/Drule.Ntimes.doc | 16 ++--- help/Docfiles/Drule.RIGHT_ETA.doc | 2 +- help/Docfiles/Drule.SPEC_UNDISCH_EXL.doc | 2 +- help/Docfiles/Drule.SUBST_CONV.doc | 6 +- help/Docfiles/Drule.SUBS_OCCS.doc | 2 +- help/Docfiles/Drule.UNDISCH_TM.doc | 4 +- help/Docfiles/EmitTeX.non_type_theorems.doc | 4 +- help/Docfiles/EmitTeX.print_term_as_tex.doc | 2 +- .../Docfiles/EmitTeX.print_theorem_as_tex.doc | 2 +- help/Docfiles/EmitTeX.print_type_as_tex.doc | 2 +- help/Docfiles/Feedback.MESG_to_string.doc | 4 +- help/Docfiles/Feedback.Raise.doc | 4 +- help/Docfiles/Feedback.WARNING_to_string.doc | 6 +- help/Docfiles/Feedback.doc | 2 +- help/Docfiles/Feedback.fail.doc | 2 +- help/Docfiles/Feedback.failwith.doc | 2 +- help/Docfiles/Globals.priming.doc | 4 +- help/Docfiles/HolKernel.subst_occs.doc | 4 +- help/Docfiles/HolSatLib.SAT_PROVE.doc | 6 +- help/Docfiles/IndDefRules.doc | 2 +- help/Docfiles/Lib.append.doc | 2 +- help/Docfiles/Lib.assert.doc | 2 +- help/Docfiles/Lib.assert_exn.doc | 2 +- help/Docfiles/Lib.assoc.doc | 6 +- help/Docfiles/Lib.assoc1.doc | 2 +- help/Docfiles/Lib.can.doc | 2 +- help/Docfiles/Lib.combine.doc | 2 +- help/Docfiles/Lib.delta.doc | 4 +- help/Docfiles/Lib.delta_apply.doc | 8 +-- help/Docfiles/Lib.delta_map.doc | 2 +- help/Docfiles/Lib.delta_pair.doc | 8 +-- help/Docfiles/Lib.doc | 2 +- help/Docfiles/Lib.end_time.doc | 10 +-- help/Docfiles/Lib.exists.doc | 2 +- help/Docfiles/Lib.for_se.doc | 2 +- help/Docfiles/Lib.hash.doc | 4 +- help/Docfiles/Lib.index.doc | 4 +- help/Docfiles/Lib.int_sort.doc | 2 +- help/Docfiles/Lib.istream.doc | 4 +- help/Docfiles/Lib.itlist2.doc | 4 +- help/Docfiles/Lib.map2.doc | 2 +- help/Docfiles/Lib.mapfilter.doc | 2 +- help/Docfiles/Lib.mk_istream.doc | 4 +- help/Docfiles/Lib.mlquote.doc | 4 +- help/Docfiles/Lib.next.doc | 2 +- help/Docfiles/Lib.partial.doc | 2 +- help/Docfiles/Lib.partition.doc | 4 +- help/Docfiles/Lib.pluck.doc | 2 +- help/Docfiles/Lib.quote.doc | 2 +- help/Docfiles/Lib.repeat.doc | 4 +- help/Docfiles/Lib.rev_assoc.doc | 6 +- help/Docfiles/Lib.sort.doc | 6 +- help/Docfiles/Lib.split_after.doc | 2 +- help/Docfiles/Lib.start_time.doc | 2 +- help/Docfiles/Lib.subst.doc | 4 +- help/Docfiles/Lib.topsort.doc | 6 +- help/Docfiles/Lib.total.doc | 4 +- help/Docfiles/Lib.try.doc | 10 +-- help/Docfiles/Lib.trye.doc | 4 +- help/Docfiles/Lib.trypluck.doc | 2 +- help/Docfiles/Lib.trypluckprime.doc | 2 +- help/Docfiles/Lib.with_exn.doc | 16 ++--- help/Docfiles/Lib.with_flag.doc | 6 +- help/Docfiles/PairRules.FILTER_PSTRIP_TAC.doc | 2 +- help/Docfiles/PairRules.GEN_PALPHA_CONV.doc | 2 +- help/Docfiles/PairRules.HALF_MK_PABS.doc | 2 +- .../PairRules.LEFT_AND_PEXISTS_CONV.doc | 2 +- help/Docfiles/PairRules.LEFT_LIST_PBETA.doc | 2 +- .../PairRules.LEFT_OR_PEXISTS_CONV.doc | 2 +- help/Docfiles/PairRules.PALPHA.doc | 6 +- help/Docfiles/PairRules.PALPHA_CONV.doc | 10 +-- help/Docfiles/PairRules.PBETA_CONV.doc | 8 +-- help/Docfiles/PairRules.PCHOOSE_TAC.doc | 2 +- help/Docfiles/PairRules.PEXISTENCE.doc | 2 +- help/Docfiles/PairRules.PEXISTS.doc | 2 +- help/Docfiles/PairRules.PEXISTS_AND_CONV.doc | 4 +- help/Docfiles/PairRules.PEXISTS_IMP.doc | 2 +- help/Docfiles/PairRules.PEXISTS_TAC.doc | 2 +- .../PairRules.PEXISTS_UNIQUE_CONV.doc | 2 +- help/Docfiles/PairRules.PFORALL_OR_CONV.doc | 2 +- help/Docfiles/PairRules.PSELECT_EQ.doc | 4 +- help/Docfiles/PairRules.PSKOLEM_CONV.doc | 2 +- help/Docfiles/PairRules.PSPEC.doc | 2 +- help/Docfiles/PairRules.PSPEC_TAC.doc | 4 +- help/Docfiles/PairRules.PSTRIP_GOAL_THEN.doc | 2 +- help/Docfiles/PairRules.PSTRIP_TAC.doc | 2 +- help/Docfiles/PairRules.PSTRIP_THM_THEN.doc | 4 +- help/Docfiles/PairRules.PSUB_CONV.doc | 2 +- help/Docfiles/PairRules.P_FUN_EQ_CONV.doc | 4 +- help/Docfiles/PairRules.P_PCHOOSE_TAC.doc | 6 +- help/Docfiles/PairRules.P_PCHOOSE_THEN.doc | 4 +- help/Docfiles/PairRules.P_PSKOLEM_CONV.doc | 2 +- .../PairRules.RIGHT_AND_PFORALL_CONV.doc | 2 +- .../PairRules.RIGHT_IMP_PEXISTS_CONV.doc | 2 +- help/Docfiles/PairRules.RIGHT_LIST_PBETA.doc | 2 +- .../PairRules.RIGHT_OR_PEXISTS_CONV.doc | 2 +- help/Docfiles/PairRules.RIGHT_PBETA.doc | 2 +- help/Docfiles/PairRules.UNCURRY_CONV.doc | 2 +- .../PairedLambda.PAIRED_BETA_CONV.doc | 8 +-- help/Docfiles/Parse.Absyn.doc | 2 +- help/Docfiles/Parse.ty_antiq.doc | 8 +-- .../Prim_rec.new_recursive_definition.doc | 6 +- .../Docfiles/Rewrite.ONCE_ASM_REWRITE_TAC.doc | 2 +- help/Docfiles/Rewrite.PURE_REWRITE_TAC.doc | 4 +- help/Docfiles/Rewrite.REWRITE_CONV.doc | 2 +- help/Docfiles/Rewrite.bool_rewrites.doc | 4 +- help/Docfiles/Rewrite.implicit_rewrites.doc | 8 +-- help/Docfiles/Tactic.ASM_CASES_TAC.doc | 2 +- help/Docfiles/Tactic.ASSUME_TAC.doc | 2 +- help/Docfiles/Tactic.CCONTR_TAC.doc | 2 +- help/Docfiles/Tactic.MK_COMB_TAC.doc | 2 +- help/Docfiles/Tactic.NTAC.doc | 4 +- help/Docfiles/Tactic.STRIP_TAC.doc | 2 +- help/Docfiles/Tactic.SUBST_OCCS_TAC.doc | 6 +- help/Docfiles/Tactic.WEAKEN_TAC.doc | 6 +- help/Docfiles/Tactic.irule.doc | 2 +- help/Docfiles/Tactic.prim_irule.doc | 6 +- help/Docfiles/Tactical.ADD_SGS_TAC.doc | 20 +++--- help/Docfiles/Tactical.ALLGOALS.doc | 6 +- help/Docfiles/Tactical.ALL_LT.doc | 4 +- help/Docfiles/Tactical.ALL_TAC.doc | 2 +- help/Docfiles/Tactical.GEN_VALIDATE.doc | 16 ++--- help/Docfiles/Tactical.GEN_VALIDATE_LT.doc | 6 +- help/Docfiles/Tactical.HEADGOAL.doc | 4 +- help/Docfiles/Tactical.LASTGOAL.doc | 4 +- help/Docfiles/Tactical.NTH_GOAL.doc | 4 +- help/Docfiles/Tactical.NULL_OK_LT.doc | 4 +- help/Docfiles/Tactical.POP_ASSUM.doc | 2 +- help/Docfiles/Tactical.PRED_ASSUM.doc | 6 +- help/Docfiles/Tactical.REVERSE_LT.doc | 2 +- help/Docfiles/Tactical.ROTATE_LT.doc | 6 +- help/Docfiles/Tactical.SPLIT_LT.doc | 8 +-- help/Docfiles/Tactical.TACS_TO_LT.doc | 6 +- help/Docfiles/Tactical.THEN_LT.doc | 14 ++-- help/Docfiles/Tactical.TRYALL.doc | 2 +- help/Docfiles/Tactical.USE_SG_THEN.doc | 14 ++-- help/Docfiles/Tactical.VALIDATE.doc | 22 +++---- help/Docfiles/Tactical.VALIDATE_LT.doc | 18 ++--- help/Docfiles/Tactical.VALID_LT.doc | 6 +- help/Docfiles/Tactical.store_thm.doc | 2 +- help/Docfiles/Tag.read.doc | 2 +- help/Docfiles/Tag.tag.doc | 6 +- help/Docfiles/Term.beta_conv.doc | 8 +-- help/Docfiles/Term.body.doc | 2 +- help/Docfiles/Term.bvar.doc | 2 +- help/Docfiles/Term.decls.doc | 2 +- help/Docfiles/Term.dest_const.doc | 6 +- help/Docfiles/Term.dest_thy_const.doc | 2 +- help/Docfiles/Term.dest_var.doc | 2 +- help/Docfiles/Term.empty_varset.doc | 2 +- help/Docfiles/Term.eta_conv.doc | 10 +-- help/Docfiles/Term.genvar.doc | 4 +- help/Docfiles/Term.is_comb.doc | 2 +- help/Docfiles/Term.list_mk_abs.doc | 2 +- help/Docfiles/Term.list_mk_binder.doc | 16 ++--- help/Docfiles/Term.list_mk_comb.doc | 2 +- help/Docfiles/Term.match_term.doc | 6 +- help/Docfiles/Term.match_terml.doc | 20 +++--- help/Docfiles/Term.mk_const.doc | 8 +-- help/Docfiles/Term.mk_thy_const.doc | 6 +- help/Docfiles/Term.mk_var.doc | 2 +- help/Docfiles/Term.norm_subst.doc | 14 ++-- help/Docfiles/Term.prim_mk_const.doc | 6 +- help/Docfiles/Term.rand.doc | 2 +- help/Docfiles/Term.rator.doc | 2 +- help/Docfiles/Term.rename_bvar.doc | 2 +- help/Docfiles/Term.same_const.doc | 4 +- help/Docfiles/Term.strip_abs.doc | 2 +- help/Docfiles/Term.strip_binder.doc | 8 +-- help/Docfiles/Term.subst.doc | 8 +-- help/Docfiles/Term.term.doc | 4 +- help/Docfiles/Term.var_compare.doc | 4 +- help/Docfiles/Theory.ancestry.doc | 4 +- help/Docfiles/Theory.axioms.doc | 4 +- help/Docfiles/Theory.constants.doc | 4 +- help/Docfiles/Theory.current_axioms.doc | 4 +- help/Docfiles/Theory.current_definitions.doc | 12 ++-- help/Docfiles/Theory.current_theorems.doc | 6 +- help/Docfiles/Theory.current_theory.doc | 20 +++--- help/Docfiles/Theory.delete_binding.doc | 4 +- help/Docfiles/Theory.delete_const.doc | 12 ++-- help/Docfiles/Theory.delete_type.doc | 10 +-- help/Docfiles/Theory.export_theory.doc | 28 ++++---- help/Docfiles/Theory.new_axiom.doc | 8 +-- help/Docfiles/Theory.new_constant.doc | 14 ++-- help/Docfiles/Theory.new_type.doc | 4 +- help/Docfiles/Theory.parents.doc | 2 +- help/Docfiles/Theory.save_thm.doc | 18 ++--- help/Docfiles/Theory.scrub.doc | 18 ++--- help/Docfiles/Theory.set_MLname.doc | 16 ++--- help/Docfiles/Theory.types.doc | 8 +-- help/Docfiles/Theory.uptodate_thm.doc | 12 ++-- help/Docfiles/Theory.uptodate_type.doc | 6 +- help/Docfiles/Thm.Beta.doc | 2 +- help/Docfiles/Thm.GEN.doc | 2 +- help/Docfiles/Thm.INST.doc | 8 +-- help/Docfiles/Thm.INST_TYPE.doc | 4 +- help/Docfiles/Thm.SUBST.doc | 8 +-- help/Docfiles/Thm.Specialize.doc | 2 +- help/Docfiles/Thm.TRANS.doc | 4 +- help/Docfiles/Thm.hyp.doc | 2 +- help/Docfiles/Thm.mk_thm.doc | 2 +- help/Docfiles/Thm.tag.doc | 2 +- help/Docfiles/Thm.thm.doc | 6 +- help/Docfiles/Thm_cont.IMP_RES_THEN.doc | 6 +- help/Docfiles/Thm_cont.X_CASES_THEN.doc | 2 +- help/Docfiles/TotalDefn.DefineSchema.doc | 12 ++-- help/Docfiles/Type.arrow.doc | 2 +- help/Docfiles/Type.dest_thy_type.doc | 8 +-- help/Docfiles/Type.dest_type.doc | 2 +- help/Docfiles/Type.gen_tyvar.doc | 6 +- help/Docfiles/Type.ind.doc | 2 +- help/Docfiles/Type.match_type.doc | 4 +- help/Docfiles/Type.mk_thy_type.doc | 10 +-- help/Docfiles/Type.mk_type.doc | 6 +- help/Docfiles/Type.op_arity.doc | 2 +- help/Docfiles/Type.polymorphic.doc | 2 +- help/Docfiles/Type.raw_match_type.doc | 12 ++-- help/Docfiles/Type.type_varsl.doc | 4 +- help/Docfiles/boolSimps.bool_ss.doc | 2 +- help/Docfiles/boolSyntax.dest_arb.doc | 2 +- help/Docfiles/boolSyntax.dest_bool_case.doc | 2 +- help/Docfiles/boolSyntax.dest_cond.doc | 2 +- help/Docfiles/boolSyntax.dest_eq_ty.doc | 2 +- help/Docfiles/boolSyntax.dest_imp.doc | 2 +- help/Docfiles/boolSyntax.dest_imp_only.doc | 2 +- help/Docfiles/boolSyntax.dest_neg.doc | 2 +- help/Docfiles/boolSyntax.is_bool_case.doc | 2 +- help/Docfiles/boolSyntax.is_cond.doc | 2 +- help/Docfiles/boolSyntax.is_exists.doc | 2 +- help/Docfiles/boolSyntax.is_exists1.doc | 2 +- help/Docfiles/boolSyntax.is_imp.doc | 4 +- help/Docfiles/boolSyntax.is_imp_only.doc | 2 +- help/Docfiles/boolSyntax.mk_arb.doc | 2 +- help/Docfiles/boolSyntax.mk_bool_case.doc | 2 +- help/Docfiles/boolSyntax.mk_disj.doc | 2 +- help/Docfiles/boolSyntax.mk_exists.doc | 2 +- help/Docfiles/boolSyntax.mk_exists1.doc | 2 +- help/Docfiles/boolSyntax.mk_forall.doc | 2 +- help/Docfiles/boolSyntax.mk_imp.doc | 2 +- help/Docfiles/boolSyntax.mk_let.doc | 6 +- help/Docfiles/boolSyntax.mk_select.doc | 2 +- help/Docfiles/boolSyntax.new_binder.doc | 6 +- .../boolSyntax.new_binder_definition.doc | 4 +- .../boolSyntax.new_infixl_definition.doc | 2 +- help/Docfiles/boolSyntax.strip_abs.doc | 2 +- help/Docfiles/boolSyntax.strip_comb.doc | 2 +- help/Docfiles/boolSyntax.strip_fun.doc | 2 +- help/Docfiles/boolSyntax.strip_imp.doc | 2 +- help/Docfiles/boolSyntax.strip_imp_only.doc | 2 +- help/Docfiles/bossLib.ASM_SIMP_TAC.doc | 4 +- help/Docfiles/bossLib.Cases.doc | 8 +-- help/Docfiles/bossLib.Cases_on.doc | 6 +- help/Docfiles/bossLib.DECIDE.doc | 6 +- help/Docfiles/bossLib.Define.doc | 24 +++---- help/Docfiles/bossLib.EVAL.doc | 4 +- help/Docfiles/bossLib.EVAL_RULE.doc | 4 +- help/Docfiles/bossLib.EVAL_TAC.doc | 10 +-- help/Docfiles/bossLib.FULL_SIMP_TAC.doc | 2 +- help/Docfiles/bossLib.Hol_defn.doc | 36 +++++----- help/Docfiles/bossLib.Induct.doc | 22 +++---- help/Docfiles/bossLib.Induct_on.doc | 8 +-- help/Docfiles/bossLib.PROVE.doc | 14 ++-- help/Docfiles/bossLib.PROVE_TAC.doc | 10 +-- help/Docfiles/bossLib.RW_TAC.doc | 10 +-- help/Docfiles/bossLib.SIMP_RULE.doc | 2 +- help/Docfiles/bossLib.SIMP_TAC.doc | 12 ++-- help/Docfiles/bossLib.SPOSE_NOT_THEN.doc | 6 +- help/Docfiles/bossLib.amper2.doc | 8 +-- help/Docfiles/bossLib.arith_ss.doc | 42 ++++++------ help/Docfiles/bossLib.bool_ss.doc | 42 ++++++------ help/Docfiles/bossLib.completeInduct_on.doc | 6 +- help/Docfiles/bossLib.measureInduct_on.doc | 4 +- help/Docfiles/bossLib.recInduct.doc | 4 +- help/Docfiles/bossLib.std_ss.doc | 32 ++++----- help/Docfiles/bossLib.tDefine.doc | 28 ++++---- help/Docfiles/bossLib.type_rws.doc | 4 +- help/Docfiles/bossLib.xDefine.doc | 10 +-- help/Docfiles/computeLib.CBV_CONV.doc | 6 +- help/Docfiles/computeLib.RESTR_EVAL_CONV.doc | 4 +- help/Docfiles/computeLib.RESTR_EVAL_RULE.doc | 2 +- help/Docfiles/computeLib.RESTR_EVAL_TAC.doc | 2 +- help/Docfiles/computeLib.bool_compset.doc | 4 +- help/Docfiles/computeLib.monitoring.doc | 2 +- help/Docfiles/fcpLib.FCP_ss.doc | 2 +- help/Docfiles/hol88Lib.assoc.doc | 2 +- help/Docfiles/hol88Lib.rev_assoc.doc | 2 +- help/Docfiles/holCheckLib.empty_model.doc | 4 +- help/Docfiles/holCheckLib.get_flag_abs.doc | 4 +- help/Docfiles/holCheckLib.get_flag_ric.doc | 2 +- help/Docfiles/holCheckLib.get_init.doc | 2 +- help/Docfiles/holCheckLib.get_name.doc | 2 +- help/Docfiles/holCheckLib.get_props.doc | 2 +- help/Docfiles/holCheckLib.get_results.doc | 8 +-- help/Docfiles/holCheckLib.get_state.doc | 2 +- help/Docfiles/holCheckLib.get_trans.doc | 2 +- help/Docfiles/holCheckLib.get_vord.doc | 2 +- help/Docfiles/holCheckLib.holCheck.doc | 22 +++---- help/Docfiles/holCheckLib.mk_state.doc | 2 +- help/Docfiles/holCheckLib.prove_model.doc | 4 +- help/Docfiles/holCheckLib.set_flag_abs.doc | 4 +- help/Docfiles/holCheckLib.set_flag_ric.doc | 4 +- help/Docfiles/holCheckLib.set_init.doc | 12 ++-- help/Docfiles/holCheckLib.set_name.doc | 4 +- help/Docfiles/holCheckLib.set_props.doc | 10 +-- help/Docfiles/holCheckLib.set_state.doc | 4 +- help/Docfiles/holCheckLib.set_trans.doc | 10 +-- help/Docfiles/holCheckLib.set_vord.doc | 4 +- help/Docfiles/holyHammer.hh.doc | 6 +- help/Docfiles/listLib.BUTFIRSTN_CONV.doc | 2 +- help/Docfiles/listLib.BUTLASTN_CONV.doc | 2 +- help/Docfiles/listLib.ELL_CONV.doc | 2 +- help/Docfiles/listLib.EL_CONV.doc | 2 +- .../Docfiles/listLib.EQ_LENGTH_INDUCT_TAC.doc | 8 +-- .../listLib.EQ_LENGTH_SNOC_INDUCT_TAC.doc | 8 +-- help/Docfiles/listLib.FIRSTN_CONV.doc | 2 +- help/Docfiles/listLib.IS_EL_CONV.doc | 2 +- help/Docfiles/listLib.LASTN_CONV.doc | 2 +- help/Docfiles/listLib.LIST_CONV.doc | 54 +++++++-------- help/Docfiles/listLib.MAP2_CONV.doc | 16 ++--- help/Docfiles/listLib.MAP_CONV.doc | 14 ++-- help/Docfiles/listLib.OR_EL_CONV.doc | 2 +- help/Docfiles/listLib.PURE_LIST_CONV.doc | 66 +++++++++---------- help/Docfiles/listLib.SCANL_CONV.doc | 4 +- help/Docfiles/listLib.SCANR_CONV.doc | 4 +- help/Docfiles/listLib.SNOC_INDUCT_TAC.doc | 2 +- help/Docfiles/listLib.X_LIST_CONV.doc | 52 +++++++-------- help/Docfiles/listLib.list_FOLD_CONV.doc | 2 +- help/Docfiles/listLib.list_thm_database.doc | 2 +- .../listLib.set_list_thm_database.doc | 2 +- help/Docfiles/listSyntax.mk_list.doc | 2 +- help/Docfiles/numLib.REDUCE_CONV.doc | 8 +-- help/Docfiles/numSyntax.dest_numeral.doc | 4 +- help/Docfiles/numSyntax.is_numeral.doc | 4 +- help/Docfiles/numSyntax.mk_numeral.doc | 4 +- help/Docfiles/pairSyntax.dest_anylet.doc | 8 +-- help/Docfiles/pairSyntax.genvarstruct.doc | 4 +- help/Docfiles/pairSyntax.list_mk_anylet.doc | 26 ++++---- help/Docfiles/pairSyntax.list_mk_pabs.doc | 2 +- help/Docfiles/pairSyntax.mk_anylet.doc | 14 ++-- help/Docfiles/pairSyntax.mk_pabs.doc | 2 +- help/Docfiles/pairSyntax.pvariant.doc | 2 +- help/Docfiles/pairSyntax.strip_anylet.doc | 16 ++--- help/Docfiles/pred_setLib.DELETE_CONV.doc | 14 ++-- help/Docfiles/pred_setLib.FINITE_CONV.doc | 2 +- help/Docfiles/pred_setLib.IMAGE_CONV.doc | 10 +-- help/Docfiles/pred_setLib.INSERT_CONV.doc | 12 ++-- help/Docfiles/pred_setLib.IN_CONV.doc | 12 ++-- help/Docfiles/pred_setLib.SET_SPEC_CONV.doc | 2 +- help/Docfiles/pred_setLib.UNION_CONV.doc | 6 +- help/Docfiles/proofManagerLib.backup.doc | 12 ++-- help/Docfiles/proofManagerLib.eall.doc | 2 +- help/Docfiles/proofManagerLib.elt.doc | 2 +- help/Docfiles/proofManagerLib.enth.doc | 2 +- help/Docfiles/proofManagerLib.eta.doc | 2 +- help/Docfiles/proofManagerLib.expand.doc | 22 +++---- help/Docfiles/proofManagerLib.expand_list.doc | 14 ++-- .../Docfiles/proofManagerLib.expand_listf.doc | 2 +- help/Docfiles/proofManagerLib.flatn.doc | 8 +-- help/Docfiles/proofManagerLib.set_backup.doc | 18 ++--- help/Docfiles/proofManagerLib.set_goal.doc | 2 +- ...euristicsLib.ASM_QUANT_INSTANTIATE_TAC.doc | 2 +- ...ntHeuristicsLib.QUANT_INSTANTIATE_CONV.doc | 10 +-- .../Docfiles/quantHeuristicsLib.QUANT_TAC.doc | 12 ++-- .../res_quanLib.IMP_RES_FORALL_CONV.doc | 2 +- .../res_quanLib.RESQ_REWRITE1_TAC.doc | 2 +- help/Docfiles/res_quanLib.dest_res_exists.doc | 2 +- .../res_quanLib.dest_res_exists_unique.doc | 2 +- help/Docfiles/res_quanLib.dest_res_forall.doc | 2 +- help/Docfiles/res_quanLib.dest_res_select.doc | 2 +- help/Docfiles/res_quanLib.is_res_exists.doc | 2 +- .../res_quanLib.is_res_exists_unique.doc | 2 +- help/Docfiles/res_quanLib.is_res_forall.doc | 2 +- .../res_quanLib.list_mk_res_exists.doc | 2 +- .../res_quanLib.list_mk_res_forall.doc | 2 +- .../res_quanTools.IMP_RES_FORALL_CONV.doc | 2 +- help/Docfiles/res_quanTools.RESQ_GEN_TAC.doc | 2 +- .../res_quanTools.RESQ_IMP_RES_TAC.doc | 2 +- help/Docfiles/res_quanTools.RESQ_MATCH_MP.doc | 2 +- help/Docfiles/res_quanTools.RESQ_RES_TAC.doc | 2 +- .../res_quanTools.RESQ_REWRITE1_TAC.doc | 2 +- help/Docfiles/res_quanTools.RESQ_SPECL.doc | 2 +- .../res_quanTools.dest_res_exists.doc | 2 +- .../res_quanTools.dest_res_forall.doc | 2 +- .../res_quanTools.dest_res_select.doc | 2 +- help/Docfiles/res_quanTools.is_res_exists.doc | 2 +- help/Docfiles/res_quanTools.is_res_forall.doc | 2 +- .../res_quanTools.list_mk_res_exists.doc | 2 +- .../res_quanTools.list_mk_res_forall.doc | 2 +- help/Docfiles/simpLib.SIMP_PROVE.doc | 2 +- help/Docfiles/unwindLib.PRUNE_ONCE_CONV.doc | 2 +- help/Docfiles/unwindLib.PRUNE_ONE_CONV.doc | 2 +- help/Docfiles/wordsLib.WORD_DP.doc | 2 +- 445 files changed, 1253 insertions(+), 1253 deletions(-) diff --git a/help/Docfiles/BasicProvers.RW_TAC.doc b/help/Docfiles/BasicProvers.RW_TAC.doc index 89b65780cd..73727f0144 100644 --- a/help/Docfiles/BasicProvers.RW_TAC.doc +++ b/help/Docfiles/BasicProvers.RW_TAC.doc @@ -3,7 +3,7 @@ \TYPE {RW_TAC : simpset -> thm list -> tactic} \SYNOPSIS -Simplification with case-splitting and built-in knowledge of +Simplification with case-splitting and built-in knowledge of declared datatypes. \DESCRIBE diff --git a/help/Docfiles/Cond_rewrite.COND_REWR_CANON.doc b/help/Docfiles/Cond_rewrite.COND_REWR_CANON.doc index 2865861080..397e5c4f99 100644 --- a/help/Docfiles/Cond_rewrite.COND_REWR_CANON.doc +++ b/help/Docfiles/Cond_rewrite.COND_REWR_CANON.doc @@ -22,7 +22,7 @@ variable capture, and have all antecedents which are a conjunction transformed to implications. The output theorem will be in the following form { - !x1 ... xn y1 ... ym z1 ... zk. + !x1 ... xn y1 ... ym z1 ... zk. P11[xi] ==> ... ==> P1p[xi] ==> ... ==> Pr1[xi,yi] ==> ... ==> Prq[x1,yi] ==> (u[xi,yi,zi] = v[xi,yi,zi]) } diff --git a/help/Docfiles/Cond_rewrite.COND_REWR_CONV.doc b/help/Docfiles/Cond_rewrite.COND_REWR_CONV.doc index 84d326fed2..4f516c0699 100644 --- a/help/Docfiles/Cond_rewrite.COND_REWR_CONV.doc +++ b/help/Docfiles/Cond_rewrite.COND_REWR_CONV.doc @@ -15,7 +15,7 @@ conversion, rewriting, conditional. {COND_REWR_CONV} is one of the basic building blocks for the implementation of the simple conditional rewriting conversions in the HOL system. In particular, the conditional term replacement or -rewriting done by all the conditional +rewriting done by all the conditional rewriting conversions in this library is ultimately done by applications of {COND_REWR_CONV}. The description given here for {COND_REWR_CONV} may therefore be taken as a specification of the atomic action of @@ -34,7 +34,7 @@ implicative theorem in the following form: } where {x1}, ..., {xn} are all the variables that occur free in the left hand side of the conclusion of the theorem but do not occur free in the -assumptions. +assumptions. The last argument to {COND_REWR_CONV} is the term to be rewritten. diff --git a/help/Docfiles/ConseqConv.CHANGED_CONSEQ_CONV.doc b/help/Docfiles/ConseqConv.CHANGED_CONSEQ_CONV.doc index 538c410b2a..ab99d558e8 100644 --- a/help/Docfiles/ConseqConv.CHANGED_CONSEQ_CONV.doc +++ b/help/Docfiles/ConseqConv.CHANGED_CONSEQ_CONV.doc @@ -5,9 +5,9 @@ \SYNOPSIS Makes a consequence conversion fail if applying it leaves a term unchanged. -\DESCRIBE +\DESCRIBE If {c} is a consequence conversion that maps a term {``t``} -to a theorem {|- t = t'}, {|- t' ==> t} or {|- t ==> t'}, +to a theorem {|- t = t'}, {|- t' ==> t} or {|- t ==> t'}, where {t'} is alpha-equivalent to {t}, or if {c} raises the {UNCHANGED} exception when applied to {``t``}, then {CHANGED_CONSEQ_CONV c} fails when applied to the term diff --git a/help/Docfiles/ConseqConv.CONSEQ_CONV_TAC.doc b/help/Docfiles/ConseqConv.CONSEQ_CONV_TAC.doc index 8c7213a26f..bac0cc5d19 100644 --- a/help/Docfiles/ConseqConv.CONSEQ_CONV_TAC.doc +++ b/help/Docfiles/ConseqConv.CONSEQ_CONV_TAC.doc @@ -3,7 +3,7 @@ \TYPE {CONSEQ_CONV_TAC : directed_conseq_conv -> tactic} \SYNOPSIS -Reduces the goal using a consequence conversion. +Reduces the goal using a consequence conversion. \DESCRIBE {CONSEQ_CONV_TAC c} tries to strengthen a goal {P} using diff --git a/help/Docfiles/ConseqConv.CONSEQ_CONV_direction.doc b/help/Docfiles/ConseqConv.CONSEQ_CONV_direction.doc index be7b5493fd..a9d72cdcec 100644 --- a/help/Docfiles/ConseqConv.CONSEQ_CONV_direction.doc +++ b/help/Docfiles/ConseqConv.CONSEQ_CONV_direction.doc @@ -15,7 +15,7 @@ a directed consequence conversion {DCONSEQ_CONV} should be of the form - t ==> wt for dir = CONSEQ_CONV_WEAKEN_direction - st ==> t, t ==> wt or t = eqt for dir = CONSEQ_CONV_UNKNOWN_direction } - + \SEEALSO ConseqConv.directed_conseq_conv, ConseqConv.TRUE_FALSE_REFL_CONSEQ_CONV \ENDDOC diff --git a/help/Docfiles/ConseqConv.CONSEQ_REWRITE_CONV.doc b/help/Docfiles/ConseqConv.CONSEQ_REWRITE_CONV.doc index 02b54b4142..ebf8b2d4d0 100644 --- a/help/Docfiles/ConseqConv.CONSEQ_REWRITE_CONV.doc +++ b/help/Docfiles/ConseqConv.CONSEQ_REWRITE_CONV.doc @@ -5,7 +5,7 @@ \SYNOPSIS Applies {CONSEQ_TOP_REWRITE_CONV} repeatedly at subterms. -\DESCRIBE +\DESCRIBE This directed consequence conversion is a combination of {CONSEQ_TOP_REWRITE_CONV} and {DEPTH_CONSEQ_CONV}. Given lists of theorems, these theorems are preprocessed to @@ -17,16 +17,16 @@ Reconsider the example for {DEPTH_CONSEQ_CONV}. Let {rewrite_every_thm} be the following theorem: { val rewrite_every_thm = - |- FEVERY P FEMPTY /\ + |- FEVERY P FEMPTY /\ (FEVERY P f /\ P (x,y) ==> FEVERY P (f |+ (x,y))); } Then the following call of {CONSEQ_REWRITE_CONV} { - CONSEQ_REWRITE_CONV ([], [rewrite_every_thm], []) CONSEQ_CONV_STRENGTHEN_direction + CONSEQ_REWRITE_CONV ([], [rewrite_every_thm], []) CONSEQ_CONV_STRENGTHEN_direction ``!y2. FEVERY P (f |+ (x1, y1) |+ (x2,y2)) /\ Q z`` } results in -{ +{ |- (!y2. ((FEVERY P f /\ P (x1, y1)) /\ P (x2,y2)) /\ Q z) ==> (!y2. FEVERY P (f |+ (x1, y1) |+ (x2,y2)) /\ Q z) } @@ -34,6 +34,6 @@ results in More examples can be found at the end of {ConseqConv.sml}. \SEEALSO -Drule.MATCH_MP, ConseqConv.CONSEQ_TOP_REWRITE_CONV, ConseqConv.DEPTH_CONSEQ_CONV, +Drule.MATCH_MP, ConseqConv.CONSEQ_TOP_REWRITE_CONV, ConseqConv.DEPTH_CONSEQ_CONV, ConseqConv.EXT_CONSEQ_REWRITE_CONV. \ENDDOC diff --git a/help/Docfiles/ConseqConv.CONSEQ_TOP_REWRITE_CONV.doc b/help/Docfiles/ConseqConv.CONSEQ_TOP_REWRITE_CONV.doc index 552a1ca104..198db467c8 100644 --- a/help/Docfiles/ConseqConv.CONSEQ_TOP_REWRITE_CONV.doc +++ b/help/Docfiles/ConseqConv.CONSEQ_TOP_REWRITE_CONV.doc @@ -3,12 +3,12 @@ \TYPE {CONSEQ_TOP_REWRITE_CONV : (thm list * thm list * thm list) -> directed_conseq_conv} \SYNOPSIS -An extended version of {MATCH_MP}. +An extended version of {MATCH_MP}. -\DESCRIBE +\DESCRIBE This consequence conversion gets 3 lists of theorems as parameters: {both_thmL}, {strengthen_thmL} and {weaken_thmL}. -The theorems in these lists are used to strengthen or weaken a given +The theorems in these lists are used to strengthen or weaken a given boolean term at toplevel. If using them for strengthening this consequence conversion behaves similar to MATCH_MP. As the names suggest, the theorems in {strengthen_thmL} are used for strengthening, the ones in @@ -16,15 +16,15 @@ theorems in {strengthen_thmL} are used for strengthening, the ones in Before trying to apply the conversion, the theorem lists are preprocessed. The theorems are split along conjunctions and -allquantification is removed. Then theorems with toplevel negation +allquantification is removed. Then theorems with toplevel negation {|- ~P} are rewritten to {|- P = F}. Afterwards every theorem {|- P} that -is not an implication or an boolean equation is replaced by +is not an implication or an boolean equation is replaced by {|- P = T}. Finally, boolean equations {|- P = Q} are splitted into two theorems {|- P ==> Q} and {|- Q ==> P}. One ends up with a list of implications. -Given a term {t} the conversion tries -to find a theorem {|- P ==> Q} and - depending on to the direction - +Given a term {t} the conversion tries +to find a theorem {|- P ==> Q} and - depending on to the direction - strengthen {t} by matching it with {Q} or weaken it by matching it with {P}. diff --git a/help/Docfiles/ConseqConv.DEPTH_CONSEQ_CONV.doc b/help/Docfiles/ConseqConv.DEPTH_CONSEQ_CONV.doc index 4615537db0..c88294e2d8 100644 --- a/help/Docfiles/ConseqConv.DEPTH_CONSEQ_CONV.doc +++ b/help/Docfiles/ConseqConv.DEPTH_CONSEQ_CONV.doc @@ -18,11 +18,11 @@ Notice that some operators switch the direction that is passed to {c}, e.g. to strengthen a term {~t}, {DEPTH_CONSEQ_CONV} tries to weaken {t}. -\EXAMPLE -Consider the expression {FEVERY P (f |+ (x1, y1) |+ (x2,y2))}. -It states that all elements of the finite map +\EXAMPLE +Consider the expression {FEVERY P (f |+ (x1, y1) |+ (x2,y2))}. +It states that all elements of the finite map {f |+ (x1, y1) |+ (x2, y2)} satisfy the predicate {P}. However, the definition of {x1} and -{x2} possible hide definitions of these keys inside {f} or in case {x1 = x2} +{x2} possible hide definitions of these keys inside {f} or in case {x1 = x2} the middle update is void. You easily get into a lot of aliasing problems while proving thus a statement. However, the following theorem holds: { diff --git a/help/Docfiles/ConseqConv.DEPTH_STRENGTHEN_CONSEQ_CONV.doc b/help/Docfiles/ConseqConv.DEPTH_STRENGTHEN_CONSEQ_CONV.doc index 4138b3eb8f..777b5a46a0 100644 --- a/help/Docfiles/ConseqConv.DEPTH_STRENGTHEN_CONSEQ_CONV.doc +++ b/help/Docfiles/ConseqConv.DEPTH_STRENGTHEN_CONSEQ_CONV.doc @@ -10,7 +10,7 @@ order. \DESCRIBE {DEPTH_STRENGTHEN_CONSEQ_CONV c} is defined as {DEPTH_CONSEQ_CONV (K c) CONSEQ_CONV_STRENGTHEN_direction}. So, -its just a slightly simplified interface to {DEPTH_CONSEQ_CONV}, +its just a slightly simplified interface to {DEPTH_CONSEQ_CONV}, that tries to strengthen all the time and that does not require the conversion to know about directions. diff --git a/help/Docfiles/ConseqConv.EXISTS_EQ___CONSEQ_CONV.doc b/help/Docfiles/ConseqConv.EXISTS_EQ___CONSEQ_CONV.doc index 0890afa43d..793a81fe4b 100644 --- a/help/Docfiles/ConseqConv.EXISTS_EQ___CONSEQ_CONV.doc +++ b/help/Docfiles/ConseqConv.EXISTS_EQ___CONSEQ_CONV.doc @@ -4,7 +4,7 @@ \SYNOPSIS -Given a term of the form {(?x. P x) = (?x. Q x)} this consequence +Given a term of the form {(?x. P x) = (?x. Q x)} this consequence conversion returns the theorem {|- (!x. (P x = Q x)) ==> ((?x. P x) = (?x. Q x))}. diff --git a/help/Docfiles/ConseqConv.FORALL_EQ___CONSEQ_CONV.doc b/help/Docfiles/ConseqConv.FORALL_EQ___CONSEQ_CONV.doc index 4f7ecad1f4..afd55edebe 100644 --- a/help/Docfiles/ConseqConv.FORALL_EQ___CONSEQ_CONV.doc +++ b/help/Docfiles/ConseqConv.FORALL_EQ___CONSEQ_CONV.doc @@ -3,7 +3,7 @@ \TYPE {FORALL_EQ___CONSEQ_CONV : conseq_conv} \SYNOPSIS -Given a term of the form {(!x. P x) = (!x. Q x)} this consequence +Given a term of the form {(!x. P x) = (!x. Q x)} this consequence conversion returns the theorem {|- (!x. (P x = Q x)) ==> ((!x. P x) = (!x. Q x))}. diff --git a/help/Docfiles/ConseqConv.NUM_DEPTH_CONSEQ_CONV.doc b/help/Docfiles/ConseqConv.NUM_DEPTH_CONSEQ_CONV.doc index fad954a0e8..0ce2b56fc6 100644 --- a/help/Docfiles/ConseqConv.NUM_DEPTH_CONSEQ_CONV.doc +++ b/help/Docfiles/ConseqConv.NUM_DEPTH_CONSEQ_CONV.doc @@ -8,7 +8,7 @@ Applies a consequence conversion at most a given number of times to the sub-terms of a term, in bottom-up order. \DESCRIBE -While {DEPTH_CONSEQ_CONV c tm} applies {c} repeatedly, +While {DEPTH_CONSEQ_CONV c tm} applies {c} repeatedly, {NUM_DEPTH_CONSEQ_CONV c n tm} applies it at most n-times. \SEEALSO diff --git a/help/Docfiles/ConseqConv.ONCE_DEPTH_CONSEQ_CONV.doc b/help/Docfiles/ConseqConv.ONCE_DEPTH_CONSEQ_CONV.doc index 1f398ea8ba..ddaf8d125b 100644 --- a/help/Docfiles/ConseqConv.ONCE_DEPTH_CONSEQ_CONV.doc +++ b/help/Docfiles/ConseqConv.ONCE_DEPTH_CONSEQ_CONV.doc @@ -7,7 +7,7 @@ Applies a consequence conversion at most once to a sub-terms of a term. \DESCRIBE -While {DEPTH_CONSEQ_CONV c tm} applies {c} repeatedly, +While {DEPTH_CONSEQ_CONV c tm} applies {c} repeatedly, {ONCE_DEPTH_CONSEQ_CONV c tm} applies {c} at most once. \SEEALSO diff --git a/help/Docfiles/ConseqConv.THEN_CONSEQ_CONV.doc b/help/Docfiles/ConseqConv.THEN_CONSEQ_CONV.doc index 9e304f569f..aa03405693 100644 --- a/help/Docfiles/ConseqConv.THEN_CONSEQ_CONV.doc +++ b/help/Docfiles/ConseqConv.THEN_CONSEQ_CONV.doc @@ -8,10 +8,10 @@ Applies two consequence conversions in sequence. \DESCRIBE {THEN_CONSEQ_CONV cc1 cc2} corresponds to {c1 THENC c2} for classical conversions. Thus, if {cc1} returns {|- t' ==> t} when applied to {t}, and {cc2} returns {|- t'' ==> t'} when applied to -{t'}, then {(THEN_CONSEQ_CONV cc1 cc2) t} returns {|- t'' ==> t}. +{t'}, then {(THEN_CONSEQ_CONV cc1 cc2) t} returns {|- t'' ==> t}. {THEN_CONSEQ_CONV} can handle weakening as well: If {cc1} returns {|- t ==> t'} when applied to {t}, and {cc2} returns {|- t' ==> t''} -when applied to {t'}, then {(THEN_CONSEQ_CONV cc1 cc2) t} returns +when applied to {t'}, then {(THEN_CONSEQ_CONV cc1 cc2) t} returns {|- t ==> t''}. Finally, if {cc1} returns {|- t = t'} when applied to {t}, and {cc2} returns {|- t' = t''} when applied to {t'}, then {(THEN_CONSEQ_CONV cc1 cc2) t} returns {|- t = t''}. If one of the diff --git a/help/Docfiles/Conv.ABS_CONV.doc b/help/Docfiles/Conv.ABS_CONV.doc index 4c8a01ceb7..71356de560 100644 --- a/help/Docfiles/Conv.ABS_CONV.doc +++ b/help/Docfiles/Conv.ABS_CONV.doc @@ -33,7 +33,7 @@ function returned by {ABS_CONV c} may also fail if the ML function \SEEALSO -Conv.RAND_CONV, Conv.RATOR_CONV, Conv.SUB_CONV, +Conv.RAND_CONV, Conv.RATOR_CONV, Conv.SUB_CONV, Conv.BINDER_CONV, Conv.QUANT_CONV, Conv.STRIP_BINDER_CONV, Conv.STRIP_QUANT_CONV. diff --git a/help/Docfiles/Conv.AC_CONV.doc b/help/Docfiles/Conv.AC_CONV.doc index 9fbd6730b8..2fd600faea 100644 --- a/help/Docfiles/Conv.AC_CONV.doc +++ b/help/Docfiles/Conv.AC_CONV.doc @@ -9,7 +9,7 @@ Proves equality of terms using associative and commutative laws. conversion,associative, commutative. \DESCRIBE -Suppose {_} is a function, which is assumed to be infix in the following +Suppose {_} is a function, which is assumed to be infix in the following syntax, and {ath} and {cth} are theorems expressing its associativity and commutativity; they must be of the following form, except that any free variables may have arbitrary names and may be universally quantified: @@ -32,7 +32,7 @@ Consider the terms {x + SUC t + ((3 + y) + z)} and {3 + SUC t + x + y + z}. - AC_CONV(ADD_ASSOC,ADD_SYM) (Term `x + (SUC t) + ((3 + y) + z) = 3 + (SUC t) + x + y + z`); - > val it = + > val it = |- (x + ((SUC t) + ((3 + y) + z)) = 3 + ((SUC t) + (x + (y + z)))) = T } diff --git a/help/Docfiles/Conv.AND_EXISTS_CONV.doc b/help/Docfiles/Conv.AND_EXISTS_CONV.doc index 0decb8cf75..d9c6fef6f5 100644 --- a/help/Docfiles/Conv.AND_EXISTS_CONV.doc +++ b/help/Docfiles/Conv.AND_EXISTS_CONV.doc @@ -23,7 +23,7 @@ in which the variable {x} is free in either {P} or {Q}. \COMMENTS It may be easier to use higher order rewriting with some of -{BOTH_EXISTS_AND_THM}, {LEFT_EXISTS_AND_THM}, and +{BOTH_EXISTS_AND_THM}, {LEFT_EXISTS_AND_THM}, and {RIGHT_EXISTS_AND_THM}. diff --git a/help/Docfiles/Conv.BINDER_CONV.doc b/help/Docfiles/Conv.BINDER_CONV.doc index 68a544b5f3..451505487f 100644 --- a/help/Docfiles/Conv.BINDER_CONV.doc +++ b/help/Docfiles/Conv.BINDER_CONV.doc @@ -23,8 +23,8 @@ If {conv N} fails, or if {v} is free in {A}. } \COMMENTS -For deeply nested quantifiers, {STRIP_BINDER_CONV} and -{STRIP_QUANT_CONV} are more efficient than iterated application of +For deeply nested quantifiers, {STRIP_BINDER_CONV} and +{STRIP_QUANT_CONV} are more efficient than iterated application of {BINDER_CONV}, {BINDER_CONV}, or {ABS_CONV}. \SEEALSO diff --git a/help/Docfiles/Conv.BINOP_CONV.doc b/help/Docfiles/Conv.BINOP_CONV.doc index 755563d31d..584014d849 100644 --- a/help/Docfiles/Conv.BINOP_CONV.doc +++ b/help/Docfiles/Conv.BINOP_CONV.doc @@ -36,6 +36,6 @@ when applied to those arguments. (The latter case would imply that \SEEALSO -Conv.FORK_CONV, Conv.LAND_CONV, Conv.RAND_CONV, Conv.RATOR_CONV, +Conv.FORK_CONV, Conv.LAND_CONV, Conv.RAND_CONV, Conv.RATOR_CONV, numLib.REDUCE_CONV. \ENDDOC diff --git a/help/Docfiles/Conv.DEPTH_CONV.doc b/help/Docfiles/Conv.DEPTH_CONV.doc index 4bf58b70e1..94efa4b924 100644 --- a/help/Docfiles/Conv.DEPTH_CONV.doc +++ b/help/Docfiles/Conv.DEPTH_CONV.doc @@ -39,8 +39,8 @@ contain subterms to which the supplied conversion applies. For example, in: > val it = |- (\f x. (f x) + 1)(\y. y)2 = ((\y. y)2) + 1 : thm } the right-hand side of the result still contains a beta-redex, -because the redex {(\y.y)2} is introduced by virtue of an application of -{BETA_CONV} higher-up in the structure of the input term. By contrast, +because the redex {(\y.y)2} is introduced by virtue of an application of +{BETA_CONV} higher-up in the structure of the input term. By contrast, in the example: { - DEPTH_CONV BETA_CONV (Term `(\f x. (f x)) (\y.y) 2`); diff --git a/help/Docfiles/Conv.QUANT_CONV.doc b/help/Docfiles/Conv.QUANT_CONV.doc index 4783c0587d..45cb94d6b0 100644 --- a/help/Docfiles/Conv.QUANT_CONV.doc +++ b/help/Docfiles/Conv.QUANT_CONV.doc @@ -23,7 +23,7 @@ If {conv N} fails, or if {v} is free in {A}. \COMMENTS For deeply nested quantifiers, {STRIP_QUANT_CONV} and {STRIP_BINDER_CONV} -are more efficient than iterated application of {QUANT_CONV}, {BINDER_CONV}, +are more efficient than iterated application of {QUANT_CONV}, {BINDER_CONV}, or {ABS_CONV}. \SEEALSO diff --git a/help/Docfiles/Conv.REWR_CONV.doc b/help/Docfiles/Conv.REWR_CONV.doc index cd5ac002d7..054e465295 100644 --- a/help/Docfiles/Conv.REWR_CONV.doc +++ b/help/Docfiles/Conv.REWR_CONV.doc @@ -117,7 +117,7 @@ and {REWR_CONV EQ_SYM_EQ} behaves as follows: > val it = |- (1 = 2) = (2 = 1) : thm - REWR_CONV EQ_SYM_EQ (Term `1 < 2`); - ! Uncaught exception: + ! Uncaught exception: ! HOL_ERR } The second application fails because the left-hand side {x = y} of @@ -127,17 +127,17 @@ In the following example, one might expect the result to be the theorem {A |- f 2 = 2}, where {A} is the assumption of the supplied rewrite rule: { - REWR_CONV (ASSUME (Term `!x:'a. f x = x`)) (Term `f 2:num`); - ! Uncaught exception: + ! Uncaught exception: ! HOL_ERR } The application fails, however, because the type variable -{'a} appears in the assumption of the theorem returned by +{'a} appears in the assumption of the theorem returned by {ASSUME (Term `!x:'a. f x = x`)}. Failure will also occur in situations like: { - REWR_CONV (ASSUME (Term `f (n:num) = n`)) (Term `f 2:num`); - ! Uncaught exception: + ! Uncaught exception: ! HOL_ERR } where the left-hand side of the supplied equation contains a free diff --git a/help/Docfiles/Conv.REWR_CONV_A.doc b/help/Docfiles/Conv.REWR_CONV_A.doc index ccc00b2bf2..958634ba65 100644 --- a/help/Docfiles/Conv.REWR_CONV_A.doc +++ b/help/Docfiles/Conv.REWR_CONV_A.doc @@ -9,16 +9,16 @@ Uses an instance of a given equation to rewrite a term. conversion. \DESCRIBE -{REWR_CONV_A th} behaves as +{REWR_CONV_A th} behaves as {REWR_CONV th} except that it allows substitution of variables or type variables which appear in the hypotheses of {th}. \EXAMPLE -Consider the theorem {th} +Consider the theorem {th} { [0 < n] |- (a * n = b * (n : int)) <=> (a = b) } -and the term {tm} +and the term {tm} { f (a * m = b * (m : int)) x } @@ -36,6 +36,6 @@ gives the two subgoals: } \SEEALSO -Conv.REWR_CONV, Rewrite.REWRITE_CONV, +Conv.REWR_CONV, Rewrite.REWRITE_CONV, Conv.DEPTH_CONV, Tactic.CONV_TAC, Tactical.VALIDATE. \ENDDOC diff --git a/help/Docfiles/Conv.STRIP_BINDER_CONV.doc b/help/Docfiles/Conv.STRIP_BINDER_CONV.doc index 4ea0821a37..cd40e8eee5 100644 --- a/help/Docfiles/Conv.STRIP_BINDER_CONV.doc +++ b/help/Docfiles/Conv.STRIP_BINDER_CONV.doc @@ -9,14 +9,14 @@ Applies a conversion underneath a binder prefix. conversion, binder. \DESCRIBE -If the application of {conv} to {M} yields {|- M = N}, then +If the application of {conv} to {M} yields {|- M = N}, then {STRIP_BINDER_CONV (SOME c) conv (c(\v1. ... (c(\vn.M))...))} returns {|- c(\v1. ... (c(\vn.M))...) = c(\v1. ... (c(\vn.N))...)} and -{STRIP_BINDER_CONV NONE conv (\v1 ... vn.M)} returns +{STRIP_BINDER_CONV NONE conv (\v1 ... vn.M)} returns {|- (\v1 ... vn.M) = (\v1 ... vn.N)}. \FAILURE -If {conv M} fails. Also fails if some of {[v1,...,vn]} are free in +If {conv M} fails. Also fails if some of {[v1,...,vn]} are free in the hypotheses of {conv M}. \EXAMPLE @@ -24,9 +24,9 @@ the hypotheses of {conv M}. - STRIP_BINDER_CONV NONE BETA_CONV (Term `\u v w. (\a. a + v * w) u`); > val it = |- (\u v w. (\a. a + v * w) u) = (\u v w. u + v * w) : thm -- STRIP_BINDER_CONV (SOME existential) SYM_CONV +- STRIP_BINDER_CONV (SOME existential) SYM_CONV (Term `?u v w x y. u + v = w + x + y`); -> val it = |- (?u v w x y. u + v = w + x + y) = +> val it = |- (?u v w x y. u + v = w + x + y) = ?u v w x y. w + x + y = u + v : thm } @@ -35,7 +35,7 @@ the hypotheses of {conv M}. {BINDER_CONV} or {ABS_CONV} or {QUANT_CONV}. \SEEALSO -Conv.BINDER_CONV, Conv.ABS_CONV, Conv.QUANT_CONV, +Conv.BINDER_CONV, Conv.ABS_CONV, Conv.QUANT_CONV, Conv.STRIP_BINDER_CONV, Conv.STRIP_QUANT_CONV. \ENDDOC diff --git a/help/Docfiles/Conv.STRIP_QUANT_CONV.doc b/help/Docfiles/Conv.STRIP_QUANT_CONV.doc index 3c333db9e1..e9abffcebf 100644 --- a/help/Docfiles/Conv.STRIP_QUANT_CONV.doc +++ b/help/Docfiles/Conv.STRIP_QUANT_CONV.doc @@ -9,10 +9,10 @@ Applies a conversion underneath a quantifier prefix. conversion, quantifier. \DESCRIBE -If {tm} has the form {Q(\v1. ... (Q(\vn.M))...)} and the application of +If {tm} has the form {Q(\v1. ... (Q(\vn.M))...)} and the application of {conv} to {M} yields {|- M = N}, then {STRIP_QUANT_CONV conv tm} returns {|- Q(\v1. ... (Q(\vn.M))...) = Q(\v1. ... (Q(\vn.N))...)}, -provided {Q} is Hilbert's choice operator or a universal, existential, or +provided {Q} is Hilbert's choice operator or a universal, existential, or unique-existence quantifer. Otherwise, {STRIP_QUANT_CONV conv tm} returns {conv tm}. @@ -32,11 +32,11 @@ Also fails if some of {[v1,...,vn]} are free in the hypotheses of {conv M}. } \COMMENTS -To deal with binders not in the above list, e.g., newly introduced ones, -use {STRIP_BINDER_CONV}. +To deal with binders not in the above list, e.g., newly introduced ones, +use {STRIP_BINDER_CONV}. For deeply nested quantifiers, {STRIP_QUANT_CONV} and {STRIP_BINDER_CONV} -are more efficient than iterated application of {QUANT_CONV}, {BINDER_CONV}, +are more efficient than iterated application of {QUANT_CONV}, {BINDER_CONV}, or {ABS_CONV}. \SEEALSO diff --git a/help/Docfiles/DB.apropos.doc b/help/Docfiles/DB.apropos.doc index 10887da8b6..5dd0d2488b 100644 --- a/help/Docfiles/DB.apropos.doc +++ b/help/Docfiles/DB.apropos.doc @@ -6,7 +6,7 @@ Attempt to find matching theorems in the currently loaded theories. \DESCRIBE -An invocation {DB.apropos M} collects all theorems, definitions, and +An invocation {DB.apropos M} collects all theorems, definitions, and axioms of the currently loaded theories that have a subterm that matches {M}. If there are no matches, the empty list is returned. diff --git a/help/Docfiles/DB.apropos_in.doc b/help/Docfiles/DB.apropos_in.doc index 299c68a20d..2a373f9783 100644 --- a/help/Docfiles/DB.apropos_in.doc +++ b/help/Docfiles/DB.apropos_in.doc @@ -6,7 +6,7 @@ Attempt to select matching theorems among a given list. \DESCRIBE -An invocation {DB.apropos_in M data_list} selects all +An invocation {DB.apropos_in M data_list} selects all theorems, definitions, and axioms within {data_list} that have a subterm that matches {M}. If there are no matches, the empty list is returned. @@ -39,7 +39,7 @@ It uses {DB.matches}. \USES Finding theorems in interactive proof sessions. -The second argument will normally be the result of a previous call to +The second argument will normally be the result of a previous call to {DB.find, DB.match, DB.apropos, DB.listDB, DB.thy} etc. \SEEALSO diff --git a/help/Docfiles/DB.axioms.doc b/help/Docfiles/DB.axioms.doc index f3330c7525..3fddf7969c 100644 --- a/help/Docfiles/DB.axioms.doc +++ b/help/Docfiles/DB.axioms.doc @@ -7,8 +7,8 @@ All the axioms stored in the named theory. \DESCRIBE An invocation {axioms thy}, where {thy} is the name of a currently -loaded theory segment, will return a list of the axioms stored in -that theory. Each theorem is paired with its name in the result. +loaded theory segment, will return a list of the axioms stored in +that theory. Each theorem is paired with its name in the result. The string {"-"} may be used to denote the current theory segment. \FAILURE diff --git a/help/Docfiles/DB.class.doc b/help/Docfiles/DB.class.doc index 867c778f8e..4d55a1a01f 100644 --- a/help/Docfiles/DB.class.doc +++ b/help/Docfiles/DB.class.doc @@ -11,9 +11,9 @@ the {class} type, which is declared as { datatype class = Thm | Axm | Def } -When occurring with {th}, an ML value of type {thm}, +When occurring with {th}, an ML value of type {thm}, {Axm} means that {th} has been asserted as an axiom; {Def} means that {th} -is a constant definition; and {Thm} means that {th} is a plain old theorem, +is a constant definition; and {Thm} means that {th} is a plain old theorem, i.e,. not an axiom or a definition. \SEEALSO diff --git a/help/Docfiles/DB.data.doc b/help/Docfiles/DB.data.doc index 293cf8b4e1..758eb553aa 100644 --- a/help/Docfiles/DB.data.doc +++ b/help/Docfiles/DB.data.doc @@ -13,14 +13,14 @@ type, which is a type abbreviation declared as type data = (string * string) * (thm * class) } -An element {((thy,name), (th,cl))} means that {th} is a theorem +An element {((thy,name), (th,cl))} means that {th} is a theorem with classification {class}, stored in theory segment {thy} under {name}. \EXAMPLE { - DB.find "BOOL_CASES_AX"; -> val it = [(("bool", "BOOL_CASES_AX"), - (|- !t. (t = T) \/ (t = F), Axm))] +> val it = [(("bool", "BOOL_CASES_AX"), + (|- !t. (t = T) \/ (t = F), Axm))] : ((string * string) * (thm * class)) list } diff --git a/help/Docfiles/DB.definitions.doc b/help/Docfiles/DB.definitions.doc index 45c1250f45..fd2e56291e 100644 --- a/help/Docfiles/DB.definitions.doc +++ b/help/Docfiles/DB.definitions.doc @@ -8,7 +8,7 @@ All the definitions stored in the named theory. \DESCRIBE An invocation {definitions thy}, where {thy} is the name of a currently loaded theory segment, will return a list of the definitions stored in -that theory. Each definition is paired with its name in the result. +that theory. Each definition is paired with its name in the result. The string {"-"} may be used to denote the current theory segment. \FAILURE diff --git a/help/Docfiles/DB.fetch.doc b/help/Docfiles/DB.fetch.doc index 4400cbce25..dce374e3ea 100644 --- a/help/Docfiles/DB.fetch.doc +++ b/help/Docfiles/DB.fetch.doc @@ -6,7 +6,7 @@ Fetch a theorem by theory and name. \DESCRIBE -An invocation {fetch thy name} searches through the currently loaded +An invocation {fetch thy name} searches through the currently loaded theory segments in an attempt to find a theorem, axiom, or definition stored under {name} in theory {thy}. diff --git a/help/Docfiles/DB.find_in.doc b/help/Docfiles/DB.find_in.doc index 15669043c1..dfa40c828e 100644 --- a/help/Docfiles/DB.find_in.doc +++ b/help/Docfiles/DB.find_in.doc @@ -9,7 +9,7 @@ Search for theory element by name fragment, among a given list. An invocation {DB.find_in s data_list} selects from {data_list} those theory elements which have been stored with a name in which {s} occurs as a proper substring, -ignoring case distinctions. +ignoring case distinctions. \FAILURE Never fails. If nothing suitable can be found, the empty list is returned. @@ -35,7 +35,7 @@ Never fails. If nothing suitable can be found, the empty list is returned. \USES Finding theorems in interactive proof sessions. -The second argument will normally be the result of a previous call to +The second argument will normally be the result of a previous call to {DB.find, DB.match, DB.apropos, DB.listDB, DB.thy} etc. \SEEALSO diff --git a/help/Docfiles/DB.match.doc b/help/Docfiles/DB.match.doc index ef08bae154..6a11a33e9f 100644 --- a/help/Docfiles/DB.match.doc +++ b/help/Docfiles/DB.match.doc @@ -9,13 +9,13 @@ Attempt to find matching theorems in the specified theories. matching, database. \DESCRIBE -An invocation {DB.match [s1,...,sn] M} collects all theorems, definitions, +An invocation {DB.match [s1,...,sn] M} collects all theorems, definitions, and axioms of the theories designated by {s1},...,{sn} that have a subterm that matches {M}. If there are no matches, the empty list is returned. The strings {s1},...,{sn} should be a subset of the currently loaded theory segments. The string {"-"} may be used to designate the -current theory segment. If the list of theories is empty, then all +current theory segment. If the list of theories is empty, then all currently loaded theories are searched. \FAILURE @@ -27,7 +27,7 @@ Never fails. <> > val it = [(("bool", "EQ_CLAUSES"), - (|- !t.((T = t) = t) /\ ((t = T) = t) /\ + (|- !t.((T = t) = t) /\ ((t = T) = t) /\ ((F = t) = ~t) /\ ((t = F) = ~t), Db.Thm)), (("bool", "EQ_EXPAND"), (|- !t1 t2. (t1 = t2) = t1 /\ t2 \/ ~t1 /\ ~t2, Db.Thm)), diff --git a/help/Docfiles/DB.matcher.doc b/help/Docfiles/DB.matcher.doc index ef16f0255f..a73f599bf7 100644 --- a/help/Docfiles/DB.matcher.doc +++ b/help/Docfiles/DB.matcher.doc @@ -8,11 +8,11 @@ All theory elements matching a given term. \DESCRIBE An invocation {matcher pm [thy1,...,thyn] M} collects all elements of the theory segments {thy1},...,{thyn} that have a subterm {N} such -that {pm M} does not fail (raise an exception) when applied to {N}. -Thus {matcher} potentially traverses all subterms of all theorems in +that {pm M} does not fail (raise an exception) when applied to {N}. +Thus {matcher} potentially traverses all subterms of all theorems in all the listed theories in its search for `matches'. -If the list of theory segments is empty, then all currently loaded +If the list of theory segments is empty, then all currently loaded segments are examined. The string {"-"} may be used to designate the current theory segment. diff --git a/help/Docfiles/DB.matches.doc b/help/Docfiles/DB.matches.doc index 2da4f6fe86..65ceeaa624 100644 --- a/help/Docfiles/DB.matches.doc +++ b/help/Docfiles/DB.matches.doc @@ -3,7 +3,7 @@ \TYPE {matches : term -> thm -> bool} \SYNOPSIS -Tells whether part of a theorem matches a pattern. +Tells whether part of a theorem matches a pattern. \KEYWORDS matching. diff --git a/help/Docfiles/DB.matchp.doc b/help/Docfiles/DB.matchp.doc index 5089eaf3cd..7362011d03 100644 --- a/help/Docfiles/DB.matchp.doc +++ b/help/Docfiles/DB.matchp.doc @@ -7,13 +7,13 @@ All theory elements satisfying a predicate. \DESCRIBE An invocation {matchp P [thy1,...,thyn]} collects all elements of -the theory segments {thy1},...,{thyn} that {P} holds of. If the list +the theory segments {thy1},...,{thyn} that {P} holds of. If the list of theory segments is empty, then all currently loaded segments are examined. The string {"-"} may be used to designate the current theory segment. \FAILURE -Fails if {P} fails when applied to a theorem in one of the +Fails if {P} fails when applied to a theorem in one of the theories being searched. \EXAMPLE diff --git a/help/Docfiles/DB.theorems.doc b/help/Docfiles/DB.theorems.doc index 95076cf021..f1423527ab 100644 --- a/help/Docfiles/DB.theorems.doc +++ b/help/Docfiles/DB.theorems.doc @@ -8,8 +8,8 @@ All the theorems stored in the named theory. \DESCRIBE An invocation {theorems thy}, where {thy} is the name of a currently loaded theory segment, will return a list of the theorems stored in -that theory. Axioms and definitions are excluded. Each theorem is -paired with its name in the result. The string {"-"} may be +that theory. Axioms and definitions are excluded. Each theorem is +paired with its name in the result. The string {"-"} may be used to denote the current theory segment. \FAILURE diff --git a/help/Docfiles/DB.thy.doc b/help/Docfiles/DB.thy.doc index cc8e2f2878..578e292fb2 100644 --- a/help/Docfiles/DB.thy.doc +++ b/help/Docfiles/DB.thy.doc @@ -12,11 +12,11 @@ theory. An invocation {DB.thy s} returns the contents of the specified theory segment {s} in a list of {(thy,name),(thm,class)} tuples. In a tuple, {(thy,name)} designate the theory and the name given to the object -in the theory. The {thm} element is the named object, and {class} its +in the theory. The {thm} element is the named object, and {class} its classification (one of {Thm} (theorem), {Axm} (axiom), or {Def} (definition)). -Case distinctions are ignored when determining the segment. The current -segment may be specified, either by the distinguished literal {"-"}, +Case distinctions are ignored when determining the segment. The current +segment may be specified, either by the distinguished literal {"-"}, or by the name given when creating the segment with {new_theory}. \FAILURE diff --git a/help/Docfiles/Definition.new_definition.doc b/help/Docfiles/Definition.new_definition.doc index 483e856eca..406336c0dd 100644 --- a/help/Docfiles/Definition.new_definition.doc +++ b/help/Docfiles/Definition.new_definition.doc @@ -30,9 +30,9 @@ may have any of its variables universally quantified. \FAILURE {new_definition} fails if {t} contains free variables that are not -in {x_1}, ..., {x_m} (this is equivalent to requiring +in {x_1}, ..., {x_m} (this is equivalent to requiring {\v_1 ... v_n. t} to be a closed term). Failure also occurs if -any variable occurs more than once in {v_1, ..., v_n}. Finally, +any variable occurs more than once in {v_1, ..., v_n}. Finally, failure occurs if there is a type variable in {v_1}, ..., {v_n} or {t} that does not occur in the type of {c}. diff --git a/help/Docfiles/Definition.new_specification.doc b/help/Docfiles/Definition.new_specification.doc index 818d65b78e..33a26fecb7 100644 --- a/help/Docfiles/Definition.new_specification.doc +++ b/help/Docfiles/Definition.new_specification.doc @@ -23,9 +23,9 @@ the current theory segment. It is also returned by the call to \FAILURE {new_specification} fails if the theorem argument has assumptions or -free variables. It also fails if the supplied constant names +free variables. It also fails if the supplied constant names {c1}, ..., {cn} are not distinct. It also fails if the length of -the existential prefix of the theorem is not at least {n}. Finally, +the existential prefix of the theorem is not at least {n}. Finally, failure occurs if some {ci} does not contain all the type variables that occur in the term {?x1...xn. t}. @@ -43,17 +43,17 @@ and then making the constant specification: new_specification ("DIVISION", ["MOD","DIV"], th) } This introduces the constants {MOD} and {DIV} with the defining -property shown above. +property shown above. \COMMENTS -The introduced constants have a prefix parsing status. To alter this, +The introduced constants have a prefix parsing status. To alter this, use {set_fixity}. Typical fixity values are {Prefix}, {Binder}, {Infixl n}, {Infixr n}, {Suffix n}, {TruePrefix n} or {Closefix}. \SEEALSO Definition.gen_new_specification, -Definition.new_definition, -boolSyntax.new_binder_definition, boolSyntax.new_infixl_definition, +Definition.new_definition, +boolSyntax.new_binder_definition, boolSyntax.new_infixl_definition, boolSyntax.new_infixr_definition, TotalDefn.Define, Parse.set_fixity. \ENDDOC diff --git a/help/Docfiles/Defn.tgoal.doc b/help/Docfiles/Defn.tgoal.doc index a9994d3249..4bdcb896d4 100644 --- a/help/Docfiles/Defn.tgoal.doc +++ b/help/Docfiles/Defn.tgoal.doc @@ -17,16 +17,16 @@ goalstack operations. \FAILURE {tgoal defn} fails if {defn} represents a non-recursive or primitive -recursive function. +recursive function. \EXAMPLE -{ -- val qsort_defn = +{ +- val qsort_defn = Hol_defn "qsort" `(qsort ___ [] = []) /\ - (qsort ord (x::rst) = + (qsort ord (x::rst) = APPEND (qsort ord (FILTER ($~ o ord x) rst)) (x :: qsort ord (FILTER (ord x) rst)))`; diff --git a/help/Docfiles/Drule.ASSUME_CONJS.doc b/help/Docfiles/Drule.ASSUME_CONJS.doc index eb1a5b160c..ae51dc82ba 100644 --- a/help/Docfiles/Drule.ASSUME_CONJS.doc +++ b/help/Docfiles/Drule.ASSUME_CONJS.doc @@ -21,7 +21,7 @@ Never fails. { [t1, t2, ..., tn] |- t1 /\ t2 /\ ... /\ tn } To split up conjuncts in selected hypotheses {hyps} of a theorem {th}, -use {Lib.itlist (PROVE_HYP o ASSUME_CONJS) hyps th} +use {Lib.itlist (PROVE_HYP o ASSUME_CONJS) hyps th} \SEEALSO Drule.CONJUNCTS, Thm.CONJ, Drule.CONJUNCTS_AC diff --git a/help/Docfiles/Drule.BODY_CONJUNCTS.doc b/help/Docfiles/Drule.BODY_CONJUNCTS.doc index 7b6e2b8c27..c6e40067a3 100644 --- a/help/Docfiles/Drule.BODY_CONJUNCTS.doc +++ b/help/Docfiles/Drule.BODY_CONJUNCTS.doc @@ -26,7 +26,7 @@ or conjuncts. \EXAMPLE The following illustrates how a typical term will be split: { - - local val tm = Parser.term_parser + - local val tm = Parser.term_parser `!x:bool. A /\ (B \/ (C /\ D)) /\ ((!y:bool. E) /\ F)` in val x = ASSUME tm diff --git a/help/Docfiles/Drule.CONJ_LIST.doc b/help/Docfiles/Drule.CONJ_LIST.doc index eb46e5419f..357738eb6e 100644 --- a/help/Docfiles/Drule.CONJ_LIST.doc +++ b/help/Docfiles/Drule.CONJ_LIST.doc @@ -34,7 +34,7 @@ Suppose the identifier {th} is bound to the theorem: Here are some applications of {CONJ_LIST} to {th}: { - CONJ_LIST 0 th; - ! Uncaught exception: + ! Uncaught exception: ! HOL_ERR - CONJ_LIST 1 th; @@ -47,7 +47,7 @@ Here are some applications of {CONJ_LIST} to {th}: > val it = [ [A] |- x /\ y, [A] |- z, [A] |- w] : thm list - CONJ_LIST 4 th; - ! Uncaught exception: + ! Uncaught exception: ! HOL_ERR } diff --git a/help/Docfiles/Drule.EXISTS_LEFT.doc b/help/Docfiles/Drule.EXISTS_LEFT.doc index 97de29b4b9..0dcec7c6c3 100644 --- a/help/Docfiles/Drule.EXISTS_LEFT.doc +++ b/help/Docfiles/Drule.EXISTS_LEFT.doc @@ -13,7 +13,7 @@ In this example, assume that {h1} and {h3} (only) involve the free variable {x}. { h1, h2, h3 |- t --------------------- EXISTS_LEFT [``x``] - ?x. h1 /\ h3, h2 |- t + ?x. h1 /\ h3, h2 |- t } \FAILURE @@ -22,21 +22,21 @@ variables \EXAMPLE Where {th} is {[p, q, g x, h y, f x y] |- r}, and {fvx} and {fvy} are -{``x``} and {``y``}, +{``x``} and {``y``}, {EXISTS_LEFT [fvx, fvy] th} is {[p, q, ?y. (?x. g x /\ f x y) /\ h y] |- r} {EXISTS_LEFT [fvy, fvx] th} is {[p, q, ?x. (?y. h y /\ f x y) /\ g x] |- r} \USES -Where {EQ_TRANS} is +Where {EQ_TRANS} is {[] |- !x y z. (x = y) /\ (y = z) ==> (x = z)} and the current goal is {a = b}, the tactic {MATCH_MP_TAC EQ_TRANS} gives a new goal {?y. (a = y) /\ (y = b)} by virtue of the smart features built into {MATCH_MP_TAC}. -Where {trans_thm} is +Where {trans_thm} is {[] |- !x y z. (x = y) ==> (y = z) ==> (x = z)} the same result could of course be achieved by rewriting it with {AND_IMP_INTRO}. diff --git a/help/Docfiles/Drule.EXISTS_LEFT1.doc b/help/Docfiles/Drule.EXISTS_LEFT1.doc index c0dddf72ab..b608e0d05b 100644 --- a/help/Docfiles/Drule.EXISTS_LEFT1.doc +++ b/help/Docfiles/Drule.EXISTS_LEFT1.doc @@ -13,7 +13,7 @@ In this example, assume that {h1} and {h3} (only) involve the free variable {x}. { h1, h2, h3 |- t --------------------- EXISTS_LEFT1 ``x`` - ?x. h1 /\ h3, h2 |- t + ?x. h1 /\ h3, h2 |- t } \FAILURE @@ -23,14 +23,14 @@ theorem \EXAMPLE Where {th} is {[p, q, g x, h y, f x y] |- r}, and {fvx} and {fvy} are -{``x``} and {``y``}, +{``x``} and {``y``}, {EXISTS_LEFT1 fvx th} is {[p, q, h y, ?x. g x /\ f x y] |- r} {EXISTS_LEFT1 fvy th} is {[p, q, g x, ?y. h y /\ f x y] |- r} \COMMENTS -{EXISTS_LEFT1 fv} is just like {EXISTS_LEFT [fv]} except that +{EXISTS_LEFT1 fv} is just like {EXISTS_LEFT [fv]} except that {EXISTS_LEFT1 fv} fails where {EXISTS_LEFT [fv]} returns the theorem unchanged See {EXISTS_LEFT} for further discussion diff --git a/help/Docfiles/Drule.GEN_ALPHA_CONV.doc b/help/Docfiles/Drule.GEN_ALPHA_CONV.doc index e1527874d9..1b112fe6d4 100644 --- a/help/Docfiles/Drule.GEN_ALPHA_CONV.doc +++ b/help/Docfiles/Drule.GEN_ALPHA_CONV.doc @@ -14,14 +14,14 @@ The conversion {GEN_ALPHA_CONV} provides alpha conversion for lambda abstractions of the form {\y.t}, quantified terms of the forms {!y.t}, {?y.t} or {?!y.t}, and epsilon terms of the form {@y.t}. In general, if {B} is a binder constant, then {GEN_ALPHA_CONV} implements alpha -conversion for applications of the form {B y.t}. +conversion for applications of the form {B y.t}. If {tm} is an abstraction {\y.t} or an application of a binder to an abstraction {B y.t}, where the bound variable {y} has type {ty}, and if {x} is a variable also of type {ty}, then {GEN_ALPHA_CONV x tm} returns one of the theorems: { - |- (\y.t) = (\x'. t[x'/y]) + |- (\y.t) = (\x'. t[x'/y]) |- (B y.t) = (B x'. t[x'/y]) } depending on whether the input term is {\y.t} or {B y.t} @@ -31,8 +31,8 @@ argument to {GEN_ALPHA_CONV}. \FAILURE {GEN_ALPHA_CONV x tm} fails if {x} is not a variable, or if {tm} does not have -one of the forms {\y.t} or {B y.t}, where {B} is a binder. -{GEN_ALPHA_CONV x tm} also fails if {tm} does have one of these +one of the forms {\y.t} or {B y.t}, where {B} is a binder. +{GEN_ALPHA_CONV x tm} also fails if {tm} does have one of these forms, but types of the variables {x} and {y} differ. \SEEALSO diff --git a/help/Docfiles/Drule.IMP_ANTISYM_RULE.doc b/help/Docfiles/Drule.IMP_ANTISYM_RULE.doc index fd1f600f94..3bf9cc2298 100644 --- a/help/Docfiles/Drule.IMP_ANTISYM_RULE.doc +++ b/help/Docfiles/Drule.IMP_ANTISYM_RULE.doc @@ -10,7 +10,7 @@ rule, implication, equality. \DESCRIBE When applied to the theorems {A1 |- t1 ==> t2} and {A2 |- t2 ==> t1}, -the inference rule {IMP_ANTISYM_RULE} returns the theorem +the inference rule {IMP_ANTISYM_RULE} returns the theorem {A1 u A2 |- t1 = t2}. { A1 |- t1 ==> t2 A2 |- t2 ==> t1 diff --git a/help/Docfiles/Drule.INST_TT_HYPS.doc b/help/Docfiles/Drule.INST_TT_HYPS.doc index 2b786e919f..26d11b8420 100644 --- a/help/Docfiles/Drule.INST_TT_HYPS.doc +++ b/help/Docfiles/Drule.INST_TT_HYPS.doc @@ -13,7 +13,7 @@ rule, type, instantiate. \DESCRIBE {INST_TT_HYPS} instantiates types and terms in a theorem {thm}, -in the same way {INST_TY_TERM} does. +in the same way {INST_TY_TERM} does. It also returns a list of the instantiated hypotheses, in the same order as the uninstantiated hypotheses appear in the list {hyp thm}. diff --git a/help/Docfiles/Drule.INST_TY_TERM.doc b/help/Docfiles/Drule.INST_TY_TERM.doc index b84da3cdeb..d5e81ab31f 100644 --- a/help/Docfiles/Drule.INST_TY_TERM.doc +++ b/help/Docfiles/Drule.INST_TY_TERM.doc @@ -19,7 +19,7 @@ variables in the resulting theorem, in the same way as {INST}. \COMMENTS Because the types are instantiated first, the terms (redexes as well as residues) in the term substitution must contain the substituted types, not the -original ones. Use {norm_subst} to achieve this. +original ones. Use {norm_subst} to achieve this. \FAILURE {INST_TY_TERM} fails under the same conditions as either {INST} or diff --git a/help/Docfiles/Drule.Ntimes.doc b/help/Docfiles/Drule.Ntimes.doc index a877c5b24e..1b58c1797f 100644 --- a/help/Docfiles/Drule.Ntimes.doc +++ b/help/Docfiles/Drule.Ntimes.doc @@ -1,4 +1,4 @@ -\DOC Ntimes +\DOC Ntimes \TYPE {Ntimes : thm -> int -> thm} @@ -9,8 +9,8 @@ Rewriting control. Rewriting, simplification. \DESCRIBE -When used as an argument to the rewriter or simplifier, {Ntimes th n} is -a directive saying that {th} should be used at most {n} times in the +When used as an argument to the rewriter or simplifier, {Ntimes th n} is +a directive saying that {th} should be used at most {n} times in the rewriting process. This is useful for controlling looping rewrites. \FAILURE @@ -32,7 +32,7 @@ application of the simplifier will loop: (* looping *) > Interrupted. } -In order to expand the definition of {fact_def} three times, the +In order to expand the definition of {fact_def} three times, the following invocation can be made { - SIMP_CONV arith_ss [Ntimes Fact_def 3] ``fact 6``; @@ -42,14 +42,14 @@ following invocation can be made \COMMENTS Use of {Ntimes} does not compose well. For example, { - tac1 THENL [SIMP_TAC std_ss [Ntimes th 1], + tac1 THENL [SIMP_TAC std_ss [Ntimes th 1], SIMP_TAC std_ss [Ntimes th 1]] } -is not equivalent in behaviour to +is not equivalent in behaviour to { tac1 THEN SIMP_TAC std_ss [Ntimes th 1]. -} -In the first call two rewrites using {th} can occur; in the second, +} +In the first call two rewrites using {th} can occur; in the second, only one can occur. \SEEALSO diff --git a/help/Docfiles/Drule.RIGHT_ETA.doc b/help/Docfiles/Drule.RIGHT_ETA.doc index dc9f503bbf..bf2a25867b 100644 --- a/help/Docfiles/Drule.RIGHT_ETA.doc +++ b/help/Docfiles/Drule.RIGHT_ETA.doc @@ -3,7 +3,7 @@ \TYPE {RIGHT_ETA : thm -> thm} \SYNOPSIS -Perform one step of eta-reduction on the right hand side of an +Perform one step of eta-reduction on the right hand side of an equational theorem. \KEYWORDS diff --git a/help/Docfiles/Drule.SPEC_UNDISCH_EXL.doc b/help/Docfiles/Drule.SPEC_UNDISCH_EXL.doc index 7048d90b71..4014412e8c 100644 --- a/help/Docfiles/Drule.SPEC_UNDISCH_EXL.doc +++ b/help/Docfiles/Drule.SPEC_UNDISCH_EXL.doc @@ -15,7 +15,7 @@ In this example, assume that {a1} and {a3} (only) involve the free variable {x}. { |- !x. a1 ==> !y. a2 ==> !z. a3 ==> !u. t ----------------------------------------- SPEC_UNDISCH_EXL - ?x. a1 /\ a3, a2 |- t + ?x. a1 /\ a3, a2 |- t } \FAILURE diff --git a/help/Docfiles/Drule.SUBST_CONV.doc b/help/Docfiles/Drule.SUBST_CONV.doc index 82ec92042c..5f9def3a07 100644 --- a/help/Docfiles/Drule.SUBST_CONV.doc +++ b/help/Docfiles/Drule.SUBST_CONV.doc @@ -44,14 +44,14 @@ variables in {vi} becoming bound after substitution. \FAILURE {SUBST_CONV [{redex=x1,residue=th1},...,{redex=xn,residue=thn}] t[x1,...,xn] t'} fails if the conclusion of any theorem {thi} in the list is not an equation; or if -the template {t[x1,...,xn]} does not match the term {t'}; or if and term {ti} -in {t'} marked by the variable {xi} in the template, is not identical to the +the template {t[x1,...,xn]} does not match the term {t'}; or if and term {ti} +in {t'} marked by the variable {xi} in the template, is not identical to the left-hand side of the conclusion of the theorem {thi}. \EXAMPLE The values { - - val thm0 = SPEC (Term`0`) ADD1 + - val thm0 = SPEC (Term`0`) ADD1 and thm1 = SPEC (Term`1`) ADD1 and x = Term`x:num` and y = Term`y:num`; diff --git a/help/Docfiles/Drule.SUBS_OCCS.doc b/help/Docfiles/Drule.SUBS_OCCS.doc index 395547cd42..0f5fcd6d26 100644 --- a/help/Docfiles/Drule.SUBS_OCCS.doc +++ b/help/Docfiles/Drule.SUBS_OCCS.doc @@ -36,7 +36,7 @@ The commutative law for addition can be used for substituting only the second occurrence of the subterm {m + n} { - - SUBS_OCCS [([2],thm)] + - SUBS_OCCS [([2],thm)] (ASSUME (Term `(n + m) + (m + n) = (m + n) + (m + n)`)); > val it = [.] |- n + m + (m + n) = n + m + (m + n) : thm } diff --git a/help/Docfiles/Drule.UNDISCH_TM.doc b/help/Docfiles/Drule.UNDISCH_TM.doc index 4668d6ede5..ea1d197195 100644 --- a/help/Docfiles/Drule.UNDISCH_TM.doc +++ b/help/Docfiles/Drule.UNDISCH_TM.doc @@ -24,8 +24,8 @@ Note that {UNDISCH_TM} treats {"~u"} as {"u ==> F"}. If the antecedent already appears in (or is alpha-equivalent to one of) the hypotheses, it will not be duplicated. -{UNDISCH_TM} is similar to {UNDISCH} except that it also returns the antecedent -concerned, which may be useful, for example, when the new assumption +{UNDISCH_TM} is similar to {UNDISCH} except that it also returns the antecedent +concerned, which may be useful, for example, when the new assumption is subsequently to be discharged \SEEALSO diff --git a/help/Docfiles/EmitTeX.non_type_theorems.doc b/help/Docfiles/EmitTeX.non_type_theorems.doc index 2d2e234aa4..aef8812360 100644 --- a/help/Docfiles/EmitTeX.non_type_theorems.doc +++ b/help/Docfiles/EmitTeX.non_type_theorems.doc @@ -8,7 +8,7 @@ A versions of {theorems} that attempts to filter out theorems created by {Hol_da \DESCRIBE An invocation {non_type_theorems thy}, where {thy} is the name of a currently loaded theory segment, will return a list of the theorems stored in -that theory. Axioms and definitions are excluded. Each theorem is +that theory. Axioms and definitions are excluded. Each theorem is paired with its name in the result. \FAILURE @@ -27,7 +27,7 @@ the empty list is returned. Definition has been stored under "example_def". > val example_def = |- (example First = Second) /\ (example Second = First) : thm -- save_thm("example_thm", +- save_thm("example_thm", METIS_PROVE [example_def, theorem "example_nchotomy"] ``!x. example (example x) = x``); metis: r[+0+5]+0+0+0+0+6+2+2+1+0+1+1# diff --git a/help/Docfiles/EmitTeX.print_term_as_tex.doc b/help/Docfiles/EmitTeX.print_term_as_tex.doc index 2e352869f4..007a4cead0 100644 --- a/help/Docfiles/EmitTeX.print_term_as_tex.doc +++ b/help/Docfiles/EmitTeX.print_term_as_tex.doc @@ -21,7 +21,7 @@ Should never fail. \COMMENTS -The LaTeX style file {holtexbasic.sty} (or {holtex.sty}) should be used and the output should be pasted into a Verbatim environment. +The LaTeX style file {holtexbasic.sty} (or {holtex.sty}) should be used and the output should be pasted into a Verbatim environment. \SEEALSO EmitTeX.print_type_as_tex, EmitTeX.print_theorem_as_tex, EmitTeX.print_theory_as_tex, EmitTeX.print_theories_as_tex_doc, EmitTeX.tex_theory diff --git a/help/Docfiles/EmitTeX.print_theorem_as_tex.doc b/help/Docfiles/EmitTeX.print_theorem_as_tex.doc index f01110e6c4..6d90e7240c 100644 --- a/help/Docfiles/EmitTeX.print_theorem_as_tex.doc +++ b/help/Docfiles/EmitTeX.print_theorem_as_tex.doc @@ -28,7 +28,7 @@ Should never fail. \COMMENTS -The LaTeX style file {holtexbasic.sty} (or {holtex.sty}) should be used and the output should be pasted into a Verbatim environment. +The LaTeX style file {holtexbasic.sty} (or {holtex.sty}) should be used and the output should be pasted into a Verbatim environment. \SEEALSO EmitTeX.print_term_as_tex, EmitTeX.print_type_as_tex, EmitTeX.print_theory_as_tex, EmitTeX.print_theories_as_tex_doc, EmitTeX.tex_theory diff --git a/help/Docfiles/EmitTeX.print_type_as_tex.doc b/help/Docfiles/EmitTeX.print_type_as_tex.doc index b9c8519c6a..396539062c 100644 --- a/help/Docfiles/EmitTeX.print_type_as_tex.doc +++ b/help/Docfiles/EmitTeX.print_type_as_tex.doc @@ -21,7 +21,7 @@ Should never fail. \COMMENTS -The LaTeX style file {holtexbasic.sty} (or {holtex.sty}) should be used and the output should be pasted into a Verbatim environment. +The LaTeX style file {holtexbasic.sty} (or {holtex.sty}) should be used and the output should be pasted into a Verbatim environment. \SEEALSO EmitTeX.print_term_as_tex, EmitTeX.print_theorem_as_tex, EmitTeX.print_theory_as_tex, EmitTeX.print_theories_as_tex_doc, EmitTeX.tex_theory diff --git a/help/Docfiles/Feedback.MESG_to_string.doc b/help/Docfiles/Feedback.MESG_to_string.doc index 899bc61f04..400f48aeb9 100644 --- a/help/Docfiles/Feedback.MESG_to_string.doc +++ b/help/Docfiles/Feedback.MESG_to_string.doc @@ -9,8 +9,8 @@ Alterable function for formatting {HOL_MESG}. message, formatting \DESCRIBE -{MESG_to_string} is a reference to a function for formatting the argument -to an application of {HOL_MESG}. +{MESG_to_string} is a reference to a function for formatting the argument +to an application of {HOL_MESG}. The default value of {MESG_to_string} is {format_MESG}. diff --git a/help/Docfiles/Feedback.Raise.doc b/help/Docfiles/Feedback.Raise.doc index a3431b89cd..8094aea7ae 100644 --- a/help/Docfiles/Feedback.Raise.doc +++ b/help/Docfiles/Feedback.Raise.doc @@ -11,7 +11,7 @@ I/O, exception \DESCRIBE The {Raise} function prints out information about its argument exception before re-raising it. It uses the value of {ERR_to_string} to format the -message, and prints the information on the {outstream} held in +message, and prints the information on the {outstream} held in {ERR_outstream}. \FAILURE @@ -23,7 +23,7 @@ Never fails, since it always succeeds in raising the supplied exception. Exception raised at Foo.bar: incomprehensible input -! Uncaught exception: +! Uncaught exception: ! HOL_ERR } diff --git a/help/Docfiles/Feedback.WARNING_to_string.doc b/help/Docfiles/Feedback.WARNING_to_string.doc index 7edec9137b..e3ec1fb034 100644 --- a/help/Docfiles/Feedback.WARNING_to_string.doc +++ b/help/Docfiles/Feedback.WARNING_to_string.doc @@ -9,14 +9,14 @@ Alterable function for formatting {HOL_WARNING}. message, formatting \DESCRIBE -{WARNING_to_string} is a reference to a function for formatting the argument -to {HOL_WARNING}. +{WARNING_to_string} is a reference to a function for formatting the argument +to {HOL_WARNING}. The default value of {WARNING_to_string} is {format_WARNING}. \EXAMPLE { - - fun alt_WARNING_report s t u = + - fun alt_WARNING_report s t u = String.concat["WARNING---", s,".",t,": ",u,"---END WARNING\n"]; - WARNING_to_string := alt_WARNING_report; diff --git a/help/Docfiles/Feedback.doc b/help/Docfiles/Feedback.doc index f383553085..26e48dd8c1 100644 --- a/help/Docfiles/Feedback.doc +++ b/help/Docfiles/Feedback.doc @@ -9,7 +9,7 @@ Module for messages, warnings, errors, and tracing of HOL functions. I/O, messages, warnings, errors, exceptions, tracing. \DESCRIBE -The {Feedback} structure provides facilities for raising and +The {Feedback} structure provides facilities for raising and viewing HOL errors, and also for monitoring tools as they run. \ENDDOC diff --git a/help/Docfiles/Feedback.fail.doc b/help/Docfiles/Feedback.fail.doc index 029e28b4ce..916c4595f9 100644 --- a/help/Docfiles/Feedback.fail.doc +++ b/help/Docfiles/Feedback.fail.doc @@ -21,7 +21,7 @@ Always fails. Exception raised at ??.??: fail -! Uncaught exception: +! Uncaught exception: ! HOL_ERR } diff --git a/help/Docfiles/Feedback.failwith.doc b/help/Docfiles/Feedback.failwith.doc index cd87dee8e1..5fbfa5da35 100644 --- a/help/Docfiles/Feedback.failwith.doc +++ b/help/Docfiles/Feedback.failwith.doc @@ -25,7 +25,7 @@ Always fails. Exception raised at ??.failwith: foo -! Uncaught exception: +! Uncaught exception: ! HOL_ERR } diff --git a/help/Docfiles/Globals.priming.doc b/help/Docfiles/Globals.priming.doc index d97c234a89..8ca50169d1 100644 --- a/help/Docfiles/Globals.priming.doc +++ b/help/Docfiles/Globals.priming.doc @@ -30,8 +30,8 @@ The default value of {priming} is {NONE}. \COMMENTS -Proofs should be re-run in the same priming regime as they were -originally performed in, since different styles of renaming can +Proofs should be re-run in the same priming regime as they were +originally performed in, since different styles of renaming can break proofs. \SEEALSO diff --git a/help/Docfiles/HolKernel.subst_occs.doc b/help/Docfiles/HolKernel.subst_occs.doc index 9a1a29e955..5e03488f01 100644 --- a/help/Docfiles/HolKernel.subst_occs.doc +++ b/help/Docfiles/HolKernel.subst_occs.doc @@ -6,9 +6,9 @@ Substitutes for particular occurrences of subterms of a given term. \DESCRIBE -For each {{redex,residue}} in the second argument, there should be a +For each {{redex,residue}} in the second argument, there should be a corresponding integer list {l_i} in the first argument that specifies which -free occurrences of {redex_i} in the third argument should be substituted +free occurrences of {redex_i} in the third argument should be substituted by {residue_i}. \FAILURE diff --git a/help/Docfiles/HolSatLib.SAT_PROVE.doc b/help/Docfiles/HolSatLib.SAT_PROVE.doc index 77b96c2e00..25baa4cb6e 100644 --- a/help/Docfiles/HolSatLib.SAT_PROVE.doc +++ b/help/Docfiles/HolSatLib.SAT_PROVE.doc @@ -7,7 +7,7 @@ Proves that the supplied term is a tautology, or provides a counterexample. \DESCRIBE -The supplied term should be purely propositional, i.e., atoms must be Boolean variables or constants, and conditionals must be Boolean-valued. {SAT_PROVE} uses the MiniSat SAT solver's proof logging feature to construct and verify a resolution refutation for the negation of the supplied term. +The supplied term should be purely propositional, i.e., atoms must be Boolean variables or constants, and conditionals must be Boolean-valued. {SAT_PROVE} uses the MiniSat SAT solver's proof logging feature to construct and verify a resolution refutation for the negation of the supplied term. \FAILURE Fails if the supplied term is not a tautology. In this case, a theorem providing a satisfying assignment for the negation of the input term is returned, wrapped in an exception. @@ -19,11 +19,11 @@ Fails if the supplied term is not a tautology. In this case, a theorem providing > val it = () : unit - SAT_PROVE ``(a ==> b) /\ (b ==> a) ==> (a=b)``; > val it = |- (a ==> b) /\ (b ==> a) ==> (a = b) : thm -- SAT_PROVE ``~((a ==> b) /\ (b ==> a) ==> (a=b))`` +- SAT_PROVE ``~((a ==> b) /\ (b ==> a) ==> (a=b))`` handle HolSatLib.SAT_cex th => th; > val it = |- ~b /\ a ==> ~~((a ==> b) /\ (b ==> a) ==> (a = b)) : thm } - + \COMMENTS If MiniSat terminates abnormally, or if the MiniSat binary cannot be located or executed, SAT_PROVE falls back to a slower propositional tautology prover implemented in SML. For low-level use of SAT solver facilities and other details, see the section on the HolSat library in the HOL Description. diff --git a/help/Docfiles/IndDefRules.doc b/help/Docfiles/IndDefRules.doc index 66ef7d017c..33aa2b6b86 100644 --- a/help/Docfiles/IndDefRules.doc +++ b/help/Docfiles/IndDefRules.doc @@ -9,7 +9,7 @@ Tom Melham's inference support for inductive definitions. inductive \DESCRIBE -{IndDefRules} provides support for reasoning about inductively +{IndDefRules} provides support for reasoning about inductively defined relations, including a general induction tactic, and an entrypoint for deriving so-called `strong' rule induction. diff --git a/help/Docfiles/Lib.append.doc b/help/Docfiles/Lib.append.doc index b80ad6354b..739fb674ac 100644 --- a/help/Docfiles/Lib.append.doc +++ b/help/Docfiles/Lib.append.doc @@ -9,7 +9,7 @@ Curry Curried form of list append. \DESCRIBE -The function {append} is a curried form of the standard operation for +The function {append} is a curried form of the standard operation for appending two ML lists. \FAILURE diff --git a/help/Docfiles/Lib.assert.doc b/help/Docfiles/Lib.assert.doc index d21397bb46..0fc46ccf09 100644 --- a/help/Docfiles/Lib.assert.doc +++ b/help/Docfiles/Lib.assert.doc @@ -11,7 +11,7 @@ Checks that a value satisfies a predicate. \FAILURE {assert p x} fails with exception {HOL_ERR} if the predicate {p} yields -{false} when applied to the value {x}. If the application {p x} raises an +{false} when applied to the value {x}. If the application {p x} raises an exception {e}, then {assert p x} raises {e}. \EXAMPLE diff --git a/help/Docfiles/Lib.assert_exn.doc b/help/Docfiles/Lib.assert_exn.doc index 99bab6b014..2b3d0411e5 100644 --- a/help/Docfiles/Lib.assert_exn.doc +++ b/help/Docfiles/Lib.assert_exn.doc @@ -28,7 +28,7 @@ an exception {ex}, then {assert_exn p x e} raises {ex}. > false : bool - assert_exn null [1] (Fail "non-empty list");; -! Uncaught exception: +! Uncaught exception: ! Fail "non-empty list" } diff --git a/help/Docfiles/Lib.assoc.doc b/help/Docfiles/Lib.assoc.doc index 991ba63c0c..8a9653474e 100644 --- a/help/Docfiles/Lib.assoc.doc +++ b/help/Docfiles/Lib.assoc.doc @@ -3,7 +3,7 @@ \TYPE {assoc : ''a -> (''a * 'b) list -> 'b} \SYNOPSIS -Searches a list of pairs for a pair whose first component equals a +Searches a list of pairs for a pair whose first component equals a specified value, then returns the second component of the pair. \KEYWORDS @@ -11,8 +11,8 @@ list. \DESCRIBE {assoc x [(x1,y1),...,(xn,yn)]} locates the first {(xi,yi)} in a left-to-right -scan of the list such that {xi} equals {x}. Then {yi} is returned. The lookup -is done on an eqtype, i.e., the SML implementation must be able to decide equality +scan of the list such that {xi} equals {x}. Then {yi} is returned. The lookup +is done on an eqtype, i.e., the SML implementation must be able to decide equality for the type of {x}. \FAILURE diff --git a/help/Docfiles/Lib.assoc1.doc b/help/Docfiles/Lib.assoc1.doc index 20f3223a1a..99e84bc7f2 100644 --- a/help/Docfiles/Lib.assoc1.doc +++ b/help/Docfiles/Lib.assoc1.doc @@ -3,7 +3,7 @@ \TYPE {assoc1 : ''a -> (''a * 'b) list -> (''a * 'b)option} \SYNOPSIS -Searches a list of pairs for a pair whose first component equals a +Searches a list of pairs for a pair whose first component equals a specified value. \KEYWORDS diff --git a/help/Docfiles/Lib.can.doc b/help/Docfiles/Lib.can.doc index 06806decdd..477235d2f3 100644 --- a/help/Docfiles/Lib.can.doc +++ b/help/Docfiles/Lib.can.doc @@ -18,7 +18,7 @@ Only fails if {f x} raises the {Interrupt} exception. \EXAMPLE { - hd []; -! Uncaught exception: +! Uncaught exception: ! Empty - can hd []; diff --git a/help/Docfiles/Lib.combine.doc b/help/Docfiles/Lib.combine.doc index f73f5d2cda..ddab4da73f 100644 --- a/help/Docfiles/Lib.combine.doc +++ b/help/Docfiles/Lib.combine.doc @@ -16,7 +16,7 @@ Fails if the two lists are of different lengths. \COMMENTS Has much the same effect as the SML Basis function {ListPair.zip} -except that it fails if the arguments are not of equal length. Also +except that it fails if the arguments are not of equal length. Also note that {zip} is a curried version of {combine} \SEEALSO diff --git a/help/Docfiles/Lib.delta.doc b/help/Docfiles/Lib.delta.doc index 0ded53050f..d848274d01 100644 --- a/help/Docfiles/Lib.delta.doc +++ b/help/Docfiles/Lib.delta.doc @@ -10,12 +10,12 @@ The {delta} type is declared as follows: { datatype 'a delta = SAME | DIFF of 'a } -The {delta} type may be used in applications where it is +The {delta} type may be used in applications where it is important to tell if a function has changed its argument or not. As an example of this, consider mapping a function over a large collection of elements. If only a few elements are changed, it makes sense to re-use all those that were not changed. This can of course be handled on an -ad hoc basis; the {delta} type provides a mechanism for doing this +ad hoc basis; the {delta} type provides a mechanism for doing this systematically. \COMMENTS diff --git a/help/Docfiles/Lib.delta_apply.doc b/help/Docfiles/Lib.delta_apply.doc index a868b89d54..087e8b351f 100644 --- a/help/Docfiles/Lib.delta_apply.doc +++ b/help/Docfiles/Lib.delta_apply.doc @@ -17,8 +17,8 @@ returned. If {f x} raises exception {e}, then {delta_apply f x} raises {e}. \EXAMPLE -Suppose we want to write a function that replaces every even integer -in a list of pairs of integers with an odd one. The most basic +Suppose we want to write a function that replaces every even integer +in a list of pairs of integers with an odd one. The most basic replacement function is therefore { - fun ireplace i = if i mod 2 = 0 then DIFF (i+1) else SAME @@ -26,7 +26,7 @@ replacement function is therefore Applying {ireplace} to an arbitrary integer would yield an element of the {int delta} type. It's not seemingly useful, but it becomes useful when used with similar functions for type operators. -Then a delta function for pairs of integers is built by +Then a delta function for pairs of integers is built by {delta_pair ireplace ireplace}, and a delta function for a list of pairs of integers is built by applying {delta_map}. { @@ -38,7 +38,7 @@ pairs of integers is built by applying {delta_map}. [(1,3), (3,5), (5,7), (7,9)]; > val it = SAME : (int * int) list delta } -Finally, we can move the result from the {delta} type +Finally, we can move the result from the {delta} type to the actual type we are interested in. { - delta_apply (delta_map (delta_pair ireplace ireplace)) diff --git a/help/Docfiles/Lib.delta_map.doc b/help/Docfiles/Lib.delta_map.doc index 39184dfda3..9a16f68dbc 100644 --- a/help/Docfiles/Lib.delta_map.doc +++ b/help/Docfiles/Lib.delta_map.doc @@ -10,7 +10,7 @@ sharing. \DESCRIBE An application {delta_map f list} applies {f} to each member {[x1,...,xn]} -of {list}. If all applications of {f} return {SAME}, then {delta_map f list} +of {list}. If all applications of {f} return {SAME}, then {delta_map f list} returns {SAME}. Otherwise, {DIFF [y1,...,yn]} is returned. If {f xi} yielded {SAME}, then {yi} is {xi}. Otherwise, {f xi} equals {DIFF yi}. diff --git a/help/Docfiles/Lib.delta_pair.doc b/help/Docfiles/Lib.delta_pair.doc index 44be929fd1..0cbe6a2281 100644 --- a/help/Docfiles/Lib.delta_pair.doc +++ b/help/Docfiles/Lib.delta_pair.doc @@ -1,13 +1,13 @@ \DOC delta_pair \BLTYPE -delta_pair : ('a -> 'a delta) -> - ('b -> 'b delta) -> +delta_pair : ('a -> 'a delta) -> + ('b -> 'b delta) -> 'a * 'b -> ('a * 'b) delta \ELTYPE \SYNOPSIS -Apply two functions to the projections of a pair, sharing as much +Apply two functions to the projections of a pair, sharing as much structure as possible. \KEYWORDS @@ -17,7 +17,7 @@ sharing. An application {delta_pair f g (x,y)} applies {f} to {x} and {g} to {y}. If {f x} equals {g y} equals {SAME}, then {SAME} is returned. Otherwise {DIFF (p1,p2)} is returned, where {p1} is {x} if {f x} -equals {SAME}; otherwise {p1} is {f x}. Similarly, {p2} is {y} if {g y} +equals {SAME}; otherwise {p1} is {f x}. Similarly, {p2} is {y} if {g y} equals {SAME}; otherwise {p2} is {g y}. \FAILURE diff --git a/help/Docfiles/Lib.doc b/help/Docfiles/Lib.doc index d1bd020313..684232476e 100644 --- a/help/Docfiles/Lib.doc +++ b/help/Docfiles/Lib.doc @@ -6,7 +6,7 @@ Collection of commonly used functions. \DESCRIBE -{Lib} is a collection of functions that have been found useful in +{Lib} is a collection of functions that have been found useful in writing the HOL system. \COMMENTS diff --git a/help/Docfiles/Lib.end_time.doc b/help/Docfiles/Lib.end_time.doc index c7e0fc294b..632aff73dc 100644 --- a/help/Docfiles/Lib.end_time.doc +++ b/help/Docfiles/Lib.end_time.doc @@ -9,8 +9,8 @@ Check a running timer, and print out how long it has been running. time. \DESCRIBE -An application {end_time timer} looks to see how long {timer} has been -running, and prints out the elapsed runtime, garbage collection time, +An application {end_time timer} looks to see how long {timer} has been +running, and prints out the elapsed runtime, garbage collection time, and system time. \FAILURE @@ -21,7 +21,7 @@ Never fails. - val clock = start_time(); > val clock = : cpu_timer -- use "foo.sml"; +- use "foo.sml"; > ... output omitted ... - end_time clock; @@ -31,8 +31,8 @@ runtime: 525.996s, gctime: 0.000s, systime: 525.996s. \COMMENTS -A {start_time} ... {end_time} pair is for use when calling {time} -would be clumsy, e.g., when multiple function applications are to +A {start_time} ... {end_time} pair is for use when calling {time} +would be clumsy, e.g., when multiple function applications are to be timed. \SEEALSO diff --git a/help/Docfiles/Lib.exists.doc b/help/Docfiles/Lib.exists.doc index c0c853e79c..91a4b3a7e5 100644 --- a/help/Docfiles/Lib.exists.doc +++ b/help/Docfiles/Lib.exists.doc @@ -26,7 +26,7 @@ exception. In that case, {exists P l} raises an exception. > val it = false : bool - exists (fn _ => raise Fail "") [1]; -! Uncaught exception: +! Uncaught exception: ! Fail "" } diff --git a/help/Docfiles/Lib.for_se.doc b/help/Docfiles/Lib.for_se.doc index 95845e22ab..eb90c7d3a3 100644 --- a/help/Docfiles/Lib.for_se.doc +++ b/help/Docfiles/Lib.for_se.doc @@ -19,7 +19,7 @@ If {f i} fails for {b <= i <= t}. \EXAMPLE { - let val A = Array.array(26,#" ") - in + in for_se 0 25 (fn i => Array.update(A,i, Char.chr (i+97))) ; for_se 0 25 (print o Char.toString o curry Array.sub A) ; print "\n" diff --git a/help/Docfiles/Lib.hash.doc b/help/Docfiles/Lib.hash.doc index b37e96a11f..2b3002d03e 100644 --- a/help/Docfiles/Lib.hash.doc +++ b/help/Docfiles/Lib.hash.doc @@ -11,9 +11,9 @@ hash. \DESCRIBE An invocation {hash i s (j,k)} takes an integer {i} and uses that to construct a function that, given a string {s}, will produce values -approximately equally distributed among the numbers less than {i}. +approximately equally distributed among the numbers less than {i}. The argument {j} gives an index in the string to start from. The {k} -argument is an accumulator, which is useful when hashing a +argument is an accumulator, which is useful when hashing a collection of strings. \FAILURE diff --git a/help/Docfiles/Lib.index.doc b/help/Docfiles/Lib.index.doc index 0987c12385..41f579cec5 100644 --- a/help/Docfiles/Lib.index.doc +++ b/help/Docfiles/Lib.index.doc @@ -13,8 +13,8 @@ An application {index P l} returns the index (0-based) to the first element (in a left-to-right scan) of {l} that {P} holds of. \FAILURE -If {P} doesn't hold of any element of {l}, then {index P l} fails. -If {P x} fails for any {x} encountered in the scan, then +If {P} doesn't hold of any element of {l}, then {index P l} fails. +If {P x} fails for any {x} encountered in the scan, then {index P l} fails. \EXAMPLE diff --git a/help/Docfiles/Lib.int_sort.doc b/help/Docfiles/Lib.int_sort.doc index 1971d4c757..fb393a3be6 100644 --- a/help/Docfiles/Lib.int_sort.doc +++ b/help/Docfiles/Lib.int_sort.doc @@ -7,7 +7,7 @@ Sorts a list of integers using the {<=} relation. \DESCRIBE The call {int_sort list} is equal to {sort (curry (op <=))}. That is, -it is the specialization of {sort} to the usual notion of +it is the specialization of {sort} to the usual notion of less-than-or-equal on ML integers. \FAILURE diff --git a/help/Docfiles/Lib.istream.doc b/help/Docfiles/Lib.istream.doc index fd9307f957..aa6bb1df7c 100644 --- a/help/Docfiles/Lib.istream.doc +++ b/help/Docfiles/Lib.istream.doc @@ -9,8 +9,8 @@ Type of imperative streams. stream. \DESCRIBE -The type {('a,'b) istream} is an abstract type of imperative streams. -These may be created with {mk_istream}, advanced by {next}, +The type {('a,'b) istream} is an abstract type of imperative streams. +These may be created with {mk_istream}, advanced by {next}, accessed by {state}, and reset with {reset}. \COMMENTS diff --git a/help/Docfiles/Lib.itlist2.doc b/help/Docfiles/Lib.itlist2.doc index 124060a4bd..c56bf15e7c 100644 --- a/help/Docfiles/Lib.itlist2.doc +++ b/help/Docfiles/Lib.itlist2.doc @@ -15,11 +15,11 @@ list. { f x1 y1 (f x2 y2 ... (f xn yn z)...) } -An invocation {itlist2 f list1 list2 b} returns {b} if +An invocation {itlist2 f list1 list2 b} returns {b} if {list1} and {list2} are empty. \FAILURE -Fails if the two lists are of different lengths, or if one of the +Fails if the two lists are of different lengths, or if one of the applications of {f} fails. \EXAMPLE diff --git a/help/Docfiles/Lib.map2.doc b/help/Docfiles/Lib.map2.doc index 40964a3be9..eea21375ea 100644 --- a/help/Docfiles/Lib.map2.doc +++ b/help/Docfiles/Lib.map2.doc @@ -9,7 +9,7 @@ Maps a function over two lists to create one new list. {map2 f [x1,...,xn] [y1,...,yn]} returns {[f x1 y1,...,f xn yn]}. \FAILURE -Fails if the two lists are of different lengths. Also fails if any +Fails if the two lists are of different lengths. Also fails if any {f xi yi} fails. \EXAMPLE diff --git a/help/Docfiles/Lib.mapfilter.doc b/help/Docfiles/Lib.mapfilter.doc index 26b5d10404..4335308dae 100644 --- a/help/Docfiles/Lib.mapfilter.doc +++ b/help/Docfiles/Lib.mapfilter.doc @@ -10,7 +10,7 @@ for those elements for which application succeeds. list. \FAILURE -If {f x} raises {Interrupt} for some element {x} of {l}, then +If {f x} raises {Interrupt} for some element {x} of {l}, then {mapfilter f l} fails. \EXAMPLE diff --git a/help/Docfiles/Lib.mk_istream.doc b/help/Docfiles/Lib.mk_istream.doc index 3bc1d789c4..a86bb4a76b 100644 --- a/help/Docfiles/Lib.mk_istream.doc +++ b/help/Docfiles/Lib.mk_istream.doc @@ -11,7 +11,7 @@ stream, imperative. \DESCRIBE An application {mk_istream trans init proj} creates an imperative stream of elements. The stream is generated by applying {trans} to -the state. The first element in the stream state is {init}. +the state. The first element in the stream state is {init}. The value of the state is obtained by applying {proj}. \FAILURE @@ -26,7 +26,7 @@ The following creates a stream of distinct strings. \COMMENTS -It is aesthetically unpleasant that the underlying implementation +It is aesthetically unpleasant that the underlying implementation type is visible. See any book on ML programming to see how functional streams are built. diff --git a/help/Docfiles/Lib.mlquote.doc b/help/Docfiles/Lib.mlquote.doc index 5ba264ad26..d74f50319f 100644 --- a/help/Docfiles/Lib.mlquote.doc +++ b/help/Docfiles/Lib.mlquote.doc @@ -18,12 +18,12 @@ Never fails \EXAMPLE { -- print (quote "foo\nbar" ^ "\n"); +- print (quote "foo\nbar" ^ "\n"); "foo bar" > val it = () : unit -- print (mlquote "foo\nbar" ^ "\n"); +- print (mlquote "foo\nbar" ^ "\n"); "foo\nbar" > val it = () : unit } diff --git a/help/Docfiles/Lib.next.doc b/help/Docfiles/Lib.next.doc index d6d1ab9fb3..869e063815 100644 --- a/help/Docfiles/Lib.next.doc +++ b/help/Docfiles/Lib.next.doc @@ -12,7 +12,7 @@ stream. An application {next istrm} moves to the next element in the stream. \FAILURE -If the transition function supplied when building the stream fails on +If the transition function supplied when building the stream fails on the current state. \EXAMPLE diff --git a/help/Docfiles/Lib.partial.doc b/help/Docfiles/Lib.partial.doc index 18e50eb775..604898b6bd 100644 --- a/help/Docfiles/Lib.partial.doc +++ b/help/Docfiles/Lib.partial.doc @@ -31,7 +31,7 @@ When application of the second argument to the third argument returns {NONE}. > val it = NONE : int option - partial (Fail "not convertable") Int.fromString "foo"; -! Uncaught exception: +! Uncaught exception: ! Fail "not convertable" - (total o partial (Fail "not convertable")) Int.fromString "foo"; diff --git a/help/Docfiles/Lib.partition.doc b/help/Docfiles/Lib.partition.doc index 20676c97c8..3b85511fcf 100644 --- a/help/Docfiles/Lib.partition.doc +++ b/help/Docfiles/Lib.partition.doc @@ -10,7 +10,7 @@ list \DESCRIBE An invocation {partition P l} divides {l} into a pair of lists {(l1,l2)}. -{P} holds of each element of {l1}, and {P} does not hold of any element of +{P} holds of each element of {l1}, and {P} does not hold of any element of {l2}. \FAILURE @@ -28,7 +28,7 @@ If applying {P} to any element of {l} results in failure. > val it = ([], []) : int list * int list - partition (fn _ => raise Fail "") [1]; -! Uncaught exception: +! Uncaught exception: ! Fail "" } diff --git a/help/Docfiles/Lib.pluck.doc b/help/Docfiles/Lib.pluck.doc index b95ce7be0e..3b44c047ae 100644 --- a/help/Docfiles/Lib.pluck.doc +++ b/help/Docfiles/Lib.pluck.doc @@ -12,7 +12,7 @@ list An invocation {pluck P [x1,...,xk,...,xn]} returns a pair {(xk,[x1,...,xk-1,xk+1,...xn])}, where {xk} has been lifted out of the list without disturbing the relative positions of the other elements. For -this to happen, {P xk} must hold, and {P xi} must not have held for +this to happen, {P xk} must hold, and {P xi} must not have held for {x1,...,xk-1}. \FAILURE diff --git a/help/Docfiles/Lib.quote.doc b/help/Docfiles/Lib.quote.doc index f616b43682..3e92b14eac 100644 --- a/help/Docfiles/Lib.quote.doc +++ b/help/Docfiles/Lib.quote.doc @@ -17,7 +17,7 @@ Never fails \EXAMPLE { -- print "foo\n"; +- print "foo\n"; foo > val it = () : unit diff --git a/help/Docfiles/Lib.repeat.doc b/help/Docfiles/Lib.repeat.doc index d7aed68e07..ab420f14a0 100644 --- a/help/Docfiles/Lib.repeat.doc +++ b/help/Docfiles/Lib.repeat.doc @@ -19,7 +19,7 @@ resources are exhausted. \EXAMPLE The following gives a simple-minded way of calculating the largest integer -on the machine. +on the machine. { - fun incr x = x+1; > val incr = fn : int -> int @@ -27,7 +27,7 @@ on the machine. val maxint = repeat incr 0; (* takes some time *) > val maxint = 1073741823 : int } -(Caution: in some ML implementations, the type {int} is +(Caution: in some ML implementations, the type {int} is not implemented by machine words, but by `bignum' techniques that allow numbers of arbitrary size, in which case the example above will not return for a very long time.) diff --git a/help/Docfiles/Lib.rev_assoc.doc b/help/Docfiles/Lib.rev_assoc.doc index da7fc84f84..0c8b8c5435 100644 --- a/help/Docfiles/Lib.rev_assoc.doc +++ b/help/Docfiles/Lib.rev_assoc.doc @@ -11,9 +11,9 @@ list. \DESCRIBE An invocation {rev_assoc y [(x1,y1),...,(xn,yn)]} locates -the first {(xi,yi)} in a left-to-right scan of the list such that -{yi} equals {y}. Then {xi} is returned. The lookup is done on an eqtype, -i.e., the SML implementation must be able to decide equality for the type +the first {(xi,yi)} in a left-to-right scan of the list such that +{yi} equals {y}. Then {xi} is returned. The lookup is done on an eqtype, +i.e., the SML implementation must be able to decide equality for the type of {y}. \FAILURE diff --git a/help/Docfiles/Lib.sort.doc b/help/Docfiles/Lib.sort.doc index 5d904203d0..ec70bc791d 100644 --- a/help/Docfiles/Lib.sort.doc +++ b/help/Docfiles/Lib.sort.doc @@ -7,10 +7,10 @@ Sorts a list using a given transitive `ordering' relation. \DESCRIBE The call {sort opr list} where {opr} is a curried transitive relation -on the elements of {list}, will sort the list, i.e., will permute {list} +on the elements of {list}, will sort the list, i.e., will permute {list} such that if {x opr y} but not {y opr x} then {x} will -occur to the left of {y} in the sorted list. In particular if {opr} is -a total order, the result list will be sorted in the usual sense of the +occur to the left of {y} in the sorted list. In particular if {opr} is +a total order, the result list will be sorted in the usual sense of the word. \FAILURE diff --git a/help/Docfiles/Lib.split_after.doc b/help/Docfiles/Lib.split_after.doc index a9ead5ed66..2f8570bafc 100644 --- a/help/Docfiles/Lib.split_after.doc +++ b/help/Docfiles/Lib.split_after.doc @@ -30,7 +30,7 @@ If {k} is negative, or longer than the length of the list. > val it = ([1, 2, 3, 4, 5], []) : int list * int list - split_after 6 [1,2,3,4,5]; -! Uncaught exception: +! Uncaught exception: ! HOL_ERR - split_after 0 ([]:int list); diff --git a/help/Docfiles/Lib.start_time.doc b/help/Docfiles/Lib.start_time.doc index cf2e22c360..1dd342e72b 100644 --- a/help/Docfiles/Lib.start_time.doc +++ b/help/Docfiles/Lib.start_time.doc @@ -26,7 +26,7 @@ Never fails. \COMMENTS Multiple timers may be started without any interfering with the others. -Further operations associated with the type {cpu_timer} may be found +Further operations associated with the type {cpu_timer} may be found in the Standard ML Basis Library structures {Timer} and {Time}. \SEEALSO diff --git a/help/Docfiles/Lib.subst.doc b/help/Docfiles/Lib.subst.doc index 99029125d8..0769cf8f73 100644 --- a/help/Docfiles/Lib.subst.doc +++ b/help/Docfiles/Lib.subst.doc @@ -9,14 +9,14 @@ Type abbreviation for substitutions. substitutions. \DESCRIBE -The type {('a,'b) subst} abbreviates the type {{redex,residue} list}, +The type {('a,'b) subst} abbreviates the type {{redex,residue} list}, in which {redex} has type {'a} and {residue} has type {'b}. Usually, a {{redex,residue}} pair in a substition is interpreted as `replace occurrences of {redex} by {residue}'. \COMMENTS The different types of {redex} and {residue} components allows -flexibility, as in the rule of inference {SUBST}, which takes a +flexibility, as in the rule of inference {SUBST}, which takes a {(term,thm) subst} argument. \SEEALSO diff --git a/help/Docfiles/Lib.topsort.doc b/help/Docfiles/Lib.topsort.doc index dc40051041..a55ef02a0c 100644 --- a/help/Docfiles/Lib.topsort.doc +++ b/help/Docfiles/Lib.topsort.doc @@ -8,12 +8,12 @@ Topologically sorts a list using a given partial order relation. \DESCRIBE The call {topsort opr list} where {opr} is a curried partial order on the elements of {list}, will topologically sort the list, i.e., -will permute it such that if {x opr y} then {x} will occur to the left -of {y} in the resulting list. +will permute it such that if {x opr y} then {x} will occur to the left +of {y} in the resulting list. \FAILURE If {opr} fails when applied to {x} and {y} in {list}. Also, {topsort} -will fail if there is a chain of elements {x1,...,xn}, all in {list}, such +will fail if there is a chain of elements {x1,...,xn}, all in {list}, such that {opr x_1 x_2}, ..., {opr xn x1}. This displays a cyclic dependency. \EXAMPLE diff --git a/help/Docfiles/Lib.total.doc b/help/Docfiles/Lib.total.doc index 5b42ac82e3..b8b6dac09a 100644 --- a/help/Docfiles/Lib.total.doc +++ b/help/Docfiles/Lib.total.doc @@ -30,14 +30,14 @@ When application of the first argument to the second argument raises \EXAMPLE { - 3 div 0; -! Uncaught exception: +! Uncaught exception: ! Div - total (op div) (3,0); > val it = NONE : int option - (partial Div o total) (op div) (3,0); -! Uncaught exception: +! Uncaught exception: ! Div } diff --git a/help/Docfiles/Lib.try.doc b/help/Docfiles/Lib.try.doc index 36da23f6f4..807aabef04 100644 --- a/help/Docfiles/Lib.try.doc +++ b/help/Docfiles/Lib.try.doc @@ -12,7 +12,7 @@ exception, error, application The application {try f x} evaluates {f x}; if this evaluation raises an exception {e}, then {e} is examined and some information about it is printed before {e} is re-raised. If {f x} evaluates to {y}, then {y} is -returned. +returned. Often, a {HOL_ERR} exception can propagate all the way to the top level. Unfortunately, the information held in the exception is not then printed. @@ -24,14 +24,14 @@ When application of the first argument to the second raises an exception. \EXAMPLE { - mk_comb (T,F); -! Uncaught exception: +! Uncaught exception: ! HOL_ERR - try mk_comb (T,F); Exception raised at Term.mk_comb: incompatible types -! Uncaught exception: +! Uncaught exception: ! HOL_ERR } Evaluation order can be significant. ML evaluates {try M N} by @@ -43,14 +43,14 @@ abstraction is not detected by {try} and the exception propagates all the way to the top level; however, {Raise} does handle the exception. { - try mk_comb (T, mk_abs(T,T)); - ! Uncaught exception: + ! Uncaught exception: ! HOL_ERR - mk_comb (T, mk_abs(T,T)) handle e => Raise e; Exception raised at Term.mk_abs: Bvar not a variable - ! Uncaught exception: + ! Uncaught exception: ! HOL_ERR } diff --git a/help/Docfiles/Lib.trye.doc b/help/Docfiles/Lib.trye.doc index 81c9a50d15..4c08cb70a7 100644 --- a/help/Docfiles/Lib.trye.doc +++ b/help/Docfiles/Lib.trye.doc @@ -29,11 +29,11 @@ Fails if the function application fails. \EXAMPLE { - hd []; -! Uncaught exception: +! Uncaught exception: ! Empty - trye hd []; -! Uncaught exception: +! Uncaught exception: ! HOL_ERR - trye (fn _ => raise Interrupt) 1; diff --git a/help/Docfiles/Lib.trypluck.doc b/help/Docfiles/Lib.trypluck.doc index 6fa6fc9870..04c6984414 100644 --- a/help/Docfiles/Lib.trypluck.doc +++ b/help/Docfiles/Lib.trypluck.doc @@ -19,7 +19,7 @@ this to happen, {f(xk)} must hold, and {f(xi)} must fail for {x1,...,xk-1}. \FAILURE If the input list is empty. Also fails if {f} fails on every member of the -list. +list. \EXAMPLE { diff --git a/help/Docfiles/Lib.trypluckprime.doc b/help/Docfiles/Lib.trypluckprime.doc index e9fe6150ec..7b53e0edb5 100644 --- a/help/Docfiles/Lib.trypluckprime.doc +++ b/help/Docfiles/Lib.trypluckprime.doc @@ -22,7 +22,7 @@ returns {NONE}. This is an `option' version of the other library function {trypluck}. \FAILURE -Never fails. +Never fails. \SEEALSO Lib.first, Lib.filter, Lib.mapfilter, Lib.tryfind, Lib.trypluck. diff --git a/help/Docfiles/Lib.with_exn.doc b/help/Docfiles/Lib.with_exn.doc index 5071a6dfee..28f60d80b5 100644 --- a/help/Docfiles/Lib.with_exn.doc +++ b/help/Docfiles/Lib.with_exn.doc @@ -10,10 +10,10 @@ exception, application. \DESCRIBE An evaluation of {with_exn f x e} applies function {f} to -argument {x}. If that computation finishes with {y}, then {y} is -the result. Otherwise, {f x} raised an exception, and the exception -{e} is raised instead. However, if {f x} raises the {Interrupt} -exception, then {with_exn f x e} results in the {Interrupt} exception +argument {x}. If that computation finishes with {y}, then {y} is +the result. Otherwise, {f x} raised an exception, and the exception +{e} is raised instead. However, if {f x} raises the {Interrupt} +exception, then {with_exn f x e} results in the {Interrupt} exception being raised. \FAILURE @@ -22,7 +22,7 @@ When {f x} fails or is interrupted. \EXAMPLE { - with_exn dest_comb (Term`\x. x /\ y`) (Fail "My kingdom for a horse"); -! Uncaught exception: +! Uncaught exception: ! Fail "My kingdom for a horse" - with_exn (fn _ => raise Interrupt) 1 (Fail "My kingdom for a horse"); @@ -34,15 +34,15 @@ When {f x} fails or is interrupted. Often {with_exn} can be used to clean up programming where lots of exceptions may be handled. For example, taking apart a compound term of a certain desired form may fail at several places, but a uniform error -message is desired. +message is desired. { local val expected = mk_HOL_ERR "" "dest_quant" "expected !v.M or ?v.M" in fun dest_quant tm = let val (q,body) = with_exn dest_comb tm expected val (p as (v,M)) = with_exn dest_abs body expected - in - if q = universal orelse q = existential + in + if q = universal orelse q = existential then p else raise expected end diff --git a/help/Docfiles/Lib.with_flag.doc b/help/Docfiles/Lib.with_flag.doc index 7c7e0d1df6..7e11fdc4c3 100644 --- a/help/Docfiles/Lib.with_flag.doc +++ b/help/Docfiles/Lib.with_flag.doc @@ -9,12 +9,12 @@ Apply a function under a particular flag setting. Lib \DESCRIBE -An invocation {with_flag (r,v) f x} sets the reference variable {r} to -the value {v}, then evaluates {f x}, then resets {r} to its original value, +An invocation {with_flag (r,v) f x} sets the reference variable {r} to +the value {v}, then evaluates {f x}, then resets {r} to its original value, and returns the value of {f x}. \FAILURE -Fails if {f x} fails. In that case, {r} is reset to its original value +Fails if {f x} fails. In that case, {r} is reset to its original value before raising the exception from {f x}. \EXAMPLE diff --git a/help/Docfiles/PairRules.FILTER_PSTRIP_TAC.doc b/help/Docfiles/PairRules.FILTER_PSTRIP_TAC.doc index 95c912a9a8..47dd43897e 100644 --- a/help/Docfiles/PairRules.FILTER_PSTRIP_TAC.doc +++ b/help/Docfiles/PairRules.FILTER_PSTRIP_TAC.doc @@ -33,7 +33,7 @@ strips off the quantifier: A ?- v[p'/p] } where {p'} is a primed variant of the pair {p} that does not contain -any variables that appear free in the assumptions {A}. +any variables that appear free in the assumptions {A}. If {t} is a conjunction, no filtering is done and {FILTER_PSTRIP_TAC} simply splits the conjunction: { diff --git a/help/Docfiles/PairRules.GEN_PALPHA_CONV.doc b/help/Docfiles/PairRules.GEN_PALPHA_CONV.doc index 3042f2048c..fe509deb01 100644 --- a/help/Docfiles/PairRules.GEN_PALPHA_CONV.doc +++ b/help/Docfiles/PairRules.GEN_PALPHA_CONV.doc @@ -15,7 +15,7 @@ or other binder. \DESCRIBE The conversion {GEN_PALPHA_CONV} provides alpha conversion for lambda abstractions of the form {\p.t}, quantified terms of the forms {!p.t}, -{?p.t} or {?!p.t}, and epsilon terms of the form {@p.t}. +{?p.t} or {?!p.t}, and epsilon terms of the form {@p.t}. The renaming of pairs is as described for {PALPHA_CONV}. diff --git a/help/Docfiles/PairRules.HALF_MK_PABS.doc b/help/Docfiles/PairRules.HALF_MK_PABS.doc index 9ed1288fcc..d79e2a8c84 100644 --- a/help/Docfiles/PairRules.HALF_MK_PABS.doc +++ b/help/Docfiles/PairRules.HALF_MK_PABS.doc @@ -23,7 +23,7 @@ universally quantified equation, {HALF_MK_PABS} returns the theorem \FAILURE -Fails unless the theorem is a singly paired universally quantified equation +Fails unless the theorem is a singly paired universally quantified equation whose left-hand side is a function applied to the quantified pair, or if any of the variables in the quantified pair is free in that function. diff --git a/help/Docfiles/PairRules.LEFT_AND_PEXISTS_CONV.doc b/help/Docfiles/PairRules.LEFT_AND_PEXISTS_CONV.doc index e22f17d3a3..64ff52b88b 100644 --- a/help/Docfiles/PairRules.LEFT_AND_PEXISTS_CONV.doc +++ b/help/Docfiles/PairRules.LEFT_AND_PEXISTS_CONV.doc @@ -18,7 +18,7 @@ When applied to a term of the form {(?p. t) /\ u}, the conversion { |- (?p. t) /\ u = (?p'. t[p'/p] /\ u) } -where {p'} is a primed variant of the pair {p} that does not +where {p'} is a primed variant of the pair {p} that does not contains variables free in the input term. \FAILURE diff --git a/help/Docfiles/PairRules.LEFT_LIST_PBETA.doc b/help/Docfiles/PairRules.LEFT_LIST_PBETA.doc index 3f8b4e8a41..090230500e 100644 --- a/help/Docfiles/PairRules.LEFT_LIST_PBETA.doc +++ b/help/Docfiles/PairRules.LEFT_LIST_PBETA.doc @@ -13,7 +13,7 @@ Iteratively beta-reduces a top-level paired beta-redex on the left-hand side of an equation. \DESCRIBE -When applied to an equational theorem, {LEFT_LIST_PBETA} applies paired +When applied to an equational theorem, {LEFT_LIST_PBETA} applies paired beta-reduction over a top-level chain of beta-redexes to the left-hand side (only). Variables are renamed if necessary to avoid free variable capture. diff --git a/help/Docfiles/PairRules.LEFT_OR_PEXISTS_CONV.doc b/help/Docfiles/PairRules.LEFT_OR_PEXISTS_CONV.doc index 6ae8d1dbe1..671dacd9e2 100644 --- a/help/Docfiles/PairRules.LEFT_OR_PEXISTS_CONV.doc +++ b/help/Docfiles/PairRules.LEFT_OR_PEXISTS_CONV.doc @@ -18,7 +18,7 @@ When applied to a term of the form {(?p. t) \/ u}, the conversion { |- (?p. t) \/ u = (?p'. t[p'/p] \/ u) } -where {p'} is a primed variant of the pair {p} that does not +where {p'} is a primed variant of the pair {p} that does not contain any variables free in the input term. \FAILURE diff --git a/help/Docfiles/PairRules.PALPHA.doc b/help/Docfiles/PairRules.PALPHA.doc index d7865ed192..b0a66d8b12 100644 --- a/help/Docfiles/PairRules.PALPHA.doc +++ b/help/Docfiles/PairRules.PALPHA.doc @@ -20,7 +20,7 @@ alpha-equivalent, {ALPHA} returns the theorem {|- t1 = t1'}. |- t1 = t1' } -The difference between {PALPHA} and {ALPHA} is that +The difference between {PALPHA} and {ALPHA} is that {PALPHA} is prepared to consider pair structures of different structure to be alpha-equivalent. In its most trivial case this means that {PALPHA} can consider @@ -37,7 +37,7 @@ Fails unless the terms provided are alpha-equivalent. \COMMENTS -Alpha-converting a paired abstraction to a nonpaired abstraction +Alpha-converting a paired abstraction to a nonpaired abstraction can introduce instances of the terms {FST} and {SND}. A paired abstraction and a nonpaired abstraction will be considered equivalent by {PALPHA} if the nonpaired abstraction contains all @@ -57,7 +57,7 @@ For example: Exception raised at ??.failwith: PALPHA - ! Uncaught exception: + ! Uncaught exception: ! HOL_ERR } diff --git a/help/Docfiles/PairRules.PALPHA_CONV.doc b/help/Docfiles/PairRules.PALPHA_CONV.doc index fc85473b84..a549e344f2 100644 --- a/help/Docfiles/PairRules.PALPHA_CONV.doc +++ b/help/Docfiles/PairRules.PALPHA_CONV.doc @@ -37,7 +37,7 @@ The new bound pair and the old bound pair need not have the same structure. - PALPHA_CONV (Term `((wx:'a#'a),(y:'a,z:'a))`) (Term `\((a:'a,b:'a),(c:'a,d:'a)). (f a b c d):'a`); - > val it = |- (\((a,b),c,d). f a b c d) = + > val it = |- (\((a,b),c,d). f a b c d) = (\(wx,y,z). f (FST wx) (SND wx) y z) : thm } {PALPHA_CONV} recognises subpairs of a pair as variables @@ -51,15 +51,15 @@ and preserves structure accordingly. \COMMENTS -{PALPHA_CONV} will only ever add the terms {FST} and {SND}, i.e., it will -never remove them. This means that while {\(x,y). x + y} can be +{PALPHA_CONV} will only ever add the terms {FST} and {SND}, i.e., it will +never remove them. This means that while {\(x,y). x + y} can be converted to {\xy. (FST xy) + (SND xy)}, it can not be converted back again. \FAILURE {PALPHA_CONV q tm} fails if {q} is not a variable, -if {tm} is not an abstraction, or if {q} is a variable and -{tm} is the lambda abstraction {\p.t} but the types of {p} +if {tm} is not an abstraction, or if {q} is a variable and +{tm} is the lambda abstraction {\p.t} but the types of {p} and {q} differ. \SEEALSO diff --git a/help/Docfiles/PairRules.PBETA_CONV.doc b/help/Docfiles/PairRules.PBETA_CONV.doc index e3a235cf49..a4af745af7 100644 --- a/help/Docfiles/PairRules.PBETA_CONV.doc +++ b/help/Docfiles/PairRules.PBETA_CONV.doc @@ -28,7 +28,7 @@ much faster. \EXAMPLE {PBETA_CONV} will reduce applications with arbitrary structure. { - - PBETA_CONV + - PBETA_CONV (Term `((\((a:'a,b:'a),(c:'a,d:'a)). f a b c d) ((w,x),(y,z))):'a`); > val it = |- (\((a,b),c,d). f a b c d) ((w,x),y,z) = f w x y z : thm } @@ -36,16 +36,16 @@ much faster. {PBETA_CONV} does not require the structure of the argument and the bound pair to match. { - - PBETA_CONV + - PBETA_CONV (Term `((\((a:'a,b:'a),(c:'a,d:'a)). f a b c d) ((w,x),yz)):'a`); - > val it = |- (\((a,b),c,d). f a b c d) ((w,x),yz) = + > val it = |- (\((a,b),c,d). f a b c d) ((w,x),yz) = f w x (FST yz) (SND yz) : thm } {PBETA_CONV} regards component pairs of the bound pair as variables in their own right and preserves structure accordingly: { - - PBETA_CONV + - PBETA_CONV (Term `((\((a:'a,b:'a),(c:'a,d:'a)). f (a,b) (c,d)) (wx,(y,z))):'a`); > val it = |- (\((a,b),c,d). f (a,b) (c,d)) (wx,y,z) = f wx (y,z) : thm } diff --git a/help/Docfiles/PairRules.PCHOOSE_TAC.doc b/help/Docfiles/PairRules.PCHOOSE_TAC.doc index 903c1b42d9..5d1e33be2c 100644 --- a/help/Docfiles/PairRules.PCHOOSE_TAC.doc +++ b/help/Docfiles/PairRules.PCHOOSE_TAC.doc @@ -14,7 +14,7 @@ of a goal. \DESCRIBE When applied to a theorem {A' |- ?p. t} and a goal, {CHOOSE_TAC} adds -{t[p'/p]} to the assumptions of the goal, where {p'} is a variant of +{t[p'/p]} to the assumptions of the goal, where {p'} is a variant of the pair {p} which has no components free in the assumption list; normally {p'} is just {p}. { diff --git a/help/Docfiles/PairRules.PEXISTENCE.doc b/help/Docfiles/PairRules.PEXISTENCE.doc index 1f57a9e620..6e02792d67 100644 --- a/help/Docfiles/PairRules.PEXISTENCE.doc +++ b/help/Docfiles/PairRules.PEXISTENCE.doc @@ -13,7 +13,7 @@ Deduces paired existence from paired unique existence. \DESCRIBE When applied to a theorem with a paired unique-existentially quantified -conclusion, {EXISTENCE} returns the same theorem with normal paired +conclusion, {EXISTENCE} returns the same theorem with normal paired existential quantification over the same pair. { A |- ?!p. t diff --git a/help/Docfiles/PairRules.PEXISTS.doc b/help/Docfiles/PairRules.PEXISTS.doc index c7bf744547..7f1a1acd7a 100644 --- a/help/Docfiles/PairRules.PEXISTS.doc +++ b/help/Docfiles/PairRules.PEXISTS.doc @@ -40,7 +40,7 @@ The following examples illustrate the various uses of {PEXISTS}: - PEXISTS (Term`?(x,y). x + y = x + y`, Term`(1,2)`) (REFL (Term`1 + 2`)); > val it = |- ?(x,y). x + y = x + y : thm - - PEXISTS (Term`?(a:'a,b:'a). (a,b) = (a,b)`, Term`ab:'a#'a`) + - PEXISTS (Term`?(a:'a,b:'a). (a,b) = (a,b)`, Term`ab:'a#'a`) (REFL (Term `ab:'a#'a`)); > val it = |- ?(a,b). (a,b) = (a,b) : thm } diff --git a/help/Docfiles/PairRules.PEXISTS_AND_CONV.doc b/help/Docfiles/PairRules.PEXISTS_AND_CONV.doc index 98f7313925..8814c3fcbd 100644 --- a/help/Docfiles/PairRules.PEXISTS_AND_CONV.doc +++ b/help/Docfiles/PairRules.PEXISTS_AND_CONV.doc @@ -14,7 +14,7 @@ Moves a paired existential quantification inwards through a conjunction. \DESCRIBE When applied to a term of the form {?p. t /\ u}, where variables in {p} are not free in both {t} and {u}, {PEXISTS_AND_CONV} returns a theorem of one of -three forms, depending on occurrences of variables from {p} in {t} and {u}. +three forms, depending on occurrences of variables from {p} in {t} and {u}. If {p} contains variables free in {t} but none in {u}, then the theorem: { |- (?p. t /\ u) = (?p. t) /\ u @@ -33,7 +33,7 @@ then the result is: \FAILURE {PEXISTS_AND_CONV} fails if it is applied to a term not of the form -{?p. t /\ u}, or if it is applied to a term {?p. t /\ u} in which +{?p. t /\ u}, or if it is applied to a term {?p. t /\ u} in which variables in {p} are free in both {t} and {u}. \SEEALSO diff --git a/help/Docfiles/PairRules.PEXISTS_IMP.doc b/help/Docfiles/PairRules.PEXISTS_IMP.doc index 32471052d5..319eb5b8f5 100644 --- a/help/Docfiles/PairRules.PEXISTS_IMP.doc +++ b/help/Docfiles/PairRules.PEXISTS_IMP.doc @@ -24,7 +24,7 @@ provided no variable in {p} is free in the assumptions. \FAILURE -Fails if the theorem is not implicative, or if the term is not a paired +Fails if the theorem is not implicative, or if the term is not a paired structure of variables, of if any variable in the pair is free in the assumption list. diff --git a/help/Docfiles/PairRules.PEXISTS_TAC.doc b/help/Docfiles/PairRules.PEXISTS_TAC.doc index 6067bec278..29ec5ea0f6 100644 --- a/help/Docfiles/PairRules.PEXISTS_TAC.doc +++ b/help/Docfiles/PairRules.PEXISTS_TAC.doc @@ -9,7 +9,7 @@ tactic, quantifier, existential, choose, witness. pair \SYNOPSIS -Reduces paired existentially quantified goal to one involving a +Reduces paired existentially quantified goal to one involving a specific witness. \DESCRIBE diff --git a/help/Docfiles/PairRules.PEXISTS_UNIQUE_CONV.doc b/help/Docfiles/PairRules.PEXISTS_UNIQUE_CONV.doc index 85a841247a..65d043ae42 100644 --- a/help/Docfiles/PairRules.PEXISTS_UNIQUE_CONV.doc +++ b/help/Docfiles/PairRules.PEXISTS_UNIQUE_CONV.doc @@ -21,7 +21,7 @@ there is at most one value {p} for which {t[p]} holds. The theorem returned is: } where {p'} is a primed variant of the pair {p} none of the components of which appear free in the input term. Note that the quantified pair {p} -need not in fact appear free in the body of the input term. +need not in fact appear free in the body of the input term. For example, {PEXISTS_UNIQUE_CONV "?!(x,y). T"} returns the theorem: { diff --git a/help/Docfiles/PairRules.PFORALL_OR_CONV.doc b/help/Docfiles/PairRules.PFORALL_OR_CONV.doc index ab3c4d3cf7..0512793d4a 100644 --- a/help/Docfiles/PairRules.PFORALL_OR_CONV.doc +++ b/help/Docfiles/PairRules.PFORALL_OR_CONV.doc @@ -33,7 +33,7 @@ then the result is: \FAILURE {PFORALL_OR_CONV} fails if it is applied to a term not of the form -{!p. t \/ u}, or if it is applied to a term {!p. t \/ u} in which +{!p. t \/ u}, or if it is applied to a term {!p. t \/ u} in which variables from {p} are free in both {t} and {u}. \SEEALSO diff --git a/help/Docfiles/PairRules.PSELECT_EQ.doc b/help/Docfiles/PairRules.PSELECT_EQ.doc index 2574593165..0a43737610 100644 --- a/help/Docfiles/PairRules.PSELECT_EQ.doc +++ b/help/Docfiles/PairRules.PSELECT_EQ.doc @@ -32,8 +32,8 @@ provided no variable in {p} is free in the assumptions. \FAILURE -Fails if the conclusion of the theorem is not an equation, -of if {p} is not a paired structure of variables, +Fails if the conclusion of the theorem is not an equation, +of if {p} is not a paired structure of variables, or if any variable in {p} is free in {A}. \SEEALSO diff --git a/help/Docfiles/PairRules.PSKOLEM_CONV.doc b/help/Docfiles/PairRules.PSKOLEM_CONV.doc index 6181e69445..95b7770d0a 100644 --- a/help/Docfiles/PairRules.PSKOLEM_CONV.doc +++ b/help/Docfiles/PairRules.PSKOLEM_CONV.doc @@ -27,7 +27,7 @@ input term. Both {q} and any {pi} may be a paired structure of variables: { - PSKOLEM_CONV - (Term `!(x11:'a,x12:'a) (x21:'a,x22:'a). + (Term `!(x11:'a,x12:'a) (x21:'a,x22:'a). ?(y1:'a,y2:'a). tm x11 x12 x21 x21 y1 y2`); > val it = diff --git a/help/Docfiles/PairRules.PSPEC.doc b/help/Docfiles/PairRules.PSPEC.doc index 58e23408ce..6a38431a2c 100644 --- a/help/Docfiles/PairRules.PSPEC.doc +++ b/help/Docfiles/PairRules.PSPEC.doc @@ -35,7 +35,7 @@ or if {p} and {q} have different types. > val it = [.] |- 1 + 2 = 2 + 1 : thm } -{PSPEC} treats paired structures of variables as variables and +{PSPEC} treats paired structures of variables as variables and preserves structure accordingly. { - PSPEC (Term `x:'a#'a`) (ASSUME (Term `!(x:'a,y:'a). (x,y) = (x,y)`)); diff --git a/help/Docfiles/PairRules.PSPEC_TAC.doc b/help/Docfiles/PairRules.PSPEC_TAC.doc index ac181df6bb..e6ec62ca11 100644 --- a/help/Docfiles/PairRules.PSPEC_TAC.doc +++ b/help/Docfiles/PairRules.PSPEC_TAC.doc @@ -14,7 +14,7 @@ Generalizes a goal. \DESCRIBE When applied to a pair of terms {(q,p)}, where {p} is a paired structure of variables and a goal {A ?- t}, the tactic {PSPEC_TAC} generalizes the -goal to {A ?- !p. t[p/q]}, that is, all components of {q} are turned into +goal to {A ?- !p. t[p/q]}, that is, all components of {q} are turned into the corresponding components of {p}. { A ?- t @@ -40,7 +40,7 @@ OK.. 1 subgoal: > val it = !(x,y). x + y = y + x - + : proof } diff --git a/help/Docfiles/PairRules.PSTRIP_GOAL_THEN.doc b/help/Docfiles/PairRules.PSTRIP_GOAL_THEN.doc index e7efa1e518..09db54d8a5 100644 --- a/help/Docfiles/PairRules.PSTRIP_GOAL_THEN.doc +++ b/help/Docfiles/PairRules.PSTRIP_GOAL_THEN.doc @@ -48,7 +48,7 @@ Finally, a negation {~t} is treated as the implication {t ==> F}. \FAILURE {PSTRIP_GOAL_THEN ttac (A,t)} fails if {t} is not a paired universally -quantified term, an implication, a negation or a conjunction. +quantified term, an implication, a negation or a conjunction. Failure also occurs if the application of {ttac} fails, after stripping the goal. diff --git a/help/Docfiles/PairRules.PSTRIP_TAC.doc b/help/Docfiles/PairRules.PSTRIP_TAC.doc index 1832c43f2e..2126d3f753 100644 --- a/help/Docfiles/PairRules.PSTRIP_TAC.doc +++ b/help/Docfiles/PairRules.PSTRIP_TAC.doc @@ -12,7 +12,7 @@ pair Splits a goal by eliminating one outermost connective. \DESCRIBE -Given a goal {(A,t)}, {PSTRIP_TAC} removes one outermost occurrence of one of +Given a goal {(A,t)}, {PSTRIP_TAC} removes one outermost occurrence of one of the connectives {!}, {==>}, {~} or {/\} from the conclusion of the goal {t}. If {t} is a universally quantified term, then {STRIP_TAC} strips off the quantifier. Note that {PSTRIP_TAC} will strip off paired quantifications. diff --git a/help/Docfiles/PairRules.PSTRIP_THM_THEN.doc b/help/Docfiles/PairRules.PSTRIP_THM_THEN.doc index f9f27a5d08..367c089357 100644 --- a/help/Docfiles/PairRules.PSTRIP_THM_THEN.doc +++ b/help/Docfiles/PairRules.PSTRIP_THM_THEN.doc @@ -15,7 +15,7 @@ stripping off one outer connective from the given theorem. \DESCRIBE Given a theorem-tactic {ttac}, a theorem {th} whose conclusion is a conjunction, a disjunction or a paired existentially quantified term, -and a goal {(A,t)}, {STRIP_THM_THEN ttac th} first strips apart the +and a goal {(A,t)}, {STRIP_THM_THEN ttac th} first strips apart the conclusion of {th}, next applies {ttac} to the theorem(s) resulting from the stripping and then applies the resulting tactic to the goal. @@ -41,7 +41,7 @@ then: When stripping a paired existentially quantified theorem {A'|- ?p. u}, the tactic resulting from applying {ttac} to the body of the paired existential quantification, {ttac(u|-u)}, -is applied to the goal. +is applied to the goal. That is, if: { A ?- t diff --git a/help/Docfiles/PairRules.PSUB_CONV.doc b/help/Docfiles/PairRules.PSUB_CONV.doc index 06d81fd1d1..2bf853aedc 100644 --- a/help/Docfiles/PairRules.PSUB_CONV.doc +++ b/help/Docfiles/PairRules.PSUB_CONV.doc @@ -34,7 +34,7 @@ conversion on variables and constants. That is, if {"t"} is a variable or constant, then {PSUB_CONV c "t"} returns {|- t = t}. \FAILURE -{PSUB_CONV c tm} fails if {tm} is a paired abstraction {"\p.t"} and the +{PSUB_CONV c tm} fails if {tm} is a paired abstraction {"\p.t"} and the conversion {c} fails when applied to {t}, or if {tm} is an application {"t1 t2"} and the conversion {c} fails when applied to either {t1} or {t2}. The function diff --git a/help/Docfiles/PairRules.P_FUN_EQ_CONV.doc b/help/Docfiles/PairRules.P_FUN_EQ_CONV.doc index 658bfd99e9..b27ff19c6a 100644 --- a/help/Docfiles/PairRules.P_FUN_EQ_CONV.doc +++ b/help/Docfiles/PairRules.P_FUN_EQ_CONV.doc @@ -24,9 +24,9 @@ a call to {P_FUN_EQ_CONV "p" "f = g"} returns the theorem: \FAILURE {P_FUN_EQ_CONV p tm} fails if {p} is not a paired structure of variables -or if {tm} is not an equation {f = g} where {f} and {g} are functions. +or if {tm} is not an equation {f = g} where {f} and {g} are functions. Furthermore, if {f} and {g} are functions of type {ty1->ty2}, -then the pair {x} must have type {ty1}; otherwise the conversion fails. +then the pair {x} must have type {ty1}; otherwise the conversion fails. Finally, failure also occurs if any of the variables in {p} is free in either {f} or {g}. diff --git a/help/Docfiles/PairRules.P_PCHOOSE_TAC.doc b/help/Docfiles/PairRules.P_PCHOOSE_TAC.doc index 691ae1855b..851281f153 100644 --- a/help/Docfiles/PairRules.P_PCHOOSE_TAC.doc +++ b/help/Docfiles/PairRules.P_PCHOOSE_TAC.doc @@ -26,10 +26,10 @@ the pair {p} whose existence is asserted in the theorem. \FAILURE Fails if the theorem's conclusion is not a paired existential quantification, -or if the first argument is not a paired structure of variables. -Failures may arise in the tactic-generating function. +or if the first argument is not a paired structure of variables. +Failures may arise in the tactic-generating function. An invalid tactic is produced if the introduced variable is free in {u} or {t}, -or if the theorem has any hypothesis which is not alpha-convertible to an +or if the theorem has any hypothesis which is not alpha-convertible to an assumption of the goal. \SEEALSO diff --git a/help/Docfiles/PairRules.P_PCHOOSE_THEN.doc b/help/Docfiles/PairRules.P_PCHOOSE_THEN.doc index 2fdf207e61..ef064f97a3 100644 --- a/help/Docfiles/PairRules.P_PCHOOSE_THEN.doc +++ b/help/Docfiles/PairRules.P_PCHOOSE_THEN.doc @@ -36,8 +36,8 @@ goal {(A ?- t)} produces the subgoal: \FAILURE Fails if the theorem's conclusion is not existentially quantified, or if -the first argument is not a paired structure of variables. -Failures may arise in the tactic-generating function. +the first argument is not a paired structure of variables. +Failures may arise in the tactic-generating function. An invalid tactic is produced if the introduced variable is free in {u} or {t}, or if the theorem has any hypothesis which is not alpha-convertible to an assumption of the goal. diff --git a/help/Docfiles/PairRules.P_PSKOLEM_CONV.doc b/help/Docfiles/PairRules.P_PSKOLEM_CONV.doc index e3474955c8..c04412b0f5 100644 --- a/help/Docfiles/PairRules.P_PSKOLEM_CONV.doc +++ b/help/Docfiles/PairRules.P_PSKOLEM_CONV.doc @@ -14,7 +14,7 @@ Introduces a user-supplied Skolem function. \DESCRIBE {P_PSKOLEM_CONV} takes two arguments. The first is a variable {f}, which must range over functions of the appropriate type, and the second is a term of -the form {!p1...pn. ?q. t} (where {pi} and {q} may be pairs). +the form {!p1...pn. ?q. t} (where {pi} and {q} may be pairs). Given these arguments, {P_PSKOLEM_CONV} returns the theorem: { |- (!p1...pn. ?q. t) = (?f. !p1...pn. tm[f p1 ... pn/q]) diff --git a/help/Docfiles/PairRules.RIGHT_AND_PFORALL_CONV.doc b/help/Docfiles/PairRules.RIGHT_AND_PFORALL_CONV.doc index edb91819d3..995de2b31b 100644 --- a/help/Docfiles/PairRules.RIGHT_AND_PFORALL_CONV.doc +++ b/help/Docfiles/PairRules.RIGHT_AND_PFORALL_CONV.doc @@ -18,7 +18,7 @@ When applied to a term of the form {t /\ (!p. u)}, the conversion { |- t /\ (!p. u) = (!p'. t /\ (u[p'/p])) } -where {p'} is a primed variant of the pair {p} that does not +where {p'} is a primed variant of the pair {p} that does not contain any variables free in the input term. \FAILURE diff --git a/help/Docfiles/PairRules.RIGHT_IMP_PEXISTS_CONV.doc b/help/Docfiles/PairRules.RIGHT_IMP_PEXISTS_CONV.doc index 426c389ce2..51b4db5c50 100644 --- a/help/Docfiles/PairRules.RIGHT_IMP_PEXISTS_CONV.doc +++ b/help/Docfiles/PairRules.RIGHT_IMP_PEXISTS_CONV.doc @@ -13,7 +13,7 @@ Moves a paired existential quantification of the consequent outwards through an implication. \DESCRIBE -When applied to a term of the form {t ==> (?p. u)}, +When applied to a term of the form {t ==> (?p. u)}, {RIGHT_IMP_PEXISTS_CONV} returns the theorem: { |- t ==> (?p. u) = (?p'. t ==> (u[p'/p])) diff --git a/help/Docfiles/PairRules.RIGHT_LIST_PBETA.doc b/help/Docfiles/PairRules.RIGHT_LIST_PBETA.doc index 90fa42c956..bd364955e6 100644 --- a/help/Docfiles/PairRules.RIGHT_LIST_PBETA.doc +++ b/help/Docfiles/PairRules.RIGHT_LIST_PBETA.doc @@ -13,7 +13,7 @@ Iteratively beta-reduces a top-level paired beta-redex on the right-hand side of an equation. \DESCRIBE -When applied to an equational theorem, {RIGHT_LIST_PBETA} applies paired +When applied to an equational theorem, {RIGHT_LIST_PBETA} applies paired beta-reduction over a top-level chain of beta-redexes to the right-hand side (only). Variables are renamed if necessary to avoid free variable capture. diff --git a/help/Docfiles/PairRules.RIGHT_OR_PEXISTS_CONV.doc b/help/Docfiles/PairRules.RIGHT_OR_PEXISTS_CONV.doc index 1bb3eef597..1c330c06df 100644 --- a/help/Docfiles/PairRules.RIGHT_OR_PEXISTS_CONV.doc +++ b/help/Docfiles/PairRules.RIGHT_OR_PEXISTS_CONV.doc @@ -18,7 +18,7 @@ When applied to a term of the form {t \/ (?p. u)}, the conversion { |- t \/ (?p. u) = (?p'. t \/ (u[p'/p])) } -where {p'} is a primed variant of the pair {p} that does not +where {p'} is a primed variant of the pair {p} that does not contain any variables free in the input term. \FAILURE diff --git a/help/Docfiles/PairRules.RIGHT_PBETA.doc b/help/Docfiles/PairRules.RIGHT_PBETA.doc index 17c04b1f6b..658860c7ca 100644 --- a/help/Docfiles/PairRules.RIGHT_PBETA.doc +++ b/help/Docfiles/PairRules.RIGHT_PBETA.doc @@ -9,7 +9,7 @@ rule. pair \SYNOPSIS -Beta-reduces a top-level paired beta-redex on the right-hand side of an +Beta-reduces a top-level paired beta-redex on the right-hand side of an equation. \DESCRIBE diff --git a/help/Docfiles/PairRules.UNCURRY_CONV.doc b/help/Docfiles/PairRules.UNCURRY_CONV.doc index 1797a7391c..8f9086f2a6 100644 --- a/help/Docfiles/PairRules.UNCURRY_CONV.doc +++ b/help/Docfiles/PairRules.UNCURRY_CONV.doc @@ -16,7 +16,7 @@ Uncurrys an application of an abstraction. \FAILURE -{UNCURRY_CONV tm} fails if {tm} is not double abstraction applied to two +{UNCURRY_CONV tm} fails if {tm} is not double abstraction applied to two arguments \SEEALSO diff --git a/help/Docfiles/PairedLambda.PAIRED_BETA_CONV.doc b/help/Docfiles/PairedLambda.PAIRED_BETA_CONV.doc index 7139da126c..ac9cf6f579 100644 --- a/help/Docfiles/PairedLambda.PAIRED_BETA_CONV.doc +++ b/help/Docfiles/PairedLambda.PAIRED_BETA_CONV.doc @@ -63,7 +63,7 @@ use {BETA_CONV}, or {GEN_BETA_CONV}. \EXAMPLE The following is a typical use of the conversion: { - - PairedLambda.PAIRED_BETA_CONV + - PairedLambda.PAIRED_BETA_CONV (Term `(\((a,b),(c,d)). a + b + c + d) ((1,2),(3,4))`); > val it = |- (\((a,b),c,d). a+b+c+d) ((1,2),3,4) = 1+2+3+4 : thm } @@ -71,15 +71,15 @@ Note that the term to which the tupled lambda abstraction is applied must have the same structure as the varstruct. For example, the following succeeds: { - - PairedLambda.PAIRED_BETA_CONV + - PairedLambda.PAIRED_BETA_CONV (Term `(\((a,b),p). a + b) ((1,2),(3+5,4))`); > val it = |- (\((a,b),p). a + b)((1,2),3 + 5,4) = 1 + 2 : thm } but the following call fails: { - - PairedLambda.PAIRED_BETA_CONV + - PairedLambda.PAIRED_BETA_CONV (Term `(\((a,b),(c,d)). a + b + c + d) ((1,2),p)`); - ! Uncaught exception: + ! Uncaught exception: ! HOL_ERR } because {p} is not a pair. diff --git a/help/Docfiles/Parse.Absyn.doc b/help/Docfiles/Parse.Absyn.doc index 5fc3f0aad0..6a29e67bcc 100644 --- a/help/Docfiles/Parse.Absyn.doc +++ b/help/Docfiles/Parse.Absyn.doc @@ -14,7 +14,7 @@ Parse \DESCRIBE {Absyn} takes a quotation and parses it into an abstract syntax tree of type {absyn}, using the current term and type grammars. -This phase of parsing is unconcerned with types, and will happily +This phase of parsing is unconcerned with types, and will happily parse meaningless expressions that are syntactically valid. \EXAMPLE diff --git a/help/Docfiles/Parse.ty_antiq.doc b/help/Docfiles/Parse.ty_antiq.doc index e708287337..ca52b2fc3e 100644 --- a/help/Docfiles/Parse.ty_antiq.doc +++ b/help/Docfiles/Parse.ty_antiq.doc @@ -8,14 +8,14 @@ Make a variable named {ty_antiq}. \DESCRIBE Given a type {ty}, the ML invocation {ty_antiq ty} returns the HOL variable -{ty_antiq : ty}. This provides a way to antiquote types into terms, -which is necessary because the HOL term parser only allows terms to +{ty_antiq : ty}. This provides a way to antiquote types into terms, +which is necessary because the HOL term parser only allows terms to be antiquoted. The use of {ty_antiq} promotes a type to a term variable -which can be antiquoted. The HOL parser detects occurrences of +which can be antiquoted. The HOL parser detects occurrences of {ty_antiq ty} and inserts {ty} as a constraint. \EXAMPLE -Suppose we want to constrain a term to have type {num list}, which is +Suppose we want to constrain a term to have type {num list}, which is bound to ML value {ty}. Attempting to antiquote ty directly into the term won't work: { diff --git a/help/Docfiles/Prim_rec.new_recursive_definition.doc b/help/Docfiles/Prim_rec.new_recursive_definition.doc index 09d979cc92..f31a40028e 100644 --- a/help/Docfiles/Prim_rec.new_recursive_definition.doc +++ b/help/Docfiles/Prim_rec.new_recursive_definition.doc @@ -47,7 +47,7 @@ automatically proves the existence of a function {fn} that satisfies the defining equations supplied as the fourth argument, and then declares a new constant in the current theory with this definition as its specification. This constant specification is returned as a theorem and is saved in the current -theory segment under the name {name}. +theory segment under the name {name}. {new_recursive_definition} also allows the supplied definition to omit clauses for any number of constructors. If a defining equation for the {i}th @@ -99,7 +99,7 @@ tree: rec_axiom = th, def = --`(IsLeaf (NODE t1 t2) = F) /\ (IsLeaf (LEAF (x:'a)) = T)`--}; -> val IsLeaf = |- (!t1 t2. IsLeaf (NODE t1 t2) = F) /\ +> val IsLeaf = |- (!t1 t2. IsLeaf (NODE t1 t2) = F) /\ !x. IsLeaf (LEAF x) = T : thm } Note that the equations defining a (recursive or non-recursive) @@ -136,7 +136,7 @@ expresses the idea that one tree is a proper subtree of another. > val Subtree = |- (!t x. t << LEAF x = F) /\ !t t1 t2. - t << NODE t1 t2 = (t = t1) \/ (t = t2) \/ + t << NODE t1 t2 = (t = t1) \/ (t = t2) \/ (t << t1) \/ (t << t2) : thm } Note that the fixity of the identifier {<<} is set independently of diff --git a/help/Docfiles/Rewrite.ONCE_ASM_REWRITE_TAC.doc b/help/Docfiles/Rewrite.ONCE_ASM_REWRITE_TAC.doc index 9bac5465b7..d5897842a6 100644 --- a/help/Docfiles/Rewrite.ONCE_ASM_REWRITE_TAC.doc +++ b/help/Docfiles/Rewrite.ONCE_ASM_REWRITE_TAC.doc @@ -28,7 +28,7 @@ performed is illustrated below: - ONCE_ASM_REWRITE_TAC [] ([Term` (a:'a) = b`, Term `(b:'a) = c`], Term `P (a:'a): bool`); - > val it = ([([`a = b`, `b = c`], `P b`)], fn) + > val it = ([([`a = b`, `b = c`], `P b`)], fn) : (term list * term) list * (thm list -> thm) } diff --git a/help/Docfiles/Rewrite.PURE_REWRITE_TAC.doc b/help/Docfiles/Rewrite.PURE_REWRITE_TAC.doc index b8ae33af7e..b1db2d10ae 100644 --- a/help/Docfiles/Rewrite.PURE_REWRITE_TAC.doc +++ b/help/Docfiles/Rewrite.PURE_REWRITE_TAC.doc @@ -36,11 +36,11 @@ It might be necessary, say for subsequent application of an induction hypothesis, to resist reducing a term {b = T} to {b}. { - PURE_REWRITE_TAC [] ([], Term `b = T`); - > val it = ([([], `b = T`)], fn) + > val it = ([([], `b = T`)], fn) : (term list * term) list * (thm list -> thm) - REWRITE_TAC [] ([], Term `b = T`); - > val it = ([([], `b`)], fn) + > val it = ([([], `b`)], fn) : (term list * term) list * (thm list -> thm) } diff --git a/help/Docfiles/Rewrite.REWRITE_CONV.doc b/help/Docfiles/Rewrite.REWRITE_CONV.doc index 7ab195328f..8c51970924 100644 --- a/help/Docfiles/Rewrite.REWRITE_CONV.doc +++ b/help/Docfiles/Rewrite.REWRITE_CONV.doc @@ -18,7 +18,7 @@ ordering specified among the set of rewrites. Variants of this conversion allow changes in the set of equations used: {PURE_REWRITE_CONV} and others in its family do not rewrite with the -theorems in {implicit_rewrites}. +theorems in {implicit_rewrites}. The top-down recursive search for matches may not be desirable, as this may increase the number of inferences being made or may result in diff --git a/help/Docfiles/Rewrite.bool_rewrites.doc b/help/Docfiles/Rewrite.bool_rewrites.doc index 7a0974d391..2fadc06f3e 100644 --- a/help/Docfiles/Rewrite.bool_rewrites.doc +++ b/help/Docfiles/Rewrite.bool_rewrites.doc @@ -6,7 +6,7 @@ Contains a number of basic equalities useful in rewriting. \DESCRIBE -The variable {bool_rewrites} is a basic collection of rewrite rules +The variable {bool_rewrites} is a basic collection of rewrite rules useful in expression simplification. The current collection is { - bool_rewrites; @@ -26,7 +26,7 @@ useful in expression simplification. The current collection is \USES -The contents of {bool_rewrites} provide a standard basis upon which to +The contents of {bool_rewrites} provide a standard basis upon which to build bespoke rewrite rule sets for use by the functions in {Rewrite}. \SEEALSO diff --git a/help/Docfiles/Rewrite.implicit_rewrites.doc b/help/Docfiles/Rewrite.implicit_rewrites.doc index efdd76974b..1cf0ba55d7 100644 --- a/help/Docfiles/Rewrite.implicit_rewrites.doc +++ b/help/Docfiles/Rewrite.implicit_rewrites.doc @@ -13,8 +13,8 @@ Rewrite \DESCRIBE The variable {implicit_rewrites} holds a collection of rewrite rules -commonly used to simplify expressions. These rules include the clause -for reflexivity: +commonly used to simplify expressions. These rules include the clause +for reflexivity: { |- !x. (x = x) = T } @@ -65,13 +65,13 @@ universally and existentially quantified variables and abstractions: |- !t1 t2. (\x. t1)t2 = t1 } -The value of {implicit_rewrites} can be augmented by +The value of {implicit_rewrites} can be augmented by {add_implicit_rewrites} and altered by {set_implicit_rewrites}. The initial value of {implicit_rewrites} is {bool_rewrites}. \USES -The rewrite rules held in {implicit_rewrites} are automatically +The rewrite rules held in {implicit_rewrites} are automatically included in the simplifications performed by some of the rewriting tools. \SEEALSO diff --git a/help/Docfiles/Tactic.ASM_CASES_TAC.doc b/help/Docfiles/Tactic.ASM_CASES_TAC.doc index 905b8effd8..2be2dfa311 100644 --- a/help/Docfiles/Tactic.ASM_CASES_TAC.doc +++ b/help/Docfiles/Tactic.ASM_CASES_TAC.doc @@ -42,7 +42,7 @@ on {u}: ASM_CASES_TAC u ([],g) end; - ([([`u`], `P u`), + ([([`u`], `P u`), ([`~u`], `P u`)], fn) : tactic_result } diff --git a/help/Docfiles/Tactic.ASSUME_TAC.doc b/help/Docfiles/Tactic.ASSUME_TAC.doc index f64b2d9086..ff9ebcd853 100644 --- a/help/Docfiles/Tactic.ASSUME_TAC.doc +++ b/help/Docfiles/Tactic.ASSUME_TAC.doc @@ -61,7 +61,7 @@ assumptions of {g}: end; val it = - ([([`!x y z. (x = y) /\ (y = z) ==> (x = z)`, + ([([`!x y z. (x = y) /\ (y = z) ==> (x = z)`, `x = y`,`y = z`],`P`)],fn) : tactic_result } diff --git a/help/Docfiles/Tactic.CCONTR_TAC.doc b/help/Docfiles/Tactic.CCONTR_TAC.doc index 9a5265b787..de859062b2 100644 --- a/help/Docfiles/Tactic.CCONTR_TAC.doc +++ b/help/Docfiles/Tactic.CCONTR_TAC.doc @@ -10,7 +10,7 @@ tactic, contradiction. \DESCRIBE {CCONTR_TAC} takes a theorem {A' |- F} and completely solves the goal. -This is an invalid tactic unless {A'} is a subset of {A}. +This is an invalid tactic unless {A'} is a subset of {A}. { A ?- t ======== CCONTR_TAC (A' |- F) diff --git a/help/Docfiles/Tactic.MK_COMB_TAC.doc b/help/Docfiles/Tactic.MK_COMB_TAC.doc index 37781df302..edf5d5daa7 100644 --- a/help/Docfiles/Tactic.MK_COMB_TAC.doc +++ b/help/Docfiles/Tactic.MK_COMB_TAC.doc @@ -3,7 +3,7 @@ \TYPE {MK_COMB_TAC : tactic} \SYNOPSIS -Breaks an equality between applications into two equality goals: one +Breaks an equality between applications into two equality goals: one for the functions, and other for the arguments. \LIBRARY diff --git a/help/Docfiles/Tactic.NTAC.doc b/help/Docfiles/Tactic.NTAC.doc index 7109b0b68d..87f444ad08 100644 --- a/help/Docfiles/Tactic.NTAC.doc +++ b/help/Docfiles/Tactic.NTAC.doc @@ -9,11 +9,11 @@ Apply tactic a specified number of times. tactic. \DESCRIBE -An invocation {NTAC n tac} applies the tactic {tac} +An invocation {NTAC n tac} applies the tactic {tac} exactly {n} times. If {n <= 0} then the goal is unchanged. \FAILURE -Fails if {tac} fails. +Fails if {tac} fails. \EXAMPLE Suppose we have the following goal: diff --git a/help/Docfiles/Tactic.STRIP_TAC.doc b/help/Docfiles/Tactic.STRIP_TAC.doc index 9ced24cd70..15b30757b1 100644 --- a/help/Docfiles/Tactic.STRIP_TAC.doc +++ b/help/Docfiles/Tactic.STRIP_TAC.doc @@ -61,6 +61,6 @@ When trying to solve a goal, often the best thing to do first is {REPEAT STRIP_TAC} to split the goal up into manageable pieces. \SEEALSO -Tactic.CONJ_TAC, Tactic.DISCH_TAC, Thm_cont.DISCH_THEN, Tactic.GEN_TAC, +Tactic.CONJ_TAC, Tactic.DISCH_TAC, Thm_cont.DISCH_THEN, Tactic.GEN_TAC, Tactic.STRIP_ASSUME_TAC, Tactic.STRIP_GOAL_THEN. \ENDDOC diff --git a/help/Docfiles/Tactic.SUBST_OCCS_TAC.doc b/help/Docfiles/Tactic.SUBST_OCCS_TAC.doc index 3cfab618e5..105da270c7 100644 --- a/help/Docfiles/Tactic.SUBST_OCCS_TAC.doc +++ b/help/Docfiles/Tactic.SUBST_OCCS_TAC.doc @@ -42,7 +42,7 @@ When trying to solve the goal applying the commutative law for addition on the third occurrence of the subterm {m + n} { - SUBST_OCCS_TAC [([3], SPECL [Term `m:num`, Term `n:num`] + SUBST_OCCS_TAC [([3], SPECL [Term `m:num`, Term `n:num`] arithmeticTheory.ADD_SYM)] } results in the goal @@ -53,8 +53,8 @@ results in the goal \USES {SUBST_OCCS_TAC} is used when rewriting a goal at specific occurrences -of a term, and when rewriting tactics such as {REWRITE_TAC}, -{PURE_REWRITE_TAC}, {ONCE_REWRITE_TAC}, {SUBST_TAC}, etc. +of a term, and when rewriting tactics such as {REWRITE_TAC}, +{PURE_REWRITE_TAC}, {ONCE_REWRITE_TAC}, {SUBST_TAC}, etc. are too extensive or would diverge. \SEEALSO diff --git a/help/Docfiles/Tactic.WEAKEN_TAC.doc b/help/Docfiles/Tactic.WEAKEN_TAC.doc index c269dc336a..dbb7596a45 100644 --- a/help/Docfiles/Tactic.WEAKEN_TAC.doc +++ b/help/Docfiles/Tactic.WEAKEN_TAC.doc @@ -9,9 +9,9 @@ Deletes assumption from goal. tactic, assumption. \DESCRIBE -Given an ML predicate {P} mapping terms to {true} or {false} and -a goal {(asl,g)}, an invocation {WEAKEN_TAC P (asl,g)} removes the -first element (call it {tm}) that {P} holds of from {asl}, returning +Given an ML predicate {P} mapping terms to {true} or {false} and +a goal {(asl,g)}, an invocation {WEAKEN_TAC P (asl,g)} removes the +first element (call it {tm}) that {P} holds of from {asl}, returning the goal {(asl - tm,g)}. \FAILURE diff --git a/help/Docfiles/Tactic.irule.doc b/help/Docfiles/Tactic.irule.doc index 7f9571b73f..56581f3a6b 100644 --- a/help/Docfiles/Tactic.irule.doc +++ b/help/Docfiles/Tactic.irule.doc @@ -46,7 +46,7 @@ Then {prim_irule} is applied. To avoid this preprocessing just use {prim_irule}. The order of the new subgoals depends on the order in which the hypotheses of -the pre-processed theorem (before the substitution) are stored. +the pre-processed theorem (before the substitution) are stored. See {prim_irule}. \EXAMPLE diff --git a/help/Docfiles/Tactic.prim_irule.doc b/help/Docfiles/Tactic.prim_irule.doc index e81e30aead..a3ecbbc1ed 100644 --- a/help/Docfiles/Tactic.prim_irule.doc +++ b/help/Docfiles/Tactic.prim_irule.doc @@ -10,13 +10,13 @@ replace the goal by the instantiated hypotheses of the supplied theorem. tactic. \DESCRIBE -When given a theorem {th = A' |- t} and a goal {A ?- t'} +When given a theorem {th = A' |- t} and a goal {A ?- t'} where {t} can be matched to {t'} by instantiating free variables, including appropriate type instantiation, {prim_irule} replaces the goal by new subgoals which are the hypotheses {A'}, instantiated -The order of the new subgoals corresponds to the order in which +The order of the new subgoals corresponds to the order in which {hyp th} returns the hypotheses {A'} \FAILURE @@ -30,6 +30,6 @@ of the goal. theorem may also be substituted, and will appear as new subgoals \SEEALSO -Tactic.irule, Tactic.MATCH_ACCEPT_TAC, Tactic.ACCEPT_TAC +Tactic.irule, Tactic.MATCH_ACCEPT_TAC, Tactic.ACCEPT_TAC \ENDDOC diff --git a/help/Docfiles/Tactical.ADD_SGS_TAC.doc b/help/Docfiles/Tactical.ADD_SGS_TAC.doc index 97b984e95c..5f22c9b342 100644 --- a/help/Docfiles/Tactical.ADD_SGS_TAC.doc +++ b/help/Docfiles/Tactical.ADD_SGS_TAC.doc @@ -3,7 +3,7 @@ \TYPE {ADD_SGS_TAC : term list -> tactic -> tactic} \SYNOPSIS -Adds extra sub-goals to the outcome of a tactic, +Adds extra sub-goals to the outcome of a tactic, as may be required to make an invalid tactic valid. \DESCRIBE @@ -11,7 +11,7 @@ Suppose {tac} applied to the goal {(asl,w)} produces new goal list {gl}. Then {ADD_SGS_TAC tml tac (asl,w)} produces, as new goals, {gl} and, additionally, {(asl,tm)} for each {tm} in {tml}. -Then, if the justification returned by {tac}, +Then, if the justification returned by {tac}, when applied to the proved goals {gl}, gives a theorem which uses some additional assumption {tm} in {tml}, then the proved goal {(asl,tm)} is used to remove {tm} from the assumption list @@ -21,9 +21,9 @@ of that theorem. {ADD_SGS_TAC tml tac (asl,w)} fails if {tac (asl,w)} fails. \USES -Where a tactic {tac} requires certain assumptions {tml} -to be present in the goal, -which are not present but are capable of being proved, +Where a tactic {tac} requires certain assumptions {tml} +to be present in the goal, +which are not present but are capable of being proved, {ADD_SGS_TAC tml tac} will conveniently set up new subgoals to prove the missing assumptions. @@ -32,10 +32,10 @@ assumptions. but its extra new subgoals may occur in an unpredictable order. \EXAMPLE -Given a goal with an implication in the assumptions, +Given a goal with an implication in the assumptions, one can split it into two subgoals, defining an auxiliary function { -fun split_imp_asm th = +fun split_imp_asm th = let val (tm, thu) = UNDISCH_TM th ; in ADD_SGS_TAC [tm] (ASSUME_TAC thu) end ; } @@ -43,7 +43,7 @@ This can be used as follows: { 1 subgoal: val it = - + r ------------------------------------ p ==> q @@ -55,7 +55,7 @@ r OK.. 2 subgoals: val it = - + r ------------------------------------ q @@ -68,7 +68,7 @@ p } To propose a term, prove it as a subgoal and then use it to prove -the goal, as is done using {SUBGOAL_THEN tm ASSUME_TAC}, +the goal, as is done using {SUBGOAL_THEN tm ASSUME_TAC}, can also be done by {ADD_SGS_TAC [tm] (ASSUME_TAC (ASSUME tm))} \SEEALSO diff --git a/help/Docfiles/Tactical.ALLGOALS.doc b/help/Docfiles/Tactical.ALLGOALS.doc index e9b0430ebb..04a23890ea 100644 --- a/help/Docfiles/Tactical.ALLGOALS.doc +++ b/help/Docfiles/Tactical.ALLGOALS.doc @@ -9,12 +9,12 @@ Applies a tactic to every goal in a list tactical, list-tactic. \DESCRIBE -If {tac} is a tactic, {ALLGOALS tac} is a list-tactic which -applies the tactic {tac} to all the goals in the given list. +If {tac} is a tactic, {ALLGOALS tac} is a list-tactic which +applies the tactic {tac} to all the goals in the given list. \FAILURE The application of {ALLGOALS} to a tactic never fails. -The resulting list-tactic fails if +The resulting list-tactic fails if {tac} fails when applied to any of the goals in the given list. \EXAMPLE diff --git a/help/Docfiles/Tactical.ALL_LT.doc b/help/Docfiles/Tactical.ALL_LT.doc index 1656431c22..08756db24b 100644 --- a/help/Docfiles/Tactical.ALL_LT.doc +++ b/help/Docfiles/Tactical.ALL_LT.doc @@ -9,7 +9,7 @@ Passes on a goal list unchanged. list-tactic, identity. \DESCRIBE -{ALL_LT} applied to a goal list {gl} +{ALL_LT} applied to a goal list {gl} simply produces the goal list {gl}. It is the identity for the {THEN_LT} tactical. @@ -17,7 +17,7 @@ the identity for the {THEN_LT} tactical. Never fails. \EXAMPLE -To apply tactic {tac1} to a goal, and then to apply {tac2} +To apply tactic {tac1} to a goal, and then to apply {tac2} to all resulting subgoals except the first, use { tac1 THEN_LT SPLIT_LT 1 (ALL_LT, ALLGOALS tac2) diff --git a/help/Docfiles/Tactical.ALL_TAC.doc b/help/Docfiles/Tactical.ALL_TAC.doc index 2ffe3bfd51..38c2161b69 100644 --- a/help/Docfiles/Tactical.ALL_TAC.doc +++ b/help/Docfiles/Tactical.ALL_TAC.doc @@ -16,7 +16,7 @@ the identity for the {THEN} tactical. Never fails. \EXAMPLE -The tactic +The tactic { INDUCT_THEN numTheory.INDUCTION THENL [ALL_TAC, tac] } diff --git a/help/Docfiles/Tactical.GEN_VALIDATE.doc b/help/Docfiles/Tactical.GEN_VALIDATE.doc index b90f31f5c4..cb6d70b361 100644 --- a/help/Docfiles/Tactical.GEN_VALIDATE.doc +++ b/help/Docfiles/Tactical.GEN_VALIDATE.doc @@ -3,7 +3,7 @@ \TYPE {GEN_VALIDATE : bool -> tactic -> tactic} \SYNOPSIS -Where a tactic requires assumptions to be in the goal, +Where a tactic requires assumptions to be in the goal, add those assumptions as new subgoals. \DESCRIBE @@ -22,12 +22,12 @@ a theorem whose conclusion differs from that of the goal. Also fails if {tac} fails when applied to the given goal. \EXAMPLE -For example, where theorem {uthr'} is {[p', q] |- r} +For example, where theorem {uthr'} is {[p', q] |- r} { 1 subgoal: val it = - + r ------------------------------------ 0. p @@ -37,20 +37,20 @@ r OK.. 1 subgoal: val it = - + p' ------------------------------------ p : proof -} -but, instead of that, +} +but, instead of that, { > e (GEN_VALIDATE false (ACCEPT_TAC uthr')) ; OK.. 2 subgoals: val it = - + q ------------------------------------ 0. p @@ -65,7 +65,7 @@ p' \USES Use {GEN_VALIDATE false} rather than {VALIDATE} -when programming compound tactics if you want to know +when programming compound tactics if you want to know what the resulting subgoals will be, regardless of what the assumptions of the goal are. diff --git a/help/Docfiles/Tactical.GEN_VALIDATE_LT.doc b/help/Docfiles/Tactical.GEN_VALIDATE_LT.doc index c388363552..2d2b360abb 100644 --- a/help/Docfiles/Tactical.GEN_VALIDATE_LT.doc +++ b/help/Docfiles/Tactical.GEN_VALIDATE_LT.doc @@ -1,9 +1,9 @@ -\DOC GEN_VALIDATE_LT +\DOC GEN_VALIDATE_LT \TYPE {GEN_VALIDATE_LT : bool -> list_tactic -> list_tactic} \SYNOPSIS -Where a list-tactic requires assumptions to be in the goal, +Where a list-tactic requires assumptions to be in the goal, add those assumptions as new subgoals. \DESCRIBE @@ -35,7 +35,7 @@ of the goal, which may be useful when coding compound tactics. \SEEALSO Tactical.VALID, Tactical.VALID_LT, Tactical.VALIDATE, -Tactical.VALIDATE_LT, Tactical.GEN_VALIDATE +Tactical.VALIDATE_LT, Tactical.GEN_VALIDATE \ENDDOC diff --git a/help/Docfiles/Tactical.HEADGOAL.doc b/help/Docfiles/Tactical.HEADGOAL.doc index 54cecbf2eb..e6188e9805 100644 --- a/help/Docfiles/Tactical.HEADGOAL.doc +++ b/help/Docfiles/Tactical.HEADGOAL.doc @@ -9,7 +9,7 @@ The list-tactic which applies a tactic to the first member of a list of goals. tactical. \DESCRIBE -If {tac} is a tactic, {HEADGOAL tac} is a +If {tac} is a tactic, {HEADGOAL tac} is a list-tactic which applies the tactic {tac} to the first member of a list of goals. @@ -22,7 +22,7 @@ or finally if {tac} fails when applied to the first member of the goal list. Applying a tactic to the first subgoal. \EXAMPLE -Where {tac1} and {tac2} are tactics, {tac1 THEN_LT HEADGOAL tac2} +Where {tac1} and {tac2} are tactics, {tac1 THEN_LT HEADGOAL tac2} applies {tac1} to a goal, and then applies {tac2} to the first resulting subgoal. diff --git a/help/Docfiles/Tactical.LASTGOAL.doc b/help/Docfiles/Tactical.LASTGOAL.doc index 0da1328341..8661a1dfb0 100644 --- a/help/Docfiles/Tactical.LASTGOAL.doc +++ b/help/Docfiles/Tactical.LASTGOAL.doc @@ -9,7 +9,7 @@ The list-tactic which applies a tactic to the last member of a list of goals. tactical. \DESCRIBE -If {tac} is a tactic, {LASTGOAL tac} is a +If {tac} is a tactic, {LASTGOAL tac} is a list-tactic which applies the tactic {tac} to the last member of a list of goals. @@ -22,7 +22,7 @@ or finally if {tac} fails when applied to the last member of the goal list. Applying a tactic to the last subgoal. \EXAMPLE -Where {tac1} and {tac2} are tactics, {tac1 THEN_LT LASTGOAL tac2} +Where {tac1} and {tac2} are tactics, {tac1 THEN_LT LASTGOAL tac2} applies {tac1} to a goal, and then applies {tac2} to the last resulting subgoal. diff --git a/help/Docfiles/Tactical.NTH_GOAL.doc b/help/Docfiles/Tactical.NTH_GOAL.doc index f0be2104bd..bb31e70ec5 100644 --- a/help/Docfiles/Tactical.NTH_GOAL.doc +++ b/help/Docfiles/Tactical.NTH_GOAL.doc @@ -10,7 +10,7 @@ The list-tactic which applies a tactic to the tactical. \DESCRIBE -If {tac} is a tactic, {NTH_GOAL n tac} is a +If {tac} is a tactic, {NTH_GOAL n tac} is a list-tactic which applies the tactic {tac} to the {n}'th member of a list of goals. @@ -27,7 +27,7 @@ or finally if {tac} fails when applied to the {n}'th member of the goal list. Applying a tactic to a particular subgoal. \EXAMPLE -Where {tac1} and {tac2} are tactics, {tac1 THEN_LT NTH_GOAL n tac2} +Where {tac1} and {tac2} are tactics, {tac1 THEN_LT NTH_GOAL n tac2} applies {tac1} to a goal, and then applies {tac2} to the {n}'th resulting subgoal. diff --git a/help/Docfiles/Tactical.NULL_OK_LT.doc b/help/Docfiles/Tactical.NULL_OK_LT.doc index 4f472d5363..9e0edf0a8e 100644 --- a/help/Docfiles/Tactical.NULL_OK_LT.doc +++ b/help/Docfiles/Tactical.NULL_OK_LT.doc @@ -9,8 +9,8 @@ Makes a list-tactic succeed with no effect when applied to the empty goal list. list-tactical, failure. \DESCRIBE -For any list-tactic {ltac}, the application {NULL_OK_LT ltac} -gives a new list-tactic which has the same effect as {ltac} when applied to +For any list-tactic {ltac}, the application {NULL_OK_LT ltac} +gives a new list-tactic which has the same effect as {ltac} when applied to a non-empty goal list. Applied to the empty goal list it succeeds with no effect. diff --git a/help/Docfiles/Tactical.POP_ASSUM.doc b/help/Docfiles/Tactical.POP_ASSUM.doc index bf208d3c4b..007f6b108b 100644 --- a/help/Docfiles/Tactical.POP_ASSUM.doc +++ b/help/Docfiles/Tactical.POP_ASSUM.doc @@ -53,7 +53,7 @@ The goal: } can be solved by: { - POP_ASSUM + POP_ASSUM (fn th => REWRITE_TAC[REWRITE_RULE[num_CONV (Term`4`), INV_SUC_EQ] th]) } diff --git a/help/Docfiles/Tactical.PRED_ASSUM.doc b/help/Docfiles/Tactical.PRED_ASSUM.doc index 7836d4ab5d..3990896bdd 100644 --- a/help/Docfiles/Tactical.PRED_ASSUM.doc +++ b/help/Docfiles/Tactical.PRED_ASSUM.doc @@ -12,7 +12,7 @@ theorem-tactic, discharge. {PRED_ASSUM} finds the first assumption satisfying the prediate given, removes it from the assumption list, {ASSUME}s it, passes it to the theorem-tactic and then applies the consequent tactic. Thus, -where {t} is the first assumption satisfying {p}, +where {t} is the first assumption satisfying {p}, { PRED_ASSUM p f ([a1,... ai, t, aj, ... an], goal) = f (ASSUME t) ([a1,... ai, aj,... an], goal) @@ -32,10 +32,10 @@ then } \FAILURE -{PRED_ASSUM p} will fail on goals where no +{PRED_ASSUM p} will fail on goals where no assumption safisfies {p}. \SEEALSO -Thm_cont.UNDISCH_THEN, Tactical.PAT_ASSUM, Tactical.POP_ASSUM, +Thm_cont.UNDISCH_THEN, Tactical.PAT_ASSUM, Tactical.POP_ASSUM, Tactic.UNDISCH_TAC. \ENDDOC diff --git a/help/Docfiles/Tactical.REVERSE_LT.doc b/help/Docfiles/Tactical.REVERSE_LT.doc index 08f8abdb63..ad64d6457b 100644 --- a/help/Docfiles/Tactical.REVERSE_LT.doc +++ b/help/Docfiles/Tactical.REVERSE_LT.doc @@ -13,7 +13,7 @@ The list-tactic {REVERSE_LT} reverses the order of a list of subgoals. \FAILURE -Never fails. +Never fails. \EXAMPLE Where {tac} is a tactic, diff --git a/help/Docfiles/Tactical.ROTATE_LT.doc b/help/Docfiles/Tactical.ROTATE_LT.doc index 7c721d7605..fe7555fb8f 100644 --- a/help/Docfiles/Tactical.ROTATE_LT.doc +++ b/help/Docfiles/Tactical.ROTATE_LT.doc @@ -9,7 +9,7 @@ Rotates a list of goals list-tactic. \DESCRIBE -{ROTATE_LT n gl} rotates a goal list {gl} by {n} places. +{ROTATE_LT n gl} rotates a goal list {gl} by {n} places. For {n >= 0}, this means moving the first {n} goals to the end of the list. A negative {n} means rotating the list in the opposite direction. @@ -23,11 +23,11 @@ To bring the third goal to first position, leaving the others in order, use } \COMMENTS -Using {SPLIT_LT}, {ROTATE_LT} and {REVERSE_LT}, +Using {SPLIT_LT}, {ROTATE_LT} and {REVERSE_LT}, any reordering of a list of goals is possible. \SEEALSO proofManagerLib.rotate, proofManagerLib.r, -Tactical.SPLIT_LT, Tactical.REVERSE_LT, Tactical.ALL_LT +Tactical.SPLIT_LT, Tactical.REVERSE_LT, Tactical.ALL_LT \ENDDOC diff --git a/help/Docfiles/Tactical.SPLIT_LT.doc b/help/Docfiles/Tactical.SPLIT_LT.doc index 4414b086f2..0d81ac9239 100644 --- a/help/Docfiles/Tactical.SPLIT_LT.doc +++ b/help/Docfiles/Tactical.SPLIT_LT.doc @@ -10,10 +10,10 @@ list-tactic. \DESCRIBE For list-tactics {ltac1} and {ltac2}, integer {n} and goal list {gl}, -the application {SPLIT_LT n (ltac1, ltac2) gl} -applies {ltac1} to the first {n} goals in {gl}, and {ltac2} to the remainder. +the application {SPLIT_LT n (ltac1, ltac2) gl} +applies {ltac1} to the first {n} goals in {gl}, and {ltac2} to the remainder. If {n} is negative, {ltac1} is applied to the goals before the last {-n}, -and {ltac2} to the last {-n} goals. +and {ltac2} to the last {-n} goals. \FAILURE The application {SPLIT_LT n (ltac1, ltac2)} never fails, @@ -23,7 +23,7 @@ larger then the length of the list, or if either of the list-tactics {ltac1} and {ltac2} fails. \EXAMPLE -To apply tactic {tac1} to a goal, and then to apply {tac2} +To apply tactic {tac1} to a goal, and then to apply {tac2} to all resulting subgoals except the first, use { tac1 THEN_LT SPLIT_LT 1 (ALL_LT, ALLGOALS tac2) diff --git a/help/Docfiles/Tactical.TACS_TO_LT.doc b/help/Docfiles/Tactical.TACS_TO_LT.doc index 59fd4c7e12..6f8f119437 100644 --- a/help/Docfiles/Tactical.TACS_TO_LT.doc +++ b/help/Docfiles/Tactical.TACS_TO_LT.doc @@ -10,14 +10,14 @@ corresponding members of a list of goals. tactical. \DESCRIBE -If {T1,...,Tn} are tactics, {TACS_TO_LT [T1,...,Tn]} is a +If {T1,...,Tn} are tactics, {TACS_TO_LT [T1,...,Tn]} is a list-tactic which applies the tactics {T1,...,Tn} to the corresponding goals. \FAILURE The application of {TACS_TO_LT} to a tactic list never fails. -The resulting list-tactic fails if length of the goal list -is not the same as that of the tactic list, +The resulting list-tactic fails if length of the goal list +is not the same as that of the tactic list, or finally if {Ti} fails when applied to the {i}'th member of the goal list. \USES diff --git a/help/Docfiles/Tactical.THEN_LT.doc b/help/Docfiles/Tactical.THEN_LT.doc index 7609292b8e..b7cb186270 100644 --- a/help/Docfiles/Tactical.THEN_LT.doc +++ b/help/Docfiles/Tactical.THEN_LT.doc @@ -11,27 +11,27 @@ or by a previous list-tactic. tactical, list-tactic. \DESCRIBE -If {tac} is a tactic and {ltac} is a list-tactic, +If {tac} is a tactic and {ltac} is a list-tactic, then {tac THEN_LT ltac} is a tactic which applies {tac} to a goal, and if it does not fail, applies the list-tactic {ltac} to the resulting list of subgoals. -If {ltac1} and {ltac2} are list-tactics, +If {ltac1} and {ltac2} are list-tactics, then {ltac1 THEN_LT ltac2} is a list-tactic which applies {ltac1} to a goal list, and if it does not fail, applies {ltac2} to the resulting list of goals. \FAILURE -The application of {THEN_LT} to a tactic or list-tactic and a list-tactic +The application of {THEN_LT} to a tactic or list-tactic and a list-tactic never fails. -The tactic {tac THEN_LT ltac} fails -if {tac} fails when applied to the goal, +The tactic {tac THEN_LT ltac} fails +if {tac} fails when applied to the goal, or if {ltac} fails when applied to the resulting subgoal list. -The list-tactic {ltac1 THEN_LT ltac2} fails -if {ltac1} fails when applied to the goal list, +The list-tactic {ltac1 THEN_LT ltac2} fails +if {ltac1} fails when applied to the goal list, or if {ltac2} fails when applied to the goal list result of {ltac1}. \USES diff --git a/help/Docfiles/Tactical.TRYALL.doc b/help/Docfiles/Tactical.TRYALL.doc index 5417836052..1b0d21ae13 100644 --- a/help/Docfiles/Tactical.TRYALL.doc +++ b/help/Docfiles/Tactical.TRYALL.doc @@ -10,7 +10,7 @@ tactical, list-tactic. \DESCRIBE If {tac} is a tactic, {TRYALL tac} is a list-tactic which, -when applied to a list of goals, +when applied to a list of goals, applies the tactic {tac} to each goal for which it succeeds. When {tac} fails on a goal, {TRYALL tac} has no effect on that goal. diff --git a/help/Docfiles/Tactical.USE_SG_THEN.doc b/help/Docfiles/Tactical.USE_SG_THEN.doc index 18963faa25..812a8beaaa 100644 --- a/help/Docfiles/Tactical.USE_SG_THEN.doc +++ b/help/Docfiles/Tactical.USE_SG_THEN.doc @@ -9,22 +9,22 @@ Allows the user to use one subgoal to prove another theorem-tactic, lemma. \DESCRIBE -In {USE_SG_THEN ttac nu np}, of the current goal list, subgoal number +In {USE_SG_THEN ttac nu np}, of the current goal list, subgoal number {nu} can be used in proving subgoal number {np}. Subgoal number {nu} is used as a lemma by {ttac} -to simplify subgoal number {np}. That is, if +to simplify subgoal number {np}. That is, if subgoal number {nu} is {A ?- u}, subgoal number {np} is {A1 ?- t1}, and { A1 ?- t1 ========== ttac (u |- u) A2 ?- t2 } -then the list-tactic {USE_SG_THEN ttac nu np} gives this same result +then the list-tactic {USE_SG_THEN ttac nu np} gives this same result (new subgoal(s)) for subgoal {np}. This list-tactic will be invalid unless {A} is a subset of {A1}. -Note that in the interactive system, +Note that in the interactive system, subgoals are printed in reverse order of their numbering. \FAILURE @@ -33,7 +33,7 @@ or if indices {np} or {nu} are out of range. Note that the subgoals in the current subgoal list are numbered starting from 1. \USES -Where two subgoals are similar and not easy to prove, one can be used to +Where two subgoals are similar and not easy to prove, one can be used to help prove the other. \EXAMPLE @@ -58,7 +58,7 @@ r OK.. 2 subgoals: val it = - + r \/ s ------------------------------------ 0. p @@ -99,7 +99,7 @@ r OK.. 2 subgoals: val it = - + r ------------------------------------ 0. p' diff --git a/help/Docfiles/Tactical.VALIDATE.doc b/help/Docfiles/Tactical.VALIDATE.doc index 0e1790fe45..12db74b14b 100644 --- a/help/Docfiles/Tactical.VALIDATE.doc +++ b/help/Docfiles/Tactical.VALIDATE.doc @@ -11,7 +11,7 @@ Suppose {tac} applied to the goal {(asl,g)} produces a justification that creates a theorem {A |- g'}. If {A} a not a subset of {asl}, then the tactic is invalid (and {VALID tac (asl,g)} fails, ie, raises an exception). -But {VALIDATE tac (asl,g)} produces a subgoal list augmented by the +But {VALIDATE tac (asl,g)} produces a subgoal list augmented by the members of {A} missing from {asl}. If {g'} differs from {g}, both {VALID tac (asl,g)} and {VALIDATE tac (asl,g)} @@ -25,12 +25,12 @@ a theorem whose conclusion differs from that of the goal. Also fails if {tac} fails when applied to the given goal. \EXAMPLE -For example, where theorem {uth'} is {[p'] |- q} +For example, where theorem {uth'} is {[p'] |- q} { 1 subgoal: val it = - + q ------------------------------------ p @@ -47,20 +47,20 @@ Invalid tactic [...] OK.. 1 subgoal: val it = - + p' ------------------------------------ p : proof -} +} -Given a goal with an implication in the assumptions, +Given a goal with an implication in the assumptions, one can split it into two subgoals. { 1 subgoal: val it = - + r ------------------------------------ p ==> q @@ -72,7 +72,7 @@ r OK.. 2 subgoals: val it = - + r ------------------------------------ q @@ -86,13 +86,13 @@ p proof } Meanwhile, to propose a term, prove it as a subgoal and then use it to prove -the goal, as is done using {SUBGOAL_THEN tm ASSUME_TAC}, +the goal, as is done using {SUBGOAL_THEN tm ASSUME_TAC}, can also be done by {VALIDATE (ASSUME_TAC (ASSUME tm)))} \USES -Where a tactic {tac} requires certain assumptions to be present in the goal, -which are not present but are capable of being proved, +Where a tactic {tac} requires certain assumptions to be present in the goal, +which are not present but are capable of being proved, {VALIDATE tac} will conveniently set up new subgoals to prove the missing assumptions. diff --git a/help/Docfiles/Tactical.VALIDATE_LT.doc b/help/Docfiles/Tactical.VALIDATE_LT.doc index 3995a59f2b..5f59d8a6c1 100644 --- a/help/Docfiles/Tactical.VALIDATE_LT.doc +++ b/help/Docfiles/Tactical.VALIDATE_LT.doc @@ -1,4 +1,4 @@ -\DOC VALIDATE_LT +\DOC VALIDATE_LT \TYPE {VALIDATE_LT : list_tactic -> list_tactic} @@ -13,7 +13,7 @@ When the justification is applied to a list {thl'} of theorems which are the new goals {gl'}, proved, it should produce a list {thl} of theorems which are the goals {gl}, proved. -A list-tactic can be invalid due to proving +A list-tactic can be invalid due to proving a theorem whose conclusion differs from that of the corresponding goal, or due to proving a theorem which contains extra assumptions relative to the corresponding goal. @@ -30,12 +30,12 @@ a theorem whose conclusion differs from that of the corresponding goal. Also fails if {ltac} fails when applied to the given goals. \EXAMPLE -Where {uthr'} is {[p', q] |- r} and {uths'} is {[p, q'] |- s} +Where {uthr'} is {[p', q] |- r} and {uths'} is {[p, q'] |- s} { 2 subgoals: val it = - + s ------------------------------------ 0. p @@ -60,7 +60,7 @@ Invalid list-tactic [...] OK.. 2 subgoals: val it = - + q' ------------------------------------ 0. p @@ -77,14 +77,14 @@ p' } \USES -Where a tactic {ltac} requires certain assumptions to be present in -one of the goals, -which are not present but are capable of being proved, +Where a tactic {ltac} requires certain assumptions to be present in +one of the goals, +which are not present but are capable of being proved, {VALIDATE_LT ltac} will conveniently set up new subgoals to prove the missing assumptions. \SEEALSO -Tactical.VALID, Tactical.VALID_LT, Tactical.VALIDATE, +Tactical.VALID, Tactical.VALID_LT, Tactical.VALIDATE, proofManagerLib.elt, proofManagerLib.expand_list. \ENDDOC diff --git a/help/Docfiles/Tactical.VALID_LT.doc b/help/Docfiles/Tactical.VALID_LT.doc index d03d5dd517..f9173582a0 100644 --- a/help/Docfiles/Tactical.VALID_LT.doc +++ b/help/Docfiles/Tactical.VALID_LT.doc @@ -1,4 +1,4 @@ -\DOC VALID_LT +\DOC VALID_LT \TYPE {VALID_LT : list_tactic -> list_tactic} @@ -19,12 +19,12 @@ and {VALID_LT ltac gl} fails (raises an exception). Otherwise, {VALID_LT ltac gl} behaves the same as {ltac gl}. \FAILURE -{VALID_LT ltac gl} fails by design if {ltac gl} produces new goals and +{VALID_LT ltac gl} fails by design if {ltac gl} produces new goals and justification which do not prove the given goals {gl}. Also fails if its {ltac gl} fails. \SEEALSO -Tactical.VALID, Tactical.VALIDATE_LT, +Tactical.VALID, Tactical.VALIDATE_LT, proofManagerLib.elt, proofManagerLib.expand_list. \ENDDOC diff --git a/help/Docfiles/Tactical.store_thm.doc b/help/Docfiles/Tactical.store_thm.doc index 16797d39b5..572090a8ee 100644 --- a/help/Docfiles/Tactical.store_thm.doc +++ b/help/Docfiles/Tactical.store_thm.doc @@ -14,7 +14,7 @@ Whenever {prove} fails to prove the given term. \USES Saving theorems for retrieval in later sessions. Binding the result -of {store_thm} to an ML variable makes it easy to access the theorem +of {store_thm} to an ML variable makes it easy to access the theorem in the current terminal session. \SEEALSO diff --git a/help/Docfiles/Tag.read.doc b/help/Docfiles/Tag.read.doc index f1a9a85f97..91eeb7ef9a 100644 --- a/help/Docfiles/Tag.read.doc +++ b/help/Docfiles/Tag.read.doc @@ -9,7 +9,7 @@ Make a tag suitable for use by {mk_oracle_thm}. tag, oracle, theorem. \DESCRIBE -In order to construct a tag usable by {mk_oracle_thm}, one uses {read}, +In order to construct a tag usable by {mk_oracle_thm}, one uses {read}, which takes a string and makes it into a tag. \FAILURE diff --git a/help/Docfiles/Tag.tag.doc b/help/Docfiles/Tag.tag.doc index 0b4f216585..46d06dad37 100644 --- a/help/Docfiles/Tag.tag.doc +++ b/help/Docfiles/Tag.tag.doc @@ -10,10 +10,10 @@ tag, oracle. \DESCRIBE The type {tag} is used to track the use of oracles in HOL. An `oracle' -is a source of theorems that are not proved, but just asserted. In HOL, +is a source of theorems that are not proved, but just asserted. In HOL, such unproven `theorems' are used to incorporate the results of -external proof tools. Each theorem coming from an oracle has a tag -attached to it. This tag gets copied to any theorems hereditarily +external proof tools. Each theorem coming from an oracle has a tag +attached to it. This tag gets copied to any theorems hereditarily generated from an oracular theorem by inference. \SEEALSO diff --git a/help/Docfiles/Term.beta_conv.doc b/help/Docfiles/Term.beta_conv.doc index 0ff53d495b..6a8e1f13c9 100644 --- a/help/Docfiles/Term.beta_conv.doc +++ b/help/Docfiles/Term.beta_conv.doc @@ -9,10 +9,10 @@ Performs one step of beta-reduction. conversion, beta. \DESCRIBE -Beta-reduction is one of the primitive operations in the lambda calculus. +Beta-reduction is one of the primitive operations in the lambda calculus. A step of beta-reduction may be performed by {beta_conv M}, where {M} -is the application of a lambda abstraction to an argument, i.e., has -the form {((\v.N) P)}. The beta-reduction occurs by systematically +is the application of a lambda abstraction to an argument, i.e., has +the form {((\v.N) P)}. The beta-reduction occurs by systematically replacing every free occurrence of {v} in {N} by {P}. Care is taken so that no free variable of {P} becomes captured in @@ -32,7 +32,7 @@ If {M} is not the application of an abstraction to an argument. \COMMENTS -More complex strategies for coding up full beta-reduction can be +More complex strategies for coding up full beta-reduction can be coded up in ML. The {conversions} of Larry Paulson support this activity as inference steps. diff --git a/help/Docfiles/Term.body.doc b/help/Docfiles/Term.body.doc index 2241322105..765c6c83fc 100644 --- a/help/Docfiles/Term.body.doc +++ b/help/Docfiles/Term.body.doc @@ -6,7 +6,7 @@ Returns the body of an abstraction. \DESCRIBE -If {M} is a lambda abstraction, i.e, has the form {\v. t}, then +If {M} is a lambda abstraction, i.e, has the form {\v. t}, then {body M} returns {t}. \FAILURE diff --git a/help/Docfiles/Term.bvar.doc b/help/Docfiles/Term.bvar.doc index 719e064e1e..43bcbec6ea 100644 --- a/help/Docfiles/Term.bvar.doc +++ b/help/Docfiles/Term.bvar.doc @@ -6,7 +6,7 @@ Returns the bound variable of an abstraction. \DESCRIBE -If {M} is a lambda abstraction, i.e, has the form {\v. t}, then +If {M} is a lambda abstraction, i.e, has the form {\v. t}, then {bvar M} returns {v}. \FAILURE diff --git a/help/Docfiles/Term.decls.doc b/help/Docfiles/Term.decls.doc index ec36aa3cb3..6132ccf4ee 100644 --- a/help/Docfiles/Term.decls.doc +++ b/help/Docfiles/Term.decls.doc @@ -28,7 +28,7 @@ Never fails. \COMMENTS Useful for untangling confusion arising from overloading and -also the possibility to declare two different constants with the +also the possibility to declare two different constants with the same name in different theories. \SEEALSO diff --git a/help/Docfiles/Term.dest_const.doc b/help/Docfiles/Term.dest_const.doc index fba1df30dd..b55bb4ce2a 100644 --- a/help/Docfiles/Term.dest_const.doc +++ b/help/Docfiles/Term.dest_const.doc @@ -6,7 +6,7 @@ Breaks apart a constant into name and type. \DESCRIBE -{dest_const} is a term destructor for constants. If {M} is a +{dest_const} is a term destructor for constants. If {M} is a constant with name {c} and type {ty}, then {dest_const M} returns {(c,ty)}. @@ -14,8 +14,8 @@ returns {(c,ty)}. Fails if {M} is not a constant. \COMMENTS -In Hol98, constants also carry the theory they are declared in. A -more precise and robust way to analyze a constant is with +In Hol98, constants also carry the theory they are declared in. A +more precise and robust way to analyze a constant is with {dest_thy_const}. \SEEALSO diff --git a/help/Docfiles/Term.dest_thy_const.doc b/help/Docfiles/Term.dest_thy_const.doc index dda5544606..fbd76377b3 100644 --- a/help/Docfiles/Term.dest_thy_const.doc +++ b/help/Docfiles/Term.dest_thy_const.doc @@ -6,7 +6,7 @@ Breaks apart a constant into name, theory, and type. \DESCRIBE -{dest_thy_const} is a term destructor for constants. If {M} is a +{dest_thy_const} is a term destructor for constants. If {M} is a constant, declared in theory {Thy} with name {Name}, having type {ty}, then {dest_thy_const M} returns {{Thy, Name, Ty}}, where {Ty} is equal to {ty}. diff --git a/help/Docfiles/Term.dest_var.doc b/help/Docfiles/Term.dest_var.doc index 3b611f926f..5d0f4f6636 100644 --- a/help/Docfiles/Term.dest_var.doc +++ b/help/Docfiles/Term.dest_var.doc @@ -6,7 +6,7 @@ Breaks apart a variable into name and type. \DESCRIBE -If {M} is a HOL variable, then {dest_var M} returns {(v,ty)}, where {v} +If {M} is a HOL variable, then {dest_var M} returns {(v,ty)}, where {v} is the name of the variable, an {ty} is its type. \FAILURE diff --git a/help/Docfiles/Term.empty_varset.doc b/help/Docfiles/Term.empty_varset.doc index f584337dab..9933186dc5 100644 --- a/help/Docfiles/Term.empty_varset.doc +++ b/help/Docfiles/Term.empty_varset.doc @@ -9,7 +9,7 @@ Empty set of term variables. term, set. \DESCRIBE -The value {empty_varset} represents an empty set of term variables. +The value {empty_varset} represents an empty set of term variables. The set has a built-in ordering, which is given by {Term.var_compare}. \COMMENTS diff --git a/help/Docfiles/Term.eta_conv.doc b/help/Docfiles/Term.eta_conv.doc index e90820c803..4682b556fa 100644 --- a/help/Docfiles/Term.eta_conv.doc +++ b/help/Docfiles/Term.eta_conv.doc @@ -9,11 +9,11 @@ Performs one step of eta-reduction. conversion, reduction, eta. \DESCRIBE -Eta-reduction is an important operation in the lambda calculus. +Eta-reduction is an important operation in the lambda calculus. A step of eta-reduction may be performed by {eta_conv M}, where {M} -is a lambda abstraction of the following form: {\v. (N v)}, i.e., -a lambda abstraction whose body is an application of a term {N} to -the bound variable {v}. Moreover, {v} must not occur free in {M}. +is a lambda abstraction of the following form: {\v. (N v)}, i.e., +a lambda abstraction whose body is an application of a term {N} to +the bound variable {v}. Moreover, {v} must not occur free in {M}. If this proviso is met, an invocation {eta_conv (\v. (N v))} is equal to {N}. @@ -28,7 +28,7 @@ If {M} is not of the specified form, or if {v} occurs free in {N}. \COMMENTS -Eta-reduction embodies the principle of extensionality, which is +Eta-reduction embodies the principle of extensionality, which is basic to the HOL logic. \SEEALSO diff --git a/help/Docfiles/Term.genvar.doc b/help/Docfiles/Term.genvar.doc index 5e9d97d781..17be76f128 100644 --- a/help/Docfiles/Term.genvar.doc +++ b/help/Docfiles/Term.genvar.doc @@ -32,8 +32,8 @@ Note that one can anticipate {genvar}: } This shortcoming could be guarded against, but it doesn't seem worth -it currently. It doesn't seem to affect the soundness of the -implementation of HOL; at worst, a proof procedure may fail because +it currently. It doesn't seem to affect the soundness of the +implementation of HOL; at worst, a proof procedure may fail because it doesn't have a sufficiently fresh variable. \USES diff --git a/help/Docfiles/Term.is_comb.doc b/help/Docfiles/Term.is_comb.doc index 6e877e0d92..8516b285bf 100644 --- a/help/Docfiles/Term.is_comb.doc +++ b/help/Docfiles/Term.is_comb.doc @@ -6,7 +6,7 @@ Tests a term to see if it is a combination (function application). \DESCRIBE -If term {M} has the form {f x}, then {is_comb M} equals {true}. +If term {M} has the form {f x}, then {is_comb M} equals {true}. Otherwise, the result is {false}. \FAILURE diff --git a/help/Docfiles/Term.list_mk_abs.doc b/help/Docfiles/Term.list_mk_abs.doc index 198e2d8425..3143a7e60d 100644 --- a/help/Docfiles/Term.list_mk_abs.doc +++ b/help/Docfiles/Term.list_mk_abs.doc @@ -25,7 +25,7 @@ Fails if some {vi} (1 <= i <= n) is not a variable. \COMMENTS -In the current implementation, {list_mk_abs} is more efficient than +In the current implementation, {list_mk_abs} is more efficient than iteration of {mk_abs} for larger tasks. \SEEALSO diff --git a/help/Docfiles/Term.list_mk_binder.doc b/help/Docfiles/Term.list_mk_binder.doc index e26b5b19ff..236b182c61 100644 --- a/help/Docfiles/Term.list_mk_binder.doc +++ b/help/Docfiles/Term.list_mk_binder.doc @@ -10,17 +10,17 @@ variable, binding, abstraction. \DESCRIBE An application {list_mk_binder (SOME c) ([v1,...,vn],M)} builds the term -{c (\v1. ... (c (\vn. M) ...))}. The term {c} should be a binder, that is, a -constant that takes a lambda abstraction and returns a bound term. Thus -{list_mk_binder} implements Church's view that variable binding operations +{c (\v1. ... (c (\vn. M) ...))}. The term {c} should be a binder, that is, a +constant that takes a lambda abstraction and returns a bound term. Thus +{list_mk_binder} implements Church's view that variable binding operations should be reduced to lambda-binding. An application {list_mk_binder NONE ([v1,...,vn],M)} builds the term -{\v1...vn. M}. +{\v1...vn. M}. \FAILURE {list_mk_binder opt ([v1,...,vn],M)} fails if some {vi} {1 <= i <= n} is -not a variable. It also fails if the constructed term +not a variable. It also fails if the constructed term {c (\v1. ... (c (\vn. M) ...))} is not well typed. \EXAMPLE @@ -47,7 +47,7 @@ Repeated existential quantification is easy to code up using } Now we exercise {list_mk_binder}. { - - val exl_tm = list_mk_binder (SOME boolSyntax.existential) + - val exl_tm = list_mk_binder (SOME boolSyntax.existential) (vars, list_mk_conj vars); > val exl_tm = `?v0 v1 v2 v3 v4 v5 v6 v7 v8 v9 v10 v11 v12 v13 v14 v15 v16 v17 v18 v19 v20 @@ -70,9 +70,9 @@ Now we exercise {list_mk_binder}. \COMMENTS -Terms with many consecutive binders should be constructed using +Terms with many consecutive binders should be constructed using {list_mk_binder} and its instantiations {list_mk_abs}, {list_mk_forall}, -and {list_mk_exists}. In the current implementation of HOL, iterating +and {list_mk_exists}. In the current implementation of HOL, iterating {mk_abs}, {mk_forall}, or {mk_exists} is far slower for terms with many consecutive binders. diff --git a/help/Docfiles/Term.list_mk_comb.doc b/help/Docfiles/Term.list_mk_comb.doc index a89a8585f8..f089566b0e 100644 --- a/help/Docfiles/Term.list_mk_comb.doc +++ b/help/Docfiles/Term.list_mk_comb.doc @@ -9,7 +9,7 @@ Iteratively constructs combinations (function applications). {list_mk_comb(t,[t1,...,tn])} returns {t t1 ... tn}. \FAILURE -Fails if the types of {t1},...,{tn} are not equal to the argument +Fails if the types of {t1},...,{tn} are not equal to the argument types of {t}. It is not necessary for all the arguments of {t} to be given. In particular the list of terms {t1},...,{tn} may be empty. diff --git a/help/Docfiles/Term.match_term.doc b/help/Docfiles/Term.match_term.doc index 63eb15896b..ea500c3e2e 100644 --- a/help/Docfiles/Term.match_term.doc +++ b/help/Docfiles/Term.match_term.doc @@ -9,9 +9,9 @@ Finds instantiations to match one term to another. An application {match_term M N} attempts to find a set of type and term instantiations for {M} to make it alpha-convertible to {N}. If {match_term} succeeds, it returns the instantiations -in the form of a pair containing a term substitution and a -type substitution. In particular, if {match_term pat ob} succeeds -in returning a value {(S,T)}, then +in the form of a pair containing a term substitution and a +type substitution. In particular, if {match_term pat ob} succeeds +in returning a value {(S,T)}, then { aconv (subst S (inst T pat)) ob. } diff --git a/help/Docfiles/Term.match_terml.doc b/help/Docfiles/Term.match_terml.doc index 319833a468..8a31d26527 100644 --- a/help/Docfiles/Term.match_terml.doc +++ b/help/Docfiles/Term.match_terml.doc @@ -1,8 +1,8 @@ \DOC match_terml \BLTYPE -match_terml - : hol_type list -> term set -> term -> term +match_terml + : hol_type list -> term set -> term -> term -> (term,term) subst * (hol_type,hol_type) subst \ELTYPE @@ -15,42 +15,42 @@ match, substitution. \DESCRIBE An invocation {match_terml avoid_tys avoid_tms pat ob (tmS,tyS)}, if it does not raise an exception, returns a pair of substitutions {(S,T)} -such that +such that { aconv (subst S (inst T pat)) ob. } The arguments {avoid_tys} and {avoid_tms} specify type -and term variables in {pat} that are not allowed to become {redex}es +and term variables in {pat} that are not allowed to become {redex}es in {S} and {T}. \FAILURE {match_terml} will fail if no {S} and {T} meeting the above requirements can be found. If a match {(S,T)} between {pat} and {ob} can be found, -but elements of {avoid_tys} would appear as redexes in {T} or -elements of {avoid_tms} would appear as redexes in {S}, then +but elements of {avoid_tys} would appear as redexes in {T} or +elements of {avoid_tms} would appear as redexes in {S}, then {match_terml} will also fail. \EXAMPLE { -- val (S,T) = match_terml [] empty_varset +- val (S,T) = match_terml [] empty_varset (Term `\x:'a. x = f (y:'b)`) (Term `\a. a = ~p`); > val S = [{redex = `(f :'b -> 'a)`, residue = `$~`}, {redex = `(y :'b)`, residue = `(p :bool)`}] : ... - val T = [{redex = `:'b`, residue = `:bool`}, + val T = [{redex = `:'b`, residue = `:bool`}, {redex = `:'a`, residue = `:bool`}] : ... - match_terml [alpha] empty_varset (* forbid instantiation of 'a *) (Term `\x:'a. x = f (y:'b)`) (Term `\a. a = ~p`); -! Uncaught exception: +! Uncaught exception: ! HOL_ERR - match_terml [] (HOLset.add(empty_varset,mk_var("y",beta))) (Term `\x:'a. x = f (y:'b)`) (Term `\a. a = ~p`); -! Uncaught exception: +! Uncaught exception: ! HOL_ERR } diff --git a/help/Docfiles/Term.mk_const.doc b/help/Docfiles/Term.mk_const.doc index e830b6a307..192194b5f8 100644 --- a/help/Docfiles/Term.mk_const.doc +++ b/help/Docfiles/Term.mk_const.doc @@ -6,16 +6,16 @@ Constructs a constant. \DESCRIBE -If {n} is a string that has been previously declared to be a constant +If {n} is a string that has been previously declared to be a constant with type {ty} and {ty1} is an instance of {ty}, then {mk_const(n,ty1)} returns the specified instance of the constant. (A type {ty1} is an 'instance' of a type {ty2} when {match_type ty2 ty1} does not fail.) -Note, however, that constants with the same name (and type) may be +Note, however, that constants with the same name (and type) may be declared in different theories. If two theories having constants with -the same name {n} are in the ancestry of the current theory, then +the same name {n} are in the ancestry of the current theory, then {mk_const(n,ty)} will issue a warning before arbitrarily selecting which constant to construct. In such situations, {mk_thy_const} allows one to specify exactly which constant to use. @@ -37,7 +37,7 @@ instance of the type that the constant has in the signature. test not found } -The following example shows a new constant being introduced that +The following example shows a new constant being introduced that has the same name as the standard equality of HOL. Then we attempt to make an instance of that constant. { diff --git a/help/Docfiles/Term.mk_thy_const.doc b/help/Docfiles/Term.mk_thy_const.doc index 7ddd7789a4..988aea9be0 100644 --- a/help/Docfiles/Term.mk_thy_const.doc +++ b/help/Docfiles/Term.mk_thy_const.doc @@ -6,8 +6,8 @@ Constructs a constant. \DESCRIBE -If {n} is a string that has been previously declared to be a constant -with type {ty} in theory {thy}, and {ty1} is an instance of {ty}, +If {n} is a string that has been previously declared to be a constant +with type {ty} in theory {thy}, and {ty1} is an instance of {ty}, then {mk_thy_const{Name=n, Thy=thy, Ty=ty1}} returns the specified instance of the constant. @@ -15,7 +15,7 @@ instance of the constant. does not fail.) \FAILURE -Fails if {n} is not the name of a constant in theory {thy}, if {thy} is +Fails if {n} is not the name of a constant in theory {thy}, if {thy} is not in the ancestry of the current theory, or if {ty1} is not an instance of {ty}. diff --git a/help/Docfiles/Term.mk_var.doc b/help/Docfiles/Term.mk_var.doc index e1e7276f89..46a39c4fc2 100644 --- a/help/Docfiles/Term.mk_var.doc +++ b/help/Docfiles/Term.mk_var.doc @@ -6,7 +6,7 @@ Constructs a variable of given name and type. \DESCRIBE -If {v} is a string and {ty} is a HOL type, then {mk_var(v, ty)} returns +If {v} is a string and {ty} is a HOL type, then {mk_var(v, ty)} returns a HOL variable. \FAILURE diff --git a/help/Docfiles/Term.norm_subst.doc b/help/Docfiles/Term.norm_subst.doc index a0918ca87f..698162aa95 100644 --- a/help/Docfiles/Term.norm_subst.doc +++ b/help/Docfiles/Term.norm_subst.doc @@ -13,15 +13,15 @@ Instantiate term substitution by a type substitution. substitution, term, type. \DESCRIBE -Given a term substitution and a type substitution, +Given a term substitution and a type substitution, {norm_subst} applies the type substitution to the redexes of the term substitution. The substitutions coming from {raw_match} need to be normalized before they can be applied by inference rules like {INST_TY_TERM}. An invocation {raw_match avoid_tys avoid_tms pat ob A} returns a pair of substitutions -{((S,Ids),(T,Idt))}. The {Id} components can be ignored. The {S} component is -a substitution for term variables, but it has to be instantiated by +{((S,Ids),(T,Idt))}. The {Id} components can be ignored. The {S} component is +a substitution for term variables, but it has to be instantiated by the type substitution {T} in order to be suitable for use by {INST_TY_TERM}. In this case, one uses {norm_subst ((S,Ids),(T,Idt))} as the first argument for {INST_TY_TERM}. @@ -36,20 +36,20 @@ Never fails. \EXAMPLE { -- val ((S,Ids),(T,Idt)) = raw_match [] empty_varset +- val ((S,Ids),(T,Idt)) = raw_match [] empty_varset (Term `\x:'a. x = f (y:'b)`) (Term `\a. a = ~p`) ([],[]); > val S = [{redex = `(f :'b -> 'a)`, residue = `$~`}, {redex = `(y :'b)`, residue = `(p :bool)`}] : (term, term) subst - val T = [{redex = `:'b`, residue = `:bool`}, - {redex = `:'a`, residue = `:bool`}] + val T = [{redex = `:'b`, residue = `:bool`}, + {redex = `:'a`, residue = `:bool`}] : (hol_type, hol_type) subst - val (S',_) = norm_subst ((S,Ids),(T,Idt)) ; > val S' = [{redex = `(y :bool)`, residue = `(p :bool)`}, - {redex = `(f :bool -> bool)`, residue = `$~`}] + {redex = `(f :bool -> bool)`, residue = `$~`}] : (term, term) subst } diff --git a/help/Docfiles/Term.prim_mk_const.doc b/help/Docfiles/Term.prim_mk_const.doc index c9e824632c..a0af019582 100644 --- a/help/Docfiles/Term.prim_mk_const.doc +++ b/help/Docfiles/Term.prim_mk_const.doc @@ -26,9 +26,9 @@ If {Name} is not the name of a constant declared in theory {Thy}. \COMMENTS -The difference between {mk_thy_const} (and {mk_const}) and {prim_mk_const} -is that {mk_thy_const} and {mk_const} will create type instances of -polymorphic constants, while {prim_mk_const} merely returns the originally +The difference between {mk_thy_const} (and {mk_const}) and {prim_mk_const} +is that {mk_thy_const} and {mk_const} will create type instances of +polymorphic constants, while {prim_mk_const} merely returns the originally declared constant. \SEEALSO diff --git a/help/Docfiles/Term.rand.doc b/help/Docfiles/Term.rand.doc index 1fba0683af..2a4f4600a1 100644 --- a/help/Docfiles/Term.rand.doc +++ b/help/Docfiles/Term.rand.doc @@ -6,7 +6,7 @@ Returns the operand from a combination (function application). \DESCRIBE -If {M} is a combination, i.e., has the form {(t1 t2)}, then +If {M} is a combination, i.e., has the form {(t1 t2)}, then {rand M} returns {t2}. \FAILURE diff --git a/help/Docfiles/Term.rator.doc b/help/Docfiles/Term.rator.doc index 7a8759f5f7..ad0595de07 100644 --- a/help/Docfiles/Term.rator.doc +++ b/help/Docfiles/Term.rator.doc @@ -6,7 +6,7 @@ Returns the operator from a combination (function application). \DESCRIBE -If {M} is a combination, i.e., has the form {(t1 t2)}, then +If {M} is a combination, i.e., has the form {(t1 t2)}, then {rator M} returns {t1}. \FAILURE diff --git a/help/Docfiles/Term.rename_bvar.doc b/help/Docfiles/Term.rename_bvar.doc index be0236c968..2394c2007f 100644 --- a/help/Docfiles/Term.rename_bvar.doc +++ b/help/Docfiles/Term.rename_bvar.doc @@ -10,7 +10,7 @@ conversion, alpha. \DESCRIBE If {M} is a lambda abstraction, i.e., has the form {\v.N}, an -invocation {rename_bvar s M} performs one step of alpha conversion to +invocation {rename_bvar s M} performs one step of alpha conversion to obtain {\s. N[s/v]}. \FAILURE diff --git a/help/Docfiles/Term.same_const.doc b/help/Docfiles/Term.same_const.doc index 2bfaf1e031..65aeda8004 100644 --- a/help/Docfiles/Term.same_const.doc +++ b/help/Docfiles/Term.same_const.doc @@ -9,9 +9,9 @@ Constant time equality check for constants. constant, equality. \DESCRIBE -In many cases, one needs to check that a constant is an instance of +In many cases, one needs to check that a constant is an instance of the generic constant originally introduced into the signature, or that -two constants are both type instantiations of another. This can be +two constants are both type instantiations of another. This can be achieved by taking the constants apart with {dest_thy_const} and comparing their name and theory. However, this is relatively inefficient. Instead, one can invoke {same_const}, which takes constant time. diff --git a/help/Docfiles/Term.strip_abs.doc b/help/Docfiles/Term.strip_abs.doc index 6efbb89983..cc8294ac18 100644 --- a/help/Docfiles/Term.strip_abs.doc +++ b/help/Docfiles/Term.strip_abs.doc @@ -10,7 +10,7 @@ lambda abstraction. \DESCRIBE If M is a term of the form {\v1...vn.N}, where {N} is not a lambda abstraction, -then {strip_abs M} equals {([v1,...,vn],N)}. Otherwise, the result +then {strip_abs M} equals {([v1,...,vn],N)}. Otherwise, the result is {([],M)}. \FAILURE diff --git a/help/Docfiles/Term.strip_binder.doc b/help/Docfiles/Term.strip_binder.doc index a01bcc10d6..fb5a9d2641 100644 --- a/help/Docfiles/Term.strip_binder.doc +++ b/help/Docfiles/Term.strip_binder.doc @@ -9,7 +9,7 @@ Break apart consecutive binders. variable, binding. \DESCRIBE -An application {strip_binder (SOME c) (c(\v1. ... (c(\vn.M))...))} +An application {strip_binder (SOME c) (c(\v1. ... (c(\vn.M))...))} returns {([v1,...,vn],M)}. The constant {c} should represent a term binding operation. @@ -34,14 +34,14 @@ Defining {strip_forall} is similar. \COMMENTS -Terms with many consecutive binders should be taken apart using +Terms with many consecutive binders should be taken apart using {strip_binder} and its instantiations {strip_abs}, {strip_forall}, -and {strip_exists}. In the current implementation of HOL, iterating +and {strip_exists}. In the current implementation of HOL, iterating {dest_abs}, {dest_forall}, or {dest_exists} is far slower for terms with many consecutive binders. \SEEALSO -Term.list_mk_binder, +Term.list_mk_binder, Term.strip_abs, boolSyntax.strip_forall, boolSyntax.strip_exists. \ENDDOC diff --git a/help/Docfiles/Term.subst.doc b/help/Docfiles/Term.subst.doc index 673d2b95de..1f9cae231c 100644 --- a/help/Docfiles/Term.subst.doc +++ b/help/Docfiles/Term.subst.doc @@ -24,16 +24,16 @@ equal. { - load "arithmeticTheory"; -- subst [Term`SUC 0` |-> Term`1`] +- subst [Term`SUC 0` |-> Term`1`] (Term`SUC(SUC 0)`); > val it = `SUC 1` : term -- subst [Term`SUC 0` |-> Term`1`, +- subst [Term`SUC 0` |-> Term`1`, Term`SUC 1` |-> Term`2`] (Term`SUC(SUC 0)`); > val it = `SUC 1` : term -- subst [Term`SUC 0` |-> Term`1`, +- subst [Term`SUC 0` |-> Term`1`, Term`SUC 1` |-> Term`2`] (Term`SUC(SUC 0) = SUC 1`); > val it = `SUC 1 = 2` : term @@ -42,7 +42,7 @@ equal. (Term`\a:num. b:num`); > val it = `\a'. a` : term -- subst [Term`flip:'a` |-> Term`foo:'a`] +- subst [Term`flip:'a` |-> Term`foo:'a`] (Term`waddle:'a`); > val it = `waddle` : term } diff --git a/help/Docfiles/Term.term.doc b/help/Docfiles/Term.term.doc index 9f8e3dd566..4d104e32cd 100644 --- a/help/Docfiles/Term.term.doc +++ b/help/Docfiles/Term.term.doc @@ -9,9 +9,9 @@ ML datatype of HOL terms. term. \DESCRIBE -The ML abstract type {term} represents the set of HOL terms, +The ML abstract type {term} represents the set of HOL terms, which is essentially the simply typed lambda calculus of Church. A term -may be a variable, a constant, an application of one term to another, +may be a variable, a constant, an application of one term to another, or a lambda abstraction. \COMMENTS diff --git a/help/Docfiles/Term.var_compare.doc b/help/Docfiles/Term.var_compare.doc index 1c53e70c3b..bb63957ebc 100644 --- a/help/Docfiles/Term.var_compare.doc +++ b/help/Docfiles/Term.var_compare.doc @@ -9,7 +9,7 @@ Total ordering on variables. variable, order. \DESCRIBE -An invocation {var_compare (v1,v2)} will return one of +An invocation {var_compare (v1,v2)} will return one of {{LESS, EQUAL, GREATER}}, according to an ordering on term variables. The ordering is transitive and total. @@ -24,7 +24,7 @@ If {v1} and {v2} are not both variables. \COMMENTS -Used to build high performance datastructures for dealing with sets +Used to build high performance datastructures for dealing with sets having many variables. \SEEALSO diff --git a/help/Docfiles/Theory.ancestry.doc b/help/Docfiles/Theory.ancestry.doc index f43d292f49..41fe39aca3 100644 --- a/help/Docfiles/Theory.ancestry.doc +++ b/help/Docfiles/Theory.ancestry.doc @@ -6,9 +6,9 @@ Returns the (proper) ancestry of a theory in a list. \DESCRIBE -A call to {ancestry thy} returns a list of all the proper +A call to {ancestry thy} returns a list of all the proper ancestors (i.e. parents, parents of parents, etc.) of the theory {thy}. -The shorthand {"-"} may be used to denote the name of the current +The shorthand {"-"} may be used to denote the name of the current theory segment. \FAILURE diff --git a/help/Docfiles/Theory.axioms.doc b/help/Docfiles/Theory.axioms.doc index 15ac54e53d..9376a62baa 100644 --- a/help/Docfiles/Theory.axioms.doc +++ b/help/Docfiles/Theory.axioms.doc @@ -7,8 +7,8 @@ Returns the axioms of the current theory. \DESCRIBE A call {axioms ()} returns the axioms of the current theory segment together -with their names. The names are those given to the axioms by the user -when they were originally added to the theory segment (by a call to +with their names. The names are those given to the axioms by the user +when they were originally added to the theory segment (by a call to {new_axiom}). \FAILURE diff --git a/help/Docfiles/Theory.constants.doc b/help/Docfiles/Theory.constants.doc index b9e01b327b..c1a05f11bf 100644 --- a/help/Docfiles/Theory.constants.doc +++ b/help/Docfiles/Theory.constants.doc @@ -10,7 +10,7 @@ The call { constants thy } -where {thy} is an ancestor theory (the special string {"-"} +where {thy} is an ancestor theory (the special string {"-"} means the current theory), returns a list of all the constants in that theory. @@ -28,7 +28,7 @@ current theory. } \SEEALSO -Theory.types, Theory.current_axioms, +Theory.types, Theory.current_axioms, Theory.current_definitions, Theory.current_theorems. \ENDDOC diff --git a/help/Docfiles/Theory.current_axioms.doc b/help/Docfiles/Theory.current_axioms.doc index fbbc27217b..68aae3d7c8 100644 --- a/help/Docfiles/Theory.current_axioms.doc +++ b/help/Docfiles/Theory.current_axioms.doc @@ -16,8 +16,8 @@ asserted in the current theory segment. Never fails. If no axioms have been asserted, the empty list is returned. \SEEALSO -Theory.current_theory, Theory.new_theory, -Theory.current_definitions, Theory.current_theorems, +Theory.current_theory, Theory.new_theory, +Theory.current_definitions, Theory.current_theorems, Theory.constants, Theory.types, Theory.parents. \ENDDOC diff --git a/help/Docfiles/Theory.current_definitions.doc b/help/Docfiles/Theory.current_definitions.doc index 1ccbe72030..df4d66db6e 100644 --- a/help/Docfiles/Theory.current_definitions.doc +++ b/help/Docfiles/Theory.current_definitions.doc @@ -13,19 +13,19 @@ An invocation {current_definitions()} returns the list of definitions stored in the current theory segment. Every definition is automatically stored in the current segment by the primitive definition principles. -Advanced definition principles are built in terms of the primitives, -so they also store their results in the cuurent segment. However, the -definitions may be quite far removed from the user input, and they may +Advanced definition principles are built in terms of the primitives, +so they also store their results in the cuurent segment. However, the +definitions may be quite far removed from the user input, and they may also store some consequences of the definition as theorems. \FAILURE Never fails. If no definitions have been made, the empty list is returned. \SEEALSO -Theory.current_theory, Theory.new_theory, -Theory.current_axioms, Theory.current_theorems, +Theory.current_theory, Theory.new_theory, +Theory.current_axioms, Theory.current_theorems, Theory.constants, Theory.types, Theory.parents, -Definition.new_definition, Definition.new_specification, +Definition.new_definition, Definition.new_specification, Definition.new_type_definition, TotalDefn.Define, IndDefLib.Hol_reln. \ENDDOC diff --git a/help/Docfiles/Theory.current_theorems.doc b/help/Docfiles/Theory.current_theorems.doc index ece3b87422..3a9638dfa2 100644 --- a/help/Docfiles/Theory.current_theorems.doc +++ b/help/Docfiles/Theory.current_theorems.doc @@ -9,15 +9,15 @@ Return the theorems stored in the current theory segment. theorem, theory. \DESCRIBE -An invocation {current_theorems ()} returns the list of theorems +An invocation {current_theorems ()} returns the list of theorems stored in the current theory segment. \FAILURE Never fails. If no theorems have been stored, the empty list is returned. \SEEALSO -Theory.current_theory, Theory.new_theory, -Theory.current_definitions, Theory.current_theorems, +Theory.current_theory, Theory.new_theory, +Theory.current_definitions, Theory.current_theorems, Theory.constants, Theory.types, Theory.parents. \ENDDOC diff --git a/help/Docfiles/Theory.current_theory.doc b/help/Docfiles/Theory.current_theory.doc index 1d9c427e7a..d0074deb48 100644 --- a/help/Docfiles/Theory.current_theory.doc +++ b/help/Docfiles/Theory.current_theory.doc @@ -8,30 +8,30 @@ Returns the name of the current theory segment. \DESCRIBE A HOL session has a notion of `current theory'. There are two senses to this phrase. First, the current theory denotes the totality of all -loaded theories plus whatever definitions, axioms, and theorems have +loaded theories plus whatever definitions, axioms, and theorems have been stored in the current session. In this sense, the current theory is the full logical context being used at the moment. This logical context can be extended in two ways: (a) by loading in prebuilt theories residing on disk; and (b) by making a definition, asserting an axiom, -or storing a theorem. Therefore, the current theory consists of a body -of prebuilt theories that have been loaded from disk -(a collection of static components) plus whatever has been stored -in the current session. +or storing a theorem. Therefore, the current theory consists of a body +of prebuilt theories that have been loaded from disk +(a collection of static components) plus whatever has been stored +in the current session. This latter component --- what has been stored in the current session ---- embodies the second sense of `current theory'. +--- embodies the second sense of `current theory'. It is more properly known as the `current theory segment'. The current -segment is dynamic in nature, for its contents can be augmented and +segment is dynamic in nature, for its contents can be augmented and overwritten. It functions as a kind of scratchpad used to help build a static theory segment. In a HOL session, there is always a single current theory segment. Its name is given by calling {current_theory()}. On startup, the current theory -segment is called {"scratch"}, which is just a default name. If one is +segment is called {"scratch"}, which is just a default name. If one is just experimenting, or hacking about, then this segment can be used. -On the other hand, if one intends to build a static theory segment, -one usually creates a new theory segment named {thy} by calling +On the other hand, if one intends to build a static theory segment, +one usually creates a new theory segment named {thy} by calling {new_theory thy}. This changes the value of {current_theory} to {thy}. Once such a theory segment has been built (which may take many sessions), one calls {export_theory}, which exports the stored elements diff --git a/help/Docfiles/Theory.delete_binding.doc b/help/Docfiles/Theory.delete_binding.doc index ed7c9908c6..922cb5246d 100644 --- a/help/Docfiles/Theory.delete_binding.doc +++ b/help/Docfiles/Theory.delete_binding.doc @@ -6,8 +6,8 @@ Remove a stored value from the current theory segment. \DESCRIBE -An invocation {delete_binding s} attempts to locate an axiom, definition, -or theorem that has been stored under name {s} in the current theory segment. +An invocation {delete_binding s} attempts to locate an axiom, definition, +or theorem that has been stored under name {s} in the current theory segment. If such a binding can be found, it is deleted. \FAILURE diff --git a/help/Docfiles/Theory.delete_const.doc b/help/Docfiles/Theory.delete_const.doc index 50c365f036..7a167286dc 100644 --- a/help/Docfiles/Theory.delete_const.doc +++ b/help/Docfiles/Theory.delete_const.doc @@ -10,15 +10,15 @@ constant, delete. \DESCRIBE An invocation {delete_const s} removes the constant denoted by {s} -from the current HOL segment. All types, terms, and theorems that +from the current HOL segment. All types, terms, and theorems that depend on that constant become garbage. -The implementation ensures that a deleted constant is never equal +The implementation ensures that a deleted constant is never equal to a subsequently declared constant, even if it has the same name and type. -Furthermore, although garbage types, terms, and theorems may exist in +Furthermore, although garbage types, terms, and theorems may exist in a session, and may even have been stored in the current segment for export, no theorem, definition, or axiom that is garbage is exported -when {export_theory} is invoked. +when {export_theory} is invoked. The prettyprinter highlights deleted constants. @@ -44,11 +44,11 @@ Induction stored under "foo_ind". } \COMMENTS -A type, term, or theorem that depends on a deleted constant may be +A type, term, or theorem that depends on a deleted constant may be detected by invoking the appropriate `uptodate' entrypoint. It may happen that a theorem {th} is proved with the use of another -theorem {th1} that subsequently becomes garbage because a +theorem {th1} that subsequently becomes garbage because a constant {c} was deleted. If {c} does not occur in {th}, then {th} does not become garbage, which may be contrary to expectation. The conservative extension property of HOL says that {th} is still provable, even in diff --git a/help/Docfiles/Theory.delete_type.doc b/help/Docfiles/Theory.delete_type.doc index 4b92794919..617a99b954 100644 --- a/help/Docfiles/Theory.delete_type.doc +++ b/help/Docfiles/Theory.delete_type.doc @@ -10,7 +10,7 @@ type, delete. \DESCRIBE An invocation {delete_type s} removes the type constant denoted by {s} -from the current HOL segment. All types, terms, and theorems that +from the current HOL segment. All types, terms, and theorems that depend on that type should therefore disappear, as though they hadn't been constructed in the first place. Conceptually, they have become "garbage" and need to be collected. However, because of the way that HOL is @@ -21,11 +21,11 @@ some consistency maintenance support. In particular, the implementation ensures that a deleted type operator is never equal to a subsequently declared type operator with the same name (and arity). Furthermore, although garbage types, -terms, and theorems may exist in a session, no theorem, definition, -or axiom that is garbage is exported when {export_theory} is invoked. +terms, and theorems may exist in a session, no theorem, definition, +or axiom that is garbage is exported when {export_theory} is invoked. The notion of garbage is hereditary. Any type, term, definition, or theorem -is garbage if any of its constituents are. Furthermore, if a type operator or +is garbage if any of its constituents are. Furthermore, if a type operator or term constant had been defined, and its witness theorem later becomes garbage, then that type or term is garbage, as is anything built from it. @@ -55,7 +55,7 @@ new_type ("foo", 2); } \COMMENTS -It's rather dodgy to withdraw constants from the HOL signature. +It's rather dodgy to withdraw constants from the HOL signature. It is not possible to delete constants from ancestor theories. diff --git a/help/Docfiles/Theory.export_theory.doc b/help/Docfiles/Theory.export_theory.doc index 650f69a0f5..38b44bf1b2 100644 --- a/help/Docfiles/Theory.export_theory.doc +++ b/help/Docfiles/Theory.export_theory.doc @@ -10,18 +10,18 @@ theory, export, file. \DESCRIBE An invocation {export_theory()} saves the current theory segment to disk. -All parents, definitions, axioms, and stored theorems of the segment +All parents, definitions, axioms, and stored theorems of the segment are saved in such a way that, when the theory is loaded from disk -in a later session, the full theory in place at the time -{export_theory} was called is re-instated. +in a later session, the full theory in place at the time +{export_theory} was called is re-instated. If the current theory segment is named {thy}, then {export_theory()} -will create ML files {thyTheory.sig} and {thyTheory.sml}, in -the current directory at the time {export_theory} is invoked. These -files need to be compiled before they become usable. In the standard way -of doing things, the {Holmake} facility will handle this task. +will create ML files {thyTheory.sig} and {thyTheory.sml}, in +the current directory at the time {export_theory} is invoked. These +files need to be compiled before they become usable. In the standard way +of doing things, the {Holmake} facility will handle this task. -Once a theory segment has been exported and compiled, it is available +Once a theory segment has been exported and compiled, it is available for use. It can be brought into an interactive proof session via { load "thyTheory"; @@ -32,9 +32,9 @@ definitions are incorporated into the current theory (recall that this notion is different than the current theory segment). \FAILURE -A call to {export_theory} may fail if the disk file cannot be opened. +A call to {export_theory} may fail if the disk file cannot be opened. A call to {export_theory} will also fail if some bindings are such that -the name of the binding is not a valid ML identifier. In that case, +the name of the binding is not a valid ML identifier. In that case, {export_theory} will report all such bad names. These can be changed with {set_MLname}, and then {export_theory} may be attempted again. @@ -50,10 +50,10 @@ Exporting theory "scratch" ... done. \COMMENTS -Note that {export_theory} exports the state of the -theory, and not that of the ML environment. If one wants to restore -the state of the ML environment in existence at the time -{export_theory()} is invoked, special steps have to be taken; +Note that {export_theory} exports the state of the +theory, and not that of the ML environment. If one wants to restore +the state of the ML environment in existence at the time +{export_theory()} is invoked, special steps have to be taken; see {adjoin_to_theory}. \SEEALSO diff --git a/help/Docfiles/Theory.new_axiom.doc b/help/Docfiles/Theory.new_axiom.doc index 033f4e5f41..15a10c22dc 100644 --- a/help/Docfiles/Theory.new_axiom.doc +++ b/help/Docfiles/Theory.new_axiom.doc @@ -6,12 +6,12 @@ Install a new axiom in the current theory. \DESCRIBE -If {M} is a term of type {bool}, a call {new_axiom(name,M)} creates +If {M} is a term of type {bool}, a call {new_axiom(name,M)} creates a theorem { |- tm } -and stores it away in the current theory segment under {name}. +and stores it away in the current theory segment under {name}. \FAILURE Fails if the given term does not have type {bool}. @@ -23,9 +23,9 @@ Fails if the given term does not have type {bool}. } \COMMENTS -For most purposes, it is unnecessary to declare new axioms: all +For most purposes, it is unnecessary to declare new axioms: all of classical mathematics can be derived by definitional extension -alone. Proceeding by definition is not only more elegant, but also +alone. Proceeding by definition is not only more elegant, but also guarantees the consistency of the deductions made. However, there are certain entities which cannot be modelled in simple type theory without further axioms, such as higher transfinite ordinals. diff --git a/help/Docfiles/Theory.new_constant.doc b/help/Docfiles/Theory.new_constant.doc index a003762c9b..16620f0e00 100644 --- a/help/Docfiles/Theory.new_constant.doc +++ b/help/Docfiles/Theory.new_constant.doc @@ -6,9 +6,9 @@ Declares a new constant in the current theory. \DESCRIBE -A call {new_constant(n,ty)} installs a new constant named {n} in +A call {new_constant(n,ty)} installs a new constant named {n} in the current theory. Note that {new_constant} does not specify a value -for the constant, just a name and type. The constant may have a +for the constant, just a name and type. The constant may have a polymorphic type, which can be used in arbitrary instantiations. \FAILURE @@ -17,11 +17,11 @@ name. It will overwrite an existing constant with the same name in the current theory. \SEEALSO -Theory.constants, boolSyntax.new_infix, boolSyntax.new_binder, -Definition.new_definition, Definition.new_type_definition, -Definition.new_specification, Theory.new_axiom, -boolSyntax.new_infixl_definition, -boolSyntax.new_infixr_definition, +Theory.constants, boolSyntax.new_infix, boolSyntax.new_binder, +Definition.new_definition, Definition.new_type_definition, +Definition.new_specification, Theory.new_axiom, +boolSyntax.new_infixl_definition, +boolSyntax.new_infixr_definition, boolSyntax.new_binder_definition. \ENDDOC diff --git a/help/Docfiles/Theory.new_type.doc b/help/Docfiles/Theory.new_type.doc index 66ef36d6d4..32c9be9858 100644 --- a/help/Docfiles/Theory.new_type.doc +++ b/help/Docfiles/Theory.new_type.doc @@ -7,7 +7,7 @@ Declares a new type or type constructor. \DESCRIBE A call {new_type(t,n)} declares a new {n}-ary type constructor called -{t} in the current theory segment. If {n} is zero, this is just a +{t} in the current theory segment. If {n} is zero, this is just a new base type. \FAILURE @@ -16,7 +16,7 @@ name. It will overwrite an existing type operator with the same name in the current theory. \EXAMPLE -A non-definitional version of ZF set theory might declare a new type {set} and +A non-definitional version of ZF set theory might declare a new type {set} and start using it as follows: { - new_theory "ZF"; diff --git a/help/Docfiles/Theory.parents.doc b/help/Docfiles/Theory.parents.doc index 359f4a49a5..2cf9a3d83b 100644 --- a/help/Docfiles/Theory.parents.doc +++ b/help/Docfiles/Theory.parents.doc @@ -8,7 +8,7 @@ Lists the parent theories of a named theory. \DESCRIBE If {s} is the name of the current theory or an ancestor of the current theory, the call {parents s} returns a list of strings that -identify the parent theories of {s}. The shorthand {"-"} may be +identify the parent theories of {s}. The shorthand {"-"} may be used to denote the name of the current theory segment. \FAILURE diff --git a/help/Docfiles/Theory.save_thm.doc b/help/Docfiles/Theory.save_thm.doc index dc7a14a977..ce3cc819b7 100644 --- a/help/Docfiles/Theory.save_thm.doc +++ b/help/Docfiles/Theory.save_thm.doc @@ -8,9 +8,9 @@ Stores a theorem in the current theory segment. \DESCRIBE The call {save_thm(name, th)} adds the theorem {th} to the current theory segment under the name {name}. The theorem is also the return -value of the call. When the current segment {thy} is exported, -things are arranged in such a way that, if {thyTheory} is loaded -into a later session, the ML variable {thyTheory.name} will +value of the call. When the current segment {thy} is exported, +things are arranged in such a way that, if {thyTheory} is loaded +into a later session, the ML variable {thyTheory.name} will have {th} as its value. \FAILURE @@ -30,12 +30,12 @@ message first). \COMMENTS -If a theorem is already saved under {name} in the current theory +If a theorem is already saved under {name} in the current theory segment, it will be overwritten. -The results of {new_axiom}, and definition principle (such as -{new_definition}, {new_type_definition}, and {new_specification}) -are automatically stored in the current theory: one does not have +The results of {new_axiom}, and definition principle (such as +{new_definition}, {new_type_definition}, and {new_specification}) +are automatically stored in the current theory: one does not have to call {save_thm} on them. \USES @@ -44,9 +44,9 @@ the result of {save_thm} to an ML variable makes it easy to access the theorem in the remainder of the current session. \SEEALSO -Theory.new_theory, Tactical.store_thm, DB.fetch, DB.thy, +Theory.new_theory, Tactical.store_thm, DB.fetch, DB.thy, Theory.current_definitions, Theory.current_theorems, Theory.uptodate_thm, -Theory.new_axiom, Definition.new_type_definition, +Theory.new_axiom, Definition.new_type_definition, Definition.new_definition, Definition.new_specification. \ENDDOC diff --git a/help/Docfiles/Theory.scrub.doc b/help/Docfiles/Theory.scrub.doc index c920e40c9c..f10a772771 100644 --- a/help/Docfiles/Theory.scrub.doc +++ b/help/Docfiles/Theory.scrub.doc @@ -6,24 +6,24 @@ Remove all out-of-date elements from the current theory segment. \DESCRIBE -An invocation {scrub()} goes through the current theory segment and +An invocation {scrub()} goes through the current theory segment and removes all out-of-date elements. \FAILURE Never fails. \EXAMPLE -In the following, we define a concrete type and examine the current +In the following, we define a concrete type and examine the current theory segment to see what consequences of this definition have been stored there. Then we delete the type, which turns all those -consequences into garbage. An query, like {current_theorems}, shows +consequences into garbage. An query, like {current_theorems}, shows that this garbage is not collected automatically. A manual invocation of {scrub} is necessary to show the true state of play. { - Hol_datatype `foo = A | B of 'a`; <> > val it = () : unit - + - current_theorems(); > val it = [("foo_induction", |- !P. P A /\ (!a. P (B a)) ==> !f. P f), @@ -33,13 +33,13 @@ of {scrub} is necessary to show the true state of play. |- !M M' v f. (M = M') /\ ((M' = A) ==> (v = v')) /\ (!a. (M' = B a) ==> (f a = f' a)) ==> - (case v f M = case v' f' M')), + (case v f M = case v' f' M')), ("foo_distinct", |- !a. ~(A = B a)), ("foo_11", |- !a a'. (B a = B a') = (a = a'))] : (string * thm) list - + - delete_type "foo"; > val it = () : unit - + - current_theorems(); > val it = [("foo_induction", |- !P. P A /\ (!a. P (B a)) ==> !f. P f), @@ -49,10 +49,10 @@ of {scrub} is necessary to show the true state of play. |- !M M' v f. (M = M') /\ ((M' = A) ==> (v = v')) /\ (!a. (M' = B a) ==> (f a = f' a)) ==> - (case v f M = case v' f' M')), + (case v f M = case v' f' M')), ("foo_distinct", |- !a. ~(A = B a)), ("foo_11", |- !a a'. (B a = B a') = (a = a'))] : (string * thm) list - + - scrub(); > val it = () : unit diff --git a/help/Docfiles/Theory.set_MLname.doc b/help/Docfiles/Theory.set_MLname.doc index 453c62b7d0..668b5cc229 100644 --- a/help/Docfiles/Theory.set_MLname.doc +++ b/help/Docfiles/Theory.set_MLname.doc @@ -15,14 +15,14 @@ identifier. For example, some advanced definition mechanisms in HOL automatically construct names to bind the results of making a definition. In some cases, particularly when symbolic identifiers are involved, a binding name can be generated that is not a valid ML -identifier. +identifier. -In such cases, we don't want to fail and lose the work done by the -definition mechanism. Instead, when {export_theory} is invoked, +In such cases, we don't want to fail and lose the work done by the +definition mechanism. Instead, when {export_theory} is invoked, all names binding axioms, definitions, and theorems are examined -to see if they are valid ML identifiers. If not, an informative +to see if they are valid ML identifiers. If not, an informative error message is generated, and it is up to the user to change the -names in the offending bindings. The function {set_MLname s1 s2} will +names in the offending bindings. The function {set_MLname s1 s2} will replace a binding with name {s1} by one with name {s2}. \FAILURE @@ -45,7 +45,7 @@ point. "%%_rules", "%%_ind", "%%_cases" are not acceptable ML identifiers. Use `set_MLname ' to change each name.>> -! Uncaught exception: +! Uncaught exception: ! HOL_ERR - (set_MLname "%%_rules" "odd_rules"; (* OK, do what it says *) @@ -64,12 +64,12 @@ The definition principles that currently have the potential to make problematic bindings are {Hol_datatype} and {Hol_reln}. It is slightly awkward to have to repair the names in a post-hoc fashion. -It is probably simpler to proceed by using alphanumeric names when +It is probably simpler to proceed by using alphanumeric names when defining constants, and to use overloading to get the desired name. \SEEALSO bossLib.Hol_reln, bossLib.Hol_datatype, Theory.export_theory, -Theory.current_definitions, Theory.current_theorems, +Theory.current_definitions, Theory.current_theorems, Theory.current_axioms, DB.thy, DB.dest_theory. \ENDDOC diff --git a/help/Docfiles/Theory.types.doc b/help/Docfiles/Theory.types.doc index aeea6b4eeb..6745863795 100644 --- a/help/Docfiles/Theory.types.doc +++ b/help/Docfiles/Theory.types.doc @@ -22,14 +22,14 @@ Fails unless the named theory is an ancestor, or the current theory. - itlist union (map types (ancestry "-")) []; > val it = - [("one", 0), ("option", 1), ("prod", 2), ("sum", 2), - ("fun", 2), ("ind", 0), ("bool", 0), ("num", 0), + [("one", 0), ("option", 1), ("prod", 2), ("sum", 2), + ("fun", 2), ("ind", 0), ("bool", 0), ("num", 0), ("recspace", 1), ("list", 1)] : (string * int) list } \SEEALSO -Theory.constants, Theory.current_axioms, Theory.current_definitions, -Theory.current_theorems, Theory.new_type, Definition.new_type_definition, +Theory.constants, Theory.current_axioms, Theory.current_definitions, +Theory.current_theorems, Theory.new_type, Definition.new_type_definition, Theory.parents, Theory.ancestry. \ENDDOC diff --git a/help/Docfiles/Theory.uptodate_thm.doc b/help/Docfiles/Theory.uptodate_thm.doc index dd171bcf5b..103f10060b 100644 --- a/help/Docfiles/Theory.uptodate_thm.doc +++ b/help/Docfiles/Theory.uptodate_thm.doc @@ -9,7 +9,7 @@ Tells if a theorem is out of date. theorem. \DESCRIBE -Operations in the current theory segment of HOL allow one to redefine +Operations in the current theory segment of HOL allow one to redefine types and constants. This can cause theorems to become invalid. As a result, HOL has a rudimentary consistency maintenance system built around the notion of whether type operators and term constants are @@ -17,12 +17,12 @@ around the notion of whether type operators and term constants are An invocation {uptodate_thm th} should check {th} to see if it has been proved from any out-of-date components. However, HOL does -not currently keep the proofs of theorems, so a simpler approach is -taken. Instead, {th} is checked to see if its hypotheses and +not currently keep the proofs of theorems, so a simpler approach is +taken. Instead, {th} is checked to see if its hypotheses and conclusions are up-to-date. All items from ancestor theories are fixed, and unable to -be overwritten, thus are always up-to-date. +be overwritten, thus are always up-to-date. \FAILURE Never fails. @@ -49,14 +49,14 @@ Induction stored under "fact_ind". \COMMENTS It may happen that a theorem {th} is proved with the use of another -theorem {th1} that subsequently becomes garbage because a +theorem {th1} that subsequently becomes garbage because a constant {c} was deleted. If {c} does not occur in {th}, then {th} does not become garbage, which may be contrary to expectation. The conservative extension property of HOL says that {th} is still provable, even in the absence of {c}. \SEEALSO -Theory.uptodate_type, Theory.uptodate_term, +Theory.uptodate_type, Theory.uptodate_term, Theory.delete_const, Theory.delete_type. \ENDDOC diff --git a/help/Docfiles/Theory.uptodate_type.doc b/help/Docfiles/Theory.uptodate_type.doc index 84a629c7f5..e162afeab3 100644 --- a/help/Docfiles/Theory.uptodate_type.doc +++ b/help/Docfiles/Theory.uptodate_type.doc @@ -9,7 +9,7 @@ Tells if a type is out of date. type. \DESCRIBE -Operations in the current theory segment of HOL allow one to redefine +Operations in the current theory segment of HOL allow one to redefine types and constants. This can cause theorems to become invalid. As a result, HOL has a rudimentary consistency maintenance system built around the notion of whether type operators and term constants are @@ -25,7 +25,7 @@ out-of-date if it has been re-declared or if the witness theorem used to justify the type in the call to {new_type_definition} is out-of-date. Only a component of the current theory segment may be out-of-date. All items from ancestor theories are fixed, and unable to -be overwritten, thus are always up-to-date. +be overwritten, thus are always up-to-date. \FAILURE Never fails. @@ -35,7 +35,7 @@ Never fails. - Hol_datatype `foo = A | B of 'a`; <> > val it = () : unit - + - val ty = Type `:'a foo list`; > val ty = `:'a foo list` : hol_type diff --git a/help/Docfiles/Thm.Beta.doc b/help/Docfiles/Thm.Beta.doc index 3a4469367c..703f49a012 100644 --- a/help/Docfiles/Thm.Beta.doc +++ b/help/Docfiles/Thm.Beta.doc @@ -3,7 +3,7 @@ \TYPE {Beta : thm -> thm} \SYNOPSIS -Perform one step of beta-reduction on the right hand side of +Perform one step of beta-reduction on the right hand side of an equational theorem. \KEYWORDS diff --git a/help/Docfiles/Thm.GEN.doc b/help/Docfiles/Thm.GEN.doc index 69235b061a..f928a79c71 100644 --- a/help/Docfiles/Thm.GEN.doc +++ b/help/Docfiles/Thm.GEN.doc @@ -36,7 +36,7 @@ the derivation of the theorem {x=T |- !x. x=T}, which is clearly invalid. - try (GEN (Term `x:bool`)) t; Exception raised at Thm.GEN: variable occurs free in hypotheses - ! Uncaught exception: + ! Uncaught exception: ! HOL_ERR } diff --git a/help/Docfiles/Thm.INST.doc b/help/Docfiles/Thm.INST.doc index d1218cff64..ef90f0af82 100644 --- a/help/Docfiles/Thm.INST.doc +++ b/help/Docfiles/Thm.INST.doc @@ -14,8 +14,8 @@ in a theorem. { A |- t INST [x1 |-> t1,...,xn |-> tn] ----------------------------- - A[t1,...,tn/x1,...,xn] - |- + A[t1,...,tn/x1,...,xn] + |- t[t1,...,tn/x1,...,xn] } @@ -26,13 +26,13 @@ Fails if, for {1 <= i <= n}, some {xi} is not a variable, or if some \EXAMPLE In the following example a theorem is instantiated for a specific term: -{ +{ - load"arithmeticTheory"; - CONJUNCT1 arithmeticTheory.ADD_CLAUSES; > val it = |- 0 + m = m : thm - - INST [``m:num`` |-> ``2*x``] + - INST [``m:num`` |-> ``2*x``] (CONJUNCT1 arithmeticTheory.ADD_CLAUSES); val it = |- 0 + (2 * x) = 2 * x : thm diff --git a/help/Docfiles/Thm.INST_TYPE.doc b/help/Docfiles/Thm.INST_TYPE.doc index 6323eca751..3e0648a54d 100644 --- a/help/Docfiles/Thm.INST_TYPE.doc +++ b/help/Docfiles/Thm.INST_TYPE.doc @@ -15,8 +15,8 @@ instantiation of type variables. A |- t ----------------------------------- INST_TYPE[vty1|->ty1,..., vtyn|->tyn] - A[ty1,...,tyn/vty1,...,vtyn] - |- + A[ty1,...,tyn/vty1,...,vtyn] + |- t[ty1,...,tyn/vty1,...,vtyn] } Type substitution is performed throughout the hypotheses and diff --git a/help/Docfiles/Thm.SUBST.doc b/help/Docfiles/Thm.SUBST.doc index 6efe89f1e6..1c22556e80 100644 --- a/help/Docfiles/Thm.SUBST.doc +++ b/help/Docfiles/Thm.SUBST.doc @@ -47,7 +47,7 @@ equations (i.e. the terms {t1}, ... , {tn}). { - val x = --`x:num`-- and y = --`y:num`-- - and th0 = SPEC (--`0`--) arithmeticTheory.ADD1 + and th0 = SPEC (--`0`--) arithmeticTheory.ADD1 and th1 = SPEC (--`1`--) arithmeticTheory.ADD1; (* x = `x` @@ -55,21 +55,21 @@ equations (i.e. the terms {t1}, ... , {tn}). th0 = |- SUC 0 = 0 + 1 th1 = |- SUC 1 = 1 + 1 *) -- SUBST [x |-> th0, y |-> th1] +- SUBST [x |-> th0, y |-> th1] (--`(x+y) > SUC 0`--) (ASSUME (--`(SUC 0 + SUC 1) > SUC 0`--)); > val it = [.] |- (0 + 1) + 1 + 1 > SUC 0 : thm -- SUBST [x |-> th0, y |-> th1] +- SUBST [x |-> th0, y |-> th1] (--`(SUC 0 + y) > SUC 0`--) (ASSUME (--`(SUC 0 + SUC 1) > SUC 0`--)); > val it = [.] |- SUC 0 + 1 + 1 > SUC 0 : thm -- SUBST [x |-> th0, y |-> th1] +- SUBST [x |-> th0, y |-> th1] (--`(x+y) > x`--) (ASSUME (--`(SUC 0 + SUC 1) > SUC 0`--)); diff --git a/help/Docfiles/Thm.Specialize.doc b/help/Docfiles/Thm.Specialize.doc index bbf74d5ba3..5280610434 100644 --- a/help/Docfiles/Thm.Specialize.doc +++ b/help/Docfiles/Thm.Specialize.doc @@ -9,7 +9,7 @@ Specializes the conclusion of a universal theorem. rule, specialization. \DESCRIBE -When applied to a term {u} and a theorem {A |- !x. t}, +When applied to a term {u} and a theorem {A |- !x. t}, {Specialize} returns the theorem {A |- t[u/x]}. Care is taken to ensure that no variables free in {u} become bound after this operation. diff --git a/help/Docfiles/Thm.TRANS.doc b/help/Docfiles/Thm.TRANS.doc index 62aac5fdee..49eb160c5c 100644 --- a/help/Docfiles/Thm.TRANS.doc +++ b/help/Docfiles/Thm.TRANS.doc @@ -10,7 +10,7 @@ rule, transitivity, equality. \DESCRIBE When applied to a theorem {A1 |- t1 = t2} and a theorem {A2 |- t2 = t3}, the -inference rule {TRANS} returns the theorem {A1 u A2 |- t1 = t3}. +inference rule {TRANS} returns the theorem {A1 u A2 |- t1 = t3}. { A1 |- t1 = t2 A2 |- t2 = t3 ------------------------------- TRANS @@ -26,7 +26,7 @@ being the same as the left side of the second. { - val t1 = ASSUME ``a:bool = b`` and t2 = ASSUME ``b:bool = c``; val t1 = [.] |- a = b : thm - val t2 = [.] |- b = c : thm + val t2 = [.] |- b = c : thm - TRANS t1 t2; val it = [..] |- a = c : thm diff --git a/help/Docfiles/Thm.hyp.doc b/help/Docfiles/Thm.hyp.doc index dfe67472df..bbc4238100 100644 --- a/help/Docfiles/Thm.hyp.doc +++ b/help/Docfiles/Thm.hyp.doc @@ -13,7 +13,7 @@ list of hypotheses of the theorem. Never fails. \COMMENTS -The order in which hypotheses are returned can not be relied on. +The order in which hypotheses are returned can not be relied on. \SEEALSO Thm.dest_thm, Thm.concl. diff --git a/help/Docfiles/Thm.mk_thm.doc b/help/Docfiles/Thm.mk_thm.doc index 50e116696b..1722f52c10 100644 --- a/help/Docfiles/Thm.mk_thm.doc +++ b/help/Docfiles/Thm.mk_thm.doc @@ -16,7 +16,7 @@ and conclusion. All the terms therein should be of type {bool}. of it tags the resulting theorem with {MK_THM}. \FAILURE -Fails unless all the terms provided for assumptions and conclusion +Fails unless all the terms provided for assumptions and conclusion are of type {bool}. \EXAMPLE diff --git a/help/Docfiles/Thm.tag.doc b/help/Docfiles/Thm.tag.doc index e5ad93c455..ea663db07e 100644 --- a/help/Docfiles/Thm.tag.doc +++ b/help/Docfiles/Thm.tag.doc @@ -10,7 +10,7 @@ tag, theorem. \DESCRIBE An invocation {tag th}, where {th} has type {thm}, returns the tag -of the theorem. If derivation of the theorem has appealed at some +of the theorem. If derivation of the theorem has appealed at some point to an oracle, the tag of that oracle will be embedded in the result. Otherwise, an empty tag is returned. diff --git a/help/Docfiles/Thm.thm.doc b/help/Docfiles/Thm.thm.doc index da562e5f24..0ff91b3e9a 100644 --- a/help/Docfiles/Thm.thm.doc +++ b/help/Docfiles/Thm.thm.doc @@ -9,11 +9,11 @@ Type of theorems of the HOL logic. theorem, primitive inference. \DESCRIBE -The abstract type {thm} represents the theorems derivable by inference +The abstract type {thm} represents the theorems derivable by inference in the HOL logic. The type of theorems can be viewed as the inductive closure -of the axioms of the HOL logic by the primitive inference rules of HOL. +of the axioms of the HOL logic by the primitive inference rules of HOL. Robin Milner had the brilliant insight to implement this view by encapsulating -the primitive rules of inference for a logic as the constructors for +the primitive rules of inference for a logic as the constructors for an abstract type of theorems. This implementation technique is adopted in HOL. \SEEALSO diff --git a/help/Docfiles/Thm_cont.IMP_RES_THEN.doc b/help/Docfiles/Thm_cont.IMP_RES_THEN.doc index d1a4df89a5..26b207ed43 100644 --- a/help/Docfiles/Thm_cont.IMP_RES_THEN.doc +++ b/help/Docfiles/Thm_cont.IMP_RES_THEN.doc @@ -59,9 +59,9 @@ entry for {RES_CANON}. Evaluating {IMP_RES_THEN ttac th (A ?- g)} fails if no assumption of the goal {A ?- g} can be resolved with the implication or implications derived from {th}. Evaluation also fails if there are resolvents, but for every resolvent {Ai u {aj} |- vi} -evaluating the application {ttac (Ai u {aj} |- vi)} fails---that -is, if for every resolvent {ttac} fails to produce a tactic. Finally, -failure is propagated if any of the tactics that are produced from +evaluating the application {ttac (Ai u {aj} |- vi)} fails---that +is, if for every resolvent {ttac} fails to produce a tactic. Finally, +failure is propagated if any of the tactics that are produced from the resolvents by {ttac} fails when applied in sequence to the goal. \EXAMPLE diff --git a/help/Docfiles/Thm_cont.X_CASES_THEN.doc b/help/Docfiles/Thm_cont.X_CASES_THEN.doc index b9547117b5..be085dd875 100644 --- a/help/Docfiles/Thm_cont.X_CASES_THEN.doc +++ b/help/Docfiles/Thm_cont.X_CASES_THEN.doc @@ -59,7 +59,7 @@ used to split into 2 cases: { th = |- (?m. x = 2 * m) \/ (?m. x = (2 * m) + 1) } -by the tactic +by the tactic { X_CASES_THEN [[Term`n:num`],[Term`n:num]] ASSUME_TAC th } diff --git a/help/Docfiles/TotalDefn.DefineSchema.doc b/help/Docfiles/TotalDefn.DefineSchema.doc index 877d64b1f1..ebab1dfbb0 100644 --- a/help/Docfiles/TotalDefn.DefineSchema.doc +++ b/help/Docfiles/TotalDefn.DefineSchema.doc @@ -13,19 +13,19 @@ Schema, recursive definition. `recursion schemas`. These are just recursive functions with extra free variables (also called `parameters`) on the right-hand side of some clauses. Such schemas have been used as a basis for program -transformation systems. +transformation systems. {DefineSchema} takes its input in exactly the same format as {Define}. The termination constraints of a schematic definition are collected on -the hypotheses of the definition, and also on the hypotheses of the +the hypotheses of the definition, and also on the hypotheses of the automatically proved induction theorem, but a termination proof is only -attempted when the termination conditions have no occurrences of +attempted when the termination conditions have no occurrences of parameters. This is because, in general, termination can only be proved after some of the parameters of the schema have been instantiated. \FAILURE -{DefineSchema} fails in many of the same ways as {Define}. However, it +{DefineSchema} fails in many of the same ways as {Define}. However, it will not fail if it cannot prove termination. \EXAMPLE @@ -43,7 +43,7 @@ The following defines a schema for binary recursion. Induction stored under "binRec_ind". > val it = - [!x. ~atomic x ==> R (left x) x, + [!x. ~atomic x ==> R (left x) x, !x. ~atomic x ==> R (right x) x, WF R] |- binRec A atomic join left right x = if atomic x then A x @@ -52,7 +52,7 @@ The following defines a schema for binary recursion. (binRec A atomic join left right (right x)) : thm } The following defines a schema in which a termination proof is -attempted successfully. +attempted successfully. { - DefineSchema `(map [] = []) /\ (map (h::t) = f h :: map t)`; diff --git a/help/Docfiles/Type.arrow.doc b/help/Docfiles/Type.arrow.doc index dfadf72a92..290eafbdb4 100644 --- a/help/Docfiles/Type.arrow.doc +++ b/help/Docfiles/Type.arrow.doc @@ -23,7 +23,7 @@ Never fails. \COMMENTS -This operator associates to the right, that is, {ty1 --> ty2 --> ty3} +This operator associates to the right, that is, {ty1 --> ty2 --> ty3} is identical to {ty1 --> (ty2 --> ty3)}. \SEEALSO diff --git a/help/Docfiles/Type.dest_thy_type.doc b/help/Docfiles/Type.dest_thy_type.doc index c951e96f7d..ad68f72cfb 100644 --- a/help/Docfiles/Type.dest_thy_type.doc +++ b/help/Docfiles/Type.dest_thy_type.doc @@ -1,8 +1,8 @@ \DOC dest_thy_type \BLTYPE -dest_thy_type - : hol_type -> {Thy:string, Tyop:string, +dest_thy_type + : hol_type -> {Thy:string, Tyop:string, Args:hol_type list} \ELTYPE @@ -12,8 +12,8 @@ Breaks apart a type (other than a variable type). \DESCRIBE -If {ty} is an application of a type operator {Tyop}, which -was declared in theory {Thy}, to a list of types {Args}, then +If {ty} is an application of a type operator {Tyop}, which +was declared in theory {Thy}, to a list of types {Args}, then {dest_thy_type ty} returns {{Tyop,Thy,Args}}. \FAILURE diff --git a/help/Docfiles/Type.dest_type.doc b/help/Docfiles/Type.dest_type.doc index f097977f5f..09131466e2 100644 --- a/help/Docfiles/Type.dest_type.doc +++ b/help/Docfiles/Type.dest_type.doc @@ -24,7 +24,7 @@ Fails if {ty} is a type variable. \COMMENTS -A more precise alternative is {dest_thy_type}, which tells which theory +A more precise alternative is {dest_thy_type}, which tells which theory the type operator was declared in. \SEEALSO diff --git a/help/Docfiles/Type.gen_tyvar.doc b/help/Docfiles/Type.gen_tyvar.doc index 1c3a6870a0..b513c5c644 100644 --- a/help/Docfiles/Type.gen_tyvar.doc +++ b/help/Docfiles/Type.gen_tyvar.doc @@ -13,8 +13,8 @@ Type \DESCRIBE An invocation {gen_tyvar()} generates a type variable {tyv} not -seen in the current session. Furthermore, the concrete syntax -of {tyv} is such that {tyv} is not obtainable by {mk_vartype}, +seen in the current session. Furthermore, the concrete syntax +of {tyv} is such that {tyv} is not obtainable by {mk_vartype}, or by parsing. \FAILURE @@ -38,7 +38,7 @@ incorrect syntax \COMMENTS -In general, the actual name returned by {gen_tyvar} should not be +In general, the actual name returned by {gen_tyvar} should not be relied on. \USES diff --git a/help/Docfiles/Type.ind.doc b/help/Docfiles/Type.ind.doc index e670826635..c76442b0ab 100644 --- a/help/Docfiles/Type.ind.doc +++ b/help/Docfiles/Type.ind.doc @@ -10,7 +10,7 @@ Type \DESCRIBE The ML variable {Type.ind} is bound to the HOL type constant {ind}. -The axiom {INFINITY_AX} in {boolTheory} states that {ind} represents +The axiom {INFINITY_AX} in {boolTheory} states that {ind} represents an infinite set of individuals. \SEEALSO diff --git a/help/Docfiles/Type.match_type.doc b/help/Docfiles/Type.match_type.doc index 61badf5c6f..04df6bbb36 100644 --- a/help/Docfiles/Type.match_type.doc +++ b/help/Docfiles/Type.match_type.doc @@ -3,7 +3,7 @@ \TYPE {match_type : hol_type -> hol_type -> hol_type subst} \SYNOPSIS -Calculates a substitution {theta} such that instantiating the first +Calculates a substitution {theta} such that instantiating the first argument with {theta} equals the second argument. \DESCRIBE @@ -30,7 +30,7 @@ If no such substitution can be found. - match_type (alpha --> alpha) (ind --> bool); -! Uncaught exception: +! Uncaught exception: ! HOL_ERR } diff --git a/help/Docfiles/Type.mk_thy_type.doc b/help/Docfiles/Type.mk_thy_type.doc index ecbd9efd6a..90e3aa0a65 100644 --- a/help/Docfiles/Type.mk_thy_type.doc +++ b/help/Docfiles/Type.mk_thy_type.doc @@ -1,7 +1,7 @@ \DOC mk_thy_type \BLTYPE -mk_thy_type +mk_thy_type : {Thy:string, Tyop:string, Args:hol_type list} -> hol_type \ELTYPE @@ -15,8 +15,8 @@ to {n}, then {mk_thy_type{Tyop=s, Thy=thy, Args=tyl}} returns the requested compound type. \FAILURE -Fails if {s} is not the name of a type in theory {thy}, if {thy} is -not in the ancestry of the current theory, or if {n} is not +Fails if {s} is not the name of a type in theory {thy}, if {thy} is +not in the ancestry of the current theory, or if {n} is not the length of {tyl}. \EXAMPLE @@ -25,14 +25,14 @@ the length of {tyl}. > val it = `:'a -> bool` : hol_type - try mk_thy_type {Tyop="bar", Thy="foo", Args = []}; - + Exception raised at Type.mk_thy_type: "foo$bar" not found } \COMMENTS -In general, {mk_thy_type} is to be preferred over {mk_type} because +In general, {mk_thy_type} is to be preferred over {mk_type} because HOL provides a fresh namespace for each theory ({mk_type} is a holdover from a time when there was only one namespace shared by all theories). diff --git a/help/Docfiles/Type.mk_type.doc b/help/Docfiles/Type.mk_type.doc index 51d76e5ffa..a70ffc17bb 100644 --- a/help/Docfiles/Type.mk_type.doc +++ b/help/Docfiles/Type.mk_type.doc @@ -6,12 +6,12 @@ Constructs a compound type. \DESCRIBE -{mk_type(tyop,[ty1,...,tyn])} returns the HOL type {(ty1,...,tyn)tyop}, +{mk_type(tyop,[ty1,...,tyn])} returns the HOL type {(ty1,...,tyn)tyop}, provided {tyop} is the name of a known {n}-ary type constructor. \FAILURE Fails if {tyop} is not the name of a known type, or if {tyop} is known, -but the length of the list of argument types is not equal to the arity +but the length of the list of argument types is not equal to the arity of {tyop}. \EXAMPLE @@ -26,7 +26,7 @@ of {tyop}. \COMMENTS Note that type operators with the same name (and arity) may -be declared in different theories. If two theories having type +be declared in different theories. If two theories having type operators with the same name {s} are in the ancestry of the current theory, then {mk_type(s,tyl)} will issue a warning before arbitrarily selecting which type operator to use. In such situations, it is diff --git a/help/Docfiles/Type.op_arity.doc b/help/Docfiles/Type.op_arity.doc index bfb0f4ef65..8d91b42c59 100644 --- a/help/Docfiles/Type.op_arity.doc +++ b/help/Docfiles/Type.op_arity.doc @@ -10,7 +10,7 @@ signature, type operator. \DESCRIBE An invocation {op_arity{Tyop,Thy}} returns {NONE} if the given record -does not identify a type operator in the current type signature. +does not identify a type operator in the current type signature. Otherwise, it returns {SOME n}, where {n} identifies the number of arguments the specified type operator takes. diff --git a/help/Docfiles/Type.polymorphic.doc b/help/Docfiles/Type.polymorphic.doc index fb28ec134c..7fcf83b121 100644 --- a/help/Docfiles/Type.polymorphic.doc +++ b/help/Docfiles/Type.polymorphic.doc @@ -10,7 +10,7 @@ variable, type. \DESCRIBE An invocation {polymorphic ty} checks to see if {ty} has an occurrence -of any type variable. It is equivalent in functionality to +of any type variable. It is equivalent in functionality to {not o null o type_vars}, but may be more efficient in some situations, since it can stop processing once it finds one type variable. diff --git a/help/Docfiles/Type.raw_match_type.doc b/help/Docfiles/Type.raw_match_type.doc index 547586dc81..f99131905c 100644 --- a/help/Docfiles/Type.raw_match_type.doc +++ b/help/Docfiles/Type.raw_match_type.doc @@ -15,16 +15,16 @@ type, matching. \DESCRIBE An invocation {raw_match_type pat ty (S,Id)} performs matching, just -as {match_type}, except that it takes an extra accumulating parameter -{(S,Id)}, which represents a 'raw' substitution that the match +as {match_type}, except that it takes an extra accumulating parameter +{(S,Id)}, which represents a 'raw' substitution that the match {(theta,id)} of {pat} and {ty} must be compatible with. If matching is successful, {(theta,id)} is merged with {(S,Id)} to yield the result. \FAILURE -A call to {raw_match_type pat ty (S,Id)} will fail -when {match_type pat ty} would. It will also fail when a -{{redex,residue}} calculated in the course of matching {pat} and {ty} -is such that there is a {{redex_i,residue_i}} in {S} and {redex} +A call to {raw_match_type pat ty (S,Id)} will fail +when {match_type pat ty} would. It will also fail when a +{{redex,residue}} calculated in the course of matching {pat} and {ty} +is such that there is a {{redex_i,residue_i}} in {S} and {redex} equals {redex_i} but {residue} does not equal {residue_i}. \EXAMPLE diff --git a/help/Docfiles/Type.type_varsl.doc b/help/Docfiles/Type.type_varsl.doc index 197b712138..1ea58ec107 100644 --- a/help/Docfiles/Type.type_varsl.doc +++ b/help/Docfiles/Type.type_varsl.doc @@ -9,8 +9,8 @@ Returns the set of type variables in a list of types. variable, type. \DESCRIBE -An invocation {type_varsl [ty1,...,tyn]} returns a list -representing the set-theoretic union of the type variables +An invocation {type_varsl [ty1,...,tyn]} returns a list +representing the set-theoretic union of the type variables occurring in {ty1,...,tyn}. \FAILURE diff --git a/help/Docfiles/boolSimps.bool_ss.doc b/help/Docfiles/boolSimps.bool_ss.doc index d34e673bb4..ff6b820376 100644 --- a/help/Docfiles/boolSimps.bool_ss.doc +++ b/help/Docfiles/boolSimps.bool_ss.doc @@ -3,7 +3,7 @@ \TYPE {bool_ss : simpset} \SYNOPSIS -Basic simpset containing standard propositional and first order +Basic simpset containing standard propositional and first order logic simplifications, plus beta-conversion. \DESCRIBE diff --git a/help/Docfiles/boolSyntax.dest_arb.doc b/help/Docfiles/boolSyntax.dest_arb.doc index 14b6da07ff..83a1622b1e 100644 --- a/help/Docfiles/boolSyntax.dest_arb.doc +++ b/help/Docfiles/boolSyntax.dest_arb.doc @@ -9,7 +9,7 @@ Extract the type of an instance of the {ARB} constant. \DESCRIBE -If {M} is an instance of the constant {ARB} with type {ty}, then +If {M} is an instance of the constant {ARB} with type {ty}, then {dest_arb M} equals {ty}. \FAILURE diff --git a/help/Docfiles/boolSyntax.dest_bool_case.doc b/help/Docfiles/boolSyntax.dest_bool_case.doc index 569c46e4ce..df0e6a335b 100644 --- a/help/Docfiles/boolSyntax.dest_bool_case.doc +++ b/help/Docfiles/boolSyntax.dest_bool_case.doc @@ -6,7 +6,7 @@ Destructs a case expression over {bool}. \DESCRIBE -If {M} has the form {bool_case M1 M2 b}, then {dest_bool_case M} +If {M} has the form {bool_case M1 M2 b}, then {dest_bool_case M} returns {M1,M2,b}. \FAILURE diff --git a/help/Docfiles/boolSyntax.dest_cond.doc b/help/Docfiles/boolSyntax.dest_cond.doc index a1b279972b..f34cf7f573 100644 --- a/help/Docfiles/boolSyntax.dest_cond.doc +++ b/help/Docfiles/boolSyntax.dest_cond.doc @@ -6,7 +6,7 @@ Breaks apart a conditional into the three terms involved. \DESCRIBE -If {M} has the form {if t then t1 else t2} then {dest_cond M} +If {M} has the form {if t then t1 else t2} then {dest_cond M} returns {(t,t1,t2)}. \FAILURE diff --git a/help/Docfiles/boolSyntax.dest_eq_ty.doc b/help/Docfiles/boolSyntax.dest_eq_ty.doc index ec9b5e404c..7b678380a0 100644 --- a/help/Docfiles/boolSyntax.dest_eq_ty.doc +++ b/help/Docfiles/boolSyntax.dest_eq_ty.doc @@ -14,7 +14,7 @@ If {M} is the term {t1 = t2}, then {dest_eq_ty M} returns Fails if {M} is not an equality. \USES -Gives an efficient way to break apart an equality and get the +Gives an efficient way to break apart an equality and get the type of the equality. Useful for obtaining that last fraction of speed when optimizing the bejeesus out of an inference rule. diff --git a/help/Docfiles/boolSyntax.dest_imp.doc b/help/Docfiles/boolSyntax.dest_imp.doc index c9d43ed551..ddabe1933b 100644 --- a/help/Docfiles/boolSyntax.dest_imp.doc +++ b/help/Docfiles/boolSyntax.dest_imp.doc @@ -8,7 +8,7 @@ Breaks an implication or negation into antecedent and consequent. \DESCRIBE {dest_imp} is a term destructor for implications. It treats negations as implications with consequent {F}. Thus, if {M} is a term with the form -{t1 ==> t2}, then {dest_imp M} returns {(t1,t2)}, and if {M} has the +{t1 ==> t2}, then {dest_imp M} returns {(t1,t2)}, and if {M} has the form {~t}, then {dest_imp M} returns {(t,F)}. \FAILURE diff --git a/help/Docfiles/boolSyntax.dest_imp_only.doc b/help/Docfiles/boolSyntax.dest_imp_only.doc index fd9af5cca4..88d6a45b08 100644 --- a/help/Docfiles/boolSyntax.dest_imp_only.doc +++ b/help/Docfiles/boolSyntax.dest_imp_only.doc @@ -6,7 +6,7 @@ Breaks an implication into antecedent and consequent. \DESCRIBE -If {M} is a term with the form {t1 ==> t2}, then {dest_imp_only M} +If {M} is a term with the form {t1 ==> t2}, then {dest_imp_only M} returns {(t1,t2)}. \FAILURE diff --git a/help/Docfiles/boolSyntax.dest_neg.doc b/help/Docfiles/boolSyntax.dest_neg.doc index 0815cdc9a4..9ccc6f5ba8 100644 --- a/help/Docfiles/boolSyntax.dest_neg.doc +++ b/help/Docfiles/boolSyntax.dest_neg.doc @@ -6,7 +6,7 @@ Breaks apart a negation, returning its body. \DESCRIBE -{dest_neg} is a term destructor for negations: if {M} has the +{dest_neg} is a term destructor for negations: if {M} has the form {~t}, then {dest_neg M} returns {t}. \FAILURE diff --git a/help/Docfiles/boolSyntax.is_bool_case.doc b/help/Docfiles/boolSyntax.is_bool_case.doc index e58b380e26..1f19cd643c 100644 --- a/help/Docfiles/boolSyntax.is_bool_case.doc +++ b/help/Docfiles/boolSyntax.is_bool_case.doc @@ -6,7 +6,7 @@ Tests a case expression over {bool}. \DESCRIBE -If {M} has the form {bool_case M1 M2 b}, then {is_bool_case M} +If {M} has the form {bool_case M1 M2 b}, then {is_bool_case M} returns {true}. Otherwise, it returns {false}. \FAILURE diff --git a/help/Docfiles/boolSyntax.is_cond.doc b/help/Docfiles/boolSyntax.is_cond.doc index 4783cece53..e1a268f682 100644 --- a/help/Docfiles/boolSyntax.is_cond.doc +++ b/help/Docfiles/boolSyntax.is_cond.doc @@ -6,7 +6,7 @@ Tests a term to see if it is a conditional. \DESCRIBE -If {M} has the form {if t then t1 else t2} then {is_cond M} +If {M} has the form {if t then t1 else t2} then {is_cond M} returns {true} If the term is not a conditional the result is {false}. diff --git a/help/Docfiles/boolSyntax.is_exists.doc b/help/Docfiles/boolSyntax.is_exists.doc index 629d7fbfcf..ccda595171 100644 --- a/help/Docfiles/boolSyntax.is_exists.doc +++ b/help/Docfiles/boolSyntax.is_exists.doc @@ -6,7 +6,7 @@ Tests a term to see if it is an existential quantification. \DESCRIBE -If {M} has the form {?v. t} then {is_exists M} returns {true}. +If {M} has the form {?v. t} then {is_exists M} returns {true}. If the term is not an existential quantification the result is {false}. \FAILURE diff --git a/help/Docfiles/boolSyntax.is_exists1.doc b/help/Docfiles/boolSyntax.is_exists1.doc index f1cd4c4011..50b6d87138 100644 --- a/help/Docfiles/boolSyntax.is_exists1.doc +++ b/help/Docfiles/boolSyntax.is_exists1.doc @@ -6,7 +6,7 @@ Tests a term to see if it is a unique existence term. \DESCRIBE -If {M} has the form {?!v. t} then {is_exists1 M} returns {true}. +If {M} has the form {?!v. t} then {is_exists1 M} returns {true}. If the term is not a unique existence quantification the result is {false}. \FAILURE diff --git a/help/Docfiles/boolSyntax.is_imp.doc b/help/Docfiles/boolSyntax.is_imp.doc index 21f6c1fc9e..0fe8239883 100644 --- a/help/Docfiles/boolSyntax.is_imp.doc +++ b/help/Docfiles/boolSyntax.is_imp.doc @@ -6,8 +6,8 @@ Tests a term to see if it is an implication or a negation. \DESCRIBE -If {M} has the form {t1 ==> t2}, or the form {~t}, then {is_imp M} -returns {true}. If the term is neither an implication nor a negation +If {M} has the form {t1 ==> t2}, or the form {~t}, then {is_imp M} +returns {true}. If the term is neither an implication nor a negation the result is {false}. \FAILURE diff --git a/help/Docfiles/boolSyntax.is_imp_only.doc b/help/Docfiles/boolSyntax.is_imp_only.doc index b0dba69b39..583e0f0ffd 100644 --- a/help/Docfiles/boolSyntax.is_imp_only.doc +++ b/help/Docfiles/boolSyntax.is_imp_only.doc @@ -6,7 +6,7 @@ Tests a term to see if it is an implication. \DESCRIBE -If {M} has the form {t1 ==> t2} then {is_imp_only M} returns {true}. +If {M} has the form {t1 ==> t2} then {is_imp_only M} returns {true}. If the term is not an implication, the result is {false}. \FAILURE diff --git a/help/Docfiles/boolSyntax.mk_arb.doc b/help/Docfiles/boolSyntax.mk_arb.doc index 793829cf4e..80e56f51b7 100644 --- a/help/Docfiles/boolSyntax.mk_arb.doc +++ b/help/Docfiles/boolSyntax.mk_arb.doc @@ -16,7 +16,7 @@ constant. Never fails. \COMMENTS -{ARB} is a constant of type {'a}. It is sometimes used for +{ARB} is a constant of type {'a}. It is sometimes used for creating pseudo-partial functions. \SEEALSO diff --git a/help/Docfiles/boolSyntax.mk_bool_case.doc b/help/Docfiles/boolSyntax.mk_bool_case.doc index 35699803e5..c0fd7e3723 100644 --- a/help/Docfiles/boolSyntax.mk_bool_case.doc +++ b/help/Docfiles/boolSyntax.mk_bool_case.doc @@ -11,7 +11,7 @@ displays this as {case b of T -> M1 || F -> M2}. The {bool_case} constant may be thought of as a pattern-matching version of the conditional. \FAILURE -Fails if {b} is not of type {bool}. Also fails if {M1} and {M2} do not +Fails if {b} is not of type {bool}. Also fails if {M1} and {M2} do not have the same type. \EXAMPLE diff --git a/help/Docfiles/boolSyntax.mk_disj.doc b/help/Docfiles/boolSyntax.mk_disj.doc index bf0198c8b2..0d7f1aaf32 100644 --- a/help/Docfiles/boolSyntax.mk_disj.doc +++ b/help/Docfiles/boolSyntax.mk_disj.doc @@ -6,7 +6,7 @@ Constructs a disjunction. \DESCRIBE -If {t1} and {t2} are terms, both of type {bool}, then +If {t1} and {t2} are terms, both of type {bool}, then {mk_disj(t1,t2)} returns the term {t1 \/ t2}. \FAILURE diff --git a/help/Docfiles/boolSyntax.mk_exists.doc b/help/Docfiles/boolSyntax.mk_exists.doc index 5e3f774090..f02769b796 100644 --- a/help/Docfiles/boolSyntax.mk_exists.doc +++ b/help/Docfiles/boolSyntax.mk_exists.doc @@ -6,7 +6,7 @@ Term constructor for existential quantification. \DESCRIBE -If {v} is a variable and {t} is a term of type {bool}, then +If {v} is a variable and {t} is a term of type {bool}, then {mk_exists (v,t)} returns the term {?v. t}. \FAILURE diff --git a/help/Docfiles/boolSyntax.mk_exists1.doc b/help/Docfiles/boolSyntax.mk_exists1.doc index 81ffdecb5d..e1829460c6 100644 --- a/help/Docfiles/boolSyntax.mk_exists1.doc +++ b/help/Docfiles/boolSyntax.mk_exists1.doc @@ -6,7 +6,7 @@ Term constructor for unique existence. \DESCRIBE -If {v} is a variable and {t} is a term of type {bool}, then +If {v} is a variable and {t} is a term of type {bool}, then {mk_exists1 (v,t)} returns the term {?!v. t}. \FAILURE diff --git a/help/Docfiles/boolSyntax.mk_forall.doc b/help/Docfiles/boolSyntax.mk_forall.doc index af68671c00..de4bf61f08 100644 --- a/help/Docfiles/boolSyntax.mk_forall.doc +++ b/help/Docfiles/boolSyntax.mk_forall.doc @@ -6,7 +6,7 @@ Term constructor for universal quantification. \DESCRIBE -If {v} is a variable and {t} is a term of type {bool}, then +If {v} is a variable and {t} is a term of type {bool}, then {mk_forall (v,t)} returns the term {!v. t}. \FAILURE diff --git a/help/Docfiles/boolSyntax.mk_imp.doc b/help/Docfiles/boolSyntax.mk_imp.doc index 351c7def0a..b96ff6c3c9 100644 --- a/help/Docfiles/boolSyntax.mk_imp.doc +++ b/help/Docfiles/boolSyntax.mk_imp.doc @@ -6,7 +6,7 @@ Constructs an implication. \DESCRIBE -If {t1} and {t2} are terms of type {bool}, then {mk_imp(t1,t2)} +If {t1} and {t2} are terms of type {bool}, then {mk_imp(t1,t2)} constructs the term {t1 ==> t2}. \FAILURE diff --git a/help/Docfiles/boolSyntax.mk_let.doc b/help/Docfiles/boolSyntax.mk_let.doc index f55d8b27ab..d7d10166ca 100644 --- a/help/Docfiles/boolSyntax.mk_let.doc +++ b/help/Docfiles/boolSyntax.mk_let.doc @@ -7,13 +7,13 @@ Constructs a {let} term. \DESCRIBE The invocation {mk_let (M,N)} returns the term {`LET M N`}. If {M} is -of the form {\x.t} then the result will be pretty-printed as +of the form {\x.t} then the result will be pretty-printed as {let x = N in t}. Since {LET M N} is defined to be {M N}, one can think of a {let}-expression as a suspended beta-redex (if that helps). \FAILURE Fails if the types of {M} and {N} are such that {LET M N} is -not well-typed, i.e., the type of {M} must be a function type, and +not well-typed, i.e., the type of {M} must be a function type, and the type of {N} must equal the domain of the type of {M}. \EXAMPLE @@ -27,7 +27,7 @@ the type of {N} must equal the domain of the type of {M}. {let} expressions may be nested. Pairing can also be used in the {let} syntax, provided {pairTheory} -has been loaded. The library {pairLib} provides support for manipulating +has been loaded. The library {pairLib} provides support for manipulating `paired' lets. \SEEALSO diff --git a/help/Docfiles/boolSyntax.mk_select.doc b/help/Docfiles/boolSyntax.mk_select.doc index 546ffb723e..aa82126f8f 100644 --- a/help/Docfiles/boolSyntax.mk_select.doc +++ b/help/Docfiles/boolSyntax.mk_select.doc @@ -6,7 +6,7 @@ Constructs a choice-term. \DESCRIBE -If {v} is a variable and {t} is a term of type {bool}, then +If {v} is a variable and {t} is a term of type {bool}, then {mk_select (v,t)} returns {@var. t}. \FAILURE diff --git a/help/Docfiles/boolSyntax.new_binder.doc b/help/Docfiles/boolSyntax.new_binder.doc index 94edb1bc4e..0ab8a030d2 100644 --- a/help/Docfiles/boolSyntax.new_binder.doc +++ b/help/Docfiles/boolSyntax.new_binder.doc @@ -6,13 +6,13 @@ Sets up a new binder in the current theory. \DESCRIBE -A call {new_binder(bnd,ty)} declares a new binder {bnd} in the +A call {new_binder(bnd,ty)} declares a new binder {bnd} in the current theory. The type must be of the form {('a -> 'b) -> 'c}, because -being a binder, {bnd} will apply to an abstraction; for example +being a binder, {bnd} will apply to an abstraction; for example { !x:bool. (x=T) \/ (x=F) } -is actually a prettyprinting of +is actually a prettyprinting of { $! (\x. (x=T) \/ (x=F)) } diff --git a/help/Docfiles/boolSyntax.new_binder_definition.doc b/help/Docfiles/boolSyntax.new_binder_definition.doc index 3f826345cb..7f644bd8bc 100644 --- a/help/Docfiles/boolSyntax.new_binder_definition.doc +++ b/help/Docfiles/boolSyntax.new_binder_definition.doc @@ -18,8 +18,8 @@ variables {x1,...,xm}. A binder is defined by evaluating { new_binder_definition (name, `b v1 ... vn = t`) } -where {b} does not occur in {t}, all the free variables that -occur in {t} are a subset of {x1,...,xn}, and the type +where {b} does not occur in {t}, all the free variables that +occur in {t} are a subset of {x1,...,xn}, and the type of {b} has the form {(ty1->ty2)->ty3}. This declares {b} to be a new constant with the syntactic status of a binder in the current theory, and with the definitional theorem diff --git a/help/Docfiles/boolSyntax.new_infixl_definition.doc b/help/Docfiles/boolSyntax.new_infixl_definition.doc index ae55a5a243..e98fdae352 100644 --- a/help/Docfiles/boolSyntax.new_infixl_definition.doc +++ b/help/Docfiles/boolSyntax.new_infixl_definition.doc @@ -17,7 +17,7 @@ definition requested by the user. Let {v_1} and {v_2} be tuples of distinct variables, containing the variables {x_1,...,x_m}. Evaluating {new_infix_definition (name, ix v_1 v_2 = t)} -declares the sequent {({},\v_1 v_2. t)} to be a definition in the +declares the sequent {({},\v_1 v_2. t)} to be a definition in the current theory, and declares {ix} to be a new constant in the current theory with this definition as its specification. This constant specification is returned as a theorem with the form diff --git a/help/Docfiles/boolSyntax.strip_abs.doc b/help/Docfiles/boolSyntax.strip_abs.doc index e9882d5569..5816819b23 100644 --- a/help/Docfiles/boolSyntax.strip_abs.doc +++ b/help/Docfiles/boolSyntax.strip_abs.doc @@ -6,7 +6,7 @@ Iteratively breaks apart abstractions. \DESCRIBE -If {M} has the form {\x1 ... xn.t} then {strip_abs M} returns +If {M} has the form {\x1 ... xn.t} then {strip_abs M} returns {([x1,...,xn],t)}. Note that { strip_abs(list_mk_abs([x1,...,xn],t)) diff --git a/help/Docfiles/boolSyntax.strip_comb.doc b/help/Docfiles/boolSyntax.strip_comb.doc index e0a0e432a8..3ca7eeba0c 100644 --- a/help/Docfiles/boolSyntax.strip_comb.doc +++ b/help/Docfiles/boolSyntax.strip_comb.doc @@ -6,7 +6,7 @@ Iteratively breaks apart combinations (function applications). \DESCRIBE -If {M} has the form {t t1 ... tn} then {strip_comb M} returns +If {M} has the form {t t1 ... tn} then {strip_comb M} returns {(t,[t1,...,tn])}. Note that { strip_comb(list_mk_comb(t,[t1,...,tn])) diff --git a/help/Docfiles/boolSyntax.strip_fun.doc b/help/Docfiles/boolSyntax.strip_fun.doc index 59a58c30a0..f4a9ed2186 100644 --- a/help/Docfiles/boolSyntax.strip_fun.doc +++ b/help/Docfiles/boolSyntax.strip_fun.doc @@ -6,7 +6,7 @@ Iteratively breaks apart function types. \DESCRIBE -If {fty} is of the form {ty1 -> (... (tyn -> ty) ...)}, then +If {fty} is of the form {ty1 -> (... (tyn -> ty) ...)}, then {strip_fun fty} returns {([ty1,...,tyn],ty)}. Note that { strip_fun(list_mk_fun([ty1,...,tyn],ty)) diff --git a/help/Docfiles/boolSyntax.strip_imp.doc b/help/Docfiles/boolSyntax.strip_imp.doc index a396a79fb6..dcaf170f96 100644 --- a/help/Docfiles/boolSyntax.strip_imp.doc +++ b/help/Docfiles/boolSyntax.strip_imp.doc @@ -6,7 +6,7 @@ Iteratively breaks apart implications. \DESCRIBE -If {M} is of the form {t1 ==> (... (tn ==> t) ...)}, then {strip_imp M} +If {M} is of the form {t1 ==> (... (tn ==> t) ...)}, then {strip_imp M} returns {([t1,...,tn],t)}. Note that { strip_imp(list_mk_imp([t1,...,tn],t)) diff --git a/help/Docfiles/boolSyntax.strip_imp_only.doc b/help/Docfiles/boolSyntax.strip_imp_only.doc index 88c04a2cd8..a1a1845165 100644 --- a/help/Docfiles/boolSyntax.strip_imp_only.doc +++ b/help/Docfiles/boolSyntax.strip_imp_only.doc @@ -6,7 +6,7 @@ Iteratively breaks apart implications. \DESCRIBE -If {M} is of the form {t1 ==> (... (tn ==> t) ...)}, then {strip_imp_only M} +If {M} is of the form {t1 ==> (... (tn ==> t) ...)}, then {strip_imp_only M} returns {([t1,...,tn],t)}. Note that { strip_imp_only(list_mk_imp([t1,...,tn],t)) diff --git a/help/Docfiles/bossLib.ASM_SIMP_TAC.doc b/help/Docfiles/bossLib.ASM_SIMP_TAC.doc index 379edd7e65..5efabb954e 100644 --- a/help/Docfiles/bossLib.ASM_SIMP_TAC.doc +++ b/help/Docfiles/bossLib.ASM_SIMP_TAC.doc @@ -25,14 +25,14 @@ explained in the entry for {SIMP_CONV}. {ASM_SIMP_TAC} never fails, though it may diverge. \EXAMPLE -The simple goal {x < y ?- x + y < y + y} can be proved by using +The simple goal {x < y ?- x + y < y + y} can be proved by using {bossLib.arith_ss} and the assumption by { ASM_SIMP_TAC bossLib.arith_ss [] } \SEEALSO -bossLib.++, bossLib.bool_ss, bossLib.FULL_SIMP_TAC, +bossLib.++, bossLib.bool_ss, bossLib.FULL_SIMP_TAC, simpLib.mk_simpset, bossLib.SIMP_CONV, bossLib.SIMP_TAC, Rewrite.ASM_REWRITE_TAC, BasicProvers.VAR_EQ_TAC diff --git a/help/Docfiles/bossLib.Cases.doc b/help/Docfiles/bossLib.Cases.doc index 6be840ca29..3a4a569a68 100644 --- a/help/Docfiles/bossLib.Cases.doc +++ b/help/Docfiles/bossLib.Cases.doc @@ -3,7 +3,7 @@ \TYPE {Cases : tactic} \SYNOPSIS -Performs case analysis on the variable of the leading universally +Performs case analysis on the variable of the leading universally quantified variable of the goal. \KEYWORDS @@ -13,8 +13,8 @@ tactic BasicProvers \DESCRIBE -When applied to a universally quantified goal {?- !u. G}, {Cases} performs a -case-split, based on the cases theorem for the type of {u} stored in +When applied to a universally quantified goal {?- !u. G}, {Cases} performs a +case-split, based on the cases theorem for the type of {u} stored in the global {TypeBase} database. The cases theorem for a type {ty} will be of the form: @@ -52,7 +52,7 @@ and the following function: - val foofn_def = Define `(foofn (Bar n) = n + 10) /\ (foofn (Baz x) = 10)`; > val foofn_def = - |- (!n. foofn (Bar n) = n + 10) /\ + |- (!n. foofn (Bar n) = n + 10) /\ !x. foofn (Baz x) = 10 : thm } then it is possible to make progress with the goal diff --git a/help/Docfiles/bossLib.Cases_on.doc b/help/Docfiles/bossLib.Cases_on.doc index 4fed0c3bea..926de66aaa 100644 --- a/help/Docfiles/bossLib.Cases_on.doc +++ b/help/Docfiles/bossLib.Cases_on.doc @@ -11,13 +11,13 @@ tactic \LIBRARY BasicProvers -\DESCRIBE +\DESCRIBE An application {Cases_on M} performs a case-split based on the type {ty} of {M}, using the cases theorem for {ty} from the global {TypeBase} database. {Cases_on} can be used to specify variables that are buried -in the quantifier prefix. {Cases_on} can also be used to perform +in the quantifier prefix. {Cases_on} can also be used to perform case splits on non-variable terms. If {M} is a non-variable term that does not occur bound in the goal, then the cases theorem is instantiated with {M} and used to generate as many sub-goals as there are disjuncts @@ -30,7 +30,7 @@ Fails if {ty} does not have a case theorem in the {TypeBase}. None yet. \SEEALSO -bossLib.Cases, bossLib.Induct, +bossLib.Cases, bossLib.Induct, bossLib.Induct_on, Tactic.STRUCT_CASES_TAC. \ENDDOC diff --git a/help/Docfiles/bossLib.DECIDE.doc b/help/Docfiles/bossLib.DECIDE.doc index 78cd2a3225..10b64499c7 100644 --- a/help/Docfiles/bossLib.DECIDE.doc +++ b/help/Docfiles/bossLib.DECIDE.doc @@ -10,8 +10,8 @@ arithmetic, decision procedure. \DESCRIBE An application {DECIDE M}, where {M} is a boolean term, attempts to -prove {M} using a propositional tautology checker and a linear -arithmetic decision procedure. +prove {M} using a propositional tautology checker and a linear +arithmetic decision procedure. \FAILURE The invocation fails if {M} is not of boolean type. It also fails if {M} @@ -27,7 +27,7 @@ is not a tautology or an instance of a theorem of linear arithmetic. } \COMMENTS -{DECIDE} is currently somewhat underpowered. Formerly it was +{DECIDE} is currently somewhat underpowered. Formerly it was implemented by a cooperating decision procedure mechanism. However, most proofs seemed to go somewhat smoother with simplification using the {arith_ss} simpset, so we have adopted a simpler implementation. That diff --git a/help/Docfiles/bossLib.Define.doc b/help/Docfiles/bossLib.Define.doc index 56719e3f19..f88d9c6a29 100644 --- a/help/Docfiles/bossLib.Define.doc +++ b/help/Docfiles/bossLib.Define.doc @@ -14,10 +14,10 @@ attempts to define the function in the logic. If this attempt is successful, the specification is derived from the definition. The derived specification is returned to the user, and also stored in the current theory. {Define} may be used to define abbreviations, -recursive functions, and mutually recursive functions. An induction -theorem may be stored in the current theory as a by-product of -{Define}'s activity. This induction theorem follows the -recursion structure of the function, and may be useful when proving +recursive functions, and mutually recursive functions. An induction +theorem may be stored in the current theory as a by-product of +{Define}'s activity. This induction theorem follows the +recursion structure of the function, and may be useful when proving properties of the function. {Define} takes as input a quotation representing a conjunction of @@ -133,10 +133,10 @@ ML function {xDefine} should be used. {Define} fails if the name of the function being defined is not alphanumeric. -{Define} fails if there are more free variables on the right hand -sides of the recursion equations than the left. +{Define} fails if there are more free variables on the right hand +sides of the recursion equations than the left. -{Define} fails if it cannot prove the termination of the +{Define} fails if it cannot prove the termination of the specified recursive function. In that case, one has to embark on the following multi-step process in order to get the same effect as if {Define} had succeeded: (1) construct the function and synthesize its @@ -151,7 +151,7 @@ and (4) package everything up with an invocation of {tDefine}. We will give a number of examples that display the range of functions that may be defined with {Define}. First, we have a recursive function that uses "destructors" in the recursive call. Since {fact} is not -primitive recursive, an induction theorem for {fact} is generated and +primitive recursive, an induction theorem for {fact} is generated and stored in the current theory. { Define `fact x = if x = 0 then 1 else x * fact(x-1)`; @@ -211,9 +211,9 @@ induction theorem is generated in this case. !P h t. filter P (h::t) = (if P h then h::filter P t else filter P t) : thm } -{Define} may also be used to define mutually recursive functions. +{Define} may also be used to define mutually recursive functions. For example, we can define a datatype of propositions and a function for -putting a proposition into negation normal form as follows. +putting a proposition into negation normal form as follows. First we define a datatype for boolean formulae ({prop}): { - Hol_datatype @@ -320,8 +320,8 @@ less baggage---it depends only on {numLib} and {pairLib}. \SEEALSO -bossLib.tDefine, bossLib.xDefine, TotalDefn.DefineSchema, bossLib.Hol_defn, -Defn.tgoal, Defn.tprove, bossLib.WF_REL_TAC, bossLib.recInduct, +bossLib.tDefine, bossLib.xDefine, TotalDefn.DefineSchema, bossLib.Hol_defn, +Defn.tgoal, Defn.tprove, bossLib.WF_REL_TAC, bossLib.recInduct, bossLib.EVAL, bossLib.EVAL_TAC. \ENDDOC diff --git a/help/Docfiles/bossLib.EVAL.doc b/help/Docfiles/bossLib.EVAL.doc index 428ff7982f..99897ecd2a 100644 --- a/help/Docfiles/bossLib.EVAL.doc +++ b/help/Docfiles/bossLib.EVAL.doc @@ -12,8 +12,8 @@ evaluation. An invocation {EVAL M} symbolically evaluates {M} by applying the defining equations of constants occurring in {M}. These equations are held in a mutable datastructure that is automatically added to -by {Hol_datatype}, {Define}, and {tprove}. The underlying -algorithm is call-by-value with a few differences, see the entry for +by {Hol_datatype}, {Define}, and {tprove}. The underlying +algorithm is call-by-value with a few differences, see the entry for {CBV_CONV} for details. diff --git a/help/Docfiles/bossLib.EVAL_RULE.doc b/help/Docfiles/bossLib.EVAL_RULE.doc index 926601cb78..51ecb07aa4 100644 --- a/help/Docfiles/bossLib.EVAL_RULE.doc +++ b/help/Docfiles/bossLib.EVAL_RULE.doc @@ -8,14 +8,14 @@ Evaluate conclusion of a theorem. \KEYWORDS evaluation. -\DESCRIBE +\DESCRIBE An invocation {EVAL_RULE th} symbolically evaluates the conclusion of {th} by applying the defining equations of constants which occur in the conclusion of {th}. These equations are held in a mutable datastructure that is automatically added to by {Hol_datatype}, {Define}, and {tprove}. The underlying algorithm is call-by-value with a -few differences, see the entry for {CBV_CONV} for details. +few differences, see the entry for {CBV_CONV} for details. \FAILURE Never fails, but may diverge. diff --git a/help/Docfiles/bossLib.EVAL_TAC.doc b/help/Docfiles/bossLib.EVAL_TAC.doc index 8e88b8bfef..032fb47df9 100644 --- a/help/Docfiles/bossLib.EVAL_TAC.doc +++ b/help/Docfiles/bossLib.EVAL_TAC.doc @@ -9,12 +9,12 @@ Evaluate a goal deductively. tactic, evaluation. \DESCRIBE -Applying {EVAL_TAC} to a goal {A ?- g} results in {EVAL} being applied +Applying {EVAL_TAC} to a goal {A ?- g} results in {EVAL} being applied to {g} to obtain {|- g = g'}. This theorem is used to transform the goal -to {A ?- g'}. +to {A ?- g'}. The notion of evaluation is based around rules for replacing constants -by their (equational) definitions. Thus {EVAL_TAC} is currently +by their (equational) definitions. Thus {EVAL_TAC} is currently suited to evaluation of expressions that look like functional programs. Evaluation of inductive relations is not currently supported. @@ -29,10 +29,10 @@ to the goal } \COMMENTS -The main problem with {EVAL_TAC} is knowing when it will terminate. One +The main problem with {EVAL_TAC} is knowing when it will terminate. One typical cause of non-termination is that a constant in the goal has not been added to {the_compset}. Another is that a test in a conditional in -the expression may involve a variable. +the expression may involve a variable. \USES Symbolic evaluation. diff --git a/help/Docfiles/bossLib.FULL_SIMP_TAC.doc b/help/Docfiles/bossLib.FULL_SIMP_TAC.doc index 5af5de4130..c88ad0ebea 100644 --- a/help/Docfiles/bossLib.FULL_SIMP_TAC.doc +++ b/help/Docfiles/bossLib.FULL_SIMP_TAC.doc @@ -61,7 +61,7 @@ this occurring, the best approach seems to be the use of {RULE_ASSUM_TAC} and {SIMP_RULE}. Each assumption is used to rewrite lower-numbered assumptions. -To get the opposite effect, where +To get the opposite effect, where each assumption is used to rewrite higher-numbered assumptions, use {REV_FULL_SIMP_TAC}. diff --git a/help/Docfiles/bossLib.Hol_defn.doc b/help/Docfiles/bossLib.Hol_defn.doc index 49f51d85be..8ea9f9e09b 100644 --- a/help/Docfiles/bossLib.Hol_defn.doc +++ b/help/Docfiles/bossLib.Hol_defn.doc @@ -189,22 +189,22 @@ termination conditions for {fact} are 0. WF R 1. !n. ~(n = 0) ==> R (n - 1) n } -and are easy to prove. +and are easy to prove. -Now we discuss congruence theorems for higher-order functions. A +Now we discuss congruence theorems for higher-order functions. A `higher-order` recursion is one in which a higher-order function is used to apply the recursive function to arguments. In order for the -correct termination conditions to be proved for such a recursion, -congruence rules for the higher order function must be known to -the termination condition extraction mechanism. Congruence rules for -common higher-order functions, e.g., {MAP}, {EVERY}, and {EXISTS} for -lists, are already known to the mechanism. However, at times, one must -manually prove and install a congruence theorem for a higher-order -function. +correct termination conditions to be proved for such a recursion, +congruence rules for the higher order function must be known to +the termination condition extraction mechanism. Congruence rules for +common higher-order functions, e.g., {MAP}, {EVERY}, and {EXISTS} for +lists, are already known to the mechanism. However, at times, one must +manually prove and install a congruence theorem for a higher-order +function. For example, suppose we define a higher-order function {SIGMA} for -summing the results of a function in a list. We then use {SIGMA} in -the definition of a function for summing the results of a function +summing the results of a function in a list. We then use {SIGMA} in +the definition of a function for summing the results of a function in an arbitrarily (finitely) branching tree. { - Define `(SIGMA f [] = 0) /\ @@ -214,7 +214,7 @@ in an arbitrarily (finitely) branching tree. - Hol_datatype `ltree = Node of 'a => ltree list`; > val it = () : unit - - Defn.Hol_defn + - Defn.Hol_defn "ltree_sigma" (* higher order recursion *) `ltree_sigma f (Node v tl) = f v + SIGMA (ltree_sigma f) tl`; @@ -247,7 +247,7 @@ congruence theorem is the following: (SIGMA f l1 = SIGMA g l2) } Once {Hol_defn} has been told about this theorem, via {write_congs}, the -termination conditions extracted for the definition are provable, +termination conditions extracted for the definition are provable, since {a} is a proper subterm of {Node v tl}. { - local open DefnBase @@ -270,9 +270,9 @@ since {a} is a proper subterm of {Node v tl}. 1. !v f tl a. MEM a tl ==> R (f,a) (f,Node v tl) } -One final point : for every HOL datatype defined by application of -{Hol_datatype}, a congruence theorem is automatically proved for the -`case' constant for that type, and stored in the {TypeBase}. For example, +One final point : for every HOL datatype defined by application of +{Hol_datatype}, a congruence theorem is automatically proved for the +`case' constant for that type, and stored in the {TypeBase}. For example, the following congruence theorem for {num_case} is stored in the {TypeBase}: { |- !f' f b' b M' M. @@ -283,10 +283,10 @@ the following congruence theorem for {num_case} is stored in the {TypeBase}: (num_case b f M = num_case b' f' M') } This allows the contexts of recursive calls in branches of -`case' expressions to be tracked. +`case' expressions to be tracked. \SEEALSO -Defn.tgoal, Defn.tprove, bossLib.WF_REL_TAC, bossLib.Define, +Defn.tgoal, Defn.tprove, bossLib.WF_REL_TAC, bossLib.Define, bossLib.xDefine, bossLib.Hol_datatype. \ENDDOC diff --git a/help/Docfiles/bossLib.Induct.doc b/help/Docfiles/bossLib.Induct.doc index 9853e6dcd0..0fd990d4c9 100644 --- a/help/Docfiles/bossLib.Induct.doc +++ b/help/Docfiles/bossLib.Induct.doc @@ -52,7 +52,7 @@ with {Induct} yields the two goals n > 2 ==> !x y z. ~(x EXP n + y EXP n = z EXP n) ?- SUC n > 2 ==> !x y z. ~(x EXP SUC n + y EXP SUC n = z EXP SUC n) } -{Induct} can also be used to perform induction on mutually recursive types. +{Induct} can also be used to perform induction on mutually recursive types. For example, given the datatype { Hol_datatype @@ -72,7 +72,7 @@ defined for datatypes.) Typically, mutually recursive types lead to mutually recursive induction schemes having multiple predicates. The scheme for the above definition has 3 predicates: {P0}, {P1}, and {P2}, which respectively range over expressions, boolean expressions, and -lists of expressions. +lists of expressions. { |- !P0 P1 P2. (!a. P0 (VAR a)) /\ @@ -82,9 +82,9 @@ lists of expressions. (!e e0. P0 e /\ P0 e0 ==> P1 (LEQ e e0)) /\ (!b b0. P1 b /\ P1 b0 ==> P1 (AND b b0)) /\ (!b b0. P1 b /\ P1 b0 ==> P1 (OR b b0)) /\ - (!b. P1 b ==> P1 (NOT b)) /\ + (!b. P1 b ==> P1 (NOT b)) /\ P2 [] /\ - (!e l. P0 e /\ P2 l ==> P2 (e::l)) + (!e l. P0 e /\ P2 l ==> P2 (e::l)) ==> (!e. P0 e) /\ (!b. P1 b) /\ !l. P2 l } @@ -95,28 +95,28 @@ Invoking {Induct} on a goal such as yields the three subgoals { ?- !s. 0 < exp_size (APP s l) - - + + [ 0 < exp_size e, 0 < exp_size e' ] ?- 0 < exp_size (IF b e e') - + ?- !s. 0 < exp_size (VAR s) } In this case, {P1} and {P2} have been vacuously instantiated in the application of {Induct}, since it detects that only {P0} is needed. However, it is also possible to use {Induct} to start the proofs -of +of { (!e. 0 < exp_size e) /\ (!b. 0 < bexp_size b) } and { - (!e. 0 < exp_size e) /\ - (!b. 0 < bexp_size b) /\ + (!e. 0 < exp_size e) /\ + (!b. 0 < bexp_size b) /\ (!list. 0 < exp1_size list) } \SEEALSO -bossLib.Induct_on, bossLib.completeInduct_on, +bossLib.Induct_on, bossLib.completeInduct_on, bossLib.measureInduct_on, Prim_rec.INDUCT_THEN, bossLib.Cases, bossLib.Hol_datatype, proofManagerLib.g, proofManagerLib.e. diff --git a/help/Docfiles/bossLib.Induct_on.doc b/help/Docfiles/bossLib.Induct_on.doc index a8eeb61f01..d8ec8d90ec 100644 --- a/help/Docfiles/bossLib.Induct_on.doc +++ b/help/Docfiles/bossLib.Induct_on.doc @@ -25,9 +25,9 @@ goal, then {Induct_on} equates {M} to a new variable {v} (one not occurring in the goal), moves all hypotheses in which free variables of {M} occur to the conclusion of the goal, adds the antecedent {v = M}, and quantifies all free variables of {M} before universally quantifying -{v} and then finally inducting on {v}. +{v} and then finally inducting on {v}. -{Induct_on} may also be used to apply an induction theorem coming from +{Induct_on} may also be used to apply an induction theorem coming from declaration of a mutually recursive datatype. @@ -42,10 +42,10 @@ If attempting to prove } one can apply {Induct_on `x`} to begin a proof by induction on the list structure of {x}. In this case, {Induct_on} serves as an explicit -version of {Induct}. +version of {Induct}. \SEEALSO -bossLib.Induct, bossLib.completeInduct_on, +bossLib.Induct, bossLib.completeInduct_on, bossLib.measureInduct_on, Prim_rec.INDUCT_THEN, bossLib.Cases, bossLib.Hol_datatype, proofManagerLib.g, proofManagerLib.e. diff --git a/help/Docfiles/bossLib.PROVE.doc b/help/Docfiles/bossLib.PROVE.doc index 6341b83b89..a0522d70ad 100644 --- a/help/Docfiles/bossLib.PROVE.doc +++ b/help/Docfiles/bossLib.PROVE.doc @@ -9,7 +9,7 @@ Prove a theorem with use of supplied lemmas. proof, first order. \DESCRIBE -An invocation {PROVE thl M} attempts to prove {M} using an automated +An invocation {PROVE thl M} attempts to prove {M} using an automated reasoner supplied with the lemmas in {thl}. The automated reasoner performs a first order proof search. It currently provides some support for polymorphism and higher-order values (lambda terms). @@ -23,9 +23,9 @@ If the proof search fails, or if {M} does not have type {bool}. Meson search level: ........ > val it = |- !P. (!x. ?y. P x y) = ?f. !x. P x (f x) : thm -- let open arithmeticTheory - in - PROVE [ADD_ASSOC, ADD_SYM, ADD_CLAUSES] +- let open arithmeticTheory + in + PROVE [ADD_ASSOC, ADD_SYM, ADD_CLAUSES] (Term `x + 0 + y + z = y + (z + x)`) end; Meson search level: ............ @@ -33,9 +33,9 @@ Meson search level: ............ } \COMMENTS -Some output (a row of dots) is currently generated as {PROVE} works. If -the frequency of dot emission becomes slow, that is a sign that the -term is not likely to be proved with the current lemmas. +Some output (a row of dots) is currently generated as {PROVE} works. If +the frequency of dot emission becomes slow, that is a sign that the +term is not likely to be proved with the current lemmas. Unlike {MESON_TAC}, {PROVE} can handle terms with conditionals. diff --git a/help/Docfiles/bossLib.PROVE_TAC.doc b/help/Docfiles/bossLib.PROVE_TAC.doc index ecb823d297..186ab892b5 100644 --- a/help/Docfiles/bossLib.PROVE_TAC.doc +++ b/help/Docfiles/bossLib.PROVE_TAC.doc @@ -11,15 +11,15 @@ tactic, search, first order. \DESCRIBE An invocation {PROVE_TAC thl} attempts to solve the goal it is applied to by executing a proof procedure that is semi-complete for pure first order -logic. The assumptions of the goal and the theorems in {thl} are used. -The procedure makes special provision for handling polymorphic and -higher-order values (lambda terms). It also handles conditional +logic. The assumptions of the goal and the theorems in {thl} are used. +The procedure makes special provision for handling polymorphic and +higher-order values (lambda terms). It also handles conditional expressions. \FAILURE {PROVE_TAC} fails if it searches to a depth equal to the contents of the reference variable {mesonLib.max_depth} (set to 30 by default, but -changeable by the user) without finding a proof. +changeable by the user) without finding a proof. \COMMENTS {PROVE_TAC} can only progress the goal to a successful proof of the @@ -29,7 +29,7 @@ existential goals and to make effective use of transitivity theorems make it a particularly powerful tactic. \SEEALSO -bossLib.PROVE, mesonLib.MESON_TAC, mesonLib.ASM_MESON_TAC, +bossLib.PROVE, mesonLib.MESON_TAC, mesonLib.ASM_MESON_TAC, mesonLib.GEN_MESON_TAC. \ENDDOC diff --git a/help/Docfiles/bossLib.RW_TAC.doc b/help/Docfiles/bossLib.RW_TAC.doc index d41029594c..2b548b9e7d 100644 --- a/help/Docfiles/bossLib.RW_TAC.doc +++ b/help/Docfiles/bossLib.RW_TAC.doc @@ -3,15 +3,15 @@ \TYPE {RW_TAC : simpset -> thm list -> tactic} \SYNOPSIS -Simplification with case-splitting and built-in knowledge of +Simplification with case-splitting and built-in knowledge of declared datatypes. \KEYWORDS simplification, datatype. \DESCRIBE -{RW_TAC} is a simplification tactic that provides conditional and -contextual rewriting, and automatic invocation of conversions and decision +{RW_TAC} is a simplification tactic that provides conditional and +contextual rewriting, and automatic invocation of conversions and decision procedures in the course of simplification. An application {RW_TAC ss thl} adds the theorems in {thl} to the simpset {ss} and proceeds to simplify the goal. @@ -30,13 +30,13 @@ variable or negated boolean variable occurring as a hypothesis. It breaks down any conjunctions, disjunctions, double negations, or existentials occurring as hypotheses. It keeps the goal in "stripped" format so that the resulting goal will not be an implication or -universally quantified. +universally quantified. \FAILURE Never fails, but may diverge. \COMMENTS -The case splits arising from conditionals and disjunctions can result in +The case splits arising from conditionals and disjunctions can result in many unforeseen subgoals. In that case, {SIMP_TAC} or even {REWRITE_TAC} should be used. diff --git a/help/Docfiles/bossLib.SIMP_RULE.doc b/help/Docfiles/bossLib.SIMP_RULE.doc index bc1d5be19b..eb6f341b64 100644 --- a/help/Docfiles/bossLib.SIMP_RULE.doc +++ b/help/Docfiles/bossLib.SIMP_RULE.doc @@ -36,7 +36,7 @@ possible with simplification ({FORALL_AND_THM} states {SIMP_RULE ss thmlist} is equivalent to {CONV_RULE (SIMP_CONV ss thmlist)}. \SEEALSO -simpLib.ASM_SIMP_RULE, bossLib.SIMP_CONV, bossLib.SIMP_TAC, +simpLib.ASM_SIMP_RULE, bossLib.SIMP_CONV, bossLib.SIMP_TAC, bossLib.bool_ss. \ENDDOC diff --git a/help/Docfiles/bossLib.SIMP_TAC.doc b/help/Docfiles/bossLib.SIMP_TAC.doc index 1e5eaf2b95..8fa2e6dd22 100644 --- a/help/Docfiles/bossLib.SIMP_TAC.doc +++ b/help/Docfiles/bossLib.SIMP_TAC.doc @@ -32,10 +32,10 @@ simplification. {SIMP_TAC} never fails, though it may diverge. \EXAMPLE -{SIMP_TAC} and the {arith_ss} simpset combine to prove quite +{SIMP_TAC} and the {arith_ss} simpset combine to prove quite difficult seeming goals: { - - val (_, p) = SIMP_TAC arith_ss [] + - val (_, p) = SIMP_TAC arith_ss [] ([], Term`P x /\ (x = y + 3) ==> P x /\ y < x`); > val p = fn : thm list -> thm @@ -65,10 +65,10 @@ rewrites can still result in divergence, or poor performance. \SEEALSO -bossLib.++, bossLib.ASM_SIMP_TAC, -bossLib.std_ss, bossLib.bool_ss, bossLib.arith_ss, bossLib.list_ss, -bossLib.FULL_SIMP_TAC, simpLib.mk_simpset, -Rewrite.REWRITE_TAC, bossLib.SIMP_CONV, +bossLib.++, bossLib.ASM_SIMP_TAC, +bossLib.std_ss, bossLib.bool_ss, bossLib.arith_ss, bossLib.list_ss, +bossLib.FULL_SIMP_TAC, simpLib.mk_simpset, +Rewrite.REWRITE_TAC, bossLib.SIMP_CONV, simpLib.SIMP_PROVE, bossLib.SIMP_RULE. \ENDDOC diff --git a/help/Docfiles/bossLib.SPOSE_NOT_THEN.doc b/help/Docfiles/bossLib.SPOSE_NOT_THEN.doc index fc327518c3..1744f35842 100644 --- a/help/Docfiles/bossLib.SPOSE_NOT_THEN.doc +++ b/help/Docfiles/bossLib.SPOSE_NOT_THEN.doc @@ -14,13 +14,13 @@ Simple tactics for contradiction proofs often simply negate the goal and place it on the assumption list. However, if the goal is quantified, as is often the case, then more processing is required in order to get it into a suitable form for subsequent work. {SPOSE_NOT_THEN ttac} negates -the current goal, pushes the negation inwards, and applies {ttac} to it. +the current goal, pushes the negation inwards, and applies {ttac} to it. \FAILURE Never fails, unless {ttac} fails. \EXAMPLE -Suppose we want to prove Euclid's theorem. +Suppose we want to prove Euclid's theorem. { !m. ?n. prime n /\ m < n } @@ -41,6 +41,6 @@ and {SPOSE_NOT_THEN STRIP_ASSUME_TAC} results in \SEEALSO Tactic.CCONTR_TAC, Tactic.CONTR_TAC, Tactic.ASSUME_TAC, -Tactic.STRIP_ASSUME_TAC. +Tactic.STRIP_ASSUME_TAC. \ENDDOC diff --git a/help/Docfiles/bossLib.amper2.doc b/help/Docfiles/bossLib.amper2.doc index 97c7d85c82..4e175f7fb0 100644 --- a/help/Docfiles/bossLib.amper2.doc +++ b/help/Docfiles/bossLib.amper2.doc @@ -9,8 +9,8 @@ Infix operator for adding theorems into a simpset. simplification. \DESCRIBE -It is occasionally necessary to extend an existing simpset {ss} with a -collection {rwlist} of new rewrite rules. To achieve this, one +It is occasionally necessary to extend an existing simpset {ss} with a +collection {rwlist} of new rewrite rules. To achieve this, one applies the {&&} function via {ss && rwlist}. \FAILURE @@ -25,8 +25,8 @@ Never fails. } \COMMENTS -Of limited applicability since most of the tactics for rewriting -already include this functionality. However, applications of {ZAP_TAC} +Of limited applicability since most of the tactics for rewriting +already include this functionality. However, applications of {ZAP_TAC} can benefit. \SEEALSO diff --git a/help/Docfiles/bossLib.arith_ss.doc b/help/Docfiles/bossLib.arith_ss.doc index 699ad06729..b59beb27f3 100644 --- a/help/Docfiles/bossLib.arith_ss.doc +++ b/help/Docfiles/bossLib.arith_ss.doc @@ -9,7 +9,7 @@ Simplification set for arithmetic. simplification, arithmetic. \DESCRIBE -The simplification set {arith_ss} is a version of {std_ss} enhanced for +The simplification set {arith_ss} is a version of {std_ss} enhanced for arithmetic. It includes many arithmetic rewrites, an evaluation mechanism for ground arithmetic terms, and a decision procedure for linear arithmetic. It also incorporates a cache of successfully solved conditions proved when @@ -24,22 +24,22 @@ from {std_ss}: |- !m n. (0 = m + n) = (m = 0) /\ (n = 0) |- !x y. (x * y = 1) = (x = 1) /\ (y = 1) |- !x y. (1 = x * y) = (x = 1) /\ (y = 1) - |- !m. m * 0 = 0 + |- !m. m * 0 = 0 |- !m. 0 * m = 0 |- !x y. (x * y = SUC 0) = (x = SUC 0) /\ (y = SUC 0) |- !x y. (SUC 0 = x * y) = (x = SUC 0) /\ (y = SUC 0) - |- !m. m * 1 = m + |- !m. m * 1 = m |- !m. 1 * m = m |- !x.((SUC x = 1) = (x = 0)) /\ ((1 = SUC x) = (x = 0)) |- !x.((SUC x = 2) = (x = 1)) /\ ((2 = SUC x) = (x = 1)) |- !m n. (m + n = m) = (n = 0) - |- !m n. (n + m = m) = (n = 0) + |- !m n. (n + m = m) = (n = 0) |- !c. c - c = 0 - |- !m. SUC m - 1 = m + |- !m. SUC m - 1 = m |- !m. (0 - m = 0) /\ (m - 0 = m) - |- !a c. a + c - c = a + |- !a c. a + c - c = a |- !m n. (m - n = 0) = m <= n - |- !m n. (0 = m - n) = m <= n + |- !m n. (0 = m - n) = m <= n |- !n m. n - m <= n |- !n m. SUC n - SUC m = n - m |- !m n p. m - n > p = m > n + p @@ -65,12 +65,12 @@ from {std_ss}: |- !p q n m. (n * SUC q ** p = m * SUC q ** p) = (n = m) |- !m n. ~(SUC n ** m = 0) |- !n m. ~(SUC (n + n) = m + m) - |- !m n. ~(SUC (m + n) <= m) + |- !m n. ~(SUC (m + n) <= m) |- !n. ~(SUC n <= 0) - |- !n. ~(n < 0) + |- !n. ~(n < 0) |- !n. (MIN n 0 = 0) /\ (MIN 0 n = 0) |- !n. (MAX n 0 = n) /\ (MAX 0 n = n) - |- !n. MIN n n = n + |- !n. MIN n n = n |- !n. MAX n n = n |- !n m. MIN m n <= m /\ MIN m n <= n |- !n m. m <= MAX m n /\ n <= MAX m n @@ -84,23 +84,23 @@ from {std_ss}: |- !m n. MIN m n < MAX m n = ~(m = n) } -The decision procedure proves valid purely univeral formulas -constructed using variables and the operators {SUC,PRE,+,-,<,>,<=,>=}. -Multiplication by constants is accomodated by translation to repeated -addition. An attempt is made to generalize sub-formulas of type {num} +The decision procedure proves valid purely univeral formulas +constructed using variables and the operators {SUC,PRE,+,-,<,>,<=,>=}. +Multiplication by constants is accomodated by translation to repeated +addition. An attempt is made to generalize sub-formulas of type {num} not fitting into this syntax. \COMMENTS -The philosophy behind this simpset is fairly conservative. For example, -some potential rewrite rules, e.g., the recursive clauses for addition -and multiplication, are not included, since it was felt that their -incorporation too often resulted in formulas becoming more complex -rather than simpler. Also, transitivity theorems are avoided because +The philosophy behind this simpset is fairly conservative. For example, +some potential rewrite rules, e.g., the recursive clauses for addition +and multiplication, are not included, since it was felt that their +incorporation too often resulted in formulas becoming more complex +rather than simpler. Also, transitivity theorems are avoided because they tend to make simplification diverge. \SEEALSO -BasicProvers.RW_TAC, BasicProvers.SRW_TAC, +BasicProvers.RW_TAC, BasicProvers.SRW_TAC, simpLib.SIMP_TAC, simpLib.SIMP_CONV, simpLib.SIMP_RULE, -BasicProvers.bool_ss, bossLib.std_ss, bossLib.list_ss. +BasicProvers.bool_ss, bossLib.std_ss, bossLib.list_ss. \ENDDOC diff --git a/help/Docfiles/bossLib.bool_ss.doc b/help/Docfiles/bossLib.bool_ss.doc index 50f54256c0..520b3d22b0 100644 --- a/help/Docfiles/bossLib.bool_ss.doc +++ b/help/Docfiles/bossLib.bool_ss.doc @@ -14,44 +14,44 @@ boolSimps \DESCRIBE The {bool_ss} simpset is almost at the base of the system-provided -simpset hierarchy. Though not very powerful, it does include the -following ad hoc collection of rewrite rules for propositions and +simpset hierarchy. Though not very powerful, it does include the +following ad hoc collection of rewrite rules for propositions and first order terms: { |- !A B. ~(A ==> B) = A /\ ~B - |- !A B. (~(A /\ B) = ~A \/ ~B) /\ + |- !A B. (~(A /\ B) = ~A \/ ~B) /\ (~(A \/ B) = ~A /\ ~B) |- !P. ~(!x. P x) = ?x. ~P x - |- !P. ~(?x. P x) = !x. ~P x + |- !P. ~(?x. P x) = !x. ~P x |- (~p = ~q) = (p = q) |- !x. (x = x) = T - |- !t. ((T = t) = t) /\ - ((t = T) = t) /\ - ((F = t) = ~t) /\ + |- !t. ((T = t) = t) /\ + ((t = T) = t) /\ + ((F = t) = ~t) /\ ((t = F) = ~t) |- (!t. ~~t = t) /\ (~T = F) /\ (~F = T) - |- !t. (T /\ t = t) /\ - (t /\ T = t) /\ + |- !t. (T /\ t = t) /\ + (t /\ T = t) /\ (F /\ t = F) /\ - (t /\ F = F) /\ + (t /\ F = F) /\ (t /\ t = t) - |- !t. (T \/ t = T) /\ - (t \/ T = T) /\ + |- !t. (T \/ t = T) /\ + (t \/ T = T) /\ (F \/ t = t) /\ - (t \/ F = t) /\ + (t \/ F = t) /\ (t \/ t = t) - |- !t. (T ==> t = t) /\ - (t ==> T = T) /\ + |- !t. (T ==> t = t) /\ + (t ==> T = T) /\ (F ==> t = T) /\ - (t ==> t = T) /\ + (t ==> t = T) /\ (t ==> F = ~t) |- !t1 t2. ((if T then t1 else t2) = t1) /\ ((if F then t1 else t2) = t2) |- !t. (!x. t) = t |- !t. (?x. t) = t |- !b t. (if b then t else t) = t - |- !a. ?x. x = a - |- !a. ?x. a = x + |- !a. ?x. x = a + |- !a. ?x. a = x |- !a. ?!x. x = a, |- !a. ?!x. a = x, |- (!b e. (if b then T else e) = b \/ e) /\ @@ -59,7 +59,7 @@ first order terms: (!b e. (if b then F else e) = ~b /\ e) /\ (!b t. (if b then t else F) = b /\ t) |- !t. t \/ ~t - |- !t. ~t \/ t + |- !t. ~t \/ t |- !t. ~(t /\ ~t) |- !x. (@y. y = x) = x |- !x. (@y. x = y) = x @@ -69,8 +69,8 @@ first order terms: |- !P a. (?x. (a = x) /\ P x) = P a } Also included in {bool_ss} is a conversion to perform beta reduction, as -well as the following congruence rules, which allow the simplifier to glean -additional contextual information as it descends through implications and +well as the following congruence rules, which allow the simplifier to glean +additional contextual information as it descends through implications and conditionals. { |- !x x' y y'. diff --git a/help/Docfiles/bossLib.completeInduct_on.doc b/help/Docfiles/bossLib.completeInduct_on.doc index fdbeee609e..e449d716f3 100644 --- a/help/Docfiles/bossLib.completeInduct_on.doc +++ b/help/Docfiles/bossLib.completeInduct_on.doc @@ -12,7 +12,7 @@ induction, complete. If {q} parses into a well-typed term {M}, an invocation {completeInduct_on q} begins a proof by complete (also known as `course-of-values') induction on {M}. The term {M} should occur free in -the current goal. +the current goal. \FAILURE If {M} does not parse into a term or does not occur free in the @@ -20,10 +20,10 @@ current goal. \EXAMPLE Suppose we wish to prove that every number not equal to one has a prime -factor: +factor: { !n. ~(n = 1) ==> ?p. prime p /\ p divides n -} +} A natural way to prove this is by complete induction. Invoking {completeInduct_on `n`} yields the goal { diff --git a/help/Docfiles/bossLib.measureInduct_on.doc b/help/Docfiles/bossLib.measureInduct_on.doc index 242146c3c3..0e95c4cae6 100644 --- a/help/Docfiles/bossLib.measureInduct_on.doc +++ b/help/Docfiles/bossLib.measureInduct_on.doc @@ -11,14 +11,14 @@ induction, measure. \DESCRIBE If {q} parses into a well-typed term {M N}, an invocation {measureInduct_on q} begins a proof by induction, using {M} to map -{N} into a number. The term {N} should occur free in the current goal. +{N} into a number. The term {N} should occur free in the current goal. \FAILURE If {M N} does not parse into a term or if {N} does not occur free in the current goal. \EXAMPLE -Suppose we wish to prove {P (APPEND l1 l2)} by induction on the length of +Suppose we wish to prove {P (APPEND l1 l2)} by induction on the length of {l1}. Then {measureInduct_on `LENGTH ll`} yields the goal { { !y. LENGTH y < LENGTH l1 ==> P (APPEND y l2) } ?- P (APPEND l1 l2) diff --git a/help/Docfiles/bossLib.recInduct.doc b/help/Docfiles/bossLib.recInduct.doc index b963b40c94..921f2c2368 100644 --- a/help/Docfiles/bossLib.recInduct.doc +++ b/help/Docfiles/bossLib.recInduct.doc @@ -44,7 +44,7 @@ list is not in the list: One could try mathematical induction, but that won't work well, since {x} gets incremented in recursive calls. Instead, induction with `{variant}-induction' works much better. {recInduct} can be used to -apply such theorems in tactic proof. For our example, +apply such theorems in tactic proof. For our example, {recInduct variant_ind} yields the goal { ?- !x L. (MEM x L ==> ~MEM (variant (x + 1) L) L) ==> ~MEM (variant x L) L @@ -52,7 +52,7 @@ apply such theorems in tactic proof. For our example, A few simple tactic applications then prove this goal. \SEEALSO -bossLib.Induct, bossLib.Induct_on, bossLib.completeInduct_on, +bossLib.Induct, bossLib.Induct_on, bossLib.completeInduct_on, bossLib.measureInduct_on, Prim_rec.INDUCT_THEN, bossLib.Cases, bossLib.Hol_datatype, proofManagerLib.g, proofManagerLib.e. diff --git a/help/Docfiles/bossLib.std_ss.doc b/help/Docfiles/bossLib.std_ss.doc index 2b782c8ae9..c778fe3102 100644 --- a/help/Docfiles/bossLib.std_ss.doc +++ b/help/Docfiles/bossLib.std_ss.doc @@ -9,10 +9,10 @@ Basic simplification set. simplification. \DESCRIBE -The simplification set {std_ss} extends {bool_ss} with a useful set -of rewrite rules for terms involving options, pairs, and sums. It -also performs beta and eta reduction. It applies some standard rewrites -to evaluate expressions involving only numerals. +The simplification set {std_ss} extends {bool_ss} with a useful set +of rewrite rules for terms involving options, pairs, and sums. It +also performs beta and eta reduction. It applies some standard rewrites +to evaluate expressions involving only numerals. The following rewrites from {pairTheory} are included in {std_ss}: { @@ -34,9 +34,9 @@ The following rewrites from {sumTheory} are included in {std_ss}: |- !x. ISR x ==> (INR (OUTR x) = x) |- (!x. ISL (INL x)) /\ !y. ~ISL (INR y) |- (!x. ISR (INR x)) /\ !y. ~ISR (INL y) - |- !x. OUTL (INL x) = x + |- !x. OUTL (INL x) = x |- !x. OUTR (INR x) = x - |- !x y. ~(INL x = INR y) + |- !x y. ~(INL x = INR y) |- !x y. ~(INR y = INL x) |- (!y x. (INL x = INL y) = (x = y)) /\ (!y x. (INR x = INR y) = (x = y)) @@ -48,8 +48,8 @@ The following rewrites from {optionTheory} are included in {std_ss}: |- (!x y. (SOME x = SOME y) = (x = y)) |- (!x. ~(NONE = SOME x)) |- (!x. ~(SOME x = NONE)) - |- (!x. THE (SOME x) = x) - |- (!x. IS_SOME (SOME x) = T) + |- (!x. THE (SOME x) = x) + |- (!x. IS_SOME (SOME x) = T) |- (IS_SOME NONE = F) |- (!x. IS_NONE x = (x = NONE)) |- (!x. ~IS_SOME x = (x = NONE)) @@ -69,22 +69,22 @@ The following rewrites from {optionTheory} are included in {std_ss}: |- !f x. (OPTION_MAP f x = NONE) = (x = NONE) } \USES -For performing obvious simplification steps on terms, formulas, and -goals. Also, sometimes simplification with more powerful simpsets, +For performing obvious simplification steps on terms, formulas, and +goals. Also, sometimes simplification with more powerful simpsets, like {arith_ss}, becomes too slow, in which case one can use {std_ss} supplemented with whatever theorems are needed. \COMMENTS -The simplification sets provided in {BasicProvers} and {bossLib} -(currently {bool_ss}, {std_ss}, {arith_ss}, and {list_ss}) do not -include useful rewrites stemming from HOL datatype declarations, such -as injectivity and distinctness of constructors. However, the +The simplification sets provided in {BasicProvers} and {bossLib} +(currently {bool_ss}, {std_ss}, {arith_ss}, and {list_ss}) do not +include useful rewrites stemming from HOL datatype declarations, such +as injectivity and distinctness of constructors. However, the simplification routines {RW_TAC} and {SRW_TAC} automatically load these rewrites. \SEEALSO -BasicProvers.RW_TAC, BasicProvers.SRW_TAC, +BasicProvers.RW_TAC, BasicProvers.SRW_TAC, simpLib.SIMP_TAC, simpLib.SIMP_CONV, simpLib.SIMP_RULE, -BasicProvers.bool_ss, bossLib.arith_ss, bossLib.list_ss. +BasicProvers.bool_ss, bossLib.arith_ss, bossLib.list_ss. \ENDDOC diff --git a/help/Docfiles/bossLib.tDefine.doc b/help/Docfiles/bossLib.tDefine.doc index 9cbf46a8fd..5d502c8f20 100644 --- a/help/Docfiles/bossLib.tDefine.doc +++ b/help/Docfiles/bossLib.tDefine.doc @@ -8,7 +8,7 @@ General-purpose function definition facility. \KEYWORDS definition, abbreviation, recursive function, mutual recursion. -\DESCRIBE +\DESCRIBE {tDefine} is a definition package similar to {Define} except that it has a tactic parameter which is used to perform the termination proof @@ -24,7 +24,7 @@ primitive recursion, and the termination prover may succeed or fail. When processing the specification of a recursive function, {tDefine} must perform a termination proof. It automatically constructs -termination conditions for the function, and invokes the supplied +termination conditions for the function, and invokes the supplied tactic in an attempt to prove the termination conditions. If that attempt fails, then {tDefine} fails. @@ -41,32 +41,32 @@ If the tactic application fails, then {tDefine} fails. \FAILURE {tDefine} fails if its input fails to parse and typecheck. -{tDefine} fails if it cannot prove the termination of the +{tDefine} fails if it cannot prove the termination of the specified recursive function. In that case, one has to embark on the following multi-step process: (1) construct the function and synthesize its termination conditions with {Hol_defn}; (2) set up a goal to prove the termination conditions with {tgoal}; (3) interactively prove the -termination conditions, usually by starting with an invocation of -{WF_REL_TAC}; and (4) package everything up with an invocation +termination conditions, usually by starting with an invocation of +{WF_REL_TAC}; and (4) package everything up with an invocation of {tDefine}. \EXAMPLE -The following attempt to invoke {Define} fails because the +The following attempt to invoke {Define} fails because the current default termination prover for {Define} is too weak: { Hol_datatype`foo = c1 | c2 | c3`; - Define `(f c1 x = x) /\ - (f c2 x = x + 3) /\ + Define `(f c1 x = x) /\ + (f c2 x = x + 3) /\ (f c3 x = f c2 (x + 6))`; } -The following invocation of {tDefine} uses the supplied tactic +The following invocation of {tDefine} uses the supplied tactic to prove termination. { - tDefine "f" - `(f c1 x = x) /\ - (f c2 x = x + 3) /\ + tDefine "f" + `(f c1 x = x) /\ + (f c2 x = x + 3) /\ (f c3 x = f c2 (x + 6))` (WF_REL_TAC `measure (\p. case FST p of c3 -> 1 || _ -> 0)`); @@ -81,8 +81,8 @@ to prove termination. `compset` accessed by {EVAL} and {EVAL_TAC}. \SEEALSO -bossLib.Define, bossLib.xDefine, TotalDefn.DefineSchema, bossLib.Hol_defn, -Defn.tgoal, Defn.tprove, bossLib.WF_REL_TAC, bossLib.recInduct, +bossLib.Define, bossLib.xDefine, TotalDefn.DefineSchema, bossLib.Hol_defn, +Defn.tgoal, Defn.tprove, bossLib.WF_REL_TAC, bossLib.recInduct, bossLib.EVAL, bossLib.EVAL_TAC. \ENDDOC diff --git a/help/Docfiles/bossLib.type_rws.doc b/help/Docfiles/bossLib.type_rws.doc index d35e10ea6f..415bf6839f 100644 --- a/help/Docfiles/bossLib.type_rws.doc +++ b/help/Docfiles/bossLib.type_rws.doc @@ -14,7 +14,7 @@ returns a list of rewrite rules corresponding to the types. The list typically contains theorems about the distinctness and injectivity of constructors, the definition of the 'case' constant introduced at the time the type was defined, and any extra rewrites coming from the use of -records. +records. \FAILURE If {s} is not the name of a declared datatype. @@ -25,7 +25,7 @@ If {s} is not the name of a declared datatype. > val it = [|- (!v f. case v f [] = v) /\ !v f a0 a1. case v f (a0::a1) = f a0 a1, - |- !a1 a0. ~([] = a0::a1), + |- !a1 a0. ~([] = a0::a1), |- !a1 a0. ~(a0::a1 = []), |- !a0 a1 a0' a1'. (a0::a1 = a0'::a1') = (a0 = a0') /\ (a1 = a1')] diff --git a/help/Docfiles/bossLib.xDefine.doc b/help/Docfiles/bossLib.xDefine.doc index 646de40fa8..302f0945e2 100644 --- a/help/Docfiles/bossLib.xDefine.doc +++ b/help/Docfiles/bossLib.xDefine.doc @@ -34,13 +34,13 @@ a symbolic identifier. - set_fixity ("/", Infixl 600); (* tell the parser about "/" *) > val it = () : unit - - Define + - Define `x/y = if y=0 then NONE else - if x same_const c1 x orelse ... orelse same_const cn x) } diff --git a/help/Docfiles/fcpLib.FCP_ss.doc b/help/Docfiles/fcpLib.FCP_ss.doc index 02ed790c06..c7109428de 100644 --- a/help/Docfiles/fcpLib.FCP_ss.doc +++ b/help/Docfiles/fcpLib.FCP_ss.doc @@ -1,4 +1,4 @@ -\DOC +\DOC \TYPE {FCP_ss : ssfrag} diff --git a/help/Docfiles/hol88Lib.assoc.doc b/help/Docfiles/hol88Lib.assoc.doc index c5d1c701c6..dfa03b4369 100644 --- a/help/Docfiles/hol88Lib.assoc.doc +++ b/help/Docfiles/hol88Lib.assoc.doc @@ -8,7 +8,7 @@ value. \DESCRIBE {assoc x [(x1,y1),...,(xn,yn)]} returns the first {(xi,yi)} in the list such -that {xi} equals {x}. The lookup is done on an eqtype, i.e., the SML +that {xi} equals {x}. The lookup is done on an eqtype, i.e., the SML implementation must be able to decide equality for the type of {x}. \FAILURE diff --git a/help/Docfiles/hol88Lib.rev_assoc.doc b/help/Docfiles/hol88Lib.rev_assoc.doc index d1d7d72846..88b750ec80 100644 --- a/help/Docfiles/hol88Lib.rev_assoc.doc +++ b/help/Docfiles/hol88Lib.rev_assoc.doc @@ -8,7 +8,7 @@ value. \DESCRIBE {rev_assoc y [(x1,y1),...,(xn,yn)]} returns the first {(xi,yi)} in the list -such that {yi} equals {y}. The lookup is done on an eqtype, i.e., the SML +such that {yi} equals {y}. The lookup is done on an eqtype, i.e., the SML implementation must be able to decide equality for the type of {y}. \FAILURE diff --git a/help/Docfiles/holCheckLib.empty_model.doc b/help/Docfiles/holCheckLib.empty_model.doc index c6121e00ac..57551ef8e6 100644 --- a/help/Docfiles/holCheckLib.empty_model.doc +++ b/help/Docfiles/holCheckLib.empty_model.doc @@ -3,12 +3,12 @@ \TYPE {empty_model : model} \SYNOPSIS -Represents a HolCheck model with no information. +Represents a HolCheck model with no information. \DESCRIBE This is used as a starting point for building a HolCheck model, using the set_X functions in holCheckLib. -\SEEALSO +\SEEALSO holCheckLib.holCheck, holCheckLib.set_init, holCheckLib.set_trans, diff --git a/help/Docfiles/holCheckLib.get_flag_abs.doc b/help/Docfiles/holCheckLib.get_flag_abs.doc index dafb4f9de6..1c185cefcf 100644 --- a/help/Docfiles/holCheckLib.get_flag_abs.doc +++ b/help/Docfiles/holCheckLib.get_flag_abs.doc @@ -3,9 +3,9 @@ \TYPE {get_flag_abs : model -> bool} \SYNOPSIS -Returns whether or not HolCheck will attempt abstraction when checking this model. +Returns whether or not HolCheck will attempt abstraction when checking this model. -\SEEALSO +\SEEALSO holCheckLib.holCheck, holCheckLib.set_flag_abs. diff --git a/help/Docfiles/holCheckLib.get_flag_ric.doc b/help/Docfiles/holCheckLib.get_flag_ric.doc index 4c56aa0782..d75b5cc8c1 100644 --- a/help/Docfiles/holCheckLib.get_flag_ric.doc +++ b/help/Docfiles/holCheckLib.get_flag_ric.doc @@ -5,7 +5,7 @@ \SYNOPSIS Returns whether or not the transition system for this HolCheck model is synchronous (conjunctive). Throws an exception if this information has not been set. -\SEEALSO +\SEEALSO holCheckLib.holCheck, holCheckLib.set_flag_ric. diff --git a/help/Docfiles/holCheckLib.get_init.doc b/help/Docfiles/holCheckLib.get_init.doc index fe17807137..89477eafd8 100644 --- a/help/Docfiles/holCheckLib.get_init.doc +++ b/help/Docfiles/holCheckLib.get_init.doc @@ -5,7 +5,7 @@ \SYNOPSIS Returns the term describing the initial states of the HolCheck model. Throws an exception if no initial states have been set. -\SEEALSO +\SEEALSO holCheckLib.holCheck, holCheckLib.set_init. diff --git a/help/Docfiles/holCheckLib.get_name.doc b/help/Docfiles/holCheckLib.get_name.doc index 31d506e941..b74c06cdd0 100644 --- a/help/Docfiles/holCheckLib.get_name.doc +++ b/help/Docfiles/holCheckLib.get_name.doc @@ -5,7 +5,7 @@ \SYNOPSIS Returns the name of the HolCheck model, if one has been set. -\SEEALSO +\SEEALSO holCheckLib.holCheck, holCheckLib.set_name. diff --git a/help/Docfiles/holCheckLib.get_props.doc b/help/Docfiles/holCheckLib.get_props.doc index 0e205964fb..d1bc1cc9f1 100644 --- a/help/Docfiles/holCheckLib.get_props.doc +++ b/help/Docfiles/holCheckLib.get_props.doc @@ -5,7 +5,7 @@ \SYNOPSIS Returns the properties that will be checked for this HolCheck model. Throws an exception if no properties have been set. -\SEEALSO +\SEEALSO holCheckLib.holCheck, holCheckLib.set_props. diff --git a/help/Docfiles/holCheckLib.get_results.doc b/help/Docfiles/holCheckLib.get_results.doc index dd5e67eadc..284067cebc 100644 --- a/help/Docfiles/holCheckLib.get_results.doc +++ b/help/Docfiles/holCheckLib.get_results.doc @@ -3,12 +3,12 @@ \TYPE {get_results : model -> (term_bdd * thm option * term list option) list option} \SYNOPSIS -Returns the results of model checking the HolCheck model, if the model has been checked. +Returns the results of model checking the HolCheck model, if the model has been checked. \DESCRIBE -The order of results in the list corresponds to the order of properties in the list of properties to be checked for the model. The latter list can be recovered via holCheckLib.get_props. +The order of results in the list corresponds to the order of properties in the list of properties to be checked for the model. The latter list can be recovered via holCheckLib.get_props. -Each result is a triple. the first component contains the BDD representation of the set of states satisfying the property. If the check succeeded, the second component contains a theorem certifying that the property holds in the model i.e. it holds in the initial states. The third component contains a counterexample or witness trace, if one could be recovered. +Each result is a triple. the first component contains the BDD representation of the set of states satisfying the property. If the check succeeded, the second component contains a theorem certifying that the property holds in the model i.e. it holds in the initial states. The third component contains a counterexample or witness trace, if one could be recovered. \EXAMPLE For the mod-8 counter example used as a running example in the online reference, we obtain the following results for the property that the most significant bit eventually goes high: @@ -24,7 +24,7 @@ The first component contains the BDD representation of the set of states satisfy The second component contains a formal theorem certifying the property. The third component contains a witness trace that counts up to 4. -\SEEALSO +\SEEALSO holCheckLib.holCheck, holCheckLib.set_props, holCheckLib.prove_model. diff --git a/help/Docfiles/holCheckLib.get_state.doc b/help/Docfiles/holCheckLib.get_state.doc index c5e9020383..c477a027f3 100644 --- a/help/Docfiles/holCheckLib.get_state.doc +++ b/help/Docfiles/holCheckLib.get_state.doc @@ -5,7 +5,7 @@ \SYNOPSIS Returns the state tuple used internally by HolCheck for this model, if one has been set. -\SEEALSO +\SEEALSO holCheckLib.holCheck, holCheckLib.set_state. diff --git a/help/Docfiles/holCheckLib.get_trans.doc b/help/Docfiles/holCheckLib.get_trans.doc index 4c4a5ebca9..51e9d6affe 100644 --- a/help/Docfiles/holCheckLib.get_trans.doc +++ b/help/Docfiles/holCheckLib.get_trans.doc @@ -5,7 +5,7 @@ \SYNOPSIS Returns a description of the transition system of the HolCheck model. Throws an exception if no transition system has been set. -\SEEALSO +\SEEALSO holCheckLib.holCheck, holCheckLib.set_trans holCheckLib.get_flag_ric. diff --git a/help/Docfiles/holCheckLib.get_vord.doc b/help/Docfiles/holCheckLib.get_vord.doc index fdd1457201..06562b94a6 100644 --- a/help/Docfiles/holCheckLib.get_vord.doc +++ b/help/Docfiles/holCheckLib.get_vord.doc @@ -5,7 +5,7 @@ \SYNOPSIS Returns the BDD variable ordering used by HolCheck for this model, if one has been set. -\SEEALSO +\SEEALSO holCheckLib.holCheck, holCheckLib.set_vord. diff --git a/help/Docfiles/holCheckLib.holCheck.doc b/help/Docfiles/holCheckLib.holCheck.doc index 630e648396..53126a60d8 100644 --- a/help/Docfiles/holCheckLib.holCheck.doc +++ b/help/Docfiles/holCheckLib.holCheck.doc @@ -3,17 +3,17 @@ \TYPE {holCheck : model -> model} \SYNOPSIS -Basic symbolic model checker. +Basic symbolic model checker. \DESCRIBE User specifies a model by specifying (at least) the initial states, a labelled transition system, and a list of CTL or mu-calculus propertes. This model is then passed to the model checker which returns the model with the results of the checking filled in. These can be recovered by calling get_results on the returned model and are presented as a list of : the BDD semantics of each property, a theorem if the property holds in the model, and a counterexample or witness trace if appropriate. \FAILURE -holCheck should not fail, except on malformed input e.g. mu-calculus properties that are not well-formed mu-formulas or a supplied state tuple that does not include all state variables etc. +holCheck should not fail, except on malformed input e.g. mu-calculus properties that are not well-formed mu-formulas or a supplied state tuple that does not include all state variables etc. \EXAMPLE -We choose a mod-8 counter as our example, which starts at 0 and counts up to 7, and then loops from 0 again. We wish to show that the most significant bit eventually goes high. +We choose a mod-8 counter as our example, which starts at 0 and counts up to 7, and then loops from 0 again. We wish to show that the most significant bit eventually goes high. 1. Load the HolCheck library: { @@ -24,7 +24,7 @@ We choose a mod-8 counter as our example, which starts at 0 and counts up to 7, 2. Specify the labelled transition system as a list of (string, term) pairs, where each string is a transition label and each term represents a transition relation (three booleans required to encode numbers 0-7; next-state variable values indicated by priming; note we expand the xor, since HolCheck requires purely propositional terms) : { - val xor_def = Define `xor x y = (x \/ y) /\ ~(x=y)`; - val TS = List.map (I ## (rhs o concl o (fn tm => REWRITE_CONV [xor_def] tm handle ex => REFL tm))) + val TS = List.map (I ## (rhs o concl o (fn tm => REWRITE_CONV [xor_def] tm handle ex => REFL tm))) [("v0",``(v0'=~v0)``),("v1",``v1' = xor v0 v1``),("v2",``v2' = xor (v0 /\ v1) v2``)] Definition has been stored under "xor_def". > val xor_def = |- !x y. xor x y = (x \/ y) /\ ~(x = y) : thm @@ -36,7 +36,7 @@ Definition has been stored under "xor_def". 3. Specify the initial states (counter starts at 0): { -- val S0 = ``~v0 /\ ~v1 /\ ~v2``; +- val S0 = ``~v0 /\ ~v1 /\ ~v2``; > val S0 = ``~v0 /\ ~v1 /\ ~v2`` : term } @@ -60,7 +60,7 @@ Definition has been stored under "xor_def". Note how atomic propositions are represented as functions on the state. -7. Create the model: +7. Create the model: { - val m = ((set_init S0) o (set_trans TS) o (set_flag_ric ric) o (set_state state) o (set_props [ctlf])) empty_model; > val m = : model @@ -74,7 +74,7 @@ Note how atomic propositions are represented as functions on the state. 9. Examine the results: { -- get_results m2; +- get_results m2; > val it = SOME [(, SOME [............................] @@ -94,7 +94,7 @@ Note that since we did not supply a name for the model (via holCheckLib.set_name > val m3 = : model } -11. Examine the verified results: +11. Examine the verified results: { - get_results m3; > val it = @@ -105,12 +105,12 @@ Note that since we did not supply a name for the model (via holCheckLib.set_name (term_bdd * thm option * term list option) list option } -Note that the theorem component now has no assumptions. Any assumptions to the term_bdd would also have been discharged. +Note that the theorem component now has no assumptions. Any assumptions to the term_bdd would also have been discharged. \COMMENTS -For more detail, read the section on the HolCheck library in the HOL System Description. +For more detail, read the section on the HolCheck library in the HOL System Description. -\SEEALSO +\SEEALSO holCheckLib.empty_model, holCheckLib.get_init, holCheckLib.get_trans, diff --git a/help/Docfiles/holCheckLib.mk_state.doc b/help/Docfiles/holCheckLib.mk_state.doc index 98c27aa333..6ce4937e14 100644 --- a/help/Docfiles/holCheckLib.mk_state.doc +++ b/help/Docfiles/holCheckLib.mk_state.doc @@ -8,7 +8,7 @@ Given the initial states and transition system of a HolCheck model, constructs a \DESCRIBE HolCheck models atomic propositions in properties as functions on the state. Thus we need a representation of the state to specify properties. This function is used to create such a representative. Its return value is also passed to holCheckLib.set_state to ensure that the properties and the model use the same state tuple. -\SEEALSO +\SEEALSO holCheckLib.holCheck, holCheckLib.set_state. diff --git a/help/Docfiles/holCheckLib.prove_model.doc b/help/Docfiles/holCheckLib.prove_model.doc index f40cb26f73..8a1a515972 100644 --- a/help/Docfiles/holCheckLib.prove_model.doc +++ b/help/Docfiles/holCheckLib.prove_model.doc @@ -9,12 +9,12 @@ Attempts to discharge all assumptions to the term_bdd's and theorems in the resu HolCheck uses postponed proof verification to speed up the model checking work-flow. Any success theorems and term_bdd's thus end up with several undischarged assumptions. The idea is that the time-consuming proof verification can be postponed to a later time, when the user is otherwise occupied (e.g. asleep). \FAILURE -Fails if not called in the same HOL session that generated the results. This is because the required proof tactics are accumulated in memory as closures. Moscow ML (in which HOL is implemented) cannot persist closures. +Fails if not called in the same HOL session that generated the results. This is because the required proof tactics are accumulated in memory as closures. Moscow ML (in which HOL is implemented) cannot persist closures. \COMMENTS Other than the failure scenario documented above, a failure in the proof verification points to a bug in the HolCheck proof verification machinery; it does not invalidate the result. -\SEEALSO +\SEEALSO holCheckLib.holCheck, holCheckLib.get_results. diff --git a/help/Docfiles/holCheckLib.set_flag_abs.doc b/help/Docfiles/holCheckLib.set_flag_abs.doc index 5924c3509f..e0d394457b 100644 --- a/help/Docfiles/holCheckLib.set_flag_abs.doc +++ b/help/Docfiles/holCheckLib.set_flag_abs.doc @@ -6,12 +6,12 @@ Sets a flag telling HolCheck whether to attempt abstraction. \DESCRIBE -HolCheck uses a simple heuristic analysis of the model to determine whether it would be worthwhile to do abstraction. This flag can be used to override the default. +HolCheck uses a simple heuristic analysis of the model to determine whether it would be worthwhile to do abstraction. This flag can be used to override the default. \COMMENTS This information is optional when constructing HolCheck models. The default is true. -\SEEALSO +\SEEALSO holCheckLib.holCheck, holCheckLib.empty_model, holCheckLib.get_flag_abs. diff --git a/help/Docfiles/holCheckLib.set_flag_ric.doc b/help/Docfiles/holCheckLib.set_flag_ric.doc index 8bc180f0ad..fc39ab3bae 100644 --- a/help/Docfiles/holCheckLib.set_flag_ric.doc +++ b/help/Docfiles/holCheckLib.set_flag_ric.doc @@ -10,9 +10,9 @@ Sets a HolCheck model to be synchronous if the first argument is true, asynchron ric stands for "relation is conjunctive". This information is used by HolCheck to decide if the transitions of the model occur simultaneously (conjunctive, synchronous) or interleaved (disjunctive, asynchronous). \COMMENTS -This information must be set for a HolCheck model. +This information must be set for a HolCheck model. -\SEEALSO +\SEEALSO holCheckLib.holCheck, holCheckLib.empty_model, holCheckLib.get_flag_ric. diff --git a/help/Docfiles/holCheckLib.set_init.doc b/help/Docfiles/holCheckLib.set_init.doc index 25efd33042..950c57b219 100644 --- a/help/Docfiles/holCheckLib.set_init.doc +++ b/help/Docfiles/holCheckLib.set_init.doc @@ -3,16 +3,16 @@ \TYPE {set_init : term -> model -> model} \SYNOPSIS -Sets the initial set of states of a HolCheck model. +Sets the initial set of states of a HolCheck model. \DESCRIBE -The supplied term should be a term of propositional logic over the state variables, with no primed variables. +The supplied term should be a term of propositional logic over the state variables, with no primed variables. \FAILURE Fails if the supplied term is not a quantified boolean formula (QBF). \EXAMPLE -For a mod-8 counter, we need three boolean variables to encode the state. If the counter starts at 0, the set of initial states of the +For a mod-8 counter, we need three boolean variables to encode the state. If the counter starts at 0, the set of initial states of the model would be set as follows (assuming holCheckLib has been loaded): { @@ -20,12 +20,12 @@ model would be set as follows (assuming holCheckLib has been loaded): > val m = : model } -where empty_model can be replaced by whatever model the user is building. - +where empty_model can be replaced by whatever model the user is building. + \COMMENTS This information must be set for a HolCheck model. -\SEEALSO +\SEEALSO holCheckLib.holCheck, holCheckLib.empty_model, holCheckLib.get_init. diff --git a/help/Docfiles/holCheckLib.set_name.doc b/help/Docfiles/holCheckLib.set_name.doc index 3299cf91af..47eb15dc88 100644 --- a/help/Docfiles/holCheckLib.set_name.doc +++ b/help/Docfiles/holCheckLib.set_name.doc @@ -4,7 +4,7 @@ \SYNOPSIS -Sets the name given to the formal model HolCheck constructs internally. +Sets the name given to the formal model HolCheck constructs internally. \FAILURE Fails if the first argument does not follow the naming rules for constants. @@ -12,7 +12,7 @@ Fails if the first argument does not follow the naming rules for constants. \COMMENTS This information is optional when constructing HolCheck models. It should be set if more than one model is being used in the same session, to avoid name clashes. -\SEEALSO +\SEEALSO holCheckLib.holCheck, holCheckLib.empty_model, holCheckLib.get_name. diff --git a/help/Docfiles/holCheckLib.set_props.doc b/help/Docfiles/holCheckLib.set_props.doc index 5a6cddc870..0c669a4f0a 100644 --- a/help/Docfiles/holCheckLib.set_props.doc +++ b/help/Docfiles/holCheckLib.set_props.doc @@ -3,17 +3,17 @@ \TYPE {set_props : (string * term) list -> model -> model} \SYNOPSIS -Sets the properties to be checked for the supplied HolCheck model. +Sets the properties to be checked for the supplied HolCheck model. \DESCRIBE -The first argument is a list of (property_name, property) pair, where the name is a string and the property is a well-formed CTL or mu-calculus property. The list must not be empty. Names must be unique. +The first argument is a list of (property_name, property) pair, where the name is a string and the property is a well-formed CTL or mu-calculus property. The list must not be empty. Names must be unique. -In the properties, care must be taken to model atomic propositions as functions on the state. At the moment, only boolean variables are allowed as atomic propositions. +In the properties, care must be taken to model atomic propositions as functions on the state. At the moment, only boolean variables are allowed as atomic propositions. \FAILURE Fails if the property list is empty, or the names violate HOL constant naming rules, or names are unique. Also fails if any atomic proposition is not a paired abstraction of the form {\state. boolvar}. -\EXAMPLE +\EXAMPLE Specifing a CTL property for a mod-8 counter assuming holCheckLib has been loaded (there exists a future in which the most significant bit will go high) : { @@ -24,7 +24,7 @@ Specifing a CTL property for a mod-8 counter assuming holCheckLib has been loade \COMMENTS This information must be set for a HolCheck model. For more details on how to specify properties, see the examples in the src/HolCheck/examples directory; the mod8 and amba_apb examples are good starting points. -\SEEALSO +\SEEALSO holCheckLib.holCheck, holCheckLib.empty_model, holCheckLib.get_props, diff --git a/help/Docfiles/holCheckLib.set_state.doc b/help/Docfiles/holCheckLib.set_state.doc index b4265d078f..ceea17c856 100644 --- a/help/Docfiles/holCheckLib.set_state.doc +++ b/help/Docfiles/holCheckLib.set_state.doc @@ -4,12 +4,12 @@ \SYNOPSIS -Sets the state tuple used internally by the formal model contructed by HolCheck. +Sets the state tuple used internally by the formal model contructed by HolCheck. \COMMENTS This information is optional when constructing HolCheck models. By default, HolCheck will construct the state tuple itself. In practice however, a user nearly always needs to supply the state tuple, since it is almost always required when specifying properties. -\SEEALSO +\SEEALSO holCheckLib.holCheck, holCheckLib.mk_state, holCheckLib.get_state. diff --git a/help/Docfiles/holCheckLib.set_trans.doc b/help/Docfiles/holCheckLib.set_trans.doc index 70c73bd036..4a65e21d5a 100644 --- a/help/Docfiles/holCheckLib.set_trans.doc +++ b/help/Docfiles/holCheckLib.set_trans.doc @@ -3,16 +3,16 @@ \TYPE {set_trans : (string * Term.term) list -> model -> model} \SYNOPSIS -Sets the transition system for a HolCheck model. +Sets the transition system for a HolCheck model. \DESCRIBE The transition system is supplied as list of (transition label, transition relation) pairs. Each label must be a unique string. Each relation must be a propositional term, in which primed variables represent values in the next state. The transition label "." is internally used as a wildcard that is expected to match all transitions, and is thus not allowed as a transition label, unless there is only one transition. \FAILURE -Fails if the transition labels are not unique, or the transition list is empty, or the wildcard label is used with a non-singleton transition list, or any of the relation terms is not a quantified boolean formula (QBF). +Fails if the transition labels are not unique, or the transition list is empty, or the wildcard label is used with a non-singleton transition list, or any of the relation terms is not a quantified boolean formula (QBF). \EXAMPLE -For a mod-8 counter, we need three boolean variables to encode the state. The single transition relation can then be set as follows (assuming holCheckLib has been loaded): +For a mod-8 counter, we need three boolean variables to encode the state. The single transition relation can then be set as follows (assuming holCheckLib has been loaded): { - val m = holCheckLib.set_trans [("v0", ``v0' = ~v0``), ("v1", ``v1' = (v0 \/ v1) /\ ~(v0 = v1)``), @@ -20,12 +20,12 @@ For a mod-8 counter, we need three boolean variables to encode the state. The si > val m = : model } -where empty_model can be replaced by whatever model the user is building. +where empty_model can be replaced by whatever model the user is building. \COMMENTS This information must be set for a HolCheck model. -\SEEALSO +\SEEALSO holCheckLib.holCheck, holCheckLib.empty_model, holCheckLib.get_trans, diff --git a/help/Docfiles/holCheckLib.set_vord.doc b/help/Docfiles/holCheckLib.set_vord.doc index c7de1819eb..e0aecbda78 100644 --- a/help/Docfiles/holCheckLib.set_vord.doc +++ b/help/Docfiles/holCheckLib.set_vord.doc @@ -9,9 +9,9 @@ Sets the BDD variable ordering used by HolCheck for the given model. The first argument specifies the ordering of variables. This ordering must contain all current- and next-state variables specified by set_init and set_trans. In particular, if either set_init or set_trans use a variable v, then v' must be mentioned in the ordering. Likewise for unprimed versions of primed variables. \COMMENTS -This information is optional when constructing HolCheck models. By default, HolCheck constructs its own heuristic-based variable ordering. The heuristic used is a rather primitive one, at the moment. It just interleaves next- and current-state variables. +This information is optional when constructing HolCheck models. By default, HolCheck constructs its own heuristic-based variable ordering. The heuristic used is a rather primitive one, at the moment. It just interleaves next- and current-state variables. -\SEEALSO +\SEEALSO holCheckLib.holCheck, holCheckLib.empty_model, holCheckLib.get_vord. diff --git a/help/Docfiles/holyHammer.hh.doc b/help/Docfiles/holyHammer.hh.doc index 5838c26504..77c69ff16d 100644 --- a/help/Docfiles/holyHammer.hh.doc +++ b/help/Docfiles/holyHammer.hh.doc @@ -3,8 +3,8 @@ \TYPE {hh : Thm.thm list -> Term.term -> unit} \SYNOPSIS -Select relevant lemmas for proving a term using premise selection -algorithms and external provers (ATP). Additional theorems may +Select relevant lemmas for proving a term using premise selection +algorithms and external provers (ATP). Additional theorems may optionnally be provided to help the proof search. \DESCRIBE @@ -13,7 +13,7 @@ If an easy goal fails, consider changing predictor using is {KNN}. It is also possible to increase the default timeout of the provers using {set_timeout 5}. Additional theorems are considered very important for the proof so they should be chosen carefully and their -number should be limited. +number should be limited. \FAILURE Fails if the supplied term is not a boolean. Or if no ATP is installed. diff --git a/help/Docfiles/listLib.BUTFIRSTN_CONV.doc b/help/Docfiles/listLib.BUTFIRSTN_CONV.doc index 714fcfd786..2d47f5eeab 100644 --- a/help/Docfiles/listLib.BUTFIRSTN_CONV.doc +++ b/help/Docfiles/listLib.BUTFIRSTN_CONV.doc @@ -21,7 +21,7 @@ is the theorem \FAILURE -{BUTFIRSTN_CONV tm} fails if {tm} is not of the form described above, +{BUTFIRSTN_CONV tm} fails if {tm} is not of the form described above, or {k} is greater than the length of the list. \ENDDOC diff --git a/help/Docfiles/listLib.BUTLASTN_CONV.doc b/help/Docfiles/listLib.BUTLASTN_CONV.doc index 168465ec2c..9b6f34f49b 100644 --- a/help/Docfiles/listLib.BUTLASTN_CONV.doc +++ b/help/Docfiles/listLib.BUTLASTN_CONV.doc @@ -21,7 +21,7 @@ is the theorem \FAILURE -{BUTLASTN_CONV tm} fails if {tm} is not of the form described above, +{BUTLASTN_CONV tm} fails if {tm} is not of the form described above, or {k} is greater than the length of the list. \ENDDOC diff --git a/help/Docfiles/listLib.ELL_CONV.doc b/help/Docfiles/listLib.ELL_CONV.doc index eda4b7d442..f1114baf98 100644 --- a/help/Docfiles/listLib.ELL_CONV.doc +++ b/help/Docfiles/listLib.ELL_CONV.doc @@ -23,7 +23,7 @@ where {k} must not be greater then the length of the list. Note that {ELL} indexes the list elements from the tail end. \FAILURE -{ELL_CONV tm} fails if {tm} is not of the form described above, +{ELL_CONV tm} fails if {tm} is not of the form described above, or {k} is not less than the length of the list. \SEEALSO diff --git a/help/Docfiles/listLib.EL_CONV.doc b/help/Docfiles/listLib.EL_CONV.doc index 71d4c8862c..a0eb50e6c0 100644 --- a/help/Docfiles/listLib.EL_CONV.doc +++ b/help/Docfiles/listLib.EL_CONV.doc @@ -21,7 +21,7 @@ is the theorem \FAILURE -{EL_CONV tm} fails if {tm} is not of the form described above, +{EL_CONV tm} fails if {tm} is not of the form described above, or {k} is not less than the length of the list. \SEEALSO diff --git a/help/Docfiles/listLib.EQ_LENGTH_INDUCT_TAC.doc b/help/Docfiles/listLib.EQ_LENGTH_INDUCT_TAC.doc index a2071aeb51..ad4e0b8e05 100644 --- a/help/Docfiles/listLib.EQ_LENGTH_INDUCT_TAC.doc +++ b/help/Docfiles/listLib.EQ_LENGTH_INDUCT_TAC.doc @@ -12,7 +12,7 @@ tactic. {EQ_LENGTH_INDUCT_TAC} reduces a goal {!x y . (LENGTH x = LENGTH y) ==> t[x,y]}, where {x} and {y} range over lists, to two -subgoals corresponding to the base and step cases in a proof by +subgoals corresponding to the base and step cases in a proof by induction on the length of {x} and {y}. The induction hypothesis appears among the assumptions of the subgoal for the step case. The specification of {EQ_LENGTH_INDUCT_TAC} is: @@ -20,20 +20,20 @@ subgoal for the step case. The specification of {EQ_LENGTH_INDUCT_TAC} is: A ?- !x y . (LENGTH x = LENGTH y) ==> t[x,y] ==================================================== EQ_LENGTH_INDUCT_TAC A ?- t[NIL/x][NIL/y] - A u {{LENGTH x = LENGTH y, t[x'/x, y'/y]}} ?- + A u {{LENGTH x = LENGTH y, t[x'/x, y'/y]}} ?- !h h'. t[(CONS h x)/x, (CONS h' y)/y] } \FAILURE {EQ_LENGTH_INDUCT_TAC g} fails unless the conclusion of the goal {g} has the - form + form { !x y . (LENGTH x = LENGTH y) ==> t[x,y] } where the variables {x} and {y} have types {(xty)list} and {(yty)list} for some types {xty} and {yty}. It also fails if either of the variables {x} or {y} appear free in the - assumptions. + assumptions. \USES Use this tactic to perform structural induction over two lists that have diff --git a/help/Docfiles/listLib.EQ_LENGTH_SNOC_INDUCT_TAC.doc b/help/Docfiles/listLib.EQ_LENGTH_SNOC_INDUCT_TAC.doc index b6f13bc98d..35d1e2cee2 100644 --- a/help/Docfiles/listLib.EQ_LENGTH_SNOC_INDUCT_TAC.doc +++ b/help/Docfiles/listLib.EQ_LENGTH_SNOC_INDUCT_TAC.doc @@ -13,7 +13,7 @@ tactic. {EQ_LENGTH_SNOC_INDUCT_TAC} reduces a goal {!x y . (LENGTH x = LENGTH y) ==> t[x,y]}, where {x} and {y} range over lists, to two -subgoals corresponding to the base and step cases in a proof by +subgoals corresponding to the base and step cases in a proof by induction on the length of {x} and {y}. The induction hypothesis appears among the assumptions of the subgoal for the step case. The specification of {EQ_LENGTH_SNOC_INDUCT_TAC} is: @@ -21,20 +21,20 @@ subgoal for the step case. The specification of {EQ_LENGTH_SNOC_INDUCT_TAC} is: A ?- !x y . (LENGTH x = LENGTH y) ==> t[x,y] ================================================ EQ_LENGTH_SNOC_INDUCT_TAC A ?- t[NIL/x][NIL/y] - A u {{LENGTH x = LENGTH y, t[x'/x, y'/y]}} ?- + A u {{LENGTH x = LENGTH y, t[x'/x, y'/y]}} ?- !h h'. t[(SNOC h x)/x, (SNOC h' y)/y] } \FAILURE {EQ_LENGTH_SNOC_INDUCT_TAC g} fails unless the conclusion of the goal {g} has the - form + form { !x y . (LENGTH x = LENGTH y) ==> t[x,y] } where the variables {x} and {y} have types {(xty)list} and {(yty)list} for some types {xty} and {yty}. It also fails if either of the variables {x} or {y} appear free in the - assumptions. + assumptions. \USES Use this tactic to perform structural induction on two lists that have diff --git a/help/Docfiles/listLib.FIRSTN_CONV.doc b/help/Docfiles/listLib.FIRSTN_CONV.doc index 0914d513a1..4819ea667d 100644 --- a/help/Docfiles/listLib.FIRSTN_CONV.doc +++ b/help/Docfiles/listLib.FIRSTN_CONV.doc @@ -21,7 +21,7 @@ is the theorem \FAILURE -{FIRSTN_CONV tm} fails if {tm} is not of the form described above, +{FIRSTN_CONV tm} fails if {tm} is not of the form described above, or {k} is greater than the length of the list. \ENDDOC diff --git a/help/Docfiles/listLib.IS_EL_CONV.doc b/help/Docfiles/listLib.IS_EL_CONV.doc index 9408f7c5e3..ea11dd97c5 100644 --- a/help/Docfiles/listLib.IS_EL_CONV.doc +++ b/help/Docfiles/listLib.IS_EL_CONV.doc @@ -21,7 +21,7 @@ It returns the theorem if for every {xi} occurred in the list, {conv (--`x = xi`--)} returns a theorem {|- P xi = F}, otherwise, if for at least one {xi}, evaluating {conv (--`P xi`--)} returns the theorem {|- P xi = T}, then it -returns the theorem +returns the theorem { |- IS_EL P [x0;...xn] = T } diff --git a/help/Docfiles/listLib.LASTN_CONV.doc b/help/Docfiles/listLib.LASTN_CONV.doc index f728da9e91..0302594183 100644 --- a/help/Docfiles/listLib.LASTN_CONV.doc +++ b/help/Docfiles/listLib.LASTN_CONV.doc @@ -21,7 +21,7 @@ is the theorem \FAILURE -{LASTN_CONV tm} fails if {tm} is not of the form described above, +{LASTN_CONV tm} fails if {tm} is not of the form described above, or {k} is greater than the length of the list. \ENDDOC diff --git a/help/Docfiles/listLib.LIST_CONV.doc b/help/Docfiles/listLib.LIST_CONV.doc index 43badb7fd0..3a39d8c001 100644 --- a/help/Docfiles/listLib.LIST_CONV.doc +++ b/help/Docfiles/listLib.LIST_CONV.doc @@ -12,9 +12,9 @@ conversion, list. \DESCRIBE {LIST_CONV} takes a term of the form: { - CONST1 ... (CONST2 ...) ... -} -where {CONST1} and {CONST2} are operators on lists and {CONST2} returns a list + CONST1 ... (CONST2 ...) ... +} +where {CONST1} and {CONST2} are operators on lists and {CONST2} returns a list result. It can be one of {NIL}, {CONS}, {SNOC}, {APPEND}, {FLAT} or {REVERSE}. The form of the resulting theorem depends on {CONST1} and {CONST2}. Some auxiliary information must be provided about {CONST1}. {LIST_CONV} maintains a @@ -52,38 +52,38 @@ auxiliary theorems needed if {CONST1} is defined in terms of {FOLDR}. { CONST2 | side conditions | tm2 in result |- tm1 = tm2 ==============|================================|=========================== - [] | NONE | e - [x] | NONE | f x e - CONS x l | NONE | f x (CONST1 l) - SNOC x l | e is a list variable | CONST1 (f x e) l - APPEND l1 l2 | e is a list variable | CONST1 (CONST1 l1) l2 - APPEND l1 l2 | |- FCOMM g f, |- LEFT_ID g e | g (CONST1 l1) (CONST2 l2) - FLAT l1 | |- FCOMM g f, |- LEFT_ID g e, | - | |- CONST3 l = FOLDR g e l | CONST3 (MAP CONST1 l) - REVERSE l | |- COMM f, |- ASSOC f | CONST1 l - REVERSE l | f == (\x l. h (g x) l) | - | |- COMM h, |- ASSOC h | CONST1 l + [] | NONE | e + [x] | NONE | f x e + CONS x l | NONE | f x (CONST1 l) + SNOC x l | e is a list variable | CONST1 (f x e) l + APPEND l1 l2 | e is a list variable | CONST1 (CONST1 l1) l2 + APPEND l1 l2 | |- FCOMM g f, |- LEFT_ID g e | g (CONST1 l1) (CONST2 l2) + FLAT l1 | |- FCOMM g f, |- LEFT_ID g e, | + | |- CONST3 l = FOLDR g e l | CONST3 (MAP CONST1 l) + REVERSE l | |- COMM f, |- ASSOC f | CONST1 l + REVERSE l | f == (\x l. h (g x) l) | + | |- COMM h, |- ASSOC h | CONST1 l } The following table shows the form of the theorem returned and the auxiliary theorems needed if {CONST1} is defined in terms of {FOLDL}. { CONST2 | side conditions | tm2 in result |- tm1 = tm2 ==============|================================|=========================== - [] | NONE | e - [x] | NONE | f x e - SNOC x l | NONE | f x (CONST1 l) - CONS x l | e is a list variable | CONST1 (f x e) l - APPEND l1 l2 | e is a list variable | CONST1 (CONST1 l1) l2 - APPEND l1 l2 | |- FCOMM f g, |- RIGHT_ID g e | g (CONST1 l1) (CONST2 l2) - FLAT l1 | |- FCOMM f g, |- RIGHT_ID g e, | - | |- CONST3 l = FOLDR g e l | CONST3 (MAP CONST1 l) - REVERSE l | |- COMM f, |- ASSOC f | CONST1 l - REVERSE l | f == (\l x. h l (g x)) | - | |- COMM h, |- ASSOC h | CONST1 l + [] | NONE | e + [x] | NONE | f x e + SNOC x l | NONE | f x (CONST1 l) + CONS x l | e is a list variable | CONST1 (f x e) l + APPEND l1 l2 | e is a list variable | CONST1 (CONST1 l1) l2 + APPEND l1 l2 | |- FCOMM f g, |- RIGHT_ID g e | g (CONST1 l1) (CONST2 l2) + FLAT l1 | |- FCOMM f g, |- RIGHT_ID g e, | + | |- CONST3 l = FOLDR g e l | CONST3 (MAP CONST1 l) + REVERSE l | |- COMM f, |- ASSOC f | CONST1 l + REVERSE l | f == (\l x. h l (g x)) | + | |- COMM h, |- ASSOC h | CONST1 l } {|- MONOID f e} can be used instead of {|- FCOMM f f}, {|- LEFT_ID f} or {|- RIGHT_ID f}. {|- ASSOC f} can also be used in place of -{|- FCOMM f f}. +{|- FCOMM f f}. Auxiliary theorems are held in a user-updatable database. In particular, @@ -112,7 +112,7 @@ auxiliary theorems about their step functions and base elements. |- APPEND l1 (CONS h t) = APPEND (SNOC h l1) t } { -- LIST_CONV (--`MAP (P:'a list -> 'a) (SNOC h t)`--); +- LIST_CONV (--`MAP (P:'a list -> 'a) (SNOC h t)`--); |- MAP P (SNOC h t) = SNOC (P h) (MAP P t) } { diff --git a/help/Docfiles/listLib.MAP2_CONV.doc b/help/Docfiles/listLib.MAP2_CONV.doc index 9d14b24c88..0f126c2336 100644 --- a/help/Docfiles/listLib.MAP2_CONV.doc +++ b/help/Docfiles/listLib.MAP2_CONV.doc @@ -8,27 +8,27 @@ Compute the result of mapping a binary function down two lists. \KEYWORDS conversion, list. -\DESCRIBE +\DESCRIBE The function {MAP2_CONV} is a conversion for computing the result of mapping a binary function {f:ty1->ty2->ty3} down two lists {--`[l11;...;l1n]`--} whose elements are of type {ty1} and {--`[l21;...;l2n]`--} whose elements are of type {ty2}. The lengths of the two lists must be identical. The first -argument to {MAP2_CONV} is expected to be a conversion +argument to {MAP2_CONV} is expected to be a conversion that computes the result of applying the function {f} to a pair of corresponding elements of these lists. When applied to a term {--`f l1i l2i`--}, this conversion should return a theorem of the form {|- (f l1i l2i) = ri}, where {ri} is the result of applying the function -{f} to the elements {l1i} and {l2i}. +{f} to the elements {l1i} and {l2i}. Given an appropriate {conv}, the conversion {MAP2_CONV conv} takes a term of the form {--`MAP2 f [l11;...;dl2tn] [l21;...;l2n]`--} and returns -the theorem +the theorem { - |- MAP2 f [l11;...;l1n] [l21;...;l2n] = [r1;...;rn] -} + |- MAP2 f [l11;...;l1n] [l21;...;l2n] = [r1;...;rn] +} where {conv (--`f l1i l2i`--)} returns {|- (f l1i l2i) = ri} for -{i} from {1} to {n}. +{i} from {1} to {n}. \EXAMPLE @@ -40,7 +40,7 @@ elements from the two lists are summed to form the resulting list: |- MAP2 $+ [1;2;3] [1;2;3] = [2;4;6] } -\FAILURE +\FAILURE {MAP2_CONV conv} fails if applied to a term not of the form described above. An application of {MAP2_CONV conv} to a term {--`MAP2 f [l11;...;l1n] [l21;...;l2n]`--} fails unless for all {i} where {1<=i<=n} diff --git a/help/Docfiles/listLib.MAP_CONV.doc b/help/Docfiles/listLib.MAP_CONV.doc index 66b192009b..57dc1b617e 100644 --- a/help/Docfiles/listLib.MAP_CONV.doc +++ b/help/Docfiles/listLib.MAP_CONV.doc @@ -8,31 +8,31 @@ Compute the result of mapping a function down a list. \KEYWORDS conversion, list. -\DESCRIBE +\DESCRIBE The function {MAP_CONV} is a parameterized conversion for computing the result of mapping a function {f:ty1->ty2} down a list {--`[t1;...;tn]`--} of elements of type {ty1}. The first argument to {MAP_CONV} is expected to be a conversion that computes the result of applying the function {f} to an element of this list. When applied to a term {--`f ti`--}, this conversion should return a theorem of the form {|- (f ti) = ri}, where {ri} is the result of applying the function -{f} to the element {ti}. +{f} to the element {ti}. Given an appropriate {conv}, the conversion {MAP_CONV conv} takes a term of the form {--`MAP f [t1;...;tn]`--} to the theorem { - |- MAP f [t1;...;tn] = [r1;...;rn] -} + |- MAP f [t1;...;tn] = [r1;...;rn] +} where {conv (--`f ti`--)} returns {|- (f ti) = ri} for {i} from {1} to {n}. \EXAMPLE -The following is a very simple example in which no computation is done for +The following is a very simple example in which no computation is done for applications of the function being mapped down a list: { - MAP_CONV ALL_CONV (--`MAP SUC [1;2;1;4]`--); |- MAP SUC[1;2;1;4] = [SUC 1;SUC 2;SUC 1;SUC 4] } -The result just contains applications of {SUC}, since the supplied +The result just contains applications of {SUC}, since the supplied conversion {ALL_CONV} does no evaulation. We now construct a conversion that maps {SUC n} for any numeral {n} to the @@ -61,7 +61,7 @@ result of mapping the successor function down a list of numerals: |- MAP SUC[1;2;1;4] = [2;3;2;5] } -\FAILURE +\FAILURE {MAP_CONV conv} fails if applied to a term not of the form {--`MAP f [t1;...;tn]`--}. An application of {MAP_CONV conv} to a term {--`MAP f [t1;...;tn]`--} fails unless for all {ti} in the list {[t1;...;tn]}, diff --git a/help/Docfiles/listLib.OR_EL_CONV.doc b/help/Docfiles/listLib.OR_EL_CONV.doc index 3341fe505f..f17c63141a 100644 --- a/help/Docfiles/listLib.OR_EL_CONV.doc +++ b/help/Docfiles/listLib.OR_EL_CONV.doc @@ -37,7 +37,7 @@ are not boolean constants. } { - OR_EL_CONV (--`OR_EL [x;T;y]`--); -|- OR_EL [x; T; y] = T +|- OR_EL [x; T; y] = T } diff --git a/help/Docfiles/listLib.PURE_LIST_CONV.doc b/help/Docfiles/listLib.PURE_LIST_CONV.doc index c9f10e8435..075b825d28 100644 --- a/help/Docfiles/listLib.PURE_LIST_CONV.doc +++ b/help/Docfiles/listLib.PURE_LIST_CONV.doc @@ -12,7 +12,7 @@ conversion, list. \DESCRIBE {PURE_LIST_CONV} takes a term of the form: { - CONST1 ... (CONST2 ...) ... + CONST1 ... (CONST2 ...) ... } where {CONST1} and {CONST2} are operators on lists and {CONST2} returns a list result. It can be one of {NIL}, {CONS}, {SNOC}, {APPEND}, @@ -33,56 +33,56 @@ base element and {l} a list variable. For example, a suitable theorem for Given this theorem, no auxiliary theorems and the term {--`SUM (CONS x l)`--}, a call to {PURE_LIST_CONV} returns the theorem: { - |- SUM (CONS x l) = x + (SUM l) + |- SUM (CONS x l) = x + (SUM l) } The {Aux_thms} field of the record argument to {PURE_LIST_CONV} provides auxiliary theorems concerning the terms {f} and {e} found in the definition -with respect to {FOLDR} or {FOLDL}. For example, given the theorem: -{ - |- MONOID $+ 0 -} +with respect to {FOLDR} or {FOLDL}. For example, given the theorem: +{ + |- MONOID $+ 0 +} and given the term {--`SUM (APPEND l1 l2)`--}, a call to -{PURE_LIST_CONV} returns the theorem +{PURE_LIST_CONV} returns the theorem { - |- SUM (APPEND l1 l2) = (SUM l1) + (SUM l2) -} + |- SUM (APPEND l1 l2) = (SUM l1) + (SUM l2) +} The following table shows the form of the theorem returned and the auxiliary theorems needed if {CONST1} is defined in terms of {FOLDR}. { CONST2 | side conditions | tm2 in result |- tm1 = tm2 ==============|================================|=========================== - [] | NONE | e - [x] | NONE | f x e - CONS x l | NONE | f x (CONST1 l) - SNOC x l | e is a list variable | CONST1 (f x e) l - APPEND l1 l2 | e is a list variable | CONST1 (CONST1 l1) l2 - APPEND l1 l2 | |- FCOMM g f, |- LEFT_ID g e | g (CONST1 l1) (CONST2 l2) - FLAT l1 | |- FCOMM g f, |- LEFT_ID g e, | - | |- CONST3 l = FOLDR g e l | CONST3 (MAP CONST1 l) - REVERSE l | |- COMM f, |- ASSOC f | CONST1 l - REVERSE l | f == (\x l. h (g x) l) | - | |- COMM h, |- ASSOC h | CONST1 l + [] | NONE | e + [x] | NONE | f x e + CONS x l | NONE | f x (CONST1 l) + SNOC x l | e is a list variable | CONST1 (f x e) l + APPEND l1 l2 | e is a list variable | CONST1 (CONST1 l1) l2 + APPEND l1 l2 | |- FCOMM g f, |- LEFT_ID g e | g (CONST1 l1) (CONST2 l2) + FLAT l1 | |- FCOMM g f, |- LEFT_ID g e, | + | |- CONST3 l = FOLDR g e l | CONST3 (MAP CONST1 l) + REVERSE l | |- COMM f, |- ASSOC f | CONST1 l + REVERSE l | f == (\x l. h (g x) l) | + | |- COMM h, |- ASSOC h | CONST1 l } The following table shows the form of the theorem returned and the auxiliary theorems needed if {CONST1} is defined in terms of {FOLDL}. { CONST2 | side conditions | tm2 in result |- tm1 = tm2 ==============|================================|=========================== - [] | NONE | e - [x] | NONE | f x e - SNOC x l | NONE | f x (CONST1 l) - CONS x l | e is a list variable | CONST1 (f x e) l - APPEND l1 l2 | e is a list variable | CONST1 (CONST1 l1) l2 - APPEND l1 l2 | |- FCOMM f g, |- RIGHT_ID g e | g (CONST1 l1) (CONST2 l2) - FLAT l1 | |- FCOMM f g, |- RIGHT_ID g e, | - | |- CONST3 l = FOLDR g e l | CONST3 (MAP CONST1 l) - REVERSE l | |- COMM f, |- ASSOC f | CONST1 l - REVERSE l | f == (\l x. h l (g x)) | - | |- COMM h, |- ASSOC h | CONST1 l -} + [] | NONE | e + [x] | NONE | f x e + SNOC x l | NONE | f x (CONST1 l) + CONS x l | e is a list variable | CONST1 (f x e) l + APPEND l1 l2 | e is a list variable | CONST1 (CONST1 l1) l2 + APPEND l1 l2 | |- FCOMM f g, |- RIGHT_ID g e | g (CONST1 l1) (CONST2 l2) + FLAT l1 | |- FCOMM f g, |- RIGHT_ID g e, | + | |- CONST3 l = FOLDR g e l | CONST3 (MAP CONST1 l) + REVERSE l | |- COMM f, |- ASSOC f | CONST1 l + REVERSE l | f == (\l x. h l (g x)) | + | |- COMM h, |- ASSOC h | CONST1 l +} {|- MONOID f e} can be used instead of {|- FCOMM f f}, {|- LEFT_ID f} or {|- RIGHT_ID f}. {|- ASSOC f} can also be used in place of -{|- FCOMM f f}. +{|- FCOMM f f}. \EXAMPLE { diff --git a/help/Docfiles/listLib.SCANL_CONV.doc b/help/Docfiles/listLib.SCANL_CONV.doc index ac8fe8c32c..65e6a28295 100644 --- a/help/Docfiles/listLib.SCANL_CONV.doc +++ b/help/Docfiles/listLib.SCANL_CONV.doc @@ -20,8 +20,8 @@ It returns the theorem where {ei} is the result of applying the function {f} to the result of the previous iteration and the current element, i.e., {ei = f e(i-1) xi}. The iteration starts from the left-hand side (the -head) of the list. -The user supplied conversion {conv} is used to derive a theorem +head) of the list. +The user supplied conversion {conv} is used to derive a theorem { |- f e(i-1) xi = ei } diff --git a/help/Docfiles/listLib.SCANR_CONV.doc b/help/Docfiles/listLib.SCANR_CONV.doc index bb9e16156c..d1130ee99c 100644 --- a/help/Docfiles/listLib.SCANR_CONV.doc +++ b/help/Docfiles/listLib.SCANR_CONV.doc @@ -21,8 +21,8 @@ It returns the theorem where {ei} is the result of applying the function {f} to the result of the previous iteration and the current element, i.e., {ei = f e(i-1) xi}. The iteration starts from the right-hand side (the -tail) of the list. -The user supplied conversion {conv} is used to derive a theorem +tail) of the list. +The user supplied conversion {conv} is used to derive a theorem { |- f e(i-1) xi = ei } diff --git a/help/Docfiles/listLib.SNOC_INDUCT_TAC.doc b/help/Docfiles/listLib.SNOC_INDUCT_TAC.doc index f463f66ae2..6387afff21 100644 --- a/help/Docfiles/listLib.SNOC_INDUCT_TAC.doc +++ b/help/Docfiles/listLib.SNOC_INDUCT_TAC.doc @@ -13,7 +13,7 @@ tactic, list, induction. subgoals corresponding to the base and step cases in a proof by structural induction on {l} from the tail end. The induction hypothesis appears among the assumptions of the subgoal for the step case. The -specification of {SNOC_INDUCT_TAC} is: +specification of {SNOC_INDUCT_TAC} is: { A ?- !l. P ===================================================== SNOC_INDUCT_TAC diff --git a/help/Docfiles/listLib.X_LIST_CONV.doc b/help/Docfiles/listLib.X_LIST_CONV.doc index bcab2fef2c..b4dff53fa5 100644 --- a/help/Docfiles/listLib.X_LIST_CONV.doc +++ b/help/Docfiles/listLib.X_LIST_CONV.doc @@ -15,9 +15,9 @@ conversion, list. theorems about user-defined constants as an argument. It takes a term of the form: { - CONST1 ... (CONST2 ...) ... -} -where {CONST1} and {CONST2} are operators on lists and {CONST2} returns a list + CONST1 ... (CONST2 ...) ... +} +where {CONST1} and {CONST2} are operators on lists and {CONST2} returns a list result. It can be one of {NIL}, {CONS}, {SNOC}, {APPEND}, {FLAT} or {REVERSE}. The form of the resulting theorem depends on {CONST1} and {CONST2}. Some auxiliary information must be provided about {CONST1}. {X_LIST_CONV} maintains a @@ -55,38 +55,38 @@ auxiliary theorems needed if {CONST1} is defined in terms of {FOLDR}. { CONST2 | side conditions | tm2 in result |- tm1 = tm2 ==============|================================|=========================== - [] | NONE | e - [x] | NONE | f x e - CONS x l | NONE | f x (CONST1 l) - SNOC x l | e is a list variable | CONST1 (f x e) l - APPEND l1 l2 | e is a list variable | CONST1 (CONST1 l1) l2 - APPEND l1 l2 | |- FCOMM g f, |- LEFT_ID g e | g (CONST1 l1) (CONST2 l2) - FLAT l1 | |- FCOMM g f, |- LEFT_ID g e, | - | |- CONST3 l = FOLDR g e l | CONST3 (MAP CONST1 l) - REVERSE l | |- COMM f, |- ASSOC f | CONST1 l - REVERSE l | f == (\x l. h (g x) l) | - | |- COMM h, |- ASSOC h | CONST1 l + [] | NONE | e + [x] | NONE | f x e + CONS x l | NONE | f x (CONST1 l) + SNOC x l | e is a list variable | CONST1 (f x e) l + APPEND l1 l2 | e is a list variable | CONST1 (CONST1 l1) l2 + APPEND l1 l2 | |- FCOMM g f, |- LEFT_ID g e | g (CONST1 l1) (CONST2 l2) + FLAT l1 | |- FCOMM g f, |- LEFT_ID g e, | + | |- CONST3 l = FOLDR g e l | CONST3 (MAP CONST1 l) + REVERSE l | |- COMM f, |- ASSOC f | CONST1 l + REVERSE l | f == (\x l. h (g x) l) | + | |- COMM h, |- ASSOC h | CONST1 l } The following table shows the form of the theorem returned and the auxiliary theorems needed if {CONST1} is defined in terms of {FOLDL}. { CONST2 | side conditions | tm2 in result |- tm1 = tm2 ==============|================================|=========================== - [] | NONE | e - [x] | NONE | f x e - SNOC x l | NONE | f x (CONST1 l) - CONS x l | e is a list variable | CONST1 (f x e) l - APPEND l1 l2 | e is a list variable | CONST1 (CONST1 l1) l2 - APPEND l1 l2 | |- FCOMM f g, |- RIGHT_ID g e | g (CONST1 l1) (CONST2 l2) - FLAT l1 | |- FCOMM f g, |- RIGHT_ID g e, | - | |- CONST3 l = FOLDR g e l | CONST3 (MAP CONST1 l) - REVERSE l | |- COMM f, |- ASSOC f | CONST1 l - REVERSE l | f == (\l x. h l (g x)) | - | |- COMM h, |- ASSOC h | CONST1 l + [] | NONE | e + [x] | NONE | f x e + SNOC x l | NONE | f x (CONST1 l) + CONS x l | e is a list variable | CONST1 (f x e) l + APPEND l1 l2 | e is a list variable | CONST1 (CONST1 l1) l2 + APPEND l1 l2 | |- FCOMM f g, |- RIGHT_ID g e | g (CONST1 l1) (CONST2 l2) + FLAT l1 | |- FCOMM f g, |- RIGHT_ID g e, | + | |- CONST3 l = FOLDR g e l | CONST3 (MAP CONST1 l) + REVERSE l | |- COMM f, |- ASSOC f | CONST1 l + REVERSE l | f == (\l x. h l (g x)) | + | |- COMM h, |- ASSOC h | CONST1 l } {|- MONOID f e} can be used instead of {|- FCOMM f f}, {|- LEFT_ID f} or {|- RIGHT_ID f}. {|- ASSOC f} can also be used in place of -{|- FCOMM f f}. +{|- FCOMM f f}. diff --git a/help/Docfiles/listLib.list_FOLD_CONV.doc b/help/Docfiles/listLib.list_FOLD_CONV.doc index d6952964a0..385f741fbd 100644 --- a/help/Docfiles/listLib.list_FOLD_CONV.doc +++ b/help/Docfiles/listLib.list_FOLD_CONV.doc @@ -40,7 +40,7 @@ following theorem: { |- !l. SUM l = FOLDR $+ 0 l } -The conversion for {SUM}, {SUM_CONV} can be implemented as +The conversion for {SUM}, {SUM_CONV} can be implemented as { load_library_in_place num_lib; val SUM_CONV = diff --git a/help/Docfiles/listLib.list_thm_database.doc b/help/Docfiles/listLib.list_thm_database.doc index 24ff2ebb30..cf09e48864 100644 --- a/help/Docfiles/listLib.list_thm_database.doc +++ b/help/Docfiles/listLib.list_thm_database.doc @@ -15,7 +15,7 @@ A call to {list_thm_database()} returns a pair of lists. The first element of the pair contains the known fold definitions. The second contains the known auxiliary theorems. -The following is an example of a fold definition in the database: +The following is an example of a fold definition in the database: { |- !l. SUM l = FOLDR $+ 0 l } diff --git a/help/Docfiles/listLib.set_list_thm_database.doc b/help/Docfiles/listLib.set_list_thm_database.doc index d3a1aa1e6d..6378157a91 100644 --- a/help/Docfiles/listLib.set_list_thm_database.doc +++ b/help/Docfiles/listLib.set_list_thm_database.doc @@ -17,7 +17,7 @@ replaces the existing database with the theorems given as the arguments. The {Aux_thms} field contains the new auxiliary theorems. Theorems which do not have an appropriate form will be ignored. -The following is an example of a fold definition in the database: +The following is an example of a fold definition in the database: { |- !l. SUM l = FOLDR $+ 0 l } diff --git a/help/Docfiles/listSyntax.mk_list.doc b/help/Docfiles/listSyntax.mk_list.doc index e5240f122b..d0abcec969 100644 --- a/help/Docfiles/listSyntax.mk_list.doc +++ b/help/Docfiles/listSyntax.mk_list.doc @@ -10,7 +10,7 @@ Constructs an object-level (HOL) list from an ML list of terms. The type argument is required so that empty lists can be constructed. \FAILURE -Fails if any term in the list is not of the type specified as the +Fails if any term in the list is not of the type specified as the second argument. \SEEALSO diff --git a/help/Docfiles/numLib.REDUCE_CONV.doc b/help/Docfiles/numLib.REDUCE_CONV.doc index b818aaed61..7833f160dc 100644 --- a/help/Docfiles/numLib.REDUCE_CONV.doc +++ b/help/Docfiles/numLib.REDUCE_CONV.doc @@ -3,8 +3,8 @@ \TYPE {REDUCE_CONV : conv} \SYNOPSIS -Evaluate ground expressions involving arithemetic and boolean -operations. +Evaluate ground expressions involving arithemetic and boolean +operations. \KEYWORDS Ground evaluation. @@ -12,7 +12,7 @@ Ground evaluation. \DESCRIBE An invocation {REDUCE_CONV M}, where {M} is a ground term made up of the standard boolean and numerical operators, uses deductive steps -to perform any possible reductions, yielding the result {N}. The +to perform any possible reductions, yielding the result {N}. The theorem {|- M = N} is returned. \FAILURE @@ -23,7 +23,7 @@ Never fails. - REDUCE_CONV (Term `!x:num. x = x`); > val it = |- (!x. x = x) = !x. T : thm -- REDUCE_CONV +- REDUCE_CONV (Term`(y = (((2 + 4 - 1) * 5) ** 3) DIV 2) /\ (p \/ T ==> q)`); > val it = |- (y = ((2 + 4 - 1) * 5) ** 3 DIV 2) /\ (p \/ T ==> q) = diff --git a/help/Docfiles/numSyntax.dest_numeral.doc b/help/Docfiles/numSyntax.dest_numeral.doc index a4df81b338..0a97b834f9 100644 --- a/help/Docfiles/numSyntax.dest_numeral.doc +++ b/help/Docfiles/numSyntax.dest_numeral.doc @@ -7,14 +7,14 @@ Convert HOL numeral to ML bignum value. \DESCRIBE An invocation {dest_numeral tm}, where {tm} is a HOL numeral (a literal of type {num}), -returns the corrresponding ML value of type {Arbnum.num}. A numeral is a +returns the corrresponding ML value of type {Arbnum.num}. A numeral is a dyadic positional notation described by the following BNF: { ::= 0 | NUMERAL ::= ZERO | BIT1 () | BIT2 () } The {NUMERAL} constant is used as a tag signalling that its argument -is indeed a numeric literal. The {ZERO} constant is equal to {0}, +is indeed a numeric literal. The {ZERO} constant is equal to {0}, and {BIT1(n) = 2*n + 1} while {BIT2(n) = 2*n + 2}. This representation allows asymptotically efficient operations on numeric values. diff --git a/help/Docfiles/numSyntax.is_numeral.doc b/help/Docfiles/numSyntax.is_numeral.doc index 4ffd3c6f15..7bf36df97f 100644 --- a/help/Docfiles/numSyntax.is_numeral.doc +++ b/help/Docfiles/numSyntax.is_numeral.doc @@ -6,7 +6,7 @@ Check if HOL term is a numeral. \DESCRIBE -An invocation {is_numeral tm}, where {tm} is a HOL term with +An invocation {is_numeral tm}, where {tm} is a HOL term with the following form { ::= 0 | NUMERAL @@ -14,7 +14,7 @@ the following form } returns {true}; otherwise, {false} is returned. The {NUMERAL} constant is used as a tag signalling that its argument -is indeed a numeric literal. The {ZERO} constant is equal to {0}, +is indeed a numeric literal. The {ZERO} constant is equal to {0}, and {BIT1(n) = 2*n + 1} while {BIT2(n) = 2*n + 2}. This representation allows asymptotically efficient operations on numeric values. diff --git a/help/Docfiles/numSyntax.mk_numeral.doc b/help/Docfiles/numSyntax.mk_numeral.doc index 96c85e16fa..740ba2e498 100644 --- a/help/Docfiles/numSyntax.mk_numeral.doc +++ b/help/Docfiles/numSyntax.mk_numeral.doc @@ -6,8 +6,8 @@ Convert ML bignum value to HOL numeral. \DESCRIBE -An invocation {mk_numeral n}, where {n} is an ML value of type -{Arbnum.num} returns the corrresponding HOL term. +An invocation {mk_numeral n}, where {n} is an ML value of type +{Arbnum.num} returns the corrresponding HOL term. \EXAMPLE { diff --git a/help/Docfiles/pairSyntax.dest_anylet.doc b/help/Docfiles/pairSyntax.dest_anylet.doc index 770669dec4..b98a72738e 100644 --- a/help/Docfiles/pairSyntax.dest_anylet.doc +++ b/help/Docfiles/pairSyntax.dest_anylet.doc @@ -8,11 +8,11 @@ Destructs arbitrary {let} terms. \DESCRIBE The invocation {dest_anylet M} where {M} has the form of a let-abstraction, i.e., {LET P Q}, returns a pair {([(a1,b1),...,(an,bn)],body)}, where the first argument -is a list of bindings, and the second is the body of the let. The list of bindings +is a list of bindings, and the second is the body of the let. The list of bindings is required since let terms can, in general, be of the form (using surface syntax) {let a1 = b1 and ... and an = bn in body}. -Each {ai} can be a varstruct (a single variable or a tuple of variables), +Each {ai} can be a varstruct (a single variable or a tuple of variables), or a function variable applied to a sequence of varstructs. \FAILURE @@ -24,9 +24,9 @@ Fails if {M} is not a let abstraction. > val it = ([(`f (x,y)`, `M`), (`g z`, `N`)], `g (f (a,b))`) : - dest_anylet ``let f (x,y) = M in - let g z = N + let g z = N in g (f (a,b))``; -> val it = ([(`f (x,y)`, `M`)], `let g z = N in g (f (a,b))`) +> val it = ([(`f (x,y)`, `M`)], `let g z = N in g (f (a,b))`) } \USES diff --git a/help/Docfiles/pairSyntax.genvarstruct.doc b/help/Docfiles/pairSyntax.genvarstruct.doc index 5b33cf0548..c940e779ed 100644 --- a/help/Docfiles/pairSyntax.genvarstruct.doc +++ b/help/Docfiles/pairSyntax.genvarstruct.doc @@ -9,8 +9,8 @@ pair Returns a pair structure of variables whose names have not been previously used. \DESCRIBE -When given a product type, {genvarstruct} returns a -paired structure of variables whose names have not been +When given a product type, {genvarstruct} returns a +paired structure of variables whose names have not been used for variables or constants in the HOL session so far. The structure of the term returned will be identical to the structure of the argument. diff --git a/help/Docfiles/pairSyntax.list_mk_anylet.doc b/help/Docfiles/pairSyntax.list_mk_anylet.doc index 9f40b072a0..996d9c639d 100644 --- a/help/Docfiles/pairSyntax.list_mk_anylet.doc +++ b/help/Docfiles/pairSyntax.list_mk_anylet.doc @@ -6,30 +6,30 @@ Construct arbitrary {let} terms. \DESCRIBE -The invocation -{list_mk_anylet ([[(a1,b1),...,(an,bn)], ... [(u1,v1),...,(uk,vk)]],body)} -returns a term with surface syntax +The invocation +{list_mk_anylet ([[(a1,b1),...,(an,bn)], ... [(u1,v1),...,(uk,vk)]],body)} +returns a term with surface syntax { -let a1 = b1 and ... an = bn in - ... in +let a1 = b1 and ... an = bn in + ... in let u1 = v1 and ... and uk = vk in body -} +} \FAILURE If any binding pair {(x,y)} is such that {x} and {y} have different types. \EXAMPLE { -list_mk_anylet - ([[(``x:'a``, ``P:'a``)], +list_mk_anylet + ([[(``x:'a``, ``P:'a``)], [(``(y:'a, z:ind)``, ``M:'a#ind``)], - [(``f (x:'a):bool``, ``N:bool``), + [(``f (x:'a):bool``, ``N:bool``), (``g:bool->'a``, ``K (v:'a):bool->'a``)]], ``g (f (x:'a):bool):'a``); -> val it = `let x = P in - let (y,z) = M in - let f x = N - and g = K v +> val it = `let x = P in + let (y,z) = M in + let f x = N + and g = K v in g (f x)` } diff --git a/help/Docfiles/pairSyntax.list_mk_pabs.doc b/help/Docfiles/pairSyntax.list_mk_pabs.doc index f69fd6c646..319380f86d 100644 --- a/help/Docfiles/pairSyntax.list_mk_pabs.doc +++ b/help/Docfiles/pairSyntax.list_mk_pabs.doc @@ -12,7 +12,7 @@ Iteratively constructs paired abstractions. {list_mk_pabs([p1,...,pn], t)} returns {\p1 ... pn. t}. \FAILURE -Fails with {list_mk_pabs} if the terms in the list are not paired +Fails with {list_mk_pabs} if the terms in the list are not paired structures of variables. \SEEALSO diff --git a/help/Docfiles/pairSyntax.mk_anylet.doc b/help/Docfiles/pairSyntax.mk_anylet.doc index 96496b3ab6..242e8436e2 100644 --- a/help/Docfiles/pairSyntax.mk_anylet.doc +++ b/help/Docfiles/pairSyntax.mk_anylet.doc @@ -6,14 +6,14 @@ Constructs arbitrary {let} terms. \DESCRIBE -The invocation {mk_anylet ([(a1,b1),...,(an,bn)],N)} returns a term of the +The invocation {mk_anylet ([(a1,b1),...,(an,bn)],N)} returns a term of the form {`LET P Q`}, which will prettyprint as {let a1 = b1 and ... and an = bn in N}. -The internal representation is equal to +The internal representation is equal to { LET (...(LET (\an ...\a1. N) bn) ...) b1 } -Each {ai} can be a varstruct (a single variable or a tuple of variables), -or a function variable applied to a sequence of varstructs. In the usual case, +Each {ai} can be a varstruct (a single variable or a tuple of variables), +or a function variable applied to a sequence of varstructs. In the usual case, only a single binding is made, i.e., {mk_anylet ([(a,b)],N)}, and the result is equal to {LET (\a. N) b}. @@ -22,10 +22,10 @@ Fails if the type of any {ai} is not equal to the type of the corresponding {bi} \EXAMPLE { -- strip_comb (mk_anylet ([(Term`x`, Term`M`)], Term`N x`)); +- strip_comb (mk_anylet ([(Term`x`, Term`M`)], Term`N x`)); > val it = (`LET`, [`\x. N x`, `M`]) : term * term list -- mk_anylet ([(``f (x:'a,y:'b):'c``, ``M:'c``), (``g (z:'c) :'d``, ``N:'d``)], +- mk_anylet ([(``f (x:'a,y:'b):'c``, ``M:'c``), (``g (z:'c) :'d``, ``N:'d``)], ``g (f (a:'a,b:'b):'c):'d`); > val it = ``let f (x,y) = M and g z = N in g (f (a,b))`` : term } @@ -34,7 +34,7 @@ Fails if the type of any {ai} is not equal to the type of the corresponding {bi} Programming that involves manipulation of term syntax. \SEEALSO -boolSyntax.mk_let, boolSyntax.dest_let, boolSyntax.is_let, +boolSyntax.mk_let, boolSyntax.dest_let, boolSyntax.is_let, pairSyntax.list_mk_anylet, pairSyntax.dest_anylet. \ENDDOC diff --git a/help/Docfiles/pairSyntax.mk_pabs.doc b/help/Docfiles/pairSyntax.mk_pabs.doc index a10a75f87e..878a8bbd9c 100644 --- a/help/Docfiles/pairSyntax.mk_pabs.doc +++ b/help/Docfiles/pairSyntax.mk_pabs.doc @@ -10,7 +10,7 @@ If {M} is the tuple {(v1,..(..)..,vn)}, and {N} is an arbitrary term, then {mk_pabs (M,N)} returns the paired abstraction {`\(v1,..(..)..,vn).N`}. \FAILURE -Fails unless {M} is an arbitrarily nested pair composed from variables, +Fails unless {M} is an arbitrarily nested pair composed from variables, with no repetitions of variables. \SEEALSO diff --git a/help/Docfiles/pairSyntax.pvariant.doc b/help/Docfiles/pairSyntax.pvariant.doc index d7ecb4fa8f..10c00b58ca 100644 --- a/help/Docfiles/pairSyntax.pvariant.doc +++ b/help/Docfiles/pairSyntax.pvariant.doc @@ -29,7 +29,7 @@ variables, or if {p} is not a paired structure of variables and constants. \EXAMPLE The following shows a case that exhibits most possible behaviours: { - - pvariant [Term `b:'a`, Term `(c:'a,c':'a)`] + - pvariant [Term `b:'a`, Term `(c:'a,c':'a)`] (Term `((a:'a,b:'a),(c:'a,b':'a,T,b:'a))`); val it = `(a,b''),c'',b',T',b''` : term } diff --git a/help/Docfiles/pairSyntax.strip_anylet.doc b/help/Docfiles/pairSyntax.strip_anylet.doc index 3dcb9aae8a..cf225c1bab 100644 --- a/help/Docfiles/pairSyntax.strip_anylet.doc +++ b/help/Docfiles/pairSyntax.strip_anylet.doc @@ -8,26 +8,26 @@ Repeatedly destructs arbitrary {let} terms. \DESCRIBE The invocation {strip_anylet M} where {M} has the form of a let-abstraction, i.e., {LET P Q}, returns a pair {([[(a1,b1),...,(an,bn)], ... [(u1,v1),...,(uk,vk)]],body)}, -where the first element of the pair is a list of lists of bindings, -and the second is the body of the let. The binding lists are required since let -terms can, in general, be of the form (using surface syntax) +where the first element of the pair is a list of lists of bindings, +and the second is the body of the let. The binding lists are required since let +terms can, in general, be of the form (using surface syntax) {let a1 = b1 and ... and an = bn in body}. \FAILURE -Never fails. +Never fails. \EXAMPLE { - strip_anylet ``let g x = A in let v = g x y in - let f x y (a,b) = g a - and foo = M + let f x y (a,b) = g a + and foo = M in f x foo v``; > val it = - ([[(`g x`, `A`)], + ([[(`g x`, `A`)], [(`v`, `g x y`)], - [(`f x y (a,b)`, `g a`), (`foo`, `M`)]], `f x foo v`) + [(`f x y (a,b)`, `g a`), (`foo`, `M`)]], `f x foo v`) } \USES diff --git a/help/Docfiles/pred_setLib.DELETE_CONV.doc b/help/Docfiles/pred_setLib.DELETE_CONV.doc index b2f256a607..2e8ffff244 100644 --- a/help/Docfiles/pred_setLib.DELETE_CONV.doc +++ b/help/Docfiles/pred_setLib.DELETE_CONV.doc @@ -7,18 +7,18 @@ Reduce {{t1;...;tn} DELETE t} by deleting {t} from {{t1;...;tn}}. \LIBRARY pred_set -\DESCRIBE +\DESCRIBE The function {DELETE_CONV} is a parameterized conversion for reducing finite sets of the form {{t1;...;tn} DELETE t}, where the term {t} and the elements of {{t1;...;tn}} are of some base type {ty}. The first argument to {DELETE_CONV} is expected to be a conversion that decides equality between values of the base type {ty}. Given an equation {e1 = e2}, where {e1} and -{e2} are terms of type {ty}, this conversion should return the theorem +{e2} are terms of type {ty}, this conversion should return the theorem {|- (e1 = e2) = T} or the theorem {|- (e1 = e2) = F}, as appropriate. Given such a conversion {conv}, the function {DELETE_CONV} returns a conversion that maps a term of the form {{t1;...;tn} DELETE t} to the -theorem +theorem { |- {t1;...;tn} DELETE t = {ti;...;tj} } @@ -42,11 +42,11 @@ elements of the set. > val it = |- {2; 1; SUC 1; 3} DELETE 2 = {1; 3} : thm } ` -\FAILURE -{DELETE_CONV conv} fails if applied to a term not of the form +\FAILURE +{DELETE_CONV conv} fails if applied to a term not of the form {{t1;...;tn} DELETE t}. A call {DELETE_CONV conv ``{t1;...;tn} DELETE t``} -fails unless for each element {ti} of the set {{t1;...;tn}}, the -term {t} is either alpha-equivalent to {ti} or {conv ``ti = t``} returns +fails unless for each element {ti} of the set {{t1;...;tn}}, the +term {t} is either alpha-equivalent to {ti} or {conv ``ti = t``} returns {|- (ti = t) = T} or {|- (ti = t) = F}. \SEEALSO diff --git a/help/Docfiles/pred_setLib.FINITE_CONV.doc b/help/Docfiles/pred_setLib.FINITE_CONV.doc index 123fc33729..b473feab0f 100644 --- a/help/Docfiles/pred_setLib.FINITE_CONV.doc +++ b/help/Docfiles/pred_setLib.FINITE_CONV.doc @@ -7,7 +7,7 @@ Proves finiteness of sets of the form {{t1;...;tn}}. \LIBRARY pred_set -\DESCRIBE +\DESCRIBE The conversion {FINITE_CONV} expects its term argument to be an assertion of the form {FINITE {t1;...;tn}}. Given such a term, the conversion returns the theorem diff --git a/help/Docfiles/pred_setLib.IMAGE_CONV.doc b/help/Docfiles/pred_setLib.IMAGE_CONV.doc index ff4fd1dc45..8216c807c3 100644 --- a/help/Docfiles/pred_setLib.IMAGE_CONV.doc +++ b/help/Docfiles/pred_setLib.IMAGE_CONV.doc @@ -7,7 +7,7 @@ Compute the image of a function on a finite set. \LIBRARY pred_set -\DESCRIBE +\DESCRIBE The function {IMAGE_CONV} is a parameterized conversion for computing the image of a function {f:ty1->ty2} on a finite set {{t1;...;tn}} of type {ty1->bool}. The first argument to {IMAGE_CONV} is expected to be a conversion @@ -55,7 +55,7 @@ The result contains only one occurrence of {f 1}, even though removing elements that are redundant up to alpha-equivalence. For the next example, we construct a conversion that maps {SUC n} for any -numeral {n} to the numeral standing for the successor of {n}. +numeral {n} to the numeral standing for the successor of {n}. { - fun SUC_CONV tm = let open numLib Arbnum @@ -81,18 +81,18 @@ of the successor function on a finite set: - IMAGE_CONV SUC_CONV NO_CONV ``IMAGE SUC {1; 2; 1; 4}``; > val it = |- IMAGE SUC {1; 2; 1; 4} = {3; 2; 5} : thm } -Note that {2} (= {SUC 1}) appears only once in the resulting set. +Note that {2} (= {SUC 1}) appears only once in the resulting set. Finally, here is an example of using {IMAGE_CONV} to compute the image of a paired addition function on a set of pairs of numbers: { - - IMAGE_CONV (pairLib.PAIRED_BETA_CONV THENC reduceLib.ADD_CONV) + - IMAGE_CONV (pairLib.PAIRED_BETA_CONV THENC reduceLib.ADD_CONV) numLib.REDUCE_CONV ``IMAGE (\(n,m).n+m) {{(1,2), (3,4), (0,3), (1,3)}}``; > val it = |- IMAGE (\(n,m). n + m) {(1,2); (3,4); (0,3); (1,3)} = {7; 3; 4} } -\FAILURE +\FAILURE {IMAGE_CONV conv1 conv2} fails if applied to a term not of the form {IMAGE f {t1;...;tn}}. An application of {IMAGE_CONV conv1 conv2} to a term {IMAGE f {t1;...;tn}} fails unless for all {ti} in the set diff --git a/help/Docfiles/pred_setLib.INSERT_CONV.doc b/help/Docfiles/pred_setLib.INSERT_CONV.doc index fb4cefcb89..76b14af5d8 100644 --- a/help/Docfiles/pred_setLib.INSERT_CONV.doc +++ b/help/Docfiles/pred_setLib.INSERT_CONV.doc @@ -7,7 +7,7 @@ Reduce {t INSERT {t1;...;t;...;tn}} to {{t1;...;t;...;tn}}. \LIBRARY pred_set -\DESCRIBE +\DESCRIBE The function {INSERT_CONV} is a parameterized conversion for reducing finite sets of the form {t INSERT {t1;...;tn}}, where {{t1;...;tn}} is a set of type {ty->bool} and {t} is equal to some element {ti} of this set. The first @@ -40,7 +40,7 @@ A call to {INSERT_CONV} fails when the value being inserted is provably not equal to any of the remaining elements: { - INSERT_CONV REDUCE_CONV ``1 INSERT {2;3}``; - ! Uncaught exception: + ! Uncaught exception: ! HOL_ERR } But this failure can, if desired, be caught using {TRY_CONV}. @@ -52,14 +52,14 @@ is alpha-equivalent to one of the remaining elements: > val it = |- {y; x; y; z} = {x; y; z} : thm } The conversion {NO_CONV} always fails, but {INSERT_CONV} is -nontheless able in this case to prove the required result. +nontheless able in this case to prove the required result. Note that {DEPTH_CONV(INSERT_CONV conv)} can be used to remove duplicate elements from a finite set, but the following conversion is faster: { - fun SETIFY_CONV conv tm = - (SUB_CONV (SETIFY_CONV conv) - THENC + (SUB_CONV (SETIFY_CONV conv) + THENC TRY_CONV (INSERT_CONV conv)) tm; > val SETIFY_CONV = fn : conv -> conv @@ -67,7 +67,7 @@ elements from a finite set, but the following conversion is faster: > val it = |- {1; 2; 1; 3; 2; 4; 3; 5; 6} = {1; 2; 4; 3; 5; 6} : thm } -\FAILURE +\FAILURE {INSERT_CONV conv} fails if applied to a term not of the form {t INSERT {t1;...;tn}}. A call {INSERT_CONV conv ``t INSERT {t1;...;tn}} fails unless {t} is alpha-equivalent to some {ti}, or {conv ``t = ti``} returns diff --git a/help/Docfiles/pred_setLib.IN_CONV.doc b/help/Docfiles/pred_setLib.IN_CONV.doc index 71672debaf..78248ad928 100644 --- a/help/Docfiles/pred_setLib.IN_CONV.doc +++ b/help/Docfiles/pred_setLib.IN_CONV.doc @@ -7,7 +7,7 @@ Decision procedure for membership in finite sets. \LIBRARY pred_set -\DESCRIBE +\DESCRIBE The function {IN_CONV} is a parameterized conversion for proving or disproving membership assertions of the general form: { @@ -30,8 +30,8 @@ if {t} is alpha-equivalent to any {ti}, or if the supplied conversion proves {|- (t = ti) = T} for any {ti}. If the supplied conversion proves {|- (t = ti) = F} for every {ti}, then the result is the theorem { - |- t IN {t1;...;tn} = F -} + |- t IN {t1;...;tn} = F +} In all other cases, {IN_CONV} will fail. \EXAMPLE @@ -58,9 +58,9 @@ The conversion {NO_CONV} always fails, but {IN_CONV} is nontheless able in this case to prove the required result. \FAILURE -{IN_CONV conv} fails if applied to a term that is not of the form -{t IN {t1;...;tn}}. A call {IN_CONV conv t IN {t1;...;tn}} fails -unless the term {t} is alpha-equivalent to some {ti}, or {conv ``t = ti``} +{IN_CONV conv} fails if applied to a term that is not of the form +{t IN {t1;...;tn}}. A call {IN_CONV conv t IN {t1;...;tn}} fails +unless the term {t} is alpha-equivalent to some {ti}, or {conv ``t = ti``} returns {|- (t = ti) = T} for some {ti}, or {conv ``t = ti``} returns {|- (t = ti) = F} for every {ti}. diff --git a/help/Docfiles/pred_setLib.SET_SPEC_CONV.doc b/help/Docfiles/pred_setLib.SET_SPEC_CONV.doc index bfd199b416..017fd8eeb7 100644 --- a/help/Docfiles/pred_setLib.SET_SPEC_CONV.doc +++ b/help/Docfiles/pred_setLib.SET_SPEC_CONV.doc @@ -7,7 +7,7 @@ Axiom-scheme of specification for set abstractions. \LIBRARY pred_set -\DESCRIBE +\DESCRIBE The conversion {SET_SPEC_CONV} expects its term argument to be an assertion of the form {t IN {E | P}}. Given such a term, the conversion returns a theorem that defines the condition under which this membership assertion holds. diff --git a/help/Docfiles/pred_setLib.UNION_CONV.doc b/help/Docfiles/pred_setLib.UNION_CONV.doc index f5d8208a9b..f09e105c88 100644 --- a/help/Docfiles/pred_setLib.UNION_CONV.doc +++ b/help/Docfiles/pred_setLib.UNION_CONV.doc @@ -7,7 +7,7 @@ Reduce {{t1;...;tn} UNION s} to {t1 INSERT (... (tn INSERT s))}. \LIBRARY pred_set -\DESCRIBE +\DESCRIBE The function {UNION_CONV} is a parameterized conversion for reducing sets of the form {{t1;...;tn} UNION s}, where {{t1;...;tn}} and {s} are sets of type {ty->bool}. The first argument to {UNION_CONV} is expected to be a @@ -35,7 +35,7 @@ finite set {{1;2;3}} of the union in the second finite set {{SUC 0;3;4}}. > val it = |- {1; 2; 3} UNION {SUC 0; 3; 4} = {2; SUC 0; 3; 4} : thm } The result is {{2;SUC 0;3;4}}, rather than {{1;2;SUC 0;3;4}}, -because {UNION_CONV} is able by means of a call to +because {UNION_CONV} is able by means of a call to { - IN_CONV REDUCE_CONV (Term`1 IN {SUC 0;3;4}`); } @@ -56,7 +56,7 @@ the second set argument to {UNION} need not be a finite set: And, of course, in this case the conversion argument to {UNION_CONV} is irrelevant. -\FAILURE +\FAILURE {UNION_CONV conv} fails if applied to a term not of the form {{t1;...;tn} UNION s}. diff --git a/help/Docfiles/proofManagerLib.backup.doc b/help/Docfiles/proofManagerLib.backup.doc index fac8533b9b..9e3802253c 100644 --- a/help/Docfiles/proofManagerLib.backup.doc +++ b/help/Docfiles/proofManagerLib.backup.doc @@ -30,7 +30,7 @@ The function {backup} will fail if the backup list is empty. 1. Incomplete: Initial goal: (HD [1; 2; 3] = 1) /\ (TL [1; 2; 3] = [2; 3]) - + : proofs - e CONJ_TAC; @@ -38,18 +38,18 @@ OK.. 2 subgoals: > val it = TL [1; 2; 3] = [2; 3] - - + + HD [1; 2; 3] = 1 - + : proof - backup(); > val it = Initial goal: - + (HD [1; 2; 3] = 1) /\ (TL [1; 2; 3] = [2; 3]) - + : proof - e (REWRITE_TAC[listTheory.HD, listTheory.TL]); diff --git a/help/Docfiles/proofManagerLib.eall.doc b/help/Docfiles/proofManagerLib.eall.doc index 59684655ad..557eae21da 100644 --- a/help/Docfiles/proofManagerLib.eall.doc +++ b/help/Docfiles/proofManagerLib.eall.doc @@ -3,7 +3,7 @@ \TYPE {eall : tactic -> proof} \SYNOPSIS -Applies a tactic to all goals in the current goal list, +Applies a tactic to all goals in the current goal list, replacing the list with the resulting subgoals. \DESCRIBE diff --git a/help/Docfiles/proofManagerLib.elt.doc b/help/Docfiles/proofManagerLib.elt.doc index d015d54264..fa5d8ae7d7 100644 --- a/help/Docfiles/proofManagerLib.elt.doc +++ b/help/Docfiles/proofManagerLib.elt.doc @@ -3,7 +3,7 @@ \TYPE {elt : list_tactic -> proof} \SYNOPSIS -Applies a list-tactic to the current goal list, +Applies a list-tactic to the current goal list, replacing it with the resulting subgoals. \DESCRIBE diff --git a/help/Docfiles/proofManagerLib.enth.doc b/help/Docfiles/proofManagerLib.enth.doc index 89c00c1201..08578f3296 100644 --- a/help/Docfiles/proofManagerLib.enth.doc +++ b/help/Docfiles/proofManagerLib.enth.doc @@ -3,7 +3,7 @@ \TYPE {enth : tactic -> int -> proof} \SYNOPSIS -Applies a tactic to one goal, referenced by number, in the current goal list, +Applies a tactic to one goal, referenced by number, in the current goal list, replacing that goal with the resulting subgoals. \DESCRIBE diff --git a/help/Docfiles/proofManagerLib.eta.doc b/help/Docfiles/proofManagerLib.eta.doc index b64a4424b7..89deba4601 100644 --- a/help/Docfiles/proofManagerLib.eta.doc +++ b/help/Docfiles/proofManagerLib.eta.doc @@ -3,7 +3,7 @@ \TYPE {eta : tactic -> proof} \SYNOPSIS -Applies a tactic to all goals, on which it succeeds, in the current goal list, +Applies a tactic to all goals, on which it succeeds, in the current goal list, replacing the list with the resulting subgoals. \DESCRIBE diff --git a/help/Docfiles/proofManagerLib.expand.doc b/help/Docfiles/proofManagerLib.expand.doc index e97b42017e..b66a667785 100644 --- a/help/Docfiles/proofManagerLib.expand.doc +++ b/help/Docfiles/proofManagerLib.expand.doc @@ -44,7 +44,7 @@ the tactic is invalid. - expand CONJ_TAC; - expand CONJ_TAC; OK.. -NO_PROOFS! Uncaught exception: +NO_PROOFS! Uncaught exception: ! NO_PROOFS - g `(HD[1;2;3] = 1) /\ (TL[1;2;3] = [2;3])`; @@ -53,7 +53,7 @@ NO_PROOFS! Uncaught exception: 1. Incomplete: Initial goal: (HD [1; 2; 3] = 1) /\ (TL [1; 2; 3] = [2; 3]) - + : proofs - expand CONJ_TAC; @@ -61,10 +61,10 @@ OK.. 2 subgoals: > val it = TL [1; 2; 3] = [2; 3] - - + + HD [1; 2; 3] = 1 - + : proof - expand (REWRITE_TAC[listTheory.HD]); @@ -76,7 +76,7 @@ Goal proved. Remaining subgoals: > val it = TL [1; 2; 3] = [2; 3] - + : proof - expand (REWRITE_TAC[listTheory.TL]); @@ -100,26 +100,26 @@ justification would not prove the goal that was set. 1. Incomplete: Initial goal: 1 = 2 - + : proofs - expand (REWRITE_TAC[ASSUME (Term `1=2`)]); OK.. Exception raised at Tactical.VALID: Invalid tactic -! Uncaught exception: +! Uncaught exception: ! HOL_ERR } Note that an invalid tactic may "succeed". Thus, where {tac1} is invalid, and {tac2} is valid (and both succeed), {FIRST [tac1, tac2]} is invalid. For example, where -theorem {uth} is {[p] |- q} and {uth'} is {[p'] |- q} +theorem {uth} is {[p] |- q} and {uth'} is {[p'] |- q} { 1 subgoal: val it = - + q ------------------------------------ p @@ -137,7 +137,7 @@ OK.. Goal proved. [p] |- q -} +} \USES Doing a step in an interactive goal-directed proof. diff --git a/help/Docfiles/proofManagerLib.expand_list.doc b/help/Docfiles/proofManagerLib.expand_list.doc index 7db56b52b3..edfc1a3272 100644 --- a/help/Docfiles/proofManagerLib.expand_list.doc +++ b/help/Docfiles/proofManagerLib.expand_list.doc @@ -15,7 +15,7 @@ The previous state is stored on the backup list. If the list-tactic produces subgoals, the new proof state is formed from the old one by removing the current goal list from the goal stack and replacing it by the list of subgoals produced by the list-tactic. -The corresponding justification is modified accordingly, +The corresponding justification is modified accordingly, appropriate to the new goal list. The new subgoals are printed. If more than one subgoal is produced, they are printed from the bottom of the stack so that the new current goal is printed @@ -23,7 +23,7 @@ last. If a list-tactic solves the current goal list (returns an empty subgoal list), then its justification is used to prove a corresponding theorem. This theorem -is incorporated into the justification of the parent goal and printed. +is incorporated into the justification of the parent goal and printed. That level of goals is removed and the parent goal is proved using its (new) justification. This process is repeated until a level with unproven subgoals is reached. The next goal on the goal stack then @@ -57,7 +57,7 @@ NO_PROOFSException- NO_PROOFS raised 1. Incomplete: Initial goal: (HD [1; 2; 3] = 1) /\ (TL [1; 2; 3] = [2; 3]) - + : proofs > expand CONJ_TAC; @@ -65,10 +65,10 @@ OK.. 2 subgoals: > val it = TL [1; 2; 3] = [2; 3] - - + + HD [1; 2; 3] = 1 - + : proof > expand_list (ALLGOALS (REWRITE_TAC[listTheory.HD,listTheory.TL])) ; @@ -82,7 +82,7 @@ val it = \USES Doing a step in an interactive goal-directed proof, -in particular, a step which affects all the subgoals generated by the +in particular, a step which affects all the subgoals generated by the preceding step. \SEEALSO diff --git a/help/Docfiles/proofManagerLib.expand_listf.doc b/help/Docfiles/proofManagerLib.expand_listf.doc index 7be69d379e..1cedaed7bc 100644 --- a/help/Docfiles/proofManagerLib.expand_listf.doc +++ b/help/Docfiles/proofManagerLib.expand_listf.doc @@ -32,7 +32,7 @@ Saving CPU time when doing goal-directed proofs, since the extra validation is not done. Redoing proofs quickly that are already known to work. \COMMENTS -The CPU time saved may cause misery later. +The CPU time saved may cause misery later. If an invalid tactic or list-tactic is used, this will only be discovered when the proof has apparently been finished and the justifications are applied. diff --git a/help/Docfiles/proofManagerLib.flatn.doc b/help/Docfiles/proofManagerLib.flatn.doc index 3df347ab4f..f8bd5256f4 100644 --- a/help/Docfiles/proofManagerLib.flatn.doc +++ b/help/Docfiles/proofManagerLib.flatn.doc @@ -6,10 +6,10 @@ Flattens the tree structure of subgoals on the subgoal package goal stack. \DESCRIBE -The function {flatn} is part of the subgoal package. +The function {flatn} is part of the subgoal package. For a general description of the subgoal package, see {set_goal}. -The {flatn} function's basic step of operation is to take the +The {flatn} function's basic step of operation is to take the the current list of sub-goals and concatenate it with the previous list of subgoals (excluding the first of that list, from which the current list was obtained). @@ -18,13 +18,13 @@ times this operation is to be performed. \FAILURE Raises the {NO_PROOFS} exception if there is no current proof -manipulated by the subgoal package. +manipulated by the subgoal package. If {n} is too large, or negative, the result will be a flat list of all subgoals. \USES -To view, reorder, or attack simultaneously, +To view, reorder, or attack simultaneously, current and previously obtained subgoals. \SEEALSO diff --git a/help/Docfiles/proofManagerLib.set_backup.doc b/help/Docfiles/proofManagerLib.set_backup.doc index b816e58d79..36db511c72 100644 --- a/help/Docfiles/proofManagerLib.set_backup.doc +++ b/help/Docfiles/proofManagerLib.set_backup.doc @@ -23,7 +23,7 @@ For a description of the subgoal package, see {set_goal}. 1. Incomplete: Initial goal: (HD [1; 2; 3] = 1) /\ (TL [1; 2; 3] = [2; 3]) - + : proofs - e CONJ_TAC; @@ -31,10 +31,10 @@ OK.. 2 subgoals: > val it = TL [1; 2; 3] = [2; 3] - - + + HD [1; 2; 3] = 1 - + :proof - e (REWRITE_TAC[listTheory.HD]); @@ -46,20 +46,20 @@ Goal proved. Remaining subgoals: > val it = TL [1; 2; 3] = [2; 3] - + : proof - b(); > val it = TL [1; 2; 3] = [2; 3] - - + + HD [1; 2; 3] = 1 - + : proof - b(); -! Uncaught exception: +! Uncaught exception: ! CANT_BACKUP_ANYMORE } diff --git a/help/Docfiles/proofManagerLib.set_goal.doc b/help/Docfiles/proofManagerLib.set_goal.doc index da552bb0fb..870bd045db 100644 --- a/help/Docfiles/proofManagerLib.set_goal.doc +++ b/help/Docfiles/proofManagerLib.set_goal.doc @@ -70,7 +70,7 @@ saved. proofManagerLib.set_goal, proofManagerLib.restart, proofManagerLib.backup,proofManagerLib.restore, proofManagerLib.save, proofManagerLib.set_backup,proofManagerLib.expand, proofManagerLib.expandf, -proofManagerLib.expand_list, proofManagerLib.flatn, +proofManagerLib.expand_list, proofManagerLib.flatn, proofManagerLib.p,proofManagerLib.top_thm, proofManagerLib.top_goal. \ENDDOC diff --git a/help/Docfiles/quantHeuristicsLib.ASM_QUANT_INSTANTIATE_TAC.doc b/help/Docfiles/quantHeuristicsLib.ASM_QUANT_INSTANTIATE_TAC.doc index fa290a3b9a..3d653a26dc 100644 --- a/help/Docfiles/quantHeuristicsLib.ASM_QUANT_INSTANTIATE_TAC.doc +++ b/help/Docfiles/quantHeuristicsLib.ASM_QUANT_INSTANTIATE_TAC.doc @@ -10,7 +10,7 @@ quantifier heuristic parameters. This tactic is based on {quantHeuristicsLib.QUANT_INSTANTIATE_CONV}. It tries to instantiate quantifiers. Free variables of the goal are seen as universally quantified by this tactic. Therefore, it tries to -instantiate these free variables. +instantiate these free variables. In contrast to {quantHeuristicsLib.QUANT_INSTANTIATE_TAC} this tactic takes the assumptions of the goal into account. diff --git a/help/Docfiles/quantHeuristicsLib.QUANT_INSTANTIATE_CONV.doc b/help/Docfiles/quantHeuristicsLib.QUANT_INSTANTIATE_CONV.doc index 3f26440db4..20a8f4e7c1 100644 --- a/help/Docfiles/quantHeuristicsLib.QUANT_INSTANTIATE_CONV.doc +++ b/help/Docfiles/quantHeuristicsLib.QUANT_INSTANTIATE_CONV.doc @@ -7,11 +7,11 @@ Intantiate quantifiers in a term using a given list of quantifier heuristic parameters. \DESCRIBE -This conversion tries to instantiate quantifiers. Therefore, +This conversion tries to instantiate quantifiers. Therefore, it uses the given list of quantifier heuristic parameters. If the list is empty, it knows about the usual Boolean Connectives, quantifiers and equations. The parameter {quantHeuristicsArgsLib.std_qp} adds knowledge -about option-types, pairs, lists, records and natural numbers. +about option-types, pairs, lists, records and natural numbers. The stateful parameter {quantHeuristicsArgsLib.Type_Base_qp} can be used to extract information about user defined datatypes. @@ -28,11 +28,11 @@ used to extract information about user defined datatypes. |- (?x. (f(8 + 2) = f(x + 2)) /\ P(f (x + 2))) = P(f (8 + 2)) #QUANT_INSTANTIATE_CONV [std_qp] "!x. IS_SOME x ==> P x";; -|- (!x. IS_SOME x ==> P x) = +|- (!x. IS_SOME x ==> P x) = (!x_x'. P (SOME x_x')) #QUANT_INSTANTIATE_CONV [std_qp] "!l. (~(l = []) ==> (LENGTH l > 0))";; -|- (!l. (~(l = []) ==> (LENGTH l > 0))) = +|- (!l. (~(l = []) ==> (LENGTH l > 0))) = (!l_t l_h. LENGTH (l_h::l_t) > 0) } @@ -40,7 +40,7 @@ used to extract information about user defined datatypes. quantHeuristicsLib.QUANT_INST_ss, quantHeuristicsLib.QUANT_INSTANTIATE_TAC, quantHeuristicsLib.ASM_QUANT_INSTANTIATE_TAC, -quantHeuristicsLib.FAST_QUANT_INSTANTIATE_CONV, +quantHeuristicsLib.FAST_QUANT_INSTANTIATE_CONV, quantHeuristicsLib.FAST_QUANT_INST_ss, quantHeuristicsLib.FAST_QUANT_INSTANTIATE_TAC. \ENDDOC diff --git a/help/Docfiles/quantHeuristicsLib.QUANT_TAC.doc b/help/Docfiles/quantHeuristicsLib.QUANT_TAC.doc index c57cdbe08f..4072fc155c 100644 --- a/help/Docfiles/quantHeuristicsLib.QUANT_TAC.doc +++ b/help/Docfiles/quantHeuristicsLib.QUANT_TAC.doc @@ -9,16 +9,16 @@ A tactic to intantiate quantifiers in a term using an explitly given list of (pa tactic, quantifier, existential, choose, witness. \DESCRIBE -This tactic can be seen as a generalisation of {Q.EXISTS_TAC}. +This tactic can be seen as a generalisation of {Q.EXISTS_TAC}. When applied to a term fragment {u} and a goal {?x. t}, the tactic {EXISTS_TAC} reduces the goal to {t[u/x]}. {QUANT_TAC} allows to -perform similar instantiations of quantifiers at subpositions, provided +perform similar instantiations of quantifiers at subpositions, provided the subposition occurs in a formula composed of standard operators that the tactic can handle. It can - depending on negation level - instantiate both existential and universal quantifiers. Moreover, it allows partial instantiations and instantiating multiple variables at the same time. -{QUANT_TAC} gets a list of triples {(var_name, instantiation, free_vars)} +{QUANT_TAC} gets a list of triples {(var_name, instantiation, free_vars)} as an argument. {var_name} is the name of the variable to be instantiated; {instantiation} is the term this variable should be instantiated with. Finally, {free_vars} is a list of free variables in {instantiation} that should remain @@ -28,7 +28,7 @@ As this tactic adresses variables by their name, resulting proofs might not be robust. Therefore, this tactic should be used carefully. \EXAMPLE -Given the goal +Given the goal { !x. (!z. P x z) ==> ?a b. Q a b z } @@ -38,11 +38,11 @@ The variable {z} is universally quantified, but in the antecedent of the implica Therefore, it can be safely instantiated. {a} is existentially quantified. In this example we just want to say that {a} is not {0}, therefore {a'} is considered as a free variable and thus remains existentially quantified. -The call results in the goal +The call results in the goal { !x. ( P x 0) ==> ? b a'. Q (SUC a') b z } - + \SEEALSO Tactic.EXISTS_TAC. \ENDDOC diff --git a/help/Docfiles/res_quanLib.IMP_RES_FORALL_CONV.doc b/help/Docfiles/res_quanLib.IMP_RES_FORALL_CONV.doc index 06d05de059..03afef404c 100644 --- a/help/Docfiles/res_quanLib.IMP_RES_FORALL_CONV.doc +++ b/help/Docfiles/res_quanLib.IMP_RES_FORALL_CONV.doc @@ -12,7 +12,7 @@ conversion, restricted quantifier, universal, implication. When applied to a term of the form {!x. x IN P ==> Q}, the conversion {IMP_RES_FORALL_CONV} returns the theorem: { - |- (!x. x IN P ==> Q) = !x::P. Q + |- (!x. x IN P ==> Q) = !x::P. Q } \FAILURE diff --git a/help/Docfiles/res_quanLib.RESQ_REWRITE1_TAC.doc b/help/Docfiles/res_quanLib.RESQ_REWRITE1_TAC.doc index c089479421..706a9f119c 100644 --- a/help/Docfiles/res_quanLib.RESQ_REWRITE1_TAC.doc +++ b/help/Docfiles/res_quanLib.RESQ_REWRITE1_TAC.doc @@ -28,7 +28,7 @@ form {asml'}, and they also become new subgoals {(asml,P x')}. \FAILURE {RESQ_REWRITE1_TAC th} fails if {th} cannot be transformed into the -required form by the function {RESQ_REWR_CANON}. Otherwise, it fails if no +required form by the function {RESQ_REWR_CANON}. Otherwise, it fails if no match is found or the theorem cannot be instantiated. diff --git a/help/Docfiles/res_quanLib.dest_res_exists.doc b/help/Docfiles/res_quanLib.dest_res_exists.doc index 5e9d39c19d..5097abc70b 100644 --- a/help/Docfiles/res_quanLib.dest_res_exists.doc +++ b/help/Docfiles/res_quanLib.dest_res_exists.doc @@ -8,7 +8,7 @@ the quantified variable, predicate and body. \DESCRIBE {dest_res_exists} is a term destructor for restricted existential -quantification: +quantification: { dest_res_exists "?var::P. t" } diff --git a/help/Docfiles/res_quanLib.dest_res_exists_unique.doc b/help/Docfiles/res_quanLib.dest_res_exists_unique.doc index d93a92a3e5..ddee252b6b 100644 --- a/help/Docfiles/res_quanLib.dest_res_exists_unique.doc +++ b/help/Docfiles/res_quanLib.dest_res_exists_unique.doc @@ -8,7 +8,7 @@ the quantified variable, predicate and body. \DESCRIBE {dest_res_exists_unique} is a term destructor for restricted existential -quantification: +quantification: { dest_res_exists_unique "?var::P. t" } diff --git a/help/Docfiles/res_quanLib.dest_res_forall.doc b/help/Docfiles/res_quanLib.dest_res_forall.doc index 7a6870d780..158f6aa445 100644 --- a/help/Docfiles/res_quanLib.dest_res_forall.doc +++ b/help/Docfiles/res_quanLib.dest_res_forall.doc @@ -8,7 +8,7 @@ the quantified variable, predicate and body. \DESCRIBE {dest_res_forall} is a term destructor for restricted universal -quantification: +quantification: { dest_res_forall "!var::P. t" } diff --git a/help/Docfiles/res_quanLib.dest_res_select.doc b/help/Docfiles/res_quanLib.dest_res_select.doc index 8229be962d..b97b5f06e7 100644 --- a/help/Docfiles/res_quanLib.dest_res_select.doc +++ b/help/Docfiles/res_quanLib.dest_res_select.doc @@ -8,7 +8,7 @@ the quantified variable, predicate and body. \DESCRIBE {dest_res_select} is a term destructor for restricted choice -quantification: +quantification: { dest_res_select "@var::P. t" } diff --git a/help/Docfiles/res_quanLib.is_res_exists.doc b/help/Docfiles/res_quanLib.is_res_exists.doc index aefc60b61d..e030059c59 100644 --- a/help/Docfiles/res_quanLib.is_res_exists.doc +++ b/help/Docfiles/res_quanLib.is_res_exists.doc @@ -6,7 +6,7 @@ Tests a term to see if it is a restricted existential quantification. \DESCRIBE -{is_res_exists "?var::P. t"} returns {true}. If the term is not a +{is_res_exists "?var::P. t"} returns {true}. If the term is not a restricted existential quantification the result is {false}. \FAILURE diff --git a/help/Docfiles/res_quanLib.is_res_exists_unique.doc b/help/Docfiles/res_quanLib.is_res_exists_unique.doc index f711b3990d..cc6133097f 100644 --- a/help/Docfiles/res_quanLib.is_res_exists_unique.doc +++ b/help/Docfiles/res_quanLib.is_res_exists_unique.doc @@ -6,7 +6,7 @@ Tests a term to see if it is a restricted unique existential quantification. \DESCRIBE -{is_res_exists_unique "?!var::P. t"} returns {true}. If the term is not a +{is_res_exists_unique "?!var::P. t"} returns {true}. If the term is not a restricted unique existential quantification the result is {false}. \FAILURE diff --git a/help/Docfiles/res_quanLib.is_res_forall.doc b/help/Docfiles/res_quanLib.is_res_forall.doc index 0677fa0fb9..0217544399 100644 --- a/help/Docfiles/res_quanLib.is_res_forall.doc +++ b/help/Docfiles/res_quanLib.is_res_forall.doc @@ -6,7 +6,7 @@ Tests a term to see if it is a restricted universal quantification. \DESCRIBE -{is_res_forall "!var::P. t"} returns {true}. If the term is not a +{is_res_forall "!var::P. t"} returns {true}. If the term is not a restricted universal quantification the result is {false}. \FAILURE diff --git a/help/Docfiles/res_quanLib.list_mk_res_exists.doc b/help/Docfiles/res_quanLib.list_mk_res_exists.doc index bd54ed0624..3473a65c99 100644 --- a/help/Docfiles/res_quanLib.list_mk_res_exists.doc +++ b/help/Docfiles/res_quanLib.list_mk_res_exists.doc @@ -13,7 +13,7 @@ returns {"?x1::P1. ... ?xn::Pn. t"}. \FAILURE Fails with {list_mk_res_exists} if the first terms {xi} in the pairs are -not a variable or if the second terms {Pi} in the pairs and {t} +not a variable or if the second terms {Pi} in the pairs and {t} are not of type {":bool"} if the list is non-empty. If the list is empty the type of {t} can be anything. diff --git a/help/Docfiles/res_quanLib.list_mk_res_forall.doc b/help/Docfiles/res_quanLib.list_mk_res_forall.doc index 73c413b8ce..36c63b1a39 100644 --- a/help/Docfiles/res_quanLib.list_mk_res_forall.doc +++ b/help/Docfiles/res_quanLib.list_mk_res_forall.doc @@ -13,7 +13,7 @@ returns {"!x1::P1. ... !xn::Pn. t"}. \FAILURE Fails with {list_mk_res_forall} if the first terms {xi} in the pairs are -not a variable or if the second terms {Pi} in the pairs and {t} +not a variable or if the second terms {Pi} in the pairs and {t} are not of type {":bool"} if the list is non-empty. If the list is empty the type of {t} can be anything. diff --git a/help/Docfiles/res_quanTools.IMP_RES_FORALL_CONV.doc b/help/Docfiles/res_quanTools.IMP_RES_FORALL_CONV.doc index f431f14392..253deba65e 100644 --- a/help/Docfiles/res_quanTools.IMP_RES_FORALL_CONV.doc +++ b/help/Docfiles/res_quanTools.IMP_RES_FORALL_CONV.doc @@ -12,7 +12,7 @@ conversion, restricted quantifier, universal, implication. When applied to a term of the form {!x.P x ==> Q}, the conversion {IMP_RES_FORALL_CONV} returns the theorem: { - |- (!x. P x ==> Q) = !x::P. Q + |- (!x. P x ==> Q) = !x::P. Q } \FAILURE diff --git a/help/Docfiles/res_quanTools.RESQ_GEN_TAC.doc b/help/Docfiles/res_quanTools.RESQ_GEN_TAC.doc index 8f50880501..4df6aee405 100644 --- a/help/Docfiles/res_quanTools.RESQ_GEN_TAC.doc +++ b/help/Docfiles/res_quanTools.RESQ_GEN_TAC.doc @@ -25,7 +25,7 @@ Fails unless the goal's conclusion is a restricted universal quantification. \USES The tactic {REPEAT RESQ_GEN_TAC} strips away a series of restricted universal quantifiers, and is commonly used before tactics relying on -the underlying term structure. +the underlying term structure. \SEEALSO res_quanTools.RESQ_SPEC, res_quanTools.RESQ_SPECL, Tactic.STRIP_TAC, diff --git a/help/Docfiles/res_quanTools.RESQ_IMP_RES_TAC.doc b/help/Docfiles/res_quanTools.RESQ_IMP_RES_TAC.doc index 08bdb5d424..4b8c871d3d 100644 --- a/help/Docfiles/res_quanTools.RESQ_IMP_RES_TAC.doc +++ b/help/Docfiles/res_quanTools.RESQ_IMP_RES_TAC.doc @@ -17,7 +17,7 @@ implication. This resulting theorem is used in the resolution. Given a theorem {th}, the theorem-tactic {RESQ_IMP_RES_TAC} applies {RESQ_IMP_RES_THEN} repeatedly to resolve the theorem with the -assumptions. +assumptions. \FAILURE Never fails diff --git a/help/Docfiles/res_quanTools.RESQ_MATCH_MP.doc b/help/Docfiles/res_quanTools.RESQ_MATCH_MP.doc index 16b8bdb451..dc11465817 100644 --- a/help/Docfiles/res_quanTools.RESQ_MATCH_MP.doc +++ b/help/Docfiles/res_quanTools.RESQ_MATCH_MP.doc @@ -10,7 +10,7 @@ rule, modus ponens, restricted quantifier. \DESCRIBE When applied to theorems {A1 |- !x::P. Q[x]} and {A2 |- P x'}, the -derived inference rule {RESQ_MATCH_MP} matches {x'} to {x} by instantiating +derived inference rule {RESQ_MATCH_MP} matches {x'} to {x} by instantiating free or universally quantified variables in the first theorem (only), and returns a theorem {A1 u A2 |- Q[x'/x]}. Polymorphic types are also instantiated if necessary. diff --git a/help/Docfiles/res_quanTools.RESQ_RES_TAC.doc b/help/Docfiles/res_quanTools.RESQ_RES_TAC.doc index 3893395684..3f45005fef 100644 --- a/help/Docfiles/res_quanTools.RESQ_RES_TAC.doc +++ b/help/Docfiles/res_quanTools.RESQ_RES_TAC.doc @@ -14,7 +14,7 @@ tactic, resolution, restricted quantifier. quantifications in resolution in a way similar to {RES_TAC}. It calls {RESQ_RES_THEN} repeatedly until there is no more resolution can be done. The conclusions of all the new results are returned as additional -assumptions of the subgoal(s). The effect of {RESQ_RES_TAC} +assumptions of the subgoal(s). The effect of {RESQ_RES_TAC} on a goal is to enrich the assumption set with some of its collective consequences. diff --git a/help/Docfiles/res_quanTools.RESQ_REWRITE1_TAC.doc b/help/Docfiles/res_quanTools.RESQ_REWRITE1_TAC.doc index e74842db24..fba716e958 100644 --- a/help/Docfiles/res_quanTools.RESQ_REWRITE1_TAC.doc +++ b/help/Docfiles/res_quanTools.RESQ_REWRITE1_TAC.doc @@ -28,7 +28,7 @@ form {asml'}, and they also become new subgoals {(asml,P x')}. \FAILURE {RESQ_REWRITE1_TAC th} fails if {th} cannot be transformed into the -required form by the function {RESQ_REWR_CANON}. Otherwise, it fails if no +required form by the function {RESQ_REWR_CANON}. Otherwise, it fails if no match is found or the theorem cannot be instantiated. diff --git a/help/Docfiles/res_quanTools.RESQ_SPECL.doc b/help/Docfiles/res_quanTools.RESQ_SPECL.doc index 547998fecf..2c27c75913 100644 --- a/help/Docfiles/res_quanTools.RESQ_SPECL.doc +++ b/help/Docfiles/res_quanTools.RESQ_SPECL.doc @@ -29,7 +29,7 @@ It is permissible for the term-list to be empty, in which case the application of {RESQ_SPECL} has no effect. \FAILURE -Fails if one of the specialization of the +Fails if one of the specialization of the restricted universally quantified variable in the original theorem fails. \SEEALSO diff --git a/help/Docfiles/res_quanTools.dest_res_exists.doc b/help/Docfiles/res_quanTools.dest_res_exists.doc index c872889531..7bae708621 100644 --- a/help/Docfiles/res_quanTools.dest_res_exists.doc +++ b/help/Docfiles/res_quanTools.dest_res_exists.doc @@ -8,7 +8,7 @@ the quantified variable, predicate and body. \DESCRIBE {dest_res_exists} is a term destructor for restricted existential -quantification: +quantification: { dest_res_exists "?var::P. t" } diff --git a/help/Docfiles/res_quanTools.dest_res_forall.doc b/help/Docfiles/res_quanTools.dest_res_forall.doc index ad34d77405..0672a60855 100644 --- a/help/Docfiles/res_quanTools.dest_res_forall.doc +++ b/help/Docfiles/res_quanTools.dest_res_forall.doc @@ -8,7 +8,7 @@ the quantified variable, predicate and body. \DESCRIBE {dest_res_forall} is a term destructor for restricted universal -quantification: +quantification: { dest_res_forall "!var::P. t" } diff --git a/help/Docfiles/res_quanTools.dest_res_select.doc b/help/Docfiles/res_quanTools.dest_res_select.doc index 38e133e949..15f300cac5 100644 --- a/help/Docfiles/res_quanTools.dest_res_select.doc +++ b/help/Docfiles/res_quanTools.dest_res_select.doc @@ -8,7 +8,7 @@ the quantified variable, predicate and body. \DESCRIBE {dest_res_select} is a term destructor for restricted choice -quantification: +quantification: { dest_res_select "@var::P. t" } diff --git a/help/Docfiles/res_quanTools.is_res_exists.doc b/help/Docfiles/res_quanTools.is_res_exists.doc index feb8f21bcb..cbd1e875ca 100644 --- a/help/Docfiles/res_quanTools.is_res_exists.doc +++ b/help/Docfiles/res_quanTools.is_res_exists.doc @@ -6,7 +6,7 @@ Tests a term to see if it is a restricted existential quantification. \DESCRIBE -{is_res_exists "?var::P. t"} returns {true}. If the term is not a +{is_res_exists "?var::P. t"} returns {true}. If the term is not a restricted existential quantification the result is {false}. \FAILURE diff --git a/help/Docfiles/res_quanTools.is_res_forall.doc b/help/Docfiles/res_quanTools.is_res_forall.doc index 8547292d97..f098580b15 100644 --- a/help/Docfiles/res_quanTools.is_res_forall.doc +++ b/help/Docfiles/res_quanTools.is_res_forall.doc @@ -6,7 +6,7 @@ Tests a term to see if it is a restricted universal quantification. \DESCRIBE -{is_res_forall "!var::P. t"} returns {true}. If the term is not a +{is_res_forall "!var::P. t"} returns {true}. If the term is not a restricted universal quantification the result is {false}. \FAILURE diff --git a/help/Docfiles/res_quanTools.list_mk_res_exists.doc b/help/Docfiles/res_quanTools.list_mk_res_exists.doc index d9ebc168da..3b37b58eb0 100644 --- a/help/Docfiles/res_quanTools.list_mk_res_exists.doc +++ b/help/Docfiles/res_quanTools.list_mk_res_exists.doc @@ -13,7 +13,7 @@ returns {"?x1::P1. ... ?xn::Pn. t"}. \FAILURE Fails with {list_mk_res_exists} if the first terms {xi} in the pairs are -not a variable or if the second terms {Pi} in the pairs and {t} +not a variable or if the second terms {Pi} in the pairs and {t} are not of type {":bool"} if the list is non-empty. If the list is empty the type of {t} can be anything. diff --git a/help/Docfiles/res_quanTools.list_mk_res_forall.doc b/help/Docfiles/res_quanTools.list_mk_res_forall.doc index b71c56c9b1..9b1efb5613 100644 --- a/help/Docfiles/res_quanTools.list_mk_res_forall.doc +++ b/help/Docfiles/res_quanTools.list_mk_res_forall.doc @@ -13,7 +13,7 @@ returns {"!x1::P1. ... !xn::Pn. t"}. \FAILURE Fails with {list_mk_res_forall} if the first terms {xi} in the pairs are -not a variable or if the second terms {Pi} in the pairs and {t} +not a variable or if the second terms {Pi} in the pairs and {t} are not of type {":bool"} if the list is non-empty. If the list is empty the type of {t} can be anything. diff --git a/help/Docfiles/simpLib.SIMP_PROVE.doc b/help/Docfiles/simpLib.SIMP_PROVE.doc index 75755ee0e9..0a72f3225f 100644 --- a/help/Docfiles/simpLib.SIMP_PROVE.doc +++ b/help/Docfiles/simpLib.SIMP_PROVE.doc @@ -29,7 +29,7 @@ to the goal {?- x + y = 10} yields the new goal } Using {SIMP_PROVE} here allows {ASSUME_TAC} to add a new fact, where the equality with truth that {SIMP_CONV} would produce would be less -useful. +useful. \USES diff --git a/help/Docfiles/unwindLib.PRUNE_ONCE_CONV.doc b/help/Docfiles/unwindLib.PRUNE_ONCE_CONV.doc index 4385c956c1..5caece080d 100644 --- a/help/Docfiles/unwindLib.PRUNE_ONCE_CONV.doc +++ b/help/Docfiles/unwindLib.PRUNE_ONCE_CONV.doc @@ -26,7 +26,7 @@ more than one of the conjuncts or if the equation for {l} is recursive. \EXAMPLE { -#PRUNE_ONCE_CONV "?l2. (!(x:num). l1 x = F) /\ (!x. l2 x = ~(l1 x))";; +#PRUNE_ONCE_CONV "?l2. (!(x:num). l1 x = F) /\ (!x. l2 x = ~(l1 x))";; |- (?l2. (!x. l1 x = F) /\ (!x. l2 x = ~l1 x)) = (!x. l1 x = F) } \SEEALSO diff --git a/help/Docfiles/unwindLib.PRUNE_ONE_CONV.doc b/help/Docfiles/unwindLib.PRUNE_ONE_CONV.doc index 8949285a47..ef9d76d6d3 100644 --- a/help/Docfiles/unwindLib.PRUNE_ONE_CONV.doc +++ b/help/Docfiles/unwindLib.PRUNE_ONE_CONV.doc @@ -38,7 +38,7 @@ quantified lines. #PRUNE_ONE_CONV `l2` "?l2 l1. (!(x:num). l1 x = F) /\ (!x. l2 x = ~(l1 x))";; |- (?l2 l1. (!x. l1 x = F) /\ (!x. l2 x = ~l1 x)) = (?l1. !x. l1 x = F) -#PRUNE_ONE_CONV `l1` "?l2 l1. (!(x:num). l1 x = F) /\ (!x. l2 x = ~(l1 x))";; +#PRUNE_ONE_CONV `l1` "?l2 l1. (!(x:num). l1 x = F) /\ (!x. l2 x = ~(l1 x))";; evaluation failed PRUNE_ONE_CONV } \SEEALSO diff --git a/help/Docfiles/wordsLib.WORD_DP.doc b/help/Docfiles/wordsLib.WORD_DP.doc index 8b56badec7..7ad7db7418 100644 --- a/help/Docfiles/wordsLib.WORD_DP.doc +++ b/help/Docfiles/wordsLib.WORD_DP.doc @@ -14,7 +14,7 @@ decision procedures include {tautLib.TAUT_PROVE}, {bossLib.DECIDE}, {intLib.ARITH_PROVE} and {intLib.COOPER_PROVE}. The procedure will first apply {conv} and then {WORD_BIT_EQ_CONV}. If this is not sufficient then an attempt is made to solve the problem by applying an arithmetic decision procedure {dp}, -e.g. {``(a = 0w) \/ (a = 1w :1 word)``} is mapped to the goal +e.g. {``(a = 0w) \/ (a = 1w :1 word)``} is mapped to the goal {``w2n a < 2 ==> (w2n a = 0) \/ (w2n a = 1)``}. \FAILURE From eb991075af1551a435b4c3fcdcddcc64c87f949c Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 18 Nov 2015 08:55:01 +1100 Subject: [PATCH 571/718] Provide gentactic's type definition in Abbrev.sml --- src/1/Abbrev.sml | 1 + 1 file changed, 1 insertion(+) diff --git a/src/1/Abbrev.sml b/src/1/Abbrev.sml index ea8168a2e4..8a9fe855c7 100644 --- a/src/1/Abbrev.sml +++ b/src/1/Abbrev.sml @@ -10,6 +10,7 @@ struct type tactic = goal -> goal list * validation type list_validation = thm list -> thm list type list_tactic = goal list -> goal list * list_validation + type ('a,'b) gentactic = 'a -> goal list * (thm list -> 'b) type thm_tactic = thm -> tactic type thm_tactical = thm_tactic -> thm_tactic type ppstream = Portable.ppstream From 48bce6f2738ec5468cb42cf8e9e3b86331b4d23a Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Sat, 5 Dec 2015 07:50:16 +1100 Subject: [PATCH 572/718] Move some tactics from lcsymtacs to Tactic{,al} As per Github issue #274 --- src/1/Tactic.sig | 18 ++++++++++++++++++ src/1/Tactic.sml | 21 +++++++++++++++++++++ src/1/Tactical.sig | 8 ++++++++ src/1/Tactical.sml | 8 ++++++++ src/boss/lcsymtacs.sml | 35 ++++------------------------------- 5 files changed, 59 insertions(+), 31 deletions(-) diff --git a/src/1/Tactic.sig b/src/1/Tactic.sig index fcd21a2fa0..51e8a5f081 100644 --- a/src/1/Tactic.sig +++ b/src/1/Tactic.sig @@ -7,29 +7,41 @@ sig val CONTR_TAC : thm_tactic val CCONTR_TAC : tactic val ASSUME_TAC : thm_tactic + val assume_tac : thm_tactic val FREEZE_THEN : thm_tactical val CONJ_TAC : tactic + val conj_tac : tactic val CONJ_ASM1_TAC : tactic + val conj_asm1_tac : tactic val CONJ_ASM2_TAC : tactic + val conj_asm2_tac : tactic val DISJ1_TAC : tactic + val disj1_tac : tactic val DISJ2_TAC : tactic + val disj2_tac : tactic val MP_TAC : thm_tactic + val mp_tac : thm_tactic val EQ_TAC : tactic + val eq_tac : tactic val X_GEN_TAC : term -> tactic val GEN_TAC : tactic + val gen_tac : tactic val SPEC_TAC : term * term -> tactic val ID_SPEC_TAC : term -> tactic val EXISTS_TAC : term -> tactic + val exists_tac : term -> tactic val GSUBST_TAC : ((term,term) Lib.subst -> term -> term) -> thm list -> tactic val SUBST_TAC : thm list -> tactic val SUBST_OCCS_TAC : (int list * thm) list -> tactic val SUBST1_TAC : thm -> tactic val RULE_ASSUM_TAC : (thm -> thm) -> tactic + val rule_assum_tac : (thm -> thm) -> tactic val RULE_L_ASSUM_TAC : (thm -> thm list) -> tactic val SUBST_ALL_TAC : thm -> tactic val CHECK_ASSUME_TAC : thm_tactic val STRIP_ASSUME_TAC : thm_tactic + val strip_assume_tac : thm_tactic val STRUCT_CASES_TAC : thm_tactic val FULL_STRUCT_CASES_TAC : thm_tactic val GEN_COND_CASES_TAC : (term -> bool) -> tactic @@ -45,6 +57,7 @@ sig val CHOOSE_TAC : thm_tactic val X_CHOOSE_TAC : term -> thm_tactic val STRIP_TAC : tactic + val strip_tac : tactic val FILTER_DISCH_TAC : term -> tactic val FILTER_STRIP_TAC : term -> tactic val ASM_CASES_TAC : term -> tactic @@ -56,16 +69,21 @@ sig val BINOP_TAC : tactic val ABS_TAC : tactic val NTAC : int -> tactic -> tactic + val ntac : int -> tactic -> tactic val WEAKEN_TAC : (term -> bool) -> tactic val MATCH_ACCEPT_TAC : thm -> tactic val MATCH_MP_TAC : thm -> tactic + val match_mp_tac : thm -> tactic val prim_irule : thm -> tactic val irule : thm -> tactic val HO_MATCH_ACCEPT_TAC : thm -> tactic val HO_BACKCHAIN_TAC : thm -> tactic val HO_MATCH_MP_TAC : thm -> tactic + val ho_match_mp_tac : thm -> tactic val IMP_RES_TAC : thm -> tactic + val imp_res_tac : thm -> tactic val RES_TAC : tactic + val res_tac : tactic val via : term * tactic -> tactic val CONV_TAC : conv -> tactic val BETA_TAC : tactic diff --git a/src/1/Tactic.sml b/src/1/Tactic.sml index 5ab8558f9a..2702cbd20e 100644 --- a/src/1/Tactic.sml +++ b/src/1/Tactic.sml @@ -106,6 +106,8 @@ fun CCONTR_TAC (asl, w) = ([(mk_neg w :: asl, boolSyntax.F)], sing (CCONTR w)) val ASSUME_TAC: thm_tactic = fn bth => fn (asl, w) => ([(concl bth :: asl, w)], sing (PROVE_HYP bth)) +val assume_tac = ASSUME_TAC + (*---------------------------------------------------------------------------* * "Freeze" a theorem to prevent instantiation * * * @@ -139,11 +141,14 @@ val CONJ_TAC: tactic = fn [th1, th2] => CONJ th1 th2 | _ => raise Match) end handle HOL_ERR _ => raise ERR "CONJ_TAC" "" +val conj_tac = CONJ_TAC (* ASM1 & ASM2 variants assume the given conjunct when proving the other one *) val CONJ_ASM1_TAC = CONJ_TAC THEN_LT USE_SG_THEN ASSUME_TAC 1 2 ; val CONJ_ASM2_TAC = CONJ_TAC THEN_LT USE_SG_THEN ASSUME_TAC 2 1 ; +val conj_asm1_tac = CONJ_ASM1_TAC +val conj_asm2_tac = CONJ_ASM2_TAC (*---------------------------------------------------------------------------* * Disjunction introduction * @@ -161,6 +166,7 @@ fun DISJ1_TAC (asl, w) = ([(asl, disj1)], sing (fn th => DISJ1 th disj2)) end handle HOL_ERR _ => raise ERR "DISJ1_TAC" "" +val disj1_tac = DISJ1_TAC (*---------------------------------------------------------------------------* * A \/ B * @@ -176,6 +182,7 @@ fun DISJ2_TAC (asl, w) = ([(asl, disj2)], sing (DISJ2 disj1)) end handle HOL_ERR _ => raise ERR "DISJ2_TAC" "" +val disj2_tac = DISJ2_TAC (*---------------------------------------------------------------------------* * Implication elimination * @@ -188,6 +195,7 @@ fun DISJ2_TAC (asl, w) = fun MP_TAC thb (asl, w) = ([(asl, mk_imp (concl thb, w))], sing (fn thimp => MP thimp thb)) +val mp_tac = MP_TAC (*---------------------------------------------------------------------------* * Equality Introduction * @@ -207,6 +215,7 @@ val EQ_TAC: tactic = fn [th1, th2] => IMP_ANTISYM_RULE th1 th2 | _ => raise Match) end handle HOL_ERR _ => raise ERR "EQ_TAC" "" +val eq_tac = EQ_TAC (*---------------------------------------------------------------------------* * Universal quantifier * @@ -275,6 +284,7 @@ val GEN_TAC: tactic = (gen_variant Parse.is_constname "" (free_varsl (w :: asl)) Bvar) (asl, w) end +val gen_tac = GEN_TAC (*---------------------------------------------------------------------------* * Specialization * @@ -312,6 +322,7 @@ fun EXISTS_TAC t : tactic = ([(asl, subst [Bvar |-> t] Body)], sing (EXISTS (w, t))) end handle HOL_ERR _ => raise ERR "EXISTS_TAC" "" +val exists_tac = EXISTS_TAC (*---------------------------------------------------------------------------* * Substitution * @@ -373,6 +384,7 @@ fun SUBST1_TAC rthm = SUBST_TAC [rthm] fun RULE_ASSUM_TAC rule : tactic = POP_ASSUM_LIST (fn asl => MAP_EVERY ASSUME_TAC (rev_itlist (cons o rule) asl [])) +val rule_assum_tac = RULE_ASSUM_TAC fun RULE_L_ASSUM_TAC rule : tactic = POP_ASSUM_LIST @@ -390,6 +402,7 @@ val CHECK_ASSUME_TAC: thm_tactic = DISCARD_TAC gth, ASSUME_TAC gth] val STRIP_ASSUME_TAC = REPEAT_TCL STRIP_THM_THEN CHECK_ASSUME_TAC +val strip_assume_tac = STRIP_ASSUME_TAC (*---------------------------------------------------------------------------* * given a theorem: * @@ -524,6 +537,7 @@ fun X_CHOOSE_TAC x = X_CHOOSE_THEN x ASSUME_TAC fun STRIP_TAC g = STRIP_GOAL_THEN STRIP_ASSUME_TAC g handle HOL_ERR _ => raise ERR "STRIP_TAC" "" +val strip_tac = STRIP_TAC val FILTER_STRIP_TAC = FILTER_STRIP_THEN STRIP_ASSUME_TAC @@ -681,6 +695,7 @@ end *---------------------------------------------------------------------------*) fun NTAC n tac = funpow n (curry op THEN tac) ALL_TAC +val ntac = NTAC (*---------------------------------------------------------------------------* * WEAKEN_TAC tm - Removes the first term meeting P from the hypotheses * @@ -780,6 +795,7 @@ in ([(A, ant)], fn thl => MP (DISCH ant gth) (hd thl)) end end + val match_mp_tac = MATCH_MP_TAC end (* --------------------------------------------------------------------------* @@ -821,6 +837,9 @@ in fun RES_TAC g = RES_THEN (REPEAT_GTCL IMP_RES_THEN STRIP_ASSUME_TAC) g handle HOL_ERR _ => ALL_TAC g + + val res_tac = RES_TAC + val imp_res_tac = IMP_RES_TAC end (*--------------------------------------------------------------------------* @@ -931,6 +950,8 @@ fun HO_MATCH_MP_TAC th = handle e => raise (wrap_exn "Tactic" "HO_MATCH_MP_TAC" e) end +val ho_match_mp_tac = HO_MATCH_MP_TAC + (*----------------------------------------------------------------------* * Tactics explicitly declaring subgoals. * *----------------------------------------------------------------------*) diff --git a/src/1/Tactical.sig b/src/1/Tactical.sig index aca43023ee..7081b5c5d4 100644 --- a/src/1/Tactical.sig +++ b/src/1/Tactical.sig @@ -37,16 +37,19 @@ sig val SPLIT_LT : int -> list_tactic * list_tactic -> list_tactic val ROTATE_LT : int -> list_tactic val REVERSE : tactic -> tactic + val reverse : tactic -> tactic val REVERSE_LT : list_tactic val FAIL_TAC : string -> tactic val NO_TAC : tactic val FAIL_LT : string -> list_tactic val NO_LT : list_tactic val ALL_TAC : tactic + val all_tac : tactic val ALL_LT : list_tactic val TRY : tactic -> tactic val TRY_LT : list_tactic -> list_tactic val REPEAT : tactic -> tactic + val rpt : tactic -> tactic val REPEAT_LT : list_tactic -> list_tactic val VALID : tactic -> tactic val VALID_LT : list_tactic -> list_tactic @@ -63,11 +66,16 @@ sig val FIRST_PROVE : tactic list -> tactic val EVERY_ASSUM : thm_tactic -> tactic val FIRST_ASSUM : thm_tactic -> tactic + val first_assum : thm_tactic -> tactic val FIRST_X_ASSUM : thm_tactic -> tactic + val first_x_assum : thm_tactic -> tactic val LAST_ASSUM : thm_tactic -> tactic + val last_assum : thm_tactic -> tactic val LAST_X_ASSUM : thm_tactic -> tactic + val last_x_assum : thm_tactic -> tactic val ASSUM_LIST : (thm list -> tactic) -> tactic val POP_ASSUM : thm_tactic -> tactic + val pop_assum : thm_tactic -> tactic val PRED_ASSUM : (term -> bool) -> thm_tactic -> tactic val PAT_ASSUM : term -> thm_tactic -> tactic val POP_ASSUM_LIST : (thm list -> tactic) -> tactic diff --git a/src/1/Tactical.sml b/src/1/Tactical.sml index d9f59179a1..05c96fa557 100644 --- a/src/1/Tactical.sml +++ b/src/1/Tactical.sml @@ -287,6 +287,7 @@ fun REVERSE tac g = in (rev gl, jf o rev) end +val reverse = REVERSE (*--------------------------------------------------------------------------- * REVERSE_LT: A list_tactic that reverses a list of subgoals @@ -327,6 +328,7 @@ fun tac1 THEN1 tac2 = tac1 THEN_LT REVERSE_LT THEN_LT val ALL_TAC: tactic = fn (g: goal) => ([g], hd) val ALL_LT: list_tactic = fn (gl: goal list) => (gl, Lib.I) +val all_tac = ALL_TAC fun TRY tac = tac ORELSE ALL_TAC fun TRY_LT ltac = ltac ORELSE_LT ALL_LT @@ -339,6 +341,7 @@ fun TRYALL tac = ALLGOALS (TRY tac) ; fun REPEAT tac g = ((tac THEN REPEAT tac) ORELSE ALL_TAC) g fun REPEAT_LT ltac gl = ((ltac THEN_LT REPEAT_LT ltac) ORELSE_LT ALL_LT) gl +val rpt = REPEAT (*--------------------------------------------------------------------------- * Add extra subgoals, which may be needed to make a tactic valid; @@ -490,6 +493,7 @@ fun ASSUM_LIST aslfun (g as (asl, _)) = aslfun (map ASSUME asl) g fun POP_ASSUM thfun (a :: asl, w) = thfun (ASSUME a) (asl, w) | POP_ASSUM _ ([], _) = raise ERR "POP_ASSUM" "no assum" +val pop_assum = POP_ASSUM (*--------------------------------------------------------------------------- * Pop off the entire assumption list and give it to a function (tactic) @@ -593,6 +597,8 @@ in shut_parser_up (find ttac "FIRST_ASSUM" (A, g)) A fun LAST_ASSUM ttac (A, g) = shut_parser_up (find ttac "LAST_ASSUM" (A, g)) (List.rev A) + val first_assum = FIRST_ASSUM + val last_assum = LAST_ASSUM end @@ -612,6 +618,8 @@ local in val FIRST_X_ASSUM = FIRST_ASSUM o f val LAST_X_ASSUM = LAST_ASSUM o f + val first_x_assum = FIRST_X_ASSUM + val last_x_assum = LAST_X_ASSUM end (*--------------------------------------------------------------------------- diff --git a/src/boss/lcsymtacs.sml b/src/boss/lcsymtacs.sml index 3112b3f5bf..d72efc5063 100644 --- a/src/boss/lcsymtacs.sml +++ b/src/boss/lcsymtacs.sml @@ -1,38 +1,17 @@ structure lcsymtacs :> lcsymtacs = struct - open Abbrev HolKernel boolLib - - val all_tac : tactic = Tactical.ALL_TAC - fun kall_tac (_: 'a) : tactic = Tactical.ALL_TAC - val eq_tac : tactic = Tactic.EQ_TAC - val strip_tac : tactic = Tactic.STRIP_TAC - val conj_tac : tactic = Tactic.CONJ_TAC - val conj_asm1_tac : tactic = Tactic.CONJ_ASM1_TAC - val conj_asm2_tac : tactic = Tactic.CONJ_ASM2_TAC - val disj1_tac : tactic = Tactic.DISJ1_TAC - val disj2_tac : tactic = Tactic.DISJ2_TAC - val gen_tac : tactic = Tactic.GEN_TAC - val exists_tac : term -> tactic = Tactic.EXISTS_TAC + open Abbrev HolKernel boolLib Tactic Tactical + + fun kall_tac (_: 'a) : tactic = all_tac val suff_tac : term -> tactic = Tactic.SUFF_TAC - val rpt = Tactical.REPEAT - val reverse = Tactical.REVERSE - val ntac = Tactic.NTAC val var_eq_tac = BasicProvers.VAR_EQ_TAC val rewrite_tac : thm list -> tactic = Rewrite.REWRITE_TAC val once_rewrite_tac : thm list -> tactic = Rewrite.ONCE_REWRITE_TAC val asm_rewrite_tac : thm list -> tactic = Rewrite.ASM_REWRITE_TAC val once_asm_rewrite_tac : thm list -> tactic = Rewrite.ONCE_ASM_REWRITE_TAC - val ho_match_mp_tac : thm_tactic = Tactic.HO_MATCH_MP_TAC - val match_mp_tac : thm_tactic = Tactic.MATCH_MP_TAC - val mp_tac = Tactic.MP_TAC - - val pop_assum : thm_tactic -> tactic = Tactical.POP_ASSUM - val first_assum : thm_tactic -> tactic = Tactical.FIRST_ASSUM - val first_x_assum : thm_tactic -> tactic = Tactical.FIRST_X_ASSUM - val last_assum : thm_tactic -> tactic = Tactical.LAST_ASSUM - val last_x_assum : thm_tactic -> tactic = Tactical.LAST_X_ASSUM + val disch_then = Thm_cont.DISCH_THEN val qx_gen_tac : term quotation -> tactic = Q.X_GEN_TAC @@ -61,18 +40,12 @@ struct val every_case_tac = BasicProvers.EVERY_CASE_TAC val full_case_tac = BasicProvers.FULL_CASE_TAC - val rule_assum_tac : (thm -> thm) -> tactic = Tactic.RULE_ASSUM_TAC - val assume_tac : thm_tactic = Tactic.ASSUME_TAC - val strip_assume_tac : thm_tactic = Tactic.STRIP_ASSUME_TAC val spose_not_then : thm_tactic -> tactic = BasicProvers.SPOSE_NOT_THEN val qabbrev_tac : term quotation -> tactic = Q.ABBREV_TAC val qunabbrev_tac : term quotation -> tactic = Q.UNABBREV_TAC val unabbrev_all_tac : tactic = markerLib.UNABBREV_ALL_TAC - val res_tac : tactic = Tactic.RES_TAC - val imp_res_tac : thm_tactic = Tactic.IMP_RES_TAC - val map_every : ('a -> tactic) -> 'a list -> tactic = Tactical.MAP_EVERY val qx_genl_tac = map_every qx_gen_tac fun qx_choosel_then [] ttac = ttac From 5b282aae73695545142f27e98f98b2fa70af435b Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 7 Dec 2015 09:58:29 +1100 Subject: [PATCH 573/718] More moving lcsymtacs implementations elsewhere Eventually lcsymtacs will just be a bunch of 'open' declarations, and then people won't bother to include it at all. --- src/1/Rewrite.sig | 4 +++ src/1/Rewrite.sml | 5 +++ src/1/Tactic.sig | 1 + src/1/Tactic.sml | 1 + src/1/Tactical.sig | 2 ++ src/1/Tactical.sml | 2 ++ src/1/Thm_cont.sig | 1 + src/1/Thm_cont.sml | 1 + src/basicProof/BasicProvers.sig | 7 ++++ src/basicProof/BasicProvers.sml | 7 ++++ src/boss/bossLib.sig | 14 ++++++++ src/boss/bossLib.sml | 30 +++++++++++++++++ src/boss/lcsymtacs.sml | 57 ++------------------------------- src/simp/src/simpLib.sig | 4 +++ src/simp/src/simpLib.sml | 4 +++ 15 files changed, 85 insertions(+), 55 deletions(-) diff --git a/src/1/Rewrite.sig b/src/1/Rewrite.sig index 264447f0e7..cc50dfff49 100644 --- a/src/1/Rewrite.sig +++ b/src/1/Rewrite.sig @@ -38,12 +38,16 @@ sig val PURE_REWRITE_TAC : thm list -> tactic val REWRITE_TAC : thm list -> tactic + val rewrite_tac : thm list -> tactic val PURE_ONCE_REWRITE_TAC : thm list -> tactic val ONCE_REWRITE_TAC : thm list -> tactic + val once_rewrite_tac : thm list -> tactic val PURE_ASM_REWRITE_TAC : thm list -> tactic val ASM_REWRITE_TAC : thm list -> tactic + val asm_rewrite_tac : thm list -> tactic val PURE_ONCE_ASM_REWRITE_TAC : thm list -> tactic val ONCE_ASM_REWRITE_TAC : thm list -> tactic + val once_asm_rewrite_tac : thm list -> tactic type pred = term -> bool diff --git a/src/1/Rewrite.sml b/src/1/Rewrite.sml index b552077fcc..b2a4401efa 100644 --- a/src/1/Rewrite.sml +++ b/src/1/Rewrite.sml @@ -190,6 +190,8 @@ fun REWRITE_TAC thl = GEN_REWRITE_TAC Conv.TOP_DEPTH_CONV (implicit_rewrites()) and ONCE_REWRITE_TAC thl = GEN_REWRITE_TAC Conv.ONCE_DEPTH_CONV (implicit_rewrites()) thl; +val rewrite_tac = REWRITE_TAC and once_rewrite_tac = ONCE_REWRITE_TAC + (* Rewrite a goal with the help of its assumptions *) @@ -202,6 +204,9 @@ and PURE_ONCE_ASM_REWRITE_TAC thl :tactic = and ONCE_ASM_REWRITE_TAC thl :tactic = Tactical.ASSUM_LIST (fn asl => ONCE_REWRITE_TAC (asl @ thl)); +val asm_rewrite_tac = ASM_REWRITE_TAC +val once_asm_rewrite_tac = ONCE_ASM_REWRITE_TAC + (* Rewriting using equations that satisfy a predicate *) fun FILTER_PURE_ASM_REWRITE_RULE f thl th = PURE_REWRITE_RULE ((map ASSUME (filter f (hyp th))) @ thl) th diff --git a/src/1/Tactic.sig b/src/1/Tactic.sig index 51e8a5f081..097536d940 100644 --- a/src/1/Tactic.sig +++ b/src/1/Tactic.sig @@ -89,6 +89,7 @@ sig val BETA_TAC : tactic val KNOW_TAC : term -> tactic val SUFF_TAC : term -> tactic + val suff_tac : term -> tactic val DEEP_INTROk_TAC : thm -> tactic -> tactic val DEEP_INTRO_TAC : thm -> tactic diff --git a/src/1/Tactic.sml b/src/1/Tactic.sml index 2702cbd20e..2cd100942f 100644 --- a/src/1/Tactic.sml +++ b/src/1/Tactic.sml @@ -960,6 +960,7 @@ fun SUFF_TAC tm (al, c) = ([(al, mk_imp (tm, c)), (al, tm)], fn [th1, th2] => MP th1 th2 | _ => raise ERR "SUFF_TAC" "panic") +val suff_tac = SUFF_TAC fun KNOW_TAC tm = REVERSE (SUFF_TAC tm) diff --git a/src/1/Tactical.sig b/src/1/Tactical.sig index 7081b5c5d4..3d898d3eda 100644 --- a/src/1/Tactical.sig +++ b/src/1/Tactical.sig @@ -7,6 +7,7 @@ sig val store_thm : string * term * tactic -> thm val THEN : ('a,'b) gentactic * tactic -> ('a,'b) gentactic val >> : ('a,'b) gentactic * tactic -> ('a,'b) gentactic + val \\ : ('a,'b) gentactic * tactic -> ('a,'b) gentactic (* could be used as val THEN : tactic * tactic -> tactic val THEN : list_tactic * tactic -> list_tactic @@ -62,6 +63,7 @@ sig val EVERY_LT : list_tactic list -> list_tactic val FIRST : tactic list -> tactic val MAP_EVERY : ('a -> tactic) -> 'a list -> tactic + val map_every : ('a -> tactic) -> 'a list -> tactic val MAP_FIRST : ('a -> tactic) -> 'a list -> tactic val FIRST_PROVE : tactic list -> tactic val EVERY_ASSUM : thm_tactic -> tactic diff --git a/src/1/Tactical.sml b/src/1/Tactical.sml index 05c96fa557..480b5784b4 100644 --- a/src/1/Tactical.sml +++ b/src/1/Tactical.sml @@ -132,6 +132,7 @@ fun ALLGOALS tac2 gl = fun tac1 THEN tac2 = tac1 THEN_LT ALLGOALS tac2 ; val op >> = op THEN +val op \\ = op THEN (* first argument can be a tactic or a list-tactic *) val _ = op THEN : tactic * tactic -> tactic ; @@ -561,6 +562,7 @@ fun FIRST [] g = NO_TAC g | FIRST (tac :: rst) g = tac g handle HOL_ERR _ => FIRST rst g fun MAP_EVERY tacf lst = EVERY (map tacf lst) +val map_every = MAP_EVERY fun MAP_FIRST tacf lst = FIRST (map tacf lst) (*--------------------------------------------------------------------------- diff --git a/src/1/Thm_cont.sig b/src/1/Thm_cont.sig index 3bd80154c6..e76a3e15e4 100644 --- a/src/1/Thm_cont.sig +++ b/src/1/Thm_cont.sig @@ -16,6 +16,7 @@ sig val DISJ_CASES_THEN : thm_tactical val DISJ_CASES_THENL : thm_tactic list -> thm_tactic val DISCH_THEN : thm_tactic -> tactic + val disch_then : thm_tactic -> tactic val UNDISCH_THEN : Term.term -> thm_tactic -> tactic val X_CHOOSE_THEN : Term.term -> thm_tactical val CHOOSE_THEN : thm_tactical diff --git a/src/1/Thm_cont.sml b/src/1/Thm_cont.sml index d0f406f4b6..81149f76e7 100644 --- a/src/1/Thm_cont.sml +++ b/src/1/Thm_cont.sml @@ -194,6 +194,7 @@ fun DISCH_THEN ttac (asl,w) = (gl, (if is_neg w then NEG_DISCH ant else DISCH ant) o prf) end handle HOL_ERR _ => raise ERR "DISCH_THEN" "" +val disch_then = DISCH_THEN (*---------------------------------------------------------------------------* * DISCH_THEN's "dual" * diff --git a/src/basicProof/BasicProvers.sig b/src/basicProof/BasicProvers.sig index 16ea61af88..d8cd0f4090 100644 --- a/src/basicProof/BasicProvers.sig +++ b/src/basicProof/BasicProvers.sig @@ -6,11 +6,13 @@ sig (* Eliminate v = M or M = v from hypotheses *) val VAR_EQ_TAC : tactic + val var_eq_tac : tactic (* First order automatic proof *) val PROVE : thm list -> term -> thm val PROVE_TAC : thm list -> tactic + val prove_tac : thm list -> tactic val GEN_PROVE_TAC : int -> int -> int -> thm list -> tactic (* Simplification *) @@ -21,8 +23,10 @@ sig val LEAVE_LETS : thm val RW_TAC : simpset -> thm list -> tactic + val rw_tac : simpset -> thm list -> tactic val NORM_TAC : simpset -> thm list -> tactic val SRW_TAC : simpLib.ssfrag list -> thm list -> tactic + val srw_tac : simpLib.ssfrag list -> thm list -> tactic val augment_srw_ss : simpLib.ssfrag list -> unit val diminish_srw_ss : string list -> simpLib.ssfrag list val export_rewrites : string list -> unit @@ -39,6 +43,7 @@ sig (* Other reasoning support. *) val SPOSE_NOT_THEN : (thm -> tactic) -> tactic + val spose_not_then : (thm -> tactic) -> tactic val by : term quotation * tactic -> tactic (* infix *) val suffices_by : term quotation * tactic -> tactic (* infix *) @@ -69,6 +74,8 @@ sig val CASE_TAC : tactic (* PURE_CASE_TAC then simplification *) val TOP_CASE_TAC : tactic (* PURE_TOP_CASE_TAC then simplification *) val FULL_CASE_TAC : tactic (* PURE_FULL_CASE_TAC then simplification *) + val full_case_tac : tactic val EVERY_CASE_TAC : tactic (* Repeat FULL_CASE_TAC *) + val every_case_tac : tactic end diff --git a/src/basicProof/BasicProvers.sml b/src/basicProof/BasicProvers.sml index 8782b97850..69b336f9f3 100644 --- a/src/basicProof/BasicProvers.sml +++ b/src/basicProof/BasicProvers.sml @@ -32,6 +32,7 @@ in EXPAND_COND_TAC THEN CONV_TAC (DEST_LABELS_CONV) THEN mesonLib.MESON_TAC (map NORM_RULE working) end (asl, w) +val prove_tac = PROVE_TAC fun GEN_PROVE_TAC x y z thl (asl, w) = let val working = LLABEL_RESOLVE thl asl @@ -51,6 +52,7 @@ fun SPOSE_NOT_THEN ttac = CCONTR_TAC THEN POP_ASSUM (fn th => ttac (simpLib.SIMP_RULE boolSimps.bool_ss [GSYM boolTheory.IMP_DISJ_THM] th)) +val spose_not_then = SPOSE_NOT_THEN (*===========================================================================*) (* Case analysis and induction tools that index the TypeBase. *) @@ -487,6 +489,7 @@ fun FULL_CASE_TAC goal = THEN RULE_ASSUM_TAC asm_rule THEN CONV_TAC case_conv end goal; +val full_case_tac = FULL_CASE_TAC (*---------------------------------------------------------------------------*) (* Repeatedly do a case analysis anywhere in the goal. Avoids re-computing *) @@ -503,6 +506,7 @@ fun EVERY_CASE_TAC goal = CONV_TAC case_conv) a in REPEAT tac end goal; +val every_case_tac = EVERY_CASE_TAC (*===========================================================================*) (* Rewriters *) @@ -556,6 +560,7 @@ fun grab P f v = fun ASSUM_TAC f P = W (fn (asl,_) => grab P f NO_TAC asl) val VAR_EQ_TAC = ASSUM_TAC VSUBST_TAC var_eq; +val var_eq_tac = VAR_EQ_TAC fun ASSUMS_TAC f P = W (fn (asl,_) => case filter P asl @@ -829,6 +834,7 @@ fun STP_TAC ss finisher fun RW_TAC ss thl g = markerLib.ABBRS_THEN (fn thl => STP_TAC (ss && thl) NO_TAC) thl g +val rw_tac = RW_TAC fun NORM_TAC ss thl g = markerLib.ABBRS_THEN @@ -899,6 +905,7 @@ fun SRW_TAC ssdl thl g = let in markerLib.ABBRS_THEN (fn thl => PRIM_STP_TAC (ss && thl) NO_TAC) thl end g; +val srw_tac = SRW_TAC val Abbr = markerSyntax.Abbr diff --git a/src/boss/bossLib.sig b/src/boss/bossLib.sig index 830aaa0820..adf2165d38 100644 --- a/src/boss/bossLib.sig +++ b/src/boss/bossLib.sig @@ -48,7 +48,9 @@ sig val DECIDE : term -> thm (* Cooperating dec. procs *) val PROVE_TAC : thm list -> tactic val METIS_TAC : thm list -> tactic + val metis_tac : thm list -> tactic val DECIDE_TAC : tactic + val decide_tac : tactic (* Simplification *) @@ -116,4 +118,16 @@ sig val REABBREV_TAC : tactic val WITHOUT_ABBREVS : tactic -> tactic + (* more simplification variants *) + val fsrw_tac : simpLib.ssfrag list -> thm list -> tactic + val simp : thm list -> tactic + val csimp : thm list -> tactic + val dsimp : thm list -> tactic + val lrw : thm list -> tactic + val lfs : thm list -> tactic + val lrfs : thm list -> tactic + val rw : thm list -> tactic + val fs : thm list -> tactic + val rfs : thm list -> tactic + end diff --git a/src/boss/bossLib.sml b/src/boss/bossLib.sml index 945835867e..cf4e5548d7 100644 --- a/src/boss/bossLib.sml +++ b/src/boss/bossLib.sml @@ -66,8 +66,10 @@ val PROVE = BasicProvers.PROVE val PROVE_TAC = BasicProvers.PROVE_TAC val METIS_PROVE = metisLib.METIS_PROVE val METIS_TAC = metisLib.METIS_TAC +val metis_tac = METIS_TAC val RW_TAC = BasicProvers.RW_TAC val SRW_TAC = BasicProvers.SRW_TAC +val srw_tac = BasicProvers.srw_tac val srw_ss = BasicProvers.srw_ss val augment_srw_ss = BasicProvers.augment_srw_ss val diminish_srw_ss = BasicProvers.diminish_srw_ss @@ -113,6 +115,7 @@ end val DECIDE = numLib.DECIDE; val DECIDE_TAC = numLib.DECIDE_TAC; +val decide_tac = DECIDE_TAC fun ZAP_TAC ss thl = BasicProvers.STP_TAC ss @@ -153,4 +156,31 @@ val UNABBREV_ALL_TAC = markerLib.UNABBREV_ALL_TAC val REABBREV_TAC = markerLib.REABBREV_TAC val WITHOUT_ABBREVS = markerLib.WITHOUT_ABBREVS +(* ---------------------------------------------------------------------- + convenient simplification aliases + ---------------------------------------------------------------------- *) + +open simpLib +fun stateful f ssfl thm : tactic = + let + val ss = List.foldl (simpLib.++ o Lib.swap) (srw_ss()) ssfl + in + f ss thm + end + +val fsrw_tac = stateful full_simp_tac +val rfsrw_tac = stateful rev_full_simp_tac + +val let_arith_list = [boolSimps.LET_ss, numSimps.ARITH_ss, listSimps.LIST_ss] +val simp = stateful asm_simp_tac let_arith_list +val dsimp = stateful asm_simp_tac (boolSimps.DNF_ss :: let_arith_list) +val csimp = stateful asm_simp_tac (boolSimps.CONJ_ss :: let_arith_list) +val lrw = srw_tac let_arith_list +val lfs = fsrw_tac let_arith_list +val lrfs = rfsrw_tac let_arith_list + +val rw = srw_tac [] +val fs = fsrw_tac [] +val rfs = rfsrw_tac [] + end diff --git a/src/boss/lcsymtacs.sml b/src/boss/lcsymtacs.sml index d72efc5063..95fefa1c77 100644 --- a/src/boss/lcsymtacs.sml +++ b/src/boss/lcsymtacs.sml @@ -1,18 +1,10 @@ structure lcsymtacs :> lcsymtacs = struct - open Abbrev HolKernel boolLib Tactic Tactical + open Abbrev HolKernel boolLib Tactic Tactical BasicProvers simpLib + open Rewrite bossLib Thm_cont fun kall_tac (_: 'a) : tactic = all_tac - val suff_tac : term -> tactic = Tactic.SUFF_TAC - val var_eq_tac = BasicProvers.VAR_EQ_TAC - - val rewrite_tac : thm list -> tactic = Rewrite.REWRITE_TAC - val once_rewrite_tac : thm list -> tactic = Rewrite.ONCE_REWRITE_TAC - val asm_rewrite_tac : thm list -> tactic = Rewrite.ASM_REWRITE_TAC - val once_asm_rewrite_tac : thm list -> tactic = Rewrite.ONCE_ASM_REWRITE_TAC - - val disch_then = Thm_cont.DISCH_THEN val qx_gen_tac : term quotation -> tactic = Q.X_GEN_TAC val qx_choose_then = Q.X_CHOOSE_THEN @@ -37,57 +29,12 @@ struct val qmatch_goalsub_rename_tac = Q.MATCH_GOALSUB_RENAME_TAC val qcase_tac = Q.FIND_CASE_TAC - val every_case_tac = BasicProvers.EVERY_CASE_TAC - val full_case_tac = BasicProvers.FULL_CASE_TAC - - val spose_not_then : thm_tactic -> tactic = BasicProvers.SPOSE_NOT_THEN - val qabbrev_tac : term quotation -> tactic = Q.ABBREV_TAC val qunabbrev_tac : term quotation -> tactic = Q.UNABBREV_TAC val unabbrev_all_tac : tactic = markerLib.UNABBREV_ALL_TAC - val map_every : ('a -> tactic) -> 'a list -> tactic = Tactical.MAP_EVERY val qx_genl_tac = map_every qx_gen_tac fun qx_choosel_then [] ttac = ttac | qx_choosel_then (q::qs) ttac = qx_choose_then q (qx_choosel_then qs ttac) - val decide_tac : tactic = numLib.DECIDE_TAC - val metis_tac : thm list -> tactic = metisLib.METIS_TAC - val prove_tac : thm list -> tactic = BasicProvers.PROVE_TAC - - val simp_tac = simpLib.SIMP_TAC - val asm_simp_tac = simpLib.ASM_SIMP_TAC - val full_simp_tac = simpLib.FULL_SIMP_TAC - val rev_full_simp_tac = simpLib.REV_FULL_SIMP_TAC - val rw_tac = BasicProvers.RW_TAC - val srw_tac = BasicProvers.SRW_TAC - - fun stateful f ssfl thm : tactic = - let - val ss = List.foldl (simpLib.++ o Lib.swap) (BasicProvers.srw_ss()) ssfl - in - f ss thm - end - - val fsrw_tac = stateful full_simp_tac - val rfsrw_tac = stateful rev_full_simp_tac - - val let_arith_list = [boolSimps.LET_ss, numSimps.ARITH_ss, listSimps.LIST_ss] - val simp = stateful asm_simp_tac let_arith_list - val dsimp = stateful asm_simp_tac (boolSimps.DNF_ss :: let_arith_list) - val csimp = stateful asm_simp_tac (boolSimps.CONJ_ss :: let_arith_list) - val lrw = srw_tac let_arith_list - val lfs = fsrw_tac let_arith_list - val lrfs = rfsrw_tac let_arith_list - - val rw = srw_tac [] - val fs = fsrw_tac [] - val rfs = rfsrw_tac [] - - val op>> = op Tactical.>> - val op\\ = op Tactical.>> - val op>- = op Tactical.>- - val op>| = op Tactical.>| - val op>>> = op Tactical.>>> - end diff --git a/src/simp/src/simpLib.sig b/src/simp/src/simpLib.sig index 410ab58e40..f1f97cd5fb 100644 --- a/src/simp/src/simpLib.sig +++ b/src/simp/src/simpLib.sig @@ -167,10 +167,14 @@ sig * ---------------------------------------------------------------------*) val SIMP_TAC : simpset -> thm list -> tactic + val simp_tac : simpset -> thm list -> tactic val ASM_SIMP_TAC : simpset -> thm list -> tactic + val asm_simp_tac : simpset -> thm list -> tactic val FULL_SIMP_TAC : simpset -> thm list -> tactic + val full_simp_tac : simpset -> thm list -> tactic val REV_FULL_SIMP_TAC : simpset -> thm list -> tactic + val rev_full_simp_tac : simpset -> thm list -> tactic val NO_STRIP_FULL_SIMP_TAC : simpset -> thm list -> tactic val NO_STRIP_REV_FULL_SIMP_TAC : simpset -> thm list -> tactic diff --git a/src/simp/src/simpLib.sml b/src/simp/src/simpLib.sml index e02e88687d..c15edfd452 100644 --- a/src/simp/src/simpLib.sml +++ b/src/simp/src/simpLib.sml @@ -589,11 +589,13 @@ fun SIMP_RULE ss l = CONV_RULE (SIMP_CONV ss l) fun ASM_SIMP_RULE ss l th = SIMP_RULE ss (l@map ASSUME (hyp th)) th; fun SIMP_TAC ss l = markerLib.ABBRS_THEN (CONV_TAC o SIMP_CONV ss) l; +val simp_tac = SIMP_TAC fun ASM_SIMP_TAC ss = markerLib.ABBRS_THEN (fn thl => fn gl as (asl,_) => SIMP_TAC ss (markerLib.LLABEL_RESOLVE thl asl) gl); +val asm_simp_tac = ASM_SIMP_TAC local (* differs only in that it doesn't call OPPOSITE_TAC or DISCARD_TAC *) @@ -620,7 +622,9 @@ local val rev_full_tac = GEN_FULL_SIMP_TAC (drop Lib.I, List.rev) in val FULL_SIMP_TAC = full_tac STRIP_ASSUME_TAC' + val full_simp_tac = FULL_SIMP_TAC val REV_FULL_SIMP_TAC = rev_full_tac STRIP_ASSUME_TAC' + val rev_full_simp_tac = REV_FULL_SIMP_TAC val NO_STRIP_FULL_SIMP_TAC = full_tac caa_tac val NO_STRIP_REV_FULL_SIMP_TAC = rev_full_tac caa_tac end From 39e206bcebcb1836f113a25450833d0726a37b71 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 8 Dec 2015 16:42:18 +1100 Subject: [PATCH 574/718] Adjusting DESCRIPTION's revived section on tactics --- Manual/Description/tactics.tex | 531 +++++++++------------------------ 1 file changed, 137 insertions(+), 394 deletions(-) diff --git a/Manual/Description/tactics.tex b/Manual/Description/tactics.tex index e204a89f77..3c4cf9334f 100644 --- a/Manual/Description/tactics.tex +++ b/Manual/Description/tactics.tex @@ -20,23 +20,11 @@ \chapter{Goal Directed Proof: Tactics and Tacticals} the tactic as a means of organizing the construction of proofs; and the use of tacticals for composing tactics. -Even with recourse to derived inference rules, -it is still surprisingly awkward to work forward, -\index{forward proof!compared to goal directed} to find a chain of -theorems that culminates in a desired theorem. This is in part because -chains have no structure, while `proof efforts' do. For instance, if -within one sequence, two chains of steps -are to be combined in the end by conjunction, then -one chain must follow or be interspersed with -the other in the overall sequence. It can also be difficult to direct -the proof toward its object when starting from -only hypotheses (if any), lemmas (if any), -axioms, and theorems following from no hypotheses -(\eg\ by \ml{ASSUME} or \ml{REFL}). Likewise, it can be equally difficult -to reconstruct -\index{tactics!as documentation of proofs} -the plan of the proof effort after the fact, from the -linear sequence of theorems; the sequence is unhelpful as documentation. +Even with recourse to derived inference rules, it is still surprisingly awkward to work forward, \index{forward proof!compared to goal-directed} to find a chain of theorems that culminates in a desired theorem. +This is in part because chains have no structure, while `proof efforts' do. For instance, if within one sequence, two chains of steps are to be combined in the end by conjunction, then one chain must follow or be interspersed with the other in the overall sequence. +It can also be difficult to direct the proof toward its object when starting from only hypotheses (if any), lemmas (if any), axioms, and theorems following from no hypotheses (\eg,\ by \ml{ASSUME} or \ml{REFL}). +\index{tactics!as documentation of proofs}% +Likewise, it can be equally difficult to reconstruct the plan of the proof effort after the fact, from the linear sequence of theorems; the sequence is unhelpful as documentation. The idea of goal directed proof\index{goal directed proof search!reason for} is a simple one, well known in artificial intelligence: to organize the search\index{proof construction!as tree search} as a tree, and to reverse @@ -72,31 +60,19 @@ \chapter{Goal Directed Proof: Tactics and Tacticals} %from the ones %in Edinburgh \LCF\ \cite{Edinburgh-LCF}). -\section{Tactics, goals and justifications} +\section{Tactics, goals and validations} \label{tactics} \index{goal directed proof search!concepts of|(} -A \emph{tactic}% -\index{proof steps, as ML function applications@proof steps, as \ML{} function applications} -is an \ML{} function that when applied to a \emph{goal} -\index{goals, in HOL system@goals, in \HOL{} system} -reduces it to (i) a list\footnote{The ordering is necessary for selecting -a tree search strategy.} of -(sub)goals, along with (ii) a \emph{justification} -\index{justifications, in goal-directed proof search} -function mapping a list of theorems to a theorem. The idea is that -the function justifies the decomposition of the goal. -%that respectively {\it achieve\/} the (sub)goals -%to a theorem that achieves the goal. -A goal is an \ML{} value whose type is isomorphic -to, but distinct from, the \ML{} abstract type \ml{thm} of theorems. -That is, a goal is -a list of terms ({\it assumptions\/}) -\index{assumption list, of goal} paired with a term. -\index{term component, of goal} +A \emph{tactic}\index{proof steps, as ML function applications@proof steps, as \ML{} function applications} is an \ML{} function that when applied to a \emph{goal}\index{goals, in HOL system@goals, in \HOL{} system} reduces it to +(i) a list\footnote{The ordering is necessary for selecting a tree search strategy.} of (sub)goals, along with +(ii) a \emph{validation}\index{validations, in goal-directed proof search} function mapping a list of theorems to a theorem. +The idea is that this function justifies the decomposition of the goal, and so it is also known as a \emph{justification}. +A goal is an \ML{} value whose type is isomorphic to, but distinct from, the \ML{} abstract type \ml{thm} of theorems. +That is, a goal is a list of terms (\emph{assumptions})\index{assumption list, of goal} paired with a term.\index{term component, of goal} These two components correspond, respectively, to the list of hypotheses -and the conclusion of a theorem. The list of assumptions is a working -record of facts that may be used in decomposing the goal. +and the conclusion of a theorem. +The list of assumptions is a working record of facts that may be used in decomposing the goal. The relation of theorems to goals is achievement: \index{achievement, of goals} @@ -107,53 +83,16 @@ \section{Tactics, goals and justifications} the theorem purporting to satisfy a goal does not depend on assumptions beyond the working assumptions of the goal. -A justification is (rather confusingly) called -a {\it proof\/} -\index{proofs, in HOL logic@proofs, in \HOL{} logic!as ML function applications@as \ML{} function applications} -\index{proof functions (same as justifications, validations)} -in \HOL{}, following the \LCF{} usage; it is, as mentioned, -an \ML{} function -from a theorem list to a theorem. The \ML{} `proof' function -corresponds to a proof -\index{proofs, in HOL logic@proofs, in \HOL{} logic!as generated by tactics} in the -logical sense (of a sequence of theorems depending on inference\index{inferences, in HOL logic@inferences, in \HOL{} logic!in goal-directed proof search} rules) -only in that it must -evaluate the \ML{} function corresponding -to each inference rule on which the sequence depends -in order to compute its \ml{thm}-valued result. (`Justification', or -`validation', -\index{validations} as is sometimes used, are less confusing terms for -the \ML{} function in question.) -The proof function, or justification, returned by a tactic is intended to map the -list of theorems respectively achieving the subgoals to the -theorem achieving the original goal; it justifies the decomposition -into subgoals. - -A tactic is said to {\it solve\/} -\index{solving, of goals} a goal if it reduces the goal to the -empty set of subgoals. -This depends, obviously, on there being at least one -tactic that maps a goal to the empty subgoal list. The simplest -tactic that does this is one that can recognize when a goal is -achieved by an axiom or an existing theorem; in \HOL, the function -\ml{ACCEPT\_TAC}\index{ACCEPT_TAC@\ml{ACCEPT\_TAC}} - does this. \ml{ACCEPT\_TAC} takes a theorem $th$ -and produces a tactic that maps a value -of type \ml{thm} to the empty list of subgoals. It justifies this -`decomposition' by a proof function that maps the empty list of theorems -to the theorem $th$. The use of this technical device, or other -such tactics, ends the decomposition of subgoals, and allows the proof -to be built up.\index{tactics!purpose of|)} - -Unlike theorems, goals need not be defined as an abstract type; they -are transparent and can be constructed freely. Thus, an \ML{} type -abbreviation is introduced for goals.\footnote{However, if goals were - an abstract type, the print abbreviation could be avoided where not - intended.} The operations on goals are therefore just the ordinary -pair selectors and constructor. -Likewise, type abbreviations are introduced for justifications -(proofs) and tactics. Conceptually, the following abbreviations are -made in \HOL: +A tactic is said to \emph{solve}\index{solving, of goals} a goal if it reduces the goal to the empty set of subgoals. +This depends, obviously, on there being at least one tactic that maps a goal to the empty subgoal list. +The simplest tactic that does this is one that can recognize when a goal is achieved by an axiom or an existing theorem; in \HOL, the function \ml{ACCEPT\_TAC}\index{ACCEPT_TAC@\ml{ACCEPT\_TAC}} does this. \ml{ACCEPT\_TAC} takes a theorem $\mathit{th}$ +and produces a tactic that maps a value of type \ml{thm} to the empty list of subgoals. +It justifies this `decomposition' by a validation function that maps the empty list of theorems to the theorem $\mathit{th}$. +The use of this technical device, or other such tactics, ends the decomposition of subgoals, and allows the proof to be built up.\index{tactics!purpose of|)} + +Unlike theorems, goals need not be defined as an abstract type; they are transparent and can be constructed freely. Thus, an \ML{} type abbreviation is introduced for goals. +The operations on goals are therefore just the ordinary pair selectors and constructor. +Likewise, type abbreviations are introduced for validations and tactics. Conceptually, the following abbreviations are made in \HOL: \begin{hol} \index{goal@\ml{goal}} @@ -162,42 +101,20 @@ \section{Tactics, goals and justifications} \index{tactics!ML type of@\ML{} type of} \begin{verbatim} goal = term list * term - tactic = goal -> goal list * proof - proof = thm list -> thm -\end{verbatim}\end{hol} + tactic = goal -> goal list * validation + validation = thm list -> thm +\end{verbatim} +\end{hol} -\index{subgoals@\ml{subgoals}} In fact, the type -\ml{goal~list~*~proof} is abbreviated in \ML{} to \ml{subgoals}, and -the abbreviation of \ml{tactic} made indirectly through it. Thus, if -$T$ is a tactic and $g$ is a goal, then applying $T$ to $g$ (\ie\ -evaluating the \ML\ expression $T\ g$) results in an \ML{} value of -type \ml{subgoals}, \ie\ a pair whose first component is a list of -goals and whose second component has \ML{} type \ml{proof}. (The word -`tactic' is occasionally used loosely to mean a tactic-valued -function.) - -It does not follow, of course, from the type \ml{tactic} that a -particular tactic is well-behaved. For example, -suppose that -$T\ g${\small\verb% = ([%}$g_1${\small\verb%;%}$\ldots -${\small\verb%;%}$g_n${\small\verb%],%}$p${\small\verb%)%}, and that -the subgoals $g_1$ , $\dots$, $g_n$ have been solved. -That means that some -theorems $th_1$ , $\dots$, $th_n$ have been proved -such that each $th_i$ ($1\leq i\leq n$) achieves the goal $g_i$. -The justification $p$ -is intended to be a -function that when applied to the list -{\small\verb%[%}$th_1${\small\verb%;%}$\ldots${\small\verb%;%}$th_n${\small\verb%]%}, -succeeds in returning a theorem, $th$, -achieving the original goal $g$; but, of course, it might sometimes -not succeed. If $p$ -succeeds for every list of achieving theorems, then the tactic $T$ is -said to be {\it valid\/}\index{validity, of tactics|(}. This does not guarantee, however, that -the subgoals are solvable in the first place. If, in addition +It does not follow, of course, from the type \ml{tactic} that a particular tactic is well-behaved. +For example, suppose that $T\ g${\small\verb% = ([%}$g_1${\small\verb%,%}$\ldots ${\small\verb%,%}$g_n${\small\verb%],%}$v${\small\verb%)%}, and that the subgoals $g_1$ , $\dots$, $g_n$ have been solved. +That means that some theorems $\mathit{th}_1$ , $\dots$, $\mathit{th}_n$ have been proved such that each $\mathit{th}_i$ ($1\leq i\leq n$) achieves the goal $g_i$. +The validation $v$ is intended to be a function that when applied to the list {\small\verb%[%}$\mathit{th}_1${\small\verb%,%}$\ldots${\small\verb%,%}$\mathit{th}_n${\small\verb%]%}, succeeds in returning a theorem, $\mathit{th}$, achieving the original goal $g$; but, of course, it might sometimes not succeed. +If $v$ succeeds for every list of achieving theorems, then the tactic $T$ is said to be \emph{valid}\index{validity, of tactics|(}. +This does not guarantee, however, that the subgoals are solvable in the first place. +If, in addition to being valid, a tactic always produces solvable subgoals from a -solvable goal, it is called {\it strongly valid\/}. -\index{strong validity, of tactics} +solvable goal, it is called \emph{strongly valid}.\index{strong validity, of tactics} Tactics can be perfectly useful without being strongly valid, or without @@ -244,20 +161,16 @@ \section{Tactics, goals and justifications} \end{tabular} \end{center} -\noindent For example, the -tactic for decomposing conjunctions into -two conjunct subgoals is called {\small\verb%CONJ_TAC%}. -\index{CONJ_TAC@\ml{CONJ\_TAC}} It is described by: - +\noindent For example, the tactic for decomposing conjunctions into two conjunct subgoals is called {\small\verb%conj_tac%}.\index{conj_tac@\ml{conj\_tac}}\footnote{The tactic is also available under the name \ml{CONJ\_TAC}.} +It is described by: \begin{center} -\begin{tabular}{c} \\ -$ t_1${\small\verb% /\ %}$t_2$ \\ \hline \hline -$t_1\ \ \ \ \ \ \ t_2$ \\ +\begin{tabular}{lcr} +\multicolumn{3}{c}{$t_1 \quad\land\quad t_2$} \\ \hline \hline +$t_1$ & & $t_2$ \end{tabular} \end{center} -\noindent This indicates -that {\small\verb%CONJ_TAC%} reduces a goal of the form +\noindent This indicates that {\small\verb%conj_tac%} reduces a goal of the form {\small\verb%(%}$\Gamma${\small\verb%,%}$t_1${\small\verb%/\%}$t_2${\small\verb%)%} to subgoals {\small\verb%(%}$\Gamma${\small\verb%,%}$t_1${\small\verb%)%} and {\small\verb%(%}$\Gamma${\small\verb%,%}$t_2${\small\verb%)%}. @@ -266,32 +179,26 @@ \section{Tactics, goals and justifications} of assumptions in the notation. The notation gives no indication of the proof function. -Another example is {\small\verb%INDUCT_TAC%}\index{INDUCT_TAC@\ml{INDUCT\_TAC}}\index{induction tactics}, -the tactic for performing mathematical induction -on the natural numbers: +Another example is {\small\verb%numLib.INDUCT_TAC%}\index{INDUCT_TAC@\ml{INDUCT\_TAC}}\index{induction tactics}, a low-level tactic for performing mathematical induction on the natural numbers: \begin{center} -\begin{tabular}{c} \\ -{\small\verb%!%}$n${\small\verb%.%}$t[n]$ \\ \hline \hline -$t[${\small\verb%0%}$]$ {\small\verb% %} $\{t[n]\}\ t[${\small\verb%SUC %}$n]$ +\begin{tabular}{lcr} \\ +\multicolumn{3}{c}{$\forall n.\;t[n]$}\\ \hline \hline +$t[${\small\verb%0%}$]$ & & $\{t[n]\}\ t[${\small\verb%SUC %}$n]$ \end{tabular} \end{center} -{\small\verb%INDUCT_TAC%} reduces a goal of the form -{\small\verb%(%}$\Gamma${\small\verb%,!%}$n${\small\verb%.%}$t[n]${\small\verb%)%} to a basis subgoal +Thus, {\small\verb%INDUCT_TAC%} reduces a goal of the form +{\small\verb%(%}$\Gamma,\forall n.\;t[n]${\small\verb%)%} to a basis subgoal {\small\verb%(%}$\Gamma${\small\verb%,%}$t[${\small\verb%0%}$]${\small\verb%)%} and an induction step subgoal {\small\verb%(%}$\Gamma\cup\{${\small\verb%%}$t[n]${\small\verb%%}$\}${\small\verb%,%}$t[${\small\verb%SUC %}$n]${\small\verb%)%}. -The induction assumption -is indicated in the tactic notation with set brackets. +The induction assumption is indicated in the tactic notation with set brackets. -Tactics fail -\index{failure, of tactics|)} -(in the \ML{} sense) if they are applied to -inappropriate -goals. For example, {\small\verb%CONJ_TAC%} will fail if it is applied to a goal whose -conclusion is not a conjunction. Some tactics never fail; for example -{\small\verb%ALL_TAC%}\index{ALL_TAC@\ml{ALL\_TAC}} +Tactics fail \index{failure, of tactics|)} (in the \ML{} sense) if they are applied to inappropriate goals. +For example, {\small\verb%conj_tac%} will fail if it is applied to a goal whose conclusion is not a conjunction. +Some tactics never fail; for example +{\small\verb%all_tac%}\index{all_tac@\ml{all\_tac}} \begin{center} \begin{tabular}{c} \\ @@ -304,55 +211,48 @@ \section{Tactics, goals and justifications} \index{identity tactic} it reduces a goal {\small\verb%(%}$\Gamma${\small\verb%,%}$t${\small\verb%)%} to the single -subgoal {\small\verb%(%}$\Gamma${\small\verb%,%}$t${\small\verb%)%}---\ie\ -it has no effect. {\small\verb%ALL_TAC%} is useful for writing -compound tactics, as discussed later (see Section~\ref{tacticals}). - -In just the way that the derived rule \ml{REWRITE\_RULE} -\index{REWRITE_TAC@\ml{REWRITE\_TAC}|(} - is central -to forward proof (Section~\ref{sec:rewriting}), the corresponding -function \ml{REWRITE\_TAC} -\index{rewriting!main tactic for|(} -\index{rewriting!importance of, in goal directed proof|(} -is central to goal -directed proof. Given a goal and a list of equational theorems, -\ml{REWRITE\_TAC} transforms the term component of the goal by -applying the equations as left-to-right rewrites, recursively and -to all depths, until no more changes can be made. Unless not -required, the function includes as rewrites the same -standard set of pre-proved tautologies -\index{tautologies, in rewriting tactic} -that \ml{REWRITE\_RULE} uses. +subgoal {\small\verb%(%}$\Gamma${\small\verb%,%}$t${\small\verb%)%}---\ie,\ +it has no effect. +The {\small\verb%all_tac%} tactic is useful for writing +compound tactics, as discussed later~(see Section~\ref{tacticals}). + +In just the way that the derived rule \ml{REWRITE\_RULE}\index{rewrite_tac@\ml{rewrite\_tac}|(} can be used in forward proof (Section~\ref{sec:rewriting}), the corresponding tactic \ml{rewrite\_tac}\index{rewriting!main tactic for|(}\index{rewriting!importance of, in goal directed proof|(} can be used in goal-directed proof. +Given a goal and a list of equational theorems, \ml{rewrite\_tac} transforms the term component of the goal by applying the equations as left-to-right rewrites, recursively and to all depths, until no more changes can be made. +Unless not required, the function includes as rewrites the same standard set of pre-proved tautologies \index{tautologies, in rewriting tactic} that \ml{REWRITE\_RULE} uses. By use of the tautologies, some subgoals can be solved internally by rewriting, and in that case, an empty list of subgoals is returned. The transformation of the goal is justified in each case by the appropriate chain of inferences. -Rewriting often does a large share of the work in goal directed proof searches.\index{goal directed proof search!concepts of|)} -\index{REWRITE_TAC@\ml{REWRITE\_TAC}|)} +Rewriting is a simple implementation of an extremely powerful idea. +The more sophisticated simplification functions~(\eg, \ml{simp}; see Section~\ref{sec:simpLib}) often do a very large share of the work in goal directed proof searches.\index{goal directed proof search!concepts of|)} +\index{rewrite_tac@\ml{rewrite\_tac}|)} +\index{simplification} \index{rewriting!importance of, in goal directed proof|)} \index{rewriting!main tactic for|)} A simple example from list theory (Section~\ref{sec:list}) illustrates the use of tactics. -A conjunctive goal is declared, and \ml{CONJ\_TAC} applied to it: +A conjunctive goal is declared, and \ml{conj\_tac} applied to it: \setcounter{sessioncount}{1} -\begin{session}\begin{verbatim} +\begin{session} +\begin{verbatim} - val g = ([]:term list,``(HD[1;2;3] = 1) /\ (TL[1;2;3] = [2;3])``); > val g = ([], ``(HD[1;2;3] = 1) /\ (TL[1;2;3] = [2;3])``) : term list * term -- val (gl1,p1) = CONJ_TAC g; +- val (gl1,p1) = conj_tac g; > val gl1 = [([], ``HD[1;2;3] = 1``); ([], ``TL[1;2;3] = [2;3]``)] : (term list * term) list val p1 = fn : thm list -> thm -\end{verbatim}\end{session} +\end{verbatim} +\end{session} \noindent The subgoals are each rewritten, using the definitions of \ml{HD} and \ml{TL}: -\begin{session}\begin{verbatim} +\begin{session} +\begin{verbatim} - open listTheory [...] @@ -369,7 +269,8 @@ \section{Tactics, goals and justifications} - val (gl1_2,p1_2) = REWRITE_TAC[HD,TL](hd(tl gl1)); > val gl1_2 = [] : (term list * term) list val p1_2 = fn : thm list -> thm -\end{verbatim}\end{session} +\end{verbatim} +\end{session} \noindent Both of the two subgoals are now solved, so the decomposition is complete and the proof can be built up in stages. @@ -397,12 +298,11 @@ \section{Tactics, goals and justifications} The same proof could be constructed by forward search, starting from the definitions of \ml{HD} and \ml{TL}, but not nearly as easily. -The \HOL{} system provides a collection of pre-defined tactics (and -\ml{tactic}-valued functions) that includes -\ml{CONJ\_TAC}, \ml{INDUCT\_TAC}, \ml{ALL\_TAC} and -\ml{REWRITE\_TAC}. The pre-defined tactics -are adequate for many applications. In addition, there are two means of -defining new tactics. +The \HOL{} system provides a very large collection of pre-defined tactics that includes +\ml{conj\_tac}, \ml{INDUCT\_TAC}, \ml{all\_tac} and +\ml{rewrite\_tac}. +The pre-defined tactics are adequate for many applications. +In addition, there are two means of defining new tactics. \index{tactics!definition of new} Since a tactic\index{proof steps, as ML function applications@proof steps, as \ML{} function applications} is an \ML{} function, the user can define a new tactic directly in \ML. Definitions of this sort @@ -418,13 +318,13 @@ \section{Tactics, goals and justifications} primitive and defined inference rules, and is usually the more difficult part of the project. -A simple example of a tactic written in \ML\index{proofs, in HOL logic@proofs, in \HOL{} logic!as ML function applications@as \ML{} function applications}\ is afforded by \ml{CONJ\_TAC}, +A simple example of a tactic written in \ML\index{proofs, in HOL logic@proofs, in \HOL{} logic!as ML function applications@as \ML{} function applications}\ is afforded by \ml{conj\_tac}, whose definition in \HOL{} is as follows: \begin{hol} -\index{CONJ_TAC@\ml{CONJ\_TAC}!ML implementation of@\ML{} implementation of} +\index{conj_tac@\ML{conj\_tac}!ML implementation of@\ML{} implementation of} \begin{verbatim} - fun CONJ_TAC (asl,w) = + fun conj_tac (asl,w) = let val (l,r) = dest_conj w in ([(asl,l), (asl,r)],(fn [th1, th2] => CONJ th1 th2)) @@ -433,8 +333,7 @@ \section{Tactics, goals and justifications} \end{hol} \noindent This shows how the subgoals are constructed, and how the -proof function is specified in terms of the derived rule \ml{CONJ} -(Section~\ref{sec:conj}). +proof function is specified in terms of the derived rule \ml{CONJ}~(Section~\ref{sec:conj}). The second method is to compose \index{tactics!indirect implementation of}% @@ -448,28 +347,30 @@ \section{Tactics, goals and justifications} \index{sequencing!of tactics}% \index{tactics!sequencing of}% by use of the -tactical \ml{THEN}:\index{THEN@\ml{THEN}} +tactical \ml{>>}\footnote{The \ml{>>} function can also be written as \ml{THEN}.}:\index{THEN@\ml{THEN}}\index{>>@\ml{>>}} if $T_1$ and -$T_2$ are tactics, then the \ML{} expression $T_1${\small\verb% THEN %}$T_2$ +$T_2$ are tactics, then the \ML{} expression $T_1${\small\verb% >> %}$T_2$ evaluates to a tactic that first applies $T_1$ to a goal and then applies -$T_2$ to each subgoal produced by $T_1$. The tactical {\small\verb%THEN%} is +$T_2$ to each subgoal produced by $T_1$. The tactical {\small\verb%>>%} is an infixed \ML{} function. Complex and powerful tactics can be constructed in this way; and new tacticals can also be defined, although this is unusual. The example from earlier -is continued, to illustrate the use of the tactical \ml{THEN}: +is continued, to illustrate the use of the tactical \ml{>>}: -\begin{session}\begin{verbatim} -- val (gl2,p2) = (CONJ_TAC THEN REWRITE_TAC [HD, TL])g; +\begin{session} +\begin{verbatim} +- val (gl2,p2) = (conj_tac >> rewrite_tac [HD, TL])g; > val gl2 = [] : (term list * term) list val p2 = fn : thm list -> thm - p2 []; > val it = |- (HD [1; 2; 3] = 1) /\ (TL [1; 2; 3] = [2; 3]) -\end{verbatim}\end{session} +\end{verbatim} +\end{session} -\noindent The single tactic \ml{CONJ\_TAC THEN REWRITE\_TAC[HD;TL]} +\noindent The single tactic \ml{conj\_tac >> rewrite\_tac[HD;TL]} solves the goal in one single application. The chain of inference computed, however, is exactly the same as in the interactive proof; only the search is different. @@ -487,57 +388,15 @@ \section{Tactics, goals and justifications} \index{tactics!debugging of}% in a variety of ways, and although, as usual, they cannot cause false theorems to appear, the failures can be difficult to understand and -trace.\footnote{A possible extension to \HOL\ would be a `debugging - environment' for this class of tactic.} On the other hand, there are -some proof strategies that cannot be implemented as compositions of -existing tactics, and these have to be implemented directly in \ML. +trace. +On the other hand, there are some proof strategies that cannot be implemented as compositions of existing tactics, and these have to be implemented directly in \ML. Certain sorts of inductions are an example of this; as well as tactics to support some personal styles of proof. -Either sort of tactic can be difficult to apply by hand, as shown in -the examples above. There can be a lot of book-keeping required to -support such an activity. For this reason, most interactive -theorem-proving uses the subgoal or goalstack package described in -Section~\ref{sec:goalstack}. - - -\subsection{Details of proving theorems} -\label{using-tactics} - -When a theorem is proved that the user wishes to preserve for future use, -it can be stored in the current theory -by using the function \ml{save\_thm} (see Section~\ref{theoryprims}). +Either sort of tactic can be difficult to apply by hand, as shown in the examples above. +There can be a lot of book-keeping required to support such an activity. +For this reason, most interactive theorem-proving uses the subgoal or goalstack package described in Section~\ref{sec:goalstack}. -To simplify the use of tactics there are three standard functions - -\index{TAC_PROOF@\ml{TAC\_PROOF}|pin} -\index{prove_thm@\ml{prove\_thm}|pin} -\index{PROVE@\ml{PROVE}|pin} -\begin{holboxed}\begin{verbatim} - TAC_PROOF : (goal * tactic) -> thm - store_thm : (string * term * tactic) -> thm - prove : (term * tactic) -> thm -\end{verbatim}\end{holboxed} - -\noindent \ml{TAC\_PROOF} takes a goal and a tactic, and applies the -tactic to the goal; the goal can have assumptions. Executing -\ml{store\_thm("foo",}$t$\ml{,}$T$\ml{)} proves the goal -\ml{([],}$t$\ml{)} (\ie\ the goal with no assumptions and conclusion -$t$) using tactic $T$ and saves the resulting theorem with name -\ml{foo} in the current theory. Executing -\ml{prove(}$t$\ml{,}$T$\ml{)} proves the goal \ml{([],}$t$\ml{)} using -$T$ and returns the result without saving it. In all cases the -evaluation fails if $T$ does not solve the goal. - -In short, \HOL{} provides a very general framework in which proof -strategies can be designed, implemented, applied and tested. Tactics -range from the very simple to the very advanced; in theory, a -conventional automatic theorem prover could be expressed as a tactic or group -of tactics. In contrast, some users never have need to go beyond the -built in tactics of the system. The vital support that \HOL{} provides -in all cases is the assurance that only theorems of the deductive system -can be represented as theorems of the \HOL{} system---security is -always preserved. \section{Some tactics built into HOL} @@ -549,83 +408,26 @@ \section{Some tactics built into HOL} It should be recalled that the \ML{} type \ml{thm\_tactic} abbreviates \ml{thm->tactic}, and the type \ml{conv} abbreviates \ml{term->thm}. -\subsection{Acceptance of a theorem} - - -\begin{holboxed}\index{ACCEPT_TAC@\ml{ACCEPT\_TAC}|pin} -\begin{verbatim} - ACCEPT_TAC : thm_tactic -\end{verbatim}\end{holboxed} - -\begin{itemize} - -\item{\bf Summary:} {\small\verb%ACCEPT_TAC %}$th$ -is a tactic that solves any goal that is -achieved by $th$. - -\index{forward proof!interfacing to goal directed} -\item{\bf Use:} Incorporating forward proofs, or theorems already -proved, into goal directed proofs. -For example, one might reduce a goal $g$ to -subgoals $g_1$, $\dots$, $g_n$ -using a tactic $T$ and then prove theorems $th_1$ , $\dots$, $th_n$ -respectively achieving -these goals by forward proof. The tactic - -\[\ml{ T THENL[ACCEPT\_TAC }th_1\ml{;}\ldots\ml{;ACCEPT\_TAC }th_n\ml{]} -\] - -would then solve $g$, where \ml{THENL} -\index{THENL@\ml{THENL}} is the tactical that applies -the respective elements of the tactic list to the subgoals produced -by \ml{T} (see Section~\ref{sec:thenl}). - -\end{itemize} - - -\subsection{Adding an assumption} - -\index{ASSUME_TAC@\ml{ASSUME\_TAC}|pin} -\begin{holboxed}\begin{verbatim} - ASSUME_TAC : thm_tactic -\end{verbatim}\end{holboxed} - -\begin{itemize} - -\item {\bf Summary:} {\small\verb%ASSUME_TAC |-%}$u$ adds $u$ as an assumption. -\index{assumptions!tactic for adding} - -\begin{center} -\begin{tabular}{c} \\ -$t$ -\\ \hline \hline -$\{u\}t$ -\\ -\end{tabular} -\end{center} - -\item{\bf Use:} Enriching the assumptions of a goal -with definitions or previously proved theorems. - -\end{itemize} - \subsection{Specialization}\index{universal quantifier, in HOL logic@universal quantifier, in \HOL{} logic!tactics for} -\index{GEN_TAC@\ml{GEN\_TAC}|pin} -\begin{holboxed}\begin{verbatim} - GEN_TAC : tactic -\end{verbatim}\end{holboxed} +\index{gen_tac@\ml{gen\_tac}|pin} +\begin{holboxed} +\begin{verbatim} + gen_tac : tactic +\end{verbatim} +\end{holboxed} -\begin{itemize} +\begin{description} \index{specialization tactic} -\item{\bf Summary:} Specializes a universally quantified -theorem to an arbitrary value. +\item[Summary:] +Specializes a universally quantified theorem to an arbitrary value. +Also available under the name \ml{GEN_TAC}. \begin{center} \begin{tabular}{c} \\ -{\small\verb%!%}$x${\small\verb%.%}$t[x]$ +$\forall{}x${\small\verb%.%}$t[x]$ \\ \hline \hline $t[x']$ \\ @@ -636,26 +438,24 @@ \subsection{Specialization}\index{universal quantifier, in HOL logic@universal q not free in either goal or assumptions. \item{\bf Use:} Solving universally quantified goals. -\ml{GEN\_TAC} is often the first step of a goal directed proof. -{\small\verb%STRIP_TAC%} (see below) -applies {\small\verb%GEN_TAC%} to universally quantified goals. -\end{itemize} +\ml{gen\_tac} is often the first step of a goal directed proof. +{\small\verb%strip_tac%} (see below) +applies {\small\verb%gen_tac%} to universally quantified goals. +\end{description} \subsection{Conjunction} -\index{CONJ_TAC@\ml{CONJ\_TAC}|pin} +\index{conj_tac@\ml{conj\_tac}|pin} \begin{holboxed} \begin{verbatim} - CONJ_TAC : tactic + conj_tac : tactic \end{verbatim} \end{holboxed} -\begin{itemize} +\begin{description} \index{conjunction, in HOL logic@conjunction, in \HOL{} logic!tactic for splitting of} -\item{\bf Summary:} Splits a -goal $t_1${\small\verb%/\%}$t_2$ into two -subgoals, $t_1$ and $t_2$. +\item[Summary:] Splits a goal $t_1\land t_2$ into two subgoals, $t_1$ and $t_2$. \begin{center} \begin{tabular}{c} \\ @@ -666,102 +466,45 @@ \subsection{Conjunction} \end{tabular} \end{center} -\item{\bf Use:} Solving conjunctive goals. -{\small\verb%CONJ_TAC%} is invoked by {\small\verb%STRIP_TAC%} (see below). - -\end{itemize} - -\subsection{Discharging an assumption} -\label{sec:disch} - -\index{implication, in HOL logic@implication, in \HOL{} logic!tactics for} -\index{DISCH_TAC@\ml{DISCH\_TAC}|pin} -\begin{holboxed} -\begin{verbatim} - DISCH_TAC : tactic -\end{verbatim} -\end{holboxed} - -\begin{itemize} - -\item{\bf Summary:} Moves the antecedant -of an implicative goal into the assumptions, leaving the consequent -as the term component. - -\begin{center} -\begin{tabular}{c} \\ -$u${\small\verb% ==> %}$v$ -\\ \hline \hline -$\{u\}v$ -\\ -\end{tabular} -\end{center} - +\item[Use:] Solving conjunctive goals. +{\small\verb%conj_tac%} is also invoked by {\small\verb%strip_tac%} (see below). -\item{\bf Use:} Solving goals of the form -$u${\small\verb% ==> %}$v$ -by assuming $u$ and then solving -$v$ under the assumption. -{\small\verb%STRIP_TAC%} (see below) invokes -{\small\verb%DISCH_TAC%} on implicative goals. -\end{itemize} +\end{description} \subsection{Combined simple decompositions} -\index{STRIP_TAC@\ml{STRIP\_TAC}|pin} +\index{strip_tac@\ml{strip\_tac}|pin} \begin{holboxed} \begin{verbatim} - STRIP_TAC : tactic + strip_tac : tactic \end{verbatim} \end{holboxed} -\begin{itemize} +\begin{description} -\item{\bf Summary:} Breaks a goal apart. -{\small\verb%STRIP_TAC%} removes one outer connective from the goal, using -{\small\verb%CONJ_TAC%}, {\small\verb%DISCH_TAC%}, {\small\verb%GEN_TAC%}, -and other tactics. -If the goal has the form $t_1${\small\verb%/\%}$\cdots${\small\verb%/\%}$t_n${\small\verb% ==> %}$t$ -then {\small\verb%DISCH_TAC%} makes each $t_i$ into a separate assumption. +\item[Summary:] Breaks a goal apart. +The tactic {\small\verb%strip_tac%} removes one outer connective from the goal, using +{\small\verb%conj_tac%}, {\small\verb%gen_tac%}, and other tactics. +If the goal has the form $t_1\land \cdots \land t_n${\small\verb% ==> %}$t$ +then {\small\verb%strip_tac%} makes each $t_i$ into a separate assumption. -\item{\bf Use:} Useful for splitting a goal up into manageable pieces. -Often the best thing to do first is {\small\verb%REPEAT STRIP_TAC%}, -where \ml{REPEAT} is the tactical that repeatedly applies a tactic +\item[Use:] Useful for splitting a goal up into manageable pieces. +Often the best thing to do first is {\small\verb%rpt strip_tac%}, +where \ml{rpt} is the tactical that repeatedly applies a tactic until it fails (see Section~\ref{sec:repeat}). -\end{itemize} - +\end{description} -\subsection{Substitution} - -\index{SUBST_TAC@\ml{SUBST\_TAC}|pin} -\begin{holboxed}\begin{verbatim} - SUBST_TAC : thm list -> tactic -\end{verbatim}\end{holboxed} - -\begin{itemize} - -\item{\bf Summary:} -{\small\verb%SUBST_TAC[|-%}$u_1${\small\verb%=%}$v_1${\small\verb%;%}$\ldots${\small\verb%;|-%}$u_n${\small\verb%=%}$v_n${\small\verb%]%} -changes\index{substitution, tactic for} each sub-term -$t[u_1,\ldots ,u_n]$ of the goal to -$t[v_1,\ldots ,v_n]$ -by substitution. - -\item{\bf Use:} -Useful in situations where {\small\verb%REWRITE_TAC%} -\index{REWRITE_TAC@\ml{REWRITE\_TAC}} does too much, -or would loop. -\end{itemize} - \subsection{Case analysis on a boolean term} \index{case analysis, in HOL logic@case analysis, in \HOL{} logic!tactics for|(} \index{ASM_CASES_TAC@\ml{ASM\_CASES\_TAC}|(} -\begin{holboxed}\begin{verbatim} +\begin{holboxed} +\begin{verbatim} ASM_CASES_TAC : term -> tactic -\end{verbatim}\end{holboxed} +\end{verbatim} +\end{holboxed} \begin{itemize} From 8ef596ccc1a502b475260bcf4dec07126adb2f42 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 14 Dec 2015 17:09:32 +1100 Subject: [PATCH 575/718] More hacking at Description's Tactics chapter --- Manual/Description/tactics.tex | 139 +++++++++++++-------------------- Manual/LaTeX/commands.tex | 1 + 2 files changed, 54 insertions(+), 86 deletions(-) diff --git a/Manual/Description/tactics.tex b/Manual/Description/tactics.tex index 3c4cf9334f..d86d458edf 100644 --- a/Manual/Description/tactics.tex +++ b/Manual/Description/tactics.tex @@ -496,91 +496,63 @@ \subsection{Combined simple decompositions} -\subsection{Case analysis on a boolean term} +\subsection{Case analysis} \index{case analysis, in HOL logic@case analysis, in \HOL{} logic!tactics for|(} -\index{ASM_CASES_TAC@\ml{ASM\_CASES\_TAC}|(} +\index{Cases_on@\ml{Cases\_on}|(} \begin{holboxed} \begin{verbatim} - ASM_CASES_TAC : term -> tactic + Cases_on : term quotation -> tactic \end{verbatim} \end{holboxed} \begin{itemize} -\item{\bf Summary:} \ml{ASM\_CASES\_TAC} $u$ , where $u$ is a -boolean-valued term, does case analysis on $u$. +\item{\bf Summary:} +\ml{Cases\_on}~$q$, where $q$ is a quotation denoting a term of an algebraic type (\eg, booleans, lists, natural numbers, types defined by the user with \ml{Datatype}), does case analysis on that term. +Let the relevant type have $m$ constructors $\textsf{C}_1$ to $\textsf{C}_m$, where $\textsf{C}_i$ has $n_i$ arguments. +If the term is a variable, then the variable is substituted out of the goal entirely: \begin{center} \begin{tabular}{c} \\ $t$ \\ \hline \hline -$\{u\}t\ \ \ \ \ \{${\small\verb%~%}$u\}t$ +$t[q := \textsf{C}_1\,a_{11}\cdots a_{1n_1}]\quad\cdots\quad +t[q := \textsf{C}_m\,a_{m1}\cdots a_{mn_m}]$ \\ \end{tabular} \end{center} -\item{\bf Use:} Case analysis. -\end{itemize} -\index{ASM_CASES_TAC@\ml{ASM\_CASES\_TAC}|)} - -\subsection{Case analysis on a disjunction} - - -\begin{holboxed} -\index{DISJ_CASES_TAC@\ml{DISJ\_CASES\_TAC}|pin} -\index{disjunction, in HOL logic@disjunction, in \HOL{} logic!tactic for case splits on} -\begin{verbatim} - DISJ_CASES_TAC : thm_tactic -\end{verbatim}\end{holboxed} - -\begin{itemize} - -\item{\bf Summary:} -{\small\verb%DISJ_CASES_TAC |- %}$u${\small\verb% \/ %}$v$ -splits a goal into two cases: one with $u$ -as an assumption -and the other with $v$ as an assumption. - +If the term denoted by $q$ is not simply a variable (\eg, \ml{Cases\_on`n~+~1`}), then fresh assumptions are introduced: \begin{center} \begin{tabular}{c} \\ $t$ \\ \hline \hline -$\{u\}t\ \ \ \ \ \{v\}t$ +$\{q := \textsf{C}_1\,a_{11}\cdots a_{1n_1}\}t\quad\cdots\quad +\{q := \textsf{C}_m\,a_{m1}\cdots a_{mn_m}\}t$ \\ \end{tabular} \end{center} - -\item{\bf Use:} Case analysis. The -tactic {\small\verb%ASM_CASES_TAC%} is defined in \ML{} by - -{\small\begin{verbatim} - let ASM_CASES_TAC t = DISJ_CASES_TAC(SPEC t EXCLUDED_MIDDLE) -\end{verbatim}} - - -\noindent where {\small\verb%EXCLUDED_MIDDLE%} is -the theorem {\small\verb%|- !t. t \/ ~t%}. - +\item{\bf Use:} Case analysis. \end{itemize} -\index{case analysis, in HOL logic@case analysis, in \HOL{} logic!tactics for|)} +\index{Cases_on@\ml{Cases\_on}|)} \subsection{Rewriting} \label{rewrite} \index{rewriting!main tactic for|(} \begin{holboxed} -\index{REWRITE_TAC@\ml{REWRITE\_TAC}|pin} +\index{rewrite_tac@\ml{rewrite\_tac}|pin} \begin{verbatim} - REWRITE_TAC : thm list -> tactic -\end{verbatim}\end{holboxed} - - + rewrite_tac : thm list -> tactic +\end{verbatim} +\end{holboxed} \begin{itemize} -\item{\bf Summary:} {\small\verb%REWRITE_TAC[%}$th_1${\small\verb%;%}$\ldots${\small\verb%;%}$th_n${\small\verb%]%} +\item{\bf Summary:} {\small\verb%rewrite_tac[%}$th_1${\small\verb%,%}$\ldots${\small\verb%,%}$th_n${\small\verb%]%} transforms the term part of a goal by rewriting it with the given theorems $th_1$, $\dots$, $th_n$, and the set of pre-proved standard tautologies\index{tautologies, in rewriting tactic}. +Also written \ml{REWRITE\_TAC}. \begin{center} @@ -595,21 +567,21 @@ \subsection{Rewriting} \noindent where $t'$ is obtained from $t$ as described. \item{\bf Use:} Advancing goals by using definitions and -previously proved theorems (lemmas).\index{lemmas} +previously proved theorems. -\item{\bf Some other rewriting tactics} (based on {\small\verb%REWRITE_TAC%}) are: +\item{\bf Some other rewriting tactics} (based on \ml{rewrite\_tac}) are: \begin{enumerate} -\item {\small\verb%ASM_REWRITE_TAC%}\index{ASM_REWRITE_TAC@\ml{ASM\_REWRITE\_TAC}} - adds the assumptions of the goal to the list of -theorems used for rewriting. +\item {\small\verb%asm_rewrite_tac%}\index{asm_rewrite_tac@\ml{asm\_rewrite\_tac}} adds the assumptions of the goal to the list of theorems used for rewriting. +Also written \ml{ASM\_REWRITE\_TAC}. + \index{PURE_ASM_REWRITE_TAC@\ml{PURE\_ASM\_REWRITE\_TAC}} -\item {\small\verb%PURE_ASM_REWRITE_TAC%} is like {\small\verb%ASM_REWRITE_TAC%}, but it +\item {\small\verb%PURE_ASM_REWRITE_TAC%} is like {\small\verb%asm_rewrite_tac%}, but it doesn't use any built-in rewrites. \index{PURE_REWRITE_TAC@\ml{PURE\_REWRITE\_TAC}} \item {\small\verb%PURE_REWRITE_TAC%} uses neither the assumptions nor the built-in rewrites. \index{FILTER_ASM_REWRITE_TAC@\ml{FILTER\_ASM\_REWRITE\_TAC}} -\item {\small\verb%FILTER_ASM_REWRITE_TAC %}$p${\small\verb% [%}$th_1${\small\verb%;%}$\ldots${\small\verb%;%}$th_n${\small\verb%]%} +\item {\small\verb%FILTER_ASM_REWRITE_TAC %}$p${\small\verb% [%}$th_1${\small\verb%,%}$\ldots${\small\verb%,%}$th_n${\small\verb%]%} simplifies the goal by rewriting it with the explicitly given theorems $th_1$ , $\dots$, $th_n$ , together with those @@ -617,6 +589,9 @@ \subsection{Rewriting} the standard rewrites. \end{enumerate} + +See also the more powerful simplification tactics described in Section~\ref{sec:simpLib}. + \end{itemize} \index{rewriting!main tactic for|)} @@ -625,21 +600,19 @@ \subsection{Rewriting} \subsection{Resolution by Modus Ponens} \index{implication, in HOL logic@implication, in \HOL{} logic!tactics for} -\index{IMP_RES_TAC@\ml{IMP\_RES\_TAC}|pin} -\begin{holboxed}\begin{verbatim} - IMP_RES_TAC : thm -> tactic -\end{verbatim}\end{holboxed} +\index{imp_res_tac@\ml{imp\_res\_tac}|pin} +\begin{holboxed} +\begin{verbatim} + imp_res_tac : thm -> tactic +\end{verbatim} +\end{holboxed} \begin{itemize} \index{resolution tactics} -\item{\bf Summary:} {\small\verb%IMP_RES_TAC %}$th$ does a limited amount of -automated theorem proving in the form of forward inference; it -`resolves' the theorem $th$ with the -assumptions of the goal -and adds any new results to the assumptions. The specification for -\ml{IMP\_RES\_TAC} is: - +\item{\bf Summary:} +\ml{imp\_res\_tac}~$th$ does a limited amount of automated theorem proving in the form of forward inference; it `resolves' the theorem $th$ with the assumptions of the goal and adds any new results to the assumptions. +The specification for \ml{imp\_res\_tac} is: \begin{center} \begin{tabular}{c} \\ @@ -650,30 +623,23 @@ \subsection{Resolution by Modus Ponens} \end{tabular} \end{center} -\noindent where $u_1$, $\dots$, $u_n$ -are derived by `resolving' the theorem $th$ with the existing assumptions -$t_1$, $\dots$, $t_m$. -Resolution in \HOL{} is not classical resolution, but just Modus Ponens with -one-way pattern matching (not unification) and term and type instantiation. The -general case is where $th$ is of the canonical form +\noindent where $u_1$, $\dots$, $u_n$ are derived by `resolving' the theorem $th$ with the existing assumptions $t_1$, $\dots$, $t_m$. +Resolution in \HOL{} is not classical resolution, but just Modus Ponens with one-way pattern matching (not unification) and term and type instantiation. +The general case is where $th$ is of the canonical form $\ \ \ ${\small\verb%|- !%}$x_1$$\ldots x_p${\small\verb%.%}$v_1$ {\small\verb%==>%} $v_2$ {\small\verb%==>%} $\ldots$ {\small\verb%==>%} $v_q$ {\small\verb%==>%} $v$ -\noindent {\small\verb%IMP_RES_TAC %}$th$ then tries to specialize $x_1$, -$\dots$, $x_p$ in succession so that $v_1$, $\dots$, $v_q$ match members of -$\{t_1,\ldots ,t_m\}$. Each time a match is found for some antecedent $v_i$, -for $i$ successively equal to $1$, $2$, \dots, $q$, a term and type -instantiation is made and the rule of Modus Ponens is applied. If all the -antecedents $v_i$ (for $1 \leq i \leq q$) can be dismissed in this way, then -the appropriate instance of $v$ is added to the assumptions. Otherwise, if only -some initial sequence $v_1$, \dots, $v_k$ (for some $k$ where $1 < k < q$) of -the assumptions can be dismissed, then the remaining implication: +\noindent +\ml{imp\_res\_tac}~$th$ then tries to specialize $x_1$, $\dots$, $x_p$ in succession so that $v_1$, $\dots$, $v_q$ match members of $\{t_1,\ldots ,t_m\}$. +Each time a match is found for some antecedent $v_i$, for $i$ successively equal to $1$, $2$, \dots, $q$, a term and type instantiation is made and the rule of Modus Ponens is applied. +If all the antecedents $v_i$ (for $1 \leq i \leq q$) can be dismissed in this way, then the appropriate instance of $v$ is added to the assumptions. +Otherwise, if only some initial sequence $v_1$, \dots, $v_k$ (for some $k$ where $1 < k < q$) of the assumptions can be dismissed, then the remaining implication: $\ \ \ ${\small\verb%|- %} $v_{k+1}$ {\small\verb%==>%} $\ldots$ {\small\verb%==>%} $v_q$ {\small\verb%==>%} $v$ \noindent is added to the assumptions. -For a more detailed description of resolution and \ml{IMP\_RES\_TAC}, see +For a more detailed description of resolution and \ml{imp\_res\_tac}, see \REFERENCE. (See also the Cambridge \LCF\ Manual \cite{new-LCF-man}.) \item{\bf Use:} Deriving new results from a previously proved implicative @@ -687,10 +653,10 @@ \subsection{Resolution by Modus Ponens} \subsection{Identity} -\index{ALL_TAC@\ml{ALL\_TAC}|pin} +\index{all_tac@\ml{all\_tac}|pin} \begin{holboxed} \begin{verbatim} - ALL_TAC : tactic + all_tac : tactic \end{verbatim} \end{holboxed} @@ -703,9 +669,10 @@ \subsection{Identity} \item{\bf Use:} \begin{enumerate} \index{REPEAT@\ml{REPEAT}} -\item Writing tacticals (see description of {\small\verb%REPEAT%} -in Section~\ref{tacticals}). +\index{rpt@\ml{rpt}} +\item Writing tacticals (see description of \ml{rpt} in Section~\ref{tacticals}). \index{THENL@\ml{THENL}} +\index{>{"|}@\ml{\gt\pipe}~(\ml{THENL})} \item With {\small\verb%THENL%} (see Section~\ref{sec:thenl}); for example, if tactic $T$ produces two subgoals $T_1$ is to be applied to the first while diff --git a/Manual/LaTeX/commands.tex b/Manual/LaTeX/commands.tex index ed2a9f0b5f..ce132c9742 100644 --- a/Manual/LaTeX/commands.tex +++ b/Manual/LaTeX/commands.tex @@ -22,6 +22,7 @@ \newcommand{\lt}{\texttt{\char'74}} % less than \newcommand{\gt}{\texttt{\char'76}} % greater than \newcommand{\dol}{\texttt{\char'44}} % dollar +\newcommand{\pipe}{\texttt{\char'174}} \newcommand{\apost}{\texttt{\textquotesingle}} % double back quotes `` \newcommand{\dq}{\texttt{\char'140\char'140}} From d0a11f5e940cbf8b5f82f53846da7b7af537931e Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 30 Dec 2015 20:35:37 +1300 Subject: [PATCH 576/718] Adjust installation instructions a little. From comments in github issue #324: * tell users not to use the --with-portable option when building Poly/ML * make it clear that the system installs "in place", and that once build has done its thing, the system can't be moved. Closes #324 --- INSTALL | 7 +++++++ Manual/Tutorial/intro.tex | 5 +++++ 2 files changed, 12 insertions(+) diff --git a/INSTALL b/INSTALL index ffe5ff9dc9..d9aaa25557 100644 --- a/INSTALL +++ b/INSTALL @@ -75,6 +75,8 @@ A. [Moscow ML:] First, install Moscow ML. This is usually ./configure --enable-shared + Do not use the --with-portable option. + B. Unpack HOL with the commands gunzip release.tar.gz; tar xf release.tar @@ -163,6 +165,11 @@ E. If bin/build completes (it takes a while!), successfully, you are On Windows the hol scripts additionally include a .bat extension, and Holmake has a .exe extension. + At this point, the system is build in and cannot easily + be moved to other locations. In other words, you should unpack HOL + in the location/directory where you wish to access it for all your + future work. + External tools -------------- diff --git a/Manual/Tutorial/intro.tex b/Manual/Tutorial/intro.tex index acd3abae9f..96ea8abcca 100644 --- a/Manual/Tutorial/intro.tex +++ b/Manual/Tutorial/intro.tex @@ -103,6 +103,7 @@ \section{Installing \HOL{}} \begin{verbatim} ./configure --enable-shared \end{verbatim} +Do not use the \texttt{--with-portable} option. When you have your ML system installed, and are in the root directory of the distribution, the next step is to run \texttt{smart-configure}. With Moscow~ML, this looks like: @@ -158,6 +159,10 @@ \section{Installing \HOL{}} \end{alltt} \end{session} +At this point, the system is build in your HOL directory, and cannot easily be moved to other locations. +In other words, you should unpack HOL in the location/directory where you wish to access it for all your future work. + + \subsection{Overriding \texttt{smart-configure}} \label{sec:editting-configure} From ed8f0afe18bbc555585f804fc06e07b212bc0c9c Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 30 Dec 2015 20:57:00 +1300 Subject: [PATCH 577/718] More work on Tactics chapter of Description --- Manual/Description/tactics.tex | 586 ++++++++++++--------------------- 1 file changed, 204 insertions(+), 382 deletions(-) diff --git a/Manual/Description/tactics.tex b/Manual/Description/tactics.tex index d86d458edf..bbe96d9117 100644 --- a/Manual/Description/tactics.tex +++ b/Manual/Description/tactics.tex @@ -347,7 +347,7 @@ \section{Tactics, goals and validations} \index{sequencing!of tactics}% \index{tactics!sequencing of}% by use of the -tactical \ml{>>}\footnote{The \ml{>>} function can also be written as \ml{THEN}.}:\index{THEN@\ml{THEN}}\index{>>@\ml{>>}} +tactical \ml{>>}\footnote{The \ml{>>} function can also be written as \ml{THEN}.}:\index{THEN@\ml{THEN}} if $T_1$ and $T_2$ are tactics, then the \ML{} expression $T_1${\small\verb% >> %}$T_2$ evaluates to a tactic that first applies $T_1$ to a goal and then applies @@ -547,8 +547,8 @@ \subsection{Rewriting} rewrite_tac : thm list -> tactic \end{verbatim} \end{holboxed} -\begin{itemize} -\item{\bf Summary:} {\small\verb%rewrite_tac[%}$th_1${\small\verb%,%}$\ldots${\small\verb%,%}$th_n${\small\verb%]%} +\begin{description} +\item[Summary:] {\small\verb%rewrite_tac[%}$th_1${\small\verb%,%}$\ldots${\small\verb%,%}$th_n${\small\verb%]%} transforms the term part of a goal by rewriting it with the given theorems $th_1$, $\dots$, $th_n$, and the set of pre-proved standard tautologies\index{tautologies, in rewriting tactic}. @@ -566,11 +566,11 @@ \subsection{Rewriting} \noindent where $t'$ is obtained from $t$ as described. -\item{\bf Use:} Advancing goals by using definitions and +\item[Use:] Advancing goals by using definitions and previously proved theorems. -\item{\bf Some other rewriting tactics} (based on \ml{rewrite\_tac}) are: +\item[Other rewriting tactics] (based on \ml{rewrite\_tac}) are: \begin{enumerate} \item {\small\verb%asm_rewrite_tac%}\index{asm_rewrite_tac@\ml{asm\_rewrite\_tac}} adds the assumptions of the goal to the list of theorems used for rewriting. Also written \ml{ASM\_REWRITE\_TAC}. @@ -592,7 +592,7 @@ \subsection{Rewriting} See also the more powerful simplification tactics described in Section~\ref{sec:simpLib}. -\end{itemize} +\end{description} \index{rewriting!main tactic for|)} @@ -607,10 +607,10 @@ \subsection{Resolution by Modus Ponens} \end{verbatim} \end{holboxed} -\begin{itemize} +\begin{description} \index{resolution tactics} -\item{\bf Summary:} +\item[Summary:] \ml{imp\_res\_tac}~$th$ does a limited amount of automated theorem proving in the form of forward inference; it `resolves' the theorem $th$ with the assumptions of the goal and adds any new results to the assumptions. The specification for \ml{imp\_res\_tac} is: @@ -642,11 +642,11 @@ \subsection{Resolution by Modus Ponens} For a more detailed description of resolution and \ml{imp\_res\_tac}, see \REFERENCE. (See also the Cambridge \LCF\ Manual \cite{new-LCF-man}.) -\item{\bf Use:} Deriving new results from a previously proved implicative +\item[Use:] Deriving new results from a previously proved implicative theorem, in combination with the current assumptions, so that subsequent tactics can use these new results. -\end{itemize} +\end{description} @@ -663,72 +663,51 @@ \subsection{Identity} \begin{itemize} \index{identity tactic}\index{tactics!identity for} \index{THEN@\ml{THEN}} -\item{\bf Summary:} The identity tactic for the tactical {\small\verb%THEN%} -(see Section~\ref{tactics}). Useful for writing tactics. +\item{\bf Summary:} The identity tactic for the tactical \ml{\gt\gt} (see the example in Section~\ref{tactics}, and Section~\ref{sec:sequencing-tacticals}). Useful for writing tactics. \item{\bf Use:} \begin{enumerate} \index{REPEAT@\ml{REPEAT}} -\index{rpt@\ml{rpt}} \item Writing tacticals (see description of \ml{rpt} in Section~\ref{tacticals}). \index{THENL@\ml{THENL}} -\index{>{"|}@\ml{\gt\pipe}~(\ml{THENL})} -\item With {\small\verb%THENL%} (see Section~\ref{sec:thenl}); -for example, if tactic $T$ produces two subgoals -$T_1$ is to be applied to the first while -nothing is to be done to the second, -then $T${\small\verb% THENL[%}$T_1${\small\verb%;ALL_TAC]%} is the +\index{>{"|}@\ml{\gt\pipe}|see{\ml{THENL}}} +\item +With \ml{THENL} (see Section~\ref{sec:thenl}); for example, if tactic $T$ produces two subgoals and $T_1$ is to be applied to the first while nothing is to be done to the second, then $T\;\ml{THENL}\;[T_1,\,\ml{all\_tac}]$ is the tactic required. \end{enumerate} \end{itemize} -\subsection{Null} - -\index{NO_TAC@\ml{NO\_TAC}|pin} -\begin{holboxed} -\begin{verbatim} - NO_TAC : tactic -\end{verbatim} -\end{holboxed} - -\begin{itemize} -\item{\bf Summary:} Tactic that always fails. - -\item{\bf Use:} Writing tacticals. -\end{itemize} - - \subsection{Splitting logical equivalences} \begin{holboxed} -\index{EQ_TAC@\ml{EQ\_TAC}|pin} +\index{eq_tac@\ml{eq\_tac}|pin} \index{equality, in HOL logic@equality, in \HOL{} logic!tactic for splitting} \begin{verbatim} - EQ_TAC : tactic -\end{verbatim}\end{holboxed} + eq_tac : tactic +\end{verbatim} +\end{holboxed} \begin{itemize} \item{\bf Summary:} -{\small\verb%EQ_TAC%} -splits an equational goal into two implications (the `if-case' and -the `only-if' case): +\ml{eq_tac} splits an equational goal into two implications (the `if-case' and the `only-if' case): \begin{center} - - - \begin{tabular}{c} \\ -$u\ \ml{=}\ v$ +$u \iff v$ \\ \hline \hline -$u\ \ml{==>}\ v\ \ \ \ \ v\ \ml{==>}\ u$ +$u\ \Rightarrow\ v \qquad v\ \Rightarrow\ u$ \\ \end{tabular} \end{center} -\item{\bf Use:} Proving logical equivalences, \ie\ goals of the form -``$u$\ml{=}$v$'' where $u$ and $v$ are boolean terms. +\item{\bf Use:} +Proving logical equivalences, \ie\ goals of the form ``$u\iff v$'' where $u$ and $v$ are boolean terms. +Note that the same end can often be achieved by rewriting with the theorem \ml{EQ\_IMP\_THM}, which states +\[ +\vdash (u \iff v) \iff (u \Rightarrow v) \land (v \Rightarrow u) +\] \end{itemize} @@ -740,18 +719,18 @@ \subsection{Solving existential goals} \index{existential quantifier, in HOL logic@existential quantifier, in \HOL{} logic!tactic for} \begin{verbatim} EXISTS_TAC : term -> tactic -\end{verbatim}\end{holboxed} +\end{verbatim} +\end{holboxed} \begin{itemize} \item{\bf Summary:} -{\small\verb%EXISTS_TAC "%}$u${\small\verb%"%} -reduces an existential goal {\small\verb%!%}$x${\small\verb%. %}$t[x]$ -to the subgoal $t[u]$. +$\ml{EXISTS\_TAC}\;u$ reduces an existential goal $\exists x.\;t[x]$ to the subgoal $t[u]$. +(In ASCII form, the existential is printed as a question mark.) \begin{center} \begin{tabular}{c} \\ -$\ml{!}x\ml{.} t[x]$ +$\ml{?}x\ml{.} t[x]$ \\ \hline \hline $t[u]$ \\ @@ -760,15 +739,6 @@ \subsection{Solving existential goals} \item{\bf Use:} Proving existential goals. -\item{\bf Comment:} \ml{EXISTS\_TAC} is a crude way of solving -existential goals, but it is the only built-in tactic for this -purpose. A more powerful approach uses Prolog-style `logic variables' -(\ie\ meta-variables) -that can be progressively refined towards the eventual witness. -Implementing this requires goals to contain an environment giving the binding -of logic variables to terms. Details (in the context of \LCF) are given -in a paper by Stefan Soko\l owski \cite{Stefan}. - \end{itemize} \index{tactics!list of some|)} @@ -853,186 +823,32 @@ \subsection{Change detection} \subsection{Sequencing} +\label{sec:sequencing-tacticals} \index{sequencing!of tactics|(} \index{tacticals!for sequencing|(} \index{tactics!sequencing of|(} -\index{THEN@\ml{THEN}!ML implementation of@\ML{} implementation of|(} +\index{THEN@\ml{THEN}} +\index{>>@\ml{\gt\gt}|see{\ml{THEN}}} -\begin{holboxed}\index{THEN@\ml{THEN}|pin} +\begin{holboxed} \begin{verbatim} THEN : tactic -> tactic -> tactic -\end{verbatim}\end{holboxed} - - -The tactical {\small\verb%THEN%} is an \ML{} infix. If $T_1$ and $T_2$ are tactics, -then the \ML{} expression $T_1${\small\verb% THEN %}$T_2$ evaluates to a tactic -which first applies $T_1$ and then applies $T_2$ to each subgoal produced by -$T_1$. Its definition - in \ML{} is complex (and due to Milner)\index{Milner, R.} but worth -understanding as an exercise in \ML. It is an \ML{} curried infix. - -\begin{hol}\begin{verbatim} - let ((T1:tactic) THEN (T2:tactic)) g = - let gl,p = T1 g - in - let gll,pl = split(map T2 gl) - in - (flat gll, (p o mapshape(map length gll)pl));; -\end{verbatim}\end{hol} - -\noindent Here are -the definitions of the \ML{} functions \ml{map}, \ml{split}, \ml{o}, -\ml{length}, \ml{flat} and \ml{mapshape}: - -%\begin{itemize} -\bigskip - -\index{map@\ml{map}} -{\small\verb%map : (* -> **) -> * list -> ** list%} - -\medskip - -\begin{hol}\begin{alltt} - map \(f\) [\(x\sb{1}\);\(\ldots\);\(x\sb{n}\)] = [\(f\) \(x\sb{1}\);\(\ldots\);\(f\) \(x\sb{n}\)] -\end{alltt}\end{hol} - -\medskip - -\index{split@\ml{split}} -{\small\verb%split : (* # **) list -> (* list # ** list)%} - -\medskip - -\begin{hol}\begin{alltt}\ split[(\(x\sb{1}\),\(y\sb{1}\));\(\ldots\);(\(x\sb{n}\),\(y\sb{n}\))] = ([\(x\sb{1}\);\(\ldots\);\(x\sb{n}\)],[\(y\sb{1}\);\(\ldots\);\(y\sb{n}\)]) -\end{alltt}\end{hol} - - -\medskip - -{\small\verb%$o : ((* -> **) # (*** -> *)) -> *** -> **$%} - (an infix)\index{function composition, in ML@function composition, in \ML} - -\medskip - -\begin{hol} -\begin{alltt} - (\(f\) o \(g\)) \(x\) = \(f\)(\(g\) \(x\)) -\end{alltt}\end{hol} -\index{ function composition operator, in ML@{\small\verb+o+} (function composition operator, in \ML)} - -\medskip - -\index{length@\ml{length}} -{\small\verb%length : * list -> int%} - -\medskip - -\begin{hol}\begin{alltt} - length[\(x\sb{1}\);\(\ldots\);\(x\sb{n}\)] = n -\end{alltt}\end{hol} - -\medskip - - -{\small\verb%flat : (* list) list -> * list%}\index{flat@\ml{flat}} - - -\medskip - -\begin{hol}\begin{alltt} - flat[[\({x\sb{1}}\sb{1}\);\(\ldots\);\({x\sb{1}}\sb{m\sb{1}}\)];[\({x\sb{2}}\sb{1}\);\(\ldots\);\({x\sb{2}}\sb{m\sb{2}}\)];\(\ldots\);[\({x\sb{n}}\sb{1}\);\(\ldots\);\({x\sb{n}}\sb{m\sb{n}}\)]] = - [\({x\sb{1}}\sb{1}\);\(\ldots\);\({x\sb{1}}\sb{m\sb{1}}\);\({x\sb{2}}\sb{1}\);\(\ldots\);\({x\sb{2}}\sb{m\sb{2}}\); \(\ldots\) ;\({x\sb{n}}\sb{1}\);\(\ldots\);\({x\sb{n}}\sb{m\sb{n}}\)] -\end{alltt}\end{hol} - -\medskip - -{\small\verb%mapshape : int list -> (* list -> **) list -> * list -> ** list%}\index{mapshape@\ml{mapshape}} - - -\medskip - -\begin{hol}\begin{alltt} - mapshape - [\(m\sb{1}\);\(\ldots\);\(m\sb{n}\)] - [\(f\sb{1}\);\(\ldots\);\(f\sb{n}\)] - [\({x\sb{1}}\sb{1}\);\(\ldots\);\({x\sb{1}}\sb{m\sb{1}}\);\({x\sb{2}}\sb{1}\);\(\ldots\);\({x\sb{2}}\sb{m\sb{2}}\); \(\ldots\) ;\({x\sb{n}}\sb{1}\);\(\ldots\);\({x\sb{n}}\sb{m\sb{n}}\)] = - [\(f\sb{1}\)[\({x\sb{1}}\sb{1}\);\(\ldots\);\({x\sb{1}}\sb{m\sb{1}}\)];\(f\sb{2}\)[\({x\sb{2}}\sb{1}\);\(\ldots\);\({x\sb{2}}\sb{m\sb{2}}\)]; \(\ldots\) ;\(f\sb{n}\)[\({x\sb{n}}\sb{1}\);\(\ldots\);\({x\sb{n}}\sb{m\sb{n}}\)]] -\end{alltt}\end{hol} - -%\end{itemize} - -\bigskip - -Suppose \ml{$T_1\ g$ = ($gl$,$p$)} where \ml{$gl$=[$g_1$;$\ldots$;$g_n$]}. -Suppose also that -for $i$ between $1$ and $n$ it is the case that -\ml{$T_2\ g_i$ = ([${g_i}_1$;$\ldots$;${g_i}_{m_i}$],$p_i$)}. -Then \ml{split(map $T_2$ $gl$)} will evaluate to the -pair \ml{($gll$,$pl$)} of a subgoal list and a proof function, where - -\bigskip - -\ml{$gll$ = [[${g_1}_1$;$\ldots$;${g_1}_{m_1}$];[${g_2}_1$;$\ldots$;${g_2}_{m_2}$]; -$\ \ldots\ $;[${g_n}_1$;$\ldots$;${g_n}_{m_n}$]]} - -\bigskip - -\noindent and -\ml{$pl$ = [$p_1$;$\ldots$;$p_n$]}. Note that - -\bigskip - -\ml{map length $gll$ = [$m_1$;$\ldots$;$m_n$]} - -\bigskip - -\noindent and that - -\bigskip - -\ml{flat $gll$ = [${g_1}_1$;$\ldots$;${g_1}_{m_1}$;${g_2}_1$;$\ldots$;${g_2}_{m_2}$; -$\ \ldots\ $;${g_n}_1$;$\ldots$;${g_n}_{m_n}$]} - -\bigskip - -Suppose now that, for $i$ between $1$ and $n$, the theorems -${th_i}_1$, $\dots$, ${th_i}_{m_i}$ achieve -the goals ${g_i}_1$, $\dots$, ${g_i}_{m_i}$, respectively. -It will follow that if $T_2$ is valid -then for $i$ between $1$ and $n$ -the result of applying $p_i$ to the list of -theorems \ml{[${th_i}_1$;$\ldots$;${th_i}_{m_i}$]} -will be a theorem, $th_i$ say, which achieves -$g_i$. -Now if $T_1$ is valid then \ml{$p$[$th_1$;$\ldots$;$th_n$]} -will evaluate to a theorem, -$th$ say, -that achieves the goal $g$. Thus - -\begin{hol} -\begin{alltt} - \(p\) - (mapshape - (map length \(gll\)) - \(pl\) - [\({th\sb{1}}\sb{1}\);\(\ldots\);\({th\sb{1}}\sb{m\sb{1}}\);\({th\sb{2}}\sb{1}\);\(\ldots\);\({th\sb{2}}\sb{m\sb{2}}\);\(\ \ldots\ \) ;\({th\sb{n}}\sb{1}\);\(\ldots\);\({th\sb{n}}\sb{m\sb{n}}\)]) = - - \(p\)([\(p\sb{1}\)[\({th\sb{1}}\sb{1}\);\(\ldots\);\({th\sb{1}}\sb{m\sb{1}}\)];\(p\sb{2}\)[\({th\sb{2}}\sb{1}\);\(\ldots\);\({th\sb{2}}\sb{m\sb{2}}\)];\(\ \ldots\ \);\(p\sb{n}\)[\({th\sb{n}}\sb{1}\);\(\ldots\);\({th\sb{n}}\sb{m\sb{n}}\)]]) = - - \(p\)([\(th\sb{1}\);\(\ldots\);\(th\sb{n}\)]) = - - \(th\) -\end{alltt} -\end{hol} + >> : tactic -> tactic -> tactic +\end{verbatim} +\end{holboxed} -This shows that -\index{justifications, in goal-directed proof search!THEN example of@\ml{THEN} example of} -\index{proof functions (same as justifications, validations)!THEN example of@\ml{THEN} example of} -\ml{$p$ o mapshape(map length $gll$)$pl$} -is a function that, when -applied to a list of theorems respectively -achieving \ml{flat $gll$}, returns a theorem -(namely $th$) that achieves $g$.\index{sequencing!of tactics|)} +The tactical \ml{\gt\gt} is an \ML{} infix. +Its alias \ml{THEN} is also an infix. +If $T_1$ and $T_2$ are tactics, then the \ML{} expression $T_1\;\ml{\gt\gt}\;T_2$ evaluates to a tactic which first applies $T_1$ and then applies $T_2$ to each subgoal produced by $T_1$. + +Both \ml{\gt\gt} and \ml{THEN} associate to the left, which can lead to some counter-intuitive behaviours when they combine with other sequencing operators. +However, chains of tactics connected with \ml{\gt\gt} behave as one might expect. +In particular, if $T_1$ produces $n$ sub-goals, and $T_2$ produces varying numbers of sub-goals when applied to each of those, then the expression +\( +T_1 \;\texttt{\gt\gt}\; T_2 \;\texttt{\gt\gt}\; T_3 +\) +will apply $T_3$ to \emph{all} of the leaf sub-goals generated by the sequencing of $T_1$ and $T_2$. +\index{sequencing!of tactics|)} \index{tacticals!for sequencing|)} \index{THEN@\ml{THEN}!ML implementation of@\ML{} implementation of|)} @@ -1042,6 +858,7 @@ \subsection{Selective sequencing} \begin{holboxed} \begin{verbatim} THENL : tactic -> tactic list -> tactic + >| : tactic -> tactic list -> tactic \end{verbatim} \end{holboxed} \label{sec:thenl} @@ -1049,25 +866,12 @@ \subsection{Selective sequencing} \index{selective sequencing tactical} If tactic $T$ produces $n$ subgoals and $T_1$, $\dots$, $T_n$ are tactics -then $T${\small\verb% THENL [%}$T_1${\small\verb%;%}$\ldots${\small\verb%;%}$T_n${\small\verb%]%} +then $T${\small\verb% >| [%}$T_1${\small\verb%,%}$\ldots${\small\verb%,%}$T_n${\small\verb%]%} is a tactic which first applies $T$ and then applies $T_i$ to the $i$th subgoal produced by $T$. The tactical {\small\verb%THENL%} is useful if one wants to apply different tactics to different subgoals. - -Here is the definition of \ml{THENL}: - -\begin{hol}\begin{verbatim} - let ((T:tactic) THENL (Tl:tactic list)) g = - let gl,p = T g - in - let gll,pl = (split(map (\(T,g). T g) Tgl) - where Tgl = combine(Tl,gl) ? failwith `THENL`) - in - (flat gll, (p o mapshape(map length gll)pl)) -\end{verbatim}\end{hol} - -\noindent The understanding of this procedure is left as an exercise!\index{tactics!sequencing of|)} +\index{tactics!sequencing of|)} \subsection{Successive application} @@ -1084,33 +888,36 @@ \subsection{Successive application} The tactical \ml{EVERY} applies a list of tactics one after the other. -\begin{hol}\begin{alltt} - EVERY [\(T\sb{1}\);\(T\sb{2}\);\(\ldots\);\(T\sb{n}\)] = \(T\sb{1}\) THEN \(T\sb{2}\) THEN \(\ldots\) THEN \(T\sb{n}\) -\end{alltt}\end{hol} +\begin{hol} +\begin{alltt} + EVERY [\(T\sb{1}\),\(T\sb{2}\),\(\ldots\),\(T\sb{n}\)] = \(T\sb{1}\) \gt\gt \(T\sb{2}\) \gt\gt \(\ldots\) \gt\gt \(T\sb{n}\) +\end{alltt} +\end{hol} \subsection{Repetition} -\begin{holboxed}\index{REPEAT@\ml{REPEAT}|pin} +\begin{holboxed}\index{REPEAT@\ml{REPEAT}|pin}\index{rpt@\ml{rpt}|see{\ml{REPEAT}}} \begin{verbatim} REPEAT : tactic -> tactic -\end{verbatim}\end{holboxed} + rpt : tactic -> tactic +\end{verbatim} +\end{holboxed} \label{sec:repeat} If $T$ is a -tactic then {\small\verb%REPEAT %}$T$ is a tactic\index{tactics!repetition of} +tactic then {\small\verb%rpt %}$T$ is a tactic\index{tactics!repetition of} \index{tacticals!for repetition}\index{repetition!of tactics} that repeatedly applies $T$ until it fails. It is defined in \ML{} by: {\small\baselineskip\HOLSpacing \begin{verbatim} - letrec REPEAT T g = ((T THEN REPEAT T) ORELSE ALL_TAC) g + fun REPEAT T g = ((T THEN REPEAT T) ORELSE ALL_TAC) g \end{verbatim}} -\noindent (The extra argument {\small\verb%g%} is needed because \ML{} does not use -lazy evaluation.) +\noindent (The extra argument {\small\verb%g%} is needed because \ML{} does not use lazy evaluation.) \index{tacticals|)} \index{tacticals!list of some|)} \index{tactics!tacticals for|)} @@ -1403,48 +1210,65 @@ \subsection{Theorem continuations with popping} \setcounter{sessioncount}{1} -\begin{session}\begin{verbatim} -#g "((n = 0) \/ (n = 1)) ==> (n * n = n)";; -"(n = 0) \/ (n = 1) ==> (n * n = n)" +\begin{session} +\begin{alltt} +> g `((n = 0) \/ (n = 1)) ==> (n * n = n)`; + Initial goal: -() : void + (n = 0) \(\lor\) (n = 1) \(\Rightarrow\) (n * n = n) -#e DISCH_TAC;; +> e DISCH_TAC; OK.. -"n * n = n" - [ "(n = 0) \/ (n = 1)" ] +1 subgoal: +val it = -() : void +n * n = n +------------------------------------ + (n = 0) \(\lor\) (n = 1) -#backup();; -"(n = 0) \/ (n = 1) ==> (n * n = n)" -\end{verbatim}\end{session} -\vfill -\newpage -\begin{session}\begin{verbatim} -#e(DISCH_TAC THEN POP_ASSUM DISJ_CASES_TAC);; +> b(); +val it = + Initial goal: + + +(n = 0) \(\lor\) (n = 1) \(\Rightarrow\) (n * n = n) +\end{alltt} +\end{session} + +\begin{session} +\begin{alltt} +> e(DISCH_TAC THEN POP_ASSUM DISJ_CASES_TAC); OK.. -2 subgoals -"n * n = n" - [ "n = 1" ] +2 subgoals: +val it = -"n * n = n" - [ "n = 0" ] +n * n = n +------------------------------------ + n = 1 -() : void -#backup();; -"(n = 0) \/ (n = 1) ==> (n * n = n)" +n * n = n +------------------------------------ + n = 0 + +> b(); +val it = + Initial goal: -() : void -#e(DISCH_TAC THEN POP_ASSUM DISJ_CASES_TAC THEN POP_ASSUM SUBST1_TAC);; +(n = 0) \(\lor\) (n = 1) \(\Rightarrow\) (n * n = n) + +> e(DISCH_TAC THEN POP_ASSUM DISJ_CASES_TAC THEN POP_ASSUM SUBST1_TAC);; OK.. -2 subgoals -"1 * 1 = 1" +2 subgoals: +val it = +1 * 1 = 1 -"0 * 0 = 0" -\end{verbatim}\end{session} + +0 * 0 = 0 + +\end{alltt} +\end{session} As noted earlier, \ml{POP\_ASSUM} is useful when an assumption is required that is still at the top of the stack, @@ -1628,64 +1452,56 @@ \subsection{Theorem continuations with popping} where this could be avoided. Two other tacticals that can be used to manipulate the assumption list are -{\small\verb%FIRST_ASSUM%} and {\small\verb%EVERY_ASSUM%}. +\ml{FIRST\_ASSUM} and \ml{EVERY\_ASSUM}. These are characterized by: \index{FIRST_ASSUM@\ml{FIRST\_ASSUM}} \index{EVERY_ASSUM@\ml{EVERY\_ASSUM}} -\begin{hol}\begin{alltt} - FIRST_ASSUM \(f\) ([\(t\sb{1}\); \(\ldots\) ;\(t\sb{n}\)], \(t\)) = - (\(f\)(ASSUME \(t\sb{1}\)) ORELSE \(\ldots\) ORELSE \(f\)(ASSUME \(t\sb{n}\))) ([\(t\sb{1}\); \(\ldots\) ;\(t\sb{n}\)], \(t\)) +\begin{hol} +\begin{alltt} + FIRST_ASSUM \(f\) ([\(t\sb{1}\), \(\ldots\) ,\(t\sb{n}\)], \(t\)) = + (\(f\)(ASSUME \(t\sb{1}\)) ORELSE \(\ldots\) ORELSE \(f\)(ASSUME \(t\sb{n}\))) ([\(t\sb{1}\), \(\ldots\) ,\(t\sb{n}\)], \(t\)) - EVERY_ASSUM \(f\) ([\(t\sb{1}\); \(\ldots\) ;\(t\sb{n}\)], \(t\)) = - (\(f\)(ASSUME \(t\sb{1}\)) THEN \(\ldots\) THEN \(f\)(ASSUME \(t\sb{n}\))) ([\(t\sb{1}\); \(\ldots\) ;\(t\sb{n}\)], \(t\)) -\end{alltt}\end{hol} + EVERY_ASSUM \(f\) ([\(t\sb{1}\), \(\ldots\) ,\(t\sb{n}\)], \(t\)) = + (\(f\)(ASSUME \(t\sb{1}\)) THEN \(\ldots\) THEN \(f\)(ASSUME \(t\sb{n}\))) ([\(t\sb{1}\), \(\ldots\) ,\(t\sb{n}\)], \(t\)) +\end{alltt} +\end{hol} + +Both of these tactics leave the terms that are assumed (the various $t_i$) in the goal's assumption list. +The \index{FIRST_X_ASSUM@\ml{FIRST\_X\_ASSUM}}\ml{FIRST\_X\_ASSUM} tactical is similar to \ml{FIRST\_ASSUM}, but in addition to assuming one of the goal's assumptions as a theorem and passing this to the function $f$, the goal-state that $f\,(t_i\vdash t_i)$ acts upon has had $t_i$ removed from the assumption list. \subsection{Theorem continuations without popping} \label{tacont} -The idea of the second approach is suggested by the way the array-style -tacticals\index{tacticals!purpose of} supply a list of theorems (the assumed assumptions) -to a function. These tacticals use the function to -infer new -results from the list of theorems, and then to do something with the -results. In some cases, -\eg\ the last example, the assumptions need never have been made in the -first place, which suggests a different use of tacticals. -The original example for \ml{POP\_ASSUM} -illustrates this: namely, to show that $(n = 0) \imp (n\times n = n)$. Here, -instead of discharging the antecedent by applying -\ml{DISCH\_TAC} to the goal, which adds the antecedent as an assumption -and returns the consequent as the conclusion, -and {\it then\/} supplying the (assumed) added assumption to the -theorem continuation \ml{SUBST1\_TAC} and -discarding it at the same time, -a tactical called \ml{DISCH\_THEN} is applied to \ml{SUBST1\_TAC} directly. -\ml{DISCH\_THEN} transforms \ml{SUBST1\_TAC} into -a new tactic: one that applies \ml{SUBST1\_TAC} directly to the (assumed) -antecedent, and the resulting tactic to a subgoal with no new -assumptions and the consequent as its conclusion: -\vfill -\newpage +The idea of the second approach is suggested by the way the array-style tacticals\index{tacticals!purpose of} supply a list of theorems (the assumed assumptions) to a function. +These tacticals use the function to infer new results from the list of theorems, and then to do something with the results. +In some cases, \eg\ the last example, the assumptions need never have been made in the first place, which suggests a different use of tacticals. +The original example for \ml{POP\_ASSUM} illustrates this: namely, to show that $(n = 0) \imp (n\times n = n)$. +Here, instead of discharging the antecedent by applying \ml{DISCH\_TAC} to the goal, which adds the antecedent as an assumption and returns the consequent as the conclusion, and {\it then\/} supplying the (assumed) added assumption to the theorem continuation \ml{SUBST1\_TAC} and discarding it at the same time, a tactical called \ml{DISCH\_THEN} is applied to \ml{SUBST1\_TAC} directly. +\ml{DISCH\_THEN} transforms \ml{SUBST1\_TAC} into a new tactic: one that applies \ml{SUBST1\_TAC} directly to the (assumed) antecedent, and the resulting tactic to a subgoal with no new assumptions and the consequent as its conclusion: \setcounter{sessioncount}{1} -\begin{session}\begin{verbatim} -#DISCH_THEN;; -- : (thm_tactic -> tactic) +\begin{session} +\begin{verbatim} +> DISCH_THEN; +val it = fn : (thm_tactic -> tactic) -#DISCH_THEN SUBST1_TAC;; -- : tactic +> DISCH_THEN SUBST1_TAC; +val it = fn : tactic -#g "(n = 0) ==> (n * n = n)";; -"(n = 0) ==> (n * n = n)" +> g `(n = 0) ==> (n * n = n)`; + Initial goal: -() : void + (n = 0) \(\Rightarrow\) (n * n = n) -#e(DISCH_THEN SUBST1_TAC);; +> e(DISCH_THEN SUBST1_TAC); OK.. -"0 * 0 = 0" -\end{verbatim}\end{session} +1 subgoal: +val it = +0 * 0 = 0 +\end{verbatim} +\end{session} \noindent This gives the same result as the stack method, but more directly, with a more compact \ML{} expression, @@ -1702,16 +1518,20 @@ \subsection{Theorem continuations without popping} immediately: \setcounter{sessioncount}{1} -\begin{session}\begin{verbatim} -#g "(0 = n) ==> (n * n = n)";; -"(0 = n) ==> (n * n = n)" +\begin{session} +\begin{alltt} +> g `(0 = n) ==> (n * n = n)`; + Initial goal: -() : void + (0 = n) \(\Rightarrow\) (n * n = n) -#e(DISCH_THEN(SUBST1_TAC o SYM));; +> e(DISCH_THEN(SUBST1_TAC o SYM)); OK.. -"0 * 0 = 0" -\end{verbatim}\end{session} +1 subgoal: +val it = +0 * 0 = 0 +\end{alltt} +\end{session} The justification of \ml{DISCH\_THEN SUBST1\_TAC} is easily constructed from the justification of \ml{DISCH\_TAC} composed with the justification of @@ -1730,30 +1550,40 @@ \subsection{Theorem continuations without popping} provides a compact tactic: \setcounter{sessioncount}{1} -\begin{session}\begin{verbatim} -#g "((n = 0) \/ (n = 1)) ==> (n * n = n)";; -"(n = 0) \/ (n = 1) ==> (n * n = n)" +\begin{session} +\begin{alltt} +> g `((n = 0) \/ (n = 1)) ==> (n * n = n)`; + Initial goal: -() : void + (n = 0) \(\lor\) (n = 1) \(\Rightarrow\) (n * n = n) -#e(DISCH_THEN(DISJ_CASES_THEN SUBST1_TAC));; +> e(DISCH_THEN(DISJ_CASES_THEN SUBST1_TAC)); OK.. -2 subgoals -"1 * 1 = 1" +2 subgoals: +val it = +1 * 1 = 1 -"0 * 0 = 0" -\end{verbatim}\end{session} + + +0 * 0 = 0 + + +2 subgoals +\end{alltt} +\end{session} \noindent This avoids the repeated popping and pushing of the stack solution, and likewise, gives a shorter \ML{} expression. Both give a shorter expression than the direct method, which is: -\begin{hol}\begin{verbatim} +\begin{hol} +\begin{verbatim} DISCH_TAC - THEN DISJ_CASES_TAC(ASSUME "(n = 0) \/ (n = 1)") - THENL[SUBST1_TAC(ASSUME "n = 0"); - SUBST1_TAC(ASSUME "n = 1")] -\end{verbatim}\end{hol} + THEN DISJ_CASES_TAC(ASSUME ``(n = 0) \/ (n = 1)``) + THENL[SUBST1_TAC(ASSUME ``n = 0``); + SUBST1_TAC(ASSUME ``n = 1``)] +\end{verbatim} +\end{hol} To summarize, there are so far at least five ways to solve a goal (and these are often combined in one interaction): @@ -1766,7 +1596,7 @@ \subsection{Theorem continuations without popping} \begin{hol}\index{ASSUM_LIST@\ml{ASSUM\_LIST}} \begin{verbatim} DISCH_TAC - THEN SUBST1_TAC(ASSUME "n = 0") + THEN SUBST1_TAC(ASSUME ``n = 0``) THEN REWRITE_TAC[MULT_CLAUSES] DISCH_TAC @@ -1806,11 +1636,8 @@ \subsection{Theorem continuations without popping} redundant, if desired); and how assumptions can be denoted without recourse to their text. -It is a strength of the \LCF\ approach -\index{LCF@\LCF} to -theorem proving that many different proof styles are supported, -(all in a secure way) and indeed, can be studied in their own -right. +% +It is a strength of the \LCF\ approach \index{LCF@\LCF} to theorem proving that many different proof styles are supported, (all in a secure way) and indeed, can be studied in their own right. \HOL{} provides several other theorem continuation functions analogous to \ml{DISCH\_THEN} and \ml{DISJ\_CASES\_THEN}. @@ -1820,22 +1647,22 @@ \subsection{Theorem continuations without popping} For example: \index{CHOOSE_THEN@\ml{CHOOSE\_THEN}|pin} -\begin{holboxed}\begin{verbatim} +\begin{holboxed} +\begin{verbatim} CHOOSE_THEN : thm_tactical -\end{verbatim}\end{holboxed} +\end{verbatim} +\end{holboxed} -\noindent Where \ml{thm\_tactical} abbreviates -{\small\verb%thm_tactic -> tactic%}. -\ml{CHOOSE\_THEN\ $f$\ (|-\ ?$x$.$t[x]$)} +\noindent Where \ml{thm\_tactical} abbreviates \ml{thm\_tactic -> tactic}. +\ml{CHOOSE\_THEN\ $f$\ ($\vdash\;\exists x.\;t[x]$)} is a tactic that, given a goal, generates the subgoal obtained -by applying $f$ to \ml{($t[x]$|-$t[x]$)}. The intuition is that if -\ml{|-\ ?$x$.$t[x]$} holds then \ml{|-\ $t[x]$} +by applying $f$ to \ml{($t[x]$|-$t[x]$)}. +The intuition is that if +\ml{|-\ $\exists x$.$t[x]$} holds then \ml{|-\ $t[x]$} holds for some value of $x$ (as long as the variable $x$ is not free elsewhere in the theorem or current goal). -%(The choice of the witness is `understood' by the justification function.) -This gives an easy way of using existentially quantified theorems, -something that is otherwise awkward. +This gives an easy way of using existentially quantified theorems, something that is otherwise awkward. The new method has other applications as well, including as an implementation technique. @@ -1844,21 +1671,19 @@ \subsection{Theorem continuations without popping} taking \ml{DISJ\_CASES\_THEN} as basic, \ml{DISJ\_CASES\_TAC} can be defined by: -\begin{hol}\begin{verbatim} - let DISJ_CASES_TAC = DISJ_CASES_THEN ASSUME_TAC -\end{verbatim}\end{hol} +\begin{hol} +\begin{verbatim} + val DISJ_CASES_TAC = DISJ_CASES_THEN ASSUME_TAC +\end{verbatim} +\end{hol} -\noindent Similarly, the method is useful for modifying existing tactics -(\eg\ resolution tactics) without -having to re-program them in \ML. This avoids the danger of -introducing tactics -whose justifications may fail, -\index{failure, of tactics} a particularly difficult problem to -track down; it is also much easier than starting from scratch. +\noindent Similarly, the method is useful for modifying existing tactics (\eg\ resolution tactics) without having to re-program them in \ML. +This avoids the danger of introducing tactics whose justifications may fail, \index{failure, of tactics} a particularly difficult problem to track down; it is also much easier than starting from scratch. The main theorem continuation functions in the system are: -\begin{hol}\begin{verbatim} +\begin{hol} +\begin{verbatim} ANTE_RES_THEN CHOOSE_THEN X_CHOOSE_THEN CONJUNCTS_THEN CONJUNCTS_THEN2 @@ -1868,15 +1693,12 @@ \subsection{Theorem continuations without popping} RES_THEN STRIP_THM_THEN STRIP_GOAL_THEN -\end{verbatim}\end{hol} +\end{verbatim} +\end{hol} \noindent See \REFERENCE\ for full details. \index{tactics!for manipulating assumptions|)} - - - - %%% Local Variables: %%% mode: latex %%% TeX-master: "description" From 553fa8ecea042bf31d932cffeda159c822dbc4e2 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 1 Jan 2016 16:41:26 +1300 Subject: [PATCH 578/718] Correct typo in description of word concatenation --- Manual/Description/theories.tex | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/Manual/Description/theories.tex b/Manual/Description/theories.tex index 28b4d8142d..b9dcabd3d1 100644 --- a/Manual/Description/theories.tex +++ b/Manual/Description/theories.tex @@ -2274,7 +2274,10 @@ \subsubsection{Words theory} \paragraph{Concatenation} -The operation \holtxt{word\_concat:\worda\rarr\wordb\rarr\wordc} concatenates words. Note that the return type is not constrained. This means that two sixteen bit words can be concatenated to give a word of any length -- which may be smaller or larger than the expect value of 32. The related function \holtxt{word\_join} does return a word of the expected length, \ie{} of type \fcp{\bool}{$\alpha+\beta$}; however, the concatenation operation is more useful because we often want \fcp{\bool}{\ty{32}} and not the logically distinct \fcp{\bool}{\ty{16}+\ty{16}}. +The operation \holtxt{word\_concat:\worda\rarr\wordb\rarr\wordc} concatenates words. +Note that the return type is not constrained. +This means that two sixteen bit words can be concatenated to give a word of any length -- which may be smaller or larger than the expected value of 32. +The related function \holtxt{word\_join} does return a word of the expected length, \ie{} of type \fcp{\bool}{$\alpha+\beta$}; however, the concatenation operation is more useful because we often want \fcp{\bool}{\ty{32}} and not the logically distinct \fcp{\bool}{\ty{16}+\ty{16}}. \paragraph{Signed and unsigned words} From e2adb4feec4008f755b962c4a03e5b7a28dd26bd Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 1 Jan 2016 16:55:41 +1300 Subject: [PATCH 579/718] Make ORELSE_LT an infix in experimental kernel This otherwise prevents build from succeeding --- src/experimental-kernel/Overlay.sml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/experimental-kernel/Overlay.sml b/src/experimental-kernel/Overlay.sml index bc1938bf15..656d9c5e45 100644 --- a/src/experimental-kernel/Overlay.sml +++ b/src/experimental-kernel/Overlay.sml @@ -6,7 +6,7 @@ between the two. ---------------------------------------------------------------------- *) -infix ++ && |-> THEN THEN1 THENL THEN_LT THENC ORELSE ORELSEC +infix ++ && |-> THEN THEN1 THENL THEN_LT THENC ORELSE ORELSE_LT ORELSEC THEN_TCL ORELSE_TCL ?> |> infixr ## infixr 3 -->; From d0cfa8cdb9572bbb3dd542d7a3f4ccd528be7f32 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Sat, 2 Jan 2016 12:09:07 +1300 Subject: [PATCH 580/718] Improve wording of type parameter ordering in Datatype Closes #326 --- Manual/Description/definitions.tex | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) diff --git a/Manual/Description/definitions.tex b/Manual/Description/definitions.tex index 1e9ac7bc52..32b1a500a3 100644 --- a/Manual/Description/definitions.tex +++ b/Manual/Description/definitions.tex @@ -109,17 +109,14 @@ \section{Datatypes}\label{sec:datatype} % \begin{hol} \begin{verbatim} - Datatype `sum = Left 'left | Right 'right`; + Datatype `sum = C1 'left | C2 'right`; \end{verbatim} \end{hol} % and then writes \ml{('a,'b)sum}, will the \ml{'a} value be under the -\ml{Left} or \ml{Right} constructor? The system chooses to make the -arguments corresponding to variables appear in the order given by the -dictionary ordering of the variables' names. Thus, in the example -given, the \ml{'a} of \ml{('a,'b)sum} will be the \ml{Left} argument -because \ml{left} comes before \ml{right} in the standard (ASCII) -dictionary ordering. +\ml{C1} or \ml{C2} constructor? +The system chooses to make the arguments corresponding to variables appear in the order given by the dictionary ordering of the names of the variables occurring in the definition. +Thus, in the example given, the \ml{'a} of \ml{('a,'b)sum} will be the argument to the \holtxt{C1} constructor because \holtxt{'left} comes before \holtxt{'right} in the standard (ASCII) dictionary ordering. \subsection{Further examples} From 0e8ae90fa28d836a4a425fa1bbeaac4ced58840d Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Sat, 2 Jan 2016 22:14:11 +1300 Subject: [PATCH 581/718] Make ORELSE_LT an infix for logging kernel too --- src/logging-kernel/Overlay.sml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/logging-kernel/Overlay.sml b/src/logging-kernel/Overlay.sml index bc1938bf15..656d9c5e45 100644 --- a/src/logging-kernel/Overlay.sml +++ b/src/logging-kernel/Overlay.sml @@ -6,7 +6,7 @@ between the two. ---------------------------------------------------------------------- *) -infix ++ && |-> THEN THEN1 THENL THEN_LT THENC ORELSE ORELSEC +infix ++ && |-> THEN THEN1 THENL THEN_LT THENC ORELSE ORELSE_LT ORELSEC THEN_TCL ORELSE_TCL ?> |> infixr ## infixr 3 -->; From 66eaae4d97123d68c508f35155af3fa2b2ed6037 Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Wed, 6 Jan 2016 16:09:44 +0000 Subject: [PATCH 582/718] Adaptations in preparation for the release of Poly/ML 5.6. Note that HOL4 now relies on PolyML.addPrettyPrinter and PolyML.Compiler.compilerVersionNumber, which came with Poly/ML version 5.3. --- src/bool/DB.sml | 2 +- src/holyhammer/holyHammer.sml | 2 +- src/parse/term_grammar.sml | 2 +- src/portableML/HOLPP.sml | 2 +- src/prekernel/Lib.sml | 2 +- tools-poly/build.sml | 22 +- tools-poly/configure.sml | 20 +- tools-poly/prelude.ML | 369 +++++++++++++++++----------------- tools-poly/prelude2.ML | 43 ++-- tools/check-intconfig.sml | 2 - 10 files changed, 210 insertions(+), 256 deletions(-) diff --git a/src/bool/DB.sml b/src/bool/DB.sml index aa734f20a7..ceda115635 100644 --- a/src/bool/DB.sml +++ b/src/bool/DB.sml @@ -15,7 +15,7 @@ (* *) (* ------------------------------------------------------------------------- *) -structure DB :> DB = +structure DB : DB = struct open HolKernel; diff --git a/src/holyhammer/holyHammer.sml b/src/holyhammer/holyHammer.sml index f5465cb648..50f58cb515 100644 --- a/src/holyhammer/holyHammer.sml +++ b/src/holyhammer/holyHammer.sml @@ -10,7 +10,7 @@ (* ===================================================================== *) -structure holyHammer :> holyHammer = +structure holyHammer : holyHammer = struct open HolKernel boolLib hhWriter hhReconstruct diff --git a/src/parse/term_grammar.sml b/src/parse/term_grammar.sml index 100f030723..d55e36ad72 100644 --- a/src/parse/term_grammar.sml +++ b/src/parse/term_grammar.sml @@ -1,4 +1,4 @@ -structure term_grammar :> term_grammar = +structure term_grammar : term_grammar = struct open HOLgrammars GrammarSpecials Lib Feedback diff --git a/src/portableML/HOLPP.sml b/src/portableML/HOLPP.sml index f8cff14013..0e6fc20723 100644 --- a/src/portableML/HOLPP.sml +++ b/src/portableML/HOLPP.sml @@ -7,7 +7,7 @@ *) (* the functions and data for actually doing printing. *) -structure HOLPP :> HOLPP = +structure HOLPP : HOLPP = struct datatype 'a frag = QUOTE of string | ANTIQUOTE of 'a diff --git a/src/prekernel/Lib.sml b/src/prekernel/Lib.sml index 818a74cc40..c9962e412f 100644 --- a/src/prekernel/Lib.sml +++ b/src/prekernel/Lib.sml @@ -7,7 +7,7 @@ (* Modified : September 22, 1997, Ken Larsen *) (* ===================================================================== *) -structure Lib :> Lib = +structure Lib : Lib = struct open Feedback; diff --git a/tools-poly/build.sml b/tools-poly/build.sml index 404eab2b15..4e414a07a1 100644 --- a/tools-poly/build.sml +++ b/tools-poly/build.sml @@ -21,26 +21,8 @@ datatype phase = Initial | Bare | Full Analysing the command-line ---------------------------------------------------------------------- *) -fun kmod kernelspec = let - (* use the experimental kernel? Depends on the command-line and the - compiler version... *) - val version_string_w1 = - hd (String.tokens Char.isSpace PolyML.Compiler.compilerVersion) - handle Empty => "" - val compiler_number = - Real.floor (100.0 * valOf (Real.fromString version_string_w1)) - handle Option => 0 -in - if kernelspec <> "-expk" andalso compiler_number < 530 then - (warn "*** Using the experimental kernel (standard kernel requires \ - \Poly/ML 5.3 or\n*** higher)"; - "-expk") - else - kernelspec -end - - -val {cmdline,build_theory_graph,do_selftests,SRCDIRS} = process_cline kmod +val {cmdline,build_theory_graph,do_selftests,SRCDIRS} = + process_cline (fn c => c) open Systeml; diff --git a/tools-poly/configure.sml b/tools-poly/configure.sml index 7f7ce49e8c..223ddad843 100644 --- a/tools-poly/configure.sml +++ b/tools-poly/configure.sml @@ -61,24 +61,16 @@ in val machine_flags = if sysname = "Darwin" (* Mac OS X *) then let - open PolyML - val vnum_s = hd (String.fields Char.isSpace Compiler.compilerVersion) - val (major,minor,point) = - case String.fields (fn c => c = #".") vnum_s of - [mj] => (intOf mj, 0, 0) - | [mj, mn] => (intOf mj, intOf mn, 0) - | [mj, mn, pt] => (intOf mj, intOf mn, intOf pt) - | _ => die "Can't pull apart Compiler.compilerVersion" - val number = major * 100 + 10 * minor + point + val number = PolyML.Compiler.compilerVersionNumber in - (if number >= 551 - then ["-lpthread", "-lm", "-ldl", "-lstdc++", - "-Wl,-no_pie"] + (if number >= 560 + then ["-lstdc++", "-Wl,-no_pie", "-w"] + else if number >= 551 + then ["-lpthread", "-lm", "-ldl", "-lstdc++", "-Wl,-no_pie"] else if number >= 550 then ["-Wl,-no_pie"] else ["-segprot", "POLY", "rwx", "rwx"]) @ - (if PolyML.architecture() = "I386" then ["-arch", "i386"] - else []) + (if PolyML.architecture() = "I386" then ["-arch", "i386"] else []) end else [] end; diff --git a/tools-poly/prelude.ML b/tools-poly/prelude.ML index 12ae07cd2d..fe94e0d5ab 100644 --- a/tools-poly/prelude.ML +++ b/tools-poly/prelude.ML @@ -1,214 +1,213 @@ (* this is an -*- sml -*- file *) -val _ = PolyML.print_depth 0; -open HolKernel Parse boolLib proofManagerLib; +val () = PolyML.print_depth 0; -val _ = let - open PP - fun with_pp ppfn pps x = - Parse.respect_width_ref Globals.linewidth ppfn pps x handle e => Raise e - fun pp_from_stringfn sf pps x = PP.add_string pps (sf x) - fun pp2polypp (f : PP.ppstream -> 'a -> unit) - (putString : string -> unit, - beginBlock : int * bool -> unit, - spaceBlock : int * int -> unit, - endBlock : unit -> unit) - (dpth_limit : int) - recursive_print - (e : 'a) = - putString (pp_to_string (!Globals.linewidth) f e) - fun gprint g pps t = let - val tyg = Parse.type_grammar() - val (_, ppt) = Parse.print_from_grammars (tyg,g) - in - ppt pps t - end - fun ppg pps g = term_grammar.prettyprint_grammar gprint pps g - fun locpp pps l = PP.add_string pps (locn.toShortString l) - fun tybpp pps (t:TypeBasePure.typeBase) = PP.add_string pps "" - open PolyML - val version_string_w1 = - hd (String.tokens Char.isSpace Compiler.compilerVersion) - handle Empty => "" - val compiler_number = - Real.floor (100.0 * valOf (Real.fromString version_string_w1)) - handle Option => 0 -in - if compiler_number >= 530 then +open HolKernel Parse boolLib proofManagerLib + +(* Install pretty-printers *) + +local + fun pp2polypp (ppfn: PP.ppstream -> 'b -> unit) = let - fun pp_redblackmap pps (_:('a,'b) Redblackmap.dict) = - HOLPP.add_string pps "" - fun pp_redblackset pps (_:'a Redblackset.set) = - HOLPP.add_string pps "" - fun pp_seq pps (_ : 'a seq.seq) = HOLPP.add_string pps "" + fun f pps x = Parse.respect_width_ref Globals.linewidth ppfn pps x + handle e => Raise e in - install_pp (pp2polypp (with_pp HOLset.pp_holset)); - install_pp (pp2polypp (with_pp pp_redblackmap)); - install_pp (pp2polypp (with_pp pp_redblackset)); - install_pp (pp2polypp (with_pp pp_seq)) + fn depth => fn printArgTypes => fn e: 'b => + PolyML.PrettyString (PP.pp_to_string (!Globals.linewidth) f e) end - else (); - install_pp (pp2polypp - (with_pp (Parse.term_pp_with_delimiters Hol_pp.pp_term))); - install_pp (pp2polypp - (with_pp (Parse.type_pp_with_delimiters Hol_pp.pp_type))); - install_pp (pp2polypp (with_pp Pretype.pp_pretype)); - install_pp (pp2polypp (with_pp Hol_pp.pp_thm)); - install_pp (pp2polypp (with_pp Hol_pp.pp_theory)); - install_pp (pp2polypp (with_pp type_grammar.prettyprint_grammar)); - install_pp (pp2polypp (with_pp ppg)); - - install_pp (pp2polypp (with_pp proofManagerLib.pp_proof)); - install_pp (pp2polypp (with_pp proofManagerLib.pp_proofs)); - install_pp (pp2polypp (with_pp Rewrite.pp_rewrites)); - install_pp (pp2polypp (with_pp TypeBasePure.pp_tyinfo)); - install_pp (pp2polypp (with_pp DefnBase.pp_defn)); - install_pp (pp2polypp (with_pp Arbnum.pp_num)); - install_pp (pp2polypp (with_pp Arbint.pp_int)); - install_pp (pp2polypp (with_pp Arbrat.pp_rat)); - install_pp (pp2polypp (with_pp locpp)); - install_pp (pp2polypp (with_pp tybpp)) + fun gprint g pps t = + let + val tyg = Parse.type_grammar () + val (_, ppt) = Parse.print_from_grammars (tyg, g) + in + ppt pps t + end + val ppg = term_grammar.prettyprint_grammar gprint + fun locpp pps l = PP.add_string pps (locn.toShortString l) + fun pp_redblackmap pps (d: ('a,'b) Redblackmap.dict) = + PP.add_string pps + ("") + fun pp_redblackset pps (s: 'a Redblackset.set) = + PP.add_string pps + ("") +in + val () = + ( if PolyML.Compiler.compilerVersionNumber < 560 then + let + fun tybpp pps (_:TypeBasePure.typeBase) = PP.add_string pps "" + fun pp_seq pps (_:'a seq.seq) = PP.add_string pps "" + in + PolyML.addPrettyPrinter (pp2polypp tybpp) + ; PolyML.addPrettyPrinter (pp2polypp pp_seq) + ; PolyML.addPrettyPrinter (pp2polypp HOLset.pp_holset) + end + else () + ; PolyML.addPrettyPrinter (pp2polypp ppg) + ; PolyML.addPrettyPrinter (pp2polypp locpp) + ; PolyML.addPrettyPrinter (pp2polypp pp_redblackmap) + ; PolyML.addPrettyPrinter (pp2polypp pp_redblackset) + ; PolyML.addPrettyPrinter + (pp2polypp (Parse.term_pp_with_delimiters Hol_pp.pp_term)) + ; PolyML.addPrettyPrinter + (pp2polypp (Parse.type_pp_with_delimiters Hol_pp.pp_type)) + ; PolyML.addPrettyPrinter (pp2polypp Pretype.pp_pretype) + ; PolyML.addPrettyPrinter (pp2polypp Hol_pp.pp_thm) + ; PolyML.addPrettyPrinter (pp2polypp Hol_pp.pp_theory) + ; PolyML.addPrettyPrinter (pp2polypp type_grammar.prettyprint_grammar) + ; PolyML.addPrettyPrinter (pp2polypp proofManagerLib.pp_proof) + ; PolyML.addPrettyPrinter (pp2polypp proofManagerLib.pp_proofs) + ; PolyML.addPrettyPrinter (pp2polypp Rewrite.pp_rewrites) + ; PolyML.addPrettyPrinter (pp2polypp TypeBasePure.pp_tyinfo) + ; PolyML.addPrettyPrinter (pp2polypp DefnBase.pp_defn) + ; PolyML.addPrettyPrinter (pp2polypp Arbnum.pp_num) + ; PolyML.addPrettyPrinter (pp2polypp Arbint.pp_int) + ; PolyML.addPrettyPrinter (pp2polypp Arbrat.pp_rat) + ; PolyML.addPrettyPrinter (pp2polypp simpLib.pp_ssfrag) + ; PolyML.addPrettyPrinter (pp2polypp simpLib.pp_simpset) + ; PolyML.addPrettyPrinter (pp2polypp computeLib.pp_compset) + ) end (*---------------------------------------------------------------------------* - * Set up the help paths. * + Switch in and out of quiet mode *---------------------------------------------------------------------------*) -val _ = let -fun huse s = use (Path.concat(HOLDIR, s)); -in -huse "help/src-sml/Database.sig"; -huse "help/src-sml/Database.sml"; -huse "tools-poly/poly/Help.sig"; -huse "tools-poly/poly/Help.sml" +structure HOL_Interactive :> + sig + val toggle_quietdec : unit -> bool + val amquiet : unit -> bool + end = +struct + val qd = ref true + fun toggle_quietdec () = + if !qd then + ( PolyML.Compiler.prompt1 := "> " + ; PolyML.Compiler.prompt2 := "# " + ; PolyML.print_depth 100 + ; qd := false + ; false + ) + else + ( PolyML.Compiler.prompt1 := "" + ; PolyML.Compiler.prompt2 := "" + ; PolyML.print_depth 0 + ; qd := true + ; true + ) + fun amquiet () = !qd end; -local - open Path - fun HELP s = toString(fromString(concat(HOLDIR, concat("help",s)))) - val SIGOBJ = toString(fromString(concat(HOLDIR, "sigobj"))) -in - val () = Help.indexfiles := HELP "HOL.Help" :: !Help.indexfiles - val () = Help.helpdirs := HOLDIR :: SIGOBJ :: !Help.helpdirs - val () = Help.specialfiles := - {file = "help/Docfiles/HOL.help", - term = "hol", title = "HOL Overview"} - :: !Help.specialfiles - val help = Help.help -end (* local *) - (*---------------------------------------------------------------------------* - * Set parameters for parsing and help. * + * Set up the help paths. * + * Set parameters for parsing and help. * *---------------------------------------------------------------------------*) -val _ = Help.displayLines := 60; - - local - fun try_remove f = ((OS.FileSys.remove f) handle OS.SysErr _ => ()); - fun has_dq file = - let - val istrm = TextIO.openIn file - fun loop() = - case TextIO.input1 istrm of - NONE => false - | SOME #"`" => true - | SOME _ => loop() - in - loop() before TextIO.closeIn istrm - end handle IO.Io _ => false; - infix ++; - fun p1 ++ p2 = OS.Path.concat (p1, p2); - open Systeml; + fun try_remove f = ((OS.FileSys.remove f) handle OS.SysErr _ => ()) + fun has_dq file = + let + val istrm = TextIO.openIn file + fun loop() = + case TextIO.input1 istrm of + NONE => false + | SOME #"`" => true + | SOME _ => loop() + in + loop() before TextIO.closeIn istrm + end handle IO.Io _ => false + infix ++ + val op ++ = OS.Path.concat fun unquote_to file1 file2 = - systeml [HOLDIR ++ "bin" ++ "unquote", file1, file2]; + Systeml.systeml [HOLDIR ++ "bin" ++ "unquote", file1, file2]; in -fun use s = - if has_dq s then + fun use s = + if has_dq s then + let + val filename = OS.FileSys.tmpName() + in + (if OS.Process.isSuccess (unquote_to s filename) then + (PolyML.use filename; OS.FileSys.remove filename) + else + ( TextIO.output + (TextIO.stdOut, ("Failed to translate file: " ^ s ^ "\n")) + ; raise Fail "use" + )) + handle e => (try_remove filename; raise e) + end + else PolyML.use s +end (* local *) + +local + infix ++ + val op ++ = OS.Path.concat + fun hol_use p s = let - val filename = OS.FileSys.tmpName() + val nm = HOLDIR ++ p ++ s in - (if OS.Process.isSuccess (unquote_to s filename) then - (PolyML.use filename; OS.FileSys.remove filename) - else (TextIO.output(TextIO.stdOut, - ("Failed to translate file: "^s^"\n")); - raise Fail "use")) - handle e => (try_remove filename; raise e) + use (nm ^ ".sig") + ; use (nm ^ ".sml") end - else PolyML.use s; -end (* local *) - -val _ = Globals.interactive := true; -val _ = Parse.current_backend := Parse.interactive_ppbackend() - -val build_stamp = - let open TextIO Path; - val stampstr = openIn (concat(HOLDIR, concat("tools", "build-stamp"))); - val stamp = inputAll stampstr before closeIn stampstr; - in - stamp - end handle _ => ""; - -val exit_string = + val build_stamp = + let + val stampstr = TextIO.openIn (HOLDIR ++ "tools" ++ "build-stamp") + val stamp = TextIO.inputAll stampstr before TextIO.closeIn stampstr + in + stamp + end + handle _ => "" + val id_string = + "HOL-4 [" ^ Globals.release ^ " " ^ Lib.int_to_string Globals.version ^ + " (" ^ Thm.kernelid ^ ", " ^ build_stamp ^ ")]\n\n" + val exit_string = if Systeml.OS = "winNT" then "To exit type -Z (*not* quit();)" else "To exit type -D" - -val _ = -TextIO.output(TextIO.stdOut, - "\n---------------------------------------------------------------------\n" - ^" HOL-4 [" - ^Globals.release^" "^Lib.int_to_string(Globals.version) - ^" ("^Thm.kernelid^", "^build_stamp^")" - ^"]\n\n" - ^" For introductory HOL help, type: help \"hol\";\n" - ^" "^exit_string - ^"\n---------------------------------------------------------------------\n\ - \\n") - -val _ = let - infix ++ - fun p1 ++ p2 = OS.Path.concat (p1,p2) - fun appthis s = let - val nm = HOLDIR ++ "tools" ++ "Holmake" ++ s - in - use (nm ^ ".sig"); - use (nm ^ ".sml") - end + val line = + "\n---------------------------------------------------------------------\n" + val () = + TextIO.output (TextIO.stdOut, + line ^ + " " ^ id_string ^ + " For introductory HOL help, type: help \"hol\";\n" ^ + " " ^ exit_string ^ + line) in - app appthis ["regexpMatch", "parse_glob", "internal_functions", - "Holmake_types", "ReadHMF"] -end; - -use (OS.Path.concat (HOLDIR, OS.Path.concat("tools", "makefile-includes.ML"))); - -val _ = - (term_pp_prefix := "``"; term_pp_suffix := "``"; - type_pp_prefix := "``"; type_pp_suffix := "``"); -structure HOL_Interactive :> sig - val toggle_quietdec : unit -> bool - val amquiet : unit -> bool -end = -struct - val qd = ref false - fun toggle_quietdec () = - if !qd then (PolyML.Compiler.prompt1 := "> "; - PolyML.Compiler.prompt2 := "# "; - PolyML.print_depth 100; - qd := false; - false) - else (PolyML.Compiler.prompt1 := ""; - PolyML.Compiler.prompt2 := ""; - PolyML.print_depth 0; - qd := true; - true) - fun amquiet () = !qd + val () = + ( hol_use ("help" ++ "src-sml") "Database" + ; hol_use ("tools-poly" ++ "poly") "Help" + ; List.app (hol_use ("tools" ++ "Holmake")) + ["regexpMatch", "parse_glob", "internal_functions", "Holmake_types", + "ReadHMF"] + ; List.app (fn s => PolyML.use (HOLDIR ++ "tools" ++ s)) + ["makefile-includes.ML", "check-intconfig.sml"] + ; List.app Meta.fakeload ["PP", "PolyML"] + ; Globals.interactive := true + ; Parse.current_backend := Parse.interactive_ppbackend () + ; term_pp_prefix := "``" + ; term_pp_suffix := "``" + ; type_pp_prefix := "``" + ; type_pp_suffix := "``" + ; set_trace "pp_annotations" 1 + ) end; -val _ = app Meta.fakeload ["PP", "PolyML"]; - -use (Path.concat(Globals.HOLDIR, "tools/check-intconfig.sml")); - -val _ = set_trace "pp_annotations" 1 +local + infix ++ + val op ++ = OS.Path.concat + val path = Path.toString o Path.fromString + fun HELP s = path (HOLDIR ++ "help" ++ s) + val SIGOBJ = path (HOLDIR ++ "sigobj") + val () = + ( Help.indexfiles := HELP "HOL.Help" :: !Help.indexfiles + ; Help.helpdirs := HOLDIR :: SIGOBJ :: !Help.helpdirs + ; Help.specialfiles := + {file = "help" ++ "Docfiles" ++ "HOL.help", + term = "hol", + title = "HOL Overview"} :: !Help.specialfiles + ; Help.displayLines := 60 + ) +in + val help = Help.help +end -val _ = PolyML.print_depth 100; +val _ = HOL_Interactive.toggle_quietdec () diff --git a/tools-poly/prelude2.ML b/tools-poly/prelude2.ML index 28b147b1c3..c838355bc0 100644 --- a/tools-poly/prelude2.ML +++ b/tools-poly/prelude2.ML @@ -1,37 +1,20 @@ (* this is an -*- sml -*- file *) -val _ = PolyML.print_depth 0; +val () = PolyML.print_depth 0; -val _ = if heapname <> "hol.builder" then - TextIO.output(TextIO.stdOut, "[In non-standard heap: "^heapname^"]\n") - else () - -local (* install prettyprinters for simpsets and ssfrags *) -fun pp2polypp (f : PP.ppstream -> 'a -> unit) - (putString : string -> unit, - beginBlock : int * bool -> unit, - spaceBlock : int * int -> unit, - endBlock : unit -> unit) - (dpth_limit : int) - recursive_print - (e : 'a) = - putString (PP.pp_to_string (!Globals.linewidth) f e); -fun with_pp ppfn pps x = - Parse.respect_width_ref Globals.linewidth ppfn pps x handle e => Raise e -in - val _ = PolyML.install_pp (pp2polypp (with_pp simpLib.pp_ssfrag)); - val _ = PolyML.install_pp (pp2polypp (with_pp simpLib.pp_simpset)); - val _ = PolyML.install_pp (pp2polypp (with_pp computeLib.pp_compset)); -end; - -open bossLib; (* Any others? *) +open bossLib (* Any others? *) (* This uses quietdec, so it doesn't work in PolyML -val _ = use (HOLDIR^"/src/proofman/expandq"); +val _ = use (HOLDIR ^ "/src/proofman/expandq"); +val _ = use (HOLDIR ^ "/src/datatype/Interactive"); *) -(* val _ = use (HOLDIR^"/src/datatype/Interactive"); *) - -val _ = set_trace "metis" 1 -val _ = set_trace "meson" 1 -val _ = PolyML.print_depth 100; +val () = + ( if heapname <> "hol.builder" then + TextIO.output + (TextIO.stdOut, "[In non-standard heap: " ^ heapname ^ "]\n") + else () + ; set_trace "metis" 1 + ; set_trace "meson" 1 + ; PolyML.print_depth 100 + ) diff --git a/tools/check-intconfig.sml b/tools/check-intconfig.sml index e059feb4a0..7e89d16879 100644 --- a/tools/check-intconfig.sml +++ b/tools/check-intconfig.sml @@ -25,5 +25,3 @@ of ignore (oldq orelse HOL_Interactive.toggle_quietdec()) end end; - - From bdf2639cd0bd353d24384f4b5665eced5d71efbb Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Wed, 6 Jan 2016 16:30:28 +0000 Subject: [PATCH 583/718] Fix for last check-in. hol.bare was giving an error. --- tools-poly/prelude.ML | 5 +---- tools-poly/prelude2.ML | 32 +++++++++++++++++++++++--------- 2 files changed, 24 insertions(+), 13 deletions(-) diff --git a/tools-poly/prelude.ML b/tools-poly/prelude.ML index fe94e0d5ab..206151417d 100644 --- a/tools-poly/prelude.ML +++ b/tools-poly/prelude.ML @@ -61,9 +61,6 @@ in ; PolyML.addPrettyPrinter (pp2polypp Arbnum.pp_num) ; PolyML.addPrettyPrinter (pp2polypp Arbint.pp_int) ; PolyML.addPrettyPrinter (pp2polypp Arbrat.pp_rat) - ; PolyML.addPrettyPrinter (pp2polypp simpLib.pp_ssfrag) - ; PolyML.addPrettyPrinter (pp2polypp simpLib.pp_simpset) - ; PolyML.addPrettyPrinter (pp2polypp computeLib.pp_compset) ) end @@ -187,7 +184,7 @@ in ; term_pp_suffix := "``" ; type_pp_prefix := "``" ; type_pp_suffix := "``" - ; set_trace "pp_annotations" 1 + ; Feedback.set_trace "pp_annotations" 1 ) end; diff --git a/tools-poly/prelude2.ML b/tools-poly/prelude2.ML index c838355bc0..89a7694884 100644 --- a/tools-poly/prelude2.ML +++ b/tools-poly/prelude2.ML @@ -9,12 +9,26 @@ val _ = use (HOLDIR ^ "/src/proofman/expandq"); val _ = use (HOLDIR ^ "/src/datatype/Interactive"); *) -val () = - ( if heapname <> "hol.builder" then - TextIO.output - (TextIO.stdOut, "[In non-standard heap: " ^ heapname ^ "]\n") - else () - ; set_trace "metis" 1 - ; set_trace "meson" 1 - ; PolyML.print_depth 100 - ) +local + fun pp2polypp (ppfn: PP.ppstream -> 'b -> unit) = + let + fun f pps x = Parse.respect_width_ref Globals.linewidth ppfn pps x + handle e => Raise e + in + fn depth => fn printArgTypes => fn e: 'b => + PolyML.PrettyString (PP.pp_to_string (!Globals.linewidth) f e) + end +in + val () = + ( if heapname <> "hol.builder" then + TextIO.output + (TextIO.stdOut, "[In non-standard heap: " ^ heapname ^ "]\n") + else () + ; Feedback.set_trace "metis" 1 + ; Feedback.set_trace "meson" 1 + ; PolyML.addPrettyPrinter (pp2polypp simpLib.pp_ssfrag) + ; PolyML.addPrettyPrinter (pp2polypp simpLib.pp_simpset) + ; PolyML.addPrettyPrinter (pp2polypp computeLib.pp_compset) + ; PolyML.print_depth 100 + ) +end From 459e6c195b2668c5d7fe9e9a7c57d0a019e43fcf Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 7 Jan 2016 11:32:57 +1100 Subject: [PATCH 584/718] Reinstate a couple of opaque signature ascriptions --- src/bool/DB.sml | 2 +- src/portableML/HOLPP.sml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/bool/DB.sml b/src/bool/DB.sml index ceda115635..aa734f20a7 100644 --- a/src/bool/DB.sml +++ b/src/bool/DB.sml @@ -15,7 +15,7 @@ (* *) (* ------------------------------------------------------------------------- *) -structure DB : DB = +structure DB :> DB = struct open HolKernel; diff --git a/src/portableML/HOLPP.sml b/src/portableML/HOLPP.sml index 0e6fc20723..f8cff14013 100644 --- a/src/portableML/HOLPP.sml +++ b/src/portableML/HOLPP.sml @@ -7,7 +7,7 @@ *) (* the functions and data for actually doing printing. *) -structure HOLPP : HOLPP = +structure HOLPP :> HOLPP = struct datatype 'a frag = QUOTE of string | ANTIQUOTE of 'a From a8a190ac02e3d05aebd76942c7aa4753a19c8e0f Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 7 Jan 2016 11:38:12 +1100 Subject: [PATCH 585/718] More opaque type ascriptions --- src/holyhammer/holyHammer.sml | 2 +- src/parse/term_grammar.sml | 2 +- src/prekernel/Lib.sml | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/holyhammer/holyHammer.sml b/src/holyhammer/holyHammer.sml index 50f58cb515..f5465cb648 100644 --- a/src/holyhammer/holyHammer.sml +++ b/src/holyhammer/holyHammer.sml @@ -10,7 +10,7 @@ (* ===================================================================== *) -structure holyHammer : holyHammer = +structure holyHammer :> holyHammer = struct open HolKernel boolLib hhWriter hhReconstruct diff --git a/src/parse/term_grammar.sml b/src/parse/term_grammar.sml index d55e36ad72..100f030723 100644 --- a/src/parse/term_grammar.sml +++ b/src/parse/term_grammar.sml @@ -1,4 +1,4 @@ -structure term_grammar : term_grammar = +structure term_grammar :> term_grammar = struct open HOLgrammars GrammarSpecials Lib Feedback diff --git a/src/prekernel/Lib.sml b/src/prekernel/Lib.sml index c9962e412f..818a74cc40 100644 --- a/src/prekernel/Lib.sml +++ b/src/prekernel/Lib.sml @@ -7,7 +7,7 @@ (* Modified : September 22, 1997, Ken Larsen *) (* ===================================================================== *) -structure Lib : Lib = +structure Lib :> Lib = struct open Feedback; From bded7b186329fee617cf4516684ca6120d7947c7 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 7 Jan 2016 19:45:52 +1100 Subject: [PATCH 586/718] Use PolyML.SaveState instead of executable heaps Interface in terms of "HOLHEAP" declarations in Holmakefiles stays the same. Implementation uses hierarchical saved states. All command-line executables should also now be compiled with polyc. Closes #292 --- .gitignore | 13 ------ bin/.gitignore | 14 ++++++ bin/hol.ML | 26 +++++++++++ bin/noninterhol.ML | 23 ++++++++++ src/TeX/Holmakefile | 22 +++------ src/TeX/mkmunger.sml | 3 +- src/TeX/mosmlmunge.sml | 2 +- src/TeX/poly-mkmkmunge.ML | 68 ++++++++++++++++------------ src/TeX/poly-munge.ML | 1 - src/TeX/theory_tests/Holmakefile | 2 +- src/boss/Holmakefile | 5 +- src/num/termination/Holmakefile | 4 +- src/proofman/Holmakefile | 6 +-- tools-poly/Holmake/Holmake.sml | 44 ++++++------------ tools-poly/Holmake/unix-systeml.sml | 11 +++-- tools-poly/Holmake/winNT-systeml.sml | 1 + tools-poly/build.sml | 11 ++--- tools-poly/builder0.ML | 3 +- tools-poly/buildheap.ML | 16 ++----- tools-poly/configure.sml | 9 ++-- tools-poly/heapname.ML | 5 +- tools-poly/prelude2.ML | 2 +- tools/Holmake/Systeml.sig | 1 + tools/Holmake/unix-systeml.sml | 1 + tools/Holmake/winNT-systeml.sml | 1 + tools/cmp/Holmakefile | 9 ++-- tools/cmp/cmp.ML | 2 - 27 files changed, 166 insertions(+), 139 deletions(-) create mode 100644 bin/.gitignore create mode 100644 bin/hol.ML create mode 100644 bin/noninterhol.ML delete mode 100644 src/TeX/poly-munge.ML delete mode 100644 tools/cmp/cmp.ML diff --git a/.gitignore b/.gitignore index 5c3c0f3f1b..09520fcefd 100644 --- a/.gitignore +++ b/.gitignore @@ -42,19 +42,6 @@ build-log svn-update developers/generateBuildSummary developers/comparelogs -bin/Holmake -bin/build -bin/hol -bin/hol.bare -bin/hol.bare.noquote -bin/hol.noquote -bin/unquote -bin/hol.builder -bin/hol.builder0 -bin/heapname -bin/buildheap -bin/*.bat - developers/docfiles/*.txt tools*/Holmake/Systeml.sml diff --git a/bin/.gitignore b/bin/.gitignore new file mode 100644 index 0000000000..ae505dbc12 --- /dev/null +++ b/bin/.gitignore @@ -0,0 +1,14 @@ +hol.state +hol.state0 +Holmake +build +hol +hol.bare +hol.bare.noquote +hol.noquote +unquote +hol.builder +hol.builder0 +heapname +buildheap +*.bat diff --git a/bin/hol.ML b/bin/hol.ML new file mode 100644 index 0000000000..6444e41574 --- /dev/null +++ b/bin/hol.ML @@ -0,0 +1,26 @@ +fun die s = + (TextIO.output(TextIO.stdErr, s ^ "\n"); + OS.Process.exit OS.Process.failure) + +val args = CommandLine.arguments() + +fun dropUninteresting l = + case l of + "-q" :: rest => dropUninteresting rest + | "--use" :: file :: rest => dropUninteresting rest + | "-i" :: rest => dropUninteresting rest + | gc::rest => if String.isPrefix "--gcthreads" gc then + dropUninteresting rest + else l + | _ => l + +val realArgs = dropUninteresting args + +val (holstate, rest) = + case realArgs of + [] => die "No holstate argument provided" + | x::xs => (x,xs) + +val _ = PolyML.SaveState.loadState holstate + +val _ = List.app use rest diff --git a/bin/noninterhol.ML b/bin/noninterhol.ML new file mode 100644 index 0000000000..a81ffabb02 --- /dev/null +++ b/bin/noninterhol.ML @@ -0,0 +1,23 @@ +fun die s = + (TextIO.output(TextIO.stdErr, s ^ "\n"); + OS.Process.exit OS.Process.failure) + +val args = CommandLine.arguments() + +fun dropUninteresting l = + case l of + "-q" :: rest => dropUninteresting rest + | "--use" :: file :: rest => dropUninteresting rest + | "-i" :: rest => dropUninteresting rest + | gc::rest => if String.isPrefix "--gcthreads" gc then + dropUninteresting rest + else l + | _ => l + +val holstate = + case dropUninteresting args of + [] => die "No holstate argument provided" + | [x] => x + | _ => die "Too many arguments" + +val _ = PolyML.SaveState.loadState holstate diff --git a/src/TeX/Holmakefile b/src/TeX/Holmakefile index 3690974459..bbf40793f2 100644 --- a/src/TeX/Holmakefile +++ b/src/TeX/Holmakefile @@ -9,30 +9,20 @@ EXTRA_CLEANS = munger.lex.sml $(EXE) mkmunge.o munger.o $(TARGET) \ holindex.lex.sml holindex.grm.sig mosml_MKMUNGE_DEP = mkmkmunge.uo mungeTools.uo warning_stream.uo -poly_MKMUNGE_DEP = mkmunge.o mungeTools.uo +poly_MKMUNGE_DEP = poly-mkmkmunge.ML mkmkcline.sml \ + $(dprot $(HOLDIR)/bin/hol.state) \ + EmitTeX.uo mungeTools.uo mosml_MKMUNGE_COMM = $(HOLMOSMLC) -o $@ $< -poly_MKMUNGE_COMM = cc -o $@ $< $(POLY_LDFLAGS) +poly_MKMUNGE_COMM = $(POLY)c $< -o $@ UOFILES = $(patsubst %.sml,%.uo,$(wildcard *.sml)) -all: selftest.exe $(EXE) $(UOFILES) +all: selftest.exe $(TARGET) $(UOFILES) .PHONY: all -$(TARGET) : $(EXE) - $(CP) $< $@ - -$(EXE): $($(ML_SYSNAME)_MKMUNGE_DEP) +$(TARGET): $($(ML_SYSNAME)_MKMUNGE_DEP) $($(ML_SYSNAME)_MKMUNGE_COMM) - $(CP) $@ $(protect $(HOLDIR)/bin) - -ifdef POLY - -mkmunge.o: poly-mkmkmunge.ML mkmkcline.sml $(dprot $(HOLDIR)/bin/hol.builder) \ - EmitTeX.uo - $(HOLDIR)/bin/hol.builder -q < $< - -endif munger.lex.sml: munger.lex $(MLLEX) $< diff --git a/src/TeX/mkmunger.sml b/src/TeX/mkmunger.sml index 909f78629c..60976dc460 100644 --- a/src/TeX/mkmunger.sml +++ b/src/TeX/mkmunger.sml @@ -2,13 +2,14 @@ local open HolKernel Parse structure UD = mungeLex.UserDeclarations in -fun munger () = let +fun munger eatfirstNL () = let val () = Feedback.emit_MESG := false val () = Feedback.WARNING_outstream := TextIO.stdErr val () = set_trace "Unicode" 1 val () = set_trace "pp_dollar_escapes" 1 val () = set_trace "ambiguous grammar warning" 2 open TextIO + val _ = if eatfirstNL then TextIO.inputLine stdIn else NONE val lexer = mungeLex.makeLexer (fn n => TextIO.input stdIn) fun parseWidth s = if String.isPrefix "-w" s then let diff --git a/src/TeX/mosmlmunge.sml b/src/TeX/mosmlmunge.sml index a5565c5280..009dcef8e6 100644 --- a/src/TeX/mosmlmunge.sml +++ b/src/TeX/mosmlmunge.sml @@ -1 +1 @@ -val _ = mkmunger.munger() +val _ = mkmunger.munger false () diff --git a/src/TeX/poly-mkmkmunge.ML b/src/TeX/poly-mkmkmunge.ML index b39ee21fd6..b09e236a9a 100644 --- a/src/TeX/poly-mkmkmunge.ML +++ b/src/TeX/poly-mkmkmunge.ML @@ -1,46 +1,54 @@ (* this is an -*- sml -*- file *) (* the expectation is that this file gets fed into hol *) -val _ = PolyML.print_depth 0; +val _ = PolyML.SaveState.loadState "../../bin/hol.state"; use "mkmkcline.sml"; local - fun p1 ++ p2 = OS.Path.concat(p1,p2) fun die s = (TextIO.output(TextIO.stdErr, s ^ "\n"); OS.Process.exit OS.Process.failure) + fun p1 ++ p2 = OS.Path.concat(p1,p2) + val cn = PolyML.Compiler.compilerVersionNumber in -fun mkmunge () = let +fun main () = let val (exeopt,theories,staticp) = mkmkcline.read_cline() val exe = case exeopt of NONE => "munge.exe" | SOME s => s - val _ = load "EmitTeX" - fun load1 s = let - val _ = print ("Loading "^s^"\n") - in - load s - end handle e => (die ("Exception raised: "^General.exnMessage e)) - val _ = load1 (Globals.HOLDIR ++ "src" ++ "TeX" ++ "holindex"); - val _ = app load1 theories - fun appthis s = let - val nm = Globals.HOLDIR ++ "src" ++ "TeX" ++ s - val _ = print ("Using "^s^"\n") - in - use nm - end handle e => (die ("Exception raised: "^General.exnMessage e)) - open Systeml + val tmpnm = OS.FileSys.tmpName () + val tmpmungeO = TextIO.openOut tmpnm + fun p s = TextIO.output(tmpmungeO, s ^ ";\n") + val exnSuffix = + "\n handle e => (die (\"Exception raised: \"^General.exnMessage e))" + fun gen1 vrb fname = + p ("fun " ^ fname ^ + "1 s = let val _ = print (\"" ^ vrb ^ " \"^s^\"\\n\") in " ^ fname ^ + " s end" ^ exnSuffix) in - List.app appthis ["mungeTools.sig", "mungeTools.sml", "munger.lex.sml", - "mkmunger.sml", "poly-munge.ML"]; - print "Linking object code\n"; - let - val flags = if staticp then POLY_LDFLAGS_STATIC else POLY_LDFLAGS - val res = systeml ([CC, "-o", exe, "munger.o"] @ flags) + p ("val _ = PolyML.SaveState.loadState \"" ^ + String.toString Systeml.DEFAULT_STATE ^"\""); + p ("fun p1 ++ p2 = OS.Path.concat(p1,p2)"); + p ("load \"EmitTeX\""); + p ("fun die s = (TextIO.output(TextIO.stdErr, s ^ \"\\n\");\n\ + \ OS.Process.exit OS.Process.failure)"); + gen1 "Loading" "load"; + gen1 "Using" "use"; + p ("load1 (Globals.HOLDIR ++ \"src\" ++ \"TeX\" ++ \"holindex\")"); + app (fn thy => p ("load1 \"" ^ String.toString thy ^ "\"")) theories; + app (fn ml => p ("use1 \"" ^ + String.toString (Globals.HOLDIR ++ "src" ++ "TeX" ++ ml) ^ + "\"")) + ["mungeTools.sig", "mungeTools.sml", "munger.lex.sml", + "mkmunger.sml"]; + + p ("val main = munger " ^ Bool.toString (551 <= cn andalso cn <= 552)) ; + (* test necessary to work around bug described at + https://www.mail-archive.com/polyml@inf.ed.ac.uk/msg00982.html + *) + TextIO.closeOut tmpmungeO; + let val res = Systeml.systeml [Systeml.POLY ^ "c", "-o", exe, tmpnm] in - if OS.Process.isSuccess res - then OS.FileSys.remove "munger.o" - else die "Linking of Poly/ML object code failed" + if OS.Process.isSuccess res then OS.Process.exit res + else die "Compilation of Poly/ML code failed" end end -end (* local *) - -val _ = PolyML.export("mkmunge", mkmunge) +end (* local *) diff --git a/src/TeX/poly-munge.ML b/src/TeX/poly-munge.ML deleted file mode 100644 index 5c10f78a3c..0000000000 --- a/src/TeX/poly-munge.ML +++ /dev/null @@ -1 +0,0 @@ -val () = PolyML.export("munger", munger) diff --git a/src/TeX/theory_tests/Holmakefile b/src/TeX/theory_tests/Holmakefile index 308c55ea55..fb637d7384 100644 --- a/src/TeX/theory_tests/Holmakefile +++ b/src/TeX/theory_tests/Holmakefile @@ -25,7 +25,7 @@ tyabb_output: tyabb_input tymunge.exe utyabb_output: tyabb_input utymunge.exe ./utymunge.exe < $< > $@ -munge.exe: mdtTheory.uo +munge.exe: mdtTheory.uo $(dprot $(HOLDIR)/bin/mkmunge.exe) $(protect $(HOLDIR)/bin/mkmunge.exe) mdtTheory tymunge.exe: tyabbrevTheory.uo diff --git a/src/boss/Holmakefile b/src/boss/Holmakefile index 2f10c3f130..826a2a9bfd 100644 --- a/src/boss/Holmakefile +++ b/src/boss/Holmakefile @@ -1,7 +1,7 @@ ifdef POLY EXTRA_CLEANS = $(TARGET) -TARGET = $(dprot $(HOLDIR)/bin/hol.builder) +TARGET = $(dprot $(HOLDIR)/bin/hol.state) builder0 = $(HOLDIR)/src/num/termination/numheap @@ -14,8 +14,7 @@ DEPS = bossLib.uo $(patsubst %,$(dprot $(SIGOBJ)/%.uo),$(boss_deps)) \ all: $(TARGET) $(TARGET): $(DEPS) - $(protect $(HOLDIR)/bin/buildheap) -o hol.builder -b $(builder0) $(boss_deps) bossLib && \ - $(MV) hol.builder $(TARGET) + $(protect $(HOLDIR)/bin/buildheap) -o $(TARGET) -b $(builder0) $(boss_deps) bossLib endif diff --git a/src/num/termination/Holmakefile b/src/num/termination/Holmakefile index 39fc65ce9e..d60eda5210 100644 --- a/src/num/termination/Holmakefile +++ b/src/num/termination/Holmakefile @@ -21,8 +21,8 @@ DEPS = $(patsubst %,%.uo,$(BARE_DEPS)) all: $(HOLHEAP) -$(HOLHEAP): $(DEPS) $(dprot $(HOLDIR)/bin/hol.builder0) - $(protect $(HOLDIR)/bin/buildheap) -o $@ -b $(protect $(HOLDIR)/bin/hol.builder0) $(BARE_DEPS) +$(HOLHEAP): $(DEPS) $(dprot $(HOLDIR)/bin/hol.state0) + $(protect $(HOLDIR)/bin/buildheap) -o $@ -b $(protect $(HOLDIR)/bin/hol.state0) $(BARE_DEPS) else EXTRA_CLEANS = selftest.exe endif diff --git a/src/proofman/Holmakefile b/src/proofman/Holmakefile index 127a0e926d..46e0d7302e 100644 --- a/src/proofman/Holmakefile +++ b/src/proofman/Holmakefile @@ -1,5 +1,5 @@ ifdef POLY -TARGET = $(dprot $(HOLDIR)/bin/hol.builder0) +TARGET = $(dprot $(HOLDIR)/bin/hol.state0) BOOLTHEORY = $(dprot $(SIGOBJ)/boolTheory.uo) BOOLLIB = $(dprot $(SIGOBJ)/boolLib.uo) @@ -29,9 +29,7 @@ EXTRA_CLEANS = $(TARGET) $(TARGET): $(DEPS) cd $(protect $(HOLDIR)/tools-poly) && \ - $(POLY) < builder0.ML && \ - cc -o $(protect $@) hol.builder0.o $(POLY_LDFLAGS) && \ - rm hol.builder0.o + $(POLY) -q < builder0.ML all: selftest.exe $(TARGET) .PHONY: all diff --git a/tools-poly/Holmake/Holmake.sml b/tools-poly/Holmake/Holmake.sml index d541654163..2e9886ced2 100644 --- a/tools-poly/Holmake/Holmake.sml +++ b/tools-poly/Holmake/Holmake.sml @@ -14,6 +14,10 @@ open Systeml Holmake_tools structure FileSys = OS.FileSys structure Path = OS.Path +infix // +fun p1 // p2 = OS.Path.concat(p1,p2) +val default_holstate = Systeml.DEFAULT_STATE + fun main () = let val execname = OS.Path.file (CommandLine.name()) @@ -159,7 +163,8 @@ fun parse_command_line list = let val (rem, quiet_flag) = find_toggle "--quiet" rem val (rem, do_logging_flag) = find_toggle "--logging" rem - val (rem, cmdl_POLYs) = find_pairs "--poly" rem + val (rem, POLY) = find_one_pairtag "--poly" Systeml.POLY (fn x => x) rem + val (rem, cmdl_HOLSTATE) = find_one_pairtag "--holstate" NONE SOME rem val (rem, polynothol) = find_toggle "--poly_not_hol" rem val (rem, no_lastmakercheck) = find_toggle "--nolmbc" rem in @@ -195,15 +200,8 @@ in warn "Ignoring all but last --polymllibdir spec."; SOME (List.last cmdl_POLYMLLIBDIRs) end, - cmdl_POLY = - case cmdl_POLYs of - [] => NONE - | [x] => SOME x - | _ => let - in - warn "Ignoring all but last --poly spec."; - SOME (List.last cmdl_POLYs) - end, + POLY = POLY, + cmdl_HOLSTATE = cmdl_HOLSTATE, polynothol = polynothol, keep_going_flag = keep_going_flag, quiet_flag = quiet_flag, @@ -215,7 +213,7 @@ end val {targets, debug, dontmakes, show_usage, allfast, fastfiles, always_rebuild_deps, interactive_flag, opentheory, additional_includes = cline_additional_includes, - cmdl_HOLDIR, cmdl_POLYMLLIBDIR, cmdl_POLY, polynothol, + cmdl_HOLDIR, cmdl_HOLSTATE, cmdl_POLYMLLIBDIR, POLY, polynothol, no_sigobj = cline_no_sigobj, no_prereqs, quit_on_failure, no_hmakefile, user_hmakefile, no_overlay, no_lastmakercheck, user_overlay, keep_going_flag, quiet_flag, @@ -384,10 +382,10 @@ val hmake_qof = member "QUIT_ON_FAILURE" hmake_options val hmake_noprereqs = member "NO_PREREQS" hmake_options val extra_cleans = envlist "EXTRA_CLEANS" -val POLY = let +val HOLSTATE = let val default = - case cmdl_POLY of - NONE => fullPath [HOLDIR, "bin", "hol.builder"] + case cmdl_HOLSTATE of + NONE => default_holstate | SOME s => s in case envlist "HOLHEAP" of @@ -398,16 +396,6 @@ in default) end -val EXE_POLY = - if Path.isRelative POLY then let - val d = Path.dir POLY - in - if d = "" then Path.concat(".", POLY) - else if d = "." then POLY - else POLY - end - else POLY - val quit_on_failure = quit_on_failure orelse hmake_qof val _ = if cline_recursive andalso no_prereqs then @@ -514,12 +502,9 @@ let (TextIO.output (out, s); TextIO.output (out, "\n")) in p "#!/bin/sh"; - p (protect(EXE_POLY) ^ " --gcthreads=1 " ^ + p (protect(POLY) ^ " -q --gcthreads=1 " ^ String.concatWith " " (envlist "POLY_CLINE_OPTIONS") ^ " <<'__end-of-file__'"); - p "val _ = PolyML.Compiler.prompt1:=\"\";"; - p "val _ = PolyML.Compiler.prompt2:=\"\";"; - p "val _ = PolyML.print_depth 0;"; (if polynothol then (p "local"; p "val dir = OS.FileSys.getDir();"; @@ -529,7 +514,8 @@ in p "val _ = OS.FileSys.chDir dir;"; p "in end;") else - ()); + (p ("val _ = PolyML.SaveState.loadState \"" ^ + String.toString HOLSTATE ^ "\";\n"))); p ("val _ = List.map load [" ^ String.concatWith "," (List.map (fn f => "\"" ^ f ^ "\"") diff --git a/tools-poly/Holmake/unix-systeml.sml b/tools-poly/Holmake/unix-systeml.sml index 69a13c15a0..6c0f62eaf4 100644 --- a/tools-poly/Holmake/unix-systeml.sml +++ b/tools-poly/Holmake/unix-systeml.sml @@ -105,6 +105,7 @@ val version = "" val ML_SYSNAME = "" val release = "" val DOT_PATH = "" +val DEFAULT_STATE = fullPath [HOLDIR, "bin", "hol.state"] val isUnix = true @@ -122,6 +123,10 @@ val build_log_dir = fullPath [HOLDIR, "tools-poly", "build-logs"] val build_log_file = fullPath [build_log_dir, "current-build-log"] val make_log_file = "current-make-log"; +fun base_interactive state scripts = + [POLY, "-q", "--use", fullPath [HOLDIR, "bin", "hol.ML"], state] @ scripts + + fun emit_hol_script target exe s = let val ostrm = TextIO.openOut target fun output s = TextIO.output(ostrm, s) @@ -132,7 +137,7 @@ val make_log_file = "current-make-log"; output "#!/bin/sh\n"; output "# The bare HOL script\n"; output "# (automatically generated by HOL configuration)\n\n"; - output (String.concat [exe, " ", String.concatWith " " script, "\n"]); + output (String.concatWith " " (base_interactive exe script) ^ "\n"); TextIO.closeOut ostrm; mk_xable target end; @@ -148,8 +153,8 @@ val make_log_file = "current-make-log"; output "#!/bin/sh\n"; output "# The HOL script (with quote preprocessing)\n"; output "# (automatically generated by HOL configuration)\n\n"; - output (String.concat [qfilter, " | ", exe, " ", - String.concatWith " " script, "\n"]); + output (String.concatWith " " + ([qfilter, "|"] @ base_interactive exe script) ^ "\n"); TextIO.closeOut ostrm; mk_xable target end; diff --git a/tools-poly/Holmake/winNT-systeml.sml b/tools-poly/Holmake/winNT-systeml.sml index ff22bc74ec..9cf0573ccf 100644 --- a/tools-poly/Holmake/winNT-systeml.sml +++ b/tools-poly/Holmake/winNT-systeml.sml @@ -57,6 +57,7 @@ val DYNLIB = val version = val release = val DOT_PATH = +val DEFAULT_STATE = fullPath [HOLDIR, "bin", "hol.state"] val isUnix = false val pointer_eq = PolyML.pointerEq diff --git a/tools-poly/build.sml b/tools-poly/build.sml index 4e414a07a1..70a9f9dfbf 100644 --- a/tools-poly/build.sml +++ b/tools-poly/build.sml @@ -26,11 +26,11 @@ val {cmdline,build_theory_graph,do_selftests,SRCDIRS} = open Systeml; -fun which_hol () = +fun phase_extras () = case !phase of - Initial => [POLY, "--poly_not_hol"] - | Bare => [fullPath [HOLDIR, "bin", "hol.builder0"]] - | Full => [fullPath [HOLDIR, "bin", "hol.builder"]] + Initial => ["--poly_not_hol"] + | Bare => ["--holstate", fullPath [HOLDIR, "bin", "hol.state0"]] + | Full => [] fun aug_systeml proc args = let open Posix.Process @@ -49,7 +49,6 @@ end val Holmake = let - fun extras() = "--poly" :: which_hol() fun isSuccess Posix.Process.W_EXITED = true | isSuccess _ = false fun analysis hmstatus = let @@ -64,7 +63,7 @@ val Holmake = let SysWord.toString (Posix.Signal.toWord sg) end in - buildutils.Holmake aug_systeml isSuccess extras analysis do_selftests + buildutils.Holmake aug_systeml isSuccess phase_extras analysis do_selftests end (* create a symbolic link - Unix only *) diff --git a/tools-poly/builder0.ML b/tools-poly/builder0.ML index 330080197c..67bd7e56dc 100644 --- a/tools-poly/builder0.ML +++ b/tools-poly/builder0.ML @@ -19,6 +19,5 @@ local (List.app safe_use (CommandLine.arguments ()) ; PolyML.rootFunction ()) in - val _ = PolyML.shareCommonData main - val _ = PolyML.export ("hol.builder0", main) + val _ = PolyML.SaveState.saveState (Systeml.HOLDIR ++ "bin/hol.state0") end diff --git a/tools-poly/buildheap.ML b/tools-poly/buildheap.ML index 1f5232d08c..423b3778cd 100644 --- a/tools-poly/buildheap.ML +++ b/tools-poly/buildheap.ML @@ -13,7 +13,7 @@ use "../tools/Holmake/Systeml.sig"; use "Holmake/Systeml.sml"; open Systeml; -val defaultbase = fullPath [HOLDIR, "bin", "hol.builder"] +val defaultbase = Systeml.DEFAULT_STATE fun usage() = (output(stdErr, "Usage:\n"); @@ -52,6 +52,7 @@ fun create_heap (objs, outputheap, base) = let if OS.Process.isSuccess (Systeml.system_ps s) then () else die ("*** Failed to execute\n "^s^"\nsuccessfully") in + p ("val _ = PolyML.SaveState.loadState \"" ^ String.toString base ^ "\"\n"); p ("val heapname = \""^outputheap^"\";"); p "local"; p "fun hload s = (print (\"Loading \"^s^\"\\n\"); load s)"; @@ -59,18 +60,11 @@ in p ("val _ = List.map hload [" ^ String.concatWith "," (map (fn f => "\"" ^ String.toString f ^ "\"") objs) ^ "] handle x => ((case x of Fail s => print (s^\"\\n\") | _ => ()); OS.Process.exit OS.Process.failure);"); - p "fun safe_use s = if String.sub (s, 0) = #\"-\" then () else use s"; - p "fun main() = (List.app safe_use (CommandLine.arguments()); PolyML.rootFunction());"; - p "val _ = PolyML.shareCommonData main;"; p "in"; - p ("val _ = PolyML.export(\""^ outputheap ^"\", main) end"); + p ("val _ = PolyML.SaveState.saveChild(\""^ outputheap ^ + "\", List.length (PolyML.SaveState.showHierarchy()))\nend\n"); closeOut ostrm; - system_ps (base ^ " < " ^ ofile); - system_ps ("cc -o " ^ outputheap ^ " " ^ outputheap^".o" ^ " " ^ - String.concatWith " " POLY_LDFLAGS); - OS.FileSys.remove (outputheap^".o") - handle OS.SysErr(msg, _) => - warn ("Couldn't remove "^outputheap^".o: "^msg) + system_ps (Systeml.POLY ^ " -q < " ^ ofile) end diff --git a/tools-poly/configure.sml b/tools-poly/configure.sml index 223ddad843..b4f8eb4c6c 100644 --- a/tools-poly/configure.sml +++ b/tools-poly/configure.sml @@ -503,9 +503,12 @@ val _ = val _ = echo "Generating bin/hol." val target = fullPath [holdir, "bin", "hol.bare"] val target_boss = fullPath [holdir, "bin", "hol"] - val hol0_heap = protect(fullPath[HOLDIR,"bin", "hol.builder0"]) ^ " -i" - val hol_heapcalc= "$(" ^ protect(fullPath[HOLDIR,"bin","heapname"]) ^ - ") --gcthreads=1 -i" + val hol0_heap = "-i " ^ protect(fullPath[HOLDIR,"bin", "hol.state0"]) + val hol_heapcalc= + String.concatWith " " [ + "--gcthreads=1", "-i", + "$(" ^ protect(fullPath[HOLDIR,"bin","heapname"]) ^ ")" + ] val prelude = ["prelude.ML"] val prelude2 = prelude @ ["prelude2.ML"] in diff --git a/tools-poly/heapname.ML b/tools-poly/heapname.ML index a40685876f..b566f919b8 100644 --- a/tools-poly/heapname.ML +++ b/tools-poly/heapname.ML @@ -1,6 +1,3 @@ -val _ = PolyML.Compiler.prompt1:=""; -val _ = PolyML.Compiler.prompt2:=""; -val _ = PolyML.print_depth 0; val _ = use "../tools/Holmake/Systeml.sig"; val _ = use "Holmake/Systeml.sml"; val _ = use "poly/Binarymap.sig"; @@ -32,7 +29,7 @@ fun warn s = (TextIO.output(TextIO.stdErr, s ^ "\n"); TextIO.flushOut TextIO.stdErr) fun main() = let - val default = Path.concat(HOLDIR, Path.concat("bin", "hol.builder")) + val default = Systeml.DEFAULT_STATE val heap = if FileSys.access ("Holmakefile", [FileSys.A_READ]) then let open Holmake_types diff --git a/tools-poly/prelude2.ML b/tools-poly/prelude2.ML index 89a7694884..0b18c3e087 100644 --- a/tools-poly/prelude2.ML +++ b/tools-poly/prelude2.ML @@ -20,7 +20,7 @@ local end in val () = - ( if heapname <> "hol.builder" then + ( if heapname <> Systeml.DEFAULT_STATE then TextIO.output (TextIO.stdOut, "[In non-standard heap: " ^ heapname ^ "]\n") else () diff --git a/tools/Holmake/Systeml.sig b/tools/Holmake/Systeml.sig index 3a173527a2..042650c7dc 100644 --- a/tools/Holmake/Systeml.sig +++ b/tools/Holmake/Systeml.sig @@ -32,6 +32,7 @@ sig val DYNLIB : bool val ML_SYSNAME : string val DOT_PATH : string + val DEFAULT_STATE : string val isUnix : bool val pointer_eq : 'a * 'a -> bool diff --git a/tools/Holmake/unix-systeml.sml b/tools/Holmake/unix-systeml.sml index ac2504dcb0..5bdfb6b472 100644 --- a/tools/Holmake/unix-systeml.sml +++ b/tools/Holmake/unix-systeml.sml @@ -108,6 +108,7 @@ val version = "" val ML_SYSNAME = "" val release = "" val DOT_PATH = "" +val DEFAULT_STATE = fullPath [HOLDIR, "bin", "hol.state"] val isUnix = true local val cast : 'a -> int = Obj.magic diff --git a/tools/Holmake/winNT-systeml.sml b/tools/Holmake/winNT-systeml.sml index 42fe9a2c3b..7d8c066e38 100644 --- a/tools/Holmake/winNT-systeml.sml +++ b/tools/Holmake/winNT-systeml.sml @@ -96,6 +96,7 @@ val version = "" val ML_SYSNAME = "" val release = "" val DOT_PATH = "" +val DEFAULT_STATE = fullPath [HOLDIR, "bin", "hol.state"] val isUnix = false local val cast : 'a -> int = Obj.magic diff --git a/tools/cmp/Holmakefile b/tools/cmp/Holmakefile index 1d528e2c21..492b9a9e8c 100644 --- a/tools/cmp/Holmakefile +++ b/tools/cmp/Holmakefile @@ -3,13 +3,10 @@ all: cmp.exe ifdef POLY -cmp.o: cmp.ML cmp.sml - $(POLY) < $< +cmp.exe: cmp.sml + $(POLY)c $< -o $@ -cmp.exe: cmp.o - $(CC) -o $@ $< $(POLY_LDFLAGS) - -EXTRA_CLEANS = cmp.exe cmp.o +EXTRA_CLEANS = cmp.exe else diff --git a/tools/cmp/cmp.ML b/tools/cmp/cmp.ML deleted file mode 100644 index ac290a8cd1..0000000000 --- a/tools/cmp/cmp.ML +++ /dev/null @@ -1,2 +0,0 @@ -use "cmp.sml"; -PolyML.export("cmp", main); From 8c42e5500902a0faad4f0ac16745c2010ead4001 Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Thu, 7 Jan 2016 10:48:45 +0000 Subject: [PATCH 587/718] Add some pretty-printers for Poly/ML 5.6. --- tools-poly/prelude.ML | 62 +++++++++++++++++++++++++++++++++++++++---- 1 file changed, 57 insertions(+), 5 deletions(-) diff --git a/tools-poly/prelude.ML b/tools-poly/prelude.ML index 206151417d..fbdd581b2d 100644 --- a/tools-poly/prelude.ML +++ b/tools-poly/prelude.ML @@ -33,14 +33,66 @@ in val () = ( if PolyML.Compiler.compilerVersionNumber < 560 then let - fun tybpp pps (_:TypeBasePure.typeBase) = PP.add_string pps "" - fun pp_seq pps (_:'a seq.seq) = PP.add_string pps "" + fun pp_typebase _ _ (_: TypeBasePure.typeBase) = + PolyML.PrettyString "" + fun pp_seq _ _ (_: 'a seq.seq) = PolyML.PrettyString "" in - PolyML.addPrettyPrinter (pp2polypp tybpp) - ; PolyML.addPrettyPrinter (pp2polypp pp_seq) + PolyML.addPrettyPrinter pp_typebase + ; PolyML.addPrettyPrinter pp_seq ; PolyML.addPrettyPrinter (pp2polypp HOLset.pp_holset) end - else () + else + let + fun pp_db _ _ (c: DB.class) = + PolyML.PrettyString + (case c of + DB.Thm => "Thm" + | DB.Axm => "Axm" + | DB.Def => "Def") + fun pp_delta depth printArgTypes (d: 'a delta) = + case d of + Lib.SAME => PolyML.PrettyString "SAME" + | Lib.DIFF a => + PolyML.PrettyBlock + (2, false, [], + [PolyML.PrettyString "DIFF", PolyML.PrettyBreak (1, 0), + printArgTypes (a, depth)]) + fun pp_verdict depth (pra, prb) (v: ('a, 'b) Lib.verdict) = + case v of + Lib.PASS (a: 'a) => + PolyML.PrettyBlock + (2, false, [], + [PolyML.PrettyString "PASS", PolyML.PrettyBreak (1, 0), + pra (a, depth)]) + | Lib.FAIL (b: 'b) => + PolyML.PrettyBlock + (2, false, [], + [PolyML.PrettyString "FAIL", PolyML.PrettyBreak (1, 0), + prb (b, depth)]) + fun pp_frag depth printArgTypes (f: 'a HOLPP.frag) = + case f of + HOLPP.QUOTE s => + PolyML.PrettyBlock + (2, false, [], + [PolyML.PrettyString "QUOTE", PolyML.PrettyBreak (1, 0), + PolyML.PrettyString s]) + | HOLPP.ANTIQUOTE a => + PolyML.PrettyBlock + (2, false, [], + [PolyML.PrettyString "ANTIQUOTE", PolyML.PrettyBreak (1, 0), + printArgTypes (a, depth)]) + fun pp_breakstyle _ _ (b: HOLPP.break_style) = + PolyML.PrettyString + (case b of + HOLPP.CONSISTENT => "CONSISTENT" + | HOLPP.INCONSISTENT => "INCONSISTENT") + in + PolyML.addPrettyPrinter pp_db + ; PolyML.addPrettyPrinter pp_delta + ; PolyML.addPrettyPrinter pp_verdict + ; PolyML.addPrettyPrinter pp_frag + ; PolyML.addPrettyPrinter pp_breakstyle + end ; PolyML.addPrettyPrinter (pp2polypp ppg) ; PolyML.addPrettyPrinter (pp2polypp locpp) ; PolyML.addPrettyPrinter (pp2polypp pp_redblackmap) From 4271c03573bf2e7ee85d438050c1bf5f5fda84b0 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 7 Jan 2016 21:54:50 +1100 Subject: [PATCH 588/718] Fix bug in shift to PolyML.SaveState User heaps weren't recorded as dependencies for the files in their directories, and so they weren't built first. --- tools-poly/Holmake/Holmake.sml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools-poly/Holmake/Holmake.sml b/tools-poly/Holmake/Holmake.sml index 2e9886ced2..c23cb13570 100644 --- a/tools-poly/Holmake/Holmake.sml +++ b/tools-poly/Holmake/Holmake.sml @@ -738,7 +738,7 @@ in val tcdeps = collect_all_dependencies [] [f] val uo_deps = List.mapPartial (fn (UI x) => SOME (UO x) | _ => NONE) tcdeps - val heap_deps = [Unhandled POLY] + val heap_deps = [Unhandled HOLSTATE] val alldeps = set_union (set_union tcdeps uo_deps) (set_union file_dependencies heap_deps) in From 5e4db62668ebbf35ecf13116b749728dea57ee84 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 7 Jan 2016 21:58:31 +1100 Subject: [PATCH 589/718] Record a selftest commandline - reveals problem The CommandLine.arguments() are inherited from the construction of the underlying heap, not from how the selftest "executable" is actually called. --- src/integer/testing/selftest.sml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/integer/testing/selftest.sml b/src/integer/testing/selftest.sml index 547a19a536..ab702f7a0d 100644 --- a/src/integer/testing/selftest.sml +++ b/src/integer/testing/selftest.sml @@ -12,7 +12,9 @@ fun omega() = test_cases.perform_tests Omega.OMEGA_CONV Omega.OMEGA_TAC andalso val omega_result = (print "Omega Test regression tests\n"; omega()) fun usage() = - (TextIO.output(TextIO.stdErr, "Testing Cooper's: bogus commandline\n"); + (TextIO.output(TextIO.stdErr, + "Testing Cooper's: bogus commandline: " ^ + String.concatWith " " (CommandLine.arguments()) ^ "\n"); TextIO.flushOut TextIO.stdErr) val cooper_result = From 81c3519403c23e7fbcdd1182c7531f69312a0e6b Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 7 Jan 2016 22:06:01 +1100 Subject: [PATCH 590/718] Record correct dependency for pre-heaps theories boolTheory and ConseqConvTheory need to depend on the poly executable (if anything), rather than the default HOL state. --- tools-poly/Holmake/Holmake.sml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools-poly/Holmake/Holmake.sml b/tools-poly/Holmake/Holmake.sml index c23cb13570..471d5f2e7c 100644 --- a/tools-poly/Holmake/Holmake.sml +++ b/tools-poly/Holmake/Holmake.sml @@ -385,7 +385,7 @@ val extra_cleans = envlist "EXTRA_CLEANS" val HOLSTATE = let val default = case cmdl_HOLSTATE of - NONE => default_holstate + NONE => if polynothol then POLY else default_holstate | SOME s => s in case envlist "HOLHEAP" of From 3a93303b4256862b46276d3d0b8ac52ae00fa6d7 Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Thu, 7 Jan 2016 11:53:33 +0000 Subject: [PATCH 591/718] Add -lgmp flag. --- tools-poly/configure.sml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools-poly/configure.sml b/tools-poly/configure.sml index b4f8eb4c6c..8e8f641785 100644 --- a/tools-poly/configure.sml +++ b/tools-poly/configure.sml @@ -64,7 +64,7 @@ in val number = PolyML.Compiler.compilerVersionNumber in (if number >= 560 - then ["-lstdc++", "-Wl,-no_pie", "-w"] + then ["-lgmp", "-lstdc++", "-Wl,-no_pie", "-w"] else if number >= 551 then ["-lpthread", "-lm", "-ldl", "-lstdc++", "-Wl,-no_pie"] else if number >= 550 From b897ed8109b0df25746ecefc8831a430b4f22ede Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 8 Jan 2016 10:15:46 +1100 Subject: [PATCH 592/718] buildheap now outputs success confirmation Mostly so that I can better see what's going on in failing cases like that at https://travis-ci.org/HOL-Theorem-Prover/HOL/jobs/100817844 where I got an error building numheap and nothing more than a message from the checking of the Systeml return code. --- tools-poly/buildheap.ML | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/tools-poly/buildheap.ML b/tools-poly/buildheap.ML index 423b3778cd..69d07ea81c 100644 --- a/tools-poly/buildheap.ML +++ b/tools-poly/buildheap.ML @@ -62,7 +62,10 @@ in "] handle x => ((case x of Fail s => print (s^\"\\n\") | _ => ()); OS.Process.exit OS.Process.failure);"); p "in"; p ("val _ = PolyML.SaveState.saveChild(\""^ outputheap ^ - "\", List.length (PolyML.SaveState.showHierarchy()))\nend\n"); + "\", List.length (PolyML.SaveState.showHierarchy()))"); + p ("val _ = print \"Exported "^outputheap^"\\n\""); + p ("val _ = OS.Process.exit OS.Process.success"); + p ("end"); closeOut ostrm; system_ps (Systeml.POLY ^ " -q < " ^ ofile) end From 8901d2908c0da15c751903042d9cadad9fa9f03a Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 8 Jan 2016 10:17:52 +1100 Subject: [PATCH 593/718] Insist on Poly/ML version >= 5.5.1 --- tools-poly/configure.sml | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/tools-poly/configure.sml b/tools-poly/configure.sml index 8e8f641785..f1cdae6980 100644 --- a/tools-poly/configure.sml +++ b/tools-poly/configure.sml @@ -45,6 +45,11 @@ val CC:string = "cc"; (* C compiler *) val GNUMAKE:string = "make"; (* for bdd library and SMV *) val DEPDIR:string = ".HOLMK"; (* where Holmake dependencies kept *) +val _ = if PolyML.Compiler.compilerVersionNumber < 551 then + (TextIO.output(TextIO.stdErr, + "Must be running PolyML with version >= 5.5.1\n"); + OS.Process.exit OS.Process.failure) + else () local fun assoc item = From 5d39c3e3c6c17285a0ef5d8885eaf57b67ff1d00 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 8 Jan 2016 11:05:42 +1100 Subject: [PATCH 594/718] Put POLY_VERSION into Systeml. This allows code that might be compiled with Moscow ML to also work (there the POLY_VERSION value will be 0). --- tools-poly/Holmake/unix-systeml.sml | 1 + tools-poly/Holmake/winNT-systeml.sml | 1 + tools/Holmake/Systeml.sig | 1 + tools/Holmake/unix-systeml.sml | 1 + tools/Holmake/winNT-systeml.sml | 1 + tools/buildutils.sml | 5 +++++ 6 files changed, 10 insertions(+) diff --git a/tools-poly/Holmake/unix-systeml.sml b/tools-poly/Holmake/unix-systeml.sml index 6c0f62eaf4..1ac26075ae 100644 --- a/tools-poly/Holmake/unix-systeml.sml +++ b/tools-poly/Holmake/unix-systeml.sml @@ -93,6 +93,7 @@ val HAVE_BASIS2002 = false val POLYMLLIBDIR = "" val POLY = "" val POLYC = NONE +val POLY_VERSION = PolyML.Compiler.compilerVersionNumber val POLY_LDFLAGS = [] val POLY_LDFLAGS_STATIC = [] val CC = "" diff --git a/tools-poly/Holmake/winNT-systeml.sml b/tools-poly/Holmake/winNT-systeml.sml index 9cf0573ccf..c2015677bb 100644 --- a/tools-poly/Holmake/winNT-systeml.sml +++ b/tools-poly/Holmake/winNT-systeml.sml @@ -58,6 +58,7 @@ val version = val release = val DOT_PATH = val DEFAULT_STATE = fullPath [HOLDIR, "bin", "hol.state"] +val POLY_VERSION = PolyML.Compiler.compilerVersionNumber val isUnix = false val pointer_eq = PolyML.pointerEq diff --git a/tools/Holmake/Systeml.sig b/tools/Holmake/Systeml.sig index 042650c7dc..2bf00520ee 100644 --- a/tools/Holmake/Systeml.sig +++ b/tools/Holmake/Systeml.sig @@ -21,6 +21,7 @@ sig val POLYMLLIBDIR : string val POLY : string val POLYC : string option + val POLY_VERSION : int val POLY_LDFLAGS : string list val POLY_LDFLAGS_STATIC : string list val CC : string diff --git a/tools/Holmake/unix-systeml.sml b/tools/Holmake/unix-systeml.sml index 5bdfb6b472..07cddd4c03 100644 --- a/tools/Holmake/unix-systeml.sml +++ b/tools/Holmake/unix-systeml.sml @@ -96,6 +96,7 @@ val HAVE_BASIS2002 = false val OS = "" val POLY = "" val POLYC = NONE +val POLY_VERSION = 0 val POLYMLLIBDIR = "" val POLY_LDFLAGS = [] val POLY_LDFLAGS_STATIC = [] diff --git a/tools/Holmake/winNT-systeml.sml b/tools/Holmake/winNT-systeml.sml index 7d8c066e38..e1c1be2f0a 100644 --- a/tools/Holmake/winNT-systeml.sml +++ b/tools/Holmake/winNT-systeml.sml @@ -85,6 +85,7 @@ val HAVE_BASIS2002 = "" val OS = "" val POLY = "" val POLYC = NONE +val POLY_VERSION = 0 val POLYMLLIBDIR = "" val POLY_LDFLAGS = [] val POLY_LDFLAGS_STATIC = [] diff --git a/tools/buildutils.sml b/tools/buildutils.sml index 3b199aa226..8a4ad34b71 100644 --- a/tools/buildutils.sml +++ b/tools/buildutils.sml @@ -568,6 +568,11 @@ in warn (" this suggests you should reconfigure the system."); warn (" Press Ctl-C now to abort the build; to continue."); warn ("WARNING! WARNING!"); + if Systeml.POLY_VERSION = 551 orelse Systeml.POLY_VERSION = 552 then + ignore(TextIO.inputLine TextIO.stdIn) + (* see PolyML bug report at + https://www.mail-archive.com/polyml@inf.ed.ac.uk/msg00982.html *) + else (); ignore (TextIO.inputLine TextIO.stdIn)) else () end handle OS.SysErr _ => die ("File "^s^" has disappeared."); From a670538ad6299ed9fad929adcc94e65a8b3aefe3 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 8 Jan 2016 11:30:31 +1100 Subject: [PATCH 595/718] POLYC + POLY_VERSION now available in Holmakefiles Also change POLYC from string option to string in Systeml (and "" in Moscow ML environments). --- src/TeX/Holmakefile | 2 +- tools-poly/Holmake/unix-systeml.sml | 2 +- tools-poly/Holmake/winNT-systeml.sml | 2 ++ tools-poly/configure.sml | 45 ++++++++-------------------- tools-poly/smart-configure.sml | 13 ++++++-- tools/Holmake/Holmake_types.sml | 2 ++ tools/Holmake/Systeml.sig | 2 +- tools/Holmake/unix-systeml.sml | 2 +- tools/Holmake/winNT-systeml.sml | 2 +- tools/cmp/Holmakefile | 2 +- 10 files changed, 33 insertions(+), 41 deletions(-) diff --git a/src/TeX/Holmakefile b/src/TeX/Holmakefile index bbf40793f2..251c3a77c0 100644 --- a/src/TeX/Holmakefile +++ b/src/TeX/Holmakefile @@ -14,7 +14,7 @@ poly_MKMUNGE_DEP = poly-mkmkmunge.ML mkmkcline.sml \ EmitTeX.uo mungeTools.uo mosml_MKMUNGE_COMM = $(HOLMOSMLC) -o $@ $< -poly_MKMUNGE_COMM = $(POLY)c $< -o $@ +poly_MKMUNGE_COMM = $(POLYC) $< -o $@ UOFILES = $(patsubst %.sml,%.uo,$(wildcard *.sml)) diff --git a/tools-poly/Holmake/unix-systeml.sml b/tools-poly/Holmake/unix-systeml.sml index 1ac26075ae..ea88efdff3 100644 --- a/tools-poly/Holmake/unix-systeml.sml +++ b/tools-poly/Holmake/unix-systeml.sml @@ -92,7 +92,7 @@ val MOSMLDIR = "" val HAVE_BASIS2002 = false val POLYMLLIBDIR = "" val POLY = "" -val POLYC = NONE +val POLYC = "" val POLY_VERSION = PolyML.Compiler.compilerVersionNumber val POLY_LDFLAGS = [] val POLY_LDFLAGS_STATIC = [] diff --git a/tools-poly/Holmake/winNT-systeml.sml b/tools-poly/Holmake/winNT-systeml.sml index c2015677bb..bcf9c10cee 100644 --- a/tools-poly/Holmake/winNT-systeml.sml +++ b/tools-poly/Holmake/winNT-systeml.sml @@ -57,6 +57,8 @@ val DYNLIB = val version = val release = val DOT_PATH = +val POLY = "" +val POLYC = "" val DEFAULT_STATE = fullPath [HOLDIR, "bin", "hol.state"] val POLY_VERSION = PolyML.Compiler.compilerVersionNumber diff --git a/tools-poly/configure.sml b/tools-poly/configure.sml index f1cdae6980..77c179ca8d 100644 --- a/tools-poly/configure.sml +++ b/tools-poly/configure.sml @@ -45,12 +45,6 @@ val CC:string = "cc"; (* C compiler *) val GNUMAKE:string = "make"; (* for bdd library and SMV *) val DEPDIR:string = ".HOLMK"; (* where Holmake dependencies kept *) -val _ = if PolyML.Compiler.compilerVersionNumber < 551 then - (TextIO.output(TextIO.stdErr, - "Must be running PolyML with version >= 5.5.1\n"); - OS.Process.exit OS.Process.failure) - else () - local fun assoc item = let @@ -229,7 +223,7 @@ in ["val HOLDIR =" --> ("val HOLDIR = "^quote holdir^"\n"), "val POLYMLLIBDIR =" --> ("val POLYMLLIBDIR = "^quote polymllibdir^"\n"), "val POLY =" --> ("val POLY = "^quote poly^"\n"), - "val POLYC =" --> ("val POLYC = "^optquote polyc^"\n"), + "val POLYC =" --> ("val POLYC = "^quote polyc^"\n"), "val POLY_LDFLAGS =" --> ("val POLY_LDFLAGS = ["^ (String.concatWith ", " @@ -366,29 +360,14 @@ val _ = remove (fullPath [hmakedir, "Parser.grm.sig"]); val _ = remove (fullPath [hmakedir, "Parser.grm.sml"]); -fun fakepolyc src tgt = +fun polyc_compile s tgt = let - val cline = - "echo 'use \"" ^ src ^ "\"; PolyML.export(\"" ^ tgt ^ "\", main);' | " ^ - POLY ^ " -q --error-exit" + val cline = POLYC ^ " -o " ^ tgt ^ " " ^ s in echov cline; - system_ps cline; - compile systeml tgt (tgt ^ ".o") + system_ps cline end -val maybe_polyc_compile = - case POLYC of - NONE => fakepolyc - | SOME pc => (fn s => fn tgt => - let - val cline = pc ^ " -o " ^ tgt ^ " " ^ s - in - echov cline; - system_ps cline - end) - - fun work_in_dir tgtname d f = (echo ("Making " ^ tgtname); FileSys.chDir d; f(); FileSys.chDir cdir) handle _ => die ("Failed to make "^tgtname) @@ -396,44 +375,44 @@ fun work_in_dir tgtname d f = (* mllex *) val _ = work_in_dir "mllex" lexdir - (fn () => maybe_polyc_compile "poly-mllex.ML" "mllex.exe") + (fn () => polyc_compile "poly-mllex.ML" "mllex.exe") (* mlyacc *) val _ = work_in_dir "mlyacc" yaccdir (fn () => (systeml [lexer, "yacc.lex"]; - maybe_polyc_compile "poly-mlyacc.ML" "mlyacc.exe")) + polyc_compile "poly-mlyacc.ML" "mlyacc.exe")) (* unquote - the quotation filter *) val _ = work_in_dir "unquote." qfdir (fn () => (systeml [lexer, "filter"]; - maybe_polyc_compile "poly-unquote.ML" qfbin)) + polyc_compile "poly-unquote.ML" qfbin)) (* Holmake *) val _ = work_in_dir "Holmake" hmakedir - (fn () => maybe_polyc_compile "poly-Holmake.ML" hmakebin) + (fn () => polyc_compile "poly-Holmake.ML" hmakebin) (* holdeptool *) val _ = work_in_dir "holdeptool" (fullPath [HOLDIR, "tools", "Holmake"]) (fn () => - maybe_polyc_compile + polyc_compile "poly-holdeptool.ML" (fullPath [HOLDIR, "bin", "holdeptool.exe"])) (* build *) val _ = work_in_dir "build" toolsdir - (fn () => maybe_polyc_compile "poly-build.ML" buildbin) + (fn () => polyc_compile "poly-build.ML" buildbin) (* heapname *) val _ = work_in_dir "heapname" toolsdir - (fn () => maybe_polyc_compile "heapname.ML" + (fn () => polyc_compile "heapname.ML" (fullPath [HOLDIR,"bin","heapname"])) (* buildheap *) val _ = work_in_dir "buildheap" toolsdir - (fn () => maybe_polyc_compile "buildheap.ML" + (fn () => polyc_compile "buildheap.ML" (fullPath [HOLDIR, "bin", "buildheap"])) end (* local *) diff --git a/tools-poly/smart-configure.sml b/tools-poly/smart-configure.sml index fb8fd0081c..50f4db09df 100644 --- a/tools-poly/smart-configure.sml +++ b/tools-poly/smart-configure.sml @@ -12,6 +12,10 @@ fun warn s = TextIO.output(TextIO.stdErr, s ^ "\n") fun die s = (TextIO.output(TextIO.stdErr, s ^ "\n"); OS.Process.exit OS.Process.failure) +val _ = if PolyML.Compiler.compilerVersionNumber < 551 then + die "Must be running PolyML with version >= 5.5.1\n" + else () + fun readdir s = let val ds = OS.FileSys.openDir s fun recurse acc = @@ -130,7 +134,7 @@ val polyinstruction = \properly.\n\ \This file should include a line of the form\n\n\ \ val poly = \"path-to-poly\";" -val (poly,polyc) = +val (poly,polycopt) = if poly = "" then let val _ = determining "poly" val nm = CommandLine.name() @@ -177,6 +181,11 @@ val (poly,polyc) = polyinstruction) | SOME p => (OS.Path.concat(p, "poly"), check_polyc p) +val polyc = + case polycopt of + NONE => die ("Couldn't find polyc executable\n" ^ polyinstruction) + | SOME p => p + val polylibsister = let val p as {arcs,isAbs,vol} = OS.Path.fromString poly val (dirname, _) = frontlast arcs @@ -236,7 +245,7 @@ fun optverdict (prompt, optvalue) = verdict ("OS", OS); verdict ("poly", poly); -optverdict ("polyc", polyc); +verdict ("polyc", polyc); verdict ("polymllibdir", polymllibdir); verdict ("holdir", holdir); verdict ("DOT_PATH", DOT_PATH); diff --git a/tools/Holmake/Holmake_types.sml b/tools/Holmake/Holmake_types.sml index 2900327fce..ff0e5d5a81 100644 --- a/tools/Holmake/Holmake_types.sml +++ b/tools/Holmake/Holmake_types.sml @@ -366,6 +366,8 @@ val base_environment = let ("UNQUOTE", [VREF ("protect $(HOLDIR)/" ^ xable_string "/bin/unquote")])] @ (if Systeml.ML_SYSNAME = "poly" then [("POLY", [LIT (Systeml.protect Systeml.POLY)]), + ("POLYC", [LIT (Systeml.protect Systeml.POLYC)]), + ("POLY_VERSION", [LIT (Int.toString Systeml.POLY_VERSION)]), ("POLYMLLIBDIR", [LIT (Systeml.protect Systeml.POLYMLLIBDIR)])] else []) in diff --git a/tools/Holmake/Systeml.sig b/tools/Holmake/Systeml.sig index 2bf00520ee..00c2012411 100644 --- a/tools/Holmake/Systeml.sig +++ b/tools/Holmake/Systeml.sig @@ -20,7 +20,7 @@ sig val HOLDIR : string val POLYMLLIBDIR : string val POLY : string - val POLYC : string option + val POLYC : string val POLY_VERSION : int val POLY_LDFLAGS : string list val POLY_LDFLAGS_STATIC : string list diff --git a/tools/Holmake/unix-systeml.sml b/tools/Holmake/unix-systeml.sml index 07cddd4c03..8a8434c21f 100644 --- a/tools/Holmake/unix-systeml.sml +++ b/tools/Holmake/unix-systeml.sml @@ -95,7 +95,7 @@ val MOSMLDIR = "" val HAVE_BASIS2002 = false val OS = "" val POLY = "" -val POLYC = NONE +val POLYC = "" val POLY_VERSION = 0 val POLYMLLIBDIR = "" val POLY_LDFLAGS = [] diff --git a/tools/Holmake/winNT-systeml.sml b/tools/Holmake/winNT-systeml.sml index e1c1be2f0a..b8e1f9d622 100644 --- a/tools/Holmake/winNT-systeml.sml +++ b/tools/Holmake/winNT-systeml.sml @@ -84,7 +84,7 @@ val MOSMLDIR = "" val HAVE_BASIS2002 = "" val OS = "" val POLY = "" -val POLYC = NONE +val POLYC = "" val POLY_VERSION = 0 val POLYMLLIBDIR = "" val POLY_LDFLAGS = [] diff --git a/tools/cmp/Holmakefile b/tools/cmp/Holmakefile index 492b9a9e8c..ee588d98ee 100644 --- a/tools/cmp/Holmakefile +++ b/tools/cmp/Holmakefile @@ -4,7 +4,7 @@ all: cmp.exe ifdef POLY cmp.exe: cmp.sml - $(POLY)c $< -o $@ + $(POLYC) $< -o $@ EXTRA_CLEANS = cmp.exe From 1a67f1c82d3b04700b6d981fb9e6350bb30a7bc3 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 8 Jan 2016 13:46:19 +1100 Subject: [PATCH 596/718] Remove more invocations of poly in favour of POLYC In the developers directory and the building of the help system's tools. --- developers/Holmakefile | 16 ++++++---------- developers/poly-gbs.ML | 3 +-- help/src-sml/poly-Doc2Html.ML | 4 +--- help/src-sml/poly-Doc2Tex.ML | 4 +--- help/src-sml/poly-Doc2Txt.ML | 4 +--- help/src-sml/poly-makebase.ML | 7 +------ tools/buildutils.sml | 14 +++++--------- 7 files changed, 16 insertions(+), 36 deletions(-) diff --git a/developers/Holmakefile b/developers/Holmakefile index c8d021133b..b4212343a8 100644 --- a/developers/Holmakefile +++ b/developers/Holmakefile @@ -1,18 +1,14 @@ OPTIONS = NO_OVERLAY -EXTRA_CLEANS = mosml-comparelogs comparelogs generateBuildSummary $($(ML_SYSNAME)_gbsdep) +EXTRA_CLEANS = comparelogs generateBuildSummary MLTON_SRCS = mlton-srcs/Binarymap.sml mlton-srcs/Listsort.sml comparelogs.mlb -mosml-comparelogs : mosmlTextIO.ui comparelogs.sml - $(MOSMLC) -o $@ -toplevel mosmlTextIO.ui comparelogs.sml - -mosmlTextIO.ui mosmlTextIO.uo: mosmlTextIO.sml - $(MOSMLC) -toplevel $< +.PHONY: all +all: comparelogs generateBuildSummary ifdef POLY comparelogs: poly-comparelogs.ML comparelogs.sml - poly < $< - gcc -o $@ comparelogs.o $(POLY_LDFLAGS) + $(POLYC) $< -o $@ else @@ -21,10 +17,10 @@ comparelogs: comparelogs.uo endif -poly_gbsdep = generateBuildSummary.o +poly_gbsdep = poly-gbs.ML generateBuildSummary.sml mosml_gbsdep = mosmlgbs.uo generateBuildSummary.uo -poly_gbscomm = gcc -o $@ $< $(POLY_LDFLAGS) +poly_gbscomm = $(POLYC) -o $@ $< mosml_gbscomm = $(MOSMLC) -o $@ $< diff --git a/developers/poly-gbs.ML b/developers/poly-gbs.ML index 35f1437cd3..05630375f1 100644 --- a/developers/poly-gbs.ML +++ b/developers/poly-gbs.ML @@ -1,3 +1,2 @@ use "generateBuildSummary.sml"; - -val _ = PolyML.export ("generateBuildSummary", generateBuildSummary.main) +val main = generateBuildSummary.main diff --git a/help/src-sml/poly-Doc2Html.ML b/help/src-sml/poly-Doc2Html.ML index e100c34f2d..b9381f24a9 100644 --- a/help/src-sml/poly-Doc2Html.ML +++ b/help/src-sml/poly-Doc2Html.ML @@ -18,6 +18,4 @@ val _ = useB "ParseDoc"; val _ = useB "../../sigobj/Systeml"; val _ = use "Doc2Html.sml"; -val _ = PolyML.shareCommonData Doc2Html.main; -val _ = PolyML.export ("Doc2Html", Doc2Html.main); - +val main = Doc2Html.main diff --git a/help/src-sml/poly-Doc2Tex.ML b/help/src-sml/poly-Doc2Tex.ML index afd5063401..f2145421e3 100644 --- a/help/src-sml/poly-Doc2Tex.ML +++ b/help/src-sml/poly-Doc2Tex.ML @@ -17,6 +17,4 @@ val _ = useB "Symbolic"; val _ = useB "ParseDoc"; val _ = use "Doc2Tex.sml"; -val _ = PolyML.shareCommonData Doc2Tex.main; -val _ = PolyML.export ("Doc2Tex", Doc2Tex.main); - +val main = Doc2Tex.main; diff --git a/help/src-sml/poly-Doc2Txt.ML b/help/src-sml/poly-Doc2Txt.ML index 941c385d4f..b1ab690b3c 100644 --- a/help/src-sml/poly-Doc2Txt.ML +++ b/help/src-sml/poly-Doc2Txt.ML @@ -18,6 +18,4 @@ val _ = useB "ParseDoc"; val _ = useB "../../sigobj/Systeml"; val _ = use "Doc2Txt.sml"; -val _ = PolyML.shareCommonData Doc2Txt.main; -val _ = PolyML.export ("Doc2Txt", Doc2Txt.main); - +val main = Doc2Txt.main; diff --git a/help/src-sml/poly-makebase.ML b/help/src-sml/poly-makebase.ML index 5dd55870ef..096301ceb5 100644 --- a/help/src-sml/poly-makebase.ML +++ b/help/src-sml/poly-makebase.ML @@ -1,6 +1,3 @@ -val _ = PolyML.Compiler.prompt1:=""; -val _ = PolyML.Compiler.prompt2:=""; -val _ = PolyML.print_depth 0; val _ = use "../../tools-poly/poly/Binarymap.sig"; val _ = use "../../tools-poly/poly/Binarymap.sml"; val _ = use "../../tools-poly/poly/Binaryset.sig"; @@ -47,6 +44,4 @@ val _ = useB "../../sigobj/Systeml"; val _ = use "makebase.sml"; -val _ = PolyML.shareCommonData makebase.main; -val _ = PolyML.export ("makebase", makebase.main); - +val main = makebase.main diff --git a/tools/buildutils.sml b/tools/buildutils.sml index 8a4ad34b71..affb1c6604 100644 --- a/tools/buildutils.sml +++ b/tools/buildutils.sml @@ -719,14 +719,10 @@ fun Poly_compilehelp() = let in system_ps (fullPath [HOLDIR, "tools", "mllex", "mllex.exe"] ^ " Lexer.lex"); system_ps (fullPath [HOLDIR, "tools", "mlyacc", "src", "mlyacc.exe"] ^ " Parser.grm"); - system_ps (POLY ^ " < poly-makebase.ML"); - link "makebase.exe" "makebase.o"; - system_ps (POLY ^ " < poly-Doc2Html.ML"); - link "Doc2Html.exe" "Doc2Html.o"; - system_ps (POLY ^ " < poly-Doc2Txt.ML"); - link "Doc2Txt.exe" "Doc2Txt.o"; - system_ps (POLY ^ " < poly-Doc2Tex.ML"); - link "Doc2Tex.exe" "Doc2Tex.o" + system_ps (POLYC ^ " poly-makebase.ML -o makebase.exe"); + system_ps (POLYC ^ " poly-Doc2Html.ML -o Doc2Html.exe"); + system_ps (POLYC ^ " poly-Doc2Txt.ML -o Doc2Txt.exe"); + system_ps (POLYC ^ " poly-Doc2Tex.ML -o Doc2Tex.exe") end val HOLMAKE = fullPath [HOLDIR, "bin/Holmake"] @@ -761,7 +757,7 @@ fun build_help graph = val _ = OS.FileSys.chDir dir (* builds the documentation tools called below *) - val _ = if ML_SYSNAME = "poly" then Poly_compilehelp() + val _ = if ML_SYSNAME = "poly" then ignore (Poly_compilehelp()) else if ML_SYSNAME = "mosml" then mosml_compilehelp() else raise Fail "Bogus ML_SYSNAME" From 822cc4d15cfe5b4369e6a80628d72e6cbaf65894 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 8 Jan 2016 15:30:58 +1100 Subject: [PATCH 597/718] Move more tactics from lcsymtacs to bossLib Work on #274 --- src/boss/bossLib.sig | 25 +++++++++++++++++++++++++ src/boss/bossLib.sml | 33 +++++++++++++++++++++++++++++++++ src/boss/lcsymtacs.sml | 30 ------------------------------ 3 files changed, 58 insertions(+), 30 deletions(-) diff --git a/src/boss/bossLib.sig b/src/boss/bossLib.sig index adf2165d38..9af23a5400 100644 --- a/src/boss/bossLib.sig +++ b/src/boss/bossLib.sig @@ -130,4 +130,29 @@ sig val fs : thm list -> tactic val rfs : thm list -> tactic + (* useful quotation-based tactics (from Q) *) + val qx_gen_tac : term quotation -> tactic + val qx_choose_then : term quotation -> thm_tactic -> thm_tactic + val qexists_tac : term quotation -> tactic + val qsuff_tac : term quotation -> tactic + val qid_spec_tac : term quotation -> tactic + val qspec_tac : term quotation * term quotation -> tactic + val qspec_then : term quotation -> thm_tactic -> thm -> tactic + val qspecl_then : term quotation list -> thm_tactic -> thm -> tactic + val qpat_assum : term quotation -> thm_tactic -> tactic + val qpat_abbrev_tac : term quotation -> tactic + val qmatch_abbrev_tac : term quotation -> tactic + val qho_match_abbrev_tac : term quotation -> tactic + val qmatch_rename_tac : term quotation -> tactic + val qmatch_assum_abbrev_tac : term quotation -> tactic + val qmatch_assum_rename_tac : term quotation -> tactic + val qmatch_asmsub_rename_tac : term quotation -> tactic + val qmatch_goalsub_rename_tac : term quotation -> tactic + val qcase_tac : term quotation -> tactic + val qabbrev_tac : term quotation -> tactic + val qunabbrev_tac : term quotation -> tactic + val unabbrev_all_tac : tactic + val qx_genl_tac : term quotation list -> tactic + val qx_choosel_then : term quotation list -> thm_tactic -> thm_tactic + end diff --git a/src/boss/bossLib.sml b/src/boss/bossLib.sml index cf4e5548d7..2c581c6849 100644 --- a/src/boss/bossLib.sml +++ b/src/boss/bossLib.sml @@ -183,4 +183,37 @@ val rw = srw_tac [] val fs = fsrw_tac [] val rfs = rfsrw_tac [] + (* useful quotation-based tactics (from Q) *) + val qx_gen_tac : term quotation -> tactic = Q.X_GEN_TAC + val qx_choose_then = Q.X_CHOOSE_THEN + val qexists_tac : term quotation -> tactic = Q.EXISTS_TAC + val qsuff_tac : term quotation -> tactic = Q_TAC SUFF_TAC + val qspec_tac = Q.SPEC_TAC + val qid_spec_tac : term quotation -> tactic = Q.ID_SPEC_TAC + val qspec_then : term quotation -> thm_tactic -> thm -> tactic = Q.SPEC_THEN + val qspecl_then : term quotation list -> thm_tactic -> thm -> tactic = + Q.SPECL_THEN + val qpat_assum : term quotation -> thm_tactic -> tactic = Q.PAT_ASSUM + val qpat_abbrev_tac : term quotation -> tactic = Q.PAT_ABBREV_TAC + val qmatch_abbrev_tac : term quotation -> tactic = Q.MATCH_ABBREV_TAC + val qho_match_abbrev_tac : term quotation -> tactic = Q.HO_MATCH_ABBREV_TAC + val qmatch_rename_tac : term quotation -> tactic = + Q.MATCH_RENAME_TAC + val qmatch_assum_abbrev_tac : term quotation -> tactic = + Q.MATCH_ASSUM_ABBREV_TAC + val qmatch_assum_rename_tac : term quotation -> tactic = + Q.MATCH_ASSUM_RENAME_TAC + val qmatch_asmsub_rename_tac = Q.MATCH_ASMSUB_RENAME_TAC + val qmatch_goalsub_rename_tac = Q.MATCH_GOALSUB_RENAME_TAC + val qcase_tac = Q.FIND_CASE_TAC + + val qabbrev_tac : term quotation -> tactic = Q.ABBREV_TAC + val qunabbrev_tac : term quotation -> tactic = Q.UNABBREV_TAC + val unabbrev_all_tac : tactic = markerLib.UNABBREV_ALL_TAC + + val qx_genl_tac = map_every qx_gen_tac + fun qx_choosel_then [] ttac = ttac + | qx_choosel_then (q::qs) ttac = qx_choose_then q (qx_choosel_then qs ttac) + + end diff --git a/src/boss/lcsymtacs.sml b/src/boss/lcsymtacs.sml index 95fefa1c77..5258b255ca 100644 --- a/src/boss/lcsymtacs.sml +++ b/src/boss/lcsymtacs.sml @@ -6,35 +6,5 @@ struct fun kall_tac (_: 'a) : tactic = all_tac - val qx_gen_tac : term quotation -> tactic = Q.X_GEN_TAC - val qx_choose_then = Q.X_CHOOSE_THEN - val qexists_tac : term quotation -> tactic = Q.EXISTS_TAC - val qsuff_tac : term quotation -> tactic = Q_TAC SUFF_TAC - val qspec_tac = Q.SPEC_TAC - val qid_spec_tac : term quotation -> tactic = Q.ID_SPEC_TAC - val qspec_then : term quotation -> thm_tactic -> thm -> tactic = Q.SPEC_THEN - val qspecl_then : term quotation list -> thm_tactic -> thm -> tactic = - Q.SPECL_THEN - val qpat_assum : term quotation -> thm_tactic -> tactic = Q.PAT_ASSUM - val qpat_abbrev_tac : term quotation -> tactic = Q.PAT_ABBREV_TAC - val qmatch_abbrev_tac : term quotation -> tactic = Q.MATCH_ABBREV_TAC - val qho_match_abbrev_tac : term quotation -> tactic = Q.HO_MATCH_ABBREV_TAC - val qmatch_rename_tac : term quotation -> tactic = - Q.MATCH_RENAME_TAC - val qmatch_assum_abbrev_tac : term quotation -> tactic = - Q.MATCH_ASSUM_ABBREV_TAC - val qmatch_assum_rename_tac : term quotation -> tactic = - Q.MATCH_ASSUM_RENAME_TAC - val qmatch_asmsub_rename_tac = Q.MATCH_ASMSUB_RENAME_TAC - val qmatch_goalsub_rename_tac = Q.MATCH_GOALSUB_RENAME_TAC - val qcase_tac = Q.FIND_CASE_TAC - - val qabbrev_tac : term quotation -> tactic = Q.ABBREV_TAC - val qunabbrev_tac : term quotation -> tactic = Q.UNABBREV_TAC - val unabbrev_all_tac : tactic = markerLib.UNABBREV_ALL_TAC - - val qx_genl_tac = map_every qx_gen_tac - fun qx_choosel_then [] ttac = ttac - | qx_choosel_then (q::qs) ttac = qx_choose_then q (qx_choosel_then qs ttac) end From 21cfe0f7dbef667982281c70f29e69e0332c8565 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 8 Jan 2016 20:32:39 +1100 Subject: [PATCH 598/718] Simple-minded technology to record HOL sessions Intention is to generate Manuals' sessions automatically so that they won't bitrot (as per issue #325). My feeling is that this approach should be replaced by something that directly calls the compiler while sweeping over the TeX sources. --- developers/forTeX.pl | 27 +++++++++++++++++++++++++++ developers/record-script.sh | 22 ++++++++++++++++++++++ 2 files changed, 49 insertions(+) create mode 100644 developers/forTeX.pl create mode 100755 developers/record-script.sh diff --git a/developers/forTeX.pl b/developers/forTeX.pl new file mode 100644 index 0000000000..fe0c366e41 --- /dev/null +++ b/developers/forTeX.pl @@ -0,0 +1,27 @@ +local $dropping = 0; + +while (<>) +{ + if (m/\(\* remove output end \*\)/) { + $dropping = 0; + next; + } + next if $dropping; + if (m/\(\* remove output begin \*\)/) { + s/\(\* remove output begin \*\)/ .../; + $dropping = 1; + } + s/ //g; + s/\\/\\bs{}/g; + s/∀/\\(\\forall\\)/g; + s/∃/\\(\\exists\\)/g; + s/⇔/\\(\\iff\\)/g; + s/⇒/\\(\\Rightarrow\\)/g; + s/¬/\\(\\neg\\)/g; + s/∧/\\(\\land\\)/g; + s/∨/\\(\\lor\\)/g; + s/≤/\\(\\le\\)/g; + s/^# / /g; + s/^> *$//g; + print; +} diff --git a/developers/record-script.sh b/developers/record-script.sh new file mode 100755 index 0000000000..84624484c4 --- /dev/null +++ b/developers/record-script.sh @@ -0,0 +1,22 @@ +#!/bin/bash + +if [ $# -ne 2 ] +then + echo "Usage: $0 outputfile command" >&2 + exit 1 +fi + +output=$1 +shift +fast=0 + +(sleep 3 + while IFS= read -r line + do + case "$line" in + '##FAST' ) fast=1 ;; + '##SLOW' ) fast=0 ;; + * ) echo "$line" ;; + esac + if [ $fast -eq 0 ] ; then sleep 1 ; fi + done) | script $output "$@" From cd62ddda9fa4e665a7bb57167f006eea202fe9ae Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 8 Jan 2016 20:42:00 +1100 Subject: [PATCH 599/718] Some changes to Euclid chapter of Tutorial. Motivated by github issues #325, #273 and #275. - 273: encourage lcsymtacs/modern proofs - 275: document lcsymtacs/modern proofs - 325: tactics/proofs have rotted --- Manual/Tutorial/euclid.tex | 562 +++++++++++++------------------------ 1 file changed, 192 insertions(+), 370 deletions(-) diff --git a/Manual/Tutorial/euclid.tex b/Manual/Tutorial/euclid.tex index 72974bac5c..857f017b97 100644 --- a/Manual/Tutorial/euclid.tex +++ b/Manual/Tutorial/euclid.tex @@ -3,37 +3,24 @@ \chapter{Example: Euclid's Theorem} \setcounter{sessioncount}{0} -In this chapter, we prove in \holn{} that for every number, there is a -prime number that is larger, \ie, that the prime numbers form an -infinite sequence. This proof has been excerpted and adapted from a -much larger example due to John Harrison, in which he proved the $n = -4$ case of Fermat's Last Theorem. The proof development is intended -to serve as an introduction to performing high-level interactive proofs -in \holn.\footnote{The proofs discussed below may be found in +In this chapter, we prove in \holn{} that for every number, there is a prime number that is larger, \ie, that the prime numbers form an infinite sequence. +This proof has been excerpted and adapted from a much larger example due to John Harrison, in which he proved the $n = 4$ case of Fermat's Last Theorem. +The proof development is intended to serve as an introduction to performing high-level interactive proofs in \holn.% +\footnote{The proofs discussed below may be found in \texttt{examples/euclid.sml} of the \HOL{} distribution.} -Many of the details may be difficult to grasp for the novice reader; -nonetheless, it is recommended that the example be followed through in -order to gain a true taste of using \HOL{} to prove non-trivial theorems. - -Some tutorial descriptions of proof systems show the system performing -amazing feats of automated theorem proving. In this example, we have -\textit{not} taken this approach; instead, we try to show how one -actually goes about the business of proving theorems in \holn{}: when -more than one way to prove something is possible, we will consider the -choices; when a difficulty arises, we will attempt to explain how to fight -one's way clear. - -One `drives' \holn{} by interacting with the ML top-level loop. In this -interaction style, ML function calls are made to bring in -already-established logical context, \eg, via \ml{load}; to define -new concepts, \eg, via \ml{Hol\_datatype}, \ml{Define}, and \ml{Hol\_reln}; -and to perform proofs using the goalstack interface, and -the proof tools from \ml{bossLib} (or if they fail to do the job, from -lower-level libraries). - -Let's get started. First, we start the system, with the command \ml{/bin/hol}. -We then ``\ml{open}'' the arithmetic theory; this means that all of the \ML{} bindings -from the \HOL{} theory of arithmetic are made available at the top level. +Many of the details may be difficult to grasp for the novice reader; nonetheless, it is recommended that the example be followed through in order to gain a true taste of using \HOL{} to prove non-trivial theorems. + +Some tutorial descriptions of proof systems show the system performing amazing feats of automated theorem proving. +In this example, we have \textit{not} taken this approach; instead, we try to show how one actually goes about the business of proving theorems in \holn{}: when more than one way to prove something is possible, we will consider the choices; when a difficulty arises, we will attempt to explain how to fight one's way clear. + +One `drives' \holn{} by interacting with the ML top-level loop, perhaps mediated \emph{via} an editor such as \texttt{emacs} or \texttt{vim}. +In this interaction style, ML function calls are made to bring in already-established logical context, \eg, \emph{via} \ml{load}; +to define new concepts, \eg, \emph{via} \ml{Datatype}, \ml{Define}, and \ml{Hol\_reln}; +and to perform proofs using the goalstack interface, and the proof tools from \ml{bossLib} (or if they fail to do the job, from lower-level libraries). + +Let's get started. +First, we start the system, with the command \ml{/bin/hol}. +We then ``\ml{open}'' the arithmetic theory; this means that all of the \ML{} bindings from the \HOL{} theory of arithmetic are made available at the top level. \begin{session} \begin{verbatim} - open arithmeticTheory; @@ -44,13 +31,16 @@ \chapter{Example: Euclid's Theorem} prime number, we first need to define the \emph{divisibility} relation: \begin{session} -\begin{verbatim} +\begin{alltt} - val divides_def = Define `divides a b = ?x. b = a * x`; Definition has been stored under "divides_def". -> val divides_def = |- !a b. divides a b = ?x. b = a * x : thm -\end{verbatim} +val divides_def = + |- \(\forall\)a b. divides a b \(\iff\) \(\exists\)x. b = a * x : thm +\end{alltt} \end{session} +Note how we are using ASCII notation to input our terms, but the system responds with pleasant Unicode. +Unicode characters can also be used in the input. The definition is added to the current theory with the name \ml{divides\_def}, and also returned from the invocation of @@ -72,15 +62,15 @@ \chapter{Example: Euclid's Theorem} than $1$ and itself: \begin{session} -\begin{verbatim} +\begin{alltt} - val prime_def = - Define `prime p = ~(p=1) /\ !x. x divides p ==> (x=1) \/ (x=p)`; + Define `prime p = p <> 1 /\ !x. x divides p ==> (x=1) \/ (x=p)`; Definition has been stored under "prime_def". -> val prime_def = - |- !p. prime p = ~(p = 1) /\ !x. x divides p ==> (x = 1) \/ (x = p) +val prime_def = + |- \(\forall\)p. prime p \(\iff\) p \(\ne\) 1 \(\land\) \(\forall\)x. x divides p \(\Rightarrow\) (x = 1) \(\lor\) (x = p) : thm -\end{verbatim} +\end{alltt} \end{session} That concludes the definitions to be made. Now we ``just'' have to prove @@ -95,44 +85,37 @@ \chapter{Example: Euclid's Theorem} \paragraph{Proof tools} The development will illustrate that there is often more than one way to tackle a HOL proof, even if one has only a single (informal) proof in -mind. In this example, we often \emph{find} proofs by using -the rewriter \ml{RW\_TAC} to unwind definitions and perform basic -simplifications, often reducing a goal to its essence. +mind. +In this example, we often \emph{find} proofs by using the rewriter \ml{rw} to unwind definitions and perform basic simplifications, often reducing a goal to its essence. \begin{session} \begin{verbatim} -RW_TAC; -val it = fn :simpset -> thm list -> term list * term -> - (term list * term) list * (thm list -> thm) +rw; +val it = fn :thm list -> tactic \end{verbatim} \end{session} -The ML type of \ml{RW\_TAC} is -\ml{:simpset -> thm list -> tactic}.\footnote{Unfortunately, the MoscowML system does not print out -the type of tactics in its abbreviated form.} -When \ml{RW\_TAC} is applied to a \textit{simpset}---for this example it will -always be \ml{arith\_ss}---and a list of theorems, the -theorems will be added to the simpset as supplementary rewrite rules. -We will see that \ml{arith\_ss} is also somewhat knowledgeable about +When \ml{rw} is applied to a list of theorems, the theorems will be added to \HOL{}'s built-in database of useful facts as supplementary rewrite rules. +We will see that \ml{rw} is also somewhat knowledgeable about arithmetic.\footnote{Linear arithmetic especially: purely universal formulas involving the operators {\tt SUC}, $+$, $-$, numeric literals, $<$, $\leq$, $>$, $\geq$, $=$, and multiplication by numeric literals.} -Sometimes simplification with \ml{RW\_TAC} proves the goal immediately. +Sometimes simplification with \ml{rw} proves the goal immediately. Often however, we are left with a goal that requires some study before one -realizes what lemmas are needed to conclude the proof. Once these lemmas -have been proven, or located in ancestor theories, -\ml{METIS\_TAC}\footnote{\ml{METIS\_TAC} -performs resolution-style first-order proof search.} can -be invoked with them, with the expectation that it will find the right -instantiations needed to finish the proof. Note that these two operations, -simplification and resolution-style automatic proof search, will not suffice to -perform all the proofs in this example; in particular, our development will -also need case analysis and induction. +realizes what lemmas are needed to conclude the proof. +Once these lemmas have been proven, or located in ancestor theories, +\ml{metis\_tac}% +\footnote{The \ml{metis\_tac} tactic performs resolution-style first-order proof search.} +can be invoked with them, with the expectation that it will find the right instantiations needed to finish the proof. +Note that these two operations, simplification and resolution-style +automatic proof search, will not suffice to perform all the proofs in +this example; in particular, our development will also need case +analysis and induction. \paragraph{Finding theorems} This raises the following question: how does one find the right lemmas -and rewrite rules to use? This is quite a problem, especially since the number of -ancestor theories, and the theorems in them, is large. There are several -possibilities +and rewrite rules to use? +This is quite a problem, especially since the number of ancestor theories, and the theorems in them, is large. +There are several possibilities \begin{itemize} \item The help system can be used to look up definitions and theorems, as well as proof procedures; for example, an invocation of @@ -165,28 +148,28 @@ \section{Divisibility} We start by proving a number of theorems about the \verb+divides+ relation. We will see that each of these initial theorems can be -proved with a single invocation of \ml{METIS\_TAC}. Both \ml{RW\_TAC} -and \ml{METIS\_TAC} are quite powerful reasoners, and the choice of a +proved with a single invocation of \ml{metis\_tac}. Both \ml{rw} +and \ml{metis\_tac} are quite powerful reasoners, and the choice of a reasoner in a particular situation is a matter of experience. The -major reason that \ml{METIS\_TAC} works so well is that \verb+divides+ -is defined by means of an existential quantifier, and \ml{METIS\_TAC} +major reason that \ml{metis\_tac} works so well is that \verb+divides+ +is defined by means of an existential quantifier, and \ml{metis\_tac} is quite good at automatically instantiating existentials in the course of proof. For a simple example, consider proving $\forall x.\ x\; \mathtt{divides}\; 0$. A new proposition to be proved is entered to the proof manager via ``\ml{g}'', which starts a fresh goalstack: \begin{session} -\begin{verbatim} +\begin{alltt} - g `!x. x divides 0`; > val it = Proof manager status: 1 proof. 1. Incomplete: Initial goal: - !x. x divides 0 + \(\forall\)x. x divides 0 : proofs -\end{verbatim} +\end{alltt} \end{session} The proof manager tells us that it has only one proof to manage, and echoes the given goal. Now we expand the definition of @@ -195,408 +178,235 @@ \section{Divisibility} \ml{divides}: \begin{session} \begin{verbatim} -- e (RW_TAC arith_ss [divides_def]); - +- e (lrw[divides_def]); OK.. +<> 1 subgoal: -> val it = - ?x'. (x = 0) \/ (x' = 0) +val it = +\(\exists\)x'. (x = 0) \/ (x' = 0) \end{verbatim} \end{session} It is of course quite easy to instantiate the existential quantifier by hand. \begin{session} -\begin{verbatim} -- e (EXISTS_TAC ``0``); - +\begin{alltt} +- e (qexists_tac `0`); OK.. 1 subgoal: -> val it = - (x = 0) \/ (0 = 0) -\end{verbatim} +val it = +(x = 0) \(\lor\) (0 = 0) +\end{alltt} \end{session} Then a simplification step finishes the proof. \begin{session} -\begin{verbatim} -- e (RW_TAC arith_ss []); +\begin{alltt} +- e (lrw[]); OK.. Goal proved. -|- (x = 0) \/ (0 = 0) +|- (x = 0) \(\lor\) (0 = 0) Goal proved. -|- ?x'. (x = 0) \/ (x' = 0) -> val it = - Initial goal proved. - |- !x. x divides 0 -\end{verbatim} +|- \(\exists\)x'. (x = 0) \(\lor\) (x' = 0) +val it = Initial goal proved. +|- \(\forall\)x. x divides 0: proof +\end{alltt} \end{session} -What just happened here? The application of \ml{RW\_TAC} to the goal -decomposed it to an empty list of subgoals; in other words the goal was -proved by \ml{RW\_TAC}. Once a goal has been proved, it is popped off -the goalstack, prettyprinted to the output, and the theorem becomes -available for use by the level of the stack. When all the sub-goals -required by \textit{that} level are proven, the corresponding goal at -that level can be proven too. This `unwinding' process continues until -the stack is empty, or until it hits a goal with more than one remaining -unproved subgoal. This process may be hard to -visualize,\footnote{Perhaps since we have used a stack to implement what -is notionally a tree!} but that doesn't matter, since the goalstack was -expressly written to allow the user to ignore such details. - -If the three interactions are joined together with \ml{THEN} to -form a single tactic, we can try the proof again from the -beginning (using the \ml{restart} function) and this time it will -take just one step: +What just happened here? The application of \ml{lrw} to the goal decomposed it to an empty list of subgoals; in other words the goal was proved by \ml{lrw}. +Once a goal has been proved, it is popped off the goalstack, prettyprinted to the output, and the theorem becomes available for use by the level of the stack. When all the sub-goals required by \textit{that} level are proven, the corresponding goal at that level can be proven too. This `unwinding' process continues until the stack is empty, or until it hits a goal with more than one remaining unproved subgoal. +This process may be hard to visualize,\footnote{Perhaps since we have used a stack to implement what is notionally a tree!} but that doesn't matter, since the goalstack was expressly written to allow the user to ignore such details. + +If the three interactions are joined together with \ml{\gt\gt} to form a single tactic, we can try the proof again from the beginning (using the \ml{restart} function) and this time it will take just one step: \begin{session} -\begin{verbatim} -- restart(); -> ... +\begin{alltt} +- restart(); ... -- e (RW_TAC arith_ss [divides_def] THEN EXISTS_TAC ``0`` - THEN RW_TAC arith_ss []); +- e (lrw[divides_def] >> qexists_tac `0` >> lrw[]); OK.. - -> val it = - Initial goal proved. - |- !x. x divides 0 -\end{verbatim} +val it = Initial goal proved. +|- \(\forall\)x. x divides 0: proof +\end{alltt} \end{session} -We have seen one way to prove the theorem. However, as mentioned -earlier, there is another: one can let \ml{METIS\_TAC} expand the -definition of \ml{divides} and find the required instantiation for -\verb+x'+ from the theorem \ml{MULT\_CLAUSES}.\footnote{You might +We have seen one way to prove the theorem. +However, as mentioned +earlier, there is another: one can let \ml{metis\_tac} expand the definition of \ml{divides} and find the required instantiation for \verb+x'+ from the theorem \ml{MULT\_CLAUSES}.% +\footnote{You might like to try typing \ml{MULT\_CLAUSES} into the interactive loop to see exactly what it states.} \begin{session} -\begin{verbatim} -- restart(); -> ... +\begin{alltt} +- restart(); ... -- e (METIS_TAC [divides_def, MULT_CLAUSES]); +- e (metis_tac [divides_def, MULT_CLAUSES]); OK.. metis: r[+0+10]+0+0+0+1+2# -> val it = - Initial goal proved. - |- !x. x divides 0 -\end{verbatim} +val it = Initial goal proved. +|- \(\forall\)x. x divides 0: proof +\end{alltt} \end{session} -As it runs, \ml{METIS\_TAC} prints out some possibly interesting -diagnostics. In any case, having done our proof inside the goalstack package, - we now want to have access to the theorem value that we have - proved. We use the \ml{top\_thm} function to do this, and then - use \ml{drop} to dispose of the stack: +As it runs, \ml{metis\_tac} prints out some possibly interesting diagnostics. +In any case, having done our proof inside the goalstack package, we now want to have access to the theorem value that we have proved. +We use the \ml{top\_thm} function to do this, and then use \ml{drop} to dispose of the stack: \begin{session} -\begin{verbatim} -- val DIVIDES_0 = top_thm(); - -> val DIVIDES_0 = |- !x. x divides 0 : thm - -- drop(); +\begin{alltt} +> val DIVIDES_0 = top_thm(); +val DIVIDES_0 = |- \(\forall\)x. x divides 0: thm +> drop(); OK.. -> val it = There are currently no proofs. : proofs -\end{verbatim} +val it = There are currently no proofs.: proofs +\end{alltt} \end{session} -We have used \ml{METIS\_TAC} in this way to prove the following -collection of theorems about \ml{divides}. As mentioned previously, the -theorems supplied to \ml{METIS\_TAC} in the following proofs did not -(usually) come from thin air: in most cases some exploratory work with -\ml{RW\_TAC} was done to open up definitions and see what lemmas would -be required by \ml{METIS\_TAC}. +We have used \ml{metis\_tac} in this way to prove the following collection of theorems about \ml{divides}. +As mentioned previously, the theorems supplied to \ml{metis\_tac} in the following proofs did not (usually) come from thin air: in most cases some exploratory work with \ml{RW\_TAC} was done to open up definitions and see what lemmas would be required by \ml{metis\_tac}. \begin{description} \label{euclid:extra-proofs} \item [\small{({\it DIVIDES\_0\/})}] \begin{tabular}[t]{l} \verb+!x. x divides 0+ \\ \hline - \verb+METIS_TAC [divides_def, MULT_CLAUSES]+ + \verb+metis_tac [divides_def, MULT_CLAUSES]+ \end{tabular} \item[\small{({\it DIVIDES\_ZERO\/})}] \begin{tabular}[t]{l} \verb+!x. 0 divides x = (x = 0)+ \\ \hline - \verb+METIS_TAC [divides_def, MULT_CLAUSES]+ + \verb+metis_tac [divides_def, MULT_CLAUSES]+ \end{tabular} \item[\small{({\it DIVIDES\_ONE\/})}] \begin{tabular}[t]{l} \verb+!x. x divides 1 = (x = 1)+ \\ \hline - \verb+METIS_TAC [divides_def, MULT_CLAUSES, MULT_EQ_1]+ + \verb+metis_tac [divides_def, MULT_CLAUSES, MULT_EQ_1]+ \end{tabular} \item[\small{({\it DIVIDES\_REFL\/})}] \begin{tabular}[t]{l} \verb+!x. x divides x+ \\ \hline - \verb+METIS_TAC [divides_def, MULT_CLAUSES]+ \\ + \verb+metis_tac [divides_def, MULT_CLAUSES]+ \\ \end{tabular} \item[\small{({\it DIVIDES\_TRANS\/})}] \begin{tabular}[t]{l} \verb+!a b c. a divides b /\ b divides c ==> a divides c+ \\ \hline - \verb+METIS_TAC [divides_def, MULT_ASSOC]+ \\ + \verb+metis_tac [divides_def, MULT_ASSOC]+ \\ \end{tabular} \item[\small{({\it DIVIDES\_ADD\/})}] \begin{tabular}[t]{l} \verb|!d a b. d divides a /\ d divides b ==> d divides (a+b)| \\ \hline - \verb|METIS_TAC [divides_def,LEFT_ADD_DISTRIB]| + \verb|metis_tac [divides_def,LEFT_ADD_DISTRIB]| \end{tabular} \item[\small{({\it DIVIDES\_SUB\/})}] \begin{tabular}[t]{l} \verb+!d a b. d divides a /\ d divides b ==> d divides (a-b)+ \\ \hline - \verb+METIS_TAC [divides_def, LEFT_SUB_DISTRIB]+ \\ + \verb+metis_tac [divides_def, LEFT_SUB_DISTRIB]+ \\ \end{tabular} \item[\small{({\it DIVIDES\_ADDL\/})}] \begin{tabular}[t]{l} \verb|!d a b. d divides a /\ d divides (a+b) ==> d divides b| \\ \hline - \verb+METIS_TAC [ADD_SUB, ADD_SYM, DIVIDES_SUB]+ \\ + \verb+metis_tac [ADD_SUB, ADD_SYM, DIVIDES_SUB]+ \\ \end{tabular} \item[\small{({\it DIVIDES\_LMUL\/})}] \begin{tabular}[t]{l} \verb+!d a x. d divides a ==> d divides (x * a)+ \\ \hline - \verb+METIS_TAC [divides_def, MULT_ASSOC, MULT_SYM]+ \\ + \verb+metis_tac [divides_def, MULT_ASSOC, MULT_SYM]+ \\ \end{tabular} \item[\small{({\it DIVIDES\_RMUL\/})}] \begin{tabular}[t]{l} \verb+!d a x. d divides a ==> d divides (a * x)+ \\ \hline - \verb+METIS_TAC [MULT_SYM, DIVIDES_LMUL]+ \\ + \verb+metis_tac [MULT_SYM, DIVIDES_LMUL]+ \\ \end{tabular} \end{description} \noindent We'll assume that the above proofs have been performed, and that the appropriate ML names have been given to all of the theorems. -Now we encounter a lemma about divisibility that doesn't succumb to a +Now we encounter a lemma about divisibility that doesn't succumb to just a single invocation of \ml{METIS\_TAC}: \begin{description} \item [\small{({\it DIVIDES\_LE\/})}] \begin{tabular}[t]{l} \verb+!m n. m divides n ==> m <= n \/ (n = 0)+ \\ \hline -\verb+RW_TAC arith_ss [divides_def]+ \\ -\verb+ THEN Cases_on `x`+ \\ -\verb+ THEN RW_TAC arith_ss [MULT_CLAUSES]+ \\ +\verb+lrw[divides_def] >> lrw[]+ \\ \end{tabular} \end{description} -Let's see how this is proved. The easiest way to start is to simplify -with the definition of \ml{divides}: +Let's see how this is proved. +The easiest way to start is to simplify with the definition of \ml{divides}: \begin{session} -\begin{verbatim} -- g `!m n . m divides n ==> m <= n \/ (n = 0)`; -> ... - -- e (RW_TAC arith_ss [divides_def]); +\begin{alltt} +> g `!m n. m divides n ==> m <= n \bs{}/ (n = 0)`; ... +> e (lrw[divides_def]); +OK.. 1 subgoal: -> val it = - m <= m * x \/ (m * x = 0) -\end{verbatim} +val it = +m \(\le\) m * x \(\lor\) (m * x = 0) +\end{alltt} \end{session} -Considering the goal, we basically have three choices: (1) find a -collection of lemmas that together imply the goal and use -\ml{METIS\_TAC}; (2) do a case split on $m$; or (3) do a case split on -$x$. The first doesn't seem simple, because the goal doesn't really fit -in the `shape' of any pre-proved theorem(s) that the author knows -about. Although option (2) will be rejected in the end, let's try it -anyway. To perform the case split, we use \verb+Cases_on+, which stands -for ``find the given term in the goal and do a case split on the -possible means of building it out of datatype constructors''. Since the -occurrence of $m$ in the goal has type $num$, the cases considered will -be whether $m$ is $0$ or a successor. -\begin{session} -\begin{verbatim} -- e (Cases_on `m`); -OK.. -2 subgoals: -> val it = - SUC n <= SUC n * x \/ (SUC n * x = 0) - - 0 <= 0 * x \/ (0 * x = 0) -\end{verbatim} -\end{session} -\noindent The first subgoal (the last one printed) is trivial: +This goal is a disappointing one to have the simplifier produce. +Both disjuncts look as if they should simplify further: +the first looks as if we should be able to divide through by \holtxt{m} on both sides of the inequality, and the second looks like something we could attack with the knowledge that one of two factors must be zero if a multiplication equals zero. -\begin{session} -\begin{verbatim} -- e (RW_TAC arith_ss []); -OK.. +The relevant theorems justifying such steps have already been proved in \ml{arithmeticTheory}; something we can confirm with the generally useful \ml{DB.match} function -Goal proved. - ... -Remaining subgoals: -> val it = - SUC n <= SUC n * x \/ (SUC n * x = 0) -\end{verbatim} -\end{session} -\noindent Let's try \ml{RW\_TAC} again: -\begin{session} -\begin{verbatim} -- e (RW_TAC arith_ss []); -OK.. -1 subgoal: -> val it = - SUC n <= x * SUC n \/ (x = 0) -\end{verbatim} -\end{session} -The right disjunct has been simplified; however, the left disjunct has -failed to expand the definition of multiplication in the expression -$\mathtt{SUC}\ n * x$, which would have been convenient. In fact, it has -changed it to $x * \mathtt{SUC}\ n$, which is inconvenient. -Why, when \verb+arith_ss+ and hence \ml{RW\_TAC} is supposed to be expert in -arithmetic? The answer is twofold: first, the recursive clauses for addition and -multiplication are not in \verb+arith_ss+ because uncontrolled -application of them by the rewriter seems, in general, to make some -proofs \emph{more} complicated, rather than simpler; second, the simplifier -will rearrange arithmetical terms to make some automated proofs simpler. So -the absence of the recursive clauses for multiplication -means that $\mathtt{SUC}\ n * x$ does not expand to $(n * x) + x$; -instead, the rearrangement yields $x * \mathtt{SUC}\; n$. OK, so let's -add in the definition of multiplication. This uncovers a new problem: how -to locate this definition. The function \begin{holboxed} \begin{verbatim} DB.match : string list -> term -> ((string * string) * (thm * class)) list \end{verbatim} \end{holboxed} - -\noindent -is often helpful for such tasks. It takes a list of theory names, and -a pattern, and looks in the list of theories for any theorem, -definition, or axiom that has an instance of the pattern as a subterm. +This function takes a list of theory names, and a pattern, and looks in the list of theories for any theorem, definition, or axiom that has an instance of the pattern as a subterm. If the list of theory names is empty, then all loaded theories are -included in the search. Let's look in the theory of arithmetic for the -subterm to be rewritten. - -\begin{session} -\begin{verbatim} -- DB.match ["arithmetic"] ``SUC n * x``; - -> val it = - [(("arithmetic", "FACT"), - (|- (FACT 0 = 1) /\ !n. FACT (SUC n) = SUC n * FACT n, Def)), - (("arithmetic", "LESS_MULT_MONO"), - (|- !m i n. SUC n * m < SUC n * i = m < i, Thm)), - (("arithmetic", "MULT"), - (|- (!n. 0 * n = 0) /\ !m n. SUC m * n = m * n + n, Def)), - (("arithmetic", "MULT_CLAUSES"), - (|- !m n. - (0 * m = 0) /\ (m * 0 = 0) /\ (1 * m = m) /\ (m * 1 = m) /\ - (SUC m * n = m * n + n) /\ (m * SUC n = m + m * n), Thm)), - (("arithmetic", "MULT_LESS_EQ_SUC"), - (|- !m n p. m <= n = SUC p * m <= SUC p * n, Thm)), - (("arithmetic", "MULT_MONO_EQ"), - (|- !m i n. (SUC n * m = SUC n * i) = m = i, Thm)), - (("arithmetic", "ODD_OR_EVEN"), - (|- !n. ?m. (n = SUC (SUC 0) * m) \/ (n = SUC (SUC 0) * m + 1), Thm))] - : ... -\end{verbatim} -\end{session} - -For some, this returns slightly too much information; however, we can -focus the search by stipulating that the pattern look like a rewrite -rule: +included in the search. +Let's look in the theory of arithmetic for the subterm to be rewritten. \begin{session} -\begin{verbatim} -- DB.match [] ``SUC n * x = M``; - -> val it = - [(("arithmetic", "MULT"), - (|- (!n. 0 * n = 0) /\ !m n. SUC m * n = m * n + n, Def)), - (("arithmetic", "MULT_CLAUSES"), - (|- !m n. - (0 * m = 0) /\ (m * 0 = 0) /\ (1 * m = m) /\ (m * 1 = m) /\ - (SUC m * n = m * n + n) /\ (m * SUC n = m + m * n), Thm)), - (("arithmetic", "MULT_MONO_EQ"), - (|- !m i n. (SUC n * m = SUC n * i) = m = i, Thm))] : ... -\end{verbatim} +\begin{alltt} +> DB.match ["arithmetic"] ``m <= m * x``; +val it = + [(("arithmetic", "LE_MULT_CANCEL_LBARE"), + (|- (m \(\le\) m * n \(\iff\) (m = 0) \(\lor\) 0 < n) \(\land\) + (m \(\le\) n * m \(\iff\) (m = 0) \(\lor\) 0 < n), Thm))] + : DB.data list +\end{alltt} \end{session} -Either {\small\verb+arithmeticTheory.MULT+} or -{\small\verb+arithmeticTheory.MULT_CLAUSES+} would be acceptable; we -choose the latter. - +This is just the theorem we'd like to use. +Using \ml{DB.match} again, you should now try to find the theorem that will simplify the other disjunct. +Because both are so generally useful, \ml{lrw} already has both rewrites in its internal database, and all we need to do is rewrite once more to get those rewrites applied: \begin{session} -\begin{verbatim} -- b(); - ... - -e (RW_TAC arith_ss [MULT_CLAUSES]); - +\begin{alltt} +> e (lrw[]); OK.. -1 subgoal: -> val it = - SUC n <= x + n * x \/ (x = 0) -\end{verbatim} -\end{session} -Now we see that, in order to make progress in the proof, we will have to -do a case split on $x$ anyway, and that we should have split on it -originally. Hence we backup. We will have to backup (undo) three times: -\begin{session} -\begin{verbatim} -- b(); -> val it = - SUC n <= SUC n * x \/ (SUC n * x = 0) - -- b(); -> val it = - SUC n <= SUC n * x \/ (SUC n * x = 0) - - 0 <= 0 * x \/ (0 * x = 0) - -- b(); -> val it = - m <= m * x \/ (m * x = 0) -\end{verbatim} +Goal proved. +|- m \(\le\) m * x \(\lor\) (m * x = 0) +val it = Initial goal proved. +|- \(\forall\)m n. m divides n \(\Rightarrow\) m \(\le\) n \(\lor\) (n = 0): + proof +\end{alltt} \end{session} -Now we can go forward and do case analysis on $x$. We will also make a -compound tactic invocation, since we already know that we'll have to -invoke \ml{RW\_TAC} in both branches of the case split. This can be -done using \ml{THEN}. When $t_1 \ \mbox{\ml{THEN}}\ t_2$ is applied -to a goal $g$, first $t_1$ is applied to $g$, giving a list of new -subgoals, then $t_2$ is applied to each member of the list. All goals -resulting from these applications of $t_2$ are gathered together and -returned. +That was gratifyingly easy! +The process of {\it finding\/} the proof has now finished, and all that remains is for the proof to be packaged up into the single tactic we saw above. +Rather than use \ml{top\_thm} and the goalstack, we can bypass it and use the \ml{store\_thm} function. +This function takes a string, a term and a tactic and applies the tactic to the term to get a theorem, and then stores the theorem in the current theory under the given name. \begin{session} -\begin{verbatim} -- e (Cases_on `x` THEN RW_TAC arith_ss [MULT_CLAUSES]); -OK.. +\begin{alltt} +> val DIVIDES_LE = store_thm( + "DIVIDES_LE", + ``!m n. m divides n ==> m <= n \bs{}/ (n = 0)``, + lrw[divides_def] >> lrw[]); -Goal proved. -|- m <= m * x \/ (m * x = 0) -> val it = - Initial goal proved. - |- !m n. m divides n ==> m <= n \/ (n = 0) -\end{verbatim} -\end{session} -That was easy! Obviously making a case split on $x$ was the right -choice. The process of {\it finding\/} the proof has now finished, and -all that remains is for the proof to be packaged up into the single -tactic we saw above. Rather than use \ml{top\_thm} and the goalstack, -we can bypass it and use the \ml{store\_thm} function. This function -takes a string, a term and a tactic and applies the tactic to the term -to get a theorem, and then stores the theorem in the current theory -under the given name. -\begin{session} -\begin{verbatim} -- val DIVIDES_LE = store_thm ( - "DIVIDES_LE", - ``!m n. m divides n ==> m <= n \/ (n = 0)``, - RW_TAC arith_ss [divides_def] - THEN Cases_on `x` - THEN RW_TAC arith_ss [MULT_CLAUSES]); - -> val DIVIDES_LE = |- !m n. m divides n ==> m <= n \/ (n = 0) : thm -\end{verbatim} +val DIVIDES_LE = |- \(\forall\)m n. m divides n \(\Rightarrow\) m \(\le\) n \(\lor\) (n = 0) : thm +\end{alltt} \end{session} Storing theorems in our script record of the session in this style (rather than with the goalstack) results in a more concise script, and @@ -626,7 +436,7 @@ \subsection{Divisibility and factorial} \item [\small{({\it DIVIDES\_FACT\/})}] \begin{tabular}[t]{l} \verb+!m n. 0 < m /\ m <= n ==> m divides (FACT n)+ \\ \hline -\verb+RW_TAC arith_ss [LESS_EQ_EXISTS]+ \\ +\verb+lrw[LESS_EQ_EXISTS]+ \\ \verb+ THEN Induct_on `p`+ \\ \verb+ THEN RW_TAC arith_ss [FACT,ADD_CLAUSES]+ \\ \verb+ THENL [Cases_on `m`, ALL_TAC]+ \\ @@ -652,33 +462,45 @@ \subsection{Divisibility and factorial} cases of the induction for us. If the inductive case turns out to be not what we expect, we will have to re-think our approach. \begin{session} -\begin{verbatim} -- g `!m n. 0 < m /\ m <= n ==> m divides (FACT n)`; - -> val it = - Proof manager status: 1 proof. - 1. Incomplete: - Initial goal: - !m n. 0 < m /\ m <= n ==> m divides FACT n -\end{verbatim} +\begin{alltt} +> g `!m n. 0 < m /\bs{} m <= n ==> m divides (FACT n)`; +val it = + Proof manager status: 2 proofs. +2. Completed goalstack: |- \(\forall\)m n. m divides n \(\Rightarrow\) m \(\le\) n \(\lor\) (n = 0) +1. Incomplete goalstack: + Initial goal: + + \(\forall\)m n. 0 < m \(\land\) m \(\le\) n \(\Rightarrow\) m divides FACT n +\end{alltt} \end{session} Instead of directly inducting on $n-m$, we will induct on a witness variable, obtained by use of the theorem \verb+LESS_EQ_EXISTS+. \begin{session} -\begin{verbatim} -- LESS_EQ_EXISTS; -> val it = |- !m n. m <= n = (?p. n = m + p) : thm +\begin{alltt} +> LESS_EQ_EXISTS; +val it = |- \(\forall\)m n. m \(\le\) n \(\iff\) \(\exists\)p. n = m + p: thm -- e (RW_TAC arith_ss [LESS_EQ_EXISTS]); +> e (lrw[LESS_EQ_EXISTS]); OK.. 1 subgoal: -> val it = - m divides FACT (m + p) - ------------------------------------ - 0 < m -\end{verbatim} +val it = + +m divides FACT (m + p) +------------------------------------ + 0 < m +\end{alltt} +\end{session} +\noindent Now we want to induct on $p$, but before doing so, we should realise that the name $p$ has been chosen by the system. +In this case, it has come from the theorem \ml{LESS\_EQ\_EXISTS}, and future changes to \HOL{} are unlikely to change this behaviour. +Nonetheless, it is generally not good practice to rely on names chosen by the system. +We can make our proof much more robust at the cost of slight wordiness by using the \ml{qcase\_tac} tactic: +\begin{session} +\begin{alltt} +> qcase_tac; +val it = fn : term quotation -> tactic +\end{alltt} \end{session} -\noindent Now we induct on $p$: +This tactic takes a \emph{quotation} as an argument corresponding to a pattern that appears somewhere within the goal, and then renames the variables in the goal to match those in the pattern. \begin{session} \begin{verbatim} - e (Induct_on `p`); From 90b17d3bb45f6c414ddbb9e093f26aeb4d69d356 Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Fri, 8 Jan 2016 11:51:09 +0000 Subject: [PATCH 600/718] Fix glitch in prelude.ML. The wrong "use" was been used in vimhol. --- tools-poly/prelude.ML | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools-poly/prelude.ML b/tools-poly/prelude.ML index fbdd581b2d..76f6831242 100644 --- a/tools-poly/prelude.ML +++ b/tools-poly/prelude.ML @@ -183,7 +183,7 @@ in handle e => (try_remove filename; raise e) end else PolyML.use s -end (* local *) +end; (* local *) local infix ++ From b40ac5b131d1f318ab0b1cfd1dea2644e5a18f1a Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Sat, 9 Jan 2016 09:40:47 +1100 Subject: [PATCH 601/718] Better diagnostics if buildheap fails --- tools-poly/buildheap.ML | 3 +++ 1 file changed, 3 insertions(+) diff --git a/tools-poly/buildheap.ML b/tools-poly/buildheap.ML index 69d07ea81c..4c8ea33eea 100644 --- a/tools-poly/buildheap.ML +++ b/tools-poly/buildheap.ML @@ -52,7 +52,10 @@ fun create_heap (objs, outputheap, base) = let if OS.Process.isSuccess (Systeml.system_ps s) then () else die ("*** Failed to execute\n "^s^"\nsuccessfully") in + p ("fun die s = (TextIO.output(TextIO.stdErr, s ^ \"\\n\"); \ + \OS.Process.exit OS.Process.failure)"); p ("val _ = PolyML.SaveState.loadState \"" ^ String.toString base ^ "\"\n"); + p (" handle e => die (General.exnMessage e)"); p ("val heapname = \""^outputheap^"\";"); p "local"; p "fun hload s = (print (\"Loading \"^s^\"\\n\"); load s)"; From edfce75396f2d231b172ea814c029deeb66a76c3 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Sat, 9 Jan 2016 12:43:30 +1100 Subject: [PATCH 602/718] When creating heaps store absolute path names Otherwise, you can end up with a heap storing a reference to something like ../heap, and this then means that the heap can't be loaded except in the directory where it was created. --- tools-poly/buildheap.ML | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/tools-poly/buildheap.ML b/tools-poly/buildheap.ML index 4c8ea33eea..143f90f481 100644 --- a/tools-poly/buildheap.ML +++ b/tools-poly/buildheap.ML @@ -43,7 +43,9 @@ in recurse args ([], NONE, NONE) end -fun create_heap (objs, outputheap, base) = let +fun mkAbs p = OS.Path.mkAbsolute {relativeTo = OS.FileSys.getDir(), path = p} + +fun create_heap (objs, outputheap0, base0) = let open Systeml val ofile = OS.FileSys.tmpName() val ostrm = openOut ofile @@ -51,6 +53,8 @@ fun create_heap (objs, outputheap, base) = let fun system_ps s = if OS.Process.isSuccess (Systeml.system_ps s) then () else die ("*** Failed to execute\n "^s^"\nsuccessfully") + val outputheap = mkAbs outputheap0 + val base = mkAbs base0 in p ("fun die s = (TextIO.output(TextIO.stdErr, s ^ \"\\n\"); \ \OS.Process.exit OS.Process.failure)"); From 840264ddb9f52a2076a3b9cc5b833c16d236d392 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Sun, 10 Jan 2016 21:11:45 +1100 Subject: [PATCH 603/718] Make hol.state0 build fail properly Previously the load of the source files might not compile and yet the build would proceed. --- tools-poly/builder0.ML | 1 + 1 file changed, 1 insertion(+) diff --git a/tools-poly/builder0.ML b/tools-poly/builder0.ML index 67bd7e56dc..45c17bc692 100644 --- a/tools-poly/builder0.ML +++ b/tools-poly/builder0.ML @@ -14,6 +14,7 @@ local (Systeml.HOLDIR ++ "sigobj") :: (!loadPath) val _ = app load ["boolLib", "proofManagerLib", "Arbrat"] + handle e => OS.Process.exit OS.Process.failure fun safe_use s = if String.sub (s, 0) = #"-" then () else use s fun main () = (List.app safe_use (CommandLine.arguments ()) From 5b30ce41a3b38d0d66c957c59a96c64514a10120 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Sun, 10 Jan 2016 16:43:26 +1100 Subject: [PATCH 604/718] Quote filter now outputs via user-provided fns Previously it targeted a TextIO.outstream, only assuming output and flush operations. --- tools/quote-filter/filter | 25 ++++++++++++++----------- tools/quote-filter/poly-unquote.ML | 4 +++- tools/quote-filter/quote-filter.sml | 5 ++++- 3 files changed, 21 insertions(+), 13 deletions(-) diff --git a/tools/quote-filter/filter b/tools/quote-filter/filter index cca2dd5606..3b239bf343 100644 --- a/tools/quote-filter/filter +++ b/tools/quote-filter/filter @@ -4,26 +4,29 @@ fun dec r = (r := !r - 1) fun bslash_escape s = "\\" ^ Int.toString (Char.ord(String.sub(s,0))) -datatype qfs = QFS of {output_stream : TextIO.outstream, +datatype qfs = QFS of {output_stream : string -> unit, + flush : unit -> unit, comdepth : int ref, pardepth : int ref, antiquote: bool ref, row : int ref, rowstart : int ref} -fun newstate os = QFS {output_stream = os, - comdepth = ref 0, - pardepth = ref 0, - antiquote = ref false, - row = ref 0, - rowstart = ref 0} +fun newstate (os,flush) = + QFS {output_stream = os, + flush = flush, + comdepth = ref 0, + pardepth = ref 0, + antiquote = ref false, + row = ref 0, + rowstart = ref 0} fun resetstate (QFS{comdepth, pardepth, antiquote,...}) = (comdepth := 0; pardepth := 0; antiquote := false) -fun ECHO (QFS {output_stream , ...}) s = TextIO.output(output_stream, s) -fun print (QFS {output_stream, ...}) s = TextIO.output(output_stream, s) +fun ECHO (QFS {output_stream , ...}) s = output_stream s +fun print (QFS {output_stream, ...}) s = output_stream s fun makesafe c = if not (Char.isPrint c) then "\\" ^ Int.toString (Char.ord c) @@ -54,7 +57,7 @@ fun locpragma (QFS {row, rowstart, ...}) (s,pos) off nised when prepended by a paren or symbol char. --KW See cvs log comment at rev 1.2 of src/parse/base_tokens.lex *) -fun flushOut (QFS {output_stream,...}) = TextIO.flushOut output_stream +fun flushOut (QFS {flush,...}) = flush() fun newline (arg as QFS q) (yypos,yytext) = (print arg "\n"; @@ -82,7 +85,7 @@ fun eof arg = ("", 0) %% %structure filter %s string comment qcomment tmcomment tycomment tyquote tmquote quote ANTIQ; -%arg (UserDeclarations.QFS {output_stream, comdepth, pardepth, antiquote, row, rowstart}); +%arg (UserDeclarations.QFS {output_stream, flush, comdepth, pardepth, antiquote, row, rowstart}); %full letter = [A-Za-z]; diff --git a/tools/quote-filter/poly-unquote.ML b/tools/quote-filter/poly-unquote.ML index 8285ac4b13..922c1749af 100644 --- a/tools/quote-filter/poly-unquote.ML +++ b/tools/quote-filter/poly-unquote.ML @@ -39,7 +39,9 @@ fun main() = let Kenn Heinrich who helped me see the light with respect to this code *) open filter.UserDeclarations - val state as QFS args = newstate outstream + val state as QFS args = + newstate ((fn s => TextIO.output(outstream, s)), + (fn () => TextIO.flushOut outstream)) fun loop() = let val lexer = filter.makeLexer (read_from_stream instream) state diff --git a/tools/quote-filter/quote-filter.sml b/tools/quote-filter/quote-filter.sml index 12af463505..7394d8181f 100644 --- a/tools/quote-filter/quote-filter.sml +++ b/tools/quote-filter/quote-filter.sml @@ -31,7 +31,10 @@ val (instream, outstream) = exit failure) open filter.UserDeclarations -val state as QFS args = newstate outstream +val state as QFS args = + newstate ((fn s => TextIO.output(outstream, s)), + (fn () => TextIO.flushOut outstream)) + (* with many thanks to Ken Friis Larsen, Peter Sestoft, Claudio Russo and Kenn Heinrich who helped me see the light with respect to this code *) From 19d9f186fa615dafe43a49b5ec7829794dcc435c Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Sun, 10 Jan 2016 17:50:33 +1100 Subject: [PATCH 605/718] Make Feedback streams fns rather than outstreams Allows a smidge more generality --- src/TeX/mkmunger.sml | 4 +++- src/TeX/warning_stream.sml | 4 +++- src/prekernel/Feedback.sig | 6 +++--- src/prekernel/Feedback.sml | 40 ++++++++++++++------------------------ 4 files changed, 24 insertions(+), 30 deletions(-) diff --git a/src/TeX/mkmunger.sml b/src/TeX/mkmunger.sml index 60976dc460..0ce2a11d35 100644 --- a/src/TeX/mkmunger.sml +++ b/src/TeX/mkmunger.sml @@ -4,7 +4,9 @@ structure UD = mungeLex.UserDeclarations in fun munger eatfirstNL () = let val () = Feedback.emit_MESG := false - val () = Feedback.WARNING_outstream := TextIO.stdErr + val () = Feedback.WARNING_outstream := + (fn s => (TextIO.output(TextIO.stdErr, s); + TextIO.flushOut TextIO.stdErr)) val () = set_trace "Unicode" 1 val () = set_trace "pp_dollar_escapes" 1 val () = set_trace "ambiguous grammar warning" 2 diff --git a/src/TeX/warning_stream.sml b/src/TeX/warning_stream.sml index 95d8f82ddb..5c295c38bb 100644 --- a/src/TeX/warning_stream.sml +++ b/src/TeX/warning_stream.sml @@ -1 +1,3 @@ -val () = Feedback.WARNING_outstream := TextIO.stdErr +val () = Feedback.WARNING_outstream := + (fn s => (TextIO.output(TextIO.stdErr, s); + TextIO.flushOut TextIO.stdErr)) diff --git a/src/prekernel/Feedback.sig b/src/prekernel/Feedback.sig index 336430f9cf..315c6032ab 100644 --- a/src/prekernel/Feedback.sig +++ b/src/prekernel/Feedback.sig @@ -15,9 +15,9 @@ sig val emit_WARNING : bool ref val WARNINGs_as_ERRs : bool ref - val ERR_outstream : TextIO.outstream ref - val MESG_outstream : TextIO.outstream ref - val WARNING_outstream : TextIO.outstream ref + val ERR_outstream : (string -> unit) ref + val MESG_outstream : (string -> unit) ref + val WARNING_outstream : (string -> unit) ref val format_ERR : error_record -> string val format_MESG : string -> string diff --git a/src/prekernel/Feedback.sml b/src/prekernel/Feedback.sml index 65a9e764c8..dc212ba4c6 100644 --- a/src/prekernel/Feedback.sml +++ b/src/prekernel/Feedback.sml @@ -42,9 +42,6 @@ val ERR = mk_HOL_ERR "Feedback" (* local to this file *) Misc. utilities ---------------------------------------------------------------------------*) -val output = TextIO.output -val flush_out = TextIO.flushOut - fun quote s = String.concat ["\"", s, "\""] fun assoc1 item = @@ -65,9 +62,11 @@ val emit_MESG = ref true val emit_WARNING = ref true val WARNINGs_as_ERRs = ref false -val ERR_outstream = ref TextIO.stdErr -val MESG_outstream = ref TextIO.stdOut -val WARNING_outstream = ref TextIO.stdOut +fun out strm s = (TextIO.output(strm, s); TextIO.flushOut strm) + +val ERR_outstream = ref (out TextIO.stdErr) +val MESG_outstream = ref (out TextIO.stdOut) +val WARNING_outstream = ref (out TextIO.stdOut) (*---------------------------------------------------------------------------* * Formatting and output for exceptions, messages, and warnings. * @@ -90,10 +89,7 @@ val ERR_to_string = ref format_ERR val MESG_to_string = ref format_MESG val WARNING_to_string = ref format_WARNING -fun output_ERR s = - if !emit_ERR - then (output (!ERR_outstream, s); flush_out (!ERR_outstream)) - else () +fun output_ERR s = if !emit_ERR then !ERR_outstream s else () (*--------------------------------------------------------------------------- Makes an informative message from an exception. Subtlety: if we see @@ -130,28 +126,22 @@ fun wrap_exn_loc s f l Portable.Interrupt = raise Portable.Interrupt | wrap_exn_loc s f l exn = mk_HOL_ERRloc s f l (General.exnMessage exn) fun HOL_MESG s = - if !emit_MESG - then (output (!MESG_outstream, !MESG_to_string s) - ; flush_out (!MESG_outstream)) - else () + if !emit_MESG then !MESG_outstream (!MESG_to_string s) else () fun HOL_PROGRESS_MESG (start, finish) f x = - if !emit_MESG - then let - val () = output (!MESG_outstream, "<>\n") - ; flush_out (!MESG_outstream)) - end + if !emit_MESG then + let + in + !MESG_outstream ("<>\n") + end else f x fun HOL_WARNING s1 s2 s3 = if !WARNINGs_as_ERRs then raise mk_HOL_ERR s1 s2 s3 else if !emit_WARNING then - (output (!WARNING_outstream, !WARNING_to_string s1 s2 s3) - ; flush_out (!WARNING_outstream)) + !WARNING_outstream (!WARNING_to_string s1 s2 s3) else () fun HOL_WARNINGloc s1 s2 locn s3 = From dbb529c41f218a1e4e3bccb4db441de0d37b080b Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Sun, 10 Jan 2016 21:03:33 +1100 Subject: [PATCH 606/718] Tie Lib.say to Feedback.MESG_outstream --- src/prekernel/Lib.sml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/prekernel/Lib.sml b/src/prekernel/Lib.sml index 818a74cc40..7ba785650c 100644 --- a/src/prekernel/Lib.sml +++ b/src/prekernel/Lib.sml @@ -685,7 +685,7 @@ val string_to_int = val saying = ref true -fun say s = if !saying then TextIO.print s else () +fun say s = if !saying then !Feedback.MESG_outstream s else () (*--------------------------------------------------------------------------- quote puts double quotes around a string. mlquote does this as well, From 72e794462dfa39f2d1f14d194df5cd054daf8dd0 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Sun, 10 Jan 2016 21:13:09 +1100 Subject: [PATCH 607/718] Tie all chatting in goalstack to Lib.say --- src/proofman/goalStack.sml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/proofman/goalStack.sml b/src/proofman/goalStack.sml index b5b9779655..ca91765d0a 100644 --- a/src/proofman/goalStack.sml +++ b/src/proofman/goalStack.sml @@ -35,7 +35,7 @@ fun say s = if !chatting then Lib.say s else (); fun add_string_cr s = say (s^"\n") fun cr_add_string_cr s = say ("\n"^s^"\n") -fun printthm th = if !chatting then Parse.print_thm th else () +fun printthm th = if !chatting then say (Parse.thm_to_string th) else () fun rotl (a::rst) = rst@[a] | rotl [] = raise ERR "rotl" "empty list" From 976bf75398b3d866d46c2c33e61d76e182e14123 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Sun, 10 Jan 2016 17:20:16 +1100 Subject: [PATCH 608/718] Executable for running HOL sessions in text files Lines not preceded with >> are passed unchanged to the output; lines with >> are executed in a HOL session with the input and output of this passed onto standard out. Lines with >>_ are evaluated but the output is replaced by "output elided". --- Manual/Tools/.gitignore | 1 + Manual/Tools/Holmakefile | 4 + Manual/Tools/README | 20 ++++ Manual/Tools/polyscripter.sml | 196 ++++++++++++++++++++++++++++++++++ Manual/Tools/umap | 16 +++ 5 files changed, 237 insertions(+) create mode 100644 Manual/Tools/.gitignore create mode 100644 Manual/Tools/Holmakefile create mode 100644 Manual/Tools/README create mode 100644 Manual/Tools/polyscripter.sml create mode 100644 Manual/Tools/umap diff --git a/Manual/Tools/.gitignore b/Manual/Tools/.gitignore new file mode 100644 index 0000000000..5084933564 --- /dev/null +++ b/Manual/Tools/.gitignore @@ -0,0 +1 @@ +polyscripter diff --git a/Manual/Tools/Holmakefile b/Manual/Tools/Holmakefile new file mode 100644 index 0000000000..98fd8695b0 --- /dev/null +++ b/Manual/Tools/Holmakefile @@ -0,0 +1,4 @@ +EXTRA_CLEANS = polyscripter + +polyscripter: polyscripter.sml $(dprot $(HOLDIR)/bin/hol.state) + $(POLYC) $< -o $@ diff --git a/Manual/Tools/README b/Manual/Tools/README new file mode 100644 index 0000000000..73e62f3b0c --- /dev/null +++ b/Manual/Tools/README @@ -0,0 +1,20 @@ +# The `polyscripter` Tool + +The `polyscripter` tool is a Unix filter program that passes most input lines unchanged, but looks out for those lines beginning with `>>` characters. +If it sees one such, it executes the Poly/ML compiler on that line, captures the result and then emits the input and the response to standard out. + +## Inline Options + +- The usual `>>` command gets the input after this prompt read until the next line that begins with a non-space character. +- The `>>_` command gets the compiler to act on the accompanying input, and this input is printed out, but the output is elided + +## Command-line Options + +- If `polyscripter` is passed a filename as its first argument, this file is read, and treated as a dictionary mapping single (UTF8) characters to replacement strings (with character separated from mapping by whitespace). + This mapping is applied to user-input strings (after the `>>`) and to compiler output as well. + An example mapping would include lines such as + + ∀ \(\forall\) + ∧ \(\land\) + + A mapping for LaTeX `alltt` type environments should also handle backslash and brace characters. diff --git a/Manual/Tools/polyscripter.sml b/Manual/Tools/polyscripter.sml new file mode 100644 index 0000000000..a73c8c20a1 --- /dev/null +++ b/Manual/Tools/polyscripter.sml @@ -0,0 +1,196 @@ +val _ = PolyML.SaveState.loadState "../../bin/hol.state"; + +val _ = use "../../tools-poly/prelude.ML"; +val _ = use "../../tools-poly/prelude2.ML"; +val _ = PolyML.print_depth 0; + +fun mkBuffer () = let + val buf = ref ([] : string list) + fun push s = buf := s :: !buf + fun read () = let + val contents = String.concat (List.rev (!buf)) + in + buf := [contents]; + contents + end + fun reset() = buf := [] +in + (push, read, reset) +end; + +use "../../tools/quote-filter/filter.sml"; + +val (QBpush, QBread, QBreset) = mkBuffer() +val qstate = filter.UserDeclarations.newstate(QBpush, fn () => ()) + +fun readFromString s = + let + val sz = size s + val i = ref 0 + fun read _ = + if !i < sz then str (String.sub(s, !i)) before i := !i + 1 + else "" + in + read + end + +fun quote s = + (QBreset() ; filter.makeLexer (readFromString s) qstate () ; + QBread()) + +fun die s = (TextIO.output(TextIO.stdErr, s ^ "\n"); + OS.Process.exit OS.Process.failure) + +datatype lbuf = + LB of { + currentOpt : string option ref, + strm : TextIO.instream , + line : int ref + } + +fun current (LB {currentOpt, ...}) = !currentOpt +fun linenum (LB {line, ...}) = !line +fun advance (LB {strm, currentOpt, line}) = + (currentOpt := TextIO.inputLine strm ; + line := !line + 1) + +fun mklbuf strm = + let + val lb = LB {currentOpt = ref NONE, strm = strm, line = ref 0} + val _ = advance lb + in + lb + end + +fun mkLex s = let + val i = ref 0 + val sz = size s + fun doit () = + if !i < sz then SOME (String.sub(s,!i)) before i := !i + 1 + else NONE +in + doit +end + +fun compiler (obufPush, obufRD, _) linenum infn = let + fun record_error {message,...} = PolyML.prettyPrint(obufPush,70) message +in + PolyML.compiler(infn, + [PolyML.Compiler.CPErrorMessageProc record_error, + PolyML.Compiler.CPOutStream obufPush]) () + handle e => die ("Exception raised on line " ^ Int.toString linenum ^ ": "^ + obufRD() ^ General.exnMessage e); + obufRD() +end + +fun umunge umap s = + let + fun recurse acc s = + case UTF8.getChar s of + NONE => String.concat (List.rev acc) + | SOME ((c, _), rest) => + case Binarymap.peek(umap, c) of + NONE => recurse (c :: acc) rest + | SOME s => recurse (s :: acc) rest + in + recurse [] s + end + +fun process_line umap (obuf as (_, _, obRST)) line lbuf = let + fun getRest acc = + let + val _ = advance lbuf + in + case current lbuf of + NONE => String.concat (List.rev acc) + | SOME s => if String.size s > 1 andalso + Char.isSpace (String.sub(s,0)) + then + getRest (String.extract(s,1,NONE)::acc) + else + String.concat (List.rev acc) + end +in + if String.isPrefix ">>_" line then + let + val firstline = String.extract(line, 3, NONE) + val input = getRest [firstline] + val _ = compiler obuf (linenum lbuf) (mkLex (quote input)) + in + (umunge umap input, SOME " ... output elided ...\n") + end + else if String.isPrefix ">>" line then + let + val _ = obRST() + val firstline = String.extract(line, 2, NONE) + val input = getRest [firstline] + in + (umunge umap input, + SOME (umunge umap (compiler obuf (linenum lbuf) (mkLex (quote input))))) + end + else + (advance lbuf; (line, NONE)) +end + +fun read_umap fname = + let + val instrm = TextIO.openIn fname + fun recurse (i, acc) = + case TextIO.inputLine instrm of + SOME line => + (if size line <= 1 then recurse (i + 1, acc) + else + case UTF8.getChar line of + NONE => die ("read_umap: should never happen") + | SOME ((cstr, _), rest) => + let + val restss = Substring.full rest + val range = + restss |> Substring.dropl Char.isSpace + |> Substring.dropr Char.isSpace + |> Substring.string + in + recurse(i + 1, Binarymap.insert(acc, cstr, range)) + end) + | NONE => acc + in + recurse(1, Binarymap.mkDict String.compare) + end + + +fun usage() = + "Usage:\n "^ CommandLine.name() ^ " [umapfile]" + +fun main () = + let + val _ = PolyML.print_depth 100; + val _ = Parse.current_backend := PPBackEnd.raw_terminal + val umap = + case CommandLine.arguments() of + [] => Binarymap.mkDict String.compare + | [name] => read_umap name + | _ => die (usage()) + val (obuf as (obPush, _, _)) = mkBuffer() + val _ = Feedback.ERR_outstream := obPush + val _ = Feedback.WARNING_outstream := obPush + val _ = Feedback.MESG_outstream := obPush + val cvn = PolyML.Compiler.compilerVersionNumber + val _ = if cvn = 551 orelse cvn = 552 then + ignore (TextIO.inputLine TextIO.stdIn) + else () + val lb = mklbuf TextIO.stdIn + fun recurse lb : unit= + case current lb of + NONE => () + | SOME line => + let + val (i, coutopt) = process_line umap obuf line lb + in + (case coutopt of + NONE => print i + | SOME out => print (">" ^ i ^ out)); + recurse lb + end + in + recurse lb + end diff --git a/Manual/Tools/umap b/Manual/Tools/umap new file mode 100644 index 0000000000..a78cdd3882 --- /dev/null +++ b/Manual/Tools/umap @@ -0,0 +1,16 @@ +∀ \(\forall\) +∃ \(\exists\) +\ \bs{} +⇒ \(\Rightarrow\) +∧ \(\land\) +∨ \(\lor\) +¬ \(\neg\) +⇔ \(\iff\) +≠ \(\ne\) +λ \(\lambda\) +α \(\alpha\) +β \(\beta\) +γ \(\gamma\) +∈ \(\in\) +∪ \(\cup\) +∩ \(\cap\) From ecb2be84debbb927edd2c960501b6bb9c4fd647d Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Sun, 10 Jan 2016 20:53:52 +1100 Subject: [PATCH 609/718] Demonstrate polyscripter on Euclid in TUTORIAL --- Manual/Tutorial/.gitignore | 1 + Manual/Tutorial/Holmakefile | 7 +++ Manual/Tutorial/Makefile | 29 ---------- Manual/Tutorial/{euclid.tex => euclid.stex} | 63 +++++---------------- 4 files changed, 21 insertions(+), 79 deletions(-) create mode 100644 Manual/Tutorial/.gitignore create mode 100644 Manual/Tutorial/Holmakefile delete mode 100644 Manual/Tutorial/Makefile rename Manual/Tutorial/{euclid.tex => euclid.stex} (98%) diff --git a/Manual/Tutorial/.gitignore b/Manual/Tutorial/.gitignore new file mode 100644 index 0000000000..444ea9e8b3 --- /dev/null +++ b/Manual/Tutorial/.gitignore @@ -0,0 +1 @@ +euclid.tex diff --git a/Manual/Tutorial/Holmakefile b/Manual/Tutorial/Holmakefile new file mode 100644 index 0000000000..ccec5e8528 --- /dev/null +++ b/Manual/Tutorial/Holmakefile @@ -0,0 +1,7 @@ +INCLUDES = ../Tools + +tutorial.pdf: tutorial.tex euclid.tex logic.tex preface.tex proof-tools.tex theories.tex combin.tex + latexmk -pdf tutorial + +euclid.tex: euclid.stex ../Tools/umap ../Tools/polyscripter + ../Tools/polyscripter ../Tools/umap < $< > $@ diff --git a/Manual/Tutorial/Makefile b/Manual/Tutorial/Makefile deleted file mode 100644 index 3994a97e16..0000000000 --- a/Manual/Tutorial/Makefile +++ /dev/null @@ -1,29 +0,0 @@ -# ===================================================================== -# Makefile for the hol TUTORIAL -# ===================================================================== - -PDFLATEX=pdflatex -DVILATEX=latex - -CHAPTERS = title.tex preface.tex intro.tex ml.tex logic.tex euclid.tex \ - parity.tex combin.tex proof-tools.tex more-examples.tex references.tex -OTHERS = ../LaTeX/commands.tex ../LaTeX/layout.sty ../LaTeX/ack.tex \ - ../LaTeX/proof.sty - -default: pdf -all: ps pdf -ps: tutorial.ps -pdf: tutorial.pdf - -clean: - rm -f *.dvi *.aux *.toc *.log tutorial.ps tutorial.pdf - -tutorial.pdf: tutorial.tex $(CHAPTERS) $(OTHER) - ${PDFLATEX} tutorial.tex ; ${PDFLATEX} tutorial.tex - -tutorial.dvi: tutorial.tex $(CHAPTERS) $(OTHER) - ${DVILATEX} tutorial.tex ; ${DVILATEX} tutorial.tex - -tutorial.ps: tutorial.dvi - dvips -Ppdf -G0 -f tutorial.dvi > tutorial.ps.tmp - mv tutorial.ps.tmp $@ diff --git a/Manual/Tutorial/euclid.tex b/Manual/Tutorial/euclid.stex similarity index 98% rename from Manual/Tutorial/euclid.tex rename to Manual/Tutorial/euclid.stex index 857f017b97..1a1e5042f8 100644 --- a/Manual/Tutorial/euclid.tex +++ b/Manual/Tutorial/euclid.stex @@ -23,8 +23,7 @@ \chapter{Example: Euclid's Theorem} We then ``\ml{open}'' the arithmetic theory; this means that all of the \ML{} bindings from the \HOL{} theory of arithmetic are made available at the top level. \begin{session} \begin{verbatim} -- open arithmeticTheory; - ... +>>_ open arithmeticTheory; \end{verbatim} \end{session} We now begin the formalization. In order to define the concept of @@ -32,11 +31,7 @@ \chapter{Example: Euclid's Theorem} \begin{session} \begin{alltt} -- val divides_def = Define `divides a b = ?x. b = a * x`; - -Definition has been stored under "divides_def". -val divides_def = - |- \(\forall\)a b. divides a b \(\iff\) \(\exists\)x. b = a * x : thm +>> val divides_def = Define`divides a b = ?x. b = a * x`; \end{alltt} \end{session} Note how we are using ASCII notation to input our terms, but the system responds with pleasant Unicode. @@ -54,7 +49,7 @@ \chapter{Example: Euclid's Theorem} We want to treat \ml{divides} as a (non-associating) infix: \begin{session} \begin{verbatim} -- set_fixity "divides" (Infix(NONASSOC, 450)); +>>_ set_fixity "divides" (Infix(NONASSOC, 450)); \end{verbatim} \end{session} Next we define the property of a number being \emph{prime}: a number $p$ is @@ -63,13 +58,8 @@ \chapter{Example: Euclid's Theorem} \begin{session} \begin{alltt} -- val prime_def = +>> val prime_def = Define `prime p = p <> 1 /\ !x. x divides p ==> (x=1) \/ (x=p)`; - -Definition has been stored under "prime_def". -val prime_def = - |- \(\forall\)p. prime p \(\iff\) p \(\ne\) 1 \(\land\) \(\forall\)x. x divides p \(\Rightarrow\) (x = 1) \(\lor\) (x = p) - : thm \end{alltt} \end{session} @@ -88,10 +78,9 @@ \chapter{Example: Euclid's Theorem} mind. In this example, we often \emph{find} proofs by using the rewriter \ml{rw} to unwind definitions and perform basic simplifications, often reducing a goal to its essence. \begin{session} -\begin{verbatim} -rw; -val it = fn :thm list -> tactic -\end{verbatim} +\begin{alltt} +>> rw; +\end{alltt} \end{session} When \ml{rw} is applied to a list of theorems, the theorems will be added to \HOL{}'s built-in database of useful facts as supplementary rewrite rules. We will see that \ml{rw} is also somewhat knowledgeable about @@ -160,15 +149,7 @@ \section{Divisibility} \begin{session} \begin{alltt} -- g `!x. x divides 0`; - -> val it = - Proof manager status: 1 proof. - 1. Incomplete: - Initial goal: - \(\forall\)x. x divides 0 - - : proofs +>> g `!x. x divides 0`; \end{alltt} \end{session} The proof manager tells us that it has only one proof to manage, and @@ -177,39 +158,21 @@ \section{Divisibility} keep distinct the $x$ of the goal and the $x$ in the definition of \ml{divides}: \begin{session} -\begin{verbatim} -- e (lrw[divides_def]); -OK.. -<> -1 subgoal: -val it = -\(\exists\)x'. (x = 0) \/ (x' = 0) -\end{verbatim} +\begin{alltt} +>> e (lrw[divides_def]); +\end{alltt} \end{session} It is of course quite easy to instantiate the existential quantifier by hand. \begin{session} \begin{alltt} -- e (qexists_tac `0`); -OK.. -1 subgoal: -val it = -(x = 0) \(\lor\) (0 = 0) +>> e (qexists_tac `0`); \end{alltt} \end{session} Then a simplification step finishes the proof. \begin{session} \begin{alltt} -- e (lrw[]); -OK.. - -Goal proved. -|- (x = 0) \(\lor\) (0 = 0) - -Goal proved. -|- \(\exists\)x'. (x = 0) \(\lor\) (x' = 0) -val it = Initial goal proved. -|- \(\forall\)x. x divides 0: proof +>> e (lrw[]); \end{alltt} \end{session} From 34be9d4cf108563854cc8d767a2827d07713e0bc Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 11 Jan 2016 11:51:26 +1100 Subject: [PATCH 610/718] Tie metis tracing to Lib.say --- src/metis/mlibUseful.sml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/metis/mlibUseful.sml b/src/metis/mlibUseful.sml index b603417279..65dddacdca 100644 --- a/src/metis/mlibUseful.sml +++ b/src/metis/mlibUseful.sml @@ -82,7 +82,7 @@ in end; end; -val trace = print; +val trace = Lib.say; (* ------------------------------------------------------------------------- *) (* Combinators *) From 4d3844c58577a34a428e42c2fd0c2a391e876fb0 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 11 Jan 2016 11:51:59 +1100 Subject: [PATCH 611/718] =?UTF-8?q?Handle=20=E2=87=94=20better,=20handle?= =?UTF-8?q?=20=E2=89=A4=20in=20polyscripter's=20umap?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Manual/Tools/umap | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/Manual/Tools/umap b/Manual/Tools/umap index a78cdd3882..fa1d2d8117 100644 --- a/Manual/Tools/umap +++ b/Manual/Tools/umap @@ -5,8 +5,9 @@ ∧ \(\land\) ∨ \(\lor\) ¬ \(\neg\) -⇔ \(\iff\) +⇔ \({\iff}\) ≠ \(\ne\) +≤ \(\le\) λ \(\lambda\) α \(\alpha\) β \(\beta\) From ec15f9deab9091eda30b593291cb6fd2172d6680 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 11 Jan 2016 11:56:48 +1100 Subject: [PATCH 612/718] Give polyscripter ability to silently 'use' files --- Manual/Tools/README | 10 ++++-- Manual/Tools/polyscripter.sml | 64 +++++++++++++++++++++++++++++------ 2 files changed, 61 insertions(+), 13 deletions(-) diff --git a/Manual/Tools/README b/Manual/Tools/README index 73e62f3b0c..8086bf5a9b 100644 --- a/Manual/Tools/README +++ b/Manual/Tools/README @@ -5,8 +5,14 @@ If it sees one such, it executes the Poly/ML compiler on that line, captures the ## Inline Options -- The usual `>>` command gets the input after this prompt read until the next line that begins with a non-space character. -- The `>>_` command gets the compiler to act on the accompanying input, and this input is printed out, but the output is elided +All of the following inline commands must begin the line in which they occur: + +- The usual `>>` command gets the input after this prompt read until the next line that begins with a non-space character. +- The `>>_` command gets the compiler to act on the accompanying input, and this input is printed out, but the output is elided +- The `>>__` command gets the compiler to act on the accompanying input, but nothing is printed out (strictly, this line is replaced by a blank line). +- The `##use` command gets the compiler to evaluate the `use` the filename. + The filename is given after a single space character and is the rest of the line; it need not be quoted, and shouldn’t be followed by a semicolon. + The compilation and evaluation of the filename is done entirely silently. ## Command-line Options diff --git a/Manual/Tools/polyscripter.sml b/Manual/Tools/polyscripter.sml index a73c8c20a1..a51c3fe86d 100644 --- a/Manual/Tools/polyscripter.sml +++ b/Manual/Tools/polyscripter.sml @@ -4,6 +4,12 @@ val _ = use "../../tools-poly/prelude.ML"; val _ = use "../../tools-poly/prelude2.ML"; val _ = PolyML.print_depth 0; +fun die s = (TextIO.output(TextIO.stdErr, s ^ "\n"); + OS.Process.exit OS.Process.failure) +fun lnumdie linenum extra exn = + die ("Exception raised on line " ^ Int.toString linenum ^ ": "^ + extra ^ General.exnMessage exn) + fun mkBuffer () = let val buf = ref ([] : string list) fun push s = buf := s :: !buf @@ -35,11 +41,19 @@ fun readFromString s = end fun quote s = - (QBreset() ; filter.makeLexer (readFromString s) qstate () ; + (QBreset() ; filter.makeLexer (readFromString s) qstate (); QBread()) -fun die s = (TextIO.output(TextIO.stdErr, s ^ "\n"); - OS.Process.exit OS.Process.failure) +fun quoteFile lnum fname = + let + val instrm = TextIO.openIn fname handle e => lnumdie lnum "" e + in + QBreset() ; + filter.makeLexer (fn n => TextIO.input instrm) qstate (); + TextIO.closeIn instrm; + QBread() + end + datatype lbuf = LB of { @@ -72,17 +86,29 @@ in doit end -fun compiler (obufPush, obufRD, _) linenum infn = let +fun compiler (obufPush, obufRD, obufRST) linenum infn = let fun record_error {message,...} = PolyML.prettyPrint(obufPush,70) message + fun rpt acc = + (obufRST(); + PolyML.compiler(infn, + [PolyML.Compiler.CPErrorMessageProc record_error, + PolyML.Compiler.CPOutStream obufPush]) () + handle e => lnumdie linenum (obufRD()) e; + if obufRD() = "" then String.concat (List.rev acc) + else rpt (obufRD() :: acc)) in - PolyML.compiler(infn, - [PolyML.Compiler.CPErrorMessageProc record_error, - PolyML.Compiler.CPOutStream obufPush]) () - handle e => die ("Exception raised on line " ^ Int.toString linenum ^ ": "^ - obufRD() ^ General.exnMessage e); - obufRD() + rpt [] end +fun silentUse lnum s = + let + val filecontents = quoteFile lnum s + val buf = mkBuffer() + in + compiler buf 1 (mkLex filecontents) + end + + fun umunge umap s = let fun recurse acc s = @@ -111,7 +137,23 @@ fun process_line umap (obuf as (_, _, obRST)) line lbuf = let String.concat (List.rev acc) end in - if String.isPrefix ">>_" line then + if String.isPrefix "##use " line then + let + val fname = String.substring(line, 6, size line - 7) (* for \n at end *) + val _ = silentUse (linenum lbuf) fname + val _ = advance lbuf + in + ("\n", NONE) + end + else if String.isPrefix ">>__" line then + let + val firstline = String.extract(line, 4, NONE) + val input = getRest [firstline] + val _ = compiler obuf (linenum lbuf) (mkLex (quote input)) + in + ("\n", NONE) + end + else if String.isPrefix ">>_" line then let val firstline = String.extract(line, 3, NONE) val input = getRest [firstline] From af3a6a819f4b6d5c7f3713af574acaa7419102ec Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 11 Jan 2016 11:58:47 +1100 Subject: [PATCH 613/718] More Euclid chapter work, using new ##use facility --- Manual/Tutorial/Holmakefile | 2 +- Manual/Tutorial/euclid-extras.ML | 44 ++++ Manual/Tutorial/euclid.stex | 371 +++++++++++-------------------- 3 files changed, 178 insertions(+), 239 deletions(-) create mode 100644 Manual/Tutorial/euclid-extras.ML diff --git a/Manual/Tutorial/Holmakefile b/Manual/Tutorial/Holmakefile index ccec5e8528..8583d2aab1 100644 --- a/Manual/Tutorial/Holmakefile +++ b/Manual/Tutorial/Holmakefile @@ -3,5 +3,5 @@ INCLUDES = ../Tools tutorial.pdf: tutorial.tex euclid.tex logic.tex preface.tex proof-tools.tex theories.tex combin.tex latexmk -pdf tutorial -euclid.tex: euclid.stex ../Tools/umap ../Tools/polyscripter +euclid.tex: euclid.stex ../Tools/umap ../Tools/polyscripter euclid-extras.ML ../Tools/polyscripter ../Tools/umap < $< > $@ diff --git a/Manual/Tutorial/euclid-extras.ML b/Manual/Tutorial/euclid-extras.ML new file mode 100644 index 0000000000..92b69956a6 --- /dev/null +++ b/Manual/Tutorial/euclid-extras.ML @@ -0,0 +1,44 @@ +val DIVIDES_ZERO = store_thm + ("DIVIDES_ZERO", + ``!x. 0 divides x = (x = 0)``, + METIS_TAC [divides_def,MULT_CLAUSES]); + +val DIVIDES_ONE = store_thm + ("DIVIDES_ONE", + ``!x. x divides 1 = (x = 1)``, + METIS_TAC [divides_def,MULT_CLAUSES,MULT_EQ_1]); + +val DIVIDES_REFL = store_thm + ("DIVIDES_REFL", + ``!x. x divides x``, + METIS_TAC [divides_def,MULT_CLAUSES]); + +val DIVIDES_TRANS = store_thm + ("DIVIDES_TRANS", + ``!a b c. a divides b /\ b divides c ==> a divides c``, + METIS_TAC [divides_def,MULT_ASSOC]); + +val DIVIDES_ADD = store_thm +("DIVIDES_ADD", + ``!d a b. d divides a /\ d divides b ==> d divides (a + b)``, + METIS_TAC[divides_def,LEFT_ADD_DISTRIB]); + +val DIVIDES_SUB = store_thm + ("DIVIDES_SUB", + ``!d a b. d divides a /\ d divides b ==> d divides (a - b)``, + METIS_TAC [divides_def,LEFT_SUB_DISTRIB]); + +val DIVIDES_ADDL = store_thm + ("DIVIDES_ADDL", + ``!d a b. d divides a /\ d divides (a + b) ==> d divides b``, + METIS_TAC [ADD_SUB,ADD_SYM,DIVIDES_SUB]); + +val DIVIDES_LMUL = store_thm + ("DIVIDES_LMUL", + ``!d a x. d divides a ==> d divides (x * a)``, + METIS_TAC [divides_def,MULT_ASSOC,MULT_SYM]); + +val DIVIDES_RMUL = store_thm + ("DIVIDES_RMUL", + ``!d a x. d divides a ==> d divides (a * x)``, + METIS_TAC [MULT_SYM,DIVIDES_LMUL]); diff --git a/Manual/Tutorial/euclid.stex b/Manual/Tutorial/euclid.stex index 1a1e5042f8..8aa373d25e 100644 --- a/Manual/Tutorial/euclid.stex +++ b/Manual/Tutorial/euclid.stex @@ -49,7 +49,7 @@ later reference in the session. We want to treat \ml{divides} as a (non-associating) infix: \begin{session} \begin{verbatim} ->>_ set_fixity "divides" (Infix(NONASSOC, 450)); +>> set_fixity "divides" (Infix(NONASSOC, 450)); \end{verbatim} \end{session} Next we define the property of a number being \emph{prime}: a number $p$ is @@ -79,10 +79,10 @@ mind. In this example, we often \emph{find} proofs by using the rewriter \ml{rw} to unwind definitions and perform basic simplifications, often reducing a goal to its essence. \begin{session} \begin{alltt} ->> rw; +>> lrw; \end{alltt} \end{session} -When \ml{rw} is applied to a list of theorems, the theorems will be added to \HOL{}'s built-in database of useful facts as supplementary rewrite rules. +When \ml{lrw} is applied to a list of theorems, the theorems will be added to \HOL{}'s built-in database of useful facts as supplementary rewrite rules. We will see that \ml{rw} is also somewhat knowledgeable about arithmetic.\footnote{Linear arithmetic especially: purely universal formulas involving the operators {\tt SUC}, $+$, $-$, numeric @@ -183,12 +183,9 @@ This process may be hard to visualize,\footnote{Perhaps since we have used a sta If the three interactions are joined together with \ml{\gt\gt} to form a single tactic, we can try the proof again from the beginning (using the \ml{restart} function) and this time it will take just one step: \begin{session} \begin{alltt} -- restart(); ... +>>_ restart(); -- e (lrw[divides_def] >> qexists_tac `0` >> lrw[]); -OK.. -val it = Initial goal proved. -|- \(\forall\)x. x divides 0: proof +>> e (lrw[divides_def] >> qexists_tac `0` >> lrw[]); \end{alltt} \end{session} We have seen one way to prove the theorem. @@ -199,13 +196,9 @@ earlier, there is another: one can let \ml{metis\_tac} expand the definition of to see exactly what it states.} \begin{session} \begin{alltt} -- restart(); ... +>>_ restart(); -- e (metis_tac [divides_def, MULT_CLAUSES]); -OK.. -metis: r[+0+10]+0+0+0+1+2# -val it = Initial goal proved. -|- \(\forall\)x. x divides 0: proof +>> e (metis_tac [divides_def, MULT_CLAUSES]); \end{alltt} \end{session} As it runs, \ml{metis\_tac} prints out some possibly interesting diagnostics. @@ -213,16 +206,15 @@ In any case, having done our proof inside the goalstack package, we now want to We use the \ml{top\_thm} function to do this, and then use \ml{drop} to dispose of the stack: \begin{session} \begin{alltt} -> val DIVIDES_0 = top_thm(); -val DIVIDES_0 = |- \(\forall\)x. x divides 0: thm -> drop(); -OK.. -val it = There are currently no proofs.: proofs +>> val DIVIDES_0 = top_thm(); +>> drop(); \end{alltt} \end{session} We have used \ml{metis\_tac} in this way to prove the following collection of theorems about \ml{divides}. -As mentioned previously, the theorems supplied to \ml{metis\_tac} in the following proofs did not (usually) come from thin air: in most cases some exploratory work with \ml{RW\_TAC} was done to open up definitions and see what lemmas would be required by \ml{metis\_tac}. +As mentioned previously, the theorems supplied to \ml{metis\_tac} in the following proofs did not (usually) come from thin air: in most cases some exploratory work with the simplifier (\ml{lrw}) was done to open up definitions and see what lemmas would be required by \ml{metis\_tac}. + +##use euclid-extras.ML \begin{description} \label{euclid:extra-proofs} @@ -290,7 +282,7 @@ As mentioned previously, the theorems supplied to \ml{metis\_tac} in the followi \noindent We'll assume that the above proofs have been performed, and that the appropriate ML names have been given to all of the theorems. Now we encounter a lemma about divisibility that doesn't succumb to just a -single invocation of \ml{METIS\_TAC}: +single invocation of \ml{metis\_tac}: \begin{description} \item [\small{({\it DIVIDES\_LE\/})}] \begin{tabular}[t]{l} @@ -302,13 +294,9 @@ Let's see how this is proved. The easiest way to start is to simplify with the definition of \ml{divides}: \begin{session} \begin{alltt} -> g `!m n. m divides n ==> m <= n \bs{}/ (n = 0)`; ... +>>_ g `!m n. m divides n ==> m <= n \/ (n = 0)`; -> e (lrw[divides_def]); -OK.. -1 subgoal: -val it = -m \(\le\) m * x \(\lor\) (m * x = 0) +>> e (lrw[divides_def]); \end{alltt} \end{session} @@ -332,12 +320,7 @@ Let's look in the theory of arithmetic for the subterm to be rewritten. \begin{session} \begin{alltt} -> DB.match ["arithmetic"] ``m <= m * x``; -val it = - [(("arithmetic", "LE_MULT_CANCEL_LBARE"), - (|- (m \(\le\) m * n \(\iff\) (m = 0) \(\lor\) 0 < n) \(\land\) - (m \(\le\) n * m \(\iff\) (m = 0) \(\lor\) 0 < n), Thm))] - : DB.data list +>> DB.match ["arithmetic"] ``m <= m * x``; \end{alltt} \end{session} @@ -346,14 +329,7 @@ Using \ml{DB.match} again, you should now try to find the theorem that will simp Because both are so generally useful, \ml{lrw} already has both rewrites in its internal database, and all we need to do is rewrite once more to get those rewrites applied: \begin{session} \begin{alltt} -> e (lrw[]); -OK.. - -Goal proved. -|- m \(\le\) m * x \(\lor\) (m * x = 0) -val it = Initial goal proved. -|- \(\forall\)m n. m divides n \(\Rightarrow\) m \(\le\) n \(\lor\) (n = 0): - proof +>> e (lrw[]); \end{alltt} \end{session} @@ -363,12 +339,10 @@ Rather than use \ml{top\_thm} and the goalstack, we can bypass it and use the \m This function takes a string, a term and a tactic and applies the tactic to the term to get a theorem, and then stores the theorem in the current theory under the given name. \begin{session} \begin{alltt} -> val DIVIDES_LE = store_thm( - "DIVIDES_LE", - ``!m n. m divides n ==> m <= n \bs{}/ (n = 0)``, - lrw[divides_def] >> lrw[]); - -val DIVIDES_LE = |- \(\forall\)m n. m divides n \(\Rightarrow\) m \(\le\) n \(\lor\) (n = 0) : thm +>> val DIVIDES_LE = store_thm( + "DIVIDES_LE", + ``!m n. m divides n ==> m <= n \/ (n = 0)``, + lrw[divides_def] >> lrw[]); \end{alltt} \end{session} Storing theorems in our script record of the session in this style @@ -399,58 +373,38 @@ following\footnote{This and subsequent proofs use the theorems proved \item [\small{({\it DIVIDES\_FACT\/})}] \begin{tabular}[t]{l} \verb+!m n. 0 < m /\ m <= n ==> m divides (FACT n)+ \\ \hline -\verb+lrw[LESS_EQ_EXISTS]+ \\ -\verb+ THEN Induct_on `p`+ \\ -\verb+ THEN RW_TAC arith_ss [FACT,ADD_CLAUSES]+ \\ -\verb+ THENL [Cases_on `m`, ALL_TAC]+ \\ -\verb+ THEN METIS_TAC [FACT, DECIDE ``!x. ~(x < x)``,+ \\ -\verb+ DIVIDES_RMUL, DIVIDES_LMUL, DIVIDES_REFL]+ \\ +\verb+lrw[LESS_EQ_EXISTS] >>+ \\ +\verb+Induct_on `p`+ >>+\\ +\verb!qcase_tac `m divides FACT (m + q)`+ >>!\\ +\verb+lrw[FACT,ADD_CLAUSES] >| [+ \\ +\verb+ Cases_on `m`, ALL_TAC+ \\ +\verb+] >> metis_tac [FACT, DECIDE ``!x. ~(x < x)``,+ \\ +\verb+ DIVIDES_RMUL, DIVIDES_LMUL, DIVIDES_REFL]+ \\ \end{tabular} \end{description} -We will examine this proof in detail, so we should first attempt to -understand why the theorem is true. What's the underlying intuition? -Suppose $0 < m \leq n$, and so $\mbox{\tt FACT}\ n = 1 * \cdots * m * -\cdots * n$. To show $m\ \mbox{\tt divides}\ (\mbox{\tt FACT}\ n)$ -means exhibiting a $q$ such that $q * m = \mbox{\tt FACT}\ n$. Thus $q -= \mbox{\tt FACT}\ n \div m$. If we were to take this approach to the -proof, we would end up having to find and apply lemmas about $\div$. +We will examine this proof in detail, so we should first attempt to understand why the theorem is true. +What's the underlying intuition? +Suppose $0 < m \leq n$, and so $\mbox{\tt FACT}\ n = 1 * \cdots * m * \cdots * n$. +To show $m\ \mbox{\tt divides}\ (\mbox{\tt FACT}\ n)$ means exhibiting a $q$ such that $q * m = \mbox{\tt FACT}\ n$. +Thus $q = \mbox{\tt FACT}\ n \div m$. +If we were to take this approach to the proof, we would end up having to find and apply lemmas about $\div$. This seems to take us a little out of our way; isn't there a proof -that doesn't use division? Well yes, we can prove the theorem by -induction on $n - m$: in the base case, we will have to prove $n\; -\mbox{\tt divides}\ (\mbox{\tt FACT}\; n)$, which ought to be easy; in -the inductive case, the inductive hypothesis seems like it should give -us what we need. This strategy for the inductive case is a bit vague, -because we are trying to mentally picture a slightly complicated -formula, but we can rely on the system to accurately calculate the -cases of the induction for us. If the inductive case turns out to be -not what we expect, we will have to re-think our approach. +that doesn't use division? +Well yes, we can prove the theorem by induction on $n - m$: in the base case, we will have to prove $n\; \mbox{\tt divides}\ (\mbox{\tt FACT}\; n)$, which ought to be easy; in the inductive case, the inductive hypothesis seems like it should give us what we need. +This strategy for the inductive case is a bit vague, because we are trying to mentally picture a slightly complicated formula, but we can rely on the system to accurately calculate the cases of the induction for us. +If the inductive case turns out to be not what we expect, we will have to re-think our approach. \begin{session} \begin{alltt} -> g `!m n. 0 < m /\bs{} m <= n ==> m divides (FACT n)`; -val it = - Proof manager status: 2 proofs. -2. Completed goalstack: |- \(\forall\)m n. m divides n \(\Rightarrow\) m \(\le\) n \(\lor\) (n = 0) -1. Incomplete goalstack: - Initial goal: - - \(\forall\)m n. 0 < m \(\land\) m \(\le\) n \(\Rightarrow\) m divides FACT n +>> g `!m n. 0 < m /\ m <= n ==> m divides (FACT n)`; \end{alltt} \end{session} Instead of directly inducting on $n-m$, we will induct on a witness variable, obtained by use of the theorem \verb+LESS_EQ_EXISTS+. \begin{session} \begin{alltt} -> LESS_EQ_EXISTS; -val it = |- \(\forall\)m n. m \(\le\) n \(\iff\) \(\exists\)p. n = m + p: thm - -> e (lrw[LESS_EQ_EXISTS]); -OK.. -1 subgoal: -val it = +>> LESS_EQ_EXISTS; -m divides FACT (m + p) ------------------------------------- - 0 < m +>> e (lrw[LESS_EQ_EXISTS]); \end{alltt} \end{session} \noindent Now we want to induct on $p$, but before doing so, we should realise that the name $p$ has been chosen by the system. @@ -464,33 +418,25 @@ val it = fn : term quotation -> tactic \end{alltt} \end{session} This tactic takes a \emph{quotation} as an argument corresponding to a pattern that appears somewhere within the goal, and then renames the variables in the goal to match those in the pattern. +Here we will rename to \holtxt{q} just to illustrate how we can choose whichever variables we like: \begin{session} -\begin{verbatim} -- e (Induct_on `p`); -OK.. -2 subgoals: -> val it = - m divides FACT (m + SUC p) - ------------------------------------ - 0. 0 < m - 1. m divides FACT (m + p) - - m divides FACT (m + 0) - ------------------------------------ - 0 < m -\end{verbatim} +\begin{alltt} +>> e (qcase_tac `m divides FACT (m + q)`) +\end{alltt} \end{session} -\noindent The first goal can obviously be simplified: +And now we can perform the induction: \begin{session} -\begin{verbatim} -- e (RW_TAC arith_ss []); -OK.. -1 subgoal: -> val it = - m divides FACT m - ------------------------------------ - 0 < m -\end{verbatim} +\begin{alltt} +>> e (Induct_on `q`); +\end{alltt} +\end{session} +\noindent We now have two sub-goals to prove: a base case and a step case. +The first goal the system expects us to prove is the lowest one printed (it's closest to the cursor), the base-case. +This can obviously be simplified: +\begin{session} +\begin{alltt} +>> e (lrw[]); +\end{alltt} \end{session} \noindent Now we can do a case analysis on $m$: if it is $0$, we have a trivial goal; if it is a successor, then we can use the definition of @@ -498,110 +444,56 @@ trivial goal; if it is a successor, then we can use the definition of \ml{DIVIDES\_REFL}. \begin{session} \begin{verbatim} -- e (Cases_on `m`); -OK.. -2 subgoals: -> val it = - SUC n divides FACT (SUC n) - ------------------------------------ - 0 < SUC n - - 0 divides FACT 0 - ------------------------------------ - 0 < 0 +>> e (Cases_on `m`); \end{verbatim} \end{session} - Here the first sub-goal goal has an assumption that is false. We - can demonstrate this to the system by using the \ml{DECIDE} -function to prove a simple fact about arithmetic (namely, that no -number $x$ is less than itself), and then passing the resulting -theorem to \ml{METIS\_TAC}, which can combine this with the -contradictory assumption.\footnote{Note how the interactive system - prints out the proved theorem with \ml{[.]} before the - turnstile. This notation indicates that a theorem has an - assumption (the false $0 < 0$ in this case).} - -\begin{session} -\begin{verbatim} -- e (METIS_TAC [DECIDE ``!x. ~(x < x)``]); -OK.. -metis: r[+0+4]# +Here the first sub-goal goal has an assumption that is false. +We can demonstrate this to the system by using the \ml{DECIDE} function to prove a simple fact about arithmetic (namely, that no number $x$ is less than itself), and then passing the resulting theorem to \ml{METIS\_TAC}, which can combine this with the contradictory assumption. -Goal proved. - [.] |- 0 divides FACT 0 -Remaining subgoals: -> val it = - SUC n divides FACT (SUC n) - ------------------------------------ - 0 < SUC n -\end{verbatim} +\begin{session} +\begin{alltt} +>> e (metis_tac [DECIDE ``!x. ~(x < x)``]); +\end{alltt} \end{session} -Using the theorems identified above the remaining sub-goal can -be proved with \ml{RW\_TAC}. +Alternatively, we could trust that \HOL{}'s existing theories somewhere include the fact that less-then is irreflexive, find that theorem using \ml{DB.match} (using the pattern \holtxt{x~$<$~x}), and then quote that theorem-name to \ml{metis\_tac}. + +Another alternative would be to apply the simplifier directly to the sub-goal's assumptions. +Certainly, the simplifier has already been primed with the irreflexivity of less-than, so this seems natural. +This can be done with the \ml{fs} tactic: \begin{session} -\begin{verbatim} -- e (RW_TAC arith_ss [FACT, DIVIDES_LMUL, DIVIDES_REFL]); -OK.. +\begin{alltt} +>> b(); +>> e (fs[]); +\end{alltt} +\end{session} -Goal proved. ... -Remaining subgoals: -> val it = - m divides FACT (m + SUC p) - ------------------------------------ - 0. 0 < m - 1. m divides FACT (m + p) -\end{verbatim} -\end{session} -This last step, namely the invocation of \ml{RW\_TAC}, -could also have been accomplished with \ml{METIS\_TAC}. Note that -the only difference is the use of \ml{DIVIDES\_LMUL} in the simplifier -\emph{versus} \ml{DIVIDES\_RMUL} in \ml{METIS\_TAC}. This is due to the -already mentioned algebraic rearrangement of arithmetical terms in the simplifier. -\begin{session} -\begin{verbatim} -- b(); -> ... -- e (METIS_TAC [FACT, DIVIDES_RMUL, DIVIDES_REFL]); -OK.. +Using the theorems identified above the remaining sub-goal can +be proved with \ml{RW\_TAC}. -Goal proved. ... -\end{verbatim} +\begin{session} +\begin{alltt} +>> e (lrw [FACT, DIVIDES_LMUL, DIVIDES_REFL]); +\end{alltt} \end{session} Now we have finished the base case of the induction and can move to the step case. An obvious thing to try is simplification with the definitions of addition and factorial: \begin{session} -\begin{verbatim} -- e (RW_TAC arith_ss [FACT, ADD_CLAUSES]); - -OK.. -1 subgoal: -> val it = - m divides FACT (m + p) * SUC (m + p) - ------------------------------------ - 0. 0 < m - 1. m divides FACT (m + p) -\end{verbatim} +\begin{alltt} +>> e (lrw [FACT, ADD_CLAUSES]); +\end{alltt} \end{session} -\noindent And now, by \ml{DIVIDES\_RMUL} and the inductive hypothesis, we are +\noindent And now, by \ml{DIVIDES\_LMUL} and the inductive hypothesis, we are done: \begin{session} -\begin{verbatim} -- e (METIS_TAC [DIVIDES_RMUL]); -OK.. -metis: r[+0+5]+0+0+0+0+1# - -Goal proved. - ... -> val it = - Initial goal proved. - |- !m n. 0 < m /\ m <= n ==> m divides FACT n -\end{verbatim} +\begin{alltt} +>> e (metis_tac [DIVIDES_RMUL]); +\end{alltt} \end{session} We have finished the search for the proof, and now turn to the task of making a single tactic out of the sequence of tactic invocations we have @@ -610,18 +502,19 @@ track of in a file or a text editor buffer. We would thus have something like the following: \begin{hol} \begin{verbatim} - e (RW_TAC arith_ss [LESS_EQ_EXISTS]); - e (Induct_on `p`); + e (lrw[LESS_EQ_EXISTS]); + e (qcase_tac `m divides FACT (m + q)`); + e (Induct_on `q`); (*1*) - e (RW_TAC arith_ss []); + e (lrw[]); e (Cases_on `m`); (*1.1*) - e (METIS_TAC [DECIDE ``!x. ~(x < x)``]); + e (metis_tac [DECIDE ``!x. ~(x < x)``]); (*1.2*) - e (RW_TAC arith_ss [FACT, DIVIDES_LMUL, DIVIDES_REFL]); + e (lrw[FACT, DIVIDES_LMUL, DIVIDES_REFL]); (*2*) - e (RW_TAC arith_ss [FACT, ADD_CLAUSES]); - e (METIS_TAC [DIVIDES_RMUL]); + e (lrw[FACT, ADD_CLAUSES]); + e (metis_tac [DIVIDES_RMUL]); \end{verbatim} \end{hol} \noindent @@ -632,35 +525,34 @@ tactic: \begin{hol} \begin{verbatim} - RW_TAC arith_ss [LESS_EQ_EXISTS] - THEN Induct_on `p` - THENL [RW_TAC arith_ss [] THEN Cases_on `m` - THENL [METIS_TAC [DECIDE ``!x. ~(x < x)``], - RW_TAC arith_ss [FACT, DIVIDES_LMUL, DIVIDES_REFL]], - RW_TAC arith_ss [FACT, ADD_CLAUSES] THEN METIS_TAC [DIVIDES_RMUL]] + lrw[LESS_EQ_EXISTS] >> + qcase_tac `m divides FACT (m + q)` >> + Induct_on `q` >| [ + lrw[] >> Cases_on `m` >| [ + METIS_TAC [DECIDE ``!x. ~(x < x)``], + lrw[FACT, DIVIDES_LMUL, DIVIDES_REFL] + ], + lrw[FACT, ADD_CLAUSES] >> metis_tac [DIVIDES_RMUL] + ] \end{verbatim} \end{hol} \noindent This can be tested to see that we have made no errors: \begin{session} -\begin{verbatim} -- restart(); -> ... - -- e (RW_TAC arith_ss [LESS_EQ_EXISTS] - THEN Induct_on `p` THENL - [RW_TAC arith_ss [] THEN Cases_on `m` THENL - [METIS_TAC [DECIDE ``!x. ~(x < x)``], - RW_TAC arith_ss [FACT, DIVIDES_LMUL, DIVIDES_REFL]], - RW_TAC arith_ss [FACT, ADD_CLAUSES] THEN METIS_TAC [DIVIDES_RMUL]]); -OK.. -metis: r[+0+5]+0+0+0+0+1# -metis: r[+0+4]# -> val it = - Initial goal proved. - |- !m n. 0 < m /\ m <= n ==> m divides FACT n -\end{verbatim} +\begin{alltt} +>>_ restart(); + +>> e (lrw[LESS_EQ_EXISTS] >> + qcase_tac `m divides FACT (m + q)` >> + Induct_on `q` >| [ + lrw[] >> Cases_on `m` >| [ + METIS_TAC [DECIDE ``!x. ~(x < x)``], + lrw[FACT, DIVIDES_LMUL, DIVIDES_REFL] + ], + lrw[FACT, ADD_CLAUSES] >> metis_tac [DIVIDES_RMUL] + ]) +\end{alltt} \end{session} For many users, this would be the end of dealing with this proof: the @@ -669,26 +561,29 @@ tactic can now be packaged into an invocation of and attempts to prove the term using the supplied tactic. It returns the proved theorem if the tactic succeeds. It doesn't save the theorem to the developing theory.} or \ml{store\_thm} and that -would be the end of it. However, another user might notice -that this tactic could be shortened. +would be the end of it. +However, another user might notice that this tactic could be shortened. To start, both arms of the induction start with an invocation of -\ml{RW\_TAC}, and the semantics of \ml{THEN} allow us to merge the -occurrences of \ml{RW\_TAC} above the \ml{THENL}. The recast tactic -is +\ml{lrw}, and the semantics of \ml{\gt\gt} allow us to merge the +occurrences of \ml{lrw} above the \ml{\gt|}. +The recast tactic is \begin{hol} \begin{verbatim} - RW_TAC arith_ss [LESS_EQ_EXISTS] - THEN Induct_on `p` - THEN RW_TAC arith_ss [FACT, ADD_CLAUSES] - THENL [Cases_on `m` THENL - [METIS_TAC [DECIDE ``!x. ~(x < x)``], - RW_TAC arith_ss [FACT, DIVIDES_LMUL, DIVIDES_REFL]], - METIS_TAC [DIVIDES_RMUL]] + lrw[LESS_EQ_EXISTS] >> + qcase_tac `m divides FACT (m + q)` >> + Induct_on `q` >> lrw[FACT, ADD_CLAUSES] >| [ + Cases_on `m` >| [ + metis_tac [DECIDE ``!x. ~(x < x)``], + lrw[FACT, DIVIDES_LMUL, DIVIDES_REFL] + ], + metis_tac [DIVIDES_RMUL] + ] \end{verbatim} \end{hol} (Of course, when a tactic has been revised, it should be tested to see -if it still proves the goal!) Now recall that the use of \ml{RW\_TAC} +if it still proves the goal!) +Now recall that the use of \ml{RW\_TAC} in the base case could be replaced by a call to \ml{METIS\_TAC}. Thus it seems possible to merge the two sub-cases of the base case into a single invocation of \ml{METIS\_TAC}: From e2d1c109c2d253081ef7484679762277cd775308 Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Fri, 11 Dec 2015 13:15:22 +0000 Subject: [PATCH 614/718] Avoid using pp_strip_case. This code needs to be fixed before it's used. --- src/1/TypeBase.sml | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/src/1/TypeBase.sml b/src/1/TypeBase.sml index 259c1cff8d..c9bd7501ad 100644 --- a/src/1/TypeBase.sml +++ b/src/1/TypeBase.sml @@ -218,9 +218,15 @@ end *) (* Less ambitious version, which only fires if all (>1) but one row have - the same right-hand-side and it doesn't depend on any pattern variables.*) + the same right-hand-side and it doesn't depend on any pattern variables. + + NOTE: This is also broken, since + ``case x of 0n => T | 2 => T | _ => F`` + is printed as + ``case x of v => F | _ => T`` + local - val disjoint = HOLset.isEmpty o HOLset.intersection + fun disjoint x = HOLset.isEmpty (HOLset.intersection x) fun FV tm = FVL [tm] empty_varset in fun pp_strip_case tm = @@ -252,7 +258,8 @@ in (split_on, reduced_splits) end end +*) -val _ = term_pp.init_casesplit_munger pp_strip_case +val _ = term_pp.init_casesplit_munger strip_case end From 904ec2164d1ddfbcc180b59c23a5df6a8054ce05 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 13 Jan 2016 11:03:41 +1100 Subject: [PATCH 615/718] Improve subtraction/conditional handling in ARITH Closes #6 --- src/num/arith/src/Holmakefile | 2 +- src/num/arith/src/Sub_and_cond.sml | 227 ++++++++++++++++++++++++----- src/num/arith/src/selftest.sml | 64 +++++--- 3 files changed, 232 insertions(+), 61 deletions(-) diff --git a/src/num/arith/src/Holmakefile b/src/num/arith/src/Holmakefile index 4f4aebed24..c8de7c1fc1 100644 --- a/src/num/arith/src/Holmakefile +++ b/src/num/arith/src/Holmakefile @@ -8,7 +8,7 @@ TARGETS = $(patsubst %.sml,%.uo,$(THYFILES)) all: $(TARGETS) selftest.exe .PHONY: all -selftest.exe : selftest.uo numSimps.uo +selftest.exe : selftest.uo numSimps.uo Gen_arith.uo Arith.uo HOLMOSMLC -o $@ $< GenRelNorm.uo: GenRelNorm.sml $(BOOLLIB) diff --git a/src/num/arith/src/Sub_and_cond.sml b/src/num/arith/src/Sub_and_cond.sml index 086b8351fd..9cbd8b1e6d 100644 --- a/src/num/arith/src/Sub_and_cond.sml +++ b/src/num/arith/src/Sub_and_cond.sml @@ -18,13 +18,11 @@ structure Sub_and_cond :> Sub_and_cond = struct - open Arbint HolKernel Parse boolLib RJBConv Thm_convs Rsyntax; + open Arbint HolKernel Parse boolLib RJBConv Thm_convs val COND_ABS = boolTheory.COND_ABS; val TOP_DEPTH_CONV = Conv.TOP_DEPTH_CONV; -infix THENC ORELSEC |->; - fun failwith function = raise HOL_ERR{origin_structure = "Sub_and_cond", origin_function = function, @@ -36,12 +34,12 @@ fun failwith function = (*---------------------------------------------------------------------------*) fun COND_ABS_CONV tm = - (let val {Bvar=v,Body=bdy} = dest_abs tm - val {cond,larm=x,rarm=y} = Rsyntax.dest_cond bdy + (let val (v,bdy) = dest_abs tm + val (cond,x,y) = dest_cond bdy val _ = assert (not o equal Type.bool o type_of) x val b = assert (not o Lib.mem v o free_vars) cond - val xf = mk_abs{Bvar=v,Body=x} - and yf = mk_abs{Bvar=v,Body=y} + val xf = mk_abs(v,x) + and yf = mk_abs(v,y) val th1 = INST_TYPE [alpha |-> type_of v, beta |-> type_of x] COND_ABS val th2 = SPECL [b,xf,yf] th1 in CONV_RULE (RATOR_CONV (RAND_CONV (ABS_CONV @@ -50,6 +48,143 @@ fun COND_ABS_CONV tm = end ) handle (HOL_ERR _) => failwith "COND_ABS_CONV"; +(* ---------------------------------------------------------------------- + SUB_NORM_CONV' : bool -> term + + Eliminates as many subtractions as possible without introducing any + goal-blowup in the term, knowing that it is going to be normalised + subsequently. In particular, the term is going to be negated and then + converted to DNF. + + So, it's fine to introduce a disjunction at the top level or under + another disjunction. On the other hand, introducing a conjunction at + this level has just doubled the goal size. + + The boolean is true at top-level and flips as negations are traversed. + ---------------------------------------------------------------------- *) + +fun termsig t = + let val {Thy,Name,...} = dest_thy_const t + in + SOME(Thy,Name) + end handle HOL_ERR _ => NONE + +datatype termposn = Positive | Negative | Both +fun pneg Positive = Negative | pneg Negative = Positive | pneg Both = Both + +val SUB_LEFT_LESS_EQ' = + REWRITE_RULE [arithmeticTheory.LESS_EQ_0] arithmeticTheory.SUB_LEFT_LESS_EQ + +val peqn_or_nleqp = let + val p = mk_var("p", numSyntax.num) + val n = mk_var("n", numSyntax.num) + val peqn = mk_eq(p,n) + val nlep = numSyntax.mk_leq(n,p) + val l = mk_disj(peqn, nlep) + val nle = mk_comb(numSyntax.leq_tm, n) +in + IMP_ANTISYM_RULE + (DISCH_ALL (DISJ_CASES (ASSUME l) + (EQ_MP (AP_TERM nle (ASSUME peqn) |> SYM) + (SPEC n arithmeticTheory.LESS_EQ_REFL)) + (ASSUME nlep))) + (DISCH_ALL (DISJ2 peqn (ASSUME nlep))) +end + + +val SUB_LEFT_EQ0 = let + open arithmeticTheory +in + SUB_LEFT_EQ |> SPEC ``0`` + |> REWRITE_RULE [ADD_CLAUSES, LESS_EQ_REFL, peqn_or_nleqp] +end +val SUB_RIGHT_EQ0 = + CONV_RULE (STRIP_QUANT_CONV (LAND_CONV (REWR_CONV EQ_SYM_EQ))) SUB_LEFT_EQ0 + +fun SUBEQC_CONV t = + let + open arithmeticTheory + val (l,r) = dest_eq t + in + if numSyntax.is_minus l andalso numSyntax.is_numeral r then + REWR_CONV SUB_RIGHT_EQ THENC RAND_CONV (RAND_CONV reduceLib.LE_CONV) THENC + REWRITE_CONV [] + else if numSyntax.is_minus r andalso numSyntax.is_numeral l then + REWR_CONV SUB_LEFT_EQ THENC RAND_CONV (LAND_CONV reduceLib.LE_CONV) THENC + REWRITE_CONV [] + else NO_CONV + end t + + +fun SUB_NORM_CONV' topp t = + let + open arithmeticTheory + val (f, args) = strip_comb t + in + case (termsig f, length args) of + (SOME("bool", "/\\"), 2) => BINOP_CONV (SUB_NORM_CONV' topp) + | (SOME("bool", "\\/"), 2) => BINOP_CONV (SUB_NORM_CONV' topp) + | (SOME("bool", "~"), 1) => RAND_CONV (SUB_NORM_CONV' (pneg topp)) + | (SOME("min", "==>"), 2) => + FORK_CONV (SUB_NORM_CONV' (pneg topp), SUB_NORM_CONV' topp) + | (SOME("bool", "!"), 1) => RAND_CONV (ABS_CONV (SUB_NORM_CONV' topp)) + | (SOME("bool", "?"), 1) => RAND_CONV (ABS_CONV (SUB_NORM_CONV' topp)) + | (SOME("bool", "COND"), 3) => + BINOP_CONV (SUB_NORM_CONV' topp) THENC + RATOR_CONV (RATOR_CONV (RAND_CONV (SUB_NORM_CONV' Both))) + | (SOME("arithmetic", ">"), 2) => + REWR_CONV GREATER_DEF THENC SUB_NORM_CONV' topp + | (SOME("arithmetic", ">="), 2) => + REWR_CONV GREATER_EQ THENC SUB_NORM_CONV' topp + | (SOME("arithmetic", "<="), 2) => + (case topp of + Positive => FIRST_CONV [REWR_CONV SUB_RIGHT_LESS_EQ, + REWR_CONV SUB_LEFT_LESS_EQ', ALL_CONV] + | _ => TRY_CONV (REWR_CONV SUB_RIGHT_LESS_EQ)) + | (SOME("prim_rec", "<"), 2) => + (case topp of + Negative => FIRST_CONV [REWR_CONV SUB_LEFT_LESS, + REWR_CONV SUB_RIGHT_LESS, ALL_CONV] + | _ => TRY_CONV (REWR_CONV SUB_LEFT_LESS)) + | (SOME("min", "="), 2) => + FIRST_CONV [REWR_CONV SUB_LEFT_EQ0, REWR_CONV SUB_RIGHT_EQ0, + SUBEQC_CONV, ALL_CONV] + | _ => ALL_CONV + end t + +val TRY_SUB_NORM = let + open arithmeticTheory +in + PURE_REWRITE_CONV [PRE_SUB1, SUB_EQUAL_0, SUB_RIGHT_SUB, LEFT_SUB_DISTRIB, + RIGHT_SUB_DISTRIB] THENC + SUB_NORM_CONV' Positive +end + +fun find_elim p t m = let + fun doit t = + if numSyntax.is_minus t then + UNBETA_CONV t THENC + REWR_CONV arithmeticTheory.SUB_ELIM_THM THENC + BINDER_CONV (BINOP_CONV (RAND_CONV BETA_CONV)) THENC + PURE_REWRITE_CONV [arithmeticTheory.ADD_CLAUSES, + arithmeticTheory.SUB_EQUAL_0, + arithmeticTheory.SUB_0] + else NO_CONV +in + case dest_term t of + COMB(f,x) => find_elim (p o RATOR_CONV) f ORELSEC + find_elim (p o RAND_CONV) x ORELSEC doit t + | LAMB(_, body) => if type_of body = bool then + p (ABS_CONV (find_elim I body)) + else NO_CONV + | _ => NO_CONV +end m + +fun ELIM_SUB1 t = find_elim I t t + +val NEW_SUB_ELIM_CONV = TRY_SUB_NORM THENC REPEATC ELIM_SUB1 + + (*---------------------------------------------------------------------------*) (* SUB_AND_COND_ELIM_CONV : conv *) (* *) @@ -70,22 +205,50 @@ fun COND_ABS_CONV tm = (* Also eliminates the predecessor function, PRE. *) (*---------------------------------------------------------------------------*) +val COND_t = prim_mk_const {Name = "COND", Thy = "bool"} +fun TB c t = + if Type.compare(type_of t, bool) = EQUAL then NO_CONV t + else c t + +val CASES_ELIM = let + val p = mk_var("p", bool) + val P = mk_var("P", bool --> bool) +in + prove(mk_eq(mk_comb(P, p), + mk_conj(mk_imp(p,mk_comb(P,T)), mk_imp(mk_neg p,mk_comb(P,F)))), + ASM_CASES_TAC p THEN ASM_REWRITE_TAC[]) +end + +fun find_celim p t m = let + fun doit t = + if is_cond t then + UNBETA_CONV (t |> rator |> rator |> rand) THENC + REWR_CONV CASES_ELIM THENC + BINOP_CONV (RAND_CONV BETA_CONV) THENC + PURE_REWRITE_CONV [COND_CLAUSES] + else NO_CONV +in + case dest_term t of + COMB(f,x) => find_celim (p o RATOR_CONV) f ORELSEC + find_celim (p o RAND_CONV) x ORELSEC doit t + | LAMB(_, body) => if type_of body = bool then + p (ABS_CONV (find_celim I body)) + else NO_CONV + | _ => NO_CONV +end m + +fun ELIM_COND1 t = find_celim I t t + +fun op_of_app tm = op_of_app (rator tm) handle _ => tm val SUB_AND_COND_ELIM_CONV = - let fun op_of_app tm = op_of_app (rator tm) handle _ => tm - in - fn tm => - TOP_DEPTH_CONV - (SUB_NORM_CONV ORELSEC - COND_EXPAND_CONV ORELSEC - NUM_COND_RATOR_CONV ORELSEC - (fn tm => if ((#Name (dest_const (op_of_app tm)) = "COND") - handle _ => false) - then failwith "fail" - else NUM_COND_RAND_CONV tm) ORELSEC - COND_ABS_CONV - ) - tm - end; + TOP_DEPTH_CONV + (NUM_COND_RATOR_CONV ORELSEC + (fn tm => if same_const (op_of_app tm) COND_t then failwith "fail" + else NUM_COND_RAND_CONV tm) ORELSEC + TB COND_ABS_CONV) THENC + REPEATC ELIM_COND1 THENC + NEW_SUB_ELIM_CONV + (*---------------------------------------------------------------------------*) (* COND_ELIM_CONV : conv *) @@ -105,19 +268,11 @@ val SUB_AND_COND_ELIM_CONV = (*---------------------------------------------------------------------------*) val COND_ELIM_CONV = - let fun op_of_app tm = op_of_app (rator tm) handle _ => tm - in - fn tm => - TOP_DEPTH_CONV - (COND_EXPAND_CONV ORELSEC - COND_RATOR_CONV ORELSEC - (fn tm => if ((#Name (dest_const (op_of_app tm)) = "COND") - handle HOL_ERR _ => false) - then failwith "fail" - else COND_RAND_CONV tm) ORELSEC - COND_ABS_CONV - ) - tm - end; + TOP_DEPTH_CONV + (TB COND_RATOR_CONV ORELSEC + (fn tm => if same_const (op_of_app tm) COND_t then failwith "fail" + else TB COND_RAND_CONV tm) ORELSEC + TB COND_ABS_CONV) THENC + REPEATC ELIM_COND1 end diff --git a/src/num/arith/src/selftest.sml b/src/num/arith/src/selftest.sml index 8d982bdf56..a913b5f679 100644 --- a/src/num/arith/src/selftest.sml +++ b/src/num/arith/src/selftest.sml @@ -51,31 +51,47 @@ in else die "FAILED\n" end -val _ = pr "Testing Alexey Gotsman's arith d.p. problem ..." -val _ = let - val t = - ``(e*bv_c+e*(2*bv_cout+wb_sum)+wbs_sum = - bv_cin+e*(bv_c+wb_a+wb_b)+wbs_a+wbs_b) - ==> - (2n*e*bv_cout+e*wb_sum+wbs_sum = bv_cin+e*wb_a+e*wb_b+wbs_a+wbs_b)`` - val result = SOME (Arith.ARITH_CONV t) handle HOL_ERR _ => NONE -in - case result of - SOME th => if rhs (concl th) = boolSyntax.T then print "OK\n" - else die "FAILED!\n" - | NONE => die "FAILED!\n" -end +fun TRUE_ARITH nm t = + let + val _ = pr ("ARITH_CONV: " ^ nm) + val result = SOME (Arith.ARITH_CONV t) handle HOL_ERR _ => NONE + in + case result of + SOME th => if rhs (concl th) = boolSyntax.T then print "OK\n" + else die "FAILED!" + | NONE => die "FAILED!" + end -val _ = pr "Testing arith on nested COND clause" -val _ = let - val t = ``x <= y ==> x <= y + if p then q else r`` - val result = SOME (Arith.ARITH_CONV t) handle HOL_ERR _ => NONE -in - case result of - SOME th => if rhs (concl th) = boolSyntax.T then print "OK\n" - else die "FAILED!\n" - | NONE => die "FAILED!\n" -end +val _ = TRUE_ARITH + "Alexey Gotsman's problem ..." + ``(e*bv_c+e*(2*bv_cout+wb_sum)+wbs_sum = + bv_cin+e*(bv_c+wb_a+wb_b)+wbs_a+wbs_b) + ==> + (2n*e*bv_cout+e*wb_sum+wbs_sum = bv_cin+e*wb_a+e*wb_b+wbs_a+wbs_b)`` + +val _ = TRUE_ARITH + "Testing arith on nested COND clause" + ``x <= y ==> x <= y + if p then q else r`` + +val _ = TRUE_ARITH + "Subtraction term 1 (should be very quick)" + ``1 <= x /\ (i = 1) ==> (x - PRE i - SUC (PRE i - PRE i) = x - 1)`` + +val _ = TRUE_ARITH + "Subtraction + cond (should be very quick)" + ``(if x = 0 then 1 else 0) = 1 - x`` + +val _ = TRUE_ARITH + "Distributing subtraction over multiplication" + ``0 < b ⇒ (a * b − a = (b − 1) * a)`` + +val _ = TRUE_ARITH + "Horrible subtraction + conditional" + ``!j i. i <> j ==> + (if (if i < j then i + 1 else i − 1) < j then + j − if i < j then i + 1 else i − 1 + else (if i < j then i + 1 else i − 1) − j) < + if i < j then j − i else i − j`` val _ = pr "Testing r-cache behaviour with CONJ_ss ..." val _ = let From a5b09774c9070e5ca7d3e130d08bebf2a0e5b43a Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 14 Jan 2016 20:12:08 +1100 Subject: [PATCH 616/718] Don't eliminate non-bool, non-num conditionals These cause goal blowup for no reason --- src/num/arith/src/Sub_and_cond.sml | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/num/arith/src/Sub_and_cond.sml b/src/num/arith/src/Sub_and_cond.sml index 9cbd8b1e6d..27d2dc41ca 100644 --- a/src/num/arith/src/Sub_and_cond.sml +++ b/src/num/arith/src/Sub_and_cond.sml @@ -220,8 +220,11 @@ in end fun find_celim p t m = let + fun isboolnum ty = + Type.compare(ty, numSyntax.num) = EQUAL orelse + Type.compare(ty, bool) = EQUAL fun doit t = - if is_cond t then + if is_cond t andalso isboolnum (type_of t) then UNBETA_CONV (t |> rator |> rator |> rand) THENC REWR_CONV CASES_ELIM THENC BINOP_CONV (RAND_CONV BETA_CONV) THENC From 1f91a97c8525574c99d795019ae5154406e1b4a7 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 14 Jan 2016 21:54:50 +1100 Subject: [PATCH 617/718] More l/case names in bossLib.sig Work on github issue #274 --- src/boss/bossLib.sig | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/boss/bossLib.sig b/src/boss/bossLib.sig index 9af23a5400..10fe793720 100644 --- a/src/boss/bossLib.sig +++ b/src/boss/bossLib.sig @@ -85,11 +85,17 @@ sig val SIMP_CONV : simpset -> thm list -> conv val SIMP_RULE : simpset -> thm list -> thm -> thm val SIMP_TAC : simpset -> thm list -> tactic + val simp_tac : simpset -> thm list -> tactic val ASM_SIMP_TAC : simpset -> thm list -> tactic + val asm_simp_tac : simpset -> thm list -> tactic val FULL_SIMP_TAC : simpset -> thm list -> tactic + val full_simp_tac : simpset -> thm list -> tactic val REV_FULL_SIMP_TAC : simpset -> thm list -> tactic + val rev_full_simp_tac : simpset -> thm list -> tactic val RW_TAC : simpset -> thm list -> tactic + val rw_tac : simpset -> thm list -> tactic val SRW_TAC : ssfrag list -> thm list -> tactic + val srw_tac : ssfrag list -> thm list -> tactic val NO_STRIP_FULL_SIMP_TAC : simpset -> thm list -> tactic val NO_STRIP_REV_FULL_SIMP_TAC : simpset -> thm list -> tactic From bc4856801dbccdedf0146faedba9572161d38fdd Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 14 Jan 2016 21:57:45 +1100 Subject: [PATCH 618/718] Corrections for last commit --- src/boss/bossLib.sml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/boss/bossLib.sml b/src/boss/bossLib.sml index 2c581c6849..fa7894a4b3 100644 --- a/src/boss/bossLib.sml +++ b/src/boss/bossLib.sml @@ -69,6 +69,8 @@ val METIS_TAC = metisLib.METIS_TAC val metis_tac = METIS_TAC val RW_TAC = BasicProvers.RW_TAC val SRW_TAC = BasicProvers.SRW_TAC +val rw_tac = BasicProvers.RW_TAC +val srw_tac = BasicProvers.SRW_TAC val srw_tac = BasicProvers.srw_tac val srw_ss = BasicProvers.srw_ss val augment_srw_ss = BasicProvers.augment_srw_ss From 48e341c912ce04702c0eb11132fcd082966c30bd Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 15 Jan 2016 11:21:04 +1100 Subject: [PATCH 619/718] More l/case names into bossLib Work on #274 --- src/boss/bossLib.sig | 2 ++ src/boss/bossLib.sml | 2 ++ 2 files changed, 4 insertions(+) diff --git a/src/boss/bossLib.sig b/src/boss/bossLib.sig index 10fe793720..1482e81882 100644 --- a/src/boss/bossLib.sig +++ b/src/boss/bossLib.sig @@ -47,6 +47,7 @@ sig val METIS_PROVE : thm list -> term -> thm (* First order *) val DECIDE : term -> thm (* Cooperating dec. procs *) val PROVE_TAC : thm list -> tactic + val prove_tac : thm list -> tactic val METIS_TAC : thm list -> tactic val metis_tac : thm list -> tactic val DECIDE_TAC : tactic @@ -113,6 +114,7 @@ sig val ZAP_TAC : simpset -> thm list -> tactic val SPOSE_NOT_THEN : (thm -> tactic) -> tactic + val spose_not_then : (thm -> tactic) -> tactic val by : term quotation * tactic -> tactic (* infix *) val suffices_by : term quotation * tactic -> tactic (* infix *) val cheat : tactic diff --git a/src/boss/bossLib.sml b/src/boss/bossLib.sml index fa7894a4b3..34f583dd6b 100644 --- a/src/boss/bossLib.sml +++ b/src/boss/bossLib.sml @@ -64,6 +64,7 @@ val WF_REL_TAC = TotalDefn.WF_REL_TAC val PROVE = BasicProvers.PROVE val PROVE_TAC = BasicProvers.PROVE_TAC +val prove_tac = BasicProvers.PROVE_TAC val METIS_PROVE = metisLib.METIS_PROVE val METIS_TAC = metisLib.METIS_TAC val metis_tac = METIS_TAC @@ -143,6 +144,7 @@ val completeInduct_on = numLib.completeInduct_on val measureInduct_on = numLib.measureInduct_on; val SPOSE_NOT_THEN = BasicProvers.SPOSE_NOT_THEN +val spose_not_then = BasicProvers.SPOSE_NOT_THEN val op by = BasicProvers.by; (* infix 8 by *) val op suffices_by = BasicProvers.suffices_by From 828b75b45a3b8e1f29a2111e2f46c42d5818c976 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 15 Jan 2016 11:23:03 +1100 Subject: [PATCH 620/718] Better elision of cruft in polyscripter Make some things reference values so that they might later be user-configurable from command-line etc. --- Manual/Tools/polyscripter.sml | 41 ++++++++++++++++++++++++++++++++--- Manual/Tutorial/euclid.stex | 4 ++-- 2 files changed, 40 insertions(+), 5 deletions(-) diff --git a/Manual/Tools/polyscripter.sml b/Manual/Tools/polyscripter.sml index a51c3fe86d..94b5cb3bd0 100644 --- a/Manual/Tools/polyscripter.sml +++ b/Manual/Tools/polyscripter.sml @@ -122,6 +122,40 @@ fun umunge umap s = recurse [] s end +val elision_string1 = + ref "\\quad\\textit{\\small\\dots{}output elided\\dots{}}\n" + +fun deleteTrailingWhiteSpace s = + let + open Substring + val (pfx, sfx) = splitr Char.isSpace (full s) + val noNLsfx = dropl (not o equal #"\n") sfx + val term = if size noNLsfx = 0 then "" else "\n" + in + string pfx ^ term + end + +fun cruftSuffix sfxs s = + case List.find (fn (sfx,_) => String.isSuffix sfx s) sfxs of + NONE => NONE + | SOME (sfx,rep) => SOME (String.substring(s, 0, size s - size sfx) ^ rep) + +val cruftySuffixes = ref [ + (":\n proofs\n", ""), + ("\n: proof\n", "\n"), + (":\n proof\n", "\n") + ] + +fun removeCruft s = + case cruftSuffix (!cruftySuffixes) s of + NONE => s + | SOME s' => removeCruft s' + +fun transformOutput umap s = + s |> umunge umap + |> removeCruft + |> deleteTrailingWhiteSpace + fun process_line umap (obuf as (_, _, obRST)) line lbuf = let fun getRest acc = let @@ -158,17 +192,18 @@ in val firstline = String.extract(line, 3, NONE) val input = getRest [firstline] val _ = compiler obuf (linenum lbuf) (mkLex (quote input)) + fun removeNL s = String.substring(s, 0, size s - 1) in - (umunge umap input, SOME " ... output elided ...\n") + (removeNL (umunge umap input), SOME (!elision_string1)) end else if String.isPrefix ">>" line then let val _ = obRST() val firstline = String.extract(line, 2, NONE) val input = getRest [firstline] + val raw_output = compiler obuf (linenum lbuf) (mkLex (quote input)) in - (umunge umap input, - SOME (umunge umap (compiler obuf (linenum lbuf) (mkLex (quote input))))) + (umunge umap input, SOME (transformOutput umap raw_output)) end else (advance lbuf; (line, NONE)) diff --git a/Manual/Tutorial/euclid.stex b/Manual/Tutorial/euclid.stex index 8aa373d25e..9a16f37232 100644 --- a/Manual/Tutorial/euclid.stex +++ b/Manual/Tutorial/euclid.stex @@ -22,9 +22,9 @@ Let's get started. First, we start the system, with the command \ml{/bin/hol}. We then ``\ml{open}'' the arithmetic theory; this means that all of the \ML{} bindings from the \HOL{} theory of arithmetic are made available at the top level. \begin{session} -\begin{verbatim} +\begin{alltt} >>_ open arithmeticTheory; -\end{verbatim} +\end{alltt} \end{session} We now begin the formalization. In order to define the concept of prime number, we first need to define the \emph{divisibility} relation: From 3267b8babe3c60f6b7dcbc5d827bd5eb961b895f Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 15 Jan 2016 14:36:52 +1100 Subject: [PATCH 621/718] Tweak Holyhammer notice in release notes Credit Thibault Gauthier as part of this --- doc/kananaskis-11.release.md | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/doc/kananaskis-11.release.md b/doc/kananaskis-11.release.md index 1ee361c924..633693cebc 100644 --- a/doc/kananaskis-11.release.md +++ b/doc/kananaskis-11.release.md @@ -94,9 +94,17 @@ New theories: New tools: ---------- -- Holyhammer: A method for automatically finding relevant theorems for Metis. Given a term, the procedure selects a large number of lemmas through different predictors such as KNN or Mepo. These lemmas are given to the external provers E-prover, Vampire or Z3. The necessary lemmas in the provers' proofs are then returned to the user. - Modifications to the kernels to track dependencies between theorems allow predictors to learn from the induced relation improving future predictions. - The build of the source directory `src/holyhammer` needs ocaml (> 3.12.1) installed as well as a recent version of g++ that supports the c++11 standard. The three ATPs have to be installed independently. At least one of them should be present, preferably E-prover. +- **Holyhammer:** A method for automatically finding relevant theorems for Metis. + Given a term, the procedure selects a large number of lemmas through different predictors such as KNN or Mepo. + These lemmas are given to the external provers E-prover, Vampire or Z3. + The necessary lemmas in the provers' proofs are then returned to the user. + Modifications to the kernels to track dependencies between theorems allow predictors to learn from the induced relation improving future predictions. + The build of the source directory `src/holyhammer` needs ocaml (> 3.12.1) installed as well as a recent version of g++ that supports the C++11 standard. + The three ATPs have to be installed independently. + At least one of them should be present, preferably E-prover. + + Thanks to Thibault Gauthier for this tool. + New examples: --------- From b4a8691aaa7f28afd34b363476d5e4a664092dc6 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 15 Jan 2016 14:44:22 +1100 Subject: [PATCH 622/718] Document Hol_coreln in release notes --- doc/kananaskis-11.release.md | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/doc/kananaskis-11.release.md b/doc/kananaskis-11.release.md index 633693cebc..592c3cbc87 100644 --- a/doc/kananaskis-11.release.md +++ b/doc/kananaskis-11.release.md @@ -105,6 +105,22 @@ New tools: Thanks to Thibault Gauthier for this tool. +- A principle for making coinductive definitions, `Hol_coreln`. + The input syntax is the same as for `Hol_reln`, that is: a conjunction of introduction rules. + For example, if one is representing coalgebraic lists as a subset of the type `:num → α option`, the coinductive predicate specifying the subset would be given as + + val (lrep_ok_rules, lrep_ok_coind, lrep_ok_cases) = Hol_coreln` + lrep_ok (λn. NONE) + ∧ + ∀h t. + lrep_ok t + ⇒ + lrep_ok (λn. if n = 0 then SOME h else t(n - 1)) + `; + + as is now done in `src/llist/llistScript.sml`. + + Thanks to Andrea Condoluci for this tool. New examples: --------- From 4fcb79097cca6cc90d82c9c2708131288a393f5c Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 15 Jan 2016 14:49:59 +1100 Subject: [PATCH 623/718] Tweak release notes' discussion of qmatch* tactics Notes previously mentioned them as being in lcsymtacs. With the move of everything to bossLib in earlier, this is no longer appropriate. Part of work on #274 --- doc/kananaskis-11.release.md | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/doc/kananaskis-11.release.md b/doc/kananaskis-11.release.md index 592c3cbc87..f3c852d2bc 100644 --- a/doc/kananaskis-11.release.md +++ b/doc/kananaskis-11.release.md @@ -154,9 +154,13 @@ Incompatibilities: ?- (f x = Pair c1 c2) ⇒ (f c1 = f c2) - where the `X` in the pattern was ignored. The interface now achieves the same end by simply allowing the user to write underscores in the pattern. Thus, the tactic would become ``Q.MATCH_RENAME_TAC `(f x = Pair c1 c2) ⇒ _` ``. Multiple underscores can be used to ignore multiple sub-terms. + where the `X` in the pattern was ignored. + The interface now achieves the same end by simply allowing the user to write underscores in the pattern. + Thus, the tactic would become ``Q.MATCH_RENAME_TAC `(f x = Pair c1 c2) ⇒ _` ``. + Multiple underscores can be used to ignore multiple sub-terms. - Of course, the `qmatch_rename_tac` and `qmatch_assum_rename_tac` names for these tactics in `lcsymtacs` have changed types as well. The new `Q.MATCH_GOALSUB_RENAME_TAC` and `Q.MATCH_ASMSUB_RENAME_TAC` (and their lower-case versions) have similar types, without explicit lists of variable names to ignore. + Of course, the `qmatch_rename_tac` and `qmatch_assum_rename_tac` names for these tactics in `bossLib` have changed types as well. + The new `Q.MATCH_GOALSUB_RENAME_TAC` and `Q.MATCH_ASMSUB_RENAME_TAC` (and their lower-case versions) have similar types, without explicit lists of variable names to ignore. - The theory `state_option` was removed. The better-developed `errorStateMonad` theory should be used instead. From c9a794c0d254b41cec4d819c2b27a15478a4b378 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 15 Jan 2016 14:55:17 +1100 Subject: [PATCH 624/718] Mention use of PolyML's SaveState in release notes --- doc/kananaskis-11.release.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/doc/kananaskis-11.release.md b/doc/kananaskis-11.release.md index f3c852d2bc..fc367e6a87 100644 --- a/doc/kananaskis-11.release.md +++ b/doc/kananaskis-11.release.md @@ -52,6 +52,8 @@ New features: This definition would have previously been rejected. ([Github issue](https://github.com/HOL-Theorem-Prover/HOL/issues/173)) +- PolyML “heaps” are now implemented with its `SaveState` technology, used hierarchically. + This should make heaps smaller as they now only save deltas over the last used heap. Bugs fixed: ----------- From 334768676d8b94cbd4419493bc0f7479844e1bce Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 15 Jan 2016 15:09:33 +1100 Subject: [PATCH 625/718] Remove docs saying --enable-shared must be used --- INSTALL | 10 ---------- Manual/Tutorial/intro.tex | 5 ----- 2 files changed, 15 deletions(-) diff --git a/INSTALL b/INSTALL index d9aaa25557..7ca22c5f39 100644 --- a/INSTALL +++ b/INSTALL @@ -65,16 +65,6 @@ A. [Moscow ML:] First, install Moscow ML. This is usually declare -x LD_LIBRARY_PATH=/usr/local/lib:$HOME/lib - If you are using PolyML 5.5.1 or later, you will have to configure - its build with the - - --enabled-shared - - option. In other words, the first thing to do when building PolyML - will be - - ./configure --enable-shared - Do not use the --with-portable option. B. Unpack HOL with the commands diff --git a/Manual/Tutorial/intro.tex b/Manual/Tutorial/intro.tex index 96ea8abcca..85cc753035 100644 --- a/Manual/Tutorial/intro.tex +++ b/Manual/Tutorial/intro.tex @@ -98,11 +98,6 @@ \section{Installing \HOL{}} \begin{verbatim} declare -x LD_LIBRARY_PATH=/usr/local/lib:$HOME/lib \end{verbatim} -Further, if you are using Poly/ML version 5.5.1 or later, you will need to make sure that Poly/ML is configured with the \texttt{--enable-shared} option. -That is, your configure command (the first thing that is done when building the system), will look something like -\begin{verbatim} - ./configure --enable-shared -\end{verbatim} Do not use the \texttt{--with-portable} option. When you have your ML system installed, and are in the root directory of the distribution, the next step is to run \texttt{smart-configure}. From 84cc1436182b0b1db7421d2cb7280a6c773ab2aa Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 14 Jan 2016 14:03:30 +1100 Subject: [PATCH 626/718] All l/case short simp tacs use LET_ss + ARITH_ss This means that fs and rfs pick up LET_ss and ARITH_ss, making them indistinguishable from the 'l' versions. --- Manual/Tutorial/euclid.stex | 18 +-- examples/misc/balancedParensScript.sml | 2 +- .../hol_sets/ordNotationSemanticsScript.sml | 2 +- .../set-theory/hol_sets/wellorderScript.sml | 16 +-- src/bag/bagScript.sml | 8 +- src/boss/bossLib.sml | 10 +- src/floating-point/binary_ieeeScript.sml | 24 ++-- src/integer/int_bitwiseScript.sml | 14 +- src/n-bit/bitstringScript.sml | 25 ++-- src/patricia/sptreeScript.sml | 13 +- src/sort/mergesortScript.sml | 130 +++++++++--------- 11 files changed, 127 insertions(+), 135 deletions(-) diff --git a/Manual/Tutorial/euclid.stex b/Manual/Tutorial/euclid.stex index 9a16f37232..bff5c01e28 100644 --- a/Manual/Tutorial/euclid.stex +++ b/Manual/Tutorial/euclid.stex @@ -79,10 +79,10 @@ mind. In this example, we often \emph{find} proofs by using the rewriter \ml{rw} to unwind definitions and perform basic simplifications, often reducing a goal to its essence. \begin{session} \begin{alltt} ->> lrw; +>> rw; \end{alltt} \end{session} -When \ml{lrw} is applied to a list of theorems, the theorems will be added to \HOL{}'s built-in database of useful facts as supplementary rewrite rules. +When \ml{rw} is applied to a list of theorems, the theorems will be added to \HOL{}'s built-in database of useful facts as supplementary rewrite rules. We will see that \ml{rw} is also somewhat knowledgeable about arithmetic.\footnote{Linear arithmetic especially: purely universal formulas involving the operators {\tt SUC}, $+$, $-$, numeric @@ -159,7 +159,7 @@ keep distinct the $x$ of the goal and the $x$ in the definition of \ml{divides}: \begin{session} \begin{alltt} ->> e (lrw[divides_def]); +>> e (rw[divides_def]); \end{alltt} \end{session} It is of course quite easy to instantiate the existential quantifier by @@ -172,7 +172,7 @@ hand. Then a simplification step finishes the proof. \begin{session} \begin{alltt} ->> e (lrw[]); +>> e (rw[]); \end{alltt} \end{session} @@ -180,17 +180,17 @@ What just happened here? The application of \ml{lrw} to the goal decomposed it t Once a goal has been proved, it is popped off the goalstack, prettyprinted to the output, and the theorem becomes available for use by the level of the stack. When all the sub-goals required by \textit{that} level are proven, the corresponding goal at that level can be proven too. This `unwinding' process continues until the stack is empty, or until it hits a goal with more than one remaining unproved subgoal. This process may be hard to visualize,\footnote{Perhaps since we have used a stack to implement what is notionally a tree!} but that doesn't matter, since the goalstack was expressly written to allow the user to ignore such details. -If the three interactions are joined together with \ml{\gt\gt} to form a single tactic, we can try the proof again from the beginning (using the \ml{restart} function) and this time it will take just one step: +We can sequence tactics with the \ml{\gt\gt} operator (also known as \ml{THEN}). +If our three interactions above are joined together with \ml{\gt\gt} to form a single tactic, we can try the proof again from the beginning (using the \ml{restart} function) and this time it will take just one step: \begin{session} \begin{alltt} >>_ restart(); ->> e (lrw[divides_def] >> qexists_tac `0` >> lrw[]); +>> e (rw[divides_def] >> qexists_tac `0` >> rw[]); \end{alltt} \end{session} We have seen one way to prove the theorem. -However, as mentioned -earlier, there is another: one can let \ml{metis\_tac} expand the definition of \ml{divides} and find the required instantiation for \verb+x'+ from the theorem \ml{MULT\_CLAUSES}.% +However, as mentioned earlier, there is another: one can let \ml{metis\_tac} expand the definition of \ml{divides} and find the required instantiation for \verb+x'+ from the theorem \ml{MULT\_CLAUSES}.% \footnote{You might like to try typing \ml{MULT\_CLAUSES} into the interactive loop to see exactly what it states.} @@ -296,7 +296,7 @@ The easiest way to start is to simplify with the definition of \ml{divides}: \begin{alltt} >>_ g `!m n. m divides n ==> m <= n \/ (n = 0)`; ->> e (lrw[divides_def]); +>> e (rw[divides_def]); \end{alltt} \end{session} diff --git a/examples/misc/balancedParensScript.sml b/examples/misc/balancedParensScript.sml index ee7999294a..454e54d026 100644 --- a/examples/misc/balancedParensScript.sml +++ b/examples/misc/balancedParensScript.sml @@ -50,7 +50,7 @@ val balanced_append = Q.store_thm("balanced_append", ho_match_mp_tac balanced_ind >> rw[] >> fs[] >- ( res_tac >> fsrw_tac[ARITH_ss][ADD1] ) >> - REWRITE_TAC[GSYM SUC_ADD_SYM] >> + REWRITE_TAC[ADD_CLAUSES] >> simp[]) val S_balanced = Q.store_thm("S_balanced", diff --git a/examples/set-theory/hol_sets/ordNotationSemanticsScript.sml b/examples/set-theory/hol_sets/ordNotationSemanticsScript.sml index 526503a1f5..fb5012b4d2 100644 --- a/examples/set-theory/hol_sets/ordNotationSemanticsScript.sml +++ b/examples/set-theory/hol_sets/ordNotationSemanticsScript.sml @@ -183,7 +183,7 @@ val addL_disappears = store_thm( `(dn = 0) ∨ ∃dn0. dn = SUC dn0` by (Cases_on `dn` >> simp[]) >- (rw[] >> qexists_tac `c` >> simp[ordle_lteq]) >> `dn = 1 + dn0` by decide_tac >> - Q.UNDISCH_THEN `dn = SUC dn0` (K ALL_TAC) >> rw[] >> + Q.UNDISCH_THEN `dn = SUC dn0` (K ALL_TAC) >> srw_tac[][] >> SIMP_TAC bool_ss [GSYM ordADD_fromNat, ordMULT_LDISTRIB] >> simp[] >> `0 < c` by (spose_not_then strip_assume_tac >> fs[]) >> diff --git a/examples/set-theory/hol_sets/wellorderScript.sml b/examples/set-theory/hol_sets/wellorderScript.sml index f7a9f48406..47915b092c 100644 --- a/examples/set-theory/hol_sets/wellorderScript.sml +++ b/examples/set-theory/hol_sets/wellorderScript.sml @@ -1,5 +1,4 @@ open HolKernel Parse boolLib bossLib -open lcsymtacs open boolSimps open set_relationTheory pred_setTheory (* cardinalTheory *) @@ -243,18 +242,9 @@ val wellorder_fromNat = store_thm( "wellorder_fromNat", ``wellorder { (i,j) | i <= j /\ j < n }``, rw[wellorder_def, wellfounded_def, linear_order_def, in_range, in_domain, - reflexive_def] - >| [ - qexists_tac `LEAST m. m IN s` >> numLib.LEAST_ELIM_TAC >> rw[strict_def] >> - metis_tac [DECIDE ``x ≤ y ⇔ (x = y) ∨ x < y``], - srw_tac[ARITH_ss][transitive_def], - srw_tac[ARITH_ss][antisym_def], - decide_tac, - decide_tac, - decide_tac, - decide_tac, - decide_tac - ]); + reflexive_def,transitive_def,antisym_def] >> + qexists_tac `LEAST m. m IN s` >> numLib.LEAST_ELIM_TAC >> rw[strict_def] >> + metis_tac []); val INJ_preserves_transitive = store_thm( "INJ_preserves_transitive", diff --git a/src/bag/bagScript.sml b/src/bag/bagScript.sml index 6cd39193b9..e6d800b369 100644 --- a/src/bag/bagScript.sml +++ b/src/bag/bagScript.sml @@ -139,16 +139,14 @@ val BAG_INN_BAG_INSERT_STRONG = store_thm ( PROVE_TAC[BAG_INN_LESS]); val BAG_UNION_EQ_LCANCEL1 = store_thm( - "BAG_UNION_EQ_LCANCEL1", + "BAG_UNION_EQ_LCANCEL1[simp]", ``(b = BAG_UNION b c) <=> (c = {||})``, rw[BAG_UNION, EMPTY_BAG, FUN_EQ_THM, DECIDE ``(x:num = x + y) <=> (y = 0)``]) -val _ = export_rewrites ["BAG_UNION_EQ_LCANCEL1"] val BAG_UNION_EQ_RCANCEL1 = store_thm( - "BAG_UNION_EQ_RCANCEL1", + "BAG_UNION_EQ_RCANCEL1[simp]", ``(b = BAG_UNION c b) <=> (c = {||})``, - rw[BAG_UNION, EMPTY_BAG, FUN_EQ_THM, DECIDE ``(x:num = y + x) <=> (y = 0)``]) -val _ = export_rewrites ["BAG_UNION_EQ_RCANCEL1"] + rw[BAG_UNION, EMPTY_BAG, FUN_EQ_THM, DECIDE ``(x:num = x + y) <=> (y = 0)``]) val BAG_IN_BAG_UNION = Q.store_thm( "BAG_IN_BAG_UNION", diff --git a/src/boss/bossLib.sml b/src/boss/bossLib.sml index 34f583dd6b..f794a2856f 100644 --- a/src/boss/bossLib.sml +++ b/src/boss/bossLib.sml @@ -172,20 +172,22 @@ fun stateful f ssfl thm : tactic = f ss thm end +val ARITH_ss = numSimps.ARITH_ss val fsrw_tac = stateful full_simp_tac val rfsrw_tac = stateful rev_full_simp_tac -val let_arith_list = [boolSimps.LET_ss, numSimps.ARITH_ss, listSimps.LIST_ss] +val let_arith_list = [boolSimps.LET_ss, ARITH_ss] val simp = stateful asm_simp_tac let_arith_list val dsimp = stateful asm_simp_tac (boolSimps.DNF_ss :: let_arith_list) val csimp = stateful asm_simp_tac (boolSimps.CONJ_ss :: let_arith_list) + val lrw = srw_tac let_arith_list val lfs = fsrw_tac let_arith_list val lrfs = rfsrw_tac let_arith_list -val rw = srw_tac [] -val fs = fsrw_tac [] -val rfs = rfsrw_tac [] +val rw = srw_tac let_arith_list +val fs = fsrw_tac let_arith_list +val rfs = rfsrw_tac let_arith_list (* useful quotation-based tactics (from Q) *) val qx_gen_tac : term quotation -> tactic = Q.X_GEN_TAC diff --git a/src/floating-point/binary_ieeeScript.sml b/src/floating-point/binary_ieeeScript.sml index 0871dc97e4..c9d9d4c161 100644 --- a/src/floating-point/binary_ieeeScript.sml +++ b/src/floating-point/binary_ieeeScript.sml @@ -964,7 +964,7 @@ val min_properties = Q.store_thm("min_properties", \\ Cases_on `precision (:'t) = 1` \\ Cases_on `precision (:'w) = 1` \\ imp_res_tac ge2 - \\ rw [] + \\ srw_tac[][] >- (qexists_tac `1n` \\ decide_tac) \\ Cases_on `n` \\ simp [] @@ -1000,9 +1000,9 @@ val lem2 = Q.prove( val tac = tac - \\ rw [float_to_real_def, two_mod_eq_zero, wordsTheory.dimword_def, - realLib.REAL_ARITH ``0r <= n ==> 1 + n <> 0``, exp_id, lem1, - DECIDE ``0 < n ==> n <> 0n``] + \\ srw_tac[] [float_to_real_def, two_mod_eq_zero, wordsTheory.dimword_def, + realLib.REAL_ARITH ``0r <= n ==> 1 + n <> 0``, exp_id, lem1, + DECIDE ``0 < n ==> n <> 0n``] \\ Cases_on `dimindex(:'w) = 1` \\ lrw [lem2] @@ -1534,7 +1534,8 @@ val not_next_tac = \\ imp_res_tac arithmeticTheory.LESS_EQUAL_ADD \\ imp_res_tac arithmeticTheory.LESS_ADD_1 \\ pop_assum kall_tac - \\ rfs [DECIDE ``1 < b ==> ((b - 1 = e) = (b = e + 1n))``] + \\ REV_FULL_SIMP_TAC (srw_ss()) + [DECIDE ``1 < b ==> ((b - 1 = e) = (b = e + 1n))``] \\ simp [arithmeticTheory.LEFT_ADD_DISTRIB] local @@ -1673,10 +1674,13 @@ in cancel_rwts] \\ rsimp [realTheory.REAL_OF_NUM_POW, Abbr `z`] \\ match_mp_tac lem4 - \\ fs [exponent_boundary_def] - \\ rfs [w2n_lt_pow, w2n_lt_pow_sub1, word_lt0, ge4, lem5] - \\ `p <> 0` by (strip_tac \\ fs [DECIDE ``(1 = x + 1) = (x = 0n)``]) - \\ fs [ge4] + \\ full_simp_tac (srw_ss()) [exponent_boundary_def] + \\ REV_FULL_SIMP_TAC (srw_ss()) + [w2n_lt_pow, w2n_lt_pow_sub1, word_lt0, ge4, lem5] + \\ `p <> 0` by (strip_tac \\ + full_simp_tac (srw_ss()) + [DECIDE ``(1 = x + 1) = (x = 0n)``]) + \\ full_simp_tac (srw_ss()) [ge4] val tac4 = abs_diff_tac abs_diff1a >- (match_mp_tac abs_diff1a \\ simp [subnormal_lt_normal]) @@ -1719,7 +1723,7 @@ in cancel_rwts] \\ rsimp [realTheory.REAL_OF_NUM_POW, Abbr `z`] \\ match_mp_tac lem4b - \\ rfs [w2n_lt_pow, word_lt0, lem5] + \\ REV_FULL_SIMP_TAC (srw_ss()) [w2n_lt_pow, word_lt0, lem5] end val diff_exponent_ULP = Q.prove( diff --git a/src/integer/int_bitwiseScript.sml b/src/integer/int_bitwiseScript.sml index f3f1162b23..a0abfbaf8e 100644 --- a/src/integer/int_bitwiseScript.sml +++ b/src/integer/int_bitwiseScript.sml @@ -88,7 +88,7 @@ val num_of_bits_bits_of_num = prove( \\ Q.PAT_ASSUM `n = kkk:num` (fn th => CONV_TAC (RAND_CONV (ONCE_REWRITE_CONV [th]))) \\ ASSUME_TAC MOD2 - \\ fs [AC MULT_COMM MULT_ASSOC, AC ADD_ASSOC ADD_COMM]); + \\ fs []); val bits_bitwise_NIL = prove( ``!xs rest f. bits_bitwise f ([],F) (xs,rest) = (MAP (f F) xs,f F rest)``, @@ -120,12 +120,12 @@ val BIT_lemmas = prove( (BIT 0 (1 + 2 * k) = T) /\ (BIT (SUC n) (2 * k) = BIT n k) /\ (BIT (SUC n) (1 + 2 * k) = BIT n k)``, - fs [GSYM BIT_DIV2] + simp_tac (srw_ss()) [GSYM BIT_DIV2] \\ ONCE_REWRITE_TAC [ADD_COMM] \\ ONCE_REWRITE_TAC [MULT_COMM] - \\ fs [DIV_MULT,MULT_DIV] - \\ fs [BIT_def,BITS_THM] - \\ fs [MOD_TIMES,MOD_EQ_0]); + \\ simp_tac (srw_ss()) [DIV_MULT,MULT_DIV] + \\ simp_tac (srw_ss()) [BIT_def,BITS_THM] + \\ rw [MOD_TIMES,MOD_EQ_0]); val BIT_num_of_bits = prove( ``!bs n. BIT n (num_of_bits bs) = n < LENGTH bs /\ EL n bs``, @@ -265,10 +265,10 @@ val int_bit_shift_left_lemma2 = prove( val int_bit_shift_left = store_thm("int_bit_shift_left", ``!b n i. int_bit b (int_shift_left n i) = n <= b /\ int_bit (b - n) i``, REPEAT STRIP_TAC \\ Cases_on `b < n` - \\ fs [int_bit_shift_left_lemma2] THEN1 decide_tac + \\ asm_simp_tac (srw_ss()) [int_bit_shift_left_lemma2] THEN1 decide_tac \\ fs [NOT_LESS] \\ imp_res_tac LESS_EQUAL_ADD \\ fs [] \\ ONCE_REWRITE_TAC [ADD_COMM] - \\ fs [int_bit_shift_left_lemma1]); + \\ simp_tac (srw_ss()) [int_bit_shift_left_lemma1]); val int_bit_shift_right = store_thm("int_bit_shift_right", ``!b n i. int_bit b (int_shift_right n i) = int_bit (b + n) i``, diff --git a/src/n-bit/bitstringScript.sml b/src/n-bit/bitstringScript.sml index 4d8d937a49..95cf0385ce 100644 --- a/src/n-bit/bitstringScript.sml +++ b/src/n-bit/bitstringScript.sml @@ -136,15 +136,14 @@ val pad_left_extend = Q.store_thm("pad_left_extend", \\ Cases_on `n <= LENGTH l` >- lrw [listTheory.PAD_LEFT, DECIDE ``n <= l ==> (n - l = 0)``, Thm.CONJUNCT1 extend_def] - \\ Induct_on `n` \\ lrw [listTheory.PAD_LEFT] + \\ simp[listTheory.PAD_LEFT] + \\ Induct_on `n` \\ rw [] \\ Cases_on `LENGTH l = n` \\ lrw [bitTheory.SUC_SUB, extend_cons |> Q.SPEC `0` |> SIMP_RULE std_ss [Thm.CONJUNCT1 extend_def]] \\ `SUC n - LENGTH l = SUC (n - LENGTH l)` by decide_tac - \\ `LENGTH l < n` by decide_tac - \\ fs [extend_cons, listTheory.PAD_LEFT, listTheory.GENLIST_CONS, - DECIDE ``l < n ==> ~(n <= l : num)``]); + \\ simp [extend_cons, listTheory.GENLIST_CONS]); val extend = Q.store_thm("extend", `(!n v. zero_extend n v = extend F (n - LENGTH v) v) /\ @@ -229,12 +228,12 @@ val length_w2v = Q.store_thm("length_w2v", val length_rotate = Q.store_thm("length_rotate", `!v n. LENGTH (rotate v n) = LENGTH v`, - simp [rotate_def] - \\ rw [length_field] - \\ fs [DECIDE ``n <> 0n ==> (SUC (n - 1) = n)``, - DECIDE ``n:num < l ==> (n + (l - n) = l)``, - arithmeticTheory.NOT_ZERO_LT_ZERO, arithmeticTheory.MOD_LESS] - ) + simp [rotate_def, LET_THM] + \\ srw_tac[][length_field] + \\ full_simp_tac (srw_ss()) [DECIDE ``n <> 0n ==> (SUC (n - 1) = n)``, + DECIDE ``n:num < l ==> (n + (l - n) = l)``, + arithmeticTheory.NOT_ZERO_LT_ZERO, + arithmeticTheory.MOD_LESS]) val el_rev_count_list = Q.store_thm("el_rev_count_list", `!n i. i < n ==> (EL i (rev_count_list n) = n - 1 - i)`, @@ -320,11 +319,11 @@ val testbit = Q.store_thm("testbit", val testbit_geq_len = Q.store_thm("testbit_geq_len", `!v i. LENGTH v <= i ==> ~testbit i v`, - simp [testbit]) + simp [testbit, LET_THM]) val testbit_el = Q.store_thm("testbit_el", `!v i. i < LENGTH v ==> (testbit i v = EL (LENGTH v - 1 - i) v)`, - simp [testbit]) + simp [testbit, LET_THM]) val bit_v2w = Q.store_thm("bit_v2w", `!n v. word_bit n (v2w v : 'a word) = n < dimindex(:'a) /\ testbit n v`, @@ -431,7 +430,7 @@ val field_concat_left = Q.store_thm("field_concat_left", `!h l a b. l <= h /\ LENGTH b <= l ==> (field h l (a ++ b) = field (h - LENGTH b) (l - LENGTH b) a)`, - rw [field_def, shiftr_def] + srw_tac [][field_def, shiftr_def] \\ imp_res_tac arithmeticTheory.LESS_EQUAL_ADD \\ pop_assum kall_tac \\ pop_assum SUBST_ALL_TAC diff --git a/src/patricia/sptreeScript.sml b/src/patricia/sptreeScript.sml index 3abc89bbf2..4f6a0144f5 100644 --- a/src/patricia/sptreeScript.sml +++ b/src/patricia/sptreeScript.sml @@ -377,14 +377,14 @@ val lrnext_def = prove( REPEAT STRIP_TAC THEN1 (fs [Once ALT_ZERO,Once lrnext_real_def]) THEN1 - (fs [Once BIT1,Once lrnext_real_def] - \\ AP_TERM_TAC \\ AP_TERM_TAC \\ fs [Once BIT1] - \\ fs [ADD_ASSOC,DECIDE ``n+n=n*2``,MULT_DIV]) + (full_simp_tac (srw_ss()) [Once BIT1,Once lrnext_real_def] + \\ AP_TERM_TAC \\ AP_TERM_TAC \\ simp_tac (srw_ss()) [Once BIT1] + \\ full_simp_tac (srw_ss()) [ADD_ASSOC,DECIDE ``n+n=n*2``,MULT_DIV]) THEN1 - (fs [Once BIT2,Once lrnext_real_def] - \\ AP_TERM_TAC \\ AP_TERM_TAC \\ fs [Once BIT2] + (simp_tac (srw_ss()) [Once BIT2,Once lrnext_real_def] + \\ AP_TERM_TAC \\ AP_TERM_TAC \\ simp_tac (srw_ss()) [Once BIT2] \\ `n + (n + 2) - 1 = n * 2 + 1` by DECIDE_TAC - \\ fs [DIV_MULT])) + \\ asm_simp_tac (srw_ss()) [DIV_MULT])) val lrnext' = prove( ``(!a. lrnext 0 = 1) /\ (!n a. lrnext (NUMERAL n) = lrnext n)``, simp[NUMERAL_DEF, GSYM ALT_ZERO, lrnext_def]) @@ -431,7 +431,6 @@ val lookup_fromList = store_thm( val bit_cases = prove( ``!n. (n = 0) \/ (?m. n = 2 * m + 1) \/ (?m. n = 2 * m + 2)``, Induct >> simp[] >> fs[] - >- (disj1_tac >> qexists_tac `0` >> simp[]) >- (disj2_tac >> qexists_tac `m` >> simp[]) >- (disj1_tac >> qexists_tac `SUC m` >> simp[])) diff --git a/src/sort/mergesortScript.sml b/src/sort/mergesortScript.sml index 8eb7cc78d0..efd61cfbd9 100644 --- a/src/sort/mergesortScript.sml +++ b/src/sort/mergesortScript.sml @@ -13,7 +13,7 @@ val every_case_tac = BasicProvers.EVERY_CASE_TAC; val last_reverse = Q.prove ( `!l. l <> [] ==> LAST (REVERSE l) = HD l`, Induct_on `l` >> - rw []); + srw_tac[][]); val mem_sorted_append = Q.prove ( `!R l1 l2 x y. @@ -24,7 +24,7 @@ val mem_sorted_append = Q.prove ( ==> R x y`, Induct_on `l1` >> - rw [] >> + srw_tac[][] >> REV_FULL_SIMP_TAC (srw_ss()) [SORTED_EQ] >> metis_tac []); @@ -83,7 +83,7 @@ val mergesortN_def = tDefine "mergesortN" ` let len1 = DIV2 n in merge R (mergesortN R (DIV2 n) l) (mergesortN R (n - len1) (DROP len1 l)))` (WF_REL_TAC `measure (\(R,n,l). n)` >> - rw [DIV2_def, X_LT_DIV] + srw_tac[][DIV2_def, X_LT_DIV] >- (match_mp_tac DIV_LESS >> decide_tac) >> decide_tac); @@ -151,8 +151,8 @@ val mergesortN_tail_def = tDefine "mergesortN_tail" ` (mergesortN_tail neg R (n - len1) (DROP len1 l)) [])` (WF_REL_TAC `measure (\(neg,R,n,l). n)` >> - rw [DIV2_def] >> - rw [DIV2_def, X_LT_DIV] + srw_tac[][DIV2_def] >> + srw_tac[][DIV2_def, X_LT_DIV] >- (match_mp_tac DIV_LESS >> decide_tac) >> decide_tac); @@ -178,15 +178,15 @@ val sort3_perm = Q.store_thm ("sort3_perm", val merge_perm = Q.store_thm ("merge_perm", `!R l1 l2. PERM (l1++l2) (merge R l1 l2)`, ho_match_mp_tac merge_ind >> - rw [merge_def] >> + srw_tac[][merge_def] >> full_simp_tac (srw_ss()++PERM_ss) []); val mergesortN_perm = Q.store_thm ("mergesortN_perm", `!R n l. PERM (TAKE n l) (mergesortN R n l)`, ho_match_mp_tac mergesortN_ind >> - rw [] >> + srw_tac[][] >> ONCE_REWRITE_TAC [mergesortN_def] >> - rw [sort2_perm, sort3_perm] + srw_tac[][sort2_perm, sort3_perm] >- (every_case_tac >> fs []) >- (every_case_tac >> @@ -202,7 +202,7 @@ val mergesortN_perm = Q.store_thm ("mergesortN_perm", val mergesort_perm = Q.store_thm ("mergesort_perm", `!R l. PERM l (mergesort R l)`, - rw [mergesort_def] >> + srw_tac[][mergesort_def] >> metis_tac [TAKE_LENGTH_ID, mergesortN_perm]); (* mergesort's output is sorted *) @@ -212,7 +212,7 @@ val sort2_sorted = Q.store_thm ("sort2_sorted", total R ==> SORTED R (sort2 R x y)`, - rw [sort2_def, SORTED_DEF, total_def] >> + srw_tac[][sort2_def, SORTED_DEF, total_def] >> metis_tac []); val sort3_sorted = Q.store_thm ("sort3_sorted", @@ -220,7 +220,7 @@ val sort3_sorted = Q.store_thm ("sort3_sorted", total R ==> SORTED R (sort3 R x y z)`, - rw [sort3_def, SORTED_DEF, total_def] >> + srw_tac[][sort3_def, SORTED_DEF, total_def] >> metis_tac []); val merge_sorted = Q.store_thm ("merge_sorted", @@ -229,9 +229,9 @@ val merge_sorted = Q.store_thm ("merge_sorted", ==> SORTED R (merge R l1 l2)`, ho_match_mp_tac merge_ind >> - rw [merge_def] >> + srw_tac[][merge_def] >> REV_FULL_SIMP_TAC (srw_ss()) [SORTED_EQ] >> - rw [] >> + srw_tac[][] >> fs [transitive_def, total_def] >- (`PERM (l1++(y::l2)) (merge R l1 (y::l2))` by metis_tac [merge_perm] >> imp_res_tac MEM_PERM >> @@ -248,21 +248,21 @@ val mergesortN_sorted = Q.store_thm ("mergesortN_sorted", ==> SORTED R (mergesortN R n l)`, ho_match_mp_tac mergesortN_ind >> - rw [] >> + srw_tac[][] >> ONCE_REWRITE_TAC [mergesortN_def] >> - rw [SORTED_EQ, SORTED_DEF, sort2_sorted, sort3_sorted] + srw_tac[][SORTED_EQ, SORTED_DEF, sort2_sorted, sort3_sorted] >- (Cases_on `l` >> - rw []) + srw_tac[][]) >- (Cases_on `l` >> - rw [] >> + srw_tac[][] >> Cases_on `t` >> - rw [sort2_sorted]) + srw_tac[][sort2_sorted]) >- (Cases_on `l` >> - rw [] >> + srw_tac[][] >> Cases_on `t` >> - rw [sort2_sorted] >> + srw_tac[][sort2_sorted] >> Cases_on `t'` >> - rw [sort2_sorted, sort3_sorted]) + srw_tac[][sort2_sorted, sort3_sorted]) >- metis_tac [merge_sorted]); val mergesort_sorted = Q.store_thm ("mergesort_sorted", @@ -276,20 +276,20 @@ val stable_cong = Q.store_thm ("stable_cong", stable R l1 l2 /\ stable R l3 l4 ==> stable R (l1++l3) (l2++l4)`, - rw [stable_def, FILTER_APPEND]); + srw_tac[][stable_def, FILTER_APPEND]); val stable_trans = Q.store_thm ("stable_trans", `!R l1 l2 l3. stable R l1 l2 /\ stable R l2 l3 ==> stable R l1 l3`, - rw [stable_def]); + srw_tac[][stable_def]); val sort2_stable = Q.store_thm ("sort2_stable", `!R x y. stable R [x;y] (sort2 R x y)`, - rw [stable_def, sort2_def] >> + srw_tac[][stable_def, sort2_def] >> every_case_tac >> - rw [] >> + srw_tac[][] >> metis_tac []); val sort3_stable = Q.store_thm ("sort3_stable", @@ -297,9 +297,9 @@ val sort3_stable = Q.store_thm ("sort3_stable", total R /\ transitive R ==> stable R [x;y;z] (sort3 R x y z)`, - rw [sort3_def, stable_def] >> + srw_tac[][sort3_def, stable_def] >> every_case_tac >> - rw [] >> + srw_tac[][] >> metis_tac [total_def, transitive_def]); val filter_merge = Q.store_thm ("filter_merge", @@ -311,17 +311,17 @@ val filter_merge = Q.store_thm ("filter_merge", FILTER P (merge R l1 l2) = FILTER P (l1 ++ l2)`, gen_tac >> ho_match_mp_tac merge_ind >> - rw [merge_def, SORTED_EQ] >> - rw [merge_def, FILTER_APPEND] >> + srw_tac[][merge_def, SORTED_EQ] >> + srw_tac[][merge_def, FILTER_APPEND] >> REV_FULL_SIMP_TAC (srw_ss()) [SORTED_EQ, FILTER_APPEND] >- metis_tac [] >- metis_tac [] >- (`FILTER P l1 = []` - by (rw [FILTER_EQ_NIL] >> + by (srw_tac[][FILTER_EQ_NIL] >> CCONTR_TAC >> fs [EXISTS_MEM] >> metis_tac [transitive_def]) >> - rw [])); + srw_tac[][])); val merge_stable = Q.store_thm ("merge_stable", `!R l1 l2. @@ -329,7 +329,7 @@ val merge_stable = Q.store_thm ("merge_stable", SORTED R l1 ==> stable R (l1 ++ l2) (merge R l1 l2)`, - rw [stable_def, filter_merge]); + srw_tac[][stable_def, filter_merge]); val mergesortN_stable = Q.store_thm ("mergesortN_stable", `!R n l. @@ -337,26 +337,26 @@ val mergesortN_stable = Q.store_thm ("mergesortN_stable", ==> stable R (TAKE n l) (mergesortN R n l)`, ho_match_mp_tac mergesortN_ind >> - rw [] >> + srw_tac[][] >> ONCE_REWRITE_TAC [mergesortN_def] >> - rw [sort2_stable, sort3_stable] >> - TRY (rw [stable_def] >> NO_TAC) + srw_tac[][sort2_stable, sort3_stable] >> + TRY (srw_tac[][stable_def] >> NO_TAC) >- (Cases_on `l` >> - rw [stable_def]) + srw_tac[][stable_def]) >- (Cases_on `l` >> - rw [] >> - TRY (rw [stable_def] >> NO_TAC) >> + srw_tac[][] >> + TRY (srw_tac[][stable_def] >> NO_TAC) >> Cases_on `t` >> - rw [sort2_stable] >> - rw [stable_def]) + srw_tac[][sort2_stable] >> + srw_tac[][stable_def]) >- (Cases_on `l` >> - rw [] >> - TRY (rw [stable_def] >> NO_TAC) >> + srw_tac[][] >> + TRY (srw_tac[][stable_def] >> NO_TAC) >> Cases_on `t` >> - rw [sort2_stable] >> - TRY (rw [stable_def] >> NO_TAC) >> + srw_tac[][sort2_stable] >> + TRY (srw_tac[][stable_def] >> NO_TAC) >> Cases_on `t'` >> - rw [sort2_stable, sort3_stable]) + srw_tac[][sort2_stable, sort3_stable]) >- (`len1 <= n` by (UNABBREV_ALL_TAC >> fs [DIV2_def, DIV_LESS_EQ]) >> @@ -370,7 +370,7 @@ val mergesort_stable = Q.store_thm ("mergesort_stable", val mergesort_STABLE_SORT = Q.store_thm ("mergesort_STABLE_SORT", `!R. transitive R /\ total R ==> STABLE mergesort R`, - rw [STABLE_DEF, SORTS_DEF] >> + srw_tac[][STABLE_DEF, SORTS_DEF] >> metis_tac [mergesort_perm, mergesort_sorted, mergesort_stable, stable_def]); val mergesort_mem = Q.store_thm ("mergesort_mem", @@ -382,13 +382,13 @@ val mergesort_mem = Q.store_thm ("mergesort_mem", val sort2_tail_correct = Q.store_thm ("sort2_tail_correct", `!neg R x y. sort2_tail neg R x y = if neg then REVERSE (sort2 R x y) else sort2 R x y`, - rw [sort2_def, sort2_tail_def] >> + srw_tac[][sort2_def, sort2_tail_def] >> fs []); val sort3_tail_correct = Q.store_thm ("sort3_tail_correct", `!neg R x y z. sort3_tail neg R x y z = if neg then REVERSE (sort3 R x y z) else sort3 R x y z`, - rw [sort3_def, sort3_tail_def] >> + srw_tac[][sort3_def, sort3_tail_def] >> fs []); val merge_tail_correct1 = Q.store_thm ("merge_tail_correct1", @@ -397,14 +397,14 @@ val merge_tail_correct1 = Q.store_thm ("merge_tail_correct1", ==> merge_tail neg R l1 l2 acc = REVERSE (merge R l1 l2) ++ acc`, ho_match_mp_tac merge_tail_ind >> - rw [merge_tail_def, merge_def, REV_REVERSE_LEM]); + srw_tac[][merge_tail_def, merge_def, REV_REVERSE_LEM]); val merge_empty = Q.store_thm ("merge_empty", `!R l acc. merge R l [] = l /\ merge R [] l = l`, Cases_on `l` >> - rw [merge_def]); + srw_tac[][merge_def]); val merge_last_lem1 = Q.prove ( `!R l1 l2 x. @@ -412,9 +412,9 @@ val merge_last_lem1 = Q.prove ( ==> merge R (l1 ++ [x]) l2 = merge R l1 l2 ++ [x]`, ho_match_mp_tac merge_ind >> - rw [merge_def, merge_empty] >> + srw_tac[][merge_def, merge_empty] >> Induct_on `v5` >> - rw [merge_empty, merge_def] >> + srw_tac[][merge_empty, merge_def] >> metis_tac []); val merge_last_lem2 = Q.prove ( @@ -423,9 +423,9 @@ val merge_last_lem2 = Q.prove ( ==> merge R l1 (l2 ++ [y]) = merge R l1 l2 ++ [y]`, ho_match_mp_tac merge_ind >> - rw [merge_def, merge_empty] >> + srw_tac[][merge_def, merge_empty] >> Induct_on `v9` >> - rw [merge_empty, merge_def] >> + srw_tac[][merge_empty, merge_def] >> metis_tac []); val merge_tail_correct2 = Q.store_thm ("merge_tail_correct2", @@ -437,21 +437,21 @@ val merge_tail_correct2 = Q.store_thm ("merge_tail_correct2", ==> merge_tail neg R l1 l2 acc = (merge R (REVERSE l1) (REVERSE l2)) ++ acc`, ho_match_mp_tac merge_tail_ind >> - rw [merge_tail_def, merge_def, REV_REVERSE_LEM, merge_empty] >> + srw_tac[][merge_tail_def, merge_def, REV_REVERSE_LEM, merge_empty] >> fs [] >> `SORTED R (REVERSE l1) /\ SORTED R (REVERSE l2)` by metis_tac [SORTED_APPEND_IFF] >> fs [] >- (match_mp_tac (GSYM merge_last_lem1) >> - rw [] >> - rw [] >> + srw_tac[][] >> + srw_tac[][] >> CCONTR_TAC >> fs [] >> `R y' y` by metis_tac [mem_sorted_append, MEM_REVERSE, MEM] >> metis_tac [transitive_def]) >- (match_mp_tac (GSYM merge_last_lem2) >> - rw [] >> - rw [] >> + srw_tac[][] >> + srw_tac[][] >> `R x' x` by metis_tac [mem_sorted_append, MEM_REVERSE, MEM] >> metis_tac [transitive_def])); @@ -463,14 +463,14 @@ val mergesortN_tail_correct = Q.store_thm ("mergesortN_correct", mergesortN_tail negate R n l = (if negate then REVERSE (mergesortN R n l) else mergesortN R n l)`, ho_match_mp_tac mergesortN_tail_ind >> - rw [] >> + srw_tac[][] >> ONCE_REWRITE_TAC [mergesortN_tail_def, mergesortN_def] >> - rw [sort2_tail_correct, sort3_tail_correct] >> + srw_tac[][sort2_tail_correct, sort3_tail_correct] >> fs [] >> every_case_tac >> fs [] >> UNABBREV_ALL_TAC >> - rw [merge_tail_correct1] >> + srw_tac[][merge_tail_correct1] >> metis_tac [merge_tail_correct2, mergesortN_sorted, REVERSE_REVERSE, APPEND_NIL]); val mergesort_tail_correct = Q.store_thm ("mergesort_tail_correct", @@ -479,7 +479,7 @@ val mergesort_tail_correct = Q.store_thm ("mergesort_tail_correct", transitive R ==> mergesort_tail R l = mergesort R l`, - rw [mergesort_tail_def, mergesort_def, mergesortN_tail_correct]); + srw_tac[][mergesort_tail_def, mergesort_def, mergesortN_tail_correct]); (* @@ -498,7 +498,7 @@ val mergesortN'_def = tDefine "mergesortN'" ` let len1 = DIV2 n in merge R (mergesortN' R (DIV2 n) l) (mergesortN' R (n - len1) (DROP len1 l)))` (WF_REL_TAC `measure (\(R,n,l). n)` >> - rw [DIV2_def] >> + srw_tac[][DIV2_def] >> COOPER_TAC); val mergesortN''_def = tDefine "mergesortN''" ` @@ -509,7 +509,7 @@ val mergesortN''_def = tDefine "mergesortN''" ` let len1 = DIV2 n in merge R (mergesortN'' R (DIV2 n) l) (mergesortN'' R (n - len1) (DROP len1 l)))` (WF_REL_TAC `measure (\(R,n,l). n)` >> - rw [DIV2_def] >> + srw_tac[][DIV2_def] >> COOPER_TAC); val rand_list_def = Define ` From 016d1d1ca6ae5efd50d453f14b3091794a2f8bc1 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 15 Jan 2016 16:13:39 +1100 Subject: [PATCH 627/718] Polyscripter: ##assert directive; work on parity chapter --- Manual/Tools/README | 3 + Manual/Tools/polyscripter.sml | 16 +- Manual/Tutorial/.gitignore | 1 + Manual/Tutorial/Holmakefile | 5 +- Manual/Tutorial/{parity.tex => parity.stex} | 203 ++++++-------------- 5 files changed, 80 insertions(+), 148 deletions(-) rename Manual/Tutorial/{parity.tex => parity.stex} (83%) diff --git a/Manual/Tools/README b/Manual/Tools/README index 8086bf5a9b..0411cc8ed5 100644 --- a/Manual/Tools/README +++ b/Manual/Tools/README @@ -13,6 +13,9 @@ All of the following inline commands must begin the line in which they occur: - The `##use` command gets the compiler to evaluate the `use` the filename. The filename is given after a single space character and is the rest of the line; it need not be quoted, and shouldn’t be followed by a semicolon. The compilation and evaluation of the filename is done entirely silently. +- The `##assert` command gets the compiler to evaluate the following expression (which can just be one line long). + If it evaluates to true, then nothing is output. + If it is false, then the scripter aborts. ## Command-line Options diff --git a/Manual/Tools/polyscripter.sml b/Manual/Tools/polyscripter.sml index 94b5cb3bd0..a03da86f32 100644 --- a/Manual/Tools/polyscripter.sml +++ b/Manual/Tools/polyscripter.sml @@ -170,8 +170,22 @@ fun process_line umap (obuf as (_, _, obRST)) line lbuf = let else String.concat (List.rev acc) end + val assertcmd = "##assert " + val assertcmdsz = size assertcmd in - if String.isPrefix "##use " line then + if String.isPrefix assertcmd line then + let + val e = String.substring(line, assertcmdsz, size line - assertcmdsz - 1) + (* for \n at end *) + val _ = compiler obuf (linenum lbuf) + (mkLex ("val _ = if (" ^ quote e ^ ") then () " ^ + "else die \"Assertion failed: line " ^ + Int.toString (linenum lbuf) ^ "\";")) + val _ = advance lbuf + in + ("\n", NONE) + end + else if String.isPrefix "##use " line then let val fname = String.substring(line, 6, size line - 7) (* for \n at end *) val _ = silentUse (linenum lbuf) fname diff --git a/Manual/Tutorial/.gitignore b/Manual/Tutorial/.gitignore index 444ea9e8b3..8dff665837 100644 --- a/Manual/Tutorial/.gitignore +++ b/Manual/Tutorial/.gitignore @@ -1 +1,2 @@ euclid.tex +parity.tex diff --git a/Manual/Tutorial/Holmakefile b/Manual/Tutorial/Holmakefile index 8583d2aab1..15c954b8e1 100644 --- a/Manual/Tutorial/Holmakefile +++ b/Manual/Tutorial/Holmakefile @@ -1,7 +1,10 @@ INCLUDES = ../Tools -tutorial.pdf: tutorial.tex euclid.tex logic.tex preface.tex proof-tools.tex theories.tex combin.tex +tutorial.pdf: tutorial.tex euclid.tex logic.tex preface.tex proof-tools.tex theories.tex combin.tex parity.tex latexmk -pdf tutorial euclid.tex: euclid.stex ../Tools/umap ../Tools/polyscripter euclid-extras.ML ../Tools/polyscripter ../Tools/umap < $< > $@ + +parity.tex: parity.stex ../Tools/umap ../Tools/polyscripter euclid-extras.ML + ../Tools/polyscripter ../Tools/umap < $< > $@ diff --git a/Manual/Tutorial/parity.tex b/Manual/Tutorial/parity.stex similarity index 83% rename from Manual/Tutorial/parity.tex rename to Manual/Tutorial/parity.stex index 099d8f0079..069abfe6a5 100644 --- a/Manual/Tutorial/parity.tex +++ b/Manual/Tutorial/parity.stex @@ -43,10 +43,9 @@ \section{Introduction} \section{Specification} \label{example} -The first step is to start up the \HOL{} system. We again use -\texttt{/bin/hol}. The \ML{} prompt is {\small\verb|-|}, so -lines beginning with {\small\verb|-|} are typed by the user and other -lines are the system's response. +The first step is to start up the \HOL{} system. +We again use \texttt{/bin/hol}. +The \ML{} prompt is {\small\verb|>|}, so lines beginning with {\small\verb|>|} are typed by the user and other lines are the system's response. To specify the device, a primitive recursive function {\small\verb|PARITY|} is defined so that for $n>0$, {\small\tt PARITY} @@ -56,17 +55,11 @@ \section{Specification} \setcounter{sessioncount}{0} \begin{session} -\begin{verbatim} -- val PARITY_def = Define` - (PARITY 0 f = T) /\ - (PARITY(SUC n) f = if f(SUC n) then ~(PARITY n f) else PARITY n f)`; -Definition has been stored under "PARITY_def". -> val PARITY_def = - |- (!f. PARITY 0 f = T) /\ - !n f. PARITY (SUC n) f = - (if f (SUC n) then ~PARITY n f else PARITY n f) - : thm -\end{verbatim} +\begin{alltt} +>> val PARITY_def = Define` + (PARITY 0 f = T) /\ + (PARITY(SUC n) f = if f(SUC n) then ~PARITY n f else PARITY n f)`; +\end{alltt} \end{session} \noindent @@ -139,44 +132,28 @@ \section{Specification} function {\small\verb|g|} which takes a goal as argument. \begin{session} -\begin{verbatim} -- g `!inp out. +\begin{alltt} +>> g `!inp out. (out 0 = T) /\ (!t. out(SUC t) = (if inp(SUC t) then ~(out t) else out t)) ==> (!t. out t = PARITY t inp)`; -> val it = - Proof manager status: 1 proof. - 1. Incomplete: - Initial goal: - !inp out. - (out 0 = T) /\ - (!t. out (SUC t) = (if inp (SUC t) then ~out t else out t)) ==> - !t. out t = PARITY t inp -\end{verbatim} +\end{alltt} \end{session} -\noindent The subgoal package prints out the goal on the top of the goal stack. +\noindent +The subgoal package prints out the goal on the top of the goal stack. The top goal is expanded by stripping off the universal quantifier -(with {\small\verb|GEN_TAC|}) and then making the two conjuncts of the +(with {\small\verb|gen_tac|}) and then making the two conjuncts of the antecedent of the implication into assumptions of the goal (with -{\small\verb|STRIP_TAC|}). The \ML{} function {\small\verb|expand|} -takes a tactic and applies it to the top goal; the resulting subgoals -are pushed on to the goal stack. The message `{\small\verb|OK..|}' is -printed out just before the tactic is applied. The resulting subgoal -is then printed. - +{\small\verb|strip_tac|}). +The \ML{} function {\small\verb|e|} takes a tactic and applies it to the top goal; the resulting subgoals are pushed on to the goal stack. +The message `{\small\verb|OK..|}' is printed out just before the tactic is applied. +The resulting subgoal is then printed. \begin{session} -\begin{verbatim} -- expand(REPEAT GEN_TAC THEN STRIP_TAC); -OK.. -1 subgoal: -> val it = - !t. out t = PARITY t inp - ------------------------------------ - 0. out 0 = T - 1. !t. out (SUC t) = (if inp (SUC t) then ~out t else out t) -\end{verbatim} +\begin{alltt} +>> e(rpt gen_tac >> strip_tac); +\end{alltt} \end{session} \noindent Next induction on {\small\verb|t|} is done @@ -184,22 +161,9 @@ \section{Specification} induction on the outermost universally quantified variable. \begin{session} -\begin{verbatim} -- expand Induct; -OK.. -2 subgoals: -> val it = - out (SUC t) = PARITY (SUC t) inp - ------------------------------------ - 0. out 0 = T - 1. !t. out (SUC t) = (if inp (SUC t) then ~out t else out t) - 2. out t = PARITY t inp - - out 0 = PARITY 0 inp - ------------------------------------ - 0. out 0 = T - 1. !t. out (SUC t) = (if inp (SUC t) then ~out t else out t) -\end{verbatim} +\begin{alltt} +>> e Induct; +\end{alltt} \end{session} \noindent The assumptions of the two subgoals @@ -208,23 +172,10 @@ \section{Specification} basis case. This is solved by rewriting with its assumptions and the definition of {\small\verb|PARITY|}. - \begin{session} -\begin{verbatim} -- expand(ASM_REWRITE_TAC[PARITY_def]); -OK.. - -Goal proved. - [.] |- out 0 = PARITY 0 inp - -Remaining subgoals: -> val it = - out (SUC t) = PARITY (SUC t) inp - ------------------------------------ - 0. out 0 = T - 1. !t. out (SUC t) = (if inp (SUC t) then ~out t else out t) - 2. out t = PARITY t inp -\end{verbatim} +\begin{alltt} +>> e(rw[PARITY_def]); +\end{alltt} \end{session} The top goal is proved, so the system pops it from the goal stack (and @@ -232,22 +183,10 @@ \section{Specification} the step case of the induction. This goal is also solved by rewriting. \begin{session} -\begin{verbatim} -- expand(ASM_REWRITE_TAC[PARITY_def]); -OK.. - -Goal proved. - [..] |- out (SUC t) = PARITY (SUC t) inp - -Goal proved. - [..] |- !t. out t = PARITY t inp -> val it = - Initial goal proved. - |- !inp out. - (out 0 = T) /\ - (!t. out (SUC t) = (if inp (SUC t) then ~out t else out t)) ==> - !t. out t = PARITY t inp -\end{verbatim} +\begin{alltt} +>> e(rw[PARITY_def]); +##assert can top_thm () +\end{alltt} \end{session} \noindent The goal is proved, \ie\ the empty list of subgoals is produced. @@ -270,15 +209,9 @@ \section{Specification} \ml{UNIQUENESS\_LEMMA}. \begin{session} -\begin{verbatim} -- val UNIQUENESS_LEMMA = top_thm(); -> val UNIQUENESS_LEMMA = - |- !inp out. - (out 0 = T) /\ - (!t. out (SUC t) = (if inp (SUC t) then ~out t else out t)) ==> - !t. out t = PARITY t inp - : thm -\end{verbatim} +\begin{alltt} +>> val UNIQUENESS_LEMMA = top_thm(); +\end{alltt} \end{session} \section{Implementation} @@ -369,11 +302,9 @@ \section{Implementation} {\small\verb|out|} is {\small\verb|T|}. \begin{session} -\begin{verbatim} -- val ONE_def = Define `ONE(out:num->bool) = !t. out t = T`; -Definition stored under "ONE_def". -> val ONE_def = |- !out. ONE out = !t. out t = T : thm -\end{verbatim} +\begin{alltt} +>> val ONE_def = Define `ONE(out:num->bool) = !t. out t = T`; +\end{alltt} \end{session} \noindent Note that, as discussed above, `{\small\verb|ONE_def|}' is used both @@ -390,11 +321,9 @@ \section{Implementation} register-transfer level model, but not at a lower level. \begin{session} -\begin{verbatim} -- val NOT_def = Define`NOT(inp, out:num->bool) = !t. out t = ~(inp t)`; -Definition stored under "NOT_def". -> val NOT_def = |- !inp out. NOT (inp,out) = !t. out t = ~inp t : Thm.thm -\end{verbatim} +\begin{alltt} +>> val NOT_def = Define`NOT(inp, out:num->bool) = !t. out t = ~(inp t)`; +\end{alltt} \end{session} \noindent The final combinational device needed is a multiplexer. @@ -403,16 +332,11 @@ \section{Implementation} two inputs are to be connected to the output {\small\verb|out|}. \begin{session} -\begin{verbatim} -- val MUX_def = Define` - MUX(sw,in1,in2,out:num->bool) = - !t. out t = if sw t then in1 t else in2 t`; -Definition stored under "MUX_def". -> val MUX_def = - |- !sw in1 in2 out. - MUX (sw,in1,in2,out) = !t. out t = (if sw t then in1 t else in2 t) - : thm -\end{verbatim} +\begin{alltt} +>> val MUX_def = Define` + MUX(sw,in1,in2,out:num->bool) = + !t. out t = if sw t then in1 t else in2 t`; +\end{alltt} \end{session} The remaining devices in the schematic are registers. These are @@ -423,16 +347,11 @@ \section{Implementation} device is switched on.} \begin{session} -\begin{verbatim} -- val REG_def = - Define `REG(inp,out:num->bool) = - !t. out t = if (t=0) then F else inp(t-1)`; -Definition stored under "REG_def". -> val REG_def = - |- !inp out. REG (inp,out) = !t. out t = - (if t = 0 then F else inp (t - 1)) - : thm -\end{verbatim} +\begin{alltt} +>> val REG_def = + Define `REG(inp,out:num->bool) = + !t. out t = if (t=0) then F else inp(t-1)`; +\end{alltt} \end{session} The schematic diagram above can be represented as a predicate by @@ -442,21 +361,13 @@ \section{Implementation} (\eg\ see \cite{Camilleri-et-al,Why-HOL-paper}). \begin{session} -\begin{verbatim} -- val PARITY_IMP_def = Define - `PARITY_IMP(inp,out) = - ?l1 l2 l3 l4 l5. - NOT(l2,l1) /\ MUX(inp,l1,l2,l3) /\ REG(out,l2) /\ - ONE l4 /\ REG(l4,l5) /\ MUX(l5,l3,l4,out)`; -Definition stored under "PARITY_IMP_def". -> val PARITY_IMP_def = - |- !inp out. - PARITY_IMP (inp,out) = - ?l1 l2 l3 l4 l5. - NOT (l2,l1) /\ MUX (inp,l1,l2,l3) /\ REG (out,l2) /\ ONE l4 /\ - REG (l4,l5) /\ MUX (l5,l3,l4,out) - : thm -\end{verbatim} +\begin{alltt} +>> val PARITY_IMP_def = Define + `PARITY_IMP(inp,out) = + ?l1 l2 l3 l4 l5. + NOT(l2,l1) /\ MUX(inp,l1,l2,l3) /\ REG(out,l2) /\ + ONE l4 /\ REG(l4,l5) /\ MUX(l5,l3,l4,out)`; +\end{alltt} \end{session}\label{parity-imp} \section{Verification} From 1082e3d494c830d5dbae4d138c9f77206c081942 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 11 Jan 2016 14:29:17 +1100 Subject: [PATCH 628/718] Better overload-removal API in Parse Previously, one could only remove mappings from strings to bare terms, making it hard to remove overloadings to patterns. Now it is possible to remove pattern overloadings too. Illustrate new facility with example of fixing record field updates to be less polymorphic. --- src/datatype/theory_tests/monofldAScript.sml | 14 +++++++++ src/datatype/theory_tests/monofldBScript.sml | 33 ++++++++++++++++++++ src/parse/Parse.sig | 2 ++ src/parse/Parse.sml | 18 +++++++++++ 4 files changed, 67 insertions(+) create mode 100644 src/datatype/theory_tests/monofldAScript.sml create mode 100644 src/datatype/theory_tests/monofldBScript.sml diff --git a/src/datatype/theory_tests/monofldAScript.sml b/src/datatype/theory_tests/monofldAScript.sml new file mode 100644 index 0000000000..01f23c7e02 --- /dev/null +++ b/src/datatype/theory_tests/monofldAScript.sml @@ -0,0 +1,14 @@ +open HolKernel Parse boolLib Datatype + +val _ = new_theory "monofldA"; + +val _ = Datatype`rcd = <| myset : 'a -> bool ; sz : num |>`; + +val _ = gen_remove_ovl_mapping + (GrammarSpecials.recfupd_special ^ "myset") + ``λf x. rcd_myset_fupd f x`` + +val _ = Parse.add_record_fupdate( + "myset", Term.inst[beta |-> alpha] ``rcd_myset_fupd``); + +val _ = export_theory(); diff --git a/src/datatype/theory_tests/monofldBScript.sml b/src/datatype/theory_tests/monofldBScript.sml new file mode 100644 index 0000000000..756ac48ca8 --- /dev/null +++ b/src/datatype/theory_tests/monofldBScript.sml @@ -0,0 +1,33 @@ +open HolKernel Parse boolLib + +open monofldATheory + +val _ = new_theory "monofldB"; + +val (write, read) = let + val buf = ref ([] : string list) + fun w s = (buf := s :: !buf) + fun r () = let + val result = String.concat (List.rev (!buf)) + in + buf := [result]; + result + end +in + (w, r) +end + +val _ = Feedback.MESG_outstream := write +val _ = Globals.interactive := true + +val t = ``(r : 'a rcd) with myset := (\x. F)``; + +val _ = assert (equal ``:'a rcd``) (type_of t) + +val msg = read() +val _ = if msg = "" then print "No message\n" + else raise Fail ("Message was: "^msg) + +val _ = save_thm("MFB", TRUTH) + +val _ = export_theory(); diff --git a/src/parse/Parse.sig b/src/parse/Parse.sig index 0de9d29228..a1f450d53a 100644 --- a/src/parse/Parse.sig +++ b/src/parse/Parse.sig @@ -109,6 +109,7 @@ signature Parse = sig val bring_to_front_overload : string -> {Name: string, Thy: string} -> unit val clear_overloads_on : string -> unit val remove_ovl_mapping : string -> {Name:string, Thy:string} -> unit + val gen_remove_ovl_mapping : string -> term -> unit val add_record_field : string * term -> unit val add_record_fupdate : string * term -> unit @@ -161,6 +162,7 @@ signature Parse = sig val temp_bring_to_front_overload : string -> {Name:string,Thy:string} -> unit val temp_clear_overloads_on : string -> unit val temp_remove_ovl_mapping : string -> {Name:string, Thy:string} -> unit + val temp_gen_remove_ovl_mapping : string -> term -> unit val temp_add_record_field : string * term -> unit val temp_add_record_fupdate : string * term -> unit diff --git a/src/parse/Parse.sml b/src/parse/Parse.sml index 50bcb0b657..84bb25755b 100644 --- a/src/parse/Parse.sml +++ b/src/parse/Parse.sml @@ -1212,6 +1212,24 @@ in [" {Name = ", quote Name, ", ", "Thy = ", quote Thy, "}"]) end +fun temp_gen_remove_ovl_mapping s t = + let + open term_grammar + in + the_term_grammar := + fupdate_overload_info (Overload.gen_remove_mapping s t) (term_grammar()); + term_grammar_changed := true + end + +fun gen_remove_ovl_mapping s t = + let + in + temp_gen_remove_ovl_mapping s t ; + update_grms "gen_remove_ovl_mapping" + ("(UTOFF (temp_gen_remove_ovl_mapping " ^ quote s ^ "))", + minprint t) + end + fun primadd_rcdfld f ovopn (fldname, t) = let val (d,r) = dom_rng (type_of t) From d85972d5076891a2e84e19b38310e080a350622c Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Sun, 17 Jan 2016 19:49:33 +1100 Subject: [PATCH 629/718] Explain record polymorphism "fix" in release notes --- doc/kananaskis-11.release.md | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/doc/kananaskis-11.release.md b/doc/kananaskis-11.release.md index fc367e6a87..1623ee9f0b 100644 --- a/doc/kananaskis-11.release.md +++ b/doc/kananaskis-11.release.md @@ -52,6 +52,17 @@ New features: This definition would have previously been rejected. ([Github issue](https://github.com/HOL-Theorem-Prover/HOL/issues/173)) + This change can cause **incompatibilities**. + If one wants the old behaviour, it should suffice to overload the record update syntax to use a more specific type. + For example: + + val _ = gen_remove_ovl_mapping + (GrammarSpecials.recfupd_special ^ "myset") + ``λf x. rcd_myset_fupd f x`` + + val _ = Parse.add_record_fupdate( + "myset", Term.inst[beta |-> alpha] ``rcd_myset_fupd``); + - PolyML “heaps” are now implemented with its `SaveState` technology, used hierarchically. This should make heaps smaller as they now only save deltas over the last used heap. From f38cb0113766d5c8e5831cc28ae4beefea49af4c Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 18 Jan 2016 09:42:27 +1100 Subject: [PATCH 630/718] Move kall_tac to bossLib Closes #274 --- src/boss/bossLib.sig | 1 + src/boss/bossLib.sml | 1 + src/boss/lcsymtacs.sml | 3 --- 3 files changed, 2 insertions(+), 3 deletions(-) diff --git a/src/boss/bossLib.sig b/src/boss/bossLib.sig index 1482e81882..2952c0d16d 100644 --- a/src/boss/bossLib.sig +++ b/src/boss/bossLib.sig @@ -118,6 +118,7 @@ sig val by : term quotation * tactic -> tactic (* infix *) val suffices_by : term quotation * tactic -> tactic (* infix *) val cheat : tactic + val kall_tac : 'a -> tactic (* Abbreviations (see also Q structure) *) diff --git a/src/boss/bossLib.sml b/src/boss/bossLib.sml index 34f583dd6b..f150d6386f 100644 --- a/src/boss/bossLib.sml +++ b/src/boss/bossLib.sml @@ -126,6 +126,7 @@ fun ZAP_TAC ss thl = ORELSE DECIDE_TAC ORELSE BasicProvers.GEN_PROVE_TAC 0 12 1 thl); +fun kall_tac x = Tactical.all_tac val cheat:tactic = fn g => ([], fn _ => Thm.mk_oracle_thm "cheat" g) (*--------------------------------------------------------------------------- diff --git a/src/boss/lcsymtacs.sml b/src/boss/lcsymtacs.sml index 5258b255ca..e6b5fae3c1 100644 --- a/src/boss/lcsymtacs.sml +++ b/src/boss/lcsymtacs.sml @@ -4,7 +4,4 @@ struct open Abbrev HolKernel boolLib Tactic Tactical BasicProvers simpLib open Rewrite bossLib Thm_cont - fun kall_tac (_: 'a) : tactic = all_tac - - end From 71143f0b0da3f41425a3eceba205819ef0b95874 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 18 Jan 2016 10:17:34 +1100 Subject: [PATCH 631/718] Remove Unicode from 1082e3d4 --- src/datatype/theory_tests/monofldAScript.sml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/datatype/theory_tests/monofldAScript.sml b/src/datatype/theory_tests/monofldAScript.sml index 01f23c7e02..80672fe33e 100644 --- a/src/datatype/theory_tests/monofldAScript.sml +++ b/src/datatype/theory_tests/monofldAScript.sml @@ -6,7 +6,7 @@ val _ = Datatype`rcd = <| myset : 'a -> bool ; sz : num |>`; val _ = gen_remove_ovl_mapping (GrammarSpecials.recfupd_special ^ "myset") - ``λf x. rcd_myset_fupd f x`` + ``\f x. rcd_myset_fupd f x`` val _ = Parse.add_record_fupdate( "myset", Term.inst[beta |-> alpha] ``rcd_myset_fupd``); From f38b7cba09e29106686049e5a81a093dc493d08d Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 18 Jan 2016 10:55:15 +1100 Subject: [PATCH 632/718] Tweak "couldn't build thy graph" message in build --- tools/buildutils.sml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/tools/buildutils.sml b/tools/buildutils.sml index affb1c6604..1e3b212c7d 100644 --- a/tools/buildutils.sml +++ b/tools/buildutils.sml @@ -695,7 +695,9 @@ in \*** config-override (Moscow ML)\n\ \***\n\ \*** (Under Poly/ML you will have to delete bin/hol.builder0 as \ - \well)\n") + \well)\n***\n\ + \*** (Or: build with -nograph to stop this \ + \message from appearing again)\n") else let val _ = print "Generating theory-graph and HTML theory signatures; this may take a while\n" val _ = print " (Use build's -nograph option to skip this step.)\n" From 6500ee9493a6d7f16882c4af06f4f29f2226a09e Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Mon, 18 Jan 2016 18:36:40 +1100 Subject: [PATCH 633/718] attempt to allow indented input/output in polyscripter --- Manual/Tools/README | 2 +- Manual/Tools/polyscripter.sml | 35 +++++++++++++++++++++++------------ 2 files changed, 24 insertions(+), 13 deletions(-) diff --git a/Manual/Tools/README b/Manual/Tools/README index 0411cc8ed5..dcfca071b7 100644 --- a/Manual/Tools/README +++ b/Manual/Tools/README @@ -5,7 +5,7 @@ If it sees one such, it executes the Poly/ML compiler on that line, captures the ## Inline Options -All of the following inline commands must begin the line in which they occur: +All of the following inline commands must be the first non-whitespace on the line in which they occur. - The usual `>>` command gets the input after this prompt read until the next line that begins with a non-space character. - The `>>_` command gets the compiler to act on the accompanying input, and this input is printed out, but the output is elided diff --git a/Manual/Tools/polyscripter.sml b/Manual/Tools/polyscripter.sml index a03da86f32..86f1c5666a 100644 --- a/Manual/Tools/polyscripter.sml +++ b/Manual/Tools/polyscripter.sml @@ -151,24 +151,35 @@ fun removeCruft s = NONE => s | SOME s' => removeCruft s' -fun transformOutput umap s = +fun addIndent ws = String.translate(fn #"\n" => "\n"^ws | c => str c) + +fun transformOutput umap ws s = s |> umunge umap |> removeCruft + |> addIndent ws |> deleteTrailingWhiteSpace +val getIndent = + (Substring.string ## Substring.string) + o Substring.splitl Char.isSpace o Substring.full + fun process_line umap (obuf as (_, _, obRST)) line lbuf = let + val (ws,line) = getIndent line + val indent = String.size ws fun getRest acc = let val _ = advance lbuf in case current lbuf of NONE => String.concat (List.rev acc) - | SOME s => if String.size s > 1 andalso - Char.isSpace (String.sub(s,0)) - then - getRest (String.extract(s,1,NONE)::acc) - else - String.concat (List.rev acc) + | SOME s => + let + val (ws',s) = getIndent s + in + if indent < String.size ws' + then getRest (s::acc) + else String.concat (List.rev acc) + end end val assertcmd = "##assert " val assertcmdsz = size assertcmd @@ -191,7 +202,7 @@ in val _ = silentUse (linenum lbuf) fname val _ = advance lbuf in - ("\n", NONE) + ("", NONE) end else if String.isPrefix ">>__" line then let @@ -199,7 +210,7 @@ in val input = getRest [firstline] val _ = compiler obuf (linenum lbuf) (mkLex (quote input)) in - ("\n", NONE) + ("", NONE) end else if String.isPrefix ">>_" line then let @@ -208,7 +219,7 @@ in val _ = compiler obuf (linenum lbuf) (mkLex (quote input)) fun removeNL s = String.substring(s, 0, size s - 1) in - (removeNL (umunge umap input), SOME (!elision_string1)) + (ws^">"^addIndent ws (removeNL (umunge umap input)), SOME (!elision_string1)) end else if String.isPrefix ">>" line then let @@ -217,7 +228,7 @@ in val input = getRest [firstline] val raw_output = compiler obuf (linenum lbuf) (mkLex (quote input)) in - (umunge umap input, SOME (transformOutput umap raw_output)) + (ws^">"^addIndent ws (umunge umap input), SOME (transformOutput umap ws raw_output)) end else (advance lbuf; (line, NONE)) @@ -279,7 +290,7 @@ fun main () = in (case coutopt of NONE => print i - | SOME out => print (">" ^ i ^ out)); + | SOME out => print (i ^ out)); recurse lb end in From 867f07bf2e7b006c563e583e9c3d9d772eb0c41a Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 19 Jan 2016 09:34:06 +1100 Subject: [PATCH 634/718] Fix polyscripter to not lose blank lines --- Manual/Tools/polyscripter.sml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Manual/Tools/polyscripter.sml b/Manual/Tools/polyscripter.sml index 86f1c5666a..7a3ef6319c 100644 --- a/Manual/Tools/polyscripter.sml +++ b/Manual/Tools/polyscripter.sml @@ -163,8 +163,8 @@ val getIndent = (Substring.string ## Substring.string) o Substring.splitl Char.isSpace o Substring.full -fun process_line umap (obuf as (_, _, obRST)) line lbuf = let - val (ws,line) = getIndent line +fun process_line umap (obuf as (_, _, obRST)) origline lbuf = let + val (ws,line) = getIndent origline val indent = String.size ws fun getRest acc = let @@ -231,7 +231,7 @@ in (ws^">"^addIndent ws (umunge umap input), SOME (transformOutput umap ws raw_output)) end else - (advance lbuf; (line, NONE)) + (advance lbuf; (origline, NONE)) end fun read_umap fname = From da7bb21795d924506cde49bb07837c00d1494e4b Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 19 Jan 2016 09:36:47 +1100 Subject: [PATCH 635/718] Add 'bag-in' Unicode symbol to polyscripter's umap --- Manual/Tools/umap | 1 + 1 file changed, 1 insertion(+) diff --git a/Manual/Tools/umap b/Manual/Tools/umap index fa1d2d8117..f86be33d96 100644 --- a/Manual/Tools/umap +++ b/Manual/Tools/umap @@ -15,3 +15,4 @@ ∈ \(\in\) ∪ \(\cup\) ∩ \(\cap\) +⋲ <: From a372370d6a35d5e3c3786673fa097461cbefe942 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 19 Jan 2016 09:37:28 +1100 Subject: [PATCH 636/718] Run a test-case when polyscripter builds --- Manual/Tools/Holmakefile | 11 +++++++- Manual/Tools/expected1 | 55 ++++++++++++++++++++++++++++++++++++++++ Manual/Tools/testinput1 | 25 ++++++++++++++++++ 3 files changed, 90 insertions(+), 1 deletion(-) create mode 100644 Manual/Tools/expected1 create mode 100644 Manual/Tools/testinput1 diff --git a/Manual/Tools/Holmakefile b/Manual/Tools/Holmakefile index 98fd8695b0..48900bcaa6 100644 --- a/Manual/Tools/Holmakefile +++ b/Manual/Tools/Holmakefile @@ -1,4 +1,13 @@ -EXTRA_CLEANS = polyscripter +INCLUDES = ../../tools/cmp +EXTRA_CLEANS = polyscripter testoutput1 + +.PHONY: all tests + +all: polyscripter tests polyscripter: polyscripter.sml $(dprot $(HOLDIR)/bin/hol.state) $(POLYC) $< -o $@ + +tests: polyscripter umap testinput1 expected1 $(dprot ../../tools/cmp/cmp.exe) + ./polyscripter umap < testinput1 > testoutput1 + ../../tools/cmp/cmp.exe testoutput1 expected1 diff --git a/Manual/Tools/expected1 b/Manual/Tools/expected1 new file mode 100644 index 0000000000..6b8e07ee1d --- /dev/null +++ b/Manual/Tools/expected1 @@ -0,0 +1,55 @@ +foo bar +baz +> val x = 10; +val x = 10: int +> x + 1; +val it = 11: int +> g `!x. 4 < x /\bs{} x < 10 ==> +x < 20`; +val it = + Proof manager status: 1 proof. +1. Incomplete goalstack: + Initial goal: + + \(\forall\)x. 4 < x \(\land\) x < 10 \(\Rightarrow\) x < 20 +\end{verbatim} + +\begin{session} +> open arithmeticTheory;\quad\textit{\small\dots{}output elided\dots{}} +> ADD_CLAUSES; +val it = + |- (0 + m = m) \(\land\) (m + 0 = m) \(\land\) (SUC m + n = SUC (m + n)) \(\land\) + (m + SUC n = SUC (m + n)): + thm +> load "bagTheory"; +val it = (): unit +> bagTheory.BAG_IN_BAG_INSERT; +val it = |- \(\forall\)b e1 e2. e1 <: BAG_INSERT e2 b \({\iff}\) (e1 = e2) \(\lor\) e1 <: b: + thm +This case illustrates an interesting issue: the HOL system itself writes a message to standard out; we'd like to capture this so that it is properly sequenced with the other output. + +> g `p \(\in\) set l \(\Rightarrow\) \(\exists\)i. i < LENGTH l \(\land\) (p = EL i l)`; +<> +val it = + Proof manager status: 2 proofs. +2. Incomplete goalstack: + Initial goal: + + \(\forall\)x. 4 < x \(\land\) x < 10 \(\Rightarrow\) x < 20 + + +1. Incomplete goalstack: + Initial goal: + + MEM p l \(\Rightarrow\) \(\exists\)i. i < LENGTH l \(\land\) (p = EL i l) +> ``3 <> 4``; +val it = ``3 \(\ne\) 4``: term +> type_of ``[]``; +<> +val it = ``:\(\alpha\) list``: hol_type +\end{session} +> 3 + +4; +val it = 7: int +foo +bar diff --git a/Manual/Tools/testinput1 b/Manual/Tools/testinput1 new file mode 100644 index 0000000000..ac8c40dc1f --- /dev/null +++ b/Manual/Tools/testinput1 @@ -0,0 +1,25 @@ +foo bar +baz +>> val x = 10; +>> x + 1; +>> g `!x. 4 < x /\ x < 10 ==> + x < 20`; +\end{verbatim} + +\begin{session} +>>_ open arithmeticTheory; +>> ADD_CLAUSES; + +>> load "bagTheory"; +>> bagTheory.BAG_IN_BAG_INSERT; + +This case illustrates an interesting issue: the HOL system itself writes a message to standard out; we'd like to capture this so that it is properly sequenced with the other output. + +>> g `p ∈ set l ⇒ ∃i. i < LENGTH l ∧ (p = EL i l)`; +>> ``3 <> 4``; +>> type_of ``[]``; +\end{session} +>> 3 + + 4; +foo +bar From c7e671413a0b7e25f13681b0691310887f5a8dd9 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 19 Jan 2016 10:01:10 +1100 Subject: [PATCH 637/718] Handle indentation better in polyscripter --- Manual/Tools/.gitignore | 1 + Manual/Tools/expected1 | 15 ++++++++++++++- Manual/Tools/polyscripter.sml | 34 +++++++++++++++++++++++++--------- Manual/Tools/testinput1 | 8 ++++++++ 4 files changed, 48 insertions(+), 10 deletions(-) diff --git a/Manual/Tools/.gitignore b/Manual/Tools/.gitignore index 5084933564..ed1ea8faf7 100644 --- a/Manual/Tools/.gitignore +++ b/Manual/Tools/.gitignore @@ -1 +1,2 @@ polyscripter +testoutput1 diff --git a/Manual/Tools/expected1 b/Manual/Tools/expected1 index 6b8e07ee1d..4ff4160689 100644 --- a/Manual/Tools/expected1 +++ b/Manual/Tools/expected1 @@ -5,7 +5,7 @@ val x = 10: int > x + 1; val it = 11: int > g `!x. 4 < x /\bs{} x < 10 ==> -x < 20`; + x < 20`; val it = Proof manager status: 1 proof. 1. Incomplete goalstack: @@ -21,11 +21,13 @@ val it = |- (0 + m = m) \(\land\) (m + 0 = m) \(\land\) (SUC m + n = SUC (m + n)) \(\land\) (m + SUC n = SUC (m + n)): thm + > load "bagTheory"; val it = (): unit > bagTheory.BAG_IN_BAG_INSERT; val it = |- \(\forall\)b e1 e2. e1 <: BAG_INSERT e2 b \({\iff}\) (e1 = e2) \(\lor\) e1 <: b: thm + This case illustrates an interesting issue: the HOL system itself writes a message to standard out; we'd like to capture this so that it is properly sequenced with the other output. > g `p \(\in\) set l \(\Rightarrow\) \(\exists\)i. i < LENGTH l \(\land\) (p = EL i l)`; @@ -53,3 +55,14 @@ val it = ``:\(\alpha\) list``: hol_type val it = 7: int foo bar + + > "indented string"; + val it = "indented string": string + + > x + size "indented\bs{} + \bs{}string"; + val it = 24: int + > 10 + + 20 + + 4; + val it = 34: int diff --git a/Manual/Tools/polyscripter.sml b/Manual/Tools/polyscripter.sml index 7a3ef6319c..3996e6d6b3 100644 --- a/Manual/Tools/polyscripter.sml +++ b/Manual/Tools/polyscripter.sml @@ -10,6 +10,8 @@ fun lnumdie linenum extra exn = die ("Exception raised on line " ^ Int.toString linenum ^ ": "^ extra ^ General.exnMessage exn) +val outputPrompt = ref ">" + fun mkBuffer () = let val buf = ref ([] : string list) fun push s = buf := s :: !buf @@ -158,26 +160,40 @@ fun transformOutput umap ws s = |> removeCruft |> addIndent ws |> deleteTrailingWhiteSpace + |> (fn s => ws ^ s) + +fun spaceNotNL c = Char.isSpace c andalso c <> #"\n" val getIndent = (Substring.string ## Substring.string) - o Substring.splitl Char.isSpace o Substring.full + o Substring.splitl spaceNotNL o Substring.full fun process_line umap (obuf as (_, _, obRST)) origline lbuf = let val (ws,line) = getIndent origline val indent = String.size ws - fun getRest acc = + val oPsize = size (!outputPrompt) + fun getRest userPromptSize acc = let val _ = advance lbuf + val handlePromptSize = + if userPromptSize > oPsize then + fn s => String.extract(s, userPromptSize - oPsize, NONE) + else + let + val ws_n = + CharVector.tabulate(oPsize - userPromptSize, fn _ => #" ") + in + fn s => ws_n ^ s + end in case current lbuf of NONE => String.concat (List.rev acc) | SOME s => let - val (ws',s) = getIndent s + val (ws',_) = getIndent s in if indent < String.size ws' - then getRest (s::acc) + then getRest userPromptSize (handlePromptSize s::acc) else String.concat (List.rev acc) end end @@ -207,7 +223,7 @@ in else if String.isPrefix ">>__" line then let val firstline = String.extract(line, 4, NONE) - val input = getRest [firstline] + val input = getRest 4 [firstline] val _ = compiler obuf (linenum lbuf) (mkLex (quote input)) in ("", NONE) @@ -215,20 +231,20 @@ in else if String.isPrefix ">>_" line then let val firstline = String.extract(line, 3, NONE) - val input = getRest [firstline] + val input = getRest 3 [firstline] val _ = compiler obuf (linenum lbuf) (mkLex (quote input)) fun removeNL s = String.substring(s, 0, size s - 1) in - (ws^">"^addIndent ws (removeNL (umunge umap input)), SOME (!elision_string1)) + (ws ^ ">" ^ removeNL (umunge umap input), SOME (!elision_string1)) end else if String.isPrefix ">>" line then let val _ = obRST() val firstline = String.extract(line, 2, NONE) - val input = getRest [firstline] + val input = getRest 2 [firstline] val raw_output = compiler obuf (linenum lbuf) (mkLex (quote input)) in - (ws^">"^addIndent ws (umunge umap input), SOME (transformOutput umap ws raw_output)) + (ws ^ ">" ^ umunge umap input, SOME (transformOutput umap ws raw_output)) end else (advance lbuf; (origline, NONE)) diff --git a/Manual/Tools/testinput1 b/Manual/Tools/testinput1 index ac8c40dc1f..78c6fd5241 100644 --- a/Manual/Tools/testinput1 +++ b/Manual/Tools/testinput1 @@ -23,3 +23,11 @@ This case illustrates an interesting issue: the HOL system itself writes a messa 4; foo bar + + >> "indented string"; + + >> x + size "indented\ + \string"; + >> 10 + + 20 + + 4; From 7e295ce2ce75a5f2807ad8eff31e52ea2b626b3e Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 19 Jan 2016 10:11:25 +1100 Subject: [PATCH 638/718] Allow polyscripter commands to be escaped --- Manual/Tools/README | 3 +++ Manual/Tools/expected1 | 4 ++++ Manual/Tools/polyscripter.sml | 6 +++++- Manual/Tools/testinput1 | 4 ++++ 4 files changed, 16 insertions(+), 1 deletion(-) diff --git a/Manual/Tools/README b/Manual/Tools/README index dcfca071b7..d299bc2102 100644 --- a/Manual/Tools/README +++ b/Manual/Tools/README @@ -17,6 +17,9 @@ All of the following inline commands must be the first non-whitespace on the lin If it evaluates to true, then nothing is output. If it is false, then the scripter aborts. +If the first non-whitespace characters are `>>>` or `###` then the first of these characters is dropped, and the rest of the line is passed unchanged. +This allows for a form of escaping, just in case the input naturally wants to include `>>` or `##` at the start of a line. + ## Command-line Options - If `polyscripter` is passed a filename as its first argument, this file is read, and treated as a dictionary mapping single (UTF8) characters to replacement strings (with character separated from mapping by whitespace). diff --git a/Manual/Tools/expected1 b/Manual/Tools/expected1 index 4ff4160689..44de344888 100644 --- a/Manual/Tools/expected1 +++ b/Manual/Tools/expected1 @@ -66,3 +66,7 @@ bar 20 + 4; val it = 34: int + + >> is something I want passed “unchanged” + +##use should also be let through diff --git a/Manual/Tools/polyscripter.sml b/Manual/Tools/polyscripter.sml index 3996e6d6b3..7ea7a819f6 100644 --- a/Manual/Tools/polyscripter.sml +++ b/Manual/Tools/polyscripter.sml @@ -200,7 +200,11 @@ fun process_line umap (obuf as (_, _, obRST)) origline lbuf = let val assertcmd = "##assert " val assertcmdsz = size assertcmd in - if String.isPrefix assertcmd line then + if String.isPrefix ">>>" line then + (advance lbuf; (ws ^ String.extract(line, 1, NONE), NONE)) + else if String.isPrefix "###" line then + (advance lbuf; (ws ^ String.extract(line, 1, NONE), NONE)) + else if String.isPrefix assertcmd line then let val e = String.substring(line, assertcmdsz, size line - assertcmdsz - 1) (* for \n at end *) diff --git a/Manual/Tools/testinput1 b/Manual/Tools/testinput1 index 78c6fd5241..5f2d4545cb 100644 --- a/Manual/Tools/testinput1 +++ b/Manual/Tools/testinput1 @@ -31,3 +31,7 @@ bar >> 10 + 20 + 4; + + >>> is something I want passed “unchanged” + +###use should also be let through From cb5cc78f433c6cad5b0e296d63b9a1bb9311371c Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Tue, 19 Jan 2016 10:37:45 +1100 Subject: [PATCH 639/718] avoid re-testing polyscripter unnecessarily --- Manual/Tools/Holmakefile | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/Manual/Tools/Holmakefile b/Manual/Tools/Holmakefile index 48900bcaa6..02df53f709 100644 --- a/Manual/Tools/Holmakefile +++ b/Manual/Tools/Holmakefile @@ -1,13 +1,13 @@ INCLUDES = ../../tools/cmp EXTRA_CLEANS = polyscripter testoutput1 -.PHONY: all tests +.PHONY: all -all: polyscripter tests +all: polyscripter testoutput1 polyscripter: polyscripter.sml $(dprot $(HOLDIR)/bin/hol.state) $(POLYC) $< -o $@ -tests: polyscripter umap testinput1 expected1 $(dprot ../../tools/cmp/cmp.exe) - ./polyscripter umap < testinput1 > testoutput1 - ../../tools/cmp/cmp.exe testoutput1 expected1 +testoutput1: testinput1 polyscripter umap expected1 $(dprot ../../tools/cmp/cmp.exe) + ./polyscripter umap < $< > $@ + ../../tools/cmp/cmp.exe $@ expected1 From cdda9e807f443bddc5099c51e6db66bb6618694f Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Tue, 19 Jan 2016 11:54:26 +1100 Subject: [PATCH 640/718] polyscripter: add >>- for suppressing input but printing output --- Manual/Tools/README | 3 ++- Manual/Tools/expected1 | 2 ++ Manual/Tools/polyscripter.sml | 8 ++++++++ Manual/Tools/testinput1 | 2 ++ 4 files changed, 14 insertions(+), 1 deletion(-) diff --git a/Manual/Tools/README b/Manual/Tools/README index d299bc2102..65f4e60556 100644 --- a/Manual/Tools/README +++ b/Manual/Tools/README @@ -9,7 +9,8 @@ All of the following inline commands must be the first non-whitespace on the lin - The usual `>>` command gets the input after this prompt read until the next line that begins with a non-space character. - The `>>_` command gets the compiler to act on the accompanying input, and this input is printed out, but the output is elided -- The `>>__` command gets the compiler to act on the accompanying input, but nothing is printed out (strictly, this line is replaced by a blank line). +- The `>>__` command gets the compiler to act on the accompanying input, but nothing is printed out. +- The `>>-` command is similar to `>>_` except the input is suppressed while the output is printed out. - The `##use` command gets the compiler to evaluate the `use` the filename. The filename is given after a single space character and is the rest of the line; it need not be quoted, and shouldn’t be followed by a semicolon. The compilation and evaluation of the filename is done entirely silently. diff --git a/Manual/Tools/expected1 b/Manual/Tools/expected1 index 44de344888..f923249d72 100644 --- a/Manual/Tools/expected1 +++ b/Manual/Tools/expected1 @@ -70,3 +70,5 @@ bar >> is something I want passed “unchanged” ##use should also be let through + + val it = "input elided": string diff --git a/Manual/Tools/polyscripter.sml b/Manual/Tools/polyscripter.sml index 7ea7a819f6..37be136117 100644 --- a/Manual/Tools/polyscripter.sml +++ b/Manual/Tools/polyscripter.sml @@ -224,6 +224,14 @@ in in ("", NONE) end + else if String.isPrefix ">>-" line then + let + val firstline = String.extract(line, 3, NONE) + val input = getRest 3 [firstline] + val raw_output = compiler obuf (linenum lbuf) (mkLex (quote input)) + in + ("", SOME (transformOutput umap ws raw_output)) + end else if String.isPrefix ">>__" line then let val firstline = String.extract(line, 4, NONE) diff --git a/Manual/Tools/testinput1 b/Manual/Tools/testinput1 index 5f2d4545cb..5967d4ad3a 100644 --- a/Manual/Tools/testinput1 +++ b/Manual/Tools/testinput1 @@ -35,3 +35,5 @@ bar >>> is something I want passed “unchanged” ###use should also be let through + + >>- "input elided"; From 148845ed7fd0aa36d9afe44983ba745fa9a067fe Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Thu, 21 Jan 2016 18:31:06 +1100 Subject: [PATCH 641/718] add polyscripter command for catching and printing exceptions --- Manual/Tools/README | 1 + Manual/Tools/polyscripter.sml | 26 ++++++++++++++++++-------- 2 files changed, 19 insertions(+), 8 deletions(-) diff --git a/Manual/Tools/README b/Manual/Tools/README index 65f4e60556..82c22fb1e2 100644 --- a/Manual/Tools/README +++ b/Manual/Tools/README @@ -11,6 +11,7 @@ All of the following inline commands must be the first non-whitespace on the lin - The `>>_` command gets the compiler to act on the accompanying input, and this input is printed out, but the output is elided - The `>>__` command gets the compiler to act on the accompanying input, but nothing is printed out. - The `>>-` command is similar to `>>_` except the input is suppressed while the output is printed out. +- The `>>+` command is similar to `>>` except that if the input expression raises an un-handled exception, then rather than aborting execution, the exception will be printed as output. - The `##use` command gets the compiler to evaluate the `use` the filename. The filename is given after a single space character and is the rest of the line; it need not be quoted, and shouldn’t be followed by a semicolon. The compilation and evaluation of the filename is done entirely silently. diff --git a/Manual/Tools/polyscripter.sml b/Manual/Tools/polyscripter.sml index 37be136117..d6f952a30f 100644 --- a/Manual/Tools/polyscripter.sml +++ b/Manual/Tools/polyscripter.sml @@ -88,14 +88,14 @@ in doit end -fun compiler (obufPush, obufRD, obufRST) linenum infn = let +fun compiler (obufPush, obufRD, obufRST) handler infn = let fun record_error {message,...} = PolyML.prettyPrint(obufPush,70) message fun rpt acc = (obufRST(); PolyML.compiler(infn, [PolyML.Compiler.CPErrorMessageProc record_error, PolyML.Compiler.CPOutStream obufPush]) () - handle e => lnumdie linenum (obufRD()) e; + handle e => handler (obufRD()) e; if obufRD() = "" then String.concat (List.rev acc) else rpt (obufRD() :: acc)) in @@ -107,7 +107,7 @@ fun silentUse lnum s = val filecontents = quoteFile lnum s val buf = mkBuffer() in - compiler buf 1 (mkLex filecontents) + compiler buf (lnumdie 1) (mkLex filecontents) end @@ -208,7 +208,7 @@ in let val e = String.substring(line, assertcmdsz, size line - assertcmdsz - 1) (* for \n at end *) - val _ = compiler obuf (linenum lbuf) + val _ = compiler obuf (lnumdie (linenum lbuf)) (mkLex ("val _ = if (" ^ quote e ^ ") then () " ^ "else die \"Assertion failed: line " ^ Int.toString (linenum lbuf) ^ "\";")) @@ -228,7 +228,7 @@ in let val firstline = String.extract(line, 3, NONE) val input = getRest 3 [firstline] - val raw_output = compiler obuf (linenum lbuf) (mkLex (quote input)) + val raw_output = compiler obuf (lnumdie (linenum lbuf)) (mkLex (quote input)) in ("", SOME (transformOutput umap ws raw_output)) end @@ -236,7 +236,7 @@ in let val firstline = String.extract(line, 4, NONE) val input = getRest 4 [firstline] - val _ = compiler obuf (linenum lbuf) (mkLex (quote input)) + val _ = compiler obuf (lnumdie (linenum lbuf)) (mkLex (quote input)) in ("", NONE) end @@ -244,17 +244,27 @@ in let val firstline = String.extract(line, 3, NONE) val input = getRest 3 [firstline] - val _ = compiler obuf (linenum lbuf) (mkLex (quote input)) + val _ = compiler obuf (lnumdie (linenum lbuf)) (mkLex (quote input)) fun removeNL s = String.substring(s, 0, size s - 1) in (ws ^ ">" ^ removeNL (umunge umap input), SOME (!elision_string1)) end + else if String.isPrefix ">>+" line then + let + val firstline = String.extract(line, 3, NONE) + val input = getRest 3 [firstline] + fun handle_exn extra exn = raise Fail (extra ^ General.exnMessage exn) + val raw_output = compiler obuf handle_exn (mkLex (quote input)) + handle Fail s => s + in + (ws ^ ">" ^ umunge umap input, SOME (transformOutput umap ws raw_output)) + end else if String.isPrefix ">>" line then let val _ = obRST() val firstline = String.extract(line, 2, NONE) val input = getRest 2 [firstline] - val raw_output = compiler obuf (linenum lbuf) (mkLex (quote input)) + val raw_output = compiler obuf (lnumdie (linenum lbuf)) (mkLex (quote input)) in (ws ^ ">" ^ umunge umap input, SOME (transformOutput umap ws raw_output)) end From aa7d9b748cd8343b338ec20f911658ae67d10270 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 25 Jan 2016 22:06:53 +1100 Subject: [PATCH 642/718] Use polyscripter's exn handling >>+ in ML chapter Not quite ideal yet. --- Manual/Tutorial/.gitignore | 1 + Manual/Tutorial/Holmakefile | 7 ++- Manual/Tutorial/{ml.tex => ml.stex} | 95 ++++++++++++----------------- 3 files changed, 46 insertions(+), 57 deletions(-) rename Manual/Tutorial/{ml.tex => ml.stex} (86%) diff --git a/Manual/Tutorial/.gitignore b/Manual/Tutorial/.gitignore index 8dff665837..3d9033624e 100644 --- a/Manual/Tutorial/.gitignore +++ b/Manual/Tutorial/.gitignore @@ -1,2 +1,3 @@ euclid.tex parity.tex +ml.tex diff --git a/Manual/Tutorial/Holmakefile b/Manual/Tutorial/Holmakefile index 15c954b8e1..e01ff41203 100644 --- a/Manual/Tutorial/Holmakefile +++ b/Manual/Tutorial/Holmakefile @@ -1,10 +1,13 @@ INCLUDES = ../Tools -tutorial.pdf: tutorial.tex euclid.tex logic.tex preface.tex proof-tools.tex theories.tex combin.tex parity.tex +tutorial.pdf: tutorial.tex euclid.tex logic.tex preface.tex proof-tools.tex theories.tex combin.tex parity.tex ml.tex latexmk -pdf tutorial euclid.tex: euclid.stex ../Tools/umap ../Tools/polyscripter euclid-extras.ML ../Tools/polyscripter ../Tools/umap < $< > $@ -parity.tex: parity.stex ../Tools/umap ../Tools/polyscripter euclid-extras.ML +parity.tex: parity.stex ../Tools/umap ../Tools/polyscripter + ../Tools/polyscripter ../Tools/umap < $< > $@ + +ml.tex: ml.stex ../Tools/umap ../Tools/polyscripter ../Tools/polyscripter ../Tools/umap < $< > $@ diff --git a/Manual/Tutorial/ml.tex b/Manual/Tutorial/ml.stex similarity index 86% rename from Manual/Tutorial/ml.tex rename to Manual/Tutorial/ml.stex index 6a6e966432..ee20729d2a 100644 --- a/Manual/Tutorial/ml.tex +++ b/Manual/Tutorial/ml.stex @@ -57,7 +57,8 @@ \section{How to interact with ML} {\small\verb|hol|}. \setcounter{sessioncount}{0} -\begin{session}\begin{alltt} +\begin{session} +\begin{alltt} \$ bin/hol ----------------------------------------------------------------- @@ -68,8 +69,8 @@ \section{How to interact with ML} [loading theories and proof tools ************* ] [closing file "/local/scratch/mn200/Work/hol98/tools/end-init-boss.sml"] -- 1 :: [2,3,4,5]; -> val it = [1, 2, 3, 4, 5] : int list +> 1 :: [2,3,4,5]; +val it = [1, 2, 3, 4, 5] : int list \end{alltt} \end{session} @@ -94,19 +95,16 @@ \section{How to interact with ML} remembered in a variable called {\small\verb|it|}. \begin{session} -\begin{verbatim} -- val l = it; -> val l = [1, 2, 3, 4, 5] : int list +\begin{alltt} +>>__ 1 :: [2,3,4,5]; +>> val l = it; -- tl l; -> val it = [2, 3, 4, 5] : int list +>> tl l; -- hd it; -> val it = 2 : int +>> hd it; -- tl(tl(tl(tl(tl l)))); -> val it = [] : int list -\end{verbatim} +>> tl(tl(tl(tl(tl l)))); +\end{alltt} \end{session} Following standard $\lambda$-calculus usage, the application of a @@ -123,11 +121,9 @@ \section{How to interact with ML} each expression $e_i$ being bound to the name $x_i$. \begin{session} -\begin{verbatim} -- val l1 = [1,2,3] and l2 = ["a","b","c"]; -> val l1 = [1, 2, 3] : int list - val l2 = ["a", "b", "c"] : string list -\end{verbatim} +\begin{alltt} +>> val l1 = [1,2,3] and l2 = ["a","b","c"]; +\end{alltt} \end{session} \ML{} expressions like {\small\verb|"a"|}, {\small\verb|"b"|}, @@ -140,10 +136,9 @@ \section{How to interact with ML} {\small\verb|#|} character prepended. \begin{session} -\begin{verbatim} -- explode "a b c"; -> val it = [#"a", #" ", #"b", #" ", #"c"] : char list -\end{verbatim} +\begin{alltt} +>> explode "a b c"; +\end{alltt} \end{session} An expression of the form @@ -163,17 +158,15 @@ \section{How to interact with ML} {\small\verb|(int * int) * int|} respectively. \begin{session} -\begin{verbatim} -- val triple1 = (1,true,"abc"); -> val triple1 = (1, true, "abc") : int * bool * string -- #2 triple1; -> val it = true : bool - -- val triple2 = (1, (true, "abc")); -> val triple2 = (1, (true, "abc")) : int * (bool * string) -- #2 triple2;; -> val it = (true, "abc") : bool * string -\end{verbatim} +\begin{alltt} +>> val triple1 = (1,true,"abc"); + +>> #2 triple1; + +>> val triple2 = (1, (true, "abc")); + +>> #2 triple2;; +\end{alltt} \end{session} \noindent The \ML{} expressions {\small\verb|true|} and {\small\verb|false|} @@ -197,15 +190,13 @@ \section{How to interact with ML} {\small\verb|,(|}$x_n${\small\verb|,|}$y_n${\small\verb|)]|}. \begin{session} -\begin{verbatim} -- fun zip(l1,l2) = +\begin{alltt} +>> fun zip(l1,l2) = if null l1 orelse null l2 then [] else (hd l1,hd l2) :: zip(tl l1,tl l2); -> val zip = fn : 'a list * 'b list -> ('a * 'b) list -- zip([1,2,3],["a","b","c"]); -> val it = [(1, "a"), (2, "b"), (3, "c")] : (int * string) list -\end{verbatim} +>> zip([1,2,3],["a","b","c"]); +\end{alltt} \end{session} Functions may be {\it curried\/}, \ie\ take their arguments `one at a time' @@ -213,16 +204,13 @@ \section{How to interact with ML} {\small\verb|curried_zip|} below: \begin{session} -\begin{verbatim} -- fun curried_zip l1 l2 = zip(l1,l2); -> val curried_zip = fn : 'a list -> 'b list -> ('a * 'b) list +\begin{alltt} +>> fun curried_zip l1 l2 = zip(l1,l2); -- fun zip_num l2 = curried_zip [0,1,2] l2; -> val zip_num = fn : 'a list -> (int * 'a) list +>> fun zip_num l2 = curried_zip [0,1,2] l2; -- zip_num ["a","b","c"]; -> val it = [(0, "a"), (1, "b"), (2, "c")] : (int * string) list -\end{verbatim} +>> zip_num ["a","b","c"]; +\end{alltt} \end{session} The evaluation of an expression either {\it succeeds\/} or {\it @@ -242,14 +230,11 @@ \section{How to interact with ML} for a better explanation.} \begin{session} -\begin{verbatim} -- 3 div 0; -! Uncaught exception: -! Div - -- 3 div 0 handle _ => 0; -> val it = 0 : int -\end{verbatim} +\begin{alltt} +>>+ 3 div 0; + +>> 3 div 0 handle _ => 0; +\end{alltt} \end{session} The sessions above are enough to give a feel for \ML. In the next From c04e75aaf35e4a28d0676289cf0d560f1593905f Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 25 Jan 2016 22:10:53 +1100 Subject: [PATCH 643/718] Mimic Poly/ML's exn output better in polyscripter --- Manual/Tools/polyscripter.sml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Manual/Tools/polyscripter.sml b/Manual/Tools/polyscripter.sml index d6f952a30f..40a178ad1d 100644 --- a/Manual/Tools/polyscripter.sml +++ b/Manual/Tools/polyscripter.sml @@ -255,7 +255,7 @@ in val input = getRest 3 [firstline] fun handle_exn extra exn = raise Fail (extra ^ General.exnMessage exn) val raw_output = compiler obuf handle_exn (mkLex (quote input)) - handle Fail s => s + handle Fail s => "Exception- " ^ s ^ " raised\n" in (ws ^ ">" ^ umunge umap input, SOME (transformOutput umap ws raw_output)) end From 8e851303977e44a5e06bc496549bd0bd3523451a Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 25 Jan 2016 22:12:50 +1100 Subject: [PATCH 644/718] Test polyscripter exn-handling in regression test --- Manual/Tools/expected1 | 3 +++ Manual/Tools/testinput1 | 2 ++ 2 files changed, 5 insertions(+) diff --git a/Manual/Tools/expected1 b/Manual/Tools/expected1 index f923249d72..22fd3a4e30 100644 --- a/Manual/Tools/expected1 +++ b/Manual/Tools/expected1 @@ -72,3 +72,6 @@ bar ##use should also be let through val it = "input elided": string + +> 3 div 0; +Exception- Div raised diff --git a/Manual/Tools/testinput1 b/Manual/Tools/testinput1 index 5967d4ad3a..9cf71cff8d 100644 --- a/Manual/Tools/testinput1 +++ b/Manual/Tools/testinput1 @@ -37,3 +37,5 @@ bar ###use should also be let through >>- "input elided"; + +>>+ 3 div 0; From 9980faf423259c46d77cbaa0db79347ab4cbd772 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 25 Jan 2016 22:59:08 +1100 Subject: [PATCH 645/718] Handle Unicode subtraction in polyscripter's umap --- Manual/Tools/umap | 1 + 1 file changed, 1 insertion(+) diff --git a/Manual/Tools/umap b/Manual/Tools/umap index f86be33d96..8a7863fe46 100644 --- a/Manual/Tools/umap +++ b/Manual/Tools/umap @@ -16,3 +16,4 @@ ∪ \(\cup\) ∩ \(\cap\) ⋲ <: +− \({-}\) From d6b7a8bb6e45ff18be51fc3f906d59abeb5d6e6a Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 25 Jan 2016 22:59:23 +1100 Subject: [PATCH 646/718] More footling with Euclid proof in Tutorial --- Manual/Tutorial/euclid.stex | 193 ++++++++++++++---------------------- 1 file changed, 75 insertions(+), 118 deletions(-) diff --git a/Manual/Tutorial/euclid.stex b/Manual/Tutorial/euclid.stex index 9a16f37232..1b390884b5 100644 --- a/Manual/Tutorial/euclid.stex +++ b/Manual/Tutorial/euclid.stex @@ -369,13 +369,21 @@ A polished proof of {\small{\it DIVIDES\_FACT\/}} is the following\footnote{This and subsequent proofs use the theorems proved on page~\pageref{euclid:extra-proofs}, which were added to the \ML{} environment after being proved.}: +>>__ prove(``!m n. 0 < m /\ m <= n ==> m divides (FACT n)``, + lrw[LESS_EQ_EXISTS] >> + qcase_tac `m divides FACT (m + q)` >> + Induct_on `q` >> + lrw[FACT,ADD_CLAUSES] >| [ + Cases_on `m`, ALL_TAC + ] >> metis_tac [FACT, DECIDE ``!x. ~(x < x)``, + DIVIDES_RMUL, DIVIDES_LMUL, DIVIDES_REFL]) \begin{description} \item [\small{({\it DIVIDES\_FACT\/})}] \begin{tabular}[t]{l} \verb+!m n. 0 < m /\ m <= n ==> m divides (FACT n)+ \\ \hline \verb+lrw[LESS_EQ_EXISTS] >>+ \\ -\verb+Induct_on `p`+ >>+\\ -\verb!qcase_tac `m divides FACT (m + q)`+ >>!\\ +\verb!qcase_tac `m divides FACT (m + q)` >>!\\ +\verb+Induct_on `q` >>+\\ \verb+lrw[FACT,ADD_CLAUSES] >| [+ \\ \verb+ Cases_on `m`, ALL_TAC+ \\ \verb+] >> metis_tac [FACT, DECIDE ``!x. ~(x < x)``,+ \\ @@ -465,7 +473,7 @@ Certainly, the simplifier has already been primed with the irreflexivity of less This can be done with the \ml{fs} tactic: \begin{session} \begin{alltt} ->> b(); +>>_ b(); >> e (fs[]); \end{alltt} \end{session} @@ -542,7 +550,6 @@ tactic: \begin{session} \begin{alltt} >>_ restart(); - >> e (lrw[LESS_EQ_EXISTS] >> qcase_tac `m divides FACT (m + q)` >> Induct_on `q` >| [ @@ -583,66 +590,63 @@ The recast tactic is \end{hol} (Of course, when a tactic has been revised, it should be tested to see if it still proves the goal!) -Now recall that the use of \ml{RW\_TAC} -in the base case could be replaced by a call to \ml{METIS\_TAC}. Thus -it seems possible to merge the two sub-cases of the base case into a -single invocation of \ml{METIS\_TAC}: +Now recall that the use of \ml{lrw} in the base case could be replaced by a call to \ml{metis\_tac}. +Thus it seems possible to merge the two sub-cases of the base case into a single invocation of \ml{metis\_tac}: \begin{hol} \begin{verbatim} - RW_TAC arith_ss [LESS_EQ_EXISTS] - THEN Induct_on `p` - THEN RW_TAC arith_ss [FACT, ADD_CLAUSES] - THENL [Cases_on `m` THEN - METIS_TAC[DECIDE ``!x. ~(x> + qcase_tac `m divides FACT (m + q)` >> + Induct_on `q` >> + lrw[FACT, ADD_CLAUSES] >| [ + Cases_on `m` >> + metis_tac[DECIDE ``!x. ~(x> + qcase_tac `m divides FACT (m + q)` >> + Induct_on `q` >> + lrw[FACT, ADD_CLAUSES] >| [Cases_on `m`, all_tac] >> + metis_tac [DECIDE ``!x. ~(x < x)``, FACT, DIVIDES_RMUL, DIVIDES_REFL] \end{verbatim} \end{hol} \noindent -The result is that there will be three subgoals emerging from the -\ml{THENL}: the two sub-cases in the base case and the unaltered step -case. Each is proved with a call to \ml{METIS\_TAC}. Are we now done? -Not necessarily. For example, the explicit case split, namely \ml{Cases\_on `m`}, -can be replaced by providing the \emph{cases} theorem for natural numbers -(\ml{num\_CASES}) to \ml{METIS\_TAC}. With this, the case split on $m$ will be -automatically generated by \ml{METIS\_TAC} as it searches for the proof. Hence we -can shorten the tactic again. +The result is that there will be three subgoals emerging from the \ml{THENL}: the two sub-cases in the base case and the unaltered step case. +Each is proved with a call to \ml{metis\_tac}. +Are we now done? +Not necessarily. +For example, the explicit case split, namely \ml{Cases\_on `m`}, can be replaced by providing the \emph{cases} theorem for natural numbers (\ml{num\_CASES}) to \ml{metis\_tac}. +With this, the case split on $m$ will be automatically generated by \ml{metis\_tac} as it searches for the proof. +Hence we can shorten the tactic again. \begin{session} -\begin{verbatim} -- num_CASES; -> val it = |- !m. (m = 0) \/ ?n. m = SUC n : thm - -- restart(); -- e (RW_TAC arith_ss [LESS_EQ_EXISTS] - THEN Induct_on `p` - THEN METIS_TAC [DECIDE ``!x. ~(x < x)``, FACT, num_CASES, - DIVIDES_RMUL, DIVIDES_LMUL, DIVIDES_REFL, ADD_CLAUSES]); -\end{verbatim} +\begin{alltt} +>> num_CASES; + +>>_ restart(); +>> e (lrw[LESS_EQ_EXISTS] >> + qcase_tac `m divides FACT (m + q)` >> + Induct_on `q` >> + metis_tac [DECIDE ``!x. ~(x < x)``, FACT, num_CASES, + DIVIDES_RMUL, DIVIDES_LMUL, DIVIDES_REFL, ADD_CLAUSES]); +##assert can top_thm () +\end{alltt} \end{session} We have now finished our exercise in tactic revision. Certainly, it would be hard to foresee that this final tactic would prove the -goal; the required lemmas for the final invocation of \ml{METIS\_TAC} +goal; the required lemmas for the final invocation of \ml{metis\_tac} have been found by an incremental process of revision. \subsection{Divisibility and factorial (again!)} @@ -653,83 +657,32 @@ really by induction on $n - m$. Can we express this directly? The answer is a qualified yes: the induction can be naturally stated, but it leads to somewhat less natural goals. \begin{session} -\begin{verbatim} -- restart(); - -- e (Induct_on `n - m`); - -OK.. -2 subgoals: -> val it = - !n m. (SUC v = n - m) ==> 0 < m /\ m <= n ==> m divides FACT n - ------------------------------------ - !n m. (v = n - m) ==> 0 < m /\ m <= n ==> m divides FACT n - - !n m. (0 = n - m) ==> 0 < m /\ m <= n ==> m divides FACT n -\end{verbatim} +\begin{alltt} +>>_ restart(); +>> e (Induct_on `n - m`); +\end{alltt} \end{session} - This is slighly hard to read, so we use \ml{STRIP\_TAC} and - \ml{REPEAT} to move the antecedents of the goals to the - assumptions. Use of \ml{THEN} ensures that the tactic gets applied - in both branches of the induction. +This is slighly hard to read, so we combine with a call to the simplifier to strip both arms of the proof. +Use of \ml{\gt\gt} ensures that the tactic gets applied in both branches of the induction. +(We might also use \ml{rpt~strip\_tac} if we \emph{didn't} want the simplification to happen.) \begin{session} -\begin{verbatim} -- b(); - ... - -- e (Induct_on `n - m` THEN REPEAT STRIP_TAC); - -OK.. -2 subgoals: -> val it = - m divides FACT n - ------------------------------------ - 0. !n m. (v = n - m) ==> 0 < m /\ m <= n ==> m divides FACT n - 1. SUC v = n - m - 2. 0 < m - 3. m <= n - - m divides FACT n - ------------------------------------ - 0. 0 = n - m - 1. 0 < m - 2. m <= n -\end{verbatim} +\begin{alltt} +>>_ b(); +>> e (Induct_on `n - m` >> lrw[]); +\end{alltt} \end{session} -Looking at the first goal, we reason that if $0 = n - m$ and $m -\leq n$, then $m = n$. We can prove this fact, using \ml{DECIDE\_TAC}\footnote -{\ml{DECIDE\_TAC} is a decision procedure for a useful class of arithmetical formulas.} -and add it to the hypotheses by use of the infix operator ``\ml{by}'': +Looking at the first goal, we reason that if $0 = n - m$ and $m \leq n$, then $m = n$. We can prove this fact, using \ml{lrw} and add it to the hypotheses by use of the infix operator ``\ml{by}'': \begin{session} -\begin{verbatim} -- e (`m = n` by DECIDE_TAC); -OK.. -1 subgoal: -> val it = - m divides FACT n - ------------------------------------ - 0. 0 = n - m - 1. 0 < m - 2. m <= n - 3. m = n -\end{verbatim} +\begin{alltt} +>> e (`m = n` by lrw[]); +\end{alltt} \end{session} -\noindent We can now use \ml{RW\_TAC} to propagate the newly derived equality -throughout the goal. +\noindent We can now use simplification again to propagate the newly derived equality throughout the goal. \begin{session} -\begin{verbatim} -- e (RW_TAC arith_ss []); - -OK.. -1 subgoal: -> val it = - m divides FACT m - ------------------------------------ - 0. 0 = m - m - 1. 0 < m - 2. m <= m -\end{verbatim} +\begin{alltt} +>> e (lrw[]); +\end{alltt} \end{session} At this point in the previous proof we did a case analysis on $m$. However, we already have the hypothesis that $m$ is positive @@ -739,9 +692,13 @@ OK.. \[ \mbox{\ml{`?k. m = SUC k` by }} \] -But what is the tactic? If we try \ml{DECIDE\_TAC}, it will fail since -it doesn't handle existential statements. An application of -\ml{RW\_TAC} will also prove to be unsatisfactory. What to do? +But what is the tactic? +If we try \ml{lrw}, it will fail since the embedded arithmetic decision procedure doesn't handle existential statements very well. +What to do? + +In fact, that earlier case analysis will again do the job: but now we hide it away so that it is only used to prove this sub-goal. +When we execute \ml{Cases\_on `m`}, we will get a case where \holtxt{m} has been substituted out for \holtxt{0}. +This case will be contradictory given that we already have an assumption \holtxt{0~$<$~m}. When such situations occur, it is often best to start a new proof for the required lemma. This can be done simply by invoking ``\ml{g}'' From d5ffbeb658f13bda8c4e3c7e5e80f363f1232402 Mon Sep 17 00:00:00 2001 From: Magnus Myreen Date: Tue, 19 Jan 2016 11:41:03 +1100 Subject: [PATCH 647/718] HOL interaction guide updated --- Manual/Interaction/HOL-interaction.tex | 37 +++++++++++++------------- 1 file changed, 18 insertions(+), 19 deletions(-) diff --git a/Manual/Interaction/HOL-interaction.tex b/Manual/Interaction/HOL-interaction.tex index 7f1b75493d..1e0b4b969a 100644 --- a/Manual/Interaction/HOL-interaction.tex +++ b/Manual/Interaction/HOL-interaction.tex @@ -1,6 +1,7 @@ \documentclass[a4paper,10pt]{article} \usepackage{alltt} +\usepackage{url} \addtolength{\voffset}{-1em} \addtolength{\textheight}{-2em} @@ -41,7 +42,7 @@ \item[~] Section \ref{tactics}:~~Common proof tactics \item[~] Section \ref{reading}:~~Further reading and general advice \end{enum} -The text assumes that the reader has HOL4 installed from: {\tt\small http://hol.sf.net/}. +The text assumes that the reader has HOL4 installed. You can download and install HOL4 following the instructions on \url{http://hol-theorem-prover.org}. \mysec{Interaction with HOL4 (via emacs or xemacs)\label{interaction}} @@ -64,21 +65,18 @@ \begin{enum} \item Start emacs. \item Press {\tt C-x C-f} to open a file for your proof script. -\item Press {\tt C-x 3} to split the emacs window into two columns. -\item Press {\tt M-h h} to start HOL4. -\item Press {\tt C-x o} to move cursor to the other window (where we type). +\item Press {\tt C-h 3} to split the emacs window into two columns and start HOL4. \end{enum} The HOL window should look something like this: \begin{code} ------------------------------------------------------------------ - HOL-4 [Kananaskis 5 (built Thu Feb 21 08:37:11 2008)] +--------------------------------------------------------------------- + HOL-4 [Kananaskis 11 (stdknl, built Fri Jan 15 10:58:28 2016)] For introductory HOL help, type: help "hol"; ------------------------------------------------------------------ - -[loading theories and proof tools ............. ] -[closing file "/local/scratch/user/HOL/tools/end-init-boss.sml"] -- + To exit type -D +--------------------------------------------------------------------- +[Use-ing configuration file /Users/myreen/.hol-config.sml] +> > > > > \end{code} \mysubsec{Copying input into HOL4 (Opening a theory)\label{copy}} @@ -169,13 +167,14 @@ ASM_SIMP_TAC bool_ss [MULT] (* comment: simplify goal *) DECIDE_TAC (* comment: solve step case *) \end{code} -Tactics can be pieced together for {\tt prove} using {\tt THEN} and {\tt THENL}: +Tactics can be pieced together for {\tt prove} using {\tt THEN} and {\tt THEN1}. {\tt THEN} is an infix that composes tactics. {\tt THEN1} \emph{tac} proves the first subgoal using \emph{tac}. \begin{code} -val LESS_EQ_MULT = prove({`}` !n. n <= n * n {`}`, - Induct_on `n` THENL [ - DECIDE_TAC, - ASM_SIMP_TAC bool_ss [MULT] THEN - DECIDE_TAC]); +val LESS_EQ_MULT = prove( + {`}` !n. n <= n * n {`}`, + Induct_on `n` + THEN1 DECIDE_TAC + THEN1 (ASM_SIMP_TAC bool_ss [MULT] + THEN DECIDE_TAC])); \end{code} Copy the above into HOL4 using {\tt C-space} then {\tt M-h M-r}, as in Section~\ref{copy}. @@ -221,7 +220,7 @@ Data-types are defined using {\tt Hol\_datatype}, \eg{} a binary tree which holds values of type {\tt 'a} (a type variable) at the leaves: \begin{code} -val _ = Hol_datatype `TREE = LEAF of 'a | BRANCH of TREE => TREE`; +val _ = Datatype `TREE = LEAF 'a | BRANCH TREE TREE`; \end{code} \noindent @@ -247,7 +246,7 @@ can store the definitions from above in a file called {\tt mytreeScript.sml}, which should begin with the lines \begin{code} -open HolKernel boolLib bossLib Parse; +open HolKernel boolLib bossLib Parse lcsymtacs; val _ = new_theory "mytree"; \end{code} and end with the line From 7dac633bb5688531e5c42039a959ccd226a5b45d Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 27 Jan 2016 10:02:12 +1100 Subject: [PATCH 648/718] Updates to Interaction guide for release E.g.: - update a URL - prefer lcsymtacs versions of tactics (as per #275) --- Manual/Interaction/HOL-interaction.tex | 57 ++++++++++++-------------- 1 file changed, 27 insertions(+), 30 deletions(-) diff --git a/Manual/Interaction/HOL-interaction.tex b/Manual/Interaction/HOL-interaction.tex index 1e0b4b969a..586f7dc1c9 100644 --- a/Manual/Interaction/HOL-interaction.tex +++ b/Manual/Interaction/HOL-interaction.tex @@ -7,6 +7,7 @@ \addtolength{\textheight}{-2em} \addtolength{\textwidth}{0.5em} \setlength{\arraycolsep}{0.1em} +\input{../LaTeX/commands} \begin{document} @@ -17,16 +18,12 @@ \maketitle -\newcommand{\etal}{{et al$.$}} -\newcommand{\eg}{{e$.$g$.$}} -\newcommand{\ie}{{i$.$e$.$}} - \newenvironment{code}{\begin{quote}\begin{alltt}\small}{\end{alltt}\end{quote}} \newenvironment{enum}{\begin{enumerate} \setlength{\itemsep}{-\parsep} }{\end{enumerate}} -\newcommand{\conj}{\(\begin{array}{c}\texttt{\bf\scriptsize/\textbackslash}\\[0.18em]\end{array}\)} +\renewcommand{\conj}{\(\begin{array}{c}\texttt{\bf\scriptsize/\textbackslash}\\[0.18em]\end{array}\)} \newcommand{\mysec}[1]{\section{\large #1}} \newcommand{\mysubsec}[1]{\subsection{\normalsize#1}} @@ -121,7 +118,7 @@ Make progress in a proof using \emph{proof tactics}. \begin{enum} -\item Write the name of a tactic, \eg{} {\tt DECIDE\_TAC},~see Section~\ref{tactics} for more tactics +\item Write the name of a tactic, \eg{} {\tt decide\_tac},~see Section~\ref{tactics} for more tactics \item Press {\tt C-space} at one end of the text. \item Move the cursor to the other end of the text. \item Press {\tt M-h e} to apply the tactic. @@ -148,7 +145,7 @@ \emph{theorem}), \eg{} the following stores the theorem $\forall n.\;n < n + 1$ in an ML variable {\tt LESS\_ADD\_1}: \begin{code} -val LESS_ADD_1 = prove({`}` !n. n < n + 1 {`}`,DECIDE_TAC); +val LESS_ADD_1 = prove({`}` !n. n < n + 1 {`}`,decide_tac); \end{code} When the above line is copied into HOL4 (using {\tt C-space} then {\tt M-h M-r}, as described in Section~\ref{copy}), HOL4 responds with: @@ -162,19 +159,19 @@ \begin{code} Induct_on `n` (* comment: induction on n *) - DECIDE_TAC (* comment: solve base case *) + decide_tac (* comment: solve base case *) ASM_SIMP_TAC bool_ss [MULT] (* comment: simplify goal *) - DECIDE_TAC (* comment: solve step case *) + decide_tac (* comment: solve step case *) \end{code} -Tactics can be pieced together for {\tt prove} using {\tt THEN} and {\tt THEN1}. {\tt THEN} is an infix that composes tactics. {\tt THEN1} \emph{tac} proves the first subgoal using \emph{tac}. +Tactics can be pieced together for {\tt prove} using \ml{\gt\gt} and \ml{\gt-}. The \ml{\gt\gt} operator is an infix that composes tactics. Similarly, \ml{\gt-} \emph{tac} proves the first subgoal using \emph{tac}. \begin{code} val LESS_EQ_MULT = prove( - {`}` !n. n <= n * n {`}`, + `{`} !n. n <= n * n `{`}, Induct_on `n` - THEN1 DECIDE_TAC - THEN1 (ASM_SIMP_TAC bool_ss [MULT] - THEN DECIDE_TAC])); + >- decide_tac + >- (ASM_SIMP_TAC bool_ss [MULT] + >> decide_tac])); \end{code} Copy the above into HOL4 using {\tt C-space} then {\tt M-h M-r}, as in Section~\ref{copy}. @@ -207,7 +204,7 @@ \mysubsec{Interrupting HOL4} Press {\tt M-h C-c} to interrupt HOL4 --- useful when a tactic fails to terminate -(\eg{} {\tt\small METIS\_TAC} often fails to terminate when unsuccessfully applied). +(\eg{} {\tt\small metis\_tac} often fails to terminate when unsuccessfully applied). \mysubsec{Making a definition\label{definition}} @@ -217,7 +214,7 @@ \end{code} \noindent -Data-types are defined using {\tt Hol\_datatype}, \eg{} a binary tree +Data-types are defined using {\tt Datatype}, \eg{} a binary tree which holds values of type {\tt 'a} (a type variable) at the leaves: \begin{code} val _ = Datatype `TREE = LEAF 'a | BRANCH TREE TREE`; @@ -246,7 +243,7 @@ can store the definitions from above in a file called {\tt mytreeScript.sml}, which should begin with the lines \begin{code} -open HolKernel boolLib bossLib Parse lcsymtacs; +open HolKernel boolLib bossLib Parse val _ = new_theory "mytree"; \end{code} and end with the line @@ -256,7 +253,7 @@ Replace {\tt prove} by {\tt store\_thm} for results you wish to export from the theory, \eg{} \begin{code} -val LESS_ADD_1 = store_thm("LESS_ADD_1",{`}`!n.n !m p n. (m MOD k * p + n) MOD k = (m * p + n) MOD k \end{code} \noindent -{\tt\small DECIDE\_TAC} handles linear arithmetic over natural -numbers, \eg{} {\tt\small DECIDE\_TAC} solves: +{\tt\small decide\_tac} handles linear arithmetic over natural +numbers, \eg{} {\tt\small decide\_tac} solves: \begin{code} !m n k. m < n \conj{} n < m+k \conj{} k <= 3 \conj{} ~(n = m+1) ==> (n = m+2) \end{code} @@ -454,11 +451,11 @@ ------------------------------------ 0 < n \end{code} -If {\tt\small `h n = g n`} can be proved in one step, \eg{} using {\tt\small METIS\_TAC [MY\_LEMMA]}, then -apply {\tt\small `h n = g n` by METIS\_TAC [MY\_LEMMA]} instead of +If {\tt\small `h n = g n`} can be proved in one step, \eg{} using {\tt\small metis\_tac [MY\_LEMMA]}, then +apply {\tt\small `h n = g n` by metis\_tac [MY\_LEMMA]} instead of {\tt\small `h n = g n` by ALL\_TAC}. If the sub-goal requires multiple steps the tactic after the \texttt{by} will need to be -parenthesised: {\tt\small`\textit{goal}` by ($\mathit{tac}_1$ THEN +parenthesised: {\tt\small`\textit{goal}` by ($\mathit{tac}_1$ \ml{\gt\gt} $\mathit{tac}_2$ ...)} \mysubsec{Proof by contradiction} @@ -494,10 +491,10 @@ One can only learn HOL4 via examples, so try proving something. Example problems and solutions are presented in the \emph{HOL Tutorial}, available under: -\begin{code} -http://hol.sf.net/documentation.html -\end{code} -The same page also contains: +\begin{center} +\url{http://hol-theorem-prover.org/#doc} +\end{center} +The same page also contains links to: \begin{enum} \item[~]\emph{HOL Description} -- a description of the HOL4 system \item[~]\emph{HOL Reference} -- a detailed descriptions of proof tactics and other tools From 4362bc5a5becf0cff41c694e07feb535958c1d66 Mon Sep 17 00:00:00 2001 From: Ramana Kumar Date: Wed, 27 Jan 2016 10:16:14 +1100 Subject: [PATCH 649/718] URL tweaks: https --- Manual/Interaction/HOL-interaction.tex | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Manual/Interaction/HOL-interaction.tex b/Manual/Interaction/HOL-interaction.tex index 586f7dc1c9..305f84333e 100644 --- a/Manual/Interaction/HOL-interaction.tex +++ b/Manual/Interaction/HOL-interaction.tex @@ -39,7 +39,7 @@ \item[~] Section \ref{tactics}:~~Common proof tactics \item[~] Section \ref{reading}:~~Further reading and general advice \end{enum} -The text assumes that the reader has HOL4 installed. You can download and install HOL4 following the instructions on \url{http://hol-theorem-prover.org}. +The text assumes that the reader has HOL4 installed. You can download and install HOL4 following the instructions on \url{https://hol-theorem-prover.org}. \mysec{Interaction with HOL4 (via emacs or xemacs)\label{interaction}} @@ -492,7 +492,7 @@ Example problems and solutions are presented in the \emph{HOL Tutorial}, available under: \begin{center} -\url{http://hol-theorem-prover.org/#doc} +\url{https://hol-theorem-prover.org/#doc} \end{center} The same page also contains links to: \begin{enum} From 67d4de130162dcc0b5a2b67f4f756fe26c7a1acc Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 27 Jan 2016 16:06:47 +1100 Subject: [PATCH 650/718] Fix balanced_map theory to build with new lc simp --- examples/balanced_bst/balanced_mapScript.sml | 51 ++++++++++---------- 1 file changed, 26 insertions(+), 25 deletions(-) diff --git a/examples/balanced_bst/balanced_mapScript.sml b/examples/balanced_bst/balanced_mapScript.sml index e630909af7..75be0bd656 100644 --- a/examples/balanced_bst/balanced_mapScript.sml +++ b/examples/balanced_bst/balanced_mapScript.sml @@ -19,7 +19,7 @@ val list_rel_lem1 = Q.prove ( ((n = LENGTH l ∧ n ≠ LENGTH l') ∨ (n ≠ LENGTH l ∧ n = LENGTH l') ∨ (n ≠ LENGTH l ∧ n ≠ LENGTH l' ∧ ~f (EL n l) (EL n l')))`, - rw [] >> + srw_tac[][] >> `FINITE { n | n ≤ LENGTH l ∧ n ≤ LENGTH l' ∧ LIST_REL f (TAKE n l) (TAKE n l') }` by (rw [GSPEC_AND, LE_LT1] >> match_mp_tac FINITE_INTER >> @@ -27,30 +27,31 @@ val list_rel_lem1 = Q.prove ( rw [GSYM count_def]) >> qabbrev_tac `nset = { n | n ≤ LENGTH l ∧ n ≤ LENGTH l' ∧ LIST_REL f (TAKE n l) (TAKE n l') }` >> Cases_on `nset = {}` >> - rw [] - >- (fs [markerTheory.Abbrev_def, EXTENSION] >> + srw_tac[] [] + >- (full_simp_tac (srw_ss()) [markerTheory.Abbrev_def, EXTENSION] >> qexists_tac `0` >> - rw [] >> + srw_tac[][] >> Cases_on `l` >> Cases_on `l'` >> - fs [] >> + full_simp_tac (srw_ss()) [] >> pop_assum (qspecl_then [`0`] mp_tac) >> - rw []) + srw_tac[][]) >- (imp_res_tac MAX_SET_DEF >> qexists_tac `MAX_SET nset` >> qabbrev_tac `max_nset = MAX_SET nset` >> qunabbrev_tac `nset` >> imp_res_tac in_max_set >> - rfs [] >> - rw [] >> - fs [LESS_OR_EQ] >> + REV_FULL_SIMP_TAC (srw_ss()) [] >> + srw_tac[] [] >> + full_simp_tac (srw_ss()) [LESS_OR_EQ] >> srw_tac [ARITH_ss] [] >> - fs [TAKE_LENGTH_ID] >> + full_simp_tac (srw_ss()) [TAKE_LENGTH_ID] >> CCONTR_TAC >> - fs [] >> + full_simp_tac (srw_ss()) [] >> `LIST_REL f (TAKE (max_nset + 1) l) (TAKE (max_nset + 1) l')` - by (fs [rich_listTheory.TAKE_EL_SNOC, SNOC_APPEND, - rich_listTheory.LIST_REL_APPEND_SING]) >> + by (full_simp_tac (srw_ss()) + [rich_listTheory.TAKE_EL_SNOC, SNOC_APPEND, + rich_listTheory.LIST_REL_APPEND_SING]) >> `max_nset + 1 ∈ {n | (n < LENGTH l ∨ n = LENGTH l) ∧ (n < LENGTH l' ∨ n = LENGTH l') ∧ LIST_REL f (TAKE n l) (TAKE n l')}` by srw_tac [ARITH_ss] [] >> imp_res_tac in_max_set >> @@ -66,28 +67,28 @@ val list_rel_lem2 = Q.prove ( (n ≠ LENGTH l ∧ n = LENGTH l') ∨ (n ≠ LENGTH l ∧ n ≠ LENGTH l' ∧ ~f (EL n l) (EL n l')))`, ho_match_mp_tac LIST_REL_ind >> - rw [] >> + srw_tac[] [] >> CCONTR_TAC >> - fs [] >> + full_simp_tac (srw_ss()) [] >> EVERY_CASE_TAC >> - fs [] >> - rw [] + full_simp_tac (srw_ss()) [] >> + srw_tac[] [] >- (first_x_assum (qspecl_then [`LENGTH l`] mp_tac) >> - rw []) + srw_tac[] []) >- (first_x_assum (qspecl_then [`LENGTH l'`] mp_tac) >> - rw []) + srw_tac[] []) >- (first_x_assum (qspecl_then [`n-1`] mp_tac) >> - rw [] >> - full_simp_tac (srw_ss()++ARITH_ss) [] >> - fs [LIST_REL_EL_EQN] >> + srw_tac[] [] >> + fs[] >> + full_simp_tac (srw_ss()) [LIST_REL_EL_EQN] >> `n - 1 ≤ LENGTH l ∧ n - 1 ≤ LENGTH l'` by decide_tac >> `n ≤ LENGTH l ∧ n ≤ LENGTH l'` by decide_tac >> - fs [LENGTH_TAKE, rich_listTheory.EL_TAKE] >> - rw [] >> + full_simp_tac (srw_ss()) [LENGTH_TAKE, rich_listTheory.EL_TAKE] >> + srw_tac[] [] >> `0 < n` by decide_tac >> full_simp_tac (srw_ss()++ARITH_ss) [rich_listTheory.EL_CONS] >> `PRE n = n - 1` by decide_tac >> - fs [])); + full_simp_tac (srw_ss()) [])); val list_rel_thm = Q.prove ( `!f l l'. From a0e8eafb998d74129cd671d0706dec94e7a03e31 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 27 Jan 2016 10:28:53 +1100 Subject: [PATCH 651/718] Update Moscow ML homepage footnote URL --- Manual/Tutorial/ml.stex | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/Manual/Tutorial/ml.stex b/Manual/Tutorial/ml.stex index ee20729d2a..8026ead330 100644 --- a/Manual/Tutorial/ml.stex +++ b/Manual/Tutorial/ml.stex @@ -3,12 +3,11 @@ This chapter is a brief introduction to the meta-language \ML. The aim is just to give a feel for what it is like to interact with the -language. A more detailed introduction can be found in numerous -textbooks and web-pages; see for example the list of resources on the -MoscowML -home-page\footnote{\url{http://www.dina.kvl.dk/~sestoft/mosml.html}}, -or the \texttt{comp.lang.ml} -FAQ\footnote{\url{http://www.faqs.org/faqs/meta-lang-faq/}}. +language. +A more detailed introduction can be found in numerous textbooks and web-pages; see for example the list of resources on the MoscowML home-page% +\footnote{\url{http://mosml.org}}% +, or the \texttt{comp.lang.ml} FAQ.% +\footnote{\url{http://www.faqs.org/faqs/meta-lang-faq/}} \section{How to interact with ML} From eaa9e36beaf263dd333e40962421207b37c581f7 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 27 Jan 2016 10:33:11 +1100 Subject: [PATCH 652/718] Some more "modern" polishing of parity example --- Manual/Tutorial/parity.stex | 200 ++++++++++-------------------------- 1 file changed, 52 insertions(+), 148 deletions(-) diff --git a/Manual/Tutorial/parity.stex b/Manual/Tutorial/parity.stex index 069abfe6a5..024c34e048 100644 --- a/Manual/Tutorial/parity.stex +++ b/Manual/Tutorial/parity.stex @@ -389,26 +389,17 @@ checker follows from this and {\small\verb|UNIQUENESS_LEMMA|} by the transitivity of {\small{\tt\verb+==>+}}. \begin{session} -\begin{verbatim} -- g `!inp out. +\begin{alltt} +>> g `!inp out. PARITY_IMP(inp,out) ==> (out 0 = T) /\ !t. out(SUC t) = if inp(SUC t) then ~(out t) else out t`; -> val it = - Proof manager status: 2 proofs. - 2. Completed: ... - 1. Incomplete: - Initial goal: - !inp out. - PARITY_IMP (inp,out) ==> - (out 0 = T) /\ - !t. out (SUC t) = (if inp (SUC t) then ~out t else out t) -\end{verbatim} +\end{alltt} \end{session} The first step in proving this goal is to rewrite with definitions followed by a decomposition of the resulting goal using -{\small\verb|STRIP_TAC|}. The rewriting tactic +{\small\verb|strip_tac|}. The rewriting tactic {\small\verb|PURE_REWRITE_TAC|} is used; this does no built-in simplifications, only the ones explicitly given in the list of theorems supplied as an argument. One of the built-in simplifications @@ -416,31 +407,11 @@ used by {\small\verb|REWRITE_TAC|} is {\small\tt |-~(x~=~T)~=~x}. {\small\verb|PURE_REWRITE_TAC|} is used to prevent rewriting with this being done. \begin{session} -\begin{verbatim} -- expand(PURE_REWRITE_TAC - [PARITY_IMP_def, ONE_def, NOT_def, MUX_def, REG_def] THEN - REPEAT STRIP_TAC); -OK.. -2 subgoals: -> val it = - out (SUC t) = (if inp (SUC t) then ~out t else out t) - ------------------------------------ - 0. !t. l1 t = ~l2 t - 1. !t. l3 t = (if inp t then l1 t else l2 t) - 2. !t. l2 t = (if t = 0 then F else out (t - 1)) - 3. !t. l4 t = T - 4. !t. l5 t = (if t = 0 then F else l4 (t - 1)) - 5. !t. out t = (if l5 t then l3 t else l4 t) - - out 0 = T - ------------------------------------ - 0. !t. l1 t = ~l2 t - 1. !t. l3 t = (if inp t then l1 t else l2 t) - 2. !t. l2 t = (if t = 0 then F else out (t - 1)) - 3. !t. l4 t = T - 4. !t. l5 t = (if t = 0 then F else l4 (t - 1)) - 5. !t. out t = (if l5 t then l3 t else l4 t) -\end{verbatim} +\begin{alltt} +>> expand(PURE_REWRITE_TAC + [PARITY_IMP_def, ONE_def, NOT_def, MUX_def, REG_def] >> + rpt strip_tac); +\end{alltt} \end{session} The top goal is the one printed last; its conclusion is @@ -450,28 +421,12 @@ be to expand the top goal by rewriting with the assumptions. However, if this were done the system would go into an infinite loop because the equations for {\small\verb|out|}, {\small\verb|l2|} and {\small\verb|l3|} are mutually recursive. Instead we use the -first-order reasoner {\small\verb|PROVE_TAC|} to do the work: +first-order reasoner \ml{metis\_tac} to do the work: \begin{session} -\begin{verbatim} -- expand(PROVE_TAC []); -OK.. -Meson search level: ..... - -Goal proved. - [......] |- out 0 = T - -Remaining subgoals: -> val it = - out (SUC t) = (if inp (SUC t) then ~out t else out t) - ------------------------------------ - 0. !t. l1 t = ~l2 t - 1. !t. l3 t = (if inp t then l1 t else l2 t) - 2. !t. l2 t = (if t = 0 then F else out (t - 1)) - 3. !t. l4 t = T - 4. !t. l5 t = (if t = 0 then F else l4 (t - 1)) - 5. !t. out t = (if l5 t then l3 t else l4 t) -\end{verbatim} +\begin{alltt} +>> e(metis_tac []); +\end{alltt} \end{session} The first of the two subgoals is proved. Inspecting the remaining goal it can be seen that it will be solved if its left hand side, @@ -484,35 +439,19 @@ goal it can be seen that it will be solved if its left hand side, \end{hol} - However, if this assumption is used for rewriting, then all the - subterms of the form {\small\verb|out t|} will also be expanded. - To prevent this, we really want to rewrite with a formula that is - specifically about {\small\verb|out (SUC t)|}. We want to somehow - pull the assumption that we do have out of the list and rewrite - with a specialised version of it. We can do just this using - {\small\verb|PAT_ASSUM|}. This tactic is of type \ml{term -> thm - -> tactic}. It selects an assumption that is of the form given - by its term argument, and passes it to the second argument, a - function which expects a theorem and returns a tactic. Here it is - in action: +However, if this assumption is used for rewriting, then all the subterms of the form {\small\verb|out t|} will also be expanded. +To prevent this, we really want to rewrite with a formula that is specifically about {\small\verb|out (SUC t)|}. +We want to somehow pull the assumption that we do have out of the list and rewrite with a specialised version of it. +We can do just this using \ml{qpat\_assum}. +This tactic is of type \ml{term quotation~->~thm~->~tactic}. +It selects an assumption that is of the form given by its first argument, and passes it to the second argument, a function which expects a theorem and returns a tactic. +Here it is in action: \begin{session} -\begin{verbatim} -- e (PAT_ASSUM ``!t. out t = X t`` +\begin{alltt} +>> e (qpat_assum `!t. out t = X t` (fn th => REWRITE_TAC [SPEC ``SUC t`` th])); -<> -OK.. -1 subgoal: -> val it = - (if l5 (SUC t) then l3 (SUC t) else l4 (SUC t)) = - (if inp (SUC t) then ~out t else out t) - ------------------------------------ - 0. !t. l1 t = ~l2 t - 1. !t. l3 t = (if inp t then l1 t else l2 t) - 2. !t. l2 t = (if t = 0 then F else out (t - 1)) - 3. !t. l4 t = T - 4. !t. l5 t = (if t = 0 then F else l4 (t - 1)) -\end{verbatim} +\end{alltt} \end{session} The pattern used here exploited something called \emph{higher order matching}. The actual assumption that was taken off the assumption @@ -522,45 +461,22 @@ could nonetheless be seen as equal to the application of \emph{some} function to the \ml{t} parameter. In fact, the value that matched \ml{X} was {\small\verb|``\x. if l5 x then l3 x else l4 x``|}. -Inspecting the goal above, it can be seen that the next step is to -unwind the equations for the remaining lines of the circuit. We do -this using the \ml{arith\_ss} simpset that comes with \ml{bossLib} to -help with the arithmetic embodied by the subtractions and \ml{SUC} -terms. +Inspecting the goal above, it can be seen that the next step is to unwind the equations for the remaining lines of the circuit. +We do using the standard simplifier \ml{lrw}. \begin{session} -\begin{verbatim} -- e (RW_TAC arith_ss []); -OK.. - -Goal proved. - [.....] -|- (if l5 (SUC t) then l3 (SUC t) else l4 (SUC t)) = - (if inp (SUC t) then ~out t else out t) - -Goal proved. - [......] |- out (SUC t) = (if inp (SUC t) then ~out t else out t) -> val it = - Initial goal proved. - |- !inp out. - PARITY_IMP (inp,out) ==> - (out 0 = T) /\ - !t. out (SUC t) = (if inp (SUC t) then ~out t else out t) -\end{verbatim} +\begin{alltt} +>> e (lrw[]); +\end{alltt} \end{session} \noindent The theorem just proved is named {\small\verb|PARITY_LEMMA|} and saved in the current theory. \begin{session} -\begin{verbatim} -- val PARITY_LEMMA = top_thm (); -> val PARITY_LEMMA = - |- !inp out. - PARITY_IMP (inp,out) ==> - (out 0 = T) /\ - !t. out (SUC t) = (if inp (SUC t) then ~out t else out t) -\end{verbatim} +\begin{alltt} +>> val PARITY_LEMMA = top_thm (); +\end{alltt} \end{session} {\small\verb|PARITY_LEMMA|} could have been proved in one step with a @@ -569,42 +485,30 @@ single tactic corresponding to the sequence of tactics that were used interactively: \begin{session} -\begin{verbatim} -- restart() -> ... -- e (PURE_REWRITE_TAC [PARITY_IMP_def, ONE_def, NOT_def, - MUX_def, REG_def] THEN - REPEAT STRIP_TAC THENL [ - PROVE_TAC [], - PAT_ASSUM ``!t. out t = X t`` - (fn th => REWRITE_TAC [SPEC ``SUC t`` th]) THEN - RW_TAC arith_ss [] +\begin{alltt} +>>_ restart(); +>> e (PURE_REWRITE_TAC [PARITY_IMP_def, ONE_def, NOT_def, + MUX_def, REG_def] >> + rpt strip_tac >| [ + metis_tac [], + qpat_assum `!t. out t = X t` + (fn th => REWRITE_TAC [SPEC ``SUC t`` th]) >> + lrw[] ]); -<> -OK.. -Meson search level: ..... -> val it = - Initial goal proved. - |- !inp out. - PARITY_IMP (inp,out) ==> - (out 0 = T) /\ - !t. out (SUC t) = (if inp (SUC t) then ~out t else out t) -\end{verbatim} +\end{alltt} \end{session} Armed with {\small\verb|PARITY_LEMMA|}, the final theorem is easily -proved. This will be done in one step using the \ML{} function -{\small\verb|prove|}. +proved. +This will be done in one step using the \ML{} function \ml{prove}. \begin{session} -\begin{verbatim} -- val PARITY_CORRECT = prove( - ``!inp out. PARITY_IMP(inp,out) ==> (!t. out t = PARITY t inp)``, - REPEAT STRIP_TAC THEN MATCH_MP_TAC UNIQUENESS_LEMMA THEN - MATCH_MP_TAC PARITY_LEMMA THEN ASM_REWRITE_TAC []); -> val PARITY_CORRECT = - |- !inp out. PARITY_IMP (inp,out) ==> !t. out t = PARITY t inp -\end{verbatim} +\begin{alltt} +>> val PARITY_CORRECT = prove( + ``!inp out. PARITY_IMP(inp,out) ==> (!t. out t = PARITY t inp)``, + rpt strip_tac >> irule UNIQUENESS_LEMMA >> + irule PARITY_LEMMA >> lrw[]); +\end{alltt} \end{session} \noindent This completes the proof of the @@ -639,9 +543,9 @@ This is formalized in \HOL{} by the definition: \begin{hol} \begin{verbatim} - RESET_REG(reset,inp,out) = - (!t. reset t ==> (out t = T)) /\ - (!t. out(t+1) = if reset t \/ reset(t+1) then T else inp t) + RESET_REG(reset,inp,out) <=> + (!t. reset t ==> (out t = T)) /\ + (!t. out(t+1) = if reset t \/ reset(t+1) then T else inp t) \end{verbatim} \end{hol} From 4d4bed7cc7ac6f747cb32de25963cc049403395a Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 27 Jan 2016 16:37:51 +1100 Subject: [PATCH 653/718] Yet another directive form for the polyscripter --- Manual/Tools/README | 10 ++++++++++ Manual/Tools/expected1 | 11 +++++++++++ Manual/Tools/polyscripter.sml | 27 +++++++++++++++++++++++++++ Manual/Tools/testinput1 | 10 ++++++++++ 4 files changed, 58 insertions(+) diff --git a/Manual/Tools/README b/Manual/Tools/README index 82c22fb1e2..42084d58b0 100644 --- a/Manual/Tools/README +++ b/Manual/Tools/README @@ -18,6 +18,16 @@ All of the following inline commands must be the first non-whitespace on the lin - The `##assert` command gets the compiler to evaluate the following expression (which can just be one line long). If it evaluates to true, then nothing is output. If it is false, then the scripter aborts. +- The `##eval` command gets the compiler to evaluate the following code (similarly to the various `>>` commands). + The output is *not* printed, and the input is printed without a prompt symbol (the `>`). + The command may be followed by a name in square brackets. + This can allow further assertion checking on an expression that has been shown to the user. + For example + + ##eval[n] 3 + 4; + ##assert (equal n) 7; + + will print `3 + 4` in the document and also silently check that it really does evaluate to 7. If the first non-whitespace characters are `>>>` or `###` then the first of these characters is dropped, and the rest of the line is passed unchanged. This allows for a form of escaping, just in case the input naturally wants to include `>>` or `##` at the start of a line. diff --git a/Manual/Tools/expected1 b/Manual/Tools/expected1 index 22fd3a4e30..99a43e257b 100644 --- a/Manual/Tools/expected1 +++ b/Manual/Tools/expected1 @@ -75,3 +75,14 @@ bar > 3 div 0; Exception- Div raised + +Term`p /\bs{} q ==> + r` + +> t; +val it = ``p \(\land\) q \(\Rightarrow\) r``: term + +Term`p /\bs{} q ==> + r`; + + 3 + 4; diff --git a/Manual/Tools/polyscripter.sml b/Manual/Tools/polyscripter.sml index 40a178ad1d..6768b17c15 100644 --- a/Manual/Tools/polyscripter.sml +++ b/Manual/Tools/polyscripter.sml @@ -216,6 +216,33 @@ in in ("\n", NONE) end + else if String.isPrefix "##eval" line then + let + val line = String.extract(line, 6, NONE) + val e = Fail "" + val (inputpfx, firstline, indent) = + if String.isPrefix "[" line then + let + val ss = Substring.full line + val (p,s) = Substring.position "] " ss + val _ = Substring.size s <> 0 orelse + lnumdie (linenum lbuf) "Mal-formed ##eval directive" e + val vname = String.extract(Substring.string p, 1, NONE) + val firstline = String.extract(Substring.string s, 2, NONE) + in + ("val "^vname^" = ", firstline, 9 + size vname) + end + else + ("", String.extract(line, 1, NONE), 7) + handle Subcript => + lnumdie (linenum lbuf) "Mal-formed ##eval directive" e + val input = getRest (indent + 1) [firstline] + val _ = compiler obuf + (lnumdie (linenum lbuf)) + (mkLex (quote (inputpfx ^ input))) + in + (ws ^ umunge umap input, NONE) + end else if String.isPrefix "##use " line then let val fname = String.substring(line, 6, size line - 7) (* for \n at end *) diff --git a/Manual/Tools/testinput1 b/Manual/Tools/testinput1 index 9cf71cff8d..a27f85bb43 100644 --- a/Manual/Tools/testinput1 +++ b/Manual/Tools/testinput1 @@ -39,3 +39,13 @@ bar >>- "input elided"; >>+ 3 div 0; + +##eval[t] Term`p /\ q ==> + r` + +>> t; + +##eval Term`p /\ q ==> + r`; + + ##eval 3 + 4; From b46df37d54bcc8ee82b94973159d8e569d4825d2 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 27 Jan 2016 16:55:43 +1100 Subject: [PATCH 654/718] Remove use of parser in a library. Parsing ``0`` when the integers were in scope led to parse problems and a failure for the Arith library to load. This was an issue with Moscow ML only. --- src/num/arith/src/Sub_and_cond.sml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/num/arith/src/Sub_and_cond.sml b/src/num/arith/src/Sub_and_cond.sml index 27d2dc41ca..ff8b5eba14 100644 --- a/src/num/arith/src/Sub_and_cond.sml +++ b/src/num/arith/src/Sub_and_cond.sml @@ -95,7 +95,7 @@ end val SUB_LEFT_EQ0 = let open arithmeticTheory in - SUB_LEFT_EQ |> SPEC ``0`` + SUB_LEFT_EQ |> SPEC numSyntax.zero_tm |> REWRITE_RULE [ADD_CLAUSES, LESS_EQ_REFL, peqn_or_nleqp] end val SUB_RIGHT_EQ0 = From 5c427ce5ac8be53ae0ab82f4a2eee758c5876697 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 27 Jan 2016 16:59:46 +1100 Subject: [PATCH 655/718] More hacking about with the Euclid example --- Manual/Tutorial/euclid.stex | 560 ++++++++++++------------------------ 1 file changed, 184 insertions(+), 376 deletions(-) diff --git a/Manual/Tutorial/euclid.stex b/Manual/Tutorial/euclid.stex index 1b390884b5..f20b90cf36 100644 --- a/Manual/Tutorial/euclid.stex +++ b/Manual/Tutorial/euclid.stex @@ -370,9 +370,9 @@ following\footnote{This and subsequent proofs use the theorems proved on page~\pageref{euclid:extra-proofs}, which were added to the \ML{} environment after being proved.}: >>__ prove(``!m n. 0 < m /\ m <= n ==> m divides (FACT n)``, - lrw[LESS_EQ_EXISTS] >> - qcase_tac `m divides FACT (m + q)` >> - Induct_on `q` >> + `!p m. 0 < m ==> m divides (FACT (m + p))` + suffices_by metis_tac[LESS_EQ_EXISTS] >> + Induct_on `p` >> lrw[FACT,ADD_CLAUSES] >| [ Cases_on `m`, ALL_TAC ] >> metis_tac [FACT, DECIDE ``!x. ~(x < x)``, @@ -411,31 +411,23 @@ variable, obtained by use of the theorem \verb+LESS_EQ_EXISTS+. \begin{session} \begin{alltt} >> LESS_EQ_EXISTS; - ->> e (lrw[LESS_EQ_EXISTS]); -\end{alltt} -\end{session} -\noindent Now we want to induct on $p$, but before doing so, we should realise that the name $p$ has been chosen by the system. -In this case, it has come from the theorem \ml{LESS\_EQ\_EXISTS}, and future changes to \HOL{} are unlikely to change this behaviour. -Nonetheless, it is generally not good practice to rely on names chosen by the system. -We can make our proof much more robust at the cost of slight wordiness by using the \ml{qcase\_tac} tactic: -\begin{session} -\begin{alltt} -> qcase_tac; -val it = fn : term quotation -> tactic \end{alltt} \end{session} -This tactic takes a \emph{quotation} as an argument corresponding to a pattern that appears somewhere within the goal, and then renames the variables in the goal to match those in the pattern. -Here we will rename to \holtxt{q} just to illustrate how we can choose whichever variables we like: +\noindent Now we want to induct on the $p$ that our theorem says exists. +This effectively requires to prove a slight restatement of the theorem. +We might prove the restatement as a separate lemma, but it is probably just as easy to do this inline with the (infix) \ml{suffices\_by} tactic: \begin{session} \begin{alltt} ->> e (qcase_tac `m divides FACT (m + q)`) +>> e (`!m p. 0 < m ==> m divides FACT(m + p)` + suffices_by metis_tac[LESS_EQ_EXISTS]); \end{alltt} \end{session} -And now we can perform the induction: +The tactic that we provide after the \ml{suffices\_by} checks that the first argument does indeed imply the original goal. +If that tactic succeeds (as it does here), we have a new goal to prove. +Now we can perform the induction: \begin{session} \begin{alltt} ->> e (Induct_on `q`); +>> e (Induct_on `p`); \end{alltt} \end{session} \noindent We now have two sub-goals to prove: a base case and a step case. @@ -478,10 +470,8 @@ This can be done with the \ml{fs} tactic: \end{alltt} \end{session} - - Using the theorems identified above the remaining sub-goal can -be proved with \ml{RW\_TAC}. +be proved with the simplifier \ml{rw}. \begin{session} \begin{alltt} @@ -500,7 +490,7 @@ definitions of addition and factorial: done: \begin{session} \begin{alltt} ->> e (metis_tac [DIVIDES_RMUL]); +>> e (rw[DIVIDES_RMUL]); \end{alltt} \end{session} We have finished the search for the proof, and now turn to the task of @@ -509,21 +499,23 @@ just made. We assume that the sequence of invocations has been kept track of in a file or a text editor buffer. We would thus have something like the following: \begin{hol} -\begin{verbatim} - e (lrw[LESS_EQ_EXISTS]); - e (qcase_tac `m divides FACT (m + q)`); - e (Induct_on `q`); - (*1*) - e (lrw[]); - e (Cases_on `m`); - (*1.1*) - e (metis_tac [DECIDE ``!x. ~(x < x)``]); - (*1.2*) - e (lrw[FACT, DIVIDES_LMUL, DIVIDES_REFL]); - (*2*) - e (lrw[FACT, ADD_CLAUSES]); - e (metis_tac [DIVIDES_RMUL]); -\end{verbatim} +\begin{alltt} +>>__ restart(); +##eval e (`!m p. 0 < m ==> m divides FACT (m + p)` + suffices_by metis_tac[LESS_EQ_EXISTS]); + e (Induct_on `p`); + (*1*) + e (lrw[]); + e (Cases_on `m`); + (*1.1*) + e (fs[]); + (*1.2*) + e (lrw[FACT, DIVIDES_LMUL, DIVIDES_REFL]); + (*2*) + e (lrw[FACT, ADD_CLAUSES]); + e (rw[DIVIDES_RMUL]); +##assert can top_thm () +\end{alltt} \end{hol} \noindent @@ -532,17 +524,19 @@ proof. We can stitch the above together directly into the following compound tactic: \begin{hol} -\begin{verbatim} - lrw[LESS_EQ_EXISTS] >> - qcase_tac `m divides FACT (m + q)` >> - Induct_on `q` >| [ - lrw[] >> Cases_on `m` >| [ - METIS_TAC [DECIDE ``!x. ~(x < x)``], - lrw[FACT, DIVIDES_LMUL, DIVIDES_REFL] - ], - lrw[FACT, ADD_CLAUSES] >> metis_tac [DIVIDES_RMUL] - ] -\end{verbatim} +\begin{alltt} + ##eval[tac] `!m p. 0 < m ==> m divides FACT (m + p)` + suffices_by metis_tac[LESS_EQ_EXISTS] >> + Induct_on `p` >| [ + lrw[] >> Cases_on `m` >| [ + fs[], + lrw[FACT, DIVIDES_LMUL, DIVIDES_REFL] + ], + lrw[FACT, ADD_CLAUSES] >> rw[DIVIDES_RMUL] + ] +>>__ restart(); e tac; +##assert can top_thm () +\end{alltt} \end{hol} \noindent This can be tested to see that we have made no errors: @@ -550,15 +544,16 @@ tactic: \begin{session} \begin{alltt} >>_ restart(); ->> e (lrw[LESS_EQ_EXISTS] >> - qcase_tac `m divides FACT (m + q)` >> - Induct_on `q` >| [ +>> e (`!m p. 0 < m ==> m divides FACT (m + p)` + suffices_by metis_tac[LESS_EQ_EXISTS] >> + Induct_on `p` >| [ lrw[] >> Cases_on `m` >| [ - METIS_TAC [DECIDE ``!x. ~(x < x)``], + fs[], lrw[FACT, DIVIDES_LMUL, DIVIDES_REFL] ], - lrw[FACT, ADD_CLAUSES] >> metis_tac [DIVIDES_RMUL] + lrw[FACT, ADD_CLAUSES] >> rw[DIVIDES_RMUL] ]) +##assert can top_thm () \end{alltt} \end{session} @@ -571,79 +566,71 @@ the theorem to the developing theory.} or \ml{store\_thm} and that would be the end of it. However, another user might notice that this tactic could be shortened. -To start, both arms of the induction start with an invocation of -\ml{lrw}, and the semantics of \ml{\gt\gt} allow us to merge the -occurrences of \ml{lrw} above the \ml{\gt|}. -The recast tactic is +One obvious step would be to merge the two successive invocations of the simplifier in the step case: \begin{hol} -\begin{verbatim} - lrw[LESS_EQ_EXISTS] >> - qcase_tac `m divides FACT (m + q)` >> - Induct_on `q` >> lrw[FACT, ADD_CLAUSES] >| [ - Cases_on `m` >| [ - metis_tac [DECIDE ``!x. ~(x < x)``], - lrw[FACT, DIVIDES_LMUL, DIVIDES_REFL] - ], - metis_tac [DIVIDES_RMUL] - ] -\end{verbatim} +\begin{alltt} + ##eval[tac] `!m p. 0 < m ==> m divides FACT (m + p)` + suffices_by metis_tac[LESS_EQ_EXISTS] >> + Induct_on `p` >| [ + Cases_on `m` >| [ + fs[], + lrw[FACT, DIVIDES_LMUL, DIVIDES_REFL] + ], + lrw[FACT, ADD_CLAUSES, DIVIDES_RMUL] + ] +>>__ restart(); e tac; +##assert can top_thm() +\end{alltt} \end{hol} -(Of course, when a tactic has been revised, it should be tested to see -if it still proves the goal!) -Now recall that the use of \ml{lrw} in the base case could be replaced by a call to \ml{metis\_tac}. -Thus it seems possible to merge the two sub-cases of the base case into a single invocation of \ml{metis\_tac}: +Then, both arms of the induction start with an invocation of \ml{lrw}, and the semantics of \ml{\gt\gt} allow us to merge the occurrences of \ml{lrw} above the \ml{\gt|}. +This makes the step case entirely empty, so that when we execute the first steps of the proof we are left with only the base case to prove: +\begin{session} +\begin{alltt} +>>_ restart(); +>> e (`!m p. 0 < m ==> m divides FACT (m + p)` + suffices_by metis_tac[LESS_EQ_EXISTS] >> + Induct_on `p` >> lrw[FACT, ADD_CLAUSES, DIVIDES_RMUL]); +\end{alltt} +\end{session} +This means that our tactic can become \begin{hol} -\begin{verbatim} - lrw[LESS_EQ_EXISTS] >> - qcase_tac `m divides FACT (m + q)` >> - Induct_on `q` >> - lrw[FACT, ADD_CLAUSES] >| [ - Cases_on `m` >> - metis_tac[DECIDE ``!x. ~(x m divides FACT (m + p)` + suffices_by metis_tac[LESS_EQ_EXISTS] >> + Induct_on `p` >> + lrw[FACT, ADD_CLAUSES,DIVIDES_RMUL] >> + (* base case only remains *) + Cases_on `m` >| [ + fs[], + lrw[FACT,DIVIDES_LMUL,DIVIDES_REFL] + ] +>>__ val tac = it; restart(); e tac; +##assert can top_thm () +\end{alltt} \end{hol} -\noindent -Finally, pushing this revisionism nearly to its limit, we'd like there to be only a single invocation of \ml{metis\_tac} to finish the proof off. -The semantics of \ml{\gt\gt} and \ml{all\_tac} come to -our rescue: we will split on the construction of $m$ in the base case, -as in the current incarnation of the tactic, but we will let the -inductive case pass unaltered through the \ml{\gt|}. -This is achieved by using \ml{all\_tac}, which is a tactic that acts as an identity function on the goal. +In the base case, we have two invocations of the simplifier under the case-split on \holtxt{m}. +In general, the two different simplifier invocations do slightly different things in addition to simplifying the conclusion of the goal: +\begin{itemize} +\item \ml{rw} strips apart the propositional structure of the goal, and eliminates equalities from the assumptions +\item \ml{fs} simplifies the assumptions as well as the conclusion +\end{itemize} +However, in this case the goal where we used \ml{rw} did not include any propositional structure to strip apart, and so we can be confident that using \ml{fs} in the same place would also work. +Thus, we can merge the two sub-cases of the base-case into a single invocation of \ml{fs}: \begin{hol} -\begin{verbatim} - lrw[LESS_EQ_EXISTS] >> - qcase_tac `m divides FACT (m + q)` >> - Induct_on `q` >> - lrw[FACT, ADD_CLAUSES] >| [Cases_on `m`, all_tac] >> - metis_tac [DECIDE ``!x. ~(x < x)``, FACT, DIVIDES_RMUL, DIVIDES_REFL] -\end{verbatim} -\end{hol} - -\noindent -The result is that there will be three subgoals emerging from the \ml{THENL}: the two sub-cases in the base case and the unaltered step case. -Each is proved with a call to \ml{metis\_tac}. -Are we now done? -Not necessarily. -For example, the explicit case split, namely \ml{Cases\_on `m`}, can be replaced by providing the \emph{cases} theorem for natural numbers (\ml{num\_CASES}) to \ml{metis\_tac}. -With this, the case split on $m$ will be automatically generated by \ml{metis\_tac} as it searches for the proof. -Hence we can shorten the tactic again. -\begin{session} \begin{alltt} ->> num_CASES; - ->>_ restart(); ->> e (lrw[LESS_EQ_EXISTS] >> - qcase_tac `m divides FACT (m + q)` >> - Induct_on `q` >> - metis_tac [DECIDE ``!x. ~(x < x)``, FACT, num_CASES, - DIVIDES_RMUL, DIVIDES_LMUL, DIVIDES_REFL, ADD_CLAUSES]); -##assert can top_thm () + ##eval[tac] `!m p. 0 < m ==> m divides FACT (m + p)` + suffices_by metis_tac[LESS_EQ_EXISTS] >> + Induct_on `p` >> + lrw[FACT, ADD_CLAUSES,DIVIDES_RMUL] >> + Cases_on `m` >> + fs[FACT,DIVIDES_RMUL,DIVIDES_REFL] +>>__ restart(); e tac; +##assert can top_thm() \end{alltt} -\end{session} +\end{hol} + We have now finished our exercise in tactic revision. Certainly, it would be hard to foresee that this final tactic would prove the goal; the required lemmas for the final invocation of \ml{metis\_tac} @@ -698,131 +685,36 @@ What to do? In fact, that earlier case analysis will again do the job: but now we hide it away so that it is only used to prove this sub-goal. When we execute \ml{Cases\_on `m`}, we will get a case where \holtxt{m} has been substituted out for \holtxt{0}. -This case will be contradictory given that we already have an assumption \holtxt{0~$<$~m}. - -When such situations occur, it is often best to start a new proof for -the required lemma. This can be done simply by invoking ``\ml{g}'' -again. A new goalstack will be created and stacked upon the current -one\footnote{This stacking of proof attempts (goalstacks) is different - than the stacking of goals and justifications inside a particular - goalstack.} and an overview of the extant proof attempts will be -printed: -\begin{session} -\begin{verbatim} -- g `!m. 0 < m ==> ?k. m = SUC k`; +This case will be contradictory given that we already have an assumption \holtxt{0~$<$~m}, and we can again use \ml{fs}. +In the other case, there will be an assumption that \holtxt{m} is some successor value, and this will make it easy for the simplifier to prove the goal. -> val it = - Proof manager status: 2 proofs. - 2. Incomplete: - Initial goal: - !m n. 0 < m /\ m <= n ==> m divides FACT n - - - Current goal: - m divides FACT m - ------------------------------------ - 0. 0 = m - m - 1. 0 < m - 2. m <= m - - 1. Incomplete: - Initial goal: - !m. 0 < m ==> ?k. m = SUC k -\end{verbatim} -\end{session} - Our new goal can be proved quite quickly. Once we have proved it, - we can bind it to an ML name and use it in the previous proof, by - some sleight of hand with the ``\ml{before}''\footnote{An infix - version of the {\tt K} combinator, defined by {\tt fun (x before - y) = x}.} function. +Thus: \begin{session} -\begin{verbatim} -- e (Cases THEN RW_TAC arith_ss []); - -OK.. -> val it = - Initial goal proved. - |- !m. 0 < m ==> ?k. m = SUC k - -- val lem = top_thm() before drop(); - -OK.. -> val lem = |- !m. 0 < m ==> ?k. m = SUC k : thm -\end{verbatim} +\begin{alltt} +>> e (`?k. m = SUC k` by (Cases_on `m` >> fs[])); +\end{alltt} \end{session} -Now we can return to the main thread of the proof. The state of the -current sub-goal of the proof can be displayed using the function -``\ml{p}''. - -\begin{session} -\begin{verbatim} -- p (); - -> val it = - m divides FACT m - ------------------------------------ - 0. 0 = m - m - 1. 0 < m - 2. m <= m -\end{verbatim} -\end{session} - Now we can use \ml{lem} in the proof. Somewhat opportunistically, - we will tack on the invocation used in the earlier proof at - (roughly) the same point, hoping that it will solve the goal: +\noindent Now the tactic we used before can finish this off: \begin{session} -\begin{verbatim} -- e (`?k. m = SUC k` by - METIS_TAC[lem] THEN RW_TAC arith_ss [FACT, DIVIDES_LMUL, DIVIDES_REFL]); -OK.. -metis: r[+0+6]+0+0+0+0+0+1# - -Goal proved. ... - -Remaining subgoals: -> val it = - m divides FACT n - ------------------------------------ - 0. !n m. (v = n - m) ==> 0 < m /\ m <= n ==> m divides FACT n - 1. SUC v = n - m - 2. 0 < m - 3. m <= n -\end{verbatim} +\begin{alltt} +>> e (lfs[FACT, DIVIDES_LMUL, DIVIDES_REFL]); +\end{alltt} \end{session} - It does! That takes care of the base case. For the induction step, - things look a bit more difficult than in the earlier proof. - However, we can make progress by realizing that the hypotheses - imply that $0 < n$ and so, again by \ml{lem}, we can transform $n$ - into a successor, thus enabling the unfolding of \ml{FACT}, as in - the previous proof: +That takes care of the base case. +For the induction step, things look a bit more difficult than in the earlier proof. +However, we can make progress by realizing that the hypotheses imply that $0 < n$ and so we can transform $n$ into a successor, thus enabling the unfolding of \ml{FACT}, as in the previous proof: \begin{session} -\begin{verbatim} -- e (`0 < n` by DECIDE_TAC THEN `?k. n = SUC k` by METIS_TAC [lem]); -OK.. -metis: r[+0+8]+0+0+0+0+0+0+2# -1 subgoal: -> val it = - m divides FACT n - ------------------------------------ - 0. !n m. (v = n - m) ==> 0 < m /\ m <= n ==> m divides FACT n - 1. SUC v = n - m - 2. 0 < m - 3. m <= n - 4. 0 < n - 5. n = SUC k -\end{verbatim} +\begin{alltt} +>> e (`0 < n` by lrw[] >> `?k. n = SUC k` by (Cases_on `n` >> fs[])); +\end{alltt} \end{session} \noindent The proof now finishes in much the same manner as the previous one: \begin{session} -\begin{verbatim} -- e (RW_TAC arith_ss [FACT, DIVIDES_RMUL]); -OK.. - -Goal proved. ... -> val it = - Initial goal proved. - |- !m n. 0 < m /\ m <= n ==> m divides FACT n -\end{verbatim} +\begin{alltt} +>> e (lrw [FACT, DIVIDES_RMUL]); +##assert can top_thm() +\end{alltt} \end{session} \noindent We leave the details of stitching the proof together to the interested reader. @@ -838,28 +730,35 @@ primes are positive. These are all quite simple to prove. \item [\small{({\it NOT\_PRIME\_0\/})}] \begin{tabular}[t]{l} \verb+~prime 0+ \\ \hline -\verb+RW_TAC arith_ss [prime_def,DIVIDES_0]+ \\ +\verb+lrw[prime_def,DIVIDES_0]+ \\ \end{tabular} +>>__ val NOT_PRIME_0 = prove(``~prime 0``, lrw[prime_def, DIVIDES_0]) \item [\small{({\it NOT\_PRIME\_1\/})}] \begin{tabular}[t]{l} \verb+~prime 1+ \\ \hline -\verb+RW_TAC arith_ss [prime_def]+ \\ +\verb+lrw[prime_def]+ \\ \end{tabular} +>>__ val NOT_PRIME_1 = prove(``~prime 1``, lrw[prime_def]) \item [\small{({\it PRIME\_2\/})}] \begin{tabular}[t]{l} \verb+prime 2+ \\ \hline -\verb+RW_TAC arith_ss [prime_def]+ \\ -\verb+ THEN METIS_TAC [DIVIDES_LE, DIVIDES_ZERO,+ \\ -\verb+ DECIDE ``~(2=1)``, DECIDE ``~(2=0)``,+ \\ -\verb+ DECIDE ``x <= 2 = (x=0) \/ (x=1) \/ (x=2)``]+ \\ +\verb+lrw[prime_def] >>+ \\ +\verb+metis_tac [DIVIDES_LE, DIVIDES_ZERO, DECIDE ``2<>0``,+ \\ +\verb+ DECIDE ``x <= 2 <=> (x=0) \/ (x=1) \/ (x=2)``]+ \\ \end{tabular} +>>__ val PRIME_2 = prove(``prime 2``, + lrw[prime_def] >> + metis_tac[DIVIDES_LE, DIVIDES_ZERO, DECIDE ``~(2=0)``, + DECIDE ``x <= 2 = (x=0) \/ (x=1) \/ (x=2)``]) \item [\small{({\it PRIME\_POS\/})}] \begin{tabular}[t]{l} \verb+!p. prime p ==> 0> lrw[NOT_PRIME_0]+ \\ +>>__ val PRIME_POS = prove( + ``!p. prime p ==> 0 < p``, Cases >> lrw[NOT_PRIME_0]) \end{tabular} \end{description} @@ -882,181 +781,90 @@ or $n$. The polished tactic is the following: \item [\small{({\it PRIME\_FACTOR\/})}] \begin{tabular}[t]{l} \verb+!n. ~(n = 1) ==> ?p. prime p /\ p divides n+ \\ \hline -\verb+completeInduct_on `n`+ \\ -\verb+ THEN RW_TAC arith_ss []+ \\ -\verb+ THEN Cases `prime n` THENL+ \\ -\verb+ [METIS_TAC [DIVIDES_REFL], + \\ -\verb+ `?x. x divides n /\ ~(x=1) /\ ~(x=n)` + \\ -\verb+ by METIS_TAC[prime_def]+ \\ -\verb+ THEN METIS_TAC [LESS_OR_EQ, PRIME_2, +\\ -\verb+ DIVIDES_LE,DIVIDES_TRANS,DIVIDES_0]]+ \\ +\verb+completeInduct_on `n` >>+ \\ +\verb+ lrw [] >>+ \\ +\verb+ Cases_on `prime n` >| [+ \\ +\verb+ metis_tac [DIVIDES_REFL], + \\ +\verb+ `?x. x divides n /\ x<>1 /\ x<>n` + \\ +\verb+ by METIS_TAC[prime_def] >>+ \\ +\verb+ metis_tac [LESS_OR_EQ, PRIME_2, +\\ +\verb+ DIVIDES_LE,DIVIDES_TRANS,DIVIDES_0]]+ \\ \end{tabular} \end{description} We start by invoking complete induction. This gives us an inductive hypothesis that holds at every number $m$ strictly smaller than $n$: \begin{session} -\begin{verbatim} -- g `!n. ~(n = 1) ==> ?p. prime p /\ p divides n`; +\begin{alltt} +>>__ proofManagerLib.dropn (case proofManagerLib.status() of + Manager.PRFS l => List.length l) +>> g `!n. n <> 1 ==> ?p. prime p /\ p divides n`; -- e (completeInduct_on `n`); -OK.. -1 subgoal: -> val it = - ~(n = 1) ==> ?p. prime p /\ p divides n - ------------------------------------ - !m. m < n ==> ~(m = 1) ==> ?p. prime p /\ p divides m -\end{verbatim} +>> e (completeInduct_on `n`); +\end{alltt} \end{session} We can move the antecedent to the hypotheses and make our case split. Notice that the term given to \ml{Cases\_on} need not occur in the goal: \begin{session} -\begin{verbatim} -- e (RW_TAC arith_ss [] THEN Cases_on `prime n`); -OK.. -2 subgoals: -> val it = - ?p. prime p /\ p divides n - ------------------------------------ - 0. !m. m < n ==> ~(m = 1) ==> ?p. prime p /\ p divides m - 1. ~(n = 1) - 2. ~prime n - - ?p. prime p /\ p divides n - ------------------------------------ - 0. !m. m < n ==> ~(m = 1) ==> ?p. prime p /\ p divides m - 1. ~(n = 1) - 2. prime n -\end{verbatim} +\begin{alltt} +>> e (lrw[] >> Cases_on `prime n`); +\end{alltt} \end{session} \noindent As mentioned, the first case is proved with the reflexivity of divisibility: \begin{session} -\begin{verbatim} -- e (METIS_TAC [DIVIDES_REFL]); -OK.. -metis: r[+0+7]+0+0+0+0+1# - -Goal proved. ... -\end{verbatim} +\begin{alltt} +>>_ e (metis_tac [DIVIDES_REFL]); +\end{alltt} \end{session} \noindent In the second case, we can get a divisor of $n$ that isn't $1$ or $n$ (since $n$ is not prime): \begin{session} -\begin{verbatim} -- e (`?x. x divides n /\ ~(x=1) /\ ~(x=n)` by METIS_TAC [prime_def]); -OK.. -metis: r[+0+11]+0+0+0+0+0+0+1+1+1+1+0+1+1# -1 subgoal: -> val it = - ?p. prime p /\ p divides n - ------------------------------------ - 0. !m. m < n ==> ~(m = 1) ==> ?p. prime p /\ p divides m - 1. ~(n = 1) - 2. ~prime n - 3. x divides n - 4. ~(x = 1) - 5. ~(x = n) -\end{verbatim} +\begin{alltt} +>> e (`?x. x divides n /\ x<>1 /\ x<>n` by metis_tac [prime_def]); +\end{alltt} \end{session} -At this point, the polished tactic simply invokes \ml{METIS\_TAC} with -a collection of theorems. We will attempt a more detailed -exposition. Given the hypotheses, and by {\small\it DIVIDES\_LE}, we can -assert $x < n \lor n = 0$ and thus split the proof into two cases: +At this point, the polished tactic simply invokes \ml{metis\_tac} with +a collection of theorems. +We will attempt a more detailed exposition. +Given the hypotheses, and by {\small\it DIVIDES\_LE}, we can assert $x < n \lor n = 0$ and thus split the proof into two cases: \begin{session} -\begin{verbatim} -- e (`x < n \/ (n=0)` by METIS_TAC [DIVIDES_LE,LESS_OR_EQ]); -OK.. -metis: r[+0+14]+0+0+0+0+0+0+0+0+0+0+1+0+1# -2 subgoals: -> val it = - ?p. prime p /\ p divides n - ------------------------------------ - 0. !m. m < n ==> ~(m = 1) ==> ?p. prime p /\ p divides m - 1. ~(n = 1) - 2. ~prime n - 3. x divides n - 4. ~(x = 1) - 5. ~(x = n) - 6. n = 0 - - ?p. prime p /\ p divides n - ------------------------------------ - 0. !m. m < n ==> ~(m = 1) ==> ?p. prime p /\ p divides m - 1. ~(n = 1) - 2. ~prime n - 3. x divides n - 4. ~(x = 1) - 5. ~(x = n) - 6. x < n -\end{verbatim} +\begin{alltt} +>> e (`x < n \/ (n=0)` by metis_tac [DIVIDES_LE,LESS_OR_EQ]); +\end{alltt} \end{session} In the first subgoal, we can see that the antecedents of the inductive hypothesis are met and so $x$ has a prime divisor. We can then use the transitivity of divisibility to get the fact that this divisor of $x$ is also a divisor of $n$, thus finishing this branch of the proof: \begin{session} -\begin{verbatim} -- e (METIS_TAC [DIVIDES_TRANS]); -OK.. -metis: r[+0+11]+0+0+0+0+0+0+0+1+0+4+1+0+3+0+2+2+1# +\begin{alltt} +>>_ e (metis_tac [DIVIDES_TRANS]); Goal proved. -\end{verbatim} +\end{alltt} \end{session} \noindent The remaining goal can be clarified by simplification: \begin{session} -\begin{verbatim} -- e (RW_TAC arith_ss []); -OK.. -1 subgoal: -> val it = - ?p. prime p /\ p divides 0 - ------------------------------------ - 0. !m. m < 0 ==> ~(m = 1) ==> ?p. prime p /\ p divides m - 1. ~(0 = 1) - 2. ~prime 0 - 3. x divides 0 - 4. ~(x = 1) - 5. ~(x = 0) +\begin{alltt} +>> e (lrw[]); -- DIVIDES_0; -> val it = |- !x. x divides 0 : thm +>> DIVIDES_0; -- e (RW_TAC arith_ss [it]); -OK.. -1 subgoal: -> val it = - ?p. prime p - ------------------------------------ - 0. !m. m < 0 ==> ~(m = 1) ==> ?p. prime p /\ p divides m - 1. ~(0 = 1) - 2. ~prime 0 - 3. x divides 0 - 4. ~(x = 1) - 5. ~(x = 0) -\end{verbatim} +>> e (lrw[it]); +\end{alltt} \end{session} The two steps of exploratory simplification have led us to a state where all we have to do is exhibit a prime. And we already have one to hand: \begin{session} -\begin{verbatim} -- e (METIS_TAC [PRIME_2]); -OK.. -metis: r[+0+6]# - -Goal proved. ... -> val it = - Initial goal proved. - |- !n. ~(n = 1) ==> ?p. prime p /\ p divides n -\end{verbatim} +\begin{alltt} +>> e (metis_tac [PRIME_2]); +\end{alltt} \end{session} -Again, work now needs to be done to compose and perhaps polish a single -tactic from the individual proof steps, but we will not describe -it.\footnote{Indeed, the tactic can be simplified into complete induction - followed by an invocation of \ml{METIS\_TAC} with suitable lemmas.} - Instead we move forward, because our ultimate goal is in reach. +Again, work now needs to be done to compose and perhaps polish a single tactic from the individual proof steps, but we will not describe it.% +\footnote{Indeed, the tactic can be simplified into complete induction followed by an invocation of \ml{METIS\_TAC} with suitable lemmas.} +Instead we move forward, because our ultimate goal is in reach. \section{Euclid's theorem} From bf01cd8b03bf5e5c8c8cffb9255506c19b65884e Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 27 Jan 2016 17:00:56 +1100 Subject: [PATCH 656/718] Don't include chapter 3 on Logic in Tutorial --- Manual/Tutorial/ml.stex | 2 +- Manual/Tutorial/tutorial.tex | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Manual/Tutorial/ml.stex b/Manual/Tutorial/ml.stex index 8026ead330..9365d7b3ac 100644 --- a/Manual/Tutorial/ml.stex +++ b/Manual/Tutorial/ml.stex @@ -88,7 +88,7 @@ infers the type of expressions using methods invented by Robin Milner \cite{Milner-types}. The type {\small\verb|int list|} is the type of `lists of integers'; {\small\verb|list|} is a unary type operator. The type system of \ML{} is very similar to the type system of the -\HOL{} logic which is explained in Chapter~\ref{HOLlogic}. +\HOL{} logic. The value of the last expression evaluated at top-level in \ML{} is always remembered in a variable called {\small\verb|it|}. diff --git a/Manual/Tutorial/tutorial.tex b/Manual/Tutorial/tutorial.tex index 2291b4ba24..39cfd59183 100644 --- a/Manual/Tutorial/tutorial.tex +++ b/Manual/Tutorial/tutorial.tex @@ -56,7 +56,7 @@ \include{intro} % intro: getting and installing hol \include{ml} % intro to ml - \include{logic} % the HOL logic and intro to HOL proof +% \include{logic} % the HOL logic and intro to HOL proof \include{euclid} % Euclid example \include{parity} % parity example % \include{tool} % conjunction canonicalization tool From 0a718da18ec8703f78dbc27be38826b75e93eb74 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 27 Jan 2016 17:10:07 +1100 Subject: [PATCH 657/718] Minor tidies in ML chapter of Tutorial --- Manual/Tutorial/ml.stex | 26 ++++++++------------------ 1 file changed, 8 insertions(+), 18 deletions(-) diff --git a/Manual/Tutorial/ml.stex b/Manual/Tutorial/ml.stex index 9365d7b3ac..5b06a521e3 100644 --- a/Manual/Tutorial/ml.stex +++ b/Manual/Tutorial/ml.stex @@ -66,32 +66,22 @@ by the user and other lines are the system's responses. For introductory HOL help, type: help "hol"; ----------------------------------------------------------------- -[loading theories and proof tools ************* ] -[closing file "/local/scratch/mn200/Work/hol98/tools/end-init-boss.sml"] > 1 :: [2,3,4,5]; val it = [1, 2, 3, 4, 5] : int list \end{alltt} \end{session} -The \ML{} expression {\small\verb|1 :: [2,3,4,5]|} has the form $e_1\ -op\ e_2$ where $e_1$ is the expression {\small\verb|1|} (whose value -is the integer $1$), $e_2$ is the expression {\small\verb|[2,3,4,5]|} -(whose value is a list of four integers) and $op$ is the infixed -operator `{\small\verb|::|}' which is like Lisp's {\it cons} function. -Other list processing functions include {\small\verb|hd|} ($car$ in -Lisp), {\small\verb|tl|} ($cdr$ in Lisp) and {\small\verb|null|} -($null$ in Lisp). The semicolon `{\small\verb|;|}' terminates a -top-level phrase. The system's response is shown on the line starting -with the {\small\verb|>|} prompt. It consists of the value of the -expression followed, after a colon, by its type. The \ML{} type checker -infers the type of expressions using methods invented by Robin Milner -\cite{Milner-types}. The type {\small\verb|int list|} is the type of -`lists of integers'; {\small\verb|list|} is a unary type operator. +The \ML{} expression {\small\verb|1 :: [2,3,4,5]|} has the form $e_1\ op\ e_2$ where $e_1$ is the expression {\small\verb|1|} (whose value is the integer $1$), $e_2$ is the expression {\small\verb|[2,3,4,5]|} (whose value is a list of four integers) and $op$ is the infixed operator `{\small\verb|::|}' which is like Lisp's {\it cons} function. +Other list processing functions include {\small\verb|hd|} ($car$ in Lisp), {\small\verb|tl|} ($cdr$ in Lisp) and {\small\verb|null|} ($null$ in Lisp). +The semicolon `{\small\verb|;|}' terminates a top-level phrase. +The system's response is shown on the line starting with the word \ml{val}. +It consists of the value of the expression followed, after a colon, by its type. +The \ML{} type checker infers the type of expressions using methods invented by Robin Milner \cite{Milner-types}. +The type \ml{int~list} is the type of `lists of integers'; \ml{list} is a unary type operator. The type system of \ML{} is very similar to the type system of the \HOL{} logic. -The value of the last expression evaluated at top-level in \ML{} is always -remembered in a variable called {\small\verb|it|}. +The value of the last expression evaluated at the top-level not otherwise bound to a name is always remembered in a variable called \ml{it}. \begin{session} \begin{alltt} From d1912a8449408d595eff4b5e81196c8b51ef33e8 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 27 Jan 2016 20:15:45 +1100 Subject: [PATCH 658/718] Add print_banner function to interactive preludes This allows the banner to be printed in other contexts if desired. --- std.prelude | 45 +++++++++++++++++++---------------- tools-poly/prelude.ML | 55 +++++++++++++++++++++++-------------------- 2 files changed, 55 insertions(+), 45 deletions(-) diff --git a/std.prelude b/std.prelude index 65603543d9..1b60165c67 100644 --- a/std.prelude +++ b/std.prelude @@ -150,23 +150,37 @@ val exit_string = else "To exit type -D (*not* quit();)" -val _ = -TextIO.output(TextIO.stdOut, - "\n---------------------------------------------------------------------\n" - ^" HOL-4 [" - ^Globals.release^" "^Lib.int_to_string(Globals.version) - ^" ("^Thm.kernelid^", "^build_stamp - ^")]\n\n" - ^" For introductory HOL help, type: help \"hol\";\n" - ^" "^exit_string - ^"\n---------------------------------------------------------------------\n\ - \\n"); (* ---------------------------------------------------------------------- if present, look at a Holmakefile in the current directory to see if we should extend the loadPath ---------------------------------------------------------------------- *) +structure HOL_Interactive : sig + val toggle_quietdec : unit -> bool + val amquiet : unit -> bool + val print_banner : unit -> unit +end = +struct + fun toggle_quietdec () = (Meta.quietdec := not (!Meta.quietdec) ; + !Meta.quietdec) + fun amquiet () = !Meta.quietdec + fun print_banner() = + TextIO.output(TextIO.stdOut, + "\n---------------------------------------------------------------------\n" + ^" HOL-4 [" + ^Globals.release^" "^Lib.int_to_string(Globals.version) + ^" ("^Thm.kernelid^", "^build_stamp + ^")]\n\n" + ^" For introductory HOL help, type: help \"hol\";\n" + ^" "^exit_string + ^"\n---------------------------------------------------------------------\ + \\n\n") + +end; + +val _ = HOL_Interactive.print_banner() + local open Path in @@ -177,15 +191,6 @@ end; use (OS.Path.concat (HOLDIR, OS.Path.concat("tools", "makefile-includes.ML"))); -structure HOL_Interactive : sig - val toggle_quietdec : unit -> bool - val amquiet : unit -> bool -end = -struct - fun toggle_quietdec () = (Meta.quietdec := not (!Meta.quietdec) ; - !Meta.quietdec) - fun amquiet () = !Meta.quietdec -end; use (Path.concat(Globals.HOLDIR, "tools/check-intconfig.sml")); diff --git a/tools-poly/prelude.ML b/tools-poly/prelude.ML index 76f6831242..d04bb50ac1 100644 --- a/tools-poly/prelude.ML +++ b/tools-poly/prelude.ML @@ -124,8 +124,11 @@ structure HOL_Interactive :> sig val toggle_quietdec : unit -> bool val amquiet : unit -> bool + val print_banner : unit -> unit end = struct + infix ++ + val op ++ = OS.Path.concat val qd = ref true fun toggle_quietdec () = if !qd then @@ -143,6 +146,32 @@ struct ; true ) fun amquiet () = !qd + val build_stamp = + let + val stampstr = TextIO.openIn (HOLDIR ++ "tools" ++ "build-stamp") + val stamp = TextIO.inputAll stampstr before TextIO.closeIn stampstr + in + stamp + end + handle _ => "" + val id_string = + "HOL-4 [" ^ Globals.release ^ " " ^ Lib.int_to_string Globals.version ^ + " (" ^ Thm.kernelid ^ ", " ^ build_stamp ^ ")]\n\n" + val exit_string = + if Systeml.OS = "winNT" then + "To exit type -Z (*not* quit();)" + else + "To exit type -D" + val line = + "\n---------------------------------------------------------------------\n" + + fun print_banner () = + TextIO.output (TextIO.stdOut, + line ^ + " " ^ id_string ^ + " For introductory HOL help, type: help \"hol\";\n" ^ + " " ^ exit_string ^ + line) end; (*---------------------------------------------------------------------------* @@ -195,32 +224,8 @@ local use (nm ^ ".sig") ; use (nm ^ ".sml") end - val build_stamp = - let - val stampstr = TextIO.openIn (HOLDIR ++ "tools" ++ "build-stamp") - val stamp = TextIO.inputAll stampstr before TextIO.closeIn stampstr - in - stamp - end - handle _ => "" - val id_string = - "HOL-4 [" ^ Globals.release ^ " " ^ Lib.int_to_string Globals.version ^ - " (" ^ Thm.kernelid ^ ", " ^ build_stamp ^ ")]\n\n" - val exit_string = - if Systeml.OS = "winNT" then - "To exit type -Z (*not* quit();)" - else - "To exit type -D" - val line = - "\n---------------------------------------------------------------------\n" - val () = - TextIO.output (TextIO.stdOut, - line ^ - " " ^ id_string ^ - " For introductory HOL help, type: help \"hol\";\n" ^ - " " ^ exit_string ^ - line) in + val _ = HOL_Interactive.print_banner() val () = ( hol_use ("help" ++ "src-sml") "Database" ; hol_use ("tools-poly" ++ "poly") "Help" From 542d3185736735054a8f36a191f1fefb6f9c986d Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 27 Jan 2016 20:19:41 +1100 Subject: [PATCH 659/718] Use print_banner() in Tutorial's intro --- Manual/Tutorial/ml.stex | 11 ++--------- 1 file changed, 2 insertions(+), 9 deletions(-) diff --git a/Manual/Tutorial/ml.stex b/Manual/Tutorial/ml.stex index 5b06a521e3..cb9013ad2e 100644 --- a/Manual/Tutorial/ml.stex +++ b/Manual/Tutorial/ml.stex @@ -59,15 +59,9 @@ by the user and other lines are the system's responses. \begin{session} \begin{alltt} \$ bin/hol +>>- val _ = HOL_Interactive.print_banner(); ------------------------------------------------------------------ - HOL-4 [\holnsversion (built Fri Apr 12 15:34:35 2002)] - - For introductory HOL help, type: help "hol"; ------------------------------------------------------------------ - -> 1 :: [2,3,4,5]; -val it = [1, 2, 3, 4, 5] : int list +>> 1 :: [2,3,4,5]; \end{alltt} \end{session} @@ -85,7 +79,6 @@ The value of the last expression evaluated at the top-level not otherwise bound \begin{session} \begin{alltt} ->>__ 1 :: [2,3,4,5]; >> val l = it; >> tl l; From aa9688cc81c07c0e6808a3099c2518b7d1ab51ea Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 27 Jan 2016 22:20:06 +1100 Subject: [PATCH 660/718] Minor tweaks to intro and ML chapters of Tutorial --- Manual/Tutorial/intro.tex | 6 +++--- Manual/Tutorial/ml.stex | 18 ++++++------------ 2 files changed, 9 insertions(+), 15 deletions(-) diff --git a/Manual/Tutorial/intro.tex b/Manual/Tutorial/intro.tex index 85cc753035..0fca28610d 100644 --- a/Manual/Tutorial/intro.tex +++ b/Manual/Tutorial/intro.tex @@ -87,9 +87,9 @@ \section{Installing \HOL{}} web-page mentioned above.} Before beginning you must have a current version of Moscow~ML or -Poly/ML\footnote{Poly/ML cannot be used with HOL on Windows.}. In the -case of Moscow~ML, you must have version 2.01. Moscow~ML is available -on the web from \url{http://www.itu.dk/~sestoft/mosml.html}. +Poly/ML\footnote{Poly/ML cannot be used with HOL on Windows.}. +In the case of Moscow~ML, you must have at least version 2.01. +Moscow~ML is available on the web from \url{http://mosml.org}. Poly/ML is available from \url{http://polyml.org}. When working with Poly/ML, the installation must ensure that dynamic library loading (typically done by setting the \texttt{LD\_LIBRARY\_PATH} environment variable) picks up \texttt{libpolyml.so} and \texttt{libpolymain.so}. diff --git a/Manual/Tutorial/ml.stex b/Manual/Tutorial/ml.stex index cb9013ad2e..2e1e89496e 100644 --- a/Manual/Tutorial/ml.stex +++ b/Manual/Tutorial/ml.stex @@ -42,18 +42,12 @@ this way. These sessions are split into segments displayed in boxes with a number in their top right hand corner (to indicate their position in the complete session). -The interactions in these boxes should be understood as occurring in -sequence. For example, variable bindings made in earlier boxes are -assumed to persist to later ones. To enter the \HOL{} system one -types {\small\verb|hol|} or {\small\verb|hol.noquote|} to Unix, -possibly preceded by path information if the \HOL{} system's -\texttt{bin} directory is not in one's path. The \HOL{} system then -prints a sign-on message and puts one into \ML. The \ML{} prompt is -{\small\verb|-|}, so lines beginning with {\small\verb|-|} are typed -by the user and other lines are the system's responses. - - Here, as elsewhere in the \TUTORIAL{}, we will be assuming use of - {\small\verb|hol|}. +The interactions in these boxes should be understood as occurring in sequence. +For example, variable bindings made in earlier boxes are assumed to persist to later ones. +To enter the \HOL{} system, one types \texttt{hol} at the command-line, possibly preceded by path information if the \HOL{} system's \texttt{bin} directory is not in one's path. +The \HOL{} system then prints a sign-on message and puts one into \ML. +The \ML{} prompt varies depending on the implementation. +In Poly/ML, the implementation assumed for our sessions here, the prompt is \ml{\gt}, so lines beginning with \ml{\gt} are typed by the user, and other lines are the system's responses. \setcounter{sessioncount}{0} \begin{session} From f9a6edbce4ed267a29ef876cad2bac7a0cd89183 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 27 Jan 2016 22:20:31 +1100 Subject: [PATCH 661/718] Euclid Tutorial chapter revisions almost complete --- Manual/Tutorial/euclid.stex | 315 +++++++++++++++--------------------- examples/euclid.sml | 129 ++++++++------- 2 files changed, 191 insertions(+), 253 deletions(-) diff --git a/Manual/Tutorial/euclid.stex b/Manual/Tutorial/euclid.stex index d237d87d31..d6f610fca4 100644 --- a/Manual/Tutorial/euclid.stex +++ b/Manual/Tutorial/euclid.stex @@ -176,7 +176,7 @@ Then a simplification step finishes the proof. \end{alltt} \end{session} -What just happened here? The application of \ml{lrw} to the goal decomposed it to an empty list of subgoals; in other words the goal was proved by \ml{lrw}. +What just happened here? The application of \ml{rw} to the goal decomposed it to an empty list of subgoals; in other words the goal was proved by \ml{rw}. Once a goal has been proved, it is popped off the goalstack, prettyprinted to the output, and the theorem becomes available for use by the level of the stack. When all the sub-goals required by \textit{that} level are proven, the corresponding goal at that level can be proven too. This `unwinding' process continues until the stack is empty, or until it hits a goal with more than one remaining unproved subgoal. This process may be hard to visualize,\footnote{Perhaps since we have used a stack to implement what is notionally a tree!} but that doesn't matter, since the goalstack was expressly written to allow the user to ignore such details. @@ -212,7 +212,7 @@ We use the \ml{top\_thm} function to do this, and then use \ml{drop} to dispose \end{session} We have used \ml{metis\_tac} in this way to prove the following collection of theorems about \ml{divides}. -As mentioned previously, the theorems supplied to \ml{metis\_tac} in the following proofs did not (usually) come from thin air: in most cases some exploratory work with the simplifier (\ml{lrw}) was done to open up definitions and see what lemmas would be required by \ml{metis\_tac}. +As mentioned previously, the theorems supplied to \ml{metis\_tac} in the following proofs did not (usually) come from thin air: in most cases some exploratory work with the simplifier (\ml{rw}) was done to open up definitions and see what lemmas would be required by \ml{metis\_tac}. ##use euclid-extras.ML @@ -287,7 +287,7 @@ single invocation of \ml{metis\_tac}: \item [\small{({\it DIVIDES\_LE\/})}] \begin{tabular}[t]{l} \verb+!m n. m divides n ==> m <= n \/ (n = 0)+ \\ \hline -\verb+lrw[divides_def] >> lrw[]+ \\ +\verb+rw[divides_def] >> rw[]+ \\ \end{tabular} \end{description} Let's see how this is proved. @@ -326,10 +326,11 @@ Let's look in the theory of arithmetic for the subterm to be rewritten. This is just the theorem we'd like to use. Using \ml{DB.match} again, you should now try to find the theorem that will simplify the other disjunct. -Because both are so generally useful, \ml{lrw} already has both rewrites in its internal database, and all we need to do is rewrite once more to get those rewrites applied: +Because both are so generally useful, \ml{rw} already has both rewrites in its internal database, and all we need to do is rewrite once more to get those rewrites applied: \begin{session} \begin{alltt} ->> e (lrw[]); +>> e (rw[]); +##assert can top_thm() \end{alltt} \end{session} @@ -342,7 +343,7 @@ This function takes a string, a term and a tactic and applies the tactic to the >> val DIVIDES_LE = store_thm( "DIVIDES_LE", ``!m n. m divides n ==> m <= n \/ (n = 0)``, - lrw[divides_def] >> lrw[]); + rw[divides_def] >> rw[]); \end{alltt} \end{session} Storing theorems in our script record of the session in this style @@ -373,7 +374,7 @@ following\footnote{This and subsequent proofs use the theorems proved `!p m. 0 < m ==> m divides (FACT (m + p))` suffices_by metis_tac[LESS_EQ_EXISTS] >> Induct_on `p` >> - lrw[FACT,ADD_CLAUSES] >| [ + rw[FACT,ADD_CLAUSES] >| [ Cases_on `m`, ALL_TAC ] >> metis_tac [FACT, DECIDE ``!x. ~(x < x)``, DIVIDES_RMUL, DIVIDES_LMUL, DIVIDES_REFL]) @@ -381,10 +382,10 @@ following\footnote{This and subsequent proofs use the theorems proved \item [\small{({\it DIVIDES\_FACT\/})}] \begin{tabular}[t]{l} \verb+!m n. 0 < m /\ m <= n ==> m divides (FACT n)+ \\ \hline -\verb+lrw[LESS_EQ_EXISTS] >>+ \\ +\verb+rw[LESS_EQ_EXISTS] >>+ \\ \verb!qcase_tac `m divides FACT (m + q)` >>!\\ \verb+Induct_on `q` >>+\\ -\verb+lrw[FACT,ADD_CLAUSES] >| [+ \\ +\verb+rw[FACT,ADD_CLAUSES] >| [+ \\ \verb+ Cases_on `m`, ALL_TAC+ \\ \verb+] >> metis_tac [FACT, DECIDE ``!x. ~(x < x)``,+ \\ \verb+ DIVIDES_RMUL, DIVIDES_LMUL, DIVIDES_REFL]+ \\ @@ -414,7 +415,7 @@ variable, obtained by use of the theorem \verb+LESS_EQ_EXISTS+. \end{alltt} \end{session} \noindent Now we want to induct on the $p$ that our theorem says exists. -This effectively requires to prove a slight restatement of the theorem. +This effectively requires us to prove a slight restatement of the theorem. We might prove the restatement as a separate lemma, but it is probably just as easy to do this inline with the (infix) \ml{suffices\_by} tactic: \begin{session} \begin{alltt} @@ -435,7 +436,7 @@ The first goal the system expects us to prove is the lowest one printed (it's cl This can obviously be simplified: \begin{session} \begin{alltt} ->> e (lrw[]); +>> e (rw[]); \end{alltt} \end{session} \noindent Now we can do a case analysis on $m$: if it is $0$, we have a @@ -443,9 +444,9 @@ trivial goal; if it is a successor, then we can use the definition of \ml{FACT} and the theorems \ml{DIVIDES\_RMUL} and \ml{DIVIDES\_REFL}. \begin{session} -\begin{verbatim} +\begin{alltt} >> e (Cases_on `m`); -\end{verbatim} +\end{alltt} \end{session} Here the first sub-goal goal has an assumption that is false. @@ -475,7 +476,7 @@ be proved with the simplifier \ml{rw}. \begin{session} \begin{alltt} ->> e (lrw [FACT, DIVIDES_LMUL, DIVIDES_REFL]); +>> e (rw [FACT, DIVIDES_LMUL, DIVIDES_REFL]); \end{alltt} \end{session} Now we have finished the base case of the induction and can move to the @@ -483,7 +484,7 @@ step case. An obvious thing to try is simplification with the definitions of addition and factorial: \begin{session} \begin{alltt} ->> e (lrw [FACT, ADD_CLAUSES]); +>> e (rw [FACT, ADD_CLAUSES]); \end{alltt} \end{session} \noindent And now, by \ml{DIVIDES\_LMUL} and the inductive hypothesis, we are @@ -491,6 +492,7 @@ done: \begin{session} \begin{alltt} >> e (rw[DIVIDES_RMUL]); +##assert can top_thm() \end{alltt} \end{session} We have finished the search for the proof, and now turn to the task of @@ -505,14 +507,14 @@ like the following: suffices_by metis_tac[LESS_EQ_EXISTS]); e (Induct_on `p`); (*1*) - e (lrw[]); + e (rw[]); e (Cases_on `m`); (*1.1*) e (fs[]); (*1.2*) - e (lrw[FACT, DIVIDES_LMUL, DIVIDES_REFL]); + e (rw[FACT, DIVIDES_LMUL, DIVIDES_REFL]); (*2*) - e (lrw[FACT, ADD_CLAUSES]); + e (rw[FACT, ADD_CLAUSES]); e (rw[DIVIDES_RMUL]); ##assert can top_thm () \end{alltt} @@ -528,11 +530,11 @@ tactic: ##eval[tac] `!m p. 0 < m ==> m divides FACT (m + p)` suffices_by metis_tac[LESS_EQ_EXISTS] >> Induct_on `p` >| [ - lrw[] >> Cases_on `m` >| [ + rw[] >> Cases_on `m` >| [ fs[], - lrw[FACT, DIVIDES_LMUL, DIVIDES_REFL] + rw[FACT, DIVIDES_LMUL, DIVIDES_REFL] ], - lrw[FACT, ADD_CLAUSES] >> rw[DIVIDES_RMUL] + rw[FACT, ADD_CLAUSES] >> rw[DIVIDES_RMUL] ] >>__ restart(); e tac; ##assert can top_thm () @@ -547,11 +549,11 @@ tactic: >> e (`!m p. 0 < m ==> m divides FACT (m + p)` suffices_by metis_tac[LESS_EQ_EXISTS] >> Induct_on `p` >| [ - lrw[] >> Cases_on `m` >| [ + rw[] >> Cases_on `m` >| [ fs[], - lrw[FACT, DIVIDES_LMUL, DIVIDES_REFL] + rw[FACT, DIVIDES_LMUL, DIVIDES_REFL] ], - lrw[FACT, ADD_CLAUSES] >> rw[DIVIDES_RMUL] + rw[FACT, ADD_CLAUSES] >> rw[DIVIDES_RMUL] ]) ##assert can top_thm () \end{alltt} @@ -574,23 +576,23 @@ One obvious step would be to merge the two successive invocations of the simplif Induct_on `p` >| [ Cases_on `m` >| [ fs[], - lrw[FACT, DIVIDES_LMUL, DIVIDES_REFL] + rw[FACT, DIVIDES_LMUL, DIVIDES_REFL] ], - lrw[FACT, ADD_CLAUSES, DIVIDES_RMUL] + rw[FACT, ADD_CLAUSES, DIVIDES_RMUL] ] >>__ restart(); e tac; ##assert can top_thm() \end{alltt} \end{hol} -Then, both arms of the induction start with an invocation of \ml{lrw}, and the semantics of \ml{\gt\gt} allow us to merge the occurrences of \ml{lrw} above the \ml{\gt|}. +Then, both arms of the induction start with an invocation of \ml{rw}, and the semantics of \ml{\gt\gt} allow us to merge the occurrences of \ml{rw} above the \ml{\gt|}. This makes the step case entirely empty, so that when we execute the first steps of the proof we are left with only the base case to prove: \begin{session} \begin{alltt} >>_ restart(); >> e (`!m p. 0 < m ==> m divides FACT (m + p)` suffices_by metis_tac[LESS_EQ_EXISTS] >> - Induct_on `p` >> lrw[FACT, ADD_CLAUSES, DIVIDES_RMUL]); + Induct_on `p` >> rw[FACT, ADD_CLAUSES, DIVIDES_RMUL]); \end{alltt} \end{session} This means that our tactic can become @@ -599,11 +601,11 @@ This means that our tactic can become ##eval[it] `!m p. 0 < m ==> m divides FACT (m + p)` suffices_by metis_tac[LESS_EQ_EXISTS] >> Induct_on `p` >> - lrw[FACT, ADD_CLAUSES,DIVIDES_RMUL] >> + rw[FACT, ADD_CLAUSES,DIVIDES_RMUL] >> (* base case only remains *) Cases_on `m` >| [ fs[], - lrw[FACT,DIVIDES_LMUL,DIVIDES_REFL] + rw[FACT,DIVIDES_LMUL,DIVIDES_REFL] ] >>__ val tac = it; restart(); e tac; ##assert can top_thm () @@ -623,11 +625,12 @@ Thus, we can merge the two sub-cases of the base-case into a single invocation o ##eval[tac] `!m p. 0 < m ==> m divides FACT (m + p)` suffices_by metis_tac[LESS_EQ_EXISTS] >> Induct_on `p` >> - lrw[FACT, ADD_CLAUSES,DIVIDES_RMUL] >> + rw[FACT, ADD_CLAUSES,DIVIDES_RMUL] >> Cases_on `m` >> - fs[FACT,DIVIDES_RMUL,DIVIDES_REFL] + fs[FACT,DIVIDES_LMUL,DIVIDES_REFL] >>__ restart(); e tac; ##assert can top_thm() +>>__ val DIVIDES_FACT = top_thm() \end{alltt} \end{hol} @@ -655,20 +658,20 @@ Use of \ml{\gt\gt} ensures that the tactic gets applied in both branches of the \begin{session} \begin{alltt} >>_ b(); ->> e (Induct_on `n - m` >> lrw[]); +>> e (Induct_on `n - m` >> rw[]); \end{alltt} \end{session} -Looking at the first goal, we reason that if $0 = n - m$ and $m \leq n$, then $m = n$. We can prove this fact, using \ml{lrw} and add it to the hypotheses by use of the infix operator ``\ml{by}'': +Looking at the first goal, we reason that if $0 = n - m$ and $m \leq n$, then $m = n$. We can prove this fact, using \ml{rw} and add it to the hypotheses by use of the infix operator ``\ml{by}'': \begin{session} \begin{alltt} ->> e (`m = n` by lrw[]); +>> e (`m = n` by rw[]); \end{alltt} \end{session} \noindent We can now use simplification again to propagate the newly derived equality throughout the goal. \begin{session} \begin{alltt} ->> e (lrw[]); +>> e (rw[]); \end{alltt} \end{session} At this point in the previous proof we did a case analysis on $m$. @@ -680,7 +683,7 @@ Looking at the first goal, we reason that if $0 = n - m$ and $m \leq n$, then $m \mbox{\ml{`?k. m = SUC k` by }} \] But what is the tactic? -If we try \ml{lrw}, it will fail since the embedded arithmetic decision procedure doesn't handle existential statements very well. +If we try \ml{rw}, it will fail since the embedded arithmetic decision procedure doesn't handle existential statements very well. What to do? In fact, that earlier case analysis will again do the job: but now we hide it away so that it is only used to prove this sub-goal. @@ -698,7 +701,7 @@ Thus: \noindent Now the tactic we used before can finish this off: \begin{session} \begin{alltt} ->> e (lfs[FACT, DIVIDES_LMUL, DIVIDES_REFL]); +>> e (fs[FACT, DIVIDES_LMUL, DIVIDES_REFL]); \end{alltt} \end{session} That takes care of the base case. @@ -706,18 +709,17 @@ For the induction step, things look a bit more difficult than in the earlier pro However, we can make progress by realizing that the hypotheses imply that $0 < n$ and so we can transform $n$ into a successor, thus enabling the unfolding of \ml{FACT}, as in the previous proof: \begin{session} \begin{alltt} ->> e (`0 < n` by lrw[] >> `?k. n = SUC k` by (Cases_on `n` >> fs[])); +>> e (`0 < n` by rw[] >> `?k. n = SUC k` by (Cases_on `n` >> fs[])); \end{alltt} \end{session} \noindent The proof now finishes in much the same manner as the previous one: \begin{session} \begin{alltt} ->> e (lrw [FACT, DIVIDES_RMUL]); +>> e (rw [FACT, DIVIDES_RMUL]); ##assert can top_thm() \end{alltt} \end{session} -\noindent We leave the details of stitching the proof together to the interested -reader. +\noindent We leave the details of stitching the proof together to the interested reader. \section{Primality} @@ -730,35 +732,35 @@ primes are positive. These are all quite simple to prove. \item [\small{({\it NOT\_PRIME\_0\/})}] \begin{tabular}[t]{l} \verb+~prime 0+ \\ \hline -\verb+lrw[prime_def,DIVIDES_0]+ \\ +\verb+rw[prime_def,DIVIDES_0]+ \\ \end{tabular} ->>__ val NOT_PRIME_0 = prove(``~prime 0``, lrw[prime_def, DIVIDES_0]) +>>__ val NOT_PRIME_0 = prove(``~prime 0``, rw[prime_def, DIVIDES_0]) \item [\small{({\it NOT\_PRIME\_1\/})}] \begin{tabular}[t]{l} \verb+~prime 1+ \\ \hline -\verb+lrw[prime_def]+ \\ +\verb+rw[prime_def]+ \\ \end{tabular} ->>__ val NOT_PRIME_1 = prove(``~prime 1``, lrw[prime_def]) +>>__ val NOT_PRIME_1 = prove(``~prime 1``, rw[prime_def]) \item [\small{({\it PRIME\_2\/})}] \begin{tabular}[t]{l} \verb+prime 2+ \\ \hline -\verb+lrw[prime_def] >>+ \\ +\verb+rw[prime_def] >>+ \\ \verb+metis_tac [DIVIDES_LE, DIVIDES_ZERO, DECIDE ``2<>0``,+ \\ \verb+ DECIDE ``x <= 2 <=> (x=0) \/ (x=1) \/ (x=2)``]+ \\ \end{tabular} >>__ val PRIME_2 = prove(``prime 2``, - lrw[prime_def] >> + rw[prime_def] >> metis_tac[DIVIDES_LE, DIVIDES_ZERO, DECIDE ``~(2=0)``, DECIDE ``x <= 2 = (x=0) \/ (x=1) \/ (x=2)``]) \item [\small{({\it PRIME\_POS\/})}] \begin{tabular}[t]{l} \verb+!p. prime p ==> 0> lrw[NOT_PRIME_0]+ \\ +\verb+Cases >> rw[NOT_PRIME_0]+ \\ >>__ val PRIME_POS = prove( - ``!p. prime p ==> 0 < p``, Cases >> lrw[NOT_PRIME_0]) + ``!p. prime p ==> 0 < p``, Cases >> rw[NOT_PRIME_0]) \end{tabular} \end{description} @@ -782,7 +784,7 @@ or $n$. The polished tactic is the following: \begin{tabular}[t]{l} \verb+!n. ~(n = 1) ==> ?p. prime p /\ p divides n+ \\ \hline \verb+completeInduct_on `n` >>+ \\ -\verb+ lrw [] >>+ \\ +\verb+ rw [] >>+ \\ \verb+ Cases_on `prime n` >| [+ \\ \verb+ metis_tac [DIVIDES_REFL], + \\ \verb+ `?x. x divides n /\ x<>1 /\ x<>n` + \\ @@ -807,7 +809,7 @@ split. Notice that the term given to \ml{Cases\_on} need not occur in the goal: \begin{session} \begin{alltt} ->> e (lrw[] >> Cases_on `prime n`); +>> e (rw[] >> Cases_on `prime n`); \end{alltt} \end{session} \noindent As mentioned, the first case is proved with the reflexivity of @@ -848,11 +850,11 @@ Goal proved. \noindent The remaining goal can be clarified by simplification: \begin{session} \begin{alltt} ->> e (lrw[]); +>> e (rw[]); >> DIVIDES_0; ->> e (lrw[it]); +>> e (rw[it]); \end{alltt} \end{session} The two steps of exploratory simplification have led us to a state where @@ -860,6 +862,7 @@ all we have to do is exhibit a prime. And we already have one to hand: \begin{session} \begin{alltt} >> e (metis_tac [PRIME_2]); +>>__ val PRIME_FACTOR = top_thm(); \end{alltt} \end{session} Again, work now needs to be done to compose and perhaps polish a single tactic from the individual proof steps, but we will not describe it.% @@ -883,16 +886,16 @@ A HOL rendition of the proof may be given as follows: \item [\small{({\it EUCLID\/})}] \begin{tabular}[t]{l} \verb+!n. ?p. n < p /\ prime p+ \\ \hline -\verb+SPOSE_NOT_THEN STRIP_ASSUME_TAC+ \\ -\verb! THEN MP_TAC (SPEC ``FACT n + 1`` PRIME_FACTOR)! \\ -\verb+ THEN RW_TAC arith_ss [FACT_LESS, DECIDE ``~(x=0) = 0> mp_tac (SPEC ``FACT n + 1`` PRIME_FACTOR)! \\ +\verb+ >> rw[FACT_LESS, DECIDE ``~(x=0) = 0> metis_tac [NOT_PRIME_1, NOT_LESS, PRIME_POS, + \\ +\verb+ DIVIDES_FACT, DIVIDES_ADDL, DIVIDES_ONE]+ \\ \end{tabular} \end{description} Let's prise this apart and look at it in some detail. A proof by contradiction can be started by using the \ml{bossLib} function -\ml{SPOSE\_NOT\_THEN}. With it, one assumes the negation of the +\ml{spose\_not\_then}. With it, one assumes the negation of the current goal and then uses that in an attempt to prove falsity (\verb+F+). The assumed negation $\neg(\forall n.\ \exists p.\ n < p \land \mbox{\tt prime}\ p)$ is simplified a bit into $\exists n.\ @@ -901,17 +904,11 @@ passed to the tactic \ml{STRIP\_ASSUME\_TAC}. This moves its argument to the assumption list of the goal after eliminating the existential quantification on $n$. \begin{session} -\begin{verbatim} -- g `!n. ?p. n < p /\ prime p`; - -- e (SPOSE_NOT_THEN STRIP_ASSUME_TAC); -OK.. -1 subgoal: -> val it = - F - ------------------------------------ - !p. n < p ==> ~prime p -\end{verbatim} +\begin{alltt} +>>_ g `!n. ?p. n < p /\ prime p`; + +>> e (spose_not_then strip_assume_tac); +\end{alltt} \end{session} Thus we have the hypothesis that all $p$ beyond a certain unspecified $n$ are not prime, and our task is to show that this cannot be. At this @@ -925,14 +922,11 @@ formal HOL proof? Answer: by instantiating a lemma with it and bringing the lemma into the proof. The lemma and its instantiation are:\footnote{The function {\tt SPEC} implements the rule of universal specialization.} \begin{session} -\begin{verbatim} -- PRIME_FACTOR; -> val it = |- !n. ~(n = 1) ==> (?p. prime p /\ p divides n) : thm +\begin{alltt} +>> PRIME_FACTOR; -- val th = SPEC ``FACT n + 1`` PRIME_FACTOR; -> val th = - |- ~(FACT n + 1 = 1) ==> (?p. prime p /\ p divides FACT n + 1) -\end{verbatim} +>> val th = SPEC ``FACT n + 1`` PRIME_FACTOR; +\end{alltt} \end{session} It is evident that the antecedent of \ml{th} can be eliminated. In \holn{}, one could do this in a so-called {\it forward\/} proof style (by @@ -941,44 +935,26 @@ modus ponens}, the result of which can then be used in the proof), or one could bring \ml{th} into the proof and simplify it {\it in situ}. We choose the latter approach. \begin{session} -\begin{verbatim} -- e (MP_TAC (SPEC ``FACT n + 1`` PRIME_FACTOR)); -OK.. -1 subgoal: -> val it = - (~(FACT n + 1 = 1) ==> ?p. prime p /\ p divides FACT n + 1) ==> F - ------------------------------------ - !p. n < p ==> ~prime p -\end{verbatim} +\begin{alltt} +>> e (mp_tac (SPEC ``FACT n + 1`` PRIME_FACTOR)); +\end{alltt} \end{session} - The invocation \ml{MP\_TAC} ($\vdash M$) applied to a goal - $(\Delta, g)$ returns the goal $(\Delta, M \supset g)$. Now we - simplify: +The invocation \ml{mp\_tac} ($\vdash M$) applied to a goal $(\Delta, g)$ returns the goal $(\Delta, M \supset g)$. +Now we simplify: \begin{session} -\begin{verbatim} -- e (RW_TAC arith_ss []); -OK.. -2 subgoals: -> val it = - ~prime p \/ ~(p divides FACT n + 1) - ------------------------------------ - 0. !p. n < p ==> ~prime p - 1. prime p - - ~(FACT n = 0) - ------------------------------------ - !p. n < p ==> ~prime p -\end{verbatim} +\begin{alltt} +>> e (rw[]); +\end{alltt} \end{session} We recall that zero is less than every factorial, a fact found in \ml{arithmeticTheory} under the name \ml{FACT\_LESS}. Thus we can solve the top goal by simplification: \begin{session} -\begin{verbatim} -- e (RW_TAC arith_ss [FACT_LESS, DECIDE ``!x. ~(x=0) = 0 < x``]); -OK.. -Goal proved. ... -\end{verbatim} +\begin{alltt} +>>_ e (rw[FACT_LESS, DECIDE ``!x. ~(x=0) = 0 < x``]); + +Goal proved. ... +\end{alltt} \end{session} Notice the `on-the-fly' use of \verb+DECIDE+ to provide an \textit{ad hoc} rewrite. Looking at the remaining goal, one might think that our aim, to @@ -989,47 +965,21 @@ $\vdash A \imp B = \neg A \lor B$ as a rewrite rule oriented right to left by use of \ml{GSYM}.\footnote{Loosely speaking, \ml{GSYM} swaps the left and right hand sides of any equations it finds.} \begin{session} -\begin{verbatim} -- IMP_DISJ_THM; -> val it = |- !A B. A ==> B = ~A \/ B : thm - -- e (RW_TAC arith_ss [GSYM IMP_DISJ_THM]); -OK.. -1 subgoal: -> val it = - ~(p divides FACT n + 1) - ------------------------------------ - 0. !p. n < p ==> ~prime p - 1. prime p - : goalstack -\end{verbatim} +\begin{alltt} +>> IMP_DISJ_THM; + +>> e (rw[GSYM IMP_DISJ_THM]); +\end{alltt} \end{session} -We can quickly proceed to show that $p \ \mathtt{divides}\ (\mathtt{FACT}\; n)$, -and thus that $p = 1$, hence that $p$ is not prime, at which point we are done. +We can quickly proceed to show that $p \ \mathtt{divides}\ (\mathtt{FACT}\; n)$, so that if it also divides \holtxt{FACT n + 1}, then $p$ divides 1, meaning that $p = 1$. +But then $p$ is not prime, at which point we are done. This can all be packaged into a single invocation of \ml{METIS\_TAC}: \begin{session} -\begin{verbatim} -- e (METIS_TAC [DIVIDES_FACT, DIVIDES_ADDL, DIVIDES_ONE, - NOT_PRIME_1, NOT_LESS, PRIME_POS]); -metis: r[+0+12]+0+0+0+0+0+0+0+1+1+0+0+0+0+1+1+1+1+4# - -Goal proved. - [..] |- ~(p divides FACT n + 1) - -Goal proved. - [.] |- ~prime p \/ ~(p divides FACT n + 1) - -Goal proved. - [.] -|- (~(FACT n + 1 = 1) ==> ?p. prime p /\ p divides FACT n + 1) ==> F - -Goal proved. - [.] |- F -> val it = - Initial goal proved. - |- !n. ?p. n < p /\ prime p : goalstack -\end{verbatim} +\begin{alltt} +>> e (metis_tac [DIVIDES_FACT, DIVIDES_ADDL, DIVIDES_ONE, + NOT_PRIME_1, NOT_LESS, PRIME_POS]); +\end{alltt} \end{session} Euclid's theorem is now proved, and we can rest. However, this presentation of the final proof will be unsatisfactory to some, @@ -1048,19 +998,19 @@ Goal proved. \item [\small{({\it AGAIN\/})}] \begin{tabular}[t]{l} \verb+!n. ?p. n < p /\ prime p+ \\ \hline -\verb|CCONTR_TAC THEN | \\ -\verb|`?n. !p. n < p ==> ~prime p` by METIS_TAC [] THEN| \\ -\verb|`~(FACT n + 1 = 1)` by RW_TAC arith_ss [FACT_LESS,| \\ -\verb| DECIDE``~(x=0)=0> | \\ +\verb|`?n. !p. n < p ==> ~prime p` by metis_tac [] >>| \\ +\verb|`~(FACT n + 1 = 1)` by rw[FACT_LESS,| \\ +\verb| DECIDE``~(x=0)=0>| \\ \verb|`?p. prime p /\ | \\ -\verb| p divides (FACT n + 1)` by METIS_TAC [PRIME_FACTOR] THEN| \\ -\verb|`0 < p` by METIS_TAC [PRIME_POS] THEN| \\ -\verb|`p <= n` by METIS_TAC [NOT_LESS] THEN| \\ -\verb|`p divides FACT n` by METIS_TAC [DIVIDES_FACT] THEN| \\ -\verb|`p divides 1` by METIS_TAC [DIVIDES_ADDL] THEN| \\ -\verb|`p = 1` by METIS_TAC [DIVIDES_ONE] THEN| \\ -\verb|`~prime p` by METIS_TAC [NOT_PRIME_1] THEN| \\ -\verb|METIS_TAC []| \\ +\verb| p divides (FACT n + 1)` by metis_tac [PRIME_FACTOR] >>| \\ +\verb|`0 < p` by metis_tac [PRIME_POS] >>| \\ +\verb|`p <= n` by metis_tac [NOT_LESS] >>| \\ +\verb|`p divides FACT n` by metis_tac [DIVIDES_FACT] >>| \\ +\verb|`p divides 1` by metis_tac [DIVIDES_ADDL] >>| \\ +\verb|`p = 1` by metis_tac [DIVIDES_ONE] >>| \\ +\verb|`~prime p` by metis_tac [NOT_PRIME_1] >>| \\ +\verb|metis_tac []| \\ \end{tabular} \end{description} @@ -1073,14 +1023,10 @@ us to go all through the theorem-proving effort again. Even having a complete script from which it would be possible to cut-and-paste is an error-prone solution. -In order to do this we need to create a file with the name -$x$\ml{Script.sml}, where $x$ is the name of the theory we wish to -export. This file then needs to be compiled. In fact, we really do -use the Moscow ML compiler, carefully augmented with the appropriate -logical context. However, the language accepted by the compiler is -not quite the same as that accepted by the interactive system, so we -will need to do a little work to massage the original script into the -correct form. +In order to do this we need to create a file with the name $x$\ml{Script.sml}, where $x$ is the name of the theory we wish to export. +This file then needs to be compiled. +In fact, we really do use the \ML{} compiler, carefully augmented with the appropriate logical context. +However, the language accepted by the compiler is not quite the same as that accepted by the interactive system, so we will need to do a little work to massage the original script into the correct form. We'll give an illustration of converting to a form that can be compiled using the script @@ -1209,32 +1155,30 @@ understand when presented informally, a perhaps surprising amount of support development was required to set the stage for Euclid's classic argument. -\item The proof support offered by \ml{bossLib} -(\verb+RW_TAC+, \ml{METIS\_TAC}, \ml{DECIDE\_TAC}, \ml{DECIDE}, -\ml{Cases\_on}, \ml{Induct\_on}, and the ``\ml{by}'' construct) was -nearly complete for this example: it was rarely necessary to resort to +\item The proof support offered by \ml{bossLib} (\ml{rw}, \ml{metis\_tac}, \ml{DECIDE}, \ml{Cases\_on}, \ml{Induct\_on}, and the ``\ml{by}'' construct) was nearly complete for this example: it was rarely necessary to resort to lower-level tactics. \item Simplification is a workhorse tactic; even when an automated -reasoner such as \ml{METIS\_TAC} is used, its application has often been +reasoner such as \ml{metis\_tac} is used, its application has often been set up by some exploratory simplifications. It therefore pays to become familiar with the strengths and weaknesses of the simplifier. \item A common problem with interactive proof systems is dealing with -hypotheses. Often \ml{METIS\_TAC} and the ``\ml{by}'' construct allow +hypotheses. Often \ml{metis\_tac} and the ``\ml{by}'' construct allow the use of hypotheses without directly resorting to indexing into them (or naming them, which amounts to the same thing). This is desirable, since the hypotheses are notionally a {\it set}, and moreover, experience has shown that profligate indexing into hypotheses results in -hard-to-maintain proof scripts. However, it can be clumsy to work with a -large set of hypotheses, in which case the following approaches may be -useful. +hard-to-maintain proof scripts. + +We also found that we could directly simplify in the assumptions by using the \ml{fs} tactic. +Nonetheless, it can be clumsy to work with a large set of hypotheses, in which case the following approaches may be useful. One can directly refer to hypotheses by using \ml{UNDISCH\_TAC} (makes the designated hypothesis the antecedent to the goal), \ml{ASSUM\_LIST} (gives the entire hypothesis list to a tactic), -\ml{POP\_ASSUM} (gives the top hypothesis to a tactic), and -\ml{PAT\_ASSUM} (gives the first {\it matching\/} hypothesis to a +\ml{pop\_assum} (gives the top hypothesis to a tactic), and +\ml{qpat\_assum} (gives the first {\it matching\/} hypothesis to a tactic). (See the \REFERENCE{} for further details on all of these.) The numbers attached to hypotheses by the proof manager could likely be used to access hypotheses (it would be quite simple to write such a @@ -1244,12 +1188,12 @@ clarifying thing to do. In some cases, it is useful to be able to delete a hypothesis. This can be accomplished by passing the hypothesis to a tactic that ignores it. For example, to discard the top hypothesis, one could invoke -\ml{POP\_ASSUM (K ALL\_TAC)}. +\ml{pop\_assum~kall\_tac}. \item In the example, we didn't use the more advanced features of \ml{bossLib}, largely because they do not, as yet, provide much more functionality than the simple sequencing of simplification, decision -procedures, and automated first order reasoning. The \ml{THEN} +procedures, and automated first order reasoning. The \ml{\gt\gt} tactical has thus served as an adequate replacement. In the future, these entrypoints should become more powerful. @@ -1272,14 +1216,11 @@ On the other hand, one of the advantages of having a mechanized logic is that the machine can be used as a formal expression calculator, and thus the user can use it to quickly and accurately explore various proof possibilities. -\item High powered tools like \ml{METIS\_TAC}, \ml{DECIDE\_TAC}, and -\ml{RW\_TAC} are the principal way of advancing a proof in -\ml{bossLib}. In many cases, they do exactly what is desired, or even -manage to surprise the user with their power. In the formalization of -Euclid's theorem, the tools performed fairly well. However, sometimes -they are overly aggressive, or they simply flounder. In such cases, more -specialized proof tools need to be used, or even written, and hence the -support underlying \ml{bossLib} must eventually be learned. + +\item High powered tools like \ml{metis\_tac}, and \ml{rw} are the principal way of advancing a proof in \ml{bossLib}. +In many cases, they do exactly what is desired, or even manage to surprise the user with their power. +In the formalization of Euclid's theorem, the tools performed fairly well. However, sometimes they are overly aggressive, or they simply flounder. +In such cases, more specialized proof tools need to be used, or even written, and hence the support underlying \ml{bossLib} must eventually be learned. \item Having a good knowledge of the available lemmas, and where they are located, is an essential part of being successful. Often powerful diff --git a/examples/euclid.sml b/examples/euclid.sml index 066c48bf4b..0b027cb578 100644 --- a/examples/euclid.sml +++ b/examples/euclid.sml @@ -31,7 +31,7 @@ val divides_def = val prime_def = Define - `prime p = ~(p=1) /\ !x. x divides p ==> (x=1) \/ (x=p)`; + `prime p = p<>1 /\ !x. x divides p ==> (x=1) \/ (x=p)`; (*---------------------------------------------------------------------------*) (* A sequence of basic theorems about the "divides" relation. *) @@ -40,59 +40,57 @@ val prime_def = val DIVIDES_0 = store_thm ("DIVIDES_0", ``!x. x divides 0``, - METIS_TAC [divides_def,MULT_CLAUSES]); + metis_tac [divides_def,MULT_CLAUSES]); val DIVIDES_ZERO = store_thm ("DIVIDES_ZERO", ``!x. 0 divides x = (x = 0)``, - METIS_TAC [divides_def,MULT_CLAUSES]); + metis_tac [divides_def,MULT_CLAUSES]); val DIVIDES_ONE = store_thm ("DIVIDES_ONE", ``!x. x divides 1 = (x = 1)``, - METIS_TAC [divides_def,MULT_CLAUSES,MULT_EQ_1]); + metis_tac [divides_def,MULT_CLAUSES,MULT_EQ_1]); val DIVIDES_REFL = store_thm ("DIVIDES_REFL", ``!x. x divides x``, - METIS_TAC [divides_def,MULT_CLAUSES]); + metis_tac [divides_def,MULT_CLAUSES]); val DIVIDES_TRANS = store_thm ("DIVIDES_TRANS", ``!a b c. a divides b /\ b divides c ==> a divides c``, - METIS_TAC [divides_def,MULT_ASSOC]); + metis_tac [divides_def,MULT_ASSOC]); val DIVIDES_ADD = store_thm ("DIVIDES_ADD", ``!d a b. d divides a /\ d divides b ==> d divides (a + b)``, - METIS_TAC[divides_def,LEFT_ADD_DISTRIB]); + metis_tac[divides_def,LEFT_ADD_DISTRIB]); val DIVIDES_SUB = store_thm ("DIVIDES_SUB", ``!d a b. d divides a /\ d divides b ==> d divides (a - b)``, - METIS_TAC [divides_def,LEFT_SUB_DISTRIB]); + metis_tac [divides_def,LEFT_SUB_DISTRIB]); val DIVIDES_ADDL = store_thm ("DIVIDES_ADDL", ``!d a b. d divides a /\ d divides (a + b) ==> d divides b``, - METIS_TAC [ADD_SUB,ADD_SYM,DIVIDES_SUB]); + metis_tac [ADD_SUB,ADD_SYM,DIVIDES_SUB]); val DIVIDES_LMUL = store_thm ("DIVIDES_LMUL", ``!d a x. d divides a ==> d divides (x * a)``, - METIS_TAC [divides_def,MULT_ASSOC,MULT_SYM]); + metis_tac [divides_def,MULT_ASSOC,MULT_SYM]); val DIVIDES_RMUL = store_thm ("DIVIDES_RMUL", ``!d a x. d divides a ==> d divides (a * x)``, - METIS_TAC [MULT_SYM,DIVIDES_LMUL]); + metis_tac [MULT_SYM,DIVIDES_LMUL]); val DIVIDES_LE = store_thm ("DIVIDES_LE", ``!m n. m divides n ==> m <= n \/ (n = 0)``, - RW_TAC arith_ss [divides_def] - THEN Cases_on `x` - THEN RW_TAC arith_ss [MULT_CLAUSES]); + rw [divides_def] >> rw[]); (*---------------------------------------------------------------------------*) (* Various proofs of the same formula *) @@ -101,39 +99,40 @@ val DIVIDES_LE = store_thm val DIVIDES_FACT = store_thm ("DIVIDES_FACT", ``!m n. 0 < m /\ m <= n ==> m divides (FACT n)``, - RW_TAC arith_ss [LESS_EQ_EXISTS] - THEN Induct_on `p` - THEN RW_TAC arith_ss [FACT,ADD_CLAUSES] - THENL [Cases_on `m`, ALL_TAC] - THEN METIS_TAC [FACT, DECIDE ``!x. ~(x < x)``, + rw [LESS_EQ_EXISTS] + >> Induct_on `p` + >> rw [FACT,ADD_CLAUSES] + >| [Cases_on `m`, ALL_TAC] + >> metis_tac [FACT, DECIDE ``!x. ~(x < x)``, DIVIDES_RMUL, DIVIDES_LMUL, DIVIDES_REFL]); val DIVIDES_FACT = prove (``!m n. 0 < m /\ m <= n ==> m divides (FACT n)``, - RW_TAC arith_ss [LESS_EQ_EXISTS] - THEN Induct_on `p` - THEN RW_TAC arith_ss [FACT,ADD_CLAUSES] - THEN METIS_TAC [FACT, DECIDE ``!x. ~(x < x)``, num_CASES, + `!m p. 0 < m ==> m divides FACT (m + p)` + suffices_by metis_tac[LESS_EQ_EXISTS] + >> Induct_on `p` + >> rw [FACT,ADD_CLAUSES] + >> metis_tac [FACT, DECIDE ``!x. ~(x < x)``, num_CASES, DIVIDES_RMUL, DIVIDES_LMUL, DIVIDES_REFL]); val DIVIDES_FACT = prove (``!m n. 0 < m /\ m <= n ==> m divides (FACT n)``, - RW_TAC arith_ss [LESS_EQ_EXISTS] - THEN Induct_on `p` - THEN METIS_TAC [FACT, DECIDE ``!x. ~(x < x)``, num_CASES, + rw [LESS_EQ_EXISTS] + >> Induct_on `p` + >> metis_tac [FACT, DECIDE ``!x. ~(x < x)``, num_CASES, DIVIDES_RMUL,DIVIDES_LMUL,DIVIDES_REFL,ADD_CLAUSES]); val DIVIDES_FACT = prove (``!m n. 0 < m /\ m <= n ==> m divides (FACT n)``, Induct_on `n - m` - THEN RW_TAC arith_ss [] THENL - [`m = n` by DECIDE_TAC THEN - `?k. m = SUC k` by METIS_TAC[num_CASES,prim_recTheory.LESS_REFL] - THEN METIS_TAC[FACT,DIVIDES_RMUL,DIVIDES_REFL], - `0 < n` by DECIDE_TAC THEN - `?k. n = SUC k` by METIS_TAC [num_CASES,prim_recTheory.LESS_REFL] - THEN RW_TAC arith_ss [FACT, DIVIDES_RMUL]]); + >> rw [] >| + [`m = n` by rw[] >> + `?k. m = SUC k` by (Cases_on `m` >> fs[]) + >> metis_tac[FACT,DIVIDES_RMUL,DIVIDES_REFL], + `0 < n` by rw[] >> + `?k. n = SUC k` by (Cases_on `n` >> fs[]) + >> rw [FACT, DIVIDES_RMUL]]); (*---------------------------------------------------------------------------*) @@ -143,24 +142,24 @@ Induct_on `n - m` val NOT_PRIME_0 = store_thm ("NOT_PRIME_0", ``~prime 0``, - RW_TAC arith_ss [prime_def,DIVIDES_0]); + rw [prime_def,DIVIDES_0]); val NOT_PRIME_1 = store_thm ("NOT_PRIME_1", ``~prime 1``, - RW_TAC arith_ss [prime_def]); + rw [prime_def]); val PRIME_2 = store_thm ("PRIME_2", ``prime 2``, - RW_TAC arith_ss [prime_def] THEN - METIS_TAC [DIVIDES_LE, DIVIDES_ZERO, + rw [prime_def] >> + metis_tac [DIVIDES_LE, DIVIDES_ZERO, DECIDE``~(2=1) /\ ~(2=0) /\ (x<=2 = (x=0) \/ (x=1) \/ (x=2))``]); val PRIME_POS = store_thm ("PRIME_POS", ``!p. prime p ==> 0> rw [NOT_PRIME_0]); (*---------------------------------------------------------------------------*) (* Every number has a prime factor, except for 1. The proof proceeds by a *) @@ -177,22 +176,22 @@ val PRIME_FACTOR = store_thm ("PRIME_FACTOR", ``!n. ~(n = 1) ==> ?p. prime p /\ p divides n``, completeInduct_on `n` - THEN RW_TAC arith_ss [] - THEN Cases_on `prime n` THENL - [METIS_TAC [DIVIDES_REFL], - `?x. x divides n /\ ~(x=1) /\ ~(x=n)` by METIS_TAC[prime_def] THEN - METIS_TAC [LESS_OR_EQ, PRIME_2, + >> rw [] + >> Cases_on `prime n` >| + [metis_tac [DIVIDES_REFL], + `?x. x divides n /\ x<>1 /\ x<>n` by metis_tac[prime_def] >> + metis_tac [LESS_OR_EQ, PRIME_2, DIVIDES_LE, DIVIDES_TRANS, DIVIDES_0]]); (*---------------------------------------------------------------------------*) -(* In the following proof, METIS_TAC automatically considers cases on *) +(* In the following proof, metis_tac automatically considers cases on *) (* whether n is prime or not. *) (*---------------------------------------------------------------------------*) val PRIME_FACTOR = prove - (``!n. ~(n = 1) ==> ?p. prime p /\ p divides n``, - completeInduct_on `n` THEN - METIS_TAC [DIVIDES_REFL,prime_def,LESS_OR_EQ, PRIME_2, + (``!n. n<>1 ==> ?p. prime p /\ p divides n``, + completeInduct_on `n` >> + metis_tac [DIVIDES_REFL,prime_def,LESS_OR_EQ, PRIME_2, DIVIDES_LE, DIVIDES_TRANS, DIVIDES_0]); @@ -209,11 +208,11 @@ val PRIME_FACTOR = prove val EUCLID = store_thm ("EUCLID", ``!n. ?p. n < p /\ prime p``, - SPOSE_NOT_THEN STRIP_ASSUME_TAC - THEN MP_TAC (SPEC ``FACT n + 1`` PRIME_FACTOR) - THEN RW_TAC arith_ss [FACT_LESS, DECIDE ``~(x=0) = 0> mp_tac (SPEC ``FACT n + 1`` PRIME_FACTOR) + >> rw [FACT_LESS, DECIDE ``~(x=0) = 0> metis_tac [DIVIDES_FACT, DIVIDES_ADDL, DIVIDES_ONE, + NOT_PRIME_1, NOT_LESS, PRIME_POS]); (*---------------------------------------------------------------------------*) @@ -223,18 +222,16 @@ val EUCLID = store_thm (*---------------------------------------------------------------------------*) val EUCLID_AGAIN = prove (``!n. ?p. n < p /\ prime p``, -CCONTR_TAC -THEN - `?n. !p. n < p ==> ~prime p` by METIS_TAC[] THEN - `~(FACT n + 1 = 1)` by RW_TAC arith_ss [FACT_LESS, - DECIDE ``~(x=0) = 0> + `?n. !p. n < p ==> ~prime p` by metis_tac[] >> + `~(FACT n + 1 = 1)` by rw [FACT_LESS, + DECIDE ``~(x=0) = 0> `?p. prime p /\ - p divides (FACT n + 1)` by METIS_TAC [PRIME_FACTOR] THEN - `0 < p` by METIS_TAC [PRIME_POS] THEN - `p <= n` by METIS_TAC [NOT_LESS] THEN - `p divides FACT n` by METIS_TAC [DIVIDES_FACT] THEN - `p divides 1` by METIS_TAC [DIVIDES_ADDL] THEN - `p = 1` by METIS_TAC [DIVIDES_ONE] THEN - `~prime p` by METIS_TAC [NOT_PRIME_1] -THEN -METIS_TAC[]); + p divides (FACT n + 1)` by metis_tac [PRIME_FACTOR] >> + `0 < p` by metis_tac [PRIME_POS] >> + `p <= n` by metis_tac [NOT_LESS] >> + `p divides FACT n` by metis_tac [DIVIDES_FACT] >> + `p divides 1` by metis_tac [DIVIDES_ADDL] >> + `p = 1` by metis_tac [DIVIDES_ONE] >> + `~prime p` by metis_tac [NOT_PRIME_1] >> + metis_tac[]); From eb8d400f201b7ba4497e87e7e799a2ead251de29 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 28 Jan 2016 20:50:10 +1100 Subject: [PATCH 662/718] Remove more goalstack cruft in polyscripter --- Manual/Tools/expected1 | 12 ++++++++ Manual/Tools/polyscripter.sml | 53 +++++++++++++++++++++++++++++++++-- Manual/Tools/testinput1 | 3 ++ 3 files changed, 65 insertions(+), 3 deletions(-) diff --git a/Manual/Tools/expected1 b/Manual/Tools/expected1 index 99a43e257b..d66bd11608 100644 --- a/Manual/Tools/expected1 +++ b/Manual/Tools/expected1 @@ -86,3 +86,15 @@ Term`p /\bs{} q ==> r`; 3 + 4; + +> e Induct; +OK.. +2 subgoals: +val it = + +0 < SUC n \(\Rightarrow\) 0 < SUC n * SUC n +------------------------------------ + 0 < n \(\Rightarrow\) 0 < n * n + + +0 < 0 \(\Rightarrow\) 0 < 0 * 0 diff --git a/Manual/Tools/polyscripter.sml b/Manual/Tools/polyscripter.sml index 6768b17c15..5a37a17330 100644 --- a/Manual/Tools/polyscripter.sml +++ b/Manual/Tools/polyscripter.sml @@ -137,6 +137,30 @@ fun deleteTrailingWhiteSpace s = string pfx ^ term end +fun remove_multi_goalproved s = + let + val ss = Substring.full s + val (l,r) = Substring.position "\n\nGoal proved." ss + fun recurse ss = + let + val ss' = Substring.slice(ss, 1, NONE) + val (l,r) = Substring.position "\n\nGoal proved." ss' + in + if Substring.size r <> 0 then + case recurse r of NONE => SOME r | x => x + else NONE + end + in + if Substring.size r <> 0 then + case recurse r of + NONE => NONE + | SOME r' => + SOME (Substring.string l ^ !elision_string1 ^ + Substring.string (Substring.triml 1 r')) + else + NONE + end + fun cruftSuffix sfxs s = case List.find (fn (sfx,_) => String.isSuffix sfx s) sfxs of NONE => NONE @@ -148,10 +172,33 @@ val cruftySuffixes = ref [ (":\n proof\n", "\n") ] +fun try _ [] s = s + | try restart (f::fs) s = case f s of + SOME s' => restart s' + | NONE => try restart fs s + +fun remove_nsubgoals s = + let + open Substring + val ss0 = full s + val (ss,_) = splitr Char.isSpace ss0 + in + if isSuffix "subgoals" ss then + let + val (p,s) = splitr (fn c => c <> #"\n") ss + val (sn, rest) = splitl Char.isDigit s + in + if size sn <> 0 andalso string rest = " subgoals" then SOME (string p) + else NONE + end + else NONE + end + fun removeCruft s = - case cruftSuffix (!cruftySuffixes) s of - NONE => s - | SOME s' => removeCruft s' + try removeCruft [cruftSuffix (!cruftySuffixes), + remove_multi_goalproved, + remove_nsubgoals] + s fun addIndent ws = String.translate(fn #"\n" => "\n"^ws | c => str c) diff --git a/Manual/Tools/testinput1 b/Manual/Tools/testinput1 index a27f85bb43..8dea1e863e 100644 --- a/Manual/Tools/testinput1 +++ b/Manual/Tools/testinput1 @@ -49,3 +49,6 @@ bar r`; ##eval 3 + 4; + +>>__ g `!n. 0 < n ==> 0 < n * n`; +>> e Induct; From a716816f0ea06d68bc530b2ac20f4fe3075d181a Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 28 Jan 2016 20:50:32 +1100 Subject: [PATCH 663/718] More words for Euclid example --- Manual/Tutorial/euclid.stex | 48 ++++++++++++++++++------------------- 1 file changed, 23 insertions(+), 25 deletions(-) diff --git a/Manual/Tutorial/euclid.stex b/Manual/Tutorial/euclid.stex index d6f610fca4..790a11c652 100644 --- a/Manual/Tutorial/euclid.stex +++ b/Manual/Tutorial/euclid.stex @@ -34,8 +34,10 @@ prime number, we first need to define the \emph{divisibility} relation: >> val divides_def = Define`divides a b = ?x. b = a * x`; \end{alltt} \end{session} -Note how we are using ASCII notation to input our terms, but the system responds with pleasant Unicode. +Note how we are using ASCII notation to input our terms (\holtxt{?} is the ASCII way to write the existential quantifier), but the system responds with pleasant Unicode. Unicode characters can also be used in the input. +Also note how equality on booleans gets printed as the if-and-only-if arrow, while equality on natural numbers stays as an equality. +The underlying constant is the same (equality) (as is implied by the fact that one can use \holtxt{=} in both places in the input), but the system tries to be helpful when printing. The definition is added to the current theory with the name \ml{divides\_def}, and also returned from the invocation of @@ -62,6 +64,7 @@ than $1$ and itself: Define `prime p = p <> 1 /\ !x. x divides p ==> (x=1) \/ (x=p)`; \end{alltt} \end{session} +There is more ASCII syntax to observe here: \holtxt{\lt\gt} for not-equals, and \holtxt{!} for the universal quantifier. That concludes the definitions to be made. Now we ``just'' have to prove that there are infinitely many prime numbers. If we were coming to this @@ -382,13 +385,12 @@ following\footnote{This and subsequent proofs use the theorems proved \item [\small{({\it DIVIDES\_FACT\/})}] \begin{tabular}[t]{l} \verb+!m n. 0 < m /\ m <= n ==> m divides (FACT n)+ \\ \hline -\verb+rw[LESS_EQ_EXISTS] >>+ \\ -\verb!qcase_tac `m divides FACT (m + q)` >>!\\ -\verb+Induct_on `q` >>+\\ -\verb+rw[FACT,ADD_CLAUSES] >| [+ \\ -\verb+ Cases_on `m`, ALL_TAC+ \\ -\verb+] >> metis_tac [FACT, DECIDE ``!x. ~(x < x)``,+ \\ -\verb+ DIVIDES_RMUL, DIVIDES_LMUL, DIVIDES_REFL]+ \\ +\verb|`!p m. 0 < m ==> m divides (FACT (m + p))` | +\verb+ suffices_by metis_tac[LESS_EQ_EXISTS] >>+ +\verb+Induct_on `p` >>+ +\verb+rw[FACT,ADD_CLAUSES,DIVIDES_RMUL] >>+ +\verb+Cases_on `m` >>+ +\verb+fs[FACT,DIVIDES_LMUL,DIVIDES_REFL]+\\ \end{tabular} \end{description} We will examine this proof in detail, so we should first attempt to understand why the theorem is true. @@ -487,7 +489,7 @@ definitions of addition and factorial: >> e (rw [FACT, ADD_CLAUSES]); \end{alltt} \end{session} -\noindent And now, by \ml{DIVIDES\_LMUL} and the inductive hypothesis, we are +\noindent And now, by \ml{DIVIDES\_RMUL} and the inductive hypothesis, we are done: \begin{session} \begin{alltt} @@ -554,7 +556,7 @@ tactic: rw[FACT, DIVIDES_LMUL, DIVIDES_REFL] ], rw[FACT, ADD_CLAUSES] >> rw[DIVIDES_RMUL] - ]) + ]); ##assert can top_thm () \end{alltt} \end{session} @@ -599,7 +601,7 @@ This means that our tactic can become \begin{hol} \begin{alltt} ##eval[it] `!m p. 0 < m ==> m divides FACT (m + p)` - suffices_by metis_tac[LESS_EQ_EXISTS] >> + suffices_by metis_tac[LESS_EQ_EXISTS] >> Induct_on `p` >> rw[FACT, ADD_CLAUSES,DIVIDES_RMUL] >> (* base case only remains *) @@ -611,7 +613,6 @@ This means that our tactic can become ##assert can top_thm () \end{alltt} \end{hol} - In the base case, we have two invocations of the simplifier under the case-split on \holtxt{m}. In general, the two different simplifier invocations do slightly different things in addition to simplifying the conclusion of the goal: \begin{itemize} @@ -842,26 +843,25 @@ transitivity of divisibility to get the fact that this divisor of $x$ is also a divisor of $n$, thus finishing this branch of the proof: \begin{session} \begin{alltt} ->>_ e (metis_tac [DIVIDES_TRANS]); - -Goal proved. +>> e (metis_tac [DIVIDES_TRANS]); \end{alltt} \end{session} \noindent The remaining goal can be clarified by simplification: \begin{session} \begin{alltt} >> e (rw[]); - +\end{alltt} +\end{session} +We know that everything divides 0: +\begin{session} +\begin{alltt} >> DIVIDES_0; - ->> e (rw[it]); \end{alltt} \end{session} -The two steps of exploratory simplification have led us to a state where -all we have to do is exhibit a prime. And we already have one to hand: +So any prime will do for \holtxt{p}. \begin{session} \begin{alltt} ->> e (metis_tac [PRIME_2]); +>> e (metis_tac [PRIME_2, DIVIDES_0]); >>__ val PRIME_FACTOR = top_thm(); \end{alltt} \end{session} @@ -900,7 +900,7 @@ current goal and then uses that in an attempt to prove falsity (\verb+F+). The assumed negation $\neg(\forall n.\ \exists p.\ n < p \land \mbox{\tt prime}\ p)$ is simplified a bit into $\exists n.\ \forall p.\ n < p \supset \, \neg \,\mbox{\tt prime}\ p$ and then is -passed to the tactic \ml{STRIP\_ASSUME\_TAC}. This moves its argument +passed to the tactic \ml{strip\_assume\_tac}. This moves its argument to the assumption list of the goal after eliminating the existential quantification on $n$. \begin{session} @@ -951,9 +951,7 @@ Now we simplify: solve the top goal by simplification: \begin{session} \begin{alltt} ->>_ e (rw[FACT_LESS, DECIDE ``!x. ~(x=0) = 0 < x``]); - -Goal proved. ... +>> e (rw[FACT_LESS, DECIDE ``!x. ~(x=0) = 0 < x``]); \end{alltt} \end{session} Notice the `on-the-fly' use of \verb+DECIDE+ to provide an \textit{ad hoc} From ee02e6c234c5fa7072ac6c0d24b1afbd438b9b5b Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 28 Jan 2016 20:52:38 +1100 Subject: [PATCH 664/718] Polyscripter dies cleanly if it can't open umap file --- Manual/Tools/polyscripter.sml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Manual/Tools/polyscripter.sml b/Manual/Tools/polyscripter.sml index 5a37a17330..11560ff293 100644 --- a/Manual/Tools/polyscripter.sml +++ b/Manual/Tools/polyscripter.sml @@ -348,7 +348,7 @@ end fun read_umap fname = let - val instrm = TextIO.openIn fname + val instrm = TextIO.openIn fname handle _ => die ("Couldn't open "^fname) fun recurse (i, acc) = case TextIO.inputLine instrm of SOME line => From 3b6b1dc569ae7b94a3d33afdc2a010b8b1ca90df Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 28 Jan 2016 20:53:52 +1100 Subject: [PATCH 665/718] Use polyscripter for combinatory logic chapter --- Manual/Tutorial/.gitignore | 1 + Manual/Tutorial/Holmakefile | 3 +++ Manual/Tutorial/{combin.tex => combin.stex} | 0 3 files changed, 4 insertions(+) rename Manual/Tutorial/{combin.tex => combin.stex} (100%) diff --git a/Manual/Tutorial/.gitignore b/Manual/Tutorial/.gitignore index 3d9033624e..7253340765 100644 --- a/Manual/Tutorial/.gitignore +++ b/Manual/Tutorial/.gitignore @@ -1,3 +1,4 @@ euclid.tex parity.tex ml.tex +combin.tex diff --git a/Manual/Tutorial/Holmakefile b/Manual/Tutorial/Holmakefile index e01ff41203..32d535d511 100644 --- a/Manual/Tutorial/Holmakefile +++ b/Manual/Tutorial/Holmakefile @@ -11,3 +11,6 @@ parity.tex: parity.stex ../Tools/umap ../Tools/polyscripter ml.tex: ml.stex ../Tools/umap ../Tools/polyscripter ../Tools/polyscripter ../Tools/umap < $< > $@ + +combin.tex: combin.stex ../Tools/umap ../Tools/polyscripter + ../Tools/polyscripter ../Tools/umap < $< > $@ diff --git a/Manual/Tutorial/combin.tex b/Manual/Tutorial/combin.stex similarity index 100% rename from Manual/Tutorial/combin.tex rename to Manual/Tutorial/combin.stex From 8084d16d8ac6c4a02b3cc551870ffb87616f3a98 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 29 Jan 2016 14:26:27 +1100 Subject: [PATCH 666/718] Fix for changes to lcsymtacs' short simp tactics --- .../multiword/multiwordScript.sml | 238 +++++++++--------- 1 file changed, 119 insertions(+), 119 deletions(-) diff --git a/examples/machine-code/multiword/multiwordScript.sml b/examples/machine-code/multiword/multiwordScript.sml index 9435e5856b..63bd1a7fa6 100644 --- a/examples/machine-code/multiword/multiwordScript.sml +++ b/examples/machine-code/multiword/multiwordScript.sml @@ -1491,22 +1491,22 @@ val d_lemma3 = store_thm ("d_lemma3", w2n (calc_d (FST(v1,d),1w:'a word)) * w2n (FST (v1,d)) < dimword(:'a)``, HO_MATCH_MP_TAC calc_d_ind >> REPEAT strip_tac >> - rw[Once calc_d_def,w2n_lt] >> + srw_tac[][Once calc_d_def,w2n_lt] >> ASSUME_TAC d_lemma1 >> - RES_TAC >> fs[FST,SND] >> - `2w = 1w*2w` by rw[] >> + RES_TAC >> full_simp_tac (srw_ss())[FST,SND] >> + `2w = 1w*2w` by srw_tac[][] >> `calc_d (2w * d,2w) = 2w * (calc_d (2w * d,1w))` by METIS_TAC[] >> POP_ASSUM (fn x => REWRITE_TAC[x]) >> Q.PAT_ABBREV_TAC` X = calc_d (2w * d,1w)` >> - fs[word_mul_def] >> - Cases_on `dimword(:'a) = 2` THEN1 fs[] >> + full_simp_tac (srw_ss())[word_mul_def] >> + Cases_on `dimword(:'a) = 2` THEN1 full_simp_tac (srw_ss())[] >> ASSUME_TAC ONE_LT_dimword >> `2 < dimword(:'a)` by DECIDE_TAC >> `2 MOD dimword(:'a) = 2` by METIS_TAC[LESS_MOD] >> - POP_ASSUM (fn x => fs[x]) >> + POP_ASSUM (fn x => full_simp_tac (srw_ss())[x]) >> `w2n d < dimword(:'a) DIV 2` by METIS_TAC[d_word_msb,NOT_LESS_EQUAL] >> `0 < 2` by DECIDE_TAC >> `(2 * w2n d) < dimword(:'a)` by METIS_TAC[MULT_COMM,DIV_thm3,LESS_LESS_EQ_TRANS,LT_MULT_RCANCEL] >> - `(2 * w2n d) MOD dimword(:'a) = (2 * w2n d)` by rw[LESS_MOD] >> POP_ASSUM (fn x => fs[x]) >> + `(2 * w2n d) MOD dimword(:'a) = (2 * w2n d)` by srw_tac[][LESS_MOD] >> POP_ASSUM (fn x => full_simp_tac (srw_ss())[x]) >> `(2 * w2n X) * w2n d < dimword(:'a)` by RW_TAC arith_ss[] >> METIS_TAC[MOD_LESS_EQ,ZERO_LT_dimword,LESS_EQ_LESS_TRANS,LESS_MONO_MULT]); @@ -1514,38 +1514,38 @@ val d_lemma4 = store_thm ("d_lemma4", ``!(v1:'a word) (d:'a word). ?n. w2n (calc_d (FST(v1,d),1w)) = 2 ** n``, - HO_MATCH_MP_TAC calc_d_ind >> REPEAT strip_tac >> rw[Once calc_d_def] >> RES_TAC >> - fs[FST] >> - `2w = 1w * 2w` by rw[] >> + HO_MATCH_MP_TAC calc_d_ind >> REPEAT strip_tac >> srw_tac[][Once calc_d_def] >> RES_TAC >> + full_simp_tac (srw_ss())[FST] >> + `2w = 1w * 2w` by srw_tac[][] >> `calc_d (2w * d,2w) = calc_d (2w * d,1w) * 2w` by METIS_TAC[d_lemma1,FST,SND] >> - POP_ASSUM (fn x => REWRITE_TAC[x]) >> rw[word_mul_def] >> + POP_ASSUM (fn x => REWRITE_TAC[x]) >> srw_tac[][word_mul_def] >> REWRITE_TAC[dimword_def] >> ASSUME_TAC dimword_def >> Q.PAT_ABBREV_TAC `m = dimindex(:'a)` >> markerLib.RM_ABBREV_TAC "m" >> Cases_on `m = 1` THEN1 ( `w2n d < 1` by METIS_TAC[d_word_msb,NOT_LESS_EQUAL,EVAL ``2 ** 1 DIV 2``] >> `w2n d = 0` by DECIDE_TAC >> METIS_TAC[w2n_eq_0]) >> Cases_on `m` THEN1 METIS_TAC[EXP,ONE_LT_dimword,prim_recTheory.LESS_NOT_EQ] >> - `2 < dimword(:'a)` by rw[] THEN1( + `2 < dimword(:'a)` by srw_tac[][] THEN1( Cases_on `n'` THEN1 DECIDE_TAC >> - rw[EXP] >> METIS_TAC[LE_MULT_CANCEL_LBARE,ZERO_LT_EXP,DECIDE ``0 < 2 /\ 1 < 2``, LESS_LESS_EQ_TRANS] ) >> + srw_tac[][EXP] >> METIS_TAC[LE_MULT_CANCEL_LBARE,ZERO_LT_EXP,DECIDE ``0 < 2 /\ 1 < 2``, LESS_LESS_EQ_TRANS] ) >> qpat_assum `dimword(:'a) = xxx` (fn x => REWRITE_TAC [GSYM x] \\ (ASSUME_TAC x)) >> - rw[LESS_MOD,DECIDE ``2 ** n * 2 = 2 * 2 ** n``,GSYM EXP] >> + srw_tac[][LESS_MOD,DECIDE ``2 ** n * 2 = 2 * 2 ** n``,GSYM EXP] >> `SUC n < SUC n'` by ASSUME_TAC (Q.SPECL [`(2w:'a word)*(d:'a word)`,`x`] d_lemma3) THEN1( - qpat_assum `2 < xxx` (fn x => fs[FST] \\ ASSUME_TAC x) >> + qpat_assum `2 < xxx` (fn x => full_simp_tac (srw_ss())[FST] \\ ASSUME_TAC x) >> qsuff_tac `w2n (calc_d (2w * d, 1w)) < dimword(:'a) DIV 2` THEN1 (strip_tac >> - `dimword(:'a) DIV 2 = 2 ** SUC n' DIV 2 ** 1` by rw[] >> + `dimword(:'a) DIV 2 = 2 ** SUC n' DIV 2 ** 1` by srw_tac[][] >> `dimword(:'a) DIV 2 = 2 ** n'` by METIS_TAC[SUC_SUB1,EXP_SUB,DECIDE ``(0 < 2) /\ (1 <= SUC n')`` ] >> - ` 2 ** n < 2 ** n'` by METIS_TAC[] >> fs[]) >> - `w2n (2w * d) = 2 * w2n d` by rw[word_mul_def] THEN1 ( + ` 2 ** n < 2 ** n'` by METIS_TAC[] >> full_simp_tac (srw_ss())[]) >> + `w2n (2w * d) = 2 * w2n d` by srw_tac[][word_mul_def] THEN1 ( `w2n d < dimword(:'a) DIV 2` by METIS_TAC[d_word_msb,NOT_LESS_EQUAL] >> `0 < 2` by DECIDE_TAC >> METIS_TAC[MULT_COMM,DIV_thm3,LESS_LESS_EQ_TRANS,LT_MULT_RCANCEL]) >> - POP_ASSUM (fn x => fs[x,EXP]) >> POP_ASSUM (K ALL_TAC) >> + POP_ASSUM (fn x => full_simp_tac (srw_ss())[x,EXP]) >> POP_ASSUM (K ALL_TAC) >> POP_ASSUM (fn x => ASSUME_TAC (RW [DECIDE ``a*(b*c) = a*c*b``] x)) >> `0 < w2n d` by METIS_TAC[NOT_0w_bis] >> - ONCE_REWRITE_TAC[MULT_COMM] >> rw[MULT_DIV] >> + ONCE_REWRITE_TAC[MULT_COMM] >> srw_tac[][MULT_DIV] >> METIS_TAC[LE_MULT_CANCEL_LBARE,LESS_EQ_LESS_TRANS,MULT_COMM,EQ_M_R_S_i,EXP_BASE_LT_MONO,DECIDE ``1 < 2``]) >> - IMP_RES_TAC TWOEXP_MONO >> rw[LESS_MOD]); + IMP_RES_TAC TWOEXP_MONO >> srw_tac[][LESS_MOD]); val d_lemma5 = store_thm ("d_lemma5", ``!(v1:'a word) (d:'a word). @@ -1555,7 +1555,7 @@ val d_lemma5 = store_thm ("d_lemma5", REPEAT strip_tac >> REWRITE_TAC[dimword_def] >> ASSUME_TAC dimword_def >> Q.PAT_ABBREV_TAC `m = dimindex(:'a)` >> markerLib.RM_ABBREV_TAC "m" >> ASSUME_TAC (Q.SPECL [`v1:'a word`, `d:'a word`] d_lemma4) >> - fs[] >> + full_simp_tac (srw_ss())[] >> `n < m` by METIS_TAC[EXP_BASE_LT_MONO,DECIDE ``1 < 2``,w2n_lt] >> `?p. m = n + p` by METIS_TAC[LESS_EQ_EXISTS,LESS_IMP_LESS_OR_EQ] >> `w2n v1 * 2 ** n < 2 ** p * 2 ** n` by METIS_TAC[d_lemma3,FST,EXP_ADD,MULT_COMM] >> @@ -1600,18 +1600,18 @@ val d_clauses = store_thm( "d_clauses", DECIDE_TAC) >> `mw2n X = w2n (calc_d (v1,1w)) * mw2n (REVERSE (v1::vs))` by METIS_TAC[mw_mul_by_single_lemma,Abbr`X`] >> POP_ASSUM (fn x => REWRITE_TAC[x]) >> - rw[mw2n_msf,LEFT_ADD_DISTRIB] >> + srw_tac[][mw2n_msf,LEFT_ADD_DISTRIB] >> REWRITE_TAC[DECIDE ``a*b + a * (c * d) = a*d*c + a*b``] >> - `v1 <> 0w` by (Cases_on `v1 = 0w` >> fs[]) >> - `!(a:'a word) (b:'a word).w2n (a * b) <= w2n a * w2n b` by rw[word_mul_def,MOD_LESS_EQ] >> + `v1 <> 0w` by (Cases_on `v1 = 0w` >> full_simp_tac (srw_ss())[]) >> + `!(a:'a word) (b:'a word).w2n (a * b) <= w2n a * w2n b` by srw_tac[][word_mul_def,MOD_LESS_EQ] >> METIS_TAC[d_lemma2,FST,LESS_MONO_MULT,LESS_EQ_ADD,LESS_EQ_TRANS]) >> MATCH_MP_TAC mw2n_msf_NIL >> strip_tac THEN1 METIS_TAC[] >> - rw[rich_listTheory.LENGTH_BUTLAST] >> + srw_tac[][rich_listTheory.LENGTH_BUTLAST] >> markerLib.UNABBREV_TAC "X" >> REWRITE_TAC[mw_mul_by_single_lemma,GSYM ADD1,prim_recTheory.PRE] >> Q.PAT_ABBREV_TAC `Z = w2n (calc_d (v1,1w))` >> Cases_on `Z = 1` THEN1 METIS_TAC[mw2n_lt,DECIDE``1*x = x``] >> - fs[mw2n_msf,LEFT_ADD_DISTRIB] >> + full_simp_tac (srw_ss())[mw2n_msf,LEFT_ADD_DISTRIB] >> REWRITE_TAC[DECIDE ``x*y + x*(z*w) = x*w*z + x*y``,EXP] >> Q.PAT_ABBREV_TAC `Y = Z * w2n v1 * dimwords (LENGTH vs) (:'a)` >> Cases_on `v1 = 0w` THEN1 METIS_TAC[word_0_n2w,DECIDE ``~(0<0)``] >> @@ -1623,7 +1623,7 @@ val d_clauses = store_thm( "d_clauses", markerLib.UNABBREV_TAC "Y" >> REWRITE_TAC[dimwords_SUC,DECIDE ``z*v*l + z*l = z*(v+1)*l``,DECIDE ``x * dimword(:'a) = dimword(:'a) * x``] >> MATCH_MP_TAC LESS_MONO_MULT >> METIS_TAC[Abbr`Z`,ADD1,d_lemma5,FST,MULT_COMM]) >> - Cases_on `v1 = 0w` THEN1 fs[] >> METIS_TAC[d_lemma2_bis,FST,NOT_0w_bis]) + Cases_on `v1 = 0w` THEN1 full_simp_tac (srw_ss())[] >> METIS_TAC[d_lemma2_bis,FST,NOT_0w_bis]) val LAST_FRONT_mw_mul_by_single_NOT_ZERO = store_thm( "LAST_FRONT_mw_mul_by_single_NOT_ZERO", @@ -1671,8 +1671,8 @@ val single_div_thm = store_thm ( "single_div_thm", ==> ((w2n q = (w2n x1 * dimword(:'a) + w2n x2) DIV w2n y) /\ (w2n r = (w2n x1 * dimword(:'a) + w2n x2) MOD w2n y)))``, - lrw [single_div_def] >> fs [] >> lrw[w2n_n2w] >> - `!w. w <> 0w ==> 0 < w2n w` by (Cases_on `w`>> fs [] >> DECIDE_TAC) >> + lrw[single_div_def] >> full_simp_tac (srw_ss()) [] >> lrw[w2n_n2w] >> + `!w. w <> 0w ==> 0 < w2n w` by (Cases_on `w`>> full_simp_tac (srw_ss()) [] >> DECIDE_TAC) >> `w2n y < dimword(:'a)` by lrw[w2n_lt] >> METIS_TAC[MOD_LESS,LESS_TRANS] ); @@ -1682,8 +1682,8 @@ val single_div_thm_bis = store_thm ( "single_div_thm_bis", (w2n q * w2n y + w2n r = w2n x1 * dimword(:'a) + w2n x2)``, REPEAT strip_tac >> IMP_RES_TAC single_div_lemma1 >> - qpat_assum `!xs. xxx` (fn x => (ASSUME_TAC (RW [Once ADD_COMM,Once MULT_COMM] (SPEC ``x2:'a word`` x)))) >> - Cases_on `y = 0w` THEN1 fs[word_0_n2w] >> + qpat_assum `!xs. xxx` (fn x => (ASSUME_TAC (RW[Once ADD_COMM,Once MULT_COMM] (SPEC ``x2:'a word`` x)))) >> + Cases_on `y = 0w` THEN1 full_simp_tac (srw_ss())[word_0_n2w] >> IMP_RES_TAC single_div_thm >> `0 < w2n y` by DECIDE_TAC >> METIS_TAC[DIVISION]); @@ -1710,24 +1710,24 @@ val mw_div_by_single_thm = store_thm ( "mw_div_by_single_thm", HO_MATCH_MP_TAC mw_div_by_single_ind >> REPEAT strip_tac -THEN1 (rw[Once mw_div_by_single_def] >> rw[mw_div_by_single_def,mw_mul_by_single_def,mw_mul_pass_def,mw2n_def]) -THEN1 (rw[single_div_def,mw_mul_by_single_lemma,mw_div_by_single_def,mw2n_def] >> +THEN1 (srw_tac[][Once mw_div_by_single_def] >> srw_tac[][mw_div_by_single_def,mw_mul_by_single_def,mw_mul_pass_def,mw2n_def]) +THEN1 (srw_tac[][single_div_def,mw_mul_by_single_lemma,mw_div_by_single_def,mw2n_def] >> METIS_TAC[MULT_COMM,DIVISION,w2n_lt,LESS_MOD,MOD_LESS_EQ,DIV_LESS_EQ,LESS_EQ_LESS_TRANS]) >> Cases_on `(w2n x1 < w2n y \/ (w2n y = 0))` >> Q.PAT_ABBREV_TAC `rxs = REVERSE (x1::x2::xs)` >> -rw[Once mw_div_by_single_def] -THENL [ALL_TAC,fs[],ALL_TAC] +srw_tac[][Once mw_div_by_single_def] +THENL [ALL_TAC,full_simp_tac (srw_ss())[],ALL_TAC] THEN1 (`(mw2n (REVERSE (r::xs)) = mw2n (mw_mul_by_single y (REVERSE (FRONT (mw_div_by_single (r::xs) y)))) + w2n (LAST (mw_div_by_single (r::xs) y)))` by METIS_TAC[] >> REPEAT (qpat_assum `!q r. xxx` (K ALL_TAC)) >> - rw[Once mw_div_by_single_def] >> + srw_tac[][Once mw_div_by_single_def] >> `w2n r < w2n y` by ALL_TAC - THEN1 ( fs[single_div_def] >> + THEN1 ( full_simp_tac (srw_ss())[single_div_def] >> qpat_assum `xxx=r` (fn x => REWRITE_TAC[GSYM x]) >> - rw[w2n_n2w] >> + srw_tac[][w2n_n2w] >> METIS_TAC[LESS_EQ_LESS_TRANS,MOD_LESS_EQ,MOD_LESS,ZERO_LT_dimword]) >> `mw_div_by_single (r::xs) y <> []` by METIS_TAC[mw_div_by_single_LENGTH,NOT_NIL_EQ_LENGTH_NOT_0,DECIDE ``0 < SUC n``] >> - rw[LAST_DEF,FRONT_DEF,mw2n_msf,mw_mul_by_single_lemma] >> + srw_tac[][LAST_DEF,FRONT_DEF,mw2n_msf,mw_mul_by_single_lemma] >> `mw2n rxs = mw2n (REVERSE (r::xs)) + w2n q * w2n y * dimwords (LENGTH xs) (:'a)` by ALL_TAC THEN1(markerLib.UNABBREV_TAC "rxs" >> qpat_assum `mw2n (REVERSE xx) = yy` (K ALL_TAC) >> @@ -1751,12 +1751,12 @@ THEN1 (markerLib.UNABBREV_TAC "rxs" >> THEN1 (IMP_RES_TAC single_div_thm_bis >> ASSUME_TAC word_0_n2w >> FULL_SIMP_TAC arith_ss []) >> RW_TAC arith_ss[]) >> -`(mw_div_by_single (x1::x2::xs) y) = q::mw_div_by_single (r::x2::xs) y` by rw[Once mw_div_by_single_def] >> +`(mw_div_by_single (x1::x2::xs) y) = q::mw_div_by_single (r::x2::xs) y` by srw_tac[][Once mw_div_by_single_def] >> POP_ASSUM (fn x => REWRITE_TAC[x]) >> `w2n r < w2n y` by ALL_TAC -THEN1 ( fs[single_div_def] >> +THEN1 ( full_simp_tac (srw_ss())[single_div_def] >> qpat_assum `xxx=r` (fn x => REWRITE_TAC[GSYM x]) >> - rw[w2n_n2w] >> + srw_tac[][w2n_n2w] >> METIS_TAC[LESS_EQ_LESS_TRANS,MOD_LESS_EQ,MOD_LESS,ZERO_LT_dimword]) >> `mw_div_by_single (r::x2::xs) y <> []` by METIS_TAC[mw_div_by_single_LENGTH,NOT_NIL_EQ_LENGTH_NOT_0,DECIDE ``0 < SUC n``] >> @@ -1777,7 +1777,7 @@ val mw_div_by_single_thm_bis = store_thm ("mw_div_by_single_thm_bis", POP_ASSUM (fn x => ASSUME_TAC (Q.SPECL [`xs:'a word list`] x)) >> FULL_SIMP_TAC std_ss [mw_mul_by_single_lemma] >> ONCE_REWRITE_TAC[MULT_COMM] >> - rw[MOD_TIMES,ADD_DIV_ADD_DIV] >> + srw_tac[][MOD_TIMES,ADD_DIV_ADD_DIV] >> MATCH_MP_TAC ((fn (x,y) => y) (EQ_IMP_RULE (SPEC_ALL EQ_ADDL))) >> MATCH_MP_TAC LESS_DIV_EQ_ZERO >> METIS_TAC[]) >> @@ -1786,16 +1786,16 @@ val mw_div_by_single_thm_bis = store_thm ("mw_div_by_single_thm_bis", THEN1 lrw[mw_div_by_single_def] THEN1( lrw[mw_div_by_single_def,single_div_def] >> METIS_TAC[MOD_LESS,LESS_EQ_LESS_TRANS,MOD_LESS_EQ,ZERO_LT_dimword]) >> - rw[Once mw_div_by_single_def] + srw_tac[][Once mw_div_by_single_def] THENL[Q.PAT_ABBREV_TAC `w = r::xs`,METIS_TAC[word_0_n2w,NOT_ZERO_LT_ZERO],Q.PAT_ABBREV_TAC `w = r::x2::xs`] >> `w2n r < w2n y` by ( FULL_SIMP_TAC std_ss [single_div_def] >> POP_ASSUM (fn x => REWRITE_TAC[GSYM x]) >> - rw[] >> + srw_tac[][] >> METIS_TAC[MOD_LESS,LESS_EQ_LESS_TRANS,MOD_LESS_EQ,ZERO_LT_dimword]) >> `mw_div_by_single w y <> []` by METIS_TAC[DECIDE ``0 < SUC x``,NOT_NIL_EQ_LENGTH_NOT_0,mw_div_by_single_LENGTH] >> markerLib.UNABBREV_TAC "w" >> - rw[listTheory.LAST_CONS_cond,word_0_n2w] >> + srw_tac[][listTheory.LAST_CONS_cond,word_0_n2w] >> METIS_TAC[w2n_eq_0]) val mw_simple_div_lemma = prove( @@ -1867,7 +1867,7 @@ val mw_div_range1 = store_thm("mw_div_range1", Cases_on `Q < (dimword(:'a) - 1)` >> lrw[MIN_DEF] >> markerLib.UNABBREV_TAC"X">> `0 < mw2n (REVERSE (v1::vs))` by - (fs[mw2n_msf] >> METIS_TAC[dimwords_dimword,ZERO_LT_dimword,ZERO_LT_EXP,LE_MULT_CANCEL_LBARE,LESS_LESS_EQ_TRANS,ADD_COMM,LESS_EQ_ADD,LESS_EQ_TRANS]) >> + (full_simp_tac (srw_ss())[mw2n_msf] >> METIS_TAC[dimwords_dimword,ZERO_LT_dimword,ZERO_LT_EXP,LE_MULT_CANCEL_LBARE,LESS_LESS_EQ_TRANS,ADD_COMM,LESS_EQ_ADD,LESS_EQ_TRANS]) >> MATCH_MP_TAC DIV_thm5 >> strip_tac THEN1 DECIDE_TAC >> markerLib.UNABBREV_TAC "Q" >> Q.PAT_ABBREV_TAC`a=(w2n u1) * dimword(:'a) + w2n u2`>> @@ -1875,7 +1875,7 @@ val mw_div_range1 = store_thm("mw_div_range1", Q.PAT_ABBREV_TAC`V1= w2n v1` >> Q.PAT_ABBREV_TAC`U1 = w2n u1` >> Q.PAT_ABBREV_TAC`U2 = w2n u2` >> - fs[] >> + full_simp_tac (srw_ss())[] >> `a + 1 <= V1 + a DIV V1 * V1` by METIS_TAC[DIV_thm4,LESS_MONO_ADD,DIV_thm3,SUB_ADD,LESS_EQ,ADD1] >> Q.PAT_ABBREV_TAC`q=a DIV V1` >> @@ -1916,7 +1916,7 @@ val mw_div_range2 = store_thm( "mw_div_range2", qpat_assum `~x` (ASSUME_TAC o (fn x => (MP ((fn (x,y)=>x) (EQ_IMP_RULE (Q.SPECL [`q'`,`q+2`] NOT_LESS_EQUAL))) x))) >> Cases_on `LENGTH us = LENGTH vs` THEN1( Cases_on `q < dimword(:'a)` - THEN1( rw[] >> REWRITE_TAC [NOT_LESS_EQUAL] >> + THEN1( srw_tac[][] >> REWRITE_TAC [NOT_LESS_EQUAL] >> `3 <= q' - q` by METIS_TAC[SUB_LEFT_LESS,ADD_COMM,LESS_EQ,DECIDE ``3 = SUC 2``] >> Q.PAT_ABBREV_TAC`b = dimword(:'a)` >> REWRITE_TAC[HD] >> Cases_on `0 < w2n v1` @@ -1925,19 +1925,19 @@ val mw_div_range2 = store_thm( "mw_div_range2", `0 < V` by (lrw[Abbr`V`,Abbr`a`,mw2n_msf,dimwords_dimword] >> METIS_TAC[ADD_COMM,MULT_COMM,LESS_EQ_ADD,LE_MULT_CANCEL_LBARE,LESS_EQ_TRANS,LESS_LESS_EQ_TRANS]) >> `b ** (LENGTH vs ) <= V` by (lrw[Abbr`V`,mw2n_msf,LENGTH_REVERSE,dimwords_dimword] >> METIS_TAC[LE_MULT_CANCEL_LBARE,LESS_EQ_ADD,ADD_COMM,LESS_EQ_TRANS]) >> Cases_on `V = b ** (LENGTH vs)` - THEN1( `V = mw2n ((REVERSE vs)++[v1])` by fs[] >> - qpat_assum `V = mw2n xxx` (fn x => (ASSUME_TAC (RW [mw2n_msf,LENGTH_REVERSE,dimwords_dimword] x))) >> + THEN1( `V = mw2n ((REVERSE vs)++[v1])` by full_simp_tac (srw_ss())[] >> + qpat_assum `V = mw2n xxx` (fn x => (ASSUME_TAC (RW[mw2n_msf,LENGTH_REVERSE,dimwords_dimword] x))) >> `b ** LENGTH vs * w2n v1 <= V` by METIS_TAC[ADD_COMM,LESS_EQ_ADD] >> `0 < b ** LENGTH vs` by METIS_TAC[ZERO_LT_EXP,Abbr`b`,ZERO_LT_dimword] >> `a <= 1` by METIS_TAC[Abbr`a`,LE_MULT_CANCEL_RBARE,NOT_ZERO_LT_ZERO] >> `a = 1` by DECIDE_TAC >> - `U = mw2n (REVERSE us) + V*(w2n u2) + V*b*(w2n u1)` by fs[MULT_COMM,Abbr`b`,Abbr`U`,LENGTH_REVERSE,mw2n_msf,dimwords_dimword,GSYM ADD1,EXP] >> + `U = mw2n (REVERSE us) + V*(w2n u2) + V*b*(w2n u1)` by full_simp_tac (srw_ss())[MULT_COMM,Abbr`b`,Abbr`U`,LENGTH_REVERSE,mw2n_msf,dimwords_dimword,GSYM ADD1,EXP] >> qpat_assum `U = xxx` (fn x => ASSUME_TAC(RW[GSYM MULT_ASSOC,GSYM ADD_ASSOC,GSYM LEFT_ADD_DISTRIB] x)) >> `mw2n (REVERSE us) < V` by METIS_TAC[mw2n_lt,dimwords_dimword,Abbr`b`,LENGTH_REVERSE] >> `q = w2n u1 * b + w2n u2` by METIS_TAC[RIGHT_ADD_DISTRIB,DIV_MULT,ADD_COMM,MULT_COMM] >> - `q' = MIN (b-1) q` by fs[MIN_COMM] >> + `q' = MIN (b-1) q` by full_simp_tac (srw_ss())[MIN_COMM] >> `~(b - 1 < q)` by DECIDE_TAC >> - `q' = q` by fs[MIN_DEF] >> + `q' = q` by full_simp_tac (srw_ss())[MIN_DEF] >> RW_TAC arith_ss [] ) >> `b ** (LENGTH vs) < V` by DECIDE_TAC >> qpat_assum `xxx <> yyy` (fn x => ALL_TAC) >> @@ -1953,13 +1953,13 @@ val mw_div_range2 = store_thm( "mw_div_range2", `q' * (a * l) <= (w2n u1 * b + w2n u2) * l` by METIS_TAC[MULT_ASSOC,Abbr`a`,DIV_thm3,LESS_EQ_TRANS,LESS_MONO_MULT,Abbr`q'`] >> `U = (w2n u1 * b + w2n u2) * l + mw2n (REVERSE us)` by lrw[Abbr`U`,Abbr`b`,Abbr`l`,mw2n_msf,dimwords_dimword,EXP,GSYM ADD1] >> `q' * (a * l) <= U` by METIS_TAC[Abbr`a`,LESS_EQ_ADD,LESS_EQ_TRANS,Abbr`q'`] >> - Cases_on `U = 0` THEN1 fs[] >> + Cases_on `U = 0` THEN1 full_simp_tac (srw_ss())[] >> `q' * X < U` by ALL_TAC THEN1( Cases_on `0 < q'` THEN1( `V = a * l + mw2n(REVERSE vs)` by lrw[Abbr`V`,Abbr`l`,Abbr`a`,mw2n_msf,dimwords_dimword] >> - `V < a * l + l` by (fs[Abbr`l`,Abbr`b`,Abbr`a`] >> METIS_TAC[mw2n_lt,LENGTH_REVERSE,dimwords_dimword]) >> + `V < a * l + l` by (full_simp_tac (srw_ss())[Abbr`l`,Abbr`b`,Abbr`a`] >> METIS_TAC[mw2n_lt,LENGTH_REVERSE,dimwords_dimword]) >> `0 < a * l` by METIS_TAC[ZERO_LT_EXP,ZERO_LT_dimword, Abbr`a`,ZERO_LESS_MULT] >> - `X < a * l` by fs[Abbr`X`,ADD_SUB,LT_SUB_RCANCEL,LT_ADDL,ADD_COMM] >> + `X < a * l` by full_simp_tac (srw_ss())[Abbr`X`,ADD_SUB,LT_SUB_RCANCEL,LT_ADDL,ADD_COMM] >> METIS_TAC[LT_MULT_RCANCEL,MULT_COMM,LESS_LESS_EQ_TRANS]) >> DECIDE_TAC) >> qpat_assum `q' <= xxx` (fn x => ALL_TAC)>> @@ -1980,24 +1980,24 @@ val mw_div_range2 = store_thm( "mw_div_range2", `3*((V-l)*V) <= (V*V + U*l) - V*l` by METIS_TAC[ADD_COMM,LESS_MONO_MULT,LESS_EQ_ADD_SUB] >> `3*((V-l)*V) <= U*l + V*(V-l)` by METIS_TAC[ADD_COMM,LEFT_SUB_DISTRIB,LESS_EQ_ADD_SUB,SUB_LESS_0,LESS_IMP_LESS_OR_EQ,LE_MULT_LCANCEL] >> qpat_assum `xxx <= yyy + V*(V-l)` (fn x => - ASSUME_TAC (RW [DECIDE ``3 = 2 + 1``,RIGHT_ADD_DISTRIB,MULT_LEFT_1] x)) >> + ASSUME_TAC (RW[DECIDE ``3 = 2 + 1``,RIGHT_ADD_DISTRIB,MULT_LEFT_1] x)) >> `(V-l)*V <= V*V` by METIS_TAC[SUB_LESS_EQ,LESS_MONO_MULT] >> REPEAT (qpat_assum `3*xxx <= yyy` (fn x => ALL_TAC)) >> METIS_TAC[MULT_COMM,MULT_ASSOC,LESS_EQ_MONO_ADD_EQ]) >> `V = (a-1+1) * b ** LENGTH vs + mw2n(REVERSE vs)` by lrw[Abbr`V`,Abbr`a`,mw2n_msf,dimwords_dimword] >> - qpat_assum `V = xxx` (fn x => (ASSUME_TAC (RW [RIGHT_ADD_DISTRIB,MULT_LEFT_1,Once (DECIDE ``a + b + c = a + c + b``)] x))) >> + qpat_assum `V = xxx` (fn x => (ASSUME_TAC (RW[RIGHT_ADD_DISTRIB,MULT_LEFT_1,Once (DECIDE ``a + b + c = a + c + b``)] x))) >> `(a - 1) * b ** (LENGTH vs) <= V - b ** (LENGTH vs)` by METIS_TAC[ADD_SUB,LESS_EQ_ADD] >> - `2 * V * ((a-1) * b ** LENGTH vs) <= 2 * V * (V - b ** LENGTH vs)` by fs[] >> + `2 * V * ((a-1) * b ** LENGTH vs) <= 2 * V * (V - b ** LENGTH vs)` by full_simp_tac (srw_ss())[] >> `2 * V * ((a-1) * b ** LENGTH vs) <= U * b ** LENGTH vs` by METIS_TAC[LESS_EQ_TRANS] >> - qpat_assum `xxx <= U * b ** LENGTH vs` (fn x => ASSUME_TAC (RW [MULT_ASSOC] x)) >> + qpat_assum `xxx <= U * b ** LENGTH vs` (fn x => ASSUME_TAC (RW[MULT_ASSOC] x)) >> `b ** LENGTH vs <> 0` by METIS_TAC[ZERO_LT_EXP,Abbr`b`,ZERO_LT_dimword,NOT_ZERO_LT_ZERO] >> `2 * V * (a-1) <= U` by METIS_TAC[LE_MULT_RCANCEL] >> - qpat_assum `2 * V * xxx <= U` (fn x => (ASSUME_TAC ( RW [Once (DECIDE ``a * b * c = a * c * b``)] x))) >> + qpat_assum `2 * V * xxx <= U` (fn x => (ASSUME_TAC (RW[Once (DECIDE ``a * b * c = a * c * b``)] x))) >> `2 * (a-1) <= q` by METIS_TAC[Abbr`q`,DIV_LE_MONOTONE,MULT_DIV] >> `q + 3 <= q'` by METIS_TAC [LESS_EQ, EVAL ``SUC 2``,ADD,ADD_COMM] >> `q <= (q' - 3)` by METIS_TAC[LE_SUB_RCANCEL,ADD_SUB,ADD_COMM,LESS_EQ_ADD] >> qpat_assum ` q + 3 <= q'` (fn x => ALL_TAC) >> - `!xx yy.MIN xx yy <= yy` by rw[] >> + `!xx yy.MIN xx yy <= yy` by srw_tac[][] >> `q' <= b - 1` by METIS_TAC[] >> qpat_assum `!xx yy. zzz` (fn x => ALL_TAC) >> `2 <= b - 2` by METIS_TAC[SUB_LESS_EQ,LESS_EQ_TRANS,LE_SUB_RCANCEL,DECIDE ``(3-1 = 2)/\(b - 1 - 1 = b - 2)``] >> `2 <= 2 * a` by METIS_TAC[LE_MULT_CANCEL_LBARE,Abbr`a`] >> @@ -2014,15 +2014,15 @@ val mw_div_range2 = store_thm( "mw_div_range2", strip_tac >> qpat_assum `~x` (fn x => ASSUME_TAC(MP ((fn (x,y) => x)(EQ_IMP_RULE (Q.SPECL [`V`,`U`] NOT_LESS_EQUAL))) x)) >> `LENGTH ((REVERSE us) ++ [u2]) = SUC(LENGTH us)` by lrw[] >> - `U = mw2n (REVERSE us) + dimword(:'a) ** LENGTH us * w2n u2 + dimword(:'a) ** (LENGTH(REVERSE us ++ [u2])) * w2n u1` by fs[Abbr`U`,LENGTH_REVERSE,GSYM ADD1,mw2n_msf,dimwords_dimword] >> - `U = mw2n (REVERSE us) + dimword(:'a) ** LENGTH us * w2n u2 + dimword(:'a) ** (LENGTH us) * dimword(:'a) * w2n u1` by fs[EXP,MULT_COMM] >> + `U = mw2n (REVERSE us) + dimword(:'a) ** LENGTH us * w2n u2 + dimword(:'a) ** (LENGTH(REVERSE us ++ [u2])) * w2n u1` by full_simp_tac (srw_ss())[Abbr`U`,LENGTH_REVERSE,GSYM ADD1,mw2n_msf,dimwords_dimword] >> + `U = mw2n (REVERSE us) + dimword(:'a) ** LENGTH us * w2n u2 + dimword(:'a) ** (LENGTH us) * dimword(:'a) * w2n u1` by full_simp_tac (srw_ss())[EXP,MULT_COMM] >> qpat_assum `U = xxx` (fn x => ASSUME_TAC(RW[GSYM MULT_ASSOC,GSYM ADD_ASSOC,GSYM LEFT_ADD_DISTRIB] x)) >> - `V = mw2n (REVERSE vs) + dimword(:'a) ** LENGTH vs * w2n v1` by fs[mw2n_msf,dimwords_dimword] >> + `V = mw2n (REVERSE vs) + dimword(:'a) ** LENGTH vs * w2n v1` by full_simp_tac (srw_ss())[mw2n_msf,dimwords_dimword] >> `V < dimword(:'a) ** LENGTH vs * SUC (w2n v1)` by METIS_TAC[mw2n_lt,LENGTH_REVERSE,LESS_MONO_ADD,MULT,ADD_COMM,MULT_COMM,dimwords_dimword] >> `U < dimword(:'a) ** SUC(LENGTH us)` by METIS_TAC[mw2n_lt,LESS_TRANS,LENGTH_REVERSE,LENGTH,dimwords_dimword]>> `w2n u2 + dimword(:'a) * w2n u1 <= w2n v1` by METIS_TAC[ADD_COMM,LESS_EQ_ADD,LESS_EQ_LESS_TRANS,LESS_TRANS,LT_MULT_LCANCEL,DECIDE ``a < SUC b ==> (a <= b)``] >> `MIN a b <= a` by lrw[] >> - `q' <= (w2n u2 + dimword(:'a)*w2n u1) DIV w2n v1` by fs[ADD_COMM,MULT_COMM,Abbr`q'`]>> + `q' <= (w2n u2 + dimword(:'a)*w2n u1) DIV w2n v1` by full_simp_tac (srw_ss())[ADD_COMM,MULT_COMM,Abbr`q'`]>> `0 < w2n v1` by METIS_TAC[DIV_GT0,DECIDE ``0<2``,ONE_LT_dimword,LESS_EQ,TWO,ONE,LESS_EQ_TRANS] >> `(w2n u2 + dimword(:'a)*w2n u1) DIV w2n v1 <= 1` by (Cases_on `w2n u2 + dimword(:'a)*w2n u1 = w2n v1` THEN1 (RW_TAC arith_ss[]) >> `(w2n u2 + dimword(:'a) * w2n u1) < w2n v1` by RW_TAC arith_ss[] >> METIS_TAC[LESS_DIV_EQ_ZERO, DECIDE ``0<=1``]) >> @@ -2031,11 +2031,11 @@ val mw_div_range2 = store_thm( "mw_div_range2", val mw_div_test_lemma1 = store_thm( "mw_div_test_lemma1", ``!q u1 u2 u3 v1 v2. w2n (mw_div_test q u1 u2 u3 v1 v2) <= w2n q``, HO_MATCH_MP_TAC mw_div_test_ind >> REPEAT strip_tac >> - rw[Once mw_div_test_def] >> + srw_tac[][Once mw_div_test_def] >> `w2n q2 <= w2n q` by METIS_TAC[Abbr`q2`,w2n_n2w,ZERO_LT_dimword,MOD_LESS_EQ,LESS_EQ_TRANS,DECIDE ``x - 1 <=x``] >> Cases_on `mw_cmp [u2; u1] (FST (mw_add [FST s; SND s] [0w; 1w] F)) = SOME T` - >> fs[] >> METIS_TAC[LESS_EQ_TRANS]) + >> full_simp_tac (srw_ss())[] >> METIS_TAC[LESS_EQ_TRANS]) val mw_div_test_lemma2 = store_thm( "mw_div_test_lemma2", ``!(us:'a word list) (vs:'a word list). @@ -2052,7 +2052,7 @@ val mw_div_test_lemma2 = store_thm( "mw_div_test_lemma2", Cases_on `(mw_cmp [u3; u2; u1] (mw_mul_by_single q [v2; v1]) = SOME T)` THEN1( Q.PAT_ABBREV_TAC `u = u1::u2::u3::us` >> Q.PAT_ABBREV_TAC` v = v1::v2::vs` >> - rw[Once mw_div_test_def] >> + srw_tac[][Once mw_div_test_def] >> qsuff_tac `mw2n (REVERSE (u:'a word list)) DIV mw2n (REVERSE (v:'a word list)) <= w2n (n2w (w2n (q:'a word) - 1):'a word)` THEN1( strip_tac >> Cases_on `mw_cmp [u2; u1] (FST (mw_add [FST s; SND s] [0w; 1w] F)) = SOME T` >> @@ -2065,7 +2065,7 @@ val mw_div_test_lemma2 = store_thm( "mw_div_test_lemma2", `w2n (n2w (w2n (q:'a word) - 1):'a word) = w2n q - 1` by METIS_TAC[w2n_n2w,LESS_MOD,DECIDE ``x - 1 <= x``,LESS_EQ_LESS_TRANS,w2n_lt] >> POP_ASSUM (fn x => REWRITE_TAC[x]) >> markerLib.UNABBREV_TAC "v" >> - rw[mw2n_msf,EXP, GSYM ADD1,dimwords_dimword] >> + srw_tac[][mw2n_msf,EXP, GSYM ADD1,dimwords_dimword] >> `0 < w2n v1 * dimword(:'a) + w2n v2` by METIS_TAC[ZERO_LT_dimword,LE_MULT_CANCEL_LBARE,LESS_EQ_ADD,LESS_EQ_TRANS,LESS_LESS_EQ_TRANS] >> `0 < dimword(:'a) ** (LENGTH vs)` by METIS_TAC[ZERO_LT_dimword,ZERO_LT_EXP] >> @@ -2081,7 +2081,7 @@ val mw_div_test_lemma2 = store_thm( "mw_div_test_lemma2", Q.PAT_ABBREV_TAC`X2 = dimword(:'a) ** LENGTH vs` >> `U DIV (X1 * X2) = U DIV X2 DIV X1` by METIS_TAC[MULT_COMM,DIV_DIV_DIV_MULT] >> qpat_assum `U DIV xxx = yyy` (fn x => REWRITE_TAC[x]) >> - rw[Abbr`U`,Abbr`u`,mw2n_msf,dimwords_dimword,EXP, GSYM ADD1] >> + srw_tac[][Abbr`U`,Abbr`u`,mw2n_msf,dimwords_dimword,EXP, GSYM ADD1] >> REWRITE_TAC[DECIDE ``u + x2 * u3 + b * x2 * u2 + b * (b * x2) * u1 = (u3 + u2*b + u1*b*b)*x2 + u``] >> Q.PAT_ABBREV_TAC`A = (w2n u3 + w2n u2 * dimword (:'a) + w2n u1 * dimword (:'a) * dimword (:'a))` >> Q.PAT_ABBREV_TAC`B = mw2n (REVERSE us)` >> @@ -2089,7 +2089,7 @@ val mw_div_test_lemma2 = store_thm( "mw_div_test_lemma2", qpat_assum `xx DIV X2 = A` (fn x => REWRITE_TAC[x]) >> `A < w2n q * X1` by METIS_TAC[ADD_COMM,ADD_ASSOC] >> `A DIV X1 < w2n q` by METIS_TAC[DIV_thm2] >> - Cases_on `w2n q` THEN1 fs[] >> + Cases_on `w2n q` THEN1 full_simp_tac (srw_ss())[] >> METIS_TAC[SUC_SUB1,LESS_EQ,LESS_EQ_MONO]) >> REWRITE_TAC[DECIDE ``a1 * d * d + a2 * d + a3 = a3 + d * (a2 + ( d * a1))``, DECIDE ``w * (b1 * d + b2) = w *( b2 + d * b1)``] >> @@ -2098,7 +2098,7 @@ val mw_div_test_lemma2 = store_thm( "mw_div_test_lemma2", REWRITE_TAC[SPEC_ALL (GSYM (CONJUNCT2 mw2n_def)),GSYM (CONJUNCT1 (SPEC_ALL mw_mul_by_single_lemma))] >> `LENGTH [u3;u2;u1] = LENGTH (mw_mul_by_single q [v2;v1])` by lrw[mw_mul_by_single_lemma] >> FULL_SIMP_TAC std_ss [mw_cmp_thm]) >> -fs[Once mw_div_test_def] ) +full_simp_tac (srw_ss())[Once mw_div_test_def] ) val q_thm = store_thm( "q_thm", ``!(u1:'a word) u2 us (v1:'a word) vs. @@ -2111,7 +2111,7 @@ val q_thm = store_thm( "q_thm", Q.PAT_ABBREV_TAC`V = mw2n (REVERSE (v1::vs))` >> strip_tac >> EQT_M_R_S_i `dimword(:'a) ** LENGTH (us:'a word list)` >> - `0 < V` by (fs[Abbr`V`,mw2n_msf,dimwords_dimword,Once ADD_COMM,Once MULT_COMM] + `0 < V` by (full_simp_tac (srw_ss())[Abbr`V`,mw2n_msf,dimwords_dimword,Once ADD_COMM,Once MULT_COMM] >> METIS_TAC[ZERO_LT_dimword,ZERO_LT_EXP,LESS_EQ_ADD, LE_MULT_CANCEL_LBARE, LESS_LESS_EQ_TRANS]) >> `U < dimword(:'a) * V` by METIS_TAC[DIV_LT_X] >> @@ -2142,15 +2142,15 @@ val mw_div_test_thm = store_thm( "mw_div_test_thm", Q.PAT_ABBREV_TAC`Q = U DIV V` >> strip_tac >> Q.PAT_ABBREV_TAC `q = if w2n u1 < w2n v1 then FST (single_div u1 u2 v1) else n2w (dimword (:'a) - 1)` >> - rw[] THEN1 METIS_TAC[w2n_lt] >> + srw_tac[][] THEN1 METIS_TAC[w2n_lt] >> `LENGTH (u3::us) = LENGTH (v2::vs)` by lrw[] >> `0 < w2n v1` by METIS_TAC[ONE_LT_dimword,DECIDE ``0<2 /\ ((1(2 <= x))``,DIV_GT0,LESS_LESS_EQ_TRANS] >> - `0 < V` by (fs[Abbr`V`,mw2n_msf,dimwords_dimword,Once ADD_COMM,Once MULT_COMM] + `0 < V` by (full_simp_tac (srw_ss())[Abbr`V`,mw2n_msf,dimwords_dimword,Once ADD_COMM,Once MULT_COMM] >> METIS_TAC[ZERO_LT_dimword,ZERO_LT_EXP,LESS_EQ_ADD, LE_MULT_CANCEL_LBARE, LESS_LESS_EQ_TRANS]) >> `w2n q = MIN ((w2n u1 * dimword (:'a) + w2n u2) DIV w2n v1) (dimword (:'a) - 1)` by ALL_TAC THEN1( markerLib.UNABBREV_TAC "q" >> - rw[single_div_def] + srw_tac[][single_div_def] THEN1( IMP_RES_TAC single_div_lemma1 >> POP_ASSUM (fn x => ASSUME_TAC (Q.SPECL [`u2:'a word`] x)) >> FULL_SIMP_TAC arith_ss[] >> @@ -2163,7 +2163,7 @@ val mw_div_test_thm = store_thm( "mw_div_test_thm", REWRITE_TAC[RIGHT_SUB_DISTRIB] >> METIS_TAC[NOT_LESS,MULT_COMM,LESS_MONO_MULT,SUB_LESS_EQ,LESS_EQ_ADD,LESS_EQ_TRANS]) >> markerLib.RM_ABBREV_TAC "q" >> - `dimword(:'a) - 1 < dimword(:'a)` by (Cases_on `dimword(:'a)` >> fs[ZERO_LT_dimword]) >> + `dimword(:'a) - 1 < dimword(:'a)` by (Cases_on `dimword(:'a)` >> full_simp_tac (srw_ss())[ZERO_LT_dimword]) >> `w2n q <= dimword(:'a)-1` by METIS_TAC[w2n_lt,SUB_LESS_OR] >> `w2n q>=Q` by METIS_TAC[Abbr`Q`,mw_div_range1,Abbr `U`, Abbr`V`] >> qpat_assum `w2n q >= Q` (fn x => ASSUME_TAC(METIS_PROVE [x,GREATER_EQ] ``Q <= w2n q``)) >> @@ -2180,10 +2180,10 @@ val mw_div_test_thm = store_thm( "mw_div_test_thm", `test <= w2n q - 1` by ALL_TAC THEN1( markerLib.UNABBREV_TAC "test" >> REPEAT (qpat_assum `w2n q = xxx` (K ALL_TAC)) >> - rw[Once mw_div_test_def] >> + srw_tac[][Once mw_div_test_def] >> `w2n q2 = w2n q - 1` by (markerLib.UNABBREV_TAC "q2" >> lrw[]) >> Cases_on `mw_cmp [u2; u1] (FST (mw_add [FST s; SND s] [0w; 1w] F)) = SOME T` >> - rw[] THEN1 METIS_TAC[LESS_EQ_REFL,LESS_EQ_TRANS,mw_div_test_lemma1] >> + srw_tac[][] THEN1 METIS_TAC[LESS_EQ_REFL,LESS_EQ_TRANS,mw_div_test_lemma1] >> DECIDE_TAC) >> DECIDE_TAC) >> REV (`w2n u1 * dimword(:'a) * dimword(:'a) + w2n u2 * dimword(:'a) + w2n u3 < w2n q * (w2n v1 * dimword(:'a) + w2n v2)` by ALL_TAC) @@ -2217,7 +2217,7 @@ val mw_div_test_thm = store_thm( "mw_div_test_thm", \\ SIMP_TAC std_ss [mw2n_lt]) >> markerLib.UNABBREV_TAC "V" >> lrw[mw2n_msf,dimwords_dimword,GSYM ADD1,GSYM EXP]>> ONCE_REWRITE_TAC[DECIDE``a + (b + c) = b + (a + c):num``] >> - Cases_on `V1` THEN1 fs[] >> + Cases_on `V1` THEN1 full_simp_tac (srw_ss())[] >> Q.PAT_ABBREV_TAC`A = b ** SUC(LENGTH vs)`>> Q.PAT_ABBREV_TAC`B = mw2n (REVERSE vs) + V2 * b ** LENGTH vs`>> METIS_TAC[MULT,MULT_COMM,ADD_COMM,ADD_ASSOC,LESS_EQ_ADD])>> @@ -2250,9 +2250,9 @@ val mw_div_loop_LENGTH = store_thm( "mw_div_loop_LENGTH", HO_MATCH_MP_TAC mw_div_loop_ind >> REPEAT strip_tac >> -rw[Once mw_div_loop_def] >> +srw_tac[][Once mw_div_loop_def] >> Cases_on `mw_cmp (REVERSE us) q2ys = SOME T` >> -rw[] +srw_tac[][] THEN1 (qpat_assum `! us q q2. xxx` (K ALL_TAC) >> qpat_assum `! us. xxx` (fn x => ASSUME_TAC (Q.SPECL [`us`,`q`,`q2`,`q2ys`,`q3`,`q3ys`,`zs2'`] x)) >> `LENGTH zs = SUC (LENGTH zs2')` by ALL_TAC @@ -2262,10 +2262,10 @@ THEN1 (qpat_assum `! us q q2. xxx` (K ALL_TAC) >> Q.PAT_ABBREV_TAC `X = (FST (mw_sub (REVERSE us) q3ys T))` >> `0 < LENGTH us /\ (LENGTH us = SUC(LENGTH ys))` by METIS_TAC[LENGTH_TAKE,LESS_EQ,DECIDE ``0 < SUC x``] >> `X <> [] /\ (LENGTH X = SUC(LENGTH ys))` by METIS_TAC[mw_sub_lemma,PAIR,LENGTH_REVERSE,NOT_NIL_EQ_LENGTH_NOT_0] >> - rw[rich_listTheory.LENGTH_BUTLAST,prim_recTheory.PRE] >> + srw_tac[][rich_listTheory.LENGTH_BUTLAST,prim_recTheory.PRE] >> RW_TAC arith_ss[]) >> Cases_on `LENGTH ys < LENGTH zs2'` THEN1 METIS_TAC[] >> - rw[Once mw_div_loop_def]) >> + srw_tac[][Once mw_div_loop_def]) >> qpat_assum `! us. xxx` (fn x => ASSUME_TAC (Q.SPECL [`us`,`q`,`q2`,`q2ys`,`zs2`] x)) >> qpat_assum `! us q q2. xxx` (K ALL_TAC) >> `LENGTH zs = SUC (LENGTH zs2)` by ALL_TAC @@ -2275,10 +2275,10 @@ THEN1 (`LENGTH q2ys = LENGTH us` by METIS_TAC[Abbr`us`,Abbr`q2ys`,mw_mul_by_sing Q.PAT_ABBREV_TAC `X = (FST (mw_sub (REVERSE us) q2ys T))` >> `0 < LENGTH us /\ (LENGTH us = SUC(LENGTH ys))` by METIS_TAC[LENGTH_TAKE,LESS_EQ,DECIDE ``0 < SUC x``] >> `X <> [] /\ (LENGTH X = SUC(LENGTH ys))` by METIS_TAC[mw_sub_lemma,PAIR,LENGTH_REVERSE,NOT_NIL_EQ_LENGTH_NOT_0] >> - rw[rich_listTheory.LENGTH_BUTLAST,prim_recTheory.PRE] >> + srw_tac[][rich_listTheory.LENGTH_BUTLAST,prim_recTheory.PRE] >> RW_TAC arith_ss[]) >> Cases_on `LENGTH ys < LENGTH zs2` THEN1 METIS_TAC[] >> -rw[Once mw_div_loop_def]) +srw_tac[][Once mw_div_loop_def]) val tac_div_loop_1 = `mw2n (REVERSE (TAKE (SUC (LENGTH ys)) zs2)) DIV mw2n (REVERSE ys) < dimword (:'a)` by ALL_TAC @@ -2286,9 +2286,9 @@ val tac_div_loop_1 = markerLib.UNABBREV_TAC "zs2" >> `LENGTH (FRONT w) = LENGTH ys` by METIS_TAC[prim_recTheory.PRE,LENGTH_BUTLAST] >> `LENGTH (REVERSE (FRONT w)) < SUC (LENGTH ys)` by METIS_TAC[LENGTH_REVERSE,DECIDE ``x < SUC x``] >> - rw[TAKE_APPEND2,REVERSE_APPEND,SUC_SUB] >> + srw_tac[][TAKE_APPEND2,REVERSE_APPEND,SUC_SUB] >> `LENGTH (TAKE 1 (DROP (SUC (LENGTH ys)) zs)) = 1` by METIS_TAC[LENGTH_TAKE,LENGTH_DROP,LESS_EQ,SUB_LESS_0,ONE] >> - rw[mw2n_APPEND,dimwords_dimword] >> + srw_tac[][mw2n_APPEND,dimwords_dimword] >> `!a b. (a < b * mw2n (REVERSE ys) ==> a DIV mw2n (REVERSE ys) < b)` by METIS_TAC[DIV_LT_X] >> POP_ASSUM (fn x => MATCH_MP_TAC x) >> MATCH_MP_TAC LESS_LESS_EQ_TRANS >> EXISTS_TAC ``dimword(:'a) * SUC (mw2n (REVERSE (us:'a word list)) - mw2n (q3ys:'a word list))`` >> @@ -2307,15 +2307,15 @@ val tac_div_loop_1 = mw2n (REVERSE zs2)` by METIS_TAC[] >> qpat_assum ` xx /\ (us = us) /\ yyy ==> zz` (K ALL_TAC) >> `LENGTH ys <= LENGTH (mw_div_loop zs2 ys) /\ (LENGTH (mw_div_loop zs2 ys) = LENGTH zs2)` by METIS_TAC[mw_div_loop_LENGTH,LESS_IMP_LESS_OR_EQ] >> - rw[rich_listTheory.LASTN_CONS,rich_listTheory.BUTLASTN_CONS,mw2n_msf,dimwords_dimword,rich_listTheory.LENGTH_BUTLASTN] >> + srw_tac[][rich_listTheory.LASTN_CONS,rich_listTheory.BUTLASTN_CONS,mw2n_msf,dimwords_dimword,rich_listTheory.LENGTH_BUTLASTN] >> REWRITE_TAC[DECIDE ``(a + b)* c + d = a*c + d + b*c``] >> qpat_assum `xxx = mw2n (REVERSE zs2)` (fn x => REWRITE_TAC[x]) >> markerLib.UNABBREV_TAC "zs2" >> REWRITE_TAC[REVERSE_APPEND,REVERSE_REVERSE,mw2n_APPEND] >> qpat_assum `mw2n (FRONT xx) = mw2n xx` (fn x => REWRITE_TAC[x]) >> REWRITE_TAC[LENGTH_REVERSE,LENGTH_APPEND,LENGTH_DROP] >> - fs[rich_listTheory.LENGTH_BUTLAST] >> + full_simp_tac (srw_ss())[rich_listTheory.LENGTH_BUTLAST] >> markerLib.UNABBREV_TAC "q3ys" >> - fs[mw_mul_by_single_lemma] >> + full_simp_tac (srw_ss())[mw_mul_by_single_lemma] >> `zs = us ++ (DROP (SUC(LENGTH ys)) zs)` by METIS_TAC[Abbr`us`,TAKE_DROP] >> POP_ASSUM (fn x => CONV_TAC (RAND_CONV (ONCE_REWRITE_CONV [x]))) >> REWRITE_TAC[REVERSE_APPEND,mw2n_APPEND,dimwords_dimword,LENGTH_DROP,LENGTH_REVERSE] >> @@ -2323,18 +2323,18 @@ val tac_div_loop_1 = METIS_TAC[DIV_thm3,SUB_ADD]; val tac_div_loop_2 = - rw[Once mw_div_loop_def] >> - rw[Once mw_div_loop_def] >> POP_ASSUM (K ALL_TAC) >> + srw_tac[][Once mw_div_loop_def] >> + srw_tac[][Once mw_div_loop_def] >> POP_ASSUM (K ALL_TAC) >> `LENGTH zs2 = LENGTH ys` by DECIDE_TAC >> `LENGTH ys <= LENGTH (q3::zs2)` by METIS_TAC[LENGTH,DECIDE ``n <= SUC n``] >> - rw[rich_listTheory.BUTLASTN_CONS,rich_listTheory.LASTN_CONS,mw2n_msf,dimwords_dimword] >> + srw_tac[][rich_listTheory.BUTLASTN_CONS,rich_listTheory.LASTN_CONS,mw2n_msf,dimwords_dimword] >> `(BUTLASTN (LENGTH ys) zs2 = []) /\ (LASTN (LENGTH ys) zs2 = zs2)` by METIS_TAC[rich_listTheory.BUTLASTN_LENGTH_NIL,rich_listTheory.LASTN_LENGTH_ID] >> POP_ASSUM (fn x => REWRITE_TAC[x]) >> POP_ASSUM (fn x => REWRITE_TAC[x]) >> RW_TAC arith_ss[LENGTH,REVERSE,mw2n_def] >> markerLib.UNABBREV_TAC "zs2">> ASM_REWRITE_TAC[REVERSE_REVERSE,REVERSE_APPEND,mw2n_APPEND,dimwords_dimword]>> - markerLib.UNABBREV_TAC "q3ys" >> rw[mw_mul_by_single_lemma] >> + markerLib.UNABBREV_TAC "q3ys" >> srw_tac[][mw_mul_by_single_lemma] >> RW_TAC arith_ss[] >> ONCE_REWRITE_TAC[GSYM ADD_ASSOC] >> Q.PAT_ABBREV_TAC `x = mw2n (REVERSE ys) * (mw2n (REVERSE us) DIV mw2n (REVERSE ys))` >> @@ -2342,11 +2342,11 @@ val tac_div_loop_2 = POP_ASSUM (fn x => REWRITE_TAC[x]) >> markerLib.UNABBREV_TAC "us" >> `SUC(LENGTH ys) = LENGTH zs` by DECIDE_TAC >> POP_ASSUM (fn x => REWRITE_TAC[x]) >> - rw[rich_listTheory.BUTFIRSTN_LENGTH_NIL,listTheory.TAKE_LENGTH_ID,mw2n_def]; + srw_tac[][rich_listTheory.BUTFIRSTN_LENGTH_NIL,listTheory.TAKE_LENGTH_ID,mw2n_def]; val tac_div_loop_test = - Cases_on `us` THEN1 fs[] >> Cases_on `t` THEN1 fs[] >> Cases_on `t'` THEN1 fs[] >> - Cases_on `ys` THEN1 fs[] >> Cases_on `t'` THEN1 fs[] >> + Cases_on `us` THEN1 full_simp_tac (srw_ss())[] >> Cases_on `t` THEN1 full_simp_tac (srw_ss())[] >> Cases_on `t'` THEN1 full_simp_tac (srw_ss())[] >> + Cases_on `ys` THEN1 full_simp_tac (srw_ss())[] >> Cases_on `t'` THEN1 full_simp_tac (srw_ss())[] >> FULL_SIMP_TAC std_ss[HD,TL,LENGTH] >> METIS_TAC[mw_div_test_thm]; @@ -2360,10 +2360,10 @@ val mw_div_loop_thm = store_thm( "mw_div_loop_thm", mw2n (REVERSE zs))``, HO_MATCH_MP_TAC mw_div_loop_ind >> REPEAT strip_tac >> - rw[Once mw_div_loop_def] >> + srw_tac[][Once mw_div_loop_def] >> markerLib.UNABBREV_TAC "rslt" >> Cases_on `mw_cmp (REVERSE us) q2ys = SOME T` >> - rw[] + srw_tac[][] THENL[qpat_assum `!us. xxx` (K ALL_TAC) >> qpat_assum `!us. xxx` (fn x => ASSUME_TAC (Q.SPECL [`us`,`q`,`q2`,`q2ys`,`q3`,`q3ys`,`zs2'`] x)), @@ -2390,7 +2390,7 @@ Q.PAT_ABBREV_TAC `zs2 = (REVERSE (FRONT w) ++ DROP (SUC (LENGTH ys)) zs)` >> `w2n q3 = mw2n (REVERSE us) DIV mw2n (REVERSE ys)` by ALL_TAC THENL[`(w2n q2 = mw2n (REVERSE us) DIV mw2n (REVERSE ys)) \/(w2n q2 = SUC (mw2n (REVERSE us) DIV mw2n (REVERSE ys)))` by tac_div_loop_test THEN1(`mw2n (REVERSE us) < mw2n (mw_mul_by_single q2 (REVERSE ys))` by FULL_SIMP_TAC std_ss[ADD1,LENGTH,LENGTH_REVERSE,mw_mul_by_single_lemma,mw_cmp_thm] >> - POP_ASSUM (fn x => ASSUME_TAC (RW [mw_mul_by_single_lemma] x)) >> + POP_ASSUM (fn x => ASSUME_TAC (RW[mw_mul_by_single_lemma] x)) >> qpat_assum `w2n q2 = xxx` (fn x => FULL_SIMP_TAC std_ss [x]) >> METIS_TAC[NOT_LESS,DIV_thm3]) >> METIS_TAC[SUC_SUB1,w2n_n2w,w2n_lt,LESS_MOD,DECIDE ``x < SUC x``,LESS_TRANS,Abbr`q3`], @@ -2399,7 +2399,7 @@ THENL[`(w2n q2 = mw2n (REVERSE us) DIV mw2n (REVERSE ys)) \/(w2n q2 = SUC (mw2n `LENGTH q3ys = LENGTH (REVERSE us)` by METIS_TAC[ADD1,LENGTH,LENGTH_REVERSE,mw_mul_by_single_lemma,Abbr`q3ys`] >> `mw2n q3ys <= mw2n (REVERSE us)` by FULL_SIMP_TAC std_ss[mw_cmp_thm,NOT_LESS] >> markerLib.UNABBREV_TAC "q3ys" >> - POP_ASSUM (fn x => ASSUME_TAC (RW [mw_mul_by_single_lemma] x)) >> + POP_ASSUM (fn x => ASSUME_TAC (RW[mw_mul_by_single_lemma] x)) >> qpat_assum `w2n q3 = xxx` (fn x => FULL_SIMP_TAC std_ss [x]) >> METIS_TAC[X_LE_DIV,NOT_LESS,DECIDE ``z < SUC z``], ALL_TAC] >> @@ -2407,14 +2407,14 @@ THENL[`(w2n q2 = mw2n (REVERSE us) DIV mw2n (REVERSE ys)) \/(w2n q2 = SUC (mw2n `LENGTH zs = SUC (LENGTH zs2)` by ( markerLib.UNABBREV_TAC "zs2" >> REWRITE_TAC[LENGTH_APPEND,LENGTH_REVERSE,LENGTH_DROP] >> - rw[rich_listTheory.LENGTH_BUTLAST,prim_recTheory.PRE] >> + srw_tac[][rich_listTheory.LENGTH_BUTLAST,prim_recTheory.PRE] >> RW_TAC arith_ss[]) >> `mw2n q3ys <= mw2n (REVERSE us)` by METIS_TAC[Abbr`q3ys`,mw_mul_by_single_lemma,DIV_thm3] >> `mw2n w = mw2n (REVERSE us) - mw2n q3ys` by METIS_TAC[LENGTH_REVERSE,mw_sub_thm] >> `mw2n (FRONT w) = mw2n w` by( `mw2n w < dimword(:'a) ** LENGTH (FRONT w)` by ( qpat_assum `mw2n xx = mw2n yy - mw2n zz` (K ALL_TAC) >> - rw[rich_listTheory.LENGTH_BUTLAST,prim_recTheory.PRE] >> + srw_tac[][rich_listTheory.LENGTH_BUTLAST,prim_recTheory.PRE] >> `mw2n w = mw2n (REVERSE us) - mw2n q3ys` by METIS_TAC[LENGTH_REVERSE,mw_sub_thm] >> POP_ASSUM (fn x => REWRITE_TAC[x]) >> markerLib.UNABBREV_TAC "q3ys" >> @@ -2427,15 +2427,15 @@ THENL[tac_div_loop_1,tac_div_loop_2,tac_div_loop_1,tac_div_loop_2]); val tac_div_loop_bis_1 = `0 < LENGTH zs2` by DECIDE_TAC >> `LENGTH ys <= LENGTH (mw_div_loop zs2 ys)` by METIS_TAC[NOT_NIL_EQ_LENGTH_NOT_0,mw_div_loop_LENGTH,LESS_IMP_LESS_OR_EQ] >> - rw[LASTN_CONS] >> + srw_tac[][LASTN_CONS] >> `mw2n (REVERSE (TAKE (SUC (LENGTH ys)) zs2)) DIV mw2n (REVERSE ys) < dimword (:'a)` by ALL_TAC THEN1( `SUC (LENGTH ys) < LENGTH zs` by DECIDE_TAC >> markerLib.UNABBREV_TAC "zs2" >> `LENGTH (FRONT w) = LENGTH ys` by METIS_TAC[prim_recTheory.PRE,LENGTH_BUTLAST] >> `LENGTH (REVERSE (FRONT w)) < SUC (LENGTH ys)` by METIS_TAC[LENGTH_REVERSE,DECIDE ``x < SUC x``] >> - rw[TAKE_APPEND2,REVERSE_APPEND,SUC_SUB] >> + srw_tac[][TAKE_APPEND2,REVERSE_APPEND,SUC_SUB] >> `LENGTH (TAKE 1 (DROP (SUC (LENGTH ys)) zs)) = 1` by METIS_TAC[LENGTH_TAKE,LENGTH_DROP,LESS_EQ,SUB_LESS_0,ONE] >> - rw[mw2n_APPEND,dimwords_dimword] >> + srw_tac[][mw2n_APPEND,dimwords_dimword] >> `!a b. (a < b * mw2n (REVERSE ys) ==> a DIV mw2n (REVERSE ys) < b)` by METIS_TAC[DIV_LT_X] >> POP_ASSUM (fn x => MATCH_MP_TAC x) >> MATCH_MP_TAC LESS_LESS_EQ_TRANS >> EXISTS_TAC ``dimword(:'a) * SUC (mw2n (REVERSE (us:'a word list)) - mw2n (q3ys:'a word list))`` >> @@ -2452,7 +2452,7 @@ val tac_div_loop_bis_1 = METIS_TAC[]; val tac_div_loop_bis_2 = -rw[Once mw_div_loop_def] >> +srw_tac[][Once mw_div_loop_def] >> lrw[rich_listTheory.LASTN_CONS,rich_listTheory.LASTN_LENGTH_ID] >> markerLib.UNABBREV_TAC "zs2" >> `SUC (LENGTH ys) = LENGTH zs` by DECIDE_TAC >> @@ -2479,7 +2479,7 @@ qsuff_tac `!(zs:'a word list) (ys:'a word list). ((mw2n (REVERSE (TAKE (SUC (LENGTH ys)) zs)) DIV mw2n (REVERSE ys)) < dimword(:'a) ) ==> (mw2n (REVERSE (LASTN (LENGTH ys) (mw_div_loop zs ys))) < mw2n (REVERSE ys))` THEN1(REPEAT strip_tac >> - rw[] >> + srw_tac[][] >> IMP_RES_TAC mw_div_loop_thm >> `mw2n (REVERSE zs) = mw2n (REVERSE (BUTLASTN (LENGTH ys) rslt)) * mw2n (REVERSE ys) + mw2n (REVERSE (LASTN (LENGTH ys) rslt))` by METIS_TAC[] >> @@ -2491,13 +2491,13 @@ THEN1(REPEAT strip_tac >> POP_ASSUM (fn x => lrw[x,mw2n_msf,dimwords_dimword]) >> `0 < dimword(:'a) DIV 2` by METIS_TAC[TWO,DIV_GT0,DECIDE``0<2``,TWO,LESS_EQ,ONE_LT_dimword] >> METIS_TAC[LESS_LESS_EQ_TRANS,ZERO_LT_EXP,ZERO_LT_dimword,LESS_EQ_ADD,ZERO_LESS_MULT,ADD_COMM]) >> - rw[MOD_TIMES,ADD_DIV_ADD_DIV,Abbr`rslt`] >> + srw_tac[][MOD_TIMES,ADD_DIV_ADD_DIV,Abbr`rslt`] >> MATCH_MP_TAC ((fn (x,y) => y) (EQ_IMP_RULE (SPEC_ALL EQ_ADDL))) >> MATCH_MP_TAC LESS_DIV_EQ_ZERO >> METIS_TAC[]) >> HO_MATCH_MP_TAC mw_div_loop_ind >> REPEAT strip_tac >> -rw[Once mw_div_loop_def] >> +srw_tac[][Once mw_div_loop_def] >> Cases_on `mw_cmp (REVERSE us) q2ys = SOME T` >> markerLib.UNABBREV_TAC "q3" THENL[Q.PAT_ABBREV_TAC`(q3:'a word) = n2w (w2n q2 - 1)`,markerLib.UNABBREV_TAC "q2" >> @@ -2509,7 +2509,7 @@ markerLib.UNABBREV_TAC "q3ys" >> Q.PAT_ABBREV_TAC `q3ys = (mw_mul_by_single q3 (REVERSE ys))` >> Q.PAT_ABBREV_TAC `w = FST (mw_sub (REVERSE us) q3ys T)` >> Q.PAT_ABBREV_TAC `zs2 = (REVERSE (FRONT w) ++ DROP (SUC (LENGTH ys)) zs)` >> -rw[] >> +srw_tac[][] >> `0 < LENGTH us /\ (LENGTH us = SUC(LENGTH ys))` by METIS_TAC[LENGTH_TAKE,LESS_EQ,DECIDE ``0 < SUC x``] >> `LENGTH q3ys = LENGTH us` by METIS_TAC[Abbr`us`,Abbr`q3ys`,mw_mul_by_single_lemma,ADD1,LENGTH_TAKE,LESS_EQ,LENGTH_REVERSE] >> `0 < mw2n (REVERSE ys)` by @@ -2522,7 +2522,7 @@ rw[] >> `w2n q3 = mw2n (REVERSE us) DIV mw2n (REVERSE ys)` by ALL_TAC THENL[`(w2n q2 = mw2n (REVERSE us) DIV mw2n (REVERSE ys)) \/(w2n q2 = SUC (mw2n (REVERSE us) DIV mw2n (REVERSE ys)))` by tac_div_loop_test THEN1(`mw2n (REVERSE us) < mw2n (mw_mul_by_single q2 (REVERSE ys))` by FULL_SIMP_TAC std_ss[ADD1,LENGTH,LENGTH_REVERSE,mw_mul_by_single_lemma,mw_cmp_thm] >> - POP_ASSUM (fn x => ASSUME_TAC (RW [mw_mul_by_single_lemma] x)) >> + POP_ASSUM (fn x => ASSUME_TAC (RW[mw_mul_by_single_lemma] x)) >> qpat_assum `w2n q2 = xxx` (fn x => FULL_SIMP_TAC std_ss [x]) >> METIS_TAC[NOT_LESS,DIV_thm3]) >> METIS_TAC[SUC_SUB1,w2n_n2w,w2n_lt,LESS_MOD,DECIDE ``x < SUC x``,LESS_TRANS,Abbr`q3`], @@ -2531,7 +2531,7 @@ THENL[`(w2n q2 = mw2n (REVERSE us) DIV mw2n (REVERSE ys)) \/(w2n q2 = SUC (mw2n `LENGTH q3ys = LENGTH (REVERSE us)` by METIS_TAC[ADD1,LENGTH,LENGTH_REVERSE,mw_mul_by_single_lemma,Abbr`q3ys`] >> `mw2n q3ys <= mw2n (REVERSE us)` by FULL_SIMP_TAC std_ss[mw_cmp_thm,NOT_LESS] >> markerLib.UNABBREV_TAC "q3ys" >> - POP_ASSUM (fn x => ASSUME_TAC (RW [mw_mul_by_single_lemma] x)) >> + POP_ASSUM (fn x => ASSUME_TAC (RW[mw_mul_by_single_lemma] x)) >> qpat_assum `w2n q3 = xxx` (fn x => FULL_SIMP_TAC std_ss [x]) >> METIS_TAC[X_LE_DIV,NOT_LESS,DECIDE ``z < SUC z``], ALL_TAC] >> @@ -2541,7 +2541,7 @@ THENL[`(w2n q2 = mw2n (REVERSE us) DIV mw2n (REVERSE ys)) \/(w2n q2 = SUC (mw2n `mw2n (FRONT w) = mw2n w` by ( `mw2n w < dimword(:'a) ** LENGTH (FRONT w)` by ( qpat_assum `mw2n xx = mw2n yy - mw2n zz` (fn x => ( - rw[rich_listTheory.LENGTH_BUTLAST,prim_recTheory.PRE] >> + srw_tac[][rich_listTheory.LENGTH_BUTLAST,prim_recTheory.PRE] >> ASSUME_TAC x)) >> POP_ASSUM (fn x => REWRITE_TAC[x]) >> markerLib.UNABBREV_TAC "q3ys" >> @@ -2551,7 +2551,7 @@ THENL[`(w2n q2 = mw2n (REVERSE us) DIV mw2n (REVERSE ys)) \/(w2n q2 = SUC (mw2n `LENGTH zs = SUC (LENGTH zs2)` by ( markerLib.UNABBREV_TAC "zs2" >> REWRITE_TAC[LENGTH_APPEND,LENGTH_REVERSE,LENGTH_DROP] >> - rw[rich_listTheory.LENGTH_BUTLAST,prim_recTheory.PRE] >> + srw_tac[][rich_listTheory.LENGTH_BUTLAST,prim_recTheory.PRE] >> RW_TAC arith_ss[]) >> Cases_on `LENGTH ys < LENGTH zs2` THENL[tac_div_loop_bis_1,tac_div_loop_bis_2,tac_div_loop_bis_1,tac_div_loop_bis_2]); From 3699fbd2c072be97777372a673931ebe6b8b3c99 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 29 Jan 2016 15:11:57 +1100 Subject: [PATCH 667/718] Relax indentation rules for polyscripter commands In particular, allow things like >>__ val foo = ... .. more text .. Previously, polyscripter would delete text on following lines to make everything line up with the "val" above. --- Manual/Tools/expected1 | 8 ++++++++ Manual/Tools/polyscripter.sml | 14 ++++++++++---- Manual/Tools/testinput1 | 10 ++++++++++ 3 files changed, 28 insertions(+), 4 deletions(-) diff --git a/Manual/Tools/expected1 b/Manual/Tools/expected1 index d66bd11608..9cfe2581eb 100644 --- a/Manual/Tools/expected1 +++ b/Manual/Tools/expected1 @@ -98,3 +98,11 @@ val it = 0 < 0 \(\Rightarrow\) 0 < 0 * 0 + +> val foo = store_thm( +"foo", +``p /\bs{} q ==> p``, +strip_tac); +val foo = |- p \(\land\) q \(\Rightarrow\) p: thm +> foo; +val it = |- p \(\land\) q \(\Rightarrow\) p: thm diff --git a/Manual/Tools/polyscripter.sml b/Manual/Tools/polyscripter.sml index 11560ff293..5be0720ee6 100644 --- a/Manual/Tools/polyscripter.sml +++ b/Manual/Tools/polyscripter.sml @@ -224,13 +224,18 @@ fun process_line umap (obuf as (_, _, obRST)) origline lbuf = let val _ = advance lbuf val handlePromptSize = if userPromptSize > oPsize then - fn s => String.extract(s, userPromptSize - oPsize, NONE) + fn i => fn s => + if i < userPromptSize then + s |> Substring.full |> Substring.dropl Char.isSpace + |> Substring.string + else + String.extract(s, userPromptSize - oPsize, NONE) else let val ws_n = CharVector.tabulate(oPsize - userPromptSize, fn _ => #" ") in - fn s => ws_n ^ s + fn i => fn s => ws_n ^ s end in case current lbuf of @@ -238,9 +243,10 @@ fun process_line umap (obuf as (_, _, obRST)) origline lbuf = let | SOME s => let val (ws',_) = getIndent s + val wssz = String.size ws' in - if indent < String.size ws' - then getRest userPromptSize (handlePromptSize s::acc) + if indent < wssz + then getRest userPromptSize (handlePromptSize wssz s::acc) else String.concat (List.rev acc) end end diff --git a/Manual/Tools/testinput1 b/Manual/Tools/testinput1 index 8dea1e863e..5c57de18c5 100644 --- a/Manual/Tools/testinput1 +++ b/Manual/Tools/testinput1 @@ -52,3 +52,13 @@ bar >>__ g `!n. 0 < n ==> 0 < n * n`; >> e Induct; + +>> val foo = store_thm( + "foo", + ``p /\ q ==> p``, + strip_tac); +>>__ val foo = store_thm( + "foo", + ``p /\ q ==> p``, + strip_tac); +>> foo; From d1e5092484d9f9370608f70c79746c6eaf821785 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 29 Jan 2016 15:53:45 +1100 Subject: [PATCH 668/718] Improve Tutorial's combin chapter w/ polyscripter --- Manual/Tutorial/combin.stex | 912 ++++++++++++------------------------ 1 file changed, 288 insertions(+), 624 deletions(-) diff --git a/Manual/Tutorial/combin.stex b/Manual/Tutorial/combin.stex index 15715adb05..9c3ad63b44 100644 --- a/Manual/Tutorial/combin.stex +++ b/Manual/Tutorial/combin.stex @@ -39,18 +39,16 @@ to introduce the notion of application. For lack of a better ASCII symbol, we will use the hash (\#) to represent this in the logic: \setcounter{sessioncount}{0} \begin{session} -\begin{verbatim} -- Datatype `cl = K | S | # cl cl`; -> val it = () : unit -\end{verbatim} +\begin{alltt} +>> Datatype `cl = K | S | # cl cl`; +\end{alltt} \end{session} We also want the \# to be an infix, so we set its fixity to be a tight left-associative infix: \begin{session} -\begin{verbatim} -- set_fixity "#" (Infixl 1100); -> val it = () : unit -\end{verbatim} +\begin{alltt} +>> set_fixity "#" (Infixl 1100); +\end{alltt} \end{session} @@ -84,10 +82,9 @@ In HOL, we can capture this relation with an inductive definition. First we need to set our arrow symbol up as an infix to make everything that bit prettier \begin{session} -\begin{verbatim} -- set_fixity "-->" (Infix(NONASSOC, 450)); -> val it = () : unit -\end{verbatim} +\begin{alltt} +>> set_fixity "-->" (Infix(NONASSOC, 450)); +\end{alltt} \end{session} We make our arrow symbol non-associative, thereby making it a parse error to write \verb!x --> y --> z!. It would be nice to be able @@ -108,38 +105,22 @@ doing this returns three separate theorems, and we bind the first (the third (the ``cases'' theorem): \begin{session} \begin{alltt} -val (redn_rules, _, redn_cases) = xHol_reln "redn" - `(!x y f. x --> y ==> f # x --> f # y) /\bs - (!f g x. f --> g ==> f # x --> g # x) /\bs - (!x y. K # x # y --> x) /\bs - (!f g x. S # f # g # x --> (f # x) # (g # x))`; -> val redn_rules = - |- (\(\forall\)x y f. x --> y \(\Rightarrow\) f # x --> f # y) \(\land\) - (\(\forall\)f g x. f --> g \(\Rightarrow\) f # x --> g # x) \(\land\) - (\(\forall\)x y. K # x # y --> x) \(\land\) - \(\forall\)f g x. S # f # g # x --> f # x # (g # x) : thm - val redn_cases = - |- \(\forall\)a0 a1. - a0 --> a1 \(\Leftrightarrow\) - (\(\exists\)x y f. (a0 = f # x) \(\land\) (a1 = f # y) \(\land\) x --> y) \(\lor\) - (\(\exists\)f g x. (a0 = f # x) \(\land\) (a1 = g # x) \(\land\) f --> g) \(\lor\) - (\(\exists\)y. a0 = K # a1 # y) \(\lor\) - \(\exists\)f g x. (a0 = S # f # g # x) \(\land\) (a1 = f # x # (g # x)) - : thm +>> val (redn_rules, _, redn_cases) = xHol_reln "redn" + `(!x y f. x --> y ==> f # x --> f # y) /\ + (!f g x. f --> g ==> f # x --> g # x) /\ + (!x y. K # x # y --> x) /\ + (!f g x. S # f # g # x --> (f # x) # (g # x))`; \end{alltt} \end{session} -In addition to proving these three theorems for us, the inductive -definitions package has also saved them to disk. +In addition to proving these three theorems for us, the inductive definitions package will also save them to disk when the theory is exported. Now, using our theorem \texttt{redn\_rules} we can demonstrate single steps of our reduction relation: \begin{session} -\begin{verbatim} -- PROVE [redn_rules] ``S # (K # x # x) --> S # x``; -Meson search level: ... -> val it = |- S # (K # x # x) --> S # x : thm -\end{verbatim} +\begin{alltt} +>> PROVE [redn_rules] ``S # (K # x # x) --> S # x``; +\end{alltt} \end{session} The system we have just defined is as powerful as the $\lambda$-calculus, Turing machines, and all the other standard models @@ -171,40 +152,30 @@ we will develop this notion independently and prove a variety of results that are true of any system, not just our system of combinatory logic. -So, we begin our abstract digression with another inductive -definition. Our new constant is \con{RTC}, such that -$\con{RTC}\;R\;x\;y$ is true if it is possible to get from $x$ to $y$ -with zero or more ``steps'' of the $R$ relation. (The standard -notation for $\con{RTC}\;R$ is $R^*$.) We can express this idea with -just two rules. The first \[ \infer{\con{RTC}\;R\;x\;x}{} \] says -that it's always possible to get from $x$ to $x$ in zero or more -steps. The second \[ +So, we begin our abstract digression with another inductive definition. +Our new constant is \con{RTC}, such that $\con{RTC}\;R\;x\;y$ is true if it is possible to get from $x$ to $y$ with zero or more ``steps'' of the $R$ relation. +(The standard notation for $\con{RTC}\;R$ is $R^*$; we will see \HOL{} try to approximate this with the text \holtxt{R\^{}*}.) +We can express this idea with just two rules. +The first +\[ \infer{\con{RTC}\;R\;x\;x}{} \] +says that it's always possible to get from $x$ to $x$ in zero or more steps. +The second \[ \infer{\con{RTC}\;R\;x\;z}{R\;x\;y\qquad\con{RTC}\;R\;y\;z} -\] says that if you can take a single step from $x$ to $y$, and then -take zero or more steps to get $y$ to $z$, then it's possible to take -zero or more steps to get between $x$ and $z$. The realisation of -these rules in HOL is again straightforward. +\] +says that if you can take a single step from $x$ to $y$, and then take zero or more steps to get $y$ to $z$, then it's possible to take zero or more steps to get between $x$ and $z$. +The realisation of these rules in HOL is again straightforward. -(As it happens, \con{RTC} is already a defined constant in the context -we're working in (it is found in \texttt{relationTheory}), so we'll -hide it from view before we begin. We thus avoid messages telling us -that we are inputting ambiguous terms. The ambiguities would always -be resolved in the favour of more recent definition, but the warnings -are annoying.) +(As it happens, \con{RTC} is already a defined constant in the context we're working in (it is found in \texttt{relationTheory}), so we'll hide it from view before we begin. +We thus avoid messages telling us that we are inputting ambiguous terms. +The ambiguities would always be resolved in the favour of more recent definition, but the warnings are annoying. +We inherit the nice syntax for the old constant with our new one.) \begin{session} \begin{alltt} -val _ = hide "RTC"; +>> val _ = hide "RTC"; -val (RTC_rules, _, RTC_cases) = Hol_reln ` - (!x. RTC R x x) /\bs - (!x y z. R x y /\bs RTC R y z ==> RTC R x z)`; -<> -> val RTC_rules = - |- \(\forall\)R. (\(\forall\)x. RTC R x x) \(\land\) - \(\forall\)x y z. R x y \(\land\) RTC R y z \(\Rightarrow\) RTC R x z : thm - val RTC_cases = - |- \(\forall\)R a0 a1. RTC R a0 a1 \(\Leftrightarrow\) (a1 = a0) \(\lor\) - \(\exists\)y. R a0 y \(\land\) RTC R y a1 : thm +>> val (RTC_rules, _, RTC_cases) = Hol_reln ` + (!x. RTC R x x) /\ + (!x y z. R x y /\ RTC R y z ==> RTC R x z)`; \end{alltt} \end{session} Now let us go back to the notion of confluence. We want this to mean @@ -212,12 +183,12 @@ something like: ``though a system may take different paths in the short-term, those two paths can always end up in the same place''. This suggests that we define confluent thus: \begin{session} -\begin{verbatim} -- val confluent_def = Define +\begin{alltt} +>> val confluent_def = Define `confluent R = !x y z. RTC R x y /\ RTC R x z ==> ?u. RTC R y u /\ RTC R z u`; -\end{verbatim} +\end{alltt} \end{session} This property states of $R$ that we can ``complete the diamond''; if we have @@ -251,10 +222,7 @@ point they produce no more than one \emph{normal form}, where a normal form is a value from which no further steps can be taken. \begin{session} \begin{alltt} -- val normform_def = Define`normform R x = !y. ~(R x y)`; -<> -Definition has been stored under "normform_def". -> val normform_def = |- \(\forall\)R x. normform R x \(\Leftrightarrow\) \(\forall\)y. \(\neg\)R x y : thm +>> val normform_def = Define`normform R x = !y. ~(R x y)`; \end{alltt} \end{session} In other words, a system has an $R$-normal form at $x$ if there are no @@ -264,55 +232,23 @@ connections via $R$ to any other values. (We could have written We can now prove the following: \begin{session} \begin{alltt} -- g `!R. confluent R ==> +>> g `!R. confluent R ==> !x y z. - RTC R x y /\bs normform R y /\bs - RTC R x z /\bs normform R z ==> (y = z)`; -<> -> val it = - Proof manager status: 1 proof. - 1. Incomplete: - Initial goal: - \(\forall\)R. - confluent R \(\Rightarrow\) - \(\forall\)x y z. RTC R x y \(\land\) normform R y \(\land\) RTC R x z \(\land\) normform R z \(\Rightarrow\) - (y = z) + RTC R x y /\ normform R y /\ + RTC R x z /\ normform R z ==> (y = z)`; \end{alltt} \end{session} We rewrite with the definition of confluence: \begin{session} \begin{alltt} -- e (RW_TAC std_ss [confluent_def]); -OK.. -1 subgoal: -> val it = - y = z - ------------------------------------ - 0. \(\forall\)x y z. RTC R x y \(\land\) RTC R x z \(\Rightarrow\) \(\exists\)u. RTC R y u \(\land\) RTC R z u - 1. RTC R x y - 2. normform R y - 3. RTC R x z - 4. normform R z +>> e (rw[confluent_def]); \end{alltt} \end{session} Our confluence property is now assumption 0, and we can use it to infer that there is a $u$ at the base of the diamond: \begin{session} \begin{alltt} -- e (`?u. RTC R y u /\bs RTC R z u` by PROVE_TAC []); -OK.. -Meson search level: ......... -1 subgoal: -> val it = - y = z - ------------------------------------ - 0. \(\forall\)x y z. RTC R x y \(\land\) RTC R x z \(\Rightarrow\) \(\exists\)u. RTC R y u \(\land\) RTC R z u - 1. RTC R x y - 2. normform R y - 3. RTC R x z - 4. normform R z - 5. RTC R y u - 6. RTC R z u +>> e (`?u. RTC R y u /\ RTC R z u` by metis_tac []); \end{alltt} \end{session} So, from $y$ we can take zero or more steps to get to $u$ and @@ -323,66 +259,52 @@ Meson search level: ......... finish with \begin{session} \begin{alltt} -- e (PROVE_TAC [normform_def, RTC_cases]); -OK.. -Meson search level: .......... - -Goal proved. [...] -> val it = - Initial goal proved. - |- \(\forall\)R. - confluent R \(\Rightarrow\) - \(\forall\)x y z. - RTC R x y \(\land\) normform R y \(\land\) RTC R x z \(\land\) normform R z \(\Rightarrow\) - (y = z) +>> e (metis_tac [normform_def, RTC_cases]); \end{alltt} \end{session} Packaged up so as to remove the sub-goal package commands, we can prove and save the theorem for future use by: \begin{session} -\begin{verbatim} -val confluent_normforms_unique = store_thm( - "confluent_normforms_unique", - ``!R. confluent R ==> - !x y z. RTC R x y /\ normform R y /\ - RTC R x z /\ normform R z ==> (y = z)``, - RW_TAC std_ss [confluent_def] THEN - `?u. RTC R y u /\ RTC R z u` by PROVE_TAC [] THEN - PROVE_TAC [normform_def, RTC_cases]); -\end{verbatim} +\begin{alltt} +>> val confluent_normforms_unique = store_thm( + "confluent_normforms_unique", + ``!R. confluent R ==> + !x y z. RTC R x y /\ normform R y /\ + RTC R x z /\ normform R z ==> (y = z)``, + rw[confluent_def] >> + `?u. RTC R y u /\ RTC R z u` by metis_tac [] >> + metis_tac [normform_def, RTC_cases]); +\end{alltt} \end{session} \eos{} Clearly confluence is a nice property for a system to have. The -question is how we might manage to prove it. Let's start by defining -the diamond property that we used in the definition of confluence. +question is how we might manage to prove it. +Let's start by defining the diamond property that we used in the definition of confluence. +We'll again hide the existing definition of ``diamond'': \begin{session} \begin{alltt} -- val diamond_def = Define - `diamond R = !x y z. R x y /\bs R x z ==> ?u. R y u /\bs R z u`; -<> -Definition has been stored under "diamond_def". -> val diamond_def = - |- \(\forall\)R. diamond R \(\Leftrightarrow\) \(\forall\)x y z. R x y \(\land\) R x z \(\Rightarrow\) \(\exists\)u. R y u \(\land\) R z u - : thm +>> val _ = hide "diamond"; +>> val diamond_def = Define + `diamond R = !x y z. R x y /\ R x z ==> ?u. R y u /\ R z u`; \end{alltt} \end{session} Now we clearly have that confluence of a relation is equivalent to the reflexive, transitive closure of that relation having the diamond property. \begin{session} -\begin{verbatim} -val confluent_diamond_RTC = store_thm( - "confluent_diamond_RTC", - ``!R. confluent R = diamond (RTC R)``, - RW_TAC std_ss [confluent_def, diamond_def]); -\end{verbatim} +\begin{alltt} +>> val confluent_diamond_RTC = store_thm( + "confluent_diamond_RTC", + ``!R. confluent R = diamond (RTC R)``, + rw[confluent_def, diamond_def]); +\end{alltt} \end{session} So far so good. How then do we show the diamond property for $\con{RTC}\;R$? The answer that leaps to mind is to hope that if the original relation has the diamond property, then maybe the reflexive and transitive closure will too. The theorem we want is - \[ \con{diamond}\;R \supset \con{diamond}\,(\con{RTC}\;R)\] Graphically, + \[ \con{diamond}\;R \;\Rightarrow\; \con{diamond}\,(\con{RTC}\;R)\] Graphically, this is hoping that from \[\xymatrix @R=5mm @C=2.5mm { & x \ar[dl] \ar[dr] & \\ @@ -418,32 +340,19 @@ induction principle for \con{RTC}.\footnote{In this and subsequent no harm in leaving these goals on the proof manager's stack.} \begin{session} \begin{alltt} -- g `!R. diamond R ==> - !x p. RTC R x p ==> - !z. R x z ==> - ?u. RTC R p u /\bs RTC R z u`; -<> -> val it = - Proof manager status: 1 proof. - 1. Incomplete: - Initial goal: - \(\forall\)R. - diamond R \(\Rightarrow\) - \(\forall\)x p. RTC R x p \(\Rightarrow\) \(\forall\)z. R x z \(\Rightarrow\) \(\exists\)u. RTC R p u \(\land\) RTC R z u +>>__ dropn 1; +>> g `!R. diamond R ==> + !x p. RTC R x p ==> + !z. R x z ==> + ?u. RTC R p u /\ RTC R z u`; \end{alltt} \end{session} -First, we strip away the diamond property assumption (two things need to -be stripped: the outermost universal quantifier and the antecedent of -the implication): +First, we strip away the diamond property assumption (two things need to be stripped: the outermost universal quantifier and the antecedent of the implication). +If we use \ml{rw} at this point, we strip away too much so we have to be more precise and use the lower level tool \ml{strip\_tac}. +This tactic will remove a universal quantification, an implication or a conjunction: \begin{session} \begin{alltt} -- e (GEN_TAC THEN STRIP_TAC); -OK.. -1 subgoal: -> val it = - \(\forall\)x p. RTC R x p \(\Rightarrow\) \(\forall\)z. R x z \(\Rightarrow\) \(\exists\)u. RTC R p u \(\land\) RTC R z u - ------------------------------------ - diamond R +>> e (strip_tac >> strip_tac); \end{alltt} \end{session} Now we can use the induction principle for reflexive and transitive closure (alternatively, we perform a ``rule induction''). @@ -454,38 +363,14 @@ We provide the name of the constant whose induction principle we want to use, and the tactic does the rest: \begin{session} \begin{alltt} -- e (Induct_on `RTC`); -OK.. -1 subgoal: -> val it = - (\(\forall\)x z. R x z \(\Rightarrow\) \(\exists\)u. RTC R x u \(\land\) RTC R z u) \(\land\) - \(\forall\)x x' p. - R x x' \(\land\) RTC R x' p \(\land\) (\(\forall\)z. R x' z \(\Rightarrow\) \(\exists\)u. RTC R p u \(\land\) RTC R z u) \(\Rightarrow\) - \(\forall\)z. R x z \(\Rightarrow\) \(\exists\)u. RTC R p u \(\land\) RTC R z u - ------------------------------------ - diamond R +>> e (Induct_on `RTC`); \end{alltt} \end{session} Let's strip the goal as much as possible with the aim of making what remains to be proved easier to see: \begin{session} \begin{alltt} -- e (REPEAT STRIP_TAC); -OK.. -2 subgoals: -> val it = - \(\exists\)u. RTC R p u \(\land\) RTC R z u - ------------------------------------ - 0. diamond R - 1. R x x' - 2. RTC R x' p - 3. \(\forall\)z. R x' z \(\Rightarrow\) \(\exists\)u. RTC R p u \(\land\) RTC R z u - 4. R x z - - \(\exists\)u. RTC R x u \(\land\) RTC R z u - ------------------------------------ - 0. diamond R - 1. R x z +>> e (rw[]); \end{alltt} \end{session} This first goal is easy. It corresponds to the case where the many @@ -493,25 +378,11 @@ steps from $x$ to $p$ are actually no steps at all, and $p$ and $x$ are actually the same place. In the other direction, $x$ has taken one step to $z$, and we need to find somewhere reachable in zero or more steps from both $x$ and $z$. Given what we know so far, the only -candidate is $z$ itself. In fact, we don't even need to provide this -witness explicitly. \texttt{PROVE\_TAC} will find it for us, as long -as we tell it what the rules governing \con{RTC} are: +candidate is $z$ itself. +In fact, we don't even need to provide this witness explicitly: \texttt{metis\_tac} will find it for us, as long as we tell it what the rules governing \con{RTC} are: \begin{session} \begin{alltt} -- e (PROVE_TAC [RTC_rules]); -OK.. -Meson search level: ..... - -Goal proved. [..] |- \(\exists\)u. RTC R p u \(\land\) RTC R z u -Remaining subgoals: -> val it = - \(\exists\)u. RTC R p u \(\land\) RTC R z u - ------------------------------------ - 0. diamond R - 1. R x x' - 2. RTC R x' p - 3. \(\forall\)z. R x' z \(\Rightarrow\) \(\exists\)u. RTC R p u \(\land\) RTC R z u - 4. R x z +>> e (metis_tac [RTC_rules]); \end{alltt} \end{session} And what of this remaining goal? Assumptions one and four @@ -520,127 +391,67 @@ Remaining subgoals: exists a $v$ to which $y$ and $z'$ can both take single steps: \begin{session} \begin{alltt} -- e (`?v. R x' v /\bs R z v` by PROVE_TAC [diamond_def]); -OK.. -Meson search level: ............ -1 subgoal: -> val it = - \(\exists\)u. RTC R p u \(\land\) RTC R z u - ------------------------------------ - 0. diamond R - 1. R x x' - 2. RTC R x' p - 3. \(\forall\)z. R x' z \(\Rightarrow\) \(\exists\)u. RTC R p u \(\land\) RTC R z u - 4. R x z - 5. R x' v - 6. R z v +>> e (`?v. R x' v /\ R z v` by metis_tac [diamond_def]); \end{alltt} \end{session} Now we can apply our induction hypothesis (assumption 3) to complete -the long, lop-sided strip of the diamond. We will conclude that there -is a $u$ such that $\con{RTC}\;R\;p\;u$ and $\con{RTC}\;R\;v\;u$. We -actually need a $u$ such that $\con{RTC}\;R\;z\;u$, but because there -is a single $R$-step between $z$ and $v$ we have that as well. All -we need to provide \texttt{PROVE\_TAC} is the rules for \con{RTC}: +the long, lop-sided strip of the diamond. +We will conclude that there is a $u$ such that $R^*\;p\;u$ and $R^*\;v\;u$. +We actually need a $u$ such that $\con{RTC}\;R\;z\;u$, but because there is a single $R$-step between $z$ and $v$ we have that as well. +All we need to provide \texttt{PROVE\_TAC} is the rules for \con{RTC}: \begin{session} \begin{alltt} -- e (PROVE_TAC [RTC_rules]); -OK.. -Meson search level: ....... - -Goal proved. [...] -> val it = - Initial goal proved. - |- \(\forall\)R. - diamond R \(\Rightarrow\) - \(\forall\)x p. RTC R x p \(\Rightarrow\) \(\forall\)z. R x z \(\Rightarrow\) \(\exists\)u. RTC R p u \(\land\) RTC R z u +>> e (metis_tac [RTC_rules]); +##assert can top_thm() \end{alltt} \end{session} Again we can (and should) package up the lemma, avoiding the sub-goal package commands: \begin{session} -\begin{verbatim} -val R_RTC_diamond = store_thm( - "R_RTC_diamond", - ``!R. diamond R ==> - !x p. RTC R x p ==> - !z. R x z ==> - ?u. RTC R p u /\ RTC R z u``, - GEN_TAC THEN STRIP_TAC THEN Induct_on `RTC` THEN - REPEAT STRIP_TAC THENL [ - PROVE_TAC [RTC_rules], - `?v. R x' v /\ R z v` by PROVE_TAC [diamond_def] THEN - PROVE_TAC [RTC_rules] - ]); -\end{verbatim} +\begin{alltt} +>>_ val R_RTC_diamond = store_thm( + "R_RTC_diamond", + ``!R. diamond R ==> + !x p. RTC R x p ==> + !z. R x z ==> + ?u. RTC R p u /\ RTC R z u``, + strip_tac >> strip_tac >> Induct_on `RTC` >> rw[] >| [ + metis_tac [RTC_rules], + `?v. R x' v /\ R z v` by metis_tac [diamond_def] >> + metis_tac [RTC_rules] + ]); +\end{alltt} \end{session} \eos{} -Now we can move on to proving that if $R$ has the diamond property, so -too does $\con{RTC}\;R$. We want to prove this by induction again. +Now we can move on to proving that if $R$ has the diamond property, so too does $R^*$. +We want to prove this by induction again. It's very tempting to state the goal as the obvious \[ -\con{diamond}\;R\supset\con{diamond}\,(\con{RTC}\;R) -\] but doing so will actually make it harder to apply the induction -principle when the time is right. Better to start out with a -statement of the goal that is very near in form to the induction -princple. So, we manually expand the meaning of \con{diamond} and state -our next goal thus: -\begin{session} -\begin{alltt} -- g `!R. diamond R ==> !x y. RTC R x y ==> - !z. RTC R x z ==> - ?u. RTC R y u /\bs RTC R z u`; -<> -> val it = - Proof manager status: 1 proof. - 1. Incomplete: - Initial goal: - \(\forall\)R. - diamond R \(\Rightarrow\) - \(\forall\)x y. RTC R x y \(\Rightarrow\) \(\forall\)z. RTC R x z \(\Rightarrow\) \(\exists\)u. RTC R y u \(\land\) RTC R z u +\con{diamond}\;R\;\Rightarrow\;\con{diamond}\,(R^*) +\] +but doing so will actually make it harder to apply the induction principle when the time is right. +Better to start out with a statement of the goal that is very near in form to the induction princple. +So, we manually expand the meaning of \con{diamond} and state our next goal thus: +\begin{session} +\begin{alltt} +>>__ dropn 1; +>> g `!R. diamond R ==> !x y. RTC R x y ==> + !z. RTC R x z ==> + ?u. RTC R y u /\ RTC R z u`; \end{alltt} \end{session} Again we strip the diamond property assumption, apply the induction principle, and strip repeatedly: \begin{session} \begin{alltt} -- e (GEN_TAC THEN STRIP_TAC THEN Induct_on `RTC` THEN REPEAT STRIP_TAC); -OK.. -2 subgoals: -> val it = - \(\exists\)u. RTC R y u \(\land\) RTC R z u - ------------------------------------ - 0. diamond R - 1. R x x' - 2. RTC R x' y - 3. \(\forall\)z. RTC R x' z \(\Rightarrow\) \(\exists\)u. RTC R y u \(\land\) RTC R z u - 4. RTC R x z - - \(\exists\)u. RTC R x u \(\land\) RTC R z u - ------------------------------------ - 0. diamond R - 1. RTC R x z +>> e (strip_tac >> strip_tac >> Induct_on `RTC` >> rw[]); \end{alltt} \end{session} The first goal is again an easy one, corresponding to the case where the trip from $x$ to $y$ has been one of no steps whatsoever. \begin{session} \begin{alltt} -- e (PROVE_TAC [RTC_rules]); -OK.. -Meson search level: ... - -Goal proved. [...] - -Remaining subgoals: -> val it = - \(\exists\)u. RTC R y u \(\land\) RTC R z u - ------------------------------------ - 0. diamond R - 1. R x x' - 2. RTC R x' y - 3. \(\forall\)z. RTC R x' z \(\Rightarrow\) \(\exists\)u. RTC R y u \(\land\) RTC R z u - 4. RTC R x z +>> e (metis_tac [RTC_rules]); \end{alltt} \end{session} This goal is very similar to the one we saw earlier. We have the top @@ -648,20 +459,7 @@ of a (``lop-sided'') diamond in assumptions 1 and 4, so we can infer the existence of a common destination for $x'$ and $z$: \begin{session} \begin{alltt} -- e (`?v. RTC R x' v /\bs RTC R z v` by PROVE_TAC [R_RTC_diamond]); -OK.. -Meson search level: ............ -1 subgoal: -> val it = - \(\exists\)u. RTC R y u \(\land\) RTC R z u - ------------------------------------ - 0. diamond R - 1. R x x' - 2. RTC R x' y - 3. \(\forall\)z. RTC R x' z \(\Rightarrow\) \(\exists\)u. RTC R y u \(\land\) RTC R z u - 4. RTC R x z - 5. RTC R x' v - 6. RTC R z v +>> e (`?v. RTC R x' v /\ RTC R z v` by metis_tac [R_RTC_diamond]); \end{alltt} \end{session} At this point in the last proof we were able to finish it all off @@ -670,44 +468,40 @@ Meson search level: ............ (assumption 3), we can conclude that there is a $u$ to which both $y$ and $v$ can connect in zero or more steps, but in order to show that this $u$ is reachable from $z$, we need to be able to - conclude $\con{RTC}\;R\;z\;u$ when we know that - $\con{RTC}\;R\;z\;v$ (assumption 6 above) and - $\con{RTC}\;R\;v\;u$ (our consequence of the inductive + conclude $R^*\;z\;u$ when we know that + $R^*\;z\;v$ (assumption 6 above) and + $R^*\;v\;u$ (our consequence of the inductive hypothesis). We leave the proof of this general result as an exercise, and here assume that it is already proved as the theorem \texttt{RTC\_RTC}. \begin{session} \begin{alltt} -- e (PROVE_TAC [RTC_rules, RTC_RTC]); -Meson search level: ....... - -Goal proved. [...] -> val it = - Initial goal proved. - |- \(\forall\)R. - diamond R \(\Rightarrow\) - \(\forall\)x y. RTC R x y \(\Rightarrow\) \(\forall\)z. RTC R x z \(\Rightarrow\) \(\exists\)u. RTC R y u \(\land\) RTC R z u +>>__ val RTC_RTC = store_thm( + "RTC_RTC", + ``!R x y z. RTC R x y /\ RTC R y z ==> RTC R x z``, + simp[GSYM AND_IMP_INTRO, RIGHT_FORALL_IMP_THM] >> + gen_tac >> Induct_on `RTC` >> metis_tac [RTC_rules]); +>> e (metis_tac [RTC_rules, RTC_RTC]); \end{alltt} \end{session} We can package this result up as a lemma and then prove the prettier version directly: \begin{session} -\begin{verbatim} -val diamond_RTC_lemma = prove( - ``!R. - diamond R ==> - !x y. RTC R x y ==> !z. RTC R x z ==> ?u. RTC R y u /\ RTC R z u``, - GEN_TAC THEN STRIP_TAC THEN Induct_on `RTC` THEN - REPEAT STRIP_TAC THENL [ - PROVE_TAC [RTC_rules], - `?v. RTC R x' v /\ RTC R z v` by PROVE_TAC [R_RTC_diamond] THEN - PROVE_TAC [RTC_RTC, RTC_rules] - ]); -val diamond_RTC = store_thm( - "diamond_RTC", - ``!R. diamond R ==> diamond (RTC R)``, - PROVE_TAC [diamond_def,diamond_RTC_lemma]); -\end{verbatim} +\begin{alltt} +##eval val diamond_RTC_lemma = prove( + ``!R. + diamond R ==> + !x y. RTC R x y ==> !z. RTC R x z ==> ?u. RTC R y u /\ RTC R z u``, + strip_tac >> strip_tac >> Induct_on `RTC` >> rw[] >| [ + metis_tac [RTC_rules], + `?v. RTC R x' v /\ RTC R z v` by metis_tac [R_RTC_diamond] >> + metis_tac [RTC_RTC, RTC_rules] + ]); +##eval val diamond_RTC = store_thm( + "diamond_RTC", + ``!R. diamond R ==> diamond (RTC R)``, + metis_tac [diamond_def,diamond_RTC_lemma]); +\end{alltt} \end{session} \section{Back to combinators} @@ -717,7 +511,7 @@ Now, we are in a position to return to the real object of study and prove confluence for combinatory logic. We have done an abstract development and established that\[ \begin{array}{ccccc} -\con{diamond}\;R & \supset & \con{diamond}\,(\con{RTC}\;R)\\ +\con{diamond}\;R & \Rightarrow & \con{diamond}\,(\con{RTC}\;R)\\ & & \land\\ & & \con{diamond}\,(\con{RTC}\;R) & \equiv & \con{confluent}\;R\\ \end{array} @@ -756,10 +550,9 @@ Our new relation allows for any number of reductions to occur in parallel. We use the \texttt{-||->} symbol to indicate parallel reduction because of its own parallel lines: \begin{session} -\begin{verbatim} -- set_fixity "-||->" (Infix(NONASSOC, 450)); -> val it = () : unit -\end{verbatim} +\begin{alltt} +>> set_fixity "-||->" (Infix(NONASSOC, 450)); +\end{alltt} \end{session} Then we can define parallel reduction itself. The rules look very similar to those for $\rightarrow$. The difference is that we @@ -771,27 +564,13 @@ reduction because of its own parallel lines: application ($\KC\;x\;y$) can reduce, its RHS (\KC) can't. \begin{session} \begin{alltt} -- val (predn_rules, _, predn_cases) = xHol_reln "predn" - `(!x. x -||-> x) /\bs - (!x y u v. x -||-> y /\bs u -||-> v +>> val (predn_rules, _, predn_cases) = xHol_reln "predn" + `(!x. x -||-> x) /\ + (!x y u v. x -||-> y /\ u -||-> v ==> - x # u -||-> y # v) /\bs - (!x y. K # x # y -||-> x) /\bs + x # u -||-> y # v) /\ + (!x y. K # x # y -||-> x) /\ (!f g x. S # f # g # x -||-> (f # x) # (g # x))`; -> val predn_rules = - |- (\(\forall\)x. x -||-> x) \(\land\) - (\(\forall\)x y u v. x -||-> y \(\land\) u -||-> v \(\Rightarrow\) x # u -||-> y # v) \(\land\) - (\(\forall\)x y. K # x # y -||-> x) \(\land\) - \(\forall\)f g x. S # f # g # x -||-> f # x # (g # x) : thm - val predn_cases = - |- \(\forall\)a0 a1. - a0 -||-> a1 \(\Leftrightarrow\) - (a1 = a0) \(\lor\) - (\(\exists\)x y u v. (a0 = x # u) \(\land\) (a1 = y # v) \(\land\) - x -||-> y \(\land\) u -||-> v) \(\lor\) - (\(\exists\)y. a0 = K # a1 # y) \(\lor\) - \(\exists\)f g x. (a0 = S # f # g # x) \(\land\) (a1 = f # x # (g # x)) - : thm \end{alltt} \end{session} @@ -808,40 +587,31 @@ used. First, we create the desired symbol for the concrete syntax, and then we ``overload'' it so that the parser will expand it to the desired form. \begin{session} -\begin{verbatim} -- set_fixity "-->*" (Infix(NONASSOC, 450)); -> val it = () : unit +\begin{alltt} +>> set_fixity "-->*" (Infix(NONASSOC, 450)); -- overload_on ("-->*", ``RTC $-->``); -> val it = () : unit -\end{verbatim} +>> overload_on ("-->*", ``RTC $-->``); +\end{alltt} \end{session} We do exactly the same thing for the reflexive and transitive closure of our parallel reduction. \begin{session} \begin{verbatim} -- set_fixity "-||->*" (Infix(NONASSOC, 450)); -> val it = () : unit +>> set_fixity "-||->*" (Infix(NONASSOC, 450)); -- overload_on ("-||->*", ``RTC $-||->``); -> val it = () : unit +>> overload_on ("-||->*", ``RTC $-||->``); \end{verbatim} \end{session} Incidentally, in conjunction with \texttt{PROVE} we can now automatically demonstrate relatively long chains of reductions: \begin{session} -\begin{verbatim} -- PROVE [RTC_rules, redn_rules] ``S # K # K # x -->* x``; -Meson search level: ...... -> val it = |- S # K # K # x -->* x : thm +\begin{alltt} +>> PROVE [RTC_rules, redn_rules] ``S # K # K # x -->* x``; -- PROVE [RTC_rules, redn_rules] +>> PROVE [RTC_rules, redn_rules] ``S # (S # (K # S) # K) # (S # K # K) # f # x -->* f # (f # x)``; -Meson search level: ........................... -> val it = |- S # (S # (K # S) # K) # (S # K # K) # f # x -->* f # (f # x) - : thm -\end{verbatim} +\end{alltt} \end{session} (The latter sequence is seven reductions long.) @@ -852,40 +622,31 @@ Meson search level: ........................... We start with the easier direction, and show that everything in $\rightarrow^*$ is in $\mathpredn^*$. Because \con{RTC} is monotone (which fact is left to the reader to prove), -we can reduce this to showing that $x\rightarrow y\supset x\mathpredn y$. +we can reduce this to showing that $x\rightarrow y\Rightarrow x\mathpredn y$. Our goal: \begin{session} \begin{alltt} -- g `!x y. x -->* y ==> x -||->* y`; -> val it = - Proof manager status: 1 proof. - 1. Incomplete: - Initial goal: - \(\forall\)x y. x -->* y \(\Rightarrow\) x -||->* y +>>__ dropn 1; +>> g `!x y. x -->* y ==> x -||->* y`; \end{alltt} \end{session} We back-chain using our monotonicity result: \begin{session} \begin{alltt} -- e (MATCH_MP_TAC RTC_monotone); -OK.. -1 subgoal: -> val it = - \(\forall\)x y. x --> y \(\Rightarrow\) x -||-> y +>>__ val RTC_monotone = store_thm( + "RTC_monotone", + ``!R1 R2. (!x y. R1 x y ==> R2 x y) ==> + (!x y. RTC R1 x y ==> RTC R2 x y)``, + ntac 3 strip_tac >> Induct_on `RTC` >> + metis_tac [RTC_rules]); +>> e (match_mp_tac RTC_monotone); \end{alltt} \end{session} Now we can induct over the rules for $\rightarrow$: \begin{session} \begin{alltt} -- e (Induct_on `$-->`); -OK.. -1 subgoal: -> val it = - (\(\forall\)x y f. x --> y \(\land\) x -||-> y \(\Rightarrow\) f # x -||-> f # y) \(\land\) - (\(\forall\)f g x. f --> g \(\land\) f -||-> g \(\Rightarrow\) f # x -||-> g # x) \(\land\) - (\(\forall\)x y. K # x # y -||-> x) \(\land\) - \(\forall\)f g x. S # f # g # x -||-> f # x # (g # x) +>> e (Induct_on `$-->`); \end{alltt} \end{session} We could split the 4-way conjunction apart into four goals, but there @@ -893,25 +654,18 @@ is no real need. It is quite clear that each follows immediately from the rules for parallel reduction. \begin{session} \begin{alltt} -- e (PROVE_TAC [predn_rules]); -OK.. -Meson search level: ............ - -Goal proved. [...] -> val it = - Initial goal proved. - |- \(\forall\)x y. x -->* y \(\Rightarrow\) x -||->* y : goalstack +>> e (metis_tac [predn_rules]); \end{alltt} \end{session} Packaged into a tidy little sub-goal-package-free parcel, our proof is \begin{session} -\begin{verbatim} -val RTCredn_RTCpredn = store_thm( - "RTCredn_RTCpredn", - ``!x y. x -->* y ==> x -||->* y``, - MATCH_MP_TAC RTC_monotone THEN - Induct_on `$-->` THEN PROVE_TAC [predn_rules]); -\end{verbatim} +\begin{alltt} +##eval val RTCredn_RTCpredn = store_thm( + "RTCredn_RTCpredn", + ``!x y. x -->* y ==> x -||->* y``, + match_mp_tac RTC_monotone >> + Induct_on `$-->` >> metis_tac [predn_rules]); +\end{alltt} \end{session} \eos{} @@ -923,71 +677,45 @@ mirroring one step of the parallel reduction relation might take many steps of the original relation. Let's prove that then: \begin{session} \begin{alltt} -- g `!x y. x -||-> y ==> x -->* y`; -> val it = - Proof manager status: 1 proof. - 1. Incomplete: - Initial goal: - \(\forall\)x y. x -||-> y \(\Rightarrow\) x -->* y +>>__ dropn 1; +>> g `!x y. x -||-> y ==> x -->* y`; \end{alltt} \end{session} This time our induction will be over the rules defining the parallel reduction relation. \begin{session} \begin{alltt} -- e (Induct_on `$-||->`); -OK.. -1 subgoal: -> val it = - (\(\forall\)x. x -->* x) \(\land\) - (\(\forall\)x y x' y'. x -||-> y \(\land\) x -->* y \(\land\) x' -||-> y' \(\land\) x' -->* y' \(\Rightarrow\) - x # x' -->* y # y') \(\land\) - (\(\forall\)x y. K # x # y -->* x) \(\land\) - \(\forall\)f g x. S # f # g # x -->* f # x # (g # x) -\end{alltt} -\end{session} - There are four conjuncts here, and it should be clear that all but - the second can be proved immediately by appeal to the rules for - the transitive closure and for $\rightarrow$ itself. We could - split apart the conjunctions and enter a \texttt{THENL} branch. - However, we'd need to repeat the same tactic three times to - quickly close three of the four branches. Instead, we use the - \texttt{TRY} tactical to try applying the same tactic to all four - branches. If our tactic fails on branch \#2, as we expect, - \texttt{TRY} will protect us against this failure and let us - proceed. -\begin{session} -\begin{alltt} -e (REPEAT CONJ_TAC THEN - TRY (PROVE_TAC [RTC_rules, redn_rules])); -OK.. -Meson search level: .... -Meson search level: .... -Meson search level: ............................... -Meson search level: .. -1 subgoal: -> val it = - \(\forall\)x y x' y'. x -||-> y \(\land\) x -->* y \(\land\) x' -||-> y' \(\land\) x' -->* y' \(\Rightarrow\) - x # x' -->* y # y' +>> e (Induct_on `$-||->`); \end{alltt} \end{session} - Note that wrapping \texttt{TRY} around \texttt{PROVE\_TAC} is not - always wise. It can often take the \texttt{PROVE\_TAC} tactic an extremely - long time to exhaust its search space, and then give up with a - failure. Here, ``we got lucky''. - Anyway, what of this latest sub-goal? If we look at it for long - enough, we should see that it is another monotonicity fact. More - accurately, we need what is called a \emph{congruence} result for - \holtxt{-->*}. In this form, it's not quite right for easy proof. - Let's go away and prove \texttt{RTCredn\_ap\_monotonic} - separately. (Another exercise!) Our new theorem should state +There are four conjuncts here, and it should be clear that all but the second can be proved immediately by appeal to the rules for the transitive closure and for $\rightarrow$ itself. +So, we split apart the conjunctions and enter a \texttt{THENL} branch, putting in an \ml{all\_tac} in the 2nd position so that this falls through to be dealt with more carefully. +\begin{session} +\begin{alltt} +>> e (rpt conj_tac >| [metis_tac[RTC_rules, redn_rules], + all_tac, + metis_tac[RTC_rules, redn_rules], + metis_tac[RTC_rules, redn_rules] ]); +\end{alltt} +\end{session} +What of this latest sub-goal? +If we look at it for long enough, we should see that it is another monotonicity fact. +More accurately, we need what is called a \emph{congruence} result for \holtxt{-->*}. +In this form, it's not quite right for easy proof. +Let's go away and prove \texttt{RTCredn\_ap\_monotonic} separately. +(Another exercise!) +Our new theorem should state \begin{session} \begin{verbatim} val RTCredn_ap_congruence = store_thm( "RTCredn_ap_congruence", ``!x y. x -->* y ==> !z. x # z -->* y # z /\ z # x -->* z # y``, ...); +>>__ val RTCredn_ap_congruence = store_thm( + "RTCredn_ap_congruence", + ``!x y. x -->* y ==> !z. x # z -->* y # z /\ z # x -->* z # y``, + Induct_on `RTC` THEN PROVE_TAC [RTC_rules, redn_rules]); \end{verbatim} \end{session} Now that we have this, our sub-goal is almost immediately @@ -1000,30 +728,23 @@ val RTCredn_ap_congruence = store_thm( earlier \texttt{RTC\_RTC} result. \begin{session} \begin{alltt} -e (PROVE_TAC [RTC_RTC, RTCredn_ap_congruence]); -OK.. -Meson search level: ....... - -Goal proved. [...] -> val it = - Initial goal proved. - |- \(\forall\)x y. x -||-> y \(\Rightarrow\) x -->* y : goalstack +>> e (metis_tac [RTC_RTC, RTCredn_ap_congruence]); \end{alltt} \end{session} But given that we can finish off what we thought was an awkward branch -with just another application of \texttt{PROVE\_TAC}, we don't need to -use our fancy \texttt{TRY}-footwork at the stage before. Instead, we +with just another application of \texttt{metis\_tac}, we don't need to +use our fancy branching footwork at the stage before. Instead, we can just merge the theorem lists passed to both invocations, dispense -with the \texttt{REPEAT CONJ\_TAC} and have a very short tactic proof +with the \texttt{rpt~conj\_tac} and have a very short tactic proof indeed: \begin{session} -\begin{verbatim} -val predn_RTCredn = store_thm( - "predn_RTCredn", - ``!x y. x -||-> y ==> x -->* y``, - Induct_on `$-||->` THEN - PROVE_TAC [RTC_rules, redn_rules, RTC_RTC, RTCredn_ap_congruence]); -\end{verbatim} +\begin{alltt} +##eval val predn_RTCredn = store_thm( + "predn_RTCredn", + ``!x y. x -||-> y ==> x -->* y``, + Induct_on `$-||->` >> + metis_tac [RTC_rules, redn_rules, RTC_RTC, RTCredn_ap_congruence]); +\end{alltt} \end{session} \eos{} @@ -1032,23 +753,14 @@ are chained together, then we can mirror this with some number of steps using the original reduction relation. Our goal: \begin{session} \begin{alltt} -- g `!x y. x -||->* y ==> x -->* y`; -> val it = - Proof manager status: 1 proof. - 1. Incomplete: - Initial goal: - \(\forall\)x y. x -||->* y \(\Rightarrow\) x -->* y +>>__ dropn 1; +>> g `!x y. x -||->* y ==> x -->* y`; \end{alltt} \end{session} We use the appropriate induction principle to get to: \begin{session} \begin{alltt} -- e (Induct_on `RTC`); -OK.. -1 subgoal: -> val it = - (\(\forall\)x. x -->* x) \(\land\) - \(\forall\)x x' y. x -||-> x' \(\land\) x' -||-> y* \(\land\) x' -->* y \(\Rightarrow\) x -->* z +>> e (Induct_on `RTC`); \end{alltt} \end{session} This we can finish off in one step. The first conjunct is obvious, @@ -1057,80 +769,57 @@ tell us that \verb!x -->* y!. Then this can be chained together with the other assumption in the second conjunct and we're done. \begin{session} \begin{alltt} -- e (PROVE_TAC [RTC_rules, predn_RTCredn, RTC_RTC]); -OK.. -Meson search level: ....... - -Goal proved.[...] -> val it = - Initial goal proved. - |- \(\forall\)x y. x -||->* y \(\Rightarrow\) x -->* y : proof +>> e (metis_tac [RTC_rules, predn_RTCredn, RTC_RTC]); \end{alltt} \end{session} Packaged up, this proof is: \begin{session} -\begin{verbatim} -val RTCpredn_RTCredn = store_thm( - "RTCpredn_RTCredn", - ``!x y. x -||->* y ==> x -->* y``, - Induct_on `RTC` THEN PROVE_TAC [predn_RTCredn, RTC_RTC, RTC_rules]); -\end{verbatim} +\begin{alltt} +##eval val RTCpredn_RTCredn = store_thm( + "RTCpredn_RTCredn", + ``!x y. x -||->* y ==> x -->* y``, + Induct_on `RTC` >> metis_tac [predn_RTCredn, RTC_RTC, RTC_rules]); +\end{alltt} \end{session} \eos{} Our final act is to use what we have so far to conclude that $\rightarrow^*$ and $\mathpredn^*$ are equal. We state our goal: \begin{session} -\begin{verbatim} -- g `$-||->* = $-->*`; -> val it = - Proof manager status: 1 proof. - 1. Incomplete: - Initial goal: - $-||->* = $-->* -\end{verbatim} +\begin{alltt} +>>__ dropn 1; +>> g `$-||->* = $-->*`; +\end{alltt} \end{session} We want to now appeal to extensionality. The simplest way to do this is to rewrite with the theorem \texttt{FUN\_EQ\_THM}: \begin{session} \begin{alltt} -- FUN_EQ_THM; -> val it = |- \(\forall\)f g. (f = g) \(\Leftrightarrow\) \(\forall\)x. f x = g x : thm +>> FUN_EQ_THM; \end{alltt} \end{session} So, we rewrite: \begin{session} \begin{alltt} -- e (SIMP_TAC std_ss [FUN_EQ_THM]); -OK.. -1 subgoal: -> val it = - \(\forall\)x x'. x -||->* x' = x -->* x' +>> e (rw[FUN_EQ_THM]); \end{alltt} \end{session} This goal is an easy consequence of our two earlier implications. \begin{session} -\begin{verbatim} -- e (PROVE_TAC [RTCpredn_RTCredn, RTCredn_RTCpredn]); -OK.. -Meson search level: ...... - -Goal proved. [...] -> val it = - Initial goal proved. - |- $-||->* = $-->* : goalstack -\end{verbatim} +\begin{alltt} +>> e (metis_tac [RTCpredn_RTCredn, RTCredn_RTCpredn]); +\end{alltt} \end{session} Packaged, the proof is: \begin{session} -\begin{verbatim} -val RTCpredn_EQ_RTCredn = store_thm( - "RTCpredn_EQ_RTCredn", - ``$-||->* = $-->*``, - SIMP_TAC std_ss [FUN_EQ_THM] THEN - PROVE_TAC [RTCpredn_RTCredn, RTCredn_RTCpredn]); -\end{verbatim} +\begin{alltt} +##eval val RTCpredn_EQ_RTCredn = store_thm( + "RTCpredn_EQ_RTCredn", + ``$-||->* = $-->*``, + rw [FUN_EQ_THM] >> + metis_tac [RTCpredn_RTCredn, RTCredn_RTCpredn]); +\end{alltt} \end{session} @@ -1148,10 +837,9 @@ $\SC\;x\;y\;z$. To do this, we will write a little function that derives characterisations automatically: \begin{session} -\begin{verbatim} -- fun characterise t = SIMP_RULE (srw_ss()) [] (SPEC t predn_cases); -> val characterise = fn : term -> thm -\end{verbatim} +\begin{alltt} +>> fun characterise t = SIMP_RULE (srw_ss()) [] (SPEC t predn_cases); +\end{alltt} \end{session} The \ml{characterise} function specialises the theorem \ml{predn\_cases} with the input term, and then simplifies. The @@ -1160,97 +848,73 @@ disjointness of constructors and eliminates obvious impossibilities. For example, \begin{session} \begin{alltt} -- val K_predn = characterise ``K``; -<> -> val K_predn = |- \(\forall\)a1. K -||-> a1 = (a1 = K) : thm +>> val K_predn = characterise ``K``; -- val S_predn = characterise ``S``; -<> -> val S_predn = |- \(\forall\)a1. S -||-> a1 = (a1 = S) : thm +>> val S_predn = characterise ``S``; \end{alltt} \end{session} Unfortunately, what we get back from other inputs is not so good: \begin{session} \begin{alltt} -- val Sx_predn0 = characterise ``S # x``; -> val Sx_predn0 = - |- \(\forall\)a1. - S # x -||-> a1 = - (a1 = S # x) \(\lor\) - \(\exists\)y v. (a1 = y # v) \(\land\) S -||-> y \(\land\) x -||-> v : thm +>> val Sx_predn0 = characterise ``S # x``; \end{alltt} \end{session} That first disjunct is redundant, as the following demonstrates: \begin{session} -\begin{verbatim} -val Sx_predn = prove( - ``!x y. S # x -||-> y = ?z. (y = S # z) /\ (x -||-> z)``, - REPEAT GEN_TAC THEN EQ_TAC THEN - RW_TAC std_ss [Sx_predn0, predn_rules, S_predn]); -\end{verbatim} +\begin{alltt} +##eval val Sx_predn = prove( + ``!x y. S # x -||-> y = ?z. (y = S # z) /\ (x -||-> z)``, + rw[EQ_IMP_THM, Sx_predn0, predn_rules, S_predn]); +\end{alltt} \end{session} Our \texttt{characterise} function will just have to help us in the proofs that follow. \begin{session} -\begin{verbatim} -val Kx_predn = prove( - ``!x y. K # x -||-> y = ?z. (y = K # z) /\ (x -||-> z)``, - REPEAT GEN_TAC THEN EQ_TAC THEN - RW_TAC std_ss [characterise ``K # x``, predn_rules, K_predn]); -\end{verbatim} +\begin{alltt} +##eval val Kx_predn = prove( + ``!x y. K # x -||-> y = ?z. (y = K # z) /\ (x -||-> z)``, + rw[characterise ``K # x``, predn_rules, K_predn, EQ_IMP_THM]); +\end{alltt} \end{session} What of $\KC\;x\;y$? A little thought demonstrates that there really must be two cases this time. \begin{session} -\begin{verbatim} -val Kxy_predn = prove( - ``!x y z. - K # x # y -||-> z = - (?u v. (z = K # u # v) /\ (x -||-> u) /\ (y -||-> v)) \/ - (z = x)``, - REPEAT GEN_TAC THEN EQ_TAC THEN - RW_TAC std_ss [characterise ``K # x # y``, predn_rules, - Kx_predn]); -\end{verbatim} +\begin{alltt} +##eval val Kxy_predn = prove( + ``!x y z. + K # x # y -||-> z = + (?u v. (z = K # u # v) /\ (x -||-> u) /\ (y -||-> v)) \/ + (z = x)``, + rw[EQ_IMP_THM, characterise ``K # x # y``, predn_rules, Kx_predn]); +\end{alltt} \end{session} By way of contrast, there is only one case for $\SC\;x\;y$ because it is not yet a ``redex'' at the top-level. \begin{session} -\begin{verbatim} -val Sxy_predn = prove( - ``!x y z. S # x # y -||-> z = - ?u v. (z = S # u # v) /\ (x -||-> u) /\ (y -||-> v)``, - REPEAT GEN_TAC THEN EQ_TAC THEN - RW_TAC std_ss [characterise ``S # x # y``, predn_rules, - Sx_predn]); -\end{verbatim} +\begin{alltt} +##eval val Sxy_predn = prove( + ``!x y z. S # x # y -||-> z = + ?u v. (z = S # u # v) /\ (x -||-> u) /\ (y -||-> v)``, + rw[characterise ``S # x # y``, predn_rules, EQ_IMP_THM, Sx_predn]); +\end{alltt} \end{session} Next, the characterisation for $\SC\;x\;y\;z$: \begin{session} -\begin{verbatim} -val Sxyz_predn = prove( - ``!w x y z. S # w # x # y -||-> z = - (?p q r. (z = S # p # q # r) /\ - w -||-> p /\ x -||-> q /\ y -||-> r) \/ - (z = (w # y) # (x # y))``, - REPEAT GEN_TAC THEN EQ_TAC THEN - RW_TAC std_ss [characterise ``S # w # x # y``, predn_rules, - Sxy_predn]); -\end{verbatim} +\begin{alltt} +##eval val Sxyz_predn = prove( + ``!w x y z. S # w # x # y -||-> z = + (?p q r. (z = S # p # q # r) /\ + w -||-> p /\ x -||-> q /\ y -||-> r) \/ + (z = (w # y) # (x # y))``, + rw[characterise ``S # w # x # y``, predn_rules, EQ_IMP_THM, Sxy_predn]); +\end{alltt} \end{session} Last of all, we want a characterisation for $x\;y$. What \texttt{characterise} gives us this time can't be improved upon, for all that we might look upon the four disjunctions and despair. \begin{session} \begin{alltt} -- val x_ap_y_predn = characterise ``x # y``; -> val x_ap_y_predn = - |- \(\forall\)a1. - x # y -||-> a1 = - (a1 = x # y) \(\lor\) - (\(\exists\)y' v. (a1 = y' # v) \(\land\) x -||-> y' \(\land\) y -||-> v) \(\lor\) - (x = K # a1) \(\lor\) - \(\exists\)f g. (x = S # f # g) \(\land\) (a1 = f # y # (g # y)) : thm +>> val x_ap_y_predn = characterise ``x # y``; \end{alltt} \end{session} \eos{} @@ -1550,19 +1214,19 @@ examining the source file in \texttt{examples/ind\_def/clScript.sml}. \begin{enumerate} \item Prove that \[\con{RTC}\;R \;x\; y \;\;\land \;\; - \con{RTC}\;R\;y\;z\;\;\;\supset\;\;\; \con{RTC}\;R\;x\;z + \con{RTC}\;R\;y\;z\;\;\;\Rightarrow\;\;\; \con{RTC}\;R\;x\;z \] You will need to prove the goal by induction, and will probably need to massage it slightly first to get it to match the appropriate induction principle. Store the theorem under the name \texttt{RTC\_RTC}. \item Another induction. Show that \[ - (\forall x\,y.\; R_1\;x\;y\supset R_2\;x\;y) \supset - (\forall x\,y.\; \con{RTC}\;R_1\;x\;y \supset \con{RTC}\;R_2\;x\;y) + (\forall x\,y.\; R_1\;x\;y\Rightarrow R_2\;x\;y) \Rightarrow + (\forall x\,y.\; \con{RTC}\;R_1\;x\;y \Rightarrow \con{RTC}\;R_2\;x\;y) \] Call the resulting theorem \texttt{RTC\_monotone}. \item Yet another \con{RTC} induction, but where $R$ is no longer abstract, and is instead the original reduction relation. Prove \[ -x \rightarrow^* y \;\;\;\supset\;\;\; +x \rightarrow^* y \;\;\;\Rightarrow\;\;\; \forall z.\;\; x\;z \rightarrow^* y \;z \land z\;x \rightarrow^* z\;y \] Call it \texttt{RTCredn\_ap\_congruence}. @@ -1572,10 +1236,10 @@ z\;x \rightarrow^* z\;y \left( \begin{array}{ll} \forall x\,y\,z. & - R\;x\;y\;\;\land\;\; R\;x\;z \;\;\;\supset\\ + R\;x\;y\;\;\land\;\; R\;x\;z \;\;\;\Rightarrow\\ & \exists u.\;\con{RTC}\;R\;y\;u \;\;\land\;\;\con{RTC}\;R\;z\;u \end{array}\right)\\ - \supset\\ + \Rightarrow\\ \con{diamond}\;(\con{RTC}\;R) \end{array} \] From 7234540725cfa7318fadeecfbcda710798fab7d1 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 29 Jan 2016 16:10:21 +1100 Subject: [PATCH 669/718] polyscripter's ##assert shouldn't give blank line --- Manual/Tools/polyscripter.sml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Manual/Tools/polyscripter.sml b/Manual/Tools/polyscripter.sml index 5be0720ee6..77dce3db15 100644 --- a/Manual/Tools/polyscripter.sml +++ b/Manual/Tools/polyscripter.sml @@ -267,7 +267,7 @@ in Int.toString (linenum lbuf) ^ "\";")) val _ = advance lbuf in - ("\n", NONE) + ("", NONE) end else if String.isPrefix "##eval" line then let From 1e7b4a1f5cdd9f9346f2443bfd3ec22a8001042b Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 29 Jan 2016 16:30:47 +1100 Subject: [PATCH 670/718] Minor combin chapter tweak --- Manual/Tutorial/combin.stex | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Manual/Tutorial/combin.stex b/Manual/Tutorial/combin.stex index 9c3ad63b44..522062c8e9 100644 --- a/Manual/Tutorial/combin.stex +++ b/Manual/Tutorial/combin.stex @@ -398,7 +398,7 @@ Now we can apply our induction hypothesis (assumption 3) to complete the long, lop-sided strip of the diamond. We will conclude that there is a $u$ such that $R^*\;p\;u$ and $R^*\;v\;u$. We actually need a $u$ such that $\con{RTC}\;R\;z\;u$, but because there is a single $R$-step between $z$ and $v$ we have that as well. -All we need to provide \texttt{PROVE\_TAC} is the rules for \con{RTC}: +All we need to provide \texttt{metis\_tac} is the rules for \con{RTC}: \begin{session} \begin{alltt} >> e (metis_tac [RTC_rules]); From c14b3fcbd9362bbd57d4e5976b98c16c5977e2b2 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 29 Jan 2016 16:31:08 +1100 Subject: [PATCH 671/718] Make EXTRA_CLEANS of generated files in Tutorial --- Manual/Tutorial/Holmakefile | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Manual/Tutorial/Holmakefile b/Manual/Tutorial/Holmakefile index 32d535d511..1620120bdc 100644 --- a/Manual/Tutorial/Holmakefile +++ b/Manual/Tutorial/Holmakefile @@ -1,5 +1,7 @@ INCLUDES = ../Tools +EXTRA_CLEANS = tutorial.pdf euclid.tex parity.tex ml.tex combin.tex + tutorial.pdf: tutorial.tex euclid.tex logic.tex preface.tex proof-tools.tex theories.tex combin.tex parity.tex ml.tex latexmk -pdf tutorial From b6d3c6960529a81abbab0f804118514ef9c00f69 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 29 Jan 2016 16:31:30 +1100 Subject: [PATCH 672/718] polyscripter: truncate long metis: lines --- Manual/Tools/polyscripter.sml | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/Manual/Tools/polyscripter.sml b/Manual/Tools/polyscripter.sml index 77dce3db15..51a080ae93 100644 --- a/Manual/Tools/polyscripter.sml +++ b/Manual/Tools/polyscripter.sml @@ -194,9 +194,39 @@ fun remove_nsubgoals s = else NONE end +fun shorten_longmetis s = + let + open Substring + val ss = full s + val (pfx, sfx) = position "\nmetis: " ss + fun ismetis_guff c = + case c of + #"r" => true | #"+" => true | #"[" => true | #"]" => true + | _ => Char.isDigit c + fun recurse csfx = + if size csfx <> 0 then + let + val (guff, rest) = splitl ismetis_guff (triml 8 csfx) + in + if size guff > 55 then + SOME (string (span (pfx, slice(guff, 0, SOME 50))) ^ " .... " ^ + string rest) + else + let + val (_, sfx') = position "\nmetis: " (triml 1 csfx) + in + recurse sfx' + end + end + else NONE + in + recurse sfx + end + fun removeCruft s = try removeCruft [cruftSuffix (!cruftySuffixes), remove_multi_goalproved, + shorten_longmetis, remove_nsubgoals] s From db57a48b9d49fdd196669a70f683b4730f872e0a Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 1 Feb 2016 11:34:08 +1100 Subject: [PATCH 673/718] More tweaks to the Tutorial --- Manual/Tutorial/combin.stex | 78 ++++++++++--------------------------- Manual/Tutorial/euclid.stex | 24 ++++++------ Manual/Tutorial/parity.stex | 8 ++-- 3 files changed, 37 insertions(+), 73 deletions(-) diff --git a/Manual/Tutorial/combin.stex b/Manual/Tutorial/combin.stex index 522062c8e9..d16f98dd27 100644 --- a/Manual/Tutorial/combin.stex +++ b/Manual/Tutorial/combin.stex @@ -409,17 +409,17 @@ All we need to provide \texttt{metis\_tac} is the rules for \con{RTC}: sub-goal package commands: \begin{session} \begin{alltt} ->>_ val R_RTC_diamond = store_thm( - "R_RTC_diamond", - ``!R. diamond R ==> - !x p. RTC R x p ==> - !z. R x z ==> - ?u. RTC R p u /\ RTC R z u``, - strip_tac >> strip_tac >> Induct_on `RTC` >> rw[] >| [ - metis_tac [RTC_rules], - `?v. R x' v /\ R z v` by metis_tac [diamond_def] >> - metis_tac [RTC_rules] - ]); +##eval val R_RTC_diamond = store_thm( + "R_RTC_diamond", + ``!R. diamond R ==> + !x p. RTC R x p ==> + !z. R x z ==> + ?u. RTC R p u /\ RTC R z u``, + strip_tac >> strip_tac >> Induct_on `RTC` >> rw[] >| [ + metis_tac [RTC_rules], + `?v. R x' v /\ R z v` by metis_tac [diamond_def] >> + metis_tac [RTC_rules] + ]); \end{alltt} \end{session} \eos{} @@ -564,7 +564,7 @@ reduction because of its own parallel lines: application ($\KC\;x\;y$) can reduce, its RHS (\KC) can't. \begin{session} \begin{alltt} ->> val (predn_rules, _, predn_cases) = xHol_reln "predn" +>>_ val (predn_rules, _, predn_cases) = xHol_reln "predn" `(!x. x -||-> x) /\ (!x y u v. x -||-> y /\ u -||-> v ==> @@ -715,7 +715,7 @@ val RTCredn_ap_congruence = store_thm( >>__ val RTCredn_ap_congruence = store_thm( "RTCredn_ap_congruence", ``!x y. x -->* y ==> !z. x # z -->* y # z /\ z # x -->* z # y``, - Induct_on `RTC` THEN PROVE_TAC [RTC_rules, redn_rules]); + Induct_on `RTC` >> metis_tac [RTC_rules, redn_rules]); \end{verbatim} \end{session} Now that we have this, our sub-goal is almost immediately @@ -922,51 +922,23 @@ for all that we might look upon the four disjunctions and despair. \noindent Now we are ready to prove the final goal. It is \begin{session} \begin{alltt} -- g `!x y. x -||-> y ==> - !z. x -||-> z ==> ?u. y -||-> u /\bs z -||-> u`; -> val it = - Proof manager status: 1 proof. - 1. Incomplete: - Initial goal: - \(\forall\)x y. x -||-> y \(\Rightarrow\) \(\forall\)z. x -||-> z \(\Rightarrow\) \(\exists\)u. y -||-> u \(\land\) z -||-> u +>> g `!x y. x -||-> y ==> + !z. x -||-> z ==> ?u. y -||-> u /\ z -||-> u`; \end{alltt} \end{session} We now induct and split the goal into its individual conjuncts: \begin{session} \begin{alltt} -- e (Induct_on `$-||->` THEN REPEAT CONJ_TAC); -OK.. -4 subgoals: -> val it = - \(\forall\)f g x z. S # f # g # x -||-> z \(\Rightarrow\) - \(\exists\)u. f # x # (g # x) -||-> u \(\land\) z -||-> u - - - \(\forall\)x y z. K # x # y -||-> z \(\Rightarrow\) \(\exists\)u. x -||-> u \(\land\) z -||-> u - - - \(\forall\)x y u v. - x -||-> y \(\land\) - (\(\forall\)z. x -||-> z \(\Rightarrow\) \(\exists\)u. y -||-> u \(\land\) z -||-> u) \(\land\) - u -||-> v \(\land\) - (\(\forall\)z. u -||-> z \(\Rightarrow\) \(\exists\)u. v -||-> u \(\land\) z -||-> u) \(\Rightarrow\) - \(\forall\)z. x # u -||-> z \(\Rightarrow\) \(\exists\)u. y # v -||-> u \(\land\) z -||-> u - - - \(\forall\)x z. x -||-> z \(\Rightarrow\) \(\exists\)u. x -||-> u \(\land\) z -||-> u +>> e (Induct_on `$-||->` >> rpt conj_tac); \end{alltt} \end{session} The first goal is easily disposed of. The witness we would provide for this case is simply \texttt{z}, but \texttt{PROVE\_TAC} will do the work for us: \begin{session} -\begin{verbatim} -- e (PROVE_TAC [predn_rules]); -OK.. -Meson search level: ... - -Goal proved. [...] -\end{verbatim} +\begin{alltt} +>> e (metis_tac [predn_rules]); +\end{alltt} \end{session} The next goal includes two instances of terms of the form \verb!x # y -||-> z!. We can use our \verb!x_ap_y_predn! @@ -977,17 +949,7 @@ Goal proved. [...] lead us too far astray. \begin{session} \begin{alltt} -- e (REPEAT STRIP_TAC); -OK.. -1 subgoal: -> val it = - \(\exists\)u. y # v -||-> u \(\land\) z -||-> u - ------------------------------------ - 0. x -||-> y - 1. \(\forall\)z. x -||-> z \(\Rightarrow\) \(\exists\)u. y -||-> u \(\land\) z -||-> u - 2. u -||-> v - 3. \(\forall\)z. u -||-> z \(\Rightarrow\) \(\exists\)u. v -||-> u \(\land\) z -||-> u - 4. x # u -||-> z +>> e (rw[]); \end{alltt} \end{session} We need to split up assumption 4. We can get it out of the assumption diff --git a/Manual/Tutorial/euclid.stex b/Manual/Tutorial/euclid.stex index 790a11c652..92410ce7c1 100644 --- a/Manual/Tutorial/euclid.stex +++ b/Manual/Tutorial/euclid.stex @@ -385,11 +385,11 @@ following\footnote{This and subsequent proofs use the theorems proved \item [\small{({\it DIVIDES\_FACT\/})}] \begin{tabular}[t]{l} \verb+!m n. 0 < m /\ m <= n ==> m divides (FACT n)+ \\ \hline -\verb|`!p m. 0 < m ==> m divides (FACT (m + p))` | -\verb+ suffices_by metis_tac[LESS_EQ_EXISTS] >>+ -\verb+Induct_on `p` >>+ -\verb+rw[FACT,ADD_CLAUSES,DIVIDES_RMUL] >>+ -\verb+Cases_on `m` >>+ +\verb|`!p m. 0 < m ==> m divides (FACT (m + p))` |\\ +\verb+ suffices_by metis_tac[LESS_EQ_EXISTS] >>+\\ +\verb+Induct_on `p` >>+\\ +\verb+rw[FACT,ADD_CLAUSES,DIVIDES_RMUL] >>+\\ +\verb+Cases_on `m` >>+\\ \verb+fs[FACT,DIVIDES_LMUL,DIVIDES_REFL]+\\ \end{tabular} \end{description} @@ -587,8 +587,8 @@ One obvious step would be to merge the two successive invocations of the simplif \end{alltt} \end{hol} -Then, both arms of the induction start with an invocation of \ml{rw}, and the semantics of \ml{\gt\gt} allow us to merge the occurrences of \ml{rw} above the \ml{\gt|}. -This makes the step case entirely empty, so that when we execute the first steps of the proof we are left with only the base case to prove: +Now we'll make the occasionally dangerous assumption that the simplifications of the step case won't interfere with what is happening in the base case, and move the step case's tactic to precede the first \ml{\gt|}, using \ml{\gt\gt}. +When the \ml{Induct} tactic generates two sub-goals, the step case's simplification will be applied to both of them: \begin{session} \begin{alltt} >>_ restart(); @@ -597,6 +597,7 @@ This makes the step case entirely empty, so that when we execute the first steps Induct_on `p` >> rw[FACT, ADD_CLAUSES, DIVIDES_RMUL]); \end{alltt} \end{session} +The step case has been dealt with, and as we hoped the base case has not been changed at all. This means that our tactic can become \begin{hol} \begin{alltt} @@ -653,8 +654,8 @@ it leads to somewhat less natural goals. >> e (Induct_on `n - m`); \end{alltt} \end{session} -This is slighly hard to read, so we combine with a call to the simplifier to strip both arms of the proof. -Use of \ml{\gt\gt} ensures that the tactic gets applied in both branches of the induction. +This is slighly hard to read, so we sequence a call to the simplifier to strip both arms of the proof. +As before, use of \ml{\gt\gt} ensures that the tactic gets applied in both branches of the induction. (We might also use \ml{rpt~strip\_tac} if we \emph{didn't} want the simplification to happen.) \begin{session} \begin{alltt} @@ -662,7 +663,8 @@ Use of \ml{\gt\gt} ensures that the tactic gets applied in both branches of the >> e (Induct_on `n - m` >> rw[]); \end{alltt} \end{session} -Looking at the first goal, we reason that if $0 = n - m$ and $m \leq n$, then $m = n$. We can prove this fact, using \ml{rw} and add it to the hypotheses by use of the infix operator ``\ml{by}'': +Looking at the first goal, we can see (by the anti-symmetry of ${\le}$) that $m = n$. +We can prove this fact, using \ml{rw} and add it to the hypotheses by use of the infix operator ``\ml{by}'': \begin{session} \begin{alltt} >> e (`m = n` by rw[]); @@ -939,7 +941,7 @@ situ}. We choose the latter approach. >> e (mp_tac (SPEC ``FACT n + 1`` PRIME_FACTOR)); \end{alltt} \end{session} -The invocation \ml{mp\_tac} ($\vdash M$) applied to a goal $(\Delta, g)$ returns the goal $(\Delta, M \supset g)$. +The invocation \ml{mp\_tac} ($\vdash M$) applied to a goal $(\Delta, g)$ returns the goal $(\Delta, M \Rightarrow g)$. Now we simplify: \begin{session} \begin{alltt} diff --git a/Manual/Tutorial/parity.stex b/Manual/Tutorial/parity.stex index 024c34e048..866c126b3b 100644 --- a/Manual/Tutorial/parity.stex +++ b/Manual/Tutorial/parity.stex @@ -462,11 +462,11 @@ function to the \ml{t} parameter. In fact, the value that matched \ml{X} was {\small\verb|``\x. if l5 x then l3 x else l4 x``|}. Inspecting the goal above, it can be seen that the next step is to unwind the equations for the remaining lines of the circuit. -We do using the standard simplifier \ml{lrw}. +We do using the standard simplifier \ml{rw}. \begin{session} \begin{alltt} ->> e (lrw[]); +>> e (rw[]); \end{alltt} \end{session} @@ -493,7 +493,7 @@ interactively: metis_tac [], qpat_assum `!t. out t = X t` (fn th => REWRITE_TAC [SPEC ``SUC t`` th]) >> - lrw[] + rw[] ]); \end{alltt} \end{session} @@ -507,7 +507,7 @@ This will be done in one step using the \ML{} function \ml{prove}. >> val PARITY_CORRECT = prove( ``!inp out. PARITY_IMP(inp,out) ==> (!t. out t = PARITY t inp)``, rpt strip_tac >> irule UNIQUENESS_LEMMA >> - irule PARITY_LEMMA >> lrw[]); + irule PARITY_LEMMA >> rw[]); \end{alltt} \end{session} From 417ff9a1142831764194c5e0c7983bc07e89a98c Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 1 Feb 2016 14:35:47 +1100 Subject: [PATCH 674/718] Finish tidying up combinator chapter in Tutorial --- Manual/Tutorial/combin.stex | 344 +++++++++++++--------------------- examples/ind_def/clScript.sml | 113 +++++------ 2 files changed, 187 insertions(+), 270 deletions(-) diff --git a/Manual/Tutorial/combin.stex b/Manual/Tutorial/combin.stex index d16f98dd27..8bc61079fa 100644 --- a/Manual/Tutorial/combin.stex +++ b/Manual/Tutorial/combin.stex @@ -22,24 +22,21 @@ the \texttt{examples/ind\_def} directory of the distribution. It is self-contained and so includes the answers to the exercises set at the end of this document. -The HOL sessions assume that the Unicode trace is \emph{on} (as it is -by default), meaning that even though the inputs may be written in -pure ASCII, the output still uses nice Unicode output (symbols such as -$\forall$ and $\Rightarrow$). The Unicode symbols could also be used -in the input. +The \HOL{} sessions assume that the Unicode trace is \emph{on} (as it is by default), meaning that even though the inputs may be written in pure ASCII, the output still uses nice Unicode output (symbols such as $\forall$ and $\Rightarrow$). +The Unicode symbols could also be used in the input. \section{The type of combinators} \label{sec:Type-Combinators} -The first thing we need to do is define the type of -\emph{combinators}. There are just two of these, \KC{} and \SC, but -we also need to be able to \emph{combine} them, and for this we need -to introduce the notion of application. For lack of a better ASCII -symbol, we will use the hash (\#) to represent this in the logic: +The first thing we need to do is define the type of \emph{combinators}. +There are just two of these, \KC{} and \SC, but we also need to be able to \emph{combine} them, and for this we need to introduce the notion of application. +For lack of a better ASCII symbol, we will use the hash (\#) to represent this in the logic. +Finally, we will start by ``hiding'' the names \holtxt{S} and \holtxt{K} so that the constants of these names from the existing \HOL{} theories won't interfere with parsing. \setcounter{sessioncount}{0} \begin{session} \begin{alltt} +>> hide "K"; hide "S"; >> Datatype `cl = K | S | # cl cl`; \end{alltt} \end{session} @@ -79,33 +76,24 @@ congruence rules:\[ \infer{x\;y\;\;\rightarrow\;\;x\;y'}{y\;\;\rightarrow\;\;y'} \end{array}\] In HOL, we can capture this relation with an inductive definition. -First we need to set our arrow symbol up as an infix to make everything that -bit prettier +First we need to set our arrow symbol up as an infix to make everything that bit prettier. +The \ml{set\_mapped\_fixity} function lets the arrow be our surface syntax, but maps to the name \holtxt{redn} underneath. +Making constants have pure alphanumeric names is generally a good idea. \begin{session} \begin{alltt} ->> set_fixity "-->" (Infix(NONASSOC, 450)); +>> set_mapped_fixity {fixity = Infix(NONASSOC, 450), + tok = "-->", term_name = "redn"} \end{alltt} \end{session} We make our arrow symbol non-associative, thereby making it a -parse error to write \verb!x --> y --> z!. It would be nice to be able -to write this and have it mean \verb!x --> y /\ y --> z!, but this is -not presently possible with the HOL parser. - -Our next step is to actually define the relation with the -\ml{xHol\_reln} function. In addition to a quotation specifying the -rules for the new relation, it requires a name to use as the stem for -the theorems it proves. We pick the string \ml{"redn"}.\footnote{The - related function \ml{Hol\_reln} can be used if the system's choice - of stem is acceptable. In this case, \ml{Hol\_reln} can't cope with the - non-alphanumeric characters in \holtxt{-->} and will raise an - error.} -The \ml{xHol\_reln} function for -doing this returns three separate theorems, and we bind the first (the -``rules'' theorem) and -third (the ``cases'' theorem): -\begin{session} -\begin{alltt} ->> val (redn_rules, _, redn_cases) = xHol_reln "redn" +parse error to write \verb!x --> y --> z!. +It would be nice to be able to write this and have it mean \verb!x --> y /\ y --> z!, but this is not presently possible with the HOL parser. + +Our next step is to actually define the relation with the \ml{Hol\_reln} function. +This function returns three separate theorems, but we will only need to refer to the first: +\begin{session} +\begin{alltt} +>> val (redn_rules, _, redn_cases) = Hol_reln `(!x y f. x --> y ==> f # x --> f # y) /\ (!f g x. f --> g ==> f # x --> g # x) /\ (!x y. K # x # y --> x) /\ @@ -546,12 +534,12 @@ property, and therefore, our original relation will be confluent. \subsection{Parallel reduction} \label{sec:Parallel-Reduction} -Our new relation allows for any number of reductions to occur in -parallel. We use the \texttt{-||->} symbol to indicate parallel -reduction because of its own parallel lines: +Our new relation allows for any number of reductions to occur in parallel. +We use the \texttt{-||->} symbol to indicate parallel reduction because of its own parallel lines, and use \holtxt{predn} to name the constant: \begin{session} \begin{alltt} ->> set_fixity "-||->" (Infix(NONASSOC, 450)); +>> set_mapped_fixity {tok = "-||->", fixity = Infix(NONASSOC, 450), + term_name = "predn"}; \end{alltt} \end{session} Then we can define parallel reduction itself. The rules look very @@ -564,7 +552,7 @@ reduction because of its own parallel lines: application ($\KC\;x\;y$) can reduce, its RHS (\KC) can't. \begin{session} \begin{alltt} ->>_ val (predn_rules, _, predn_cases) = xHol_reln "predn" +>>_ val (predn_rules, _, predn_cases) = Hol_reln `(!x. x -||-> x) /\ (!x y u v. x -||-> y /\ u -||-> v ==> @@ -590,7 +578,7 @@ desired form. \begin{alltt} >> set_fixity "-->*" (Infix(NONASSOC, 450)); ->> overload_on ("-->*", ``RTC $-->``); +>> overload_on ("-->*", ``RTC redn``); \end{alltt} \end{session} We do exactly the same thing for the reflexive and transitive closure @@ -599,7 +587,7 @@ of our parallel reduction. \begin{verbatim} >> set_fixity "-||->*" (Infix(NONASSOC, 450)); ->> overload_on ("-||->*", ``RTC $-||->``); +>> overload_on ("-||->*", ``RTC predn``); \end{verbatim} \end{session} Incidentally, in conjunction with \texttt{PROVE} we can now @@ -646,7 +634,7 @@ We back-chain using our monotonicity result: Now we can induct over the rules for $\rightarrow$: \begin{session} \begin{alltt} ->> e (Induct_on `$-->`); +>> e (Induct_on `x --> y`); \end{alltt} \end{session} We could split the 4-way conjunction apart into four goals, but there @@ -664,7 +652,7 @@ Packaged into a tidy little sub-goal-package-free parcel, our proof is "RTCredn_RTCpredn", ``!x y. x -->* y ==> x -||->* y``, match_mp_tac RTC_monotone >> - Induct_on `$-->` >> metis_tac [predn_rules]); + Induct_on `x --> y` >> metis_tac [predn_rules]); \end{alltt} \end{session} \eos{} @@ -685,7 +673,7 @@ This time our induction will be over the rules defining the parallel reduction relation. \begin{session} \begin{alltt} ->> e (Induct_on `$-||->`); +>> e (Induct_on `x -||-> y`); \end{alltt} \end{session} @@ -740,10 +728,10 @@ indeed: \begin{session} \begin{alltt} ##eval val predn_RTCredn = store_thm( - "predn_RTCredn", - ``!x y. x -||-> y ==> x -->* y``, - Induct_on `$-||->` >> - metis_tac [RTC_rules, redn_rules, RTC_RTC, RTCredn_ap_congruence]); + "predn_RTCredn", + ``!x y. x -||-> y ==> x -->* y``, + Induct_on `x -||-> y` >> + metis_tac [RTC_rules, redn_rules, RTC_RTC, RTCredn_ap_congruence]); \end{alltt} \end{session} \eos{} @@ -929,11 +917,11 @@ for all that we might look upon the four disjunctions and despair. We now induct and split the goal into its individual conjuncts: \begin{session} \begin{alltt} ->> e (Induct_on `$-||->` >> rpt conj_tac); +>> e (Induct_on `x -||-> y` >> rpt conj_tac); \end{alltt} \end{session} The first goal is easily disposed of. The witness we would provide -for this case is simply \texttt{z}, but \texttt{PROVE\_TAC} will do +for this case is simply \texttt{z}, but \texttt{metis\_tac} will do the work for us: \begin{session} \begin{alltt} @@ -953,218 +941,146 @@ the work for us: \end{alltt} \end{session} We need to split up assumption 4. We can get it out of the assumption -list using the \texttt{Q.PAT\_ASSUM} theorem-tactical. We will write -\begin{verbatim} - Q.PAT_ASSUM `x # y -||-> z` - (STRIP_ASSUME_TAC o SIMP_RULE std_ss [x_ap_y_predn]) -\end{verbatim} +list using the \ml{qpat\_assum} theorem-tactical. +We will write +\begin{alltt} +##eval qpat_assum `x # y -||-> z` + (strip_assume_tac o SIMP_RULE std_ss [x_ap_y_predn]) +\end{alltt} The quotation specifies the pattern that we want to match. The second argument specifies how we are going to transform the theorem. Reading the compositions from right to left, first we will simplify with the \verb!x_ap_y_predn! theorem and then we will assume the result back into the assumptions, stripping disjunctions and existentials as we -go.\footnote{An alternative to using \texttt{PAT\_ASSUM} is to use +go.\footnote{An alternative to using \ml{qpat\_assum} is to use \texttt{by} instead: you would have to state the four-way disjunction yourself, but the proof would be more ``declarative'' in style, and though wordier, might be more maintainable.} -We already know that doing this is going to produce four new sub-goals -(there were four disjuncts in the \verb!x_ap_y_predn! theorem). At -least one of these should be trivial because it will correspond to the -case when the parallel reduction is just a ``do nothing'' step. Let's -try eliminating the simple cases with a ``speculative'' call to -\texttt{PROVE\_TAC} wrapped inside a \texttt{TRY}. And before doing -that, we should do some rewriting to make sure that equalities in the -assumptions are eliminated. +We already know that doing this is going to produce four new sub-goals (there were four disjuncts in the \verb!x_ap_y_predn! theorem). +We'll follow up the use of \ml{strip\_assume\_tac} with \ml{rw} to eliminate any equalities that might appear as assumptions. So: \begin{session} \begin{alltt} -- e (Q.PAT_ASSUM `x # y -||-> z` - (STRIP_ASSUME_TAC o SIMP_RULE std_ss [x_ap_y_predn]) THEN - RW_TAC std_ss [] THEN - TRY (PROVE_TAC [predn_rules])); -OK.. -Meson search level: ............................... -Meson search level: ............................... -Meson search level: .................. -Meson search level: ..... -2 subgoals: -> val it = - \(\exists\)u'. y # v -||-> u' \(\land\) f # u # (g # u) -||-> u' - ------------------------------------ - 0. S # f # g -||-> y - 1. \(\forall\)z. S # f # g -||-> z \(\Rightarrow\) \(\exists\)u. y -||-> u \(\land\) z -||-> u - 2. u -||-> v - 3. \(\forall\)z. u -||-> z \(\Rightarrow\) \(\exists\)u. v -||-> u \(\land\) z -||-> u - - \(\exists\)u. y # v -||-> u \(\land\) z -||-> u - ------------------------------------ - 0. K # z -||-> y - 1. \(\forall\)z'. K # z -||-> z' \(\Rightarrow\) \(\exists\)u. y -||-> u \(\land\) z' -||-> u - 2. u -||-> v - 3. \(\forall\)z. u -||-> z \(\Rightarrow\) \(\exists\)u. v -||-> u \(\land\) z -||-> u -\end{alltt} -\end{session} -Brilliant! We've eliminated two of the four disjuncts already. Now -our next goal features a term \verb!K # z -||-> y! in the assumptions. -We have a theorem that pertains to just this situation. But before -applying it willy-nilly, let us try to figure out exactly what the -situation is. A diagram of the current situation might look like +>>__ set_trace "Goalstack.howmany_printed_subgoals" 1; +>> e (qpat_assum `x # y -||-> z` + (strip_assume_tac o SIMP_RULE (srw_ss()) [x_ap_y_predn]) >> + rw[]); +\end{alltt} +\end{session} +This first sub-goal is an easy consequence of the rules for parallel reduction. +Because we've elided the somewhat voluminous output, we call \ml{p()} to print the next sub-goal again: +\begin{session} +\begin{alltt} +>>_ e (metis_tac[predn_rules]); +>> p(); +\end{alltt} +\end{session} +This goal requires application of the two inductive hypotheses as well as the rules for parallel reduction, but is again straightforward for \ml{metis\_tac}; +\begin{session} +\begin{alltt} +>>_ e (metis_tac[predn_rules]); +>> p(); +\end{alltt} +\end{session} +Now our next goal (the third of the four) features a term \verb!K # z -||-> y! in the assumptions. +We have a theorem that pertains to just this situation. +But before applying it willy-nilly, let us try to figure out exactly what the situation is. +A diagram of the current situation might look like \[\xymatrix @C=2cm { -*+<4pt>[F--]\txt{\fbox{\texttt{K\kern2mm \#\kern2mm z}} \texttt{\#} \fbox{\texttt{u}}} \ar[r] & \txt{\texttt{z}} \ar@{.>}[d] \\ -*+<4pt>[F--]\txt{\fbox{\texttt{y}} \texttt{\#} \fbox{\texttt{v}}} \ar@{.>}[r] & \txt{\texttt{?u?}} +*+<4pt>[F--]\txt{\fbox{\texttt{K\kern2mm \#\kern2mm z}} \texttt{\#} \fbox{\texttt{x'}}} \ar[r] & \txt{\texttt{z}} \ar@{.>}[d] \\ +*+<4pt>[F--]\txt{\fbox{\texttt{y}} \texttt{\#} \fbox{\texttt{y'}}} \ar@{.>}[r] & \txt{\texttt{?u?}} \ar "1,1"!<-12pt,0pt>;"2,1"!<-12pt,0pt> \ar "1,1"!<28pt,0pt>;"2,1"!<11pt,0pt> } \] -Our theorem tells us that \texttt{y} must actually be of the form -\verb!K # w! for some \texttt{w}, and that there must be an arrow -between \texttt{z} and \texttt{w}. Thus: -\begin{session} -\begin{alltt} -- e (`?w. (y = K # w) /\bs (z -||-> w)` by PROVE_TAC [Kx_predn]); -OK.. -Meson search level: ...... -1 subgoal: -> val it = - \(\exists\)u. y # v -||-> u \(\land\) z -||-> u - ------------------------------------ - 0. K # z -||-> y - 1. \(\forall\)z'. K # z -||-> z' \(\Rightarrow\) \(\exists\)u. y -||-> u \(\land\) z' -||-> u - 2. u -||-> v - 3. \(\forall\)z. u -||-> z \(\Rightarrow\) \(\exists\)u. v -||-> u \(\land\) z -||-> u - 4. y = K # w - 5. z -||-> w -\end{alltt} -\end{session} - On inspection, it becomes clear that the \texttt{u} must be - \texttt{w}. The first conjunct requires \verb!K # w # v -||-> w!, - which we have because this is what \KC{}s do, and the second - conjunct is already in the assumption list. Rewriting - (eliminating that equality in the assumption list first will make - \texttt{PROVE\_TAC}'s job that much easier), and then first order - reasoning will solve this goal: -\begin{session} -\begin{alltt} -- e (RW_TAC std_ss [] THEN PROVE_TAC [predn_rules]); -OK.. -Meson search level: ... - -Goal proved. [...] -Remaining subgoals: -> val it = - \(\exists\)u'. y # v -||-> u' \(\land\) f # u # (g # u) -||-> u' - ------------------------------------ - 0. S # f # g -||-> y - 1. \(\forall\)z. S # f # g -||-> z \(\Rightarrow\) \(\exists\)u. y -||-> u \(\land\) z -||-> u - 2. u -||-> v - 3. \(\forall\)z. u -||-> z \(\Rightarrow\) \(\exists\)u. v -||-> u \(\land\) z -||-> u +Our theorem tells us that \texttt{y} must actually be of the form \verb!K # w! for some \texttt{w}, and that there must be an arrow between \texttt{z} and \texttt{w}. +Thus: +\begin{session} +\begin{alltt} +>> e (`?w. (y = K # w) /\ (z -||-> w)` by metis_tac [Kx_predn]); +\end{alltt} +\end{session} +On inspection, it becomes clear that the \texttt{u} must be \texttt{w}. +The first conjunct requires \verb!K # w # y' -||-> w!, which we have because this is what \KC{}s do, and the second conjunct is already in the assumption list. +Rewriting (eliminating that equality in the assumption list first will make \ml{metis\_tac}'s job that much easier), and then first order reasoning will solve this goal: +\begin{session} +\begin{alltt} +>> e (rw [] >> metis_tac [predn_rules]); \end{alltt} \end{session} This case involving \SC{} is analogous. Here's the tactic to apply: \begin{session} \begin{alltt} -- e (`?p q. (y = S # p # q) /\bs (f -||-> p) /\bs (g -||-> q)` - by PROVE_TAC [Sxy_predn] THEN - RW_TAC std_ss [] THEN PROVE_TAC [predn_rules]); -OK.. -Meson search level: ........ -Meson search level: ........... - -Goal proved.[...] -Remaining subgoals: -> val it = - \(\forall\)f g x z. S # f # g # x -||-> z \(\Rightarrow\) - \(\exists\)u. f # x # (g # x) -||-> u \(\land\) z -||-> u - - - \(\forall\)x y z. K # x # y -||-> z \(\Rightarrow\) \(\exists\)u. x -||-> u \(\land\) z -||-> u +>> e (`?p q. (y = S # p # q) /\ (f -||-> p) /\ (g -||-> q)` + by metis_tac [Sxy_predn] >> + rw [] >> metis_tac [predn_rules]); \end{alltt} \end{session} -This next goal features a \verb!K # x # y -||-> z! term that we have a -theorem for already. And again, let's speculatively use a call to -\texttt{PROVE\_TAC} to eliminate the simple cases immediately -(\verb!Kxy_predn! is a disjunct so we'll get two sub-goals if we don't -eliminate anything). +This next goal features a \verb!K # x # y -||-> z! term that we have a theorem for already. +Let's speculatively use a call to \texttt{metis\_tac} to eliminate the simple cases immediately (\verb!Kxy_predn! is a disjunct so we'll get two sub-goals if we don't eliminate anything). \begin{session} \begin{alltt} -- e (RW_TAC std_ss [Kxy_predn] THEN - TRY (PROVE_TAC [predn_rules])); -OK.. -Meson search level: .. -Meson search level: ... - -Goal proved. [...] -Remaining subgoals: -> val it = - \(\forall\)f g x z. S # f # g # x -||-> z \(\Rightarrow\) - \(\exists\)u. f # x # (g # x) -||-> u \(\land\) z -||-> u +>> e (rw[Kxy_predn] >> metis_tac[predn_rules]); \end{alltt} \end{session} -Better yet! We got both cases immediately, and have moved onto the -last case. We can try the same strategy. +We got both cases immediately, and have moved onto the last case. +We can try the same strategy. \begin{session} \begin{alltt} -- e (RW_TAC std_ss [Sxyz_predn] THEN PROVE_TAC [predn_rules]); -OK.. -Meson search level: .. -Meson search level: ........... - -Goal proved.[...] -> val it = - Initial goal proved. - |- \(\forall\)x y. x -||-> y \(\Rightarrow\) \(\forall\)z. x -||-> z \(\Rightarrow\) - \(\exists\)u. y -||-> u \(\land\) z -||-> u : goalstack +>> e (rw[Sxyz_predn] >> metis_tac [predn_rules]); +##assert can top_thm() \end{alltt} \end{session} The final goal proof can be packaged into: \begin{session} -\begin{verbatim} -val predn_diamond_lemma = prove( - ``!x y. x -||-> y ==> - !z. x -||-> z ==> ?u. y -||-> u /\ z -||-> u``, - Induct_on `$-||->` THEN REPEAT CONJ_TAC THENL [ - PROVE_TAC [predn_rules], - REPEAT STRIP_TAC THEN - Q.PAT_ASSUM `x # y -||-> z` - (STRIP_ASSUME_TAC o SIMP_RULE std_ss [x_ap_y_predn]) THEN - RW_TAC std_ss [] THEN - TRY (PROVE_TAC [predn_rules]) THENL [ - `?w. (y = K # w) /\ (z -||-> w)` by PROVE_TAC [Kx_predn] THEN - RW_TAC std_ss [] THEN PROVE_TAC [predn_rules], - `?p q. (y = S # p # q) /\ (f -||-> p) /\ (g -||-> q)` by - PROVE_TAC [Sxy_predn] THEN - RW_TAC std_ss [] THEN PROVE_TAC [predn_rules] - ], - RW_TAC std_ss [Kxy_predn] THEN PROVE_TAC [predn_rules], - RW_TAC std_ss [Sxyz_predn] THEN PROVE_TAC [predn_rules] - ]); -\end{verbatim} +\begin{alltt} +##eval val predn_diamond_lemma = prove( + ``!x y. x -||-> y ==> + !z. x -||-> z ==> ?u. y -||-> u /\ z -||-> u``, + Induct_on `x -||-> y` >> rpt conj_tac >| [ + metis_tac [predn_rules], + rw[] >> + qpat_assum `x # y -||-> z` + (strip_assume_tac o SIMP_RULE std_ss [x_ap_y_predn]) >> + rw[] >| [ + metis_tac[predn_rules], + metis_tac[predn_rules], + `?w. (y = K # w) /\ (z -||-> w)` by metis_tac [Kx_predn] >> + rw[] >> metis_tac [predn_rules], + `?p q. (y = S # p # q) /\ (f -||-> p) /\ (g -||-> q)` by + metis_tac [Sxy_predn] >> + rw [] >> metis_tac [predn_rules] + ], + rw[Kxy_predn] >> metis_tac [predn_rules], + rw[Sxyz_predn] >> metis_tac [predn_rules] + ]); +\end{alltt} \end{session} \eos{} We are on the home straight. The lemma can be turned into a statement involving the \con{diamond} constant directly: \begin{session} -\begin{verbatim} -val predn_diamond = store_thm( - "predn_diamond", - ``diamond $-||->``, - PROVE_TAC [diamond_def, predn_diamond_lemma]); -\end{verbatim} +\begin{alltt} +##eval val predn_diamond = store_thm( + "predn_diamond", + ``diamond predn``, + metis_tac [diamond_def, predn_diamond_lemma]); +\end{alltt} \end{session} And now we can prove that our original relation is confluent in similar fashion: \begin{session} -\begin{verbatim} -val confluent_redn = store_thm( - "confluent_redn", - ``confluent $-->``, - PROVE_TAC [predn_diamond, confluent_diamond_RTC, - RTCpredn_EQ_RTCredn, diamond_RTC]); -\end{verbatim} +\begin{alltt} +##eval val confluent_redn = store_thm( + "confluent_redn", + ``confluent redn``, + metis_tac [predn_diamond, confluent_diamond_RTC, + RTCpredn_EQ_RTCredn, diamond_RTC]); +\end{alltt} \end{session} diff --git a/examples/ind_def/clScript.sml b/examples/ind_def/clScript.sml index bd0a6dae1e..a0c7b19629 100644 --- a/examples/ind_def/clScript.sml +++ b/examples/ind_def/clScript.sml @@ -4,13 +4,15 @@ open bossLib simpLib val _ = new_theory "cl"; +val _ = (hide "S"; hide "K") val _ = Datatype `cl = S | K | # cl cl`; val _ = set_fixity "#" (Infixl 1100); -val _ = set_fixity "-->" (Infix(NONASSOC, 450)) +val _ = set_mapped_fixity {tok = "-->", fixity = Infix(NONASSOC, 450), + term_name = "redn"} -val (redn_rules, _, redn_cases) = xHol_reln "redn" ` +val (redn_rules, _, _) = Hol_reln ` (!x y f. x --> y ==> f # x --> f # y) /\ (!f g x. f --> g ==> f # x --> g # x) /\ (!x y. K # x # y --> x) /\ @@ -36,9 +38,9 @@ val confluent_normforms_unique = store_thm( !x y z. RTC R x y /\ normform R y /\ RTC R x z /\ normform R z ==> (y = z)``, - RW_TAC std_ss [confluent_def] THEN - `?u. RTC R y u /\ RTC R z u` by PROVE_TAC [] THEN - PROVE_TAC [normform_def, RTC_cases]); + rw[confluent_def] >> + `?u. RTC R y u /\ RTC R z u` by metis_tac [] >> + metis_tac [normform_def, RTC_cases]); val diamond_def = Define `diamond R = !x y z. R x y /\ R x z ==> ?u. R y u /\ R z u`; @@ -46,7 +48,7 @@ val diamond_def = Define val confluent_diamond_RTC = store_thm( "confluent_diamond_RTC", ``!R. confluent R = diamond (RTC R)``, - RW_TAC std_ss [confluent_def, diamond_def]); + rw[confluent_def, diamond_def]); val R_RTC_diamond = store_thm( "R_RTC_diamond", @@ -54,31 +56,34 @@ val R_RTC_diamond = store_thm( !x p. RTC R x p ==> !z. R x z ==> ?u. RTC R p u /\ RTC R z u``, - GEN_TAC THEN STRIP_TAC THEN Induct_on `RTC` THEN - PROVE_TAC [diamond_def,RTC_rules]); + GEN_TAC >> STRIP_TAC >> Induct_on `RTC` >> + metis_tac [diamond_def,RTC_rules]); val RTC_RTC = store_thm( "RTC_RTC", ``!R x y z. RTC R x y /\ RTC R y z ==> RTC R x z``, - SIMP_TAC std_ss [GSYM AND_IMP_INTRO, RIGHT_FORALL_IMP_THM] THEN - GEN_TAC THEN Induct_on `RTC` THEN PROVE_TAC [RTC_rules]); + SIMP_TAC std_ss [GSYM AND_IMP_INTRO, RIGHT_FORALL_IMP_THM] >> + GEN_TAC >> Induct_on `RTC` >> metis_tac [RTC_rules]); val diamond_RTC_lemma = prove( ``!R. diamond R ==> !x y. RTC R x y ==> !z. RTC R x z ==> ?u. RTC R y u /\ RTC R z u``, - GEN_TAC THEN STRIP_TAC THEN Induct_on `RTC` THEN - PROVE_TAC [RTC_RTC, RTC_rules, R_RTC_diamond] - ); + GEN_TAC >> STRIP_TAC >> Induct_on `RTC` >> rw[] >| [ + metis_tac[RTC_rules], + `?v. RTC R x' v /\ RTC R z v` by metis_tac[R_RTC_diamond] >> + metis_tac [RTC_RTC, RTC_rules] + ]); val diamond_RTC = store_thm( "diamond_RTC", ``!R. diamond R ==> diamond (RTC R)``, - PROVE_TAC [diamond_def,diamond_RTC_lemma]); + metis_tac [diamond_def,diamond_RTC_lemma]); -val _ = set_fixity "-||->" (Infix(NONASSOC, 450)) -val (predn_rules, predn_ind, predn_cases) = xHol_reln "predn" ` +val _ = set_mapped_fixity {tok = "-||->", fixity = Infix(NONASSOC, 450), + term_name = "predn"} +val (predn_rules, predn_ind, predn_cases) = Hol_reln ` (!x. x -||-> x) /\ (!x y u v. x -||-> y /\ u -||-> v ==> x # u -||-> y # v) /\ (!x y. K # x # y -||-> x) /\ @@ -89,42 +94,42 @@ val RTC_monotone = store_thm( "RTC_monotone", ``!R1 R2. (!x y. R1 x y ==> R2 x y) ==> (!x y. RTC R1 x y ==> RTC R2 x y)``, - REPEAT GEN_TAC THEN STRIP_TAC THEN Induct_on `RTC` THEN - REPEAT STRIP_TAC THEN PROVE_TAC [RTC_rules]); + rpt GEN_TAC >> STRIP_TAC >> Induct_on `RTC` >> + rpt STRIP_TAC >> metis_tac [RTC_rules]); val _ = set_fixity "-->*" (Infix(NONASSOC, 450)); -val _ = overload_on ("-->*", ``RTC $-->``) +val _ = overload_on ("-->*", ``RTC redn``) val _ = set_fixity "-||->*" (Infix(NONASSOC, 450)); -val _ = overload_on ("-||->*", ``RTC $-||->``) +val _ = overload_on ("-||->*", ``RTC predn``) val RTCredn_RTCpredn = store_thm( "RTCredn_RTCpredn", ``!x y. x -->* y ==> x -||->* y``, - HO_MATCH_MP_TAC RTC_monotone THEN Induct_on `$-->` THEN - PROVE_TAC [predn_rules]); + HO_MATCH_MP_TAC RTC_monotone >> Induct_on `x --> y` >> + metis_tac [predn_rules]); val RTCredn_ap_congruence = store_thm( "RTCredn_ap_congruence", ``!x y. x -->* y ==> !z. x # z -->* y # z /\ z # x -->* z # y``, - Induct_on `RTC` THEN PROVE_TAC [RTC_rules, redn_rules]); + Induct_on `RTC` >> metis_tac [RTC_rules, redn_rules]); val predn_RTCredn = store_thm( "predn_RTCredn", ``!x y. x -||-> y ==> x -->* y``, - Induct_on `$-||->` THEN - PROVE_TAC [RTC_rules,redn_rules,RTC_RTC,RTCredn_ap_congruence]); + Induct_on `x -||-> y` >> + metis_tac [RTC_rules,redn_rules,RTC_RTC,RTCredn_ap_congruence]); val RTCpredn_RTCredn = store_thm( "RTCpredn_RTCredn", ``!x y. x -||->* y ==> x -->* y``, - Induct_on `RTC` THEN PROVE_TAC [predn_RTCredn, RTC_RTC, RTC_rules]); + Induct_on `RTC` >> metis_tac [predn_RTCredn, RTC_RTC, RTC_rules]); val RTCpredn_EQ_RTCredn = store_thm( "RTCpredn_EQ_RTCredn", ``$-||->* = $-->*``, - SIMP_TAC std_ss [FUN_EQ_THM] THEN - PROVE_TAC [RTCpredn_RTCredn, RTCredn_RTCpredn]); + SIMP_TAC std_ss [FUN_EQ_THM] >> + metis_tac [RTCpredn_RTCredn, RTCredn_RTCpredn]); fun characterise t = SIMP_RULE (srw_ss()) [] (SPEC t predn_cases); @@ -134,68 +139,64 @@ val Sx_predn0 = characterise ``S # x``; val Sx_predn = prove( ``!x y. S # x -||-> y = ?z. (y = S # z) /\ (x -||-> z)``, - REPEAT GEN_TAC THEN EQ_TAC THEN - RW_TAC std_ss [Sx_predn0, predn_rules, S_predn]); + rw[Sx_predn0, predn_rules, S_predn, EQ_IMP_THM]); val Kx_predn = prove( ``!x y. K # x -||-> y = ?z. (y = K # z) /\ (x -||-> z)``, - REPEAT GEN_TAC THEN EQ_TAC THEN - RW_TAC std_ss [characterise ``K # x``, predn_rules, K_predn]); + rw[characterise ``K # x``, predn_rules, K_predn, EQ_IMP_THM]); val Kxy_predn = prove( ``!x y z. K # x # y -||-> z = (?u v. (z = K # u # v) /\ (x -||-> u) /\ (y -||-> v)) \/ (z = x)``, - REPEAT GEN_TAC THEN EQ_TAC THEN - RW_TAC std_ss [characterise ``K # x # y``, predn_rules, Kx_predn]); + rw[characterise ``K # x # y``, predn_rules, Kx_predn, EQ_IMP_THM]); val Sxy_predn = prove( ``!x y z. S # x # y -||-> z = ?u v. (z = S # u # v) /\ (x -||-> u) /\ (y -||-> v)``, - REPEAT GEN_TAC THEN EQ_TAC THEN - RW_TAC std_ss [characterise ``S # x # y``, predn_rules, - S_predn, Sx_predn]); + rw[characterise ``S # x # y``, predn_rules, EQ_IMP_THM, + S_predn, Sx_predn]); val Sxyz_predn = prove( ``!w x y z. S # w # x # y -||-> z = (?p q r. (z = S # p # q # r) /\ w -||-> p /\ x -||-> q /\ y -||-> r) \/ (z = (w # y) # (x # y))``, - REPEAT GEN_TAC THEN EQ_TAC THEN - RW_TAC std_ss [characterise ``S # w # x # y``, predn_rules, Sxy_predn]); + rw[characterise ``S # w # x # y``, predn_rules, Sxy_predn, EQ_IMP_THM]); val x_ap_y_predn = characterise ``x # y``; val predn_diamond_lemma = prove( ``!x y. x -||-> y ==> !z. x -||-> z ==> ?u. y -||-> u /\ z -||-> u``, - Induct_on `$-||->` THEN REPEAT CONJ_TAC THENL [ - PROVE_TAC [predn_rules], - REPEAT STRIP_TAC THEN - Q.PAT_ASSUM `x # y -||-> z` - (STRIP_ASSUME_TAC o SIMP_RULE std_ss [x_ap_y_predn]) THEN - RW_TAC std_ss [] THEN - TRY (PROVE_TAC [predn_rules]) THENL [ - `?w. (y = K # w) /\ (z -||-> w)` by PROVE_TAC [Kx_predn] THEN - RW_TAC std_ss [] THEN PROVE_TAC [predn_rules], + Induct_on `x -||-> y` >> rpt conj_tac >| [ + metis_tac [predn_rules], + rw[] >> + qpat_assum `x # y -||-> z` + (strip_assume_tac o SIMP_RULE std_ss [x_ap_y_predn]) >> + rw[] >| [ + metis_tac[predn_rules], + metis_tac[predn_rules], + `?w. (y = K # w) /\ (z -||-> w)` by metis_tac [Kx_predn] >> + rw[] >> metis_tac [predn_rules], `?p q. (y = S # p # q) /\ (f -||-> p) /\ (g -||-> q)` by - PROVE_TAC [Sxy_predn] THEN - RW_TAC std_ss [] THEN PROVE_TAC [predn_rules] + metis_tac [Sxy_predn] >> + rw[] >> metis_tac [predn_rules] ], - RW_TAC std_ss [Kxy_predn] THEN PROVE_TAC [predn_rules], - RW_TAC std_ss [Sxyz_predn] THEN PROVE_TAC [predn_rules] + rw[Kxy_predn] >> metis_tac [predn_rules], + rw[Sxyz_predn] >> metis_tac [predn_rules] ]); val predn_diamond = store_thm( "predn_diamond", - ``diamond $-||->``, - PROVE_TAC [diamond_def, predn_diamond_lemma]); + ``diamond predn``, + metis_tac [diamond_def, predn_diamond_lemma]); val confluent_redn = store_thm( "confluent_redn", - ``confluent $-->``, - PROVE_TAC [predn_diamond, confluent_diamond_RTC, + ``confluent redn``, + metis_tac [predn_diamond, confluent_diamond_RTC, RTCpredn_EQ_RTCredn, diamond_RTC]); From 91c4b051fdfbae9badfb2514b853469631b3a846 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 1 Feb 2016 15:23:37 +1100 Subject: [PATCH 675/718] Use polyscripter on Tutorial's proof tools chapter --- Manual/Tutorial/.gitignore | 1 + Manual/Tutorial/Holmakefile | 5 ++++- Manual/Tutorial/{proof-tools.tex => proof-tools.stex} | 0 3 files changed, 5 insertions(+), 1 deletion(-) rename Manual/Tutorial/{proof-tools.tex => proof-tools.stex} (100%) diff --git a/Manual/Tutorial/.gitignore b/Manual/Tutorial/.gitignore index 7253340765..5583848a91 100644 --- a/Manual/Tutorial/.gitignore +++ b/Manual/Tutorial/.gitignore @@ -2,3 +2,4 @@ euclid.tex parity.tex ml.tex combin.tex +proof-tools.tex diff --git a/Manual/Tutorial/Holmakefile b/Manual/Tutorial/Holmakefile index 1620120bdc..fe5905416f 100644 --- a/Manual/Tutorial/Holmakefile +++ b/Manual/Tutorial/Holmakefile @@ -1,6 +1,6 @@ INCLUDES = ../Tools -EXTRA_CLEANS = tutorial.pdf euclid.tex parity.tex ml.tex combin.tex +EXTRA_CLEANS = tutorial.pdf euclid.tex parity.tex ml.tex combin.tex proof-tools.tex tutorial.pdf: tutorial.tex euclid.tex logic.tex preface.tex proof-tools.tex theories.tex combin.tex parity.tex ml.tex latexmk -pdf tutorial @@ -16,3 +16,6 @@ ml.tex: ml.stex ../Tools/umap ../Tools/polyscripter combin.tex: combin.stex ../Tools/umap ../Tools/polyscripter ../Tools/polyscripter ../Tools/umap < $< > $@ + +proof-tools.tex: proof-tools.stex ../Tools/umap ../Tools/polyscripter + ../Tools/polyscripter ../Tools/umap < $< > $@ diff --git a/Manual/Tutorial/proof-tools.tex b/Manual/Tutorial/proof-tools.stex similarity index 100% rename from Manual/Tutorial/proof-tools.tex rename to Manual/Tutorial/proof-tools.stex From 1a029e8a6204afd0626c744d01a6c6a595750414 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 1 Feb 2016 15:28:35 +1100 Subject: [PATCH 676/718] Tie Lib's timing output to Lib.say --- src/prekernel/Lib.sml | 11 +++-------- 1 file changed, 3 insertions(+), 8 deletions(-) diff --git a/src/prekernel/Lib.sml b/src/prekernel/Lib.sml index 7ba785650c..937b06b2ed 100644 --- a/src/prekernel/Lib.sml +++ b/src/prekernel/Lib.sml @@ -798,11 +798,9 @@ fun end_time timer = val {sys, usr} = Timer.checkCPUTimer timer val gc = Timer.checkGCTime timer in - TextIO.output (TextIO.stdOut, - "runtime: " ^ timeToString usr ^ ",\ + say ("runtime: " ^ timeToString usr ^ ",\ \ gctime: " ^ timeToString gc ^ ", \ - \ systime: " ^ timeToString sys ^ ".\n"); - TextIO.flushOut TextIO.stdOut + \ systime: " ^ timeToString sys ^ ".\n") end fun time f x = @@ -816,10 +814,7 @@ fun time f x = fun start_real_time () = Timer.startRealTimer () fun end_real_time timer = - (TextIO.output - (TextIO.stdOut, - "realtime: " ^ Time.toString (Timer.checkRealTimer timer) ^ "s\n") - ; TextIO.flushOut TextIO.stdOut) + say ("realtime: " ^ Time.toString (Timer.checkRealTimer timer) ^ "s\n") fun real_time f x = let From c8f12184790954bb4298c5569b847aded08183a7 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 1 Feb 2016 15:28:50 +1100 Subject: [PATCH 677/718] Use polyscripter on proof tools chapter --- Manual/Tutorial/proof-tools.stex | 283 ++++++++++++++++--------------- 1 file changed, 142 insertions(+), 141 deletions(-) diff --git a/Manual/Tutorial/proof-tools.stex b/Manual/Tutorial/proof-tools.stex index 23800ca4c3..73f8d13735 100644 --- a/Manual/Tutorial/proof-tools.stex +++ b/Manual/Tutorial/proof-tools.stex @@ -39,11 +39,11 @@ all possible boolean combinations. This approach's only real virtue is that it is exceptionally easy to implement. First we will prove the motivating theorem: \begin{hol} -\begin{verbatim} - val FORALL_BOOL = prove( - ``(!v. P v) = P T /\ P F``, - SRW_TAC [][EQ_IMP_THM] THEN Cases_on `v` THEN SRW_TAC [][]); -\end{verbatim} +\begin{alltt} +##eval val FORALL_BOOL = prove( + ``(!v. P v) = P T /\ P F``, + rw[EQ_IMP_THM] >> Cases_on `v` >> rw[]); +\end{alltt} \end{hol} The proof proceeds by splitting the goal into two halves, showing \[ @@ -59,37 +59,29 @@ actually already proved in the theory \theoryimp{bool}.) The next, and final, step is to rewrite with this theorem: \begin{hol} -\begin{verbatim} - val tautDP = SIMP_CONV bool_ss [FORALL_BOOL] -\end{verbatim} +\begin{alltt} + ##eval val tautDP = SIMP_CONV bool_ss [FORALL_BOOL] +\end{alltt} \end{hol} This enables the following \begin{session} -\begin{verbatim} -- tautDP ``!p q. p /\ q /\ ~p``; -> val it = |- (!p q. p /\ q /\ ~p) = F : thm +\begin{alltt} +>> tautDP ``!p q. p /\ q /\ ~p``; -- tautDP ``!p. p \/ ~p`` -> val it = |- (!p. p \/ ~p) = T : thm -\end{verbatim} +>> tautDP ``!p. p \/ ~p`` +\end{alltt} \end{session} and even the marginally more intimidating \begin{session} -\begin{verbatim} -- time tautDP +\begin{alltt} +>> time tautDP ``!p q c a. ~(((~a \/ p /\ ~q \/ ~p /\ q) /\ (~(p /\ ~q \/ ~p /\ q) \/ a)) /\ (~c \/ p /\ q) /\ (~(p /\ q) \/ c)) \/ ~(p /\ q) \/ c /\ ~a``; -runtime: 0.147s, gctime: 0.012s, systime: 0.000s. -> val it = - |- (!p q c a. - ~(((~a \/ p /\ ~q \/ ~p /\ q) /\ (~(p /\ ~q \/ ~p /\ q) \/ a)) /\ - (~c \/ p /\ q) /\ (~(p /\ q) \/ c)) \/ ~(p /\ q) \/ c /\ ~a) = - T : thm -\end{verbatim} +\end{alltt} \end{session} This is a dreadful algorithm for solving this problem. The system's @@ -189,9 +181,9 @@ final result, we will need to turn this into $\vdash\varphi$. This is best done by proving a bespoke theorem embodying the equality (there isn't one such already in the system): \begin{hol} -\begin{verbatim} - val NEG_EQ_F = prove(``(~p = F) = p``, REWRITE_TAC []); -\end{verbatim} +\begin{alltt} + ##eval val NEG_EQ_F = prove(``(~p = F) = p``, REWRITE_TAC []); +\end{alltt} \end{hol} To turn $\vdash \varphi$ into $\vdash (\forall \vec{v}.\;\varphi) = \holtxt{T}$, we will perform the following proof: @@ -228,27 +220,30 @@ which we will call \ml{DPLL\_UNIV}, with the \ml{UNIV} suffix reminding us that the input must be universally quantified. \begin{hol} \begin{verbatim} - fun DPLL_UNIV t = let - val (vs, phi) = strip_forall t - val cnf_eqn = toCNF (mk_neg phi) - val phi' = rhs (concl cnf_eqn) - in - case DPLL phi' of - Unsat phi'_eq_F => let - val negphi_eq_F = TRANS cnf_eqn phi'_eq_F - val phi_thm = CONV_RULE (REWR_CONV NEG_EQ_F) negphi_eq_F - in - EQT_INTRO (GENL vs phi_thm) - end - | Sat f => let - val t_assumed = ASSUME t - fun spec th = - spec (SPEC (f (#1 (dest_forall (concl th)))) th) - handle HOL_ERR _ => REWRITE_RULE [] th - in - CONV_RULE (REWR_CONV IMP_F_EQ_F) (DISCH t (spec t_assumed)) - end - end +>>__ datatype result = Unsat of thm | Sat of term -> term + fun DPLL (t : term) = raise Fail "Not yet implemented" + fun toCNF (t : term) = raise Fail "Not yet implemented" +##eval fun DPLL_UNIV t = let + val (vs, phi) = strip_forall t + val cnf_eqn = toCNF (mk_neg phi) + val phi' = rhs (concl cnf_eqn) + in + case DPLL phi' of + Unsat phi'_eq_F => let + val negphi_eq_F = TRANS cnf_eqn phi'_eq_F + val phi_thm = CONV_RULE (REWR_CONV NEG_EQ_F) negphi_eq_F + in + EQT_INTRO (GENL vs phi_thm) + end + | Sat f => let + val t_assumed = ASSUME t + fun spec th = + spec (SPEC (f (#1 (dest_forall (concl th)))) th) + handle HOL_ERR _ => REWRITE_RULE [] th + in + CONV_RULE (REWR_CONV IMP_F_EQ_F) (DISCH t (spec t_assumed)) + end + end \end{verbatim} \end{hol} @@ -296,12 +291,10 @@ CNF''. \HOL{} includes functions to do this in the structure \ml{defCNF}. Unfortunately, this approach adds extra, existential, quantifiers to the formula. For example \begin{session} -\begin{verbatim} -- defCNF.DEF_CNF_CONV ``p \/ (q /\ r)``; -> val it = - |- p \/ q /\ r = - ?x. (x \/ ~q \/ ~r) /\ (r \/ ~x) /\ (q \/ ~x) /\ (p \/ x) : thm -\end{verbatim} +\begin{alltt} +>>__ load "defCNF"; +>> defCNF.DEF_CNF_CONV ``p \/ (q /\ r)``; +\end{alltt} \end{session} Under the existentially-bound \holtxt{x}, the code has produced a formula in CNF{}. With an example this small, the formula is actually @@ -364,26 +357,27 @@ CNF produces an existential quantification, we use the proof sketched above. Otherwise, the transformation can be the identity function, \ml{I}: \begin{hol} -\begin{verbatim} - fun DPLL t = let - val (transform, body) = let - val (vector, body) = dest_exists t - fun transform body_eq_F = let - val body_imp_F = CONV_RULE (REWR_CONV (GSYM IMP_F_EQ_F)) body_eq_F - val fa_body_imp_F = GEN vector body_imp_F - val ex_body_imp_F = CONV_RULE FORALL_IMP_CONV fa_body_imp_F +\begin{alltt} +>>__ fun CoreDPLL (x:term) : result = raise Fail "Not yet implemented" +##eval fun DPLL t = let + val (transform, body) = let + val (vector, body) = dest_exists t + fun transform body_eq_F = let + val body_imp_F = CONV_RULE (REWR_CONV (GSYM IMP_F_EQ_F)) body_eq_F + val fa_body_imp_F = GEN vector body_imp_F + val ex_body_imp_F = CONV_RULE FORALL_IMP_CONV fa_body_imp_F + in + CONV_RULE (REWR_CONV IMP_F_EQ_F) ex_body_imp_F + end + in + (transform, body) + end handle HOL_ERR _ => (I, t) in - CONV_RULE (REWR_CONV IMP_F_EQ_F) ex_body_imp_F + case CoreDPLL body of + Unsat body_eq_F => Unsat (transform body_eq_F) + | x => x end - in - (transform, body) - end handle HOL_ERR _ => (I, t) - in - case CoreDPLL body of - Unsat body_eq_F => Unsat (transform body_eq_F) - | x => x - end -\end{verbatim} +\end{alltt} \end{hol} where we have still to implement the core DPLL procedure (called \ml{CoreDPLL} above). The above code uses \ml{REWR\_CONV} with the @@ -452,12 +446,12 @@ among the assumptions of the result. The \ml{casesplit} function is thus: \begin{hol} \begin{verbatim} - fun casesplit v th = let - val eqT = ASSUME (mk_eq(v, boolSyntax.T)) - val eqF = ASSUME (mk_eq(v, boolSyntax.F)) - in - (REWRITE_RULE [eqT] th, REWRITE_RULE [eqF] th) - end + ##eval fun casesplit v th = let + val eqT = ASSUME (mk_eq(v, boolSyntax.T)) + val eqF = ASSUME (mk_eq(v, boolSyntax.F)) + in + (REWRITE_RULE [eqT] th, REWRITE_RULE [eqF] th) + end \end{verbatim} \end{hol} @@ -470,18 +464,18 @@ those hypotheses into a finite-map, and then returns the lookup function for that finite-map: \begin{hol} \begin{verbatim} - fun mk_satmap th = let - val hyps = hypset th - fun foldthis (t,acc) = let - val (l,r) = dest_eq t - in - Binarymap.insert(acc,l,r) - end handle HOL_ERR _ => acc - val fmap = HOLset.foldl foldthis (Binarymap.mkDict Term.compare) hyps - in - Sat (fn v => Binarymap.find(fmap,v) - handle Binarymap.NotFound => boolSyntax.T) - end + ##eval fun mk_satmap th = let + val hyps = hypset th + fun foldthis (t,acc) = let + val (l,r) = dest_eq t + in + Binarymap.insert(acc,l,r) + end handle HOL_ERR _ => acc + val fmap = HOLset.foldl foldthis (Binarymap.mkDict Term.compare) hyps + in + Sat (fn v => Binarymap.find(fmap,v) + handle Binarymap.NotFound => boolSyntax.T) + end \end{verbatim} \end{hol} The \ml{foldthis} function above adds the equations that are stored as @@ -532,35 +526,36 @@ We can put these fragments together and write the top-level \begin{figure}[htbp] \begin{holboxed} \begin{verbatim} -fun CoreDPLL form = let - val initial_th = ASSUME form - fun recurse th = let - val c = concl th - in - if c = boolSyntax.T then - mk_satmap th - else if c = boolSyntax.F then - Unsat th - else let - val v = find_splitting_var c - val (l,r) = casesplit v th - in - case recurse l of - Unsat l_false => let - in - case recurse r of - Unsat r_false => - Unsat (DISJ_CASES (SPEC v BOOL_CASES_AX) l_false r_false) - | x => x - end - | x => x - end - end -in - case (recurse initial_th) of - Unsat th => Unsat (CONV_RULE (REWR_CONV IMP_F_EQ_F) (DISCH form th)) - | x => x -end +>>__ fun find_splitting_var (c:term) : term = raise Fail "" +##eval fun CoreDPLL form = let + val initial_th = ASSUME form + fun recurse th = let + val c = concl th + in + if c = boolSyntax.T then + mk_satmap th + else if c = boolSyntax.F then + Unsat th + else let + val v = find_splitting_var c + val (l,r) = casesplit v th + in + case recurse l of + Unsat l_false => let + in + case recurse r of + Unsat r_false => + Unsat (DISJ_CASES (SPEC v BOOL_CASES_AX) l_false r_false) + | x => x + end + | x => x + end + end + in + case (recurse initial_th) of + Unsat th => Unsat (CONV_RULE (REWR_CONV IMP_F_EQ_F) (DISCH form th)) + | x => x + end \end{verbatim} \end{holboxed} \caption{The core of the DPLL function} @@ -648,34 +643,40 @@ do with the \ml{foldl} function: \subsection{Performance} \label{sec:dpll-performance} +##use ../../examples/dpll.sml Once inputs get even a little beyond the clearly trivial, the function we have written (at the top-level, \ml{DPLL\_UNIV}) performs considerably better than the truth table implementation. For example, the generalisation of the following term, with 29 variables, takes -\ml{wrapper} three and a half seconds to demonstrate as a tautology: +our function between three and four seconds to demonstrate as a tautology: \begin{hol} -\begin{verbatim} - (s0_0 = (x_0 = ~y_0)) /\ (c0_1 = x_0 /\ y_0) /\ - (s0_1 = ((x_1 = ~y_1) = ~c0_1)) /\ - (c0_2 = x_1 /\ y_1 \/ (x_1 \/ y_1) /\ c0_1) /\ - (s0_2 = ((x_2 = ~y_2) = ~c0_2)) /\ - (c0_3 = x_2 /\ y_2 \/ (x_2 \/ y_2) /\ c0_2) /\ - (s1_0 = ~(x_0 = ~y_0)) /\ (c1_1 = x_0 /\ y_0 \/ x_0 \/ y_0) /\ - (s1_1 = ((x_1 = ~y_1) = ~c1_1)) /\ - (c1_2 = x_1 /\ y_1 \/ (x_1 \/ y_1) /\ c1_1) /\ - (s1_2 = ((x_2 = ~y_2) = ~c1_2)) /\ - (c1_3 = x_2 /\ y_2 \/ (x_2 \/ y_2) /\ c1_2) /\ - (c_3 = ~c_0 /\ c0_3 \/ c_0 /\ c1_3) /\ - (s_0 = ~c_0 /\ s0_0 \/ c_0 /\ s1_0) /\ - (s_1 = ~c_0 /\ s0_1 \/ c_0 /\ s1_1) /\ - (s_2 = ~c_0 /\ s0_2 \/ c_0 /\ s1_2) /\ ~c_0 /\ - (s2_0 = (x_0 = ~y_0)) /\ (c2_1 = x_0 /\ y_0) /\ - (s2_1 = ((x_1 = ~y_1) = ~c2_1)) /\ - (c2_2 = x_1 /\ y_1 \/ (x_1 \/ y_1) /\ c2_1) /\ - (s2_2 = ((x_2 = ~y_2) = ~c2_2)) /\ - (c2_3 = x_2 /\ y_2 \/ (x_2 \/ y_2) /\ c2_2) ==> - (c_3 = c2_3) /\ (s_0 = s2_0) /\ (s_1 = s2_1) /\ (s_2 = s2_2) -\end{verbatim} +\begin{alltt} +##eval val t0 = `` + (s0_0 = (x_0 = ~y_0)) /\ (c0_1 = x_0 /\ y_0) /\ + (s0_1 = ((x_1 = ~y_1) = ~c0_1)) /\ + (c0_2 = x_1 /\ y_1 \/ (x_1 \/ y_1) /\ c0_1) /\ + (s0_2 = ((x_2 = ~y_2) = ~c0_2)) /\ + (c0_3 = x_2 /\ y_2 \/ (x_2 \/ y_2) /\ c0_2) /\ + (s1_0 = ~(x_0 = ~y_0)) /\ (c1_1 = x_0 /\ y_0 \/ x_0 \/ y_0) /\ + (s1_1 = ((x_1 = ~y_1) = ~c1_1)) /\ + (c1_2 = x_1 /\ y_1 \/ (x_1 \/ y_1) /\ c1_1) /\ + (s1_2 = ((x_2 = ~y_2) = ~c1_2)) /\ + (c1_3 = x_2 /\ y_2 \/ (x_2 \/ y_2) /\ c1_2) /\ + (c_3 = ~c_0 /\ c0_3 \/ c_0 /\ c1_3) /\ + (s_0 = ~c_0 /\ s0_0 \/ c_0 /\ s1_0) /\ + (s_1 = ~c_0 /\ s0_1 \/ c_0 /\ s1_1) /\ + (s_2 = ~c_0 /\ s0_2 \/ c_0 /\ s1_2) /\ ~c_0 /\ + (s2_0 = (x_0 = ~y_0)) /\ (c2_1 = x_0 /\ y_0) /\ + (s2_1 = ((x_1 = ~y_1) = ~c2_1)) /\ + (c2_2 = x_1 /\ y_1 \/ (x_1 \/ y_1) /\ c2_1) /\ + (s2_2 = ((x_2 = ~y_2) = ~c2_2)) /\ + (c2_3 = x_2 /\ y_2 \/ (x_2 \/ y_2) /\ c2_2) ==> + (c_3 = c2_3) /\ (s_0 = s2_0) /\ (s_1 = s2_1) /\ (s_2 = s2_2)``; +##eval val t = list_mk_forall(free_vars t0, t0); + +>> val _ = time DPLL_UNIV t; +>> val _ = time tautLib.TAUT_PROVE t; +\end{alltt} \end{hol} (If you want real speed, the built-in function \ml{tautLib.TAUT\_PROVE} does the above in less than a hundredth of a second, by using an external tool to generate the proof of unsatisfiability, and then translating that proof back into HOL.) From 19eedc5bf3eaeafd05b44d2fbe3fbd1f09c3edec Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 1 Feb 2016 15:31:06 +1100 Subject: [PATCH 678/718] =?UTF-8?q?Give=20Laurent=20Th=C3=A9ry=20his=20acu?= =?UTF-8?q?te=20accents=20in=20Tutorial?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Manual/Tutorial/Holmakefile | 2 +- Manual/Tutorial/more-examples.tex | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/Manual/Tutorial/Holmakefile b/Manual/Tutorial/Holmakefile index fe5905416f..5dac87a18a 100644 --- a/Manual/Tutorial/Holmakefile +++ b/Manual/Tutorial/Holmakefile @@ -2,7 +2,7 @@ INCLUDES = ../Tools EXTRA_CLEANS = tutorial.pdf euclid.tex parity.tex ml.tex combin.tex proof-tools.tex -tutorial.pdf: tutorial.tex euclid.tex logic.tex preface.tex proof-tools.tex theories.tex combin.tex parity.tex ml.tex +tutorial.pdf: tutorial.tex euclid.tex logic.tex preface.tex proof-tools.tex theories.tex combin.tex parity.tex ml.tex more-examples.tex latexmk -pdf tutorial euclid.tex: euclid.stex ../Tools/umap ../Tools/polyscripter euclid-extras.ML diff --git a/Manual/Tutorial/more-examples.tex b/Manual/Tutorial/more-examples.tex index 7ac125f382..0b2083cfb1 100644 --- a/Manual/Tutorial/more-examples.tex +++ b/Manual/Tutorial/more-examples.tex @@ -71,14 +71,14 @@ \chapter{More Examples} \item[\tt Thery.sml] - A very short example due to Laurent Thery, demonstrating a cute + A very short example due to Laurent Th\'ery, demonstrating a cute inductive proof. \item[\tt RSA] This directory develops some of the mathematics underlying the RSA cryptography scheme. The theories have been - produced by Laurent Thery of INRIA Sophia-Antipolis. + produced by Laurent Th\'ery of INRIA Sophia-Antipolis. \end{description} From 96863e1f528075c336e41018abe7f0662ceb89bb Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 1 Feb 2016 15:43:53 +1100 Subject: [PATCH 679/718] Tweaks to the Tutorial's preface --- Manual/Tutorial/preface.tex | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-) diff --git a/Manual/Tutorial/preface.tex b/Manual/Tutorial/preface.tex index c45fc1d498..e53b07642e 100644 --- a/Manual/Tutorial/preface.tex +++ b/Manual/Tutorial/preface.tex @@ -34,17 +34,13 @@ \section*{Getting started} \item The programming meta-language \ML, and how to interact with it. \item The formal logic supported by the \HOL{} system (higher order logic) and its manipulation via \ML. -\item Forward proof and derived rules of inference. \item Goal directed proof, tactics, and tacticals. \end{enumerate} % -Chapters 2 and 3 introduce these topics. -Chapter~\ref{chap:euclid} then develops an extended example --- Euclid's +Chapter~\ref{ML} introduces \ML{}. +Chapter~\ref{chap:euclid} then develops an extended example---Euclid's proof of the infinitude of primes---to illustrate how \HOL{} is used -to prove theorems. - -%Chapter~\ref{proof} then describes forward and goal -%directed proof in much greater detail. +to prove theorems, demonstrating both the logic and proving properties of one's definitions with some high-level tactics. Chapter~\ref{parity} features another worked example: the specification and verification of a simple sequential parity checker. The intention From 73106ea2f3cae7a4850ffc9e79722fce75ee136d Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 4 Feb 2016 10:38:15 +1100 Subject: [PATCH 680/718] Start using polyscripter in Description manual --- Manual/Description/.gitignore | 1 + Manual/Description/Holmakefile | 10 ++++++++++ Manual/Description/{drules.tex => drules.stex} | 0 3 files changed, 11 insertions(+) create mode 100644 Manual/Description/.gitignore create mode 100644 Manual/Description/Holmakefile rename Manual/Description/{drules.tex => drules.stex} (100%) diff --git a/Manual/Description/.gitignore b/Manual/Description/.gitignore new file mode 100644 index 0000000000..36fc1e9254 --- /dev/null +++ b/Manual/Description/.gitignore @@ -0,0 +1 @@ +drules.tex diff --git a/Manual/Description/Holmakefile b/Manual/Description/Holmakefile new file mode 100644 index 0000000000..06dd41e35e --- /dev/null +++ b/Manual/Description/Holmakefile @@ -0,0 +1,10 @@ +TEX_SOURCES = description.tex ../LaTeX/ack.tex title.tex preface.tex ../LaTeX/commands.tex system.tex drules.tex tactics.tex theories.tex definitions.tex libraries.tex misc.tex + +PS_STUFF = ../Tools/polyscripter ../Tools/umap +PS_COMMAND = $(PS_STUFF) < $< > $@ + +description.pdf: $(TEX_SOURCES) + latexmk -pdf description + +drules.tex: drules.stex $(PS_STUFF) + $(PS_COMMAND) diff --git a/Manual/Description/drules.tex b/Manual/Description/drules.stex similarity index 100% rename from Manual/Description/drules.tex rename to Manual/Description/drules.stex From 3d1c774bf05044515d9411566d8435c13ccb1774 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 4 Feb 2016 10:38:46 +1100 Subject: [PATCH 681/718] Tweaks to derived rules chapter of Description --- Manual/Description/drules.stex | 181 ++++++++------------------------- 1 file changed, 44 insertions(+), 137 deletions(-) diff --git a/Manual/Description/drules.stex b/Manual/Description/drules.stex index b5b4eb0473..2593335d47 100644 --- a/Manual/Description/drules.stex +++ b/Manual/Description/drules.stex @@ -62,35 +62,29 @@ using the \ML\ functions \ml{ASSUME}\index{ASSUME@\ml{ASSUME}} and \setcounter{sessioncount}{1} \begin{session} -\begin{verbatim} -- show_assums := true; -> val it = () : unit +\begin{alltt} +>> show_assums := true; -- val th1 = ASSUME ``t1 ==> t2``; -> val th1 = [t1 ==> t2] |- t1 ==> t2 : thm +>> val th1 = ASSUME ``t1 ==> t2``; -- val th2 = ASSUME ``t1:bool`` -> val th2 = [t1] |- t1 : thm +>> val th2 = ASSUME ``t1:bool`` -- MP th1 th2; -> val it = [t1 ==> t2, t1] |- t2 : thm -\end{verbatim} +>> MP th1 th2; +\end{alltt} \end{session} -\noindent More briefly, one could evaluate the following, and `count'\index{counting inferences, in HOL proofs@counting inferences, in \HOL{} proofs} the -invocations of functions representing primitive inferences. +\noindent More briefly, one could evaluate the following, and `count'\index{counting inferences, in HOL proofs@counting inferences, in \HOL{} proofs} the invocations of functions representing primitive inferences. +Here, the \ml{Count.apply} function counts the number of primitive inferences performed after the function is applied to the argument. +In the first invocation, this means that only the \emph{modus ponens} step is counted. +We create an artificial function to see the count of all 3 in the second interaction: \begin{session} -\begin{verbatim} -#set_flag(`timing`, true);; -false : bool -Run time: 0.0s - -#MP(ASSUME "t1 ==> t2")(ASSUME "t1:bool");; -t1 ==> t2, t1 |- t2 -Run time: 0.0s -Intermediate theorems generated: 3 -\end{verbatim} +\begin{alltt} +>> Count.apply (MP (ASSUME ``t1 ==> t2``)) (ASSUME ``t1:bool``); + +>> fun f () = MP (ASSUME ``t1 ==> t2``) (ASSUME ``t1:bool``); +>> Count.apply f (); +\end{alltt} \end{session} \noindent Each of the three inference steps of the abstract proof @@ -161,10 +155,9 @@ appropriate sequence of primitive inferences. The \ML\ definition of \ml{UNDISCH} is simply \begin{session} -\begin{verbatim} -- fun UNDISCH th = MP th (ASSUME(fst(dest_imp(concl th))));; -> val UNDISCH = fn : thm -> thm -\end{verbatim} +\begin{alltt} +>> fun UNDISCH th = MP th (ASSUME(fst(dest_imp(concl th)))); +\end{alltt} \end{session} \noindent This provides a function that maps a theorem to a theorem; @@ -179,25 +172,14 @@ counted.% \setcounter{sessioncount}{1} \begin{session} -\begin{verbatim} -#th;; -|- (t1 ==> t2) ==> (t2 ==> t1) ==> (t1 = t2) -Run time: 0.0s - -#set_flag(`timing`,true);; -true : bool -Run time: 0.0s - -#UNDISCH th;; -t1 ==> t2 |- (t2 ==> t1) ==> (t1 = t2) -Run time: 0.1s -Intermediate theorems generated: 2 - -#UNDISCH it;; -t1 ==> t2, t2 ==> t1 |- t1 = t2 -Run time: 0.0s -Intermediate theorems generated: 2 -\end{verbatim} +\begin{alltt} +>>__ val th = DECIDE ``(t1 ==> t2) ==> (t2 ==> t1) ==> (t1 = t2)`` +>> th; + +>> Count.apply UNDISCH th; + +>> Count.apply UNDISCH it; +\end{alltt} \end{session} \noindent Each successful application of {\small\verb%UNDISCH%} @@ -299,29 +281,13 @@ of theorems is adjusted as above. \setcounter{sessioncount}{1} \begin{session} -\begin{verbatim} -#top_print print_all_thm;; -- : (thm -> void) - -#set_flag(`timing`,true);; -false : bool -Run time: 0.0s - -#REWRITE_RULE - [GREATER] - (ASSUME "SUC 4 > 0 = (SUC 3 > 0 = (SUC 2 > 0 = (SUC 1 > 0 = SUC 0 > 0)))");; -##Definition GREATER autoloaded from theory `arithmetic`. -GREATER = |- !m n. m > n = n < m -Run time: 1.5s -Intermediate theorems generated: 1 - -(SUC 4) > 0 = -((SUC 3) > 0 = ((SUC 2) > 0 = ((SUC 1) > 0 = (SUC 0) > 0))) -|- 0 < (SUC 4) = - (0 < (SUC 3) = (0 < (SUC 2) = (0 < (SUC 1) = 0 < (SUC 0)))) -Run time: 0.3s -Intermediate theorems generated: 23 -\end{verbatim} +\begin{alltt} +>>__ Globals.linewidth := 60; +>> Count.apply (REWRITE_RULE [arithmeticTheory.GREATER_DEF]) + (ASSUME ``SUC 4 > 0 = (SUC 3 > 0 = (SUC 2 > 0 = + (SUC 1 > 0 = SUC 0 > 0)))``); +>>__ Globals.linewidth := 72; +\end{alltt} \end{session} \noindent Notice that rewriting @@ -386,74 +352,14 @@ optimised for improved performance. In addition, for reasons that are mostly historical, not all the inferences that are derived in terms of the abstract logic are actually derived in the current version of the \HOL\ system. That is, -there are currently about forty rules that are installed in the system +there are currently a number of rules that are installed in the system on an `axiomatic' basis, all of which should be derived by explicit -inference. Although the current status of these rules is not -satisfactory, and it is planned, as a high priority, to derive them -properly in a future version, their current status does not actually -compromise the consistency of the logic. In effect, the existing -\HOL\ system has a deductive system more comprehensive than the one -presented abstractly, but the model outlined in \LOGIC{} would easily -extend to cover it.% +inference. +These rules' status does not actually compromise the consistency of the logic. +In effect, the existing \HOL\ system has a deductive system more comprehensive than the one presented abstractly, but the model outlined in \LOGIC{} would easily extend to cover it.% % \index{derived rules, in HOL logic@derived rules, in \HOL{} logic!pre-defined|)} -For reference, in \HOL\ Version 2.0 the following rules that should be -derived -% -\index{inference rules, of HOL logic@inference rules, of \HOL{} logic!some not properly derived|(}% -\index{rules in HOL logic, some not properly derived@rules in \HOL{} logic, some not properly derived|(}% -% -are not derived, but (for efficiency) are implemented as -primitives. The list includes some conversions and conversion-valued -functions. % (conversions are discussed in Chapter~\ref{avra_conv}). -\vfill \newpage - -\begin{hol} -\index{derived rules, in HOL logic@derived rules, in \HOL{} logic!list of axiomatic} -\index{AP_TERM@\ml{AP\_TERM}} -\index{AP_THM@\ml{AP\_THM}} -\index{CCONTR@\ml{CCONTR}} -\index{CHOOSE@\ml{CHOOSE}} -\index{CONJ@\ml{CONJ}} -\index{CONJUNCT1@\ml{CONJUNCT1}} -\index{CONJUNCT2@\ml{CONJUNCT2}} -\index{DISJ_CASES@\ml{DISJ\_CASES}} -\index{DISJ1@\ml{DISJ1}} -\index{DISJ2@\ml{DISJ2}} -\index{EQ_IMP_RULE@\ml{EQ\_IMP\_RULE}} -\index{EQ_MP@\ml{EQ\_MP}} -\index{EQT_INTRO@\ml{EQT\_INTRO}} -\index{ETA_CONV@\ml{ETA\_CONV}} -\index{EXISTS@\ml{EXISTS}} -\index{EXT@\ml{EXT}} -\index{GEN@\ml{GEN}} -\index{MK_ABS@\ml{MK\_ABS}} -\index{MK_COMB@\ml{MK\_COMB}} -\index{num_CONV@\ml{num\_CONV}} -\index{SPEC@\ml{SPEC}} -\index{SUBS@\ml{SUBS}} -\index{SUBS_OCCS@\ml{SUBS\_OCCS}} -\index{SUBST_CONV@\ml{SUBST\_CONV}} -\index{SYM@\ml{SYM}} -\index{TRANS@\ml{TRANS}} -\begin{verbatim} - ADD_ASSUM CONTR IMP_ANTISYM_RULE - ALPHA DEF_EXISTS_RULE IMP_TRANS - AP_TERM DISJ_CASES INST - AP_THM DISJ1 MK_ABS - SUBS DISJ2 MK_COMB - SUBS_OCCS EQ_IMP_RULE MK_EXISTS - CCONTR EQ_MP NOT_ELIM - CHOOSE EQT_INTRO NOT_INTRO - CONJ ETA_CONV num_CONV - EXISTS SPEC TRANS - EXT SUBST_CONV CONJUNCT1 - GEN SYM CONJUNCT2 -\end{verbatim}\end{hol} -\index{inference rules, of HOL logic@inference rules, of \HOL{} logic!some not properly derived|)} -\index{rules in HOL logic, some not properly derived@rules in \HOL{} logic, some not properly derived|)} - \index{inference rules, of HOL logic@inference rules, of \HOL{} logic!derived|(} The derivations that follow consist of sequences of numbered steps each of which @@ -652,7 +558,7 @@ $$\Gamma_1\turn t_1=t_2\qquad\qquad\qquad \Gamma_2\turn t_1\over \begin{holboxed} \index{EQ_IMP_RULE@\ml{EQ\_IMP\_RULE}|pin} \begin{verbatim} - EQ_IMP_RULE : thm -> (thm # thm) + EQ_IMP_RULE : thm -> thm * thm \end{verbatim}\end{holboxed} \vspace{12pt plus2pt minus1pt} @@ -986,7 +892,7 @@ type-instantiated axiom] \index{choice operator, in HOL logic@choice operator, in \HOL{} logic!inference rules for} \index{SELECT_ELIM@\ml{SELECT\_ELIM}|pin} \begin{verbatim} - SELECT_ELIM : thm -> (term # thm) -> thm + SELECT_ELIM : thm -> term * thm -> thm \end{verbatim}\end{holboxed} \vspace{12pt plus2pt minus1pt} @@ -1018,8 +924,9 @@ hypothesis. \begin{holboxed} \index{EXISTS@\ml{EXISTS}|pin} \begin{verbatim} - EXISTS : (term # term) -> thm -> thm -\end{verbatim}\end{holboxed} + EXISTS : term * term -> thm -> thm +\end{verbatim} +\end{holboxed} \vspace{12pt plus2pt minus1pt} @@ -1061,7 +968,7 @@ doesn't become bound after substitution. \begin{holboxed} \index{CHOOSE@\ml{CHOOSE}|pin} \begin{verbatim} - CHOOSE : (term # thm) -> thm -> thm + CHOOSE : term * thm -> thm -> thm \end{verbatim}\end{holboxed} \vspace{12pt plus2pt minus1pt} From a63456ae32b4f11bf86cd38ee2c98275a4952039 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 4 Feb 2016 10:39:28 +1100 Subject: [PATCH 682/718] More minor Tutorial tweaks --- Manual/Tutorial/Holmakefile | 2 +- Manual/Tutorial/intro.tex | 6 ++---- Manual/Tutorial/ml.stex | 2 +- 3 files changed, 4 insertions(+), 6 deletions(-) diff --git a/Manual/Tutorial/Holmakefile b/Manual/Tutorial/Holmakefile index 5dac87a18a..43c7a435ae 100644 --- a/Manual/Tutorial/Holmakefile +++ b/Manual/Tutorial/Holmakefile @@ -2,7 +2,7 @@ INCLUDES = ../Tools EXTRA_CLEANS = tutorial.pdf euclid.tex parity.tex ml.tex combin.tex proof-tools.tex -tutorial.pdf: tutorial.tex euclid.tex logic.tex preface.tex proof-tools.tex theories.tex combin.tex parity.tex ml.tex more-examples.tex +tutorial.pdf: tutorial.tex euclid.tex logic.tex preface.tex proof-tools.tex theories.tex combin.tex parity.tex ml.tex more-examples.tex intro.tex latexmk -pdf tutorial euclid.tex: euclid.stex ../Tools/umap ../Tools/polyscripter euclid-extras.ML diff --git a/Manual/Tutorial/intro.tex b/Manual/Tutorial/intro.tex index 0fca28610d..a7445c7d17 100644 --- a/Manual/Tutorial/intro.tex +++ b/Manual/Tutorial/intro.tex @@ -11,10 +11,8 @@ \chapter{Getting and Installing \HOL{}} \section{Getting \HOL{}} -The \HOL{} system can be downloaded from -\url{http://hol.sourceforge.net}. The naming scheme for \holn{} -releases is $\langle${\it name}$\rangle$-$\langle${\it - number}$\rangle$; the release described here is \holnversion. +The \HOL{} system can be downloaded from \url{http://hol-theorem-prover.org}. +The naming scheme for \holn{} releases is $\langle${\it name}$\rangle$-$\langle${\it number}$\rangle$; the release described here is \holnversion. \section{The {\tt hol-info} mailing list} diff --git a/Manual/Tutorial/ml.stex b/Manual/Tutorial/ml.stex index 2e1e89496e..7cb65eeb1f 100644 --- a/Manual/Tutorial/ml.stex +++ b/Manual/Tutorial/ml.stex @@ -141,7 +141,7 @@ The values {\small\verb|(1,2,3)|}, {\small\verb|(1,(2,3))|} and >> val triple2 = (1, (true, "abc")); ->> #2 triple2;; +>> #2 triple2; \end{alltt} \end{session} From 37c2afb5b64c597c901c4085e3731427c76a7579 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 4 Feb 2016 11:26:52 +1100 Subject: [PATCH 683/718] Update tactics chapter of Description --- Manual/Description/.gitignore | 1 + Manual/Description/Holmakefile | 3 + .../Description/{tactics.tex => tactics.stex} | 655 +++++------------- 3 files changed, 189 insertions(+), 470 deletions(-) rename Manual/Description/{tactics.tex => tactics.stex} (77%) diff --git a/Manual/Description/.gitignore b/Manual/Description/.gitignore index 36fc1e9254..e443dde1cf 100644 --- a/Manual/Description/.gitignore +++ b/Manual/Description/.gitignore @@ -1 +1,2 @@ drules.tex +tactics.tex diff --git a/Manual/Description/Holmakefile b/Manual/Description/Holmakefile index 06dd41e35e..30d30e9df5 100644 --- a/Manual/Description/Holmakefile +++ b/Manual/Description/Holmakefile @@ -8,3 +8,6 @@ description.pdf: $(TEX_SOURCES) drules.tex: drules.stex $(PS_STUFF) $(PS_COMMAND) + +tactics.tex: tactics.stex $(PS_STUFF) + $(PS_COMMAND) diff --git a/Manual/Description/tactics.tex b/Manual/Description/tactics.stex similarity index 77% rename from Manual/Description/tactics.tex rename to Manual/Description/tactics.stex index bbe96d9117..f7ae836620 100644 --- a/Manual/Description/tactics.tex +++ b/Manual/Description/tactics.stex @@ -236,40 +236,28 @@ \section{Tactics, goals and validations} \setcounter{sessioncount}{1} \begin{session} -\begin{verbatim} -- val g = ([]:term list,``(HD[1;2;3] = 1) /\ (TL[1;2;3] = [2;3])``); -> val g = ([], ``(HD[1;2;3] = 1) /\ (TL[1;2;3] = [2;3])``) : - term list * term - -- val (gl1,p1) = conj_tac g; -> val gl1 = [([], ``HD[1;2;3] = 1``); ([], ``TL[1;2;3] = [2;3]``)] : - (term list * term) list - val p1 = fn : thm list -> thm -\end{verbatim} +\begin{alltt} +>> val gl0 = ([]:term list,``(HD[1;2;3] = 1) /\ (TL[1;2;3] = [2;3])``); + +>> val (gl1,p1) = conj_tac gl0; +\end{alltt} \end{session} \noindent The subgoals are each rewritten, using the definitions of \ml{HD} and \ml{TL}: \begin{session} -\begin{verbatim} -- open listTheory - [...] +\begin{alltt} +>>_ open listTheory; -- HD; -> val it = |- !h t. HD (h::t) = h : thm +>> HD; -- TL; -> val it = |- !h t. TL (h::t) = t : thm +>> TL; -- val (gl1_1,p1_1) = REWRITE_TAC[HD,TL](hd gl1); -> val gl1_1 = [] : (term list * term) list - val p1_1 = fn : thm list -> thm +>> val (gl1_1,p1_1) = rewrite_tac[HD,TL](hd gl1); -- val (gl1_2,p1_2) = REWRITE_TAC[HD,TL](hd(tl gl1)); -> val gl1_2 = [] : (term list * term) list - val p1_2 = fn : thm list -> thm -\end{verbatim} +>> val (gl1_2,p1_2) = rewrite_tac[HD,TL](hd(tl gl1)); +\end{alltt} \end{session} \noindent Both of the two subgoals are now solved, so the @@ -279,16 +267,13 @@ \section{Tactics, goals and validations} \vfill \newpage \begin{session} -\begin{verbatim} -- val th1 = p1_1[]; -> val th1 = |- HD [1; 2; 3] = 1 : thm +\begin{alltt} +>> val th1 = p1_1[]; -- val th2 = p1_2[]; -> val th2 = |- TL [1; 2; 3] = [2; 3] : thm +>> val th2 = p1_2[]; -- p1[th1,th2]; -> val it = |- (HD [1; 2; 3] = 1) /\ (TL [1; 2; 3] = [2;3]) : thm -\end{verbatim} +>> p1[th1,th2]; +\end{alltt} \end{session} \noindent Although only the theorems achieving the subgoals are `seen' here, @@ -360,14 +345,11 @@ \section{Tactics, goals and validations} is continued, to illustrate the use of the tactical \ml{>>}: \begin{session} -\begin{verbatim} -- val (gl2,p2) = (conj_tac >> rewrite_tac [HD, TL])g; -> val gl2 = [] : (term list * term) list - val p2 = fn : thm list -> thm +\begin{alltt} +>> val (gl2,p2) = (conj_tac >> rewrite_tac [HD, TL]) gl0; -- p2 []; -> val it = |- (HD [1; 2; 3] = 1) /\ (TL [1; 2; 3] = [2; 3]) -\end{verbatim} +>> p2 []; +\end{alltt} \end{session} \noindent The single tactic \ml{conj\_tac >> rewrite\_tac[HD;TL]} @@ -506,9 +488,9 @@ \subsection{Case analysis} \end{verbatim} \end{holboxed} -\begin{itemize} +\begin{description} -\item{\bf Summary:} +\item[Summary:] \ml{Cases\_on}~$q$, where $q$ is a quotation denoting a term of an algebraic type (\eg, booleans, lists, natural numbers, types defined by the user with \ml{Datatype}), does case analysis on that term. Let the relevant type have $m$ constructors $\textsf{C}_1$ to $\textsf{C}_m$, where $\textsf{C}_i$ has $n_i$ arguments. If the term is a variable, then the variable is substituted out of the goal entirely: @@ -533,8 +515,8 @@ \subsection{Case analysis} \\ \end{tabular} \end{center} -\item{\bf Use:} Case analysis. -\end{itemize} +\item[Use:] Case analysis. +\end{description} \index{Cases_on@\ml{Cases\_on}|)} \subsection{Rewriting} @@ -660,12 +642,12 @@ \subsection{Identity} \end{verbatim} \end{holboxed} -\begin{itemize} +\begin{description} \index{identity tactic}\index{tactics!identity for} \index{THEN@\ml{THEN}} -\item{\bf Summary:} The identity tactic for the tactical \ml{\gt\gt} (see the example in Section~\ref{tactics}, and Section~\ref{sec:sequencing-tacticals}). Useful for writing tactics. +\item[Summary:] The identity tactic for the tactical \ml{\gt\gt} (see the example in Section~\ref{tactics}, and Section~\ref{sec:sequencing-tacticals}). Useful for writing tactics. -\item{\bf Use:} +\item[Use:] \begin{enumerate} \index{REPEAT@\ml{REPEAT}} \item Writing tacticals (see description of \ml{rpt} in Section~\ref{tacticals}). @@ -675,7 +657,7 @@ \subsection{Identity} With \ml{THENL} (see Section~\ref{sec:thenl}); for example, if tactic $T$ produces two subgoals and $T_1$ is to be applied to the first while nothing is to be done to the second, then $T\;\ml{THENL}\;[T_1,\,\ml{all\_tac}]$ is the tactic required. \end{enumerate} -\end{itemize} +\end{description} \subsection{Splitting logical equivalences} @@ -688,9 +670,9 @@ \subsection{Splitting logical equivalences} \end{verbatim} \end{holboxed} -\begin{itemize} +\begin{description} -\item{\bf Summary:} +\item[Summary:] \ml{eq_tac} splits an equational goal into two implications (the `if-case' and the `only-if' case): \begin{center} @@ -702,14 +684,14 @@ \subsection{Splitting logical equivalences} \end{tabular} \end{center} -\item{\bf Use:} +\item[Use:] Proving logical equivalences, \ie\ goals of the form ``$u\iff v$'' where $u$ and $v$ are boolean terms. Note that the same end can often be achieved by rewriting with the theorem \ml{EQ\_IMP\_THM}, which states \[ \vdash (u \iff v) \iff (u \Rightarrow v) \land (v \Rightarrow u) \] -\end{itemize} +\end{description} \subsection{Solving existential goals} @@ -724,7 +706,7 @@ \subsection{Solving existential goals} \begin{itemize} -\item{\bf Summary:} +\item[Summary:] $\ml{EXISTS\_TAC}\;u$ reduces an existential goal $\exists x.\;t[x]$ to the subgoal $t[u]$. (In ASCII form, the existential is printed as a question mark.) @@ -737,7 +719,7 @@ \subsection{Solving existential goals} \end{tabular} \end{center} -\item{\bf Use:} Proving existential goals. +\item[Use:] Proving existential goals. \end{itemize} \index{tactics!list of some|)} @@ -764,9 +746,11 @@ \section{Tacticals} \subsection{Alternation}\index{alternation!of tactics|(}\index{tactics!alternation of} \index{ORELSE@\ml{ORELSE}|pin} -\begin{holboxed}\begin{verbatim} +\begin{holboxed} +\begin{verbatim} ORELSE : tactic -> tactic -> tactic -\end{verbatim}\end{holboxed} +\end{verbatim} +\end{holboxed} The tactical {\small\verb%ORELSE%} @@ -778,22 +762,26 @@ \subsection{Alternation}\index{alternation!of tactics|(}\index{tactics!alternati it applies $T_2$. \ml{ORELSE} is defined in \ML\ as a curried infix by -\begin{hol}\begin{verbatim} +\begin{hol} +\begin{verbatim} (T1 ORELSE T2) g = T1 g ? T2 g -\end{verbatim}\end{hol}\index{alternation!of tactics|)} +\end{verbatim} +\end{hol}\index{alternation!of tactics|)} \subsection{First success} \index{FIRST@\ml{FIRST}|pin} -\begin{holboxed}\begin{verbatim} +\begin{holboxed} +\begin{verbatim} FIRST : tactic list -> tactic \end{verbatim}\end{holboxed} The tactical \ml{FIRST} applies the first tactic, in a list of tactics, that succeeds. -\begin{hol}\begin{alltt} +\begin{hol} +\begin{alltt} FIRST [\(T\sb{1}\);\(T\sb{2}\);\(\ldots\);\(T\sb{n}\)] = \(T\sb{1}\) ORELSE \(T\sb{2}\) ORELSE \(\ldots\) ORELSE \(T\sb{n}\) \end{alltt}\end{hol} @@ -802,9 +790,11 @@ \subsection{First success} \subsection{Change detection} \index{CHANGED_TAC@\ml{CHANGED\_TAC}|pin} -\begin{holboxed}\begin{verbatim} +\begin{holboxed} +\begin{verbatim} CHANGED_TAC : tactic -> tactic -\end{verbatim}\end{holboxed} +\end{verbatim} +\end{holboxed} \ml{CHANGED\_TAC\ $T$\ $g$} fails if the subgoals @@ -814,11 +804,14 @@ \subsection{Change detection} denote the same set (\ie\ contain the same elements). -\begin{hol}\begin{verbatim} - letrec CHANGED_TAC tac g = - let gl,p = tac g in - if set_equal gl [g] then fail else (gl,p) -\end{verbatim}\end{hol} +\begin{hol} +\begin{verbatim} + fun CHANGED_TAC tac g = + let val (gl,p) = tac g + in + if set_eq gl [g] then fail else (gl,p) +\end{verbatim} +\end{hol} @@ -833,7 +826,7 @@ \subsection{Sequencing} \begin{holboxed} \begin{verbatim} THEN : tactic -> tactic -> tactic - >> : tactic -> tactic -> tactic + >>> : tactic -> tactic -> tactic \end{verbatim} \end{holboxed} @@ -1019,18 +1012,21 @@ \subsection{Theorem continuations with popping} is illustrated using its main tool: the tactical \ml{POP\_ASSUM}. \index{POP_ASSUM@\ml{POP\_ASSUM}|pin} -\begin{holboxed}\begin{verbatim} +\begin{holboxed} +\begin{verbatim} POP_ASSUM : (thm -> tactic) -> tactic + pop_assum : (thm -> tactic) -> tactic \end{verbatim}\end{holboxed} \noindent Given a function $f$\ml{:thm -> tactic}, the tactic -\ml{POP\_ASSUM}\ $f$ applies $f$ to the (assumed) first +\ml{pop\_assum}\ $f$ applies $f$ to the (assumed) first assumption of a goal (\ie\ to the top element of the assumption stack) and then applies the tactic created thereby to the original goal minus its top assumption: -\begin{hol}\begin{alltt} - POP_ASSUM \(f\) ([\(t\sb{1}\);\(\ldots\);\(t\sb{n}\)],\(t\)) = \(f\) (ASSUME \(t\sb{1}\)) ([\(t\sb{2}\);\(\ldots\);\(t\sb{n}\)],\(t\)) +\begin{hol} +\begin{alltt} + pop_assum \(f\) ([\(t\sb{1}\);\(\ldots\);\(t\sb{n}\)],\(t\)) = \(f\) (ASSUME \(t\sb{1}\)) ([\(t\sb{2}\);\(\ldots\);\(t\sb{n}\)],\(t\)) \end{alltt}\end{hol} \noindent \ML{} functions such as $f$, @@ -1040,11 +1036,12 @@ \subsection{Theorem continuations with popping} \index{theorem continuations} suggesting the fact that they take theorems and then continue the proof.\footnote{There is a superficial analogy with continuations in denotational semantics.} -The use of \ml{POP\_ASSUM}\ can be illustrated by applying it -to a particular tactic, namely \ml{DISCH\_TAC} (Section~\ref{sec:disch}). +The use of \ml{pop\_assum}\ can be illustrated by applying it +to a particular tactic, namely \ml{DISCH\_TAC}. \index{DISCH_TAC@\ml{DISCH\_TAC}} -\begin{holboxed}\begin{verbatim} +\begin{holboxed} +\begin{verbatim} DISCH_TAC : tactic \end{verbatim}\end{holboxed} @@ -1054,17 +1051,12 @@ \subsection{Theorem continuations with popping} suppose it were required to prove that $(n = 0) \imp (n\times n = n)$: \setcounter{sessioncount}{1} -\begin{session}\begin{verbatim} -#g "(n = 0) ==> (n * n = n)";; -"(n = 0) ==> (n * n = n)" - -() : void +\begin{session} +\begin{alltt} +>> g `(n = 0) ==> (n * n = n)`; -#e DISCH_TAC;; -OK.. -"n * n = n" - [ "n = 0" ] -\end{verbatim}\end{session} +>> e DISCH_TAC; +\end{alltt}\end{session} \noindent Application of \ml{DISCH\_TAC} to the goal produces one subgoal, as shown, with the added assumption. To engage the assumption @@ -1073,7 +1065,8 @@ \subsection{Theorem continuations with popping} \index{SUBST1_TAC@\ml{SUBST1\_TAC}|pin} -\begin{holboxed}\begin{verbatim} +\begin{holboxed} +\begin{verbatim} SUBST1_TAC : thm_tactic \end{verbatim}\end{holboxed} @@ -1084,14 +1077,12 @@ \subsection{Theorem continuations with popping} \ml{SUBST1\_TAC} to form a new tactic. The new tactic is applied to the current subgoal. -\begin{session}\begin{verbatim} -#top_goal();; -(["n = 0"], "n * n = n") : goal +\begin{session} +\begin{alltt} +>> p(); -#e(POP_ASSUM SUBST1_TAC);; -OK.. -"0 * 0 = 0" -\end{verbatim}\end{session} +>> e(pop_assum SUBST1_TAC);; +\end{alltt}\end{session} \noindent The result, as shown, is that the assumption is used as a substitution rule and then discarded. @@ -1099,66 +1090,36 @@ \subsection{Theorem continuations with popping} \index{assumptions!discarding of, in proofs} The one subgoal therefore has no assumptions on its stack. The two tactics used thus far could be combined -into one using the tactical \ml{THEN}:\index{THEN@\ml{THEN}} +into one using the tactical \ml{\gt\gt}:\index{THEN@\ml{THEN}} \setcounter{sessioncount}{1} -\begin{session}\begin{verbatim} -#g "(n = 0) ==> (n * n = n)";; -"(n = 0) ==> (n * n = 0)" - -() : void - -#e(DISCH_TAC THEN POP_ASSUM SUBST1_TAC);; -OK.. -"0 * 0 = 0" -\end{verbatim}\end{session} - -\noindent The goal can now be solved by rewriting with a fact of arithmetic: - -\begin{session}\begin{verbatim} -#e(REWRITE_TAC[MULT_CLAUSES]);; -Theorem MULT_CLAUSES autoloaded from theory `arithmetic`. -MULT_CLAUSES = -|- !m n. - (0 * m = 0) /\ - (m * 0 = 0) /\ - (1 * m = m) /\ - (m * 1 = m) /\ - ((SUC m) * n = (m * n) + n) /\ - (m * (SUC n) = m + (m * n)) - -OK.. -goal proved -|- 0 * 0 = 0 -|- (n = 0) ==> (n * n = n) -\end{verbatim}\end{session} - -\noindent A single tactic can, of course, be written to solve the goal: +\begin{session} +\begin{alltt} +>>__ drop() +>> g `(n = 0) ==> (n * n = n)`; + +>> e(DISCH_TAC >> pop_assum SUBST1_TAC);; +\end{alltt}\end{session} + +\noindent The goal can now be solved by simplification:of arithmetic: + +\begin{session} +\begin{alltt} +>> e(simp[]); +##assert can top_thm() +\end{alltt}\end{session} + +\noindent A single tactic can, of course, be written to solve the goal:\footnote{Indeed, the tactic \ml{simp[]} solves the entire goal from the outset.} \setcounter{sessioncount}{1} -\begin{session}\begin{verbatim} -#g "(n = 0) ==> (n * n = n)";; -"(n = 0) ==> (n * n = n)" - -() : void - -#e(DISCH_TAC THEN POP_ASSUM SUBST1_TAC THEN REWRITE_TAC[MULT_CLAUSES]);; -Theorem MULT_CLAUSES autoloaded from theory `arithmetic`. -MULT_CLAUSES = -|- !m n. - (0 * m = 0) /\ - (m * 0 = 0) /\ - (1 * m = m) /\ - (m * 1 = m) /\ - ((SUC m) * n = (m * n) + n) /\ - (m * (SUC n) = m + (m * n)) - -OK.. -goal proved -|- (n = 0) ==> (n * n = n) -\end{verbatim}\end{session} - -This example illustrates how the tactical \ml{POP\_ASSUM} provides +\begin{session} +\begin{alltt} +>>_ restart(); + +>> e(DISCH_TAC >> pop_assum SUBST1_TAC >> simp[]);; +\end{alltt}\end{session} + +This example illustrates how the tactical \ml{pop\_assum} provides access\index{assumptions!denoting of, in proofs} \index{denoting assumptions} to the top of the assumption `stack' (a capability that @@ -1169,24 +1130,15 @@ \subsection{Theorem continuations with popping} \index{assumptions!explicit} construct, with explicit assumptions: \setcounter{sessioncount}{1} -\begin{session}\begin{verbatim} -#g "(n = 0) ==> (n * n = n)";; -"(n = 0) ==> (n * n = n)" - -() : void - -#e(DISCH_TAC);; -OK.. -"n * n = n" - [ "n = 0" ] +\begin{session} +\begin{alltt} +>>__ drop(); +>> g `(n = 0) ==> (n * n = n)`; -() : void +>> e DISCH_TAC; -#e(SUBST1_TAC(ASSUME "n = 0"));; -OK.. -"0 * 0 = 0" - [ "n = 0" ] -\end{verbatim}\end{session} +>> e(SUBST1_TAC(ASSUME ``n = 0``)); +\end{alltt}\end{session} In contrast to the above, the popping example also illustrates the convenient disappearance of an assumption no longer required, by removing it @@ -1196,279 +1148,77 @@ \subsection{Theorem continuations with popping} is a separate issue from accessing them; there could, if one liked, be another tactical that produced a similar tactic on a theorem continuation -to \ml{POP\_ASSUM} but which did not pop the +to \ml{pop\_assum} but which did not pop the stack. -Finally, \ml{POP\_ASSUM} $f$ induces case splits where $f$ does. To prove -$(n=0 \disj n=1) \imp (n\times n = n)$, the function \ml{DISJ\_CASES\_TAC} -can be used. The tactic +Finally, \ml{pop\_assum} $f$ induces case splits where $f$ does. +To prove $(n=0 \disj n=1) \imp (n\times n = n)$, the function \ml{DISJ\_CASES\_TAC} can be used. +The tactic \ \ \ml{DISJ\_CASES\_TAC\ |- $p$}{\small\verb% \/ %}\ml{$q$} \noindent splits a goal into two subgoals that have $p$ and $q$, respectively, as new assumptions. - +Simply using \ml{DISCH\_TAC} does not cause the disjunction to split when it becomes an assumption. \setcounter{sessioncount}{1} \begin{session} \begin{alltt} -> g `((n = 0) \/ (n = 1)) ==> (n * n = n)`; - Initial goal: - - (n = 0) \(\lor\) (n = 1) \(\Rightarrow\) (n * n = n) - -> e DISCH_TAC; -OK.. -1 subgoal: -val it = +>>__ drop() +>> g `((n = 0) \/ (n = 1)) ==> (n * n = n)`; -n * n = n ------------------------------------- - (n = 0) \(\lor\) (n = 1) - -> b(); -val it = - Initial goal: - - -(n = 0) \(\lor\) (n = 1) \(\Rightarrow\) (n * n = n) +>> e DISCH_TAC; \end{alltt} \end{session} \begin{session} \begin{alltt} -> e(DISCH_TAC THEN POP_ASSUM DISJ_CASES_TAC); -OK.. -2 subgoals: -val it = - -n * n = n ------------------------------------- - n = 1 +>>_ restart(); +>> e(DISCH_TAC >> pop_assum DISJ_CASES_TAC); -n * n = n ------------------------------------- - n = 0 - -> b(); -val it = - Initial goal: - - -(n = 0) \(\lor\) (n = 1) \(\Rightarrow\) (n * n = n) - -> e(DISCH_TAC THEN POP_ASSUM DISJ_CASES_TAC THEN POP_ASSUM SUBST1_TAC);; -OK.. -2 subgoals: -val it = -1 * 1 = 1 - - -0 * 0 = 0 +>>_ restart(); +>> e(DISCH_TAC >> pop_assum DISJ_CASES_TAC >> pop_assum SUBST1_TAC); \end{alltt} \end{session} -As noted earlier, \ml{POP\_ASSUM} is useful when an assumption +As noted earlier, \ml{pop\_assum} is useful when an assumption is required that is still at the top of the stack, as in the examples. However, it is often necessary to access assumptions made at arbitrary previous times, in order to -give them as parameters, combine them, etc. The stack approach can be -extended to such cases by re-conceiving the stack as an array\index{assumptions!as array}\index{array, of assumptions}, and by -use of the tactical \ml{ASSUM\_LIST}:\index{ASSUM_LIST@\ml{ASSUM\_LIST}|(} - -\begin{hol}\begin{verbatim} - ASSUM_LIST : (thm list -> tactic) -> tactic -\end{verbatim}\end{hol} - -\noindent where +give them as parameters, combine them, etc. -\begin{hol}\begin{alltt} - ASSUM_LIST \m{f} ([\m{t\sb{1}};...;\m{t\sb{n}}],\m{t}) = \m{f}([ASSUME \m{t\sb{1}};...;ASSUME \m{t\sb{n}}]) -\end{alltt}\end{hol} - -\noindent That is, given a function $f$, \ml{ASSUM\_LIST}$\ f$ forms a new tactic -by applying $f$ to the list of (assumed) assumptions of a goal, then applies -the resulting tactic to the goal. For example, a tactic of the form -{\small\verb%ASSUM_LIST (\thl.%}$\ f\ $\ml{(el\ $i$\ thl))} applies the -function $f$ to the $i$th assumption of a goal to produce a new tactic, then -applies the new tactic to the goal. -Again, \ml{ASSUM\_LIST REWRITE\_TAC} is a tactic that engages all of the -current assumptions as rewrite rules. -In this way, the array approach -enables arbitrary assumptions to be accessed; and in particular, -specific assumptions to be accessed by location using the function \ml{el}. - -To illustrate the use of \ml{ASSUM\_LIST}, suppose it were required to prove -something different: \index{ASSUM_LIST@\ml{ASSUM\_LIST}|)} -that $(\forall m.\ m + n = m) \imp (n \times n = n)$. Suppose -also that the arithmetic fact \ml{ADD\_INV\_{0}} is already known: namely, that -$\forall m\ n.\ (m + n = m) \imp (n = 0)$. After discharging the assumption, -the conclusion of the theorem \ml{ADD\_INV\_{0}} is imported as an -assumption, occupying first place in the array. - -\setcounter{sessioncount}{1} -\begin{session}\begin{verbatim} -#g "(!m. m + n = m) ==> (n * n = n)";; -"(!m. m + n = m) ==> (n * n = n)" - -() : void - -#e(DISCH_TAC);; -OK.. -"n * n = n" - [ "!m. m + n = m" ] - -() : void - -#e(ASSUME_TAC ADD_INV_0);; -Theorem ADD_INV_0 autoloaded from theory `arithmetic`. -ADD_INV_0 = |- !m n. (m + n = m) ==> (n = 0) - -OK.. -"n * n = n" - [ "!m. m + n = m" ] - [ "!m n. (m + n = m) ==> (n = 0)" ] -\end{verbatim}\end{session} - -\noindent The problem is now to combine the two assumptions to produce the -obvious conclusion. That requires denoting -\index{denoting assumptions}% -\index{assumptions!denoting of, in proofs}% -them, for which \ml{ASSUM\_LIST} -provides the means. Finally, -\ml{ASSUME\_TAC} places the conclusion of the new result in the assumptions. -(The \ML{} function \ml{el:\ int -> * list -> *} is used here to select a -numbered element of a list.) - -\begin{session}\begin{verbatim} -#e(ASSUM_LIST(\thl. ASSUME_TAC - (MP (SPECL ["m:num";"n:num"] (el 1 thl)) - (SPEC "m:num" (el 2 thl)))));; -##OK.. -"n * n = n" - [ "!m. m + n = m" ] - [ "!m n. (m + n = m) ==> (n = 0)" ] - [ "n = 0" ] -\end{verbatim}\end{session} - -\noindent The goal can now be solved as in the previous example. - -To access the -two particular assumptions in the straightforward way would again require quoting -their text. To access all of them (to pass to \ml{REWRITE\_TAC}, for -instance) would require quoting all of them. - -\ml{ASSUM\_LIST} addresses the issue of accessing assumptions, -but not the issue of discarding them. A related function generalizes -\ml{POP\_ASSUM} to discard them as well: - -\begin{hol}\begin{verbatim} - POP_ASSUM_LIST : (thm list -> tactic ) -> tactic -\end{verbatim}\end{hol} - -\noindent \ml{POP\_ASSUM\_LIST} -\index{POP_ASSUM_LIST@\ml{POP\_ASSUM\_LIST}} -resembles \ml{ASSUM\_LIST} except in removing -all of the old assumptions of the subgoal, the way that \ml{POP\_ASSUM} -removes the most recent. (Thus \ml{POP\_ASSUM} is no more than a special case -of \ml{POP\_ASSUM\_LIST} that selects the first element of those supplied -and re-assumes the others.) - -\begin{hol}\begin{alltt} - POP_ASSUM_LIST \(f\) ([\(t\sb{1}\);\(\ \ldots\ \);\(t\sb{n}\)],\(t\)) = \(f\) [ASSUME \(t\sb{1}\);\(\ \ldots\ \);ASSUME \(t\sb{n}\)] ([],t) -\end{alltt}\end{hol} - -\noindent This is used when the existing assumptions have served -their purpose and can be discarded, as in the current example: - -\begin{session}\begin{verbatim} -#backup();; -"n * n = n" - [ "!m. m + n = m" ] - [ "!m n. (m + n = m) ==> (n = 0)" ] - -() : void - -#e(POP_ASSUM_LIST(\thl. ASSUME_TAC - (MP (SPECL ["m:num";"n:num"] (el 1 thl)) - (SPEC "m:num" (el 2 thl)))));; -##OK.. -"n * n = n" - [ "n = 0" ] -\end{verbatim}\end{session} - -\noindent This leaves only the one assumption vital to solving the goal, -as before. In some contexts, the new result is required as an assumption, -but here it can be used immediately: - -\begin{session}\begin{verbatim} -#backup();; -"n * n = n" - [ "!m. m + n = m" ] - [ "!m n. (m + n = m) ==> (n = 0)" ] - -() : void - -#e(POP_ASSUM_LIST(\thl. SUBST1_TAC - (MP (SPECL ["m:num";"n:num"] (el 1 thl)) - (SPEC "m:num" (el 2 thl)))));; -##OK.. -"0 * 0 = 0" -\end{verbatim}\end{session} - -\noindent \ml{POP\_ASSUM\_LIST} can, of course, -take any function of appropriate -type, but is in fact often used in conjunction with the element-selecting -functions. Function composition occasionally allows a more -compact expression to be written. - -The array view (of which the stack view is a special case) -gives a way in which unnecessary assumptions can -be dropped, and assumptions can be accessed, individually if necessary, -using tacticals. -Although this approach can be effective, as illustrated, it does -tend to rely on the ordering of the representation of the assumption -\index{assumptions!importance of ordering of} set. -(That is, \ml{POP\_ASSUM} necessarily does, while the other two provide the -temptation!) A minor drawback of this reliance is that tactics are then -sensitive to changes that alter the order or composition of the assumptions; -for example, changes in the implementation of \HOL, modifications of -existing tactics, and so on. -However, that sensitivity is not so serious in any one incarnation of \HOL; -there is a logical viewpoint that regards the assumptions (sequents) as -ordered anyway. -A more serious problem is that order-sensitive tactics are meaningful -only during interactive sessions; to reconstruct the assumptions from -the \ML{} text and the original goal alone is generally difficult, -and more so when assumptions are denoted by location. -This means that (i) the resulting tactics cannot easily be generalized -for use in other contexts, and (ii) the \ML{} text does not supply -useful documentation -\index{tactics!as documentation of proofs} of the solution of the goal. -Also, as shown in the last example, it is slightly unsatisfactory -to push and subsequently pop assumptions, especially in immediate succession, -where this could be avoided. - -Two other tacticals that can be used to manipulate the assumption list are -\ml{FIRST\_ASSUM} and \ml{EVERY\_ASSUM}. -These are characterized by: +Two other useful tacticals that can be used to manipulate the assumption list are +\ml{first\_assum} and \ml{qpat_assum}. +The first has an easy characterisation: \index{FIRST_ASSUM@\ml{FIRST\_ASSUM}} -\index{EVERY_ASSUM@\ml{EVERY\_ASSUM}} \begin{hol} \begin{alltt} - FIRST_ASSUM \(f\) ([\(t\sb{1}\), \(\ldots\) ,\(t\sb{n}\)], \(t\)) = + first_assum \(f\) ([\(t\sb{1}\), \(\ldots\) ,\(t\sb{n}\)], \(t\)) = (\(f\)(ASSUME \(t\sb{1}\)) ORELSE \(\ldots\) ORELSE \(f\)(ASSUME \(t\sb{n}\))) ([\(t\sb{1}\), \(\ldots\) ,\(t\sb{n}\)], \(t\)) +\end{alltt} +\end{hol} - EVERY_ASSUM \(f\) ([\(t\sb{1}\), \(\ldots\) ,\(t\sb{n}\)], \(t\)) = - (\(f\)(ASSUME \(t\sb{1}\)) THEN \(\ldots\) THEN \(f\)(ASSUME \(t\sb{n}\))) ([\(t\sb{1}\), \(\ldots\) ,\(t\sb{n}\)], \(t\)) +The \index{FIRST_X_ASSUM@\ml{FIRST\_X\_ASSUM}}\ml{first\_x\_assum} tactical is similar to \ml{first\_assum}, but in addition to assuming one of the goal's assumptions as a theorem and passing this to the function $f$, the goal-state that $f\,(t_i\vdash t_i)$ acts upon has had $t_i$ removed from the assumption list. +It is a ``popping'' version of \ml{first\_assum}. + +\index{qpat_assum@\ml{qpat\_assum}} +The \ml{qpat\_assum} tactical takes a pattern-quotation as its first argument. +The second \ml{thm\_tactic} parameter is then passed the first assumption that matches this pattern. +This tactical is also a ``popping'' manipulator of the assumptions, so the matching assumption is not present when the theorem-tactic is applied to the goal. + +Thus: +\begin{hol} +\begin{alltt} + qpat_assum pat \(f\) ([\(t\sb{1}\), \(\ldots\) ,\(t\sb{p}\), \(\ldots\) ,\(t\sb{n}\)], \(t\)) = + f (ASSUME \(t\sb{p}\)) ([\(t\sb{1}\), \(\ldots\) ,\(t\sb{p-1}\),\(t\sb{p+1}\), \(\ldots\) ,\(t\sb{n}\)], \(t\)) \end{alltt} \end{hol} +where $t_p$ is the first assumption that matches the pattern \ml{pat}. -Both of these tactics leave the terms that are assumed (the various $t_i$) in the goal's assumption list. -The \index{FIRST_X_ASSUM@\ml{FIRST\_X\_ASSUM}}\ml{FIRST\_X\_ASSUM} tactical is similar to \ml{FIRST\_ASSUM}, but in addition to assuming one of the goal's assumptions as a theorem and passing this to the function $f$, the goal-state that $f\,(t_i\vdash t_i)$ acts upon has had $t_i$ removed from the assumption list. +While \ml{first\_assum} (and \ml{first\_x\_assum}) try to apply their theorem-tactic to every assumption, eventually using the first that succeeds, \ml{qpat\_assum} only applies its theorem-tactic to one assumption (the first that matches). \subsection{Theorem continuations without popping} @@ -1477,30 +1227,22 @@ \subsection{Theorem continuations without popping} The idea of the second approach is suggested by the way the array-style tacticals\index{tacticals!purpose of} supply a list of theorems (the assumed assumptions) to a function. These tacticals use the function to infer new results from the list of theorems, and then to do something with the results. In some cases, \eg\ the last example, the assumptions need never have been made in the first place, which suggests a different use of tacticals. -The original example for \ml{POP\_ASSUM} illustrates this: namely, to show that $(n = 0) \imp (n\times n = n)$. -Here, instead of discharging the antecedent by applying \ml{DISCH\_TAC} to the goal, which adds the antecedent as an assumption and returns the consequent as the conclusion, and {\it then\/} supplying the (assumed) added assumption to the theorem continuation \ml{SUBST1\_TAC} and discarding it at the same time, a tactical called \ml{DISCH\_THEN} is applied to \ml{SUBST1\_TAC} directly. -\ml{DISCH\_THEN} transforms \ml{SUBST1\_TAC} into a new tactic: one that applies \ml{SUBST1\_TAC} directly to the (assumed) antecedent, and the resulting tactic to a subgoal with no new assumptions and the consequent as its conclusion: +The original example for \ml{pop\_assum} illustrates this: namely, to show that $(n = 0) \imp (n\times n = n)$. +Here, instead of discharging the antecedent by applying \ml{DISCH\_TAC} to the goal, which adds the antecedent as an assumption and returns the consequent as the conclusion, and {\it then\/} supplying the (assumed) added assumption to the theorem continuation \ml{SUBST1\_TAC} and discarding it at the same time, a tactical called \ml{disch\_then} is applied to \ml{SUBST1\_TAC} directly. +\ml{disch\_then} transforms \ml{SUBST1\_TAC} into a new tactic: one that applies \ml{SUBST1\_TAC} directly to the (assumed) antecedent, and the resulting tactic to a subgoal with no new assumptions and the consequent as its conclusion: \setcounter{sessioncount}{1} \begin{session} -\begin{verbatim} -> DISCH_THEN; -val it = fn : (thm_tactic -> tactic) - -> DISCH_THEN SUBST1_TAC; -val it = fn : tactic +\begin{alltt} +>>__ drop(); +>> disch_then; -> g `(n = 0) ==> (n * n = n)`; - Initial goal: +>> disch_then SUBST1_TAC; - (n = 0) \(\Rightarrow\) (n * n = n) +>> g `(n = 0) ==> (n * n = n)`; -> e(DISCH_THEN SUBST1_TAC); -OK.. -1 subgoal: -val it = -0 * 0 = 0 -\end{verbatim} +>> e(disch_then SUBST1_TAC); +\end{alltt} \end{session} \noindent This gives the same result as the stack method, but more @@ -1520,20 +1262,13 @@ \subsection{Theorem continuations without popping} \setcounter{sessioncount}{1} \begin{session} \begin{alltt} -> g `(0 = n) ==> (n * n = n)`; - Initial goal: - - (0 = n) \(\Rightarrow\) (n * n = n) - -> e(DISCH_THEN(SUBST1_TAC o SYM)); -OK.. -1 subgoal: -val it = -0 * 0 = 0 +>>__ drop(); +>> g `(0 = n) ==> (n * n = n)`; +>> e(disch_then(SUBST1_TAC o SYM)); \end{alltt} \end{session} -The justification of \ml{DISCH\_THEN SUBST1\_TAC} is easily constructed +The justification of \ml{disch\_then SUBST1\_TAC} is easily constructed from the justification of \ml{DISCH\_TAC} composed with the justification of \ml{SUBST1\_TAC}. \index{assumptions!internal|(} The term $n=0$ is assumed, to yield the @@ -1541,7 +1276,7 @@ \subsection{Theorem continuations without popping} and it is accordingly discharged during the construction of the actual proof; but the assumption happens only internally -\index{assumptions!internal|)} to the tactic \ml{DISCH\_THEN SUBST1\_TAC}, and not +\index{assumptions!internal|)} to the tactic \ml{disch\_then SUBST1\_TAC}, and not as a step in the tactical proof. In other words, the subgoal tree here has one node fewer than before, when an explicit step (\ml{DISCH\_TAC}) reflected the assumption. @@ -1552,23 +1287,10 @@ \subsection{Theorem continuations without popping} \setcounter{sessioncount}{1} \begin{session} \begin{alltt} -> g `((n = 0) \/ (n = 1)) ==> (n * n = n)`; - Initial goal: - - (n = 0) \(\lor\) (n = 1) \(\Rightarrow\) (n * n = n) - -> e(DISCH_THEN(DISJ_CASES_THEN SUBST1_TAC)); -OK.. -2 subgoals: -val it = -1 * 1 = 1 - - - -0 * 0 = 0 +>>__ drop(); +>> g `((n = 0) \/ (n = 1)) ==> (n * n = n)`; - -2 subgoals +>> e(disch_then(DISJ_CASES_THEN SUBST1_TAC)); \end{alltt} \end{session} @@ -1579,9 +1301,9 @@ \subsection{Theorem continuations without popping} \begin{hol} \begin{verbatim} DISCH_TAC - THEN DISJ_CASES_TAC(ASSUME ``(n = 0) \/ (n = 1)``) - THENL[SUBST1_TAC(ASSUME ``n = 0``); - SUBST1_TAC(ASSUME ``n = 1``)] + >>> DISJ_CASES_TAC(ASSUME ``(n = 0) \/ (n = 1)``) + >| [SUBST1_TAC(ASSUME ``n = 0``); + SUBST1_TAC(ASSUME ``n = 1``)] \end{verbatim} \end{hol} @@ -1593,29 +1315,22 @@ \subsection{Theorem continuations without popping} \index{assumptions!compared methods of handling} on the goal $(n=0) \imp (n \times n = n)$: -\begin{hol}\index{ASSUM_LIST@\ml{ASSUM\_LIST}} +\begin{hol} \begin{verbatim} DISCH_TAC - THEN SUBST1_TAC(ASSUME ``n = 0``) - THEN REWRITE_TAC[MULT_CLAUSES] - - DISCH_TAC - THEN POP_ASSUM SUBST1_TAC - THEN REWRITE_TAC[MULT_CLAUSES] + >>> SUBST1_TAC(ASSUME ``n = 0``) + >>> simp[] DISCH_TAC - THEN ASSUM_LIST (SUBST1_TAC o el 1) - THEN REWRITE_TAC[MULT_CLAUSES] + >>> pop_assum SUBST1_TAC + >>> simp[] - DISCH_TAC - THEN POP_ASSUM_LIST (SUBST1_TAC o el 1) - THEN REWRITE_TAC[MULT_CLAUSES] - - DISCH_THEN SUBST1_TAC - THEN REWRITE_TAC[MULT_CLAUSES] -\end{verbatim}\end{hol} + disch_then SUBST1_TAC + >>> simp[] +\end{verbatim} +\end{hol} -\noindent Furthermore, all five induce the +\noindent Furthermore, all induce the same sequence of inferences leading to the desired theorem; internally, no inference steps are saved by the economies in the \ML{} text or the subgoal tree. In this sense, @@ -1631,8 +1346,8 @@ \subsection{Theorem continuations without popping} illustrates both the elegance and the inscrutibility of using functions to manipulate intermediate results directly, rather than as assumptions. -The middle three expressions -show how results can be used as assumptions (discarded when +The middle expression +shows how results can be used as assumptions (discarded when redundant, if desired); and how assumptions can be denoted without recourse to their text. @@ -1640,7 +1355,7 @@ \subsection{Theorem continuations without popping} It is a strength of the \LCF\ approach \index{LCF@\LCF} to theorem proving that many different proof styles are supported, (all in a secure way) and indeed, can be studied in their own right. \HOL{} provides several other theorem continuation functions analogous to -\ml{DISCH\_THEN} and \ml{DISJ\_CASES\_THEN}. +\ml{disch\_then} and \ml{DISJ\_CASES\_THEN}. (Their names always end with `\ml{\_THEN}', `\ml{\_THENL} or `\ml{\_THEN2}'.) Some of these do convenient inferences for the user. From be2fde3d1563ceebae432a31814b7ed28349fecd Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 4 Feb 2016 11:49:11 +1100 Subject: [PATCH 684/718] Adjust theories chapter of Description --- Manual/Description/.gitignore | 1 + Manual/Description/Holmakefile | 12 +- Manual/Description/Makefile | 64 -------- .../{theories.tex => theories.stex} | 149 +++++++----------- 4 files changed, 68 insertions(+), 158 deletions(-) delete mode 100644 Manual/Description/Makefile rename Manual/Description/{theories.tex => theories.stex} (98%) diff --git a/Manual/Description/.gitignore b/Manual/Description/.gitignore index e443dde1cf..aeadcca6ff 100644 --- a/Manual/Description/.gitignore +++ b/Manual/Description/.gitignore @@ -1,2 +1,3 @@ drules.tex tactics.tex +theories.tex diff --git a/Manual/Description/Holmakefile b/Manual/Description/Holmakefile index 30d30e9df5..248217b68a 100644 --- a/Manual/Description/Holmakefile +++ b/Manual/Description/Holmakefile @@ -1,4 +1,6 @@ -TEX_SOURCES = description.tex ../LaTeX/ack.tex title.tex preface.tex ../LaTeX/commands.tex system.tex drules.tex tactics.tex theories.tex definitions.tex libraries.tex misc.tex +TEX_CORES = description title preface system drules tactics theories definitions libraries misc + +TEX_SOURCES = ../LaTeX/ack.tex ../LaTeX/commands.tex $(patsubst %,%.tex,$(TEX_CORES)) PS_STUFF = ../Tools/polyscripter ../Tools/umap PS_COMMAND = $(PS_STUFF) < $< > $@ @@ -11,3 +13,11 @@ drules.tex: drules.stex $(PS_STUFF) tactics.tex: tactics.stex $(PS_STUFF) $(PS_COMMAND) + +theories.tex: theories.stex $(PS_STUFF) + $(PS_COMMAND) + +EXTRA_CLEANS = drules.tex tactics.tex theories.tex description.pdf \ + $(patsubst %,%.aux,$(TEX_CORES)) description.log description.out \ + description.toc description.fls description.idx description.ilg \ + description.ind description.blg description.bbl description.fdb_latexmk diff --git a/Manual/Description/Makefile b/Manual/Description/Makefile deleted file mode 100644 index 3c7175bf69..0000000000 --- a/Manual/Description/Makefile +++ /dev/null @@ -1,64 +0,0 @@ -# ===================================================================== -# Makefile for the HOL DESCRIPTION -# ===================================================================== - -PDFLATEX=pdflatex -DVILATEX=latex -MAKEINDEX=makeindex -BIBTEX=bibtex - -CHAPTERS = conv.tex drules.tex HolQbf.tex HolSat.tex HolSmt.tex \ - libraries.tex misc.tex preface.tex QuantHeuristics.tex \ - tactics.tex theories.tex title.tex system.tex definitions.tex \ - enumfset.tex -OTHER = ../LaTeX/commands.tex ../LaTeX/layout.sty ../LaTeX/ack.tex - -default: pdf -pdf: description.pdf HolBdd.pdf holCheck.pdf - -clean: - rm -f *.dvi *.aux *.toc *.log *.idx *.ilg *.ind description.pdf \ - *.bbl *.blg *.out HolBdd.pdf holCheck.pdf - -description.pdf: description.tex $(CHAPTERS) $(OTHER) - ${PDFLATEX} description - ${BIBTEX} description - ${PDFLATEX} description - ${MAKEINDEX} description - ${PDFLATEX} description - ${PDFLATEX} description - -HolBdd.pdf: HolBdd.tex - ${PDFLATEX} HolBdd - ${BIBTEX} HolBdd - ${PDFLATEX} HolBdd - ${PDFLATEX} HolBdd - -holCheck.pdf: holCheck.tex - ${PDFLATEX} holCheck - ${PDFLATEX} holCheck - -description.dvi: description.tex $(CHAPTERS) $(OTHER) - ${DVILATEX} description - ${MAKEINDEX} description - ${BIBTEX} description - ${DVILATEX} description - ${DVILATEX} description - -description.ps: description.dvi - dvips -Ppdf -G0 -f description.dvi > description.ps.tmp - mv description.ps.tmp $@ - -HolBdd.ps: HolBdd.tex - ${DVILATEX} HolBdd - ${BIBTEX} HolBdd - ${DVILATEX} HolBdd - ${DVILATEX} HolBdd - dvips -Ppdf -G0 -f HolBdd.dvi > HolBdd.ps.tmp - mv HolBdd.ps.tmp $@ - -holCheck.ps: holCheck.tex - ${DVILATEX} holCheck - ${DVILATEX} holCheck - dvips -Ppdf -G0 -f holCheck.dvi > holCheck.ps.tmp - mv holCheck.ps.tmp $@ diff --git a/Manual/Description/theories.tex b/Manual/Description/theories.stex similarity index 98% rename from Manual/Description/theories.tex rename to Manual/Description/theories.stex index b9dcabd3d1..3e9c38265d 100644 --- a/Manual/Description/theories.tex +++ b/Manual/Description/theories.stex @@ -1007,19 +1007,13 @@ \subsubsection{Paired abstractions} position of a lambda abstraction fails: \begin{session} -\begin{verbatim} -- ``\(x,y).x+y``; -> val it = `\(x,y). x + y` : term - -- val p = Term `(x:num,y:num)`; -> val p = `(x,y)` : term +\begin{alltt} +>> ``\(x,y).x+y``; -- Lib.try Term `\^p.x+y`; +>> val p = Term `(x:num,y:num)`; -Exception raised at Term.dest_var: -not a var -! Uncaught exception: -\end{verbatim} +>>+ Lib.try Term `\^p.x+y` handle _ => T +\end{alltt} \end{session} If $b$ is a binder, then \ml{$b$($x_1$,$x_2$).$t$} is parsed as \ml{$b$(\bs($x_1$,$x_2$).$t$)}, and hence transformed as above. For @@ -1090,19 +1084,15 @@ \subsubsection{\texttt{let}-terms} destructor operations. For example: \begin{session} -\begin{verbatim} -- Term `let x = 1 and y = 2 in x+y`; -> val it = `let x = 1 and y = 2 in x + y` : term +\begin{alltt} +>> Term `let x = 1 and y = 2 in x+y`; -- dest_comb it; -> val it = (`LET (LET (\x y. x + y) 1)`, `2`) : term * term +>> dest_comb it; -- Term `let (x,y) = (1,2) in x+y`; -> val it = `let (x,y) = (1,2) in x + y` : Term.term +>> Term `let (x,y) = (1,2) in x+y`; -- dest_comb it; -> val it = (`LET (\(x,y). x + y)`, `(1,2)`) : Term.term * Term.term -\end{verbatim} +>> dest_comb it; +\end{alltt} \end{session} Readers are encouraged to convince themselves that the translations of @@ -1785,16 +1775,13 @@ \subsection{Numerals}\label{sec:numerals} theory; these are mechanized by the \verb+reduce+ library. Thus, arithmetic calculations are performed by deductive steps in \HOL. For example the following calculation of $2 ^{(1023 + 14)/9}$ takes -approximately 4,200 primitive inference steps and returns in 30 -milli-seconds. +approximately 4,200 primitive inference steps and returns quickly: % \setcounter{sessioncount}{0} \begin{session} -\begin{verbatim} -- reduceLib.REDUCE_CONV ``2 EXP ((1023 + 14) DIV 9)``; - -> val it = |- 2 ** ((1023 + 14) DIV 9) = 41538374868278621028243970633760768 -\end{verbatim} +\begin{alltt} +>> Count.apply reduceLib.REDUCE_CONV ``2 EXP ((1023 + 14) DIV 9)``; +\end{alltt} \end{session} \paragraph {Construction of numerals} @@ -1813,17 +1800,14 @@ \subsection{Numerals}\label{sec:numerals} \verb|*|, \verb|-|, \etc \begin{session} -\begin{verbatim} -- numSyntax.mk_numeral +\begin{alltt} +>> numSyntax.mk_numeral (Arbnum.fromString "3432432423423423234"); -> val it = ``3432432423423423234`` : term -- numSyntax.dest_numeral it; -> val it = 3432432423423423234 : num +>> numSyntax.dest_numeral it; -- Arbnum.+(it,it); -> val it = 6864864846846846468 : num -\end{verbatim} +>> Arbnum.+(it,it); +\end{alltt} \end{session} \paragraph{Numerals and the parser} @@ -1849,19 +1833,15 @@ \subsection{Numerals}\label{sec:numerals} Thus \begin{session} -\begin{verbatim} -- ``0xAA``; -> val it = ``170`` : term +\begin{alltt} +>> ``0xAA``; -- ``0b1010_1011``; -> val it = ``171`` : term +>> ``0b1010_1011``; -- base_tokens.allow_octal_input := true; -> val it = () : unit +>> base_tokens.allow_octal_input := true; -- ``067``; -> val it = ``55`` : term -\end{verbatim} +>> ``067``; +\end{alltt} \end{session} \paragraph{Numerals and Peano numbers} @@ -1881,15 +1861,12 @@ \subsection{Numerals}\label{sec:numerals} equation for any non-zero numeral. For example: \begin{session} -\begin{verbatim} -- load "numLib"; open numLib; - -- num_CONV ``2``; -> val it = |- 2 = SUC 1 : thm +\begin{alltt} +>>_ open numLib; +>> num_CONV ``2``; -- num_CONV ``3141592653``; -> val it = |- 3141592653 = SUC 3141592652 : thm -\end{verbatim} +>> num_CONV ``3141592653``; +\end{alltt} \end{session} \noindent The \ml{num\_CONV} function works purely by inference. @@ -1906,30 +1883,24 @@ \subsubsection{Overloading of arithmetic operators} numeral \verb+2+ is taken to be an integer. % \begin{session} -\begin{verbatim} -- load "integerTheory"; -> val it = () : unit +\begin{alltt} +>> load "integerTheory"; -- ``2``; -<> -> val it = `2` : term +>> ``2``; -- type_of it; -> val it = `:int` : hol_type -\end{verbatim} +>> type_of it; +\end{alltt} \end{session} In order to precisely specify the desired type, the user can use single character suffixes (`\ml{n}' for the natural numbers, and `\ml{i}' for the integers): \begin{session} -\begin{verbatim} -- type_of ``2n``; -> val it = `:num` : hol_type +\begin{alltt} +>> type_of ``2n``; -- type_of ``42i``; -> val it = `:int` : hol_type -\end{verbatim} +>> type_of ``42i``; +\end{alltt} \end{session} A numeric literal for a \HOL{} type other than \verb+num+, such as @@ -1980,17 +1951,13 @@ \subsection{Integers} \setcounter{sessioncount}{0} \begin{session} -\begin{verbatim} -Term `1i = &(1n + 0n)`; -> val it = `1 = & (1 + 0)` : term +\begin{alltt} +>> Term `1i = &(1n + 0n)`; -- show_numeral_types := true; -> val it = () : unit +>> show_numeral_types := true; -- Term `&1 = &(1n + 0n)`; -<> -> val it = `1i = & (1n + 0n)` : Term.term -\end{verbatim} +>> Term `&1 = &(1n + 0n)`; +\end{alltt} \end{session} @@ -3317,14 +3284,12 @@ \subsection{Character strings (\theoryimp{string})} Thus: \setcounter{sessioncount}{0} \begin{session} -\begin{verbatim} -- val t = ``f #"c" #"\n"``; -<> -> val t = ``f #"c" #"\n"`` : term +\begin{alltt} +>> load "stringTheory"; +>> val t = ``f #"c" #"\n"``; -- dest_term ``#"\t"``; -> val it = COMB(``CHR``, ``9``) : lambda -\end{verbatim} +>> dest_term ``#"\t"``; +\end{alltt} \end{session} @@ -3361,10 +3326,9 @@ \subsection{Character strings (\theoryimp{string})} \] Of course, one could also write \begin{session} -\begin{verbatim} -- ``[#"a"; #"b"]``; -> val it = ``"ab"`` : term -\end{verbatim} +\begin{alltt} +>> ``[#"a"; #"b"]``; +\end{alltt} \end{session} String literals can be constructed using the various special escape @@ -3372,10 +3336,9 @@ \subsection{Character strings (\theoryimp{string})} newline character, and a backslash followed by three decimal digits for characters of the given number. \begin{session} -\begin{verbatim} -- val t = ``"foo bar\n\001"``; -> val t = ``"foo bar\n\^A"`` : term -\end{verbatim} +\begin{alltt} +>> val t = ``"foo bar\n\001"``; +\end{alltt} \end{session} Note that if one wants to use the control-character syntax with the caret that the pretty-printer has chosen to use in printing the given From ec38806eaa2eab3ab367004c269daea320221ef7 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 4 Feb 2016 11:49:22 +1100 Subject: [PATCH 685/718] Handle brace characters in polyscripter's umap --- Manual/Tools/umap | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Manual/Tools/umap b/Manual/Tools/umap index 8a7863fe46..2172b721c8 100644 --- a/Manual/Tools/umap +++ b/Manual/Tools/umap @@ -17,3 +17,5 @@ ∩ \(\cap\) ⋲ <: − \({-}\) +{ \{ +} \} From b232d07814836f45d9e548811a4b86faefe84197 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 5 Feb 2016 09:21:43 +1100 Subject: [PATCH 686/718] Font tweaks in Absyn parsing part of DESCRIPTION --- Manual/Description/libraries.tex | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/Manual/Description/libraries.tex b/Manual/Description/libraries.tex index 946ed82cfe..ac979c065f 100644 --- a/Manual/Description/libraries.tex +++ b/Manual/Description/libraries.tex @@ -461,16 +461,16 @@ \subsubsection{Syntactic patterns (``macros'')} form $\lambda x.\;M$), then the parser will perform all possible $\beta$-reductions for that term and the arguments accompanying it. For example, in \theoryimp{boolTheory} and its descendants, the string -\ml{"<>"} is overloaded to the term \holquote{\bs{}x~y.~\td{}(x~=~y)}. +\ml{"<>"} is overloaded to the term \holquote{\holtxt{\bs{}x~y.~\td{}(x~=~y)}}. Additionally, \ml{"<>"} is set up at the concrete syntax level as an -infix. When the user inputs \holquote{x~\lt\gt~y}, the resulting +infix. When the user inputs \holquote{\holtxt{x~\lt\gt~y}}, the resulting \ml{Absyn} value is \begin{verbatim} APP(APP(IDENT "<>", IDENT "x"), IDENT "x") \end{verbatim} The \ml{"x"} and \ml{"y"} identifiers will map to free variables, but the \ml{"<>"} identifier maps to a list containing -\holquote{\bs{}x~y.~\td(x~=~y)}. This term has type +\holquote{\holtxt{\bs{}x~y.~\td(x~=~y)}}. This term has type \begin{verbatim} :'a -> 'a -> bool \end{verbatim} @@ -480,7 +480,7 @@ \subsubsection{Syntactic patterns (``macros'')} after type inference, then the resulting term will be \holtxt{\td(x~=~y)}. Better, though this will be the underlying structure of the term in memory, it will actually print as -\holquote{x~\lt\gt~y}. +\holquote{\holtxt{x~\lt\gt~y}}. If the term mapped to in the overload map contains any free variables, these variables will not be instantiated in any way. In particular, From 987cf361a7ffd4501b8358e68db5849fe8fb1be0 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 5 Feb 2016 12:39:42 +1100 Subject: [PATCH 687/718] Make libraries chapter of DESC use polyscripter --- Manual/Description/.gitignore | 1 + Manual/Description/Holmakefile | 5 ++++- Manual/Description/{libraries.tex => libraries.stex} | 0 3 files changed, 5 insertions(+), 1 deletion(-) rename Manual/Description/{libraries.tex => libraries.stex} (100%) diff --git a/Manual/Description/.gitignore b/Manual/Description/.gitignore index aeadcca6ff..d7375595b1 100644 --- a/Manual/Description/.gitignore +++ b/Manual/Description/.gitignore @@ -1,3 +1,4 @@ drules.tex tactics.tex theories.tex +libraries.tex diff --git a/Manual/Description/Holmakefile b/Manual/Description/Holmakefile index 248217b68a..57df6a927d 100644 --- a/Manual/Description/Holmakefile +++ b/Manual/Description/Holmakefile @@ -17,7 +17,10 @@ tactics.tex: tactics.stex $(PS_STUFF) theories.tex: theories.stex $(PS_STUFF) $(PS_COMMAND) -EXTRA_CLEANS = drules.tex tactics.tex theories.tex description.pdf \ +libraries.tex: libraries.stex $(PS_STUFF) + $(PS_COMMAND) + +EXTRA_CLEANS = drules.tex tactics.tex theories.tex libraries.tex description.pdf \ $(patsubst %,%.aux,$(TEX_CORES)) description.log description.out \ description.toc description.fls description.idx description.ilg \ description.ind description.blg description.bbl description.fdb_latexmk diff --git a/Manual/Description/libraries.tex b/Manual/Description/libraries.stex similarity index 100% rename from Manual/Description/libraries.tex rename to Manual/Description/libraries.stex From 7ead6a37ba2aa59e2b572a4923e551c50ce96e20 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 5 Feb 2016 12:40:12 +1100 Subject: [PATCH 688/718] Handle not-iff Unicode symbol in polyscripter umap The \notiff is not a standard LaTeX macro --- Manual/Tools/umap | 1 + 1 file changed, 1 insertion(+) diff --git a/Manual/Tools/umap b/Manual/Tools/umap index 2172b721c8..cff1f0862f 100644 --- a/Manual/Tools/umap +++ b/Manual/Tools/umap @@ -6,6 +6,7 @@ ∨ \(\lor\) ¬ \(\neg\) ⇔ \({\iff}\) +⇎ \({\notiff}\) ≠ \(\ne\) ≤ \(\le\) λ \(\lambda\) From 3b9d8dc843d40ef0e3bb64449de22a685a761657 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 5 Feb 2016 12:40:53 +1100 Subject: [PATCH 689/718] Polyscripter tweaks to libraries chapter in DESCRIPTION --- Manual/Description/description.tex | 4 + Manual/Description/libraries.stex | 411 +++++++++++------------------ 2 files changed, 155 insertions(+), 260 deletions(-) diff --git a/Manual/Description/description.tex b/Manual/Description/description.tex index 62249e05ab..0deaebe3a9 100644 --- a/Manual/Description/description.tex +++ b/Manual/Description/description.tex @@ -38,6 +38,10 @@ \usepackage[hidelinks,hypertexnames=false,pdftitle={The HOL System DESCRIPTION}]{hyperref} +\usepackage{centernot} +\newcommand{\notiff}{% + \mathrel{{\ooalign{\hidewidth$\not\phantom{"}$\hidewidth\cr$\iff$}}}} + \makeindex \begin{document} diff --git a/Manual/Description/libraries.stex b/Manual/Description/libraries.stex index ac979c065f..171485283e 100644 --- a/Manual/Description/libraries.stex +++ b/Manual/Description/libraries.stex @@ -641,17 +641,13 @@ system will inform us that overloading resolution is being performed. \setcounter{sessioncount}{0} \begin{session} -\begin{verbatim} -- load "integerTheory"; -> val it = () : unit +\begin{alltt} +>> load "integerTheory"; -- Term `~~x`; -<> -> val it = `~~x` : term +>> Term `~~x`; -- type_of it; -> val it = `:bool` : hol_type -\end{verbatim} +>> type_of it; +\end{alltt} \end{session} A priority mechanism is used to resolve multiple possible choices. In @@ -664,17 +660,13 @@ while in the second, a type constraint ensures that \holtxt{\~{}\~{}x} has type \holtxt{:int}. \begin{session} -\begin{verbatim} -- show_types := true; -> val it = () : unit +\begin{alltt} +>> show_types := true; -- Term `~(x = ~~x)`; -<> -> val it = `~((x :bool) = ~~x)` : term +>> Term `~(x = ~~x)`; -- Term `~(x:int = ~~x)`; -> val it = `~((x :int) = ~~x)` : term -\end{verbatim} +>> Term `~(x:int = ~~x)`; +\end{alltt} \end{session} Note that the symbol \holtxt{\~{}} stands for two different constants in @@ -996,17 +988,13 @@ print depth are printed as \holtxt{...}. For example: \setcounter{sessioncount}{0} \begin{session} -\begin{verbatim} -- ADD_CLAUSES; -> val it = - |- (0 + m = m) /\ (m + 0 = m) /\ (SUC m + n = SUC (m + n)) /\ - (m + SUC n = SUC (m + n)) : thm +\begin{alltt} +>> arithmeticTheory.ADD_CLAUSES; -- max_print_depth := 3; -> val it = () : unit -- ADD_CLAUSES; -> val it = |- (... + ... = m) /\ (... = ...) /\ ... /\ ... : thm -\end{verbatim} +>> max_print_depth := 3; +>> arithmeticTheory.ADD_CLAUSES; +>>__ max_print_depth := ~1; +\end{alltt} \end{session} \index{default print depth, for HOL logic@default print depth, for \HOL{} logic|)} @@ -1023,10 +1011,9 @@ rather ugly because of the special filtering that is done to these values before the ML interpreter even sees them: \setcounter{sessioncount}{0} \begin{session} -\begin{verbatim} -- val q = `f x = 3`; -> val 'a q = [QUOTE " (*#loc 1 11*)f x = 3"] : 'a frag list -\end{verbatim} +\begin{alltt} +>> val q = `f x = 3`; +\end{alltt} \end{session} Quotations (Moscow ML prints the type as \ml{'a frag list}) are the raw input form expected by the various HOL parsers. They are also @@ -1040,13 +1027,11 @@ double back-ticks as delimiters. For the type parser, the first non-space character after the leading delimiter must also be a colon. Thus: \begin{session} -\begin{verbatim} -- val t = ``p /\ q``; -> val t = ``p /\ q`` : term +\begin{alltt} +>> val t = ``p /\ q``; -- val ty = ``:'a -> bool``; -> val ty = ``:'a -> bool`` : hol_type -\end{verbatim} +>> val ty = ``:'a -> bool``; +\end{alltt} \end{session} The expression bound to ML variable \ml{t} above is actually expanded @@ -1070,33 +1055,27 @@ passed to the HOL parser unchanged. Otherwise, one caret can be obtained by writing two in a row. (This last rule is analogous to the way in \ML{} string syntax treats the back-slash.) Thus: \begin{session} -\begin{verbatim} -- ``f ^` x ``; -<> -> val it = ``f ` x`` : term +\begin{alltt} +>> ``f ^` x ``; -- ``f ^ x``; -<> -> val it = ``f ^ x`` : term -\end{verbatim} +>> ``f ^ x``; +\end{alltt} \end{session} The rule for carets not followed by white-space is illustrated here, including an example of what happens when the quoting rule is not followed: \begin{session} -\begin{verbatim} -- ``f ^^+ x``; -<> -> val it = ``f ^+ x`` : term +\begin{alltt} +>> ``f ^^+ x``; -- ``f ^+ x``; +>>+ ``f ^+ x``; ! Toplevel input: ! (Parse.Term [QUOTE " (*#loc 2 3*)f ", ANTIQUOTE (+), ! QUOTE " (*#loc 2 7*) x"]); ! ^ ! Ill-formed infix expression -\end{verbatim} +\end{alltt} \end{session} The main use of the caret is to introduce \emph{antiquotations} (as @@ -1125,28 +1104,24 @@ The following session illustrates antiquotation. \setcounter{sessioncount}{0} \begin{session} -\begin{verbatim} -- val y = ``x+1``; -> val y = ``x + 1`` : term +\begin{alltt} +>>__ remove_ovl_mapping "+" {Name = "int_add", Thy = "integer"}; +>> val y = ``x+1``; -val z = ``y = ^y``; -> val z = ``y = x + 1`` : term +>> val z = ``y = ^y``; -- ``!x:num.?y:num.^z``; -> val it = ``!x. ?y. y = x + 1`` : term -\end{verbatim} +>> ``!x:num.?y:num.^z``; +\end{alltt} \end{session} \noindent Types may be antiquoted as well: \begin{session} -\begin{verbatim} -- val pred = ``:'a -> bool``; -> val pred = ``:'a -> bool`` : hol_type +\begin{alltt} +>> val pred = ``:'a -> bool``; -- ``:^pred -> bool``; -> val it = ``:('a -> bool) -> bool`` : hol_type -\end{verbatim} +>> ``:^pred -> bool``; +\end{alltt} \end{session} \noindent Quotations are polymorphic, and the type variable of a @@ -1158,20 +1133,12 @@ terms, antiquoting a type into a term quotation requires the use of \index{ty_antiq@\ml{ty\_antiq}} \begin{session} -\begin{verbatim} -- ``!P:^pred. P x ==> Q x``; +\begin{alltt} +>>+ ``!P:^pred. P x ==> Q x``; -! Toplevel input: -! Term `!P:^pred. P x ==> Q x`; -! ^^^^ -! Type clash: expression of type -! hol_type -! cannot have type -! term - -- ``!P:^(ty_antiq pred). P x ==> Q x``; +>> ``!P:^(ty_antiq pred). P x ==> Q x``; > val it = `!P. P x ==> Q x` : term -\end{verbatim} +\end{alltt} \end{session} % \index{parsing, of HOL logic@parsing, of \HOL{} logic!of quotation syntax|)} @@ -1688,19 +1655,18 @@ in \ml{boolSimps} embodies all of the usual rewrite theorems one would want over formulas: \setcounter{sessioncount}{0} \begin{session} -\begin{verbatim} -- SIMP_CONV bool_ss [] ``p /\ T \/ ~(q /\ r)``; -> val it = |- p /\ T \/ ~(q /\ r) = p \/ ~q \/ ~r : thm -\end{verbatim} +\begin{alltt} +>>__ show_types := false; +>> SIMP_CONV bool_ss [] ``p /\ T \/ ~(q /\ r)``; +\end{alltt} \end{session} In addition to rewriting with the obvious theorems, \ml{bool\_ss} is also capable of performing simplifications that are not expressible as simple theorems: \begin{session} -\begin{verbatim} -- SIMP_CONV bool_ss [] ``?x. (\y. P (f y)) x /\ (x = z)``; -> val it = |- (?x. (\y. P (f y)) x /\ (x = z)) = P (f z) : thm -\end{verbatim} +\begin{alltt} +>> SIMP_CONV bool_ss [] ``?x. (\y. P (f y)) x /\ (x = z)``; +\end{alltt} \end{session} In this example, the simplifier performed a $\beta$-reduction in the first conjunct under the existential quantifier, and then did an @@ -1722,10 +1688,10 @@ term size (there are two occurrences of $p$ on the right hand side of the theorem). Nonetheless, it is clear that this theorem may be appropriate on occasion: \begin{session} -\begin{verbatim} -- SIMP_CONV bossLib.arith_ss [LEFT_ADD_DISTRIB] ``p * (n + 1)``; -> val it = |- p * (n + 1) = p + n * p : thm -\end{verbatim} +\begin{alltt} +>>_ open arithmeticTheory; +>> SIMP_CONV bossLib.arith_ss [LEFT_ADD_DISTRIB] ``p * (n + 1)``; +\end{alltt} \end{session} Note how the \ml{arith\_ss} \simpset{} has not only simplified the intermediate \ml{(p * 1)} term, but also re-ordered the addition to @@ -1759,23 +1725,12 @@ Like \ml{SIMP\_TAC}, \ml{ASM\_SIMP\_TAC} simplifies the current goal (leaving the assumptions untouched), but includes the goal's assumptions as extra rewrite rules. Thus: \begin{session} -\begin{verbatim} -1 subgoal: -> val it = - P x - ------------------------------------ - x = 3 - : goalstack - -- e (ASM_SIMP_TAC bool_ss []); -OK.. -1 subgoal: -> val it = - P 3 - ------------------------------------ - x = 3 - : goalstack -\end{verbatim} +\begin{alltt} +>>__ g `(x = 3) ==> P x`; +>>- e strip_tac; + +>> e (ASM_SIMP_TAC bool_ss []); +\end{alltt} \end{session} \noindent In this example, \ml{ASM\_SIMP\_TAC} used \holtxt{x = 3} as an @@ -1809,23 +1764,13 @@ way up the list of assumptions, from bottom to top. The following demonstrates a simple use of \ml{FULL\_SIMP\_TAC}: \begin{session} -\begin{verbatim} - x + y < z - ------------------------------------ - 0. f x < 10 - 1. x = 4 - : goalstack +\begin{alltt} +>>__ drop(); +>>__ g `f (x:num) < 10 /\ (x = 4) ==> 4 + x < 10`; +>>- e strip_tac; -- e (FULL_SIMP_TAC bool_ss []); -OK.. -1 subgoal: -> val it = - 4 + y < z - ------------------------------------ - 0. f 4 < 10 - 1. x = 4 - : goalstack -\end{verbatim} +>> e (FULL_SIMP_TAC bool_ss []); +\end{alltt} \end{session} In this example, the assumption \holtxt{x = 4} caused the \holtxt{x} in the assumption \holtxt{f x < 10} to be replaced by \holtxt{4}. The @@ -1835,30 +1780,16 @@ have changed. The next session demonstrates more interesting behaviour: \begin{session} -\begin{verbatim} -> val it = - f x + 1 < 10 - ------------------------------------ - x <= 4 - : goalstack - -- e (FULL_SIMP_TAC bool_ss [arithmeticTheory.LESS_OR_EQ]); -OK.. -2 subgoals: -> val it = - f 4 + 1 < 10 - ------------------------------------ - x = 4 +\begin{alltt} +>>__ drop(); g`x <= 4n ==> f x + 1 < 10`; +>>- e strip_tac; - f x + 1 < 10 - ------------------------------------ - x < 4 - : goalstack -\end{verbatim} +>> e (FULL_SIMP_TAC bool_ss [arithmeticTheory.LESS_OR_EQ]); +\end{alltt} \end{session} In this example, the goal was rewritten with the theorem stating \[ -\vdash x \leq y \equiv x < y \lor x = y +\vdash x \leq y \iff x < y \lor x = y \] Turning the assumption into a disjunction resulted in two sub-goals. In the second of these, the assumption \holtxt{x = 4} further @@ -1977,14 +1908,13 @@ explained in Section~\ref{sec:simplifier-rewriting} below, but can be illustrated by some examples (the first also demonstrates unwinding under a universal quantifier): \begin{session} -\begin{verbatim} -- SIMP_CONV bool_ss [] ``!x. (x = 3) /\ P x ==> Q x /\ P 3``; -> val it = |- (!x. (x = 3) /\ P x ==> Q x /\ P 3) = P 3 ==> Q 3 : thm +\begin{alltt} +>>__ remove_ovl_mapping GrammarSpecials.fromNum_str + {Name = "int_of_num", Thy = "integer"}; +>> SIMP_CONV bool_ss [] ``!x. (x = 3) /\ P x ==> Q x /\ P 3``; -- SIMP_CONV bool_ss [] ``if ~(x = 3) then P x else Q x``; -> val it = |- (if ~(x = 3) then P x else Q x) = - (if ~(x = 3) then P x else Q 3) : thm -\end{verbatim} +>> SIMP_CONV bool_ss [] ``if x <> 3 then P x else Q x``; +\end{alltt} \end{session} \subsubsection{\ml{std\_ss}} @@ -1995,27 +1925,22 @@ The \ml{std\_ss} \simpset{} is defined in \ml{bossLib}, and adds rewrite rules pertinent to the types of sums, pairs, options and natural numbers to \ml{bool\_ss}. \begin{session} -\begin{verbatim} -- SIMP_CONV std_ss [] ``FST (x,y) + OUTR (INR z)``; -<> -> val it = |- FST (x,y) + OUTR (INR z) = x + z : thm +\begin{alltt} +>> SIMP_CONV std_ss [] ``FST (x,y) + OUTR (INR z)``; -- SIMP_CONV std_ss [] ``case SOME x of NONE => P | SOME y => f y``; -> val it = |- (case SOME x of NONE => P | SOME v => f v) = f x : thm -\end{verbatim} +>> SIMP_CONV std_ss [] ``case SOME x of NONE => P | SOME y => f y``; +\end{alltt} \end{session} With the natural numbers, the \ml{std\_ss} \simpset{} can calculate with ground values, and also includes a suite of ``obvious rewrites'' for formulas including variables. \begin{session} -\begin{verbatim} -- SIMP_CONV std_ss [] ``P (0 <= x) /\ Q (y + x - y)``; -> val it = |- P (0 <= x) /\ Q (y + x - y) = P T /\ Q x : thm +\begin{alltt} +>> SIMP_CONV std_ss [] ``P (0 <= x) /\ Q (y + x - y)``; -- SIMP_CONV std_ss [] ``23 * 6 + 7 ** 2 - 31 DIV 3``; -> val it = |- 23 * 6 + 7 ** 2 - 31 DIV 3 = 177 : thm -\end{verbatim} +>> SIMP_CONV std_ss [] ``23 * 6 + 7 ** 2 - 31 DIV 3``; +\end{alltt} \end{session} \subsubsection{\ml{arith\_ss}} @@ -2032,23 +1957,19 @@ Section~\ref{sec:numLib} below. These two facets of the \ml{arith\_ss} \simpset{} are demonstrated here: \begin{session} -\begin{verbatim} -- SIMP_CONV arith_ss [] ``x < 3 /\ P x ==> x < 20 DIV 2``; -> val it = |- x < 3 /\ P x ==> x < 20 DIV 2 = T : thm +\begin{alltt} +>> SIMP_CONV arith_ss [] ``x < 3 /\ P x ==> x < 20 DIV 2``; -- SIMP_CONV arith_ss [] ``2 * x + y - x + y``; -> val it = |- 2 * x + y - x + y = x + 2 * y : thm -\end{verbatim} +>> SIMP_CONV arith_ss [] ``2 * x + y - x + y``; +\end{alltt} \end{session} Note that subtraction over the natural numbers works in ways that can seem unintuitive. In particular, coefficient normalisation may not occur when first expected: \begin{session} -\begin{verbatim} -- SIMP_CONV arith_ss [] ``2 * x + y - z + y``; -! Uncaught exception: -! UNCHANGED -\end{verbatim} +\begin{alltt} +>>+ SIMP_CONV arith_ss [] ``2 * x + y - z + y``; +\end{alltt} \end{session} Over the natural numbers, the expression $2 x + y - z + y$ is not equal to $2 x + 2 y - z$. In particular, these expressions are not @@ -2072,16 +1993,13 @@ Conveniently, \ml{list\_ss} also includes rewrites for the functions defined by primitive recursion over lists. Examples include \holtxt{MAP}, \holtxt{FILTER} and \holtxt{LENGTH}. Thus: \begin{session} -\begin{verbatim} -- SIMP_CONV list_ss [] ``MAP (\x. x + 1) [1;2;3;4]``; -> val it = |- MAP (\x. x + 1) [1; 2; 3; 4] = [2; 3; 4; 5] : thm +\begin{alltt} +>> SIMP_CONV list_ss [] ``MAP (\x. x + 1) [1;2;3;4]``; -- SIMP_CONV list_ss [] ``FILTER (\x. x < 4) [1;2;y + 4]``; -> val it = |- FILTER (\x. x < 4) [1; 2; y + 4] = [1; 2] : thm +>> SIMP_CONV list_ss [] ``FILTER (\x. x < 4) [1;2;y + 4]``; -- SIMP_CONV list_ss [] ``LENGTH (FILTER ODD [1;2;3;4;5])``; -> val it = |- LENGTH (FILTER ODD [1; 2; 3; 4; 5]) = 3 : thm -\end{verbatim} +>> SIMP_CONV list_ss [] ``LENGTH (FILTER ODD [1;2;3;4;5])``; +\end{alltt} \end{session} These examples demonstrate how the simplifier can be used as a general purpose symbolic evaluator for terms that look a great deal like those @@ -2090,12 +2008,9 @@ this functionality is also provided by \ml{computeLib} (see Section~\ref{sec:computeLib} below); \ml{computeLib} is more efficient, but less general than the simplifier. For example: \begin{session} -\begin{verbatim} -- EVAL ``FILTER (\x. x < 4) [1;2;y + 4]``; -> val it = - |- FILTER (\x. x < 4) [1; 2; y + 4] = - 1::2::(if y + 4 < 4 then [y + 4] else []) : thm -\end{verbatim} +\begin{alltt} +>> EVAL ``FILTER (\x. x < 4) [1;2;y + 4]``; +\end{alltt} \end{session} \subsubsection{The ``stateful'' \simpset---\ml{srw\_ss()}} @@ -2121,23 +2036,15 @@ all situations where the simplifier is used. This versatility is illustrated in the following example: \begin{session} -\begin{verbatim} -- Datatype `tree = Leaf | Node num tree tree`; -<> -> val it = () : unit +\begin{alltt} +>> Datatype `tree = Leaf | Node num tree tree`; -- SIMP_CONV (srw_ss()) [] ``Node x Leaf Leaf = Node 3 t1 t2``; -<> -> val it = - |- (Node x Leaf Leaf = Node 3 t1 t2) = - (x = 3) /\ (Leaf = t1) /\ (Leaf = t2) : thm +>> SIMP_CONV (srw_ss()) [] ``Node x Leaf Leaf = Node 3 t1 t2``; -- load "pred_setTheory"; -> val it = () : unit +>> load "pred_setTheory"; -- SIMP_CONV (srw_ss()) [] ``x IN { y | y < 6}``; -> val it = |- x IN {y | y < 6} = x < 6 : thm -\end{verbatim} +>> SIMP_CONV (srw_ss()) [] ``x IN { y | y < 6}``; +\end{alltt} \end{session} % Users can augment the stateful \simpset{} themselves with the function @@ -2154,21 +2061,16 @@ in the current segment (those that will be exported when the underlying \simpset{} in the current session, but they will be added in future sessions when the current theory is reloaded. \begin{session} -\begin{verbatim} -- val tsize_def = Define` - (tsize Leaf = 0) /\ - (tsize (Node n t1 t2) = n + tsize t1 + tsize t2) -`; -Definition has been stored under "tsize_def". -> val tsize_def = - |- (tsize Leaf = 0) /\ - !n t1 t2. tsize (Node n t1 t2) = n + tsize t1 + tsize t2 : thm +\begin{alltt} +>> val tsize_def = Define` + (tsize Leaf = 0) /\ + (tsize (Node n t1 t2) = n + tsize t1 + tsize t2) + `; -- val _ = BasicProvers.export_rewrites ["tsize_def"]; +>> val _ = BasicProvers.export_rewrites ["tsize_def"]; -- SIMP_CONV (srw_ss()) [] ``tsize (Node 4 (Node 6 Leaf Leaf) Leaf)``; -> val it = |- tsize (Node 4 (Node 6 Leaf Leaf) Leaf) = 10 : thm -\end{verbatim} +>> SIMP_CONV (srw_ss()) [] ``tsize (Node 4 (Node 6 Leaf Leaf) Leaf)``; +\end{alltt} \end{session} Alternatively, the user may also flag theorems directly when using \ml{store\_thm} or \ml{save\_thm} by appending the \ml{simp} attribute to the name of the theorem. @@ -3132,12 +3034,11 @@ augments this database with relevant definitions, that of Quicksort % \setcounter{sessioncount}{0} \begin{session} -\begin{verbatim} - - load "sortingTheory"; +\begin{alltt} +>> load "sortingTheory"; - - EVAL ``QSORT (<=) [76;34;102;3;4]``; - > val it = |- QSORT $<= [76; 34; 102; 3; 4] = [3; 4; 34; 76; 102] : thm -\end{verbatim} +>> EVAL ``QSORT (<=) [76;34;102;3;4]``; +\end{alltt} \end{session} Often, the argument to a function has no variables: in that case application of \ml{EVAL} ought to return a ground result, @@ -3151,13 +3052,11 @@ in the input to allow the algorithm any traction, no expansion will take place. % \begin{session} -\begin{verbatim} - - EVAL ``REVERSE [u;v;w;x;y;z]``; - > val it = |- REVERSE [u; v; w; x; y; z] = [z; y; x; w; v; u] : thm +\begin{alltt} +>> EVAL ``REVERSE [u;v;w;x;y;z]``; - - EVAL ``REVERSE alist``; - > val it = |- REVERSE alist = REVERSE alist : thm -\end{verbatim} +>> EVAL ``REVERSE alist``; +\end{alltt} \end{session} % @@ -3169,22 +3068,20 @@ enormous terms. The usual cause is conditionals with variables in the test. For example, the following definition is provably equal to \holtxt{FACT}, % \begin{session} -\begin{verbatim} - Define `fact n = if n=0 then 1 else n * fact (n-1)`; - > val it = |- fact n = (if n = 0 then 1 else n * fact (n - 1)) : thm -\end{verbatim} +\begin{alltt} +>> Define `fact n = if n=0 then 1 else n * fact (n-1)`; +\end{alltt} \end{session} % But the two definitions evaluate completely differently. % \begin{session} \begin{verbatim} - EVAL ``FACT n``; - > val it = |- FACT n = FACT n : thm +>> EVAL ``FACT n``; - - EVAL ``fact n``; +> EVAL ``fact n``; <.... interrupt key struck ...> - > Interrupted. +Interrupted. \end{verbatim} \end{session} % @@ -3194,32 +3091,26 @@ expanding. A rudimentary monitoring facility shows the behaviour, first on a ground argument, then on a symbolic argument. % \begin{session} -\begin{verbatim} - - val [fact] = decls "fact"; - - computeLib.monitoring := SOME (same_const fact); - - - EVAL ``fact 4``; - fact 4 = (if 4 = 0 then 1 else 4 * fact (4 - 1)) - fact 3 = (if 3 = 0 then 1 else 3 * fact (3 - 1)) - fact 2 = (if 2 = 0 then 1 else 2 * fact (2 - 1)) - fact 1 = (if 1 = 0 then 1 else 1 * fact (1 - 1)) - fact 0 = (if 0 = 0 then 1 else 0 * fact (0 - 1)) - > val it = |- fact 4 = 24 : thm - - - EVAL ``fact n``; - fact n = (if n = 0 then 1 else n * fact (n - 1)) - fact (n - 1) = (if n - 1 = 0 then 1 else (n - 1) * fact (n - 1 - 1)) - fact (n - 1 - 1) = - (if n - 1 - 1 = 0 then 1 else (n - 1 - 1) * fact (n - 1 - 1 - 1)) - fact (n - 1 - 1 - 1) = - (if n - 1 - 1 - 1 = 0 then - 1 - else - (n - 1 - 1 - 1) * fact (n - 1 - 1 - 1 - 1)) - . - . - . -\end{verbatim} +\begin{alltt} +>> val [fact] = decls "fact"; +>> computeLib.monitoring := SOME (same_const fact); + +>> EVAL ``fact 4``; + +> EVAL ``fact n``; +fact n = (if n = 0 then 1 else n * fact (n - 1)) +fact (n - 1) = (if n - 1 = 0 then 1 else (n - 1) * fact (n - 1 - 1)) +fact (n - 1 - 1) = +(if n - 1 - 1 = 0 then 1 else (n - 1 - 1) * fact (n - 1 - 1 - 1)) +fact (n - 1 - 1 - 1) = +(if n - 1 - 1 - 1 = 0 then + 1 + else + (n - 1 - 1 - 1) * fact (n - 1 - 1 - 1 - 1)) + . + . + . +\end{alltt} \end{session} % In each recursive expansion, the test involves a variable, and hence From 2278636693a5f4afef25c54680604263b75c4f76 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 8 Feb 2016 15:15:42 +1100 Subject: [PATCH 690/718] Handle some Unicode word symbols in polyscripter umap --- Manual/Tools/umap | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/Manual/Tools/umap b/Manual/Tools/umap index cff1f0862f..49d8b1ab01 100644 --- a/Manual/Tools/umap +++ b/Manual/Tools/umap @@ -20,3 +20,7 @@ − \({-}\) { \{ } \} +‖ \(\mid\!\mid\) +≪ \(<\!\!<\) +⋙ \(>\!\!>\!\!>\) +₊ \({}\sb{+}\) From 022346c603571a93f016f62569b1f0d3262cfd25 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 8 Feb 2016 15:21:11 +1100 Subject: [PATCH 691/718] Make local parsing work better for OmegaMath Unfortunately, if you use Q.EXISTS_TAC and similar, you are dependent on the global grammar (hidden behind a reference), and rebinding the Parse structure doesn't protect you. If this happens in a library, you really have to use temp_set_grammars to get the right behaviour (and the correct independence from what has happened globally). --- src/integer/OmegaMath.sml | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/src/integer/OmegaMath.sml b/src/integer/OmegaMath.sml index 5eb961362e..bc681e58f8 100644 --- a/src/integer/OmegaMath.sml +++ b/src/integer/OmegaMath.sml @@ -5,11 +5,8 @@ open CooperMath local open OmegaTheory in end (* Fix the grammar used by this file *) -structure Parse = struct - open Parse - val (Type,Term) = parse_from_grammars int_arith_grammars -end -open Parse +val ctxt_grammars = (type_grammar(), term_grammar()) +val _ = temp_set_grammars int_arith_grammars val REWRITE_CONV = GEN_REWRITE_CONV TOP_DEPTH_CONV bool_rewrites @@ -1160,4 +1157,6 @@ in TRY_CONV eliminate_negative_divides end t +val _ = temp_set_grammars ctxt_grammars + end (* struct *) From d1176a17d95e35947aa9522e5c5e66a1c343a91f Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 8 Feb 2016 15:23:09 +1100 Subject: [PATCH 692/718] Finish Description/libraries.tex for polyscripter Still to do embedded sections on HolSat etc --- Manual/Description/libraries.stex | 224 +++++++++++------------------- 1 file changed, 80 insertions(+), 144 deletions(-) diff --git a/Manual/Description/libraries.stex b/Manual/Description/libraries.stex index 171485283e..d92911c0cb 100644 --- a/Manual/Description/libraries.stex +++ b/Manual/Description/libraries.stex @@ -3227,13 +3227,11 @@ The library \theoryimp{wordsLib} should be loaded when evaluating ground bit-vec can be used in the construction of custom \emph{compsets} and conversions. \setcounter{sessioncount}{0} \begin{session} -\begin{verbatim} -- load "wordsLib"; -> val it = () : unit +\begin{alltt} +>> load "wordsLib"; -- EVAL ``8w + 9w:word4``; -> val it = |- 8w + 9w = 1w : thm -\end{verbatim} +>> EVAL ``8w + 9w:word4``; +\end{alltt} \end{session} Note that a type annotation is used here to designate the word size. When the word size is represented by a type variable (\ie{} for arbitrary length words), evaluation may give partial or unsatisfactory results. @@ -3241,38 +3239,31 @@ Note that a type annotation is used here to designate the word size. When the w Words can be parsed in binary, decimal and hexadecimal. For example: \begin{session} -\begin{verbatim} -- ``0b111010w : word8``; -> val it = ``58w`` : term +\begin{alltt} +>> ``0b111010w : word8``; -- ``0x3Aw : word8``; -> val it = ``58w`` : term -\end{verbatim} +>> ``0x3Aw : word8``; +\end{alltt} \end{session} It is possible to parse octal numbers, but this must be enabled first by setting the reference \ml{base\_tokens.allow\_octal\_input} to true. For example: \begin{session} -\begin{verbatim} -- ``072w : word8``; -> val it = ``72w`` : term +\begin{alltt} +>> ``072w : word8``; -- base_tokens.allow_octal_input:=true; -> val it = () : unit +>> base_tokens.allow_octal_input:=true; -- ``072w : word8``; -> val it = ``58w`` : term -\end{verbatim} +>> ``072w : word8``; +\end{alltt} \end{session} Words can be pretty-printed using the standard number bases. For example, the function \ml{wordsLib.output\_words\_as\_bin} will select binary format: \begin{session} -\begin{verbatim} -- wordsLib.output_words_as_bin(); -> val it = () : unit +\begin{alltt} +>> wordsLib.output_words_as_bin(); -- EVAL ``($FCP ODD):word16``; -> val it = |- $FCP ODD = 0b1010101010101010w : thm -\end{verbatim} +>> EVAL ``($FCP ODD):word16``; +\end{alltt} \end{session} The function \ml{output\_words\_as} is more flexible and allows the number base to vary depending on the word length and numeric value. The default pretty-printer (installed when loading \theoryimp{wordsLib}) prints small values in decimal and large values in hexadecimal. @@ -3280,11 +3271,9 @@ The function \ml{output\_words\_as\_oct} will automatically enable the parsing o The trace variable \ml{"word printing"} provides an alternative method for changing the output number base --- it is particularly suited to temporarily selecting a number base, for example: \begin{session} -\begin{verbatim} -- Feedback.trace ("word printing", 1) Parse.print_term ``32w``; -<> -0b100000w> val it = () : unit -\end{verbatim} +\begin{alltt} +>> Feedback.trace ("word printing", 1) Parse.term_to_string ``32w``; +\end{alltt} \end{session} The choices are as follows: 0 (default) -- small numbers decimal, large numbers hexadecimal; 1 -- binary; 2 -- octal; 3 -- decimal; and 4 -- hexadecimal. @@ -3292,72 +3281,50 @@ The choices are as follows: 0 (default) -- small numbers decimal, large numbers You may have noticed that \ty{:word4} and \ty{:word8} have been used as convenient parsing abbreviations for \ty{:\bool[4]} and \ty{:\bool[8]} --- this facility is available for many standard word sizes. Users wishing to use this notation for non-standard word sizes can use the function \ml{wordsLib.mk\_word\_size}: \begin{session} -\begin{verbatim} -- ``:word15``; -! Uncaught exception: -! HOL_ERR +\begin{alltt} +>>+ Lib.try Parse.Type `:word15` handle _ => bool; -- wordsLib.mk_word_size 15; -> val it = () : unit +>> wordsLib.mk_word_size 15; -- ``:word15``; -> val it = ``:bool[15]`` : hol_type -\end{verbatim} +>> ``:word15``; +\end{alltt} \end{session} \subsubsection{Operator overloading} The symbols for the standard arithmetic operations (addition, subtraction and multiplication) are overloaded with operators from other standard theories, \ie{} for the natural, integer, rational and real numbers. In many cases type inference will resolve overloading, however, in some cases this is not possible. The choice of operator will then depend upon the order in which theories are loaded. To change this behaviour the functions \ml{wordsLib.deprecate\_word} and \ml{wordsLib.prefer\_word} are provided. For example, in the following session, the selection of word operators is deprecated: \begin{session} -\begin{verbatim} -- type_of ``a + b``; -<> -<> -> val it = ``:bool['a]`` : hol_type +\begin{alltt} +>> type_of ``a + b``; -- wordsLib.deprecate_word(); -> val it = () : unit +>> wordsLib.deprecate_word(); -- type_of ``a + b``; -<> -> val it = ``:num`` : hol_type -\end{verbatim} +>> type_of ``a + b``; +\end{alltt} \end{session} In the above, natural number addition is chosen in preference to word addition. Conversely, words are preferred over the integers below: \begin{session} -\begin{verbatim} -- load "intLib"; ... +\begin{alltt} +>>_ load "intLib"; +>>__ temp_overload_on("+", ``int_add``); -- type_of ``a + b``; -<> -> val it = ``:int`` : hol_type +>> type_of ``a + b``; -- wordsLib.prefer_word(); -> val it = () : unit -- type_of ``a + b``; -<> -<> -> it = ``:bool['a]`` : hol_type -\end{verbatim} +>> wordsLib.prefer_word(); +>> type_of ``a + b``; +\end{alltt} \end{session} -Of course, type annotations could have been added to avoid this problem entirely. Note that, unlike \ml{deprecate\_int}, the function \ml{deprecate\_word} does not remove the overloadings, it simply lowers their priority. +Of course, type annotations could have been added to avoid this problem entirely. \subsubsection{Guessing word lengths} It can be a nuisance to add type annotations when specifying the return type for operations such as: \holtxt{word\_extract}, \holtxt{word\_concat}, \holtxt{concat\_word\_list} and \holtxt{word\_replicate}. This is because there is often a ``standard'' length that could be guessed, \eg{} concatenation usually sums the constituent word lengths. A facility for word length guessing is controlled by the reference \ml{wordsLib.guessing\_word\_lengths}, which is false by default. The guesses are made during a post-processing step that occurs after the application of \ml{Parse.Term}. This is demonstrated below. \begin{session} -\begin{verbatim} -- wordsLib.guessing_word_lengths:=true; -> val it = () : unit +\begin{alltt} +>> wordsLib.guessing_word_lengths:=true; -- ``concat_word_list [(4 >< 1) (w:word32); w2; w3]``; -<> -<> -<> -> val it = - ``concat_word_list [(4 >< 1) w; w2; w3]`` - : term -\end{verbatim} +>> ``concat_word_list [(4 >< 1) (w:word32); w2; w3]``; +\end{alltt} \end{session} In the example above, word length guessing is turned on. Two guesses are made: the extraction is expected to give a four bit word, and the concatenation gives a twelve bit word ($3 \times 4$). If non-standard numeric lengths are required then type annotations can be added to avoid guesses being made. With guessing turned off the result types would remain as invented type variables, \ie{} as alpha and beta above. @@ -3380,87 +3347,62 @@ Many of these \emph{simpset} fragments have corresponding conversions. For exam The behaviour of the fragments listed above are demonstrated using the following function: \begin{session} -\begin{verbatim} -- fun conv ss = SIMP_CONV (pure_ss++ss) []; -> val conv = fn : ssfrag -> term -> thm -\end{verbatim} +\begin{alltt} +>> fun conv ss = SIMP_CONV (pure_ss++ss) []; +\end{alltt} \end{session} The following session demonstrates \ml{SIZES\_ss}: \begin{session} -\begin{verbatim} -- conv wordsLib.SIZES_ss ``dimindex(:12)``; -> val it = |- dimindex (:12) = 12 : thm +\begin{alltt} +>> conv wordsLib.SIZES_ss ``dimindex(:12)``; -- conv wordsLib.SIZES_ss ``FINITE univ(:32)``; -> val it = |- FINITE univ(:32) <=> T : thm -\end{verbatim} +>> conv wordsLib.SIZES_ss ``FINITE univ(:32)``; +\end{alltt} \end{session} The fragment \ml{BIT\_ss} converts \holtxt{BIT} into membership test over a set of (high) bit positions: \begin{session} -\begin{verbatim} -- conv wordsLib.BIT_ss ``BIT 3 5``; -> val it = |- BIT 3 5 <=> (3 = 0) \/ (3 = 2) : thm +\begin{alltt} +>> conv wordsLib.BIT_ss ``BIT 3 5``; -- conv wordsLib.BIT_ss ``BIT i 123``; -> val it = |- BIT i 123 <=> i IN {0; 1; 3; 4; 5; 6} : - thm -\end{verbatim} +>> conv wordsLib.BIT_ss ``BIT i 123``; +\end{alltt} \end{session} This simplification provides some support for reasoning about bitwise operations over arbitrary word lengths. The arithmetic, logic and shift fragments help tidy up basic word expressions: \begin{session} -\begin{verbatim} -- conv wordsLib.WORD_LOGIC_ss ``a && 12w || 11w && a``; -<> -> val it = - |- a && 12w || 11w && a = 15w && a : - thm +\begin{alltt} +>> conv wordsLib.WORD_LOGIC_ss ``a && 12w || 11w && a``; -- conv wordsLib.WORD_ARITH_ss ``3w * b + a + 2w * b - a * 4w:word2``; -> val it = - |- 3w * b + a + 2w * b - a * 4w = a + b - : thm +>> conv wordsLib.WORD_ARITH_ss ``3w * b + a + 2w * b - a * 4w:word2``; -- conv wordsLib.WORD_SHIFT_ss ``0w << 12 + a >>> 0 + b << 2 << 3``; -<> -> val it = - |- 0w << 12 + a >>> 0 + b << 2 << 3 = 0w + a + b << (2 + 3) - : thm -\end{verbatim} +>> conv wordsLib.WORD_SHIFT_ss ``0w << 12 + a >>> 0 + b << 2 << 3``; +\end{alltt} \end{session} The remaining fragments are not included in \ml{wordsLib.WORD\_ss} or \ml{srw\_ss}. The bit equality fragment is demonstrated below. \begin{session} -\begin{verbatim} -- SIMP_CONV (std_ss++wordsLib.WORD_BIT_EQ_ss) [] ``a && b = ~0w : word2``; -> val it = - |- (a && b = ~0w) <=> (a ' 1 /\ b ' 1) /\ a ' 0 /\ b ' 0 - : thm -\end{verbatim} +\begin{alltt} +>> SIMP_CONV (std_ss++wordsLib.WORD_BIT_EQ_ss) [] ``a && b = ~0w : word2``; +\end{alltt} \end{session} The extract fragment is useful for reasoning about bit-field operations and is best used in combination with \ml{wordsLib.SIZES\_ss} or \ml{wordsLib.WORD\_ss}, for example: \begin{session} -\begin{verbatim} -- SIMP_CONV (std_ss++wordsLib.SIZES_ss++wordsLib.WORD_EXTRACT_ss) [] - ``(4 -- 1) ((a:word3) @@ (b:word2)) : word5``; -> val it = - |- (4 -- 1) (a @@ b) = (2 >< 0) a << 1 || (1 >< 1) b - : thm -\end{verbatim} +\begin{alltt} +>> SIMP_CONV (std_ss++wordsLib.SIZES_ss++wordsLib.WORD_EXTRACT_ss) [] + ``(4 -- 1) ((a:word3) @@ (b:word2)) : word5``; +\end{alltt} \end{session} Finally, the fragment \ml{WORD\_MUL\_LSL\_ss} is demonstrated below. \begin{session} -\begin{verbatim} -- conv wordsLib.WORD_MUL_LSL_ss ``5w * a : word8``; -> val it = |- 5w * a = a << 2 + a : thm -\end{verbatim} +\begin{alltt} +>> conv wordsLib.WORD_MUL_LSL_ss ``5w * a : word8``; +\end{alltt} \end{session} Rewriting with the theorem \ml{wordsTheory.WORD\_MUL\_LSL} provides an means to undo this simplification, for example: \begin{session} -\begin{verbatim} -- SIMP_CONV (std_ss++wordsLib.WORD_ARITH_ss) [wordsTheory.WORD_MUL_LSL] - ``a << 2 + a : word8``; -> val it = |- a << 2 + a = 5w * a : thm -\end{verbatim} +\begin{alltt} +>> SIMP_CONV (std_ss++wordsLib.WORD_ARITH_ss) [wordsTheory.WORD_MUL_LSL] + ``a << 2 + a : word8``; +\end{alltt} \end{session} Obviously, without adding safeguards, this rewrite theorem cannot be deployed when used in combination with the \ml{WORD\_MUL\_LSL\_ss} fragment. @@ -3480,26 +3422,20 @@ there are many nested additions (perhaps through multiplication). The following examples show \ml{BBLAST\_PROVE} in use: \begin{session} -\begin{verbatim} -- blastLib.BBLAST_PROVE ``a + 2w <+ 4w = a <+ 2w \/ 13w <+ a :word4``; -> val it = - |- a + 2w <+ 4w <=> a <+ 2w \/ 13w <+ a - : thm +\begin{alltt} +>>_ load "blastLib"; +>> blastLib.BBLAST_PROVE ``a + 2w <+ 4w = a <+ 2w \/ 13w <+ a :word4``; -- blastLib.BBLAST_PROVE ``w2w (a:word8) <+ 256w : word16``; -> val it = |- w2w a <+ 256w : thm -\end{verbatim} +>> blastLib.BBLAST_PROVE ``w2w (a:word8) <+ 256w : word16``; +\end{alltt} \end{session} The decision procedure \ml{BBLAST\_PROVE} is based on the conversion \ml{BBLAST\_CONV}. This conversion can be used to convert bit-vector problems into a propositional form; for example: \begin{session} -\begin{verbatim} -- blastLib.BBLAST_CONV ``(((a : word16) + 5w) << 3) ' 5``; -> val it = - |- ((a + 5w) << 3) ' 5 <=> (~a ' 2 <=> ~(a ' 1 /\ a ' 0)) - : thm -\end{verbatim} +\begin{alltt} +>> blastLib.BBLAST_CONV ``(((a : word16) + 5w) << 3) ' 5``; +\end{alltt} \end{session} There are also bit-blasting tactics: \ml{BBLAST\_TAC} and \ml{FULL\_BBLAST\_TAC}; with only the latter making use of goal assumptions. From 7a60e8c02e11be4d28f6a657ef61e5dc694821fa Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 8 Feb 2016 16:01:39 +1100 Subject: [PATCH 693/718] Use polyscripter for HolSat chapter of DESCRIPTION --- Manual/Description/.gitignore | 1 + .../Description/{HolSat.tex => HolSat.stex} | 59 +++++++------------ Manual/Description/Holmakefile | 8 ++- Manual/Description/zchaff.cnf | 4 ++ 4 files changed, 31 insertions(+), 41 deletions(-) rename Manual/Description/{HolSat.tex => HolSat.stex} (87%) create mode 100644 Manual/Description/zchaff.cnf diff --git a/Manual/Description/.gitignore b/Manual/Description/.gitignore index d7375595b1..eeee7c8cad 100644 --- a/Manual/Description/.gitignore +++ b/Manual/Description/.gitignore @@ -2,3 +2,4 @@ drules.tex tactics.tex theories.tex libraries.tex +HolSat.tex diff --git a/Manual/Description/HolSat.tex b/Manual/Description/HolSat.stex similarity index 87% rename from Manual/Description/HolSat.tex rename to Manual/Description/HolSat.stex index af3ea5fc4f..19a01293f6 100644 --- a/Manual/Description/HolSat.tex +++ b/Manual/Description/HolSat.stex @@ -55,27 +55,18 @@ The following example illustrates the use of {\tt{HolSatLib}} for proving propositional tautologies: \begin{session} -\begin{verbatim} -- load "HolSatLib"; open HolSatLib; -(* output omitted *) -> val it = () : unit +\begin{alltt} +>>_ load "HolSatLib"; open HolSatLib; -- show_tags := true; -> val it = () : unit +>> show_tags := true; -- SAT_PROVE ``(a ==> b) /\ (b ==> a) = (a=b)``; -> val it = [oracles: DISK_THM] [axioms: ] [] - |- (a ==> b) /\ (b ==> a) = (a = b) : thm +>> SAT_PROVE ``(a ==> b) /\ (b ==> a) = (a=b)``; -- SAT_PROVE ``(a ==> b) ==> (a=b)`` +>> SAT_PROVE ``(a ==> b) ==> (a=b)`` handle HolSatLib.SAT_cex th => th; -> val it = [oracles: DISK_THM] [axioms: ] [] - |- ~a /\ b ==> ~((a ==> b) ==> (a = b)) : thm -- SAT_ORACLE ``(a ==> b) /\ (b ==> a) = (a=b)``; -> val it = [oracles: DISK_THM, HolSatLib] [axioms: ] [] - |- (a ==> b) /\ (b ==> a) = (a = b) : thm -\end{verbatim} +>> SAT_ORACLE ``(a ==> b) /\ (b ==> a) = (a=b)``; +\end{alltt} \end{session} Setting \t{show\_tags} to \t{true} makes the \HOL{} top-level print theorem tags. The \t{DISK\_THM} oracle tag has nothing to do with \t{HolSatLib}. It just indicates the use of theorems from \HOL{} libraries read in from permanent storage. @@ -85,16 +76,12 @@ The next example illustrates using {\tt{HolSatLib}} for satisfiability testing. The idea is to negate the target term before passing it to {\tt{HolSatLib}}. \begin{session} -\begin{verbatim} -- SAT_PROVE ``~((a ==> b) ==> (a=b))`` - handle HolSatLib.SAT_cex => th; -> val it = [oracles: DISK_THM ] [axioms: ] [] - |- a /\ ~b ==> ~~((a ==> b) ==> (a = b)) : thm - -- SAT_PROVE ``~(a /\ ~a)``; -> val it = [oracles: DISK_THM ] [axioms: ] [] - |- ~(a /\ ~a) : thm -\end{verbatim} +\begin{alltt} +>> SAT_PROVE ``~((a ==> b) ==> (a=b))`` + handle HolSatLib.SAT_cex th => th; + +>> SAT_PROVE ``~(a /\ ~a)``; +\end{alltt} \end{session} As expected, if the target term is unsatisfiable we get a theorem saying as much. @@ -149,24 +136,18 @@ \subsection{The general interface} If true then \HOL{} will prove the SAT solver's results. \end{enumerate} -A special value \texttt{base\_config~:~sat\_config} is provided for which the term is \texttt{T}, the solver is MiniSat, the options are unset, the CNF flag is false and the proof flag is true. This value can be inspected and modified using getter and setter functions provided in \texttt{src/HolSat/satConfig.sig}. For example, to invoke ZChaff (assuming it is installed), on a file \texttt{unsat.cnf} containing an unsatisfiable problem, we do: +A special value \texttt{base\_config~:~sat\_config} is provided for which the term is \texttt{T}, the solver is MiniSat, the options are unset, the CNF flag is false and the proof flag is true. This value can be inspected and modified using getter and setter functions provided in \texttt{src/HolSat/satConfig.sig}. For example, to invoke ZChaff (assuming it is installed), on a file \texttt{zchaff.cnf} containing a DIMACS-formatted problem, we do: \begin{session} -\begin{verbatim} -- open satConfig; -(* output omitted *) +\begin{alltt} +>>_ open satConfig; -- val c = (set_infile "unsat.cnf" o set_solver SatSolvers.zchaff) base_config; -> val c = : sat_config +>> val c = base_config |> set_infile "zchaff.cnf" + |> set_solver SatSolvers.zchaff; -- GEN_SAT c; -> val it = [oracles: DISK_THM ] [axioms: ] [] - |- ~ : thm -\end{verbatim} +>>+ GEN_SAT c; +\end{alltt} \end{session} - -If the problem were satisfiable, the model can be captured via exception, as shown earlier. - Normally, {\tt{HolSatLib}} will delete the files generated by the SAT solver, such as the output proof, counter-model, and result status. However, if \texttt{infile} is set, the files are not deleted, in case they are required elsewhere. \subsection{Notes} diff --git a/Manual/Description/Holmakefile b/Manual/Description/Holmakefile index 57df6a927d..adc6584645 100644 --- a/Manual/Description/Holmakefile +++ b/Manual/Description/Holmakefile @@ -1,4 +1,4 @@ -TEX_CORES = description title preface system drules tactics theories definitions libraries misc +TEX_CORES = description title preface system drules tactics theories definitions libraries misc HolSat TEX_SOURCES = ../LaTeX/ack.tex ../LaTeX/commands.tex $(patsubst %,%.tex,$(TEX_CORES)) @@ -20,7 +20,11 @@ theories.tex: theories.stex $(PS_STUFF) libraries.tex: libraries.stex $(PS_STUFF) $(PS_COMMAND) -EXTRA_CLEANS = drules.tex tactics.tex theories.tex libraries.tex description.pdf \ +HolSat.tex: HolSat.stex $(PS_STUFF) zchaff.cnf + $(PS_COMMAND) + +EXTRA_CLEANS = drules.tex tactics.tex theories.tex libraries.tex HolSat.tex \ + description.pdf \ $(patsubst %,%.aux,$(TEX_CORES)) description.log description.out \ description.toc description.fls description.idx description.ilg \ description.ind description.blg description.bbl description.fdb_latexmk diff --git a/Manual/Description/zchaff.cnf b/Manual/Description/zchaff.cnf new file mode 100644 index 0000000000..7315f4878a --- /dev/null +++ b/Manual/Description/zchaff.cnf @@ -0,0 +1,4 @@ +p cnf 5 3 +1 -5 4 0 +-1 5 3 4 0 +-3 -4 0 From 69c2c18fbca0dc6fa39a943e97bf3dc011cf70f9 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 9 Feb 2016 10:09:52 +1100 Subject: [PATCH 694/718] Get OmegaMath fix from 022346c6 to compile --- src/integer/OmegaMath.sml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/integer/OmegaMath.sml b/src/integer/OmegaMath.sml index bc681e58f8..418b493fd1 100644 --- a/src/integer/OmegaMath.sml +++ b/src/integer/OmegaMath.sml @@ -5,8 +5,8 @@ open CooperMath local open OmegaTheory in end (* Fix the grammar used by this file *) -val ctxt_grammars = (type_grammar(), term_grammar()) -val _ = temp_set_grammars int_arith_grammars +val ctxt_grammars = (Parse.type_grammar(), Parse.term_grammar()) +val _ = Parse.temp_set_grammars int_arith_grammars val REWRITE_CONV = GEN_REWRITE_CONV TOP_DEPTH_CONV bool_rewrites @@ -1157,6 +1157,6 @@ in TRY_CONV eliminate_negative_divides end t -val _ = temp_set_grammars ctxt_grammars +val _ = Parse.temp_set_grammars ctxt_grammars end (* struct *) From 0043a8dce1916b34edc4afc765291ee91dac0169 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 10 Feb 2016 14:01:07 +1100 Subject: [PATCH 695/718] Document Holmake's --holstate option in help message --- tools-poly/Holmake/Holmake.sml | 1 + 1 file changed, 1 insertion(+) diff --git a/tools-poly/Holmake/Holmake.sml b/tools-poly/Holmake/Holmake.sml index 471d5f2e7c..a62f9b014b 100644 --- a/tools-poly/Holmake/Holmake.sml +++ b/tools-poly/Holmake/Holmake.sml @@ -1160,6 +1160,7 @@ in " --help | -h : show this message\n", " --holdir : use specified directory as HOL root\n", " --holmakefile : use file as Holmakefile\n", + " --holstate : use file as underlying \"heap\"\n", " --interactive | -i : run HOL with \"interactive\" flag set\n", " --keep-going | -k : don't stop on failure\n", " --logging : do per-theory time logging\n", From f7718876494d294ce8359c127f4848a7b5c259aa Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 16 Feb 2016 15:42:06 +1100 Subject: [PATCH 696/718] Update fail-to-find-dot message We no longer have hol.builder0 but have instead hol.state0 as the thing that is built as part of src/proofman's action. --- tools/buildutils.sml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/buildutils.sml b/tools/buildutils.sml index 1e3b212c7d..b52b79c029 100644 --- a/tools/buildutils.sml +++ b/tools/buildutils.sml @@ -694,7 +694,7 @@ in \*** or\n\ \*** config-override (Moscow ML)\n\ \***\n\ - \*** (Under Poly/ML you will have to delete bin/hol.builder0 as \ + \*** (Under Poly/ML you will have to delete bin/hol.state0 as \ \well)\n***\n\ \*** (Or: build with -nograph to stop this \ \message from appearing again)\n") From 432405ed190f1e9d90df3f56a58a75a49971406a Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 16 Feb 2016 15:47:57 +1100 Subject: [PATCH 697/718] Remove some unused code in build --- tools-poly/build.sml | 11 ----------- tools/buildutils.sig | 1 - tools/buildutils.sml | 5 ----- 3 files changed, 17 deletions(-) diff --git a/tools-poly/build.sml b/tools-poly/build.sml index 70a9f9dfbf..5afa3e21bb 100644 --- a/tools-poly/build.sml +++ b/tools-poly/build.sml @@ -104,17 +104,6 @@ fun upload ((src, regulardir), target, symlink) = (thus requiring only a single place to look for things). ---------------------------------------------------------------------------*) -fun make_exe (name:string) (POLY : string) (target:string) : unit = let - val _ = print ("Building "^target^"\n") - val dir = OS.FileSys.getDir() - in - OS.FileSys.chDir (fullPath [HOLDIR, "tools-poly"]); - Systeml.system_ps (POLY ^ " < " ^ name); - Poly_link {exe = fullPath [Systeml.HOLDIR, "bin", target], - obj = target ^ ".o"}; - OS.FileSys.chDir dir - end - fun buildDir symlink s = if #1 s = fullPath [HOLDIR, "bin/hol.bare"] then phase := Bare else if #1 s = fullPath [HOLDIR, "bin/hol"] then phase := Full diff --git a/tools/buildutils.sig b/tools/buildutils.sig index 22402cee58..3183e843da 100644 --- a/tools/buildutils.sig +++ b/tools/buildutils.sig @@ -18,7 +18,6 @@ sig {cmdline : string list, build_theory_graph : bool, do_selftests : int, SRCDIRS : (string * int) list} - val Poly_link : {exe:string,obj:string} -> unit val map_dir : (string * string -> unit) -> string -> unit (* f gets dirname * filename *) val rem_file : string -> unit diff --git a/tools/buildutils.sml b/tools/buildutils.sml index b52b79c029..f16f18f392 100644 --- a/tools/buildutils.sml +++ b/tools/buildutils.sml @@ -711,13 +711,8 @@ in end end -fun Poly_link {exe, obj} = - (Systeml.systeml([Systeml.CC, "-o", exe, obj] @ Systeml.POLY_LDFLAGS); - OS.FileSys.remove obj) - fun Poly_compilehelp() = let open Systeml - fun link exe obj = Poly_link{exe=exe,obj=obj} in system_ps (fullPath [HOLDIR, "tools", "mllex", "mllex.exe"] ^ " Lexer.lex"); system_ps (fullPath [HOLDIR, "tools", "mlyacc", "src", "mlyacc.exe"] ^ " Parser.grm"); From bed9d0350e29e69f4561f37a44c454fd0b0fb320 Mon Sep 17 00:00:00 2001 From: Anthony Fox Date: Wed, 17 Feb 2016 16:29:00 +0000 Subject: [PATCH 698/718] Updates for the manuals. The Makefile in Manual/ wasn't working (GNU Make 3.81 on a Mac). Also, sessioncount should be reset to 0 and not 1. --- Manual/Description/drules.stex | 6 +++--- Manual/Description/tactics.stex | 18 +++++++++--------- Manual/Makefile | 27 +++++++++++++++++---------- Manual/Quick/quick.tex | 4 ++-- 4 files changed, 31 insertions(+), 24 deletions(-) diff --git a/Manual/Description/drules.stex b/Manual/Description/drules.stex index 2593335d47..440389fb6b 100644 --- a/Manual/Description/drules.stex +++ b/Manual/Description/drules.stex @@ -60,7 +60,7 @@ In the session below, the proof is performed in the \HOL\ system, using the \ML\ functions \ml{ASSUME}\index{ASSUME@\ml{ASSUME}} and \ml{MP}. -\setcounter{sessioncount}{1} +\setcounter{sessioncount}{0} \begin{session} \begin{alltt} >> show_assums := true; @@ -170,7 +170,7 @@ counted.% ) Assume that the printing of theorems has been adjusted as above and \ml{th} is bound as shown below: -\setcounter{sessioncount}{1} +\setcounter{sessioncount}{0} \begin{session} \begin{alltt} >>__ val th = DECIDE ``(t1 ==> t2) ==> (t2 ==> t1) ==> (t1 = t2)`` @@ -279,7 +279,7 @@ The timing\index{counting inferences, in HOL proofs@counting inferences, in \HOL of theorems is adjusted as above. -\setcounter{sessioncount}{1} +\setcounter{sessioncount}{0} \begin{session} \begin{alltt} >>__ Globals.linewidth := 60; diff --git a/Manual/Description/tactics.stex b/Manual/Description/tactics.stex index f7ae836620..e7259a3ef7 100644 --- a/Manual/Description/tactics.stex +++ b/Manual/Description/tactics.stex @@ -234,7 +234,7 @@ A simple example from list theory (Section~\ref{sec:list}) illustrates the use of tactics. A conjunctive goal is declared, and \ml{conj\_tac} applied to it: -\setcounter{sessioncount}{1} +\setcounter{sessioncount}{0} \begin{session} \begin{alltt} >> val gl0 = ([]:term list,``(HD[1;2;3] = 1) /\ (TL[1;2;3] = [2;3])``); @@ -1050,7 +1050,7 @@ to a particular tactic, namely \ml{DISCH\_TAC}. $v$ under the assumption $u$, the discharged antecedent. For example, suppose it were required to prove that $(n = 0) \imp (n\times n = n)$: -\setcounter{sessioncount}{1} +\setcounter{sessioncount}{0} \begin{session} \begin{alltt} >> g `(n = 0) ==> (n * n = n)`; @@ -1092,7 +1092,7 @@ The one subgoal therefore has no assumptions on its stack. The two tactics used thus far could be combined into one using the tactical \ml{\gt\gt}:\index{THEN@\ml{THEN}} -\setcounter{sessioncount}{1} +\setcounter{sessioncount}{0} \begin{session} \begin{alltt} >>__ drop() @@ -1111,7 +1111,7 @@ into one using the tactical \ml{\gt\gt}:\index{THEN@\ml{THEN}} \noindent A single tactic can, of course, be written to solve the goal:\footnote{Indeed, the tactic \ml{simp[]} solves the entire goal from the outset.} -\setcounter{sessioncount}{1} +\setcounter{sessioncount}{0} \begin{session} \begin{alltt} >>_ restart(); @@ -1129,7 +1129,7 @@ To accomplish this access in the straightforward way would require some more awkward \index{assumptions!explicit} construct, with explicit assumptions: -\setcounter{sessioncount}{1} +\setcounter{sessioncount}{0} \begin{session} \begin{alltt} >>__ drop(); @@ -1161,7 +1161,7 @@ The tactic $p$ and $q$, respectively, as new assumptions. Simply using \ml{DISCH\_TAC} does not cause the disjunction to split when it becomes an assumption. -\setcounter{sessioncount}{1} +\setcounter{sessioncount}{0} \begin{session} \begin{alltt} >>__ drop() @@ -1231,7 +1231,7 @@ The original example for \ml{pop\_assum} illustrates this: namely, to show that Here, instead of discharging the antecedent by applying \ml{DISCH\_TAC} to the goal, which adds the antecedent as an assumption and returns the consequent as the conclusion, and {\it then\/} supplying the (assumed) added assumption to the theorem continuation \ml{SUBST1\_TAC} and discarding it at the same time, a tactical called \ml{disch\_then} is applied to \ml{SUBST1\_TAC} directly. \ml{disch\_then} transforms \ml{SUBST1\_TAC} into a new tactic: one that applies \ml{SUBST1\_TAC} directly to the (assumed) antecedent, and the resulting tactic to a subgoal with no new assumptions and the consequent as its conclusion: -\setcounter{sessioncount}{1} +\setcounter{sessioncount}{0} \begin{session} \begin{alltt} >>__ drop(); @@ -1259,7 +1259,7 @@ For example, to prove $(0=n) \imp (n \times n = n)$, the result $n=0$ could be reversed immediately: -\setcounter{sessioncount}{1} +\setcounter{sessioncount}{0} \begin{session} \begin{alltt} >>__ drop(); @@ -1284,7 +1284,7 @@ reflected the assumption. On the goal with the disjunctive antecedent, this method again provides a compact tactic: -\setcounter{sessioncount}{1} +\setcounter{sessioncount}{0} \begin{session} \begin{alltt} >>__ drop(); diff --git a/Manual/Makefile b/Manual/Makefile index e823864038..44558befc3 100644 --- a/Manual/Makefile +++ b/Manual/Makefile @@ -5,34 +5,34 @@ default: all clean: - (cd Description; make clean; cd ..) - (cd Tutorial; make clean; cd ..) + (cd Description; Holmake cleanAll; cd ..) + (cd Tutorial; Holmake cleanAll; cd ..) (cd Logic; make clean; cd ..) (cd Reference; make clean; cd ..) (cd Interaction; make clean; cd ..) (cd Quick; make clean; cd ..) -description: - (cd Description; make; cd ..) +Description/description.pdf: + (cd Description; Holmake; cd ..) @echo "====> DESCRIPTION made" -logic: +Logic/logic.pdf: (cd Logic; make; cd ..) @echo "====> LOGIC made" -tutorial: - (cd Tutorial; make; cd ..) +Tutorial/tutorial.pdf: + (cd Tutorial; Holmake; cd ..) @echo "====> TUTORIAL made" -reference: +Reference/reference.pdf: (cd Reference; make; cd ..) @echo "====> REFERENCE made" -interaction: +Interaction/HOL-interaction.pdf: (cd Interaction; make; cd ..) @echo "====> Quick Reference made" -quick: +Quick/quick.pdf: (cd Quick; make; cd ..) @echo "====> Quick Reference made" @@ -40,5 +40,12 @@ quick: # (cd Libraries; make all; cd ..) # @echo "====> LIBRARIES made" +description: Description/description.pdf +logic: Logic/logic.pdf +tutorial: Tutorial/tutorial.pdf +reference: Reference/reference.pdf +interaction: Interaction/HOL-interaction.pdf +quick: Quick/quick.pdf + all: description tutorial logic reference interaction quick @echo "=======> MANUAL made" diff --git a/Manual/Quick/quick.tex b/Manual/Quick/quick.tex index 4f88f2484b..c12c092938 100644 --- a/Manual/Quick/quick.tex +++ b/Manual/Quick/quick.tex @@ -1,8 +1,8 @@ \documentclass[landscape,10pt]{article} \usepackage[landscape,a4paper,left=3mm,right=3mm,noheadfoot]{geometry} -\usepackage[T1]{fontenc} \usepackage{multicol} -\usepackage{helvet} +%\usepackage[T1]{fontenc} +%\usepackage{helvet} \usepackage[colorlinks,pdftitle={HOL Quick Reference}]{hyperref} \usepackage{underscore} % http://www.tex.ac.uk/tex-archive/help/Catalogue/entries/underscore.html From 1e440e6c7cec48d14f1f7cb7507a9fe66374f96f Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 18 Feb 2016 10:57:49 +1100 Subject: [PATCH 699/718] Improve tactics chapter of DESCRIPTION slightly --- Manual/Description/tactics.stex | 29 ++++++++++++++++++----------- 1 file changed, 18 insertions(+), 11 deletions(-) diff --git a/Manual/Description/tactics.stex b/Manual/Description/tactics.stex index e7259a3ef7..590eefbc90 100644 --- a/Manual/Description/tactics.stex +++ b/Manual/Description/tactics.stex @@ -264,8 +264,6 @@ A conjunctive goal is declared, and \ml{conj\_tac} applied to it: decomposition is complete and the proof can be built up in stages. First the theorems achieving the subgoals are proved, then from those, the theorem achieving the original goal: -\vfill -\newpage \begin{session} \begin{alltt} >> val th1 = p1_1[]; @@ -704,7 +702,7 @@ Note that the same end can often be achieved by rewriting with the theorem \ml{E \end{verbatim} \end{holboxed} -\begin{itemize} +\begin{description} \item[Summary:] $\ml{EXISTS\_TAC}\;u$ reduces an existential goal $\exists x.\;t[x]$ to the subgoal $t[u]$. @@ -721,7 +719,7 @@ $t[u]$ \item[Use:] Proving existential goals. -\end{itemize} +\end{description} \index{tactics!list of some|)} \section{Tacticals} @@ -764,7 +762,7 @@ as a curried infix by \begin{hol} \begin{verbatim} - (T1 ORELSE T2) g = T1 g ? T2 g + (T1 ORELSE T2) g = T1 g handle HOL_ERR _ => T2 g \end{verbatim} \end{hol}\index{alternation!of tactics|)} @@ -797,11 +795,12 @@ of tactics, that succeeds. \end{holboxed} -\ml{CHANGED\_TAC\ $T$\ $g$} fails if the subgoals -produced by $T$ are just \ml{[$g$]}; otherwise it is equivalent -to $T\ g$. It is defined by the following, where -{\small\verb%set_equal : * list -> * list -> bool%} tests whether two lists -denote the same set (\ie\ contain the same elements). +\ml{CHANGED\_TAC\ $T$\ $g$} fails if the subgoals produced by $T$ are just \ml{[$g$]}; otherwise it is equivalent to $T\ g$. +It is defined by the following, where +\begin{verbatim} + set_eq: 'a list -> 'a list -> bool +\end{verbatim} +tests whether two lists denote the same set (\ie\ contain the same elements). \begin{hol} @@ -809,7 +808,9 @@ denote the same set (\ie\ contain the same elements). fun CHANGED_TAC tac g = let val (gl,p) = tac g in - if set_eq gl [g] then fail else (gl,p) + if set_eq gl [g] then raise ERR "CHANGED_TAC" "no change" + else (gl,p) + end \end{verbatim} \end{hol} @@ -1171,12 +1172,18 @@ Simply using \ml{DISCH\_TAC} does not cause the disjunction to split when it bec \end{alltt} \end{session} +So, we can combine \ml{pop\_assum} and \ml{DISJ\_CASES\_TAC} to apply the latter to the theorem corresponding to the disjunctive assumption: \begin{session} \begin{alltt} >>_ restart(); >> e(DISCH_TAC >> pop_assum DISJ_CASES_TAC); +\end{alltt} +\end{session} +Indeed, we can then combine this with our earlier use of \ml{SUBST1\_TAC} to have both branches make progress at once: +\begin{session} +\begin{alltt} >>_ restart(); >> e(DISCH_TAC >> pop_assum DISJ_CASES_TAC >> pop_assum SUBST1_TAC); From 54d733eeeaeff95643253cd1a822fddffbc12fad Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 24 Feb 2016 16:11:10 +1100 Subject: [PATCH 700/718] Make Description's system chapter use polyscripter --- Manual/Description/.gitignore | 5 +++-- Manual/Description/Holmakefile | 4 ++++ Manual/Description/{system.tex => system.stex} | 0 3 files changed, 7 insertions(+), 2 deletions(-) rename Manual/Description/{system.tex => system.stex} (100%) diff --git a/Manual/Description/.gitignore b/Manual/Description/.gitignore index eeee7c8cad..0062cea4d8 100644 --- a/Manual/Description/.gitignore +++ b/Manual/Description/.gitignore @@ -1,5 +1,6 @@ drules.tex +HolSat.tex +libraries.tex tactics.tex theories.tex -libraries.tex -HolSat.tex +system.tex diff --git a/Manual/Description/Holmakefile b/Manual/Description/Holmakefile index adc6584645..2be8dca5e5 100644 --- a/Manual/Description/Holmakefile +++ b/Manual/Description/Holmakefile @@ -20,10 +20,14 @@ theories.tex: theories.stex $(PS_STUFF) libraries.tex: libraries.stex $(PS_STUFF) $(PS_COMMAND) +system.tex: system.stex $(PS_STUFF) + $(PS_COMMAND) + HolSat.tex: HolSat.stex $(PS_STUFF) zchaff.cnf $(PS_COMMAND) EXTRA_CLEANS = drules.tex tactics.tex theories.tex libraries.tex HolSat.tex \ + system.tex\ description.pdf \ $(patsubst %,%.aux,$(TEX_CORES)) description.log description.out \ description.toc description.fls description.idx description.ilg \ diff --git a/Manual/Description/system.tex b/Manual/Description/system.stex similarity index 100% rename from Manual/Description/system.tex rename to Manual/Description/system.stex From b647d802bb8fd6b4a3607706e72b7a8405a26dbd Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 24 Feb 2016 16:26:56 +1100 Subject: [PATCH 701/718] Tweak system chapter of DESCRIPTION --- Manual/Description/system.stex | 140 +++++++++++---------------------- 1 file changed, 47 insertions(+), 93 deletions(-) diff --git a/Manual/Description/system.stex b/Manual/Description/system.stex index 5503d17535..8f61e5c880 100644 --- a/Manual/Description/system.stex +++ b/Manual/Description/system.stex @@ -461,11 +461,11 @@ can be used instead of\footnote{In order to be processed successfully, been loaded, which can be accomplished in the interactive system by \ml{load "arithmeticTheory"}.} -\begin{hol} -\begin{verbatim} - let val numty = mk_thy_type{Tyop="num",Thy="num",Args=[]} - in - mk_abs +\setcounter{sessioncount}{0} +\begin{session} +\begin{alltt} +>> val numty = mk_thy_type{Tyop="num",Thy="num",Args=[]} +>> mk_abs (mk_var("x",numty), mk_comb(mk_comb (mk_thy_const @@ -473,10 +473,9 @@ can be used instead of\footnote{In order to be processed successfully, mk_var("x", numty)), mk_comb(mk_thy_const{Name="NUMERAL",Thy="arithmetic",Ty=numty-->numty}, mk_comb(mk_thy_const{Name="BIT1",Thy="arithmetic",Ty=numty-->numty}, - mk_thy_const{Name="ZERO",Thy="arithmetic",Ty=numty})))) - end -\end{verbatim} -\end{hol} + mk_thy_const{Name="ZERO",Thy="arithmetic",Ty=numty})))); +\end{alltt} +\end{session} The \HOL{} printer, which is integrated into the \ML{} toplevel loop, also outputs types and terms using this syntax. @@ -528,39 +527,21 @@ illustrated in the following session. % \setcounter{sessioncount}{0} \begin{session} -\begin{verbatim} -- ``x = (x = 1)``; -Type inference failure: unable to infer a type for the application of - -$= (x :num) - -which has type - -:num -> bool - -to - -(x :num) = (1 :num) - -which has type - -:bool - -unification failure message: unify failed -\end{verbatim} +\begin{alltt} +>>+ ``x = (x = 1)``; +\end{alltt} \end{session} The desired value can be directly constructed by the primitive constructor functions: \begin{session} -\begin{verbatim} -- mk_eq +\begin{alltt} +>> mk_eq (mk_var("x",bool), mk_eq(mk_var("x",numty), - mk_numeral (Arbnum.fromString "1"))); -> val it = ``x <=> (x = 1)`` : term -\end{verbatim} + numSyntax.mk_numeral (Arbnum.fromString "1"))); +\end{alltt} \end{session} The original quotation type checker was designed and implemented by @@ -598,19 +579,10 @@ used in the startup context of \HOL{} has the type operators \verb+num+, \verb+option+, \verb+one+, \verb+label+, \verb+ind+, and \verb+bool+. -\setcounter{sessioncount}{0} \begin{session} -\begin{verbatim} -- type_grammar(); -> val it = - Rules: - (50) TY ::= TY -> TY [fun] (R-associative) - (60) TY ::= TY + TY [sum] (R-associative) - (70) TY ::= TY # TY [prod] (R-associative) - (100) TY ::= TY list | TY recspace | num | (TY, TY)prod | TY option | - one | (TY, TY)sum | label | (TY, TY)fun | ind | bool - : grammar -\end{verbatim} +\begin{alltt} +>> type_grammar(); +\end{alltt} \end{session} Also, \verb+fun+, \verb+sum+, and \verb+prod+ have infix @@ -632,8 +604,8 @@ which bind very tightly. \begin{figure}[htbp] \begin{session} \begin{verbatim} -- term_grammar(); -> val it = +> term_grammar(); +val it = (0) TM ::= "LEAST" <..binders..> "." TM | "?!" <..binders..> "." TM | "?" <..binders..> "." TM | "!" <..binders..> "." TM | "@" <..binders..> "." TM | @@ -698,10 +670,9 @@ explicitly specified. \setcounter{sessioncount}{0} \begin{session} -\begin{verbatim} -- ``prim_rec$< x y`` -> val it = ``x < y`` : term -\end{verbatim} +\begin{alltt} +>> ``prim_rec$< x y`` +\end{alltt} \end{session} Note how the \holtxt{<} symbol is not treated as an infix by the parser when given in ``fully-qualified'' form. Syntactically, such @@ -989,12 +960,12 @@ below). For example, the axiom \ml{BOOL\_CASES\_AX} mentioned in \ml{F} are the \HOL{} logic's constants representing truth and falsity, respectively): -\begin{hol} +\begin{session} \index{F (falsity), the HOL constant@\holtxt{F} (falsity), the \HOL{} constant!axiom for} -\begin{verbatim} - |- !t. (t = T) \/ (t = F) : thm -\end{verbatim} -\end{hol} +\begin{alltt} +>> BOOL_CASES_AX; +\end{alltt} +\end{session} \noindent Note the special print format, @@ -1015,19 +986,13 @@ destructor functions: \setcounter{sessioncount}{0} \begin{session} -\begin{verbatim} - - val th = BOOL_CASES_AX; - > val th = |- !t. (t = T) \/ (t = F) : thm - - - hyp th; - > val it = [] : term list +\begin{alltt} +>> hyp BOOL_CASES_AX; - - concl th; - > val it = ``!t. (t = T) \/ (t = F)`` : term +>> concl BOOL_CASES_AX; - - type_of it; - > val it = ``:bool`` : hol_type -\end{verbatim} +>> type_of it; +\end{alltt} \end{session} \index{turnstile notation|)} @@ -1041,16 +1006,13 @@ theorem inferred, for example purposes, from another axiom mentioned in \LOGIC, \ml{SELECT\_AX}. \begin{session} -\begin{verbatim} -- val th = UNDISCH (SPEC_ALL SELECT_AX); -> val th = [.] |- P ($@ P) : thm +\begin{alltt} +>> val th = UNDISCH (SPEC_ALL SELECT_AX); -- show_assums := true; -> val it = () : unit +>> show_assums := true; -- th; -> val it = [P x] |- P ($@ P) : thm -\end{verbatim} +>> th; +\end{alltt} \end{session} \index{theorem notation, in HOL logic@theorem notation, in \HOL{} logic|)} @@ -1408,13 +1370,11 @@ true. \setcounter{sessioncount}{0} \begin{session} -\begin{verbatim} - - Globals.show_tags := true; - > val it = () : unit +\begin{alltt} +>> Globals.show_tags := true; - - mk_thm([], Term `F`);; - > val it = [oracles: MK_THM] [axioms: ] [] |- F : thm -\end{verbatim} +>> mk_thm([], Term `F`);; +\end{alltt} \end{session}\index{mk_thm@\ml{mk\_thm}} There are three elements to the left of the turnstile in the fully printed @@ -1556,17 +1516,11 @@ of the theory hierarchy. The argument is the name of a theory (or \texttt{ancestry} will respond with a list of the argument's ancestors in the theory hierarchy. -\begin{holboxed} -{\small -\begin{verbatim} - - ancestry "-"; - > val it = - ["num", "prim_rec", "normalForms", "relation", "pair", - "arithmetic", "while", "numeral", "label", "combin", "sum", "min", - "bool", "marker", "one", "option", "ind_type", "list"] : string list -\end{verbatim} -} -\end{holboxed} +\begin{session} +\begin{alltt} +>> ancestry "-"; +\end{alltt} +\end{session} \paragraph{Creating a theory segment} From c8a4b16603c048a26188a866e9252d14c394eb6f Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 24 Feb 2016 17:07:53 +1100 Subject: [PATCH 702/718] Document "abbreviated power simplifier" tactics These are simp, fs, rfs, rw as well as csimp and dsimp. --- Manual/Description/libraries.stex | 38 +++++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+) diff --git a/Manual/Description/libraries.stex b/Manual/Description/libraries.stex index d92911c0cb..5a4127df46 100644 --- a/Manual/Description/libraries.stex +++ b/Manual/Description/libraries.stex @@ -1853,6 +1853,44 @@ rewrites. The latter ``advantage'' is based on the assumption that of unused rewrites is never a concern: the presence of rewrites that do the wrong thing can be a major irritation. +\subsubsection{Abbreviated ``Power'' Tactics} +\HOL{}'s \ml{bossLib} module (part of the standard interactive environment) comes with a number of powerful simplification tactics with short lower-case names. +These do not require or allow for the specification of a particular \simpset{} because they use \ml{srw_ss()} combined with the arithmetic decision procedure for the natural numbers, as well as a \simpset{} fragment that eliminates \holtxt{let}-terms. +All of the tactics take a list of rewrite theorems as their one argument. +These tactics are: + +\begin{center} +\index{simp (simplification tactic)@\ml{simp} (simplification tactic)}% +\index{rw (simplification tactic)@\ml{rw} (simplification tactic)}% +\index{fs (simplification tactic)@ \ml{fs} (simplification tactic)}% +\index{rfs (simplification tactic)@\ml{rfs} (simplification tactic)}% +\begin{tabular}{ll} +\ml{simp} & Corresponds to \ml{ASM\_SIMP\_TAC}\\ +\ml{rw} & Corresponds to \ml{SRW\_TAC[]}\\ +\ml{fs} & Corresponds to \ml{FULL\_SIMP\_TAC}\\ +\ml{rfs} & Corresponds to \ml{REV\_FULL\_SIMP\_TAC} +\end{tabular} +\end{center} +Thus, the following is possible: +\begin{session} +\begin{alltt} +>>_ g `x < 3 /\ P x ==> x < 20 DIV 2`; +>> e (simp[]); +\end{alltt} +\end{session} +In addition, two similar tactics allow special-purpose simplification of propositional structure: +\begin{itemize} +\item% +\index{csimp@\ml{csimp}}% +\ml{csimp} simplifies with \ml{srw\_ss()} and the \ml{CONJ\_ss} \simpset{} fragment. +The latter allows for conjuncts to be used as assumptions when rewriting other conjuncts. +Thus, if simplifying $c_1\land c_2$, $c_2$ will be assumed as a possible source of rewrites while $c_1$ is simplified to $c_1'$. +Then $c_1'$ will be assumed while $c_2$ is simplified. +\item \index{dsimp@\ml{dsimp}}\ml{dsimp} simplifies with \ml{srw\_ss()} and the \ml{DNF\_ss} \simpset{} fragment. +The latter normalises to disjunctive normal form and also moves quantifiers so as to maximise the chance that they can be eliminated over equalities. +When this tactic works well, it can provide a ``pure'' simplification analogue of the repeated stripping and variable elimination done by \ml{rw}. +\end{itemize} + \subsection{The standard \simpset{}s} \label{sec:standard-simpsets} From 43c9d4aed2e30f70b190ea47845a3d213932131a Mon Sep 17 00:00:00 2001 From: Thibault Gauthier Date: Sat, 5 Mar 2016 12:47:11 +0100 Subject: [PATCH 703/718] escaping backslash --- src/holyhammer/hhWriter.sml | 1 + 1 file changed, 1 insertion(+) diff --git a/src/holyhammer/hhWriter.sml b/src/holyhammer/hhWriter.sml index 26e5ce985e..36ae42e4e2 100644 --- a/src/holyhammer/hhWriter.sml +++ b/src/holyhammer/hhWriter.sml @@ -95,6 +95,7 @@ fun hh_escape s = #"#" => String.explode "#hash#" | #"/" => String.explode "#slash#" | #"\"" => String.explode "#quote#" + | #"\\" => String.explode "#bslash#" | #"'" => String.explode "#squote#" | _ => [x] val l2 = map image l1 From cfb96850a381218fde43eec441b09429a094ef77 Mon Sep 17 00:00:00 2001 From: Thibault Gauthier Date: Sat, 5 Mar 2016 13:35:03 +0100 Subject: [PATCH 704/718] holyhammer: README --- src/holyhammer/README | 30 ++++++++++-------------------- 1 file changed, 10 insertions(+), 20 deletions(-) diff --git a/src/holyhammer/README b/src/holyhammer/README index 4559a67474..ea5da4ea68 100644 --- a/src/holyhammer/README +++ b/src/holyhammer/README @@ -18,26 +18,15 @@ Install holyhammer: (done during the build) run Holmake in src/holyhammer/predict run Holmake in src/holyhammer/predict/mepo -Supported provers: Eprover, Z3 (4.0) and (Vampire) +Supported provers: Eprover(1.9), Z3 (4.0) and (Vampire) - They need to be installed manually. Binaries with the appropriate version - have to be fetched from the location cited below. They should be copied - or linked in the directory src/provers. Their names should be respectively - eprover, z3 and vampire. - - Eprover: - Tested with 1.8 and 1.9. Can be fetched from - http://wwwlehre.dhbw-stuttgart.de/~sschulz/E/E.html. - Vampire: - Tested with version 2.6. Parsing may need changing for higher versions. - Waiting for 3.0 to be released at http://www.vprover.org/download.cgi - before adapting the parsing. - Z3: - Tested with 4.0. Higher versions of z3 does not support - tptp input. Can be fetch from http://isabelle.in.tum.de/components/. - CVC4: - Waiting for a good minimization algorithm to be implemented - as it does not output have unsatisfiable cores. + Binaries with the appropriate version should be copied or linked in the directory + src/holyhammer/provers. + Their names should respectively be eprover, z3 and vampire. + + Eprover 1.9 : http://wwwlehre.dhbw-stuttgart.de/~sschulz/E/E.html. + Vampire 2.6: Difficult to obtain. + Z3 4.0 (not 4.4.0): http://isabelle.in.tum.de/components/ . Predictors: @@ -60,4 +49,5 @@ Example: Questions: - If you have any question, you can send an email to thibault_gauthier@hotmail.fr. + If you have any question, you can send an email to thibault_gauthier@hotmail.fr (or + thibault.gauthier@uibk.ac.at) From 41f7773af8386232593274bb182a2645bb801d4a Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Tue, 8 Mar 2016 16:31:08 +1100 Subject: [PATCH 705/718] Get Description Holmake to 'INCLUDE' ../Tools --- Manual/Description/Holmakefile | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Manual/Description/Holmakefile b/Manual/Description/Holmakefile index 2be8dca5e5..e170e230d0 100644 --- a/Manual/Description/Holmakefile +++ b/Manual/Description/Holmakefile @@ -1,3 +1,5 @@ +INCLUDES = ../Tools + TEX_CORES = description title preface system drules tactics theories definitions libraries misc HolSat TEX_SOURCES = ../LaTeX/ack.tex ../LaTeX/commands.tex $(patsubst %,%.tex,$(TEX_CORES)) From e97c16d5904a20b51829bbbe7e33f8600e647e54 Mon Sep 17 00:00:00 2001 From: Thibault Gauthier Date: Thu, 10 Mar 2016 21:22:38 +0100 Subject: [PATCH 706/718] release notes: holyhammer: version number --- doc/kananaskis-11.release.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/doc/kananaskis-11.release.md b/doc/kananaskis-11.release.md index 1623ee9f0b..43e85e9161 100644 --- a/doc/kananaskis-11.release.md +++ b/doc/kananaskis-11.release.md @@ -109,12 +109,12 @@ New tools: - **Holyhammer:** A method for automatically finding relevant theorems for Metis. Given a term, the procedure selects a large number of lemmas through different predictors such as KNN or Mepo. - These lemmas are given to the external provers E-prover, Vampire or Z3. + These lemmas are given to the external provers E-prover(1.9), Vampire(2.6) or Z3(4.0). The necessary lemmas in the provers' proofs are then returned to the user. Modifications to the kernels to track dependencies between theorems allow predictors to learn from the induced relation improving future predictions. The build of the source directory `src/holyhammer` needs ocaml (> 3.12.1) installed as well as a recent version of g++ that supports the C++11 standard. The three ATPs have to be installed independently. - At least one of them should be present, preferably E-prover. + At least one of them should be present, preferably E-prover(1.9). Thanks to Thibault Gauthier for this tool. From 7f0299849cd49e2207683633639914cbe22b60e7 Mon Sep 17 00:00:00 2001 From: Thibault Gauthier Date: Thu, 10 Mar 2016 21:23:55 +0100 Subject: [PATCH 707/718] release notes: holyhammer: version number --- doc/kananaskis-11.release.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/doc/kananaskis-11.release.md b/doc/kananaskis-11.release.md index 43e85e9161..9a2d05d7d0 100644 --- a/doc/kananaskis-11.release.md +++ b/doc/kananaskis-11.release.md @@ -109,12 +109,12 @@ New tools: - **Holyhammer:** A method for automatically finding relevant theorems for Metis. Given a term, the procedure selects a large number of lemmas through different predictors such as KNN or Mepo. - These lemmas are given to the external provers E-prover(1.9), Vampire(2.6) or Z3(4.0). + These lemmas are given to the external provers E-prover (1.9), Vampire (2.6) or Z3 (4.0). The necessary lemmas in the provers' proofs are then returned to the user. Modifications to the kernels to track dependencies between theorems allow predictors to learn from the induced relation improving future predictions. The build of the source directory `src/holyhammer` needs ocaml (> 3.12.1) installed as well as a recent version of g++ that supports the C++11 standard. The three ATPs have to be installed independently. - At least one of them should be present, preferably E-prover(1.9). + At least one of them should be present, preferably E-prover (1.9). Thanks to Thibault Gauthier for this tool. From e298ee6440cc8c2e727f96fcb813515f015bf849 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Thu, 17 Mar 2016 12:38:33 +1100 Subject: [PATCH 708/718] Explain LIST_TO_SET and MEM better in DESCRIPTION --- Manual/Description/theories.stex | 36 ++++++++++++++------------------ Manual/Tools/umap | 1 + 2 files changed, 17 insertions(+), 20 deletions(-) diff --git a/Manual/Description/theories.stex b/Manual/Description/theories.stex index 3e9c38265d..1455cf2aa4 100644 --- a/Manual/Description/theories.stex +++ b/Manual/Description/theories.stex @@ -2616,15 +2616,14 @@ $\holtxt{list\_CASE}\ e_1\ e_2\ (\lambda h\; t.\ e_3)$ where the constant \end{hol} \paragraph{List membership} -\index{MEM, the HOL constant@\ml{MEM}, the \HOL{} constant} +\index{MEM, the HOL notion of list membership@\holtxt{MEM}, the \HOL{} notion of list membership} -Membership in a list, \ml{MEM}, is defined as follows: +Membership in a list, written using the \holtxt{MEM} syntax, is characterised as follows: % \begin{hol} -\begin{verbatim} - MEM |- (!x. MEM x [] = F) /\ - (!x h t. MEM x (h::t) = (x = h) \/ MEM x t) -\end{verbatim} +\begin{alltt} +>> listTheory.MEM; +\end{alltt} \end{hol} \paragraph {Concatenation of lists} @@ -2772,28 +2771,25 @@ counterpart \holtxt{REV} are defined in \theoryimp{list}. \paragraph {Removal of duplicates} The \holtxt{nub} function removes all duplicate entries from a list. \begin{hol} -\begin{verbatim} - nub_DEF - |- (nub [] = []) /\ - (!x l. nub (x::l) = if MEM x l then nub l else x::nub l) -\end{verbatim} +\begin{alltt} +>> listTheory.nub_def; +\end{alltt} \end{hol} \paragraph {Conversion to sets} -Lists can be converted to sets (\ml{LIST\_TO\_SET}) by partial -application of \holtxt{MEM}. The somewhat terse definition is used to -derive the theorem \ml{IN\_LIST\_TO\_SET}. +Lists can be converted to sets with the \holtxt{LIST\_TO\_SET} constant, which is overloaded to the prettier name \holtxt{set}. +The definition is made by primitive recursion in \holtxt{listTheory}: % \begin{hol} -\begin{verbatim} - LIST_TO_SET - |- LIST_TO_SET = combin$C MEM - IN_LIST_TO_SET - |- x IN LIST_TO_SET l = MEM x l -\end{verbatim} +\begin{alltt} +>> listTheory.LIST_TO_SET; +\end{alltt} \end{hol} % +\index{MEM, the HOL notion of list membership@\holtxt{MEM}, the \HOL{} notion of list membership} +Note that \holtxt{MEM} is an overloaded form of syntax such that \holtxt{MEM~x~l} is actually a pretty-printing of the underlying term \holtxt{x~$\in$~set~l}. + Further support for translating between different kinds of collections may be found in the \theoryimp{container} theory. diff --git a/Manual/Tools/umap b/Manual/Tools/umap index 49d8b1ab01..67c64f6b38 100644 --- a/Manual/Tools/umap +++ b/Manual/Tools/umap @@ -24,3 +24,4 @@ ≪ \(<\!\!<\) ⋙ \(>\!\!>\!\!>\) ₊ \({}\sb{+}\) +∅ \(\emptyset\) From 6ffd8b6bb7d6466b77e3116b16c54551696d9449 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 17 Jun 2016 09:37:22 +1000 Subject: [PATCH 709/718] Rename: qcase_tac/rename1; Q.FIND_CASE_TAC/Q.RENAME1_TAC This use of the "case" substring was just confusing given things like Cases_on. The "1" is there because I want to now implement a more general version that - deals with the issue (identified in the .doc file), where existing names in the goal can still get in the way; and - allows multiple subterms to be matched and renamed as a unit Though seemingly independent, the second feature is really needed if the first is to be done: implementing the first will require all the free variables in a goal to be renamed away (to genvars, I expect), and then it's impossible to ground particular matches against known free variables. --- examples/computability/lambda/prtermScript.sml | 2 +- .../context-free/precparserScript.sml | 6 +++--- examples/hfs/hfsScript.sml | 12 ++++++------ .../separationLogic/src/separationLogicScript.sml | 14 +++++++------- .../separationLogic/src/vars_as_resourceScript.sml | 6 +++--- .../{Q.FIND_CASE_TAC.doc => Q.RENAME1_TAC.doc} | 11 ++++------- src/boss/bossLib.sig | 2 +- src/boss/bossLib.sml | 2 +- src/boss/lcsymtacs.sig | 2 +- src/monad/errorStateMonadScript.sml | 14 +++++++------- src/q/Q.sig | 2 +- src/q/Q.sml | 2 +- 12 files changed, 36 insertions(+), 39 deletions(-) rename help/Docfiles/{Q.FIND_CASE_TAC.doc => Q.RENAME1_TAC.doc} (75%) diff --git a/examples/computability/lambda/prtermScript.sml b/examples/computability/lambda/prtermScript.sml index deb5b06dc9..83e36eff84 100644 --- a/examples/computability/lambda/prtermScript.sml +++ b/examples/computability/lambda/prtermScript.sml @@ -1431,7 +1431,7 @@ val recPhi_rec2Phi = store_thm( ``recPhi = rec2 Phi``, simp[FUN_EQ_THM] >> Cases >- simp[recPhi_def, recCn_def, GSYM recPhi_correct] >> - qcase_tac `recPhi (h::rest)` >> Cases_on `rest` >> + rename1 `recPhi (h::rest)` >> Cases_on `rest` >> simp[recPhi_def, recCn_def, GSYM recPhi_correct]) (* the other way - every recursive function can be emulated in the λ-calculus *) diff --git a/examples/formal-languages/context-free/precparserScript.sml b/examples/formal-languages/context-free/precparserScript.sml index a9df866d9f..4df1e9d793 100644 --- a/examples/formal-languages/context-free/precparserScript.sml +++ b/examples/formal-languages/context-free/precparserScript.sml @@ -99,7 +99,7 @@ val wfStk_ignores_hdvalues = store_thm( "wfStk_ignores_hdvalues[simp]", ``wfStk (INL l::t) = wfStk (INL ARB :: t) ∧ wfStk (INR r::t) = wfStk (INR ARB :: t)``, - Cases_on `t` >> simp[] >> qcase_tac `wfStk (INL ARB :: el2 :: tl)` >> + Cases_on `t` >> simp[] >> rename1 `wfStk (INL ARB :: el2 :: tl)` >> Cases_on `el2` >> simp[]); val precparse1_preserves_wfStk = store_thm( @@ -120,8 +120,8 @@ val wfStk_ALT = store_thm( "wfStk_ALT", ``wfStk l ⇔ (l ≠ [] ⇒ ∀opn. LAST l ≠ INL opn) ∧ (∀i. i + 1 < LENGTH l ⇒ ISR (EL i l) ≠ ISR (EL (i + 1) l))``, - Induct_on `l` >> simp[] >> Cases >> simp[] >> qcase_tac `wfStk (_ :: stk)` >> - Cases_on `stk` >> simp[] >> fs[] >> qcase_tac `wfStk (_ :: el2 :: stk)` >> + Induct_on `l` >> simp[] >> Cases >> simp[] >> rename1 `wfStk (_ :: stk)` >> + Cases_on `stk` >> simp[] >> fs[] >> rename1 `wfStk (_ :: el2 :: stk)` >> Cases_on `el2` >> simp[] >- (disj2_tac >> qexists_tac `0` >> simp[]) >> simp[DECIDE ``x + 1 < SUC y ⇔ x < y``] >> dsimp[LT_SUC, DECIDE ``x + 1 = SUC x``]) diff --git a/examples/hfs/hfsScript.sml b/examples/hfs/hfsScript.sml index 34a44d1b87..38ed5274c6 100644 --- a/examples/hfs/hfsScript.sml +++ b/examples/hfs/hfsScript.sml @@ -51,7 +51,7 @@ val numeq_wlog = prove( val strictly_increasing_SUC_extends = prove( ``(∀n. f n < f (n + 1)) ⇒ (∀n m. n < m ⇒ f n < f m)``, strip_tac >> Induct_on `m` >> simp[] >> rpt strip_tac >> - qcase_tac `n < SUC m` >> + rename1 `n < SUC m` >> `n = m ∨ n < m` by simp[] >> simp[arithmeticTheory.ADD1] >> metis_tac [DECIDE ``∀m n p. m < n ⇒ n < p ⇒ m < p``]); @@ -61,14 +61,14 @@ val strictly_increasing_injective = prove( simp[EQ_IMP_THM] >> rpt strip_tac >> qspec_then `λn m. f n = f m` (irule o BETA_RULE) numeq_wlog >> qexists_tac `f` >> simp[] >> spose_not_then strip_assume_tac >> - qcase_tac `¬(n ≤ m)` >> `m < n` by simp[] >> + rename1 `¬(n ≤ m)` >> `m < n` by simp[] >> `f m < f n` by metis_tac [strictly_increasing_SUC_extends] >> metis_tac[DECIDE ``¬(x < x)``]); val strictly_increasing_nobounds = prove( ``(∀n. f n < f (n + 1)) ⇒ ∀b. ∃n. b < f n``, rpt strip_tac >> spose_not_then strip_assume_tac >> - qcase_tac `bnd < f _` >> + rename1 `bnd < f _` >> `∀n. f n ≤ bnd` by metis_tac[DECIDE ``¬(x < y) ⇒ y ≤ x``] >> `∀n m. f n = f m ⇔ n = m` by metis_tac[strictly_increasing_injective] >> `INJ f (count (bnd + 2)) (count (bnd + 1))` @@ -166,7 +166,7 @@ val topdown_induct = prove( `s = M INSERT (s DELETE M)` by metis_tac[INSERT_DELETE] >> qabbrev_tac `s0 = s DELETE M` >> `M ∉ s0 ∧ FINITE s0` by simp[Abbr`s0`] >> - qcase_tac `SUC n = CARD s` >> + rename1 `SUC n = CARD s` >> `CARD s = SUC (CARD s0)` by simp[] >> `n = CARD s0` by simp[] >> `P s0` by metis_tac[] >> @@ -178,9 +178,9 @@ val mk_upper_bound = prove( ``∀s. FINITE s ⇒ ∀b. (∀n. n ∈ s ⇒ n < b) ⇒ mk s < 2 ** b``, ho_match_mp_tac topdown_induct >> dsimp[SUM_IMAGE_THM, DELETE_NON_ELEMENT_RWT] >> rpt strip_tac >> - qcase_tac `e ∉ s` >> + rename1 `e ∉ s` >> `mk s < 2 ** e` by metis_tac[] >> - qcase_tac `e < b` >> + rename1 `e < b` >> `∃d. b = SUC d + e` by metis_tac[arithmeticTheory.LESS_STRONG_ADD] >> simp[arithmeticTheory.EXP_ADD, arithmeticTheory.EXP] >> match_mp_tac arithmeticTheory.LESS_LESS_EQ_TRANS >> diff --git a/examples/separationLogic/src/separationLogicScript.sml b/examples/separationLogic/src/separationLogicScript.sml index 03f76f1be2..f778d823ed 100644 --- a/examples/separationLogic/src/separationLogicScript.sml +++ b/examples/separationLogic/src/separationLogicScript.sml @@ -2269,7 +2269,7 @@ REPEAT STRIP_TAC THEN EQ_TAC THENL [ REPEAT STRIP_TAC THEN - lcsymtacs.qcase_tac `f (SOME s1) (SOME s2) = SOME y` THEN + lcsymtacs.rename1 `f (SOME s1) (SOME s2) = SOME y` THEN Cases_on `R (SOME s1) NONE` THEN ASM_SIMP_TAC std_ss [fasl_star_REWRITE, fasl_order_THM] THEN `~(R (SOME y) NONE)` by METIS_TAC[] THEN @@ -2441,17 +2441,17 @@ SIMP_TAC std_ss [HOARE_TRIPLE_def, fasl_order_THM, ASL_IS_LOCAL_ACTION_def, ASL_IS_SEPARATE_def, IS_SOME_EXISTS, GSYM LEFT_FORALL_IMP_THM] THEN REPEAT STRIP_TAC THEN EQ_TAC THEN REPEAT STRIP_TAC THENL [ FULL_SIMP_TAC std_ss [asl_star_def, IN_ABS, SUBSET_DEF] THEN - lcsymtacs.qcase_tac `SOME s = f (SOME p) (SOME q)` THEN + lcsymtacs.rename1 `SOME s = f (SOME p) (SOME q)` THEN `fasl_order (a s) (fasl_star f (a p) (SOME {q}))` by METIS_TAC[] THEN `?p'. (a p = SOME p') /\ !x. x IN p' ==> x IN Q` by METIS_TAC[] THEN FULL_SIMP_TAC std_ss [fasl_star_REWRITE, fasl_order_THM, asl_star_def, IN_SING, IN_ABS, SUBSET_DEF] THEN METIS_TAC[], - lcsymtacs.qcase_tac `f (SOME s1) (SOME s2) = SOME y` THEN + lcsymtacs.rename1 `f (SOME s1) (SOME s2) = SOME y` THEN Cases_on `a s1` THEN ASM_SIMP_TAC std_ss [fasl_star_REWRITE, fasl_order_THM] THEN - lcsymtacs.qcase_tac `a s1 = SOME xx` THEN + lcsymtacs.rename1 `a s1 = SOME xx` THEN Q.PAT_ASSUM `!P Q. X P Q` (MP_TAC o Q.SPECL [`{s1}`, `xx`]) THEN ASM_SIMP_TAC std_ss [IN_SING, SUBSET_REFL, asl_star_def, IN_ABS, SUBSET_DEF] THEN @@ -2884,7 +2884,7 @@ SIMP_TAC std_ss [ASL_IS_LOCAL_ACTION_def, ASL_IS_SEPARATE_def, fasl_star_def, BIN_OPTION_MAP_ALL_DEF_THM, INF_fasl_order_def] THEN REPEAT STRIP_TAC THEN -lcsymtacs.qcase_tac `f (SOME s1) (SOME s2) = SOME y` THEN +lcsymtacs.rename1 `f (SOME s1) (SOME s2) = SOME y` THEN Cases_on `!s0 s1'. ~(SOME y = f (SOME s0) (SOME s1')) \/ ~(s1' IN P1)` THENL [ ASM_SIMP_TAC std_ss [COND_RAND, COND_RATOR, fasl_order_THM, BIN_OPTION_MAP_ALL_DEF_THM] THEN @@ -5270,8 +5270,8 @@ SIMP_TAC std_ss [fasl_star_REWRITE, fasl_order_THM, asl_star_def, `f (SOME s2) (SOME s1) = f (SOME s1) (SOME s2)` by METIS_TAC[IS_SEPARATION_COMBINATOR_def, COMM_DEF] THEN ASM_SIMP_TAC std_ss [GSYM LEFT_FORALL_IMP_THM] THEN REPEAT STRIP_TAC THEN - lcsymtacs.qcase_tac `la1 s = SOME y` THEN - lcsymtacs.qcase_tac `x IN y` THEN + lcsymtacs.rename1 `la1 s = SOME y` THEN + lcsymtacs.rename1 `x IN y` THEN Q.PAT_ASSUM `!s1 s2 s3 y. P s1 s2 s3 y` ( MP_TAC o Q.SPECL [`s2`, `s1`, `s`, `vq3`, `y`, `x`]) THEN ASM_SIMP_TAC std_ss [GSYM LEFT_FORALL_IMP_THM] THEN diff --git a/examples/separationLogic/src/vars_as_resourceScript.sml b/examples/separationLogic/src/vars_as_resourceScript.sml index 1806a15b1e..c43222eb32 100644 --- a/examples/separationLogic/src/vars_as_resourceScript.sml +++ b/examples/separationLogic/src/vars_as_resourceScript.sml @@ -12619,8 +12619,8 @@ CONJ_TAC THEN1 ( ) THEN REPEAT GEN_TAC THEN STRIP_TAC THEN GEN_TAC THEN STRIP_TAC THEN -lcsymtacs.qcase_tac `asla_report _ n x = SOME s1` THEN -lcsymtacs.qcase_tac `yy IN s1` THEN +lcsymtacs.rename1 `asla_report _ n x = SOME s1` THEN +lcsymtacs.rename1 `yy IN s1` THEN `yy IN P /\ VAR_RES_STACK___IS_EQUAL_UPTO_VALUES (FST x) (FST yy)` by METIS_TAC[] THEN Q.PAT_ASSUM `!x. x IN P ==> X x` (MP_TAC o Q.SPEC `yy`) THEN @@ -13211,7 +13211,7 @@ EQ_TAC THENL [ REPEAT (GEN_TAC ORELSE DISCH_TAC) THEN - lcsymtacs.qcase_tac + lcsymtacs.rename1 `VAR_RES_COMBINATOR f (SOME ss1) (SOME ss2) = SOME xx` THEN Tactical.REVERSE (`MAP (\e. e (FST xx)) el = MAP (\e. e (FST ss1)) el` by ALL_TAC) THEN1 ( diff --git a/help/Docfiles/Q.FIND_CASE_TAC.doc b/help/Docfiles/Q.RENAME1_TAC.doc similarity index 75% rename from help/Docfiles/Q.FIND_CASE_TAC.doc rename to help/Docfiles/Q.RENAME1_TAC.doc index d679dc1b60..1b9b89759a 100644 --- a/help/Docfiles/Q.FIND_CASE_TAC.doc +++ b/help/Docfiles/Q.RENAME1_TAC.doc @@ -1,6 +1,6 @@ \DOC -\TYPE {FIND_CASE_TAC : term quotation -> tactic} +\TYPE {RENAME1_TAC : term quotation -> tactic} \SYNOPSIS Finds an instance of a pattern in a goal, and renames to use names @@ -9,7 +9,7 @@ from the pattern. \KEYWORDS \DESCRIBE -The tactic {Q.FIND_CASE_TAC pat} is defined to be +The tactic {Q.RENAME1_TAC q} is defined to be { MATCH_RENAME_TAC q ORELSE MATCH_ASSUM_RENAME_TAC q ORELSE MATCH_GOALSUB_RENAME_TAC q ORELSE MATCH_ASMSUB_RENAME_TAC q @@ -19,7 +19,6 @@ The tactic {Q.FIND_CASE_TAC pat} is defined to be \FAILURE Fails if all of the constituent tactics fail. - \COMMENTS This tactic can be used to force a particular set of names on a goal, hopefully making the resulting tactic more robust in the face of @@ -27,11 +26,9 @@ underlying implementation changes. Note though that successful use of this tactic requires that the ``new'' names in the provided pattern really be fresh for the goal. If one is really uncertain about what names might be appearing in a goal, this condition may be difficult to -ensure. +ensure, particularly as the tactic only looks for one instance of the pattern at a time (but see {Q.RENAME_TAC}). -The name is derived from the fact that this tactic can be used to -ensure that it is being applied to a particular case in a proof that -has branched. +This tactic is also available under the alias {bossLib.rename1}. \SEEALSO Q.MATCH_ASMSUB_RENAME_TAC, Q.MATCH_ASSUM_RENAME_TAC, Q.MATCH_GOALSUB_RENAME_TAC, Q.MATCH_RENAME_TAC. diff --git a/src/boss/bossLib.sig b/src/boss/bossLib.sig index 2952c0d16d..206f8fd5ac 100644 --- a/src/boss/bossLib.sig +++ b/src/boss/bossLib.sig @@ -157,7 +157,7 @@ sig val qmatch_assum_rename_tac : term quotation -> tactic val qmatch_asmsub_rename_tac : term quotation -> tactic val qmatch_goalsub_rename_tac : term quotation -> tactic - val qcase_tac : term quotation -> tactic + val rename1 : term quotation -> tactic val qabbrev_tac : term quotation -> tactic val qunabbrev_tac : term quotation -> tactic val unabbrev_all_tac : tactic diff --git a/src/boss/bossLib.sml b/src/boss/bossLib.sml index a47b405745..29261aaca4 100644 --- a/src/boss/bossLib.sml +++ b/src/boss/bossLib.sml @@ -212,7 +212,7 @@ val rfs = rfsrw_tac let_arith_list Q.MATCH_ASSUM_RENAME_TAC val qmatch_asmsub_rename_tac = Q.MATCH_ASMSUB_RENAME_TAC val qmatch_goalsub_rename_tac = Q.MATCH_GOALSUB_RENAME_TAC - val qcase_tac = Q.FIND_CASE_TAC + val rename1 = Q.RENAME1_TAC val qabbrev_tac : term quotation -> tactic = Q.ABBREV_TAC val qunabbrev_tac : term quotation -> tactic = Q.UNABBREV_TAC diff --git a/src/boss/lcsymtacs.sig b/src/boss/lcsymtacs.sig index 2f4de3bbd0..231d237296 100644 --- a/src/boss/lcsymtacs.sig +++ b/src/boss/lcsymtacs.sig @@ -55,7 +55,7 @@ sig val qmatch_assum_rename_tac : term quotation -> tactic val qmatch_asmsub_rename_tac : term quotation -> tactic val qmatch_goalsub_rename_tac : term quotation -> tactic - val qcase_tac : term quotation -> tactic + val rename1 : term quotation -> tactic val assume_tac : thm_tactic val strip_assume_tac : thm_tactic diff --git a/src/monad/errorStateMonadScript.sml b/src/monad/errorStateMonadScript.sml index fb03b93d46..64fd949124 100644 --- a/src/monad/errorStateMonadScript.sml +++ b/src/monad/errorStateMonadScript.sml @@ -170,7 +170,7 @@ val BIND_RIGHT_UNIT = store_thm ``!k. BIND k UNIT = k``, SRW_TAC [boolSimps.CONJ_ss] [BIND_DEF, UNIT_DEF, FUN_EQ_THM, option_case_eq, pair_case_eq] THEN - (Q.FIND_CASE_TAC `k v = NONE` ORELSE Q.FIND_CASE_TAC `NONE = k v`) THEN + (Q.RENAME1_TAC `k v = NONE` ORELSE Q.RENAME1_TAC `NONE = k v`) THEN Cases_on `k v` THEN SRW_TAC [][] THEN metisLib.METIS_TAC [TypeBase.nchotomy_of ``:'a # 'b``]); @@ -178,9 +178,9 @@ val BIND_ASSOC = store_thm ("BIND_ASSOC", ``!k m n. BIND k (\a. BIND (m a) n) = BIND (BIND k m) n``, SRW_TAC [][BIND_DEF, FUN_EQ_THM] THEN - Q.FIND_CASE_TAC `option_CASE (k v) NONE _` THEN + Q.RENAME1_TAC `option_CASE (k v) NONE _` THEN Cases_on `k v` THEN SRW_TAC [][] THEN - Q.FIND_CASE_TAC `pair_CASE p _` THEN Cases_on `p` THEN + Q.RENAME1_TAC `pair_CASE p _` THEN Cases_on `p` THEN SRW_TAC [][]); val MMAP_ID = store_thm @@ -257,7 +257,7 @@ val ES_CHOICE_ASSOC = store_thm( "ES_CHOICE_ASSOC", ``ES_CHOICE xM (ES_CHOICE yM zM) = ES_CHOICE (ES_CHOICE xM yM) zM``, SRW_TAC[][FUN_EQ_THM, ES_CHOICE_DEF] THEN - Q.FIND_CASE_TAC `option_CASE (xM s)` THEN Cases_on `xM s` THEN SRW_TAC[][]); + Q.RENAME1_TAC `option_CASE (xM s)` THEN Cases_on `xM s` THEN SRW_TAC[][]); val ES_CHOICE_FAIL_LID = store_thm( "ES_CHOICE_FAIL_LID[simp]", @@ -268,7 +268,7 @@ val ES_CHOICE_FAIL_RID = store_thm( "ES_CHOICE_FAIL_RID[simp]", ``ES_CHOICE xM ES_FAIL = xM``, SRW_TAC[][FUN_EQ_THM, ES_CHOICE_DEF, ES_FAIL_DEF] THEN - Q.FIND_CASE_TAC `option_CASE (xM s)` THEN Cases_on `xM s` THEN SRW_TAC[][]); + Q.RENAME1_TAC `option_CASE (xM s)` THEN Cases_on `xM s` THEN SRW_TAC[][]); val BIND_FAIL = store_thm( "BIND_FAIL_L[simp]", @@ -293,8 +293,8 @@ val IGNORE_BIND_FAIL = store_thm( (IGNORE_BIND xM ES_FAIL = ES_FAIL)``, SRW_TAC[][IGNORE_BIND_DEF] THEN SRW_TAC[][ES_FAIL_DEF, BIND_DEF, FUN_EQ_THM] THEN - Q.FIND_CASE_TAC `option_CASE (xM s)` THEN Cases_on `xM s` THEN - SRW_TAC [][] THEN Q.FIND_CASE_TAC `xM s = SOME rs` THEN Cases_on `rs` THEN + Q.RENAME1_TAC `option_CASE (xM s)` THEN Cases_on `xM s` THEN + SRW_TAC [][] THEN Q.RENAME1_TAC `xM s = SOME rs` THEN Cases_on `rs` THEN SRW_TAC[][]) (* applicative *) diff --git a/src/q/Q.sig b/src/q/Q.sig index 0f69c1d27d..ee13a43071 100644 --- a/src/q/Q.sig +++ b/src/q/Q.sig @@ -63,6 +63,6 @@ sig val MATCH_ASSUM_RENAME_TAC : tmquote -> tactic val MATCH_GOALSUB_RENAME_TAC : tmquote -> tactic val MATCH_ASMSUB_RENAME_TAC : tmquote -> tactic - val FIND_CASE_TAC : tmquote -> tactic + val RENAME1_TAC : tmquote -> tactic end diff --git a/src/q/Q.sml b/src/q/Q.sml index c99ca4efc4..3349989578 100644 --- a/src/q/Q.sml +++ b/src/q/Q.sml @@ -443,7 +443,7 @@ in FIRST_ASSUM (subterm_rename_helper args o concl) g end -fun FIND_CASE_TAC q = +fun RENAME1_TAC q = MATCH_RENAME_TAC q ORELSE MATCH_ASSUM_RENAME_TAC q ORELSE MATCH_GOALSUB_RENAME_TAC q ORELSE MATCH_ASMSUB_RENAME_TAC q From 37b9b33bde95195bcec60f62535c1e575f6f90f7 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 20 Jun 2016 14:37:34 +1000 Subject: [PATCH 710/718] Implement Q.RENAME_TAC / bossLib.rename This tactic is more powerful than rename1 as it allows multiple patterns to be matched at once, and without regard to the initial goal's free variables (which might otherwise cause unpredictable clashes). --- src/boss/bossLib.sig | 1 + src/boss/bossLib.sml | 1 + src/q/Q.sig | 3 ++ src/q/Q.sml | 66 ++++++++++++++++++++++++++++++++++++-------- 4 files changed, 59 insertions(+), 12 deletions(-) diff --git a/src/boss/bossLib.sig b/src/boss/bossLib.sig index 206f8fd5ac..0b87173427 100644 --- a/src/boss/bossLib.sig +++ b/src/boss/bossLib.sig @@ -158,6 +158,7 @@ sig val qmatch_asmsub_rename_tac : term quotation -> tactic val qmatch_goalsub_rename_tac : term quotation -> tactic val rename1 : term quotation -> tactic + val rename : term quotation list -> tactic val qabbrev_tac : term quotation -> tactic val qunabbrev_tac : term quotation -> tactic val unabbrev_all_tac : tactic diff --git a/src/boss/bossLib.sml b/src/boss/bossLib.sml index 29261aaca4..667cd60da4 100644 --- a/src/boss/bossLib.sml +++ b/src/boss/bossLib.sml @@ -213,6 +213,7 @@ val rfs = rfsrw_tac let_arith_list val qmatch_asmsub_rename_tac = Q.MATCH_ASMSUB_RENAME_TAC val qmatch_goalsub_rename_tac = Q.MATCH_GOALSUB_RENAME_TAC val rename1 = Q.RENAME1_TAC + val rename = Q.RENAME_TAC val qabbrev_tac : term quotation -> tactic = Q.ABBREV_TAC val qunabbrev_tac : term quotation -> tactic = Q.UNABBREV_TAC diff --git a/src/q/Q.sig b/src/q/Q.sig index ee13a43071..91aef013ad 100644 --- a/src/q/Q.sig +++ b/src/q/Q.sig @@ -64,5 +64,8 @@ sig val MATCH_GOALSUB_RENAME_TAC : tmquote -> tactic val MATCH_ASMSUB_RENAME_TAC : tmquote -> tactic val RENAME1_TAC : tmquote -> tactic + val RENAME_TAC : tmquote list -> tactic + val kRENAME_TAC : tmquote list -> tactic -> tactic + val coreRENAME_TAC : tmquote list -> tactic -> tactic end diff --git a/src/q/Q.sml b/src/q/Q.sml index 3349989578..4b61ee566b 100644 --- a/src/q/Q.sml +++ b/src/q/Q.sml @@ -389,19 +389,23 @@ in t end g -fun MATCH_ASSUM_RENAME_TAC q (g as (asl,t)) = let +fun kMATCH_ASSUM_RENAME_TAC q k (g as (asl,t)) = let val fvs = free_varsl(t::asl) val pat = Parse.parse_in_context fvs q in - FIRST_ASSUM (wholeterm_rename_helper {pat=pat, ERR = ERR "MATCH_ASSUM_RENAME_TAC", - fvs_set = HOLset.fromList Term.compare fvs} o - concl) + FIRST_ASSUM (fn th => + wholeterm_rename_helper + {pat=pat, ERR = ERR "MATCH_ASSUM_RENAME_TAC", + fvs_set = HOLset.fromList Term.compare fvs} + (concl th) THEN k) end g +fun MATCH_ASSUM_RENAME_TAC q = kMATCH_ASSUM_RENAME_TAC q ALL_TAC + (* needs to be eta-expanded so that the possible HOL_ERRs are raised when applied to a goal, not before, thereby letting FIRST_ASSUM catch the exception *) -fun subterm_rename_helper {thetasz,ERR,pat,fvs_set} t g = let +fun subterm_rename_helper k {thetasz,ERR,pat,fvs_set} t g = let fun test (bvs, subt) = case Lib.total (fn t => raw_match [] fvs_set pat t ([],[])) subt of SOME ((theta0, _), (tytheta,_)) => @@ -413,14 +417,15 @@ fun subterm_rename_helper {thetasz,ERR,pat,fvs_set} t g = let theta0 val theta = map (redex_map (inst tytheta)) theta0 in - if length theta <> thetasz then NONE else SOME theta + if length theta <> thetasz then NONE + else Lib.total (make_rename_tac theta THEN k) g end | NONE => NONE in case gen_find_term test t of - SOME theta => make_rename_tac theta + SOME tacresult => tacresult | NONE => raise ERR "No matching sub-term found" -end g +end fun prep_rename q nm (asl, t) = let val ERR = ERR nm @@ -434,17 +439,54 @@ in {ERR = ERR, pat = pat, fvs_set = fvs_set, thetasz = length pat_binds} end -fun MATCH_GOALSUB_RENAME_TAC q (g as (asl, t)) = - subterm_rename_helper (prep_rename q "MATCH_GOALSUB_RENAME_TAC" g) t g +fun kMATCH_GOALSUB_RENAME_TAC q k (g as (asl, t)) = + subterm_rename_helper k (prep_rename q "MATCH_GOALSUB_RENAME_TAC" g) t g + +fun MATCH_GOALSUB_RENAME_TAC q = kMATCH_GOALSUB_RENAME_TAC q ALL_TAC -fun MATCH_ASMSUB_RENAME_TAC q (g as (asl, t)) = let +fun kMATCH_ASMSUB_RENAME_TAC q k (g as (asl, t)) = let val args = prep_rename q "MATCH_ASMSUB_RENAME_TAC" g in - FIRST_ASSUM (subterm_rename_helper args o concl) g + FIRST_ASSUM (subterm_rename_helper k args o concl) g end +fun MATCH_ASMSUB_RENAME_TAC q = kMATCH_ASMSUB_RENAME_TAC q ALL_TAC + fun RENAME1_TAC q = MATCH_RENAME_TAC q ORELSE MATCH_ASSUM_RENAME_TAC q ORELSE MATCH_GOALSUB_RENAME_TAC q ORELSE MATCH_ASMSUB_RENAME_TAC q +fun coreRENAME_TAC qs k = + let + fun kRENAME1 q k = + (MATCH_RENAME_TAC q THEN k) ORELSE kMATCH_ASSUM_RENAME_TAC q k ORELSE + kMATCH_GOALSUB_RENAME_TAC q k ORELSE kMATCH_ASMSUB_RENAME_TAC q k + fun recurse qs = + case qs of + [] => k + | q::rest => kRENAME1 q (recurse rest) + in + recurse qs + end + +fun flip_inst s = map (fn {redex,residue} => {redex=residue,residue=redex}) s + +fun gvarify (goal as (asl,w)) = + let + fun gentheta (v, acc) = {residue = v, redex = genvar (type_of v)} :: acc + in + HOLset.foldl gentheta [] (FVL (w::asl) empty_tmset) + end + +fun kRENAME_TAC qs k g = + let + val gsig = gvarify g + val gsig_inv = flip_inst gsig + in + make_rename_tac gsig THEN + coreRENAME_TAC qs (make_rename_tac gsig_inv THEN k) + end g + +fun RENAME_TAC qs = kRENAME_TAC qs ALL_TAC + end (* Q *) From 53375a5c2a287e77d9a52d7406f5ebbbf3dbe9d1 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 20 Jun 2016 14:39:21 +1000 Subject: [PATCH 711/718] Document Q.RENAME_TAC --- help/Docfiles/Q.RENAME_TAC.doc | 79 ++++++++++++++++++++++++++++++++++ 1 file changed, 79 insertions(+) create mode 100644 help/Docfiles/Q.RENAME_TAC.doc diff --git a/help/Docfiles/Q.RENAME_TAC.doc b/help/Docfiles/Q.RENAME_TAC.doc new file mode 100644 index 0000000000..8407331c39 --- /dev/null +++ b/help/Docfiles/Q.RENAME_TAC.doc @@ -0,0 +1,79 @@ +\DOC + +\TYPE {RENAME_TAC : term quotation list -> tactic} + +\SYNOPSIS +Renames free variables or subterms within a goal. + +\KEYWORDS + +\DESCRIBE +A call to {RENAME_TAC qs} searches the current goal for matches to the +patterns in the list {qs}, and then substitutes out the matches (in +the ``reverse direction'') so that the goal becomes one that uses the +names from {qs}. This can cause subterms within the goal to turn into +simple variables, but the usual intention is to rename free variables +into the variables that appear in the patterns. + +The matching is done without reference to the goal's existing free +variables. If a variable in {qs} clashes with an existing variable in +the goal, then the goal's variable will be renamed away. The search +for matches begins by attempting to find matches against the whole of +the goal, against whole assumptions, for sub-terms within the goal, +and then sub-terms of assumptions. If multiple matches are possible, a +variant {Q.kRENAME_TAC} takes a ``continuation'' tactic that can be +used to discriminate between these matches. + +Patterns can use underscores to match anything without any change in +the goal's naming being introduced. Underscores can match against +sub-terms that include bound variables. Matching is first-order. + +\FAILURE +Fails if it is impossible to consistently match the combination of +patterns in the provided list of quotations ({qs}). + +\EXAMPLE +If the goal is of the form +{ + x < y, y < z ?- x < f a +} +then invoking {Q.RENAME_TAC [`b < c`, `a < b`]} will produce the sub-goal: +{ + a < b, b < c ?- a < f a' +} +where the goal's original {a} variable (which is not even of type +{num}), has been renamed away from {a} as that variable occurs in the +patterns. (If the right hand side of the inequality was simply {a} and +was thus of type num, it would also be renamed to {a'}.) + +If {Q.RENAME_TAC [`b < c`]} is invoked on the same initial goal, the result is: +{ + b < y, y < z ?- b < c +} +illustrating the way in which variables can eliminate more complicated sub-terms. + +The useful way in which underscores in patterns can be used to ``dodge'' terms including bound variables is illustrated in the next example, where the initial goal is: +{ + (!a. f a < z), z < c ?- z < d +} +After applying {Q.RENAME_TAC [`_ < x`, `x < c`]}, the goal becomes +{ + (!a. f a < x), x < c' ?- x < c +} +The goal was chosen for the match to the second pattern because the goal is considered first. If the initial goal had been +{ + (!a. f a < z), z < c ?- z < d /\ P z +} +then the result of the same application would be +{ + (!a. f a < z), z < c ?- x < d /\ P x +} +because whole assumptions are considered before sub-terms of the goal. + +\COMMENT +This function is also available under the name {bossLib.rename}. + +\SEEALSO +Q.RENAME1_TAC. + +\ENDDOC From 4ad0233a71ef1004e37162494997cd46ff4d190c Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Mon, 20 Jun 2016 15:08:08 +1000 Subject: [PATCH 712/718] Fix typo in Q.RENAME_TAC documentation file --- help/Docfiles/Q.RENAME_TAC.doc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/help/Docfiles/Q.RENAME_TAC.doc b/help/Docfiles/Q.RENAME_TAC.doc index 8407331c39..63c2f0d605 100644 --- a/help/Docfiles/Q.RENAME_TAC.doc +++ b/help/Docfiles/Q.RENAME_TAC.doc @@ -70,7 +70,7 @@ then the result of the same application would be } because whole assumptions are considered before sub-terms of the goal. -\COMMENT +\COMMENTS This function is also available under the name {bossLib.rename}. \SEEALSO From a1e07ed5c0f82bf8b14537a5a8b5087b393ce393 Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 22 Jun 2016 10:05:00 +1000 Subject: [PATCH 713/718] Allow for emphasis in .doc files by using *-delimiters --- help/src-sml/Doc2Html.sml | 2 ++ help/src-sml/Doc2Tex.sml | 2 ++ help/src-sml/Doc2Txt.sml | 2 ++ help/src-sml/ParseDoc.sig | 1 + help/src-sml/ParseDoc.sml | 51 ++++++++++++++++++++++++++++++--------- 5 files changed, 47 insertions(+), 11 deletions(-) diff --git a/help/src-sml/Doc2Html.sml b/help/src-sml/Doc2Html.sml index a4d9f8300a..27b626c04d 100644 --- a/help/src-sml/Doc2Html.sml +++ b/help/src-sml/Doc2Html.sml @@ -88,6 +88,8 @@ fun html (name,sectionl) ostrm = (out ""; out (text_encode ss); out "") + | markout (EMPH ss) = + out ("" ^ text_encode ss ^ "") | markout (BRKT ss) = (out ""; out (bracket_trans ss); diff --git a/help/src-sml/Doc2Tex.sml b/help/src-sml/Doc2Tex.sml index dc7bfe55d3..93ed6a1259 100644 --- a/help/src-sml/Doc2Tex.sml +++ b/help/src-sml/Doc2Tex.sml @@ -61,6 +61,8 @@ fun print_markup(m, ostr) = case m of PARA => out(ostr, "\n\n") | TEXT ss => out(ostr, lastminute_fixes (Substring.string ss)) + | EMPH ss => out(ostr, + "\\emph{" ^ lastminute_fixes (Substring.string ss) ^ "}") | BRKT ss => print_verb1(ss, ostr) | XMPL ss => print_verbblock(ss, ostr) diff --git a/help/src-sml/Doc2Txt.sml b/help/src-sml/Doc2Txt.sml index c04049e4b2..a5479906c2 100644 --- a/help/src-sml/Doc2Txt.sml +++ b/help/src-sml/Doc2Txt.sml @@ -83,6 +83,8 @@ fun print_markups strm mlist = PARA => (out(strm, "\n\n"); print_markups strm ms) | TEXT ss => (out(strm, text_encode ss); print_markups strm ms) + | EMPH ss => (out(strm, "*" ^ text_encode ss ^ "*"); + print_markups strm ms) | BRKT ss => (out(strm, "{" ^ Substring.string ss ^ "}"); print_markups strm ms) | XMPL ss => (out(strm, Substring.string ss); diff --git a/help/src-sml/ParseDoc.sig b/help/src-sml/ParseDoc.sig index c15bc69559..f8a3a67ba1 100644 --- a/help/src-sml/ParseDoc.sig +++ b/help/src-sml/ParseDoc.sig @@ -6,6 +6,7 @@ sig datatype markup = PARA | TEXT of substring | BRKT of substring + | EMPH of substring | XMPL of substring datatype section = TYPE of substring diff --git a/help/src-sml/ParseDoc.sml b/help/src-sml/ParseDoc.sml index 5c2f968113..453f9238c9 100644 --- a/help/src-sml/ParseDoc.sml +++ b/help/src-sml/ParseDoc.sml @@ -51,6 +51,7 @@ datatype markup = PARA | TEXT of substring | BRKT of substring + | EMPH of substring | XMPL of substring; datatype section @@ -142,18 +143,46 @@ in recurse ss 0 end +fun stars ss = + let + fun recurse acc ss = + case getc ss of + SOME (#"*", ss1) => SOME (String.implode (List.rev acc), ss1) + | SOME (#"\\", ss1) => escapedchar acc ss1 + | SOME (c, ss1) => recurse (c::acc) ss1 + | NONE => NONE + and escapedchar acc ss = + case getc ss of + SOME (#"*", ss1) => recurse (#"*" :: acc) ss1 + | SOME (#"\\", ss1) => recurse (#"\\" :: acc) ss1 + | _ => raise ParseError "Strange backslash in normal text" + in + recurse [] ss + end + + fun markup ss = - let val (ssa,ssb) = position "{" ss - in if isEmpty ssb then [TEXT ss] - else let val ssc = braces ssb - val (s,i,n) = base ssa - val (_,j,_) = base ssc - val chunk = substring (s,i+n+1,j-(i+n+2)) - in TEXT ssa - :: (if occurs "\n" chunk then XMPL chunk else BRKT chunk) - :: markup ssc - end - end; + case CharVector.findi (fn (_,c) => c = #"*" orelse c = #"{") (string ss) of + NONE => [TEXT ss] + | SOME (i, #"{") => + let + val (ssa,ssb) = splitAt(ss,i) + val ssc = braces ssb + val (s,i,n) = base ssa + val (_,j,_) = base ssc + val chunk = substring (s,i+n+1,j-(i+n+2)) + in TEXT ssa + :: (if occurs "\n" chunk then XMPL chunk else BRKT chunk) + :: markup ssc + end + | SOME (i, _) => + let + val (ssa,ssb) = splitAt(ss,i) + in + case stars (slice(ssb,1,NONE)) of + NONE => [TEXT ss] + | SOME (s, rest) => TEXT ssa :: EMPH (full s) :: markup rest + end val paragraphs = let fun para (TEXT ss) = From 714c6bb9b156940338135d37131ca42bcd9e5c3a Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Wed, 22 Jun 2016 10:05:52 +1000 Subject: [PATCH 714/718] Improve documentation of Q.RENAME_TAC In particular, point out that the behaviour with a singleton list is different to Q.RENAME1_TAC applied to the single element. --- help/Docfiles/Q.RENAME_TAC.doc | 24 +++++++++++++++++------- 1 file changed, 17 insertions(+), 7 deletions(-) diff --git a/help/Docfiles/Q.RENAME_TAC.doc b/help/Docfiles/Q.RENAME_TAC.doc index 63c2f0d605..46cf9754ff 100644 --- a/help/Docfiles/Q.RENAME_TAC.doc +++ b/help/Docfiles/Q.RENAME_TAC.doc @@ -17,12 +17,15 @@ into the variables that appear in the patterns. The matching is done without reference to the goal's existing free variables. If a variable in {qs} clashes with an existing variable in -the goal, then the goal's variable will be renamed away. The search -for matches begins by attempting to find matches against the whole of -the goal, against whole assumptions, for sub-terms within the goal, -and then sub-terms of assumptions. If multiple matches are possible, a -variant {Q.kRENAME_TAC} takes a ``continuation'' tactic that can be -used to discriminate between these matches. +the goal, then the goal's variable will be renamed away. It is +sufficient for variables to have the same name to ``clash''; they need +not also have the same type. The search for matches begins by +attempting to find matches against the whole of the goal, against +whole assumptions, for sub-terms within the goal, and then sub-terms +of assumptions. If multiple matches are possible, a variant tactic, +{Q.kRENAME_TAC}, can be used: this tactic takes an additional +``continuation'' tactic argument that can be used to discriminate +between these matches. Patterns can use underscores to match anything without any change in the goal's naming being introduced. Underscores can match against @@ -42,7 +45,7 @@ then invoking {Q.RENAME_TAC [`b < c`, `a < b`]} will produce the sub-goal: a < b, b < c ?- a < f a' } where the goal's original {a} variable (which is not even of type -{num}), has been renamed away from {a} as that variable occurs in the +{num}), has been renamed away from {a} because that variable occurs in the patterns. (If the right hand side of the inequality was simply {a} and was thus of type num, it would also be renamed to {a'}.) @@ -73,6 +76,13 @@ because whole assumptions are considered before sub-terms of the goal. \COMMENTS This function is also available under the name {bossLib.rename}. +Note that {Q.RENAME_TAC [q]} is *not* the same as {Q.RENAME1_TAC q}. +The latter pays attention to the goal's free variables, using these to +constrain the match to the pattern. In contrast, {Q.RENAME_TAC} +completely ignores all of the goal's free variables, such that using +an existing name in a pattern doesn't make any difference to the +matching behaviour. + \SEEALSO Q.RENAME1_TAC. From 606ed51b37b867724fabe29c477b44bbb6c5cdbf Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 3 Mar 2017 09:55:14 +1100 Subject: [PATCH 715/718] Update hol4 template for Developer markdown "manual" --- Manual/Developers/hol4.latex | 3 +++ 1 file changed, 3 insertions(+) diff --git a/Manual/Developers/hol4.latex b/Manual/Developers/hol4.latex index 0d7e95e4d8..7947d73d90 100644 --- a/Manual/Developers/hol4.latex +++ b/Manual/Developers/hol4.latex @@ -142,6 +142,9 @@ $for(header-includes)$ $header-includes$ $endfor$ +\providecommand{\tightlist}{% + \setlength{\itemsep}{0pt}\setlength{\parskip}{0pt}} + \begin{document} $if(title)$ \maketitle From 025cdb0f52598ea113cdc7f04fe8bed1c6e8281f Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 3 Mar 2017 10:06:13 +1100 Subject: [PATCH 716/718] Provide slightly better error message when dot doesn't work --- help/src-sml/DOT | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/help/src-sml/DOT b/help/src-sml/DOT index 88232c9b3b..2a51df221a 100644 --- a/help/src-sml/DOT +++ b/help/src-sml/DOT @@ -30,6 +30,11 @@ val _ = HOL_Interactive.toggle_quietdec(); +fun die s = + (TextIO.output(TextIO.stdErr, s ^ "\n"); + TextIO.flushOut TextIO.stdErr; + OS.Process.exit OS.Process.failure) + val HTML_DIR = Path.toString(Path.fromString(Path.concat (Globals.HOLDIR,"help/theorygraph"))); val SIGOBJ_DIR = Path.toString(Path.fromString(Path.concat @@ -225,5 +230,8 @@ val _ = print " done\n"; (* The following works on Unix with dot version 1.10.2003xxxxxxx *) - -gen_map_file DOTPATH ancs (Path.concat(HTML_DIR, "theories")); +gen_map_file DOTPATH ancs (Path.concat(HTML_DIR, "theories")) + handle _ => + die ("Failed to call gen_map_file on dot="^DOTPATH^" targeting "^ + Path.concat(HTML_DIR, "theories")) +; From 06603de9440c0cd9b4eb4e7104b728ede02e2d2a Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 3 Mar 2017 10:24:12 +1100 Subject: [PATCH 717/718] Avoid generating intermediate .tex file in Developers Manual --- Manual/Developers/Makefile | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/Manual/Developers/Makefile b/Manual/Developers/Makefile index d777aa710b..85bada5a07 100644 --- a/Manual/Developers/Makefile +++ b/Manual/Developers/Makefile @@ -4,11 +4,8 @@ TARGETS = developers.pdf developers.html all: $(TARGETS) -developers.pdf: developers.tex - latexmk -pdf developers - -developers.tex: developers.md - pandoc -s --template=hol4 $< -o $@ +developers.pdf: developers.md + pandoc --template=hol4 $< -o $@ developers.html: developers.md pandoc -s $< -o $@ From 962a079ccaabcb928855a338793dd1c5be01526e Mon Sep 17 00:00:00 2001 From: Michael Norrish Date: Fri, 3 Mar 2017 10:39:21 +1100 Subject: [PATCH 718/718] Put release date into release notes --- doc/kananaskis-11.release.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/kananaskis-11.release.md b/doc/kananaskis-11.release.md index 9a2d05d7d0..b64644a0bf 100644 --- a/doc/kananaskis-11.release.md +++ b/doc/kananaskis-11.release.md @@ -3,7 +3,7 @@ -(Released: ??????) +(Released: 3 March 2017) We are pleased to announce the Kananaskis-11 release of HOL 4.